am 62f39c10: merge from open-source master (573463c3) · Commits · e / os / android_system_core

include/arch/linux-sh/AndroidConfig.h

0 → 100644

+327 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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.
		*/

		/*
		* Android config -- "android-sh". Used for SuperH device builds.
		*/
		#ifndef _ANDROID_CONFIG_H
		#define _ANDROID_CONFIG_H

		/*
		* ===========================================================================
		* !!! IMPORTANT !!!
		* ===========================================================================
		*
		* This file is included by ALL C/C++ source files. Don't put anything in
		* here unless you are absolutely certain it can't go anywhere else.
		*
		* Any C++ stuff must be wrapped with "#ifdef __cplusplus". Do not use "//"
		* comments.
		*/

		/*
		* Threading model. Choose one:
		*
		* HAVE_PTHREADS - use the pthreads library.
		* HAVE_WIN32_THREADS - use Win32 thread primitives.
		* -- combine HAVE_CREATETHREAD, HAVE_CREATEMUTEX, and HAVE__BEGINTHREADEX
		*/
		#define HAVE_PTHREADS

		/*
		* Do we have the futex syscall?
		*/

		#define HAVE_FUTEX

		/*
		* Define if we already have the futex wrapper functions defined. Yes if
		* compiling against bionic.
		*/
		#define HAVE_FUTEX_WRAPPERS 1

		/*
		* Process creation model. Choose one:
		*
		* HAVE_FORKEXEC - use fork() and exec()
		* HAVE_WIN32_PROC - use CreateProcess()
		*/
		#define HAVE_FORKEXEC

		/*
		* Process out-of-memory adjustment. Set if running on Linux,
		* where we can write to /proc/<pid>/oom_adj to modify the out-of-memory
		* badness adjustment.
		*/
		#define HAVE_OOM_ADJ

		/*
		* IPC model. Choose one:
		*
		* HAVE_SYSV_IPC - use the classic SysV IPC mechanisms (semget, shmget).
		* HAVE_MACOSX_IPC - use Macintosh IPC mechanisms (sem_open, mmap).
		* HAVE_WIN32_IPC - use Win32 IPC (CreateSemaphore, CreateFileMapping).
		* HAVE_ANDROID_IPC - use Android versions (?, mmap).
		*/
		#define HAVE_ANDROID_IPC

		/*
		* Memory-mapping model. Choose one:
		*
		* HAVE_POSIX_FILEMAP - use the Posix sys/mmap.h
		* HAVE_WIN32_FILEMAP - use Win32 filemaps
		*/
		#define HAVE_POSIX_FILEMAP

		/*
		* Define this if you have <termio.h>
		*/
		#define HAVE_TERMIO_H

		/*
		* Define this if you build against MSVCRT.DLL
		*/
		/* #define HAVE_MS_C_RUNTIME */

		/*
		* Define this if you have sys/uio.h
		*/
		#define HAVE_SYS_UIO_H

		/*
		* Define this if your platforms implements symbolic links
		* in its filesystems
		*/
		#define HAVE_SYMLINKS

		/*
		* Define this if we have localtime_r().
		*/
		/* #define HAVE_LOCALTIME_R */

		/*
		* Define this if we have gethostbyname_r().
		*/
		/* #define HAVE_GETHOSTBYNAME_R */

		/*
		* Define this if we have ioctl().
		*/
		#define HAVE_IOCTL

		/*
		* Define this if we want to use WinSock.
		*/
		/* #define HAVE_WINSOCK */

		/*
		* Define this if have clock_gettime() and friends
		*/
		#define HAVE_POSIX_CLOCKS

		/*
		* Define this if we have pthread_cond_timedwait_monotonic() and
		* clock_gettime(CLOCK_MONOTONIC).
		*/
		/* #define HAVE_TIMEDWAIT_MONOTONIC */

		/*
		* Define this if we have linux style epoll()
		*/
		#define HAVE_EPOLL

		/*
		* Endianness of the target machine. Choose one:
		*
		* HAVE_ENDIAN_H -- have endian.h header we can include.
		* HAVE_LITTLE_ENDIAN -- we are little endian.
		* HAVE_BIG_ENDIAN -- we are big endian.
		*/
		#define HAVE_ENDIAN_H
		#define HAVE_LITTLE_ENDIAN

		/*
		* We need to choose between 32-bit and 64-bit off_t. All of our code should
		* agree on the same size. For desktop systems, use 64-bit values,
		* because some of our libraries (e.g. wxWidgets) expect to be built that way.
		*/
		/* #define _FILE_OFFSET_BITS 64 */
		/* #define _LARGEFILE_SOURCE 1 */

		/*
		* Defined if we have the backtrace() call for retrieving a stack trace.
		* Needed for CallStack to operate; if not defined, CallStack is
		* non-functional.
		*/
		#define HAVE_BACKTRACE 0

		/*
		* Defined if we have the dladdr() call for retrieving the symbol associated
		* with a memory address. If not defined, stack crawls will not have symbolic
		* information.
		*/
		#define HAVE_DLADDR 0

		/*
		* Defined if we have the cxxabi.h header for demangling C++ symbols. If
		* not defined, stack crawls will be displayed with raw mangled symbols
		*/
		#define HAVE_CXXABI 0

		/*
		* Defined if we have the gettid() system call.
		*/
		#define HAVE_GETTID

		/*
		* Defined if we have the sched_setscheduler() call
		*/
		#define HAVE_SCHED_SETSCHEDULER

		/*
		* Add any extra platform-specific defines here.
		*/
		/* #define __linux__ / / for SuperH */

		/*
		* Define if we have <malloc.h> header
		*/
		#define HAVE_MALLOC_H

		/*
		* Define if we're running on our linux on device or emulator.
		*/
		#define HAVE_ANDROID_OS 1

		/*
		* Define if we have Linux-style non-filesystem Unix Domain Sockets
		*/
		#define HAVE_LINUX_LOCAL_SOCKET_NAMESPACE 1

		/*
		* Define if we have Linux's inotify in <sys/inotify.h>.
		*/
		#define HAVE_INOTIFY 1

		/*
		* Define if we have madvise() in <sys/mman.h>
		*/
		#define HAVE_MADVISE 1

		/*
		* Define if tm struct has tm_gmtoff field
		*/
		#define HAVE_TM_GMTOFF 1

		/*
		* Define if dirent struct has d_type field
		*/
		#define HAVE_DIRENT_D_TYPE 1

		/*
		* Define if libc includes Android system properties implementation.
		*/
		#define HAVE_LIBC_SYSTEM_PROPERTIES 1

		/*
		* Define if system provides a system property server (should be
		* mutually exclusive with HAVE_LIBC_SYSTEM_PROPERTIES).
		*/
		/* #define HAVE_SYSTEM_PROPERTY_SERVER */

		/*
		* What CPU architecture does this platform use?
		*/
		#define ARCH_SH

		/*
		* Define if the size of enums is as short as possible,
		*/
		/* #define HAVE_SHORT_ENUMS */

		/*
		* sprintf() format string for shared library naming.
		*/
		#define OS_SHARED_LIB_FORMAT_STR "lib%s.so"

		/*
		* Do we have __memcmp16()?
		*
		* TODO : Investigate the perfomance impact of __memcmp16()
		* and implement it.
		* This influences on dalvikVM's string performance.
		* See dalvik/vm/InlineNative.c.
		*/
		/* #define HAVE__MEMCMP16 */

		/*
		* type for the third argument to mincore().
		*/
		#define MINCORE_POINTER_TYPE unsigned char *

		/*
		* Do we have the sigaction flag SA_NOCLDWAIT?
		*/
		#define HAVE_SA_NOCLDWAIT

		/*
		* The default path separator for the platform
		*/
		#define OS_PATH_SEPARATOR '/'

		/*
		* Is the filesystem case sensitive?
		*/
		#define OS_CASE_SENSITIVE

		/*
		* Define if <sys/socket.h> exists.
		*/
		#define HAVE_SYS_SOCKET_H 1

		/*
		* Define if the strlcpy() function exists on the system.
		*/
		#define HAVE_STRLCPY 1

		/*
		* Define if prctl() exists
		*/
		#define HAVE_PRCTL 1

		/*
		* Define if writev() exists
		*/
		#define HAVE_WRITEV 1

		/*
		* For dalvik/libcore
		*/
		#define CANT_PASS_VALIST_AS_CHARPTR

		/*
		* For external/bluez/utils/tools/hciattach.c
		* TODO : This definition should be somewhere in bionic/libc/kernel/(*).
		* Cosider the place and move it there.
		*/
		#define N_TTY 0

		/*
		* Whether or not _Unwind_Context is defined as a struct.
		*/
		#define HAVE_UNWIND_CONTEXT_STRUCT

		#endif /* _ANDROID_CONFIG_H */

