Changeset 1f7753a in mainline


Ignore:
Timestamp:
2012-11-18T22:10:15Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0ab362c, c739102
Parents:
a7f7ed12 (diff), 34ae0a5 (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 from lp:~jakub/helenos/mm.

Files:
2 added
22 edited

Legend:

Unmodified
Added
Removed
  • abi/include/mm/as.h

    ra7f7ed12 r1f7753a  
    3737
    3838/** Address space area flags. */
    39 #define AS_AREA_READ       0x01
    40 #define AS_AREA_WRITE      0x02
    41 #define AS_AREA_EXEC       0x04
    42 #define AS_AREA_CACHEABLE  0x08
    43 #define AS_AREA_GUARD      0x10
     39#define AS_AREA_READ         0x01
     40#define AS_AREA_WRITE        0x02
     41#define AS_AREA_EXEC         0x04
     42#define AS_AREA_CACHEABLE    0x08
     43#define AS_AREA_GUARD        0x10
     44#define AS_AREA_LATE_RESERVE 0x20
    4445
    4546/** Address space area info exported to uspace. */
  • boot/arch/ia64/src/main.c

    ra7f7ed12 r1f7753a  
    4848
    4949#define DEFAULT_MEMORY_BASE             0x4000000ULL
    50 #define DEFAULT_MEMORY_SIZE             0x4000000ULL
     50#define DEFAULT_MEMORY_SIZE             (256 * 1024 * 1024)
    5151#define DEFAULT_LEGACY_IO_BASE          0x00000FFFFC000000ULL
    5252#define DEFAULT_LEGACY_IO_SIZE          0x4000000ULL
  • contrib/conf/ski.conf

    ra7f7ed12 r1f7753a  
    1 load HelenOS/image.boot
     1load image.boot
  • kernel/arch/ia64/include/mm/as.h

    ra7f7ed12 r1f7753a  
    4343#define USER_ADDRESS_SPACE_END_ARCH      UINT64_C(0xdfffffffffffffff)
    4444
    45 #define USTACK_ADDRESS_ARCH  UINT64_C(0x0000000ff0000000)
    46 
    4745typedef struct {
    4846} as_arch_t;
  • kernel/arch/ia64/src/mm/tlb.c

    ra7f7ed12 r1f7753a  
    113113        va = page;
    114114       
    115         rr.word = rr_read(VA2VRN(va));
    116         if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
     115        rr.word = rr_read(VA2VRN(page));
     116        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(page))))) {
    117117                /*
    118118                 * The selected region register does not contain required RID.
     
    122122               
    123123                rr0 = rr;
    124                 rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    125                 rr_write(VA2VRN(va), rr0.word);
     124                rr0.map.rid = ASID2RID(asid, VA2VRN(page));
     125                rr_write(VA2VRN(page), rr0.word);
    126126                srlz_d();
    127127                srlz_i();
     
    139139        case 1: /* cnt 4 - 15 */
    140140                ps = PAGE_WIDTH + 2;
    141                 va &= ~((1 << ps) - 1);
     141                va &= ~((1UL << ps) - 1);
    142142                break;
    143143        case 2: /* cnt 16 - 63 */
    144144                ps = PAGE_WIDTH + 4;
    145                 va &= ~((1 << ps) - 1);
     145                va &= ~((1UL << ps) - 1);
    146146                break;
    147147        case 3: /* cnt 64 - 255 */
    148148                ps = PAGE_WIDTH + 6;
    149                 va &= ~((1 << ps) - 1);
     149                va &= ~((1UL << ps) - 1);
    150150                break;
    151151        case 4: /* cnt 256 - 1023 */
    152152                ps = PAGE_WIDTH + 8;
    153                 va &= ~((1 << ps) - 1);
     153                va &= ~((1UL << ps) - 1);
    154154                break;
    155155        case 5: /* cnt 1024 - 4095 */
    156156                ps = PAGE_WIDTH + 10;
    157                 va &= ~((1 << ps) - 1);
     157                va &= ~((1UL << ps) - 1);
    158158                break;
    159159        case 6: /* cnt 4096 - 16383 */
    160160                ps = PAGE_WIDTH + 12;
    161                 va &= ~((1 << ps) - 1);
     161                va &= ~((1UL << ps) - 1);
    162162                break;
    163163        case 7: /* cnt 16384 - 65535 */
    164164        case 8: /* cnt 65536 - (256K - 1) */
    165165                ps = PAGE_WIDTH + 14;
    166                 va &= ~((1 << ps) - 1);
     166                va &= ~((1UL << ps) - 1);
    167167                break;
    168168        default:
    169169                ps = PAGE_WIDTH + 18;
    170                 va &= ~((1 << ps) - 1);
     170                va &= ~((1UL << ps) - 1);
    171171                break;
    172172        }
    173173       
    174         for (; va < (page + cnt * PAGE_SIZE); va += (1 << ps))
     174        for (; va < (page + cnt * PAGE_SIZE); va += (1UL << ps))
    175175                asm volatile (
    176176                        "ptc.l %[va], %[ps] ;;"
     
    183183       
    184184        if (restore_rr) {
    185                 rr_write(VA2VRN(va), rr.word);
     185                rr_write(VA2VRN(page), rr.word);
    186186                srlz_d();
    187187                srlz_i();
  • kernel/genarch/src/mm/page_ht.c

    ra7f7ed12 r1f7753a  
    209209                pte->frame = ALIGN_DOWN(frame, FRAME_SIZE);
    210210
     211                /*
     212                 * Make sure that a concurrent ht_mapping_find() will see the
     213                 * new entry only after it is fully initialized.
     214                 */
    211215                write_barrier();
    212216               
  • kernel/genarch/src/mm/page_pt.c

    ra7f7ed12 r1f7753a  
    8989                    PAGE_NOT_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
    9090                    PAGE_WRITE);
     91                /*
     92                 * Make sure that a concurrent hardware page table walk or
     93                 * pt_mapping_find() will see the new PTL1 only after it is
     94                 * fully initialized.
     95                 */
    9196                write_barrier();
    9297                SET_PTL1_PRESENT(ptl0, PTL0_INDEX(page));
     
    103108                    PAGE_NOT_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
    104109                    PAGE_WRITE);
     110                /*
     111                 * Make the new PTL2 visible only after it is fully initialized.
     112                 */
    105113                write_barrier();
    106114                SET_PTL2_PRESENT(ptl1, PTL1_INDEX(page));       
     
    117125                    PAGE_NOT_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
    118126                    PAGE_WRITE);
     127                /*
     128                 * Make the new PTL3 visible only after it is fully initialized.
     129                 */
    119130                write_barrier();
    120131                SET_PTL3_PRESENT(ptl2, PTL2_INDEX(page));
     
    125136        SET_FRAME_ADDRESS(ptl3, PTL3_INDEX(page), frame);
    126137        SET_FRAME_FLAGS(ptl3, PTL3_INDEX(page), flags | PAGE_NOT_PRESENT);
     138        /*
     139         * Make the new mapping visible only after it is fully initialized.
     140         */
    127141        write_barrier();
    128142        SET_FRAME_PRESENT(ptl3, PTL3_INDEX(page));
     
    296310
    297311#if (PTL1_ENTRIES != 0)
     312        /*
     313         * Always read ptl2 only after we are sure it is present.
     314         */
    298315        read_barrier();
    299316#endif
     
    304321
    305322#if (PTL2_ENTRIES != 0)
     323        /*
     324         * Always read ptl3 only after we are sure it is present.
     325         */
    306326        read_barrier();
    307327#endif
  • kernel/generic/include/config.h

    ra7f7ed12 r1f7753a  
    4444#define STACK_FRAMES  TWO_FRAMES
    4545#define STACK_SIZE    ((1 << STACK_FRAMES) << PAGE_WIDTH)
     46
     47#define STACK_SIZE_USER (1 * 1024 * 1024)
    4648
    4749#define CONFIG_INIT_TASKS        32
  • kernel/generic/include/mm/as.h

    ra7f7ed12 r1f7753a  
    6161#define USER_ADDRESS_SPACE_END      USER_ADDRESS_SPACE_END_ARCH
    6262
    63 #ifdef USTACK_ADDRESS_ARCH
    64         #define USTACK_ADDRESS  USTACK_ADDRESS_ARCH
    65 #else
    66         #define USTACK_ADDRESS  (USER_ADDRESS_SPACE_END - (STACK_SIZE - 1))
    67 #endif
    68 
    6963/** Kernel address space. */
    7064#define FLAG_AS_KERNEL  (1 << 0)
     
    224218        void (* destroy)(as_area_t *);
    225219
     220        bool (* is_resizable)(as_area_t *);
     221        bool (* is_shareable)(as_area_t *);
     222
    226223        int (* page_fault)(as_area_t *, uintptr_t, pf_access_t);
    227224        void (* frame_free)(as_area_t *, uintptr_t, uintptr_t);
  • kernel/generic/include/proc/task.h

    ra7f7ed12 r1f7753a  
    134134        uint64_t ucycles;
    135135        uint64_t kcycles;
     136
     137        /** If true, do not attempt to print a verbose kill message. */
     138        bool silent_kill;
    136139} task_t;
    137140
  • kernel/generic/src/interrupt/interrupt.c

    ra7f7ed12 r1f7753a  
    168168static NO_TRACE void fault_from_uspace_core(istate_t *istate, const char *fmt, va_list args)
    169169{
    170         printf("Task %s (%" PRIu64 ") killed due to an exception at "
    171             "program counter %p.\n", TASK->name, TASK->taskid,
    172             (void *) istate_get_pc(istate));
    173        
    174         istate_decode(istate);
    175         stack_trace_istate(istate);
    176        
    177         printf("Kill message: ");
    178         vprintf(fmt, args);
    179         printf("\n");
     170        if (!TASK->silent_kill) {
     171                printf("Task %s (%" PRIu64 ") killed due to an exception at "
     172                    "program counter %p.\n", TASK->name, TASK->taskid,
     173                    (void *) istate_get_pc(istate));
     174       
     175                istate_decode(istate);
     176                stack_trace_istate(istate);
     177       
     178                printf("Kill message: ");
     179                vprintf(fmt, args);
     180                printf("\n");
     181        }
    180182       
    181183        task_kill_self(true);
  • kernel/generic/src/main/kinit.c

    ra7f7ed12 r1f7753a  
    172172#endif /* CONFIG_KCONSOLE */
    173173       
     174        /*
     175         * Store the default stack size in sysinfo so that uspace can create
     176         * stack with this default size.
     177         */
     178        sysinfo_set_item_val("default.stack_size", NULL, STACK_SIZE_USER);
     179       
    174180        interrupts_enable();
    175181       
  • kernel/generic/src/mm/as.c

    ra7f7ed12 r1f7753a  
    426426        /*
    427427         * So far, the area does not conflict with other areas.
    428          * Check if it doesn't conflict with kernel address space.
     428         * Check if it is contained in the user address space.
    429429         */
    430430        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    431                 return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
    432                     KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
     431                return iswithin(USER_ADDRESS_SPACE_START,
     432                    (USER_ADDRESS_SPACE_END - USER_ADDRESS_SPACE_START) + 1,
     433                    addr, P2SZ(count));
    433434        }
    434435       
     
    696697                return ENOENT;
    697698        }
    698        
    699         if (area->backend == &phys_backend) {
    700                 /*
    701                  * Remapping of address space areas associated
    702                  * with memory mapped devices is not supported.
     699
     700        if (!area->backend->is_resizable(area)) {
     701                /*
     702                 * The backend does not support resizing for this area.
    703703                 */
    704704                mutex_unlock(&area->lock);
     
    10571057        }
    10581058       
    1059         if ((!src_area->backend) || (!src_area->backend->share)) {
    1060                 /*
    1061                  * There is no backend or the backend does not
    1062                  * know how to share the area.
     1059        if (!src_area->backend->is_shareable(src_area)) {
     1060                /*
     1061                 * The backend does not permit sharing of this area.
    10631062                 */
    10641063                mutex_unlock(&src_area->lock);
  • kernel/generic/src/mm/backend_anon.c

    ra7f7ed12 r1f7753a  
    5959static void anon_destroy(as_area_t *);
    6060
     61static bool anon_is_resizable(as_area_t *);
     62static bool anon_is_shareable(as_area_t *);
     63
    6164static int anon_page_fault(as_area_t *, uintptr_t, pf_access_t);
    6265static void anon_frame_free(as_area_t *, uintptr_t, uintptr_t);
     
    6871        .destroy = anon_destroy,
    6972
     73        .is_resizable = anon_is_resizable,
     74        .is_shareable = anon_is_shareable,
     75
    7076        .page_fault = anon_page_fault,
    7177        .frame_free = anon_frame_free,
     
    7480bool anon_create(as_area_t *area)
    7581{
     82        if (area->flags & AS_AREA_LATE_RESERVE)
     83                return true;
     84
    7685        return reserve_try_alloc(area->pages);
    7786}
     
    7988bool anon_resize(as_area_t *area, size_t new_pages)
    8089{
     90        if (area->flags & AS_AREA_LATE_RESERVE)
     91                return true;
     92
    8193        if (new_pages > area->pages)
    8294                return reserve_try_alloc(new_pages - area->pages);
     
    100112        ASSERT(mutex_locked(&area->as->lock));
    101113        ASSERT(mutex_locked(&area->lock));
     114        ASSERT(!(area->flags & AS_AREA_LATE_RESERVE));
    102115
    103116        /*
     
    139152void anon_destroy(as_area_t *area)
    140153{
     154        if (area->flags & AS_AREA_LATE_RESERVE)
     155                return;
     156
    141157        reserve_free(area->pages);
    142158}
    143159
     160bool anon_is_resizable(as_area_t *area)
     161{
     162        return true;
     163}
     164
     165bool anon_is_shareable(as_area_t *area)
     166{
     167        return !(area->flags & AS_AREA_LATE_RESERVE);
     168}
    144169
    145170/** Service a page fault in the anonymous memory address space area.
     
    225250                 *   the different causes
    226251                 */
     252
     253                if (area->flags & AS_AREA_LATE_RESERVE) {
     254                        /*
     255                         * Reserve the memory for this page now.
     256                         */
     257                        if (!reserve_try_alloc(1)) {
     258                                printf("Killing task %" PRIu64 " due to a "
     259                                    "failed late reservation request.\n",
     260                                    TASK->taskid);
     261                                TASK->silent_kill = true;
     262                                return AS_PF_FAULT;
     263                        }
     264                }
     265
    227266                kpage = km_temporary_page_get(&frame, FRAME_NO_RESERVE);
    228267                memsetb((void *) kpage, PAGE_SIZE, 0);
     
    255294        ASSERT(mutex_locked(&area->lock));
    256295
    257         frame_free_noreserve(frame);
     296        if (area->flags & AS_AREA_LATE_RESERVE) {
     297                /*
     298                 * In case of the late reserve areas, physical memory will not
     299                 * be unreserved when the area is destroyed so we need to use
     300                 * the normal unreserving frame_free().
     301                 */
     302                frame_free(frame);
     303        } else {
     304                /*
     305                 * The reserve will be given back when the area is destroyed or
     306                 * resized, so use the frame_free_noreserve() which does not
     307                 * manipulate the reserve or it would be given back twice.
     308                 */
     309                frame_free_noreserve(frame);
     310        }
    258311}
    259312
  • kernel/generic/src/mm/backend_elf.c

    ra7f7ed12 r1f7753a  
    5858static void elf_destroy(as_area_t *);
    5959
     60static bool elf_is_resizable(as_area_t *);
     61static bool elf_is_shareable(as_area_t *);
     62
    6063static int elf_page_fault(as_area_t *, uintptr_t, pf_access_t);
    6164static void elf_frame_free(as_area_t *, uintptr_t, uintptr_t);
     
    6669        .share = elf_share,
    6770        .destroy = elf_destroy,
     71
     72        .is_resizable = elf_is_resizable,
     73        .is_shareable = elf_is_shareable,
    6874
    6975        .page_fault = elf_page_fault,
     
    213219}
    214220
     221bool elf_is_resizable(as_area_t *area)
     222{
     223        return true;
     224}
     225
     226bool elf_is_shareable(as_area_t *area)
     227{
     228        return true;
     229}
     230
     231
    215232/** Service a page fault in the ELF backend address space area.
    216233 *
  • kernel/generic/src/mm/backend_phys.c

    ra7f7ed12 r1f7753a  
    5252static void phys_destroy(as_area_t *);
    5353
     54static bool phys_is_resizable(as_area_t *);
     55static bool phys_is_shareable(as_area_t *);
     56
     57
    5458static int phys_page_fault(as_area_t *, uintptr_t, pf_access_t);
    5559
     
    5963        .share = phys_share,
    6064        .destroy = phys_destroy,
     65
     66        .is_resizable = phys_is_resizable,
     67        .is_shareable = phys_is_shareable,
    6168
    6269        .page_fault = phys_page_fault,
     
    8794        /* Nothing to do. */
    8895}
     96
     97bool phys_is_resizable(as_area_t *area)
     98{
     99        return false;
     100}
     101
     102bool phys_is_shareable(as_area_t *area)
     103{
     104        return true;
     105}
     106
    89107
    90108/** Service a page fault in the address space area backed by physical memory.
  • kernel/generic/src/mm/km.c

    ra7f7ed12 r1f7753a  
    233233 * @param[inout] framep Pointer to a variable which will receive the physical
    234234 *                      address of the allocated frame.
    235  * @param[in] flags     Frame allocation flags. FRAME_NONE or FRAME_NO_RESERVE.
     235 * @param[in] flags     Frame allocation flags. FRAME_NONE, FRAME_NO_RESERVE
     236 *                      and FRAME_ATOMIC bits are allowed.
    236237 * @return              Virtual address of the allocated frame.
    237238 */
     
    243244        ASSERT(THREAD);
    244245        ASSERT(framep);
    245         ASSERT(!(flags & ~FRAME_NO_RESERVE));
     246        ASSERT(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
    246247
    247248        /*
     
    255256                ASSERT(page);   // FIXME
    256257        } else {
    257                 frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME,
    258                     FRAME_LOWMEM);
     258                frame = (uintptr_t) frame_alloc(ONE_FRAME,
     259                    FRAME_LOWMEM | flags);
     260                if (!frame)
     261                        return (uintptr_t) NULL;
    259262                page = PA2KA(frame);
    260263        }
  • kernel/generic/src/proc/program.c

    ra7f7ed12 r1f7753a  
    7979         * Create the stack address space area.
    8080         */
    81         uintptr_t virt = USTACK_ADDRESS;
     81        uintptr_t virt = (uintptr_t) -1;
     82        uintptr_t bound = USER_ADDRESS_SPACE_END - (STACK_SIZE_USER - 1);
     83
     84        /* Adjust bound to create space for the desired guard page. */
     85        bound -= PAGE_SIZE;
     86
    8287        as_area_t *area = as_area_create(as,
    83             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
    84             STACK_SIZE, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, 0);
     88            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
     89            AS_AREA_LATE_RESERVE, STACK_SIZE_USER, AS_AREA_ATTR_NONE,
     90            &anon_backend, NULL, &virt, bound);
    8591        if (!area) {
    8692                task_destroy(prg->task);
     
    9399        kernel_uarg->uspace_entry = (void *) entry_addr;
    94100        kernel_uarg->uspace_stack = (void *) virt;
    95         kernel_uarg->uspace_stack_size = STACK_SIZE;
     101        kernel_uarg->uspace_stack_size = STACK_SIZE_USER;
    96102        kernel_uarg->uspace_thread_function = NULL;
    97103        kernel_uarg->uspace_thread_arg = NULL;
  • kernel/generic/src/proc/task.c

    ra7f7ed12 r1f7753a  
    196196        task->ucycles = 0;
    197197        task->kcycles = 0;
     198
     199        task->silent_kill = false;
    198200       
    199201        task->ipc_info.call_sent = 0;
  • uspace/lib/c/Makefile

    ra7f7ed12 r1f7753a  
    140140        generic/net/socket_client.c \
    141141        generic/net/socket_parse.c \
     142        generic/stack.c \
    142143        generic/stacktrace.c \
    143144        generic/arg_parse.c \
  • uspace/lib/c/generic/fibril.c

    ra7f7ed12 r1f7753a  
    3737#include <fibril.h>
    3838#include <thread.h>
     39#include <stack.h>
    3940#include <tls.h>
    4041#include <malloc.h>
     42#include <abi/mm/as.h>
     43#include <as.h>
    4144#include <unistd.h>
    4245#include <stdio.h>
     
    4649#include <assert.h>
    4750#include <async.h>
    48 
    49 #ifndef FIBRIL_INITIAL_STACK_PAGES_NO
    50         #define FIBRIL_INITIAL_STACK_PAGES_NO  1
    51 #endif
    5251
    5352/**
     
    195194                                         * stack member filled.
    196195                                         */
    197                                         free(stack);
     196                                        as_area_destroy(stack);
    198197                                }
    199198                                fibril_teardown(srcf->clean_after_me);
     
    269268                return 0;
    270269       
    271         fibril->stack =
    272             (char *) malloc(FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize());
    273         if (!fibril->stack) {
     270        size_t stack_size = stack_size_get();
     271        fibril->stack = as_area_create((void *) -1, stack_size,
     272            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
     273            AS_AREA_LATE_RESERVE);
     274        if (fibril->stack == (void *) -1) {
    274275                fibril_teardown(fibril);
    275276                return 0;
     
    281282        context_save(&fibril->ctx);
    282283        context_set(&fibril->ctx, FADDR(fibril_main), fibril->stack,
    283             FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize(), fibril->tcb);
     284            stack_size, fibril->tcb);
    284285
    285286        return (fid_t) fibril;
     
    298299        fibril_t *fibril = (fibril_t *) fid;
    299300       
    300         free(fibril->stack);
     301        as_area_destroy(fibril->stack);
    301302        fibril_teardown(fibril);
    302303}
  • uspace/lib/c/generic/thread.c

    ra7f7ed12 r1f7753a  
    3939#include <abi/proc/uarg.h>
    4040#include <fibril.h>
     41#include <stack.h>
    4142#include <str.h>
    4243#include <async.h>
     
    4445#include <as.h>
    4546#include "private/thread.h"
    46 
    47 #ifndef THREAD_INITIAL_STACK_PAGES
    48         #define THREAD_INITIAL_STACK_PAGES  2
    49 #endif
    5047
    5148/** Main thread function.
     
    10198                return ENOMEM;
    10299       
    103         size_t stack_size = getpagesize() * THREAD_INITIAL_STACK_PAGES;
     100        size_t stack_size = stack_size_get();
    104101        void *stack = as_area_create(AS_AREA_ANY, stack_size,
    105             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
     102            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
     103            AS_AREA_LATE_RESERVE);
    106104        if (stack == AS_MAP_FAILED) {
    107105                free(uarg);
Note: See TracChangeset for help on using the changeset viewer.