Changeset ad4b32c in mainline


Ignore:
Timestamp:
2009-09-04T21:50:59Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
309ede1
Parents:
7e266ff (diff), 40240b1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Files:
2 added
20 edited

Legend:

Unmodified
Added
Removed

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

    r7e266ff rad4b32c  
    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/ia64/include/asm.h

    r7e266ff rad4b32c  
    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                :: [mask] "i" (PSR_PK_MASK)
     425        );
    352426}
    353427

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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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/mm/as.c

    r7e266ff rad4b32c  
    5555void as_install_arch(as_t *as)
    5656{
    57         region_register rr;
     57        region_register_t rr;
    5858        int i;
    5959       

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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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

    r7e266ff rad4b32c  
    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;;
     186        movl r20 = (VRN_KERNEL << VRN_SHIFT) ;;
     187        or r20 = r20, r1 ;;
    182188        movl r1 = _hardcoded_load_address
    183189       
    … …  
    192198(p3)    addl r19 = @gprel(hardcoded_load_address), gp
    193199(p3)    addl r21 = @gprel(bootinfo), gp
    194         ;;
     200                ;;
    195201(p3)    st8 [r17] = r14
    196202(p3)    st8 [r18] = r15
    197203(p3)    st8 [r19] = r16
    198204(p3)    st8 [r21] = r20
    199 
     205       
    200206        ssm (1 << 19) ;; /* Disable f32 - f127 */
    201207        srlz.i
    202208        srlz.d ;;
    203 
     209       
    204210#ifdef CONFIG_SMP
    205211(p2)    movl r18 = main_ap ;;
    206 (p2)    mov b1 = r18 ;;
     212(p2)    mov b1 = r18 ;;
    207213(p2)    br.call.sptk.many b0 = b1
    208 
     214       
    209215        # Mark that BSP is on
     216       
    210217        mov r20 = 1 ;;
    211218        movl r21 = bsp_started ;;
    212219        st8 [r21] = r20 ;;
    213220#endif
    214 
     221       
    215222        br.call.sptk.many b0 = arch_pre_main
    216 
     223       
    217224        movl r18 = main_bsp ;;
    218225        mov b1 = r18 ;;
    … …  
    227234kernel_image_ap_start:
    228235        .auto
    229 
     236       
    230237        # Identify self(CPU) in OS structures by ID / EID
    231 
     238       
    232239        mov r9 = cr64
    233240        mov r10 = 1
    … …  
    240247       
    241248        # Wait for wakeup synchro signal (#3 in cpu_by_id_eid_list)
    242        
     249
    243250kernel_image_ap_start_loop:
    244251        movl r11 = kernel_image_ap_start_loop
    245252        and r11 = r11, r12
    246         mov b1 = r11
    247 
    248         ld1 r20 = [r8] ;;
    249         movl r21 = 3 ;;
    250         cmp.eq p2, p3 = r20, r21 ;;
     253        mov b1 = r11
     254       
     255        ld1 r20 = [r8]
     256        movl r21 = 3
     257        cmp.eq p2, p3 = r20, r21
    251258(p3)    br.call.sptk.many b0 = b1
    252 
     259       
    253260        movl r11 = kernel_image_start
    254261        and r11 = r11, r12
    255         mov b1 = r11 
     262        mov b1 = r11
    256263        br.call.sptk.many b0 = b1
    257264
    … …  
    259266.global bsp_started
    260267bsp_started:
    261 .space 8
     268        .space 8
    262269
    263270.align 4096
    264271.global cpu_by_id_eid_list
    265272cpu_by_id_eid_list:
    266 .space 65536
    267 
    268 #endif  /* CONFIG_SMP */
     273        .space 65536
     274
     275#endif  /* CONFIG_SMP */

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

    r7e266ff rad4b32c  
    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;

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

    r7e266ff rad4b32c  
    112112        while (size > 0) {
    113113                rc = block_get(&block, handle, boff, 0);
    114                 assert(rc == EOK);
     114                if (rc != EOK) {
     115                        printf("Error: could not get block %u, device %u.\n",
     116                            boff, handle);
     117                        return CMD_FAILURE;
     118                }
    115119                blk = (uint8_t *) block->data;
    116120
    … …  
    142146
    143147                rc = block_put(block);
    144                 assert(rc == EOK);
     148                if (rc != EOK) {
     149                        printf("Error: could not put block %p.\n",
     150                            block);
     151                        return CMD_FAILURE;
     152                }
    145153
    146154                if (size > rows * BPR)

  • uspace/lib/libblock/libblock.c

    r7e266ff rad4b32c  
    345345        link_t *l;
    346346        unsigned long key = boff;
    347         int rc = EOK;
     347        int rc;
    348348       
    349349        devcon = devcon_search(dev_handle);
    … …  
    355355
    356356retry:
     357        rc = EOK;
     358        b = NULL;
     359
    357360        fibril_mutex_lock(&cache->lock);
    358361        l = hash_table_find(&cache->block_hash, &key);
    … …  
    394397                        unsigned long temp_key;
    395398recycle:
    396                         assert(!list_empty(&cache->free_head));
     399                        if (list_empty(&cache->free_head)) {
     400                                fibril_mutex_unlock(&cache->lock);
     401                                rc = ENOMEM;
     402                                goto out;
     403                        }
    397404                        l = cache->free_head.next;
    398405                        b = list_get_instance(l, block_t, free_link);
    … …  
    477484
    478485                fibril_mutex_unlock(&b->lock);
     486        }
     487out:
     488        if ((rc != EOK) && b) {
     489                assert(b->toxic);
     490                (void) block_put(b);
     491                b = NULL;
    479492        }
    480493        *block = b;

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

    r7e266ff rad4b32c  
    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/srv/fs/fat/fat_fat.c

    r7e266ff rad4b32c  
    6161 * @param dev_handle    Device handle of the device with the file.
    6262 * @param firstc        First cluster to start the walk with.
    63  * @param lastc         If non-NULL, output argument hodling the last cluster number visited.
     63 * @param lastc         If non-NULL, output argument hodling the last cluster
     64 *                      number visited.
     65 * @param numc          If non-NULL, output argument holding the number of
     66 *                      clusters seen during the walk.
    6467 * @param max_clusters  Maximum number of clusters to visit.   
    6568 *
    66  * @return              Number of clusters seen during the walk.
    67  */
    68 uint16_t
     69 * @return              EOK on success or a negative error code.
     70 */
     71int
    6972fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
    70     fat_cluster_t *lastc, uint16_t max_clusters)
     73    fat_cluster_t *lastc, uint16_t *numc, uint16_t max_clusters)
    7174{
    7275        block_t *b;
    … …  
    8487                if (lastc)
    8588                        *lastc = firstc;
    86                 return 0;
     89                if (numc)
     90                        *numc = 0;
     91                return EOK;
    8792        }
    8893
    … …  
    98103                /* read FAT1 */
    99104                rc = block_get(&b, dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
    100                 assert(rc == EOK);
     105                if (rc != EOK)
     106                        return rc;
    101107                clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
    102108                assert(clst != FAT_CLST_BAD);
    103109                rc = block_put(b);
    104                 assert(rc == EOK);
     110                if (rc != EOK)
     111                        return rc;
    105112                clusters++;
    106113        }
    … …  
    108115        if (lastc && clst < FAT_CLST_LAST1)
    109116                *lastc = clst;
    110 
    111         return clusters;
     117        if (numc)
     118                *numc = clusters;
     119
     120        return EOK;
    112121}
    113122
    114123/** Read block from file located on a FAT file system.
    115124 *
     125 * @param block         Pointer to a block pointer for storing result.
    116126 * @param bs            Buffer holding the boot sector of the file system.
    117127 * @param dev_handle    Device handle of the file system.
    … …  
    121131 * @param flags         Flags passed to libblock.
    122132 *
    123  * @return              Block structure holding the requested block.
    124  */
    125 block_t *
    126 _fat_block_get(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
    127     bn_t bn, int flags)
    128 {
    129         block_t *b;
     133 * @return              EOK on success or a negative error code.
     134 */
     135int
     136_fat_block_get(block_t **block, fat_bs_t *bs, dev_handle_t dev_handle,
     137    fat_cluster_t firstc, bn_t bn, int flags)
     138{
    130139        unsigned bps;
    131140        unsigned rscnt;         /* block address of the first FAT */
    … …  
    134143        unsigned sf;
    135144        unsigned ssa;           /* size of the system area */
    136         unsigned clusters, max_clusters;
     145        uint16_t clusters;
     146        unsigned max_clusters;
    137147        fat_cluster_t lastc;
    138148        int rc;
    … …  
    150160                /* root directory special case */
    151161                assert(bn < rds);
    152                 rc = block_get(&b, dev_handle, rscnt + bs->fatcnt * sf + bn,
     162                rc = block_get(block, dev_handle, rscnt + bs->fatcnt * sf + bn,
    153163                    flags);
    154                 assert(rc == EOK);
    155                 return b;
     164                return rc;
    156165        }
    157166
    158167        max_clusters = bn / bs->spc;
    159         clusters = fat_cluster_walk(bs, dev_handle, firstc, &lastc,
     168        rc = fat_cluster_walk(bs, dev_handle, firstc, &lastc, &clusters,
    160169            max_clusters);
     170        if (rc != EOK)
     171                return rc;
    161172        assert(clusters == max_clusters);
    162173
    163         rc = block_get(&b, dev_handle, ssa +
    164             (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
    165         assert(rc == EOK);
    166 
    167         return b;
     174        rc = block_get(block, dev_handle,
     175            ssa + (lastc - FAT_CLST_FIRST) * bs->spc + bn % bs->spc, flags);
     176
     177        return rc;
    168178}
    169179
    … …  
    177187 *                      this argument is ignored.
    178188 * @param pos           Position in the last node block.
    179  */
    180 void fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
     189 *
     190 * @return              EOK on success or a negative error code.
     191 */
     192int fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
    181193{
    182194        uint16_t bps;
    … …  
    196208                int flags = (o % bps == 0) ?
    197209                    BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
    198                 b = fat_block_get(bs, nodep, o / bps, flags);
     210                rc = fat_block_get(&b, bs, nodep, o / bps, flags);
     211                if (rc != EOK)
     212                        return rc;
    199213                memset(b->data + o % bps, 0, bps - o % bps);
    200214                b->dirty = true;                /* need to sync node */
    201215                rc = block_put(b);
    202                 assert(rc == EOK);
     216                if (rc != EOK)
     217                        return rc;
    203218        }
    204219       
    205220        if (o >= pos)
    206                 return;
     221                return EOK;
    207222       
    208223        /* zero out the initial part of the new cluster chain */
    209224        for (o = boundary; o < pos; o += bps) {
    210                 b = _fat_block_get(bs, nodep->idx->dev_handle, mcl,
     225                rc = _fat_block_get(&b, bs, nodep->idx->dev_handle, mcl,
    211226                    (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
     227                if (rc != EOK)
     228                        return rc;
    212229                memset(b->data, 0, min(bps, pos - o));
    213230                b->dirty = true;                /* need to sync node */
    214231                rc = block_put(b);
    215                 assert(rc == EOK);
    216         }
     232                if (rc != EOK)
     233                        return rc;
     234        }
     235
     236        return EOK;
    217237}
    218238
    … …  
    222242 * @param dev_handle    Device handle for the file system.
    223243 * @param clst          Cluster which to get.
    224  *
    225  * @return              Value found in the cluster.
    226  */
    227 fat_cluster_t
    228 fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t clst)
     244 * @param value         Output argument holding the value of the cluster.
     245 *
     246 * @return              EOK or a negative error code.
     247 */
     248int
     249fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t clst,
     250    fat_cluster_t *value)
    229251{
    230252        block_t *b;
    231253        uint16_t bps;
    232254        uint16_t rscnt;
    233         fat_cluster_t *cp, value;
     255        fat_cluster_t *cp;
    234256        int rc;
    235257
    … …  
    239261        rc = block_get(&b, dev_handle, rscnt +
    240262            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
    241         assert(rc == EOK);
     263        if (rc != EOK)
     264                return rc;
    242265        cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
    243         value = uint16_t_le2host(*cp);
     266        *value = uint16_t_le2host(*cp);
    244267        rc = block_put(b);
    245         assert(rc == EOK);
    246        
    247         return value;
     268       
     269        return rc;
    248270}
    249271
    … …  
    255277 * @param clst          Cluster which is to be set.
    256278 * @param value         Value to set the cluster with.
    257  */
    258 void
     279 *
     280 * @return              EOK on success or a negative error code.
     281 */
     282int
    259283fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
    260284    fat_cluster_t clst, fat_cluster_t value)
    … …  
    274298        rc = block_get(&b, dev_handle, rscnt + sf * fatno +
    275299            (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
    276         assert(rc == EOK);
     300        if (rc != EOK)
     301                return rc;
    277302        cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
    278303        *cp = host2uint16_t_le(value);
    279304        b->dirty = true;                /* need to sync block */
    280305        rc = block_put(b);
    281         assert(rc == EOK);
     306        return rc;
    282307}
    283308
    … …  
    288313 * @param lifo          Chain of allocated clusters.
    289314 * @param nclsts        Number of clusters in the lifo chain.
    290  */
    291 void fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
     315 *
     316 * @return              EOK on success or a negative error code.
     317 */
     318int fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
    292319    fat_cluster_t *lifo, unsigned nclsts)
    293320{
    294321        uint8_t fatno;
    295322        unsigned c;
     323        int rc;
    296324
    297325        for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
    298326                for (c = 0; c < nclsts; c++) {
    299                         fat_set_cluster(bs, dev_handle, fatno, lifo[c],
     327                        rc = fat_set_cluster(bs, dev_handle, fatno, lifo[c],
    300328                            c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
     329                        if (rc != EOK)
     330                                return rc;
    301331                }
    302332        }
     333
     334        return EOK;
    303335}
    304336
    … …  
    347379        for (b = 0, cl = 0; b < sf; b++) {
    348380                rc = block_get(&blk, dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
     381                if (rc != EOK)
     382                        goto error;
    349383                for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
    350384                        fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
    … …  
    362396                                        /* we are almost done */
    363397                                        rc = block_put(blk);
    364                                         assert(rc == EOK);
     398                                        if (rc != EOK)
     399                                                goto error;
    365400                                        /* update the shadow copies of FAT */
    366                                         fat_alloc_shadow_clusters(bs,
     401                                        rc = fat_alloc_shadow_clusters(bs,
    367402                                            dev_handle, lifo, nclsts);
     403                                        if (rc != EOK)
     404                                                goto error;
    368405                                        *mcl = lifo[found - 1];
    369406                                        *lcl = lifo[0];
    … …  
    375412                }
    376413                rc = block_put(blk);
    377                 assert(rc == EOK);
     414                if (rc != EOK) {
     415error:
     416                        fibril_mutex_unlock(&fat_alloc_lock);
     417                        free(lifo);
     418                        return rc;
     419                }
    378420        }
    379421        fibril_mutex_unlock(&fat_alloc_lock);
    … …  
    384426         */
    385427        while (found--) {
    386                 fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
     428                rc = fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
    387429                    FAT_CLST_RES0);
     430                if (rc != EOK) {
     431                        free(lifo);
     432                        return rc;
     433                }
    388434        }
    389435       
    … …  
    397443 * @param dev_handle    Device handle of the file system.
    398444 * @param firstc        First cluster in the chain which is to be freed.
    399  */
    400 void
     445 *
     446 * @return              EOK on success or a negative return code.
     447 */
     448int
    401449fat_free_clusters(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc)
    402450{
    403451        unsigned fatno;
    404452        fat_cluster_t nextc;
     453        int rc;
    405454
    406455        /* Mark all clusters in the chain as free in all copies of FAT. */
    407456        while (firstc < FAT_CLST_LAST1) {
    408457                assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
    409                 nextc = fat_get_cluster(bs, dev_handle, firstc);
    410                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
    411                         fat_set_cluster(bs, dev_handle, fatno, firstc,
     458                rc = fat_get_cluster(bs, dev_handle, firstc, &nextc);
     459                if (rc != EOK)
     460                        return rc;
     461                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
     462                        rc = fat_set_cluster(bs, dev_handle, fatno, firstc,
    412463                            FAT_CLST_RES0);
     464                        if (rc != EOK)
     465                                return rc;
     466                }
     467
    413468                firstc = nextc;
    414469        }
     470
     471        return EOK;
    415472}
    416473
    … …  
    420477 * @param nodep         Node representing the file.
    421478 * @param mcl           First cluster of the cluster chain to append.
    422  */
    423 void fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
     479 *
     480 * @return              EOK on success or a negative error code.
     481 */
     482int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
    424483{
    425484        dev_handle_t dev_handle = nodep->idx->dev_handle;
    426485        fat_cluster_t lcl;
     486        uint16_t numc;
    427487        uint8_t fatno;
    428 
    429         if (fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl,
    430             (uint16_t) -1) == 0) {
     488        int rc;
     489
     490        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl, &numc,
     491            (uint16_t) -1);
     492        if (rc != EOK)
     493                return rc;
     494
     495        if (numc == 0) {
    431496                /* No clusters allocated to the node yet. */
    432497                nodep->firstc = mcl;
    433498                nodep->dirty = true;            /* need to sync node */
    434                 return;
    435         }
    436 
    437         for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
    438                 fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl, mcl);
     499                return EOK;
     500        }
     501
     502        for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
     503                rc = fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl,
     504                    mcl);
     505                if (rc != EOK)
     506                        return rc;
     507        }
     508
     509        return EOK;
    439510}
    440511
    … …  
    446517 *                      argument is FAT_CLST_RES0, then all clusters will
    447518 *                      be chopped off.
    448  */
    449 void fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
    450 {
     519 *
     520 * @return              EOK on success or a negative return code.
     521 */
     522int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
     523{
     524        int rc;
     525
    451526        dev_handle_t dev_handle = nodep->idx->dev_handle;
    452527        if (lastc == FAT_CLST_RES0) {
    453528                /* The node will have zero size and no clusters allocated. */
    454                 fat_free_clusters(bs, dev_handle, nodep->firstc);
     529                rc = fat_free_clusters(bs, dev_handle, nodep->firstc);
     530                if (rc != EOK)
     531                        return rc;
    455532                nodep->firstc = FAT_CLST_RES0;
    456533                nodep->dirty = true;            /* need to sync node */
    … …  
    459536                unsigned fatno;
    460537
    461                 nextc = fat_get_cluster(bs, dev_handle, lastc);
     538                rc = fat_get_cluster(bs, dev_handle, lastc, &nextc);
     539                if (rc != EOK)
     540                        return rc;
    462541
    463542                /* Terminate the cluster chain in all copies of FAT. */
    464                 for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
    465                         fat_set_cluster(bs, dev_handle, fatno, lastc, FAT_CLST_LAST1);
     543                for (fatno = FAT1; fatno < bs->fatcnt; fatno++) {
     544                        rc = fat_set_cluster(bs, dev_handle, fatno, lastc,
     545                            FAT_CLST_LAST1);
     546                        if (rc != EOK)
     547                                return rc;
     548                }
    466549
    467550                /* Free all following clusters. */
    468                 fat_free_clusters(bs, dev_handle, nextc);
    469         }
    470 }
    471 
    472 void
     551                rc = fat_free_clusters(bs, dev_handle, nextc);
     552                if (rc != EOK)
     553                        return rc;
     554        }
     555
     556        return EOK;
     557}
     558
     559int
    473560fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c)
    474561{
    … …  
    481568       
    482569        for (i = 0; i < bs->spc; i++) {
    483                 b = _fat_block_get(bs, dev_handle, c, i, BLOCK_FLAGS_NOREAD);
     570                rc = _fat_block_get(&b, bs, dev_handle, c, i,
     571                    BLOCK_FLAGS_NOREAD);
     572                if (rc != EOK)
     573                        return rc;
    484574                memset(b->data, 0, bps);
    485575                b->dirty = true;
    486576                rc = block_put(b);
    487                 assert(rc == EOK);
    488         }
     577                if (rc != EOK)
     578                        return rc;
     579        }
     580
     581        return EOK;
    489582}
    490583

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

    r7e266ff rad4b32c  
    5959typedef uint16_t fat_cluster_t;
    6060
    61 #define fat_clusters_get(bs, dh, fc) \
    62     fat_cluster_walk((bs), (dh), (fc), NULL, (uint16_t) -1)
    63 extern uint16_t fat_cluster_walk(struct fat_bs *, dev_handle_t, fat_cluster_t,
    64     fat_cluster_t *, uint16_t);
     61#define fat_clusters_get(numc, bs, dh, fc) \
     62    fat_cluster_walk((bs), (dh), (fc), NULL, (numc), (uint16_t) -1)
     63extern int fat_cluster_walk(struct fat_bs *, dev_handle_t, fat_cluster_t,
     64    fat_cluster_t *, uint16_t *, uint16_t);
    6565
    66 #define fat_block_get(bs, np, bn, flags) \
    67     _fat_block_get((bs), (np)->idx->dev_handle, (np)->firstc, (bn), (flags))
     66#define fat_block_get(b, bs, np, bn, flags) \
     67    _fat_block_get((b), (bs), (np)->idx->dev_handle, (np)->firstc, (bn), \
     68    (flags))
    6869
    69 extern struct block *_fat_block_get(struct fat_bs *, dev_handle_t,
     70extern int _fat_block_get(block_t **, struct fat_bs *, dev_handle_t,
    7071    fat_cluster_t, bn_t, int);
    7172 
    72 extern void fat_append_clusters(struct fat_bs *, struct fat_node *,
     73extern int fat_append_clusters(struct fat_bs *, struct fat_node *,
    7374    fat_cluster_t);
    74 extern void fat_chop_clusters(struct fat_bs *, struct fat_node *,
     75extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
    7576    fat_cluster_t);
    7677extern int fat_alloc_clusters(struct fat_bs *, dev_handle_t, unsigned,
    7778    fat_cluster_t *, fat_cluster_t *);
    78 extern void fat_free_clusters(struct fat_bs *, dev_handle_t, fat_cluster_t);
    79 extern void fat_alloc_shadow_clusters(struct fat_bs *, dev_handle_t,
     79extern int fat_free_clusters(struct fat_bs *, dev_handle_t, fat_cluster_t);
     80extern int fat_alloc_shadow_clusters(struct fat_bs *, dev_handle_t,
    8081    fat_cluster_t *, unsigned);
    81 extern fat_cluster_t fat_get_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
    82 extern void fat_set_cluster(struct fat_bs *, dev_handle_t, unsigned,
     82extern int fat_get_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t,
     83    fat_cluster_t *);
     84extern int fat_set_cluster(struct fat_bs *, dev_handle_t, unsigned,
    8385    fat_cluster_t, fat_cluster_t);
    84 extern void fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
     86extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
    8587    off_t);
    86 extern void fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
     88extern int fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
    8789
    8890#endif

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

    r7e266ff rad4b32c  
    9494       
    9595        /* Read the block that contains the dentry of interest. */
    96         b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
     96        rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
    9797            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
     98        assert(rc == EOK);
    9899
    99100        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
    … …  
    202203
    203204        /* Read the block that contains the dentry of interest. */
    204         b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
     205        rc = _fat_block_get(&b, bs, idxp->dev_handle, idxp->pfc,
    205206            (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
    206         assert(b);
     207        assert(rc == EOK);
    207208
    208209        d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
    … …  
    219220                 * size of the directory by walking the FAT.
    220221                 */
    221                 nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
     222                uint16_t clusters;
     223                rc = fat_clusters_get(&clusters, bs, idxp->dev_handle,
    222224                    uint16_t_le2host(d->firstc));
     225                assert(rc == EOK);
     226                nodep->size = bps * spc * clusters;
    223227        } else {
    224228                nodep->type = FAT_FILE;
    … …  
    325329        nodep = fat_node_get_new();
    326330        if (!nodep) {
    327                 fat_free_clusters(bs, dev_handle, mcl);
     331                (void) fat_free_clusters(bs, dev_handle, mcl);
    328332                return NULL;
    329333        }
    330334        idxp = fat_idx_get_new(dev_handle);
    331335        if (!idxp) {
    332                 fat_free_clusters(bs, dev_handle, mcl);
     336                (void) fat_free_clusters(bs, dev_handle, mcl); 
    333337                fat_node_put(FS_NODE(nodep));
    334338                return NULL;
    … …  
    337341        if (flags & L_DIRECTORY) {
    338342                /* Populate the new cluster with unused dentries. */
    339                 fat_zero_cluster(bs, dev_handle, mcl);
     343                rc = fat_zero_cluster(bs, dev_handle, mcl);
     344                assert(rc == EOK);
    340345                nodep->type = FAT_DIRECTORY;
    341346                nodep->firstc = mcl;
    … …  
    361366        fat_node_t *nodep = FAT_NODE(fn);
    362367        fat_bs_t *bs;
     368        int rc = EOK;
    363369
    364370        /*
    … …  
    379385                assert(nodep->size);
    380386                /* Free all clusters allocated to the node. */
    381                 fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
     387                rc = fat_free_clusters(bs, nodep->idx->dev_handle,
     388                    nodep->firstc);
    382389        }
    383390
    … …  
    385392        free(nodep->bp);
    386393        free(nodep);
    387         return EOK;
     394        return rc;
    388395}
    389396
    … …  
    433440
    434441        for (i = 0; i < blocks; i++) {
    435                 b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
     442                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     443                assert(rc == EOK);
    436444                for (j = 0; j < dps; j++) {
    437445                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    465473                return rc;
    466474        }
    467         fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    468         fat_append_clusters(bs, parentp, mcl);
     475        rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
     476        assert(rc == EOK);
     477        rc = fat_append_clusters(bs, parentp, mcl);
     478        assert(rc == EOK);
    469479        parentp->size += bps * bs->spc;
    470480        parentp->dirty = true;          /* need to sync node */
    471         b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
     481        rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     482        assert(rc == EOK);
    472483        d = (fat_dentry_t *)b->data;
    473484
    … …  
    494505         * not use them anyway, so this is rather a sign of our good will.
    495506         */
    496         b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
     507        rc = fat_block_get(&b, bs, childp, 0, BLOCK_FLAGS_NONE);
     508        assert(rc == EOK);
    497509        d = (fat_dentry_t *)b->data;
    498510        if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
    … …  
    561573        bps = uint16_t_le2host(bs->bps);
    562574
    563         b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
     575        rc = _fat_block_get(&b, bs, childp->idx->dev_handle, childp->idx->pfc,
    564576            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
    565577            BLOCK_FLAGS_NONE);
     578        assert(rc == EOK);
    566579        d = (fat_dentry_t *)b->data +
    567580            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
    … …  
    605618        blocks = parentp->size / bps;
    606619        for (i = 0; i < blocks; i++) {
    607                 b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
     620                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
     621                assert(rc == EOK);
    608622                for (j = 0; j < dps; j++) {
    609623                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    698712                fat_dentry_t *d;
    699713       
    700                 b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
     714                rc = fat_block_get(&b, bs, nodep, i, BLOCK_FLAGS_NONE);
     715                assert(rc == EOK);
    701716                for (j = 0; j < dps; j++) {
    702717                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    953968                        bytes = min(len, bps - pos % bps);
    954969                        bytes = min(bytes, nodep->size - pos);
    955                         b = fat_block_get(bs, nodep, pos / bps,
     970                        rc = fat_block_get(&b, bs, nodep, pos / bps,
    956971                            BLOCK_FLAGS_NONE);
     972                        assert(rc == EOK);
    957973                        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
    958974                            bytes);
    … …  
    980996                        off_t o;
    981997
    982                         b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
     998                        rc = fat_block_get(&b, bs, nodep, bnum,
     999                            BLOCK_FLAGS_NONE);
     1000                        assert(rc == EOK);
    9831001                        for (o = pos % (bps / sizeof(fat_dentry_t));
    9841002                            o < bps / sizeof(fat_dentry_t);
    … …  
    10751093                 * next block size boundary.
    10761094                 */
    1077                 fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
    1078                 b = fat_block_get(bs, nodep, pos / bps, flags);
     1095                rc = fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
     1096                assert(rc == EOK);
     1097                rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
     1098                assert(rc == EOK);
    10791099                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    10801100                    bytes);
    … …  
    11091129                }
    11101130                /* zero fill any gaps */
    1111                 fat_fill_gap(bs, nodep, mcl, pos);
    1112                 b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
     1131                rc = fat_fill_gap(bs, nodep, mcl, pos);
     1132                assert(rc == EOK);
     1133                rc = _fat_block_get(&b, bs, dev_handle, lcl, (pos / bps) % spc,
    11131134                    flags);
     1135                assert(rc == EOK);
    11141136                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    11151137                    bytes);
    … …  
    11211143                 * node's cluster chain.
    11221144                 */
    1123                 fat_append_clusters(bs, nodep, mcl);
     1145                rc = fat_append_clusters(bs, nodep, mcl);
     1146                assert(rc == EOK);
    11241147                nodep->size = pos + bytes;
    11251148                nodep->dirty = true;            /* need to sync node */
    … …  
    11741197                 */
    11751198                if (size == 0) {
    1176                         fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
     1199                        rc = fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
     1200                        if (rc != EOK)
     1201                                goto out;
    11771202                } else {
    11781203                        fat_cluster_t lastc;
    1179                         (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
    1180                             &lastc, (size - 1) / bpc);
    1181                         fat_chop_clusters(bs, nodep, lastc);
     1204                        rc = fat_cluster_walk(bs, dev_handle, nodep->firstc,
     1205                            &lastc, NULL, (size - 1) / bpc);
     1206                        if (rc != EOK)
     1207                                goto out;
     1208                        rc = fat_chop_clusters(bs, nodep, lastc);
     1209                        if (rc != EOK)
     1210                                goto out;
    11821211                }
    11831212                nodep->size = size;
    … …  
    11851214                rc = EOK;       
    11861215        }
     1216out:
    11871217        fat_node_put(fn);
    11881218        ipc_answer_0(rid, rc);
Note: See TracChangeset for help on using the changeset viewer.