Changeset 153cc76a in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2011-12-23T16:42:22Z (14 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7e1b130
Parents:
4291215 (diff), 2f0dd2a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes.

Location:
uspace/lib/c/generic
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r4291215 r153cc76a  
    4545/** Create address space area.
    4646 *
    47  * @param address Virtual address where to place new address space area.
    48  * @param size    Size of the area.
    49  * @param flags   Flags describing type of the area.
     47 * @param base  Starting virtual address of the area.
     48 *              If set to (void *) -1, the kernel finds
     49 *              a mappable area.
     50 * @param size  Size of the area.
     51 * @param flags Flags describing type of the area.
    5052 *
    51  * @return address on success, (void *) -1 otherwise.
     53 * @return Starting virtual address of the created area on success.
     54 * @return (void *) -1 otherwise.
    5255 *
    5356 */
    54 void *as_area_create(void *address, size_t size, unsigned int flags)
     57void *as_area_create(void *base, size_t size, unsigned int flags)
    5558{
    56         return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t) address,
    57             (sysarg_t) size, (sysarg_t) flags);
     59        return (void *) __SYSCALL4(SYS_AS_AREA_CREATE, (sysarg_t) base,
     60            (sysarg_t) size, (sysarg_t) flags, (sysarg_t) __entry);
    5861}
    5962
    … …  
    102105}
    103106
    104 /** Return pointer to unmapped address space area
     107/** Find mapping to physical address.
    105108 *
    106  * @param size Requested size of the allocation.
     109 * @param      virt Virtual address to find mapping for.
     110 * @param[out] phys Physical adress.
    107111 *
    108  * @return Pointer to the beginning of unmapped address space area.
     112 * @return EOK on no error.
     113 * @retval ENOENT if no mapping was found.
    109114 *
    110115 */
    111 void *as_get_mappable_page(size_t size)
     116int as_get_physical_mapping(const void *virt, uintptr_t *phys)
    112117{
    113         return (void *) __SYSCALL2(SYS_AS_GET_UNMAPPED_AREA,
    114             (sysarg_t) __entry, (sysarg_t) size);
    115 }
    116 
    117 /** Find mapping to physical address.
    118  *
    119  * @param address Virtual address in question (virtual).
    120  * @param[out] frame Frame address (physical).
    121  * @return Error code.
    122  * @retval EOK No error, @p frame holds the translation.
    123  * @retval ENOENT Mapping not found.
    124  */
    125 int as_get_physical_mapping(const void *address, uintptr_t *frame)
    126 {
    127         uintptr_t tmp_frame;
    128         uintptr_t virt = (uintptr_t) address;
    129        
    130         int rc = (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING,
    131             (sysarg_t) virt, (sysarg_t) &tmp_frame);
    132         if (rc != EOK) {
    133                 return rc;
    134         }
    135        
    136         if (frame != NULL) {
    137                 *frame = tmp_frame;
    138         }
    139        
    140         return EOK;
     118        return (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING, (sysarg_t) virt,
     119            (sysarg_t) phys);
    141120}
    142121

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

    r4291215 r153cc76a  
    19981998 *
    19991999 * @param exch  Exchange for sending the message.
    2000  * @param dst   Destination address space area base.
    20012000 * @param size  Size of the destination address space area.
    20022001 * @param arg   User defined argument.
    20032002 * @param flags Storage for the received flags. Can be NULL.
     2003 * @param dst   Destination address space area base. Cannot be NULL.
    20042004 *
    20052005 * @return Zero on success or a negative error code from errno.h.
    20062006 *
    20072007 */
    2008 int async_share_in_start(async_exch_t *exch, void *dst, size_t size,
    2009     sysarg_t arg, unsigned int *flags)
     2008int async_share_in_start(async_exch_t *exch, size_t size, sysarg_t arg,
     2009    unsigned int *flags, void **dst)
    20102010{
    20112011        if (exch == NULL)
    20122012                return ENOENT;
    20132013       
    2014         sysarg_t tmp_flags;
    2015         int res = async_req_3_2(exch, IPC_M_SHARE_IN, (sysarg_t) dst,
    2016             (sysarg_t) size, arg, NULL, &tmp_flags);
     2014        sysarg_t _flags = 0;
     2015        sysarg_t _dst = (sysarg_t) -1;
     2016        int res = async_req_2_4(exch, IPC_M_SHARE_IN, (sysarg_t) size,
     2017            arg, NULL, &_flags, NULL, &_dst);
    20172018       
    20182019        if (flags)
    2019                 *flags = (unsigned int) tmp_flags;
    2020        
     2020                *flags = (unsigned int) _flags;
     2021       
     2022        *dst = (void *) _dst;
    20212023        return res;
    20222024}
    … …  
    20472049                return false;
    20482050       
    2049         *size = (size_t) IPC_GET_ARG2(data);
     2051        *size = (size_t) IPC_GET_ARG1(data);
    20502052        return true;
    20512053}
    … …  
    20532055/** Wrapper for answering the IPC_M_SHARE_IN calls using the async framework.
    20542056 *
    2055  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
     2057 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_IN
    20562058 * calls so that the user doesn't have to remember the meaning of each IPC
    20572059 * argument.
    … …  
    21312133 *
    21322134 */
    2133 int async_share_out_finalize(ipc_callid_t callid, void *dst)
     2135int async_share_out_finalize(ipc_callid_t callid, void **dst)
    21342136{
    21352137        return ipc_share_out_finalize(callid, dst);

  • uspace/lib/c/generic/ddi.c

    r4291215 r153cc76a  
    3333 */
    3434
     35#include <assert.h>
     36#include <unistd.h>
     37#include <errno.h>
    3538#include <sys/types.h>
    3639#include <abi/ddi/arg.h>
    … …  
    4245#include <align.h>
    4346#include <libarch/config.h>
     47#include "private/libc.h"
    4448
    4549/** Return unique device number.
    … …  
    5761 * Caller of this function must have the CAP_MEM_MANAGER capability.
    5862 *
    59  * @param pf    Physical address of the starting frame.
    60  * @param vp    Virtual address of the starting page.
     63 * @param phys  Physical address of the starting frame.
    6164 * @param pages Number of pages to map.
    6265 * @param flags Flags for the new address space area.
     66 * @param virt  Virtual address of the starting page.
    6367 *
    6468 * @return EOK on success
    … …  
    6973 *
    7074 */
    71 int physmem_map(void *pf, void *vp, size_t pages, unsigned int flags)
     75int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
    7276{
    73         return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) pf, (sysarg_t) vp,
    74             pages, flags);
     77        return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
     78            pages, flags, (sysarg_t) virt, (sysarg_t) __entry);
    7579}
    7680
    77 int dmamem_map(dmamem_t *dmamem, size_t pages, unsigned int map_flags,
    78     unsigned int dma_flags)
     81int dmamem_map(void *virt, size_t size, unsigned int map_flags,
     82    unsigned int flags, void **phys)
    7983{
    80         // FIXME TODO
    81         return -1;
     84        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
     85            (sysarg_t) map_flags, (sysarg_t) flags & ~DMAMEM_FLAGS_ANONYMOUS,
     86            (sysarg_t) phys, (sysarg_t) virt, 0);
    8287}
    8388
    84 int dmamem_unmap(dmamem_t *dmamem)
     89int dmamem_map_anonymous(size_t size, unsigned int map_flags,
     90    unsigned int flags, void **phys, void **virt)
    8591{
    86         // FIXME TODO
    87         return -1;
     92        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
     93            (sysarg_t) map_flags, (sysarg_t) flags | DMAMEM_FLAGS_ANONYMOUS,
     94            (sysarg_t) phys, (sysarg_t) virt, (sysarg_t) __entry);
    8895}
    8996
    90 int dmamem_lock(void *virt, void **phys, size_t pages)
     97int dmamem_unmap(void *virt, size_t size)
    9198{
    92         // FIXME TODO
    93         return -1;
     99        return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, (sysarg_t) size, 0);
    94100}
    95101
    96 int dmamem_unlock(void *virt, size_t pages)
     102int dmamem_unmap_anonymous(void *virt)
    97103{
    98         // FIXME TODO
    99         return -1;
     104        return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, 0,
     105            DMAMEM_FLAGS_ANONYMOUS);
    100106}
    101107
    … …  
    129135 * @param pio_addr I/O start address.
    130136 * @param size     Size of the I/O region.
    131  * @param use_addr Address where the final address for
    132  *                 application's PIO will be stored.
     137 * @param virt     Virtual address for application's
     138 *                 PIO operations.
    133139 *
    134  * @return Zero on success or negative error code.
     140 * @return EOK on success.
     141 * @return Negative error code on failure.
    135142 *
    136143 */
    137 int pio_enable(void *pio_addr, size_t size, void **use_addr)
     144int pio_enable(void *pio_addr, size_t size, void **virt)
    138145{
    139         void *phys;
    140         void *virt;
    141         size_t offset;
    142         unsigned int pages;
    143        
    144146#ifdef IO_SPACE_BOUNDARY
    145147        if (pio_addr < IO_SPACE_BOUNDARY) {
    146                 *use_addr = pio_addr;
     148                *virt = pio_addr;
    147149                return iospace_enable(task_get_id(), pio_addr, size);
    148150        }
    149151#endif
    150152       
    151         phys = (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
    152         offset = pio_addr - phys;
    153         pages = ALIGN_UP(offset + size, PAGE_SIZE) >> PAGE_WIDTH;
    154         virt = as_get_mappable_page(pages << PAGE_WIDTH);
    155         *use_addr = virt + offset;
    156         return physmem_map(phys, virt, pages, AS_AREA_READ | AS_AREA_WRITE);
     153        void *phys_frame =
     154            (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
     155        size_t offset = pio_addr - phys_frame;
     156        size_t pages = SIZE2PAGES(offset + size);
     157       
     158        void *virt_page;
     159        int rc = physmem_map(phys_frame, pages,
     160            AS_AREA_READ | AS_AREA_WRITE, &virt_page);
     161        if (rc != EOK)
     162                return rc;
     163       
     164        *virt = virt_page + offset;
     165        return EOK;
    157166}
    158167
    … …  
    167176 *
    168177 */
    169 int register_irq(int inr, int devno, int method, irq_code_t *ucode)
     178int irq_register(int inr, int devno, int method, irq_code_t *ucode)
    170179{
    171         return __SYSCALL4(SYS_REGISTER_IRQ, inr, devno, method,
     180        return __SYSCALL4(SYS_IRQ_REGISTER, inr, devno, method,
    172181            (sysarg_t) ucode);
    173182}
    … …  
    181190 *
    182191 */
    183 int unregister_irq(int inr, int devno)
     192int irq_unregister(int inr, int devno)
    184193{
    185         return __SYSCALL2(SYS_UNREGISTER_IRQ, inr, devno);
     194        return __SYSCALL2(SYS_IRQ_UNREGISTER, inr, devno);
    186195}
    187196

  • uspace/lib/c/generic/elf/elf_load.c

    r4291215 r153cc76a  
    364364         * and writeable.
    365365         */
    366         a = as_area_create((uint8_t *)base + bias, mem_sz,
     366        a = as_area_create((uint8_t *) base + bias, mem_sz,
    367367            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    368         if (a == (void *)(-1)) {
     368        if (a == (void *) -1) {
    369369                DPRINTF("memory mapping failed (0x%x, %d)\n",
    370                         base+bias, mem_sz);
     370                    base + bias, mem_sz);
    371371                return EE_MEMORY;
    372372        }

  • uspace/lib/c/generic/ipc.c

    r4291215 r153cc76a  
    4848#include <fibril.h>
    4949#include <macros.h>
     50#include "private/libc.h"
    5051
    5152/**
    … …  
    760761 *
    761762 * @param phoneid Phone that will be used to contact the receiving side.
    762  * @param dst     Destination address space area base.
    763763 * @param size    Size of the destination address space area.
    764764 * @param arg     User defined argument.
    765765 * @param flags   Storage for received flags. Can be NULL.
     766 * @param dst     Destination address space area base. Cannot be NULL.
    766767 *
    767768 * @return Zero on success or a negative error code from errno.h.
    768769 *
    769770 */
    770 int ipc_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
    771     unsigned int *flags)
    772 {
    773         sysarg_t tmp_flags = 0;
    774         int res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
    775             (sysarg_t) size, arg, NULL, &tmp_flags);
     771int ipc_share_in_start(int phoneid, size_t size, sysarg_t arg,
     772    unsigned int *flags, void **dst)
     773{
     774        sysarg_t _flags = 0;
     775        sysarg_t _dst = (sysarg_t) -1;
     776        int res = ipc_call_sync_2_4(phoneid, IPC_M_SHARE_IN, (sysarg_t) size,
     777            arg, NULL, &_flags, NULL, &_dst);
    776778       
    777779        if (flags)
    778                 *flags = (unsigned int) tmp_flags;
    779        
     780                *flags = (unsigned int) _flags;
     781       
     782        *dst = (void *) _dst;
    780783        return res;
    781784}
    … …  
    783786/** Wrapper for answering the IPC_M_SHARE_IN calls.
    784787 *
    785  * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
     788 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_IN
    786789 * calls so that the user doesn't have to remember the meaning of each
    787790 * IPC argument.
    … …  
    796799int ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
    797800{
    798         return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) flags);
     801        return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
     802            (sysarg_t) __entry);
    799803}
    800804
    … …  
    826830 *
    827831 */
    828 int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
    829 {
    830         return ipc_answer_1(callid, EOK, (sysarg_t) dst);
     832int ipc_share_out_finalize(ipc_callid_t callid, void **dst)
     833{
     834        return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
    831835}
    832836

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

    r4291215 r153cc76a  
    283283static bool area_create(size_t size)
    284284{
    285         void *start = as_get_mappable_page(size);
    286         if (start == NULL)
    287                 return false;
    288        
    289         /* Align the heap area on page boundary */
    290         void *astart = (void *) ALIGN_UP((uintptr_t) start, PAGE_SIZE);
     285        /* Align the heap area size on page boundary */
    291286        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    292        
    293         astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
     287        void *astart = as_area_create((void *) -1, asize,
     288            AS_AREA_WRITE | AS_AREA_READ);
    294289        if (astart == (void *) -1)
    295290                return false;

  • uspace/lib/c/generic/mman.c

    r4291215 r153cc76a  
    4242{
    4343        if (!start)
    44                 start = as_get_mappable_page(length);
     44                start = (void *) -1;
    4545       
    4646//      if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))

  • uspace/lib/c/generic/time.c

    r4291215 r153cc76a  
    147147                }
    148148               
    149                 void *addr = as_get_mappable_page(PAGE_SIZE);
    150                 if (addr == NULL) {
    151                         errno = ENOMEM;
    152                         return -1;
    153                 }
    154                
    155                 rc = physmem_map((void *) faddr, addr, 1,
    156                     AS_AREA_READ | AS_AREA_CACHEABLE);
     149                void *addr;
     150                rc = physmem_map((void *) faddr, 1,
     151                    AS_AREA_READ | AS_AREA_CACHEABLE, &addr);
    157152                if (rc != EOK) {
    158153                        as_area_destroy(addr);
Note: See TracChangeset for help on using the changeset viewer.