FAQ Search Today's Posts Mark Forums Read
» Video Reviews

» Linux Archive

Linux-archive is a website aiming to archive linux email lists and to make them easily accessible for linux users/developers.


» Sponsor

» Partners

» Sponsor

Go Back   Linux Archive > Redhat > Crash Utility

 
 
LinkBack Thread Tools
 
Old 03-17-2011, 04:57 AM
Wen Congyang
 
Default use the value of register in the vmcore when we do not find panic task

We have a new hardware to do dump, and use makedumpfile to generate
vmcore. Our hardware can work when the OS is out of controll(for
example: dead loop). When we use crash to analyze the vmcore, bt can
not work, because there is no panic task.

We have provide the value of register in the vmcore(the format is
elf_prstatus, it is same with normal kdump's vmcore). So we can use
it when we do not find panic task.

---
defs.h | 10 +++-
diskdump.c | 118 +++++++++++++++++++++++++++++++++++++++++---
netdump.c | 161 ++++++++++++++++++++++++++++++++++++++++++++++-------------
task.c | 6 ++-
x86.c | 8 +++
x86_64.c | 6 ++
6 files changed, 263 insertions(+), 46 deletions(-)

diff --git a/defs.h b/defs.h
index af3c8ed..b926725 100644
--- a/defs.h
+++ b/defs.h
@@ -1426,6 +1426,7 @@ struct offset_table { /* stash of commonly-used offsets */
long prio_array_queue;
long user_regs_struct_ebp;
long user_regs_struct_esp;
+ long user_regs_struct_eip;
long user_regs_struct_rip;
long user_regs_struct_cs;
long user_regs_struct_eflags;
@@ -4567,13 +4568,16 @@ int xen_major_version(void);
int xen_minor_version(void);
int get_netdump_arch(void);
void *get_regs_from_elf_notes(struct task_context *);
-void map_cpus_to_prstatus(void);
+void map_cpus_to_prstatus(void **, size_t);
int arm_kdump_phys_base(ulong *);
int is_proc_kcore(char *, ulong);
int proc_kcore_init(FILE *);
int read_proc_kcore(int, void *, int, ulong, physaddr_t);
int write_proc_kcore(int, void *, int, ulong, physaddr_t);
int kcore_memory_dump(FILE *);
+void **netdump_get_prstatus(void);
+size_t netdump_get_num_prstatus(void);
+

/*
* diskdump.c
@@ -4595,6 +4599,10 @@ ulong *diskdump_flags;
int is_partial_diskdump(void);
int dumpfile_is_split(void);
void show_split_dumpfiles(void);
+int KDUMP_CMPRS_DUMPFILE(void);
+void **diskdump_get_prstatus(void);
+size_t diskdump_get_num_prstatus(void);
+void *diskdump_get_prstatus_percpu(int);

/*
* makedumpfile.c
diff --git a/diskdump.c b/diskdump.c
index 9a2f37f..074f1d7 100644
--- a/diskdump.c
+++ b/diskdump.c
@@ -49,6 +49,7 @@ struct diskdump_data {
int byte, bit;
char *compressed_page; /* copy of compressed page data */
char *curbufptr; /* ptr to uncompressed page buffer */
+ unsigned char *notes_buf; /* copy of notes */

/* page cache */
struct page_cache_hdr { /* header for each cached page */
@@ -67,6 +68,8 @@ struct diskdump_data {

static struct diskdump_data diskdump_data = { 0 };
static struct diskdump_data *dd = &diskdump_data;
+static unsigned char *nt_prstatus_percpu[NR_CPUS];
+static size_t num_prstatus_notes = 0;
static int get_dump_level(void);

ulong *diskdump_flags = &diskdump_data.flags;
@@ -185,12 +188,86 @@ static int open_dump_file(char *file)
return TRUE;
}

+static size_t dump_elf_note(unsigned char *note_buf, size_t max_size, int machine)
+{
+ Elf64_Nhdr *note64;
+ Elf32_Nhdr *note32;
+ size_t len;
+ unsigned int type;
+ int i;
+
+ if (machine == EM_X86_64) {
+ note64 = (Elf64_Nhdr *)note_buf;
+ len = sizeof(Elf64_Nhdr);
+ len = roundup(len + note64->n_namesz, 4);
+ len = roundup(len + note64->n_descsz, 4);
+ type = note64->n_type;
+ } else {
+ note32 = (Elf32_Nhdr *)note_buf;
+ len = sizeof(Elf32_Nhdr);
+ len = roundup(len + note32->n_namesz, 4);
+ len = roundup(len + note32->n_descsz, 4);
+ type = note32->n_type;
+ }
+ if (len > max_size) {
+ /* this note is broken, do not restore it */
+ return max_size;
+ }
+
+ if (type != NT_PRSTATUS) {
+ /* This note segment does not contain copy of prstatus struct */
+ return len;
+ }
+
+ for (i = 0; i < NR_CPUS; i++) {
+ if (!nt_prstatus_percpu[i]) {
+ nt_prstatus_percpu[i] = (void *)note_buf;
+ num_prstatus_notes++;
+ break;
+ }
+ }
+ return len;
+}
+
+static void process_elf_notes(unsigned char *notes_buf, size_t size, int machine)
+{
+ size_t len = 0;
+ void **nt_ptr;
+ int online, i, j, nrcpus;
+ size_t buf_size;
+
+ while (len < size) {
+ len += dump_elf_note(notes_buf + len, size - len, machine);
+ }
+
+ /* copy from map_cpus_to_prstatus from netdump.c */
+ if (!(online = get_cpus_online()) || (online == kt->cpus))
+ return;
+
+ buf_size = NR_CPUS * sizeof(void *);
+
+ nt_ptr = (void **)GETBUF(buf_size);
+ BCOPY(nt_prstatus_percpu, nt_ptr, buf_size);
+ BZERO(nt_prstatus_percpu, buf_size);
+
+ /*
+ * Re-populate the array with the notes mapping to online cpus
+ */
+ nrcpus = (kt->kernel_NR_CPUS ? kt->kernel_NR_CPUS : NR_CPUS);
+
+ for (i = 0, j = 0; i < nrcpus; i++) {
+ if (in_cpu_map(ONLINE, i))
+ nt_prstatus_percpu[i] = nt_ptr[j++];
+ }
+
+ FREEBUF(nt_ptr);
+}
+
static int read_dump_header(char *file)
{
struct disk_dump_header *header = NULL;
struct disk_dump_sub_header *sub_header = NULL;
struct kdump_sub_header *sub_header_kdump = NULL;
- unsigned char *notes_buf = NULL;
size_t size;
int bitmap_len;
int block_size = (int)sysconf(_SC_PAGESIZE);
@@ -394,16 +471,18 @@ restart:
/* process elf notes data */
if (KDUMP_CMPRS_VALID() && (dd->header->header_version >= 4) &&
(sub_header_kdump->offset_note) &&
- (sub_header_kdump->size_note) && (machdep->process_elf_notes)) {
+ (sub_header_kdump->size_note) &&
+ (machdep->process_elf_notes || dd->machine_type == EM_X86_64 ||
+ dd->machine_type == EM_386)) {
size = sub_header_kdump->size_note;
offset = sub_header_kdump->offset_note;

- if ((notes_buf = malloc(size)) == NULL)
+ if ((dd->notes_buf = malloc(size)) == NULL)
error(FATAL, "compressed kdump: cannot malloc notes"
" buffer
");

if (FLAT_FORMAT()) {
- if (!read_flattened_format(dd->dfd, offset, notes_buf, size)) {
+ if (!read_flattened_format(dd->dfd, offset, dd->notes_buf, size)) {
error(INFO, "compressed kdump: cannot read notes data"
"
");
goto err;
@@ -413,14 +492,19 @@ restart:
error(INFO, "compressed kdump: cannot lseek notes data
");
goto err;
}
- if (read(dd->dfd, notes_buf, size) < size) {
+ if (read(dd->dfd, dd->notes_buf, size) < size) {
error(INFO, "compressed kdump: cannot read notes data"
"
");
goto err;
}
}

- machdep->process_elf_notes(notes_buf, size);
+ if (machdep->process_elf_notes) {
+ /* s390 */
+ machdep->process_elf_notes(dd->notes_buf, size);
+ } else if (dd->machine_type == EM_X86_64 || dd->machine_type == EM_386) {
+ process_elf_notes(dd->notes_buf, size, dd->machine_type);
+ }
}

/* For split dumpfile */
@@ -468,8 +552,6 @@ err:
free(sub_header);
if (sub_header_kdump)
free(sub_header_kdump);
- if (notes_buf)
- free(notes_buf);
if (dd->bitmap)
free(dd->bitmap);
if (dd->dumpable_bitmap)
@@ -1226,3 +1308,23 @@ show_split_dumpfiles(void)
fprintf(fp, "
");
}
}
+
+int KDUMP_CMPRS_DUMPFILE(void)
+{
+ return KDUMP_CMPRS_VALID();
+}
+
+void **diskdump_get_prstatus(void)
+{
+ return (void **)nt_prstatus_percpu;
+}
+
+size_t diskdump_get_num_prstatus(void)
+{
+ return num_prstatus_notes;
+}
+
+void *diskdump_get_prstatus_percpu(int cpu)
+{
+ return nt_prstatus_percpu[cpu];
+}
diff --git a/netdump.c b/netdump.c
index 7916df1..6c1cf13 100644
--- a/netdump.c
+++ b/netdump.c
@@ -59,7 +59,7 @@ static int proc_kcore_init_64(FILE *fp);
* to remap the NT_PRSTATUS notes only to the online cpus.
*/
void
-map_cpus_to_prstatus(void)
+map_cpus_to_prstatus(void **nt_prstatus, size_t num_prstatus)
{
void **nt_ptr;
int online, i, j, nrcpus;
@@ -71,13 +71,13 @@ map_cpus_to_prstatus(void)
if (CRASHDEBUG(1))
error(INFO,
"cpus: %d online: %d NT_PRSTATUS notes: %d (remapping)
",
- kt->cpus, online, nd->num_prstatus_notes);
+ kt->cpus, online, num_prstatus);

size = NR_CPUS * sizeof(void *);

nt_ptr = (void **)GETBUF(size);
- BCOPY(nd->nt_prstatus_percpu, nt_ptr, size);
- BZERO(nd->nt_prstatus_percpu, size);
+ BCOPY(nt_prstatus, nt_ptr, size);
+ BZERO(nt_prstatus, size);

/*
* Re-populate the array with the notes mapping to online cpus
@@ -86,12 +86,22 @@ map_cpus_to_prstatus(void)

for (i = 0, j = 0; i < nrcpus; i++) {
if (in_cpu_map(ONLINE, i))
- nd->nt_prstatus_percpu[i] = nt_ptr[j++];
+ nt_prstatus[i] = nt_ptr[j++];
}

FREEBUF(nt_ptr);
}

+void **netdump_get_prstatus(void)
+{
+ return nd->nt_prstatus_percpu;
+}
+
+size_t netdump_get_num_prstatus(void)
+{
+ return nd->num_prstatus_notes;
+}
+
/*
* Determine whether a file is a netdump/diskdump/kdump creation,
* and if TRUE, initialize the vmcore_data structure.
@@ -2170,60 +2180,71 @@ get_netdump_regs(struct bt_info *bt, ulong *eip, ulong *esp)
}
}

-struct x86_64_user_regs_struct {
- unsigned long r15,r14,r13,r12,rbp,rbx,r11,r10;
- unsigned long r9,r8,rax,rcx,rdx,rsi,rdi,orig_rax;
- unsigned long rip,cs,eflags;
- unsigned long rsp,ss;
- unsigned long fs_base, gs_base;
- unsigned long ds,es,fs,gs;
-};
+/* get regs from elf note, and return the address of user_regs. */
+static char * get_x86_regs_from_note(char *note, ulong *eip, ulong *esp)
+{
+ Elf32_Nhdr *note32;
+ size_t len;
+ char *user_regs;
+
+ note32 = (Elf32_Nhdr *)note;
+ len = sizeof(Elf32_Nhdr);
+ len = roundup(len + note32->n_namesz, 4);
+ len = roundup(len + note32->n_descsz, 4);
+
+ user_regs = note + len - SIZE(user_regs_struct) - sizeof(long);
+ *esp = ULONG(user_regs + OFFSET(user_regs_struct_esp));
+ *eip = ULONG(user_regs + OFFSET(user_regs_struct_eip));
+
+ return user_regs;
+}
+
+static char * get_x86_64_regs_from_note(char *note, ulong *rip, ulong *rsp)
+{
+ Elf64_Nhdr *note64;
+ size_t len;
+ char *user_regs;
+
+ note64 = (Elf64_Nhdr *)note;
+ len = sizeof(Elf64_Nhdr);
+ len = roundup(len + note64->n_namesz, 4);
+ len = roundup(len + note64->n_descsz, 4);
+
+ user_regs = note + len - SIZE(user_regs_struct) - sizeof(long);
+ *rsp = ULONG(user_regs + OFFSET(user_regs_struct_rsp));
+ *rip = ULONG(user_regs + OFFSET(user_regs_struct_rip));
+
+ return user_regs;
+}

void
get_netdump_regs_x86_64(struct bt_info *bt, ulong *ripp, ulong *rspp)
{
Elf64_Nhdr *note;
- size_t len;
char *user_regs;
- ulong regs_size, rsp_offset, rip_offset;
+ ulong rip, rsp;

if (is_task_active(bt->task))
bt->flags |= BT_DUMPFILE_SEARCH;

if (((NETDUMP_DUMPFILE() || KDUMP_DUMPFILE()) &&
VALID_STRUCT(user_regs_struct) && (bt->task == tt->panic_task)) ||
- (KDUMP_DUMPFILE() && (kt->flags & DWARF_UNWIND) &&
- (bt->flags & BT_DUMPFILE_SEARCH))) {
+ (KDUMP_DUMPFILE() && (bt->flags & BT_DUMPFILE_SEARCH))) {
if (nd->num_prstatus_notes > 1)
note = (Elf64_Nhdr *)
nd->nt_prstatus_percpu[bt->tc->processor];
else
note = (Elf64_Nhdr *)nd->nt_prstatus;

- len = sizeof(Elf64_Nhdr);
- len = roundup(len + note->n_namesz, 4);
- len = roundup(len + note->n_descsz, 4);
-
- regs_size = VALID_STRUCT(user_regs_struct) ?
- SIZE(user_regs_struct) :
- sizeof(struct x86_64_user_regs_struct);
- rsp_offset = VALID_MEMBER(user_regs_struct_rsp) ?
- OFFSET(user_regs_struct_rsp) :
- offsetof(struct x86_64_user_regs_struct, rsp);
- rip_offset = VALID_MEMBER(user_regs_struct_rip) ?
- OFFSET(user_regs_struct_rip) :
- offsetof(struct x86_64_user_regs_struct, rip);
-
- user_regs = ((char *)note + len) - regs_size - sizeof(long);
+ user_regs = get_x86_64_regs_from_note((char *)note, &rip, &rsp);

if (CRASHDEBUG(1))
netdump_print("ELF prstatus rsp: %lx rip: %lx
",
- ULONG(user_regs + rsp_offset),
- ULONG(user_regs + rip_offset));
+ rsp, rip);

if (KDUMP_DUMPFILE()) {
- *rspp = ULONG(user_regs + rsp_offset);
- *ripp = ULONG(user_regs + rip_offset);
+ *rspp = rsp;
+ *ripp = rip;

if (*ripp && *rspp)
bt->flags |= BT_KDUMP_ELF_REGS;
@@ -2232,6 +2253,28 @@ get_netdump_regs_x86_64(struct bt_info *bt, ulong *ripp, ulong *rspp)
bt->machdep = (void *)user_regs;
}

+ if (DISKDUMP_DUMPFILE() && (bt->flags & BT_DUMPFILE_SEARCH)) {
+ note = (Elf64_Nhdr *)diskdump_get_prstatus_percpu(bt->tc->processor);
+ if (note == NULL)
+ /* The version of makedumpfile may be less than 4 */
+ goto skip_notes;
+
+ user_regs = get_x86_64_regs_from_note((char *)note, &rip, &rsp);
+
+ if (CRASHDEBUG(1))
+ netdump_print("ELF prstatus rsp: %lx rip: %lx
",
+ rsp, rip);
+
+ *rspp = rsp;
+ *ripp = rip;
+
+ if (*ripp && *rspp)
+ bt->flags |= BT_KDUMP_ELF_REGS;
+
+ bt->machdep = (void *)user_regs;
+ }
+
+skip_notes:
machdep->get_stack_frame(bt, ripp, rspp);
}

@@ -2423,6 +2466,52 @@ next_sysrq:
goto retry;
}

+ if (KDUMP_DUMPFILE()) {
+ Elf32_Nhdr *note;
+ char *user_regs;
+ ulong ip, sp;
+
+ if (nd->num_prstatus_notes > 1)
+ note = (Elf32_Nhdr *)
+ nd->nt_prstatus_percpu[bt->tc->processor];
+ else
+ note = (Elf32_Nhdr *)nd->nt_prstatus;
+
+ user_regs = get_x86_regs_from_note((char *)note, &ip, &sp);
+ bt->flags |= BT_KDUMP_ELF_REGS;
+ if (is_kernel_text(ip) &&
+ (((sp >= GET_STACKBASE(bt->task)) &&
+ (sp < GET_STACKTOP(bt->task))) ||
+ in_alternate_stack(bt->tc->processor, sp))) {
+ *eip = ip;
+ *esp = sp;
+ bt->flags |= BT_KERNEL_SPACE;
+ return;
+ }
+ }
+ if (DISKDUMP_DUMPFILE()) {
+ Elf32_Nhdr *note = (Elf32_Nhdr *)diskdump_get_prstatus_percpu(bt->tc->processor);
+ char *user_regs;
+ ulong ip, sp;
+
+ if (note == NULL)
+ /* The version of makedumpfile may be less than 4 */
+ goto skip_notes;
+
+ user_regs = get_x86_regs_from_note((char *)note, &ip, &sp);
+ bt->flags |= BT_KDUMP_ELF_REGS;
+ if (is_kernel_text(ip) &&
+ (((sp >= GET_STACKBASE(bt->task)) &&
+ (sp < GET_STACKTOP(bt->task))) ||
+ in_alternate_stack(bt->tc->processor, sp))) {
+ *eip = ip;
+ *esp = sp;
+ bt->flags |= BT_KERNEL_SPACE;
+ return;
+ }
+ }
+
+skip_notes:
if (CRASHDEBUG(1))
error(INFO,
"get_netdump_regs_x86: cannot find anything useful (task: %lx)
", bt->task);
diff --git a/task.c b/task.c
index 290463f..de77033 100644
--- a/task.c
+++ b/task.c
@@ -457,7 +457,11 @@ task_init(void)
}
else {
if (KDUMP_DUMPFILE())
- map_cpus_to_prstatus();
+ map_cpus_to_prstatus(netdump_get_prstatus(),
+ netdump_get_num_prstatus());
+ if (KDUMP_CMPRS_DUMPFILE())
+ map_cpus_to_prstatus(diskdump_get_prstatus(),
+ diskdump_get_num_prstatus());
please_wait("determining panic task");
set_context(get_panic_context(), NO_PID);
please_wait_done();
diff --git a/x86.c b/x86.c
index ab2e7f3..e6fa2e2 100644
--- a/x86.c
+++ b/x86.c
@@ -1798,6 +1798,12 @@ x86_init(int when)
else
MEMBER_OFFSET_INIT(user_regs_struct_esp,
"user_regs_struct", "sp");
+ if (MEMBER_EXISTS("user_regs_struct", "eip"))
+ MEMBER_OFFSET_INIT(user_regs_struct_eip,
+ "user_regs_struct", "eip");
+ else
+ MEMBER_OFFSET_INIT(user_regs_struct_eip,
+ "user_regs_struct", "ip");
if (!VALID_STRUCT(user_regs_struct)) {
/* Use this hardwired version -- sometimes the
* debuginfo doesn't pick this up even though
@@ -1818,6 +1824,8 @@ x86_init(int when)
offsetof(struct x86_user_regs_struct, ebp);
ASSIGN_OFFSET(user_regs_struct_esp) =
offsetof(struct x86_user_regs_struct, esp);
+ ASSIGN_OFFSET(user_regs_struct_eip) =
+ offsetof(struct x86_user_regs_struct, eip);
}
MEMBER_OFFSET_INIT(thread_struct_cr3, "thread_struct", "cr3");
STRUCT_SIZE_INIT(cpuinfo_x86, "cpuinfo_x86");
diff --git a/x86_64.c b/x86_64.c
index 853a1aa..48864f9 100644
--- a/x86_64.c
+++ b/x86_64.c
@@ -4009,6 +4009,12 @@ x86_64_get_dumpfile_stack_frame(struct bt_info *bt_in, ulong *rip, ulong *rsp)
goto skip_stage;
}
}
+ } else if (bt->machdep) {
+ user_regs = bt->machdep;
+ ur_rip = ULONG(user_regs +
+ OFFSET(user_regs_struct_rip));
+ ur_rsp = ULONG(user_regs +
+ OFFSET(user_regs_struct_rsp));
}

panic = FALSE;
--
1.7.1

--
Crash-utility mailing list
Crash-utility@redhat.com
https://www.redhat.com/mailman/listinfo/crash-utility
 
Old 03-17-2011, 07:59 PM
Dave Anderson
 
Default use the value of register in the vmcore when we do not find panic task

----- Original Message -----
> We have a new hardware to do dump, and use makedumpfile to generate
> vmcore. Our hardware can work when the OS is out of controll(for
> example: dead loop). When we use crash to analyze the vmcore, bt can
> not work, because there is no panic task.
>
> We have provide the value of register in the vmcore(the format is
> elf_prstatus, it is same with normal kdump's vmcore). So we can use
> it when we do not find panic task.

Let me state first that I get very nervous when patches are
made to commonly used functions to handle special cases such
as this. When those kinds of changes are proposed, I much prefer
that the new code *only* apply to the special cases, and should
not affect anything else.

I do not have any x86 or x86_64 compressed kdumps that
contain ELF note data, so I cannot really test this patch.
However, when I do run this patch against a sample set
of ~150 x86_64 dumpfiles, I see errors on simple backtraces
such as the following examples.

Without the patch:

crash> bt ffff81007e54c100
PID: 0 TASK: ffff81007e54c100 CPU: 1 COMMAND: "swapper"
#0 [ffff81007e565ef0] cpu_idle at ffffffff80047282
crash>

With your patch:

crash> bt ffff81007e54c100
PID: 0 TASK: ffff81007e54c100 CPU: 1 COMMAND: "swapper"
Segmentation fault

And it doesn't work with Xen kernels very well.

Without the patch:

crash> bt ffff8800009c0040
PID: 0 TASK: ffff8800009c0040 CPU: 1 COMMAND: "swapper"
#0 [ffff88001d485ef8] safe_halt at ffffffff8011004c
#1 [ffff88001d485f28] xen_idle at ffffffff801092f4
#2 [ffff88001d485f38] cpu_idle at ffffffff801093b5
crash>

With your patch:

crash> bt ffff8800009c0040
PID: 0 TASK: ffff8800009c0040 CPU: 1 COMMAND: "swapper"
bt: cannot determine starting stack pointer
crash>

Without the patch:

crash> bt -a
... [ cut ] ...

PID: 0 TASK: ffff880000017040 CPU: 1 COMMAND: "swapper"
#0 [ffff880033983f38] xen_idle at ffffffff8026c502
#1 [ffff880033983f48] cpu_idle at ffffffff8024a982

PID: 0 TASK: ffff8800000037e0 CPU: 2 COMMAND: "swapper"
#0 [ffff880033987f38] xen_idle at ffffffff8026c502
#1 [ffff880033987f48] cpu_idle at ffffffff8024a982

PID: 0 TASK: ffff880000003080 CPU: 3 COMMAND: "swapper"
#0 [ffff880033989f38] xen_idle at ffffffff8026c502
#1 [ffff880033989f48] cpu_idle at ffffffff8024a982

With your patch:

crash> bt -a
... [ cut ] ...

PID: 0 TASK: ffff880000017040 CPU: 1 COMMAND: "swapper"
bt: cannot determine starting stack pointer

PID: 0 TASK: ffff8800000037e0 CPU: 2 COMMAND: "swapper"
bt: cannot determine starting stack pointer

PID: 0 TASK: ffff880000003080 CPU: 3 COMMAND: "swapper"
bt: cannot determine starting stack pointer
crash>

So my point is that given that *none* of these kernels even
contain makedumpfile-generated ELF data -- so your code should
*not* affect them at all.

That being the case, I cannot accept the patch as it is currently
written. Things work fine as things are now, and I'm not interested
in debugging things that break because your patch changes current
behavior.

Here are my two major suggestions:

(1) If it is determined during the initial dumpfile scan that
it contains ELF note data, then set a global flag, perhaps
in the new pc->flags2, something like MAKEDUMPFILE_ELF_NOTES.

(2) Then, segregate your changes *completely* based upon that
flag. I would rather have essentially-redundant code put in
place instead of breaking currently-existing code.

That way, for all dumpfiles where the MAKEDUMPFILE_ELF_NOTES flag
is *not* set, then your code should *not* run.

And here are a few specific comments:

(1) The machdep->process_elf_notes handler was put in place for
this kind of thing, so please continue to use it for x86 and
x86_64 in the same way that the s390x architecture does.
You don't need to pass the machine type as an extra argument,
given that "machine_type()" can be used anywhere. The two
arches can share the same handler.

(2) get_netdump_regs_x86_64: segregate the code based upon the
MAKEDUMPFILE_ELF_NOTES flag.

(3) get_netdump_regs_x86(): segregate the code based upon the
MAKEDUMPFILE_ELF_NOTES flag.

(4) Make a new map_cpus_to_prstatus()-type function for this kind
of dumpfile. In task_init(), you can check the MAKEDUMPFILE_ELF_NOTES
flag and call the new function, and so you won't need your new
KDUMP_CMPRS_DUMPFILE() function.

(5) x86_64_get_dumpfile_stack_frame(): use the MAKEDUMPFILE_ELF_NOTES
flags instead of bt->machdep.

And two final requests:

(1) Before posting the patch, please build your changes with "make warn".
Your changes generate a few warnings.

(2) Can make your patches attachments to your email instead of inline?

Thanks,
Dave

--
Crash-utility mailing list
Crash-utility@redhat.com
https://www.redhat.com/mailman/listinfo/crash-utility
 

Thread Tools




All times are GMT. The time now is 12:35 AM.

VBulletin, Copyright ©2000 - 2014, Jelsoft Enterprises Ltd.
Content Relevant URLs by vBSEO ©2007, Crawlability, Inc.
Copyright 2007 - 2008, www.linux-archive.org