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

btf: rename BtfRelocationError to RelocationError

Browse Source
pull/1/head
Alessandro Decina 4 years ago
parent 3b668d9274
commit 88d49927c2
2 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File

64
src/obj/btf/relocation.rs
Unescape Escape View File

@ -22,7 +22,7 @@ use crate::{
};
#[derive(Error, Debug)]
pub enum BtfRelocationError {
pub enum RelocationError {
#[error("{error}")]
BtfError {
#[from]
@ -161,7 +161,7 @@ impl Relocation {
}
impl Object {
pub fn relocate_btf(&mut self) -> Result<(), BtfRelocationError> {
pub fn relocate_btf(&mut self) -> Result<(), RelocationError> {
let (local_btf, btf_ext) = match (&self.btf, &self.btf_ext) {
(Some(btf), Some(btf_ext)) => (btf, btf_ext),
_ => return Ok(()),
@ -189,7 +189,7 @@ impl Object {
}
let section_name = parts[1];
let program = self.programs.get_mut(section_name).ok_or_else(|| {
BtfRelocationError::SectionNotFound {
RelocationError::SectionNotFound {
name: section_name.to_string(),
}
})?;
@ -198,7 +198,7 @@ impl Object {
let instructions = &mut program.instructions;
let ins_index = rel.ins_offset as usize / std::mem::size_of::<bpf_insn>();
if ins_index >= instructions.len() {
return Err(BtfRelocationError::InvalidInstructionIndex {
return Err(RelocationError::InvalidInstructionIndex {
index: ins_index,
num_instructions: instructions.len(),
section_name: section_name.to_string(),
@ -259,7 +259,7 @@ impl Object {
})
.collect::<Vec<_>>();
if !conflicts.is_empty() {
return Err(BtfRelocationError::ConflictingCandidates {
return Err(RelocationError::ConflictingCandidates {
type_name: local_name.to_string(),
candidates: conflicts,
});
@ -314,7 +314,7 @@ fn find_candidates<'target>(
fn match_candidate<'target>(
local_spec: &AccessSpec,
candidate: &'target Candidate,
) -> Result<Option<AccessSpec<'target>>, BtfRelocationError> {
) -> Result<Option<AccessSpec<'target>>, RelocationError> {
let mut target_spec = AccessSpec {
btf: candidate.btf,
root_type_id: candidate.type_id,
@ -414,7 +414,7 @@ fn match_candidate<'target>(
}
if target_spec.parts.len() == MAX_SPEC_LEN {
return Err(BtfRelocationError::MaximumNestingLevelReached {
return Err(RelocationError::MaximumNestingLevelReached {
type_name: Some(candidate.name.clone()),
});
}
@ -442,7 +442,7 @@ fn match_member<'local, 'target>(
target_btf: &'target Btf,
target_id: u32,
target_spec: &mut AccessSpec<'target>,
) -> Result<Option<u32>, BtfRelocationError> {
) -> Result<Option<u32>, RelocationError> {
let local_ty = local_btf.type_by_id(local_accessor.type_id)?;
let local_member = match local_ty {
BtfType::Struct(_, members) | BtfType::Union(_, members) => {
@ -465,7 +465,7 @@ fn match_member<'local, 'target>(
for (index, target_member) in target_members.iter().enumerate() {
if target_spec.parts.len() == MAX_SPEC_LEN {
let root_ty = target_spec.btf.type_by_id(target_spec.root_type_id)?;
return Err(BtfRelocationError::MaximumNestingLevelReached {
return Err(RelocationError::MaximumNestingLevelReached {
type_name: target_spec.btf.err_type_name(root_ty),
});
}
@ -527,12 +527,12 @@ impl<'a> AccessSpec<'a> {
root_type_id: u32,
spec: &str,
relocation: Relocation,
) -> Result<AccessSpec<'a>, BtfRelocationError> {
) -> Result<AccessSpec<'a>, RelocationError> {
let parts = spec
.split(":")
.map(|s| s.parse::<usize>())
.collect::<Result<Vec<_>, _>>()
.map_err(|_| BtfRelocationError::InvalidAccessString {
.map_err(|_| RelocationError::InvalidAccessString {
access_str: spec.to_string(),
})?;
@ -545,7 +545,7 @@ impl<'a> AccessSpec<'a> {
| RelocationKind::TypeExists
| RelocationKind::TypeSize => {
if parts != [0] {
return Err(BtfRelocationError::InvalidAccessString {
return Err(RelocationError::InvalidAccessString {
access_str: spec.to_string(),
});
}
@ -561,13 +561,13 @@ impl<'a> AccessSpec<'a> {
RelocationKind::EnumVariantExists | RelocationKind::EnumVariantValue => match ty {
BtfType::Enum(_, members) => {
if parts.len() != 1 {
return Err(BtfRelocationError::InvalidAccessString {
return Err(RelocationError::InvalidAccessString {
access_str: spec.to_string(),
});
}
let index = parts[0];
if index >= members.len() {
return Err(BtfRelocationError::InvalidAccessIndex {
return Err(RelocationError::InvalidAccessIndex {
type_name: btf.err_type_name(ty),
spec: spec.to_string(),
index: index,
@ -591,7 +591,7 @@ impl<'a> AccessSpec<'a> {
}
}
_ => {
return Err(BtfRelocationError::InvalidRelocationKindForType {
return Err(RelocationError::InvalidRelocationKindForType {
relocation_number: relocation.number,
relocation_kind: format!("{:?}", relocation.kind),
type_kind: format!("{:?}", ty.kind()?.unwrap()),
@ -620,7 +620,7 @@ impl<'a> AccessSpec<'a> {
match ty {
Struct(t, members) | Union(t, members) => {
if index >= members.len() {
return Err(BtfRelocationError::InvalidAccessIndex {
return Err(RelocationError::InvalidAccessIndex {
type_name: btf.err_type_name(ty),
spec: spec.to_string(),
index: index,
@ -656,7 +656,7 @@ impl<'a> AccessSpec<'a> {
}
};
if !var_len && index >= array.nelems as usize {
return Err(BtfRelocationError::InvalidAccessIndex {
return Err(RelocationError::InvalidAccessIndex {
type_name: btf.err_type_name(ty),
spec: spec.to_string(),
index,
@ -673,7 +673,7 @@ impl<'a> AccessSpec<'a> {
bit_offset += index * size * 8;
}
rel_kind => {
return Err(BtfRelocationError::InvalidRelocationKindForType {
return Err(RelocationError::InvalidRelocationKindForType {
relocation_number: relocation.number,
relocation_kind: format!("{:?}", rel_kind),
type_kind: format!("{:?}", ty.kind()),
@ -732,7 +732,7 @@ impl ComputedRelocation {
rel: &Relocation,
local_spec: &AccessSpec,
target_spec: Option<&AccessSpec>,
) -> Result<ComputedRelocation, BtfRelocationError> {
) -> Result<ComputedRelocation, RelocationError> {
use RelocationKind::*;
let ret = match rel.kind {
FieldByteOffset | FieldByteSize | FieldExists | FieldSigned | FieldLShift64
@ -760,14 +760,14 @@ impl ComputedRelocation {
section_name: &str,
local_btf: &Btf,
target_btf: &Btf,
) -> Result<(), BtfRelocationError> {
) -> Result<(), RelocationError> {
let instructions = &mut program.instructions;
let num_instructions = instructions.len();
let ins_index = rel.ins_offset as usize / std::mem::size_of::<bpf_insn>();
let mut ins =
instructions
.get_mut(ins_index)
.ok_or(BtfRelocationError::InvalidInstructionIndex {
.ok_or(RelocationError::InvalidInstructionIndex {
index: rel.ins_offset as usize,
num_instructions,
section_name: section_name.to_string(),
@ -782,7 +782,7 @@ impl ComputedRelocation {
BPF_ALU | BPF_ALU64 => {
let src_reg = ins.src_reg();
if src_reg != BPF_K as u8 {
return Err(BtfRelocationError::InvalidInstruction {
return Err(RelocationError::InvalidInstruction {
relocation_number: rel.number,
index: ins_index,
error: format!("invalid src_reg={:x} expected {:x}", src_reg, BPF_K),
@ -793,7 +793,7 @@ impl ComputedRelocation {
}
BPF_LDX | BPF_ST | BPF_STX => {
if target_value > std::i16::MAX as u32 {
return Err(BtfRelocationError::InvalidInstruction {
return Err(RelocationError::InvalidInstruction {
relocation_number: rel.number,
index: ins_index,
error: format!("value `{}` overflows 16 bits offset field", target_value),
@ -812,7 +812,7 @@ impl ComputedRelocation {
(Int(_, local_info), Int(_, target_info))
if unsigned(*local_info) && unsigned(*target_info) => {}
_ => {
return Err(BtfRelocationError::InvalidInstruction {
return Err(RelocationError::InvalidInstruction {
relocation_number: rel.number,
index: ins_index,
error: format!(
@ -832,7 +832,7 @@ impl ComputedRelocation {
2 => BPF_H,
1 => BPF_B,
size => {
return Err(BtfRelocationError::InvalidInstruction {
return Err(RelocationError::InvalidInstruction {
relocation_number: rel.number,
index: ins_index,
error: format!("invalid target size {}", size),
@ -845,7 +845,7 @@ impl ComputedRelocation {
BPF_LD => {
ins.imm = target_value as i32;
let mut next_ins = instructions.get_mut(ins_index + 1).ok_or(
BtfRelocationError::InvalidInstructionIndex {
RelocationError::InvalidInstructionIndex {
index: ins_index + 1,
num_instructions,
section_name: section_name.to_string(),
@ -856,7 +856,7 @@ impl ComputedRelocation {
next_ins.imm = 0;
}
class => {
return Err(BtfRelocationError::InvalidInstruction {
return Err(RelocationError::InvalidInstruction {
relocation_number: rel.number,
index: ins_index,
error: format!("invalid instruction class {:x}", class),
@ -870,7 +870,7 @@ impl ComputedRelocation {
fn compute_enum_relocation(
rel: &Relocation,
spec: Option<&AccessSpec>,
) -> Result<ComputedRelocationValue, BtfRelocationError> {
) -> Result<ComputedRelocationValue, RelocationError> {
use RelocationKind::*;
let value = match rel.kind {
EnumVariantExists => spec.is_some() as u32,
@ -896,7 +896,7 @@ impl ComputedRelocation {
fn compute_field_relocation(
rel: &Relocation,
spec: Option<&AccessSpec>,
) -> Result<ComputedRelocationValue, BtfRelocationError> {
) -> Result<ComputedRelocationValue, RelocationError> {
use RelocationKind::*;
if let FieldExists = rel.kind {
@ -926,7 +926,7 @@ impl ComputedRelocation {
}),
rel_kind => {
let ty = spec.btf.type_by_id(accessor.type_id)?;
return Err(BtfRelocationError::InvalidRelocationKindForType {
return Err(RelocationError::InvalidRelocationKindForType {
relocation_number: rel.number,
relocation_kind: format!("{:?}", rel_kind),
type_kind: format!("{:?}", ty.kind()),
@ -942,7 +942,7 @@ impl ComputedRelocation {
(ty, members[accessor.index])
}
_ => {
return Err(BtfRelocationError::InvalidRelocationKindForType {
return Err(RelocationError::InvalidRelocationKindForType {
relocation_number: rel.number,
relocation_kind: format!("{:?}", rel.kind),
type_kind: format!("{:?}", ty.kind()),
@ -1021,7 +1021,7 @@ impl ComputedRelocation {
rel: &Relocation,
local_spec: &AccessSpec,
target_spec: Option<&AccessSpec>,
) -> Result<ComputedRelocationValue, BtfRelocationError> {
) -> Result<ComputedRelocationValue, RelocationError> {
use RelocationKind::*;
let value = match rel.kind {
TypeIdLocal => local_spec.root_type_id,

2
src/obj/relocation.rs
Unescape Escape View File

@ -6,7 +6,7 @@ use thiserror::Error;
use crate::{
generated::{bpf_insn, BPF_PSEUDO_MAP_FD, BPF_PSEUDO_MAP_VALUE},
maps::Map,
obj::{btf::BtfRelocationError, Object},
obj::{btf::RelocationError as BtfRelocationError, Object},
};
#[derive(Debug, Error)]

Write Preview
Loading…
Cancel
Save