diff options
Diffstat (limited to 'kernel')
-rw-r--r-- | kernel/Makefile | 3 | ||||
-rw-r--r-- | kernel/early_res.c | 578 | ||||
-rw-r--r-- | kernel/range.c | 163 |
3 files changed, 743 insertions, 1 deletions
diff --git a/kernel/Makefile b/kernel/Makefile index 6aebdeb2aa34..7b974699f8c2 100644 --- a/kernel/Makefile +++ b/kernel/Makefile | |||
@@ -10,7 +10,8 @@ obj-y = sched.o fork.o exec_domain.o panic.o printk.o \ | |||
10 | kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \ | 10 | kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \ |
11 | hrtimer.o rwsem.o nsproxy.o srcu.o semaphore.o \ | 11 | hrtimer.o rwsem.o nsproxy.o srcu.o semaphore.o \ |
12 | notifier.o ksysfs.o pm_qos_params.o sched_clock.o cred.o \ | 12 | notifier.o ksysfs.o pm_qos_params.o sched_clock.o cred.o \ |
13 | async.o | 13 | async.o range.o |
14 | obj-$(CONFIG_HAVE_EARLY_RES) += early_res.o | ||
14 | obj-y += groups.o | 15 | obj-y += groups.o |
15 | 16 | ||
16 | ifdef CONFIG_FUNCTION_TRACER | 17 | ifdef CONFIG_FUNCTION_TRACER |
diff --git a/kernel/early_res.c b/kernel/early_res.c new file mode 100644 index 000000000000..3cb2c661bb78 --- /dev/null +++ b/kernel/early_res.c | |||
@@ -0,0 +1,578 @@ | |||
1 | /* | ||
2 | * early_res, could be used to replace bootmem | ||
3 | */ | ||
4 | #include <linux/kernel.h> | ||
5 | #include <linux/types.h> | ||
6 | #include <linux/init.h> | ||
7 | #include <linux/bootmem.h> | ||
8 | #include <linux/mm.h> | ||
9 | #include <linux/early_res.h> | ||
10 | |||
11 | /* | ||
12 | * Early reserved memory areas. | ||
13 | */ | ||
14 | /* | ||
15 | * need to make sure this one is bigger enough before | ||
16 | * find_fw_memmap_area could be used | ||
17 | */ | ||
18 | #define MAX_EARLY_RES_X 32 | ||
19 | |||
20 | struct early_res { | ||
21 | u64 start, end; | ||
22 | char name[15]; | ||
23 | char overlap_ok; | ||
24 | }; | ||
25 | static struct early_res early_res_x[MAX_EARLY_RES_X] __initdata; | ||
26 | |||
27 | static int max_early_res __initdata = MAX_EARLY_RES_X; | ||
28 | static struct early_res *early_res __initdata = &early_res_x[0]; | ||
29 | static int early_res_count __initdata; | ||
30 | |||
31 | static int __init find_overlapped_early(u64 start, u64 end) | ||
32 | { | ||
33 | int i; | ||
34 | struct early_res *r; | ||
35 | |||
36 | for (i = 0; i < max_early_res && early_res[i].end; i++) { | ||
37 | r = &early_res[i]; | ||
38 | if (end > r->start && start < r->end) | ||
39 | break; | ||
40 | } | ||
41 | |||
42 | return i; | ||
43 | } | ||
44 | |||
45 | /* | ||
46 | * Drop the i-th range from the early reservation map, | ||
47 | * by copying any higher ranges down one over it, and | ||
48 | * clearing what had been the last slot. | ||
49 | */ | ||
50 | static void __init drop_range(int i) | ||
51 | { | ||
52 | int j; | ||
53 | |||
54 | for (j = i + 1; j < max_early_res && early_res[j].end; j++) | ||
55 | ; | ||
56 | |||
57 | memmove(&early_res[i], &early_res[i + 1], | ||
58 | (j - 1 - i) * sizeof(struct early_res)); | ||
59 | |||
60 | early_res[j - 1].end = 0; | ||
61 | early_res_count--; | ||
62 | } | ||
63 | |||
64 | static void __init drop_range_partial(int i, u64 start, u64 end) | ||
65 | { | ||
66 | u64 common_start, common_end; | ||
67 | u64 old_start, old_end; | ||
68 | |||
69 | old_start = early_res[i].start; | ||
70 | old_end = early_res[i].end; | ||
71 | common_start = max(old_start, start); | ||
72 | common_end = min(old_end, end); | ||
73 | |||
74 | /* no overlap ? */ | ||
75 | if (common_start >= common_end) | ||
76 | return; | ||
77 | |||
78 | if (old_start < common_start) { | ||
79 | /* make head segment */ | ||
80 | early_res[i].end = common_start; | ||
81 | if (old_end > common_end) { | ||
82 | char name[15]; | ||
83 | |||
84 | /* | ||
85 | * Save a local copy of the name, since the | ||
86 | * early_res array could get resized inside | ||
87 | * reserve_early_without_check() -> | ||
88 | * __check_and_double_early_res(), which would | ||
89 | * make the current name pointer invalid. | ||
90 | */ | ||
91 | strncpy(name, early_res[i].name, | ||
92 | sizeof(early_res[i].name) - 1); | ||
93 | /* add another for left over on tail */ | ||
94 | reserve_early_without_check(common_end, old_end, name); | ||
95 | } | ||
96 | return; | ||
97 | } else { | ||
98 | if (old_end > common_end) { | ||
99 | /* reuse the entry for tail left */ | ||
100 | early_res[i].start = common_end; | ||
101 | return; | ||
102 | } | ||
103 | /* all covered */ | ||
104 | drop_range(i); | ||
105 | } | ||
106 | } | ||
107 | |||
108 | /* | ||
109 | * Split any existing ranges that: | ||
110 | * 1) are marked 'overlap_ok', and | ||
111 | * 2) overlap with the stated range [start, end) | ||
112 | * into whatever portion (if any) of the existing range is entirely | ||
113 | * below or entirely above the stated range. Drop the portion | ||
114 | * of the existing range that overlaps with the stated range, | ||
115 | * which will allow the caller of this routine to then add that | ||
116 | * stated range without conflicting with any existing range. | ||
117 | */ | ||
118 | static void __init drop_overlaps_that_are_ok(u64 start, u64 end) | ||
119 | { | ||
120 | int i; | ||
121 | struct early_res *r; | ||
122 | u64 lower_start, lower_end; | ||
123 | u64 upper_start, upper_end; | ||
124 | char name[15]; | ||
125 | |||
126 | for (i = 0; i < max_early_res && early_res[i].end; i++) { | ||
127 | r = &early_res[i]; | ||
128 | |||
129 | /* Continue past non-overlapping ranges */ | ||
130 | if (end <= r->start || start >= r->end) | ||
131 | continue; | ||
132 | |||
133 | /* | ||
134 | * Leave non-ok overlaps as is; let caller | ||
135 | * panic "Overlapping early reservations" | ||
136 | * when it hits this overlap. | ||
137 | */ | ||
138 | if (!r->overlap_ok) | ||
139 | return; | ||
140 | |||
141 | /* | ||
142 | * We have an ok overlap. We will drop it from the early | ||
143 | * reservation map, and add back in any non-overlapping | ||
144 | * portions (lower or upper) as separate, overlap_ok, | ||
145 | * non-overlapping ranges. | ||
146 | */ | ||
147 | |||
148 | /* 1. Note any non-overlapping (lower or upper) ranges. */ | ||
149 | strncpy(name, r->name, sizeof(name) - 1); | ||
150 | |||
151 | lower_start = lower_end = 0; | ||
152 | upper_start = upper_end = 0; | ||
153 | if (r->start < start) { | ||
154 | lower_start = r->start; | ||
155 | lower_end = start; | ||
156 | } | ||
157 | if (r->end > end) { | ||
158 | upper_start = end; | ||
159 | upper_end = r->end; | ||
160 | } | ||
161 | |||
162 | /* 2. Drop the original ok overlapping range */ | ||
163 | drop_range(i); | ||
164 | |||
165 | i--; /* resume for-loop on copied down entry */ | ||
166 | |||
167 | /* 3. Add back in any non-overlapping ranges. */ | ||
168 | if (lower_end) | ||
169 | reserve_early_overlap_ok(lower_start, lower_end, name); | ||
170 | if (upper_end) | ||
171 | reserve_early_overlap_ok(upper_start, upper_end, name); | ||
172 | } | ||
173 | } | ||
174 | |||
175 | static void __init __reserve_early(u64 start, u64 end, char *name, | ||
176 | int overlap_ok) | ||
177 | { | ||
178 | int i; | ||
179 | struct early_res *r; | ||
180 | |||
181 | i = find_overlapped_early(start, end); | ||
182 | if (i >= max_early_res) | ||
183 | panic("Too many early reservations"); | ||
184 | r = &early_res[i]; | ||
185 | if (r->end) | ||
186 | panic("Overlapping early reservations " | ||
187 | "%llx-%llx %s to %llx-%llx %s\n", | ||
188 | start, end - 1, name ? name : "", r->start, | ||
189 | r->end - 1, r->name); | ||
190 | r->start = start; | ||
191 | r->end = end; | ||
192 | r->overlap_ok = overlap_ok; | ||
193 | if (name) | ||
194 | strncpy(r->name, name, sizeof(r->name) - 1); | ||
195 | early_res_count++; | ||
196 | } | ||
197 | |||
198 | /* | ||
199 | * A few early reservtations come here. | ||
200 | * | ||
201 | * The 'overlap_ok' in the name of this routine does -not- mean it | ||
202 | * is ok for these reservations to overlap an earlier reservation. | ||
203 | * Rather it means that it is ok for subsequent reservations to | ||
204 | * overlap this one. | ||
205 | * | ||
206 | * Use this entry point to reserve early ranges when you are doing | ||
207 | * so out of "Paranoia", reserving perhaps more memory than you need, | ||
208 | * just in case, and don't mind a subsequent overlapping reservation | ||
209 | * that is known to be needed. | ||
210 | * | ||
211 | * The drop_overlaps_that_are_ok() call here isn't really needed. | ||
212 | * It would be needed if we had two colliding 'overlap_ok' | ||
213 | * reservations, so that the second such would not panic on the | ||
214 | * overlap with the first. We don't have any such as of this | ||
215 | * writing, but might as well tolerate such if it happens in | ||
216 | * the future. | ||
217 | */ | ||
218 | void __init reserve_early_overlap_ok(u64 start, u64 end, char *name) | ||
219 | { | ||
220 | drop_overlaps_that_are_ok(start, end); | ||
221 | __reserve_early(start, end, name, 1); | ||
222 | } | ||
223 | |||
224 | static void __init __check_and_double_early_res(u64 ex_start, u64 ex_end) | ||
225 | { | ||
226 | u64 start, end, size, mem; | ||
227 | struct early_res *new; | ||
228 | |||
229 | /* do we have enough slots left ? */ | ||
230 | if ((max_early_res - early_res_count) > max(max_early_res/8, 2)) | ||
231 | return; | ||
232 | |||
233 | /* double it */ | ||
234 | mem = -1ULL; | ||
235 | size = sizeof(struct early_res) * max_early_res * 2; | ||
236 | if (early_res == early_res_x) | ||
237 | start = 0; | ||
238 | else | ||
239 | start = early_res[0].end; | ||
240 | end = ex_start; | ||
241 | if (start + size < end) | ||
242 | mem = find_fw_memmap_area(start, end, size, | ||
243 | sizeof(struct early_res)); | ||
244 | if (mem == -1ULL) { | ||
245 | start = ex_end; | ||
246 | end = get_max_mapped(); | ||
247 | if (start + size < end) | ||
248 | mem = find_fw_memmap_area(start, end, size, | ||
249 | sizeof(struct early_res)); | ||
250 | } | ||
251 | if (mem == -1ULL) | ||
252 | panic("can not find more space for early_res array"); | ||
253 | |||
254 | new = __va(mem); | ||
255 | /* save the first one for own */ | ||
256 | new[0].start = mem; | ||
257 | new[0].end = mem + size; | ||
258 | new[0].overlap_ok = 0; | ||
259 | /* copy old to new */ | ||
260 | if (early_res == early_res_x) { | ||
261 | memcpy(&new[1], &early_res[0], | ||
262 | sizeof(struct early_res) * max_early_res); | ||
263 | memset(&new[max_early_res+1], 0, | ||
264 | sizeof(struct early_res) * (max_early_res - 1)); | ||
265 | early_res_count++; | ||
266 | } else { | ||
267 | memcpy(&new[1], &early_res[1], | ||
268 | sizeof(struct early_res) * (max_early_res - 1)); | ||
269 | memset(&new[max_early_res], 0, | ||
270 | sizeof(struct early_res) * max_early_res); | ||
271 | } | ||
272 | memset(&early_res[0], 0, sizeof(struct early_res) * max_early_res); | ||
273 | early_res = new; | ||
274 | max_early_res *= 2; | ||
275 | printk(KERN_DEBUG "early_res array is doubled to %d at [%llx - %llx]\n", | ||
276 | max_early_res, mem, mem + size - 1); | ||
277 | } | ||
278 | |||
279 | /* | ||
280 | * Most early reservations come here. | ||
281 | * | ||
282 | * We first have drop_overlaps_that_are_ok() drop any pre-existing | ||
283 | * 'overlap_ok' ranges, so that we can then reserve this memory | ||
284 | * range without risk of panic'ing on an overlapping overlap_ok | ||
285 | * early reservation. | ||
286 | */ | ||
287 | void __init reserve_early(u64 start, u64 end, char *name) | ||
288 | { | ||
289 | if (start >= end) | ||
290 | return; | ||
291 | |||
292 | __check_and_double_early_res(start, end); | ||
293 | |||
294 | drop_overlaps_that_are_ok(start, end); | ||
295 | __reserve_early(start, end, name, 0); | ||
296 | } | ||
297 | |||
298 | void __init reserve_early_without_check(u64 start, u64 end, char *name) | ||
299 | { | ||
300 | struct early_res *r; | ||
301 | |||
302 | if (start >= end) | ||
303 | return; | ||
304 | |||
305 | __check_and_double_early_res(start, end); | ||
306 | |||
307 | r = &early_res[early_res_count]; | ||
308 | |||
309 | r->start = start; | ||
310 | r->end = end; | ||
311 | r->overlap_ok = 0; | ||
312 | if (name) | ||
313 | strncpy(r->name, name, sizeof(r->name) - 1); | ||
314 | early_res_count++; | ||
315 | } | ||
316 | |||
317 | void __init free_early(u64 start, u64 end) | ||
318 | { | ||
319 | struct early_res *r; | ||
320 | int i; | ||
321 | |||
322 | i = find_overlapped_early(start, end); | ||
323 | r = &early_res[i]; | ||
324 | if (i >= max_early_res || r->end != end || r->start != start) | ||
325 | panic("free_early on not reserved area: %llx-%llx!", | ||
326 | start, end - 1); | ||
327 | |||
328 | drop_range(i); | ||
329 | } | ||
330 | |||
331 | void __init free_early_partial(u64 start, u64 end) | ||
332 | { | ||
333 | struct early_res *r; | ||
334 | int i; | ||
335 | |||
336 | try_next: | ||
337 | i = find_overlapped_early(start, end); | ||
338 | if (i >= max_early_res) | ||
339 | return; | ||
340 | |||
341 | r = &early_res[i]; | ||
342 | /* hole ? */ | ||
343 | if (r->end >= end && r->start <= start) { | ||
344 | drop_range_partial(i, start, end); | ||
345 | return; | ||
346 | } | ||
347 | |||
348 | drop_range_partial(i, start, end); | ||
349 | goto try_next; | ||
350 | } | ||
351 | |||
352 | #ifdef CONFIG_NO_BOOTMEM | ||
353 | static void __init subtract_early_res(struct range *range, int az) | ||
354 | { | ||
355 | int i, count; | ||
356 | u64 final_start, final_end; | ||
357 | int idx = 0; | ||
358 | |||
359 | count = 0; | ||
360 | for (i = 0; i < max_early_res && early_res[i].end; i++) | ||
361 | count++; | ||
362 | |||
363 | /* need to skip first one ?*/ | ||
364 | if (early_res != early_res_x) | ||
365 | idx = 1; | ||
366 | |||
367 | #define DEBUG_PRINT_EARLY_RES 1 | ||
368 | |||
369 | #if DEBUG_PRINT_EARLY_RES | ||
370 | printk(KERN_INFO "Subtract (%d early reservations)\n", count); | ||
371 | #endif | ||
372 | for (i = idx; i < count; i++) { | ||
373 | struct early_res *r = &early_res[i]; | ||
374 | #if DEBUG_PRINT_EARLY_RES | ||
375 | printk(KERN_INFO " #%d [%010llx - %010llx] %15s\n", i, | ||
376 | r->start, r->end, r->name); | ||
377 | #endif | ||
378 | final_start = PFN_DOWN(r->start); | ||
379 | final_end = PFN_UP(r->end); | ||
380 | if (final_start >= final_end) | ||
381 | continue; | ||
382 | subtract_range(range, az, final_start, final_end); | ||
383 | } | ||
384 | |||
385 | } | ||
386 | |||
387 | int __init get_free_all_memory_range(struct range **rangep, int nodeid) | ||
388 | { | ||
389 | int i, count; | ||
390 | u64 start = 0, end; | ||
391 | u64 size; | ||
392 | u64 mem; | ||
393 | struct range *range; | ||
394 | int nr_range; | ||
395 | |||
396 | count = 0; | ||
397 | for (i = 0; i < max_early_res && early_res[i].end; i++) | ||
398 | count++; | ||
399 | |||
400 | count *= 2; | ||
401 | |||
402 | size = sizeof(struct range) * count; | ||
403 | end = get_max_mapped(); | ||
404 | #ifdef MAX_DMA32_PFN | ||
405 | if (end > (MAX_DMA32_PFN << PAGE_SHIFT)) | ||
406 | start = MAX_DMA32_PFN << PAGE_SHIFT; | ||
407 | #endif | ||
408 | mem = find_fw_memmap_area(start, end, size, sizeof(struct range)); | ||
409 | if (mem == -1ULL) | ||
410 | panic("can not find more space for range free"); | ||
411 | |||
412 | range = __va(mem); | ||
413 | /* use early_node_map[] and early_res to get range array at first */ | ||
414 | memset(range, 0, size); | ||
415 | nr_range = 0; | ||
416 | |||
417 | /* need to go over early_node_map to find out good range for node */ | ||
418 | nr_range = add_from_early_node_map(range, count, nr_range, nodeid); | ||
419 | #ifdef CONFIG_X86_32 | ||
420 | subtract_range(range, count, max_low_pfn, -1ULL); | ||
421 | #endif | ||
422 | subtract_early_res(range, count); | ||
423 | nr_range = clean_sort_range(range, count); | ||
424 | |||
425 | /* need to clear it ? */ | ||
426 | if (nodeid == MAX_NUMNODES) { | ||
427 | memset(&early_res[0], 0, | ||
428 | sizeof(struct early_res) * max_early_res); | ||
429 | early_res = NULL; | ||
430 | max_early_res = 0; | ||
431 | } | ||
432 | |||
433 | *rangep = range; | ||
434 | return nr_range; | ||
435 | } | ||
436 | #else | ||
437 | void __init early_res_to_bootmem(u64 start, u64 end) | ||
438 | { | ||
439 | int i, count; | ||
440 | u64 final_start, final_end; | ||
441 | int idx = 0; | ||
442 | |||
443 | count = 0; | ||
444 | for (i = 0; i < max_early_res && early_res[i].end; i++) | ||
445 | count++; | ||
446 | |||
447 | /* need to skip first one ?*/ | ||
448 | if (early_res != early_res_x) | ||
449 | idx = 1; | ||
450 | |||
451 | printk(KERN_INFO "(%d/%d early reservations) ==> bootmem [%010llx - %010llx]\n", | ||
452 | count - idx, max_early_res, start, end); | ||
453 | for (i = idx; i < count; i++) { | ||
454 | struct early_res *r = &early_res[i]; | ||
455 | printk(KERN_INFO " #%d [%010llx - %010llx] %16s", i, | ||
456 | r->start, r->end, r->name); | ||
457 | final_start = max(start, r->start); | ||
458 | final_end = min(end, r->end); | ||
459 | if (final_start >= final_end) { | ||
460 | printk(KERN_CONT "\n"); | ||
461 | continue; | ||
462 | } | ||
463 | printk(KERN_CONT " ==> [%010llx - %010llx]\n", | ||
464 | final_start, final_end); | ||
465 | reserve_bootmem_generic(final_start, final_end - final_start, | ||
466 | BOOTMEM_DEFAULT); | ||
467 | } | ||
468 | /* clear them */ | ||
469 | memset(&early_res[0], 0, sizeof(struct early_res) * max_early_res); | ||
470 | early_res = NULL; | ||
471 | max_early_res = 0; | ||
472 | early_res_count = 0; | ||
473 | } | ||
474 | #endif | ||
475 | |||
476 | /* Check for already reserved areas */ | ||
477 | static inline int __init bad_addr(u64 *addrp, u64 size, u64 align) | ||
478 | { | ||
479 | int i; | ||
480 | u64 addr = *addrp; | ||
481 | int changed = 0; | ||
482 | struct early_res *r; | ||
483 | again: | ||
484 | i = find_overlapped_early(addr, addr + size); | ||
485 | r = &early_res[i]; | ||
486 | if (i < max_early_res && r->end) { | ||
487 | *addrp = addr = round_up(r->end, align); | ||
488 | changed = 1; | ||
489 | goto again; | ||
490 | } | ||
491 | return changed; | ||
492 | } | ||
493 | |||
494 | /* Check for already reserved areas */ | ||
495 | static inline int __init bad_addr_size(u64 *addrp, u64 *sizep, u64 align) | ||
496 | { | ||
497 | int i; | ||
498 | u64 addr = *addrp, last; | ||
499 | u64 size = *sizep; | ||
500 | int changed = 0; | ||
501 | again: | ||
502 | last = addr + size; | ||
503 | for (i = 0; i < max_early_res && early_res[i].end; i++) { | ||
504 | struct early_res *r = &early_res[i]; | ||
505 | if (last > r->start && addr < r->start) { | ||
506 | size = r->start - addr; | ||
507 | changed = 1; | ||
508 | goto again; | ||
509 | } | ||
510 | if (last > r->end && addr < r->end) { | ||
511 | addr = round_up(r->end, align); | ||
512 | size = last - addr; | ||
513 | changed = 1; | ||
514 | goto again; | ||
515 | } | ||
516 | if (last <= r->end && addr >= r->start) { | ||
517 | (*sizep)++; | ||
518 | return 0; | ||
519 | } | ||
520 | } | ||
521 | if (changed) { | ||
522 | *addrp = addr; | ||
523 | *sizep = size; | ||
524 | } | ||
525 | return changed; | ||
526 | } | ||
527 | |||
528 | /* | ||
529 | * Find a free area with specified alignment in a specific range. | ||
530 | * only with the area.between start to end is active range from early_node_map | ||
531 | * so they are good as RAM | ||
532 | */ | ||
533 | u64 __init find_early_area(u64 ei_start, u64 ei_last, u64 start, u64 end, | ||
534 | u64 size, u64 align) | ||
535 | { | ||
536 | u64 addr, last; | ||
537 | |||
538 | addr = round_up(ei_start, align); | ||
539 | if (addr < start) | ||
540 | addr = round_up(start, align); | ||
541 | if (addr >= ei_last) | ||
542 | goto out; | ||
543 | while (bad_addr(&addr, size, align) && addr+size <= ei_last) | ||
544 | ; | ||
545 | last = addr + size; | ||
546 | if (last > ei_last) | ||
547 | goto out; | ||
548 | if (last > end) | ||
549 | goto out; | ||
550 | |||
551 | return addr; | ||
552 | |||
553 | out: | ||
554 | return -1ULL; | ||
555 | } | ||
556 | |||
557 | u64 __init find_early_area_size(u64 ei_start, u64 ei_last, u64 start, | ||
558 | u64 *sizep, u64 align) | ||
559 | { | ||
560 | u64 addr, last; | ||
561 | |||
562 | addr = round_up(ei_start, align); | ||
563 | if (addr < start) | ||
564 | addr = round_up(start, align); | ||
565 | if (addr >= ei_last) | ||
566 | goto out; | ||
567 | *sizep = ei_last - addr; | ||
568 | while (bad_addr_size(&addr, sizep, align) && addr + *sizep <= ei_last) | ||
569 | ; | ||
570 | last = addr + *sizep; | ||
571 | if (last > ei_last) | ||
572 | goto out; | ||
573 | |||
574 | return addr; | ||
575 | |||
576 | out: | ||
577 | return -1ULL; | ||
578 | } | ||
diff --git a/kernel/range.c b/kernel/range.c new file mode 100644 index 000000000000..74e2e6114927 --- /dev/null +++ b/kernel/range.c | |||
@@ -0,0 +1,163 @@ | |||
1 | /* | ||
2 | * Range add and subtract | ||
3 | */ | ||
4 | #include <linux/module.h> | ||
5 | #include <linux/init.h> | ||
6 | #include <linux/sort.h> | ||
7 | |||
8 | #include <linux/range.h> | ||
9 | |||
10 | #ifndef ARRAY_SIZE | ||
11 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
12 | #endif | ||
13 | |||
14 | int add_range(struct range *range, int az, int nr_range, u64 start, u64 end) | ||
15 | { | ||
16 | if (start >= end) | ||
17 | return nr_range; | ||
18 | |||
19 | /* Out of slots: */ | ||
20 | if (nr_range >= az) | ||
21 | return nr_range; | ||
22 | |||
23 | range[nr_range].start = start; | ||
24 | range[nr_range].end = end; | ||
25 | |||
26 | nr_range++; | ||
27 | |||
28 | return nr_range; | ||
29 | } | ||
30 | |||
31 | int add_range_with_merge(struct range *range, int az, int nr_range, | ||
32 | u64 start, u64 end) | ||
33 | { | ||
34 | int i; | ||
35 | |||
36 | if (start >= end) | ||
37 | return nr_range; | ||
38 | |||
39 | /* Try to merge it with old one: */ | ||
40 | for (i = 0; i < nr_range; i++) { | ||
41 | u64 final_start, final_end; | ||
42 | u64 common_start, common_end; | ||
43 | |||
44 | if (!range[i].end) | ||
45 | continue; | ||
46 | |||
47 | common_start = max(range[i].start, start); | ||
48 | common_end = min(range[i].end, end); | ||
49 | if (common_start > common_end) | ||
50 | continue; | ||
51 | |||
52 | final_start = min(range[i].start, start); | ||
53 | final_end = max(range[i].end, end); | ||
54 | |||
55 | range[i].start = final_start; | ||
56 | range[i].end = final_end; | ||
57 | return nr_range; | ||
58 | } | ||
59 | |||
60 | /* Need to add it: */ | ||
61 | return add_range(range, az, nr_range, start, end); | ||
62 | } | ||
63 | |||
64 | void subtract_range(struct range *range, int az, u64 start, u64 end) | ||
65 | { | ||
66 | int i, j; | ||
67 | |||
68 | if (start >= end) | ||
69 | return; | ||
70 | |||
71 | for (j = 0; j < az; j++) { | ||
72 | if (!range[j].end) | ||
73 | continue; | ||
74 | |||
75 | if (start <= range[j].start && end >= range[j].end) { | ||
76 | range[j].start = 0; | ||
77 | range[j].end = 0; | ||
78 | continue; | ||
79 | } | ||
80 | |||
81 | if (start <= range[j].start && end < range[j].end && | ||
82 | range[j].start < end) { | ||
83 | range[j].start = end; | ||
84 | continue; | ||
85 | } | ||
86 | |||
87 | |||
88 | if (start > range[j].start && end >= range[j].end && | ||
89 | range[j].end > start) { | ||
90 | range[j].end = start; | ||
91 | continue; | ||
92 | } | ||
93 | |||
94 | if (start > range[j].start && end < range[j].end) { | ||
95 | /* Find the new spare: */ | ||
96 | for (i = 0; i < az; i++) { | ||
97 | if (range[i].end == 0) | ||
98 | break; | ||
99 | } | ||
100 | if (i < az) { | ||
101 | range[i].end = range[j].end; | ||
102 | range[i].start = end; | ||
103 | } else { | ||
104 | printk(KERN_ERR "run of slot in ranges\n"); | ||
105 | } | ||
106 | range[j].end = start; | ||
107 | continue; | ||
108 | } | ||
109 | } | ||
110 | } | ||
111 | |||
112 | static int cmp_range(const void *x1, const void *x2) | ||
113 | { | ||
114 | const struct range *r1 = x1; | ||
115 | const struct range *r2 = x2; | ||
116 | s64 start1, start2; | ||
117 | |||
118 | start1 = r1->start; | ||
119 | start2 = r2->start; | ||
120 | |||
121 | return start1 - start2; | ||
122 | } | ||
123 | |||
124 | int clean_sort_range(struct range *range, int az) | ||
125 | { | ||
126 | int i, j, k = az - 1, nr_range = 0; | ||
127 | |||
128 | for (i = 0; i < k; i++) { | ||
129 | if (range[i].end) | ||
130 | continue; | ||
131 | for (j = k; j > i; j--) { | ||
132 | if (range[j].end) { | ||
133 | k = j; | ||
134 | break; | ||
135 | } | ||
136 | } | ||
137 | if (j == i) | ||
138 | break; | ||
139 | range[i].start = range[k].start; | ||
140 | range[i].end = range[k].end; | ||
141 | range[k].start = 0; | ||
142 | range[k].end = 0; | ||
143 | k--; | ||
144 | } | ||
145 | /* count it */ | ||
146 | for (i = 0; i < az; i++) { | ||
147 | if (!range[i].end) { | ||
148 | nr_range = i; | ||
149 | break; | ||
150 | } | ||
151 | } | ||
152 | |||
153 | /* sort them */ | ||
154 | sort(range, nr_range, sizeof(struct range), cmp_range, NULL); | ||
155 | |||
156 | return nr_range; | ||
157 | } | ||
158 | |||
159 | void sort_range(struct range *range, int nr_range) | ||
160 | { | ||
161 | /* sort them */ | ||
162 | sort(range, nr_range, sizeof(struct range), cmp_range, NULL); | ||
163 | } | ||