Changeset fbcdeb8 in mainline for uspace


Ignore:
Timestamp:
2011-12-19T17:30:39Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
58f6229
Parents:
24cf31f1
Message:

Remove the two-phase way of creating virtual memory areas (first asking for a mappable address and then mapping it) which was prone to race conditions when two or more calls to as_get_mappable_page() and as_area_create() were interleaved. This for example caused the e1k driver to randomly fail.

The memory area related syscalls and IPC calls have all been altered to accept a special value (void *) -1, representing a demand to atomically search for a mappable address space "hole" and map to it.

Individual changes:

  • IPC_M_SHARE_OUT: the destination address space area is supplied by the kernel, the callee only specifies the lower bound

(the address is returned to the callee via a pointer in an IPC reply argument)

  • IPC_M_SHARE_IN: the destination address space ares is supplied by the kernel, the callee only specifies the lower bound

(the address is returned to the caller as usual via an IPC argument)

  • SYS_AS_GET_UNMAPPED_AREA was removed
  • dummy implementations of SYS_PHYSMEM_UNMAP and SYS_IOSPACE_DISABLE were added for the sake of symmetry (they do nothing yet)
  • SYS_PHYSMEM_MAP and SYS_DMAMEM_MAP were altered to accept (void *) -1 as address space area base and a lower bound
  • kernel as_area_create() and as_area_share() were altered to accept (void *) -1 as address space area base and a lower bound
  • uspace libraries and programs were altered to reflect the new API
