Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e2a0d76 in mainline


Ignore:
Timestamp:
2013-09-09T23:29:57Z (8 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
ba2be23
Parents:
8cbf1c3
Message:

cstyle

Location:
kernel
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/arm32/src/ras.c

    r8cbf1c3 re2a0d76  
    5151void ras_init(void)
    5252{
    53         uintptr_t frame;
    54 
    55         frame = frame_alloc(ONE_FRAME,
     53        uintptr_t frame = frame_alloc(ONE_FRAME,
    5654            FRAME_ATOMIC | FRAME_HIGHMEM, 0);
    5755        if (!frame)
    5856                frame = frame_alloc(ONE_FRAME, FRAME_LOWMEM, 0);
     57       
    5958        ras_page = (uintptr_t *) km_map(frame,
    6059            PAGE_SIZE, PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
    61 
     60       
    6261        memsetb(ras_page, PAGE_SIZE, 0);
    6362        ras_page[RAS_START] = 0;
  • kernel/arch/ia64/src/mm/vhpt.c

    r8cbf1c3 re2a0d76  
    4646        if (!vhpt_base)
    4747                panic("Kernel configured with VHPT but no memory for table.");
     48       
    4849        vhpt_invalidate_all();
    4950        return (uintptr_t) vhpt_base;
  • kernel/arch/mips32/include/arch/mm/page.h

    r8cbf1c3 re2a0d76  
    2727 */
    2828
    29 /** @addtogroup mips32mm       
     29/** @addtogroup mips32mm
    3030 * @{
    3131 */
     
    7070 * - PTL3 has 4096 entries (12 bits)
    7171 */
    72  
     72
    7373/* Macros describing number of entries in each level. */
    74 #define PTL0_ENTRIES_ARCH       64
    75 #define PTL1_ENTRIES_ARCH       0
    76 #define PTL2_ENTRIES_ARCH       0
    77 #define PTL3_ENTRIES_ARCH       4096
     74#define PTL0_ENTRIES_ARCH  64
     75#define PTL1_ENTRIES_ARCH  0
     76#define PTL2_ENTRIES_ARCH  0
     77#define PTL3_ENTRIES_ARCH  4096
    7878
    7979/* Macros describing size of page tables in each level. */
     
    8484
    8585/* Macros calculating entry indices for each level. */
    86 #define PTL0_INDEX_ARCH(vaddr)  ((vaddr) >> 26)
    87 #define PTL1_INDEX_ARCH(vaddr)  0
    88 #define PTL2_INDEX_ARCH(vaddr)  0
    89 #define PTL3_INDEX_ARCH(vaddr)  (((vaddr) >> 14) & 0xfff)
     86#define PTL0_INDEX_ARCH(vaddr)  ((vaddr) >> 26)
     87#define PTL1_INDEX_ARCH(vaddr)  0
     88#define PTL2_INDEX_ARCH(vaddr)  0
     89#define PTL3_INDEX_ARCH(vaddr)  (((vaddr) >> 14) & 0xfff)
    9090
    9191/* Set accessor for PTL0 address. */
    9292#define SET_PTL0_ADDRESS_ARCH(ptl0)
    9393
    94 /* Get PTE address accessors for each level. */ 
     94/* Get PTE address accessors for each level. */
    9595#define GET_PTL1_ADDRESS_ARCH(ptl0, i) \
    9696        (((pte_t *) (ptl0))[(i)].pfn << 12)
  • kernel/arch/sparc64/src/mm/sun4u/as.c

    r8cbf1c3 re2a0d76  
    7272       
    7373        uintptr_t tsb = PA2KA(frame_alloc(order, flags, 0));
    74        
    7574        if (!tsb)
    7675                return -1;
  • kernel/arch/sparc64/src/mm/sun4v/as.c

    r8cbf1c3 re2a0d76  
    7070       
    7171        uintptr_t tsb = frame_alloc(order, flags, 0);
    72        
    7372        if (!tsb)
    7473                return -1;
  • kernel/doc/mm

    r8cbf1c3 re2a0d76  
    7171
    7272'malloc' function accepts flags as a second argument. The flags are directly
    73 passed to the underlying frame_alloc function. 
     73passed to the underlying frame_alloc function.
    7474
    75751) If the flags parameter contains FRAME_ATOMIC, the allocator will not sleep.
  • kernel/genarch/src/mm/as_pt.c

    r8cbf1c3 re2a0d76  
    8282                /*
    8383                 * Copy the kernel address space portion to new PTL0.
    84                  *
    8584                 */
    8685               
  • kernel/genarch/src/mm/page_pt.c

    r8cbf1c3 re2a0d76  
    363363 * @param size Size in bytes defining the range of PTL0 entries that will be
    364364 *             altered by this function.
     365 *
    365366 */
    366367void pt_mapping_make_global(uintptr_t base, size_t size)
    367368{
     369        ASSERT(size > 0);
     370       
    368371        uintptr_t ptl0 = PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
    369372        uintptr_t ptl0_step = ptl0_step_get();
    370373        size_t order;
    371         uintptr_t addr;
    372 
     374       
    373375#if (PTL1_ENTRIES != 0)
    374376        order = PTL1_SIZE;
     
    378380        order = PTL3_SIZE;
    379381#endif
    380 
    381         ASSERT(size > 0);
    382 
    383         for (addr = ALIGN_DOWN(base, ptl0_step); addr - 1 < base + size - 1;
     382       
     383        for (uintptr_t addr = ALIGN_DOWN(base, ptl0_step);
     384            addr - 1 < base + size - 1;
    384385            addr += ptl0_step) {
    385                 uintptr_t l1;
    386 
    387                 l1 = PA2KA(frame_alloc(order, FRAME_LOWMEM, 0));
     386                uintptr_t l1 = PA2KA(frame_alloc(order, FRAME_LOWMEM, 0));
    388387                memsetb((void *) l1, FRAME_SIZE << order, 0);
    389388                SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(addr), KA2PA(l1));
  • kernel/generic/include/config.h

    r8cbf1c3 re2a0d76  
    4545#define STACK_SIZE    ((1 << STACK_FRAMES) << PAGE_WIDTH)
    4646
    47 #define STACK_SIZE_USER (1 * 1024 * 1024)
     47#define STACK_SIZE_USER  (1 * 1024 * 1024)
    4848
    4949#define CONFIG_INIT_TASKS        32
  • kernel/generic/include/mm/slab.h

    r8cbf1c3 re2a0d76  
    9090       
    9191        /* Configuration */
     92       
    9293        /** Size of slab position - align_up(sizeof(obj)) */
    9394        size_t size;
  • kernel/generic/src/ddi/ddi.c

    r8cbf1c3 re2a0d76  
    327327        ASSERT(TASK);
    328328       
    329         size_t pages = SIZE2FRAMES(size);
     329        size_t frames = SIZE2FRAMES(size);
    330330        uint8_t order;
    331331       
    332         /* We need the 2^order >= pages */
    333         if (pages == 1)
     332        /* We need the 2^order >= frames */
     333        if (frames == 1)
    334334                order = 0;
    335335        else
    336                 order = fnzb(pages - 1) + 1;
     336                order = fnzb(frames - 1) + 1;
    337337       
    338338        *phys = frame_alloc_noreserve(order, 0, 0);
     
    342342        mem_backend_data_t backend_data;
    343343        backend_data.base = *phys;
    344         backend_data.frames = pages;
     344        backend_data.frames = frames;
    345345       
    346346        if (!as_area_create(TASK->as, map_flags, size,
  • kernel/generic/src/debug/stacktrace.c

    r8cbf1c3 re2a0d76  
    3939#include <print.h>
    4040
    41 #define STACK_FRAMES_MAX        20
     41#define STACK_FRAMES_MAX  20
    4242
    4343void stack_trace_ctx(stack_trace_ops_t *ops, stack_trace_context_t *ctx)
     
    4949        uintptr_t pc;
    5050       
    51         while (cnt++ < STACK_FRAMES_MAX &&
    52             ops->stack_trace_context_validate(ctx)) {
     51        while ((cnt++ < STACK_FRAMES_MAX) &&
     52            (ops->stack_trace_context_validate(ctx))) {
    5353                if (ops->symbol_resolve &&
    5454                    ops->symbol_resolve(ctx->pc, &symbol, &offset)) {
  • kernel/generic/src/mm/km.c

    r8cbf1c3 re2a0d76  
    239239uintptr_t km_temporary_page_get(uintptr_t *framep, frame_flags_t flags)
    240240{
    241         uintptr_t frame;
    242         uintptr_t page;
    243 
    244241        ASSERT(THREAD);
    245242        ASSERT(framep);
    246243        ASSERT(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
    247 
     244       
    248245        /*
    249246         * Allocate a frame, preferably from high memory.
    250247         */
    251         frame = frame_alloc(ONE_FRAME,
     248        uintptr_t page;
     249        uintptr_t frame = frame_alloc(ONE_FRAME,
    252250            FRAME_HIGHMEM | FRAME_ATOMIC | flags, 0);
    253251        if (frame) {
    254252                page = km_map(frame, PAGE_SIZE,
    255253                    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    256                 ASSERT(page);   // FIXME
     254               
     255                // FIXME
     256                ASSERT(page);
    257257        } else {
    258258                frame = frame_alloc(ONE_FRAME, FRAME_LOWMEM | flags, 0);
    259259                if (!frame)
    260260                        return (uintptr_t) NULL;
     261               
    261262                page = PA2KA(frame);
    262263        }
    263 
     264       
    264265        *framep = frame;
    265         return page;   
     266        return page;
    266267}
    267268
  • kernel/generic/src/mm/slab.c

    r8cbf1c3 re2a0d76  
    184184        void *data = (void *)
    185185            PA2KA(frame_alloc_generic(cache->order, flags, 0, &zone));
    186         if (!data) {
     186        if (!data)
    187187                return NULL;
    188         }
    189188       
    190189        slab_t *slab;
  • kernel/test/mm/mapping1.c

    r8cbf1c3 re2a0d76  
    4343        uintptr_t page0, page1;
    4444        uint32_t v;
    45         int i;
    4645       
    4746        uintptr_t frame = frame_alloc(ONE_FRAME, FRAME_NONE, 0);
     
    5655            (void *) page1, (void *) frame);
    5756       
    58         for (i = 0; i < 2; i++) {
     57        for (unsigned int i = 0; i < 2; i++) {
    5958                TPRINTF("Writing magic using the first virtual address.\n");
    60 
     59               
    6160                *((uint32_t *) page0) = TEST_MAGIC;
    62 
     61               
    6362                TPRINTF("Reading magic using the second virtual address.\n");
    64 
     63               
    6564                v = *((uint32_t *) page1);
    66        
     65               
    6766                if (v != TEST_MAGIC) {
    6867                        km_unmap(page0, PAGE_SIZE);
     
    7170                        return "Criss-cross read does not match the value written.";
    7271                }
    73 
     72               
    7473                TPRINTF("Writing zero using the second virtual address.\n");
    75        
     74               
    7675                *((uint32_t *) page1) = 0;
    77 
     76               
    7877                TPRINTF("Reading zero using the first virtual address.\n");
    79        
     78               
    8079                v = *((uint32_t *) page0);
    81        
     80               
    8281                if (v != 0) {
    8382                        km_unmap(page0, PAGE_SIZE);
     
    8786                }
    8887        }
    89 
     88       
    9089        km_unmap(page0, PAGE_SIZE);
    9190        km_unmap(page1, PAGE_SIZE);
Note: See TracChangeset for help on using the changeset viewer.