Integrate from //sandbox/mathias/donut/...@145728 (1d3faaf7) · Commits · e / os / android_system_core

include/cutils/ashmem.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -10,6 +10,8 @@
		#ifndef _CUTILS_ASHMEM_H
		#define _CUTILS_ASHMEM_H

		#include <stdint.h>

		#ifdef __cplusplus
		extern "C" {
		#endif

include/cutils/native_handle.h

+66 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,10 @@
		#ifndef NATIVE_HANDLE_H_
		#define NATIVE_HANDLE_H_

		#include <sys/cdefs.h>

		__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_ */

libcutils/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -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 \

libcutils/native_handle.c

0 → 100644

+104 −0

Original line number	Diff line number	Diff line
		/*
		* 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 <stdint.h>
		#include <errno.h>
		#include <string.h>
		#include <stdlib.h>
		#include <unistd.h>

		#include <cutils/log.h>
		#include <cutils/native_handle.h>

		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 ; i<numFds ; i++) {
		lhs->data[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 ; i<numFds ; i++) {
		close(h->data[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;
		}