Changes in / [b2fa2d86:8a26f82] in mainline


Ignore:
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • boot/generic/include/memstr.h

    rb2fa2d86 r8a26f82  
    3636
    3737extern void *memcpy(void *, const void *, size_t);
    38 extern void *memset(void *, int, size_t);
    3938extern void *memmove(void *, const void *, size_t);
    4039

  • boot/generic/src/memstr.c

    rb2fa2d86 r8a26f82  
    3535 * memory areas cannot overlap.
    3636 *
    37  * @param src Source address to copy from.
    38  * @param dst Destination address to copy to.
    39  * @param cnt Number of bytes to copy.
     37 * @param src           Source address to copy from.
     38 * @param dst           Destination address to copy to.
     39 * @param cnt           Number of bytes to copy.
    4040 *
    41  * @return Destination address.
    42  *
     41 * @return              Destination address.
    4342 */
    4443void *memcpy(void *dst, const void *src, size_t cnt)
    4544{
    46         return __builtin_memcpy(dst, src, cnt);
    47 }
     45        size_t i;
    4846
    49 /** Fill block of memory.
    50  *
    51  * Fill cnt bytes at dst address with the value val.
    52  *
    53  * @param dst Destination address to fill.
    54  * @param val Value to fill.
    55  * @param cnt Number of bytes to fill.
    56  *
    57  * @return Destination address.
    58  *
    59  */
    60 void *memset(void *dst, int val, size_t cnt)
    61 {
    62         return __builtin_memset(dst, val, cnt);
     47        for (i = 0; i < cnt; i++)
     48                ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
     49
     50        return dst;
    6351}
    6452

  • kernel/arch/amd64/src/mm/page.c

    rb2fa2d86 r8a26f82  
    7878void page_fault(unsigned int n, istate_t *istate)
    7979{
    80         uintptr_t badvaddr = read_cr2();
     80        uintptr_t page = read_cr2();
    8181       
    8282        if (istate->error_word & PFERR_CODE_RSVD)
    … …  
    9292                access = PF_ACCESS_READ;
    9393       
    94         (void) as_page_fault(badvaddr, access, istate);
     94        as_page_fault(page, access, istate);
    9595}
    9696

  • kernel/arch/arm32/src/fpu_context.c

    rb2fa2d86 r8a26f82  
    119119 * rely on user decision to use CONFIG_FPU.
    120120 */
    121 #ifdef PROCESSOR_ARCH_armv7_a
     121#ifdef PROCESSOR_ARC_armv7_a
    122122        const uint32_t cpacr = CPACR_read();
    123123        /* FPU needs access to coprocessor 10 and 11.
    124          * Moreover they need to have same access enabled */
     124         * Moreover they need to have same access enabledd */
    125125        if (((cpacr & CPACR_CP_MASK(10)) != CPACR_CP_FULL_ACCESS(10)) &&
    126126           ((cpacr & CPACR_CP_MASK(11)) != CPACR_CP_FULL_ACCESS(11))) {

  • kernel/arch/ia32/src/mm/page.c

    rb2fa2d86 r8a26f82  
    8484void page_fault(unsigned int n __attribute__((unused)), istate_t *istate)
    8585{
    86         uintptr_t badvaddr;
     86        uintptr_t page;
    8787        pf_access_t access;
    8888       
    89         badvaddr = read_cr2();
     89        page = read_cr2();
    9090               
    9191        if (istate->error_word & PFERR_CODE_RSVD)
    … …  
    9797                access = PF_ACCESS_READ;
    9898       
    99         (void) as_page_fault(badvaddr, access, istate);
     99        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
     100                fault_if_from_uspace(istate, "Page fault: %#x.", page);
     101                panic_memtrap(istate, access, page, NULL);
     102        }
    100103}
    101104

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

    rb2fa2d86 r8a26f82  
    9494        entry_lo_t lo;
    9595        uintptr_t badvaddr;
     96        uintptr_t page;
    9697        pte_t *pte;
    9798       
    9899        badvaddr = cp0_badvaddr_read();
    99 
    100         pte = page_mapping_find(AS, badvaddr, true);
     100        page = ALIGN_DOWN(badvaddr, PAGE_SIZE);
     101
     102        pte = page_mapping_find(AS, page, true);
    101103        if (pte && pte->p) {
    102104                /*
    … …  
    123125        }
    124126
    125         (void) as_page_fault(badvaddr, PF_ACCESS_READ, istate);
     127        (void) as_page_fault(page, PF_ACCESS_READ, istate);
    126128}
    127129
    … …  
    135137        tlb_index_t index;
    136138        uintptr_t badvaddr;
     139        uintptr_t page;
    137140        pte_t *pte;
    138141
    … …  
    158161
    159162        badvaddr = cp0_badvaddr_read();
    160 
    161         pte = page_mapping_find(AS, badvaddr, true);
     163        page = ALIGN_DOWN(badvaddr, PAGE_SIZE);
     164
     165        pte = page_mapping_find(AS, page, true);
    162166        if (pte && pte->p) {
    163167                /*
    … …  
    185189        }
    186190
    187         (void) as_page_fault(badvaddr, PF_ACCESS_READ, istate);
     191        (void) as_page_fault(page, PF_ACCESS_READ, istate);
    188192}
    189193
    … …  
    197201        tlb_index_t index;
    198202        uintptr_t badvaddr;
     203        uintptr_t page;
    199204        pte_t *pte;
    200205
    201206        badvaddr = cp0_badvaddr_read();
     207        page = ALIGN_DOWN(badvaddr, PAGE_SIZE);
    202208
    203209        /*
    … …  
    221227        }
    222228
    223         pte = page_mapping_find(AS, badvaddr, true);
     229        pte = page_mapping_find(AS, page, true);
    224230        if (pte && pte->p && pte->w) {
    225231                /*
    … …  
    248254        }
    249255
    250         (void) as_page_fault(badvaddr, PF_ACCESS_WRITE, istate);
     256        (void) as_page_fault(page, PF_ACCESS_WRITE, istate);
    251257}
    252258

  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    rb2fa2d86 r8a26f82  
    196196void fast_instruction_access_mmu_miss(sysarg_t unused, istate_t *istate)
    197197{
     198        uintptr_t page_16k = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
    198199        size_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
    199200        pte_t *t;
    200201
    201         t = page_mapping_find(AS, istate->tpc, true);
     202        t = page_mapping_find(AS, page_16k, true);
    202203        if (t && PTE_EXECUTABLE(t)) {
    203204                /*
    … …  
    215216                 * handler.
    216217                 */
    217                 as_page_fault(istate->tpc, PF_ACCESS_EXEC, istate);
     218                as_page_fault(page_16k, PF_ACCESS_EXEC, istate);
    218219        }
    219220}

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

    rb2fa2d86 r8a26f82  
    544544    mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
    545545{
    546         if ((*base != (uintptr_t) -1) && !IS_ALIGNED(*base, PAGE_SIZE))
     546        if ((*base != (uintptr_t) -1) && ((*base % PAGE_SIZE) != 0))
    547547                return NULL;
    548548       
    … …  
    688688int as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
    689689{
    690         if (!IS_ALIGNED(address, PAGE_SIZE))
    691                 return EINVAL;
    692 
    693690        mutex_lock(&as->lock);
    694691       
    … …  
    13531350 * Interrupts are assumed disabled.
    13541351 *
    1355  * @param address Faulting address.
    1356  * @param access  Access mode that caused the page fault (i.e.
    1357  *                read/write/exec).
    1358  * @param istate  Pointer to the interrupted state.
     1352 * @param page   Faulting page.
     1353 * @param access Access mode that caused the page fault (i.e.
     1354 *               read/write/exec).
     1355 * @param istate Pointer to the interrupted state.
    13591356 *
    13601357 * @return AS_PF_FAULT on page fault.
    … …  
    13641361 *
    13651362 */
    1366 int as_page_fault(uintptr_t address, pf_access_t access, istate_t *istate)
    1367 {
    1368         uintptr_t page = ALIGN_DOWN(address, PAGE_SIZE);
     1363int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
     1364{
    13691365        int rc = AS_PF_FAULT;
    13701366
    … …  
    14561452                task_kill_self(true);
    14571453        } else {
    1458                 fault_if_from_uspace(istate, "Page fault: %p.", (void *) address);
    1459                 panic_memtrap(istate, access, address, NULL);
     1454                fault_if_from_uspace(istate, "Page fault: %p.", (void *) page);
     1455                panic_memtrap(istate, access, page, NULL);
    14601456        }
    14611457       
    … …  
    16831679{
    16841680        ASSERT(mutex_locked(&area->lock));
    1685         ASSERT(IS_ALIGNED(page, PAGE_SIZE));
     1681        ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
    16861682        ASSERT(count);
    16871683       
    … …  
    19671963{
    19681964        ASSERT(mutex_locked(&area->lock));
    1969         ASSERT(IS_ALIGNED(page, PAGE_SIZE));
     1965        ASSERT(page == ALIGN_DOWN(page, PAGE_SIZE));
    19701966        ASSERT(count);
    19711967       

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

    rb2fa2d86 r8a26f82  
    173173 *
    174174 * @param area Pointer to the address space area.
    175  * @param upage Faulting virtual page.
     175 * @param addr Faulting virtual address.
    176176 * @param access Access mode that caused the fault (i.e. read/write/exec).
    177177 *
    … …  
    179179 *     serviced).
    180180 */
    181 int anon_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
    182 {
     181int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
     182{
     183        uintptr_t upage = ALIGN_DOWN(addr, PAGE_SIZE);
    183184        uintptr_t kpage;
    184185        uintptr_t frame;
    … …  
    186187        ASSERT(page_table_locked(AS));
    187188        ASSERT(mutex_locked(&area->lock));
    188         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
    189189
    190190        if (!as_area_check_access(area, access))

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

    rb2fa2d86 r8a26f82  
    235235 *
    236236 * @param area          Pointer to the address space area.
    237  * @param upage         Faulting virtual page.
     237 * @param addr          Faulting virtual address.
    238238 * @param access        Access mode that caused the fault (i.e.
    239239 *                      read/write/exec).
    … …  
    242242 *                      on success (i.e. serviced).
    243243 */
    244 int elf_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
     244int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
    245245{
    246246        elf_header_t *elf = area->backend_data.elf;
    … …  
    250250        uintptr_t frame;
    251251        uintptr_t kpage;
     252        uintptr_t upage;
    252253        uintptr_t start_anon;
    253254        size_t i;
    … …  
    256257        ASSERT(page_table_locked(AS));
    257258        ASSERT(mutex_locked(&area->lock));
    258         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
    259259
    260260        if (!as_area_check_access(area, access))
    261261                return AS_PF_FAULT;
    262262       
    263         if (upage < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
     263        if (addr < ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE))
    264264                return AS_PF_FAULT;
    265265       
    266         if (upage >= entry->p_vaddr + entry->p_memsz)
     266        if (addr >= entry->p_vaddr + entry->p_memsz)
    267267                return AS_PF_FAULT;
    268268       
    269         i = (upage - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
     269        i = (addr - ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) >> PAGE_WIDTH;
    270270        base = (uintptr_t)
    271271            (((void *) elf) + ALIGN_DOWN(entry->p_offset, PAGE_SIZE));
     272
     273        /* Virtual address of faulting page */
     274        upage = ALIGN_DOWN(addr, PAGE_SIZE);
    272275
    273276        /* Virtual address of the end of initialized part of segment */

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

    rb2fa2d86 r8a26f82  
    111111 *
    112112 * @param area Pointer to the address space area.
    113  * @param upage Faulting virtual page.
     113 * @param addr Faulting virtual address.
    114114 * @param access Access mode that caused the fault (i.e. read/write/exec).
    115115 *
    … …  
    117117 * serviced).
    118118 */
    119 int phys_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
     119int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
    120120{
    121121        uintptr_t base = area->backend_data.base;
    … …  
    123123        ASSERT(page_table_locked(AS));
    124124        ASSERT(mutex_locked(&area->lock));
    125         ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
    126125
    127126        if (!as_area_check_access(area, access))
    128127                return AS_PF_FAULT;
    129128
    130         ASSERT(upage - area->base < area->backend_data.frames * FRAME_SIZE);
    131         page_mapping_insert(AS, upage, base + (upage - area->base),
     129        ASSERT(addr - area->base < area->backend_data.frames * FRAME_SIZE);
     130        page_mapping_insert(AS, addr, base + (addr - area->base),
    132131            as_area_get_flags(area));
    133132       
    134         if (!used_space_insert(area, upage, 1))
     133        if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
    135134                panic("Cannot insert used space.");
    136135

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

    rb2fa2d86 r8a26f82  
    104104        ASSERT(page_mapping_operations->mapping_insert);
    105105
    106         page_mapping_operations->mapping_insert(as, ALIGN_DOWN(page, PAGE_SIZE),
    107             ALIGN_DOWN(frame, FRAME_SIZE), flags);
     106        page_mapping_operations->mapping_insert(as, page, frame, flags);
    108107       
    109108        /* Repel prefetched accesses to the old mapping. */
    … …  
    128127        ASSERT(page_mapping_operations->mapping_remove);
    129128       
    130         page_mapping_operations->mapping_remove(as,
    131             ALIGN_DOWN(page, PAGE_SIZE));
     129        page_mapping_operations->mapping_remove(as, page);
    132130       
    133131        /* Repel prefetched accesses to the old mapping. */
    … …  
    152150        ASSERT(page_mapping_operations->mapping_find);
    153151       
    154         return page_mapping_operations->mapping_find(as,
    155             ALIGN_DOWN(page, PAGE_SIZE), nolock);
     152        return page_mapping_operations->mapping_find(as, page, nolock);
    156153}
    157154

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

    rb2fa2d86 r8a26f82  
    753753        sysinfo_return_t ret;
    754754        ret.tag = SYSINFO_VAL_UNDEFINED;
    755         ret.data.data = NULL;
    756         ret.data.size = 0;
    757755       
    758756        if (size > SYSINFO_MAX_PATH)

  • tools/toolchain.sh

    rb2fa2d86 r8a26f82  
    5555BINUTILS_VERSION="2.23.1"
    5656BINUTILS_RELEASE=""
    57 GCC_VERSION="4.8.0"
    58 GDB_VERSION="7.5.1"
     57GCC_VERSION="4.7.2"
     58GDB_VERSION="7.5"
    5959
    6060BASEDIR="`pwd`"
    … …  
    275275       
    276276        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "33adb18c3048d057ac58d07a3f1adb38"
    277         download_fetch "${GCC_SOURCE}" "${GCC}" "e6040024eb9e761c3bea348d1fa5abb0"
    278         download_fetch "${GDB_SOURCE}" "${GDB}" "3f48f468b24447cf24820054ff6e85b1"
     277        download_fetch "${GCC_SOURCE}" "${GCC}" "cc308a0891e778cfda7a151ab8a6e762"
     278        download_fetch "${GDB_SOURCE}" "${GDB}" "24a6779a9fe0260667710de1b082ef61"
    279279}
    280280

  • uspace/srv/fs/exfat/exfat_fat.c

    rb2fa2d86 r8a26f82  
    401401{
    402402        service_id_t service_id = nodep->idx->service_id;
    403         exfat_cluster_t lastc = 0;
     403        exfat_cluster_t lastc;
    404404        int rc;
    405405

  • uspace/srv/fs/fat/fat_fat.c

    rb2fa2d86 r8a26f82  
    128128{
    129129        fat_cluster_t firstc = nodep->firstc;
    130         fat_cluster_t currc = 0;
     130        fat_cluster_t currc;
    131131        aoff64_t relbn = bn;
    132132        int rc;
    … …  
    194194        uint32_t clusters;
    195195        uint32_t max_clusters;
    196         fat_cluster_t c = 0;
     196        fat_cluster_t c;
    197197        int rc;
    198198
    … …  
    679679        fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
    680680        unsigned found = 0;     /* top of the free cluster number stack */
    681         fat_cluster_t clst;
    682         fat_cluster_t value = 0;
    683         fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
     681        fat_cluster_t clst, value, clst_last1 = FAT_CLST_LAST1(bs);
    684682        int rc = EOK;
    685683
    … …  
    785783{
    786784        service_id_t service_id = nodep->idx->service_id;
    787         fat_cluster_t lastc = 0;
     785        fat_cluster_t lastc;
    788786        uint8_t fatno;
    789787        int rc;
    … …  
    909907int fat_sanity_check(fat_bs_t *bs, service_id_t service_id)
    910908{
    911         fat_cluster_t e0 = 0;
    912         fat_cluster_t e1 = 0;
     909        fat_cluster_t e0, e1;
    913910        unsigned fat_no;
    914911        int rc;

  • uspace/srv/fs/mfs/mfs_ops.c

    rb2fa2d86 r8a26f82  
    773773{
    774774        int rc;
    775         fs_node_t *fn = NULL;
     775        fs_node_t *fn;
    776776
    777777        rc = mfs_node_get(&fn, service_id, index);
    … …  
    11081108mfs_sync(service_id_t service_id, fs_index_t index)
    11091109{
    1110         fs_node_t *fn = NULL;
     1110        fs_node_t *fn;
    11111111        int rc = mfs_node_get(&fn, service_id, index);
    11121112        if (rc != EOK)
Note: See TracChangeset for help on using the changeset viewer.