// SPDX-License-Identifier: GPL-2.0-only/* * * Copyright (C) 2017		Facebook Inc. * Copyright (C) 2017		Dennis Zhou <dennis@kernel.org> * * Prints statistics about the percpu allocator and backing chunks. */#include <linux/debugfs.h>#include <linux/list.h>#include <linux/percpu.h>#include <linux/seq_file.h>#include <linux/sort.h>#include <linux/vmalloc.h> #include "percpu-internal.h" #define P(X, Y) \	seq_printf(m, "  %-20s: %12lld\n", X, (long long int)Y) struct percpu_stats pcpu_stats;struct pcpu_alloc_info pcpu_stats_ai; static int cmpint(const void *a, const void *b){	return *(int *)a - *(int *)b;} /* * Iterates over all chunks to find the max nr_alloc entries. */static int find_max_nr_alloc(void){	struct pcpu_chunk *chunk;	int slot, max_nr_alloc; 	max_nr_alloc = 0;	for (slot = 0; slot < pcpu_nr_slots; slot++)		list_for_each_entry(chunk, &pcpu_chunk_lists[slot], list)			max_nr_alloc = max(max_nr_alloc, chunk->nr_alloc); 	return max_nr_alloc;} /* * Prints out chunk state. Fragmentation is considered between * the beginning of the chunk to the last allocation. * * All statistics are in bytes unless stated otherwise. */static void chunk_map_stats(struct seq_file *m, struct pcpu_chunk *chunk,			    int *buffer){	struct pcpu_block_md *chunk_md = &chunk->chunk_md;	int i, last_alloc, as_len, start, end;	int *alloc_sizes, *p;	/* statistics */	int sum_frag = 0, max_frag = 0;	int cur_min_alloc = 0, cur_med_alloc = 0, cur_max_alloc = 0; 	alloc_sizes = buffer; 	/*	 * find_last_bit returns the start value if nothing found.	 * Therefore, we must determine if it is a failure of find_last_bit	 * and set the appropriate value.	 */	last_alloc = find_last_bit(chunk->alloc_map,				   pcpu_chunk_map_bits(chunk) -				   chunk->end_offset / PCPU_MIN_ALLOC_SIZE - 1);	last_alloc = test_bit(last_alloc, chunk->alloc_map) ?		     last_alloc + 1 : 0; 	as_len = 0;	start = chunk->start_offset / PCPU_MIN_ALLOC_SIZE; 	/*	 * If a bit is set in the allocation map, the bound_map identifies	 * where the allocation ends.  If the allocation is not set, the	 * bound_map does not identify free areas as it is only kept accurate	 * on allocation, not free.	 *	 * Positive values are allocations and negative values are free	 * fragments.	 */	while (start < last_alloc) {		if (test_bit(start, chunk->alloc_map)) {			end = find_next_bit(chunk->bound_map, last_alloc,					    start + 1);			alloc_sizes[as_len] = 1;		} else {			end = find_next_bit(chunk->alloc_map, last_alloc,					    start + 1);			alloc_sizes[as_len] = -1;		} 		alloc_sizes[as_len++] *= (end - start) * PCPU_MIN_ALLOC_SIZE; 		start = end;	} 	/*	 * The negative values are free fragments and thus sorting gives the	 * free fragments at the beginning in largest first order.	 */	if (as_len > 0) {		sort(alloc_sizes, as_len, sizeof(int), cmpint, NULL); 		/* iterate through the unallocated fragments */		for (i = 0, p = alloc_sizes; *p < 0 && i < as_len; i++, p++) {			sum_frag -= *p;			max_frag = max(max_frag, -1 * (*p));		} 		cur_min_alloc = alloc_sizes[i];		cur_med_alloc = alloc_sizes[(i + as_len - 1) / 2];		cur_max_alloc = alloc_sizes[as_len - 1];	} 	P("nr_alloc", chunk->nr_alloc);	P("max_alloc_size", chunk->max_alloc_size);	P("empty_pop_pages", chunk->nr_empty_pop_pages);	P("first_bit", chunk_md->first_free);	P("free_bytes", chunk->free_bytes);	P("contig_bytes", chunk_md->contig_hint * PCPU_MIN_ALLOC_SIZE);	P("sum_frag", sum_frag);	P("max_frag", max_frag);	P("cur_min_alloc", cur_min_alloc);	P("cur_med_alloc", cur_med_alloc);	P("cur_max_alloc", cur_max_alloc);	seq_putc(m, '\n');} static int percpu_stats_show(struct seq_file *m, void *v){	struct pcpu_chunk *chunk;	int slot, max_nr_alloc;	int *buffer; alloc_buffer:	spin_lock_irq(&pcpu_lock);	max_nr_alloc = find_max_nr_alloc();	spin_unlock_irq(&pcpu_lock); 	/* there can be at most this many free and allocated fragments */	buffer = vmalloc_array(2 * max_nr_alloc + 1, sizeof(int));	if (!buffer)		return -ENOMEM; 	spin_lock_irq(&pcpu_lock); 	/* if the buffer allocated earlier is too small */	if (max_nr_alloc < find_max_nr_alloc()) {		spin_unlock_irq(&pcpu_lock);		vfree(buffer);		goto alloc_buffer;	} #define PL(X)								\	seq_printf(m, "  %-20s: %12lld\n", #X, (long long int)pcpu_stats_ai.X) 	seq_printf(m,			"Percpu Memory Statistics\n"			"Allocation Info:\n"			"----------------------------------------\n");	PL(unit_size);	PL(static_size);	PL(reserved_size);	PL(dyn_size);	PL(atom_size);	PL(alloc_size);	seq_putc(m, '\n'); #undef PL #define PU(X) \	seq_printf(m, "  %-20s: %12llu\n", #X, (unsigned long long)pcpu_stats.X) 	seq_printf(m,			"Global Stats:\n"			"----------------------------------------\n");	PU(nr_alloc);	PU(nr_dealloc);	PU(nr_cur_alloc);	PU(nr_max_alloc);	PU(nr_chunks);	PU(nr_max_chunks);	PU(min_alloc_size);	PU(max_alloc_size);	P("empty_pop_pages", pcpu_nr_empty_pop_pages);	seq_putc(m, '\n'); #undef PU 	seq_printf(m,			"Per Chunk Stats:\n"			"----------------------------------------\n"); 	if (pcpu_reserved_chunk) {		seq_puts(m, "Chunk: <- Reserved Chunk\n");		chunk_map_stats(m, pcpu_reserved_chunk, buffer);	} 	for (slot = 0; slot < pcpu_nr_slots; slot++) {		list_for_each_entry(chunk, &pcpu_chunk_lists[slot], list) {			if (chunk == pcpu_first_chunk)				seq_puts(m, "Chunk: <- First Chunk\n");			else if (slot == pcpu_to_depopulate_slot)				seq_puts(m, "Chunk (to_depopulate)\n");			else if (slot == pcpu_sidelined_slot)				seq_puts(m, "Chunk (sidelined):\n");			else				seq_puts(m, "Chunk:\n");			chunk_map_stats(m, chunk, buffer);		}	} 	spin_unlock_irq(&pcpu_lock); 	vfree(buffer); 	return 0;}DEFINE_SHOW_ATTRIBUTE(percpu_stats); static int __init init_percpu_stats_debugfs(void){	debugfs_create_file("percpu_stats", 0444, NULL, NULL,			&percpu_stats_fops); 	return 0;} late_initcall(init_percpu_stats_debugfs);