kgdb support in vanilla 2.6.2
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 2 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Also what's also ugly in i386 is that it uses ugly hooks in traps.c/fault.c. On x86-64 I instead added generic notifiers (see include/asm-x86_64/die.h and notify_die in arch/x86_64/kernel/traps.c)
where both kdb and kgdb and possibly dprobes and other debuggers can hook in without conflicting patches for the same files from everybody. I would strongly suggest to adopt such a generic framework for i386 too to clean up the core kernel <-> debugger interaction. As soon as this frame work is in just dropping the stub is is very clean.
The x86-64 version should be pretty simple to port to i386 if someone is interested ...
Another issue is that for modern gdb and frame pointer less debugging with dwarf2 we really need dwarf2 cfi annotation on i386 too. It is not as ugly as it used to be because newer binutils have much nicer to use .cfi_* mnemonics to generate the dwarf2 unwind table. x86-64 uses that now thanks to Jim Houston. It only works with uptodate binutils, but I guess that's a reasonable requirement. It's a bit intrusive in entry.S, but not too bad compared to the old way (take a look at arch/i386/kernel/vsyscall-sysenter.S to see how the old way looks like) Having the dwarf2 unwind information in the kernel vmlinux is useful even independent of kgdb for other tools that look at crash dumps.
-Andi
Hi!
Quoted 18 lines
Quoted 2 lines
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Also what's also ugly in i386 is that it uses ugly hooks in
traps.c/fault.c. On x86-64 I instead added generic notifiers (seeinclude/asm-x86_64/die.handnotify_dieinarch/x86_64/kernel/traps.c)
where both kdb and kgdb and possibly dprobes and other debuggers can hook in without conflicting patches for the same files from everybody. I would strongly suggest to adopt such a generic framework for i386 too to clean up the core kernel <-> debugger interaction. As soon as this frame work is in just dropping the stub is is very clean.
Quoted 2 lines
The x86-64 version should be pretty simple to port to i386 if someone is interested ...
Hmm, this tells me that perhaps it is reasonable to get amd64 version in first, since it received lot of cleaning already...
Pavel
Signature · 2 lines
When do you have a heart between your knees? [Johanka's followup: and *two* hearts?]
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
I use the global to let page fault handler that this access is from kgdb so don't try to load any pages, report an error instead.
Quoted 9 lines
Also what's also ugly in i386 is that it uses ugly hooks in
traps.c/fault.c. On x86-64 I instead added generic notifiers (seeinclude/asm-x86_64/die.handnotify_dieinarch/x86_64/kernel/traps.c) where both kdb and kgdb and possibly dprobes and other debuggers can hook in without conflicting patches for the same files from everybody. I would strongly suggest to adopt such a generic framework for i386 too to clean up the core kernel <-> debugger interaction. As soon as this frame work is in just dropping the stub is is very clean.
I liked these. Never got time to integrate them.
Quoted 4 lines
The x86-64 version should be pretty simple to port to i386 if someone is interested ...
Quoted 11 lines
Another issue is that for modern gdb and frame pointer less debugging with dwarf2 we really need dwarf2 cfi annotation on i386 too. It is not as ugly as it used to be because newer binutils have much nicer to use .cfi_* mnemonics to generate the dwarf2 unwind table. x86-64 uses that now thanks to Jim Houston. It only works with uptodate binutils, but I guess that's a reasonable requirement. It's a bit intrusive in
entry.S, but not too bad compared to the old way (take a look atarch/i386/kernel/vsyscall-sysenter.Sto see how the old way looks like) Having the dwarf2 unwind information in the kernel vmlinux is useful even independent of kgdb for other tools that look at crash dumps.
George has coded cfi directives i386 too. He can use them to backtrace past irqs stack.
Signature · 3 lines
Amit Kale EmSysSoft (http://www.emsyssoft.com) KGDB: Linux Kernel Source Level Debugger (http://kgdb.sourceforge.net)
Quoted 12 lines · On Thu, 5 Feb 2004 23:20:04 +0530 "Amit S. Kale" <[email protected]> wrote:
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Modern i386 kernels don't grab the mm semaphore when the access is >= TASK_SIZE and the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
Quoted 2 lines
George has coded cfi directives i386 too. He can use them to backtrace past irqs stack.
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
-Andi
Quoted 19 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 12 lines · Amit S. Kale
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 5 lines
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZEand the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
OK. It don't deadlock when kgdb accesses kernel addresses.
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
-Amit
Quoted 9 lines
Quoted 3 lines
George has coded cfi directives i386 too. He can use them to backtrace past irqs stack.
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
-Andi
Quoted 26 lines · On Fri, 6 Feb 2004 17:28:36 +0530 "Amit S. Kale" <[email protected]> wrote:
Quoted 19 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 12 lines · Amit S. Kale
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 5 lines
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZEand the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
Quoted 4 lines
OK. It don't deadlock when kgdb accesses kernel addresses.
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
-Andi
Quoted 31 lines · Andi Kleen
On Fri, 6 Feb 2004 17:28:36 +0530
Quoted 28 lines · Amit S. Kale
Quoted 19 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 12 lines · Amit S. Kale
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 5 lines
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZEand the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.OK. It don't deadlock when kgdb accesses kernel addresses.
Quoted 7 lines
Quoted 3 lines
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
Let kgdb refuse to access any addresses below TASK_SIZE. That's better than accidentally typing something and getting lost.
I guess preventing user address accesses is lesser evil compared to using a debugger global.
gdb itself may access user addresses in following scenarios. Not allowing user accesses doesn't hurt as gdb can accept that and recover gracefully.
1. When a function parameter contains a char pointer.
GDB prints the string pointed to by a function parameter when printing frame for the function.
2. If a kernel variable points to a user string, print command will show its contents, unless user explicitely says print/x.
3. When a stack trace goes beyond an interrupt or an exception entrypoint:
The gdb at kgdb.sourceforge.net has some patchup for this problem, though it doesn't work all the time. Sometimes we do endup seeing one invalid stack frame for which gdb has accessed a user address.
-Amit
Quoted 36 lines · On Fri, 6 Feb 2004 18:35:16 +0530 "Amit S. Kale" <[email protected]> wrote:
Quoted 35 lines · Andi Kleen
On Fri, 6 Feb 2004 17:28:36 +0530
Quoted 31 lines · Amit S. Kale
Quoted 19 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 12 lines · Amit S. Kale
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 5 lines
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZEand the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.OK. It don't deadlock when kgdb accesses kernel addresses.
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Quoted 6 lines
Quoted 3 lines
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
Let kgdb refuse to access any addresses below
TASK_SIZE. That's better than accidentally typing something and getting lost.
That's fine. But can you perhaps add a magic command that enables it again? I could imagine in a few cases it will be useful because there may be pages mapped into the user address space that are not in the direct mapping (that's mainly on 32bit of course, on amd64 you can always access all memory using mappings >TASK_SIZE)
-Andi
Quoted 39 lines · Andi Kleen
On Fri, 6 Feb 2004 18:35:16 +0530
Quoted 36 lines · Amit S. Kale
Quoted 35 lines · Andi Kleen
On Fri, 6 Feb 2004 17:28:36 +0530
Quoted 31 lines · Amit S. Kale
Quoted 19 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 12 lines · Amit S. Kale
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 5 lines
Modern i386 kernels don't grab the mm semaphore when the access is
Quoted 1 line
=
TASK_SIZEand the access came from kernel space (actually I seex86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
OK. It don't deadlock when kgdb accesses kernel addresses.
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
Let kgdb refuse to access any addresses below
TASK_SIZE. That's better than accidentally typing something and getting lost.That's fine. But can you perhaps add a magic command that enables it again?
Yes. This sounds good.
-Amit
Quoted 6 lines
I could imagine in a few cases it will be useful because there may be pages mapped into the user address space that are not in the direct mapping (that's mainly on 32bit of course, on amd64 you can always access all memory using mappings >TASK_SIZE)
-Andi
Quoted 54 lines · Amit S. Kale
Quoted 52 lines · Andi Kleen
On Fri, 6 Feb 2004 18:35:16 +0530
Quoted 48 lines · Amit S. Kale
Quoted 45 lines · Andi Kleen
On Fri, 6 Feb 2004 17:28:36 +0530
Quoted 32 lines · Amit S. Kale
Quoted 22 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 14 lines · Amit S. Kale
Quoted 11 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 7 lines
Modern i386 kernels don't grab the mm semaphore when the access is
Quoted 1 line
=
TASK_SIZEand the access came from kernel space (actually I seex86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
Quoted 5 lines
OK. It don't deadlock when kgdb accesses kernel addresses.
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
Quoted 7 lines
Quoted 4 lines
Quoted 2 lines
Let kgdb refuse to access any addresses below
TASK_SIZE. That's better than accidentally typing something and getting lost.That's fine. But can you perhaps add a magic command that enables it again?
Yes. This sounds good.
This could be a flag in the kgdb_info structure. See -mm kgdb. Does not require any new commands as it is just a global the user can change.
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 50 lines · George Anzinger
Quoted 49 lines · Amit S. Kale
Quoted 48 lines · Andi Kleen
On Fri, 6 Feb 2004 18:35:16 +0530
Quoted 44 lines · Amit S. Kale
Quoted 33 lines · Andi Kleen
On Fri, 6 Feb 2004 17:28:36 +0530
Quoted 30 lines · Amit S. Kale
Quoted 19 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 12 lines · Amit S. Kale
Quoted 10 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 7 lines
Modern i386 kernels don't grab the mm semaphore when the access is
Quoted 1 line
=
TASK_SIZEand the access came from kernel space (actually I seex86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
OK. It don't deadlock when kgdb accesses kernel addresses.
Quoted 7 lines
Quoted 3 lines
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
Let kgdb refuse to access any addresses below
TASK_SIZE. That's better than accidentally typing something and getting lost.
Quoted 7 lines
Quoted 4 lines
Quoted 2 lines
That's fine. But can you perhaps add a magic command that enables it again?
Yes. This sounds good.
This could be a flag in the
kgdb_infostructure. See -mm kgdb. Does not require any new commands as it is just a global the user can change.
Having all user modifiable variables in one place is definitely a good idea. Need to do this sometime.
-Amit
Quoted 65 lines · Amit S. Kale
Quoted 63 lines · George Anzinger
Quoted 61 lines · Amit S. Kale
Quoted 58 lines · Andi Kleen
On Fri, 6 Feb 2004 18:35:16 +0530
Quoted 45 lines · Amit S. Kale
Quoted 43 lines · Andi Kleen
On Fri, 6 Feb 2004 17:28:36 +0530
Quoted 38 lines · Amit S. Kale
Quoted 22 lines · Andi Kleen
On Thu, 5 Feb 2004 23:20:04 +0530
Quoted 14 lines · Amit S. Kale
Quoted 11 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Quoted 8 lines
Modern i386 kernels don't grab the mm semaphore when the access is
Quoted 1 line
=
TASK_SIZEand the access came from kernel space (actually I seex86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
OK. It don't deadlock when kgdb accesses kernel addresses.
When a user space address is accessed through kgdb, won't the kernel attempt to fault in the user page? We don't want that to happen inside kgdb.
Quoted 6 lines
Quoted 3 lines
Yes, it will. But I don't think it's a bad thing. If the users doesn't want that they should not follow user addresses. After all kgdb is for people who know what they are doing.
Let kgdb refuse to access any addresses below
TASK_SIZE. That's better than accidentally typing something and getting lost.That's fine. But can you perhaps add a magic command that enables it again?
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
Yes. This sounds good.
This could be a flag in the
kgdb_infostructure. See -mm kgdb. Does not require any new commands as it is just a global the user can change.Having all user modifiable variables in one place is definitely a good idea. Need to do this sometime.
I also put the discovered status of each cpu other than the current one here. The structure is explained in the documentation part of the -mm patch. Another thing I put here and have found to be very useful is the address that the stub was called from. Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such. I have found, on occasion, that knowing this info has been key to understanding what was wrong.
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 3 lines · George Anzinger
Often it is not clear just why we are in the stub, given that
we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
Quoted 7 lines · Andrew Morton
Quoted 1 line · George Anzinger
Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
That assumes that one can do a printk and not run into a lock. Far better IMNSHO is to provide a simple way to get it from gdb. One can then even provide a gdb macro to print the relevant source line and its surrounds. I my lighter moments I call this the comefrom macro :) In my kgdb it would look like:
l * kgdb_info.called_from
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 9 lines · George Anzinger
Quoted 7 lines · Andrew Morton
Quoted 3 lines · George Anzinger
Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
Quoted 7 lines
That assumes that one can do a printk and not run into a lock. Far better IMNSHO is to provide a simple way to get it from gdb. One can then even provide a gdb macro to print the relevant source line and its surrounds. I my lighter moments I call this the comefrom macro :) In my kgdb it would look like:
l * kgdb_info.called_from
How about echoing "Waiting for gdb connection" stright into the serial line without any encoding? Since gdb won't be connected to the other end, and many a times a minicom could be running at the other end, it'll give a user an indication of kgdb being ready.
Signature · 3 lines
Amit Kale EmSysSoft (http://www.emsyssoft.com) KGDB: Linux Kernel Source Level Debugger (http://kgdb.sourceforge.net)
Quoted 16 lines · Amit S. Kale
Quoted 15 lines · George Anzinger
Quoted 7 lines · Andrew Morton
Quoted 3 lines · George Anzinger
Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
That assumes that one can do a printk and not run into a lock. Far better IMNSHO is to provide a simple way to get it from gdb. One can then even provide a gdb macro to print the relevant source line and its surrounds. I my lighter moments I call this the comefrom macro :) In my kgdb it would look like:
Quoted 6 lines
Quoted 1 line
l * kgdb_info.called_from
How about echoing "Waiting for gdb connection" stright into the serial line without any encoding? Since gdb won't be connected to the other end, and many a times a minicom could be running at the other end, it'll give a user an indication of kgdb being ready.
It's not "GDB is ready" it's "GDB is ready now because ..."
Signature · 2 lines
Tom Rini http://gate.crashing.org/~trini/
Quoted 19 lines · Amit S. Kale
Quoted 17 lines · George Anzinger
Quoted 8 lines · Andrew Morton
Quoted 3 lines · George Anzinger
Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
That assumes that one can do a printk and not run into a lock. Far better IMNSHO is to provide a simple way to get it from gdb. One can then even provide a gdb macro to print the relevant source line and its surrounds. I my lighter moments I call this the comefrom macro :) In my kgdb it would look like:
Quoted 4 lines
Quoted 1 line
l * kgdb_info.called_from
How about echoing "Waiting for gdb connection" stright into the serial line without any encoding? Since gdb won't be connected to the other end, and many a times a minicom could be running at the other end, it'll give a user an indication of kgdb being ready.
Uh, different solution for a different problem. The above command to gdb causes the source code around the location "kgdb_info.called_from" to be displayed. In the -mm version, this is location is filled in by kgdb with the return address for the "kgdb_handle_exception()". This allows you to see just why you are in kgdb.
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 7 lines · Andrew Morton
Quoted 3 lines · George Anzinger
Often it is not clear just why we are in the stub, given that
we trap such things as kernel page faults, NMI watchdog, BUG macros and such.Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
What I did for kdb and panic some time ago was to flash the keyboard lights. If you use a unique frequency (different from kdb and from panic) it works quite nicely.
-Andi
Quoted 4 lines · Andi Kleen
Quoted 2 lines · Andrew Morton
George Anzinger <[email protected]> wrote:
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
What I did for kdb and panic some time ago was to flash the keyboard
lights. If you use a unique frequency (different from kdb and from panic) it works quite nicely.
Assuming a key board and a clear (no spin locks) path to it. Still it only says we are in kgdb, now why.
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 12 lines · On Wed, 03 Mar 2004 16:43:47 -0800 George Anzinger <[email protected]> wrote:
Quoted 11 lines · Andi Kleen
Quoted 7 lines · Andrew Morton
Quoted 2 lines · George Anzinger
Often it is not clear just why we are in the stub, given that
we trap such things as kernel page faults, NMI watchdog, BUG macros and such.Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
Quoted 5 lines
Quoted 3 lines
What I did for kdb and panic some time ago was to flash the keyboard lights. If you use a unique frequency (different from kdb and from panic) it works quite nicely.
Assuming a key board and a clear (no spin locks) path to it. Still it only says
I think it's reasonable to just write to the keyboard without any locking. The keyboard driver will recover.
Quoted 1 line
we are in kgdb, now why.
The big advantage is that it works even when you are in X (like most people) printks are often not visible.
-Andi
Quoted 1 line
Quoted 16 lines · Andi Kleen
On Wed, 03 Mar 2004 16:43:47 -0800
Quoted 13 lines · George Anzinger
Quoted 12 lines · Andi Kleen
Quoted 7 lines · Andrew Morton
Quoted 3 lines · George Anzinger
Often it is not clear just why we are in the stub, given that we trap such things as kernel page faults, NMI watchdog, BUG macros and such.
Yes, that can be confusing. A little printk on the console prior to entering the debugger would be nice.
What I did for kdb and panic some time ago was to flash the keyboard lights. If you use a unique frequency (different from kdb and from panic) it works quite nicely.
Flashing keyboard lights is far simpler compared to a printk. Printk is too heavy. Once a system is unstable, it's more important to run into kgdb code asap. Calling printk and co may be too much.
Quoted 6 lines
Quoted 3 lines
Assuming a key board and a clear (no spin locks) path to it. Still it only says
I think it's reasonable to just write to the keyboard without any locking. The keyboard driver will recover.
Flashing keyboard lights is easy on x86 and x86_64 platforms. Is that easy on ppc workstations/servers? Embedded boards don't have keyboards.
Quoted 5 lines
Quoted 2 lines
we are in kgdb, now why.
The big advantage is that it works even when you are in X (like most people) printks are often not visible.
Yep.
Signature · 3 lines
Amit Kale EmSysSoft (http://www.emsyssoft.com) KGDB: Linux Kernel Source Level Debugger (http://kgdb.sourceforge.net)
Quoted 2 lines · Amit S. Kale
Flashing keyboard lights is easy on x86 and
x86_64platforms.
Please, no keyboards. Some people want to be able to use kgdboe to find out why machine number 324 down the corridor just died.
How about just doing
char *why_i_crashed;
{
...
if (expr1)
why_i_crashed = "hit a BUG";
else if (expr2)
why_i_crashed = "divide by zero";
else ...
}then provide a gdb macro which prints out the string at *why_i_crashed?
Quoted 21 lines · Andrew Morton
Quoted 1 line · Amit S. Kale
Flashing keyboard lights is easy on x86 and
x86_64platforms.Please, no keyboards. Some people want to be able to use kgdboe to find out why machine number 324 down the corridor just died.
How about just doing
char
*why_i_crashed;{ ... if (expr1) why_i_crashed = "hit a BUG"; else if (expr2) why_i_crashed = "divide by zero"; else ... }
Quoted 1 line
then provide a gdb macro which prints out the string at
*why_i_crashed?
If we can afford to do this (in terms of actions that can be done with the machine being unstable) we can certainly print a console message through gdb.
A stub is free to send console messages to gdb at any time. We can send a "'O'hex(Page fault at 0x1234)" packet to gdb regardless of whether CONFIG_KGDB_CONSOLE is configured in. This way kgdb will send this packet to gdb and then immediately report a segfault/trap. To a user it'll appear as a message printed from gdb "Page fault at 0x1234" followed by gdb showing a SIGSEGV etc. The gdb console message should print information other than a signal number.
-Amit
Quoted 4 lines · Amit S. Kale
To a user it'll appear as a
message printed from gdb "Page fault at0x1234" followed by gdb showing a SIGSEGV etc.
Well that would be nice. Bear in mind that one usage scenario is to say "hey, machine 342 has stopped responding" and to then fire up gdb and connect to that machine with kgdboe.
In other words: if we rely on a gdb instance being connected at the time of the exception, that message will be lost. There needs to be a way of retrieving the message post-facto.
Quoted 24 lines · Amit S. Kale
Quoted 22 lines · Andrew Morton
Quoted 1 line · Amit S. Kale
Flashing keyboard lights is easy on x86 and
x86_64platforms.Please, no keyboards. Some people want to be able to use kgdboe to find out why machine number 324 down the corridor just died.
How about just doing
char
*why_i_crashed;{ ... if (expr1) why_i_crashed = "hit a BUG"; else if (expr2) why_i_crashed = "divide by zero"; else ... }
Quoted 4 lines
Quoted 1 line
then provide a gdb macro which prints out the string at
*why_i_crashed?If we can afford to do this (in terms of actions that can be done with the machine being unstable) we can certainly print a console message through gdb.
Not once you are connected to gdb. The "O" packet can only be sent if the program (i.e. kernel) is running as far as gdb knows. So you could preceed a connection with this, but could not used it after gdb knows the kernel is stopped.
Quoted 5 lines
A stub is free to send console messages to gdb at any time. We can send a "'O'hex(Page fault at
0x1234)" packet to gdb regardless of whetherCONFIG_KGDB_CONSOLEis configured in. This way kgdb will send this packet to gdb and then immediately report a segfault/trap. To a user it'll appear as a message printed from gdb "Page fault at0x1234" followed by gdb showing a SIGSEGV etc. The gdb console message should print information other than a signal number.-Amit
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 28 lines · George Anzinger
Quoted 27 lines · Amit S. Kale
Quoted 23 lines · Andrew Morton
Quoted 1 line · Amit S. Kale
Flashing keyboard lights is easy on x86 and
x86_64platforms.Please, no keyboards. Some people want to be able to use kgdboe to find out why machine number 324 down the corridor just died.
How about just doing
char
*why_i_crashed;{ ... if (expr1) why_i_crashed = "hit a BUG"; else if (expr2) why_i_crashed = "divide by zero"; else ... }then provide a gdb macro which prints out the string at
*why_i_crashed?
Quoted 8 lines
Quoted 3 lines
If we can afford to do this (in terms of actions that can be done with the machine being unstable) we can certainly print a console message through gdb.
Not once you are connected to gdb. The "O" packet can only be sent if the program (i.e. kernel) is running as far as gdb knows. So you could preceed a connection with this, but could not used it after gdb knows the kernel is stopped.
If GDB is already connected and sitting by waiting, you can send the O packet. If it is not, you could delay sending the O packet until you know that GDB has now connected.
This isn't an unworkable idea, but it's probably better to just set *why_i_crashed (think work work work, oh wait, what caused this again?) and provide some handy macros (which we should be in the docs anyhow).
Signature · 2 lines
Tom Rini http://gate.crashing.org/~trini/
Quoted 38 lines · Tom Rini
Quoted 28 lines · George Anzinger
Quoted 26 lines · Amit S. Kale
Quoted 23 lines · Andrew Morton
Quoted 1 line · Amit S. Kale
Flashing keyboard lights is easy on x86 and
x86_64platforms.Please, no keyboards. Some people want to be able to use kgdboe to find out why machine number 324 down the corridor just died.
How about just doing
char
*why_i_crashed;{ ... if (expr1) why_i_crashed = "hit a BUG"; else if (expr2) why_i_crashed = "divide by zero"; else ... }Quoted 6 lines
Quoted 4 lines
Quoted 1 line
then provide a gdb macro which prints out the string at
*why_i_crashed?If we can afford to do this (in terms of actions that can be done with the machine being unstable) we can certainly print a console message through gdb.
Not once you are connected to gdb. The "O" packet can only be sent if the program (i.e. kernel) is running as far as gdb knows. So you could preceed a connection with this, but could not used it after gdb knows the kernel is stopped.
Quoted 7 lines
If GDB is already connected and sitting by waiting, you can send the O packet. If it is not, you could delay sending the O packet until you know that GDB has now connected.
This isn't an unworkable idea, but it's probably better to just set
*why_i_crashed(think work work work, oh wait, what caused this again?) and provide some handy macros (which we should be in the docs anyhow).
Well, I did provide a "come_from" macro, but more definition could be had...
On the subject of macros, I am being convinced by the gdb folks that the way to do the info threads thing is with macros. We get almost all we want this way without messing with gdb or lying to it the way the -mm kgdb does.
Quoted 1 line
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 6 lines · On Wed, 3 Mar 2004 21:18:50 -0800 Andrew Morton <[email protected]> wrote:
Quoted 2 lines · Amit S. Kale
Flashing keyboard lights is easy on x86 and
x86_64platforms.Please, no keyboards. Some people want to be able to use kgdboe to find out why machine number 324 down the corridor just died.
Not as the only indication I agree. But for machines running X that are actually used by people I think it's important to always give some kind of visual feedback when the X server freezes. And kgdb will make the X server freeze. You could actually make it a notifier list to register severals ways to do this, e.g. the cluster people could add something that makes it flash a warning light. For a standard box I think flashing the keyboard is a good default for now
(ok there are USB keyboards too, for those there will need to be a different solution)
Quoted 13 lines
char
*why_i_crashed;{ ... if (expr1) why_i_crashed = "hit a BUG"; else if (expr2) why_i_crashed = "divide by zero"; else ... }
Quoted 1 line
then provide a gdb macro which prints out the string at
*why_i_crashed?
That doesn't tell the user at all why his X server just froze. But it may be a good addition.
-Andi
Quoted 5 lines · Andi Kleen
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Done in this version of kgdb.
Signature · 3 lines
Amit Kale EmSysSoft (http://www.emsyssoft.com) KGDB: Linux Kernel Source Level Debugger (http://kgdb.sourceforge.net)
Quoted 27 lines · Andi Kleen
Quoted 8 lines · On Thu, 5 Feb 2004 23:20:04 +0530 "Amit S. Kale" <[email protected]> wrote:
Quoted 6 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
Quoted 7 lines
Quoted 5 lines
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZE
and the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.
Quoted 6 lines
Quoted 1 line
George has coded cfi directives i386 too. He can use them to backtrace past irqs stack.
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
Well, bin utils, at this time, makes it even worse in that it does not support the expression syntax. Also, it is not asm but dwarf2 and it is written in, IMHO, useful macros (not hex :)
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 7 lines · On Tue, 10 Feb 2004 13:56:24 -0800 George Anzinger <[email protected]> wrote:
Quoted 3 lines
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
Well, bin utils, at this time, makes it even worse in that it does not support the expression syntax. Also, it is not asm but dwarf2 and it is written in, IMHO, useful macros (not hex :)
The latest binutils should support .cfi_* for i386 too. I don't see much sense in making the code more ugly just for staying backwards compatible with older versions for the debug case (without CONFIG_DEBUG_INFO it should be compatible though).
You need a fairly new gdb too anyways for it.
-Andi
Quoted 8 lines · Andi Kleen
Quoted 4 lines · On Tue, 10 Feb 2004 13:56:24 -0800 George Anzinger <[email protected]> wrote:
Quoted 3 lines
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
Quoted 6 lines
Quoted 1 line
Well, bin utils, at this time, makes it even worse in that it does not support the expression syntax. Also, it is not asm but dwarf2 and it is written in, IMHO, useful macros (not hex :)
The latest binutils should support .cfi_* for i386 too. I don't see much sense
in making the code more ugly just for staying backwards compatible with older versions for the debug case (withoutCONFIG_DEBUG_INFOit should be compatible though). You need a fairly new gdb too anyways for it.
Well, yes, the CVS version I mentioned in my patch is needed as I found a bug in the expression analizer. I am NOT trying to say compatable with old tools. I AM trying to do something the CURRENT tools make hard to impossible.
The problem with the gas CFI support is that it does not provide a way to define CFI expressions which are needed to determine if the CFI address should be zero (i.e. the return is to user space) or the current adjusted stack address.
I suppose the open ended .cfi_ thing could be used but it requires that you compute your own sleb128 and uleb128 values. It is also not clear how you tell this thing if you want a word or a half word as the dwarf2 spec requires. More info on this would be very "nice". I really would like to do this with out the dwarf2 macros, but, please understand, one of the main reasons for the effort was to tie off the bottom of the stack and that seems to require an expression capability for the asm code in entry.S.
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Quoted 5 lines · On Wed, 11 Feb 2004 17:34:13 -0800 George Anzinger <[email protected]> wrote:
Quoted 4 lines
The latest binutils should support .cfi_* for i386 too. I don't see much sense in making the code more ugly just for staying backwards compatible with older versions for the debug case (without
CONFIG_DEBUG_INFOit should be compatible though).
You need a fairly new gdb too anyways for it.
Quoted 7 lines
Well, yes, the CVS version I mentioned in my patch is needed as I found a bug in the expression analizer. I am NOT trying to say compatable with old tools. I AM trying to do something the CURRENT tools make hard to impossible.
The problem with the gas CFI support is that it does not provide a way to define CFI expressions which are needed to determine if the CFI address should be zero (i.e. the return is to user space) or the current adjusted stack address.
Michal, can you comment?
Quoted 7 lines
I suppose the open ended .cfi_ thing could be used but it requires that you compute your own sleb128 and uleb128 values. It is also not clear how you tell this thing if you want a word or a half word as the dwarf2 spec requires. More info on this would be very "nice". I really would like to do this with out the dwarf2 macros, but, please understand, one of the main reasons for the effort was to tie off the bottom of the stack and that seems to require an expression capability for the asm code in
entry.S.
The one issue that required expression support on x86-64 (switching between the interrupt stack and the process stack) was handled by a dummy base register with a single ifdef. This turned out to be relatively clean.
-Andi
On Tue, 2004-02-10 at 13:56, George Anzinger wrote:
I thought I'd poke around an AMD64 with etherbased kgdb on 2.6.*. I just picked up a used AMD64 K8D Master-F MS-9131 and thought I'd install Fedora Core 1 test1 and the latest kernel from kernel.org.
It Might be interesting to try out a SuSE release also, I was wondering if 9.0 from linuxiso.org might be best.
Last I worked with your kgdb patch for 2.6 Andrew's mm patch had the latest code; Is that still the case?
-piet
Quoted 56 lines
Quoted 31 lines · Andi Kleen
Quoted 14 lines · On Thu, 5 Feb 2004 23:20:04 +0530 "Amit S. Kale" <[email protected]> wrote:
Quoted 11 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
Quoted 3 lines
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZEand the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.Quoted 7 lines
Quoted 2 lines
George has coded cfi directives i386 too. He can use them to backtrace past irqs stack.
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
Well, bin utils, at this time, makes it even worse in that it does not support the expression syntax. Also, it is not asm but dwarf2 and it is written in, IMHO, useful macros (not hex :)
Signature · 9 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Signature · 1 line
[email protected]
Quoted 11 lines · Piet Delaney
On Tue, 2004-02-10 at 13:56, George Anzinger wrote:
I thought I'd poke around an AMD64 with etherbased kgdb on 2.6.*. I just picked up a used AMD64 K8D Master-F MS-9131 and thought I'd install Fedora Core 1 test1 and the latest kernel from kernel.org.
It Might be interesting to try out a SuSE release also, I was wondering if 9.0 from linuxiso.org might be best.
Last I worked with your kgdb patch for 2.6 Andrew's mm patch had the latest code; Is that still the case?
I think so. I haven't look lately. I did send out an additional patch that only put in dwarft2 records in some of the asm code to allow better "bt" through the interrupt/exception frames. I don't know if he picked this up or not, but it does require using the cvs version of gdb.
-g
Quoted 58 lines
-piet
Quoted 54 lines
Quoted 31 lines · Andi Kleen
Quoted 10 lines · On Thu, 5 Feb 2004 23:20:04 +0530 "Amit S. Kale" <[email protected]> wrote:
Quoted 7 lines · Andi Kleen
Quoted 3 lines · Andrew Morton
need to take a look at such things and really convice ourselves that they're worthwhile. Personally, I'd only be interested in the basic stub.
Quoted 7 lines
Quoted 5 lines
What I found always extremly ugly in the i386 stub was that it uses magic globals to talk to the page fault handler. For the x86-64 version I replaced that by just using __get/__put_user in the memory accesses, which is much cleaner. I would suggest doing that for i386 too.
May be I am missing something obvious. When debugging a page fault handler if kgdb accesses an swapped-out user page doesn't it deadlock when trying to hold mm semaphore?
Modern i386 kernels don't grab the mm semaphore when the access is >=
TASK_SIZE
and the access came from kernel space (actually I see x86-64 still does, but that's a bug, will fix). You could only see a deadlock when using user addresses and you already hold the mm semaphore for writing (normal read lock is ok). Just don't do that.Quoted 6 lines
Quoted 1 line
George has coded cfi directives i386 too. He can use them to backtrace past irqs stack.
Problem is that he did it without binutils support. I don't think that's a good idea because it makes the code basically unmaintainable for normal souls (it's like writing assembly code directly in hex)
Well, bin utils, at this time, makes it even worse in that it does not support the expression syntax. Also, it is not asm but dwarf2 and it is written in, IMHO, useful macros (not hex :)
Signature · 9 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
Signature · 3 lines
George Anzinger [email protected] High-res-timers: http://sourceforge.net/projects/high-res-timers/ Preemption patch: http://www.kernel.org/pub/linux/kernel/people/rml
Hi!
Quoted 9 lines
I thought I'd poke around an AMD64 with etherbased kgdb on 2.6.*. I just picked up a used AMD64 K8D Master-F MS-9131 and thought I'd install Fedora Core 1 test1 and the latest kernel from kernel.org.
It Might be interesting to try out a SuSE release also, I was wondering if 9.0 from linuxiso.org might be best.
Last I worked with your kgdb patch for 2.6 Andrew's mm patch had the latest code; Is that still the case?
I think that latest is the code in kgdb.sf.net cvs. Code in -mm tree is "known good".
Pavel
Signature · 2 lines
When do you have a heart between your knees? [Johanka's followup: and *two* hearts?]