sgx_signal/src/exception.rs - incubator-teaclave-sgx-sdk - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License..

 use sgx_libc::int32_t;
 use sgx_trts::veh::{
     exception_handle, rsgx_register_exception_handler, rsgx_unregister_exception_handler,
 };
 use sgx_types::SE_WORDSIZE;
 use sgx_types::{sgx_exception_info_t, sgx_exception_vector_t};
 use sgx_types::{EXCEPTION_CONTINUE_EXECUTION, EXCEPTION_CONTINUE_SEARCH};
 use std::collections::LinkedList;
 use std::convert::From;
 use std::num::NonZeroU64;
 use std::ops::Drop;
 use std::sync::{Arc, Once, SgxRwLock, SgxThreadMutex, ONCE_INIT};
 use std::u64;

 #[repr(u32)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum ContinueType {
     Search,
     Execution,
 }

 impl From<ContinueType> for i32 {
     fn from(continue_type: ContinueType) -> i32 {
         match continue_type {
             ContinueType::Search => EXCEPTION_CONTINUE_SEARCH,
             ContinueType::Execution => EXCEPTION_CONTINUE_EXECUTION,
         }
     }
 }

 #[allow(unknown_lints, bare_trait_objects)]
 type ExceptionHandler = dyn Fn(&mut sgx_exception_info_t) -> ContinueType + Send + Sync;

 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct HandlerId(NonZeroU64);

 impl HandlerId {
     fn new() -> HandlerId {
         static GUARD: SgxThreadMutex = SgxThreadMutex::new();
         static mut COUNTER: u64 = 1;

         unsafe {
             let _guard = GUARD.lock();
             if COUNTER == u64::MAX {
                 panic!("failed to generate unique HandlerId : bitspace exhausted");
             }
             let id = COUNTER;
             COUNTER += 1;
             let _ = GUARD.unlock();
             HandlerId(NonZeroU64::new(id).unwrap())
         }
     }
 }

 struct HandlerNode {
     id: HandlerId,
     handler: Arc<ExceptionHandler>,
 }

 impl HandlerNode {
     // add code here
     pub fn new(id: HandlerId, handler: Arc<ExceptionHandler>) -> Self {
         HandlerNode { id, handler }
     }
     pub fn get_handler_id(&self) -> HandlerId {
         self.id
     }
 }

 struct ExceptionManager {
     exception_handler: SgxRwLock<LinkedList<HandlerNode>>,
     native_handle: Option<exception_handle>,
 }

 static mut GLOBAL_DATA: Option<GlobalData> = None;

 #[allow(deprecated)]
 static GLOBAL_INIT: Once = ONCE_INIT;
 struct GlobalData {
     manager: ExceptionManager,
 }

 impl GlobalData {
     fn get() -> &'static Self {
         unsafe { GLOBAL_DATA.as_ref().unwrap() }
     }
     fn ensure() -> &'static Self {
         GLOBAL_INIT.call_once(|| unsafe {
             GLOBAL_DATA = Some(GlobalData {
                 manager: ExceptionManager::new(),
             });
         });
         Self::get()
     }
 }

 extern "C" fn native_exception_handler(info: *mut sgx_exception_info_t) -> int32_t {
     if let Ok(handlers) = GlobalData::get().manager.exception_handler.read() {
         let info = unsafe { info.as_mut().unwrap() };
         for h in handlers.iter() {
             match (h.handler)(info) {
                 ContinueType::Search => {}
                 ContinueType::Execution => return EXCEPTION_CONTINUE_EXECUTION,
             }
         }
     }
     unsafe { panic_handler(info).into() }
 }

 unsafe extern "C" fn panic_handler(info: *mut sgx_exception_info_t) -> ContinueType {
     let exception_info = info.as_mut().unwrap();
     let mut rsp = exception_info.cpu_context.rsp;
     if rsp & 0xF == 0 {
         rsp -= SE_WORDSIZE as u64;
         exception_info.cpu_context.rsp = rsp;
         let addr = rsp as *mut u64;
         *addr = exception_info.cpu_context.rip;
     } else {
     }

     exception_info.cpu_context.rdi = exception_info.exception_vector as u32 as u64;
     exception_info.cpu_context.rsi = exception_info.cpu_context.rip;
     exception_info.cpu_context.rip = exception_panic as usize as u64;

     ContinueType::Execution
 }

 #[no_mangle]
 #[inline(never)]
 unsafe fn exception_panic(vector: sgx_exception_vector_t, rip: usize) {
     let exception = match vector {
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_DE => "#DE",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_DB => "#DB",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_BP => "#BP",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_BR => "#BR",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_UD => "#UD",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_GP => "#GP",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_PF => "#PF",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_MF => "#MF",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_AC => "#AC",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_XM => "#XM",
         sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_CP => "#CP",
     };
     panic!("enclave exception: {}, at rip: 0x{:x}", exception, rip);
 }

 impl ExceptionManager {
     // add code here
     pub fn new() -> Self {
         ExceptionManager {
             exception_handler: SgxRwLock::new(LinkedList::new()),
             native_handle: rsgx_register_exception_handler(0, native_exception_handler),
         }
     }
 }

 #[allow(dead_code)]
 impl Drop for ExceptionManager {
     fn drop(&mut self) {
         if let Some(handler) = self.native_handle {
             rsgx_unregister_exception_handler(handler);
             self.native_handle = None;
             if let Ok(ref mut handlers) = self.exception_handler.write() {
                 handlers.clear();
             }
         }
     }
 }

 fn register_exception_impl<F>(first: bool, handler: F) -> Option<HandlerId>
 where
     F: Fn(&mut sgx_exception_info_t) -> ContinueType + Sync + Send + 'static,
 {
     let globals = GlobalData::ensure();

     if let Ok(ref mut handlers) = globals.manager.exception_handler.write() {
         let handler_id = HandlerId::new();
         if first {
             handlers.push_front(HandlerNode::new(handler_id, Arc::from(handler)));
         } else {
             handlers.push_back(HandlerNode::new(handler_id, Arc::from(handler)));
         }
         Some(handler_id)
     } else {
         None
     }
 }

 ///
 /// The register_exception function allows developers to register an exception handler,
 /// and specify whether to prepend (when is_first is true) or append the handler to the handler chain.
 ///
 /// # Description
 ///
 /// The Rust SGX SDK supports the registration of custom exception handler
 /// functions. You can write your own code to handle a limited set of hardware
 /// exceptions.
 ///
 /// # Note
 ///
 /// 1. OCALLs are not allowed in the exception handler.
 /// 2. Custom exception handing only saves general purpose registers in sgx_exception_info_t. You should be careful when touching other registers inthe exception handlers.
 ///
 pub fn register_exception<F>(is_first: bool, handler: F) -> Option<HandlerId>
 where
     F: Fn(&mut sgx_exception_info_t) -> ContinueType + Sync + Send + 'static,
 {
     register_exception_impl(is_first, handler)
 }

 ///
 /// The register function allows developers to register an exception handler.
 ///
 /// # Description
 ///
 /// The Rust SGX SDK supports the registration of custom exception handler
 /// functions. You can write your own code to handle a limited set of hardware
 /// exceptions.
 ///
 /// # Note
 ///
 /// 1. OCALLs are not allowed in the exception handler.
 /// 2. Custom exception handing only saves general purpose registers in sgx_exception_info_t. You should be careful when touching other registers inthe exception handlers.
 ///
 pub fn register<F>(handler: F) -> Option<HandlerId>
 where
     F: Fn(&mut sgx_exception_info_t) -> ContinueType + Sync + Send + 'static,
 {
     register_exception_impl(true, handler)
 }

 pub fn unregister(id: HandlerId) -> bool {
     let globals = GlobalData::ensure();
     if let Ok(ref mut handlers) = globals.manager.exception_handler.write() {
         handlers
             .drain_filter(|n| n.get_handler_id() == id)
             .next()
             .is_some()
     } else {
         false
     }
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License..

	use sgx_libc::int32_t;
	use sgx_trts::veh::{
	exception_handle, rsgx_register_exception_handler, rsgx_unregister_exception_handler,
	};
	use sgx_types::SE_WORDSIZE;
	use sgx_types::{sgx_exception_info_t, sgx_exception_vector_t};
	use sgx_types::{EXCEPTION_CONTINUE_EXECUTION, EXCEPTION_CONTINUE_SEARCH};
	use std::collections::LinkedList;
	use std::convert::From;
	use std::num::NonZeroU64;
	use std::ops::Drop;
	use std::sync::{Arc, Once, SgxRwLock, SgxThreadMutex, ONCE_INIT};
	use std::u64;

	#[repr(u32)]
	#[derive(Copy, Clone, PartialEq, Eq)]
	pub enum ContinueType {
	Search,
	Execution,
	}

	impl From<ContinueType> for i32 {
	fn from(continue_type: ContinueType) -> i32 {
	match continue_type {
	ContinueType::Search => EXCEPTION_CONTINUE_SEARCH,
	ContinueType::Execution => EXCEPTION_CONTINUE_EXECUTION,
	}
	}
	}

	#[allow(unknown_lints, bare_trait_objects)]
	type ExceptionHandler = dyn Fn(&mut sgx_exception_info_t) -> ContinueType + Send + Sync;

	#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
	pub struct HandlerId(NonZeroU64);

	impl HandlerId {
	fn new() -> HandlerId {
	static GUARD: SgxThreadMutex = SgxThreadMutex::new();
	static mut COUNTER: u64 = 1;

	unsafe {
	let _guard = GUARD.lock();
	if COUNTER == u64::MAX {
	panic!("failed to generate unique HandlerId : bitspace exhausted");
	}
	let id = COUNTER;
	COUNTER += 1;
	let _ = GUARD.unlock();
	HandlerId(NonZeroU64::new(id).unwrap())
	}
	}
	}

	struct HandlerNode {
	id: HandlerId,
	handler: Arc<ExceptionHandler>,
	}

	impl HandlerNode {
	// add code here
	pub fn new(id: HandlerId, handler: Arc<ExceptionHandler>) -> Self {
	HandlerNode { id, handler }
	}
	pub fn get_handler_id(&self) -> HandlerId {
	self.id
	}
	}

	struct ExceptionManager {
	exception_handler: SgxRwLock<LinkedList<HandlerNode>>,
	native_handle: Option<exception_handle>,
	}

	static mut GLOBAL_DATA: Option<GlobalData> = None;

	#[allow(deprecated)]
	static GLOBAL_INIT: Once = ONCE_INIT;
	struct GlobalData {
	manager: ExceptionManager,
	}

	impl GlobalData {
	fn get() -> &'static Self {
	unsafe { GLOBAL_DATA.as_ref().unwrap() }
	}
	fn ensure() -> &'static Self {
	GLOBAL_INIT.call_once(\|\| unsafe {
	GLOBAL_DATA = Some(GlobalData {
	manager: ExceptionManager::new(),
	});
	});
	Self::get()
	}
	}

	extern "C" fn native_exception_handler(info: *mut sgx_exception_info_t) -> int32_t {
	if let Ok(handlers) = GlobalData::get().manager.exception_handler.read() {
	let info = unsafe { info.as_mut().unwrap() };
	for h in handlers.iter() {
	match (h.handler)(info) {
	ContinueType::Search => {}
	ContinueType::Execution => return EXCEPTION_CONTINUE_EXECUTION,
	}
	}
	}
	unsafe { panic_handler(info).into() }
	}

	unsafe extern "C" fn panic_handler(info: *mut sgx_exception_info_t) -> ContinueType {
	let exception_info = info.as_mut().unwrap();
	let mut rsp = exception_info.cpu_context.rsp;
	if rsp & 0xF == 0 {
	rsp -= SE_WORDSIZE as u64;
	exception_info.cpu_context.rsp = rsp;
	let addr = rsp as *mut u64;
	*addr = exception_info.cpu_context.rip;
	} else {
	}

	exception_info.cpu_context.rdi = exception_info.exception_vector as u32 as u64;
	exception_info.cpu_context.rsi = exception_info.cpu_context.rip;
	exception_info.cpu_context.rip = exception_panic as usize as u64;

	ContinueType::Execution
	}

	#[no_mangle]
	#[inline(never)]
	unsafe fn exception_panic(vector: sgx_exception_vector_t, rip: usize) {
	let exception = match vector {
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_DE => "#DE",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_DB => "#DB",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_BP => "#BP",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_BR => "#BR",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_UD => "#UD",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_GP => "#GP",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_PF => "#PF",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_MF => "#MF",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_AC => "#AC",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_XM => "#XM",
	sgx_exception_vector_t::SGX_EXCEPTION_VECTOR_CP => "#CP",
	};
	panic!("enclave exception: {}, at rip: 0x{:x}", exception, rip);
	}

	impl ExceptionManager {
	// add code here
	pub fn new() -> Self {
	ExceptionManager {
	exception_handler: SgxRwLock::new(LinkedList::new()),
	native_handle: rsgx_register_exception_handler(0, native_exception_handler),
	}
	}
	}

	#[allow(dead_code)]
	impl Drop for ExceptionManager {
	fn drop(&mut self) {
	if let Some(handler) = self.native_handle {
	rsgx_unregister_exception_handler(handler);
	self.native_handle = None;
	if let Ok(ref mut handlers) = self.exception_handler.write() {
	handlers.clear();
	}
	}
	}
	}

	fn register_exception_impl<F>(first: bool, handler: F) -> Option<HandlerId>
	where
	F: Fn(&mut sgx_exception_info_t) -> ContinueType + Sync + Send + 'static,
	{
	let globals = GlobalData::ensure();

	if let Ok(ref mut handlers) = globals.manager.exception_handler.write() {
	let handler_id = HandlerId::new();
	if first {
	handlers.push_front(HandlerNode::new(handler_id, Arc::from(handler)));
	} else {
	handlers.push_back(HandlerNode::new(handler_id, Arc::from(handler)));
	}
	Some(handler_id)
	} else {
	None
	}
	}

	///
	/// The register_exception function allows developers to register an exception handler,
	/// and specify whether to prepend (when is_first is true) or append the handler to the handler chain.
	///
	/// # Description
	///
	/// The Rust SGX SDK supports the registration of custom exception handler
	/// functions. You can write your own code to handle a limited set of hardware
	/// exceptions.
	///
	/// # Note
	///
	/// 1. OCALLs are not allowed in the exception handler.
	/// 2. Custom exception handing only saves general purpose registers in sgx_exception_info_t. You should be careful when touching other registers inthe exception handlers.
	///
	pub fn register_exception<F>(is_first: bool, handler: F) -> Option<HandlerId>
	where
	F: Fn(&mut sgx_exception_info_t) -> ContinueType + Sync + Send + 'static,
	{
	register_exception_impl(is_first, handler)
	}

	///
	/// The register function allows developers to register an exception handler.
	///
	/// # Description
	///
	/// The Rust SGX SDK supports the registration of custom exception handler
	/// functions. You can write your own code to handle a limited set of hardware
	/// exceptions.
	///
	/// # Note
	///
	/// 1. OCALLs are not allowed in the exception handler.
	/// 2. Custom exception handing only saves general purpose registers in sgx_exception_info_t. You should be careful when touching other registers inthe exception handlers.
	///
	pub fn register<F>(handler: F) -> Option<HandlerId>
	where
	F: Fn(&mut sgx_exception_info_t) -> ContinueType + Sync + Send + 'static,
	{
	register_exception_impl(true, handler)
	}

	pub fn unregister(id: HandlerId) -> bool {
	let globals = GlobalData::ensure();
	if let Ok(ref mut handlers) = globals.manager.exception_handler.write() {
	handlers
	.drain_filter(\|n\| n.get_handler_id() == id)
	.next()
	.is_some()
	} else {
	false
	}
	}