2 * mm/percpu-vm.c - vmalloc area based chunk allocation
4 * Copyright (C) 2010 SUSE Linux Products GmbH
5 * Copyright (C) 2010 Tejun Heo <tj@kernel.org>
7 * This file is released under the GPLv2.
9 * Chunks are mapped into vmalloc areas and populated page by page.
10 * This is the default chunk allocator.
13 static struct page *pcpu_chunk_page(struct pcpu_chunk *chunk,
14 unsigned int cpu, int page_idx)
16 /* must not be used on pre-mapped chunk */
17 WARN_ON(chunk->immutable);
19 return vmalloc_to_page((void *)pcpu_chunk_addr(chunk, cpu, page_idx));
23 * pcpu_get_pages_and_bitmap - get temp pages array and bitmap
24 * @chunk: chunk of interest
25 * @bitmapp: output parameter for bitmap
26 * @may_alloc: may allocate the array
28 * Returns pointer to array of pointers to struct page and bitmap,
29 * both of which can be indexed with pcpu_page_idx(). The returned
30 * array is cleared to zero and *@bitmapp is copied from
31 * @chunk->populated. Note that there is only one array and bitmap
32 * and access exclusion is the caller's responsibility.
35 * pcpu_alloc_mutex and does GFP_KERNEL allocation if @may_alloc.
36 * Otherwise, don't care.
39 * Pointer to temp pages array on success, NULL on failure.
41 static struct page **pcpu_get_pages_and_bitmap(struct pcpu_chunk *chunk,
42 unsigned long **bitmapp,
45 static struct page **pages;
46 static unsigned long *bitmap;
47 size_t pages_size = pcpu_nr_units * pcpu_unit_pages * sizeof(pages[0]);
48 size_t bitmap_size = BITS_TO_LONGS(pcpu_unit_pages) *
49 sizeof(unsigned long);
51 if (!pages || !bitmap) {
52 if (may_alloc && !pages)
53 pages = pcpu_mem_zalloc(pages_size);
54 if (may_alloc && !bitmap)
55 bitmap = pcpu_mem_zalloc(bitmap_size);
56 if (!pages || !bitmap)
60 bitmap_copy(bitmap, chunk->populated, pcpu_unit_pages);
67 * pcpu_free_pages - free pages which were allocated for @chunk
68 * @chunk: chunk pages were allocated for
69 * @pages: array of pages to be freed, indexed by pcpu_page_idx()
70 * @populated: populated bitmap
71 * @page_start: page index of the first page to be freed
72 * @page_end: page index of the last page to be freed + 1
74 * Free pages [@page_start and @page_end) in @pages for all units.
75 * The pages were allocated for @chunk.
77 static void pcpu_free_pages(struct pcpu_chunk *chunk,
78 struct page **pages, unsigned long *populated,
79 int page_start, int page_end)
84 for_each_possible_cpu(cpu) {
85 for (i = page_start; i < page_end; i++) {
86 struct page *page = pages[pcpu_page_idx(cpu, i)];
95 * pcpu_alloc_pages - allocates pages for @chunk
96 * @chunk: target chunk
97 * @pages: array to put the allocated pages into, indexed by pcpu_page_idx()
98 * @populated: populated bitmap
99 * @page_start: page index of the first page to be allocated
100 * @page_end: page index of the last page to be allocated + 1
102 * Allocate pages [@page_start,@page_end) into @pages for all units.
103 * The allocation is for @chunk. Percpu core doesn't care about the
104 * content of @pages and will pass it verbatim to pcpu_map_pages().
106 static int pcpu_alloc_pages(struct pcpu_chunk *chunk,
107 struct page **pages, unsigned long *populated,
108 int page_start, int page_end)
110 const gfp_t gfp = GFP_KERNEL | __GFP_HIGHMEM | __GFP_COLD;
111 unsigned int cpu, tcpu;
114 for_each_possible_cpu(cpu) {
115 for (i = page_start; i < page_end; i++) {
116 struct page **pagep = &pages[pcpu_page_idx(cpu, i)];
118 *pagep = alloc_pages_node(cpu_to_node(cpu), gfp, 0);
126 while (--i >= page_start)
127 __free_page(pages[pcpu_page_idx(cpu, i)]);
129 for_each_possible_cpu(tcpu) {
132 for (i = page_start; i < page_end; i++)
133 __free_page(pages[pcpu_page_idx(tcpu, i)]);
139 * pcpu_pre_unmap_flush - flush cache prior to unmapping
140 * @chunk: chunk the regions to be flushed belongs to
141 * @page_start: page index of the first page to be flushed
142 * @page_end: page index of the last page to be flushed + 1
144 * Pages in [@page_start,@page_end) of @chunk are about to be
145 * unmapped. Flush cache. As each flushing trial can be very
146 * expensive, issue flush on the whole region at once rather than
147 * doing it for each cpu. This could be an overkill but is more
150 static void pcpu_pre_unmap_flush(struct pcpu_chunk *chunk,
151 int page_start, int page_end)
154 pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
155 pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
158 static void __pcpu_unmap_pages(unsigned long addr, int nr_pages)
160 unmap_kernel_range_noflush(addr, nr_pages << PAGE_SHIFT);
164 * pcpu_unmap_pages - unmap pages out of a pcpu_chunk
165 * @chunk: chunk of interest
166 * @pages: pages array which can be used to pass information to free
167 * @populated: populated bitmap
168 * @page_start: page index of the first page to unmap
169 * @page_end: page index of the last page to unmap + 1
171 * For each cpu, unmap pages [@page_start,@page_end) out of @chunk.
172 * Corresponding elements in @pages were cleared by the caller and can
173 * be used to carry information to pcpu_free_pages() which will be
174 * called after all unmaps are finished. The caller should call
175 * proper pre/post flush functions.
177 static void pcpu_unmap_pages(struct pcpu_chunk *chunk,
178 struct page **pages, unsigned long *populated,
179 int page_start, int page_end)
184 for_each_possible_cpu(cpu) {
185 for (i = page_start; i < page_end; i++) {
188 page = pcpu_chunk_page(chunk, cpu, i);
190 pages[pcpu_page_idx(cpu, i)] = page;
192 __pcpu_unmap_pages(pcpu_chunk_addr(chunk, cpu, page_start),
193 page_end - page_start);
196 for (i = page_start; i < page_end; i++)
197 __clear_bit(i, populated);
201 * pcpu_post_unmap_tlb_flush - flush TLB after unmapping
202 * @chunk: pcpu_chunk the regions to be flushed belong to
203 * @page_start: page index of the first page to be flushed
204 * @page_end: page index of the last page to be flushed + 1
206 * Pages [@page_start,@page_end) of @chunk have been unmapped. Flush
207 * TLB for the regions. This can be skipped if the area is to be
208 * returned to vmalloc as vmalloc will handle TLB flushing lazily.
210 * As with pcpu_pre_unmap_flush(), TLB flushing also is done at once
211 * for the whole region.
213 static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,
214 int page_start, int page_end)
216 flush_tlb_kernel_range(
217 pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
218 pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
221 static int __pcpu_map_pages(unsigned long addr, struct page **pages,
224 return map_kernel_range_noflush(addr, nr_pages << PAGE_SHIFT,
229 * pcpu_map_pages - map pages into a pcpu_chunk
230 * @chunk: chunk of interest
231 * @pages: pages array containing pages to be mapped
232 * @populated: populated bitmap
233 * @page_start: page index of the first page to map
234 * @page_end: page index of the last page to map + 1
236 * For each cpu, map pages [@page_start,@page_end) into @chunk. The
237 * caller is responsible for calling pcpu_post_map_flush() after all
238 * mappings are complete.
240 * This function is responsible for setting corresponding bits in
241 * @chunk->populated bitmap and whatever is necessary for reverse
242 * lookup (addr -> chunk).
244 static int pcpu_map_pages(struct pcpu_chunk *chunk,
245 struct page **pages, unsigned long *populated,
246 int page_start, int page_end)
248 unsigned int cpu, tcpu;
251 for_each_possible_cpu(cpu) {
252 err = __pcpu_map_pages(pcpu_chunk_addr(chunk, cpu, page_start),
253 &pages[pcpu_page_idx(cpu, page_start)],
254 page_end - page_start);
259 /* mapping successful, link chunk and mark populated */
260 for (i = page_start; i < page_end; i++) {
261 for_each_possible_cpu(cpu)
262 pcpu_set_page_chunk(pages[pcpu_page_idx(cpu, i)],
264 __set_bit(i, populated);
270 for_each_possible_cpu(tcpu) {
273 __pcpu_unmap_pages(pcpu_chunk_addr(chunk, tcpu, page_start),
274 page_end - page_start);
276 pcpu_post_unmap_tlb_flush(chunk, page_start, page_end);
281 * pcpu_post_map_flush - flush cache after mapping
282 * @chunk: pcpu_chunk the regions to be flushed belong to
283 * @page_start: page index of the first page to be flushed
284 * @page_end: page index of the last page to be flushed + 1
286 * Pages [@page_start,@page_end) of @chunk have been mapped. Flush
289 * As with pcpu_pre_unmap_flush(), TLB flushing also is done at once
290 * for the whole region.
292 static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
293 int page_start, int page_end)
296 pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
297 pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
301 * pcpu_populate_chunk - populate and map an area of a pcpu_chunk
302 * @chunk: chunk of interest
303 * @off: offset to the area to populate
304 * @size: size of the area to populate in bytes
306 * For each cpu, populate and map pages [@page_start,@page_end) into
307 * @chunk. The area is cleared on return.
310 * pcpu_alloc_mutex, does GFP_KERNEL allocation.
312 static int pcpu_populate_chunk(struct pcpu_chunk *chunk, int off, int size)
314 int page_start = PFN_DOWN(off);
315 int page_end = PFN_UP(off + size);
316 int free_end = page_start, unmap_end = page_start;
318 unsigned long *populated;
322 /* quick path, check whether all pages are already there */
324 pcpu_next_pop(chunk, &rs, &re, page_end);
325 if (rs == page_start && re == page_end)
328 /* need to allocate and map pages, this chunk can't be immutable */
329 WARN_ON(chunk->immutable);
331 pages = pcpu_get_pages_and_bitmap(chunk, &populated, true);
336 pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
337 rc = pcpu_alloc_pages(chunk, pages, populated, rs, re);
343 pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
344 rc = pcpu_map_pages(chunk, pages, populated, rs, re);
349 pcpu_post_map_flush(chunk, page_start, page_end);
351 /* commit new bitmap */
352 bitmap_copy(chunk->populated, populated, pcpu_unit_pages);
354 for_each_possible_cpu(cpu)
355 memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size);
359 pcpu_pre_unmap_flush(chunk, page_start, unmap_end);
360 pcpu_for_each_unpop_region(chunk, rs, re, page_start, unmap_end)
361 pcpu_unmap_pages(chunk, pages, populated, rs, re);
362 pcpu_post_unmap_tlb_flush(chunk, page_start, unmap_end);
364 pcpu_for_each_unpop_region(chunk, rs, re, page_start, free_end)
365 pcpu_free_pages(chunk, pages, populated, rs, re);
370 * pcpu_depopulate_chunk - depopulate and unmap an area of a pcpu_chunk
371 * @chunk: chunk to depopulate
372 * @off: offset to the area to depopulate
373 * @size: size of the area to depopulate in bytes
374 * @flush: whether to flush cache and tlb or not
376 * For each cpu, depopulate and unmap pages [@page_start,@page_end)
377 * from @chunk. If @flush is true, vcache is flushed before unmapping
383 static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, int off, int size)
385 int page_start = PFN_DOWN(off);
386 int page_end = PFN_UP(off + size);
388 unsigned long *populated;
391 /* quick path, check whether it's empty already */
393 pcpu_next_unpop(chunk, &rs, &re, page_end);
394 if (rs == page_start && re == page_end)
397 /* immutable chunks can't be depopulated */
398 WARN_ON(chunk->immutable);
401 * If control reaches here, there must have been at least one
402 * successful population attempt so the temp pages array must
405 pages = pcpu_get_pages_and_bitmap(chunk, &populated, false);
409 pcpu_pre_unmap_flush(chunk, page_start, page_end);
411 pcpu_for_each_pop_region(chunk, rs, re, page_start, page_end)
412 pcpu_unmap_pages(chunk, pages, populated, rs, re);
414 /* no need to flush tlb, vmalloc will handle it lazily */
416 pcpu_for_each_pop_region(chunk, rs, re, page_start, page_end)
417 pcpu_free_pages(chunk, pages, populated, rs, re);
419 /* commit new bitmap */
420 bitmap_copy(chunk->populated, populated, pcpu_unit_pages);
423 static struct pcpu_chunk *pcpu_create_chunk(void)
425 struct pcpu_chunk *chunk;
426 struct vm_struct **vms;
428 chunk = pcpu_alloc_chunk();
432 vms = pcpu_get_vm_areas(pcpu_group_offsets, pcpu_group_sizes,
433 pcpu_nr_groups, pcpu_atom_size);
435 pcpu_free_chunk(chunk);
440 chunk->base_addr = vms[0]->addr - pcpu_group_offsets[0];
444 static void pcpu_destroy_chunk(struct pcpu_chunk *chunk)
446 if (chunk && chunk->data)
447 pcpu_free_vm_areas(chunk->data, pcpu_nr_groups);
448 pcpu_free_chunk(chunk);
451 static struct page *pcpu_addr_to_page(void *addr)
453 return vmalloc_to_page(addr);
456 static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai)
458 /* no extra restriction */