GFS2: Remove dirent_first() function
[linux-2.6.git] / mm / allocpercpu.c
1 /*
2  * linux/mm/allocpercpu.c
3  *
4  * Separated from slab.c August 11, 2006 Christoph Lameter
5  */
6 #include <linux/mm.h>
7 #include <linux/module.h>
8 #include <linux/bootmem.h>
9 #include <asm/sections.h>
10
11 #ifndef cache_line_size
12 #define cache_line_size()       L1_CACHE_BYTES
13 #endif
14
15 /**
16  * percpu_depopulate - depopulate per-cpu data for given cpu
17  * @__pdata: per-cpu data to depopulate
18  * @cpu: depopulate per-cpu data for this cpu
19  *
20  * Depopulating per-cpu data for a cpu going offline would be a typical
21  * use case. You need to register a cpu hotplug handler for that purpose.
22  */
23 static void percpu_depopulate(void *__pdata, int cpu)
24 {
25         struct percpu_data *pdata = __percpu_disguise(__pdata);
26
27         kfree(pdata->ptrs[cpu]);
28         pdata->ptrs[cpu] = NULL;
29 }
30
31 /**
32  * percpu_depopulate_mask - depopulate per-cpu data for some cpu's
33  * @__pdata: per-cpu data to depopulate
34  * @mask: depopulate per-cpu data for cpu's selected through mask bits
35  */
36 static void __percpu_depopulate_mask(void *__pdata, const cpumask_t *mask)
37 {
38         int cpu;
39         for_each_cpu_mask_nr(cpu, *mask)
40                 percpu_depopulate(__pdata, cpu);
41 }
42
43 #define percpu_depopulate_mask(__pdata, mask) \
44         __percpu_depopulate_mask((__pdata), &(mask))
45
46 /**
47  * percpu_populate - populate per-cpu data for given cpu
48  * @__pdata: per-cpu data to populate further
49  * @size: size of per-cpu object
50  * @gfp: may sleep or not etc.
51  * @cpu: populate per-data for this cpu
52  *
53  * Populating per-cpu data for a cpu coming online would be a typical
54  * use case. You need to register a cpu hotplug handler for that purpose.
55  * Per-cpu object is populated with zeroed buffer.
56  */
57 static void *percpu_populate(void *__pdata, size_t size, gfp_t gfp, int cpu)
58 {
59         struct percpu_data *pdata = __percpu_disguise(__pdata);
60         int node = cpu_to_node(cpu);
61
62         /*
63          * We should make sure each CPU gets private memory.
64          */
65         size = roundup(size, cache_line_size());
66
67         BUG_ON(pdata->ptrs[cpu]);
68         if (node_online(node))
69                 pdata->ptrs[cpu] = kmalloc_node(size, gfp|__GFP_ZERO, node);
70         else
71                 pdata->ptrs[cpu] = kzalloc(size, gfp);
72         return pdata->ptrs[cpu];
73 }
74
75 /**
76  * percpu_populate_mask - populate per-cpu data for more cpu's
77  * @__pdata: per-cpu data to populate further
78  * @size: size of per-cpu object
79  * @gfp: may sleep or not etc.
80  * @mask: populate per-cpu data for cpu's selected through mask bits
81  *
82  * Per-cpu objects are populated with zeroed buffers.
83  */
84 static int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
85                                   cpumask_t *mask)
86 {
87         cpumask_t populated;
88         int cpu;
89
90         cpus_clear(populated);
91         for_each_cpu_mask_nr(cpu, *mask)
92                 if (unlikely(!percpu_populate(__pdata, size, gfp, cpu))) {
93                         __percpu_depopulate_mask(__pdata, &populated);
94                         return -ENOMEM;
95                 } else
96                         cpu_set(cpu, populated);
97         return 0;
98 }
99
100 #define percpu_populate_mask(__pdata, size, gfp, mask) \
101         __percpu_populate_mask((__pdata), (size), (gfp), &(mask))
102
103 /**
104  * alloc_percpu - initial setup of per-cpu data
105  * @size: size of per-cpu object
106  * @align: alignment
107  *
108  * Allocate dynamic percpu area.  Percpu objects are populated with
109  * zeroed buffers.
110  */
111 void *__alloc_percpu(size_t size, size_t align)
112 {
113         /*
114          * We allocate whole cache lines to avoid false sharing
115          */
116         size_t sz = roundup(nr_cpu_ids * sizeof(void *), cache_line_size());
117         void *pdata = kzalloc(sz, GFP_KERNEL);
118         void *__pdata = __percpu_disguise(pdata);
119
120         /*
121          * Can't easily make larger alignment work with kmalloc.  WARN
122          * on it.  Larger alignment should only be used for module
123          * percpu sections on SMP for which this path isn't used.
124          */
125         WARN_ON_ONCE(align > SMP_CACHE_BYTES);
126
127         if (unlikely(!pdata))
128                 return NULL;
129         if (likely(!__percpu_populate_mask(__pdata, size, GFP_KERNEL,
130                                            &cpu_possible_map)))
131                 return __pdata;
132         kfree(pdata);
133         return NULL;
134 }
135 EXPORT_SYMBOL_GPL(__alloc_percpu);
136
137 /**
138  * free_percpu - final cleanup of per-cpu data
139  * @__pdata: object to clean up
140  *
141  * We simply clean up any per-cpu object left. No need for the client to
142  * track and specify through a bis mask which per-cpu objects are to free.
143  */
144 void free_percpu(void *__pdata)
145 {
146         if (unlikely(!__pdata))
147                 return;
148         __percpu_depopulate_mask(__pdata, cpu_possible_mask);
149         kfree(__percpu_disguise(__pdata));
150 }
151 EXPORT_SYMBOL_GPL(free_percpu);
152
153 /*
154  * Generic percpu area setup.
155  */
156 #ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
157 unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
158
159 EXPORT_SYMBOL(__per_cpu_offset);
160
161 void __init setup_per_cpu_areas(void)
162 {
163         unsigned long size, i;
164         char *ptr;
165         unsigned long nr_possible_cpus = num_possible_cpus();
166
167         /* Copy section for each CPU (we discard the original) */
168         size = ALIGN(PERCPU_ENOUGH_ROOM, PAGE_SIZE);
169         ptr = alloc_bootmem_pages(size * nr_possible_cpus);
170
171         for_each_possible_cpu(i) {
172                 __per_cpu_offset[i] = ptr - __per_cpu_start;
173                 memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);
174                 ptr += size;
175         }
176 }
177 #endif /* CONFIG_HAVE_SETUP_PER_CPU_AREA */