Commit | Line | Data |
---|---|---|
d00bcc98 CL |
1 | /* |
2 | * linux/mm/allocpercpu.c | |
3 | * | |
4 | * Separated from slab.c August 11, 2006 Christoph Lameter <clameter@sgi.com> | |
5 | */ | |
6 | #include <linux/mm.h> | |
7 | #include <linux/module.h> | |
8 | ||
9 | /** | |
10 | * percpu_depopulate - depopulate per-cpu data for given cpu | |
11 | * @__pdata: per-cpu data to depopulate | |
12 | * @cpu: depopulate per-cpu data for this cpu | |
13 | * | |
14 | * Depopulating per-cpu data for a cpu going offline would be a typical | |
15 | * use case. You need to register a cpu hotplug handler for that purpose. | |
16 | */ | |
17 | void percpu_depopulate(void *__pdata, int cpu) | |
18 | { | |
19 | struct percpu_data *pdata = __percpu_disguise(__pdata); | |
a1205868 AS |
20 | |
21 | kfree(pdata->ptrs[cpu]); | |
22 | pdata->ptrs[cpu] = NULL; | |
d00bcc98 CL |
23 | } |
24 | EXPORT_SYMBOL_GPL(percpu_depopulate); | |
25 | ||
26 | /** | |
27 | * percpu_depopulate_mask - depopulate per-cpu data for some cpu's | |
28 | * @__pdata: per-cpu data to depopulate | |
29 | * @mask: depopulate per-cpu data for cpu's selected through mask bits | |
30 | */ | |
31 | void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask) | |
32 | { | |
33 | int cpu; | |
34 | for_each_cpu_mask(cpu, *mask) | |
35 | percpu_depopulate(__pdata, cpu); | |
36 | } | |
37 | EXPORT_SYMBOL_GPL(__percpu_depopulate_mask); | |
38 | ||
39 | /** | |
40 | * percpu_populate - populate per-cpu data for given cpu | |
41 | * @__pdata: per-cpu data to populate further | |
42 | * @size: size of per-cpu object | |
43 | * @gfp: may sleep or not etc. | |
44 | * @cpu: populate per-data for this cpu | |
45 | * | |
46 | * Populating per-cpu data for a cpu coming online would be a typical | |
47 | * use case. You need to register a cpu hotplug handler for that purpose. | |
48 | * Per-cpu object is populated with zeroed buffer. | |
49 | */ | |
50 | void *percpu_populate(void *__pdata, size_t size, gfp_t gfp, int cpu) | |
51 | { | |
52 | struct percpu_data *pdata = __percpu_disguise(__pdata); | |
53 | int node = cpu_to_node(cpu); | |
54 | ||
55 | BUG_ON(pdata->ptrs[cpu]); | |
56 | if (node_online(node)) { | |
57 | /* FIXME: kzalloc_node(size, gfp, node) */ | |
58 | pdata->ptrs[cpu] = kmalloc_node(size, gfp, node); | |
59 | if (pdata->ptrs[cpu]) | |
60 | memset(pdata->ptrs[cpu], 0, size); | |
61 | } else | |
62 | pdata->ptrs[cpu] = kzalloc(size, gfp); | |
63 | return pdata->ptrs[cpu]; | |
64 | } | |
65 | EXPORT_SYMBOL_GPL(percpu_populate); | |
66 | ||
67 | /** | |
68 | * percpu_populate_mask - populate per-cpu data for more cpu's | |
69 | * @__pdata: per-cpu data to populate further | |
70 | * @size: size of per-cpu object | |
71 | * @gfp: may sleep or not etc. | |
72 | * @mask: populate per-cpu data for cpu's selected through mask bits | |
73 | * | |
74 | * Per-cpu objects are populated with zeroed buffers. | |
75 | */ | |
76 | int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp, | |
77 | cpumask_t *mask) | |
78 | { | |
79 | cpumask_t populated = CPU_MASK_NONE; | |
80 | int cpu; | |
81 | ||
82 | for_each_cpu_mask(cpu, *mask) | |
83 | if (unlikely(!percpu_populate(__pdata, size, gfp, cpu))) { | |
84 | __percpu_depopulate_mask(__pdata, &populated); | |
85 | return -ENOMEM; | |
86 | } else | |
87 | cpu_set(cpu, populated); | |
88 | return 0; | |
89 | } | |
90 | EXPORT_SYMBOL_GPL(__percpu_populate_mask); | |
91 | ||
92 | /** | |
93 | * percpu_alloc_mask - initial setup of per-cpu data | |
94 | * @size: size of per-cpu object | |
95 | * @gfp: may sleep or not etc. | |
96 | * @mask: populate per-data for cpu's selected through mask bits | |
97 | * | |
98 | * Populating per-cpu data for all online cpu's would be a typical use case, | |
99 | * which is simplified by the percpu_alloc() wrapper. | |
100 | * Per-cpu objects are populated with zeroed buffers. | |
101 | */ | |
102 | void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask) | |
103 | { | |
104 | void *pdata = kzalloc(sizeof(struct percpu_data), gfp); | |
105 | void *__pdata = __percpu_disguise(pdata); | |
106 | ||
107 | if (unlikely(!pdata)) | |
108 | return NULL; | |
109 | if (likely(!__percpu_populate_mask(__pdata, size, gfp, mask))) | |
110 | return __pdata; | |
111 | kfree(pdata); | |
112 | return NULL; | |
113 | } | |
114 | EXPORT_SYMBOL_GPL(__percpu_alloc_mask); | |
115 | ||
116 | /** | |
117 | * percpu_free - final cleanup of per-cpu data | |
118 | * @__pdata: object to clean up | |
119 | * | |
120 | * We simply clean up any per-cpu object left. No need for the client to | |
121 | * track and specify through a bis mask which per-cpu objects are to free. | |
122 | */ | |
123 | void percpu_free(void *__pdata) | |
124 | { | |
a1205868 AS |
125 | if (unlikely(!__pdata)) |
126 | return; | |
d00bcc98 CL |
127 | __percpu_depopulate_mask(__pdata, &cpu_possible_map); |
128 | kfree(__percpu_disguise(__pdata)); | |
129 | } | |
130 | EXPORT_SYMBOL_GPL(percpu_free); |