Changeset 5828554 in mainline for uspace/lib/c


Ignore:
Timestamp:
2014-01-19T14:37:22Z (12 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cf982ff
Parents:
2f591127 (diff), 476f62c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge mainline changes

Location:
uspace/lib/c
Files:
32 added
4 deleted
17 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r2f591127 r5828554  
    6161        generic/bd.c \
    6262        generic/bd_srv.c \
    63         generic/bitops.c \
    6463        generic/cap.c \
    6564        generic/cfg.c \
    … …  
    7069        generic/device/hw_res_parsed.c \
    7170        generic/device/pio_window.c \
    72         generic/device/char_dev.c \
    7371        generic/device/clock_dev.c \
    74         generic/device/battery_dev.c \
    75         generic/device/graph_dev.c \
    76         generic/device/nic.c \
    77         generic/device/pci.c \
    78         generic/device/ahci.c \
    7972        generic/dhcp.c \
    8073        generic/dnsr.c \
    … …  
    108101        generic/io/log.c \
    109102        generic/io/logctl.c \
     103        generic/io/kio.c \
    110104        generic/io/klog.c \
    111105        generic/io/snprintf.c \
    … …  
    129123        generic/loader.c \
    130124        generic/getopt.c \
     125        generic/adt/checksum.c \
    131126        generic/adt/list.c \
    132127        generic/adt/hash_table.c \
    … …  
    143138        generic/net/socket_client.c \
    144139        generic/net/socket_parse.c \
     140        generic/setjmp.c \
    145141        generic/stack.c \
    146142        generic/stacktrace.c \

  • uspace/lib/c/arch/abs32le/include/libarch/atomic.h

    r2f591127 r5828554  
    5353}
    5454
    55 static inline void atomic_inc(atomic_t *val) {
     55static inline void atomic_inc(atomic_t *val)
     56{
    5657        /* On real hardware the increment has to be done
    5758           as an atomic action. */
    … …  
    6061}
    6162
    62 static inline void atomic_dec(atomic_t *val) {
     63static inline void atomic_dec(atomic_t *val)
     64{
    6365        /* On real hardware the decrement has to be done
    6466           as an atomic action. */

  • uspace/lib/c/arch/amd64/_link.ld.in

    r2f591127 r5828554  
    3939        .data : {
    4040                *(.data);
     41                *(.data.rel*);
    4142        } :data
    4243       

  • uspace/lib/c/arch/ia32/Makefile.inc

    r2f591127 r5828554  
    3434        arch/$(UARCH)/src/fibril.S \
    3535        arch/$(UARCH)/src/tls.c \
    36         arch/$(UARCH)/src/setjmp.S \
    3736        arch/$(UARCH)/src/stacktrace.c \
    3837        arch/$(UARCH)/src/stacktrace_asm.S \

  • uspace/lib/c/arch/sparc32/src/stacktrace_asm.S

    r2f591127 r5828554  
    11#
    2 # Copyright (c) 2008 Josef Cejka
     2# Copyright (c) 2009 Jakub Jermar
    33# All rights reserved.
    44#
    … …  
    2727#
    2828
    29 #include <libarch/context_offset.h>
     29#include <libarch/stack.h>
    3030
    3131.text
    32 .global setjmp
    33 .global longjmp
    3432
    35 .type setjmp,@function
    36 setjmp:
    37         movl 0(%esp), %eax  # save pc value into eax
    38         movl 4(%esp), %edx  # address of the jmp_buf structure to save context to
     33.global stacktrace_prepare
     34.global stacktrace_fp_get
     35.global stacktrace_pc_get
     36
     37stacktrace_prepare:
     38        save %sp, -(STACK_WINDOW_SAVE_AREA_SIZE+STACK_ARG_SAVE_AREA_SIZE), %sp
    3939       
    40         # save registers to the jmp_buf structure
    41         CONTEXT_SAVE_ARCH_CORE %edx %eax
     40        # Flush all other windows to memory so that we can read their contents.
    4241       
    43         xorl %eax, %eax     # set_jmp returns 0
     42        mov 7, %g1
     43        1:
     44                subcc %g1, 1, %g1
     45                bg 1b
     46                save %sp, -64, %sp
     47       
     48        mov 7, %g1
     49        1:
     50                subcc %g1, 1, %g1
     51                bg 1b
     52       
    4453        ret
     54        restore
    4555
    46 .type longjmp,@function
    47 longjmp:
    48         movl 4(%esp), %ecx  # put address of jmp_buf into ecx
    49         movl 8(%esp), %eax  # put return value into eax
    50        
    51         # restore registers from the jmp_buf structure
    52         CONTEXT_RESTORE_ARCH_CORE %ecx %edx
    53        
    54         movl %edx, 0(%esp)  # put saved pc on stack
    55         ret
     56stacktrace_fp_get:
     57        # Add the stack bias to %sp to get the actual address.
     58        retl
     59        mov %sp,  %o0
     60
     61stacktrace_pc_get:
     62        retl
     63        mov %o7, %o0

  • uspace/lib/c/generic/assert.c

    r2f591127 r5828554  
    3333#include <assert.h>
    3434#include <stdio.h>
    35 #include <io/klog.h>
     35#include <io/kio.h>
    3636#include <stdlib.h>
    3737#include <atomic.h>
    … …  
    4444{
    4545        /*
    46          * Send the message safely to klog. Nested asserts should not occur.
     46         * Send the message safely to kio. Nested asserts should not occur.
    4747         */
    48         klog_printf("Assertion failed (%s) in file \"%s\", line %u.\n",
     48        kio_printf("Assertion failed (%s) in file \"%s\", line %u.\n",
    4949            cond, file, line);
    5050       

  • uspace/lib/c/generic/ddi.c

    r2f591127 r5828554  
    280280 *
    281281 */
    282 int irq_register(int inr, int devno, int method, irq_code_t *ucode)
     282int irq_register(int inr, int devno, int method, const irq_code_t *ucode)
    283283{
    284284        return __SYSCALL4(SYS_IRQ_REGISTER, inr, devno, method,

  • uspace/lib/c/generic/io/io.c

    r2f591127 r5828554  
    4242#include <malloc.h>
    4343#include <async.h>
    44 #include <io/klog.h>
     44#include <io/kio.h>
    4545#include <vfs/vfs.h>
    4646#include <vfs/vfs_sess.h>
    … …  
    5757        .error = true,
    5858        .eof = true,
    59         .klog = false,
     59        .kio = false,
    6060        .sess = NULL,
    6161        .btype = _IONBF,
    … …  
    6767};
    6868
    69 static FILE stdout_klog = {
     69static FILE stdout_kio = {
    7070        .fd = -1,
    7171        .error = false,
    7272        .eof = false,
    73         .klog = true,
     73        .kio = true,
    7474        .sess = NULL,
    7575        .btype = _IOLBF,
    … …  
    8181};
    8282
    83 static FILE stderr_klog = {
     83static FILE stderr_kio = {
    8484        .fd = -1,
    8585        .error = false,
    8686        .eof = false,
    87         .klog = true,
     87        .kio = true,
    8888        .sess = NULL,
    8989        .btype = _IONBF,
    … …  
    113113                stdout = fdopen(1, "w");
    114114        } else {
    115                 stdout = &stdout_klog;
     115                stdout = &stdout_kio;
    116116                list_append(&stdout->link, &files);
    117117        }
    … …  
    120120                stderr = fdopen(2, "w");
    121121        } else {
    122                 stderr = &stderr_klog;
     122                stderr = &stderr_kio;
    123123                list_append(&stderr->link, &files);
    124124        }
    … …  
    267267        stream->error = false;
    268268        stream->eof = false;
    269         stream->klog = false;
     269        stream->kio = false;
    270270        stream->sess = NULL;
    271271        stream->need_sync = false;
    … …  
    289289        stream->error = false;
    290290        stream->eof = false;
    291         stream->klog = false;
     291        stream->kio = false;
    292292        stream->sess = NULL;
    293293        stream->need_sync = false;
    … …  
    314314       
    315315        if ((stream != &stdin_null)
    316             && (stream != &stdout_klog)
    317             && (stream != &stderr_klog))
     316            && (stream != &stdout_kio)
     317            && (stream != &stderr_kio))
    318318                free(stream);
    319319       
    … …  
    382382                ssize_t wr;
    383383               
    384                 if (stream->klog)
    385                         wr = klog_write(buf + done, left);
     384                if (stream->kio)
     385                        wr = kio_write(buf + done, left);
    386386                else
    387387                        wr = write(stream->fd, buf + done, left);
    … …  
    705705        _fflushbuf(stream);
    706706       
    707         if (stream->klog) {
    708                 klog_update();
     707        if (stream->kio) {
     708                kio_update();
    709709                return EOK;
    710710        }
    … …  
    740740int fileno(FILE *stream)
    741741{
    742         if (stream->klog) {
     742        if (stream->kio) {
    743743                errno = EBADF;
    744744                return -1;

  • uspace/lib/c/generic/io/klog.c

    r2f591127 r5828554  
    11/*
    2  * Copyright (c) 2006 Josef Cejka
    3  * Copyright (c) 2006 Jakub Vana
     2 * Copyright (c) 2013 Martin Sucha
    43 * All rights reserved.
    54 *
    … …  
    4140#include <abi/klog.h>
    4241#include <io/klog.h>
    43 #include <io/printf_core.h>
     42#include <abi/log.h>
    4443
    45 size_t klog_write(const void *buf, size_t size)
     44size_t klog_write(log_level_t lvl, const void *buf, size_t size)
    4645{
    47         ssize_t ret = (ssize_t) __SYSCALL3(SYS_KLOG, KLOG_WRITE, (sysarg_t) buf, size);
     46        ssize_t ret = (ssize_t) __SYSCALL4(SYS_KLOG, KLOG_WRITE, (sysarg_t) buf,
     47            size, lvl);
    4848       
    4949        if (ret >= 0)
    … …  
    5353}
    5454
    55 void klog_update(void)
     55int klog_read(void *data, size_t size)
    5656{
    57         (void) __SYSCALL3(SYS_KLOG, KLOG_UPDATE, (uintptr_t) NULL, 0);
    58 }
    59 
    60 void klog_command(const void *buf, size_t size)
    61 {
    62         (void) __SYSCALL3(SYS_KLOG, KLOG_COMMAND, (sysarg_t) buf, (sysarg_t) size);
    63 }
    64 
    65 /** Print formatted text to klog.
    66  *
    67  * @param fmt Format string
    68  *
    69  * \see For more details about format string see printf_core.
    70  *
    71  */
    72 int klog_printf(const char *fmt, ...)
    73 {
    74         va_list args;
    75         va_start(args, fmt);
    76        
    77         int ret = klog_vprintf(fmt, args);
    78        
    79         va_end(args);
    80        
    81         return ret;
    82 }
    83 
    84 static int klog_vprintf_str_write(const char *str, size_t size, void *data)
    85 {
    86         size_t wr = klog_write(str, size);
    87         return str_nlength(str, wr);
    88 }
    89 
    90 static int klog_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
    91 {
    92         size_t offset = 0;
    93         size_t chars = 0;
    94        
    95         while (offset < size) {
    96                 char buf[STR_BOUNDS(1)];
    97                 size_t sz = 0;
    98                
    99                 if (chr_encode(str[chars], buf, &sz, STR_BOUNDS(1)) == EOK)
    100                         klog_write(buf, sz);
    101                
    102                 chars++;
    103                 offset += sizeof(wchar_t);
    104         }
    105        
    106         return chars;
    107 }
    108 
    109 /** Print formatted text to klog.
    110  *
    111  * @param fmt Format string
    112  * @param ap  Format parameters
    113  *
    114  * \see For more details about format string see printf_core.
    115  *
    116  */
    117 int klog_vprintf(const char *fmt, va_list ap)
    118 {
    119         printf_spec_t ps = {
    120                 klog_vprintf_str_write,
    121                 klog_vprintf_wstr_write,
    122                 NULL
    123         };
    124        
    125         return printf_core(fmt, &ps, ap);
     57        return (int) __SYSCALL4(SYS_KLOG, KLOG_READ, (uintptr_t) data, size, 0);
    12658}
    12759

  • uspace/lib/c/generic/io/window.c

    r2f591127 r5828554  
    4040#include <stdio.h>
    4141
    42 int win_register(async_sess_t *sess, service_id_t *in, service_id_t *out,
    43     sysarg_t x_offset, sysarg_t y_offset)
     42int win_register(async_sess_t *sess, service_id_t *in, service_id_t *out)
    4443{
    4544        async_exch_t *exch = async_exchange_begin(sess);
    46         int ret = async_req_2_2(exch, WINDOW_REGISTER, x_offset, y_offset, in, out);
     45        int ret = async_req_0_2(exch, WINDOW_REGISTER, in, out);
    4746        async_exchange_end(exch);
    48 
     47       
    4948        return ret;
    5049}
    … …  
    9291}
    9392
    94 int win_resize(async_sess_t *sess, sysarg_t width, sysarg_t height, void *cells)
     93int win_resize(async_sess_t *sess, sysarg_t x, sysarg_t y, sysarg_t width,
     94    sysarg_t height, window_placement_flags_t placement_flags, void *cells)
    9595{
    9696        async_exch_t *exch = async_exchange_begin(sess);
    97 
     97       
    9898        ipc_call_t answer;
    99         aid_t req = async_send_2(exch, WINDOW_RESIZE, width, height, &answer);
    100 
     99        aid_t req = async_send_5(exch, WINDOW_RESIZE, x, y, width, height,
     100            (sysarg_t) placement_flags, &answer);
     101       
    101102        int rc = async_share_out_start(exch, cells, AS_AREA_READ | AS_AREA_CACHEABLE);
    102 
     103       
    103104        async_exchange_end(exch);
    104 
     105       
    105106        sysarg_t ret;
    106107        async_wait_for(req, &ret);
    107 
    108         if (rc != EOK) {
     108       
     109        if (rc != EOK)
    109110                return rc;
    110         } else if (ret != EOK) {
     111        else if (ret != EOK)
    111112                return ret;
    112         } else {
    113                 return EOK;
    114         }
     113       
     114        return EOK;
    115115}
    116116

  • uspace/lib/c/generic/private/stdio.h

    r2f591127 r5828554  
    5353        int eof;
    5454       
    55         /** Klog indicator */
    56         int klog;
     55        /** KIO indicator */
     56        int kio;
    5757       
    5858        /** Session to the file provider */

  • uspace/lib/c/include/bitops.h

    r2f591127 r5828554  
    107107}
    108108
    109 extern int __popcountsi2(int);
    110 
    111109#endif
    112110

  • uspace/lib/c/include/ddi.h

    r2f591127 r5828554  
    130130}
    131131
    132 extern int irq_register(int, int, int, irq_code_t *);
     132extern int irq_register(int, int, int, const irq_code_t *);
    133133extern int irq_unregister(int, int);
    134134

  • uspace/lib/c/include/io/klog.h

    r2f591127 r5828554  
    11/*
    2  * Copyright (c) 2006 Jakub Vana
     2 * Copyright (c) 2013 Martin Sucha
    33 * All rights reserved.
    44 *
    … …  
    3939#include <stdarg.h>
    4040#include <io/verify.h>
     41#include <stdio.h>
     42#include <stdlib.h>
     43#include <str.h>
     44#include <abi/log.h>
    4145
    42 extern size_t klog_write(const void *, size_t);
    43 extern void klog_update(void);
    44 extern void klog_command(const void *, size_t);
    45 extern int klog_printf(const char *, ...)
    46     PRINTF_ATTRIBUTE(1, 2);
    47 extern int klog_vprintf(const char *, va_list);
     46extern size_t klog_write(log_level_t, const void *, size_t);
     47extern int klog_read(void *, size_t);
     48
     49#define KLOG_PRINTF(lvl, fmt, ...) ({ \
     50        char *_fmt = str_dup(fmt); \
     51        size_t _fmtsize = str_size(_fmt); \
     52        if (_fmtsize > 0 && _fmt[_fmtsize - 1] == '\n') \
     53                _fmt[_fmtsize - 1] = 0; \
     54        char *_s; \
     55        int _c = asprintf(&_s, _fmt, ##__VA_ARGS__); \
     56        free(_fmt); \
     57        if (_c >= 0) { \
     58                _c = klog_write((lvl), _s, str_size(_s)); \
     59                free(_s); \
     60        }; \
     61        (_c >= 0); \
     62})
    4863
    4964#endif

  • uspace/lib/c/include/io/log.h

    r2f591127 r5828554  
    3939#include <io/verify.h>
    4040
    41 /** Log message level. */
    42 typedef enum {
    43         /** Fatal error, program is not able to recover at all. */
    44         LVL_FATAL,
    45         /** Serious error but the program can recover from it. */
    46         LVL_ERROR,
    47         /** Easily recoverable problem. */
    48         LVL_WARN,
    49         /** Information message that ought to be printed by default. */
    50         LVL_NOTE,
    51         /** Debugging purpose message. */
    52         LVL_DEBUG,
    53         /** More detailed debugging message. */
    54         LVL_DEBUG2,
    55        
    56         /** For checking range of values */
    57         LVL_LIMIT
    58 } log_level_t;
     41#include <abi/log.h>
    5942
    6043/** Log itself (logging target). */

  • uspace/lib/c/include/io/window.h

    r2f591127 r5828554  
    4343#include <io/pos_event.h>
    4444
     45typedef enum {
     46        GF_EMPTY = 0,
     47        GF_MOVE_X = 1,
     48        GF_MOVE_Y = 2,
     49        GF_RESIZE_X = 4,
     50        GF_RESIZE_Y = 8,
     51        GF_SCALE_X = 16,
     52        GF_SCALE_Y = 32
     53} window_grab_flags_t;
     54
     55typedef enum {
     56        WINDOW_PLACEMENT_ANY = 0,
     57        WINDOW_PLACEMENT_CENTER_X = 1,
     58        WINDOW_PLACEMENT_CENTER_Y = 2,
     59        WINDOW_PLACEMENT_CENTER =
     60            WINDOW_PLACEMENT_CENTER_X | WINDOW_PLACEMENT_CENTER_Y,
     61        WINDOW_PLACEMENT_LEFT = 4,
     62        WINDOW_PLACEMENT_RIGHT = 8,
     63        WINDOW_PLACEMENT_TOP = 16,
     64        WINDOW_PLACEMENT_BOTTOM = 32,
     65        WINDOW_PLACEMENT_ABSOLUTE_X = 64,
     66        WINDOW_PLACEMENT_ABSOLUTE_Y = 128,
     67        WINDOW_PLACEMENT_ABSOLUTE =
     68            WINDOW_PLACEMENT_ABSOLUTE_X | WINDOW_PLACEMENT_ABSOLUTE_Y
     69} window_placement_flags_t;
     70
    4571typedef struct {
    4672        sysarg_t object;
    4773        sysarg_t slot;
    4874        sysarg_t argument;
    49 } sig_event_t;
     75} signal_event_t;
    5076
    5177typedef struct {
     78        sysarg_t offset_x;
     79        sysarg_t offset_y;
    5280        sysarg_t width;
    5381        sysarg_t height;
    54 } rsz_event_t;
     82        window_placement_flags_t placement_flags;
     83} resize_event_t;
    5584
    5685typedef enum {
    … …  
    6998        kbd_event_t kbd;
    7099        pos_event_t pos;
    71         sig_event_t sig;
    72         rsz_event_t rsz;
     100        signal_event_t signal;
     101        resize_event_t resize;
    73102} window_event_data_t;
    74103
    … …  
    79108} window_event_t;
    80109
    81 typedef enum {
    82         GF_EMPTY = 0,
    83         GF_MOVE_X = 1,
    84         GF_MOVE_Y = 2,
    85         GF_RESIZE_X = 4,
    86         GF_RESIZE_Y = 8,
    87         GF_SCALE_X = 16,
    88         GF_SCALE_Y = 32
    89 } window_grab_flags_t;
    90 
    91 extern int win_register(async_sess_t *, service_id_t *, service_id_t *, sysarg_t, sysarg_t);
     110extern int win_register(async_sess_t *, service_id_t *, service_id_t *);
    92111
    93112extern int win_get_event(async_sess_t *, window_event_t *);
    … …  
    95114extern int win_damage(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
    96115extern int win_grab(async_sess_t *, sysarg_t, sysarg_t);
    97 extern int win_resize(async_sess_t *, sysarg_t, sysarg_t, void *);
     116extern int win_resize(async_sess_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
     117    window_placement_flags_t, void *);
    98118extern int win_close(async_sess_t *);
    99119extern int win_close_request(async_sess_t *);

  • uspace/lib/c/include/setjmp.h

    r2f591127 r5828554  
    11/*
    22 * Copyright (c) 2008 Josef Cejka
     3 * Copyright (c) 2013 Vojtech Horky
    34 * All rights reserved.
    45 *
    … …  
    3031 * @{
    3132 */
    32 /** @file
     33/** @file Long jump implementation.
     34 *
     35 * Implementation inspired by Jiri Zarevucky's code from
     36 * http://bazaar.launchpad.net/~zarevucky-jiri/helenos/stdc/revision/1544/uspace/lib/posix/setjmp.h
    3337 */
    3438
    … …  
    3842#include <libarch/fibril.h>
    3943
    40 typedef context_t jmp_buf[1];
     44struct jmp_buf_interal {
     45        context_t context;
     46        int return_value;
     47};
     48typedef struct jmp_buf_interal jmp_buf[1];
    4149
    42 extern int setjmp(jmp_buf env);
     50/*
     51 * Specified as extern to minimize number of included headers
     52 * because this file is used as is in libposix too.
     53 */
     54extern int context_save(context_t *ctx) __attribute__((returns_twice));
     55
     56/**
     57 * Save current environment (registers).
     58 *
     59 * This function may return twice.
     60 *
     61 * @param env Variable where to save the environment (of type jmp_buf).
     62 * @return Whether the call returned after longjmp.
     63 * @retval 0 Environment was saved, normal execution.
     64 * @retval other longjmp was executed and returned here.
     65 */
     66#define setjmp(env) \
     67        ((env)[0].return_value = 0, \
     68        context_save(&(env)[0].context), \
     69        (env)[0].return_value)
     70
    4371extern void longjmp(jmp_buf env, int val) __attribute__((noreturn));
    4472

  • uspace/lib/c/include/stdio.h

    r2f591127 r5828554  
    4040#include <str.h>
    4141#include <io/verify.h>
    42 #include <abi/klog.h>
     42#include <abi/kio.h>
    4343
    4444#define EOF  (-1)
    … …  
    5252                int _n = snprintf(_buf, sizeof(_buf), fmt, ##__VA_ARGS__); \
    5353                if (_n > 0) \
    54                         (void) __SYSCALL3(SYS_KLOG, KLOG_WRITE, (sysarg_t) _buf, str_size(_buf)); \
     54                        (void) __SYSCALL3(SYS_KIO, KIO_WRITE, (sysarg_t) _buf, str_size(_buf)); \
    5555        }
    5656
Note: See TracChangeset for help on using the changeset viewer.