include/sysutils/NetlinkListener.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -26,7 +26,9 @@ class NetlinkListener : public SocketListener {
		public:
		NetlinkListener(int socket);
		virtual ~NetlinkListener() {}

		protected:
		virtual bool onDataAvailable(SocketClient *cli);
		virtual void onEvent(NetlinkEvent *evt) = 0;
		};
		#endif

libcutils/Android.mk

+4 −0

Original line number	Diff line number	Diff line
		@@ -103,7 +103,11 @@ LOCAL_SRC_FILES := $(commonSources) ashmem-dev.c mq.c
		ifeq ($(TARGET_ARCH),arm)
		LOCAL_SRC_FILES += memset32.S atomic-android-arm.S
		else # !arm
		ifeq ($(TARGET_ARCH),sh)
		LOCAL_SRC_FILES += memory.c atomic-android-sh.c
		else # !sh
		LOCAL_SRC_FILES += memory.c
		endif # !sh
		endif # !arm

		LOCAL_C_INCLUDES := $(KERNEL_HEADERS)

libcutils/atomic-android-sh.c

0 → 100644

+159 −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.
		*/

		#include <cutils/atomic.h>
		#ifdef HAVE_WIN32_THREADS
		#include <windows.h>
		#else
		#include <sched.h>
		#endif

		/*
		* Note :
		*
		* (1) SuperH does not have CMPXCHG. It has only TAS for atomic
		* operations. It does not seem a good idea to implement CMPXCHG,
		* with TAS. So, we choose to implemnt these operations with
		* posix mutexes. Please be sure that this might cause performance
		* problem for Android-SH. Using LL/SC instructions supported in SH-X3,
		* best performnace would be realized.
		*
		* (2) Mutex initialization problem happens, which is commented for
		* ARM implementation, in this file above.
		* We follow the fact that the initializer for mutex is a simple zero
		* value.
		*/

		#include <pthread.h>

		#define SWAP_LOCK_COUNT 32U
		static pthread_mutex_t _swap_locks[SWAP_LOCK_COUNT];

		#define SWAP_LOCK(addr) \
		&_swap_locks[((unsigned)(void*)(addr) >> 3U) % SWAP_LOCK_COUNT]


		void android_atomic_write(int32_t value, volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, value, addr));
		}

		int32_t android_atomic_inc(volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, oldValue+1, addr));
		return oldValue;
		}

		int32_t android_atomic_dec(volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, oldValue-1, addr));
		return oldValue;
		}

		int32_t android_atomic_add(int32_t value, volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, oldValue+value, addr));
		return oldValue;
		}

		int32_t android_atomic_and(int32_t value, volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, oldValue&value, addr));
		return oldValue;
		}

		int32_t android_atomic_or(int32_t value, volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, oldValue\|value, addr));
		return oldValue;
		}

		int32_t android_atomic_swap(int32_t value, volatile int32_t* addr) {
		int32_t oldValue;
		do {
		oldValue = *addr;
		} while (android_atomic_cmpxchg(oldValue, value, addr));
		return oldValue;
		}

		int android_atomic_cmpxchg(int32_t oldvalue, int32_t newvalue,
		volatile int32_t* addr) {
		int result;
		pthread_mutex_t* lock = SWAP_LOCK(addr);

		pthread_mutex_lock(lock);

		if (*addr == oldvalue) {
		*addr = newvalue;
		result = 0;
		} else {
		result = 1;
		}
		pthread_mutex_unlock(lock);
		return result;
		}

		int64_t android_quasiatomic_swap_64(int64_t value, volatile int64_t* addr) {
		int64_t oldValue;
		pthread_mutex_t* lock = SWAP_LOCK(addr);

		pthread_mutex_lock(lock);

		oldValue = *addr;
		*addr = value;

		pthread_mutex_unlock(lock);
		return oldValue;
		}

		int android_quasiatomic_cmpxchg_64(int64_t oldvalue, int64_t newvalue,
		volatile int64_t* addr) {
		int result;
		pthread_mutex_t* lock = SWAP_LOCK(addr);

		pthread_mutex_lock(lock);

		if (*addr == oldvalue) {
		*addr = newvalue;
		result = 0;
		} else {
		result = 1;
		}
		pthread_mutex_unlock(lock);
		return result;
		}

		int64_t android_quasiatomic_read_64(volatile int64_t* addr) {
		int64_t result;
		pthread_mutex_t* lock = SWAP_LOCK(addr);

		pthread_mutex_lock(lock);
		result = *addr;
		pthread_mutex_unlock(lock);
		return result;
		}

libcutils/atomic.c

+4 −0

Original line number	Diff line number	Diff line
		@@ -245,6 +245,10 @@ int64_t android_quasiatomic_read_64(volatile int64_t* addr) {
		return result;
		}

		/*****************************************************************************/
		#elif __sh__
		// implementation for SuperH is in atomic-android-sh.c.

		#else

		#error "Unsupported atomic operations for this platform"