Changeset 30c4005 in mainline for uspace


Ignore:
Timestamp:
2011-04-29T19:56:07Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2874547
Parents:
6b40ea7 (diff), afdcc60e (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 improvements

Location:
uspace
Files:
3 added
39 edited

Legend:

Unmodified
Added
Removed

  • uspace/Makefile.common

    r6b40ea7 r30c4005  
    187187
    188188$(BINARY): $(LINKER_SCRIPT) $(OBJECTS) $(LIBS) $(BASE_LIBS)
    189         $(LD) -N $(LFLAGS) -T $(LINKER_SCRIPT) -M -Map $(BINARY).map -o $(BINARY) $(OBJECTS) $(LIBS) $(BASE_LIBS)
     189        $(LD) -n $(LFLAGS) -T $(LINKER_SCRIPT) -M -Map $(BINARY).map -o $(BINARY) $(OBJECTS) $(LIBS) $(BASE_LIBS)
    190190ifeq ($(CONFIG_STRIP_BINARIES),y)
    191191        $(STRIP) $(BINARY)

  • uspace/app/klog/klog.c

    r6b40ea7 r30c4005  
    118118        }
    119119       
    120         /*
    121          * Mode "a" would be definitively much better here, but it is
    122          * not well supported by the FAT driver.
    123          */
    124         log = fopen(LOG_FNAME, "w");
     120        log = fopen(LOG_FNAME, "a");
    125121        if (log == NULL)
    126122                printf("%s: Unable to create log file %s (%s)\n", NAME, LOG_FNAME,

  • uspace/app/stats/stats.c

    r6b40ea7 r30c4005  
    6969        size_t i;
    7070        for (i = 0; i < count; i++) {
    71                 uint64_t resmem, virtmem, ucycles, kcycles;
    72                 char resmem_suffix, virtmem_suffix, usuffix, ksuffix;
    73                
    74                 order_suffix(stats_tasks[i].resmem, &resmem, &resmem_suffix);
    75                 order_suffix(stats_tasks[i].virtmem, &virtmem, &virtmem_suffix);
     71                uint64_t resmem;
     72                uint64_t virtmem;
     73                uint64_t ucycles;
     74                uint64_t kcycles;
     75                const char *resmem_suffix;
     76                const char *virtmem_suffix;
     77                char usuffix;
     78                char ksuffix;
     79               
     80                bin_order_suffix(stats_tasks[i].resmem, &resmem, &resmem_suffix, true);
     81                bin_order_suffix(stats_tasks[i].virtmem, &virtmem, &virtmem_suffix, true);
    7682                order_suffix(stats_tasks[i].ucycles, &ucycles, &usuffix);
    7783                order_suffix(stats_tasks[i].kcycles, &kcycles, &ksuffix);
    7884               
    79                 printf("%-8" PRIu64 " %7zu %9" PRIu64 "%c %8" PRIu64 "%c"
     85                printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s %6" PRIu64 "%s"
    8086                    " %8" PRIu64 "%c %8" PRIu64 "%c %s\n",
    8187                    stats_tasks[i].task_id, stats_tasks[i].threads,

  • uspace/app/tester/Makefile

    r6b40ea7 r30c4005  
    4949        loop/loop1.c \
    5050        mm/malloc1.c \
     51        mm/malloc2.c \
    5152        devs/devman1.c \
    5253        hw/misc/virtchar1.c \

  • uspace/app/tester/tester.c

    r6b40ea7 r30c4005  
    6262#include "loop/loop1.def"
    6363#include "mm/malloc1.def"
     64#include "mm/malloc2.def"
    6465#include "hw/serial/serial1.def"
    6566#include "hw/misc/virtchar1.def"

  • uspace/app/tester/tester.h

    r6b40ea7 r30c4005  
    7878extern const char *test_loop1(void);
    7979extern const char *test_malloc1(void);
     80extern const char *test_malloc2(void);
    8081extern const char *test_serial1(void);
    8182extern const char *test_virtchar1(void);

  • uspace/app/top/screen.c

    r6b40ea7 r30c4005  
    254254        uint64_t used;
    255255        uint64_t free;
    256         char total_suffix;
    257         char unavail_suffix;
    258         char used_suffix;
    259         char free_suffix;
    260        
    261         order_suffix(data->physmem->total, &total, &total_suffix);
    262         order_suffix(data->physmem->unavail, &unavail, &unavail_suffix);
    263         order_suffix(data->physmem->used, &used, &used_suffix);
    264         order_suffix(data->physmem->free, &free, &free_suffix);
    265        
    266         printf("memory: %" PRIu64 "%c total, %" PRIu64 "%c unavail, %"
    267             PRIu64 "%c used, %" PRIu64 "%c free", total, total_suffix,
     256        const char *total_suffix;
     257        const char *unavail_suffix;
     258        const char *used_suffix;
     259        const char *free_suffix;
     260       
     261        bin_order_suffix(data->physmem->total, &total, &total_suffix, false);
     262        bin_order_suffix(data->physmem->unavail, &unavail, &unavail_suffix, false);
     263        bin_order_suffix(data->physmem->used, &used, &used_suffix, false);
     264        bin_order_suffix(data->physmem->free, &free, &free_suffix, false);
     265       
     266        printf("memory: %" PRIu64 "%s total, %" PRIu64 "%s unavail, %"
     267            PRIu64 "%s used, %" PRIu64 "%s free", total, total_suffix,
    268268            unavail, unavail_suffix, used, used_suffix, free, free_suffix);
    269269        screen_newline();
    … …  
    295295               
    296296                uint64_t resmem;
    297                 char resmem_suffix;
    298                 order_suffix(task->resmem, &resmem, &resmem_suffix);
     297                const char *resmem_suffix;
     298                bin_order_suffix(task->resmem, &resmem, &resmem_suffix, true);
    299299               
    300300                uint64_t virtmem;
    301                 char virtmem_suffix;
    302                 order_suffix(task->virtmem, &virtmem, &virtmem_suffix);
    303                
    304                 printf("%-8" PRIu64 " %7zu %9" PRIu64 "%c ",
     301                const char *virtmem_suffix;
     302                bin_order_suffix(task->virtmem, &virtmem, &virtmem_suffix, true);
     303               
     304                printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s ",
    305305                    task->task_id, task->threads, resmem, resmem_suffix);
    306306                print_percent(perc->resmem, 2);
    307                 printf(" %8" PRIu64 "%c ", virtmem, virtmem_suffix);
     307                printf(" %6" PRIu64 "%s ", virtmem, virtmem_suffix);
    308308                print_percent(perc->virtmem, 2);
    309309                puts(" ");

  • uspace/lib/block/libblock.c

    r6b40ea7 r30c4005  
    5151#include <macros.h>
    5252#include <mem.h>
     53#include <malloc.h>
     54#include <stdio.h>
    5355#include <sys/typefmt.h>
    5456#include <stacktrace.h>

  • uspace/lib/c/Makefile

    r6b40ea7 r30c4005  
    113113        generic/arg_parse.c \
    114114        generic/sort.c \
    115         generic/stats.c
     115        generic/stats.c \
     116        generic/assert.c \
    116117
    117118SOURCES = \

  • uspace/lib/c/arch/ia32/include/config.h

    r6b40ea7 r30c4005  
    3636#define LIBC_ia32_CONFIG_H_
    3737
    38 #define PAGE_WIDTH      12
    39 #define PAGE_SIZE       (1 << PAGE_WIDTH)
     38#define PAGE_WIDTH  12
     39#define PAGE_SIZE   (1 << PAGE_WIDTH)
     40
     41#define USER_ADDRESS_SPACE_START_ARCH  UINT32_C(0x00000000)
     42#define USER_ADDRESS_SPACE_END_ARCH    UINT32_C(0x7fffffff)
    4043
    4144#endif

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

    r6b40ea7 r30c4005  
    3737#include <libarch/types.h>
    3838
    39 #define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
     39#define IO_SPACE_BOUNDARY  ((void *) (64 * 1024))
    4040
    4141static inline uint8_t pio_read_8(ioport8_t *port)

  • uspace/lib/c/arch/ia32/include/faddr.h

    r6b40ea7 r30c4005  
    3838#include <libarch/types.h>
    3939
    40 #define FADDR(fptr)             ((uintptr_t) (fptr))
     40#define FADDR(fptr)  ((uintptr_t) (fptr))
    4141
    4242#endif

  • uspace/lib/c/arch/ia32/include/fibril.h

    r6b40ea7 r30c4005  
    4242 * panic sooner or later
    4343 */
    44 #define SP_DELTA     (12)
     44#define SP_DELTA  12
    4545
    4646#define context_set(c, _pc, stack, size, ptls) \
    … …  
    5151                (c)->ebp = 0; \
    5252        } while (0)
    53        
    54 /* We include only registers that must be preserved
     53
     54/*
     55 * We include only registers that must be preserved
    5556 * during function call
    5657 */

  • uspace/lib/c/arch/ia32/src/stacktrace.c

    r6b40ea7 r30c4005  
    3535 */
    3636
     37#include <libarch/config.h>
    3738#include <sys/types.h>
    3839#include <bool.h>
    39 
    4040#include <stacktrace.h>
    4141
    42 #define FRAME_OFFSET_FP_PREV    0
    43 #define FRAME_OFFSET_RA         4
     42#define FRAME_OFFSET_FP_PREV  0
     43#define FRAME_OFFSET_RA       4
    4444
    4545bool stacktrace_fp_valid(stacktrace_t *st, uintptr_t fp)
    4646{
    4747        (void) st;
    48         return fp != 0;
     48        return (fp != 0) && (fp <= USER_ADDRESS_SPACE_END_ARCH);
    4949}
    5050

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

    r6b40ea7 r30c4005  
    2222       
    2323        .got : {
    24                 _gp = .;
     24                /* Tell the linker where we expect GP to point. */
     25                __gp = .;
    2526                *(.got .got.*);
    2627        } :data

  • uspace/lib/c/arch/ia64/src/entry.s

    r6b40ea7 r30c4005  
    3939__entry:
    4040        alloc loc0 = ar.pfs, 0, 1, 2, 0
    41         movl gp = _gp
     41        movl gp = __gp
    4242       
    4343        # Pass PCB pointer as the first argument to __main

  • uspace/lib/c/arch/ia64/src/thread_entry.s

    r6b40ea7 r30c4005  
    3737        alloc loc0 = ar.pfs, 0, 1, 1, 0
    3838
    39         movl gp = _gp
     39        movl gp = __gp
    4040       
    4141        #

  • uspace/lib/c/generic/async.c

    r6b40ea7 r30c4005  
    102102#include <arch/barrier.h>
    103103#include <bool.h>
     104#include <stdlib.h>
     105#include <malloc.h>
    104106#include "private/async.h"
    105107

  • uspace/lib/c/generic/async_sess.c

    r6b40ea7 r30c4005  
    105105#include <errno.h>
    106106#include <assert.h>
     107#include <async.h>
    107108#include "private/async_sess.h"
    108109

  • uspace/lib/c/generic/errno.c

    r6b40ea7 r30c4005  
    3636#include <fibril.h>
    3737
    38 int _errno;
     38static fibril_local int fibril_errno;
     39
     40int *__errno(void)
     41{
     42        return &fibril_errno;
     43}
    3944
    4045/** @}

  • uspace/lib/c/generic/fibril_synch.c

    r6b40ea7 r30c4005  
    4343#include <stacktrace.h>
    4444#include <stdlib.h>
     45#include <stdio.h>
    4546#include "private/async.h"
    4647

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

    r6b40ea7 r30c4005  
    173173                }
    174174                *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
     175                break;
    175176        default:
    176177                errno = EINVAL;

  • uspace/lib/c/generic/malloc.c

    r6b40ea7 r30c4005  
    4444#include <mem.h>
    4545#include <futex.h>
     46#include <stdlib.h>
    4647#include <adt/gcdlcm.h>
    4748#include "private/malloc.h"

  • uspace/lib/c/generic/stacktrace.c

    r6b40ea7 r30c4005  
    6161        stacktrace_prepare();
    6262        stacktrace_print_fp_pc(stacktrace_fp_get(), stacktrace_pc_get());
     63       
    6364        /*
    6465         * Prevent the tail call optimization of the previous call by
    6566         * making it a non-tail call.
    6667         */
    67         (void) stacktrace_fp_get();
     68       
     69        printf("-- end of stack trace --\n");
    6870}
    6971

  • uspace/lib/c/generic/str.c

    r6b40ea7 r30c4005  
    12151215void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
    12161216{
    1217         if (val > 10000000000000000000ULL) {
    1218                 *rv = val / 1000000000000000000ULL;
     1217        if (val > UINT64_C(10000000000000000000)) {
     1218                *rv = val / UINT64_C(1000000000000000000);
    12191219                *suffix = 'Z';
    1220         } else if (val > 1000000000000000000ULL) {
    1221                 *rv = val / 1000000000000000ULL;
     1220        } else if (val > UINT64_C(1000000000000000000)) {
     1221                *rv = val / UINT64_C(1000000000000000);
    12221222                *suffix = 'E';
    1223         } else if (val > 1000000000000000ULL) {
    1224                 *rv = val / 1000000000000ULL;
     1223        } else if (val > UINT64_C(1000000000000000)) {
     1224                *rv = val / UINT64_C(1000000000000);
    12251225                *suffix = 'T';
    1226         } else if (val > 1000000000000ULL) {
    1227                 *rv = val / 1000000000ULL;
     1226        } else if (val > UINT64_C(1000000000000)) {
     1227                *rv = val / UINT64_C(1000000000);
    12281228                *suffix = 'G';
    1229         } else if (val > 1000000000ULL) {
    1230                 *rv = val / 1000000ULL;
     1229        } else if (val > UINT64_C(1000000000)) {
     1230                *rv = val / UINT64_C(1000000);
    12311231                *suffix = 'M';
    1232         } else if (val > 1000000ULL) {
    1233                 *rv = val / 1000ULL;
     1232        } else if (val > UINT64_C(1000000)) {
     1233                *rv = val / UINT64_C(1000);
    12341234                *suffix = 'k';
    12351235        } else {
    … …  
    12391239}
    12401240
     1241void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix,
     1242    bool fixed)
     1243{
     1244        if (val > UINT64_C(1152921504606846976)) {
     1245                *rv = val / UINT64_C(1125899906842624);
     1246                *suffix = "EiB";
     1247        } else if (val > UINT64_C(1125899906842624)) {
     1248                *rv = val / UINT64_C(1099511627776);
     1249                *suffix = "TiB";
     1250        } else if (val > UINT64_C(1099511627776)) {
     1251                *rv = val / UINT64_C(1073741824);
     1252                *suffix = "GiB";
     1253        } else if (val > UINT64_C(1073741824)) {
     1254                *rv = val / UINT64_C(1048576);
     1255                *suffix = "MiB";
     1256        } else if (val > UINT64_C(1048576)) {
     1257                *rv = val / UINT64_C(1024);
     1258                *suffix = "KiB";
     1259        } else {
     1260                *rv = val;
     1261                if (fixed)
     1262                        *suffix = "B  ";
     1263                else
     1264                        *suffix = "B";
     1265        }
     1266}
     1267
    12411268/** @}
    12421269 */

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

    r6b40ea7 r30c4005  
    4040 *
    4141 * If NDEBUG is not set, the assert() macro
    42  * evaluates expr and if it is false prints 
     42 * evaluates expr and if it is false prints
    4343 * error message and terminate program.
    4444 *
    … …  
    4747 */
    4848
    49 #include <stdio.h>
    50 #include <stdlib.h>
    51 
    5249#ifndef NDEBUG
    5350
    5451#define assert(expr) \
    5552        do { \
    56                 if (!(expr)) { \
    57                         printf("Assertion failed (%s) at file '%s', " \
    58                             "line %d.\n", #expr, __FILE__, __LINE__); \
    59                         abort(); \
    60                 } \
     53                if (!(expr)) \
     54                        assert_abort(#expr, __FILE__, __LINE__); \
    6155        } while (0)
    6256
    … …  
    6761#endif /* NDEBUG */
    6862
     63extern void assert_abort(const char *, const char *, unsigned int)
     64    __attribute__((noreturn));
     65
    6966#endif
    7067

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

    r6b40ea7 r30c4005  
    3939#include <fibril.h>
    4040
    41 #define errno _errno
     41#define errno  (*(__errno()))
    4242
    43 extern int _errno;
     43extern int *__errno(void) __attribute__((const));
    4444
    4545#define EMFILE        (-18)

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

    r6b40ea7 r30c4005  
    3636#define LIBC_FIBRIL_SYNCH_H_
    3737
    38 #include <async.h>
    3938#include <fibril.h>
    4039#include <adt/list.h>
    4140#include <libarch/tls.h>
    4241#include <sys/time.h>
     42#include <bool.h>
    4343
    4444typedef struct {
    45         fibril_owner_info_t oi;         /* Keep this the first thing. */
     45        fibril_owner_info_t oi;  /**< Keep this the first thing. */
    4646        int counter;
    4747        link_t waiters;
    … …  
    6464
    6565typedef struct {
    66         fibril_owner_info_t oi; /* Keep this the first thing. */
     66        fibril_owner_info_t oi;  /**< Keep this the first thing. */
    6767        unsigned writers;
    6868        unsigned readers;

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

    r6b40ea7 r30c4005  
    3939#define max(a, b)  ((a) > (b) ? (a) : (b))
    4040
    41 #define SIZE2KB(size)  ((size) >> 10)
    42 #define SIZE2MB(size)  ((size) >> 20)
    43 
    44 #define KB2SIZE(kb)  ((kb) << 10)
    45 #define MB2SIZE(mb)  ((mb) << 20)
     41#define KiB2SIZE(kb)  ((kb) << 10)
     42#define MiB2SIZE(mb)  ((mb) << 20)
    4643
    4744#define STRING(arg)      STRING_ARG(arg)

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

    r6b40ea7 r30c4005  
    8989extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);
    9090
    91 extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
     91extern void order_suffix(const uint64_t, uint64_t *, char *);
     92extern void bin_order_suffix(const uint64_t, uint64_t *, const char **, bool);
    9293
    9394/*

  • uspace/srv/devman/devman.c

    r6b40ea7 r30c4005  
    3939#include <devmap.h>
    4040#include <str_error.h>
     41#include <stdio.h>
    4142
    4243#include "devman.h"

  • uspace/srv/fs/fat/fat_fat.c

    r6b40ea7 r30c4005  
    4747#include <assert.h>
    4848#include <fibril_synch.h>
     49#include <malloc.h>
    4950#include <mem.h>
    5051

  • uspace/srv/fs/fat/fat_idx.c

    r6b40ea7 r30c4005  
    4444#include <assert.h>
    4545#include <fibril_synch.h>
     46#include <malloc.h>
    4647
    4748/** Each instance of this type describes one interval of freed VFS indices. */

  • uspace/srv/fs/fat/fat_ops.c

    r6b40ea7 r30c4005  
    5555#include <sys/mman.h>
    5656#include <align.h>
     57#include <malloc.h>
    5758
    5859#define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)

  • uspace/srv/hw/netif/ne2000/dp8390.c

    r6b40ea7 r30c4005  
    5353#include <byteorder.h>
    5454#include <errno.h>
     55#include <stdio.h>
    5556#include <libarch/ddi.h>
    5657#include <net/packet.h>

  • uspace/srv/loader/arch/ia64/_link.ld.in

    r6b40ea7 r30c4005  
    2828       
    2929        .got : {
    30                 _gp = .;
     30                /* Tell the linker where we expect GP to point. */
     31                __gp = .;
    3132                *(.got .got.*);
    3233        } :data

  • uspace/srv/ns/clonable.c

    r6b40ea7 r30c4005  
    7878        if (list_empty(&cs_req)) {
    7979                /* There was no pending connection request. */
    80                 printf(NAME ": Unexpected clonable server.\n");
     80                printf("%s: Unexpected clonable server.\n", NAME);
    8181                ipc_answer_0(callid, EBUSY);
    8282                return;

  • uspace/srv/ns/service.c

    r6b40ea7 r30c4005  
    3535#include <assert.h>
    3636#include <errno.h>
     37#include <stdio.h>
     38#include <malloc.h>
    3739#include "service.h"
    3840#include "ns.h"

  • uspace/srv/ns/task.c

    r6b40ea7 r30c4005  
    3939#include <stdio.h>
    4040#include <macros.h>
     41#include <malloc.h>
    4142#include "task.h"
    4243#include "ns.h"
Note: See TracChangeset for help on using the changeset viewer.