NAME
struct - structure contents
SYNOPSIS
struct struct_name[.member[,member]][-o][-l offset][-rfuxdp]
[address | symbol][:cpuspec] [count | -c count]
DESCRIPTION
This command displays either a structure definition, or a formatted display
of the contents of a structure at a specified address. When no address is
specified, the structure definition is shown along with the structure size.
A structure member may be appended to the structure name in order to limit
the scope of the data displayed to that particular member; when no address
is specified, the member's offset and definition are shown.
struct_name name of a C-code structure used by the kernel.
.member name of a structure member; to display multiple members of a
structure, use a comma-separated list of members. If any
member contains an embedded structure, or the member is an
array, the output may be restricted to just the embedded
structure or an array element by expressing the member argument
as "member.member" or "member[index]"; embedded member
specifications may extend beyond one level deep, by expressing
the member argument as "member.member.member...".
-o show member offsets when displaying structure definitions;
if used with an address or symbol argument, each member will
be preceded by its virtual address.
-l offset if the address argument is a pointer to a structure member that
is contained by the target data structure, typically a pointer
to an embedded list_head, the offset to the embedded member may
be entered in either of the following manners:
1. in "structure.member" format.
2. a number of bytes.
-r raw dump of structure data.
-f address argument is a dumpfile offset.
-u address argument is a user virtual address in the current
context.
-x override default output format with hexadecimal format.
-d override default output format with decimal format.
-p if a structure member is a pointer value, show the member's
data type on the output line; and on the subsequent line(s),
dereference the pointer, display the pointer target's symbol
value in brackets if appropriate, and if possible, display the
target data; requires an address argument.
address hexadecimal address of a structure; if the address points
to an embedded list_head structure contained within the
target data structure, then the "-l" option must be used.
symbol symbolic reference to the address of a structure.
:cpuspec CPU specification for a per-cpu address or symbol:
: CPU of the currently selected task.
:a[ll] all CPUs.
:#[-#][,...] CPU list(s), e.g. "1,3,5", "1-3",
or "1,3,5-7,10".
count count of structures to dump from an array of structures;
if used, this must be the last argument entered.
-c count "-c" is only required if "count" is not the last argument
entered or if a negative number is entered; if a negative
value is entered, the (positive) "count" structures that
lead up to and include the target structure will be displayed.
Structure data, sizes, and member offsets are shown in the current output
radix unless the -x or -d option is specified.
Please note that in the vast majority of cases, the "struct" command
name may be dropped; if the structure name does not conflict with any crash
or gdb command name, then the "struct_name[.member]" argument will be
recognized as a structure name, and this command automatically executed.
See the NOTE below.
EXAMPLES
Display the vm_area_struct at address c1e44f10:
crash> struct vm_area_struct c1e44f10
struct vm_area_struct {
vm_mm = 0xc2857750,
vm_start = 0x8048000,
vm_end = 0x80a5000,
vm_next = 0xc1e44a10,
vm_page_prot = {
pgprot = 0x25
},
vm_flags = 0x1875,
vm_avl_height = 0x2,
vm_avl_left = 0xc30fe200,
vm_avl_right = 0xc30fed00,
vm_next_share = 0x0,
vm_pprev_share = 0xc1e44a30,
vm_ops = 0xc0215ca0,
vm_offset = 0x0,
vm_file = 0xc0bfdc70,
vm_pte = 0
}
Display the definition and size of a vm_area_struct structure. This first
example below displays just the structure and size. The second example
uses the -o option to also display member offsets. Both examples were
run with the output radix set to 10 (decimal):
crash> struct vm_area_struct
struct vm_area_struct {
struct mm_struct *vm_mm;
long unsigned int vm_start;
long unsigned int vm_end;
struct vm_area_struct *vm_next;
pgprot_t vm_page_prot;
short unsigned int vm_flags;
short int vm_avl_height;
struct vm_area_struct *vm_avl_left;
struct vm_area_struct *vm_avl_right;
struct vm_area_struct *vm_next_share;
struct vm_area_struct **vm_pprev_share;
struct vm_operations_struct *vm_ops;
long unsigned int vm_offset;
struct file *vm_file;
long unsigned int vm_pte;
}
SIZE: 56
crash> struct vm_area_struct -o
struct vm_area_struct {
[0] struct mm_struct *vm_mm;
[4] long unsigned int vm_start;
[8] long unsigned int vm_end;
[12] struct vm_area_struct *vm_next;
[16] pgprot_t vm_page_prot;
[20] short unsigned int vm_flags;
[22] short int vm_avl_height;
[24] struct vm_area_struct *vm_avl_left;
[28] struct vm_area_struct *vm_avl_right;
[32] struct vm_area_struct *vm_next_share;
[36] struct vm_area_struct **vm_pprev_share;
[40] struct vm_operations_struct *vm_ops;
[44] long unsigned int vm_offset;
[48] struct file *vm_file;
[52] long unsigned int vm_pte;
}
SIZE: 56
Display the definition and offset of the pgd member of an mm_struct:
crash> struct mm_struct.pgd
struct mm_struct {
[80] pgd_t *pgd;
}
Display the pgd member of the mm_struct at address ffff810022e7d080:
crash> struct mm_struct.pgd ffff810022e7d080
pgd = 0xffff81000e3ac000
Display the pgd_t pointed to by the mm_struct.pgd pointer above, forcing
the output to be expressed in hexadecimal:
crash> mm_struct.pgd ffff810022e7d080 -px
pgd_t *pgd = 0xffff81000e3ac000
-> {
pgd = 0x2c0a6067
}
Display the thread_info structure pointed to by the thread_info
member of the task_struct at ffff8100181190c0:
crash> task_struct.thread_info ffff8100181190c0 -p
struct thread_info *thread_info = 0xffff810023c06000
-> {
task = 0xffff8100181190c0,
exec_domain = 0xffffffff802f78e0,
flags = 128,
status = 1,
cpu = 3,
preempt_count = 0,
addr_limit = {
seg = 18446604435732824064
},
restart_block = {
fn = 0xffffffff80095a52 <do_no_restart_syscall>,
arg0 = 0,
arg1 = 0,
arg2 = 0,
arg3 = 0
}
}
Display the flags and virtual members of 4 contiguous page structures
in the mem_map page structure array:
crash> page.flags,virtual c101196c 4
flags = 0x8000,
virtual = 0xc04b0000
flags = 0x8000,
virtual = 0xc04b1000
flags = 0x8000,
virtual = 0xc04b2000
flags = 0x8000,
virtual = 0xc04b3000
Display the array of tcp_sl_timer structures declared by tcp_slt_array[]:
crash> struct tcp_sl_timer tcp_slt_array 4
struct tcp_sl_timer {
count = {
counter = 0x0
},
period = 0x32,
last = 0x1419e4,
handler = 0xc0164854 <tcp_syn_recv_timer>
}
struct tcp_sl_timer {
count = {
counter = 0x2
},
period = 0x753,
last = 0x14a6df,
handler = 0xc01645b0 <tcp_keepalive>
}
struct tcp_sl_timer {
count = {
counter = 0x0
},
period = 0x2ee,
last = 0x143134,
handler = 0xc016447c <tcp_twkill>
}
struct tcp_sl_timer {
count = {
counter = 0x0
},
period = 0x64,
last = 0x143198,
handler = 0xc0164404 <tcp_bucketgc>
}
Without using the "struct" command name, display the the "d_child"
list_head member from a dentry structure:
crash> dentry.d_child 0xe813cb4
d_child = {
next = 0x3661344,
prev = 0xdea4bc4
},
Display the child dentry structure referenced by the "next" pointer above.
Since the "next" address of 0x3661344 above is a pointer to an embedded
list_head structure within the child dentry structure, the -l option
is required:
crash> dentry -l dentry.d_child 0x3661344
struct dentry {
d_count = {
counter = 1
},
d_flags = 0,
d_inode = 0xf9aa604,
d_parent = 0x11152b1c,
d_hash = {
next = 0x11fb3fc0,
prev = 0x11fb3fc0
},
d_lru = {
next = 0x366133c,
prev = 0x366133c
},
d_child = {
next = 0x36613cc,
prev = 0xe813cd4
},
d_subdirs = {
next = 0x366134c,
prev = 0x366134c
},
d_alias = {
next = 0xf9aa614,
prev = 0xf9aa614
},
d_mounted = 0,
d_name = {
name = 0x3661384 "boot.log",
len = 8,
hash = 1935169207
},
d_time = 1515870810,
d_op = 0x0,
d_sb = 0x11fc9c00,
d_vfs_flags = 0,
d_fsdata = 0x0,
d_extra_attributes = 0x0,
d_iname = "boot.log\000"
}
Display the virtual address of each member of the task_struct at
ffff8100145d2080:
crash> task_struct -o ffff8100145d2080
struct task_struct {
[ffff8100145d2080] volatile long int state;
[ffff8100145d2088] struct thread_info *thread_info;
[ffff8100145d2090] atomic_t usage;
[ffff8100145d2098] long unsigned int flags;
[ffff8100145d20a0] int lock_depth;
[ffff8100145d20a4] int load_weight;
[ffff8100145d20a8] int prio;
[ffff8100145d20ac] int static_prio;
[ffff8100145d20b0] int normal_prio;
[ffff8100145d20b8] struct list_head run_list;
[ffff8100145d20c8] struct prio_array *array;
...
Display the embedded sched_entity structure's on_rq member and
the third pid_link structure in the embedded pids[] array of the
task_struct at ffff88011653e250:
crash> task_struct.se.on_rq,pids[2] ffff88011653e250
se.on_rq = 1,
pids[2] = {
node = {
next = 0xffff88011653aff0,
pprev = 0xffff88011653a860
},
pid = 0xffff88010d07ed00
}
For an example of displaying per-cpu variables, consider the
struct hd_struct.dkstats member, which is a percpu pointer to
a disk_stats structure:
crash> struct hd_struct.dkstats
struct hd_struct {
[1232] struct disk_stats *dkstats;
}
Taking an hd_struct at address ffff8802450e2848, display all
of the per-cpu disk_stats structures that it references:
crash> struct hd_struct.dkstats ffff8802450e2848
dkstats = 0x60fdb48026c8
crash> struct disk_stats 0x60fdb48026c8:a
[0]: ffffe8fefe6026c8
struct disk_stats {
sectors = {451376, 80468},
ios = {6041, 971},
merges = {386, 390},
ticks = {194877, 56131},
io_ticks = 12371,
time_in_queue = 309163
}
[1]: ffffe8fefe8026c8
struct disk_stats {
sectors = {0, 0},
ios = {0, 0},
merges = {7, 242},
ticks = {0, 0},
io_ticks = 23,
time_in_queue = 581
}
[2]: ffffe8fefea026c8
struct disk_stats {
sectors = {0, 0},
ios = {0, 0},
merges = {4, 112},
ticks = {0, 0},
io_ticks = 11,
time_in_queue = 305
}
[3]: ffffe8fefec026c8
struct disk_stats {
sectors = {0, 0},
ios = {0, 0},
merges = {5, 54},
ticks = {0, 0},
io_ticks = 17,
time_in_queue = 41
}
NOTE
If the structure name does not conflict with any crash command name, the
"struct" command may be dropped. Accordingly, the examples above could
also have been accomplished like so:
crash> vm_area_struct c1e44f10
crash> vm_area_struct
crash> vm_area_struct -o
crash> mm_struct.pgd ffff810022e7d080
crash> mm_struct.pgd
crash> tcp_sl_timer tcp_slt_array 4
Lastly, the short-cut "*" pointer-to command may also be used to negate
the need to enter the "struct" command name (enter "help *" for details).
|
