Display Linux linked list in Trace32

Question

I try to print Linux linked list in user friendly way in Trace32.

1. Is there already any known method available?

If not then let me show an example with modules list.

I have global variable

static struct list_head modules;

where

struct list_head {
        struct list_head *next, *prev;
};

So, in T32 I just see list of next and prev pointers when doing v.v modules, no useful info in fact. However, every node of modules list is a part of a container type. In this case struct module

struct module {
         ...
         struct list_head list;
         ...
}

Normally, to extract container pointer Linux uses container_of macro.

/**
  * container_of - cast a member of a structure out to the containing structure
  * @ptr:        the pointer to the member.
  * @type:       the type of the container struct this is embedded in.
  * @member:     the name of the member within the struct.
  *
  */
 #define container_of(ptr, type, member) ({                      \
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
         (type *)( (char *)__mptr - offsetof(type,member) );})

In our example we know the pointer to struct list_head which is a list member in struct module then we should call container_of(modules->next, struct module, list) to get a pointer to the container.

To be able to archive this in T32 I need to calculate offset of the list member in container type.

Anyone knows how to achieve this?

Holger · Accepted Answer

Well, sounds for me that you have two questions:

How to display linked lists?
How to get the byte offset of a member in a struct?

For displaying linked lists I suggest the command Var.CHAIN or VAR.FixedCHAIN. Both commands have two mandatory arguments: Variable name of the struct and name of the next element. (You can look up all the optional arguments and format options in the TRACE32 manual.)

So, view your first simple case with

Var.CHAIN modules modules.next

A window will open with a table showing you the complete list until 'next' points to NULL.

Note: As stated by Wrymarki below in the comments, this first part of the answer is actually wrong. Var.CHAIN works for ordinary linked lists, but not for "Linux linked lists". Solution for "Linux linked lists" (by Wrymarki) is to write a PRACTICE script which loops through the list and adds the list entries with Var.AddWatch to a watch-window by using the container_of() macro (see below).

For getting the offsset of of a member in a struct I recommend to declare preprocessor macros just like you do in your source code. Or almost like in your source code since TRACE32 does not know GCC specific extensions like typeof() or statement expressions.

Anyway, we can get the offsetof() macro with

sYmbol.NEW.MACRO offsetof(type,member) ((int)(&((type*)0)->member))

A preprocessor macro can be used inside every HLL expression in TRACE32 (with all Var.* commands and functions). E.g.:

Var.AddWatch offsetof(struct module,list)

Note: sYmbol.NEW.MACRO does not accept spaces in the macro name: You have to write offsetof(type,member) instead of offsetof(type, member).

You can view your macros in window sYmbol.List.MACRO

You can also get the macros from your source code if your compiler support this (GCC does with option -g3) when loading your ELF with option /MACRO: Data.LOAD.Elf * /MACRO. But again: TRACE32 will not understand GCC specific extensions or internal macros like '__builtin_offsetof()'.

You can also declare a container_of() preprocessor macro with

sYmbol.NEW.MACRO container_of(ptr,type,member) ((type *)((char *)(ptr)-offsetof(type,member)))

Use it e.g. as follows:

Var.View container_of(modules->next,struct module,list)

Display Linux linked list in Trace32

Answers (2)

Related Questions