libsyscall/wrappers/_libc_funcptr.c

   1 /*
   2  * Copyright (c) 2010-2014 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include "_libkernel_init.h"
  30 #include "strings.h"
  31
  32 extern _libkernel_functions_t _libkernel_functions;
  33 extern void mig_os_release(void* ptr);
  34
  35 __attribute__((visibility("hidden")))
  36 void *
  37 malloc(size_t size)
  38 {
  39         return _libkernel_functions->malloc(size);
  40 }
  41
  42 __attribute__((visibility("hidden")))
  43 void
  44 free(void *ptr)
  45 {
  46         return _libkernel_functions->free(ptr);
  47 }
  48
  49 __attribute__((visibility("hidden")))
  50 void *
  51 realloc(void *ptr, size_t size)
  52 {
  53         return _libkernel_functions->realloc(ptr, size);
  54 }
  55
  56 __attribute__((visibility("hidden")))
  57 void *
  58 reallocf(void *ptr, size_t size)
  59 {
  60         void *nptr = realloc(ptr, size);
  61         if (!nptr && ptr)
  62                 free(ptr);
  63         return (nptr);
  64 }
  65
  66 __attribute__((visibility("hidden")))
  67 void
  68 _pthread_exit_if_canceled(int error)
  69 {
  70         return _libkernel_functions->_pthread_exit_if_canceled(error);
  71 }
  72
  73 __attribute__((visibility("hidden")))
  74 void
  75 _pthread_set_self(void *ptr __attribute__((__unused__))) {}
  76
  77 __attribute__((visibility("hidden")))
  78 void
  79 _pthread_clear_qos_tsd(mach_port_t thread_port)
  80 {
  81         if (_libkernel_functions->version >= 3 &&
  82                         _libkernel_functions->pthread_clear_qos_tsd) {
  83                 return _libkernel_functions->pthread_clear_qos_tsd(thread_port);
  84         }
  85 }
  86
  87 /*
  88  * Upcalls to optimized libplatform string functions
  89  */
  90
  91 static const struct _libkernel_string_functions
  92                 _libkernel_generic_string_functions = {
  93         .bzero = _libkernel_bzero,
  94         .memmove = _libkernel_memmove,
  95         .memset = _libkernel_memset,
  96         .strchr = _libkernel_strchr,
  97         .strcmp = _libkernel_strcmp,
  98         .strcpy = _libkernel_strcpy,
  99         .strlcpy = _libkernel_strlcpy,
 100         .strlen = _libkernel_strlen,
 101 };
 102 static _libkernel_string_functions_t _libkernel_string_functions =
 103                 &_libkernel_generic_string_functions;
 104
 105 kern_return_t
 106 __libkernel_platform_init(_libkernel_string_functions_t fns)
 107 {
 108         _libkernel_string_functions = fns;
 109         return KERN_SUCCESS;
 110 }
 111
 112 __attribute__((visibility("hidden")))
 113 void
 114 bzero(void *s, size_t n)
 115 {
 116         return _libkernel_string_functions->bzero(s, n);
 117 }
 118
 119 __attribute__((visibility("hidden")))
 120 void *
 121 memchr(const void *s, int c, size_t n)
 122 {
 123         return _libkernel_string_functions->memchr(s, c, n);
 124 }
 125
 126 __attribute__((visibility("hidden")))
 127 int
 128 memcmp(const void *s1, const void *s2, size_t n)
 129 {
 130         return _libkernel_string_functions->memcmp(s1, s2, n);
 131 }
 132
 133 __attribute__((visibility("hidden")))
 134 void *
 135 memmove(void *dst, const void *src, size_t n)
 136 {
 137         return _libkernel_string_functions->memmove(dst, src, n);
 138 }
 139
 140 __attribute__((visibility("hidden")))
 141 void *
 142 memcpy(void *dst, const void *src, size_t n)
 143 {
 144         return _libkernel_string_functions->memmove(dst, src, n);
 145 }
 146
 147 __attribute__((visibility("hidden")))
 148 void *
 149 memccpy(void *__restrict dst, const void *__restrict src, int c, size_t n)
 150 {
 151         return _libkernel_string_functions->memccpy(dst, src, c, n);
 152 }
 153
 154 __attribute__((visibility("hidden")))
 155 void *
 156 memset(void *b, int c, size_t len)
 157 {
 158         return _libkernel_string_functions->memset(b, c, len);
 159 }
 160
 161 __attribute__((visibility("hidden")))
 162 char *
 163 strchr(const char *s, int c)
 164 {
 165         return _libkernel_string_functions->strchr(s, c);
 166 }
 167
 168 __attribute__((visibility("hidden")))
 169 char *
 170 index(const char *s, int c)
 171 {
 172         return _libkernel_string_functions->strchr(s, c);
 173 }
 174
 175 __attribute__((visibility("hidden")))
 176 int
 177 strcmp(const char *s1, const char *s2)
 178 {
 179         return _libkernel_string_functions->strcmp(s1, s2);
 180 }
 181
 182 __attribute__((visibility("hidden")))
 183 char *
 184 strcpy(char * restrict dst, const char * restrict src)
 185 {
 186         return _libkernel_string_functions->strcpy(dst, src);
 187 }
 188
 189 __attribute__((visibility("hidden")))
 190 size_t
 191 strlcat(char * restrict dst, const char * restrict src, size_t maxlen)
 192 {
 193         return _libkernel_string_functions->strlcat(dst, src, maxlen);
 194 }
 195
 196 __attribute__((visibility("hidden")))
 197 size_t
 198 strlcpy(char * restrict dst, const char * restrict src, size_t maxlen)
 199 {
 200         return _libkernel_string_functions->strlcpy(dst, src, maxlen);
 201 }
 202
 203 __attribute__((visibility("hidden")))
 204 size_t
 205 strlen(const char *str)
 206 {
 207         return _libkernel_string_functions->strlen(str);
 208 }
 209
 210 __attribute__((visibility("hidden")))
 211 int
 212 strncmp(const char *s1, const char *s2, size_t n)
 213 {
 214         return _libkernel_string_functions->strncmp(s1, s2, n);
 215 }
 216
 217 __attribute__((visibility("hidden")))
 218 char *
 219 strncpy(char * restrict dst, const char * restrict src, size_t maxlen)
 220 {
 221         return _libkernel_string_functions->strncpy(dst, src, maxlen);
 222 }
 223
 224 __attribute__((visibility("hidden")))
 225 size_t
 226 strnlen(const char *s, size_t maxlen)
 227 {
 228         return _libkernel_string_functions->strnlen(s, maxlen);
 229 }
 230
 231 __attribute__((visibility("hidden")))
 232 char *
 233 strstr(const char *s, const char *find)
 234 {
 235         return _libkernel_string_functions->strstr(s, find);
 236 }
 237
 238 /*
 239  * mach/mach.h voucher_mach_msg API
 240  */
 241
 242 static const struct _libkernel_voucher_functions
 243                 _libkernel_voucher_functions_empty;
 244 static _libkernel_voucher_functions_t _libkernel_voucher_functions =
 245                 &_libkernel_voucher_functions_empty;
 246
 247 kern_return_t
 248 __libkernel_voucher_init(_libkernel_voucher_functions_t fns)
 249 {
 250         _libkernel_voucher_functions = fns;
 251         return KERN_SUCCESS;
 252 }
 253
 254 boolean_t
 255 voucher_mach_msg_set(mach_msg_header_t *msg)
 256 {
 257         if (_libkernel_voucher_functions->voucher_mach_msg_set) {
 258                 return _libkernel_voucher_functions->voucher_mach_msg_set(msg);
 259         }
 260         return 0;
 261 }
 262
 263 void
 264 voucher_mach_msg_clear(mach_msg_header_t *msg)
 265 {
 266         if (_libkernel_voucher_functions->voucher_mach_msg_clear) {
 267                 return _libkernel_voucher_functions->voucher_mach_msg_clear(msg);
 268         }
 269 }
 270
 271 voucher_mach_msg_state_t
 272 voucher_mach_msg_adopt(mach_msg_header_t *msg)
 273 {
 274         if (_libkernel_voucher_functions->voucher_mach_msg_adopt) {
 275                 return _libkernel_voucher_functions->voucher_mach_msg_adopt(msg);
 276         }
 277         return VOUCHER_MACH_MSG_STATE_UNCHANGED;
 278 }
 279
 280 void
 281 voucher_mach_msg_revert(voucher_mach_msg_state_t state)
 282 {
 283         if (_libkernel_voucher_functions->voucher_mach_msg_revert) {
 284                 return _libkernel_voucher_functions->voucher_mach_msg_revert(state);
 285         }
 286 }
 287