Keil Studio Cloud
Mistake on this page?
Report an issue in GitHub or email us
mbed_error.h
1 /* mbed Microcontroller Library
2  * Copyright (c) 2006-2019 ARM Limited
3  * SPDX-License-Identifier: Apache-2.0
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 #ifndef MBED_ERROR_H
18 #define MBED_ERROR_H
19 
20 #include <stdbool.h>
21 #include "platform/mbed_retarget.h"
22 #include "platform/mbed_toolchain.h"
23 
24 #ifdef __cplusplus
25 extern "C" {
26 #endif
27 
28 /** \addtogroup platform-public-api */
29 /** @{*/
30 
31 /**
32  * \defgroup platform_error Error functions
33  * @{
34  */
35 
36 /** Define this macro to include filenames in error context. For release builds, do not include filename to save memory.
37  * MBED_PLATFORM_CONF_ERROR_FILENAME_CAPTURE_ENABLED
38  */
39 
40 /** Define this macro to enable error history
41  * MBED_PLATFORM_CONF_ERROR_HIST_ENABLED
42  */
43 
44 #ifndef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
45 #define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 16
46 #else //MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
47 #if MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN > 64
48 //We have to limit this to 64 bytes since we use mbed_error_printf for error reporting
49 //and mbed_error_vprintf uses 128bytes internal buffer which may not be sufficient for anything
50 //longer that 64 bytes with the current implementation.
51 #error "Unsupported error filename buffer length detected, max supported length is 64 chars. Please change MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN or max-error-filename-len in configuration."
52 #endif
53 #endif
54 
55 #define MBED_ERROR_STATUS_CODE_MASK (0x0000FFFF)
56 #define MBED_ERROR_STATUS_CODE_UNSHIFTED_MASK (0x0000FFFF)
57 #define MBED_ERROR_STATUS_CODE_POS (0)
58 #define MBED_ERROR_STATUS_CODE_FIELD_SIZE (16)
59 
60 #define MBED_ERROR_STATUS_MODULE_MASK (0x00FF0000)
61 #define MBED_ERROR_STATUS_MODULE_UNSHIFTED_MASK (0x000000FF)
62 #define MBED_ERROR_STATUS_MODULE_POS (16)
63 #define MBED_ERROR_STATUS_MODULE_FIELD_SIZE (8)
64 
65 #define MBED_ERROR_STATUS_TYPE_MASK (0x60000000)
66 #define MBED_ERROR_STATUS_TYPE_UNSHIFTED_MASK (0x00000003)
67 #define MBED_ERROR_STATUS_TYPE_POS (29)
68 #define MBED_ERROR_STATUS_TYPE_FIELD_SIZE (2)
69 
70 /* mbed_error_status_t Status Encoding */
71 //|31(1 bit) Always Negative|30-29(2 bits) |28-24 | 23-16(8 bits) | 15-0(16 bits) |
72 //|-1 |TYPE |(unused/reserved) | MODULE TYPE | ERROR CODE |
73 
74 #define MAKE_MBED_ERROR(type, module, error_code) (mbed_error_status_t) \
75  ((0x80000000) | \
76  ((mbed_error_status_t) (error_code & MBED_ERROR_STATUS_CODE_UNSHIFTED_MASK) << MBED_ERROR_STATUS_CODE_POS) | \
77  ((mbed_error_status_t) (module & MBED_ERROR_STATUS_MODULE_UNSHIFTED_MASK) << MBED_ERROR_STATUS_MODULE_POS) | \
78  ((mbed_error_status_t) (type & MBED_ERROR_STATUS_TYPE_UNSHIFTED_MASK) << MBED_ERROR_STATUS_TYPE_POS))
79 
80 #define MBED_GET_ERROR_TYPE( error_status ) ((error_status & MBED_ERROR_STATUS_TYPE_MASK) >> MBED_ERROR_STATUS_TYPE_POS)
81 #define MBED_GET_ERROR_MODULE( error_status ) ((error_status & MBED_ERROR_STATUS_MODULE_MASK) >> MBED_ERROR_STATUS_MODULE_POS)
82 #define MBED_GET_ERROR_CODE( error_status ) (int)((MBED_GET_ERROR_TYPE( error_status ) == MBED_ERROR_TYPE_POSIX)?(-error_status):((error_status & MBED_ERROR_STATUS_CODE_MASK) >> MBED_ERROR_STATUS_CODE_POS))
83 
84 /** mbed_error_status_t description
85  *
86  * mbed_error_status_t type represents the error status values under MbedOS. mbed_error_status_t values are signed integers and always be negative.\n
87  * Internally its encoded as below with bit-fields representing error type, module and error code:\n\n
88  * mbed_error_status_t Status Encoding:\n
89  *
90  \verbatim
91  | 31 Always Negative | 30-29(2 bits) | 28-24 | 23-16(8 bits) | 15-0(16 bits) |
92  | -1 | TYPE | (unused/reserved) | MODULE TYPE | ERROR CODE |
93  \endverbatim
94  *
95  * The error status value range for each error type is as follows:\n
96  * POSIX Error Status-es - 0xFFFFFFFF to 0xFFFFFF01(-1 -255) - This corresponds to POSIX error codes represented as negative.\n
97  * System Error Status-es - 0x80XX0100 to 0x80XX0FFF - This corresponds to System error codes range(all values are negative). Bits 23-16 will be module type(marked with XX)\n
98  * Custom Error Status-es - 0xA0XX1000 to 0xA0XXFFFF - This corresponds to Custom error codes range(all values are negative). Bits 23-16 will be module type(marked with XX)\n\n
99  *
100  * The ERROR CODE(values encoded into ERROR CODE bit-field in mbed_error_status_t) value range for each error type is also separated as below:\n
101  * POSIX Error Codes - 1 to 255.\n
102  * System Error Codes - 256 to 4095.\n
103  * Custom Error Codes - 4096 to 65535.\n
104  *
105  * @note POSIX error codes are always encoded as negative of their actual value. For example, EPERM is encoded as -EPERM.
106  * And, the MODULE TYPE for POSIX error codes are always encoded as MBED_MODULE_UNKNOWN.\n
107  * This is to enable easy injection of POSIX error codes into MbedOS error handling system without altering the actual POSIX error values.\n
108  * Accordingly, POSIX error codes are represented as -1 to -255 under MbedOS error status representation.
109  */
110 typedef int mbed_error_status_t;
111 
112 /**
113  * Macro for defining a POSIX error status. This macro is mainly used to define POSIX error values in mbed_error_code_t enumeration.
114  * @param error_name Name of the error without the ERROR_ prefix
115  * @param error_code Error code value to be used, must be between 1 and 255(inclusive).
116  *
117  */
118 #define MBED_DEFINE_POSIX_ERROR( error_name, error_code ) \
119  MBED_ERROR_CODE_##error_name = error_code, \
120  MBED_ERROR_##error_name = -(MBED_POSIX_ERROR_BASE + error_code)
121 
122 /**
123  * Macro for defining a System error status. This macro is used to define System error values in mbed_error_code_t enumeration.
124  * @param error_name Name of the error without the ERROR_ prefix
125  * @param error_code Error code value to be used, must be between 256 and 4096(inclusive).
126  *
127  */
128 #define MBED_DEFINE_SYSTEM_ERROR( error_name, error_code ) \
129  MBED_ERROR_CODE_##error_name = MBED_SYSTEM_ERROR_BASE + error_code, \
130  MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
131 
132 /**
133  * Macro for defining a Custom error status. This macro is used to define custom error values in mbed_error_code_t enumeration.
134  * @param error_name Name of the error without the ERROR_ prefix
135  * @param error_code Error code value to be used, must be between 4097 and 65535(inclusive).
136  *
137  */
138 #define MBED_DEFINE_CUSTOM_ERROR( error_name, error_code ) \
139  MBED_ERROR_CODE_##error_name = MBED_CUSTOM_ERROR_BASE + error_code, \
140  MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
141 
142 
143 /**
144  * Macros for setting a system warning. These macros will log the error, Its a wrapper for calling mbed_warning API.
145  * There are 2 versions of this macro. MBED_WARNING takes status and message. MBED_WARNING1 takes an additional context specific argument
146  * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
147  * @param error_msg The error message to be printed out to STDIO/Serial.
148  * @param error_value Value associated with the error status. This would depend on error code/error scenario.
149  *
150  * @code
151  *
152  * MBED_WARNING( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read" )
153  * MBED_WARNING1( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read", size_val )
154  *
155  * @endcode
156  * @note The macro calls mbed_warning API with filename and line number info without caller explicitly passing them.
157  * Since this macro is a wrapper for mbed_warning API callers should process the return value from this macro which is the return value from calling mbed_error API.
158  *
159  */
160 #ifdef NDEBUG
161 #define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 )
162 #define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)NULL, (uint32_t)0, NULL, 0 )
163 #else //NDEBUG
164 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
165 #define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, (const char *)MBED_FILENAME, __LINE__ )
166 #define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)0 , (const char *)MBED_FILENAME, __LINE__ )
167 #else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
168 #define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 )
169 #define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)0, NULL, 0 )
170 #endif
171 #endif
172 
173 /**
174  * Macros for setting a fatal system error. These macros will log the error, prints the error report and halts the system. Its a wrapper for calling mbed_error API.
175  * There are 2 versions of this macro. MBED_ERROR takes status and message. MBED_ERROR1 takes an additional context specific argument
176  * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
177  * @param error_msg The error message to be printed out to STDIO/Serial.
178  * @param error_value Value associated with the error status. This would depend on error code/error scenario. Only available with MBED_ERROR1
179  * @return Does not return
180  *
181  * @code
182  *
183  * MBED_ERROR( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex" )
184  * MBED_ERROR1( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex", &my_mutex )
185  *
186  * @endcode
187  * @note The macro calls mbed_error API with filename and line number info without caller explicitly passing them.
188  * Since this macro is a wrapper for mbed_error API callers should process the return value from this macro which is the return value from calling mbed_error API.
189  *
190  */
191 #ifdef NDEBUG
192 #define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 )
193 #define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)NULL, (uint32_t)0 , NULL, 0 )
194 #else //NDEBUG
195 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
196 #define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, (const char *)MBED_FILENAME, __LINE__ )
197 #define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)error_msg, (uint32_t)0 , (const char *)MBED_FILENAME, __LINE__ )
198 #else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED
199 #define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 )
200 #define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)error_msg, (uint32_t)0 , NULL, 0 )
201 #endif
202 #endif
203 
204 //Error Type definition
205 /** mbed_error_type_t definition
206  * @note
207  * This enumeration defines the Error types supported. The value of these enum values will be encoded into mbed_error_status_t TYPE field.\n
208  * See mbed_error_status_t description for more info.\n
209  * MBED_ERROR_TYPE_SYSTEM - Used to indicate that the error status is of System defined Error type.\n
210  * MBED_ERROR_TYPE_CUSTOM - Used to indicate that the error status is of Custom defined Error type.\n
211  * MBED_ERROR_TYPE_POSIX - Used to indicate that the error status is of POSIX error type.\n
212  *
213  */
214 typedef enum _mbed_error_type_t {
215  MBED_ERROR_TYPE_SYSTEM = 0,
216  MBED_ERROR_TYPE_CUSTOM = 1,
217  //2 is reserved
218  //Use 3 for POSIX because we are mapping -1 to -255 to POSIX error codes
219  //and thus we must use 3 to match the type bits in error status representation which are from 0xFFFFFFFF to 0xFFFFFF00
220  MBED_ERROR_TYPE_POSIX = 3
221 } mbed_error_type_t;
222 
223 //Module type/id definitions
224 /** mbed_module_type_t definition
225  * @note
226  * This enumeration defines the module types. The value of these enum values will be encoded into mbed_error_status_t MODULE field.\n\n
227  * See mbed_error_status_t description for more info.\n
228  * MBED_MODULE_UNKNOWN - This module type can be used if caller of the mbed_error/mbed_warning doesn't know who is the actual originator of the error.\n
229  * Other module values can be used to provide more info on who/where the error originated from.\n\n
230  * For example, if I2C driver is the component originating the error you can use MBED_MODULE_DRIVER_I2C to provide more info.\n
231  * Its used in call to MBED_MAKE_ERROR/MBED_MAKE_SYSTEM_ERROR/MBED_MAKE_CUSTOM_ERROR macros.\n
232  *
233  * @code
234  * Example: mbed_error_status_t i2c_driver_error = MBED_MAKE_ERROR( MBED_MODULE_DRIVER_I2C, MBED_ERROR_CONFIG_UNSUPPORTED );
235  * @endcode
236  *
237  * @note
238  * \n Below are the module code mappings:\n
239  \verbatim
240  MBED_MODULE_APPLICATION 0 Application
241  MBED_MODULE_PLATFORM 1 Platform
242  MBED_MODULE_KERNEL 2 RTX Kernel
243  MBED_MODULE_NETWORK_STACK 3 Network stack
244  MBED_MODULE_HAL 4 HAL - Hardware Abstraction Layer
245  MBED_MODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem
246  MBED_MODULE_FILESYSTEM 6 Filesystem
247  MBED_MODULE_BLOCK_DEVICE 7 Block device
248  MBED_MODULE_DRIVER 8 Driver
249  MBED_MODULE_DRIVER_SERIAL 9 Serial Driver
250  MBED_MODULE_DRIVER_RTC 10 RTC Driver
251  MBED_MODULE_DRIVER_I2C 11 I2C Driver
252  MBED_MODULE_DRIVER_SPI 12 SPI Driver
253  MBED_MODULE_DRIVER_GPIO 13 GPIO Driver
254  MBED_MODULE_DRIVER_ANALOG 14 Analog Driver
255  MBED_MODULE_DRIVER_DIGITAL 15 DigitalIO Driver
256  MBED_MODULE_DRIVER_CAN 16 CAN Driver
257  MBED_MODULE_DRIVER_ETHERNET 17 Ethernet Driver
258  MBED_MODULE_DRIVER_CRC 18 CRC Module
259  MBED_MODULE_DRIVER_PWM 19 PWM Driver
260  MBED_MODULE_DRIVER_QSPI 20 QSPI Driver
261  MBED_MODULE_DRIVER_USB 21 USB Driver
262  MBED_MODULE_TARGET_SDK 22 SDK
263  MBED_MODULE_BLE 23 BLE
264  MBED_MODULE_NETWORK_STATS 24 Network Statistics
265 
266  MBED_MODULE_UNKNOWN 255 Unknown module
267  \endverbatim
268  *
269  */
270 typedef enum _mbed_module_type {
271  MBED_MODULE_APPLICATION = 0,
272  MBED_MODULE_PLATFORM,
273  MBED_MODULE_KERNEL,
274  MBED_MODULE_NETWORK_STACK,
275  MBED_MODULE_HAL,
276  MBED_MODULE_MEMORY_SUBSYSTEM,
277  MBED_MODULE_FILESYSTEM,
278  MBED_MODULE_BLOCK_DEVICE,
279  MBED_MODULE_DRIVER,
280  MBED_MODULE_DRIVER_SERIAL,
281  MBED_MODULE_DRIVER_RTC,
282  MBED_MODULE_DRIVER_I2C,
283  MBED_MODULE_DRIVER_SPI,
284  MBED_MODULE_DRIVER_GPIO,
285  MBED_MODULE_DRIVER_ANALOG,
286  MBED_MODULE_DRIVER_DIGITAL,
287  MBED_MODULE_DRIVER_CAN,
288  MBED_MODULE_DRIVER_ETHERNET,
289  MBED_MODULE_DRIVER_CRC,
290  MBED_MODULE_DRIVER_PWM,
291  MBED_MODULE_DRIVER_QSPI,
292  MBED_MODULE_DRIVER_USB,
293  MBED_MODULE_DRIVER_WATCHDOG,
294  MBED_MODULE_TARGET_SDK,
295  MBED_MODULE_BLE,
296  MBED_MODULE_NETWORK_STATS,
297  /* Add More entities here as required */
298 
299  MBED_MODULE_UNKNOWN = 255,
300  MBED_MODULE_MAX = MBED_MODULE_UNKNOWN
301 } mbed_module_type_t;
302 
303 //Use MBED_SUCCESS(=0) or any positive number for successful returns
304 #define MBED_SUCCESS 0
305 
306 #define MBED_POSIX_ERROR_BASE 0
307 #define MBED_SYSTEM_ERROR_BASE 256
308 #define MBED_CUSTOM_ERROR_BASE 4096
309 
310 //Error Code definitions
311 /** mbed_error_code_t definition
312  *
313  * mbed_error_code_t enumeration defines the Error codes and Error status values for MBED_MODULE_UNKNOWN.\n
314  * It defines all of POSIX Error Codes/Statuses and Mbed System Error Codes/Statuses.\n\n
315  *
316  * @note
317  * POSIX Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n
318  * For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This effectively defines the following values:\n
319  * ERROR_CODE_EPERM = EPERM\n
320  * ERROR_EPERM = -EPERM\n
321  *
322  * POSIX Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n
323  * For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This macro defines the following values:\n
324  * ERROR_CODE_EPERM = MBED_POSIX_ERROR_BASE+EPERM\n
325  * ERROR_EPERM = -(MBED_POSIX_ERROR_BASE+EPERM)\n
326  * Its effectively equivalent to:\n
327  * ERROR_CODE_EPERM = 1\n
328  * ERROR_EPERM = -1\n
329  * All POSIX error codes currently supported by MbedOS(defined in mbed_retarget.h) are defined using the MBED_DEFINE_POSIX_ERROR macro.\n\n
330  * Below are the POSIX error codes and the description:\n
331  * \verbatim
332  EPERM 1 Operation not permitted
333  ENOENT 2 No such file or directory
334  ESRCH 3 No such process
335  EINTR 4 Interrupted system call
336  EIO 5 I/O error
337  ENXIO 6 No such device or address
338  E2BIG 7 Argument list too long
339  ENOEXEC 8 Exec format error
340  EBADF 9 Bad file number
341  ECHILD 10 No child processes
342  EAGAIN 11 Try again
343  ENOMEM 12 Out of memory
344  EACCES 13 Permission denied
345  EFAULT 14 Bad address
346  ENOTBLK 15 Block device required
347  EBUSY 16 Device or resource busy
348  EEXIST 17 File exists
349  EXDEV 18 Cross-device link
350  ENODEV 19 No such device
351  ENOTDIR 20 Not a directory
352  EISDIR 21 Is a directory
353  EINVAL 22 Invalid argument
354  ENFILE 23 File table overflow
355  EMFILE 24 Too many open files
356  ENOTTY 25 Not a typewriter
357  ETXTBSY 26 Text file busy
358  EFBIG 27 File too large
359  ENOSPC 28 No space left on device
360  ESPIPE 29 Illegal seek
361  EROFS 30 Read-only file system
362  EMLINK 31 Too many links
363  EPIPE 32 Broken pipe
364  EDOM 33 Math argument out of domain of func
365  ERANGE 34 Math result not representable
366  EDEADLK 35 Resource deadlock would occur
367  ENAMETOOLONG 36 File name too long
368  ENOLCK 37 No record locks available
369  ENOSYS 38 Function not implemented
370  ENOTEMPTY 39 Directory not empty
371  ELOOP 40 Too many symbolic links encountered
372  EWOULDBLOCK EAGAIN Operation would block
373  ENOMSG 42 No message of desired type
374  EIDRM 43 Identifier removed
375  ECHRNG 44 Channel number out of range
376  EL2NSYNC 45 Level 2 not synchronized
377  EL3HLT 46 Level 3 halted
378  EL3RST 47 Level 3 reset
379  ELNRNG 48 Link number out of range
380  EUNATCH 49 Protocol driver not attached
381  ENOCSI 50 No CSI structure available
382  EL2HLT 51 Level 2 halted
383  EBADE 52 Invalid exchange
384  EBADR 53 Invalid request descriptor
385  EXFULL 54 Exchange full
386  ENOANO 55 No anode
387  EBADRQC 56 Invalid request code
388  EBADSLT 57 Invalid slot
389  EDEADLOCK EDEADLK Resource deadlock would occur
390  EBFONT 59 Bad font file format
391  ENOSTR 60 Device not a stream
392  ENODATA 61 No data available
393  ETIME 62 Timer expired
394  ENOSR 63 Out of streams resources
395  ENONET 64 Machine is not on the network
396  ENOPKG 65 Package not installed
397  EREMOTE 66 Object is remote
398  ENOLINK 67 Link has been severed
399  EADV 68 Advertise error
400  ESRMNT 69 Srmount error
401  ECOMM 70 Communication error on send
402  EPROTO 71 Protocol error
403  EMULTIHOP 72 Multihop attempted
404  EDOTDOT 73 RFS specific error
405  EBADMSG 74 Not a data message
406  EOVERFLOW 75 Value too large for defined data type
407  ENOTUNIQ 76 Name not unique on network
408  EBADFD 77 File descriptor in bad state
409  EREMCHG 78 Remote address changed
410  ELIBACC 79 Can not access a needed shared library
411  ELIBBAD 80 Accessing a corrupted shared library
412  ELIBSCN 81 .lib section in a.out corrupted
413  ELIBMAX 82 Attempting to link in too many shared libraries
414  ELIBEXEC 83 Cannot exec a shared library directly
415  EILSEQ 84 Illegal byte sequence
416  ERESTART 85 Interrupted system call should be restarted
417  ESTRPIPE 86 Streams pipe error
418  EUSERS 87 Too many users
419  ENOTSOCK 88 Socket operation on non-socket
420  EDESTADDRREQ 89 Destination address required
421  EMSGSIZE 90 Message too long
422  EPROTOTYPE 91 Protocol wrong type for socket
423  ENOPROTOOPT 92 Protocol not available
424  EPROTONOSUPPORT 93 Protocol not supported
425  ESOCKTNOSUPPORT 94 Socket type not supported
426  EOPNOTSUPP 95 Operation not supported on transport endpoint
427  EPFNOSUPPORT 96 Protocol family not supported
428  EAFNOSUPPORT 97 Address family not supported by protocol
429  EADDRINUSE 98 Address already in use
430  EADDRNOTAVAIL 99 Cannot assign requested address
431  ENETDOWN 100 Network is down
432  ENETUNREACH 101 Network is unreachable
433  ENETRESET 102 Network dropped connection because of reset
434  ECONNABORTED 103 Software caused connection abort
435  ECONNRESET 104 Connection reset by peer
436  ENOBUFS 105 No buffer space available
437  EISCONN 106 Transport endpoint is already connected
438  ENOTCONN 107 Transport endpoint is not connected
439  ESHUTDOWN 108 Cannot send after transport endpoint shutdown
440  ETOOMANYREFS 109 Too many references: cannot splice
441  ETIMEDOUT 110 Connection timed out
442  ECONNREFUSED 111 Connection refused
443  EHOSTDOWN 112 Host is down
444  EHOSTUNREACH 113 No route to host
445  EALREADY 114 Operation already in progress
446  EINPROGRESS 115 Operation now in progress
447  ESTALE 116 Stale NFS file handle
448  EUCLEAN 117 Structure needs cleaning
449  ENOTNAM 118 Not a XENIX named type file
450  ENAVAIL 119 No XENIX semaphores available
451  EISNAM 120 Is a named type file
452  EREMOTEIO 121 Remote I/O error
453  EDQUOT 122 Quota exceeded
454  ENOMEDIUM 123 No medium found
455  EMEDIUMTYPE 124 Wrong medium type
456  ECANCELED 125 Operation Canceled
457  ENOKEY 126 Required key not available
458  EKEYEXPIRED 127 Key has expired
459  EKEYREVOKED 128 Key has been revoked
460  EKEYREJECTED 129 Key was rejected by service
461  EOWNERDEAD 130 Owner died
462  ENOTRECOVERABLE 131 State not recoverable
463  \endverbatim
464  *
465  * @note
466  * MbedOS System Error codes are defined using the macro MBED_DEFINE_SYSTEM_ERROR\n
467  * For example MBED_DEFINE_SYSTEM_ERROR( INVALID_ARGUMENT ,1 ) macro defines the following values:\n
468  * ERROR_CODE_INVALID_ARGUMENT = MBED_SYSTEM_ERROR_BASE+1\n
469  * ERROR_INVALID_ARGUMENT = MAKE_MBED_ERROR(ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, ERROR_CODE_INVALID_ARGUMENT)\n
470  * Its effectively equivalent to:\n
471  * ERROR_CODE_INVALID_ARGUMENT = 1\n
472  * ERROR_INVALID_ARGUMENT = 0x80FF0001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN)
473  * New System Error codes should be defined using MBED_DEFINE_SYSTEM_ERROR macro and must have an unique error code value\n
474  * passed as the second argument in the MBED_DEFINE_SYSTEM_ERROR macro.\n\n
475  * Below are the Mbed System error codes and the description:
476  * \verbatim
477  UNKNOWN 256 Unknown error
478  INVALID_ARGUMENT 257 Invalid Argument
479  INVALID_DATA 258 Invalid data
480  INVALID_FORMAT 259 Invalid format
481  INVALID_INDEX 260 Invalid Index
482  INVALID_SIZE 261 Invalid Size
483  INVALID_OPERATION 262 Invalid Operation
484  NOT_FOUND 263 Not Found
485  ACCESS_DENIED 264 Access Denied
486  NOT_SUPPORTED 265 Not supported
487  BUFFER_FULL 266 Buffer Full
488  MEDIA_FULL 267 Media/Disk Full
489  ALREADY_IN_USE 268 Already in use
490  TIMEOUT 269 Timeout error
491  NOT_READY 270 Not Ready
492  FAILED_OPERATION 271 Requested Operation failed
493  OPERATION_PROHIBITED 272 Operation prohibited
494  OPERATION_ABORTED 273 Operation failed
495  WRITE_PROTECTED 274 Attempt to write to write-protected resource
496  NO_RESPONSE 275 No response
497  SEMAPHORE_LOCK_FAILED 276 Semaphore lock failed
498  MUTEX_LOCK_FAILED 277 Mutex lock failed
499  SEMAPHORE_UNLOCK_FAILED 278 Semaphore unlock failed
500  MUTEX_UNLOCK_FAILED 279 Mutex unlock failed
501  CRC_ERROR 280 CRC error or mismatch
502  OPEN_FAILED 281 Open failed
503  CLOSE_FAILED 282 Close failed
504  READ_FAILED 283 Read failed
505  WRITE_FAILED 284 Write failed
506  INITIALIZATION_FAILED 285 Initialization failed
507  BOOT_FAILURE 286 Boot failure
508  OUT_OF_MEMORY 287 Out of memory
509  OUT_OF_RESOURCES 288 Out of resources
510  ALLOC_FAILED 289 Alloc failed
511  FREE_FAILED 290 Free failed
512  OVERFLOW 291 Overflow error
513  UNDERFLOW 292 Underflow error
514  STACK_OVERFLOW 293 Stack overflow error
515  ISR_QUEUE_OVERFLOW 294 ISR queue overflow
516  TIMER_QUEUE_OVERFLOW 295 Timer Queue overflow
517  CLIB_SPACE_UNAVAILABLE 296 Standard library error - Space unavailable
518  CLIB_EXCEPTION 297 Standard library error - Exception
519  CLIB_MUTEX_INIT_FAILURE 298 Standard library error - Mutex Init failure
520  CREATE_FAILED 299 Create failed
521  DELETE_FAILED 300 Delete failed
522  THREAD_CREATE_FAILED 301 Thread Create failed
523  THREAD_DELETE_FAILED 302 Thread Delete failed
524  PROHIBITED_IN_ISR_CONTEXT 303 Operation Prohibited in ISR context
525  PINMAP_INVALID 304 Pinmap Invalid
526  RTOS_EVENT 305 Unknown Rtos Error
527  RTOS_THREAD_EVENT 306 Rtos Thread Error
528  RTOS_MUTEX_EVENT 307 Rtos Mutex Error
529  RTOS_SEMAPHORE_EVENT 308 Rtos Semaphore Error
530  RTOS_MEMORY_POOL_EVENT 309 Rtos Memory Pool Error
531  RTOS_TIMER_EVENT 310 Rtos Timer Error
532  RTOS_EVENT_FLAGS_EVENT 311 Rtos Event flags Error
533  RTOS_MESSAGE_QUEUE_EVENT 312 Rtos Message queue Error
534  DEVICE_BUSY 313 Device Busy
535  CONFIG_UNSUPPORTED 314 Configuration not supported
536  CONFIG_MISMATCH 315 Configuration mismatch
537  ALREADY_INITIALIZED 316 Already initialized
538  HARDFAULT_EXCEPTION 317 HardFault exception
539  MEMMANAGE_EXCEPTION 318 MemManage exception
540  BUSFAULT_EXCEPTION 319 BusFault exception
541  USAGEFAULT_EXCEPTION 320 UsageFault exception
542  BLE_NO_FRAME_INITIALIZED, 321 BLE No frame initialized
543  BLE_BACKEND_CREATION_FAILED 322 BLE Backend creation failed
544  BLE_BACKEND_NOT_INITIALIZED 323 BLE Backend not initialized
545  ASSERTION_FAILED 324 Assertion Failed
546  AUTHENTICATION_FAILED 325 Authentication Failed
547  RBP_AUTHENTICATION_FAILED 326 Rollback Protect Authentication Failed
548  \endverbatim
549  *
550  * @note
551  * Custom Error codes can be defined using the macro DEFINE_CUSTOM_ERROR\n
552  * This is mainly meant to capture non-generic error codes specific to a device.
553  * For example DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR ,1 ) macro defines the following values:\n
554  * ERROR_CODE_MY_CUSTOM_ERROR = MBED_CUSTOM_ERROR_BASE+1\n
555  * ERROR_MY_CUSTOM_ERROR = MAKE_MBED_ERROR(ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, ERROR_CODE_MY_CUSTOM_ERROR)\n
556  * Its effectively equivalent to:\n
557  * ERROR_CODE_MY_CUSTOM_ERROR = 4097\n
558  * ERROR_MY_CUSTOM_ERROR = 0xA0FF1001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN) \n\n
559  *
560  * @note
561  * **Using error codes:** \n
562  * POSIX error codes may be used in modules/functions currently using POSIX error codes and switching them to Mbed-OS error codes
563  * may cause interoperability issues. For example, some of the filesystem, network stack implementations may need to use
564  * POSIX error codes in order to keep them compatible with other modules interfacing with them, and may continue to use POSIX error codes.
565  *
566  * In all other cases, like for any native development of Mbed-OS modules Mbed-OS error codes should be used.
567  * This makes it easy to use Mbed-OS error reporting/logging infrastructure and makes debugging error scenarios
568  * much more efficient.
569  *
570  * @note
571  * **Searching for error codes in mbed-os source tree:** \n
572  * If you get an error report as below which you want to search for in mbed-os source tree, first take note of "Error Code" number. \n
573  * For example, the below error report has an error code of \b 259. Find the error name associated with the error code and in this case its \b INVALID_FORMAT. \n
574  * Use that error name(\b INVALID_FORMAT) to search the source tree for code locations setting that specific error code. \n
575  * If the Error module reported is not 255(which indicates unknown module), you can also use that to narrow down to the specific component reporting the error.
576  * See mbed_module_type_t enum above for module mapping. \n
577  *
578  * \verbatim
579  ++ MbedOS Error Info ++
580  Error Status: 0x80FF013D Code: 317 Module: 255
581  Error Message: Fault exception
582  Location: 0x5CD1
583  Error Value: 0x4A2A
584  Current Thread: Id: 0x20001E80 Entry: 0x5EB1 StackSize: 0x1000 StackMem: 0x20000E80 SP: 0x2002FF90
585  For more info, visit: https://mbed.com/s/error?error=0x80FF013D&mbedos=999999&core=0x410FC241&compile=1&ver=5060528
586  -- MbedOS Error Info --
587  \endverbatim
588  */
589 
590 typedef enum _mbed_error_code {
591  //Below are POSIX ERROR CODE definitions, which starts at MBED_POSIX_ERROR_BASE(=0)
592  //POSIX ERROR CODE definitions starts at offset 0(MBED_POSIX_ERROR_BASE) to align them with actual POSIX Error Code
593  //defintions in mbed_retarget.h
594  // Error Name Error Code
595  MBED_DEFINE_POSIX_ERROR(EPERM, EPERM), /* 1 Operation not permitted */
596  MBED_DEFINE_POSIX_ERROR(ENOENT, ENOENT), /* 2 No such file or directory */
597  MBED_DEFINE_POSIX_ERROR(ESRCH, ESRCH), /* 3 No such process */
598  MBED_DEFINE_POSIX_ERROR(EINTR, EINTR), /* 4 Interrupted system call */
599  MBED_DEFINE_POSIX_ERROR(EIO, EIO), /* 5 I/O error */
600  MBED_DEFINE_POSIX_ERROR(ENXIO, ENXIO), /* 6 No such device or address */
601  MBED_DEFINE_POSIX_ERROR(E2BIG, E2BIG), /* 7 Argument list too long */
602  MBED_DEFINE_POSIX_ERROR(ENOEXEC, ENOEXEC), /* 8 Exec format error */
603  MBED_DEFINE_POSIX_ERROR(EBADF, EBADF), /* 9 Bad file number */
604  MBED_DEFINE_POSIX_ERROR(ECHILD, ECHILD), /* 10 No child processes */
605  MBED_DEFINE_POSIX_ERROR(EAGAIN, EAGAIN), /* 11 Try again */
606  MBED_DEFINE_POSIX_ERROR(ENOMEM, ENOMEM), /* 12 Out of memory */
607  MBED_DEFINE_POSIX_ERROR(EACCES, EACCES), /* 13 Permission denied */
608  MBED_DEFINE_POSIX_ERROR(EFAULT, EFAULT), /* 14 Bad address */
609  MBED_DEFINE_POSIX_ERROR(ENOTBLK, ENOTBLK), /* 15 Block device required */
610  MBED_DEFINE_POSIX_ERROR(EBUSY, EBUSY), /* 16 Device or resource busy */
611  MBED_DEFINE_POSIX_ERROR(EEXIST, EEXIST), /* 17 File exists */
612  MBED_DEFINE_POSIX_ERROR(EXDEV, EXDEV), /* 18 Cross-device link */
613  MBED_DEFINE_POSIX_ERROR(ENODEV, ENODEV), /* 19 No such device */
614  MBED_DEFINE_POSIX_ERROR(ENOTDIR, ENOTDIR), /* 20 Not a directory */
615  MBED_DEFINE_POSIX_ERROR(EISDIR, EISDIR), /* 21 Is a directory */
616  MBED_DEFINE_POSIX_ERROR(EINVAL, EINVAL), /* 22 Invalid argument */
617  MBED_DEFINE_POSIX_ERROR(ENFILE, ENFILE), /* 23 File table overflow */
618  MBED_DEFINE_POSIX_ERROR(EMFILE, EMFILE), /* 24 Too many open files */
619  MBED_DEFINE_POSIX_ERROR(ENOTTY, ENOTTY), /* 25 Not a typewriter */
620  MBED_DEFINE_POSIX_ERROR(ETXTBSY, ETXTBSY), /* 26 Text file busy */
621  MBED_DEFINE_POSIX_ERROR(EFBIG, EFBIG), /* 27 File too large */
622  MBED_DEFINE_POSIX_ERROR(ENOSPC, ENOSPC), /* 28 No space left on device */
623  MBED_DEFINE_POSIX_ERROR(ESPIPE, ESPIPE), /* 29 Illegal seek */
624  MBED_DEFINE_POSIX_ERROR(EROFS, EROFS), /* 30 Read-only file system */
625  MBED_DEFINE_POSIX_ERROR(EMLINK, EMLINK), /* 31 Too many links */
626  MBED_DEFINE_POSIX_ERROR(EPIPE, EPIPE), /* 32 Broken pipe */
627  MBED_DEFINE_POSIX_ERROR(EDOM, EDOM), /* 33 Math argument out of domain of func */
628  MBED_DEFINE_POSIX_ERROR(ERANGE, ERANGE), /* 34 Math result not representable */
629  MBED_DEFINE_POSIX_ERROR(EDEADLK, EDEADLK), /* 35 Resource deadlock would occur */
630  MBED_DEFINE_POSIX_ERROR(ENAMETOOLONG, ENAMETOOLONG), /* 36 File name too long */
631  MBED_DEFINE_POSIX_ERROR(ENOLCK, ENOLCK), /* 37 No record locks available */
632  MBED_DEFINE_POSIX_ERROR(ENOSYS, ENOSYS), /* 38 Function not implemented */
633  MBED_DEFINE_POSIX_ERROR(ENOTEMPTY, ENOTEMPTY), /* 39 Directory not empty */
634  MBED_DEFINE_POSIX_ERROR(ELOOP, ELOOP), /* 40 Too many symbolic links encountered */
635  MBED_DEFINE_POSIX_ERROR(EWOULDBLOCK, EAGAIN), /* EAGAIN Operation would block */
636  MBED_DEFINE_POSIX_ERROR(ENOMSG, ENOMSG), /* 42 No message of desired type */
637  MBED_DEFINE_POSIX_ERROR(EIDRM, EIDRM), /* 43 Identifier removed */
638  MBED_DEFINE_POSIX_ERROR(ECHRNG, ECHRNG), /* 44 Channel number out of range */
639  MBED_DEFINE_POSIX_ERROR(EL2NSYNC, EL2NSYNC), /* 45 Level 2 not synchronized */
640  MBED_DEFINE_POSIX_ERROR(EL3HLT, EL3HLT), /* 46 Level 3 halted */
641  MBED_DEFINE_POSIX_ERROR(EL3RST, EL3RST), /* 47 Level 3 reset */
642  MBED_DEFINE_POSIX_ERROR(ELNRNG, ELNRNG), /* 48 Link number out of range */
643  MBED_DEFINE_POSIX_ERROR(EUNATCH, EUNATCH), /* 49 Protocol driver not attached */
644  MBED_DEFINE_POSIX_ERROR(ENOCSI, ENOCSI), /* 50 No CSI structure available */
645  MBED_DEFINE_POSIX_ERROR(EL2HLT, EL2HLT), /* 51 Level 2 halted */
646  MBED_DEFINE_POSIX_ERROR(EBADE, EBADE), /* 52 Invalid exchange */
647  MBED_DEFINE_POSIX_ERROR(EBADR, EBADR), /* 53 Invalid request descriptor */
648  MBED_DEFINE_POSIX_ERROR(EXFULL, EXFULL), /* 54 Exchange full */
649  MBED_DEFINE_POSIX_ERROR(ENOANO, ENOANO), /* 55 No anode */
650  MBED_DEFINE_POSIX_ERROR(EBADRQC, EBADRQC), /* 56 Invalid request code */
651  MBED_DEFINE_POSIX_ERROR(EBADSLT, EBADSLT), /* 57 Invalid slot */
652  MBED_DEFINE_POSIX_ERROR(EDEADLOCK, EDEADLK), /* EDEADLK Resource deadlock would occur */
653  MBED_DEFINE_POSIX_ERROR(EBFONT, EBFONT), /* 59 Bad font file format */
654  MBED_DEFINE_POSIX_ERROR(ENOSTR, ENOSTR), /* 60 Device not a stream */
655  MBED_DEFINE_POSIX_ERROR(ENODATA, ENODATA), /* 61 No data available */
656  MBED_DEFINE_POSIX_ERROR(ETIME, ETIME), /* 62 Timer expired */
657  MBED_DEFINE_POSIX_ERROR(ENOSR, ENOSR), /* 63 Out of streams resources */
658  MBED_DEFINE_POSIX_ERROR(ENONET, ENONET), /* 64 Machine is not on the network */
659  MBED_DEFINE_POSIX_ERROR(ENOPKG, ENOPKG), /* 65 Package not installed */
660  MBED_DEFINE_POSIX_ERROR(EREMOTE, EREMOTE), /* 66 Object is remote */
661  MBED_DEFINE_POSIX_ERROR(ENOLINK, ENOLINK), /* 67 Link has been severed */
662  MBED_DEFINE_POSIX_ERROR(EADV, EADV), /* 68 Advertise error */
663  MBED_DEFINE_POSIX_ERROR(ESRMNT, ESRMNT), /* 69 Srmount error */
664  MBED_DEFINE_POSIX_ERROR(ECOMM, ECOMM), /* 70 Communication error on send */
665  MBED_DEFINE_POSIX_ERROR(EPROTO, EPROTO), /* 71 Protocol error */
666  MBED_DEFINE_POSIX_ERROR(EMULTIHOP, EMULTIHOP), /* 72 Multihop attempted */
667  MBED_DEFINE_POSIX_ERROR(EDOTDOT, EDOTDOT), /* 73 RFS specific error */
668  MBED_DEFINE_POSIX_ERROR(EBADMSG, EBADMSG), /* 74 Not a data message */
669  MBED_DEFINE_POSIX_ERROR(EOVERFLOW, EOVERFLOW), /* 75 Value too large for defined data type */
670  MBED_DEFINE_POSIX_ERROR(ENOTUNIQ, ENOTUNIQ), /* 76 Name not unique on network */
671  MBED_DEFINE_POSIX_ERROR(EBADFD, EBADFD), /* 77 File descriptor in bad state */
672  MBED_DEFINE_POSIX_ERROR(EREMCHG, EREMCHG), /* 78 Remote address changed */
673  MBED_DEFINE_POSIX_ERROR(ELIBACC, ELIBACC), /* 79 Can not access a needed shared library */
674  MBED_DEFINE_POSIX_ERROR(ELIBBAD, ELIBBAD), /* 80 Accessing a corrupted shared library */
675  MBED_DEFINE_POSIX_ERROR(ELIBSCN, ELIBSCN), /* 81 .lib section in a.out corrupted */
676  MBED_DEFINE_POSIX_ERROR(ELIBMAX, ELIBMAX), /* 82 Attempting to link in too many shared libraries */
677  MBED_DEFINE_POSIX_ERROR(ELIBEXEC, ELIBEXEC), /* 83 Cannot exec a shared library directly */
678  MBED_DEFINE_POSIX_ERROR(EILSEQ, EILSEQ), /* 84 Illegal byte sequence */
679  MBED_DEFINE_POSIX_ERROR(ERESTART, ERESTART), /* 85 Interrupted system call should be restarted */
680  MBED_DEFINE_POSIX_ERROR(ESTRPIPE, ESTRPIPE), /* 86 Streams pipe error */
681  MBED_DEFINE_POSIX_ERROR(EUSERS, EUSERS), /* 87 Too many users */
682  MBED_DEFINE_POSIX_ERROR(ENOTSOCK, ENOTSOCK), /* 88 Socket operation on non-socket */
683  MBED_DEFINE_POSIX_ERROR(EDESTADDRREQ, EDESTADDRREQ), /* 89 Destination address required */
684  MBED_DEFINE_POSIX_ERROR(EMSGSIZE, EMSGSIZE), /* 90 Message too long */
685  MBED_DEFINE_POSIX_ERROR(EPROTOTYPE, EPROTOTYPE), /* 91 Protocol wrong type for socket */
686  MBED_DEFINE_POSIX_ERROR(ENOPROTOOPT, ENOPROTOOPT), /* 92 Protocol not available */
687  MBED_DEFINE_POSIX_ERROR(EPROTONOSUPPORT, EPROTONOSUPPORT), /* 93 Protocol not supported */
688  MBED_DEFINE_POSIX_ERROR(ESOCKTNOSUPPORT, ESOCKTNOSUPPORT), /* 94 Socket type not supported */
689  MBED_DEFINE_POSIX_ERROR(EOPNOTSUPP, EOPNOTSUPP), /* 95 Operation not supported on transport endpoint */
690  MBED_DEFINE_POSIX_ERROR(EPFNOSUPPORT, EPFNOSUPPORT), /* 96 Protocol family not supported */
691  MBED_DEFINE_POSIX_ERROR(EAFNOSUPPORT, EAFNOSUPPORT), /* 97 Address family not supported by protocol */
692  MBED_DEFINE_POSIX_ERROR(EADDRINUSE, EADDRINUSE), /* 98 Address already in use */
693  MBED_DEFINE_POSIX_ERROR(EADDRNOTAVAIL, EADDRNOTAVAIL), /* 99 Cannot assign requested address */
694  MBED_DEFINE_POSIX_ERROR(ENETDOWN, ENETDOWN), /* 100 Network is down */
695  MBED_DEFINE_POSIX_ERROR(ENETUNREACH, ENETUNREACH), /* 101 Network is unreachable */
696  MBED_DEFINE_POSIX_ERROR(ENETRESET, ENETRESET), /* 102 Network dropped connection because of reset */
697  MBED_DEFINE_POSIX_ERROR(ECONNABORTED, ECONNABORTED), /* 103 Software caused connection abort */
698  MBED_DEFINE_POSIX_ERROR(ECONNRESET, ECONNRESET), /* 104 Connection reset by peer */
699  MBED_DEFINE_POSIX_ERROR(ENOBUFS, ENOBUFS), /* 105 No buffer space available */
700  MBED_DEFINE_POSIX_ERROR(EISCONN, EISCONN), /* 106 Transport endpoint is already connected */
701  MBED_DEFINE_POSIX_ERROR(ENOTCONN, ENOTCONN), /* 107 Transport endpoint is not connected */
702  MBED_DEFINE_POSIX_ERROR(ESHUTDOWN, ESHUTDOWN), /* 108 Cannot send after transport endpoint shutdown */
703  MBED_DEFINE_POSIX_ERROR(ETOOMANYREFS, ETOOMANYREFS), /* 109 Too many references: cannot splice */
704  MBED_DEFINE_POSIX_ERROR(ETIMEDOUT, ETIMEDOUT), /* 110 Connection timed out */
705  MBED_DEFINE_POSIX_ERROR(ECONNREFUSED, ECONNREFUSED), /* 111 Connection refused */
706  MBED_DEFINE_POSIX_ERROR(EHOSTDOWN, EHOSTDOWN), /* 112 Host is down */
707  MBED_DEFINE_POSIX_ERROR(EHOSTUNREACH, EHOSTUNREACH), /* 113 No route to host */
708  MBED_DEFINE_POSIX_ERROR(EALREADY, EALREADY), /* 114 Operation already in progress */
709  MBED_DEFINE_POSIX_ERROR(EINPROGRESS, EINPROGRESS), /* 115 Operation now in progress */
710  MBED_DEFINE_POSIX_ERROR(ESTALE, ESTALE), /* 116 Stale NFS file handle */
711  MBED_DEFINE_POSIX_ERROR(EUCLEAN, EUCLEAN), /* 117 Structure needs cleaning */
712  MBED_DEFINE_POSIX_ERROR(ENOTNAM, ENOTNAM), /* 118 Not a XENIX named type file */
713  MBED_DEFINE_POSIX_ERROR(ENAVAIL, ENAVAIL), /* 119 No XENIX semaphores available */
714  MBED_DEFINE_POSIX_ERROR(EISNAM, EISNAM), /* 120 Is a named type file */
715  MBED_DEFINE_POSIX_ERROR(EREMOTEIO, EREMOTEIO), /* 121 Remote I/O error */
716  MBED_DEFINE_POSIX_ERROR(EDQUOT, EDQUOT), /* 122 Quota exceeded */
717  MBED_DEFINE_POSIX_ERROR(ENOMEDIUM, ENOMEDIUM), /* 123 No medium found */
718  MBED_DEFINE_POSIX_ERROR(EMEDIUMTYPE, EMEDIUMTYPE), /* 124 Wrong medium type */
719  MBED_DEFINE_POSIX_ERROR(ECANCELED, ECANCELED), /* 125 Operation Canceled */
720  MBED_DEFINE_POSIX_ERROR(ENOKEY, ENOKEY), /* 126 Required key not available */
721  MBED_DEFINE_POSIX_ERROR(EKEYEXPIRED, EKEYEXPIRED), /* 127 Key has expired */
722  MBED_DEFINE_POSIX_ERROR(EKEYREVOKED, EKEYREVOKED), /* 128 Key has been revoked */
723  MBED_DEFINE_POSIX_ERROR(EKEYREJECTED, EKEYREJECTED), /* 129 Key was rejected by service */
724  MBED_DEFINE_POSIX_ERROR(EOWNERDEAD, EOWNERDEAD), /* 130 Owner died */
725  MBED_DEFINE_POSIX_ERROR(ENOTRECOVERABLE, ENOTRECOVERABLE), /* 131 State not recoverable */
726 
727  //Below are MBED SYSTEM ERROR CODE definitions
728  //MBED SYSTEM ERROR CODE definitions starts at offset MBED_SYSTEM_ERROR_BASE, see above.
729  // Error Name Error Offset Error Code
730  MBED_DEFINE_SYSTEM_ERROR(UNKNOWN, 0), /* 256 Unknown error */
731  MBED_DEFINE_SYSTEM_ERROR(INVALID_ARGUMENT, 1), /* 257 Invalid Argument */
732  MBED_DEFINE_SYSTEM_ERROR(INVALID_DATA_DETECTED, 2), /* 258 Invalid data detected */
733  MBED_DEFINE_SYSTEM_ERROR(INVALID_FORMAT, 3), /* 259 Invalid format */
734  MBED_DEFINE_SYSTEM_ERROR(INVALID_INDEX, 4), /* 260 Invalid Index */
735  MBED_DEFINE_SYSTEM_ERROR(INVALID_SIZE, 5), /* 261 Invalid Size */
736  MBED_DEFINE_SYSTEM_ERROR(INVALID_OPERATION, 6), /* 262 Invalid Operation */
737  MBED_DEFINE_SYSTEM_ERROR(ITEM_NOT_FOUND, 7), /* 263 Item Not Found */
738  MBED_DEFINE_SYSTEM_ERROR(ACCESS_DENIED, 8), /* 264 Access Denied */
739  MBED_DEFINE_SYSTEM_ERROR(UNSUPPORTED, 9), /* 265 Unsupported */
740  MBED_DEFINE_SYSTEM_ERROR(BUFFER_FULL, 10), /* 266 Buffer Full */
741  MBED_DEFINE_SYSTEM_ERROR(MEDIA_FULL, 11), /* 267 Media/Disk Full */
742  MBED_DEFINE_SYSTEM_ERROR(ALREADY_IN_USE, 12), /* 268 Already in use */
743  MBED_DEFINE_SYSTEM_ERROR(TIME_OUT, 13), /* 269 Timeout error */
744  MBED_DEFINE_SYSTEM_ERROR(NOT_READY, 14), /* 270 Not Ready */
745  MBED_DEFINE_SYSTEM_ERROR(FAILED_OPERATION, 15), /* 271 Requested Operation failed */
746  MBED_DEFINE_SYSTEM_ERROR(OPERATION_PROHIBITED, 16), /* 272 Operation prohibited */
747  MBED_DEFINE_SYSTEM_ERROR(OPERATION_ABORTED, 17), /* 273 Operation failed */
748  MBED_DEFINE_SYSTEM_ERROR(WRITE_PROTECTED, 18), /* 274 Attempt to write to write-protected resource */
749  MBED_DEFINE_SYSTEM_ERROR(NO_RESPONSE, 19), /* 275 No response */
750  MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_LOCK_FAILED, 20), /* 276 Semaphore lock failed */
751  MBED_DEFINE_SYSTEM_ERROR(MUTEX_LOCK_FAILED, 21), /* 277 Mutex lock failed */
752  MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_UNLOCK_FAILED, 22), /* 278 Semaphore unlock failed */
753  MBED_DEFINE_SYSTEM_ERROR(MUTEX_UNLOCK_FAILED, 23), /* 279 Mutex unlock failed */
754  MBED_DEFINE_SYSTEM_ERROR(CRC_ERROR, 24), /* 280 CRC error or mismatch */
755  MBED_DEFINE_SYSTEM_ERROR(OPEN_FAILED, 25), /* 281 Open failed */
756  MBED_DEFINE_SYSTEM_ERROR(CLOSE_FAILED, 26), /* 282 Close failed */
757  MBED_DEFINE_SYSTEM_ERROR(READ_FAILED, 27), /* 283 Read failed */
758  MBED_DEFINE_SYSTEM_ERROR(WRITE_FAILED, 28), /* 284 Write failed */
759  MBED_DEFINE_SYSTEM_ERROR(INITIALIZATION_FAILED, 29), /* 285 Initialization failed */
760  MBED_DEFINE_SYSTEM_ERROR(BOOT_FAILURE, 30), /* 286 Boot failure */
761  MBED_DEFINE_SYSTEM_ERROR(OUT_OF_MEMORY, 31), /* 287 Out of memory */
762  MBED_DEFINE_SYSTEM_ERROR(OUT_OF_RESOURCES, 32), /* 288 Out of resources */
763  MBED_DEFINE_SYSTEM_ERROR(ALLOC_FAILED, 33), /* 289 Alloc failed */
764  MBED_DEFINE_SYSTEM_ERROR(FREE_FAILED, 34), /* 290 Free failed */
765  MBED_DEFINE_SYSTEM_ERROR(OVERFLOW, 35), /* 291 Overflow error */
766  MBED_DEFINE_SYSTEM_ERROR(UNDERFLOW, 36), /* 292 Underflow error */
767  MBED_DEFINE_SYSTEM_ERROR(STACK_OVERFLOW, 37), /* 293 Stack overflow error */
768  MBED_DEFINE_SYSTEM_ERROR(ISR_QUEUE_OVERFLOW, 38), /* 294 ISR queue overflow */
769  MBED_DEFINE_SYSTEM_ERROR(TIMER_QUEUE_OVERFLOW, 39), /* 295 Timer Queue overflow */
770  MBED_DEFINE_SYSTEM_ERROR(CLIB_SPACE_UNAVAILABLE, 40), /* 296 Standard library error - Space unavailable */
771  MBED_DEFINE_SYSTEM_ERROR(CLIB_EXCEPTION, 41), /* 297 Standard library error - Exception */
772  MBED_DEFINE_SYSTEM_ERROR(CLIB_MUTEX_INIT_FAILURE, 42), /* 298 Standard library error - Mutex Init failure */
773  MBED_DEFINE_SYSTEM_ERROR(CREATE_FAILED, 43), /* 299 Create failed */
774  MBED_DEFINE_SYSTEM_ERROR(DELETE_FAILED, 44), /* 300 Delete failed */
775  MBED_DEFINE_SYSTEM_ERROR(THREAD_CREATE_FAILED, 45), /* 301 Thread Create failed */
776  MBED_DEFINE_SYSTEM_ERROR(THREAD_DELETE_FAILED, 46), /* 302 Thread Delete failed */
777  MBED_DEFINE_SYSTEM_ERROR(PROHIBITED_IN_ISR_CONTEXT, 47), /* 303 Operation Prohibited in ISR context */
778  MBED_DEFINE_SYSTEM_ERROR(PINMAP_INVALID, 48), /* 304 Pinmap Invalid */
779  MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT, 49), /* 305 Unknown Rtos Error */
780  MBED_DEFINE_SYSTEM_ERROR(RTOS_THREAD_EVENT, 50), /* 306 Rtos Thread Error */
781  MBED_DEFINE_SYSTEM_ERROR(RTOS_MUTEX_EVENT, 51), /* 307 Rtos Mutex Error */
782  MBED_DEFINE_SYSTEM_ERROR(RTOS_SEMAPHORE_EVENT, 52), /* 308 Rtos Semaphore Error */
783  MBED_DEFINE_SYSTEM_ERROR(RTOS_MEMORY_POOL_EVENT, 53), /* 309 Rtos Memory Pool Error */
784  MBED_DEFINE_SYSTEM_ERROR(RTOS_TIMER_EVENT, 54), /* 310 Rtos Timer Error */
785  MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT_FLAGS_EVENT, 55), /* 311 Rtos Event flags Error */
786  MBED_DEFINE_SYSTEM_ERROR(RTOS_MESSAGE_QUEUE_EVENT, 56), /* 312 Rtos Message queue Error */
787  MBED_DEFINE_SYSTEM_ERROR(DEVICE_BUSY, 57), /* 313 Device Busy */
788  MBED_DEFINE_SYSTEM_ERROR(CONFIG_UNSUPPORTED, 58), /* 314 Configuration not supported */
789  MBED_DEFINE_SYSTEM_ERROR(CONFIG_MISMATCH, 59), /* 315 Configuration mismatch */
790  MBED_DEFINE_SYSTEM_ERROR(ALREADY_INITIALIZED, 60), /* 316 Already initialized */
791  MBED_DEFINE_SYSTEM_ERROR(HARDFAULT_EXCEPTION, 61), /* 317 HardFault exception */
792  MBED_DEFINE_SYSTEM_ERROR(MEMMANAGE_EXCEPTION, 62), /* 318 MemManage exception */
793  MBED_DEFINE_SYSTEM_ERROR(BUSFAULT_EXCEPTION, 63), /* 319 BusFault exception */
794  MBED_DEFINE_SYSTEM_ERROR(USAGEFAULT_EXCEPTION, 64), /* 320 UsageFault exception*/
795  MBED_DEFINE_SYSTEM_ERROR(BLE_NO_FRAME_INITIALIZED, 65), /* 321 BLE No frame initialized */
796  MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_CREATION_FAILED, 66), /* 322 BLE Backend creation failed */
797  MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_NOT_INITIALIZED, 67), /* 323 BLE Backend not initialized */
798  MBED_DEFINE_SYSTEM_ERROR(ASSERTION_FAILED, 68), /* 324 Assertion Failed */
799  MBED_DEFINE_SYSTEM_ERROR(AUTHENTICATION_FAILED, 69), /* 325 Authentication Failed */
800  MBED_DEFINE_SYSTEM_ERROR(RBP_AUTHENTICATION_FAILED, 70), /* 326 Rollback Protection Authentication Failed */
801  MBED_DEFINE_SYSTEM_ERROR(BLE_USE_INCOMPATIBLE_API, 71), /* 327 Concurrent use of incompatible versions of a BLE API */
802  MBED_DEFINE_SYSTEM_ERROR(BLE_ILLEGAL_STATE, 72), /* 328 BLE stack entered illegal state */
803 
804  //Everytime you add a new system error code, you must update
805  //Error documentation under Handbook to capture the info on
806  //the new error status/codes
807 
808  //MBED CUSTOM ERROR CODE definitions starts at offset MBED_CUSTOM_ERROR_BASE, see above.
809  /* Add More/Custom Error Codes here, See example below */
810  //DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR , 1 ),
811 
812 } mbed_error_code_t;
813 
814 /** mbed_error_ctx struct
815  *
816  * This struct captures the context information at the time of error.\n
817  * It primarily contains information about the thread where the error originated,\n
818  * filename/line number of the source file where the error occurred, a context specific error value(error_value)\n
819  * and the address where the error originated.\n
820  *
821  * @note
822  * Below are the members of mbed_error_ctx struct\n
823  * error_status mbed_error_status_t value for this error\n
824  * error_function_address Address where the error occurred\n
825  * thread_id ID of the thread which generated the error\n
826  * thread_entry_address Entry function of the thread which generated the error\n
827  * thread_stack_size Stack Size of the thread which generated the error\n
828  * thread_stack_mem Stack Top of the thread which generated the error\n
829  * thread_current_sp Current Stack Pointer of the thread which generated the error\n
830  * error_value A context/error specific value associated with this error\n
831  * error_filename Filename where the error originated\n
832  * error_line_number Line number in error_filename where the error originated\n
833  */
834 typedef struct _mbed_error_ctx {
835  mbed_error_status_t error_status;
836  uint32_t error_address;
837  uint32_t error_value;
838  uint32_t thread_id;
839  uint32_t thread_entry_address;
840  uint32_t thread_stack_size;
841  uint32_t thread_stack_mem;
842  uint32_t thread_current_sp;
843 #ifdef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
844  char error_filename[MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN];
845  uint32_t error_line_number;
846 #endif
847 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED
848  int32_t error_reboot_count;//everytime we write this struct we increment this value by 1, irrespective of time between reboots. Note that the data itself might change, but everytime we reboot due to error we update this count by 1
849  int32_t is_error_processed;//once this error is processed set this value to 1
850  uint32_t crc_error_ctx;//crc_error_ctx should always be the last member in this struct
851 #endif
852 } mbed_error_ctx;
853 
854 /** To generate a fatal compile-time error, you can use the pre-processor #error directive.
855  *
856  * @param format C string that contains data stream to be printed.
857  * Code snippets below show valid format.
858  *
859  * @code
860  * #error "That shouldn't have happened!"
861  * @endcode
862  *
863  * If the compiler evaluates this line, it will report the error and stop the compile.
864  *
865  * For example, you could use this to check some user-defined compile-time variables:
866  *
867  * @code
868  * #define NUM_PORTS 7
869  * #if (NUM_PORTS > 4)
870  * #error "NUM_PORTS must be less than 4"
871  * #endif
872  * @endcode
873  *
874  * Reporting Run-Time Errors:
875  * To generate a fatal run-time error, you can use the mbed error() function.
876  *
877  * @code
878  * error("That shouldn't have happened!");
879  * @endcode
880  *
881  * If the mbed running the program executes this function, it will print the
882  * message via the USB serial port, and then die with the blue lights of death!
883  *
884  * The message can use printf-style formatting, so you can report variables in the
885  * message too. For example, you could use this to check a run-time condition:
886  *
887  * @code
888  * if(x >= 5) {
889  * error("expected x to be less than 5, but got %d", x);
890  * }
891  * @endcode
892  *
893  *
894  */
895 
896 MBED_NORETURN void error(const char *format, ...) MBED_PRINTF(1, 2);
897 
898 /**
899  * Call this Macro to generate a mbed_error_status_t value for a System error
900  * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
901  * @param error_code The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes.
902  *
903  * @code
904  *
905  * mbed_error_status_t driver_error = MBED_MAKE_SYSTEM_ERROR( MODULE_DRIVER_USB, MBED_ERROR_CODE_INITIALIZATION_FAILED )
906  *
907  * @endcode
908  * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
909  *
910  */
911 #define MBED_MAKE_SYSTEM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, module, error_code)
912 
913 /**
914  * Call this Macro to generate a mbed_error_status_t value for a Custom error
915  * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
916  * @param error_code The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes.
917  *
918  * @code
919  *
920  * mbed_error_status_t custom_error = MBED_MAKE_CUSTOM_ERROR( MBED_MODULE_APPLICATION, 0xDEAD//16-bit custom error code )
921  *
922  * @endcode
923  * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_CUSTOM
924  *
925  */
926 #define MBED_MAKE_CUSTOM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, module, error_code)
927 
928 /**
929  * Call this Macro to generate a mbed_error_status_t value for a System error
930  * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
931  * @param error_code The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes.
932  *
933  * @code
934  *
935  * mbed_error_status_t new_error = MBED_MAKE_ERROR( MODULE_DRIVER_USB, MBED_ERROR_INITIALIZATION_FAILED )
936  *
937  * @endcode
938  * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
939  *
940  */
941 #define MBED_MAKE_ERROR(module, error_code) MBED_MAKE_SYSTEM_ERROR(module, error_code)
942 
943 /**
944  * Callback/Error hook function prototype. Applications needing a callback when an error is reported can use mbed_set_error_hook function
945  * to register a callback/error hook function using the following prototype. When an error happens in the system error handling
946  * implementation will invoke this callback with the mbed_error_status_t reported and the error context at the time of error.
947  * @param error_ctx Error context structure associated with this error.
948  * @return void
949  *
950  */
951 typedef void (*mbed_error_hook_t)(const mbed_error_ctx *error_ctx);
952 
953 /**
954  * Callback/Error hook function. If application implementation needs to receive this callback when an error is reported,
955  * mbed_error_hook function should be overridden with custom implementation. When an error happens in the system error handling
956  * implementation will invoke this callback with the mbed_error_status_t reported and the error context at the time of error.
957  * @param error_ctx Error context structure associated with this error.
958  * @return void
959  *
960  */
961 void mbed_error_hook(const mbed_error_ctx *error_context);
962 
963 /**
964  * Callback function for reporting error context during boot up. When MbedOS error handling system detects a fatal error
965  * it will auto-reboot the system(if MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED is enabled) after capturing the
966  * error info in special crash data RAM region. Once rebooted, MbedOS initialization routines will call this function with a pointer to
967  * the captured mbed_error_ctx structure. If application implementation needs to receive this callback, mbed_error_reboot_callback
968  * function should be overridden with custom implementation. By default it's defined as a WEAK function in mbed_error.c.
969  * Note that this callback will be invoked before the system starts executing main() function. So the implementation of
970  * the callback should be aware any resource limitations/availability of resources which are yet to be initialized by application main().
971  *
972  * @param error_ctx Error context structure associated with this error.
973  * @return void
974  *
975  */
976 void mbed_error_reboot_callback(mbed_error_ctx *error_context);
977 
978 /**
979  * Initialize error handling system, this is called by the mbed-os boot sequence. This is not required to be called by Application unless the boot sequence is overridden by the system implementation.
980  * NOTE: If MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED is enabled and if the current reboot count exceeds MBED_CONF_PLATFORM_ERROR_REBOOT_MAX the system will halt when this function is called,
981  * and in such cases the caller will not get the control back. Also note that calling this function may trigger mbed_error_reboot_callback() if application side overides mbed_error_reboot_callback().
982  * @return MBED_SUCCESS on success.
983  *
984  */
985 
986 mbed_error_status_t mbed_error_initialize(void);
987 
988 /**
989  * Call this function to retrieve the error context after a fatal error which triggered a system reboot. The function retrieves the error context stored in crash-report ram area which is preserved over reboot.
990  * @param error_info Pointer to mbed_error_ctx struct allocated by the caller. This is the mbed_error_ctx info captured as part of the fatal error which triggered the reboot.
991  * @return 0 or MBED_SUCCESS on success.
992  * MBED_ERROR_INVALID_ARGUMENT in case of invalid error_info pointer
993  * MBED_ERROR_ITEM_NOT_FOUND if no reboot context is currently captured by the system
994  *
995  */
996 mbed_error_status_t mbed_get_reboot_error_info(mbed_error_ctx *error_info);
997 
998 /**
999  * Calling this function resets the current reboot context captured by the system(stored in special crash data RAM region).
1000  * @return MBED_SUCCESS on success.
1001  * MBED_ERROR_ITEM_NOT_FOUND if no reboot context is currently captured by the system
1002  */
1003 mbed_error_status_t mbed_reset_reboot_error_info(void);
1004 
1005 /**
1006  * Calling this function resets the current reboot count stored as part of error context captured in special crash data RAM region.
1007  * The function will also update the CRC value stored as part of error context accordingly.
1008  * @return MBED_SUCCESS on success.
1009  * MBED_ERROR_ITEM_NOT_FOUND if no reboot context is currently captured by the system
1010  */
1011 mbed_error_status_t mbed_reset_reboot_count(void);
1012 
1013 /**
1014  * Call this function to set a system error/warning. This function will log the error status with the context info and return to caller.
1015  *
1016  * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
1017  * @param error_msg The error message to be printed out to STDIO/Serial.
1018  * @param error_value Value associated with the error status. This would depend on error code/error scenario.
1019  * @param filename Name of the source file originating the error( Most callers can pass __FILE__ here ).
1020  * @param line_number The line number of the source file originating the error( Most callers can pass __LINE__ here ) .
1021  * @return 0 or MBED_SUCCESS.
1022  * MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes
1023  *
1024  * @code
1025  *
1026  * mbed_error( ERROR_OUT_OF_MEMORY, "Out of memory error", 0, __FILE__, __LINE__ )
1027  *
1028  * @endcode
1029  *
1030  * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API
1031  */
1032 mbed_error_status_t mbed_warning(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number);
1033 
1034 /**
1035  * Returns the first system error reported.
1036  * @return mbed_error_status_t code logged for the first error or MBED_SUCCESS if no errors are logged.
1037  *
1038  */
1039 mbed_error_status_t mbed_get_first_error(void);
1040 
1041 /**
1042  * Returns the most recent system error reported.
1043  * @return mbed_error_status_t code logged for the last error or MBED_SUCCESS if no errors are logged.
1044  *
1045  */
1046 mbed_error_status_t mbed_get_last_error(void);
1047 
1048 /**
1049  * Returns the number of system errors reported after boot.
1050  * @return int Number of errors reported.
1051  *
1052  */
1053 int mbed_get_error_count(void);
1054 
1055 /**
1056  * Returns whether we are processing a fatal mbed error.
1057  * @return bool Whether a fatal error has occurred.
1058  *
1059  */
1060 bool mbed_get_error_in_progress(void);
1061 
1062 /**
1063  * Call this function to set a fatal system error and halt the system. This function will log the fatal error with the context info and prints the error report and halts the system.
1064  *
1065  * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
1066  * @param error_msg The error message to be printed out to STDIO/Serial.
1067  * @param error_value Value associated with the error status. This would depend on error code/error scenario.
1068  * @param filename Name of the source file originating the error( Most callers can pass __FILE__ here ).
1069  * @param line_number The line number of the source file originating the error( Most callers can pass __LINE__ here ) .
1070  * @return Does not return.
1071  *
1072  * @code
1073  *
1074  * mbed_error( MBED_ERROR_PROHIBITED_OPERATION, "Prohibited operation tried", 0, __FILE__, __LINE__ )
1075  *
1076  * @endcode
1077  *
1078  * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API
1079  */
1080 MBED_NORETURN mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number);
1081 
1082 /**
1083  * Registers an application defined error callback with the error handling system.
1084  * This function will be called with error context info whenever system handles a mbed_error/mbed_warning call
1085  * NOTE: This function should be implemented for re-entrancy as multiple threads may invoke mbed_error which may cause error hook to be called.
1086  * @param custom_error_hook mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values).
1087  * @return 0 or MBED_SUCCESS on success.
1088  * MBED_ERROR_INVALID_ARGUMENT in case of NULL for custom_error_hook
1089  *
1090  * @code
1091  *
1092  * mbed_error_status_t my_custom_error_hook(mbed_error_status_t error_status, const mbed_error_ctx *error_ctx) {
1093  * //Do something with the error_status or error_ctx
1094  * }
1095  *
1096  * mbed_set_error_hook( my_custom_error_hook )
1097  *
1098  * @endcode
1099  * @note The error hook function implementation should be re-entrant.
1100  *
1101  * @deprecated You should use an overridden mbed_error_hook() function if you like to catch errors in your application.
1102  * With mbed_set_error_hook() it is not possible to catch errors before your application started.
1103  */
1104 mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t custom_error_hook);
1105 
1106 /**
1107  * Reads the first error context information captured.
1108  * @param error_info This is the mbed_error_context info captured as part of the first mbed_error call. The caller should pass a pointer to mbed_error_context struct allocated by the caller.
1109  * @return 0 or MBED_SUCCESS on success.
1110  * MBED_ERROR_INVALID_ARGUMENT in case of invalid index
1111  *
1112  */
1113 mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info);
1114 
1115 /**
1116  * Reads the last error context information captured.
1117  * @param error_info This is the mbed_error_context info captured as part of the last mbed_error call. The caller should pass a pointer to mbed_error_context struct allocated by the caller.
1118  * @return 0 or MBED_ERROR_SUCCESS on success.
1119  * MBED_ERROR_INVALID_ARGUMENT in case of invalid index
1120  *
1121  */
1122 mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info);
1123 
1124 /**
1125  * Clears the last error, first error, error count and all entries in the error history.
1126  * @return 0 or MBED_SUCCESS on success.
1127  *
1128  */
1129 mbed_error_status_t mbed_clear_all_errors(void);
1130 
1131 /**
1132  * Generates a mbed_error_status_t value based on passed in values for type, module and error code.
1133  * @param error_type Error type based on mbed_error_type_t enum.
1134  * @param module Module type based on mbed_module_type_t enum.
1135  * @param error_code Error codes defined by mbed_error_code_t enum
1136  * @return 0 or MBED_ERROR_SUCCESS on success.
1137  *
1138  */
1139 mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code);
1140 
1141 /**
1142  * Returns the current number of entries in the error history, if there has been more than max number of errors logged the number returned will be max depth of error history.
1143  * @return Current number of entries in the error history.
1144  *
1145  */
1146 int mbed_get_error_hist_count(void);
1147 
1148 /**
1149  * Reads the error context information for a specific error from error history, specified by the index.
1150  *
1151  * @param index index of the error context entry in the history to be retrieved.\n
1152  * The number of entries in the error history is configured during build and the max index depends on max depth of error history.\n
1153  * index = 0 points to the oldest entry in the history, and index = (max history depth - 1) points to the latest entry in the error history.\n
1154  * @param error_info This is the mbed_error_context info captured as part of the error history. The caller should pass a pointer to mbed_error_context struct allocated by the caller.
1155  * @return 0 or MBED_SUCCESS on success.
1156  * MBED_ERROR_INVALID_ARGUMENT in case of invalid index
1157  *
1158  */
1159 mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info);
1160 
1161 /**
1162  * Saves the error history information to a file
1163  *
1164  * @param path path to the file in the filesystem
1165  * @return 0 or MBED_ERROR_SUCCESS on success.
1166  * MBED_ERROR_WRITE_FAILED if writing to file failed
1167  * MBED_ERROR_INVALID_ARGUMENT if path is not valid
1168  *
1169  * @note Filesystem support is required in order for this function to work.
1170  *
1171  */
1172 mbed_error_status_t mbed_save_error_hist(const char *path);
1173 
1174 #ifdef __cplusplus
1175 }
1176 #endif
1177 
1178 #endif
1179 
1180 /** @}*/
1181 /** @}*/
1182 
1183 
mbed_set_error_hook
mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t custom_error_hook)
Registers an application defined error callback with the error handling system.
mbed_error_initialize
mbed_error_status_t mbed_error_initialize(void)
Initialize error handling system, this is called by the mbed-os boot sequence.
mbed_error_reboot_callback
void mbed_error_reboot_callback(mbed_error_ctx *error_context)
Callback function for reporting error context during boot up.
error
MBED_NORETURN void error(const char *format,...) MBED_PRINTF(1
To generate a fatal compile-time error, you can use the pre-processor error directive.
_mbed_module_type
_mbed_module_type
mbed_module_type_t definition
Definition: mbed_error.h:270
mbed_error_type_t
enum _mbed_error_type_t mbed_error_type_t
mbed_error_type_t definition
MBED_DEFINE_POSIX_ERROR
#define MBED_DEFINE_POSIX_ERROR(error_name, error_code)
Macro for defining a POSIX error status.
Definition: mbed_error.h:118
mbed_make_error
mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code)
Generates a mbed_error_status_t value based on passed in values for type, module and error code...
mbed_get_error_count
int mbed_get_error_count(void)
Returns the number of system errors reported after boot.
mbed_get_last_error
mbed_error_status_t mbed_get_last_error(void)
Returns the most recent system error reported.
mbed_get_last_error_info
mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info)
Reads the last error context information captured.
mbed_get_error_hist_count
int mbed_get_error_hist_count(void)
Returns the current number of entries in the error history, if there has been more than max number of...
mbed_error_code_t
enum _mbed_error_code mbed_error_code_t
mbed_error_code_t definition
mbed_error
MBED_NORETURN mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number)
Call this function to set a fatal system error and halt the system.
mbed_get_error_hist_info
mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info)
Reads the error context information for a specific error from error history, specified by the index...
mbed_module_type_t
enum _mbed_module_type mbed_module_type_t
mbed_module_type_t definition
mbed_clear_all_errors
mbed_error_status_t mbed_clear_all_errors(void)
Clears the last error, first error, error count and all entries in the error history.
mbed_warning
mbed_error_status_t mbed_warning(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number)
Call this function to set a system error/warning.
MBED_DEFINE_SYSTEM_ERROR
#define MBED_DEFINE_SYSTEM_ERROR(error_name, error_code)
Macro for defining a System error status.
Definition: mbed_error.h:128
mbed_error_ctx
struct _mbed_error_ctx mbed_error_ctx
mbed_error_ctx struct
mbed_get_error_in_progress
bool mbed_get_error_in_progress(void)
Returns whether we are processing a fatal mbed error.
mbed_reset_reboot_count
mbed_error_status_t mbed_reset_reboot_count(void)
Calling this function resets the current reboot count stored as part of error context captured in spe...
mbed_error_status_t
int mbed_error_status_t
mbed_error_status_t description
Definition: mbed_error.h:110
_mbed_error_type_t
_mbed_error_type_t
mbed_error_type_t definition
Definition: mbed_error.h:214
_mbed_error_code
_mbed_error_code
mbed_error_code_t definition
Definition: mbed_error.h:590
mbed_get_first_error_info
mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info)
Reads the first error context information captured.
mbed_get_first_error
mbed_error_status_t mbed_get_first_error(void)
Returns the first system error reported.
MBED_NORETURN
#define MBED_NORETURN
MBED_NORETURN Declare a function that will never return.
Definition: mbed_toolchain.h:323
mbed_save_error_hist
mbed_error_status_t mbed_save_error_hist(const char *path)
Saves the error history information to a file.
mbed_error_hook
void mbed_error_hook(const mbed_error_ctx *error_context)
Callback/Error hook function.
mbed_error_hook_t
void(* mbed_error_hook_t)(const mbed_error_ctx *error_ctx)
Callback/Error hook function prototype.
Definition: mbed_error.h:951
mbed_reset_reboot_error_info
mbed_error_status_t mbed_reset_reboot_error_info(void)
Calling this function resets the current reboot context captured by the system(stored in special cras...
mbed_get_reboot_error_info
mbed_error_status_t mbed_get_reboot_error_info(mbed_error_ctx *error_info)
Call this function to retrieve the error context after a fatal error which triggered a system reboot...
_mbed_error_ctx
mbed_error_ctx struct
Definition: mbed_error.h:834
MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
#define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN
Define this macro to include filenames in error context.
Definition: mbed_error.h:45
Important Information for this Arm website

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.