Kev Mann / mbed-dev-OS5_10_4

RTC auf true

platform/mbed_retarget.cpp@0:38ceb79fef03, 2018-11-28 (annotated)

Committer:
kevman
Date:
Wed Nov 28 15:10:15 2018 +0000
Revision:
0:38ceb79fef03
RTC modified

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kevman 0:38ceb79fef03 1 /* mbed Microcontroller Library
kevman 0:38ceb79fef03 2 * Copyright (c) 2006-2015 ARM Limited
kevman 0:38ceb79fef03 3 *
kevman 0:38ceb79fef03 4 * Licensed under the Apache License, Version 2.0 (the "License");
kevman 0:38ceb79fef03 5 * you may not use this file except in compliance with the License.
kevman 0:38ceb79fef03 6 * You may obtain a copy of the License at
kevman 0:38ceb79fef03 7 *
kevman 0:38ceb79fef03 8 * http://www.apache.org/licenses/LICENSE-2.0
kevman 0:38ceb79fef03 9 *
kevman 0:38ceb79fef03 10 * Unless required by applicable law or agreed to in writing, software
kevman 0:38ceb79fef03 11 * distributed under the License is distributed on an "AS IS" BASIS,
kevman 0:38ceb79fef03 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
kevman 0:38ceb79fef03 13 * See the License for the specific language governing permissions and
kevman 0:38ceb79fef03 14 * limitations under the License.
kevman 0:38ceb79fef03 15 */
kevman 0:38ceb79fef03 16 #include <time.h>
kevman 0:38ceb79fef03 17 #include "platform/platform.h"
kevman 0:38ceb79fef03 18 #include "platform/FilePath.h"
kevman 0:38ceb79fef03 19 #include "hal/serial_api.h"
kevman 0:38ceb79fef03 20 #include "hal/us_ticker_api.h"
kevman 0:38ceb79fef03 21 #include "platform/mbed_toolchain.h"
kevman 0:38ceb79fef03 22 #include "platform/mbed_semihost_api.h"
kevman 0:38ceb79fef03 23 #include "platform/mbed_interface.h"
kevman 0:38ceb79fef03 24 #include "platform/SingletonPtr.h"
kevman 0:38ceb79fef03 25 #include "platform/PlatformMutex.h"
kevman 0:38ceb79fef03 26 #include "platform/mbed_error.h"
kevman 0:38ceb79fef03 27 #include "platform/mbed_stats.h"
kevman 0:38ceb79fef03 28 #include "platform/mbed_critical.h"
kevman 0:38ceb79fef03 29 #include "platform/mbed_poll.h"
kevman 0:38ceb79fef03 30 #include "platform/PlatformMutex.h"
kevman 0:38ceb79fef03 31 #include "drivers/UARTSerial.h"
kevman 0:38ceb79fef03 32 #include "us_ticker_api.h"
kevman 0:38ceb79fef03 33 #include "lp_ticker_api.h"
kevman 0:38ceb79fef03 34 #include <stdlib.h>
kevman 0:38ceb79fef03 35 #include <string.h>
kevman 0:38ceb79fef03 36 #include <limits.h>
kevman 0:38ceb79fef03 37 #ifndef SSIZE_MAX
kevman 0:38ceb79fef03 38 #define SSIZE_MAX INT_MAX
kevman 0:38ceb79fef03 39 #endif
kevman 0:38ceb79fef03 40 #include <stdio.h>
kevman 0:38ceb79fef03 41 #include <errno.h>
kevman 0:38ceb79fef03 42 #include "platform/mbed_retarget.h"
kevman 0:38ceb79fef03 43
kevman 0:38ceb79fef03 44 static SingletonPtr<PlatformMutex> _mutex;
kevman 0:38ceb79fef03 45
kevman 0:38ceb79fef03 46 #if defined(__ARMCC_VERSION)
kevman 0:38ceb79fef03 47 # if __ARMCC_VERSION >= 6010050
kevman 0:38ceb79fef03 48 # include <arm_compat.h>
kevman 0:38ceb79fef03 49 # endif
kevman 0:38ceb79fef03 50 # include <rt_sys.h>
kevman 0:38ceb79fef03 51 # include <rt_misc.h>
kevman 0:38ceb79fef03 52 # include <stdint.h>
kevman 0:38ceb79fef03 53 # define PREFIX(x) _sys##x
kevman 0:38ceb79fef03 54 # define OPEN_MAX _SYS_OPEN
kevman 0:38ceb79fef03 55 # ifdef __MICROLIB
kevman 0:38ceb79fef03 56 # pragma import(__use_full_stdio)
kevman 0:38ceb79fef03 57 # endif
kevman 0:38ceb79fef03 58
kevman 0:38ceb79fef03 59 #elif defined(__ICCARM__)
kevman 0:38ceb79fef03 60 # include <yfuns.h>
kevman 0:38ceb79fef03 61 # define PREFIX(x) _##x
kevman 0:38ceb79fef03 62 # define OPEN_MAX 16
kevman 0:38ceb79fef03 63
kevman 0:38ceb79fef03 64 # define STDIN_FILENO 0
kevman 0:38ceb79fef03 65 # define STDOUT_FILENO 1
kevman 0:38ceb79fef03 66 # define STDERR_FILENO 2
kevman 0:38ceb79fef03 67
kevman 0:38ceb79fef03 68 #else
kevman 0:38ceb79fef03 69 # include <sys/syslimits.h>
kevman 0:38ceb79fef03 70 # define PREFIX(x) x
kevman 0:38ceb79fef03 71 #endif
kevman 0:38ceb79fef03 72
kevman 0:38ceb79fef03 73 #define FILE_HANDLE_RESERVED ((FileHandle*)0xFFFFFFFF)
kevman 0:38ceb79fef03 74
kevman 0:38ceb79fef03 75 /**
kevman 0:38ceb79fef03 76 * Macros for setting console flow control.
kevman 0:38ceb79fef03 77 */
kevman 0:38ceb79fef03 78 #define CONSOLE_FLOWCONTROL_RTS 1
kevman 0:38ceb79fef03 79 #define CONSOLE_FLOWCONTROL_CTS 2
kevman 0:38ceb79fef03 80 #define CONSOLE_FLOWCONTROL_RTSCTS 3
kevman 0:38ceb79fef03 81 #define mbed_console_concat_(x) CONSOLE_FLOWCONTROL_##x
kevman 0:38ceb79fef03 82 #define mbed_console_concat(x) mbed_console_concat_(x)
kevman 0:38ceb79fef03 83 #define CONSOLE_FLOWCONTROL mbed_console_concat(MBED_CONF_TARGET_CONSOLE_UART_FLOW_CONTROL)
kevman 0:38ceb79fef03 84
kevman 0:38ceb79fef03 85 using namespace mbed;
kevman 0:38ceb79fef03 86
kevman 0:38ceb79fef03 87 #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000)
kevman 0:38ceb79fef03 88 // Before version 5.03, we were using a patched version of microlib with proper names
kevman 0:38ceb79fef03 89 extern const char __stdin_name[] = ":tt";
kevman 0:38ceb79fef03 90 extern const char __stdout_name[] = ":tt";
kevman 0:38ceb79fef03 91 extern const char __stderr_name[] = ":tt";
kevman 0:38ceb79fef03 92
kevman 0:38ceb79fef03 93 #else
kevman 0:38ceb79fef03 94 extern const char __stdin_name[] = "/stdin";
kevman 0:38ceb79fef03 95 extern const char __stdout_name[] = "/stdout";
kevman 0:38ceb79fef03 96 extern const char __stderr_name[] = "/stderr";
kevman 0:38ceb79fef03 97 #endif
kevman 0:38ceb79fef03 98
kevman 0:38ceb79fef03 99 unsigned char *mbed_heap_start = 0;
kevman 0:38ceb79fef03 100 uint32_t mbed_heap_size = 0;
kevman 0:38ceb79fef03 101
kevman 0:38ceb79fef03 102 /* newlib has the filehandle field in the FILE struct as a short, so
kevman 0:38ceb79fef03 103 * we can't just return a Filehandle* from _open and instead have to
kevman 0:38ceb79fef03 104 * put it in a filehandles array and return the index into that array
kevman 0:38ceb79fef03 105 */
kevman 0:38ceb79fef03 106 static FileHandle *filehandles[OPEN_MAX] = { FILE_HANDLE_RESERVED, FILE_HANDLE_RESERVED, FILE_HANDLE_RESERVED };
kevman 0:38ceb79fef03 107 static char stdio_in_prev[OPEN_MAX];
kevman 0:38ceb79fef03 108 static char stdio_out_prev[OPEN_MAX];
kevman 0:38ceb79fef03 109 static SingletonPtr<PlatformMutex> filehandle_mutex;
kevman 0:38ceb79fef03 110
kevman 0:38ceb79fef03 111 namespace mbed {
kevman 0:38ceb79fef03 112 void mbed_set_unbuffered_stream(std::FILE *_file);
kevman 0:38ceb79fef03 113
kevman 0:38ceb79fef03 114 void remove_filehandle(FileHandle *file)
kevman 0:38ceb79fef03 115 {
kevman 0:38ceb79fef03 116 filehandle_mutex->lock();
kevman 0:38ceb79fef03 117 /* Remove all open filehandles for this */
kevman 0:38ceb79fef03 118 for (unsigned int fh_i = 0; fh_i < sizeof(filehandles) / sizeof(*filehandles); fh_i++) {
kevman 0:38ceb79fef03 119 if (filehandles[fh_i] == file) {
kevman 0:38ceb79fef03 120 filehandles[fh_i] = NULL;
kevman 0:38ceb79fef03 121 }
kevman 0:38ceb79fef03 122 }
kevman 0:38ceb79fef03 123 filehandle_mutex->unlock();
kevman 0:38ceb79fef03 124 }
kevman 0:38ceb79fef03 125 }
kevman 0:38ceb79fef03 126
kevman 0:38ceb79fef03 127 #if DEVICE_SERIAL
kevman 0:38ceb79fef03 128 extern int stdio_uart_inited;
kevman 0:38ceb79fef03 129 extern serial_t stdio_uart;
kevman 0:38ceb79fef03 130
kevman 0:38ceb79fef03 131 /* Private FileHandle to implement backwards-compatible functionality of
kevman 0:38ceb79fef03 132 * direct HAL serial access for default stdin/stdout/stderr.
kevman 0:38ceb79fef03 133 * This is not a particularly well-behaved FileHandle for a stream, which
kevman 0:38ceb79fef03 134 * is why it's not public. People should be using UARTSerial.
kevman 0:38ceb79fef03 135 */
kevman 0:38ceb79fef03 136 class DirectSerial : public FileHandle {
kevman 0:38ceb79fef03 137 public:
kevman 0:38ceb79fef03 138 DirectSerial(PinName tx, PinName rx, int baud);
kevman 0:38ceb79fef03 139 virtual ssize_t write(const void *buffer, size_t size);
kevman 0:38ceb79fef03 140 virtual ssize_t read(void *buffer, size_t size);
kevman 0:38ceb79fef03 141 virtual off_t seek(off_t offset, int whence = SEEK_SET)
kevman 0:38ceb79fef03 142 {
kevman 0:38ceb79fef03 143 return -ESPIPE;
kevman 0:38ceb79fef03 144 }
kevman 0:38ceb79fef03 145 virtual off_t size()
kevman 0:38ceb79fef03 146 {
kevman 0:38ceb79fef03 147 return -EINVAL;
kevman 0:38ceb79fef03 148 }
kevman 0:38ceb79fef03 149 virtual int isatty()
kevman 0:38ceb79fef03 150 {
kevman 0:38ceb79fef03 151 return true;
kevman 0:38ceb79fef03 152 }
kevman 0:38ceb79fef03 153 virtual int close()
kevman 0:38ceb79fef03 154 {
kevman 0:38ceb79fef03 155 return 0;
kevman 0:38ceb79fef03 156 }
kevman 0:38ceb79fef03 157 virtual short poll(short events) const;
kevman 0:38ceb79fef03 158 };
kevman 0:38ceb79fef03 159
kevman 0:38ceb79fef03 160 DirectSerial::DirectSerial(PinName tx, PinName rx, int baud)
kevman 0:38ceb79fef03 161 {
kevman 0:38ceb79fef03 162 if (stdio_uart_inited) {
kevman 0:38ceb79fef03 163 return;
kevman 0:38ceb79fef03 164 }
kevman 0:38ceb79fef03 165 serial_init(&stdio_uart, tx, rx);
kevman 0:38ceb79fef03 166 serial_baud(&stdio_uart, baud);
kevman 0:38ceb79fef03 167 #if CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTS
kevman 0:38ceb79fef03 168 serial_set_flow_control(&stdio_uart, FlowControlRTS, STDIO_UART_RTS, NC);
kevman 0:38ceb79fef03 169 #elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_CTS
kevman 0:38ceb79fef03 170 serial_set_flow_control(&stdio_uart, FlowControlCTS, NC, STDIO_UART_CTS);
kevman 0:38ceb79fef03 171 #elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTSCTS
kevman 0:38ceb79fef03 172 serial_set_flow_control(&stdio_uart, FlowControlRTSCTS, STDIO_UART_RTS, STDIO_UART_CTS);
kevman 0:38ceb79fef03 173 #endif
kevman 0:38ceb79fef03 174 }
kevman 0:38ceb79fef03 175
kevman 0:38ceb79fef03 176 ssize_t DirectSerial::write(const void *buffer, size_t size)
kevman 0:38ceb79fef03 177 {
kevman 0:38ceb79fef03 178 const unsigned char *buf = static_cast<const unsigned char *>(buffer);
kevman 0:38ceb79fef03 179 for (size_t i = 0; i < size; i++) {
kevman 0:38ceb79fef03 180 serial_putc(&stdio_uart, buf[i]);
kevman 0:38ceb79fef03 181 }
kevman 0:38ceb79fef03 182 return size;
kevman 0:38ceb79fef03 183 }
kevman 0:38ceb79fef03 184
kevman 0:38ceb79fef03 185 ssize_t DirectSerial::read(void *buffer, size_t size)
kevman 0:38ceb79fef03 186 {
kevman 0:38ceb79fef03 187 unsigned char *buf = static_cast<unsigned char *>(buffer);
kevman 0:38ceb79fef03 188 if (size == 0) {
kevman 0:38ceb79fef03 189 return 0;
kevman 0:38ceb79fef03 190 }
kevman 0:38ceb79fef03 191 buf[0] = serial_getc(&stdio_uart);
kevman 0:38ceb79fef03 192 return 1;
kevman 0:38ceb79fef03 193 }
kevman 0:38ceb79fef03 194
kevman 0:38ceb79fef03 195 short DirectSerial::poll(short events) const
kevman 0:38ceb79fef03 196 {
kevman 0:38ceb79fef03 197 short revents = 0;
kevman 0:38ceb79fef03 198 if ((events & POLLIN) && serial_readable(&stdio_uart)) {
kevman 0:38ceb79fef03 199 revents |= POLLIN;
kevman 0:38ceb79fef03 200 }
kevman 0:38ceb79fef03 201 if ((events & POLLOUT) && serial_writable(&stdio_uart)) {
kevman 0:38ceb79fef03 202 revents |= POLLOUT;
kevman 0:38ceb79fef03 203 }
kevman 0:38ceb79fef03 204 return revents;
kevman 0:38ceb79fef03 205 }
kevman 0:38ceb79fef03 206 #endif
kevman 0:38ceb79fef03 207
kevman 0:38ceb79fef03 208 class Sink : public FileHandle {
kevman 0:38ceb79fef03 209 public:
kevman 0:38ceb79fef03 210 virtual ssize_t write(const void *buffer, size_t size);
kevman 0:38ceb79fef03 211 virtual ssize_t read(void *buffer, size_t size);
kevman 0:38ceb79fef03 212 virtual off_t seek(off_t offset, int whence = SEEK_SET)
kevman 0:38ceb79fef03 213 {
kevman 0:38ceb79fef03 214 return ESPIPE;
kevman 0:38ceb79fef03 215 }
kevman 0:38ceb79fef03 216 virtual off_t size()
kevman 0:38ceb79fef03 217 {
kevman 0:38ceb79fef03 218 return -EINVAL;
kevman 0:38ceb79fef03 219 }
kevman 0:38ceb79fef03 220 virtual int isatty()
kevman 0:38ceb79fef03 221 {
kevman 0:38ceb79fef03 222 return true;
kevman 0:38ceb79fef03 223 }
kevman 0:38ceb79fef03 224 virtual int close()
kevman 0:38ceb79fef03 225 {
kevman 0:38ceb79fef03 226 return 0;
kevman 0:38ceb79fef03 227 }
kevman 0:38ceb79fef03 228 };
kevman 0:38ceb79fef03 229
kevman 0:38ceb79fef03 230 ssize_t Sink::write(const void *buffer, size_t size)
kevman 0:38ceb79fef03 231 {
kevman 0:38ceb79fef03 232 // Just swallow the data - this is historical non-DEVICE_SERIAL behaviour
kevman 0:38ceb79fef03 233 return size;
kevman 0:38ceb79fef03 234 }
kevman 0:38ceb79fef03 235
kevman 0:38ceb79fef03 236 ssize_t Sink::read(void *buffer, size_t size)
kevman 0:38ceb79fef03 237 {
kevman 0:38ceb79fef03 238 // Produce 1 zero byte - historical behaviour returned 1 without touching
kevman 0:38ceb79fef03 239 // the buffer
kevman 0:38ceb79fef03 240 unsigned char *buf = static_cast<unsigned char *>(buffer);
kevman 0:38ceb79fef03 241 buf[0] = 0;
kevman 0:38ceb79fef03 242 return 1;
kevman 0:38ceb79fef03 243 }
kevman 0:38ceb79fef03 244
kevman 0:38ceb79fef03 245
kevman 0:38ceb79fef03 246 MBED_WEAK FileHandle *mbed::mbed_target_override_console(int fd)
kevman 0:38ceb79fef03 247 {
kevman 0:38ceb79fef03 248 return NULL;
kevman 0:38ceb79fef03 249 }
kevman 0:38ceb79fef03 250
kevman 0:38ceb79fef03 251 MBED_WEAK FileHandle *mbed::mbed_override_console(int fd)
kevman 0:38ceb79fef03 252 {
kevman 0:38ceb79fef03 253 return NULL;
kevman 0:38ceb79fef03 254 }
kevman 0:38ceb79fef03 255
kevman 0:38ceb79fef03 256 static FileHandle *default_console()
kevman 0:38ceb79fef03 257 {
kevman 0:38ceb79fef03 258 #if DEVICE_SERIAL
kevman 0:38ceb79fef03 259 # if MBED_CONF_PLATFORM_STDIO_BUFFERED_SERIAL
kevman 0:38ceb79fef03 260 static UARTSerial console(STDIO_UART_TX, STDIO_UART_RX, MBED_CONF_PLATFORM_STDIO_BAUD_RATE);
kevman 0:38ceb79fef03 261 # if CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTS
kevman 0:38ceb79fef03 262 console.set_flow_control(SerialBase::RTS, STDIO_UART_RTS, NC);
kevman 0:38ceb79fef03 263 # elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_CTS
kevman 0:38ceb79fef03 264 console.set_flow_control(SerialBase::CTS, NC, STDIO_UART_CTS);
kevman 0:38ceb79fef03 265 # elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTSCTS
kevman 0:38ceb79fef03 266 console.set_flow_control(SerialBase::RTSCTS, STDIO_UART_RTS, STDIO_UART_CTS);
kevman 0:38ceb79fef03 267 # endif
kevman 0:38ceb79fef03 268 # else
kevman 0:38ceb79fef03 269 static DirectSerial console(STDIO_UART_TX, STDIO_UART_RX, MBED_CONF_PLATFORM_STDIO_BAUD_RATE);
kevman 0:38ceb79fef03 270 # endif
kevman 0:38ceb79fef03 271 #else // DEVICE_SERIAL
kevman 0:38ceb79fef03 272 static Sink console;
kevman 0:38ceb79fef03 273 #endif
kevman 0:38ceb79fef03 274 return &console;
kevman 0:38ceb79fef03 275 }
kevman 0:38ceb79fef03 276
kevman 0:38ceb79fef03 277 /* Locate the default console for stdout, stdin, stderr */
kevman 0:38ceb79fef03 278 static FileHandle *get_console(int fd)
kevman 0:38ceb79fef03 279 {
kevman 0:38ceb79fef03 280 FileHandle *fh = mbed_override_console(fd);
kevman 0:38ceb79fef03 281 if (fh) {
kevman 0:38ceb79fef03 282 return fh;
kevman 0:38ceb79fef03 283 }
kevman 0:38ceb79fef03 284 fh = mbed_target_override_console(fd);
kevman 0:38ceb79fef03 285 if (fh) {
kevman 0:38ceb79fef03 286 return fh;
kevman 0:38ceb79fef03 287 }
kevman 0:38ceb79fef03 288 return default_console();
kevman 0:38ceb79fef03 289 }
kevman 0:38ceb79fef03 290
kevman 0:38ceb79fef03 291 /* Deal with the fact C library may not _open descriptors 0, 1, 2 - auto bind */
kevman 0:38ceb79fef03 292 static FileHandle *get_fhc(int fd)
kevman 0:38ceb79fef03 293 {
kevman 0:38ceb79fef03 294 if (fd >= OPEN_MAX) {
kevman 0:38ceb79fef03 295 return NULL;
kevman 0:38ceb79fef03 296 }
kevman 0:38ceb79fef03 297 FileHandle *fh = filehandles[fd];
kevman 0:38ceb79fef03 298 if (fh == FILE_HANDLE_RESERVED && fd < 3) {
kevman 0:38ceb79fef03 299 filehandles[fd] = fh = get_console(fd);
kevman 0:38ceb79fef03 300 }
kevman 0:38ceb79fef03 301 return fh;
kevman 0:38ceb79fef03 302 }
kevman 0:38ceb79fef03 303
kevman 0:38ceb79fef03 304 /**
kevman 0:38ceb79fef03 305 * Sets errno when file opening fails.
kevman 0:38ceb79fef03 306 * Wipes out the filehandle too.
kevman 0:38ceb79fef03 307 *
kevman 0:38ceb79fef03 308 * @param error is a negative error code returned from an mbed function and
kevman 0:38ceb79fef03 309 * will be negated to store a positive error code in errno
kevman 0:38ceb79fef03 310 */
kevman 0:38ceb79fef03 311 static int handle_open_errors(int error, unsigned filehandle_idx)
kevman 0:38ceb79fef03 312 {
kevman 0:38ceb79fef03 313 errno = -error;
kevman 0:38ceb79fef03 314 // Free file handle
kevman 0:38ceb79fef03 315 filehandles[filehandle_idx] = NULL;
kevman 0:38ceb79fef03 316 return -1;
kevman 0:38ceb79fef03 317 }
kevman 0:38ceb79fef03 318
kevman 0:38ceb79fef03 319 static inline int openflags_to_posix(int openflags)
kevman 0:38ceb79fef03 320 {
kevman 0:38ceb79fef03 321 int posix = openflags;
kevman 0:38ceb79fef03 322 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 323 if (openflags & OPEN_PLUS) {
kevman 0:38ceb79fef03 324 posix = O_RDWR;
kevman 0:38ceb79fef03 325 } else if (openflags & OPEN_W) {
kevman 0:38ceb79fef03 326 posix = O_WRONLY;
kevman 0:38ceb79fef03 327 } else if (openflags & OPEN_A) {
kevman 0:38ceb79fef03 328 posix = O_WRONLY | O_APPEND;
kevman 0:38ceb79fef03 329 } else {
kevman 0:38ceb79fef03 330 posix = O_RDONLY;
kevman 0:38ceb79fef03 331 }
kevman 0:38ceb79fef03 332 /* a, w, a+, w+ all create if file does not already exist */
kevman 0:38ceb79fef03 333 if (openflags & (OPEN_A | OPEN_W)) {
kevman 0:38ceb79fef03 334 posix |= O_CREAT;
kevman 0:38ceb79fef03 335 }
kevman 0:38ceb79fef03 336 /* w and w+ truncate */
kevman 0:38ceb79fef03 337 if (openflags & OPEN_W) {
kevman 0:38ceb79fef03 338 posix |= O_TRUNC;
kevman 0:38ceb79fef03 339 }
kevman 0:38ceb79fef03 340 #elif defined(__ICCARM__)
kevman 0:38ceb79fef03 341 switch (openflags & _LLIO_RDWRMASK) {
kevman 0:38ceb79fef03 342 case _LLIO_RDONLY:
kevman 0:38ceb79fef03 343 posix = O_RDONLY;
kevman 0:38ceb79fef03 344 break;
kevman 0:38ceb79fef03 345 case _LLIO_WRONLY:
kevman 0:38ceb79fef03 346 posix = O_WRONLY;
kevman 0:38ceb79fef03 347 break;
kevman 0:38ceb79fef03 348 case _LLIO_RDWR :
kevman 0:38ceb79fef03 349 posix = O_RDWR ;
kevman 0:38ceb79fef03 350 break;
kevman 0:38ceb79fef03 351 }
kevman 0:38ceb79fef03 352 if (openflags & _LLIO_CREAT) {
kevman 0:38ceb79fef03 353 posix |= O_CREAT;
kevman 0:38ceb79fef03 354 }
kevman 0:38ceb79fef03 355 if (openflags & _LLIO_APPEND) {
kevman 0:38ceb79fef03 356 posix |= O_APPEND;
kevman 0:38ceb79fef03 357 }
kevman 0:38ceb79fef03 358 if (openflags & _LLIO_TRUNC) {
kevman 0:38ceb79fef03 359 posix |= O_TRUNC;
kevman 0:38ceb79fef03 360 }
kevman 0:38ceb79fef03 361 #elif defined(TOOLCHAIN_GCC)
kevman 0:38ceb79fef03 362 posix &= ~O_BINARY;
kevman 0:38ceb79fef03 363 #endif
kevman 0:38ceb79fef03 364 return posix;
kevman 0:38ceb79fef03 365 }
kevman 0:38ceb79fef03 366
kevman 0:38ceb79fef03 367 static int reserve_filehandle()
kevman 0:38ceb79fef03 368 {
kevman 0:38ceb79fef03 369 // find the first empty slot in filehandles, after the slots reserved for stdin/stdout/stderr
kevman 0:38ceb79fef03 370 filehandle_mutex->lock();
kevman 0:38ceb79fef03 371 int fh_i;
kevman 0:38ceb79fef03 372 for (fh_i = 3; fh_i < OPEN_MAX; fh_i++) {
kevman 0:38ceb79fef03 373 /* Take a next free filehandle slot available. */
kevman 0:38ceb79fef03 374 if (filehandles[fh_i] == NULL) {
kevman 0:38ceb79fef03 375 break;
kevman 0:38ceb79fef03 376 }
kevman 0:38ceb79fef03 377 }
kevman 0:38ceb79fef03 378 if (fh_i >= OPEN_MAX) {
kevman 0:38ceb79fef03 379 /* Too many file handles have been opened */
kevman 0:38ceb79fef03 380 errno = EMFILE;
kevman 0:38ceb79fef03 381 filehandle_mutex->unlock();
kevman 0:38ceb79fef03 382 return -1;
kevman 0:38ceb79fef03 383 }
kevman 0:38ceb79fef03 384 filehandles[fh_i] = FILE_HANDLE_RESERVED;
kevman 0:38ceb79fef03 385 filehandle_mutex->unlock();
kevman 0:38ceb79fef03 386
kevman 0:38ceb79fef03 387 return fh_i;
kevman 0:38ceb79fef03 388 }
kevman 0:38ceb79fef03 389
kevman 0:38ceb79fef03 390 int mbed::bind_to_fd(FileHandle *fh)
kevman 0:38ceb79fef03 391 {
kevman 0:38ceb79fef03 392 int fildes = reserve_filehandle();
kevman 0:38ceb79fef03 393 if (fildes < 0) {
kevman 0:38ceb79fef03 394 return fildes;
kevman 0:38ceb79fef03 395 }
kevman 0:38ceb79fef03 396
kevman 0:38ceb79fef03 397 filehandles[fildes] = fh;
kevman 0:38ceb79fef03 398 stdio_in_prev[fildes] = 0;
kevman 0:38ceb79fef03 399 stdio_out_prev[fildes] = 0;
kevman 0:38ceb79fef03 400
kevman 0:38ceb79fef03 401 return fildes;
kevman 0:38ceb79fef03 402 }
kevman 0:38ceb79fef03 403
kevman 0:38ceb79fef03 404 static int unbind_from_fd(int fd, FileHandle *fh)
kevman 0:38ceb79fef03 405 {
kevman 0:38ceb79fef03 406 if (filehandles[fd] == fh) {
kevman 0:38ceb79fef03 407 filehandles[fd] = NULL;
kevman 0:38ceb79fef03 408 return 0;
kevman 0:38ceb79fef03 409 } else {
kevman 0:38ceb79fef03 410 errno = EBADF;
kevman 0:38ceb79fef03 411 return -1;
kevman 0:38ceb79fef03 412 }
kevman 0:38ceb79fef03 413 }
kevman 0:38ceb79fef03 414
kevman 0:38ceb79fef03 415 #ifndef __IAR_SYSTEMS_ICC__
kevman 0:38ceb79fef03 416 /* IAR provides fdopen itself */
kevman 0:38ceb79fef03 417 extern "C" std::FILE *fdopen(int fildes, const char *mode)
kevman 0:38ceb79fef03 418 {
kevman 0:38ceb79fef03 419 // This is to avoid scanf and the bloat it brings.
kevman 0:38ceb79fef03 420 char buf[1 + sizeof fildes]; /* @(integer) */
kevman 0:38ceb79fef03 421 MBED_STATIC_ASSERT(sizeof buf == 5, "Integers should be 4 bytes.");
kevman 0:38ceb79fef03 422 buf[0] = '@';
kevman 0:38ceb79fef03 423 memcpy(buf + 1, &fildes, sizeof fildes);
kevman 0:38ceb79fef03 424
kevman 0:38ceb79fef03 425 std::FILE *stream = std::fopen(buf, mode);
kevman 0:38ceb79fef03 426 /* newlib-nano doesn't appear to ever call _isatty itself, so
kevman 0:38ceb79fef03 427 * happily fully buffers an interactive stream. Deal with that here.
kevman 0:38ceb79fef03 428 */
kevman 0:38ceb79fef03 429 if (stream && isatty(fildes)) {
kevman 0:38ceb79fef03 430 mbed_set_unbuffered_stream(stream);
kevman 0:38ceb79fef03 431 }
kevman 0:38ceb79fef03 432 return stream;
kevman 0:38ceb79fef03 433 }
kevman 0:38ceb79fef03 434 #endif
kevman 0:38ceb79fef03 435
kevman 0:38ceb79fef03 436 namespace mbed {
kevman 0:38ceb79fef03 437 std::FILE *fdopen(FileHandle *fh, const char *mode)
kevman 0:38ceb79fef03 438 {
kevman 0:38ceb79fef03 439 // First reserve the integer file descriptor
kevman 0:38ceb79fef03 440 int fd = bind_to_fd(fh);
kevman 0:38ceb79fef03 441 if (!fd) {
kevman 0:38ceb79fef03 442 return NULL;
kevman 0:38ceb79fef03 443 }
kevman 0:38ceb79fef03 444 // Then bind that to the C stream. If successful, C library
kevman 0:38ceb79fef03 445 // takes ownership and responsibility to close.
kevman 0:38ceb79fef03 446 std::FILE *stream = ::fdopen(fd, mode);
kevman 0:38ceb79fef03 447 if (!stream) {
kevman 0:38ceb79fef03 448 unbind_from_fd(fd, fh);
kevman 0:38ceb79fef03 449 }
kevman 0:38ceb79fef03 450 return stream;
kevman 0:38ceb79fef03 451 }
kevman 0:38ceb79fef03 452 }
kevman 0:38ceb79fef03 453
kevman 0:38ceb79fef03 454 /* @brief standard c library fopen() retargeting function.
kevman 0:38ceb79fef03 455 *
kevman 0:38ceb79fef03 456 * This function is invoked by the standard c library retargeting to handle fopen()
kevman 0:38ceb79fef03 457 *
kevman 0:38ceb79fef03 458 * @return
kevman 0:38ceb79fef03 459 * On success, a valid FILEHANDLE is returned.
kevman 0:38ceb79fef03 460 * On failure, -1 is returned and errno is set to an appropriate value e.g.
kevman 0:38ceb79fef03 461 * ENOENT file not found (default errno setting)
kevman 0:38ceb79fef03 462 * EMFILE the maximum number of open files was exceeded.
kevman 0:38ceb79fef03 463 *
kevman 0:38ceb79fef03 464 * */
kevman 0:38ceb79fef03 465 extern "C" FILEHANDLE PREFIX(_open)(const char *name, int openflags)
kevman 0:38ceb79fef03 466 {
kevman 0:38ceb79fef03 467 #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000)
kevman 0:38ceb79fef03 468 #if !defined(MBED_CONF_RTOS_PRESENT)
kevman 0:38ceb79fef03 469 // valid only for mbed 2
kevman 0:38ceb79fef03 470 // for ulib, this is invoked after RAM init, prior c++
kevman 0:38ceb79fef03 471 // used as hook, as post stack/heap is not active there
kevman 0:38ceb79fef03 472 extern void mbed_copy_nvic(void);
kevman 0:38ceb79fef03 473 extern void mbed_sdk_init(void);
kevman 0:38ceb79fef03 474
kevman 0:38ceb79fef03 475 static int mbed_sdk_inited = 0;
kevman 0:38ceb79fef03 476 if (!mbed_sdk_inited) {
kevman 0:38ceb79fef03 477 mbed_copy_nvic();
kevman 0:38ceb79fef03 478 mbed_sdk_init();
kevman 0:38ceb79fef03 479 mbed_sdk_inited = 1;
kevman 0:38ceb79fef03 480 }
kevman 0:38ceb79fef03 481 #endif
kevman 0:38ceb79fef03 482 // Before version 5.03, we were using a patched version of microlib with proper names
kevman 0:38ceb79fef03 483 // This is the workaround that the microlib author suggested us
kevman 0:38ceb79fef03 484 static int n = 0;
kevman 0:38ceb79fef03 485 if (std::strcmp(name, ":tt") == 0 && n < 3) {
kevman 0:38ceb79fef03 486 return n++;
kevman 0:38ceb79fef03 487 }
kevman 0:38ceb79fef03 488 #else
kevman 0:38ceb79fef03 489 /* Use the posix convention that stdin,out,err are filehandles 0,1,2.
kevman 0:38ceb79fef03 490 */
kevman 0:38ceb79fef03 491 if (std::strcmp(name, __stdin_name) == 0) {
kevman 0:38ceb79fef03 492 get_fhc(STDIN_FILENO);
kevman 0:38ceb79fef03 493 return STDIN_FILENO;
kevman 0:38ceb79fef03 494 } else if (std::strcmp(name, __stdout_name) == 0) {
kevman 0:38ceb79fef03 495 get_fhc(STDOUT_FILENO);
kevman 0:38ceb79fef03 496 return STDOUT_FILENO;
kevman 0:38ceb79fef03 497 } else if (std::strcmp(name, __stderr_name) == 0) {
kevman 0:38ceb79fef03 498 get_fhc(STDERR_FILENO);
kevman 0:38ceb79fef03 499 return STDERR_FILENO;
kevman 0:38ceb79fef03 500 }
kevman 0:38ceb79fef03 501 #endif
kevman 0:38ceb79fef03 502 #ifndef __IAR_SYSTEMS_ICC__
kevman 0:38ceb79fef03 503 /* FILENAME: "@(integer)" gives an already-allocated descriptor */
kevman 0:38ceb79fef03 504 if (name[0] == '@') {
kevman 0:38ceb79fef03 505 int fd;
kevman 0:38ceb79fef03 506 memcpy(&fd, name + 1, sizeof fd);
kevman 0:38ceb79fef03 507 return fd;
kevman 0:38ceb79fef03 508 }
kevman 0:38ceb79fef03 509 #endif
kevman 0:38ceb79fef03 510 return open(name, openflags_to_posix(openflags));
kevman 0:38ceb79fef03 511 }
kevman 0:38ceb79fef03 512
kevman 0:38ceb79fef03 513 extern "C" int open(const char *name, int oflag, ...)
kevman 0:38ceb79fef03 514 {
kevman 0:38ceb79fef03 515 int fildes = reserve_filehandle();
kevman 0:38ceb79fef03 516 if (fildes < 0) {
kevman 0:38ceb79fef03 517 return fildes;
kevman 0:38ceb79fef03 518 }
kevman 0:38ceb79fef03 519
kevman 0:38ceb79fef03 520 FileHandle *res = NULL;
kevman 0:38ceb79fef03 521 FilePath path(name);
kevman 0:38ceb79fef03 522
kevman 0:38ceb79fef03 523 if (!path.exists()) {
kevman 0:38ceb79fef03 524 /* The first part of the filename (between first 2 '/') is not a
kevman 0:38ceb79fef03 525 * registered mount point in the namespace.
kevman 0:38ceb79fef03 526 */
kevman 0:38ceb79fef03 527 return handle_open_errors(-ENODEV, fildes);
kevman 0:38ceb79fef03 528 }
kevman 0:38ceb79fef03 529
kevman 0:38ceb79fef03 530 if (path.isFile()) {
kevman 0:38ceb79fef03 531 res = path.file();
kevman 0:38ceb79fef03 532 } else {
kevman 0:38ceb79fef03 533 FileSystemHandle *fs = path.fileSystem();
kevman 0:38ceb79fef03 534 if (fs == NULL) {
kevman 0:38ceb79fef03 535 return handle_open_errors(-ENODEV, fildes);
kevman 0:38ceb79fef03 536 }
kevman 0:38ceb79fef03 537 int err = fs->open(&res, path.fileName(), oflag);
kevman 0:38ceb79fef03 538 if (err) {
kevman 0:38ceb79fef03 539 return handle_open_errors(err, fildes);
kevman 0:38ceb79fef03 540 }
kevman 0:38ceb79fef03 541 }
kevman 0:38ceb79fef03 542
kevman 0:38ceb79fef03 543 filehandles[fildes] = res;
kevman 0:38ceb79fef03 544 stdio_in_prev[fildes] = 0;
kevman 0:38ceb79fef03 545 stdio_out_prev[fildes] = 0;
kevman 0:38ceb79fef03 546
kevman 0:38ceb79fef03 547 return fildes;
kevman 0:38ceb79fef03 548 }
kevman 0:38ceb79fef03 549
kevman 0:38ceb79fef03 550 extern "C" int PREFIX(_close)(FILEHANDLE fh)
kevman 0:38ceb79fef03 551 {
kevman 0:38ceb79fef03 552 return close(fh);
kevman 0:38ceb79fef03 553 }
kevman 0:38ceb79fef03 554
kevman 0:38ceb79fef03 555 extern "C" int close(int fildes)
kevman 0:38ceb79fef03 556 {
kevman 0:38ceb79fef03 557 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 558 filehandles[fildes] = NULL;
kevman 0:38ceb79fef03 559 if (fhc == NULL) {
kevman 0:38ceb79fef03 560 errno = EBADF;
kevman 0:38ceb79fef03 561 return -1;
kevman 0:38ceb79fef03 562 }
kevman 0:38ceb79fef03 563
kevman 0:38ceb79fef03 564 int err = fhc->close();
kevman 0:38ceb79fef03 565 if (err < 0) {
kevman 0:38ceb79fef03 566 errno = -err;
kevman 0:38ceb79fef03 567 return -1;
kevman 0:38ceb79fef03 568 } else {
kevman 0:38ceb79fef03 569 return 0;
kevman 0:38ceb79fef03 570 }
kevman 0:38ceb79fef03 571 }
kevman 0:38ceb79fef03 572
kevman 0:38ceb79fef03 573 static bool convert_crlf(int fd)
kevman 0:38ceb79fef03 574 {
kevman 0:38ceb79fef03 575 #if MBED_CONF_PLATFORM_STDIO_CONVERT_TTY_NEWLINES
kevman 0:38ceb79fef03 576 return isatty(fd);
kevman 0:38ceb79fef03 577 #elif MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
kevman 0:38ceb79fef03 578 return fd < 3 && isatty(fd);
kevman 0:38ceb79fef03 579 #else
kevman 0:38ceb79fef03 580 return false;
kevman 0:38ceb79fef03 581 #endif
kevman 0:38ceb79fef03 582 }
kevman 0:38ceb79fef03 583
kevman 0:38ceb79fef03 584 #if defined(__ICCARM__)
kevman 0:38ceb79fef03 585 extern "C" size_t __write(int fh, const unsigned char *buffer, size_t length)
kevman 0:38ceb79fef03 586 {
kevman 0:38ceb79fef03 587 #else
kevman 0:38ceb79fef03 588 extern "C" int PREFIX(_write)(FILEHANDLE fh, const unsigned char *buffer, unsigned int length, int mode)
kevman 0:38ceb79fef03 589 {
kevman 0:38ceb79fef03 590 #endif
kevman 0:38ceb79fef03 591
kevman 0:38ceb79fef03 592 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
kevman 0:38ceb79fef03 593 if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
kevman 0:38ceb79fef03 594 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - writing to a file in an ISR or critical section\r\n", fh);
kevman 0:38ceb79fef03 595 }
kevman 0:38ceb79fef03 596 #endif
kevman 0:38ceb79fef03 597
kevman 0:38ceb79fef03 598 if (length > SSIZE_MAX) {
kevman 0:38ceb79fef03 599 errno = EINVAL;
kevman 0:38ceb79fef03 600 return -1;
kevman 0:38ceb79fef03 601 }
kevman 0:38ceb79fef03 602
kevman 0:38ceb79fef03 603 ssize_t slength = length;
kevman 0:38ceb79fef03 604 ssize_t written = 0;
kevman 0:38ceb79fef03 605
kevman 0:38ceb79fef03 606 if (convert_crlf(fh)) {
kevman 0:38ceb79fef03 607 // local prev is previous in buffer during seek
kevman 0:38ceb79fef03 608 // stdio_out_prev[fh] is last thing actually written
kevman 0:38ceb79fef03 609 char prev = stdio_out_prev[fh];
kevman 0:38ceb79fef03 610 // Seek for '\n' without preceding '\r'; if found flush
kevman 0:38ceb79fef03 611 // preceding and insert '\r'. Continue until end of input.
kevman 0:38ceb79fef03 612 for (ssize_t cur = 0; cur < slength; cur++) {
kevman 0:38ceb79fef03 613 if (buffer[cur] == '\n' && prev != '\r') {
kevman 0:38ceb79fef03 614 ssize_t r;
kevman 0:38ceb79fef03 615 // flush stuff preceding the \n
kevman 0:38ceb79fef03 616 if (cur > written) {
kevman 0:38ceb79fef03 617 r = write(fh, buffer + written, cur - written);
kevman 0:38ceb79fef03 618 if (r < 0) {
kevman 0:38ceb79fef03 619 return -1;
kevman 0:38ceb79fef03 620 }
kevman 0:38ceb79fef03 621 written += r;
kevman 0:38ceb79fef03 622 if (written < cur) {
kevman 0:38ceb79fef03 623 // For some reason, didn't write all - give up now
kevman 0:38ceb79fef03 624 goto finish;
kevman 0:38ceb79fef03 625 }
kevman 0:38ceb79fef03 626 stdio_out_prev[fh] = prev;
kevman 0:38ceb79fef03 627 }
kevman 0:38ceb79fef03 628 // insert a \r now, leaving the \n still to be written
kevman 0:38ceb79fef03 629 r = write(fh, "\r", 1);
kevman 0:38ceb79fef03 630 if (r < 0) {
kevman 0:38ceb79fef03 631 return -1;
kevman 0:38ceb79fef03 632 }
kevman 0:38ceb79fef03 633 if (r < 1) {
kevman 0:38ceb79fef03 634 goto finish;
kevman 0:38ceb79fef03 635 }
kevman 0:38ceb79fef03 636 stdio_out_prev[fh] = '\r';
kevman 0:38ceb79fef03 637 }
kevman 0:38ceb79fef03 638 prev = buffer[cur];
kevman 0:38ceb79fef03 639 }
kevman 0:38ceb79fef03 640 }
kevman 0:38ceb79fef03 641
kevman 0:38ceb79fef03 642 // Flush remaining from conversion, or the whole thing if no conversion
kevman 0:38ceb79fef03 643 if (written < slength) {
kevman 0:38ceb79fef03 644 ssize_t r = write(fh, buffer + written, slength - written);
kevman 0:38ceb79fef03 645 if (r < 0) {
kevman 0:38ceb79fef03 646 return -1;
kevman 0:38ceb79fef03 647 }
kevman 0:38ceb79fef03 648 written += r;
kevman 0:38ceb79fef03 649 if (written > 0) {
kevman 0:38ceb79fef03 650 stdio_out_prev[fh] = buffer[written - 1];
kevman 0:38ceb79fef03 651 }
kevman 0:38ceb79fef03 652 }
kevman 0:38ceb79fef03 653
kevman 0:38ceb79fef03 654 finish:
kevman 0:38ceb79fef03 655 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 656 if (written >= 0) {
kevman 0:38ceb79fef03 657 return slength - written;
kevman 0:38ceb79fef03 658 } else {
kevman 0:38ceb79fef03 659 return written;
kevman 0:38ceb79fef03 660 }
kevman 0:38ceb79fef03 661 #else
kevman 0:38ceb79fef03 662 return written;
kevman 0:38ceb79fef03 663 #endif
kevman 0:38ceb79fef03 664 }
kevman 0:38ceb79fef03 665
kevman 0:38ceb79fef03 666 extern "C" ssize_t write(int fildes, const void *buf, size_t length)
kevman 0:38ceb79fef03 667 {
kevman 0:38ceb79fef03 668
kevman 0:38ceb79fef03 669 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 670 if (fhc == NULL) {
kevman 0:38ceb79fef03 671 errno = EBADF;
kevman 0:38ceb79fef03 672 return -1;
kevman 0:38ceb79fef03 673 }
kevman 0:38ceb79fef03 674
kevman 0:38ceb79fef03 675 ssize_t ret = fhc->write(buf, length);
kevman 0:38ceb79fef03 676 if (ret < 0) {
kevman 0:38ceb79fef03 677 errno = -ret;
kevman 0:38ceb79fef03 678 return -1;
kevman 0:38ceb79fef03 679 } else {
kevman 0:38ceb79fef03 680 return ret;
kevman 0:38ceb79fef03 681 }
kevman 0:38ceb79fef03 682 }
kevman 0:38ceb79fef03 683
kevman 0:38ceb79fef03 684 #if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
kevman 0:38ceb79fef03 685 extern "C" void PREFIX(_exit)(int return_code)
kevman 0:38ceb79fef03 686 {
kevman 0:38ceb79fef03 687 while (1) {}
kevman 0:38ceb79fef03 688 }
kevman 0:38ceb79fef03 689
kevman 0:38ceb79fef03 690 extern "C" void _ttywrch(int ch)
kevman 0:38ceb79fef03 691 {
kevman 0:38ceb79fef03 692 char c = ch;
kevman 0:38ceb79fef03 693 write(STDOUT_FILENO, &c, 1);
kevman 0:38ceb79fef03 694 }
kevman 0:38ceb79fef03 695 #endif
kevman 0:38ceb79fef03 696
kevman 0:38ceb79fef03 697 #if defined(__ICCARM__)
kevman 0:38ceb79fef03 698 extern "C" size_t __read(int fh, unsigned char *buffer, size_t length)
kevman 0:38ceb79fef03 699 {
kevman 0:38ceb79fef03 700 #else
kevman 0:38ceb79fef03 701 extern "C" int PREFIX(_read)(FILEHANDLE fh, unsigned char *buffer, unsigned int length, int mode)
kevman 0:38ceb79fef03 702 {
kevman 0:38ceb79fef03 703 #endif
kevman 0:38ceb79fef03 704
kevman 0:38ceb79fef03 705 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
kevman 0:38ceb79fef03 706 if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
kevman 0:38ceb79fef03 707 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - reading from a file in an ISR or critical section\r\n", fh);
kevman 0:38ceb79fef03 708 }
kevman 0:38ceb79fef03 709 #endif
kevman 0:38ceb79fef03 710
kevman 0:38ceb79fef03 711 if (length > SSIZE_MAX) {
kevman 0:38ceb79fef03 712 errno = EINVAL;
kevman 0:38ceb79fef03 713 return -1;
kevman 0:38ceb79fef03 714 }
kevman 0:38ceb79fef03 715
kevman 0:38ceb79fef03 716 ssize_t bytes_read = 0;
kevman 0:38ceb79fef03 717
kevman 0:38ceb79fef03 718 if (convert_crlf(fh)) {
kevman 0:38ceb79fef03 719 while (true) {
kevman 0:38ceb79fef03 720 char c;
kevman 0:38ceb79fef03 721 ssize_t r = read(fh, &c, 1);
kevman 0:38ceb79fef03 722 if (r < 0) {
kevman 0:38ceb79fef03 723 return -1;
kevman 0:38ceb79fef03 724 }
kevman 0:38ceb79fef03 725 if (r == 0) {
kevman 0:38ceb79fef03 726 return bytes_read;
kevman 0:38ceb79fef03 727 }
kevman 0:38ceb79fef03 728 if ((c == '\r' && stdio_in_prev[fh] != '\n') ||
kevman 0:38ceb79fef03 729 (c == '\n' && stdio_in_prev[fh] != '\r')) {
kevman 0:38ceb79fef03 730 stdio_in_prev[fh] = c;
kevman 0:38ceb79fef03 731 *buffer = '\n';
kevman 0:38ceb79fef03 732 break;
kevman 0:38ceb79fef03 733 } else if ((c == '\r' && stdio_in_prev[fh] == '\n') ||
kevman 0:38ceb79fef03 734 (c == '\n' && stdio_in_prev[fh] == '\r')) {
kevman 0:38ceb79fef03 735 stdio_in_prev[fh] = c;
kevman 0:38ceb79fef03 736 continue;
kevman 0:38ceb79fef03 737 } else {
kevman 0:38ceb79fef03 738 stdio_in_prev[fh] = c;
kevman 0:38ceb79fef03 739 *buffer = c;
kevman 0:38ceb79fef03 740 break;
kevman 0:38ceb79fef03 741 }
kevman 0:38ceb79fef03 742 }
kevman 0:38ceb79fef03 743 bytes_read = 1;
kevman 0:38ceb79fef03 744 } else {
kevman 0:38ceb79fef03 745 bytes_read = read(fh, buffer, length);
kevman 0:38ceb79fef03 746 }
kevman 0:38ceb79fef03 747
kevman 0:38ceb79fef03 748 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 749 if (bytes_read < 0) {
kevman 0:38ceb79fef03 750 return -1;
kevman 0:38ceb79fef03 751 } else if (bytes_read == 0) {
kevman 0:38ceb79fef03 752 return 0x80000000 | length; // weird EOF indication
kevman 0:38ceb79fef03 753 } else {
kevman 0:38ceb79fef03 754 return (ssize_t)length - bytes_read;
kevman 0:38ceb79fef03 755 }
kevman 0:38ceb79fef03 756 #else
kevman 0:38ceb79fef03 757 return bytes_read;
kevman 0:38ceb79fef03 758 #endif
kevman 0:38ceb79fef03 759 }
kevman 0:38ceb79fef03 760
kevman 0:38ceb79fef03 761 extern "C" ssize_t read(int fildes, void *buf, size_t length)
kevman 0:38ceb79fef03 762 {
kevman 0:38ceb79fef03 763
kevman 0:38ceb79fef03 764 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 765 if (fhc == NULL) {
kevman 0:38ceb79fef03 766 errno = EBADF;
kevman 0:38ceb79fef03 767 return -1;
kevman 0:38ceb79fef03 768 }
kevman 0:38ceb79fef03 769
kevman 0:38ceb79fef03 770 ssize_t ret = fhc->read(buf, length);
kevman 0:38ceb79fef03 771 if (ret < 0) {
kevman 0:38ceb79fef03 772 errno = -ret;
kevman 0:38ceb79fef03 773 return -1;
kevman 0:38ceb79fef03 774 } else {
kevman 0:38ceb79fef03 775 return ret;
kevman 0:38ceb79fef03 776 }
kevman 0:38ceb79fef03 777 }
kevman 0:38ceb79fef03 778
kevman 0:38ceb79fef03 779
kevman 0:38ceb79fef03 780 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 781 extern "C" int PREFIX(_istty)(FILEHANDLE fh)
kevman 0:38ceb79fef03 782 #else
kevman 0:38ceb79fef03 783 extern "C" int _isatty(FILEHANDLE fh)
kevman 0:38ceb79fef03 784 #endif
kevman 0:38ceb79fef03 785 {
kevman 0:38ceb79fef03 786 return isatty(fh);
kevman 0:38ceb79fef03 787 }
kevman 0:38ceb79fef03 788
kevman 0:38ceb79fef03 789 extern "C" int isatty(int fildes)
kevman 0:38ceb79fef03 790 {
kevman 0:38ceb79fef03 791 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 792 if (fhc == NULL) {
kevman 0:38ceb79fef03 793 errno = EBADF;
kevman 0:38ceb79fef03 794 return 0;
kevman 0:38ceb79fef03 795 }
kevman 0:38ceb79fef03 796
kevman 0:38ceb79fef03 797 int tty = fhc->isatty();
kevman 0:38ceb79fef03 798 if (tty < 0) {
kevman 0:38ceb79fef03 799 errno = -tty;
kevman 0:38ceb79fef03 800 return 0;
kevman 0:38ceb79fef03 801 } else {
kevman 0:38ceb79fef03 802 return tty;
kevman 0:38ceb79fef03 803 }
kevman 0:38ceb79fef03 804 }
kevman 0:38ceb79fef03 805
kevman 0:38ceb79fef03 806 extern "C"
kevman 0:38ceb79fef03 807 #if defined(__ARMCC_VERSION)
kevman 0:38ceb79fef03 808 int _sys_seek(FILEHANDLE fh, long offset)
kevman 0:38ceb79fef03 809 #elif defined(__ICCARM__)
kevman 0:38ceb79fef03 810 long __lseek(int fh, long offset, int whence)
kevman 0:38ceb79fef03 811 #else
kevman 0:38ceb79fef03 812 int _lseek(FILEHANDLE fh, int offset, int whence)
kevman 0:38ceb79fef03 813 #endif
kevman 0:38ceb79fef03 814 {
kevman 0:38ceb79fef03 815 #if defined(__ARMCC_VERSION)
kevman 0:38ceb79fef03 816 int whence = SEEK_SET;
kevman 0:38ceb79fef03 817 #endif
kevman 0:38ceb79fef03 818
kevman 0:38ceb79fef03 819 off_t off = lseek(fh, offset, whence);
kevman 0:38ceb79fef03 820 // Assuming INT_MAX = LONG_MAX, so we don't care about prototype difference
kevman 0:38ceb79fef03 821 if (off > INT_MAX) {
kevman 0:38ceb79fef03 822 errno = EOVERFLOW;
kevman 0:38ceb79fef03 823 return -1;
kevman 0:38ceb79fef03 824 }
kevman 0:38ceb79fef03 825 return off;
kevman 0:38ceb79fef03 826 }
kevman 0:38ceb79fef03 827
kevman 0:38ceb79fef03 828 extern "C" off_t lseek(int fildes, off_t offset, int whence)
kevman 0:38ceb79fef03 829 {
kevman 0:38ceb79fef03 830 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 831 if (fhc == NULL) {
kevman 0:38ceb79fef03 832 errno = EBADF;
kevman 0:38ceb79fef03 833 return -1;
kevman 0:38ceb79fef03 834 }
kevman 0:38ceb79fef03 835
kevman 0:38ceb79fef03 836 off_t off = fhc->seek(offset, whence);
kevman 0:38ceb79fef03 837 if (off < 0) {
kevman 0:38ceb79fef03 838 errno = -off;
kevman 0:38ceb79fef03 839 return -1;
kevman 0:38ceb79fef03 840 }
kevman 0:38ceb79fef03 841 return off;
kevman 0:38ceb79fef03 842 }
kevman 0:38ceb79fef03 843
kevman 0:38ceb79fef03 844 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 845 extern "C" int PREFIX(_ensure)(FILEHANDLE fh)
kevman 0:38ceb79fef03 846 {
kevman 0:38ceb79fef03 847 return fsync(fh);
kevman 0:38ceb79fef03 848 }
kevman 0:38ceb79fef03 849 #endif
kevman 0:38ceb79fef03 850
kevman 0:38ceb79fef03 851 extern "C" int fsync(int fildes)
kevman 0:38ceb79fef03 852 {
kevman 0:38ceb79fef03 853 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 854 if (fhc == NULL) {
kevman 0:38ceb79fef03 855 errno = EBADF;
kevman 0:38ceb79fef03 856 return -1;
kevman 0:38ceb79fef03 857 }
kevman 0:38ceb79fef03 858
kevman 0:38ceb79fef03 859 int err = fhc->sync();
kevman 0:38ceb79fef03 860 if (err < 0) {
kevman 0:38ceb79fef03 861 errno = -err;
kevman 0:38ceb79fef03 862 return -1;
kevman 0:38ceb79fef03 863 } else {
kevman 0:38ceb79fef03 864 return 0;
kevman 0:38ceb79fef03 865 }
kevman 0:38ceb79fef03 866 }
kevman 0:38ceb79fef03 867
kevman 0:38ceb79fef03 868 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 869 extern "C" long PREFIX(_flen)(FILEHANDLE fh)
kevman 0:38ceb79fef03 870 {
kevman 0:38ceb79fef03 871 FileHandle *fhc = get_fhc(fh);
kevman 0:38ceb79fef03 872 if (fhc == NULL) {
kevman 0:38ceb79fef03 873 errno = EBADF;
kevman 0:38ceb79fef03 874 return -1;
kevman 0:38ceb79fef03 875 }
kevman 0:38ceb79fef03 876
kevman 0:38ceb79fef03 877 off_t size = fhc->size();
kevman 0:38ceb79fef03 878 if (size < 0) {
kevman 0:38ceb79fef03 879 errno = -size;
kevman 0:38ceb79fef03 880 return -1;
kevman 0:38ceb79fef03 881 }
kevman 0:38ceb79fef03 882 if (size > LONG_MAX) {
kevman 0:38ceb79fef03 883 errno = EOVERFLOW;
kevman 0:38ceb79fef03 884 return -1;
kevman 0:38ceb79fef03 885 }
kevman 0:38ceb79fef03 886 return size;
kevman 0:38ceb79fef03 887 }
kevman 0:38ceb79fef03 888
kevman 0:38ceb79fef03 889 extern "C" char Image$$RW_IRAM1$$ZI$$Limit[];
kevman 0:38ceb79fef03 890
kevman 0:38ceb79fef03 891 extern "C" MBED_WEAK __value_in_regs struct __initial_stackheap _mbed_user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3)
kevman 0:38ceb79fef03 892 {
kevman 0:38ceb79fef03 893 uint32_t zi_limit = (uint32_t)Image$$RW_IRAM1$$ZI$$Limit;
kevman 0:38ceb79fef03 894 uint32_t sp_limit = __current_sp();
kevman 0:38ceb79fef03 895
kevman 0:38ceb79fef03 896 zi_limit = (zi_limit + 7) & ~0x7; // ensure zi_limit is 8-byte aligned
kevman 0:38ceb79fef03 897
kevman 0:38ceb79fef03 898 struct __initial_stackheap r;
kevman 0:38ceb79fef03 899 r.heap_base = zi_limit;
kevman 0:38ceb79fef03 900 r.heap_limit = sp_limit;
kevman 0:38ceb79fef03 901 return r;
kevman 0:38ceb79fef03 902 }
kevman 0:38ceb79fef03 903
kevman 0:38ceb79fef03 904 extern "C" __value_in_regs struct __initial_stackheap __user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3)
kevman 0:38ceb79fef03 905 {
kevman 0:38ceb79fef03 906 return _mbed_user_setup_stackheap(R0, R1, R2, R3);
kevman 0:38ceb79fef03 907 }
kevman 0:38ceb79fef03 908
kevman 0:38ceb79fef03 909 #endif
kevman 0:38ceb79fef03 910
kevman 0:38ceb79fef03 911
kevman 0:38ceb79fef03 912 #if !defined(__ARMCC_VERSION) && !defined(__ICCARM__)
kevman 0:38ceb79fef03 913 extern "C" int _fstat(int fh, struct stat *st)
kevman 0:38ceb79fef03 914 {
kevman 0:38ceb79fef03 915 return fstat(fh, st);
kevman 0:38ceb79fef03 916 }
kevman 0:38ceb79fef03 917 #endif
kevman 0:38ceb79fef03 918
kevman 0:38ceb79fef03 919 extern "C" int fstat(int fildes, struct stat *st)
kevman 0:38ceb79fef03 920 {
kevman 0:38ceb79fef03 921 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 922 if (fhc == NULL) {
kevman 0:38ceb79fef03 923 errno = EBADF;
kevman 0:38ceb79fef03 924 return -1;
kevman 0:38ceb79fef03 925 }
kevman 0:38ceb79fef03 926
kevman 0:38ceb79fef03 927 st->st_mode = fhc->isatty() ? S_IFCHR : S_IFREG;
kevman 0:38ceb79fef03 928 st->st_size = fhc->size();
kevman 0:38ceb79fef03 929 return 0;
kevman 0:38ceb79fef03 930 }
kevman 0:38ceb79fef03 931
kevman 0:38ceb79fef03 932 extern "C" int fcntl(int fildes, int cmd, ...)
kevman 0:38ceb79fef03 933 {
kevman 0:38ceb79fef03 934 FileHandle *fhc = get_fhc(fildes);
kevman 0:38ceb79fef03 935 if (fhc == NULL) {
kevman 0:38ceb79fef03 936 errno = EBADF;
kevman 0:38ceb79fef03 937 return -1;
kevman 0:38ceb79fef03 938 }
kevman 0:38ceb79fef03 939
kevman 0:38ceb79fef03 940 switch (cmd) {
kevman 0:38ceb79fef03 941 case F_GETFL: {
kevman 0:38ceb79fef03 942 int flags = 0;
kevman 0:38ceb79fef03 943 if (fhc->is_blocking()) {
kevman 0:38ceb79fef03 944 flags |= O_NONBLOCK;
kevman 0:38ceb79fef03 945 }
kevman 0:38ceb79fef03 946 return flags;
kevman 0:38ceb79fef03 947 }
kevman 0:38ceb79fef03 948 case F_SETFL: {
kevman 0:38ceb79fef03 949 va_list ap;
kevman 0:38ceb79fef03 950 va_start(ap, cmd);
kevman 0:38ceb79fef03 951 int flags = va_arg(ap, int);
kevman 0:38ceb79fef03 952 va_end(ap);
kevman 0:38ceb79fef03 953 int ret = fhc->set_blocking(flags & O_NONBLOCK);
kevman 0:38ceb79fef03 954 if (ret < 0) {
kevman 0:38ceb79fef03 955 errno = -ret;
kevman 0:38ceb79fef03 956 return -1;
kevman 0:38ceb79fef03 957 }
kevman 0:38ceb79fef03 958 return 0;
kevman 0:38ceb79fef03 959 }
kevman 0:38ceb79fef03 960
kevman 0:38ceb79fef03 961 default: {
kevman 0:38ceb79fef03 962 errno = EINVAL;
kevman 0:38ceb79fef03 963 return -1;
kevman 0:38ceb79fef03 964 }
kevman 0:38ceb79fef03 965 }
kevman 0:38ceb79fef03 966 }
kevman 0:38ceb79fef03 967
kevman 0:38ceb79fef03 968 extern "C" int poll(struct pollfd fds[], nfds_t nfds, int timeout)
kevman 0:38ceb79fef03 969 {
kevman 0:38ceb79fef03 970 if (nfds > OPEN_MAX) {
kevman 0:38ceb79fef03 971 errno = EINVAL;
kevman 0:38ceb79fef03 972 return -1;
kevman 0:38ceb79fef03 973 }
kevman 0:38ceb79fef03 974
kevman 0:38ceb79fef03 975 struct mbed::pollfh fhs[OPEN_MAX];
kevman 0:38ceb79fef03 976 for (nfds_t n = 0; n < nfds; n++) {
kevman 0:38ceb79fef03 977 // Underlying FileHandle poll returns POLLNVAL if given NULL, so
kevman 0:38ceb79fef03 978 // we don't need to take special action.
kevman 0:38ceb79fef03 979 fhs[n].fh = get_fhc(fds[n].fd);
kevman 0:38ceb79fef03 980 fhs[n].events = fds[n].events;
kevman 0:38ceb79fef03 981 }
kevman 0:38ceb79fef03 982 int ret = poll(fhs, nfds, timeout);
kevman 0:38ceb79fef03 983 for (nfds_t n = 0; n < nfds; n++) {
kevman 0:38ceb79fef03 984 fds[n].revents = fhs[n].revents;
kevman 0:38ceb79fef03 985 }
kevman 0:38ceb79fef03 986 return ret;
kevman 0:38ceb79fef03 987 }
kevman 0:38ceb79fef03 988
kevman 0:38ceb79fef03 989 namespace std {
kevman 0:38ceb79fef03 990 extern "C" int remove(const char *path)
kevman 0:38ceb79fef03 991 {
kevman 0:38ceb79fef03 992 FilePath fp(path);
kevman 0:38ceb79fef03 993 FileSystemHandle *fs = fp.fileSystem();
kevman 0:38ceb79fef03 994 if (fs == NULL) {
kevman 0:38ceb79fef03 995 errno = ENODEV;
kevman 0:38ceb79fef03 996 return -1;
kevman 0:38ceb79fef03 997 }
kevman 0:38ceb79fef03 998
kevman 0:38ceb79fef03 999 int err = fs->remove(fp.fileName());
kevman 0:38ceb79fef03 1000 if (err < 0) {
kevman 0:38ceb79fef03 1001 errno = -err;
kevman 0:38ceb79fef03 1002 return -1;
kevman 0:38ceb79fef03 1003 } else {
kevman 0:38ceb79fef03 1004 return 0;
kevman 0:38ceb79fef03 1005 }
kevman 0:38ceb79fef03 1006 }
kevman 0:38ceb79fef03 1007
kevman 0:38ceb79fef03 1008 extern "C" int rename(const char *oldname, const char *newname)
kevman 0:38ceb79fef03 1009 {
kevman 0:38ceb79fef03 1010 FilePath fpOld(oldname);
kevman 0:38ceb79fef03 1011 FilePath fpNew(newname);
kevman 0:38ceb79fef03 1012 FileSystemHandle *fsOld = fpOld.fileSystem();
kevman 0:38ceb79fef03 1013 FileSystemHandle *fsNew = fpNew.fileSystem();
kevman 0:38ceb79fef03 1014
kevman 0:38ceb79fef03 1015 if (fsOld == NULL) {
kevman 0:38ceb79fef03 1016 errno = ENODEV;
kevman 0:38ceb79fef03 1017 return -1;
kevman 0:38ceb79fef03 1018 }
kevman 0:38ceb79fef03 1019
kevman 0:38ceb79fef03 1020 /* rename only if both files are on the same FS */
kevman 0:38ceb79fef03 1021 if (fsOld != fsNew) {
kevman 0:38ceb79fef03 1022 errno = EXDEV;
kevman 0:38ceb79fef03 1023 return -1;
kevman 0:38ceb79fef03 1024 }
kevman 0:38ceb79fef03 1025
kevman 0:38ceb79fef03 1026 int err = fsOld->rename(fpOld.fileName(), fpNew.fileName());
kevman 0:38ceb79fef03 1027 if (err < 0) {
kevman 0:38ceb79fef03 1028 errno = -err;
kevman 0:38ceb79fef03 1029 return -1;
kevman 0:38ceb79fef03 1030 } else {
kevman 0:38ceb79fef03 1031 return 0;
kevman 0:38ceb79fef03 1032 }
kevman 0:38ceb79fef03 1033 }
kevman 0:38ceb79fef03 1034
kevman 0:38ceb79fef03 1035 extern "C" char *tmpnam(char *s)
kevman 0:38ceb79fef03 1036 {
kevman 0:38ceb79fef03 1037 errno = EBADF;
kevman 0:38ceb79fef03 1038 return NULL;
kevman 0:38ceb79fef03 1039 }
kevman 0:38ceb79fef03 1040
kevman 0:38ceb79fef03 1041 extern "C" FILE *tmpfile()
kevman 0:38ceb79fef03 1042 {
kevman 0:38ceb79fef03 1043 errno = EBADF;
kevman 0:38ceb79fef03 1044 return NULL;
kevman 0:38ceb79fef03 1045 }
kevman 0:38ceb79fef03 1046 } // namespace std
kevman 0:38ceb79fef03 1047
kevman 0:38ceb79fef03 1048 #ifdef __ARMCC_VERSION
kevman 0:38ceb79fef03 1049 extern "C" char *_sys_command_string(char *cmd, int len)
kevman 0:38ceb79fef03 1050 {
kevman 0:38ceb79fef03 1051 return NULL;
kevman 0:38ceb79fef03 1052 }
kevman 0:38ceb79fef03 1053 #endif
kevman 0:38ceb79fef03 1054
kevman 0:38ceb79fef03 1055 extern "C" DIR *opendir(const char *path)
kevman 0:38ceb79fef03 1056 {
kevman 0:38ceb79fef03 1057 FilePath fp(path);
kevman 0:38ceb79fef03 1058 FileSystemHandle *fs = fp.fileSystem();
kevman 0:38ceb79fef03 1059 if (fs == NULL) {
kevman 0:38ceb79fef03 1060 errno = ENODEV;
kevman 0:38ceb79fef03 1061 return NULL;
kevman 0:38ceb79fef03 1062 }
kevman 0:38ceb79fef03 1063
kevman 0:38ceb79fef03 1064 DirHandle *dir;
kevman 0:38ceb79fef03 1065 int err = fs->open(&dir, fp.fileName());
kevman 0:38ceb79fef03 1066 if (err < 0) {
kevman 0:38ceb79fef03 1067 errno = -err;
kevman 0:38ceb79fef03 1068 return NULL;
kevman 0:38ceb79fef03 1069 }
kevman 0:38ceb79fef03 1070
kevman 0:38ceb79fef03 1071 return dir;
kevman 0:38ceb79fef03 1072 }
kevman 0:38ceb79fef03 1073
kevman 0:38ceb79fef03 1074 extern "C" struct dirent *readdir(DIR *dir)
kevman 0:38ceb79fef03 1075 {
kevman 0:38ceb79fef03 1076 static struct dirent ent;
kevman 0:38ceb79fef03 1077 int err = dir->read(&ent);
kevman 0:38ceb79fef03 1078 if (err < 1) {
kevman 0:38ceb79fef03 1079 if (err < 0) {
kevman 0:38ceb79fef03 1080 errno = -err;
kevman 0:38ceb79fef03 1081 }
kevman 0:38ceb79fef03 1082 return NULL;
kevman 0:38ceb79fef03 1083 }
kevman 0:38ceb79fef03 1084
kevman 0:38ceb79fef03 1085 return &ent;
kevman 0:38ceb79fef03 1086 }
kevman 0:38ceb79fef03 1087
kevman 0:38ceb79fef03 1088 extern "C" int closedir(DIR *dir)
kevman 0:38ceb79fef03 1089 {
kevman 0:38ceb79fef03 1090 int err = dir->close();
kevman 0:38ceb79fef03 1091 if (err < 0) {
kevman 0:38ceb79fef03 1092 errno = -err;
kevman 0:38ceb79fef03 1093 return -1;
kevman 0:38ceb79fef03 1094 } else {
kevman 0:38ceb79fef03 1095 return 0;
kevman 0:38ceb79fef03 1096 }
kevman 0:38ceb79fef03 1097 }
kevman 0:38ceb79fef03 1098
kevman 0:38ceb79fef03 1099 extern "C" void rewinddir(DIR *dir)
kevman 0:38ceb79fef03 1100 {
kevman 0:38ceb79fef03 1101 dir->rewind();
kevman 0:38ceb79fef03 1102 }
kevman 0:38ceb79fef03 1103
kevman 0:38ceb79fef03 1104 extern "C" off_t telldir(DIR *dir)
kevman 0:38ceb79fef03 1105 {
kevman 0:38ceb79fef03 1106 return dir->tell();
kevman 0:38ceb79fef03 1107 }
kevman 0:38ceb79fef03 1108
kevman 0:38ceb79fef03 1109 extern "C" void seekdir(DIR *dir, off_t off)
kevman 0:38ceb79fef03 1110 {
kevman 0:38ceb79fef03 1111 dir->seek(off);
kevman 0:38ceb79fef03 1112 }
kevman 0:38ceb79fef03 1113
kevman 0:38ceb79fef03 1114 extern "C" int mkdir(const char *path, mode_t mode)
kevman 0:38ceb79fef03 1115 {
kevman 0:38ceb79fef03 1116 FilePath fp(path);
kevman 0:38ceb79fef03 1117 FileSystemHandle *fs = fp.fileSystem();
kevman 0:38ceb79fef03 1118 if (fs == NULL) {
kevman 0:38ceb79fef03 1119 errno = ENODEV;
kevman 0:38ceb79fef03 1120 return -1;
kevman 0:38ceb79fef03 1121 }
kevman 0:38ceb79fef03 1122
kevman 0:38ceb79fef03 1123 int err = fs->mkdir(fp.fileName(), mode);
kevman 0:38ceb79fef03 1124 if (err < 0) {
kevman 0:38ceb79fef03 1125 errno = -err;
kevman 0:38ceb79fef03 1126 return -1;
kevman 0:38ceb79fef03 1127 } else {
kevman 0:38ceb79fef03 1128 return 0;
kevman 0:38ceb79fef03 1129 }
kevman 0:38ceb79fef03 1130 }
kevman 0:38ceb79fef03 1131
kevman 0:38ceb79fef03 1132 extern "C" int stat(const char *path, struct stat *st)
kevman 0:38ceb79fef03 1133 {
kevman 0:38ceb79fef03 1134 FilePath fp(path);
kevman 0:38ceb79fef03 1135 FileSystemHandle *fs = fp.fileSystem();
kevman 0:38ceb79fef03 1136 if (fs == NULL) {
kevman 0:38ceb79fef03 1137 errno = ENODEV;
kevman 0:38ceb79fef03 1138 return -1;
kevman 0:38ceb79fef03 1139 }
kevman 0:38ceb79fef03 1140
kevman 0:38ceb79fef03 1141 int err = fs->stat(fp.fileName(), st);
kevman 0:38ceb79fef03 1142 if (err < 0) {
kevman 0:38ceb79fef03 1143 errno = -err;
kevman 0:38ceb79fef03 1144 return -1;
kevman 0:38ceb79fef03 1145 } else {
kevman 0:38ceb79fef03 1146 return 0;
kevman 0:38ceb79fef03 1147 }
kevman 0:38ceb79fef03 1148 }
kevman 0:38ceb79fef03 1149
kevman 0:38ceb79fef03 1150 extern "C" int statvfs(const char *path, struct statvfs *buf)
kevman 0:38ceb79fef03 1151 {
kevman 0:38ceb79fef03 1152 FilePath fp(path);
kevman 0:38ceb79fef03 1153 FileSystemHandle *fs = fp.fileSystem();
kevman 0:38ceb79fef03 1154 if (fs == NULL) {
kevman 0:38ceb79fef03 1155 errno = ENODEV;
kevman 0:38ceb79fef03 1156 return -1;
kevman 0:38ceb79fef03 1157 }
kevman 0:38ceb79fef03 1158
kevman 0:38ceb79fef03 1159 int err = fs->statvfs(fp.fileName(), buf);
kevman 0:38ceb79fef03 1160 if (err < 0) {
kevman 0:38ceb79fef03 1161 errno = -err;
kevman 0:38ceb79fef03 1162 return -1;
kevman 0:38ceb79fef03 1163 } else {
kevman 0:38ceb79fef03 1164 return 0;
kevman 0:38ceb79fef03 1165 }
kevman 0:38ceb79fef03 1166 }
kevman 0:38ceb79fef03 1167
kevman 0:38ceb79fef03 1168 #if defined(TOOLCHAIN_GCC)
kevman 0:38ceb79fef03 1169 /* prevents the exception handling name demangling code getting pulled in */
kevman 0:38ceb79fef03 1170 #include "mbed_error.h"
kevman 0:38ceb79fef03 1171 namespace __gnu_cxx {
kevman 0:38ceb79fef03 1172 void __verbose_terminate_handler()
kevman 0:38ceb79fef03 1173 {
kevman 0:38ceb79fef03 1174 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_CLIB_EXCEPTION), "Exception", 0);
kevman 0:38ceb79fef03 1175 }
kevman 0:38ceb79fef03 1176 }
kevman 0:38ceb79fef03 1177 extern "C" WEAK void __cxa_pure_virtual(void);
kevman 0:38ceb79fef03 1178 extern "C" WEAK void __cxa_pure_virtual(void)
kevman 0:38ceb79fef03 1179 {
kevman 0:38ceb79fef03 1180 exit(1);
kevman 0:38ceb79fef03 1181 }
kevman 0:38ceb79fef03 1182
kevman 0:38ceb79fef03 1183 #endif
kevman 0:38ceb79fef03 1184
kevman 0:38ceb79fef03 1185 // Provide implementation of _sbrk (low-level dynamic memory allocation
kevman 0:38ceb79fef03 1186 // routine) for GCC_ARM which compares new heap pointer with MSP instead of
kevman 0:38ceb79fef03 1187 // SP. This make it compatible with RTX RTOS thread stacks.
kevman 0:38ceb79fef03 1188 #if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR)
kevman 0:38ceb79fef03 1189
kevman 0:38ceb79fef03 1190 #if defined(TARGET_CORTEX_A)
kevman 0:38ceb79fef03 1191 extern "C" uint32_t __HeapLimit;
kevman 0:38ceb79fef03 1192 #endif
kevman 0:38ceb79fef03 1193
kevman 0:38ceb79fef03 1194 // Turn off the errno macro and use actual global variable instead.
kevman 0:38ceb79fef03 1195 #undef errno
kevman 0:38ceb79fef03 1196 extern "C" int errno;
kevman 0:38ceb79fef03 1197
kevman 0:38ceb79fef03 1198 // Dynamic memory allocation related syscall.
kevman 0:38ceb79fef03 1199 #if defined(TWO_RAM_REGIONS)
kevman 0:38ceb79fef03 1200
kevman 0:38ceb79fef03 1201 // Overwrite _sbrk() to support two region model (heap and stack are two distinct regions).
kevman 0:38ceb79fef03 1202 // __wrap__sbrk() is implemented in:
kevman 0:38ceb79fef03 1203 // TARGET_STM32L4 targets/TARGET_STM/TARGET_STM32L4/TARGET_STM32L4/l4_retarget.c
kevman 0:38ceb79fef03 1204 extern "C" void *__wrap__sbrk(int incr);
kevman 0:38ceb79fef03 1205 extern "C" caddr_t _sbrk(int incr)
kevman 0:38ceb79fef03 1206 {
kevman 0:38ceb79fef03 1207 return (caddr_t) __wrap__sbrk(incr);
kevman 0:38ceb79fef03 1208 }
kevman 0:38ceb79fef03 1209 #else
kevman 0:38ceb79fef03 1210 // Linker defined symbol used by _sbrk to indicate where heap should start.
kevman 0:38ceb79fef03 1211 extern "C" uint32_t __end__;
kevman 0:38ceb79fef03 1212 // Weak attribute allows user to override, e.g. to use external RAM for dynamic memory.
kevman 0:38ceb79fef03 1213 extern "C" WEAK caddr_t _sbrk(int incr)
kevman 0:38ceb79fef03 1214 {
kevman 0:38ceb79fef03 1215 static unsigned char *heap = (unsigned char *)&__end__;
kevman 0:38ceb79fef03 1216 unsigned char *prev_heap = heap;
kevman 0:38ceb79fef03 1217 unsigned char *new_heap = heap + incr;
kevman 0:38ceb79fef03 1218
kevman 0:38ceb79fef03 1219 #if defined(TARGET_CORTEX_A)
kevman 0:38ceb79fef03 1220 if (new_heap >= (unsigned char *)&__HeapLimit) { /* __HeapLimit is end of heap section */
kevman 0:38ceb79fef03 1221 #else
kevman 0:38ceb79fef03 1222 if (new_heap >= (unsigned char *)__get_MSP()) {
kevman 0:38ceb79fef03 1223 #endif
kevman 0:38ceb79fef03 1224 errno = ENOMEM;
kevman 0:38ceb79fef03 1225 return (caddr_t) -1;
kevman 0:38ceb79fef03 1226 }
kevman 0:38ceb79fef03 1227
kevman 0:38ceb79fef03 1228 // Additional heap checking if set
kevman 0:38ceb79fef03 1229 if (mbed_heap_size && (new_heap >= mbed_heap_start + mbed_heap_size)) {
kevman 0:38ceb79fef03 1230 errno = ENOMEM;
kevman 0:38ceb79fef03 1231 return (caddr_t) -1;
kevman 0:38ceb79fef03 1232 }
kevman 0:38ceb79fef03 1233
kevman 0:38ceb79fef03 1234 heap = new_heap;
kevman 0:38ceb79fef03 1235 return (caddr_t) prev_heap;
kevman 0:38ceb79fef03 1236 }
kevman 0:38ceb79fef03 1237 #endif
kevman 0:38ceb79fef03 1238 #endif
kevman 0:38ceb79fef03 1239
kevman 0:38ceb79fef03 1240 #if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR)
kevman 0:38ceb79fef03 1241 extern "C" void _exit(int return_code)
kevman 0:38ceb79fef03 1242 {
kevman 0:38ceb79fef03 1243 #else
kevman 0:38ceb79fef03 1244 namespace std {
kevman 0:38ceb79fef03 1245 extern "C" void exit(int return_code)
kevman 0:38ceb79fef03 1246 {
kevman 0:38ceb79fef03 1247 #endif
kevman 0:38ceb79fef03 1248
kevman 0:38ceb79fef03 1249 #if DEVICE_STDIO_MESSAGES
kevman 0:38ceb79fef03 1250 #if MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT
kevman 0:38ceb79fef03 1251 fflush(stdout);
kevman 0:38ceb79fef03 1252 fflush(stderr);
kevman 0:38ceb79fef03 1253 #endif
kevman 0:38ceb79fef03 1254 #endif
kevman 0:38ceb79fef03 1255
kevman 0:38ceb79fef03 1256 #if DEVICE_SEMIHOST
kevman 0:38ceb79fef03 1257 if (mbed_interface_connected()) {
kevman 0:38ceb79fef03 1258 semihost_exit();
kevman 0:38ceb79fef03 1259 }
kevman 0:38ceb79fef03 1260 #endif
kevman 0:38ceb79fef03 1261 if (return_code) {
kevman 0:38ceb79fef03 1262 mbed_die();
kevman 0:38ceb79fef03 1263 }
kevman 0:38ceb79fef03 1264
kevman 0:38ceb79fef03 1265 while (1);
kevman 0:38ceb79fef03 1266 }
kevman 0:38ceb79fef03 1267
kevman 0:38ceb79fef03 1268 #if !defined(TOOLCHAIN_GCC_ARM) && !defined(TOOLCHAIN_GCC_CR)
kevman 0:38ceb79fef03 1269 } //namespace std
kevman 0:38ceb79fef03 1270 #endif
kevman 0:38ceb79fef03 1271
kevman 0:38ceb79fef03 1272 #if defined(TOOLCHAIN_ARM) || defined(TOOLCHAIN_GCC)
kevman 0:38ceb79fef03 1273
kevman 0:38ceb79fef03 1274 // This series of function disable the registration of global destructors
kevman 0:38ceb79fef03 1275 // in a dynamic table which will be called when the application exit.
kevman 0:38ceb79fef03 1276 // In mbed, program never exit properly, it dies.
kevman 0:38ceb79fef03 1277 // More informations about this topic for ARMCC here:
kevman 0:38ceb79fef03 1278 // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/6449.html
kevman 0:38ceb79fef03 1279 extern "C" {
kevman 0:38ceb79fef03 1280 int __aeabi_atexit(void *object, void (*dtor)(void * /*this*/), void *handle)
kevman 0:38ceb79fef03 1281 {
kevman 0:38ceb79fef03 1282 return 1;
kevman 0:38ceb79fef03 1283 }
kevman 0:38ceb79fef03 1284
kevman 0:38ceb79fef03 1285 int __cxa_atexit(void (*dtor)(void * /*this*/), void *object, void *handle)
kevman 0:38ceb79fef03 1286 {
kevman 0:38ceb79fef03 1287 return 1;
kevman 0:38ceb79fef03 1288 }
kevman 0:38ceb79fef03 1289
kevman 0:38ceb79fef03 1290 void __cxa_finalize(void *handle)
kevman 0:38ceb79fef03 1291 {
kevman 0:38ceb79fef03 1292 }
kevman 0:38ceb79fef03 1293
kevman 0:38ceb79fef03 1294 } // end of extern "C"
kevman 0:38ceb79fef03 1295
kevman 0:38ceb79fef03 1296 #endif
kevman 0:38ceb79fef03 1297
kevman 0:38ceb79fef03 1298
kevman 0:38ceb79fef03 1299 #if defined(TOOLCHAIN_GCC)
kevman 0:38ceb79fef03 1300
kevman 0:38ceb79fef03 1301 /*
kevman 0:38ceb79fef03 1302 * Depending on how newlib is configured, it is often not enough to define
kevman 0:38ceb79fef03 1303 * __aeabi_atexit, __cxa_atexit and __cxa_finalize in order to override the
kevman 0:38ceb79fef03 1304 * behavior regarding the registration of handlers with atexit.
kevman 0:38ceb79fef03 1305 *
kevman 0:38ceb79fef03 1306 * To overcome this limitation, exit and atexit are overriden here.
kevman 0:38ceb79fef03 1307 */
kevman 0:38ceb79fef03 1308 extern "C" {
kevman 0:38ceb79fef03 1309
kevman 0:38ceb79fef03 1310 /**
kevman 0:38ceb79fef03 1311 * @brief Retarget of exit for GCC.
kevman 0:38ceb79fef03 1312 * @details Unlike the standard version, this function doesn't call any function
kevman 0:38ceb79fef03 1313 * registered with atexit before calling _exit.
kevman 0:38ceb79fef03 1314 */
kevman 0:38ceb79fef03 1315 void __wrap_exit(int return_code)
kevman 0:38ceb79fef03 1316 {
kevman 0:38ceb79fef03 1317 _exit(return_code);
kevman 0:38ceb79fef03 1318 }
kevman 0:38ceb79fef03 1319
kevman 0:38ceb79fef03 1320 /**
kevman 0:38ceb79fef03 1321 * @brief Retarget atexit from GCC.
kevman 0:38ceb79fef03 1322 * @details This function will always fail and never register any handler to be
kevman 0:38ceb79fef03 1323 * called at exit.
kevman 0:38ceb79fef03 1324 */
kevman 0:38ceb79fef03 1325 int __wrap_atexit(void (*func)())
kevman 0:38ceb79fef03 1326 {
kevman 0:38ceb79fef03 1327 return 1;
kevman 0:38ceb79fef03 1328 }
kevman 0:38ceb79fef03 1329
kevman 0:38ceb79fef03 1330 }
kevman 0:38ceb79fef03 1331
kevman 0:38ceb79fef03 1332 #endif
kevman 0:38ceb79fef03 1333
kevman 0:38ceb79fef03 1334
kevman 0:38ceb79fef03 1335
kevman 0:38ceb79fef03 1336 namespace mbed {
kevman 0:38ceb79fef03 1337
kevman 0:38ceb79fef03 1338 void mbed_set_unbuffered_stream(std::FILE *_file)
kevman 0:38ceb79fef03 1339 {
kevman 0:38ceb79fef03 1340 #if defined (__ICCARM__)
kevman 0:38ceb79fef03 1341 char buf[2];
kevman 0:38ceb79fef03 1342 std::setvbuf(_file, buf, _IONBF, NULL);
kevman 0:38ceb79fef03 1343 #else
kevman 0:38ceb79fef03 1344 setbuf(_file, NULL);
kevman 0:38ceb79fef03 1345 #endif
kevman 0:38ceb79fef03 1346 }
kevman 0:38ceb79fef03 1347
kevman 0:38ceb79fef03 1348 int mbed_getc(std::FILE *_file)
kevman 0:38ceb79fef03 1349 {
kevman 0:38ceb79fef03 1350 #if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ < 8000000)
kevman 0:38ceb79fef03 1351 /*This is only valid for unbuffered streams*/
kevman 0:38ceb79fef03 1352 int res = std::fgetc(_file);
kevman 0:38ceb79fef03 1353 if (res >= 0) {
kevman 0:38ceb79fef03 1354 _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */
kevman 0:38ceb79fef03 1355 _file->_Rend = _file->_Wend;
kevman 0:38ceb79fef03 1356 _file->_Next = _file->_Wend;
kevman 0:38ceb79fef03 1357 }
kevman 0:38ceb79fef03 1358 return res;
kevman 0:38ceb79fef03 1359 #else
kevman 0:38ceb79fef03 1360 return std::fgetc(_file);
kevman 0:38ceb79fef03 1361 #endif
kevman 0:38ceb79fef03 1362 }
kevman 0:38ceb79fef03 1363
kevman 0:38ceb79fef03 1364 char *mbed_gets(char *s, int size, std::FILE *_file)
kevman 0:38ceb79fef03 1365 {
kevman 0:38ceb79fef03 1366 #if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ < 8000000)
kevman 0:38ceb79fef03 1367 /*This is only valid for unbuffered streams*/
kevman 0:38ceb79fef03 1368 char *str = fgets(s, size, _file);
kevman 0:38ceb79fef03 1369 if (str != NULL) {
kevman 0:38ceb79fef03 1370 _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */
kevman 0:38ceb79fef03 1371 _file->_Rend = _file->_Wend;
kevman 0:38ceb79fef03 1372 _file->_Next = _file->_Wend;
kevman 0:38ceb79fef03 1373 }
kevman 0:38ceb79fef03 1374 return str;
kevman 0:38ceb79fef03 1375 #else
kevman 0:38ceb79fef03 1376 return std::fgets(s, size, _file);
kevman 0:38ceb79fef03 1377 #endif
kevman 0:38ceb79fef03 1378 }
kevman 0:38ceb79fef03 1379
kevman 0:38ceb79fef03 1380 } // namespace mbed
kevman 0:38ceb79fef03 1381
kevman 0:38ceb79fef03 1382 #if defined (__ICCARM__)
kevman 0:38ceb79fef03 1383 // Stub out locks when an rtos is not present
kevman 0:38ceb79fef03 1384 extern "C" WEAK void __iar_system_Mtxinit(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1385 extern "C" WEAK void __iar_system_Mtxdst(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1386 extern "C" WEAK void __iar_system_Mtxlock(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1387 extern "C" WEAK void __iar_system_Mtxunlock(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1388 extern "C" WEAK void __iar_file_Mtxinit(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1389 extern "C" WEAK void __iar_file_Mtxdst(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1390 extern "C" WEAK void __iar_file_Mtxlock(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1391 extern "C" WEAK void __iar_file_Mtxunlock(__iar_Rmtx *mutex) {}
kevman 0:38ceb79fef03 1392 #if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ >= 8000000)
kevman 0:38ceb79fef03 1393 #pragma section="__iar_tls$$DATA"
kevman 0:38ceb79fef03 1394 extern "C" WEAK void *__aeabi_read_tp(void)
kevman 0:38ceb79fef03 1395 {
kevman 0:38ceb79fef03 1396 // Thread Local storage is not supported, using main thread memory for errno
kevman 0:38ceb79fef03 1397 return __section_begin("__iar_tls$$DATA");
kevman 0:38ceb79fef03 1398 }
kevman 0:38ceb79fef03 1399 #endif
kevman 0:38ceb79fef03 1400 #elif defined(__CC_ARM)
kevman 0:38ceb79fef03 1401 // Do nothing
kevman 0:38ceb79fef03 1402 #elif defined (__GNUC__)
kevman 0:38ceb79fef03 1403 struct _reent;
kevman 0:38ceb79fef03 1404 // Stub out locks when an rtos is not present
kevman 0:38ceb79fef03 1405 extern "C" WEAK void __rtos_malloc_lock(struct _reent *_r) {}
kevman 0:38ceb79fef03 1406 extern "C" WEAK void __rtos_malloc_unlock(struct _reent *_r) {}
kevman 0:38ceb79fef03 1407 extern "C" WEAK void __rtos_env_lock(struct _reent *_r) {}
kevman 0:38ceb79fef03 1408 extern "C" WEAK void __rtos_env_unlock(struct _reent *_r) {}
kevman 0:38ceb79fef03 1409
kevman 0:38ceb79fef03 1410 extern "C" void __malloc_lock(struct _reent *_r)
kevman 0:38ceb79fef03 1411 {
kevman 0:38ceb79fef03 1412 __rtos_malloc_lock(_r);
kevman 0:38ceb79fef03 1413 }
kevman 0:38ceb79fef03 1414
kevman 0:38ceb79fef03 1415 extern "C" void __malloc_unlock(struct _reent *_r)
kevman 0:38ceb79fef03 1416 {
kevman 0:38ceb79fef03 1417 __rtos_malloc_unlock(_r);
kevman 0:38ceb79fef03 1418 }
kevman 0:38ceb79fef03 1419
kevman 0:38ceb79fef03 1420 extern "C" void __env_lock(struct _reent *_r)
kevman 0:38ceb79fef03 1421 {
kevman 0:38ceb79fef03 1422 __rtos_env_lock(_r);
kevman 0:38ceb79fef03 1423 }
kevman 0:38ceb79fef03 1424
kevman 0:38ceb79fef03 1425 extern "C" void __env_unlock(struct _reent *_r)
kevman 0:38ceb79fef03 1426 {
kevman 0:38ceb79fef03 1427 __rtos_env_unlock(_r);
kevman 0:38ceb79fef03 1428 }
kevman 0:38ceb79fef03 1429
kevman 0:38ceb79fef03 1430 #endif
kevman 0:38ceb79fef03 1431
kevman 0:38ceb79fef03 1432 #if defined (__GNUC__) || defined(__CC_ARM) || (defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))
kevman 0:38ceb79fef03 1433
kevman 0:38ceb79fef03 1434 #define CXA_GUARD_INIT_DONE (1 << 0)
kevman 0:38ceb79fef03 1435 #define CXA_GUARD_INIT_IN_PROGRESS (1 << 1)
kevman 0:38ceb79fef03 1436 #define CXA_GUARD_MASK (CXA_GUARD_INIT_DONE | CXA_GUARD_INIT_IN_PROGRESS)
kevman 0:38ceb79fef03 1437
kevman 0:38ceb79fef03 1438 extern "C" int __cxa_guard_acquire(int *guard_object_p)
kevman 0:38ceb79fef03 1439 {
kevman 0:38ceb79fef03 1440 uint8_t *guard_object = (uint8_t *)guard_object_p;
kevman 0:38ceb79fef03 1441 if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) {
kevman 0:38ceb79fef03 1442 return 0;
kevman 0:38ceb79fef03 1443 }
kevman 0:38ceb79fef03 1444 singleton_lock();
kevman 0:38ceb79fef03 1445 if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) {
kevman 0:38ceb79fef03 1446 singleton_unlock();
kevman 0:38ceb79fef03 1447 return 0;
kevman 0:38ceb79fef03 1448 }
kevman 0:38ceb79fef03 1449 MBED_ASSERT(0 == (*guard_object & CXA_GUARD_MASK));
kevman 0:38ceb79fef03 1450 *guard_object = *guard_object | CXA_GUARD_INIT_IN_PROGRESS;
kevman 0:38ceb79fef03 1451 return 1;
kevman 0:38ceb79fef03 1452 }
kevman 0:38ceb79fef03 1453
kevman 0:38ceb79fef03 1454 extern "C" void __cxa_guard_release(int *guard_object_p)
kevman 0:38ceb79fef03 1455 {
kevman 0:38ceb79fef03 1456 uint8_t *guard_object = (uint8_t *)guard_object_p;
kevman 0:38ceb79fef03 1457 MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK));
kevman 0:38ceb79fef03 1458 *guard_object = (*guard_object & ~CXA_GUARD_MASK) | CXA_GUARD_INIT_DONE;
kevman 0:38ceb79fef03 1459 singleton_unlock();
kevman 0:38ceb79fef03 1460 }
kevman 0:38ceb79fef03 1461
kevman 0:38ceb79fef03 1462 extern "C" void __cxa_guard_abort(int *guard_object_p)
kevman 0:38ceb79fef03 1463 {
kevman 0:38ceb79fef03 1464 uint8_t *guard_object = (uint8_t *)guard_object_p;
kevman 0:38ceb79fef03 1465 MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK));
kevman 0:38ceb79fef03 1466 *guard_object = *guard_object & ~CXA_GUARD_INIT_IN_PROGRESS;
kevman 0:38ceb79fef03 1467 singleton_unlock();
kevman 0:38ceb79fef03 1468 }
kevman 0:38ceb79fef03 1469
kevman 0:38ceb79fef03 1470 #endif
kevman 0:38ceb79fef03 1471
kevman 0:38ceb79fef03 1472 #if MBED_MEM_TRACING_ENABLED && (defined(__CC_ARM) || defined(__ICCARM__) || (defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)))
kevman 0:38ceb79fef03 1473
kevman 0:38ceb79fef03 1474 // If the memory tracing is enabled, the wrappers in mbed_alloc_wrappers.cpp
kevman 0:38ceb79fef03 1475 // provide the implementation for these. Note: this needs to use the wrappers
kevman 0:38ceb79fef03 1476 // instead of malloc()/free() as the caller address would point to wrappers,
kevman 0:38ceb79fef03 1477 // not the caller of "new" or "delete".
kevman 0:38ceb79fef03 1478 extern "C" void *malloc_wrapper(size_t size, const void *caller);
kevman 0:38ceb79fef03 1479 extern "C" void free_wrapper(void *ptr, const void *caller);
kevman 0:38ceb79fef03 1480
kevman 0:38ceb79fef03 1481 void *operator new (std::size_t count)
kevman 0:38ceb79fef03 1482 {
kevman 0:38ceb79fef03 1483 void *buffer = malloc_wrapper(count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1484 if (NULL == buffer) {
kevman 0:38ceb79fef03 1485 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
kevman 0:38ceb79fef03 1486 }
kevman 0:38ceb79fef03 1487 return buffer;
kevman 0:38ceb79fef03 1488 }
kevman 0:38ceb79fef03 1489
kevman 0:38ceb79fef03 1490 void *operator new[](std::size_t count)
kevman 0:38ceb79fef03 1491 {
kevman 0:38ceb79fef03 1492 void *buffer = malloc_wrapper(count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1493 if (NULL == buffer) {
kevman 0:38ceb79fef03 1494 error("Operator new[] out of memory\r\n");
kevman 0:38ceb79fef03 1495 }
kevman 0:38ceb79fef03 1496 return buffer;
kevman 0:38ceb79fef03 1497 }
kevman 0:38ceb79fef03 1498
kevman 0:38ceb79fef03 1499 void *operator new (std::size_t count, const std::nothrow_t &tag)
kevman 0:38ceb79fef03 1500 {
kevman 0:38ceb79fef03 1501 return malloc_wrapper(count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1502 }
kevman 0:38ceb79fef03 1503
kevman 0:38ceb79fef03 1504 void *operator new[](std::size_t count, const std::nothrow_t &tag)
kevman 0:38ceb79fef03 1505 {
kevman 0:38ceb79fef03 1506 return malloc_wrapper(count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1507 }
kevman 0:38ceb79fef03 1508
kevman 0:38ceb79fef03 1509 void operator delete (void *ptr)
kevman 0:38ceb79fef03 1510 {
kevman 0:38ceb79fef03 1511 free_wrapper(ptr, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1512 }
kevman 0:38ceb79fef03 1513 void operator delete[](void *ptr)
kevman 0:38ceb79fef03 1514 {
kevman 0:38ceb79fef03 1515 free_wrapper(ptr, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1516 }
kevman 0:38ceb79fef03 1517
kevman 0:38ceb79fef03 1518 #elif MBED_MEM_TRACING_ENABLED && defined(__GNUC__)
kevman 0:38ceb79fef03 1519
kevman 0:38ceb79fef03 1520 #include <reent.h>
kevman 0:38ceb79fef03 1521
kevman 0:38ceb79fef03 1522 extern "C" void *malloc_wrapper(struct _reent *r, size_t size, void *caller);
kevman 0:38ceb79fef03 1523 extern "C" void free_wrapper(struct _reent *r, void *ptr, void *caller);
kevman 0:38ceb79fef03 1524
kevman 0:38ceb79fef03 1525 void *operator new (std::size_t count)
kevman 0:38ceb79fef03 1526 {
kevman 0:38ceb79fef03 1527 void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1528 if (NULL == buffer) {
kevman 0:38ceb79fef03 1529 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
kevman 0:38ceb79fef03 1530 }
kevman 0:38ceb79fef03 1531 return buffer;
kevman 0:38ceb79fef03 1532 }
kevman 0:38ceb79fef03 1533
kevman 0:38ceb79fef03 1534 void *operator new[](std::size_t count)
kevman 0:38ceb79fef03 1535 {
kevman 0:38ceb79fef03 1536 void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1537 if (NULL == buffer) {
kevman 0:38ceb79fef03 1538 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
kevman 0:38ceb79fef03 1539 }
kevman 0:38ceb79fef03 1540 return buffer;
kevman 0:38ceb79fef03 1541 }
kevman 0:38ceb79fef03 1542
kevman 0:38ceb79fef03 1543 void *operator new (std::size_t count, const std::nothrow_t &tag)
kevman 0:38ceb79fef03 1544 {
kevman 0:38ceb79fef03 1545 return malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1546 }
kevman 0:38ceb79fef03 1547
kevman 0:38ceb79fef03 1548 void *operator new[](std::size_t count, const std::nothrow_t &tag)
kevman 0:38ceb79fef03 1549 {
kevman 0:38ceb79fef03 1550 return malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1551 }
kevman 0:38ceb79fef03 1552
kevman 0:38ceb79fef03 1553 void operator delete (void *ptr)
kevman 0:38ceb79fef03 1554 {
kevman 0:38ceb79fef03 1555 free_wrapper(_REENT, ptr, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1556 }
kevman 0:38ceb79fef03 1557
kevman 0:38ceb79fef03 1558 void operator delete[](void *ptr)
kevman 0:38ceb79fef03 1559 {
kevman 0:38ceb79fef03 1560 free_wrapper(_REENT, ptr, MBED_CALLER_ADDR());
kevman 0:38ceb79fef03 1561 }
kevman 0:38ceb79fef03 1562
kevman 0:38ceb79fef03 1563 #else
kevman 0:38ceb79fef03 1564
kevman 0:38ceb79fef03 1565 void *operator new (std::size_t count)
kevman 0:38ceb79fef03 1566 {
kevman 0:38ceb79fef03 1567 void *buffer = malloc(count);
kevman 0:38ceb79fef03 1568 if (NULL == buffer) {
kevman 0:38ceb79fef03 1569 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
kevman 0:38ceb79fef03 1570 }
kevman 0:38ceb79fef03 1571 return buffer;
kevman 0:38ceb79fef03 1572 }
kevman 0:38ceb79fef03 1573
kevman 0:38ceb79fef03 1574 void *operator new[](std::size_t count)
kevman 0:38ceb79fef03 1575 {
kevman 0:38ceb79fef03 1576 void *buffer = malloc(count);
kevman 0:38ceb79fef03 1577 if (NULL == buffer) {
kevman 0:38ceb79fef03 1578 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new[] out of memory\r\n", count);
kevman 0:38ceb79fef03 1579 }
kevman 0:38ceb79fef03 1580 return buffer;
kevman 0:38ceb79fef03 1581 }
kevman 0:38ceb79fef03 1582
kevman 0:38ceb79fef03 1583 void *operator new (std::size_t count, const std::nothrow_t &tag)
kevman 0:38ceb79fef03 1584 {
kevman 0:38ceb79fef03 1585 return malloc(count);
kevman 0:38ceb79fef03 1586 }
kevman 0:38ceb79fef03 1587
kevman 0:38ceb79fef03 1588 void *operator new[](std::size_t count, const std::nothrow_t &tag)
kevman 0:38ceb79fef03 1589 {
kevman 0:38ceb79fef03 1590 return malloc(count);
kevman 0:38ceb79fef03 1591 }
kevman 0:38ceb79fef03 1592
kevman 0:38ceb79fef03 1593 void operator delete (void *ptr)
kevman 0:38ceb79fef03 1594 {
kevman 0:38ceb79fef03 1595 free(ptr);
kevman 0:38ceb79fef03 1596 }
kevman 0:38ceb79fef03 1597 void operator delete[](void *ptr)
kevman 0:38ceb79fef03 1598 {
kevman 0:38ceb79fef03 1599 free(ptr);
kevman 0:38ceb79fef03 1600 }
kevman 0:38ceb79fef03 1601
kevman 0:38ceb79fef03 1602 #endif
kevman 0:38ceb79fef03 1603
kevman 0:38ceb79fef03 1604 /* @brief standard c library clock() function.
kevman 0:38ceb79fef03 1605 *
kevman 0:38ceb79fef03 1606 * This function returns the number of clock ticks elapsed since the start of the program.
kevman 0:38ceb79fef03 1607 *
kevman 0:38ceb79fef03 1608 * @note Synchronization level: Thread safe
kevman 0:38ceb79fef03 1609 *
kevman 0:38ceb79fef03 1610 * @return
kevman 0:38ceb79fef03 1611 * the number of clock ticks elapsed since the start of the program.
kevman 0:38ceb79fef03 1612 *
kevman 0:38ceb79fef03 1613 * */
kevman 0:38ceb79fef03 1614 extern "C" clock_t clock()
kevman 0:38ceb79fef03 1615 {
kevman 0:38ceb79fef03 1616 _mutex->lock();
kevman 0:38ceb79fef03 1617 clock_t t = ticker_read(get_us_ticker_data());
kevman 0:38ceb79fef03 1618 t /= 1000000 / CLOCKS_PER_SEC; // convert to processor time
kevman 0:38ceb79fef03 1619 _mutex->unlock();
kevman 0:38ceb79fef03 1620 return t;
kevman 0:38ceb79fef03 1621 }
kevman 0:38ceb79fef03 1622
kevman 0:38ceb79fef03 1623 // temporary - Default to 1MHz at 32 bits if target does not have us_ticker_get_info
kevman 0:38ceb79fef03 1624 MBED_WEAK const ticker_info_t *us_ticker_get_info()
kevman 0:38ceb79fef03 1625 {
kevman 0:38ceb79fef03 1626 static const ticker_info_t info = {
kevman 0:38ceb79fef03 1627 1000000,
kevman 0:38ceb79fef03 1628 32
kevman 0:38ceb79fef03 1629 };
kevman 0:38ceb79fef03 1630 return &info;
kevman 0:38ceb79fef03 1631 }
kevman 0:38ceb79fef03 1632
kevman 0:38ceb79fef03 1633 // temporary - Default to 1MHz at 32 bits if target does not have lp_ticker_get_info
kevman 0:38ceb79fef03 1634 MBED_WEAK const ticker_info_t *lp_ticker_get_info()
kevman 0:38ceb79fef03 1635 {
kevman 0:38ceb79fef03 1636 static const ticker_info_t info = {
kevman 0:38ceb79fef03 1637 1000000,
kevman 0:38ceb79fef03 1638 32
kevman 0:38ceb79fef03 1639 };
kevman 0:38ceb79fef03 1640 return &info;
kevman 0:38ceb79fef03 1641 }