Changeset e28175d in mainline for kernel/generic/src


Ignore:
Timestamp:
2020-03-15T10:44:02Z (6 years ago)
Author:
GitHub <noreply@…>
Parents:
b401b33 (diff), 44dde42 (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:
heiducteam <tristanided@…> (2020-03-15 10:44:02)
git-committer:
GitHub <noreply@…> (2020-03-15 10:44:02)
Message:

Merge pull request #1 from HelenOS/master

sync

Location:
kernel/generic/src
Files:
31 edited

Legend:

Unmodified
Added
Removed

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

    rb401b33 re28175d  
    8383#include <mm/slab.h>
    8484#include <adt/list.h>
     85#include <synch/syswaitq.h>
     86#include <ipc/ipcrsc.h>
     87#include <ipc/ipc.h>
     88#include <ipc/irq.h>
    8589
    8690#include <limits.h>
    … …  
    8892#include <stdlib.h>
    8993
    90 #define CAPS_START      (CAP_NIL + 1)
    91 #define CAPS_SIZE       (INT_MAX - CAPS_START)
     94#define CAPS_START      ((intptr_t) CAP_NIL + 1)
     95#define CAPS_SIZE       (INT_MAX - (int) CAPS_START)
    9296#define CAPS_LAST       (CAPS_SIZE - 1)
    9397
    9498static slab_cache_t *cap_cache;
    9599static slab_cache_t *kobject_cache;
     100
     101kobject_ops_t *kobject_ops[KOBJECT_TYPE_MAX] = {
     102        [KOBJECT_TYPE_CALL] = &call_kobject_ops,
     103        [KOBJECT_TYPE_IRQ] = &irq_kobject_ops,
     104        [KOBJECT_TYPE_PHONE] = &phone_kobject_ops,
     105        [KOBJECT_TYPE_WAITQ] = &waitq_kobject_ops
     106};
    96107
    97108static size_t caps_hash(const ht_link_t *item)
    … …  
    412423 * @param type  Type of the kernel object.
    413424 * @param raw   Raw pointer to the encapsulated object.
    414  * @param ops   Pointer to kernel object operations for the respective type.
    415  */
    416 void kobject_initialize(kobject_t *kobj, kobject_type_t type, void *raw,
    417     kobject_ops_t *ops)
     425 */
     426void kobject_initialize(kobject_t *kobj, kobject_type_t type, void *raw)
    418427{
    419428        atomic_store(&kobj->refcnt, 1);
    … …  
    424433        kobj->type = type;
    425434        kobj->raw = raw;
    426         kobj->ops = ops;
    427435}
    428436
    … …  
    474482{
    475483        if (atomic_postdec(&kobj->refcnt) == 1) {
    476                 kobj->ops->destroy(kobj->raw);
     484                KOBJECT_OP(kobj)->destroy(kobj->raw);
    477485                kobject_free(kobj);
    478486        }

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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    248248 */
    249249sys_errno_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
    250     void *virt_ptr, uintptr_t bound)
     250    uspace_ptr_uintptr_t virt_ptr, uintptr_t bound)
    251251{
    252252        uintptr_t virt;
    … …  
    262262        rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
    263263        if (rc != EOK) {
    264                 physmem_unmap((uintptr_t) virt);
     264                physmem_unmap(virt);
    265265                return rc;
    266266        }
    … …  
    393393 *
    394394 */
    395 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)
    396396{
    397397        ddi_ioarg_t arg;
    … …  
    404404}
    405405
    406 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)
    407407{
    408408        ddi_ioarg_t arg;
    … …  
    465465
    466466sys_errno_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
    467     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)
    468468{
    469469        if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0) {
    … …  
    473473
    474474                uintptr_t phys;
    475                 errno_t rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
     475                errno_t rc = dmamem_map(virt_ptr, size, map_flags,
    476476                    flags, &phys);
    477477
    … …  
    481481                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
    482482                if (rc != EOK) {
    483                         dmamem_unmap((uintptr_t) virt_ptr, size);
     483                        dmamem_unmap(virt_ptr, size);
    484484                        return rc;
    485485                }
    … …  
    508508                rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
    509509                if (rc != EOK) {
    510                         dmamem_unmap_anonymous((uintptr_t) virt);
     510                        dmamem_unmap_anonymous(virt);
    511511                        return rc;
    512512                }
    … …  
    514514                rc = copy_to_uspace(virt_ptr, &virt, sizeof(virt));
    515515                if (rc != EOK) {
    516                         dmamem_unmap_anonymous((uintptr_t) virt);
     516                        dmamem_unmap_anonymous(virt);
    517517                        return rc;
    518518                }

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

    rb401b33 re28175d  
    100100}
    101101
    102 static kobject_ops_t call_kobject_ops = {
     102kobject_ops_t call_kobject_ops = {
    103103        .destroy = call_destroy
    104104};
    … …  
    127127
    128128        _ipc_call_init(call);
    129         kobject_initialize(kobj, KOBJECT_TYPE_CALL, call, &call_kobject_ops);
     129        kobject_initialize(kobj, KOBJECT_TYPE_CALL, call);
    130130        call->kobject = kobj;
    131131

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

    rb401b33 re28175d  
    5252}
    5353
    54 static kobject_ops_t phone_kobject_ops = {
     54kobject_ops_t phone_kobject_ops = {
    5555        .destroy = phone_destroy
    5656};
    … …  
    9494                phone->hangup_call = hcall;
    9595
    96                 kobject_initialize(kobj, KOBJECT_TYPE_PHONE, phone,
    97                     &phone_kobject_ops);
     96                kobject_initialize(kobj, KOBJECT_TYPE_PHONE, phone);
    9897                phone->kobject = kobj;
    9998

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

    rb401b33 re28175d  
    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)
    … …  
    306306}
    307307
    308 static kobject_ops_t irq_kobject_ops = {
     308kobject_ops_t irq_kobject_ops = {
    309309        .destroy = irq_destroy
    310310};
    … …  
    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))
    … …  
    385385        irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
    386386
    387         kobject_initialize(kobject, KOBJECT_TYPE_IRQ, irq, &irq_kobject_ops);
     387        kobject_initialize(kobject, KOBJECT_TYPE_IRQ, irq);
    388388        cap_publish(TASK, handle, kobject);
    389389

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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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/str_error.c

    rb401b33 re28175d  
    5353
    5454#undef __errno_entry
    55 #define __errno_entry(name, num, desc) "[" #name "]" desc,
     55#define __errno_entry(name, num, desc) "[" #name "] " desc,
    5656
    5757static const char *err_desc[] = {

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

    rb401b33 re28175d  
    245245}
    246246
    247 static inline intmax_t _strtosigned(const char *nptr, char **endptr, int base,
    248     intmax_t min, intmax_t max, errno_t *err, bool nonstd)
    249 {
    250         bool sgn = false;
    251         uintmax_t number = _strtoumax(nptr, endptr, base, &sgn, err, nonstd);
    252 
    253         if (number > (uintmax_t) max) {
    254                 if (sgn && (number - 1 == (uintmax_t) max)) {
    255                         return min;
    256                 }
    257 
    258                 *err = nonstd ? EOVERFLOW : ERANGE;
    259                 return (sgn ? min : max);
    260         }
    261 
    262         return (sgn ? -number : number);
    263 }
    264 
    265247static inline uintmax_t _strtounsigned(const char *nptr, char **endptr, int base,
    266248    uintmax_t max, errno_t *err, bool nonstd)

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

    rb401b33 re28175d  
    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/uinit.c

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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/malloc.c

    rb401b33 re28175d  
    187187void *malloc(size_t size)
    188188{
     189        if (size + _offset < size)
     190                return NULL;
     191
    189192        void *obj = mem_alloc(alignof(max_align_t), size + _offset) + _offset;
    190193

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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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 *)
    … …  
    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        /*
    … …  
    187187                log(LF_OTHER, LVL_ERROR, "Cannot spawn loader (%s)",
    188188                    str_error(prg->loader_status));
    189                 return ENOENT;
     189                return prg->loader_status;
    190190        }
    191191
    … …  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    5454}
    5555
    56 static kobject_ops_t waitq_kobject_ops = {
     56kobject_ops_t waitq_kobject_ops = {
    5757        .destroy = waitq_destroy
    5858};
    … …  
    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);
    … …  
    100100                return (sys_errno_t) ENOMEM;
    101101        }
    102         kobject_initialize(kobj, KOBJECT_TYPE_WAITQ, wq, &waitq_kobject_ops);
     102        kobject_initialize(kobj, KOBJECT_TYPE_WAITQ, wq);
    103103
    104104        cap_handle_t handle;

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

    rb401b33 re28175d  
    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/syscall/syscall.c

    rb401b33 re28175d  
    5656#include <log.h>
    5757
    58 /** Dispatch system call */
    59 sysarg_t syscall_handler(sysarg_t a1, sysarg_t a2, sysarg_t a3,
    60     sysarg_t a4, sysarg_t a5, sysarg_t a6, sysarg_t id)
    61 {
    62         /* Do userpace accounting */
    63         irq_spinlock_lock(&THREAD->lock, true);
    64         thread_update_accounting(true);
    65         irq_spinlock_unlock(&THREAD->lock, true);
    66 
    67 #ifdef CONFIG_UDEBUG
    68         /*
    69          * An istate_t-compatible record was created on the stack by the
    70          * low-level syscall handler. This is the userspace space state
    71          * structure.
    72          */
    73         THREAD->udebug.uspace_state = istate_get(THREAD);
    74 
    75         /*
    76          * Early check for undebugged tasks. We do not lock anything as this
    77          * test need not be precise in either direction.
    78          */
    79         if (THREAD->udebug.active)
    80                 udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
    81 #endif
    82 
    83         sysarg_t rc;
    84         if (id < SYSCALL_END) {
    85                 rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
    86         } else {
    87                 log(LF_OTHER, LVL_ERROR,
    88                     "Task %" PRIu64 ": Unknown syscall %#" PRIxn, TASK->taskid, id);
    89                 task_kill_self(true);
    90         }
    91 
    92         if (THREAD->interrupted)
    93                 thread_exit();
    94 
    95 #ifdef CONFIG_UDEBUG
    96         if (THREAD->udebug.active) {
    97                 udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, rc, true);
    98 
    99                 /*
    100                  * Stopping point needed for tasks that only invoke
    101                  * non-blocking system calls. Not needed if the task
    102                  * is not being debugged (it cannot block here).
    103                  */
    104                 udebug_stoppable_begin();
    105                 udebug_stoppable_end();
    106         }
    107 
    108         /* Clear userspace state pointer */
    109         THREAD->udebug.uspace_state = NULL;
    110 #endif
    111 
    112         /* Do kernel accounting */
    113         irq_spinlock_lock(&THREAD->lock, true);
    114         thread_update_accounting(false);
    115         irq_spinlock_unlock(&THREAD->lock, true);
    116 
    117         return rc;
    118 }
    119 
    120 syshandler_t syscall_table[SYSCALL_END] = {
     58static syshandler_t syscall_table[] = {
    12159        /* System management syscalls. */
    12260        [SYS_KIO] = (syshandler_t) sys_kio,
    … …  
    198136};
    199137
     138/** Dispatch system call */
     139sysarg_t syscall_handler(sysarg_t a1, sysarg_t a2, sysarg_t a3,
     140    sysarg_t a4, sysarg_t a5, sysarg_t a6, sysarg_t id)
     141{
     142        /* Do userpace accounting */
     143        irq_spinlock_lock(&THREAD->lock, true);
     144        thread_update_accounting(true);
     145        irq_spinlock_unlock(&THREAD->lock, true);
     146
     147#ifdef CONFIG_UDEBUG
     148        /*
     149         * An istate_t-compatible record was created on the stack by the
     150         * low-level syscall handler. This is the userspace space state
     151         * structure.
     152         */
     153        THREAD->udebug.uspace_state = istate_get(THREAD);
     154
     155        /*
     156         * Early check for undebugged tasks. We do not lock anything as this
     157         * test need not be precise in either direction.
     158         */
     159        if (THREAD->udebug.active)
     160                udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
     161#endif
     162
     163        sysarg_t rc;
     164        if (id < sizeof_array(syscall_table)) {
     165                rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
     166        } else {
     167                log(LF_OTHER, LVL_ERROR,
     168                    "Task %" PRIu64 ": Unknown syscall %#" PRIxn, TASK->taskid, id);
     169                task_kill_self(true);
     170        }
     171
     172        if (THREAD->interrupted)
     173                thread_exit();
     174
     175#ifdef CONFIG_UDEBUG
     176        if (THREAD->udebug.active) {
     177                udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, rc, true);
     178
     179                /*
     180                 * Stopping point needed for tasks that only invoke
     181                 * non-blocking system calls. Not needed if the task
     182                 * is not being debugged (it cannot block here).
     183                 */
     184                udebug_stoppable_begin();
     185                udebug_stoppable_end();
     186        }
     187
     188        /* Clear userspace state pointer */
     189        THREAD->udebug.uspace_state = NULL;
     190#endif
     191
     192        /* Do kernel accounting */
     193        irq_spinlock_lock(&THREAD->lock, true);
     194        thread_update_accounting(false);
     195        irq_spinlock_unlock(&THREAD->lock, true);
     196
     197        return rc;
     198}
     199
    200200/** @}
    201201 */

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

    rb401b33 re28175d  
    6969#define LOAD_INTERVAL  5
    7070
     71/** IPC connections statistics state */
     72typedef struct {
     73        bool counting;
     74        size_t count;
     75        size_t i;
     76        stats_ipcc_t *data;
     77} ipccs_state_t;
     78
    7179/** Fixed-point representation of
    7280 *
    … …  
    371379
    372380        return ((void *) stats_threads);
     381}
     382
     383/** Produce IPC connection statistics
     384 *
     385 * Summarize IPC connection information into IPC connection statistics.
     386 *
     387 * @param cap Phone capability.
     388 * @param arg State variable.
     389 *
     390 */
     391static bool produce_stats_ipcc_cb(cap_t *cap, void *arg)
     392{
     393        phone_t *phone = cap->kobject->phone;
     394        ipccs_state_t *state = (ipccs_state_t *) arg;
     395
     396        if (state->counting) {
     397                /*
     398                 * Simply update the number of entries
     399                 * in case we are in the counting mode.
     400                 */
     401
     402                state->count++;
     403                return true;
     404        }
     405
     406        /* We are in the gathering mode */
     407
     408        if ((state->data == NULL) || (state->i >= state->count)) {
     409                /*
     410                 * Do nothing if we have no buffer
     411                 * to store the data to (meaning we are
     412                 * in a dry run) or the buffer is already
     413                 * full.
     414                 */
     415
     416                return true;
     417        }
     418
     419        mutex_lock(&phone->lock);
     420
     421        if (phone->state == IPC_PHONE_CONNECTED) {
     422                state->data[state->i].caller = phone->caller->taskid;
     423                state->data[state->i].callee = phone->callee->task->taskid;
     424                state->i++;
     425        }
     426
     427        mutex_unlock(&phone->lock);
     428
     429        return true;
     430}
     431
     432/** Get IPC connections statistics
     433 *
     434 * @param item    Sysinfo item (unused).
     435 * @param size    Size of the returned data.
     436 * @param dry_run Do not get the data, just calculate the size.
     437 * @param data    Unused.
     438 *
     439 * @return Data containing several stats_ipccs_t structures.
     440 *         If the return value is not NULL, it should be freed
     441 *         in the context of the sysinfo request.
     442 *
     443 */
     444static void *get_stats_ipccs(struct sysinfo_item *item, size_t *size,
     445    bool dry_run, void *data)
     446{
     447        /* Messing with tasks structures, avoid deadlock */
     448        irq_spinlock_lock(&tasks_lock, true);
     449
     450        ipccs_state_t state = {
     451                .counting = true,
     452                .count = 0,
     453                .i = 0,
     454                .data = NULL
     455        };
     456
     457        /* Compute the number of IPC connections */
     458        task_t *task = task_first();
     459        while (task != NULL) {
     460                task_hold(task);
     461                irq_spinlock_unlock(&tasks_lock, true);
     462
     463                caps_apply_to_kobject_type(task, KOBJECT_TYPE_PHONE,
     464                    produce_stats_ipcc_cb, &state);
     465
     466                irq_spinlock_lock(&tasks_lock, true);
     467
     468                task = task_next(task);
     469        }
     470
     471        state.counting = false;
     472        *size = sizeof(stats_ipcc_t) * state.count;
     473
     474        if (!dry_run)
     475                state.data = (stats_ipcc_t *) malloc(*size);
     476
     477        /* Gather the statistics for each task */
     478        task = task_first();
     479        while (task != NULL) {
     480                /* We already hold a reference to the task */
     481                irq_spinlock_unlock(&tasks_lock, true);
     482
     483                caps_apply_to_kobject_type(task, KOBJECT_TYPE_PHONE,
     484                    produce_stats_ipcc_cb, &state);
     485
     486                irq_spinlock_lock(&tasks_lock, true);
     487
     488                task_t *prev_task = task;
     489                task = task_next(prev_task);
     490                task_release(prev_task);
     491        }
     492
     493        irq_spinlock_unlock(&tasks_lock, true);
     494
     495        return ((void *) state.data);
    373496}
    374497
    … …  
    754877        sysinfo_set_item_gen_data("system.tasks", NULL, get_stats_tasks, NULL);
    755878        sysinfo_set_item_gen_data("system.threads", NULL, get_stats_threads, NULL);
     879        sysinfo_set_item_gen_data("system.ipccs", NULL, get_stats_ipccs, NULL);
    756880        sysinfo_set_item_gen_data("system.exceptions", NULL, get_stats_exceptions, NULL);
    757881        sysinfo_set_subtree_fn("system.tasks", NULL, get_stats_task, NULL);

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

    rb401b33 re28175d  
    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.c

    rb401b33 re28175d  
    479479        mutex_unlock(&THREAD->udebug.lock);
    480480
    481         /* Make sure the debugging session is over before proceeding. */
    482         mutex_lock(&THREAD->udebug.lock);
    483         while (THREAD->udebug.active)
    484                 condvar_wait(&THREAD->udebug.active_cv, &THREAD->udebug.lock);
    485         mutex_unlock(&THREAD->udebug.lock);
    486 
     481        /*
     482         * This is where we will typically block until a post-mortem debugger
     483         * terminates the debugging session.
     484         */
    487485        udebug_stoppable_end();
    488486}

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

    rb401b33 re28175d  
    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

    rb401b33 re28175d  
    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.