From 88d49927c2cba6cc3579a04a62ef2f6fc9c96983 Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Fri, 5 Feb 2021 20:10:39 +0000 Subject: [PATCH] btf: rename BtfRelocationError to RelocationError --- src/obj/btf/relocation.rs | 64 +++++++++++++++++++-------------------- src/obj/relocation.rs | 2 +- 2 files changed, 33 insertions(+), 33 deletions(-) diff --git a/src/obj/btf/relocation.rs b/src/obj/btf/relocation.rs index a3d24b45..12e355b6 100644 --- a/src/obj/btf/relocation.rs +++ b/src/obj/btf/relocation.rs @@ -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::(); 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::>(); 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>, BtfRelocationError> { +) -> Result>, 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, BtfRelocationError> { +) -> Result, 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, BtfRelocationError> { + ) -> Result, RelocationError> { let parts = spec .split(":") .map(|s| s.parse::()) .collect::, _>>() - .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 { + ) -> Result { 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::(); 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 { + ) -> Result { 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 { + ) -> Result { 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 { + ) -> Result { use RelocationKind::*; let value = match rel.kind { TypeIdLocal => local_spec.root_type_id, diff --git a/src/obj/relocation.rs b/src/obj/relocation.rs index 1d225df3..b3bffacd 100644 --- a/src/obj/relocation.rs +++ b/src/obj/relocation.rs @@ -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)]