Merge "binder_rs: Add stability support to binder services" am: b02552dd94 am:... (96496ba0) · Commits · e / os / android_frameworks_native-old

libs/binder/rust/src/binder.rs

+63 −1

Original line number	Original line	Diff line number	Diff line
	@@ -56,6 +56,26 @@ pub trait Interface: Send {
	}		}
	}		}

			/// Interface stability promise
			///
			/// An interface can promise to be a stable vendor interface ([`Vintf`]), or
			/// makes no stability guarantees ([`Local`]). [`Local`] is
			/// currently the default stability.
			pub enum Stability {
			/// Default stability, visible to other modules in the same compilation
			/// context (e.g. modules on system.img)
			Local,

			/// A Vendor Interface Object, which promises to be stable
			Vintf,
			}

			impl Default for Stability {
			fn default() -> Self {
			Stability::Local
			}
			}

	/// A local service that can be remotable via Binder.		/// A local service that can be remotable via Binder.
	///		///
	/// An object that implement this interface made be made into a Binder service		/// An object that implement this interface made be made into a Binder service
	@@ -94,6 +114,8 @@ pub const LAST_CALL_TRANSACTION: TransactionCode = sys::LAST_CALL_TRANSACTION;
	pub const FLAG_ONEWAY: TransactionFlags = sys::FLAG_ONEWAY;		pub const FLAG_ONEWAY: TransactionFlags = sys::FLAG_ONEWAY;
	/// Corresponds to TF_CLEAR_BUF -- clear transaction buffers after call is made.		/// Corresponds to TF_CLEAR_BUF -- clear transaction buffers after call is made.
	pub const FLAG_CLEAR_BUF: TransactionFlags = sys::FLAG_CLEAR_BUF;		pub const FLAG_CLEAR_BUF: TransactionFlags = sys::FLAG_CLEAR_BUF;
			/// Set to the vendor flag if we are building for the VNDK, 0 otherwise
			pub const FLAG_PRIVATE_LOCAL: TransactionFlags = sys::FLAG_PRIVATE_LOCAL;

	/// Internal interface of binder local or remote objects for making		/// Internal interface of binder local or remote objects for making
	/// transactions.		/// transactions.
	@@ -602,6 +624,42 @@ macro_rules! declare_binder_interface {
	$interface[$descriptor] {		$interface[$descriptor] {
	native: $native($on_transact),		native: $native($on_transact),
	proxy: $proxy {},		proxy: $proxy {},
			stability: $crate::Stability::default(),
			}
			}
			};

			{
			$interface:path[$descriptor:expr] {
			native: $native:ident($on_transact:path),
			proxy: $proxy:ident,
			stability: $stability:expr,
			}
			} => {
			$crate::declare_binder_interface! {
			$interface[$descriptor] {
			native: $native($on_transact),
			proxy: $proxy {},
			stability: $stability,
			}
			}
			};

			{
			$interface:path[$descriptor:expr] {
			native: $native:ident($on_transact:path),
			proxy: $proxy:ident {
			$($fname:ident: $fty:ty = $finit:expr),*
			},
			}
			} => {
			$crate::declare_binder_interface! {
			$interface[$descriptor] {
			native: $native($on_transact),
			proxy: $proxy {
			$($fname: $fty = $finit),*
			},
			stability: $crate::Stability::default(),
	}		}
	}		}
	};		};
	@@ -612,6 +670,7 @@ macro_rules! declare_binder_interface {
	proxy: $proxy:ident {		proxy: $proxy:ident {
	$($fname:ident: $fty:ty = $finit:expr),*		$($fname:ident: $fty:ty = $finit:expr),*
	},		},
			stability: $stability:expr,
	}		}
	} => {		} => {
	$crate::declare_binder_interface! {		$crate::declare_binder_interface! {
	@@ -622,6 +681,7 @@ macro_rules! declare_binder_interface {
	proxy: $proxy {		proxy: $proxy {
	$($fname: $fty = $finit),*		$($fname: $fty = $finit),*
	},		},
			stability: $stability,
	}		}
	}		}
	};		};
	@@ -635,6 +695,8 @@ macro_rules! declare_binder_interface {
	proxy: $proxy:ident {		proxy: $proxy:ident {
	$($fname:ident: $fty:ty = $finit:expr),*		$($fname:ident: $fty:ty = $finit:expr),*
	},		},

			stability: $stability:expr,
	}		}
	} => {		} => {
	#[doc = $proxy_doc]		#[doc = $proxy_doc]
	@@ -669,7 +731,7 @@ macro_rules! declare_binder_interface {
	impl $native {		impl $native {
	/// Create a new binder service.		/// Create a new binder service.
	pub fn new_binder<T: $interface + Sync + Send + 'static>(inner: T) -> $crate::Strong<dyn $interface> {		pub fn new_binder<T: $interface + Sync + Send + 'static>(inner: T) -> $crate::Strong<dyn $interface> {
	let binder = $crate::Binder::new($native(Box::new(inner)));		let binder = $crate::Binder::new_with_stability($native(Box::new(inner)), $stability);
	$crate::Strong::new(Box::new(binder))		$crate::Strong::new(Box::new(binder))
	}		}
	}		}

libs/binder/rust/src/lib.rs

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -107,8 +107,9 @@ use binder_ndk_sys as sys;
	pub mod parcel;		pub mod parcel;

	pub use crate::binder::{		pub use crate::binder::{
	FromIBinder, IBinder, IBinderInternal, Interface, InterfaceClass, Remotable, Strong,		FromIBinder, IBinder, IBinderInternal, Interface, InterfaceClass, Remotable,
	TransactionCode, TransactionFlags, Weak, FIRST_CALL_TRANSACTION, FLAG_CLEAR_BUF, FLAG_ONEWAY,		Stability, Strong, TransactionCode, TransactionFlags, Weak,
			FIRST_CALL_TRANSACTION, FLAG_CLEAR_BUF, FLAG_ONEWAY, FLAG_PRIVATE_LOCAL,
	LAST_CALL_TRANSACTION,		LAST_CALL_TRANSACTION,
	};		};
	pub use error::{status_t, ExceptionCode, Result, Status, StatusCode};		pub use error::{status_t, ExceptionCode, Result, Status, StatusCode};

libs/binder/rust/src/native.rs

+50 −4

Original line number	Original line	Diff line number	Diff line
	@@ -14,7 +14,7 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

	use crate::binder::{AsNative, Interface, InterfaceClassMethods, Remotable, TransactionCode};		use crate::binder::{AsNative, Interface, InterfaceClassMethods, Remotable, Stability, TransactionCode};
	use crate::error::{status_result, status_t, Result, StatusCode};		use crate::error::{status_result, status_t, Result, StatusCode};
	use crate::parcel::{Parcel, Serialize};		use crate::parcel::{Parcel, Serialize};
	use crate::proxy::SpIBinder;		use crate::proxy::SpIBinder;
	@@ -49,11 +49,19 @@ pub struct Binder<T: Remotable> {
	unsafe impl<T: Remotable> Send for Binder<T> {}		unsafe impl<T: Remotable> Send for Binder<T> {}

	impl<T: Remotable> Binder<T> {		impl<T: Remotable> Binder<T> {
	/// Create a new Binder remotable object.		/// Create a new Binder remotable object with default stability
	///		///
	/// This moves the `rust_object` into an owned [`Box`] and Binder will		/// This moves the `rust_object` into an owned [`Box`] and Binder will
	/// manage its lifetime.		/// manage its lifetime.
	pub fn new(rust_object: T) -> Binder<T> {		pub fn new(rust_object: T) -> Binder<T> {
			Self::new_with_stability(rust_object, Stability::default())
			}

			/// Create a new Binder remotable object with the given stability
			///
			/// This moves the `rust_object` into an owned [`Box`] and Binder will
			/// manage its lifetime.
			pub fn new_with_stability(rust_object: T, stability: Stability) -> Binder<T> {
	let class = T::get_class();		let class = T::get_class();
	let rust_object = Box::into_raw(Box::new(rust_object));		let rust_object = Box::into_raw(Box::new(rust_object));
	let ibinder = unsafe {		let ibinder = unsafe {
	@@ -65,10 +73,12 @@ impl<T: Remotable> Binder<T> {
	// ends.		// ends.
	sys::AIBinder_new(class.into(), rust_object as *mut c_void)		sys::AIBinder_new(class.into(), rust_object as *mut c_void)
	};		};
	Binder {		let mut binder = Binder {
	ibinder,		ibinder,
	rust_object,		rust_object,
	}		};
			binder.mark_stability(stability);
			binder
	}		}

	/// Set the extension of a binder interface. This allows a downstream		/// Set the extension of a binder interface. This allows a downstream
	@@ -161,6 +171,42 @@ impl<T: Remotable> Binder<T> {
	pub fn get_descriptor() -> &'static str {		pub fn get_descriptor() -> &'static str {
	T::get_descriptor()		T::get_descriptor()
	}		}

			/// Mark this binder object with the given stability guarantee
			fn mark_stability(&mut self, stability: Stability) {
			match stability {
			Stability::Local => self.mark_local_stability(),
			Stability::Vintf => {
			unsafe {
			// Safety: Self always contains a valid `AIBinder` pointer, so
			// we can always call this C API safely.
			sys::AIBinder_markVintfStability(self.as_native_mut());
			}
			}
			}
			}

			/// Mark this binder object with local stability, which is vendor if we are
			/// building for the VNDK and system otherwise.
			#[cfg(vendor_ndk)]
			fn mark_local_stability(&mut self) {
			unsafe {
			// Safety: Self always contains a valid `AIBinder` pointer, so
			// we can always call this C API safely.
			sys::AIBinder_markVendorStability(self.as_native_mut());
			}
			}

			/// Mark this binder object with local stability, which is vendor if we are
			/// building for the VNDK and system otherwise.
			#[cfg(not(vendor_ndk))]
			fn mark_local_stability(&mut self) {
			unsafe {
			// Safety: Self always contains a valid `AIBinder` pointer, so
			// we can always call this C API safely.
			sys::AIBinder_markSystemStability(self.as_native_mut());
			}
			}
	}		}

	impl<T: Remotable> Interface for Binder<T> {		impl<T: Remotable> Interface for Binder<T> {

libs/binder/rust/sys/BinderBindings.hpp

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@
	#include <android/binder_parcel_platform.h>		#include <android/binder_parcel_platform.h>
	#include <android/binder_process.h>		#include <android/binder_process.h>
	#include <android/binder_shell.h>		#include <android/binder_shell.h>
			#include <android/binder_stability.h>
	#include <android/binder_status.h>		#include <android/binder_status.h>

	namespace android {		namespace android {
	@@ -80,6 +81,7 @@ enum {
	enum {		enum {
	FLAG_ONEWAY = FLAG_ONEWAY,		FLAG_ONEWAY = FLAG_ONEWAY,
	FLAG_CLEAR_BUF = FLAG_CLEAR_BUF,		FLAG_CLEAR_BUF = FLAG_CLEAR_BUF,
			FLAG_PRIVATE_LOCAL = FLAG_PRIVATE_LOCAL,
	};		};

	} // namespace consts		} // namespace consts