Snap for 12348750 from 80a9016e3fdc019776f97cbd276bc367858266b3 to 24Q4-release (28639af3) · Commits · e / devices / smdk4412 / android_frameworks_native

libs/binder/FdTrigger.cpp

+4 −1

Original line number	Diff line number	Diff line
		@@ -82,7 +82,9 @@ status_t FdTrigger::triggerablePoll(const android::RpcTransportFd& transportFd,

		int ret = TEMP_FAILURE_RETRY(poll(pfd, countof(pfd), -1));
		if (ret < 0) {
		return -errno;
		int saved_errno = errno;
		ALOGE("FdTrigger poll returned error: %d, with error: %s", ret, strerror(saved_errno));
		return -saved_errno;
		}
		LOG_ALWAYS_FATAL_IF(ret == 0, "poll(%d) returns 0 with infinite timeout", transportFd.fd.get());

		@@ -106,6 +108,7 @@ status_t FdTrigger::triggerablePoll(const android::RpcTransportFd& transportFd,

		// POLLNVAL: invalid FD number, e.g. not opened.
		if (pfd[0].revents & POLLNVAL) {
		ALOGE("Invalid FD number (%d) in FdTrigger (POLLNVAL)", pfd[0].fd);
		return BAD_VALUE;
		}

libs/bufferstreams/rust/src/stream_config.rs

+19 −5

Original line number	Diff line number	Diff line
		@@ -32,10 +32,23 @@ pub struct StreamConfig {
		pub stride: u32,
		}

		impl From<StreamConfig> for HardwareBufferDescription {
		fn from(config: StreamConfig) -> Self {
		HardwareBufferDescription::new(
		config.width,
		config.height,
		config.layers,
		config.format,
		config.usage,
		config.stride,
		)
		}
		}

		impl StreamConfig {
		/// Tries to create a new HardwareBuffer from settings in a [StreamConfig].
		pub fn create_hardware_buffer(&self) -> Option<HardwareBuffer> {
		HardwareBuffer::new(self.width, self.height, self.layers, self.format, self.usage)
		HardwareBuffer::new(&(*self).into())
		}
		}

		@@ -59,9 +72,10 @@ mod test {
		assert!(maybe_buffer.is_some());

		let buffer = maybe_buffer.unwrap();
		assert_eq!(config.width, buffer.width());
		assert_eq!(config.height, buffer.height());
		assert_eq!(config.format, buffer.format());
		assert_eq!(config.usage, buffer.usage());
		let description = buffer.description();
		assert_eq!(config.width, description.width());
		assert_eq!(config.height, description.height());
		assert_eq!(config.format, description.format());
		assert_eq!(config.usage, description.usage());
		}
		}

libs/nativewindow/rust/Android.bp

+4 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,8 @@ rust_bindgen {
		"--bitfield-enum=AHardwareBuffer_UsageFlags",

		"--allowlist-file=./nativewindow/include/.\\.h",
		"--allowlist-file=./include/cutils/.\\.h",
		"--allowlist-file=./include_outside_system/cutils/.\\.h",
		"--blocklist-type",
		"AParcel",
		"--raw-line",
		@@ -39,6 +41,7 @@ rust_bindgen {
		],
		shared_libs: [
		"libbinder_ndk",
		"libcutils",
		"libnativewindow",
		],
		rustlibs: [
		@@ -66,6 +69,7 @@ rust_library {
		srcs: [":libnativewindow_bindgen_internal"],
		shared_libs: [
		"libbinder_ndk",
		"libcutils",
		"libnativewindow",
		],
		rustlibs: [

libs/nativewindow/rust/src/handle.rs

0 → 100644

+92 −0

Original line number	Diff line number	Diff line
		// Copyright (C) 2024 The Android Open Source Project
		//
		// Licensed 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 std::{mem::forget, ptr::NonNull};

		/// Rust wrapper around `native_handle_t`.
		///
		/// This owns the `native_handle_t` and its file descriptors, and will close them and free it when
		/// it is dropped.
		#[derive(Debug)]
		pub struct NativeHandle(NonNull<ffi::native_handle_t>);

		impl NativeHandle {
		/// Wraps a raw `native_handle_t` pointer, taking ownership of it.
		///
		/// # Safety
		///
		/// `native_handle` must be a valid pointer to a `native_handle_t`, and must not be used
		/// anywhere else after calling this method.
		pub unsafe fn from_raw(native_handle: NonNull<ffi::native_handle_t>) -> Self {
		Self(native_handle)
		}

		/// Creates a new `NativeHandle` wrapping a clone of the given `native_handle_t` pointer.
		///
		/// Unlike [`from_raw`](Self::from_raw) this doesn't take ownership of the pointer passed in, so
		/// the caller remains responsible for closing and freeing it.
		///
		/// # Safety
		///
		/// `native_handle` must be a valid pointer to a `native_handle_t`.
		pub unsafe fn clone_from_raw(native_handle: NonNull<ffi::native_handle_t>) -> Option<Self> {
		// SAFETY: The caller promised that `native_handle` was valid.
		let cloned = unsafe { ffi::native_handle_clone(native_handle.as_ptr()) };
		NonNull::new(cloned).map(Self)
		}

		/// Returns a raw pointer to the wrapped `native_handle_t`.
		///
		/// This is only valid as long as this `NativeHandle` exists, so shouldn't be stored. It mustn't
		/// be closed or deleted.
		pub fn as_raw(&self) -> NonNull<ffi::native_handle_t> {
		self.0
		}

		/// Turns the `NativeHandle` into a raw `native_handle_t`.
		///
		/// The caller takes ownership of the `native_handle_t` and its file descriptors, so is
		/// responsible for closing and freeing it.
		pub fn into_raw(self) -> NonNull<ffi::native_handle_t> {
		let raw = self.0;
		forget(self);
		raw
		}
		}

		impl Clone for NativeHandle {
		fn clone(&self) -> Self {
		// SAFETY: Our wrapped `native_handle_t` pointer is always valid.
		unsafe { Self::clone_from_raw(self.0) }.expect("native_handle_clone returned null")
		}
		}

		impl Drop for NativeHandle {
		fn drop(&mut self) {
		// SAFETY: Our wrapped `native_handle_t` pointer is always valid, and it won't be accessed
		// after this because we own it and are being dropped.
		unsafe {
		assert_eq!(ffi::native_handle_close(self.0.as_ptr()), 0);
		assert_eq!(ffi::native_handle_delete(self.0.as_ptr()), 0);
		}
		}
		}

		// SAFETY: `NativeHandle` owns the `native_handle_t`, which just contains some integers and file
		// descriptors, which aren't tied to any particular thread.
		unsafe impl Send for NativeHandle {}

		// SAFETY: A `NativeHandle` can be used from different threads simultaneously, as is is just
		// integers and file descriptors.
		unsafe impl Sync for NativeHandle {}

libs/nativewindow/rust/src/lib.rs

+182 −84

Original line number	Diff line number	Diff line
		@@ -16,7 +16,10 @@

		extern crate nativewindow_bindgen as ffi;

		mod handle;
		mod surface;

		pub use handle::NativeHandle;
		pub use surface::Surface;

		pub use ffi::{AHardwareBuffer_Format, AHardwareBuffer_UsageFlags};
		@@ -27,31 +30,29 @@ use binder::{
		unstable_api::{status_result, AsNative},
		StatusCode,
		};
		use ffi::{AHardwareBuffer, AHardwareBuffer_readFromParcel, AHardwareBuffer_writeToParcel};
		use ffi::{
		AHardwareBuffer, AHardwareBuffer_Desc, AHardwareBuffer_readFromParcel,
		AHardwareBuffer_writeToParcel,
		};
		use std::fmt::{self, Debug, Formatter};
		use std::mem::ManuallyDrop;
		use std::ptr::{self, null_mut, NonNull};

		/// Wrapper around an opaque C `AHardwareBuffer`.
		#[derive(PartialEq, Eq)]
		pub struct HardwareBuffer(NonNull<AHardwareBuffer>);
		/// Wrapper around a C `AHardwareBuffer_Desc`.
		#[derive(Clone, Debug, PartialEq, Eq)]
		pub struct HardwareBufferDescription(AHardwareBuffer_Desc);

		impl HardwareBuffer {
		/// Test whether the given format and usage flag combination is allocatable. If this function
		/// returns true, it means that a buffer with the given description can be allocated on this
		/// implementation, unless resource exhaustion occurs. If this function returns false, it means
		/// that the allocation of the given description will never succeed.
		///
		/// Available since API 29
		pub fn is_supported(
		impl HardwareBufferDescription {
		/// Creates a new `HardwareBufferDescription` with the given parameters.
		pub fn new(
		width: u32,
		height: u32,
		layers: u32,
		format: AHardwareBuffer_Format::Type,
		usage: AHardwareBuffer_UsageFlags,
		stride: u32,
		) -> bool {
		let buffer_desc = ffi::AHardwareBuffer_Desc {
		) -> Self {
		Self(AHardwareBuffer_Desc {
		width,
		height,
		layers,
		@@ -60,9 +61,69 @@ impl HardwareBuffer {
		stride,
		rfu0: 0,
		rfu1: 0,
		};
		// SAFETY: *buffer_desc will never be null.
		let status = unsafe { ffi::AHardwareBuffer_isSupported(&buffer_desc) };
		})
		}

		/// Returns the width from the buffer description.
		pub fn width(&self) -> u32 {
		self.0.width
		}

		/// Returns the height from the buffer description.
		pub fn height(&self) -> u32 {
		self.0.height
		}

		/// Returns the number from layers from the buffer description.
		pub fn layers(&self) -> u32 {
		self.0.layers
		}

		/// Returns the format from the buffer description.
		pub fn format(&self) -> AHardwareBuffer_Format::Type {
		self.0.format
		}

		/// Returns the usage bitvector from the buffer description.
		pub fn usage(&self) -> AHardwareBuffer_UsageFlags {
		AHardwareBuffer_UsageFlags(self.0.usage)
		}

		/// Returns the stride from the buffer description.
		pub fn stride(&self) -> u32 {
		self.0.stride
		}
		}

		impl Default for HardwareBufferDescription {
		fn default() -> Self {
		Self(AHardwareBuffer_Desc {
		width: 0,
		height: 0,
		layers: 0,
		format: 0,
		usage: 0,
		stride: 0,
		rfu0: 0,
		rfu1: 0,
		})
		}
		}

		/// Wrapper around an opaque C `AHardwareBuffer`.
		#[derive(PartialEq, Eq)]
		pub struct HardwareBuffer(NonNull<AHardwareBuffer>);

		impl HardwareBuffer {
		/// Test whether the given format and usage flag combination is allocatable. If this function
		/// returns true, it means that a buffer with the given description can be allocated on this
		/// implementation, unless resource exhaustion occurs. If this function returns false, it means
		/// that the allocation of the given description will never succeed.
		///
		/// Available since API 29
		pub fn is_supported(buffer_description: &HardwareBufferDescription) -> bool {
		// SAFETY: The pointer comes from a reference so must be valid.
		let status = unsafe { ffi::AHardwareBuffer_isSupported(&buffer_description.0) };

		status == 1
		}
		@@ -74,27 +135,11 @@ impl HardwareBuffer {
		///
		/// Available since API level 26.
		#[inline]
		pub fn new(
		width: u32,
		height: u32,
		layers: u32,
		format: AHardwareBuffer_Format::Type,
		usage: AHardwareBuffer_UsageFlags,
		) -> Option<Self> {
		let buffer_desc = ffi::AHardwareBuffer_Desc {
		width,
		height,
		layers,
		format,
		usage: usage.0,
		stride: 0,
		rfu0: 0,
		rfu1: 0,
		};
		pub fn new(buffer_description: &HardwareBufferDescription) -> Option<Self> {
		let mut ptr = ptr::null_mut();
		// SAFETY: The returned pointer is valid until we drop/deallocate it. The function may fail
		// and return a status, but we check it later.
		let status = unsafe { ffi::AHardwareBuffer_allocate(&buffer_desc, &mut ptr) };
		let status = unsafe { ffi::AHardwareBuffer_allocate(&buffer_description.0, &mut ptr) };

		if status == 0 {
		Some(Self(NonNull::new(ptr).expect("Allocated AHardwareBuffer was null")))
		@@ -103,6 +148,50 @@ impl HardwareBuffer {
		}
		}

		/// Creates a `HardwareBuffer` from a native handle.
		///
		/// The native handle is cloned, so this doesn't take ownership of the original handle passed
		/// in.
		pub fn create_from_handle(
		handle: &NativeHandle,
		buffer_description: &HardwareBufferDescription,
		) -> Result<Self, StatusCode> {
		let mut buffer = ptr::null_mut();
		// SAFETY: The caller guarantees that `handle` is valid, and the buffer pointer is valid
		// because it comes from a reference. The method we pass means that
		// `AHardwareBuffer_createFromHandle` will clone the handle rather than taking ownership of
		// it.
		let status = unsafe {
		ffi::AHardwareBuffer_createFromHandle(
		&buffer_description.0,
		handle.as_raw().as_ptr(),
		ffi::CreateFromHandleMethod_AHARDWAREBUFFER_CREATE_FROM_HANDLE_METHOD_CLONE
		.try_into()
		.unwrap(),
		&mut buffer,
		)
		};
		status_result(status)?;
		Ok(Self(NonNull::new(buffer).expect("Allocated AHardwareBuffer was null")))
		}

		/// Returns a clone of the native handle of the buffer.
		///
		/// Returns `None` if the operation fails for any reason.
		pub fn cloned_native_handle(&self) -> Option<NativeHandle> {
		// SAFETY: The AHardwareBuffer pointer we pass is guaranteed to be non-null and valid
		// because it must have been allocated by `AHardwareBuffer_allocate`,
		// `AHardwareBuffer_readFromParcel` or the caller of `from_raw` and we have not yet
		// released it.
		let native_handle = unsafe { ffi::AHardwareBuffer_getNativeHandle(self.0.as_ptr()) };
		NonNull::new(native_handle.cast_mut()).and_then(\|native_handle\| {
		// SAFETY: `AHardwareBuffer_getNativeHandle` should have returned a valid pointer which
		// is valid at least as long as the buffer is, and `clone_from_raw` clones it rather
		// than taking ownership of it so the original `native_handle` isn't stored.
		unsafe { NativeHandle::clone_from_raw(native_handle) }
		})
		}

		/// Adopts the given raw pointer and wraps it in a Rust HardwareBuffer.
		///
		/// # Safety
		@@ -155,37 +244,8 @@ impl HardwareBuffer {
		out_id
		}

		/// Get the width of this buffer
		pub fn width(&self) -> u32 {
		self.description().width
		}

		/// Get the height of this buffer
		pub fn height(&self) -> u32 {
		self.description().height
		}

		/// Get the number of layers of this buffer
		pub fn layers(&self) -> u32 {
		self.description().layers
		}

		/// Get the format of this buffer
		pub fn format(&self) -> AHardwareBuffer_Format::Type {
		self.description().format
		}

		/// Get the usage bitvector of this buffer
		pub fn usage(&self) -> AHardwareBuffer_UsageFlags {
		AHardwareBuffer_UsageFlags(self.description().usage)
		}

		/// Get the stride of this buffer
		pub fn stride(&self) -> u32 {
		self.description().stride
		}

		fn description(&self) -> ffi::AHardwareBuffer_Desc {
		/// Returns the description of this buffer.
		pub fn description(&self) -> HardwareBufferDescription {
		let mut buffer_desc = ffi::AHardwareBuffer_Desc {
		width: 0,
		height: 0,
		@@ -198,7 +258,7 @@ impl HardwareBuffer {
		};
		// SAFETY: neither the buffer nor AHardwareBuffer_Desc pointers will be null.
		unsafe { ffi::AHardwareBuffer_describe(self.0.as_ref(), &mut buffer_desc) };
		buffer_desc
		HardwareBufferDescription(buffer_desc)
		}
		}

		@@ -281,19 +341,27 @@ mod test {

		#[test]
		fn create_valid_buffer_returns_ok() {
		let buffer = HardwareBuffer::new(
		let buffer = HardwareBuffer::new(&HardwareBufferDescription::new(
		512,
		512,
		1,
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
		);
		0,
		));
		assert!(buffer.is_some());
		}

		#[test]
		fn create_invalid_buffer_returns_err() {
		let buffer = HardwareBuffer::new(512, 512, 1, 0, AHardwareBuffer_UsageFlags(0));
		let buffer = HardwareBuffer::new(&HardwareBufferDescription::new(
		512,
		512,
		1,
		0,
		AHardwareBuffer_UsageFlags(0),
		0,
		));
		assert!(buffer.is_none());
		}

		@@ -319,39 +387,45 @@ mod test {
		// SAFETY: The pointer must be valid because it was just allocated successfully, and we
		// don't use it after calling this.
		let buffer = unsafe { HardwareBuffer::from_raw(NonNull::new(raw_buffer_ptr).unwrap()) };
		assert_eq!(buffer.width(), 1024);
		assert_eq!(buffer.description().width(), 1024);
		}

		#[test]
		fn basic_getters() {
		let buffer = HardwareBuffer::new(
		let buffer = HardwareBuffer::new(&HardwareBufferDescription::new(
		1024,
		512,
		1,
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
		)
		0,
		))
		.expect("Buffer with some basic parameters was not created successfully");

		assert_eq!(buffer.width(), 1024);
		assert_eq!(buffer.height(), 512);
		assert_eq!(buffer.layers(), 1);
		assert_eq!(buffer.format(), AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM);
		let description = buffer.description();
		assert_eq!(description.width(), 1024);
		assert_eq!(description.height(), 512);
		assert_eq!(description.layers(), 1);
		assert_eq!(
		description.format(),
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM
		);
		assert_eq!(
		buffer.usage(),
		description.usage(),
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN
		);
		}

		#[test]
		fn id_getter() {
		let buffer = HardwareBuffer::new(
		let buffer = HardwareBuffer::new(&HardwareBufferDescription::new(
		1024,
		512,
		1,
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
		)
		0,
		))
		.expect("Buffer with some basic parameters was not created successfully");

		assert_ne!(0, buffer.id());
		@@ -359,13 +433,14 @@ mod test {

		#[test]
		fn clone() {
		let buffer = HardwareBuffer::new(
		let buffer = HardwareBuffer::new(&HardwareBufferDescription::new(
		1024,
		512,
		1,
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
		)
		0,
		))
		.expect("Buffer with some basic parameters was not created successfully");
		let buffer2 = buffer.clone();

		@@ -374,13 +449,14 @@ mod test {

		#[test]
		fn into_raw() {
		let buffer = HardwareBuffer::new(
		let buffer = HardwareBuffer::new(&HardwareBufferDescription::new(
		1024,
		512,
		1,
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
		)
		0,
		))
		.expect("Buffer with some basic parameters was not created successfully");
		let buffer2 = buffer.clone();

		@@ -390,4 +466,26 @@ mod test {

		assert_eq!(remade_buffer, buffer2);
		}

		#[test]
		fn native_handle_and_back() {
		let buffer_description = HardwareBufferDescription::new(
		1024,
		512,
		1,
		AHardwareBuffer_Format::AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM,
		AHardwareBuffer_UsageFlags::AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN,
		1024,
		);
		let buffer = HardwareBuffer::new(&buffer_description)
		.expect("Buffer with some basic parameters was not created successfully");

		let native_handle =
		buffer.cloned_native_handle().expect("Failed to get native handle for buffer");
		let buffer2 = HardwareBuffer::create_from_handle(&native_handle, &buffer_description)
		.expect("Failed to create buffer from native handle");

		assert_eq!(buffer.description(), buffer_description);
		assert_eq!(buffer2.description(), buffer_description);
		}
		}