[Crash-utility] [RFC] [PATCH 4/6] Maple tree kernel code modification for step 2

This patch will remove all kernel structures, and leave them to be blank for debug purpose. There seems to be a lot of code changes, but most are rewriting struct member resolving into crash way. Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- defs.h | 20 +++++- maple_tree.c | 183 ++++++++++++++++++++++++++++++++------------------- maple_tree.h | 92 ++++++-------------------- memory.c | 4 ++ 4 files changed, 159 insertions(+), 140 deletions(-) diff --git a/defs.h b/defs.h index d4be477..8ea710f 100644 --- a/defs.h +++ b/defs.h @@ -1332,7 +1332,6 @@ struct offset_table { /* stash of commonly-used offsets */ long percpu_struct_halt_ra; long percpu_struct_halt_pv; long mm_struct_mmap; - long mm_struct_mm_mt; long mm_struct_pgd; long mm_struct_rss; long mm_struct_anon_rss; @@ -2182,6 +2181,23 @@ struct offset_table { /* stash of commonly-used offsets */ long blk_mq_tags_nr_reserved_tags; long blk_mq_tags_rqs; long request_queue_hctx_table; + + long mm_struct_mm_mt; + long maple_tree_ma_root; + long maple_tree_ma_flags; + long maple_node_parent; + long maple_node_ma64; + long maple_node_mr64; + long maple_node_slot; + long maple_arange_64_parent; + long maple_arange_64_pivot; + long maple_arange_64_slot; + long maple_arange_64_meta; + long maple_range_64_parent; + long maple_range_64_pivot; + long maple_range_64_slot; + long maple_range_64_meta; + long maple_metadata_end; }; struct size_table { /* stash of commonly-used sizes */ @@ -2352,6 +2368,8 @@ struct size_table { /* stash of commonly-used sizes */ long sbitmap_queue; long sbq_wait_state; long blk_mq_tags; + long maple_tree_struct; + long maple_node_struct; }; struct array_table { diff --git a/maple_tree.c b/maple_tree.c index 21a2226..ff07d58 100644 --- a/maple_tree.c +++ b/maple_tree.c @@ -78,10 +78,11 @@ static inline enum maple_type mte_node_type(const struct maple_enode *entry) static inline void *mas_root(struct ma_state *mas) { - struct maple_tree tree; - readmem(mas->tree, KVADDR, &tree, sizeof(tree), + char tree[SIZE(maple_tree_struct)]; + + readmem((ulonglong)(mas->tree), KVADDR, tree, SIZE(maple_tree_struct), "mas_root read maple_tree", FAULT_ON_ERROR); - return tree.ma_root; + return *(void **)(tree + OFFSET(maple_tree_ma_root)); } static inline struct maple_enode *mas_start(struct ma_state *mas) @@ -127,10 +128,12 @@ static inline unsigned long *ma_pivots(struct maple_node *node, { switch (type) { case maple_arange_64: - return node->ma64.pivot; + return (unsigned long *)((char *)node + OFFSET(maple_node_ma64) + + OFFSET(maple_arange_64_pivot)); case maple_range_64: case maple_leaf_64: - return node->mr64.pivot; + return (unsigned long *)((char *)node + OFFSET(maple_node_mr64) + + OFFSET(maple_range_64_pivot)); case maple_dense: return NULL; } @@ -142,9 +145,13 @@ static inline struct maple_metadata *ma_meta(struct maple_node *mn, { switch (mt) { case maple_arange_64: - return &mn->ma64.meta; + return (struct maple_metadata *)( + (char *)mn + OFFSET(maple_node_ma64) + + OFFSET(maple_arange_64_meta)); default: - return &mn->mr64.meta; + return (struct maple_metadata *)( + (char *)mn + OFFSET(maple_node_mr64) + + OFFSET(maple_range_64_meta)); } } @@ -153,7 +160,7 @@ static inline unsigned char ma_meta_end(struct maple_node *mn, { struct maple_metadata *meta = ma_meta(mn, mt); - return meta->end; + return *((char *)meta + OFFSET(maple_metadata_end)); } static inline unsigned char ma_data_end(struct maple_node *node, @@ -179,9 +186,10 @@ static inline unsigned char ma_data_end(struct maple_node *node, static inline bool ma_dead_node(const struct maple_node *node, const struct maple_node *orig_node) { - struct maple_node *parent = (void *)((unsigned long) - node->parent & ~MAPLE_NODE_MASK); - + struct maple_node *parent = (struct maple_node *) + (*(unsigned long *)((char *)node + + OFFSET(maple_node_parent)) + & ~MAPLE_NODE_MASK); return (parent == orig_node); } @@ -190,12 +198,14 @@ static inline void **ma_slots(struct maple_node *mn, enum maple_type mt) switch (mt) { default: case maple_arange_64: - return mn->ma64.slot; + return (void **)((char *)mn + OFFSET(maple_node_ma64) + + OFFSET(maple_arange_64_slot)); case maple_range_64: case maple_leaf_64: - return mn->mr64.slot; + return (void **)((char *)mn + OFFSET(maple_node_mr64) + + OFFSET(maple_range_64_slot)); case maple_dense: - return mn->slot; + return (void **)((char *)mn + OFFSET(maple_node_slot)); } } @@ -222,7 +232,7 @@ static inline void *mtree_range_walk(struct ma_state *mas) unsigned long max, min; unsigned long prev_max, prev_min; - struct maple_node tmp_node; + char tmp_node[SIZE(maple_node_struct)]; last = next = mas->node; prev_min = min = mas->min; @@ -232,11 +242,11 @@ static inline void *mtree_range_walk(struct ma_state *mas) last = next; node = mte_to_node(next); type = mte_node_type(next); - readmem(node, KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)node, KVADDR, tmp_node, SIZE(maple_node_struct), "mtree_range_walk read maple_node", FAULT_ON_ERROR); - pivots = ma_pivots(&tmp_node, type); - end = ma_data_end(&tmp_node, type, pivots, max); - if (ma_dead_node(&tmp_node, node)) + pivots = ma_pivots((struct maple_node *)tmp_node, type); + end = ma_data_end((struct maple_node *)tmp_node, type, pivots, max); + if (ma_dead_node((struct maple_node *)tmp_node, node)) goto dead_node; if (pivots[offset] >= mas->index) { @@ -257,9 +267,9 @@ static inline void *mtree_range_walk(struct ma_state *mas) max = pivots[offset]; next: - slots = ma_slots(&tmp_node, type); + slots = ma_slots((struct maple_node *)tmp_node, type); next = mt_slot(mas->tree, slots, offset); - if (ma_dead_node(&tmp_node, node)) + if (ma_dead_node((struct maple_node *)tmp_node, node)) goto dead_node; } while (!ma_is_leaf(type)); @@ -410,13 +420,16 @@ retry: static inline bool ma_is_root(struct maple_node *node) { - return ((unsigned long)node->parent & MA_ROOT_PARENT); + return (*(unsigned long *)((char *)node + + OFFSET(maple_node_parent)) + & MA_ROOT_PARENT); } static inline struct maple_node *mte_parent(const struct maple_node *node) { - return (void *)((unsigned long) - (node->parent) & ~MAPLE_NODE_MASK); + return (void *)(*(unsigned long *)((char *)node + + OFFSET(maple_node_parent)) + & ~MAPLE_NODE_MASK); } static inline unsigned long mte_parent_slot_mask(unsigned long parent) @@ -430,7 +443,9 @@ static inline unsigned long mte_parent_slot_mask(unsigned long parent) static inline bool mt_is_alloc(struct maple_tree *mt) { - return (mt->ma_flags & MT_FLAGS_ALLOC_RANGE); + return (*(unsigned int *)((char *)mt + + OFFSET(maple_tree_ma_flags)) + & MT_FLAGS_ALLOC_RANGE); } static inline @@ -438,7 +453,7 @@ enum maple_type mte_parent_enum(struct maple_enode *p_enode, struct maple_tree *mt) { unsigned long p_type; - struct maple_tree tmp_tree; + char tmp_tree[SIZE(maple_tree_struct)]; p_type = (unsigned long)p_enode; if (p_type & MAPLE_PARENT_ROOT) @@ -449,9 +464,9 @@ enum maple_type mte_parent_enum(struct maple_enode *p_enode, switch (p_type) { case MAPLE_PARENT_RANGE64: /* or MAPLE_PARENT_ARANGE64 */ - readmem(mt, KVADDR, &tmp_tree, sizeof(tmp_tree), + readmem((ulonglong)mt, KVADDR, tmp_tree, SIZE(maple_tree_struct), "mte_parent_enum read maple_tree", FAULT_ON_ERROR); - if (mt_is_alloc(&tmp_tree)) + if (mt_is_alloc((struct maple_tree *)tmp_tree)) return maple_arange_64; return maple_range_64; } @@ -462,7 +477,9 @@ enum maple_type mte_parent_enum(struct maple_enode *p_enode, static inline enum maple_type mas_parent_enum(struct ma_state *mas, struct maple_node *node) { - return mte_parent_enum(ma_enode_ptr(node->parent), mas->tree); + return mte_parent_enum(ma_enode_ptr(*(struct maple_pnode **) + ((char *)node + OFFSET(maple_node_parent))), + mas->tree); } static inline unsigned long mte_parent_shift(unsigned long parent) @@ -476,7 +493,8 @@ static inline unsigned long mte_parent_shift(unsigned long parent) static inline unsigned int mte_parent_slot(const struct maple_node *node) { - unsigned long val = (unsigned long) node->parent; + unsigned long val = *(unsigned long *)((char *)node + + OFFSET(maple_node_parent)); /* Root. */ if (val & 1) @@ -513,35 +531,36 @@ static int mas_ascend(struct ma_state *mas) unsigned long *pivots; unsigned char offset; bool set_max = false, set_min = false; - struct maple_node tmp_node; + + char tmp_node[SIZE(maple_node_struct)]; a_node = mas_mn(mas); - readmem(a_node, KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)a_node, KVADDR, tmp_node, SIZE(maple_node_struct), "mas_ascend read maple_node", FAULT_ON_ERROR); - if (ma_is_root(&tmp_node)) { + if (ma_is_root((struct maple_node *)tmp_node)) { mas->offset = 0; return 0; } - readmem(mte_to_node(mas->node), KVADDR, &tmp_node, sizeof(tmp_node), - "mas_ascend read maple_node", FAULT_ON_ERROR); - p_node = mte_parent(&tmp_node); + readmem((ulonglong)(mte_to_node(mas->node)), KVADDR, tmp_node, + SIZE(maple_node_struct), "mas_ascend read maple_node", FAULT_ON_ERROR); + p_node = mte_parent((struct maple_node *)tmp_node); if (a_node == p_node) return 1; - a_type = mas_parent_enum(mas, &tmp_node); - offset = mte_parent_slot(&tmp_node); + a_type = mas_parent_enum(mas, (struct maple_node *)tmp_node); + offset = mte_parent_slot((struct maple_node *)tmp_node); a_enode = mt_mk_node(p_node, a_type); /* Check to make sure all parent information is still accurate */ - if (p_node != mte_parent(&tmp_node)) + if (p_node != mte_parent((struct maple_node *)tmp_node)) return 1; mas->node = a_enode; mas->offset = offset; - readmem(mte_to_node(a_enode), KVADDR, &tmp_node, sizeof(tmp_node), - "mas_ascend read maple_node", FAULT_ON_ERROR); - if (mte_is_root(&tmp_node)) { + readmem((ulonglong)(mte_to_node(a_enode)), KVADDR, tmp_node, + SIZE(maple_node_struct), "mas_ascend read maple_node", FAULT_ON_ERROR); + if (mte_is_root((struct maple_node *)tmp_node)) { mas->max = ULONG_MAX; mas->min = 0; return 0; @@ -551,15 +570,16 @@ static int mas_ascend(struct ma_state *mas) max = ULONG_MAX; do { p_enode = a_enode; - readmem(mte_to_node(p_enode), KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)(mte_to_node(p_enode)), KVADDR, tmp_node, + SIZE(maple_node_struct), "mas_ascend read maple_node", FAULT_ON_ERROR); - a_type = mas_parent_enum(mas, &tmp_node); - a_node = mte_parent(&tmp_node); - a_slot = mte_parent_slot(&tmp_node); - readmem(a_node, KVADDR, &tmp_node, sizeof(tmp_node), + a_type = mas_parent_enum(mas, (struct maple_node *)tmp_node); + a_node = mte_parent((struct maple_node *)tmp_node); + a_slot = mte_parent_slot((struct maple_node *)tmp_node); + readmem((ulonglong)a_node, KVADDR, tmp_node, SIZE(maple_node_struct), "mas_ascend read maple_node", FAULT_ON_ERROR); - pivots = ma_pivots(&tmp_node, a_type); - a_enode = mt_mk_node(&tmp_node, a_type); + pivots = ma_pivots((struct maple_node *)tmp_node, a_type); + a_enode = mt_mk_node((struct maple_node *)tmp_node, a_type); if (!set_min && a_slot) { set_min = true; @@ -571,10 +591,10 @@ static int mas_ascend(struct ma_state *mas) max = pivots[a_slot]; } - if (ma_dead_node(&tmp_node, a_node)) + if (ma_dead_node((struct maple_node *)tmp_node, a_node)) return 1; - if (ma_is_root(&tmp_node)) + if (ma_is_root((struct maple_node *)tmp_node)) break; } while (!set_min || !set_max); @@ -595,16 +615,16 @@ static inline int mas_next_node(struct ma_state *mas, struct maple_node *node, enum maple_type mt; void **slots; - struct maple_node tmp_node; + char tmp_node[SIZE(maple_node_struct)]; if (mas->max >= max) goto no_entry; level = 0; - readmem(node, KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)node, KVADDR, tmp_node, SIZE(maple_node_struct), "mas_next_node read maple_node", FAULT_ON_ERROR); do { - if (ma_is_root(&tmp_node)) + if (ma_is_root((struct maple_node *)tmp_node)) goto no_entry; min = mas->max + 1; @@ -618,33 +638,33 @@ static inline int mas_next_node(struct ma_state *mas, struct maple_node *node, level++; node = mas_mn(mas); mt = mte_node_type(mas->node); - readmem(node, KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)node, KVADDR, tmp_node, SIZE(maple_node_struct), "mas_next_node read maple_node", FAULT_ON_ERROR); - pivots = ma_pivots(&tmp_node, mt); - } while (offset == ma_data_end(&tmp_node, mt, pivots, mas->max)); + pivots = ma_pivots((struct maple_node *)tmp_node, mt); + } while (offset == ma_data_end((struct maple_node *)tmp_node, mt, pivots, mas->max)); - slots = ma_slots(&tmp_node, mt); + slots = ma_slots((struct maple_node *)tmp_node, mt); pivot = mas_safe_pivot(mas, pivots, ++offset, mt); while (level > 1) { /* Descend, if necessary */ enode = mas_slot(mas, slots, offset); - if (ma_dead_node(&tmp_node, node)) + if (ma_dead_node((struct maple_node *)tmp_node, node)) return 1; mas->node = enode; level--; node = mas_mn(mas); mt = mte_node_type(mas->node); - readmem(node, KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)node, KVADDR, tmp_node, SIZE(maple_node_struct), "mas_next_node read maple_node", FAULT_ON_ERROR); - slots = ma_slots(&tmp_node, mt); - pivots = ma_pivots(&tmp_node, mt); + slots = ma_slots((struct maple_node *)tmp_node, mt); + pivots = ma_pivots((struct maple_node *)tmp_node, mt); offset = 0; pivot = pivots[0]; } enode = mas_slot(mas, slots, offset); - if (ma_dead_node(&tmp_node, node)) + if (ma_dead_node((struct maple_node *)tmp_node, node)) return 1; mas->node = enode; @@ -653,7 +673,7 @@ static inline int mas_next_node(struct ma_state *mas, struct maple_node *node, return 0; no_entry: - if (ma_dead_node(&tmp_node, node)) + if (ma_dead_node((struct maple_node *)tmp_node, node)) return 1; mas->node = MAS_NONE; @@ -669,7 +689,7 @@ static inline void *mas_next_entry(struct ma_state *mas, unsigned long limit) unsigned long last; enum maple_type mt; - struct maple_node tmp_node; + char tmp_node[SIZE(maple_node_struct)]; last = mas->last; retry: @@ -684,10 +704,10 @@ retry: } while (!mas_is_none(mas)) { - readmem(node, KVADDR, &tmp_node, sizeof(tmp_node), + readmem((ulonglong)node, KVADDR, tmp_node, SIZE(maple_node_struct), "mas_next_entry read maple_node", FAULT_ON_ERROR); - entry = mas_next_nentry(mas, &tmp_node, limit, mt, node); - if (ma_dead_node(&tmp_node, node)) { + entry = mas_next_nentry(mas, (struct maple_node *)tmp_node, limit, mt, node); + if (ma_dead_node((struct maple_node *)tmp_node, node)) { mas_rewalk(mas, last); goto retry; } @@ -771,4 +791,31 @@ void *mas_find(struct ma_state *mas, unsigned long max) /* Retries on dead nodes handled by mas_next_entry */ return mas_next_entry(mas, max); +} + +/***********************************************/ +void maple_init(void) +{ + STRUCT_SIZE_INIT(maple_tree_struct, "maple_tree"); + STRUCT_SIZE_INIT(maple_node_struct, "maple_node"); + + MEMBER_OFFSET_INIT(maple_tree_ma_root, "maple_tree", "ma_root"); + MEMBER_OFFSET_INIT(maple_tree_ma_flags, "maple_tree", "ma_flags"); + + MEMBER_OFFSET_INIT(maple_node_parent, "maple_node", "parent"); + MEMBER_OFFSET_INIT(maple_node_ma64, "maple_node", "ma64"); + MEMBER_OFFSET_INIT(maple_node_mr64, "maple_node", "mr64"); + MEMBER_OFFSET_INIT(maple_node_slot, "maple_node", "slot"); + + MEMBER_OFFSET_INIT(maple_arange_64_parent, "maple_arange_64", "parent"); + MEMBER_OFFSET_INIT(maple_arange_64_pivot, "maple_arange_64", "pivot"); + MEMBER_OFFSET_INIT(maple_arange_64_slot, "maple_arange_64", "slot"); + MEMBER_OFFSET_INIT(maple_arange_64_meta, "maple_arange_64", "meta"); + + MEMBER_OFFSET_INIT(maple_range_64_parent, "maple_range_64", "parent"); + MEMBER_OFFSET_INIT(maple_range_64_pivot, "maple_range_64", "pivot"); + MEMBER_OFFSET_INIT(maple_range_64_slot, "maple_range_64", "slot"); + MEMBER_OFFSET_INIT(maple_range_64_meta, "maple_range_64", "meta"); + + MEMBER_OFFSET_INIT(maple_metadata_end, "maple_metadata", "end"); } \ No newline at end of file diff --git a/maple_tree.h b/maple_tree.h index a5a131e..98f3c5c 100644 --- a/maple_tree.h +++ b/maple_tree.h @@ -7,29 +7,23 @@ * Authors: Liam R. Howlett <Liam.Howlett(a)Oracle.com&gt; * Matthew Wilcox <willy(a)infradead.org&gt; */ -#include <stdint.h> #include <stdbool.h> -typedef uint32_t spinlock_t; -typedef uint32_t lockdep_map_p; - -struct maple_tree { - union { - spinlock_t ma_lock; - lockdep_map_p ma_external_lock; - }; - void *ma_root; - unsigned int ma_flags; -}; +/* + * Keep the empty struct names for debug purpose of compiler warning. + * And can also keep the function prototypes consistent with kernel's + * corresponding functions. + */ +struct maple_tree { }; +struct maple_metadata { }; +struct maple_range_64 { }; +struct maple_arange_64 { }; +struct maple_alloc { }; +struct maple_node { }; typedef struct maple_enode *maple_enode; /* encoded node */ typedef struct maple_pnode *maple_pnode; /* parent node */ -struct maple_metadata { - unsigned char end; - unsigned char gap; -}; - struct ma_state { struct maple_tree *tree; /* The tree we're operating in */ unsigned long index; /* The index we're operating on - range start */ @@ -67,21 +61,28 @@ enum maple_type { .max = ULONG_MAX, \ } -#if defined(CONFIG_64BIT) || defined(BUILD_VDSO32_64) +#if defined(ALPHA) || defined(IA64) || \ + defined(S390) || defined(S390X) || \ + defined(PPC64) || defined(X86_64) || \ + defined(ARM64) || defined(SPARC64) || \ + defined(MIPS64) /* 64bit sizes */ #define MAPLE_NODE_SLOTS 31 /* 256 bytes including ->parent */ #define MAPLE_RANGE64_SLOTS 16 /* 256 bytes */ #define MAPLE_ARANGE64_SLOTS 10 /* 240 bytes */ #define MAPLE_ARANGE64_META_MAX 15 /* Out of range for metadata */ #define MAPLE_ALLOC_SLOTS (MAPLE_NODE_SLOTS - 1) -#else +#endif + +#if defined(X86) || defined(PPC) || \ + defined(ARM) || defined(MIPS) /* 32bit sizes */ #define MAPLE_NODE_SLOTS 63 /* 256 bytes including ->parent */ #define MAPLE_RANGE64_SLOTS 32 /* 256 bytes */ #define MAPLE_ARANGE64_SLOTS 21 /* 240 bytes */ #define MAPLE_ARANGE64_META_MAX 31 /* Out of range for metadata */ #define MAPLE_ALLOC_SLOTS (MAPLE_NODE_SLOTS - 2) -#endif /* defined(CONFIG_64BIT) || defined(BUILD_VDSO32_64) */ +#endif #define MAPLE_NODE_MASK 255UL @@ -101,56 +102,6 @@ enum maple_type { #define MAPLE_RESERVED_RANGE 4096 -typedef struct rcu_head { unsigned char x[16]; } rcu_head; - -struct maple_range_64 { - struct maple_pnode *parent; - unsigned long pivot[MAPLE_RANGE64_SLOTS - 1]; - union { - void *slot[MAPLE_RANGE64_SLOTS]; - struct { - void *pad[MAPLE_RANGE64_SLOTS - 1]; - struct maple_metadata meta; - }; - }; -}; - -struct maple_arange_64 { - struct maple_pnode *parent; - unsigned long pivot[MAPLE_ARANGE64_SLOTS - 1]; - void *slot[MAPLE_ARANGE64_SLOTS]; - unsigned long gap[MAPLE_ARANGE64_SLOTS]; - struct maple_metadata meta; -}; - -struct maple_alloc { - unsigned long total; - unsigned char node_count; - unsigned int request_count; - struct maple_alloc *slot[MAPLE_ALLOC_SLOTS]; -}; - -struct maple_node { - union { - struct { - struct maple_pnode *parent; - void *slot[MAPLE_NODE_SLOTS]; - }; - struct { - void *pad; - struct rcu_head rcu; - struct maple_enode *piv_parent; - unsigned char parent_slot; - enum maple_type type; - unsigned char slot_len; - unsigned int ma_flags; - }; - struct maple_range_64 mr64; - struct maple_arange_64 ma64; - struct maple_alloc alloc; - }; -}; - static inline void mas_reset(struct ma_state *mas) { mas->node = MAS_START; @@ -166,7 +117,6 @@ void mas_set_range(struct ma_state *mas, unsigned long start, unsigned long last static inline void mas_set(struct ma_state *mas, unsigned long index) { - mas_set_range(mas, index, index); } diff --git a/memory.c b/memory.c index 00f7c9a..2bfd5ae 100644 --- a/memory.c +++ b/memory.c @@ -299,6 +299,7 @@ static void dump_page_flags(ulonglong); static ulong kmem_cache_nodelists(ulong); static void dump_hstates(void); static ulong freelist_ptr(struct meminfo *, ulong, ulong); +extern void maple_init(void); /* * Memory display modes specific to this file. @@ -364,6 +365,9 @@ vm_init(void) MEMBER_OFFSET_INIT(task_struct_mm, "task_struct", "mm"); MEMBER_OFFSET_INIT(mm_struct_mmap, "mm_struct", "mmap"); MEMBER_OFFSET_INIT(mm_struct_mm_mt, "mm_struct", "mm_mt"); + if (VALID_MEMBER(mm_struct_mm_mt)) { + maple_init(); + } MEMBER_OFFSET_INIT(mm_struct_pgd, "mm_struct", "pgd"); MEMBER_OFFSET_INIT(mm_struct_rss, "mm_struct", "rss"); if (!VALID_MEMBER(mm_struct_rss)) -- 2.33.1