Changeset 3e828ea in mainline for kernel/generic/src


Ignore:
Timestamp:
2019-09-23T12:49:29Z (6 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9be2358
Parents:
9259d20 (diff), 1a4ec93f (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.
git-author:
Jiri Svoboda <jiri@…> (2019-09-22 12:49:07)
git-committer:
Jiri Svoboda <jiri@…> (2019-09-23 12:49:29)
Message:

Merge changes from master, especially Meson build

Location:
kernel/generic/src
Files:
1 added
26 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/cap/cap.c

    r9259d20 r3e828ea  
    8888#include <stdlib.h>
    8989
    90 #define CAPS_START      (CAP_NIL + 1)
    91 #define CAPS_SIZE       (INT_MAX - CAPS_START)
     90#define CAPS_START      ((intptr_t) CAP_NIL + 1)
     91#define CAPS_SIZE       (INT_MAX - (int) CAPS_START)
    9292#define CAPS_LAST       (CAPS_SIZE - 1)
    9393

  • kernel/generic/src/console/console.c

    r9259d20 r3e828ea  
    395395 *
    396396 */
    397 sys_errno_t sys_kio(int cmd, const void *buf, size_t size)
     397sys_errno_t sys_kio(int cmd, uspace_addr_t buf, size_t size)
    398398{
    399399        char *data;

  • kernel/generic/src/ddi/ddi.c

    r9259d20 r3e828ea  
    4646#include <mm/frame.h>
    4747#include <mm/as.h>
     48#include <mm/km.h>
    4849#include <mm/page.h>
    4950#include <synch/mutex.h>
    … …  
    5657#include <trace.h>
    5758#include <bitops.h>
     59#include <arch/asm.h>
    5860
    5961/** This lock protects the @c pareas ordered dictionary. */
    … …  
    246248 */
    247249sys_errno_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
    248     void *virt_ptr, uintptr_t bound)
     250    uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
    249251{
    250252        uintptr_t virt;
    … …  
    260262        rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
    261263        if (rc != EOK) {
    262                 physmem_unmap((uintptr_t) virt);
     264                physmem_unmap(virt);
    263265                return rc;
    264266        }
    … …  
    391393 *
    392394 */
    393 sys_errno_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
     395sys_errno_t sys_iospace_enable(uspace_ptr_ddi_ioarg_t uspace_io_arg)
    394396{
    395397        ddi_ioarg_t arg;
    … …  
    402404}
    403405
    404 sys_errno_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
     406sys_errno_t sys_iospace_disable(uspace_ptr_ddi_ioarg_t uspace_io_arg)
    405407{
    406408        ddi_ioarg_t arg;
    … …  
    463465
    464466sys_errno_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
    465     void *phys_ptr, void *virt_ptr, uintptr_t bound)
     467    uspace_ptr_uintptr_t phys_ptr, uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
    466468{
    467469        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
    … …  
    471473
    472474                uintptr_t phys;
    473                 errno_t rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
     475                errno_t rc = dmamem_map(virt_ptr, size, map_flags,
    474476                    flags, &phys);
    475477
    … …  
    479481                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
    480482                if (rc != EOK) {
    481                         dmamem_unmap((uintptr_t) virt_ptr, size);
     483                        dmamem_unmap(virt_ptr, size);
    482484                        return rc;
    483485                }
    … …  
    506508                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
    507509                if (rc != EOK) {
    508                         dmamem_unmap_anonymous((uintptr_t) virt);
     510                        dmamem_unmap_anonymous(virt);
    509511                        return rc;
    510512                }
    … …  
    512514                rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
    513515                if (rc != EOK) {
    514                         dmamem_unmap_anonymous((uintptr_t) virt);
     516                        dmamem_unmap_anonymous(virt);
    515517                        return rc;
    516518                }
    … …  
    527529                return dmamem_unmap_anonymous(virt);
    528530}
     531void *pio_map(void *phys, size_t size)
     532{
     533#ifdef IO_SPACE_BOUNDARY
     534        if (phys < IO_SPACE_BOUNDARY)
     535                return phys;
     536#endif
     537        return (void *) km_map((uintptr_t) phys, size, KM_NATURAL_ALIGNMENT,
     538            PAGE_READ | PAGE_WRITE | PAGE_NOT_CACHEABLE);
     539}
     540
     541void pio_unmap(void *phys, void *virt, size_t size)
     542{
     543#ifdef IO_SPACE_BOUNDARY
     544        if (phys < IO_SPACE_BOUNDARY)
     545                return;
     546#endif
     547        km_unmap((uintptr_t) virt, size);
     548}
    529549
    530550/** @}

  • kernel/generic/src/ipc/irq.c

    r9259d20 r3e828ea  
    223223 *
    224224 */
    225 static irq_code_t *code_from_uspace(irq_code_t *ucode)
     225static irq_code_t *code_from_uspace(uspace_ptr_irq_code_t ucode)
    226226{
    227227        irq_pio_range_t *ranges = NULL;
    … …  
    242242        if (!ranges)
    243243                goto error;
    244         rc = copy_from_uspace(ranges, code->ranges,
     244        rc = copy_from_uspace(ranges, (uintptr_t) code->ranges,
    245245            sizeof(code->ranges[0]) * code->rangecount);
    246246        if (rc != EOK)
    … …  
    250250        if (!cmds)
    251251                goto error;
    252         rc = copy_from_uspace(cmds, code->cmds,
     252        rc = copy_from_uspace(cmds, (uintptr_t) code->cmds,
    253253            sizeof(code->cmds[0]) * code->cmdcount);
    254254        if (rc != EOK)
    … …  
    323323 */
    324324errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
    325     irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
     325    uspace_ptr_irq_code_t ucode, uspace_ptr_cap_irq_handle_t uspace_handle)
    326326{
    327327        if ((inr < 0) || (inr > last_inr))

  • kernel/generic/src/ipc/ops/dataread.c

    r9259d20 r3e828ea  
    6363        if (!ipc_get_retval(&answer->data)) {
    6464                /* The recipient agreed to send data. */
    65                 uintptr_t src = ipc_get_arg1(&answer->data);
    66                 uintptr_t dst = ipc_get_arg1(olddata);
     65                uspace_addr_t src = ipc_get_arg1(&answer->data);
     66                uspace_addr_t dst = ipc_get_arg1(olddata);
    6767                size_t max_size = ipc_get_arg2(olddata);
    6868                size_t size = ipc_get_arg2(&answer->data);
    … …  
    8181                        }
    8282                        errno_t rc = copy_from_uspace(answer->buffer,
    83                             (void *) src, size);
     83                            src, size);
    8484                        if (rc) {
    8585                                ipc_set_retval(&answer->data, rc);
    … …  
    103103{
    104104        if (answer->buffer) {
    105                 uintptr_t dst = ipc_get_arg1(&answer->data);
     105                uspace_addr_t dst = ipc_get_arg1(&answer->data);
    106106                size_t size = ipc_get_arg2(&answer->data);
    107107                errno_t rc;
    108108
    109                 rc = copy_to_uspace((void *) dst, answer->buffer, size);
     109                rc = copy_to_uspace(dst, answer->buffer, size);
    110110                if (rc)
    111111                        ipc_set_retval(&answer->data, rc);

  • kernel/generic/src/ipc/ops/datawrite.c

    r9259d20 r3e828ea  
    4343static errno_t request_preprocess(call_t *call, phone_t *phone)
    4444{
    45         uintptr_t src = ipc_get_arg1(&call->data);
     45        uspace_addr_t src = ipc_get_arg1(&call->data);
    4646        size_t size = ipc_get_arg2(&call->data);
    4747
    … …  
    5959        if (!call->buffer)
    6060                return ENOMEM;
    61         errno_t rc = copy_from_uspace(call->buffer, (void *) src, size);
     61        errno_t rc = copy_from_uspace(call->buffer, src, size);
    6262        if (rc != EOK) {
    6363                /*
    … …  
    7777        if (!ipc_get_retval(&answer->data)) {
    7878                /* The recipient agreed to receive data. */
    79                 uintptr_t dst = (uintptr_t)ipc_get_arg1(&answer->data);
    80                 size_t size = (size_t)ipc_get_arg2(&answer->data);
    81                 size_t max_size = (size_t)ipc_get_arg2(olddata);
     79                uspace_addr_t dst = ipc_get_arg1(&answer->data);
     80                size_t size = ipc_get_arg2(&answer->data);
     81                size_t max_size = ipc_get_arg2(olddata);
    8282
    8383                if (size <= max_size) {
    84                         errno_t rc = copy_to_uspace((void *) dst,
     84                        errno_t rc = copy_to_uspace(dst,
    8585                            answer->buffer, size);
    8686                        if (rc)

  • kernel/generic/src/ipc/ops/debug.c

    r9259d20 r3e828ea  
    4747{
    4848        if (answer->buffer) {
    49                 uintptr_t dst = ipc_get_arg1(&answer->data);
     49                uspace_addr_t dst = ipc_get_arg1(&answer->data);
    5050                size_t size = ipc_get_arg2(&answer->data);
    5151                errno_t rc;
    5252
    53                 rc = copy_to_uspace((void *) dst, answer->buffer, size);
     53                rc = copy_to_uspace(dst, answer->buffer, size);
    5454                if (rc)
    5555                        ipc_set_retval(&answer->data, rc);

  • kernel/generic/src/ipc/ops/shareout.c

    r9259d20 r3e828ea  
    7070
    7171                if (rc == EOK) {
    72                         rc = copy_to_uspace((void *) ipc_get_arg2(&answer->data),
     72                        rc = copy_to_uspace(ipc_get_arg2(&answer->data),
    7373                            &dst_base, sizeof(dst_base));
    7474                }

  • kernel/generic/src/ipc/sysipc.c

    r9259d20 r3e828ea  
    419419 *
    420420 */
    421 sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, ipc_data_t *data,
     421sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, uspace_ptr_ipc_data_t data,
    422422    sysarg_t label)
    423423{
    … …  
    437437        }
    438438
    439         errno_t rc = copy_from_uspace(&call->data.args, &data->args,
     439        errno_t rc = copy_from_uspace(&call->data.args, data + offsetof(ipc_data_t, args),
    440440            sizeof(call->data.args));
    441441        if (rc != EOK) {
    … …  
    623623 */
    624624sys_errno_t sys_ipc_forward_slow(cap_call_handle_t chandle,
    625     cap_phone_handle_t phandle, ipc_data_t *data, unsigned int mode)
     625    cap_phone_handle_t phandle, uspace_ptr_ipc_data_t data, unsigned int mode)
    626626{
    627627        ipc_data_t newdata;
    628         errno_t rc = copy_from_uspace(&newdata.args, &data->args,
     628        errno_t rc = copy_from_uspace(&newdata.args, data + offsetof(ipc_data_t, args),
    629629            sizeof(newdata.args));
    630630        if (rc != EOK)
    … …  
    700700 *
    701701 */
    702 sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, ipc_data_t *data)
     702sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, uspace_ptr_ipc_data_t data)
    703703{
    704704        kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
    … …  
    718718                saved = false;
    719719
    720         errno_t rc = copy_from_uspace(&call->data.args, &data->args,
     720        errno_t rc = copy_from_uspace(&call->data.args, data + offsetof(ipc_data_t, args),
    721721            sizeof(call->data.args));
    722722        if (rc != EOK) {
    … …  
    766766 * @return An error code on error.
    767767 */
    768 sys_errno_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     768sys_errno_t sys_ipc_wait_for_call(uspace_ptr_ipc_data_t calldata, uint32_t usec,
    769769    unsigned int flags)
    770770{
    … …  
    888888 */
    889889sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod,
    890     irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
     890    uspace_ptr_irq_code_t ucode, uspace_ptr_cap_irq_handle_t uspace_handle)
    891891{
    892892        if (!(perm_get(TASK) & PERM_IRQ_REG))
    … …  
    918918 *
    919919 */
    920 sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid,
    921     cap_phone_handle_t *uspace_phone)
     920sys_errno_t sys_ipc_connect_kbox(uspace_ptr_task_id_t uspace_taskid,
     921    uspace_ptr_cap_phone_handle_t uspace_phone)
    922922{
    923923#ifdef CONFIG_UDEBUG

  • kernel/generic/src/lib/elf.c

    r9259d20 r3e828ea  
    5050#include <lib/elf_load.h>
    5151
    52 static const char *error_codes[] = {
    53         "no error",
    54         "invalid image",
    55         "address space error",
    56         "incompatible image",
    57         "unsupported image type",
    58         "irrecoverable error"
    59 };
    60 
    61 static int load_segment(elf_segment_header_t *, elf_header_t *, as_t *);
     52static errno_t load_segment(elf_segment_header_t *, elf_header_t *, as_t *);
    6253
    6354/** ELF loader
    … …  
    6758 * @param flags  A combination of ELD_F_*
    6859 *
    69  * @return EE_OK on success
     60 * @return EOK on success
    7061 *
    7162 */
    72 unsigned int elf_load(elf_header_t *header, as_t *as)
     63errno_t elf_load(elf_header_t *header, as_t *as)
    7364{
    7465        /* Identify ELF */
    … …  
    7768            (header->e_ident[EI_MAG2] != ELFMAG2) ||
    7869            (header->e_ident[EI_MAG3] != ELFMAG3))
    79                 return EE_INVALID;
     70                return EINVAL;
    8071
    8172        /* Identify ELF compatibility */
    … …  
    8576            (header->e_version != EV_CURRENT) ||
    8677            (header->e_ident[EI_CLASS] != ELF_CLASS))
    87                 return EE_INCOMPATIBLE;
     78                return EINVAL;
    8879
    8980        if (header->e_phentsize != sizeof(elf_segment_header_t))
    90                 return EE_INCOMPATIBLE;
     81                return EINVAL;
    9182
    9283        /* Check if the object type is supported. */
    9384        if (header->e_type != ET_EXEC)
    94                 return EE_UNSUPPORTED;
     85                return ENOTSUP;
    9586
    9687        /* Check if the ELF image starts on a page boundary */
    9788        if (ALIGN_UP((uintptr_t) header, PAGE_SIZE) != (uintptr_t) header)
    98                 return EE_UNSUPPORTED;
     89                return ENOTSUP;
    9990
    10091        /* Walk through all segment headers and process them. */
    … …  
    10899                        continue;
    109100
    110                 int rc = load_segment(seghdr, header, as);
    111                 if (rc != EE_OK)
     101                errno_t rc = load_segment(seghdr, header, as);
     102                if (rc != EOK)
    112103                        return rc;
    113104        }
    114105
    115         return EE_OK;
    116 }
    117 
    118 /** Print error message according to error code.
    119  *
    120  * @param rc Return code returned by elf_load().
    121  *
    122  * @return NULL terminated description of error.
    123  *
    124  */
    125 const char *elf_error(unsigned int rc)
    126 {
    127         assert(rc < sizeof(error_codes) / sizeof(char *));
    128 
    129         return error_codes[rc];
     106        return EOK;
    130107}
    131108
    … …  
    136113 * @param as    Address space into wich the ELF is being loaded.
    137114 *
    138  * @return EE_OK on success, error code otherwise.
     115 * @return EOK on success, error code otherwise.
    139116 *
    140117 */
    141 int load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
     118errno_t load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
    142119{
    143120        mem_backend_data_t backend_data;
    … …  
    146123                if ((entry->p_offset % entry->p_align) !=
    147124                    (entry->p_vaddr % entry->p_align))
    148                         return EE_INVALID;
     125                        return EINVAL;
    149126        }
    150127
    … …  
    177154            AS_AREA_ATTR_NONE, &elf_backend, &backend_data, &base, 0);
    178155        if (!area)
    179                 return EE_MEMORY;
     156                return ENOMEM;
    180157
    181158        /*
    … …  
    184161         */
    185162
    186         return EE_OK;
     163        return EOK;
    187164}
    188165

  • kernel/generic/src/lib/str.c

    r9259d20 r3e828ea  
    789789        str_ncpy(dest, size + 1, src, size);
    790790        return dest;
    791 }
    792 
    793 /** Convert string to uint64_t (internal variant).
    794  *
    795  * @param nptr   Pointer to string.
    796  * @param endptr Pointer to the first invalid character is stored here.
    797  * @param base   Zero or number between 2 and 36 inclusive.
    798  * @param neg    Indication of unary minus is stored here.
    799  * @apram result Result of the conversion.
    800  *
    801  * @return EOK if conversion was successful.
    802  *
    803  */
    804 static errno_t str_uint(const char *nptr, char **endptr, unsigned int base,
    805     bool *neg, uint64_t *result)
    806 {
    807         assert(endptr != NULL);
    808         assert(neg != NULL);
    809         assert(result != NULL);
    810 
    811         *neg = false;
    812         const char *str = nptr;
    813 
    814         /* Ignore leading whitespace */
    815         while (isspace(*str))
    816                 str++;
    817 
    818         if (*str == '-') {
    819                 *neg = true;
    820                 str++;
    821         } else if (*str == '+')
    822                 str++;
    823 
    824         if (base == 0) {
    825                 /* Decode base if not specified */
    826                 base = 10;
    827 
    828                 if (*str == '0') {
    829                         base = 8;
    830                         str++;
    831 
    832                         switch (*str) {
    833                         case 'b':
    834                         case 'B':
    835                                 base = 2;
    836                                 str++;
    837                                 break;
    838                         case 'o':
    839                         case 'O':
    840                                 base = 8;
    841                                 str++;
    842                                 break;
    843                         case 'd':
    844                         case 'D':
    845                         case 't':
    846                         case 'T':
    847                                 base = 10;
    848                                 str++;
    849                                 break;
    850                         case 'x':
    851                         case 'X':
    852                                 base = 16;
    853                                 str++;
    854                                 break;
    855                         default:
    856                                 str--;
    857                         }
    858                 }
    859         } else {
    860                 /* Check base range */
    861                 if ((base < 2) || (base > 36)) {
    862                         *endptr = (char *) str;
    863                         return EINVAL;
    864                 }
    865         }
    866 
    867         *result = 0;
    868         const char *startstr = str;
    869 
    870         while (*str != 0) {
    871                 unsigned int digit;
    872 
    873                 if ((*str >= 'a') && (*str <= 'z'))
    874                         digit = *str - 'a' + 10;
    875                 else if ((*str >= 'A') && (*str <= 'Z'))
    876                         digit = *str - 'A' + 10;
    877                 else if ((*str >= '0') && (*str <= '9'))
    878                         digit = *str - '0';
    879                 else
    880                         break;
    881 
    882                 if (digit >= base)
    883                         break;
    884 
    885                 uint64_t prev = *result;
    886                 *result = (*result) * base + digit;
    887 
    888                 if (*result < prev) {
    889                         /* Overflow */
    890                         *endptr = (char *) str;
    891                         return EOVERFLOW;
    892                 }
    893 
    894                 str++;
    895         }
    896 
    897         if (str == startstr) {
    898                 /*
    899                  * No digits were decoded => first invalid character is
    900                  * the first character of the string.
    901                  */
    902                 str = nptr;
    903         }
    904 
    905         *endptr = (char *) str;
    906 
    907         if (str == nptr)
    908                 return EINVAL;
    909 
    910         return EOK;
    911 }
    912 
    913 /** Convert string to uint64_t.
    914  *
    915  * @param nptr   Pointer to string.
    916  * @param endptr If not NULL, pointer to the first invalid character
    917  *               is stored here.
    918  * @param base   Zero or number between 2 and 36 inclusive.
    919  * @param strict Do not allow any trailing characters.
    920  * @param result Result of the conversion.
    921  *
    922  * @return EOK if conversion was successful.
    923  *
    924  */
    925 errno_t str_uint64_t(const char *nptr, char **endptr, unsigned int base,
    926     bool strict, uint64_t *result)
    927 {
    928         assert(result != NULL);
    929 
    930         bool neg;
    931         char *lendptr;
    932         errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
    933 
    934         if (endptr != NULL)
    935                 *endptr = (char *) lendptr;
    936 
    937         if (ret != EOK)
    938                 return ret;
    939 
    940         /* Do not allow negative values */
    941         if (neg)
    942                 return EINVAL;
    943 
    944         /*
    945          * Check whether we are at the end of
    946          * the string in strict mode
    947          */
    948         if ((strict) && (*lendptr != 0))
    949                 return EINVAL;
    950 
    951         return EOK;
    952791}
    953792

  • kernel/generic/src/log/log.c

    r9259d20 r3e828ea  
    295295 *
    296296 */
    297 sys_errno_t sys_klog(sysarg_t operation, void *buf, size_t size,
    298     sysarg_t level, size_t *uspace_nread)
     297sys_errno_t sys_klog(sysarg_t operation, uspace_addr_t buf, size_t size,
     298    sysarg_t level, uspace_ptr_size_t uspace_nread)
    299299{
    300300        char *data;

  • kernel/generic/src/main/kinit.c

    r9259d20 r3e828ea  
    291291                        log(LF_OTHER, LVL_ERROR,
    292292                            "init[%zu]: Init binary load failed "
    293                             "(error %s, loader status %u)", i,
    294                             str_error_name(rc), programs[i].loader_status);
     293                            "(error %s, loader status %s)", i,
     294                            str_error_name(rc), str_error_name(programs[i].loader_status));
    295295                }
    296296        }

  • kernel/generic/src/main/uinit.c

    r9259d20 r3e828ea  
    7070#endif
    7171
    72         uspace_arg_t *uarg = (uspace_arg_t *) arg;
     72        uspace_arg_t *uarg = arg;
    7373        uspace_arg_t local_uarg;
    7474
    … …  
    7777        local_uarg.uspace_stack_size = uarg->uspace_stack_size;
    7878        local_uarg.uspace_uarg = uarg->uspace_uarg;
    79         local_uarg.uspace_thread_function = NULL;
    80         local_uarg.uspace_thread_arg = NULL;
     79        local_uarg.uspace_thread_function = USPACE_NULL;
     80        local_uarg.uspace_thread_arg = USPACE_NULL;
    8181
    8282        free(uarg);

  • kernel/generic/src/main/version.c

    r9259d20 r3e828ea  
    3838
    3939static const char *project = "SPARTAN kernel";
    40 static const char *copyright = STRING(COPYRIGHT);
    41 static const char *release = STRING(RELEASE);
    42 static const char *name = STRING(NAME);
     40static const char *copyright = STRING(HELENOS_COPYRIGHT);
     41static const char *release = STRING(HELENOS_RELEASE);
     42static const char *name = STRING(HELENOS_CODENAME);
    4343static const char *arch = STRING(KARCH);
    4444

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

    r9259d20 r3e828ea  
    20922092
    20932093sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
    2094     uintptr_t bound, as_area_pager_info_t *pager_info)
     2094    uintptr_t bound, uspace_ptr_as_area_pager_info_t pager_info)
    20952095{
    20962096        uintptr_t virt = base;
    … …  
    20982098        mem_backend_data_t backend_data;
    20992099
    2100         if (pager_info == AS_AREA_UNPAGED)
     2100        if (!pager_info)
    21012101                backend = &anon_backend;
    21022102        else {
    … …  
    21252125}
    21262126
    2127 sys_errno_t sys_as_area_get_info(uintptr_t address, as_area_info_t *dest)
     2127sys_errno_t sys_as_area_get_info(uintptr_t address, uspace_ptr_as_area_info_t dest)
    21282128{
    21292129        as_area_t *area;
     2130        as_area_info_t info;
     2131
     2132        /* Prevent leaking stack bytes via structure padding. */
     2133        memset(&info, 0, sizeof(info));
    21302134
    21312135        mutex_lock(&AS->lock);
    … …  
    21362140        }
    21372141
    2138         dest->start_addr = area->base;
    2139         dest->size = P2SZ(area->pages);
    2140         dest->flags = area->flags;
     2142        info.start_addr = area->base;
     2143        info.size = P2SZ(area->pages);
     2144        info.flags = area->flags;
    21412145
    21422146        mutex_unlock(&area->lock);
    21432147        mutex_unlock(&AS->lock);
     2148
     2149        copy_to_uspace(dest, &info, sizeof(info));
    21442150        return EOK;
    21452151}

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

    r9259d20 r3e828ea  
    215215 *
    216216 */
    217 sys_errno_t sys_page_find_mapping(uintptr_t virt, uintptr_t *phys_ptr)
     217sys_errno_t sys_page_find_mapping(uintptr_t virt, uspace_ptr_uintptr_t phys_ptr)
    218218{
    219219        uintptr_t phys;

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

    r9259d20 r3e828ea  
    4848#include <security/perm.h>
    4949#include <lib/elf_load.h>
    50 #include <errno.h>
     50#include <str.h>
    5151#include <log.h>
    5252#include <syscall/copy.h>
    … …  
    6969 *
    7070 */
    71 errno_t program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
     71errno_t program_create(as_t *as, uspace_addr_t entry_addr, char *name, program_t *prg)
    7272{
    7373        uspace_arg_t *kernel_uarg = (uspace_arg_t *)
    … …  
    7676                return ENOMEM;
    7777
    78         prg->loader_status = EE_OK;
     78        prg->loader_status = EOK;
    7979        prg->task = task_create(as, name);
    8080        if (!prg->task) {
    … …  
    8686         * Create the stack address space area.
    8787         */
    88         uintptr_t virt = (uintptr_t) -1;
     88        uintptr_t virt = (uintptr_t) AS_AREA_ANY;
    8989        uintptr_t bound = USER_ADDRESS_SPACE_END - (STACK_SIZE_USER - 1);
    9090
    … …  
    103103        }
    104104
    105         kernel_uarg->uspace_entry = (void *) entry_addr;
    106         kernel_uarg->uspace_stack = (void *) virt;
     105        kernel_uarg->uspace_entry = entry_addr;
     106        kernel_uarg->uspace_stack = virt;
    107107        kernel_uarg->uspace_stack_size = STACK_SIZE_USER;
    108         kernel_uarg->uspace_thread_function = NULL;
    109         kernel_uarg->uspace_thread_arg = NULL;
    110         kernel_uarg->uspace_uarg = NULL;
     108        kernel_uarg->uspace_thread_function = USPACE_NULL;
     109        kernel_uarg->uspace_thread_arg = USPACE_NULL;
     110        kernel_uarg->uspace_uarg = USPACE_NULL;
    111111
    112112        /*
    … …  
    149149
    150150        prg->loader_status = elf_load((elf_header_t *) image_addr, as);
    151         if (prg->loader_status != EE_OK) {
     151        if (prg->loader_status != EOK) {
    152152                as_release(as);
    153153                prg->task = NULL;
    … …  
    183183
    184184        prg->loader_status = elf_load((elf_header_t *) program_loader, as);
    185         if (prg->loader_status != EE_OK) {
     185        if (prg->loader_status != EOK) {
    186186                as_release(as);
    187187                log(LF_OTHER, LVL_ERROR, "Cannot spawn loader (%s)",
    188                     elf_error(prg->loader_status));
     188                    str_error(prg->loader_status));
    189189                return ENOENT;
    190190        }
    … …  
    218218 *
    219219 */
    220 sys_errno_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
     220sys_errno_t sys_program_spawn_loader(uspace_ptr_char uspace_name, size_t name_len)
    221221{
    222222        /* Cap length of name and copy it from userspace. */

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

    r9259d20 r3e828ea  
    323323 *
    324324 */
    325 sys_errno_t sys_task_get_id(sysarg64_t *uspace_taskid)
     325sys_errno_t sys_task_get_id(uspace_ptr_sysarg64_t uspace_taskid)
    326326{
    327327        /*
    … …  
    363363 *
    364364 */
    365 sys_errno_t sys_task_set_name(const char *uspace_name, size_t name_len)
     365sys_errno_t sys_task_set_name(const uspace_ptr_char uspace_name, size_t name_len)
    366366{
    367367        char namebuf[TASK_NAME_BUFLEN];
    … …  
    404404 *
    405405 */
    406 sys_errno_t sys_task_kill(task_id_t *uspace_taskid)
     406sys_errno_t sys_task_kill(uspace_ptr_task_id_t uspace_taskid)
    407407{
    408408        task_id_t taskid;

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

    r9259d20 r3e828ea  
    998998 *
    999999 */
    1000 sys_errno_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
    1001     size_t name_len, thread_id_t *uspace_thread_id)
     1000sys_errno_t sys_thread_create(uspace_ptr_uspace_arg_t uspace_uarg, uspace_ptr_char uspace_name,
     1001    size_t name_len, uspace_ptr_thread_id_t uspace_thread_id)
    10021002{
    10031003        if (name_len > THREAD_NAME_BUFLEN - 1)
    … …  
    10291029            THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf);
    10301030        if (thread) {
    1031                 if (uspace_thread_id != NULL) {
     1031                if (uspace_thread_id) {
    10321032                        rc = copy_to_uspace(uspace_thread_id, &thread->tid,
    10331033                            sizeof(thread->tid));
    … …  
    10881088 *
    10891089 */
    1090 sys_errno_t sys_thread_get_id(thread_id_t *uspace_thread_id)
     1090sys_errno_t sys_thread_get_id(uspace_ptr_thread_id_t uspace_thread_id)
    10911091{
    10921092        /*

  • kernel/generic/src/security/perm.c

    r9259d20 r3e828ea  
    158158 *
    159159 */
    160 sys_errno_t sys_perm_grant(sysarg64_t *uspace_taskid, perm_t perms)
     160sys_errno_t sys_perm_grant(uspace_ptr_sysarg64_t uspace_taskid, perm_t perms)
    161161{
    162162        sysarg64_t taskid;
    … …  
    179179 *
    180180 */
    181 sys_errno_t sys_perm_revoke(sysarg64_t *uspace_taskid, perm_t perms)
     181sys_errno_t sys_perm_revoke(uspace_ptr_sysarg64_t uspace_taskid, perm_t perms)
    182182{
    183183        sysarg64_t taskid;

  • kernel/generic/src/synch/syswaitq.c

    r9259d20 r3e828ea  
    8888 * @return              Error code.
    8989 */
    90 sys_errno_t sys_waitq_create(cap_waitq_handle_t *whandle)
     90sys_errno_t sys_waitq_create(uspace_ptr_cap_waitq_handle_t whandle)
    9191{
    9292        waitq_t *wq = slab_alloc(waitq_cache, FRAME_ATOMIC);

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

    r9259d20 r3e828ea  
    5959 * @return EOK on success or an error code from @ref errno.h.
    6060 */
    61 errno_t copy_from_uspace(void *dst, const void *uspace_src, size_t size)
     61errno_t copy_from_uspace(void *dst, uspace_addr_t uspace_src, size_t size)
    6262{
    6363        ipl_t ipl;
    … …  
    6868
    6969        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    70                 if (overlaps((uintptr_t) uspace_src, size,
     70                if (overlaps(uspace_src, size,
    7171                    KERNEL_ADDRESS_SPACE_START,
    7272                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START)) {
    … …  
    8282         * Check whether the address is outside the address space hole.
    8383         */
    84         if (overlaps((uintptr_t) uspace_src, size, ADDRESS_SPACE_HOLE_START,
     84        if (overlaps(uspace_src, size, ADDRESS_SPACE_HOLE_START,
    8585            ADDRESS_SPACE_HOLE_END - ADDRESS_SPACE_HOLE_START))
    8686                return EPERM;
    … …  
    110110 * @return 0 on success or an error code from @ref errno.h.
    111111 */
    112 errno_t copy_to_uspace(void *uspace_dst, const void *src, size_t size)
     112errno_t copy_to_uspace(uspace_addr_t uspace_dst, const void *src, size_t size)
    113113{
    114114        ipl_t ipl;
    … …  
    119119
    120120        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    121                 if (overlaps((uintptr_t) uspace_dst, size,
     121                if (overlaps(uspace_dst, size,
    122122                    KERNEL_ADDRESS_SPACE_START,
    123123                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START)) {
    … …  
    133133         * Check whether the address is outside the address space hole.
    134134         */
    135         if (overlaps((uintptr_t) uspace_dst, size, ADDRESS_SPACE_HOLE_START,
     135        if (overlaps(uspace_dst, size, ADDRESS_SPACE_HOLE_START,
    136136            ADDRESS_SPACE_HOLE_END - ADDRESS_SPACE_HOLE_START))
    137137                return EPERM;

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

    r9259d20 r3e828ea  
    677677 *
    678678 */
    679 _NO_TRACE static sysinfo_return_t sysinfo_get_item_uspace(void *ptr, size_t size,
     679_NO_TRACE static sysinfo_return_t sysinfo_get_item_uspace(uspace_addr_t ptr, size_t size,
    680680    bool dry_run)
    681681{
    … …  
    786786 *
    787787 */
    788 _NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(void *ptr, size_t size,
     788_NO_TRACE static sysinfo_return_t sysinfo_get_keys_uspace(uspace_addr_t ptr, size_t size,
    789789    bool dry_run)
    790790{
    … …  
    831831 *
    832832 */
    833 sys_errno_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
    834     void *size_ptr)
     833sys_errno_t sys_sysinfo_get_keys_size(uspace_addr_t path_ptr, size_t path_size,
     834    uspace_addr_t size_ptr)
    835835{
    836836        errno_t rc;
    … …  
    879879 *
    880880 */
    881 sys_errno_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
    882     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
     881sys_errno_t sys_sysinfo_get_keys(uspace_addr_t path_ptr, size_t path_size,
     882    uspace_addr_t buffer_ptr, size_t buffer_size, uspace_ptr_size_t size_ptr)
    883883{
    884884        errno_t rc;
    … …  
    914914 *
    915915 */
    916 sysarg_t sys_sysinfo_get_val_type(void *path_ptr, size_t path_size)
     916sysarg_t sys_sysinfo_get_val_type(uspace_addr_t path_ptr, size_t path_size)
    917917{
    918918        /*
    … …  
    950950 *
    951951 */
    952 sys_errno_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
    953     void *value_ptr)
     952sys_errno_t sys_sysinfo_get_value(uspace_addr_t path_ptr, size_t path_size,
     953    uspace_addr_t value_ptr)
    954954{
    955955        errno_t rc;
    … …  
    986986 *
    987987 */
    988 sys_errno_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
    989     void *size_ptr)
     988sys_errno_t sys_sysinfo_get_data_size(uspace_addr_t path_ptr, size_t path_size,
     989    uspace_addr_t size_ptr)
    990990{
    991991        errno_t rc;
    … …  
    10361036 *
    10371037 */
    1038 sys_errno_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
    1039     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
     1038sys_errno_t sys_sysinfo_get_data(uspace_addr_t path_ptr, size_t path_size,
     1039    uspace_addr_t buffer_ptr, size_t buffer_size, uspace_ptr_size_t size_ptr)
    10401040{
    10411041        errno_t rc;

  • kernel/generic/src/udebug/udebug_ipc.c

    r9259d20 r3e828ea  
    5959        }
    6060
    61         return 0;
     61        return EOK;
    6262}
    6363
    … …  
    191191         */
    192192
    193         ipc_set_retval(&call->data, 0);
     193        ipc_set_retval(&call->data, EOK);
    194194        /*
    195195         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    … …  
    218218        size_t buf_size;
    219219        void *data;
     220        errno_t rc;
    220221
    221222        uspace_addr = ipc_get_arg2(&call->data);        /* Destination address */
    … …  
    225226         * Read task name.
    226227         */
    227         udebug_name_read((char **) &data, &data_size);
     228        rc = udebug_name_read((char **) &data, &data_size);
     229        if (rc != EOK) {
     230                ipc_set_retval(&call->data, rc);
     231                ipc_answer(&TASK->kb.box, call);
     232                return;
     233        }
    228234
    229235        /* Copy MAX(buf_size, data_size) bytes */
    … …  
    238244         */
    239245
    240         ipc_set_retval(&call->data, 0);
     246        ipc_set_retval(&call->data, EOK);
    241247        /*
    242248         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    … …  
    292298         */
    293299
    294         ipc_set_retval(&call->data, 0);
     300        ipc_set_retval(&call->data, EOK);
    295301        /*
    296302         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    … …  
    334340        uspace_addr = ipc_get_arg3(&call->data);
    335341
    336         ipc_set_retval(&call->data, 0);
     342        ipc_set_retval(&call->data, EOK);
    337343        /*
    338344         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    … …  
    377383        to_copy = sizeof(istate_t);
    378384
    379         ipc_set_retval(&call->data, 0);
     385        ipc_set_retval(&call->data, EOK);
    380386        /*
    381387         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
    … …  
    398404static void udebug_receive_mem_read(call_t *call)
    399405{
    400         sysarg_t uspace_dst;
    401         sysarg_t uspace_src;
     406        uspace_addr_t uspace_dst;
     407        uspace_addr_t uspace_src;
    402408        unsigned size;
    403409        void *buffer = NULL;
    … …  
    417423        assert(buffer != NULL);
    418424
    419         ipc_set_retval(&call->data, 0);
     425        ipc_set_retval(&call->data, EOK);
    420426        /*
    421427         * ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that

  • kernel/generic/src/udebug/udebug_ops.c

    r9259d20 r3e828ea  
    427427 * @param data_size Place to store size of the data.
    428428 *
    429  * @return EOK.
     429 * @return EOK on success, ENOMEM if memory allocation failed.
    430430 *
    431431 */
    … …  
    548548 *
    549549 */
    550 errno_t udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
     550errno_t udebug_mem_read(uspace_addr_t uspace_addr, size_t n, void **buffer)
    551551{
    552552        /* Verify task state */
    … …  
    569569         *
    570570         */
    571         errno_t rc = copy_from_uspace(data_buffer, (void *) uspace_addr, n);
     571        errno_t rc = copy_from_uspace(data_buffer, uspace_addr, n);
    572572        mutex_unlock(&TASK->udebug.lock);
    573573
Note: See TracChangeset for help on using the changeset viewer.