Hello Dave, Changed according to your suggestions. But need to add some explanation here. change 1:
Perhaps there could be a way to pre-verify the addresses with accessible(), and if the address is bogus, display an error message, but allow the command to continue on with the other cpus?
Error comes from rb_last() which used to calculate the space for printing expires. I fixed rb_last(), adding pre-verify the addresses. But I didn't use rb_last() any more, for change 2 helps to find the last hrtimer. change 2:
Maybe you can use hq_open()/hq_enter()/hq_close() on the hrtimer addresses to prevent this from happening, warn the user when it does, and continue on with the next cpu?
As you suggested. change3: When doing some snap test, I found rb_node's data may be destroyed, so I also fixed other rbtree manipulation functions to avoid abort of command. -- -- Regards Qiao Nuohan
>From 2c3d65962715a94af15b090f96f137730396a864 Mon Sep 17 00:00:00 2001 From: qiaonuohan <qiaonuohan@xxxxxxxxxxxxxx> Date: Wed, 27 Feb 2013 17:34:11 +0800 Subject: [PATCH 2/2] hrtimer: add -r option to command timer command timer -r is used to display all hrtimers and their related information. e.g. crash> timer -r UPTIME: 776348196(1000HZ) cpu: 0 clock: 0 .base: ffff880002210f48 .offset: 1361070676510533252 .get_time: ktime_get_real EXPIRES HRTIMER FUNCTION 1361847061015817487-1361847061015867487 ffff88004bb43d18 ffffffff81094d50 <hrtimer_wakeup> 1361847073001411000-1361847073001461000 ffff88004b1d3d18 ffffffff81094d50 <hrtimer_wakeup> clock: 1 .base: ffff880002210f88 .offset: 0 .get_time: ktime_get EXPIRES HRTIMER FUNCTION 776348200000000-776348200000000 ffff880002211040 ffffffff810a0b70 <tick_sched_timer> 776352046999849-776352046999849 ffff880002211260 ffffffff810d8ab0 <watchdog_timer_fn> ... --- defs.h | 22 ++++ help.c | 65 ++++++++++- kernel.c | 356 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 435 insertions(+), 8 deletions(-) diff --git a/defs.h b/defs.h index 2993f2b..66e75e4 100755 --- a/defs.h +++ b/defs.h @@ -1848,6 +1848,26 @@ struct offset_table { /* stash of commonly-used offsets */ long vmap_area_list; long vmap_area_flags; long vmap_area_vm; + long hrtimer_cpu_base_clock_base; + long hrtimer_clock_base_offset; + long hrtimer_clock_base_active; + long hrtimer_clock_base_first; + long hrtimer_clock_base_get_time; + long hrtimer_base_active; + long hrtimer_base_first; + long hrtimer_base_pending; + long hrtimer_base_get_time; + long hrtimer_node; + long hrtimer_list; + long hrtimer_softexpires; + long hrtimer_expires; + long hrtimer_function; + long timerqueue_head_next; + long timerqueue_node_expires; + long timerqueue_node_node; + long ktime_t_tv64; + long ktime_t_sec; + long ktime_t_nsec; }; struct size_table { /* stash of commonly-used sizes */ @@ -1985,6 +2005,8 @@ struct size_table { /* stash of commonly-used sizes */ long rt_rq; long task_group; long vmap_area; + long hrtimer_clock_base; + long hrtimer_base; }; struct array_table { diff --git a/help.c b/help.c index c542743..9587de6 100755 --- a/help.c +++ b/help.c @@ -2154,13 +2154,17 @@ NULL char *help_timer[] = { "timer", -"timer queue data", -" ", -" This command displays the timer queue entries, both old- and new-style,", -" in chronological order. In the case of the old-style timers, the", -" timer_table array index is shown; in the case of the new-style timers, ", -" the timer_list address is shown. On later kernels, the timer data is", -" per-cpu.", +"timer data", +"[-r]" +" ", +" This command provides information of timer. With no arguments, the command", +" displays the timer queue entries, both old- and new-style, in chronological", +" order. In the case of the old-style timers, the timer_table array index is", +" shown; in the case of the new-style timers, the timer_list address is", +" shown. On later kernels, the timer data is per-cpu.", +" ", +" -r shows all hrtimers and their related information. On earlier kernels, ", +" expire is an integer, and on later kernels, expire is a range.", "\nEXAMPLES", " %s> timer", " JIFFIES", @@ -2218,6 +2222,55 @@ char *help_timer[] = { " 18277900 ceebaec0 c01232bb <process_timeout>", " 18283769 cf739f64 c01232bb <process_timeout>", " 18331902 cee8af64 c01232bb <process_timeout>", +" ", +" Display hrtimers on a 2-cpu system:\n", +" %s> timer -r", +" UPTIME: 773504381(1000HZ)", +" ", +" cpu: 0", +" clock: 0", +" .base: ffff880002210f48", +" .offset: 1361070676510533252", +" .get_time: ktime_get_real", +" EXPIRES HRTIMER FUNCTION", +" (empty)", +" ", +" clock: 1", +" .base: ffff880002210f88", +" .offset: 0", +" .get_time: ktime_get", +" EXPIRES HRTIMER FUNCTION", +" 773504385000000-773504385000000 ffff880002211040 ffffffff810a0b70 <tick_sched_timer>", +" 773504593280596-773504623280594 ffff88004b951a68 ffffffff81094d50 <hrtimer_wakeup>", +" 773508046999849-773508046999849 ffff880002211260 ffffffff810d8ab0 <watchdog_timer_fn>", +" 774033561838113-774033561888113 ffff88004a889ea8 ffffffff81094d50 <hrtimer_wakeup>", +" 777636126762107-777636126812107 ffff88004b101ea8 ffffffff81094d50 <hrtimer_wakeup>", +" 777643135448820-777643135498820 ffff88004be13ea8 ffffffff81094d50 <hrtimer_wakeup>", +" 835425492707207-835425592707207 ffff8800370ad918 ffffffff81094d50 <hrtimer_wakeup>", +" ", +" cpu: 1", +" clock: 0", +" .base: ffff880002310f48", +" .offset: 1361070676510533252", +" .get_time: ktime_get_real", +" EXPIRES HRTIMER FUNCTION", +" 1361844180919594677-1361844180919644677 ffff88004b3c3d18 ffffffff81094d50 <hrtimer_wakeup>", +" 1361844222824734000-1361844222824784000 ffff88004b1d3d18 ffffffff81094d50 <hrtimer_wakeup>", +" ", +" clock: 1", +" .base: ffff880002310f88", +" .offset: 0", +" .get_time: ktime_get", +" EXPIRES HRTIMER FUNCTION", +" 773504385250000-773504385250000 ffff880002311040 ffffffff810a0b70 <tick_sched_timer>", +" 773505214823336-773505214873336 ffff88004ba83ea8 ffffffff81094d50 <hrtimer_wakeup>", +" 773507489467713-773507489517713 ffff880037ba3ea8 ffffffff81094d50 <hrtimer_wakeup>", +" 773508047999849-773508047999849 ffff880002311260 ffffffff810d8ab0 <watchdog_timer_fn>", +" 773519489700296-773519519670295 ffff88003759ba68 ffffffff81094d50 <hrtimer_wakeup>", +" 773556240968656-773556241018656 ffff88004ab51ea8 ffffffff81094d50 <hrtimer_wakeup>", +" 773596813474406-773596813474406 ffff880037485468 ffffffff8106f8b0 <it_real_fn>", +" 773803814242633-773803814242633 ffff88004be8b868 ffffffff8106f8b0 <it_real_fn>", +" 779470814225727-779470814225727 ffff880037482868 ffffffff8106f8b0 <it_real_fn>", NULL }; diff --git a/kernel.c b/kernel.c index c420518..3cb9569 100755 --- a/kernel.c +++ b/kernel.c @@ -34,6 +34,13 @@ static void display_bh_1(void); static void display_bh_2(void); static void display_bh_3(void); static void display_bh_4(void); +static void dump_hrtimer_data(void); +static void dump_hrtimer_clock_base(const void *, const int); +static void dump_hrtimer_base(const void *, const int); +static void dump_active_timers(const void *); +static int get_expires_len(const int, const ulong *); +static void print_timer(const void *); +static ulonglong ktime_to_ns(const void *); static void dump_timer_data(void); static void dump_timer_data_tvec_bases_v1(void); static void dump_timer_data_tvec_bases_v2(void); @@ -638,6 +645,51 @@ kernel_init() BUG_bytes_init(); kt->flags &= ~PRE_KERNEL_INIT; + + /* + * for hrtimer + */ + MEMBER_OFFSET_INIT(hrtimer_cpu_base_clock_base, "hrtimer_cpu_base", + "clock_base"); + MEMBER_OFFSET_INIT(hrtimer_clock_base_offset, "hrtimer_clock_base", + "offset"); + MEMBER_OFFSET_INIT(hrtimer_clock_base_active, "hrtimer_clock_base", + "active"); + MEMBER_OFFSET_INIT(hrtimer_clock_base_first, "hrtimer_clock_base", + "first"); + MEMBER_OFFSET_INIT(hrtimer_clock_base_get_time, "hrtimer_clock_base", + "get_time"); + MEMBER_OFFSET_INIT(hrtimer_base_active, "hrtimer_base", "active"); + MEMBER_OFFSET_INIT(hrtimer_base_first, "hrtimer_base", "first"); + MEMBER_OFFSET_INIT(hrtimer_base_pending, "hrtimer_base", "pending"); + MEMBER_OFFSET_INIT(hrtimer_base_get_time, "hrtimer_base", "get_time"); + MEMBER_OFFSET_INIT(hrtimer_node, "hrtimer", "node"); + MEMBER_OFFSET_INIT(hrtimer_list, "hrtimer", "list"); + MEMBER_OFFSET_INIT(hrtimer_expires, "hrtimer", "expires"); + if (INVALID_MEMBER(hrtimer_expires)) + MEMBER_OFFSET_INIT(hrtimer_expires, "hrtimer", "_expires"); + if (INVALID_MEMBER(hrtimer_expires)) { + MEMBER_OFFSET_INIT(timerqueue_head_next, "timerqueue_head", "next"); + MEMBER_OFFSET_INIT(timerqueue_node_expires, "timerqueue_node", + "expires"); + MEMBER_OFFSET_INIT(timerqueue_node_node, "timerqueue_node_node", + "node"); + } + + MEMBER_OFFSET_INIT(hrtimer_softexpires, "hrtimer", "_softexpires"); + MEMBER_OFFSET_INIT(hrtimer_function, "hrtimer", "function"); + MEMBER_OFFSET_INIT(ktime_t_tv64, "ktime", "tv64"); + if (INVALID_MEMBER(ktime_t_tv64)) + MEMBER_OFFSET_INIT(ktime_t_tv64, "ktime_t", "tv64"); + MEMBER_OFFSET_INIT(ktime_t_sec, "ktime", "sec"); + if (INVALID_MEMBER(ktime_t_sec)) + MEMBER_OFFSET_INIT(ktime_t_sec, "ktime_t", "sec"); + MEMBER_OFFSET_INIT(ktime_t_nsec, "ktime", "nsec"); + if (INVALID_MEMBER(ktime_t_nsec)) + MEMBER_OFFSET_INIT(ktime_t_nsec, "ktime_t", "nsec"); + + STRUCT_SIZE_INIT(hrtimer_clock_base, "hrtimer_clock_base"); + STRUCT_SIZE_INIT(hrtimer_base, "hrtimer_base"); } /* @@ -6333,10 +6385,17 @@ void cmd_timer(void) { int c; + int rflag; - while ((c = getopt(argcnt, args, "")) != EOF) { + rflag = 0; + + while ((c = getopt(argcnt, args, "r")) != EOF) { switch(c) { + case 'r': + rflag = 1; + break; + default: argerrs++; break; @@ -6346,7 +6405,300 @@ cmd_timer(void) if (argerrs) cmd_usage(pc->curcmd, SYNOPSIS); - dump_timer_data(); + if (rflag) + dump_hrtimer_data(); + else + dump_timer_data(); +} + +static void +dump_hrtimer_data(void) +{ + int i, j; + ulonglong jiffies_64; + int hrtimer_max_clock_bases, max_hrtimer_bases; + struct syment * hrtimer_bases; + + hrtimer_max_clock_bases = 0; + max_hrtimer_bases = 0; + + /* + * deside whether hrtimer is available and + * set hrtimer_max_clock_bases or max_hrtimer_bases. + * if both are not available, hrtimer is not available. + */ + if (VALID_SIZE(hrtimer_clock_base)) { + hrtimer_max_clock_bases = 2; + if (symbol_exists("ktime_get_boottime")) + hrtimer_max_clock_bases = 3; + } else if (VALID_SIZE(hrtimer_base)) { + max_hrtimer_bases = 2; + } else + command_not_supported(); + + /* get current time(uptime) */ + get_uptime(NULL, &jiffies_64); + fprintf(fp, "UPTIME: %lld(%dHZ)\n\n", jiffies_64, machdep->hz); + + hrtimer_bases = per_cpu_symbol_search("hrtimer_bases"); + for (i = 0; i < kt->cpus; i++) { + if (i) + fprintf(fp, "\n"); + fprintf(fp, "cpu: %d\n", i); + if (VALID_SIZE(hrtimer_clock_base)) { + for (j = 0; j < hrtimer_max_clock_bases; j++) { + if (j) + fprintf(fp, "\n"); + dump_hrtimer_clock_base( + (void *)(hrtimer_bases->value) + + kt->__per_cpu_offset[i], j); + } + } else { + for (j = 0; j < max_hrtimer_bases; j++) { + if (j) + fprintf(fp, "\n"); + dump_hrtimer_base( + (void *)(hrtimer_bases->value) + + kt->__per_cpu_offset[i], j); + } + } + } +} + +static int expires_len = VADDR_PRLEN; + +static void +dump_hrtimer_clock_base(const void *hrtimer_bases, const int num) +{ + void *base; + ulonglong offset; + ulong get_time; + char buf[BUFSIZE]; + + base = (void *)hrtimer_bases + OFFSET(hrtimer_cpu_base_clock_base) + + SIZE(hrtimer_clock_base) * num; + fprintf(fp, " clock: %d\n", num); + fprintf(fp, " .base:\t%lx\n", (ulong)base); + + if (VALID_MEMBER(hrtimer_clock_base_offset)) { + offset = ktime_to_ns(base + OFFSET(hrtimer_clock_base_offset)); + fprintf(fp, " .offset:\t%lld\n", offset); + } + + readmem((ulong)(base + OFFSET(hrtimer_clock_base_get_time)), KVADDR, + &get_time, sizeof(get_time), "hrtimer_clock_base get_time", + FAULT_ON_ERROR); + + fprintf(fp ," .get_time:\t%s\n", value_to_symstr(get_time, buf, 0)); + + dump_active_timers(base); +} + +static void +dump_hrtimer_base(const void *hrtimer_bases, const int num) +{ + void *base; + ulong get_time; + char buf[BUFSIZE]; + + base = (void *)hrtimer_bases + SIZE(hrtimer_base) * num; + fprintf(fp, " clock: %d\n", num); + fprintf(fp, " .base:\t%lx\n", (ulong)base); + + readmem((ulong)(base + OFFSET(hrtimer_base_get_time)), KVADDR, + &get_time, sizeof(get_time), "hrtimer_base get_time", + FAULT_ON_ERROR); + + fprintf(fp ," .get_time:\t%s\n", value_to_symstr(get_time, buf, 0)); + + dump_active_timers(base); +} + +static void +dump_active_timers(const void *base) +{ + int next, i, t; + struct rb_node *curr; + int timer_cnt; + ulong *timer_list; + void *timer; + char buf1[BUFSIZE]; + char buf2[BUFSIZE]; + char buf3[BUFSIZE]; + + + next = 0; + + /* search hrtimers */ + hq_open(); + timer_cnt = 0; +next_one: + i = 0; + + /* get the first node */ + if (VALID_MEMBER(hrtimer_base_pending)) + readmem((ulong)(base + OFFSET(hrtimer_base_pending) - + OFFSET(hrtimer_list) + OFFSET(hrtimer_node)), + KVADDR, &curr, sizeof(curr), "hrtimer_base pending", + FAULT_ON_ERROR); + else if (VALID_MEMBER(hrtimer_base_first)) + readmem((ulong)(base + OFFSET(hrtimer_base_first)), + KVADDR, &curr, sizeof(curr), "hrtimer_base first", + FAULT_ON_ERROR); + else if (VALID_MEMBER(hrtimer_clock_base_first)) + readmem((ulong)(base + OFFSET(hrtimer_clock_base_first)), + KVADDR, &curr, sizeof(curr), "hrtimer_clock_base first", + FAULT_ON_ERROR); + else + readmem((ulong)(base + OFFSET(hrtimer_clock_base_active) + + OFFSET(timerqueue_head_next)), + KVADDR, &curr, sizeof(curr), "hrtimer_clock base", + FAULT_ON_ERROR); + + while (curr && i < next) { + curr = rb_next(curr); + i++; + } + + if (curr) { + if (!hq_enter((ulong)curr)) { + error(INFO, "duplicate rb_node: %lx\n", curr); + return; + } + + timer_cnt++; + next++; + goto next_one; + } + + if (timer_cnt) { + timer_list = (ulong *)GETBUF(timer_cnt * sizeof(long)); + timer_cnt = retrieve_list(timer_list, timer_cnt); + } + hq_close(); + + /* dump hrtimers */ + /* print header */ + expires_len = get_expires_len(timer_cnt, timer_list); + if (!expires_len) + expires_len = 8; + + fprintf(fp, "%s %s %s\n", + mkstring(buf1, expires_len, CENTER|RJUST, "EXPIRES"), + mkstring(buf2, VADDR_PRLEN, CENTER|LJUST, "HRTIMER"), + mkstring(buf3, VADDR_PRLEN, CENTER|LJUST, "FUNCTION")); + + /* print timer */ + if (!timer_cnt) + fprintf(fp, "(empty)\n"); + + for (t = 0; t < timer_cnt; t++) { + if (VALID_MEMBER(timerqueue_node_node)) + timer = (void *)(timer_list[t] - + OFFSET(timerqueue_node_node) - + OFFSET(hrtimer_node)); + else + timer = (void *)(timer_list[t] - OFFSET(hrtimer_node)); + + print_timer(timer); + } +} + +static int +get_expires_len(const int timer_cnt, const ulong *timer_list) +{ + void *last_timer; + char buf[BUFSIZE]; + ulonglong softexpires, expires; + int len; + + len = 0; + + if (!timer_cnt) + return 8; + + if (VALID_MEMBER(timerqueue_node_node)) + last_timer = (void *)(timer_list[timer_cnt - 1] - + OFFSET(timerqueue_node_node) - + OFFSET(hrtimer_node)); + else + last_timer = (void *)(timer_list[timer_cnt -1] - + OFFSET(hrtimer_node)); + + /* expire is range */ + if (VALID_MEMBER(hrtimer_softexpires)) { + softexpires = ktime_to_ns(last_timer + OFFSET(hrtimer_softexpires)); + sprintf(buf, "%lld", softexpires); + len += strlen(buf) + 1; + } + + if (VALID_MEMBER(hrtimer_expires)) + expires = ktime_to_ns(last_timer + OFFSET(hrtimer_expires)); + else + expires = ktime_to_ns(last_timer + OFFSET(hrtimer_node) + + OFFSET(timerqueue_node_expires)); + + sprintf(buf, "%lld", expires); + len += strlen(buf); + + return len; +} + +/* + * print hrtimer and its related information + */ +static void +print_timer(const void *timer) +{ + ulonglong softexpires, expires; + + ulong function; + char buf1[BUFSIZE]; + char buf2[BUFSIZE]; + char buf3[BUFSIZE]; + + if (VALID_MEMBER(hrtimer_expires)) + expires = ktime_to_ns(timer + OFFSET(hrtimer_expires)); + else + expires = ktime_to_ns(timer + OFFSET(hrtimer_node) + + OFFSET(timerqueue_node_expires)); + + if (VALID_MEMBER(hrtimer_softexpires)) { + softexpires = ktime_to_ns(timer + OFFSET(hrtimer_softexpires)); + sprintf(buf1, "%lld-%lld", softexpires, expires); + } else { + sprintf(buf1, "%lld", expires); + } + fprintf(fp, "%s ", mkstring(buf2, expires_len, CENTER|RJUST, buf1)); + + fprintf(fp, "%lx ", (ulong)timer); + + readmem((ulong)(timer + OFFSET(hrtimer_function)), KVADDR, &function, + sizeof(function), "hrtimer function", FAULT_ON_ERROR); + fprintf(fp, "%lx ", function); + fprintf(fp ,"<%s>\n", value_to_symstr(function, buf3, 0)); +} + +/* + * convert ktime to ns, only need the address of ktime + */ +static ulonglong +ktime_to_ns(const void *ktime) +{ + ulonglong ns; + + if (VALID_MEMBER(ktime_t_tv64)) + readmem((ulong)ktime + OFFSET(ktime_t_tv64), KVADDR, &ns, + sizeof(ns), "ktime_t tv64", FAULT_ON_ERROR); + else { + uint32_t sec, nsec; + readmem((ulong)ktime + OFFSET(ktime_t_sec), KVADDR, &sec, + sizeof(sec), "ktime_t sec", FAULT_ON_ERROR); + readmem((ulong)ktime + OFFSET(ktime_t_nsec), KVADDR, &nsec, + sizeof(nsec), "ktime_t nsec", FAULT_ON_ERROR); + } + + return ns; } /* -- 1.7.1
>From 95cddfa3a5f10f23ee5a825a5586aad82bb87e7b Mon Sep 17 00:00:00 2001 From: qiaonuohan <qiaonuohan@xxxxxxxxxxxxxx> Date: Wed, 27 Feb 2013 16:56:11 +0800 Subject: [PATCH 1/2] make rbtree manipulation functions global rbtree manipulation functions were only used by runq cmd. Now make them global and available to other commands. --- defs.h | 20 ++++++++++ task.c | 94 ---------------------------------------------- tools.c | 128 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 148 insertions(+), 94 deletions(-) diff --git a/defs.h b/defs.h index 1f693c3..2993f2b 100755 --- a/defs.h +++ b/defs.h @@ -2256,6 +2256,20 @@ struct alias_data { /* command alias storage */ char argbuf[1]; }; +struct rb_node +{ + unsigned long rb_parent_color; +#define RB_RED 0 +#define RB_BLACK 1 + struct rb_node *rb_right; + struct rb_node *rb_left; +}; + +struct rb_root +{ + struct rb_node *rb_node; +}; + #define NUMBER_STACKFRAMES 4 #define SAVE_RETURN_ADDRESS(retaddr) \ @@ -4082,6 +4096,12 @@ uint16_t swap16(uint16_t, int); uint32_t swap32(uint32_t, int); int make_cpumask(char *, ulong *, int, int *); size_t strlcpy(char *, char *, size_t); +struct rb_node *rb_first(struct rb_root *); +struct rb_node *rb_parent(struct rb_node *, struct rb_node *); +struct rb_node *rb_right(struct rb_node *, struct rb_node *); +struct rb_node *rb_left(struct rb_node *, struct rb_node *); +struct rb_node *rb_next(struct rb_node *); +struct rb_node *rb_last(struct rb_root *); /* * symbols.c diff --git a/task.c b/task.c index fec9f6a..6fb2b4e 100755 --- a/task.c +++ b/task.c @@ -56,13 +56,6 @@ static void dump_runq(void); static void dump_on_rq_timestamp(void); static void dump_runqueues(void); static void dump_prio_array(int, ulong, char *); -struct rb_root; -static struct rb_node *rb_first(struct rb_root *); -struct rb_node; -static struct rb_node *rb_next(struct rb_node *); -static struct rb_node *rb_parent(struct rb_node *, struct rb_node *); -static struct rb_node *rb_right(struct rb_node *, struct rb_node *); -static struct rb_node *rb_left(struct rb_node *, struct rb_node *); static void dump_task_runq_entry(struct task_context *); static void print_group_header_fair(int, ulong, void *); static void print_parent_task_group_fair(void *, int); @@ -7529,93 +7522,6 @@ dump_prio_array(int which, ulong k_prio_array, char *u_prio_array) } } -/* - * CFS scheduler uses Red-Black trees to maintain run queue. - */ -struct rb_node -{ - unsigned long rb_parent_color; -#define RB_RED 0 -#define RB_BLACK 1 - struct rb_node *rb_right; - struct rb_node *rb_left; -}; - -struct rb_root -{ - struct rb_node *rb_node; -}; - -static struct rb_node * -rb_first(struct rb_root *root) -{ - struct rb_root rloc; - struct rb_node *n; - struct rb_node nloc; - - readmem((ulong)root, KVADDR, &rloc, sizeof(struct rb_root), - "rb_root", FAULT_ON_ERROR); - - n = rloc.rb_node; - if (!n) - return NULL; - while (rb_left(n, &nloc)) - n = nloc.rb_left; - - return n; -} - -static struct rb_node * -rb_parent(struct rb_node *node, struct rb_node *nloc) -{ - readmem((ulong)node, KVADDR, nloc, sizeof(struct rb_node), - "rb_node", FAULT_ON_ERROR); - - return (struct rb_node *)(nloc->rb_parent_color & ~3); -} - -static struct rb_node * -rb_right(struct rb_node *node, struct rb_node *nloc) -{ - readmem((ulong)node, KVADDR, nloc, sizeof(struct rb_node), - "rb_node", FAULT_ON_ERROR); - - return nloc->rb_right; -} - -static struct rb_node * -rb_left(struct rb_node *node, struct rb_node *nloc) -{ - readmem((ulong)node, KVADDR, nloc, sizeof(struct rb_node), - "rb_node", FAULT_ON_ERROR); - - return nloc->rb_left; -} - -static struct rb_node * -rb_next(struct rb_node *node) -{ - struct rb_node nloc; - struct rb_node *parent; - - parent = rb_parent(node, &nloc); - - if (parent == node) - return NULL; - - if (nloc.rb_right) { - node = nloc.rb_right; - while (rb_left(node, &nloc)) - node = nloc.rb_left; - return node; - } - - while ((parent = rb_parent(node, &nloc)) && (node == rb_right(parent, &nloc))) - node = parent; - - return parent; -} - #define MAX_GROUP_NUM 200 struct task_group_info { int use; diff --git a/tools.c b/tools.c index d8dd04a..066f7fa 100755 --- a/tools.c +++ b/tools.c @@ -5555,3 +5555,131 @@ strlcpy(char *dest, char *src, size_t size) return ret; } +struct rb_node * +rb_first(struct rb_root *root) +{ + struct rb_root rloc; + struct rb_node *n; + struct rb_node nloc; + + readmem((ulong)root, KVADDR, &rloc, sizeof(struct rb_root), + "rb_root", FAULT_ON_ERROR); + + n = rloc.rb_node; + if (!n) + return NULL; + while (rb_left(n, &nloc)) + n = nloc.rb_left; + + return n; +} + +struct rb_node * +rb_parent(struct rb_node *node, struct rb_node *nloc) +{ + readmem((ulong)node, KVADDR, nloc, sizeof(struct rb_node), + "rb_node", FAULT_ON_ERROR); + + return (struct rb_node *)(nloc->rb_parent_color & ~3); +} + +struct rb_node * +rb_right(struct rb_node *node, struct rb_node *nloc) +{ + readmem((ulong)node, KVADDR, nloc, sizeof(struct rb_node), + "rb_node", FAULT_ON_ERROR); + + return nloc->rb_right; +} + +struct rb_node * +rb_left(struct rb_node *node, struct rb_node *nloc) +{ + readmem((ulong)node, KVADDR, nloc, sizeof(struct rb_node), + "rb_node", FAULT_ON_ERROR); + + return nloc->rb_left; +} + +struct rb_node * +rb_next(struct rb_node *node) +{ + struct rb_node nloc; + struct rb_node *parent; + + /* node is destroyed */ + if (!accessible((ulong)node)) + return NULL; + + parent = rb_parent(node, &nloc); + + if (parent == node) + return NULL; + + if (nloc.rb_right) { + /* rb_right is destroyed */ + if (!accessible((ulong)nloc.rb_right)) + return NULL; + + node = nloc.rb_right; + while (rb_left(node, &nloc)) { + /* rb_left is destroyed */ + if (!accessible((ulong)nloc.rb_left)) + return NULL; + node = nloc.rb_left; + } + return node; + } + + while ((parent = rb_parent(node, &nloc))) { + /* parent is destroyed */ + if (!accessible((ulong)parent)) + return NULL; + + + if (node != rb_right(parent, &nloc)) + break; + + node = parent; + } + + return parent; +} + +struct rb_node * +rb_last(struct rb_root *root) +{ + struct rb_node *node; + struct rb_node nloc; + + /* meet destroyed data */ + if (!accessible((ulong)(root + OFFSET(rb_root_rb_node)))) + return NULL; + + readmem((ulong)(root + OFFSET(rb_root_rb_node)), KVADDR, &node, + sizeof(node), "rb_root node", FAULT_ON_ERROR); + + while (1) { + if (!node) + break; + + /* meet destroyed data */ + if (!accessible((ulong)node)) + return NULL; + + readmem((ulong)node, KVADDR, &nloc, sizeof(struct rb_node), + "rb_node last", FAULT_ON_ERROR); + + /* meet the last one */ + if (!nloc.rb_right) + break; + + /* meet destroyed data */ + if (!!accessible((ulong)nloc.rb_right)) + break; + + node = nloc.rb_right; + } + + return node; +} -- 1.7.1
-- Crash-utility mailing list Crash-utility@xxxxxxxxxx https://www.redhat.com/mailman/listinfo/crash-utility