Add some more functions that will be used in memory-device context.

range_init(): Init using lower bound and size, check for validity
range_init_nofail(): Init using lower bound and size, validity asserted
range_size(): Extract the size of a range
range_overlaps_range(): Check for overlaps of two ranges
range_contains_range(): Check if one range is contained in the other

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/qemu/range.h | 62 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/include/qemu/range.h b/include/qemu/range.h
index 7e75f4e655..ba606c6bc0 100644
--- a/include/qemu/range.h
+++ b/include/qemu/range.h
@@ -112,6 +112,68 @@ static inline uint64_t range_upb(Range *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.
  */
-- 
2.17.1

On Tue, 23 Oct 2018 17:23:03 +0200
David Hildenbrand <david@redhat.com> wrote:

> Add some more functions that will be used in memory-device context.
> 
> range_init(): Init using lower bound and size, check for validity
> range_init_nofail(): Init using lower bound and size, validity asserted
> range_size(): Extract the size of a range
> range_overlaps_range(): Check for overlaps of two ranges
> range_contains_range(): Check if one range is contained in the other
> 
> Signed-off-by: David Hildenbrand <david@redhat.com>
> ---
>  include/qemu/range.h | 62 ++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 62 insertions(+)
> 
> diff --git a/include/qemu/range.h b/include/qemu/range.h
> index 7e75f4e655..ba606c6bc0 100644
> --- a/include/qemu/range.h
> +++ b/include/qemu/range.h
> @@ -112,6 +112,68 @@ static inline uint64_t range_upb(Range *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)) {
compilation fails with:
 "error: passing argument 1 of ‘range_is_empty’ discards ‘const’ qualifier from pointer target type [-Werror]"

the same for range_invariant,
following should fix issues:

diff --git a/include/qemu/range.h b/include/qemu/range.h
index 3586eb1..4b05bd1 100644
--- a/include/qemu/range.h
+++ b/include/qemu/range.h
@@ -39,7 +39,7 @@ struct Range {
     uint64_t upb;        /* inclusive upper bound */
 };
 
-static inline void range_invariant(Range *range)
+static inline void range_invariant(const Range *range)
 {
     assert(range->lob <= range->upb || range->lob == range->upb + 1);
 }
@@ -48,7 +48,7 @@ static inline void range_invariant(Range *range)
 #define range_empty ((Range){ .lob = 1, .upb = 0 })
 
 /* Is @range empty? */
-static inline bool range_is_empty(Range *range)
+static inline bool range_is_empty(const Range *range)
 {
     range_invariant(range);
     return range->lob > range->upb;



> +        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.
>   */

On 01.11.18 11:00, Igor Mammedov wrote:
> On Tue, 23 Oct 2018 17:23:03 +0200
> David Hildenbrand <david@redhat.com> wrote:
> 
>> Add some more functions that will be used in memory-device context.
>>
>> range_init(): Init using lower bound and size, check for validity
>> range_init_nofail(): Init using lower bound and size, validity asserted
>> range_size(): Extract the size of a range
>> range_overlaps_range(): Check for overlaps of two ranges
>> range_contains_range(): Check if one range is contained in the other
>>
>> Signed-off-by: David Hildenbrand <david@redhat.com>
>> ---
>>  include/qemu/range.h | 62 ++++++++++++++++++++++++++++++++++++++++++++
>>  1 file changed, 62 insertions(+)
>>
>> diff --git a/include/qemu/range.h b/include/qemu/range.h
>> index 7e75f4e655..ba606c6bc0 100644
>> --- a/include/qemu/range.h
>> +++ b/include/qemu/range.h
>> @@ -112,6 +112,68 @@ static inline uint64_t range_upb(Range *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)) {
> compilation fails with:
>  "error: passing argument 1 of ‘range_is_empty’ discards ‘const’ qualifier from pointer target type [-Werror]"
> 
> the same for range_invariant,
> following should fix issues:

I guess you missed patch #3.


-- 

Thanks,

David / dhildenb

On Thu, 1 Nov 2018 11:29:51 +0100
David Hildenbrand <david@redhat.com> wrote:

> On 01.11.18 11:00, Igor Mammedov wrote:
> > On Tue, 23 Oct 2018 17:23:03 +0200
> > David Hildenbrand <david@redhat.com> wrote:
> >   
> >> Add some more functions that will be used in memory-device context.
> >>
> >> range_init(): Init using lower bound and size, check for validity
> >> range_init_nofail(): Init using lower bound and size, validity asserted
> >> range_size(): Extract the size of a range
> >> range_overlaps_range(): Check for overlaps of two ranges
> >> range_contains_range(): Check if one range is contained in the other
> >>
> >> Signed-off-by: David Hildenbrand <david@redhat.com>
> >> ---
> >>  include/qemu/range.h | 62 ++++++++++++++++++++++++++++++++++++++++++++
> >>  1 file changed, 62 insertions(+)
> >>
> >> diff --git a/include/qemu/range.h b/include/qemu/range.h
> >> index 7e75f4e655..ba606c6bc0 100644
> >> --- a/include/qemu/range.h
> >> +++ b/include/qemu/range.h
> >> @@ -112,6 +112,68 @@ static inline uint64_t range_upb(Range *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)) {  
> > compilation fails with:
> >  "error: passing argument 1 of ‘range_is_empty’ discards ‘const’ qualifier from pointer target type [-Werror]"
> > 
> > the same for range_invariant,
> > following should fix issues:  
> 
> I guess you missed patch #3.
Yep, I was applying it randomly. I'd squash 3 and 4 but considering 3
it already queued  there is no point in doing so.

Reviewed-by: Igor Mammedov <imammedo@redhat.com>

On 01.11.18 12:05, Igor Mammedov wrote:
> On Thu, 1 Nov 2018 11:29:51 +0100
> David Hildenbrand <david@redhat.com> wrote:
> 
>> On 01.11.18 11:00, Igor Mammedov wrote:
>>> On Tue, 23 Oct 2018 17:23:03 +0200
>>> David Hildenbrand <david@redhat.com> wrote:
>>>   
>>>> Add some more functions that will be used in memory-device context.
>>>>
>>>> range_init(): Init using lower bound and size, check for validity
>>>> range_init_nofail(): Init using lower bound and size, validity asserted
>>>> range_size(): Extract the size of a range
>>>> range_overlaps_range(): Check for overlaps of two ranges
>>>> range_contains_range(): Check if one range is contained in the other
>>>>
>>>> Signed-off-by: David Hildenbrand <david@redhat.com>
>>>> ---
>>>>  include/qemu/range.h | 62 ++++++++++++++++++++++++++++++++++++++++++++
>>>>  1 file changed, 62 insertions(+)
>>>>
>>>> diff --git a/include/qemu/range.h b/include/qemu/range.h
>>>> index 7e75f4e655..ba606c6bc0 100644
>>>> --- a/include/qemu/range.h
>>>> +++ b/include/qemu/range.h
>>>> @@ -112,6 +112,68 @@ static inline uint64_t range_upb(Range *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)) {  
>>> compilation fails with:
>>>  "error: passing argument 1 of ‘range_is_empty’ discards ‘const’ qualifier from pointer target type [-Werror]"
>>>
>>> the same for range_invariant,
>>> following should fix issues:  
>>
>> I guess you missed patch #3.
> Yep, I was applying it randomly. I'd squash 3 and 4 but considering 3
> it already queued  there is no point in doing so.
> 
> Reviewed-by: Igor Mammedov <imammedo@redhat.com>
> 

Thanks Igor, would be great if you (or one of the other CC people) could
have a look at the remaining patch #7. Thanks!

-- 

Thanks,

David / dhildenb