From eedc36cb12f20ed62f5dfeaea25c84c7c984cf5f Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Sat, 28 Oct 2000 05:00:00 +0000 Subject: Cleanup formatting on some files. Remove excessive whitespace. --- winsup/utils/dumper.cc | 672 ++++++++++++++++++++++++++----------------------- 1 file changed, 354 insertions(+), 318 deletions(-) (limited to 'winsup/utils/dumper.cc') diff --git a/winsup/utils/dumper.cc b/winsup/utils/dumper.cc index 6ccf2f1c9..df3f14640 100644 --- a/winsup/utils/dumper.cc +++ b/winsup/utils/dumper.cc @@ -4,11 +4,11 @@ Written by Egor Duda -This file is part of Cygwin. + 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. */ + This software is a copyrighted work licensed under the terms of the + Cygwin license. Please consult the file "CYGWIN_LICENSE" for + details. */ #include #include @@ -27,35 +27,36 @@ details. */ #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 */ -} + { + Elf_External_Note elf_note_header; + char name[NOTE_NAME_SIZE - 1]; /* external note contains first byte of data */ + } #ifdef __GNUC__ - __attribute__ ((packed)) +__attribute__ ((packed)) #endif -note_header ; + note_header; -BOOL verbose = FALSE; + BOOL verbose = FALSE; -int deb_printf ( const char* format, ... ) + int deb_printf (const char *format,...) { - if ( !verbose ) return 0; + if (!verbose) + return 0; va_list va; - va_start ( va, format ); - int ret_val = vprintf ( format, va ); - va_end ( 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 ) +dumper::dumper (DWORD pid, DWORD tid, const char *file_name) { - this->file_name = strdup ( file_name ); + this->file_name = strdup (file_name); this->pid = pid; this->tid = tid; core_bfd = NULL; - excl_list = new exclusion ( 20 ); + excl_list = new exclusion (20); list = last = NULL; @@ -63,39 +64,43 @@ dumper::dumper ( DWORD pid, DWORD tid, const char* file_name ) memory_num = module_num = thread_num = 0; - hProcess = OpenProcess ( PROCESS_ALL_ACCESS, - FALSE, /* no inheritance */ - pid ); - if ( !hProcess ) + hProcess = OpenProcess (PROCESS_ALL_ACCESS, + FALSE, /* no inheritance */ + pid); + if (!hProcess) { - fprintf ( stderr, "Failed to open process #%lu\n", pid ); + fprintf (stderr, "Failed to open process #%lu\n", pid); return; } init_core_dump (); - if ( ! sane () ) dumper_abort (); + if (!sane ()) + dumper_abort (); } -dumper::~dumper () +dumper: :~dumper () { close (); - free ( file_name ); + free (file_name); } void dumper::dumper_abort () { close (); - unlink ( file_name ); + unlink (file_name); } void dumper::close () { - if ( core_bfd ) bfd_close ( core_bfd ); - if ( excl_list ) delete excl_list; - if ( hProcess ) CloseHandle ( hProcess ); + 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; @@ -104,20 +109,23 @@ dumper::close () int dumper::sane () { - if ( hProcess == NULL || core_bfd == NULL || excl_list == NULL ) return 0; + 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 ) +process_entity * +dumper::add_process_entity_to_list (process_entity_type type) { - if ( ! sane () ) return NULL; + if (!sane ()) + return NULL; - process_entity* new_entity = ( process_entity* ) malloc ( sizeof ( process_entity ) ); - if ( new_entity == NULL ) 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 ) + if (last == NULL) list = new_entity; else last->next = new_entity; @@ -126,101 +134,111 @@ dumper::add_process_entity_to_list ( process_entity_type type ) } int -dumper::add_thread ( DWORD tid, HANDLE hThread ) +dumper::add_thread (DWORD tid, HANDLE hThread) { - if ( ! sane () ) return 0 ; + if (!sane ()) + return 0; - CONTEXT* pcontext; + CONTEXT *pcontext; - process_entity* new_entity = add_process_entity_to_list ( pr_ent_thread ); - if ( new_entity == NULL ) return 0; + 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 = &(new_entity->u.thread.context); pcontext->ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT; - if ( ! GetThreadContext ( hThread, pcontext ) ) return 0; + if (!GetThreadContext (hThread, pcontext)) + return 0; - deb_printf ( "added thread %u\n", tid ); + deb_printf ("added thread %u\n", tid); return 1; } int -dumper::add_mem_region ( LPBYTE base, DWORD size ) +dumper::add_mem_region (LPBYTE base, DWORD size) { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - if ( base == NULL || size == 0 ) return 1; // just ignore empty regions + 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; + 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 ); + 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 - */ +/* 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 ) +dumper::split_add_mem_region (LPBYTE base, DWORD size) { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - if ( base == NULL || size == 0 ) return 1; // just ignore empty regions + 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++ ) + 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 + size || p->base + p->size <= base) + continue; - if ( p->base <= base ) - { - last_base = p->base + p->size; - continue ; - } + if (p->base <= base) + { + last_base = p->base + p->size; + continue; + } - add_mem_region ( last_base, p->base - last_base ); + 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 ); + if (last_base < base + size) + add_mem_region (last_base, base + size - last_base); return 1; } int -dumper::add_module ( LPVOID base_address ) +dumper::add_module (LPVOID base_address) { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - char* module_name = psapi_get_module_name ( hProcess, (DWORD) base_address ); - if ( module_name == NULL ) return 1; + 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; + 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 ); + parse_pe (module_name, excl_list); - deb_printf ( "added module %08x %s\n", base_address, module_name ); + deb_printf ("added module %08x %s\n", base_address, module_name); return 1; } @@ -229,89 +247,94 @@ dumper::add_module ( LPVOID base_address ) int dumper::collect_memory_sections () { - if ( ! sane () ) return 0; + 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 ]; + char mem_buf[PAGE_BUFFER_SIZE]; MEMORY_BASIC_INFORMATION mbi; - if ( hProcess == NULL ) return 0; + if (hProcess == NULL) + return 0; - for ( current_page_address = 0; current_page_address < (LPBYTE) 0xFFFF0000; ) + for (current_page_address = 0; current_page_address < (LPBYTE) 0xFFFF0000;) { - if ( ! VirtualQueryEx ( hProcess, current_page_address, &mbi, sizeof ( mbi ) ) ) - break ; + 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 ); + 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; - } - } + } + } + + 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 ); + { + split_add_mem_region (last_base, last_size); last_base = NULL; - last_size = 0; - } + last_size = 0; + } current_page_address += mbi.RegionSize; } /* dump last sections, if any */ - split_add_mem_region ( last_base, last_size ); + split_add_mem_region (last_base, last_size); return 1; }; int -dumper::dump_memory_region ( asection* to, process_mem_region* memory ) +dumper::dump_memory_region (asection * to, process_mem_region * memory) { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; DWORD size = memory->size; DWORD todo; @@ -319,126 +342,132 @@ dumper::dump_memory_region ( asection* to, process_mem_region* memory ) LPBYTE pos = memory->base; DWORD sect_pos = 0; - if ( to == NULL || memory == NULL ) return 0; + if (to == NULL || memory == NULL) + return 0; - char mem_buf [ PAGE_BUFFER_SIZE ]; + char mem_buf[PAGE_BUFFER_SIZE]; - while ( size > 0 ) + while (size > 0) { - todo = min ( size, PAGE_BUFFER_SIZE ); - if ( ! ReadProcessMemory ( hProcess, pos, mem_buf, todo, &done ) ) + 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 () ); + 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; - } ; + 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 ) +dumper::dump_thread (asection * to, process_thread * thread) { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - if ( to == NULL || thread == NULL ) 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 ); + 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 ) + if (tid == 0) { /* this is a special case. we don't know, which thread - was active when exception occured, so let's blame + was active when exception occured, so let's blame the first one */ - thread_pstatus.data.thread_info.is_active_thread = TRUE ; - tid = (DWORD) -1 ; + thread_pstatus.data.thread_info.is_active_thread = TRUE; + tid = (DWORD) - 1; } - else if ( tid > 0 && thread->tid == tid ) + 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 ) ); + 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 ) ) ) + 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" ); + bfd_perror ("writing thread info to bfd"); dumper_abort (); return 0; - } ; + }; return 1; } int -dumper::dump_module ( asection* to, process_module* module ) +dumper::dump_module (asection * to, process_module * module) { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - if ( to == NULL || module == NULL ) return 0; + if (to == NULL || module == NULL) + return 0; - struct win32_pstatus* module_pstatus_ptr; + struct win32_pstatus *module_pstatus_ptr; - int note_length = sizeof ( struct win32_pstatus ) + strlen ( module->name ); + int note_length = sizeof (struct win32_pstatus) + strlen (module->name); - char* buf = (char*) malloc ( note_length ); + char *buf = (char *) malloc (note_length); - if ( ! buf ) + if (!buf) { - fprintf ( stderr, "Error alloating memory. Dumping aborted.\n" ); + fprintf (stderr, "Error alloating memory. Dumping aborted.\n"); goto out; - } ; + }; - module_pstatus_ptr = (struct win32_pstatus*) buf; + 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 ); + 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 ) ) + 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" ); + bfd_perror ("writing module info to bfd"); goto out; }; return 1; out: - if ( buf ) free ( buf ); + if (buf) + free (buf); dumper_abort (); return 0; @@ -447,49 +476,51 @@ out: int dumper::collect_process_information () { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - if ( ! DebugActiveProcess ( pid ) ) + if (!DebugActiveProcess (pid)) { - fprintf ( stderr, "Cannot attach to process #%lu", 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 ); + 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 ( ¤t_event, 20000 ) ) return 0; + if (!WaitForDebugEvent (¤t_event, 20000)) + return 0; switch (current_event.dwDebugEventCode) { case CREATE_THREAD_DEBUG_EVENT: - if ( ! add_thread ( current_event.dwThreadId, - current_event.u.CreateThread.hThread ) ) + 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; + 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 ); + deb_printf ("debugee quits"); + ContinueDebugEvent (current_event.dwProcessId, + current_event.dwThreadId, + DBG_CONTINUE); return 1; @@ -497,31 +528,32 @@ dumper::collect_process_information () case LOAD_DLL_DEBUG_EVENT: - if ( ! add_module ( current_event.u.LoadDll.lpBaseOfDll ) ) - goto failed; + if (!add_module (current_event.u.LoadDll.lpBaseOfDll)) + goto failed; break; case EXCEPTION_DEBUG_EVENT: - collect_memory_sections (); + collect_memory_sections (); - /* got all info. time to dump */ + /* got all info. time to dump */ - if ( ! prepare_core_dump () ) + if (!prepare_core_dump ()) { - fprintf ( stderr, "Failed to prepare core dump\n" ); + fprintf (stderr, "Failed to prepare core dump\n"); goto failed; }; - if ( ! write_core_dump () ) + if (!write_core_dump ()) { - fprintf ( stderr, "Failed to write core dump\n" ); + 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 ); + /* signal a debugee that we've finished */ + if (sync_with_debugee) + SetEvent (sync_with_debugee); break; @@ -531,13 +563,14 @@ dumper::collect_process_information () } - ContinueDebugEvent ( current_event.dwProcessId, - current_event.dwThreadId, - DBG_CONTINUE ); + ContinueDebugEvent (current_event.dwProcessId, + current_event.dwThreadId, + DBG_CONTINUE); } failed: /* set debugee free */ - if ( sync_with_debugee ) SetEvent ( sync_with_debugee ); + if (sync_with_debugee) + SetEvent (sync_with_debugee); return 0; } @@ -547,16 +580,16 @@ dumper::init_core_dump () { bfd_init (); - core_bfd = bfd_openw ( file_name, "elf32-i386" ); - if ( core_bfd == NULL ) + core_bfd = bfd_openw (file_name, "elf32-i386"); + if (core_bfd == NULL) { - bfd_perror ( "opening bfd" ); + bfd_perror ("opening bfd"); goto failed; } - if ( ! bfd_set_format ( core_bfd, bfd_core ) ) + if (!bfd_set_format (core_bfd, bfd_core)) { - bfd_perror ( "setting bfd format" ); + bfd_perror ("setting bfd format"); goto failed; } @@ -571,73 +604,74 @@ failed: int dumper::prepare_core_dump () { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; int sect_no = 0; - char sect_name [ 50 ]; + char sect_name[50]; flagword sect_flags; DWORD sect_size; bfd_vma sect_vma; - asection* new_section; + asection *new_section; - for ( process_entity* p = list; p != NULL; p = p->next ) + 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; + 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; + 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: + 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 ) ) + 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" ); + bfd_perror ("resizing status section"); goto failed; }; - continue; - } + continue; + } - deb_printf ( "creating section (type%u) %s(%u), flags=%08x\n", - p->type, sect_name, sect_size, sect_flags ); + 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 ); + 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 ) ) + 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" ); + bfd_perror ("creating section"); goto failed; }; @@ -657,36 +691,38 @@ failed: int dumper::write_core_dump () { - if ( ! sane () ) return 0; + if (!sane ()) + return 0; - for ( process_entity* p = list; p != NULL; p = p->next ) + 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) ); + 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_module: - dump_module ( p->section, &(p->u.module) ); - 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: + default: continue; - } + } } return 1; } @@ -694,17 +730,17 @@ dumper::write_core_dump () 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" ); + 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 ) +main (int argc, char **argv) { int opt; - char* p = ""; + char *p = ""; DWORD pid; while ((opt = getopt (argc, argv, "dc:")) != EOF) @@ -714,25 +750,25 @@ main( int argc, char** argv ) verbose = TRUE; break; case 'c': - char win32_name [ MAX_PATH ]; - cygwin_conv_to_win32_path ( optarg, win32_name ); - if ( ( p = strrchr ( win32_name, '\\' ) ) ) + 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 ) + char *core_file = (char *) malloc (strlen (p) + sizeof (".core")); + if (!core_file) { - fprintf ( stderr, "error allocating memory\n" ); + fprintf (stderr, "error allocating memory\n"); return -1; } - sprintf ( core_file, "%s.core", p ); + sprintf (core_file, "%s.core", p); - if ( argv && *(argv+optind) ) - pid = atoi ( *(argv+optind) ); + if (argv && *(argv + optind)) + pid = atoi (*(argv + optind)); else { usage (); @@ -741,14 +777,14 @@ main( int argc, char** argv ) DWORD tid = 0; - if ( verbose ) - printf ( "dumping process #%lu to %s\n", pid, core_file ); + if (verbose) + printf ("dumping process #%lu to %s\n", pid, core_file); - dumper d ( pid, tid, core_file ); - if ( ! d.sane () ) + dumper d (pid, tid, core_file); + if (!d.sane ()) return -1; d.collect_process_information (); - free ( core_file ); + free (core_file); return 0; }; -- cgit v1.2.3