Changeset b678410 in mainline for uspace/lib/c
- Timestamp:
- 2011-04-27T20:01:13Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- a6dffb8
- Parents:
- 628d548 (diff), 933cadf (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- uspace/lib/c
- Files:
-
- 25 edited
- 1 moved
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/Makefile
r628d548 rb678410 122 122 generic/sort.c \ 123 123 generic/stats.c \ 124 generic/assert.c \ 124 125 rtld/rtld.c \ 125 126 rtld/elf_load.c \ -
uspace/lib/c/arch/ia32/include/config.h
r628d548 rb678410 36 36 #define LIBC_ia32_CONFIG_H_ 37 37 38 #define PAGE_WIDTH 12 39 #define PAGE_SIZE (1 << PAGE_WIDTH) 38 #define PAGE_WIDTH 12 39 #define PAGE_SIZE (1 << PAGE_WIDTH) 40 41 #define USER_ADDRESS_SPACE_START_ARCH UINT32_C(0x00000000) 42 #define USER_ADDRESS_SPACE_END_ARCH UINT32_C(0x7fffffff) 40 43 41 44 #endif -
uspace/lib/c/arch/ia32/include/ddi.h
r628d548 rb678410 37 37 #include <libarch/types.h> 38 38 39 #define IO_SPACE_BOUNDARY 39 #define IO_SPACE_BOUNDARY ((void *) (64 * 1024)) 40 40 41 41 static inline uint8_t pio_read_8(ioport8_t *port) -
uspace/lib/c/arch/ia32/include/faddr.h
r628d548 rb678410 38 38 #include <libarch/types.h> 39 39 40 #define FADDR(fptr) 40 #define FADDR(fptr) ((uintptr_t) (fptr)) 41 41 42 42 #endif -
uspace/lib/c/arch/ia32/include/fibril.h
r628d548 rb678410 42 42 * panic sooner or later 43 43 */ 44 #define SP_DELTA (12)44 #define SP_DELTA 12 45 45 46 46 #define context_set(c, _pc, stack, size, ptls) \ … … 51 51 (c)->ebp = 0; \ 52 52 } while (0) 53 54 /* We include only registers that must be preserved 53 54 /* 55 * We include only registers that must be preserved 55 56 * during function call 56 57 */ -
uspace/lib/c/arch/ia32/src/stacktrace.c
r628d548 rb678410 35 35 */ 36 36 37 #include <libarch/config.h> 37 38 #include <sys/types.h> 38 39 #include <bool.h> 39 40 40 #include <stacktrace.h> 41 41 42 #define FRAME_OFFSET_FP_PREV 43 #define FRAME_OFFSET_RA 42 #define FRAME_OFFSET_FP_PREV 0 43 #define FRAME_OFFSET_RA 4 44 44 45 45 bool stacktrace_fp_valid(stacktrace_t *st, uintptr_t fp) 46 46 { 47 47 (void) st; 48 return fp != 0;48 return (fp != 0) && (fp <= USER_ADDRESS_SPACE_END_ARCH); 49 49 } 50 50 -
uspace/lib/c/arch/ia64/_link.ld.in
r628d548 rb678410 22 22 23 23 .got : { 24 _gp = .; 24 /* Tell the linker where we expect GP to point. */ 25 __gp = .; 25 26 *(.got .got.*); 26 27 } :data -
uspace/lib/c/arch/ia64/src/entry.s
r628d548 rb678410 39 39 __entry: 40 40 alloc loc0 = ar.pfs, 0, 1, 2, 0 41 movl gp = _ gp41 movl gp = __gp 42 42 43 43 # Pass PCB pointer as the first argument to __main -
uspace/lib/c/arch/ia64/src/thread_entry.s
r628d548 rb678410 37 37 alloc loc0 = ar.pfs, 0, 1, 1, 0 38 38 39 movl gp = _ gp39 movl gp = __gp 40 40 41 41 # -
uspace/lib/c/arch/mips32/include/atomic.h
r628d548 rb678410 70 70 " sc %0, %1\n" 71 71 " beq %0, %4, 1b\n" /* if the atomic operation failed, try again */ 72 /* nop */ /* nop is inserted automatically by compiler */73 72 " nop\n" 74 73 : "=&r" (tmp), -
uspace/lib/c/generic/assert.c
r628d548 rb678410 1 1 /* 2 * Copyright (c) 2007 Jan Hudecek 3 * Copyright (c) 2008 Martin Decky 2 * Copyright (c) 2011 Martin Decky 4 3 * All rights reserved. 5 4 * … … 28 27 */ 29 28 30 /** @addtogroup genericproc29 /** @addtogroup libc 31 30 * @{ 32 31 */ 33 /** @file tasklet.c34 * @brief Tasklet implementation35 */36 32 37 #include < proc/tasklet.h>38 #include <s ynch/spinlock.h>39 #include < mm/slab.h>40 #include < config.h>33 #include <assert.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <stacktrace.h> 41 37 42 /** Spinlock protecting list of tasklets */ 43 SPINLOCK_INITIALIZE(tasklet_lock); 44 45 /** Array of tasklet lists for every CPU */ 46 tasklet_descriptor_t **tasklet_list; 47 48 void tasklet_init(void) 38 void assert_abort(const char *cond, const char *file, unsigned int line) 49 39 { 50 unsigned int i; 51 52 tasklet_list = malloc(sizeof(tasklet_descriptor_t *) * config.cpu_count, 0); 53 if (!tasklet_list) 54 panic("Error initializing tasklets."); 55 56 for (i = 0; i < config.cpu_count; i++) 57 tasklet_list[i] = NULL; 58 59 spinlock_initialize(&tasklet_lock, "tasklet_lock"); 40 printf("Assertion failed (%s) in file \"%s\", line %u.\n", 41 cond, file, line); 42 stacktrace_print(); 43 abort(); 60 44 } 61 62 45 63 46 /** @} -
uspace/lib/c/generic/async.c
r628d548 rb678410 102 102 #include <arch/barrier.h> 103 103 #include <bool.h> 104 #include <stdlib.h> 105 #include <malloc.h> 104 106 #include "private/async.h" 105 107 … … 1572 1574 * @param dst Address of the beginning of the destination buffer. 1573 1575 * @param size Size of the destination buffer. 1576 * @param flags Flags to control the data transfer. 1574 1577 * 1575 1578 * @return Zero on success or a negative error code from errno.h. 1576 1579 * 1577 1580 */ 1578 int async_data_read_start(int phoneid, void *dst, size_t size) 1579 { 1580 return async_req_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst, 1581 (sysarg_t) size); 1581 int 1582 async_data_read_start_generic(int phoneid, void *dst, size_t size, int flags) 1583 { 1584 return async_req_3_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst, 1585 (sysarg_t) size, (sysarg_t) flags); 1582 1586 } 1583 1587 … … 1669 1673 * @param src Address of the beginning of the source buffer. 1670 1674 * @param size Size of the source buffer. 1675 * @param flags Flags to control the data transfer. 1671 1676 * 1672 1677 * @return Zero on success or a negative error code from errno.h. 1673 1678 * 1674 1679 */ 1675 int async_data_write_start(int phoneid, const void *src, size_t size) 1676 { 1677 return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src, 1678 (sysarg_t) size); 1680 int 1681 async_data_write_start_generic(int phoneid, const void *src, size_t size, 1682 int flags) 1683 { 1684 return async_req_3_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src, 1685 (sysarg_t) size, (sysarg_t) flags); 1679 1686 } 1680 1687 -
uspace/lib/c/generic/async_sess.c
r628d548 rb678410 105 105 #include <errno.h> 106 106 #include <assert.h> 107 #include <async.h> 107 108 #include "private/async_sess.h" 108 109 -
uspace/lib/c/generic/errno.c
r628d548 rb678410 36 36 #include <fibril.h> 37 37 38 int _errno; 38 static fibril_local int fibril_errno; 39 40 int *__errno(void) 41 { 42 return &fibril_errno; 43 } 39 44 40 45 /** @} -
uspace/lib/c/generic/fibril_synch.c
r628d548 rb678410 43 43 #include <stacktrace.h> 44 44 #include <stdlib.h> 45 #include <stdio.h> 45 46 #include "private/async.h" 46 47 -
uspace/lib/c/generic/io/io.c
r628d548 rb678410 173 173 } 174 174 *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY); 175 break; 175 176 default: 176 177 errno = EINVAL; -
uspace/lib/c/generic/malloc.c
r628d548 rb678410 44 44 #include <mem.h> 45 45 #include <futex.h> 46 #include <stdlib.h> 46 47 #include <adt/gcdlcm.h> 47 48 #include "private/malloc.h" -
uspace/lib/c/generic/stacktrace.c
r628d548 rb678410 61 61 stacktrace_prepare(); 62 62 stacktrace_print_fp_pc(stacktrace_fp_get(), stacktrace_pc_get()); 63 63 64 /* 64 65 * Prevent the tail call optimization of the previous call by 65 66 * making it a non-tail call. 66 67 */ 67 (void) stacktrace_fp_get(); 68 69 printf("-- end of stack trace --\n"); 68 70 } 69 71 -
uspace/lib/c/generic/str.c
r628d548 rb678410 1215 1215 void order_suffix(const uint64_t val, uint64_t *rv, char *suffix) 1216 1216 { 1217 if (val > 10000000000000000000ULL) {1218 *rv = val / 1000000000000000000ULL;1217 if (val > UINT64_C(10000000000000000000)) { 1218 *rv = val / UINT64_C(1000000000000000000); 1219 1219 *suffix = 'Z'; 1220 } else if (val > 1000000000000000000ULL) {1221 *rv = val / 1000000000000000ULL;1220 } else if (val > UINT64_C(1000000000000000000)) { 1221 *rv = val / UINT64_C(1000000000000000); 1222 1222 *suffix = 'E'; 1223 } else if (val > 1000000000000000ULL) {1224 *rv = val / 1000000000000ULL;1223 } else if (val > UINT64_C(1000000000000000)) { 1224 *rv = val / UINT64_C(1000000000000); 1225 1225 *suffix = 'T'; 1226 } else if (val > 1000000000000ULL) {1227 *rv = val / 1000000000ULL;1226 } else if (val > UINT64_C(1000000000000)) { 1227 *rv = val / UINT64_C(1000000000); 1228 1228 *suffix = 'G'; 1229 } else if (val > 1000000000ULL) {1230 *rv = val / 1000000ULL;1229 } else if (val > UINT64_C(1000000000)) { 1230 *rv = val / UINT64_C(1000000); 1231 1231 *suffix = 'M'; 1232 } else if (val > 1000000ULL) {1233 *rv = val / 1000ULL;1232 } else if (val > UINT64_C(1000000)) { 1233 *rv = val / UINT64_C(1000); 1234 1234 *suffix = 'k'; 1235 1235 } else { … … 1239 1239 } 1240 1240 1241 void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix, 1242 bool fixed) 1243 { 1244 if (val > UINT64_C(1152921504606846976)) { 1245 *rv = val / UINT64_C(1125899906842624); 1246 *suffix = "EiB"; 1247 } else if (val > UINT64_C(1125899906842624)) { 1248 *rv = val / UINT64_C(1099511627776); 1249 *suffix = "TiB"; 1250 } else if (val > UINT64_C(1099511627776)) { 1251 *rv = val / UINT64_C(1073741824); 1252 *suffix = "GiB"; 1253 } else if (val > UINT64_C(1073741824)) { 1254 *rv = val / UINT64_C(1048576); 1255 *suffix = "MiB"; 1256 } else if (val > UINT64_C(1048576)) { 1257 *rv = val / UINT64_C(1024); 1258 *suffix = "KiB"; 1259 } else { 1260 *rv = val; 1261 if (fixed) 1262 *suffix = "B "; 1263 else 1264 *suffix = "B"; 1265 } 1266 } 1267 1241 1268 /** @} 1242 1269 */ -
uspace/lib/c/generic/vfs/vfs.c
r628d548 rb678410 378 378 379 379 req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer); 380 rc = async_data_read_start(vfs_phone, (void *)buf, nbyte); 380 rc = async_data_read_start_generic(vfs_phone, (void *) buf, nbyte, 381 IPC_XF_RESTRICT); 381 382 if (rc != EOK) { 382 383 vfs_exchange_end(vfs_phone); … … 407 408 408 409 req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer); 409 rc = async_data_write_start(vfs_phone, (void *)buf, nbyte); 410 rc = async_data_write_start_generic(vfs_phone, (void *) buf, nbyte, 411 IPC_XF_RESTRICT); 410 412 if (rc != EOK) { 411 413 vfs_exchange_end(vfs_phone); -
uspace/lib/c/include/assert.h
r628d548 rb678410 40 40 * 41 41 * If NDEBUG is not set, the assert() macro 42 * evaluates expr and if it is false prints 42 * evaluates expr and if it is false prints 43 43 * error message and terminate program. 44 44 * … … 47 47 */ 48 48 49 #include <stdio.h>50 #include <stdlib.h>51 52 49 #ifndef NDEBUG 53 50 54 51 #define assert(expr) \ 55 52 do { \ 56 if (!(expr)) { \ 57 printf("Assertion failed (%s) at file '%s', " \ 58 "line %d.\n", #expr, __FILE__, __LINE__); \ 59 abort(); \ 60 } \ 53 if (!(expr)) \ 54 assert_abort(#expr, __FILE__, __LINE__); \ 61 55 } while (0) 62 56 … … 67 61 #endif /* NDEBUG */ 68 62 63 extern void assert_abort(const char *, const char *, unsigned int) 64 __attribute__((noreturn)); 65 69 66 #endif 70 67 -
uspace/lib/c/include/async.h
r628d548 rb678410 340 340 (arg4), (answer)) 341 341 342 extern int async_data_read_start(int, void *, size_t); 342 #define async_data_read_start(p, buf, len) \ 343 async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE) 344 345 extern int async_data_read_start_generic(int, void *, size_t, int); 343 346 extern bool async_data_read_receive(ipc_callid_t *, size_t *); 344 347 extern int async_data_read_finalize(ipc_callid_t, const void *, size_t); … … 379 382 (arg4), (answer)) 380 383 381 extern int async_data_write_start(int, const void *, size_t); 384 #define async_data_write_start(p, buf, len) \ 385 async_data_write_start_generic((p), (buf), (len), IPC_XF_NONE) 386 387 extern int async_data_write_start_generic(int, const void *, size_t, int); 382 388 extern bool async_data_write_receive(ipc_callid_t *, size_t *); 383 389 extern int async_data_write_finalize(ipc_callid_t, void *, size_t); -
uspace/lib/c/include/errno.h
r628d548 rb678410 39 39 #include <fibril.h> 40 40 41 #define errno _errno41 #define errno (*(__errno())) 42 42 43 extern int _errno;43 extern int *__errno(void) __attribute__((const)); 44 44 45 45 #define EMFILE (-18) -
uspace/lib/c/include/fibril_synch.h
r628d548 rb678410 36 36 #define LIBC_FIBRIL_SYNCH_H_ 37 37 38 #include <async.h>39 38 #include <fibril.h> 40 39 #include <adt/list.h> 41 40 #include <libarch/tls.h> 42 41 #include <sys/time.h> 42 #include <bool.h> 43 43 44 44 typedef struct { 45 fibril_owner_info_t oi; /*Keep this the first thing. */45 fibril_owner_info_t oi; /**< Keep this the first thing. */ 46 46 int counter; 47 47 link_t waiters; … … 64 64 65 65 typedef struct { 66 fibril_owner_info_t oi; /*Keep this the first thing. */66 fibril_owner_info_t oi; /**< Keep this the first thing. */ 67 67 unsigned writers; 68 68 unsigned readers; -
uspace/lib/c/include/macros.h
r628d548 rb678410 39 39 #define max(a, b) ((a) > (b) ? (a) : (b)) 40 40 41 #define SIZE2KB(size) ((size) >> 10) 42 #define SIZE2MB(size) ((size) >> 20) 43 44 #define KB2SIZE(kb) ((kb) << 10) 45 #define MB2SIZE(mb) ((mb) << 20) 41 #define KiB2SIZE(kb) ((kb) << 10) 42 #define MiB2SIZE(mb) ((mb) << 20) 46 43 47 44 #define STRING(arg) STRING_ARG(arg) -
uspace/lib/c/include/str.h
r628d548 rb678410 89 89 extern int str_size_t(const char *, char **, unsigned int, bool, size_t *); 90 90 91 extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix); 91 extern void order_suffix(const uint64_t, uint64_t *, char *); 92 extern void bin_order_suffix(const uint64_t, uint64_t *, const char **, bool); 92 93 93 94 /*
Note:
See TracChangeset
for help on using the changeset viewer.