569de905eb
pcpu_freelist_populate() is disabling interrupts and then iterates over the possible CPUs. The reason why this disables interrupts is to silence lockdep because the invoked ___pcpu_freelist_push() takes spin locks. Neither the interrupt disabling nor the locking are required in this function because it's called during initialization and the resulting map is not yet visible to anything. Split out the actual push assignement into an inline, call it from the loop and remove the interrupt disable. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Alexei Starovoitov <ast@kernel.org> Link: https://lore.kernel.org/bpf/20200224145643.365930116@linutronix.de
119 lines
2.5 KiB
C
119 lines
2.5 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/* Copyright (c) 2016 Facebook
|
|
*/
|
|
#include "percpu_freelist.h"
|
|
|
|
int pcpu_freelist_init(struct pcpu_freelist *s)
|
|
{
|
|
int cpu;
|
|
|
|
s->freelist = alloc_percpu(struct pcpu_freelist_head);
|
|
if (!s->freelist)
|
|
return -ENOMEM;
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
struct pcpu_freelist_head *head = per_cpu_ptr(s->freelist, cpu);
|
|
|
|
raw_spin_lock_init(&head->lock);
|
|
head->first = NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void pcpu_freelist_destroy(struct pcpu_freelist *s)
|
|
{
|
|
free_percpu(s->freelist);
|
|
}
|
|
|
|
static inline void pcpu_freelist_push_node(struct pcpu_freelist_head *head,
|
|
struct pcpu_freelist_node *node)
|
|
{
|
|
node->next = head->first;
|
|
head->first = node;
|
|
}
|
|
|
|
static inline void ___pcpu_freelist_push(struct pcpu_freelist_head *head,
|
|
struct pcpu_freelist_node *node)
|
|
{
|
|
raw_spin_lock(&head->lock);
|
|
pcpu_freelist_push_node(head, node);
|
|
raw_spin_unlock(&head->lock);
|
|
}
|
|
|
|
void __pcpu_freelist_push(struct pcpu_freelist *s,
|
|
struct pcpu_freelist_node *node)
|
|
{
|
|
struct pcpu_freelist_head *head = this_cpu_ptr(s->freelist);
|
|
|
|
___pcpu_freelist_push(head, node);
|
|
}
|
|
|
|
void pcpu_freelist_push(struct pcpu_freelist *s,
|
|
struct pcpu_freelist_node *node)
|
|
{
|
|
unsigned long flags;
|
|
|
|
local_irq_save(flags);
|
|
__pcpu_freelist_push(s, node);
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
void pcpu_freelist_populate(struct pcpu_freelist *s, void *buf, u32 elem_size,
|
|
u32 nr_elems)
|
|
{
|
|
struct pcpu_freelist_head *head;
|
|
int i, cpu, pcpu_entries;
|
|
|
|
pcpu_entries = nr_elems / num_possible_cpus() + 1;
|
|
i = 0;
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
again:
|
|
head = per_cpu_ptr(s->freelist, cpu);
|
|
/* No locking required as this is not visible yet. */
|
|
pcpu_freelist_push_node(head, buf);
|
|
i++;
|
|
buf += elem_size;
|
|
if (i == nr_elems)
|
|
break;
|
|
if (i % pcpu_entries)
|
|
goto again;
|
|
}
|
|
}
|
|
|
|
struct pcpu_freelist_node *__pcpu_freelist_pop(struct pcpu_freelist *s)
|
|
{
|
|
struct pcpu_freelist_head *head;
|
|
struct pcpu_freelist_node *node;
|
|
int orig_cpu, cpu;
|
|
|
|
orig_cpu = cpu = raw_smp_processor_id();
|
|
while (1) {
|
|
head = per_cpu_ptr(s->freelist, cpu);
|
|
raw_spin_lock(&head->lock);
|
|
node = head->first;
|
|
if (node) {
|
|
head->first = node->next;
|
|
raw_spin_unlock(&head->lock);
|
|
return node;
|
|
}
|
|
raw_spin_unlock(&head->lock);
|
|
cpu = cpumask_next(cpu, cpu_possible_mask);
|
|
if (cpu >= nr_cpu_ids)
|
|
cpu = 0;
|
|
if (cpu == orig_cpu)
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
struct pcpu_freelist_node *pcpu_freelist_pop(struct pcpu_freelist *s)
|
|
{
|
|
struct pcpu_freelist_node *ret;
|
|
unsigned long flags;
|
|
|
|
local_irq_save(flags);
|
|
ret = __pcpu_freelist_pop(s);
|
|
local_irq_restore(flags);
|
|
return ret;
|
|
}
|