Changeset 96b02eb9 in mainline for kernel/generic/src


Ignore:
Timestamp:
2010-12-14T12:52:38Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6b10dab
Parents:
554debd
Message:

more unification of basic types

  • use sysarg_t and native_t (unsigned and signed variant) in both kernel and uspace
  • remove ipcarg_t in favour of sysarg_t

(no change in functionality)

Location:
kernel/generic/src
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/adt/hash_table.c

    r554debd r96b02eb9  
    8282 * @param item Item to be inserted into the hash table.
    8383 */
    84 void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)
     84void hash_table_insert(hash_table_t *h, sysarg_t key[], link_t *item)
    8585{
    8686        size_t chain;
     
    105105 * @return Matching item on success, NULL if there is no such item.
    106106 */
    107 link_t *hash_table_find(hash_table_t *h, unative_t key[])
     107link_t *hash_table_find(hash_table_t *h, sysarg_t key[])
    108108{
    109109        link_t *cur;
     
    138138 * @param keys Number of keys in the key array.
    139139 */
    140 void hash_table_remove(hash_table_t *h, unative_t key[], size_t keys)
     140void hash_table_remove(hash_table_t *h, sysarg_t key[], size_t keys)
    141141{
    142142        size_t chain;
  • kernel/generic/src/console/cmd.c

    r554debd r96b02eb9  
    601601       
    602602        /* This doesn't have to be very accurate */
    603         unative_t sec = uptime->seconds1;
     603        sysarg_t sec = uptime->seconds1;
    604604       
    605605        printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
     
    656656        uintptr_t symaddr;
    657657        char *symbol;
    658         unative_t (*fnc)(void);
     658        sysarg_t (*fnc)(void);
    659659        fncptr_t fptr;
    660660        int rc;
     
    672672
    673673                ipl = interrupts_disable();
    674                 fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
     674                fnc = (sysarg_t (*)(void)) arch_construct_function(&fptr,
    675675                    (void *) symaddr, (void *) cmd_call0);
    676676                printf("Calling %s() (%p)\n", symbol, (void *) symaddr);
     
    720720        uintptr_t symaddr;
    721721        char *symbol;
    722         unative_t (*fnc)(unative_t, ...);
    723         unative_t arg1 = argv[1].intval;
     722        sysarg_t (*fnc)(sysarg_t, ...);
     723        sysarg_t arg1 = argv[1].intval;
    724724        fncptr_t fptr;
    725725        int rc;
     
    737737
    738738                ipl = interrupts_disable();
    739                 fnc = (unative_t (*)(unative_t, ...))
     739                fnc = (sysarg_t (*)(sysarg_t, ...))
    740740                    arch_construct_function(&fptr, (void *) symaddr,
    741741                    (void *) cmd_call1);
     
    756756        uintptr_t symaddr;
    757757        char *symbol;
    758         unative_t (*fnc)(unative_t, unative_t, ...);
    759         unative_t arg1 = argv[1].intval;
    760         unative_t arg2 = argv[2].intval;
     758        sysarg_t (*fnc)(sysarg_t, sysarg_t, ...);
     759        sysarg_t arg1 = argv[1].intval;
     760        sysarg_t arg2 = argv[2].intval;
    761761        fncptr_t fptr;
    762762        int rc;
     
    774774
    775775                ipl = interrupts_disable();
    776                 fnc = (unative_t (*)(unative_t, unative_t, ...))
     776                fnc = (sysarg_t (*)(sysarg_t, sysarg_t, ...))
    777777                    arch_construct_function(&fptr, (void *) symaddr,
    778778                    (void *) cmd_call2);
     
    792792        uintptr_t symaddr;
    793793        char *symbol;
    794         unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
    795         unative_t arg1 = argv[1].intval;
    796         unative_t arg2 = argv[2].intval;
    797         unative_t arg3 = argv[3].intval;
     794        sysarg_t (*fnc)(sysarg_t, sysarg_t, sysarg_t, ...);
     795        sysarg_t arg1 = argv[1].intval;
     796        sysarg_t arg2 = argv[2].intval;
     797        sysarg_t arg3 = argv[3].intval;
    798798        fncptr_t fptr;
    799799        int rc;
     
    811811
    812812                ipl = interrupts_disable();
    813                 fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...))
     813                fnc = (sysarg_t (*)(sysarg_t, sysarg_t, sysarg_t, ...))
    814814                    arch_construct_function(&fptr, (void *) symaddr,
    815815                    (void *) cmd_call3);
  • kernel/generic/src/console/console.c

    r554debd r96b02eb9  
    162162        ddi_parea_register(&klog_parea);
    163163       
    164         sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
     164        sysinfo_set_item_val("klog.faddr", NULL, (sysarg_t) faddr);
    165165        sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
    166166       
     
    193193
    194194/** Tell kernel to get keyboard/console access again */
    195 unative_t sys_debug_enable_console(void)
     195sysarg_t sys_debug_enable_console(void)
    196196{
    197197#ifdef CONFIG_KCONSOLE
     
    204204
    205205/** Tell kernel to relinquish keyboard/console access */
    206 unative_t sys_debug_disable_console(void)
     206sysarg_t sys_debug_disable_console(void)
    207207{
    208208        release_console();
     
    333333 *
    334334 */
    335 unative_t sys_klog(int fd, const void *buf, size_t size)
     335sysarg_t sys_klog(int fd, const void *buf, size_t size)
    336336{
    337337        char *data;
     
    339339       
    340340        if (size > PAGE_SIZE)
    341                 return (unative_t) ELIMIT;
     341                return (sysarg_t) ELIMIT;
    342342       
    343343        if (size > 0) {
    344344                data = (char *) malloc(size + 1, 0);
    345345                if (!data)
    346                         return (unative_t) ENOMEM;
     346                        return (sysarg_t) ENOMEM;
    347347               
    348348                rc = copy_from_uspace(data, buf, size);
    349349                if (rc) {
    350350                        free(data);
    351                         return (unative_t) rc;
     351                        return (sysarg_t) rc;
    352352                }
    353353                data[size] = 0;
  • kernel/generic/src/console/kconsole.c

    r554debd r96b02eb9  
    426426
    427427NO_TRACE static bool parse_int_arg(const char *text, size_t len,
    428     unative_t *result)
     428    sysarg_t *result)
    429429{
    430430        bool isaddr = false;
     
    461461                case EOK:
    462462                        if (isaddr)
    463                                 *result = (unative_t) symaddr;
     463                                *result = (sysarg_t) symaddr;
    464464                        else if (isptr)
    465                                 *result = **((unative_t **) symaddr);
     465                                *result = **((sysarg_t **) symaddr);
    466466                        else
    467                                 *result = *((unative_t *) symaddr);
     467                                *result = *((sysarg_t *) symaddr);
    468468                        break;
    469469                default:
     
    483483                        return false;
    484484                case EOK:
    485                         *result = (unative_t) value;
     485                        *result = (sysarg_t) value;
    486486                        if (isptr)
    487                                 *result = *((unative_t *) *result);
     487                                *result = *((sysarg_t *) *result);
    488488                        break;
    489489                default:
     
    629629                                            cmdline + start + 1,
    630630                                            (end - start) - 1);
    631                                         cmd->argv[i].intval = (unative_t) buf;
     631                                        cmd->argv[i].intval = (sysarg_t) buf;
    632632                                        cmd->argv[i].vartype = ARG_TYPE_STRING;
    633633                                } else {
  • kernel/generic/src/ddi/ddi.c

    r554debd r96b02eb9  
    232232 *
    233233 */
    234 unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base,
    235     unative_t pages, unative_t flags)
    236 {
    237         return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
     234sysarg_t sys_physmem_map(sysarg_t phys_base, sysarg_t virt_base,
     235    sysarg_t pages, sysarg_t flags)
     236{
     237        return (sysarg_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
    238238            FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
    239239            (size_t) pages, (int) flags);
     
    247247 *
    248248 */
    249 unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
     249sysarg_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
    250250{
    251251        ddi_ioarg_t arg;
    252252        int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
    253253        if (rc != 0)
    254                 return (unative_t) rc;
    255        
    256         return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id,
     254                return (sysarg_t) rc;
     255       
     256        return (sysarg_t) ddi_iospace_enable((task_id_t) arg.task_id,
    257257            (uintptr_t) arg.ioaddr, (size_t) arg.size);
    258258}
     
    265265 * @retutn Zero on success, error code otherwise.
    266266 */
    267 unative_t sys_interrupt_enable(int irq, int enable)
     267sysarg_t sys_interrupt_enable(int irq, int enable)
    268268{
    269269/* FIXME: this needs to be generic code, or better not be in kernel at all. */
  • kernel/generic/src/ddi/device.c

    r554debd r96b02eb9  
    5454}
    5555
    56 unative_t sys_device_assign_devno(void)
     56sysarg_t sys_device_assign_devno(void)
    5757{
    58         return (unative_t) device_assign_devno();
     58        return (sysarg_t) device_assign_devno();
    5959}
    6060
  • kernel/generic/src/ddi/irq.c

    r554debd r96b02eb9  
    106106 *
    107107 */
    108 static size_t irq_ht_hash(unative_t *key);
    109 static bool irq_ht_compare(unative_t *key, size_t keys, link_t *item);
     108static size_t irq_ht_hash(sysarg_t *key);
     109static bool irq_ht_compare(sysarg_t *key, size_t keys, link_t *item);
    110110static void irq_ht_remove(link_t *item);
    111111
     
    123123 *
    124124 */
    125 static size_t irq_lin_hash(unative_t *key);
    126 static bool irq_lin_compare(unative_t *key, size_t keys, link_t *item);
     125static size_t irq_lin_hash(sysarg_t *key);
     126static bool irq_lin_compare(sysarg_t *key, size_t keys, link_t *item);
    127127static void irq_lin_remove(link_t *item);
    128128
     
    194194void irq_register(irq_t *irq)
    195195{
    196         unative_t key[] = {
    197                 (unative_t) irq->inr,
    198                 (unative_t) irq->devno
     196        sysarg_t key[] = {
     197                (sysarg_t) irq->inr,
     198                (sysarg_t) irq->devno
    199199        };
    200200       
     
    212212{
    213213        link_t *lnk;
    214         unative_t key[] = {
    215                 (unative_t) inr,
    216                 (unative_t) -1    /* Search will use claim() instead of devno */
     214        sysarg_t key[] = {
     215                (sysarg_t) inr,
     216                (sysarg_t) -1    /* Search will use claim() instead of devno */
    217217        };
    218218       
     
    235235{
    236236        link_t *lnk;
    237         unative_t key[] = {
    238                 (unative_t) inr,
    239                 (unative_t) -1    /* Search will use claim() instead of devno */
     237        sysarg_t key[] = {
     238                (sysarg_t) inr,
     239                (sysarg_t) -1    /* Search will use claim() instead of devno */
    240240        };
    241241       
     
    306306 *
    307307 */
    308 size_t irq_ht_hash(unative_t key[])
     308size_t irq_ht_hash(sysarg_t key[])
    309309{
    310310        inr_t inr = (inr_t) key[KEY_INR];
     
    333333 *
    334334 */
    335 bool irq_ht_compare(unative_t key[], size_t keys, link_t *item)
     335bool irq_ht_compare(sysarg_t key[], size_t keys, link_t *item)
    336336{
    337337        irq_t *irq = hash_table_get_instance(item, irq_t, link);
     
    381381 *
    382382 */
    383 size_t irq_lin_hash(unative_t key[])
     383size_t irq_lin_hash(sysarg_t key[])
    384384{
    385385        inr_t inr = (inr_t) key[KEY_INR];
     
    408408 *
    409409 */
    410 bool irq_lin_compare(unative_t key[], size_t keys, link_t *item)
     410bool irq_lin_compare(sysarg_t key[], size_t keys, link_t *item)
    411411{
    412412        irq_t *irq = list_get_instance(item, irq_t, link);
  • kernel/generic/src/interrupt/interrupt.c

    r554debd r96b02eb9  
    197197                /* Notify the subscriber that a fault occurred. */
    198198                event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid),
    199                     UPPER32(TASK->taskid), (unative_t) THREAD);
     199                    UPPER32(TASK->taskid), (sysarg_t) THREAD);
    200200               
    201201#ifdef CONFIG_UDEBUG
     
    263263               
    264264                const char *symbol =
    265                     symtab_fmt_name_lookup((unative_t) exc_table[i].handler);
     265                    symtab_fmt_name_lookup((sysarg_t) exc_table[i].handler);
    266266               
    267267#ifdef __32_BITS__
  • kernel/generic/src/ipc/event.c

    r554debd r96b02eb9  
    6161}
    6262
    63 static int event_subscribe(event_type_t evno, unative_t method,
     63static int event_subscribe(event_type_t evno, sysarg_t method,
    6464    answerbox_t *answerbox)
    6565{
     
    8484}
    8585
    86 unative_t sys_event_subscribe(unative_t evno, unative_t method)
     86sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t method)
    8787{
    88         return (unative_t) event_subscribe((event_type_t) evno, (unative_t)
     88        return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t)
    8989            method, &TASK->answerbox);
    9090}
     
    119119}
    120120
    121 void event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,
    122     unative_t a4, unative_t a5)
     121void event_notify(event_type_t evno, sysarg_t a1, sysarg_t a2, sysarg_t a3,
     122    sysarg_t a4, sysarg_t a5)
    123123{
    124124        ASSERT(evno < EVENT_END);
  • kernel/generic/src/ipc/ipc.c

    r554debd r96b02eb9  
    270270 *
    271271 */
    272 void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)
     272void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err)
    273273{
    274274        call->data.phone = phone;
  • kernel/generic/src/ipc/ipcrsc.c

    r554debd r96b02eb9  
    144144 *
    145145 */
    146 call_t *get_call(unative_t callid)
     146call_t *get_call(sysarg_t callid)
    147147{
    148148        link_t *lst;
     
    153153            lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
    154154                call_t *call = list_get_instance(lst, call_t, link);
    155                 if ((unative_t) call == callid) {
     155                if ((sysarg_t) call == callid) {
    156156                        result = call;
    157157                        break;
  • kernel/generic/src/ipc/irq.c

    r554debd r96b02eb9  
    140140 */
    141141int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
    142     unative_t method, irq_code_t *ucode)
    143 {
    144         unative_t key[] = {
    145                 (unative_t) inr,
    146                 (unative_t) devno
     142    sysarg_t method, irq_code_t *ucode)
     143{
     144        sysarg_t key[] = {
     145                (sysarg_t) inr,
     146                (sysarg_t) devno
    147147        };
    148148       
     
    213213int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
    214214{
    215         unative_t key[] = {
    216                 (unative_t) inr,
    217                 (unative_t) devno
     215        sysarg_t key[] = {
     216                (sysarg_t) inr,
     217                (sysarg_t) devno
    218218        };
    219219       
     
    290290                }
    291291               
    292                 unative_t key[2];
     292                sysarg_t key[2];
    293293                key[0] = irq->inr;
    294294                key[1] = irq->devno;
     
    465465 *
    466466 */
    467 void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3,
    468     unative_t a4, unative_t a5)
     467void ipc_irq_send_msg(irq_t *irq, sysarg_t a1, sysarg_t a2, sysarg_t a3,
     468    sysarg_t a4, sysarg_t a5)
    469469{
    470470        irq_spinlock_lock(&irq->lock, true);
  • kernel/generic/src/ipc/sysipc.c

    r554debd r96b02eb9  
    6868 *
    6969 */
    70 static int phone_get(unative_t phoneid, phone_t **phone)
     70static int phone_get(sysarg_t phoneid, phone_t **phone)
    7171{
    7272        if (phoneid >= IPC_MAX_PHONES)
     
    8484 *
    8585 */
    86 static inline bool method_is_system(unative_t method)
     86static inline bool method_is_system(sysarg_t method)
    8787{
    8888        if (method <= IPC_M_LAST_SYSTEM)
     
    102102 *
    103103 */
    104 static inline bool method_is_forwardable(unative_t method)
     104static inline bool method_is_forwardable(sysarg_t method)
    105105{
    106106        switch (method) {
     
    124124 *
    125125 */
    126 static inline bool method_is_immutable(unative_t method)
     126static inline bool method_is_immutable(sysarg_t method)
    127127{
    128128        switch (method) {
     
    248248                        /* Set 'phone hash' as arg5 of response */
    249249                        IPC_SET_ARG5(answer->data,
    250                             (unative_t) &TASK->phones[phoneid]);
     250                            (sysarg_t) &TASK->phones[phoneid]);
    251251                }
    252252        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
     
    399399        }
    400400        case IPC_M_CONNECT_ME:
    401                 IPC_SET_ARG5(call->data, (unative_t) phone);
     401                IPC_SET_ARG5(call->data, (sysarg_t) phone);
    402402                break;
    403403        case IPC_M_CONNECT_ME_TO: {
     
    407407               
    408408                /* Set arg5 for server */
    409                 IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
     409                IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]);
    410410                call->flags |= IPC_CALL_CONN_ME_TO;
    411411                call->priv = newphid;
     
    541541 *
    542542 */
    543 unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
    544     unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
     543sysarg_t sys_ipc_call_sync_fast(sysarg_t phoneid, sysarg_t method,
     544    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, ipc_data_t *data)
    545545{
    546546        phone_t *phone;
     
    601601 *
    602602 */
    603 unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
     603sysarg_t sys_ipc_call_sync_slow(sysarg_t phoneid, ipc_data_t *question,
    604604    ipc_data_t *reply)
    605605{
     
    613613        if (rc != 0) {
    614614                ipc_call_free(call);
    615                 return (unative_t) rc;
     615                return (sysarg_t) rc;
    616616        }
    617617       
     
    677677 *
    678678 */
    679 unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
    680     unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
     679sysarg_t sys_ipc_call_async_fast(sysarg_t phoneid, sysarg_t method,
     680    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    681681{
    682682        phone_t *phone;
     
    707707                ipc_backsend_err(phone, call, res);
    708708       
    709         return (unative_t) call;
     709        return (sysarg_t) call;
    710710}
    711711
     
    718718 *
    719719 */
    720 unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
     720sysarg_t sys_ipc_call_async_slow(sysarg_t phoneid, ipc_data_t *data)
    721721{
    722722        phone_t *phone;
     
    732732        if (rc != 0) {
    733733                ipc_call_free(call);
    734                 return (unative_t) rc;
     734                return (sysarg_t) rc;
    735735        }
    736736       
     
    742742                ipc_backsend_err(phone, call, res);
    743743       
    744         return (unative_t) call;
     744        return (sysarg_t) call;
    745745}
    746746
     
    767767 *
    768768 */
    769 static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
    770     unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
    771     unative_t arg4, unative_t arg5, unsigned int mode, bool slow)
     769static sysarg_t sys_ipc_forward_common(sysarg_t callid, sysarg_t phoneid,
     770    sysarg_t method, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
     771    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
    772772{
    773773        call_t *call = get_call(callid);
     
    846846 *
    847847 */
    848 unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
    849     unative_t method, unative_t arg1, unative_t arg2, unsigned int mode)
     848sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid,
     849    sysarg_t method, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    850850{
    851851        return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
     
    870870 *
    871871 */
    872 unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
     872sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid,
    873873    ipc_data_t *data, unsigned int mode)
    874874{
     
    877877            sizeof(newdata.args));
    878878        if (rc != 0)
    879                 return (unative_t) rc;
     879                return (sysarg_t) rc;
    880880       
    881881        return sys_ipc_forward_common(callid, phoneid,
     
    900900 *
    901901 */
    902 unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
    903     unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
     902sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval,
     903    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    904904{
    905905        /* Do not answer notification callids */
     
    945945 *
    946946 */
    947 unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
     947sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data)
    948948{
    949949        /* Do not answer notification callids */
     
    982982 *
    983983 */
    984 unative_t sys_ipc_hangup(unative_t phoneid)
     984sysarg_t sys_ipc_hangup(sysarg_t phoneid)
    985985{
    986986        phone_t *phone;
     
    10081008 *
    10091009 */
    1010 unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     1010sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
    10111011    unsigned int flags)
    10121012{
     
    10371037                ipc_call_free(call);
    10381038               
    1039                 return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
     1039                return ((sysarg_t) call) | IPC_CALLID_NOTIFICATION;
    10401040        }
    10411041       
     
    10511051                ipc_call_free(call);
    10521052               
    1053                 return ((unative_t) call) | IPC_CALLID_ANSWERED;
     1053                return ((sysarg_t) call) | IPC_CALLID_ANSWERED;
    10541054        }
    10551055       
     
    10791079        }
    10801080       
    1081         return (unative_t) call;
     1081        return (sysarg_t) call;
    10821082}
    10831083
     
    10851085 *
    10861086 */
    1087 unative_t sys_ipc_poke(void)
     1087sysarg_t sys_ipc_poke(void)
    10881088{
    10891089        waitq_unsleep(&TASK->answerbox.wq);
     
    11011101 *
    11021102 */
    1103 unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
     1103sysarg_t sys_ipc_register_irq(inr_t inr, devno_t devno, sysarg_t method,
    11041104    irq_code_t *ucode)
    11051105{
     
    11181118 *
    11191119 */
    1120 unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
     1120sysarg_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
    11211121{
    11221122        if (!(cap_get(TASK) & CAP_IRQ_REG))
     
    11351135 *
    11361136 */
    1137 unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
     1137sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
    11381138{
    11391139#ifdef CONFIG_UDEBUG
     
    11411141        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
    11421142        if (rc != 0)
    1143                 return (unative_t) rc;
     1143                return (sysarg_t) rc;
    11441144       
    11451145        LOG("sys_ipc_connect_kbox(%" PRIu64 ")", taskid_arg.value);
     
    11471147        return ipc_connect_kbox(taskid_arg.value);
    11481148#else
    1149         return (unative_t) ENOTSUP;
     1149        return (sysarg_t) ENOTSUP;
    11501150#endif
    11511151}
  • kernel/generic/src/lib/memstr.c

    r554debd r96b02eb9  
    6262        unsigned int i, j;
    6363       
    64         if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
    65             ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
     64        if (ALIGN_UP((uintptr_t) src, sizeof(sysarg_t)) != (uintptr_t) src ||
     65            ALIGN_UP((uintptr_t) dst, sizeof(sysarg_t)) != (uintptr_t) dst) {
    6666                for (i = 0; i < cnt; i++)
    6767                        ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
    6868        } else {
    69                 for (i = 0; i < cnt / sizeof(unative_t); i++)
    70                         ((unative_t *) dst)[i] = ((unative_t *) src)[i];
     69                for (i = 0; i < cnt / sizeof(sysarg_t); i++)
     70                        ((sysarg_t *) dst)[i] = ((sysarg_t *) src)[i];
    7171               
    72                 for (j = 0; j < cnt % sizeof(unative_t); j++)
    73                         ((uint8_t *)(((unative_t *) dst) + i))[j] =
    74                             ((uint8_t *)(((unative_t *) src) + i))[j];
     72                for (j = 0; j < cnt % sizeof(sysarg_t); j++)
     73                        ((uint8_t *)(((sysarg_t *) dst) + i))[j] =
     74                            ((uint8_t *)(((sysarg_t *) src) + i))[j];
    7575        }
    7676               
  • kernel/generic/src/lib/rd.c

    r554debd r96b02eb9  
    9696        sysinfo_set_item_val("rd.size", NULL, dsize);
    9797        sysinfo_set_item_val("rd.address.physical", NULL,
    98             (unative_t) KA2PA((void *) header + hsize));
     98            (sysarg_t) KA2PA((void *) header + hsize));
    9999
    100100        return RE_OK;
  • kernel/generic/src/mm/as.c

    r554debd r96b02eb9  
    20002000
    20012001/** Wrapper for as_area_create(). */
    2002 unative_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
     2002sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
    20032003{
    20042004        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
    20052005            AS_AREA_ATTR_NONE, &anon_backend, NULL))
    2006                 return (unative_t) address;
     2006                return (sysarg_t) address;
    20072007        else
    2008                 return (unative_t) -1;
     2008                return (sysarg_t) -1;
    20092009}
    20102010
    20112011/** Wrapper for as_area_resize(). */
    2012 unative_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
    2013 {
    2014         return (unative_t) as_area_resize(AS, address, size, 0);
     2012sysarg_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
     2013{
     2014        return (sysarg_t) as_area_resize(AS, address, size, 0);
    20152015}
    20162016
    20172017/** Wrapper for as_area_change_flags(). */
    2018 unative_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
    2019 {
    2020         return (unative_t) as_area_change_flags(AS, flags, address);
     2018sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
     2019{
     2020        return (sysarg_t) as_area_change_flags(AS, flags, address);
    20212021}
    20222022
    20232023/** Wrapper for as_area_destroy(). */
    2024 unative_t sys_as_area_destroy(uintptr_t address)
    2025 {
    2026         return (unative_t) as_area_destroy(AS, address);
     2024sysarg_t sys_as_area_destroy(uintptr_t address)
     2025{
     2026        return (sysarg_t) as_area_destroy(AS, address);
    20272027}
    20282028
  • kernel/generic/src/mm/slab.c

    r554debd r96b02eb9  
    612612        cache->name = name;
    613613       
    614         if (align < sizeof(unative_t))
    615                 align = sizeof(unative_t);
     614        if (align < sizeof(sysarg_t))
     615                align = sizeof(sysarg_t);
    616616       
    617617        size = ALIGN_UP(size, align);
  • kernel/generic/src/proc/program.c

    r554debd r96b02eb9  
    210210 *
    211211 */
    212 unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
     212sysarg_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
    213213{
    214214        /* Cap length of name and copy it from userspace. */
     
    219219        int rc = copy_from_uspace(namebuf, uspace_name, name_len);
    220220        if (rc != 0)
    221                 return (unative_t) rc;
     221                return (sysarg_t) rc;
    222222       
    223223        namebuf[name_len] = 0;
  • kernel/generic/src/proc/task.c

    r554debd r96b02eb9  
    298298 *
    299299 */
    300 unative_t sys_task_get_id(task_id_t *uspace_task_id)
     300sysarg_t sys_task_get_id(task_id_t *uspace_task_id)
    301301{
    302302        /*
     
    304304         * the lifespan of the task.
    305305         */
    306         return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
     306        return (sysarg_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
    307307            sizeof(TASK->taskid));
    308308}
     
    318318 *
    319319 */
    320 unative_t sys_task_set_name(const char *uspace_name, size_t name_len)
     320sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len)
    321321{
    322322        int rc;
     
    330330        rc = copy_from_uspace(namebuf, uspace_name, name_len);
    331331        if (rc != 0)
    332                 return (unative_t) rc;
     332                return (sysarg_t) rc;
    333333       
    334334        namebuf[name_len] = '\0';
  • kernel/generic/src/proc/thread.c

    r554debd r96b02eb9  
    755755 *
    756756 */
    757 unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
     757sysarg_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
    758758    size_t name_len, thread_id_t *uspace_thread_id)
    759759{
     
    764764        int rc = copy_from_uspace(namebuf, uspace_name, name_len);
    765765        if (rc != 0)
    766                 return (unative_t) rc;
     766                return (sysarg_t) rc;
    767767       
    768768        namebuf[name_len] = 0;
     
    779779        if (rc != 0) {
    780780                free(kernel_uarg);
    781                 return (unative_t) rc;
     781                return (sysarg_t) rc;
    782782        }
    783783       
     
    804804                                free(kernel_uarg);
    805805                               
    806                                 return (unative_t) rc;
     806                                return (sysarg_t) rc;
    807807                         }
    808808                }
     
    827827                free(kernel_uarg);
    828828       
    829         return (unative_t) ENOMEM;
     829        return (sysarg_t) ENOMEM;
    830830}
    831831
     
    833833 *
    834834 */
    835 unative_t sys_thread_exit(int uspace_status)
     835sysarg_t sys_thread_exit(int uspace_status)
    836836{
    837837        thread_exit();
     
    849849 *
    850850 */
    851 unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
     851sysarg_t sys_thread_get_id(thread_id_t *uspace_thread_id)
    852852{
    853853        /*
     
    856856         *
    857857         */
    858         return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
     858        return (sysarg_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
    859859            sizeof(THREAD->tid));
    860860}
    861861
    862862/** Syscall wrapper for sleeping. */
    863 unative_t sys_thread_usleep(uint32_t usec)
     863sysarg_t sys_thread_usleep(uint32_t usec)
    864864{
    865865        thread_usleep(usec);
  • kernel/generic/src/security/cap.c

    r554debd r96b02eb9  
    8585 *
    8686 */
    87 unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
     87sysarg_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
    8888{
    8989        if (!(cap_get(TASK) & CAP_CAP))
    90                 return (unative_t) EPERM;
     90                return (sysarg_t) EPERM;
    9191       
    9292        sysarg64_t taskid_arg;
    9393        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
    9494        if (rc != 0)
    95                 return (unative_t) rc;
     95                return (sysarg_t) rc;
    9696       
    9797        irq_spinlock_lock(&tasks_lock, true);
     
    100100        if ((!task) || (!context_check(CONTEXT, task->context))) {
    101101                irq_spinlock_unlock(&tasks_lock, true);
    102                 return (unative_t) ENOENT;
     102                return (sysarg_t) ENOENT;
    103103        }
    104104       
     
    122122 *
    123123 */
    124 unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
     124sysarg_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
    125125{
    126126        sysarg64_t taskid_arg;
    127127        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
    128128        if (rc != 0)
    129                 return (unative_t) rc;
     129                return (sysarg_t) rc;
    130130       
    131131        irq_spinlock_lock(&tasks_lock, true);
     
    134134        if ((!task) || (!context_check(CONTEXT, task->context))) {
    135135                irq_spinlock_unlock(&tasks_lock, true);
    136                 return (unative_t) ENOENT;
     136                return (sysarg_t) ENOENT;
    137137        }
    138138       
     
    147147                irq_spinlock_unlock(&TASK->lock, false);
    148148                irq_spinlock_unlock(&tasks_lock, true);
    149                 return (unative_t) EPERM;
     149                return (sysarg_t) EPERM;
    150150        }
    151151       
  • kernel/generic/src/synch/futex.c

    r554debd r96b02eb9  
    6060
    6161static futex_t *futex_find(uintptr_t paddr);
    62 static size_t futex_ht_hash(unative_t *key);
    63 static bool futex_ht_compare(unative_t *key, size_t keys, link_t *item);
     62static size_t futex_ht_hash(sysarg_t *key);
     63static bool futex_ht_compare(sysarg_t *key, size_t keys, link_t *item);
    6464static void futex_ht_remove_callback(link_t *item);
    6565
     
    108108 *                      synch.h.
    109109 */
    110 unative_t sys_futex_sleep(uintptr_t uaddr)
     110sysarg_t sys_futex_sleep(uintptr_t uaddr)
    111111{
    112112        futex_t *futex;
     
    122122        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    123123                page_table_unlock(AS, true);
    124                 return (unative_t) ENOENT;
     124                return (sysarg_t) ENOENT;
    125125        }
    126126        paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
     
    136136        udebug_stoppable_end();
    137137#endif
    138         return (unative_t) rc;
     138        return (sysarg_t) rc;
    139139}
    140140
     
    145145 * @return              ENOENT if there is no physical mapping for uaddr.
    146146 */
    147 unative_t sys_futex_wakeup(uintptr_t uaddr)
     147sysarg_t sys_futex_wakeup(uintptr_t uaddr)
    148148{
    149149        futex_t *futex;
     
    158158        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    159159                page_table_unlock(AS, true);
    160                 return (unative_t) ENOENT;
     160                return (sysarg_t) ENOENT;
    161161        }
    162162        paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
     
    235235 * @return              Index into futex hash table.
    236236 */
    237 size_t futex_ht_hash(unative_t *key)
     237size_t futex_ht_hash(sysarg_t *key)
    238238{
    239239        return (*key & (FUTEX_HT_SIZE - 1));
     
    247247 * @return              True if the item matches the key. False otherwise.
    248248 */
    249 bool futex_ht_compare(unative_t *key, size_t keys, link_t *item)
     249bool futex_ht_compare(sysarg_t *key, size_t keys, link_t *item)
    250250{
    251251        futex_t *futex;
  • kernel/generic/src/synch/smc.c

    r554debd r96b02eb9  
    4242#include <synch/smc.h>
    4343
    44 unative_t sys_smc_coherence(uintptr_t va, size_t size)
     44sysarg_t sys_smc_coherence(uintptr_t va, size_t size)
    4545{
    4646        if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))
  • kernel/generic/src/syscall/syscall.c

    r554debd r96b02eb9  
    5656
    5757/** Dispatch system call */
    58 unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
    59     unative_t a4, unative_t a5, unative_t a6, unative_t id)
     58sysarg_t syscall_handler(sysarg_t a1, sysarg_t a2, sysarg_t a3,
     59    sysarg_t a4, sysarg_t a5, sysarg_t a6, sysarg_t id)
    6060{
    6161        /* Do userpace accounting */
     
    7474#endif
    7575       
    76         unative_t rc;
     76        sysarg_t rc;
    7777        if (id < SYSCALL_END) {
    7878                rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
  • kernel/generic/src/sysinfo/stats.c

    r554debd r96b02eb9  
    8787 *
    8888 */
    89 static unative_t get_stats_uptime(struct sysinfo_item *item)
     89static sysarg_t get_stats_uptime(struct sysinfo_item *item)
    9090{
    9191        /* This doesn't have to be very accurate */
  • kernel/generic/src/sysinfo/sysinfo.c

    r554debd r96b02eb9  
    296296 */
    297297void sysinfo_set_item_val(const char *name, sysinfo_item_t **root,
    298     unative_t val)
     298    sysarg_t val)
    299299{
    300300        /* Protect sysinfo tree consistency */
     
    481481                sysinfo_indent(depth);
    482482               
    483                 unative_t val;
     483                sysarg_t val;
    484484                size_t size;
    485485               
     
    660660 *
    661661 */
    662 unative_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)
     662sysarg_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)
    663663{
    664664        /*
     
    679679                ret.tag = SYSINFO_VAL_DATA;
    680680       
    681         return (unative_t) ret.tag;
     681        return (sysarg_t) ret.tag;
    682682}
    683683
     
    696696 *
    697697 */
    698 unative_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
     698sysarg_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
    699699    void *value_ptr)
    700700{
     
    715715                rc = EINVAL;
    716716       
    717         return (unative_t) rc;
     717        return (sysarg_t) rc;
    718718}
    719719
     
    732732 *
    733733 */
    734 unative_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
     734sysarg_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
    735735    void *size_ptr)
    736736{
     
    752752                rc = EINVAL;
    753753       
    754         return (unative_t) rc;
     754        return (sysarg_t) rc;
    755755}
    756756
     
    774774 *
    775775 */
    776 unative_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
     776sysarg_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
    777777    void *buffer_ptr, size_t buffer_size)
    778778{
     
    797797                free(ret.data.data);
    798798       
    799         return (unative_t) rc;
     799        return (sysarg_t) rc;
    800800}
    801801
  • kernel/generic/src/time/clock.c

    r554debd r96b02eb9  
    7070 *
    7171 */
    72 static unative_t secfrag = 0;
     72static sysarg_t secfrag = 0;
    7373
    7474/** Initialize realtime clock counter
     
    100100         *
    101101         */
    102         sysinfo_set_item_val("clock.cacheable", NULL, (unative_t) true);
    103         sysinfo_set_item_val("clock.faddr", NULL, (unative_t) faddr);
     102        sysinfo_set_item_val("clock.cacheable", NULL, (sysarg_t) true);
     103        sysinfo_set_item_val("clock.faddr", NULL, (sysarg_t) faddr);
    104104}
    105105
  • kernel/generic/src/udebug/udebug.c

    r554debd r96b02eb9  
    219219 *
    220220 */
    221 void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
    222     unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
     221void udebug_syscall_event(sysarg_t a1, sysarg_t a2, sysarg_t a3,
     222    sysarg_t a4, sysarg_t a5, sysarg_t a6, sysarg_t id, sysarg_t rc,
    223223    bool end_variant)
    224224{
     
    314314        IPC_SET_RETVAL(call->data, 0);
    315315        IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_B);
    316         IPC_SET_ARG2(call->data, (unative_t) thread);
     316        IPC_SET_ARG2(call->data, (sysarg_t) thread);
    317317       
    318318        /*
  • kernel/generic/src/udebug/udebug_ipc.c

    r554debd r96b02eb9  
    210210static void udebug_receive_name_read(call_t *call)
    211211{
    212         unative_t uspace_addr;
    213         unative_t to_copy;
     212        sysarg_t uspace_addr;
     213        sysarg_t to_copy;
    214214        size_t data_size;
    215215        size_t buf_size;
     
    257257static void udebug_receive_areas_read(call_t *call)
    258258{
    259         unative_t uspace_addr;
    260         unative_t to_copy;
     259        sysarg_t uspace_addr;
     260        sysarg_t to_copy;
    261261        size_t data_size;
    262262        size_t buf_size;
     
    304304{
    305305        thread_t *t;
    306         unative_t uspace_addr;
     306        sysarg_t uspace_addr;
    307307        int rc;
    308308        void *buffer;
     
    328328           (no way to distinguish method in answer) */
    329329        IPC_SET_ARG1(call->data, uspace_addr);
    330         IPC_SET_ARG2(call->data, 6 * sizeof(unative_t));
     330        IPC_SET_ARG2(call->data, 6 * sizeof(sysarg_t));
    331331        call->buffer = buffer;
    332332
     
    341341{
    342342        thread_t *t;
    343         unative_t uspace_addr;
    344         unative_t to_copy;
     343        sysarg_t uspace_addr;
     344        sysarg_t to_copy;
    345345        void *buffer;
    346346        int rc;
     
    382382static void udebug_receive_mem_read(call_t *call)
    383383{
    384         unative_t uspace_dst;
    385         unative_t uspace_src;
     384        sysarg_t uspace_dst;
     385        sysarg_t uspace_src;
    386386        unsigned size;
    387387        void *buffer;
  • kernel/generic/src/udebug/udebug_ops.c

    r554debd r96b02eb9  
    371371       
    372372        /* Allocate a buffer to hold thread IDs */
    373         unative_t *id_buffer = malloc(buf_size + 1, 0);
     373        sysarg_t *id_buffer = malloc(buf_size + 1, 0);
    374374       
    375375        mutex_lock(&TASK->udebug.lock);
     
    385385        /* Copy down the thread IDs */
    386386       
    387         size_t max_ids = buf_size / sizeof(unative_t);
     387        size_t max_ids = buf_size / sizeof(sysarg_t);
    388388        size_t copied_ids = 0;
    389389        size_t extra_ids = 0;
     
    404404                if (copied_ids < max_ids) {
    405405                        /* Using thread struct pointer as identification hash */
    406                         id_buffer[copied_ids++] = (unative_t) thread;
     406                        id_buffer[copied_ids++] = (sysarg_t) thread;
    407407                } else
    408408                        extra_ids++;
     
    414414       
    415415        *buffer = id_buffer;
    416         *stored = copied_ids * sizeof(unative_t);
    417         *needed = (copied_ids + extra_ids) * sizeof(unative_t);
     416        *stored = copied_ids * sizeof(sysarg_t);
     417        *needed = (copied_ids + extra_ids) * sizeof(sysarg_t);
    418418       
    419419        return 0;
     
    463463{
    464464        /* Prepare a buffer to hold the arguments. */
    465         unative_t *arg_buffer = malloc(6 * sizeof(unative_t), 0);
     465        sysarg_t *arg_buffer = malloc(6 * sizeof(sysarg_t), 0);
    466466       
    467467        /* On success, this will lock t->udebug.lock. */
     
    478478       
    479479        /* Copy to a local buffer before releasing the lock. */
    480         memcpy(arg_buffer, thread->udebug.syscall_args, 6 * sizeof(unative_t));
     480        memcpy(arg_buffer, thread->udebug.syscall_args, 6 * sizeof(sysarg_t));
    481481       
    482482        _thread_op_end(thread);
     
    539539 *
    540540 */
    541 int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer)
     541int udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
    542542{
    543543        /* Verify task state */
Note: See TracChangeset for help on using the changeset viewer.