JehanneOS
/
newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
newlib/winsup/utils/dumper.cc

755 lines
18 KiB
C++
Raw Blame History

/* dumper.cc
Copyright 1999 Cygnus Solutions.
Written by Egor Duda <deo@logos-m.ru>
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#include <bfd.h>
#include <elf/common.h>
#include <elf/external.h>
#include <sys/procfs.h>
#include <sys/cygwin.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <windows.h>
#include "dumper.h"
#define NOTE_NAME_SIZE 16
typedef struct _note_header
{
Elf_External_Note elf_note_header;
char name [ NOTE_NAME_SIZE - 1 ]; /* external note contains first byte of data */
}
#ifdef __GNUC__
__attribute__ ((packed))
#endif
note_header ;
BOOL verbose = FALSE;
int deb_printf ( const char* format, ... )
{
if ( !verbose ) return 0;
va_list va;
va_start ( va, format );
int ret_val = vprintf ( format, va );
va_end ( va );
return ret_val;
}
dumper::dumper ( DWORD pid, DWORD tid, const char* file_name )
{
this->file_name = strdup ( file_name );
this->pid = pid;
this->tid = tid;
core_bfd = NULL;
excl_list = new exclusion ( 20 );
list = last = NULL;
status_section = NULL;
memory_num = module_num = thread_num = 0;
hProcess = OpenProcess ( PROCESS_ALL_ACCESS,
FALSE, /* no inheritance */
pid );
if ( !hProcess )
{
fprintf ( stderr, "Failed to open process #%lu\n", pid );
return;
}
init_core_dump ();
if ( ! sane () ) dumper_abort ();
}
dumper::~dumper ()
{
close ();
free ( file_name );
}
void
dumper::dumper_abort ()
{
close ();
unlink ( file_name );
}
void
dumper::close ()
{
if ( core_bfd ) bfd_close ( core_bfd );
if ( excl_list ) delete excl_list;
if ( hProcess ) CloseHandle ( hProcess );
core_bfd = NULL;
hProcess = NULL;
excl_list = NULL;
}
int
dumper::sane ()
{
if ( hProcess == NULL || core_bfd == NULL || excl_list == NULL ) return 0;
return 1;
}
process_entity*
dumper::add_process_entity_to_list ( process_entity_type type )
{
if ( ! sane () ) return NULL;
process_entity* new_entity = ( process_entity* ) malloc ( sizeof ( process_entity ) );
if ( new_entity == NULL ) return NULL;
new_entity->next = NULL;
new_entity->section = NULL;
if ( last == NULL )
list = new_entity;
else
last->next = new_entity;
last = new_entity;
return new_entity;
}
int
dumper::add_thread ( DWORD tid, HANDLE hThread )
{
if ( ! sane () ) return 0 ;
CONTEXT* pcontext;
process_entity* new_entity = add_process_entity_to_list ( pr_ent_thread );
if ( new_entity == NULL ) return 0;
new_entity->type = pr_ent_thread;
thread_num++;
new_entity->u.thread.tid = tid;
new_entity->u.thread.hThread = hThread;
pcontext = &( new_entity->u.thread.context );
pcontext->ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT;
if ( ! GetThreadContext ( hThread, pcontext ) ) return 0;
deb_printf ( "added thread %u\n", tid );
return 1;
}
int
dumper::add_mem_region ( LPBYTE base, DWORD size )
{
if ( ! sane () ) return 0;
if ( base == NULL || size == 0 ) return 1; // just ignore empty regions
process_entity* new_entity = add_process_entity_to_list ( pr_ent_memory );
if ( new_entity == NULL ) return 0;
new_entity->type = pr_ent_memory;
memory_num++;
new_entity->u.memory.base = base;
new_entity->u.memory.size = size;
deb_printf ( "added memory region %08x-%08x\n", (DWORD)base, (DWORD)base + size );
return 1;
}
/*
* split_add_mem_region scans list of regions to be excluded from dumping process
* (excl_list) and removes all "excluded" parts from given region
*/
int
dumper::split_add_mem_region ( LPBYTE base, DWORD size )
{
if ( ! sane () ) return 0;
if ( base == NULL || size == 0 ) return 1; // just ignore empty regions
LPBYTE last_base = base;
for ( process_mem_region* p = excl_list->region;
p < excl_list->region + excl_list->last;
p++ )
{
if ( p->base >= base + size || p->base + p->size <= base ) continue;
if ( p->base <= base )
{
last_base = p->base + p->size;
continue ;
}
add_mem_region ( last_base, p->base - last_base );
last_base = p->base + p->size;
}
if ( last_base < base + size )
add_mem_region ( last_base, base + size - last_base );
return 1;
}
int
dumper::add_module ( LPVOID base_address )
{
if ( ! sane () ) return 0;
char* module_name = psapi_get_module_name ( hProcess, (DWORD) base_address );
if ( module_name == NULL ) return 1;
process_entity* new_entity = add_process_entity_to_list ( pr_ent_module );
if ( new_entity == NULL ) return 0;
new_entity->type = pr_ent_module;
module_num++;
new_entity->u.module.base_address = base_address;
new_entity->u.module.name = module_name;
parse_pe ( module_name, excl_list );
deb_printf ( "added module %08x %s\n", base_address, module_name );
return 1;
}
#define PAGE_BUFFER_SIZE 4096
int
dumper::collect_memory_sections ()
{
if ( ! sane () ) return 0;
LPBYTE current_page_address;
LPBYTE last_base = (LPBYTE) 0xFFFFFFFF;
DWORD last_size = 0;
DWORD done;
char mem_buf [ PAGE_BUFFER_SIZE ];
MEMORY_BASIC_INFORMATION mbi;
if ( hProcess == NULL ) return 0;
for ( current_page_address = 0; current_page_address < (LPBYTE) 0xFFFF0000; )
{
if ( ! VirtualQueryEx ( hProcess, current_page_address, &mbi, sizeof ( mbi ) ) )
break ;
int skip_region_p = 0;
if ( mbi.Protect & ( PAGE_NOACCESS | PAGE_GUARD ) ||
mbi.State != MEM_COMMIT ) skip_region_p = 1;
if ( ! skip_region_p )
{
/* just to make sure that later we'll be able to read it.
According to MS docs either region is all-readable or
all-nonreadable */
if ( ! ReadProcessMemory ( hProcess, current_page_address, mem_buf, sizeof ( mem_buf ), &done ) )
{
const char* pt[10] ;
pt[0] = ( mbi.Protect & PAGE_READONLY ) ? "RO " : "";
pt[1] = ( mbi.Protect & PAGE_READWRITE ) ? "RW " : "";
pt[2] = ( mbi.Protect & PAGE_WRITECOPY ) ? "WC " : "";
pt[3] = ( mbi.Protect & PAGE_EXECUTE ) ? "EX " : "";
pt[4] = ( mbi.Protect & PAGE_EXECUTE_READ ) ? "EXRO " : "";
pt[5] = ( mbi.Protect & PAGE_EXECUTE_READWRITE ) ? "EXRW " : "";
pt[6] = ( mbi.Protect & PAGE_EXECUTE_WRITECOPY ) ? "EXWC " : "";
pt[7] = ( mbi.Protect & PAGE_GUARD ) ? "GRD " : "";
pt[8] = ( mbi.Protect & PAGE_NOACCESS ) ? "NA " : "";
pt[9] = ( mbi.Protect & PAGE_NOCACHE ) ? "NC " : "";
char buf [ 10*6 ] ;
buf [ 0 ] = '\0';
for ( int i = 0 ; i < 10 ; i++ ) strcat ( buf, pt[i] );
deb_printf ( "warning: failed to read memory at %08x-%08x. protect = %s\n",
(DWORD)current_page_address,
(DWORD)current_page_address + mbi.RegionSize,
buf );
skip_region_p = 1;
}
}
if ( ! skip_region_p )
{
if ( last_base + last_size == current_page_address )
last_size += mbi.RegionSize;
else
{
split_add_mem_region ( last_base, last_size );
last_base = (LPBYTE) mbi.BaseAddress;
last_size = mbi.RegionSize;
}
}
else
{
split_add_mem_region ( last_base, last_size );
last_base = NULL;
last_size = 0;
}
current_page_address += mbi.RegionSize;
}
/* dump last sections, if any */
split_add_mem_region ( last_base, last_size );
return 1;
};
int
dumper::dump_memory_region ( asection* to, process_mem_region* memory )
{
if ( ! sane () ) return 0;
DWORD size = memory->size;
DWORD todo;
DWORD done;
LPBYTE pos = memory->base;
DWORD sect_pos = 0;
if ( to == NULL || memory == NULL ) return 0;
char mem_buf [ PAGE_BUFFER_SIZE ];
while ( size > 0 )
{
todo = min ( size, PAGE_BUFFER_SIZE );
if ( ! ReadProcessMemory ( hProcess, pos, mem_buf, todo, &done ) )
{
deb_printf ( "Error reading process memory at %x(%x) %u\n", pos, todo, GetLastError () );
return 0;
}
size -= done;
pos += done;
if ( ! bfd_set_section_contents ( core_bfd, to, mem_buf, sect_pos, done ) )
{
bfd_perror ( "writing memory region to bfd" );
dumper_abort ();
return 0;
} ;
sect_pos += done;
}
return 1;
}
int
dumper::dump_thread ( asection* to, process_thread* thread )
{
if ( ! sane () ) return 0;
if ( to == NULL || thread == NULL ) return 0;
win32_pstatus thread_pstatus;
note_header header;
bfd_putl32 ( NOTE_NAME_SIZE, header.elf_note_header.namesz );
bfd_putl32 ( sizeof ( thread_pstatus ), header.elf_note_header.descsz );
bfd_putl32 ( NT_WIN32PSTATUS, header.elf_note_header.type );
strncpy ( (char*) & header.elf_note_header.name, "win32thread", NOTE_NAME_SIZE );
thread_pstatus.data_type = NOTE_INFO_THREAD;
thread_pstatus.data.thread_info.tid = thread->tid;
if ( tid == 0 )
{
/* this is a special case. we don't know, which thread
was active when exception occured, so let's blame
the first one */
thread_pstatus.data.thread_info.is_active_thread = TRUE ;
tid = (DWORD) -1 ;
}
else if ( tid > 0 && thread->tid == tid )
thread_pstatus.data.thread_info.is_active_thread = TRUE;
else
thread_pstatus.data.thread_info.is_active_thread = FALSE;
memcpy ( &(thread_pstatus.data.thread_info.thread_context),
&(thread->context),
sizeof ( thread->context ) );
if ( ! bfd_set_section_contents ( core_bfd, to, &header,
0,
sizeof ( header ) ) ||
! bfd_set_section_contents ( core_bfd, to, &thread_pstatus,
sizeof ( header ),
sizeof ( thread_pstatus ) ) )
{
bfd_perror ( "writing thread info to bfd" );
dumper_abort ();
return 0;
} ;
return 1;
}
int
dumper::dump_module ( asection* to, process_module* module )
{
if ( ! sane () ) return 0;
if ( to == NULL || module == NULL ) return 0;
struct win32_pstatus* module_pstatus_ptr;
int note_length = sizeof ( struct win32_pstatus ) + strlen ( module->name );
char* buf = (char*) malloc ( note_length );
if ( ! buf )
{
fprintf ( stderr, "Error alloating memory. Dumping aborted.\n" );
goto out;
} ;
module_pstatus_ptr = (struct win32_pstatus*) buf;
note_header header;
bfd_putl32 ( NOTE_NAME_SIZE, header.elf_note_header.namesz );
bfd_putl32 ( note_length, header.elf_note_header.descsz );
bfd_putl32 ( NT_WIN32PSTATUS, header.elf_note_header.type );
strncpy ( (char*) & header.elf_note_header.name, "win32module", NOTE_NAME_SIZE );
module_pstatus_ptr->data_type = NOTE_INFO_MODULE;
module_pstatus_ptr->data.module_info.base_address = module->base_address;
module_pstatus_ptr->data.module_info.module_name_size = strlen ( module->name ) + 1;
strcpy ( module_pstatus_ptr->data.module_info.module_name, module->name );
if ( ! bfd_set_section_contents ( core_bfd, to, &header,
0,
sizeof ( header ) ) ||
! bfd_set_section_contents ( core_bfd, to, module_pstatus_ptr,
sizeof ( header ),
note_length ) )
{
bfd_perror ( "writing module info to bfd" );
goto out;
};
return 1;
out:
if ( buf ) free ( buf );
dumper_abort ();
return 0;
}
int
dumper::collect_process_information ()
{
if ( ! sane () ) return 0;
if ( ! DebugActiveProcess ( pid ) )
{
fprintf ( stderr, "Cannot attach to process #%lu", pid );
return 0;
}
char event_name [ sizeof ( "cygwin_error_start_event" ) + 20 ];
sprintf ( event_name, "cygwin_error_start_event%16lx", pid );
HANDLE sync_with_debugee = OpenEvent ( EVENT_MODIFY_STATE, FALSE, event_name );
DEBUG_EVENT current_event;
while (1)
{
if ( ! WaitForDebugEvent ( &current_event, 20000 ) ) return 0;
switch (current_event.dwDebugEventCode)
{
case CREATE_THREAD_DEBUG_EVENT:
if ( ! add_thread ( current_event.dwThreadId,
current_event.u.CreateThread.hThread ) )
goto failed;
break;
case CREATE_PROCESS_DEBUG_EVENT:
if ( ! add_module ( current_event.u.CreateProcessInfo.lpBaseOfImage ) ||
! add_thread ( current_event.dwThreadId,
current_event.u.CreateProcessInfo.hThread ) )
goto failed;
break;
case EXIT_PROCESS_DEBUG_EVENT:
deb_printf ( "debugee quits" );
ContinueDebugEvent ( current_event.dwProcessId,
current_event.dwThreadId,
DBG_CONTINUE );
return 1;
break;
case LOAD_DLL_DEBUG_EVENT:
if ( ! add_module ( current_event.u.LoadDll.lpBaseOfDll ) )
goto failed;
break;
case EXCEPTION_DEBUG_EVENT:
collect_memory_sections ();
/* got all info. time to dump */
if ( ! prepare_core_dump () )
{
fprintf ( stderr, "Failed to prepare core dump\n" );
goto failed;
};
if ( ! write_core_dump () )
{
fprintf ( stderr, "Failed to write core dump\n" );
goto failed;
};
/* signal a debugee that we've finished */
if ( sync_with_debugee ) SetEvent ( sync_with_debugee );
break;
default:
break;
}
ContinueDebugEvent ( current_event.dwProcessId,
current_event.dwThreadId,
DBG_CONTINUE );
}
failed:
/* set debugee free */
if ( sync_with_debugee ) SetEvent ( sync_with_debugee );
return 0;
}
int
dumper::init_core_dump ()
{
bfd_init ();
core_bfd = bfd_openw ( file_name, "elf32-i386" );
if ( core_bfd == NULL )
{
bfd_perror ( "opening bfd" );
goto failed;
}
if ( ! bfd_set_format ( core_bfd, bfd_core ) )
{
bfd_perror ( "setting bfd format" );
goto failed;
}
return 1;
failed:
dumper_abort ();
return 0;
}
int
dumper::prepare_core_dump ()
{
if ( ! sane () ) return 0;
int sect_no = 0;
char sect_name [ 50 ];
flagword sect_flags;
DWORD sect_size;
bfd_vma sect_vma;
asection* new_section;
for ( process_entity* p = list; p != NULL; p = p->next )
{
sect_no++;
switch ( p->type )
{
case pr_ent_memory:
sprintf ( sect_name, ".mem/%u", sect_no );
sect_flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
sect_size = p->u.memory.size;
sect_vma = (bfd_vma)(p->u.memory.base);
break;
case pr_ent_thread:
sprintf ( sect_name, ".note/%u", sect_no );
sect_flags = SEC_HAS_CONTENTS | SEC_LOAD;
sect_size = sizeof ( note_header ) + sizeof ( struct win32_pstatus );
sect_vma = 0;
break;
case pr_ent_module:
sprintf ( sect_name, ".note/%u", sect_no );
sect_flags = SEC_HAS_CONTENTS | SEC_LOAD;
sect_size = sizeof ( note_header ) + sizeof ( struct win32_pstatus ) +
(bfd_size_type)( strlen (p->u.module.name) );
sect_vma = 0;
break;
default:
continue;
}
if ( p->type == pr_ent_module && status_section != NULL )
{
if ( ! bfd_set_section_size ( core_bfd,
status_section,
status_section->_raw_size + sect_size ) )
{
bfd_perror ( "resizing status section" );
goto failed;
};
continue;
}
deb_printf ( "creating section (type%u) %s(%u), flags=%08x\n",
p->type, sect_name, sect_size, sect_flags );
char* buf = strdup ( sect_name );
new_section = bfd_make_section ( core_bfd, buf );
if ( new_section == NULL ||
! bfd_set_section_flags ( core_bfd, new_section, sect_flags ) ||
! bfd_set_section_size ( core_bfd, new_section, sect_size ) )
{
bfd_perror ( "creating section" );
goto failed;
};
new_section->vma = sect_vma;
new_section->output_section = new_section;
new_section->output_offset = 0;
p->section = new_section;
}
return 1;
failed:
dumper_abort ();
return 0;
}
int
dumper::write_core_dump ()
{
if ( ! sane () ) return 0;
for ( process_entity* p = list; p != NULL; p = p->next )
{
if ( p->section == NULL ) continue;
deb_printf ( "writing section type=%u base=%08x size=%08x flags=%08x\n",
p->type,
p->section->vma,
p->section->_raw_size,
p->section->flags );
switch ( p->type )
{
case pr_ent_memory:
dump_memory_region ( p->section, &(p->u.memory) );
break;
case pr_ent_thread:
dump_thread ( p->section, &(p->u.thread) );
break;
case pr_ent_module:
dump_module ( p->section, &(p->u.module) );
break;
default:
continue;
}
}
return 1;
}
static void
usage ()
{
fprintf ( stderr, "Usage: dumper [-v] [-c filename] pid\n" );
fprintf ( stderr, "-c filename -- dump core to filename.core\n" );
fprintf ( stderr, "-d -- print some debugging info while dumping\n" );
fprintf ( stderr, "pid -- win32-pid of process to dump\n" );
}
int
main( int argc, char** argv )
{
int opt;
char* p = "";
DWORD pid;
while ((opt = getopt (argc, argv, "dc:")) != EOF)
switch (opt)
{
case 'd':
verbose = TRUE;
break;
case 'c':
char win32_name [ MAX_PATH ];
cygwin_conv_to_win32_path ( optarg, win32_name );
if ( ( p = strrchr ( win32_name, '\\' ) ) )
p++;
else
p = win32_name;
break;
}
char* core_file = (char*) malloc ( strlen ( p ) + sizeof ( ".core" ) );
if ( ! core_file )
{
fprintf ( stderr, "error allocating memory\n" );
return -1;
}
sprintf ( core_file, "%s.core", p );
if ( argv && *(argv+optind) )
pid = atoi ( *(argv+optind) );
else
{
usage ();
return -1;
}
DWORD tid = 0;
if ( verbose )
printf ( "dumping process #%lu to %s\n", pid, core_file );
dumper d ( pid, tid, core_file );
if ( ! d.sane () )
return -1;
d.collect_process_information ();
free ( core_file );
return 0;
};
Reference in New Issue View Git Blame Copy Permalink