views:

115

answers:

5

I am having a slight problem with some structs in a kernel module I'm building, so I thought it would be nice if there was an easy way to print out structs and their values - and below is a small userland example of what I mean.

Say we have the simple C example as below (given in form of a bash commands):

FN=mtest

cat > $FN.c <<EOF
#include <stdio.h> //printf
#include <stdlib.h> //calloc

struct person
{
 int age; 
 int height; 
};

static struct person *johndoe;

main ()
{

 johndoe = (struct person *)calloc(1, sizeof(struct person));
 johndoe->age = 6; 

 asm("int3"); //breakpoint for gdb

 printf("Hello World - age: %d\n", johndoe->age);

 free(johndoe);
}
EOF

gcc -g -O0 $FN.c -o $FN

# just a run command for gdb
cat > ./gdbcmds <<EOF
run
EOF

gdb --command=./gdbcmds ./$FN 

 

If we run this example, the program will compile, and gdb will run it, and automatically stop at the breakpoint. Here we can do the following:

Program received signal SIGTRAP, Trace/breakpoint trap.
main () at mtest.c:20
20  printf("Hello World - age: %d\n", johndoe->age);
(gdb) p johndoe
$1 = (struct person *) 0x804b008
(gdb) p (struct person)*0x804b008
$2 = {age = 6, height = 0}
(gdb) c
Continuing.
Hello World - age: 6

Program exited with code 0300.
(gdb) q

 

As shown, in gdb we can printout (dump?) the value of the struct pointer johndoe as {age = 6, height = 0} ... I would like to do the same, but directly from a C program; say as in the following example:

#include <stdio.h> //printf
#include <stdlib.h> //calloc
#include <whatever.h> //for imaginary printout_struct

struct person
{
 int age; 
 int height; 
};

static struct person *johndoe;
static char report[255]; 

main ()
{

 johndoe = (struct person *)calloc(1, sizeof(struct person));
 johndoe->age = 6; 

 printout_struct(johndoe, report); //imaginary command

 printf("Hello World - age: %d\nreport: %s", johndoe->age, report);

 free(johndoe);
}

 

which would result with an output like:

Hello World - age: 6
$2 = {age = 6, height = 0}

 

So my question is - does a function like that imaginary printout_struct exist - or is there another approach to make a printout like this possible?

Thanks in advance for any help,
Cheers!

+1  A: 

You have to add meta-info describing the structure, so that printout_struct can do its job. Otherwise, it can't guess anything. Try with gdb removing every debugging info, and you will see that it can't "speak" about "age" or whatever.

ShinTakezou
I mean of course that the metainfo about the struct must be given as argument to printout_struct
ShinTakezou
+1  A: 

The C language doesn't have metadata, either compile-time or run-time. There might be some vendor-specific extensions to do this. For example, doxygen will make an XML file with all the member information (name and type) of each struct type in your program, it wouldn't be too difficult to write a program to process that XML file and generate the code for a printout_person(const struct person*) function automatically.

Ben Voigt
Many (most?) compilers provide a "include debugging symbols" options which generates exactly such metadata. In the case of `gcc` the option is `-g` That is, after all, where `gdb` get the info to accomplish this..
dmckee
Indeed. See my answer for a couple of possibilities for getting at the info.
bstpierre
A: 

recently somebody mentioned

exuberant ctags

on stackoverflow for a similar task. Perhaps you can dig that out, I didn't find immediately, though.

Jens Gustedt
+1  A: 

See this related question for some info on parsing structs. Specifically my reference there to pstruct.

In your case, where you want to get info from inside a running program, you'd have to either invoke one of those external tools, or parse out the debug info from your executable and display it appropriately.

You might also look at libgdb, though it looks like it might be somewhat dated.

bstpierre
A: 

Hi all,

Just wanted to say - thanks for all your good and incredibly fast answers, helped me a lot to understand the problem (of why there isn't such a 'native' function in C)!

(and sorry for answering my own question - doing that, so as not to garble the original post, and being able to format code)

While looking further I managed to find:

which illustrate the trick with calling gdb with the pid of the process itself, and so I modified the dumpstack function found there, to get the following code:

FN=mtest

cat > $FN.c <<EOF
#include <stdio.h> //printf
#include <stdlib.h> //calloc, system

extern const char *__progname;

struct person
{
    int age; 
    int height; 
};

static struct person *johndoe;
static char report[255]; 

static void printout_struct(void* invar, char* structname){
    /* dumpstack(void) Got this routine from http://www.whitefang.com/unix/faq_toc.html
    ** Section 6.5. Modified to redirect to file to prevent clutter
    */
    /* This needs to be changed... */
    char dbx[160];

    sprintf(dbx, "echo 'p (struct %s)*%p\n' > gdbcmds", structname, invar );
    system(dbx);

    sprintf(dbx, "echo 'where\ndetach' | gdb -batch --command=gdbcmds %s %d > struct.dump", __progname, getpid() );
    system(dbx);

    sprintf(dbx, "cat struct.dump");
    system(dbx);

    return;
}

main ()
{

    johndoe = (struct person *)calloc(1, sizeof(struct person));

    johndoe->age = 6; 
    printout_struct(johndoe, "person"); 

    johndoe->age = 8; 
    printout_struct(johndoe, "person"); 

    printf("Hello World - age: %d\n:", johndoe->age);

    free(johndoe);
}


EOF

gcc -g -O0 $FN.c -o $FN

./$FN

  which basically ends up displaying what I wanted:

0x00740422 in __kernel_vsyscall ()
$1 = {age = 6, height = 0}
0x00740422 in __kernel_vsyscall ()
$1 = {age = 8, height = 0}
Hello World - age: 8

 

Though, I'm not sure it will work with kernel modules ...

Thanks again for the help,
Cheers!

EDIT: The reason why I don't think it will work for kernel modules, is that in this case, we have a userland program with a process ID; and we simply call gdb from this program, while instructing it about our PID - so gdb can "attach" to our process; then, since gdb is also instructed to load the executable with debug symbols (so it will 'know' what the struct is), and instructed about the address where a given struct variable is located, gdb can then printout the struct.

For kernel modules - first I don't think they are 'processes' in the sense of having a unique PID, so gdb will have nothing to attach to! In fact, there is a kernel debugger, kgdb which can in fact break into a running kernel and step through module source code; however, you need a second machine connected through a serial connection for that - or a virtual machine, see Linux Hacks: Setting up kgdb using kvm/qemu.

So, in any case, it seems that gdb would not be able to inspect memory of the currently running host kernel gdb is running in - but I'll try to experiment, and if the experiments show otherwise, I'll be sure to post :)

sdaau
Don't apologize for answering your own questions, that is encouraged around here.
dmckee
self-answering is fine on SO; in this case, I would say that it would be better if you try and update this answer so to make us know if the solution is fine even in kernel modules.
ShinTakezou
OK guys - thanks for that; I just noticed the "are you sure you want to answer your own question" part when I was trying to post it :) Also, added an edit of why I think kernel modules will not work..
sdaau