1 /* Copyright (C) 2008 The Android Open Source Project 2 ** 3 ** This software is licensed under the terms of the GNU General Public 4 ** License version 2, as published by the Free Software Foundation, and 5 ** may be copied, distributed, and modified under those terms. 6 ** 7 ** This program is distributed in the hope that it will be useful, 8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 ** GNU General Public License for more details. 11 */ 12 #ifndef _ANDROID_UTILS_SYSTEM_H 13 #define _ANDROID_UTILS_SYSTEM_H 14 15 #include <string.h> 16 #include <stdint.h> 17 18 /* the following functions perform 'checked allocations', i.e. 19 * they abort if there is not enough memory. 20 */ 21 22 /* checked malloc, only returns NULL if size is 0 */ 23 void* android_alloc( size_t size ); 24 25 /* checked calloc, only returns NULL if size is 0 */ 26 void* android_alloc0( size_t size ); 27 28 /* checked realloc, only returns NULL if size if 0 */ 29 void* android_realloc( void* block, size_t size ); 30 31 /* free memory block */ 32 void android_free( void* block ); 33 34 /* convenience macros */ 35 36 #define AZERO(p) memset((char*)(p),0,sizeof(*(p))) 37 #define ANEW(p) (p = android_alloc(sizeof(*p))) 38 #define ANEW0(p) (p = android_alloc0(sizeof(*p))) 39 #define AFREE(p) android_free(p) 40 41 #define AMEM_ZERO(dst,size) memset((char*)(dst), 0, (size_t)(size)) 42 #define AMEM_COPY(dst,src,size) memcpy((char*)(dst),(const char*)(src),(size_t)(size)) 43 #define AMEM_MOVE(dst,src,size) memmove((char*)(dst),(const char*)(src),(size_t)(size)) 44 45 #define AARRAY_NEW(p,count) ((p) = android_alloc(sizeof(*p)*(count))) 46 #define AARRAY_NEW0(p,count) ((p) = android_alloc0(sizeof(*p)*(count))) 47 48 #define AARRAY_RENEW(p,count) ((p) = android_realloc((p),sizeof(*(p))*(count))) 49 50 #define AARRAY_COPY(dst,src,count) AMEM_COPY(dst,src,(count)*sizeof((dst)[0])) 51 #define AARRAY_MOVE(dst,src,count) AMEM_MOVE(dst,src,(count)*sizeof((dst)[0])) 52 #define AARRAY_ZERO(dst,count) AMEM_ZERO(dst,(count)*sizeof((dst)[0])) 53 54 #define AARRAY_STATIC_LEN(a) (sizeof((a))/sizeof((a)[0])) 55 56 #define AINLINED static __inline__ 57 58 /* unlike strdup(), this accepts NULL as valid input (and will return NULL then) */ 59 char* android_strdup(const char* src); 60 61 #define ASTRDUP(str) android_strdup(str) 62 63 /* used for functions that return a Posix-style status code, i.e. 64 * 0 means success, -1 means failure with the error code in 'errno' 65 */ 66 typedef int APosixStatus; 67 68 /* used for functions that return or accept a boolean type */ 69 typedef int ABool; 70 71 /** Stringification macro 72 **/ 73 #ifndef STRINGIFY 74 #define _STRINGIFY(x) #x 75 #define STRINGIFY(x) _STRINGIFY(x) 76 #endif 77 78 /** Concatenation macros 79 **/ 80 #ifndef GLUE 81 #define _GLUE(x,y) x##y 82 #define GLUE(x,y) _GLUE(x,y) 83 84 #define _GLUE3(x,y,z) x##y##z 85 #define GLUE3(x,y,z) _GLUE3(x,y,z) 86 #endif 87 88 /** Handle strsep() on Win32 89 **/ 90 #ifdef _WIN32 91 # undef strsep 92 # define strsep win32_strsep 93 extern char* win32_strsep(char** pline, const char* delim); 94 #endif 95 96 /** Handle strcasecmp on Windows 97 **/ 98 #ifdef _WIN32 99 # define strcasecmp stricmp 100 #endif 101 102 /** EINTR HANDLING 103 ** 104 ** since QEMU uses SIGALRM pretty extensively, having a system call returning 105 ** EINTR on Unix happens very frequently. provide a simple macro to guard against 106 ** this. 107 **/ 108 109 #ifdef _WIN32 110 # define CHECKED(ret, call) (ret) = (call) 111 #else 112 # define CHECKED(ret, call) do { (ret) = (call); } while ((ret) < 0 && errno == EINTR) 113 #endif 114 115 /** SIGNAL HANDLING 116 ** 117 ** the following can be used to block SIGALRM for a given period of time. 118 ** use with caution, the QEMU execution loop uses SIGALRM extensively 119 ** 120 **/ 121 #ifdef _WIN32 122 typedef struct { int dumy; } signal_state_t; 123 #else 124 #include <signal.h> 125 typedef struct { sigset_t old; } signal_state_t; 126 #endif 127 128 extern void disable_sigalrm( signal_state_t *state ); 129 extern void restore_sigalrm( signal_state_t *state ); 130 131 #ifdef _WIN32 132 133 #define BEGIN_NOSIGALRM \ 134 { 135 136 #define END_NOSIGALRM \ 137 } 138 139 #else /* !WIN32 */ 140 141 #define BEGIN_NOSIGALRM \ 142 { signal_state_t __sigalrm_state; \ 143 disable_sigalrm( &__sigalrm_state ); 144 145 #define END_NOSIGALRM \ 146 restore_sigalrm( &__sigalrm_state ); \ 147 } 148 149 #endif /* !WIN32 */ 150 151 /** TIME HANDLING 152 ** 153 ** sleep for a given time in milliseconds. note: this uses 154 ** disable_sigalrm()/restore_sigalrm() 155 **/ 156 157 extern void sleep_ms( int timeout ); 158 159 /* */ 160 161 #endif /* _ANDROID_UTILS_SYSTEM_H */ 162