Changes in / [aa7dc64:0c968a17] in mainline


Ignore:
Files:
3 deleted
37 edited

Legend:

Unmodified
Added
Removed

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

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

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

    raa7dc64 r0c968a17  
    115115       
    116116        /**
    117          * Number of processors on wich is this address space active.
    118          * Protected by asidlock.
     117         * Number of processors on which this
     118         * address space is active. Protected by
     119         * asidlock.
    119120         */
    120121        size_t cpu_refcount;
    121122       
    122         /**
    123          * Address space identifier.
    124          * Constant on architectures that do not support ASIDs.
    125          * Protected by asidlock.
     123        /** Address space identifier.
     124         *
     125         * Constant on architectures that do not
     126         * support ASIDs. Protected by asidlock.
     127         *
    126128         */
    127129        asid_t asid;
    128130       
    129         /** Number of references (i.e tasks that reference this as). */
     131        /** Number of references (i.e. tasks that reference this as). */
    130132        atomic_t refcount;
    131133       
    … …  
    199201typedef struct {
    200202        mutex_t lock;
     203       
    201204        /** Containing address space. */
    202205        as_t *as;
    203206       
    204         /**
    205          * Flags related to the memory represented by the address space area.
    206          */
     207        /** Memory flags. */
    207208        unsigned int flags;
    208209       
    209         /** Attributes related to the address space area itself. */
     210        /** Address space area attributes. */
    210211        unsigned int attributes;
    211         /** Size of this area in multiples of PAGE_SIZE. */
     212       
     213        /** Number of pages in the area. */
    212214        size_t pages;
     215       
     216        /** Number of resident pages in the area. */
     217        size_t resident;
     218       
    213219        /** Base address of this area. */
    214220        uintptr_t base;
     221       
    215222        /** Map of used space. */
    216223        btree_t used_space;
    217224       
    218225        /**
    219          * If the address space area has been shared, this pointer will
    220          * reference the share info structure.
     226         * If the address space area is shared. this is
     227         * a reference to the share info structure.
    221228         */
    222229        share_info_t *sh_info;
    … …  
    261268extern bool as_area_check_access(as_area_t *, pf_access_t);
    262269extern size_t as_area_get_size(uintptr_t);
    263 extern int used_space_insert(as_area_t *, uintptr_t, size_t);
    264 extern int used_space_remove(as_area_t *, uintptr_t, size_t);
    265 
     270extern bool used_space_insert(as_area_t *, uintptr_t, size_t);
     271extern bool used_space_remove(as_area_t *, uintptr_t, size_t);
    266272
    267273/* Interface to be implemented by architectures. */
    … …  
    307313extern sysarg_t sys_as_area_change_flags(uintptr_t, unsigned int);
    308314extern sysarg_t sys_as_area_destroy(uintptr_t);
     315extern sysarg_t sys_as_get_unmapped_area(uintptr_t, size_t);
    309316
    310317/* Introspection functions. */

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

    raa7dc64 r0c968a17  
    5959        SYS_AS_AREA_CHANGE_FLAGS,
    6060        SYS_AS_AREA_DESTROY,
     61        SYS_AS_GET_UNMAPPED_AREA,
    6162       
    6263        SYS_IPC_CALL_SYNC_FAST,

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

    raa7dc64 r0c968a17  
    7171#include <memstr.h>
    7272#include <macros.h>
     73#include <bitops.h>
    7374#include <arch.h>
    7475#include <errno.h>
    … …  
    8687 * Each architecture decides what functions will be used to carry out
    8788 * address space operations such as creating or locking page tables.
    88  *
    8989 */
    9090as_operations_t *as_operations = NULL;
    9191
    92 /**
    93  * Slab for as_t objects.
     92/** Slab for as_t objects.
    9493 *
    9594 */
    9695static slab_cache_t *as_slab;
    9796
    98 /**
    99  * This lock serializes access to the ASID subsystem.
    100  * It protects:
     97/** ASID subsystem lock.
     98 *
     99 * This lock protects:
    101100 * - inactive_as_with_asid_head list
    102101 * - as->asid for each as of the as_t type
    … …  
    107106
    108107/**
    109  * This list contains address spaces that are not active on any
    110  * processor and that have valid ASID.
    111  *
     108 * Inactive address spaces (on all processors)
     109 * that have valid ASID.
    112110 */
    113111LIST_INITIALIZE(inactive_as_with_asid_head);
    … …  
    123121        mutex_initialize(&as->lock, MUTEX_PASSIVE);
    124122       
    125         int rc = as_constructor_arch(as, flags);
    126        
    127         return rc;
     123        return as_constructor_arch(as, flags);
    128124}
    129125
    130126NO_TRACE static size_t as_destructor(void *obj)
    131127{
    132         as_t *as = (as_t *) obj;
    133         return as_destructor_arch(as);
     128        return as_destructor_arch((as_t *) obj);
    134129}
    135130
    … …  
    146141                panic("Cannot create kernel address space.");
    147142       
    148         /* Make sure the kernel address space
     143        /*
     144         * Make sure the kernel address space
    149145         * reference count never drops to zero.
    150146         */
    … …  
    195191{
    196192        DEADLOCK_PROBE_INIT(p_asidlock);
    197 
     193       
    198194        ASSERT(as != AS);
    199195        ASSERT(atomic_get(&as->refcount) == 0);
    … …  
    203199         * lock its mutex.
    204200         */
    205 
     201       
    206202        /*
    207203         * We need to avoid deadlock between TLB shootdown and asidlock.
    … …  
    210206         * disabled to prevent nested context switches. We also depend on the
    211207         * fact that so far no spinlocks are held.
    212          *
    213208         */
    214209        preemption_disable();
    … …  
    235230        spinlock_unlock(&asidlock);
    236231        interrupts_restore(ipl);
    237 
     232       
    238233       
    239234        /*
    … …  
    241236         * The B+tree must be walked carefully because it is
    242237         * also being destroyed.
    243          *
    244238         */
    245239        bool cond = true;
    … …  
    268262/** Hold a reference to an address space.
    269263 *
    270  * Holding a reference to an address space prevents destruction of that address
    271  * space.
     264 * Holding a reference to an address space prevents destruction
     265 * of that address space.
    272266 *
    273267 * @param as Address space to be held.
    … …  
    281275/** Release a reference to an address space.
    282276 *
    283  * The last one to release a reference to an address space destroys the address
    284  * space.
     277 * The last one to release a reference to an address space
     278 * destroys the address space.
    285279 *
    286280 * @param asAddress space to be released.
    … …  
    295289/** Check area conflicts with other areas.
    296290 *
    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.
     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.
    301295 *
    302296 * @return True if there is no conflict, false otherwise.
    303297 *
    304298 */
    305 NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size,
    306     as_area_t *avoid_area)
    307 {
     299NO_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);
    308303        ASSERT(mutex_locked(&as->lock));
    309304       
    310305        /*
    311306         * We don't want any area to have conflicts with NULL page.
    312          *
    313          */
    314         if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))
     307         */
     308        if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
    315309                return false;
    316310       
    … …  
    321315         * record in the left neighbour, the leftmost record in the right
    322316         * neighbour and all records in the leaf node itself.
    323          *
    324317         */
    325318        btree_node_t *leaf;
    326319        as_area_t *area =
    327             (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
     320            (as_area_t *) btree_search(&as->as_area_btree, addr, &leaf);
    328321        if (area) {
    329                 if (area != avoid_area)
     322                if (area != avoid)
    330323                        return false;
    331324        }
    … …  
    337330                area = (as_area_t *) node->value[node->keys - 1];
    338331               
    339                 mutex_lock(&area->lock);
    340                
    341                 if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
     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                       
    342341                        mutex_unlock(&area->lock);
    343                         return false;
    344                 }
    345                
    346                 mutex_unlock(&area->lock);
     342                }
    347343        }
    348344       
    … …  
    351347                area = (as_area_t *) node->value[0];
    352348               
    353                 mutex_lock(&area->lock);
    354                
    355                 if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
     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                       
    356358                        mutex_unlock(&area->lock);
    357                         return false;
    358                 }
    359                
    360                 mutex_unlock(&area->lock);
     359                }
    361360        }
    362361       
    … …  
    366365                area = (as_area_t *) leaf->value[i];
    367366               
    368                 if (area == avoid_area)
     367                if (area == avoid)
    369368                        continue;
    370369               
    371370                mutex_lock(&area->lock);
    372371               
    373                 if (overlaps(va, size, area->base, area->pages * PAGE_SIZE)) {
     372                if (overlaps(addr, count << PAGE_WIDTH,
     373                    area->base, area->pages << PAGE_WIDTH)) {
    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          *
    385384         */
    386385        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    387                 return !overlaps(va, size,
     386                return !overlaps(addr, count << PAGE_WIDTH,
    388387                    KERNEL_ADDRESS_SPACE_START,
    389388                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
    … …  
    412411    mem_backend_data_t *backend_data)
    413412{
    414         if (base % PAGE_SIZE)
     413        if ((base % PAGE_SIZE) != 0)
    415414                return NULL;
    416415       
    417         if (!size)
     416        if (size == 0)
    418417                return NULL;
     418       
     419        size_t pages = SIZE2FRAMES(size);
    419420       
    420421        /* Writeable executable areas are not supported. */
    … …  
    424425        mutex_lock(&as->lock);
    425426       
    426         if (!check_area_conflicts(as, base, size, NULL)) {
     427        if (!check_area_conflicts(as, base, pages, NULL)) {
    427428                mutex_unlock(&as->lock);
    428429                return NULL;
    … …  
    436437        area->flags = flags;
    437438        area->attributes = attrs;
    438         area->pages = SIZE2FRAMES(size);
     439        area->pages = pages;
     440        area->resident = 0;
    439441        area->base = base;
    440442        area->sh_info = NULL;
    … …  
    479481         * to find out whether this is a miss or va belongs to an address
    480482         * space area found there.
    481          *
    482483         */
    483484       
    … …  
    490491                mutex_lock(&area->lock);
    491492               
    492                 if ((area->base <= va) && (va < area->base + area->pages * PAGE_SIZE))
     493                if ((area->base <= va) &&
     494                    (va < area->base + (area->pages << PAGE_WIDTH)))
    493495                        return area;
    494496               
    … …  
    499501         * Second, locate the left neighbour and test its last record.
    500502         * Because of its position in the B+tree, it must have base < va.
    501          *
    502503         */
    503504        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
    … …  
    507508                mutex_lock(&area->lock);
    508509               
    509                 if (va < area->base + area->pages * PAGE_SIZE)
     510                if (va < area->base + (area->pages << PAGE_WIDTH))
    510511                        return area;
    511512               
    … …  
    534535        /*
    535536         * 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                  *
    549548                 */
    550549                mutex_unlock(&area->lock);
    … …  
    557556                 * Remapping of shared address space areas
    558557                 * is not supported.
    559                  *
    560558                 */
    561559                mutex_unlock(&area->lock);
    … …  
    568566                /*
    569567                 * Zero size address space areas are not allowed.
    570                  *
    571568                 */
    572569                mutex_unlock(&area->lock);
    … …  
    576573       
    577574        if (pages < area->pages) {
    578                 uintptr_t start_free = area->base + pages * PAGE_SIZE;
     575                uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
    579576               
    580577                /*
    581578                 * Shrinking the area.
    582579                 * No need to check for overlaps.
    583                  *
    584580                 */
    585581               
    … …  
    588584                /*
    589585                 * Start TLB shootdown sequence.
    590                  *
    591586                 */
    592587                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    593                     area->base + pages * PAGE_SIZE, area->pages - pages);
     588                    area->base + (pages << PAGE_WIDTH), area->pages - pages);
    594589               
    595590                /*
    … …  
    599594                 * is also the right way to remove part of the used_space
    600595                 * B+tree leaf list.
    601                  *
    602596                 */
    603597                bool cond = true;
    … …  
    615609                                size_t i = 0;
    616610                               
    617                                 if (overlaps(ptr, size * PAGE_SIZE, area->base,
    618                                     pages * PAGE_SIZE)) {
     611                                if (overlaps(ptr, size << PAGE_WIDTH, area->base,
     612                                    pages << PAGE_WIDTH)) {
    619613                                       
    620                                         if (ptr + size * PAGE_SIZE <= start_free) {
     614                                        if (ptr + (size << PAGE_WIDTH) <= start_free) {
    621615                                                /*
    622616                                                 * The whole interval fits
    623617                                                 * completely in the resized
    624618                                                 * address space area.
    625                                                  *
    626619                                                 */
    627620                                                break;
    … …  
    632625                                         * to b and c overlaps with the resized
    633626                                         * address space area.
    634                                          *
    635627                                         */
    636628                                       
    … …  
    652644                                for (; i < size; i++) {
    653645                                        pte_t *pte = page_mapping_find(as, ptr +
    654                                             i * PAGE_SIZE);
     646                                            (i << PAGE_WIDTH));
    655647                                       
    656648                                        ASSERT(pte);
    … …  
    661653                                            (area->backend->frame_free)) {
    662654                                                area->backend->frame_free(area,
    663                                                     ptr + i * PAGE_SIZE,
     655                                                    ptr + (i << PAGE_WIDTH),
    664656                                                    PTE_GET_FRAME(pte));
    665657                                        }
    666658                                       
    667659                                        page_mapping_remove(as, ptr +
    668                                             i * PAGE_SIZE);
     660                                            (i << PAGE_WIDTH));
    669661                                }
    670662                        }
    … …  
    673665                /*
    674666                 * Finish TLB shootdown sequence.
    675                  *
    676                  */
    677                
    678                 tlb_invalidate_pages(as->asid, area->base + pages * PAGE_SIZE,
     667                 */
     668               
     669                tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
    679670                    area->pages - pages);
    680671               
    681672                /*
    682673                 * Invalidate software translation caches (e.g. TSB on sparc64).
    683                  *
    684674                 */
    685675                as_invalidate_translation_cache(as, area->base +
    686                     pages * PAGE_SIZE, area->pages - pages);
     676                    (pages << PAGE_WIDTH), area->pages - pages);
    687677                tlb_shootdown_finalize(ipl);
    688678               
    … …  
    692682                 * Growing the area.
    693683                 * Check for overlaps with other address space areas.
    694                  *
    695                  */
    696                 if (!check_area_conflicts(as, address, pages * PAGE_SIZE,
    697                     area)) {
     684                 */
     685                if (!check_area_conflicts(as, address, pages, area)) {
    698686                        mutex_unlock(&area->lock);
    699687                        mutex_unlock(&as->lock);
    … …  
    794782                       
    795783                        for (size = 0; size < (size_t) node->value[i]; size++) {
    796                                 pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE);
     784                                pte_t *pte =
     785                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
    797786                               
    798787                                ASSERT(pte);
    … …  
    803792                                    (area->backend->frame_free)) {
    804793                                        area->backend->frame_free(area,
    805                                             ptr + size * PAGE_SIZE, PTE_GET_FRAME(pte));
     794                                            ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
    806795                                }
    807796                               
    808                                 page_mapping_remove(as, ptr + size * PAGE_SIZE);
     797                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
    809798                        }
    810799                }
    … …  
    813802        /*
    814803         * Finish TLB shootdown sequence.
    815          *
    816804         */
    817805       
    … …  
    821809         * Invalidate potential software translation caches (e.g. TSB on
    822810         * sparc64).
    823          *
    824811         */
    825812        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    839826        /*
    840827         * Remove the empty area from address space.
    841          *
    842828         */
    843829        btree_remove(&as->as_area_btree, base, NULL);
    … …  
    881867                /*
    882868                 * Could not find the source address space area.
    883                  *
    884869                 */
    885870                mutex_unlock(&src_as->lock);
    … …  
    891876                 * There is no backend or the backend does not
    892877                 * know how to share the area.
    893                  *
    894878                 */
    895879                mutex_unlock(&src_area->lock);
    … …  
    898882        }
    899883       
    900         size_t src_size = src_area->pages * PAGE_SIZE;
     884        size_t src_size = src_area->pages << PAGE_WIDTH;
    901885        unsigned int src_flags = src_area->flags;
    902886        mem_backend_t *src_backend = src_area->backend;
    … …  
    918902         * First, prepare the area for sharing.
    919903         * Then it will be safe to unlock it.
    920          *
    921904         */
    922905        share_info_t *sh_info = src_area->sh_info;
    … …  
    930913                /*
    931914                 * Call the backend to setup sharing.
    932                  *
    933915                 */
    934916                src_area->backend->share(src_area);
    … …  
    949931         * The flags of the source area are masked against dst_flags_mask
    950932         * to support sharing in less privileged mode.
    951          *
    952933         */
    953934        as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size,
    … …  
    966947         * fully initialized. Clear the AS_AREA_ATTR_PARTIAL
    967948         * attribute and set the sh_info.
    968          *
    969949         */
    970950        mutex_lock(&dst_as->lock);
    … …  
    989969NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
    990970{
     971        ASSERT(mutex_locked(&area->lock));
     972       
    991973        int flagmap[] = {
    992974                [PF_ACCESS_READ] = AS_AREA_READ,
    … …  
    994976                [PF_ACCESS_EXEC] = AS_AREA_EXEC
    995977        };
    996 
    997         ASSERT(mutex_locked(&area->lock));
    998978       
    999979        if (!(area->flags & flagmap[access]))
    … …  
    10661046        /*
    10671047         * Compute total number of used pages in the used_space B+tree
    1068          *
    10691048         */
    10701049        size_t used_pages = 0;
    … …  
    10881067        /*
    10891068         * Start TLB shootdown sequence.
    1090          *
    10911069         */
    10921070        ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base,
    … …  
    10961074         * Remove used pages from page tables and remember their frame
    10971075         * numbers.
    1098          *
    10991076         */
    11001077        size_t frame_idx = 0;
    … …  
    11111088                       
    11121089                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1113                                 pte_t *pte = page_mapping_find(as, ptr + size * PAGE_SIZE);
     1090                                pte_t *pte =
     1091                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
    11141092                               
    11151093                                ASSERT(pte);
    … …  
    11201098                               
    11211099                                /* Remove old mapping */
    1122                                 page_mapping_remove(as, ptr + size * PAGE_SIZE);
     1100                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
    11231101                        }
    11241102                }
    … …  
    11271105        /*
    11281106         * Finish TLB shootdown sequence.
    1129          *
    11301107         */
    11311108       
    … …  
    11351112         * Invalidate potential software translation caches (e.g. TSB on
    11361113         * sparc64).
    1137          *
    11381114         */
    11391115        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    11681144                               
    11691145                                /* Insert the new mapping */
    1170                                 page_mapping_insert(as, ptr + size * PAGE_SIZE,
     1146                                page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
    11711147                                    old_frame[frame_idx++], page_flags);
    11721148                               
    … …  
    12171193                 * No area contained mapping for 'page'.
    12181194                 * Signal page fault to low-level handler.
    1219                  *
    12201195                 */
    12211196                mutex_unlock(&AS->lock);
    … …  
    12371212                 * The address space area is not backed by any backend
    12381213                 * or the backend cannot handle page faults.
    1239                  *
    12401214                 */
    12411215                mutex_unlock(&area->lock);
    … …  
    12491223         * To avoid race condition between two page faults on the same address,
    12501224         * we need to make sure the mapping has not been already inserted.
    1251          *
    12521225         */
    12531226        pte_t *pte;
    … …  
    12671240        /*
    12681241         * Resort to the backend page fault handler.
    1269          *
    12701242         */
    12711243        if (area->backend->page_fault(area, page, access) != AS_PF_OK) {
    … …  
    13221294                 * preemption is disabled. We should not be
    13231295                 * holding any other lock.
    1324                  *
    13251296                 */
    13261297                (void) interrupts_enable();
    … …  
    13421313                         * list of inactive address spaces with assigned
    13431314                         * ASID.
    1344                          *
    13451315                         */
    13461316                        ASSERT(old_as->asid != ASID_INVALID);
    … …  
    13531323                 * Perform architecture-specific tasks when the address space
    13541324                 * is being removed from the CPU.
    1355                  *
    13561325                 */
    13571326                as_deinstall_arch(old_as);
    … …  
    13601329        /*
    13611330         * Second, prepare the new address space.
    1362          *
    13631331         */
    13641332        if ((new_as->cpu_refcount++ == 0) && (new_as != AS_KERNEL)) {
    … …  
    13761344         * Perform architecture-specific steps.
    13771345         * (e.g. write ASID to hardware register etc.)
    1378          *
    13791346         */
    13801347        as_install_arch(new_as);
    … …  
    13951362{
    13961363        ASSERT(mutex_locked(&area->lock));
    1397 
     1364       
    13981365        return area_flags_to_page_flags(area->flags);
    13991366}
    … …  
    14991466       
    15001467        if (src_area) {
    1501                 size = src_area->pages * PAGE_SIZE;
     1468                size = src_area->pages << PAGE_WIDTH;
    15021469                mutex_unlock(&src_area->lock);
    15031470        } else
    … …  
    15161483 * @param count Number of page to be marked.
    15171484 *
    1518  * @return Zero on failure and non-zero on success.
    1519  *
    1520  */
    1521 int used_space_insert(as_area_t *area, uintptr_t page, size_t count)
     1485 * @return False on failure or true on success.
     1486 *
     1487 */
     1488bool used_space_insert(as_area_t *area, uintptr_t page, size_t count)
    15221489{
    15231490        ASSERT(mutex_locked(&area->lock));
    … …  
    15301497                /*
    15311498                 * We hit the beginning of some used space.
    1532                  *
    1533                  */
    1534                 return 0;
     1499                 */
     1500                return false;
    15351501        }
    15361502       
    15371503        if (!leaf->keys) {
    15381504                btree_insert(&area->used_space, page, (void *) count, leaf);
    1539                 return 1;
     1505                goto success;
    15401506        }
    15411507       
    … …  
    15511517                 * somewhere between the rightmost interval of
    15521518                 * the left neigbour and the first interval of the leaf.
    1553                  *
    15541519                 */
    15551520               
    15561521                if (page >= right_pg) {
    15571522                        /* Do nothing. */
    1558                 } else if (overlaps(page, count * PAGE_SIZE, left_pg,
    1559                     left_cnt * PAGE_SIZE)) {
     1523                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1524                    left_cnt << PAGE_WIDTH)) {
    15601525                        /* The interval intersects with the left interval. */
    1561                         return 0;
    1562                 } else if (overlaps(page, count * PAGE_SIZE, right_pg,
    1563                     right_cnt * PAGE_SIZE)) {
     1526                        return false;
     1527                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1528                    right_cnt << PAGE_WIDTH)) {
    15641529                        /* The interval intersects with the right interval. */
    1565                         return 0;
    1566                 } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
    1567                     (page + count * PAGE_SIZE == right_pg)) {
     1530                        return false;
     1531                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1532                    (page + (count << PAGE_WIDTH) == right_pg)) {
    15681533                        /*
    15691534                         * The interval can be added by merging the two already
    15701535                         * present intervals.
    1571                          *
    15721536                         */
    15731537                        node->value[node->keys - 1] += count + right_cnt;
    15741538                        btree_remove(&area->used_space, right_pg, leaf);
    1575                         return 1;
    1576                 } else if (page == left_pg + left_cnt * PAGE_SIZE) {
     1539                        goto success;
     1540                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    15771541                        /*
    15781542                         * The interval can be added by simply growing the left
    15791543                         * interval.
    1580                          *
    15811544                         */
    15821545                        node->value[node->keys - 1] += count;
    1583                         return 1;
    1584                 } else if (page + count * PAGE_SIZE == right_pg) {
     1546                        goto success;
     1547                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    15851548                        /*
    15861549                         * The interval can be addded by simply moving base of
    15871550                         * the right interval down and increasing its size
    15881551                         * accordingly.
    1589                          *
    15901552                         */
    15911553                        leaf->value[0] += count;
    15921554                        leaf->key[0] = page;
    1593                         return 1;
     1555                        goto success;
    15941556                } else {
    15951557                        /*
    15961558                         * The interval is between both neigbouring intervals,
    15971559                         * but cannot be merged with any of them.
    1598                          *
    15991560                         */
    16001561                        btree_insert(&area->used_space, page, (void *) count,
    16011562                            leaf);
    1602                         return 1;
     1563                        goto success;
    16031564                }
    16041565        } else if (page < leaf->key[0]) {
    … …  
    16091570                 * Investigate the border case in which the left neighbour does
    16101571                 * not exist but the interval fits from the left.
    1611                  *
    1612                  */
    1613                
    1614                 if (overlaps(page, count * PAGE_SIZE, right_pg,
    1615                     right_cnt * PAGE_SIZE)) {
     1572                 */
     1573               
     1574                if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1575                    right_cnt << PAGE_WIDTH)) {
    16161576                        /* The interval intersects with the right interval. */
    1617                         return 0;
    1618                 } else if (page + count * PAGE_SIZE == right_pg) {
     1577                        return false;
     1578                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    16191579                        /*
    16201580                         * The interval can be added by moving the base of the
    16211581                         * right interval down and increasing its size
    16221582                         * accordingly.
    1623                          *
    16241583                         */
    16251584                        leaf->key[0] = page;
    16261585                        leaf->value[0] += count;
    1627                         return 1;
     1586                        goto success;
    16281587                } else {
    16291588                        /*
    16301589                         * The interval doesn't adjoin with the right interval.
    16311590                         * It must be added individually.
    1632                          *
    16331591                         */
    16341592                        btree_insert(&area->used_space, page, (void *) count,
    16351593                            leaf);
    1636                         return 1;
     1594                        goto success;
    16371595                }
    16381596        }
    … …  
    16491607                 * somewhere between the leftmost interval of
    16501608                 * the right neigbour and the last interval of the leaf.
    1651                  *
    16521609                 */
    16531610               
    16541611                if (page < left_pg) {
    16551612                        /* Do nothing. */
    1656                 } else if (overlaps(page, count * PAGE_SIZE, left_pg,
    1657                     left_cnt * PAGE_SIZE)) {
     1613                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1614                    left_cnt << PAGE_WIDTH)) {
    16581615                        /* The interval intersects with the left interval. */
    1659                         return 0;
    1660                 } else if (overlaps(page, count * PAGE_SIZE, right_pg,
    1661                     right_cnt * PAGE_SIZE)) {
     1616                        return false;
     1617                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1618                    right_cnt << PAGE_WIDTH)) {
    16621619                        /* The interval intersects with the right interval. */
    1663                         return 0;
    1664                 } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
    1665                     (page + count * PAGE_SIZE == right_pg)) {
     1620                        return false;
     1621                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1622                    (page + (count << PAGE_WIDTH) == right_pg)) {
    16661623                        /*
    16671624                         * The interval can be added by merging the two already
    16681625                         * present intervals.
    1669                          *
    16701626                         */
    16711627                        leaf->value[leaf->keys - 1] += count + right_cnt;
    16721628                        btree_remove(&area->used_space, right_pg, node);
    1673                         return 1;
    1674                 } else if (page == left_pg + left_cnt * PAGE_SIZE) {
     1629                        goto success;
     1630                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    16751631                        /*
    16761632                         * The interval can be added by simply growing the left
    16771633                         * interval.
    1678                          *
    16791634                         */
    1680                         leaf->value[leaf->keys - 1] +=  count;
    1681                         return 1;
    1682                 } else if (page + count * PAGE_SIZE == right_pg) {
     1635                        leaf->value[leaf->keys - 1] += count;
     1636                        goto success;
     1637                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    16831638                        /*
    16841639                         * The interval can be addded by simply moving base of
    16851640                         * the right interval down and increasing its size
    16861641                         * accordingly.
    1687                          *
    16881642                         */
    16891643                        node->value[0] += count;
    16901644                        node->key[0] = page;
    1691                         return 1;
     1645                        goto success;
    16921646                } else {
    16931647                        /*
    16941648                         * The interval is between both neigbouring intervals,
    16951649                         * but cannot be merged with any of them.
    1696                          *
    16971650                         */
    16981651                        btree_insert(&area->used_space, page, (void *) count,
    16991652                            leaf);
    1700                         return 1;
     1653                        goto success;
    17011654                }
    17021655        } else if (page >= leaf->key[leaf->keys - 1]) {
    … …  
    17071660                 * Investigate the border case in which the right neighbour
    17081661                 * does not exist but the interval fits from the right.
    1709                  *
    1710                  */
    1711                
    1712                 if (overlaps(page, count * PAGE_SIZE, left_pg,
    1713                     left_cnt * PAGE_SIZE)) {
     1662                 */
     1663               
     1664                if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1665                    left_cnt << PAGE_WIDTH)) {
    17141666                        /* The interval intersects with the left interval. */
    1715                         return 0;
    1716                 } else if (left_pg + left_cnt * PAGE_SIZE == page) {
     1667                        return false;
     1668                } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
    17171669                        /*
    17181670                         * The interval can be added by growing the left
    17191671                         * interval.
    1720                          *
    17211672                         */
    17221673                        leaf->value[leaf->keys - 1] += count;
    1723                         return 1;
     1674                        goto success;
    17241675                } else {
    17251676                        /*
    17261677                         * The interval doesn't adjoin with the left interval.
    17271678                         * It must be added individually.
    1728                          *
    17291679                         */
    17301680                        btree_insert(&area->used_space, page, (void *) count,
    17311681                            leaf);
    1732                         return 1;
     1682                        goto success;
    17331683                }
    17341684        }
    … …  
    17381688         * only between two other intervals of the leaf. The two border cases
    17391689         * were already resolved.
    1740          *
    17411690         */
    17421691        btree_key_t i;
    … …  
    17501699                        /*
    17511700                         * The interval fits between left_pg and right_pg.
    1752                          *
    17531701                         */
    17541702                       
    1755                         if (overlaps(page, count * PAGE_SIZE, left_pg,
    1756                             left_cnt * PAGE_SIZE)) {
     1703                        if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1704                            left_cnt << PAGE_WIDTH)) {
    17571705                                /*
    17581706                                 * The interval intersects with the left
    17591707                                 * interval.
    1760                                  *
    17611708                                 */
    1762                                 return 0;
    1763                         } else if (overlaps(page, count * PAGE_SIZE, right_pg,
    1764                             right_cnt * PAGE_SIZE)) {
     1709                                return false;
     1710                        } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1711                            right_cnt << PAGE_WIDTH)) {
    17651712                                /*
    17661713                                 * The interval intersects with the right
    17671714                                 * interval.
    1768                                  *
    17691715                                 */
    1770                                 return 0;
    1771                         } else if ((page == left_pg + left_cnt * PAGE_SIZE) &&
    1772                             (page + count * PAGE_SIZE == right_pg)) {
     1716                                return false;
     1717                        } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1718                            (page + (count << PAGE_WIDTH) == right_pg)) {
    17731719                                /*
    17741720                                 * The interval can be added by merging the two
    17751721                                 * already present intervals.
    1776                                  *
    17771722                                 */
    17781723                                leaf->value[i - 1] += count + right_cnt;
    17791724                                btree_remove(&area->used_space, right_pg, leaf);
    1780                                 return 1;
    1781                         } else if (page == left_pg + left_cnt * PAGE_SIZE) {
     1725                                goto success;
     1726                        } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    17821727                                /*
    17831728                                 * The interval can be added by simply growing
    17841729                                 * the left interval.
    1785                                  *
    17861730                                 */
    17871731                                leaf->value[i - 1] += count;
    1788                                 return 1;
    1789                         } else if (page + count * PAGE_SIZE == right_pg) {
     1732                                goto success;
     1733                        } else if (page + (count << PAGE_WIDTH) == right_pg) {
    17901734                                /*
    17911735                                 * The interval can be addded by simply moving
    17921736                                 * base of the right interval down and
    17931737                                 * increasing its size accordingly.
    1794                                  *
    17951738                                 */
    17961739                                leaf->value[i] += count;
    17971740                                leaf->key[i] = page;
    1798                                 return 1;
     1741                                goto success;
    17991742                        } else {
    18001743                                /*
    … …  
    18021745                                 * intervals, but cannot be merged with any of
    18031746                                 * them.
    1804                                  *
    18051747                                 */
    18061748                                btree_insert(&area->used_space, page,
    18071749                                    (void *) count, leaf);
    1808                                 return 1;
     1750                                goto success;
    18091751                        }
    18101752                }
    … …  
    18131755        panic("Inconsistency detected while adding %zu pages of used "
    18141756            "space at %p.", count, (void *) page);
     1757       
     1758success:
     1759        area->resident += count;
     1760        return true;
    18151761}
    18161762
    … …  
    18231769 * @param count Number of page to be marked.
    18241770 *
    1825  * @return Zero on failure and non-zero on success.
    1826  *
    1827  */
    1828 int used_space_remove(as_area_t *area, uintptr_t page, size_t count)
     1771 * @return False on failure or true on success.
     1772 *
     1773 */
     1774bool used_space_remove(as_area_t *area, uintptr_t page, size_t count)
    18291775{
    18301776        ASSERT(mutex_locked(&area->lock));
    … …  
    18371783                /*
    18381784                 * We are lucky, page is the beginning of some interval.
    1839                  *
    18401785                 */
    18411786                if (count > pages) {
    1842                         return 0;
     1787                        return false;
    18431788                } else if (count == pages) {
    18441789                        btree_remove(&area->used_space, page, leaf);
    1845                         return 1;
     1790                        goto success;
    18461791                } else {
    18471792                        /*
    18481793                         * Find the respective interval.
    18491794                         * Decrease its size and relocate its start address.
    1850                          *
    18511795                         */
    18521796                        btree_key_t i;
    18531797                        for (i = 0; i < leaf->keys; i++) {
    18541798                                if (leaf->key[i] == page) {
    1855                                         leaf->key[i] += count * PAGE_SIZE;
     1799                                        leaf->key[i] += count << PAGE_WIDTH;
    18561800                                        leaf->value[i] -= count;
    1857                                         return 1;
     1801                                        goto success;
    18581802                                }
    18591803                        }
     1804                       
    18601805                        goto error;
    18611806                }
    … …  
    18671812                size_t left_cnt = (size_t) node->value[node->keys - 1];
    18681813               
    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) {
     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)) {
    18731818                                /*
    18741819                                 * The interval is contained in the rightmost
    … …  
    18761821                                 * removed by updating the size of the bigger
    18771822                                 * interval.
    1878                                  *
    18791823                                 */
    18801824                                node->value[node->keys - 1] -= count;
    1881                                 return 1;
    1882                         } else if (page + count * PAGE_SIZE <
    1883                             left_pg + left_cnt*PAGE_SIZE) {
     1825                                goto success;
     1826                        } else if (page + (count << PAGE_WIDTH) <
     1827                            left_pg + (left_cnt << PAGE_WIDTH)) {
    18841828                                /*
    18851829                                 * The interval is contained in the rightmost
    … …  
    18881832                                 * the original interval and also inserting a
    18891833                                 * new interval.
    1890                                  *
    18911834                                 */
    1892                                 size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
    1893                                     (page + count*PAGE_SIZE)) >> PAGE_WIDTH;
     1835                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
     1836                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
    18941837                                node->value[node->keys - 1] -= count + new_cnt;
    18951838                                btree_insert(&area->used_space, page +
    1896                                     count * PAGE_SIZE, (void *) new_cnt, leaf);
    1897                                 return 1;
     1839                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
     1840                                goto success;
    18981841                        }
    18991842                }
    1900                 return 0;
     1843               
     1844                return false;
    19011845        } else if (page < leaf->key[0])
    1902                 return 0;
     1846                return false;
    19031847       
    19041848        if (page > leaf->key[leaf->keys - 1]) {
    … …  
    19061850                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    19071851               
    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) {
     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)) {
    19121856                                /*
    19131857                                 * The interval is contained in the rightmost
    19141858                                 * interval of the leaf and can be removed by
    19151859                                 * updating the size of the bigger interval.
    1916                                  *
    19171860                                 */
    19181861                                leaf->value[leaf->keys - 1] -= count;
    1919                                 return 1;
    1920                         } else if (page + count * PAGE_SIZE < left_pg +
    1921                             left_cnt * PAGE_SIZE) {
     1862                                goto success;
     1863                        } else if (page + (count << PAGE_WIDTH) < left_pg +
     1864                            (left_cnt << PAGE_WIDTH)) {
    19221865                                /*
    19231866                                 * The interval is contained in the rightmost
    … …  
    19261869                                 * original interval and also inserting a new
    19271870                                 * interval.
    1928                                  *
    19291871                                 */
    1930                                 size_t new_cnt = ((left_pg + left_cnt * PAGE_SIZE) -
    1931                                     (page + count * PAGE_SIZE)) >> PAGE_WIDTH;
     1872                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
     1873                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
    19321874                                leaf->value[leaf->keys - 1] -= count + new_cnt;
    19331875                                btree_insert(&area->used_space, page +
    1934                                     count * PAGE_SIZE, (void *) new_cnt, leaf);
    1935                                 return 1;
     1876                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
     1877                                goto success;
    19361878                        }
    19371879                }
    1938                 return 0;
     1880               
     1881                return false;
    19391882        }
    19401883       
    19411884        /*
    19421885         * The border cases have been already resolved.
    1943          * Now the interval can be only between intervals of the leaf. 
     1886         * Now the interval can be only between intervals of the leaf.
    19441887         */
    19451888        btree_key_t i;
    … …  
    19531896                         * to (i - 1) and i.
    19541897                         */
    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) {
     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)) {
    19591902                                        /*
    19601903                                         * The interval is contained in the
    … …  
    19621905                                         * be removed by updating the size of
    19631906                                         * the bigger interval.
    1964                                          *
    19651907                                         */
    19661908                                        leaf->value[i - 1] -= count;
    1967                                         return 1;
    1968                                 } else if (page + count * PAGE_SIZE <
    1969                                     left_pg + left_cnt * PAGE_SIZE) {
     1909                                        goto success;
     1910                                } else if (page + (count << PAGE_WIDTH) <
     1911                                    left_pg + (left_cnt << PAGE_WIDTH)) {
    19701912                                        /*
    19711913                                         * The interval is contained in the
    … …  
    19761918                                         */
    19771919                                        size_t new_cnt = ((left_pg +
    1978                                             left_cnt * PAGE_SIZE) -
    1979                                             (page + count * PAGE_SIZE)) >>
     1920                                            (left_cnt << PAGE_WIDTH)) -
     1921                                            (page + (count << PAGE_WIDTH))) >>
    19801922                                            PAGE_WIDTH;
    19811923                                        leaf->value[i - 1] -= count + new_cnt;
    19821924                                        btree_insert(&area->used_space, page +
    1983                                             count * PAGE_SIZE, (void *) new_cnt,
     1925                                            (count << PAGE_WIDTH), (void *) new_cnt,
    19841926                                            leaf);
    1985                                         return 1;
     1927                                        goto success;
    19861928                                }
    19871929                        }
    1988                         return 0;
     1930                       
     1931                        return false;
    19891932                }
    19901933        }
    … …  
    19931936        panic("Inconsistency detected while removing %zu pages of used "
    19941937            "space from %p.", count, (void *) page);
     1938       
     1939success:
     1940        area->resident -= count;
     1941        return true;
    19951942}
    19961943
    … …  
    20271974}
    20281975
     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 */
     1984sysarg_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;
     2040}
     2041
    20292042/** Get list of adress space areas.
    20302043 *
    … …  
    20932106        mutex_lock(&as->lock);
    20942107       
    2095         /* print out info about address space areas */
     2108        /* Print out info about address space areas */
    20962109        link_t *cur;
    20972110        for (cur = as->as_area_btree.leaf_head.next;

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

    raa7dc64 r0c968a17  
    171171        void *loader = program_loader;
    172172        if (!loader) {
     173                as_destroy(as);
    173174                printf("Cannot spawn loader as none was registered\n");
    174175                return ENOENT;
    … …  
    179180        if (rc != EE_OK) {
    180181                as_destroy(as);
     182                printf("Cannot spawn loader (%s)\n", elf_error(rc));
    181183                return ENOENT;
    182184        }

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

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

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

    raa7dc64 r0c968a17  
    160160static size_t get_task_virtmem(as_t *as)
    161161{
    162         size_t result = 0;
    163 
    164162        /*
    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.
     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.
    173167         */
    174 
     168       
    175169        if (SYNCH_FAILED(mutex_trylock(&as->lock)))
    176                 return result * PAGE_SIZE;
     170                return 0;
     171       
     172        size_t pages = 0;
    177173       
    178174        /* 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  */
    208 static 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 */
    227175        link_t *cur;
    228176        for (cur = as->as_area_btree.leaf_head.next;
    … …  
    238186                                continue;
    239187                       
    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                        
     188                        pages += area->pages;
    252189                        mutex_unlock(&area->lock);
    253190                }
    … …  
    256193        mutex_unlock(&as->lock);
    257194       
    258         return result * PAGE_SIZE;
     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 */
     205static 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);
    259241}
    260242

  • uspace/app/taskdump/taskdump.c

    raa7dc64 r0c968a17  
    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
    408421        free(file_name);
    409422        printf("Failed autoloading symbol table.\n");

  • uspace/lib/block/libblock.c

    raa7dc64 r0c968a17  
    294294
    295295        /* Allow 1:1 or small-to-large block size translation */
    296         if (cache->lblock_size % devcon->pblock_size != 0)
     296        if (cache->lblock_size % devcon->pblock_size != 0) {
     297                free(cache);
    297298                return ENOTSUP;
     299        }
    298300
    299301        cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
    … …  
    436438                        if (!b->data) {
    437439                                free(b);
     440                                b = NULL;
    438441                                goto recycle;
    439442                        }
    … …  
    563566        assert(devcon);
    564567        assert(devcon->cache);
     568        assert(block->refcnt >= 1);
    565569
    566570        cache = devcon->cache;
    … …  
    622626                        unsigned long key = block->lba;
    623627                        hash_table_remove(&cache->block_hash, &key, 1);
     628                        free(block->data);
    624629                        free(block);
    625                         free(block->data);
    626630                        cache->blocks_cached--;
    627631                        fibril_mutex_unlock(&cache->lock);

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

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

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

    raa7dc64 r0c968a17  
    4242        } :data
    4343       
    44         . = ALIGN(0x1000);
    45         _heap = .;
    46        
    4744#ifdef CONFIG_LINE_DEBUG
    4845        .comment 0 : { *(.comment); } :debug
    … …  
    6158                *(*);
    6259        }
    63 
    6460}

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

    raa7dc64 r0c968a17  
    99SECTIONS {
    1010        . = 0x1000 + SIZEOF_HEADERS;
    11 
     11       
    1212        .init : {
    1313                *(.init);
    14         } : text
     14        } :text
     15       
    1516        .text : {
    1617                *(.text);
    17         *(.rodata*);
     18                *(.rodata*);
    1819        } :text
    19 
     20       
    2021        . = . + 0x1000;
    21 
     22       
    2223        .data : {
    2324                *(.opd);
    … …  
    2526                *(.sdata);
    2627        } :data
     28       
    2729        .tdata : {
    2830                _tdata_start = .;
    … …  
    3335                _tbss_end = .;
    3436        } :data
     37       
    3538        _tls_alignment = ALIGNOF(.tdata);
     39       
    3640        .bss : {
    3741                *(.sbss);
    3842                *(.scommon);
    39         *(COMMON);
    40         *(.bss);
     43                *(COMMON);
     44                *(.bss);
    4145        } :data
    42        
    43         . = ALIGN(0x1000);
    44         _heap = .;
    4546       
    4647        /DISCARD/ : {
    4748                *(*);
    4849        }
    49 
    5050}

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

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

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

    raa7dc64 r0c968a17  
    99SECTIONS {
    1010        . = 0x4000 + SIZEOF_HEADERS;
    11 
     11       
    1212        .init : {
    1313                *(.init);
    14         } : text
     14        } :text
     15       
    1516        .text : {
    1617                *(.text);
    1718                *(.rodata*);
    1819        } :text
    19 
     20       
    2021        . = . + 0x4000;
    21 
     22       
    2223        .got : {
    2324                _gp = .;
    2425                *(.got*);
    25         } :data
     26        } :data
     27       
    2628        .data : {
    2729                *(.opd);
    … …  
    2931                *(.sdata);
    3032        } :data
     33       
    3134        .tdata : {
    3235                _tdata_start = .;
    … …  
    3740                _tbss_end = .;
    3841        } :data
     42       
    3943        _tls_alignment = ALIGNOF(.tdata);
     44       
    4045        .bss : {
    4146                *(.sbss);
    … …  
    4449                *(.bss);
    4550        } :data
    46 
    47         . = ALIGN(0x4000);
    48         _heap = .;
    49  
     51       
    5052        /DISCARD/ : {
    5153                *(*);
    52         }
     54        }
    5355}

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

    raa7dc64 r0c968a17  
    1313                *(.init);
    1414        } :text
     15       
    1516        .text : {
    16                 *(.text);
     17                *(.text);
    1718                *(.rodata*);
    1819        } :text
    19 
     20       
    2021        . = . + 0x4000;
    21 
     22       
    2223        .data : {
    2324                *(.data);
    2425                *(.data.rel*);
    2526        } :data
    26 
     27       
    2728        .got : {
    2829                _gp = .;
    2930                *(.got);
    3031        } :data
    31 
     32       
    3233        .tdata : {
    3334                _tdata_start = .;
    3435                *(.tdata);
    3536                _tdata_end = .;
     37        } :data
     38       
     39        .tbss : {
    3640                _tbss_start = .;
    3741                *(.tbss);
    3842                _tbss_end = .;
    3943        } :data
    40         _tls_alignment = ALIGNOF(.tdata);
    41 
     44       
     45        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
     46       
    4247        .sbss : {
    4348                *(.scommon);
    4449                *(.sbss);
    45         }       
     50        }
     51       
    4652        .bss : {
    4753                *(.bss);
    4854                *(COMMON);
    4955        } :data
    50 
    51         . = ALIGN(0x4000);
    52         _heap = .;
    53 
     56       
    5457        /DISCARD/ : {
    5558                *(*);

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

    raa7dc64 r0c968a17  
    2929.text
    3030.section .init, "ax"
     31
    3132.global __entry
    32 .global __entry_driver
     33
    3334.set noreorder
    3435.option pic2
    … …  
    5758        nop
    5859.end
    59 
    60 # Alignment of output section data to 0x4000
    61 .section .data
    62 .align 14

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

    raa7dc64 r0c968a17  
    99SECTIONS {
    1010        . = 0x1000 + SIZEOF_HEADERS;
    11 
     11       
    1212        .init : {
    1313                *(.init);
    1414        } :text
     15       
    1516        .text : {
    1617                *(.text);
    1718                *(.rodata*);
    1819        } :text
    19 
     20       
    2021        . = . + 0x1000;
    21 
     22       
    2223        .data : {
    2324                *(.data);
    2425                *(.sdata);
    2526        } :data
     27       
    2628        .tdata : {
    2729                _tdata_start = .;
    … …  
    3234                _tbss_end = .;
    3335        } :data
     36       
    3437        _tls_alignment = ALIGNOF(.tdata);
     38       
    3539        .bss : {
    3640                *(.sbss);
    … …  
    3842                *(.bss);
    3943        } :data
    40 
    41         . = ALIGN(0x1000);
    42         _heap = .;
    4344       
    4445        /DISCARD/ : {
    4546                *(*);
    4647        }
    47 
    4848}

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

    raa7dc64 r0c968a17  
    99SECTIONS {
    1010        . = 0x4000 + SIZEOF_HEADERS;
    11 
     11       
    1212        .init : {
    1313                *(.init);
    1414        } :text
     15       
    1516        .text : {
    1617                *(.text);
    1718                *(.rodata*);
    1819        } :text
    19 
     20       
    2021        . = . + 0x4000;
    21 
     22       
    2223        .got : {
    2324                 _gp = .;
    2425                 *(.got*);
    2526        } :data
     27       
    2628        .data : {
    2729                *(.data);
    2830                *(.sdata);
    2931        } :data
     32       
    3033        .tdata : {
    3134                _tdata_start = .;
    … …  
    3639                _tbss_end = .;
    3740        } :data
     41       
    3842        _tls_alignment = ALIGNOF(.tdata);
     43       
    3944        .bss : {
    4045                *(.sbss);
    … …  
    4247                *(.bss);
    4348        } :data
    44 
    45         . = ALIGN(0x4000);
    46         _heap = .;
    4749       
    4850        /DISCARD/ : {
    4951                *(*);
    5052        }
    51 
    5253}

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

    raa7dc64 r0c968a17  
    4040#include <bitops.h>
    4141#include <malloc.h>
    42 
    43 /** Last position allocated by as_get_mappable_page */
    44 static uintptr_t last_allocated = 0;
     42#include "private/libc.h"
    4543
    4644/** Create address space area.
    … …  
    103101}
    104102
    105 /** Return pointer to some unmapped area, where fits new as_area
     103/** Return pointer to unmapped address space area
    106104 *
    107105 * @param size Requested size of the allocation.
    108106 *
    109  * @return pointer to the beginning
     107 * @return Pointer to the beginning of unmapped address space area.
    110108 *
    111109 */
    112110void *as_get_mappable_page(size_t size)
    113111{
    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);
     112        return (void *) __SYSCALL2(SYS_AS_GET_UNMAPPED_AREA,
     113            (sysarg_t) __entry, (sysarg_t) size);
    128114}
    129115

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

    raa7dc64 r0c968a17  
    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  */
    304296static void conn_remove(link_t *item)
    305297{
    306         free(hash_table_get_instance(item, connection_t, link));
    307298}
    308299
    … …  
    647638                ipc_answer_0(FIBRIL_connection->close_callid, EOK);
    648639       
     640        free(FIBRIL_connection);
    649641        return 0;
    650642}

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

    raa7dc64 r0c968a17  
    4747#include "private/malloc.h"
    4848
    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) */
     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 */
    5764#define BASE_ALIGN  16
    5865
    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)
     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 *
    7174 */
    7275#define GROSS_SIZE(size)  ((size) + STRUCT_OVERHEAD)
    7376
    74 /**
    75  * Calculate net size of a heap block (without header and footer)
     77/** Calculate net size of a heap block.
     78 *
     79 * Subtract header and footer size.
     80 *
    7681 */
    7782#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 */
     105typedef 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;
    78122
    79123/** Header of a heap block
    … …  
    87131        bool free;
    88132       
     133        /** Heap area this block belongs to */
     134        heap_area_t *area;
     135       
    89136        /* A magic value to detect overwrite of heap header */
    90137        uint32_t magic;
    … …  
    102149} heap_block_foot_t;
    103150
    104 /** Linker heap symbol */
    105 extern char _heap;
     151/** First heap area */
     152static heap_area_t *first_heap_area = NULL;
     153
     154/** Last heap area */
     155static heap_area_t *last_heap_area = NULL;
     156
     157/** Next heap block to examine (next fit algorithm) */
     158static heap_block_head_t *next = NULL;
    106159
    107160/** Futex for thread-safe heap manipulation */
    108161static futex_t malloc_futex = FUTEX_INITIALIZER;
    109162
    110 /** Address of heap start */
    111 static void *heap_start = 0;
    112 
    113 /** Address of heap end */
    114 static void *heap_end = 0;
    115 
    116 /** Maximum heap size */
    117 static size_t max_heap_size = (size_t) -1;
    118 
    119 /** Current number of pages of heap area */
    120 static size_t heap_pages = 0;
    121 
    122163/** Initialize a heap block
    123164 *
    124  * Fills in the structures related to a heap block.
     165 * Fill in the structures related to a heap block.
    125166 * Should be called only inside the critical section.
    126167 *
    … …  
    128169 * @param size Size of the block including the header and the footer.
    129170 * @param free Indication of a free block.
    130  *
    131  */
    132 static void block_init(void *addr, size_t size, bool free)
     171 * @param area Heap area the block belongs to.
     172 *
     173 */
     174static void block_init(void *addr, size_t size, bool free, heap_area_t *area)
    133175{
    134176        /* Calculate the position of the header and the footer */
    135177        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));
    138178       
    139179        head->size = size;
    140180        head->free = free;
     181        head->area = area;
    141182        head->magic = HEAP_BLOCK_HEAD_MAGIC;
     183       
     184        heap_block_foot_t *foot = BLOCK_FOOT(head);
    142185       
    143186        foot->size = size;
    … …  
    160203        assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
    161204       
    162         heap_block_foot_t *foot =
    163             (heap_block_foot_t *) (addr + head->size - sizeof(heap_block_foot_t));
     205        heap_block_foot_t *foot = BLOCK_FOOT(head);
    164206       
    165207        assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
    … …  
    167209}
    168210
    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  */
    176 static bool grow_heap(size_t size)
     211/** Check a heap area structure
     212 *
     213 * @param addr Address of the heap area.
     214 *
     215 */
     216static 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 */
     232static bool area_create(size_t size)
     233{
     234        void *start = as_get_mappable_page(size);
     235        if (start == NULL)
     236                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)
     244                return false;
     245       
     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 */
     276static bool area_grow(heap_area_t *area, size_t size)
    177277{
    178278        if (size == 0)
     279                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)
    179292                return false;
    180 
    181         if ((heap_start + size < heap_start) || (heap_end + size < heap_end))
     293       
     294        /* Resize the address space area */
     295        int ret = as_area_resize(area->start, asize, 0);
     296        if (ret != EOK)
    182297                return false;
    183298       
    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;
     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 */
     313static bool heap_grow(size_t size)
     314{
     315        if (size == 0)
    198316                return true;
    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  */
    211 static void shrink_heap(void)
    212 {
    213         // TODO
     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 */
     334static void heap_shrink(void)
     335{
     336        next = NULL;
    214337}
    215338
    … …  
    223346void __malloc_init(void)
    224347{
    225         if (!as_area_create((void *) &_heap, PAGE_SIZE,
    226             AS_AREA_WRITE | AS_AREA_READ))
     348        if (!area_create(PAGE_SIZE))
    227349                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  */
    241 uintptr_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;
    254350}
    255351
    … …  
    273369                /* Block big enough -> split. */
    274370                void *next = ((void *) cur) + size;
    275                 block_init(next, cur->size - size, true);
    276                 block_init(cur, size, false);
     371                block_init(next, cur->size - size, true, cur->area);
     372                block_init(cur, size, false, cur->area);
    277373        } else {
    278374                /* Block too small -> use as is. */
    … …  
    281377}
    282378
    283 /** Allocate a memory block
     379/** Allocate memory from heap area starting from given block
    284380 *
    285381 * Should be called only inside the critical section.
    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  */
    293 static 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        
    304 loop:
    305         result = NULL;
    306         heap_block_head_t *cur = (heap_block_head_t *) heap_start;
    307        
    308         while ((result == NULL) && ((void *) cur < heap_end)) {
     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 */
     395static 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)) {
    309405                block_check(cur);
     406               
     407                /* Finish searching on the final block */
     408                if ((final_block != NULL) && (cur == final_block))
     409                        break;
    310410               
    311411                /* Try to find a block that is free and large enough. */
    312412                if ((cur->free) && (cur->size >= real_size)) {
    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);
     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);
    317421                       
    318422                        if (addr == aligned) {
    319423                                /* Exact block start including alignment. */
    320424                                split_mark(cur, real_size);
    321                                 result = addr;
     425                               
     426                                next = cur;
     427                                return addr;
    322428                        } else {
    323429                                /* Block start has to be aligned */
    … …  
    325431                               
    326432                                if (cur->size >= real_size + excess) {
    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);
     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));
    335445                                               
    336                                                 heap_block_head_t *prev_head =
    337                                                     (heap_block_head_t *) (((void *) cur) - prev_foot->size);
     446                                                heap_block_head_t *prev_head = (heap_block_head_t *)
     447                                                    ((void *) cur - prev_foot->size);
    338448                                               
    339449                                                block_check(prev_head);
    … …  
    342452                                                heap_block_head_t *next_head = ((void *) cur) + excess;
    343453                                               
    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);
     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);
    349463                                                } else {
    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);
     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);
    354473                                                }
    355474                                               
    356                                                 block_init(next_head, reduced_size, true);
     475                                                block_init(next_head, reduced_size, true, area);
    357476                                                split_mark(next_head, real_size);
    358                                                 result = aligned;
    359                                                 cur = next_head;
     477                                               
     478                                                next = next_head;
     479                                                return aligned;
    360480                                        } else {
    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 */
     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                                                 */
    365488                                                while (excess < STRUCT_OVERHEAD) {
    366489                                                        aligned += falign;
    … …  
    371494                                                if (cur->size >= real_size + excess) {
    372495                                                        size_t reduced_size = cur->size - excess;
    373                                                         cur = (heap_block_head_t *) (heap_start + excess);
     496                                                        cur = (heap_block_head_t *)
     497                                                            (AREA_FIRST_BLOCK(area) + excess);
    374498                                                       
    375                                                         block_init(heap_start, excess, true);
    376                                                         block_init(cur, reduced_size, true);
     499                                                        block_init((void *) AREA_FIRST_BLOCK(area), excess,
     500                                                            true, area);
     501                                                        block_init(cur, reduced_size, true, area);
    377502                                                        split_mark(cur, real_size);
    378                                                         result = aligned;
     503                                                       
     504                                                        next = cur;
     505                                                        return aligned;
    379506                                                }
    380507                                        }
    … …  
    382509                        }
    383510                }
    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;
     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 */
     526static 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       
     539loop:
     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;
    392569                        goto loop;
    393570                }
    394571        }
    395572       
    396         return result;
     573        return NULL;
    397574}
    398575
    … …  
    473650            (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
    474651       
    475         assert((void *) head >= heap_start);
    476         assert((void *) head < heap_end);
    477        
    478652        block_check(head);
    479653        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);
    480660       
    481661        void *ptr = NULL;
    … …  
    487667                /* Shrink */
    488668                if (orig_size - real_size >= STRUCT_OVERHEAD) {
    489                         /* Split the original block to a full block
    490                            and a trailing free block */
    491                         block_init((void *) head, real_size, false);
     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);
    492674                        block_init((void *) head + real_size,
    493                             orig_size - real_size, true);
    494                         shrink_heap();
     675                            orig_size - real_size, true, area);
     676                        heap_shrink();
    495677                }
    496678               
    497679                ptr = ((void *) head) + sizeof(heap_block_head_t);
    498680        } else {
    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. */
     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                 */
    503687                heap_block_head_t *next_head =
    504688                    (heap_block_head_t *) (((void *) head) + head->size);
    505689               
    506                 if (((void *) next_head < heap_end) &&
     690                if (((void *) next_head < area->end) &&
    507691                    (head->size + next_head->size >= real_size) &&
    508692                    (next_head->free)) {
    509693                        block_check(next_head);
    510                         block_init(head, head->size + next_head->size, false);
     694                        block_init(head, head->size + next_head->size, false, area);
    511695                        split_mark(head, real_size);
    512696                       
    513697                        ptr = ((void *) head) + sizeof(heap_block_head_t);
     698                        next = NULL;
    514699                } else
    515700                        reloc = true;
    … …  
    542727            = (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
    543728       
    544         assert((void *) head >= heap_start);
    545         assert((void *) head < heap_end);
    546        
    547729        block_check(head);
    548730        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);
    549737       
    550738        /* Mark the block itself as free. */
    … …  
    555743            = (heap_block_head_t *) (((void *) head) + head->size);
    556744       
    557         if ((void *) next_head < heap_end) {
     745        if ((void *) next_head < area->end) {
    558746                block_check(next_head);
    559747                if (next_head->free)
    560                         block_init(head, head->size + next_head->size, true);
     748                        block_init(head, head->size + next_head->size, true, area);
    561749        }
    562750       
    563751        /* Look at the previous block. If it is free, merge the two. */
    564         if ((void *) head > heap_start) {
     752        if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) {
    565753                heap_block_foot_t *prev_foot =
    566754                    (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
    … …  
    572760               
    573761                if (prev_head->free)
    574                         block_init(prev_head, prev_head->size + head->size, true);
    575         }
    576        
    577         shrink_heap();
     762                        block_init(prev_head, prev_head->size + head->size, true,
     763                            area);
     764        }
     765       
     766        heap_shrink();
    578767       
    579768        futex_up(&malloc_futex);

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

    raa7dc64 r0c968a17  
    3636#define LIBC_PRIVATE_LIBC_H_
    3737
     38extern void __entry(void);
     39extern void __main(void *) __attribute__((noreturn));
    3840extern int main(int, char *[]);
    39 extern void __main(void *) __attribute__((noreturn));
    4041
    4142#endif

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

    raa7dc64 r0c968a17  
    4141#include <libarch/config.h>
    4242
     43static 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
     51static inline size_t PAGES2SIZE(size_t pages)
     52{
     53        return (size_t) (pages << PAGE_WIDTH);
     54}
     55
    4356extern void *as_area_create(void *address, size_t size, int flags);
    4457extern int as_area_resize(void *address, size_t size, int flags);

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

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

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

    raa7dc64 r0c968a17  
    4444#endif
    4545
    46 #define getpagesize()  (PAGE_SIZE)
    47 
    4846#ifndef SEEK_SET
    4947        #define SEEK_SET  0
    … …  
    5755        #define SEEK_END  2
    5856#endif
     57
     58#define getpagesize()  (PAGE_SIZE)
    5959
    6060extern int dup2(int oldfd, int newfd);

  • uspace/srv/devman/devman.c

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

  • uspace/srv/devmap/devmap.c

    raa7dc64 r0c968a17  
    423423         */
    424424        list_initialize(&driver->devices);
    425         list_initialize(&(driver->drivers));
     425
     426        link_initialize(&driver->drivers);
    426427       
    427428        fibril_mutex_lock(&drivers_list_mutex);
    … …  
    538539        }
    539540       
    540         list_initialize(&(device->devices));
    541         list_initialize(&(device->driver_devices));
     541        link_initialize(&device->devices);
     542        link_initialize(&device->driver_devices);
    542543       
    543544        /* Check that device is not already registered */
    … …  
    942943        }
    943944       
    944         list_initialize(&(device->devices));
    945         list_initialize(&(device->driver_devices));
     945        link_initialize(&device->devices);
     946        link_initialize(&device->driver_devices);
    946947       
    947948        /* Get unique device handle */

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

    raa7dc64 r0c968a17  
    130130{
    131131        devfs_node_t *node = (devfs_node_t *) pfn->data;
     132        int ret;
    132133       
    133134        if (node->handle == 0) {
    … …  
    145146                               
    146147                                if (str_cmp(devs[pos].name, component) == 0) {
     148                                        ret = devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
    147149                                        free(devs);
    148                                         return devfs_node_get_internal(rfn, DEV_HANDLE_NAMESPACE, devs[pos].handle);
     150                                        return ret;
    149151                                }
    150152                        }
    … …  
    162164                                for (pos = 0; pos < count; pos++) {
    163165                                        if (str_cmp(devs[pos].name, component) == 0) {
     166                                                ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    164167                                                free(devs);
    165                                                 return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
     168                                                return ret;
    166169                                        }
    167170                                }
    … …  
    184187                        for (pos = 0; pos < count; pos++) {
    185188                                if (str_cmp(devs[pos].name, component) == 0) {
     189                                        ret = devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
    186190                                        free(devs);
    187                                         return devfs_node_get_internal(rfn, DEV_HANDLE_DEVICE, devs[pos].handle);
     191                                        return ret;
    188192                                }
    189193                        }

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

    raa7dc64 r0c968a17  
    33 * is the base address and the special interp section.
    44 */
     5
    56STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    67ENTRY(__entry)
    … …  
    5455        } :data
    5556       
    56         . = ALIGN(0x1000);
    57        
    58         _heap = .;
    59        
    6057        /DISCARD/ : {
    6158                *(*);

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

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

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

    raa7dc64 r0c968a17  
    33 * is the base address.
    44 */
     5
    56STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    67ENTRY(__entry)
    … …  
    1617                *(.interp);
    1718        } : interp
    18 
     19       
    1920        . = 0x70001000;
    20 
     21       
    2122        .init ALIGN(0x1000): SUBALIGN(0x1000) {
    2223                *(.init);
    23         } : text
     24        } :text
     25       
    2426        .text : {
    2527                *(.text);
    26         *(.rodata*);
     28                *(.rodata*);
    2729        } :text
    2830       
    … …  
    3234                *(.sdata);
    3335        } :data
     36       
    3437        .tdata : {
    3538                _tdata_start = .;
    … …  
    3740                _tdata_end = .;
    3841        } :data
     42       
    3943        .tbss : {
    4044                _tbss_start = .;
    … …  
    4246                _tbss_end = .;
    4347        } :data
     48       
    4449        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
     50       
    4551        .bss : {
    4652                *(.sbss);
    4753                *(.scommon);
    48         *(COMMON);
    49         *(.bss);
     54                *(COMMON);
     55                *(.bss);
    5056        } :data
    51        
    52         . = ALIGN(0x1000);
    53         _heap = .;
    5457       
    5558        /DISCARD/ : {
    5659                *(*);
    5760        }
    58 
    5961}

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

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

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

    raa7dc64 r0c968a17  
    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
     20        } :text
     21       
    2122        .text : {
    2223                *(.text);
    2324                *(.rodata*);
    2425        } :text
    25 
     26       
    2627        . = . + 0x4000;
    27 
     28       
    2829        .got : {
    2930                _gp = .;
    3031                *(.got*);
    31         } :data
     32        } :data
     33       
    3234        .data : {
    3335                *(.opd);
    … …  
    3537                *(.sdata);
    3638        } :data
     39       
    3740        .tdata : {
    3841                _tdata_start = .;
    … …  
    4043                _tdata_end = .;
    4144        } :data
     45       
    4246        .tbss : {
    4347                _tbss_start = .;
    … …  
    4549                _tbss_end = .;
    4650        } :data
     51       
    4752        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
     53       
    4854        .bss : {
    4955                *(.sbss);
    … …  
    5258                *(.bss);
    5359        } :data
    54 
    55         . = ALIGN(0x4000);
    56         _heap = .;
    57  
     60       
    5861        /DISCARD/ : {
    5962                *(*);
    60         }
     63        }
    6164}

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

    raa7dc64 r0c968a17  
    33 * is the base address.
    44 */
     5
    56STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    67ENTRY(__entry)
    … …  
    1617                *(.interp);
    1718        } :interp
    18 
     19       
    1920        . = 0x70004000;
    2021       
    … …  
    2223                *(.init);
    2324        } :text
     25       
    2426        .text : {
    25                 *(.text);
     27                *(.text);
    2628                *(.rodata*);
    2729        } :text
    28 
     30       
     31        . = . + 0x4000;
     32       
    2933        .data : {
    3034                *(.data);
    3135                *(.data.rel*);
    3236        } :data
    33 
     37       
    3438        .got : {
    3539                _gp = .;
    3640                *(.got);
    3741        } :data
    38 
     42       
    3943        .tdata : {
    4044                _tdata_start = .;
    … …  
    4246                _tdata_end = .;
    4347        } :data
     48       
    4449        .tbss : {
    4550                _tbss_start = .;
    … …  
    4752                _tbss_end = .;
    4853        } :data
     54       
    4955        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
    50 
     56       
    5157        .sbss : {
    5258                *(.scommon);
    5359                *(.sbss);
    54         }       
     60        }
     61       
    5562        .bss : {
    5663                *(.bss);
    5764                *(COMMON);
    5865        } :data
    59 
    60         . = ALIGN(0x4000);
    61         _heap = .;
    62 
     66       
    6367        /DISCARD/ : {
    6468                *(*);

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

    raa7dc64 r0c968a17  
    33 * is the base address.
    44 */
     5
    56STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
    67ENTRY(__entry)
    … …  
    1617                *(.interp);
    1718        } :interp
    18 
     19       
    1920        . = 0x70001000;
    20 
     21       
    2122        .init ALIGN(0x1000) : SUBALIGN(0x1000) {
    2223                *(.init);
    2324        } :text
     25       
    2426        .text : {
    2527                *(.text);
    … …  
    3133                *(.sdata);
    3234        } :data
     35       
    3336        .tdata : {
    3437                _tdata_start = .;
    … …  
    3639                _tdata_end = .;
    3740        } :data
     41       
    3842        .tbss : {
    3943                _tbss_start = .;
    … …  
    4145                _tbss_end = .;
    4246        } :data
     47       
    4348        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
     49       
    4450        .bss : {
    4551                *(.sbss);
    … …  
    4753                *(.bss);
    4854        } :data
    49 
    50         . = ALIGN(0x1000);
    51         _heap = .;
    5255       
    5356        /DISCARD/ : {
    5457                *(*);
    5558        }
    56 
    5759}

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

    raa7dc64 r0c968a17  
    1212                *(.interp);
    1313        } :interp
    14 
     14       
    1515        . = 0x70004000 + SIZEOF_HEADERS;
    16 
     16       
    1717        .init : {
    1818                *(.init);
    1919        } :text
     20       
    2021        .text : {
    2122                *(.text);
    2223                *(.rodata*);
    2324        } :text
    24 
     25       
    2526        . = . + 0x4000;
    26 
     27       
    2728        .got : {
    2829                 _gp = .;
    2930                 *(.got*);
    3031        } :data
     32       
    3133        .data : {
    3234                *(.data);
    3335                *(.sdata);
    3436        } :data
     37       
    3538        .tdata : {
    3639                _tdata_start = .;
    … …  
    3841                _tdata_end = .;
    3942        } :data
     43       
    4044        .tbss : {
    4145                _tbss_start = .;
    … …  
    4347                _tbss_end = .;
    4448        } :data
     49       
    4550        _tls_alignment = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss));
     51       
    4652        .bss : {
    4753                *(.sbss);
    … …  
    4955                *(.bss);
    5056        } :data
    51 
    52         . = ALIGN(0x4000);
    53         _heap = .;
    5457       
    5558        /DISCARD/ : {
    5659                *(*);
    5760        }
    58 
    5961}

  • uspace/srv/loader/elf_load.c

    raa7dc64 r0c968a17  
    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", seg_addr,
     346        DPRINTF("Load segment at addr %p, size 0x%x\n", (void *) 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", seg_addr,
    375         entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
     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)));
    376377
    377378        /*
    … …  
    386387        }
    387388
    388         DPRINTF("as_area_create(%p, 0x%x, %d) -> 0x%lx\n",
    389                 base + bias, mem_sz, flags, (uintptr_t)a);
     389        DPRINTF("as_area_create(%p, %#zx, %d) -> %p\n",
     390            (void *) (base + bias), mem_sz, flags, (void *) a);
    390391
    391392        /*
    … …  
    464465                    (void *)((uint8_t *)entry->sh_addr + elf->bias);
    465466                DPRINTF("Dynamic section found at %p.\n",
    466                         (uintptr_t)elf->info->dynamic);
     467                    (void *) elf->info->dynamic);
    467468                break;
    468469        default:
Note: See TracChangeset for help on using the changeset viewer.