From 1d3faaf72f28c9d71dde067b74b1351cdbc9a758 Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Fri, 10 Apr 2009 14:24:31 -0700 Subject: [PATCH] Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support. --- include/cutils/ashmem.h | 2 + include/cutils/native_handle.h | 66 +++++++++++++++++++++ libcutils/Android.mk | 1 + libcutils/native_handle.c | 104 +++++++++++++++++++++++++++++++++ 4 files changed, 173 insertions(+) create mode 100644 libcutils/native_handle.c diff --git a/include/cutils/ashmem.h b/include/cutils/ashmem.h index fd71352eb..6e19ad4b4 100644 --- a/include/cutils/ashmem.h +++ b/include/cutils/ashmem.h @@ -10,6 +10,8 @@ #ifndef _CUTILS_ASHMEM_H #define _CUTILS_ASHMEM_H +#include + #ifdef __cplusplus extern "C" { #endif diff --git a/include/cutils/native_handle.h b/include/cutils/native_handle.h index 2b648935c..298270b43 100644 --- a/include/cutils/native_handle.h +++ b/include/cutils/native_handle.h @@ -17,6 +17,10 @@ #ifndef NATIVE_HANDLE_H_ #define NATIVE_HANDLE_H_ +#include + +__BEGIN_DECLS + typedef struct { int version; /* sizeof(native_handle) */ @@ -25,4 +29,66 @@ typedef struct int data[0]; /* numFds + numInts ints */ } native_handle; + +/* + * native_handle_dup + * + * duplicates a native handle. All source file descriptors are dup()'ed. + * + * lhs.numFds must be 0 or match rhs.numFds + * lhs.numInts must be 0 or match rhs.numInts + * + * if lhs.numFds and lhs.numInts are set to 0, they are the only fields + * updated, this can be used to figure out the size needed for copying rhs. + * + * return 0 on success, or a negative error code on failure + * + */ +int native_handle_dup(native_handle* lhs, native_handle const* rhs); + + +/* + * native_handle_close + * + * closes the file descriptors contained in this native_handle + * + * return 0 on success, or a negative error code on failure + * + */ +int native_handle_close(const native_handle* h); + + +/* + * native_handle_create + * + * creates a native_handle and initializes it. must be destroyed with + * native_handle_delete(). + * + */ +native_handle* native_handle_create(int numFds, int numInts); + +/* + * native_handle_delete + * + * frees a native_handle allocated with native_handle_create(). + * This ONLY frees the memory allocated for the native_handle, but doesn't + * close the file descriptors; which can be achieved with native_handle_close(). + * + * return 0 on success, or a negative error code on failure + * + */ +int native_handle_delete(native_handle* h); + + +/* + * native_handle_copy + * + * makes a deep copy of rhs. If rhs is null, returns null. + * + */ +native_handle* native_handle_copy(const native_handle* rhs); + + +__END_DECLS + #endif /* NATIVE_HANDLE_H_ */ diff --git a/libcutils/Android.mk b/libcutils/Android.mk index b6d806e46..3bc48fb6b 100644 --- a/libcutils/Android.mk +++ b/libcutils/Android.mk @@ -20,6 +20,7 @@ commonSources := \ array.c \ hashmap.c \ atomic.c \ + native_handle.c \ buffer.c \ socket_inaddr_any_server.c \ socket_local_client.c \ diff --git a/libcutils/native_handle.c b/libcutils/native_handle.c new file mode 100644 index 000000000..47f695062 --- /dev/null +++ b/libcutils/native_handle.c @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2007 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. + */ + +#define LOG_TAG "Gralloc" + +#include +#include +#include +#include +#include + +#include +#include + +native_handle* native_handle_create(int numFds, int numInts) +{ + native_handle* h = malloc( + sizeof(native_handle) + sizeof(int)*(numFds+numInts)); + + h->version = sizeof(native_handle); + h->numFds = numFds; + h->numInts = numInts; + return h; +} + +int native_handle_delete(native_handle* h) +{ + if (h) { + if (h->version != sizeof(native_handle)) + return -EINVAL; + free(h); + } + return 0; +} + +int native_handle_dup(native_handle* lhs, native_handle const* rhs) +{ + if (rhs->version != sizeof(native_handle)) + return -EINVAL; + + if (lhs->version != sizeof(native_handle)) + return -EINVAL; + + const int numFds = rhs->numFds; + const int numInts = rhs->numInts; + + if (lhs->numFds == 0 && lhs->numInts == 0) { + lhs->numFds = numFds; + lhs->numInts = numInts; + return 0; + } + + if (lhs->numFds != numFds) + return -EINVAL; + + if (lhs->numInts != numInts) + return -EINVAL; + + int i; + for (i=0 ; idata[i] = dup( rhs->data[i] ); + } + memcpy(&lhs->data[i], &rhs->data[i], numInts*sizeof(int)); + return 0; +} + +int native_handle_close(const native_handle* h) +{ + if (h->version != sizeof(native_handle)) + return -EINVAL; + + const int numFds = h->numFds; + int i; + for (i=0 ; idata[i]); + } + return 0; +} + +native_handle* native_handle_copy(const native_handle* rhs) +{ + if (rhs == 0) + return 0; + + native_handle* lhs = native_handle_create(rhs->numFds, rhs->numInts); + if (native_handle_dup(lhs, rhs) < 0) { + native_handle_delete(lhs); + lhs = 0; + } + return lhs; +}