Changeset 720db0c in mainline


Ignore:
Timestamp:
2010-06-26T23:00:54Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
68667ce
Parents:
cae5404
Message:

fix erroneous resizing of physical zones (ticket #240)

Location:
kernel/arch
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/ia32/src/mm/frame.c

    rcae5404 r720db0c  
    4747#include <print.h>
    4848
    49 #define PHYSMEM_LIMIT  0x7C000000
     49#define PHYSMEM_LIMIT  0x7C000000ull
    5050
    5151size_t hardcoded_unmapped_ktext_size = 0;
     
    8888#endif
    8989               
    90                 pfn_t pfn;
    91                 size_t count;
    92                
    9390                if (e820table[i].type == MEMMAP_MEMORY_AVAILABLE) {
    94                         /* To be safe, make available zone possibly smaller */
    95                         pfn = ADDR2PFN(ALIGN_UP(base, FRAME_SIZE));
    96                         count = SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE));
     91                        /* To be safe, make the available zone possibly smaller */
     92                        uint64_t new_base = ALIGN_UP(base, FRAME_SIZE);
     93                        uint64_t new_size = ALIGN_DOWN(size - (new_base - base),
     94                            FRAME_SIZE);
     95                       
     96                        pfn_t pfn = ADDR2PFN(new_base);
     97                        size_t count = SIZE2FRAMES(new_size);
    9798                       
    9899                        pfn_t conf;
     
    105106                       
    106107                        // XXX this has to be removed
    107                         if (last_frame < ALIGN_UP(base + size, FRAME_SIZE))
    108                                 last_frame = ALIGN_UP(base + size, FRAME_SIZE);
     108                        if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
     109                                last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
    109110                }
    110111               
    111112                if (e820table[i].type == MEMMAP_MEMORY_RESERVED) {
    112                         /* To be safe, make reserved zone possibly larger */
    113                         pfn = ADDR2PFN(ALIGN_DOWN(base, FRAME_SIZE));
    114                         count = SIZE2FRAMES(ALIGN_UP(size, FRAME_SIZE));
     113                        /* To be safe, make the reserved zone possibly larger */
     114                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
     115                        uint64_t new_size = ALIGN_UP(size + (base - new_base),
     116                            FRAME_SIZE);
    115117                       
    116                         zone_create(pfn, count, 0, ZONE_RESERVED);
     118                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
     119                            ZONE_RESERVED);
    117120                }
    118121               
    119122                if (e820table[i].type == MEMMAP_MEMORY_ACPI) {
    120                         /* To be safe, make firmware zone possibly larger */
    121                         pfn = ADDR2PFN(ALIGN_DOWN(base, (uintptr_t) FRAME_SIZE));
    122                         count = SIZE2FRAMES(ALIGN_UP(size, (uintptr_t) FRAME_SIZE));
     123                        /* To be safe, make the firmware zone possibly larger */
     124                        uint64_t new_base = ALIGN_DOWN(base, FRAME_SIZE);
     125                        uint64_t new_size = ALIGN_UP(size + (base - new_base),
     126                            FRAME_SIZE);
    123127                       
    124                         zone_create(pfn, count, 0, ZONE_FIRMWARE);
     128                        zone_create(ADDR2PFN(new_base), SIZE2FRAMES(new_size), 0,
     129                            ZONE_FIRMWARE);
    125130                }
    126131        }
  • kernel/arch/ppc32/src/mm/frame.c

    rcae5404 r720db0c  
    6060       
    6161        for (i = 0; i < memmap.cnt; i++) {
    62                 pfn_t start = ADDR2PFN(ALIGN_UP((uintptr_t) memmap.zones[i].start,
    63                     FRAME_SIZE));
    64                 size_t size = SIZE2FRAMES(ALIGN_DOWN(memmap.zones[i].size, FRAME_SIZE));
     62                /* To be safe, make the available zone possibly smaller */
     63                uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     64                    FRAME_SIZE);
     65                size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
     66                    (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     67               
     68                pfn_t pfn = ADDR2PFN(new_start);
     69                size_t count = SIZE2FRAMES(new_size);
    6570               
    6671                pfn_t conf;
    67                 if ((minconf < start) || (minconf >= start + size))
    68                         conf = start;
     72                if ((minconf < pfn) || (minconf >= pfn + count))
     73                        conf = pfn;
    6974                else
    7075                        conf = minconf;
    7176               
    72                 zone_create(start, size, conf, 0);
    73                 if (last_frame < ALIGN_UP((uintptr_t) memmap.zones[i].start
    74                     + memmap.zones[i].size, FRAME_SIZE))
    75                         last_frame = ALIGN_UP((uintptr_t) memmap.zones[i].start
    76                             + memmap.zones[i].size, FRAME_SIZE);
     77                zone_create(pfn, count, conf, 0);
     78               
     79                if (last_frame < ALIGN_UP(new_start + new_size, FRAME_SIZE))
     80                        last_frame = ALIGN_UP(new_start + new_size, FRAME_SIZE);
    7781        }
    7882       
  • kernel/arch/sparc64/src/mm/sun4u/frame.c

    rcae5404 r720db0c  
    4949void frame_arch_init(void)
    5050{
    51         unsigned int i;
    52         pfn_t confdata;
    53 
    5451        if (config.cpu_active == 1) {
     52                unsigned int i;
     53               
    5554                for (i = 0; i < memmap.cnt; i++) {
    56                         uintptr_t start = (uintptr_t) memmap.zones[i].start;
    57                         size_t size = memmap.zones[i].size;
    58 
     55                        /* To be safe, make the available zone possibly smaller */
     56                        uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     57                            FRAME_SIZE);
     58                        size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
     59                            (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     60                       
    5961                        /*
    6062                         * The memmap is created by HelenOS boot loader.
    6163                         * It already contains no holes.
    6264                         */
    63 
    64                         confdata = ADDR2PFN(start);
     65                       
     66                        pfn_t confdata = ADDR2PFN(new_start);
     67                       
    6568                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    6669                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    67                         zone_create(ADDR2PFN(start),
    68                             SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE)),
     70                       
     71                        zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
    6972                            confdata, 0);
    70                         last_frame = max(last_frame, start + ALIGN_UP(size,
    71                             FRAME_SIZE));
     73                       
     74                        last_frame = max(last_frame, new_start + new_size);
    7275                }
    73 
     76               
    7477                /*
    7578                 * On sparc64, physical memory can start on a non-zero address.
     
    8083                frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    8184        }
    82 
     85       
    8386        end_of_identity = PA2KA(last_frame);
    8487}
  • kernel/arch/sparc64/src/mm/sun4v/frame.c

    rcae5404 r720db0c  
    4747void frame_arch_init(void)
    4848{
    49         unsigned int i;
    50         pfn_t confdata;
    51 
    5249        if (config.cpu_active == 1) {
     50                unsigned int i;
     51               
    5352                for (i = 0; i < memmap.cnt; i++) {
    54                         uintptr_t start = (uintptr_t) memmap.zones[i].start;
    55                         size_t size = memmap.zones[i].size;
    56 
     53                        /* To be safe, make the available zone possibly smaller */
     54                        uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     55                            FRAME_SIZE);
     56                        size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
     57                            (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     58                       
    5759                        /*
    5860                         * The memmap is created by HelenOS boot loader.
    5961                         * It already contains no holes.
    6062                         */
    61 
    62                         confdata = ADDR2PFN(start);
     63                       
     64                        pfn_t confdata = ADDR2PFN(new_start);
     65                       
    6366                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    6467                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    65                         zone_create(ADDR2PFN(start),
    66                             SIZE2FRAMES(ALIGN_DOWN(size, FRAME_SIZE)),
     68                       
     69                        zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
    6770                            confdata, 0);
    6871                }
    69 
     72               
    7073                /*
    7174                 * On sparc64, physical memory can start on a non-zero address.
Note: See TracChangeset for help on using the changeset viewer.