On 11/2/22 13:06, zhaoyang.huang wrote: > From: Zhaoyang Huang <zhaoyang.huang@xxxxxxxxxx> > > Page_owner could be accounted and sort via its backtrace, which could > simplify the output. > > Signed-off-by: Zhaoyang Huang <zhaoyang.huang@xxxxxxxxxx> At first glance this looks like the same goal as Oscar's (CC'd) patchset: https://lore.kernel.org/linux-mm/20220905031012.4450-1-osalvador@xxxxxxx/ > --- > include/linux/page_owner.h | 7 +++ > mm/page_owner.c | 113 +++++++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 120 insertions(+) > > diff --git a/include/linux/page_owner.h b/include/linux/page_owner.h > index 119a0c9..c86a342 100644 > --- a/include/linux/page_owner.h > +++ b/include/linux/page_owner.h > @@ -3,6 +3,13 @@ > #define __LINUX_PAGE_OWNER_H > > #include <linux/jump_label.h> > +#include <linux/stackdepot.h> > + > +struct hash_object { > + int count; > + depot_stack_handle_t trace_hash; > + struct rb_node rb_node; > +}; > > #ifdef CONFIG_PAGE_OWNER > extern struct static_key_false page_owner_inited; > diff --git a/mm/page_owner.c b/mm/page_owner.c > index e4c6f3f..3d014fd 100644 > --- a/mm/page_owner.c > +++ b/mm/page_owner.c > @@ -42,6 +42,12 @@ struct page_owner { > static depot_stack_handle_t early_handle; > > static void init_early_allocated_pages(void); > +static void store_user_hash(depot_stack_handle_t trace_hash, int count); > +static DEFINE_SPINLOCK(stack_hash_lock); > +static struct hash_object ho_pool[8192]; > +static int ho_pool_free_count = ARRAY_SIZE(ho_pool); > +struct rb_root user_hash_root = RB_ROOT; > + > > static int __init early_page_owner_param(char *buf) > { > @@ -152,6 +158,8 @@ void __reset_page_owner(struct page *page, unsigned short order) > page_owner->free_handle = handle; > page_owner->free_ts_nsec = free_ts_nsec; > page_ext = page_ext_next(page_ext); > + if (!i) > + store_user_hash(page_owner->handle, -(1 << order)); > } > } > > @@ -190,6 +198,7 @@ noinline void __set_page_owner(struct page *page, unsigned short order, > return; > > handle = save_stack(gfp_mask); > + store_user_hash(handle, 1 << order); > __set_page_owner_handle(page_ext, handle, order, gfp_mask); > } > > @@ -570,6 +579,105 @@ void __dump_page_owner(const struct page *page) > return 0; > } > > +static void store_user_hash(depot_stack_handle_t trace_hash, int count) > +{ > + struct rb_node *rb_parent; > + unsigned int trace_hash_parent; > + struct rb_node **link = &user_hash_root.rb_node; > + struct hash_object *hash_parent = NULL; > + struct hash_object *hash_object = NULL; > + unsigned long flags; > + > + spin_lock_irqsave(&stack_hash_lock, flags); > + while (*link) { > + rb_parent = *link; > + hash_parent = rb_entry(rb_parent, struct hash_object, rb_node); > + trace_hash_parent = hash_parent->trace_hash; > + if (trace_hash < trace_hash_parent) > + link = &hash_parent->rb_node.rb_left; > + else if (trace_hash_parent < trace_hash) > + link = &hash_parent->rb_node.rb_right; > + else { > + hash_object = rb_entry(*link, struct hash_object, rb_node); > + hash_object->count += count; > + if (!RB_EMPTY_ROOT(&user_hash_root) > + && !hash_object->count) { > + rb_erase(&hash_object->rb_node, &user_hash_root); > + } > + spin_unlock_irqrestore(&stack_hash_lock, flags); > + return; > + } > + } > + /* > + * hash_object is the 1st node represent this trace_hash > + * insert it to user_hash_root > + */ > + hash_object = ho_pool_free_count ? &ho_pool[--ho_pool_free_count] : NULL; > + if (!hash_object) { > + spin_unlock_irqrestore(&stack_hash_lock, flags); > + return; > + } > + hash_object->trace_hash = trace_hash; > + /* add the node to rb tree*/ > + rb_link_node(&hash_object->rb_node, rb_parent, link); > + rb_insert_color(&hash_object->rb_node, &user_hash_root); > + spin_unlock_irqrestore(&stack_hash_lock, flags); > + return; > +} > +static ssize_t print_owner_stack(struct file *file, char __user *buf, size_t count, loff_t *ppos) > +{ > + struct hash_object *object; > + struct rb_node *rb; > + unsigned long *entries; > + unsigned int nr_entries; > + char *kbuf; > + int i, ret = 0; > + unsigned long flags; > + > + count = min_t(size_t, count, PAGE_SIZE); > + kbuf = kmalloc(count, GFP_KERNEL); > + if (!kbuf) > + return -ENOMEM; > + > + rb = file->private_data ? (struct rb_node *)file->private_data : rb_first(&user_hash_root); > + if(!rb) > + return 0; > + spin_lock_irqsave(&stack_hash_lock, flags); > + object = rb_entry(rb, struct hash_object, rb_node); > + if (object) { > + while (!object->trace_hash || object->count <= 0) { > + rb = rb_next(rb); > + object = rb ? rb_entry(rb, struct hash_object, rb_node) : NULL; > + if (!object) { > + spin_unlock_irqrestore(&stack_hash_lock, flags); > + kfree(kbuf); > + return 0; > + } > + } > + nr_entries = stack_depot_fetch(object->trace_hash, &entries); > + ret += snprintf(kbuf + ret, count - ret, "count %d\n", object->count); > + if (ret >= count) > + goto err; > + for (i = 0; i < nr_entries; i++) { > + void *ptr = (void *)entries[i]; > + ret += snprintf(kbuf + ret, count - ret, " [<%p>] %pS\n", ptr, ptr); > + if (ret >= count) > + goto err; > + } > + } > + file->private_data = (void *)rb_next(rb); > + spin_unlock_irqrestore(&stack_hash_lock, flags); > + if (copy_to_user(buf, kbuf, ret)) > + ret = -EFAULT; > + > + kfree(kbuf); > + return ret; > +err: > + spin_unlock_irqrestore(&stack_hash_lock, flags); > + kfree(kbuf); > + return -ENOMEM; > +} > + > static void init_pages_in_zone(pg_data_t *pgdat, struct zone *zone) > { > unsigned long pfn = zone->zone_start_pfn; > @@ -661,6 +769,9 @@ static void init_early_allocated_pages(void) > static const struct file_operations proc_page_owner_operations = { > .read = read_page_owner, > }; > +static const struct file_operations proc_page_owner_simple_operations = { > + .read = print_owner_stack, > +}; > > static int __init pageowner_init(void) > { > @@ -671,6 +782,8 @@ static int __init pageowner_init(void) > > debugfs_create_file("page_owner", 0400, NULL, NULL, > &proc_page_owner_operations); > + debugfs_create_file("page_owner_simple", 0400, NULL, NULL, > + &proc_page_owner_simple_operations); > > return 0; > }