Location:
uspace
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/klog/klog.c

    r24cf31f1 rfbcdeb8  
    205205        klog_length = size / sizeof(wchar_t);
    206206       
    207         klog = (wchar_t *) as_get_mappable_page(size);
    208         if (klog == NULL) {
    209                 fprintf(stderr, "%s: Unable to allocate virtual memory area\n",
    210                     NAME);
    211                 return ENOMEM;
    212         }
    213        
    214         rc = physmem_map((void *) faddr, (void *) klog, pages,
    215             AS_AREA_READ | AS_AREA_CACHEABLE);
     207        rc = physmem_map((void *) faddr, pages,
     208            AS_AREA_READ | AS_AREA_CACHEABLE, (void *) &klog);
    216209        if (rc != EOK) {
    217210                fprintf(stderr, "%s: Unable to map klog\n", NAME);

  • uspace/app/tester/mm/common.c

    r24cf31f1 rfbcdeb8  
    342342        link_initialize(&area->link);
    343343       
    344         /* Map the memory area */
    345         void *addr = as_get_mappable_page(size);
    346         if (addr == NULL) {
     344        area->addr = as_area_create((void *) -1, size,
     345            AS_AREA_WRITE | AS_AREA_READ);
     346        if (area->addr == (void *) -1) {
    347347                free(area);
    348348                check_consistency("map_area (a)");
    349                 return NULL;
    350         }
    351        
    352         area->addr = as_area_create(addr, size, AS_AREA_WRITE | AS_AREA_READ);
    353         if (area->addr == (void *) -1) {
    354                 free(area);
    355                 check_consistency("map_area (b)");
    356349                return NULL;
    357350        }

  • uspace/app/tester/mm/mapping1.c

    r24cf31f1 rfbcdeb8  
    3535#include "../tester.h"
    3636
    37 #define BUFFER1_PAGES 4
    38 #define BUFFER2_PAGES 2
     37#define BUFFER1_PAGES  4
     38#define BUFFER2_PAGES  2
    3939
    4040static void *create_as_area(size_t size)
    4141{
    42         void *result = as_get_mappable_page(size);
    4342        TPRINTF("Creating AS area...\n");
    44         if (as_area_create(result, size,
    45             AS_AREA_READ | AS_AREA_WRITE) != result) {
     43       
     44        void *result = as_area_create((void *) -1, size,
     45            AS_AREA_READ | AS_AREA_WRITE);
     46        if (result == (void *) -1)
    4647                return NULL;
    47         }
     48       
    4849        return result;
    4950}

  • uspace/drv/bus/usb/uhci/utils/malloc32.h

    r24cf31f1 rfbcdeb8  
    9898static inline void * get_page(void)
    9999{
    100         void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
    101         if (free_address == 0)
     100        void *address = as_area_create((void *) -1, UHCI_REQUIRED_PAGE_SIZE,
     101            AS_AREA_READ | AS_AREA_WRITE);
     102        if (address == (void *) -1)
    102103                return NULL;
    103         void *address = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
    104                   AS_AREA_READ | AS_AREA_WRITE);
    105         if (address != free_address)
    106                 return NULL;
     104       
    107105        return address;
    108106}

  • uspace/drv/bus/usb/usbmast/main.c

    r24cf31f1 rfbcdeb8  
    300300                return;
    301301        }
    302 
    303         comm_buf = as_get_mappable_page(comm_size);
    304         if (comm_buf == NULL) {
     302       
     303        (void) async_share_out_finalize(callid, &comm_buf);
     304        if (comm_buf == (void *) -1) {
    305305                async_answer_0(callid, EHANGUP);
    306306                return;
    307307        }
    308 
    309         (void) async_share_out_finalize(callid, comm_buf);
    310 
     308       
    311309        mfun = (usbmast_fun_t *) ((ddf_fun_t *)arg)->driver_data;
    312310

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

    r24cf31f1 rfbcdeb8  
    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
    105  *
    106  * @param size Requested size of the allocation.
    107  *
    108  * @return Pointer to the beginning of unmapped address space area.
    109  *
    110  */
    111 void *as_get_mappable_page(size_t size)
    112 {
    113         return (void *) __SYSCALL2(SYS_AS_GET_UNMAPPED_AREA,
    114             (sysarg_t) __entry, (sysarg_t) size);
    115 }
    116 
    117107/** Find mapping to physical address.
    118108 *

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

    r24cf31f1 rfbcdeb8  
    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

    r24cf31f1 rfbcdeb8  
    4545#include <align.h>
    4646#include <libarch/config.h>
     47#include "private/libc.h"
    4748
    4849/** Return unique device number.
    … …  
    6162 *
    6263 * @param phys  Physical address of the starting frame.
    63  * @param virt  Virtual address of the starting page.
    6464 * @param pages Number of pages to map.
    6565 * @param flags Flags for the new address space area.
     66 * @param virt  Virtual address of the starting page.
    6667 *
    6768 * @return EOK on success
    … …  
    7273 *
    7374 */
    74 int physmem_map(void *phys, void *virt, size_t pages, unsigned int flags)
     75int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
    7576{
    76         return __SYSCALL4(SYS_PHYSMEM_MAP, (sysarg_t) phys,
    77             (sysarg_t) virt, pages, flags);
     77        return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
     78            pages, flags, (sysarg_t) virt, (sysarg_t) __entry);
    7879}
    7980
    … …  
    8182    unsigned int flags, void **phys)
    8283{
    83         return (int) __SYSCALL5(SYS_DMAMEM_MAP, (sysarg_t) virt,
    84             (sysarg_t) size, (sysarg_t) map_flags, (sysarg_t) flags,
    85             (sysarg_t) phys);
     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);
    8687}
    8788
    … …  
    8990    unsigned int flags, void **phys, void **virt)
    9091{
    91         *virt = as_get_mappable_page(size);
    92         if (*virt == NULL)
    93                 return ENOMEM;
    94        
    95         return dmamem_map(*virt, size, map_flags,
    96             flags | DMAMEM_FLAGS_ANONYMOUS, phys);
     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);
    9795}
    9896
    99 int dmamem_unmap(void *virt, size_t size, unsigned int flags)
     97int dmamem_unmap(void *virt, size_t size)
    10098{
    101         return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, (sysarg_t) size,
    102             (sysarg_t) flags);
     99        return __SYSCALL3(SYS_DMAMEM_UNMAP, (sysarg_t) virt, (sysarg_t) size, 0);
    103100}
    104101
    … …  
    138135 * @param pio_addr I/O start address.
    139136 * @param size     Size of the I/O region.
    140  * @param use_addr Address where the final address for
    141  *                 application's PIO will be stored.
     137 * @param virt     Virtual address for application's
     138 *                 PIO operations.
    142139 *
    143  * @return Zero on success or negative error code.
     140 * @return EOK on success.
     141 * @return Negative error code on failure.
    144142 *
    145143 */
    146 int pio_enable(void *pio_addr, size_t size, void **use_addr)
     144int pio_enable(void *pio_addr, size_t size, void **virt)
    147145{
    148         void *phys;
    149         void *virt;
    150         size_t offset;
    151         unsigned int pages;
    152        
    153146#ifdef IO_SPACE_BOUNDARY
    154147        if (pio_addr < IO_SPACE_BOUNDARY) {
    155                 *use_addr = pio_addr;
     148                *virt = pio_addr;
    156149                return iospace_enable(task_get_id(), pio_addr, size);
    157150        }
    158151#endif
    159152       
    160         phys = (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
    161         offset = pio_addr - phys;
    162         pages = ALIGN_UP(offset + size, PAGE_SIZE) >> PAGE_WIDTH;
    163         virt = as_get_mappable_page(pages << PAGE_WIDTH);
    164         *use_addr = virt + offset;
    165         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;
    166166}
    167167

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

    r24cf31f1 rfbcdeb8  
    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

    r24cf31f1 rfbcdeb8  
    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

    r24cf31f1 rfbcdeb8  
    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

    r24cf31f1 rfbcdeb8  
    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);

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

    r24cf31f1 rfbcdeb8  
    5959extern int as_area_destroy(void *);
    6060extern void *set_maxheapsize(size_t);
    61 extern void *as_get_mappable_page(size_t);
    6261extern int as_get_physical_mapping(const void *, uintptr_t *);
    6362

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

    r24cf31f1 rfbcdeb8  
    346346 */
    347347
    348 #define async_share_in_start_0_0(exch, dst, size) \
    349         async_share_in_start(exch, dst, size, 0, NULL)
    350 #define async_share_in_start_0_1(exch, dst, size, flags) \
    351         async_share_in_start(exch, dst, size, 0, flags)
    352 #define async_share_in_start_1_0(exch, dst, size, arg) \
    353         async_share_in_start(exch, dst, size, arg, NULL)
    354 #define async_share_in_start_1_1(exch, dst, size, arg, flags) \
    355         async_share_in_start(exch, dst, size, arg, flags)
    356 
    357 extern int async_share_in_start(async_exch_t *, void *, size_t, sysarg_t,
    358     unsigned int *);
     348#define async_share_in_start_0_0(exch, size, dst) \
     349        async_share_in_start(exch, size, 0, NULL, dst)
     350#define async_share_in_start_0_1(exch, size, flags, dst) \
     351        async_share_in_start(exch, size, 0, flags, dst)
     352#define async_share_in_start_1_0(exch, size, arg, dst) \
     353        async_share_in_start(exch, size, arg, NULL, dst)
     354#define async_share_in_start_1_1(exch, size, arg, flags, dst) \
     355        async_share_in_start(exch, size, arg, flags, dst)
     356
     357extern int async_share_in_start(async_exch_t *, size_t, sysarg_t,
     358    unsigned int *, void **);
    359359extern bool async_share_in_receive(ipc_callid_t *, size_t *);
    360360extern int async_share_in_finalize(ipc_callid_t, void *, unsigned int);
    … …  
    362362extern int async_share_out_start(async_exch_t *, void *, unsigned int);
    363363extern bool async_share_out_receive(ipc_callid_t *, size_t *, unsigned int *);
    364 extern int async_share_out_finalize(ipc_callid_t, void *);
     364extern int async_share_out_finalize(ipc_callid_t, void **);
    365365
    366366/*

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

    r24cf31f1 rfbcdeb8  
    4242extern int device_assign_devno(void);
    4343
    44 extern int physmem_map(void *, void *, size_t, unsigned int);
     44extern int physmem_map(void *, size_t, unsigned int, void **);
    4545
    4646extern int dmamem_map(void *, size_t, unsigned int, unsigned int, void **);
    4747extern int dmamem_map_anonymous(size_t, unsigned int, unsigned int, void **,
    4848    void **);
    49 extern int dmamem_unmap(void *, size_t, unsigned int);
     49extern int dmamem_unmap(void *, size_t);
    5050extern int dmamem_unmap_anonymous(void *);
    5151

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

    r24cf31f1 rfbcdeb8  
    271271 */
    272272
    273 #define ipc_share_in_start_0_0(phoneid, dst, size) \
    274         ipc_share_in_start((phoneid), (dst), (size), 0, NULL)
    275 #define ipc_share_in_start_0_1(phoneid, dst, size, flags) \
    276         ipc_share_in_start((phoneid), (dst), (size), 0, (flags))
    277 #define ipc_share_in_start_1_0(phoneid, dst, size, arg) \
    278         ipc_share_in_start((phoneid), (dst), (size), (arg), NULL)
    279 #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
    280         ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
    281 
    282 extern int ipc_share_in_start(int, void *, size_t, sysarg_t, unsigned int *);
     273#define ipc_share_in_start_0_0(phoneid, size, dst) \
     274        ipc_share_in_start((phoneid), (size), 0, NULL, (dst))
     275#define ipc_share_in_start_0_1(phoneid, size, flags, dst) \
     276        ipc_share_in_start((phoneid), (size), 0, (flags), (dst))
     277#define ipc_share_in_start_1_0(phoneid, size, arg, dst) \
     278        ipc_share_in_start((phoneid), (size), (arg), NULL, (dst))
     279#define ipc_share_in_start_1_1(phoneid, size, arg, flags, dst) \
     280        ipc_share_in_start((phoneid), (size), (arg), (flags), (dst))
     281
     282extern int ipc_share_in_start(int, size_t, sysarg_t, unsigned int *, void **);
    283283extern int ipc_share_in_finalize(ipc_callid_t, void *, unsigned int);
    284284extern int ipc_share_out_start(int, void *, unsigned int);
    285 extern int ipc_share_out_finalize(ipc_callid_t, void *);
     285extern int ipc_share_out_finalize(ipc_callid_t, void **);
    286286extern int ipc_data_read_start(int, void *, size_t);
    287287extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);

  • uspace/lib/fb/imgmap.c

    r24cf31f1 rfbcdeb8  
    420420       
    421421        if ((flags & IMGMAP_FLAG_SHARED) == IMGMAP_FLAG_SHARED) {
    422                 imgmap = (imgmap_t *) as_get_mappable_page(size);
    423                
    424                 if (as_area_create((void *) imgmap, size, AS_AREA_READ |
    425                     AS_AREA_WRITE | AS_AREA_CACHEABLE) != (void *) imgmap)
     422                imgmap = (imgmap_t *) as_area_create((void *) -1, size,
     423                    AS_AREA_READ | AS_AREA_WRITE);
     424                if (imgmap == (void *) -1)
    426425                        return NULL;
    427426        } else {

  • uspace/lib/fb/screenbuffer.c

    r24cf31f1 rfbcdeb8  
    7979       
    8080        if ((flags & SCREENBUFFER_FLAG_SHARED) == SCREENBUFFER_FLAG_SHARED) {
    81                 scrbuf = (screenbuffer_t *) as_get_mappable_page(size);
    82                
    83                 if (as_area_create((void *) scrbuf, size, AS_AREA_READ |
    84                     AS_AREA_WRITE | AS_AREA_CACHEABLE) != (void *) scrbuf)
     81                scrbuf = (screenbuffer_t *) as_area_create((void *) -1, size,
     82                    AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
     83                if (scrbuf == (void *) -1)
    8584                        return NULL;
    8685        } else {

  • uspace/lib/fs/libfs.c

    r24cf31f1 rfbcdeb8  
    336336       
    337337        /*
    338          * Allocate piece of address space for PLB.
    339          */
    340         reg.plb_ro = as_get_mappable_page(PLB_SIZE);
    341         if (!reg.plb_ro) {
     338         * Request sharing the Path Lookup Buffer with VFS.
     339         */
     340        rc = async_share_in_start_0_0(exch, PLB_SIZE, (void *) &reg.plb_ro);
     341        if (reg.plb_ro == (void *) -1) {
    342342                async_exchange_end(exch);
    343343                async_wait_for(req, NULL);
    344344                return ENOMEM;
    345345        }
    346        
    347         /*
    348          * Request sharing the Path Lookup Buffer with VFS.
    349          */
    350         rc = async_share_in_start_0_0(exch, reg.plb_ro, PLB_SIZE);
    351346       
    352347        async_exchange_end(exch);

  • uspace/lib/net/generic/packet_remote.c

    r24cf31f1 rfbcdeb8  
    6666    packet_id_t packet_id, size_t size)
    6767{
    68         *packet = (packet_t *) as_get_mappable_page(size);
    69        
    7068        async_exch_t *exch = async_exchange_begin(sess);
    7169        ipc_call_t answer;
    7270        aid_t message = async_send_1(exch, NET_PACKET_GET, packet_id, &answer);
    73         int rc = async_share_in_start_0_0(exch, *packet, size);
     71        int rc = async_share_in_start_0_0(exch, size, (void *) packet);
    7472        async_exchange_end(exch);
    7573       
    … …  
    7977        if (rc != EOK)
    8078                return rc;
     79       
     80        if (packet == (void *) -1)
     81                return ENOMEM;
    8182       
    8283        rc = pm_add(*packet);

  • uspace/lib/nic/src/nic_driver.c

    r24cf31f1 rfbcdeb8  
    13451345int nic_dma_unlock_packet(packet_t *packet, size_t size)
    13461346{
    1347         return dmamem_unmap(packet, size, 0);
     1347        return dmamem_unmap(packet, size);
    13481348}
    13491349

  • uspace/srv/bd/ata_bd/ata_bd.c

    r24cf31f1 rfbcdeb8  
    309309        }
    310310
    311         fs_va = as_get_mappable_page(comm_size);
    312         if (fs_va == NULL) {
     311        (void) async_share_out_finalize(callid, &fs_va);
     312        if (fs_va == (void *) -1) {
    313313                async_answer_0(callid, EHANGUP);
    314314                return;
    315315        }
    316 
    317         (void) async_share_out_finalize(callid, fs_va);
    318316
    319317        while (true) {

  • uspace/srv/bd/file_bd/file_bd.c

    r24cf31f1 rfbcdeb8  
    190190        }
    191191
    192         fs_va = as_get_mappable_page(comm_size);
    193         if (fs_va == NULL) {
     192        (void) async_share_out_finalize(callid, &fs_va);
     193        if (fs_va == (void *) -1) {
    194194                async_answer_0(callid, EHANGUP);
    195195                return;
    196196        }
    197 
    198         (void) async_share_out_finalize(callid, fs_va);
    199197
    200198        while (true) {

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r24cf31f1 rfbcdeb8  
    193193        }
    194194
    195         fs_va = as_get_mappable_page(comm_size);
    196         if (fs_va == NULL) {
     195        (void) async_share_out_finalize(callid, &fs_va);
     196        if (fs_va == (void *) -1) {
    197197                async_answer_0(callid, EHANGUP);
    198198                return;
    199199        }
    200 
    201         (void) async_share_out_finalize(callid, fs_va);
    202200
    203201        while (true) {

  • uspace/srv/bd/part/guid_part/guid_part.c

    r24cf31f1 rfbcdeb8  
    348348        }
    349349
    350         fs_va = as_get_mappable_page(comm_size);
    351         if (fs_va == NULL) {
     350        (void) async_share_out_finalize(callid, &fs_va);
     351        if (fs_va == (void *) -1) {
    352352                async_answer_0(callid, EHANGUP);
    353353                return;
    354354        }
    355 
    356         (void) async_share_out_finalize(callid, fs_va);
    357355
    358356        while (true) {

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    r24cf31f1 rfbcdeb8  
    425425        }
    426426
    427         fs_va = as_get_mappable_page(comm_size);
    428         if (fs_va == NULL) {
     427        (void) async_share_out_finalize(callid, &fs_va);
     428        if (fs_va == (void *) -1) {
    429429                async_answer_0(callid, EHANGUP);
    430430                return;
    431431        }
    432 
    433         (void) async_share_out_finalize(callid, fs_va);
    434432
    435433        while (1) {

  • uspace/srv/bd/rd/rd.c

    r24cf31f1 rfbcdeb8  
    105105        unsigned int flags;
    106106        if (async_share_out_receive(&callid, &comm_size, &flags)) {
    107                 fs_va = as_get_mappable_page(comm_size);
    108                 if (fs_va) {
    109                         (void) async_share_out_finalize(callid, fs_va);
    110                 } else {
     107                (void) async_share_out_finalize(callid, &fs_va);
     108                if (fs_va == (void *) -1) {
    111109                        async_answer_0(callid, EHANGUP);
    112110                        return;
    … …  
    224222       
    225223        rd_size = ALIGN_UP(size, block_size);
    226         rd_addr = as_get_mappable_page(rd_size);
    227        
    228224        unsigned int flags =
    229225            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
    230         ret = physmem_map((void *) addr_phys, rd_addr,
    231             ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
    232         if (ret < 0) {
     226       
     227        ret = physmem_map((void *) addr_phys,
     228            ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags, &rd_addr);
     229        if (ret != EOK) {
    233230                printf("%s: Error mapping RAM disk\n", NAME);
    234231                return false;

  • uspace/srv/hid/fb/fb.c

    r24cf31f1 rfbcdeb8  
    304304        }
    305305       
    306         frontbuf->data = as_get_mappable_page(frontbuf->size);
    307         int rc = async_answer_1(callid, EOK, (sysarg_t) frontbuf->data);
    308         if (rc != EOK) {
     306        int rc = async_share_out_finalize(callid, &frontbuf->data);
     307        if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
    309308                free(frontbuf);
    310309                async_answer_0(iid, ENOMEM);
    … …  
    348347        }
    349348       
    350         imagemap->data = as_get_mappable_page(imagemap->size);
    351         int rc = async_answer_1(callid, EOK, (sysarg_t) imagemap->data);
    352         if (rc != EOK) {
     349        int rc = async_share_out_finalize(callid, &imagemap->data);
     350        if ((rc != EOK) || (imagemap->data == (void *) -1)) {
    353351                free(imagemap);
    354352                async_answer_0(iid, ENOMEM);

  • uspace/srv/hid/fb/port/ega.c

    r24cf31f1 rfbcdeb8  
    280280       
    281281        ega.size = (width * height) << 1;
    282         ega.addr = as_get_mappable_page(ega.size);
    283         if (ega.addr == NULL)
    284                 return ENOMEM;
    285        
    286         rc = physmem_map((void *) paddr, ega.addr,
    287             ALIGN_UP(ega.size, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     282       
     283        rc = physmem_map((void *) paddr,
     284            ALIGN_UP(ega.size, PAGE_SIZE) >> PAGE_WIDTH,
     285            AS_AREA_READ | AS_AREA_WRITE, (void *) &ega.addr);
    288286        if (rc != EOK)
    289287                return rc;

  • uspace/srv/hid/fb/port/kchar.c

    r24cf31f1 rfbcdeb8  
    8383                return rc;
    8484       
    85         kchar.addr = as_get_mappable_page(1);
    86         if (kchar.addr == NULL)
    87                 return ENOMEM;
    88        
    89         rc = physmem_map((void *) paddr, kchar.addr,
    90             ALIGN_UP(1, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     85        rc = physmem_map((void *) paddr,
     86            ALIGN_UP(1, PAGE_SIZE) >> PAGE_WIDTH,
     87            AS_AREA_READ | AS_AREA_WRITE, (void *) &kchar.addr);
    9188        if (rc != EOK)
    9289                return rc;

  • uspace/srv/hid/fb/port/kfb.c

    r24cf31f1 rfbcdeb8  
    756756       
    757757        kfb.size = scanline * height;
    758         kfb.addr = as_get_mappable_page(kfb.size);
    759         if (kfb.addr == NULL) {
    760                 free(kfb.glyphs);
    761                 return ENOMEM;
    762         }
    763        
    764         rc = physmem_map((void *) paddr + offset, kfb.addr,
    765             ALIGN_UP(kfb.size, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     758       
     759        rc = physmem_map((void *) paddr + offset,
     760            ALIGN_UP(kfb.size, PAGE_SIZE) >> PAGE_WIDTH,
     761            AS_AREA_READ | AS_AREA_WRITE, (void *) &kfb.addr);
    766762        if (rc != EOK) {
    767763                free(kfb.glyphs);

  • uspace/srv/hid/fb/port/niagara.c

    r24cf31f1 rfbcdeb8  
    103103                return rc;
    104104       
    105         niagara.fifo =
    106             (output_fifo_t *) as_get_mappable_page(sizeof(output_fifo_t));
    107         if (niagara.fifo == NULL)
    108                 return ENOMEM;
    109        
    110         rc = physmem_map((void *) paddr, (void *) niagara.fifo, 1,
    111             AS_AREA_READ | AS_AREA_WRITE);
     105        rc = physmem_map((void *) paddr, 1,
     106            AS_AREA_READ | AS_AREA_WRITE, (void *) &niagara.fifo);
    112107        if (rc != EOK)
    113108                return rc;

  • uspace/srv/hid/input/port/niagara.c

    r24cf31f1 rfbcdeb8  
    6363#define POLL_INTERVAL  10000
    6464
    65 /**
    66  * Virtual address mapped to the buffer shared with the kernel counterpart.
    67  */
    68 static uintptr_t input_buffer_addr;
    69 
    7065/*
    7166 * Kernel counterpart of the driver pushes characters (it has read) here.
    … …  
    10297                return -1;
    10398       
    104         input_buffer_addr = (uintptr_t) as_get_mappable_page(PAGE_SIZE);
    105         int rc = physmem_map((void *) paddr, (void *) input_buffer_addr,
    106             1, AS_AREA_READ | AS_AREA_WRITE);
    107        
     99        int rc = physmem_map((void *) paddr, 1,
     100            AS_AREA_READ | AS_AREA_WRITE, (void *) &input_buffer);
    108101        if (rc != 0) {
    109102                printf("Niagara: uspace driver couldn't map physical memory: %d\n",
    … …  
    111104                return rc;
    112105        }
    113        
    114         input_buffer = (input_buffer_t) input_buffer_addr;
    115106       
    116107        thread_id_t tid;

  • uspace/srv/hw/irc/obio/obio.c

    r24cf31f1 rfbcdeb8  
    124124       
    125125        base_phys = (void *) paddr;
    126         base_virt = as_get_mappable_page(OBIO_SIZE);
    127126       
    128127        int flags = AS_AREA_READ | AS_AREA_WRITE;
    129         int retval = physmem_map(base_phys, (void *) base_virt,
    130             ALIGN_UP(OBIO_SIZE, PAGE_SIZE) >> PAGE_WIDTH, flags);
     128        int retval = physmem_map(base_phys,
     129            ALIGN_UP(OBIO_SIZE, PAGE_SIZE) >> PAGE_WIDTH, flags, &base_virt);
    131130       
    132131        if (retval < 0) {

  • uspace/srv/vfs/vfs.c

    r24cf31f1 rfbcdeb8  
    172172         * Allocate and initialize the Path Lookup Buffer.
    173173         */
    174         plb = as_get_mappable_page(PLB_SIZE);
    175         if (!plb) {
    176                 printf(NAME ": Cannot allocate a mappable piece of address space\n");
    177                 return ENOMEM;
    178         }
    179        
    180         if (as_area_create(plb, PLB_SIZE, AS_AREA_READ | AS_AREA_WRITE |
    181             AS_AREA_CACHEABLE) != plb) {
     174        plb = as_area_create((void *) -1, PLB_SIZE,
     175            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
     176        if (plb == (void *) -1) {
    182177                printf(NAME ": Cannot create address space area\n");
    183178                return ENOMEM;
Note: See TracChangeset for help on using the changeset viewer.