Changes in / [2f636b6:f6b5593] in mainline


Ignore:
Files:
109 added
23 deleted
45 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r2f636b6 rf6b5593  
    219219
    220220% Compiler
    221 @ "gcc_cross" GCC Cross-compiler
    222 @ "gcc_native" GCC Native
    223 @ "icc_native" ICC Native
    224 @ "suncc_native" Sun Studio C Compiler
     221@ "gcc_cross" GNU C Compiler (cross-compiler)
     222@ "gcc_native" GNU C Compiler (native)
     223@ "icc" Intel C Compiler
     224@ "suncc" Sun Studio C Compiler
     225@ "clang" Clang
    225226! [PLATFORM=amd64|PLATFORM=ia32] COMPILER (choice)
    226227
    227228% Compiler
    228 @ "gcc_cross" GCC Cross-compiler
    229 @ "gcc_native" GCC Native
    230 @ "icc_native" ICC Native
     229@ "gcc_cross" GNU C Compiler (cross-compiler)
     230@ "gcc_native" GNU C Compiler (native)
     231@ "icc" Intel C Compiler
    231232! [PLATFORM=ia64] COMPILER (choice)
    232233
    233234% Compiler
    234 @ "gcc_cross" GCC Cross-compiler
    235 @ "gcc_native" GCC Native
    236 @ "suncc_native" Sun Studio C Compiler
     235@ "gcc_cross" GNU C Compiler (cross-compiler)
     236@ "gcc_native" GNU C Compiler (native)
     237@ "suncc" Sun Studio C Compiler
    237238! [PLATFORM=sparc64] COMPILER (choice)
    238239
    239240% Compiler
    240 @ "gcc_cross" GCC Cross-compiler
    241 @ "gcc_native" GCC Native
     241@ "gcc_cross" GNU C Compiler (cross-compiler)
     242@ "gcc_native" GNU C Compiler (native)
    242243! [PLATFORM=arm32|PLATFORM=mips32|PLATFORM=ppc32] COMPILER (choice)
    243244

  • boot/arch/amd64/Makefile.inc

    r2f636b6 rf6b5593  
    5252        $(USPACEDIR)/srv/fs/fat/fat \
    5353        $(USPACEDIR)/srv/bd/ata_bd/ata_bd \
    54         $(USPACEDIR)/srv/bd/file_bd/file_bd
     54        $(USPACEDIR)/srv/bd/file_bd/file_bd \
     55        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    5556
    5657RD_APPS = \
     58        $(USPACEDIR)/app/edit/edit \
    5759        $(USPACEDIR)/app/getvc/getvc \
    5860        $(USPACEDIR)/app/tetris/tetris \

  • boot/arch/arm32/loader/Makefile

    r2f636b6 rf6b5593  
    9393        $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
    9494        $(USPACEDIR)/srv/fs/fat/fat \
    95         $(USPACEDIR)/srv/bd/file_bd/file_bd
     95        $(USPACEDIR)/srv/bd/file_bd/file_bd \
     96        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    9697ifeq ($(MACHINE),testarm)
    9798        RD_SRVS += \
    … …  
    100101
    101102RD_APPS = \
     103        $(USPACEDIR)/app/edit/edit \
    102104        $(USPACEDIR)/app/getvc/getvc \
    103105        $(USPACEDIR)/app/tetris/tetris \

  • boot/arch/ia32/Makefile.inc

    r2f636b6 rf6b5593  
    5252        $(USPACEDIR)/srv/fs/fat/fat \
    5353        $(USPACEDIR)/srv/bd/ata_bd/ata_bd \
    54         $(USPACEDIR)/srv/bd/file_bd/file_bd
     54        $(USPACEDIR)/srv/bd/file_bd/file_bd \
     55        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    5556
    5657RD_APPS = \
     58        $(USPACEDIR)/app/edit/edit \
    5759        $(USPACEDIR)/app/getvc/getvc \
    5860        $(USPACEDIR)/app/tetris/tetris \

  • boot/arch/ia64/loader/Makefile

    r2f636b6 rf6b5593  
    5151endif
    5252
    53 ifeq ($(COMPILER),icc_native)
     53ifeq ($(COMPILER),icc)
    5454        CC = icc
    5555        AS = as
    … …  
    104104        $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
    105105        $(USPACEDIR)/srv/fs/fat/fat \
    106         $(USPACEDIR)/srv/bd/file_bd/file_bd
     106        $(USPACEDIR)/srv/bd/file_bd/file_bd \
     107        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    107108
    108109RD_APPS = \
     110        $(USPACEDIR)/app/edit/edit \
    109111        $(USPACEDIR)/app/getvc/getvc \
    110112        $(USPACEDIR)/app/tetris/tetris \

  • boot/arch/mips32/loader/Makefile

    r2f636b6 rf6b5593  
    106106        $(USPACEDIR)/srv/fs/fat/fat \
    107107        $(USPACEDIR)/srv/bd/file_bd/file_bd \
    108         $(USPACEDIR)/srv/bd/gxe_bd/gxe_bd
     108        $(USPACEDIR)/srv/bd/gxe_bd/gxe_bd \
     109        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    109110
    110111RD_APPS = \
     112        $(USPACEDIR)/app/edit/edit \
    111113        $(USPACEDIR)/app/getvc/getvc \
    112114        $(USPACEDIR)/app/tetris/tetris \

  • boot/arch/ppc32/loader/Makefile

    r2f636b6 rf6b5593  
    9494        $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
    9595        $(USPACEDIR)/srv/fs/fat/fat \
    96         $(USPACEDIR)/srv/bd/file_bd/file_bd
     96        $(USPACEDIR)/srv/bd/file_bd/file_bd \
     97        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    9798
    9899RD_APPS = \
     100        $(USPACEDIR)/app/edit/edit \
    99101        $(USPACEDIR)/app/getvc/getvc \
    100102        $(USPACEDIR)/app/tetris/tetris \

  • boot/arch/sparc64/loader/Makefile

    r2f636b6 rf6b5593  
    104104        $(USPACEDIR)/srv/fs/devfs/devfs \
    105105        $(USPACEDIR)/srv/fs/tmpfs/tmpfs \
    106         $(USPACEDIR)/srv/bd/file_bd/file_bd
     106        $(USPACEDIR)/srv/bd/file_bd/file_bd \
     107        $(USPACEDIR)/srv/part/mbr_part/mbr_part
    107108
    108109ifeq ($(MACHINE),generic)
    … …  
    114115
    115116RD_APPS = \
     117        $(USPACEDIR)/app/edit/edit \
    116118        $(USPACEDIR)/app/getvc/getvc \
    117119        $(USPACEDIR)/app/tetris/tetris \

  • kernel/Makefile

    r2f636b6 rf6b5593  
    5454ICC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros ../config.h \
    5555        -fno-builtin -Wall -Wmissing-prototypes -Werror \
    56         -nostdlib -nostdinc \
    57         -wd170
     56        -nostdlib -nostdinc -wd170
    5857
    5958SUNCC_CFLAGS = -I$(INCLUDES) -xO$(OPTIMIZATION) \
    6059        -xnolib -xc99=all -features=extensions \
    6160        -erroff=E_ZERO_SIZED_STRUCT_UNION
     61
     62CLANG_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros ../config.h \
     63        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
     64        -finput-charset=UTF-8 -fno-builtin -Wall -Wextra -Wno-unused-parameter \
     65        -Wmissing-prototypes -nostdlib -nostdinc -pipe
    6266
    6367LFLAGS = -M
    … …  
    109113endif
    110114
    111 ifeq ($(COMPILER),icc_native)
     115ifeq ($(COMPILER),gcc_cross)
     116        CC = $(TOOLCHAIN_DIR)/bin/$(TARGET)-gcc
     117        GCC = $(CC)
     118        AS = $(TOOLCHAIN_DIR)/bin/$(TARGET)-as
     119        LD = $(TOOLCHAIN_DIR)/bin/$(TARGET)-ld
     120        OBJCOPY = $(TOOLCHAIN_DIR)/bin/$(TARGET)-objcopy
     121        OBJDUMP = $(TOOLCHAIN_DIR)/bin/$(TARGET)-objdump
     122        LIBDIR = $(TOOLCHAIN_DIR)/lib
     123        CFLAGS = $(GCC_CFLAGS)
     124        DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
     125endif
     126
     127ifeq ($(COMPILER),icc)
    112128        CC = icc
    113129        GCC = gcc
    … …  
    121137endif
    122138
    123 ifeq ($(COMPILER),suncc_native)
     139ifeq ($(COMPILER),suncc)
    124140        CC = suncc
    125141        GCC = gcc
    … …  
    134150endif
    135151
    136 ifeq ($(COMPILER),gcc_cross)
    137         CC = $(TOOLCHAIN_DIR)/bin/$(TARGET)-gcc
    138         GCC = $(CC)
    139         AS = $(TOOLCHAIN_DIR)/bin/$(TARGET)-as
    140         LD = $(TOOLCHAIN_DIR)/bin/$(TARGET)-ld
    141         OBJCOPY = $(TOOLCHAIN_DIR)/bin/$(TARGET)-objcopy
    142         OBJDUMP = $(TOOLCHAIN_DIR)/bin/$(TARGET)-objdump
    143         LIBDIR = $(TOOLCHAIN_DIR)/lib
    144         CFLAGS = $(GCC_CFLAGS)
     152ifeq ($(COMPILER),clang)
     153        CC = clang
     154        GCC = gcc
     155        AS = $(BINUTILS_PREFIX)as
     156        LD = $(BINUTILS_PREFIX)ld
     157        OBJCOPY = $(BINUTILS_PREFIX)objcopy
     158        OBJDUMP = $(BINUTILS_PREFIX)objdump
     159        LIBDIR = /usr/lib
     160        CFLAGS = $(CLANG_CFLAGS)
    145161        DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
    146162endif

  • kernel/arch/arm32/include/elf.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup arm32   
     29/** @addtogroup arm32
    3030 * @{
    3131 */
    … …  
    3737#define KERN_arm32_ELF_H_
    3838
    39 #define ELF_MACHINE             EM_ARM
     39#define ELF_MACHINE  EM_ARM
    4040
    41 #ifdef BIG_ENDIAN
    42 #define ELF_DATA_ENCODING       ELFDATA2MSB
     41#ifdef __BE__
     42        #define ELF_DATA_ENCODING  ELFDATA2MSB
    4343#else
    44 #define ELF_DATA_ENCODING       ELFDATA2LSB
     44        #define ELF_DATA_ENCODING  ELFDATA2LSB
    4545#endif
    4646
    47 #define ELF_CLASS               ELFCLASS32
     47#define ELF_CLASS  ELFCLASS32
    4848
    4949#endif

  • kernel/arch/ia32/Makefile.inc

    r2f636b6 rf6b5593  
    4343ICC_CFLAGS += $(CMN1)
    4444SUNCC_CFLAGS += $(CMN1)
     45CLANG_CFLAGS += $(CMN1)
    4546
    4647## Accepted CPUs
    … …  
    7172GCC_CFLAGS += $(CMN2)
    7273ICC_CFLAGS += $(CMN2)
     74CLANG_CFLAGS += $(CMN2)
    7375
    7476ARCH_SOURCES = \

  • kernel/arch/ia64/_link.ld.in

    r2f636b6 rf6b5593  
    77 */
    88
     9#define LOAD_ADDRESS_V  0xe000000004404000
     10#define LOAD_ADDRESS_P  0x0000000004404000
     11
    912ENTRY(kernel_image_start)
    1013
    1114SECTIONS {
    12         .image 0xe000000004404000: AT (0x0000000004404000) {
     15        .image LOAD_ADDRESS_V: AT (LOAD_ADDRESS_P) {
    1316                ktext_start = .;
    1417                *(K_TEXT_START);
    … …  
    2124                *(.opd)
    2225                *(.data .data.*)
     26                hardcoded_load_address = .;
     27                QUAD(LOAD_ADDRESS_V);
     28                hardcoded_ktext_size = .;
     29                QUAD(ktext_end - ktext_start);
     30                hardcoded_kdata_size = .;
     31                QUAD(kdata_end - kdata_start);
    2332                *(.got .got.*)
    2433                *(.sdata)
    … …  
    3847        }
    3948
    40         _hardcoded_ktext_size = ktext_end - ktext_start;
    41         _hardcoded_kdata_size = kdata_end - kdata_start;
    42         _hardcoded_load_address = 0xe000000004404000;
    43 
    4449}

  • kernel/arch/ia64/include/asm.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
    … …  
    4141#include <arch/register.h>
    4242
    43 #define IA64_IOSPACE_ADDRESS 0xE001000000000000ULL
     43#define IA64_IOSPACE_ADDRESS  0xE001000000000000ULL
    4444
    4545static inline void pio_write_8(ioport8_t *port, uint8_t v)
    4646{
    4747        uintptr_t prt = (uintptr_t) port;
    48 
    49         *((ioport8_t *)(IA64_IOSPACE_ADDRESS +
     48       
     49        *((ioport8_t *) (IA64_IOSPACE_ADDRESS +
    5050            ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
    51 
    52         asm volatile ("mf\n" ::: "memory");
     51       
     52        asm volatile (
     53                "mf\n"
     54                ::: "memory"
     55        );
    5356}
    5457
    … …  
    5659{
    5760        uintptr_t prt = (uintptr_t) port;
    58 
    59         *((ioport16_t *)(IA64_IOSPACE_ADDRESS +
     61       
     62        *((ioport16_t *) (IA64_IOSPACE_ADDRESS +
    6063            ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
    61 
    62         asm volatile ("mf\n" ::: "memory");
     64       
     65        asm volatile (
     66                "mf\n"
     67                ::: "memory"
     68        );
    6369}
    6470
    … …  
    6672{
    6773        uintptr_t prt = (uintptr_t) port;
    68 
    69         *((ioport32_t *)(IA64_IOSPACE_ADDRESS +
     74       
     75        *((ioport32_t *) (IA64_IOSPACE_ADDRESS +
    7076            ((prt & 0xfff) | ((prt >> 2) << 12)))) = v;
    71 
    72         asm volatile ("mf\n" ::: "memory");
     77       
     78        asm volatile (
     79                "mf\n"
     80                ::: "memory"
     81        );
    7382}
    7483
    … …  
    7685{
    7786        uintptr_t prt = (uintptr_t) port;
    78 
    79         asm volatile ("mf\n" ::: "memory");
    80 
    81         return *((ioport8_t *)(IA64_IOSPACE_ADDRESS +
     87       
     88        asm volatile (
     89                "mf\n"
     90                ::: "memory"
     91        );
     92       
     93        return *((ioport8_t *) (IA64_IOSPACE_ADDRESS +
    8294            ((prt & 0xfff) | ((prt >> 2) << 12))));
    8395}
    … …  
    8698{
    8799        uintptr_t prt = (uintptr_t) port;
    88 
    89         asm volatile ("mf\n" ::: "memory");
    90 
    91         return *((ioport16_t *)(IA64_IOSPACE_ADDRESS +
     100       
     101        asm volatile (
     102                "mf\n"
     103                ::: "memory"
     104        );
     105       
     106        return *((ioport16_t *) (IA64_IOSPACE_ADDRESS +
    92107            ((prt & 0xfff) | ((prt >> 2) << 12))));
    93108}
    … …  
    96111{
    97112        uintptr_t prt = (uintptr_t) port;
    98 
    99         asm volatile ("mf\n" ::: "memory");
    100 
    101         return *((ioport32_t *)(IA64_IOSPACE_ADDRESS +
     113       
     114        asm volatile (
     115                "mf\n"
     116                ::: "memory"
     117        );
     118       
     119        return *((ioport32_t *) (IA64_IOSPACE_ADDRESS +
    102120            ((prt & 0xfff) | ((prt >> 2) << 12))));
    103121}
    … …  
    112130{
    113131        uint64_t v;
    114 
    115         //I'm not sure why but this code bad inlines in scheduler,
    116         //so THE shifts about 16B and causes kernel panic
    117         //asm volatile ("and %0 = %1, r12" : "=r" (v) : "r" (~(STACK_SIZE-1)));
    118         //return v;
    119        
    120         //this code have the same meaning but inlines well
    121         asm volatile ("mov %0 = r12" : "=r" (v)  );
    122         return v & (~(STACK_SIZE-1));
     132       
     133        /* I'm not sure why but this code bad inlines in scheduler,
     134           so THE shifts about 16B and causes kernel panic
     135           
     136           asm volatile (
     137               "and %[value] = %[mask], r12"
     138               : [value] "=r" (v)
     139               : [mask] "r" (~(STACK_SIZE - 1))
     140           );
     141           return v;
     142           
     143           This code have the same meaning but inlines well.
     144        */
     145       
     146        asm volatile (
     147                "mov %[value] = r12"
     148                : [value] "=r" (v)
     149        );
     150       
     151        return (v & (~(STACK_SIZE - 1)));
    123152}
    124153
    … …  
    131160        uint64_t v;
    132161       
    133         asm volatile ("mov %0 = psr\n" : "=r" (v));
     162        asm volatile (
     163                "mov %[value] = psr\n"
     164                : [value] "=r" (v)
     165        );
    134166       
    135167        return v;
    … …  
    144176        uint64_t v;
    145177       
    146         asm volatile ("mov %0 = cr.iva\n" : "=r" (v));
     178        asm volatile (
     179                "mov %[value] = cr.iva\n"
     180                : [value] "=r" (v)
     181        );
    147182       
    148183        return v;
    … …  
    155190static inline void iva_write(uint64_t v)
    156191{
    157         asm volatile ("mov cr.iva = %0\n" : : "r" (v));
     192        asm volatile (
     193                "mov cr.iva = %[value]\n"
     194                :: [value] "r" (v)
     195        );
    158196}
    159197
    … …  
    167205        uint64_t v;
    168206       
    169         asm volatile ("mov %0 = cr.ivr\n" : "=r" (v));
     207        asm volatile (
     208                "mov %[value] = cr.ivr\n"
     209                : [value] "=r" (v)
     210        );
    170211       
    171212        return v;
    … …  
    176217        uint64_t v;
    177218       
    178         asm volatile ("mov %0 = cr64\n" : "=r" (v));
     219        asm volatile (
     220                "mov %[value] = cr64\n"
     221                : [value] "=r" (v)
     222        );
    179223       
    180224        return v;
    … …  
    188232static inline void itc_write(uint64_t v)
    189233{
    190         asm volatile ("mov ar.itc = %0\n" : : "r" (v));
     234        asm volatile (
     235                "mov ar.itc = %[value]\n"
     236                :: [value] "r" (v)
     237        );
    191238}
    192239
    … …  
    199246        uint64_t v;
    200247       
    201         asm volatile ("mov %0 = ar.itc\n" : "=r" (v));
     248        asm volatile (
     249                "mov %[value] = ar.itc\n"
     250                : [value] "=r" (v)
     251        );
    202252       
    203253        return v;
    … …  
    210260static inline void itm_write(uint64_t v)
    211261{
    212         asm volatile ("mov cr.itm = %0\n" : : "r" (v));
     262        asm volatile (
     263                "mov cr.itm = %[value]\n"
     264                :: [value] "r" (v)
     265        );
    213266}
    214267
    … …  
    221274        uint64_t v;
    222275       
    223         asm volatile ("mov %0 = cr.itm\n" : "=r" (v));
     276        asm volatile (
     277                "mov %[value] = cr.itm\n"
     278                : [value] "=r" (v)
     279        );
    224280       
    225281        return v;
    … …  
    234290        uint64_t v;
    235291       
    236         asm volatile ("mov %0 = cr.itv\n" : "=r" (v));
     292        asm volatile (
     293                "mov %[value] = cr.itv\n"
     294                : [value] "=r" (v)
     295        );
    237296       
    238297        return v;
    … …  
    245304static inline void itv_write(uint64_t v)
    246305{
    247         asm volatile ("mov cr.itv = %0\n" : : "r" (v));
     306        asm volatile (
     307                "mov cr.itv = %[value]\n"
     308                :: [value] "r" (v)
     309        );
    248310}
    249311
    … …  
    254316static inline void eoi_write(uint64_t v)
    255317{
    256         asm volatile ("mov cr.eoi = %0\n" : : "r" (v));
     318        asm volatile (
     319                "mov cr.eoi = %[value]\n"
     320                :: [value] "r" (v)
     321        );
    257322}
    258323
    … …  
    264329{
    265330        uint64_t v;
    266 
    267         asm volatile ("mov %0 = cr.tpr\n"  : "=r" (v));
     331       
     332        asm volatile (
     333                "mov %[value] = cr.tpr\n"
     334                : [value] "=r" (v)
     335        );
    268336       
    269337        return v;
    … …  
    276344static inline void tpr_write(uint64_t v)
    277345{
    278         asm volatile ("mov cr.tpr = %0\n" : : "r" (v));
     346        asm volatile (
     347                "mov cr.tpr = %[value]\n"
     348                :: [value] "r" (v)
     349        );
    279350}
    280351
    … …  
    291362       
    292363        asm volatile (
    293                 "mov %0 = psr\n"
    294                 "rsm %1\n"
    295                 : "=r" (v)
    296                 : "i" (PSR_I_MASK)
     364                "mov %[value] = psr\n"
     365                "rsm %[mask]\n"
     366                : [value] "=r" (v)
     367                : [mask] "i" (PSR_I_MASK)
    297368        );
    298369       
    … …  
    312383       
    313384        asm volatile (
    314                 "mov %0 = psr\n"
    315                 "ssm %1\n"
     385                "mov %[value] = psr\n"
     386                "ssm %[mask]\n"
    316387                ";;\n"
    317388                "srlz.d\n"
    318                 : "=r" (v)
    319                 : "i" (PSR_I_MASK)
     389                : [value] "=r" (v)
     390                : [mask] "i" (PSR_I_MASK)
    320391        );
    321392       
    … …  
    349420static inline void pk_disable(void)
    350421{
    351         asm volatile ("rsm %0\n" : : "i" (PSR_PK_MASK));
     422        asm volatile (
     423                "rsm %[mask]\n"
     424                ";;\n"
     425                "srlz.d\n"
     426                :: [mask] "i" (PSR_PK_MASK)
     427        );
    352428}
    353429

  • kernel/arch/ia64/include/atomic.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
    … …  
    3636#define KERN_ia64_ATOMIC_H_
    3737
    38 /** Atomic addition.
    39  *
    40  * @param val           Atomic value.
    41  * @param imm           Value to add.
    42  *
    43  * @return              Value before addition.
    44  */
    45 static inline long atomic_add(atomic_t *val, int imm)
    46 {
    47         long v;
    48 
    49         asm volatile ("fetchadd8.rel %0 = %1, %2\n" : "=r" (v),
    50             "+m" (val->count) : "i" (imm));
    51  
    52         return v;
    53 }
    54 
    5538static inline uint64_t test_and_set(atomic_t *val)
    5639{
    … …  
    5841               
    5942        asm volatile (
    60                 "movl %0 = 0x1;;\n"
    61                 "xchg8 %0 = %1, %0;;\n"
    62                 : "=r" (v), "+m" (val->count)
     43                "movl %[v] = 0x1;;\n"
     44                "xchg8 %[v] = %[count], %[v];;\n"
     45                : [v] "=r" (v),
     46                  [count] "+m" (val->count)
    6347        );
    6448       
    … …  
    7660static inline void atomic_inc(atomic_t *val)
    7761{
    78         atomic_add(val, 1);
     62        long v;
     63       
     64        asm volatile (
     65                "fetchadd8.rel %[v] = %[count], 1\n"
     66                : [v] "=r" (v),
     67                  [count] "+m" (val->count)
     68        );
    7969}
    8070
    8171static inline void atomic_dec(atomic_t *val)
    8272{
    83         atomic_add(val, -1);
     73        long v;
     74       
     75        asm volatile (
     76                "fetchadd8.rel %[v] = %[count], -1\n"
     77                : [v] "=r" (v),
     78                  [count] "+m" (val->count)
     79        );
    8480}
    8581
    8682static inline long atomic_preinc(atomic_t *val)
    8783{
    88         return atomic_add(val, 1) + 1;
     84        long v;
     85       
     86        asm volatile (
     87                "fetchadd8.rel %[v] = %[count], 1\n"
     88                : [v] "=r" (v),
     89                  [count] "+m" (val->count)
     90        );
     91       
     92        return (v + 1);
    8993}
    9094
    9195static inline long atomic_predec(atomic_t *val)
    9296{
    93         return atomic_add(val, -1) - 1;
     97        long v;
     98       
     99        asm volatile (
     100                "fetchadd8.rel %[v] = %[count], -1\n"
     101                : [v] "=r" (v),
     102                  [count] "+m" (val->count)
     103        );
     104       
     105        return (v - 1);
    94106}
    95107
    96108static inline long atomic_postinc(atomic_t *val)
    97109{
    98         return atomic_add(val, 1);
     110        long v;
     111       
     112        asm volatile (
     113                "fetchadd8.rel %[v] = %[count], 1\n"
     114                : [v] "=r" (v),
     115                  [count] "+m" (val->count)
     116        );
     117       
     118        return v;
    99119}
    100120
    101121static inline long atomic_postdec(atomic_t *val)
    102122{
    103         return atomic_add(val, -1);
     123        long v;
     124       
     125        asm volatile (
     126                "fetchadd8.rel %[v] = %[count], -1\n"
     127                : [v] "=r" (v),
     128                  [count] "+m" (val->count)
     129        );
     130       
     131        return v;
    104132}
    105133

  • kernel/arch/ia64/include/interrupt.h

    r2f636b6 rf6b5593  
    4040
    4141/** ia64 has 256 INRs. */
    42 #define INR_COUNT       256
     42#define INR_COUNT  256
    4343
    4444/*
    … …  
    4747 * to genarch.
    4848 */
    49 #define IVT_ITEMS       0
    50 #define IVT_FIRST       0
     49#define IVT_ITEMS  0
     50#define IVT_FIRST  0
    5151
    5252/** External Interrupt vectors. */
    5353
    54 #define VECTOR_TLB_SHOOTDOWN_IPI 0xf0
    55 #define INTERRUPT_TIMER         255
    56 #define IRQ_KBD                 (0x01 + LEGACY_INTERRUPT_BASE)
    57 #define IRQ_MOUSE               (0x0c + LEGACY_INTERRUPT_BASE)
    58 #define INTERRUPT_SPURIOUS      15
    59 #define LEGACY_INTERRUPT_BASE   0x20
     54#define VECTOR_TLB_SHOOTDOWN_IPI  0xf0
     55
     56#define INTERRUPT_SPURIOUS  15
     57#define INTERRUPT_TIMER     255
     58
     59#define LEGACY_INTERRUPT_BASE  0x20
     60
     61#define IRQ_KBD    (0x01 + LEGACY_INTERRUPT_BASE)
     62#define IRQ_MOUSE  (0x0c + LEGACY_INTERRUPT_BASE)
    6063
    6164/** General Exception codes. */
    62 #define GE_ILLEGALOP            0
    63 #define GE_PRIVOP               1
    64 #define GE_PRIVREG              2
    65 #define GE_RESREGFLD            3
    66 #define GE_DISBLDISTRAN         4
    67 #define GE_ILLEGALDEP           8
     65#define GE_ILLEGALOP     0
     66#define GE_PRIVOP        1
     67#define GE_PRIVREG       2
     68#define GE_RESREGFLD     3
     69#define GE_DISBLDISTRAN  4
     70#define GE_ILLEGALDEP    8
    6871
    69 #define EOI     0               /**< The actual value doesn't matter. */
     72#define EOI  0  /**< The actual value doesn't matter. */
    7073
    7174typedef struct {
    … …  
    100103        uint128_t f30;
    101104        uint128_t f31;
    102                
     105       
    103106        uintptr_t ar_bsp;
    104107        uintptr_t ar_bspstore;
    … …  
    132135{
    133136        istate->cr_iip = retaddr;
    134         istate->cr_ipsr.ri = 0;         /* return to instruction slot #0 */
     137        istate->cr_ipsr.ri = 0;    /* return to instruction slot #0 */
    135138}
    136139

  • kernel/arch/ia64/include/mm/as.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64mm 
     29/** @addtogroup ia64mm
    3030 * @{
    3131 */
    … …  
    3636#define KERN_ia64_AS_H_
    3737
    38 #define KERNEL_ADDRESS_SPACE_SHADOWED_ARCH      0
     38#define KERNEL_ADDRESS_SPACE_SHADOWED_ARCH  0
    3939
    40 #define KERNEL_ADDRESS_SPACE_START_ARCH         (unsigned long) 0xe000000000000000ULL
    41 #define KERNEL_ADDRESS_SPACE_END_ARCH           (unsigned long) 0xffffffffffffffffULL
    42 #define USER_ADDRESS_SPACE_START_ARCH           (unsigned long) 0x0000000000000000ULL
    43 #define USER_ADDRESS_SPACE_END_ARCH             (unsigned long) 0xdfffffffffffffffULL
     40#define KERNEL_ADDRESS_SPACE_START_ARCH  ((unsigned long) 0xe000000000000000ULL)
     41#define KERNEL_ADDRESS_SPACE_END_ARCH    ((unsigned long) 0xffffffffffffffffULL)
     42#define USER_ADDRESS_SPACE_START_ARCH    ((unsigned long) 0x0000000000000000ULL)
     43#define USER_ADDRESS_SPACE_END_ARCH      ((unsigned long) 0xdfffffffffffffffULL)
    4444
    45 #define USTACK_ADDRESS_ARCH     0x0000000ff0000000ULL
     45#define USTACK_ADDRESS_ARCH  0x0000000ff0000000ULL
    4646
    4747typedef struct {
    … …  
    5050#include <genarch/mm/as_ht.h>
    5151
    52 #define as_constructor_arch(as, flags)          (as != as)
    53 #define as_destructor_arch(as)                  (as != as)
    54 #define as_create_arch(as, flags)               (as != as)
     52#define as_constructor_arch(as, flags)  (as != as)
     53#define as_destructor_arch(as)          (as != as)
     54#define as_create_arch(as, flags)       (as != as)
    5555#define as_deinstall_arch(as)
    5656#define as_invalidate_translation_cache(as, page, cnt)

  • kernel/arch/ia64/include/mm/page.h

    r2f636b6 rf6b5593  
    2828 */
    2929
    30 /** @addtogroup ia64mm 
     30/** @addtogroup ia64mm
    3131 * @{
    3232 */
    … …  
    3939#include <arch/mm/frame.h>
    4040
    41 #define PAGE_SIZE       FRAME_SIZE
    42 #define PAGE_WIDTH      FRAME_WIDTH
     41#define PAGE_SIZE   FRAME_SIZE
     42#define PAGE_WIDTH  FRAME_WIDTH
    4343
    4444#ifdef KERNEL
    4545
    4646/** Bit width of the TLB-locked portion of kernel address space. */
    47 #define KERNEL_PAGE_WIDTH               28      /* 256M */
    48 #define IO_PAGE_WIDTH                   26      /* 64M */
    49 #define FW_PAGE_WIDTH                   28      /* 256M */
    50 
    51 #define USPACE_IO_PAGE_WIDTH            12      /* 4K */
     47#define KERNEL_PAGE_WIDTH  28  /* 256M */
     48#define IO_PAGE_WIDTH      26  /* 64M */
     49#define FW_PAGE_WIDTH      28  /* 256M */
     50
     51#define USPACE_IO_PAGE_WIDTH  12  /* 4K */
    5252
    5353
    … …  
    5959
    6060/* Firmware area (bellow 4GB in phys mem) */
    61 #define FW_OFFSET             0x00000000F0000000
     61#define FW_OFFSET   0x00000000F0000000
    6262/* Legacy IO space */
    63 #define IO_OFFSET             0x0001000000000000
     63#define IO_OFFSET   0x0001000000000000
    6464/* Videoram - now mapped to 0 as VGA text mode vram on 0xb8000 */
    65 #define VIO_OFFSET            0x0002000000000000
    66 
    67 
    68 #define PPN_SHIFT                       12
    69 
    70 #define VRN_SHIFT                       61
    71 #define VRN_MASK                        (7LL << VRN_SHIFT)
    72 #define VA2VRN(va)                      ((va)>>VRN_SHIFT)
     65#define VIO_OFFSET  0x0002000000000000
     66
     67
     68#define PPN_SHIFT  12
     69
     70#define VRN_SHIFT   61
     71#define VRN_MASK    (7ULL << VRN_SHIFT)
     72#define VA2VRN(va)  ((va) >> VRN_SHIFT)
    7373
    7474#ifdef __ASM__
    75 #define VRN_KERNEL                      7
     75        #define VRN_KERNEL  7
    7676#else
    77 #define VRN_KERNEL                      7LL
     77        #define VRN_KERNEL  7ULL
    7878#endif
    7979
    80 #define REGION_REGISTERS                8
    81 
    82 #define KA2PA(x)        ((uintptr_t) (x - (VRN_KERNEL << VRN_SHIFT)))
    83 #define PA2KA(x)        ((uintptr_t) (x + (VRN_KERNEL << VRN_SHIFT)))
    84 
    85 #define VHPT_WIDTH                      20      /* 1M */
    86 #define VHPT_SIZE                       (1 << VHPT_WIDTH)
    87 
    88 #define PTA_BASE_SHIFT                  15
     80#define REGION_REGISTERS  8
     81
     82#define KA2PA(x)  ((uintptr_t) ((x) - (VRN_KERNEL << VRN_SHIFT)))
     83#define PA2KA(x)  ((uintptr_t) ((x) + (VRN_KERNEL << VRN_SHIFT)))
     84
     85#define VHPT_WIDTH  20  /* 1M */
     86#define VHPT_SIZE   (1 << VHPT_WIDTH)
     87
     88#define PTA_BASE_SHIFT  15
    8989
    9090/** Memory Attributes. */
    91 #define MA_WRITEBACK    0x0
    92 #define MA_UNCACHEABLE  0x4
     91#define MA_WRITEBACK    0x00
     92#define MA_UNCACHEABLE  0x04
    9393
    9494/** Privilege Levels. Only the most and the least privileged ones are ever used. */
    95 #define PL_KERNEL       0x0
    96 #define PL_USER         0x3
     95#define PL_KERNEL  0x00
     96#define PL_USER    0x03
    9797
    9898/* Access Rigths. Only certain combinations are used by the kernel. */
    99 #define AR_READ         0x0
    100 #define AR_EXECUTE      0x1
    101 #define AR_WRITE        0x2
     99#define AR_READ     0x00
     100#define AR_EXECUTE  0x01
     101#define AR_WRITE    0x02
    102102
    103103#ifndef __ASM__
    … …  
    113113struct vhpt_tag_info {
    114114        unsigned long long tag : 63;
    115         unsigned ti : 1;
     115        unsigned int ti : 1;
    116116} __attribute__ ((packed));
    117117
    … …  
    123123struct vhpt_entry_present {
    124124        /* Word 0 */
    125         unsigned p : 1;
    126         unsigned : 1;
    127         unsigned ma : 3;
    128         unsigned a : 1;
    129         unsigned d : 1;
    130         unsigned pl : 2;
    131         unsigned ar : 3;
     125        unsigned int p : 1;
     126        unsigned int : 1;
     127        unsigned int ma : 3;
     128        unsigned int a : 1;
     129        unsigned int d : 1;
     130        unsigned int pl : 2;
     131        unsigned int ar : 3;
    132132        unsigned long long ppn : 38;
    133         unsigned : 2;
    134         unsigned ed : 1;
    135         unsigned ig1 : 11;
     133        unsigned int : 2;
     134        unsigned int ed : 1;
     135        unsigned int ig1 : 11;
    136136       
    137137        /* Word 1 */
    138         unsigned : 2;
    139         unsigned ps : 6;
    140         unsigned key : 24;
    141         unsigned : 32;
     138        unsigned int : 2;
     139        unsigned int ps : 6;
     140        unsigned int key : 24;
     141        unsigned int : 32;
    142142       
    143143        /* Word 2 */
    144144        union vhpt_tag tag;
    145145       
    146         /* Word 3 */                                                                                                   
     146        /* Word 3 */
    147147        uint64_t ig3 : 64;
    148148} __attribute__ ((packed));
    … …  
    150150struct vhpt_entry_not_present {
    151151        /* Word 0 */
    152         unsigned p : 1;
     152        unsigned int p : 1;
    153153        unsigned long long ig0 : 52;
    154         unsigned ig1 : 11;
     154        unsigned int ig1 : 11;
    155155       
    156156        /* Word 1 */
    157         unsigned : 2;
    158         unsigned ps : 6;
     157        unsigned int : 2;
     158        unsigned int ps : 6;
    159159        unsigned long long ig2 : 56;
    160 
     160       
    161161        /* Word 2 */
    162162        union vhpt_tag tag;
    163163       
    164         /* Word 3 */                                                                                                   
     164        /* Word 3 */
    165165        uint64_t ig3 : 64;
    166166} __attribute__ ((packed));
    167167
    168 typedef union vhpt_entry {
     168typedef union {
    169169        struct vhpt_entry_present present;
    170170        struct vhpt_entry_not_present not_present;
    … …  
    173173
    174174struct region_register_map {
    175         unsigned ve : 1;
    176         unsigned : 1;
    177         unsigned ps : 6;
    178         unsigned rid : 24;
    179         unsigned : 32;
    180 } __attribute__ ((packed));
    181 
    182 typedef union region_register {
     175        unsigned int ve : 1;
     176        unsigned int : 1;
     177        unsigned int ps : 6;
     178        unsigned int rid : 24;
     179        unsigned int : 32;
     180} __attribute__ ((packed));
     181
     182typedef union {
    183183        struct region_register_map map;
    184184        unsigned long long word;
    185 } region_register;
     185} region_register_t;
    186186
    187187struct pta_register_map {
    188         unsigned ve : 1;
    189         unsigned : 1;
    190         unsigned size : 6;
    191         unsigned vf : 1;
    192         unsigned : 6;
     188        unsigned int ve : 1;
     189        unsigned int : 1;
     190        unsigned int size : 6;
     191        unsigned int vf : 1;
     192        unsigned int : 6;
    193193        unsigned long long base : 49;
    194194} __attribute__ ((packed));
    … …  
    197197        struct pta_register_map map;
    198198        uint64_t word;
    199 } pta_register;
     199} pta_register_t;
    200200
    201201/** Return Translation Hashed Entry Address.
    … …  
    211211{
    212212        uint64_t ret;
    213 
    214         asm volatile ("thash %0 = %1\n" : "=r" (ret) : "r" (va));
    215 
     213       
     214        asm volatile (
     215                "thash %[ret] = %[va]\n"
     216                : [ret] "=r" (ret)
     217                : [va] "r" (va)
     218        );
     219       
    216220        return ret;
    217221}
    … …  
    229233{
    230234        uint64_t ret;
    231 
    232         asm volatile ("ttag %0 = %1\n" : "=r" (ret) : "r" (va));
    233 
     235       
     236        asm volatile (
     237                "ttag %[ret] = %[va]\n"
     238                : [ret] "=r" (ret)
     239                : [va] "r" (va)
     240        );
     241       
    234242        return ret;
    235243}
    … …  
    244252{
    245253        uint64_t ret;
     254       
    246255        ASSERT(i < REGION_REGISTERS);
    247         asm volatile ("mov %0 = rr[%1]\n" : "=r" (ret) : "r" (i << VRN_SHIFT));
     256       
     257        asm volatile (
     258                "mov %[ret] = rr[%[index]]\n"
     259                : [ret] "=r" (ret)
     260                : [index] "r" (i << VRN_SHIFT)
     261        );
     262       
    248263        return ret;
    249264}
    … …  
    257272{
    258273        ASSERT(i < REGION_REGISTERS);
    259         asm volatile (
    260                 "mov rr[%0] = %1\n"
    261                 :
    262                 : "r" (i << VRN_SHIFT), "r" (v)
    263         );
    264 }
    265  
     274       
     275        asm volatile (
     276                "mov rr[%[index]] = %[value]\n"
     277                :: [index] "r" (i << VRN_SHIFT),
     278                   [value] "r" (v)
     279        );
     280}
     281
    266282/** Read Page Table Register.
    267283 *
    … …  
    272288        uint64_t ret;
    273289       
    274         asm volatile ("mov %0 = cr.pta\n" : "=r" (ret));
     290        asm volatile (
     291                "mov %[ret] = cr.pta\n"
     292                : [ret] "=r" (ret)
     293        );
    275294       
    276295        return ret;
    … …  
    283302static inline void pta_write(uint64_t v)
    284303{
    285         asm volatile ("mov cr.pta = %0\n" : : "r" (v));
     304        asm volatile (
     305                "mov cr.pta = %[value]\n"
     306                :: [value] "r" (v)
     307        );
    286308}
    287309

  • kernel/arch/ia64/include/mm/tlb.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64mm 
     29/** @addtogroup ia64mm
    3030 * @{
    3131 */
    … …  
    4242
    4343/** Data and instruction Translation Register indices. */
    44 #define DTR_KERNEL      0
    45 #define ITR_KERNEL      0
    46 #define DTR_KSTACK1     4
    47 #define DTR_KSTACK2     5
     44#define DTR_KERNEL   0
     45#define ITR_KERNEL   0
     46#define DTR_KSTACK1  4
     47#define DTR_KSTACK2  5
    4848
    4949/** Portion of TLB insertion format data structure. */
    50 union tlb_entry {
     50typedef union {
    5151        uint64_t word[2];
    5252        struct {
    5353                /* Word 0 */
    54                 unsigned p : 1;                 /**< Present. */
    55                 unsigned : 1;
    56                 unsigned ma : 3;                /**< Memory attribute. */
    57                 unsigned a : 1;                 /**< Accessed. */
    58                 unsigned d : 1;                 /**< Dirty. */
    59                 unsigned pl : 2;                /**< Privilege level. */
    60                 unsigned ar : 3;                /**< Access rights. */
    61                 unsigned long long ppn : 38;    /**< Physical Page Number, a.k.a. PFN. */
    62                 unsigned : 2;
    63                 unsigned ed : 1;
    64                 unsigned ig1 : 11;
    65 
     54                unsigned int p : 1;           /**< Present. */
     55                unsigned int : 1;
     56                unsigned int ma : 3;          /**< Memory attribute. */
     57                unsigned int a : 1;           /**< Accessed. */
     58                unsigned int d : 1;           /**< Dirty. */
     59                unsigned int pl : 2;          /**< Privilege level. */
     60                unsigned int ar : 3;          /**< Access rights. */
     61                unsigned long long ppn : 38;  /**< Physical Page Number, a.k.a. PFN. */
     62                unsigned int : 2;
     63                unsigned int ed : 1;
     64                unsigned int ig1 : 11;
     65               
    6666                /* Word 1 */
    67                 unsigned : 2;
    68                 unsigned ps : 6;                /**< Page size will be 2^ps. */
    69                 unsigned key : 24;              /**< Protection key, unused. */
    70                 unsigned : 32;
     67                unsigned int : 2;
     68                unsigned int ps : 6;    /**< Page size will be 2^ps. */
     69                unsigned int key : 24;  /**< Protection key, unused. */
     70                unsigned int : 32;
    7171        } __attribute__ ((packed));
    72 } __attribute__ ((packed));
    73 typedef union tlb_entry tlb_entry_t;
     72} __attribute__ ((packed)) tlb_entry_t;
    7473
    7574extern void tc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtc);

  • kernel/arch/ia64/include/register.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64   
     29/** @addtogroup ia64
    3030 * @{
    3131 */
    … …  
    3636#define KERN_ia64_REGISTER_H_
    3737
    38 #define CR_IVR_MASK     0xf
    39 #define PSR_IC_MASK     0x2000
    40 #define PSR_I_MASK      0x4000
    41 #define PSR_PK_MASK     0x8000
    42 
    43 #define PSR_DT_MASK     (1 << 17)
    44 #define PSR_RT_MASK     (1 << 27)
    45 
    46 #define PSR_DFL_MASK    (1 << 18)
    47 #define PSR_DFH_MASK    (1 << 19)
    48 
    49 #define PSR_IT_MASK     0x0000001000000000
    50 
    51 #define PSR_CPL_SHIFT           32
    52 #define PSR_CPL_MASK_SHIFTED    3
    53 
    54 #define PFM_MASK        (~0x3fffffffff)
    55 
    56 #define RSC_MODE_MASK   3
    57 #define RSC_PL_MASK     12
     38#define DCR_PP_MASK  (1 << 0)
     39#define DCR_BE_MASK  (1 << 1)
     40#define DCR_LC_MASK  (1 << 2)
     41#define DCR_DM_MASK  (1 << 8)
     42#define DCR_DP_MASK  (1 << 9)
     43#define DCR_DK_MASK  (1 << 10)
     44#define DCR_DX_MASK  (1 << 11)
     45#define DCR_DR_MASK  (1 << 12)
     46#define DCR_DA_MASK  (1 << 13)
     47#define DCR_DD_MASK  (1 << 14)
     48
     49#define CR_IVR_MASK  0x0f
     50
     51#define PSR_IC_MASK   (1 << 13)
     52#define PSR_I_MASK    (1 << 14)
     53#define PSR_PK_MASK   (1 << 15)
     54#define PSR_DT_MASK   (1 << 17)
     55#define PSR_DFL_MASK  (1 << 18)
     56#define PSR_DFH_MASK  (1 << 19)
     57#define PSR_RT_MASK   (1 << 27)
     58#define PSR_IT_MASK   (1 << 36)
     59
     60#define PSR_CPL_SHIFT         32
     61#define PSR_CPL_MASK_SHIFTED  3
     62
     63#define PFM_MASK  (~0x3fffffffff)
     64
     65#define RSC_MODE_MASK   3
     66#define RSC_PL_MASK     12
    5867
    5968/** Application registers. */
    60 #define AR_KR0          0
    61 #define AR_KR1          1
    62 #define AR_KR2          2
    63 #define AR_KR3          3
    64 #define AR_KR4          4
    65 #define AR_KR5          5
    66 #define AR_KR6          6
    67 #define AR_KR7          7
    68 /* AR 8-15 reserved */
    69 #define AR_RSC          16
    70 #define AR_BSP          17
    71 #define AR_BSPSTORE     18
    72 #define AR_RNAT         19
    73 /* AR 20 reserved */
    74 #define AR_FCR          21
    75 /* AR 22-23 reserved */
    76 #define AR_EFLAG        24
    77 #define AR_CSD          25
    78 #define AR_SSD          26
    79 #define AR_CFLG         27
    80 #define AR_FSR          28
    81 #define AR_FIR          29
    82 #define AR_FDR          30
    83 /* AR 31 reserved */
    84 #define AR_CCV          32
    85 /* AR 33-35 reserved */
    86 #define AR_UNAT         36
    87 /* AR 37-39 reserved */
    88 #define AR_FPSR         40
    89 /* AR 41-43 reserved */
    90 #define AR_ITC          44
    91 /* AR 45-47 reserved */
    92 /* AR 48-63 ignored */
    93 #define AR_PFS          64
    94 #define AR_LC           65
    95 #define AR_EC           66
    96 /* AR 67-111 reserved */
    97 /* AR 112-127 ignored */
     69#define AR_KR0       0
     70#define AR_KR1       1
     71#define AR_KR2       2
     72#define AR_KR3       3
     73#define AR_KR4       4
     74#define AR_KR5       5
     75#define AR_KR6       6
     76#define AR_KR7       7
     77/* ARs 8-15 are reserved */
     78#define AR_RSC       16
     79#define AR_BSP       17
     80#define AR_BSPSTORE  18
     81#define AR_RNAT      19
     82/* AR 20 is reserved */
     83#define AR_FCR       21
     84/* ARs 22-23 are reserved */
     85#define AR_EFLAG     24
     86#define AR_CSD       25
     87#define AR_SSD       26
     88#define AR_CFLG      27
     89#define AR_FSR       28
     90#define AR_FIR       29
     91#define AR_FDR       30
     92/* AR 31 is reserved */
     93#define AR_CCV       32
     94/* ARs 33-35 are reserved */
     95#define AR_UNAT      36
     96/* ARs 37-39 are reserved */
     97#define AR_FPSR      40
     98/* ARs 41-43 are reserved */
     99#define AR_ITC       44
     100/* ARs 45-47 are reserved */
     101/* ARs 48-63 are ignored */
     102#define AR_PFS       64
     103#define AR_LC        65
     104#define AR_EC        66
     105/* ARs 67-111 are reserved */
     106/* ARs 112-127 are ignored */
    98107
    99108/** Control registers. */
    100 #define CR_DCR          0
    101 #define CR_ITM          1
    102 #define CR_IVA          2
    103 /* CR3-CR7 reserved */
    104 #define CR_PTA          8
    105 /* CR9-CR15 reserved */
    106 #define CR_IPSR         16
    107 #define CR_ISR          17
    108 /* CR18 reserved */
    109 #define CR_IIP          19
    110 #define CR_IFA          20
    111 #define CR_ITIR         21
    112 #define CR_IIPA         22
    113 #define CR_IFS          23
    114 #define CR_IIM          24
    115 #define CR_IHA          25
    116 /* CR26-CR63 reserved */
    117 #define CR_LID          64
    118 #define CR_IVR          65
    119 #define CR_TPR          66
    120 #define CR_EOI          67
    121 #define CR_IRR0         68
    122 #define CR_IRR1         69
    123 #define CR_IRR2         70
    124 #define CR_IRR3         71
    125 #define CR_ITV          72
    126 #define CR_PMV          73
    127 #define CR_CMCV         74
    128 /* CR75-CR79 reserved */
    129 #define CR_LRR0         80
    130 #define CR_LRR1         81
    131 /* CR82-CR127 reserved */
     109#define CR_DCR   0
     110#define CR_ITM   1
     111#define CR_IVA   2
     112/* CR3-CR7 are reserved */
     113#define CR_PTA   8
     114/* CR9-CR15 are reserved */
     115#define CR_IPSR  16
     116#define CR_ISR   17
     117/* CR18 is reserved */
     118#define CR_IIP   19
     119#define CR_IFA   20
     120#define CR_ITIR  21
     121#define CR_IIPA  22
     122#define CR_IFS   23
     123#define CR_IIM   24
     124#define CR_IHA   25
     125/* CR26-CR63 are reserved */
     126#define CR_LID   64
     127#define CR_IVR   65
     128#define CR_TPR   66
     129#define CR_EOI   67
     130#define CR_IRR0  68
     131#define CR_IRR1  69
     132#define CR_IRR2  70
     133#define CR_IRR3  71
     134#define CR_ITV   72
     135#define CR_PMV   73
     136#define CR_CMCV  74
     137/* CR75-CR79 are reserved */
     138#define CR_LRR0  80
     139#define CR_LRR1  81
     140/* CR82-CR127 are reserved */
    132141
    133142#ifndef __ASM__
    … …  
    136145
    137146/** Processor Status Register. */
    138 union psr {
    139         uint64_t value;
    140         struct {
    141                 unsigned : 1;
    142                 unsigned be : 1;        /**< Big-Endian data accesses. */
    143                 unsigned up : 1;        /**< User Performance monitor enable. */
    144                 unsigned ac : 1;        /**< Alignment Check. */
    145                 unsigned mfl : 1;       /**< Lower floating-point register written. */
    146                 unsigned mfh : 1;       /**< Upper floating-point register written. */
    147                 unsigned : 7;
    148                 unsigned ic : 1;        /**< Interruption Collection. */
    149                 unsigned i : 1;         /**< Interrupt Bit. */
    150                 unsigned pk : 1;        /**< Protection Key enable. */
    151                 unsigned : 1;
    152                 unsigned dt : 1;        /**< Data address Translation. */
    153                 unsigned dfl : 1;       /**< Disabled Floating-point Low register set. */
    154                 unsigned dfh : 1;       /**< Disabled Floating-point High register set. */
    155                 unsigned sp : 1;        /**< Secure Performance monitors. */
    156                 unsigned pp : 1;        /**< Privileged Performance monitor enable. */
    157                 unsigned di : 1;        /**< Disable Instruction set transition. */
    158                 unsigned si : 1;        /**< Secure Interval timer. */
    159                 unsigned db : 1;        /**< Debug Breakpoint fault. */
    160                 unsigned lp : 1;        /**< Lower Privilege transfer trap. */
    161                 unsigned tb : 1;        /**< Taken Branch trap. */
    162                 unsigned rt : 1;        /**< Register Stack Translation. */
    163                 unsigned : 4;
    164                 unsigned cpl : 2;       /**< Current Privilege Level. */
    165                 unsigned is : 1;        /**< Instruction Set. */
    166                 unsigned mc : 1;        /**< Machine Check abort mask. */
    167                 unsigned it : 1;        /**< Instruction address Translation. */
    168                 unsigned id : 1;        /**< Instruction Debug fault disable. */
    169                 unsigned da : 1;        /**< Disable Data Access and Dirty-bit faults. */
    170                 unsigned dd : 1;        /**< Data Debug fault disable. */
    171                 unsigned ss : 1;        /**< Single Step enable. */
    172                 unsigned ri : 2;        /**< Restart Instruction. */
    173                 unsigned ed : 1;        /**< Exception Deferral. */
    174                 unsigned bn : 1;        /**< Register Bank. */
    175                 unsigned ia : 1;        /**< Disable Instruction Access-bit faults. */
    176         } __attribute__ ((packed));
    177 };
    178 typedef union psr psr_t;
     147typedef union {
     148        uint64_t value;
     149        struct {
     150                unsigned int : 1;
     151                unsigned int be : 1;   /**< Big-Endian data accesses. */
     152                unsigned int up : 1;   /**< User Performance monitor enable. */
     153                unsigned int ac : 1;   /**< Alignment Check. */
     154                unsigned int mfl : 1;  /**< Lower floating-point register written. */
     155                unsigned int mfh : 1;  /**< Upper floating-point register written. */
     156                unsigned int : 7;
     157                unsigned int ic : 1;   /**< Interruption Collection. */
     158                unsigned int i : 1;    /**< Interrupt Bit. */
     159                unsigned int pk : 1;   /**< Protection Key enable. */
     160                unsigned int : 1;
     161                unsigned int dt : 1;   /**< Data address Translation. */
     162                unsigned int dfl : 1;  /**< Disabled Floating-point Low register set. */
     163                unsigned int dfh : 1;  /**< Disabled Floating-point High register set. */
     164                unsigned int sp : 1;   /**< Secure Performance monitors. */
     165                unsigned int pp : 1;   /**< Privileged Performance monitor enable. */
     166                unsigned int di : 1;   /**< Disable Instruction set transition. */
     167                unsigned int si : 1;   /**< Secure Interval timer. */
     168                unsigned int db : 1;   /**< Debug Breakpoint fault. */
     169                unsigned int lp : 1;   /**< Lower Privilege transfer trap. */
     170                unsigned int tb : 1;   /**< Taken Branch trap. */
     171                unsigned int rt : 1;   /**< Register Stack Translation. */
     172                unsigned int : 4;
     173                unsigned int cpl : 2;  /**< Current Privilege Level. */
     174                unsigned int is : 1;   /**< Instruction Set. */
     175                unsigned int mc : 1;   /**< Machine Check abort mask. */
     176                unsigned int it : 1;   /**< Instruction address Translation. */
     177                unsigned int id : 1;   /**< Instruction Debug fault disable. */
     178                unsigned int da : 1;   /**< Disable Data Access and Dirty-bit faults. */
     179                unsigned int dd : 1;   /**< Data Debug fault disable. */
     180                unsigned int ss : 1;   /**< Single Step enable. */
     181                unsigned int ri : 2;   /**< Restart Instruction. */
     182                unsigned int ed : 1;   /**< Exception Deferral. */
     183                unsigned int bn : 1;   /**< Register Bank. */
     184                unsigned int ia : 1;   /**< Disable Instruction Access-bit faults. */
     185        } __attribute__ ((packed));
     186} psr_t;
    179187
    180188/** Register Stack Configuration Register */
    181 union rsc {
    182         uint64_t value;
    183         struct {
    184                 unsigned mode : 2;
    185                 unsigned pl : 2;        /**< Privilege Level. */
    186                 unsigned be : 1;        /**< Big-endian. */
    187                 unsigned : 11;
    188                 unsigned loadrs : 14;
    189         } __attribute__ ((packed));
    190 };
    191 typedef union rsc rsc_t;
     189typedef union {
     190        uint64_t value;
     191        struct {
     192                unsigned int mode : 2;
     193                unsigned int pl : 2;    /**< Privilege Level. */
     194                unsigned int be : 1;    /**< Big-endian. */
     195                unsigned int : 11;
     196                unsigned int loadrs : 14;
     197        } __attribute__ ((packed));
     198} rsc_t;
    192199
    193200/** External Interrupt Vector Register */
    194 union cr_ivr {
    195         uint8_t  vector;
    196         uint64_t value;
    197 };
    198 
    199 typedef union cr_ivr cr_ivr_t;
     201typedef union {
     202        uint8_t vector;
     203        uint64_t value;
     204} cr_ivr_t;
    200205
    201206/** Task Priority Register */
    202 union cr_tpr {
    203         struct {
    204                 unsigned : 4;
    205                 unsigned mic: 4;                /**< Mask Interrupt Class. */
    206                 unsigned : 8;
    207                 unsigned mmi: 1;                /**< Mask Maskable Interrupts. */
    208         } __attribute__ ((packed));
    209         uint64_t value;
    210 };
    211 
    212 typedef union cr_tpr cr_tpr_t;
     207typedef union {
     208        uint64_t value;
     209        struct {
     210                unsigned int : 4;
     211                unsigned int mic: 4;  /**< Mask Interrupt Class. */
     212                unsigned int : 8;
     213                unsigned int mmi: 1;  /**< Mask Maskable Interrupts. */
     214        } __attribute__ ((packed));
     215} cr_tpr_t;
    213216
    214217/** Interval Timer Vector */
    215 union cr_itv {
    216         struct {
    217                 unsigned vector : 8;
    218                 unsigned : 4;
    219                 unsigned : 1;
    220                 unsigned : 3;
    221                 unsigned m : 1;                 /**< Mask. */
    222         } __attribute__ ((packed));
    223         uint64_t value;
    224 };
    225 
    226 typedef union cr_itv cr_itv_t;
     218typedef union {
     219        uint64_t value;
     220        struct {
     221                unsigned int vector : 8;
     222                unsigned int : 4;
     223                unsigned int : 1;
     224                unsigned int : 3;
     225                unsigned int m : 1;       /**< Mask. */
     226        } __attribute__ ((packed));
     227} cr_itv_t;
    227228
    228229/** Interruption Status Register */
    229 union cr_isr {
     230typedef union {
     231        uint64_t value;
    230232        struct {
    231233                union {
    232234                        /** General Exception code field structuring. */
     235                        uint16_t code;
    233236                        struct {
    234                                 unsigned ge_na : 4;
    235                                 unsigned ge_code : 4;
     237                                unsigned int ge_na : 4;
     238                                unsigned int ge_code : 4;
    236239                        } __attribute__ ((packed));
    237                         uint16_t code;
    238240                };
    239241                uint8_t vector;
    240                 unsigned : 8;
    241                 unsigned x : 1;                 /**< Execute exception. */
    242                 unsigned w : 1;                 /**< Write exception. */
    243                 unsigned r : 1;                 /**< Read exception. */
    244                 unsigned na : 1;                /**< Non-access exception. */
    245                 unsigned sp : 1;                /**< Speculative load exception. */
    246                 unsigned rs : 1;                /**< Register stack. */
    247                 unsigned ir : 1;                /**< Incomplete Register frame. */
    248                 unsigned ni : 1;                /**< Nested Interruption. */
    249                 unsigned so : 1;                /**< IA-32 Supervisor Override. */
    250                 unsigned ei : 2;                /**< Excepting Instruction. */
    251                 unsigned ed : 1;                /**< Exception Deferral. */
    252                 unsigned : 20;
    253         } __attribute__ ((packed));
    254         uint64_t value;
    255 };
    256 
    257 typedef union cr_isr cr_isr_t;
     242                unsigned int : 8;
     243                unsigned int x : 1;   /**< Execute exception. */
     244                unsigned int w : 1;   /**< Write exception. */
     245                unsigned int r : 1;   /**< Read exception. */
     246                unsigned int na : 1;  /**< Non-access exception. */
     247                unsigned int sp : 1;  /**< Speculative load exception. */
     248                unsigned int rs : 1;  /**< Register stack. */
     249                unsigned int ir : 1;  /**< Incomplete Register frame. */
     250                unsigned int ni : 1;  /**< Nested Interruption. */
     251                unsigned int so : 1;  /**< IA-32 Supervisor Override. */
     252                unsigned int ei : 2;  /**< Excepting Instruction. */
     253                unsigned int ed : 1;  /**< Exception Deferral. */
     254                unsigned int : 20;
     255        } __attribute__ ((packed));
     256} cr_isr_t;
    258257
    259258/** CPUID Register 3 */
    260 union cpuid3 {
     259typedef union {
     260        uint64_t value;
    261261        struct {
    262262                uint8_t number;
    … …  
    266266                uint8_t archrev;
    267267        } __attribute__ ((packed));
    268         uint64_t value;
    269 };
    270 
    271 typedef union cpuid3 cpuid3_t;
     268} cpuid3_t;
    272269
    273270#endif /* !__ASM__ */

  • kernel/arch/ia64/src/ivt.S

    r2f636b6 rf6b5593  
    391391
    392392    /* 10. call handler */
    393         movl r1 = _hardcoded_load_address
     393        movl r1 = kernel_image_start
    394394   
    395395        mov b1 = loc2

  • kernel/arch/ia64/src/mm/as.c

    r2f636b6 rf6b5593  
    5555void as_install_arch(as_t *as)
    5656{
    57         region_register rr;
     57        region_register_t rr;
    5858        int i;
    5959       
    … …  
    7373                rr.map.ps = PAGE_WIDTH;
    7474                rr_write(i, rr.word);
     75                srlz_d();
     76                srlz_i();
    7577        }
    76         srlz_d();
    77         srlz_i();
    7878}
    7979

  • kernel/arch/ia64/src/mm/page.c

    r2f636b6 rf6b5593  
    6363void set_environment(void)
    6464{
    65         region_register rr;
    66         pta_register pta;
     65        region_register_t rr;
     66        pta_register_t pta;
    6767        int i;
    6868#ifdef CONFIG_VHPT
    … …  
    131131vhpt_entry_t *vhpt_hash(uintptr_t page, asid_t asid)
    132132{
    133         region_register rr_save, rr;
     133        region_register_t rr_save, rr;
    134134        size_t vrn;
    135135        rid_t rid;
    … …  
    176176bool vhpt_compare(uintptr_t page, asid_t asid, vhpt_entry_t *v)
    177177{
    178         region_register rr_save, rr;   
     178        region_register_t rr_save, rr;
    179179        size_t vrn;
    180180        rid_t rid;
    … …  
    223223    int flags)
    224224{
    225         region_register rr_save, rr;   
     225        region_register_t rr_save, rr;
    226226        size_t vrn;
    227227        rid_t rid;
    … …  
    257257        v->present.ma = (flags & PAGE_CACHEABLE) ?
    258258            MA_WRITEBACK : MA_UNCACHEABLE;
    259         v->present.a = false;   /* not accessed */
    260         v->present.d = false;   /* not dirty */
     259        v->present.a = false;  /* not accessed */
     260        v->present.d = false;  /* not dirty */
    261261        v->present.pl = (flags & PAGE_USER) ? PL_USER : PL_KERNEL;
    262262        v->present.ar = (flags & PAGE_WRITE) ? AR_WRITE : AR_READ;
    263263        v->present.ar |= (flags & PAGE_EXEC) ? AR_EXECUTE : 0;
    264264        v->present.ppn = frame >> PPN_SHIFT;
    265         v->present.ed = false;  /* exception not deffered */
     265        v->present.ed = false;  /* exception not deffered */
    266266        v->present.ps = PAGE_WIDTH;
    267267        v->present.key = 0;

  • kernel/arch/ia64/src/mm/tlb.c

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64mm 
     29/** @addtogroup ia64mm
    3030 * @{
    3131 */
    … …  
    5353#include <interrupt.h>
    5454
     55#define IO_FRAME_BASE 0xFFFFC000000
     56
    5557/** Invalidate all TLB entries. */
    5658void tlb_invalidate_all(void)
    … …  
    5961        uintptr_t adr;
    6062        uint32_t count1, count2, stride1, stride2;
    61                
     63       
    6264        unsigned int i, j;
    63                
     65       
    6466        adr = PAL_PTCE_INFO_BASE();
    6567        count1 = PAL_PTCE_INFO_COUNT1();
    … …  
    6769        stride1 = PAL_PTCE_INFO_STRIDE1();
    6870        stride2 = PAL_PTCE_INFO_STRIDE2();
    69                
     71       
    7072        ipl = interrupts_disable();
    71 
     73       
    7274        for (i = 0; i < count1; i++) {
    7375                for (j = 0; j < count2; j++) {
    7476                        asm volatile (
    75                                 "ptc.e %0 ;;"
    76                                 :
    77                                 : "r" (adr)
     77                                "ptc.e %[adr] ;;"
     78                                :: [adr] "r" (adr)
    7879                        );
    7980                        adr += stride2;
    … …  
    8182                adr += stride1;
    8283        }
    83 
     84       
    8485        interrupts_restore(ipl);
    85 
     86       
    8687        srlz_d();
    8788        srlz_i();
     89       
    8890#ifdef CONFIG_VHPT
    8991        vhpt_invalidate_all();
    90 #endif 
     92#endif
    9193}
    9294
    9395/** Invalidate entries belonging to an address space.
    9496 *
    95  * @param asid          Address space identifier.
     97 * @param asid Address space identifier.
     98 *
    9699 */
    97100void tlb_invalidate_asid(asid_t asid)
    … …  
    103106void tlb_invalidate_pages(asid_t asid, uintptr_t page, size_t cnt)
    104107{
    105         region_register rr;
     108        region_register_t rr;
    106109        bool restore_rr = false;
    107110        int b = 0;
    108111        int c = cnt;
    109 
     112       
    110113        uintptr_t va;
    111114        va = page;
    112 
     115       
    113116        rr.word = rr_read(VA2VRN(va));
    114117        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    117120                 * Save the old content of the register and replace the RID.
    118121                 */
    119                 region_register rr0;
    120 
     122                region_register_t rr0;
     123               
    121124                rr0 = rr;
    122125                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    126129        }
    127130       
    128         while(c >>= 1)
     131        while (c >>= 1)
    129132                b++;
    130133        b >>= 1;
    … …  
    169172                break;
    170173        }
    171         for(; va < (page + cnt * PAGE_SIZE); va += (1 << ps))
    172                 asm volatile ("ptc.l %0, %1;;" :: "r" (va), "r" (ps << 2));
     174       
     175        for (; va < (page + cnt * PAGE_SIZE); va += (1 << ps))
     176                asm volatile (
     177                        "ptc.l %[va], %[ps] ;;"
     178                        :: [va]"r" (va),
     179                           [ps] "r" (ps << 2)
     180                );
     181       
    173182        srlz_d();
    174183        srlz_i();
    … …  
    183192/** Insert data into data translation cache.
    184193 *
    185  * @param va            Virtual page address.
    186  * @param asid          Address space identifier.
    187  * @param entry         The rest of TLB entry as required by TLB insertion
    188  *                      format.
     194 * @param va    Virtual page address.
     195 * @param asid  Address space identifier.
     196 * @param entry The rest of TLB entry as required by TLB insertion
     197 *              format.
     198 *
    189199 */
    190200void dtc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
    … …  
    195205/** Insert data into instruction translation cache.
    196206 *
    197  * @param va            Virtual page address.
    198  * @param asid          Address space identifier.
    199  * @param entry         The rest of TLB entry as required by TLB insertion
    200  *                      format.
     207 * @param va    Virtual page address.
     208 * @param asid  Address space identifier.
     209 * @param entry The rest of TLB entry as required by TLB insertion
     210 *              format.
    201211 */
    202212void itc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
    … …  
    207217/** Insert data into instruction or data translation cache.
    208218 *
    209  * @param va            Virtual page address.
    210  * @param asid          Address space identifier.
    211  * @param entry         The rest of TLB entry as required by TLB insertion
    212  *                      format.
    213  * @param dtc           If true, insert into data translation cache, use
    214  *                      instruction translation cache otherwise.
     219 * @param va    Virtual page address.
     220 * @param asid  Address space identifier.
     221 * @param entry The rest of TLB entry as required by TLB insertion
     222 *              format.
     223 * @param dtc   If true, insert into data translation cache, use
     224 *              instruction translation cache otherwise.
     225 *
    215226 */
    216227void tc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtc)
    217228{
    218         region_register rr;
     229        region_register_t rr;
    219230        bool restore_rr = false;
    220 
     231       
    221232        rr.word = rr_read(VA2VRN(va));
    222233        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    225236                 * Save the old content of the register and replace the RID.
    226237                 */
    227                 region_register rr0;
    228 
     238                region_register_t rr0;
     239               
    229240                rr0 = rr;
    230241                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    235246       
    236247        asm volatile (
    237                 "mov r8 = psr;;\n"
    238                 "rsm %0;;\n"                    /* PSR_IC_MASK */
    239                 "srlz.d;;\n"
    240                 "srlz.i;;\n"
    241                 "mov cr.ifa = %1\n"             /* va */
    242                 "mov cr.itir = %2;;\n"          /* entry.word[1] */
    243                 "cmp.eq p6,p7 = %4,r0;;\n"      /* decide between itc and dtc */
    244                 "(p6) itc.i %3;;\n"
    245                 "(p7) itc.d %3;;\n"
    246                 "mov psr.l = r8;;\n"
    247                 "srlz.d;;\n"
    248                 :
    249                 : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]),
    250                     "r" (entry.word[0]), "r" (dtc)
     248                "mov r8 = psr ;;\n"
     249                "rsm %[mask] ;;\n"                 /* PSR_IC_MASK */
     250                "srlz.d ;;\n"
     251                "srlz.i ;;\n"
     252                "mov cr.ifa = %[va]\n"             /* va */
     253                "mov cr.itir = %[word1] ;;\n"      /* entry.word[1] */
     254                "cmp.eq p6, p7 = %[dtc], r0 ;;\n"  /* decide between itc and dtc */
     255                "(p6) itc.i %[word0] ;;\n"
     256                "(p7) itc.d %[word0] ;;\n"
     257                "mov psr.l = r8 ;;\n"
     258                "srlz.d ;;\n"
     259                :: [mask] "i" (PSR_IC_MASK),
     260                   [va] "r" (va),
     261                   [word0] "r" (entry.word[0]),
     262                   [word1] "r" (entry.word[1]),
     263                   [dtc] "r" (dtc)
    251264                : "p6", "p7", "r8"
    252265        );
    … …  
    261274/** Insert data into instruction translation register.
    262275 *
    263  * @param va            Virtual page address.
    264  * @param asid          Address space identifier.
    265  * @param entry         The rest of TLB entry as required by TLB insertion
    266  *                      format.
    267  * @param tr            Translation register.
    268  */
    269 void
    270 itr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
     276 * @param va    Virtual page address.
     277 * @param asid  Address space identifier.
     278 * @param entry The rest of TLB entry as required by TLB insertion
     279 *              format.
     280 * @param tr    Translation register.
     281 *
     282 */
     283void itr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
    271284{
    272285        tr_mapping_insert(va, asid, entry, false, tr);
    … …  
    275288/** Insert data into data translation register.
    276289 *
    277  * @param va            Virtual page address.
    278  * @param asid          Address space identifier.
    279  * @param entry         The rest of TLB entry as required by TLB insertion
    280  *                      format.
    281  * @param tr            Translation register.
    282  */
    283 void
    284 dtr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
     290 * @param va    Virtual page address.
     291 * @param asid  Address space identifier.
     292 * @param entry The rest of TLB entry as required by TLB insertion
     293 *              format.
     294 * @param tr    Translation register.
     295 *
     296 */
     297void dtr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
    285298{
    286299        tr_mapping_insert(va, asid, entry, true, tr);
    … …  
    289302/** Insert data into instruction or data translation register.
    290303 *
    291  * @param va            Virtual page address.
    292  * @param asid          Address space identifier.
    293  * @param entry         The rest of TLB entry as required by TLB insertion
    294  *                      format.
    295  * @param dtr           If true, insert into data translation register, use
    296  *                      instruction translation register otherwise.
    297  * @param tr            Translation register.
    298  */
    299 void
    300 tr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtr,
     304 * @param va    Virtual page address.
     305 * @param asid  Address space identifier.
     306 * @param entry The rest of TLB entry as required by TLB insertion
     307 *              format.
     308 * @param dtr   If true, insert into data translation register, use
     309 *              instruction translation register otherwise.
     310 * @param tr    Translation register.
     311 *
     312 */
     313void tr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtr,
    301314    size_t tr)
    302315{
    303         region_register rr;
     316        region_register_t rr;
    304317        bool restore_rr = false;
    305 
     318       
    306319        rr.word = rr_read(VA2VRN(va));
    307320        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    310323                 * Save the old content of the register and replace the RID.
    311324                 */
    312                 region_register rr0;
    313 
     325                region_register_t rr0;
     326               
    314327                rr0 = rr;
    315328                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    318331                srlz_i();
    319332        }
    320 
     333       
    321334        asm volatile (
    322                 "mov r8 = psr;;\n"
    323                 "rsm %0;;\n"                    /* PSR_IC_MASK */
    324                 "srlz.d;;\n"
    325                 "srlz.i;;\n"
    326                 "mov cr.ifa = %1\n"             /* va */                 
    327                 "mov cr.itir = %2;;\n"          /* entry.word[1] */
    328                 "cmp.eq p6,p7 = %5,r0;;\n"      /* decide between itr and dtr */
    329                 "(p6) itr.i itr[%4] = %3;;\n"
    330                 "(p7) itr.d dtr[%4] = %3;;\n"
    331                 "mov psr.l = r8;;\n"
    332                 "srlz.d;;\n"
    333                 :
    334                 : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]),
    335                     "r" (entry.word[0]), "r" (tr), "r" (dtr)
     335                "mov r8 = psr ;;\n"
     336                "rsm %[mask] ;;\n"                       /* PSR_IC_MASK */
     337                "srlz.d ;;\n"
     338                "srlz.i ;;\n"
     339                "mov cr.ifa = %[va]\n"                   /* va */
     340                "mov cr.itir = %[word1] ;;\n"            /* entry.word[1] */
     341                "cmp.eq p6, p7 = %[dtr], r0 ;;\n"        /* decide between itr and dtr */
     342                "(p6) itr.i itr[%[tr]] = %[word0] ;;\n"
     343                "(p7) itr.d dtr[%[tr]] = %[word0] ;;\n"
     344                "mov psr.l = r8 ;;\n"
     345                "srlz.d ;;\n"
     346                :: [mask] "i" (PSR_IC_MASK),
     347                   [va] "r" (va),
     348                   [word1] "r" (entry.word[1]),
     349                   [word0] "r" (entry.word[0]),
     350                   [tr] "r" (tr),
     351                   [dtr] "r" (dtr)
    336352                : "p6", "p7", "r8"
    337353        );
    … …  
    346362/** Insert data into DTLB.
    347363 *
    348  * @param page          Virtual page address including VRN bits.
    349  * @param frame         Physical frame address.
    350  * @param dtr           If true, insert into data translation register, use data
    351  *                      translation cache otherwise.
    352  * @param tr            Translation register if dtr is true, ignored otherwise.
    353  */
    354 void
    355 dtlb_kernel_mapping_insert(uintptr_t page, uintptr_t frame, bool dtr,
     364 * @param page  Virtual page address including VRN bits.
     365 * @param frame Physical frame address.
     366 * @param dtr   If true, insert into data translation register, use data
     367 *              translation cache otherwise.
     368 * @param tr    Translation register if dtr is true, ignored otherwise.
     369 *
     370 */
     371void dtlb_kernel_mapping_insert(uintptr_t page, uintptr_t frame, bool dtr,
    356372    size_t tr)
    357373{
    … …  
    361377        entry.word[1] = 0;
    362378       
    363         entry.p = true;                 /* present */
     379        entry.p = true;           /* present */
    364380        entry.ma = MA_WRITEBACK;
    365         entry.a = true;                 /* already accessed */
    366         entry.d = true;                 /* already dirty */
     381        entry.a = true;           /* already accessed */
     382        entry.d = true;           /* already dirty */
    367383        entry.pl = PL_KERNEL;
    368384        entry.ar = AR_READ | AR_WRITE;
    … …  
    380396 * Purge DTR entries used by the kernel.
    381397 *
    382  * @param page          Virtual page address including VRN bits.
    383  * @param width         Width of the purge in bits.
     398 * @param page  Virtual page address including VRN bits.
     399 * @param width Width of the purge in bits.
     400 *
    384401 */
    385402void dtr_purge(uintptr_t page, size_t width)
    386403{
    387         asm volatile ("ptr.d %0, %1\n" : : "r" (page), "r" (width << 2));
     404        asm volatile (
     405                "ptr.d %[page], %[width]\n"
     406                :: [page] "r" (page),
     407                   [width] "r" (width << 2)
     408        );
    388409}
    389410
    … …  
    391412/** Copy content of PTE into data translation cache.
    392413 *
    393  * @param t             PTE.
     414 * @param t PTE.
     415 *
    394416 */
    395417void dtc_pte_copy(pte_t *t)
    396418{
    397419        tlb_entry_t entry;
    398 
     420       
    399421        entry.word[0] = 0;
    400422        entry.word[1] = 0;
    … …  
    410432       
    411433        dtc_mapping_insert(t->page, t->as->asid, entry);
     434       
    412435#ifdef CONFIG_VHPT
    413436        vhpt_mapping_insert(t->page, t->as->asid, entry);
    414 #endif 
     437#endif
    415438}
    416439
    417440/** Copy content of PTE into instruction translation cache.
    418441 *
    419  * @param t             PTE.
     442 * @param t PTE.
     443 *
    420444 */
    421445void itc_pte_copy(pte_t *t)
    422446{
    423447        tlb_entry_t entry;
    424 
     448       
    425449        entry.word[0] = 0;
    426450        entry.word[1] = 0;
    … …  
    437461       
    438462        itc_mapping_insert(t->page, t->as->asid, entry);
     463       
    439464#ifdef CONFIG_VHPT
    440465        vhpt_mapping_insert(t->page, t->as->asid, entry);
    441 #endif 
     466#endif
    442467}
    443468
    444469/** Instruction TLB fault handler for faults with VHPT turned off.
    445470 *
    446  * @param vector                Interruption vector.
    447  * @param istate                Structure with saved interruption state.
     471 * @param vector Interruption vector.
     472 * @param istate Structure with saved interruption state.
     473 *
    448474 */
    449475void alternate_instruction_tlb_fault(uint64_t vector, istate_t *istate)
    450476{
    451         region_register rr;
     477        region_register_t rr;
    452478        rid_t rid;
    453479        uintptr_t va;
    454480        pte_t *t;
    455481       
    456         va = istate->cr_ifa;    /* faulting address */
     482        va = istate->cr_ifa; /* faulting address */
    457483        rr.word = rr_read(VA2VRN(va));
    458484        rid = rr.map.rid;
    459 
     485       
    460486        page_table_lock(AS, true);
    461487        t = page_mapping_find(AS, va);
    … …  
    473499                page_table_unlock(AS, true);
    474500                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    475                         fault_if_from_uspace(istate,"Page fault at %p.",va);
     501                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    476502                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    477503                            istate->cr_iip);
    … …  
    488514}
    489515
    490 #define IO_FRAME_BASE 0xFFFFC000000
    491 
    492516/**
    493517 * There is special handling of memory mapped legacy io, because of 4KB sized
    494518 * access for userspace.
    495519 *
    496  * @param va            Virtual address of page fault.
    497  * @param istate        Structure with saved interruption state.
    498  *
    499  * @return              One on success, zero on failure.
     520 * @param va     Virtual address of page fault.
     521 * @param istate Structure with saved interruption state.
     522 *
     523 * @return One on success, zero on failure.
     524 *
    500525 */
    501526static int try_memmap_io_insertion(uintptr_t va, istate_t *istate)
    … …  
    505530                        uint64_t io_page = (va & ((1 << IO_PAGE_WIDTH) - 1)) >>
    506531                            USPACE_IO_PAGE_WIDTH;
    507 
     532                       
    508533                        if (is_io_page_accessible(io_page)) {
    509534                                uint64_t page, frame;
    510 
     535                               
    511536                                page = IO_OFFSET +
    512537                                    (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    513538                                frame = IO_FRAME_BASE +
    514539                                    (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    515 
     540                               
    516541                                tlb_entry_t entry;
    517        
     542                               
    518543                                entry.word[0] = 0;
    519544                                entry.word[1] = 0;
    520        
    521                                 entry.p = true;         /* present */
    522                                 entry.ma = MA_UNCACHEABLE;             
    523                                 entry.a = true;         /* already accessed */
    524                                 entry.d = true;         /* already dirty */
     545                               
     546                                entry.p = true;             /* present */
     547                                entry.ma = MA_UNCACHEABLE;
     548                                entry.a = true;             /* already accessed */
     549                                entry.d = true;             /* already dirty */
    525550                                entry.pl = PL_USER;
    526551                                entry.ar = AR_READ | AR_WRITE;
    527552                                entry.ppn = frame >> PPN_SHIFT;
    528553                                entry.ps = USPACE_IO_PAGE_WIDTH;
    529        
     554                               
    530555                                dtc_mapping_insert(page, TASK->as->asid, entry);
    531556                                return 1;
    … …  
    536561                }
    537562        }
    538                
     563       
    539564        return 0;
    540565}
    … …  
    542567/** Data TLB fault handler for faults with VHPT turned off.
    543568 *
    544  * @param vector        Interruption vector.
    545  * @param istate        Structure with saved interruption state.
     569 * @param vector Interruption vector.
     570 * @param istate Structure with saved interruption state.
     571 *
    546572 */
    547573void alternate_data_tlb_fault(uint64_t vector, istate_t *istate)
    548574{
    549         region_register rr;
    550         rid_t rid;
    551         uintptr_t va;
    552         pte_t *t;
    553        
    554         va = istate->cr_ifa;    /* faulting address */
    555         rr.word = rr_read(VA2VRN(va));
    556         rid = rr.map.rid;
     575        if (istate->cr_isr.sp) {
     576                /* Speculative load. Deffer the exception
     577                   until a more clever approach can be used.
     578                   
     579                   Currently if we try to find the mapping
     580                   for the speculative load while in the kernel,
     581                   we might introduce a livelock because of
     582                   the possibly invalid values of the address. */
     583                istate->cr_ipsr.ed = true;
     584                return;
     585        }
     586       
     587        uintptr_t va = istate->cr_ifa;  /* faulting address */
     588       
     589        region_register_t rr;
     590        rr.word = rr_read(VA2VRN(va));
     591        rid_t rid = rr.map.rid;
    557592        if (RID2ASID(rid) == ASID_KERNEL) {
    558593                if (VA2VRN(va) == VRN_KERNEL) {
    … …  
    565600                }
    566601        }
    567 
     602       
     603       
    568604        page_table_lock(AS, true);
    569         t = page_mapping_find(AS, va);
    570         if (t) {
     605        pte_t *entry = page_mapping_find(AS, va);
     606        if (entry) {
    571607                /*
    572608                 * The mapping was found in the software page hash table.
    573609                 * Insert it into data translation cache.
    574610                 */
    575                 dtc_pte_copy(t);
     611                dtc_pte_copy(entry);
    576612                page_table_unlock(AS, true);
    577613        } else {
    … …  
    579615                if (try_memmap_io_insertion(va, istate))
    580616                        return;
    581                 /*
    582                  * Forward the page fault to the address space page fault
     617               
     618                /*
     619                 * Forward the page fault to the address space page fault
    583620                 * handler.
    584621                 */
    585622                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    586                         fault_if_from_uspace(istate,"Page fault at %p.",va);
     623                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    587624                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    588625                            istate->cr_iip);
    … …  
    595632 * This fault should not occur.
    596633 *
    597  * @param vector        Interruption vector.
    598  * @param istate        Structure with saved interruption state.
     634 * @param vector Interruption vector.
     635 * @param istate Structure with saved interruption state.
     636 *
    599637 */
    600638void data_nested_tlb_fault(uint64_t vector, istate_t *istate)
    601639{
    602         panic("%s.", __func__);
     640        ASSERT(false);
    603641}
    604642
    605643/** Data Dirty bit fault handler.
    606644 *
    607  * @param vector        Interruption vector.
    608  * @param istate        Structure with saved interruption state.
     645 * @param vector Interruption vector.
     646 * @param istate Structure with saved interruption state.
     647 *
    609648 */
    610649void data_dirty_bit_fault(uint64_t vector, istate_t *istate)
    611650{
    612         region_register rr;
     651        region_register_t rr;
    613652        rid_t rid;
    614653        uintptr_t va;
    615654        pte_t *t;
    616655       
    617         va = istate->cr_ifa;    /* faulting address */
     656        va = istate->cr_ifa;  /* faulting address */
    618657        rr.word = rr_read(VA2VRN(va));
    619658        rid = rr.map.rid;
    620 
     659       
    621660        page_table_lock(AS, true);
    622661        t = page_mapping_find(AS, va);
    623         ASSERT(t && t->p);
    624         if (t && t->p && t->w) {
     662        ASSERT((t) && (t->p));
     663        if ((t) && (t->p) && (t->w)) {
    625664                /*
    626665                 * Update the Dirty bit in page tables and reinsert
    … …  
    631670        } else {
    632671                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    633                         fault_if_from_uspace(istate,"Page fault at %p.",va);
     672                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    634673                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    635674                            istate->cr_iip);
    … …  
    641680/** Instruction access bit fault handler.
    642681 *
    643  * @param vector        Interruption vector.
    644  * @param istate        Structure with saved interruption state.
     682 * @param vector Interruption vector.
     683 * @param istate Structure with saved interruption state.
     684 *
    645685 */
    646686void instruction_access_bit_fault(uint64_t vector, istate_t *istate)
    647687{
    648         region_register rr;
     688        region_register_t rr;
    649689        rid_t rid;
    650690        uintptr_t va;
    651         pte_t *t;       
    652 
    653         va = istate->cr_ifa;    /* faulting address */
     691        pte_t *t;
     692       
     693        va = istate->cr_ifa;  /* faulting address */
    654694        rr.word = rr_read(VA2VRN(va));
    655695        rid = rr.map.rid;
    656 
     696       
    657697        page_table_lock(AS, true);
    658698        t = page_mapping_find(AS, va);
    659         ASSERT(t && t->p);
    660         if (t && t->p && t->x) {
     699        ASSERT((t) && (t->p));
     700        if ((t) && (t->p) && (t->x)) {
    661701                /*
    662702                 * Update the Accessed bit in page tables and reinsert
    … …  
    679719 * @param vector Interruption vector.
    680720 * @param istate Structure with saved interruption state.
     721 *
    681722 */
    682723void data_access_bit_fault(uint64_t vector, istate_t *istate)
    683724{
    684         region_register rr;
     725        region_register_t rr;
    685726        rid_t rid;
    686727        uintptr_t va;
    687728        pte_t *t;
    688 
    689         va = istate->cr_ifa;    /* faulting address */
     729       
     730        va = istate->cr_ifa;  /* faulting address */
    690731        rr.word = rr_read(VA2VRN(va));
    691732        rid = rr.map.rid;
    692 
     733       
    693734        page_table_lock(AS, true);
    694735        t = page_mapping_find(AS, va);
    695         ASSERT(t && t->p);
    696         if (t && t->p) {
     736        ASSERT((t) && (t->p));
     737        if ((t) && (t->p)) {
    697738                /*
    698739                 * Update the Accessed bit in page tables and reinsert
    … …  
    715756 * @param vector Interruption vector.
    716757 * @param istate Structure with saved interruption state.
     758 *
    717759 */
    718760void data_access_rights_fault(uint64_t vector, istate_t *istate)
    719761{
    720         region_register rr;
     762        region_register_t rr;
    721763        rid_t rid;
    722764        uintptr_t va;
    723765        pte_t *t;
    724 
    725         va = istate->cr_ifa;    /* faulting address */
     766       
     767        va = istate->cr_ifa;  /* faulting address */
    726768        rr.word = rr_read(VA2VRN(va));
    727769        rid = rr.map.rid;
    728 
     770       
    729771        /*
    730772         * Assume a write to a read-only page.
    … …  
    732774        page_table_lock(AS, true);
    733775        t = page_mapping_find(AS, va);
    734         ASSERT(t && t->p);
     776        ASSERT((t) && (t->p));
    735777        ASSERT(!t->w);
    736778        if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    … …  
    746788 * @param vector Interruption vector.
    747789 * @param istate Structure with saved interruption state.
     790 *
    748791 */
    749792void page_not_present(uint64_t vector, istate_t *istate)
    750793{
    751         region_register rr;
     794        region_register_t rr;
    752795        rid_t rid;
    753796        uintptr_t va;
    754797        pte_t *t;
    755798       
    756         va = istate->cr_ifa;    /* faulting address */
     799        va = istate->cr_ifa;  /* faulting address */
    757800        rr.word = rr_read(VA2VRN(va));
    758801        rid = rr.map.rid;
    759 
     802       
    760803        page_table_lock(AS, true);
    761804        t = page_mapping_find(AS, va);

  • kernel/arch/ia64/src/mm/vhpt.c

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup ia64mm 
     29/** @addtogroup ia64mm
    3030 * @{
    3131 */
    … …  
    4444        vhpt_base = frame_alloc(VHPT_WIDTH - FRAME_WIDTH,
    4545            FRAME_KA | FRAME_ATOMIC);
    46         if (!vhpt_base) 
     46        if (!vhpt_base)
    4747                panic("Kernel configured with VHPT but no memory for table.");
    4848        vhpt_invalidate_all();
    … …  
    5353void vhpt_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
    5454{
    55         region_register rr_save, rr;
     55        region_register_t rr_save, rr;
    5656        size_t vrn;
    5757        rid_t rid;
    5858        uint64_t tag;
    59 
     59       
    6060        vhpt_entry_t *ventry;
    61 
    62 
     61       
    6362        vrn = va >> VRN_SHIFT;
    6463        rid = ASID2RID(asid, vrn);
    65                                                                                                                                                                                                                                
     64       
    6665        rr_save.word = rr_read(vrn);
    6766        rr.word = rr_save.word;
    … …  
    7574        srlz_i();
    7675        srlz_d();
    77 
     76       
    7877        ventry->word[0] = entry.word[0];
    7978        ventry->word[1] = entry.word[1];

  • kernel/arch/ia64/src/start.S

    r2f636b6 rf6b5593  
    3232#include <mm/asid.h>
    3333
    34 #define RR_MASK (0xFFFFFFFF00000002)
    35 #define RID_SHIFT       8
    36 #define PS_SHIFT        2
    37 
    38 #define KERNEL_TRANSLATION_I    0x0010000000000661
    39 #define KERNEL_TRANSLATION_D    0x0010000000000661
    40 #define KERNEL_TRANSLATION_VIO  0x0010000000000671
    41 #define KERNEL_TRANSLATION_IO   0x00100FFFFC000671
    42 #define KERNEL_TRANSLATION_FW   0x00100000F0000671
     34#define RR_MASK    (0xFFFFFFFF00000002)
     35#define RID_SHIFT  8
     36#define PS_SHIFT   2
     37
     38#define KERNEL_TRANSLATION_I    0x0010000000000661
     39#define KERNEL_TRANSLATION_D    0x0010000000000661
     40#define KERNEL_TRANSLATION_VIO  0x0010000000000671
     41#define KERNEL_TRANSLATION_IO   0x00100FFFFC000671
     42#define KERNEL_TRANSLATION_FW   0x00100000F0000671
    4343
    4444.section K_TEXT_START, "ax"
    … …  
    4949kernel_image_start:
    5050        .auto
    51 
     51       
    5252#ifdef CONFIG_SMP
    5353        # Identify self(CPU) in OS structures by ID / EID
    54 
     54       
    5555        mov r9 = cr64
    5656        mov r10 = 1
    … …  
    6262        st1 [r8] = r10
    6363#endif
    64 
     64       
    6565        mov psr.l = r0
    6666        srlz.i
    6767        srlz.d
    68 
     68       
    6969        # Fill TR.i and TR.d using Region Register #VRN_KERNEL
    70 
     70       
    7171        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    7272        mov r9 = rr[r8]
    73 
     73       
    7474        movl r10 = (RR_MASK)
    7575        and r9 = r10, r9
    7676        movl r10 = ((RID_KERNEL << RID_SHIFT) | (KERNEL_PAGE_WIDTH << PS_SHIFT))
    77         or  r9 = r10, r9
    78 
     77        or r9 = r10, r9
     78       
    7979        mov rr[r8] = r9
    80 
     80       
    8181        movl r8 = (VRN_KERNEL << VRN_SHIFT)
    8282        mov cr.ifa = r8
    83 
     83       
    8484        mov r11 = cr.itir
    8585        movl r10 = (KERNEL_PAGE_WIDTH << PS_SHIFT)
    8686        or r10 = r10, r11
    8787        mov cr.itir = r10
    88 
     88       
    8989        movl r10 = (KERNEL_TRANSLATION_I)
    9090        itr.i itr[r0] = r10
    9191        movl r10 = (KERNEL_TRANSLATION_D)
    9292        itr.d dtr[r0] = r10
    93 
     93       
    9494        movl r7 = 1
    9595        movl r8 = (VRN_KERNEL << VRN_SHIFT) | VIO_OFFSET
    … …  
    9797        movl r10 = (KERNEL_TRANSLATION_VIO)
    9898        itr.d dtr[r7] = r10
    99 
     99       
    100100        mov r11 = cr.itir
    101101        movl r10 = ~0xfc
    … …  
    104104        or r10 = r10, r11
    105105        mov cr.itir = r10
    106 
     106       
    107107        movl r7 = 2
    108108        movl r8 = (VRN_KERNEL << VRN_SHIFT) | IO_OFFSET
    … …  
    110110        movl r10 = (KERNEL_TRANSLATION_IO)
    111111        itr.d dtr[r7] = r10
    112 
    113         # Setup mapping for fimware arrea (also SAPIC)
    114 
     112       
     113        # Setup mapping for firmware area (also SAPIC)
     114       
    115115        mov r11 = cr.itir
    116116        movl r10 = ~0xfc
    … …  
    119119        or r10 = r10, r11
    120120        mov cr.itir = r10
    121 
     121       
    122122        movl r7 = 3
    123123        movl r8 = (VRN_KERNEL << VRN_SHIFT) | FW_OFFSET
    … …  
    125125        movl r10 = (KERNEL_TRANSLATION_FW)
    126126        itr.d dtr[r7] = r10
    127 
     127       
     128        # Initialize DSR
     129       
     130        movl r10 = (DCR_DP_MASK | DCR_DK_MASK | DCR_DX_MASK | DCR_DR_MASK | DCR_DA_MASK | DCR_DD_MASK | DCR_LC_MASK)
     131        mov r9 = cr.dcr
     132        or r10 = r10, r9
     133        mov cr.dcr = r10
     134       
    128135        # Initialize PSR
    129 
     136       
    130137        movl r10 = (PSR_DT_MASK | PSR_RT_MASK | PSR_IT_MASK | PSR_IC_MASK)  /* Enable paging */
    131138        mov r9 = psr
    132 
     139       
    133140        or r10 = r10, r9
    134141        mov cr.ipsr = r10
    … …  
    138145        srlz.d
    139146        srlz.i
    140 
     147       
    141148        .explicit
    142 
     149       
    143150        /*
    144151         * Return From Interrupt is the only way to
    … …  
    147154        rfi ;;
    148155
    149 
    150156.global paging_start
    151157paging_start:
    152 
     158       
    153159        /*
    154160         * Now we are paging.
    155161         */
    156 
     162       
    157163        # Switch to register bank 1
    158164        bsw.1
    159 
     165       
    160166#ifdef CONFIG_SMP
    161167        # Am I BSP or AP?
    … …  
    164170        cmp.eq p3, p2 = r20, r0 ;;
    165171#else
    166         cmp.eq p3, p2 = r0, r0 ;;       /* you are BSP */
    167 #endif  /* CONFIG_SMP */
     172        cmp.eq p3, p2 = r0, r0 ;;  /* you are BSP */
     173#endif  /* CONFIG_SMP */
    168174       
    169175        # Initialize register stack
    … …  
    172178        mov ar.bspstore = r8
    173179        loadrs
    174 
     180       
    175181        # Initialize memory stack to some sane value
    176182        movl r12 = stack0 ;;
    177         add r12 = -16, r12      /* allocate a scratch area on the stack */
    178 
     183        add r12 = -16, r12  /* allocate a scratch area on the stack */
     184       
    179185        # Initialize gp (Global Pointer) register
    180         movl r20 = (VRN_KERNEL << VRN_SHIFT);;
    181         or r20 = r20,r1;;
    182         movl r1 = _hardcoded_load_address
     186        movl r20 = (VRN_KERNEL << VRN_SHIFT) ;;
     187        or r20 = r20, r1 ;;
     188        movl r1 = kernel_image_start
    183189       
    184190        /*
    185          * Initialize hardcoded_* variables. Do only BSP
     191         * Initialize bootinfo on BSP.
    186192         */
    187 (p3)    movl r14 = _hardcoded_ktext_size
    188 (p3)    movl r15 = _hardcoded_kdata_size
    189 (p3)    movl r16 = _hardcoded_load_address ;;
    190 (p3)    addl r17 = @gprel(hardcoded_ktext_size), gp
    191 (p3)    addl r18 = @gprel(hardcoded_kdata_size), gp
    192 (p3)    addl r19 = @gprel(hardcoded_load_address), gp
    193 (p3)    addl r21 = @gprel(bootinfo), gp
    194         ;;
    195 (p3)    st8 [r17] = r14
    196 (p3)    st8 [r18] = r15
    197 (p3)    st8 [r19] = r16
     193(p3)    addl r21 = @gprel(bootinfo), gp ;;
    198194(p3)    st8 [r21] = r20
    199 
     195       
    200196        ssm (1 << 19) ;; /* Disable f32 - f127 */
    201197        srlz.i
    202198        srlz.d ;;
    203 
     199       
    204200#ifdef CONFIG_SMP
    205201(p2)    movl r18 = main_ap ;;
    206 (p2)    mov b1 = r18 ;;
     202(p2)    mov b1 = r18 ;;
    207203(p2)    br.call.sptk.many b0 = b1
    208 
     204       
    209205        # Mark that BSP is on
     206       
    210207        mov r20 = 1 ;;
    211208        movl r21 = bsp_started ;;
    212209        st8 [r21] = r20 ;;
    213210#endif
    214 
     211       
    215212        br.call.sptk.many b0 = arch_pre_main
    216 
     213       
    217214        movl r18 = main_bsp ;;
    218215        mov b1 = r18 ;;
    … …  
    227224kernel_image_ap_start:
    228225        .auto
    229 
     226       
    230227        # Identify self(CPU) in OS structures by ID / EID
    231 
     228       
    232229        mov r9 = cr64
    233230        mov r10 = 1
    … …  
    240237       
    241238        # Wait for wakeup synchro signal (#3 in cpu_by_id_eid_list)
    242        
     239
    243240kernel_image_ap_start_loop:
    244241        movl r11 = kernel_image_ap_start_loop
    245242        and r11 = r11, r12
    246         mov b1 = r11
    247 
    248         ld1 r20 = [r8] ;;
    249         movl r21 = 3 ;;
    250         cmp.eq p2, p3 = r20, r21 ;;
     243        mov b1 = r11
     244       
     245        ld1 r20 = [r8]
     246        movl r21 = 3
     247        cmp.eq p2, p3 = r20, r21
    251248(p3)    br.call.sptk.many b0 = b1
    252 
     249       
    253250        movl r11 = kernel_image_start
    254251        and r11 = r11, r12
    255         mov b1 = r11 
     252        mov b1 = r11
    256253        br.call.sptk.many b0 = b1
    257254
    … …  
    259256.global bsp_started
    260257bsp_started:
    261 .space 8
     258        .space 8
    262259
    263260.align 4096
    264261.global cpu_by_id_eid_list
    265262cpu_by_id_eid_list:
    266 .space 65536
    267 
    268 #endif  /* CONFIG_SMP */
     263        .space 65536
     264
     265#endif  /* CONFIG_SMP */

  • kernel/arch/mips32/include/mm/tlb.h

    r2f636b6 rf6b5593  
    5959typedef union {
    6060        struct {
    61 #ifdef BIG_ENDIAN
     61#ifdef __BE__
    6262                unsigned : 2;       /* zero */
    6363                unsigned pfn : 24;  /* frame number */
    … …  
    8080typedef union {
    8181        struct {
    82 #ifdef BIG_ENDIAN
     82#ifdef __BE__
    8383                unsigned vpn2 : 19;
    8484                unsigned : 5;
    … …  
    9595typedef union {
    9696        struct {
    97 #ifdef BIG_ENDIAN
     97#ifdef __BE__
    9898                unsigned : 7;
    9999                unsigned mask : 12;
    … …  
    110110typedef union {
    111111        struct {
    112 #ifdef BIG_ENDIAN
     112#ifdef __BE__
    113113                unsigned p : 1;
    114114                unsigned : 27;

  • kernel/generic/include/main/main.h

    r2f636b6 rf6b5593  
    3838#include <arch/types.h>
    3939
     40extern size_t hardcoded_kdata_size;
     41extern size_t hardcoded_ktext_size;
     42extern uintptr_t hardcoded_load_address;
    4043extern uintptr_t stack_safe;
    4144

  • kernel/generic/src/main/main.c

    r2f636b6 rf6b5593  
    101101context_t ctx;
    102102
    103 /*
    104  * These 'hardcoded' variables will be intialized by
    105  * the linker or the low level assembler code with
    106  * appropriate sizes and addresses.
    107  */
    108 
    109 /** Virtual address of where the kernel is loaded. */
    110 uintptr_t hardcoded_load_address = 0;
    111 /** Size of the kernel code in bytes. */
    112 size_t hardcoded_ktext_size = 0;
    113 /** Size of the kernel data in bytes. */
    114 size_t hardcoded_kdata_size = 0;
    115103/** Lowest safe stack virtual address. */
    116104uintptr_t stack_safe = 0;               

  • uspace/Makefile

    r2f636b6 rf6b5593  
    5252        srv/vfs \
    5353        srv/devmap \
     54        srv/part/mbr_part \
     55        app/edit \
    5456        app/tetris \
    5557        app/tester \

  • uspace/app/bdsh/cmds/modules/bdd/bdd.c

    r2f636b6 rf6b5593  
    4242#include <assert.h>
    4343
    44 #define BLOCK_SIZE      512
    45 #define BPR              16
     44enum {
     45        /* Number of bytes per row */
     46        BPR = 16
     47};
    4648
    4749static const char *cmdname = "bdd";
    … …  
    6769        unsigned int i, j;
    6870        dev_handle_t handle;
    69         block_t *block;
    7071        uint8_t *blk;
    7172        size_t size, bytes, rows;
     73        size_t block_size;
    7274        int rc;
    73         bn_t boff;
     75        bn_t ba;
    7476        uint8_t b;
    7577
    … …  
    8385
    8486        if (argc >= 3)
    85                 boff = strtol(argv[2], NULL, 0);
     87                ba = strtol(argv[2], NULL, 0);
    8688        else
    87                 boff = 0;
     89                ba = 0;
    8890
    8991        if (argc >= 4)
    … …  
    9496        rc = devmap_device_get_handle(argv[1], &handle, 0);
    9597        if (rc != EOK) {
    96                 printf("Error: could not resolve device `%s'.\n", argv[1]);
     98                printf("%s: Error resolving device `%s'.\n", cmdname, argv[1]);
    9799                return CMD_FAILURE;
    98100        }
    99101
    100         rc = block_init(handle, BLOCK_SIZE);
     102        rc = block_init(handle, 2048);
    101103        if (rc != EOK)  {
    102                 printf("Error: could not init libblock.\n");
     104                printf("%s: Error initializing libblock.\n", cmdname);
    103105                return CMD_FAILURE;
    104106        }
    105107
    106         rc = block_cache_init(handle, BLOCK_SIZE, 2, CACHE_MODE_WB);
     108        rc = block_get_bsize(handle, &block_size);
    107109        if (rc != EOK) {
    108                 printf("Error: could not init block cache.\n");
     110                printf("%s: Error determining device block size.\n", cmdname);
     111                return CMD_FAILURE;
     112        }
     113
     114        blk = malloc(block_size);
     115        if (blk == NULL) {
     116                printf("%s: Error allocating memory.\n", cmdname);
     117                block_fini(handle);
    109118                return CMD_FAILURE;
    110119        }
    111120
    112121        while (size > 0) {
    113                 rc = block_get(&block, handle, boff, 0);
     122                rc = block_read_direct(handle, ba, 1, blk);
    114123                if (rc != EOK) {
    115                         printf("Error: could not get block %u, device %u.\n",
    116                             boff, handle);
     124                        printf("%s: Error reading block %llu\n", cmdname, ba);
     125                        free(blk);
     126                        block_fini(handle);
    117127                        return CMD_FAILURE;
    118128                }
    119                 blk = (uint8_t *) block->data;
    120129
    121                 bytes = (size < BLOCK_SIZE) ? size : BLOCK_SIZE;
     130                bytes = (size < block_size) ? size : block_size;
    122131                rows = (bytes + BPR - 1) / BPR;
    123132
    … …  
    145154                }
    146155
    147                 rc = block_put(block);
    148                 if (rc != EOK) {
    149                         printf("Error: could not put block %p.\n",
    150                             block);
    151                         return CMD_FAILURE;
    152                 }
    153 
    154156                if (size > rows * BPR)
    155157                        size -= rows * BPR;
    … …  
    157159                        size = 0;
    158160
    159                 boff += rows * BPR;
     161                /* Next block */
     162                ba += 1;
    160163        }
    161164
     165        free(blk);
    162166        block_fini(handle);
    163167

  • uspace/app/tetris/screen.h

    r2f636b6 rf6b5593  
    5151
    5252typedef struct {
    53         ipcarg_t ws_row;
    54         ipcarg_t ws_col;
     53        int ws_row;
     54        int ws_col;
    5555} winsize_t;
    5656

  • uspace/lib/libblock/libblock.c

    r2f636b6 rf6b5593  
    5050#include <adt/list.h>
    5151#include <adt/hash_table.h>
     52#include <macros.h>
    5253#include <mem.h>
    5354
    … …  
    6263typedef struct {
    6364        fibril_mutex_t lock;
    64         size_t block_size;              /**< Block size. */
     65        size_t lblock_size;             /**< Logical block size. */
    6566        unsigned block_count;           /**< Total number of blocks. */
    6667        unsigned blocks_cached;         /**< Number of cached blocks. */
    … …  
    7475        dev_handle_t dev_handle;
    7576        int dev_phone;
    76         fibril_mutex_t com_area_lock;
    77         void *com_area;
    78         size_t com_size;
     77        fibril_mutex_t comm_area_lock;
     78        void *comm_area;
     79        size_t comm_size;
    7980        void *bb_buf;
    80         off_t bb_off;
    81         size_t bb_size;
     81        bn_t bb_addr;
     82        size_t pblock_size;             /**< Physical block size. */
    8283        cache_t *cache;
    8384} devcon_t;
    8485
    85 static int read_block(devcon_t *devcon, bn_t boff, size_t block_size);
    86 static int write_block(devcon_t *devcon, bn_t boff, size_t block_size);
     86static int read_blocks(devcon_t *devcon, bn_t ba, size_t cnt);
     87static int write_blocks(devcon_t *devcon, bn_t ba, size_t cnt);
     88static int get_block_size(int dev_phone, size_t *bsize);
    8789
    8890static devcon_t *devcon_search(dev_handle_t dev_handle)
    … …  
    102104}
    103105
    104 static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
    105    size_t com_size)
     106static int devcon_add(dev_handle_t dev_handle, int dev_phone, size_t bsize,
     107    void *comm_area, size_t comm_size)
    106108{
    107109        link_t *cur;
    108110        devcon_t *devcon;
     111
     112        if (comm_size < bsize)
     113                return EINVAL;
    109114
    110115        devcon = malloc(sizeof(devcon_t));
    … …  
    115120        devcon->dev_handle = dev_handle;
    116121        devcon->dev_phone = dev_phone;
    117         fibril_mutex_initialize(&devcon->com_area_lock);
    118         devcon->com_area = com_area;
    119         devcon->com_size = com_size;
     122        fibril_mutex_initialize(&devcon->comm_area_lock);
     123        devcon->comm_area = comm_area;
     124        devcon->comm_size = comm_size;
    120125        devcon->bb_buf = NULL;
    121         devcon->bb_off = 0;
    122         devcon->bb_size = 0;
     126        devcon->bb_addr = 0;
     127        devcon->pblock_size = bsize;
    123128        devcon->cache = NULL;
    124129
    … …  
    144149}
    145150
    146 int block_init(dev_handle_t dev_handle, size_t com_size)
     151int block_init(dev_handle_t dev_handle, size_t comm_size)
    147152{
    148153        int rc;
    149154        int dev_phone;
    150         void *com_area;
    151        
    152         com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
     155        void *comm_area;
     156        size_t bsize;
     157
     158        comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
    153159            MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    154         if (!com_area) {
     160        if (!comm_area) {
    155161                return ENOMEM;
    156162        }
    … …  
    158164        dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
    159165        if (dev_phone < 0) {
    160                 munmap(com_area, com_size);
     166                munmap(comm_area, comm_size);
    161167                return dev_phone;
    162168        }
    163169
    164         rc = ipc_share_out_start(dev_phone, com_area,
     170        rc = ipc_share_out_start(dev_phone, comm_area,
    165171            AS_AREA_READ | AS_AREA_WRITE);
    166172        if (rc != EOK) {
    167                 munmap(com_area, com_size);
     173                munmap(comm_area, comm_size);
    168174                ipc_hangup(dev_phone);
    169175                return rc;
    170176        }
    171        
    172         rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
     177
     178        if (get_block_size(dev_phone, &bsize) != EOK) {
     179                munmap(comm_area, comm_size);
     180                ipc_hangup(dev_phone);
     181                return rc;
     182        }
     183       
     184        rc = devcon_add(dev_handle, dev_phone, bsize, comm_area, comm_size);
    173185        if (rc != EOK) {
    174                 munmap(com_area, com_size);
     186                munmap(comm_area, comm_size);
    175187                ipc_hangup(dev_phone);
    176188                return rc;
    … …  
    195207        }
    196208
    197         munmap(devcon->com_area, devcon->com_size);
     209        munmap(devcon->comm_area, devcon->comm_size);
    198210        ipc_hangup(devcon->dev_phone);
    199211
    … …  
    201213}
    202214
    203 int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
     215int block_bb_read(dev_handle_t dev_handle, bn_t ba)
    204216{
    205217        void *bb_buf;
    … …  
    211223        if (devcon->bb_buf)
    212224                return EEXIST;
    213         bb_buf = malloc(size);
     225        bb_buf = malloc(devcon->pblock_size);
    214226        if (!bb_buf)
    215227                return ENOMEM;
    216        
    217         fibril_mutex_lock(&devcon->com_area_lock);
    218         rc = read_block(devcon, 0, size);
     228
     229        fibril_mutex_lock(&devcon->comm_area_lock);
     230        rc = read_blocks(devcon, 0, 1);
    219231        if (rc != EOK) {
    220                 fibril_mutex_unlock(&devcon->com_area_lock);
     232                fibril_mutex_unlock(&devcon->comm_area_lock);
    221233                free(bb_buf);
    222234                return rc;
    223235        }
    224         memcpy(bb_buf, devcon->com_area, size);
    225         fibril_mutex_unlock(&devcon->com_area_lock);
     236        memcpy(bb_buf, devcon->comm_area, devcon->pblock_size);
     237        fibril_mutex_unlock(&devcon->comm_area_lock);
    226238
    227239        devcon->bb_buf = bb_buf;
    228         devcon->bb_off = off;
    229         devcon->bb_size = size;
     240        devcon->bb_addr = ba;
    230241
    231242        return EOK;
    … …  
    275286        fibril_mutex_initialize(&cache->lock);
    276287        list_initialize(&cache->free_head);
    277         cache->block_size = size;
     288        cache->lblock_size = size;
    278289        cache->block_count = blocks;
    279290        cache->blocks_cached = 0;
    280291        cache->mode = mode;
     292
     293        /* No block size translation a.t.m. */
     294        assert(cache->lblock_size == devcon->pblock_size);
    281295
    282296        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
    … …  
    371385                        if (!b)
    372386                                goto recycle;
    373                         b->data = malloc(cache->block_size);
     387                        b->data = malloc(cache->lblock_size);
    374388                        if (!b->data) {
    375389                                free(b);
    … …  
    405419                                list_append(&b->free_link, &cache->free_head);
    406420                                fibril_mutex_unlock(&cache->lock);
    407                                 fibril_mutex_lock(&devcon->com_area_lock);
    408                                 memcpy(devcon->com_area, b->data, b->size);
    409                                 rc = write_block(devcon, b->boff,
    410                                     cache->block_size);
    411                                 fibril_mutex_unlock(&devcon->com_area_lock);
     421                                fibril_mutex_lock(&devcon->comm_area_lock);
     422                                memcpy(devcon->comm_area, b->data, b->size);
     423                                rc = write_blocks(devcon, b->boff, 1);
     424                                fibril_mutex_unlock(&devcon->comm_area_lock);
    412425                                if (rc != EOK) {
    413426                                        /*
    … …  
    444457                block_initialize(b);
    445458                b->dev_handle = dev_handle;
    446                 b->size = cache->block_size;
     459                b->size = cache->lblock_size;
    447460                b->boff = boff;
    448461                hash_table_insert(&cache->block_hash, &key, &b->hash_link);
    … …  
    461474                         * the new contents from the device.
    462475                         */
    463                         fibril_mutex_lock(&devcon->com_area_lock);
    464                         rc = read_block(devcon, b->boff, cache->block_size);
    465                         memcpy(b->data, devcon->com_area, cache->block_size);
    466                         fibril_mutex_unlock(&devcon->com_area_lock);
     476                        fibril_mutex_lock(&devcon->comm_area_lock);
     477                        rc = read_blocks(devcon, b->boff, 1);
     478                        memcpy(b->data, devcon->comm_area, cache->lblock_size);
     479                        fibril_mutex_unlock(&devcon->comm_area_lock);
    467480                        if (rc != EOK)
    468481                                b->toxic = true;
    … …  
    521534        if (block->dirty && (block->refcnt == 1) &&
    522535            (blocks_cached > CACHE_HI_WATERMARK || mode != CACHE_MODE_WB)) {
    523                 fibril_mutex_lock(&devcon->com_area_lock);
    524                 memcpy(devcon->com_area, block->data, block->size);
    525                 rc = write_block(devcon, block->boff, block->size);
    526                 fibril_mutex_unlock(&devcon->com_area_lock);
     536                fibril_mutex_lock(&devcon->comm_area_lock);
     537                memcpy(devcon->comm_area, block->data, block->size);
     538                rc = write_blocks(devcon, block->boff, 1);
     539                fibril_mutex_unlock(&devcon->comm_area_lock);
    527540                block->dirty = false;
    528541        }
    … …  
    601614 */
    602615int block_seqread(dev_handle_t dev_handle, off_t *bufpos, size_t *buflen,
    603     off_t *pos, void *dst, size_t size, size_t block_size)
     616    off_t *pos, void *dst, size_t size)
    604617{
    605618        off_t offset = 0;
    606619        size_t left = size;
    607         devcon_t *devcon = devcon_search(dev_handle);
    608         assert(devcon);
    609        
    610         fibril_mutex_lock(&devcon->com_area_lock);
     620        size_t block_size;
     621        devcon_t *devcon;
     622
     623        devcon = devcon_search(dev_handle);
     624        assert(devcon);
     625        block_size = devcon->pblock_size;
     626       
     627        fibril_mutex_lock(&devcon->comm_area_lock);
    611628        while (left > 0) {
    612629                size_t rd;
    … …  
    622639                         * destination buffer.
    623640                         */
    624                         memcpy(dst + offset, devcon->com_area + *bufpos, rd);
     641                        memcpy(dst + offset, devcon->comm_area + *bufpos, rd);
    625642                        offset += rd;
    626643                        *bufpos += rd;
    … …  
    633650                        int rc;
    634651
    635                         rc = read_block(devcon, *pos / block_size, block_size);
     652                        rc = read_blocks(devcon, *pos / block_size, 1);
    636653                        if (rc != EOK) {
    637                                 fibril_mutex_unlock(&devcon->com_area_lock);
     654                                fibril_mutex_unlock(&devcon->comm_area_lock);
    638655                                return rc;
    639656                        }
    … …  
    643660                }
    644661        }
    645         fibril_mutex_unlock(&devcon->com_area_lock);
     662        fibril_mutex_unlock(&devcon->comm_area_lock);
    646663       
    647664        return EOK;
    648665}
    649666
    650 /** Read block from block device.
     667/** Read blocks directly from device (bypass cache).
     668 *
     669 * @param dev_handle    Device handle of the block device.
     670 * @param ba            Address of first block.
     671 * @param cnt           Number of blocks.
     672 * @param src           Buffer for storing the data.
     673 *
     674 * @return              EOK on success or negative error code on failure.
     675 */
     676int block_read_direct(dev_handle_t dev_handle, bn_t ba, size_t cnt, void *buf)
     677{
     678        devcon_t *devcon;
     679        int rc;
     680
     681        devcon = devcon_search(dev_handle);
     682        assert(devcon);
     683       
     684        fibril_mutex_lock(&devcon->comm_area_lock);
     685
     686        rc = read_blocks(devcon, ba, cnt);
     687        if (rc == EOK)
     688                memcpy(buf, devcon->comm_area, devcon->pblock_size * cnt);
     689
     690        fibril_mutex_unlock(&devcon->comm_area_lock);
     691
     692        return rc;
     693}
     694
     695/** Write blocks directly to device (bypass cache).
     696 *
     697 * @param dev_handle    Device handle of the block device.
     698 * @param ba            Address of first block.
     699 * @param cnt           Number of blocks.
     700 * @param src           The data to be written.
     701 *
     702 * @return              EOK on success or negative error code on failure.
     703 */
     704int block_write_direct(dev_handle_t dev_handle, bn_t ba, size_t cnt,
     705    const void *data)
     706{
     707        devcon_t *devcon;
     708        int rc;
     709
     710        devcon = devcon_search(dev_handle);
     711        assert(devcon);
     712       
     713        fibril_mutex_lock(&devcon->comm_area_lock);
     714
     715        memcpy(devcon->comm_area, data, devcon->pblock_size * cnt);
     716        rc = read_blocks(devcon, ba, cnt);
     717
     718        fibril_mutex_unlock(&devcon->comm_area_lock);
     719
     720        return rc;
     721}
     722
     723/** Get device block size.
     724 *
     725 * @param dev_handle    Device handle of the block device.
     726 * @param bsize         Output block size.
     727 *
     728 * @return              EOK on success or negative error code on failure.
     729 */
     730int block_get_bsize(dev_handle_t dev_handle, size_t *bsize)
     731{
     732        devcon_t *devcon;
     733
     734        devcon = devcon_search(dev_handle);
     735        assert(devcon);
     736       
     737        return get_block_size(devcon->dev_phone, bsize);
     738}
     739
     740/** Read blocks from block device.
    651741 *
    652742 * @param devcon        Device connection.
    653  * @param boff          Block index.
    654  * @param block_size    Block size.
     743 * @param ba            Address of first block.
     744 * @param cnt           Number of blocks.
    655745 * @param src           Buffer for storing the data.
    656746 *
    657747 * @return              EOK on success or negative error code on failure.
    658748 */
    659 static int read_block(devcon_t *devcon, bn_t boff, size_t block_size)
    660 {
    661         ipcarg_t retval;
     749static int read_blocks(devcon_t *devcon, bn_t ba, size_t cnt)
     750{
    662751        int rc;
    663752
    664753        assert(devcon);
    665         rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK, boff, block_size,
    666             &retval);
    667         if ((rc != EOK) || (retval != EOK))
    668                 return (rc != EOK ? rc : (int) retval);
    669 
    670         return EOK;
     754        rc = async_req_3_0(devcon->dev_phone, BD_READ_BLOCKS, LOWER32(ba),
     755            UPPER32(ba), cnt);
     756        return rc;
    671757}
    672758
    … …  
    674760 *
    675761 * @param devcon        Device connection.
    676  * @param boff          Block index.
    677  * @param block_size    Block size.
     762 * @param ba            Address of first block.
     763 * @param cnt           Number of blocks.
    678764 * @param src           Buffer containing the data to write.
    679765 *
    680766 * @return              EOK on success or negative error code on failure.
    681767 */
    682 static int write_block(devcon_t *devcon, bn_t boff, size_t block_size)
    683 {
    684         ipcarg_t retval;
     768static int write_blocks(devcon_t *devcon, bn_t ba, size_t cnt)
     769{
    685770        int rc;
    686771
    687772        assert(devcon);
    688         rc = async_req_2_1(devcon->dev_phone, BD_WRITE_BLOCK, boff, block_size,
    689             &retval);
    690         if ((rc != EOK) || (retval != EOK))
    691                 return (rc != EOK ? rc : (int) retval);
    692 
    693         return EOK;
     773        rc = async_req_3_0(devcon->dev_phone, BD_WRITE_BLOCKS, LOWER32(ba),
     774            UPPER32(ba), cnt);
     775        return rc;
     776}
     777
     778/** Get block size used by the device. */
     779static int get_block_size(int dev_phone, size_t *bsize)
     780{
     781        ipcarg_t bs;
     782        int rc;
     783
     784        rc = async_req_0_1(dev_phone, BD_GET_BLOCK_SIZE, &bs);
     785        if (rc == EOK)
     786                *bsize = (size_t) bs;
     787
     788        return rc;
    694789}
    695790

  • uspace/lib/libblock/libblock.h

    r2f636b6 rf6b5593  
    6060#define BLOCK_FLAGS_NOREAD      1
    6161
    62 typedef unsigned bn_t;  /**< Block number type. */
     62typedef uint64_t bn_t;  /**< Block number type. */
    6363
    6464typedef struct block {
    … …  
    9898extern void block_fini(dev_handle_t);
    9999
    100 extern int block_bb_read(dev_handle_t, off_t, size_t);
     100extern int block_bb_read(dev_handle_t, bn_t);
    101101extern void *block_bb_get(dev_handle_t);
    102102
    … …  
    107107
    108108extern int block_seqread(dev_handle_t, off_t *, size_t *, off_t *, void *,
    109     size_t, size_t);
     109    size_t);
     110
     111extern int block_get_bsize(dev_handle_t, size_t *);
     112extern int block_read_direct(dev_handle_t, bn_t, size_t, void *);
     113extern int block_write_direct(dev_handle_t, bn_t, size_t, const void *);
    110114
    111115#endif

  • uspace/lib/libc/Makefile.toolchain

    r2f636b6 rf6b5593  
    6464#
    6565
     66ifeq ($(COMPILER),gcc_cross)
     67        CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc
     68        AS = $(TOOLCHAIN_DIR)/$(TARGET)-as
     69        LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld
     70        AR = $(TOOLCHAIN_DIR)/$(TARGET)-ar
     71        OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy
     72        OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
     73        DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
     74endif
     75
    6676ifeq ($(COMPILER),gcc_native)
    6777        CC = gcc
    … …  
    7484endif
    7585
    76 ifeq ($(COMPILER),icc_native)
     86ifeq ($(COMPILER),icc)
    7787        CC = icc
    7888        AS = as
    … …  
    8494endif
    8595
    86 ifeq ($(COMPILER),gcc_cross)
    87         CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc
    88         AS = $(TOOLCHAIN_DIR)/$(TARGET)-as
    89         LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld
    90         AR = $(TOOLCHAIN_DIR)/$(TARGET)-ar
    91         OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy
    92         OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump
     96ifeq ($(COMPILER),clang)
     97        CC = clang
     98        AS = $(BINUTILS_PREFIX)as
     99        LD = $(BINUTILS_PREFIX)ld
     100        AR = $(BINUTILS_PREFIX)ar
     101        OBJCOPY = $(BINUTILS_PREFIX)objcopy
     102        OBJDUMP = $(BINUTILS_PREFIX)objdump
    93103        DEPEND_DEFS = $(DEFS) $(CONFIG_DEFS)
    94104endif

  • uspace/lib/libc/arch/ia64/include/atomic.h

    r2f636b6 rf6b5593  
    2727 */
    2828
    29 /** @addtogroup libcia64       
     29/** @addtogroup libcia64
    3030 * @{
    3131 */
    … …  
    3636#define LIBC_ia64_ATOMIC_H_
    3737
    38 /** Atomic addition.
    39  *
    40  * @param val Atomic value.
    41  * @param imm Value to add.
    42  *
    43  * @return Value before addition.
    44  */
    45 static inline long atomic_add(atomic_t *val, int imm)
     38static inline void atomic_inc(atomic_t *val)
    4639{
    4740        long v;
     41       
     42        asm volatile (
     43                "fetchadd8.rel %[v] = %[count], 1\n"
     44                : [v] "=r" (v),
     45                  [count] "+m" (val->count)
     46        );
     47}
    4848
    49         asm volatile ("fetchadd8.rel %0 = %1, %2\n" : "=r" (v), "+m" (val->count) : "i" (imm));
    50  
     49static inline void atomic_dec(atomic_t *val)
     50{
     51        long v;
     52       
     53        asm volatile (
     54                "fetchadd8.rel %[v] = %[count], -1\n"
     55                : [v] "=r" (v),
     56                  [count] "+m" (val->count)
     57        );
     58}
     59
     60static inline long atomic_preinc(atomic_t *val)
     61{
     62        long v;
     63       
     64        asm volatile (
     65                "fetchadd8.rel %[v] = %[count], 1\n"
     66                : [v] "=r" (v),
     67                  [count] "+m" (val->count)
     68        );
     69       
     70        return (v + 1);
     71}
     72
     73static inline long atomic_predec(atomic_t *val)
     74{
     75        long v;
     76       
     77        asm volatile (
     78                "fetchadd8.rel %[v] = %[count], -1\n"
     79                : [v] "=r" (v),
     80                  [count] "+m" (val->count)
     81        );
     82       
     83        return (v - 1);
     84}
     85
     86static inline long atomic_postinc(atomic_t *val)
     87{
     88        long v;
     89       
     90        asm volatile (
     91                "fetchadd8.rel %[v] = %[count], 1\n"
     92                : [v] "=r" (v),
     93                  [count] "+m" (val->count)
     94        );
     95       
    5196        return v;
    5297}
    5398
    54 static inline void atomic_inc(atomic_t *val) { atomic_add(val, 1); }
    55 static inline void atomic_dec(atomic_t *val) { atomic_add(val, -1); }
    56 
    57 static inline long atomic_preinc(atomic_t *val) { return atomic_add(val, 1) + 1; }
    58 static inline long atomic_predec(atomic_t *val) { return atomic_add(val, -1) - 1; }
    59 
    60 static inline long atomic_postinc(atomic_t *val) { return atomic_add(val, 1); }
    61 static inline long atomic_postdec(atomic_t *val) { return atomic_add(val, -1); }
     99static inline long atomic_postdec(atomic_t *val)
     100{
     101        long v;
     102       
     103        asm volatile (
     104                "fetchadd8.rel %[v] = %[count], -1\n"
     105                : [v] "=r" (v),
     106                  [count] "+m" (val->count)
     107        );
     108       
     109        return v;
     110}
    62111
    63112#endif

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

    r2f636b6 rf6b5593  
    4545}
    4646
    47 int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols)
     47int console_get_size(int phone, int *cols, int *rows)
    4848{
    49         return async_req_0_2(phone, CONSOLE_GET_SIZE, rows, cols);
     49        ipcarg_t cols_v;
     50        ipcarg_t rows_v;
     51        int rc;
     52
     53        rc = async_req_0_2(phone, CONSOLE_GET_SIZE, &cols_v, &rows_v);
     54
     55        *cols = (int) cols_v;
     56        *rows = (int) rows_v;
     57        return rc;
    5058}
    5159
    … …  
    8694}
    8795
    88 void console_goto(int phone, ipcarg_t row, ipcarg_t col)
     96void console_goto(int phone, int col, int row)
    8997{
    90         async_msg_2(phone, CONSOLE_GOTO, row, col);
     98        async_msg_2(phone, CONSOLE_GOTO, col, row);
    9199}
    92100

  • uspace/lib/libc/include/io/console.h

    r2f636b6 rf6b5593  
    6868extern void console_clear(int phone);
    6969
    70 extern int console_get_size(int phone, ipcarg_t *rows, ipcarg_t *cols);
    71 extern void console_goto(int phone, ipcarg_t row, ipcarg_t col);
     70extern int console_get_size(int phone, int *cols, int *rows);
     71extern void console_goto(int phone, int col, int row);
    7272
    7373extern void console_set_style(int phone, int style);

  • uspace/lib/libc/include/ipc/bd.h

    r2f636b6 rf6b5593  
    3939
    4040typedef enum {
    41         BD_READ_BLOCK = IPC_FIRST_USER_METHOD,
    42         BD_WRITE_BLOCK
     41        BD_GET_BLOCK_SIZE = IPC_FIRST_USER_METHOD,
     42        BD_READ_BLOCKS,
     43        BD_WRITE_BLOCKS
    4344} bd_request_t;
    4445

  • uspace/srv/bd/ata_bd/ata_bd.c

    r2f636b6 rf6b5593  
    6262#include <bool.h>
    6363#include <task.h>
     64#include <macros.h>
    6465
    6566#include "ata_bd.h"
    … …  
    8687static int ata_bd_init(void);
    8788static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
    88 static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
     89static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt,
    8990    void *buf);
    90 static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
     91static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
     92    const void *buf);
     93static int ata_bd_read_block(int disk_id, uint64_t ba, size_t cnt,
    9194    void *buf);
    92 static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
     95static int ata_bd_write_block(int disk_id, uint64_t ba, size_t cnt,
    9396    const void *buf);
    9497static int disk_init(disk_t *d, int disk_id);
    9598static int drive_identify(int drive_id, void *buf);
    9699static void disk_print_summary(disk_t *d);
    97 static int coord_calc(disk_t *d, uint64_t blk_idx, block_coord_t *bc);
     100static int coord_calc(disk_t *d, uint64_t ba, block_coord_t *bc);
    98101static void coord_sc_program(const block_coord_t *bc, uint16_t scnt);
    99102static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
    … …  
    228231        int flags;
    229232        int retval;
    230         off_t idx;
    231         size_t size;
     233        uint64_t ba;
     234        size_t cnt;
    232235        int disk_id, i;
    233236
    … …  
    270273                        ipc_answer_0(callid, EOK);
    271274                        return;
    272                 case BD_READ_BLOCK:
    273                 case BD_WRITE_BLOCK:
    274                         idx = IPC_GET_ARG1(call);
    275                         size = IPC_GET_ARG2(call);
    276                         if (size > comm_size) {
    277                                 retval = EINVAL;
     275                case BD_READ_BLOCKS:
     276                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     277                            IPC_GET_ARG2(call));
     278                        cnt = IPC_GET_ARG3(call);
     279                        if (cnt * block_size > comm_size) {
     280                                retval = ELIMIT;
    278281                                break;
    279282                        }
    280                         retval = ata_bd_rdwr(disk_id, method, idx,
    281                             size, fs_va);
     283                        retval = ata_bd_read_blocks(disk_id, ba, cnt, fs_va);
    282284                        break;
     285                case BD_WRITE_BLOCKS:
     286                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     287                            IPC_GET_ARG2(call));
     288                        cnt = IPC_GET_ARG3(call);
     289                        if (cnt * block_size > comm_size) {
     290                                retval = ELIMIT;
     291                                break;
     292                        }
     293                        retval = ata_bd_write_blocks(disk_id, ba, cnt, fs_va);
     294                        break;
     295                case BD_GET_BLOCK_SIZE:
     296                        ipc_answer_1(callid, EOK, block_size);
     297                        continue;
    283298                default:
    284299                        retval = EINVAL;
    … …  
    373388}
    374389
    375 /** Transfer a logical block from/to the device.
    376  *
    377  * @param disk_id       Device index (0 or 1)
    378  * @param method        @c BD_READ_BLOCK or @c BD_WRITE_BLOCK
    379  * @param blk_idx       Index of the first block.
    380  * @param size          Size of the logical block.
    381  * @param buf           Data buffer.
    382  *
    383  * @return EOK on success, EIO on error.
    384  */
    385 static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
    386     void *buf)
    387 {
     390/** Read multiple blocks from the device. */
     391static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt,
     392    void *buf) {
     393
    388394        int rc;
    389         size_t now;
    390 
    391         while (size > 0) {
    392                 now = size < block_size ? size : block_size;
    393                 if (now != block_size)
    394                         return EINVAL;
    395 
    396                 if (method == BD_READ_BLOCK)
    397                         rc = ata_bd_read_block(disk_id, blk_idx, 1, buf);
    398                 else
    399                         rc = ata_bd_write_block(disk_id, blk_idx, 1, buf);
    400 
     395
     396        while (cnt > 0) {
     397                rc = ata_bd_read_block(disk_id, ba, 1, buf);
    401398                if (rc != EOK)
    402399                        return rc;
    403400
     401                ++ba;
     402                --cnt;
    404403                buf += block_size;
    405                 blk_idx++;
    406 
    407                 if (size > block_size)
    408                         size -= block_size;
    409                 else
    410                         size = 0;
     404        }
     405
     406        return EOK;
     407}
     408
     409/** Write multiple blocks to the device. */
     410static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt,
     411    const void *buf) {
     412
     413        int rc;
     414
     415        while (cnt > 0) {
     416                rc = ata_bd_write_block(disk_id, ba, 1, buf);
     417                if (rc != EOK)
     418                        return rc;
     419
     420                ++ba;
     421                --cnt;
     422                buf += block_size;
    411423        }
    412424
    … …  
    466478 *
    467479 * @param disk_id       Device index (0 or 1)
    468  * @param blk_idx       Index of the first block.
    469  * @param blk_cnt       Number of blocks to transfer.
     480 * @param ba            Address the first block.
     481 * @param cnt           Number of blocks to transfer.
    470482 * @param buf           Buffer for holding the data.
    471483 *
    472484 * @return EOK on success, EIO on error.
    473485 */
    474 static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
     486static int ata_bd_read_block(int disk_id, uint64_t ba, size_t blk_cnt,
    475487    void *buf)
    476488{
    … …  
    486498
    487499        /* Compute block coordinates. */
    488         if (coord_calc(d, blk_idx, &bc) != EOK)
     500        if (coord_calc(d, ba, &bc) != EOK)
    489501                return EINVAL;
    490502
    … …  
    541553 *
    542554 * @param disk_id       Device index (0 or 1)
    543  * @param blk_idx       Index of the first block.
    544  * @param blk_cnt       Number of blocks to transfer.
     555 * @param ba            Address of the first block.
     556 * @param cnt           Number of blocks to transfer.
    545557 * @param buf           Buffer holding the data to write.
    546558 *
    547559 * @return EOK on success, EIO on error.
    548560 */
    549 static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
     561static int ata_bd_write_block(int disk_id, uint64_t ba, size_t cnt,
    550562    const void *buf)
    551563{
    … …  
    560572
    561573        /* Compute block coordinates. */
    562         if (coord_calc(d, blk_idx, &bc) != EOK)
     574        if (coord_calc(d, ba, &bc) != EOK)
    563575                return EINVAL;
    564576
    … …  
    620632 * @return EOK on success or EINVAL if block index is past end of device.
    621633 */
    622 static int coord_calc(disk_t *d, uint64_t blk_idx, block_coord_t *bc)
     634static int coord_calc(disk_t *d, uint64_t ba, block_coord_t *bc)
    623635{
    624636        uint64_t c;
    … …  
    626638
    627639        /* Check device bounds. */
    628         if (blk_idx >= d->blocks)
     640        if (ba >= d->blocks)
    629641                return EINVAL;
    630642
    … …  
    634646        case am_chs:
    635647                /* Compute CHS coordinates. */
    636                 c = blk_idx / (d->geom.heads * d->geom.sectors);
    637                 idx = blk_idx % (d->geom.heads * d->geom.sectors);
     648                c = ba / (d->geom.heads * d->geom.sectors);
     649                idx = ba % (d->geom.heads * d->geom.sectors);
    638650
    639651                bc->cyl_lo = c & 0xff;
    … …  
    645657        case am_lba28:
    646658                /* Compute LBA-28 coordinates. */
    647                 bc->c0 = blk_idx & 0xff;                /* bits 0-7 */
    648                 bc->c1 = (blk_idx >> 8) & 0xff;         /* bits 8-15 */
    649                 bc->c2 = (blk_idx >> 16) & 0xff;        /* bits 16-23 */
    650                 bc->h  = (blk_idx >> 24) & 0x0f;        /* bits 24-27 */
     659                bc->c0 = ba & 0xff;             /* bits 0-7 */
     660                bc->c1 = (ba >> 8) & 0xff;      /* bits 8-15 */
     661                bc->c2 = (ba >> 16) & 0xff;     /* bits 16-23 */
     662                bc->h  = (ba >> 24) & 0x0f;     /* bits 24-27 */
    651663                break;
    652664
    653665        case am_lba48:
    654666                /* Compute LBA-48 coordinates. */
    655                 bc->c0 = blk_idx & 0xff;                /* bits 0-7 */
    656                 bc->c1 = (blk_idx >> 8) & 0xff;         /* bits 8-15 */
    657                 bc->c2 = (blk_idx >> 16) & 0xff;        /* bits 16-23 */
    658                 bc->c3 = (blk_idx >> 24) & 0xff;        /* bits 24-31 */
    659                 bc->c4 = (blk_idx >> 32) & 0xff;        /* bits 32-39 */
    660                 bc->c5 = (blk_idx >> 40) & 0xff;        /* bits 40-47 */
     667                bc->c0 = ba & 0xff;             /* bits 0-7 */
     668                bc->c1 = (ba >> 8) & 0xff;      /* bits 8-15 */
     669                bc->c2 = (ba >> 16) & 0xff;     /* bits 16-23 */
     670                bc->c3 = (ba >> 24) & 0xff;     /* bits 24-31 */
     671                bc->c4 = (ba >> 32) & 0xff;     /* bits 32-39 */
     672                bc->c5 = (ba >> 40) & 0xff;     /* bits 40-47 */
    661673                bc->h  = 0;
    662674                break;

  • uspace/srv/bd/file_bd/file_bd.c

    r2f636b6 rf6b5593  
    5151#include <bool.h>
    5252#include <task.h>
     53#include <macros.h>
    5354
    5455#define NAME "file_bd"
    5556
    56 static size_t comm_size;
     57static const size_t block_size = 512;
    5758static FILE *img;
    5859
    … …  
    6263static int file_bd_init(const char *fname);
    6364static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
    64 static int file_bd_read(off_t blk_idx, size_t size, void *buf);
    65 static int file_bd_write(off_t blk_idx, size_t size, void *buf);
     65static int file_bd_read_blocks(uint64_t ba, size_t cnt, void *buf);
     66static int file_bd_write_blocks(uint64_t ba, size_t cnt, const void *buf);
    6667
    6768int main(int argc, char **argv)
    … …  
    120121        ipc_call_t call;
    121122        ipcarg_t method;
     123        size_t comm_size;
    122124        int flags;
    123125        int retval;
    124         off_t idx;
    125         size_t size;
     126        uint64_t ba;
     127        size_t cnt;
    126128
    127129        /* Answer the IPC_M_CONNECT_ME_TO call. */
    … …  
    149151                        ipc_answer_0(callid, EOK);
    150152                        return;
    151                 case BD_READ_BLOCK:
    152                 case BD_WRITE_BLOCK:
    153                         idx = IPC_GET_ARG1(call);
    154                         size = IPC_GET_ARG2(call);
    155                         if (size > comm_size) {
    156                                 retval = EINVAL;
     153                case BD_READ_BLOCKS:
     154                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     155                            IPC_GET_ARG2(call));
     156                        cnt = IPC_GET_ARG3(call);
     157                        if (cnt * block_size > comm_size) {
     158                                retval = ELIMIT;
    157159                                break;
    158160                        }
    159                         if (method == BD_READ_BLOCK)
    160                                 retval = file_bd_read(idx, size, fs_va);
    161                         else
    162                                 retval = file_bd_write(idx, size, fs_va);
     161                        retval = file_bd_read_blocks(ba, cnt, fs_va);
    163162                        break;
     163                case BD_WRITE_BLOCKS:
     164                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     165                            IPC_GET_ARG2(call));
     166                        cnt = IPC_GET_ARG3(call);
     167                        if (cnt * block_size > comm_size) {
     168                                retval = ELIMIT;
     169                                break;
     170                        }
     171                        retval = file_bd_write_blocks(ba, cnt, fs_va);
     172                        break;
     173                case BD_GET_BLOCK_SIZE:
     174                        ipc_answer_1(callid, EOK, block_size);
     175                        continue;
    164176                default:
    165177                        retval = EINVAL;
    … …  
    170182}
    171183
    172 static int file_bd_read(off_t blk_idx, size_t size, void *buf)
     184/** Read blocks from the device. */
     185static int file_bd_read_blocks(uint64_t ba, size_t cnt, void *buf)
    173186{
    174187        size_t n_rd;
    … …  
    176189        fibril_mutex_lock(&dev_lock);
    177190
    178         fseek(img, blk_idx * size, SEEK_SET);
    179         n_rd = fread(buf, 1, size, img);
     191        fseek(img, ba * block_size, SEEK_SET);
     192        n_rd = fread(buf, block_size, cnt, img);
    180193
    181194        if (ferror(img)) {
    … …  
    186199        fibril_mutex_unlock(&dev_lock);
    187200
    188         if (n_rd < size)
    189                 return EINVAL;  /* Read beyond end of disk */
     201        if (n_rd < cnt)
     202                return EINVAL;  /* Read beyond end of device */
    190203
    191204        return EOK;
    192205}
    193206
    194 static int file_bd_write(off_t blk_idx, size_t size, void *buf)
     207/** Write blocks to the device. */
     208static int file_bd_write_blocks(uint64_t ba, size_t cnt, const void *buf)
    195209{
    196210        size_t n_wr;
    … …  
    198212        fibril_mutex_lock(&dev_lock);
    199213
    200         fseek(img, blk_idx * size, SEEK_SET);
    201         n_wr = fread(buf, 1, size, img);
    202 
    203         if (ferror(img) || n_wr < size) {
     214        fseek(img, ba * block_size, SEEK_SET);
     215        n_wr = fread(buf, block_size, cnt, img);
     216
     217        if (ferror(img) || n_wr < cnt) {
    204218                fibril_mutex_unlock(&dev_lock);
    205219                return EIO;     /* Write error */

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r2f636b6 rf6b5593  
    4747#include <sys/types.h>
    4848#include <errno.h>
     49#include <macros.h>
    4950#include <task.h>
    5051
    … …  
    9798static int gxe_bd_init(void);
    9899static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
    99 static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
     100static int gxe_bd_read_blocks(int disk_id, uint64_t ba, unsigned cnt,
    100101    void *buf);
    101 static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
    102     void *buf);
    103 static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
     102static int gxe_bd_write_blocks(int disk_id, uint64_t ba, unsigned cnt,
    104103    const void *buf);
     104static int gxe_bd_read_block(int disk_id, uint64_t ba, void *buf);
     105static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf);
    105106
    106107int main(int argc, char **argv)
    … …  
    163164        int flags;
    164165        int retval;
    165         off_t idx;
    166         size_t size;
     166        uint64_t ba;
     167        unsigned cnt;
    167168        int disk_id, i;
    168169
    … …  
    185186
    186187        if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
     188                ipc_answer_0(callid, EHANGUP);
     189                return;
     190        }
     191
     192        if (comm_size < block_size) {
    187193                ipc_answer_0(callid, EHANGUP);
    188194                return;
    … …  
    205211                        ipc_answer_0(callid, EOK);
    206212                        return;
    207                 case BD_READ_BLOCK:
    208                 case BD_WRITE_BLOCK:
    209                         idx = IPC_GET_ARG1(call);
    210                         size = IPC_GET_ARG2(call);
    211                         if (size > comm_size) {
    212                                 retval = EINVAL;
     213                case BD_READ_BLOCKS:
     214                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     215                            IPC_GET_ARG2(call));
     216                        cnt = IPC_GET_ARG3(call);
     217                        if (cnt * block_size > comm_size) {
     218                                retval = ELIMIT;
    213219                                break;
    214220                        }
    215                         retval = gx_bd_rdwr(disk_id, method, idx * size,
    216                             size, fs_va);
     221                        retval = gxe_bd_read_blocks(disk_id, ba, cnt, fs_va);
    217222                        break;
     223                case BD_WRITE_BLOCKS:
     224                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     225                            IPC_GET_ARG2(call));
     226                        cnt = IPC_GET_ARG3(call);
     227                        if (cnt * block_size > comm_size) {
     228                                retval = ELIMIT;
     229                                break;
     230                        }
     231                        retval = gxe_bd_write_blocks(disk_id, ba, cnt, fs_va);
     232                        break;
     233                case BD_GET_BLOCK_SIZE:
     234                        ipc_answer_1(callid, EOK, block_size);
     235                        continue;
    218236                default:
    219237                        retval = EINVAL;
    … …  
    224242}
    225243
    226 static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
    227     void *buf)
    228 {
     244/** Read multiple blocks from the device. */
     245static int gxe_bd_read_blocks(int disk_id, uint64_t ba, unsigned cnt,
     246    void *buf) {
     247
    229248        int rc;
    230         size_t now;
    231 
    232         while (size > 0) {
    233                 now = size < block_size ? size : block_size;
    234 
    235                 if (method == BD_READ_BLOCK)
    236                         rc = gxe_bd_read_block(disk_id, offset, now, buf);
    237                 else
    238                         rc = gxe_bd_write_block(disk_id, offset, now, buf);
    239 
     249
     250        while (cnt > 0) {
     251                rc = gxe_bd_read_block(disk_id, ba, buf);
    240252                if (rc != EOK)
    241253                        return rc;
    242254
     255                ++ba;
     256                --cnt;
    243257                buf += block_size;
    244                 offset += block_size;
    245 
    246                 if (size > block_size)
    247                         size -= block_size;
    248                 else
    249                         size = 0;
    250         }
    251 
    252         return EOK;
    253 }
    254 
    255 static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size,
    256     void *buf)
     258        }
     259
     260        return EOK;
     261}
     262
     263/** Write multiple blocks to the device. */
     264static int gxe_bd_write_blocks(int disk_id, uint64_t ba, unsigned cnt,
     265    const void *buf) {
     266
     267        int rc;
     268
     269        while (cnt > 0) {
     270                rc = gxe_bd_write_block(disk_id, ba, buf);
     271                if (rc != EOK)
     272                        return rc;
     273
     274                ++ba;
     275                --cnt;
     276                buf += block_size;
     277        }
     278
     279        return EOK;
     280}
     281
     282/** Read a block from the device. */
     283static int gxe_bd_read_block(int disk_id, uint64_t ba, void *buf)
    257284{
    258285        uint32_t status;
     286        uint64_t byte_addr;
    259287        size_t i;
    260288        uint32_t w;
    261289
     290        byte_addr = ba * block_size;
     291
    262292        fibril_mutex_lock(&dev_lock[disk_id]);
    263         pio_write_32(&dev->offset_lo, (uint32_t) offset);
    264         pio_write_32(&dev->offset_hi, offset >> 32);
     293        pio_write_32(&dev->offset_lo, (uint32_t) byte_addr);
     294        pio_write_32(&dev->offset_hi, byte_addr >> 32);
    265295        pio_write_32(&dev->disk_id, disk_id);
    266296        pio_write_32(&dev->control, CTL_READ_START);
    … …  
    272302        }
    273303
    274         for (i = 0; i < size; i++) {
     304        for (i = 0; i < block_size; i++) {
    275305                ((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]);
    276306        }
    … …  
    280310}
    281311
    282 static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size,
    283     const void *buf)
     312/** Write a block to the device. */
     313static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf)
    284314{
    285315        uint32_t status;
     316        uint64_t byte_addr;
    286317        size_t i;
    287318
    288         for (i = 0; i < size; i++) {
     319        byte_addr = ba * block_size;
     320
     321        fibril_mutex_lock(&dev_lock[disk_id]);
     322
     323        for (i = 0; i < block_size; i++) {
    289324                pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]);
    290325        }
    291326
    292         fibril_mutex_lock(&dev_lock[disk_id]);
    293         pio_write_32(&dev->offset_lo, (uint32_t) offset);
    294         pio_write_32(&dev->offset_hi, offset >> 32);
     327        pio_write_32(&dev->offset_lo, (uint32_t) byte_addr);
     328        pio_write_32(&dev->offset_hi, byte_addr >> 32);
    295329        pio_write_32(&dev->disk_id, disk_id);
    296330        pio_write_32(&dev->control, CTL_WRITE_START);

  • uspace/srv/bd/rd/rd.c

    r2f636b6 rf6b5593  
    5555#include <devmap.h>
    5656#include <ipc/bd.h>
     57#include <macros.h>
    5758
    5859#define NAME "rd"
    5960
    60 /** Pointer to the ramdisk's image. */
     61/** Pointer to the ramdisk's image */
    6162static void *rd_addr;
    62 /** Size of the ramdisk. */
     63/** Size of the ramdisk */
    6364static size_t rd_size;
     65
     66/** Block size */
     67static const size_t block_size = 512;
     68
     69static int rd_read_blocks(uint64_t ba, size_t cnt, void *buf);
     70static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf);
    6471
    6572/**
    … …  
    8289        int retval;
    8390        void *fs_va = NULL;
    84         off_t offset;
    85         size_t block_size;
    86         size_t maxblock_size;
     91        uint64_t ba;
     92        size_t cnt;
     93        size_t comm_size;
    8794
    8895        /*
    … …  
    95102         */
    96103        int flags;
    97         if (ipc_share_out_receive(&callid, &maxblock_size, &flags)) {
    98                 fs_va = as_get_mappable_page(maxblock_size);
     104        if (ipc_share_out_receive(&callid, &comm_size, &flags)) {
     105                fs_va = as_get_mappable_page(comm_size);
    99106                if (fs_va) {
    100107                        (void) ipc_share_out_finalize(callid, fs_va);
    … …  
    123130                        ipc_answer_0(callid, EOK);
    124131                        return;
    125                 case BD_READ_BLOCK:
    126                         offset = IPC_GET_ARG1(call);
    127                         block_size = IPC_GET_ARG2(call);
    128                         if (block_size > maxblock_size) {
    129                                 /*
    130                                  * Maximum block size exceeded.
    131                                  */
     132                case BD_READ_BLOCKS:
     133                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     134                            IPC_GET_ARG2(call));
     135                        cnt = IPC_GET_ARG3(call);
     136                        if (cnt * block_size > comm_size) {
    132137                                retval = ELIMIT;
    133138                                break;
    134139                        }
    135                         if (offset * block_size > rd_size - block_size) {
    136                                 /*
    137                                  * Reading past the end of the device.
    138                                  */
     140                        retval = rd_read_blocks(ba, cnt, fs_va);
     141                        break;
     142                case BD_WRITE_BLOCKS:
     143                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
     144                            IPC_GET_ARG2(call));
     145                        cnt = IPC_GET_ARG3(call);
     146                        if (cnt * block_size > comm_size) {
    139147                                retval = ELIMIT;
    140148                                break;
    141149                        }
    142                         fibril_rwlock_read_lock(&rd_lock);
    143                         memcpy(fs_va, rd_addr + offset * block_size, block_size);
    144                         fibril_rwlock_read_unlock(&rd_lock);
    145                         retval = EOK;
     150                        retval = rd_write_blocks(ba, cnt, fs_va);
    146151                        break;
    147                 case BD_WRITE_BLOCK:
    148                         offset = IPC_GET_ARG1(call);
    149                         block_size = IPC_GET_ARG2(call);
    150                         if (block_size > maxblock_size) {
    151                                 /*
    152                                  * Maximum block size exceeded.
    153                                  */
    154                                 retval = ELIMIT;
    155                                 break;
    156                         }
    157                         if (offset * block_size > rd_size - block_size) {
    158                                 /*
    159                                  * Writing past the end of the device.
    160                                  */
    161                                 retval = ELIMIT;
    162                                 break;
    163                         }
    164                         fibril_rwlock_write_lock(&rd_lock);
    165                         memcpy(rd_addr + offset * block_size, fs_va, block_size);
    166                         fibril_rwlock_write_unlock(&rd_lock);
    167                         retval = EOK;
    168                         break;
     152                case BD_GET_BLOCK_SIZE:
     153                        ipc_answer_1(callid, EOK, block_size);
     154                        continue;
    169155                default:
    170156                        /*
    … …  
    181167}
    182168
     169/** Read blocks from the device. */
     170static int rd_read_blocks(uint64_t ba, size_t cnt, void *buf)
     171{
     172        if ((ba + cnt) * block_size > rd_size) {
     173                /* Reading past the end of the device. */
     174                return ELIMIT;
     175        }
     176
     177        fibril_rwlock_read_lock(&rd_lock);
     178        memcpy(buf, rd_addr + ba * block_size, block_size * cnt);
     179        fibril_rwlock_read_unlock(&rd_lock);
     180
     181        return EOK;
     182}
     183
     184/** Write blocks to the device. */
     185static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf)
     186{
     187        if ((ba + cnt) * block_size > rd_size) {
     188                /* Writing past the end of the device. */
     189                return ELIMIT;
     190        }
     191
     192        fibril_rwlock_write_lock(&rd_lock);
     193        memcpy(rd_addr + ba * block_size, buf, block_size * cnt);
     194        fibril_rwlock_write_unlock(&rd_lock);
     195
     196        return EOK;
     197}
     198
    183199/** Prepare the ramdisk image for operation. */
    184200static bool rd_init(void)

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

    r2f636b6 rf6b5593  
    833833
    834834        /* prepare the boot block */
    835         rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
     835        rc = block_bb_read(dev_handle, BS_BLOCK);
    836836        if (rc != EOK) {
    837837                block_fini(dev_handle);

  • uspace/srv/fs/tmpfs/tmpfs_dump.c

    r2f636b6 rf6b5593  
    4747#include <byteorder.h>
    4848
    49 #define TMPFS_BLOCK_SIZE        1024
     49#define TMPFS_COMM_SIZE         1024
    5050
    5151struct rdentry {
    … …  
    6969               
    7070                if (block_seqread(dev, bufpos, buflen, pos, &entry,
    71                     sizeof(entry), TMPFS_BLOCK_SIZE) != EOK)
     71                    sizeof(entry)) != EOK)
    7272                        return false;
    7373               
    … …  
    8989                       
    9090                        if (block_seqread(dev, bufpos, buflen, pos, fname,
    91                             entry.len, TMPFS_BLOCK_SIZE) != EOK) {
     91                            entry.len) != EOK) {
    9292                                ops->destroy(fn);
    9393                                free(fname);
    … …  
    105105                       
    106106                        if (block_seqread(dev, bufpos, buflen, pos, &size,
    107                             sizeof(size), TMPFS_BLOCK_SIZE) != EOK)
     107                            sizeof(size)) != EOK)
    108108                                return false;
    109109                       
    … …  
    117117                        nodep->size = size;
    118118                        if (block_seqread(dev, bufpos, buflen, pos, nodep->data,
    119                             size, TMPFS_BLOCK_SIZE) != EOK)
     119                            size) != EOK)
    120120                                return false;
    121121                       
    … …  
    133133                       
    134134                        if (block_seqread(dev, bufpos, buflen, pos, fname,
    135                             entry.len, TMPFS_BLOCK_SIZE) != EOK) {
     135                            entry.len) != EOK) {
    136136                                ops->destroy(fn);
    137137                                free(fname);
    … …  
    166166        int rc;
    167167
    168         rc = block_init(dev, TMPFS_BLOCK_SIZE);
     168        rc = block_init(dev, TMPFS_COMM_SIZE);
    169169        if (rc != EOK)
    170170                return false;
    … …  
    175175       
    176176        char tag[6];
    177         if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5,
    178             TMPFS_BLOCK_SIZE) != EOK)
     177        if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5) != EOK)
    179178                goto error;
    180179       

  • uspace/srv/vfs/vfs_ops.c

    r2f636b6 rf6b5593  
    934934{
    935935        int fd = IPC_GET_ARG1(*request);
    936         size_t size = IPC_GET_ARG2(*request);
    937936        ipcarg_t rc;
    938937
Note: See TracChangeset for help on using the changeset viewer.