numa: add -numa node,memdev= option
[qemu.git] / include / qemu / range.h
1 #ifndef QEMU_RANGE_H
2 #define QEMU_RANGE_H
3
4 #include <inttypes.h>
5 #include <qemu/typedefs.h>
6 #include "qemu/queue.h"
7
8 /*
9 * Operations on 64 bit address ranges.
10 * Notes:
11 * - ranges must not wrap around 0, but can include the last byte ~0x0LL.
12 * - this can not represent a full 0 to ~0x0LL range.
13 */
14
15 /* A structure representing a range of addresses. */
16 struct Range {
17 uint64_t begin; /* First byte of the range, or 0 if empty. */
18 uint64_t end; /* 1 + the last byte. 0 if range empty or ends at ~0x0LL. */
19 };
20
21 static inline void range_extend(Range *range, Range *extend_by)
22 {
23 if (!extend_by->begin && !extend_by->end) {
24 return;
25 }
26 if (!range->begin && !range->end) {
27 *range = *extend_by;
28 return;
29 }
30 if (range->begin > extend_by->begin) {
31 range->begin = extend_by->begin;
32 }
33 /* Compare last byte in case region ends at ~0x0LL */
34 if (range->end - 1 < extend_by->end - 1) {
35 range->end = extend_by->end;
36 }
37 }
38
39 /* Get last byte of a range from offset + length.
40 * Undefined for ranges that wrap around 0. */
41 static inline uint64_t range_get_last(uint64_t offset, uint64_t len)
42 {
43 return offset + len - 1;
44 }
45
46 /* Check whether a given range covers a given byte. */
47 static inline int range_covers_byte(uint64_t offset, uint64_t len,
48 uint64_t byte)
49 {
50 return offset <= byte && byte <= range_get_last(offset, len);
51 }
52
53 /* Check whether 2 given ranges overlap.
54 * Undefined if ranges that wrap around 0. */
55 static inline int ranges_overlap(uint64_t first1, uint64_t len1,
56 uint64_t first2, uint64_t len2)
57 {
58 uint64_t last1 = range_get_last(first1, len1);
59 uint64_t last2 = range_get_last(first2, len2);
60
61 return !(last2 < first1 || last1 < first2);
62 }
63
64 /* 0,1 can merge with 1,2 but don't overlap */
65 static inline bool ranges_can_merge(Range *range1, Range *range2)
66 {
67 return !(range1->end < range2->begin || range2->end < range1->begin);
68 }
69
70 static inline int range_merge(Range *range1, Range *range2)
71 {
72 if (ranges_can_merge(range1, range2)) {
73 if (range1->end < range2->end) {
74 range1->end = range2->end;
75 }
76 if (range1->begin > range2->begin) {
77 range1->begin = range2->begin;
78 }
79 return 0;
80 }
81
82 return -1;
83 }
84
85 static inline GList *g_list_insert_sorted_merged(GList *list,
86 gpointer data,
87 GCompareFunc func)
88 {
89 GList *l, *next = NULL;
90 Range *r, *nextr;
91
92 if (!list) {
93 list = g_list_insert_sorted(list, data, func);
94 return list;
95 }
96
97 nextr = data;
98 l = list;
99 while (l && l != next && nextr) {
100 r = l->data;
101 if (ranges_can_merge(r, nextr)) {
102 range_merge(r, nextr);
103 l = g_list_remove_link(l, next);
104 next = g_list_next(l);
105 if (next) {
106 nextr = next->data;
107 } else {
108 nextr = NULL;
109 }
110 } else {
111 l = g_list_next(l);
112 }
113 }
114
115 if (!l) {
116 list = g_list_insert_sorted(list, data, func);
117 }
118
119 return list;
120 }
121
122 static inline gint range_compare(gconstpointer a, gconstpointer b)
123 {
124 Range *ra = (Range *)a, *rb = (Range *)b;
125 if (ra->begin == rb->begin && ra->end == rb->end) {
126 return 0;
127 } else if (range_get_last(ra->begin, ra->end) <
128 range_get_last(rb->begin, rb->end)) {
129 return -1;
130 } else {
131 return 1;
132 }
133 }
134
135 #endif