diff options
Diffstat (limited to 'android/utils/system.h')
| -rw-r--r-- | android/utils/system.h | 161 |
1 files changed, 161 insertions, 0 deletions
diff --git a/android/utils/system.h b/android/utils/system.h new file mode 100644 index 0000000..804aa7d --- /dev/null +++ b/android/utils/system.h @@ -0,0 +1,161 @@ +/* Copyright (C) 2008 The Android Open Source Project +** +** This software is licensed under the terms of the GNU General Public +** License version 2, as published by the Free Software Foundation, and +** may be copied, distributed, and modified under those terms. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +*/ +#ifndef _ANDROID_UTILS_SYSTEM_H +#define _ANDROID_UTILS_SYSTEM_H + +#include <string.h> +#include <stdint.h> + +/* the following functions perform 'checked allocations', i.e. + * they abort if there is not enough memory. + */ + +/* checked malloc, only returns NULL if size is 0 */ +void* android_alloc( size_t size ); + +/* checked calloc, only returns NULL if size is 0 */ +void* android_alloc0( size_t size ); + +/* checked realloc, only returns NULL if size if 0 */ +void* android_realloc( void* block, size_t size ); + +/* free memory block */ +void android_free( void* block ); + +/* convenience macros */ + +#define AZERO(p) memset((char*)(p),0,sizeof(*(p))) +#define ANEW(p) (p = android_alloc(sizeof(*p))) +#define ANEW0(p) (p = android_alloc0(sizeof(*p))) +#define AFREE(p) android_free(p) + +#define AMEM_ZERO(dst,size) memset((char*)(dst), 0, (size_t)(size)) +#define AMEM_COPY(dst,src,size) memcpy((char*)(dst),(const char*)(src),(size_t)(size)) +#define AMEM_MOVE(dst,src,size) memmove((char*)(dst),(const char*)(src),(size_t)(size)) + +#define AARRAY_NEW(p,count) ((p) = android_alloc(sizeof(*p)*(count))) +#define AARRAY_NEW0(p,count) ((p) = android_alloc0(sizeof(*p)*(count))) + +#define AARRAY_RENEW(p,count) ((p) = android_realloc((p),sizeof(*(p))*(count))) + +#define AARRAY_COPY(dst,src,count) AMEM_COPY(dst,src,(count)*sizeof((dst)[0])) +#define AARRAY_MOVE(dst,src,count) AMEM_MOVE(dst,src,(count)*sizeof((dst)[0])) +#define AARRAY_ZERO(dst,count) AMEM_ZERO(dst,(count)*sizeof((dst)[0])) + +#define AARRAY_STATIC_LEN(a) (sizeof((a))/sizeof((a)[0])) + +#define AINLINED static __inline__ + +/* unlike strdup(), this accepts NULL as valid input (and will return NULL then) */ +char* android_strdup(const char* src); + +#define ASTRDUP(str) android_strdup(str) + +/* used for functions that return a Posix-style status code, i.e. + * 0 means success, -1 means failure with the error code in 'errno' + */ +typedef int APosixStatus; + +/* used for functions that return or accept a boolean type */ +typedef int ABool; + +/** Stringification macro + **/ +#ifndef STRINGIFY +#define _STRINGIFY(x) #x +#define STRINGIFY(x) _STRINGIFY(x) +#endif + +/** Concatenation macros + **/ +#ifndef GLUE +#define _GLUE(x,y) x##y +#define GLUE(x,y) _GLUE(x,y) + +#define _GLUE3(x,y,z) x##y##z +#define GLUE3(x,y,z) _GLUE3(x,y,z) +#endif + +/** Handle strsep() on Win32 + **/ +#ifdef _WIN32 +# undef strsep +# define strsep win32_strsep +extern char* win32_strsep(char** pline, const char* delim); +#endif + +/** Handle strcasecmp on Windows + **/ +#ifdef _WIN32 +# define strcasecmp stricmp +#endif + +/** EINTR HANDLING + ** + ** since QEMU uses SIGALRM pretty extensively, having a system call returning + ** EINTR on Unix happens very frequently. provide a simple macro to guard against + ** this. + **/ + +#ifdef _WIN32 +# define CHECKED(ret, call) (ret) = (call) +#else +# define CHECKED(ret, call) do { (ret) = (call); } while ((ret) < 0 && errno == EINTR) +#endif + +/** SIGNAL HANDLING + ** + ** the following can be used to block SIGALRM for a given period of time. + ** use with caution, the QEMU execution loop uses SIGALRM extensively + ** + **/ +#ifdef _WIN32 +typedef struct { int dumy; } signal_state_t; +#else +#include <signal.h> +typedef struct { sigset_t old; } signal_state_t; +#endif + +extern void disable_sigalrm( signal_state_t *state ); +extern void restore_sigalrm( signal_state_t *state ); + +#ifdef _WIN32 + +#define BEGIN_NOSIGALRM \ + { + +#define END_NOSIGALRM \ + } + +#else /* !WIN32 */ + +#define BEGIN_NOSIGALRM \ + { signal_state_t __sigalrm_state; \ + disable_sigalrm( &__sigalrm_state ); + +#define END_NOSIGALRM \ + restore_sigalrm( &__sigalrm_state ); \ + } + +#endif /* !WIN32 */ + +/** TIME HANDLING + ** + ** sleep for a given time in milliseconds. note: this uses + ** disable_sigalrm()/restore_sigalrm() + **/ + +extern void sleep_ms( int timeout ); + +/* */ + +#endif /* _ANDROID_UTILS_SYSTEM_H */ |