2000-08-24 21:03:12 +02:00
|
|
|
/* dumper.cc
|
|
|
|
|
2006-12-21 10:59:04 +01:00
|
|
|
Copyright 1999, 2001, 2002, 2004, 2006 Red Hat Inc.
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
Written by Egor Duda <deo@logos-m.ru>
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
This file is part of Cygwin.
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
|
|
details. */
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2006-12-11 20:17:17 +01:00
|
|
|
#include <ansidecl.h>
|
2006-12-21 10:59:04 +01:00
|
|
|
#include <bfd.h>
|
2000-08-24 21:03:12 +02:00
|
|
|
#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
|
2000-10-28 07:00:00 +02:00
|
|
|
{
|
|
|
|
Elf_External_Note elf_note_header;
|
|
|
|
char name[NOTE_NAME_SIZE - 1]; /* external note contains first byte of data */
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
#ifdef __GNUC__
|
2000-10-28 07:00:00 +02:00
|
|
|
__attribute__ ((packed))
|
2000-08-24 21:03:12 +02:00
|
|
|
#endif
|
2000-10-28 07:00:00 +02:00
|
|
|
note_header;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2002-05-08 03:55:56 +02:00
|
|
|
static const char version[] = "$Revision$";
|
|
|
|
|
2001-09-09 15:18:51 +02:00
|
|
|
BOOL verbose = FALSE;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2001-09-09 15:18:51 +02:00
|
|
|
int deb_printf (const char *format,...)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!verbose)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
va_list va;
|
2000-10-28 07:00:00 +02:00
|
|
|
va_start (va, format);
|
|
|
|
int ret_val = vprintf (format, va);
|
|
|
|
va_end (va);
|
2000-08-24 21:03:12 +02:00
|
|
|
return ret_val;
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::dumper (DWORD pid, DWORD tid, const char *file_name)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
this->file_name = strdup (file_name);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
this->pid = pid;
|
|
|
|
this->tid = tid;
|
|
|
|
core_bfd = NULL;
|
2000-10-28 07:00:00 +02:00
|
|
|
excl_list = new exclusion (20);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
list = last = NULL;
|
|
|
|
|
|
|
|
status_section = NULL;
|
|
|
|
|
|
|
|
memory_num = module_num = thread_num = 0;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
hProcess = OpenProcess (PROCESS_ALL_ACCESS,
|
|
|
|
FALSE, /* no inheritance */
|
|
|
|
pid);
|
|
|
|
if (!hProcess)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2001-09-14 17:07:31 +02:00
|
|
|
fprintf (stderr, "Failed to open process #%lu, error %ld\n", pid, GetLastError ());
|
2000-08-24 21:03:12 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
init_core_dump ();
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
dumper_abort ();
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
|
2000-10-28 07:39:38 +02:00
|
|
|
dumper::~dumper ()
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
|
|
|
close ();
|
2000-10-28 07:00:00 +02:00
|
|
|
free (file_name);
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dumper::dumper_abort ()
|
|
|
|
{
|
|
|
|
close ();
|
2000-10-28 07:00:00 +02:00
|
|
|
unlink (file_name);
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dumper::close ()
|
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (core_bfd)
|
|
|
|
bfd_close (core_bfd);
|
|
|
|
if (excl_list)
|
|
|
|
delete excl_list;
|
|
|
|
if (hProcess)
|
|
|
|
CloseHandle (hProcess);
|
2000-08-24 21:03:12 +02:00
|
|
|
core_bfd = NULL;
|
|
|
|
hProcess = NULL;
|
|
|
|
excl_list = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
dumper::sane ()
|
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (hProcess == NULL || core_bfd == NULL || excl_list == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2001-08-30 18:47:51 +02:00
|
|
|
void
|
|
|
|
print_section_name (bfd* abfd, asection* sect, PTR obj)
|
|
|
|
{
|
2001-09-14 17:07:31 +02:00
|
|
|
deb_printf (" %s", bfd_get_section_name (abfd, sect));
|
2001-08-30 18:47:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dumper::print_core_section_list ()
|
|
|
|
{
|
|
|
|
deb_printf ("current sections:");
|
|
|
|
bfd_map_over_sections (core_bfd, &print_section_name, NULL);
|
|
|
|
deb_printf ("\n");
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
process_entity *
|
|
|
|
dumper::add_process_entity_to_list (process_entity_type type)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return NULL;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
process_entity *new_entity = (process_entity *) malloc (sizeof (process_entity));
|
|
|
|
if (new_entity == NULL)
|
|
|
|
return NULL;
|
2000-08-24 21:03:12 +02:00
|
|
|
new_entity->next = NULL;
|
|
|
|
new_entity->section = NULL;
|
2000-10-28 07:00:00 +02:00
|
|
|
if (last == NULL)
|
2000-08-24 21:03:12 +02:00
|
|
|
list = new_entity;
|
|
|
|
else
|
|
|
|
last->next = new_entity;
|
|
|
|
last = new_entity;
|
|
|
|
return new_entity;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::add_thread (DWORD tid, HANDLE hThread)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
CONTEXT *pcontext;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
process_entity *new_entity = add_process_entity_to_list (pr_ent_thread);
|
|
|
|
if (new_entity == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
new_entity->type = pr_ent_thread;
|
|
|
|
thread_num++;
|
|
|
|
|
|
|
|
new_entity->u.thread.tid = tid;
|
|
|
|
new_entity->u.thread.hThread = hThread;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
pcontext = &(new_entity->u.thread.context);
|
2000-08-24 21:03:12 +02:00
|
|
|
pcontext->ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT;
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!GetThreadContext (hThread, pcontext))
|
2001-09-14 17:07:31 +02:00
|
|
|
{
|
|
|
|
deb_printf ("Failed to read thread context (tid=%x), error %ld\n", tid, GetLastError ());
|
|
|
|
return 0;
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
deb_printf ("added thread %u\n", tid);
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::add_mem_region (LPBYTE base, DWORD size)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (base == NULL || size == 0)
|
|
|
|
return 1; // just ignore empty regions
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
process_entity *new_entity = add_process_entity_to_list (pr_ent_memory);
|
|
|
|
if (new_entity == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
new_entity->type = pr_ent_memory;
|
|
|
|
memory_num++;
|
|
|
|
|
|
|
|
new_entity->u.memory.base = base;
|
|
|
|
new_entity->u.memory.size = size;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
deb_printf ("added memory region %08x-%08x\n", (DWORD) base, (DWORD) base + size);
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
/* split_add_mem_region scans list of regions to be excluded from dumping process
|
|
|
|
(excl_list) and removes all "excluded" parts from given region. */
|
2000-08-24 21:03:12 +02:00
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::split_add_mem_region (LPBYTE base, DWORD size)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (base == NULL || size == 0)
|
|
|
|
return 1; // just ignore empty regions
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
LPBYTE last_base = base;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
for (process_mem_region * p = excl_list->region;
|
|
|
|
p < excl_list->region + excl_list->last;
|
|
|
|
p++)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (p->base >= base + size || p->base + p->size <= base)
|
|
|
|
continue;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (p->base <= base)
|
|
|
|
{
|
|
|
|
last_base = p->base + p->size;
|
|
|
|
continue;
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
add_mem_region (last_base, p->base - last_base);
|
2000-08-24 21:03:12 +02:00
|
|
|
last_base = p->base + p->size;
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (last_base < base + size)
|
|
|
|
add_mem_region (last_base, base + size - last_base);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::add_module (LPVOID base_address)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
char *module_name = psapi_get_module_name (hProcess, (DWORD) base_address);
|
|
|
|
if (module_name == NULL)
|
|
|
|
return 1;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
process_entity *new_entity = add_process_entity_to_list (pr_ent_module);
|
|
|
|
if (new_entity == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
new_entity->type = pr_ent_module;
|
|
|
|
module_num++;
|
|
|
|
|
|
|
|
new_entity->u.module.base_address = base_address;
|
|
|
|
new_entity->u.module.name = module_name;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
parse_pe (module_name, excl_list);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
deb_printf ("added module %08x %s\n", base_address, module_name);
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PAGE_BUFFER_SIZE 4096
|
|
|
|
|
|
|
|
int
|
|
|
|
dumper::collect_memory_sections ()
|
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
LPBYTE current_page_address;
|
|
|
|
LPBYTE last_base = (LPBYTE) 0xFFFFFFFF;
|
|
|
|
DWORD last_size = 0;
|
|
|
|
DWORD done;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
char mem_buf[PAGE_BUFFER_SIZE];
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
MEMORY_BASIC_INFORMATION mbi;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (hProcess == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
for (current_page_address = 0; current_page_address < (LPBYTE) 0xFFFF0000;)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!VirtualQueryEx (hProcess, current_page_address, &mbi, sizeof (mbi)))
|
|
|
|
break;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
int skip_region_p = 0;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
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))
|
|
|
|
{
|
2001-09-14 17:07:31 +02:00
|
|
|
DWORD err = GetLastError ();
|
2000-10-28 07:00:00 +02:00
|
|
|
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]);
|
|
|
|
|
2001-09-14 17:07:31 +02:00
|
|
|
deb_printf ("warning: failed to read memory at %08x-%08x (protect = %s), error %ld.\n",
|
2000-10-28 07:00:00 +02:00
|
|
|
(DWORD) current_page_address,
|
|
|
|
(DWORD) current_page_address + mbi.RegionSize,
|
2001-09-14 17:07:31 +02:00
|
|
|
buf, err);
|
2000-08-24 21:03:12 +02:00
|
|
|
skip_region_p = 1;
|
2000-10-28 07:00:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
else
|
2000-10-28 07:00:00 +02:00
|
|
|
{
|
|
|
|
split_add_mem_region (last_base, last_size);
|
2000-08-24 21:03:12 +02:00
|
|
|
last_base = NULL;
|
2000-10-28 07:00:00 +02:00
|
|
|
last_size = 0;
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
current_page_address += mbi.RegionSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dump last sections, if any */
|
2000-10-28 07:00:00 +02:00
|
|
|
split_add_mem_region (last_base, last_size);
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::dump_memory_region (asection * to, process_mem_region * memory)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
DWORD size = memory->size;
|
|
|
|
DWORD todo;
|
|
|
|
DWORD done;
|
|
|
|
LPBYTE pos = memory->base;
|
|
|
|
DWORD sect_pos = 0;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (to == NULL || memory == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
char mem_buf[PAGE_BUFFER_SIZE];
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
while (size > 0)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
todo = min (size, PAGE_BUFFER_SIZE);
|
|
|
|
if (!ReadProcessMemory (hProcess, pos, mem_buf, todo, &done))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2001-09-14 17:07:31 +02:00
|
|
|
deb_printf ("Failed to read process memory at %x(%x), error %ld\n", pos, todo, GetLastError ());
|
2000-08-24 21:03:12 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
size -= done;
|
|
|
|
pos += done;
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!bfd_set_section_contents (core_bfd, to, mem_buf, sect_pos, done))
|
|
|
|
{
|
|
|
|
bfd_perror ("writing memory region to bfd");
|
|
|
|
dumper_abort ();
|
|
|
|
return 0;
|
|
|
|
};
|
2000-08-24 21:03:12 +02:00
|
|
|
sect_pos += done;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::dump_thread (asection * to, process_thread * thread)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (to == NULL || thread == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
win32_pstatus thread_pstatus;
|
|
|
|
|
|
|
|
note_header header;
|
2000-10-28 07:00:00 +02:00
|
|
|
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);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
thread_pstatus.data_type = NOTE_INFO_THREAD;
|
|
|
|
thread_pstatus.data.thread_info.tid = thread->tid;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (tid == 0)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
|
|
|
/* this is a special case. we don't know, which thread
|
2004-10-25 17:49:36 +02:00
|
|
|
was active when exception occured, so let's blame
|
|
|
|
the first one */
|
2000-10-28 07:00:00 +02:00
|
|
|
thread_pstatus.data.thread_info.is_active_thread = TRUE;
|
|
|
|
tid = (DWORD) - 1;
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
2000-10-28 07:00:00 +02:00
|
|
|
else if (tid > 0 && thread->tid == tid)
|
2000-08-24 21:03:12 +02:00
|
|
|
thread_pstatus.data.thread_info.is_active_thread = TRUE;
|
|
|
|
else
|
|
|
|
thread_pstatus.data.thread_info.is_active_thread = FALSE;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
memcpy (&(thread_pstatus.data.thread_info.thread_context),
|
|
|
|
&(thread->context),
|
|
|
|
sizeof (thread->context));
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
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)))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
bfd_perror ("writing thread info to bfd");
|
2000-08-24 21:03:12 +02:00
|
|
|
dumper_abort ();
|
|
|
|
return 0;
|
2000-10-28 07:00:00 +02:00
|
|
|
};
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper::dump_module (asection * to, process_module * module)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (to == NULL || module == NULL)
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
struct win32_pstatus *module_pstatus_ptr;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
int note_length = sizeof (struct win32_pstatus) + strlen (module->name);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
char *buf = (char *) malloc (note_length);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!buf)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
fprintf (stderr, "Error alloating memory. Dumping aborted.\n");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto out;
|
2000-10-28 07:00:00 +02:00
|
|
|
};
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
module_pstatus_ptr = (struct win32_pstatus *) buf;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
note_header header;
|
2000-10-28 07:00:00 +02:00
|
|
|
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);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
module_pstatus_ptr->data_type = NOTE_INFO_MODULE;
|
|
|
|
module_pstatus_ptr->data.module_info.base_address = module->base_address;
|
2000-10-28 07:00:00 +02:00
|
|
|
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))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
bfd_perror ("writing module info to bfd");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto out;
|
|
|
|
};
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
out:
|
2000-10-28 07:00:00 +02:00
|
|
|
if (buf)
|
|
|
|
free (buf);
|
2000-08-24 21:03:12 +02:00
|
|
|
dumper_abort ();
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
dumper::collect_process_information ()
|
|
|
|
{
|
2001-08-30 18:47:51 +02:00
|
|
|
int exception_level = 0;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!DebugActiveProcess (pid))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2001-09-14 17:07:31 +02:00
|
|
|
fprintf (stderr, "Cannot attach to process #%lu, error %ld", pid, GetLastError ());
|
2000-08-24 21:03:12 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
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);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
DEBUG_EVENT current_event;
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!WaitForDebugEvent (¤t_event, 20000))
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2001-08-30 18:47:51 +02:00
|
|
|
deb_printf ("got debug event %d\n", current_event.dwDebugEventCode);
|
|
|
|
|
2000-08-24 21:03:12 +02:00
|
|
|
switch (current_event.dwDebugEventCode)
|
|
|
|
{
|
|
|
|
case CREATE_THREAD_DEBUG_EVENT:
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!add_thread (current_event.dwThreadId,
|
|
|
|
current_event.u.CreateThread.hThread))
|
2000-08-24 21:03:12 +02:00
|
|
|
goto failed;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CREATE_PROCESS_DEBUG_EVENT:
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!add_module (current_event.u.CreateProcessInfo.lpBaseOfImage) ||
|
|
|
|
!add_thread (current_event.dwThreadId,
|
|
|
|
current_event.u.CreateProcessInfo.hThread))
|
|
|
|
goto failed;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EXIT_PROCESS_DEBUG_EVENT:
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
deb_printf ("debugee quits");
|
|
|
|
ContinueDebugEvent (current_event.dwProcessId,
|
|
|
|
current_event.dwThreadId,
|
|
|
|
DBG_CONTINUE);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LOAD_DLL_DEBUG_EVENT:
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!add_module (current_event.u.LoadDll.lpBaseOfDll))
|
|
|
|
goto failed;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case EXCEPTION_DEBUG_EVENT:
|
|
|
|
|
2001-08-30 18:47:51 +02:00
|
|
|
exception_level++;
|
|
|
|
if (exception_level == 2)
|
|
|
|
break;
|
|
|
|
else if (exception_level > 2)
|
|
|
|
return 0;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
collect_memory_sections ();
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
/* got all info. time to dump */
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!prepare_core_dump ())
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
fprintf (stderr, "Failed to prepare core dump\n");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto failed;
|
|
|
|
};
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!write_core_dump ())
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
fprintf (stderr, "Failed to write core dump\n");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto failed;
|
|
|
|
};
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
/* signal a debugee that we've finished */
|
|
|
|
if (sync_with_debugee)
|
|
|
|
SetEvent (sync_with_debugee);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
ContinueDebugEvent (current_event.dwProcessId,
|
|
|
|
current_event.dwThreadId,
|
|
|
|
DBG_CONTINUE);
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
failed:
|
|
|
|
/* set debugee free */
|
2000-10-28 07:00:00 +02:00
|
|
|
if (sync_with_debugee)
|
|
|
|
SetEvent (sync_with_debugee);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
dumper::init_core_dump ()
|
|
|
|
{
|
|
|
|
bfd_init ();
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
core_bfd = bfd_openw (file_name, "elf32-i386");
|
|
|
|
if (core_bfd == NULL)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
bfd_perror ("opening bfd");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!bfd_set_format (core_bfd, bfd_core))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
bfd_perror ("setting bfd format");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
2001-04-19 16:22:30 +02:00
|
|
|
if (!bfd_set_arch_mach (core_bfd, bfd_arch_i386, 0))
|
|
|
|
{
|
|
|
|
bfd_perror ("setting bfd architecture");
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
2000-08-24 21:03:12 +02:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
dumper_abort ();
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
dumper::prepare_core_dump ()
|
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
int sect_no = 0;
|
2000-10-28 07:00:00 +02:00
|
|
|
char sect_name[50];
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
flagword sect_flags;
|
|
|
|
DWORD sect_size;
|
|
|
|
bfd_vma sect_vma;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
asection *new_section;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
for (process_entity * p = list; p != NULL; p = p->next)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
|
|
|
sect_no++;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
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;
|
2000-08-24 21:03:12 +02:00
|
|
|
break;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
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;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
default:
|
2000-08-24 21:03:12 +02:00
|
|
|
continue;
|
2000-10-28 07:00:00 +02:00
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (p->type == pr_ent_module && status_section != NULL)
|
|
|
|
{
|
|
|
|
if (!bfd_set_section_size (core_bfd,
|
|
|
|
status_section,
|
2004-06-15 04:18:51 +02:00
|
|
|
(bfd_get_section_size (status_section)
|
|
|
|
+ sect_size)))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
bfd_perror ("resizing status section");
|
2000-08-24 21:03:12 +02:00
|
|
|
goto failed;
|
|
|
|
};
|
2000-10-28 07:00:00 +02:00
|
|
|
continue;
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
deb_printf ("creating section (type%u) %s(%u), flags=%08x\n",
|
|
|
|
p->type, sect_name, sect_size, sect_flags);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2001-08-30 18:47:51 +02:00
|
|
|
bfd_set_error (bfd_error_no_error);
|
2000-10-28 07:00:00 +02:00
|
|
|
char *buf = strdup (sect_name);
|
|
|
|
new_section = bfd_make_section (core_bfd, buf);
|
2001-08-30 18:47:51 +02:00
|
|
|
if (new_section == NULL)
|
|
|
|
{
|
|
|
|
if (bfd_get_error () == bfd_error_no_error)
|
|
|
|
fprintf (stderr, "error creating new section (%s), section already exists.\n", buf);
|
|
|
|
else
|
|
|
|
bfd_perror ("creating section");
|
|
|
|
goto failed;
|
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2001-08-30 18:47:51 +02:00
|
|
|
if (!bfd_set_section_flags (core_bfd, new_section, sect_flags) ||
|
2000-10-28 07:00:00 +02:00
|
|
|
!bfd_set_section_size (core_bfd, new_section, sect_size))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2001-08-30 18:47:51 +02:00
|
|
|
bfd_perror ("setting section attributes");
|
2000-08-24 21:03:12 +02:00
|
|
|
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 ()
|
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (!sane ())
|
|
|
|
return 0;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
for (process_entity * p = list; p != NULL; p = p->next)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2000-10-28 07:00:00 +02:00
|
|
|
if (p->section == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
deb_printf ("writing section type=%u base=%08x size=%08x flags=%08x\n",
|
|
|
|
p->type,
|
|
|
|
p->section->vma,
|
2004-06-15 04:18:51 +02:00
|
|
|
bfd_get_section_size (p->section),
|
2000-10-28 07:00:00 +02:00
|
|
|
p->section->flags);
|
|
|
|
|
|
|
|
switch (p->type)
|
|
|
|
{
|
|
|
|
case pr_ent_memory:
|
|
|
|
dump_memory_region (p->section, &(p->u.memory));
|
2000-08-24 21:03:12 +02:00
|
|
|
break;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
case pr_ent_thread:
|
|
|
|
dump_thread (p->section, &(p->u.thread));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case pr_ent_module:
|
|
|
|
dump_module (p->section, &(p->u.module));
|
|
|
|
break;
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
default:
|
2000-08-24 21:03:12 +02:00
|
|
|
continue;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
}
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2002-05-08 03:55:56 +02:00
|
|
|
usage (FILE *stream, int status)
|
|
|
|
{
|
|
|
|
fprintf (stream, "\
|
|
|
|
Usage: dumper [OPTION] FILENAME WIN32PID\n\
|
|
|
|
Dump core from WIN32PID to FILENAME.core\n\
|
2003-04-26 23:52:03 +02:00
|
|
|
\n\
|
2002-05-08 03:55:56 +02:00
|
|
|
-d, --verbose be verbose while dumping\n\
|
|
|
|
-h, --help output help information and exit\n\
|
|
|
|
-q, --quiet be quiet while dumping (default)\n\
|
|
|
|
-v, --version output version information and exit\n\
|
|
|
|
");
|
|
|
|
exit (status);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct option longopts[] = {
|
|
|
|
{"verbose", no_argument, NULL, 'd'},
|
|
|
|
{"help", no_argument, NULL, 'h'},
|
|
|
|
{"quiet", no_argument, NULL, 'q'},
|
|
|
|
{"version", no_argument, 0, 'v'},
|
|
|
|
{0, no_argument, NULL, 0}
|
|
|
|
};
|
|
|
|
|
2004-10-25 17:49:36 +02:00
|
|
|
static void
|
2002-05-08 03:55:56 +02:00
|
|
|
print_version ()
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2002-05-08 03:55:56 +02:00
|
|
|
const char *v = strchr (version, ':');
|
|
|
|
int len;
|
|
|
|
if (!v)
|
|
|
|
{
|
|
|
|
v = "?";
|
|
|
|
len = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
v += 2;
|
|
|
|
len = strchr (v, ' ') - v;
|
|
|
|
}
|
|
|
|
printf ("\
|
|
|
|
dumper (cygwin) %.*s\n\
|
|
|
|
Core Dumper for Cygwin\n\
|
|
|
|
Copyright 1999, 2001, 2002 Red Hat, Inc.\n", len, v);
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2000-10-28 07:00:00 +02:00
|
|
|
main (int argc, char **argv)
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
|
|
|
int opt;
|
2000-10-28 07:39:38 +02:00
|
|
|
const char *p = "";
|
2000-08-24 21:03:12 +02:00
|
|
|
DWORD pid;
|
2001-09-09 15:18:51 +02:00
|
|
|
char win32_name [MAX_PATH];
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2002-05-08 03:55:56 +02:00
|
|
|
while ((opt = getopt_long (argc, argv, "dqhv", longopts, NULL) ) != EOF)
|
2000-08-24 21:03:12 +02:00
|
|
|
switch (opt)
|
|
|
|
{
|
|
|
|
case 'd':
|
|
|
|
verbose = TRUE;
|
|
|
|
break;
|
2001-09-09 15:18:51 +02:00
|
|
|
case 'q':
|
|
|
|
verbose = FALSE;
|
|
|
|
break;
|
2002-05-08 03:55:56 +02:00
|
|
|
case 'h':
|
|
|
|
usage (stdout, 0);
|
|
|
|
case 'v':
|
|
|
|
print_version ();
|
|
|
|
exit (0);
|
2001-09-09 15:18:51 +02:00
|
|
|
default:
|
2002-05-08 03:55:56 +02:00
|
|
|
usage (stderr, 1);
|
2000-08-24 21:03:12 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-09-09 15:18:51 +02:00
|
|
|
if (argv && *(argv + optind) && *(argv + optind +1))
|
2000-08-24 21:03:12 +02:00
|
|
|
{
|
2001-09-09 15:18:51 +02:00
|
|
|
*win32_name = '\0';
|
|
|
|
cygwin_conv_to_win32_path (*(argv + optind), win32_name);
|
|
|
|
if ((p = strrchr (win32_name, '\\')))
|
|
|
|
p++;
|
|
|
|
else
|
|
|
|
p = win32_name;
|
2001-09-13 17:06:25 +02:00
|
|
|
pid = strtoul (*(argv + optind + 1), NULL, 10);
|
2000-08-24 21:03:12 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2002-05-08 03:55:56 +02:00
|
|
|
usage (stderr, 1);
|
2000-08-24 21:03:12 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-09-09 15:18:51 +02:00
|
|
|
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);
|
|
|
|
|
2000-08-24 21:03:12 +02:00
|
|
|
DWORD tid = 0;
|
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
if (verbose)
|
|
|
|
printf ("dumping process #%lu to %s\n", pid, core_file);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
2000-10-28 07:00:00 +02:00
|
|
|
dumper d (pid, tid, core_file);
|
|
|
|
if (!d.sane ())
|
2000-08-24 21:03:12 +02:00
|
|
|
return -1;
|
|
|
|
d.collect_process_information ();
|
2000-10-28 07:00:00 +02:00
|
|
|
free (core_file);
|
2000-08-24 21:03:12 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
};
|