yanguangshaonian
/
aya
mirror of https://github.com/aya-rs/aya
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

maps: move MapsIter/MapsKeys from hash_map.rs to the parent module

Browse Source
pull/1/head
Alessandro Decina 4 years ago
parent 72e43aae1a
commit 83f57447dc
2 changed files with 105 additions and 120 deletions
Show Stats Download Patch File Download Diff File

132
src/maps/hash_map.rs
Unescape Escape View File

@ -1,16 +1,15 @@
use std::{convert::TryFrom, marker::PhantomData, mem, os::unix::prelude::RawFd};
use std::{convert::TryFrom, marker::PhantomData, mem};
use crate::{
generated::bpf_map_type::BPF_MAP_TYPE_HASH,
maps::{IterableMap, Map, MapError, MapIter, MapKeys},
syscalls::{
bpf_map_delete_elem, bpf_map_get_next_key, bpf_map_lookup_and_delete_elem,
bpf_map_lookup_elem, bpf_map_update_elem,
bpf_map_delete_elem, bpf_map_lookup_and_delete_elem, bpf_map_lookup_elem,
bpf_map_update_elem,
},
Pod, RawFd,
};
use super::{Map, MapError};
use crate::Pod;
pub struct HashMap<T: AsRef<Map>, K, V> {
inner: T,
_k: PhantomData<K>,
@ -82,27 +81,6 @@ impl<T: AsRef<Map> + AsMut<Map>, K: Pod, V: Pod> HashMap<T, K, V> {
}
}
impl<'a, K: Pod, V: Pod> TryFrom<&'a Map> for HashMap<&'a Map, K, V> {
type Error = MapError;
fn try_from(inner: &'a Map) -> Result<HashMap<&'a Map, K, V>, MapError> {
HashMap::new(inner)
}
}
impl<'a, K: Pod, V: Pod> TryFrom<&'a mut Map> for HashMap<&'a mut Map, K, V> {
type Error = MapError;
fn try_from(inner: &'a mut Map) -> Result<HashMap<&'a mut Map, K, V>, MapError> {
HashMap::new(inner)
}
}
pub(crate) trait IterableMap<K: Pod, V: Pod> {
fn fd(&self) -> Result<RawFd, MapError>;
unsafe fn get(&self, key: &K) -> Result<Option<V>, MapError>;
}
impl<T: AsRef<Map>, K: Pod, V: Pod> IterableMap<K, V> for HashMap<T, K, V> {
fn fd(&self) -> Result<RawFd, MapError> {
self.inner.as_ref().fd_or_err()
@ -113,103 +91,19 @@ impl<T: AsRef<Map>, K: Pod, V: Pod> IterableMap<K, V> for HashMap<T, K, V> {
}
}
pub struct MapKeys<'coll, K: Pod, V: Pod> {
map: &'coll dyn IterableMap<K, V>,
err: bool,
key: Option<K>,
}
impl<'coll, K: Pod, V: Pod> MapKeys<'coll, K, V> {
fn new(map: &'coll dyn IterableMap<K, V>) -> MapKeys<'coll, K, V> {
MapKeys {
map,
err: false,
key: None,
}
}
}
impl<K: Pod, V: Pod> Iterator for MapKeys<'_, K, V> {
type Item = Result<K, MapError>;
fn next(&mut self) -> Option<Result<K, MapError>> {
if self.err {
return None;
}
let fd = match self.map.fd() {
Ok(fd) => fd,
Err(e) => {
self.err = true;
return Some(Err(e));
}
};
match bpf_map_get_next_key(fd, self.key.as_ref()) {
Ok(Some(key)) => {
self.key = Some(key);
return Some(Ok(key));
}
Ok(None) => {
self.key = None;
return None;
}
Err((code, io_error)) => {
self.err = true;
return Some(Err(MapError::GetNextKeyFailed { code, io_error }));
}
}
}
}
pub struct MapIter<'coll, K: Pod, V: Pod> {
inner: MapKeys<'coll, K, V>,
}
impl<'coll, K: Pod, V: Pod> MapIter<'coll, K, V> {
fn new(map: &'coll dyn IterableMap<K, V>) -> MapIter<'coll, K, V> {
MapIter {
inner: MapKeys::new(map),
}
}
}
impl<K: Pod, V: Pod> Iterator for MapIter<'_, K, V> {
type Item = Result<(K, V), MapError>;
fn next(&mut self) -> Option<Self::Item> {
loop {
match self.inner.next() {
Some(Ok(key)) => {
let value = unsafe { self.inner.map.get(&key) };
match value {
Ok(None) => continue,
Ok(Some(value)) => return Some(Ok((key, value))),
Err(e) => return Some(Err(e)),
}
}
Some(Err(e)) => return Some(Err(e)),
None => return None,
}
}
}
}
impl<'a, K: Pod, V: Pod> TryFrom<&'a Map> for HashMap<&'a Map, K, V> {
type Error = MapError;
impl AsRef<Map> for &Map {
fn as_ref(&self) -> &Map {
self
fn try_from(inner: &'a Map) -> Result<HashMap<&'a Map, K, V>, MapError> {
HashMap::new(inner)
}
}
impl AsRef<Map> for &mut Map {
fn as_ref(&self) -> &Map {
self
}
}
impl<'a, K: Pod, V: Pod> TryFrom<&'a mut Map> for HashMap<&'a mut Map, K, V> {
type Error = MapError;
impl AsMut<Map> for &mut Map {
fn as_mut(&mut self) -> &mut Map {
self
fn try_from(inner: &'a mut Map) -> Result<HashMap<&'a mut Map, K, V>, MapError> {
HashMap::new(inner)
}
}

93
src/maps/mod.rs
Unescape Escape View File

@ -1,7 +1,11 @@
use std::{ffi::CString, io};
use thiserror::Error;
use crate::{obj, syscalls::bpf_create_map, RawFd};
use crate::{
obj,
syscalls::{bpf_create_map, bpf_map_get_next_key},
Pod, RawFd,
};
mod hash_map;
pub use hash_map::*;
@ -90,6 +94,93 @@ impl Map {
}
}
pub(crate) trait IterableMap<K: Pod, V: Pod> {
fn fd(&self) -> Result<RawFd, MapError>;
unsafe fn get(&self, key: &K) -> Result<Option<V>, MapError>;
}
pub struct MapKeys<'coll, K: Pod, V: Pod> {
map: &'coll dyn IterableMap<K, V>,
err: bool,
key: Option<K>,
}
impl<'coll, K: Pod, V: Pod> MapKeys<'coll, K, V> {
fn new(map: &'coll dyn IterableMap<K, V>) -> MapKeys<'coll, K, V> {
MapKeys {
map,
err: false,
key: None,
}
}
}
impl<K: Pod, V: Pod> Iterator for MapKeys<'_, K, V> {
type Item = Result<K, MapError>;
fn next(&mut self) -> Option<Result<K, MapError>> {
if self.err {
return None;
}
let fd = match self.map.fd() {
Ok(fd) => fd,
Err(e) => {
self.err = true;
return Some(Err(e));
}
};
match bpf_map_get_next_key(fd, self.key.as_ref()) {
Ok(Some(key)) => {
self.key = Some(key);
return Some(Ok(key));
}
Ok(None) => {
self.key = None;
return None;
}
Err((code, io_error)) => {
self.err = true;
return Some(Err(MapError::GetNextKeyFailed { code, io_error }));
}
}
}
}
pub struct MapIter<'coll, K: Pod, V: Pod> {
inner: MapKeys<'coll, K, V>,
}
impl<'coll, K: Pod, V: Pod> MapIter<'coll, K, V> {
fn new(map: &'coll dyn IterableMap<K, V>) -> MapIter<'coll, K, V> {
MapIter {
inner: MapKeys::new(map),
}
}
}
impl<K: Pod, V: Pod> Iterator for MapIter<'_, K, V> {
type Item = Result<(K, V), MapError>;
fn next(&mut self) -> Option<Self::Item> {
loop {
match self.inner.next() {
Some(Ok(key)) => {
let value = unsafe { self.inner.map.get(&key) };
match value {
Ok(None) => continue,
Ok(Some(value)) => return Some(Ok((key, value))),
Err(e) => return Some(Err(e)),
}
}
Some(Err(e)) => return Some(Err(e)),
None => return None,
}
}
}
}
#[cfg(test)]
mod tests {
use libc::EFAULT;

Write Preview
Loading…
Cancel
Save