Changeset 80d2bdb in mainline


Ignore:
Timestamp:
2005-12-15T16:10:19Z (19 years ago)
Author:
Ondrej Palkovsky <ondrap@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b4cad8b2
Parents:
7dd2561
Message:

We are now almost -Wall clean.

  • redefined atomic_t
  • deleted many, many unused variables
  • some minor code cleanups found using compiler warning.
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • arch/amd64/include/asm.h

    r7dd2561 r80d2bdb  
    5555
    5656
    57 static inline __u8 inb(__u16 port)
    58 {
    59         __u8 out;
    60 
    61         __asm__ volatile (
    62                 "mov %1, %%dx\n"
    63                 "inb %%dx,%%al\n"
    64                 "mov %%al, %0\n"
    65                 :"=m"(out)
    66                 :"m"(port)
    67                 :"%rdx","%rax"
    68                 );
    69         return out;
    70 }
    71 
    72 static inline __u8 outb(__u16 port,__u8 b)
    73 {
    74         __asm__ volatile (
    75                 "mov %0,%%dx\n"
    76                 "mov %1,%%al\n"
    77                 "outb %%al,%%dx\n"
    78                 :
    79                 :"m"( port), "m" (b)
    80                 :"%rdx","%rax"
    81                 );
    82 }
     57/** Byte from port
     58 *
     59 * Get byte from port
     60 *
     61 * @param port Port to read from
     62 * @return Value read
     63 */
     64static inline __u8 inb(__u16 port) { __u8 val; __asm__ volatile ("inb %w1, %b0 \n" : "=a" (val) : "d" (port) ); return val; }
     65
     66/** Byte to port
     67 *
     68 * Output byte to port
     69 *
     70 * @param port Port to write to
     71 * @param val Value to write
     72 */
     73static inline void outb(__u16 port, __u8 val) { __asm__ volatile ("outb %b0, %w1\n" : : "a" (val), "d" (port) ); }
    8374
    8475/** Enable interrupts.

  • arch/amd64/src/cpu/cpu.c

    r7dd2561 r80d2bdb  
    126126{
    127127        cpu_info_t info;
    128         int i;
    129128
    130129        CPU->arch.vendor = VendorUnknown;

  • arch/ia32/include/atomic.h

    r7dd2561 r80d2bdb  
    3232#include <arch/types.h>
    3333
    34 typedef volatile __u32 atomic_t;
     34typedef struct { volatile __u32 count; } atomic_t;
     35
     36static inline void atomic_set(atomic_t *val, __u32 i)
     37{
     38        val->count = i;
     39}
     40
     41static inline __u32 atomic_get(atomic_t *val)
     42{
     43        return val->count;
     44}
    3545
    3646static inline void atomic_inc(atomic_t *val) {
    3747#ifdef CONFIG_SMP
    38         __asm__ volatile ("lock incl %0\n" : "=m" (*val));
     48        __asm__ volatile ("lock incl %0\n" : "=m" (val->count));
    3949#else
    40         __asm__ volatile ("incl %0\n" : "=m" (*val));
     50        __asm__ volatile ("incl %0\n" : "=m" (val->count));
    4151#endif /* CONFIG_SMP */
    4252}
    … …  
    4454static inline void atomic_dec(atomic_t *val) {
    4555#ifdef CONFIG_SMP
    46         __asm__ volatile ("lock decl %0\n" : "=m" (*val));
     56        __asm__ volatile ("lock decl %0\n" : "=m" (val->count));
    4757#else
    48         __asm__ volatile ("decl %0\n" : "=m" (*val));
     58        __asm__ volatile ("decl %0\n" : "=m" (val->count));
    4959#endif /* CONFIG_SMP */
    5060}
    … …  
    5666                "movl $1, %0\n"
    5767                "lock xaddl %0, %1\n"
    58                 : "=r"(r), "=m" (*val)
     68                : "=r"(r), "=m" (val->count)
    5969        );
    6070        return r;
    … …  
    7787#define atomic_dec_post(val) (atomic_dec_pre(val)-1)
    7888
    79 static inline int test_and_set(volatile int *val) {
     89static inline int test_and_set(atomic_t *val) {
    8090        int v;
    8191       
    … …  
    8393                "movl $1, %0\n"
    8494                "xchgl %0, %1\n"
    85                 : "=r" (v),"=m" (*val)
     95                : "=r" (v),"=m" (val->count)
    8696        );
    8797       

  • arch/ia32/src/fmath.c

    r7dd2561 r80d2bdb  
    6363        fmath_ld_union_t fmath_ld_union_int;
    6464        signed short exp;
    65         __u64 mask,mantisa;
     65        __u64 mask;
     66        // __u64 mantisa;
    6667        int i;
    6768       

  • arch/ia32/src/mm/frame.c

    r7dd2561 r80d2bdb  
    4444void frame_arch_init(void)
    4545{
    46         zone_t *z;
    4746        __u8 i;
    4847       

  • arch/ia32/src/smp/smp.c

    r7dd2561 r80d2bdb  
    8888void kmp(void *arg)
    8989{
    90         __address src, dst;
    9190        int i;
    9291       

  • arch/ia64/include/atomic.h

    r7dd2561 r80d2bdb  
    3232#include <arch/types.h>
    3333
    34 typedef volatile __u64 atomic_t;
     34typedef struct { volatile __u64 count; } atomic_t;
    3535
    3636static inline atomic_t atomic_add(atomic_t *val, int imm)
    … …  
    3939
    4040       
    41         __asm__ volatile ("fetchadd8.rel %0 = %1, %2\n" : "=r" (v), "+m" (*val) : "i" (imm));
     41        __asm__ volatile ("fetchadd8.rel %0 = %1, %2\n" : "=r" (v), "+m" (val->count) : "i" (imm));
    4242 
    4343        return v;
     44}
     45
     46static inline void atomic_set(atomic_t *val, __u64 i)
     47{
     48        val->count = i;
     49}
     50
     51static inline __u32 atomic_get(atomic_t *val)
     52{
     53        return val->count;
    4454}
    4555

  • arch/mips32/include/atomic.h

    r7dd2561 r80d2bdb  
    4242
    4343
    44 typedef volatile __u32 atomic_t;
     44typedef struct { volatile __u32 count; } atomic_t;
    4545
    4646/* Atomic addition of immediate value.
    … …  
    6363                "       beq %0, %4, 1b\n"       /* if the atomic operation failed, try again */
    6464                /*      nop     */              /* nop is inserted automatically by compiler */
    65                 : "=r" (tmp), "=m" (*val), "=r" (v)
     65                : "=r" (tmp), "=m" (val->count), "=r" (v)
    6666                : "i" (i), "i" (0)
    6767                );
    … …  
    7070}
    7171
     72/* Reads/writes are atomic on mips for 4-bytes */
     73
     74static inline void atomic_set(atomic_t *val, __u32 i)
     75{
     76        val->count = i;
     77}
     78
     79static inline __u32 atomic_get(atomic_t *val)
     80{
     81        return val->count;
     82}
    7283
    7384#endif

  • arch/mips32/src/drivers/arc.c

    r7dd2561 r80d2bdb  
    189189        arc_putchar('C');
    190190        arc_putchar('\n');
     191
     192        return 0;
    191193}
    192194
    … …  
    287289        __address base;
    288290        size_t basesize;
    289         unsigned int i,j;
    290291
    291292        desc = arc_entry->getmemorydescriptor(NULL);

  • arch/mips32/src/drivers/serial.c

    r7dd2561 r80d2bdb  
    3939static void serial_write(chardev_t *d, const char ch)
    4040{
    41         int i;
    4241        serial_t *sd = (serial_t *)d->data;
    4342

  • arch/ppc32/include/atomic.h

    r7dd2561 r80d2bdb  
    3232#include <arch/types.h>
    3333
    34 typedef volatile __u32 atomic_t;
     34typedef struct { volatile __u32 count; } atomic_t;
    3535
    3636/*
    … …  
    4040
    4141static inline void atomic_inc(atomic_t *val) {
    42         *val++;
     42        val->count++;
    4343}
    4444
    4545static inline void atomic_dec(atomic_t *val) {
    46         *val--;
     46        val->count--;
     47}
     48
     49static inline void atomic_set(atomic_t *val, __u32 i)
     50{
     51        val->count = i;
     52}
     53
     54static inline __u32 atomic_get(atomic_t *val)
     55{
     56        return val->count;
    4757}
    4858

  • arch/sparc64/include/atomic.h

    r7dd2561 r80d2bdb  
    3232#include <arch/types.h>
    3333
    34 typedef volatile __u64 atomic_t;
     34typedef struct { volatile __u64 count; } atomic_t;
    3535
    3636/*
    … …  
    4040
    4141static inline void atomic_inc(atomic_t *val) {
    42         *val++;
     42        val->count++;
    4343}
    4444
    4545static inline void atomic_dec(atomic_t *val) {
    46         *val--;
     46        val->count--;
    4747}
    4848

  • generic/include/cpu.h

    r7dd2561 r80d2bdb  
    5454
    5555        #ifdef CONFIG_SMP
    56         int kcpulbstarted;
     56        atomic_t kcpulbstarted;
    5757        waitq_t kcpulb_wq;
    5858        #endif /* CONFIG_SMP */

  • generic/include/debug.h

    r7dd2561 r80d2bdb  
    3434#include <arch.h>
    3535
    36 #define CALLER       ((__address *)__builtin_return_address(0))
     36#define CALLER       ((__address)__builtin_return_address(0))
    3737
    3838#ifndef HERE

  • generic/include/synch/spinlock.h

    r7dd2561 r80d2bdb  
    3333#include <typedefs.h>
    3434#include <preemption.h>
     35#include <arch/atomic.h>
    3536
    3637#ifdef CONFIG_SMP
    … …  
    3940        char *name;
    4041#endif
    41         int val;
     42        atomic_t val;
    4243};
    4344
    … …  
    5657        spinlock_t slname = {           \
    5758                .name = #slname,        \
    58                 .val = 0                \
     59                .val = { 0 }            \
    5960        }
    6061#else
    6162#define SPINLOCK_INITIALIZE(slname)     \
    6263        spinlock_t slname = {           \
    63                 .val = 0                \
     64                .val = { 0 }            \
    6465        }
    6566#endif

  • generic/src/console/cmd.c

    r7dd2561 r80d2bdb  
    311311{
    312312        link_t *cur;
    313         ipl_t ipl;
    314313
    315314        spinlock_lock(&cmd_lock);
    … …  
    340339{
    341340        link_t *cur;
    342         ipl_t ipl;
    343341
    344342        spinlock_lock(&cmd_lock);
    … …  
    369367int cmd_symaddr(cmd_arg_t *argv)
    370368{
    371         __address symaddr;
    372         char *symbol;
    373 
    374369        symtab_print_search(argv->buffer);
    375370       
    … …  
    511506int cmd_set4(cmd_arg_t *argv)
    512507{
    513         char *symbol;
    514508        __u32 *addr ;
    515509        __u32 arg1 = argv[1].intval;

  • generic/src/console/kconsole.c

    r7dd2561 r80d2bdb  
    9292int cmd_register(cmd_info_t *cmd)
    9393{
    94         ipl_t ipl;
    9594        link_t *cur;
    9695       
    … …  
    161160        int namelen = strlen(name);
    162161        const char *curname;
    163         char *foundsym = NULL;
    164         int foundpos = 0;
    165162
    166163        spinlock_lock(&cmd_lock);
    … …  
    470467        cmd_info_t *cmd = NULL;
    471468        link_t *cur;
    472         ipl_t ipl;
    473469        int i;
    474470       

  • generic/src/debug/symtab.c

    r7dd2561 r80d2bdb  
    6767        char *curname;
    6868        int i,j;
    69         char *foundsym = NULL;
    70         int foundpos = 0;
    7169        int colonoffset = -1;
    7270

  • generic/src/main/kinit.c

    r7dd2561 r80d2bdb  
    6969void kinit(void *arg)
    7070{
     71        thread_t *t;
     72        int i;
     73#ifdef CONFIG_USERSPACE
    7174        vm_t *m;
    7275        vm_area_t *a;
    7376        task_t *u;
    74         thread_t *t;
    75         int i;
     77#endif
    7678
    7779        interrupts_disable();

  • generic/src/main/main.c

    r7dd2561 r80d2bdb  
    126126 */
    127127static void main_bsp_separated_stack(void);
     128#ifdef CONFIG_SMP
    128129static void main_ap_separated_stack(void);
     130#endif
    129131
    130132/** Bootstrap CPU main kernel routine

  • generic/src/mm/vm.c

    r7dd2561 r80d2bdb  
    189189void vm_install(vm_t *m)
    190190{
    191         link_t *l;
    192191        ipl_t ipl;
    193192       

  • generic/src/proc/scheduler.c

    r7dd2561 r80d2bdb  
    491491        ipl = interrupts_disable();
    492492        spinlock_lock(&CPU->lock);
    493         count = nrdy / config.cpu_active;
     493        count = atomic_get(&nrdy) / config.cpu_active;
    494494        count -= CPU->nrdy;
    495495        spinlock_unlock(&CPU->lock);
    … …  
    619619         * Tell find_best_thread() to wake us up later again.
    620620         */
    621         CPU->kcpulbstarted = 0;
     621        atomic_set(&CPU->kcpulbstarted,0);
    622622        goto loop;
    623623}

  • generic/src/proc/thread.c

    r7dd2561 r80d2bdb  
    9696{
    9797        THREAD = NULL;
    98         nrdy = 0;
     98        atomic_set(&nrdy,0);
    9999}
    100100
    … …  
    112112        runq_t *r;
    113113        ipl_t ipl;
    114         int i, avg, send_ipi = 0;
     114        int i, avg;
    115115
    116116        ipl = interrupts_disable();
    … …  
    136136
    137137        atomic_inc(&nrdy);
    138         avg = nrdy / config.cpu_active;
     138        avg = atomic_get(&nrdy) / config.cpu_active;
    139139
    140140        spinlock_lock(&cpu->lock);

  • generic/src/synch/rwlock.c

    r7dd2561 r80d2bdb  
    226226                                panic("_mutex_lock_timeout()==ESYNCH_OK_ATOMIC\n");
    227227                                break;
    228                         dafault:
     228                        default:
    229229                                panic("invalid ESYNCH\n");
    230230                                break;

  • generic/src/synch/spinlock.c

    r7dd2561 r80d2bdb  
    4646void spinlock_initialize(spinlock_t *sl, char *name)
    4747{
    48         sl->val = 0;
     48        atomic_set(&sl->val, 0);
    4949#ifdef CONFIG_DEBUG_SPINLOCK
    5050        sl->name = name;
    … …  
    152152void spinlock_unlock(spinlock_t *sl)
    153153{
    154         ASSERT(sl->val != 0);
     154        ASSERT(atomic_get(&sl->val) != 0);
    155155
    156156        /*
    … …  
    159159        CS_LEAVE_BARRIER();
    160160       
    161         sl->val = 0;
     161        atomic_set(&sl->val,0);
    162162        preemption_enable();
    163163}

  • test/synch/rwlock4/test.c

    r7dd2561 r80d2bdb  
    6262{
    6363        __u32 rc;
    64         ipl_t ipl;
    6564
    6665        spinlock_lock(&lock);   
Note: See TracChangeset for help on using the changeset viewer.