| /tags/0.4.1/uspace/lib/libc/include/string.h |
|---|
| 0,0 → 1,100 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STRING_H_ |
| #define LIBC_STRING_H_ |
| #include <mem.h> |
| #include <sys/types.h> |
| #include <bool.h> |
| #define U_SPECIAL '?' |
| /** No size limit constant */ |
| #define STR_NO_LIMIT ((size_t) -1) |
| /** Maximum size of a string containing @c length characters */ |
| #define STR_BOUNDS(length) ((length) << 2) |
| extern wchar_t str_decode(const char *str, size_t *offset, size_t sz); |
| extern int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t sz); |
| extern size_t str_size(const char *str); |
| extern size_t wstr_size(const wchar_t *str); |
| extern size_t str_lsize(const char *str, size_t max_len); |
| extern size_t wstr_lsize(const wchar_t *str, size_t max_len); |
| extern size_t str_length(const char *str); |
| extern size_t wstr_length(const wchar_t *wstr); |
| extern size_t str_nlength(const char *str, size_t size); |
| extern size_t wstr_nlength(const wchar_t *str, size_t size); |
| extern bool ascii_check(wchar_t ch); |
| extern bool chr_check(wchar_t ch); |
| extern int str_cmp(const char *s1, const char *s2); |
| extern int str_lcmp(const char *s1, const char *s2, size_t max_len); |
| extern void str_cpy(char *dest, size_t size, const char *src); |
| extern void str_ncpy(char *dest, size_t size, const char *src, size_t n); |
| extern void str_append(char *dest, size_t size, const char *src); |
| extern void wstr_nstr(char *dst, const wchar_t *src, size_t size); |
| extern char *str_chr(const char *str, wchar_t ch); |
| extern char *str_rchr(const char *str, wchar_t ch); |
| extern bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos); |
| extern bool wstr_remove(wchar_t *str, size_t pos); |
| extern char *str_dup(const char *); |
| /* |
| * TODO: Get rid of this. |
| */ |
| extern int stricmp(const char *, const char *); |
| extern long int strtol(const char *, char **, int); |
| extern unsigned long strtoul(const char *, char **, int); |
| extern char * strtok_r(char *, const char *, char **); |
| extern char * strtok(char *, const char *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/io/console.h |
|---|
| 0,0 → 1,86 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IO_CONSOLE_H_ |
| #define LIBC_IO_CONSOLE_H_ |
| #include <ipc/ipc.h> |
| #include <bool.h> |
| typedef enum { |
| KEY_PRESS, |
| KEY_RELEASE |
| } console_ev_type_t; |
| enum { |
| CONSOLE_CCAP_NONE = 0, |
| CONSOLE_CCAP_STYLE, |
| CONSOLE_CCAP_INDEXED, |
| CONSOLE_CCAP_RGB |
| }; |
| /** Console event structure. */ |
| typedef struct { |
| /** Press or release event. */ |
| console_ev_type_t type; |
| /** Keycode of the key that was pressed or released. */ |
| unsigned int key; |
| /** Bitmask of modifiers held. */ |
| unsigned int mods; |
| /** The character that was generated or '\0' for none. */ |
| wchar_t c; |
| } console_event_t; |
| extern void console_clear(int phone); |
| extern int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols); |
| extern void console_goto(int phone, ipcarg_t row, ipcarg_t col); |
| extern void console_set_style(int phone, int style); |
| extern void console_set_color(int phone, int fg_color, int bg_color, int flags); |
| extern void console_set_rgb_color(int phone, int fg_color, int bg_color); |
| extern void console_cursor_visibility(int phone, bool show); |
| extern int console_get_color_cap(int phone, int *ccap); |
| extern void console_kcon_enable(int phone); |
| extern bool console_get_event(int phone, console_event_t *event); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/io/printf_core.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_PRINTF_CORE_H_ |
| #define LIBC_PRINTF_CORE_H_ |
| #include <sys/types.h> |
| #include <stdarg.h> |
| /** Structure for specifying output methods for different printf clones. */ |
| typedef struct printf_spec { |
| /* String output function, returns number of printed characters or EOF */ |
| int (*str_write)(const char *, size_t, void *); |
| /* Wide string output function, returns number of printed characters or EOF */ |
| int (*wstr_write)(const wchar_t *, size_t, void *); |
| /* User data - output stream specification, state, locks, etc. */ |
| void *data; |
| } printf_spec_t; |
| int printf_core(const char *fmt, printf_spec_t *ps, va_list ap); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/io/klog.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Jakub Vana |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STREAM_H_ |
| #define LIBC_STREAM_H_ |
| #include <sys/types.h> |
| extern size_t klog_write(const void *buf, size_t size); |
| extern void klog_update(void); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/io/color.h |
|---|
| 0,0 → 1,55 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IO_COLOR_H_ |
| #define LIBC_IO_COLOR_H_ |
| enum console_color { |
| COLOR_BLACK = 0, |
| COLOR_BLUE = 1, |
| COLOR_GREEN = 2, |
| COLOR_CYAN = 3, |
| COLOR_RED = 4, |
| COLOR_MAGENTA = 5, |
| COLOR_YELLOW = 6, |
| COLOR_WHITE = 7, |
| CATTR_BRIGHT = 8, |
| CATTR_BLINK = 8 |
| }; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/io/style.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IO_STYLE_H_ |
| #define LIBC_IO_STYLE_H_ |
| enum console_style { |
| STYLE_NORMAL = 0, |
| STYLE_EMPHASIS = 1 |
| }; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/io/keycode.h |
|---|
| 0,0 → 1,220 |
| /* |
| * Copyright (c) 2009 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IO_KEYCODE_H_ |
| #define LIBC_IO_KEYCODE_H_ |
| /** Keycode definitions. |
| * |
| * A keycode identifies a key by its position on the keyboard, rather |
| * than by its label. For human readability, key positions are noted |
| * with the key label on a keyboard with US layout. This label has |
| * nothing to do with the character, that the key produces |
| * -- this is determined by the keymap. |
| * |
| * The keyboard model reflects a standard PC keyboard layout. |
| * Non-standard keyboards need to be mapped to this model in some |
| * logical way. Scancodes are mapped to keycodes with a scanmap. |
| * |
| * For easier mapping to the model and to emphasize the nature of keycodes, |
| * they really are organized here by position, rather than by label. |
| */ |
| enum keycode { |
| /* Main block row 1 */ |
| KC_BACKTICK = 1, |
| KC_1, |
| KC_2, |
| KC_3, |
| KC_4, |
| KC_5, |
| KC_6, |
| KC_7, |
| KC_8, |
| KC_9, |
| KC_0, |
| KC_MINUS, |
| KC_EQUALS, |
| KC_BACKSPACE, |
| /* Main block row 2 */ |
| KC_TAB, |
| KC_Q, |
| KC_W, |
| KC_E, |
| KC_R, |
| KC_T, |
| KC_Y, |
| KC_U, |
| KC_I, |
| KC_O, |
| KC_P, |
| KC_LBRACKET, |
| KC_RBRACKET, |
| /* Main block row 3 */ |
| KC_CAPS_LOCK, |
| KC_A, |
| KC_S, |
| KC_D, |
| KC_F, |
| KC_G, |
| KC_H, |
| KC_J, |
| KC_K, |
| KC_L, |
| KC_SEMICOLON, |
| KC_QUOTE, |
| KC_BACKSLASH, |
| KC_ENTER, |
| /* Main block row 4 */ |
| KC_LSHIFT, |
| KC_Z, |
| KC_X, |
| KC_C, |
| KC_V, |
| KC_B, |
| KC_N, |
| KC_M, |
| KC_COMMA, |
| KC_PERIOD, |
| KC_SLASH, |
| KC_RSHIFT, |
| /* Main block row 5 */ |
| KC_LCTRL, |
| KC_LALT, |
| KC_SPACE, |
| KC_RALT, |
| KC_RCTRL, |
| /* Function keys block */ |
| KC_ESCAPE, |
| KC_F1, |
| KC_F2, |
| KC_F3, |
| KC_F4, |
| KC_F5, |
| KC_F6, |
| KC_F7, |
| KC_F8, |
| KC_F9, |
| KC_F10, |
| KC_F11, |
| KC_F12, |
| KC_PRTSCR, |
| KC_SCROLL_LOCK, |
| KC_PAUSE, |
| /* Cursor keys block */ |
| KC_INSERT, |
| KC_HOME, |
| KC_PAGE_UP, |
| KC_DELETE, |
| KC_END, |
| KC_PAGE_DOWN, |
| KC_UP, |
| KC_LEFT, |
| KC_DOWN, |
| KC_RIGHT, |
| /* Numeric block */ |
| KC_NUM_LOCK, |
| KC_NSLASH, |
| KC_NTIMES, |
| KC_NMINUS, |
| KC_NPLUS, |
| KC_NENTER, |
| KC_N7, |
| KC_N8, |
| KC_N9, |
| KC_N4, |
| KC_N5, |
| KC_N6, |
| KC_N1, |
| KC_N2, |
| KC_N3, |
| KC_N0, |
| KC_NPERIOD |
| } keycode_t; |
| enum keymod { |
| KM_LSHIFT = 0x001, |
| KM_RSHIFT = 0x002, |
| KM_LCTRL = 0x004, |
| KM_RCTRL = 0x008, |
| KM_LALT = 0x010, |
| KM_RALT = 0x020, |
| KM_CAPS_LOCK = 0x040, |
| KM_NUM_LOCK = 0x080, |
| KM_SCROLL_LOCK = 0x100, |
| KM_SHIFT = KM_LSHIFT | KM_RSHIFT, |
| KM_CTRL = KM_LCTRL | KM_RCTRL, |
| KM_ALT = KM_LALT | KM_RALT |
| } keymod_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/console.h |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IPC_CONSOLE_H_ |
| #define LIBC_IPC_CONSOLE_H_ |
| #include <ipc/ipc.h> |
| #include <ipc/vfs.h> |
| typedef enum { |
| CONSOLE_GET_SIZE = VFS_OUT_LAST, |
| CONSOLE_GET_COLOR_CAP, |
| CONSOLE_GET_EVENT, |
| CONSOLE_GOTO, |
| CONSOLE_CLEAR, |
| CONSOLE_SET_STYLE, |
| CONSOLE_SET_COLOR, |
| CONSOLE_SET_RGB_COLOR, |
| CONSOLE_CURSOR_VISIBILITY, |
| CONSOLE_KCON_ENABLE |
| } console_request_t; |
| #endif |
| /** @} |
| */ |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/0.4.1/uspace/lib/libc/include/ipc/fb.h |
|---|
| 0,0 → 1,85 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_FB_H_ |
| #define LIBC_FB_H_ |
| #include <ipc/ipc.h> |
| typedef enum { |
| FB_PUTCHAR = IPC_FIRST_USER_METHOD, |
| FB_CLEAR, |
| FB_GET_CSIZE, |
| FB_GET_COLOR_CAP, |
| FB_CURSOR_VISIBILITY, |
| FB_CURSOR_GOTO, |
| FB_SCROLL, |
| FB_VIEWPORT_SWITCH, |
| FB_VIEWPORT_CREATE, |
| FB_VIEWPORT_DELETE, |
| FB_SET_STYLE, |
| FB_SET_COLOR, |
| FB_SET_RGB_COLOR, |
| FB_GET_RESOLUTION, |
| FB_DRAW_TEXT_DATA, |
| FB_FLUSH, |
| FB_DRAW_PPM, |
| FB_PREPARE_SHM, |
| FB_DROP_SHM, |
| FB_SHM2PIXMAP, |
| FB_VP_DRAW_PIXMAP, |
| FB_VP2PIXMAP, |
| FB_DROP_PIXMAP, |
| FB_ANIM_CREATE, |
| FB_ANIM_DROP, |
| FB_ANIM_ADDPIXMAP, |
| FB_ANIM_CHGVP, |
| FB_ANIM_START, |
| FB_ANIM_STOP, |
| FB_POINTER_MOVE, |
| FB_SCREEN_YIELD, |
| FB_SCREEN_RECLAIM |
| } fb_request_t; |
| enum { |
| FB_CCAP_NONE = 0, |
| FB_CCAP_STYLE, |
| FB_CCAP_INDEXED, |
| FB_CCAP_RGB |
| }; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/ns.h |
|---|
| 0,0 → 1,50 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBIPC_NS_H_ |
| #define LIBIPC_NS_H_ |
| #include <ipc/ipc.h> |
| typedef enum { |
| NS_PING = IPC_FIRST_USER_METHOD, |
| NS_TASK_WAIT, |
| NS_ID_INTRO, |
| NS_RETVAL |
| } ns_request_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/vfs.h |
|---|
| 0,0 → 1,151 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IPC_VFS_H_ |
| #define LIBC_IPC_VFS_H_ |
| #include <sys/types.h> |
| #include <ipc/ipc.h> |
| #define FS_NAME_MAXLEN 20 |
| #define MAX_PATH_LEN (64 * 1024) |
| #define PLB_SIZE (2 * MAX_PATH_LEN) |
| /* Basic types. */ |
| typedef int16_t fs_handle_t; |
| typedef uint32_t fs_index_t; |
| /** |
| * A structure like this is passed to VFS by each individual FS upon its |
| * registration. It assosiates a human-readable identifier with each |
| * registered FS. |
| */ |
| typedef struct { |
| /** Unique identifier of the fs. */ |
| char name[FS_NAME_MAXLEN + 1]; |
| } vfs_info_t; |
| typedef enum { |
| VFS_IN_OPEN = IPC_FIRST_USER_METHOD, |
| VFS_IN_OPEN_NODE, |
| VFS_IN_READ, |
| VFS_IN_WRITE, |
| VFS_IN_SEEK, |
| VFS_IN_TRUNCATE, |
| VFS_IN_FSTAT, |
| VFS_IN_CLOSE, |
| VFS_IN_MOUNT, |
| VFS_IN_UNMOUNT, |
| VFS_IN_SYNC, |
| VFS_IN_REGISTER, |
| VFS_IN_MKDIR, |
| VFS_IN_UNLINK, |
| VFS_IN_RENAME, |
| VFS_IN_STAT |
| } vfs_in_request_t; |
| typedef enum { |
| VFS_OUT_OPEN_NODE = IPC_FIRST_USER_METHOD, |
| VFS_OUT_READ, |
| VFS_OUT_WRITE, |
| VFS_OUT_TRUNCATE, |
| VFS_OUT_CLOSE, |
| VFS_OUT_MOUNT, |
| VFS_OUT_MOUNTED, |
| VFS_OUT_UNMOUNT, |
| VFS_OUT_SYNC, |
| VFS_OUT_STAT, |
| VFS_OUT_LOOKUP, |
| VFS_OUT_DESTROY, |
| VFS_OUT_LAST |
| } vfs_out_request_t; |
| /* |
| * Lookup flags. |
| */ |
| /** |
| * No lookup flags used. |
| */ |
| #define L_NONE 0 |
| /** |
| * Lookup will succeed only if the object is a regular file. If L_CREATE is |
| * specified, an empty file will be created. This flag is mutually exclusive |
| * with L_DIRECTORY. |
| */ |
| #define L_FILE 1 |
| /** |
| * Lookup wil succeed only if the object is a directory. If L_CREATE is |
| * specified, an empty directory will be created. This flag is mutually |
| * exclusive with L_FILE. |
| */ |
| #define L_DIRECTORY 2 |
| /** |
| * When used with L_CREATE, L_EXCLUSIVE will cause the lookup to fail if the |
| * object already exists. L_EXCLUSIVE is implied when L_DIRECTORY is used. |
| */ |
| #define L_EXCLUSIVE 4 |
| /** |
| * L_CREATE is used for creating both regular files and directories. |
| */ |
| #define L_CREATE 8 |
| /** |
| * L_LINK is used for linking to an already existing nodes. |
| */ |
| #define L_LINK 16 |
| /** |
| * L_UNLINK is used to remove leaves from the file system namespace. This flag |
| * cannot be passed directly by the client, but will be set by VFS during |
| * VFS_UNLINK. |
| */ |
| #define L_UNLINK 32 |
| /** |
| * L_OPEN is used to indicate that the lookup operation is a part of VFS_OPEN |
| * call from the client. This means that the server might allocate some |
| * resources for the opened file. This flag cannot be passed directly by the |
| * client. |
| */ |
| #define L_OPEN 64 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/devmap.h |
|---|
| 0,0 → 1,78 |
| /* |
| * Copyright (c) 2007 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup devmap |
| * @{ |
| */ |
| #ifndef DEVMAP_DEVMAP_H_ |
| #define DEVMAP_DEVMAP_H_ |
| #include <atomic.h> |
| #include <ipc/ipc.h> |
| #include <adt/list.h> |
| #define DEVMAP_NAME_MAXLEN 255 |
| typedef ipcarg_t dev_handle_t; |
| typedef enum { |
| DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD, |
| DEVMAP_DRIVER_UNREGISTER, |
| DEVMAP_DEVICE_REGISTER, |
| DEVMAP_DEVICE_UNREGISTER, |
| DEVMAP_DEVICE_GET_NAME, |
| DEVMAP_DEVICE_GET_HANDLE, |
| DEVMAP_DEVICE_NULL_CREATE, |
| DEVMAP_DEVICE_NULL_DESTROY, |
| DEVMAP_DEVICE_GET_COUNT, |
| DEVMAP_DEVICE_GET_DEVICES |
| } devmap_request_t; |
| /** Interface provided by devmap. |
| * |
| * Every process that connects to devmap must ask one of following |
| * interfaces otherwise connection will be refused. |
| * |
| */ |
| typedef enum { |
| /** Connect as device driver */ |
| DEVMAP_DRIVER = 1, |
| /** Connect as client */ |
| DEVMAP_CLIENT, |
| /** Create new connection to instance of device that |
| is specified by second argument of call. */ |
| DEVMAP_CONNECT_TO_DEVICE |
| } devmap_interface_t; |
| typedef struct { |
| dev_handle_t handle; |
| char name[DEVMAP_NAME_MAXLEN + 1]; |
| } dev_desc_t; |
| #endif |
| /tags/0.4.1/uspace/lib/libc/include/ipc/ipc.h |
|---|
| 0,0 → 1,301 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBIPC_IPC_H_ |
| #define LIBIPC_IPC_H_ |
| #include <task.h> |
| #include <kernel/ipc/ipc.h> |
| #include <kernel/ddi/irq.h> |
| #include <sys/types.h> |
| #include <kernel/synch/synch.h> |
| #define IPC_FLAG_BLOCKING 0x01 |
| typedef sysarg_t ipcarg_t; |
| typedef struct { |
| ipcarg_t args[IPC_CALL_LEN]; |
| ipcarg_t in_phone_hash; |
| } ipc_call_t; |
| typedef sysarg_t ipc_callid_t; |
| typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *); |
| /* |
| * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow(). |
| * They are in the form ipc_call_sync_m_n(), where m denotes the number of |
| * arguments of payload and n denotes number of return values. Whenever |
| * possible, the fast version is used. |
| */ |
| #define ipc_call_sync_0_0(phoneid, method) \ |
| ipc_call_sync_fast((phoneid), (method), 0, 0, 0, 0, 0, 0, 0, 0) |
| #define ipc_call_sync_0_1(phoneid, method, res1) \ |
| ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), 0, 0, 0, 0) |
| #define ipc_call_sync_0_2(phoneid, method, res1, res2) \ |
| ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), 0, 0, 0) |
| #define ipc_call_sync_0_3(phoneid, method, res1, res2, res3) \ |
| ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \ |
| 0, 0) |
| #define ipc_call_sync_0_4(phoneid, method, res1, res2, res3, res4) \ |
| ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \ |
| (res4), 0) |
| #define ipc_call_sync_0_5(phoneid, method, res1, res2, res3, res4, res5) \ |
| ipc_call_sync_fast((phoneid), (method), 0, 0, 0, (res1), (res2), (res3), \ |
| (res4), (res5)) |
| #define ipc_call_sync_1_0(phoneid, method, arg1) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, 0, 0, 0, 0, 0) |
| #define ipc_call_sync_1_1(phoneid, method, arg1, res1) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), 0, 0, 0, 0) |
| #define ipc_call_sync_1_2(phoneid, method, arg1, res1, res2) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), 0, \ |
| 0, 0) |
| #define ipc_call_sync_1_3(phoneid, method, arg1, res1, res2, res3) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \ |
| (res3), 0, 0) |
| #define ipc_call_sync_1_4(phoneid, method, arg1, res1, res2, res3, res4) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \ |
| (res3), (res4), 0) |
| #define ipc_call_sync_1_5(phoneid, method, arg1, res1, res2, res3, res4, \ |
| res5) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), 0, 0, (res1), (res2), \ |
| (res3), (res4), (res5)) |
| #define ipc_call_sync_2_0(phoneid, method, arg1, arg2) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, 0, 0, 0, \ |
| 0, 0) |
| #define ipc_call_sync_2_1(phoneid, method, arg1, arg2, res1) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), 0, 0, \ |
| 0, 0) |
| #define ipc_call_sync_2_2(phoneid, method, arg1, arg2, res1, res2) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \ |
| (res2), 0, 0, 0) |
| #define ipc_call_sync_2_3(phoneid, method, arg1, arg2, res1, res2, res3) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \ |
| (res2), (res3), 0, 0) |
| #define ipc_call_sync_2_4(phoneid, method, arg1, arg2, res1, res2, res3, \ |
| res4) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \ |
| (res2), (res3), (res4), 0) |
| #define ipc_call_sync_2_5(phoneid, method, arg1, arg2, res1, res2, res3, \ |
| res4, res5)\ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), 0, (res1), \ |
| (res2), (res3), (res4), (res5)) |
| #define ipc_call_sync_3_0(phoneid, method, arg1, arg2, arg3) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, 0, 0, \ |
| 0, 0) |
| #define ipc_call_sync_3_1(phoneid, method, arg1, arg2, arg3, res1) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \ |
| 0, 0, 0, 0) |
| #define ipc_call_sync_3_2(phoneid, method, arg1, arg2, arg3, res1, res2) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), (res1), \ |
| (res2), 0, 0, 0) |
| #define ipc_call_sync_3_3(phoneid, method, arg1, arg2, arg3, res1, res2, \ |
| res3) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (res1), (res2), (res3), 0, 0) |
| #define ipc_call_sync_3_4(phoneid, method, arg1, arg2, arg3, res1, res2, \ |
| res3, res4) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (res1), (res2), (res3), (res4), 0) |
| #define ipc_call_sync_3_5(phoneid, method, arg1, arg2, arg3, res1, res2, \ |
| res3, res4, res5) \ |
| ipc_call_sync_fast((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (res1), (res2), (res3), (res4), (res5)) |
| #define ipc_call_sync_4_0(phoneid, method, arg1, arg2, arg3, arg4) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \ |
| 0, 0, 0, 0, 0) |
| #define ipc_call_sync_4_1(phoneid, method, arg1, arg2, arg3, arg4, res1) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \ |
| (res1), 0, 0, 0, 0) |
| #define ipc_call_sync_4_2(phoneid, method, arg1, arg2, arg3, arg4, res1, res2) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), 0, \ |
| (res1), (res2), 0, 0, 0) |
| #define ipc_call_sync_4_3(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \ |
| res3) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), 0, (res1), (res2), (res3), 0, 0) |
| #define ipc_call_sync_4_4(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \ |
| res3, res4) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), 0, (res1), (res2), (res3), (res4), 0) |
| #define ipc_call_sync_4_5(phoneid, method, arg1, arg2, arg3, arg4, res1, res2, \ |
| res3, res4, res5) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), 0, (res1), (res2), (res3), (res4), (res5)) |
| #define ipc_call_sync_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), 0, 0, 0, 0, 0) |
| #define ipc_call_sync_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (res1), 0, 0, 0, 0) |
| #define ipc_call_sync_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \ |
| res2) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), (arg5), (res1), (res2), 0, 0, 0) |
| #define ipc_call_sync_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \ |
| res2, res3) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), (arg5), (res1), (res2), (res3), 0, 0) |
| #define ipc_call_sync_5_4(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \ |
| res2, res3, res4) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), (arg5), (res1), (res2), (res3), (res4), 0) |
| #define ipc_call_sync_5_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, res1, \ |
| res2, res3, res4, res5) \ |
| ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), (arg5), (res1), (res2), (res3), (res4), (res5)) |
| extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t, |
| ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *); |
| extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t, |
| ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, |
| ipcarg_t *); |
| extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int); |
| extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t); |
| static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data) |
| { |
| return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT); |
| } |
| extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *); |
| /* |
| * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow(). |
| * They are in the form of ipc_answer_m(), where m is the number of return |
| * arguments. The macros decide between the fast and the slow version according |
| * to m. |
| */ |
| #define ipc_answer_0(callid, retval) \ |
| ipc_answer_fast((callid), (retval), 0, 0, 0, 0) |
| #define ipc_answer_1(callid, retval, arg1) \ |
| ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0) |
| #define ipc_answer_2(callid, retval, arg1, arg2) \ |
| ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0) |
| #define ipc_answer_3(callid, retval, arg1, arg2, arg3) \ |
| ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0) |
| #define ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4) \ |
| ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4)) |
| #define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \ |
| ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5)) |
| extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t, |
| ipcarg_t, ipcarg_t); |
| extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t, |
| ipcarg_t, ipcarg_t, ipcarg_t); |
| /* |
| * User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow(). |
| * They are in the form of ipc_call_async_m(), where m is the number of payload |
| * arguments. The macros decide between the fast and the slow version according |
| * to m. |
| */ |
| #define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \ |
| ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \ |
| (callback), (can_preempt)) |
| #define ipc_call_async_1(phoneid, method, arg1, private, callback, \ |
| can_preempt) \ |
| ipc_call_async_fast((phoneid), (method), (arg1), 0, 0, 0, (private), \ |
| (callback), (can_preempt)) |
| #define ipc_call_async_2(phoneid, method, arg1, arg2, private, callback, \ |
| can_preempt) \ |
| ipc_call_async_fast((phoneid), (method), (arg1), (arg2), 0, 0, \ |
| (private), (callback), (can_preempt)) |
| #define ipc_call_async_3(phoneid, method, arg1, arg2, arg3, private, callback, \ |
| can_preempt) \ |
| ipc_call_async_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, \ |
| (private), (callback), (can_preempt)) |
| #define ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, private, \ |
| callback, can_preempt) \ |
| ipc_call_async_fast((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), (private), (callback), (can_preempt)) |
| #define ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, \ |
| private, callback, can_preempt) \ |
| ipc_call_async_slow((phoneid), (method), (arg1), (arg2), (arg3), \ |
| (arg4), (arg5), (private), (callback), (can_preempt)) |
| extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t, |
| ipcarg_t, void *, ipc_async_callback_t, int); |
| extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t, |
| ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int); |
| extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *); |
| extern int ipc_connect_me_to(int, int, int, int); |
| extern int ipc_connect_me_to_blocking(int, int, int, int); |
| extern int ipc_hangup(int); |
| extern int ipc_register_irq(int, int, int, irq_code_t *); |
| extern int ipc_unregister_irq(int, int); |
| extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int); |
| extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, |
| ipcarg_t, ipcarg_t, ipcarg_t, int); |
| /* |
| * User-friendly wrappers for ipc_share_in_start(). |
| */ |
| #define ipc_share_in_start_0_0(phoneid, dst, size) \ |
| ipc_share_in_start((phoneid), (dst), (size), 0, NULL) |
| #define ipc_share_in_start_0_1(phoneid, dst, size, flags) \ |
| ipc_share_in_start((phoneid), (dst), (size), 0, (flags)) |
| #define ipc_share_in_start_1_0(phoneid, dst, size, arg) \ |
| ipc_share_in_start((phoneid), (dst), (size), (arg), NULL) |
| #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \ |
| ipc_share_in_start((phoneid), (dst), (size), (arg), (flags)) |
| extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *); |
| extern int ipc_share_in_receive(ipc_callid_t *, size_t *); |
| extern int ipc_share_in_finalize(ipc_callid_t, void *, int ); |
| extern int ipc_share_out_start(int, void *, int); |
| extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *); |
| extern int ipc_share_out_finalize(ipc_callid_t, void *); |
| extern int ipc_data_read_start(int, void *, size_t); |
| extern int ipc_data_read_receive(ipc_callid_t *, size_t *); |
| extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t); |
| extern int ipc_data_write_start(int, const void *, size_t); |
| extern int ipc_data_write_receive(ipc_callid_t *, size_t *); |
| extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t); |
| extern int ipc_connect_kbox(task_id_t); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/loader.h |
|---|
| 0,0 → 1,53 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IPC_LOADER_H_ |
| #define LIBC_IPC_LOADER_H_ |
| #include <ipc/ipc.h> |
| typedef enum { |
| LOADER_HELLO = IPC_FIRST_USER_METHOD, |
| LOADER_GET_TASKID, |
| LOADER_SET_PATHNAME, |
| LOADER_SET_ARGS, |
| LOADER_SET_FILES, |
| LOADER_LOAD, |
| LOADER_RUN |
| } loader_request_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/bd.h |
|---|
| 0,0 → 1,48 |
| /* |
| * Copyright (c) 2009 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_IPC_BD_H_ |
| #define LIBC_IPC_BD_H_ |
| #include <ipc/ipc.h> |
| typedef enum { |
| BD_READ_BLOCK = IPC_FIRST_USER_METHOD, |
| BD_WRITE_BLOCK |
| } bd_request_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/services.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** |
| * @file services.h |
| * @brief List of all known services and their codes. |
| */ |
| #ifndef LIBIPC_SERVICES_H_ |
| #define LIBIPC_SERVICES_H_ |
| typedef enum { |
| SERVICE_LOAD = 1, |
| SERVICE_PCI, |
| SERVICE_KEYBOARD, |
| SERVICE_VIDEO, |
| SERVICE_CONSOLE, |
| SERVICE_VFS, |
| SERVICE_DEVMAP, |
| SERVICE_FHC, |
| SERVICE_OBIO |
| } services_t; |
| /* Memory area to be received from NS */ |
| #define SERVICE_MEM_REALTIME 1 |
| #define SERVICE_MEM_KLOG 2 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ipc/bus.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcipc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_BUS_H_ |
| #define LIBC_BUS_H_ |
| #include <ipc/ipc.h> |
| typedef enum { |
| BUS_CLEAR_INTERRUPT = IPC_FIRST_USER_METHOD |
| } bus_request_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/fibril.h |
|---|
| 0,0 → 1,99 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_FIBRIL_H_ |
| #define LIBC_FIBRIL_H_ |
| #include <libarch/fibril.h> |
| #include <adt/list.h> |
| #include <libarch/tls.h> |
| #ifndef context_set |
| #define context_set(c, _pc, stack, size, ptls) \ |
| (c)->pc = (sysarg_t) (_pc); \ |
| (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \ |
| (c)->tls = (sysarg_t) (ptls); |
| #endif /* context_set */ |
| #define FIBRIL_SERIALIZED 1 |
| #define FIBRIL_WRITER 2 |
| typedef enum { |
| FIBRIL_PREEMPT, |
| FIBRIL_TO_MANAGER, |
| FIBRIL_FROM_MANAGER, |
| FIBRIL_FROM_DEAD |
| } fibril_switch_type_t; |
| typedef sysarg_t fid_t; |
| struct fibril { |
| link_t link; |
| context_t ctx; |
| void *stack; |
| void *arg; |
| int (*func)(void *); |
| tcb_t *tcb; |
| struct fibril *clean_after_me; |
| int retval; |
| int flags; |
| }; |
| typedef struct fibril fibril_t; |
| /** Fibril-local variable specifier */ |
| #define fibril_local __thread |
| extern int context_save(context_t *c) __attribute__ ((returns_twice)); |
| extern void context_restore(context_t *c) __attribute__ ((noreturn)); |
| extern fid_t fibril_create(int (*func)(void *), void *arg); |
| extern fibril_t *fibril_setup(void); |
| extern void fibril_teardown(fibril_t *f); |
| extern int fibril_switch(fibril_switch_type_t stype); |
| extern void fibril_add_ready(fid_t fid); |
| extern void fibril_add_manager(fid_t fid); |
| extern void fibril_remove_manager(void); |
| extern fid_t fibril_get_id(void); |
| extern void fibril_inc_sercount(void); |
| extern void fibril_dec_sercount(void); |
| static inline int fibril_yield(void) { |
| return fibril_switch(FIBRIL_PREEMPT); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/task.h |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_TASK_H_ |
| #define LIBC_TASK_H_ |
| #include <sys/types.h> |
| typedef uint64_t task_id_t; |
| typedef enum { |
| TASK_EXIT_NORMAL, |
| TASK_EXIT_UNEXPECTED |
| } task_exit_t; |
| extern task_id_t task_get_id(void); |
| extern int task_set_name(const char *name); |
| extern task_id_t task_spawn(const char *path, char *const argv[]); |
| extern int task_wait(task_id_t id, task_exit_t *texit, int *retval); |
| extern int task_retval(int val); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/getopt.h |
|---|
| 0,0 → 1,71 |
| /* $NetBSD: getopt.h,v 1.10.6.1 2008/05/18 12:30:09 yamt Exp $ */ |
| /*- |
| * Copyright (c) 2000 The NetBSD Foundation, Inc. |
| * All rights reserved. |
| * |
| * This code is derived from software contributed to The NetBSD Foundation |
| * by Dieter Baron and Thomas Klausner. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
| * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */ |
| #ifndef _GETOPT_H_ |
| #define _GETOPT_H_ |
| #include <unistd.h> |
| /* |
| * Gnu like getopt_long() and BSD4.4 getsubopt()/optreset extensions |
| */ |
| #define no_argument 0 |
| #define required_argument 1 |
| #define optional_argument 2 |
| struct option { |
| /* name of long option */ |
| const char *name; |
| /* |
| * one of no_argument, required_argument, and optional_argument: |
| * whether option takes an argument |
| */ |
| int has_arg; |
| /* if not NULL, set *flag to val when option found */ |
| int *flag; |
| /* if flag not NULL, value to set *flag to; else return value */ |
| int val; |
| }; |
| /* HelenOS Port - These need to be exposed for legacy getopt() */ |
| extern const char *optarg; |
| extern int optind, opterr, optopt; |
| extern int optreset; |
| int getopt_long(int, char * const *, const char *, |
| const struct option *, int *); |
| /* HelenOS Port : Expose legacy getopt() */ |
| int getopt(int, char * const [], const char *); |
| #endif /* !_GETOPT_H_ */ |
| /tags/0.4.1/uspace/lib/libc/include/vfs/vfs.h |
|---|
| 0,0 → 1,72 |
| /* |
| * Copyright (c) 2007 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_VFS_H_ |
| #define LIBC_VFS_H_ |
| #include <sys/types.h> |
| #include <ipc/vfs.h> |
| #include <ipc/devmap.h> |
| #include <stdio.h> |
| /** |
| * This type is a libc version of the VFS triplet. |
| * It uniquelly identifies a file system node within a file system instance. |
| */ |
| typedef struct { |
| fs_handle_t fs_handle; |
| dev_handle_t dev_handle; |
| fs_index_t index; |
| } fdi_node_t; |
| extern char *absolutize(const char *, size_t *); |
| extern int mount(const char *, const char *, const char *, const char *, |
| unsigned int); |
| extern void __stdio_init(int filc, fdi_node_t *filv[]); |
| extern void __stdio_done(void); |
| extern int open_node(fdi_node_t *, int); |
| extern int fd_phone(int); |
| extern int fd_node(int, fdi_node_t *); |
| extern FILE *fopen_node(fdi_node_t *, const char *); |
| extern int fphone(FILE *); |
| extern int fnode(FILE *, fdi_node_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/vfs/canonify.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_VFS_CANONIFY_H_ |
| #define LIBC_VFS_CANONIFY_H_ |
| #include <sys/types.h> |
| extern char *canonify(char *, size_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/async.h |
|---|
| 0,0 → 1,262 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ASYNC_H_ |
| #define LIBC_ASYNC_H_ |
| #include <ipc/ipc.h> |
| #include <fibril.h> |
| #include <sys/time.h> |
| #include <atomic.h> |
| #include <bool.h> |
| typedef ipc_callid_t aid_t; |
| typedef void (*async_client_conn_t)(ipc_callid_t callid, ipc_call_t *call); |
| extern atomic_t async_futex; |
| extern int __async_init(void); |
| extern ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs); |
| static inline ipc_callid_t async_get_call(ipc_call_t *data) |
| { |
| return async_get_call_timeout(data, 0); |
| } |
| static inline void async_manager(void) |
| { |
| fibril_switch(FIBRIL_TO_MANAGER); |
| } |
| /* |
| * User-friendly wrappers for async_send_fast() and async_send_slow(). The |
| * macros are in the form async_send_m(), where m denotes the number of payload |
| * arguments. Each macros chooses between the fast and the slow version based |
| * on m. |
| */ |
| #define async_send_0(phoneid, method, dataptr) \ |
| async_send_fast((phoneid), (method), 0, 0, 0, 0, (dataptr)) |
| #define async_send_1(phoneid, method, arg1, dataptr) \ |
| async_send_fast((phoneid), (method), (arg1), 0, 0, 0, (dataptr)) |
| #define async_send_2(phoneid, method, arg1, arg2, dataptr) \ |
| async_send_fast((phoneid), (method), (arg1), (arg2), 0, 0, (dataptr)) |
| #define async_send_3(phoneid, method, arg1, arg2, arg3, dataptr) \ |
| async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (dataptr)) |
| #define async_send_4(phoneid, method, arg1, arg2, arg3, arg4, dataptr) \ |
| async_send_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (dataptr)) |
| #define async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, dataptr) \ |
| async_send_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (dataptr)) |
| extern aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr); |
| extern aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, |
| ipc_call_t *dataptr); |
| extern void async_wait_for(aid_t amsgid, ipcarg_t *result); |
| extern int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, |
| suseconds_t timeout); |
| extern fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid, |
| ipc_call_t *call, void (*cthread)(ipc_callid_t, ipc_call_t *)); |
| extern void async_usleep(suseconds_t timeout); |
| extern void async_create_manager(void); |
| extern void async_destroy_manager(void); |
| extern void async_set_client_connection(async_client_conn_t conn); |
| extern void async_set_interrupt_received(async_client_conn_t conn); |
| /* Wrappers for simple communication */ |
| #define async_msg_0(phone, method) \ |
| ipc_call_async_0((phone), (method), NULL, NULL, true) |
| #define async_msg_1(phone, method, arg1) \ |
| ipc_call_async_1((phone), (method), (arg1), NULL, NULL, \ |
| true) |
| #define async_msg_2(phone, method, arg1, arg2) \ |
| ipc_call_async_2((phone), (method), (arg1), (arg2), NULL, NULL, \ |
| true) |
| #define async_msg_3(phone, method, arg1, arg2, arg3) \ |
| ipc_call_async_3((phone), (method), (arg1), (arg2), (arg3), NULL, NULL, \ |
| true) |
| #define async_msg_4(phone, method, arg1, arg2, arg3, arg4) \ |
| ipc_call_async_4((phone), (method), (arg1), (arg2), (arg3), (arg4), NULL, \ |
| NULL, true) |
| #define async_msg_5(phone, method, arg1, arg2, arg3, arg4, arg5) \ |
| ipc_call_async_5((phone), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), NULL, NULL, true) |
| /* |
| * User-friendly wrappers for async_req_fast() and async_req_slow(). The macros |
| * are in the form async_req_m_n(), where m is the number of payload arguments |
| * and n is the number of return arguments. The macros decide between the fast |
| * and slow verion based on m. |
| */ |
| #define async_req_0_0(phoneid, method) \ |
| async_req_fast((phoneid), (method), 0, 0, 0, 0, NULL, NULL, NULL, NULL, \ |
| NULL) |
| #define async_req_0_1(phoneid, method, r1) \ |
| async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), NULL, NULL, NULL, \ |
| NULL) |
| #define async_req_0_2(phoneid, method, r1, r2) \ |
| async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), NULL, NULL, \ |
| NULL) |
| #define async_req_0_3(phoneid, method, r1, r2, r3) \ |
| async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), NULL, \ |
| NULL) |
| #define async_req_0_4(phoneid, method, r1, r2, r3, r4) \ |
| async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \ |
| NULL) |
| #define async_req_0_5(phoneid, method, r1, r2, r3, r4, r5) \ |
| async_req_fast((phoneid), (method), 0, 0, 0, 0, (r1), (r2), (r3), (r4), \ |
| (r5)) |
| #define async_req_1_0(phoneid, method, arg1) \ |
| async_req_fast((phoneid), (method), (arg1), 0, 0, 0, NULL, NULL, NULL, \ |
| NULL, NULL) |
| #define async_req_1_1(phoneid, method, arg1, rc1) \ |
| async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), NULL, NULL, \ |
| NULL, NULL) |
| #define async_req_1_2(phoneid, method, arg1, rc1, rc2) \ |
| async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), NULL, \ |
| NULL, NULL) |
| #define async_req_1_3(phoneid, method, arg1, rc1, rc2, rc3) \ |
| async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ |
| NULL, NULL) |
| #define async_req_1_4(phoneid, method, arg1, rc1, rc2, rc3, rc4) \ |
| async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ |
| (rc4), NULL) |
| #define async_req_1_5(phoneid, method, arg1, rc1, rc2, rc3, rc4, rc5) \ |
| async_req_fast((phoneid), (method), (arg1), 0, 0, 0, (rc1), (rc2), (rc3), \ |
| (rc4), (rc5)) |
| #define async_req_2_0(phoneid, method, arg1, arg2) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, NULL, NULL, \ |
| NULL, NULL, NULL) |
| #define async_req_2_1(phoneid, method, arg1, arg2, rc1) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), NULL, \ |
| NULL, NULL, NULL) |
| #define async_req_2_2(phoneid, method, arg1, arg2, rc1, rc2) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ |
| NULL, NULL, NULL) |
| #define async_req_2_3(phoneid, method, arg1, arg2, rc1, rc2, rc3) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ |
| (rc3), NULL, NULL) |
| #define async_req_2_4(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ |
| (rc3), (rc4), NULL) |
| #define async_req_2_5(phoneid, method, arg1, arg2, rc1, rc2, rc3, rc4, rc5) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), 0, 0, (rc1), (rc2), \ |
| (rc3), (rc4), (rc5)) |
| #define async_req_3_0(phoneid, method, arg1, arg2, arg3) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, NULL, NULL, \ |
| NULL, NULL, NULL) |
| #define async_req_3_1(phoneid, method, arg1, arg2, arg3, rc1) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ |
| NULL, NULL, NULL, NULL) |
| #define async_req_3_2(phoneid, method, arg1, arg2, arg3, rc1, rc2) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ |
| (rc2), NULL, NULL, NULL) |
| #define async_req_3_3(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ |
| (rc2), (rc3), NULL, NULL) |
| #define async_req_3_4(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ |
| (rc2), (rc3), (rc4), NULL) |
| #define async_req_3_5(phoneid, method, arg1, arg2, arg3, rc1, rc2, rc3, rc4, \ |
| rc5) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), 0, (rc1), \ |
| (rc2), (rc3), (rc4), (rc5)) |
| #define async_req_4_0(phoneid, method, arg1, arg2, arg3, arg4) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), NULL, \ |
| NULL, NULL, NULL, NULL) |
| #define async_req_4_1(phoneid, method, arg1, arg2, arg3, arg4, rc1) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ |
| NULL, NULL, NULL, NULL) |
| #define async_req_4_2(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ |
| (rc2), NULL, NULL, NULL) |
| #define async_req_4_3(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), (rc1), \ |
| (rc2), (rc3), NULL, NULL) |
| #define async_req_4_4(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ |
| rc4) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (rc1), (rc2), (rc3), (rc4), NULL) |
| #define async_req_4_5(phoneid, method, arg1, arg2, arg3, arg4, rc1, rc2, rc3, \ |
| rc4, rc5) \ |
| async_req_fast((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (rc1), (rc2), (rc3), (rc4), (rc5)) |
| #define async_req_5_0(phoneid, method, arg1, arg2, arg3, arg4, arg5) \ |
| async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), NULL, NULL, NULL, NULL, NULL) |
| #define async_req_5_1(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1) \ |
| async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (rc1), NULL, NULL, NULL, NULL) |
| #define async_req_5_2(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2) \ |
| async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (rc1), (rc2), NULL, NULL, NULL) |
| #define async_req_5_3(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ |
| rc3) \ |
| async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (rc1), (rc2), (rc3), NULL, NULL) |
| #define async_req_5_4(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ |
| rc3, rc4) \ |
| async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (rc1), (rc2), (rc3), (rc4), NULL) |
| #define async_req_5_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, rc1, rc2, \ |
| rc3, rc4, rc5) \ |
| async_req_slow((phoneid), (method), (arg1), (arg2), (arg3), (arg4), \ |
| (arg5), (rc1), (rc2), (rc3), (rc4), (rc5)) |
| extern ipcarg_t async_req_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t *r1, ipcarg_t *r2, |
| ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5); |
| extern ipcarg_t async_req_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *r1, |
| ipcarg_t *r2, ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5); |
| static inline void async_serialize_start(void) |
| { |
| fibril_inc_sercount(); |
| } |
| static inline void async_serialize_end(void) |
| { |
| fibril_dec_sercount(); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/stdlib.h |
|---|
| 0,0 → 1,62 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STDLIB_H_ |
| #define LIBC_STDLIB_H_ |
| #include <unistd.h> |
| #include <malloc.h> |
| #define abort() _exit(1) |
| #define exit(status) _exit((status)) |
| #define RAND_MAX 714025 |
| extern long int random(void); |
| extern void srandom(unsigned int seed); |
| static inline int rand(void) |
| { |
| return random(); |
| } |
| static inline void srand(unsigned int seed) |
| { |
| srandom(seed); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/stdio.h |
|---|
| 0,0 → 1,154 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STDIO_H_ |
| #define LIBC_STDIO_H_ |
| #include <sys/types.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <adt/list.h> |
| #define EOF (-1) |
| /** Default size for stream I/O buffers */ |
| #define BUFSIZ 4096 |
| #define DEBUG(fmt, ...) \ |
| { \ |
| char _buf[256]; \ |
| int _n = snprintf(_buf, sizeof(_buf), fmt, ##__VA_ARGS__); \ |
| if (_n > 0) \ |
| (void) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) _buf, str_size(_buf)); \ |
| } |
| #ifndef SEEK_SET |
| #define SEEK_SET 0 |
| #define SEEK_CUR 1 |
| #define SEEK_END 2 |
| #endif |
| enum _buffer_type { |
| /** No buffering */ |
| _IONBF, |
| /** Line buffering */ |
| _IOLBF, |
| /** Full buffering */ |
| _IOFBF |
| }; |
| typedef struct { |
| /** Linked list pointer. */ |
| link_t link; |
| /** Underlying file descriptor. */ |
| int fd; |
| /** Error indicator. */ |
| int error; |
| /** End-of-file indicator. */ |
| int eof; |
| /** Klog indicator */ |
| int klog; |
| /** Phone to the file provider */ |
| int phone; |
| /** Buffering type */ |
| enum _buffer_type btype; |
| /** Buffer */ |
| uint8_t *buf; |
| /** Buffer size */ |
| size_t buf_size; |
| /** Buffer I/O pointer */ |
| uint8_t *buf_head; |
| } FILE; |
| extern FILE *stdin; |
| extern FILE *stdout; |
| extern FILE *stderr; |
| /* Character and string input functions */ |
| extern int fgetc(FILE *); |
| extern char *fgets(char *, size_t, FILE *); |
| extern int getchar(void); |
| extern char *gets(char *, size_t); |
| /* Character and string output functions */ |
| extern int fputc(wchar_t, FILE *); |
| extern int fputs(const char *, FILE *); |
| extern int putchar(wchar_t); |
| extern int puts(const char *); |
| /* Formatted string output functions */ |
| extern int fprintf(FILE *, const char*, ...); |
| extern int vfprintf(FILE *, const char *, va_list); |
| extern int printf(const char *, ...); |
| extern int vprintf(const char *, va_list); |
| extern int snprintf(char *, size_t , const char *, ...); |
| extern int asprintf(char **, const char *, ...); |
| extern int vsnprintf(char *, size_t, const char *, va_list); |
| /* File stream functions */ |
| extern FILE *fopen(const char *, const char *); |
| extern FILE *fdopen(int, const char *); |
| extern int fclose(FILE *); |
| extern size_t fread(void *, size_t, size_t, FILE *); |
| extern size_t fwrite(const void *, size_t, size_t, FILE *); |
| extern int fseek(FILE *, long, int); |
| extern void rewind(FILE *); |
| extern int ftell(FILE *); |
| extern int feof(FILE *); |
| extern int fflush(FILE *); |
| extern int ferror(FILE *); |
| extern void clearerr(FILE *); |
| extern void setvbuf(FILE *, void *, int, size_t); |
| /* Misc file functions */ |
| extern int rename(const char *, const char *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/bitops.h |
|---|
| 0,0 → 1,97 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_BITOPS_H_ |
| #define LIBC_BITOPS_H_ |
| #include <sys/types.h> |
| /** Return position of first non-zero bit from left (i.e. [log_2(arg)]). |
| * |
| * If number is zero, it returns 0 |
| */ |
| static inline unsigned int fnzb32(uint32_t arg) |
| { |
| unsigned int n = 0; |
| if (arg >> 16) { |
| arg >>= 16; |
| n += 16; |
| } |
| if (arg >> 8) { |
| arg >>= 8; |
| n += 8; |
| } |
| if (arg >> 4) { |
| arg >>= 4; |
| n += 4; |
| } |
| if (arg >> 2) { |
| arg >>= 2; |
| n += 2; |
| } |
| if (arg >> 1) { |
| arg >>= 1; |
| n += 1; |
| } |
| return n; |
| } |
| static inline unsigned int fnzb64(uint64_t arg) |
| { |
| unsigned int n = 0; |
| if (arg >> 32) { |
| arg >>= 32; |
| n += 32; |
| } |
| return (n + fnzb32((uint32_t) arg)); |
| } |
| static inline unsigned int fnzb(size_t arg) |
| { |
| return fnzb64(arg); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/unistd.h |
|---|
| 0,0 → 1,74 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_UNISTD_H_ |
| #define LIBC_UNISTD_H_ |
| #include <sys/types.h> |
| #include <libarch/config.h> |
| #ifndef NULL |
| #define NULL 0 |
| #endif |
| #define getpagesize() (PAGE_SIZE) |
| #ifndef SEEK_SET |
| #define SEEK_SET 0 |
| #define SEEK_CUR 1 |
| #define SEEK_END 2 |
| #endif |
| extern ssize_t write(int, const void *, size_t); |
| extern ssize_t read(int, void *, size_t); |
| extern off_t lseek(int, off_t, int); |
| extern int ftruncate(int, off_t); |
| extern int close(int); |
| extern int fsync(int); |
| extern int unlink(const char *); |
| extern char *getcwd(char *buf, size_t); |
| extern int rmdir(const char *); |
| extern int chdir(const char *); |
| extern void _exit(int status) __attribute__ ((noreturn)); |
| extern int usleep(unsigned long usec); |
| extern unsigned int sleep(unsigned int seconds); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/mem.h |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_MEM_H_ |
| #define LIBC_MEM_H_ |
| #include <sys/types.h> |
| #define bzero(ptr, len) memset((ptr), 0, (len)) |
| extern void *memset(void *, int, size_t); |
| extern void *memcpy(void *, const void *, size_t); |
| extern void *memmove(void *, const void *, size_t); |
| extern int bcmp(const char *, const char *, size_t); |
| #endif |
| /** @} |
| */ |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/0.4.1/uspace/lib/libc/include/adt/gcdlcm.h |
|---|
| 0,0 → 1,73 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_GCDLCM_H_ |
| #define LIBC_GCDLCM_H_ |
| #include <sys/types.h> |
| #define DECLARE_GCD(type, name) \ |
| static inline type name(type a, type b) \ |
| { \ |
| if (a == 0) \ |
| return b; \ |
| \ |
| while (b != 0) { \ |
| if (a > b) \ |
| a -= b; \ |
| else \ |
| b -= a; \ |
| } \ |
| \ |
| return a; \ |
| } |
| #define DECLARE_LCM(type, name, gcd) \ |
| static inline type name(type a, type b) \ |
| { \ |
| return (a * b) / gcd(a, b); \ |
| } |
| DECLARE_GCD(uint32_t, gcd32); |
| DECLARE_GCD(uint64_t, gcd64); |
| DECLARE_GCD(size_t, gcd); |
| DECLARE_LCM(uint32_t, lcm32, gcd32); |
| DECLARE_LCM(uint64_t, lcm64, gcd64); |
| DECLARE_LCM(size_t, lcm, gcd); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/adt/hash_table.h |
|---|
| 0,0 → 1,94 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_HASH_TABLE_H_ |
| #define LIBC_HASH_TABLE_H_ |
| #include <adt/list.h> |
| #include <unistd.h> |
| typedef unsigned long hash_count_t; |
| typedef unsigned long hash_index_t; |
| typedef struct hash_table hash_table_t; |
| typedef struct hash_table_operations hash_table_operations_t; |
| /** Hash table structure. */ |
| struct hash_table { |
| link_t *entry; |
| hash_count_t entries; |
| hash_count_t max_keys; |
| hash_table_operations_t *op; |
| }; |
| /** Set of operations for hash table. */ |
| struct hash_table_operations { |
| /** Hash function. |
| * |
| * @param key Array of keys needed to compute hash index. All keys |
| * must be passed. |
| * |
| * @return Index into hash table. |
| */ |
| hash_index_t (* hash)(unsigned long key[]); |
| /** Hash table item comparison function. |
| * |
| * @param key Array of keys that will be compared with item. It is |
| * not necessary to pass all keys. |
| * |
| * @return true if the keys match, false otherwise. |
| */ |
| int (*compare)(unsigned long key[], hash_count_t keys, link_t *item); |
| /** Hash table item removal callback. |
| * |
| * @param item Item that was removed from the hash table. |
| */ |
| void (*remove_callback)(link_t *item); |
| }; |
| #define hash_table_get_instance(item, type, member) \ |
| list_get_instance((item), type, member) |
| extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t, |
| hash_table_operations_t *); |
| extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *); |
| extern link_t *hash_table_find(hash_table_t *, unsigned long []); |
| extern void hash_table_remove(hash_table_t *, unsigned long [], hash_count_t); |
| extern void hash_table_destroy(hash_table_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/adt/list.h |
|---|
| 0,0 → 1,201 |
| /* |
| * Copyright (c) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_LIST_H_ |
| #define LIBC_LIST_H_ |
| #include <unistd.h> |
| /** Doubly linked list head and link type. */ |
| typedef struct link { |
| struct link *prev; /**< Pointer to the previous item in the list. */ |
| struct link *next; /**< Pointer to the next item in the list. */ |
| } link_t; |
| /** Declare and initialize statically allocated list. |
| * |
| * @param name Name of the new statically allocated list. |
| */ |
| #define LIST_INITIALIZE(name) link_t name = { \ |
| .prev = &name, \ |
| .next = &name \ |
| } |
| /** Initialize doubly-linked circular list link |
| * |
| * Initialize doubly-linked list link. |
| * |
| * @param link Pointer to link_t structure to be initialized. |
| */ |
| static inline void link_initialize(link_t *link) |
| { |
| link->prev = NULL; |
| link->next = NULL; |
| } |
| /** Initialize doubly-linked circular list |
| * |
| * Initialize doubly-linked circular list. |
| * |
| * @param head Pointer to link_t structure representing head of the list. |
| */ |
| static inline void list_initialize(link_t *head) |
| { |
| head->prev = head; |
| head->next = head; |
| } |
| /** Add item to the beginning of doubly-linked circular list |
| * |
| * Add item to the beginning of doubly-linked circular list. |
| * |
| * @param link Pointer to link_t structure to be added. |
| * @param head Pointer to link_t structure representing head of the list. |
| */ |
| static inline void list_prepend(link_t *link, link_t *head) |
| { |
| link->next = head->next; |
| link->prev = head; |
| head->next->prev = link; |
| head->next = link; |
| } |
| /** Add item to the end of doubly-linked circular list |
| * |
| * Add item to the end of doubly-linked circular list. |
| * |
| * @param link Pointer to link_t structure to be added. |
| * @param head Pointer to link_t structure representing head of the list. |
| */ |
| static inline void list_append(link_t *link, link_t *head) |
| { |
| link->prev = head->prev; |
| link->next = head; |
| head->prev->next = link; |
| head->prev = link; |
| } |
| /** Insert item before another item in doubly-linked circular list. */ |
| static inline void list_insert_before(link_t *l, link_t *r) |
| { |
| list_append(l, r); |
| } |
| /** Insert item after another item in doubly-linked circular list. */ |
| static inline void list_insert_after(link_t *r, link_t *l) |
| { |
| list_prepend(l, r); |
| } |
| /** Remove item from doubly-linked circular list |
| * |
| * Remove item from doubly-linked circular list. |
| * |
| * @param link Pointer to link_t structure to be removed from the list it is contained in. |
| */ |
| static inline void list_remove(link_t *link) |
| { |
| link->next->prev = link->prev; |
| link->prev->next = link->next; |
| link_initialize(link); |
| } |
| /** Query emptiness of doubly-linked circular list |
| * |
| * Query emptiness of doubly-linked circular list. |
| * |
| * @param head Pointer to link_t structure representing head of the list. |
| */ |
| static inline int list_empty(link_t *head) |
| { |
| return ((head->next == head) ? 1 : 0); |
| } |
| /** Split or concatenate headless doubly-linked circular list |
| * |
| * Split or concatenate headless doubly-linked circular list. |
| * |
| * Note that the algorithm works both directions: |
| * concatenates splitted lists and splits concatenated lists. |
| * |
| * @param part1 Pointer to link_t structure leading the first (half of the headless) list. |
| * @param part2 Pointer to link_t structure leading the second (half of the headless) list. |
| */ |
| static inline void headless_list_split_or_concat(link_t *part1, link_t *part2) |
| { |
| part1->prev->next = part2; |
| part2->prev->next = part1; |
| link_t *hlp = part1->prev; |
| part1->prev = part2->prev; |
| part2->prev = hlp; |
| } |
| /** Split headless doubly-linked circular list |
| * |
| * Split headless doubly-linked circular list. |
| * |
| * @param part1 Pointer to link_t structure leading the first half of the headless list. |
| * @param part2 Pointer to link_t structure leading the second half of the headless list. |
| */ |
| static inline void headless_list_split(link_t *part1, link_t *part2) |
| { |
| headless_list_split_or_concat(part1, part2); |
| } |
| /** Concatenate two headless doubly-linked circular lists |
| * |
| * Concatenate two headless doubly-linked circular lists. |
| * |
| * @param part1 Pointer to link_t structure leading the first headless list. |
| * @param part2 Pointer to link_t structure leading the second headless list. |
| */ |
| static inline void headless_list_concat(link_t *part1, link_t *part2) |
| { |
| headless_list_split_or_concat(part1, part2); |
| } |
| #define list_get_instance(link, type, member) ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member)))) |
| extern int list_member(const link_t *link, const link_t *head); |
| extern void list_concat(link_t *head1, link_t *head2); |
| extern unsigned int list_count(const link_t *link); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/adt/fifo.h |
|---|
| 0,0 → 1,127 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| /* |
| * This implementation of FIFO stores values in an array |
| * (static or dynamic). As such, these FIFOs have upper bound |
| * on number of values they can store. Push and pop operations |
| * are done via accessing the array through head and tail indices. |
| * Because of better operation ordering in fifo_pop(), the access |
| * policy for these two indices is to 'increment (mod size of FIFO) |
| * and use'. |
| */ |
| #ifndef LIBC_FIFO_H_ |
| #define LIBC_FIFO_H_ |
| #include <malloc.h> |
| typedef unsigned long fifo_count_t; |
| typedef unsigned long fifo_index_t; |
| #define FIFO_CREATE_STATIC(name, t, itms) \ |
| struct { \ |
| t fifo[(itms)]; \ |
| fifo_count_t items; \ |
| fifo_index_t head; \ |
| fifo_index_t tail; \ |
| } name |
| /** Create and initialize static FIFO. |
| * |
| * FIFO is allocated statically. |
| * This macro is suitable for creating smaller FIFOs. |
| * |
| * @param name Name of FIFO. |
| * @param t Type of values stored in FIFO. |
| * @param itms Number of items that can be stored in FIFO. |
| */ |
| #define FIFO_INITIALIZE_STATIC(name, t, itms) \ |
| FIFO_CREATE_STATIC(name, t, itms) = { \ |
| .items = (itms), \ |
| .head = 0, \ |
| .tail = 0 \ |
| } |
| /** Create and prepare dynamic FIFO. |
| * |
| * FIFO is allocated dynamically. |
| * This macro is suitable for creating larger FIFOs. |
| * |
| * @param name Name of FIFO. |
| * @param t Type of values stored in FIFO. |
| * @param itms Number of items that can be stored in FIFO. |
| */ |
| #define FIFO_INITIALIZE_DYNAMIC(name, t, itms) \ |
| struct { \ |
| t *fifo; \ |
| fifo_count_t items; \ |
| fifo_index_t head; \ |
| fifo_index_t tail; \ |
| } name = { \ |
| .fifo = NULL, \ |
| .items = (itms), \ |
| .head = 0, \ |
| .tail = 0 \ |
| } |
| /** Pop value from head of FIFO. |
| * |
| * @param name FIFO name. |
| * |
| * @return Leading value in FIFO. |
| */ |
| #define fifo_pop(name) \ |
| name.fifo[name.head = (name.head + 1) < name.items ? (name.head + 1) : 0] |
| /** Push value to tail of FIFO. |
| * |
| * @param name FIFO name. |
| * @param value Value to be appended to FIFO. |
| * |
| */ |
| #define fifo_push(name, value) \ |
| name.fifo[name.tail = (name.tail + 1) < name.items ? (name.tail + 1) : 0] = (value) |
| /** Allocate memory for dynamic FIFO. |
| * |
| * @param name FIFO name. |
| */ |
| #define fifo_create(name) \ |
| name.fifo = malloc(sizeof(*name.fifo) * name.items) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/macros.h |
|---|
| 0,0 → 1,60 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_MACROS_H_ |
| #define LIBC_MACROS_H_ |
| #define min(a, b) ((a) < (b) ? (a) : (b)) |
| #define max(a, b) ((a) > (b) ? (a) : (b)) |
| #define SIZE2KB(size) ((size) >> 10) |
| #define SIZE2MB(size) ((size) >> 20) |
| #define KB2SIZE(kb) ((kb) << 10) |
| #define MB2SIZE(mb) ((mb) << 20) |
| #define STRING(arg) STRING_ARG(arg) |
| #define STRING_ARG(arg) #arg |
| #define LOWER32(arg) ((arg) & 0xffffffff) |
| #define UPPER32(arg) (((arg) >> 32) & 0xffffffff) |
| #define MERGE_LOUP32(lo, up) \ |
| ((((uint64_t) (lo)) & 0xffffffff) \ |
| | ((((uint64_t) (up)) & 0xffffffff) << 32)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/errno.h |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ERRNO_H_ |
| #define LIBC_ERRNO_H_ |
| #include <kernel/errno.h> |
| #include <fibril.h> |
| extern int _errno; |
| #define errno _errno |
| #define EMFILE (-17) |
| #define ENAMETOOLONG (-256) |
| #define EISDIR (-257) |
| #define ENOTDIR (-258) |
| #define ENOSPC (-259) |
| #define EEXIST (-260) |
| #define ENOTEMPTY (-261) |
| #define EBADF (-262) |
| #define ERANGE (-263) |
| #define EXDEV (-264) |
| #define EIO (-265) |
| #define EMLINK (-266) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/malloc.h |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_MALLOC_H_ |
| #define LIBC_MALLOC_H_ |
| #include <sys/types.h> |
| extern void __heap_init(void); |
| extern uintptr_t get_max_heap_addr(void); |
| extern void *malloc(const size_t size); |
| extern void *memalign(const size_t align, const size_t size); |
| extern void *realloc(const void *addr, const size_t size); |
| extern void free(const void *addr); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/devmap.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2009 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_DEVMAP_H_ |
| #define LIBC_DEVMAP_H_ |
| #include <ipc/devmap.h> |
| #include <async.h> |
| extern int devmap_get_phone(devmap_interface_t, unsigned int); |
| extern void devmap_hangup_phone(devmap_interface_t iface); |
| extern int devmap_driver_register(const char *, async_client_conn_t); |
| extern int devmap_device_register(const char *, dev_handle_t *); |
| extern int devmap_device_get_handle(const char *, dev_handle_t *, unsigned int); |
| extern int devmap_device_connect(dev_handle_t, unsigned int); |
| extern int devmap_null_create(void); |
| extern void devmap_null_destroy(int); |
| extern ipcarg_t devmap_device_get_count(void); |
| extern ipcarg_t devmap_device_get_devices(ipcarg_t, dev_desc_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/sys/stat.h |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_SYS_STAT_H_ |
| #define LIBC_SYS_STAT_H_ |
| #include <sys/types.h> |
| #include <bool.h> |
| #include <ipc/vfs.h> |
| #include <ipc/devmap.h> |
| struct stat { |
| fs_handle_t fs_handle; |
| dev_handle_t dev_handle; |
| fs_index_t index; |
| unsigned lnkcnt; |
| bool is_file; |
| off_t size; |
| union { |
| struct { |
| dev_handle_t device; |
| } devfs_stat; |
| }; |
| }; |
| extern int fstat(int, struct stat *); |
| extern int stat(const char *, struct stat *); |
| extern int mkdir(const char *, mode_t); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/sys/types.h |
|---|
| 0,0 → 1,52 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_SYS_TYPES_H_ |
| #define LIBC_SYS_TYPES_H_ |
| #include <libarch/types.h> |
| typedef long off_t; |
| typedef int mode_t; |
| typedef int32_t wchar_t; |
| typedef volatile uint8_t ioport8_t; |
| typedef volatile uint16_t ioport16_t; |
| typedef volatile uint32_t ioport32_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/sys/time.h |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_SYS_TIME_H_ |
| #define LIBC_SYS_TIME_H_ |
| #include <sys/types.h> |
| #define DST_NONE 0 |
| typedef long time_t; |
| typedef long suseconds_t; |
| struct timeval { |
| time_t tv_sec; /* seconds */ |
| suseconds_t tv_usec; /* microseconds */ |
| }; |
| struct timezone { |
| int tz_minuteswest; /* minutes W of Greenwich */ |
| int tz_dsttime; /* type of dst correction */ |
| }; |
| extern void tv_add(struct timeval *tv, suseconds_t usecs); |
| extern suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2); |
| extern int tv_gt(struct timeval *tv1, struct timeval *tv2); |
| extern int tv_gteq(struct timeval *tv1, struct timeval *tv2); |
| extern int gettimeofday(struct timeval *tv, struct timezone *tz); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/sys/mman.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_MMAN_H_ |
| #define LIBC_MMAN_H_ |
| #include <as.h> |
| #include <sys/types.h> |
| #define MAP_FAILED ((void *) -1) |
| #define MAP_SHARED (1 << 0) |
| #define MAP_PRIVATE (1 << 1) |
| #define MAP_FIXED (1 << 2) |
| #define MAP_ANONYMOUS (1 << 3) |
| #define PROTO_READ AS_AREA_READ |
| #define PROTO_WRITE AS_AREA_WRITE |
| #define PROTO_EXEC AS_AREA_EXEC |
| extern void *mmap(void *start, size_t length, int prot, int flags, int fd, |
| off_t offset); |
| extern int munmap(void *start, size_t length); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/byteorder.h |
|---|
| 0,0 → 1,111 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_BYTEORDER_H_ |
| #define LIBC_BYTEORDER_H_ |
| #include <stdint.h> |
| #if !(defined(__BE__) ^ defined(__LE__)) |
| #error The architecture must be either big-endian or little-endian. |
| #endif |
| #ifdef __BE__ |
| #define uint16_t_le2host(n) (uint16_t_byteorder_swap(n)) |
| #define uint32_t_le2host(n) (uint32_t_byteorder_swap(n)) |
| #define uint64_t_le2host(n) (uint64_t_byteorder_swap(n)) |
| #define uint16_t_be2host(n) (n) |
| #define uint32_t_be2host(n) (n) |
| #define uint64_t_be2host(n) (n) |
| #define host2uint16_t_le(n) (uint16_t_byteorder_swap(n)) |
| #define host2uint32_t_le(n) (uint32_t_byteorder_swap(n)) |
| #define host2uint64_t_le(n) (uint64_t_byteorder_swap(n)) |
| #define host2uint16_t_be(n) (n) |
| #define host2uint32_t_be(n) (n) |
| #define host2uint64_t_be(n) (n) |
| #else |
| #define uint16_t_le2host(n) (n) |
| #define uint32_t_le2host(n) (n) |
| #define uint64_t_le2host(n) (n) |
| #define uint16_t_be2host(n) (uint16_t_byteorder_swap(n)) |
| #define uint32_t_be2host(n) (uint32_t_byteorder_swap(n)) |
| #define uint64_t_be2host(n) (uint64_t_byteorder_swap(n)) |
| #define host2uint16_t_le(n) (n) |
| #define host2uint32_t_le(n) (n) |
| #define host2uint64_t_le(n) (n) |
| #define host2uint16_t_be(n) (uint16_t_byteorder_swap(n)) |
| #define host2uint32_t_be(n) (uint32_t_byteorder_swap(n)) |
| #define host2uint64_t_be(n) (uint64_t_byteorder_swap(n)) |
| #endif |
| static inline uint64_t uint64_t_byteorder_swap(uint64_t n) |
| { |
| return ((n & 0xff) << 56) | |
| ((n & 0xff00) << 40) | |
| ((n & 0xff0000) << 24) | |
| ((n & 0xff000000LL) << 8) | |
| ((n & 0xff00000000LL) >> 8) | |
| ((n & 0xff0000000000LL) >> 24) | |
| ((n & 0xff000000000000LL) >> 40) | |
| ((n & 0xff00000000000000LL) >> 56); |
| } |
| static inline uint32_t uint32_t_byteorder_swap(uint32_t n) |
| { |
| return ((n & 0xff) << 24) | |
| ((n & 0xff00) << 8) | |
| ((n & 0xff0000) >> 8) | |
| ((n & 0xff000000) >> 24); |
| } |
| static inline uint16_t uint16_t_byteorder_swap(uint16_t n) |
| { |
| return ((n & 0xff) << 8) | |
| ((n & 0xff00) >> 8); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/fibril_sync.h |
|---|
| 0,0 → 1,104 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_FIBRIL_SYNC_H_ |
| #define LIBC_FIBRIL_SYNC_H_ |
| #include <async.h> |
| #include <fibril.h> |
| #include <adt/list.h> |
| #include <libarch/tls.h> |
| typedef struct { |
| int counter; |
| link_t waiters; |
| } fibril_mutex_t; |
| #define FIBRIL_MUTEX_INITIALIZE(name) \ |
| fibril_mutex_t name = { \ |
| .counter = 1, \ |
| .waiters = { \ |
| .prev = &name.waiters, \ |
| .next = &name.waiters, \ |
| } \ |
| } |
| typedef struct { |
| unsigned writers; |
| unsigned readers; |
| link_t waiters; |
| } fibril_rwlock_t; |
| #define FIBRIL_RWLOCK_INITIALIZE(name) \ |
| fibril_rwlock_t name = { \ |
| .readers = 0, \ |
| .writers = 0, \ |
| .waiters = { \ |
| .prev = &name.waiters, \ |
| .next = &name.waiters, \ |
| } \ |
| } |
| typedef struct { |
| link_t waiters; |
| } fibril_condvar_t; |
| #define FIBRIL_CONDVAR_INITIALIZE(name) \ |
| fibril_condvar_t name = { \ |
| .waiters = { \ |
| .next = &name.waiters, \ |
| .prev = &name.waiters, \ |
| } \ |
| } |
| extern void fibril_mutex_initialize(fibril_mutex_t *); |
| extern void fibril_mutex_lock(fibril_mutex_t *); |
| extern bool fibril_mutex_trylock(fibril_mutex_t *); |
| extern void fibril_mutex_unlock(fibril_mutex_t *); |
| extern void fibril_rwlock_initialize(fibril_rwlock_t *); |
| extern void fibril_rwlock_read_lock(fibril_rwlock_t *); |
| extern void fibril_rwlock_write_lock(fibril_rwlock_t *); |
| extern void fibril_rwlock_read_unlock(fibril_rwlock_t *); |
| extern void fibril_rwlock_write_unlock(fibril_rwlock_t *); |
| extern void fibril_condvar_initialize(fibril_condvar_t *); |
| extern void fibril_condvar_wait(fibril_condvar_t *, fibril_mutex_t *); |
| extern void fibril_condvar_signal(fibril_condvar_t *); |
| extern void fibril_condvar_broadcast(fibril_condvar_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/loader/pcb.h |
|---|
| 0,0 → 1,83 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup fs |
| * @{ |
| */ |
| /** @file |
| * @brief Program Control Block interface. |
| */ |
| #ifndef LIBC_PCB_H_ |
| #define LIBC_PCB_H_ |
| #include <sys/types.h> |
| #include <vfs/vfs.h> |
| typedef void (*entry_point_t)(void); |
| /** Program Control Block. |
| * |
| * Holds pointers to data passed from the program loader to the program |
| * and/or to the dynamic linker. This includes the program entry point, |
| * arguments, environment variables etc. |
| * |
| */ |
| typedef struct { |
| /** Program entry point. */ |
| entry_point_t entry; |
| /** Number of command-line arguments. */ |
| int argc; |
| /** Command-line arguments. */ |
| char **argv; |
| /** Number of preset files. */ |
| int filc; |
| /** Preset files. */ |
| fdi_node_t **filv; |
| /* |
| * ELF-specific data. |
| */ |
| /** Pointer to ELF dynamic section of the program. */ |
| void *dynamic; |
| } pcb_t; |
| /** |
| * A pointer to the program control block. Having received the PCB pointer, |
| * the C library startup code stores it here for later use. |
| */ |
| extern pcb_t *__pcb; |
| #endif |
| /** |
| * @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/loader/loader.h |
|---|
| 0,0 → 1,62 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup fs |
| * @{ |
| */ |
| /** @file |
| * @brief Program loader interface. |
| */ |
| #ifndef LIBC_LOADER_H_ |
| #define LIBC_LOADER_H_ |
| #include <task.h> |
| #include <vfs/vfs.h> |
| /** Abstraction of a loader connection */ |
| typedef struct { |
| /** ID of the phone connected to the loader. */ |
| int phone_id; |
| } loader_t; |
| extern int loader_spawn(const char *); |
| extern loader_t *loader_connect(void); |
| extern int loader_get_task_id(loader_t *, task_id_t *); |
| extern int loader_set_pathname(loader_t *, const char *); |
| extern int loader_set_args(loader_t *, char *const[]); |
| extern int loader_set_files(loader_t *, fdi_node_t *const[]); |
| extern int loader_load_program(loader_t *); |
| extern int loader_run(loader_t *); |
| extern void loader_abort(loader_t *); |
| #endif |
| /** |
| * @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/fcntl.h |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2007 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_FCNTL_H_ |
| #define LIBC_FCNTL_H_ |
| #define O_CREAT 1 |
| #define O_EXCL 2 |
| #define O_TRUNC 4 |
| #define O_APPEND 8 |
| #define O_RDONLY 16 |
| #define O_RDWR 32 |
| #define O_WRONLY 64 |
| extern int open(const char *, int, ...); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/dirent.h |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_DIRENT_H_ |
| #define LIBC_DIRENT_H_ |
| #define NAME_MAX 256 |
| struct dirent { |
| char d_name[NAME_MAX + 1]; |
| }; |
| typedef struct { |
| int fd; |
| struct dirent res; |
| } DIR; |
| extern DIR *opendir(const char *); |
| extern struct dirent *readdir(DIR *); |
| extern void rewinddir(DIR *); |
| extern int closedir(DIR *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/thread.h |
|---|
| 0,0 → 1,56 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_THREAD_H_ |
| #define LIBC_THREAD_H_ |
| #include <kernel/proc/uarg.h> |
| #include <libarch/thread.h> |
| #include <sys/types.h> |
| typedef uint64_t thread_id_t; |
| extern void __thread_entry(void); |
| extern void __thread_main(uspace_arg_t *); |
| extern int thread_create(void (*)(void *), void *, char *, thread_id_t *); |
| extern void thread_exit(int) __attribute__ ((noreturn)); |
| extern void thread_detach(thread_id_t); |
| extern int thread_join(thread_id_t); |
| extern thread_id_t thread_get_id(void); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/event.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_EVENT_H_ |
| #define LIBC_EVENT_H_ |
| #include <kernel/ipc/event_types.h> |
| #include <ipc/ipc.h> |
| extern int event_subscribe(event_type_t, ipcarg_t); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ddi.h |
|---|
| 0,0 → 1,49 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_DDI_H_ |
| #define LIBC_DDI_H_ |
| #include <task.h> |
| extern int device_assign_devno(void); |
| extern int physmem_map(void *, void *, unsigned long, int); |
| extern int iospace_enable(task_id_t, void *, unsigned long); |
| extern int preemption_control(int); |
| extern int pio_enable(void *, size_t, void **); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/libc.h |
|---|
| 0,0 → 1,63 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_LIBC_H_ |
| #define LIBC_LIBC_H_ |
| #include <sys/types.h> |
| #include <kernel/syscall/syscall.h> |
| #include <libarch/syscall.h> |
| #define __SYSCALL0(id) \ |
| __syscall0(0, 0, 0, 0, 0, 0, id) |
| #define __SYSCALL1(id, p1) \ |
| __syscall1(p1, 0, 0, 0, 0, 0, id) |
| #define __SYSCALL2(id, p1, p2) \ |
| __syscall2(p1, p2, 0, 0, 0, 0, id) |
| #define __SYSCALL3(id, p1, p2, p3) \ |
| __syscall3(p1, p2, p3, 0, 0, 0, id) |
| #define __SYSCALL4(id, p1, p2, p3, p4) \ |
| __syscall4(p1, p2, p3, p4, 0, 0, id) |
| #define __SYSCALL5(id, p1, p2, p3, p4, p5) \ |
| __syscall5(p1, p2, p3, p4, p5, 0, id) |
| #define __SYSCALL6(id, p1, p2, p3, p4, p5, p6) \ |
| __syscall6(p1, p2, p3, p4, p5, p6, id) |
| extern void __main(void *pcb_ptr); |
| extern void __exit(void); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/ctype.h |
|---|
| 0,0 → 1,98 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_CTYPE_H_ |
| #define LIBC_CTYPE_H_ |
| static inline int islower(int c) |
| { |
| return ((c >= 'a') && (c <= 'z')); |
| } |
| static inline int isupper(int c) |
| { |
| return ((c >= 'A') && (c <= 'Z')); |
| } |
| static inline int isalpha(int c) |
| { |
| return (islower(c) || isupper(c)); |
| } |
| static inline int isdigit(int c) |
| { |
| return ((c >= '0') && (c <= '9')); |
| } |
| static inline int isalnum(int c) |
| { |
| return (isalpha(c) || isdigit(c)); |
| } |
| static inline int isspace(int c) |
| { |
| switch (c) { |
| case ' ': |
| case '\n': |
| case '\t': |
| case '\f': |
| case '\r': |
| case '\v': |
| return 1; |
| break; |
| default: |
| return 0; |
| } |
| } |
| static inline int tolower(int c) |
| { |
| if (isupper(c)) |
| return (c + ('a' - 'A')); |
| else |
| return c; |
| } |
| static inline int toupper(int c) |
| { |
| if (islower(c)) |
| return (c + ('A' - 'a')); |
| else |
| return c; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/align.h |
|---|
| 0,0 → 1,63 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ALIGN_H_ |
| #define LIBC_ALIGN_H_ |
| /** Align to the nearest lower address which is a power of two. |
| * |
| * @param s Address or size to be aligned. |
| * @param a Size of alignment, must be power of 2. |
| */ |
| #define ALIGN_DOWN(s, a) ((s) & ~((a) - 1)) |
| /** Align to the nearest higher address which is a power of two. |
| * |
| * @param s Address or size to be aligned. |
| * @param a Size of alignment, must be power of 2. |
| */ |
| #define ALIGN_UP(s, a) ((long)((s) + ((a) - 1)) & ~((long) (a) - 1)) |
| /** Round up to the nearest higher boundary. |
| * |
| * @param n Number to be aligned. |
| * @param b Boundary, arbitrary unsigned number. |
| */ |
| #define ROUND_UP(n, b) (((n) / (b) + ((n) % (b) != 0)) * (b)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/syscall.h |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| * @brief Syscall function declaration for architectures that don't |
| * inline syscalls or architectures that handle syscalls |
| * according to the number of arguments. |
| */ |
| #ifndef LIBC_SYSCALL_H_ |
| #define LIBC_SYSCALL_H_ |
| #ifndef LIBARCH_SYSCALL_GENERIC |
| #error "You can't include this file directly." |
| #endif |
| #include <sys/types.h> |
| #include <kernel/syscall/syscall.h> |
| #define __syscall0 __syscall |
| #define __syscall1 __syscall |
| #define __syscall2 __syscall |
| #define __syscall3 __syscall |
| #define __syscall4 __syscall |
| #define __syscall5 __syscall |
| #define __syscall6 __syscall |
| extern sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2, |
| const sysarg_t p3, const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, |
| const syscall_t id); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/udebug.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_UDEBUG_H_ |
| #define LIBC_UDEBUG_H_ |
| #include <kernel/udebug/udebug.h> |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| typedef sysarg_t thash_t; |
| int udebug_begin(int phoneid); |
| int udebug_end(int phoneid); |
| int udebug_set_evmask(int phoneid, udebug_evmask_t mask); |
| int udebug_thread_read(int phoneid, void *buffer, size_t n, |
| size_t *copied, size_t *needed); |
| int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n); |
| int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer); |
| int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type, |
| sysarg_t *val0, sysarg_t *val1); |
| int udebug_stop(int phoneid, thash_t tid); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/as.h |
|---|
| 0,0 → 1,53 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_AS_H_ |
| #define LIBC_AS_H_ |
| #include <sys/types.h> |
| #include <task.h> |
| #include <kernel/mm/as.h> |
| #include <libarch/config.h> |
| extern void *as_area_create(void *address, size_t size, int flags); |
| extern int as_area_resize(void *address, size_t size, int flags); |
| extern int as_area_change_flags(void *address, int flags); |
| extern int as_area_destroy(void *address); |
| extern void *set_maxheapsize(size_t mhs); |
| extern void * as_get_mappable_page(size_t sz); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/smc.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_SMC_H_ |
| #define LIBC_SMC_H_ |
| #include <sys/types.h> |
| extern int smc_coherence(void *address, size_t size); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/setjmp.h |
|---|
| 0,0 → 1,49 |
| /* |
| * Copyright (c) 2008 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_SETJMP_H_ |
| #define LIBC_SETJMP_H_ |
| #include <libarch/fibril.h> |
| typedef context_t jmp_buf; |
| extern int setjmp(jmp_buf env); |
| extern void longjmp(jmp_buf env,int val) __attribute__((__noreturn__)); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/rwlock.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| * @brief This file contains rwlock API and provides its fake |
| * implementation based on futexes. |
| */ |
| #ifndef LIBC_RWLOCK_H_ |
| #define LIBC_RWLOCK_H_ |
| #include <atomic.h> |
| #include <sys/types.h> |
| #include <futex.h> |
| typedef atomic_t rwlock_t; |
| #define RWLOCK_INITIALIZE(rwlock) \ |
| rwlock_t rwlock = FUTEX_INITIALIZER |
| #define rwlock_initialize(rwlock) futex_initialize((rwlock), 1) |
| #define rwlock_read_lock(rwlock) futex_down((rwlock)) |
| #define rwlock_write_lock(rwlock) futex_down((rwlock)) |
| #define rwlock_read_unlock(rwlock) futex_up((rwlock)) |
| #define rwlock_write_unlock(rwlock) futex_up((rwlock)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/futex.h |
|---|
| 0,0 → 1,54 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_FUTEX_H_ |
| #define LIBC_FUTEX_H_ |
| #include <atomic.h> |
| #include <sys/types.h> |
| #define FUTEX_INITIALIZER {1} |
| typedef atomic_t futex_t; |
| extern void futex_initialize(futex_t *futex, int value); |
| extern int futex_down(futex_t *futex); |
| extern int futex_trydown(futex_t *futex); |
| extern int futex_down_timeout(futex_t *futex, uint32_t usec, int flags); |
| extern int futex_up(futex_t *futex); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/assert.h |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ASSERT_H_ |
| #define LIBC_ASSERT_H_ |
| /** Debugging assert macro |
| * |
| * If NDEBUG is not set, the assert() macro |
| * evaluates expr and if it is false prints |
| * error message and terminate program. |
| * |
| * @param expr Expression which is expected to be true. |
| * |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #ifndef NDEBUG |
| # define assert(expr) if (!(expr)) { printf("Assertion failed (%s) at file '%s', line %d.\n", #expr, __FILE__, __LINE__); abort();} |
| #else |
| # define assert(expr) |
| #endif |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/tls.h |
|---|
| 0,0 → 1,67 |
| /* |
| * Copyright (c) 2007 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_TLS_H_ |
| #define LIBC_TLS_H_ |
| #include <libarch/tls.h> |
| #include <sys/types.h> |
| /* |
| * Symbols defined in the respective linker script. |
| */ |
| extern char _tls_alignment; |
| extern char _tdata_start; |
| extern char _tdata_end; |
| extern char _tbss_start; |
| extern char _tbss_end; |
| extern tcb_t *__make_tls(void); |
| extern tcb_t *__alloc_tls(void **, size_t); |
| extern void __free_tls(tcb_t *); |
| extern void __free_tls_arch(tcb_t *, size_t); |
| #ifdef CONFIG_TLS_VARIANT_1 |
| extern tcb_t *tls_alloc_variant_1(void **, size_t); |
| extern void tls_free_variant_1(tcb_t *, size_t); |
| #endif |
| #ifdef CONFIG_TLS_VARIANT_2 |
| extern tcb_t *tls_alloc_variant_2(void **, size_t); |
| extern void tls_free_variant_2(tcb_t *, size_t); |
| #endif |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/time.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2007 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_TIME_H_ |
| #define LIBC_TIME_H_ |
| #include <sys/time.h> |
| extern time_t time(time_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/stdint.h |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STDINT_H_ |
| #define LIBC_STDINT_H_ |
| /* Definitions of types with fixed size */ |
| #include <libarch/types.h> |
| #define MAX_INT8 (0x7F) |
| #define MIN_INT8 (0x80) |
| #define MAX_UINT8 (0xFFu) |
| #define MIN_UINT8 (0u) |
| #define MAX_INT16 (0x7FFF) |
| #define MIN_INT16 (0x8000) |
| #define MAX_UINT16 (0xFFFFu) |
| #define MIN_UINT16 (0u) |
| #define MAX_INT32 (0x7FFFFFFF) |
| #define MIN_INT32 (0x80000000) |
| #define MAX_UINT32 (0xFFFFFFFFu) |
| #define MIN_UINT32 (0u) |
| #define MAX_INT64 (0x7FFFFFFFFFFFFFFFll) |
| #define MIN_INT64 (0x8000000000000000ll) |
| #define MAX_UINT64 (0xFFFFFFFFFFFFFFFFull) |
| #define MIN_UINT64 (0ull) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/stddef.h |
|---|
| 0,0 → 1,43 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STDDEF_H_ |
| #define LIBC_STDDEF_H_ |
| #include <sys/types.h> |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/stdarg.h |
|---|
| 0,0 → 1,55 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STDARG_H_ |
| #define LIBC_STDARG_H_ |
| #include <sys/types.h> |
| #include <libarch/stackarg.h> |
| #ifndef __VARARGS_DEFINED |
| # define __VARARGS_DEFINED |
| typedef __builtin_va_list va_list; |
| # define va_start(ap, last) __builtin_va_start(ap, last) |
| # define va_arg(ap, type) __builtin_va_arg(ap, type) |
| # define va_end(ap) __builtin_va_end(ap) |
| # endif |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/limits.h |
|---|
| 0,0 → 1,74 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_LIMITS_H_ |
| #define LIBC_LIMITS_H_ |
| #include <stdint.h> |
| #include <libarch/limits.h> |
| /* char */ |
| #define SCHAR_MIN MIN_INT8 |
| #define SCHAR_MAX MAX_INT8 |
| #define UCHAR_MIN MIN_UINT8 |
| #define UCHAR_MAX MAX_UINT8 |
| #ifdef __CHAR_UNSIGNED__ |
| # define CHAR_MIN UCHAR_MIN |
| # define CHAR_MAX UCHAR_MAX |
| #else |
| # define CHAR_MIN SCHAR_MIN |
| # define CHAR_MAX SCHAR_MAX |
| #endif |
| /* short int */ |
| #define SHRT_MIN MIN_INT16 |
| #define SHRT_MAX MAX_INT16 |
| #define USHRT_MIN MIN_UINT16 |
| #define USHRT_MAX MAX_UINT16 |
| #define INT_MIN MIN_INT32 |
| #define INT_MAX MAX_INT32 |
| #define UINT_MIN MIN_UINT32 |
| #define UINT_MAX MAX_UINT32 |
| #define LLONG_MIN MIN_INT64 |
| #define LLONG_MAX MAX_INT64 |
| #define ULLONG_MIN MIN_UINT64 |
| #define ULLONG_MAX MAX_UINT64 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/err.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ERR_H_ |
| #define LIBC_ERR_H_ |
| #define errx(status, fmt, ...) { \ |
| printf((fmt), ##__VA_ARGS__); \ |
| _exit(status); \ |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/sysinfo.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_SYSINFO_H_ |
| #define LIBC_SYSINFO_H_ |
| #include <libc.h> |
| #include <sysinfo.h> |
| #include <string.h> |
| sysarg_t sysinfo_value(char *name); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/bool.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_BOOL_H_ |
| #define LIBC_BOOL_H_ |
| #define false 0 |
| #define true 1 |
| typedef short bool; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/cap.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIB_CAP_H_ |
| #define LIB_CAP_H_ |
| #include <task.h> |
| extern int cap_grant(task_id_t id, unsigned int caps); |
| extern int cap_revoke(task_id_t id, unsigned int caps); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/include/atomic.h |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ATOMIC_H_ |
| #define LIBC_ATOMIC_H_ |
| typedef struct atomic { |
| volatile long count; |
| } atomic_t; |
| #include <libarch/atomic.h> |
| static inline void atomic_set(atomic_t *val, long i) |
| { |
| val->count = i; |
| } |
| static inline long atomic_get(atomic_t *val) |
| { |
| return val->count; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/string.c |
|---|
| 0,0 → 1,889 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <string.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <limits.h> |
| #include <ctype.h> |
| #include <malloc.h> |
| #include <errno.h> |
| #include <align.h> |
| #include <mem.h> |
| #include <string.h> |
| /** Byte mask consisting of lowest @n bits (out of 8) */ |
| #define LO_MASK_8(n) ((uint8_t) ((1 << (n)) - 1)) |
| /** Byte mask consisting of lowest @n bits (out of 32) */ |
| #define LO_MASK_32(n) ((uint32_t) ((1 << (n)) - 1)) |
| /** Byte mask consisting of highest @n bits (out of 8) */ |
| #define HI_MASK_8(n) (~LO_MASK_8(8 - (n))) |
| /** Number of data bits in a UTF-8 continuation byte */ |
| #define CONT_BITS 6 |
| /** Decode a single character from a string. |
| * |
| * Decode a single character from a string of size @a size. Decoding starts |
| * at @a offset and this offset is moved to the beginning of the next |
| * character. In case of decoding error, offset generally advances at least |
| * by one. However, offset is never moved beyond size. |
| * |
| * @param str String (not necessarily NULL-terminated). |
| * @param offset Byte offset in string where to start decoding. |
| * @param size Size of the string (in bytes). |
| * |
| * @return Value of decoded character, U_SPECIAL on decoding error or |
| * NULL if attempt to decode beyond @a size. |
| * |
| */ |
| wchar_t str_decode(const char *str, size_t *offset, size_t size) |
| { |
| if (*offset + 1 > size) |
| return 0; |
| /* First byte read from string */ |
| uint8_t b0 = (uint8_t) str[(*offset)++]; |
| /* Determine code length */ |
| unsigned int b0_bits; /* Data bits in first byte */ |
| unsigned int cbytes; /* Number of continuation bytes */ |
| if ((b0 & 0x80) == 0) { |
| /* 0xxxxxxx (Plain ASCII) */ |
| b0_bits = 7; |
| cbytes = 0; |
| } else if ((b0 & 0xe0) == 0xc0) { |
| /* 110xxxxx 10xxxxxx */ |
| b0_bits = 5; |
| cbytes = 1; |
| } else if ((b0 & 0xf0) == 0xe0) { |
| /* 1110xxxx 10xxxxxx 10xxxxxx */ |
| b0_bits = 4; |
| cbytes = 2; |
| } else if ((b0 & 0xf8) == 0xf0) { |
| /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ |
| b0_bits = 3; |
| cbytes = 3; |
| } else { |
| /* 10xxxxxx -- unexpected continuation byte */ |
| return U_SPECIAL; |
| } |
| if (*offset + cbytes > size) |
| return U_SPECIAL; |
| wchar_t ch = b0 & LO_MASK_8(b0_bits); |
| /* Decode continuation bytes */ |
| while (cbytes > 0) { |
| uint8_t b = (uint8_t) str[(*offset)++]; |
| /* Must be 10xxxxxx */ |
| if ((b & 0xc0) != 0x80) |
| return U_SPECIAL; |
| /* Shift data bits to ch */ |
| ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS)); |
| cbytes--; |
| } |
| return ch; |
| } |
| /** Encode a single character to string representation. |
| * |
| * Encode a single character to string representation (i.e. UTF-8) and store |
| * it into a buffer at @a offset. Encoding starts at @a offset and this offset |
| * is moved to the position where the next character can be written to. |
| * |
| * @param ch Input character. |
| * @param str Output buffer. |
| * @param offset Byte offset where to start writing. |
| * @param size Size of the output buffer (in bytes). |
| * |
| * @return EOK if the character was encoded successfully, EOVERFLOW if there |
| * was not enough space in the output buffer or EINVAL if the character |
| * code was invalid. |
| */ |
| int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size) |
| { |
| if (*offset >= size) |
| return EOVERFLOW; |
| if (!chr_check(ch)) |
| return EINVAL; |
| /* Unsigned version of ch (bit operations should only be done |
| on unsigned types). */ |
| uint32_t cc = (uint32_t) ch; |
| /* Determine how many continuation bytes are needed */ |
| unsigned int b0_bits; /* Data bits in first byte */ |
| unsigned int cbytes; /* Number of continuation bytes */ |
| if ((cc & ~LO_MASK_32(7)) == 0) { |
| b0_bits = 7; |
| cbytes = 0; |
| } else if ((cc & ~LO_MASK_32(11)) == 0) { |
| b0_bits = 5; |
| cbytes = 1; |
| } else if ((cc & ~LO_MASK_32(16)) == 0) { |
| b0_bits = 4; |
| cbytes = 2; |
| } else if ((cc & ~LO_MASK_32(21)) == 0) { |
| b0_bits = 3; |
| cbytes = 3; |
| } else { |
| /* Codes longer than 21 bits are not supported */ |
| return EINVAL; |
| } |
| /* Check for available space in buffer */ |
| if (*offset + cbytes >= size) |
| return EOVERFLOW; |
| /* Encode continuation bytes */ |
| unsigned int i; |
| for (i = cbytes; i > 0; i--) { |
| str[*offset + i] = 0x80 | (cc & LO_MASK_32(CONT_BITS)); |
| cc = cc >> CONT_BITS; |
| } |
| /* Encode first byte */ |
| str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1); |
| /* Advance offset */ |
| *offset += cbytes + 1; |
| return EOK; |
| } |
| /** Get size of string. |
| * |
| * Get the number of bytes which are used by the string @a str (excluding the |
| * NULL-terminator). |
| * |
| * @param str String to consider. |
| * |
| * @return Number of bytes used by the string |
| * |
| */ |
| size_t str_size(const char *str) |
| { |
| size_t size = 0; |
| while (*str++ != 0) |
| size++; |
| return size; |
| } |
| /** Get size of wide string. |
| * |
| * Get the number of bytes which are used by the wide string @a str (excluding the |
| * NULL-terminator). |
| * |
| * @param str Wide string to consider. |
| * |
| * @return Number of bytes used by the wide string |
| * |
| */ |
| size_t wstr_size(const wchar_t *str) |
| { |
| return (wstr_length(str) * sizeof(wchar_t)); |
| } |
| /** Get size of string with length limit. |
| * |
| * Get the number of bytes which are used by up to @a max_len first |
| * characters in the string @a str. If @a max_len is greater than |
| * the length of @a str, the entire string is measured (excluding the |
| * NULL-terminator). |
| * |
| * @param str String to consider. |
| * @param max_len Maximum number of characters to measure. |
| * |
| * @return Number of bytes used by the characters. |
| * |
| */ |
| size_t str_lsize(const char *str, size_t max_len) |
| { |
| size_t len = 0; |
| size_t offset = 0; |
| while (len < max_len) { |
| if (str_decode(str, &offset, STR_NO_LIMIT) == 0) |
| break; |
| len++; |
| } |
| return offset; |
| } |
| /** Get size of wide string with length limit. |
| * |
| * Get the number of bytes which are used by up to @a max_len first |
| * wide characters in the wide string @a str. If @a max_len is greater than |
| * the length of @a str, the entire wide string is measured (excluding the |
| * NULL-terminator). |
| * |
| * @param str Wide string to consider. |
| * @param max_len Maximum number of wide characters to measure. |
| * |
| * @return Number of bytes used by the wide characters. |
| * |
| */ |
| size_t wstr_lsize(const wchar_t *str, size_t max_len) |
| { |
| return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t)); |
| } |
| /** Get number of characters in a string. |
| * |
| * @param str NULL-terminated string. |
| * |
| * @return Number of characters in string. |
| * |
| */ |
| size_t str_length(const char *str) |
| { |
| size_t len = 0; |
| size_t offset = 0; |
| while (str_decode(str, &offset, STR_NO_LIMIT) != 0) |
| len++; |
| return len; |
| } |
| /** Get number of characters in a wide string. |
| * |
| * @param str NULL-terminated wide string. |
| * |
| * @return Number of characters in @a str. |
| * |
| */ |
| size_t wstr_length(const wchar_t *wstr) |
| { |
| size_t len = 0; |
| while (*wstr++ != 0) |
| len++; |
| return len; |
| } |
| /** Get number of characters in a string with size limit. |
| * |
| * @param str NULL-terminated string. |
| * @param size Maximum number of bytes to consider. |
| * |
| * @return Number of characters in string. |
| * |
| */ |
| size_t str_nlength(const char *str, size_t size) |
| { |
| size_t len = 0; |
| size_t offset = 0; |
| while (str_decode(str, &offset, size) != 0) |
| len++; |
| return len; |
| } |
| /** Get number of characters in a string with size limit. |
| * |
| * @param str NULL-terminated string. |
| * @param size Maximum number of bytes to consider. |
| * |
| * @return Number of characters in string. |
| * |
| */ |
| size_t wstr_nlength(const wchar_t *str, size_t size) |
| { |
| size_t len = 0; |
| size_t limit = ALIGN_DOWN(size, sizeof(wchar_t)); |
| size_t offset = 0; |
| while ((offset < limit) && (*str++ != 0)) { |
| len++; |
| offset += sizeof(wchar_t); |
| } |
| return len; |
| } |
| /** Check whether character is plain ASCII. |
| * |
| * @return True if character is plain ASCII. |
| * |
| */ |
| bool ascii_check(wchar_t ch) |
| { |
| if ((ch >= 0) && (ch <= 127)) |
| return true; |
| return false; |
| } |
| /** Check whether character is valid |
| * |
| * @return True if character is a valid Unicode code point. |
| * |
| */ |
| bool chr_check(wchar_t ch) |
| { |
| if ((ch >= 0) && (ch <= 1114111)) |
| return true; |
| return false; |
| } |
| /** Compare two NULL terminated strings. |
| * |
| * Do a char-by-char comparison of two NULL-terminated strings. |
| * The strings are considered equal iff they consist of the same |
| * characters on the minimum of their lengths. |
| * |
| * @param s1 First string to compare. |
| * @param s2 Second string to compare. |
| * |
| * @return 0 if the strings are equal, -1 if first is smaller, |
| * 1 if second smaller. |
| * |
| */ |
| int str_cmp(const char *s1, const char *s2) |
| { |
| wchar_t c1 = 0; |
| wchar_t c2 = 0; |
| size_t off1 = 0; |
| size_t off2 = 0; |
| while (true) { |
| c1 = str_decode(s1, &off1, STR_NO_LIMIT); |
| c2 = str_decode(s2, &off2, STR_NO_LIMIT); |
| if (c1 < c2) |
| return -1; |
| if (c1 > c2) |
| return 1; |
| if (c1 == 0 || c2 == 0) |
| break; |
| } |
| return 0; |
| } |
| /** Compare two NULL terminated strings with length limit. |
| * |
| * Do a char-by-char comparison of two NULL-terminated strings. |
| * The strings are considered equal iff they consist of the same |
| * characters on the minimum of their lengths and the length limit. |
| * |
| * @param s1 First string to compare. |
| * @param s2 Second string to compare. |
| * @param max_len Maximum number of characters to consider. |
| * |
| * @return 0 if the strings are equal, -1 if first is smaller, |
| * 1 if second smaller. |
| * |
| */ |
| int str_lcmp(const char *s1, const char *s2, size_t max_len) |
| { |
| wchar_t c1 = 0; |
| wchar_t c2 = 0; |
| size_t off1 = 0; |
| size_t off2 = 0; |
| size_t len = 0; |
| while (true) { |
| if (len >= max_len) |
| break; |
| c1 = str_decode(s1, &off1, STR_NO_LIMIT); |
| c2 = str_decode(s2, &off2, STR_NO_LIMIT); |
| if (c1 < c2) |
| return -1; |
| if (c1 > c2) |
| return 1; |
| if (c1 == 0 || c2 == 0) |
| break; |
| ++len; |
| } |
| return 0; |
| } |
| /** Copy string. |
| * |
| * Copy source string @a src to destination buffer @a dest. |
| * No more than @a size bytes are written. If the size of the output buffer |
| * is at least one byte, the output string will always be well-formed, i.e. |
| * null-terminated and containing only complete characters. |
| * |
| * @param dst Destination buffer. |
| * @param count Size of the destination buffer (must be > 0). |
| * @param src Source string. |
| */ |
| void str_cpy(char *dest, size_t size, const char *src) |
| { |
| wchar_t ch; |
| size_t src_off; |
| size_t dest_off; |
| /* There must be space for a null terminator in the buffer. */ |
| assert(size > 0); |
| src_off = 0; |
| dest_off = 0; |
| while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) { |
| if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) |
| break; |
| } |
| dest[dest_off] = '\0'; |
| } |
| /** Copy size-limited substring. |
| * |
| * Copy prefix of string @a src of max. size @a size to destination buffer |
| * @a dest. No more than @a size bytes are written. The output string will |
| * always be well-formed, i.e. null-terminated and containing only complete |
| * characters. |
| * |
| * No more than @a n bytes are read from the input string, so it does not |
| * have to be null-terminated. |
| * |
| * @param dst Destination buffer. |
| * @param count Size of the destination buffer (must be > 0). |
| * @param src Source string. |
| * @param n Maximum number of bytes to read from @a src. |
| */ |
| void str_ncpy(char *dest, size_t size, const char *src, size_t n) |
| { |
| wchar_t ch; |
| size_t src_off; |
| size_t dest_off; |
| /* There must be space for a null terminator in the buffer. */ |
| assert(size > 0); |
| src_off = 0; |
| dest_off = 0; |
| while ((ch = str_decode(src, &src_off, n)) != 0) { |
| if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) |
| break; |
| } |
| dest[dest_off] = '\0'; |
| } |
| /** Append one string to another. |
| * |
| * Append source string @a src to string in destination buffer @a dest. |
| * Size of the destination buffer is @a dest. If the size of the output buffer |
| * is at least one byte, the output string will always be well-formed, i.e. |
| * null-terminated and containing only complete characters. |
| * |
| * @param dst Destination buffer. |
| * @param count Size of the destination buffer. |
| * @param src Source string. |
| */ |
| void str_append(char *dest, size_t size, const char *src) |
| { |
| size_t dstr_size; |
| dstr_size = str_size(dest); |
| str_cpy(dest + dstr_size, size - dstr_size, src); |
| } |
| /** Copy NULL-terminated wide string to string |
| * |
| * Copy source wide string @a src to destination buffer @a dst. |
| * No more than @a size bytes are written. NULL-terminator is always |
| * written after the last succesfully copied character (i.e. if the |
| * destination buffer is has at least 1 byte, it will be always |
| * NULL-terminated). |
| * |
| * @param src Source wide string. |
| * @param dst Destination buffer. |
| * @param count Size of the destination buffer. |
| * |
| */ |
| void wstr_nstr(char *dst, const wchar_t *src, size_t size) |
| { |
| /* No space for the NULL-terminator in the buffer */ |
| if (size == 0) |
| return; |
| wchar_t ch; |
| size_t src_idx = 0; |
| size_t dst_off = 0; |
| while ((ch = src[src_idx++]) != 0) { |
| if (chr_encode(ch, dst, &dst_off, size) != EOK) |
| break; |
| } |
| if (dst_off >= size) |
| dst[size - 1] = 0; |
| else |
| dst[dst_off] = 0; |
| } |
| /** Find first occurence of character in string. |
| * |
| * @param str String to search. |
| * @param ch Character to look for. |
| * |
| * @return Pointer to character in @a str or NULL if not found. |
| */ |
| char *str_chr(const char *str, wchar_t ch) |
| { |
| wchar_t acc; |
| size_t off = 0; |
| size_t last = 0; |
| while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) { |
| if (acc == ch) |
| return (char *) (str + last); |
| last = off; |
| } |
| return NULL; |
| } |
| /** Find last occurence of character in string. |
| * |
| * @param str String to search. |
| * @param ch Character to look for. |
| * |
| * @return Pointer to character in @a str or NULL if not found. |
| */ |
| char *str_rchr(const char *str, wchar_t ch) |
| { |
| wchar_t acc; |
| size_t off = 0; |
| size_t last = 0; |
| const char *res = NULL; |
| while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) { |
| if (acc == ch) |
| res = (str + last); |
| last = off; |
| } |
| return (char *) res; |
| } |
| /** Insert a wide character into a wide string. |
| * |
| * Insert a wide character into a wide string at position |
| * @a pos. The characters after the position are shifted. |
| * |
| * @param str String to insert to. |
| * @param ch Character to insert to. |
| * @param pos Character index where to insert. |
| @ @param max_pos Characters in the buffer. |
| * |
| * @return True if the insertion was sucessful, false if the position |
| * is out of bounds. |
| * |
| */ |
| bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos) |
| { |
| size_t len = wstr_length(str); |
| if ((pos > len) || (pos + 1 > max_pos)) |
| return false; |
| size_t i; |
| for (i = len; i + 1 > pos; i--) |
| str[i + 1] = str[i]; |
| str[pos] = ch; |
| return true; |
| } |
| /** Remove a wide character from a wide string. |
| * |
| * Remove a wide character from a wide string at position |
| * @a pos. The characters after the position are shifted. |
| * |
| * @param str String to remove from. |
| * @param pos Character index to remove. |
| * |
| * @return True if the removal was sucessful, false if the position |
| * is out of bounds. |
| * |
| */ |
| bool wstr_remove(wchar_t *str, size_t pos) |
| { |
| size_t len = wstr_length(str); |
| if (pos >= len) |
| return false; |
| size_t i; |
| for (i = pos + 1; i <= len; i++) |
| str[i - 1] = str[i]; |
| return true; |
| } |
| int stricmp(const char *a, const char *b) |
| { |
| int c = 0; |
| while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c])))) |
| c++; |
| return (tolower(a[c]) - tolower(b[c])); |
| } |
| /** Convert string to a number. |
| * Core of strtol and strtoul functions. |
| * |
| * @param nptr Pointer to string. |
| * @param endptr If not NULL, function stores here pointer to the first |
| * invalid character. |
| * @param base Zero or number between 2 and 36 inclusive. |
| * @param sgn It's set to 1 if minus found. |
| * @return Result of conversion. |
| */ |
| static unsigned long |
| _strtoul(const char *nptr, char **endptr, int base, char *sgn) |
| { |
| unsigned char c; |
| unsigned long result = 0; |
| unsigned long a, b; |
| const char *str = nptr; |
| const char *tmpptr; |
| while (isspace(*str)) |
| str++; |
| if (*str == '-') { |
| *sgn = 1; |
| ++str; |
| } else if (*str == '+') |
| ++str; |
| if (base) { |
| if ((base == 1) || (base > 36)) { |
| /* FIXME: set errno to EINVAL */ |
| return 0; |
| } |
| if ((base == 16) && (*str == '0') && ((str[1] == 'x') || |
| (str[1] == 'X'))) { |
| str += 2; |
| } |
| } else { |
| base = 10; |
| if (*str == '0') { |
| base = 8; |
| if ((str[1] == 'X') || (str[1] == 'x')) { |
| base = 16; |
| str += 2; |
| } |
| } |
| } |
| tmpptr = str; |
| while (*str) { |
| c = *str; |
| c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 : |
| (c <= '9' ? c - '0' : 0xff))); |
| if (c > base) { |
| break; |
| } |
| a = (result & 0xff) * base + c; |
| b = (result >> 8) * base + (a >> 8); |
| if (b > (ULONG_MAX >> 8)) { |
| /* overflow */ |
| /* FIXME: errno = ERANGE*/ |
| return ULONG_MAX; |
| } |
| result = (b << 8) + (a & 0xff); |
| ++str; |
| } |
| if (str == tmpptr) { |
| /* |
| * No number was found => first invalid character is the first |
| * character of the string. |
| */ |
| /* FIXME: set errno to EINVAL */ |
| str = nptr; |
| result = 0; |
| } |
| if (endptr) |
| *endptr = (char *) str; |
| if (nptr == str) { |
| /*FIXME: errno = EINVAL*/ |
| return 0; |
| } |
| return result; |
| } |
| /** Convert initial part of string to long int according to given base. |
| * The number may begin with an arbitrary number of whitespaces followed by |
| * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be |
| * inserted and the number will be taken as hexadecimal one. If the base is 0 |
| * and the number begin with a zero, number will be taken as octal one (as with |
| * base 8). Otherwise the base 0 is taken as decimal. |
| * |
| * @param nptr Pointer to string. |
| * @param endptr If not NULL, function stores here pointer to the first |
| * invalid character. |
| * @param base Zero or number between 2 and 36 inclusive. |
| * @return Result of conversion. |
| */ |
| long int strtol(const char *nptr, char **endptr, int base) |
| { |
| char sgn = 0; |
| unsigned long number = 0; |
| number = _strtoul(nptr, endptr, base, &sgn); |
| if (number > LONG_MAX) { |
| if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) { |
| /* FIXME: set 0 to errno */ |
| return number; |
| } |
| /* FIXME: set ERANGE to errno */ |
| return (sgn ? LONG_MIN : LONG_MAX); |
| } |
| return (sgn ? -number : number); |
| } |
| /** Convert initial part of string to unsigned long according to given base. |
| * The number may begin with an arbitrary number of whitespaces followed by |
| * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be |
| * inserted and the number will be taken as hexadecimal one. If the base is 0 |
| * and the number begin with a zero, number will be taken as octal one (as with |
| * base 8). Otherwise the base 0 is taken as decimal. |
| * |
| * @param nptr Pointer to string. |
| * @param endptr If not NULL, function stores here pointer to the first |
| * invalid character |
| * @param base Zero or number between 2 and 36 inclusive. |
| * @return Result of conversion. |
| */ |
| unsigned long strtoul(const char *nptr, char **endptr, int base) |
| { |
| char sgn = 0; |
| unsigned long number = 0; |
| number = _strtoul(nptr, endptr, base, &sgn); |
| return (sgn ? -number : number); |
| } |
| char *str_dup(const char *src) |
| { |
| size_t size = str_size(src); |
| void *dest = malloc(size + 1); |
| if (dest == NULL) |
| return (char *) NULL; |
| return (char *) memcpy(dest, src, size + 1); |
| } |
| char *strtok(char *s, const char *delim) |
| { |
| static char *next; |
| return strtok_r(s, delim, &next); |
| } |
| char *strtok_r(char *s, const char *delim, char **next) |
| { |
| char *start, *end; |
| if (s == NULL) |
| s = *next; |
| /* Skip over leading delimiters. */ |
| while (*s && (str_chr(delim, *s) != NULL)) ++s; |
| start = s; |
| /* Skip over token characters. */ |
| while (*s && (str_chr(delim, *s) == NULL)) ++s; |
| end = s; |
| *next = (*s ? s + 1 : s); |
| if (start == end) { |
| return NULL; /* No more tokens. */ |
| } |
| /* Overwrite delimiter with NULL terminator. */ |
| *end = '\0'; |
| return start; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/vfs/vfs.c |
|---|
| 0,0 → 1,651 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <vfs/vfs.h> |
| #include <vfs/canonify.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <ipc/ipc.h> |
| #include <ipc/services.h> |
| #include <async.h> |
| #include <atomic.h> |
| #include <futex.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <devmap.h> |
| #include <ipc/vfs.h> |
| #include <ipc/devmap.h> |
| static int vfs_phone = -1; |
| static futex_t vfs_phone_futex = FUTEX_INITIALIZER; |
| static futex_t cwd_futex = FUTEX_INITIALIZER; |
| DIR *cwd_dir = NULL; |
| char *cwd_path = NULL; |
| size_t cwd_size = 0; |
| char *absolutize(const char *path, size_t *retlen) |
| { |
| char *ncwd_path; |
| char *ncwd_path_nc; |
| futex_down(&cwd_futex); |
| size_t size = str_size(path); |
| if (*path != '/') { |
| if (!cwd_path) { |
| futex_up(&cwd_futex); |
| return NULL; |
| } |
| ncwd_path_nc = malloc(cwd_size + 1 + size + 1); |
| if (!ncwd_path_nc) { |
| futex_up(&cwd_futex); |
| return NULL; |
| } |
| str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path); |
| ncwd_path_nc[cwd_size] = '/'; |
| ncwd_path_nc[cwd_size + 1] = '\0'; |
| } else { |
| ncwd_path_nc = malloc(size + 1); |
| if (!ncwd_path_nc) { |
| futex_up(&cwd_futex); |
| return NULL; |
| } |
| ncwd_path_nc[0] = '\0'; |
| } |
| str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path); |
| ncwd_path = canonify(ncwd_path_nc, retlen); |
| if (!ncwd_path) { |
| futex_up(&cwd_futex); |
| free(ncwd_path_nc); |
| return NULL; |
| } |
| /* |
| * We need to clone ncwd_path because canonify() works in-place and thus |
| * the address in ncwd_path need not be the same as ncwd_path_nc, even |
| * though they both point into the same dynamically allocated buffer. |
| */ |
| ncwd_path = str_dup(ncwd_path); |
| free(ncwd_path_nc); |
| if (!ncwd_path) { |
| futex_up(&cwd_futex); |
| return NULL; |
| } |
| futex_up(&cwd_futex); |
| return ncwd_path; |
| } |
| static void vfs_connect(void) |
| { |
| while (vfs_phone < 0) |
| vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0); |
| } |
| int mount(const char *fs_name, const char *mp, const char *dev, |
| const char *opts, unsigned int flags) |
| { |
| int res; |
| ipcarg_t rc; |
| aid_t req; |
| dev_handle_t dev_handle; |
| res = devmap_device_get_handle(dev, &dev_handle, flags); |
| if (res != EOK) |
| return res; |
| size_t mpa_size; |
| char *mpa = absolutize(mp, &mpa_size); |
| if (!mpa) |
| return ENOMEM; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL); |
| rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(mpa); |
| return (int) rc; |
| } |
| rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(mpa); |
| return (int) rc; |
| } |
| rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(mpa); |
| return (int) rc; |
| } |
| /* Ask VFS whether it likes fs_name. */ |
| rc = async_req_0_0(vfs_phone, IPC_M_PING); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(mpa); |
| return (int) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(mpa); |
| return (int) rc; |
| } |
| static int _open(const char *path, int lflag, int oflag, ...) |
| { |
| ipcarg_t rc; |
| ipc_call_t answer; |
| aid_t req; |
| size_t pa_size; |
| char *pa = absolutize(path, &pa_size); |
| if (!pa) |
| return ENOMEM; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer); |
| rc = ipc_data_write_start(vfs_phone, pa, pa_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return (int) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| if (rc != EOK) |
| return (int) rc; |
| return (int) IPC_GET_ARG1(answer); |
| } |
| int open(const char *path, int oflag, ...) |
| { |
| return _open(path, L_FILE, oflag); |
| } |
| int open_node(fdi_node_t *node, int oflag) |
| { |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| ipc_call_t answer; |
| aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle, |
| node->dev_handle, node->index, oflag, &answer); |
| ipcarg_t rc; |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| if (rc != EOK) |
| return (int) rc; |
| return (int) IPC_GET_ARG1(answer); |
| } |
| int close(int fildes) |
| { |
| ipcarg_t rc; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return (int)rc; |
| } |
| ssize_t read(int fildes, void *buf, size_t nbyte) |
| { |
| ipcarg_t rc; |
| ipc_call_t answer; |
| aid_t req; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer); |
| rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return (ssize_t) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| if (rc == EOK) |
| return (ssize_t) IPC_GET_ARG1(answer); |
| else |
| return rc; |
| } |
| ssize_t write(int fildes, const void *buf, size_t nbyte) |
| { |
| ipcarg_t rc; |
| ipc_call_t answer; |
| aid_t req; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer); |
| rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return (ssize_t) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| if (rc == EOK) |
| return (ssize_t) IPC_GET_ARG1(answer); |
| else |
| return -1; |
| } |
| int fsync(int fildes) |
| { |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| ipcarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return (int) rc; |
| } |
| off_t lseek(int fildes, off_t offset, int whence) |
| { |
| ipcarg_t rc; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| ipcarg_t newoffs; |
| rc = async_req_3_1(vfs_phone, VFS_IN_SEEK, fildes, offset, whence, |
| &newoffs); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| if (rc != EOK) |
| return (off_t) -1; |
| return (off_t) newoffs; |
| } |
| int ftruncate(int fildes, off_t length) |
| { |
| ipcarg_t rc; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| rc = async_req_2_0(vfs_phone, VFS_IN_TRUNCATE, fildes, length); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return (int) rc; |
| } |
| int fstat(int fildes, struct stat *stat) |
| { |
| ipcarg_t rc; |
| aid_t req; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL); |
| rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return (ssize_t) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| return rc; |
| } |
| int stat(const char *path, struct stat *stat) |
| { |
| ipcarg_t rc; |
| aid_t req; |
| size_t pa_size; |
| char *pa = absolutize(path, &pa_size); |
| if (!pa) |
| return ENOMEM; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_0(vfs_phone, VFS_IN_STAT, NULL); |
| rc = ipc_data_write_start(vfs_phone, pa, pa_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return (int) rc; |
| } |
| rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return (int) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return rc; |
| } |
| DIR *opendir(const char *dirname) |
| { |
| DIR *dirp = malloc(sizeof(DIR)); |
| if (!dirp) |
| return NULL; |
| dirp->fd = _open(dirname, L_DIRECTORY, 0); |
| if (dirp->fd < 0) { |
| free(dirp); |
| return NULL; |
| } |
| return dirp; |
| } |
| struct dirent *readdir(DIR *dirp) |
| { |
| ssize_t len = read(dirp->fd, &dirp->res.d_name[0], NAME_MAX + 1); |
| if (len <= 0) |
| return NULL; |
| return &dirp->res; |
| } |
| void rewinddir(DIR *dirp) |
| { |
| (void) lseek(dirp->fd, 0, SEEK_SET); |
| } |
| int closedir(DIR *dirp) |
| { |
| (void) close(dirp->fd); |
| free(dirp); |
| return 0; |
| } |
| int mkdir(const char *path, mode_t mode) |
| { |
| ipcarg_t rc; |
| aid_t req; |
| size_t pa_size; |
| char *pa = absolutize(path, &pa_size); |
| if (!pa) |
| return ENOMEM; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL); |
| rc = ipc_data_write_start(vfs_phone, pa, pa_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return (int) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return rc; |
| } |
| static int _unlink(const char *path, int lflag) |
| { |
| ipcarg_t rc; |
| aid_t req; |
| size_t pa_size; |
| char *pa = absolutize(path, &pa_size); |
| if (!pa) |
| return ENOMEM; |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL); |
| rc = ipc_data_write_start(vfs_phone, pa, pa_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return (int) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(pa); |
| return rc; |
| } |
| int unlink(const char *path) |
| { |
| return _unlink(path, L_NONE); |
| } |
| int rmdir(const char *path) |
| { |
| return _unlink(path, L_DIRECTORY); |
| } |
| int rename(const char *old, const char *new) |
| { |
| ipcarg_t rc; |
| aid_t req; |
| size_t olda_size; |
| char *olda = absolutize(old, &olda_size); |
| if (!olda) |
| return ENOMEM; |
| size_t newa_size; |
| char *newa = absolutize(new, &newa_size); |
| if (!newa) { |
| free(olda); |
| return ENOMEM; |
| } |
| futex_down(&vfs_phone_futex); |
| async_serialize_start(); |
| vfs_connect(); |
| req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL); |
| rc = ipc_data_write_start(vfs_phone, olda, olda_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(olda); |
| free(newa); |
| return (int) rc; |
| } |
| rc = ipc_data_write_start(vfs_phone, newa, newa_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(olda); |
| free(newa); |
| return (int) rc; |
| } |
| async_wait_for(req, &rc); |
| async_serialize_end(); |
| futex_up(&vfs_phone_futex); |
| free(olda); |
| free(newa); |
| return rc; |
| } |
| int chdir(const char *path) |
| { |
| size_t pa_size; |
| char *pa = absolutize(path, &pa_size); |
| if (!pa) |
| return ENOMEM; |
| DIR *d = opendir(pa); |
| if (!d) { |
| free(pa); |
| return ENOENT; |
| } |
| futex_down(&cwd_futex); |
| if (cwd_dir) { |
| closedir(cwd_dir); |
| cwd_dir = NULL; |
| free(cwd_path); |
| cwd_path = NULL; |
| cwd_size = 0; |
| } |
| cwd_dir = d; |
| cwd_path = pa; |
| cwd_size = pa_size; |
| futex_up(&cwd_futex); |
| return EOK; |
| } |
| char *getcwd(char *buf, size_t size) |
| { |
| if (!size) |
| return NULL; |
| futex_down(&cwd_futex); |
| if (size < cwd_size + 1) { |
| futex_up(&cwd_futex); |
| return NULL; |
| } |
| str_cpy(buf, size, cwd_path); |
| futex_up(&cwd_futex); |
| return buf; |
| } |
| int fd_phone(int fildes) |
| { |
| struct stat stat; |
| int rc; |
| rc = fstat(fildes, &stat); |
| if (!stat.devfs_stat.device) |
| return -1; |
| return devmap_device_connect(stat.devfs_stat.device, 0); |
| } |
| int fd_node(int fildes, fdi_node_t *node) |
| { |
| struct stat stat; |
| int rc; |
| rc = fstat(fildes, &stat); |
| if (rc == EOK) { |
| node->fs_handle = stat.fs_handle; |
| node->dev_handle = stat.dev_handle; |
| node->index = stat.index; |
| } |
| return rc; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/vfs/canonify.c |
|---|
| 0,0 → 1,341 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| * @brief |
| */ |
| #include <stdlib.h> |
| #include <vfs/canonify.h> |
| /** Token types used for tokenization of path. */ |
| typedef enum { |
| TK_INVALID, |
| TK_SLASH, |
| TK_DOT, |
| TK_DOTDOT, |
| TK_COMP, |
| TK_NUL |
| } tokval_t; |
| typedef struct { |
| tokval_t kind; |
| char *start; |
| char *stop; |
| } token_t; |
| /** Fake up the TK_SLASH token. */ |
| static token_t slash_token(char *start) |
| { |
| token_t ret; |
| ret.kind = TK_SLASH; |
| ret.start = start; |
| ret.stop = start; |
| return ret; |
| } |
| /** Given a token, return the next token. */ |
| static token_t next_token(token_t *cur) |
| { |
| token_t ret; |
| if (cur->stop[1] == '\0') { |
| ret.kind = TK_NUL; |
| ret.start = cur->stop + 1; |
| ret.stop = ret.start; |
| return ret; |
| } |
| if (cur->stop[1] == '/') { |
| ret.kind = TK_SLASH; |
| ret.start = cur->stop + 1; |
| ret.stop = ret.start; |
| return ret; |
| } |
| if (cur->stop[1] == '.' && (!cur->stop[2] || cur->stop[2] == '/')) { |
| ret.kind = TK_DOT; |
| ret.start = cur->stop + 1; |
| ret.stop = ret.start; |
| return ret; |
| } |
| if (cur->stop[1] == '.' && cur->stop[2] == '.' && |
| (!cur->stop[3] || cur->stop[3] == '/')) { |
| ret.kind = TK_DOTDOT; |
| ret.start = cur->stop + 1; |
| ret.stop = cur->stop + 2; |
| return ret; |
| } |
| unsigned i; |
| for (i = 1; cur->stop[i] && cur->stop[i] != '/'; i++) |
| ; |
| ret.kind = TK_COMP; |
| ret.start = &cur->stop[1]; |
| ret.stop = &cur->stop[i - 1]; |
| return ret; |
| } |
| /** States used by canonify(). */ |
| typedef enum { |
| S_INI, |
| S_A, |
| S_B, |
| S_C, |
| S_ACCEPT, |
| S_RESTART, |
| S_REJECT |
| } state_t; |
| typedef struct { |
| state_t s; |
| void (* f)(token_t *, token_t *, token_t *); |
| } change_state_t; |
| /* |
| * Actions that can be performed when transitioning from one |
| * state of canonify() to another. |
| */ |
| static void set_first_slash(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| *tfsl = *t; |
| *tlcomp = *t; |
| } |
| static void save_component(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| *tlcomp = *t; |
| } |
| static void terminate_slash(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| if (tfsl->stop[1]) /* avoid writing to a well-formatted path */ |
| tfsl->stop[1] = '\0'; |
| } |
| static void remove_trailing_slash(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| t->start[-1] = '\0'; |
| } |
| /** Eat the extra '/'.. |
| * |
| * @param t The current TK_SLASH token. |
| */ |
| static void shift_slash(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| char *p = t->start; |
| char *q = t->stop + 1; |
| while ((*p++ = *q++)) |
| ; |
| } |
| /** Eat the extra '.'. |
| * |
| * @param t The current TK_DOT token. |
| */ |
| static void shift_dot(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| char *p = t->start; |
| char *q = t->stop + 1; |
| while ((*p++ = *q++)) |
| ; |
| } |
| /** Collapse the TK_COMP TK_SLASH TK_DOTDOT pattern. |
| * |
| * @param t The current TK_DOTDOT token. |
| * @param tlcomp The last TK_COMP token. |
| */ |
| static void shift_dotdot(token_t *t, token_t *tfsl, token_t *tlcomp) |
| { |
| char *p = tlcomp->start; |
| char *q = t->stop + 1; |
| while ((*p++ = *q++)) |
| ; |
| } |
| /** Transition function for canonify(). */ |
| static change_state_t trans[4][6] = { |
| [S_INI] = { |
| [TK_SLASH] = { |
| .s = S_A, |
| .f = set_first_slash, |
| }, |
| [TK_DOT] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_DOTDOT] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_COMP] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_NUL] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_INVALID] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| }, |
| [S_A] = { |
| [TK_SLASH] = { |
| .s = S_A, |
| .f = set_first_slash, |
| }, |
| [TK_DOT] = { |
| .s = S_A, |
| .f = NULL, |
| }, |
| [TK_DOTDOT] = { |
| .s = S_A, |
| .f = NULL, |
| }, |
| [TK_COMP] = { |
| .s = S_B, |
| .f = save_component, |
| }, |
| [TK_NUL] = { |
| .s = S_ACCEPT, |
| .f = terminate_slash, |
| }, |
| [TK_INVALID] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| }, |
| [S_B] = { |
| [TK_SLASH] = { |
| .s = S_C, |
| .f = NULL, |
| }, |
| [TK_DOT] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_DOTDOT] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_COMP] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| [TK_NUL] = { |
| .s = S_ACCEPT, |
| .f = NULL, |
| }, |
| [TK_INVALID] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| }, |
| [S_C] = { |
| [TK_SLASH] = { |
| .s = S_RESTART, |
| .f = shift_slash, |
| }, |
| [TK_DOT] = { |
| .s = S_RESTART, |
| .f = shift_dot, |
| }, |
| [TK_DOTDOT] = { |
| .s = S_RESTART, |
| .f = shift_dotdot, |
| }, |
| [TK_COMP] = { |
| .s = S_B, |
| .f = save_component, |
| }, |
| [TK_NUL] = { |
| .s = S_ACCEPT, |
| .f = remove_trailing_slash, |
| }, |
| [TK_INVALID] = { |
| .s = S_REJECT, |
| .f = NULL, |
| }, |
| } |
| }; |
| /** Canonify a file system path. |
| * |
| * A file system path is canonical, if the following holds: |
| * 1) the path is absolute (i.e. a/b/c is not canonical) |
| * 2) there is no trailing slash in the path (i.e. /a/b/c is not canonical) |
| * 3) there is no extra slash in the path (i.e. /a//b/c is not canonical) |
| * 4) there is no '.' component in the path (i.e. /a/./b/c is not canonical) |
| * 5) there is no '..' component in the path (i.e. /a/b/../c is not canonical) |
| * |
| * This function makes a potentially non-canonical file system path canonical. |
| * It works in-place and requires a NULL-terminated input string. |
| * |
| * @param path Path to be canonified. |
| * @param lenp Pointer where the length of the final path will be |
| * stored. Can be NULL. |
| * |
| * @return Canonified path or NULL on failure. |
| */ |
| char *canonify(char *path, size_t *lenp) |
| { |
| state_t state; |
| token_t t; |
| token_t tfsl; /* first slash */ |
| token_t tlcomp; /* last component */ |
| if (*path != '/') |
| return NULL; |
| tfsl = slash_token(path); |
| restart: |
| state = S_INI; |
| t = tfsl; |
| tlcomp = tfsl; |
| while (state != S_ACCEPT && state != S_RESTART && state != S_REJECT) { |
| if (trans[state][t.kind].f) |
| trans[state][t.kind].f(&t, &tfsl, &tlcomp); |
| state = trans[state][t.kind].s; |
| t = next_token(&t); |
| } |
| switch (state) { |
| case S_RESTART: |
| goto restart; |
| case S_REJECT: |
| return NULL; |
| case S_ACCEPT: |
| if (lenp) |
| *lenp = (size_t)((tlcomp.stop - tfsl.start) + 1); |
| return tfsl.start; |
| default: |
| abort(); |
| } |
| } |
| /** |
| * @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/malloc.c |
|---|
| 0,0 → 1,475 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * Copyright (c) 2009 Petr Tuma |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <malloc.h> |
| #include <bool.h> |
| #include <as.h> |
| #include <align.h> |
| #include <macros.h> |
| #include <assert.h> |
| #include <errno.h> |
| #include <bitops.h> |
| #include <mem.h> |
| #include <adt/gcdlcm.h> |
| /* Magic used in heap headers. */ |
| #define HEAP_BLOCK_HEAD_MAGIC 0xBEEF0101 |
| /* Magic used in heap footers. */ |
| #define HEAP_BLOCK_FOOT_MAGIC 0xBEEF0202 |
| /** Allocation alignment (this also covers the alignment of fields |
| in the heap header and footer) */ |
| #define BASE_ALIGN 16 |
| /** |
| * Either 4 * 256M on 32-bit architecures or 16 * 256M on 64-bit architectures |
| */ |
| #define MAX_HEAP_SIZE (sizeof(uintptr_t) << 28) |
| /** |
| * |
| */ |
| #define STRUCT_OVERHEAD (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t)) |
| /** |
| * Calculate real size of a heap block (with header and footer) |
| */ |
| #define GROSS_SIZE(size) ((size) + STRUCT_OVERHEAD) |
| /** |
| * Calculate net size of a heap block (without header and footer) |
| */ |
| #define NET_SIZE(size) ((size) - STRUCT_OVERHEAD) |
| /** Header of a heap block |
| * |
| */ |
| typedef struct { |
| /* Size of the block (including header and footer) */ |
| size_t size; |
| /* Indication of a free block */ |
| bool free; |
| /* A magic value to detect overwrite of heap header */ |
| uint32_t magic; |
| } heap_block_head_t; |
| /** Footer of a heap block |
| * |
| */ |
| typedef struct { |
| /* Size of the block (including header and footer) */ |
| size_t size; |
| /* A magic value to detect overwrite of heap footer */ |
| uint32_t magic; |
| } heap_block_foot_t; |
| /** Linker heap symbol */ |
| extern char _heap; |
| /** Address of heap start */ |
| static void *heap_start = 0; |
| /** Address of heap end */ |
| static void *heap_end = 0; |
| /** Maximum heap size */ |
| static size_t max_heap_size = (size_t) -1; |
| /** Current number of pages of heap area */ |
| static size_t heap_pages = 0; |
| /** Initialize a heap block |
| * |
| * Fills in the structures related to a heap block. |
| * |
| * @param addr Address of the block. |
| * @param size Size of the block including the header and the footer. |
| * @param free Indication of a free block. |
| * |
| */ |
| static void block_init(void *addr, size_t size, bool free) |
| { |
| /* Calculate the position of the header and the footer */ |
| heap_block_head_t *head = (heap_block_head_t *) addr; |
| heap_block_foot_t *foot = |
| (heap_block_foot_t *) (addr + size - sizeof(heap_block_foot_t)); |
| head->size = size; |
| head->free = free; |
| head->magic = HEAP_BLOCK_HEAD_MAGIC; |
| foot->size = size; |
| foot->magic = HEAP_BLOCK_FOOT_MAGIC; |
| } |
| /** Check a heap block |
| * |
| * Verifies that the structures related to a heap block still contain |
| * the magic constants. This helps detect heap corruption early on. |
| * |
| * @param addr Address of the block. |
| * |
| */ |
| static void block_check(void *addr) |
| { |
| heap_block_head_t *head = (heap_block_head_t *) addr; |
| assert(head->magic == HEAP_BLOCK_HEAD_MAGIC); |
| heap_block_foot_t *foot = |
| (heap_block_foot_t *) (addr + head->size - sizeof(heap_block_foot_t)); |
| assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC); |
| assert(head->size == foot->size); |
| } |
| static bool grow_heap(size_t size) |
| { |
| if (size == 0) |
| return false; |
| size_t heap_size = (size_t) (heap_end - heap_start); |
| if ((max_heap_size != (size_t) -1) && (heap_size + size > max_heap_size)) |
| return false; |
| size_t pages = (size - 1) / PAGE_SIZE + 1; |
| if (as_area_resize((void *) &_heap, (heap_pages + pages) * PAGE_SIZE, 0) |
| == EOK) { |
| void *end = (void *) ALIGN_DOWN(((uintptr_t) &_heap) + |
| (heap_pages + pages) * PAGE_SIZE, BASE_ALIGN); |
| block_init(heap_end, end - heap_end, true); |
| heap_pages += pages; |
| heap_end = end; |
| return true; |
| } |
| return false; |
| } |
| static void shrink_heap(void) |
| { |
| // TODO |
| } |
| /** Initialize the heap allocator |
| * |
| * Finds how much physical memory we have and creates |
| * the heap management structures that mark the whole |
| * physical memory as a single free block. |
| * |
| */ |
| void __heap_init(void) |
| { |
| if (as_area_create((void *) &_heap, PAGE_SIZE, |
| AS_AREA_WRITE | AS_AREA_READ)) { |
| heap_pages = 1; |
| heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN); |
| heap_end = |
| (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN); |
| /* Make the entire area one large block. */ |
| block_init(heap_start, heap_end - heap_start, true); |
| } |
| } |
| uintptr_t get_max_heap_addr(void) |
| { |
| if (max_heap_size == (size_t) -1) |
| max_heap_size = |
| max((size_t) (heap_end - heap_start), MAX_HEAP_SIZE); |
| return ((uintptr_t) heap_start + max_heap_size); |
| } |
| static void split_mark(heap_block_head_t *cur, const size_t size) |
| { |
| assert(cur->size >= size); |
| /* See if we should split the block. */ |
| size_t split_limit = GROSS_SIZE(size); |
| if (cur->size > split_limit) { |
| /* Block big enough -> split. */ |
| void *next = ((void *) cur) + size; |
| block_init(next, cur->size - size, true); |
| block_init(cur, size, false); |
| } else { |
| /* Block too small -> use as is. */ |
| cur->free = false; |
| } |
| } |
| /** Allocate a memory block |
| * |
| * @param size The size of the block to allocate. |
| * @param align Memory address alignment. |
| * |
| * @return the address of the block or NULL when not enough memory. |
| * |
| */ |
| static void *malloc_internal(const size_t size, const size_t align) |
| { |
| if (align == 0) |
| return NULL; |
| size_t falign = lcm(align, BASE_ALIGN); |
| size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign)); |
| bool grown = false; |
| void *result; |
| loop: |
| result = NULL; |
| heap_block_head_t *cur = (heap_block_head_t *) heap_start; |
| while ((result == NULL) && ((void *) cur < heap_end)) { |
| block_check(cur); |
| /* Try to find a block that is free and large enough. */ |
| if ((cur->free) && (cur->size >= real_size)) { |
| /* We have found a suitable block. |
| Check for alignment properties. */ |
| void *addr = ((void *) cur) + sizeof(heap_block_head_t); |
| void *aligned = (void *) ALIGN_UP(addr, falign); |
| if (addr == aligned) { |
| /* Exact block start including alignment. */ |
| split_mark(cur, real_size); |
| result = addr; |
| } else { |
| /* Block start has to be aligned */ |
| size_t excess = (size_t) (aligned - addr); |
| if (cur->size >= real_size + excess) { |
| /* The current block is large enough to fit |
| data in including alignment */ |
| if ((void *) cur > heap_start) { |
| /* There is a block before the current block. |
| This previous block can be enlarged to compensate |
| for the alignment excess */ |
| heap_block_foot_t *prev_foot = |
| ((void *) cur) - sizeof(heap_block_foot_t); |
| heap_block_head_t *prev_head = |
| (heap_block_head_t *) (((void *) cur) - prev_foot->size); |
| block_check(prev_head); |
| size_t reduced_size = cur->size - excess; |
| heap_block_head_t *next_head = ((void *) cur) + excess; |
| if ((!prev_head->free) && (excess >= STRUCT_OVERHEAD)) { |
| /* The previous block is not free and there is enough |
| space to fill in a new free block between the previous |
| and current block */ |
| block_init(cur, excess, true); |
| } else { |
| /* The previous block is free (thus there is no need to |
| induce additional fragmentation to the heap) or the |
| excess is small, thus just enlarge the previous block */ |
| block_init(prev_head, prev_head->size + excess, prev_head->free); |
| } |
| block_init(next_head, reduced_size, true); |
| split_mark(next_head, real_size); |
| result = aligned; |
| cur = next_head; |
| } else { |
| /* The current block is the first block on the heap. |
| We have to make sure that the alignment excess |
| is large enough to fit a new free block just |
| before the current block */ |
| while (excess < STRUCT_OVERHEAD) { |
| aligned += falign; |
| excess += falign; |
| } |
| /* Check for current block size again */ |
| if (cur->size >= real_size + excess) { |
| size_t reduced_size = cur->size - excess; |
| cur = (heap_block_head_t *) (heap_start + excess); |
| block_init(heap_start, excess, true); |
| block_init(cur, reduced_size, true); |
| split_mark(cur, real_size); |
| result = aligned; |
| } |
| } |
| } |
| } |
| } |
| /* Advance to the next block. */ |
| cur = (heap_block_head_t *) (((void *) cur) + cur->size); |
| } |
| if ((result == NULL) && (!grown)) { |
| if (grow_heap(real_size)) { |
| grown = true; |
| goto loop; |
| } |
| } |
| return result; |
| } |
| void *malloc(const size_t size) |
| { |
| return malloc_internal(size, BASE_ALIGN); |
| } |
| void *memalign(const size_t align, const size_t size) |
| { |
| if (align == 0) |
| return NULL; |
| size_t palign = |
| 1 << (fnzb(max(sizeof(void *), align) - 1) + 1); |
| return malloc_internal(size, palign); |
| } |
| void *realloc(const void *addr, const size_t size) |
| { |
| if (addr == NULL) |
| return malloc(size); |
| /* Calculate the position of the header. */ |
| heap_block_head_t *head = |
| (heap_block_head_t *) (addr - sizeof(heap_block_head_t)); |
| assert((void *) head >= heap_start); |
| assert((void *) head < heap_end); |
| block_check(head); |
| assert(!head->free); |
| void *ptr = NULL; |
| size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN)); |
| size_t orig_size = head->size; |
| if (orig_size > real_size) { |
| /* Shrink */ |
| if (orig_size - real_size >= STRUCT_OVERHEAD) { |
| /* Split the original block to a full block |
| and a tailing free block */ |
| block_init((void *) head, real_size, false); |
| block_init((void *) head + real_size, |
| orig_size - real_size, true); |
| shrink_heap(); |
| } |
| ptr = ((void *) head) + sizeof(heap_block_head_t); |
| } else { |
| /* Look at the next block. If it is free and the size is |
| sufficient then merge the two. */ |
| heap_block_head_t *next_head = |
| (heap_block_head_t *) (((void *) head) + head->size); |
| if (((void *) next_head < heap_end) && |
| (head->size + next_head->size >= real_size) && |
| (next_head->free)) { |
| block_check(next_head); |
| block_init(head, head->size + next_head->size, false); |
| split_mark(head, real_size); |
| ptr = ((void *) head) + sizeof(heap_block_head_t); |
| } else { |
| ptr = malloc(size); |
| if (ptr != NULL) { |
| memcpy(ptr, addr, NET_SIZE(orig_size)); |
| free(addr); |
| } |
| } |
| } |
| return ptr; |
| } |
| /** Free a memory block |
| * |
| * @param addr The address of the block. |
| */ |
| void free(const void *addr) |
| { |
| /* Calculate the position of the header. */ |
| heap_block_head_t *head |
| = (heap_block_head_t *) (addr - sizeof(heap_block_head_t)); |
| assert((void *) head >= heap_start); |
| assert((void *) head < heap_end); |
| block_check(head); |
| assert(!head->free); |
| /* Mark the block itself as free. */ |
| head->free = true; |
| /* Look at the next block. If it is free, merge the two. */ |
| heap_block_head_t *next_head |
| = (heap_block_head_t *) (((void *) head) + head->size); |
| if ((void *) next_head < heap_end) { |
| block_check(next_head); |
| if (next_head->free) |
| block_init(head, head->size + next_head->size, true); |
| } |
| /* Look at the previous block. If it is free, merge the two. */ |
| if ((void *) head > heap_start) { |
| heap_block_foot_t *prev_foot = |
| (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t)); |
| heap_block_head_t *prev_head = |
| (heap_block_head_t *) (((void *) head) - prev_foot->size); |
| block_check(prev_head); |
| if (prev_head->free) |
| block_init(prev_head, prev_head->size + head->size, true); |
| } |
| shrink_heap(); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/console.c |
|---|
| 0,0 → 1,113 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * Copyright (c) 2006 Jakub Vana |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| #include <async.h> |
| #include <io/console.h> |
| #include <ipc/console.h> |
| void console_clear(int phone) |
| { |
| async_msg_0(phone, CONSOLE_CLEAR); |
| } |
| int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols) |
| { |
| return async_req_0_2(phone, CONSOLE_GET_SIZE, rows, cols); |
| } |
| void console_set_style(int phone, int style) |
| { |
| async_msg_1(phone, CONSOLE_SET_STYLE, style); |
| } |
| void console_set_color(int phone, int fg_color, int bg_color, int flags) |
| { |
| async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags); |
| } |
| void console_set_rgb_color(int phone, int fg_color, int bg_color) |
| { |
| async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color); |
| } |
| void console_cursor_visibility(int phone, bool show) |
| { |
| async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, show != false); |
| } |
| int console_get_color_cap(int phone, int *ccap) |
| { |
| ipcarg_t ccap_tmp; |
| int rc; |
| rc = async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, &ccap_tmp); |
| *ccap = ccap_tmp; |
| return rc; |
| } |
| void console_kcon_enable(int phone) |
| { |
| async_msg_0(phone, CONSOLE_KCON_ENABLE); |
| } |
| void console_goto(int phone, ipcarg_t row, ipcarg_t col) |
| { |
| async_msg_2(phone, CONSOLE_GOTO, row, col); |
| } |
| bool console_get_event(int phone, console_event_t *event) |
| { |
| ipcarg_t type; |
| ipcarg_t key; |
| ipcarg_t mods; |
| ipcarg_t c; |
| int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c); |
| if (rc < 0) |
| return false; |
| event->type = type; |
| event->key = key; |
| event->mods = mods; |
| event->c = c; |
| return true; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/io.c |
|---|
| 0,0 → 1,593 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <assert.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <bool.h> |
| #include <malloc.h> |
| #include <io/klog.h> |
| #include <vfs/vfs.h> |
| #include <ipc/devmap.h> |
| #include <adt/list.h> |
| static void _fflushbuf(FILE *stream); |
| static FILE stdin_null = { |
| .fd = -1, |
| .error = true, |
| .eof = true, |
| .klog = false, |
| .phone = -1, |
| .btype = _IONBF, |
| .buf = NULL, |
| .buf_size = 0, |
| .buf_head = NULL |
| }; |
| static FILE stdout_klog = { |
| .fd = -1, |
| .error = false, |
| .eof = false, |
| .klog = true, |
| .phone = -1, |
| .btype = _IOLBF, |
| .buf = NULL, |
| .buf_size = BUFSIZ, |
| .buf_head = NULL |
| }; |
| static FILE stderr_klog = { |
| .fd = -1, |
| .error = false, |
| .eof = false, |
| .klog = true, |
| .phone = -1, |
| .btype = _IONBF, |
| .buf = NULL, |
| .buf_size = 0, |
| .buf_head = NULL |
| }; |
| FILE *stdin = NULL; |
| FILE *stdout = NULL; |
| FILE *stderr = NULL; |
| static LIST_INITIALIZE(files); |
| void __stdio_init(int filc, fdi_node_t *filv[]) |
| { |
| if (filc > 0) { |
| stdin = fopen_node(filv[0], "r"); |
| } else { |
| stdin = &stdin_null; |
| list_append(&stdin->link, &files); |
| } |
| if (filc > 1) { |
| stdout = fopen_node(filv[1], "w"); |
| } else { |
| stdout = &stdout_klog; |
| list_append(&stdout->link, &files); |
| } |
| if (filc > 2) { |
| stderr = fopen_node(filv[2], "w"); |
| } else { |
| stderr = &stderr_klog; |
| list_append(&stderr->link, &files); |
| } |
| } |
| void __stdio_done(void) |
| { |
| link_t *link = files.next; |
| while (link != &files) { |
| FILE *file = list_get_instance(link, FILE, link); |
| fclose(file); |
| link = files.next; |
| } |
| } |
| static bool parse_mode(const char *mode, int *flags) |
| { |
| /* Parse mode except first character. */ |
| const char *mp = mode; |
| if (*mp++ == 0) { |
| errno = EINVAL; |
| return false; |
| } |
| if ((*mp == 'b') || (*mp == 't')) |
| mp++; |
| bool plus; |
| if (*mp == '+') { |
| mp++; |
| plus = true; |
| } else |
| plus = false; |
| if (*mp != 0) { |
| errno = EINVAL; |
| return false; |
| } |
| /* Parse first character of mode and determine flags for open(). */ |
| switch (mode[0]) { |
| case 'r': |
| *flags = plus ? O_RDWR : O_RDONLY; |
| break; |
| case 'w': |
| *flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY); |
| break; |
| case 'a': |
| /* TODO: a+ must read from beginning, append to the end. */ |
| if (plus) { |
| errno = ENOTSUP; |
| return false; |
| } |
| *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY); |
| default: |
| errno = EINVAL; |
| return false; |
| } |
| return true; |
| } |
| /** Set stream buffer. */ |
| void setvbuf(FILE *stream, void *buf, int mode, size_t size) |
| { |
| stream->btype = mode; |
| stream->buf = buf; |
| stream->buf_size = size; |
| stream->buf_head = stream->buf; |
| } |
| static void _setvbuf(FILE *stream) |
| { |
| /* FIXME: Use more complex rules for setting buffering options. */ |
| switch (stream->fd) { |
| case 1: |
| setvbuf(stream, NULL, _IOLBF, BUFSIZ); |
| break; |
| case 0: |
| case 2: |
| setvbuf(stream, NULL, _IONBF, 0); |
| break; |
| default: |
| setvbuf(stream, NULL, _IOFBF, BUFSIZ); |
| } |
| } |
| /** Allocate stream buffer. */ |
| static int _fallocbuf(FILE *stream) |
| { |
| assert(stream->buf == NULL); |
| stream->buf = malloc(stream->buf_size); |
| if (stream->buf == NULL) { |
| errno = ENOMEM; |
| return -1; |
| } |
| stream->buf_head = stream->buf; |
| return 0; |
| } |
| /** Open a stream. |
| * |
| * @param path Path of the file to open. |
| * @param mode Mode string, (r|w|a)[b|t][+]. |
| * |
| */ |
| FILE *fopen(const char *path, const char *mode) |
| { |
| int flags; |
| if (!parse_mode(mode, &flags)) |
| return NULL; |
| /* Open file. */ |
| FILE *stream = malloc(sizeof(FILE)); |
| if (stream == NULL) { |
| errno = ENOMEM; |
| return NULL; |
| } |
| stream->fd = open(path, flags, 0666); |
| if (stream->fd < 0) { |
| /* errno was set by open() */ |
| free(stream); |
| return NULL; |
| } |
| stream->error = false; |
| stream->eof = false; |
| stream->klog = false; |
| stream->phone = -1; |
| _setvbuf(stream); |
| list_append(&stream->link, &files); |
| return stream; |
| } |
| FILE *fdopen(int fd, const char *mode) |
| { |
| /* Open file. */ |
| FILE *stream = malloc(sizeof(FILE)); |
| if (stream == NULL) { |
| errno = ENOMEM; |
| return NULL; |
| } |
| stream->fd = fd; |
| stream->error = false; |
| stream->eof = false; |
| stream->klog = false; |
| stream->phone = -1; |
| _setvbuf(stream); |
| list_append(&stream->link, &files); |
| return stream; |
| } |
| FILE *fopen_node(fdi_node_t *node, const char *mode) |
| { |
| int flags; |
| if (!parse_mode(mode, &flags)) |
| return NULL; |
| /* Open file. */ |
| FILE *stream = malloc(sizeof(FILE)); |
| if (stream == NULL) { |
| errno = ENOMEM; |
| return NULL; |
| } |
| stream->fd = open_node(node, flags); |
| if (stream->fd < 0) { |
| /* errno was set by open_node() */ |
| free(stream); |
| return NULL; |
| } |
| stream->error = false; |
| stream->eof = false; |
| stream->klog = false; |
| stream->phone = -1; |
| _setvbuf(stream); |
| list_append(&stream->link, &files); |
| return stream; |
| } |
| int fclose(FILE *stream) |
| { |
| int rc = 0; |
| fflush(stream); |
| if (stream->phone >= 0) |
| ipc_hangup(stream->phone); |
| if (stream->fd >= 0) |
| rc = close(stream->fd); |
| list_remove(&stream->link); |
| if ((stream != &stdin_null) |
| && (stream != &stdout_klog) |
| && (stream != &stderr_klog)) |
| free(stream); |
| stream = NULL; |
| if (rc != 0) { |
| /* errno was set by close() */ |
| return EOF; |
| } |
| return 0; |
| } |
| /** Read from a stream. |
| * |
| * @param buf Destination buffer. |
| * @param size Size of each record. |
| * @param nmemb Number of records to read. |
| * @param stream Pointer to the stream. |
| * |
| */ |
| size_t fread(void *buf, size_t size, size_t nmemb, FILE *stream) |
| { |
| size_t left = size * nmemb; |
| size_t done = 0; |
| /* Make sure no data is pending write. */ |
| _fflushbuf(stream); |
| while ((left > 0) && (!stream->error) && (!stream->eof)) { |
| ssize_t rd = read(stream->fd, buf + done, left); |
| if (rd < 0) |
| stream->error = true; |
| else if (rd == 0) |
| stream->eof = true; |
| else { |
| left -= rd; |
| done += rd; |
| } |
| } |
| return (done / size); |
| } |
| static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream) |
| { |
| size_t left = size * nmemb; |
| size_t done = 0; |
| while ((left > 0) && (!stream->error)) { |
| ssize_t wr; |
| if (stream->klog) |
| wr = klog_write(buf + done, left); |
| else |
| wr = write(stream->fd, buf + done, left); |
| if (wr <= 0) |
| stream->error = true; |
| else { |
| left -= wr; |
| done += wr; |
| } |
| } |
| return (done / size); |
| } |
| /** Drain stream buffer, do not sync stream. */ |
| static void _fflushbuf(FILE *stream) |
| { |
| size_t bytes_used; |
| if ((!stream->buf) || (stream->btype == _IONBF) || (stream->error)) |
| return; |
| bytes_used = stream->buf_head - stream->buf; |
| if (bytes_used == 0) |
| return; |
| (void) _fwrite(stream->buf, 1, bytes_used, stream); |
| stream->buf_head = stream->buf; |
| } |
| /** Write to a stream. |
| * |
| * @param buf Source buffer. |
| * @param size Size of each record. |
| * @param nmemb Number of records to write. |
| * @param stream Pointer to the stream. |
| * |
| */ |
| size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream) |
| { |
| uint8_t *data; |
| size_t bytes_left; |
| size_t now; |
| size_t buf_free; |
| size_t total_written; |
| size_t i; |
| uint8_t b; |
| bool need_flush; |
| /* If not buffered stream, write out directly. */ |
| if (stream->btype == _IONBF) { |
| now = _fwrite(buf, size, nmemb, stream); |
| fflush(stream); |
| return now; |
| } |
| /* Perform lazy allocation of stream buffer. */ |
| if (stream->buf == NULL) { |
| if (_fallocbuf(stream) != 0) |
| return 0; /* Errno set by _fallocbuf(). */ |
| } |
| data = (uint8_t *) buf; |
| bytes_left = size * nmemb; |
| total_written = 0; |
| need_flush = false; |
| while ((!stream->error) && (bytes_left > 0)) { |
| buf_free = stream->buf_size - (stream->buf_head - stream->buf); |
| if (bytes_left > buf_free) |
| now = buf_free; |
| else |
| now = bytes_left; |
| for (i = 0; i < now; i++) { |
| b = data[i]; |
| stream->buf_head[i] = b; |
| if ((b == '\n') && (stream->btype == _IOLBF)) |
| need_flush = true; |
| } |
| buf += now; |
| stream->buf_head += now; |
| buf_free -= now; |
| bytes_left -= now; |
| total_written += now; |
| if (buf_free == 0) { |
| /* Only need to drain buffer. */ |
| _fflushbuf(stream); |
| need_flush = false; |
| } |
| } |
| if (need_flush) |
| fflush(stream); |
| return (total_written / size); |
| } |
| int fputc(wchar_t c, FILE *stream) |
| { |
| char buf[STR_BOUNDS(1)]; |
| size_t sz = 0; |
| if (chr_encode(c, buf, &sz, STR_BOUNDS(1)) == EOK) { |
| size_t wr = fwrite(buf, sz, 1, stream); |
| if (wr < sz) |
| return EOF; |
| return (int) c; |
| } |
| return EOF; |
| } |
| int putchar(wchar_t c) |
| { |
| return fputc(c, stdout); |
| } |
| int fputs(const char *str, FILE *stream) |
| { |
| return fwrite(str, str_size(str), 1, stream); |
| } |
| int puts(const char *str) |
| { |
| return fputs(str, stdout); |
| } |
| int fgetc(FILE *stream) |
| { |
| char c; |
| /* This could be made faster by only flushing when needed. */ |
| if (stdout) |
| fflush(stdout); |
| if (stderr) |
| fflush(stderr); |
| if (fread(&c, sizeof(char), 1, stream) < sizeof(char)) |
| return EOF; |
| return (int) c; |
| } |
| int getchar(void) |
| { |
| return fgetc(stdin); |
| } |
| int fseek(FILE *stream, long offset, int origin) |
| { |
| off_t rc = lseek(stream->fd, offset, origin); |
| if (rc == (off_t) (-1)) { |
| /* errno has been set by lseek. */ |
| return -1; |
| } |
| stream->eof = false; |
| return 0; |
| } |
| void rewind(FILE *stream) |
| { |
| (void) fseek(stream, 0, SEEK_SET); |
| } |
| int fflush(FILE *stream) |
| { |
| _fflushbuf(stream); |
| if (stream->klog) { |
| klog_update(); |
| return EOK; |
| } |
| if (stream->fd >= 0) |
| return fsync(stream->fd); |
| return ENOENT; |
| } |
| int feof(FILE *stream) |
| { |
| return stream->eof; |
| } |
| int ferror(FILE *stream) |
| { |
| return stream->error; |
| } |
| int fphone(FILE *stream) |
| { |
| if (stream->fd >= 0) { |
| if (stream->phone < 0) |
| stream->phone = fd_phone(stream->fd); |
| return stream->phone; |
| } |
| return -1; |
| } |
| int fnode(FILE *stream, fdi_node_t *node) |
| { |
| if (stream->fd >= 0) |
| return fd_node(stream->fd, node); |
| return ENOENT; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/printf_core.c |
|---|
| 0,0 → 1,891 |
| /* |
| * Copyright (c) 2001-2004 Jakub Jermar |
| * Copyright (c) 2006 Josef Cejka |
| * Copyright (c) 2009 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** |
| * @file |
| * @brief Printing functions. |
| */ |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <io/printf_core.h> |
| #include <ctype.h> |
| #include <string.h> |
| /** show prefixes 0x or 0 */ |
| #define __PRINTF_FLAG_PREFIX 0x00000001 |
| /** signed / unsigned number */ |
| #define __PRINTF_FLAG_SIGNED 0x00000002 |
| /** print leading zeroes */ |
| #define __PRINTF_FLAG_ZEROPADDED 0x00000004 |
| /** align to left */ |
| #define __PRINTF_FLAG_LEFTALIGNED 0x00000010 |
| /** always show + sign */ |
| #define __PRINTF_FLAG_SHOWPLUS 0x00000020 |
| /** print space instead of plus */ |
| #define __PRINTF_FLAG_SPACESIGN 0x00000040 |
| /** show big characters */ |
| #define __PRINTF_FLAG_BIGCHARS 0x00000080 |
| /** number has - sign */ |
| #define __PRINTF_FLAG_NEGATIVE 0x00000100 |
| /** |
| * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0 |
| * to terminate string... (last one is only for better testing end of buffer by |
| * zero-filling subroutine) |
| */ |
| #define PRINT_NUMBER_BUFFER_SIZE (64 + 5) |
| /** Enumeration of possible arguments types. |
| */ |
| typedef enum { |
| PrintfQualifierByte = 0, |
| PrintfQualifierShort, |
| PrintfQualifierInt, |
| PrintfQualifierLong, |
| PrintfQualifierLongLong, |
| PrintfQualifierPointer |
| } qualifier_t; |
| static char nullstr[] = "(NULL)"; |
| static char digits_small[] = "0123456789abcdef"; |
| static char digits_big[] = "0123456789ABCDEF"; |
| static char invalch = U_SPECIAL; |
| /** Print one or more characters without adding newline. |
| * |
| * @param buf Buffer holding characters with size of |
| * at least size bytes. NULL is not allowed! |
| * @param size Size of the buffer in bytes. |
| * @param ps Output method and its data. |
| * |
| * @return Number of characters printed. |
| * |
| */ |
| static int printf_putnchars(const char *buf, size_t size, |
| printf_spec_t *ps) |
| { |
| return ps->str_write((void *) buf, size, ps->data); |
| } |
| /** Print one or more wide characters without adding newline. |
| * |
| * @param buf Buffer holding wide characters with size of |
| * at least size bytes. NULL is not allowed! |
| * @param size Size of the buffer in bytes. |
| * @param ps Output method and its data. |
| * |
| * @return Number of wide characters printed. |
| * |
| */ |
| static int printf_wputnchars(const wchar_t *buf, size_t size, |
| printf_spec_t *ps) |
| { |
| return ps->wstr_write((void *) buf, size, ps->data); |
| } |
| /** Print string without adding a newline. |
| * |
| * @param str String to print. |
| * @param ps Write function specification and support data. |
| * |
| * @return Number of characters printed. |
| * |
| */ |
| static int printf_putstr(const char *str, printf_spec_t *ps) |
| { |
| if (str == NULL) |
| return printf_putnchars(nullstr, str_size(nullstr), ps); |
| return ps->str_write((void *) str, str_size(str), ps->data); |
| } |
| /** Print one ASCII character. |
| * |
| * @param c ASCII character to be printed. |
| * @param ps Output method. |
| * |
| * @return Number of characters printed. |
| * |
| */ |
| static int printf_putchar(const char ch, printf_spec_t *ps) |
| { |
| if (!ascii_check(ch)) |
| return ps->str_write((void *) &invalch, 1, ps->data); |
| return ps->str_write(&ch, 1, ps->data); |
| } |
| /** Print one wide character. |
| * |
| * @param c Wide character to be printed. |
| * @param ps Output method. |
| * |
| * @return Number of characters printed. |
| * |
| */ |
| static int printf_putwchar(const wchar_t ch, printf_spec_t *ps) |
| { |
| if (!chr_check(ch)) |
| return ps->str_write((void *) &invalch, 1, ps->data); |
| return ps->wstr_write(&ch, sizeof(wchar_t), ps->data); |
| } |
| /** Print one formatted ASCII character. |
| * |
| * @param ch Character to print. |
| * @param width Width modifier. |
| * @param flags Flags that change the way the character is printed. |
| * |
| * @return Number of characters printed, negative value on failure. |
| * |
| */ |
| static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps) |
| { |
| size_t counter = 0; |
| if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { |
| while (--width > 0) { |
| /* |
| * One space is consumed by the character itself, hence |
| * the predecrement. |
| */ |
| if (printf_putchar(' ', ps) > 0) |
| counter++; |
| } |
| } |
| if (printf_putchar(ch, ps) > 0) |
| counter++; |
| while (--width > 0) { |
| /* |
| * One space is consumed by the character itself, hence |
| * the predecrement. |
| */ |
| if (printf_putchar(' ', ps) > 0) |
| counter++; |
| } |
| return (int) (counter + 1); |
| } |
| /** Print one formatted wide character. |
| * |
| * @param ch Character to print. |
| * @param width Width modifier. |
| * @param flags Flags that change the way the character is printed. |
| * |
| * @return Number of characters printed, negative value on failure. |
| * |
| */ |
| static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps) |
| { |
| size_t counter = 0; |
| if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { |
| while (--width > 0) { |
| /* |
| * One space is consumed by the character itself, hence |
| * the predecrement. |
| */ |
| if (printf_putchar(' ', ps) > 0) |
| counter++; |
| } |
| } |
| if (printf_putwchar(ch, ps) > 0) |
| counter++; |
| while (--width > 0) { |
| /* |
| * One space is consumed by the character itself, hence |
| * the predecrement. |
| */ |
| if (printf_putchar(' ', ps) > 0) |
| counter++; |
| } |
| return (int) (counter + 1); |
| } |
| /** Print string. |
| * |
| * @param str String to be printed. |
| * @param width Width modifier. |
| * @param precision Precision modifier. |
| * @param flags Flags that modify the way the string is printed. |
| * |
| * @return Number of characters printed, negative value on failure. |
| */ |
| static int print_str(char *str, int width, unsigned int precision, |
| uint32_t flags, printf_spec_t *ps) |
| { |
| if (str == NULL) |
| return printf_putstr(nullstr, ps); |
| /* Print leading spaces. */ |
| size_t strw = str_length(str); |
| if (precision == 0) |
| precision = strw; |
| /* Left padding */ |
| size_t counter = 0; |
| width -= precision; |
| if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { |
| while (width-- > 0) { |
| if (printf_putchar(' ', ps) == 1) |
| counter++; |
| } |
| } |
| /* Part of @a str fitting into the alloted space. */ |
| int retval; |
| size_t size = str_lsize(str, precision); |
| if ((retval = printf_putnchars(str, size, ps)) < 0) |
| return -counter; |
| counter += retval; |
| /* Right padding */ |
| while (width-- > 0) { |
| if (printf_putchar(' ', ps) == 1) |
| counter++; |
| } |
| return ((int) counter); |
| } |
| /** Print wide string. |
| * |
| * @param str Wide string to be printed. |
| * @param width Width modifier. |
| * @param precision Precision modifier. |
| * @param flags Flags that modify the way the string is printed. |
| * |
| * @return Number of wide characters printed, negative value on failure. |
| */ |
| static int print_wstr(wchar_t *str, int width, unsigned int precision, |
| uint32_t flags, printf_spec_t *ps) |
| { |
| if (str == NULL) |
| return printf_putstr(nullstr, ps); |
| /* Print leading spaces. */ |
| size_t strw = wstr_length(str); |
| if (precision == 0) |
| precision = strw; |
| /* Left padding */ |
| size_t counter = 0; |
| width -= precision; |
| if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { |
| while (width-- > 0) { |
| if (printf_putchar(' ', ps) == 1) |
| counter++; |
| } |
| } |
| /* Part of @a wstr fitting into the alloted space. */ |
| int retval; |
| size_t size = wstr_lsize(str, precision); |
| if ((retval = printf_wputnchars(str, size, ps)) < 0) |
| return -counter; |
| counter += retval; |
| /* Right padding */ |
| while (width-- > 0) { |
| if (printf_putchar(' ', ps) == 1) |
| counter++; |
| } |
| return ((int) counter); |
| } |
| /** Print a number in a given base. |
| * |
| * Print significant digits of a number in given base. |
| * |
| * @param num Number to print. |
| * @param width Width modifier. |
| * @param precision Precision modifier. |
| * @param base Base to print the number in (must be between 2 and 16). |
| * @param flags Flags that modify the way the number is printed. |
| * |
| * @return Number of characters printed. |
| * |
| */ |
| static int print_number(uint64_t num, int width, int precision, int base, |
| uint32_t flags, printf_spec_t *ps) |
| { |
| char *digits; |
| if (flags & __PRINTF_FLAG_BIGCHARS) |
| digits = digits_big; |
| else |
| digits = digits_small; |
| char data[PRINT_NUMBER_BUFFER_SIZE]; |
| char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1]; |
| /* Size of number with all prefixes and signs */ |
| int size = 0; |
| /* Put zero at end of string */ |
| *ptr-- = 0; |
| if (num == 0) { |
| *ptr-- = '0'; |
| size++; |
| } else { |
| do { |
| *ptr-- = digits[num % base]; |
| size++; |
| } while (num /= base); |
| } |
| /* Size of plain number */ |
| int number_size = size; |
| /* |
| * Collect the sum of all prefixes/signs/etc. to calculate padding and |
| * leading zeroes. |
| */ |
| if (flags & __PRINTF_FLAG_PREFIX) { |
| switch(base) { |
| case 2: |
| /* Binary formating is not standard, but usefull */ |
| size += 2; |
| break; |
| case 8: |
| size++; |
| break; |
| case 16: |
| size += 2; |
| break; |
| } |
| } |
| char sgn = 0; |
| if (flags & __PRINTF_FLAG_SIGNED) { |
| if (flags & __PRINTF_FLAG_NEGATIVE) { |
| sgn = '-'; |
| size++; |
| } else if (flags & __PRINTF_FLAG_SHOWPLUS) { |
| sgn = '+'; |
| size++; |
| } else if (flags & __PRINTF_FLAG_SPACESIGN) { |
| sgn = ' '; |
| size++; |
| } |
| } |
| if (flags & __PRINTF_FLAG_LEFTALIGNED) |
| flags &= ~__PRINTF_FLAG_ZEROPADDED; |
| /* |
| * If the number is left-aligned or precision is specified then |
| * padding with zeros is ignored. |
| */ |
| if (flags & __PRINTF_FLAG_ZEROPADDED) { |
| if ((precision == 0) && (width > size)) |
| precision = width - size + number_size; |
| } |
| /* Print leading spaces */ |
| if (number_size > precision) { |
| /* Print the whole number, not only a part */ |
| precision = number_size; |
| } |
| width -= precision + size - number_size; |
| size_t counter = 0; |
| if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) { |
| while (width-- > 0) { |
| if (printf_putchar(' ', ps) == 1) |
| counter++; |
| } |
| } |
| /* Print sign */ |
| if (sgn) { |
| if (printf_putchar(sgn, ps) == 1) |
| counter++; |
| } |
| /* Print prefix */ |
| if (flags & __PRINTF_FLAG_PREFIX) { |
| switch(base) { |
| case 2: |
| /* Binary formating is not standard, but usefull */ |
| if (printf_putchar('0', ps) == 1) |
| counter++; |
| if (flags & __PRINTF_FLAG_BIGCHARS) { |
| if (printf_putchar('B', ps) == 1) |
| counter++; |
| } else { |
| if (printf_putchar('b', ps) == 1) |
| counter++; |
| } |
| break; |
| case 8: |
| if (printf_putchar('o', ps) == 1) |
| counter++; |
| break; |
| case 16: |
| if (printf_putchar('0', ps) == 1) |
| counter++; |
| if (flags & __PRINTF_FLAG_BIGCHARS) { |
| if (printf_putchar('X', ps) == 1) |
| counter++; |
| } else { |
| if (printf_putchar('x', ps) == 1) |
| counter++; |
| } |
| break; |
| } |
| } |
| /* Print leading zeroes */ |
| precision -= number_size; |
| while (precision-- > 0) { |
| if (printf_putchar('0', ps) == 1) |
| counter++; |
| } |
| /* Print the number itself */ |
| int retval; |
| if ((retval = printf_putstr(++ptr, ps)) > 0) |
| counter += retval; |
| /* Print tailing spaces */ |
| while (width-- > 0) { |
| if (printf_putchar(' ', ps) == 1) |
| counter++; |
| } |
| return ((int) counter); |
| } |
| /** Print formatted string. |
| * |
| * Print string formatted according to the fmt parameter and variadic arguments. |
| * Each formatting directive must have the following form: |
| * |
| * \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION |
| * |
| * FLAGS:@n |
| * - "#" Force to print prefix. For \%o conversion, the prefix is 0, for |
| * \%x and \%X prefixes are 0x and 0X and for conversion \%b the |
| * prefix is 0b. |
| * |
| * - "-" Align to left. |
| * |
| * - "+" Print positive sign just as negative. |
| * |
| * - " " If the printed number is positive and "+" flag is not set, |
| * print space in place of sign. |
| * |
| * - "0" Print 0 as padding instead of spaces. Zeroes are placed between |
| * sign and the rest of the number. This flag is ignored if "-" |
| * flag is specified. |
| * |
| * WIDTH:@n |
| * - Specify the minimal width of a printed argument. If it is bigger, |
| * width is ignored. If width is specified with a "*" character instead of |
| * number, width is taken from parameter list. And integer parameter is |
| * expected before parameter for processed conversion specification. If |
| * this value is negative its absolute value is taken and the "-" flag is |
| * set. |
| * |
| * PRECISION:@n |
| * - Value precision. For numbers it specifies minimum valid numbers. |
| * Smaller numbers are printed with leading zeroes. Bigger numbers are not |
| * affected. Strings with more than precision characters are cut off. Just |
| * as with width, an "*" can be used used instead of a number. An integer |
| * value is then expected in parameters. When both width and precision are |
| * specified using "*", the first parameter is used for width and the |
| * second one for precision. |
| * |
| * TYPE:@n |
| * - "hh" Signed or unsigned char.@n |
| * - "h" Signed or unsigned short.@n |
| * - "" Signed or unsigned int (default value).@n |
| * - "l" Signed or unsigned long int.@n |
| * If conversion is "c", the character is wchar_t (wide character).@n |
| * If conversion is "s", the string is wchar_t * (wide string).@n |
| * - "ll" Signed or unsigned long long int.@n |
| * |
| * CONVERSION:@n |
| * - % Print percentile character itself. |
| * |
| * - c Print single character. The character is expected to be plain |
| * ASCII (e.g. only values 0 .. 127 are valid).@n |
| * If type is "l", then the character is expected to be wide character |
| * (e.g. values 0 .. 0x10ffff are valid). |
| * |
| * - s Print zero terminated string. If a NULL value is passed as |
| * value, "(NULL)" is printed instead.@n |
| * If type is "l", then the string is expected to be wide string. |
| * |
| * - P, p Print value of a pointer. Void * value is expected and it is |
| * printed in hexadecimal notation with prefix (as with \%#X / \%#x |
| * for 32-bit or \%#X / \%#x for 64-bit long pointers). |
| * |
| * - b Print value as unsigned binary number. Prefix is not printed by |
| * default. (Nonstandard extension.) |
| * |
| * - o Print value as unsigned octal number. Prefix is not printed by |
| * default. |
| * |
| * - d, i Print signed decimal number. There is no difference between d |
| * and i conversion. |
| * |
| * - u Print unsigned decimal number. |
| * |
| * - X, x Print hexadecimal number with upper- or lower-case. Prefix is |
| * not printed by default. |
| * |
| * All other characters from fmt except the formatting directives are printed |
| * verbatim. |
| * |
| * @param fmt Format NULL-terminated string. |
| * |
| * @return Number of characters printed, negative value on failure. |
| * |
| */ |
| int printf_core(const char *fmt, printf_spec_t *ps, va_list ap) |
| { |
| size_t i; /* Index of the currently processed character from fmt */ |
| size_t nxt = 0; /* Index of the next character from fmt */ |
| size_t j = 0; /* Index to the first not printed nonformating character */ |
| size_t counter = 0; /* Number of characters printed */ |
| int retval; /* Return values from nested functions */ |
| while (true) { |
| i = nxt; |
| wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| if (uc == 0) |
| break; |
| /* Control character */ |
| if (uc == '%') { |
| /* Print common characters if any processed */ |
| if (i > j) { |
| if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) { |
| /* Error */ |
| counter = -counter; |
| goto out; |
| } |
| counter += retval; |
| } |
| j = i; |
| /* Parse modifiers */ |
| uint32_t flags = 0; |
| bool end = false; |
| do { |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| switch (uc) { |
| case '#': |
| flags |= __PRINTF_FLAG_PREFIX; |
| break; |
| case '-': |
| flags |= __PRINTF_FLAG_LEFTALIGNED; |
| break; |
| case '+': |
| flags |= __PRINTF_FLAG_SHOWPLUS; |
| break; |
| case ' ': |
| flags |= __PRINTF_FLAG_SPACESIGN; |
| break; |
| case '0': |
| flags |= __PRINTF_FLAG_ZEROPADDED; |
| break; |
| default: |
| end = true; |
| }; |
| } while (!end); |
| /* Width & '*' operator */ |
| int width = 0; |
| if (isdigit(uc)) { |
| while (true) { |
| width *= 10; |
| width += uc - '0'; |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| if (uc == 0) |
| break; |
| if (!isdigit(uc)) |
| break; |
| } |
| } else if (uc == '*') { |
| /* Get width value from argument list */ |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| width = (int) va_arg(ap, int); |
| if (width < 0) { |
| /* Negative width sets '-' flag */ |
| width *= -1; |
| flags |= __PRINTF_FLAG_LEFTALIGNED; |
| } |
| } |
| /* Precision and '*' operator */ |
| int precision = 0; |
| if (uc == '.') { |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| if (isdigit(uc)) { |
| while (true) { |
| precision *= 10; |
| precision += uc - '0'; |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| if (uc == 0) |
| break; |
| if (!isdigit(uc)) |
| break; |
| } |
| } else if (uc == '*') { |
| /* Get precision value from the argument list */ |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| precision = (int) va_arg(ap, int); |
| if (precision < 0) { |
| /* Ignore negative precision */ |
| precision = 0; |
| } |
| } |
| } |
| qualifier_t qualifier; |
| switch (uc) { |
| /** @todo Unimplemented qualifiers: |
| * t ptrdiff_t - ISO C 99 |
| */ |
| case 'h': |
| /* Char or short */ |
| qualifier = PrintfQualifierShort; |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| if (uc == 'h') { |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| qualifier = PrintfQualifierByte; |
| } |
| break; |
| case 'l': |
| /* Long or long long */ |
| qualifier = PrintfQualifierLong; |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| if (uc == 'l') { |
| i = nxt; |
| uc = str_decode(fmt, &nxt, STR_NO_LIMIT); |
| qualifier = PrintfQualifierLongLong; |
| } |
| break; |
| default: |
| /* Default type */ |
| qualifier = PrintfQualifierInt; |
| } |
| unsigned int base = 10; |
| switch (uc) { |
| /* |
| * String and character conversions. |
| */ |
| case 's': |
| if (qualifier == PrintfQualifierLong) |
| retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps); |
| else |
| retval = print_str(va_arg(ap, char *), width, precision, flags, ps); |
| if (retval < 0) { |
| counter = -counter; |
| goto out; |
| } |
| counter += retval; |
| j = nxt; |
| goto next_char; |
| case 'c': |
| if (qualifier == PrintfQualifierLong) |
| retval = print_wchar(va_arg(ap, wchar_t), width, flags, ps); |
| else |
| retval = print_char(va_arg(ap, unsigned int), width, flags, ps); |
| if (retval < 0) { |
| counter = -counter; |
| goto out; |
| }; |
| counter += retval; |
| j = nxt; |
| goto next_char; |
| /* |
| * Integer values |
| */ |
| case 'P': |
| /* Pointer */ |
| flags |= __PRINTF_FLAG_BIGCHARS; |
| case 'p': |
| flags |= __PRINTF_FLAG_PREFIX; |
| base = 16; |
| qualifier = PrintfQualifierPointer; |
| break; |
| case 'b': |
| base = 2; |
| break; |
| case 'o': |
| base = 8; |
| break; |
| case 'd': |
| case 'i': |
| flags |= __PRINTF_FLAG_SIGNED; |
| case 'u': |
| break; |
| case 'X': |
| flags |= __PRINTF_FLAG_BIGCHARS; |
| case 'x': |
| base = 16; |
| break; |
| /* Percentile itself */ |
| case '%': |
| j = i; |
| goto next_char; |
| /* |
| * Bad formatting. |
| */ |
| default: |
| /* |
| * Unknown format. Now, j is the index of '%' |
| * so we will print whole bad format sequence. |
| */ |
| goto next_char; |
| } |
| /* Print integers */ |
| size_t size; |
| uint64_t number; |
| switch (qualifier) { |
| case PrintfQualifierByte: |
| size = sizeof(unsigned char); |
| number = (uint64_t) va_arg(ap, unsigned int); |
| break; |
| case PrintfQualifierShort: |
| size = sizeof(unsigned short); |
| number = (uint64_t) va_arg(ap, unsigned int); |
| break; |
| case PrintfQualifierInt: |
| size = sizeof(unsigned int); |
| number = (uint64_t) va_arg(ap, unsigned int); |
| break; |
| case PrintfQualifierLong: |
| size = sizeof(unsigned long); |
| number = (uint64_t) va_arg(ap, unsigned long); |
| break; |
| case PrintfQualifierLongLong: |
| size = sizeof(unsigned long long); |
| number = (uint64_t) va_arg(ap, unsigned long long); |
| break; |
| case PrintfQualifierPointer: |
| size = sizeof(void *); |
| number = (uint64_t) (unsigned long) va_arg(ap, void *); |
| break; |
| default: |
| /* Unknown qualifier */ |
| counter = -counter; |
| goto out; |
| } |
| if (flags & __PRINTF_FLAG_SIGNED) { |
| if (number & (0x1 << (size * 8 - 1))) { |
| flags |= __PRINTF_FLAG_NEGATIVE; |
| if (size == sizeof(uint64_t)) { |
| number = -((int64_t) number); |
| } else { |
| number = ~number; |
| number &= |
| ~(0xFFFFFFFFFFFFFFFFll << |
| (size * 8)); |
| number++; |
| } |
| } |
| } |
| if ((retval = print_number(number, width, precision, |
| base, flags, ps)) < 0) { |
| counter = -counter; |
| goto out; |
| } |
| counter += retval; |
| j = nxt; |
| } |
| next_char: |
| ; |
| } |
| if (i > j) { |
| if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) { |
| /* Error */ |
| counter = -counter; |
| goto out; |
| } |
| counter += retval; |
| } |
| out: |
| return ((int) counter); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/vprintf.c |
|---|
| 0,0 → 1,118 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <io/printf_core.h> |
| #include <futex.h> |
| #include <async.h> |
| #include <string.h> |
| static atomic_t printf_futex = FUTEX_INITIALIZER; |
| static int vprintf_str_write(const char *str, size_t size, void *stream) |
| { |
| size_t wr = fwrite(str, 1, size, (FILE *) stream); |
| return str_nlength(str, wr); |
| } |
| static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream) |
| { |
| size_t offset = 0; |
| size_t chars = 0; |
| while (offset < size) { |
| if (fputc(str[chars], (FILE *) stream) <= 0) |
| break; |
| chars++; |
| offset += sizeof(wchar_t); |
| } |
| return chars; |
| } |
| /** Print formatted text. |
| * |
| * @param stream Output stream |
| * @param fmt Format string |
| * @param ap Format parameters |
| * |
| * \see For more details about format string see printf_core. |
| * |
| */ |
| int vfprintf(FILE *stream, const char *fmt, va_list ap) |
| { |
| struct printf_spec ps = { |
| vprintf_str_write, |
| vprintf_wstr_write, |
| stream |
| }; |
| /* |
| * Prevent other threads to execute printf_core() |
| */ |
| futex_down(&printf_futex); |
| /* |
| * Prevent other fibrils of the same thread |
| * to execute printf_core() |
| */ |
| async_serialize_start(); |
| int ret = printf_core(fmt, &ps, ap); |
| async_serialize_end(); |
| futex_up(&printf_futex); |
| return ret; |
| } |
| /** Print formatted text to stdout. |
| * |
| * @param file Output stream |
| * @param fmt Format string |
| * @param ap Format parameters |
| * |
| * \see For more details about format string see printf_core. |
| * |
| */ |
| int vprintf(const char *fmt, va_list ap) |
| { |
| return vfprintf(stdout, fmt, ap); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/printf.c |
|---|
| 0,0 → 1,78 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <io/printf_core.h> |
| #include <stdio.h> |
| /** Print formatted text. |
| * |
| * @param stream Output stream |
| * @param fmt Format string |
| * |
| * \see For more details about format string see printf_core. |
| * |
| */ |
| int fprintf(FILE *stream, const char *fmt, ...) |
| { |
| va_list args; |
| va_start(args, fmt); |
| int ret = vfprintf(stream, fmt, args); |
| va_end(args); |
| return ret; |
| } |
| /** Print formatted text to stdout. |
| * |
| * @param fmt Format string |
| * |
| * \see For more details about format string see printf_core. |
| * |
| */ |
| int printf(const char *fmt, ...) |
| { |
| va_list args; |
| va_start(args, fmt); |
| int ret = vprintf(fmt, args); |
| va_end(args); |
| return ret; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/snprintf.c |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <io/printf_core.h> |
| /** Print formatted to the given buffer with limited size. |
| * |
| * @param str Buffer |
| * @param size Buffer size |
| * @param fmt Format string |
| * |
| * \see For more details about format string see printf_core. |
| * |
| */ |
| int snprintf(char *str, size_t size, const char *fmt, ...) |
| { |
| va_list args; |
| va_start(args, fmt); |
| int ret = vsnprintf(str, size, fmt, args); |
| va_end(args); |
| return ret; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/asprintf.c |
|---|
| 0,0 → 1,89 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <io/printf_core.h> |
| static int asprintf_str_write(const char *str, size_t count, void *unused) |
| { |
| return str_nlength(str, count); |
| } |
| static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused) |
| { |
| return wstr_nlength(str, count); |
| } |
| /** Allocate and print to string. |
| * |
| * @param strp Address of the pointer where to store the address of |
| * the newly allocated string. |
| * @fmt Format string. |
| * |
| * @return Number of characters printed or a negative error code. |
| * |
| */ |
| int asprintf(char **strp, const char *fmt, ...) |
| { |
| struct printf_spec ps = { |
| asprintf_str_write, |
| asprintf_wstr_write, |
| NULL |
| }; |
| va_list args; |
| va_start(args, fmt); |
| int ret = printf_core(fmt, &ps, args); |
| va_end(args); |
| if (ret > 0) { |
| *strp = malloc(STR_BOUNDS(ret) + 1); |
| if (*strp == NULL) |
| return -1; |
| va_start(args, fmt); |
| vsnprintf(*strp, STR_BOUNDS(ret) + 1, fmt, args); |
| va_end(args); |
| } |
| return ret; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/vsnprintf.c |
|---|
| 0,0 → 1,186 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <io/printf_core.h> |
| #include <errno.h> |
| typedef struct { |
| size_t size; /* Total size of the buffer (in bytes) */ |
| size_t len; /* Number of already used bytes */ |
| char *dst; /* Destination */ |
| } vsnprintf_data_t; |
| /** Write string to given buffer. |
| * |
| * Write at most data->size plain characters including trailing zero. |
| * According to C99, snprintf() has to return number of characters that |
| * would have been written if enough space had been available. Hence |
| * the return value is not the number of actually printed characters |
| * but size of the input string. |
| * |
| * @param str Source string to print. |
| * @param size Number of plain characters in str. |
| * @param data Structure describing destination string, counter |
| * of used space and total string size. |
| * |
| * @return Number of characters to print (not characters actually |
| * printed). |
| * |
| */ |
| static int vsnprintf_str_write(const char *str, size_t size, vsnprintf_data_t *data) |
| { |
| size_t left = data->size - data->len; |
| if (left == 0) |
| return ((int) size); |
| if (left == 1) { |
| /* We have only one free byte left in buffer |
| * -> store trailing zero |
| */ |
| data->dst[data->size - 1] = 0; |
| data->len = data->size; |
| return ((int) size); |
| } |
| if (left <= size) { |
| /* We do not have enough space for the whole string |
| * with the trailing zero => print only a part |
| * of string |
| */ |
| size_t index = 0; |
| while (index < size) { |
| wchar_t uc = str_decode(str, &index, size); |
| if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK) |
| break; |
| } |
| /* Put trailing zero at end, but not count it |
| * into data->len so it could be rewritten next time |
| */ |
| data->dst[data->len] = 0; |
| return ((int) size); |
| } |
| /* Buffer is big enought to print the whole string */ |
| memcpy((void *)(data->dst + data->len), (void *) str, size); |
| data->len += size; |
| /* Put trailing zero at end, but not count it |
| * into data->len so it could be rewritten next time |
| */ |
| data->dst[data->len] = 0; |
| return ((int) size); |
| } |
| /** Write wide string to given buffer. |
| * |
| * Write at most data->size plain characters including trailing zero. |
| * According to C99, snprintf() has to return number of characters that |
| * would have been written if enough space had been available. Hence |
| * the return value is not the number of actually printed characters |
| * but size of the input string. |
| * |
| * @param str Source wide string to print. |
| * @param size Number of bytes in str. |
| * @param data Structure describing destination string, counter |
| * of used space and total string size. |
| * |
| * @return Number of wide characters to print (not characters actually |
| * printed). |
| * |
| */ |
| static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data) |
| { |
| size_t index = 0; |
| while (index < (size / sizeof(wchar_t))) { |
| size_t left = data->size - data->len; |
| if (left == 0) |
| return ((int) size); |
| if (left == 1) { |
| /* We have only one free byte left in buffer |
| * -> store trailing zero |
| */ |
| data->dst[data->size - 1] = 0; |
| data->len = data->size; |
| return ((int) size); |
| } |
| if (chr_encode(str[index], data->dst, &data->len, data->size - 1) != EOK) |
| break; |
| index++; |
| } |
| /* Put trailing zero at end, but not count it |
| * into data->len so it could be rewritten next time |
| */ |
| data->dst[data->len] = 0; |
| return ((int) size); |
| } |
| int vsnprintf(char *str, size_t size, const char *fmt, va_list ap) |
| { |
| vsnprintf_data_t data = { |
| size, |
| 0, |
| str |
| }; |
| printf_spec_t ps = { |
| (int(*) (const char *, size_t, void *)) vsnprintf_str_write, |
| (int(*) (const wchar_t *, size_t, void *)) vsnprintf_wstr_write, |
| &data |
| }; |
| /* Print 0 at end of string - fix the case that nothing will be printed */ |
| if (size > 0) |
| str[0] = 0; |
| /* vsnprintf_write ensures that str will be terminated by zero. */ |
| return printf_core(fmt, &ps, ap); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/io/klog.c |
|---|
| 0,0 → 1,53 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * Copyright (c) 2006 Jakub Vana |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| #include <io/klog.h> |
| size_t klog_write(const void *buf, size_t size) |
| { |
| return (size_t) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, size); |
| } |
| void klog_update(void) |
| { |
| (void) __SYSCALL3(SYS_KLOG, 1, NULL, 0); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/fibril.c |
|---|
| 0,0 → 1,348 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * Copyright (c) 2007 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <adt/list.h> |
| #include <fibril.h> |
| #include <thread.h> |
| #include <tls.h> |
| #include <malloc.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <libarch/faddr.h> |
| #include <futex.h> |
| #include <assert.h> |
| #include <async.h> |
| #ifndef FIBRIL_INITIAL_STACK_PAGES_NO |
| #define FIBRIL_INITIAL_STACK_PAGES_NO 1 |
| #endif |
| /** |
| * This futex serializes access to ready_list, serialized_list and manager_list. |
| */ |
| static atomic_t fibril_futex = FUTEX_INITIALIZER; |
| static LIST_INITIALIZE(ready_list); |
| static LIST_INITIALIZE(serialized_list); |
| static LIST_INITIALIZE(manager_list); |
| static void fibril_main(void); |
| /** Number of threads that are executing a manager fibril. */ |
| static int threads_in_manager; |
| /** Number of threads that are executing a manager fibril and are serialized. */ |
| static int serialized_threads; /* Protected by async_futex */ |
| /** Fibril-local count of serialization. If > 0, we must not preempt */ |
| static fibril_local int serialization_count; |
| /** Setup fibril information into TCB structure */ |
| fibril_t *fibril_setup(void) |
| { |
| fibril_t *f; |
| tcb_t *tcb; |
| tcb = __make_tls(); |
| if (!tcb) |
| return NULL; |
| f = malloc(sizeof(fibril_t)); |
| if (!f) { |
| __free_tls(tcb); |
| return NULL; |
| } |
| tcb->fibril_data = f; |
| f->tcb = tcb; |
| f->func = NULL; |
| f->arg = NULL; |
| f->stack = NULL; |
| f->clean_after_me = NULL; |
| f->retval = 0; |
| f->flags = 0; |
| return f; |
| } |
| void fibril_teardown(fibril_t *f) |
| { |
| __free_tls(f->tcb); |
| free(f); |
| } |
| /** Function that spans the whole life-cycle of a fibril. |
| * |
| * Each fibril begins execution in this function. Then the function implementing |
| * the fibril logic is called. After its return, the return value is saved. |
| * The fibril then switches to another fibril, which cleans up after it. |
| */ |
| void fibril_main(void) |
| { |
| fibril_t *f = __tcb_get()->fibril_data; |
| /* Call the implementing function. */ |
| f->retval = f->func(f->arg); |
| fibril_switch(FIBRIL_FROM_DEAD); |
| /* not reached */ |
| } |
| /** Switch from the current fibril. |
| * |
| * If calling with FIBRIL_TO_MANAGER parameter, the async_futex should be |
| * held. |
| * |
| * @param stype Switch type. One of FIBRIL_PREEMPT, FIBRIL_TO_MANAGER, |
| * FIBRIL_FROM_MANAGER, FIBRIL_FROM_DEAD. The parameter |
| * describes the circumstances of the switch. |
| * @return Return 0 if there is no ready fibril, |
| * return 1 otherwise. |
| */ |
| int fibril_switch(fibril_switch_type_t stype) |
| { |
| fibril_t *srcf, *dstf; |
| int retval = 0; |
| futex_down(&fibril_futex); |
| if (stype == FIBRIL_PREEMPT && list_empty(&ready_list)) |
| goto ret_0; |
| if (stype == FIBRIL_FROM_MANAGER) { |
| if (list_empty(&ready_list) && list_empty(&serialized_list)) |
| goto ret_0; |
| /* |
| * Do not preempt if there is not enough threads to run the |
| * ready fibrils which are not serialized. |
| */ |
| if (list_empty(&serialized_list) && |
| threads_in_manager <= serialized_threads) { |
| goto ret_0; |
| } |
| } |
| /* If we are going to manager and none exists, create it */ |
| if (stype == FIBRIL_TO_MANAGER || stype == FIBRIL_FROM_DEAD) { |
| while (list_empty(&manager_list)) { |
| futex_up(&fibril_futex); |
| async_create_manager(); |
| futex_down(&fibril_futex); |
| } |
| } |
| srcf = __tcb_get()->fibril_data; |
| if (stype != FIBRIL_FROM_DEAD) { |
| /* Save current state */ |
| if (!context_save(&srcf->ctx)) { |
| if (serialization_count) |
| srcf->flags &= ~FIBRIL_SERIALIZED; |
| if (srcf->clean_after_me) { |
| /* |
| * Cleanup after the dead fibril from which we |
| * restored context here. |
| */ |
| void *stack = srcf->clean_after_me->stack; |
| if (stack) { |
| /* |
| * This check is necessary because a |
| * thread could have exited like a |
| * normal fibril using the |
| * FIBRIL_FROM_DEAD switch type. In that |
| * case, its fibril will not have the |
| * stack member filled. |
| */ |
| free(stack); |
| } |
| fibril_teardown(srcf->clean_after_me); |
| srcf->clean_after_me = NULL; |
| } |
| return 1; /* futex_up already done here */ |
| } |
| /* Save myself to the correct run list */ |
| if (stype == FIBRIL_PREEMPT) |
| list_append(&srcf->link, &ready_list); |
| else if (stype == FIBRIL_FROM_MANAGER) { |
| list_append(&srcf->link, &manager_list); |
| threads_in_manager--; |
| } else { |
| /* |
| * If stype == FIBRIL_TO_MANAGER, don't put ourselves to |
| * any list, we should already be somewhere, or we will |
| * be lost. |
| */ |
| } |
| } |
| /* Choose a new fibril to run */ |
| if (stype == FIBRIL_TO_MANAGER || stype == FIBRIL_FROM_DEAD) { |
| dstf = list_get_instance(manager_list.next, fibril_t, link); |
| if (serialization_count && stype == FIBRIL_TO_MANAGER) { |
| serialized_threads++; |
| srcf->flags |= FIBRIL_SERIALIZED; |
| } |
| threads_in_manager++; |
| if (stype == FIBRIL_FROM_DEAD) |
| dstf->clean_after_me = srcf; |
| } else { |
| if (!list_empty(&serialized_list)) { |
| dstf = list_get_instance(serialized_list.next, fibril_t, |
| link); |
| serialized_threads--; |
| } else { |
| dstf = list_get_instance(ready_list.next, fibril_t, |
| link); |
| } |
| } |
| list_remove(&dstf->link); |
| futex_up(&fibril_futex); |
| context_restore(&dstf->ctx); |
| /* not reached */ |
| ret_0: |
| futex_up(&fibril_futex); |
| return retval; |
| } |
| /** Create a new fibril. |
| * |
| * @param func Implementing function of the new fibril. |
| * @param arg Argument to pass to func. |
| * |
| * @return Return 0 on failure or TLS of the new fibril. |
| */ |
| fid_t fibril_create(int (*func)(void *), void *arg) |
| { |
| fibril_t *f; |
| f = fibril_setup(); |
| if (!f) |
| return 0; |
| f->stack = (char *) malloc(FIBRIL_INITIAL_STACK_PAGES_NO * |
| getpagesize()); |
| if (!f->stack) { |
| fibril_teardown(f); |
| return 0; |
| } |
| f->func = func; |
| f->arg = arg; |
| context_save(&f->ctx); |
| context_set(&f->ctx, FADDR(fibril_main), f->stack, |
| FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize(), f->tcb); |
| return (fid_t) f; |
| } |
| /** Add a fibril to the ready list. |
| * |
| * @param fid Pointer to the fibril structure of the fibril to be |
| * added. |
| */ |
| void fibril_add_ready(fid_t fid) |
| { |
| fibril_t *f; |
| f = (fibril_t *) fid; |
| futex_down(&fibril_futex); |
| if ((f->flags & FIBRIL_SERIALIZED)) |
| list_append(&f->link, &serialized_list); |
| else |
| list_append(&f->link, &ready_list); |
| futex_up(&fibril_futex); |
| } |
| /** Add a fibril to the manager list. |
| * |
| * @param fid Pointer to the fibril structure of the fibril to be |
| * added. |
| */ |
| void fibril_add_manager(fid_t fid) |
| { |
| fibril_t *f; |
| f = (fibril_t *) fid; |
| futex_down(&fibril_futex); |
| list_append(&f->link, &manager_list); |
| futex_up(&fibril_futex); |
| } |
| /** Remove one manager from the manager list. */ |
| void fibril_remove_manager(void) |
| { |
| futex_down(&fibril_futex); |
| if (list_empty(&manager_list)) { |
| futex_up(&fibril_futex); |
| return; |
| } |
| list_remove(manager_list.next); |
| futex_up(&fibril_futex); |
| } |
| /** Return fibril id of the currently running fibril. |
| * |
| * @return fibril ID of the currently running fibril. |
| * |
| */ |
| fid_t fibril_get_id(void) |
| { |
| return (fid_t) __tcb_get()->fibril_data; |
| } |
| /** Disable preemption |
| * |
| * If the fibril wants to send several message in a row and does not want to be |
| * preempted, it should start async_serialize_start() in the beginning of |
| * communication and async_serialize_end() in the end. If it is a true |
| * multithreaded application, it should protect the communication channel by a |
| * futex as well. |
| * |
| */ |
| void fibril_inc_sercount(void) |
| { |
| serialization_count++; |
| } |
| /** Restore the preemption counter to the previous state. */ |
| void fibril_dec_sercount(void) |
| { |
| serialization_count--; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/task.c |
|---|
| 0,0 → 1,170 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <task.h> |
| #include <libc.h> |
| #include <stdlib.h> |
| #include <errno.h> |
| #include <loader/loader.h> |
| #include <string.h> |
| #include <ipc/ns.h> |
| #include <macros.h> |
| #include <async.h> |
| task_id_t task_get_id(void) |
| { |
| task_id_t task_id; |
| (void) __SYSCALL1(SYS_TASK_GET_ID, (sysarg_t) &task_id); |
| return task_id; |
| } |
| /** Set the task name. |
| * |
| * @param name The new name, typically the command used to execute the |
| * program. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int task_set_name(const char *name) |
| { |
| return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name)); |
| } |
| /** Create a new task by running an executable from the filesystem. |
| * |
| * This is really just a convenience wrapper over the more complicated |
| * loader API. |
| * |
| * @param path pathname of the binary to execute |
| * @param argv command-line arguments |
| * |
| * @return ID of the newly created task or zero on error. |
| * |
| */ |
| task_id_t task_spawn(const char *path, char *const args[]) |
| { |
| /* Connect to a program loader. */ |
| loader_t *ldr = loader_connect(); |
| if (ldr == NULL) |
| return 0; |
| /* Get task ID. */ |
| task_id_t task_id; |
| int rc = loader_get_task_id(ldr, &task_id); |
| if (rc != EOK) |
| goto error; |
| /* Send program pathname. */ |
| rc = loader_set_pathname(ldr, path); |
| if (rc != EOK) |
| goto error; |
| /* Send arguments. */ |
| rc = loader_set_args(ldr, args); |
| if (rc != EOK) |
| goto error; |
| /* Send default files */ |
| fdi_node_t *files[4]; |
| fdi_node_t stdin_node; |
| fdi_node_t stdout_node; |
| fdi_node_t stderr_node; |
| if ((stdin != NULL) && (fnode(stdin, &stdin_node) == EOK)) |
| files[0] = &stdin_node; |
| else |
| files[0] = NULL; |
| if ((stdout != NULL) && (fnode(stdout, &stdout_node) == EOK)) |
| files[1] = &stdout_node; |
| else |
| files[1] = NULL; |
| if ((stderr != NULL) && (fnode(stderr, &stderr_node) == EOK)) |
| files[2] = &stderr_node; |
| else |
| files[2] = NULL; |
| files[3] = NULL; |
| rc = loader_set_files(ldr, files); |
| if (rc != EOK) |
| goto error; |
| /* Load the program. */ |
| rc = loader_load_program(ldr); |
| if (rc != EOK) |
| goto error; |
| /* Run it. */ |
| rc = loader_run(ldr); |
| if (rc != EOK) |
| goto error; |
| /* Success */ |
| free(ldr); |
| return task_id; |
| error: |
| /* Error exit */ |
| loader_abort(ldr); |
| free(ldr); |
| return 0; |
| } |
| int task_wait(task_id_t id, task_exit_t *texit, int *retval) |
| { |
| ipcarg_t te, rv; |
| int rc; |
| rc = (int) async_req_2_2(PHONE_NS, NS_TASK_WAIT, LOWER32(id), |
| UPPER32(id), &te, &rv); |
| *texit = te; |
| *retval = rv; |
| return rc; |
| } |
| int task_retval(int val) |
| { |
| return (int) async_req_1_0(PHONE_NS, NS_RETVAL, val); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/libc.c |
|---|
| 0,0 → 1,100 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup lc Libc |
| * @brief HelenOS C library |
| * @{ |
| * @} |
| */ |
| /** @addtogroup libc generic |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <malloc.h> |
| #include <tls.h> |
| #include <thread.h> |
| #include <fibril.h> |
| #include <ipc/ipc.h> |
| #include <async.h> |
| #include <as.h> |
| #include <loader/pcb.h> |
| extern int main(int argc, char *argv[]); |
| void _exit(int status) |
| { |
| thread_exit(status); |
| } |
| void __main(void *pcb_ptr) |
| { |
| int retval; |
| __heap_init(); |
| __async_init(); |
| fibril_t *fibril = fibril_setup(); |
| __tcb_set(fibril->tcb); |
| /* Save the PCB pointer */ |
| __pcb = (pcb_t *) pcb_ptr; |
| int argc; |
| char **argv; |
| if (__pcb == NULL) { |
| argc = 0; |
| argv = NULL; |
| __stdio_init(0, NULL); |
| } else { |
| argc = __pcb->argc; |
| argv = __pcb->argv; |
| __stdio_init(__pcb->filc, __pcb->filv); |
| } |
| retval = main(argc, argv); |
| __stdio_done(); |
| (void) task_retval(retval); |
| } |
| void __exit(void) |
| { |
| fibril_teardown(__tcb_get()->fibril_data); |
| _exit(0); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/getopt.c |
|---|
| 0,0 → 1,479 |
| /* $NetBSD: getopt_long.c,v 1.21.4.1 2008/01/09 01:34:14 matt Exp $ */ |
| /*- |
| * Copyright (c) 2000 The NetBSD Foundation, Inc. |
| * All rights reserved. |
| * |
| * This code is derived from software contributed to The NetBSD Foundation |
| * by Dieter Baron and Thomas Klausner. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
| * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */ |
| #include <assert.h> |
| #include <stdarg.h> |
| #include <err.h> |
| #include <errno.h> |
| #include <getopt.h> |
| #include <stdlib.h> |
| #include <string.h> |
| /* HelenOS Port : We're incorporating only the modern getopt_long with wrappers |
| * to keep legacy getopt() usage from breaking. All references to REPLACE_GETOPT |
| * are dropped, we just include the code */ |
| int opterr = 1; /* if error message should be printed */ |
| int optind = 1; /* index into parent argv vector */ |
| int optopt = '?'; /* character checked for validity */ |
| int optreset; /* reset getopt */ |
| const char *optarg; /* argument associated with option */ |
| #define IGNORE_FIRST (*options == '-' || *options == '+') |
| #define PRINT_ERROR ((opterr) && ((*options != ':') \ |
| || (IGNORE_FIRST && options[1] != ':'))) |
| /*HelenOS Port - POSIXLY_CORRECT is always false */ |
| #define IS_POSIXLY_CORRECT 0 |
| #define PERMUTE (!IS_POSIXLY_CORRECT && !IGNORE_FIRST) |
| /* XXX: GNU ignores PC if *options == '-' */ |
| #define IN_ORDER (!IS_POSIXLY_CORRECT && *options == '-') |
| /* return values */ |
| #define BADCH (int)'?' |
| #define BADARG ((IGNORE_FIRST && options[1] == ':') \ |
| || (*options == ':') ? (int)':' : (int)'?') |
| #define INORDER (int)1 |
| #define EMSG "" |
| static int getopt_internal(int, char **, const char *); |
| static int gcd(int, int); |
| static void permute_args(int, int, int, char **); |
| static const char *place = EMSG; /* option letter processing */ |
| /* XXX: set optreset to 1 rather than these two */ |
| static int nonopt_start = -1; /* first non option argument (for permute) */ |
| static int nonopt_end = -1; /* first option after non options (for permute) */ |
| /* Error messages */ |
| /* HelenOS Port: Calls to warnx() were eliminated (as we have no stderr that |
| * may be redirected) and replaced with printf. As such, error messages now |
| * end in a newline */ |
| static const char recargchar[] = "option requires an argument -- %c\n"; |
| static const char recargstring[] = "option requires an argument -- %s\n"; |
| static const char ambig[] = "ambiguous option -- %.*s\n"; |
| static const char noarg[] = "option doesn't take an argument -- %.*s\n"; |
| static const char illoptchar[] = "unknown option -- %c\n"; |
| static const char illoptstring[] = "unknown option -- %s\n"; |
| /* |
| * Compute the greatest common divisor of a and b. |
| */ |
| static int |
| gcd(a, b) |
| int a; |
| int b; |
| { |
| int c; |
| c = a % b; |
| while (c != 0) { |
| a = b; |
| b = c; |
| c = a % b; |
| } |
| return b; |
| } |
| /* |
| * Exchange the block from nonopt_start to nonopt_end with the block |
| * from nonopt_end to opt_end (keeping the same order of arguments |
| * in each block). |
| */ |
| static void |
| permute_args(panonopt_start, panonopt_end, opt_end, nargv) |
| int panonopt_start; |
| int panonopt_end; |
| int opt_end; |
| char **nargv; |
| { |
| int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos; |
| char *swap; |
| assert(nargv != NULL); |
| /* |
| * compute lengths of blocks and number and size of cycles |
| */ |
| nnonopts = panonopt_end - panonopt_start; |
| nopts = opt_end - panonopt_end; |
| ncycle = gcd(nnonopts, nopts); |
| cyclelen = (opt_end - panonopt_start) / ncycle; |
| for (i = 0; i < ncycle; i++) { |
| cstart = panonopt_end+i; |
| pos = cstart; |
| for (j = 0; j < cyclelen; j++) { |
| if (pos >= panonopt_end) |
| pos -= nnonopts; |
| else |
| pos += nopts; |
| swap = nargv[pos]; |
| nargv[pos] = nargv[cstart]; |
| nargv[cstart] = swap; |
| } |
| } |
| } |
| /* |
| * getopt_internal -- |
| * Parse argc/argv argument vector. Called by user level routines. |
| * Returns -2 if -- is found (can be long option or end of options marker). |
| */ |
| static int |
| getopt_internal(nargc, nargv, options) |
| int nargc; |
| char **nargv; |
| const char *options; |
| { |
| const char *oli; /* option letter list index */ |
| int optchar; |
| assert(nargv != NULL); |
| assert(options != NULL); |
| optarg = NULL; |
| /* |
| * XXX Some programs (like rsyncd) expect to be able to |
| * XXX re-initialize optind to 0 and have getopt_long(3) |
| * XXX properly function again. Work around this braindamage. |
| */ |
| if (optind == 0) |
| optind = 1; |
| if (optreset) |
| nonopt_start = nonopt_end = -1; |
| start: |
| if (optreset || !*place) { /* update scanning pointer */ |
| optreset = 0; |
| if (optind >= nargc) { /* end of argument vector */ |
| place = EMSG; |
| if (nonopt_end != -1) { |
| /* do permutation, if we have to */ |
| permute_args(nonopt_start, nonopt_end, |
| optind, nargv); |
| optind -= nonopt_end - nonopt_start; |
| } |
| else if (nonopt_start != -1) { |
| /* |
| * If we skipped non-options, set optind |
| * to the first of them. |
| */ |
| optind = nonopt_start; |
| } |
| nonopt_start = nonopt_end = -1; |
| return -1; |
| } |
| if ((*(place = nargv[optind]) != '-') |
| || (place[1] == '\0')) { /* found non-option */ |
| place = EMSG; |
| if (IN_ORDER) { |
| /* |
| * GNU extension: |
| * return non-option as argument to option 1 |
| */ |
| optarg = nargv[optind++]; |
| return INORDER; |
| } |
| if (!PERMUTE) { |
| /* |
| * if no permutation wanted, stop parsing |
| * at first non-option |
| */ |
| return -1; |
| } |
| /* do permutation */ |
| if (nonopt_start == -1) |
| nonopt_start = optind; |
| else if (nonopt_end != -1) { |
| permute_args(nonopt_start, nonopt_end, |
| optind, nargv); |
| nonopt_start = optind - |
| (nonopt_end - nonopt_start); |
| nonopt_end = -1; |
| } |
| optind++; |
| /* process next argument */ |
| goto start; |
| } |
| if (nonopt_start != -1 && nonopt_end == -1) |
| nonopt_end = optind; |
| if (place[1] && *++place == '-') { /* found "--" */ |
| place++; |
| return -2; |
| } |
| } |
| if ((optchar = (int)*place++) == (int)':' || |
| (oli = str_chr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) { |
| /* option letter unknown or ':' */ |
| if (!*place) |
| ++optind; |
| if (PRINT_ERROR) |
| printf(illoptchar, optchar); |
| optopt = optchar; |
| return BADCH; |
| } |
| if (optchar == 'W' && oli[1] == ';') { /* -W long-option */ |
| /* XXX: what if no long options provided (called by getopt)? */ |
| if (*place) |
| return -2; |
| if (++optind >= nargc) { /* no arg */ |
| place = EMSG; |
| if (PRINT_ERROR) |
| printf(recargchar, optchar); |
| optopt = optchar; |
| return BADARG; |
| } else /* white space */ |
| place = nargv[optind]; |
| /* |
| * Handle -W arg the same as --arg (which causes getopt to |
| * stop parsing). |
| */ |
| return -2; |
| } |
| if (*++oli != ':') { /* doesn't take argument */ |
| if (!*place) |
| ++optind; |
| } else { /* takes (optional) argument */ |
| optarg = NULL; |
| if (*place) /* no white space */ |
| optarg = place; |
| /* XXX: disable test for :: if PC? (GNU doesn't) */ |
| else if (oli[1] != ':') { /* arg not optional */ |
| if (++optind >= nargc) { /* no arg */ |
| place = EMSG; |
| if (PRINT_ERROR) |
| printf(recargchar, optchar); |
| optopt = optchar; |
| return BADARG; |
| } else |
| optarg = nargv[optind]; |
| } |
| place = EMSG; |
| ++optind; |
| } |
| /* dump back option letter */ |
| return optchar; |
| } |
| /* |
| * getopt -- |
| * Parse argc/argv argument vector. |
| */ |
| int |
| getopt(nargc, nargv, options) |
| int nargc; |
| char * const *nargv; |
| const char *options; |
| { |
| int retval; |
| assert(nargv != NULL); |
| assert(options != NULL); |
| retval = getopt_internal(nargc, (char **)nargv, options); |
| if (retval == -2) { |
| ++optind; |
| /* |
| * We found an option (--), so if we skipped non-options, |
| * we have to permute. |
| */ |
| if (nonopt_end != -1) { |
| permute_args(nonopt_start, nonopt_end, optind, |
| (char **)nargv); |
| optind -= nonopt_end - nonopt_start; |
| } |
| nonopt_start = nonopt_end = -1; |
| retval = -1; |
| } |
| return retval; |
| } |
| /* |
| * getopt_long -- |
| * Parse argc/argv argument vector. |
| */ |
| int |
| getopt_long(nargc, nargv, options, long_options, idx) |
| int nargc; |
| char * const *nargv; |
| const char *options; |
| const struct option *long_options; |
| int *idx; |
| { |
| int retval; |
| #define IDENTICAL_INTERPRETATION(_x, _y) \ |
| (long_options[(_x)].has_arg == long_options[(_y)].has_arg && \ |
| long_options[(_x)].flag == long_options[(_y)].flag && \ |
| long_options[(_x)].val == long_options[(_y)].val) |
| assert(nargv != NULL); |
| assert(options != NULL); |
| assert(long_options != NULL); |
| /* idx may be NULL */ |
| retval = getopt_internal(nargc, (char **)nargv, options); |
| if (retval == -2) { |
| char *current_argv; |
| const char *has_equal; |
| size_t current_argv_len; |
| int i, ambiguous, match; |
| current_argv = (char *)place; |
| match = -1; |
| ambiguous = 0; |
| optind++; |
| place = EMSG; |
| if (*current_argv == '\0') { /* found "--" */ |
| /* |
| * We found an option (--), so if we skipped |
| * non-options, we have to permute. |
| */ |
| if (nonopt_end != -1) { |
| permute_args(nonopt_start, nonopt_end, |
| optind, (char **)nargv); |
| optind -= nonopt_end - nonopt_start; |
| } |
| nonopt_start = nonopt_end = -1; |
| return -1; |
| } |
| if ((has_equal = str_chr(current_argv, '=')) != NULL) { |
| /* argument found (--option=arg) */ |
| current_argv_len = has_equal - current_argv; |
| has_equal++; |
| } else |
| current_argv_len = str_size(current_argv); |
| for (i = 0; long_options[i].name; i++) { |
| /* find matching long option */ |
| if (str_lcmp(current_argv, long_options[i].name, |
| str_nlength(current_argv, current_argv_len))) |
| continue; |
| if (str_size(long_options[i].name) == |
| (unsigned)current_argv_len) { |
| /* exact match */ |
| match = i; |
| ambiguous = 0; |
| break; |
| } |
| if (match == -1) /* partial match */ |
| match = i; |
| else if (!IDENTICAL_INTERPRETATION(i, match)) |
| ambiguous = 1; |
| } |
| if (ambiguous) { |
| /* ambiguous abbreviation */ |
| if (PRINT_ERROR) |
| printf(ambig, (int)current_argv_len, |
| current_argv); |
| optopt = 0; |
| return BADCH; |
| } |
| if (match != -1) { /* option found */ |
| if (long_options[match].has_arg == no_argument |
| && has_equal) { |
| if (PRINT_ERROR) |
| printf(noarg, (int)current_argv_len, |
| current_argv); |
| /* |
| * XXX: GNU sets optopt to val regardless of |
| * flag |
| */ |
| if (long_options[match].flag == NULL) |
| optopt = long_options[match].val; |
| else |
| optopt = 0; |
| return BADARG; |
| } |
| if (long_options[match].has_arg == required_argument || |
| long_options[match].has_arg == optional_argument) { |
| if (has_equal) |
| optarg = has_equal; |
| else if (long_options[match].has_arg == |
| required_argument) { |
| /* |
| * optional argument doesn't use |
| * next nargv |
| */ |
| optarg = nargv[optind++]; |
| } |
| } |
| if ((long_options[match].has_arg == required_argument) |
| && (optarg == NULL)) { |
| /* |
| * Missing argument; leading ':' |
| * indicates no error should be generated |
| */ |
| if (PRINT_ERROR) |
| printf(recargstring, current_argv); |
| /* |
| * XXX: GNU sets optopt to val regardless |
| * of flag |
| */ |
| if (long_options[match].flag == NULL) |
| optopt = long_options[match].val; |
| else |
| optopt = 0; |
| --optind; |
| return BADARG; |
| } |
| } else { /* unknown option */ |
| if (PRINT_ERROR) |
| printf(illoptstring, current_argv); |
| optopt = 0; |
| return BADCH; |
| } |
| if (long_options[match].flag) { |
| *long_options[match].flag = long_options[match].val; |
| retval = 0; |
| } else |
| retval = long_options[match].val; |
| if (idx) |
| *idx = match; |
| } |
| return retval; |
| #undef IDENTICAL_INTERPRETATION |
| } |
| /tags/0.4.1/uspace/lib/libc/generic/as.c |
|---|
| 0,0 → 1,131 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <as.h> |
| #include <libc.h> |
| #include <unistd.h> |
| #include <align.h> |
| #include <sys/types.h> |
| #include <bitops.h> |
| #include <malloc.h> |
| /** Last position allocated by as_get_mappable_page */ |
| static uintptr_t last_allocated = 0; |
| /** Create address space area. |
| * |
| * @param address Virtual address where to place new address space area. |
| * @param size Size of the area. |
| * @param flags Flags describing type of the area. |
| * |
| * @return address on success, (void *) -1 otherwise. |
| * |
| */ |
| void *as_area_create(void *address, size_t size, int flags) |
| { |
| return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t) address, |
| (sysarg_t) size, (sysarg_t) flags); |
| } |
| /** Resize address space area. |
| * |
| * @param address Virtual address pointing into already existing address space |
| * area. |
| * @param size New requested size of the area. |
| * @param flags Currently unused. |
| * |
| * @return zero on success or a code from @ref errno.h on failure. |
| * |
| */ |
| int as_area_resize(void *address, size_t size, int flags) |
| { |
| return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address, |
| (sysarg_t) size, (sysarg_t) flags); |
| } |
| /** Destroy address space area. |
| * |
| * @param address Virtual address pointing into the address space area being |
| * destroyed. |
| * |
| * @return zero on success or a code from @ref errno.h on failure. |
| * |
| */ |
| int as_area_destroy(void *address) |
| { |
| return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t) address); |
| } |
| /** Change address-space area flags. |
| * |
| * @param address Virtual address pointing into the address space area being |
| * modified. |
| * @param flags New flags describing type of the area. |
| * |
| * @return zero on success or a code from @ref errno.h on failure. |
| * |
| */ |
| int as_area_change_flags(void *address, int flags) |
| { |
| return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address, |
| (sysarg_t) flags); |
| } |
| /** Return pointer to some unmapped area, where fits new as_area |
| * |
| * @param size Requested size of the allocation. |
| * |
| * @return pointer to the beginning |
| * |
| */ |
| void *as_get_mappable_page(size_t size) |
| { |
| if (size == 0) |
| return NULL; |
| size_t sz = 1 << (fnzb(size - 1) + 1); |
| if (last_allocated == 0) |
| last_allocated = get_max_heap_addr(); |
| /* |
| * Make sure we allocate from naturally aligned address. |
| */ |
| uintptr_t res = ALIGN_UP(last_allocated, sz); |
| last_allocated = res + ALIGN_UP(size, PAGE_SIZE); |
| return ((void *) res); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/async.c |
|---|
| 0,0 → 1,1101 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| /** |
| * Asynchronous library |
| * |
| * The aim of this library is to provide a facility for writing programs which |
| * utilize the asynchronous nature of HelenOS IPC, yet using a normal way of |
| * programming. |
| * |
| * You should be able to write very simple multithreaded programs, the async |
| * framework will automatically take care of most synchronization problems. |
| * |
| * Default semantics: |
| * - async_send_*(): Send asynchronously. If the kernel refuses to send |
| * more messages, [ try to get responses from kernel, if |
| * nothing found, might try synchronous ] |
| * |
| * Example of use (pseudo C): |
| * |
| * 1) Multithreaded client application |
| * |
| * fibril_create(fibril1, ...); |
| * fibril_create(fibril2, ...); |
| * ... |
| * |
| * int fibril1(void *arg) |
| * { |
| * conn = ipc_connect_me_to(); |
| * c1 = async_send(conn); |
| * c2 = async_send(conn); |
| * async_wait_for(c1); |
| * async_wait_for(c2); |
| * ... |
| * } |
| * |
| * |
| * 2) Multithreaded server application |
| * |
| * main() |
| * { |
| * async_manager(); |
| * } |
| * |
| * my_client_connection(icallid, *icall) |
| * { |
| * if (want_refuse) { |
| * ipc_answer_0(icallid, ELIMIT); |
| * return; |
| * } |
| * ipc_answer_0(icallid, EOK); |
| * |
| * callid = async_get_call(&call); |
| * handle_call(callid, call); |
| * ipc_answer_2(callid, 1, 2, 3); |
| * |
| * callid = async_get_call(&call); |
| * ... |
| * } |
| * |
| */ |
| #include <futex.h> |
| #include <async.h> |
| #include <fibril.h> |
| #include <stdio.h> |
| #include <adt/hash_table.h> |
| #include <adt/list.h> |
| #include <ipc/ipc.h> |
| #include <assert.h> |
| #include <errno.h> |
| #include <sys/time.h> |
| #include <arch/barrier.h> |
| #include <bool.h> |
| atomic_t async_futex = FUTEX_INITIALIZER; |
| /** Structures of this type represent a waiting fibril. */ |
| typedef struct { |
| /** Expiration time. */ |
| struct timeval expires; |
| /** If true, this struct is in the timeout list. */ |
| bool inlist; |
| /** Timeout list link. */ |
| link_t link; |
| /** Identification of and link to the waiting fibril. */ |
| fid_t fid; |
| /** If true, this fibril is currently active. */ |
| bool active; |
| /** If true, we have timed out. */ |
| bool timedout; |
| } awaiter_t; |
| typedef struct { |
| awaiter_t wdata; |
| /** If reply was received. */ |
| bool done; |
| /** Pointer to where the answer data is stored. */ |
| ipc_call_t *dataptr; |
| ipcarg_t retval; |
| } amsg_t; |
| /** |
| * Structures of this type are used to group information about a call and a |
| * message queue link. |
| */ |
| typedef struct { |
| link_t link; |
| ipc_callid_t callid; |
| ipc_call_t call; |
| } msg_t; |
| typedef struct { |
| awaiter_t wdata; |
| /** Hash table link. */ |
| link_t link; |
| /** Incoming phone hash. */ |
| ipcarg_t in_phone_hash; |
| /** Messages that should be delivered to this fibril. */ |
| link_t msg_queue; |
| /** Identification of the opening call. */ |
| ipc_callid_t callid; |
| /** Call data of the opening call. */ |
| ipc_call_t call; |
| /** Identification of the closing call. */ |
| ipc_callid_t close_callid; |
| /** Fibril function that will be used to handle the connection. */ |
| void (*cfibril)(ipc_callid_t, ipc_call_t *); |
| } connection_t; |
| /** Identifier of the incoming connection handled by the current fibril. */ |
| fibril_local connection_t *FIBRIL_connection; |
| static void default_client_connection(ipc_callid_t callid, ipc_call_t *call); |
| static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call); |
| /** |
| * Pointer to a fibril function that will be used to handle connections. |
| */ |
| static async_client_conn_t client_connection = default_client_connection; |
| /** |
| * Pointer to a fibril function that will be used to handle interrupt |
| * notifications. |
| */ |
| static async_client_conn_t interrupt_received = default_interrupt_received; |
| static hash_table_t conn_hash_table; |
| static LIST_INITIALIZE(timeout_list); |
| #define CONN_HASH_TABLE_CHAINS 32 |
| /** Compute hash into the connection hash table based on the source phone hash. |
| * |
| * @param key Pointer to source phone hash. |
| * |
| * @return Index into the connection hash table. |
| * |
| */ |
| static hash_index_t conn_hash(unsigned long *key) |
| { |
| assert(key); |
| return (((*key) >> 4) % CONN_HASH_TABLE_CHAINS); |
| } |
| /** Compare hash table item with a key. |
| * |
| * @param key Array containing the source phone hash as the only item. |
| * @param keys Expected 1 but ignored. |
| * @param item Connection hash table item. |
| * |
| * @return True on match, false otherwise. |
| * |
| */ |
| static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item) |
| { |
| connection_t *hs = hash_table_get_instance(item, connection_t, link); |
| return (key[0] == hs->in_phone_hash); |
| } |
| /** Connection hash table removal callback function. |
| * |
| * This function is called whenever a connection is removed from the connection |
| * hash table. |
| * |
| * @param item Connection hash table item being removed. |
| * |
| */ |
| static void conn_remove(link_t *item) |
| { |
| free(hash_table_get_instance(item, connection_t, link)); |
| } |
| /** Operations for the connection hash table. */ |
| static hash_table_operations_t conn_hash_table_ops = { |
| .hash = conn_hash, |
| .compare = conn_compare, |
| .remove_callback = conn_remove |
| }; |
| /** Sort in current fibril's timeout request. |
| * |
| * @param wd Wait data of the current fibril. |
| * |
| */ |
| static void insert_timeout(awaiter_t *wd) |
| { |
| wd->timedout = false; |
| wd->inlist = true; |
| link_t *tmp = timeout_list.next; |
| while (tmp != &timeout_list) { |
| awaiter_t *cur = list_get_instance(tmp, awaiter_t, link); |
| if (tv_gteq(&cur->expires, &wd->expires)) |
| break; |
| tmp = tmp->next; |
| } |
| list_append(&wd->link, tmp); |
| } |
| /** Try to route a call to an appropriate connection fibril. |
| * |
| * If the proper connection fibril is found, a message with the call is added to |
| * its message queue. If the fibril was not active, it is activated and all |
| * timeouts are unregistered. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| * @return False if the call doesn't match any connection. |
| * True if the call was passed to the respective connection fibril. |
| * |
| */ |
| static bool route_call(ipc_callid_t callid, ipc_call_t *call) |
| { |
| futex_down(&async_futex); |
| unsigned long key = call->in_phone_hash; |
| link_t *hlp = hash_table_find(&conn_hash_table, &key); |
| if (!hlp) { |
| futex_up(&async_futex); |
| return false; |
| } |
| connection_t *conn = hash_table_get_instance(hlp, connection_t, link); |
| msg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) { |
| futex_up(&async_futex); |
| return false; |
| } |
| msg->callid = callid; |
| msg->call = *call; |
| list_append(&msg->link, &conn->msg_queue); |
| if (IPC_GET_METHOD(*call) == IPC_M_PHONE_HUNGUP) |
| conn->close_callid = callid; |
| /* If the connection fibril is waiting for an event, activate it */ |
| if (!conn->wdata.active) { |
| /* If in timeout list, remove it */ |
| if (conn->wdata.inlist) { |
| conn->wdata.inlist = false; |
| list_remove(&conn->wdata.link); |
| } |
| conn->wdata.active = true; |
| fibril_add_ready(conn->wdata.fid); |
| } |
| futex_up(&async_futex); |
| return true; |
| } |
| /** Notification fibril. |
| * |
| * When a notification arrives, a fibril with this implementing function is |
| * created. It calls interrupt_received() and does the final cleanup. |
| * |
| * @param arg Message structure pointer. |
| * |
| * @return Always zero. |
| * |
| */ |
| static int notification_fibril(void *arg) |
| { |
| msg_t *msg = (msg_t *) arg; |
| interrupt_received(msg->callid, &msg->call); |
| free(msg); |
| return 0; |
| } |
| /** Process interrupt notification. |
| * |
| * A new fibril is created which would process the notification. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| * @return False if an error occured. |
| * True if the call was passed to the notification fibril. |
| * |
| */ |
| static bool process_notification(ipc_callid_t callid, ipc_call_t *call) |
| { |
| futex_down(&async_futex); |
| msg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) { |
| futex_up(&async_futex); |
| return false; |
| } |
| msg->callid = callid; |
| msg->call = *call; |
| fid_t fid = fibril_create(notification_fibril, msg); |
| fibril_add_ready(fid); |
| futex_up(&async_futex); |
| return true; |
| } |
| /** Return new incoming message for the current (fibril-local) connection. |
| * |
| * @param call Storage where the incoming call data will be stored. |
| * @param usecs Timeout in microseconds. Zero denotes no timeout. |
| * |
| * @return If no timeout was specified, then a hash of the |
| * incoming call is returned. If a timeout is specified, |
| * then a hash of the incoming call is returned unless |
| * the timeout expires prior to receiving a message. In |
| * that case zero is returned. |
| * |
| */ |
| ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs) |
| { |
| assert(FIBRIL_connection); |
| /* Why doing this? |
| * GCC 4.1.0 coughs on FIBRIL_connection-> dereference. |
| * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot. |
| * I would never expect to find so many errors in |
| * a compiler. |
| */ |
| connection_t *conn = FIBRIL_connection; |
| futex_down(&async_futex); |
| if (usecs) { |
| gettimeofday(&conn->wdata.expires, NULL); |
| tv_add(&conn->wdata.expires, usecs); |
| } else |
| conn->wdata.inlist = false; |
| /* If nothing in queue, wait until something arrives */ |
| while (list_empty(&conn->msg_queue)) { |
| if (usecs) |
| insert_timeout(&conn->wdata); |
| conn->wdata.active = false; |
| /* |
| * Note: the current fibril will be rescheduled either due to a |
| * timeout or due to an arriving message destined to it. In the |
| * former case, handle_expired_timeouts() and, in the latter |
| * case, route_call() will perform the wakeup. |
| */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* |
| * Futex is up after getting back from async_manager. |
| * Get it again. |
| */ |
| futex_down(&async_futex); |
| if ((usecs) && (conn->wdata.timedout) |
| && (list_empty(&conn->msg_queue))) { |
| /* If we timed out -> exit */ |
| futex_up(&async_futex); |
| return 0; |
| } |
| } |
| msg_t *msg = list_get_instance(conn->msg_queue.next, msg_t, link); |
| list_remove(&msg->link); |
| ipc_callid_t callid = msg->callid; |
| *call = msg->call; |
| free(msg); |
| futex_up(&async_futex); |
| return callid; |
| } |
| /** Default fibril function that gets called to handle new connection. |
| * |
| * This function is defined as a weak symbol - to be redefined in user code. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| */ |
| static void default_client_connection(ipc_callid_t callid, ipc_call_t *call) |
| { |
| ipc_answer_0(callid, ENOENT); |
| } |
| /** Default fibril function that gets called to handle interrupt notifications. |
| * |
| * This function is defined as a weak symbol - to be redefined in user code. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| */ |
| static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call) |
| { |
| } |
| /** Wrapper for client connection fibril. |
| * |
| * When a new connection arrives, a fibril with this implementing function is |
| * created. It calls client_connection() and does the final cleanup. |
| * |
| * @param arg Connection structure pointer. |
| * |
| * @return Always zero. |
| * |
| */ |
| static int connection_fibril(void *arg) |
| { |
| /* |
| * Setup fibril-local connection pointer and call client_connection(). |
| * |
| */ |
| FIBRIL_connection = (connection_t *) arg; |
| FIBRIL_connection->cfibril(FIBRIL_connection->callid, |
| &FIBRIL_connection->call); |
| /* Remove myself from the connection hash table */ |
| futex_down(&async_futex); |
| unsigned long key = FIBRIL_connection->in_phone_hash; |
| hash_table_remove(&conn_hash_table, &key, 1); |
| futex_up(&async_futex); |
| /* Answer all remaining messages with EHANGUP */ |
| while (!list_empty(&FIBRIL_connection->msg_queue)) { |
| msg_t *msg; |
| msg = list_get_instance(FIBRIL_connection->msg_queue.next, |
| msg_t, link); |
| list_remove(&msg->link); |
| ipc_answer_0(msg->callid, EHANGUP); |
| free(msg); |
| } |
| if (FIBRIL_connection->close_callid) |
| ipc_answer_0(FIBRIL_connection->close_callid, EOK); |
| return 0; |
| } |
| /** Create a new fibril for a new connection. |
| * |
| * Create new fibril for connection, fill in connection structures and inserts |
| * it into the hash table, so that later we can easily do routing of messages to |
| * particular fibrils. |
| * |
| * @param in_phone_hash Identification of the incoming connection. |
| * @param callid Hash of the opening IPC_M_CONNECT_ME_TO call. |
| * If callid is zero, the connection was opened by |
| * accepting the IPC_M_CONNECT_TO_ME call and this function |
| * is called directly by the server. |
| * @param call Call data of the opening call. |
| * @param cfibril Fibril function that should be called upon opening the |
| * connection. |
| * |
| * @return New fibril id or NULL on failure. |
| * |
| */ |
| fid_t async_new_connection(ipcarg_t in_phone_hash, ipc_callid_t callid, |
| ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *)) |
| { |
| connection_t *conn = malloc(sizeof(*conn)); |
| if (!conn) { |
| if (callid) |
| ipc_answer_0(callid, ENOMEM); |
| return NULL; |
| } |
| conn->in_phone_hash = in_phone_hash; |
| list_initialize(&conn->msg_queue); |
| conn->callid = callid; |
| conn->close_callid = false; |
| if (call) |
| conn->call = *call; |
| /* We will activate the fibril ASAP */ |
| conn->wdata.active = true; |
| conn->cfibril = cfibril; |
| conn->wdata.fid = fibril_create(connection_fibril, conn); |
| if (!conn->wdata.fid) { |
| free(conn); |
| if (callid) |
| ipc_answer_0(callid, ENOMEM); |
| return NULL; |
| } |
| /* Add connection to the connection hash table */ |
| unsigned long key = conn->in_phone_hash; |
| futex_down(&async_futex); |
| hash_table_insert(&conn_hash_table, &key, &conn->link); |
| futex_up(&async_futex); |
| fibril_add_ready(conn->wdata.fid); |
| return conn->wdata.fid; |
| } |
| /** Handle a call that was received. |
| * |
| * If the call has the IPC_M_CONNECT_ME_TO method, a new connection is created. |
| * Otherwise the call is routed to its connection fibril. |
| * |
| * @param callid Hash of the incoming call. |
| * @param call Data of the incoming call. |
| * |
| */ |
| static void handle_call(ipc_callid_t callid, ipc_call_t *call) |
| { |
| /* Unrouted call - do some default behaviour */ |
| if ((callid & IPC_CALLID_NOTIFICATION)) { |
| process_notification(callid, call); |
| goto out; |
| } |
| switch (IPC_GET_METHOD(*call)) { |
| case IPC_M_CONNECT_ME: |
| case IPC_M_CONNECT_ME_TO: |
| /* Open new connection with fibril etc. */ |
| async_new_connection(IPC_GET_ARG5(*call), callid, call, |
| client_connection); |
| goto out; |
| } |
| /* Try to route the call through the connection hash table */ |
| if (route_call(callid, call)) |
| goto out; |
| /* Unknown call from unknown phone - hang it up */ |
| ipc_answer_0(callid, EHANGUP); |
| return; |
| out: |
| ; |
| } |
| /** Fire all timeouts that expired. */ |
| static void handle_expired_timeouts(void) |
| { |
| struct timeval tv; |
| gettimeofday(&tv, NULL); |
| futex_down(&async_futex); |
| link_t *cur = timeout_list.next; |
| while (cur != &timeout_list) { |
| awaiter_t *waiter = list_get_instance(cur, awaiter_t, link); |
| if (tv_gt(&waiter->expires, &tv)) |
| break; |
| cur = cur->next; |
| list_remove(&waiter->link); |
| waiter->inlist = false; |
| waiter->timedout = true; |
| /* |
| * Redundant condition? |
| * The fibril should not be active when it gets here. |
| */ |
| if (!waiter->active) { |
| waiter->active = true; |
| fibril_add_ready(waiter->fid); |
| } |
| } |
| futex_up(&async_futex); |
| } |
| /** Endless loop dispatching incoming calls and answers. |
| * |
| * @return Never returns. |
| * |
| */ |
| static int async_manager_worker(void) |
| { |
| while (true) { |
| if (fibril_switch(FIBRIL_FROM_MANAGER)) { |
| futex_up(&async_futex); |
| /* |
| * async_futex is always held when entering a manager |
| * fibril. |
| */ |
| continue; |
| } |
| futex_down(&async_futex); |
| suseconds_t timeout; |
| if (!list_empty(&timeout_list)) { |
| awaiter_t *waiter = list_get_instance(timeout_list.next, |
| awaiter_t, link); |
| struct timeval tv; |
| gettimeofday(&tv, NULL); |
| if (tv_gteq(&tv, &waiter->expires)) { |
| futex_up(&async_futex); |
| handle_expired_timeouts(); |
| continue; |
| } else |
| timeout = tv_sub(&waiter->expires, &tv); |
| } else |
| timeout = SYNCH_NO_TIMEOUT; |
| futex_up(&async_futex); |
| ipc_call_t call; |
| ipc_callid_t callid = ipc_wait_cycle(&call, timeout, |
| SYNCH_FLAGS_NONE); |
| if (!callid) { |
| handle_expired_timeouts(); |
| continue; |
| } |
| if (callid & IPC_CALLID_ANSWERED) |
| continue; |
| handle_call(callid, &call); |
| } |
| return 0; |
| } |
| /** Function to start async_manager as a standalone fibril. |
| * |
| * When more kernel threads are used, one async manager should exist per thread. |
| * |
| * @param arg Unused. |
| * @return Never returns. |
| * |
| */ |
| static int async_manager_fibril(void *arg) |
| { |
| futex_up(&async_futex); |
| /* |
| * async_futex is always locked when entering manager |
| */ |
| async_manager_worker(); |
| return 0; |
| } |
| /** Add one manager to manager list. */ |
| void async_create_manager(void) |
| { |
| fid_t fid = fibril_create(async_manager_fibril, NULL); |
| fibril_add_manager(fid); |
| } |
| /** Remove one manager from manager list */ |
| void async_destroy_manager(void) |
| { |
| fibril_remove_manager(); |
| } |
| /** Initialize the async framework. |
| * |
| * @return Zero on success or an error code. |
| */ |
| int __async_init(void) |
| { |
| if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1, |
| &conn_hash_table_ops)) { |
| printf("%s: cannot create hash table\n", "async"); |
| return ENOMEM; |
| } |
| return 0; |
| } |
| /** Reply received callback. |
| * |
| * This function is called whenever a reply for an asynchronous message sent out |
| * by the asynchronous framework is received. |
| * |
| * Notify the fibril which is waiting for this message that it has arrived. |
| * |
| * @param arg Pointer to the asynchronous message record. |
| * @param retval Value returned in the answer. |
| * @param data Call data of the answer. |
| */ |
| static void reply_received(void *arg, int retval, ipc_call_t *data) |
| { |
| futex_down(&async_futex); |
| amsg_t *msg = (amsg_t *) arg; |
| msg->retval = retval; |
| /* Copy data after futex_down, just in case the call was detached */ |
| if ((msg->dataptr) && (data)) |
| *msg->dataptr = *data; |
| write_barrier(); |
| /* Remove message from timeout list */ |
| if (msg->wdata.inlist) |
| list_remove(&msg->wdata.link); |
| msg->done = true; |
| if (!msg->wdata.active) { |
| msg->wdata.active = true; |
| fibril_add_ready(msg->wdata.fid); |
| } |
| futex_up(&async_futex); |
| } |
| /** Send message and return id of the sent message. |
| * |
| * The return value can be used as input for async_wait() to wait for |
| * completion. |
| * |
| * @param phoneid Handle of the phone that will be used for the send. |
| * @param method Service-defined method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param dataptr If non-NULL, storage where the reply data will be |
| * stored. |
| * |
| * @return Hash of the sent message or 0 on error. |
| * |
| */ |
| aid_t async_send_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipc_call_t *dataptr) |
| { |
| amsg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) |
| return 0; |
| msg->done = false; |
| msg->dataptr = dataptr; |
| msg->wdata.inlist = false; |
| /* We may sleep in the next method, but it will use its own mechanism */ |
| msg->wdata.active = true; |
| ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg, |
| reply_received, true); |
| return (aid_t) msg; |
| } |
| /** Send message and return id of the sent message |
| * |
| * The return value can be used as input for async_wait() to wait for |
| * completion. |
| * |
| * @param phoneid Handle of the phone that will be used for the send. |
| * @param method Service-defined method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param dataptr If non-NULL, storage where the reply data will be |
| * stored. |
| * |
| * @return Hash of the sent message or 0 on error. |
| * |
| */ |
| aid_t async_send_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, |
| ipc_call_t *dataptr) |
| { |
| amsg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) |
| return 0; |
| msg->done = false; |
| msg->dataptr = dataptr; |
| msg->wdata.inlist = false; |
| /* We may sleep in next method, but it will use its own mechanism */ |
| msg->wdata.active = true; |
| ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg, |
| reply_received, true); |
| return (aid_t) msg; |
| } |
| /** Wait for a message sent by the async framework. |
| * |
| * @param amsgid Hash of the message to wait for. |
| * @param retval Pointer to storage where the retval of the answer will |
| * be stored. |
| * |
| */ |
| void async_wait_for(aid_t amsgid, ipcarg_t *retval) |
| { |
| amsg_t *msg = (amsg_t *) amsgid; |
| futex_down(&async_futex); |
| if (msg->done) { |
| futex_up(&async_futex); |
| goto done; |
| } |
| msg->wdata.fid = fibril_get_id(); |
| msg->wdata.active = false; |
| msg->wdata.inlist = false; |
| /* Leave the async_futex locked when entering this function */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* Futex is up automatically after fibril_switch */ |
| done: |
| if (retval) |
| *retval = msg->retval; |
| free(msg); |
| } |
| /** Wait for a message sent by the async framework, timeout variant. |
| * |
| * @param amsgid Hash of the message to wait for. |
| * @param retval Pointer to storage where the retval of the answer will |
| * be stored. |
| * @param timeout Timeout in microseconds. |
| * |
| * @return Zero on success, ETIMEOUT if the timeout has expired. |
| * |
| */ |
| int async_wait_timeout(aid_t amsgid, ipcarg_t *retval, suseconds_t timeout) |
| { |
| amsg_t *msg = (amsg_t *) amsgid; |
| /* TODO: Let it go through the event read at least once */ |
| if (timeout < 0) |
| return ETIMEOUT; |
| futex_down(&async_futex); |
| if (msg->done) { |
| futex_up(&async_futex); |
| goto done; |
| } |
| gettimeofday(&msg->wdata.expires, NULL); |
| tv_add(&msg->wdata.expires, timeout); |
| msg->wdata.fid = fibril_get_id(); |
| msg->wdata.active = false; |
| insert_timeout(&msg->wdata); |
| /* Leave the async_futex locked when entering this function */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* Futex is up automatically after fibril_switch */ |
| if (!msg->done) |
| return ETIMEOUT; |
| done: |
| if (retval) |
| *retval = msg->retval; |
| free(msg); |
| return 0; |
| } |
| /** Wait for specified time. |
| * |
| * The current fibril is suspended but the thread continues to execute. |
| * |
| * @param timeout Duration of the wait in microseconds. |
| * |
| */ |
| void async_usleep(suseconds_t timeout) |
| { |
| amsg_t *msg = malloc(sizeof(*msg)); |
| if (!msg) |
| return; |
| msg->wdata.fid = fibril_get_id(); |
| msg->wdata.active = false; |
| gettimeofday(&msg->wdata.expires, NULL); |
| tv_add(&msg->wdata.expires, timeout); |
| futex_down(&async_futex); |
| insert_timeout(&msg->wdata); |
| /* Leave the async_futex locked when entering this function */ |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* Futex is up automatically after fibril_switch() */ |
| free(msg); |
| } |
| /** Setter for client_connection function pointer. |
| * |
| * @param conn Function that will implement a new connection fibril. |
| * |
| */ |
| void async_set_client_connection(async_client_conn_t conn) |
| { |
| client_connection = conn; |
| } |
| /** Setter for interrupt_received function pointer. |
| * |
| * @param intr Function that will implement a new interrupt |
| * notification fibril. |
| */ |
| void async_set_interrupt_received(async_client_conn_t intr) |
| { |
| interrupt_received = intr; |
| } |
| /** Pseudo-synchronous message sending - fast version. |
| * |
| * Send message asynchronously and return only after the reply arrives. |
| * |
| * This function can only transfer 4 register payload arguments. For |
| * transferring more arguments, see the slower async_req_slow(). |
| * |
| * @param phoneid Hash of the phone through which to make the call. |
| * @param method Method of the call. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param r1 If non-NULL, storage for the 1st reply argument. |
| * @param r2 If non-NULL, storage for the 2nd reply argument. |
| * @param r3 If non-NULL, storage for the 3rd reply argument. |
| * @param r4 If non-NULL, storage for the 4th reply argument. |
| * @param r5 If non-NULL, storage for the 5th reply argument. |
| * |
| * @return Return code of the reply or a negative error code. |
| * |
| */ |
| ipcarg_t async_req_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t *r1, ipcarg_t *r2, |
| ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5) |
| { |
| ipc_call_t result; |
| aid_t eid = async_send_4(phoneid, method, arg1, arg2, arg3, arg4, |
| &result); |
| ipcarg_t rc; |
| async_wait_for(eid, &rc); |
| if (r1) |
| *r1 = IPC_GET_ARG1(result); |
| if (r2) |
| *r2 = IPC_GET_ARG2(result); |
| if (r3) |
| *r3 = IPC_GET_ARG3(result); |
| if (r4) |
| *r4 = IPC_GET_ARG4(result); |
| if (r5) |
| *r5 = IPC_GET_ARG5(result); |
| return rc; |
| } |
| /** Pseudo-synchronous message sending - slow version. |
| * |
| * Send message asynchronously and return only after the reply arrives. |
| * |
| * @param phoneid Hash of the phone through which to make the call. |
| * @param method Method of the call. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param r1 If non-NULL, storage for the 1st reply argument. |
| * @param r2 If non-NULL, storage for the 2nd reply argument. |
| * @param r3 If non-NULL, storage for the 3rd reply argument. |
| * @param r4 If non-NULL, storage for the 4th reply argument. |
| * @param r5 If non-NULL, storage for the 5th reply argument. |
| * |
| * @return Return code of the reply or a negative error code. |
| * |
| */ |
| ipcarg_t async_req_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *r1, |
| ipcarg_t *r2, ipcarg_t *r3, ipcarg_t *r4, ipcarg_t *r5) |
| { |
| ipc_call_t result; |
| aid_t eid = async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, |
| &result); |
| ipcarg_t rc; |
| async_wait_for(eid, &rc); |
| if (r1) |
| *r1 = IPC_GET_ARG1(result); |
| if (r2) |
| *r2 = IPC_GET_ARG2(result); |
| if (r3) |
| *r3 = IPC_GET_ARG3(result); |
| if (r4) |
| *r4 = IPC_GET_ARG4(result); |
| if (r5) |
| *r5 = IPC_GET_ARG5(result); |
| return rc; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/errno.c |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2009 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <errno.h> |
| #include <fibril.h> |
| int _errno; |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/mman.c |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <sys/mman.h> |
| #include <sys/types.h> |
| #include <as.h> |
| #include <unistd.h> |
| void *mmap(void *start, size_t length, int prot, int flags, int fd, |
| off_t offset) |
| { |
| if (!start) |
| start = as_get_mappable_page(length); |
| // if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE))) |
| // return MAP_FAILED; |
| if (!(flags & MAP_ANONYMOUS)) |
| return MAP_FAILED; |
| return as_area_create(start, length, prot); |
| } |
| int munmap(void *start, size_t length) |
| { |
| return as_area_destroy(start); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/devmap.c |
|---|
| 0,0 → 1,289 |
| /* |
| * Copyright (c) 2007 Josef Cejka |
| * Copyright (c) 2009 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <string.h> |
| #include <ipc/ipc.h> |
| #include <ipc/services.h> |
| #include <ipc/devmap.h> |
| #include <devmap.h> |
| #include <async.h> |
| #include <errno.h> |
| static int devmap_phone_driver = -1; |
| static int devmap_phone_client = -1; |
| /** Get phone to device mapper task. */ |
| int devmap_get_phone(devmap_interface_t iface, unsigned int flags) |
| { |
| switch (iface) { |
| case DEVMAP_DRIVER: |
| if (devmap_phone_driver >= 0) |
| return devmap_phone_driver; |
| if (flags & IPC_FLAG_BLOCKING) |
| devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_DRIVER, 0); |
| else |
| devmap_phone_driver = ipc_connect_me_to(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_DRIVER, 0); |
| return devmap_phone_driver; |
| case DEVMAP_CLIENT: |
| if (devmap_phone_client >= 0) |
| return devmap_phone_client; |
| if (flags & IPC_FLAG_BLOCKING) |
| devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_CLIENT, 0); |
| else |
| devmap_phone_client = ipc_connect_me_to(PHONE_NS, |
| SERVICE_DEVMAP, DEVMAP_CLIENT, 0); |
| return devmap_phone_client; |
| default: |
| return -1; |
| } |
| } |
| void devmap_hangup_phone(devmap_interface_t iface) |
| { |
| switch (iface) { |
| case DEVMAP_DRIVER: |
| if (devmap_phone_driver >= 0) { |
| ipc_hangup(devmap_phone_driver); |
| devmap_phone_driver = -1; |
| } |
| break; |
| case DEVMAP_CLIENT: |
| if (devmap_phone_client >= 0) { |
| ipc_hangup(devmap_phone_client); |
| devmap_phone_client = -1; |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| /** Register new driver with devmap. */ |
| int devmap_driver_register(const char *name, async_client_conn_t conn) |
| { |
| int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return phone; |
| async_serialize_start(); |
| ipc_call_t answer; |
| aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer); |
| ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| return -1; |
| } |
| async_set_client_connection(conn); |
| ipcarg_t callback_phonehash; |
| ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash); |
| async_wait_for(req, &retval); |
| async_serialize_end(); |
| return retval; |
| } |
| /** Register new device. |
| * |
| * @param name Device name. |
| * @param handle Output: Handle to the created instance of device. |
| * |
| */ |
| int devmap_device_register(const char *name, dev_handle_t *handle) |
| { |
| int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return phone; |
| async_serialize_start(); |
| ipc_call_t answer; |
| aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0, |
| &answer); |
| ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| return retval; |
| } |
| async_wait_for(req, &retval); |
| async_serialize_end(); |
| if (retval != EOK) { |
| if (handle != NULL) |
| *handle = -1; |
| return retval; |
| } |
| if (handle != NULL) |
| *handle = (dev_handle_t) IPC_GET_ARG1(answer); |
| return retval; |
| } |
| int devmap_device_get_handle(const char *name, dev_handle_t *handle, unsigned int flags) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, flags); |
| if (phone < 0) |
| return phone; |
| async_serialize_start(); |
| ipc_call_t answer; |
| aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0, |
| &answer); |
| ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| return retval; |
| } |
| async_wait_for(req, &retval); |
| async_serialize_end(); |
| if (retval != EOK) { |
| if (handle != NULL) |
| *handle = (dev_handle_t) -1; |
| return retval; |
| } |
| if (handle != NULL) |
| *handle = (dev_handle_t) IPC_GET_ARG1(answer); |
| return retval; |
| } |
| int devmap_device_connect(dev_handle_t handle, unsigned int flags) |
| { |
| int phone; |
| if (flags & IPC_FLAG_BLOCKING) { |
| phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CONNECT_TO_DEVICE, handle); |
| } else { |
| phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, |
| DEVMAP_CONNECT_TO_DEVICE, handle); |
| } |
| return phone; |
| } |
| int devmap_null_create(void) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return -1; |
| ipcarg_t null_id; |
| int retval = async_req_0_1(phone, DEVMAP_DEVICE_NULL_CREATE, &null_id); |
| if (retval != EOK) |
| return -1; |
| return (int) null_id; |
| } |
| void devmap_null_destroy(int null_id) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return; |
| async_req_1_0(phone, DEVMAP_DEVICE_NULL_DESTROY, (ipcarg_t) null_id); |
| } |
| ipcarg_t devmap_device_get_count(void) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return 0; |
| ipcarg_t count; |
| int retval = async_req_0_1(phone, DEVMAP_DEVICE_GET_COUNT, &count); |
| if (retval != EOK) |
| return 0; |
| return count; |
| } |
| ipcarg_t devmap_device_get_devices(ipcarg_t count, dev_desc_t *data) |
| { |
| int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING); |
| if (phone < 0) |
| return 0; |
| async_serialize_start(); |
| ipc_call_t answer; |
| aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer); |
| ipcarg_t retval = ipc_data_read_start(phone, data, count * sizeof(dev_desc_t)); |
| if (retval != EOK) { |
| async_wait_for(req, NULL); |
| async_serialize_end(); |
| return 0; |
| } |
| async_wait_for(req, &retval); |
| async_serialize_end(); |
| if (retval != EOK) |
| return 0; |
| return IPC_GET_ARG1(answer); |
| } |
| /tags/0.4.1/uspace/lib/libc/generic/fibril_sync.c |
|---|
| 0,0 → 1,219 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <fibril_sync.h> |
| #include <fibril.h> |
| #include <async.h> |
| #include <adt/list.h> |
| #include <futex.h> |
| #include <assert.h> |
| void fibril_mutex_initialize(fibril_mutex_t *fm) |
| { |
| fm->counter = 1; |
| list_initialize(&fm->waiters); |
| } |
| void fibril_mutex_lock(fibril_mutex_t *fm) |
| { |
| futex_down(&async_futex); |
| if (fm->counter-- <= 0) { |
| fibril_t *f = (fibril_t *) fibril_get_id(); |
| list_append(&f->link, &fm->waiters); |
| fibril_switch(FIBRIL_TO_MANAGER); |
| } else { |
| futex_up(&async_futex); |
| } |
| } |
| bool fibril_mutex_trylock(fibril_mutex_t *fm) |
| { |
| bool locked = false; |
| futex_down(&async_futex); |
| if (fm->counter > 0) { |
| fm->counter--; |
| locked = true; |
| } |
| futex_up(&async_futex); |
| return locked; |
| } |
| static void _fibril_mutex_unlock_unsafe(fibril_mutex_t *fm) |
| { |
| assert(fm->counter <= 0); |
| if (fm->counter++ < 0) { |
| link_t *tmp; |
| fibril_t *f; |
| assert(!list_empty(&fm->waiters)); |
| tmp = fm->waiters.next; |
| f = list_get_instance(tmp, fibril_t, link); |
| list_remove(&f->link); |
| fibril_add_ready((fid_t) f); |
| } |
| } |
| void fibril_mutex_unlock(fibril_mutex_t *fm) |
| { |
| futex_down(&async_futex); |
| _fibril_mutex_unlock_unsafe(fm); |
| futex_up(&async_futex); |
| } |
| void fibril_rwlock_initialize(fibril_rwlock_t *frw) |
| { |
| frw->writers = 0; |
| frw->readers = 0; |
| list_initialize(&frw->waiters); |
| } |
| void fibril_rwlock_read_lock(fibril_rwlock_t *frw) |
| { |
| futex_down(&async_futex); |
| if (frw->writers) { |
| fibril_t *f = (fibril_t *) fibril_get_id(); |
| f->flags &= ~FIBRIL_WRITER; |
| list_append(&f->link, &frw->waiters); |
| fibril_switch(FIBRIL_TO_MANAGER); |
| } else { |
| frw->readers++; |
| futex_up(&async_futex); |
| } |
| } |
| void fibril_rwlock_write_lock(fibril_rwlock_t *frw) |
| { |
| futex_down(&async_futex); |
| if (frw->writers || frw->readers) { |
| fibril_t *f = (fibril_t *) fibril_get_id(); |
| f->flags |= FIBRIL_WRITER; |
| list_append(&f->link, &frw->waiters); |
| fibril_switch(FIBRIL_TO_MANAGER); |
| } else { |
| frw->writers++; |
| futex_up(&async_futex); |
| } |
| } |
| static void _fibril_rwlock_common_unlock(fibril_rwlock_t *frw) |
| { |
| futex_down(&async_futex); |
| assert(frw->readers || (frw->writers == 1)); |
| if (frw->readers) { |
| if (--frw->readers) |
| goto out; |
| } else { |
| frw->writers--; |
| } |
| assert(!frw->readers && !frw->writers); |
| while (!list_empty(&frw->waiters)) { |
| link_t *tmp = frw->waiters.next; |
| fibril_t *f = list_get_instance(tmp, fibril_t, link); |
| if (f->flags & FIBRIL_WRITER) { |
| if (frw->readers) |
| break; |
| list_remove(&f->link); |
| fibril_add_ready((fid_t) f); |
| frw->writers++; |
| break; |
| } else { |
| list_remove(&f->link); |
| fibril_add_ready((fid_t) f); |
| frw->readers++; |
| } |
| } |
| out: |
| futex_up(&async_futex); |
| } |
| void fibril_rwlock_read_unlock(fibril_rwlock_t *frw) |
| { |
| _fibril_rwlock_common_unlock(frw); |
| } |
| void fibril_rwlock_write_unlock(fibril_rwlock_t *frw) |
| { |
| _fibril_rwlock_common_unlock(frw); |
| } |
| void fibril_condvar_initialize(fibril_condvar_t *fcv) |
| { |
| list_initialize(&fcv->waiters); |
| } |
| void fibril_condvar_wait(fibril_condvar_t *fcv, fibril_mutex_t *fm) |
| { |
| fibril_t *f = (fibril_t *) fibril_get_id(); |
| futex_down(&async_futex); |
| list_append(&f->link, &fcv->waiters); |
| _fibril_mutex_unlock_unsafe(fm); |
| fibril_switch(FIBRIL_TO_MANAGER); |
| fibril_mutex_lock(fm); |
| } |
| static void _fibril_condvar_wakeup_common(fibril_condvar_t *fcv, bool once) |
| { |
| link_t *tmp; |
| fibril_t *f; |
| futex_down(&async_futex); |
| while (!list_empty(&fcv->waiters)) { |
| tmp = fcv->waiters.next; |
| f = list_get_instance(tmp, fibril_t, link); |
| list_remove(&f->link); |
| fibril_add_ready((fid_t) f); |
| if (once) |
| break; |
| } |
| futex_up(&async_futex); |
| } |
| void fibril_condvar_signal(fibril_condvar_t *fcv) |
| { |
| _fibril_condvar_wakeup_common(fcv, true); |
| } |
| void fibril_condvar_broadcast(fibril_condvar_t *fcv) |
| { |
| _fibril_condvar_wakeup_common(fcv, false); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/ipc.c |
|---|
| 0,0 → 1,967 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| * @} |
| */ |
| /** @addtogroup libcipc IPC |
| * @brief HelenOS uspace IPC |
| * @{ |
| * @ingroup libc |
| */ |
| /** @file |
| */ |
| #include <ipc/ipc.h> |
| #include <libc.h> |
| #include <malloc.h> |
| #include <errno.h> |
| #include <adt/list.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <futex.h> |
| #include <kernel/synch/synch.h> |
| #include <async.h> |
| #include <fibril.h> |
| #include <assert.h> |
| /** |
| * Structures of this type are used for keeping track of sent asynchronous calls |
| * and queing unsent calls. |
| */ |
| typedef struct { |
| link_t list; |
| ipc_async_callback_t callback; |
| void *private; |
| union { |
| ipc_callid_t callid; |
| struct { |
| ipc_call_t data; |
| int phoneid; |
| } msg; |
| } u; |
| fid_t fid; /**< Fibril waiting for sending this call. */ |
| } async_call_t; |
| LIST_INITIALIZE(dispatched_calls); |
| /** List of asynchronous calls that were not accepted by kernel. |
| * |
| * It is protected by async_futex, because if the call cannot be sent into the |
| * kernel, the async framework is used automatically. |
| */ |
| LIST_INITIALIZE(queued_calls); |
| static atomic_t ipc_futex = FUTEX_INITIALIZER; |
| /** Make a fast synchronous call. |
| * |
| * Only three payload arguments can be passed using this function. However, this |
| * function is faster than the generic ipc_call_sync_slow() because the payload |
| * is passed directly in registers. |
| * |
| * @param phoneid Phone handle for the call. |
| * @param method Requested method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param result1 If non-NULL, the return ARG1 will be stored there. |
| * @param result2 If non-NULL, the return ARG2 will be stored there. |
| * @param result3 If non-NULL, the return ARG3 will be stored there. |
| * @param result4 If non-NULL, the return ARG4 will be stored there. |
| * @param result5 If non-NULL, the return ARG5 will be stored there. |
| * |
| * @return Negative values represent errors returned by IPC. |
| * Otherwise the RETVAL of the answer is returned. |
| */ |
| int |
| ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, |
| ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3, |
| ipcarg_t *result4, ipcarg_t *result5) |
| { |
| ipc_call_t resdata; |
| int callres; |
| callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1, |
| arg2, arg3, (sysarg_t) &resdata); |
| if (callres) |
| return callres; |
| if (result1) |
| *result1 = IPC_GET_ARG1(resdata); |
| if (result2) |
| *result2 = IPC_GET_ARG2(resdata); |
| if (result3) |
| *result3 = IPC_GET_ARG3(resdata); |
| if (result4) |
| *result4 = IPC_GET_ARG4(resdata); |
| if (result5) |
| *result5 = IPC_GET_ARG5(resdata); |
| return IPC_GET_RETVAL(resdata); |
| } |
| /** Make a synchronous call transmitting 5 arguments of payload. |
| * |
| * @param phoneid Phone handle for the call. |
| * @param method Requested method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param result1 If non-NULL, storage for the first return argument. |
| * @param result2 If non-NULL, storage for the second return argument. |
| * @param result3 If non-NULL, storage for the third return argument. |
| * @param result4 If non-NULL, storage for the fourth return argument. |
| * @param result5 If non-NULL, storage for the fifth return argument. |
| * |
| * @return Negative value means IPC error. |
| * Otherwise the RETVAL of the answer. |
| */ |
| int |
| ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, |
| ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t *result1, |
| ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5) |
| { |
| ipc_call_t data; |
| int callres; |
| IPC_SET_METHOD(data, method); |
| IPC_SET_ARG1(data, arg1); |
| IPC_SET_ARG2(data, arg2); |
| IPC_SET_ARG3(data, arg3); |
| IPC_SET_ARG4(data, arg4); |
| IPC_SET_ARG5(data, arg5); |
| callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, phoneid, (sysarg_t) &data, |
| (sysarg_t) &data); |
| if (callres) |
| return callres; |
| if (result1) |
| *result1 = IPC_GET_ARG1(data); |
| if (result2) |
| *result2 = IPC_GET_ARG2(data); |
| if (result3) |
| *result3 = IPC_GET_ARG3(data); |
| if (result4) |
| *result4 = IPC_GET_ARG4(data); |
| if (result5) |
| *result5 = IPC_GET_ARG5(data); |
| return IPC_GET_RETVAL(data); |
| } |
| /** Syscall to send asynchronous message. |
| * |
| * @param phoneid Phone handle for the call. |
| * @param data Call data with the request. |
| * |
| * @return Hash of the call or an error code. |
| */ |
| static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data) |
| { |
| return __SYSCALL2(SYS_IPC_CALL_ASYNC_SLOW, phoneid, (sysarg_t) data); |
| } |
| /** Prolog to ipc_call_async_*() functions. |
| * |
| * @param private Argument for the answer/error callback. |
| * @param callback Answer/error callback. |
| * |
| * @return New, partially initialized async_call structure or NULL. |
| */ |
| static inline async_call_t *ipc_prepare_async(void *private, |
| ipc_async_callback_t callback) |
| { |
| async_call_t *call; |
| call = malloc(sizeof(*call)); |
| if (!call) { |
| if (callback) |
| callback(private, ENOMEM, NULL); |
| return NULL; |
| } |
| call->callback = callback; |
| call->private = private; |
| return call; |
| } |
| /** Epilogue of ipc_call_async_*() functions. |
| * |
| * @param callid Value returned by the SYS_IPC_CALL_ASYNC_* syscall. |
| * @param phoneid Phone handle through which the call was made. |
| * @param call async_call structure returned by ipc_prepare_async(). |
| * @param can_preempt If non-zero, the current fibril can be preempted in this |
| * call. |
| */ |
| static inline void ipc_finish_async(ipc_callid_t callid, int phoneid, |
| async_call_t *call, int can_preempt) |
| { |
| if (!call) { /* Nothing to do regardless if failed or not */ |
| futex_up(&ipc_futex); |
| return; |
| } |
| if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) { |
| futex_up(&ipc_futex); |
| /* Call asynchronous handler with error code */ |
| if (call->callback) |
| call->callback(call->private, ENOENT, NULL); |
| free(call); |
| return; |
| } |
| if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) { |
| futex_up(&ipc_futex); |
| call->u.msg.phoneid = phoneid; |
| futex_down(&async_futex); |
| list_append(&call->list, &queued_calls); |
| if (can_preempt) { |
| call->fid = fibril_get_id(); |
| fibril_switch(FIBRIL_TO_MANAGER); |
| /* Async futex unlocked by previous call */ |
| } else { |
| call->fid = 0; |
| futex_up(&async_futex); |
| } |
| return; |
| } |
| call->u.callid = callid; |
| /* Add call to the list of dispatched calls */ |
| list_append(&call->list, &dispatched_calls); |
| futex_up(&ipc_futex); |
| } |
| /** Make a fast asynchronous call. |
| * |
| * This function can only handle four arguments of payload. It is, however, |
| * faster than the more generic ipc_call_async_slow(). |
| * |
| * Note that this function is a void function. |
| * During normal opertation, answering this call will trigger the callback. |
| * In case of fatal error, call the callback handler with the proper error code. |
| * If the call cannot be temporarily made, queue it. |
| * |
| * @param phoneid Phone handle for the call. |
| * @param method Requested method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param private Argument to be passed to the answer/error callback. |
| * @param callback Answer or error callback. |
| * @param can_preempt If non-zero, the current fibril will be preempted in |
| * case the kernel temporarily refuses to accept more |
| * asynchronous calls. |
| */ |
| void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private, |
| ipc_async_callback_t callback, int can_preempt) |
| { |
| async_call_t *call = NULL; |
| ipc_callid_t callid; |
| if (callback) { |
| call = ipc_prepare_async(private, callback); |
| if (!call) |
| return; |
| } |
| /* |
| * We need to make sure that we get callid before another thread |
| * accesses the queue again. |
| */ |
| futex_down(&ipc_futex); |
| callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, |
| arg2, arg3, arg4); |
| if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) { |
| if (!call) { |
| call = ipc_prepare_async(private, callback); |
| if (!call) |
| return; |
| } |
| IPC_SET_METHOD(call->u.msg.data, method); |
| IPC_SET_ARG1(call->u.msg.data, arg1); |
| IPC_SET_ARG2(call->u.msg.data, arg2); |
| IPC_SET_ARG3(call->u.msg.data, arg3); |
| IPC_SET_ARG4(call->u.msg.data, arg4); |
| /* |
| * To achieve deterministic behavior, we always zero out the |
| * arguments that are beyond the limits of the fast version. |
| */ |
| IPC_SET_ARG5(call->u.msg.data, 0); |
| } |
| ipc_finish_async(callid, phoneid, call, can_preempt); |
| } |
| /** Make an asynchronous call transmitting the entire payload. |
| * |
| * Note that this function is a void function. |
| * During normal opertation, answering this call will trigger the callback. |
| * In case of fatal error, call the callback handler with the proper error code. |
| * If the call cannot be temporarily made, queue it. |
| * |
| * @param phoneid Phone handle for the call. |
| * @param method Requested method. |
| * @param arg1 Service-defined payload argument. |
| * @param arg2 Service-defined payload argument. |
| * @param arg3 Service-defined payload argument. |
| * @param arg4 Service-defined payload argument. |
| * @param arg5 Service-defined payload argument. |
| * @param private Argument to be passed to the answer/error callback. |
| * @param callback Answer or error callback. |
| * @param can_preempt If non-zero, the current fibril will be preempted in |
| * case the kernel temporarily refuses to accept more |
| * asynchronous calls. |
| * |
| */ |
| void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private, |
| ipc_async_callback_t callback, int can_preempt) |
| { |
| async_call_t *call; |
| ipc_callid_t callid; |
| call = ipc_prepare_async(private, callback); |
| if (!call) |
| return; |
| IPC_SET_METHOD(call->u.msg.data, method); |
| IPC_SET_ARG1(call->u.msg.data, arg1); |
| IPC_SET_ARG2(call->u.msg.data, arg2); |
| IPC_SET_ARG3(call->u.msg.data, arg3); |
| IPC_SET_ARG4(call->u.msg.data, arg4); |
| IPC_SET_ARG5(call->u.msg.data, arg5); |
| /* |
| * We need to make sure that we get callid before another thread |
| * accesses the queue again. |
| */ |
| futex_down(&ipc_futex); |
| callid = _ipc_call_async(phoneid, &call->u.msg.data); |
| ipc_finish_async(callid, phoneid, call, can_preempt); |
| } |
| /** Answer a received call - fast version. |
| * |
| * The fast answer makes use of passing retval and first four arguments in |
| * registers. If you need to return more, use the ipc_answer_slow() instead. |
| * |
| * @param callid Hash of the call being answered. |
| * @param retval Return value. |
| * @param arg1 First return argument. |
| * @param arg2 Second return argument. |
| * @param arg3 Third return argument. |
| * @param arg4 Fourth return argument. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4) |
| { |
| return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3, |
| arg4); |
| } |
| /** Answer a received call - slow full version. |
| * |
| * @param callid Hash of the call being answered. |
| * @param retval Return value. |
| * @param arg1 First return argument. |
| * @param arg2 Second return argument. |
| * @param arg3 Third return argument. |
| * @param arg4 Fourth return argument. |
| * @param arg5 Fifth return argument. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1, |
| ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5) |
| { |
| ipc_call_t data; |
| IPC_SET_RETVAL(data, retval); |
| IPC_SET_ARG1(data, arg1); |
| IPC_SET_ARG2(data, arg2); |
| IPC_SET_ARG3(data, arg3); |
| IPC_SET_ARG4(data, arg4); |
| IPC_SET_ARG5(data, arg5); |
| return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data); |
| } |
| /** Try to dispatch queued calls from the async queue. */ |
| static void try_dispatch_queued_calls(void) |
| { |
| async_call_t *call; |
| ipc_callid_t callid; |
| /** @todo |
| * Integrate intelligently ipc_futex, so that it is locked during |
| * ipc_call_async_*(), until it is added to dispatched_calls. |
| */ |
| futex_down(&async_futex); |
| while (!list_empty(&queued_calls)) { |
| call = list_get_instance(queued_calls.next, async_call_t, list); |
| callid = _ipc_call_async(call->u.msg.phoneid, |
| &call->u.msg.data); |
| if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) { |
| break; |
| } |
| list_remove(&call->list); |
| futex_up(&async_futex); |
| if (call->fid) |
| fibril_add_ready(call->fid); |
| if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) { |
| if (call->callback) |
| call->callback(call->private, ENOENT, NULL); |
| free(call); |
| } else { |
| call->u.callid = callid; |
| futex_down(&ipc_futex); |
| list_append(&call->list, &dispatched_calls); |
| futex_up(&ipc_futex); |
| } |
| futex_down(&async_futex); |
| } |
| futex_up(&async_futex); |
| } |
| /** Handle a received answer. |
| * |
| * Find the hash of the answer and call the answer callback. |
| * |
| * @todo Make it use hash table. |
| * |
| * @param callid Hash of the received answer. |
| * The answer has the same hash as the request OR'ed with |
| * the IPC_CALLID_ANSWERED bit. |
| * @param data Call data of the answer. |
| */ |
| static void handle_answer(ipc_callid_t callid, ipc_call_t *data) |
| { |
| link_t *item; |
| async_call_t *call; |
| callid &= ~IPC_CALLID_ANSWERED; |
| futex_down(&ipc_futex); |
| for (item = dispatched_calls.next; item != &dispatched_calls; |
| item = item->next) { |
| call = list_get_instance(item, async_call_t, list); |
| if (call->u.callid == callid) { |
| list_remove(&call->list); |
| futex_up(&ipc_futex); |
| if (call->callback) |
| call->callback(call->private, |
| IPC_GET_RETVAL(*data), data); |
| free(call); |
| return; |
| } |
| } |
| futex_up(&ipc_futex); |
| } |
| /** Wait for a first call to come. |
| * |
| * @param call Storage where the incoming call data will be stored. |
| * @param usec Timeout in microseconds |
| * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking). |
| * |
| * @return Hash of the call. Note that certain bits have special |
| * meaning. IPC_CALLID_ANSWERED will be set in an answer |
| * and IPC_CALLID_NOTIFICATION is used for notifications. |
| * |
| */ |
| ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags) |
| { |
| ipc_callid_t callid; |
| callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags); |
| /* Handle received answers */ |
| if (callid & IPC_CALLID_ANSWERED) { |
| handle_answer(callid, call); |
| try_dispatch_queued_calls(); |
| } |
| return callid; |
| } |
| /** Wait some time for an IPC call. |
| * |
| * The call will return after an answer is received. |
| * |
| * @param call Storage where the incoming call data will be stored. |
| * @param usec Timeout in microseconds. |
| * |
| * @return Hash of the answer. |
| */ |
| ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec) |
| { |
| ipc_callid_t callid; |
| do { |
| callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE); |
| } while (callid & IPC_CALLID_ANSWERED); |
| return callid; |
| } |
| /** Check if there is an IPC call waiting to be picked up. |
| * |
| * @param call Storage where the incoming call will be stored. |
| * @return Hash of the answer. |
| */ |
| ipc_callid_t ipc_trywait_for_call(ipc_call_t *call) |
| { |
| ipc_callid_t callid; |
| do { |
| callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT, |
| SYNCH_FLAGS_NON_BLOCKING); |
| } while (callid & IPC_CALLID_ANSWERED); |
| return callid; |
| } |
| /** Ask destination to do a callback connection. |
| * |
| * @param phoneid Phone handle used for contacting the other side. |
| * @param arg1 Service-defined argument. |
| * @param arg2 Service-defined argument. |
| * @param arg3 Service-defined argument. |
| * @param phonehash Storage where the library will store an opaque |
| * identifier of the phone that will be used for incoming |
| * calls. This identifier can be used for connection |
| * tracking. |
| * |
| * @return Zero on success or a negative error code. |
| */ |
| int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3, |
| ipcarg_t *phonehash) |
| { |
| return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2, |
| arg3, NULL, NULL, NULL, NULL, phonehash); |
| } |
| /** Ask through phone for a new connection to some service. |
| * |
| * @param phoneid Phone handle used for contacting the other side. |
| * @param arg1 User defined argument. |
| * @param arg2 User defined argument. |
| * @param arg3 User defined argument. |
| * |
| * @return New phone handle on success or a negative error code. |
| */ |
| int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3) |
| { |
| ipcarg_t newphid; |
| int res; |
| res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, |
| NULL, NULL, NULL, NULL, &newphid); |
| if (res) |
| return res; |
| return newphid; |
| } |
| /** Ask through phone for a new connection to some service. |
| * |
| * If the connection is not available at the moment, the |
| * call will block. |
| * |
| * @param phoneid Phone handle used for contacting the other side. |
| * @param arg1 User defined argument. |
| * @param arg2 User defined argument. |
| * @param arg3 User defined argument. |
| * |
| * @return New phone handle on success or a negative error code. |
| */ |
| int ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3) |
| { |
| ipcarg_t newphid; |
| int res; |
| res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, |
| IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid); |
| if (res) |
| return res; |
| return newphid; |
| } |
| /** Hang up a phone. |
| * |
| * @param phoneid Handle of the phone to be hung up. |
| * |
| * @return Zero on success or a negative error code. |
| */ |
| int ipc_hangup(int phoneid) |
| { |
| return __SYSCALL1(SYS_IPC_HANGUP, phoneid); |
| } |
| /** Register IRQ notification. |
| * |
| * @param inr IRQ number. |
| * @param devno Device number of the device generating inr. |
| * @param method Use this method for notifying me. |
| * @param ucode Top-half pseudocode handler. |
| * |
| * @return Value returned by the kernel. |
| */ |
| int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode) |
| { |
| return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method, |
| (sysarg_t) ucode); |
| } |
| /** Unregister IRQ notification. |
| * |
| * @param inr IRQ number. |
| * @param devno Device number of the device generating inr. |
| * |
| * @return Value returned by the kernel. |
| */ |
| int ipc_unregister_irq(int inr, int devno) |
| { |
| return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno); |
| } |
| /** Forward a received call to another destination. |
| * |
| * @param callid Hash of the call to forward. |
| * @param phoneid Phone handle to use for forwarding. |
| * @param method New method for the forwarded call. |
| * @param arg1 New value of the first argument for the forwarded call. |
| * @param arg2 New value of the second argument for the forwarded call. |
| * @param mode Flags specifying mode of the forward operation. |
| * |
| * @return Zero on success or an error code. |
| * |
| * For non-system methods, the old method, arg1 and arg2 are rewritten by the |
| * new values. For system methods, the new method, arg1 and arg2 are written |
| * to the old arg1, arg2 and arg3, respectivelly. Calls with immutable |
| * methods are forwarded verbatim. |
| */ |
| int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, |
| ipcarg_t arg1, ipcarg_t arg2, int mode) |
| { |
| return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, method, arg1, |
| arg2, mode); |
| } |
| int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method, |
| ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, |
| int mode) |
| { |
| ipc_call_t data; |
| IPC_SET_METHOD(data, method); |
| IPC_SET_ARG1(data, arg1); |
| IPC_SET_ARG2(data, arg2); |
| IPC_SET_ARG3(data, arg3); |
| IPC_SET_ARG4(data, arg4); |
| IPC_SET_ARG5(data, arg5); |
| return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode); |
| } |
| /** Wrapper for making IPC_M_SHARE_IN calls. |
| * |
| * @param phoneid Phone that will be used to contact the receiving side. |
| * @param dst Destination address space area base. |
| * @param size Size of the destination address space area. |
| * @param arg User defined argument. |
| * @param flags Storage where the received flags will be stored. Can be |
| * NULL. |
| * |
| * @return Zero on success or a negative error code from errno.h. |
| */ |
| int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg, |
| int *flags) |
| { |
| int res; |
| sysarg_t tmp_flags; |
| res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst, |
| (ipcarg_t) size, arg, NULL, &tmp_flags); |
| if (flags) |
| *flags = tmp_flags; |
| return res; |
| } |
| /** Wrapper for receiving the IPC_M_SHARE_IN calls. |
| * |
| * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * So far, this wrapper is to be used from within a connection fibril. |
| * |
| * @param callid Storage where the hash of the IPC_M_SHARE_IN call will |
| * be stored. |
| * @param size Destination address space area size. |
| * |
| * @return Non-zero on success, zero on failure. |
| */ |
| int ipc_share_in_receive(ipc_callid_t *callid, size_t *size) |
| { |
| ipc_call_t data; |
| assert(callid); |
| assert(size); |
| *callid = async_get_call(&data); |
| if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN) |
| return 0; |
| *size = (size_t) IPC_GET_ARG2(data); |
| return 1; |
| } |
| /** Wrapper for answering the IPC_M_SHARE_IN calls. |
| * |
| * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * @param callid Hash of the IPC_M_DATA_READ call to answer. |
| * @param src Source address space base. |
| * @param flags Flags to be used for sharing. Bits can be only cleared. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags) |
| { |
| return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) flags); |
| } |
| /** Wrapper for making IPC_M_SHARE_OUT calls. |
| * |
| * @param phoneid Phone that will be used to contact the receiving side. |
| * @param src Source address space area base address. |
| * @param flags Flags to be used for sharing. Bits can be only cleared. |
| * |
| * @return Zero on success or a negative error code from errno.h. |
| */ |
| int ipc_share_out_start(int phoneid, void *src, int flags) |
| { |
| return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0, |
| (ipcarg_t) flags); |
| } |
| /** Wrapper for receiving the IPC_M_SHARE_OUT calls. |
| * |
| * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * So far, this wrapper is to be used from within a connection fibril. |
| * |
| * @param callid Storage where the hash of the IPC_M_SHARE_OUT call will |
| * be stored. |
| * @param size Storage where the source address space area size will be |
| * stored. |
| * @param flags Storage where the sharing flags will be stored. |
| * |
| * @return Non-zero on success, zero on failure. |
| */ |
| int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags) |
| { |
| ipc_call_t data; |
| assert(callid); |
| assert(size); |
| assert(flags); |
| *callid = async_get_call(&data); |
| if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT) |
| return 0; |
| *size = (size_t) IPC_GET_ARG2(data); |
| *flags = (int) IPC_GET_ARG3(data); |
| return 1; |
| } |
| /** Wrapper for answering the IPC_M_SHARE_OUT calls. |
| * |
| * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * @param callid Hash of the IPC_M_DATA_WRITE call to answer. |
| * @param dst Destination address space area base address. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int ipc_share_out_finalize(ipc_callid_t callid, void *dst) |
| { |
| return ipc_answer_1(callid, EOK, (ipcarg_t) dst); |
| } |
| /** Wrapper for making IPC_M_DATA_READ calls. |
| * |
| * @param phoneid Phone that will be used to contact the receiving side. |
| * @param dst Address of the beginning of the destination buffer. |
| * @param size Size of the destination buffer. |
| * |
| * @return Zero on success or a negative error code from errno.h. |
| */ |
| int ipc_data_read_start(int phoneid, void *dst, size_t size) |
| { |
| return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst, |
| (ipcarg_t) size); |
| } |
| /** Wrapper for receiving the IPC_M_DATA_READ calls. |
| * |
| * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * So far, this wrapper is to be used from within a connection fibril. |
| * |
| * @param callid Storage where the hash of the IPC_M_DATA_READ call will |
| * be stored. |
| * @param size Storage where the maximum size will be stored. Can be |
| * NULL. |
| * |
| * @return Non-zero on success, zero on failure. |
| */ |
| int ipc_data_read_receive(ipc_callid_t *callid, size_t *size) |
| { |
| ipc_call_t data; |
| assert(callid); |
| *callid = async_get_call(&data); |
| if (IPC_GET_METHOD(data) != IPC_M_DATA_READ) |
| return 0; |
| if (size) |
| *size = (size_t) IPC_GET_ARG2(data); |
| return 1; |
| } |
| /** Wrapper for answering the IPC_M_DATA_READ calls. |
| * |
| * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * @param callid Hash of the IPC_M_DATA_READ call to answer. |
| * @param src Source address for the IPC_M_DATA_READ call. |
| * @param size Size for the IPC_M_DATA_READ call. Can be smaller than |
| * the maximum size announced by the sender. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size) |
| { |
| return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size); |
| } |
| /** Wrapper for making IPC_M_DATA_WRITE calls. |
| * |
| * @param phoneid Phone that will be used to contact the receiving side. |
| * @param src Address of the beginning of the source buffer. |
| * @param size Size of the source buffer. |
| * |
| * @return Zero on success or a negative error code from errno.h. |
| */ |
| int ipc_data_write_start(int phoneid, const void *src, size_t size) |
| { |
| return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src, |
| (ipcarg_t) size); |
| } |
| /** Wrapper for receiving the IPC_M_DATA_WRITE calls. |
| * |
| * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * So far, this wrapper is to be used from within a connection fibril. |
| * |
| * @param callid Storage where the hash of the IPC_M_DATA_WRITE call will |
| * be stored. |
| * @param size Storage where the suggested size will be stored. May be |
| * NULL |
| * |
| * @return Non-zero on success, zero on failure. |
| */ |
| int ipc_data_write_receive(ipc_callid_t *callid, size_t *size) |
| { |
| ipc_call_t data; |
| assert(callid); |
| *callid = async_get_call(&data); |
| if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE) |
| return 0; |
| if (size) |
| *size = (size_t) IPC_GET_ARG2(data); |
| return 1; |
| } |
| /** Wrapper for answering the IPC_M_DATA_WRITE calls. |
| * |
| * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls |
| * so that the user doesn't have to remember the meaning of each IPC argument. |
| * |
| * @param callid Hash of the IPC_M_DATA_WRITE call to answer. |
| * @param dst Final destination address for the IPC_M_DATA_WRITE call. |
| * @param size Final size for the IPC_M_DATA_WRITE call. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size) |
| { |
| return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size); |
| } |
| #include <kernel/syscall/sysarg64.h> |
| /** Connect to a task specified by id. |
| */ |
| int ipc_connect_kbox(task_id_t id) |
| { |
| sysarg64_t arg; |
| arg.value = (unsigned long long) id; |
| return __SYSCALL1(SYS_IPC_CONNECT_KBOX, (sysarg_t) &arg); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/adt/hash_table.c |
|---|
| 0,0 → 1,196 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| /* |
| * This is an implementation of generic chained hash table. |
| */ |
| #include <adt/hash_table.h> |
| #include <adt/list.h> |
| #include <unistd.h> |
| #include <malloc.h> |
| #include <assert.h> |
| #include <stdio.h> |
| #include <string.h> |
| /** Create chained hash table. |
| * |
| * @param h Hash table structure. Will be initialized by this call. |
| * @param m Number of hash table buckets. |
| * @param max_keys Maximal number of keys needed to identify an item. |
| * @param op Hash table operations structure. |
| * @return True on success |
| */ |
| int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys, |
| hash_table_operations_t *op) |
| { |
| hash_count_t i; |
| assert(h); |
| assert(op && op->hash && op->compare); |
| assert(max_keys > 0); |
| h->entry = malloc(m * sizeof(link_t)); |
| if (!h->entry) { |
| printf("cannot allocate memory for hash table\n"); |
| return false; |
| } |
| memset((void *) h->entry, 0, m * sizeof(link_t)); |
| for (i = 0; i < m; i++) |
| list_initialize(&h->entry[i]); |
| h->entries = m; |
| h->max_keys = max_keys; |
| h->op = op; |
| return true; |
| } |
| /** Destroy a hash table instance. |
| * |
| * @param h Hash table to be destroyed. |
| */ |
| void hash_table_destroy(hash_table_t *h) |
| { |
| assert(h); |
| assert(h->entry); |
| free(h->entry); |
| } |
| /** Insert item into a hash table. |
| * |
| * @param h Hash table. |
| * @param key Array of all keys necessary to compute hash index. |
| * @param item Item to be inserted into the hash table. |
| */ |
| void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item) |
| { |
| hash_index_t chain; |
| assert(item); |
| assert(h && h->op && h->op->hash && h->op->compare); |
| chain = h->op->hash(key); |
| assert(chain < h->entries); |
| list_append(item, &h->entry[chain]); |
| } |
| /** Search hash table for an item matching keys. |
| * |
| * @param h Hash table. |
| * @param key Array of all keys needed to compute hash index. |
| * |
| * @return Matching item on success, NULL if there is no such item. |
| */ |
| link_t *hash_table_find(hash_table_t *h, unsigned long key[]) |
| { |
| link_t *cur; |
| hash_index_t chain; |
| assert(h && h->op && h->op->hash && h->op->compare); |
| chain = h->op->hash(key); |
| assert(chain < h->entries); |
| for (cur = h->entry[chain].next; cur != &h->entry[chain]; |
| cur = cur->next) { |
| if (h->op->compare(key, h->max_keys, cur)) { |
| /* |
| * The entry is there. |
| */ |
| return cur; |
| } |
| } |
| return NULL; |
| } |
| /** Remove all matching items from hash table. |
| * |
| * For each removed item, h->remove_callback() is called. |
| * |
| * @param h Hash table. |
| * @param key Array of keys that will be compared against items of |
| * the hash table. |
| * @param keys Number of keys in the 'key' array. |
| */ |
| void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys) |
| { |
| hash_index_t chain; |
| link_t *cur; |
| assert(h && h->op && h->op->hash && h->op->compare && |
| h->op->remove_callback); |
| assert(keys <= h->max_keys); |
| if (keys == h->max_keys) { |
| /* |
| * All keys are known, hash_table_find() can be used to find the |
| * entry. |
| */ |
| cur = hash_table_find(h, key); |
| if (cur) { |
| list_remove(cur); |
| h->op->remove_callback(cur); |
| } |
| return; |
| } |
| /* |
| * Fewer keys were passed. |
| * Any partially matching entries are to be removed. |
| */ |
| for (chain = 0; chain < h->entries; chain++) { |
| for (cur = h->entry[chain].next; cur != &h->entry[chain]; |
| cur = cur->next) { |
| if (h->op->compare(key, keys, cur)) { |
| link_t *hlp; |
| hlp = cur; |
| cur = cur->prev; |
| list_remove(hlp); |
| h->op->remove_callback(hlp); |
| continue; |
| } |
| } |
| } |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/adt/list.c |
|---|
| 0,0 → 1,112 |
| /* |
| * Copyright (c) 2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <adt/list.h> |
| /** Check for membership |
| * |
| * Check whether link is contained in the list head. |
| * The membership is defined as pointer equivalence. |
| * |
| * @param link Item to look for. |
| * @param head List to look in. |
| * |
| * @return true if link is contained in head, false otherwise. |
| * |
| */ |
| int list_member(const link_t *link, const link_t *head) |
| { |
| int found = 0; |
| link_t *hlp = head->next; |
| while (hlp != head) { |
| if (hlp == link) { |
| found = 1; |
| break; |
| } |
| hlp = hlp->next; |
| } |
| return found; |
| } |
| /** Concatenate two lists |
| * |
| * Concatenate lists head1 and head2, producing a single |
| * list head1 containing items from both (in head1, head2 |
| * order) and empty list head2. |
| * |
| * @param head1 First list and concatenated output |
| * @param head2 Second list and empty output. |
| * |
| */ |
| void list_concat(link_t *head1, link_t *head2) |
| { |
| if (list_empty(head2)) |
| return; |
| head2->next->prev = head1->prev; |
| head2->prev->next = head1; |
| head1->prev->next = head2->next; |
| head1->prev = head2->prev; |
| list_initialize(head2); |
| } |
| /** Count list items |
| * |
| * Return the number of items in the list. |
| * |
| * @param link List to count. |
| * |
| * @return Number of items in the list. |
| * |
| */ |
| unsigned int list_count(const link_t *link) |
| { |
| unsigned int count = 0; |
| link_t *hlp = link->next; |
| while (hlp != link) { |
| count++; |
| hlp = hlp->next; |
| } |
| return count; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/mem.c |
|---|
| 0,0 → 1,239 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <mem.h> |
| #include <stdlib.h> |
| #include <sys/types.h> |
| /** Fill memory block with a constant value. */ |
| void *memset(void *dest, int b, size_t n) |
| { |
| char *pb; |
| unsigned long *pw; |
| size_t word_size; |
| size_t n_words; |
| unsigned long pattern; |
| size_t i; |
| size_t fill; |
| /* Fill initial segment. */ |
| word_size = sizeof(unsigned long); |
| fill = word_size - ((uintptr_t) dest & (word_size - 1)); |
| if (fill > n) fill = n; |
| pb = dest; |
| i = fill; |
| while (i-- != 0) |
| *pb++ = b; |
| /* Compute remaining size. */ |
| n -= fill; |
| if (n == 0) return dest; |
| n_words = n / word_size; |
| n = n % word_size; |
| pw = (unsigned long *) pb; |
| /* Create word-sized pattern for aligned segment. */ |
| pattern = 0; |
| i = word_size; |
| while (i-- != 0) |
| pattern = (pattern << 8) | (uint8_t) b; |
| /* Fill aligned segment. */ |
| i = n_words; |
| while (i-- != 0) |
| *pw++ = pattern; |
| pb = (char *) pw; |
| /* Fill final segment. */ |
| i = n; |
| while (i-- != 0) |
| *pb++ = b; |
| return dest; |
| } |
| struct along { |
| unsigned long n; |
| } __attribute__ ((packed)); |
| static void *unaligned_memcpy(void *dst, const void *src, size_t n) |
| { |
| size_t i, j; |
| struct along *adst = dst; |
| const struct along *asrc = src; |
| for (i = 0; i < n / sizeof(unsigned long); i++) |
| adst[i].n = asrc[i].n; |
| for (j = 0; j < n % sizeof(unsigned long); j++) |
| ((unsigned char *) (((unsigned long *) dst) + i))[j] = |
| ((unsigned char *) (((unsigned long *) src) + i))[j]; |
| return (char *) dst; |
| } |
| /** Copy memory block. */ |
| void *memcpy(void *dst, const void *src, size_t n) |
| { |
| size_t i; |
| size_t mod, fill; |
| size_t word_size; |
| size_t n_words; |
| const unsigned long *srcw; |
| unsigned long *dstw; |
| const uint8_t *srcb; |
| uint8_t *dstb; |
| word_size = sizeof(unsigned long); |
| /* |
| * Are source and destination addresses congruent modulo word_size? |
| * If not, use unaligned_memcpy(). |
| */ |
| if (((uintptr_t) dst & (word_size - 1)) != |
| ((uintptr_t) src & (word_size - 1))) |
| return unaligned_memcpy(dst, src, n); |
| /* |
| * mod is the address modulo word size. fill is the length of the |
| * initial buffer segment before the first word boundary. |
| * If the buffer is very short, use unaligned_memcpy(), too. |
| */ |
| mod = (uintptr_t) dst & (word_size - 1); |
| fill = word_size - mod; |
| if (fill > n) fill = n; |
| /* Copy the initial segment. */ |
| srcb = src; |
| dstb = dst; |
| i = fill; |
| while (i-- != 0) |
| *dstb++ = *srcb++; |
| /* Compute remaining length. */ |
| n -= fill; |
| if (n == 0) return dst; |
| /* Pointers to aligned segment. */ |
| dstw = (unsigned long *) dstb; |
| srcw = (const unsigned long *) srcb; |
| n_words = n / word_size; /* Number of whole words to copy. */ |
| n -= n_words * word_size; /* Remaining bytes at the end. */ |
| /* "Fast" copy. */ |
| i = n_words; |
| while (i-- != 0) |
| *dstw++ = *srcw++; |
| /* |
| * Copy the rest. |
| */ |
| srcb = (const uint8_t *) srcw; |
| dstb = (uint8_t *) dstw; |
| i = n; |
| while (i-- != 0) |
| *dstb++ = *srcb++; |
| return dst; |
| } |
| /** Move memory block with possible overlapping. */ |
| void *memmove(void *dst, const void *src, size_t n) |
| { |
| const uint8_t *sp; |
| uint8_t *dp; |
| /* Nothing to do? */ |
| if (src == dst) |
| return dst; |
| /* Non-overlapping? */ |
| if (dst >= src + n || src >= dst + n) { |
| return memcpy(dst, src, n); |
| } |
| /* Which direction? */ |
| if (src > dst) { |
| /* Forwards. */ |
| sp = src; |
| dp = dst; |
| while (n-- != 0) |
| *dp++ = *sp++; |
| } else { |
| /* Backwards. */ |
| sp = src + (n - 1); |
| dp = dst + (n - 1); |
| while (n-- != 0) |
| *dp-- = *sp--; |
| } |
| return dst; |
| } |
| /** Compare two memory areas. |
| * |
| * @param s1 Pointer to the first area to compare. |
| * @param s2 Pointer to the second area to compare. |
| * @param len Size of the first area in bytes. Both areas must have |
| * the same length. |
| * @return If len is 0, return zero. If the areas match, return |
| * zero. Otherwise return non-zero. |
| */ |
| int bcmp(const char *s1, const char *s2, size_t len) |
| { |
| for (; len && *s1++ == *s2++; len--) |
| ; |
| return len; |
| } |
| /** @} |
| */ |
| Property changes: |
| Added: svn:mergeinfo |
| /tags/0.4.1/uspace/lib/libc/generic/loader.c |
|---|
| 0,0 → 1,309 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <ipc/ipc.h> |
| #include <ipc/loader.h> |
| #include <ipc/services.h> |
| #include <libc.h> |
| #include <task.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <async.h> |
| #include <errno.h> |
| #include <vfs/vfs.h> |
| #include <loader/loader.h> |
| /** Connect to a new program loader. |
| * |
| * Spawns a new program loader task and returns the connection structure. |
| * |
| * @param name Symbolic name to set on the newly created task. |
| * |
| * @return Pointer to the loader connection structure (should be |
| * deallocated using free() after use). |
| * |
| */ |
| int loader_spawn(const char *name) |
| { |
| return __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER, |
| (sysarg_t) name, str_size(name)); |
| } |
| loader_t *loader_connect(void) |
| { |
| int phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0); |
| if (phone_id < 0) |
| return NULL; |
| loader_t *ldr = malloc(sizeof(loader_t)); |
| if (ldr == NULL) |
| return NULL; |
| ldr->phone_id = phone_id; |
| return ldr; |
| } |
| /** Get ID of the new task. |
| * |
| * Retrieves the ID of the new task from the loader. |
| * |
| * @param ldr Loader connection structure. |
| * @param task_id Points to a variable where the ID should be stored. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int loader_get_task_id(loader_t *ldr, task_id_t *task_id) |
| { |
| /* Get task ID. */ |
| ipc_call_t answer; |
| aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer); |
| int rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| return rc; |
| } |
| ipcarg_t retval; |
| async_wait_for(req, &retval); |
| return (int) retval; |
| } |
| /** Set pathname of the program to load. |
| * |
| * Sets the name of the program file to load. The name can be relative |
| * to the current working directory (it will be absolutized before |
| * sending to the loader). |
| * |
| * @param ldr Loader connection structure. |
| * @param path Pathname of the program file. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int loader_set_pathname(loader_t *ldr, const char *path) |
| { |
| size_t pa_len; |
| char *pa = absolutize(path, &pa_len); |
| if (!pa) |
| return 0; |
| /* Send program pathname */ |
| ipc_call_t answer; |
| aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer); |
| int rc = ipc_data_write_start(ldr->phone_id, (void *) pa, pa_len); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| return rc; |
| } |
| free(pa); |
| ipcarg_t retval; |
| async_wait_for(req, &retval); |
| return (int) retval; |
| } |
| /** Set command-line arguments for the program. |
| * |
| * Sets the vector of command-line arguments to be passed to the loaded |
| * program. By convention, the very first argument is typically the same as |
| * the command used to execute the program. |
| * |
| * @param ldr Loader connection structure. |
| * @param argv NULL-terminated array of pointers to arguments. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int loader_set_args(loader_t *ldr, char *const argv[]) |
| { |
| /* |
| * Serialize the arguments into a single array. First |
| * compute size of the buffer needed. |
| */ |
| char *const *ap = argv; |
| size_t buffer_size = 0; |
| while (*ap != NULL) { |
| buffer_size += str_size(*ap) + 1; |
| ap++; |
| } |
| char *arg_buf = malloc(buffer_size); |
| if (arg_buf == NULL) |
| return ENOMEM; |
| /* Now fill the buffer with null-terminated argument strings */ |
| ap = argv; |
| char *dp = arg_buf; |
| while (*ap != NULL) { |
| str_cpy(dp, buffer_size - (dp - arg_buf), *ap); |
| dp += str_size(*ap) + 1; |
| ap++; |
| } |
| /* Send serialized arguments to the loader */ |
| ipc_call_t answer; |
| aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer); |
| ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| return rc; |
| } |
| async_wait_for(req, &rc); |
| if (rc != EOK) |
| return rc; |
| /* Free temporary buffer */ |
| free(arg_buf); |
| return EOK; |
| } |
| /** Set preset files for the program. |
| * |
| * Sets the vector of preset files to be passed to the loaded |
| * program. By convention, the first three files represent stdin, |
| * stdout and stderr respectively. |
| * |
| * @param ldr Loader connection structure. |
| * @param files NULL-terminated array of pointers to files. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int loader_set_files(loader_t *ldr, fdi_node_t *const files[]) |
| { |
| /* |
| * Serialize the arguments into a single array. First |
| * compute size of the buffer needed. |
| */ |
| fdi_node_t *const *ap = files; |
| size_t count = 0; |
| while (*ap != NULL) { |
| count++; |
| ap++; |
| } |
| fdi_node_t *files_buf; |
| files_buf = (fdi_node_t *) malloc(count * sizeof(fdi_node_t)); |
| if (files_buf == NULL) |
| return ENOMEM; |
| /* Fill the buffer */ |
| size_t i; |
| for (i = 0; i < count; i++) |
| files_buf[i] = *files[i]; |
| /* Send serialized files to the loader */ |
| ipc_call_t answer; |
| aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer); |
| ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) files_buf, |
| count * sizeof(fdi_node_t)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| return rc; |
| } |
| async_wait_for(req, &rc); |
| if (rc != EOK) |
| return rc; |
| /* Free temporary buffer */ |
| free(files_buf); |
| return EOK; |
| } |
| /** Instruct loader to load the program. |
| * |
| * If this function succeeds, the program has been successfully loaded |
| * and is ready to be executed. |
| * |
| * @param ldr Loader connection structure. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int loader_load_program(loader_t *ldr) |
| { |
| return (int) async_req_0_0(ldr->phone_id, LOADER_LOAD); |
| } |
| /** Instruct loader to execute the program. |
| * |
| * Note that this function blocks until the loader actually replies |
| * so you cannot expect this function to return if you are debugging |
| * the task and its thread is stopped. |
| * |
| * After using this function, no further operations must be performed |
| * on the loader structure. It should be de-allocated using free(). |
| * |
| * @param ldr Loader connection structure. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| int loader_run(loader_t *ldr) |
| { |
| int rc = async_req_0_0(ldr->phone_id, LOADER_RUN); |
| if (rc != EOK) |
| return rc; |
| ipc_hangup(ldr->phone_id); |
| ldr->phone_id = 0; |
| return EOK; |
| } |
| /** Cancel the loader session. |
| * |
| * Tells the loader not to load any program and terminate. |
| * After using this function, no further operations must be performed |
| * on the loader structure. It should be de-allocated using free(). |
| * |
| * @param ldr Loader connection structure. |
| * |
| * @return Zero on success or negative error code. |
| * |
| */ |
| void loader_abort(loader_t *ldr) |
| { |
| ipc_hangup(ldr->phone_id); |
| ldr->phone_id = 0; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/ddi.c |
|---|
| 0,0 → 1,139 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <ddi.h> |
| #include <libarch/ddi.h> |
| #include <libc.h> |
| #include <task.h> |
| #include <as.h> |
| #include <align.h> |
| #include <libarch/config.h> |
| #include <kernel/ddi/ddi_arg.h> |
| /** Return unique device number. |
| * |
| * @return New unique device number. |
| * |
| */ |
| int device_assign_devno(void) |
| { |
| return __SYSCALL0(SYS_DEVICE_ASSIGN_DEVNO); |
| } |
| /** Map piece of physical memory to task. |
| * |
| * Caller of this function must have the CAP_MEM_MANAGER capability. |
| * |
| * @param pf Physical address of the starting frame. |
| * @param vp Virtual address of the starting page. |
| * @param pages Number of pages to map. |
| * @param flags Flags for the new address space area. |
| * |
| * @return 0 on success, EPERM if the caller lacks the |
| * CAP_MEM_MANAGER capability, ENOENT if there is no task |
| * with specified ID and ENOMEM if there was some problem |
| * in creating address space area. |
| */ |
| int physmem_map(void *pf, void *vp, unsigned long pages, int flags) |
| { |
| return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp, pages, |
| flags); |
| } |
| /** Enable I/O space range to task. |
| * |
| * Caller of this function must have the IO_MEM_MANAGER capability. |
| * |
| * @param id Task ID. |
| * @param ioaddr Starting address of the I/O range. |
| * @param size Size of the range. |
| * |
| * @return 0 on success, EPERM if the caller lacks the |
| * CAP_IO_MANAGER capability, ENOENT if there is no task |
| * with specified ID and ENOMEM if there was some problem |
| * in allocating memory. |
| */ |
| int iospace_enable(task_id_t id, void *ioaddr, unsigned long size) |
| { |
| ddi_ioarg_t arg; |
| arg.task_id = id; |
| arg.ioaddr = ioaddr; |
| arg.size = size; |
| return __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg); |
| } |
| /** Interrupt control |
| * |
| * @param enable 1 - enable interrupts, 0 - disable interrupts |
| */ |
| int preemption_control(int enable) |
| { |
| return __SYSCALL1(SYS_PREEMPT_CONTROL, (sysarg_t) enable); |
| } |
| /** Enable PIO for specified I/O range. |
| * |
| * @param pio_addr I/O start address. |
| * @param size Size of the I/O region. |
| * @param use_addr Address where the final address for application's PIO |
| * will be stored. |
| * |
| * @return Zero on success or negative error code. |
| */ |
| int pio_enable(void *pio_addr, size_t size, void **use_addr) |
| { |
| void *phys; |
| void *virt; |
| size_t offset; |
| unsigned int pages; |
| #ifdef IO_SPACE_BOUNDARY |
| if (pio_addr < IO_SPACE_BOUNDARY) { |
| *use_addr = pio_addr; |
| return iospace_enable(task_get_id(), pio_addr, size); |
| } |
| #endif |
| phys = (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE); |
| offset = pio_addr - phys; |
| pages = ALIGN_UP(offset + size, PAGE_SIZE) >> PAGE_WIDTH; |
| virt = as_get_mappable_page(pages << PAGE_WIDTH); |
| *use_addr = virt + offset; |
| return physmem_map(phys, virt, pages, AS_AREA_READ | AS_AREA_WRITE); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/thread.c |
|---|
| 0,0 → 1,174 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <thread.h> |
| #include <libc.h> |
| #include <stdlib.h> |
| #include <libarch/faddr.h> |
| #include <kernel/proc/uarg.h> |
| #include <fibril.h> |
| #include <string.h> |
| #include <async.h> |
| #ifndef THREAD_INITIAL_STACK_PAGES_NO |
| #define THREAD_INITIAL_STACK_PAGES_NO 1 |
| #endif |
| /** Main thread function. |
| * |
| * This function is called from __thread_entry() and is used |
| * to call the thread's implementing function and perform cleanup |
| * and exit when thread returns back. Do not call this function |
| * directly. |
| * |
| * @param uarg Pointer to userspace argument structure. |
| */ |
| void __thread_main(uspace_arg_t *uarg) |
| { |
| fibril_t *f; |
| f = fibril_setup(); |
| __tcb_set(f->tcb); |
| uarg->uspace_thread_function(uarg->uspace_thread_arg); |
| /* XXX: we cannot free the userspace stack while running on it */ |
| // free(uarg->uspace_stack); |
| // free(uarg); |
| /* If there is a manager, destroy it */ |
| async_destroy_manager(); |
| fibril_teardown(f); |
| thread_exit(0); |
| } |
| /** Create userspace thread. |
| * |
| * This function creates new userspace thread and allocates userspace |
| * stack and userspace argument structure for it. |
| * |
| * @param function Function implementing the thread. |
| * @param arg Argument to be passed to thread. |
| * @param name Symbolic name of the thread. |
| * @param tid Thread ID of the newly created thread. |
| * |
| * @return Zero on success or a code from @ref errno.h on failure. |
| */ |
| int thread_create(void (* function)(void *), void *arg, char *name, |
| thread_id_t *tid) |
| { |
| char *stack; |
| uspace_arg_t *uarg; |
| int rc; |
| stack = (char *) malloc(getpagesize() * THREAD_INITIAL_STACK_PAGES_NO); |
| if (!stack) |
| return -1; |
| uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t)); |
| if (!uarg) { |
| free(stack); |
| return -1; |
| } |
| uarg->uspace_entry = (void *) FADDR(__thread_entry); |
| uarg->uspace_stack = (void *) stack; |
| uarg->uspace_thread_function = function; |
| uarg->uspace_thread_arg = arg; |
| uarg->uspace_uarg = uarg; |
| rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name, |
| (sysarg_t) str_size(name), (sysarg_t) tid); |
| if (rc) { |
| /* |
| * Failed to create a new thread. |
| * Free up the allocated structures. |
| */ |
| free(uarg); |
| free(stack); |
| } |
| return rc; |
| } |
| /** Terminate current thread. |
| * |
| * @param status Exit status. Currently not used. |
| */ |
| void thread_exit(int status) |
| { |
| __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status); |
| for (;;) |
| ; |
| } |
| /** Detach thread. |
| * |
| * Currently not implemented. |
| * |
| * @param thread TID. |
| */ |
| void thread_detach(thread_id_t thread) |
| { |
| } |
| /** Join thread. |
| * |
| * Currently not implemented. |
| * |
| * @param thread TID. |
| * |
| * @return Thread exit status. |
| */ |
| int thread_join(thread_id_t thread) |
| { |
| return 0; |
| } |
| /** Get current thread ID. |
| * |
| * @return Current thread ID. |
| */ |
| thread_id_t thread_get_id(void) |
| { |
| thread_id_t thread_id; |
| (void) __SYSCALL1(SYS_THREAD_GET_ID, (sysarg_t) &thread_id); |
| return thread_id; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/sysinfo.c |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| #include <sysinfo.h> |
| #include <string.h> |
| sysarg_t sysinfo_value(char *name) |
| { |
| return __SYSCALL2(SYS_SYSINFO_VALUE, (sysarg_t ) name, |
| (sysarg_t) str_size(name)); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/event.c |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| * @} |
| */ |
| /** @addtogroup libc |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| #include <event.h> |
| #include <kernel/ipc/event_types.h> |
| #include <ipc/ipc.h> |
| /** Subscribe for event notifications. |
| * |
| * @param evno Event number. |
| * @param method Use this method for notifying me. |
| * |
| * @return Value returned by the kernel. |
| */ |
| int event_subscribe(event_type_t e, ipcarg_t method) |
| { |
| return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) e, (sysarg_t) method); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/time.c |
|---|
| 0,0 → 1,219 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <sys/time.h> |
| #include <unistd.h> |
| #include <ipc/ipc.h> |
| #include <stdio.h> |
| #include <arch/barrier.h> |
| #include <unistd.h> |
| #include <atomic.h> |
| #include <futex.h> |
| #include <sysinfo.h> |
| #include <ipc/services.h> |
| #include <sysinfo.h> |
| #include <as.h> |
| #include <ddi.h> |
| #include <time.h> |
| /* Pointers to public variables with time */ |
| struct { |
| volatile sysarg_t seconds1; |
| volatile sysarg_t useconds; |
| volatile sysarg_t seconds2; |
| } *ktime = NULL; |
| /** Add microseconds to given timeval. |
| * |
| * @param tv Destination timeval. |
| * @param usecs Number of microseconds to add. |
| */ |
| void tv_add(struct timeval *tv, suseconds_t usecs) |
| { |
| tv->tv_sec += usecs / 1000000; |
| tv->tv_usec += usecs % 1000000; |
| if (tv->tv_usec > 1000000) { |
| tv->tv_sec++; |
| tv->tv_usec -= 1000000; |
| } |
| } |
| /** Subtract two timevals. |
| * |
| * @param tv1 First timeval. |
| * @param tv2 Second timeval. |
| * |
| * @return Return difference between tv1 and tv2 (tv1 - tv2) in |
| * microseconds. |
| */ |
| suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2) |
| { |
| suseconds_t result; |
| result = tv1->tv_usec - tv2->tv_usec; |
| result += (tv1->tv_sec - tv2->tv_sec) * 1000000; |
| return result; |
| } |
| /** Decide if one timeval is greater than the other. |
| * |
| * @param t1 First timeval. |
| * @param t2 Second timeval. |
| * |
| * @return Return true tv1 is greater than tv2. Otherwise return |
| * false. |
| */ |
| int tv_gt(struct timeval *tv1, struct timeval *tv2) |
| { |
| if (tv1->tv_sec > tv2->tv_sec) |
| return 1; |
| if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec > tv2->tv_usec) |
| return 1; |
| return 0; |
| } |
| /** Decide if one timeval is greater than or equal to the other. |
| * |
| * @param tv1 First timeval. |
| * @param tv2 Second timeval. |
| * |
| * @return Return true if tv1 is greater than or equal to tv2. |
| * Otherwise return false. |
| */ |
| int tv_gteq(struct timeval *tv1, struct timeval *tv2) |
| { |
| if (tv1->tv_sec > tv2->tv_sec) |
| return 1; |
| if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec >= tv2->tv_usec) |
| return 1; |
| return 0; |
| } |
| /** POSIX gettimeofday |
| * |
| * The time variables are memory mapped(RO) from kernel, which updates |
| * them periodically. As it is impossible to read 2 values atomically, we |
| * use a trick: First read a seconds, then read microseconds, then |
| * read seconds again. If a second elapsed in the meantime, set it to zero. |
| * This provides assurance, that at least the |
| * sequence of subsequent gettimeofday calls is ordered. |
| */ |
| int gettimeofday(struct timeval *tv, struct timezone *tz) |
| { |
| void *mapping; |
| sysarg_t s1, s2; |
| int rights; |
| int res; |
| if (!ktime) { |
| mapping = as_get_mappable_page(PAGE_SIZE); |
| /* Get the mapping of kernel clock */ |
| res = ipc_share_in_start_1_1(PHONE_NS, mapping, PAGE_SIZE, |
| SERVICE_MEM_REALTIME, &rights); |
| if (res) { |
| printf("Failed to initialize timeofday memarea\n"); |
| _exit(1); |
| } |
| if (!(rights & AS_AREA_READ)) { |
| printf("Received bad rights on time area: %X\n", |
| rights); |
| as_area_destroy(mapping); |
| _exit(1); |
| } |
| ktime = mapping; |
| } |
| if (tz) { |
| tz->tz_minuteswest = 0; |
| tz->tz_dsttime = DST_NONE; |
| } |
| s2 = ktime->seconds2; |
| read_barrier(); |
| tv->tv_usec = ktime->useconds; |
| read_barrier(); |
| s1 = ktime->seconds1; |
| if (s1 != s2) { |
| tv->tv_usec = 0; |
| tv->tv_sec = s1 > s2 ? s1 : s2; |
| } else |
| tv->tv_sec = s1; |
| return 0; |
| } |
| time_t time(time_t *tloc) |
| { |
| struct timeval tv; |
| if (gettimeofday(&tv, NULL)) |
| return (time_t) -1; |
| if (tloc) |
| *tloc = tv.tv_sec; |
| return tv.tv_sec; |
| } |
| /** Wait unconditionally for specified number of microseconds */ |
| int usleep(unsigned long usec) |
| { |
| atomic_t futex = FUTEX_INITIALIZER; |
| futex_initialize(&futex, 0); |
| futex_down_timeout(&futex, usec, 0); |
| return 0; |
| } |
| /** Wait unconditionally for specified number of seconds */ |
| unsigned int sleep(unsigned int seconds) |
| { |
| atomic_t futex = FUTEX_INITIALIZER; |
| futex_initialize(&futex, 0); |
| /* Sleep in 1000 second steps to support |
| full argument range */ |
| while (seconds > 0) { |
| unsigned int period = (seconds > 1000) ? 1000 : seconds; |
| futex_down_timeout(&futex, period * 1000000, 0); |
| seconds -= period; |
| } |
| return 0; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/tls.c |
|---|
| 0,0 → 1,141 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| * |
| * Support for thread-local storage, as described in: |
| * Drepper U.: ELF Handling For Thread-Local Storage, 2005 |
| * |
| * Only static model is supported. |
| */ |
| #include <tls.h> |
| #include <malloc.h> |
| #include <string.h> |
| #include <align.h> |
| /** Create TLS (Thread Local Storage) data structures. |
| * |
| * The code requires, that sections .tdata and .tbss are adjacent. It may be |
| * changed in the future. |
| * |
| * @return Pointer to TCB. |
| */ |
| tcb_t *__make_tls(void) |
| { |
| void *data; |
| tcb_t *tcb; |
| size_t tls_size = &_tbss_end - &_tdata_start; |
| tcb = __alloc_tls(&data, tls_size); |
| /* |
| * Copy thread local data from the initialization image. |
| */ |
| memcpy(data, &_tdata_start, &_tdata_end - &_tdata_start); |
| /* |
| * Zero out the thread local uninitialized data. |
| */ |
| memset(data + (&_tbss_start - &_tdata_start), 0, |
| &_tbss_end - &_tbss_start); |
| return tcb; |
| } |
| void __free_tls(tcb_t *tcb) |
| { |
| size_t tls_size = &_tbss_end - &_tdata_start; |
| __free_tls_arch(tcb, tls_size); |
| } |
| #ifdef CONFIG_TLS_VARIANT_1 |
| /** Allocate TLS variant 1 data structures. |
| * |
| * @param data Start of TLS section. This is an output argument. |
| * @param size Size of tdata + tbss section. |
| * @return Pointer to tcb_t structure. |
| */ |
| tcb_t *tls_alloc_variant_1(void **data, size_t size) |
| { |
| tcb_t *result; |
| result = malloc(sizeof(tcb_t) + size); |
| *data = ((void *)result) + sizeof(tcb_t); |
| return result; |
| } |
| /** Free TLS variant I data structures. |
| * |
| * @param tcb Pointer to TCB structure. |
| * @param size This argument is ignored. |
| */ |
| void tls_free_variant_1(tcb_t *tcb, size_t size) |
| { |
| free(tcb); |
| } |
| #endif |
| #ifdef CONFIG_TLS_VARIANT_2 |
| /** Allocate TLS variant II data structures. |
| * |
| * @param data Pointer to pointer to thread local data. This is |
| * actually an output argument. |
| * @param size Size of thread local data. |
| * @return Pointer to TCB structure. |
| */ |
| tcb_t * tls_alloc_variant_2(void **data, size_t size) |
| { |
| tcb_t *tcb; |
| size = ALIGN_UP(size, &_tls_alignment); |
| *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size); |
| tcb = (tcb_t *) (*data + size); |
| tcb->self = tcb; |
| return tcb; |
| } |
| /** Free TLS variant II data structures. |
| * |
| * @param tcb Pointer to TCB structure. |
| * @param size Size of thread local data. |
| */ |
| void tls_free_variant_2(tcb_t *tcb, size_t size) |
| { |
| size = ALIGN_UP(size, &_tls_alignment); |
| void *start = ((void *) tcb) - size; |
| free(start); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/smc.c |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| #include <sys/types.h> |
| #include <smc.h> |
| int smc_coherence(void *address, size_t size) |
| { |
| return __SYSCALL2(SYS_SMC_COHERENCE, (sysarg_t) address, |
| (sysarg_t) size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/udebug.c |
|---|
| 0,0 → 1,103 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <udebug.h> |
| #include <sys/types.h> |
| #include <ipc/ipc.h> |
| #include <async.h> |
| int udebug_begin(int phoneid) |
| { |
| return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_BEGIN); |
| } |
| int udebug_end(int phoneid) |
| { |
| return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_END); |
| } |
| int udebug_set_evmask(int phoneid, udebug_evmask_t mask) |
| { |
| return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_SET_EVMASK, |
| mask); |
| } |
| int udebug_thread_read(int phoneid, void *buffer, size_t n, |
| size_t *copied, size_t *needed) |
| { |
| ipcarg_t a_copied, a_needed; |
| int rc; |
| rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_THREAD_READ, |
| (sysarg_t)buffer, n, NULL, &a_copied, &a_needed); |
| *copied = (size_t)a_copied; |
| *needed = (size_t)a_needed; |
| return rc; |
| } |
| int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n) |
| { |
| return async_req_4_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_MEM_READ, |
| (sysarg_t)buffer, addr, n); |
| } |
| int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer) |
| { |
| return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_ARGS_READ, |
| tid, (sysarg_t)buffer); |
| } |
| int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type, |
| sysarg_t *val0, sysarg_t *val1) |
| { |
| ipcarg_t a_ev_type; |
| int rc; |
| rc = async_req_2_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_GO, |
| tid, &a_ev_type, val0, val1); |
| *ev_type = a_ev_type; |
| return rc; |
| } |
| int udebug_stop(int phoneid, thash_t tid) |
| { |
| return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_STOP, |
| tid); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/pcb.c |
|---|
| 0,0 → 1,40 |
| /* |
| * Copyright (c) 2008 Jiri Svoboda |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <loader/pcb.h> |
| pcb_t *__pcb; |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/futex.c |
|---|
| 0,0 → 1,192 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <futex.h> |
| #include <atomic.h> |
| #include <libc.h> |
| #include <stdio.h> |
| #include <sys/types.h> |
| #include <kernel/synch/synch.h> |
| /* |
| * Note about race conditions. |
| * Because of non-atomic nature of operations performed sequentially on the |
| * futex counter and the futex wait queue, there is a race condition: |
| * |
| * (wq->missed_wakeups == 1) && (futex->count = 1) |
| * |
| * Scenario 1 (wait queue timeout vs. futex_up()): |
| * 1. assume wq->missed_wakeups == 0 && futex->count == -1 |
| * (ie. thread A sleeping, thread B in the critical section) |
| * 2. A receives timeout and gets removed from the wait queue |
| * 3. B wants to leave the critical section and calls futex_up() |
| * 4. B thus changes futex->count from -1 to 0 |
| * 5. B has to call SYS_FUTEX_WAKEUP syscall to wake up the sleeping thread |
| * 6. B finds the wait queue empty and changes wq->missed_wakeups from 0 to 1 |
| * 7. A fixes futex->count (i.e. the number of waiting threads) by changing it |
| * from 0 to 1 |
| * |
| * Scenario 2 (conditional down operation vs. futex_up) |
| * 1. assume wq->missed_wakeups == 0 && futex->count == 0 |
| * (i.e. thread A is in the critical section) |
| * 2. thread B performs futex_trydown() operation and changes futex->count from |
| * 0 to -1 |
| * B is now obliged to call SYS_FUTEX_SLEEP syscall |
| * 3. A wants to leave the critical section and does futex_up() |
| * 4. A thus changes futex->count from -1 to 0 and must call SYS_FUTEX_WAKEUP |
| * syscall |
| * 5. B finds the wait queue empty and immediatelly aborts the conditional sleep |
| * 6. No thread is queueing in the wait queue so wq->missed_wakeups changes from |
| * 0 to 1 |
| * 6. B fixes futex->count (i.e. the number of waiting threads) by changing it |
| * from 0 to 1 |
| * |
| * Both scenarios allow two threads to be in the critical section |
| * simultaneously. One without kernel intervention and the other through |
| * wq->missed_wakeups being 1. |
| * |
| * To mitigate this problem, futex_down_timeout() detects that the syscall |
| * didn't sleep in the wait queue, fixes the futex counter and RETRIES the |
| * whole operation again. |
| */ |
| /** Initialize futex counter. |
| * |
| * @param futex Futex. |
| * @param val Initialization value. |
| */ |
| void futex_initialize(futex_t *futex, int val) |
| { |
| atomic_set(futex, val); |
| } |
| int futex_down(futex_t *futex) |
| { |
| return futex_down_timeout(futex, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE); |
| } |
| int futex_trydown(futex_t *futex) |
| { |
| return futex_down_timeout(futex, SYNCH_NO_TIMEOUT, |
| SYNCH_FLAGS_NON_BLOCKING); |
| } |
| /** Try to down the futex. |
| * |
| * @param futex Futex. |
| * @param usec Microseconds to wait. Zero value means sleep without |
| * timeout. |
| * @param flags Select mode of operation. See comment for |
| * waitq_sleep_timeout(). |
| * |
| * @return ENOENT if there is no such virtual address. One of |
| * ESYNCH_OK_ATOMIC and ESYNCH_OK_BLOCKED on success or |
| * ESYNCH_TIMEOUT if the lock was not acquired because of |
| * a timeout or ESYNCH_WOULD_BLOCK if the operation could |
| * not be carried out atomically (if requested so). |
| */ |
| int futex_down_timeout(futex_t *futex, uint32_t usec, int flags) |
| { |
| int rc; |
| while (atomic_predec(futex) < 0) { |
| rc = __SYSCALL3(SYS_FUTEX_SLEEP, (sysarg_t) &futex->count, |
| (sysarg_t) usec, (sysarg_t) flags); |
| switch (rc) { |
| case ESYNCH_OK_ATOMIC: |
| /* |
| * Because of a race condition between timeout and |
| * futex_up() and between conditional |
| * futex_down_timeout() and futex_up(), we have to give |
| * up and try again in this special case. |
| */ |
| atomic_inc(futex); |
| break; |
| case ESYNCH_TIMEOUT: |
| atomic_inc(futex); |
| return ESYNCH_TIMEOUT; |
| break; |
| case ESYNCH_WOULD_BLOCK: |
| /* |
| * The conditional down operation should be implemented |
| * this way. The userspace-only variant tends to |
| * accumulate missed wakeups in the kernel futex wait |
| * queue. |
| */ |
| atomic_inc(futex); |
| return ESYNCH_WOULD_BLOCK; |
| break; |
| case ESYNCH_OK_BLOCKED: |
| /* |
| * Enter the critical section. |
| * The futex counter has already been incremented for |
| * us. |
| */ |
| return ESYNCH_OK_BLOCKED; |
| break; |
| default: |
| return rc; |
| } |
| } |
| /* |
| * Enter the critical section. |
| */ |
| return ESYNCH_OK_ATOMIC; |
| } |
| /** Up the futex. |
| * |
| * @param futex Futex. |
| * |
| * @return ENOENT if there is no such virtual address. Otherwise |
| * zero. |
| */ |
| int futex_up(futex_t *futex) |
| { |
| long val; |
| val = atomic_postinc(futex); |
| if (val < 0) |
| return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->count); |
| return 0; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/cap.c |
|---|
| 0,0 → 1,75 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file cap.c |
| * @brief Functions to grant/revoke capabilities to/from a task. |
| */ |
| #include <cap.h> |
| #include <task.h> |
| #include <libc.h> |
| #include <kernel/syscall/sysarg64.h> |
| /** Grant capabilities to a task. |
| * |
| * @param id Destination task ID. |
| * @param caps Capabilities to grant. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int cap_grant(task_id_t id, unsigned int caps) |
| { |
| sysarg64_t arg; |
| arg.value = (unsigned long long) id; |
| return __SYSCALL2(SYS_CAP_GRANT, (sysarg_t) &arg, (sysarg_t) caps); |
| } |
| /** Revoke capabilities from a task. |
| * |
| * @param id Destination task ID. |
| * @param caps Capabilities to revoke. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int cap_revoke(task_id_t id, unsigned int caps) |
| { |
| sysarg64_t arg; |
| arg.value = (unsigned long long) id; |
| return __SYSCALL2(SYS_CAP_REVOKE, (sysarg_t) &arg, (sysarg_t) caps); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/stdlib.c |
|---|
| 0,0 → 1,50 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdlib.h> |
| static long glbl_seed = 1; |
| long int random(void) |
| { |
| return glbl_seed = ((1366*glbl_seed + 150889) % RAND_MAX); |
| } |
| void srandom(unsigned int seed) |
| { |
| glbl_seed = seed; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/generic/err.c |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| /* TODO |
| void errx(int __status, __const char *__format, ...) |
| { |
| _exit(0); |
| } |
| */ |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/stack.h |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_STACK_H_ |
| #define LIBC_sparc64_STACK_H_ |
| #define STACK_ITEM_SIZE 8 |
| /** According to SPARC Compliance Definition, every stack frame is 16-byte aligned. */ |
| #define STACK_ALIGNMENT 16 |
| /** |
| * 16-extended-word save area for %i[0-7] and %l[0-7] registers. |
| */ |
| #define STACK_WINDOW_SAVE_AREA_SIZE (16 * STACK_ITEM_SIZE) |
| /* |
| * Six extended words for first six arguments. |
| */ |
| #define STACK_ARG_SAVE_AREA_SIZE (6 * STACK_ITEM_SIZE) |
| /** |
| * By convention, the actual top of the stack is %sp + STACK_BIAS. |
| */ |
| #define STACK_BIAS 2047 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/fibril.h |
|---|
| 0,0 → 1,84 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_FIBRIL_H_ |
| #define LIBC_sparc64_FIBRIL_H_ |
| #include <libarch/stack.h> |
| #include <sys/types.h> |
| #include <align.h> |
| #define SP_DELTA (STACK_WINDOW_SAVE_AREA_SIZE + STACK_ARG_SAVE_AREA_SIZE) |
| #ifdef context_set |
| #undef context_set |
| #endif |
| #define context_set(c, _pc, stack, size, ptls) \ |
| (c)->pc = ((uintptr_t) _pc) - 8; \ |
| (c)->sp = ((uintptr_t) stack) + ALIGN_UP((size), \ |
| STACK_ALIGNMENT) - (STACK_BIAS + SP_DELTA); \ |
| (c)->fp = -STACK_BIAS; \ |
| (c)->tp = ptls |
| /* |
| * Save only registers that must be preserved across |
| * function calls. |
| */ |
| typedef struct { |
| uintptr_t sp; /* %o6 */ |
| uintptr_t pc; /* %o7 */ |
| uint64_t i0; |
| uint64_t i1; |
| uint64_t i2; |
| uint64_t i3; |
| uint64_t i4; |
| uint64_t i5; |
| uintptr_t fp; /* %i6 */ |
| uintptr_t i7; |
| uint64_t l0; |
| uint64_t l1; |
| uint64_t l2; |
| uint64_t l3; |
| uint64_t l4; |
| uint64_t l5; |
| uint64_t l6; |
| uint64_t l7; |
| uint64_t tp; /* %g7 */ |
| } context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/types.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_TYPES_H_ |
| #define LIBC_sparc64_TYPES_H_ |
| typedef unsigned long sysarg_t; |
| typedef signed char int8_t; |
| typedef short int int16_t; |
| typedef int int32_t; |
| typedef long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long int uint64_t; |
| typedef int64_t ssize_t; |
| typedef uint64_t size_t; |
| typedef uint64_t uintptr_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/ddi.h |
|---|
| 0,0 → 1,92 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @file |
| * @ingroup libsparc64 |
| */ |
| #ifndef LIBC_sparc64_DDI_H_ |
| #define LIBC_sparc64_DDI_H_ |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| static inline memory_barrier(void) |
| { |
| asm volatile ("membar #LoadLoad | #StoreStore\n" ::: "memory"); |
| } |
| static inline void pio_write_8(ioport8_t *port, uint8_t v) |
| { |
| *port = v; |
| memory_barrier(); |
| } |
| static inline void pio_write_16(ioport16_t *port, uint16_t v) |
| { |
| *port = v; |
| memory_barrier(); |
| } |
| static inline void pio_write_32(ioport32_t *port, uint32_t v) |
| { |
| *port = v; |
| memory_barrier(); |
| } |
| static inline uint8_t pio_read_8(ioport8_t *port) |
| { |
| uint8_t rv; |
| rv = *port; |
| memory_barrier(); |
| return rv; |
| } |
| static inline uint16_t pio_read_16(ioport16_t *port) |
| { |
| uint16_t rv; |
| rv = *port; |
| memory_barrier(); |
| return rv; |
| } |
| static inline uint32_t pio_read_32(ioport32_t *port) |
| { |
| uint32_t rv; |
| rv = *port; |
| memory_barrier(); |
| return rv; |
| } |
| #endif |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/syscall.h |
|---|
| 0,0 → 1,74 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_SYSCALL_H_ |
| #define LIBC_sparc64_SYSCALL_H_ |
| #include <sys/types.h> |
| #include <kernel/syscall/syscall.h> |
| #define __syscall0 __syscall |
| #define __syscall1 __syscall |
| #define __syscall2 __syscall |
| #define __syscall3 __syscall |
| #define __syscall4 __syscall |
| #define __syscall5 __syscall |
| #define __syscall6 __syscall |
| static inline sysarg_t |
| __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3, |
| const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id) |
| { |
| register uint64_t a1 asm("o0") = p1; |
| register uint64_t a2 asm("o1") = p2; |
| register uint64_t a3 asm("o2") = p3; |
| register uint64_t a4 asm("o3") = p4; |
| register uint64_t a5 asm("o4") = p5; |
| register uint64_t a6 asm("o5") = p6; |
| asm volatile ( |
| "ta %7\n" |
| : "=r" (a1) |
| : "r" (a1), "r" (a2), "r" (a3), "r" (a4), "r" (a5), "r" (a6), |
| "i" (id) |
| : "memory" |
| ); |
| return a1; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/config.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_CONFIG_H_ |
| #define LIBC_sparc64_CONFIG_H_ |
| #define PAGE_WIDTH 14 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/tls.h |
|---|
| 0,0 → 1,65 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** |
| * @file |
| * @brief sparc64 TLS functions. |
| */ |
| #ifndef LIBC_sparc64_TLS_H_ |
| #define LIBC_sparc64_TLS_H_ |
| #define CONFIG_TLS_VARIANT_2 |
| typedef struct { |
| void *self; |
| void *fibril_data; |
| } tcb_t; |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| asm volatile ("mov %0, %%g7\n" : : "r" (tcb) : "g7"); |
| } |
| static inline tcb_t * __tcb_get(void) |
| { |
| void *retval; |
| asm volatile ("mov %%g7, %0\n" : "=r" (retval)); |
| return retval; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/thread.h |
|---|
| 0,0 → 1,40 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| #ifndef LIBC_sparc64_THREAD_H_ |
| #define LIBC_sparc64_THREAD_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/atomic.h |
|---|
| 0,0 → 1,97 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_ATOMIC_H_ |
| #define LIBC_sparc64_ATOMIC_H_ |
| #include <sys/types.h> |
| /** Atomic add operation. |
| * |
| * Use atomic compare and swap operation to atomically add signed value. |
| * |
| * @param val Atomic variable. |
| * @param i Signed value to be added. |
| * |
| * @return Value of the atomic variable as it existed before addition. |
| */ |
| static inline long atomic_add(atomic_t *val, int i) |
| { |
| uint64_t a, b; |
| do { |
| volatile uintptr_t x = (uint64_t) &val->count; |
| a = *((uint64_t *) x); |
| b = a + i; |
| asm volatile ("casx %0, %2, %1\n" : "+m" (*((uint64_t *)x)), "+r" (b) : "r" (a)); |
| } while (a != b); |
| return a; |
| } |
| static inline long atomic_preinc(atomic_t *val) |
| { |
| return atomic_add(val, 1) + 1; |
| } |
| static inline long atomic_postinc(atomic_t *val) |
| { |
| return atomic_add(val, 1); |
| } |
| static inline long atomic_predec(atomic_t *val) |
| { |
| return atomic_add(val, -1) - 1; |
| } |
| static inline long atomic_postdec(atomic_t *val) |
| { |
| return atomic_add(val, -1); |
| } |
| static inline void atomic_inc(atomic_t *val) |
| { |
| (void) atomic_add(val, 1); |
| } |
| static inline void atomic_dec(atomic_t *val) |
| { |
| (void) atomic_add(val, -1); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/stackarg.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_STACKARG_H_ |
| #define LIBC_sparc64_STACKARG_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/faddr.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_FADDR_H_ |
| #define LIBC_sparc64_FADDR_H_ |
| #include <libarch/types.h> |
| #define FADDR(fptr) ((uintptr_t) (fptr)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/include/limits.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_sparc64_LIMITS_H_ |
| #define LIBC_sparc64_LIMITS_H_ |
| #define LONG_MIN MIN_INT64 |
| #define LONG_MAX MAX_INT64 |
| #define ULONG_MIN MIN_UINT64 |
| #define ULONG_MAX MAX_UINT64 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/Makefile.inc |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = sparc64-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/sparc64/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c |
| CFLAGS += -mcpu=ultrasparc -m64 |
| LFLAGS += -no-check-sections -N |
| ENDIANESS = BE |
| BFD_NAME = elf64-sparc |
| BFD_ARCH = sparc |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/_link.ld.in |
|---|
| 0,0 → 1,52 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x4000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } :text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x4000; |
| .got : { |
| _gp = .; |
| *(.got*); |
| } :data |
| .data : { |
| *(.data); |
| *(.sdata); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .bss : { |
| *(.sbss); |
| *(COMMON); |
| *(.bss); |
| } :data |
| . = ALIGN(0x4000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/src/entry.s |
|---|
| 0,0 → 1,48 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .section .init, "ax" |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # %o0 contains uarg |
| # %o1 contains pcb_ptr |
| # |
| __entry: |
| # Pass pcb_ptr as the first argument to __main() |
| mov %o1, %o0 |
| sethi %hi(_gp), %l7 |
| call __main |
| or %l7, %lo(_gp), %l7 |
| call __exit |
| nop |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/src/fibril.S |
|---|
| 0,0 → 1,53 |
| # |
| # Copyright (c) 2005 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| #include <kernel/arch/context_offset.h> |
| .text |
| .global context_save |
| .global context_restore |
| context_save: |
| CONTEXT_SAVE_ARCH_CORE %o0 |
| retl |
| mov 1, %o0 ! context_save_arch returns 1 |
| context_restore: |
| # |
| # Flush all active windows. |
| # This is essential, because CONTEXT_LOAD overwrites |
| # %sp of CWP - 1 with the value written to %fp of CWP. |
| # Flushing all active windows mitigates this problem |
| # as CWP - 1 becomes the overlap window. |
| # |
| flushw |
| CONTEXT_RESTORE_ARCH_CORE %o0 |
| retl |
| xor %o0, %o0, %o0 ! context_restore_arch returns 0 |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/src/tls.c |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcsparc64 sparc64 |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| * |
| */ |
| #include <tls.h> |
| #include <sys/types.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_2(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_2(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/sparc64/src/thread_entry.s |
|---|
| 0,0 → 1,43 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .globl __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| __thread_entry: |
| sethi %hi(_gp), %l7 |
| call __thread_main ! %o0 contains address of uarg |
| or %l7, %lo(_gp), %l7 |
| ! not reached |
| .end __thread_entry |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/Makefile.inc |
|---|
| 0,0 → 1,46 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = ia64-pc-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/ia64/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c \ |
| arch/$(UARCH)/src/ddi.c |
| CFLAGS += -fno-unwind-tables |
| LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a |
| ENDIANESS = LE |
| BFD_NAME = elf64-ia64-little |
| BFD_ARCH = ia64-elf64 |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/types.h |
|---|
| 0,0 → 1,68 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_TYPES_H_ |
| #define LIBC_ia64_TYPES_H_ |
| typedef unsigned long long sysarg_t; |
| typedef char int8_t; |
| typedef short int int16_t; |
| typedef int int32_t; |
| typedef long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long int uint64_t; |
| typedef int64_t ssize_t; |
| typedef uint64_t size_t; |
| typedef uint64_t uintptr_t; |
| typedef unsigned char __r8; /* Reserve byte */ |
| typedef unsigned short __r16; |
| typedef unsigned int __r32; |
| typedef unsigned long __r64; |
| typedef struct __r128{ |
| __r64 lo; |
| __r64 hi; |
| } __r128; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/ddi.h |
|---|
| 0,0 → 1,115 |
| /* |
| * Copyright (c) 2005 Jakub Vana |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_DDI_H_ |
| #define LIBC_ia64_DDI_H_ |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| #define IO_SPACE_BOUNDARY (64 * 1024) |
| uint64_t get_ia64_iospace_address(void); |
| extern uint64_t ia64_iospace_address; |
| #define IA64_IOSPACE_ADDRESS \ |
| (ia64_iospace_address ? \ |
| ia64_iospace_address : \ |
| (ia64_iospace_address = get_ia64_iospace_address())) |
| static inline void pio_write_8(ioport8_t *port, uint8_t v) |
| { |
| uintptr_t prt = (uintptr_t) port; |
| *((ioport8_t *)(IA64_IOSPACE_ADDRESS + |
| ((prt & 0xfff) | ((prt >> 2) << 12)))) = v; |
| asm volatile ("mf\n" ::: "memory"); |
| } |
| static inline void pio_write_16(ioport16_t *port, uint16_t v) |
| { |
| uintptr_t prt = (uintptr_t) port; |
| *((ioport16_t *)(IA64_IOSPACE_ADDRESS + |
| ((prt & 0xfff) | ((prt >> 2) << 12)))) = v; |
| asm volatile ("mf\n" ::: "memory"); |
| } |
| static inline void pio_write_32(ioport32_t *port, uint32_t v) |
| { |
| uintptr_t prt = (uintptr_t) port; |
| *((ioport32_t *)(IA64_IOSPACE_ADDRESS + |
| ((prt & 0xfff) | ((prt >> 2) << 12)))) = v; |
| asm volatile ("mf\n" ::: "memory"); |
| } |
| static inline uint8_t pio_read_8(ioport8_t *port) |
| { |
| uintptr_t prt = (uintptr_t) port; |
| asm volatile ("mf\n" ::: "memory"); |
| return *((ioport8_t *)(IA64_IOSPACE_ADDRESS + |
| ((prt & 0xfff) | ((prt >> 2) << 12)))); |
| } |
| static inline uint16_t pio_read_16(ioport16_t *port) |
| { |
| uintptr_t prt = (uintptr_t) port; |
| asm volatile ("mf\n" ::: "memory"); |
| return *((ioport16_t *)(IA64_IOSPACE_ADDRESS + |
| ((prt & 0xfff) | ((prt >> 2) << 12)))); |
| } |
| static inline uint32_t pio_read_32(ioport32_t *port) |
| { |
| uintptr_t prt = (uintptr_t) port; |
| asm volatile ("mf\n" ::: "memory"); |
| return *((ioport32_t *)(IA64_IOSPACE_ADDRESS + |
| ((prt & 0xfff) | ((prt >> 2) << 12)))); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/syscall.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBC_ia64_SYSCALL_H_ |
| #define LIBC_ia64_SYSCALL_H_ |
| #define LIBARCH_SYSCALL_GENERIC |
| #include <syscall.h> |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/config.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_CONFIG_H_ |
| #define LIBC_ia64_CONFIG_H_ |
| #define PAGE_WIDTH 14 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/tls.h |
|---|
| 0,0 → 1,65 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_TLS_H_ |
| #define LIBC_ia64_TLS_H_ |
| #define CONFIG_TLS_VARIANT_1 |
| #include <sys/types.h> |
| /* This structure must be exactly 16 bytes long */ |
| typedef struct { |
| void *dtv; /* unused in static linking*/ |
| void *fibril_data; |
| } tcb_t; |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| asm volatile ("mov r13 = %0\n" : : "r" (tcb) : "r13"); |
| } |
| static inline tcb_t *__tcb_get(void) |
| { |
| void *retval; |
| asm volatile ("mov %0 = r13\n" : "=r" (retval)); |
| return retval; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/thread.h |
|---|
| 0,0 → 1,43 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_THREAD_H_ |
| #define LIBC_ia64_THREAD_H_ |
| #define THREAD_INITIAL_STACK_PAGES_NO 2 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/fibril.h |
|---|
| 0,0 → 1,139 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_FIBRIL_H_ |
| #define LIBC_ia64_FIBRIL_H_ |
| #include <sys/types.h> |
| #include <align.h> |
| #include <libarch/stack.h> |
| #include <libarch/types.h> |
| /* |
| * context_save() and context_restore() are both leaf procedures. |
| * No need to allocate scratch area. |
| */ |
| #define SP_DELTA (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT)) |
| #define PFM_MASK (~0x3fffffffff) |
| #define PSTHREAD_INITIAL_STACK_PAGES_NO 2 |
| /* Stack is divided into two equal parts (for memory stack and register stack). */ |
| #define PSTHREAD_INITIAL_STACK_DIVISION 2 |
| #ifdef context_set |
| #undef context_set |
| #endif |
| #define context_set(c, _pc, stack, size, tls) \ |
| do { \ |
| (c)->pc = (uint64_t) _pc; \ |
| (c)->bsp = ((uint64_t) stack) + size / PSTHREAD_INITIAL_STACK_DIVISION; \ |
| (c)->ar_pfs &= PFM_MASK; \ |
| (c)->sp = ((uint64_t) stack) + ALIGN_UP((size / PSTHREAD_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - SP_DELTA; \ |
| (c)->tp = (uint64_t) tls; \ |
| } while (0); |
| /* |
| * Only save registers that must be preserved across |
| * function calls. |
| */ |
| typedef struct context { |
| /* |
| * Application registers |
| */ |
| uint64_t ar_pfs; |
| uint64_t ar_unat_caller; |
| uint64_t ar_unat_callee; |
| uint64_t ar_rsc; |
| uint64_t bsp; /* ar_bsp */ |
| uint64_t ar_rnat; |
| uint64_t ar_lc; |
| /* |
| * General registers |
| */ |
| uint64_t r1; |
| uint64_t r4; |
| uint64_t r5; |
| uint64_t r6; |
| uint64_t r7; |
| uint64_t sp; /* r12 */ |
| uint64_t tp; /* r13 */ |
| /* |
| * Branch registers |
| */ |
| uint64_t pc; /* b0 */ |
| uint64_t b1; |
| uint64_t b2; |
| uint64_t b3; |
| uint64_t b4; |
| uint64_t b5; |
| /* |
| * Predicate registers |
| */ |
| uint64_t pr; |
| __r128 f2 __attribute__ ((aligned(16))); |
| __r128 f3; |
| __r128 f4; |
| __r128 f5; |
| __r128 f16; |
| __r128 f17; |
| __r128 f18; |
| __r128 f19; |
| __r128 f20; |
| __r128 f21; |
| __r128 f22; |
| __r128 f23; |
| __r128 f24; |
| __r128 f25; |
| __r128 f26; |
| __r128 f27; |
| __r128 f28; |
| __r128 f29; |
| __r128 f30; |
| __r128 f31; |
| } context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/atomic.h |
|---|
| 0,0 → 1,66 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_ATOMIC_H_ |
| #define LIBC_ia64_ATOMIC_H_ |
| /** Atomic addition. |
| * |
| * @param val Atomic value. |
| * @param imm Value to add. |
| * |
| * @return Value before addition. |
| */ |
| static inline long atomic_add(atomic_t *val, int imm) |
| { |
| long v; |
| asm volatile ("fetchadd8.rel %0 = %1, %2\n" : "=r" (v), "+m" (val->count) : "i" (imm)); |
| return v; |
| } |
| static inline void atomic_inc(atomic_t *val) { atomic_add(val, 1); } |
| static inline void atomic_dec(atomic_t *val) { atomic_add(val, -1); } |
| static inline long atomic_preinc(atomic_t *val) { return atomic_add(val, 1) + 1; } |
| static inline long atomic_predec(atomic_t *val) { return atomic_add(val, -1) - 1; } |
| static inline long atomic_postinc(atomic_t *val) { return atomic_add(val, 1); } |
| static inline long atomic_postdec(atomic_t *val) { return atomic_add(val, -1); } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/stackarg.h |
|---|
| 0,0 → 1,43 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STACKARG_H_ |
| #define LIBC_STACKARG_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/faddr.h |
|---|
| 0,0 → 1,53 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_FADDR_H_ |
| #define LIBC_ia64_FADDR_H_ |
| #include <libarch/types.h> |
| /** |
| * |
| * Calculate absolute address of function |
| * referenced by fptr pointer. |
| * |
| * @param f Function pointer. |
| * |
| */ |
| #define FADDR(f) (*((uintptr_t *)(f))); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/limits.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_LIMITS_H_ |
| #define LIBC_ia64_LIMITS_H_ |
| # define LONG_MIN MIN_INT64 |
| # define LONG_MAX MAX_INT64 |
| # define ULONG_MIN MIN_UINT64 |
| # define ULONG_MAX MAX_UINT64 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/include/stack.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia64_STACK_H_ |
| #define LIBC_ia64_STACK_H_ |
| #define STACK_ITEM_SIZE 8 |
| #define STACK_ALIGNMENT 16 |
| #define STACK_SCRATCH_AREA_SIZE 16 |
| #define REGISTER_STACK_ALIGNMENT 8 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/_link.ld.in |
|---|
| 0,0 → 1,53 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x4000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } : text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x4000; |
| .got : { |
| _gp = .; |
| *(.got*); |
| } :data |
| .data : { |
| *(.opd); |
| *(.data .data.*); |
| *(.sdata); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .bss : { |
| *(.sbss); |
| *(.scommon); |
| *(COMMON); |
| *(.bss); |
| } :data |
| . = ALIGN(0x4000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/src/entry.s |
|---|
| 0,0 → 1,47 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .section .init, "ax" |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # r2 contains the PCB pointer |
| # |
| __entry: |
| alloc loc0 = ar.pfs, 0, 1, 2, 0 |
| movl r1 = _gp |
| # Pass PCB pointer as the first argument to __main |
| mov out0 = r2 |
| br.call.sptk.many b0 = __main |
| 0: |
| br.call.sptk.many b0 = __exit |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/src/thread_entry.s |
|---|
| 0,0 → 1,52 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .globl __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| __thread_entry: |
| alloc loc0 = ar.pfs, 0, 1, 1, 0 |
| movl r1 = _gp |
| # |
| # r8 contains address of uarg structure. |
| # |
| mov out0 = r8 |
| br.call.sptk.many b0 = __thread_main |
| # |
| # Not reached. |
| # |
| .end __thread_entry |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/src/ddi.c |
|---|
| 0,0 → 1,13 |
| #include <libarch/ddi.h> |
| #include <sysinfo.h> |
| uint64_t ia64_iospace_address=0; |
| uint64_t get_ia64_iospace_address(void) |
| { |
| return sysinfo_value("ia64_iospace.address.virtual"); |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/src/syscall.S |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| /** |
| * Immediate operand for break instruction. |
| * Be carefull about the value as Ski simulator |
| * is somewhat sensitive to its value. |
| * |
| * 0 will be confused with Ski breakpoint. |
| * And higher values will be confused with SSC's. |
| */ |
| #define SYSCALL_IMM 1 |
| .global __syscall |
| __syscall: |
| alloc r14 = ar.pfs, 7, 0, 0, 0 ;; |
| break SYSCALL_IMM |
| mov ar.pfs = r14 ;; |
| br.ret.sptk.many b0 |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/src/tls.c |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia64 ia64 |
| * @brief ia64 architecture dependent parts of libc |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <tls.h> |
| #include <malloc.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_1(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_1(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia64/src/fibril.S |
|---|
| 0,0 → 1,246 |
| # |
| # Copyright (c) 2005 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global context_save |
| .global context_restore |
| context_save: |
| alloc loc0 = ar.pfs, 1, 8, 0, 0 |
| mov loc1 = ar.unat ;; |
| /* loc2 */ |
| mov loc3 = ar.rsc |
| .auto |
| /* |
| * Flush dirty registers to backing store. |
| * After this ar.bsp and ar.bspstore are equal. |
| */ |
| flushrs |
| mov loc4 = ar.bsp |
| /* |
| * Put RSE to enforced lazy mode. |
| * So that ar.rnat can be read. |
| */ |
| and loc5 = ~3, loc3 |
| mov ar.rsc = loc5 |
| mov loc5 = ar.rnat |
| .explicit |
| mov loc6 = ar.lc |
| /* |
| * Save application registers |
| */ |
| st8 [in0] = loc0, 8 ;; /* save ar.pfs */ |
| st8 [in0] = loc1, 8 ;; /* save ar.unat (caller) */ |
| mov loc2 = in0 ;; |
| add in0 = 8, in0 ;; /* skip ar.unat (callee) */ |
| st8 [in0] = loc3, 8 ;; /* save ar.rsc */ |
| st8 [in0] = loc4, 8 ;; /* save ar.bsp */ |
| st8 [in0] = loc5, 8 ;; /* save ar.rnat */ |
| st8 [in0] = loc6, 8 ;; /* save ar.lc */ |
| /* |
| * Save general registers including NaT bits |
| */ |
| st8.spill [in0] = r1, 8 ;; |
| st8.spill [in0] = r4, 8 ;; |
| st8.spill [in0] = r5, 8 ;; |
| st8.spill [in0] = r6, 8 ;; |
| st8.spill [in0] = r7, 8 ;; |
| st8.spill [in0] = r12, 8 ;; /* save sp */ |
| st8.spill [in0] = r13, 8 ;; /* save tp */ |
| mov loc3 = ar.unat ;; |
| st8 [loc2] = loc3 /* save ar.unat (callee) */ |
| /* |
| * Save branch registers |
| */ |
| mov loc2 = b0 ;; |
| st8 [in0] = loc2, 8 /* save pc */ |
| mov loc3 = b1 ;; |
| st8 [in0] = loc3, 8 |
| mov loc4 = b2 ;; |
| st8 [in0] = loc4, 8 |
| mov loc5 = b3 ;; |
| st8 [in0] = loc5, 8 |
| mov loc6 = b4 ;; |
| st8 [in0] = loc6, 8 |
| mov loc7 = b5 ;; |
| st8 [in0] = loc7, 8 |
| /* |
| * Save predicate registers |
| */ |
| mov loc2 = pr ;; |
| st8 [in0] = loc2, 16;; /* Next fpu registers should be spilled to 16B aligned address */ |
| /* |
| * Save floating-point registers. |
| */ |
| stf.spill [in0] = f2, 16 ;; |
| stf.spill [in0] = f3, 16 ;; |
| stf.spill [in0] = f4, 16 ;; |
| stf.spill [in0] = f5, 16 ;; |
| stf.spill [in0] = f16, 16 ;; |
| stf.spill [in0] = f17, 16 ;; |
| stf.spill [in0] = f18, 16 ;; |
| stf.spill [in0] = f19, 16 ;; |
| stf.spill [in0] = f20, 16 ;; |
| stf.spill [in0] = f21, 16 ;; |
| stf.spill [in0] = f22, 16 ;; |
| stf.spill [in0] = f23, 16 ;; |
| stf.spill [in0] = f24, 16 ;; |
| stf.spill [in0] = f25, 16 ;; |
| stf.spill [in0] = f26, 16 ;; |
| stf.spill [in0] = f27, 16 ;; |
| stf.spill [in0] = f28, 16 ;; |
| stf.spill [in0] = f29, 16 ;; |
| stf.spill [in0] = f30, 16 ;; |
| stf.spill [in0] = f31, 16 ;; |
| mov ar.unat = loc1 |
| add r8 = r0, r0, 1 /* context_save returns 1 */ |
| br.ret.sptk.many b0 |
| context_restore: |
| alloc loc0 = ar.pfs, 1, 9, 0, 0 ;; |
| ld8 loc0 = [in0], 8 ;; /* load ar.pfs */ |
| ld8 loc1 = [in0], 8 ;; /* load ar.unat (caller) */ |
| ld8 loc2 = [in0], 8 ;; /* load ar.unat (callee) */ |
| ld8 loc3 = [in0], 8 ;; /* load ar.rsc */ |
| ld8 loc4 = [in0], 8 ;; /* load ar.bsp */ |
| ld8 loc5 = [in0], 8 ;; /* load ar.rnat */ |
| ld8 loc6 = [in0], 8 ;; /* load ar.lc */ |
| .auto |
| /* |
| * Invalidate the ALAT |
| */ |
| invala |
| /* |
| * Put RSE to enforced lazy mode. |
| * So that ar.bspstore and ar.rnat can be written. |
| */ |
| movl loc8 = ~3 |
| and loc8 = loc3, loc8 |
| mov ar.rsc = loc8 |
| /* |
| * Flush dirty registers to backing store. |
| * We do this because we want the following move |
| * to ar.bspstore to assign the same value to ar.bsp. |
| */ |
| flushrs |
| /* |
| * Restore application registers |
| */ |
| mov ar.bspstore = loc4 /* rse.bspload = ar.bsp = ar.bspstore = loc4 */ |
| mov ar.rnat = loc5 |
| mov ar.pfs = loc0 |
| mov ar.rsc = loc3 |
| .explicit |
| mov ar.unat = loc2 ;; |
| mov ar.lc = loc6 |
| /* |
| * Restore general registers including NaT bits |
| */ |
| ld8.fill r1 = [in0], 8 ;; |
| ld8.fill r4 = [in0], 8 ;; |
| ld8.fill r5 = [in0], 8 ;; |
| ld8.fill r6 = [in0], 8 ;; |
| ld8.fill r7 = [in0], 8 ;; |
| ld8.fill r12 = [in0], 8 ;; /* restore sp */ |
| ld8.fill r13 = [in0], 8 ;; |
| /* |
| * Restore branch registers |
| */ |
| ld8 loc2 = [in0], 8 ;; /* restore pc */ |
| mov b0 = loc2 |
| ld8 loc3 = [in0], 8 ;; |
| mov b1 = loc3 |
| ld8 loc4 = [in0], 8 ;; |
| mov b2 = loc4 |
| ld8 loc5 = [in0], 8 ;; |
| mov b3 = loc5 |
| ld8 loc6 = [in0], 8 ;; |
| mov b4 = loc6 |
| ld8 loc7 = [in0], 8 ;; |
| mov b5 = loc7 |
| /* |
| * Restore predicate registers |
| */ |
| ld8 loc2 = [in0], 16 ;; |
| mov pr = loc2, ~0 |
| /* |
| * Restore floating-point registers. |
| */ |
| ldf.fill f2 = [in0], 16 ;; |
| ldf.fill f3 = [in0], 16 ;; |
| ldf.fill f4 = [in0], 16 ;; |
| ldf.fill f5 = [in0], 16 ;; |
| ldf.fill f16 = [in0], 16 ;; |
| ldf.fill f17 = [in0], 16 ;; |
| ldf.fill f18 = [in0], 16 ;; |
| ldf.fill f19 = [in0], 16 ;; |
| ldf.fill f20 = [in0], 16 ;; |
| ldf.fill f21 = [in0], 16 ;; |
| ldf.fill f22 = [in0], 16 ;; |
| ldf.fill f23 = [in0], 16 ;; |
| ldf.fill f24 = [in0], 16 ;; |
| ldf.fill f25 = [in0], 16 ;; |
| ldf.fill f26 = [in0], 16 ;; |
| ldf.fill f27 = [in0], 16 ;; |
| ldf.fill f28 = [in0], 16 ;; |
| ldf.fill f29 = [in0], 16 ;; |
| ldf.fill f30 = [in0], 16 ;; |
| ldf.fill f31 = [in0], 16 ;; |
| mov ar.unat = loc1 |
| mov r8 = r0 /* context_restore returns 0 */ |
| br.ret.sptk.many b0 |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/tls.h |
|---|
| 0,0 → 1,99 |
| /* |
| * Copyright (c) 2007 Pavel Jancik |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_arm32_TLS_H_ |
| #define LIBC_arm32_TLS_H_ |
| #include <sys/types.h> |
| #define CONFIG_TLS_VARIANT_1 |
| /** Offsets for accessing thread-local variables are shifted 8 bytes higher. */ |
| #define ARM_TP_OFFSET (-8) |
| /** TCB (Thread Control Block) struct. |
| * |
| * TLS starts just after this struct. |
| */ |
| typedef struct { |
| /** Fibril data. */ |
| void *fibril_data; |
| } tcb_t; |
| /** Sets TLS address to the r9 register. |
| * |
| * @param tcb TCB (TLS starts behind) |
| */ |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| void *tls = (void *) tcb; |
| tls += sizeof(tcb_t) + ARM_TP_OFFSET; |
| asm volatile ( |
| "mov r9, %0" |
| : |
| : "r" (tls) |
| ); |
| } |
| /** Returns TCB address. |
| * |
| * @return TCB address (starts before TLS which address is stored |
| * in r9 register). |
| */ |
| static inline tcb_t *__tcb_get(void) |
| { |
| void *ret; |
| asm volatile ( |
| "mov %0, r9" |
| : "=r"(ret) |
| ); |
| return (tcb_t *) (ret - ARM_TP_OFFSET - sizeof(tcb_t)); |
| } |
| /** Returns TLS address stored. |
| * |
| * Implemented in assembly. |
| * |
| * @return TLS address stored in r9 register |
| */ |
| extern uintptr_t __aeabi_read_tp(void); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/types.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Definitions of basic types like #uintptr_t. |
| */ |
| #ifndef LIBC_arm32_TYPES_H_ |
| #define LIBC_arm32_TYPES_H_ |
| typedef unsigned int sysarg_t; |
| typedef char int8_t; |
| typedef short int int16_t; |
| typedef long int int32_t; |
| typedef long long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned long int uint32_t; |
| typedef unsigned long long int uint64_t; |
| typedef int32_t ssize_t; |
| typedef uint32_t size_t; |
| typedef uint32_t uintptr_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/fibril.h |
|---|
| 0,0 → 1,90 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Fibrils related declarations. |
| */ |
| #ifndef LIBC_arm32_FIBRIL_H_ |
| #define LIBC_arm32_FIBRIL_H_ |
| #include <sys/types.h> |
| #include <align.h> |
| #include <thread.h> |
| /** Size of a stack item */ |
| #define STACK_ITEM_SIZE 4 |
| /** Stack alignment - see <a href="http://www.arm.com/support/faqdev/14269.html">ABI</a> for details */ |
| #define STACK_ALIGNMENT 8 |
| #define SP_DELTA (0 + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT)) |
| /** Sets data to the context. |
| * |
| * @param c Context (#context_t). |
| * @param _pc Program counter. |
| * @param stack Stack address. |
| * @param size Stack size. |
| * @param ptls Pointer to the TCB. |
| */ |
| #define context_set(c, _pc, stack, size, ptls) \ |
| (c)->pc = (sysarg_t) (_pc); \ |
| (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \ |
| (c)->tls = ((sysarg_t)(ptls)) + sizeof(tcb_t) + ARM_TP_OFFSET; |
| /** Fibril context. |
| * |
| * Only registers preserved accross function calls are included. r9 is used |
| * to store a TLS address. -ffixed-r9 gcc forces gcc not to use this |
| * register. -mtp=soft forces gcc to use #__aeabi_read_tp to obtain |
| * TLS address. |
| */ |
| typedef struct { |
| uint32_t sp; |
| uint32_t pc; |
| uint32_t r4; |
| uint32_t r5; |
| uint32_t r6; |
| uint32_t r7; |
| uint32_t r8; |
| uint32_t tls; |
| uint32_t r10; |
| uint32_t r11; |
| } context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/ddi.h |
|---|
| 0,0 → 1,69 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @file |
| * @ingroup libcarm32 |
| */ |
| #ifndef LIBC_arm32_DDI_H_ |
| #define LIBC_arm32_DDI_H_ |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| static inline void pio_write_8(ioport8_t *port, uint8_t v) |
| { |
| *port = v; |
| } |
| static inline void pio_write_16(ioport16_t *port, uint16_t v) |
| { |
| *port = v; |
| } |
| static inline void pio_write_32(ioport32_t *port, uint32_t v) |
| { |
| *port = v; |
| } |
| static inline uint8_t pio_read_8(ioport8_t *port) |
| { |
| return *port; |
| } |
| static inline uint16_t pio_read_16(ioport16_t *port) |
| { |
| return *port; |
| } |
| static inline uint32_t pio_read_32(ioport32_t *port) |
| { |
| return *port; |
| } |
| #endif |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/syscall.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief |
| */ |
| #ifndef LIBC_arm32_SYSCALL_H_ |
| #define LIBC_arm32_SYSCALL_H_ |
| #define LIBARCH_SYSCALL_GENERIC |
| #include <syscall.h> |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/config.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Configuration constants. |
| */ |
| #ifndef LIBC_arm32_CONFIG_H_ |
| #define LIBC_arm32_CONFIG_H_ |
| #define PAGE_WIDTH 12 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/thread.h |
|---|
| 0,0 → 1,42 |
| /* |
| * Copyright (c) 2007 Pavel Jancik |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_arm32_THREAD_H_ |
| #define LIBC_arm32_THREAD_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/atomic.h |
|---|
| 0,0 → 1,136 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Atomic operations. |
| */ |
| #ifndef LIBC_arm32_ATOMIC_H_ |
| #define LIBC_arm32_ATOMIC_H_ |
| /** Atomic addition. |
| * |
| * @param val Where to add. |
| * @param i Value to be added. |
| * |
| * @return Value after addition. |
| */ |
| static inline long atomic_add(atomic_t *val, int i) |
| { |
| int ret; |
| volatile long * mem = &(val->count); |
| asm volatile ( |
| "1:\n" |
| "ldr r2, [%1]\n" |
| "add r3, r2, %2\n" |
| "str r3, %0\n" |
| "swp r3, r3, [%1]\n" |
| "cmp r3, r2\n" |
| "bne 1b\n" |
| : "=m" (ret) |
| : "r" (mem), "r" (i) |
| : "r3", "r2" |
| ); |
| return ret; |
| } |
| /** Atomic increment. |
| * |
| * @param val Variable to be incremented. |
| */ |
| static inline void atomic_inc(atomic_t *val) |
| { |
| atomic_add(val, 1); |
| } |
| /** Atomic decrement. |
| * |
| * @param val Variable to be decremented. |
| */ |
| static inline void atomic_dec(atomic_t *val) |
| { |
| atomic_add(val, -1); |
| } |
| /** Atomic pre-increment. |
| * |
| * @param val Variable to be incremented. |
| * @return Value after incrementation. |
| */ |
| static inline long atomic_preinc(atomic_t *val) |
| { |
| return atomic_add(val, 1); |
| } |
| /** Atomic pre-decrement. |
| * |
| * @param val Variable to be decremented. |
| * @return Value after decrementation. |
| */ |
| static inline long atomic_predec(atomic_t *val) |
| { |
| return atomic_add(val, -1); |
| } |
| /** Atomic post-increment. |
| * |
| * @param val Variable to be incremented. |
| * @return Value before incrementation. |
| */ |
| static inline long atomic_postinc(atomic_t *val) |
| { |
| return atomic_add(val, 1) - 1; |
| } |
| /** Atomic post-decrement. |
| * |
| * @param val Variable to be decremented. |
| * @return Value before decrementation. |
| */ |
| static inline long atomic_postdec(atomic_t *val) |
| { |
| return atomic_add(val, -1) + 1; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/stackarg.h |
|---|
| 0,0 → 1,43 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Empty. |
| */ |
| #ifndef LIBC_arm32_STACKARG_H_ |
| #define LIBC_arm32_STACKARG_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/faddr.h |
|---|
| 0,0 → 1,50 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Function address conversion. |
| */ |
| #ifndef LIBC_arm32_FADDR_H_ |
| #define LIBC_arm32_FADDR_H_ |
| #include <libarch/types.h> |
| /** Calculate absolute address of function referenced by fptr pointer. |
| * |
| * @param f Function pointer. |
| */ |
| #define FADDR(f) (f) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/include/limits.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2007 Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Limits declarations. |
| */ |
| #ifndef LIBC_arm32__LIMITS_H_ |
| #define LIBC_arm32__LIMITS_H_ |
| #define LONG_MIN MIN_INT32 |
| #define LONG_MAX MAX_INT32 |
| #define ULONG_MIN MIN_UINT32 |
| #define ULONG_MAX MAX_UINT32 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/Makefile.inc |
|---|
| 0,0 → 1,47 |
| # |
| # Copyright (c) 2007 Michal Kebrt |
| # Copyright (c) 2007 Pavel Jancik |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = arm-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c \ |
| arch/$(UARCH)/src/eabi.S |
| CFLAGS += -ffixed-r9 -mtp=soft |
| LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a |
| ENDIANESS = LE |
| BFD_NAME = elf32-littlearm |
| BFD_ARCH = arm |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/_link.ld.in |
|---|
| 0,0 → 1,50 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x1000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } : text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x1000; |
| .data : { |
| *(.opd); |
| *(.data .data.*); |
| *(.sdata); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .bss : { |
| *(.sbss); |
| *(.scommon); |
| *(COMMON); |
| *(.bss); |
| } :data |
| . = ALIGN(0x1000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/src/entry.s |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (c) 2007 Michal Kebrt, Pavel Jancik |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .section .init, "ax" |
| .org 0 |
| .global __entry |
| ## User-space task entry point |
| # |
| # r1 contains the PCB pointer |
| # |
| __entry: |
| # Pass pcb_ptr to __main as the first argument (in r0) |
| mov r0, r1 |
| bl __main |
| bl __exit |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/src/syscall.c |
|---|
| 0,0 → 1,78 |
| /* |
| * Copyright (c) 2007 Pavel Jancik |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 |
| * @{ |
| */ |
| /** @file |
| * @brief Syscall routine. |
| */ |
| #include <libc.h> |
| /** Syscall routine. |
| * |
| * Stores p1-p4, id to r0-r4 registers and calls <code>swi</code> |
| * instruction. Returned value is read from r0 register. |
| * |
| * @param p1 Parameter 1. |
| * @param p2 Parameter 2. |
| * @param p3 Parameter 3. |
| * @param p4 Parameter 4. |
| * @param id Number of syscall. |
| * |
| * @return Syscall return value. |
| */ |
| sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3, |
| const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id) |
| { |
| register sysarg_t __arm_reg_r0 asm("r0") = p1; |
| register sysarg_t __arm_reg_r1 asm("r1") = p2; |
| register sysarg_t __arm_reg_r2 asm("r2") = p3; |
| register sysarg_t __arm_reg_r3 asm("r3") = p4; |
| register sysarg_t __arm_reg_r4 asm("r4") = p5; |
| register sysarg_t __arm_reg_r5 asm("r5") = p6; |
| register sysarg_t __arm_reg_r6 asm("r6") = id; |
| asm volatile ( "swi" |
| : "=r" (__arm_reg_r0) |
| : "r" (__arm_reg_r0), |
| "r" (__arm_reg_r1), |
| "r" (__arm_reg_r2), |
| "r" (__arm_reg_r3), |
| "r" (__arm_reg_r4), |
| "r" (__arm_reg_r5), |
| "r" (__arm_reg_r6) |
| ); |
| return __arm_reg_r0; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/src/tls.c |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2007 Pavel Jancik |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcarm32 arm32 |
| * @brief arm32 architecture dependent parts of libc |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <tls.h> |
| #include <sys/types.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_1(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_1(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/src/fibril.S |
|---|
| 0,0 → 1,49 |
| # |
| # Copyright (c) 2007 Michal Kebrt |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global context_save |
| .global context_restore |
| context_save: |
| stmia r0!, {sp, lr} |
| stmia r0!, {r4-r11} |
| # return 1 |
| mov r0, #1 |
| mov pc, lr |
| context_restore: |
| ldmia r0!, {sp, lr} |
| ldmia r0!, {r4-r11} |
| #return 0 |
| mov r0, #0 |
| mov pc, lr |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/src/eabi.S |
|---|
| 0,0 → 1,35 |
| # |
| # Copyright (c) 2007 Pavel Jancik |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global __aeabi_read_tp |
| __aeabi_read_tp: |
| mov r0, r9 |
| mov pc, lr |
| /tags/0.4.1/uspace/lib/libc/arch/arm32/src/thread_entry.s |
|---|
| 0,0 → 1,37 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| __thread_entry: |
| b __thread_main |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/ddi.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/ddi.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/tls.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/tls.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/fibril.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/fibril.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/syscall.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/syscall.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/faddr.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/faddr.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/config.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/config.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/limits.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/limits.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/atomic.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/atomic.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/stackarg.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/stackarg.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/types.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/types.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/include/thread.h |
|---|
| 0,0 → 1,0 |
| link ../../mips32/include/thread.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/Makefile.inc |
|---|
| 0,0 → 1,45 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = mips-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c |
| CFLAGS += -mips3 |
| LFLAGS += -N |
| ENDIANESS = BE |
| BFD_ARCH = mips |
| BFD_NAME = elf32-tradbigmips |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/_link.ld.in |
|---|
| 0,0 → 1,0 |
| link ../mips32/_link.ld.in |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/mips32eb/src |
|---|
| 0,0 → 1,0 |
| link ../mips32/src |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/types.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_TYPES_H_ |
| #define LIBC_ppc32_TYPES_H_ |
| typedef unsigned int sysarg_t; |
| typedef char int8_t; |
| typedef short int int16_t; |
| typedef int int32_t; |
| typedef long long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long long int uint64_t; |
| typedef int32_t ssize_t; |
| typedef uint32_t size_t; |
| typedef uint32_t uintptr_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/ddi.h |
|---|
| 0,0 → 1,69 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @file |
| * @ingroup libcppc32 |
| */ |
| #ifndef LIBC_ppc32_DDI_H_ |
| #define LIBC_ppc32_DDI_H_ |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| static inline void pio_write_8(ioport8_t *port, uint8_t v) |
| { |
| *port = v; |
| } |
| static inline void pio_write_16(ioport16_t *port, uint16_t v) |
| { |
| *port = v; |
| } |
| static inline void pio_write_32(ioport32_t *port, uint32_t v) |
| { |
| *port = v; |
| } |
| static inline uint8_t pio_read_8(ioport8_t *port) |
| { |
| return *port; |
| } |
| static inline uint16_t pio_read_16(ioport16_t *port) |
| { |
| return *port; |
| } |
| static inline uint32_t pio_read_32(ioport32_t *port) |
| { |
| return *port; |
| } |
| #endif |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/syscall.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBC_ppc32_SYSCALL_H_ |
| #define LIBC_ppc32_SYSCALL_H_ |
| #define LIBARCH_SYSCALL_GENERIC |
| #include <syscall.h> |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/config.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_CONFIG_H_ |
| #define LIBC_ppc32_CONFIG_H_ |
| #define PAGE_WIDTH 12 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/tls.h |
|---|
| 0,0 → 1,73 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_TLS_H_ |
| #define LIBC_ppc32_TLS_H_ |
| #define CONFIG_TLS_VARIANT_1 |
| #define PPC_TP_OFFSET 0x7000 |
| typedef struct { |
| void *fibril_data; |
| } tcb_t; |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| void *tp = tcb; |
| tp += PPC_TP_OFFSET + sizeof(tcb_t); |
| asm volatile ( |
| "mr %%r2, %0\n" |
| : |
| : "r" (tp) |
| ); |
| } |
| static inline tcb_t * __tcb_get(void) |
| { |
| void * retval; |
| asm volatile ( |
| "mr %0, %%r2\n" |
| : "=r" (retval) |
| ); |
| return (tcb_t *)(retval - PPC_TP_OFFSET - sizeof(tcb_t)); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/thread.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_THREAD_H_ |
| #define LIBC_ppc32_THREAD_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/fibril.h |
|---|
| 0,0 → 1,83 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_FIBRIL_H_ |
| #define LIBC_ppc32_FIBRIL_H_ |
| #include <sys/types.h> |
| /* We define our own context_set, because we need to set |
| * the TLS pointer to the tcb+0x7000 |
| * |
| * See tls_set in thread.h |
| */ |
| #define context_set(c, _pc, stack, size, ptls) \ |
| (c)->pc = (sysarg_t) (_pc); \ |
| (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \ |
| (c)->tls = ((sysarg_t) (ptls)) + 0x7000 + sizeof(tcb_t); |
| #define SP_DELTA 16 |
| typedef struct { |
| uint32_t sp; |
| uint32_t pc; |
| uint32_t tls; |
| uint32_t r13; |
| uint32_t r14; |
| uint32_t r15; |
| uint32_t r16; |
| uint32_t r17; |
| uint32_t r18; |
| uint32_t r19; |
| uint32_t r20; |
| uint32_t r21; |
| uint32_t r22; |
| uint32_t r23; |
| uint32_t r24; |
| uint32_t r25; |
| uint32_t r26; |
| uint32_t r27; |
| uint32_t r28; |
| uint32_t r29; |
| uint32_t r30; |
| uint32_t r31; |
| uint32_t cr; |
| } __attribute__ ((packed)) context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/atomic.h |
|---|
| 0,0 → 1,95 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_ATOMIC_H_ |
| #define LIBC_ppc32_ATOMIC_H_ |
| static inline void atomic_inc(atomic_t *val) |
| { |
| long tmp; |
| asm volatile ( |
| "1:\n" |
| "lwarx %0, 0, %2\n" |
| "addic %0, %0, 1\n" |
| "stwcx. %0, 0, %2\n" |
| "bne- 1b" |
| : "=&r" (tmp), "=m" (val->count) |
| : "r" (&val->count), "m" (val->count) |
| : "cc"); |
| } |
| static inline void atomic_dec(atomic_t *val) |
| { |
| long tmp; |
| asm volatile ( |
| "1:\n" |
| "lwarx %0, 0, %2\n" |
| "addic %0, %0, -1\n" |
| "stwcx. %0, 0, %2\n" |
| "bne- 1b" |
| : "=&r" (tmp), "=m" (val->count) |
| : "r" (&val->count), "m" (val->count) |
| : "cc"); |
| } |
| static inline long atomic_postinc(atomic_t *val) |
| { |
| atomic_inc(val); |
| return val->count - 1; |
| } |
| static inline long atomic_postdec(atomic_t *val) |
| { |
| atomic_dec(val); |
| return val->count + 1; |
| } |
| static inline long atomic_preinc(atomic_t *val) |
| { |
| atomic_inc(val); |
| return val->count; |
| } |
| static inline long atomic_predec(atomic_t *val) |
| { |
| atomic_dec(val); |
| return val->count; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/regname.h |
|---|
| 0,0 → 1,188 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_REGNAME_H_ |
| #define LIBC_ppc32_REGNAME_H_ |
| /* Condition Register Bit Fields */ |
| #define cr0 0 |
| #define cr1 1 |
| #define cr2 2 |
| #define cr3 3 |
| #define cr4 4 |
| #define cr5 5 |
| #define cr6 6 |
| #define cr7 7 |
| /* General Purpose Registers (GPRs) */ |
| #define r0 0 |
| #define r1 1 |
| #define r2 2 |
| #define r3 3 |
| #define r4 4 |
| #define r5 5 |
| #define r6 6 |
| #define r7 7 |
| #define r8 8 |
| #define r9 9 |
| #define r10 10 |
| #define r11 11 |
| #define r12 12 |
| #define r13 13 |
| #define r14 14 |
| #define r15 15 |
| #define r16 16 |
| #define r17 17 |
| #define r18 18 |
| #define r19 19 |
| #define r20 20 |
| #define r21 21 |
| #define r22 22 |
| #define r23 23 |
| #define r24 24 |
| #define r25 25 |
| #define r26 26 |
| #define r27 27 |
| #define r28 28 |
| #define r29 29 |
| #define r30 30 |
| #define r31 31 |
| /* GPR Aliases */ |
| #define sp 1 |
| /* Floating Point Registers (FPRs) */ |
| #define fr0 0 |
| #define fr1 1 |
| #define fr2 2 |
| #define fr3 3 |
| #define fr4 4 |
| #define fr5 5 |
| #define fr6 6 |
| #define fr7 7 |
| #define fr8 8 |
| #define fr9 9 |
| #define fr10 10 |
| #define fr11 11 |
| #define fr12 12 |
| #define fr13 13 |
| #define fr14 14 |
| #define fr15 15 |
| #define fr16 16 |
| #define fr17 17 |
| #define fr18 18 |
| #define fr19 19 |
| #define fr20 20 |
| #define fr21 21 |
| #define fr22 22 |
| #define fr23 23 |
| #define fr24 24 |
| #define fr25 25 |
| #define fr26 26 |
| #define fr27 27 |
| #define fr28 28 |
| #define fr29 29 |
| #define fr30 30 |
| #define fr31 31 |
| #define vr0 0 |
| #define vr1 1 |
| #define vr2 2 |
| #define vr3 3 |
| #define vr4 4 |
| #define vr5 5 |
| #define vr6 6 |
| #define vr7 7 |
| #define vr8 8 |
| #define vr9 9 |
| #define vr10 10 |
| #define vr11 11 |
| #define vr12 12 |
| #define vr13 13 |
| #define vr14 14 |
| #define vr15 15 |
| #define vr16 16 |
| #define vr17 17 |
| #define vr18 18 |
| #define vr19 19 |
| #define vr20 20 |
| #define vr21 21 |
| #define vr22 22 |
| #define vr23 23 |
| #define vr24 24 |
| #define vr25 25 |
| #define vr26 26 |
| #define vr27 27 |
| #define vr28 28 |
| #define vr29 29 |
| #define vr30 30 |
| #define vr31 31 |
| #define evr0 0 |
| #define evr1 1 |
| #define evr2 2 |
| #define evr3 3 |
| #define evr4 4 |
| #define evr5 5 |
| #define evr6 6 |
| #define evr7 7 |
| #define evr8 8 |
| #define evr9 9 |
| #define evr10 10 |
| #define evr11 11 |
| #define evr12 12 |
| #define evr13 13 |
| #define evr14 14 |
| #define evr15 15 |
| #define evr16 16 |
| #define evr17 17 |
| #define evr18 18 |
| #define evr19 19 |
| #define evr20 20 |
| #define evr21 21 |
| #define evr22 22 |
| #define evr23 23 |
| #define evr24 24 |
| #define evr25 25 |
| #define evr26 26 |
| #define evr27 27 |
| #define evr28 28 |
| #define evr29 29 |
| #define evr30 30 |
| #define evr31 31 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/stackarg.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STACKARG_H_ |
| #define LIBC_STACKARG_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/faddr.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_FADDR_H_ |
| #define LIBC_ppc32_FADDR_H_ |
| #include <libarch/types.h> |
| #define FADDR(fptr) ((uintptr_t) (fptr)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/include/limits.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ppc32_LIMITS_H_ |
| #define LIBC_ppc32_LIMITS_H_ |
| #define LONG_MIN MIN_INT32 |
| #define LONG_MAX MAX_INT32 |
| #define ULONG_MIN MIN_UINT32 |
| #define ULONG_MAX MAX_UINT32 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/Makefile.inc |
|---|
| 0,0 → 1,46 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = ppc-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/ppc/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c |
| CFLAGS += -mcpu=powerpc -msoft-float -m32 |
| AFLAGS += -a32 |
| LFLAGS += -N |
| ENDIANESS = BE |
| BFD_NAME = elf32-powerpc |
| BFD_ARCH = powerpc:common |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/_link.ld.in |
|---|
| 0,0 → 1,48 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x1000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } :text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x1000; |
| .data : { |
| *(.data); |
| *(.sdata); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .bss : { |
| *(.sbss); |
| *(COMMON); |
| *(.bss); |
| } :data |
| . = ALIGN(0x1000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/src/entry.s |
|---|
| 0,0 → 1,45 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .section .init, "ax" |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # r6 contains the PCB pointer |
| # |
| __entry: |
| # Pass the PCB pointer to __main() as the first argument. |
| # The first argument is passed in r3. |
| mr %r3, %r6 |
| bl __main |
| bl __exit |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/src/fibril.S |
|---|
| 0,0 → 1,62 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global context_save |
| .global context_restore |
| #include <libarch/regname.h> |
| #include <arch/context_offset.h> |
| context_save: |
| CONTEXT_SAVE_ARCH_CORE r3 |
| mflr r4 |
| stw r4, OFFSET_PC(r3) |
| mfcr r4 |
| stw r4, OFFSET_CR(r3) |
| # context_save returns 1 |
| li r3, 1 |
| blr |
| context_restore: |
| CONTEXT_RESTORE_ARCH_CORE r3 |
| lwz r4, OFFSET_CR(r3) |
| mtcr r4 |
| lwz r4, OFFSET_PC(r3) |
| mtlr r4 |
| # context_restore returns 0 |
| li r3, 0 |
| blr |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/src/syscall.c |
|---|
| 0,0 → 1,66 |
| /* |
| * Copyright (c) 2006 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 ppc32 |
| * @brief ppc32 architecture dependent parts of libc |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <libc.h> |
| sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3, |
| const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id) |
| { |
| register sysarg_t __ppc32_reg_r3 asm("3") = p1; |
| register sysarg_t __ppc32_reg_r4 asm("4") = p2; |
| register sysarg_t __ppc32_reg_r5 asm("5") = p3; |
| register sysarg_t __ppc32_reg_r6 asm("6") = p4; |
| register sysarg_t __ppc32_reg_r7 asm("7") = p5; |
| register sysarg_t __ppc32_reg_r8 asm("8") = p6; |
| register sysarg_t __ppc32_reg_r9 asm("9") = id; |
| asm volatile ( |
| "sc\n" |
| : "=r" (__ppc32_reg_r3) |
| : "r" (__ppc32_reg_r3), |
| "r" (__ppc32_reg_r4), |
| "r" (__ppc32_reg_r5), |
| "r" (__ppc32_reg_r6), |
| "r" (__ppc32_reg_r7), |
| "r" (__ppc32_reg_r8), |
| "r" (__ppc32_reg_r9) |
| ); |
| return __ppc32_reg_r3; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/src/tls.c |
|---|
| 0,0 → 1,49 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcppc32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #include <tls.h> |
| #include <sys/types.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_1(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_1(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ppc32/src/thread_entry.s |
|---|
| 0,0 → 1,39 |
| # |
| # Copyright (c) 2006 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .globl __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| __thread_entry: |
| b __thread_main |
| .end __thread_entry |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/types.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_TYPES_H_ |
| #define LIBC_amd64_TYPES_H_ |
| typedef unsigned long long sysarg_t; |
| typedef signed char int8_t; |
| typedef short int int16_t; |
| typedef int int32_t; |
| typedef long long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long long int uint64_t; |
| typedef int64_t ssize_t; |
| typedef uint64_t size_t; |
| typedef uint64_t uintptr_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/syscall.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBC_amd64_SYSCALL_H_ |
| #define LIBC_amd64_SYSCALL_H_ |
| #define LIBARCH_SYSCALL_GENERIC |
| #include <syscall.h> |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/config.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_CONFIG_H_ |
| #define LIBC_amd64_CONFIG_H_ |
| #define PAGE_WIDTH 12 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/atomic.h |
|---|
| 0,0 → 1,80 |
| /* |
| * Copyright (c) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 amd64 |
| * @ingroup lc |
| * @brief amd64 architecture dependent parts of libc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_ATOMIC_H_ |
| #define LIBC_amd64_ATOMIC_H_ |
| static inline void atomic_inc(atomic_t *val) { |
| asm volatile ("lock incq %0\n" : "+m" (val->count)); |
| } |
| static inline void atomic_dec(atomic_t *val) { |
| asm volatile ("lock decq %0\n" : "+m" (val->count)); |
| } |
| static inline long atomic_postinc(atomic_t *val) |
| { |
| long r; |
| asm volatile ( |
| "movq $1, %0\n" |
| "lock xaddq %0, %1\n" |
| : "=r" (r), "+m" (val->count) |
| ); |
| return r; |
| } |
| static inline long atomic_postdec(atomic_t *val) |
| { |
| long r; |
| asm volatile ( |
| "movq $-1, %0\n" |
| "lock xaddq %0, %1\n" |
| : "=r" (r), "+m" (val->count) |
| ); |
| return r; |
| } |
| #define atomic_preinc(val) (atomic_postinc(val) + 1) |
| #define atomic_predec(val) (atomic_postdec(val) - 1) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/tls.h |
|---|
| 0,0 → 1,63 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_TLS_H_ |
| #define LIBC_amd64_TLS_H_ |
| #define CONFIG_TLS_VARIANT_2 |
| #include <libc.h> |
| typedef struct { |
| void *self; |
| void *fibril_data; |
| } tcb_t; |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| __SYSCALL1(SYS_TLS_SET, (sysarg_t) tcb); |
| } |
| static inline tcb_t * __tcb_get(void) |
| { |
| void * retval; |
| asm ("movq %%fs:0, %0" : "=r"(retval)); |
| return retval; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/thread.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_THREAD_H_ |
| #define LIBC_amd64_THREAD_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/fibril.h |
|---|
| 0,0 → 1,67 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_FIBRIL_H_ |
| #define LIBC_amd64_FIBRIL_H_ |
| #include <sys/types.h> |
| /* According to ABI the stack MUST be aligned on |
| * 16-byte boundary. If it is not, the va_arg calling will |
| * panic sooner or later |
| */ |
| #define SP_DELTA 16 |
| /* We include only registers that must be preserved |
| * during function call |
| */ |
| typedef struct { |
| uint64_t sp; |
| uint64_t pc; |
| uint64_t rbx; |
| uint64_t rbp; |
| uint64_t r12; |
| uint64_t r13; |
| uint64_t r14; |
| uint64_t r15; |
| uint64_t tls; |
| } context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/stackarg.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_STACKARG_H_ |
| #define LIBC_STACKARG_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/faddr.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_FADDR_H_ |
| #define LIBC_amd64_FADDR_H_ |
| #include <libarch/types.h> |
| #define FADDR(fptr) ((uintptr_t) (fptr)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/limits.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_amd64_LIMITS_H_ |
| #define LIBC_amd64_LIMITS_H_ |
| # define LONG_MIN MIN_INT64 |
| # define LONG_MAX MAX_INT64 |
| # define ULONG_MIN MIN_UINT64 |
| # define ULONG_MAX MAX_UINT64 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/include/ddi.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/ddi.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/Makefile.inc |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = amd64-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/amd64/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c |
| LFLAGS += -N |
| ENDIANESS = LE |
| BFD_NAME = elf64-x86-64 |
| BFD_ARCH = i386:x86-64 |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/_link.ld.in |
|---|
| 0,0 → 1,46 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x1000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } :text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x1000; |
| .data : { |
| *(.data); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .bss : { |
| *(COMMON); |
| *(.bss); |
| } :data |
| . = ALIGN(0x1000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/src/entry.s |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (c) 2006 Ondrej Palkovsky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .section .init, "ax" |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # %rdi contains the PCB pointer |
| # |
| __entry: |
| # %rdi was deliberately chosen as the first argument is also in %rdi |
| # Pass PCB pointer to __main (no operation) |
| call __main |
| call __exit |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/src/fibril.S |
|---|
| 0,0 → 1,73 |
| # |
| # Copyright (c) 2001-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global context_save |
| .global context_restore |
| #include <kernel/arch/context_offset.h> |
| ## Save current CPU context |
| # |
| # Save CPU context to context_t variable |
| # pointed by the 1st argument. Returns 1 in EAX. |
| # |
| context_save: |
| movq (%rsp), %rdx # the caller's return %eip |
| # In %edi is passed 1st argument |
| CONTEXT_SAVE_ARCH_CORE %rdi %rdx |
| # Save TLS |
| movq %fs:0, %rax |
| movq %rax, OFFSET_TLS(%rdi) |
| xorq %rax,%rax # context_save returns 1 |
| incq %rax |
| ret |
| ## Restore current CPU context |
| # |
| # Restore CPU context from context_t variable |
| # pointed by the 1st argument. Returns 0 in EAX. |
| # |
| context_restore: |
| CONTEXT_RESTORE_ARCH_CORE %rdi %rdx |
| movq %rdx,(%rsp) |
| # Set thread local storage |
| movq OFFSET_TLS(%rdi), %rdi # Set arg1 to TLS addr |
| movq $1, %rax # SYS_TLS_SET |
| syscall |
| xorq %rax,%rax # context_restore returns 0 |
| ret |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/src/syscall.S |
|---|
| 0,0 → 1,57 |
| # |
| # Copyright (c) 2006 Ondrej Palkovsky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global __syscall |
| ## Make a system call. |
| # |
| # @param rdi First argument. |
| # @param rsi Second argument. |
| # @param rdx Third argument. |
| # @param rcx Fourth argument. |
| # @param r8 Fifth argument. |
| # @param r9 Sixth argument. |
| # @param 8(%rsp) Syscall number. |
| # |
| # @return The return value will be stored in RAX. |
| # |
| __syscall: |
| # |
| # Move the syscall number into RAX. |
| movslq 8(%rsp), %rax |
| # |
| # Save RCX, the 4th argument, aside because RCX gets rewritten by the |
| # SYSCALL instruction. |
| # |
| movq %rcx, %r10 |
| syscall |
| ret |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/src/tls.c |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 amd64 |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcia32 |
| */ |
| #include <tls.h> |
| #include <sys/types.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_2(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_2(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/amd64/src/thread_entry.s |
|---|
| 0,0 → 1,43 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .globl __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| __thread_entry: |
| # |
| # RAX contains address of uarg |
| # |
| movq %rax, %rdi |
| call __thread_main |
| .end __thread_entry |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/types.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #ifndef LIBC_mips32_TYPES_H_ |
| #define LIBC_mips32_TYPES_H_ |
| typedef unsigned int sysarg_t; |
| typedef char int8_t; |
| typedef short int int16_t; |
| typedef long int int32_t; |
| typedef long long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned long int uint32_t; |
| typedef unsigned long long int uint64_t; |
| typedef int32_t ssize_t; |
| typedef uint32_t size_t; |
| typedef uint32_t uintptr_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/ddi.h |
|---|
| 0,0 → 1,69 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @file |
| * @ingroup libcmips32 |
| */ |
| #ifndef LIBC_mips32_DDI_H_ |
| #define LIBC_mips32_DDI_H_ |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| static inline void pio_write_8(ioport8_t *port, uint8_t v) |
| { |
| *port = v; |
| } |
| static inline void pio_write_16(ioport16_t *port, uint16_t v) |
| { |
| *port = v; |
| } |
| static inline void pio_write_32(ioport32_t *port, uint32_t v) |
| { |
| *port = v; |
| } |
| static inline uint8_t pio_read_8(ioport8_t *port) |
| { |
| return *port; |
| } |
| static inline uint16_t pio_read_16(ioport16_t *port) |
| { |
| return *port; |
| } |
| static inline uint32_t pio_read_32(ioport32_t *port) |
| { |
| return *port; |
| } |
| #endif |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/atomic.h |
|---|
| 0,0 → 1,78 |
| /* |
| * Copyright (c) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #ifndef LIBC_mips32_ATOMIC_H_ |
| #define LIBC_mips32_ATOMIC_H_ |
| #define atomic_inc(x) ((void) atomic_add(x, 1)) |
| #define atomic_dec(x) ((void) atomic_add(x, -1)) |
| #define atomic_postinc(x) (atomic_add(x, 1) - 1) |
| #define atomic_postdec(x) (atomic_add(x, -1) + 1) |
| #define atomic_preinc(x) atomic_add(x, 1) |
| #define atomic_predec(x) atomic_add(x, -1) |
| /* Atomic addition of immediate value. |
| * |
| * @param val Memory location to which will be the immediate value added. |
| * @param i Signed immediate that will be added to *val. |
| * |
| * @return Value after addition. |
| */ |
| static inline long atomic_add(atomic_t *val, int i) |
| { |
| long tmp, v; |
| asm volatile ( |
| "1:\n" |
| " ll %0, %1\n" |
| " addu %0, %0, %3\n" /* same as add, but never traps on overflow */ |
| " move %2, %0\n" |
| " sc %0, %1\n" |
| " beq %0, %4, 1b\n" /* if the atomic operation failed, try again */ |
| /* nop */ /* nop is inserted automatically by compiler */ |
| " nop\n" |
| : "=&r" (tmp), "+m" (val->count), "=&r" (v) |
| : "r" (i), "i" (0) |
| ); |
| return v; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/syscall.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBC_mips32_SYSCALL_H_ |
| #define LIBC_mips32_SYSCALL_H_ |
| #define LIBARCH_SYSCALL_GENERIC |
| #include <syscall.h> |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/config.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_mips32_CONFIG_H_ |
| #define LIBC_mips32_CONFIG_H_ |
| #define PAGE_WIDTH 14 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/tls.h |
|---|
| 0,0 → 1,86 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| /* TLS for MIPS is described in http://www.linux-mips.org/wiki/NPTL */ |
| #ifndef LIBC_mips32_TLS_H_ |
| #define LIBC_mips32_TLS_H_ |
| /* |
| * FIXME: Note that the use of variant I contradicts the observations made in |
| * the note below. Nevertheless the scheme we have used for allocating and |
| * deallocatin TLS corresponds to TLS variant I. |
| */ |
| #define CONFIG_TLS_VARIANT_1 |
| /* I did not find any specification (neither MIPS nor PowerPC), but |
| * as I found it |
| * - it uses Variant II |
| * - TCB is at Address(First TLS Block)+0x7000. |
| * - DTV is at Address(First TLS Block)+0x8000 |
| * - What would happen if the TLS data was larger then 0x7000? |
| * - The linker never accesses DTV directly, has the second definition any |
| * sense? |
| * We will make it this way: |
| * - TCB is at TP-0x7000-sizeof(tcb) |
| * - No assumption about DTV etc., but it will not have a fixed address |
| */ |
| #define MIPS_TP_OFFSET 0x7000 |
| typedef struct { |
| void *fibril_data; |
| } tcb_t; |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| void *tp = tcb; |
| tp += MIPS_TP_OFFSET + sizeof(tcb_t); |
| asm volatile ("add $27, %0, $0" : : "r"(tp)); /* Move tls to K1 */ |
| } |
| static inline tcb_t * __tcb_get(void) |
| { |
| void * retval; |
| asm volatile("add %0, $27, $0" : "=r"(retval)); |
| return (tcb_t *)(retval - MIPS_TP_OFFSET - sizeof(tcb_t)); |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/thread.h |
|---|
| 0,0 → 1,42 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #ifndef LIBC_mips32_THREAD_H_ |
| #define LIBC_mips32_THREAD_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/stackarg.h |
|---|
| 0,0 → 1,62 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #ifndef LIBC_mips32_STACKARG_H_ |
| #define LIBC_mips32_STACKARG_H_ |
| /* dont allow to define it second time in stdarg.h */ |
| #define __VARARGS_DEFINED |
| #include <sys/types.h> |
| /** |
| * va_arg macro for MIPS32 - problem is that 64 bit values must be aligned on an 8-byte boundary (32bit values not) |
| * To satisfy this, paddings must be sometimes inserted. |
| */ |
| typedef uint8_t* va_list; |
| #define va_start(ap, lst) \ |
| ((ap) = (va_list)&(lst) + sizeof(lst)) |
| #define va_arg(ap, type) \ |
| (((type *)((ap) = (va_list)( (sizeof(type) <= 4) ? ((uint32_t)((ap) + 2*4 - 1) & (~3)) : ((uint32_t)((ap) + 2*8 -1) & (~7)) )))[-1]) |
| #define va_end(ap) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/fibril.h |
|---|
| 0,0 → 1,90 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #ifndef LIBC_mips32_FIBRIL_H_ |
| #define LIBC_mips32_FIBRIL_H_ |
| #include <sys/types.h> |
| /* We define our own context_set, because we need to set |
| * the TLS pointer to the tcb+0x7000 |
| * |
| * See tls_set in thread.h |
| */ |
| #define context_set(c, _pc, stack, size, ptls) \ |
| (c)->pc = (sysarg_t) (_pc); \ |
| (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \ |
| (c)->tls = ((sysarg_t)(ptls)) + 0x7000 + sizeof(tcb_t); |
| /* +16 is just for sure that the called function |
| * have space to store it's arguments |
| */ |
| #define SP_DELTA (8+16) |
| typedef struct { |
| uint32_t sp; |
| uint32_t pc; |
| uint32_t s0; |
| uint32_t s1; |
| uint32_t s2; |
| uint32_t s3; |
| uint32_t s4; |
| uint32_t s5; |
| uint32_t s6; |
| uint32_t s7; |
| uint32_t s8; |
| uint32_t gp; |
| uint32_t tls; /* Thread local storage(=k1) */ |
| uint32_t f20; |
| uint32_t f21; |
| uint32_t f22; |
| uint32_t f23; |
| uint32_t f24; |
| uint32_t f25; |
| uint32_t f26; |
| uint32_t f27; |
| uint32_t f28; |
| uint32_t f29; |
| uint32_t f30; |
| } context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/faddr.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_mips32_FADDR_H_ |
| #define LIBC_mips32_FADDR_H_ |
| #include <libarch/types.h> |
| #define FADDR(fptr) ((uintptr_t) (fptr)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/include/limits.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #ifndef LIBC_mips32__LIMITS_H_ |
| #define LIBC_mips32__LIMITS_H_ |
| # define LONG_MIN MIN_INT32 |
| # define LONG_MAX MAX_INT32 |
| # define ULONG_MIN MIN_UINT32 |
| # define ULONG_MAX MAX_UINT32 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/Makefile.inc |
|---|
| 0,0 → 1,44 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = mipsel-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c |
| CFLAGS += -mips3 |
| ENDIANESS = LE |
| BFD_ARCH = mips |
| BFD_NAME = elf32-tradlittlemips |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/_link.ld.in |
|---|
| 0,0 → 1,57 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x4000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } :text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x4000; |
| .data : { |
| *(.data); |
| *(.data.rel*); |
| } :data |
| .got : { |
| _gp = .; |
| *(.got); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .sbss : { |
| *(.scommon); |
| *(.sbss); |
| } |
| .bss : { |
| *(.bss); |
| *(COMMON); |
| } :data |
| . = ALIGN(0x4000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/src/entry.s |
|---|
| 0,0 → 1,65 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .section .init, "ax" |
| .global __entry |
| .global __entry_driver |
| .set noreorder |
| .option pic2 |
| ## User-space task entry point |
| # |
| # $a0 ($4) contains the PCB pointer |
| # |
| .ent __entry |
| __entry: |
| .frame $sp, 32, $31 |
| .cpload $25 |
| # Mips o32 may store its arguments on stack, make space (16 bytes), |
| # so that it could work with -O0 |
| # Make space additional 16 bytes for the stack frame |
| addiu $sp, -32 |
| .cprestore 16 # Allow PIC code |
| # Pass pcb_ptr to __main() as the first argument. pcb_ptr is already |
| # in $a0. As the first argument is passed in $a0, no operation |
| # is needed. |
| jal __main |
| nop |
| jal __exit |
| nop |
| .end |
| # Alignment of output section data to 0x4000 |
| .section .data |
| .align 14 |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/src/fibril.S |
|---|
| 0,0 → 1,55 |
| # |
| # Copyright (c) 2003-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .set noat |
| .set noreorder |
| #include <arch/context_offset.h> |
| .global context_save |
| .global context_restore |
| context_save: |
| CONTEXT_SAVE_ARCH_CORE $a0 |
| # context_save returns 1 |
| j $ra |
| li $v0, 1 |
| context_restore: |
| CONTEXT_RESTORE_ARCH_CORE $a0 |
| # Just for the jump into first function, but one instruction |
| # should not bother us |
| move $t9, $ra |
| # context_restore returns 0 |
| j $ra |
| xor $v0, $v0 |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/src/syscall.c |
|---|
| 0,0 → 1,68 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #include <libc.h> |
| sysarg_t __syscall(const sysarg_t p1, const sysarg_t p2, const sysarg_t p3, |
| const sysarg_t p4, const sysarg_t p5, const sysarg_t p6, const syscall_t id) |
| { |
| register sysarg_t __mips_reg_a0 asm("$4") = p1; |
| register sysarg_t __mips_reg_a1 asm("$5") = p2; |
| register sysarg_t __mips_reg_a2 asm("$6") = p3; |
| register sysarg_t __mips_reg_a3 asm("$7") = p4; |
| register sysarg_t __mips_reg_t0 asm("$8") = p5; |
| register sysarg_t __mips_reg_t1 asm("$9") = p6; |
| register sysarg_t __mips_reg_v0 asm("$2") = id; |
| asm volatile ( |
| "syscall\n" |
| : "=r" (__mips_reg_v0) |
| : "r" (__mips_reg_a0), |
| "r" (__mips_reg_a1), |
| "r" (__mips_reg_a2), |
| "r" (__mips_reg_a3), |
| "r" (__mips_reg_t0), |
| "r" (__mips_reg_t1), |
| "r" (__mips_reg_v0) |
| : "%ra" /* We are a function call, although C does not |
| * know it */ |
| ); |
| return __mips_reg_v0; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/src/tls.c |
|---|
| 0,0 → 1,50 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcmips32 |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcmips32eb |
| */ |
| #include <tls.h> |
| #include <sys/types.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_1(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_1(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/mips32/src/thread_entry.s |
|---|
| 0,0 → 1,59 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .set noat |
| .set noreorder |
| .option pic2 |
| .globl __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| .ent __thread_entry |
| __thread_entry: |
| .frame $sp, 32, $31 |
| .cpload $25 |
| # |
| # v0 contains address of uarg. |
| # |
| add $4, $2, 0 |
| # Mips o32 may store its arguments on stack, make space |
| addiu $sp, -32 |
| .cprestore 16 |
| jal __thread_main |
| nop |
| # |
| # Not reached. |
| # |
| .end __thread_entry |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/types.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_TYPES_H_ |
| #define LIBC_ia32_TYPES_H_ |
| typedef unsigned int sysarg_t; |
| typedef char int8_t; |
| typedef short int int16_t; |
| typedef int int32_t; |
| typedef long long int int64_t; |
| typedef unsigned char uint8_t; |
| typedef unsigned short int uint16_t; |
| typedef unsigned int uint32_t; |
| typedef unsigned long long int uint64_t; |
| typedef int32_t ssize_t; |
| typedef uint32_t size_t; |
| typedef uint32_t uintptr_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/ddi.h |
|---|
| 0,0 → 1,104 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @file |
| * @ingroup libcia32, libcamd64 |
| */ |
| #ifndef LIBC_ia32_DDI_H_ |
| #define LIBC_ia32_DDI_H_ |
| #include <sys/types.h> |
| #include <libarch/types.h> |
| #define IO_SPACE_BOUNDARY ((void *) (64 * 1024)) |
| static inline uint8_t pio_read_8(ioport8_t *port) |
| { |
| uint8_t val; |
| asm volatile ( |
| "inb %w[port], %b[val]\n" |
| : [val] "=a" (val) |
| : [port] "d" (port) |
| ); |
| return val; |
| } |
| static inline uint16_t pio_read_16(ioport16_t *port) |
| { |
| uint16_t val; |
| asm volatile ( |
| "inw %w[port], %w[val]\n" |
| : [val] "=a" (val) |
| : [port] "d" (port) |
| ); |
| return val; |
| } |
| static inline uint32_t pio_read_32(ioport32_t *port) |
| { |
| uint32_t val; |
| asm volatile ( |
| "inl %w[port], %[val]\n" |
| : [val] "=a" (val) |
| : [port] "d" (port) |
| ); |
| return val; |
| } |
| static inline void pio_write_8(ioport8_t *port, uint8_t val) |
| { |
| asm volatile ( |
| "outb %b[val], %w[port]\n" |
| :: [val] "a" (val), [port] "d" (port) |
| ); |
| } |
| static inline void pio_write_16(ioport16_t *port, uint16_t val) |
| { |
| asm volatile ( |
| "outw %w[val], %w[port]\n" |
| :: [val] "a" (val), [port] "d" (port) |
| ); |
| } |
| static inline void pio_write_32(ioport32_t *port, uint32_t val) |
| { |
| asm volatile ( |
| "outl %[val], %w[port]\n" |
| :: [val] "a" (val), [port] "d" (port) |
| ); |
| } |
| #endif |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/syscall.h |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (c) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libc |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBC_ia32_SYSCALL_H_ |
| #define LIBC_ia32_SYSCALL_H_ |
| #include <sys/types.h> |
| #include <kernel/syscall/syscall.h> |
| #define __syscall0 __syscall_sysenter |
| #define __syscall1 __syscall_sysenter |
| #define __syscall2 __syscall_sysenter |
| #define __syscall3 __syscall_sysenter |
| #define __syscall4 __syscall_sysenter |
| #define __syscall5 __syscall_int |
| #define __syscall6 __syscall_int |
| extern sysarg_t |
| __syscall_sysenter(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t, |
| const sysarg_t, const sysarg_t, const syscall_t); |
| extern sysarg_t |
| __syscall_int(const sysarg_t, const sysarg_t, const sysarg_t, const sysarg_t, |
| const sysarg_t, const sysarg_t, const syscall_t); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/config.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (c) 2006 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_CONFIG_H_ |
| #define LIBC_ia32_CONFIG_H_ |
| #define PAGE_WIDTH 12 |
| #define PAGE_SIZE (1 << PAGE_WIDTH) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/atomic.h |
|---|
| 0,0 → 1,78 |
| /* |
| * Copyright (c) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_ATOMIC_H_ |
| #define LIBC_ia32_ATOMIC_H_ |
| static inline void atomic_inc(atomic_t *val) { |
| asm volatile ("lock incl %0\n" : "+m" (val->count)); |
| } |
| static inline void atomic_dec(atomic_t *val) { |
| asm volatile ("lock decl %0\n" : "+m" (val->count)); |
| } |
| static inline long atomic_postinc(atomic_t *val) |
| { |
| long r; |
| asm volatile ( |
| "movl $1, %0\n" |
| "lock xaddl %0, %1\n" |
| : "=r" (r), "+m" (val->count) |
| ); |
| return r; |
| } |
| static inline long atomic_postdec(atomic_t *val) |
| { |
| long r; |
| asm volatile ( |
| "movl $-1, %0\n" |
| "lock xaddl %0, %1\n" |
| : "=r" (r), "+m" (val->count) |
| ); |
| return r; |
| } |
| #define atomic_preinc(val) (atomic_postinc(val) + 1) |
| #define atomic_predec(val) (atomic_postdec(val) - 1) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/tls.h |
|---|
| 0,0 → 1,63 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_TLS_H_ |
| #define LIBC_ia32_TLS_H_ |
| #define CONFIG_TLS_VARIANT_2 |
| #include <libc.h> |
| typedef struct { |
| void *self; |
| void *fibril_data; |
| } tcb_t; |
| static inline void __tcb_set(tcb_t *tcb) |
| { |
| __SYSCALL1(SYS_TLS_SET, (sysarg_t) tcb); |
| } |
| static inline tcb_t * __tcb_get(void) |
| { |
| void *retval; |
| asm ("movl %%gs:0, %0" : "=r"(retval)); |
| return retval; |
| } |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/thread.h |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_THREAD_H_ |
| #define LIBC_ia32_THREAD_H_ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/stackarg.h |
|---|
| 0,0 → 1,66 |
| /* |
| * Copyright (c) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| /* |
| * Variable argument list manipulation macros |
| * for architectures using stack to pass arguments. |
| */ |
| #ifndef LIBC_ia32_STACKARG_H_ |
| #define LIBC_ia32_STACKARG_H_ |
| #include <sys/types.h> |
| /* dont allow to define it second time in stdarg.h */ |
| #define __VARARGS_DEFINED |
| typedef struct va_list { |
| int pos; |
| uint8_t *last; |
| } va_list; |
| #define va_start(ap, lst) \ |
| (ap).pos = sizeof(lst); \ |
| (ap).last = (uint8_t *) &(lst) |
| #define va_arg(ap, type) \ |
| (*((type *)((ap).last + ((ap).pos += sizeof(type) ) - sizeof(type)))) |
| #define va_end(ap) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/fibril.h |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_FIBRIL_H_ |
| #define LIBC_ia32_FIBRIL_H_ |
| #include <sys/types.h> |
| /* According to ABI the stack MUST be aligned on |
| * 16-byte boundary. If it is not, the va_arg calling will |
| * panic sooner or later |
| */ |
| #define SP_DELTA (12) |
| /* We include only registers that must be preserved |
| * during function call |
| */ |
| typedef struct { |
| uint32_t sp; |
| uint32_t pc; |
| uint32_t ebx; |
| uint32_t esi; |
| uint32_t edi; |
| uint32_t ebp; |
| uint32_t tls; |
| } context_t; |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/faddr.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (c) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32_FADDR_H_ |
| #define LIBC_ia32_FADDR_H_ |
| #include <libarch/types.h> |
| #define FADDR(fptr) ((uintptr_t) (fptr)) |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/include/limits.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcia32 |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef LIBC_ia32__LIMITS_H_ |
| #define LIBC_ia32__LIMITS_H_ |
| # define LONG_MIN MIN_INT32 |
| # define LONG_MAX MAX_INT32 |
| # define ULONG_MIN MIN_UINT32 |
| # define ULONG_MAX MAX_UINT32 |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/Makefile.inc |
|---|
| 0,0 → 1,45 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = i686-pc-linux-gnu |
| TOOLCHAIN_DIR = $(CROSS_PREFIX)/i686/bin |
| ARCH_SOURCES += arch/$(UARCH)/src/syscall.S \ |
| arch/$(UARCH)/src/fibril.S \ |
| arch/$(UARCH)/src/tls.c \ |
| arch/$(UARCH)/src/setjmp.S |
| LFLAGS += -N |
| ENDIANESS = LE |
| BFD_NAME = elf32-i386 |
| BFD_ARCH = i386 |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/_link.ld.in |
|---|
| 0,0 → 1,46 |
| STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o) |
| ENTRY(__entry) |
| PHDRS { |
| text PT_LOAD FLAGS(5); |
| data PT_LOAD FLAGS(6); |
| } |
| SECTIONS { |
| . = 0x1000 + SIZEOF_HEADERS; |
| .init : { |
| *(.init); |
| } :text |
| .text : { |
| *(.text); |
| *(.rodata*); |
| } :text |
| . = . + 0x1000; |
| .data : { |
| *(.data); |
| } :data |
| .tdata : { |
| _tdata_start = .; |
| *(.tdata); |
| _tdata_end = .; |
| _tbss_start = .; |
| *(.tbss); |
| _tbss_end = .; |
| } :data |
| _tls_alignment = ALIGNOF(.tdata); |
| .bss : { |
| *(COMMON); |
| *(.bss); |
| } :data |
| . = ALIGN(0x1000); |
| _heap = .; |
| /DISCARD/ : { |
| *(*); |
| } |
| } |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/src/syscall.S |
|---|
| 0,0 → 1,90 |
| # |
| # Copyright (c) 2007 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| /** Syscall wrapper - INT $0x30 version. |
| * |
| * Mind the order of arguments. First two arguments and the syscall number go to |
| * scratch registers. An optimized version of this wrapper for fewer arguments |
| * could benefit from this and not save unused registers on the stack. |
| */ |
| .global __syscall_int |
| __syscall_int: |
| pushl %ebx |
| pushl %esi |
| pushl %edi |
| pushl %ebp |
| movl 20(%esp), %edx # First argument. |
| movl 24(%esp), %ecx # Second argument. |
| movl 28(%esp), %ebx # Third argument. |
| movl 32(%esp), %esi # Fourth argument. |
| movl 36(%esp), %edi # Fifth argument. |
| movl 40(%esp), %ebp # Sixth argument. |
| movl 44(%esp), %eax # Syscall number. |
| int $0x30 |
| popl %ebp |
| popl %edi |
| popl %esi |
| popl %ebx |
| ret |
| /** Syscall wrapper - SYSENTER version. |
| * |
| * This is an optimized version of syscall for four or less arguments. Note |
| * that EBP and EDI are used to remember user stack address and the return |
| * address. The kernel part doesn't save DS, ES and FS so the handler restores |
| * these to the selector immediately following CS (it must be the flat data |
| * segment, otherwise the SYSENTER wouldn't work in the first place). |
| */ |
| .global __syscall_sysenter |
| __syscall_sysenter: |
| pushl %ebx |
| pushl %esi |
| pushl %edi |
| pushl %ebp |
| mov %esp, %ebp |
| lea ra, %edi |
| movl 20(%esp), %edx # First argument. |
| movl 24(%esp), %ecx # Second argument. |
| movl 28(%esp), %ebx # Third argument. |
| movl 32(%esp), %esi # Fourth argument. |
| movl 44(%esp), %eax # Syscall number. |
| sysenter |
| ra: |
| movw %cs, %cx |
| addw $8, %cx |
| movw %cx, %ds |
| movw %cx, %es |
| movw %cx, %fs |
| popl %ebp |
| popl %edi |
| popl %esi |
| popl %ebx |
| ret |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/src/entry.s |
|---|
| 0,0 → 1,50 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .section .init, "ax" |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # %ebx contains the PCB pointer |
| # |
| __entry: |
| mov %ss, %ax |
| mov %ax, %ds |
| mov %ax, %es |
| mov %ax, %fs |
| # Do not set %gs, it contains descriptor that can see TLS |
| # Pass the PCB pointer to __main as the first argument |
| pushl %ebx |
| call __main |
| call __exit |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/src/setjmp.S |
|---|
| 0,0 → 1,57 |
| # |
| # Copyright (c) 2008 Josef Cejka |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| #include <kernel/arch/context_offset.h> |
| .text |
| .global setjmp |
| .global longjmp |
| .type setjmp,@function |
| setjmp: |
| movl 0(%esp),%eax # save pc value into eax |
| movl 4(%esp),%edx # address of the jmp_buf structure to save context to |
| # save registers to the jmp_buf structure |
| CONTEXT_SAVE_ARCH_CORE %edx %eax |
| xorl %eax,%eax # set_jmp returns 0 |
| ret |
| .type longjmp,@function |
| longjmp: |
| movl 4(%esp), %ecx # put address of jmp_buf into ecx |
| movl 8(%esp), %eax # put return value into eax |
| # restore registers from the jmp_buf structure |
| CONTEXT_RESTORE_ARCH_CORE %ecx %edx |
| movl %edx,0(%esp) # put saved pc on stack |
| ret |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/src/fibril.S |
|---|
| 0,0 → 1,79 |
| # |
| # Copyright (c) 2001-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| #include <kernel/arch/context_offset.h> |
| .text |
| .global context_save |
| .global context_restore |
| ## Save current CPU context |
| # |
| # Save CPU context to the context_t variable |
| # pointed by the 1st argument. Returns 1 in EAX. |
| # |
| context_save: |
| movl 0(%esp),%eax # the caller's return %eip |
| movl 4(%esp),%edx # address of the context variable to save context to |
| # save registers to the context structure |
| CONTEXT_SAVE_ARCH_CORE %edx %eax |
| # Save TLS |
| movl %gs:0, %eax |
| movl %eax, OFFSET_TLS(%edx) # tls -> ctx->tls |
| xorl %eax,%eax # context_save returns 1 |
| incl %eax |
| ret |
| ## Restore saved CPU context |
| # |
| # Restore CPU context from context_t variable |
| # pointed by the 1st argument. Returns 0 in EAX. |
| # |
| context_restore: |
| movl 4(%esp),%eax # address of the context variable to restore context from |
| # restore registers from the context structure |
| CONTEXT_RESTORE_ARCH_CORE %eax %edx |
| movl %edx,0(%esp) # ctx->pc -> saver's return %eip |
| # Set thread local storage |
| pushl %edx |
| movl OFFSET_TLS(%eax), %edx # Set arg1 to TLS addr |
| movl $1, %eax # Syscall SYS_TLS_SET |
| int $0x30 |
| popl %edx |
| xorl %eax,%eax # context_restore returns 0 |
| ret |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/src/tls.c |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (c) 2006 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libcamd64 amd64 |
| * @ingroup lc |
| * @{ |
| */ |
| /** @file |
| * @ingroup libcia32 |
| */ |
| #include <tls.h> |
| #include <sys/types.h> |
| tcb_t * __alloc_tls(void **data, size_t size) |
| { |
| return tls_alloc_variant_2(data, size); |
| } |
| void __free_tls_arch(tcb_t *tcb, size_t size) |
| { |
| tls_free_variant_2(tcb, size); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libc/arch/ia32/src/thread_entry.s |
|---|
| 0,0 → 1,53 |
| # |
| # Copyright (c) 2006 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .globl __thread_entry |
| ## User-space thread entry point for all but the first threads. |
| # |
| # |
| __thread_entry: |
| mov %ss, %dx |
| mov %dx, %ds |
| mov %dx, %es |
| mov %dx, %fs |
| # Do not set %gs, it contains descriptor that can see TLS |
| # |
| # EAX contains address of uarg. |
| # |
| pushl %eax |
| call __thread_main |
| # |
| # Not reached. |
| # |
| .end __thread_entry |
| /tags/0.4.1/uspace/lib/libc/Makefile |
|---|
| 0,0 → 1,127 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Common compiler flags |
| # |
| LIBC_PREFIX = $(shell pwd) |
| SOFTINT_PREFIX = ../softint |
| ## Setup toolchain |
| # |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| ## Sources |
| # |
| GENERIC_SOURCES = \ |
| generic/libc.c \ |
| generic/ddi.c \ |
| generic/as.c \ |
| generic/cap.c \ |
| generic/devmap.c \ |
| generic/event.c \ |
| generic/errno.c \ |
| generic/mem.c \ |
| generic/string.c \ |
| generic/fibril.c \ |
| generic/fibril_sync.c \ |
| generic/pcb.c \ |
| generic/smc.c \ |
| generic/thread.c \ |
| generic/tls.c \ |
| generic/task.c \ |
| generic/futex.c \ |
| generic/io/asprintf.c \ |
| generic/io/io.c \ |
| generic/io/printf.c \ |
| generic/io/klog.c \ |
| generic/io/snprintf.c \ |
| generic/io/vprintf.c \ |
| generic/io/vsnprintf.c \ |
| generic/io/printf_core.c \ |
| generic/io/console.c \ |
| generic/malloc.c \ |
| generic/sysinfo.c \ |
| generic/ipc.c \ |
| generic/async.c \ |
| generic/loader.c \ |
| generic/getopt.c \ |
| generic/adt/list.o \ |
| generic/adt/hash_table.o \ |
| generic/time.c \ |
| generic/err.c \ |
| generic/stdlib.c \ |
| generic/mman.c \ |
| generic/udebug.c \ |
| generic/vfs/vfs.c \ |
| generic/vfs/canonify.c |
| ARCH_SOURCES += \ |
| arch/$(UARCH)/src/entry.s \ |
| arch/$(UARCH)/src/thread_entry.s |
| GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES))) |
| ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES))) |
| OBJECTS := $(GENERIC_OBJECTS) $(ARCH_OBJECTS) |
| .PHONY: all clean depend kerninc |
| all: kerninc libc.a arch/$(UARCH)/_link.ld |
| kerninc: |
| ln -sfn ../../../../kernel/generic/include include/kernel |
| ln -sfn kernel/arch include/arch |
| ln -sfn ../arch/$(UARCH)/include include/libarch |
| -include Makefile.depend |
| clean: |
| -rm -f include/kernel include/arch include/libarch libc.a arch/$(UARCH)/_link.ld Makefile.depend |
| find generic/ arch/$(UARCH)/ -name '*.o' -follow -exec rm \{\} \; |
| depend: kerninc |
| -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null |
| libc.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| $(AR) rc libc.a $(LIBS) $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| arch/$(UARCH)/_link.ld: arch/$(UARCH)/_link.ld.in |
| $(CC) $(DEFS) $(CFLAGS) -DLIBC_PREFIX=$(LIBC_PREFIX) -E -x c $< | grep -v "^\#" > $@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.s |
| $(AS) $(AFLAGS) $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.1/uspace/lib/libc/Makefile.toolchain |
|---|
| 0,0 → 1,94 |
| # |
| # Copyright (C) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| CFLAGS = -I$(LIBC_PREFIX)/include -O3 -imacros $(LIBC_PREFIX)/../../../config.h \ |
| -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \ |
| -finput-charset=UTF-8 -fno-builtin -Wall -Wextra -Wno-unused-parameter \ |
| -Wmissing-prototypes -Werror-implicit-function-declaration -nostdlib \ |
| -nostdinc -pipe -g -D__$(ENDIANESS)__ |
| LFLAGS = -M -N $(SOFTINT_PREFIX)/libsoftint.a |
| AFLAGS = |
| ## Cross-toolchain prefix |
| # |
| ifndef CROSS_PREFIX |
| CROSS_PREFIX = /usr/local |
| endif |
| ## Setup platform configuration |
| # |
| -include $(LIBC_PREFIX)/../../../Makefile.config |
| -include $(LIBC_PREFIX)/../../../config.defs |
| -include $(LIBC_PREFIX)/arch/$(UARCH)/Makefile.inc |
| ## Simple detection of the host system |
| # |
| HOST = $(shell uname) |
| ## On Solaris, some utilities have different names |
| # |
| ifeq ($(HOST),SunOS) |
| BINUTILS_PREFIX = "g" |
| else |
| BINUTILS_PREFIX = "" |
| endif |
| ## Toolchain configuration |
| # |
| ifeq ($(COMPILER),gcc_native) |
| CC = gcc |
| AS = $(BINUTILS_PREFIX)as |
| LD = $(BINUTILS_PREFIX)ld |
| AR = $(BINUTILS_PREFIX)ar |
| OBJCOPY = $(BINUTILS_PREFIX)objcopy |
| OBJDUMP = $(BINUTILS_PREFIX)objdump |
| DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS) |
| endif |
| ifeq ($(COMPILER),icc_native) |
| CC = icc |
| AS = as |
| LD = ld |
| AR = ar |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS) |
| endif |
| ifeq ($(COMPILER),gcc_cross) |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| AR = $(TOOLCHAIN_DIR)/$(TARGET)-ar |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS) |
| endif |
| /tags/0.4.1/uspace/lib/libblock/libblock.c |
|---|
| 0,0 → 1,604 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * Copyright (c) 2008 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libblock |
| * @{ |
| */ |
| /** |
| * @file |
| * @brief |
| */ |
| #include "libblock.h" |
| #include "../../srv/vfs/vfs.h" |
| #include <ipc/devmap.h> |
| #include <ipc/bd.h> |
| #include <ipc/services.h> |
| #include <errno.h> |
| #include <sys/mman.h> |
| #include <async.h> |
| #include <ipc/ipc.h> |
| #include <as.h> |
| #include <assert.h> |
| #include <fibril_sync.h> |
| #include <adt/list.h> |
| #include <adt/hash_table.h> |
| #include <mem.h> |
| /** Lock protecting the device connection list */ |
| static FIBRIL_MUTEX_INITIALIZE(dcl_lock); |
| /** Device connection list head. */ |
| static LIST_INITIALIZE(dcl_head); |
| #define CACHE_BUCKETS_LOG2 10 |
| #define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2) |
| typedef struct { |
| fibril_mutex_t lock; |
| size_t block_size; /**< Block size. */ |
| unsigned block_count; /**< Total number of blocks. */ |
| unsigned blocks_cached; /**< Number of cached blocks. */ |
| hash_table_t block_hash; |
| link_t free_head; |
| enum cache_mode mode; |
| } cache_t; |
| typedef struct { |
| link_t link; |
| dev_handle_t dev_handle; |
| int dev_phone; |
| fibril_mutex_t com_area_lock; |
| void *com_area; |
| size_t com_size; |
| void *bb_buf; |
| off_t bb_off; |
| size_t bb_size; |
| cache_t *cache; |
| } devcon_t; |
| static int read_block(devcon_t *devcon, bn_t boff, size_t block_size); |
| static int write_block(devcon_t *devcon, bn_t boff, size_t block_size); |
| static devcon_t *devcon_search(dev_handle_t dev_handle) |
| { |
| link_t *cur; |
| fibril_mutex_lock(&dcl_lock); |
| for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { |
| devcon_t *devcon = list_get_instance(cur, devcon_t, link); |
| if (devcon->dev_handle == dev_handle) { |
| fibril_mutex_unlock(&dcl_lock); |
| return devcon; |
| } |
| } |
| fibril_mutex_unlock(&dcl_lock); |
| return NULL; |
| } |
| static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area, |
| size_t com_size) |
| { |
| link_t *cur; |
| devcon_t *devcon; |
| devcon = malloc(sizeof(devcon_t)); |
| if (!devcon) |
| return ENOMEM; |
| link_initialize(&devcon->link); |
| devcon->dev_handle = dev_handle; |
| devcon->dev_phone = dev_phone; |
| fibril_mutex_initialize(&devcon->com_area_lock); |
| devcon->com_area = com_area; |
| devcon->com_size = com_size; |
| devcon->bb_buf = NULL; |
| devcon->bb_off = 0; |
| devcon->bb_size = 0; |
| devcon->cache = NULL; |
| fibril_mutex_lock(&dcl_lock); |
| for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { |
| devcon_t *d = list_get_instance(cur, devcon_t, link); |
| if (d->dev_handle == dev_handle) { |
| fibril_mutex_unlock(&dcl_lock); |
| free(devcon); |
| return EEXIST; |
| } |
| } |
| list_append(&devcon->link, &dcl_head); |
| fibril_mutex_unlock(&dcl_lock); |
| return EOK; |
| } |
| static void devcon_remove(devcon_t *devcon) |
| { |
| fibril_mutex_lock(&dcl_lock); |
| list_remove(&devcon->link); |
| fibril_mutex_unlock(&dcl_lock); |
| } |
| int block_init(dev_handle_t dev_handle, size_t com_size) |
| { |
| int rc; |
| int dev_phone; |
| void *com_area; |
| com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE, |
| MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); |
| if (!com_area) { |
| return ENOMEM; |
| } |
| dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING); |
| if (dev_phone < 0) { |
| munmap(com_area, com_size); |
| return dev_phone; |
| } |
| rc = ipc_share_out_start(dev_phone, com_area, |
| AS_AREA_READ | AS_AREA_WRITE); |
| if (rc != EOK) { |
| munmap(com_area, com_size); |
| ipc_hangup(dev_phone); |
| return rc; |
| } |
| rc = devcon_add(dev_handle, dev_phone, com_area, com_size); |
| if (rc != EOK) { |
| munmap(com_area, com_size); |
| ipc_hangup(dev_phone); |
| return rc; |
| } |
| return EOK; |
| } |
| void block_fini(dev_handle_t dev_handle) |
| { |
| devcon_t *devcon = devcon_search(dev_handle); |
| assert(devcon); |
| devcon_remove(devcon); |
| if (devcon->bb_buf) |
| free(devcon->bb_buf); |
| if (devcon->cache) { |
| hash_table_destroy(&devcon->cache->block_hash); |
| free(devcon->cache); |
| } |
| munmap(devcon->com_area, devcon->com_size); |
| ipc_hangup(devcon->dev_phone); |
| free(devcon); |
| } |
| int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size) |
| { |
| void *bb_buf; |
| int rc; |
| devcon_t *devcon = devcon_search(dev_handle); |
| if (!devcon) |
| return ENOENT; |
| if (devcon->bb_buf) |
| return EEXIST; |
| bb_buf = malloc(size); |
| if (!bb_buf) |
| return ENOMEM; |
| fibril_mutex_lock(&devcon->com_area_lock); |
| rc = read_block(devcon, 0, size); |
| if (rc != EOK) { |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| free(bb_buf); |
| return rc; |
| } |
| memcpy(bb_buf, devcon->com_area, size); |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| devcon->bb_buf = bb_buf; |
| devcon->bb_off = off; |
| devcon->bb_size = size; |
| return EOK; |
| } |
| void *block_bb_get(dev_handle_t dev_handle) |
| { |
| devcon_t *devcon = devcon_search(dev_handle); |
| assert(devcon); |
| return devcon->bb_buf; |
| } |
| static hash_index_t cache_hash(unsigned long *key) |
| { |
| return *key & (CACHE_BUCKETS - 1); |
| } |
| static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item) |
| { |
| block_t *b = hash_table_get_instance(item, block_t, hash_link); |
| return b->boff == *key; |
| } |
| static void cache_remove_callback(link_t *item) |
| { |
| } |
| static hash_table_operations_t cache_ops = { |
| .hash = cache_hash, |
| .compare = cache_compare, |
| .remove_callback = cache_remove_callback |
| }; |
| int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks, |
| enum cache_mode mode) |
| { |
| devcon_t *devcon = devcon_search(dev_handle); |
| cache_t *cache; |
| if (!devcon) |
| return ENOENT; |
| if (devcon->cache) |
| return EEXIST; |
| cache = malloc(sizeof(cache_t)); |
| if (!cache) |
| return ENOMEM; |
| fibril_mutex_initialize(&cache->lock); |
| list_initialize(&cache->free_head); |
| cache->block_size = size; |
| cache->block_count = blocks; |
| cache->blocks_cached = 0; |
| cache->mode = mode; |
| if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1, |
| &cache_ops)) { |
| free(cache); |
| return ENOMEM; |
| } |
| devcon->cache = cache; |
| return EOK; |
| } |
| #define CACHE_LO_WATERMARK 10 |
| #define CACHE_HI_WATERMARK 20 |
| static bool cache_can_grow(cache_t *cache) |
| { |
| if (cache->blocks_cached < CACHE_LO_WATERMARK) |
| return true; |
| if (!list_empty(&cache->free_head)) |
| return false; |
| return true; |
| } |
| static void block_initialize(block_t *b) |
| { |
| fibril_mutex_initialize(&b->lock); |
| b->refcnt = 1; |
| b->dirty = false; |
| fibril_rwlock_initialize(&b->contents_lock); |
| link_initialize(&b->free_link); |
| link_initialize(&b->hash_link); |
| } |
| /** Instantiate a block in memory and get a reference to it. |
| * |
| * @param dev_handle Device handle of the block device. |
| * @param boff Block offset. |
| * @param flags If BLOCK_FLAGS_NOREAD is specified, block_get() |
| * will not read the contents of the block from the |
| * device. |
| * |
| * @return Block structure. |
| */ |
| block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags) |
| { |
| devcon_t *devcon; |
| cache_t *cache; |
| block_t *b; |
| link_t *l; |
| unsigned long key = boff; |
| bn_t oboff; |
| devcon = devcon_search(dev_handle); |
| assert(devcon); |
| assert(devcon->cache); |
| cache = devcon->cache; |
| fibril_mutex_lock(&cache->lock); |
| l = hash_table_find(&cache->block_hash, &key); |
| if (l) { |
| /* |
| * We found the block in the cache. |
| */ |
| b = hash_table_get_instance(l, block_t, hash_link); |
| fibril_mutex_lock(&b->lock); |
| if (b->refcnt++ == 0) |
| list_remove(&b->free_link); |
| fibril_mutex_unlock(&b->lock); |
| fibril_mutex_unlock(&cache->lock); |
| } else { |
| /* |
| * The block was not found in the cache. |
| */ |
| int rc; |
| bool sync = false; |
| if (cache_can_grow(cache)) { |
| /* |
| * We can grow the cache by allocating new blocks. |
| * Should the allocation fail, we fail over and try to |
| * recycle a block from the cache. |
| */ |
| b = malloc(sizeof(block_t)); |
| if (!b) |
| goto recycle; |
| b->data = malloc(cache->block_size); |
| if (!b->data) { |
| free(b); |
| goto recycle; |
| } |
| cache->blocks_cached++; |
| } else { |
| /* |
| * Try to recycle a block from the free list. |
| */ |
| unsigned long temp_key; |
| recycle: |
| assert(!list_empty(&cache->free_head)); |
| l = cache->free_head.next; |
| list_remove(l); |
| b = list_get_instance(l, block_t, free_link); |
| sync = b->dirty; |
| oboff = b->boff; |
| temp_key = b->boff; |
| hash_table_remove(&cache->block_hash, &temp_key, 1); |
| } |
| block_initialize(b); |
| b->dev_handle = dev_handle; |
| b->size = cache->block_size; |
| b->boff = boff; |
| hash_table_insert(&cache->block_hash, &key, &b->hash_link); |
| /* |
| * Lock the block before releasing the cache lock. Thus we don't |
| * kill concurent operations on the cache while doing I/O on the |
| * block. |
| */ |
| fibril_mutex_lock(&b->lock); |
| fibril_mutex_unlock(&cache->lock); |
| if (sync) { |
| /* |
| * The block is dirty and needs to be written back to |
| * the device before we can read in the new contents. |
| */ |
| fibril_mutex_lock(&devcon->com_area_lock); |
| memcpy(devcon->com_area, b->data, b->size); |
| rc = write_block(devcon, oboff, cache->block_size); |
| assert(rc == EOK); |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| } |
| if (!(flags & BLOCK_FLAGS_NOREAD)) { |
| /* |
| * The block contains old or no data. We need to read |
| * the new contents from the device. |
| */ |
| fibril_mutex_lock(&devcon->com_area_lock); |
| rc = read_block(devcon, b->boff, cache->block_size); |
| assert(rc == EOK); |
| memcpy(b->data, devcon->com_area, cache->block_size); |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| } |
| fibril_mutex_unlock(&b->lock); |
| } |
| return b; |
| } |
| /** Release a reference to a block. |
| * |
| * If the last reference is dropped, the block is put on the free list. |
| * |
| * @param block Block of which a reference is to be released. |
| */ |
| void block_put(block_t *block) |
| { |
| devcon_t *devcon = devcon_search(block->dev_handle); |
| cache_t *cache; |
| int rc; |
| assert(devcon); |
| assert(devcon->cache); |
| cache = devcon->cache; |
| fibril_mutex_lock(&cache->lock); |
| fibril_mutex_lock(&block->lock); |
| if (!--block->refcnt) { |
| /* |
| * Last reference to the block was dropped. Either free the |
| * block or put it on the free list. |
| */ |
| if (cache->blocks_cached > CACHE_HI_WATERMARK) { |
| /* |
| * Currently there are too many cached blocks. |
| */ |
| if (block->dirty) { |
| fibril_mutex_lock(&devcon->com_area_lock); |
| memcpy(devcon->com_area, block->data, |
| block->size); |
| rc = write_block(devcon, block->boff, |
| block->size); |
| assert(rc == EOK); |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| } |
| /* |
| * Take the block out of the cache and free it. |
| */ |
| unsigned long key = block->boff; |
| hash_table_remove(&cache->block_hash, &key, 1); |
| free(block); |
| free(block->data); |
| cache->blocks_cached--; |
| fibril_mutex_unlock(&cache->lock); |
| return; |
| } |
| /* |
| * Put the block on the free list. |
| */ |
| list_append(&block->free_link, &cache->free_head); |
| if (cache->mode != CACHE_MODE_WB && block->dirty) { |
| fibril_mutex_lock(&devcon->com_area_lock); |
| memcpy(devcon->com_area, block->data, block->size); |
| rc = write_block(devcon, block->boff, block->size); |
| assert(rc == EOK); |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| block->dirty = false; |
| } |
| } |
| fibril_mutex_unlock(&block->lock); |
| fibril_mutex_unlock(&cache->lock); |
| } |
| /** Read sequential data from a block device. |
| * |
| * @param dev_handle Device handle of the block device. |
| * @param bufpos Pointer to the first unread valid offset within the |
| * communication buffer. |
| * @param buflen Pointer to the number of unread bytes that are ready in |
| * the communication buffer. |
| * @param pos Device position to be read. |
| * @param dst Destination buffer. |
| * @param size Size of the destination buffer. |
| * @param block_size Block size to be used for the transfer. |
| * |
| * @return EOK on success or a negative return code on failure. |
| */ |
| int block_seqread(dev_handle_t dev_handle, off_t *bufpos, size_t *buflen, |
| off_t *pos, void *dst, size_t size, size_t block_size) |
| { |
| off_t offset = 0; |
| size_t left = size; |
| devcon_t *devcon = devcon_search(dev_handle); |
| assert(devcon); |
| fibril_mutex_lock(&devcon->com_area_lock); |
| while (left > 0) { |
| size_t rd; |
| if (*bufpos + left < *buflen) |
| rd = left; |
| else |
| rd = *buflen - *bufpos; |
| if (rd > 0) { |
| /* |
| * Copy the contents of the communication buffer to the |
| * destination buffer. |
| */ |
| memcpy(dst + offset, devcon->com_area + *bufpos, rd); |
| offset += rd; |
| *bufpos += rd; |
| *pos += rd; |
| left -= rd; |
| } |
| if (*bufpos == (off_t) *buflen) { |
| /* Refill the communication buffer with a new block. */ |
| int rc; |
| rc = read_block(devcon, *pos / block_size, block_size); |
| if (rc != EOK) { |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| return rc; |
| } |
| *bufpos = 0; |
| *buflen = block_size; |
| } |
| } |
| fibril_mutex_unlock(&devcon->com_area_lock); |
| return EOK; |
| } |
| /** Read block from block device. |
| * |
| * @param devcon Device connection. |
| * @param boff Block index. |
| * @param block_size Block size. |
| * @param src Buffer for storing the data. |
| * |
| * @return EOK on success or negative error code on failure. |
| */ |
| static int read_block(devcon_t *devcon, bn_t boff, size_t block_size) |
| { |
| ipcarg_t retval; |
| int rc; |
| assert(devcon); |
| rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK, boff, block_size, |
| &retval); |
| if ((rc != EOK) || (retval != EOK)) |
| return (rc != EOK ? rc : (int) retval); |
| return EOK; |
| } |
| /** Write block to block device. |
| * |
| * @param devcon Device connection. |
| * @param boff Block index. |
| * @param block_size Block size. |
| * @param src Buffer containing the data to write. |
| * |
| * @return EOK on success or negative error code on failure. |
| */ |
| static int write_block(devcon_t *devcon, bn_t boff, size_t block_size) |
| { |
| ipcarg_t retval; |
| int rc; |
| assert(devcon); |
| rc = async_req_2_1(devcon->dev_phone, BD_WRITE_BLOCK, boff, block_size, |
| &retval); |
| if ((rc != EOK) || (retval != EOK)) |
| return (rc != EOK ? rc : (int) retval); |
| return EOK; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libblock/libblock.h |
|---|
| 0,0 → 1,113 |
| /* |
| * Copyright (c) 2008 Jakub Jermar |
| * Copyright (c) 2008 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libblock |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBBLOCK_LIBBLOCK_H_ |
| #define LIBBLOCK_LIBBLOCK_H_ |
| #include <stdint.h> |
| #include "../../srv/vfs/vfs.h" |
| #include <fibril_sync.h> |
| #include <adt/hash_table.h> |
| #include <adt/list.h> |
| /* |
| * Flags that can be used with block_get(). |
| */ |
| /** |
| * This macro is a symbolic value for situations where no special flags are |
| * needed. |
| */ |
| #define BLOCK_FLAGS_NONE 0 |
| /** |
| * When the client of block_get() intends to overwrite the current contents of |
| * the block, this flag is used to avoid the unnecessary read. |
| */ |
| #define BLOCK_FLAGS_NOREAD 1 |
| typedef unsigned bn_t; /**< Block number type. */ |
| typedef struct block { |
| /** Mutex protecting the reference count. */ |
| fibril_mutex_t lock; |
| /** Number of references to the block_t structure. */ |
| unsigned refcnt; |
| /** If true, the block needs to be written back to the block device. */ |
| bool dirty; |
| /** Readers / Writer lock protecting the contents of the block. */ |
| fibril_rwlock_t contents_lock; |
| /** Handle of the device where the block resides. */ |
| dev_handle_t dev_handle; |
| /** Block offset on the block device. Counted in 'size'-byte blocks. */ |
| bn_t boff; |
| /** Size of the block. */ |
| size_t size; |
| /** Link for placing the block into the free block list. */ |
| link_t free_link; |
| /** Link for placing the block into the block hash table. */ |
| link_t hash_link; |
| /** Buffer with the block data. */ |
| void *data; |
| } block_t; |
| /** Caching mode */ |
| enum cache_mode { |
| /** Write-Through */ |
| CACHE_MODE_WT, |
| /** Write-Back */ |
| CACHE_MODE_WB |
| }; |
| extern int block_init(dev_handle_t, size_t); |
| extern void block_fini(dev_handle_t); |
| extern int block_bb_read(dev_handle_t, off_t, size_t); |
| extern void *block_bb_get(dev_handle_t); |
| extern int block_cache_init(dev_handle_t, size_t, unsigned, enum cache_mode); |
| extern block_t *block_get(dev_handle_t, bn_t, int); |
| extern void block_put(block_t *); |
| extern int block_seqread(dev_handle_t, off_t *, size_t *, off_t *, void *, |
| size_t, size_t); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libblock/Makefile |
|---|
| 0,0 → 1,67 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # Copyright (c) 2007 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Common compiler flags |
| # |
| LIBC_PREFIX = ../libc |
| ## Setup toolchain |
| # |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -Iinclude |
| ## Sources |
| # |
| SOURCES = \ |
| libblock.c |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| .PHONY: all clean depend |
| all: libblock.a |
| -include Makefile.depend |
| clean: |
| -rm -f libblock.a Makefile.depend |
| find . -name '*.o' -follow -exec rm \{\} \; |
| depend: |
| -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| libblock.a: depend $(OBJECTS) |
| $(AR) rc libblock.a $(OBJECTS) |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.1/uspace/lib/libfs/libfs.c |
|---|
| 0,0 → 1,490 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libfs |
| * @{ |
| */ |
| /** |
| * @file |
| * Glue code which is commonod to all FS implementations. |
| */ |
| #include "libfs.h" |
| #include "../../srv/vfs/vfs.h" |
| #include <errno.h> |
| #include <async.h> |
| #include <ipc/ipc.h> |
| #include <as.h> |
| #include <assert.h> |
| #include <dirent.h> |
| #include <mem.h> |
| #include <sys/stat.h> |
| /** Register file system server. |
| * |
| * This function abstracts away the tedious registration protocol from |
| * file system implementations and lets them to reuse this registration glue |
| * code. |
| * |
| * @param vfs_phone Open phone for communication with VFS. |
| * @param reg File system registration structure. It will be |
| * initialized by this function. |
| * @param info VFS info structure supplied by the file system |
| * implementation. |
| * @param conn Connection fibril for handling all calls originating in |
| * VFS. |
| * |
| * @return EOK on success or a non-zero error code on errror. |
| */ |
| int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info, |
| async_client_conn_t conn) |
| { |
| /* |
| * Tell VFS that we are here and want to get registered. |
| * We use the async framework because VFS will answer the request |
| * out-of-order, when it knows that the operation succeeded or failed. |
| */ |
| ipc_call_t answer; |
| aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer); |
| /* |
| * Send our VFS info structure to VFS. |
| */ |
| int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info)); |
| if (rc != EOK) { |
| async_wait_for(req, NULL); |
| return rc; |
| } |
| /* |
| * Ask VFS for callback connection. |
| */ |
| ipc_connect_to_me(vfs_phone, 0, 0, 0, ®->vfs_phonehash); |
| /* |
| * Allocate piece of address space for PLB. |
| */ |
| reg->plb_ro = as_get_mappable_page(PLB_SIZE); |
| if (!reg->plb_ro) { |
| async_wait_for(req, NULL); |
| return ENOMEM; |
| } |
| /* |
| * Request sharing the Path Lookup Buffer with VFS. |
| */ |
| rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE); |
| if (rc) { |
| async_wait_for(req, NULL); |
| return rc; |
| } |
| /* |
| * Pick up the answer for the request to the VFS_IN_REQUEST call. |
| */ |
| async_wait_for(req, NULL); |
| reg->fs_handle = (int) IPC_GET_ARG1(answer); |
| /* |
| * Create a connection fibril to handle the callback connection. |
| */ |
| async_new_connection(reg->vfs_phonehash, 0, NULL, conn); |
| /* |
| * Tell the async framework that other connections are to be handled by |
| * the same connection fibril as well. |
| */ |
| async_set_client_connection(conn); |
| return IPC_GET_RETVAL(answer); |
| } |
| void fs_node_initialize(fs_node_t *fn) |
| { |
| memset(fn, 0, sizeof(fs_node_t)); |
| } |
| void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, |
| ipc_call_t *request) |
| { |
| dev_handle_t mp_dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); |
| fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); |
| fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request); |
| dev_handle_t mr_dev_handle = (dev_handle_t) IPC_GET_ARG4(*request); |
| int res; |
| ipcarg_t rc; |
| ipc_call_t call; |
| ipc_callid_t callid; |
| /* accept the phone */ |
| callid = async_get_call(&call); |
| int mountee_phone = (int)IPC_GET_ARG1(call); |
| if ((IPC_GET_METHOD(call) != IPC_M_CONNECTION_CLONE) || |
| mountee_phone < 0) { |
| ipc_answer_0(callid, EINVAL); |
| ipc_answer_0(rid, EINVAL); |
| return; |
| } |
| ipc_answer_0(callid, EOK); /* acknowledge the mountee_phone */ |
| res = ipc_data_write_receive(&callid, NULL); |
| if (!res) { |
| ipc_hangup(mountee_phone); |
| ipc_answer_0(callid, EINVAL); |
| ipc_answer_0(rid, EINVAL); |
| return; |
| } |
| fs_node_t *fn = ops->node_get(mp_dev_handle, mp_fs_index); |
| if (!fn) { |
| ipc_hangup(mountee_phone); |
| ipc_answer_0(callid, ENOENT); |
| ipc_answer_0(rid, ENOENT); |
| return; |
| } |
| if (fn->mp_data.mp_active) { |
| ipc_hangup(mountee_phone); |
| ops->node_put(fn); |
| ipc_answer_0(callid, EBUSY); |
| ipc_answer_0(rid, EBUSY); |
| return; |
| } |
| rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME); |
| if (rc != 0) { |
| ipc_hangup(mountee_phone); |
| ops->node_put(fn); |
| ipc_answer_0(callid, rc); |
| ipc_answer_0(rid, rc); |
| return; |
| } |
| ipc_call_t answer; |
| aid_t msg = async_send_1(mountee_phone, VFS_OUT_MOUNTED, mr_dev_handle, |
| &answer); |
| ipc_forward_fast(callid, mountee_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); |
| async_wait_for(msg, &rc); |
| if (rc == EOK) { |
| fn->mp_data.mp_active = true; |
| fn->mp_data.fs_handle = mr_fs_handle; |
| fn->mp_data.dev_handle = mr_dev_handle; |
| fn->mp_data.phone = mountee_phone; |
| } |
| /* |
| * Do not release the FS node so that it stays in memory. |
| */ |
| ipc_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer), |
| IPC_GET_ARG3(answer)); |
| } |
| /** Lookup VFS triplet by name in the file system name space. |
| * |
| * The path passed in the PLB must be in the canonical file system path format |
| * as returned by the canonify() function. |
| * |
| * @param ops libfs operations structure with function pointers to |
| * file system implementation |
| * @param fs_handle File system handle of the file system where to perform |
| * the lookup. |
| * @param rid Request ID of the VFS_OUT_LOOKUP request. |
| * @param request VFS_OUT_LOOKUP request data itself. |
| * |
| */ |
| void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, |
| ipc_call_t *request) |
| { |
| unsigned first = IPC_GET_ARG1(*request); |
| unsigned last = IPC_GET_ARG2(*request); |
| unsigned next = first; |
| dev_handle_t dev_handle = IPC_GET_ARG3(*request); |
| int lflag = IPC_GET_ARG4(*request); |
| fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */ |
| char component[NAME_MAX + 1]; |
| int len; |
| if (last < next) |
| last += PLB_SIZE; |
| fs_node_t *par = NULL; |
| fs_node_t *cur = ops->root_get(dev_handle); |
| fs_node_t *tmp = NULL; |
| if (cur->mp_data.mp_active) { |
| ipc_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, |
| next, last, cur->mp_data.dev_handle, lflag, index, |
| IPC_FF_ROUTE_FROM_ME); |
| ops->node_put(cur); |
| return; |
| } |
| if (ops->plb_get_char(next) == '/') |
| next++; /* eat slash */ |
| while (next <= last && ops->has_children(cur)) { |
| /* collect the component */ |
| len = 0; |
| while ((next <= last) && (ops->plb_get_char(next) != '/')) { |
| if (len + 1 == NAME_MAX) { |
| /* component length overflow */ |
| ipc_answer_0(rid, ENAMETOOLONG); |
| goto out; |
| } |
| component[len++] = ops->plb_get_char(next); |
| next++; /* process next character */ |
| } |
| assert(len); |
| component[len] = '\0'; |
| next++; /* eat slash */ |
| /* match the component */ |
| tmp = ops->match(cur, component); |
| if (tmp && tmp->mp_data.mp_active) { |
| if (next > last) |
| next = last = first; |
| else |
| next--; |
| ipc_forward_slow(rid, tmp->mp_data.phone, |
| VFS_OUT_LOOKUP, next, last, tmp->mp_data.dev_handle, |
| lflag, index, IPC_FF_ROUTE_FROM_ME); |
| ops->node_put(cur); |
| ops->node_put(tmp); |
| if (par) |
| ops->node_put(par); |
| return; |
| } |
| /* handle miss: match amongst siblings */ |
| if (!tmp) { |
| if (next <= last) { |
| /* there are unprocessed components */ |
| ipc_answer_0(rid, ENOENT); |
| goto out; |
| } |
| /* miss in the last component */ |
| if (lflag & (L_CREATE | L_LINK)) { |
| /* request to create a new link */ |
| if (!ops->is_directory(cur)) { |
| ipc_answer_0(rid, ENOTDIR); |
| goto out; |
| } |
| fs_node_t *fn; |
| if (lflag & L_CREATE) |
| fn = ops->create(dev_handle, lflag); |
| else |
| fn = ops->node_get(dev_handle, |
| index); |
| if (fn) { |
| int rc; |
| rc = ops->link(cur, fn, component); |
| if (rc != EOK) { |
| if (lflag & L_CREATE) { |
| (void)ops->destroy(fn); |
| } |
| ipc_answer_0(rid, rc); |
| } else { |
| ipc_answer_5(rid, EOK, |
| fs_handle, dev_handle, |
| ops->index_get(fn), |
| ops->size_get(fn), |
| ops->lnkcnt_get(fn)); |
| ops->node_put(fn); |
| } |
| } else { |
| ipc_answer_0(rid, ENOSPC); |
| } |
| goto out; |
| } |
| ipc_answer_0(rid, ENOENT); |
| goto out; |
| } |
| if (par) |
| ops->node_put(par); |
| /* descend one level */ |
| par = cur; |
| cur = tmp; |
| tmp = NULL; |
| } |
| /* handle miss: excessive components */ |
| if (next <= last && !ops->has_children(cur)) { |
| if (lflag & (L_CREATE | L_LINK)) { |
| if (!ops->is_directory(cur)) { |
| ipc_answer_0(rid, ENOTDIR); |
| goto out; |
| } |
| /* collect next component */ |
| len = 0; |
| while (next <= last) { |
| if (ops->plb_get_char(next) == '/') { |
| /* more than one component */ |
| ipc_answer_0(rid, ENOENT); |
| goto out; |
| } |
| if (len + 1 == NAME_MAX) { |
| /* component length overflow */ |
| ipc_answer_0(rid, ENAMETOOLONG); |
| goto out; |
| } |
| component[len++] = ops->plb_get_char(next); |
| next++; /* process next character */ |
| } |
| assert(len); |
| component[len] = '\0'; |
| fs_node_t *fn; |
| if (lflag & L_CREATE) |
| fn = ops->create(dev_handle, lflag); |
| else |
| fn = ops->node_get(dev_handle, index); |
| if (fn) { |
| int rc; |
| rc = ops->link(cur, fn, component); |
| if (rc != EOK) { |
| if (lflag & L_CREATE) |
| (void)ops->destroy(fn); |
| ipc_answer_0(rid, rc); |
| } else { |
| ipc_answer_5(rid, EOK, |
| fs_handle, dev_handle, |
| ops->index_get(fn), |
| ops->size_get(fn), |
| ops->lnkcnt_get(fn)); |
| ops->node_put(fn); |
| } |
| } else { |
| ipc_answer_0(rid, ENOSPC); |
| } |
| goto out; |
| } |
| ipc_answer_0(rid, ENOENT); |
| goto out; |
| } |
| /* handle hit */ |
| if (lflag & L_UNLINK) { |
| unsigned old_lnkcnt = ops->lnkcnt_get(cur); |
| int res = ops->unlink(par, cur, component); |
| ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle, |
| ops->index_get(cur), ops->size_get(cur), old_lnkcnt); |
| goto out; |
| } |
| if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) || |
| (lflag & L_LINK)) { |
| ipc_answer_0(rid, EEXIST); |
| goto out; |
| } |
| if ((lflag & L_FILE) && (ops->is_directory(cur))) { |
| ipc_answer_0(rid, EISDIR); |
| goto out; |
| } |
| if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) { |
| ipc_answer_0(rid, ENOTDIR); |
| goto out; |
| } |
| ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur), |
| ops->size_get(cur), ops->lnkcnt_get(cur)); |
| out: |
| if (par) |
| ops->node_put(par); |
| if (cur) |
| ops->node_put(cur); |
| if (tmp) |
| ops->node_put(tmp); |
| } |
| void libfs_stat(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, |
| ipc_call_t *request) |
| { |
| dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); |
| fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); |
| fs_node_t *fn = ops->node_get(dev_handle, index); |
| ipc_callid_t callid; |
| size_t size; |
| if (!ipc_data_read_receive(&callid, &size) || |
| size != sizeof(struct stat)) { |
| ipc_answer_0(callid, EINVAL); |
| ipc_answer_0(rid, EINVAL); |
| return; |
| } |
| struct stat stat; |
| memset(&stat, 0, sizeof(struct stat)); |
| stat.fs_handle = fs_handle; |
| stat.dev_handle = dev_handle; |
| stat.index = index; |
| stat.lnkcnt = ops->lnkcnt_get(fn); |
| stat.is_file = ops->is_file(fn); |
| stat.size = ops->size_get(fn); |
| ipc_data_read_finalize(callid, &stat, sizeof(struct stat)); |
| ipc_answer_0(rid, EOK); |
| } |
| /** Open VFS triplet. |
| * |
| * @param ops libfs operations structure with function pointers to |
| * file system implementation |
| * @param rid Request ID of the VFS_OUT_OPEN_NODE request. |
| * @param request VFS_OUT_OPEN_NODE request data itself. |
| * |
| */ |
| void libfs_open_node(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, |
| ipc_call_t *request) |
| { |
| dev_handle_t dev_handle = IPC_GET_ARG1(*request); |
| fs_index_t index = IPC_GET_ARG2(*request); |
| fs_node_t *node = ops->node_get(dev_handle, index); |
| if (node == NULL) { |
| ipc_answer_0(rid, ENOENT); |
| return; |
| } |
| ipc_answer_5(rid, EOK, fs_handle, dev_handle, index, |
| ops->size_get(node), ops->lnkcnt_get(node)); |
| ops->node_put(node); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libfs/libfs.h |
|---|
| 0,0 → 1,94 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup libfs |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef LIBFS_LIBFS_H_ |
| #define LIBFS_LIBFS_H_ |
| #include <ipc/vfs.h> |
| #include <stdint.h> |
| #include <ipc/ipc.h> |
| #include <async.h> |
| #include <devmap.h> |
| typedef struct { |
| bool mp_active; |
| int phone; |
| fs_handle_t fs_handle; |
| dev_handle_t dev_handle; |
| } mp_data_t; |
| typedef struct { |
| mp_data_t mp_data; /**< Mount point info. */ |
| void *data; /**< Data of the file system implementation. */ |
| } fs_node_t; |
| typedef struct { |
| fs_node_t * (* match)(fs_node_t *, const char *); |
| fs_node_t * (* node_get)(dev_handle_t, fs_index_t); |
| void (* node_put)(fs_node_t *); |
| fs_node_t * (* create)(dev_handle_t, int); |
| int (* destroy)(fs_node_t *); |
| int (* link)(fs_node_t *, fs_node_t *, const char *); |
| int (* unlink)(fs_node_t *, fs_node_t *, const char *); |
| fs_index_t (* index_get)(fs_node_t *); |
| size_t (* size_get)(fs_node_t *); |
| unsigned (* lnkcnt_get)(fs_node_t *); |
| bool (* has_children)(fs_node_t *); |
| fs_node_t *(* root_get)(dev_handle_t); |
| char (* plb_get_char)(unsigned pos); |
| bool (* is_directory)(fs_node_t *); |
| bool (* is_file)(fs_node_t *); |
| } libfs_ops_t; |
| typedef struct { |
| int fs_handle; /**< File system handle. */ |
| ipcarg_t vfs_phonehash; /**< Initial VFS phonehash. */ |
| uint8_t *plb_ro; /**< Read-only PLB view. */ |
| } fs_reg_t; |
| extern int fs_register(int, fs_reg_t *, vfs_info_t *, async_client_conn_t); |
| extern void fs_node_initialize(fs_node_t *); |
| extern void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); |
| extern void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); |
| extern void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *); |
| extern void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t, |
| ipc_call_t *); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/libfs/Makefile |
|---|
| 0,0 → 1,67 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # Copyright (c) 2007 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Common compiler flags |
| # |
| LIBC_PREFIX = ../libc |
| ## Setup toolchain |
| # |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -Iinclude |
| ## Sources |
| # |
| SOURCES = \ |
| libfs.c |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| .PHONY: all clean depend |
| all: libfs.a |
| -include Makefile.depend |
| clean: |
| -rm -f libfs.a Makefile.depend |
| find . -name '*.o' -follow -exec rm \{\} \; |
| depend: |
| -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(SOURCES) > Makefile.depend 2> /dev/null |
| libfs.a: depend $(OBJECTS) |
| $(AR) rc libfs.a $(OBJECTS) |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.1/uspace/lib/softfloat/include/sftypes.h |
|---|
| 0,0 → 1,113 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SFTYPES_H__ |
| #define __SFTYPES_H__ |
| #include <byteorder.h> |
| #include <stdint.h> |
| typedef union { |
| float f; |
| uint32_t binary; |
| struct { |
| #if defined(__BE__) |
| uint32_t sign : 1; |
| uint32_t exp : 8; |
| uint32_t fraction : 23; |
| #elif defined(__LE__) |
| uint32_t fraction : 23; |
| uint32_t exp : 8; |
| uint32_t sign : 1; |
| #else |
| #error Unknown endianess |
| #endif |
| } parts __attribute__ ((packed)); |
| } float32; |
| typedef union { |
| double d; |
| uint64_t binary; |
| struct { |
| #if defined(__BE__) |
| uint64_t sign : 1; |
| uint64_t exp : 11; |
| uint64_t fraction : 52; |
| #elif defined(__LE__) |
| uint64_t fraction : 52; |
| uint64_t exp : 11; |
| uint64_t sign : 1; |
| #else |
| #error Unknown endianess |
| #endif |
| } parts __attribute__ ((packed)); |
| } float64; |
| #define FLOAT32_MAX 0x7f800000 |
| #define FLOAT32_MIN 0xff800000 |
| #define FLOAT64_MAX |
| #define FLOAT64_MIN |
| /* |
| * For recognizing NaNs or infinity use isFloat32NaN and is Float32Inf, |
| * comparing with these constants is not sufficient. |
| */ |
| #define FLOAT32_NAN 0x7FC00001 |
| #define FLOAT32_SIGNAN 0x7F800001 |
| #define FLOAT32_INF 0x7F800000 |
| #define FLOAT64_NAN 0x7FF8000000000001ll |
| #define FLOAT64_SIGNAN 0x7FF0000000000001ll |
| #define FLOAT64_INF 0x7FF0000000000000ll |
| #define FLOAT32_FRACTION_SIZE 23 |
| #define FLOAT64_FRACTION_SIZE 52 |
| #define FLOAT32_HIDDEN_BIT_MASK 0x800000 |
| #define FLOAT64_HIDDEN_BIT_MASK 0x10000000000000ll |
| #define FLOAT32_MAX_EXPONENT 0xFF |
| #define FLOAT64_MAX_EXPONENT 0x7FF |
| #define FLOAT32_BIAS 0x7F |
| #define FLOAT64_BIAS 0x3FF |
| #define FLOAT80_BIAS 0x3FFF |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/sub.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SUB_H__ |
| #define __SUB_H__ |
| float32 subFloat32(float32 a, float32 b); |
| float64 subFloat64(float64 a, float64 b); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/comparison.h |
|---|
| 0,0 → 1,59 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __COMPARISON_H__ |
| #define __COMPARISON_H__ |
| inline int isFloat32NaN(float32 f); |
| inline int isFloat32SigNaN(float32 f); |
| inline int isFloat32Infinity(float32 f); |
| inline int isFloat32Zero(float32 f); |
| inline int isFloat64NaN(float64 d); |
| inline int isFloat64SigNaN(float64 d); |
| inline int isFloat64Infinity(float64 d); |
| inline int isFloat64Zero(float64 d); |
| inline int isFloat32eq(float32 a, float32 b); |
| inline int isFloat32lt(float32 a, float32 b); |
| inline int isFloat32gt(float32 a, float32 b); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/mul.h |
|---|
| 0,0 → 1,49 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __MUL_H__ |
| #define __MUL_H__ |
| float32 mulFloat32(float32 a, float32 b); |
| float64 mulFloat64(float64 a, float64 b); |
| void mul64integers(uint64_t a,uint64_t b, uint64_t *lo, uint64_t *hi); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/other.h |
|---|
| 0,0 → 1,43 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __OTHER_H__ |
| #define __OTHER_H__ |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/softfloat.h |
|---|
| 0,0 → 1,174 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_H__ |
| #define __SOFTFLOAT_H__ |
| float __addsf3(float a, float b); |
| double __adddf3(double a, double b); |
| long double __addtf3(long double a, long double b); |
| long double __addxf3(long double a, long double b); |
| float __subsf3(float a, float b); |
| double __subdf3(double a, double b); |
| long double __subtf3(long double a, long double b); |
| long double __subxf3(long double a, long double b); |
| float __mulsf3(float a, float b); |
| double __muldf3(double a, double b); |
| long double __multf3(long double a, long double b); |
| long double __mulxf3(long double a, long double b); |
| float __divsf3(float a, float b); |
| double __divdf3(double a, double b); |
| long double __divtf3(long double a, long double b); |
| long double __divxf3(long double a, long double b); |
| float __negsf2(float a); |
| double __negdf2(double a); |
| long double __negtf2(long double a); |
| long double __negxf2(long double a); |
| double __extendsfdf2(float a); |
| long double __extendsftf2(float a); |
| long double __extendsfxf2(float a); |
| long double __extenddftf2(double a); |
| long double __extenddfxf2(double a); |
| double __truncxfdf2(long double a); |
| double __trunctfdf2(long double a); |
| float __truncxfsf2(long double a); |
| float __trunctfsf2(long double a); |
| float __truncdfsf2(double a); |
| int __fixsfsi(float a); |
| int __fixdfsi(double a); |
| int __fixtfsi(long double a); |
| int __fixxfsi(long double a); |
| long __fixsfdi(float a); |
| long __fixdfdi(double a); |
| long __fixtfdi(long double a); |
| long __fixxfdi(long double a); |
| long long __fixsfti(float a); |
| long long __fixdfti(double a); |
| long long __fixtfti(long double a); |
| long long __fixxfti(long double a); |
| unsigned int __fixunssfsi(float a); |
| unsigned int __fixunsdfsi(double a); |
| unsigned int __fixunstfsi(long double a); |
| unsigned int __fixunsxfsi(long double a); |
| unsigned long __fixunssfdi(float a); |
| unsigned long __fixunsdfdi(double a); |
| unsigned long __fixunstfdi(long double a); |
| unsigned long __fixunsxfdi(long double a); |
| unsigned long long __fixunssfti(float a); |
| unsigned long long __fixunsdfti(double a); |
| unsigned long long __fixunstfti(long double a); |
| unsigned long long __fixunsxfti(long double a); |
| float __floatsisf(int i); |
| double __floatsidf(int i); |
| long double __floatsitf(int i); |
| long double __floatsixf(int i); |
| float __floatdisf(long i); |
| double __floatdidf(long i); |
| long double __floatditf(long i); |
| long double __floatdixf(long i); |
| float __floattisf(long long i); |
| double __floattidf(long long i); |
| long double __floattitf(long long i); |
| long double __floattixf(long long i); |
| float __floatunsisf(unsigned int i); |
| double __floatunsidf(unsigned int i); |
| long double __floatunsitf(unsigned int i); |
| long double __floatunsixf(unsigned int i); |
| float __floatundisf(unsigned long i); |
| double __floatundidf(unsigned long i); |
| long double __floatunditf(unsigned long i); |
| long double __floatundixf(unsigned long i); |
| float __floatuntisf(unsigned long long i); |
| double __floatuntidf(unsigned long long i); |
| long double __floatuntitf(unsigned long long i); |
| long double __floatuntixf(unsigned long long i); |
| int __cmpsf2(float a, float b); |
| int __cmpdf2(double a, double b); |
| int __cmptf2(long double a, long double b); |
| int __unordsf2(float a, float b); |
| int __unorddf2(double a, double b); |
| int __unordtf2(long double a, long double b); |
| int __eqsf2(float a, float b); |
| int __eqdf2(double a, double b); |
| int __eqtf2(long double a, long double b); |
| int __nesf2(float a, float b); |
| int __nedf2(double a, double b); |
| int __netf2(long double a, long double b); |
| int __gesf2(float a, float b); |
| int __gedf2(double a, double b); |
| int __getf2(long double a, long double b); |
| int __ltsf2(float a, float b); |
| int __ltdf2(double a, double b); |
| int __lttf2(long double a, long double b); |
| int __lesf2(float a, float b); |
| int __ledf2(double a, double b); |
| int __letf2(long double a, long double b); |
| int __gtsf2(float a, float b); |
| int __gtdf2(double a, double b); |
| int __gttf2(long double a, long double b); |
| /* Not implemented yet*/ |
| float __powisf2(float a, int b); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/div.h |
|---|
| 0,0 → 1,48 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __DIV_H__ |
| #define __DIV_H__ |
| float32 divFloat32(float32 a, float32 b); |
| float64 divFloat64(float64 a, float64 b); |
| uint64_t divFloat64estim(uint64_t a, uint64_t b); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/conversion.h |
|---|
| 0,0 → 1,71 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __CONVERSION_H__ |
| #define __CONVERSION_H__ |
| float64 convertFloat32ToFloat64(float32 a); |
| float32 convertFloat64ToFloat32(float64 a); |
| uint32_t float32_to_uint32(float32 a); |
| int32_t float32_to_int32(float32 a); |
| uint64_t float32_to_uint64(float32 a); |
| int64_t float32_to_int64(float32 a); |
| uint64_t float64_to_uint64(float64 a); |
| int64_t float64_to_int64(float64 a); |
| uint32_t float64_to_uint32(float64 a); |
| int32_t float64_to_int32(float64 a); |
| float32 uint32_to_float32(uint32_t i); |
| float32 int32_to_float32(int32_t i); |
| float32 uint64_to_float32(uint64_t i); |
| float32 int64_to_float32(int64_t i); |
| float64 uint32_to_float64(uint32_t i); |
| float64 int32_to_float64(int32_t i); |
| float64 uint64_to_float64(uint64_t i); |
| float64 int64_to_float64(int64_t i); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/add.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __ADD_H__ |
| #define __ADD_H__ |
| float32 addFloat32(float32 a, float32 b); |
| float64 addFloat64(float64 a, float64 b); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/include/common.h |
|---|
| 0,0 → 1,53 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __COMMON_H__ |
| #define __COMMON_H__ |
| #include<sftypes.h> |
| float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign); |
| int countZeroes64(uint64_t i); |
| int countZeroes32(uint32_t i); |
| int countZeroes8(uint8_t i); |
| void roundFloat32(int32_t *exp, uint32_t *fraction); |
| void roundFloat64(int32_t *exp, uint64_t *fraction); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/Makefile |
|---|
| 0,0 → 1,82 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Common compiler flags |
| # |
| LIBC_PREFIX = ../libc |
| ## Setup toolchain |
| # |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -Iinclude -Iarch/$(UARCH)/include/ |
| ## Sources |
| # |
| GENERIC_SOURCES = \ |
| generic/add.c \ |
| generic/common.c \ |
| generic/comparison.c \ |
| generic/conversion.c \ |
| generic/div.c \ |
| generic/mul.c \ |
| generic/other.c \ |
| generic/softfloat.c \ |
| generic/sub.c |
| ARCH_SOURCES = |
| GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES))) |
| .PHONY: all clean depend |
| all: libsoftfloat.a |
| -include Makefile.depend |
| clean: |
| -rm -f libsoftfloat.a Makefile.depend |
| find generic/ -name '*.o' -follow -exec rm \{\} \; |
| depend: |
| -makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null |
| libsoftfloat.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| $(AR) rc libsoftfloat.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.s |
| $(AS) $(AFLAGS) $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.1/uspace/lib/softfloat/arch/arm32/include/functions.h |
|---|
| 0,0 → 1,76 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatarm32 arm32 |
| * @ingroup sfl |
| * @brief Softfloat architecture dependent definitions. |
| * @{ |
| */ |
| /** @file |
| * @brief Softfloat architecture dependent definitions. |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int32(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int32(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint32(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint32(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int32_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int32_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint32_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint32_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/sparc64/include/functions.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatsparc64 sparc64 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int64(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int64(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint64(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint64(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int64_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int64_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint64_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint64_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/ia64/include/functions.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatia64 ia64 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int64(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int64(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint64(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint64(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int64_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int64_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint64_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint64_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/mips32eb/include/functions.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatmipseb32 mipseb32 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int32(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int32(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint32(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint32(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int32_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int32_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint32_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint32_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/ppc32/include/functions.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatppc32 ppc32 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int32(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int32(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint32(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint32(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int32_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int32_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint32_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint32_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/amd64/include/functions.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatamd64 amd64 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int64(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int64(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint64(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint64(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int64_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int64_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint64_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint64_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/mips32/include/functions.h |
|---|
| 0,0 → 1,77 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatmips32 mips32 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int32(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int32(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint32(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint32(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int32_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int32_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint32_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint32_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/arch/ia32/include/functions.h |
|---|
| 0,0 → 1,75 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloatia32 ia32 |
| * @ingroup sfl |
| * @brief softfloat architecture dependent definitions |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef __SOFTFLOAT_FUNCTIONS_H__ |
| #define __SOFTFLOAT_FUNCTIONS_H__ |
| #define float32_to_int(X) float32_to_int32(X); |
| #define float32_to_long(X) float32_to_int32(X); |
| #define float32_to_longlong(X) float32_to_int64(X); |
| #define float64_to_int(X) float64_to_int32(X); |
| #define float64_to_long(X) float64_to_int32(X); |
| #define float64_to_longlong(X) float64_to_int64(X); |
| #define float32_to_uint(X) float32_to_uint32(X); |
| #define float32_to_ulong(X) float32_to_uint32(X); |
| #define float32_to_ulonglong(X) float32_to_uint64(X); |
| #define float64_to_uint(X) float64_to_uint32(X); |
| #define float64_to_ulong(X) float64_to_uint32(X); |
| #define float64_to_ulonglong(X) float64_to_uint64(X); |
| #define int_to_float32(X) int32_to_float32(X); |
| #define long_to_float32(X) int32_to_float32(X); |
| #define longlong_to_float32(X) int64_to_float32(X); |
| #define int_to_float64(X) int32_to_float64(X); |
| #define long_to_float64(X) int32_to_float64(X); |
| #define longlong_to_float64(X) int64_to_float64(X); |
| #define uint_to_float32(X) uint32_to_float32(X); |
| #define ulong_to_float32(X) uint32_to_float32(X); |
| #define ulonglong_to_float32(X) uint64_to_float32(X); |
| #define uint_to_float64(X) uint32_to_float64(X); |
| #define ulong_to_float64(X) uint32_to_float64(X); |
| #define ulonglong_to_float64(X) uint64_to_float64(X); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/other.c |
|---|
| 0,0 → 1,37 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/softfloat.c |
|---|
| 0,0 → 1,499 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat generic |
| * @ingroup sfl |
| * @brief Architecture independent parts of FPU software emulation library. |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<softfloat.h> |
| #include<sftypes.h> |
| #include<add.h> |
| #include<sub.h> |
| #include<mul.h> |
| #include<div.h> |
| #include<conversion.h> |
| #include<comparison.h> |
| #include<other.h> |
| #include<functions.h> |
| /* Arithmetic functions */ |
| float __addsf3(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if (fa.parts.sign != fb.parts.sign) { |
| if (fa.parts.sign) { |
| fa.parts.sign = 0; |
| return subFloat32(fb, fa).f; |
| }; |
| fb.parts.sign = 0; |
| return subFloat32(fa, fb).f; |
| } |
| return addFloat32(fa, fb).f; |
| } |
| double __adddf3(double a, double b) |
| { |
| float64 da, db; |
| da.d = a; |
| db.d = b; |
| if (da.parts.sign != db.parts.sign) { |
| if (da.parts.sign) { |
| da.parts.sign = 0; |
| return subFloat64(db, da).d; |
| }; |
| db.parts.sign = 0; |
| return subFloat64(da, db).d; |
| } |
| return addFloat64(da, db).d; |
| } |
| float __subsf3(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if (fa.parts.sign != fb.parts.sign) { |
| fb.parts.sign = !fb.parts.sign; |
| return addFloat32(fa, fb).f; |
| } |
| return subFloat32(fa, fb).f; |
| } |
| double __subdf3(double a, double b) |
| { |
| float64 da, db; |
| da.d = a; |
| db.d = b; |
| if (da.parts.sign != db.parts.sign) { |
| db.parts.sign = !db.parts.sign; |
| return addFloat64(da, db).d; |
| } |
| return subFloat64(da, db).d; |
| } |
| float __mulsf3(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| return mulFloat32(fa, fb).f; |
| } |
| double __muldf3(double a, double b) |
| { |
| float64 da, db; |
| da.d = a; |
| db.d = b; |
| return mulFloat64(da, db).d; |
| } |
| float __divsf3(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| return divFloat32(fa, fb).f; |
| } |
| double __divdf3(double a, double b) |
| { |
| float64 da, db; |
| da.d = a; |
| db.d = b; |
| return divFloat64(da, db).d; |
| } |
| float __negsf2(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| fa.parts.sign = !fa.parts.sign; |
| return fa.f; |
| } |
| double __negdf2(double a) |
| { |
| float64 fa; |
| fa.d = a; |
| fa.parts.sign = !fa.parts.sign; |
| return fa.d; |
| } |
| /* Conversion functions */ |
| double __extendsfdf2(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return convertFloat32ToFloat64(fa).d; |
| } |
| float __truncdfsf2(double a) |
| { |
| float64 da; |
| da.d = a; |
| return convertFloat64ToFloat32(da).f; |
| } |
| int __fixsfsi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_int(fa); |
| } |
| int __fixdfsi(double a) |
| { |
| float64 da; |
| da.d = a; |
| return float64_to_int(da); |
| } |
| long __fixsfdi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_long(fa); |
| } |
| long __fixdfdi(double a) |
| { |
| float64 da; |
| da.d = a; |
| return float64_to_long(da); |
| } |
| long long __fixsfti(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_longlong(fa); |
| } |
| long long __fixdfti(double a) |
| { |
| float64 da; |
| da.d = a; |
| return float64_to_longlong(da); |
| } |
| unsigned int __fixunssfsi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_uint(fa); |
| } |
| unsigned int __fixunsdfsi(double a) |
| { |
| float64 da; |
| da.d = a; |
| return float64_to_uint(da); |
| } |
| unsigned long __fixunssfdi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_ulong(fa); |
| } |
| unsigned long __fixunsdfdi(double a) |
| { |
| float64 da; |
| da.d = a; |
| return float64_to_ulong(da); |
| } |
| unsigned long long __fixunssfti(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_ulonglong(fa); |
| } |
| unsigned long long __fixunsdfti(double a) |
| { |
| float64 da; |
| da.d = a; |
| return float64_to_ulonglong(da); |
| } |
| float __floatsisf(int i) |
| { |
| float32 fa; |
| fa = int_to_float32(i); |
| return fa.f; |
| } |
| double __floatsidf(int i) |
| { |
| float64 da; |
| da = int_to_float64(i); |
| return da.d; |
| } |
| float __floatdisf(long i) |
| { |
| float32 fa; |
| fa = long_to_float32(i); |
| return fa.f; |
| } |
| double __floatdidf(long i) |
| { |
| float64 da; |
| da = long_to_float64(i); |
| return da.d; |
| } |
| float __floattisf(long long i) |
| { |
| float32 fa; |
| fa = longlong_to_float32(i); |
| return fa.f; |
| } |
| double __floattidf(long long i) |
| { |
| float64 da; |
| da = longlong_to_float64(i); |
| return da.d; |
| } |
| float __floatunsisf(unsigned int i) |
| { |
| float32 fa; |
| fa = uint_to_float32(i); |
| return fa.f; |
| } |
| double __floatunsidf(unsigned int i) |
| { |
| float64 da; |
| da = uint_to_float64(i); |
| return da.d; |
| } |
| float __floatundisf(unsigned long i) |
| { |
| float32 fa; |
| fa = ulong_to_float32(i); |
| return fa.f; |
| } |
| double __floatundidf(unsigned long i) |
| { |
| float64 da; |
| da = ulong_to_float64(i); |
| return da.d; |
| } |
| float __floatuntisf(unsigned long long i) |
| { |
| float32 fa; |
| fa = ulonglong_to_float32(i); |
| return fa.f; |
| } |
| double __floatuntidf(unsigned long long i) |
| { |
| float64 da; |
| da = ulonglong_to_float64(i); |
| return da.d; |
| } |
| /* Comparison functions */ |
| /* Comparison functions */ |
| /* a<b .. -1 |
| * a=b .. 0 |
| * a>b .. 1 |
| * */ |
| int __cmpsf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) { |
| return 1; /* no special constant for unordered - maybe signaled? */ |
| }; |
| if (isFloat32eq(fa, fb)) { |
| return 0; |
| }; |
| if (isFloat32lt(fa, fb)) { |
| return -1; |
| }; |
| return 1; |
| } |
| int __unordsf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ); |
| } |
| /** |
| * @return zero, if neither argument is a NaN and are equal |
| * */ |
| int __eqsf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) { |
| /* TODO: sigNaNs*/ |
| return 1; |
| }; |
| return isFloat32eq(fa, fb) - 1; |
| } |
| /* strange behavior, but it was in gcc documentation */ |
| int __nesf2(float a, float b) |
| { |
| return __eqsf2(a, b); |
| } |
| /* return value >= 0 if a>=b and neither is NaN */ |
| int __gesf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) { |
| /* TODO: sigNaNs*/ |
| return -1; |
| }; |
| if (isFloat32eq(fa, fb)) { |
| return 0; |
| }; |
| if (isFloat32gt(fa, fb)) { |
| return 1; |
| }; |
| return -1; |
| } |
| /** Return negative value, if a<b and neither is NaN*/ |
| int __ltsf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) { |
| /* TODO: sigNaNs*/ |
| return 1; |
| }; |
| if (isFloat32lt(fa, fb)) { |
| return -1; |
| }; |
| return 0; |
| } |
| /* return value <= 0 if a<=b and neither is NaN */ |
| int __lesf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) { |
| /* TODO: sigNaNs*/ |
| return 1; |
| }; |
| if (isFloat32eq(fa, fb)) { |
| return 0; |
| }; |
| if (isFloat32lt(fa, fb)) { |
| return -1; |
| }; |
| return 1; |
| } |
| /** Return positive value, if a>b and neither is NaN*/ |
| int __gtsf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) { |
| /* TODO: sigNaNs*/ |
| return -1; |
| }; |
| if (isFloat32gt(fa, fb)) { |
| return 1; |
| }; |
| return 0; |
| } |
| /* Other functions */ |
| float __powisf2(float a, int b) |
| { |
| /* TODO: */ |
| float32 fa; |
| fa.binary = FLOAT32_NAN; |
| return fa.f; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/div.c |
|---|
| 0,0 → 1,364 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<sftypes.h> |
| #include<add.h> |
| #include<div.h> |
| #include<comparison.h> |
| #include<mul.h> |
| #include<common.h> |
| float32 divFloat32(float32 a, float32 b) |
| { |
| float32 result; |
| int32_t aexp, bexp, cexp; |
| uint64_t afrac, bfrac, cfrac; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat32NaN(a)) { |
| if (isFloat32SigNaN(a)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return a; |
| } |
| if (isFloat32NaN(b)) { |
| if (isFloat32SigNaN(b)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return b; |
| } |
| if (isFloat32Infinity(a)) { |
| if (isFloat32Infinity(b)) { |
| /*FIXME: inf / inf */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| /* inf / num */ |
| result.parts.exp = a.parts.exp; |
| result.parts.fraction = a.parts.fraction; |
| return result; |
| } |
| if (isFloat32Infinity(b)) { |
| if (isFloat32Zero(a)) { |
| /* FIXME 0 / inf */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* FIXME: num / inf*/ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| if (isFloat32Zero(b)) { |
| if (isFloat32Zero(a)) { |
| /*FIXME: 0 / 0*/ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| /* FIXME: division by zero */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| afrac = a.parts.fraction; |
| aexp = a.parts.exp; |
| bfrac = b.parts.fraction; |
| bexp = b.parts.exp; |
| /* denormalized numbers */ |
| if (aexp == 0) { |
| if (afrac == 0) { |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* normalize it*/ |
| afrac <<= 1; |
| /* afrac is nonzero => it must stop */ |
| while (! (afrac & FLOAT32_HIDDEN_BIT_MASK) ) { |
| afrac <<= 1; |
| aexp--; |
| } |
| } |
| if (bexp == 0) { |
| bfrac <<= 1; |
| /* bfrac is nonzero => it must stop */ |
| while (! (bfrac & FLOAT32_HIDDEN_BIT_MASK) ) { |
| bfrac <<= 1; |
| bexp--; |
| } |
| } |
| afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK ) << (32 - FLOAT32_FRACTION_SIZE - 1 ); |
| bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK ) << (32 - FLOAT32_FRACTION_SIZE ); |
| if ( bfrac <= (afrac << 1) ) { |
| afrac >>= 1; |
| aexp++; |
| } |
| cexp = aexp - bexp + FLOAT32_BIAS - 2; |
| cfrac = (afrac << 32) / bfrac; |
| if (( cfrac & 0x3F ) == 0) { |
| cfrac |= ( bfrac * cfrac != afrac << 32 ); |
| } |
| /* pack and round */ |
| /* find first nonzero digit and shift result and detect possibly underflow */ |
| while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7 )))) { |
| cexp--; |
| cfrac <<= 1; |
| /* TODO: fix underflow */ |
| }; |
| cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/ |
| if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) { |
| ++cexp; |
| cfrac >>= 1; |
| } |
| /* check overflow */ |
| if (cexp >= FLOAT32_MAX_EXPONENT ) { |
| /* FIXME: overflow, return infinity */ |
| result.parts.exp = FLOAT32_MAX_EXPONENT; |
| result.parts.fraction = 0; |
| return result; |
| } |
| if (cexp < 0) { |
| /* FIXME: underflow */ |
| result.parts.exp = 0; |
| if ((cexp + FLOAT32_FRACTION_SIZE) < 0) { |
| result.parts.fraction = 0; |
| return result; |
| } |
| cfrac >>= 1; |
| while (cexp < 0) { |
| cexp ++; |
| cfrac >>= 1; |
| } |
| } else { |
| result.parts.exp = (uint32_t)cexp; |
| } |
| result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); |
| return result; |
| } |
| float64 divFloat64(float64 a, float64 b) |
| { |
| float64 result; |
| int64_t aexp, bexp, cexp; |
| uint64_t afrac, bfrac, cfrac; |
| uint64_t remlo, remhi; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat64NaN(a)) { |
| if (isFloat64SigNaN(b)) { |
| /*FIXME: SigNaN*/ |
| return b; |
| } |
| if (isFloat64SigNaN(a)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return a; |
| } |
| if (isFloat64NaN(b)) { |
| if (isFloat64SigNaN(b)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return b; |
| } |
| if (isFloat64Infinity(a)) { |
| if (isFloat64Infinity(b) || isFloat64Zero(b)) { |
| /*FIXME: inf / inf */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| /* inf / num */ |
| result.parts.exp = a.parts.exp; |
| result.parts.fraction = a.parts.fraction; |
| return result; |
| } |
| if (isFloat64Infinity(b)) { |
| if (isFloat64Zero(a)) { |
| /* FIXME 0 / inf */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* FIXME: num / inf*/ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| if (isFloat64Zero(b)) { |
| if (isFloat64Zero(a)) { |
| /*FIXME: 0 / 0*/ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| /* FIXME: division by zero */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| afrac = a.parts.fraction; |
| aexp = a.parts.exp; |
| bfrac = b.parts.fraction; |
| bexp = b.parts.exp; |
| /* denormalized numbers */ |
| if (aexp == 0) { |
| if (afrac == 0) { |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* normalize it*/ |
| aexp++; |
| /* afrac is nonzero => it must stop */ |
| while (! (afrac & FLOAT64_HIDDEN_BIT_MASK) ) { |
| afrac <<= 1; |
| aexp--; |
| } |
| } |
| if (bexp == 0) { |
| bexp++; |
| /* bfrac is nonzero => it must stop */ |
| while (! (bfrac & FLOAT64_HIDDEN_BIT_MASK) ) { |
| bfrac <<= 1; |
| bexp--; |
| } |
| } |
| afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK ) << (64 - FLOAT64_FRACTION_SIZE - 2 ); |
| bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK ) << (64 - FLOAT64_FRACTION_SIZE - 1); |
| if ( bfrac <= (afrac << 1) ) { |
| afrac >>= 1; |
| aexp++; |
| } |
| cexp = aexp - bexp + FLOAT64_BIAS - 2; |
| cfrac = divFloat64estim(afrac, bfrac); |
| if (( cfrac & 0x1FF ) <= 2) { /*FIXME:?? */ |
| mul64integers( bfrac, cfrac, &remlo, &remhi); |
| /* (__u128)afrac << 64 - ( ((__u128)remhi<<64) + (__u128)remlo )*/ |
| remhi = afrac - remhi - ( remlo > 0); |
| remlo = - remlo; |
| while ((int64_t) remhi < 0) { |
| cfrac--; |
| remlo += bfrac; |
| remhi += ( remlo < bfrac ); |
| } |
| cfrac |= ( remlo != 0 ); |
| } |
| /* round and shift */ |
| result = finishFloat64(cexp, cfrac, result.parts.sign); |
| return result; |
| } |
| uint64_t divFloat64estim(uint64_t a, uint64_t b) |
| { |
| uint64_t bhi; |
| uint64_t remhi, remlo; |
| uint64_t result; |
| if ( b <= a ) { |
| return 0xFFFFFFFFFFFFFFFFull; |
| } |
| bhi = b >> 32; |
| result = ((bhi << 32) <= a) ?( 0xFFFFFFFFull << 32) : ( a / bhi) << 32; |
| mul64integers(b, result, &remlo, &remhi); |
| remhi = a - remhi - (remlo > 0); |
| remlo = - remlo; |
| b <<= 32; |
| while ( (int64_t) remhi < 0 ) { |
| result -= 0x1ll << 32; |
| remlo += b; |
| remhi += bhi + ( remlo < b ); |
| } |
| remhi = (remhi << 32) | (remlo >> 32); |
| if (( bhi << 32) <= remhi) { |
| result |= 0xFFFFFFFF; |
| } else { |
| result |= remhi / bhi; |
| } |
| return result; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/conversion.c |
|---|
| 0,0 → 1,593 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include "sftypes.h" |
| #include "conversion.h" |
| #include "comparison.h" |
| #include "common.h" |
| float64 convertFloat32ToFloat64(float32 a) |
| { |
| float64 result; |
| uint64_t frac; |
| result.parts.sign = a.parts.sign; |
| result.parts.fraction = a.parts.fraction; |
| result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE ); |
| if ((isFloat32Infinity(a))||(isFloat32NaN(a))) { |
| result.parts.exp = 0x7FF; |
| /* TODO; check if its correct for SigNaNs*/ |
| return result; |
| }; |
| result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS ); |
| if (a.parts.exp == 0) { |
| /* normalize denormalized numbers */ |
| if (result.parts.fraction == 0ll) { /* fix zero */ |
| result.parts.exp = 0ll; |
| return result; |
| } |
| frac = result.parts.fraction; |
| while (!(frac & (0x10000000000000ll))) { |
| frac <<= 1; |
| --result.parts.exp; |
| }; |
| ++result.parts.exp; |
| result.parts.fraction = frac; |
| }; |
| return result; |
| } |
| float32 convertFloat64ToFloat32(float64 a) |
| { |
| float32 result; |
| int32_t exp; |
| uint64_t frac; |
| result.parts.sign = a.parts.sign; |
| if (isFloat64NaN(a)) { |
| result.parts.exp = 0xFF; |
| if (isFloat64SigNaN(a)) { |
| result.parts.fraction = 0x400000; /* set first bit of fraction nonzero */ |
| return result; |
| } |
| result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */ |
| return result; |
| }; |
| if (isFloat64Infinity(a)) { |
| result.parts.fraction = 0; |
| result.parts.exp = 0xFF; |
| return result; |
| }; |
| exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS; |
| if (exp >= 0xFF) { |
| /*FIXME: overflow*/ |
| result.parts.fraction = 0; |
| result.parts.exp = 0xFF; |
| return result; |
| } else if (exp <= 0 ) { |
| /* underflow or denormalized */ |
| result.parts.exp = 0; |
| exp *= -1; |
| if (exp > FLOAT32_FRACTION_SIZE ) { |
| /* FIXME: underflow */ |
| result.parts.fraction = 0; |
| return result; |
| }; |
| /* denormalized */ |
| frac = a.parts.fraction; |
| frac |= 0x10000000000000ll; /* denormalize and set hidden bit */ |
| frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1); |
| while (exp > 0) { |
| --exp; |
| frac >>= 1; |
| }; |
| result.parts.fraction = frac; |
| return result; |
| }; |
| result.parts.exp = exp; |
| result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); |
| return result; |
| } |
| /** Helping procedure for converting float32 to uint32 |
| * @param a floating point number in normalized form (no NaNs or Inf are checked ) |
| * @return unsigned integer |
| */ |
| static uint32_t _float32_to_uint32_helper(float32 a) |
| { |
| uint32_t frac; |
| if (a.parts.exp < FLOAT32_BIAS) { |
| /*TODO: rounding*/ |
| return 0; |
| } |
| frac = a.parts.fraction; |
| frac |= FLOAT32_HIDDEN_BIT_MASK; |
| /* shift fraction to left so hidden bit will be the most significant bit */ |
| frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; |
| frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1; |
| if ((a.parts.sign == 1) && (frac != 0)) { |
| frac = ~frac; |
| ++frac; |
| } |
| return frac; |
| } |
| /* Convert float to unsigned int32 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| uint32_t float32_to_uint32(float32 a) |
| { |
| if (isFloat32NaN(a)) { |
| return MAX_UINT32; |
| } |
| if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_UINT32; |
| } |
| return MAX_UINT32; |
| } |
| return _float32_to_uint32_helper(a); |
| } |
| /* Convert float to signed int32 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| int32_t float32_to_int32(float32 a) |
| { |
| if (isFloat32NaN(a)) { |
| return MAX_INT32; |
| } |
| if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_INT32; |
| } |
| return MAX_INT32; |
| } |
| return _float32_to_uint32_helper(a); |
| } |
| /** Helping procedure for converting float64 to uint64 |
| * @param a floating point number in normalized form (no NaNs or Inf are checked ) |
| * @return unsigned integer |
| */ |
| static uint64_t _float64_to_uint64_helper(float64 a) |
| { |
| uint64_t frac; |
| if (a.parts.exp < FLOAT64_BIAS) { |
| /*TODO: rounding*/ |
| return 0; |
| } |
| frac = a.parts.fraction; |
| frac |= FLOAT64_HIDDEN_BIT_MASK; |
| /* shift fraction to left so hidden bit will be the most significant bit */ |
| frac <<= 64 - FLOAT64_FRACTION_SIZE - 1; |
| frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1; |
| if ((a.parts.sign == 1) && (frac != 0)) { |
| frac = ~frac; |
| ++frac; |
| } |
| return frac; |
| } |
| /* Convert float to unsigned int64 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| uint64_t float64_to_uint64(float64 a) |
| { |
| if (isFloat64NaN(a)) { |
| return MAX_UINT64; |
| } |
| if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_UINT64; |
| } |
| return MAX_UINT64; |
| } |
| return _float64_to_uint64_helper(a); |
| } |
| /* Convert float to signed int64 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| int64_t float64_to_int64(float64 a) |
| { |
| if (isFloat64NaN(a)) { |
| return MAX_INT64; |
| } |
| if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_INT64; |
| } |
| return MAX_INT64; |
| } |
| return _float64_to_uint64_helper(a); |
| } |
| /** Helping procedure for converting float32 to uint64 |
| * @param a floating point number in normalized form (no NaNs or Inf are checked ) |
| * @return unsigned integer |
| */ |
| static uint64_t _float32_to_uint64_helper(float32 a) |
| { |
| uint64_t frac; |
| if (a.parts.exp < FLOAT32_BIAS) { |
| /*TODO: rounding*/ |
| return 0; |
| } |
| frac = a.parts.fraction; |
| frac |= FLOAT32_HIDDEN_BIT_MASK; |
| /* shift fraction to left so hidden bit will be the most significant bit */ |
| frac <<= 64 - FLOAT32_FRACTION_SIZE - 1; |
| frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1; |
| if ((a.parts.sign == 1) && (frac != 0)) { |
| frac = ~frac; |
| ++frac; |
| } |
| return frac; |
| } |
| /* Convert float to unsigned int64 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| uint64_t float32_to_uint64(float32 a) |
| { |
| if (isFloat32NaN(a)) { |
| return MAX_UINT64; |
| } |
| if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_UINT64; |
| } |
| return MAX_UINT64; |
| } |
| return _float32_to_uint64_helper(a); |
| } |
| /* Convert float to signed int64 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| int64_t float32_to_int64(float32 a) |
| { |
| if (isFloat32NaN(a)) { |
| return MAX_INT64; |
| } |
| if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) { |
| if (a.parts.sign) { |
| return (MIN_INT64); |
| } |
| return MAX_INT64; |
| } |
| return _float32_to_uint64_helper(a); |
| } |
| /* Convert float64 to unsigned int32 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| uint32_t float64_to_uint32(float64 a) |
| { |
| if (isFloat64NaN(a)) { |
| return MAX_UINT32; |
| } |
| if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_UINT32; |
| } |
| return MAX_UINT32; |
| } |
| return (uint32_t)_float64_to_uint64_helper(a); |
| } |
| /* Convert float64 to signed int32 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| int32_t float64_to_int32(float64 a) |
| { |
| if (isFloat64NaN(a)) { |
| return MAX_INT32; |
| } |
| if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_INT32; |
| } |
| return MAX_INT32; |
| } |
| return (int32_t)_float64_to_uint64_helper(a); |
| } |
| /** Convert unsigned integer to float32 |
| * |
| * |
| */ |
| float32 uint32_to_float32(uint32_t i) |
| { |
| int counter; |
| int32_t exp; |
| float32 result; |
| result.parts.sign = 0; |
| result.parts.fraction = 0; |
| counter = countZeroes32(i); |
| exp = FLOAT32_BIAS + 32 - counter - 1; |
| if (counter == 32) { |
| result.binary = 0; |
| return result; |
| } |
| if (counter > 0) { |
| i <<= counter - 1; |
| } else { |
| i >>= 1; |
| } |
| roundFloat32(&exp, &i); |
| result.parts.fraction = i >> 7; |
| result.parts.exp = exp; |
| return result; |
| } |
| float32 int32_to_float32(int32_t i) |
| { |
| float32 result; |
| if (i < 0) { |
| result = uint32_to_float32((uint32_t)(-i)); |
| } else { |
| result = uint32_to_float32((uint32_t)i); |
| } |
| result.parts.sign = i < 0; |
| return result; |
| } |
| float32 uint64_to_float32(uint64_t i) |
| { |
| int counter; |
| int32_t exp; |
| uint32_t j; |
| float32 result; |
| result.parts.sign = 0; |
| result.parts.fraction = 0; |
| counter = countZeroes64(i); |
| exp = FLOAT32_BIAS + 64 - counter - 1; |
| if (counter == 64) { |
| result.binary = 0; |
| return result; |
| } |
| /* Shift all to the first 31 bits (31. will be hidden 1)*/ |
| if (counter > 33) { |
| i <<= counter - 1 - 32; |
| } else { |
| i >>= 1 + 32 - counter; |
| } |
| j = (uint32_t)i; |
| roundFloat32(&exp, &j); |
| result.parts.fraction = j >> 7; |
| result.parts.exp = exp; |
| return result; |
| } |
| float32 int64_to_float32(int64_t i) |
| { |
| float32 result; |
| if (i < 0) { |
| result = uint64_to_float32((uint64_t)(-i)); |
| } else { |
| result = uint64_to_float32((uint64_t)i); |
| } |
| result.parts.sign = i < 0; |
| return result; |
| } |
| /** Convert unsigned integer to float64 |
| * |
| * |
| */ |
| float64 uint32_to_float64(uint32_t i) |
| { |
| int counter; |
| int32_t exp; |
| float64 result; |
| uint64_t frac; |
| result.parts.sign = 0; |
| result.parts.fraction = 0; |
| counter = countZeroes32(i); |
| exp = FLOAT64_BIAS + 32 - counter - 1; |
| if (counter == 32) { |
| result.binary = 0; |
| return result; |
| } |
| frac = i; |
| frac <<= counter + 32 - 1; |
| roundFloat64(&exp, &frac); |
| result.parts.fraction = frac >> 10; |
| result.parts.exp = exp; |
| return result; |
| } |
| float64 int32_to_float64(int32_t i) |
| { |
| float64 result; |
| if (i < 0) { |
| result = uint32_to_float64((uint32_t)(-i)); |
| } else { |
| result = uint32_to_float64((uint32_t)i); |
| } |
| result.parts.sign = i < 0; |
| return result; |
| } |
| float64 uint64_to_float64(uint64_t i) |
| { |
| int counter; |
| int32_t exp; |
| float64 result; |
| result.parts.sign = 0; |
| result.parts.fraction = 0; |
| counter = countZeroes64(i); |
| exp = FLOAT64_BIAS + 64 - counter - 1; |
| if (counter == 64) { |
| result.binary = 0; |
| return result; |
| } |
| if (counter > 0) { |
| i <<= counter - 1; |
| } else { |
| i >>= 1; |
| } |
| roundFloat64(&exp, &i); |
| result.parts.fraction = i >> 10; |
| result.parts.exp = exp; |
| return result; |
| } |
| float64 int64_to_float64(int64_t i) |
| { |
| float64 result; |
| if (i < 0) { |
| result = uint64_to_float64((uint64_t)(-i)); |
| } else { |
| result = uint64_to_float64((uint64_t)i); |
| } |
| result.parts.sign = i < 0; |
| return result; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/add.c |
|---|
| 0,0 → 1,259 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<sftypes.h> |
| #include<add.h> |
| #include<comparison.h> |
| /** Add two Float32 numbers with same signs |
| */ |
| float32 addFloat32(float32 a, float32 b) |
| { |
| int expdiff; |
| uint32_t exp1, exp2,frac1, frac2; |
| expdiff = a.parts.exp - b.parts.exp; |
| if (expdiff < 0) { |
| if (isFloat32NaN(b)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat32SigNaN(b)) { |
| }; |
| return b; |
| }; |
| if (b.parts.exp == FLOAT32_MAX_EXPONENT) { |
| return b; |
| } |
| frac1 = b.parts.fraction; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| if ((isFloat32NaN(a)) || (isFloat32NaN(b))) { |
| /* TODO: fix SigNaN */ |
| if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) { |
| }; |
| return (isFloat32NaN(a)?a:b); |
| }; |
| if (a.parts.exp == FLOAT32_MAX_EXPONENT) { |
| return a; |
| } |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| frac1 += frac2; |
| if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) { |
| /* result is not denormalized */ |
| a.parts.exp = 1; |
| }; |
| a.parts.fraction = frac1; |
| return a; |
| }; |
| frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */ |
| if (exp2 == 0) { |
| /* second operand is denormalized */ |
| --expdiff; |
| } else { |
| /* add hidden bit to second operand */ |
| frac2 |= FLOAT32_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) { |
| frac2 >>= expdiff; |
| frac1 += frac2; |
| } else { |
| a.parts.exp = exp1; |
| a.parts.fraction = (frac1 >> 6) & (~(FLOAT32_HIDDEN_BIT_MASK)); |
| return a; |
| } |
| if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += (0x1 << 5); |
| if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { |
| /* rounding overflow */ |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| if ((exp1 == FLOAT32_MAX_EXPONENT ) || (exp2 > exp1)) { |
| /* overflow - set infinity as result */ |
| a.parts.exp = FLOAT32_MAX_EXPONENT; |
| a.parts.fraction = 0; |
| return a; |
| } |
| a.parts.exp = exp1; |
| /*Clear hidden bit and shift */ |
| a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ; |
| return a; |
| } |
| /** Add two Float64 numbers with same signs |
| */ |
| float64 addFloat64(float64 a, float64 b) |
| { |
| int expdiff; |
| uint32_t exp1, exp2; |
| uint64_t frac1, frac2; |
| expdiff = ((int )a.parts.exp) - b.parts.exp; |
| if (expdiff < 0) { |
| if (isFloat64NaN(b)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat64SigNaN(b)) { |
| }; |
| return b; |
| }; |
| /* b is infinity and a not */ |
| if (b.parts.exp == FLOAT64_MAX_EXPONENT ) { |
| return b; |
| } |
| frac1 = b.parts.fraction; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| if (isFloat64NaN(a)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) { |
| }; |
| return a; |
| }; |
| /* a is infinity and b not */ |
| if (a.parts.exp == FLOAT64_MAX_EXPONENT ) { |
| return a; |
| } |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| frac1 += frac2; |
| if (frac1 & FLOAT64_HIDDEN_BIT_MASK) { |
| /* result is not denormalized */ |
| a.parts.exp = 1; |
| }; |
| a.parts.fraction = frac1; |
| return a; |
| }; |
| /* add hidden bit - frac1 is sure not denormalized */ |
| frac1 |= FLOAT64_HIDDEN_BIT_MASK; |
| /* second operand ... */ |
| if (exp2 == 0) { |
| /* ... is denormalized */ |
| --expdiff; |
| } else { |
| /* is not denormalized */ |
| frac2 |= FLOAT64_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| if (expdiff < (FLOAT64_FRACTION_SIZE + 2) ) { |
| frac2 >>= expdiff; |
| frac1 += frac2; |
| } else { |
| a.parts.exp = exp1; |
| a.parts.fraction = (frac1 >> 6) & (~(FLOAT64_HIDDEN_BIT_MASK)); |
| return a; |
| } |
| if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += (0x1 << 5); |
| if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { |
| /* rounding overflow */ |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| if ((exp1 == FLOAT64_MAX_EXPONENT ) || (exp2 > exp1)) { |
| /* overflow - set infinity as result */ |
| a.parts.exp = FLOAT64_MAX_EXPONENT; |
| a.parts.fraction = 0; |
| return a; |
| } |
| a.parts.exp = exp1; |
| /*Clear hidden bit and shift */ |
| a.parts.fraction = ( (frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| return a; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/common.c |
|---|
| 0,0 → 1,215 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<sftypes.h> |
| #include<common.h> |
| /* Table for fast leading zeroes counting */ |
| char zeroTable[256] = { |
| 8, 7, 7, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, \ |
| 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, \ |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| }; |
| /** Take fraction shifted by 10 bits to left, round it, normalize it and detect exceptions |
| * @param cexp exponent with bias |
| * @param cfrac fraction shifted 10 places left with added hidden bit |
| * @param sign |
| * @return valied float64 |
| */ |
| float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign) |
| { |
| float64 result; |
| result.parts.sign = sign; |
| /* find first nonzero digit and shift result and detect possibly underflow */ |
| while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) { |
| cexp--; |
| cfrac <<= 1; |
| /* TODO: fix underflow */ |
| }; |
| if ((cexp < 0) || ( cexp == 0 && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) { |
| /* FIXME: underflow */ |
| result.parts.exp = 0; |
| if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */ |
| result.parts.fraction = 0; |
| return result; |
| } |
| while (cexp < 0) { |
| cexp++; |
| cfrac >>= 1; |
| } |
| cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); |
| if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))) { |
| result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2) ) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| return result; |
| } |
| } else { |
| cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); |
| } |
| ++cexp; |
| if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) { |
| ++cexp; |
| cfrac >>= 1; |
| } |
| /* check overflow */ |
| if (cexp >= FLOAT64_MAX_EXPONENT ) { |
| /* FIXME: overflow, return infinity */ |
| result.parts.exp = FLOAT64_MAX_EXPONENT; |
| result.parts.fraction = 0; |
| return result; |
| } |
| result.parts.exp = (uint32_t)cexp; |
| result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| return result; |
| } |
| /** Counts leading zeroes in 64bit unsigned integer |
| * @param i |
| */ |
| int countZeroes64(uint64_t i) |
| { |
| int j; |
| for (j =0; j < 64; j += 8) { |
| if ( i & (0xFFll << (56 - j))) { |
| return (j + countZeroes8(i >> (56 - j))); |
| } |
| } |
| return 64; |
| } |
| /** Counts leading zeroes in 32bit unsigned integer |
| * @param i |
| */ |
| int countZeroes32(uint32_t i) |
| { |
| int j; |
| for (j =0; j < 32; j += 8) { |
| if ( i & (0xFF << (24 - j))) { |
| return (j + countZeroes8(i >> (24 - j))); |
| } |
| } |
| return 32; |
| } |
| /** Counts leading zeroes in byte |
| * @param i |
| */ |
| int countZeroes8(uint8_t i) |
| { |
| return zeroTable[i]; |
| } |
| /** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 30. bit |
| * @param exp exponent |
| * @param fraction part with hidden bit shifted to 30. bit |
| */ |
| void roundFloat32(int32_t *exp, uint32_t *fraction) |
| { |
| /* rounding - if first bit after fraction is set then round up */ |
| (*fraction) += (0x1 << 6); |
| if ((*fraction) & (FLOAT32_HIDDEN_BIT_MASK << 8)) { |
| /* rounding overflow */ |
| ++(*exp); |
| (*fraction) >>= 1; |
| }; |
| if (((*exp) >= FLOAT32_MAX_EXPONENT ) || ((*exp) < 0)) { |
| /* overflow - set infinity as result */ |
| (*exp) = FLOAT32_MAX_EXPONENT; |
| (*fraction) = 0; |
| return; |
| } |
| return; |
| } |
| /** Round and normalize number expressed by exponent and fraction with first bit (equal to hidden bit) at 62. bit |
| * @param exp exponent |
| * @param fraction part with hidden bit shifted to 62. bit |
| */ |
| void roundFloat64(int32_t *exp, uint64_t *fraction) |
| { |
| /* rounding - if first bit after fraction is set then round up */ |
| (*fraction) += (0x1 << 9); |
| if ((*fraction) & (FLOAT64_HIDDEN_BIT_MASK << 11)) { |
| /* rounding overflow */ |
| ++(*exp); |
| (*fraction) >>= 1; |
| }; |
| if (((*exp) >= FLOAT64_MAX_EXPONENT ) || ((*exp) < 0)) { |
| /* overflow - set infinity as result */ |
| (*exp) = FLOAT64_MAX_EXPONENT; |
| (*fraction) = 0; |
| return; |
| } |
| return; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/sub.c |
|---|
| 0,0 → 1,265 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<sftypes.h> |
| #include<sub.h> |
| #include<comparison.h> |
| /** Subtract two float32 numbers with same signs |
| */ |
| float32 subFloat32(float32 a, float32 b) |
| { |
| int expdiff; |
| uint32_t exp1, exp2, frac1, frac2; |
| float32 result; |
| result.f = 0; |
| expdiff = a.parts.exp - b.parts.exp; |
| if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) { |
| if (isFloat32NaN(b)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat32SigNaN(b)) { |
| }; |
| return b; |
| }; |
| if (b.parts.exp == FLOAT32_MAX_EXPONENT) { |
| b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */ |
| return b; |
| } |
| result.parts.sign = !a.parts.sign; |
| frac1 = b.parts.fraction; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| if (isFloat32NaN(a)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) { |
| }; |
| return a; |
| }; |
| if (a.parts.exp == FLOAT32_MAX_EXPONENT) { |
| if (b.parts.exp == FLOAT32_MAX_EXPONENT) { |
| /* inf - inf => nan */ |
| /* TODO: fix exception */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| }; |
| return a; |
| } |
| result.parts.sign = a.parts.sign; |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| result.parts.fraction = frac1-frac2; |
| if (result.parts.fraction > frac1) { |
| /* TODO: underflow exception */ |
| return result; |
| }; |
| result.parts.exp = 0; |
| return result; |
| }; |
| /* add hidden bit */ |
| frac1 |= FLOAT32_HIDDEN_BIT_MASK; |
| if (exp2 == 0) { |
| /* denormalized */ |
| --expdiff; |
| } else { |
| /* normalized */ |
| frac2 |= FLOAT32_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| if (expdiff > FLOAT32_FRACTION_SIZE + 1) { |
| goto done; |
| }; |
| frac1 = frac1 - (frac2 >> expdiff); |
| done: |
| /* TODO: find first nonzero digit and shift result and detect possibly underflow */ |
| while ((exp1 > 0) && (!(frac1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) { |
| --exp1; |
| frac1 <<= 1; |
| /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += 0x20; |
| if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /*Clear hidden bit and shift */ |
| result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); |
| result.parts.exp = exp1; |
| return result; |
| } |
| /** Subtract two float64 numbers with same signs |
| */ |
| float64 subFloat64(float64 a, float64 b) |
| { |
| int expdiff; |
| uint32_t exp1, exp2; |
| uint64_t frac1, frac2; |
| float64 result; |
| result.d = 0; |
| expdiff = a.parts.exp - b.parts.exp; |
| if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) { |
| if (isFloat64NaN(b)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat64SigNaN(b)) { |
| }; |
| return b; |
| }; |
| if (b.parts.exp == FLOAT64_MAX_EXPONENT) { |
| b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */ |
| return b; |
| } |
| result.parts.sign = !a.parts.sign; |
| frac1 = b.parts.fraction; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| if (isFloat64NaN(a)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) { |
| }; |
| return a; |
| }; |
| if (a.parts.exp == FLOAT64_MAX_EXPONENT) { |
| if (b.parts.exp == FLOAT64_MAX_EXPONENT) { |
| /* inf - inf => nan */ |
| /* TODO: fix exception */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| }; |
| return a; |
| } |
| result.parts.sign = a.parts.sign; |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| result.parts.fraction = frac1 - frac2; |
| if (result.parts.fraction > frac1) { |
| /* TODO: underflow exception */ |
| return result; |
| }; |
| result.parts.exp = 0; |
| return result; |
| }; |
| /* add hidden bit */ |
| frac1 |= FLOAT64_HIDDEN_BIT_MASK; |
| if (exp2 == 0) { |
| /* denormalized */ |
| --expdiff; |
| } else { |
| /* normalized */ |
| frac2 |= FLOAT64_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| if (expdiff > FLOAT64_FRACTION_SIZE + 1) { |
| goto done; |
| }; |
| frac1 = frac1 - (frac2 >> expdiff); |
| done: |
| /* TODO: find first nonzero digit and shift result and detect possibly underflow */ |
| while ((exp1 > 0) && (!(frac1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) { |
| --exp1; |
| frac1 <<= 1; |
| /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += 0x20; |
| if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /*Clear hidden bit and shift */ |
| result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| result.parts.exp = exp1; |
| return result; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/comparison.c |
|---|
| 0,0 → 1,129 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<sftypes.h> |
| #include<comparison.h> |
| inline int isFloat32NaN(float32 f) |
| { /* NaN : exp = 0xff and nonzero fraction */ |
| return ((f.parts.exp==0xFF)&&(f.parts.fraction)); |
| } |
| inline int isFloat64NaN(float64 d) |
| { /* NaN : exp = 0x7ff and nonzero fraction */ |
| return ((d.parts.exp==0x7FF)&&(d.parts.fraction)); |
| } |
| inline int isFloat32SigNaN(float32 f) |
| { /* SigNaN : exp = 0xff fraction = 0xxxxx..x (binary), where at least one x is nonzero */ |
| return ((f.parts.exp==0xFF)&&(f.parts.fraction<0x400000)&&(f.parts.fraction)); |
| } |
| inline int isFloat64SigNaN(float64 d) |
| { /* SigNaN : exp = 0x7ff fraction = 0xxxxx..x (binary), where at least one x is nonzero */ |
| return ((d.parts.exp==0x7FF)&&(d.parts.fraction)&&(d.parts.fraction<0x8000000000000ll)); |
| } |
| inline int isFloat32Infinity(float32 f) |
| { |
| return ((f.parts.exp==0xFF)&&(f.parts.fraction==0x0)); |
| } |
| inline int isFloat64Infinity(float64 d) |
| { |
| return ((d.parts.exp==0x7FF)&&(d.parts.fraction==0x0)); |
| } |
| inline int isFloat32Zero(float32 f) |
| { |
| return (((f.binary) & 0x7FFFFFFF) == 0); |
| } |
| inline int isFloat64Zero(float64 d) |
| { |
| return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0); |
| } |
| /** |
| * @return 1, if both floats are equal - but NaNs are not recognized |
| */ |
| inline int isFloat32eq(float32 a, float32 b) |
| { |
| return ((a.binary==b.binary)||(((a.binary| b.binary)&0x7FFFFFFF)==0)); /* a equals to b or both are zeros (with any sign) */ |
| } |
| /** |
| * @return 1, if a<b - but NaNs are not recognized |
| */ |
| inline int isFloat32lt(float32 a, float32 b) |
| { |
| if (((a.binary| b.binary)&0x7FFFFFFF)==0) { |
| return 0; /* +- zeroes */ |
| }; |
| if ((a.parts.sign)&&(b.parts.sign)) { |
| /*if both are negative, smaller is that with greater binary value*/ |
| return (a.binary>b.binary); |
| }; |
| /* lets negate signs - now will be positive numbers allways bigger than negative (first bit will be set for unsigned integer comparison)*/ |
| a.parts.sign=!a.parts.sign; |
| b.parts.sign=!b.parts.sign; |
| return (a.binary<b.binary); |
| } |
| /** |
| * @return 1, if a>b - but NaNs are not recognized |
| */ |
| inline int isFloat32gt(float32 a, float32 b) |
| { |
| if (((a.binary| b.binary)&0x7FFFFFFF)==0) { |
| return 0; /* zeroes are equal with any sign */ |
| }; |
| if ((a.parts.sign)&&(b.parts.sign)) { |
| /*if both are negative, greater is that with smaller binary value*/ |
| return (a.binary<b.binary); |
| }; |
| /* lets negate signs - now will be positive numbers allways bigger than negative (first bit will be set for unsigned integer comparison)*/ |
| a.parts.sign=!a.parts.sign; |
| b.parts.sign=!b.parts.sign; |
| return (a.binary>b.binary); |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softfloat/generic/mul.c |
|---|
| 0,0 → 1,294 |
| /* |
| * Copyright (c) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softfloat |
| * @{ |
| */ |
| /** @file |
| */ |
| #include<sftypes.h> |
| #include<mul.h> |
| #include<comparison.h> |
| #include<common.h> |
| /** Multiply two 32 bit float numbers |
| * |
| */ |
| float32 mulFloat32(float32 a, float32 b) |
| { |
| float32 result; |
| uint64_t frac1, frac2; |
| int32_t exp; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat32NaN(a) || isFloat32NaN(b) ) { |
| /* TODO: fix SigNaNs */ |
| if (isFloat32SigNaN(a)) { |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| }; |
| if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */ |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| }; |
| /* set NaN as result */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| }; |
| if (isFloat32Infinity(a)) { |
| if (isFloat32Zero(b)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| } |
| if (isFloat32Infinity(b)) { |
| if (isFloat32Zero(a)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| } |
| /* exp is signed so we can easy detect underflow */ |
| exp = a.parts.exp + b.parts.exp; |
| exp -= FLOAT32_BIAS; |
| if (exp >= FLOAT32_MAX_EXPONENT) { |
| /* FIXME: overflow */ |
| /* set infinity as result */ |
| result.binary = FLOAT32_INF; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| return result; |
| }; |
| if (exp < 0) { |
| /* FIXME: underflow */ |
| /* return signed zero */ |
| result.parts.fraction = 0x0; |
| result.parts.exp = 0x0; |
| return result; |
| }; |
| frac1 = a.parts.fraction; |
| if (a.parts.exp > 0) { |
| frac1 |= FLOAT32_HIDDEN_BIT_MASK; |
| } else { |
| ++exp; |
| }; |
| frac2 = b.parts.fraction; |
| if (b.parts.exp > 0) { |
| frac2 |= FLOAT32_HIDDEN_BIT_MASK; |
| } else { |
| ++exp; |
| }; |
| frac1 <<= 1; /* one bit space for rounding */ |
| frac1 = frac1 * frac2; |
| /* round and return */ |
| while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= ( 1 << (FLOAT32_FRACTION_SIZE + 2)))) { |
| /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left)*/ |
| ++exp; |
| frac1 >>= 1; |
| }; |
| /* rounding */ |
| /* ++frac1; FIXME: not works - without it is ok */ |
| frac1 >>= 1; /* shift off rounding space */ |
| if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) { |
| ++exp; |
| frac1 >>= 1; |
| }; |
| if (exp >= FLOAT32_MAX_EXPONENT ) { |
| /* TODO: fix overflow */ |
| /* return infinity*/ |
| result.parts.exp = FLOAT32_MAX_EXPONENT; |
| result.parts.fraction = 0x0; |
| return result; |
| } |
| exp -= FLOAT32_FRACTION_SIZE; |
| if (exp <= FLOAT32_FRACTION_SIZE) { |
| /* denormalized number */ |
| frac1 >>= 1; /* denormalize */ |
| while ((frac1 > 0) && (exp < 0)) { |
| frac1 >>= 1; |
| ++exp; |
| }; |
| if (frac1 == 0) { |
| /* FIXME : underflow */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| }; |
| }; |
| result.parts.exp = exp; |
| result.parts.fraction = frac1 & ( (1 << FLOAT32_FRACTION_SIZE) - 1); |
| return result; |
| } |
| /** Multiply two 64 bit float numbers |
| * |
| */ |
| float64 mulFloat64(float64 a, float64 b) |
| { |
| float64 result; |
| uint64_t frac1, frac2; |
| int32_t exp; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat64NaN(a) || isFloat64NaN(b) ) { |
| /* TODO: fix SigNaNs */ |
| if (isFloat64SigNaN(a)) { |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| }; |
| if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */ |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| }; |
| /* set NaN as result */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| }; |
| if (isFloat64Infinity(a)) { |
| if (isFloat64Zero(b)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| } |
| if (isFloat64Infinity(b)) { |
| if (isFloat64Zero(a)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| } |
| /* exp is signed so we can easy detect underflow */ |
| exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS; |
| frac1 = a.parts.fraction; |
| if (a.parts.exp > 0) { |
| frac1 |= FLOAT64_HIDDEN_BIT_MASK; |
| } else { |
| ++exp; |
| }; |
| frac2 = b.parts.fraction; |
| if (b.parts.exp > 0) { |
| frac2 |= FLOAT64_HIDDEN_BIT_MASK; |
| } else { |
| ++exp; |
| }; |
| frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1); |
| frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2); |
| mul64integers(frac1, frac2, &frac1, &frac2); |
| frac2 |= (frac1 != 0); |
| if (frac2 & (0x1ll << 62)) { |
| frac2 <<= 1; |
| exp--; |
| } |
| result = finishFloat64(exp, frac2, result.parts.sign); |
| return result; |
| } |
| /** Multiply two 64 bit numbers and return result in two parts |
| * @param a first operand |
| * @param b second operand |
| * @param lo lower part from result |
| * @param hi higher part of result |
| */ |
| void mul64integers(uint64_t a,uint64_t b, uint64_t *lo, uint64_t *hi) |
| { |
| uint64_t low, high, middle1, middle2; |
| uint32_t alow, blow; |
| alow = a & 0xFFFFFFFF; |
| blow = b & 0xFFFFFFFF; |
| a >>= 32; |
| b >>= 32; |
| low = ((uint64_t)alow) * blow; |
| middle1 = a * blow; |
| middle2 = alow * b; |
| high = a * b; |
| middle1 += middle2; |
| high += (((uint64_t)(middle1 < middle2)) << 32) + (middle1 >> 32); |
| middle1 <<= 32; |
| low += middle1; |
| high += (low < middle1); |
| *lo = low; |
| *hi = high; |
| return; |
| } |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softint/Makefile |
|---|
| 0,0 → 1,74 |
| # |
| # Copyright (c) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Common compiler flags |
| # |
| LIBC_PREFIX = ../libc |
| ## Setup toolchain |
| # |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| CFLAGS += -Iinclude |
| ## Sources |
| # |
| ARCH_SOURCES = |
| GENERIC_SOURCES = \ |
| generic/division.c |
| GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES))) |
| .PHONY: all clean depend |
| all: libsoftint.a |
| -include Makefile.depend |
| clean: |
| -rm -f libsoftint.a Makefile.depend |
| find generic/ -name '*.o' -follow -exec rm \{\} \; |
| depend: |
| -makedepend -f - -- $(DEPEMD_DEFS) $(CFLAGS) -- $(GENERIC_SOURCES) > Makefile.depend 2> /dev/null |
| libsoftint.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| $(AR) rc libsoftint.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.s |
| $(AS) $(AFLAGS) $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /tags/0.4.1/uspace/lib/softint/include/division.h |
|---|
| 0,0 → 1,70 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softint |
| * @{ |
| */ |
| /** |
| * @file |
| */ |
| #ifndef __SOFTINT_DIVISION_H__ |
| #define __SOFTINT_DIVISION_H__ |
| /* 32bit integer division */ |
| int __divsi3(int a, int b); |
| /* 64bit integer division */ |
| long long __divdi3(long long a, long long b); |
| /* 32bit unsigned integer division */ |
| unsigned int __udivsi3(unsigned int a, unsigned int b); |
| /* 64bit unsigned integer division */ |
| unsigned long long __udivdi3(unsigned long long a, unsigned long long b); |
| /* 32bit remainder of the signed division */ |
| int __modsi3(int a, int b); |
| /* 64bit remainder of the signed division */ |
| long long __moddi3(long long a, long long b); |
| /* 32bit remainder of the unsigned division */ |
| unsigned int __umodsi3(unsigned int a, unsigned int b); |
| /* 64bit remainder of the unsigned division */ |
| unsigned long long __umoddi3(unsigned long long a, unsigned long long b); |
| unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b, unsigned long long *c); |
| #endif |
| /** @} |
| */ |
| /tags/0.4.1/uspace/lib/softint/generic/division.c |
|---|
| 0,0 → 1,197 |
| /* |
| * Copyright (c) 2006 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup softint |
| * @{ |
| */ |
| /** |
| * @file |
| * SW implementation of 32 and 64 bit division and modulo. |
| */ |
| #include <division.h> |
| #define ABSVAL(x) ( (x) > 0 ? (x) : -(x)) |
| #define SGN(x) ( (x) >= 0 ? 1 : 0 ) |
| static unsigned int divandmod32(unsigned int a, unsigned int b, unsigned int *remainder) |
| { |
| unsigned int result; |
| int steps = sizeof(unsigned int) * 8; |
| *remainder = 0; |
| result = 0; |
| if (b == 0) { |
| /* FIXME: division by zero */ |
| return 0; |
| } |
| if ( a < b) { |
| *remainder = a; |
| return 0; |
| } |
| for ( ; steps > 0; steps--) { |
| /* shift one bit to remainder */ |
| *remainder = ( (*remainder) << 1) | (( a >> 31) & 0x1); |
| result <<= 1; |
| if (*remainder >= b) { |
| *remainder -= b; |
| result |= 0x1; |
| } |
| a <<= 1; |
| } |
| return result; |
| } |
| static unsigned long long divandmod64(unsigned long long a, unsigned long long b, unsigned long long *remainder) |
| { |
| unsigned long long result; |
| int steps = sizeof(unsigned long long) * 8; |
| *remainder = 0; |
| result = 0; |
| if (b == 0) { |
| /* FIXME: division by zero */ |
| return 0; |
| } |
| if ( a < b) { |
| *remainder = a; |
| return 0; |
| } |
| for ( ; steps > 0; steps--) { |
| /* shift one bit to remainder */ |
| *remainder = ( (*remainder) << 1) | ((a >> 63) & 0x1); |
| result <<= 1; |
| if (*remainder >= b) { |
| *remainder -= b; |
| result |= 0x1; |
| } |
| a <<= 1; |
| } |
| return result; |
| } |
| /* 32bit integer division */ |
| int __divsi3(int a, int b) |
| { |
| unsigned int rem; |
| int result; |
| result = (int)divandmod32(ABSVAL(a), ABSVAL(b), &rem); |
| if ( SGN(a) == SGN(b)) return result; |
| return -result; |
| } |
| /* 64bit integer division */ |
| long long __divdi3(long long a, long long b) |
| { |
| unsigned long long rem; |
| long long result; |
| result = (long long)divandmod64(ABSVAL(a), ABSVAL(b), &rem); |
| if ( SGN(a) == SGN(b)) return result; |
| return -result; |
| } |
| /* 32bit unsigned integer division */ |
| unsigned int __udivsi3(unsigned int a, unsigned int b) |
| { |
| unsigned int rem; |
| return divandmod32(a, b, &rem); |
| } |
| /* 64bit unsigned integer division */ |
| unsigned long long __udivdi3(unsigned long long a, unsigned long long b) |
| { |
| unsigned long long rem; |
| return divandmod64(a, b, &rem); |
| } |
| /* 32bit remainder of the signed division */ |
| int __modsi3(int a, int b) |
| { |
| unsigned int rem; |
| divandmod32(a, b, &rem); |
| /* if divident is negative, remainder must be too */ |
| if (!(SGN(a))) { |
| return -((int)rem); |
| } |
| return (int)rem; |
| } |
| /* 64bit remainder of the signed division */ |
| long long __moddi3(long long a,long long b) |
| { |
| unsigned long long rem; |
| divandmod64(a, b, &rem); |
| /* if divident is negative, remainder must be too */ |
| if (!(SGN(a))) { |
| return -((long long)rem); |
| } |
| return (long long)rem; |
| } |
| /* 32bit remainder of the unsigned division */ |
| unsigned int __umodsi3(unsigned int a, unsigned int b) |
| { |
| unsigned int rem; |
| divandmod32(a, b, &rem); |
| return rem; |
| } |
| /* 64bit remainder of the unsigned division */ |
| unsigned long long __umoddi3(unsigned long long a, unsigned long long b) |
| { |
| unsigned long long rem; |
| divandmod64(a, b, &rem); |
| return rem; |
| } |
| unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b, unsigned long long *c) |
| { |
| return divandmod64(a, b, c); |
| } |
| /** @} |
| */ |