2005-02-10 18:39:42 +00:00
|
|
|
--- crash/memory.c.orig 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
+++ crash/memory.c 2005-01-06 14:56:46.000000000 -0500
|
|
|
|
@@ -88,7 +88,9 @@
|
|
|
|
static void kmem_search(struct meminfo *);
|
|
|
|
static void kmem_cache_init(void);
|
|
|
|
static ulong max_cpudata_limit(ulong, ulong *);
|
|
|
|
+static int ignore_cache(struct meminfo *, char *);
|
|
|
|
static char *is_kmem_cache_addr(ulong, char *);
|
|
|
|
+static void kmem_cache_list(void);
|
|
|
|
static void dump_kmem_cache(struct meminfo *);
|
|
|
|
static void dump_kmem_cache_percpu_v1(struct meminfo *);
|
|
|
|
static void dump_kmem_cache_percpu_v2(struct meminfo *);
|
|
|
|
@@ -104,6 +106,8 @@
|
|
|
|
static void dump_slab(struct meminfo *);
|
|
|
|
static void dump_slab_percpu_v1(struct meminfo *);
|
|
|
|
static void dump_slab_percpu_v2(struct meminfo *);
|
|
|
|
+static int verify_slab_v1(struct meminfo *, ulong, int);
|
|
|
|
+static int verify_slab_v2(struct meminfo *, ulong, int);
|
|
|
|
static void gather_slab_free_list(struct meminfo *);
|
|
|
|
static void gather_slab_free_list_percpu(struct meminfo *);
|
|
|
|
static void gather_cpudata_list_v1(struct meminfo *);
|
|
|
|
@@ -3321,7 +3325,10 @@
|
|
|
|
if (vt->flags & KMEM_CACHE_UNAVAIL)
|
|
|
|
error(FATAL,
|
|
|
|
"kmem cache slab subsystem not available\n");
|
|
|
|
- vt->dump_kmem_cache(&meminfo);
|
|
|
|
+ if (STREQ(meminfo.reqname, "list"))
|
|
|
|
+ kmem_cache_list();
|
|
|
|
+ else
|
|
|
|
+ vt->dump_kmem_cache(&meminfo);
|
2004-09-09 03:58:15 +00:00
|
|
|
}
|
2005-02-10 18:39:42 +00:00
|
|
|
|
|
|
|
if (Sflag == 1) {
|
|
|
|
@@ -3329,7 +3336,10 @@
|
|
|
|
error(FATAL,
|
|
|
|
"kmem cache slab subsystem not available\n");
|
|
|
|
meminfo.flags = VERBOSE;
|
|
|
|
- vt->dump_kmem_cache(&meminfo);
|
|
|
|
+ if (STREQ(meminfo.reqname, "list"))
|
|
|
|
+ kmem_cache_list();
|
|
|
|
+ else
|
|
|
|
+ vt->dump_kmem_cache(&meminfo);
|
2004-09-09 03:57:09 +00:00
|
|
|
}
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
if (vflag == 1)
|
|
|
|
@@ -5967,6 +5977,66 @@
|
|
|
|
}
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
/*
|
|
|
|
+ * Note same functionality as above, but instead it just
|
|
|
|
+ * dumps all slab cache names and their addresses.
|
|
|
|
+ */
|
|
|
|
+static void
|
|
|
|
+kmem_cache_list(void)
|
|
|
|
+{
|
|
|
|
+ ulong cache, cache_cache, name;
|
|
|
|
+ long next_offset, name_offset;
|
|
|
|
+ char *cache_buf;
|
|
|
|
+ char buf[BUFSIZE];
|
|
|
|
+
|
|
|
|
+ if (vt->flags & KMEM_CACHE_UNAVAIL) {
|
|
|
|
+ error(INFO, "kmem cache slab subsystem not available\n");
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ name_offset = vt->flags & (PERCPU_KMALLOC_V1|PERCPU_KMALLOC_V2) ?
|
|
|
|
+ OFFSET(kmem_cache_s_name) : OFFSET(kmem_cache_s_c_name);
|
|
|
|
+ next_offset = vt->flags & (PERCPU_KMALLOC_V1|PERCPU_KMALLOC_V2) ?
|
|
|
|
+ OFFSET(kmem_cache_s_next) : OFFSET(kmem_cache_s_c_nextp);
|
|
|
|
+
|
|
|
|
+ cache = cache_cache = symbol_value("cache_cache");
|
|
|
|
+
|
|
|
|
+ cache_buf = GETBUF(SIZE(kmem_cache_s));
|
|
|
|
+
|
|
|
|
+ do {
|
|
|
|
+ readmem(cache, KVADDR, cache_buf, SIZE(kmem_cache_s),
|
|
|
|
+ "kmem_cache_s buffer", FAULT_ON_ERROR);
|
|
|
|
+
|
|
|
|
+ if (vt->kmem_cache_namelen) {
|
|
|
|
+ BCOPY(cache_buf+name_offset, buf,
|
|
|
|
+ vt->kmem_cache_namelen);
|
|
|
|
+ } else {
|
|
|
|
+ name = ULONG(cache_buf + name_offset);
|
|
|
|
+ if (!read_string(name, buf, BUFSIZE-1)) {
|
|
|
|
+ if (vt->flags &
|
|
|
|
+ (PERCPU_KMALLOC_V1|PERCPU_KMALLOC_V2))
|
|
|
|
+ error(FATAL,
|
|
|
|
+ "cannot read kmem_cache_s.name string at %lx\n",
|
|
|
|
+ name);
|
|
|
|
+ else
|
|
|
|
+ error(FATAL,
|
|
|
|
+ "cannot read kmem_cache_s.c_name string at %lx\n",
|
|
|
|
+ name);
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ fprintf(fp, "%lx %s\n", cache, buf);
|
|
|
|
+
|
|
|
|
+ cache = ULONG(cache_buf + next_offset);
|
|
|
|
+
|
|
|
|
+ if (vt->flags & (PERCPU_KMALLOC_V1|PERCPU_KMALLOC_V2))
|
|
|
|
+ cache -= next_offset;
|
|
|
|
+
|
|
|
|
+ } while (cache != cache_cache);
|
|
|
|
+
|
|
|
|
+ FREEBUF(cache_buf);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
* Translate an address to its physical page number, verify that the
|
|
|
|
* page in fact belongs to the slab subsystem, and if so, return the
|
|
|
|
* name of the cache to which it belongs.
|
|
|
|
@@ -6040,11 +6110,14 @@
|
|
|
|
readmem(page+OFFSET(page_prev),
|
|
|
|
KVADDR, &slab, sizeof(void *),
|
|
|
|
"page.prev", FAULT_ON_ERROR);
|
2004-09-09 03:57:09 +00:00
|
|
|
-
|
2005-02-10 18:39:42 +00:00
|
|
|
else if (VALID_MEMBER(page_list_prev))
|
|
|
|
readmem(page+OFFSET(page_list_prev),
|
|
|
|
KVADDR, &slab, sizeof(void *),
|
|
|
|
"page.list.prev", FAULT_ON_ERROR);
|
|
|
|
+ else if (VALID_MEMBER(page_lru))
|
|
|
|
+ readmem(page+OFFSET(page_lru)+OFFSET(list_head_prev),
|
|
|
|
+ KVADDR, &slab, sizeof(void *),
|
|
|
|
+ "page.lru.prev", FAULT_ON_ERROR);
|
|
|
|
else
|
|
|
|
error(FATAL, "unknown definition of struct page?\n");
|
|
|
|
|
|
|
|
@@ -6231,6 +6304,41 @@
|
|
|
|
return max_limit;
|
|
|
|
}
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+/*
|
|
|
|
+ * Determine whether the current slab cache is contained in
|
|
|
|
+ * the comma-separated list from a "kmem -I list1,list2 ..."
|
|
|
|
+ * command entry.
|
|
|
|
+ */
|
|
|
|
+static int
|
|
|
|
+ignore_cache(struct meminfo *si, char *name)
|
|
|
|
+{
|
|
|
|
+ int i, argc;
|
|
|
|
+ char *p1;
|
|
|
|
+ char *arglist[MAXARGS];
|
|
|
|
+ char buf[BUFSIZE];
|
|
|
|
+
|
|
|
|
+ if (!si->ignore)
|
|
|
|
+ return FALSE;
|
|
|
|
+
|
|
|
|
+ strcpy(buf, si->ignore);
|
|
|
|
+
|
|
|
|
+ p1 = buf;
|
|
|
|
+ while (*p1) {
|
|
|
|
+ if (*p1 == ',')
|
|
|
|
+ *p1 = ' ';
|
|
|
|
+ p1++;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ argc = parse_line(buf, arglist);
|
|
|
|
+
|
|
|
|
+ for (i = 0; i < argc; i++) {
|
|
|
|
+ if (STREQ(name, arglist[i]))
|
|
|
|
+ return TRUE;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return FALSE;
|
|
|
|
+}
|
|
|
|
+
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
/*
|
|
|
|
* dump_kmem_cache() displays basic information about kmalloc() slabs.
|
|
|
|
@@ -6390,8 +6498,8 @@
|
|
|
|
if (reqname && !STREQ(reqname, buf))
|
|
|
|
goto next_cache;
|
|
|
|
|
|
|
|
- if (STREQ(si->ignore, buf)) {
|
|
|
|
- fprintf(fp, "%lx %-19s [IGNORED]\n", si->cache, buf);
|
|
|
|
+ if (ignore_cache(si, buf)) {
|
|
|
|
+ fprintf(fp, "%lx %-18s [IGNORED]\n", si->cache, buf);
|
|
|
|
goto next_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -6588,16 +6696,13 @@
|
|
|
|
if (reqname && !STREQ(reqname, buf))
|
|
|
|
goto next_cache;
|
|
|
|
|
|
|
|
- if (STREQ(si->ignore, buf)) {
|
|
|
|
- fprintf(fp, "%lx %-19s [IGNORED]\n", si->cache, buf);
|
|
|
|
+ if (ignore_cache(si, buf)) {
|
|
|
|
+ fprintf(fp, "%lx %-18s [IGNORED]\n", si->cache, buf);
|
|
|
|
goto next_cache;
|
2004-09-09 03:57:09 +00:00
|
|
|
}
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
si->curname = buf;
|
|
|
|
|
|
|
|
- if (CRASHDEBUG(1))
|
|
|
|
- fprintf(fp, "cache: %lx %s\n", si->cache, si->curname);
|
|
|
|
-
|
|
|
|
readmem(si->cache+OFFSET(kmem_cache_s_objsize),
|
|
|
|
KVADDR, &tmp_val, sizeof(uint),
|
|
|
|
"objsize", FAULT_ON_ERROR);
|
|
|
|
@@ -6804,16 +6909,13 @@
|
|
|
|
if (reqname && !STREQ(reqname, buf))
|
|
|
|
goto next_cache;
|
|
|
|
|
|
|
|
- if (STREQ(si->ignore, buf)) {
|
|
|
|
- fprintf(fp, "%lx %-19s [IGNORED]\n", si->cache, buf);
|
|
|
|
+ if (ignore_cache(si, buf)) {
|
|
|
|
+ fprintf(fp, "%lx %-18s [IGNORED]\n", si->cache, buf);
|
|
|
|
goto next_cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
si->curname = buf;
|
|
|
|
|
|
|
|
- if (CRASHDEBUG(3))
|
|
|
|
- fprintf(fp, "cache: %lx %s\n", si->cache, si->curname);
|
|
|
|
-
|
|
|
|
readmem(si->cache+OFFSET(kmem_cache_s_objsize),
|
|
|
|
KVADDR, &tmp_val, sizeof(uint),
|
|
|
|
"objsize", FAULT_ON_ERROR);
|
|
|
|
@@ -6883,7 +6985,7 @@
|
|
|
|
case KMEM_SLAB_ADDR:
|
|
|
|
fprintf(fp, " %lx ",
|
|
|
|
(ulong)si->spec_addr);
|
|
|
|
- fprintf(fp, "(slab_s)\n");
|
|
|
|
+ fprintf(fp, "(slab)\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KMEM_ON_SLAB:
|
|
|
|
@@ -7073,6 +7175,8 @@
|
|
|
|
|
|
|
|
#define SLAB_CHAINS (3)
|
|
|
|
|
|
|
|
+static char *slab_chain_name_v1[] = {"full", "partial", "free"};
|
|
|
|
+
|
|
|
|
static void
|
|
|
|
do_slab_chain_percpu_v1(long cmd, struct meminfo *si)
|
2004-09-09 03:57:09 +00:00
|
|
|
{
|
2005-02-10 18:39:42 +00:00
|
|
|
@@ -7080,6 +7184,7 @@
|
|
|
|
int list_borked;
|
|
|
|
char *slab_s_buf;
|
|
|
|
ulong specified_slab;
|
|
|
|
+ ulong last;
|
|
|
|
ulong slab_chains[SLAB_CHAINS];
|
|
|
|
|
|
|
|
list_borked = 0;
|
|
|
|
@@ -7096,6 +7201,12 @@
|
|
|
|
slab_chains[2] = si->cache + OFFSET(kmem_cache_s_slabs_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
+ if (CRASHDEBUG(1)) {
|
|
|
|
+ fprintf(fp, "[ %s: %lx ", si->curname, si->cache);
|
|
|
|
+ fprintf(fp, "full: %lx partial: %lx free: %lx ]\n",
|
|
|
|
+ slab_chains[0], slab_chains[1], slab_chains[2]);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case SLAB_GET_COUNTS:
|
|
|
|
@@ -7112,9 +7223,16 @@
|
|
|
|
if (!slab_chains[s])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
- readmem(slab_chains[s],
|
|
|
|
- KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
- "first slab", FAULT_ON_ERROR);
|
|
|
|
+ if (!readmem(slab_chains[s],
|
|
|
|
+ KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
+ "first slab", QUIET|RETURN_ON_ERROR)) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: bad slab pointer: %lx\n",
|
|
|
|
+ si->curname, slab_chain_name_v1[s],
|
|
|
|
+ slab_chains[s]);
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
if (slab_data_saved(si)) {
|
|
|
|
FREEBUF(slab_s_buf);
|
|
|
|
@@ -7124,11 +7242,19 @@
|
|
|
|
if (si->slab == slab_chains[s])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
+ last = slab_chains[s];
|
|
|
|
+
|
|
|
|
do {
|
|
|
|
if (received_SIGINT()) {
|
|
|
|
FREEBUF(slab_s_buf);
|
|
|
|
restart(0);
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+ if (!verify_slab_v1(si, last, s)) {
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ last = si->slab - OFFSET(slab_s_list);
|
|
|
|
|
|
|
|
readmem(si->slab, KVADDR, slab_s_buf,
|
|
|
|
SIZE(slab_s), "slab_s buffer",
|
|
|
|
@@ -7159,9 +7285,7 @@
|
|
|
|
error(NOTE,
|
|
|
|
"%s: slab chain inconsistency: %s list\n",
|
|
|
|
si->curname,
|
|
|
|
- s == 0 ? "full" :
|
|
|
|
- s == 1 ? "partial" :
|
|
|
|
- "free");
|
|
|
|
+ slab_chain_name_v1[s]);
|
|
|
|
list_borked = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@@ -7170,7 +7294,8 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
FREEBUF(slab_s_buf);
|
|
|
|
- save_slab_data(si);
|
|
|
|
+ if (!list_borked)
|
|
|
|
+ save_slab_data(si);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SLAB_WALKTHROUGH:
|
|
|
|
@@ -7183,14 +7308,24 @@
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!specified_slab) {
|
|
|
|
- readmem(slab_chains[s],
|
|
|
|
- KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
- "slabs", FAULT_ON_ERROR);
|
|
|
|
- }
|
|
|
|
+ if (!readmem(slab_chains[s],
|
|
|
|
+ KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
+ "slabs", QUIET|RETURN_ON_ERROR)) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: bad slab pointer: %lx\n",
|
|
|
|
+ si->curname,
|
|
|
|
+ slab_chain_name_v1[s],
|
|
|
|
+ slab_chains[s]);
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ last = slab_chains[s];
|
|
|
|
+ } else
|
|
|
|
+ last = 0;
|
|
|
|
|
|
|
|
if (si->slab == slab_chains[s])
|
|
|
|
continue;
|
|
|
|
-
|
|
|
|
+
|
|
|
|
if (CRASHDEBUG(1)) {
|
|
|
|
fprintf(fp, "search cache: [%s] ", si->curname);
|
|
|
|
if (si->flags & ADDRESS_SPECIFIED)
|
|
|
|
@@ -7201,6 +7336,12 @@
|
|
|
|
do {
|
|
|
|
if (received_SIGINT())
|
|
|
|
restart(0);
|
|
|
|
+
|
|
|
|
+ if (!verify_slab_v1(si, last, s)) {
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ last = si->slab - OFFSET(slab_s_list);
|
|
|
|
|
|
|
|
dump_slab_percpu_v1(si);
|
|
|
|
|
|
|
|
@@ -7214,7 +7355,7 @@
|
|
|
|
|
|
|
|
si->slab -= OFFSET(slab_s_list);
|
|
|
|
|
|
|
|
- } while (si->slab != slab_chains[s]);
|
|
|
|
+ } while (si->slab != slab_chains[s] && !list_borked);
|
|
|
|
}
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
break;
|
|
|
|
@@ -7222,8 +7363,94 @@
|
2004-09-09 03:57:09 +00:00
|
|
|
}
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
/*
|
|
|
|
+ * Try to preclude any attempt to translate a bogus slab structure.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+static int
|
|
|
|
+verify_slab_v1(struct meminfo *si, ulong last, int s)
|
2004-09-09 03:57:09 +00:00
|
|
|
+{
|
2005-02-10 18:39:42 +00:00
|
|
|
+ char slab_s_buf[BUFSIZE];
|
|
|
|
+ struct kernel_list_head *list_head;
|
|
|
|
+ unsigned int inuse;
|
|
|
|
+ ulong s_mem;
|
|
|
|
+ char *list;
|
|
|
|
+ int errcnt;
|
|
|
|
+
|
|
|
|
+ list = slab_chain_name_v1[s];
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ errcnt = 0;
|
|
|
|
+
|
|
|
|
+ if (!readmem(si->slab, KVADDR, slab_s_buf,
|
|
|
|
+ SIZE(slab_s), "slab_s buffer", QUIET|RETURN_ON_ERROR)) {
|
|
|
|
+ error(INFO, "%s: %s list: bad slab pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab);
|
|
|
|
+ return FALSE;
|
|
|
|
+ }
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ list_head = (struct kernel_list_head *)
|
|
|
|
+ (slab_s_buf + OFFSET(slab_s_list));
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ if (!IS_KVADDR((ulong)list_head->next) ||
|
|
|
|
+ !accessible((ulong)list_head->next)) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad next pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab,
|
|
|
|
+ (ulong)list_head->next);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ if (last && (last != (ulong)list_head->prev)) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad prev pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab,
|
|
|
|
+ (ulong)list_head->prev);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ inuse = UINT(slab_s_buf + OFFSET(slab_s_inuse));
|
|
|
|
+ if (inuse > si->c_num) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ switch (s)
|
|
|
|
+ {
|
|
|
|
+ case 0: /* full -- or one singular list, so we can't test this */
|
|
|
|
+ break;
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ case 1: /* partial */
|
|
|
|
+ if ((inuse == 0) || (inuse == si->c_num)) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ break;
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ case 2: /* free */
|
|
|
|
+ if (inuse > 0) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ break;
|
|
|
|
+ }
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ s_mem = ULONG(slab_s_buf + OFFSET(slab_s_s_mem));
|
|
|
|
+ if (!IS_KVADDR(s_mem) || !accessible(s_mem)) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad s_mem pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab, s_mem);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return(errcnt ? FALSE : TRUE);
|
2004-09-09 03:57:09 +00:00
|
|
|
+}
|
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+/*
|
|
|
|
* Updated for 2.6 slab substructure.
|
|
|
|
*/
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+static char *slab_chain_name_v2[] = {"partial", "full", "free"};
|
|
|
|
+
|
|
|
|
static void
|
|
|
|
do_slab_chain_percpu_v2(long cmd, struct meminfo *si)
|
2004-09-09 03:57:09 +00:00
|
|
|
{
|
2005-02-10 18:39:42 +00:00
|
|
|
@@ -7231,6 +7458,7 @@
|
|
|
|
int list_borked;
|
|
|
|
char *slab_buf;
|
|
|
|
ulong specified_slab;
|
|
|
|
+ ulong last;
|
|
|
|
ulong slab_chains[SLAB_CHAINS];
|
|
|
|
|
|
|
|
list_borked = 0;
|
|
|
|
@@ -7244,6 +7472,12 @@
|
|
|
|
slab_chains[2] = si->cache + OFFSET(kmem_cache_s_lists) +
|
|
|
|
OFFSET(kmem_list3_slabs_free);
|
|
|
|
|
|
|
|
+ if (CRASHDEBUG(1)) {
|
|
|
|
+ fprintf(fp, "[ %s: %lx ", si->curname, si->cache);
|
|
|
|
+ fprintf(fp, "partial: %lx full: %lx free: %lx ]\n",
|
|
|
|
+ slab_chains[0], slab_chains[1], slab_chains[2]);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case SLAB_GET_COUNTS:
|
|
|
|
@@ -7259,9 +7493,17 @@
|
|
|
|
if (!slab_chains[s])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
- readmem(slab_chains[s],
|
|
|
|
- KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
- "first slab", FAULT_ON_ERROR);
|
|
|
|
+ if (!readmem(slab_chains[s],
|
|
|
|
+ KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
+ "first slab", QUIET|RETURN_ON_ERROR)) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: bad slab pointer: %lx\n",
|
|
|
|
+ si->curname,
|
|
|
|
+ slab_chain_name_v2[s],
|
|
|
|
+ slab_chains[s]);
|
|
|
|
+ list_borked = 1;
|
2004-09-09 03:57:09 +00:00
|
|
|
+ continue;
|
2005-02-10 18:39:42 +00:00
|
|
|
+ }
|
|
|
|
|
|
|
|
if (slab_data_saved(si)) {
|
|
|
|
FREEBUF(slab_buf);
|
|
|
|
@@ -7271,11 +7513,19 @@
|
|
|
|
if (si->slab == slab_chains[s])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
+ last = slab_chains[s];
|
|
|
|
+
|
|
|
|
do {
|
|
|
|
if (received_SIGINT()) {
|
|
|
|
FREEBUF(slab_buf);
|
|
|
|
restart(0);
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+ if (!verify_slab_v2(si, last, s)) {
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ last = si->slab - OFFSET(slab_list);
|
|
|
|
|
|
|
|
readmem(si->slab, KVADDR, slab_buf,
|
|
|
|
SIZE(slab), "slab buffer",
|
|
|
|
@@ -7306,9 +7556,7 @@
|
|
|
|
error(NOTE,
|
|
|
|
"%s: slab chain inconsistency: %s list\n",
|
|
|
|
si->curname,
|
|
|
|
- s == 0 ? "full" :
|
|
|
|
- s == 1 ? "partial" :
|
|
|
|
- "free");
|
|
|
|
+ slab_chain_name_v2[s]);
|
|
|
|
list_borked = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@@ -7317,7 +7565,8 @@
|
|
|
|
}
|
|
|
|
|
|
|
|
FREEBUF(slab_buf);
|
|
|
|
- save_slab_data(si);
|
|
|
|
+ if (!list_borked)
|
|
|
|
+ save_slab_data(si);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SLAB_WALKTHROUGH:
|
|
|
|
@@ -7330,11 +7579,21 @@
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!specified_slab) {
|
|
|
|
- readmem(slab_chains[s],
|
|
|
|
- KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
- "slabs", FAULT_ON_ERROR);
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
+ if (!readmem(slab_chains[s],
|
|
|
|
+ KVADDR, &si->slab, sizeof(ulong),
|
|
|
|
+ "slabs", QUIET|RETURN_ON_ERROR)) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: bad slab pointer: %lx\n",
|
|
|
|
+ si->curname,
|
|
|
|
+ slab_chain_name_v2[s],
|
|
|
|
+ slab_chains[s]);
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ last = slab_chains[s];
|
|
|
|
+ } else
|
|
|
|
+ last = 0;
|
|
|
|
+
|
|
|
|
if (si->slab == slab_chains[s])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
@@ -7349,6 +7608,12 @@
|
|
|
|
if (received_SIGINT())
|
|
|
|
restart(0);
|
|
|
|
|
|
|
|
+ if (!verify_slab_v2(si, last, s)) {
|
|
|
|
+ list_borked = 1;
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ last = si->slab - OFFSET(slab_list);
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
dump_slab_percpu_v2(si);
|
|
|
|
|
|
|
|
if (si->found) {
|
|
|
|
@@ -7361,13 +7626,98 @@
|
|
|
|
|
|
|
|
si->slab -= OFFSET(slab_list);
|
|
|
|
|
|
|
|
- } while (si->slab != slab_chains[s]);
|
|
|
|
+ } while (si->slab != slab_chains[s] && !list_borked);
|
|
|
|
}
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
+/*
|
|
|
|
+ * Try to preclude any attempt to translate a bogus slab structure.
|
|
|
|
+ */
|
|
|
|
+static int
|
|
|
|
+verify_slab_v2(struct meminfo *si, ulong last, int s)
|
|
|
|
+{
|
|
|
|
+ char slab_buf[BUFSIZE];
|
|
|
|
+ struct kernel_list_head *list_head;
|
|
|
|
+ unsigned int inuse;
|
|
|
|
+ ulong s_mem;
|
|
|
|
+ char *list;
|
|
|
|
+ int errcnt;
|
|
|
|
+
|
|
|
|
+ list = slab_chain_name_v2[s];
|
|
|
|
+
|
|
|
|
+ errcnt = 0;
|
|
|
|
+
|
|
|
|
+ if (!readmem(si->slab, KVADDR, slab_buf,
|
|
|
|
+ SIZE(slab), "slab buffer", QUIET|RETURN_ON_ERROR)) {
|
|
|
|
+ error(INFO, "%s: %s list: bad slab pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab);
|
|
|
|
+ return FALSE;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ list_head = (struct kernel_list_head *)(slab_buf + OFFSET(slab_list));
|
|
|
|
+ if (!IS_KVADDR((ulong)list_head->next) ||
|
|
|
|
+ !accessible((ulong)list_head->next)) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad next pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab,
|
|
|
|
+ (ulong)list_head->next);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (last && (last != (ulong)list_head->prev)) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad prev pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab,
|
|
|
|
+ (ulong)list_head->prev);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ inuse = UINT(slab_buf + OFFSET(slab_inuse));
|
|
|
|
+ if (inuse > si->c_num) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ switch (s)
|
|
|
|
+ {
|
|
|
|
+ case 0: /* partial */
|
|
|
|
+ if ((inuse == 0) || (inuse == si->c_num)) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case 1: /* full */
|
|
|
|
+ if (inuse != si->c_num) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ case 2: /* free */
|
|
|
|
+ if (inuse > 0) {
|
|
|
|
+ error(INFO,
|
|
|
|
+ "%s: %s list: slab: %lx bad inuse counter: %ld\n",
|
|
|
|
+ si->curname, list, si->slab, inuse);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ s_mem = ULONG(slab_buf + OFFSET(slab_s_mem));
|
|
|
|
+ if (!IS_KVADDR(s_mem) || !accessible(s_mem)) {
|
|
|
|
+ error(INFO, "%s: %s list: slab: %lx bad s_mem pointer: %lx\n",
|
|
|
|
+ si->curname, list, si->slab, s_mem);
|
|
|
|
+ errcnt++;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return(errcnt ? FALSE : TRUE);
|
|
|
|
+}
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
/*
|
|
|
|
* If it's a dumpfile, save the essential slab data to avoid re-reading
|
|
|
|
@@ -7579,7 +7929,7 @@
|
|
|
|
if (INSLAB_PERCPU(si->slab, si) &&
|
|
|
|
(si->spec_addr >= si->slab) &&
|
|
|
|
(si->spec_addr < (si->slab+tmp))) {
|
|
|
|
- if (si->spec_addr >= (si->slab + SIZE(slab_s)))
|
|
|
|
+ if (si->spec_addr >= (si->slab + SIZE(slab)))
|
|
|
|
si->found = KMEM_BUFCTL_ADDR;
|
|
|
|
else
|
|
|
|
si->found = KMEM_SLAB_ADDR;
|
|
|
|
--- crash/help.c.orig 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
+++ crash/help.c 2005-01-28 15:26:13.000000000 -0500
|
|
|
|
@@ -3578,8 +3578,9 @@
|
|
|
|
" -li walks through the inactive_list and verifies nr_inactive_pages.",
|
|
|
|
" -La same as -la, but also dumps each page in the active_list.",
|
|
|
|
" -Li same as -li, but also dumps each page in the inactive_list.",
|
|
|
|
-" slab-name when used with -s or -S, limits the command to only the slab",
|
|
|
|
-" of name \"slab-cache\".",
|
|
|
|
+" slab-name when used with -s or -S, limits the command to only the slab cache",
|
|
|
|
+" of name \"slab-name\". If the slab-name argument is \"list\", then",
|
|
|
|
+" all slab cache names and addresses are listed.",
|
|
|
|
" -P declares that the following address argument is a physical address.",
|
|
|
|
" address when used without any flag, the address can be a kernel virtual,",
|
|
|
|
" or physical address; a search is made through the symbol table,",
|
|
|
|
@@ -5257,8 +5258,8 @@
|
|
|
|
" ",
|
|
|
|
" These are the current prerequisites: ",
|
|
|
|
"",
|
|
|
|
-" o At this point, x86, ia64, x86_64, alpha and ppc-based kernels are ",
|
|
|
|
-" supported. Other architectures will be addressed in the future.",
|
|
|
|
+" o At this point, x86, ia64, x86_64, alpha and ppc64-based kernels are ",
|
|
|
|
+" supported. Other architectures may be addressed in the future.",
|
|
|
|
"",
|
|
|
|
" o One size fits all -- the utility can be run on any Linux kernel version ",
|
|
|
|
" from 2.2.5-15 through 2.6.*.",
|
|
|
|
--- crash/task.c.orig 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
+++ crash/task.c 2005-01-28 15:26:13.000000000 -0500
|
|
|
|
@@ -2842,6 +2842,10 @@
|
|
|
|
fprintf(fp, "(HARDWARE RESET)");
|
|
|
|
else if (machdep->flags & SYSRQ)
|
|
|
|
fprintf(fp, "(SYSRQ)");
|
|
|
|
+ else if (machdep->flags & INIT)
|
|
|
|
+ fprintf(fp, "(INIT)");
|
|
|
|
+ else if (kt->cpu_flags[tc->processor] & NMI)
|
|
|
|
+ fprintf(fp, "(NMI)");
|
|
|
|
else if (tc->task == tt->panic_task)
|
|
|
|
fprintf(fp, "(PANIC)");
|
|
|
|
else
|
|
|
|
--- crash/kernel.c.orig 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
+++ crash/kernel.c 2005-01-28 15:26:13.000000000 -0500
|
|
|
|
@@ -3252,6 +3252,9 @@
|
|
|
|
for (i = 0; i < NR_CPUS; i++)
|
|
|
|
fprintf(fp, "%s%.*lx ", (i % 4) == 0 ? "\n " : "",
|
|
|
|
LONG_PRLEN, kt->__per_cpu_offset[i]);
|
|
|
|
+ fprintf(fp, "\n cpu_flags[NR_CPUS]:");
|
|
|
|
+ for (i = 0; i < NR_CPUS; i++)
|
|
|
|
+ fprintf(fp, "%lx ", kt->cpu_flags[i]);
|
|
|
|
fprintf(fp, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
--- crash/ia64.c.orig 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
+++ crash/ia64.c 2005-02-09 16:12:05.000000000 -0500
|
|
|
|
@@ -56,6 +56,7 @@
|
|
|
|
static struct line_number_hook ia64_line_number_hooks[];
|
|
|
|
static ulong ia64_get_stackbase(ulong);
|
|
|
|
static ulong ia64_get_stacktop(ulong);
|
|
|
|
+static void parse_cmdline_arg(void);
|
|
|
|
|
|
|
|
struct unw_frame_info;
|
|
|
|
static void dump_unw_frame_info(struct unw_frame_info *);
|
|
|
|
@@ -112,12 +113,11 @@
|
|
|
|
machdep->last_ptbl_read = 0;
|
|
|
|
machdep->verify_paddr = ia64_verify_paddr;
|
|
|
|
machdep->ptrs_per_pgd = PTRS_PER_PGD;
|
|
|
|
- if (machdep->cmdline_arg)
|
|
|
|
- machdep->machspec->phys_start =
|
|
|
|
- htol(machdep->cmdline_arg, RETURN_ON_ERROR, NULL);
|
|
|
|
- else
|
|
|
|
- machdep->machspec->phys_start = UNKNOWN_PHYS_START;
|
|
|
|
- machdep->flags |= DEVMEMRD;
|
|
|
|
+ machdep->machspec->phys_start = UNKNOWN_PHYS_START;
|
|
|
|
+ if (machdep->cmdline_arg)
|
|
|
|
+ parse_cmdline_arg();
|
|
|
|
+ if (ACTIVE())
|
|
|
|
+ machdep->flags |= DEVMEMRD;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PRE_GDB:
|
|
|
|
@@ -218,6 +218,108 @@
|
|
|
|
}
|
2004-09-09 03:57:09 +00:00
|
|
|
}
|
2005-02-10 18:39:42 +00:00
|
|
|
|
|
|
|
+/*
|
|
|
|
+ * --machdep <addr> defaults to the physical start location.
|
|
|
|
+ *
|
|
|
|
+ * Otherwise, it's got to be a "item=value" string, separated
|
|
|
|
+ * by commas if more than one is passed in.
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
+void
|
|
|
|
+parse_cmdline_arg(void)
|
|
|
|
+{
|
|
|
|
+ int i, c, errflag;
|
|
|
|
+ char *p;
|
|
|
|
+ char buf[BUFSIZE];
|
|
|
|
+ char *arglist[MAXARGS];
|
|
|
|
+ ulong value;
|
|
|
|
+ struct machine_specific *ms;
|
|
|
|
+
|
|
|
|
+ ms = &ia64_machine_specific;
|
|
|
|
+
|
|
|
|
+ if (!strstr(machdep->cmdline_arg, "=")) {
|
|
|
|
+ errflag = 0;
|
|
|
|
+ value = htol(machdep->cmdline_arg,
|
|
|
|
+ RETURN_ON_ERROR|QUIET, &errflag);
|
|
|
|
+ if (!errflag) {
|
|
|
|
+ ms->phys_start = value;
|
|
|
|
+ error(NOTE, "setting phys_start to: 0x%lx\n",
|
|
|
|
+ ms->phys_start);
|
|
|
|
+ } else
|
|
|
|
+ error(WARNING, "ignoring --machdep option: %s\n\n",
|
|
|
|
+ machdep->cmdline_arg);
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ strcpy(buf, machdep->cmdline_arg);
|
|
|
|
+
|
|
|
|
+ for (p = buf; *p; p++) {
|
|
|
|
+ if (*p == ',')
|
|
|
|
+ *p = ' ';
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ c = parse_line(buf, arglist);
|
|
|
|
+
|
|
|
|
+ for (i = 0; i < c; i++) {
|
|
|
|
+ errflag = 0;
|
|
|
|
+
|
|
|
|
+ if (STRNEQ(arglist[i], "phys_start=")) {
|
|
|
|
+ p = arglist[i] + strlen("phys_start=");
|
|
|
|
+ if (strlen(p)) {
|
|
|
|
+ value = htol(p, RETURN_ON_ERROR|QUIET,
|
|
|
|
+ &errflag);
|
|
|
|
+ if (!errflag) {
|
|
|
|
+ ms->phys_start = value;
|
|
|
|
+ error(NOTE,
|
|
|
|
+ "setting phys_start to: 0x%lx\n",
|
|
|
|
+ ms->phys_start);
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ } else if (STRNEQ(arglist[i], "init_stack_size=")) {
|
|
|
|
+ p = arglist[i] + strlen("init_stack_size=");
|
|
|
|
+ if (strlen(p)) {
|
|
|
|
+ value = stol(p, RETURN_ON_ERROR|QUIET,
|
|
|
|
+ &errflag);
|
|
|
|
+ if (!errflag) {
|
|
|
|
+ ms->ia64_init_stack_size = (int)value;
|
|
|
|
+ error(NOTE,
|
|
|
|
+ "setting init_stack_size to: 0x%x (%d)\n",
|
|
|
|
+ ms->ia64_init_stack_size,
|
|
|
|
+ ms->ia64_init_stack_size);
|
|
|
|
+ continue;
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ error(WARNING, "ignoring --machdep option: %s\n", arglist[i]);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (c)
|
|
|
|
+ fprintf(fp, "\n");
|
|
|
|
+}
|
|
|
|
+
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
|
|
|
+int
|
2005-02-10 18:39:42 +00:00
|
|
|
+ia64_in_init_stack(ulong addr)
|
2004-09-09 03:57:09 +00:00
|
|
|
+{
|
2005-02-10 18:39:42 +00:00
|
|
|
+ ulong init_stack_addr;
|
|
|
|
+
|
|
|
|
+ if (!symbol_exists("ia64_init_stack"))
|
|
|
|
+ return FALSE;
|
2004-09-09 03:57:09 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ /*
|
|
|
|
+ * ia64_init_stack could be aliased to region 5
|
|
|
|
+ */
|
|
|
|
+ init_stack_addr = ia64_VTOP(symbol_value("ia64_init_stack"));
|
|
|
|
+ addr = ia64_VTOP(addr);
|
|
|
|
+ if ((addr < init_stack_addr) ||
|
|
|
|
+ (addr >= (init_stack_addr+machdep->machspec->ia64_init_stack_size)))
|
2004-09-09 03:57:09 +00:00
|
|
|
+ return FALSE;
|
|
|
|
+
|
|
|
|
+ return TRUE;
|
|
|
|
+}
|
2005-02-10 18:39:42 +00:00
|
|
|
+
|
|
|
|
void
|
|
|
|
ia64_dump_machdep_table(ulong arg)
|
2004-09-09 03:57:09 +00:00
|
|
|
{
|
2005-02-10 18:39:42 +00:00
|
|
|
@@ -309,6 +411,8 @@
|
|
|
|
fprintf(fp, "%sSYSRQ", others++ ? "|" : "");
|
|
|
|
if (machdep->flags & DEVMEMRD)
|
|
|
|
fprintf(fp, "%sDEVMEMRD", others++ ? "|" : "");
|
|
|
|
+ if (machdep->flags & INIT)
|
|
|
|
+ fprintf(fp, "%sINIT", others++ ? "|" : "");
|
|
|
|
fprintf(fp, ")\n");
|
|
|
|
fprintf(fp, " kvbase: %lx\n", machdep->kvbase);
|
|
|
|
fprintf(fp, " identity_map_base: %lx\n", machdep->identity_map_base);
|
|
|
|
@@ -446,6 +550,9 @@
|
|
|
|
else
|
|
|
|
fprintf(fp, "%lx\n", (ulong)ms->unwind_debug);
|
|
|
|
|
|
|
|
+ fprintf(fp, " ia64_init_stack_size: %d\n",
|
|
|
|
+ ms->ia64_init_stack_size);
|
|
|
|
+
|
|
|
|
if (verbose)
|
|
|
|
ia64_display_memmap();
|
2004-09-09 03:57:09 +00:00
|
|
|
}
|
2005-02-10 18:39:42 +00:00
|
|
|
@@ -1077,9 +1184,9 @@
|
2004-09-09 03:58:15 +00:00
|
|
|
{
|
2005-02-10 18:39:42 +00:00
|
|
|
char buf1[BUFSIZE];
|
|
|
|
char buf2[BUFSIZE];
|
|
|
|
- char *colon, *p1;
|
|
|
|
+ char *colon, *p1, *p2;
|
|
|
|
int argc;
|
|
|
|
- int revise, stop_bit;
|
|
|
|
+ int revise_bracket, stop_bit;
|
|
|
|
char *argv[MAXARGS];
|
|
|
|
ulong value;
|
|
|
|
|
|
|
|
@@ -1105,25 +1212,24 @@
|
|
|
|
strcpy(buf1, inbuf);
|
|
|
|
argc = parse_line(buf1, argv);
|
|
|
|
|
|
|
|
- revise = stop_bit = 0;
|
|
|
|
+ revise_bracket = stop_bit = 0;
|
|
|
|
if ((FIRSTCHAR(argv[argc-1]) == '<') &&
|
|
|
|
(LASTCHAR(argv[argc-1]) == '>')) {
|
|
|
|
- revise = TRUE;
|
|
|
|
+ revise_bracket = TRUE;
|
|
|
|
stop_bit = FALSE;
|
|
|
|
} else if ((FIRSTCHAR(argv[argc-1]) == '<') &&
|
|
|
|
strstr(argv[argc-1], ">;;")) {
|
|
|
|
- revise = TRUE;
|
|
|
|
+ revise_bracket = TRUE;
|
|
|
|
stop_bit = TRUE;
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
- if (revise) {
|
|
|
|
+ if (revise_bracket) {
|
|
|
|
p1 = rindex(inbuf, '<');
|
|
|
|
- while ((p1 > inbuf) && !STRNEQ(p1, " 0x"))
|
|
|
|
+ while ((p1 > inbuf) && !STRNEQ(p1, "0x"))
|
|
|
|
p1--;
|
|
|
|
|
|
|
|
- if (!STRNEQ(p1, " 0x"))
|
|
|
|
+ if (!STRNEQ(p1, "0x"))
|
|
|
|
return FALSE;
|
|
|
|
- p1++;
|
|
|
|
|
|
|
|
if (!extract_hex(p1, &value, NULLCHAR, TRUE))
|
|
|
|
return FALSE;
|
|
|
|
@@ -1133,10 +1239,46 @@
|
|
|
|
stop_bit ? ";;" : "");
|
|
|
|
|
|
|
|
sprintf(p1, "%s", buf1);
|
|
|
|
- }
|
|
|
|
|
|
|
|
- console(" %s", inbuf);
|
|
|
|
+ } else if (STRNEQ(argv[argc-2], "br.call.") &&
|
|
|
|
+ STRNEQ(argv[argc-1], "b0=0x")) {
|
|
|
|
+ /*
|
|
|
|
+ * Update module function calls of these formats:
|
|
|
|
+ *
|
|
|
|
+ * br.call.sptk.many b0=0xa0000000003d5e40;;
|
|
|
|
+ * br.call.sptk.many b0=0xa00000000001dfc0
|
|
|
|
+ *
|
|
|
|
+ * to show a bracketed function name if the destination
|
|
|
|
+ * address is a known symbol with no offset.
|
|
|
|
+ */
|
|
|
|
+ if ((p1 = strstr(argv[argc-1], ";;")) &&
|
|
|
|
+ (p2 = strstr(inbuf, ";;\n"))) {
|
|
|
|
+ *p1 = NULLCHAR;
|
|
|
|
+ p1 = &argv[argc-1][3];
|
|
|
|
+
|
|
|
|
+ if (extract_hex(p1, &value, NULLCHAR, TRUE)) {
|
|
|
|
+ sprintf(buf1, " <%s>;;\n",
|
|
|
|
+ value_to_symstr(value, buf2,
|
|
|
|
+ pc->output_radix));
|
|
|
|
+ if (IS_MODULE_VADDR(value) &&
|
|
|
|
+ !strstr(buf2, "+"))
|
|
|
|
+ sprintf(p2, buf1);
|
|
|
|
+ }
|
|
|
|
+ } else {
|
|
|
|
+ p1 = &argv[argc-1][3];
|
|
|
|
+ p2 = &LASTCHAR(inbuf);
|
|
|
|
+ if (extract_hex(p1, &value, '\n', TRUE)) {
|
|
|
|
+ sprintf(buf1, " <%s>\n",
|
|
|
|
+ value_to_symstr(value, buf2,
|
|
|
|
+ pc->output_radix));
|
|
|
|
+ if (IS_MODULE_VADDR(value) &&
|
|
|
|
+ !strstr(buf2, "+"))
|
|
|
|
+ sprintf(p2, buf1);
|
|
|
|
+ }
|
2004-09-09 03:58:15 +00:00
|
|
|
+ }
|
|
|
|
+ }
|
2005-02-10 18:39:42 +00:00
|
|
|
|
|
|
|
+ console(" %s", inbuf);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
@@ -2540,6 +2682,13 @@
|
|
|
|
"unimpl_pa_mask", FAULT_ON_ERROR);
|
|
|
|
}
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ if (symbol_exists("ia64_init_stack") && !ms->ia64_init_stack_size)
|
|
|
|
+ ms->ia64_init_stack_size = get_array_length("ia64_init_stack",
|
|
|
|
+ NULL, 0);
|
|
|
|
+
|
|
|
|
+ if (DUMPFILE() && ia64_in_init_stack(SWITCH_STACK_ADDR(CURRENT_TASK())))
|
|
|
|
+ machdep->flags |= INIT;
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
/*
|
|
|
|
--- crash/x86_64.c.orig 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
+++ crash/x86_64.c 2005-01-28 15:26:13.000000000 -0500
|
|
|
|
@@ -64,6 +64,7 @@
|
|
|
|
static void x86_64_init_kernel_pgd(void);
|
|
|
|
static void x86_64_cpu_pda_init(void);
|
|
|
|
static void x86_64_ist_init(void);
|
|
|
|
+static void x86_64_post_init(void);
|
|
|
|
|
|
|
|
|
|
|
|
struct machine_specific x86_64_machine_specific = { 0 };
|
|
|
|
@@ -172,6 +173,7 @@
|
|
|
|
break;
|
|
|
|
|
|
|
|
case POST_INIT:
|
|
|
|
+ x86_64_post_init();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@@ -482,6 +484,55 @@
|
|
|
|
}
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+static void
|
|
|
|
+x86_64_post_init(void)
|
|
|
|
+{
|
|
|
|
+ int c, i, clues;
|
|
|
|
+ struct machine_specific *ms;
|
|
|
|
+ ulong *up;
|
|
|
|
+ struct syment *spt, *spc;
|
|
|
|
+ ulong offset;
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Check whether each cpu was stopped by an NMI.
|
|
|
|
+ */
|
|
|
|
+ ms = machdep->machspec;
|
|
|
|
+
|
|
|
|
+ for (c = 0; c < kt->cpus; c++) {
|
|
|
|
+ if (ms->stkinfo.ebase[c][NMI_STACK] == 0)
|
|
|
|
+ break;
|
|
|
|
+
|
|
|
|
+ if (!readmem(ms->stkinfo.ebase[c][NMI_STACK],
|
|
|
|
+ KVADDR, ms->irqstack,
|
|
|
|
+ ms->stkinfo.esize,
|
|
|
|
+ "NMI exception stack contents",
|
|
|
|
+ RETURN_ON_ERROR|QUIET))
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ for (i = clues = 0; i < (ms->stkinfo.esize)/sizeof(ulong); i++){
|
|
|
|
+ up = (ulong *)(&ms->irqstack[i*sizeof(ulong)]);
|
|
|
|
+
|
|
|
|
+ if (!is_kernel_text(*up) ||
|
|
|
|
+ !(spt = value_search(*up, &offset)))
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ if (STREQ(spt->name, "try_crashdump") ||
|
|
|
|
+ STREQ(spt->name, "die_nmi"))
|
|
|
|
+ clues++;
|
|
|
|
+
|
|
|
|
+ if ((STREQ(spt->name, "nmi_watchdog_tick") ||
|
|
|
|
+ STREQ(spt->name, "default_do_nmi"))) {
|
|
|
|
+ spc = x86_64_function_called_by((*up)-5);
|
|
|
|
+ if (spc && STREQ(spc->name, "die_nmi"))
|
|
|
|
+ clues += 2;
|
|
|
|
+ }
|
2004-09-09 03:58:15 +00:00
|
|
|
+ }
|
2005-02-10 18:39:42 +00:00
|
|
|
+
|
|
|
|
+ if (clues >= 2)
|
|
|
|
+ kt->cpu_flags[c] |= NMI;
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
/*
|
|
|
|
* No x86_64 swapper_pg_dir; initialize the vt->kernel_pgd[NR_CPUS] array
|
|
|
|
* with the lazily-sync'd init_level4_pgt page address. The level4 page
|
|
|
|
@@ -1128,7 +1179,8 @@
|
|
|
|
return BACKTRACE_ENTRY_DISPLAYED;
|
|
|
|
}
|
|
|
|
|
|
|
|
- if (!offset && !(bt->flags & BT_EXCEPTION_FRAME)) {
|
|
|
|
+ if (!offset && !(bt->flags & BT_EXCEPTION_FRAME) &&
|
|
|
|
+ !(bt->flags & BT_START)) {
|
|
|
|
if (STREQ(name, "child_rip")) {
|
|
|
|
if (symbol_exists("kernel_thread"))
|
|
|
|
name = "kernel_thread";
|
|
|
|
@@ -1164,6 +1216,8 @@
|
|
|
|
|
|
|
|
if (bt->flags & BT_EXCEPTION_FRAME)
|
|
|
|
rsp = bt->stkptr;
|
|
|
|
+ else if (bt->flags & BT_START)
|
|
|
|
+ rsp = bt->stkptr;
|
|
|
|
else
|
|
|
|
rsp = bt->stackbase + (stkindex * sizeof(long));
|
|
|
|
|
|
|
|
@@ -1320,6 +1374,10 @@
|
|
|
|
irq_eframe = 0;
|
|
|
|
bt->call_target = NULL;
|
|
|
|
rsp = bt->stkptr;
|
|
|
|
+ if (!rsp) {
|
|
|
|
+ error(INFO, "cannot determine starting stack pointer\n");
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
ms = machdep->machspec;
|
|
|
|
if (BT_REFERENCE_CHECK(bt))
|
|
|
|
ofp = pc->nullfp;
|
|
|
|
@@ -1333,7 +1391,12 @@
|
|
|
|
STREQ(closest_symbol(bt->instptr), "thread_return") ?
|
|
|
|
" (schedule)" : "",
|
|
|
|
bt->instptr);
|
|
|
|
- }
|
|
|
|
+ } else if (bt->flags & BT_START) {
|
|
|
|
+ x86_64_print_stack_entry(bt, ofp, level,
|
|
|
|
+ 0, bt->instptr);
|
|
|
|
+ bt->flags &= ~BT_START;
|
|
|
|
+ level++;
|
2004-09-09 03:58:15 +00:00
|
|
|
+ }
|
|
|
|
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
if ((estack = x86_64_in_exception_stack(bt))) {
|
|
|
|
@@ -1403,7 +1466,8 @@
|
|
|
|
bt->stackbuf + (bt->stacktop - bt->stackbase) -
|
|
|
|
SIZE(pt_regs), bt, ofp);
|
|
|
|
|
|
|
|
- fprintf(fp, "--- <exception stack> ---\n");
|
|
|
|
+ if (!BT_REFERENCE_CHECK(bt))
|
|
|
|
+ fprintf(fp, "--- <exception stack> ---\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* stack = (unsigned long *) estack_end[-2];
|
|
|
|
@@ -1411,13 +1475,24 @@
|
|
|
|
up = (ulong *)(&bt->stackbuf[bt->stacktop - bt->stackbase]);
|
|
|
|
up -= 2;
|
|
|
|
rsp = bt->stkptr = *up;
|
|
|
|
- up -= 5;
|
|
|
|
+ up -= 3;
|
|
|
|
bt->instptr = *up;
|
|
|
|
if (cs & 3)
|
|
|
|
done = TRUE; /* user-mode exception */
|
|
|
|
else
|
|
|
|
done = FALSE; /* kernel-mode exception */
|
|
|
|
bt->frameptr = 0;
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * Print the return values from the estack end.
|
|
|
|
+ */
|
|
|
|
+ if (!done) {
|
|
|
|
+ bt->flags |= BT_START;
|
|
|
|
+ x86_64_print_stack_entry(bt, ofp, level,
|
|
|
|
+ 0, bt->instptr);
|
|
|
|
+ bt->flags &= ~BT_START;
|
|
|
|
+ level++;
|
|
|
|
+ }
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
@@ -1466,7 +1541,8 @@
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
}
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
- fprintf(fp, "--- <IRQ stack> ---\n");
|
|
|
|
+ if (!BT_REFERENCE_CHECK(bt))
|
|
|
|
+ fprintf(fp, "--- <IRQ stack> ---\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* stack = (unsigned long *) (irqstack_end[-1]);
|
|
|
|
@@ -1950,6 +2026,7 @@
|
|
|
|
int panic_task;
|
|
|
|
int i, panic, stage;
|
|
|
|
char *sym;
|
|
|
|
+ struct syment *sp;
|
|
|
|
ulong *up;
|
|
|
|
struct bt_info bt_local, *bt;
|
|
|
|
struct machine_specific *ms;
|
|
|
|
@@ -1999,12 +2076,27 @@
|
2004-09-09 03:58:15 +00:00
|
|
|
if (STREQ(sym, "netconsole_netdump") ||
|
2005-02-10 18:39:42 +00:00
|
|
|
STREQ(sym, "netpoll_start_netdump") ||
|
|
|
|
STREQ(sym, "start_disk_dump") ||
|
|
|
|
- STREQ(sym, "disk_dump")) {
|
|
|
|
+ STREQ(sym, "disk_dump") ||
|
|
|
|
+ STREQ(sym, "try_crashdump")) {
|
2004-09-09 03:58:15 +00:00
|
|
|
*rip = *up;
|
|
|
|
*rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
|
2005-02-10 18:39:42 +00:00
|
|
|
return;
|
|
|
|
}
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+ if ((stage == 2) &&
|
|
|
|
+ (STREQ(sym, "nmi_watchdog_tick") ||
|
|
|
|
+ STREQ(sym, "default_do_nmi"))) {
|
|
|
|
+ sp = x86_64_function_called_by((*up)-5);
|
|
|
|
+ if (!sp || !STREQ(sp->name, "die_nmi"))
|
|
|
|
+ continue;
|
|
|
|
+ *rip = *up;
|
|
|
|
+ *rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
|
|
|
|
+ bt_in->flags |= BT_START;
|
|
|
|
+ *rip = symbol_value("die_nmi");
|
|
|
|
+ *rsp = (*rsp) - (7*sizeof(ulong));
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
if (STREQ(sym, "panic")) {
|
|
|
|
*rip = *up;
|
|
|
|
*rsp = bt->stackbase + ((char *)(up) - bt->stackbuf);
|
|
|
|
@@ -2062,7 +2154,19 @@
|
|
|
|
stage = 1;
|
|
|
|
goto next_stack;
|
|
|
|
|
|
|
|
+ /*
|
|
|
|
+ * Check the NMI exception stack.
|
|
|
|
+ */
|
|
|
|
case 1:
|
|
|
|
+ bt->stackbase = ms->stkinfo.ebase[bt->tc->processor][NMI_STACK];
|
|
|
|
+ bt->stacktop = ms->stkinfo.ebase[bt->tc->processor][NMI_STACK] +
|
|
|
|
+ ms->stkinfo.esize;
|
|
|
|
+ bt->stackbuf = ms->irqstack;
|
|
|
|
+ alter_stackbuf(bt);
|
|
|
|
+ stage = 2;
|
|
|
|
+ goto next_stack;
|
|
|
|
+
|
|
|
|
+ case 2:
|
|
|
|
break;
|
2004-09-09 03:57:09 +00:00
|
|
|
}
|
2005-02-10 18:39:42 +00:00
|
|
|
|
|
|
|
--- crash/unwind.c.orig 2005-02-09 16:13:26.000000000 -0500
|
|
|
|
+++ crash/unwind.c 2005-02-07 16:02:44.000000000 -0500
|
|
|
|
@@ -31,6 +31,10 @@
|
|
|
|
* unwind_v[123].o object files.
|
2004-09-09 03:58:15 +00:00
|
|
|
*/
|
2004-09-09 03:57:09 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+/*
|
|
|
|
+ * 2004-09-14 J. Nomura Added OS_INIT handling
|
|
|
|
+ */
|
|
|
|
+
|
|
|
|
/* #include <asm/ptrace.h> can't include this -- it's changing over time! */
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
@@ -56,6 +60,13 @@
|
|
|
|
static void dump_unwind_table(struct unw_table *);
|
|
|
|
static int unw_init_from_blocked_task(struct unw_frame_info *,
|
|
|
|
struct bt_info *);
|
|
|
|
+static void unw_init_from_interruption(struct unw_frame_info *,
|
|
|
|
+ struct bt_info *, ulong, ulong);
|
|
|
|
+static int unw_switch_from_osinit_v1(struct unw_frame_info *,
|
|
|
|
+ struct bt_info *);
|
|
|
|
+static int unw_switch_from_osinit_v2(struct unw_frame_info *,
|
|
|
|
+ struct bt_info *);
|
|
|
|
+static unsigned long get_init_stack_ulong(unsigned long addr);
|
|
|
|
static void unw_init_frame_info(struct unw_frame_info *,
|
|
|
|
struct bt_info *, ulong);
|
|
|
|
static int find_save_locs(struct unw_frame_info *);
|
|
|
|
@@ -406,8 +417,8 @@
|
|
|
|
else
|
|
|
|
*nat_addr &= ~nat_mask;
|
|
|
|
} else {
|
|
|
|
- if ((GET_STACK_ULONG(nat_addr) & nat_mask) == 0) {
|
|
|
|
- *val = GET_STACK_ULONG(addr);
|
|
|
|
+ if ((IA64_GET_STACK_ULONG(nat_addr) & nat_mask) == 0) {
|
|
|
|
+ *val = IA64_GET_STACK_ULONG(addr);
|
|
|
|
*nat = 0;
|
|
|
|
} else {
|
|
|
|
*val = 0; /* if register is a NaT, *addr may contain kernel data! */
|
|
|
|
@@ -457,7 +468,7 @@
|
|
|
|
if (write)
|
|
|
|
*addr = *val;
|
|
|
|
else
|
|
|
|
- *val = GET_STACK_ULONG(addr);
|
|
|
|
+ *val = IA64_GET_STACK_ULONG(addr);
|
|
|
|
return 0;
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
@@ -695,7 +706,7 @@
|
|
|
|
*info->cfm_loc =
|
|
|
|
(*info->cfm_loc & ~(0x3fUL << 52)) | ((*val & 0x3f) << 52);
|
|
|
|
else
|
|
|
|
- *val = (GET_STACK_ULONG(info->cfm_loc) >> 52) & 0x3f;
|
|
|
|
+ *val = (IA64_GET_STACK_ULONG(info->cfm_loc) >> 52) & 0x3f;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case UNW_AR_FPSR:
|
|
|
|
@@ -739,7 +750,7 @@
|
|
|
|
if (write)
|
|
|
|
*addr = *val;
|
|
|
|
else
|
|
|
|
- *val = GET_STACK_ULONG(addr);
|
|
|
|
+ *val = IA64_GET_STACK_ULONG(addr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -764,7 +775,7 @@
|
|
|
|
if (write)
|
|
|
|
*addr = *val;
|
|
|
|
else
|
|
|
|
- *val = GET_STACK_ULONG(addr);
|
|
|
|
+ *val = IA64_GET_STACK_ULONG(addr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
@@ -1644,6 +1655,7 @@
|
|
|
|
frame = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
+restart:
|
|
|
|
unw_get_ip(info, &ip);
|
|
|
|
unw_get_sp(info, &sp);
|
|
|
|
unw_get_bsp(info, &bsp);
|
|
|
|
@@ -1695,6 +1707,26 @@
|
|
|
|
STREQ(name, "start_kernel_thread"))
|
2004-09-09 03:58:15 +00:00
|
|
|
break;
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+ /*
|
|
|
|
+ * "init_handler_platform" indicates that this task was
|
|
|
|
+ * interrupted by INIT and its stack was switched.
|
|
|
|
+ */
|
|
|
|
+ if (STREQ(name, "init_handler_platform")) {
|
|
|
|
+ unw_switch_from_osinit_v1(info, bt);
|
|
|
|
+ frame++;
|
|
|
|
+ goto restart;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ /*
|
|
|
|
+ * In some cases, init_handler_platform is inlined into
|
|
|
|
+ * ia64_init_handler.
|
|
|
|
+ */
|
|
|
|
+ if (STREQ(name, "ia64_init_handler")) {
|
|
|
|
+ unw_switch_from_osinit_v2(info, bt);
|
|
|
|
+ frame++;
|
|
|
|
+ goto restart;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
frame++;
|
|
|
|
|
|
|
|
} while (unw_unwind(info) >= 0);
|
|
|
|
@@ -1797,6 +1829,16 @@
|
|
|
|
dump_struct("unw_table", (ulong)table, RADIX(16));
|
|
|
|
}
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+static unsigned long
|
|
|
|
+get_init_stack_ulong(unsigned long addr)
|
|
|
|
+{
|
|
|
|
+ unsigned long tmp;
|
|
|
|
+
|
|
|
|
+ readmem(addr, KVADDR, &tmp, sizeof(unsigned long),
|
|
|
|
+ "get_init_stack_ulong", FAULT_ON_ERROR);
|
|
|
|
+
|
|
|
|
+ return tmp;
|
|
|
|
+}
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
static int
|
|
|
|
unw_init_from_blocked_task(struct unw_frame_info *info, struct bt_info *bt)
|
|
|
|
@@ -1804,13 +1846,129 @@
|
|
|
|
ulong sw;
|
|
|
|
|
|
|
|
sw = SWITCH_STACK_ADDR(bt->task);
|
|
|
|
- if (!INSTACK(sw, bt))
|
|
|
|
+ if (!INSTACK(sw, bt) && !ia64_in_init_stack(sw))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
unw_init_frame_info(info, bt, sw);
|
2004-09-09 03:58:15 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+/*
|
|
|
|
+ * unw_init_from_interruption
|
|
|
|
+ * Initialize frame info from specified pt_regs/switch_stack.
|
|
|
|
+ *
|
|
|
|
+ * Similar to unw_init_frame_info() except that:
|
|
|
|
+ * - do not use readmem to access stack
|
|
|
|
+ * (because stack may be modified by unw_init_from_saved_regs)
|
|
|
|
+ * - use ar.ifs and ar.iip instead of ar.pfs and b0, respectively
|
|
|
|
+ * - use sof(size-of-frame) of ar.ifs to caluculate bsp,
|
|
|
|
+ * instead of sol(size-of-local) of ar.pfs
|
|
|
|
+ * (because of cover instruction in kernel minstate save macro)
|
|
|
|
+ */
|
|
|
|
+static void
|
|
|
|
+unw_init_from_interruption(struct unw_frame_info *info, struct bt_info *bt, ulong pt, ulong sw)
|
|
|
|
+{
|
|
|
|
+// unsigned long rbslimit, rbstop, stklimit, stktop, sof, ar_pfs;
|
|
|
|
+ unsigned long rbslimit, rbstop, stklimit, stktop, sof;
|
|
|
|
+ ulong t;
|
|
|
|
+
|
|
|
|
+ t = bt->task;
|
|
|
|
+
|
|
|
|
+ memset(info, 0, sizeof(*info));
|
|
|
|
+
|
|
|
|
+ rbslimit = (unsigned long) t + IA64_RBS_OFFSET;
|
|
|
|
+ rbstop = IA64_GET_STACK_ULONG(sw + OFFSET(switch_stack_ar_bspstore));
|
|
|
|
+ if (rbstop - (unsigned long) t >= IA64_STK_OFFSET)
|
|
|
|
+ rbstop = rbslimit;
|
|
|
|
+
|
|
|
|
+ stklimit = (unsigned long) t + IA64_STK_OFFSET;
|
|
|
|
+ stktop = IA64_GET_STACK_ULONG(pt + offsetof(struct pt_regs, r12));
|
|
|
|
+ if (stktop <= rbstop)
|
|
|
|
+ stktop = rbstop;
|
|
|
|
+
|
|
|
|
+ info->regstk.limit = rbslimit;
|
|
|
|
+ info->regstk.top = rbstop;
|
|
|
|
+ info->memstk.limit = stklimit;
|
|
|
|
+ info->memstk.top = stktop;
|
|
|
|
+ info->task = (struct task_struct *)bt;
|
|
|
|
+ info->sw = (struct switch_stack *)sw;
|
|
|
|
+ info->sp = info->psp = stktop;
|
|
|
|
+ info->pr = IA64_GET_STACK_ULONG(sw + OFFSET(switch_stack_pr));
|
|
|
|
+
|
|
|
|
+ info->cfm_loc = (unsigned long *) (pt + offsetof(struct pt_regs, cr_ifs));
|
|
|
|
+ info->unat_loc = (unsigned long *) (pt + offsetof(struct pt_regs, ar_unat));
|
|
|
|
+ info->pfs_loc = (unsigned long *) (pt + offsetof(struct pt_regs, ar_pfs));
|
|
|
|
+ /* register stack is covered */
|
|
|
|
+ sof = IA64_GET_STACK_ULONG(info->cfm_loc) & 0x7f;
|
|
|
|
+ info->bsp = (unsigned long)
|
|
|
|
+ ia64_rse_skip_regs((unsigned long *) info->regstk.top, -sof);
|
|
|
|
+ /* interrupted ip is saved in iip */
|
|
|
|
+ info->ip = IA64_GET_STACK_ULONG(pt + offsetof(struct pt_regs, cr_iip));
|
|
|
|
+#if defined(UNWIND_V2) || defined(UNWIND_V3)
|
|
|
|
+ info->pt = pt;
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+ find_save_locs(info);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+/*
|
|
|
|
+ * unw_switch_from_osinit
|
|
|
|
+ * switch back to interrupted context
|
|
|
|
+ *
|
|
|
|
+ * assumption: init_handler_platform() has 3 arguments,
|
|
|
|
+ * 2nd arg is pt_regs and 3rd arg is switch_stack.
|
|
|
|
+ */
|
2004-09-09 03:58:15 +00:00
|
|
|
+static int
|
2005-02-10 18:39:42 +00:00
|
|
|
+unw_switch_from_osinit_v1(struct unw_frame_info *info, struct bt_info *bt)
|
2004-09-09 03:58:15 +00:00
|
|
|
+{
|
2005-02-10 18:39:42 +00:00
|
|
|
+ unsigned long pt, sw;
|
|
|
|
+ char is_nat;
|
2004-09-09 03:58:15 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ /* pt_regs is the 2nd argument of init_handler_platform */
|
|
|
|
+ if (unw_get_gr(info, 33, &pt, &is_nat)) {
|
|
|
|
+ fprintf(fp, "gr 33 get error\n");
|
|
|
|
+ return FALSE;
|
|
|
|
+ }
|
|
|
|
+ /* switch_stack is the 3rd argument of init_handler_platform */
|
|
|
|
+ if (unw_get_gr(info, 34, &sw, &is_nat)) {
|
|
|
|
+ fprintf(fp, "gr 33 get error\n");
|
|
|
|
+ return FALSE;
|
|
|
|
+ }
|
2004-09-09 03:58:15 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ unw_init_from_interruption(info, bt, pt, sw);
|
|
|
|
+ ia64_exception_frame(pt, bt);
|
2004-09-09 03:58:15 +00:00
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ return TRUE;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static int
|
|
|
|
+unw_switch_from_osinit_v2(struct unw_frame_info *info, struct bt_info *bt)
|
|
|
|
+{
|
|
|
|
+ unsigned long pt, sw;
|
|
|
|
+ char is_nat;
|
|
|
|
+
|
|
|
|
+ /* pt_regs is the 1st argument of ia64_init_handler */
|
|
|
|
+ if (unw_get_gr(info, 32, &pt, &is_nat)) {
|
|
|
|
+ fprintf(fp, "gr 32 get error\n");
|
|
|
|
+
|
|
|
|
+ return FALSE;
|
|
|
|
+ }
|
|
|
|
+ /* switch_stack is the 2nd argument of ia64_init_handler */
|
|
|
|
+ if (unw_get_gr(info, 33, &sw, &is_nat)) {
|
|
|
|
+ fprintf(fp, "gr 33 get error\n");
|
|
|
|
+ return FALSE;
|
2004-09-09 03:58:15 +00:00
|
|
|
+ }
|
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
+ /* Fix me! */
|
|
|
|
+ sw = info->psp + 16;
|
|
|
|
+ pt = sw + STRUCT_SIZE("switch_stack");
|
|
|
|
+
|
|
|
|
+ unw_init_from_interruption(info, bt, pt, sw);
|
|
|
|
+ ia64_exception_frame(pt, bt);
|
|
|
|
+
|
|
|
|
+ return TRUE;
|
2004-09-09 03:58:15 +00:00
|
|
|
+}
|
|
|
|
+
|
2005-02-10 18:39:42 +00:00
|
|
|
static void
|
|
|
|
unw_init_frame_info (struct unw_frame_info *info, struct bt_info *bt, ulong sw)
|
|
|
|
{
|
|
|
|
@@ -1851,12 +2009,12 @@
|
|
|
|
info->sw = (struct switch_stack *)sw;
|
|
|
|
info->sp = info->psp = (unsigned long) (sw + SIZE(switch_stack)) - 16;
|
|
|
|
info->cfm_loc = (ulong *)(sw + OFFSET(switch_stack_ar_pfs));
|
|
|
|
- ar_pfs = GET_STACK_ULONG(info->cfm_loc);
|
|
|
|
+ ar_pfs = IA64_GET_STACK_ULONG(info->cfm_loc);
|
|
|
|
sol = (ar_pfs >> 7) & 0x7f;
|
|
|
|
info->bsp = (unsigned long)
|
|
|
|
ia64_rse_skip_regs((unsigned long *) info->regstk.top, -sol);
|
|
|
|
- info->ip = GET_STACK_ULONG(sw + OFFSET(switch_stack_b0));
|
|
|
|
- info->pr = GET_STACK_ULONG(sw + OFFSET(switch_stack_pr));
|
|
|
|
+ info->ip = IA64_GET_STACK_ULONG(sw + OFFSET(switch_stack_b0));
|
|
|
|
+ info->pr = IA64_GET_STACK_ULONG(sw + OFFSET(switch_stack_pr));
|
|
|
|
|
|
|
|
find_save_locs(info);
|
|
|
|
}
|
|
|
|
@@ -1973,7 +2131,7 @@
|
|
|
|
info->ip);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
- ip = info->ip = GET_STACK_ULONG(info->rp_loc);
|
|
|
|
+ ip = info->ip = IA64_GET_STACK_ULONG(info->rp_loc);
|
|
|
|
if (ip < GATE_ADDR + PAGE_SIZE) {
|
|
|
|
/*
|
|
|
|
* We don't have unwind info for the gate page,
|
|
|
|
@@ -1997,26 +2155,26 @@
|
|
|
|
if ((info->flags & UNW_FLAG_INTERRUPT_FRAME)) {
|
|
|
|
#ifdef UNWIND_V1
|
|
|
|
if ((pr & (1UL << pNonSys)) != 0)
|
|
|
|
- num_regs = GET_STACK_ULONG(info->cfm_loc) & 0x7f; /* size of frame */
|
|
|
|
+ num_regs = IA64_GET_STACK_ULONG(info->cfm_loc) & 0x7f; /* size of frame */
|
|
|
|
info->pfs_loc =
|
|
|
|
(unsigned long *) (info->sp + 16 + struct_offset(struct pt_regs, ar_pfs));
|
2004-09-09 03:58:15 +00:00
|
|
|
#endif
|
2005-02-10 18:39:42 +00:00
|
|
|
#ifdef UNWIND_V2
|
|
|
|
info->pt = info->sp + 16;
|
|
|
|
if ((pr & (1UL << pNonSys)) != 0)
|
|
|
|
- num_regs = GET_STACK_ULONG(info->cfm_loc) & 0x7f; /* size of frame */
|
|
|
|
+ num_regs = IA64_GET_STACK_ULONG(info->cfm_loc) & 0x7f; /* size of frame */
|
|
|
|
info->pfs_loc =
|
|
|
|
(unsigned long *) (info->pt + offsetof(struct pt_regs, ar_pfs));
|
|
|
|
#endif
|
|
|
|
#ifdef UNWIND_V3
|
|
|
|
info->pt = info->sp + 16;
|
|
|
|
if ((pr & (1UL << pNonSys)) != 0)
|
|
|
|
- num_regs = GET_STACK_ULONG(info->cfm_loc) & 0x7f; /* size of frame */
|
|
|
|
+ num_regs = IA64_GET_STACK_ULONG(info->cfm_loc) & 0x7f; /* size of frame */
|
|
|
|
info->pfs_loc =
|
|
|
|
(unsigned long *) (info->pt + offsetof(struct pt_regs, ar_pfs));
|
|
|
|
#endif
|
|
|
|
} else
|
|
|
|
- num_regs = (GET_STACK_ULONG(info->cfm_loc) >> 7) & 0x7f; /* size of locals */
|
|
|
|
+ num_regs = (IA64_GET_STACK_ULONG(info->cfm_loc) >> 7) & 0x7f; /* size of locals */
|
|
|
|
info->bsp = (unsigned long) ia64_rse_skip_regs((unsigned long *) info->bsp, -num_regs);
|
|
|
|
if (info->bsp < info->regstk.limit || info->bsp > info->regstk.top) {
|
|
|
|
error(INFO, "unwind: bsp (0x%lx) out of range [0x%lx-0x%lx]\n",
|
|
|
|
@@ -2026,7 +2184,8 @@
|
|
|
|
|
|
|
|
/* restore the sp: */
|
|
|
|
info->sp = info->psp;
|
|
|
|
- if (info->sp < info->memstk.top || info->sp > info->memstk.limit) {
|
|
|
|
+ if ((info->sp < info->memstk.top || info->sp > info->memstk.limit)
|
|
|
|
+ && !ia64_in_init_stack(info->sp)) {
|
|
|
|
error(INFO, "unwind: sp (0x%lx) out of range [0x%lx-0x%lx]\n",
|
|
|
|
info->sp, info->memstk.top, info->memstk.limit);
|
|
|
|
return -1;
|
|
|
|
@@ -2135,7 +2294,7 @@
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
- s[dst] = GET_STACK_ULONG(s[val]);
|
|
|
|
+ s[dst] = IA64_GET_STACK_ULONG(s[val]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
--- crash/defs.h.orig 2005-02-09 16:13:26.000000000 -0500
|
|
|
|
+++ crash/defs.h 2005-01-28 15:26:12.000000000 -0500
|
|
|
|
@@ -62,7 +62,7 @@
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
|
|
|
-#define BASELEVEL_REVISION "3.8"
|
|
|
|
+#define BASELEVEL_REVISION "3.10"
|
2004-09-09 03:58:15 +00:00
|
|
|
|
|
|
|
#undef TRUE
|
|
|
|
#undef FALSE
|
2005-02-10 18:39:42 +00:00
|
|
|
@@ -446,6 +446,8 @@
|
|
|
|
long __rq_idx[NR_CPUS];
|
|
|
|
long __cpu_idx[NR_CPUS];
|
|
|
|
long __per_cpu_offset[NR_CPUS];
|
|
|
|
+ long cpu_flags[NR_CPUS];
|
|
|
|
+#define NMI 0x1
|
|
|
|
};
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
/*
|
|
|
|
@@ -674,6 +676,7 @@
|
|
|
|
#define FRAMESIZE_DEBUG (0x10000000)
|
|
|
|
#define MACHDEP_BT_TEXT (0x8000000)
|
|
|
|
#define DEVMEMRD (0x4000000)
|
|
|
|
+#define INIT (0x2000000)
|
|
|
|
#define SYSRQ_TASK(X) ((machdep->flags & SYSRQ) && is_task_active(X))
|
|
|
|
|
|
|
|
extern struct machdep_table *machdep;
|
|
|
|
@@ -2030,6 +2033,9 @@
|
|
|
|
#define UNKNOWN_PHYS_START ((ulong)(-1))
|
|
|
|
#define DEFAULT_PHYS_START (KERNEL_TR_PAGE_SIZE * 1)
|
|
|
|
|
|
|
|
+#define IA64_GET_STACK_ULONG(OFF) \
|
|
|
|
+ ((INSTACK(OFF,bt)) ? (GET_STACK_ULONG(OFF)) : get_init_stack_ulong((unsigned long)OFF))
|
|
|
|
+
|
|
|
|
#endif /* IA64 */
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
#ifdef PPC64
|
|
|
|
@@ -3106,6 +3112,7 @@
|
|
|
|
#define BT_IRQSTACK (0x200000000ULL)
|
|
|
|
#define BT_DUMPFILE_SEARCH (0x400000000ULL)
|
|
|
|
#define BT_EFRAME_SEARCH2 (0x800000000ULL)
|
|
|
|
+#define BT_START (0x1000000000ULL)
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
#define BT_REF_HEXVAL (0x1)
|
|
|
|
#define BT_REF_SYMBOL (0x2)
|
|
|
|
@@ -3229,6 +3236,8 @@
|
|
|
|
int isize;
|
|
|
|
};
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+#define NMI_STACK 2 /* ebase[] offset to NMI exception stack */
|
|
|
|
+
|
|
|
|
struct machine_specific {
|
|
|
|
char *pml4;
|
|
|
|
char *irqstack;
|
|
|
|
@@ -3318,6 +3327,7 @@
|
|
|
|
int ia64_IS_VMALLOC_ADDR(ulong);
|
|
|
|
#define display_idt_table() \
|
|
|
|
error(FATAL, "-d option TBD on ia64 architecture\n");
|
|
|
|
+int ia64_in_init_stack(ulong addr);
|
|
|
|
|
|
|
|
#define OLD_UNWIND (0x1) /* CONFIG_IA64_NEW_UNWIND not turned on */
|
|
|
|
#define NEW_UNWIND (0x2) /* CONFIG_IA64_NEW_UNWIND turned on */
|
|
|
|
@@ -3359,8 +3369,10 @@
|
|
|
|
void (*unwind)(struct bt_info *);
|
|
|
|
void (*dump_unwind_stats)(void);
|
|
|
|
int (*unwind_debug)(ulong);
|
|
|
|
+ int ia64_init_stack_size;
|
|
|
|
};
|
2004-09-09 03:58:15 +00:00
|
|
|
|
2005-02-10 18:39:42 +00:00
|
|
|
+
|
|
|
|
/*
|
|
|
|
* unwind.c
|
2004-09-09 03:58:15 +00:00
|
|
|
*/
|
2005-02-10 18:39:42 +00:00
|
|
|
--- crash/Makefile.orig 2005-02-09 16:13:26.000000000 -0500
|
|
|
|
+++ crash/Makefile 2005-02-09 16:13:25.000000000 -0500
|
|
|
|
@@ -153,10 +153,10 @@
|
|
|
|
GDB_6.1_FILES=${GDB}/gdb/Makefile.in ${GDB}/Makefile.in \
|
|
|
|
${GDB}/gdb/main.c ${GDB}/gdb/symtab.c ${GDB}/gdb/target.c \
|
|
|
|
${GDB}/gdb/symfile.c ${GDB}/gdb/elfread.c \
|
|
|
|
- ${GDB}/gdb/ui-file.c ${GDB}/gdb/utils.c
|
|
|
|
+ ${GDB}/gdb/ui-file.c ${GDB}/gdb/utils.c ${GDB}/gdb/dwarf2read.c
|
|
|
|
GDB_6.1_OFILES=${GDB}/gdb/main.o ${GDB}/gdb/symtab.o \
|
|
|
|
${GDB}/gdb/target.o ${GDB}/gdb/symfile.o ${GDB}/gdb/elfread.o \
|
|
|
|
- ${GDB}/gdb/ui-file.o ${GDB}/gdb/utils.o
|
|
|
|
+ ${GDB}/gdb/ui-file.o ${GDB}/gdb/utils.o ${GDB}/gdb/dwarf2read.o
|
|
|
|
|
|
|
|
#
|
|
|
|
# GDB_FLAGS is passed up from the gdb Makefile.
|
|
|
|
--- crash/crash.8.orig 2005-02-09 16:13:26.000000000 -0500
|
|
|
|
+++ crash/crash.8 2005-01-31 10:55:43.000000000 -0500
|
|
|
|
@@ -104,9 +104,8 @@
|
|
|
|
.TP
|
|
|
|
.BI \-d \ num
|
|
|
|
.B Crash
|
|
|
|
-sets its internal debug level
|
|
|
|
-.I num
|
|
|
|
-. The higher the number, the more debugging data will be printed while
|
|
|
|
+sets its internal debug level.
|
|
|
|
+The higher the number, the more debugging data will be printed while
|
|
|
|
.B crash
|
|
|
|
runs.
|
|
|
|
.TP
|