Changes in / [0c968a17:aa7dc64] in mainline


Ignore:
Files:
3 added
37 edited

Legend:

Unmodified
Added
Removed

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

    r0c968a17 raa7dc64  
    557557        entry_hi_t hi, hi_save;
    558558        tlb_index_t index;
    559        
    560         if (asid == ASID_INVALID)
    561                 return;
     559
     560        ASSERT(asid != ASID_INVALID);
    562561
    563562        hi_save.value = cp0_entry_hi_read();

  • kernel/generic/include/mm/as.h

    r0c968a17 raa7dc64  
    115115       
    116116        /**
    117          * Number of processors on which this
    118          * address space is active. Protected by
    119          * asidlock.
     117         * Number of processors on wich is this address space active.
     118         * Protected by asidlock.
    120119         */
    121120        size_t cpu_refcount;
    122121       
    123         /** Address space identifier.
    124          *
    125          * Constant on architectures that do not
    126          * support ASIDs. Protected by asidlock.
    127          *
     122        /**
     123         * Address space identifier.
     124         * Constant on architectures that do not support ASIDs.
     125         * Protected by asidlock.
    128126         */
    129127        asid_t asid;
    130128       
    131         /** Number of references (i.e. tasks that reference this as). */
     129        /** Number of references (i.e tasks that reference this as). */
    132130        atomic_t refcount;
    133131       
    … …  
    201199typedef struct {
    202200        mutex_t lock;
    203        
    204201        /** Containing address space. */
    205202        as_t *as;
    206203       
    207         /** Memory flags. */
     204        /**
     205         * Flags related to the memory represented by the address space area.
     206         */
    208207        unsigned int flags;
    209208       
    210         /** Address space area attributes. */
     209        /** Attributes related to the address space area itself. */
    211210        unsigned int attributes;
    212        
    213         /** Number of pages in the area. */
     211        /** Size of this area in multiples of PAGE_SIZE. */
    214212        size_t pages;
    215        
    216         /** Number of resident pages in the area. */
    217         size_t resident;
    218        
    219213        /** Base address of this area. */
    220214        uintptr_t base;
    221        
    222215        /** Map of used space. */
    223216        btree_t used_space;
    224217       
    225218        /**
    226          * If the address space area is shared. this is
    227          * a reference to the share info structure.
     219         * If the address space area has been shared, this pointer will
     220         * reference the share info structure.
    228221         */
    229222        share_info_t *sh_info;
    … …  
    268261extern bool as_area_check_access(as_area_t *, pf_access_t);
    269262extern size_t as_area_get_size(uintptr_t);
    270 extern bool used_space_insert(as_area_t *, uintptr_t, size_t);
    271 extern bool used_space_remove(as_area_t *, uintptr_t, size_t);
     263extern int used_space_insert(as_area_t *, uintptr_t, size_t);
     264extern int used_space_remove(as_area_t *, uintptr_t, size_t);
     265
    272266
    273267/* Interface to be implemented by architectures. */
    … …  
    313307extern sysarg_t sys_as_area_change_flags(uintptr_t, unsigned int);
    314308extern sysarg_t sys_as_area_destroy(uintptr_t);
    315 extern sysarg_t sys_as_get_unmapped_area(uintptr_t, size_t);
    316309
    317310/* Introspection functions. */

  • kernel/generic/include/syscall/syscall.h

    r0c968a17 raa7dc64  
    5959        SYS_AS_AREA_CHANGE_FLAGS,
    6060        SYS_AS_AREA_DESTROY,
    61         SYS_AS_GET_UNMAPPED_AREA,
    6261       
    6362        SYS_IPC_CALL_SYNC_FAST,

  • kernel/generic/src/mm/as.c

    r0c968a17 raa7dc64  
    7171#include <memstr.h>
    7272#include <macros.h>
    73 #include <bitops.h>
    7473#include <arch.h>
    7574#include <errno.h>
    … …  
    8786 * Each architecture decides what functions will be used to carry out
    8887 * address space operations such as creating or locking page tables.
     88 *
    8989 */
    9090as_operations_t *as_operations = NULL;
    9191
    92 /** Slab for as_t objects.
     92/**
     93 * Slab for as_t objects.
    9394 *
    9495 */
    9596static slab_cache_t *as_slab;
    9697
    97 /** ASID subsystem lock.
    98  *
    99  * This lock protects:
     98/**
     99 * This lock serializes access to the ASID subsystem.
     100 * It protects:
    100101 * - inactive_as_with_asid_head list
    101102 * - as->asid for each as of the as_t type
    … …  
    106107
    107108/**
    108  * Inactive address spaces (on all processors)
    109  * that have valid ASID.
     109 * This list contains address spaces that are not active on any
     110 * processor and that have valid ASID.
     111 *
    110112 */
    111113LIST_INITIALIZE(inactive_as_with_asid_head);
    … …  
    121123        mutex_initialize(&as->lock, MUTEX_PASSIVE);
    122124       
    123         return as_constructor_arch(as, flags);
     125        int rc = as_constructor_arch(as, flags);
     126       
     127        return rc;
    124128}
    125129
    126130NO_TRACE static size_t as_destructor(void *obj)
    127131{
    128         return as_destructor_arch((as_t *) obj);
     132        as_t *as = (as_t *) obj;
     133        return as_destructor_arch(as);
    129134}
    130135
    … …  
    141146                panic("Cannot create kernel address space.");
    142147       
    143         /*
    144          * Make sure the kernel address space
     148        /* Make sure the kernel address space
    145149         * reference count never drops to zero.
    146150         */
    … …  
    191195{
    192196        DEADLOCK_PROBE_INIT(p_asidlock);
    193        
     197
    194198        ASSERT(as != AS);
    195199        ASSERT(atomic_get(&as->refcount) == 0);
    … …  
    199203         * lock its mutex.
    200204         */
    201        
     205
    202206        /*
    203207         * We need to avoid deadlock between TLB shootdown and asidlock.
    … …  
    206210         * disabled to prevent nested context switches. We also depend on the
    207211         * fact that so far no spinlocks are held.
     212         *
    208213         */
    209214        preemption_disable();
    … …  
    230235        spinlock_unlock(&asidlock);
    231236        interrupts_restore(ipl);
    232        
     237
    233238       
    234239        /*
    … …  
    236241         * The B+tree must be walked carefully because it is
    237242         * also being destroyed.
     243         *
    238244         */
    239245        bool cond = true;
    … …  
    262268/** Hold a reference to an address space.
    263269 *
    264  * Holding a reference to an address space prevents destruction
    265  * of that address space.
     270 * Holding a reference to an address space prevents destruction of that address
     271 * space.
    266272 *
    267273 * @param as Address space to be held.
    … …  
    275281/** Release a reference to an address space.
    276282 *
    277  * The last one to release a reference to an address space
    278  * destroys the address space.
     283 * The last one to release a reference to an address space destroys the address
     284 * space.
    279285 *
    280286 * @param asAddress space to be released.
    … …  
    289295/** Check area conflicts with other areas.
    290296 *
    291  * @param as    Address space.
    292  * @param addr  Starting virtual address of the area being tested.
    293  * @param count Number of pages in the area being tested.
    294  * @param avoid Do not touch this area.
     297 * @param as         Address space.
     298 * @param va         Starting virtual address of the area being tested.
     299 * @param size       Size of the area being tested.
     300 * @param avoid_area Do not touch this area.
    295301 *
    296302 * @return True if there is no conflict, false otherwise.
    297303 *
    298304 */
    299 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr,
    300     size_t count, as_area_t *avoid)
    301 {
    302         ASSERT((addr % PAGE_SIZE) == 0);
     305NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
     306    as_area_t *avoid_area)
     307{
    303308        ASSERT(mutex_locked(&as->lock));
    304309       
    305310        /*
    306311         * We don't want any area to have conflicts with NULL page.
    307          */
    308         if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
     312         *
     313         */
     314        if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))
    309315                return false;
    310316       
    … …  
    315321         * record in the left neighbour, the leftmost record in the right
    316322         * neighbour and all records in the leaf node itself.
     323         *
    317324         */
    318325        btree_node_t *leaf;
    319326        as_area_t *area =
    320             (as_area_t *) btree_search(&as->as_area_btree, addr, &leaf);
     327            (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
    321328        if (area) {
    322                 if (area != avoid)
     329                if (area != avoid_area)
    323330                        return false;
    324331        }
    … …  
    330337                area = (as_area_t *) node->value[node->keys - 1];
    331338               
    332                 if (area != avoid) {
    333                         mutex_lock(&area->lock);
    334                        
    335                         if (overlaps(addr, count << PAGE_WIDTH,
    336                             area->base, area->pages << PAGE_WIDTH)) {
    337                                 mutex_unlock(&area->lock);
    338                                 return false;
    339                         }
    340                        
     339                mutex_lock(&area->lock);
     340               
     341                if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
    341342                        mutex_unlock(&area->lock);
     343                        return false;
    342344                }
     345               
     346                mutex_unlock(&area->lock);
    343347        }
    344348       
    … …  
    347351                area = (as_area_t *) node->value[0];
    348352               
    349                 if (area != avoid) {
    350                         mutex_lock(&area->lock);
    351                        
    352                         if (overlaps(addr, count << PAGE_WIDTH,
    353                             area->base, area->pages << PAGE_WIDTH)) {
    354                                 mutex_unlock(&area->lock);
    355                                 return false;
    356                         }
    357                        
     353                mutex_lock(&area->lock);
     354               
     355                if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
    358356                        mutex_unlock(&area->lock);
     357                        return false;
    359358                }
     359               
     360                mutex_unlock(&area->lock);
    360361        }
    361362       
    … …  
    365366                area = (as_area_t *) leaf->value[i];
    366367               
    367                 if (area == avoid)
     368                if (area == avoid_area)
    368369                        continue;
    369370               
    370371                mutex_lock(&area->lock);
    371372               
    372                 if (overlaps(addr, count << PAGE_WIDTH,
    373                     area->base, area->pages << PAGE_WIDTH)) {
     373                if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
    374374                        mutex_unlock(&area->lock);
    375375                        return false;
    … …  
    382382         * So far, the area does not conflict with other areas.
    383383         * Check if it doesn't conflict with kernel address space.
     384         *
    384385         */
    385386        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    386                 return !overlaps(addr, count << PAGE_WIDTH,
     387                return !overlaps(va, size,
    387388                    KERNEL_ADDRESS_SPACE_START,
    388389                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
    … …  
    411412    mem_backend_data_t *backend_data)
    412413{
    413         if ((base % PAGE_SIZE) != 0)
     414        if (base % PAGE_SIZE)
    414415                return NULL;
    415416       
    416         if (size == 0)
     417        if (!size)
    417418                return NULL;
    418        
    419         size_t pages = SIZE2FRAMES(size);
    420419       
    421420        /* Writeable executable areas are not supported. */
    … …  
    425424        mutex_lock(&as->lock);
    426425       
    427         if (!check_area_conflicts(as, base, pages, NULL)) {
     426        if (!check_area_conflicts(as, base, size, NULL)) {
    428427                mutex_unlock(&as->lock);
    429428                return NULL;
    … …  
    437436        area->flags = flags;
    438437        area->attributes = attrs;
    439         area->pages = pages;
    440         area->resident = 0;
     438        area->pages = SIZE2FRAMES(size);
    441439        area->base = base;
    442440        area->sh_info = NULL;
    … …  
    481479         * to find out whether this is a miss or va belongs to an address
    482480         * space area found there.
     481         *
    483482         */
    484483       
    … …  
    491490                mutex_lock(&area->lock);
    492491               
    493                 if ((area->base <= va) &&
    494                     (va < area->base + (area->pages << PAGE_WIDTH)))
     492                if ((area->base <= va) && (va < area->base + area->pages * PAGE_SIZE))
    495493                        return area;
    496494               
    … …  
    501499         * Second, locate the left neighbour and test its last record.
    502500         * Because of its position in the B+tree, it must have base < va.
     501         *
    503502         */
    504503        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
    … …  
    508507                mutex_lock(&area->lock);
    509508               
    510                 if (va < area->base + (area->pages << PAGE_WIDTH))
     509                if (va < area->base + area->pages * PAGE_SIZE)
    511510                        return area;
    512511               
    … …  
    535534        /*
    536535         * Locate the area.
     536         *
    537537         */
    538538        as_area_t *area = find_area_and_lock(as, address);
    … …  
    546546                 * Remapping of address space areas associated
    547547                 * with memory mapped devices is not supported.
     548                 *
    548549                 */
    549550                mutex_unlock(&area->lock);
    … …  
    556557                 * Remapping of shared address space areas
    557558                 * is not supported.
     559                 *
    558560                 */
    559561                mutex_unlock(&area->lock);
    … …  
    566568                /*
    567569                 * Zero size address space areas are not allowed.
     570                 *
    568571                 */
    569572                mutex_unlock(&area->lock);
    … …  
    573576       
    574577        if (pages < area->pages) {
    575                 uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
     578                uintptr_t start_free = area->base + pages * PAGE_SIZE;
    576579               
    577580                /*
    578581                 * Shrinking the area.
    579582                 * No need to check for overlaps.
     583                 *
    580584                 */
    581585               
    … …  
    584588                /*
    585589                 * Start TLB shootdown sequence.
     590                 *
    586591                 */
    587592                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    588                     area->base + (pages << PAGE_WIDTH), area->pages - pages);
     593                    area->base + pages * PAGE_SIZE, area->pages - pages);
    589594               
    590595                /*
    … …  
    594599                 * is also the right way to remove part of the used_space
    595600                 * B+tree leaf list.
     601                 *
    596602                 */
    597603                bool cond = true;
    … …  
    609615                                size_t i = 0;
    610616                               
    611                                 if (overlaps(ptr, size << PAGE_WIDTH, area->base,
    612                                     pages << PAGE_WIDTH)) {
     617                                if (overlaps(ptr, size * PAGE_SIZE, area->base,
     618                                    pages * PAGE_SIZE)) {
    613619                                       
    614                                         if (ptr + (size << PAGE_WIDTH) <= start_free) {
     620                                        if (ptr + size * PAGE_SIZE <= start_free) {
    615621                                                /*
    616622                                                 * The whole interval fits
    617623                                                 * completely in the resized
    618624                                                 * address space area.
     625                                                 *
    619626                                                 */
    620627                                                break;
    … …  
    625632                                         * to b and c overlaps with the resized
    626633                                         * address space area.
     634                                         *
    627635                                         */
    628636                                       
    … …  
    644652                                for (; i < size; i++) {
    645653                                        pte_t *pte = page_mapping_find(as, ptr +
    646                                             (i << PAGE_WIDTH));
     654                                            i * PAGE_SIZE);
    647655                                       
    648656                                        ASSERT(pte);
    … …  
    653661                                            (area->backend->frame_free)) {
    654662                                                area->backend->frame_free(area,
    655                                                     ptr + (i << PAGE_WIDTH),
     663                                                    ptr + i * PAGE_SIZE,
    656664                                                    PTE_GET_FRAME(pte));
    657665                                        }
    658666                                       
    659667                                        page_mapping_remove(as, ptr +
    660                                             (i << PAGE_WIDTH));
     668                                            i * PAGE_SIZE);
    661669                                }
    662670                        }
    … …  
    665673                /*
    666674                 * Finish TLB shootdown sequence.
    667                  */
    668                
    669                 tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
     675                 *
     676                 */
     677               
     678                tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,
    670679                    area->pages - pages);
    671680               
    672681                /*
    673682                 * Invalidate software translation caches (e.g. TSB on sparc64).
     683                 *
    674684                 */
    675685                as_invalidate_translation_cache(as, area->base +
    676                     (pages << PAGE_WIDTH), area->pages - pages);
     686                    pages * PAGE_SIZE, area->pages - pages);
    677687                tlb_shootdown_finalize(ipl);
    678688               
    … …  
    682692                 * Growing the area.
    683693                 * Check for overlaps with other address space areas.
    684                  */
    685                 if (!check_area_conflicts(as, address, pages, area)) {
     694                 *
     695                 */
     696                if (!check_area_conflicts(as, address, pages * PAGE_SIZE,
     697                    area)) {
    686698                        mutex_unlock(&area->lock);
    687699                        mutex_unlock(&as->lock);
    … …  
    782794                       
    783795                        for (size = 0; size < (size_t) node->value[i]; size++) {
    784                                 pte_t *pte =
    785                                     page_mapping_find(as, ptr + (size << PAGE_WIDTH));
     796                                pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE);
    786797                               
    787798                                ASSERT(pte);
    … …  
    792803                                    (area->backend->frame_free)) {
    793804                                        area->backend->frame_free(area,
    794                                             ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
     805                                            ptr + size * PAGE_SIZE, PTE_GET_FRAME(pte));
    795806                                }
    796807                               
    797                                 page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
     808                                page_mapping_remove(as, ptr + size * PAGE_SIZE);
    798809                        }
    799810                }
    … …  
    802813        /*
    803814         * Finish TLB shootdown sequence.
     815         *
    804816         */
    805817       
    … …  
    809821         * Invalidate potential software translation caches (e.g. TSB on
    810822         * sparc64).
     823         *
    811824         */
    812825        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    826839        /*
    827840         * Remove the empty area from address space.
     841         *
    828842         */
    829843        btree_remove(&as->as_area_btree, base, NULL);
    … …  
    867881                /*
    868882                 * Could not find the source address space area.
     883                 *
    869884                 */
    870885                mutex_unlock(&src_as->lock);
    … …  
    876891                 * There is no backend or the backend does not
    877892                 * know how to share the area.
     893                 *
    878894                 */
    879895                mutex_unlock(&src_area->lock);
    … …  
    882898        }
    883899       
    884         size_t src_size = src_area->pages << PAGE_WIDTH;
     900        size_t src_size = src_area->pages * PAGE_SIZE;
    885901        unsigned int src_flags = src_area->flags;
    886902        mem_backend_t *src_backend = src_area->backend;
    … …  
    902918         * First, prepare the area for sharing.
    903919         * Then it will be safe to unlock it.
     920         *
    904921         */
    905922        share_info_t *sh_info = src_area->sh_info;
    … …  
    913930                /*
    914931                 * Call the backend to setup sharing.
     932                 *
    915933                 */
    916934                src_area->backend->share(src_area);
    … …  
    931949         * The flags of the source area are masked against dst_flags_mask
    932950         * to support sharing in less privileged mode.
     951         *
    933952         */
    934953        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size,
    … …  
    947966         * fully initialized. Clear the AS_AREA_ATTR_PARTIAL
    948967         * attribute and set the sh_info.
     968         *
    949969         */
    950970        mutex_lock(&dst_as->lock);
    … …  
    969989NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
    970990{
    971         ASSERT(mutex_locked(&area->lock));
    972        
    973991        int flagmap[] = {
    974992                [PF_ACCESS_READ] = AS_AREA_READ,
    … …  
    976994                [PF_ACCESS_EXEC] = AS_AREA_EXEC
    977995        };
     996
     997        ASSERT(mutex_locked(&area->lock));
    978998       
    979999        if (!(area->flags & flagmap[access]))
    … …  
    10461066        /*
    10471067         * Compute total number of used pages in the used_space B+tree
     1068         *
    10481069         */
    10491070        size_t used_pages = 0;
    … …  
    10671088        /*
    10681089         * Start TLB shootdown sequence.
     1090         *
    10691091         */
    10701092        ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base,
    … …  
    10741096         * Remove used pages from page tables and remember their frame
    10751097         * numbers.
     1098         *
    10761099         */
    10771100        size_t frame_idx = 0;
    … …  
    10881111                       
    10891112                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1090                                 pte_t *pte =
    1091                                     page_mapping_find(as, ptr + (size << PAGE_WIDTH));
     1113                                pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE);
    10921114                               
    10931115                                ASSERT(pte);
    … …  
    10981120                               
    10991121                                /* Remove old mapping */
    1100                                 page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
     1122                                page_mapping_remove(as, ptr + size * PAGE_SIZE);
    11011123                        }
    11021124                }
    … …  
    11051127        /*
    11061128         * Finish TLB shootdown sequence.
     1129         *
    11071130         */
    11081131       
    … …  
    11121135         * Invalidate potential software translation caches (e.g. TSB on
    11131136         * sparc64).
     1137         *
    11141138         */
    11151139        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    11441168                               
    11451169                                /* Insert the new mapping */
    1146                                 page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
     1170                                page_mapping_insert(as, ptr + size * PAGE_SIZE,
    11471171                                    old_frame[frame_idx++], page_flags);
    11481172                               
    … …  
    11931217                 * No area contained mapping for 'page'.
    11941218                 * Signal page fault to low-level handler.
     1219                 *
    11951220                 */
    11961221                mutex_unlock(&AS->lock);
    … …  
    12121237                 * The address space area is not backed by any backend
    12131238                 * or the backend cannot handle page faults.
     1239                 *
    12141240                 */
    12151241                mutex_unlock(&area->lock);
    … …  
    12231249         * To avoid race condition between two page faults on the same address,
    12241250         * we need to make sure the mapping has not been already inserted.
     1251         *
    12251252         */
    12261253        pte_t *pte;
    … …  
    12401267        /*
    12411268         * Resort to the backend page fault handler.
     1269         *
    12421270         */
    12431271        if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
    … …  
    12941322                 * preemption is disabled. We should not be
    12951323                 * holding any other lock.
     1324                 *
    12961325                 */
    12971326                (void) interrupts_enable();
    … …  
    13131342                         * list of inactive address spaces with assigned
    13141343                         * ASID.
     1344                         *
    13151345                         */
    13161346                        ASSERT(old_as->asid != ASID_INVALID);
    … …  
    13231353                 * Perform architecture-specific tasks when the address space
    13241354                 * is being removed from the CPU.
     1355                 *
    13251356                 */
    13261357                as_deinstall_arch(old_as);
    … …  
    13291360        /*
    13301361         * Second, prepare the new address space.
     1362         *
    13311363         */
    13321364        if ((new_as->cpu_refcount++ == 0) && (new_as != AS_KERNEL)) {
    … …  
    13441376         * Perform architecture-specific steps.
    13451377         * (e.g. write ASID to hardware register etc.)
     1378         *
    13461379         */
    13471380        as_install_arch(new_as);
    … …  
    13621395{
    13631396        ASSERT(mutex_locked(&area->lock));
    1364        
     1397
    13651398        return area_flags_to_page_flags(area->flags);
    13661399}
    … …  
    14661499       
    14671500        if (src_area) {
    1468                 size = src_area->pages << PAGE_WIDTH;
     1501                size = src_area->pages * PAGE_SIZE;
    14691502                mutex_unlock(&src_area->lock);
    14701503        } else
    … …  
    14831516 * @param count Number of page to be marked.
    14841517 *
    1485  * @return False on failure or true on success.
    1486  *
    1487  */
    1488 bool used_space_insert(as_area_t *area, uintptr_t page, size_t count)
     1518 * @return Zero on failure and non-zero on success.
     1519 *
     1520 */
     1521int used_space_insert(as_area_t *area, uintptr_t page, size_t count)
    14891522{
    14901523        ASSERT(mutex_locked(&area->lock));
    … …  
    14971530                /*
    14981531                 * We hit the beginning of some used space.
    1499                  */
    1500                 return false;
     1532                 *
     1533                 */
     1534                return 0;
    15011535        }
    15021536       
    15031537        if (!leaf->keys) {
    15041538                btree_insert(&area->used_space, page, (void *) count, leaf);
    1505                 goto success;
     1539                return 1;
    15061540        }
    15071541       
    … …  
    15171551                 * somewhere between the rightmost interval of
    15181552                 * the left neigbour and the first interval of the leaf.
     1553                 *
    15191554                 */
    15201555               
    15211556                if (page >= right_pg) {
    15221557                        /* Do nothing. */
    1523                 } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1524                     left_cnt << PAGE_WIDTH)) {
     1558                } else if (overlaps(page, count * PAGE_SIZE, left_pg,
     1559                    left_cnt * PAGE_SIZE)) {
    15251560                        /* The interval intersects with the left interval. */
    1526                         return false;
    1527                 } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1528                     right_cnt << PAGE_WIDTH)) {
     1561                        return 0;
     1562                } else if (overlaps(page, count * PAGE_SIZE, right_pg,
     1563                    right_cnt * PAGE_SIZE)) {
    15291564                        /* The interval intersects with the right interval. */
    1530                         return false;
    1531                 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1532                     (page + (count << PAGE_WIDTH) == right_pg)) {
     1565                        return 0;
     1566                } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
     1567                    (page + count * PAGE_SIZE == right_pg)) {
    15331568                        /*
    15341569                         * The interval can be added by merging the two already
    15351570                         * present intervals.
     1571                         *
    15361572                         */
    15371573                        node->value[node->keys - 1] += count + right_cnt;
    15381574                        btree_remove(&area->used_space, right_pg, leaf);
    1539                         goto success;
    1540                 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1575                        return 1;
     1576                } else if (page == left_pg + left_cnt * PAGE_SIZE) {
    15411577                        /*
    15421578                         * The interval can be added by simply growing the left
    15431579                         * interval.
     1580                         *
    15441581                         */
    15451582                        node->value[node->keys - 1] += count;
    1546                         goto success;
    1547                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1583                        return 1;
     1584                } else if (page + count * PAGE_SIZE == right_pg) {
    15481585                        /*
    15491586                         * The interval can be addded by simply moving base of
    15501587                         * the right interval down and increasing its size
    15511588                         * accordingly.
     1589                         *
    15521590                         */
    15531591                        leaf->value[0] += count;
    15541592                        leaf->key[0] = page;
    1555                         goto success;
     1593                        return 1;
    15561594                } else {
    15571595                        /*
    15581596                         * The interval is between both neigbouring intervals,
    15591597                         * but cannot be merged with any of them.
     1598                         *
    15601599                         */
    15611600                        btree_insert(&area->used_space, page, (void *) count,
    15621601                            leaf);
    1563                         goto success;
     1602                        return 1;
    15641603                }
    15651604        } else if (page < leaf->key[0]) {
    … …  
    15701609                 * Investigate the border case in which the left neighbour does
    15711610                 * not exist but the interval fits from the left.
    1572                  */
    1573                
    1574                 if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1575                     right_cnt << PAGE_WIDTH)) {
     1611                 *
     1612                 */
     1613               
     1614                if (overlaps(page, count * PAGE_SIZE, right_pg,
     1615                    right_cnt * PAGE_SIZE)) {
    15761616                        /* The interval intersects with the right interval. */
    1577                         return false;
    1578                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1617                        return 0;
     1618                } else if (page + count * PAGE_SIZE == right_pg) {
    15791619                        /*
    15801620                         * The interval can be added by moving the base of the
    15811621                         * right interval down and increasing its size
    15821622                         * accordingly.
     1623                         *
    15831624                         */
    15841625                        leaf->key[0] = page;
    15851626                        leaf->value[0] += count;
    1586                         goto success;
     1627                        return 1;
    15871628                } else {
    15881629                        /*
    15891630                         * The interval doesn't adjoin with the right interval.
    15901631                         * It must be added individually.
     1632                         *
    15911633                         */
    15921634                        btree_insert(&area->used_space, page, (void *) count,
    15931635                            leaf);
    1594                         goto success;
     1636                        return 1;
    15951637                }
    15961638        }
    … …  
    16071649                 * somewhere between the leftmost interval of
    16081650                 * the right neigbour and the last interval of the leaf.
     1651                 *
    16091652                 */
    16101653               
    16111654                if (page < left_pg) {
    16121655                        /* Do nothing. */
    1613                 } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1614                     left_cnt << PAGE_WIDTH)) {
     1656                } else if (overlaps(page, count * PAGE_SIZE, left_pg,
     1657                    left_cnt * PAGE_SIZE)) {
    16151658                        /* The interval intersects with the left interval. */
    1616                         return false;
    1617                 } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1618                     right_cnt << PAGE_WIDTH)) {
     1659                        return 0;
     1660                } else if (overlaps(page, count * PAGE_SIZE, right_pg,
     1661                    right_cnt * PAGE_SIZE)) {
    16191662                        /* The interval intersects with the right interval. */
    1620                         return false;
    1621                 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1622                     (page + (count << PAGE_WIDTH) == right_pg)) {
     1663                        return 0;
     1664                } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
     1665                    (page + count * PAGE_SIZE == right_pg)) {
    16231666                        /*
    16241667                         * The interval can be added by merging the two already
    16251668                         * present intervals.
     1669                         *
    16261670                         */
    16271671                        leaf->value[leaf->keys - 1] += count + right_cnt;
    16281672                        btree_remove(&area->used_space, right_pg, node);
    1629                         goto success;
    1630                 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1673                        return 1;
     1674                } else if (page == left_pg + left_cnt * PAGE_SIZE) {
    16311675                        /*
    16321676                         * The interval can be added by simply growing the left
    16331677                         * interval.
     1678                         *
    16341679                         */
    1635                         leaf->value[leaf->keys - 1] += count;
    1636                         goto success;
    1637                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1680                        leaf->value[leaf->keys - 1] +=  count;
     1681                        return 1;
     1682                } else if (page + count * PAGE_SIZE == right_pg) {
    16381683                        /*
    16391684                         * The interval can be addded by simply moving base of
    16401685                         * the right interval down and increasing its size
    16411686                         * accordingly.
     1687                         *
    16421688                         */
    16431689                        node->value[0] += count;
    16441690                        node->key[0] = page;
    1645                         goto success;
     1691                        return 1;
    16461692                } else {
    16471693                        /*
    16481694                         * The interval is between both neigbouring intervals,
    16491695                         * but cannot be merged with any of them.
     1696                         *
    16501697                         */
    16511698                        btree_insert(&area->used_space, page, (void *) count,
    16521699                            leaf);
    1653                         goto success;
     1700                        return 1;
    16541701                }
    16551702        } else if (page >= leaf->key[leaf->keys - 1]) {
    … …  
    16601707                 * Investigate the border case in which the right neighbour
    16611708                 * does not exist but the interval fits from the right.
    1662                  */
    1663                
    1664                 if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1665                     left_cnt << PAGE_WIDTH)) {
     1709                 *
     1710                 */
     1711               
     1712                if (overlaps(page, count * PAGE_SIZE, left_pg,
     1713                    left_cnt * PAGE_SIZE)) {
    16661714                        /* The interval intersects with the left interval. */
    1667                         return false;
    1668                 } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
     1715                        return 0;
     1716                } else if (left_pg + left_cnt * PAGE_SIZE == page) {
    16691717                        /*
    16701718                         * The interval can be added by growing the left
    16711719                         * interval.
     1720                         *
    16721721                         */
    16731722                        leaf->value[leaf->keys - 1] += count;
    1674                         goto success;
     1723                        return 1;
    16751724                } else {
    16761725                        /*
    16771726                         * The interval doesn't adjoin with the left interval.
    16781727                         * It must be added individually.
     1728                         *
    16791729                         */
    16801730                        btree_insert(&area->used_space, page, (void *) count,
    16811731                            leaf);
    1682                         goto success;
     1732                        return 1;
    16831733                }
    16841734        }
    … …  
    16881738         * only between two other intervals of the leaf. The two border cases
    16891739         * were already resolved.
     1740         *
    16901741         */
    16911742        btree_key_t i;
    … …  
    16991750                        /*
    17001751                         * The interval fits between left_pg and right_pg.
     1752                         *
    17011753                         */
    17021754                       
    1703                         if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1704                             left_cnt << PAGE_WIDTH)) {
     1755                        if (overlaps(page, count * PAGE_SIZE, left_pg,
     1756                            left_cnt * PAGE_SIZE)) {
    17051757                                /*
    17061758                                 * The interval intersects with the left
    17071759                                 * interval.
     1760                                 *
    17081761                                 */
    1709                                 return false;
    1710                         } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1711                             right_cnt << PAGE_WIDTH)) {
     1762                                return 0;
     1763                        } else if (overlaps(page, count * PAGE_SIZE, right_pg,
     1764                            right_cnt * PAGE_SIZE)) {
    17121765                                /*
    17131766                                 * The interval intersects with the right
    17141767                                 * interval.
     1768                                 *
    17151769                                 */
    1716                                 return false;
    1717                         } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1718                             (page + (count << PAGE_WIDTH) == right_pg)) {
     1770                                return 0;
     1771                        } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
     1772                            (page + count * PAGE_SIZE == right_pg)) {
    17191773                                /*
    17201774                                 * The interval can be added by merging the two
    17211775                                 * already present intervals.
     1776                                 *
    17221777                                 */
    17231778                                leaf->value[i - 1] += count + right_cnt;
    17241779                                btree_remove(&area->used_space, right_pg, leaf);
    1725                                 goto success;
    1726                         } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1780                                return 1;
     1781                        } else if (page == left_pg + left_cnt * PAGE_SIZE) {
    17271782                                /*
    17281783                                 * The interval can be added by simply growing
    17291784                                 * the left interval.
     1785                                 *
    17301786                                 */
    17311787                                leaf->value[i - 1] += count;
    1732                                 goto success;
    1733                         } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1788                                return 1;
     1789                        } else if (page + count * PAGE_SIZE == right_pg) {
    17341790                                /*
    17351791                                 * The interval can be addded by simply moving
    17361792                                 * base of the right interval down and
    17371793                                 * increasing its size accordingly.
     1794                                 *
    17381795                                 */
    17391796                                leaf->value[i] += count;
    17401797                                leaf->key[i] = page;
    1741                                 goto success;
     1798                                return 1;
    17421799                        } else {
    17431800                                /*
    … …  
    17451802                                 * intervals, but cannot be merged with any of
    17461803                                 * them.
     1804                                 *
    17471805                                 */
    17481806                                btree_insert(&area->used_space, page,
    17491807                                    (void *) count, leaf);
    1750                                 goto success;
     1808                                return 1;
    17511809                        }
    17521810                }
    … …  
    17551813        panic("Inconsistency detected while adding %zu pages of used "
    17561814            "space at %p.", count, (void *) page);
    1757        
    1758 success:
    1759         area->resident += count;
    1760         return true;
    17611815}
    17621816
    … …  
    17691823 * @param count Number of page to be marked.
    17701824 *
    1771  * @return False on failure or true on success.
    1772  *
    1773  */
    1774 bool used_space_remove(as_area_t *area, uintptr_t page, size_t count)
     1825 * @return Zero on failure and non-zero on success.
     1826 *
     1827 */
     1828int used_space_remove(as_area_t *area, uintptr_t page, size_t count)
    17751829{
    17761830        ASSERT(mutex_locked(&area->lock));
    … …  
    17831837                /*
    17841838                 * We are lucky, page is the beginning of some interval.
     1839                 *
    17851840                 */
    17861841                if (count > pages) {
    1787                         return false;
     1842                        return 0;
    17881843                } else if (count == pages) {
    17891844                        btree_remove(&area->used_space, page, leaf);
    1790                         goto success;
     1845                        return 1;
    17911846                } else {
    17921847                        /*
    17931848                         * Find the respective interval.
    17941849                         * Decrease its size and relocate its start address.
     1850                         *
    17951851                         */
    17961852                        btree_key_t i;
    17971853                        for (i = 0; i < leaf->keys; i++) {
    17981854                                if (leaf->key[i] == page) {
    1799                                         leaf->key[i] += count << PAGE_WIDTH;
     1855                                        leaf->key[i] += count * PAGE_SIZE;
    18001856                                        leaf->value[i] -= count;
    1801                                         goto success;
     1857                                        return 1;
    18021858                                }
    18031859                        }
    1804                        
    18051860                        goto error;
    18061861                }
    … …  
    18121867                size_t left_cnt = (size_t) node->value[node->keys - 1];
    18131868               
    1814                 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
    1815                     count << PAGE_WIDTH)) {
    1816                         if (page + (count << PAGE_WIDTH) ==
    1817                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1869                if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
     1870                    count * PAGE_SIZE)) {
     1871                        if (page + count * PAGE_SIZE ==
     1872                            left_pg + left_cnt * PAGE_SIZE) {
    18181873                                /*
    18191874                                 * The interval is contained in the rightmost
    … …  
    18211876                                 * removed by updating the size of the bigger
    18221877                                 * interval.
     1878                                 *
    18231879                                 */
    18241880                                node->value[node->keys - 1] -= count;
    1825                                 goto success;
    1826                         } else if (page + (count << PAGE_WIDTH) <
    1827                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1881                                return 1;
     1882                        } else if (page + count * PAGE_SIZE <
     1883                            left_pg + left_cnt*PAGE_SIZE) {
    18281884                                /*
    18291885                                 * The interval is contained in the rightmost
    … …  
    18321888                                 * the original interval and also inserting a
    18331889                                 * new interval.
     1890                                 *
    18341891                                 */
    1835                                 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
    1836                                     (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
     1892                                size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
     1893                                    (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
    18371894                                node->value[node->keys - 1] -= count + new_cnt;
    18381895                                btree_insert(&area->used_space, page +
    1839                                     (count << PAGE_WIDTH), (void *) new_cnt, leaf);
    1840                                 goto success;
     1896                                    count * PAGE_SIZE, (void *) new_cnt, leaf);
     1897                                return 1;
    18411898                        }
    18421899                }
    1843                
    1844                 return false;
     1900                return 0;
    18451901        } else if (page < leaf->key[0])
    1846                 return false;
     1902                return 0;
    18471903       
    18481904        if (page > leaf->key[leaf->keys - 1]) {
    … …  
    18501906                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    18511907               
    1852                 if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
    1853                     count << PAGE_WIDTH)) {
    1854                         if (page + (count << PAGE_WIDTH) ==
    1855                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1908                if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
     1909                    count * PAGE_SIZE)) {
     1910                        if (page + count * PAGE_SIZE ==
     1911                            left_pg + left_cnt * PAGE_SIZE) {
    18561912                                /*
    18571913                                 * The interval is contained in the rightmost
    18581914                                 * interval of the leaf and can be removed by
    18591915                                 * updating the size of the bigger interval.
     1916                                 *
    18601917                                 */
    18611918                                leaf->value[leaf->keys - 1] -= count;
    1862                                 goto success;
    1863                         } else if (page + (count << PAGE_WIDTH) < left_pg +
    1864                             (left_cnt << PAGE_WIDTH)) {
     1919                                return 1;
     1920                        } else if (page + count * PAGE_SIZE < left_pg +
     1921                            left_cnt * PAGE_SIZE) {
    18651922                                /*
    18661923                                 * The interval is contained in the rightmost
    … …  
    18691926                                 * original interval and also inserting a new
    18701927                                 * interval.
     1928                                 *
    18711929                                 */
    1872                                 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
    1873                                     (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
     1930                                size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
     1931                                    (page + count * PAGE_SIZE)) >> PAGE_WIDTH;
    18741932                                leaf->value[leaf->keys - 1] -= count + new_cnt;
    18751933                                btree_insert(&area->used_space, page +
    1876                                     (count << PAGE_WIDTH), (void *) new_cnt, leaf);
    1877                                 goto success;
     1934                                    count * PAGE_SIZE, (void *) new_cnt, leaf);
     1935                                return 1;
    18781936                        }
    18791937                }
    1880                
    1881                 return false;
     1938                return 0;
    18821939        }
    18831940       
    18841941        /*
    18851942         * The border cases have been already resolved.
    1886          * Now the interval can be only between intervals of the leaf.
     1943         * Now the interval can be only between intervals of the leaf. 
    18871944         */
    18881945        btree_key_t i;
    … …  
    18961953                         * to (i - 1) and i.
    18971954                         */
    1898                         if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
    1899                             count << PAGE_WIDTH)) {
    1900                                 if (page + (count << PAGE_WIDTH) ==
    1901                                     left_pg + (left_cnt << PAGE_WIDTH)) {
     1955                        if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
     1956                            count * PAGE_SIZE)) {
     1957                                if (page + count * PAGE_SIZE ==
     1958                                    left_pg + left_cnt*PAGE_SIZE) {
    19021959                                        /*
    19031960                                         * The interval is contained in the
    … …  
    19051962                                         * be removed by updating the size of
    19061963                                         * the bigger interval.
     1964                                         *
    19071965                                         */
    19081966                                        leaf->value[i - 1] -= count;
    1909                                         goto success;
    1910                                 } else if (page + (count << PAGE_WIDTH) <
    1911                                     left_pg + (left_cnt << PAGE_WIDTH)) {
     1967                                        return 1;
     1968                                } else if (page + count * PAGE_SIZE <
     1969                                    left_pg + left_cnt * PAGE_SIZE) {
    19121970                                        /*
    19131971                                         * The interval is contained in the
    … …  
    19181976                                         */
    19191977                                        size_t new_cnt = ((left_pg +
    1920                                             (left_cnt << PAGE_WIDTH)) -
    1921                                             (page + (count << PAGE_WIDTH))) >>
     1978                                            left_cnt * PAGE_SIZE) -
     1979                                            (page + count * PAGE_SIZE)) >>
    19221980                                            PAGE_WIDTH;
    19231981                                        leaf->value[i - 1] -= count + new_cnt;
    19241982                                        btree_insert(&area->used_space, page +
    1925                                             (count << PAGE_WIDTH), (void *) new_cnt,
     1983                                            count * PAGE_SIZE, (void *) new_cnt,
    19261984                                            leaf);
    1927                                         goto success;
     1985                                        return 1;
    19281986                                }
    19291987                        }
    1930                        
    1931                         return false;
     1988                        return 0;
    19321989                }
    19331990        }
    … …  
    19361993        panic("Inconsistency detected while removing %zu pages of used "
    19371994            "space from %p.", count, (void *) page);
    1938        
    1939 success:
    1940         area->resident -= count;
    1941         return true;
    19421995}
    19431996
    … …  
    19722025{
    19732026        return (sysarg_t) as_area_destroy(AS, address);
    1974 }
    1975 
    1976 /** Return pointer to unmapped address space area
    1977  *
    1978  * @param base Lowest address bound.
    1979  * @param size Requested size of the allocation.
    1980  *
    1981  * @return Pointer to the beginning of unmapped address space area.
    1982  *
    1983  */
    1984 sysarg_t sys_as_get_unmapped_area(uintptr_t base, size_t size)
    1985 {
    1986         if (size == 0)
    1987                 return 0;
    1988        
    1989         /*
    1990          * Make sure we allocate from page-aligned
    1991          * address. Check for possible overflow in
    1992          * each step.
    1993          */
    1994        
    1995         size_t pages = SIZE2FRAMES(size);
    1996         uintptr_t ret = 0;
    1997        
    1998         /*
    1999          * Find the lowest unmapped address aligned on the sz
    2000          * boundary, not smaller than base and of the required size.
    2001          */
    2002        
    2003         mutex_lock(&AS->lock);
    2004        
    2005         /* First check the base address itself */
    2006         uintptr_t addr = ALIGN_UP(base, PAGE_SIZE);
    2007         if ((addr >= base) &&
    2008             (check_area_conflicts(AS, addr, pages, NULL)))
    2009                 ret = addr;
    2010        
    2011         /* Eventually check the addresses behind each area */
    2012         link_t *cur;
    2013         for (cur = AS->as_area_btree.leaf_head.next;
    2014             (ret == 0) && (cur != &AS->as_area_btree.leaf_head);
    2015             cur = cur->next) {
    2016                 btree_node_t *node =
    2017                     list_get_instance(cur, btree_node_t, leaf_link);
    2018                
    2019                 btree_key_t i;
    2020                 for (i = 0; (ret == 0) && (i < node->keys); i++) {
    2021                         as_area_t *area = (as_area_t *) node->value[i];
    2022                        
    2023                         mutex_lock(&area->lock);
    2024                        
    2025                         uintptr_t addr =
    2026                             ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
    2027                             PAGE_SIZE);
    2028                        
    2029                         if ((addr >= base) && (addr >= area->base) &&
    2030                             (check_area_conflicts(AS, addr, pages, area)))
    2031                                 ret = addr;
    2032                        
    2033                         mutex_unlock(&area->lock);
    2034                 }
    2035         }
    2036        
    2037         mutex_unlock(&AS->lock);
    2038        
    2039         return (sysarg_t) ret;
    20402027}
    20412028
    … …  
    21062093        mutex_lock(&as->lock);
    21072094       
    2108         /* Print out info about address space areas */
     2095        /* print out info about address space areas */
    21092096        link_t *cur;
    21102097        for (cur = as->as_area_btree.leaf_head.next;

  • kernel/generic/src/proc/program.c

    r0c968a17 raa7dc64  
    171171        void *loader = program_loader;
    172172        if (!loader) {
    173                 as_destroy(as);
    174173                printf("Cannot spawn loader as none was registered\n");
    175174                return ENOENT;
    … …  
    180179        if (rc != EE_OK) {
    181180                as_destroy(as);
    182                 printf("Cannot spawn loader (%s)\n", elf_error(rc));
    183181                return ENOENT;
    184182        }

  • kernel/generic/src/syscall/syscall.c

    r0c968a17 raa7dc64  
    143143        (syshandler_t) sys_as_area_change_flags,
    144144        (syshandler_t) sys_as_area_destroy,
    145         (syshandler_t) sys_as_get_unmapped_area,
    146145       
    147146        /* IPC related syscalls. */

  • kernel/generic/src/sysinfo/stats.c

    r0c968a17 raa7dc64  
    160160static size_t get_task_virtmem(as_t *as)
    161161{
     162        size_t result = 0;
     163
    162164        /*
    163          * We are holding spinlocks here and therefore are not allowed to
    164          * block. Only attempt to lock the address space and address space
    165          * area mutexes conditionally. If it is not possible to lock either
    166          * object, return inexact statistics by skipping the respective object.
     165         * We are holding some spinlocks here and therefore are not allowed to
     166         * block. Only attempt to lock the address space and address space area
     167         * mutexes conditionally. If it is not possible to lock either object,
     168         * allow the statistics to be inexact by skipping the respective object.
     169         *
     170         * Note that it may be infinitely better to let the address space
     171         * management code compute these statistics as it proceeds instead of
     172         * having them calculated over and over again here.
    167173         */
    168        
     174
    169175        if (SYNCH_FAILED(mutex_trylock(&as->lock)))
    170                 return 0;
    171        
    172         size_t pages = 0;
     176                return result * PAGE_SIZE;
    173177       
    174178        /* Walk the B+ tree and count pages */
     179        link_t *cur;
     180        for (cur = as->as_area_btree.leaf_head.next;
     181            cur != &as->as_area_btree.leaf_head; cur = cur->next) {
     182                btree_node_t *node =
     183                    list_get_instance(cur, btree_node_t, leaf_link);
     184               
     185                unsigned int i;
     186                for (i = 0; i < node->keys; i++) {
     187                        as_area_t *area = node->value[i];
     188                       
     189                        if (SYNCH_FAILED(mutex_trylock(&area->lock)))
     190                                continue;
     191                        result += area->pages;
     192                        mutex_unlock(&area->lock);
     193                }
     194        }
     195       
     196        mutex_unlock(&as->lock);
     197       
     198        return result * PAGE_SIZE;
     199}
     200
     201/** Get the resident (used) size of a virtual address space
     202 *
     203 * @param as Address space.
     204 *
     205 * @return Size of the resident (used) virtual address space (bytes).
     206 *
     207 */
     208static size_t get_task_resmem(as_t *as)
     209{
     210        size_t result = 0;
     211       
     212        /*
     213         * We are holding some spinlocks here and therefore are not allowed to
     214         * block. Only attempt to lock the address space and address space area
     215         * mutexes conditionally. If it is not possible to lock either object,
     216         * allow the statistics to be inexact by skipping the respective object.
     217         *
     218         * Note that it may be infinitely better to let the address space
     219         * management code compute these statistics as it proceeds instead of
     220         * having them calculated over and over again here.
     221         */
     222       
     223        if (SYNCH_FAILED(mutex_trylock(&as->lock)))
     224                return result * PAGE_SIZE;
     225       
     226        /* Walk the B+ tree of AS areas */
    175227        link_t *cur;
    176228        for (cur = as->as_area_btree.leaf_head.next;
    … …  
    186238                                continue;
    187239                       
    188                         pages += area->pages;
     240                        /* Walk the B+ tree of resident pages */
     241                        link_t *rcur;
     242                        for (rcur = area->used_space.leaf_head.next;
     243                            rcur != &area->used_space.leaf_head; rcur = rcur->next) {
     244                                btree_node_t *rnode =
     245                                    list_get_instance(rcur, btree_node_t, leaf_link);
     246                               
     247                                unsigned int j;
     248                                for (j = 0; j < rnode->keys; j++)
     249                                        result += (size_t) rnode->value[i];
     250                        }
     251                       
    189252                        mutex_unlock(&area->lock);
    190253                }
    … …  
    193256        mutex_unlock(&as->lock);
    194257       
    195         return (pages << PAGE_WIDTH);
    196 }
    197 
    198 /** Get the resident (used) size of a virtual address space
    199  *
    200  * @param as Address space.
    201  *
    202  * @return Size of the resident (used) virtual address space (bytes).
    203  *
    204  */
    205 static size_t get_task_resmem(as_t *as)
    206 {
    207         /*
    208          * We are holding spinlocks here and therefore are not allowed to
    209          * block. Only attempt to lock the address space and address space
    210          * area mutexes conditionally. If it is not possible to lock either
    211          * object, return inexact statistics by skipping the respective object.
    212          */
    213        
    214         if (SYNCH_FAILED(mutex_trylock(&as->lock)))
    215                 return 0;
    216        
    217         size_t pages = 0;
    218        
    219         /* Walk the B+ tree and count pages */
    220         link_t *cur;
    221         for (cur = as->as_area_btree.leaf_head.next;
    222             cur != &as->as_area_btree.leaf_head; cur = cur->next) {
    223                 btree_node_t *node =
    224                     list_get_instance(cur, btree_node_t, leaf_link);
    225                
    226                 unsigned int i;
    227                 for (i = 0; i < node->keys; i++) {
    228                         as_area_t *area = node->value[i];
    229                        
    230                         if (SYNCH_FAILED(mutex_trylock(&area->lock)))
    231                                 continue;
    232                        
    233                         pages += area->resident;
    234                         mutex_unlock(&area->lock);
    235                 }
    236         }
    237        
    238         mutex_unlock(&as->lock);
    239        
    240         return (pages << PAGE_WIDTH);
     258        return result * PAGE_SIZE;
    241259}
    242260

  • uspace/app/taskdump/taskdump.c

    r0c968a17 raa7dc64  
    406406        }
    407407
    408         rc = asprintf(&file_name, "/drv/%s/%s", app_name, app_name);
    409         if (rc < 0) {
    410                 printf("Memory allocation failure.\n");
    411                 exit(1);
    412         }
    413 
    414         rc = symtab_load(file_name, &app_symtab);
    415         if (rc == EOK) {
    416                 printf("Loaded symbol table from %s\n", file_name);
    417                 free(file_name);
    418                 return;
    419         }
    420 
    421408        free(file_name);
    422409        printf("Failed autoloading symbol table.\n");

  • uspace/lib/block/libblock.c

    r0c968a17 raa7dc64  
    294294
    295295        /* Allow 1:1 or small-to-large block size translation */
    296         if (cache->lblock_size % devcon->pblock_size != 0) {
    297                 free(cache);
     296        if (cache->lblock_size % devcon->pblock_size != 0)
    298297                return ENOTSUP;
    299         }
    300298
    301299        cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
    … …  
    438436                        if (!b->data) {
    439437                                free(b);
    440                                 b = NULL;
    441438                                goto recycle;
    442439                        }
    … …  
    566563        assert(devcon);
    567564        assert(devcon->cache);
    568         assert(block->refcnt >= 1);
    569565
    570566        cache = devcon->cache;
    … …  
    626622                        unsigned long key = block->lba;
    627623                        hash_table_remove(&cache->block_hash, &key, 1);
     624                        free(block);
    628625                        free(block->data);
    629                         free(block);
    630626                        cache->blocks_cached--;
    631627                        fibril_mutex_unlock(&cache->lock);

  • uspace/lib/c/arch/abs32le/_link.ld.in

    r0c968a17 raa7dc64  
    4444        } :data
    4545       
     46        . = ALIGN(0x1000);
     47       
     48        _heap = .;
     49       
    4650        /DISCARD/ : {
    4751                *(*);

  • uspace/lib/c/arch/amd64/_link.ld.in

    r0c968a17 raa7dc64  
    4242        } :data
    4343       
     44        . = ALIGN(0x1000);
     45        _heap = .;
     46       
    4447#ifdef CONFIG_LINE_DEBUG
    4548        .comment 0 : { *(.comment); } :debug
    … …  
    5861                *(*);
    5962        }
     63
    6064}

  • uspace/lib/c/arch/arm32/_link.ld.in

    r0c968a17 raa7dc64  
    99SECTIONS {
    1010        . = 0x1000 + SIZEOF_HEADERS;
    11        
     11
    1212        .init : {
    1313                *(.init);
    14         } :text
    15        
     14        } : text
    1615        .text : {
    1716                *(.text);
    18                 *(.rodata*);
     17        *(.rodata*);
    1918        } :text
    20        
     19
    2120        . = . + 0x1000;
    22        
     21
    2322        .data : {
    2423                *(.opd);
    … …  
    2625                *(.sdata);
    2726        } :data
    28        
    2927        .tdata : {
    3028                _tdata_start = .;
    … …  
    3533                _tbss_end = .;
    3634        } :data
    37        
    3835        _tls_alignment = ALIGNOF(.tdata);
    39        
    4036        .bss : {
    4137                *(.sbss);
    4238                *(.scommon);
    43                 *(COMMON);
    44                 *(.bss);
     39        *(COMMON);
     40        *(.bss);
    4541        } :data
     42       
     43        . = ALIGN(0x1000);
     44        _heap = .;
    4645       
    4746        /DISCARD/ : {
    4847                *(*);
    4948        }
     49
    5050}

  • uspace/lib/c/arch/ia32/_link.ld.in

    r0c968a17 raa7dc64  
    4343        } :data
    4444       
     45        . = ALIGN(0x1000);
     46        _heap = .;
     47       
    4548#ifdef CONFIG_LINE_DEBUG
    4649        .comment 0 : { *(.comment); } :debug

  • uspace/lib/c/arch/ia64/_link.ld.in

    r0c968a17 raa7dc64  
    99SECTIONS {
    1010        . = 0x4000 + SIZEOF_HEADERS;
    11        
     11
    1212        .init : {
    1313                *(.init);
    14         } :text
    15        
     14        } : text
    1615        .text : {
    1716                *(.text);
    1817                *(.rodata*);
    1918        } :text
    20        
     19
    2120        . = . + 0x4000;
    22        
     21
    2322        .got : {
    2423                _gp = .;
    2524                *(.got*);
    26         } :data
    27        
     25        } :data
    2826        .data : {
    2927                *(.opd);
    … …  
    3129                *(.sdata);
    3230        } :data
    33        
    3431        .tdata : {
    3532                _tdata_start = .;
    … …  
    4037                _tbss_end = .;
    4138        } :data
    42        
    4339        _tls_alignment = ALIGNOF(.tdata);
    44        
    4540        .bss : {
    4641                *(.sbss);
    … …  
    4944                *(.bss);
    5045        } :data
    51        
     46
     47        . = ALIGN(0x4000);
     48        _heap = .;
     49 
    5250        /DISCARD/ : {
    5351                *(*);
    54         }
     52        }
    5553}

  • uspace/lib/c/arch/mips32/_link.ld.in

    r0c968a17 raa7dc64  
    1313                *(.init);
    1414        } :text
    15        
    1615        .text : {
    17                 *(.text);
     16                *(.text);
    1817                *(.rodata*);
    1918        } :text
    20        
     19
    2120        . = . + 0x4000;
    22        
     21
    2322        .data : {
    2423                *(.data);
    2524                *(.data.rel*);
    2625        } :data
    27        
     26
    2827        .got : {
    2928                _gp = .;
    3029                *(.got);
    3130        } :data
    32        
     31
    3332        .tdata : {
    3433                _tdata_start = .;
    3534                *(.tdata);
    3635                _tdata_end = .;
    37         } :data
    38        
    39         .tbss : {
    4036                _tbss_start = .;
    4137                *(.tbss);
    4238                _tbss_end = .;
    4339        } :data
    44        
    45         _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    46        
     40        _tls_alignment = ALIGNOF(.tdata);
     41
    4742        .sbss : {
    4843                *(.scommon);
    4944                *(.sbss);
    50         }
    51        
     45        }       
    5246        .bss : {
    5347                *(.bss);
    5448                *(COMMON);
    5549        } :data
    56        
     50
     51        . = ALIGN(0x4000);
     52        _heap = .;
     53
    5754        /DISCARD/ : {
    5855                *(*);

  • uspace/lib/c/arch/mips32/src/entry.s

    r0c968a17 raa7dc64  
    2929.text
    3030.section .init, "ax"
    31 
    3231.global __entry
    33 
     32.global __entry_driver
    3433.set noreorder
    3534.option pic2
    … …  
    5857        nop
    5958.end
     59
     60# Alignment of output section data to 0x4000
     61.section .data
     62.align 14

  • uspace/lib/c/arch/ppc32/_link.ld.in

    r0c968a17 raa7dc64  
    99SECTIONS {
    1010        . = 0x1000 + SIZEOF_HEADERS;
    11        
     11
    1212        .init : {
    1313                *(.init);
    1414        } :text
    15        
    1615        .text : {
    1716                *(.text);
    1817                *(.rodata*);
    1918        } :text
    20        
     19
    2120        . = . + 0x1000;
    22        
     21
    2322        .data : {
    2423                *(.data);
    2524                *(.sdata);
    2625        } :data
    27        
    2826        .tdata : {
    2927                _tdata_start = .;
    … …  
    3432                _tbss_end = .;
    3533        } :data
    36        
    3734        _tls_alignment = ALIGNOF(.tdata);
    38        
    3935        .bss : {
    4036                *(.sbss);
    … …  
    4238                *(.bss);
    4339        } :data
     40
     41        . = ALIGN(0x1000);
     42        _heap = .;
    4443       
    4544        /DISCARD/ : {
    4645                *(*);
    4746        }
     47
    4848}

  • uspace/lib/c/arch/sparc64/_link.ld.in

    r0c968a17 raa7dc64  
    99SECTIONS {
    1010        . = 0x4000 + SIZEOF_HEADERS;
    11        
     11
    1212        .init : {
    1313                *(.init);
    1414        } :text
    15        
    1615        .text : {
    1716                *(.text);
    1817                *(.rodata*);
    1918        } :text
    20        
     19
    2120        . = . + 0x4000;
    22        
     21
    2322        .got : {
    2423                 _gp = .;
    2524                 *(.got*);
    2625        } :data
    27        
    2826        .data : {
    2927                *(.data);
    3028                *(.sdata);
    3129        } :data
    32        
    3330        .tdata : {
    3431                _tdata_start = .;
    … …  
    3936                _tbss_end = .;
    4037        } :data
    41        
    4238        _tls_alignment = ALIGNOF(.tdata);
    43        
    4439        .bss : {
    4540                *(.sbss);
    … …  
    4742                *(.bss);
    4843        } :data
     44
     45        . = ALIGN(0x4000);
     46        _heap = .;
    4947       
    5048        /DISCARD/ : {
    5149                *(*);
    5250        }
     51
    5352}

  • uspace/lib/c/generic/as.c

    r0c968a17 raa7dc64  
    4040#include <bitops.h>
    4141#include <malloc.h>
    42 #include "private/libc.h"
     42
     43/** Last position allocated by as_get_mappable_page */
     44static uintptr_t last_allocated = 0;
    4345
    4446/** Create address space area.
    … …  
    101103}
    102104
    103 /** Return pointer to unmapped address space area
     105/** Return pointer to some unmapped area, where fits new as_area
    104106 *
    105107 * @param size Requested size of the allocation.
    106108 *
    107  * @return Pointer to the beginning of unmapped address space area.
     109 * @return pointer to the beginning
    108110 *
    109111 */
    110112void *as_get_mappable_page(size_t size)
    111113{
    112         return (void *) __SYSCALL2(SYS_AS_GET_UNMAPPED_AREA,
    113             (sysarg_t) __entry, (sysarg_t) size);
     114        if (size == 0)
     115                return NULL;
     116       
     117        size_t sz = 1 << (fnzb(size - 1) + 1);
     118        if (last_allocated == 0)
     119                last_allocated = get_max_heap_addr();
     120       
     121        /*
     122         * Make sure we allocate from naturally aligned address.
     123         */
     124        uintptr_t res = ALIGN_UP(last_allocated, sz);
     125        last_allocated = res + ALIGN_UP(size, PAGE_SIZE);
     126       
     127        return ((void *) res);
    114128}
    115129

  • uspace/lib/c/generic/async.c

    r0c968a17 raa7dc64  
    294294}
    295295
     296/** Connection hash table removal callback function.
     297 *
     298 * This function is called whenever a connection is removed from the connection
     299 * hash table.
     300 *
     301 * @param item Connection hash table item being removed.
     302 *
     303 */
    296304static void conn_remove(link_t *item)
    297305{
     306        free(hash_table_get_instance(item, connection_t, link));
    298307}
    299308
    … …  
    638647                ipc_answer_0(FIBRIL_connection->close_callid, EOK);
    639648       
    640         free(FIBRIL_connection);
    641649        return 0;
    642650}

  • uspace/lib/c/generic/malloc.c

    r0c968a17 raa7dc64  
    4747#include "private/malloc.h"
    4848
    49 /** Magic used in heap headers. */
    50 #define HEAP_BLOCK_HEAD_MAGIC  UINT32_C(0xBEEF0101)
    51 
    52 /** Magic used in heap footers. */
    53 #define HEAP_BLOCK_FOOT_MAGIC  UINT32_C(0xBEEF0202)
    54 
    55 /** Magic used in heap descriptor. */
    56 #define HEAP_AREA_MAGIC  UINT32_C(0xBEEFCAFE)
    57 
    58 /** Allocation alignment.
    59  *
    60  * This also covers the alignment of fields
    61  * in the heap header and footer.
    62  *
    63  */
     49/* Magic used in heap headers. */
     50#define HEAP_BLOCK_HEAD_MAGIC  0xBEEF0101
     51
     52/* Magic used in heap footers. */
     53#define HEAP_BLOCK_FOOT_MAGIC  0xBEEF0202
     54
     55/** Allocation alignment (this also covers the alignment of fields
     56    in the heap header and footer) */
    6457#define BASE_ALIGN  16
    6558
    66 /** Overhead of each heap block. */
    67 #define STRUCT_OVERHEAD \
    68         (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
    69 
    70 /** Calculate real size of a heap block.
    71  *
    72  * Add header and footer size.
    73  *
     59/**
     60 * Either 4 * 256M on 32-bit architecures or 16 * 256M on 64-bit architectures
     61 */
     62#define MAX_HEAP_SIZE  (sizeof(uintptr_t) << 28)
     63
     64/**
     65 *
     66 */
     67#define STRUCT_OVERHEAD  (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
     68
     69/**
     70 * Calculate real size of a heap block (with header and footer)
    7471 */
    7572#define GROSS_SIZE(size)  ((size) + STRUCT_OVERHEAD)
    7673
    77 /** Calculate net size of a heap block.
    78  *
    79  * Subtract header and footer size.
    80  *
     74/**
     75 * Calculate net size of a heap block (without header and footer)
    8176 */
    8277#define NET_SIZE(size)  ((size) - STRUCT_OVERHEAD)
    83 
    84 /** Get first block in heap area.
    85  *
    86  */
    87 #define AREA_FIRST_BLOCK(area) \
    88         (ALIGN_UP(((uintptr_t) (area)) + sizeof(heap_area_t), BASE_ALIGN))
    89 
    90 /** Get footer in heap block.
    91  *
    92  */
    93 #define BLOCK_FOOT(head) \
    94         ((heap_block_foot_t *) \
    95             (((uintptr_t) head) + head->size - sizeof(heap_block_foot_t)))
    96 
    97 /** Heap area.
    98  *
    99  * The memory managed by the heap allocator is divided into
    100  * multiple discontinuous heaps. Each heap is represented
    101  * by a separate address space area which has this structure
    102  * at its very beginning.
    103  *
    104  */
    105 typedef struct heap_area {
    106         /** Start of the heap area (including this structure)
    107          *
    108          * Aligned on page boundary.
    109          *
    110          */
    111         void *start;
    112        
    113         /** End of the heap area (aligned on page boundary) */
    114         void *end;
    115        
    116         /** Next heap area */
    117         struct heap_area *next;
    118        
    119         /** A magic value */
    120         uint32_t magic;
    121 } heap_area_t;
    12278
    12379/** Header of a heap block
    … …  
    13187        bool free;
    13288       
    133         /** Heap area this block belongs to */
    134         heap_area_t *area;
    135        
    13689        /* A magic value to detect overwrite of heap header */
    13790        uint32_t magic;
    … …  
    149102} heap_block_foot_t;
    150103
    151 /** First heap area */
    152 static heap_area_t *first_heap_area = NULL;
    153 
    154 /** Last heap area */
    155 static heap_area_t *last_heap_area = NULL;
    156 
    157 /** Next heap block to examine (next fit algorithm) */
    158 static heap_block_head_t *next = NULL;
     104/** Linker heap symbol */
     105extern char _heap;
    159106
    160107/** Futex for thread-safe heap manipulation */
    161108static futex_t malloc_futex = FUTEX_INITIALIZER;
    162109
     110/** Address of heap start */
     111static void *heap_start = 0;
     112
     113/** Address of heap end */
     114static void *heap_end = 0;
     115
     116/** Maximum heap size */
     117static size_t max_heap_size = (size_t) -1;
     118
     119/** Current number of pages of heap area */
     120static size_t heap_pages = 0;
     121
    163122/** Initialize a heap block
    164123 *
    165  * Fill in the structures related to a heap block.
     124 * Fills in the structures related to a heap block.
    166125 * Should be called only inside the critical section.
    167126 *
    … …  
    169128 * @param size Size of the block including the header and the footer.
    170129 * @param free Indication of a free block.
    171  * @param area Heap area the block belongs to.
    172  *
    173  */
    174 static void block_init(void *addr, size_t size, bool free, heap_area_t *area)
     130 *
     131 */
     132static void block_init(void *addr, size_t size, bool free)
    175133{
    176134        /* Calculate the position of the header and the footer */
    177135        heap_block_head_t *head = (heap_block_head_t *) addr;
     136        heap_block_foot_t *foot =
     137            (heap_block_foot_t *) (addr + size - sizeof(heap_block_foot_t));
    178138       
    179139        head->size = size;
    180140        head->free = free;
    181         head->area = area;
    182141        head->magic = HEAP_BLOCK_HEAD_MAGIC;
    183        
    184         heap_block_foot_t *foot = BLOCK_FOOT(head);
    185142       
    186143        foot->size = size;
    … …  
    203160        assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
    204161       
    205         heap_block_foot_t *foot = BLOCK_FOOT(head);
     162        heap_block_foot_t *foot =
     163            (heap_block_foot_t *) (addr + head->size - sizeof(heap_block_foot_t));
    206164       
    207165        assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
    … …  
    209167}
    210168
    211 /** Check a heap area structure
    212  *
    213  * @param addr Address of the heap area.
    214  *
    215  */
    216 static void area_check(void *addr)
    217 {
    218         heap_area_t *area = (heap_area_t *) addr;
    219        
    220         assert(area->magic == HEAP_AREA_MAGIC);
    221         assert(area->start < area->end);
    222         assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
    223         assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
    224 }
    225 
    226 /** Create new heap area
    227  *
    228  * @param start Preffered starting address of the new area.
    229  * @param size  Size of the area.
    230  *
    231  */
    232 static bool area_create(size_t size)
    233 {
    234         void *start = as_get_mappable_page(size);
    235         if (start == NULL)
     169/** Increase the heap area size
     170 *
     171 * Should be called only inside the critical section.
     172 *
     173 * @param size Number of bytes to grow the heap by.
     174 *
     175 */
     176static bool grow_heap(size_t size)
     177{
     178        if (size == 0)
    236179                return false;
    237        
    238         /* Align the heap area on page boundary */
    239         void *astart = (void *) ALIGN_UP((uintptr_t) start, PAGE_SIZE);
    240         size_t asize = ALIGN_UP(size, PAGE_SIZE);
    241        
    242         astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
    243         if (astart == (void *) -1)
     180
     181        if ((heap_start + size < heap_start) || (heap_end + size < heap_end))
    244182                return false;
    245183       
    246         heap_area_t *area = (heap_area_t *) astart;
    247        
    248         area->start = astart;
    249         area->end = (void *)
    250             ALIGN_DOWN((uintptr_t) astart + asize, BASE_ALIGN);
    251         area->next = NULL;
    252         area->magic = HEAP_AREA_MAGIC;
    253        
    254         void *block = (void *) AREA_FIRST_BLOCK(area);
    255         size_t bsize = (size_t) (area->end - block);
    256        
    257         block_init(block, bsize, true, area);
    258        
    259         if (last_heap_area == NULL) {
    260                 first_heap_area = area;
    261                 last_heap_area = area;
    262         } else {
    263                 last_heap_area->next = area;
    264                 last_heap_area = area;
    265         }
    266        
    267         return true;
    268 }
    269 
    270 /** Try to enlarge a heap area
    271  *
    272  * @param area Heap area to grow.
    273  * @param size Gross size of item to allocate (bytes).
    274  *
    275  */
    276 static bool area_grow(heap_area_t *area, size_t size)
    277 {
    278         if (size == 0)
     184        size_t heap_size = (size_t) (heap_end - heap_start);
     185       
     186        if ((max_heap_size != (size_t) -1) && (heap_size + size > max_heap_size))
     187                return false;
     188       
     189        size_t pages = (size - 1) / PAGE_SIZE + 1;
     190       
     191        if (as_area_resize((void *) &_heap, (heap_pages + pages) * PAGE_SIZE, 0)
     192            == EOK) {
     193                void *end = (void *) ALIGN_DOWN(((uintptr_t) &_heap) +
     194                    (heap_pages + pages) * PAGE_SIZE, BASE_ALIGN);
     195                block_init(heap_end, end - heap_end, true);
     196                heap_pages += pages;
     197                heap_end = end;
    279198                return true;
    280        
    281         area_check(area);
    282        
    283         size_t asize = ALIGN_UP((size_t) (area->end - area->start) + size,
    284             PAGE_SIZE);
    285        
    286         /* New heap area size */
    287         void *end = (void *)
    288             ALIGN_DOWN((uintptr_t) area->start + asize, BASE_ALIGN);
    289        
    290         /* Check for overflow */
    291         if (end < area->start)
    292                 return false;
    293        
    294         /* Resize the address space area */
    295         int ret = as_area_resize(area->start, asize, 0);
    296         if (ret != EOK)
    297                 return false;
    298        
    299         /* Add new free block */
    300         block_init(area->end, (size_t) (end - area->end), true, area);
    301        
    302         /* Update heap area parameters */
    303         area->end = end;
    304        
    305         return true;
    306 }
    307 
    308 /** Try to enlarge any of the heap areas
    309  *
    310  * @param size Gross size of item to allocate (bytes).
    311  *
    312  */
    313 static bool heap_grow(size_t size)
    314 {
    315         if (size == 0)
    316                 return true;
    317        
    318         /* First try to enlarge some existing area */
    319         heap_area_t *area;
    320         for (area = first_heap_area; area != NULL; area = area->next) {
    321                 if (area_grow(area, size))
    322                         return true;
    323         }
    324        
    325         /* Eventually try to create a new area */
    326         return area_create(AREA_FIRST_BLOCK(size));
    327 }
    328 
    329 /** Try to shrink heap space
    330  *
    331  * In all cases the next pointer is reset.
    332  *
    333  */
    334 static void heap_shrink(void)
    335 {
    336         next = NULL;
     199        }
     200       
     201        return false;
     202}
     203
     204/** Decrease the heap area
     205 *
     206 * Should be called only inside the critical section.
     207 *
     208 * @param size Number of bytes to shrink the heap by.
     209 *
     210 */
     211static void shrink_heap(void)
     212{
     213        // TODO
    337214}
    338215
    … …  
    346223void __malloc_init(void)
    347224{
    348         if (!area_create(PAGE_SIZE))
     225        if (!as_area_create((void *) &_heap, PAGE_SIZE,
     226            AS_AREA_WRITE | AS_AREA_READ))
    349227                abort();
     228       
     229        heap_pages = 1;
     230        heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN);
     231        heap_end =
     232            (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN);
     233       
     234        /* Make the entire area one large block. */
     235        block_init(heap_start, heap_end - heap_start, true);
     236}
     237
     238/** Get maximum heap address
     239 *
     240 */
     241uintptr_t get_max_heap_addr(void)
     242{
     243        futex_down(&malloc_futex);
     244       
     245        if (max_heap_size == (size_t) -1)
     246                max_heap_size =
     247                    max((size_t) (heap_end - heap_start), MAX_HEAP_SIZE);
     248       
     249        uintptr_t max_heap_addr = (uintptr_t) heap_start + max_heap_size;
     250       
     251        futex_up(&malloc_futex);
     252       
     253        return max_heap_addr;
    350254}
    351255
    … …  
    369273                /* Block big enough -> split. */
    370274                void *next = ((void *) cur) + size;
    371                 block_init(next, cur->size - size, true, cur->area);
    372                 block_init(cur, size, false, cur->area);
     275                block_init(next, cur->size - size, true);
     276                block_init(cur, size, false);
    373277        } else {
    374278                /* Block too small -> use as is. */
    … …  
    377281}
    378282
    379 /** Allocate memory from heap area starting from given block
     283/** Allocate a memory block
    380284 *
    381285 * Should be called only inside the critical section.
    382  * As a side effect this function also sets the current
    383  * pointer on successful allocation.
    384  *
    385  * @param area        Heap area where to allocate from.
    386  * @param first_block Starting heap block.
    387  * @param final_block Heap block where to finish the search
    388  *                    (may be NULL).
    389  * @param real_size   Gross number of bytes to allocate.
    390  * @param falign      Physical alignment of the block.
    391  *
    392  * @return Address of the allocated block or NULL on not enough memory.
    393  *
    394  */
    395 static void *malloc_area(heap_area_t *area, heap_block_head_t *first_block,
    396     heap_block_head_t *final_block, size_t real_size, size_t falign)
    397 {
    398         area_check((void *) area);
    399         assert((void *) first_block >= (void *) AREA_FIRST_BLOCK(area));
    400         assert((void *) first_block < area->end);
    401        
    402         heap_block_head_t *cur;
    403         for (cur = first_block; (void *) cur < area->end;
    404             cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
     286 *
     287 * @param size  The size of the block to allocate.
     288 * @param align Memory address alignment.
     289 *
     290 * @return the address of the block or NULL when not enough memory.
     291 *
     292 */
     293static void *malloc_internal(const size_t size, const size_t align)
     294{
     295        if (align == 0)
     296                return NULL;
     297       
     298        size_t falign = lcm(align, BASE_ALIGN);
     299        size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign));
     300       
     301        bool grown = false;
     302        void *result;
     303       
     304loop:
     305        result = NULL;
     306        heap_block_head_t *cur = (heap_block_head_t *) heap_start;
     307       
     308        while ((result == NULL) && ((void *) cur < heap_end)) {
    405309                block_check(cur);
    406                
    407                 /* Finish searching on the final block */
    408                 if ((final_block != NULL) && (cur == final_block))
    409                         break;
    410310               
    411311                /* Try to find a block that is free and large enough. */
    412312                if ((cur->free) && (cur->size >= real_size)) {
    413                         /*
    414                          * We have found a suitable block.
    415                          * Check for alignment properties.
    416                          */
    417                         void *addr = (void *)
    418                             ((uintptr_t) cur + sizeof(heap_block_head_t));
    419                         void *aligned = (void *)
    420                             ALIGN_UP((uintptr_t) addr, falign);
     313                        /* We have found a suitable block.
     314                           Check for alignment properties. */
     315                        void *addr = ((void *) cur) + sizeof(heap_block_head_t);
     316                        void *aligned = (void *) ALIGN_UP(addr, falign);
    421317                       
    422318                        if (addr == aligned) {
    423319                                /* Exact block start including alignment. */
    424320                                split_mark(cur, real_size);
    425                                
    426                                 next = cur;
    427                                 return addr;
     321                                result = addr;
    428322                        } else {
    429323                                /* Block start has to be aligned */
    … …  
    431325                               
    432326                                if (cur->size >= real_size + excess) {
    433                                         /*
    434                                          * The current block is large enough to fit
    435                                          * data in (including alignment).
    436                                          */
    437                                         if ((void *) cur > (void *) AREA_FIRST_BLOCK(area)) {
    438                                                 /*
    439                                                  * There is a block before the current block.
    440                                                  * This previous block can be enlarged to
    441                                                  * compensate for the alignment excess.
    442                                                  */
    443                                                 heap_block_foot_t *prev_foot = (heap_block_foot_t *)
    444                                                     ((void *) cur - sizeof(heap_block_foot_t));
     327                                        /* The current block is large enough to fit
     328                                           data in including alignment */
     329                                        if ((void *) cur > heap_start) {
     330                                                /* There is a block before the current block.
     331                                                   This previous block can be enlarged to compensate
     332                                                   for the alignment excess */
     333                                                heap_block_foot_t *prev_foot =
     334                                                    ((void *) cur) - sizeof(heap_block_foot_t);
    445335                                               
    446                                                 heap_block_head_t *prev_head = (heap_block_head_t *)
    447                                                     ((void *) cur - prev_foot->size);
     336                                                heap_block_head_t *prev_head =
     337                                                    (heap_block_head_t *) (((void *) cur) - prev_foot->size);
    448338                                               
    449339                                                block_check(prev_head);
    … …  
    452342                                                heap_block_head_t *next_head = ((void *) cur) + excess;
    453343                                               
    454                                                 if ((!prev_head->free) &&
    455                                                     (excess >= STRUCT_OVERHEAD)) {
    456                                                         /*
    457                                                          * The previous block is not free and there
    458                                                          * is enough free space left to fill in
    459                                                          * a new free block between the previous
    460                                                          * and current block.
    461                                                          */
    462                                                         block_init(cur, excess, true, area);
     344                                                if ((!prev_head->free) && (excess >= STRUCT_OVERHEAD)) {
     345                                                        /* The previous block is not free and there is enough
     346                                                           space to fill in a new free block between the previous
     347                                                           and current block */
     348                                                        block_init(cur, excess, true);
    463349                                                } else {
    464                                                         /*
    465                                                          * The previous block is free (thus there
    466                                                          * is no need to induce additional
    467                                                          * fragmentation to the heap) or the
    468                                                          * excess is small. Therefore just enlarge
    469                                                          * the previous block.
    470                                                          */
    471                                                         block_init(prev_head, prev_head->size + excess,
    472                                                             prev_head->free, area);
     350                                                        /* The previous block is free (thus there is no need to
     351                                                           induce additional fragmentation to the heap) or the
     352                                                           excess is small, thus just enlarge the previous block */
     353                                                        block_init(prev_head, prev_head->size + excess, prev_head->free);
    473354                                                }
    474355                                               
    475                                                 block_init(next_head, reduced_size, true, area);
     356                                                block_init(next_head, reduced_size, true);
    476357                                                split_mark(next_head, real_size);
    477                                                
    478                                                 next = next_head;
    479                                                 return aligned;
     358                                                result = aligned;
     359                                                cur = next_head;
    480360                                        } else {
    481                                                 /*
    482                                                  * The current block is the first block
    483                                                  * in the heap area. We have to make sure
    484                                                  * that the alignment excess is large enough
    485                                                  * to fit a new free block just before the
    486                                                  * current block.
    487                                                  */
     361                                                /* The current block is the first block on the heap.
     362                                                   We have to make sure that the alignment excess
     363                                                   is large enough to fit a new free block just
     364                                                   before the current block */
    488365                                                while (excess < STRUCT_OVERHEAD) {
    489366                                                        aligned += falign;
    … …  
    494371                                                if (cur->size >= real_size + excess) {
    495372                                                        size_t reduced_size = cur->size - excess;
    496                                                         cur = (heap_block_head_t *)
    497                                                             (AREA_FIRST_BLOCK(area) + excess);
     373                                                        cur = (heap_block_head_t *) (heap_start + excess);
    498374                                                       
    499                                                         block_init((void *) AREA_FIRST_BLOCK(area), excess,
    500                                                             true, area);
    501                                                         block_init(cur, reduced_size, true, area);
     375                                                        block_init(heap_start, excess, true);
     376                                                        block_init(cur, reduced_size, true);
    502377                                                        split_mark(cur, real_size);
    503                                                        
    504                                                         next = cur;
    505                                                         return aligned;
     378                                                        result = aligned;
    506379                                                }
    507380                                        }
    … …  
    509382                        }
    510383                }
    511         }
    512        
    513         return NULL;
    514 }
    515 
    516 /** Allocate a memory block
    517  *
    518  * Should be called only inside the critical section.
    519  *
    520  * @param size  The size of the block to allocate.
    521  * @param align Memory address alignment.
    522  *
    523  * @return Address of the allocated block or NULL on not enough memory.
    524  *
    525  */
    526 static void *malloc_internal(const size_t size, const size_t align)
    527 {
    528         assert(first_heap_area != NULL);
    529        
    530         if (align == 0)
    531                 return NULL;
    532        
    533         size_t falign = lcm(align, BASE_ALIGN);
    534         size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign));
    535        
    536         bool retry = false;
    537         heap_block_head_t *split;
    538        
    539 loop:
    540        
    541         /* Try the next fit approach */
    542         split = next;
    543        
    544         if (split != NULL) {
    545                 void *addr = malloc_area(split->area, split, NULL, real_size,
    546                     falign);
    547                
    548                 if (addr != NULL)
    549                         return addr;
    550         }
    551        
    552         /* Search the entire heap */
    553         heap_area_t *area;
    554         for (area = first_heap_area; area != NULL; area = area->next) {
    555                 heap_block_head_t *first = (heap_block_head_t *)
    556                     AREA_FIRST_BLOCK(area);
    557                
    558                 void *addr = malloc_area(area, first, split, real_size,
    559                     falign);
    560                
    561                 if (addr != NULL)
    562                         return addr;
    563         }
    564        
    565         if (!retry) {
    566                 /* Try to grow the heap space */
    567                 if (heap_grow(real_size)) {
    568                         retry = true;
     384               
     385                /* Advance to the next block. */
     386                cur = (heap_block_head_t *) (((void *) cur) + cur->size);
     387        }
     388       
     389        if ((result == NULL) && (!grown)) {
     390                if (grow_heap(real_size)) {
     391                        grown = true;
    569392                        goto loop;
    570393                }
    571394        }
    572395       
    573         return NULL;
     396        return result;
    574397}
    575398
    … …  
    650473            (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
    651474       
     475        assert((void *) head >= heap_start);
     476        assert((void *) head < heap_end);
     477       
    652478        block_check(head);
    653479        assert(!head->free);
    654        
    655         heap_area_t *area = head->area;
    656        
    657         area_check(area);
    658         assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
    659         assert((void *) head < area->end);
    660480       
    661481        void *ptr = NULL;
    … …  
    667487                /* Shrink */
    668488                if (orig_size - real_size >= STRUCT_OVERHEAD) {
    669                         /*
    670                          * Split the original block to a full block
    671                          * and a trailing free block.
    672                          */
    673                         block_init((void *) head, real_size, false, area);
     489                        /* Split the original block to a full block
     490                           and a trailing free block */
     491                        block_init((void *) head, real_size, false);
    674492                        block_init((void *) head + real_size,
    675                             orig_size - real_size, true, area);
    676                         heap_shrink();
     493                            orig_size - real_size, true);
     494                        shrink_heap();
    677495                }
    678496               
    679497                ptr = ((void *) head) + sizeof(heap_block_head_t);
    680498        } else {
    681                 /*
    682                  * Look at the next block. If it is free and the size is
    683                  * sufficient then merge the two. Otherwise just allocate
    684                  * a new block, copy the original data into it and
    685                  * free the original block.
    686                  */
     499                /* Look at the next block. If it is free and the size is
     500                   sufficient then merge the two. Otherwise just allocate
     501                   a new block, copy the original data into it and
     502                   free the original block. */
    687503                heap_block_head_t *next_head =
    688504                    (heap_block_head_t *) (((void *) head) + head->size);
    689505               
    690                 if (((void *) next_head < area->end) &&
     506                if (((void *) next_head < heap_end) &&
    691507                    (head->size + next_head->size >= real_size) &&
    692508                    (next_head->free)) {
    693509                        block_check(next_head);
    694                         block_init(head, head->size + next_head->size, false, area);
     510                        block_init(head, head->size + next_head->size, false);
    695511                        split_mark(head, real_size);
    696512                       
    697513                        ptr = ((void *) head) + sizeof(heap_block_head_t);
    698                         next = NULL;
    699514                } else
    700515                        reloc = true;
    … …  
    727542            = (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
    728543       
     544        assert((void *) head >= heap_start);
     545        assert((void *) head < heap_end);
     546       
    729547        block_check(head);
    730548        assert(!head->free);
    731        
    732         heap_area_t *area = head->area;
    733        
    734         area_check(area);
    735         assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
    736         assert((void *) head < area->end);
    737549       
    738550        /* Mark the block itself as free. */
    … …  
    743555            = (heap_block_head_t *) (((void *) head) + head->size);
    744556       
    745         if ((void *) next_head < area->end) {
     557        if ((void *) next_head < heap_end) {
    746558                block_check(next_head);
    747559                if (next_head->free)
    748                         block_init(head, head->size + next_head->size, true, area);
     560                        block_init(head, head->size + next_head->size, true);
    749561        }
    750562       
    751563        /* Look at the previous block. If it is free, merge the two. */
    752         if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) {
     564        if ((void *) head > heap_start) {
    753565                heap_block_foot_t *prev_foot =
    754566                    (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
    … …  
    760572               
    761573                if (prev_head->free)
    762                         block_init(prev_head, prev_head->size + head->size, true,
    763                             area);
    764         }
    765        
    766         heap_shrink();
     574                        block_init(prev_head, prev_head->size + head->size, true);
     575        }
     576       
     577        shrink_heap();
    767578       
    768579        futex_up(&malloc_futex);

  • uspace/lib/c/generic/private/libc.h

    r0c968a17 raa7dc64  
    3636#define LIBC_PRIVATE_LIBC_H_
    3737
    38 extern void __entry(void);
     38extern int main(int, char *[]);
    3939extern void __main(void *) __attribute__((noreturn));
    40 extern int main(int, char *[]);
    4140
    4241#endif

  • uspace/lib/c/include/as.h

    r0c968a17 raa7dc64  
    4141#include <libarch/config.h>
    4242
    43 static inline size_t SIZE2PAGES(size_t size)
    44 {
    45         if (size == 0)
    46                 return 0;
    47        
    48         return (size_t) ((size - 1) >> PAGE_WIDTH) + 1;
    49 }
    50 
    51 static inline size_t PAGES2SIZE(size_t pages)
    52 {
    53         return (size_t) (pages << PAGE_WIDTH);
    54 }
    55 
    5643extern void *as_area_create(void *address, size_t size, int flags);
    5744extern int as_area_resize(void *address, size_t size, int flags);

  • uspace/lib/c/include/malloc.h

    r0c968a17 raa7dc64  
    3838#include <sys/types.h>
    3939
     40extern uintptr_t get_max_heap_addr(void);
     41
    4042extern void *malloc(const size_t size)
    4143    __attribute__((malloc));

  • uspace/lib/c/include/unistd.h

    r0c968a17 raa7dc64  
    4444#endif
    4545
     46#define getpagesize()  (PAGE_SIZE)
     47
    4648#ifndef SEEK_SET
    4749        #define SEEK_SET  0
    … …  
    5557        #define SEEK_END  2
    5658#endif
    57 
    58 #define getpagesize()  (PAGE_SIZE)
    5959
    6060extern int dup2(int oldfd, int newfd);

  • uspace/srv/devman/devman.c

    r0c968a17 raa7dc64  
    12151215        if (info != NULL) {
    12161216                memset(info, 0, sizeof(dev_class_info_t));
    1217                 link_initialize(&info->dev_classes);
    1218                 link_initialize(&info->devmap_link);
    1219                 link_initialize(&info->link);
     1217                list_initialize(&info->dev_classes);
     1218                list_initialize(&info->devmap_link);
     1219                list_initialize(&info->link);
    12201220        }
    12211221       

  • uspace/srv/devmap/devmap.c

    r0c968a17 raa7dc64  
    423423         */
    424424        list_initialize(&driver->devices);
    425 
    426         link_initialize(&driver->drivers);
     425        list_initialize(&(driver->drivers));
    427426       
    428427        fibril_mutex_lock(&drivers_list_mutex);
    … …  
    539538        }
    540539       
    541         link_initialize(&device->devices);
    542         link_initialize(&device->driver_devices);
     540        list_initialize(&(device->devices));
     541        list_initialize(&(device->driver_devices));
    543542       
    544543        /* Check that device is not already registered */
    … …  
    943942        }
    944943       
    945         link_initialize(&device->devices);
    946         link_initialize(&device->driver_devices);
     944        list_initialize(&(device->devices));
     945        list_initialize(&(device->driver_devices));
    947946       
    948947        /* Get unique device handle */

  • uspace/srv/fs/devfs/devfs_ops.c

    r0c968a17 raa7dc64  
    130130{
    131131        devfs_node_t *node = (devfs_node_t *) pfn->data;
    132         int ret;
    133132       
    134133        if (node->handle == 0) {
    … …  
    146145                               
    147146                                if (str_cmp(devs[pos].name, component) == 0) {
    148                                         ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
    149147                                        free(devs);
    150                                         return ret;
     148                                        return devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
    151149                                }
    152150                        }
    … …  
    164162                                for (pos = 0; pos < count; pos++) {
    165163                                        if (str_cmp(devs[pos].name, component) == 0) {
    166                                                 ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    167164                                                free(devs);
    168                                                 return ret;
     165                                                return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    169166                                        }
    170167                                }
    … …  
    187184                        for (pos = 0; pos < count; pos++) {
    188185                                if (str_cmp(devs[pos].name, component) == 0) {
    189                                         ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    190186                                        free(devs);
    191                                         return ret;
     187                                        return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    192188                                }
    193189                        }

  • uspace/srv/loader/arch/abs32le/_link.ld.in

    r0c968a17 raa7dc64  
    33 * is the base address and the special interp section.
    44 */
    5 
    65STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    76ENTRY(__entry)
    … …  
    5554        } :data
    5655       
     56        . = ALIGN(0x1000);
     57       
     58        _heap = .;
     59       
    5760        /DISCARD/ : {
    5861                *(*);

  • uspace/srv/loader/arch/amd64/_link.ld.in

    r0c968a17 raa7dc64  
    5454        } :data
    5555       
     56        . = ALIGN(0x1000);
     57        _heap = .;
     58       
    5659#ifdef CONFIG_LINE_DEBUG
    5760        .comment 0 : { *(.comment); } :debug

  • uspace/srv/loader/arch/arm32/_link.ld.in

    r0c968a17 raa7dc64  
    33 * is the base address.
    44 */
    5 
    65STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    76ENTRY(__entry)
    … …  
    1716                *(.interp);
    1817        } : interp
    19        
     18
    2019        . = 0x70001000;
    21        
     20
    2221        .init ALIGN(0x1000): SUBALIGN(0x1000) {
    2322                *(.init);
    24         } :text
    25        
     23        } : text
    2624        .text : {
    2725                *(.text);
    28                 *(.rodata*);
     26        *(.rodata*);
    2927        } :text
    3028       
    … …  
    3432                *(.sdata);
    3533        } :data
    36        
    3734        .tdata : {
    3835                _tdata_start = .;
    … …  
    4037                _tdata_end = .;
    4138        } :data
    42        
    4339        .tbss : {
    4440                _tbss_start = .;
    … …  
    4642                _tbss_end = .;
    4743        } :data
    48        
    4944        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    50        
    5145        .bss : {
    5246                *(.sbss);
    5347                *(.scommon);
    54                 *(COMMON);
    55                 *(.bss);
     48        *(COMMON);
     49        *(.bss);
    5650        } :data
     51       
     52        . = ALIGN(0x1000);
     53        _heap = .;
    5754       
    5855        /DISCARD/ : {
    5956                *(*);
    6057        }
     58
    6159}

  • uspace/srv/loader/arch/ia32/_link.ld.in

    r0c968a17 raa7dc64  
    5454        } :data
    5555       
     56        . = ALIGN(0x1000);
     57        _heap = .;
     58       
    5659#ifdef CONFIG_LINE_DEBUG
    5760        .comment 0 : { *(.comment); } :debug

  • uspace/srv/loader/arch/ia64/_link.ld.in

    r0c968a17 raa7dc64  
    1212                *(.interp);
    1313        } :interp
    14        
     14
    1515        /* On Itanium code sections must be aligned to 16 bytes. */
    1616        . = ALIGN(0x800000000 + SIZEOF_HEADERS, 16);
    17        
     17
    1818        .init : {
    1919                *(.init);
    20         } :text
    21        
     20        } : text
    2221        .text : {
    2322                *(.text);
    2423                *(.rodata*);
    2524        } :text
    26        
     25
    2726        . = . + 0x4000;
    28        
     27
    2928        .got : {
    3029                _gp = .;
    3130                *(.got*);
    32         } :data
    33        
     31        } :data
    3432        .data : {
    3533                *(.opd);
    … …  
    3735                *(.sdata);
    3836        } :data
    39        
    4037        .tdata : {
    4138                _tdata_start = .;
    … …  
    4340                _tdata_end = .;
    4441        } :data
    45        
    4642        .tbss : {
    4743                _tbss_start = .;
    … …  
    4945                _tbss_end = .;
    5046        } :data
    51        
    5247        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    53        
    5448        .bss : {
    5549                *(.sbss);
    … …  
    5852                *(.bss);
    5953        } :data
    60        
     54
     55        . = ALIGN(0x4000);
     56        _heap = .;
     57 
    6158        /DISCARD/ : {
    6259                *(*);
    63         }
     60        }
    6461}

  • uspace/srv/loader/arch/mips32/_link.ld.in

    r0c968a17 raa7dc64  
    33 * is the base address.
    44 */
    5 
    65STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    76ENTRY(__entry)
    … …  
    1716                *(.interp);
    1817        } :interp
    19        
     18
    2019        . = 0x70004000;
    2120       
    … …  
    2322                *(.init);
    2423        } :text
    25        
    2624        .text : {
    27                 *(.text);
     25                *(.text);
    2826                *(.rodata*);
    2927        } :text
    30        
    31         . = . + 0x4000;
    32        
     28
    3329        .data : {
    3430                *(.data);
    3531                *(.data.rel*);
    3632        } :data
    37        
     33
    3834        .got : {
    3935                _gp = .;
    4036                *(.got);
    4137        } :data
    42        
     38
    4339        .tdata : {
    4440                _tdata_start = .;
    … …  
    4642                _tdata_end = .;
    4743        } :data
    48        
    4944        .tbss : {
    5045                _tbss_start = .;
    … …  
    5247                _tbss_end = .;
    5348        } :data
    54        
    5549        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    56        
     50
    5751        .sbss : {
    5852                *(.scommon);
    5953                *(.sbss);
    60         }
    61        
     54        }       
    6255        .bss : {
    6356                *(.bss);
    6457                *(COMMON);
    6558        } :data
    66        
     59
     60        . = ALIGN(0x4000);
     61        _heap = .;
     62
    6763        /DISCARD/ : {
    6864                *(*);

  • uspace/srv/loader/arch/ppc32/_link.ld.in

    r0c968a17 raa7dc64  
    33 * is the base address.
    44 */
    5 
    65STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    76ENTRY(__entry)
    … …  
    1716                *(.interp);
    1817        } :interp
    19        
     18
    2019        . = 0x70001000;
    21        
     20
    2221        .init ALIGN(0x1000) : SUBALIGN(0x1000) {
    2322                *(.init);
    2423        } :text
    25        
    2624        .text : {
    2725                *(.text);
    … …  
    3331                *(.sdata);
    3432        } :data
    35        
    3633        .tdata : {
    3734                _tdata_start = .;
    … …  
    3936                _tdata_end = .;
    4037        } :data
    41        
    4238        .tbss : {
    4339                _tbss_start = .;
    … …  
    4541                _tbss_end = .;
    4642        } :data
    47        
    4843        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    49        
    5044        .bss : {
    5145                *(.sbss);
    … …  
    5347                *(.bss);
    5448        } :data
     49
     50        . = ALIGN(0x1000);
     51        _heap = .;
    5552       
    5653        /DISCARD/ : {
    5754                *(*);
    5855        }
     56
    5957}

  • uspace/srv/loader/arch/sparc64/_link.ld.in

    r0c968a17 raa7dc64  
    1212                *(.interp);
    1313        } :interp
    14        
     14
    1515        . = 0x70004000 + SIZEOF_HEADERS;
    16        
     16
    1717        .init : {
    1818                *(.init);
    1919        } :text
    20        
    2120        .text : {
    2221                *(.text);
    2322                *(.rodata*);
    2423        } :text
    25        
     24
    2625        . = . + 0x4000;
    27        
     26
    2827        .got : {
    2928                 _gp = .;
    3029                 *(.got*);
    3130        } :data
    32        
    3331        .data : {
    3432                *(.data);
    3533                *(.sdata);
    3634        } :data
    37        
    3835        .tdata : {
    3936                _tdata_start = .;
    … …  
    4138                _tdata_end = .;
    4239        } :data
    43        
    4440        .tbss : {
    4541                _tbss_start = .;
    … …  
    4743                _tbss_end = .;
    4844        } :data
    49        
    5045        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    51        
    5246        .bss : {
    5347                *(.sbss);
    … …  
    5549                *(.bss);
    5650        } :data
     51
     52        . = ALIGN(0x4000);
     53        _heap = .;
    5754       
    5855        /DISCARD/ : {
    5956                *(*);
    6057        }
     58
    6159}

  • uspace/srv/loader/elf_load.c

    r0c968a17 raa7dc64  
    109109        int fd;
    110110        int rc;
    111        
     111
    112112        fd = open(file_name, O_RDONLY);
    113113        if (fd < 0) {
    … …  
    344344        seg_ptr = (void *) seg_addr;
    345345
    346         DPRINTF("Load segment at addr %p, size 0x%x\n", (void *) seg_addr,
     346        DPRINTF("Load segment at addr %p, size 0x%x\n", seg_addr,
    347347                entry->p_memsz);
    348348
    … …  
    372372        mem_sz = entry->p_memsz + (entry->p_vaddr - base);
    373373
    374         DPRINTF("Map to seg_addr=%p-%p.\n", (void *) seg_addr,
    375             (void *) (entry->p_vaddr + bias +
    376             ALIGN_UP(entry->p_memsz, PAGE_SIZE)));
     374        DPRINTF("Map to seg_addr=%p-%p.\n", seg_addr,
     375        entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
    377376
    378377        /*
    … …  
    387386        }
    388387
    389         DPRINTF("as_area_create(%p, %#zx, %d) -> %p\n",
    390             (void *) (base + bias), mem_sz, flags, (void *) a);
     388        DPRINTF("as_area_create(%p, 0x%x, %d) -> 0x%lx\n",
     389                base + bias, mem_sz, flags, (uintptr_t)a);
    391390
    392391        /*
    … …  
    465464                    (void *)((uint8_t *)entry->sh_addr + elf->bias);
    466465                DPRINTF("Dynamic section found at %p.\n",
    467                     (void *) elf->info->dynamic);
     466                        (uintptr_t)elf->info->dynamic);
    468467                break;
    469468        default:
Note: See TracChangeset for help on using the changeset viewer.