8:13 a.m.
Hello Dave,
here is the second reincarnation of the parser. I've updated
`task` and `struct` handlers along with the `list` handler:
crash> list task_struct.tasks -s task_struct.comm,pid,thread.cr2 -H 0xde83a1e0
de840aa0
comm = "ksoftirqd/0\000\000\000\000"
pid = 4
thread.cr2 = 0,
de840550
comm = "stopper/0\000\000\000\000\000\000"
pid = 5
thread.cr2 = 0,
..................
crash> task -R
restart_block.fn,restart_block.futex,thread.tls_array[0].base1,cpu_timers[2].next
restart_block.fn = 0xc046fe10 <do_no_restart_syscall>,
restart_block.futex = {
uaddr = 0x0,
val = 0,
flags = 0,
bitset = 0,
time = 0,
uaddr2 = 0x0
},
thread.tls_array[0].base1 = 112,
cpu_timers[2].next = 0xdb9a7838,
crash> task_struct.comm,thread.tls_array[0].dpl 0xdb9a7550
comm = "bash\000\000\000\000\000\000\000\000\000\000\000"
thread.tls_array[0].dpl = 3,
I'm looking forward to your comments/suggestions.
Best regards,
Alexandr
--- crash-7.1.0.orig/symbols.c 2015-02-06 21:44:11.000000000 +0300
+++ crash-7.1.0/symbols.c 2015-05-11 16:11:56.587128595 +0300
@@ -93,6 +93,7 @@ static int dereference_pointer(ulong, st
#define PARSE_FOR_DATA (1)
#define PARSE_FOR_DECLARATION (2)
static void parse_for_member(struct datatype_member *, ulong);
+void parse_for_member_new(struct datatype_member *, ulong);
static int show_member_offset(FILE *, struct datatype_member *, char *);
@@ -5576,17 +5577,18 @@ dump_struct_member(char *s, ulong addr,
FREEBUF(buf);
error(FATAL, "invalid structure name: %s\n", dm->name);
}
- if (!MEMBER_EXISTS(dm->name, dm->member)) {
- FREEBUF(buf);
- error(FATAL, "invalid structure member name: %s\n",
- dm->member);
- }
set_temporary_radix(radix, &restore_radix);
open_tmpfile();
print_struct(dm->name, addr);
- parse_for_member(dm, PARSE_FOR_DATA);
+
+ if (MEMBER_EXISTS(dm->name, dm->member)) {
+ parse_for_member(dm, PARSE_FOR_DATA);
+ } else {
+ parse_for_member_new(dm, PARSE_FOR_DATA);
+ }
+
close_tmpfile();
restore_current_radix(restore_radix);
@@ -6026,8 +6028,7 @@ cmd_datatype_common(ulong flags)
if ((count_chars(args[optind], ',')+1) > MAXARGS)
error(FATAL, "too many members in comma-separated list!\n");
- if ((count_chars(args[optind], '.') > 1) ||
- (LASTCHAR(args[optind]) == ',') ||
+ if ((LASTCHAR(args[optind]) == ',') ||
(LASTCHAR(args[optind]) == '.'))
error(FATAL, "invalid format: %s\n", args[optind]);
@@ -6219,6 +6220,10 @@ do_datatype_addr(struct datatype_member
i = 0;
do {
if (argc_members) {
+ /* This call works fine with fields
+ * of the second, third, ... levels.
+ * There is no need to fix it
+ */
if (!member_to_datatype(memberlist[i], dm,
ANON_MEMBER_QUERY))
error(FATAL, "invalid data structure reference: %s.%s\n",
@@ -6250,7 +6255,12 @@ do_datatype_addr(struct datatype_member
if (dm->member) {
if (!((flags & DEREF_POINTERS) &&
dereference_pointer(addr, dm, flags)))
- parse_for_member(dm, PARSE_FOR_DATA);
+ {
+ if (count_chars(dm->member,
'.'))
+ parse_for_member_new(dm,
PARSE_FOR_DATA);
+ else
+ parse_for_member(dm,
PARSE_FOR_DATA);
+ }
close_tmpfile();
}
@@ -6275,6 +6285,10 @@ do_datatype_declaration(struct datatype_
if (CRASHDEBUG(1))
dump_datatype_member(fp, dm);
+ if (dm->member && count_chars(dm->member, '.'))
+ error(FATAL, "invalid data structure reference: %s.%s\n",
+ dm->name, dm->member);
+
open_tmpfile();
whatis_datatype(dm->name, flags, pc->tmpfile);
rewind(pc->tmpfile);
@@ -7383,6 +7397,270 @@ next_item:
}
}
+struct struct_elem {
+ char field_name[BUFSIZE];
+ unsigned char field_len;
+ char value[BUFSIZE];
+ unsigned char is_array_root:1;
+
+ struct struct_elem *parent;
+ struct struct_elem *inner;
+ struct struct_elem *next;
+ struct struct_elem *prev;
+};
+
+#define ALLOC_XXX_ELEMENT(xxx, clone_parent) \
+{ \
+ if (NULL == current) { \
+ error(FATAL, "Internal error while parsing structure %s\n",
dm->name); \
+ } \
+ current->xxx = calloc(1, sizeof(struct struct_elem)); \
+ if (clone_parent) current->xxx->parent = current->parent; \
+ else current->xxx->parent = current; \
+ current = current->xxx; \
+}
+
+#define ALLOC_INNER_ELEMENT { ALLOC_XXX_ELEMENT(inner, 0) }
+#define ALLOC_NEXT_ELEMENT { ALLOC_XXX_ELEMENT(next, 1) }
+
+void free_structure(struct struct_elem *p) {
+ if (p == NULL)
+ return;
+ free_structure(p->inner);
+ free_structure(p->next);
+ free(p);
+}
+
+unsigned char is_right_brace(const char *b) {
+ unsigned char r = 0;
+ for (; *b == ' '; b++);
+ if (*b == '}') {
+ b++;
+ r = 1;
+ if (*b == '}') {
+ r = 2;
+ b++;
+ }
+ }
+
+ if (*b == ',')
+ b++;
+
+ if (*b == '\0')
+ return r;
+ else
+ return 0;
+}
+
+struct struct_elem *find_node(struct struct_elem *s, char *n) {
+ char *p, *b, *e;
+ struct struct_elem *t = s;
+ unsigned i;
+
+ if (('\0' == *n) || (NULL == s))
+ return s;
+
+ /* [n .. p) - struct member with index*/
+ if (NULL == (p = strstr(n, ".")))
+ p = n + strlen(n);
+
+ /* [n .. b) - struct member without index*/
+ for (b = n; (b < p) && (*b != '['); b++);
+
+ /* s - is the current level of items [s, s->next, ..., s->...->next] */
+ for (; s; s = s->next) {
+ if (*s->field_name == '\0')
+ continue;
+
+ /* `field_name` doesn't match */
+ if (((b - n) != s->field_len) || memcmp(s->field_name, n, b - n))
+ continue;
+
+ if (*b == '[') { /* Array */
+ i = strtol(b + 1, &e, 10);
+ /* Check if the current node is array and
+ * we've parsed index more or less correctly
+ */
+ if (!(s->is_array_root && *e == ']'&& (e != b +
1)))
+ return NULL;
+
+ /* Look for the i-th element */
+ for (s = s->inner; s && i; s = s->next, i--);
+ if (i || (NULL == s))
+ return NULL;
+ }
+
+ /* Ok. We've found node, it's - the last member
+ * in our search string, let's return it.
+ */
+ if ('\0' == *p)
+ return s;
+ else
+ return find_node(s->inner, p + 1);
+ }
+
+ // We haven't found any field.
+ // Might happen, we've encountered anonymous structure
+ // of union. Lets try every record without `field_name`
+ s = t;
+ t = NULL;
+ for(; s; s = s->next) {
+ if (*s->field_name)
+ continue;
+ t = find_node(s->inner, n);
+ if (t)
+ break;
+ }
+
+ return t;
+}
+
+void dump_node(struct struct_elem *p, char *f, unsigned char level, unsigned char
is_array) {
+ unsigned int i;
+ if (p == NULL)
+ return;
+ do {
+#define PUT_INDENTED_STRING(m, ...) { \
+ for (i = 0; i++ < 2 + 2 * (m * is_array + level); printf(" ")); \
+ printf(__VA_ARGS__); }
+
+ if (p->inner) {
+ if (*p->field_name) {
+ PUT_INDENTED_STRING(1, "%s = %s\n", f ? f : p->field_name,
p->inner->is_array_root ? "{{" : "{");
+ } else {
+ if (f) /* For union */
+ PUT_INDENTED_STRING(1, "%s = ", f);
+ PUT_INDENTED_STRING(1, "%s\n", p->inner->is_array_root ?
"{{" : "{");
+ }
+ dump_node(p->inner, NULL, is_array + level + 1,
p->inner->is_array_root);
+ PUT_INDENTED_STRING(1, "%s%s\n", p->inner->is_array_root ?
"}}" : "}", (p->next && !p->next->is_array_root) ?
"," : "");
+ } else {
+ PUT_INDENTED_STRING(1, "%s = %s%s", f ? f : p->field_name,
p->value, p->next ? ",\n" : "\n");
+ }
+ if (level) {
+ p = p->next;
+ if (p && p->is_array_root)
+ PUT_INDENTED_STRING(0, "}, {\n");
+ }
+ } while (p && level);
+}
+
+void parse_for_member_new(struct datatype_member *dm,
+ ulong __attribute__ ((unused)) flag)
+{
+ struct struct_elem *i, *current = NULL, *root = NULL;
+
+ char buf[BUFSIZE];
+ char *p, *p1;
+ char *s_e; // structure_element
+ unsigned int len;
+ unsigned char trailing_comma, braces, found = 0;
+
+ rewind(pc->tmpfile);
+
+ root = calloc(1, sizeof(struct struct_elem));
+ current = root;
+ ALLOC_INNER_ELEMENT;
+
+ while (fgets(buf, BUFSIZE, pc->tmpfile)) {
+ len = strlen(buf) - 1;
+ for (; buf[len] <= ' '; buf[len--] = '\0');
+ if ((trailing_comma = (buf[len] == ',')))
+ buf[len--] = '\0';
+
+ if ((braces = is_right_brace(buf))) {
+ for (; braces && current; braces--)
+ current = current->parent;
+
+ if ((current->parent == root) || trailing_comma)
+ ALLOC_NEXT_ELEMENT;
+ continue;
+ }
+
+ for (p1 = buf; *p1 == ' '; p1++);
+
+ if (NULL != (p = strstr(buf, " = "))) {
+ s_e = p + 3;
+ } else {
+ s_e = p1;
+ }
+
+ /*
+ * After that we have pointers:
+ * foobar = bazzz
+ * -----^ ^ ^
+ * | ------| |
+ * | | |
+ * p1 p s_e
+ *
+ * OR
+ *
+ * {
+ * ^
+ * |
+ * ---------
+ * | |
+ * p1 s_e
+ *
+ * p == NULL
+ *
+ *
+ * p1 - the first non-whitespace symbol in line
+ * p - pointer to line ' = '. If not NULL, there is identifier
+ * s_e - element of structure (brace / double brace / array separator / scalar
:))
+ *
+ */
+
+ if (current && p) strncpy(current->field_name, p1, p - p1);
+ current->field_len = p - p1;
+
+ if ( p && (*s_e != '{' || (*s_e == '{' &&
buf[len] == '}') )) {
+ /* Scalar or one-line array
+ * next = 0x0
+ * or
+ * files = {0x0, 0x0}
+ */
+ strcpy(current->value, s_e);
+ if (trailing_comma) ALLOC_NEXT_ELEMENT;
+ }
+ else
+ if ( *s_e == '{' ) {
+ ALLOC_INNER_ELEMENT;
+ if (*(s_e + 1) == '{') {
+ current->parent->is_array_root = 1;
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+ else
+ if (strstr(s_e, "}, {")) {
+ /* Next array element */
+ current = current->parent;
+ ALLOC_NEXT_ELEMENT;
+ ALLOC_INNER_ELEMENT;
+ }
+ else
+ if (buf == (p = strstr(buf, "struct "))) {
+ p += 7; /* strlen "struct " */
+ p1 = strstr(buf, " {");
+ strncpy(current->field_name, p, p1 - p);
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+
+ for (i = root->inner; i; i = i->next) {
+ if ((current = find_node(i->inner, dm->member))) {
+ dump_node(current, dm->member, 0, 0);
+ found = 1;
+ break;
+ }
+ }
+
+ free_structure(root);
+
+ if (!found)
+ error(WARNING, "invalid structure reference: %s\n", dm->member);
+}
+
/*
* Dig out a member name from a formatted gdb structure declaration dump,
* and print its offset from the named structure passed in.
--- crash-7.1.0.orig/task.c 2015-02-06 21:44:11.000000000 +0300
+++ crash-7.1.0/task.c 2015-05-11 15:52:57.387111513 +0300
@@ -107,6 +107,8 @@ static int sort_by_last_run(const void *
static void sort_context_array_by_last_run(void);
static void show_ps_summary(ulong);
static void irqstacks_init(void);
+static void parse_task_thread(int argcnt, char *arglist[], struct task_context *);
+void parse_for_member_new(struct datatype_member *, ulong);
/*
* Figure out how much space will be required to hold the task context
@@ -2746,13 +2748,9 @@ task_struct_member(struct task_context *
int argcnt;
char *arglist[MAXARGS];
char *refcopy;
- char buf[BUFSIZE];
- char lookfor1[BUFSIZE];
- char lookfor2[BUFSIZE];
- char lookfor3[BUFSIZE];
- int header_printed;
-
- header_printed = FALSE;
+ unsigned char call_new_parser = 0;
+ struct datatype_member dm;
+ char *member = GETBUF(BUFSIZE);
if ((count_chars(ref->str, ',')+1) > MAXARGS) {
error(INFO,
@@ -2767,14 +2765,39 @@ task_struct_member(struct task_context *
argcnt = parse_line(refcopy, arglist);
for (i = 0; i < argcnt; i++)
if (!MEMBER_EXISTS("task_struct", arglist[i]) &&
- !MEMBER_EXISTS("thread_info", arglist[i]))
- error(INFO, "%s: not a task_struct or thread_info member\n",
- arglist[i]);
-
+ !MEMBER_EXISTS("thread_info", arglist[i])) {
+ if (count_chars(arglist[i], '.') || count_chars(arglist[i], '['))
+ call_new_parser = 1;
+ else
+ error(INFO, "%s: not a task_struct or "
+ "thread_info member\n", arglist[i]);
+ }
open_tmpfile();
dump_struct("task_struct", tc->task, radix);
- if (tt->flags & THREAD_INFO)
- dump_struct("thread_info", tc->thread_info, radix);
+ if (tt->flags & THREAD_INFO)
+ dump_struct("thread_info", tc->thread_info, radix);
+ if (call_new_parser) {
+ for (i = 0; i < argcnt; i++) {
+ dm.member = arglist[i];
+ parse_for_member_new(&dm, 0);
+ }
+ } else {
+ parse_task_thread(argcnt, arglist, tc);
+ }
+ close_tmpfile();
+
+ FREEBUF(member);
+
+}
+
+static void parse_task_thread(int argcnt, char *arglist[], struct task_context *tc) {
+ char buf[BUFSIZE];
+ char lookfor1[BUFSIZE];
+ char lookfor2[BUFSIZE];
+ char lookfor3[BUFSIZE];
+ int header_printed = FALSE;
+ int i;
+
rewind(pc->tmpfile);
BZERO(lookfor1, BUFSIZE);
@@ -2825,7 +2848,6 @@ task_struct_member(struct task_context *
}
}
}
- close_tmpfile();
}
static char *ps_exclusive =
--- crash-7.1.0.orig/tools.c 2015-02-06 21:44:11.000000000 +0300
+++ crash-7.1.0/tools.c 2015-05-11 15:52:57.391111513 +0300
@@ -3526,13 +3526,9 @@ do_list(struct list_data *ld)
dump_struct(ld->structname[i],
next - ld->list_head_offset, radix);
break;
- case 1:
+ default:
dump_struct_members(ld, i, next);
break;
- default:
- error(FATAL,
- "invalid structure reference: %s\n",
- ld->structname[i]);
}
}
}
5:09 p.m.
Hi Alex,
This patch certainly looks promising. I've have only just begun
looking at the patch, and based upon a few initial tests, I like
the functionality a lot. Nice job!
However, for starters, there are a few crash utility conventions that
should be followed. I'm sorry if they seem pedantic, unnecessary,
unreasonable, pathetic, or whatever, but let's get them out of the
way first.
Before posting a patch, please build it with "make warn", and fix all
the complaints:
$ make warn
TARGET: X86_64
CRASH: 7.1.1rc28
GDB: 7.6
cc -c -g -DX86_64 -DLZO -DSNAPPY -DGDB_7_6 build_data.c -Wall -O2 -Wstrict-prototypes
-Wmissing-prototypes -fstack-protector -Wformat-security
cc -c -g -DX86_64 -DLZO -DSNAPPY -DGDB_7_6 tools.c -Wall -O2 -Wstrict-prototypes
-Wmissing-prototypes -fstack-protector -Wformat-security
cc -c -g -DX86_64 -DLZO -DSNAPPY -DGDB_7_6 task.c -Wall -O2 -Wstrict-prototypes
-Wmissing-prototypes -fstack-protector -Wformat-security
cc -c -g -DX86_64 -DLZO -DSNAPPY -DGDB_7_6 symbols.c -I./gdb-7.6/bfd -I./gdb-7.6/include
-Wall -O2 -Wstrict-prototypes -Wmissing-prototypes -fstack-protector -Wformat-security
symbols.c:7426:6: warning: no previous prototype for ‘free_structure’
[-Wmissing-prototypes]
symbols.c:7434:15: warning: no previous prototype for ‘is_right_brace’
[-Wmissing-prototypes]
symbols.c:7455:21: warning: no previous prototype for ‘find_node’
[-Wmissing-prototypes]
symbols.c:7518:6: warning: no previous prototype for ‘dump_node’
[-Wmissing-prototypes]
...
Global functions should be declared in the relevant location
in defs.h. So for example, at the top of task.c and symbols.c
you have:
+void parse_for_member_new(struct datatype_member *, ulong);
Please move both of those to the single location in defs.h where
the other global functions for symbols.c are listed.
When adding new functions, please put the function name on
its own line. For example, you have:
+ void parse_for_member_new(struct datatype_member *dm,
+ ulong __attribute__ ((unused)) flag)
+ {
I'm a dedicated cscope user, and it does not always find functions
when they are declared that way. I don't know why, but here's
an example where I've entered "parse_for_member_new":
Could not find the global definition: parse_for_member_new
Find this C symbol:
Find this global definition: parse_for_member_new
Find functions called by this function:
Find functions calling this function:
Find this text string:
Change this text string:
Find this egrep pattern:
Find this file:
Find files #including this file:
Find assignments to this symbol:
Also, when I'm editing a file with vi, I typically search for a function
by using "^function-name", which obviously doesn't work when the
function name is not at the beginning of the line.
Calling printf() should never be used, but rather you should always use
fprintf(fp, ...) so that the output is redirected as expected:
#define PUT_INDENTED_STRING(m, ...) { \
for (i = 0; i++ < 2 + 2 * (m * is_array + level); printf(" ")); \
printf(__VA_ARGS__); }
Using calloc() to allocate temporary memory for functions that are
called by crash commands should be avoided because of a high possibility
that the command will be interrupted by ctrl-c, a "q" from the scroll
prompt, or simply by an unexpected error(FATAL):
#define ALLOC_XXX_ELEMENT(xxx, clone_parent) \
{ \
if (NULL == current) { \
error(FATAL, "Internal error while parsing structure %s\n",
dm->name); \
} \
current->xxx = calloc(1, sizeof(struct struct_elem)); \
if (clone_parent) current->xxx->parent = current->parent; \
else current->xxx->parent = current; \
current = current->xxx; \
}
#define ALLOC_INNER_ELEMENT { ALLOC_XXX_ELEMENT(inner, 0) }
#define ALLOC_NEXT_ELEMENT { ALLOC_XXX_ELEMENT(next, 1) }
void free_structure(struct struct_elem *p) {
if (p == NULL)
return;
free_structure(p->inner);
free_structure(p->next);
free(p);
}
To prevent memory leaks in those cases, please use the GETBUF()
and FREEBUF() macros. They can be used like malloc/free, but
if you do not call FREEBUF(), or if the command is prematurely
interrupted as above, the buffers will be be freed automatically
by restore_sanity() prior to the next "crash>" prompt. So in
your case, you should be able to use GETBUF() and FREEBUF() in
ALLOC_XXX_ELEMENT() and free_structure().
And lastly, I see that all of your new functions use the 4-space convention
instead of using tabs. That is not done anywhere in the crash utility
code, but rather the Linux kernel coding convention is used when at all
possible:
+ void parse_for_member_new(struct datatype_member *dm,
+ ulong __attribute__ ((unused)) flag)
+ {
+ struct struct_elem *i, *current = NULL, *root = NULL;
+
+ char buf[BUFSIZE];
+ char *p, *p1;
+ char *s_e; // structure_element
+ unsigned int len;
+ unsigned char trailing_comma, braces, found = 0;
+
+ rewind(pc->tmpfile);
+
+ root = calloc(1, sizeof(struct struct_elem));
+ current = root;
+ ALLOC_INNER_ELEMENT;
+
+ while (fgets(buf, BUFSIZE, pc->tmpfile)) {
+ len = strlen(buf) - 1;
+ for (; buf[len] <= ' '; buf[len--] = '\0');
+ if ((trailing_comma = (buf[len] == ',')))
+ buf[len--] = '\0';
+
+ if ((braces = is_right_brace(buf))) {
+ for (; braces && current; braces--)
+ current = current->parent;
Again, I just prefer to keep things "conventional". Please don't take
any offense -- the content and functionality looks quite good.
Thanks,
Dave
----- Original Message -----
Hello Dave,
here is the second reincarnation of the parser. I've updated
`task` and `struct` handlers along with the `list` handler:
crash> list task_struct.tasks -s task_struct.comm,pid,thread.cr2 -H
0xde83a1e0
de840aa0
comm = "ksoftirqd/0\000\000\000\000"
pid = 4
thread.cr2 = 0,
de840550
comm = "stopper/0\000\000\000\000\000\000"
pid = 5
thread.cr2 = 0,
..................
crash> task -R
restart_block.fn,restart_block.futex,thread.tls_array[0].base1,cpu_timers[2].next
restart_block.fn = 0xc046fe10 <do_no_restart_syscall>,
restart_block.futex = {
uaddr = 0x0,
val = 0,
flags = 0,
bitset = 0,
time = 0,
uaddr2 = 0x0
},
thread.tls_array[0].base1 = 112,
cpu_timers[2].next = 0xdb9a7838,
crash> task_struct.comm,thread.tls_array[0].dpl 0xdb9a7550
comm = "bash\000\000\000\000\000\000\000\000\000\000\000"
thread.tls_array[0].dpl = 3,
I'm looking forward to your comments/suggestions.
Best regards,
Alexandr
--- crash-7.1.0.orig/symbols.c 2015-02-06 21:44:11.000000000 +0300
+++ crash-7.1.0/symbols.c 2015-05-11 16:11:56.587128595 +0300
@@ -93,6 +93,7 @@ static int dereference_pointer(ulong, st
#define PARSE_FOR_DATA (1)
#define PARSE_FOR_DECLARATION (2)
static void parse_for_member(struct datatype_member *, ulong);
+void parse_for_member_new(struct datatype_member *, ulong);
static int show_member_offset(FILE *, struct datatype_member *, char *);
@@ -5576,17 +5577,18 @@ dump_struct_member(char *s, ulong addr,
FREEBUF(buf);
error(FATAL, "invalid structure name: %s\n", dm->name);
}
- if (!MEMBER_EXISTS(dm->name, dm->member)) {
- FREEBUF(buf);
- error(FATAL, "invalid structure member name: %s\n",
- dm->member);
- }
set_temporary_radix(radix, &restore_radix);
open_tmpfile();
print_struct(dm->name, addr);
- parse_for_member(dm, PARSE_FOR_DATA);
+
+ if (MEMBER_EXISTS(dm->name, dm->member)) {
+ parse_for_member(dm, PARSE_FOR_DATA);
+ } else {
+ parse_for_member_new(dm, PARSE_FOR_DATA);
+ }
+
close_tmpfile();
restore_current_radix(restore_radix);
@@ -6026,8 +6028,7 @@ cmd_datatype_common(ulong flags)
if ((count_chars(args[optind], ',')+1) > MAXARGS)
error(FATAL, "too many members in comma-separated list!\n");
- if ((count_chars(args[optind], '.') > 1) ||
- (LASTCHAR(args[optind]) == ',') ||
+ if ((LASTCHAR(args[optind]) == ',') ||
(LASTCHAR(args[optind]) == '.'))
error(FATAL, "invalid format: %s\n", args[optind]);
@@ -6219,6 +6220,10 @@ do_datatype_addr(struct datatype_member
i = 0;
do {
if (argc_members) {
+ /* This call works fine with fields
+ * of the second, third, ... levels.
+ * There is no need to fix it
+ */
if (!member_to_datatype(memberlist[i], dm,
ANON_MEMBER_QUERY))
error(FATAL, "invalid data structure reference: %s.%s\n",
@@ -6250,7 +6255,12 @@ do_datatype_addr(struct datatype_member
if (dm->member) {
if (!((flags & DEREF_POINTERS) &&
dereference_pointer(addr, dm, flags)))
- parse_for_member(dm, PARSE_FOR_DATA);
+ {
+ if (count_chars(dm->member,
'.'))
+ parse_for_member_new(dm,
PARSE_FOR_DATA);
+ else
+ parse_for_member(dm,
PARSE_FOR_DATA);
+ }
close_tmpfile();
}
@@ -6275,6 +6285,10 @@ do_datatype_declaration(struct datatype_
if (CRASHDEBUG(1))
dump_datatype_member(fp, dm);
+ if (dm->member && count_chars(dm->member, '.'))
+ error(FATAL, "invalid data structure reference: %s.%s\n",
+ dm->name, dm->member);
+
open_tmpfile();
whatis_datatype(dm->name, flags, pc->tmpfile);
rewind(pc->tmpfile);
@@ -7383,6 +7397,270 @@ next_item:
}
}
+struct struct_elem {
+ char field_name[BUFSIZE];
+ unsigned char field_len;
+ char value[BUFSIZE];
+ unsigned char is_array_root:1;
+
+ struct struct_elem *parent;
+ struct struct_elem *inner;
+ struct struct_elem *next;
+ struct struct_elem *prev;
+};
+
+#define ALLOC_XXX_ELEMENT(xxx, clone_parent) \
+{ \
+ if (NULL == current) { \
+ error(FATAL, "Internal error while parsing structure %s\n",
dm->name); \
+ } \
+ current->xxx = calloc(1, sizeof(struct struct_elem)); \
+ if (clone_parent) current->xxx->parent = current->parent; \
+ else current->xxx->parent = current; \
+ current = current->xxx; \
+}
+
+#define ALLOC_INNER_ELEMENT { ALLOC_XXX_ELEMENT(inner, 0) }
+#define ALLOC_NEXT_ELEMENT { ALLOC_XXX_ELEMENT(next, 1) }
+
+void free_structure(struct struct_elem *p) {
+ if (p == NULL)
+ return;
+ free_structure(p->inner);
+ free_structure(p->next);
+ free(p);
+}
+
+unsigned char is_right_brace(const char *b) {
+ unsigned char r = 0;
+ for (; *b == ' '; b++);
+ if (*b == '}') {
+ b++;
+ r = 1;
+ if (*b == '}') {
+ r = 2;
+ b++;
+ }
+ }
+
+ if (*b == ',')
+ b++;
+
+ if (*b == '\0')
+ return r;
+ else
+ return 0;
+}
+
+struct struct_elem *find_node(struct struct_elem *s, char *n) {
+ char *p, *b, *e;
+ struct struct_elem *t = s;
+ unsigned i;
+
+ if (('\0' == *n) || (NULL == s))
+ return s;
+
+ /* [n .. p) - struct member with index*/
+ if (NULL == (p = strstr(n, ".")))
+ p = n + strlen(n);
+
+ /* [n .. b) - struct member without index*/
+ for (b = n; (b < p) && (*b != '['); b++);
+
+ /* s - is the current level of items [s, s->next, ..., s->...->next] */
+ for (; s; s = s->next) {
+ if (*s->field_name == '\0')
+ continue;
+
+ /* `field_name` doesn't match */
+ if (((b - n) != s->field_len) || memcmp(s->field_name, n, b - n))
+ continue;
+
+ if (*b == '[') { /* Array */
+ i = strtol(b + 1, &e, 10);
+ /* Check if the current node is array and
+ * we've parsed index more or less correctly
+ */
+ if (!(s->is_array_root && *e == ']'&& (e != b +
1)))
+ return NULL;
+
+ /* Look for the i-th element */
+ for (s = s->inner; s && i; s = s->next, i--);
+ if (i || (NULL == s))
+ return NULL;
+ }
+
+ /* Ok. We've found node, it's - the last member
+ * in our search string, let's return it.
+ */
+ if ('\0' == *p)
+ return s;
+ else
+ return find_node(s->inner, p + 1);
+ }
+
+ // We haven't found any field.
+ // Might happen, we've encountered anonymous structure
+ // of union. Lets try every record without `field_name`
+ s = t;
+ t = NULL;
+ for(; s; s = s->next) {
+ if (*s->field_name)
+ continue;
+ t = find_node(s->inner, n);
+ if (t)
+ break;
+ }
+
+ return t;
+}
+
+void dump_node(struct struct_elem *p, char *f, unsigned char level, unsigned
char is_array) {
+ unsigned int i;
+ if (p == NULL)
+ return;
+ do {
+#define PUT_INDENTED_STRING(m, ...) { \
+ for (i = 0; i++ < 2 + 2 * (m * is_array + level); printf(" ")); \
+ printf(__VA_ARGS__); }
+
+ if (p->inner) {
+ if (*p->field_name) {
+ PUT_INDENTED_STRING(1, "%s = %s\n", f ? f : p->field_name,
p->inner->is_array_root ? "{{" : "{");
+ } else {
+ if (f) /* For union */
+ PUT_INDENTED_STRING(1, "%s = ", f);
+ PUT_INDENTED_STRING(1, "%s\n", p->inner->is_array_root
?
"{{" : "{");
+ }
+ dump_node(p->inner, NULL, is_array + level + 1,
p->inner->is_array_root);
+ PUT_INDENTED_STRING(1, "%s%s\n", p->inner->is_array_root ?
"}}"
: "}", (p->next && !p->next->is_array_root) ? "," :
"");
+ } else {
+ PUT_INDENTED_STRING(1, "%s = %s%s", f ? f : p->field_name,
p->value, p->next ? ",\n" : "\n");
+ }
+ if (level) {
+ p = p->next;
+ if (p && p->is_array_root)
+ PUT_INDENTED_STRING(0, "}, {\n");
+ }
+ } while (p && level);
+}
+
+void parse_for_member_new(struct datatype_member *dm,
+ ulong __attribute__ ((unused)) flag)
+{
+ struct struct_elem *i, *current = NULL, *root = NULL;
+
+ char buf[BUFSIZE];
+ char *p, *p1;
+ char *s_e; // structure_element
+ unsigned int len;
+ unsigned char trailing_comma, braces, found = 0;
+
+ rewind(pc->tmpfile);
+
+ root = calloc(1, sizeof(struct struct_elem));
+ current = root;
+ ALLOC_INNER_ELEMENT;
+
+ while (fgets(buf, BUFSIZE, pc->tmpfile)) {
+ len = strlen(buf) - 1;
+ for (; buf[len] <= ' '; buf[len--] = '\0');
+ if ((trailing_comma = (buf[len] == ',')))
+ buf[len--] = '\0';
+
+ if ((braces = is_right_brace(buf))) {
+ for (; braces && current; braces--)
+ current = current->parent;
+
+ if ((current->parent == root) || trailing_comma)
+ ALLOC_NEXT_ELEMENT;
+ continue;
+ }
+
+ for (p1 = buf; *p1 == ' '; p1++);
+
+ if (NULL != (p = strstr(buf, " = "))) {
+ s_e = p + 3;
+ } else {
+ s_e = p1;
+ }
+
+ /*
+ * After that we have pointers:
+ * foobar = bazzz
+ * -----^ ^ ^
+ * | ------| |
+ * | | |
+ * p1 p s_e
+ *
+ * OR
+ *
+ * {
+ * ^
+ * |
+ * ---------
+ * | |
+ * p1 s_e
+ *
+ * p == NULL
+ *
+ *
+ * p1 - the first non-whitespace symbol in line
+ * p - pointer to line ' = '. If not NULL, there is identifier
+ * s_e - element of structure (brace / double brace / array
separator / scalar :))
+ *
+ */
+
+ if (current && p) strncpy(current->field_name, p1, p - p1);
+ current->field_len = p - p1;
+
+ if ( p && (*s_e != '{' || (*s_e == '{' &&
buf[len] == '}') )) {
+ /* Scalar or one-line array
+ * next = 0x0
+ * or
+ * files = {0x0, 0x0}
+ */
+ strcpy(current->value, s_e);
+ if (trailing_comma) ALLOC_NEXT_ELEMENT;
+ }
+ else
+ if ( *s_e == '{' ) {
+ ALLOC_INNER_ELEMENT;
+ if (*(s_e + 1) == '{') {
+ current->parent->is_array_root = 1;
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+ else
+ if (strstr(s_e, "}, {")) {
+ /* Next array element */
+ current = current->parent;
+ ALLOC_NEXT_ELEMENT;
+ ALLOC_INNER_ELEMENT;
+ }
+ else
+ if (buf == (p = strstr(buf, "struct "))) {
+ p += 7; /* strlen "struct " */
+ p1 = strstr(buf, " {");
+ strncpy(current->field_name, p, p1 - p);
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+
+ for (i = root->inner; i; i = i->next) {
+ if ((current = find_node(i->inner, dm->member))) {
+ dump_node(current, dm->member, 0, 0);
+ found = 1;
+ break;
+ }
+ }
+
+ free_structure(root);
+
+ if (!found)
+ error(WARNING, "invalid structure reference: %s\n", dm->member);
+}
+
/*
* Dig out a member name from a formatted gdb structure declaration dump,
* and print its offset from the named structure passed in.
--- crash-7.1.0.orig/task.c 2015-02-06 21:44:11.000000000 +0300
+++ crash-7.1.0/task.c 2015-05-11 15:52:57.387111513 +0300
@@ -107,6 +107,8 @@ static int sort_by_last_run(const void *
static void sort_context_array_by_last_run(void);
static void show_ps_summary(ulong);
static void irqstacks_init(void);
+static void parse_task_thread(int argcnt, char *arglist[], struct
task_context *);
+void parse_for_member_new(struct datatype_member *, ulong);
/*
* Figure out how much space will be required to hold the task context
@@ -2746,13 +2748,9 @@ task_struct_member(struct task_context *
int argcnt;
char *arglist[MAXARGS];
char *refcopy;
- char buf[BUFSIZE];
- char lookfor1[BUFSIZE];
- char lookfor2[BUFSIZE];
- char lookfor3[BUFSIZE];
- int header_printed;
-
- header_printed = FALSE;
+ unsigned char call_new_parser = 0;
+ struct datatype_member dm;
+ char *member = GETBUF(BUFSIZE);
if ((count_chars(ref->str, ',')+1) > MAXARGS) {
error(INFO,
@@ -2767,14 +2765,39 @@ task_struct_member(struct task_context *
argcnt = parse_line(refcopy, arglist);
for (i = 0; i < argcnt; i++)
if (!MEMBER_EXISTS("task_struct", arglist[i]) &&
- !MEMBER_EXISTS("thread_info", arglist[i]))
- error(INFO, "%s: not a task_struct or thread_info member\n",
- arglist[i]);
-
+ !MEMBER_EXISTS("thread_info", arglist[i])) {
+ if (count_chars(arglist[i], '.') || count_chars(arglist[i], '['))
+ call_new_parser = 1;
+ else
+ error(INFO, "%s: not a task_struct or "
+ "thread_info member\n", arglist[i]);
+ }
open_tmpfile();
dump_struct("task_struct", tc->task, radix);
- if (tt->flags & THREAD_INFO)
- dump_struct("thread_info", tc->thread_info, radix);
+ if (tt->flags & THREAD_INFO)
+ dump_struct("thread_info", tc->thread_info, radix);
+ if (call_new_parser) {
+ for (i = 0; i < argcnt; i++) {
+ dm.member = arglist[i];
+ parse_for_member_new(&dm, 0);
+ }
+ } else {
+ parse_task_thread(argcnt, arglist, tc);
+ }
+ close_tmpfile();
+
+ FREEBUF(member);
+
+}
+
+static void parse_task_thread(int argcnt, char *arglist[], struct
task_context *tc) {
+ char buf[BUFSIZE];
+ char lookfor1[BUFSIZE];
+ char lookfor2[BUFSIZE];
+ char lookfor3[BUFSIZE];
+ int header_printed = FALSE;
+ int i;
+
rewind(pc->tmpfile);
BZERO(lookfor1, BUFSIZE);
@@ -2825,7 +2848,6 @@ task_struct_member(struct task_context *
}
}
}
- close_tmpfile();
}
static char *ps_exclusive =
--- crash-7.1.0.orig/tools.c 2015-02-06 21:44:11.000000000 +0300
+++ crash-7.1.0/tools.c 2015-05-11 15:52:57.391111513 +0300
@@ -3526,13 +3526,9 @@ do_list(struct list_data *ld)
dump_struct(ld->structname[i],
next - ld->list_head_offset, radix);
break;
- case 1:
+ default:
dump_struct_members(ld, i, next);
break;
- default:
- error(FATAL,
- "invalid structure reference: %s\n",
- ld->structname[i]);
}
}
}
--
Crash-utility mailing list
Crash-utility(a)redhat.com
https://www.redhat.com/mailman/listinfo/crash-utility
6:26 a.m.
Hi Dave,
thank you for the comments. Here is the fixed patch.
Best,
Alexandr
--- crash-7.1.0.orig/symbols.c 2015-05-13 11:39:12.401474372 +0300
+++ crash-7.1.0/symbols.c 2015-05-13 13:57:08.193598469 +0300
@@ -94,6 +94,11 @@ static int dereference_pointer(ulong, st
#define PARSE_FOR_DECLARATION (2)
static void parse_for_member(struct datatype_member *, ulong);
static int show_member_offset(FILE *, struct datatype_member *, char *);
+struct struct_elem;
+static void free_structure(struct struct_elem *);
+static unsigned char is_right_brace(const char *);
+static struct struct_elem *find_node(struct struct_elem *, char *);
+static void dump_node(struct struct_elem *, char *, unsigned char, unsigned char);
/*
@@ -5576,17 +5581,18 @@ dump_struct_member(char *s, ulong addr,
FREEBUF(buf);
error(FATAL, "invalid structure name: %s\n", dm->name);
}
- if (!MEMBER_EXISTS(dm->name, dm->member)) {
- FREEBUF(buf);
- error(FATAL, "invalid structure member name: %s\n",
- dm->member);
- }
set_temporary_radix(radix, &restore_radix);
open_tmpfile();
print_struct(dm->name, addr);
- parse_for_member(dm, PARSE_FOR_DATA);
+
+ if (MEMBER_EXISTS(dm->name, dm->member)) {
+ parse_for_member(dm, PARSE_FOR_DATA);
+ } else {
+ parse_for_member_new(dm, PARSE_FOR_DATA);
+ }
+
close_tmpfile();
restore_current_radix(restore_radix);
@@ -6026,8 +6032,7 @@ cmd_datatype_common(ulong flags)
if ((count_chars(args[optind], ',')+1) > MAXARGS)
error(FATAL, "too many members in comma-separated list!\n");
- if ((count_chars(args[optind], '.') > 1) ||
- (LASTCHAR(args[optind]) == ',') ||
+ if ((LASTCHAR(args[optind]) == ',') ||
(LASTCHAR(args[optind]) == '.'))
error(FATAL, "invalid format: %s\n", args[optind]);
@@ -6219,6 +6224,10 @@ do_datatype_addr(struct datatype_member
i = 0;
do {
if (argc_members) {
+ /* This call works fine with fields
+ * of the second, third, ... levels.
+ * There is no need to fix it
+ */
if (!member_to_datatype(memberlist[i], dm,
ANON_MEMBER_QUERY))
error(FATAL, "invalid data structure reference: %s.%s\n",
@@ -6250,7 +6259,12 @@ do_datatype_addr(struct datatype_member
if (dm->member) {
if (!((flags & DEREF_POINTERS) &&
dereference_pointer(addr, dm, flags)))
- parse_for_member(dm, PARSE_FOR_DATA);
+ {
+ if (count_chars(dm->member, '.'))
+ parse_for_member_new(dm, PARSE_FOR_DATA);
+ else
+ parse_for_member(dm, PARSE_FOR_DATA);
+ }
close_tmpfile();
}
@@ -6275,6 +6289,10 @@ do_datatype_declaration(struct datatype_
if (CRASHDEBUG(1))
dump_datatype_member(fp, dm);
+ if (dm->member && count_chars(dm->member, '.'))
+ error(FATAL, "invalid data structure reference: %s.%s\n",
+ dm->name, dm->member);
+
open_tmpfile();
whatis_datatype(dm->name, flags, pc->tmpfile);
rewind(pc->tmpfile);
@@ -7383,6 +7401,277 @@ next_item:
}
}
+struct struct_elem {
+ char field_name[BUFSIZE];
+ unsigned char field_len;
+ char value[BUFSIZE];
+ unsigned char is_array_root:1;
+
+ struct struct_elem *parent;
+ struct struct_elem *inner;
+ struct struct_elem *next;
+ struct struct_elem *prev;
+};
+
+#define ALLOC_XXX_ELEMENT(xxx, clone_parent) \
+{ \
+ if (NULL == current) { \
+ error(FATAL, "Internal error while parsing structure %s\n", dm->name); \
+ } \
+ current->xxx = (struct struct_elem *)GETBUF(sizeof(struct struct_elem)); \
+ if (clone_parent) current->xxx->parent = current->parent; \
+ else current->xxx->parent = current; \
+ current = current->xxx; \
+}
+
+#define ALLOC_INNER_ELEMENT { ALLOC_XXX_ELEMENT(inner, 0) }
+#define ALLOC_NEXT_ELEMENT { ALLOC_XXX_ELEMENT(next, 1) }
+
+static void
+free_structure(struct struct_elem *p)
+{
+ if (p == NULL)
+ return;
+ free_structure(p->inner);
+ free_structure(p->next);
+ FREEBUF(p);
+}
+
+static unsigned char
+is_right_brace(const char *b)
+{
+ unsigned char r = 0;
+ for (; *b == ' '; b++);
+ if (*b == '}') {
+ b++;
+ r = 1;
+ if (*b == '}') {
+ r = 2;
+ b++;
+ }
+ }
+
+ if (*b == ',')
+ b++;
+
+ if (*b == '\0')
+ return r;
+ else
+ return 0;
+}
+
+static struct struct_elem *
+find_node(struct struct_elem *s, char *n)
+{
+ char *p, *b, *e;
+ struct struct_elem *t = s;
+ unsigned i;
+
+ if (('\0' == *n) || (NULL == s))
+ return s;
+
+ /* [n .. p) - struct member with index*/
+ if (NULL == (p = strstr(n, ".")))
+ p = n + strlen(n);
+
+ /* [n .. b) - struct member without index*/
+ for (b = n; (b < p) && (*b != '['); b++);
+
+ /* s - is the current level of items [s, s->next, ..., s->...->next] */
+ for (; s; s = s->next) {
+ if (*s->field_name == '\0')
+ continue;
+
+ /* `field_name` doesn't match */
+ if (((b - n) != s->field_len) || memcmp(s->field_name, n, b - n))
+ continue;
+
+ if (*b == '[') { /* Array */
+ i = strtol(b + 1, &e, 10);
+ /* Check if the current node is array and
+ * we've parsed index more or less correctly
+ */
+ if (!(s->is_array_root && *e == ']' && (e != b + 1)))
+ return NULL;
+
+ /* Look for the i-th element */
+ for (s = s->inner; s && i; s = s->next, i--);
+ if (i || (NULL == s))
+ return NULL;
+ }
+
+ /* Ok. We've found node, it's - the last member
+ * in our search string, let's return it.
+ */
+ if ('\0' == *p)
+ return s;
+ else
+ return find_node(s->inner, p + 1);
+ }
+
+ // We haven't found any field.
+ // Might happen, we've encountered anonymous structure
+ // of union. Lets try every record without `field_name`
+ s = t;
+ t = NULL;
+ for (; s; s = s->next) {
+ if (*s->field_name)
+ continue;
+ t = find_node(s->inner, n);
+ if (t)
+ break;
+ }
+
+ return t;
+}
+
+static void
+dump_node(struct struct_elem *p, char *f, unsigned char level, unsigned char is_array)
+{
+ unsigned int i;
+ if (p == NULL)
+ return;
+ do {
+#define PUT_INDENTED_STRING(m, ...) { \
+ for (i = 0; i++ < 2 + 2 * (m * is_array + level); fprintf(pc->saved_fp, "
")); \
+ fprintf(pc->saved_fp, __VA_ARGS__); }
+
+ if (p->inner) {
+ if (*p->field_name) {
+ PUT_INDENTED_STRING(1, "%s = %s\n", f ? f : p->field_name,
p->inner->is_array_root ? "{{" : "{");
+ } else {
+ if (f) /* For union */
+ PUT_INDENTED_STRING(1, "%s = ", f);
+ PUT_INDENTED_STRING(1, "%s\n", p->inner->is_array_root ?
"{{" : "{");
+ }
+ dump_node(p->inner, NULL, is_array + level + 1, p->inner->is_array_root);
+ PUT_INDENTED_STRING(1, "%s%s\n", p->inner->is_array_root ?
"}}" : "}", (p->next && !p->next->is_array_root) ?
"," : "");
+ } else {
+ PUT_INDENTED_STRING(1, "%s = %s%s", f ? f : p->field_name, p->value,
p->next ? ",\n" : "\n");
+ }
+ if (level) {
+ p = p->next;
+ if (p && p->is_array_root)
+ PUT_INDENTED_STRING(0, "}, {\n");
+ }
+ } while (p && level);
+}
+
+void
+parse_for_member_new(struct datatype_member *dm,
+ ulong __attribute__ ((unused)) flag)
+{
+ struct struct_elem *i, *current = NULL, *root = NULL;
+
+ char buf[BUFSIZE];
+ char *p, *p1;
+ char *s_e; // structure_element
+ unsigned int len;
+ unsigned char trailing_comma, braces, found = 0;
+
+ rewind(pc->tmpfile);
+
+ root = (struct struct_elem *)GETBUF(sizeof(struct struct_elem));
+ current = root;
+ ALLOC_INNER_ELEMENT;
+
+ while (fgets(buf, BUFSIZE, pc->tmpfile)) {
+ len = strlen(buf) - 1;
+ for (; buf[len] <= ' '; buf[len--] = '\0');
+ if ((trailing_comma = (buf[len] == ',')))
+ buf[len--] = '\0';
+
+ if ((braces = is_right_brace(buf))) {
+ for (; braces && current; braces--)
+ current = current->parent;
+
+ if ((current->parent == root) || trailing_comma)
+ ALLOC_NEXT_ELEMENT;
+ continue;
+ }
+
+ for (p1 = buf; *p1 == ' '; p1++);
+
+ if (NULL != (p = strstr(buf, " = "))) {
+ s_e = p + 3;
+ } else {
+ s_e = p1;
+ }
+
+ /*
+ * After that we have pointers:
+ * foobar = bazzz
+ * -----^ ^ ^
+ * | ------| |
+ * | | |
+ * p1 p s_e
+ *
+ * OR
+ *
+ * {
+ * ^
+ * |
+ * ---------
+ * | |
+ * p1 s_e
+ *
+ * p == NULL
+ *
+ *
+ * p1 - the first non-whitespace symbol in line
+ * p - pointer to line ' = '.
+ * If not NULL, there is identifier
+ * s_e - element of structure (brace / double brace / array separator / scalar)
+ *
+ */
+
+ if (current && p) strncpy(current->field_name, p1, p - p1);
+ current->field_len = p - p1;
+
+ if ( p && (*s_e != '{' || (*s_e == '{' && buf[len] ==
'}') )) {
+ /* Scalar or one-line array
+ * next = 0x0
+ * or
+ * files = {0x0, 0x0}
+ */
+ strcpy(current->value, s_e);
+ if (trailing_comma) ALLOC_NEXT_ELEMENT;
+ }
+ else if ( *s_e == '{' ) {
+ ALLOC_INNER_ELEMENT;
+ if (*(s_e + 1) == '{') {
+ current->parent->is_array_root = 1;
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+ else if (strstr(s_e, "}, {")) {
+ /* Next array element */
+ current = current->parent;
+ ALLOC_NEXT_ELEMENT;
+ ALLOC_INNER_ELEMENT;
+ }
+ else if (buf == (p = strstr(buf, "struct "))) {
+ p += 7; /* strlen "struct " */
+ p1 = strstr(buf, " {");
+ strncpy(current->field_name, p, p1 - p);
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+
+ for (i = root->inner; i; i = i->next) {
+ if ((current = find_node(i->inner, dm->member))) {
+ dump_node(current, dm->member, 0, 0);
+ found = 1;
+ break;
+ }
+ }
+
+ free_structure(root);
+
+ if (!found)
+ error(WARNING, "invalid structure reference: %s\n", dm->member);
+}
+
/*
* Dig out a member name from a formatted gdb structure declaration dump,
* and print its offset from the named structure passed in.
--- crash-7.1.0.orig/defs.h 2015-05-13 11:39:12.405474372 +0300
+++ crash-7.1.0/defs.h 2015-05-13 13:32:43.809576510 +0300
@@ -4641,6 +4641,7 @@ void dump_trace(void **);
int enumerator_value(char *, long *);
int dump_enumerator_list(char *);
struct load_module *init_module_function(ulong);
+void parse_for_member_new(struct datatype_member *, ulong);
/*
* memory.c
--- crash-7.1.0.orig/task.c 2015-05-13 11:39:12.409474373 +0300
+++ crash-7.1.0/task.c 2015-05-13 13:32:43.809576510 +0300
@@ -107,6 +107,7 @@ static int sort_by_last_run(const void *
static void sort_context_array_by_last_run(void);
static void show_ps_summary(ulong);
static void irqstacks_init(void);
+static void parse_task_thread(int argcnt, char *arglist[], struct task_context *);
/*
* Figure out how much space will be required to hold the task context
@@ -2746,13 +2747,9 @@ task_struct_member(struct task_context *
int argcnt;
char *arglist[MAXARGS];
char *refcopy;
- char buf[BUFSIZE];
- char lookfor1[BUFSIZE];
- char lookfor2[BUFSIZE];
- char lookfor3[BUFSIZE];
- int header_printed;
-
- header_printed = FALSE;
+ unsigned char call_new_parser = 0;
+ struct datatype_member dm;
+ char *member = GETBUF(BUFSIZE);
if ((count_chars(ref->str, ',')+1) > MAXARGS) {
error(INFO,
@@ -2767,14 +2764,39 @@ task_struct_member(struct task_context *
argcnt = parse_line(refcopy, arglist);
for (i = 0; i < argcnt; i++)
if (!MEMBER_EXISTS("task_struct", arglist[i]) &&
- !MEMBER_EXISTS("thread_info", arglist[i]))
- error(INFO, "%s: not a task_struct or thread_info member\n",
- arglist[i]);
-
+ !MEMBER_EXISTS("thread_info", arglist[i])) {
+ if (count_chars(arglist[i], '.') || count_chars(arglist[i], '['))
+ call_new_parser = 1;
+ else
+ error(INFO, "%s: not a task_struct or "
+ "thread_info member\n", arglist[i]);
+ }
open_tmpfile();
dump_struct("task_struct", tc->task, radix);
if (tt->flags & THREAD_INFO)
dump_struct("thread_info", tc->thread_info, radix);
+ if (call_new_parser) {
+ for (i = 0; i < argcnt; i++) {
+ dm.member = arglist[i];
+ parse_for_member_new(&dm, 0);
+ }
+ } else {
+ parse_task_thread(argcnt, arglist, tc);
+ }
+ close_tmpfile();
+
+ FREEBUF(member);
+
+}
+
+static void parse_task_thread(int argcnt, char *arglist[], struct task_context *tc) {
+ char buf[BUFSIZE];
+ char lookfor1[BUFSIZE];
+ char lookfor2[BUFSIZE];
+ char lookfor3[BUFSIZE];
+ int header_printed = FALSE;
+ int i;
+
rewind(pc->tmpfile);
BZERO(lookfor1, BUFSIZE);
@@ -2825,7 +2847,6 @@ task_struct_member(struct task_context *
}
}
}
- close_tmpfile();
}
static char *ps_exclusive =
--- crash-7.1.0.orig/tools.c 2015-05-13 11:39:12.409474373 +0300
+++ crash-7.1.0/tools.c 2015-05-13 13:32:43.813576510 +0300
@@ -3526,13 +3526,9 @@ do_list(struct list_data *ld)
dump_struct(ld->structname[i],
next - ld->list_head_offset, radix);
break;
- case 1:
+ default:
dump_struct_members(ld, i, next);
break;
- default:
- error(FATAL,
- "invalid structure reference: %s\n",
- ld->structname[i]);
}
}
}
3:02 p.m.
----- Original Message -----
Hi Dave,
thank you for the comments. Here is the fixed patch.
Best,
Alexandr
Hi Alexandr,
I actually haven't studied the meat of parse_for_member_new() yet,
but in testing the patch, I've come up with a few issues that still
need addressing.
Unlike what you have done for "struct" and "list", when the
"task"
command calls task_struct_member(), if *any* of the comma-separated
members are the new complicated format, you set the call_new_parser
flag, so it somewhat defeats the purpose of having the flag at all:
if (call_new_parser) {
for (i = 0; i < argcnt; i++) {
dm.member = arglist[i];
parse_for_member_new(&dm, 0);
}
} else {
parse_task_thread(argcnt, arglist, tc);
}
I still would like the confidence of knowing that the old function
will still be used with the simple "struct.member" format.
And related to the issue above, here's a bug -- the "task" command
is quite often useful to call from "foreach", where for each task,
the task's banner is displayed followed by the requested data.
For example:
crash> foreach task -R prio,sched_class
PID: 0 TASK: ffffffff81c13440 CPU: 0 COMMAND: "swapper/0"
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
PID: 0 TASK: ffff88021282d330 CPU: 1 COMMAND: "swapper/1"
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
PID: 0 TASK: ffff88021282dac0 CPU: 2 COMMAND: "swapper/2"
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
PID: 0 TASK: ffff88021282e250 CPU: 3 COMMAND: "swapper/3"
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
PID: 1 TASK: ffff880212828000 CPU: 2 COMMAND: "systemd"
prio = 0x78,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
PID: 2 TASK: ffff880212828790 CPU: 3 COMMAND: "kthreadd"
prio = 0x78,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
PID: 3 TASK: ffff880212828f20 CPU: 0 COMMAND: "ksoftirqd/0"
prio = 0x78,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
PID: 5 TASK: ffff880212829e40 CPU: 0 COMMAND: "kworker/0:0H"
prio = 0x64,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
PID: 7 TASK: ffff88021282ad60 CPU: 0 COMMAND: "kworker/u:0H"
prio = 0x64,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
PID: 8 TASK: ffff88021282b4f0 CPU: 0 COMMAND: "migration/0"
prio = 0x0,
sched_class = 0xffffffff81808d20 <stop_sched_class>,
...
But when I add a new extended reference, the banner doesn't get displayed,
rendering the command useless:
crash> foreach task -R prio,sched_class,se.on_rq
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
se.on_rq = 0x0,
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
se.on_rq = 0x0,
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
se.on_rq = 0x0,
prio = 0x78,
sched_class = 0xffffffff81808960 <idle_sched_class>,
se.on_rq = 0x0,
prio = 0x78,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
se.on_rq = 0x0,
prio = 0x78,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
se.on_rq = 0x0,
prio = 0x78,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
se.on_rq = 0x0,
prio = 0x64,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
se.on_rq = 0x0,
prio = 0x64,
sched_class = 0xffffffff81808a40 <fair_sched_class>,
se.on_rq = 0x0,
prio = 0x0,
sched_class = 0xffffffff81808d20 <stop_sched_class>,
se.on_rq = 0x0,
...
Also, similar to the "list" command, the "tree" command also supports
the
"-s struct.member" option:
crash> help tree
... [ cut ] ...
-s struct For each entry in a tree, format and print it as this type of data
structure; use the "struct.member" format in order to display a
particular member of the structure. To display multiple members
of a structure, use a comma-separated list of members.
Can you look into putting support there as well?
I'm also going to need "help" page updates for the commands that use
"struct.member"
arguments. I would do it, but if you want to get a head-start, please feel free
to do so.
Thanks,
Dave
4:40 p.m.
Hi Dave,
I'm sorry for my poor Inglish :)
I actually haven't studied the meat of parse_for_member_new()
yet,
but in testing the patch, I've come up with a few issues that still
need addressing.
Could you please clarify your last point?
Unlike what you have done for "struct" and
"list", when the "task"
command calls task_struct_member(), if *any* of the comma-separated
members are the new complicated format, you set the call_new_parser
flag, so it somewhat defeats the purpose of having the flag at all:
if (call_new_parser) {
for (i = 0; i < argcnt; i++) {
dm.member = arglist[i];
parse_for_member_new(&dm, 0);
}
} else {
parse_task_thread(argcnt, arglist, tc);
}
If I understood you right, you want the `parse_task_thread` to be called
for every simple field and `parse_for_member_new` should be called for
complicated format only. That is if you specify line
% task -R foo,bar,baz.foo.xxx
`parse_task_thread` should be called for `foo` and `bar`, whereas
`parse_for_member_new` would be called for `baz.foo.xxx` only.
Am I right?
I still would like the confidence of knowing that the old function
will still be used with the simple "struct.member" format.
And related to the issue above, here's a bug -- the "task" command
is quite often useful to call from "foreach", where for each task,
the task's banner is displayed followed by the requested data.
...
But when I add a new extended reference, the banner doesn't get
displayed,
rendering the command useless:
...
I will fix it.
Also, similar to the "list" command, the "tree"
command also supports the
"-s struct.member" option:
crash> help tree
... [ cut ] ...
-s struct For each entry in a tree, format and print it as this type of data
structure; use the "struct.member" format in order to display a
particular member of the structure. To display multiple members
of a structure, use a comma-separated list of members.
Can you look into putting support there as well?
Ok, I will fix it.
Thanks,
Alexandr
5:37 p.m.
----- Original Message -----
Hi Dave,
I'm sorry for my poor Inglish :)
> I actually haven't studied the meat of parse_for_member_new() yet,
> but in testing the patch, I've come up with a few issues that still
> need addressing.
Could you please clarify your last point?
If you mean the paragraph above, I meant that I haven't reviewed
parse_for_member_new() and its support functions, but have only done
some preliminary testing, which lead to the issues I listed below.
> Unlike what you have done for "struct" and "list", when the
"task"
> command calls task_struct_member(), if *any* of the comma-separated
> members are the new complicated format, you set the call_new_parser
> flag, so it somewhat defeats the purpose of having the flag at all:
>
> if (call_new_parser) {
> for (i = 0; i < argcnt; i++) {
> dm.member = arglist[i];
> parse_for_member_new(&dm, 0);
> }
> } else {
> parse_task_thread(argcnt, arglist, tc);
> }
If I understood you right, you want the `parse_task_thread` to be called
for every simple field and `parse_for_member_new` should be called for
complicated format only. That is if you specify line
% task -R foo,bar,baz.foo.xxx
`parse_task_thread` should be called for `foo` and `bar`, whereas
`parse_for_member_new` would be called for `baz.foo.xxx` only.
Am I right?
That's exactly right.
> I still would like the confidence of knowing that the old function
> will still be used with the simple "struct.member" format.
>
> And related to the issue above, here's a bug -- the "task" command
> is quite often useful to call from "foreach", where for each task,
> the task's banner is displayed followed by the requested data.
...
> But when I add a new extended reference, the banner doesn't get displayed,
> rendering the command useless:
...
I will fix it.
> Also, similar to the "list" command, the "tree" command also
supports the
> "-s struct.member" option:
>
> crash> help tree
> ... [ cut ] ...
>
> -s struct For each entry in a tree, format and print it as this type
> of data
> structure; use the "struct.member" format in order to
display a
> particular member of the structure. To display multiple members
> of a structure, use a comma-separated list of members.
>
> Can you look into putting support there as well?
Ok, I will fix it.
Thanks,
Alexandr
Great -- and you don't have to bother updating the "help task", "help
list" and
"help tree" descriptions. Let's just get the patch working first, and then
I'll
take care of the documentation.
Thanks,
Dave
5:40 p.m.
----- Original Message -----
Great -- and you don't have to bother updating the "help task", "help
list" and
"help tree" descriptions. Let's just get the patch working first, and then
I'll
take care of the documentation.
And of course the most important one, "help struct".
Thanks,
Dave
6:30 a.m.
Hi Dave,
please take a look at updated patch.
Thanks,
Alexandr
--- crash-7.1.0.orig/defs.h 2015-05-13 11:39:12.405474372 +0300
+++ crash-7.1.0/defs.h 2015-05-15 13:50:26.332183604 +0300
@@ -4641,6 +4641,7 @@ void dump_trace(void **);
int enumerator_value(char *, long *);
int dump_enumerator_list(char *);
struct load_module *init_module_function(ulong);
+void parse_for_member_new(struct datatype_member *, ulong);
/*
* memory.c
--- crash-7.1.0.orig/symbols.c 2015-05-13 11:39:12.401474372 +0300
+++ crash-7.1.0/symbols.c 2015-05-15 13:50:26.336183604 +0300
@@ -94,6 +94,11 @@ static int dereference_pointer(ulong, st
#define PARSE_FOR_DECLARATION (2)
static void parse_for_member(struct datatype_member *, ulong);
static int show_member_offset(FILE *, struct datatype_member *, char *);
+struct struct_elem;
+static void free_structure(struct struct_elem *);
+static unsigned char is_right_brace(const char *);
+static struct struct_elem *find_node(struct struct_elem *, char *);
+static void dump_node(struct struct_elem *, char *, unsigned char, unsigned char);
/*
@@ -5576,17 +5581,18 @@ dump_struct_member(char *s, ulong addr,
FREEBUF(buf);
error(FATAL, "invalid structure name: %s\n", dm->name);
}
- if (!MEMBER_EXISTS(dm->name, dm->member)) {
- FREEBUF(buf);
- error(FATAL, "invalid structure member name: %s\n",
- dm->member);
- }
set_temporary_radix(radix, &restore_radix);
open_tmpfile();
print_struct(dm->name, addr);
- parse_for_member(dm, PARSE_FOR_DATA);
+
+ if (MEMBER_EXISTS(dm->name, dm->member)) {
+ parse_for_member(dm, PARSE_FOR_DATA);
+ } else {
+ parse_for_member_new(dm, PARSE_FOR_DATA);
+ }
+
close_tmpfile();
restore_current_radix(restore_radix);
@@ -6026,8 +6032,7 @@ cmd_datatype_common(ulong flags)
if ((count_chars(args[optind], ',')+1) > MAXARGS)
error(FATAL, "too many members in comma-separated list!\n");
- if ((count_chars(args[optind], '.') > 1) ||
- (LASTCHAR(args[optind]) == ',') ||
+ if ((LASTCHAR(args[optind]) == ',') ||
(LASTCHAR(args[optind]) == '.'))
error(FATAL, "invalid format: %s\n", args[optind]);
@@ -6219,6 +6224,10 @@ do_datatype_addr(struct datatype_member
i = 0;
do {
if (argc_members) {
+ /* This call works fine with fields
+ * of the second, third, ... levels.
+ * There is no need to fix it
+ */
if (!member_to_datatype(memberlist[i], dm,
ANON_MEMBER_QUERY))
error(FATAL, "invalid data structure reference: %s.%s\n",
@@ -6250,7 +6259,12 @@ do_datatype_addr(struct datatype_member
if (dm->member) {
if (!((flags & DEREF_POINTERS) &&
dereference_pointer(addr, dm, flags)))
- parse_for_member(dm, PARSE_FOR_DATA);
+ {
+ if (count_chars(dm->member, '.'))
+ parse_for_member_new(dm, PARSE_FOR_DATA);
+ else
+ parse_for_member(dm, PARSE_FOR_DATA);
+ }
close_tmpfile();
}
@@ -6275,6 +6289,10 @@ do_datatype_declaration(struct datatype_
if (CRASHDEBUG(1))
dump_datatype_member(fp, dm);
+ if (dm->member && count_chars(dm->member, '.'))
+ error(FATAL, "invalid data structure reference: %s.%s\n",
+ dm->name, dm->member);
+
open_tmpfile();
whatis_datatype(dm->name, flags, pc->tmpfile);
rewind(pc->tmpfile);
@@ -7383,6 +7401,277 @@ next_item:
}
}
+struct struct_elem {
+ char field_name[BUFSIZE];
+ unsigned char field_len;
+ char value[BUFSIZE];
+ unsigned char is_array_root:1;
+
+ struct struct_elem *parent;
+ struct struct_elem *inner;
+ struct struct_elem *next;
+ struct struct_elem *prev;
+};
+
+#define ALLOC_XXX_ELEMENT(xxx, clone_parent) \
+{ \
+ if (NULL == current) { \
+ error(FATAL, "Internal error while parsing structure %s\n", dm->name); \
+ } \
+ current->xxx = (struct struct_elem *)GETBUF(sizeof(struct struct_elem)); \
+ if (clone_parent) current->xxx->parent = current->parent; \
+ else current->xxx->parent = current; \
+ current = current->xxx; \
+}
+
+#define ALLOC_INNER_ELEMENT { ALLOC_XXX_ELEMENT(inner, 0) }
+#define ALLOC_NEXT_ELEMENT { ALLOC_XXX_ELEMENT(next, 1) }
+
+static void
+free_structure(struct struct_elem *p)
+{
+ if (p == NULL)
+ return;
+ free_structure(p->inner);
+ free_structure(p->next);
+ FREEBUF(p);
+}
+
+static unsigned char
+is_right_brace(const char *b)
+{
+ unsigned char r = 0;
+ for (; *b == ' '; b++);
+ if (*b == '}') {
+ b++;
+ r = 1;
+ if (*b == '}') {
+ r = 2;
+ b++;
+ }
+ }
+
+ if (*b == ',')
+ b++;
+
+ if (*b == '\0')
+ return r;
+ else
+ return 0;
+}
+
+static struct struct_elem *
+find_node(struct struct_elem *s, char *n)
+{
+ char *p, *b, *e;
+ struct struct_elem *t = s;
+ unsigned i;
+
+ if (('\0' == *n) || (NULL == s))
+ return s;
+
+ /* [n .. p) - struct member with index*/
+ if (NULL == (p = strstr(n, ".")))
+ p = n + strlen(n);
+
+ /* [n .. b) - struct member without index*/
+ for (b = n; (b < p) && (*b != '['); b++);
+
+ /* s - is the current level of items [s, s->next, ..., s->...->next] */
+ for (; s; s = s->next) {
+ if (*s->field_name == '\0')
+ continue;
+
+ /* `field_name` doesn't match */
+ if (((b - n) != s->field_len) || memcmp(s->field_name, n, b - n))
+ continue;
+
+ if (*b == '[') { /* Array */
+ i = strtol(b + 1, &e, 10);
+ /* Check if the current node is array and
+ * we've parsed index more or less correctly
+ */
+ if (!(s->is_array_root && *e == ']' && (e != b + 1)))
+ return NULL;
+
+ /* Look for the i-th element */
+ for (s = s->inner; s && i; s = s->next, i--);
+ if (i || (NULL == s))
+ return NULL;
+ }
+
+ /* Ok. We've found node, it's - the last member
+ * in our search string, let's return it.
+ */
+ if ('\0' == *p)
+ return s;
+ else
+ return find_node(s->inner, p + 1);
+ }
+
+ // We haven't found any field.
+ // Might happen, we've encountered anonymous structure
+ // of union. Lets try every record without `field_name`
+ s = t;
+ t = NULL;
+ for (; s; s = s->next) {
+ if (*s->field_name)
+ continue;
+ t = find_node(s->inner, n);
+ if (t)
+ break;
+ }
+
+ return t;
+}
+
+static void
+dump_node(struct struct_elem *p, char *f, unsigned char level, unsigned char is_array)
+{
+ unsigned int i;
+ if (p == NULL)
+ return;
+ do {
+#define PUT_INDENTED_STRING(m, ...) { \
+ for (i = 0; i++ < 2 + 2 * (m * is_array + level); fprintf(pc->saved_fp, "
")); \
+ fprintf(pc->saved_fp, __VA_ARGS__); }
+
+ if (p->inner) {
+ if (*p->field_name) {
+ PUT_INDENTED_STRING(1, "%s = %s\n", f ? f : p->field_name,
p->inner->is_array_root ? "{{" : "{");
+ } else {
+ if (f) /* For union */
+ PUT_INDENTED_STRING(1, "%s = ", f);
+ PUT_INDENTED_STRING(1, "%s\n", p->inner->is_array_root ?
"{{" : "{");
+ }
+ dump_node(p->inner, NULL, is_array + level + 1, p->inner->is_array_root);
+ PUT_INDENTED_STRING(1, "%s%s\n", p->inner->is_array_root ?
"}}" : "}", (p->next && !p->next->is_array_root) ?
"," : "");
+ } else {
+ PUT_INDENTED_STRING(1, "%s = %s%s", f ? f : p->field_name, p->value,
p->next ? ",\n" : "\n");
+ }
+ if (level) {
+ p = p->next;
+ if (p && p->is_array_root)
+ PUT_INDENTED_STRING(0, "}, {\n");
+ }
+ } while (p && level);
+}
+
+void
+parse_for_member_new(struct datatype_member *dm,
+ ulong __attribute__ ((unused)) flag)
+{
+ struct struct_elem *i, *current = NULL, *root = NULL;
+
+ char buf[BUFSIZE];
+ char *p, *p1;
+ char *s_e; // structure_element
+ unsigned int len;
+ unsigned char trailing_comma, braces, found = 0;
+
+ rewind(pc->tmpfile);
+
+ root = (struct struct_elem *)GETBUF(sizeof(struct struct_elem));
+ current = root;
+ ALLOC_INNER_ELEMENT;
+
+ while (fgets(buf, BUFSIZE, pc->tmpfile)) {
+ len = strlen(buf) - 1;
+ for (; buf[len] <= ' '; buf[len--] = '\0');
+ if ((trailing_comma = (buf[len] == ',')))
+ buf[len--] = '\0';
+
+ if ((braces = is_right_brace(buf))) {
+ for (; braces && current; braces--)
+ current = current->parent;
+
+ if ((current->parent == root) || trailing_comma)
+ ALLOC_NEXT_ELEMENT;
+ continue;
+ }
+
+ for (p1 = buf; *p1 == ' '; p1++);
+
+ if (NULL != (p = strstr(buf, " = "))) {
+ s_e = p + 3;
+ } else {
+ s_e = p1;
+ }
+
+ /*
+ * After that we have pointers:
+ * foobar = bazzz
+ * -----^ ^ ^
+ * | ------| |
+ * | | |
+ * p1 p s_e
+ *
+ * OR
+ *
+ * {
+ * ^
+ * |
+ * ---------
+ * | |
+ * p1 s_e
+ *
+ * p == NULL
+ *
+ *
+ * p1 - the first non-whitespace symbol in line
+ * p - pointer to line ' = '.
+ * If not NULL, there is identifier
+ * s_e - element of structure (brace / double brace / array separator / scalar)
+ *
+ */
+
+ if (current && p) strncpy(current->field_name, p1, p - p1);
+ current->field_len = p - p1;
+
+ if ( p && (*s_e != '{' || (*s_e == '{' && buf[len] ==
'}') )) {
+ /* Scalar or one-line array
+ * next = 0x0
+ * or
+ * files = {0x0, 0x0}
+ */
+ strcpy(current->value, s_e);
+ if (trailing_comma) ALLOC_NEXT_ELEMENT;
+ }
+ else if ( *s_e == '{' ) {
+ ALLOC_INNER_ELEMENT;
+ if (*(s_e + 1) == '{') {
+ current->parent->is_array_root = 1;
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+ else if (strstr(s_e, "}, {")) {
+ /* Next array element */
+ current = current->parent;
+ ALLOC_NEXT_ELEMENT;
+ ALLOC_INNER_ELEMENT;
+ }
+ else if (buf == (p = strstr(buf, "struct "))) {
+ p += 7; /* strlen "struct " */
+ p1 = strstr(buf, " {");
+ strncpy(current->field_name, p, p1 - p);
+ ALLOC_INNER_ELEMENT;
+ }
+ }
+
+ for (i = root->inner; i; i = i->next) {
+ if ((current = find_node(i->inner, dm->member))) {
+ dump_node(current, dm->member, 0, 0);
+ found = 1;
+ break;
+ }
+ }
+
+ free_structure(root);
+
+ if (!found)
+ error(WARNING, "invalid structure reference: %s\n", dm->member);
+}
+
/*
* Dig out a member name from a formatted gdb structure declaration dump,
* and print its offset from the named structure passed in.
--- crash-7.1.0.orig/task.c 2015-05-13 11:39:12.409474373 +0300
+++ crash-7.1.0/task.c 2015-05-15 13:50:26.340183604 +0300
@@ -107,6 +107,7 @@ static int sort_by_last_run(const void *
static void sort_context_array_by_last_run(void);
static void show_ps_summary(ulong);
static void irqstacks_init(void);
+static void parse_task_thread(int argcnt, char *arglist[], struct task_context *);
/*
* Figure out how much space will be required to hold the task context
@@ -2743,16 +2744,13 @@ static void
task_struct_member(struct task_context *tc, unsigned int radix, struct reference *ref)
{
int i;
- int argcnt;
+ int argcnt, longargcnt = 0, shortargcnt = 0;
char *arglist[MAXARGS];
+ char *longarglist[MAXARGS];
+ char *shortarglist[MAXARGS];
char *refcopy;
- char buf[BUFSIZE];
- char lookfor1[BUFSIZE];
- char lookfor2[BUFSIZE];
- char lookfor3[BUFSIZE];
- int header_printed;
-
- header_printed = FALSE;
+ struct datatype_member dm;
+ char *member = GETBUF(BUFSIZE);
if ((count_chars(ref->str, ',')+1) > MAXARGS) {
error(INFO,
@@ -2765,16 +2763,51 @@ task_struct_member(struct task_context *
replace_string(refcopy, ",", ' ');
argcnt = parse_line(refcopy, arglist);
- for (i = 0; i < argcnt; i++)
- if (!MEMBER_EXISTS("task_struct", arglist[i]) &&
- !MEMBER_EXISTS("thread_info", arglist[i]))
- error(INFO, "%s: not a task_struct or thread_info member\n",
- arglist[i]);
open_tmpfile();
dump_struct("task_struct", tc->task, radix);
if (tt->flags & THREAD_INFO)
dump_struct("thread_info", tc->thread_info, radix);
+
+ // Split arguments into two lists for long and short arguments
+ for (i = 0; i < argcnt; i++) {
+ if (count_chars(arglist[i], '.') || count_chars(arglist[i], '[')) {
+ longarglist[longargcnt++] = arglist[i];
+ } else {
+ if (!MEMBER_EXISTS("task_struct", arglist[i]) &&
+ !MEMBER_EXISTS("thread_info", arglist[i]))
+ error(INFO, "%s: not a task_struct or "
+ "thread_info member\n", arglist[i]);
+
+ shortarglist[shortargcnt++] = arglist[i];
+ }
+ }
+
+ if (shortargcnt)
+ parse_task_thread(shortargcnt, shortarglist, tc);
+
+ if (longargcnt) {
+ if (0 == shortargcnt) /* We haven't printed header yet */
+ print_task_header(pc->saved_fp, tc, 0);
+ for (i = 0; i < longargcnt; i++) {
+ dm.member = longarglist[i];
+ parse_for_member_new(&dm, 0);
+ }
+ }
+ close_tmpfile();
+
+ FREEBUF(member);
+
+}
+
+static void parse_task_thread(int argcnt, char *arglist[], struct task_context *tc) {
+ char buf[BUFSIZE];
+ char lookfor1[BUFSIZE];
+ char lookfor2[BUFSIZE];
+ char lookfor3[BUFSIZE];
+ int header_printed = FALSE;
+ int i;
+
rewind(pc->tmpfile);
BZERO(lookfor1, BUFSIZE);
@@ -2825,7 +2858,6 @@ task_struct_member(struct task_context *
}
}
}
- close_tmpfile();
}
static char *ps_exclusive =
--- crash-7.1.0.orig/tools.c 2015-05-13 11:39:12.409474373 +0300
+++ crash-7.1.0/tools.c 2015-05-15 13:51:12.940184303 +0300
@@ -3526,13 +3526,9 @@ do_list(struct list_data *ld)
dump_struct(ld->structname[i],
next - ld->list_head_offset, radix);
break;
- case 1:
+ default:
dump_struct_members(ld, i, next);
break;
- default:
- error(FATAL,
- "invalid structure reference: %s\n",
- ld->structname[i]);
}
}
}
@@ -4000,14 +3996,10 @@ rdtree_iteration(ulong node_p, struct tr
dump_struct(td->structname[i],
slot, print_radix);
break;
- case 1:
+ default:
dump_struct_members_for_tree(td, i,
slot);
break;
- default:
- error(FATAL,
- "invalid struct reference: %s\n",
- td->structname[i]);
}
}
}
@@ -4078,12 +4070,9 @@ rbtree_iteration(ulong node_p, struct tr
case 0:
dump_struct(td->structname[i], struct_p, print_radix);
break;
- case 1:
+ default:
dump_struct_members_for_tree(td, i, struct_p);
break;
- default:
- error(FATAL, "invalid struct reference: %s\n",
- td->structname[i]);
}
}
}
11:15 a.m.
----- Original Message -----
Hi Dave,
please take a look at updated patch.
Thanks,
Alexandr
I did some initial testing, starting with the "task" command, but then
ran into problems.
First, I fixed/simplified task_struct_member() so that the requested
members would be printed in the same order that was specified
in the comma-separated list. I removed your shortarglist/longarglist
stuff and just moved the parsing calls into the upper loop, and moved
the header display determination from parse_task_thread() back
into do_task(). Although parse_task_thread() will now receive
only one member at a time, it still takes an array of members just
in case it's needed in the future. I've attached my modified version
of task.c for you to use.
But the patch still has problems, specifically with the "struct"
command and embedded arrays, which don't work at all. I noticed it
by testing array member displays with the "task" command, taking
this example:
crash> task_struct.pids
struct task_struct {
[608] struct pid_link pids[3];
}
crash>
Here they are:
crash> task -R pids
PID: 26602 TASK: ffff8801f0ac9e40 CPU: 1 COMMAND: "crash"
pids = {{
node = {
next = 0x0,
pprev = 0xffff880100a6a488
},
pid = 0xffff880100a6a480
}, {
node = {
next = 0xffff8801f0aca848,
pprev = 0xffff880209d064c8
},
pid = 0xffff880100a6a100
}, {
node = {
next = 0xffff8801f0aca860,
pprev = 0xffff880209d064e0
},
pid = 0xffff88010d07ed00
}},
crash>
With your patch applied, I selected the first element in the array,
which works OK:
crash> task -R pids[0]
PID: 26602 TASK: ffff8801f0ac9e40 CPU: 3 COMMAND: "crash"
pids[0] = {
node = {
next = 0x0,
pprev = 0xffff880100a6a488
},
pid = 0xffff880100a6a480
},
But testing the same thing with the "struct" command shows this:
crash> struct task_struct.pids ffff8801f0ac9e40
pids = {{
node = {
next = 0x0,
pprev = 0xffff880100a6a488
},
pid = 0xffff880100a6a480
}, {
node = {
next = 0xffff8801f0aca848,
pprev = 0xffff8801f0acafd8
},
pid = 0xffff880100a6a100
}, {
node = {
next = 0xffff8801f0aca860,
pprev = 0xffff8801f0acaff0
},
pid = 0xffff88010d07ed00
}},
crash> struct task_struct.pids[0] ffff8801f0ac9e40
crash>
It always seems to come up empty with array elements.
For another example, I can print the whole array from a structure,
but selecting an array member returns nothing:
crash> mm_struct.saved_auxv
struct mm_struct {
[320] unsigned long saved_auxv[44];
}
crash>
crash> mm_struct.saved_auxv ffff88001552d400
saved_auxv = {33, 140734416019456, 16, 3219913727, 6, 4096, 17, 100, 3, 4194368, 4, 56,
5, 8, 7, 0, 8, 0, 9, 4597288, 11, 0, 12, 0, 13, 0, 14, 0, 23, 0, 25, 140734415656601, 31,
140734415658992, 15, 140734415656617, 0, 0, 0, 0, 0, 0, 0, 0}
crash> mm_struct.saved_auxv[0] ffff88001552d400
crash>
Thanks,
Dave
3:44 p.m.
Hi Dave,
my bad.
Since you've made some simplifications in my patch, I hope it's ok to make short
patch.
--- a/symbols.c 2015-05-15 23:36:33.136710935 +0300
+++ b/symbols.c 2015-05-15 23:36:20.072710739 +0300
@@ -6260,7 +6260,7 @@
if (!((flags & DEREF_POINTERS) &&
dereference_pointer(addr, dm, flags)))
{
- if (count_chars(dm->member,
'.'))
+ if (count_chars(dm->member,
'.') || count_chars(dm->member, '['))
parse_for_member_new(dm,
PARSE_FOR_DATA);
else
parse_for_member(dm,
PARSE_FOR_DATA);
Thanks,
Alexandr
11:14 a.m.
----- Original Message -----
Hi Dave,
my bad.
Since you've made some simplifications in my patch, I hope it's ok to make
short patch.
Hi Alex,
I've run into three problems dealing with embedded arrays.
First, should array elements inside an embedded structure be
selectable? For example, the task_struct has an embedded
task_rss_stat structure:
crash> task_struct.rss_stat
struct task_struct {
[456] struct task_rss_stat rss_stat;
}
that contains a "count" array:
crash> task_rss_stat
struct task_rss_stat {
int events;
int count[3];
}
SIZE: 16
I can display the whole thing:
crash> task -R rss_stat
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
rss_stat = {
events = 11,
count = {0, 0, 0}
},
Or break it down into its two members, individually or both at the same time:
crash> task -R rss_stat.events
PID: 11722 TASK: ffff8801073da5d0 CPU: 1 COMMAND: "crash"
rss_stat.events = 13,
crash> task -R rss_stat.count
PID: 11722 TASK: ffff8801073da5d0 CPU: 1 COMMAND: "crash"
rss_stat.count = {0, 0, 0}
crash> task -R rss_stat.events,rss_stat.count
PID: 11722 TASK: ffff8801073da5d0 CPU: 1 COMMAND: "crash"
rss_stat.events = 14,
rss_stat.count = {0, 0, 0}
But trying to access a member of the rss_stat.count[] array fails:
crash> task -R rss_stat.count[1]
PID: 11722 TASK: ffff8801073da5d0 CPU: 2 COMMAND: "crash"
task: invalid structure member reference: rss_stat.count[1]
crash>
Is that expected behavior?
Secondly, on a somewhat related note, this seems strange. The
task_struct has an embedded array of 3 pid_link structures:
crash> task_struct.pids
struct task_struct {
[608] struct pid_link pids[3];
}
Here they are all dumped:
crash> task -R pids
PID: 11722 TASK: ffff8801073da5d0 CPU: 2 COMMAND: "crash"
pids = {{
node = {
next = 0x0,
pprev = 0xffff880105fc9888
},
pid = 0xffff880105fc9880
}, {
node = {
next = 0xffff880209d01198,
pprev = 0xffff880209d05d38
},
pid = 0xffff88000eeefd00
}, {
node = {
next = 0xffff880209d011b0,
pprev = 0xffff880209d05d50
},
pid = 0xffff88010d07ed00
}},
Or I can pick just one member of the array:
crash> task -R pids[1]
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
pids[1] = {
node = {
next = 0xffff880209d01198,
pprev = 0xffff880209d02848
},
pid = 0xffff88000eeefd00
},
And refine it further by asking for just the "node" member:
crash> task -R pids[1].node
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
pids[1].node = {
next = 0xffff880209d01198,
pprev = 0xffff880209d02848
},
But for some reason, it fails to accept the "pid_link.pid" member:
crash> task -R pids[1].pid
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
task: invalid structure member reference: pids[1].pid
And third, this behavior also doesn't seem correct. Here again I select
just the first element of the task_struct.pids[] array:
crash> task -R pids[0].node
PID: 11722 TASK: ffff8801073da5d0 CPU: 2 COMMAND: "crash"
pids[0].node = {
next = 0x0,
pprev = 0xffff880105fc9888
},
But it allows me to leave off the "pids[x]" reference, and if so, it defaults
to the first member of the array:
crash> task -R pids.node
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
pids.node = {
next = 0x0,
pprev = 0xffff880105fc9888
},
Should it reject that syntax?
Dave
4:16 p.m.
On Tue, May 19, 2015 at 12:14:49PM -0400, Dave Anderson wrote:
I've run into three problems dealing with embedded arrays.
First, should array elements inside an embedded structure be
selectable? For example, the task_struct has an embedded
task_rss_stat structure:
.........
crash> task -R rss_stat.count[1]
PID: 11722 TASK: ffff8801073da5d0 CPU: 2 COMMAND: "crash"
task: invalid structure member reference: rss_stat.count[1]
crash>
Is that expected behavior?
Yes, the new logic consider structure
count = {0, 0, 0}
in the same way as scalar (you can find the corresponding comment within
parser branches.
+ if ( p && (*s_e != '{' || (*s_e == '{' &&
buf[len] == '}'))) {
+ /* Scalar or one-line array
+ * next = 0x0
+ * or
+ * files = {0x0, 0x0}
+ */
+ strcpy(current->value, s_e);
+ if (trailing_comma) ALLOC_NEXT_ELEMENT;
+ }
Since this type of array is short, I wasn't sure whether it's necessary to
access its elements or not.
But for some reason, it fails to accept the "pid_link.pid"
member:
crash> task -R pids[1].pid
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
task: invalid structure member reference: pids[1].pid
This behavior is incorrent, I will check it.
And third, this behavior also doesn't seem correct. Here again I
select
just the first element of the task_struct.pids[] array:
crash> task -R pids[0].node
PID: 11722 TASK: ffff8801073da5d0 CPU: 2 COMMAND: "crash"
pids[0].node = {
next = 0x0,
pprev = 0xffff880105fc9888
},
But it allows me to leave off the "pids[x]" reference, and if so, it defaults
to the first member of the array:
crash> task -R pids.node
PID: 11722 TASK: ffff8801073da5d0 CPU: 0 COMMAND: "crash"
pids.node = {
next = 0x0,
pprev = 0xffff880105fc9888
},
Should it reject that syntax?
Yes, it should. I will fix it.
And again, since you've started updating my patch, what is the best way
to provide these fixes?
Thanks,
Alexandr
3:55 p.m.
----- Original Message -----
Hi Dave,
my bad.
Since you've made some simplifications in my patch, I hope it's ok to make
short patch.
Hi Alex,
This patch tests OK. I did make a few minor cosmetic changes, fixed the
"task" command so that the -R flag remains optional, and added some
verbiage to the struct, union, task, list and tree command help pages.
I look forward to using it in a real-life crash analysis, as it's a
pretty nifty enhancement. It's queued for crash-7.1.1:
https://github.com/crash-utility/crash/commit/042639e3f5580b503a44511be57...
Thanks very much,
Dave
--- a/symbols.c 2015-05-15 23:36:33.136710935 +0300
+++ b/symbols.c 2015-05-15 23:36:20.072710739 +0300
@@ -6260,7 +6260,7 @@
if (!((flags & DEREF_POINTERS) &&
dereference_pointer(addr, dm,
flags)))
{
- if (count_chars(dm->member,
'.'))
+ if (count_chars(dm->member,
'.') || count_chars(dm->member, '['))
parse_for_member_new(dm,
PARSE_FOR_DATA);
else
parse_for_member(dm,
PARSE_FOR_DATA);
Thanks,
Alexandr
--
Crash-utility mailing list
Crash-utility(a)redhat.com
https://www.redhat.com/mailman/listinfo/crash-utility
3508
days inactive
3518
days old
devel@lists.crash-utility.osci.io
12 comments
2 participants
participants (2)
-
Alexandr Terekhov -
Dave Anderson