On Fri, Oct 05, 2018 at 09:13:28AM -0400, Dave Anderson wrote:
>
>
> ----- Original Message -----
> > On Thu, Oct 04, 2018 at 05:03:25PM -0400, Dave Anderson wrote:
> > > ----- Original Message -----
> > ...
> > > Actually I was too quick to check the patch in -- it fails to build on
> > > most
> > > of the other architectures, like here on ppc64:
> > >
> > > $ make
> > > ... [ cut ] ...
> > > cc -c -g -DPPC64 -DLZO -DSNAPPY -DGDB_7_6 memory.c -Wall -O2
> > > -Wstrict-prototypes -Wmissing-prototypes -fstack-protector
> > > -Wformat-security
> > > memory.c: In function ‘pfn_to_phys’:
> > > memory.c:17315:16: error: ‘PAGE_SHIFT’ undeclared (first use in this
> > > function)
> > > return pfn << PAGE_SHIFT;
> > > ^
> > > memory.c:17315:16: note: each undeclared identifier is reported only
> > > once
> > > for each function it appears in
> > > memory.c:17316:1: warning: control reaches end of non-void function
> > > [-Wreturn-type]
> > > }
> > > ^
> > > make[4]: *** [memory.o] Error 1
> > > make[3]: *** [gdb] Error 2
> > > make[2]: *** [rebuild] Error 2
> > > make[1]: *** [gdb_merge] Error 2
> > > make: *** [warn] Error 2
> > > $
> > >
> > > It looks like PAGE_SHIFT is only #define'd for x86_64, 32-bit PPC, and
> > > SPARC64.
> > > Can you work on a architecture-neutral solution?
> >
> > Could you try the following additional fix?
> >
> > ---
> > diff --git a/memory.c b/memory.c
> > index 9657c28..ac94345 100644
> > --- a/memory.c
> > +++ b/memory.c
> > @@ -17312,7 +17312,7 @@ fill_memory_block_state(ulong memblock, char *buf)
> > static ulong
> > pfn_to_phys(ulong pfn)
> > {
> > - return pfn << PAGE_SHIFT;
> > + return pfn * sysconf(_SC_PAGESIZE);
> > }
>
> That wouldn't work, for example, when running a binary created
> with "make target=ARM64" on an x86_64 if the ARM64 kernel was
> using 64K pages. You could use PAGESHIFT() or PAGESIZE().
It is nice macro! The macro returns machdep->pageshift and
it is stored at crash initialization in all arch, right?
So, does the following make sense?
---
diff --git a/memory.c b/memory.c
index 9657c28..de93af0 100644
--- a/memory.c
+++ b/memory.c
@@ -17312,7 +17312,7 @@ fill_memory_block_state(ulong memblock, char *buf)
static ulong
pfn_to_phys(ulong pfn)
{
- return pfn << PAGE_SHIFT;
+ return pfn << PAGESHIFT();
}
static void
---
Thanks,
Masa
>
> Dave
>
> >
> > static void
> > ---
> >
> > Thanks,
> > Masa
> >
> >
> > >
> > > Thanks,
> > > Dave
> > >
> > >
> > >
> > > >
> > > > >
> > > > > Signed-off-by: Masayoshi Mizuma <m.miz...@jp.fujitsu.com>
> > > > > ---
> > > > > defs.h | 9 ++
> > > > > memory.c | 286
> > > > > +++++++++++++++++++++++++++++++++++++++++++++++++++---
> > > > > symbols.c | 18 ++++
> > > > > 3 files changed, 299 insertions(+), 14 deletions(-)
> > > > >
> > > > > diff --git a/defs.h b/defs.h
> > > > > index 5b64bb7..20dd6a7 100644
> > > > > --- a/defs.h
> > > > > +++ b/defs.h
> > > > > @@ -2049,6 +2049,15 @@ struct offset_table { /*
> > > > > stash of
> > > > > commonly-used offsets */
> > > > > long pci_bus_self;
> > > > > long device_kobj;
> > > > > long kobject_name;
> > > > > + long memory_block_dev;
> > > > > + long memory_block_start_section_nr;
> > > > > + long memory_block_end_section_nr;
> > > > > + long memory_block_state;
> > > > > + long memory_block_nid;
> > > > > + long mem_section_pageblock_flags;
> > > > > + long bus_type_p;
> > > > > + long device_private_device;
> > > > > + long device_private_knode_bus;
> > > > > };
> > > > >
> > > > > struct size_table { /* stash of commonly-used sizes */
> > > > > diff --git a/memory.c b/memory.c
> > > > > index ea25047..9657c28 100644
> > > > > --- a/memory.c
> > > > > +++ b/memory.c
> > > > > @@ -255,13 +255,14 @@ static void PG_slab_flag_init(void);
> > > > > static ulong nr_blockdev_pages(void);
> > > > > void sparse_mem_init(void);
> > > > > void dump_mem_sections(int);
> > > > > +void dump_memory_blocks(int);
> > > > > void list_mem_sections(void);
> > > > > ulong sparse_decode_mem_map(ulong, ulong);
> > > > > char *read_mem_section(ulong);
> > > > > ulong nr_to_section(ulong);
> > > > > int valid_section(ulong);
> > > > > int section_has_mem_map(ulong);
> > > > > -ulong section_mem_map_addr(ulong);
> > > > > +ulong section_mem_map_addr(ulong, int);
> > > > > ulong valid_section_nr(ulong);
> > > > > ulong pfn_to_map(ulong);
> > > > > static int get_nodes_online(void);
> > > > > @@ -5528,7 +5529,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
> > > > > pc->curcmd_flags |= HEADER_PRINTED;
> > > > > }
> > > > >
> > > > > - pp = section_mem_map_addr(section);
> > > > > + pp = section_mem_map_addr(section, 0);
> > > > > pp = sparse_decode_mem_map(pp, section_nr);
> > > > > phys = (physaddr_t) section_nr * PAGES_PER_SECTION() *
> > > > > PAGESIZE();
> > > > > section_size = PAGES_PER_SECTION();
> > > > > @@ -13389,7 +13390,7 @@ is_page_ptr(ulong addr, physaddr_t *phys)
> > > > > nr_mem_sections = vt->max_mem_section_nr+1;
> > > > > for (nr = 0; nr < nr_mem_sections ; nr++) {
> > > > > if ((sec_addr = valid_section_nr(nr))) {
> > > > > - coded_mem_map =
> > > > > section_mem_map_addr(sec_addr);
> > > > > + coded_mem_map =
> > > > > section_mem_map_addr(sec_addr,
> > > > > 0);
> > > > > mem_map =
> > > > > sparse_decode_mem_map(coded_mem_map,
> > > > > nr);
> > > > > end_mem_map = mem_map +
> > > > > (PAGES_PER_SECTION() * SIZE(page));
> > > > >
> > > > > @@ -16354,8 +16355,10 @@ dump_memory_nodes(int initialize)
> > > > > vt->numnodes = n;
> > > > > }
> > > > >
> > > > > - if (IS_SPARSEMEM())
> > > > > + if (IS_SPARSEMEM()) {
> > > > > dump_mem_sections(initialize);
> > > > > + dump_memory_blocks(initialize);
> > > > > + }
> > > > > }
> > > > >
> > > > > /*
> > > > > @@ -17140,7 +17143,7 @@ section_has_mem_map(ulong addr)
> > > > > }
> > > > >
> > > > > ulong
> > > > > -section_mem_map_addr(ulong addr)
> > > > > +section_mem_map_addr(ulong addr, int raw)
> > > > > {
> > > > > char *mem_section;
> > > > > ulong map;
> > > > > @@ -17148,7 +17151,8 @@ section_mem_map_addr(ulong addr)
> > > > > if ((mem_section = read_mem_section(addr))) {
> > > > > map = ULONG(mem_section +
> > > > > OFFSET(mem_section_section_mem_map));
> > > > > - map &= SECTION_MAP_MASK;
> > > > > + if (!raw)
> > > > > + map &= SECTION_MAP_MASK;
> > > > > return map;
> > > > > }
> > > > > return 0;
> > > > > @@ -17179,7 +17183,7 @@ pfn_to_map(ulong pfn)
> > > > >
> > > > > if (section_has_mem_map(section)) {
> > > > > page_offset = pfn - section_nr_to_pfn(section_nr);
> > > > > - coded_mem_map = section_mem_map_addr(section);
> > > > > + coded_mem_map = section_mem_map_addr(section, 0);
> > > > > mem_map = sparse_decode_mem_map(coded_mem_map,
> > > > > section_nr) +
> > > > > (page_offset * SIZE(page));
> > > > > return mem_map;
> > > > > @@ -17188,16 +17192,33 @@ pfn_to_map(ulong pfn)
> > > > > return 0;
> > > > > }
> > > > >
> > > > > +static void
> > > > > +fill_mem_section_state(ulong state, char *buf)
> > > > > +{
> > > > > + int bufidx = 0;
> > > > > +
> > > > > + memset(buf, 0, sizeof(*buf) * BUFSIZE);
> > > > > +
> > > > > + if (state & SECTION_MARKED_PRESENT)
> > > > > + bufidx += sprintf(buf + bufidx, "%s", "P");
> > > > > + if (state & SECTION_HAS_MEM_MAP)
> > > > > + bufidx += sprintf(buf + bufidx, "%s", "M");
> > > > > + if (state & SECTION_IS_ONLINE)
> > > > > + bufidx += sprintf(buf + bufidx, "%s", "O");
> > > > > +}
> > > > > +
> > > > > void
> > > > > dump_mem_sections(int initialize)
> > > > > {
> > > > > ulong nr, max, addr;
> > > > > ulong nr_mem_sections;
> > > > > ulong coded_mem_map, mem_map, pfn;
> > > > > + char statebuf[BUFSIZE];
> > > > > char buf1[BUFSIZE];
> > > > > char buf2[BUFSIZE];
> > > > > char buf3[BUFSIZE];
> > > > > char buf4[BUFSIZE];
> > > > > + char buf5[BUFSIZE];
> > > > >
> > > > > nr_mem_sections = NR_MEM_SECTIONS();
> > > > >
> > > > > @@ -17212,19 +17233,23 @@ dump_mem_sections(int initialize)
> > > > >
> > > > > fprintf(fp, "\n");
> > > > > pad_line(fp, BITS32() ? 59 : 67, '-');
> > > > > - fprintf(fp, "\n\nNR %s %s %s PFN\n",
> > > > > + fprintf(fp, "\n\nNR %s %s %s %s PFN\n",
> > > > > mkstring(buf1, VADDR_PRLEN, CENTER|LJUST, "SECTION"),
> > > > > mkstring(buf2,
> > > > > MAX(VADDR_PRLEN,strlen("CODED_MEM_MAP")),
> > > > > CENTER|LJUST, "CODED_MEM_MAP"),
> > > > > - mkstring(buf3, VADDR_PRLEN, CENTER|LJUST,
> > > > > "MEM_MAP"));
> > > > > + mkstring(buf3, VADDR_PRLEN, CENTER|LJUST, "MEM_MAP"),
> > > > > + mkstring(buf4, strlen("STATE"), CENTER, "STATE"));
> > > > >
> > > > > for (nr = 0; nr < nr_mem_sections ; nr++) {
> > > > > if ((addr = valid_section_nr(nr))) {
> > > > > - coded_mem_map = section_mem_map_addr(addr);
> > > > > + coded_mem_map = section_mem_map_addr(addr, 0);
> > > > > mem_map =
> > > > > sparse_decode_mem_map(coded_mem_map,nr);
> > > > > pfn = section_nr_to_pfn(nr);
> > > > > +
> > > > > fill_mem_section_state(section_mem_map_addr(addr, 1),
> > > > > + statebuf);
> > > > >
> > > > > - fprintf(fp, "%2ld %s %s %s %s\n",
> > > > > +
> > > > > + fprintf(fp, "%2ld %s %s %s %s %s\n",
> > > > > nr,
> > > > > mkstring(buf1, VADDR_PRLEN,
> > > > > CENTER|LONG_HEX, MKSTR(addr)),
> > > > > @@ -17233,15 +17258,248 @@ dump_mem_sections(int initialize)
> > > > > CENTER|LONG_HEX|RJUST,
> > > > > MKSTR(coded_mem_map)),
> > > > > mkstring(buf3, VADDR_PRLEN,
> > > > > CENTER|LONG_HEX|RJUST, MKSTR(mem_map)),
> > > > > + mkstring(buf4, strlen("STATE"), CENTER,
> > > > > statebuf),
> > > > > pc->output_radix == 10 ?
> > > > > - mkstring(buf4, VADDR_PRLEN,
> > > > > + mkstring(buf5, VADDR_PRLEN,
> > > > > LONG_DEC|LJUST, MKSTR(pfn)) :
> > > > > - mkstring(buf4, VADDR_PRLEN,
> > > > > + mkstring(buf5, VADDR_PRLEN,
> > > > > LONG_HEX|LJUST, MKSTR(pfn)));
> > > > > }
> > > > > }
> > > > > }
> > > > >
> > > > > +#define MEM_ONLINE (1<<0)
> > > > > +#define MEM_GOING_OFFLINE (1<<1)
> > > > > +#define MEM_OFFLINE (1<<2)
> > > > > +#define MEM_GOING_ONLINE (1<<3)
> > > > > +#define MEM_CANCEL_ONLINE (1<<4)
> > > > > +#define MEM_CANCEL_OFFLINE (1<<5)
> > > > > +
> > > > > +static void
> > > > > +fill_memory_block_state(ulong memblock, char *buf)
> > > > > +{
> > > > > + ulong state;
> > > > > +
> > > > > + memset(buf, 0, sizeof(*buf) * BUFSIZE);
> > > > > +
> > > > > + readmem(memblock + OFFSET(memory_block_state), KVADDR, &state,
> > > > > + sizeof(void *), "memory_block state", FAULT_ON_ERROR);
> > > > > +
> > > > > + switch (state) {
> > > > > + case MEM_ONLINE:
> > > > > + sprintf(buf, "%s", "ONLINE");
> > > > > + break;
> > > > > + case MEM_GOING_OFFLINE:
> > > > > + sprintf(buf, "%s", "GOING_OFFLINE");
> > > > > + break;
> > > > > + case MEM_OFFLINE:
> > > > > + sprintf(buf, "%s", "OFFLINE");
> > > > > + break;
> > > > > + case MEM_GOING_ONLINE:
> > > > > + sprintf(buf, "%s", "GOING_ONLINE");
> > > > > + break;
> > > > > + case MEM_CANCEL_ONLINE:
> > > > > + sprintf(buf, "%s", "CANCEL_ONLINE");
> > > > > + break;
> > > > > + case MEM_CANCEL_OFFLINE:
> > > > > + sprintf(buf, "%s", "CANCEL_OFFLINE");
> > > > > + break;
> > > > > + default:
> > > > > + sprintf(buf, "%s", "UNKNOWN");
> > > > > + }
> > > > > +}
> > > > > +
> > > > > +static ulong
> > > > > +pfn_to_phys(ulong pfn)
> > > > > +{
> > > > > + return pfn << PAGE_SHIFT;
> > > > > +}
> > > > > +
> > > > > +static void
> > > > > +fill_memory_block_name(ulong memblock, char *name)
> > > > > +{
> > > > > + ulong kobj, value;
> > > > > +
> > > > > + memset(name, 0, sizeof(*name) * BUFSIZE);
> > > > > +
> > > > > + kobj = memblock + OFFSET(memory_block_dev) +
> > > > > OFFSET(device_kobj);
> > > > > +
> > > > > + readmem(kobj + OFFSET(kobject_name),
> > > > > + KVADDR, &value, sizeof(void *), "kobject name",
> > > > > + FAULT_ON_ERROR);
> > > > > +
> > > > > + read_string(value, name, BUFSIZE-1);
> > > > > +}
> > > > > +
> > > > > +static void
> > > > > +fill_memory_block_srange(ulong start_sec, ulong end_sec, char
> > > > > *srange)
> > > > > +{
> > > > > + memset(srange, 0, sizeof(*srange) * BUFSIZE);
> > > > > +
> > > > > + if (start_sec == end_sec)
> > > > > + sprintf(srange, "%lu", start_sec);
> > > > > + else
> > > > > + sprintf(srange, "%lu-%lu", start_sec, end_sec);
> > > > > +}
> > > > > +
> > > > > +static void
> > > > > +print_memory_block(ulong memory_block)
> > > > > +{
> > > > > + ulong start_sec, end_sec, start_pfn, end_pfn, nid;
> > > > > + char statebuf[BUFSIZE];
> > > > > + char srangebuf[BUFSIZE];
> > > > > + char name[BUFSIZE];
> > > > > + char buf1[BUFSIZE];
> > > > > + char buf2[BUFSIZE];
> > > > > + char buf3[BUFSIZE];
> > > > > + char buf4[BUFSIZE];
> > > > > + char buf5[BUFSIZE];
> > > > > + char buf6[BUFSIZE];
> > > > > + char buf7[BUFSIZE];
> > > > > +
> > > > > + readmem(memory_block + OFFSET(memory_block_start_section_nr),
> > > > > KVADDR,
> > > > > + &start_sec, sizeof(void *), "memory_block
> > > > > start_section_nr",
> > > > > + FAULT_ON_ERROR);
> > > > > + readmem(memory_block + OFFSET(memory_block_end_section_nr),
> > > > > KVADDR,
> > > > > + &end_sec, sizeof(void *), "memory_block end_section_nr",
> > > > > + FAULT_ON_ERROR);
> > > > > +
> > > > > + start_pfn = section_nr_to_pfn(start_sec);
> > > > > + end_pfn = section_nr_to_pfn(end_sec + 1);
> > > > > + fill_memory_block_state(memory_block, statebuf);
> > > > > + fill_memory_block_name(memory_block, name);
> > > > > + fill_memory_block_srange(start_sec, end_sec, srangebuf);
> > > > > +
> > > > > + if (MEMBER_EXISTS("memory_block", "nid")) {
> > > > > + readmem(memory_block + OFFSET(memory_block_nid),
> > > > > KVADDR, &nid,
> > > > > + sizeof(void *), "memory_block nid",
> > > > > FAULT_ON_ERROR);
> > > > > + fprintf(fp, " %s %s %s - %s %s %s %s\n",
> > > > > + mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX,
> > > > > + MKSTR(memory_block)),
> > > > > + mkstring(buf2, 12, CENTER, name),
> > > > > + mkstring(buf3, PADDR_PRLEN, RJUST|LONG_HEX,
> > > > > + MKSTR(pfn_to_phys(start_pfn))),
> > > > > + mkstring(buf4, PADDR_PRLEN, LJUST|LONG_HEX,
> > > > > + MKSTR(pfn_to_phys(end_pfn) - 1)),
> > > > > + mkstring(buf5, strlen("NODE"), CENTER|LONG_DEC,
> > > > > + MKSTR(nid)),
> > > > > + mkstring(buf6, strlen("CANCEL_OFFLINE"), LJUST,
> > > > > + statebuf),
> > > > > + mkstring(buf7, 12, LJUST, srangebuf));
> > > > > + } else
> > > > > + fprintf(fp, " %s %s %s - %s %s %s\n",
> > > > > + mkstring(buf1, VADDR_PRLEN, LJUST|LONG_HEX,
> > > > > + MKSTR(memory_block)),
> > > > > + mkstring(buf2, 10, CENTER, name),
> > > > > + mkstring(buf3, PADDR_PRLEN, RJUST|LONG_HEX,
> > > > > + MKSTR(pfn_to_phys(start_pfn))),
> > > > > + mkstring(buf4, PADDR_PRLEN, LJUST|LONG_HEX,
> > > > > + MKSTR(pfn_to_phys(end_pfn) - 1)),
> > > > > + mkstring(buf5, strlen("CANCEL_OFFLINE"), LJUST,
> > > > > + statebuf),
> > > > > + mkstring(buf6, 12, LJUST, srangebuf));
> > > > > +}
> > > > > +
> > > > > +static void
> > > > > +init_memory_block_offset(void)
> > > > > +{
> > > > > + MEMBER_OFFSET_INIT(bus_type_p, "bus_type", "p");
> > > > > + MEMBER_OFFSET_INIT(subsys_private_klist_devices,
> > > > > + "subsys_private", "klist_devices");
> > > > > + MEMBER_OFFSET_INIT(klist_k_list, "klist", "k_list");
> > > > > + MEMBER_OFFSET_INIT(klist_node_n_node, "klist_node", "n_node");
> > > > > + MEMBER_OFFSET_INIT(device_private_knode_bus,
> > > > > + "device_private", "knode_bus");
> > > > > + MEMBER_OFFSET_INIT(device_private_device, "device_private",
> > > > > "device");
> > > > > + MEMBER_OFFSET_INIT(memory_block_dev, "memory_block", "dev");
> > > > > + MEMBER_OFFSET_INIT(memory_block_start_section_nr,
> > > > > + "memory_block", "start_section_nr");
> > > > > + MEMBER_OFFSET_INIT(memory_block_end_section_nr,
> > > > > + "memory_block", "end_section_nr");
> > > > > + MEMBER_OFFSET_INIT(memory_block_state, "memory_block", "state");
> > > > > + if (MEMBER_EXISTS("memory_block", "nid"))
> > > > > + MEMBER_OFFSET_INIT(memory_block_nid, "memory_block",
> > > > > "nid");
> > > > > +}
> > > > > +
> > > > > +static void
> > > > > +init_memory_block(struct list_data *ld, int *klistcnt, ulong
> > > > > **klistbuf)
> > > > > +{
> > > > > + ulong memory_subsys = symbol_value("memory_subsys");
> > > > > + ulong private, klist, start;
> > > > > +
> > > > > + init_memory_block_offset();
> > > > > +
> > > > > + readmem(memory_subsys + OFFSET(bus_type_p), KVADDR, &private,
> > > > > + sizeof(void *), "memory_subsys.private",
> > > > > FAULT_ON_ERROR);
> > > > > + klist = private + OFFSET(subsys_private_klist_devices) +
> > > > > + OFFSET(klist_k_list);
> > > > > + BZERO(ld, sizeof(struct list_data));
> > > > > +
> > > > > + readmem(klist, KVADDR, &start,
> > > > > + sizeof(void *), "klist klist", FAULT_ON_ERROR);
> > > > > +
> > > > > + ld->start = start;
> > > > > + ld->end = klist;
> > > > > + ld->list_head_offset = OFFSET(klist_node_n_node) +
> > > > > +
> > > > > OFFSET(device_private_knode_bus);
> > > > > + hq_open();
> > > > > + *klistcnt = do_list(ld);
> > > > > + *klistbuf = (ulong *)GETBUF(*klistcnt * sizeof(ulong));
> > > > > + *klistcnt = retrieve_list(*klistbuf, *klistcnt);
> > > > > + hq_close();
> > > > > +}
> > > > > +
> > > > > +void
> > > > > +dump_memory_blocks(int initialize)
> > > > > +{
> > > > > + ulong memory_block, device;
> > > > > + ulong *klistbuf;
> > > > > + int klistcnt, i;
> > > > > + struct list_data list_data;
> > > > > + char mb_hdr[BUFSIZE];
> > > > > + char buf1[BUFSIZE];
> > > > > + char buf2[BUFSIZE];
> > > > > + char buf3[BUFSIZE];
> > > > > + char buf4[BUFSIZE];
> > > > > + char buf5[BUFSIZE];
> > > > > + char buf6[BUFSIZE];
> > > > > +
> > > > > + if ((!STRUCT_EXISTS("memory_block")) ||
> > > > > + (!symbol_exists("memory_subsys")))
> > > > > + return;
> > > > > +
> > > > > + if (initialize)
> > > > > + return;
> > > > > +
> > > > > + init_memory_block(&list_data, &klistcnt, &klistbuf);
> > > > > +
> > > > > + if (MEMBER_EXISTS("memory_block", "nid"))
> > > > > + sprintf(mb_hdr, "\n%s %s %s %s %s %s\n",
> > > > > + mkstring(buf1, VADDR_PRLEN, CENTER|LJUST,
> > > > > "MEM_BLOCK"),
> > > > > + mkstring(buf2, 10, CENTER, "NAME"),
> > > > > + mkstring(buf3, PADDR_PRLEN*2 + 2, CENTER,
> > > > > "PHYSICAL RANGE"),
> > > > > + mkstring(buf4, strlen("NODE"), CENTER, "NODE"),
> > > > > + mkstring(buf5, strlen("CANCEL_OFFLINE"), LJUST,
> > > > > "STATE"),
> > > > > + mkstring(buf6, 12, LJUST, "SECTIONS"));
> > > > > + else
> > > > > + sprintf(mb_hdr, "\n%s %s %s %s %s\n",
> > > > > + mkstring(buf1, VADDR_PRLEN, CENTER|LJUST,
> > > > > "MEM_BLOCK"),
> > > > > + mkstring(buf2, 10, CENTER, "NAME"),
> > > > > + mkstring(buf3, PADDR_PRLEN*2, CENTER, "PHYSICAL
> > > > > RANGE"),
> > > > > + mkstring(buf4, strlen("CANCEL_OFFLINE"), LJUST,
> > > > > "STATE"),
> > > > > + mkstring(buf5, 12, LJUST, "SECTIONS"));
> > > > > + fprintf(fp, "%s", mb_hdr);
> > > > > +
> > > > > + for (i = 0; i < klistcnt; i++) {
> > > > > + readmem(klistbuf[i] + OFFSET(device_private_device),
> > > > > KVADDR,
> > > > > + &device, sizeof(void *), "device_private
> > > > > device",
> > > > > + FAULT_ON_ERROR);
> > > > > + memory_block = device - OFFSET(memory_block_dev);
> > > > > + print_memory_block(memory_block);
> > > > > + }
> > > > > + FREEBUF(klistbuf);
> > > > > +}
> > > > > +
> > > > > void
> > > > > list_mem_sections(void)
> > > > > {
> > > > > @@ -17251,7 +17509,7 @@ list_mem_sections(void)
> > > > >
> > > > > for (nr = 0; nr <= nr_mem_sections ; nr++) {
> > > > > if ((addr = valid_section_nr(nr))) {
> > > > > - coded_mem_map = section_mem_map_addr(addr);
> > > > > + coded_mem_map = section_mem_map_addr(addr, 0);
> > > > > fprintf(fp,
> > > > > "nr=%ld section = %lx coded_mem_map=%lx
> > > > > pfn=%ld mem_map=%lx\n",
> > > > > nr,
> > > > > diff --git a/symbols.c b/symbols.c
> > > > > index cb2174b..c5aab14 100644
> > > > > --- a/symbols.c
> > > > > +++ b/symbols.c
> > > > > @@ -9938,6 +9938,18 @@ dump_offset_table(char *spec, ulong makestruct)
> > > > > OFFSET(tss_struct_ist));
> > > > > fprintf(fp, " mem_section_section_mem_map: %ld\n",
> > > > > OFFSET(mem_section_section_mem_map));
> > > > > + fprintf(fp, " mem_section_pageblock_flags: %ld\n",
> > > > > + OFFSET(mem_section_pageblock_flags));
> > > > > + fprintf(fp, " memory_block_dev: %ld\n",
> > > > > + OFFSET(memory_block_dev));
> > > > > + fprintf(fp, " memory_block_nid: %ld\n",
> > > > > + OFFSET(memory_block_nid));
> > > > > + fprintf(fp, " memory_block_start_section_nr: %ld\n",
> > > > > + OFFSET(memory_block_start_section_nr));
> > > > > + fprintf(fp, " memory_block_end_section_nr: %ld\n",
> > > > > + OFFSET(memory_block_end_section_nr));
> > > > > + fprintf(fp, " memory_block_state: %ld\n",
> > > > > + OFFSET(memory_block_state));
> > > > >
> > > > > fprintf(fp, " vcpu_guest_context_user_regs: %ld\n",
> > > > > OFFSET(vcpu_guest_context_user_regs));
> > > > > @@ -10031,6 +10043,8 @@ dump_offset_table(char *spec, ulong
> > > > > makestruct)
> > > > > OFFSET(unwind_idx_addr));
> > > > > fprintf(fp, " unwind_idx_insn: %ld\n",
> > > > > OFFSET(unwind_idx_insn));
> > > > > + fprintf(fp, " bus_type_p: %ld\n",
> > > > > + OFFSET(bus_type_p));
> > > > > fprintf(fp, " class_devices: %ld\n",
> > > > > OFFSET(class_devices));
> > > > > fprintf(fp, " class_p: %ld\n",
> > > > > @@ -10041,6 +10055,10 @@ dump_offset_table(char *spec, ulong
> > > > > makestruct)
> > > > > OFFSET(device_knode_class));
> > > > > fprintf(fp, " device_node: %ld\n",
> > > > > OFFSET(device_node));
> > > > > + fprintf(fp, " device_private_device: %ld\n",
> > > > > + OFFSET(device_private_device));
> > > > > + fprintf(fp, " device_private_knode_bus: %ld\n",
> > > > > + OFFSET(device_private_knode_bus));
> > > > > fprintf(fp, " gendisk_dev: %ld\n",
> > > > > OFFSET(gendisk_dev));
> > > > > fprintf(fp, " gendisk_kobj: %ld\n",
> > > > > --
> > > > > 2.19.0
> > > > >
> > > > > --
> > > > > Crash-utility mailing list
> > > > > Crash-utility@redhat.com
> > > > > https://www.redhat.com/mailman/listinfo/crash-utility
> > > > >
> > > >
> > > > --
> > > > Crash-utility mailing list
> > > > Crash-utility@redhat.com
> > > > https://www.redhat.com/mailman/listinfo/crash-utility
> > > >
> > >
> > > --
> > > Crash-utility mailing list
> > > Crash-utility@redhat.com
> > > https://www.redhat.com/mailman/listinfo/crash-utility
> >
--
Crash-utility mailing list
Crash-utility@redhat.com
https://www.redhat.com/mailman/listinfo/crash-utility
