Re: [PATCH 01/13] static_call: Index code text reservation lookups

[Peter Zijlstra <peterz@infradead.org>]

On Mon, Nov 09, 2026 at 08:49:04PM +0100, Jiri Olsa wrote:
> --- a/kernel/static_call_inline.c
> +++ b/kernel/static_call_inline.c
> @@ -15,6 +15,18 @@ extern struct static_call_site __start_static_call_sites[],
>  extern struct static_call_tramp_key __start_static_call_tramp_key[],
>  				    __stop_static_call_tramp_key[];
>  
> +struct static_call_site_index {
> +	struct static_call_site *base;
> +	unsigned int nr;
> +	u32 entries[];
> +};
> +
> +/*
> + * Index static call sites by code address for text reservation lookups.
> + * The site table itself is sorted by static-call-key address.
> + */
> +static struct static_call_site_index *static_call_site_index;
> +
>  int static_call_initialized;
>  
>  /*
> @@ -41,7 +53,7 @@ static void static_call_unlock(void)
>  	mutex_unlock(&static_call_mutex);
>  }
>  
> -static inline void *static_call_addr(struct static_call_site *site)
> +static inline void *static_call_addr(const struct static_call_site *site)
>  {
>  	return (void *)((long)site->addr + (long)&site->addr);
>  }
> @@ -301,6 +313,79 @@ static int addr_conflict(struct static_call_site *site, void *start, void *end)
>  	return 0;
>  }
>  
> +static int static_call_site_index_cmp(const void *a, const void *b, const void *priv)
> +{
> +	const struct static_call_site *base = priv;
> +	unsigned int ia = *(u32 *)a;
> +	unsigned int ib = *(u32 *)b;
> +	unsigned long ca = (unsigned long)static_call_addr(base + ia);
> +	unsigned long cb = (unsigned long)static_call_addr(base + ib);
> +
> +	return cmp_int(ca, cb);
> +}
> +
> +static struct static_call_site_index *
> +static_call_site_index_alloc(struct static_call_site *start,
> +			     struct static_call_site *stop)
> +{
> +	struct static_call_site_index *index;
> +	unsigned int nr = stop - start;
> +	unsigned int i;
> +
> +	if (!nr)
> +		return NULL;
> +
> +	index = kvmalloc_flex(*index, entries, nr, GFP_KERNEL);
> +	if (!index)
> +		return NULL;
> +
> +	index->nr = nr;
> +	index->base = start;
> +	for (i = 0; i < nr; i++)
> +		index->entries[i] = i;
> +
> +	sort_r(index->entries, nr, sizeof(index->entries[0]),
> +	       static_call_site_index_cmp, NULL, start);
> +
> +	return index;
> +}
> +
> +static int
> +static_call_site_index_text_reserved(struct static_call_site_index *index,
> +				     void *start, void *end, bool init)
> +{
> +	unsigned int low = 0, high = index->nr, i;
> +
> +	/* Find the first site after @start. */
> +	while (low < high) {
> +		unsigned int mid = low + (high - low) / 2;
> +		void *addr = static_call_addr(index->base + index->entries[mid]);
> +
> +		if (addr <= start)
> +			low = mid + 1;
> +		else
> +			high = mid;
> +	}
> +
> +	/* The preceding site may overlap @start. */
> +	if (low)
> +		low--;
> +
> +	for (i = low; i < index->nr; i++) {
> +		struct static_call_site *site = index->base + index->entries[i];
> +		void *addr = static_call_addr(site);
> +
> +		/* Later sites cannot overlap once this address is past @end. */
> +		if (addr > end)
> +			break;
> +		if ((init || !static_call_is_init(site)) &&
> +		    addr_conflict(site, start, end))
> +			return 1;
> +	}
> +
> +	return 0;
> +}

Looking at this in a little more detail; I'm confused. 

You're literally adding an index, so that you can find the
static_call_size, while all you really need is static_call_addr().

That is, you could have just created an array of relocated site->addr
and sorted that, that would safe you a ton of indirection all around.

That is:

	index->entries[i] = (long)static_call_addr(start + i) - (long)&index->entries[i];

That will make your lookup take at least half the amount of loads.


Also, you really should support modules, there is no point being fast
until you load a module.