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
|
// Copyright 2017 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//! Represents an address in the guest's memory space.
use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
use std::ops::{BitAnd, BitOr};
/// Represents an Address in the guest's memory.
#[derive(Clone, Copy, Debug)]
pub struct GuestAddress(pub u64);
impl GuestAddress {
/// Returns the offset from this address to the given base address.
///
/// # Examples
///
/// ```
/// # use sys_util::GuestAddress;
/// let base = GuestAddress(0x100);
/// let addr = GuestAddress(0x150);
/// assert_eq!(addr.offset_from(base), 0x50u64);
/// ```
pub fn offset_from(&self, base: GuestAddress) -> u64 {
self.0 - base.0
}
/// Returns the address as a u64 offset from 0x0.
/// Use this when a raw number is needed to pass to the kernel.
pub fn offset(&self) -> u64 {
self.0
}
/// Returns the result of the add or None if there is overflow.
pub fn checked_add(&self, other: u64) -> Option<GuestAddress> {
self.0.checked_add(other).map(GuestAddress)
}
/// Returns the result of the base address + the size.
/// Only use this when `offset` is guaranteed not to overflow.
pub fn unchecked_add(&self, offset: u64) -> GuestAddress {
GuestAddress(self.0 + offset)
}
/// Returns the result of the subtraction of None if there is underflow.
pub fn checked_sub(&self, other: u64) -> Option<GuestAddress> {
self.0.checked_sub(other).map(GuestAddress)
}
/// Returns the bitwise and of the address with the given mask.
pub fn mask(&self, mask: u64) -> GuestAddress {
GuestAddress(self.0 & mask as u64)
}
}
impl BitAnd<u64> for GuestAddress {
type Output = GuestAddress;
fn bitand(self, other: u64) -> GuestAddress {
GuestAddress(self.0 & other as u64)
}
}
impl BitOr<u64> for GuestAddress {
type Output = GuestAddress;
fn bitor(self, other: u64) -> GuestAddress {
GuestAddress(self.0 | other as u64)
}
}
impl PartialEq for GuestAddress {
fn eq(&self, other: &GuestAddress) -> bool {
self.0 == other.0
}
}
impl Eq for GuestAddress {}
impl Ord for GuestAddress {
fn cmp(&self, other: &GuestAddress) -> Ordering {
self.0.cmp(&other.0)
}
}
impl PartialOrd for GuestAddress {
fn partial_cmp(&self, other: &GuestAddress) -> Option<Ordering> {
Some(self.cmp(other))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn equals() {
let a = GuestAddress(0x300);
let b = GuestAddress(0x300);
let c = GuestAddress(0x301);
assert_eq!(a, b);
assert_eq!(b, a);
assert_ne!(a, c);
assert_ne!(c, a);
}
#[test]
fn cmp() {
let a = GuestAddress(0x300);
let b = GuestAddress(0x301);
assert!(a < b);
assert!(b > a);
assert!(!(a < a));
}
#[test]
fn mask() {
let a = GuestAddress(0x5050);
assert_eq!(GuestAddress(0x5000), a & 0xff00u64);
assert_eq!(GuestAddress(0x5055), a | 0x0005u64);
}
#[test]
fn add_sub() {
let a = GuestAddress(0x50);
let b = GuestAddress(0x60);
assert_eq!(Some(GuestAddress(0xb0)), a.checked_add(0x60));
assert_eq!(0x10, b.offset_from(a));
}
#[test]
fn checked_add_overflow() {
let a = GuestAddress(0xffffffffffffff55);
assert_eq!(Some(GuestAddress(0xffffffffffffff57)), a.checked_add(2));
assert!(a.checked_add(0xf0).is_none());
}
}
|