1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
/*
* QEMU 64-bit address ranges
*
* Copyright (c) 2015-2016 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef QEMU_RANGE_H
#define QEMU_RANGE_H
#include "qemu/queue.h"
/*
* Operations on 64 bit address ranges.
* Notes:
* - Ranges must not wrap around 0, but can include UINT64_MAX.
*/
struct Range {
/*
* Do not access members directly, use the functions!
* A non-empty range has @lob <= @upb.
* An empty range has @lob == @upb + 1.
*/
uint64_t lob; /* inclusive lower bound */
uint64_t upb; /* inclusive upper bound */
};
static inline void range_invariant(const Range *range)
{
assert(range->lob <= range->upb || range->lob == range->upb + 1);
}
/* Compound literal encoding the empty range */
#define range_empty ((Range){ .lob = 1, .upb = 0 })
/* Is @range empty? */
static inline bool range_is_empty(const Range *range)
{
range_invariant(range);
return range->lob > range->upb;
}
/* Does @range contain @val? */
static inline bool range_contains(const Range *range, uint64_t val)
{
return val >= range->lob && val <= range->upb;
}
/* Initialize @range to the empty range */
static inline void range_make_empty(Range *range)
{
*range = range_empty;
assert(range_is_empty(range));
}
/*
* Initialize @range to span the interval [@lob,@upb].
* Both bounds are inclusive.
* The interval must not be empty, i.e. @lob must be less than or
* equal @upb.
*/
static inline void range_set_bounds(Range *range, uint64_t lob, uint64_t upb)
{
range->lob = lob;
range->upb = upb;
assert(!range_is_empty(range));
}
/*
* Initialize @range to span the interval [@lob,@upb_plus1).
* The lower bound is inclusive, the upper bound is exclusive.
* Zero @upb_plus1 is special: if @lob is also zero, set @range to the
* empty range. Else, set @range to [@lob,UINT64_MAX].
*/
static inline void range_set_bounds1(Range *range,
uint64_t lob, uint64_t upb_plus1)
{
if (!lob && !upb_plus1) {
*range = range_empty;
} else {
range->lob = lob;
range->upb = upb_plus1 - 1;
}
range_invariant(range);
}
/* Return @range's lower bound. @range must not be empty. */
static inline uint64_t range_lob(Range *range)
{
assert(!range_is_empty(range));
return range->lob;
}
/* Return @range's upper bound. @range must not be empty. */
static inline uint64_t range_upb(Range *range)
{
assert(!range_is_empty(range));
return range->upb;
}
/*
* Initialize @range to span the interval [@lob,@lob + @size - 1].
* @size may be 0. If the range would overflow, returns -ERANGE, otherwise
* 0.
*/
static inline int QEMU_WARN_UNUSED_RESULT range_init(Range *range, uint64_t lob,
uint64_t size)
{
if (lob + size < lob) {
return -ERANGE;
}
range->lob = lob;
range->upb = lob + size - 1;
range_invariant(range);
return 0;
}
/*
* Initialize @range to span the interval [@lob,@lob + @size - 1].
* @size may be 0. Range must not overflow.
*/
static inline void range_init_nofail(Range *range, uint64_t lob, uint64_t size)
{
range->lob = lob;
range->upb = lob + size - 1;
range_invariant(range);
}
/*
* Get the size of @range.
*/
static inline uint64_t range_size(const Range *range)
{
return range->upb - range->lob + 1;
}
/*
* Check if @range1 overlaps with @range2. If one of the ranges is empty,
* the result is always "false".
*/
static inline bool range_overlaps_range(const Range *range1,
const Range *range2)
{
if (range_is_empty(range1) || range_is_empty(range2)) {
return false;
}
return !(range2->upb < range1->lob || range1->upb < range2->lob);
}
/*
* Check if @range1 contains @range2. If one of the ranges is empty,
* the result is always "false".
*/
static inline bool range_contains_range(const Range *range1,
const Range *range2)
{
if (range_is_empty(range1) || range_is_empty(range2)) {
return false;
}
return range1->lob <= range2->lob && range1->upb >= range2->upb;
}
/*
* Extend @range to the smallest interval that includes @extend_by, too.
*/
static inline void range_extend(Range *range, Range *extend_by)
{
if (range_is_empty(extend_by)) {
return;
}
if (range_is_empty(range)) {
*range = *extend_by;
return;
}
if (range->lob > extend_by->lob) {
range->lob = extend_by->lob;
}
if (range->upb < extend_by->upb) {
range->upb = extend_by->upb;
}
range_invariant(range);
}
/* Get last byte of a range from offset + length.
* Undefined for ranges that wrap around 0. */
static inline uint64_t range_get_last(uint64_t offset, uint64_t len)
{
return offset + len - 1;
}
/* Check whether a given range covers a given byte. */
static inline int range_covers_byte(uint64_t offset, uint64_t len,
uint64_t byte)
{
return offset <= byte && byte <= range_get_last(offset, len);
}
/* Check whether 2 given ranges overlap.
* Undefined if ranges that wrap around 0. */
static inline int ranges_overlap(uint64_t first1, uint64_t len1,
uint64_t first2, uint64_t len2)
{
uint64_t last1 = range_get_last(first1, len1);
uint64_t last2 = range_get_last(first2, len2);
return !(last2 < first1 || last1 < first2);
}
GList *range_list_insert(GList *list, Range *data);
#endif
|
