Changeset 96b02eb9 in mainline for kernel/generic/src
- Timestamp:
- 2010-12-14T12:52:38Z (15 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 6b10dab
- Parents:
- 554debd
- Location:
- kernel/generic/src
- Files:
-
- 30 edited
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/adt/hash_table.c
r554debd r96b02eb9 82 82 * @param item Item to be inserted into the hash table. 83 83 */ 84 void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)84 void hash_table_insert(hash_table_t *h, sysarg_t key[], link_t *item) 85 85 { 86 86 size_t chain; … … 105 105 * @return Matching item on success, NULL if there is no such item. 106 106 */ 107 link_t *hash_table_find(hash_table_t *h, unative_t key[])107 link_t *hash_table_find(hash_table_t *h, sysarg_t key[]) 108 108 { 109 109 link_t *cur; … … 138 138 * @param keys Number of keys in the key array. 139 139 */ 140 void hash_table_remove(hash_table_t *h, unative_t key[], size_t keys)140 void hash_table_remove(hash_table_t *h, sysarg_t key[], size_t keys) 141 141 { 142 142 size_t chain; -
kernel/generic/src/console/cmd.c
r554debd r96b02eb9 601 601 602 602 /* This doesn't have to be very accurate */ 603 unative_t sec = uptime->seconds1;603 sysarg_t sec = uptime->seconds1; 604 604 605 605 printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n", … … 656 656 uintptr_t symaddr; 657 657 char *symbol; 658 unative_t (*fnc)(void);658 sysarg_t (*fnc)(void); 659 659 fncptr_t fptr; 660 660 int rc; … … 672 672 673 673 ipl = interrupts_disable(); 674 fnc = ( unative_t (*)(void)) arch_construct_function(&fptr,674 fnc = (sysarg_t (*)(void)) arch_construct_function(&fptr, 675 675 (void *) symaddr, (void *) cmd_call0); 676 676 printf("Calling %s() (%p)\n", symbol, (void *) symaddr); … … 720 720 uintptr_t symaddr; 721 721 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; 724 724 fncptr_t fptr; 725 725 int rc; … … 737 737 738 738 ipl = interrupts_disable(); 739 fnc = ( unative_t (*)(unative_t, ...))739 fnc = (sysarg_t (*)(sysarg_t, ...)) 740 740 arch_construct_function(&fptr, (void *) symaddr, 741 741 (void *) cmd_call1); … … 756 756 uintptr_t symaddr; 757 757 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; 761 761 fncptr_t fptr; 762 762 int rc; … … 774 774 775 775 ipl = interrupts_disable(); 776 fnc = ( unative_t (*)(unative_t, unative_t, ...))776 fnc = (sysarg_t (*)(sysarg_t, sysarg_t, ...)) 777 777 arch_construct_function(&fptr, (void *) symaddr, 778 778 (void *) cmd_call2); … … 792 792 uintptr_t symaddr; 793 793 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; 798 798 fncptr_t fptr; 799 799 int rc; … … 811 811 812 812 ipl = interrupts_disable(); 813 fnc = ( unative_t (*)(unative_t, unative_t, unative_t, ...))813 fnc = (sysarg_t (*)(sysarg_t, sysarg_t, sysarg_t, ...)) 814 814 arch_construct_function(&fptr, (void *) symaddr, 815 815 (void *) cmd_call3); -
kernel/generic/src/console/console.c
r554debd r96b02eb9 162 162 ddi_parea_register(&klog_parea); 163 163 164 sysinfo_set_item_val("klog.faddr", NULL, ( unative_t) faddr);164 sysinfo_set_item_val("klog.faddr", NULL, (sysarg_t) faddr); 165 165 sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES); 166 166 … … 193 193 194 194 /** Tell kernel to get keyboard/console access again */ 195 unative_t sys_debug_enable_console(void)195 sysarg_t sys_debug_enable_console(void) 196 196 { 197 197 #ifdef CONFIG_KCONSOLE … … 204 204 205 205 /** Tell kernel to relinquish keyboard/console access */ 206 unative_t sys_debug_disable_console(void)206 sysarg_t sys_debug_disable_console(void) 207 207 { 208 208 release_console(); … … 333 333 * 334 334 */ 335 unative_t sys_klog(int fd, const void *buf, size_t size)335 sysarg_t sys_klog(int fd, const void *buf, size_t size) 336 336 { 337 337 char *data; … … 339 339 340 340 if (size > PAGE_SIZE) 341 return ( unative_t) ELIMIT;341 return (sysarg_t) ELIMIT; 342 342 343 343 if (size > 0) { 344 344 data = (char *) malloc(size + 1, 0); 345 345 if (!data) 346 return ( unative_t) ENOMEM;346 return (sysarg_t) ENOMEM; 347 347 348 348 rc = copy_from_uspace(data, buf, size); 349 349 if (rc) { 350 350 free(data); 351 return ( unative_t) rc;351 return (sysarg_t) rc; 352 352 } 353 353 data[size] = 0; -
kernel/generic/src/console/kconsole.c
r554debd r96b02eb9 426 426 427 427 NO_TRACE static bool parse_int_arg(const char *text, size_t len, 428 unative_t *result)428 sysarg_t *result) 429 429 { 430 430 bool isaddr = false; … … 461 461 case EOK: 462 462 if (isaddr) 463 *result = ( unative_t) symaddr;463 *result = (sysarg_t) symaddr; 464 464 else if (isptr) 465 *result = **(( unative_t **) symaddr);465 *result = **((sysarg_t **) symaddr); 466 466 else 467 *result = *(( unative_t *) symaddr);467 *result = *((sysarg_t *) symaddr); 468 468 break; 469 469 default: … … 483 483 return false; 484 484 case EOK: 485 *result = ( unative_t) value;485 *result = (sysarg_t) value; 486 486 if (isptr) 487 *result = *(( unative_t *) *result);487 *result = *((sysarg_t *) *result); 488 488 break; 489 489 default: … … 629 629 cmdline + start + 1, 630 630 (end - start) - 1); 631 cmd->argv[i].intval = ( unative_t) buf;631 cmd->argv[i].intval = (sysarg_t) buf; 632 632 cmd->argv[i].vartype = ARG_TYPE_STRING; 633 633 } else { -
kernel/generic/src/ddi/ddi.c
r554debd r96b02eb9 232 232 * 233 233 */ 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,234 sysarg_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, 238 238 FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE), 239 239 (size_t) pages, (int) flags); … … 247 247 * 248 248 */ 249 unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)249 sysarg_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg) 250 250 { 251 251 ddi_ioarg_t arg; 252 252 int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t)); 253 253 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, 257 257 (uintptr_t) arg.ioaddr, (size_t) arg.size); 258 258 } … … 265 265 * @retutn Zero on success, error code otherwise. 266 266 */ 267 unative_t sys_interrupt_enable(int irq, int enable)267 sysarg_t sys_interrupt_enable(int irq, int enable) 268 268 { 269 269 /* FIXME: this needs to be generic code, or better not be in kernel at all. */ -
kernel/generic/src/ddi/device.c
r554debd r96b02eb9 54 54 } 55 55 56 unative_t sys_device_assign_devno(void)56 sysarg_t sys_device_assign_devno(void) 57 57 { 58 return ( unative_t) device_assign_devno();58 return (sysarg_t) device_assign_devno(); 59 59 } 60 60 -
kernel/generic/src/ddi/irq.c
r554debd r96b02eb9 106 106 * 107 107 */ 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);108 static size_t irq_ht_hash(sysarg_t *key); 109 static bool irq_ht_compare(sysarg_t *key, size_t keys, link_t *item); 110 110 static void irq_ht_remove(link_t *item); 111 111 … … 123 123 * 124 124 */ 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);125 static size_t irq_lin_hash(sysarg_t *key); 126 static bool irq_lin_compare(sysarg_t *key, size_t keys, link_t *item); 127 127 static void irq_lin_remove(link_t *item); 128 128 … … 194 194 void irq_register(irq_t *irq) 195 195 { 196 unative_t key[] = {197 ( unative_t) irq->inr,198 ( unative_t) irq->devno196 sysarg_t key[] = { 197 (sysarg_t) irq->inr, 198 (sysarg_t) irq->devno 199 199 }; 200 200 … … 212 212 { 213 213 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 */ 217 217 }; 218 218 … … 235 235 { 236 236 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 */ 240 240 }; 241 241 … … 306 306 * 307 307 */ 308 size_t irq_ht_hash( unative_t key[])308 size_t irq_ht_hash(sysarg_t key[]) 309 309 { 310 310 inr_t inr = (inr_t) key[KEY_INR]; … … 333 333 * 334 334 */ 335 bool irq_ht_compare( unative_t key[], size_t keys, link_t *item)335 bool irq_ht_compare(sysarg_t key[], size_t keys, link_t *item) 336 336 { 337 337 irq_t *irq = hash_table_get_instance(item, irq_t, link); … … 381 381 * 382 382 */ 383 size_t irq_lin_hash( unative_t key[])383 size_t irq_lin_hash(sysarg_t key[]) 384 384 { 385 385 inr_t inr = (inr_t) key[KEY_INR]; … … 408 408 * 409 409 */ 410 bool irq_lin_compare( unative_t key[], size_t keys, link_t *item)410 bool irq_lin_compare(sysarg_t key[], size_t keys, link_t *item) 411 411 { 412 412 irq_t *irq = list_get_instance(item, irq_t, link); -
kernel/generic/src/interrupt/interrupt.c
r554debd r96b02eb9 197 197 /* Notify the subscriber that a fault occurred. */ 198 198 event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid), 199 UPPER32(TASK->taskid), ( unative_t) THREAD);199 UPPER32(TASK->taskid), (sysarg_t) THREAD); 200 200 201 201 #ifdef CONFIG_UDEBUG … … 263 263 264 264 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); 266 266 267 267 #ifdef __32_BITS__ -
kernel/generic/src/ipc/event.c
r554debd r96b02eb9 61 61 } 62 62 63 static int event_subscribe(event_type_t evno, unative_t method,63 static int event_subscribe(event_type_t evno, sysarg_t method, 64 64 answerbox_t *answerbox) 65 65 { … … 84 84 } 85 85 86 unative_t sys_event_subscribe(unative_t evno, unative_t method)86 sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t method) 87 87 { 88 return ( unative_t) event_subscribe((event_type_t) evno, (unative_t)88 return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t) 89 89 method, &TASK->answerbox); 90 90 } … … 119 119 } 120 120 121 void event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,122 unative_t a4, unative_t a5)121 void event_notify(event_type_t evno, sysarg_t a1, sysarg_t a2, sysarg_t a3, 122 sysarg_t a4, sysarg_t a5) 123 123 { 124 124 ASSERT(evno < EVENT_END); -
kernel/generic/src/ipc/ipc.c
r554debd r96b02eb9 270 270 * 271 271 */ 272 void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)272 void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err) 273 273 { 274 274 call->data.phone = phone; -
kernel/generic/src/ipc/ipcrsc.c
r554debd r96b02eb9 144 144 * 145 145 */ 146 call_t *get_call( unative_t callid)146 call_t *get_call(sysarg_t callid) 147 147 { 148 148 link_t *lst; … … 153 153 lst != &TASK->answerbox.dispatched_calls; lst = lst->next) { 154 154 call_t *call = list_get_instance(lst, call_t, link); 155 if (( unative_t) call == callid) {155 if ((sysarg_t) call == callid) { 156 156 result = call; 157 157 break; -
kernel/generic/src/ipc/irq.c
r554debd r96b02eb9 140 140 */ 141 141 int 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) devno142 sysarg_t method, irq_code_t *ucode) 143 { 144 sysarg_t key[] = { 145 (sysarg_t) inr, 146 (sysarg_t) devno 147 147 }; 148 148 … … 213 213 int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno) 214 214 { 215 unative_t key[] = {216 ( unative_t) inr,217 ( unative_t) devno215 sysarg_t key[] = { 216 (sysarg_t) inr, 217 (sysarg_t) devno 218 218 }; 219 219 … … 290 290 } 291 291 292 unative_t key[2];292 sysarg_t key[2]; 293 293 key[0] = irq->inr; 294 294 key[1] = irq->devno; … … 465 465 * 466 466 */ 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)467 void ipc_irq_send_msg(irq_t *irq, sysarg_t a1, sysarg_t a2, sysarg_t a3, 468 sysarg_t a4, sysarg_t a5) 469 469 { 470 470 irq_spinlock_lock(&irq->lock, true); -
kernel/generic/src/ipc/sysipc.c
r554debd r96b02eb9 68 68 * 69 69 */ 70 static int phone_get( unative_t phoneid, phone_t **phone)70 static int phone_get(sysarg_t phoneid, phone_t **phone) 71 71 { 72 72 if (phoneid >= IPC_MAX_PHONES) … … 84 84 * 85 85 */ 86 static inline bool method_is_system( unative_t method)86 static inline bool method_is_system(sysarg_t method) 87 87 { 88 88 if (method <= IPC_M_LAST_SYSTEM) … … 102 102 * 103 103 */ 104 static inline bool method_is_forwardable( unative_t method)104 static inline bool method_is_forwardable(sysarg_t method) 105 105 { 106 106 switch (method) { … … 124 124 * 125 125 */ 126 static inline bool method_is_immutable( unative_t method)126 static inline bool method_is_immutable(sysarg_t method) 127 127 { 128 128 switch (method) { … … 248 248 /* Set 'phone hash' as arg5 of response */ 249 249 IPC_SET_ARG5(answer->data, 250 ( unative_t) &TASK->phones[phoneid]);250 (sysarg_t) &TASK->phones[phoneid]); 251 251 } 252 252 } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) { … … 399 399 } 400 400 case IPC_M_CONNECT_ME: 401 IPC_SET_ARG5(call->data, ( unative_t) phone);401 IPC_SET_ARG5(call->data, (sysarg_t) phone); 402 402 break; 403 403 case IPC_M_CONNECT_ME_TO: { … … 407 407 408 408 /* 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]); 410 410 call->flags |= IPC_CALL_CONN_ME_TO; 411 411 call->priv = newphid; … … 541 541 * 542 542 */ 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)543 sysarg_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) 545 545 { 546 546 phone_t *phone; … … 601 601 * 602 602 */ 603 unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,603 sysarg_t sys_ipc_call_sync_slow(sysarg_t phoneid, ipc_data_t *question, 604 604 ipc_data_t *reply) 605 605 { … … 613 613 if (rc != 0) { 614 614 ipc_call_free(call); 615 return ( unative_t) rc;615 return (sysarg_t) rc; 616 616 } 617 617 … … 677 677 * 678 678 */ 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)679 sysarg_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) 681 681 { 682 682 phone_t *phone; … … 707 707 ipc_backsend_err(phone, call, res); 708 708 709 return ( unative_t) call;709 return (sysarg_t) call; 710 710 } 711 711 … … 718 718 * 719 719 */ 720 unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)720 sysarg_t sys_ipc_call_async_slow(sysarg_t phoneid, ipc_data_t *data) 721 721 { 722 722 phone_t *phone; … … 732 732 if (rc != 0) { 733 733 ipc_call_free(call); 734 return ( unative_t) rc;734 return (sysarg_t) rc; 735 735 } 736 736 … … 742 742 ipc_backsend_err(phone, call, res); 743 743 744 return ( unative_t) call;744 return (sysarg_t) call; 745 745 } 746 746 … … 767 767 * 768 768 */ 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)769 static 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) 772 772 { 773 773 call_t *call = get_call(callid); … … 846 846 * 847 847 */ 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)848 sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid, 849 sysarg_t method, sysarg_t arg1, sysarg_t arg2, unsigned int mode) 850 850 { 851 851 return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0, … … 870 870 * 871 871 */ 872 unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,872 sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid, 873 873 ipc_data_t *data, unsigned int mode) 874 874 { … … 877 877 sizeof(newdata.args)); 878 878 if (rc != 0) 879 return ( unative_t) rc;879 return (sysarg_t) rc; 880 880 881 881 return sys_ipc_forward_common(callid, phoneid, … … 900 900 * 901 901 */ 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)902 sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval, 903 sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4) 904 904 { 905 905 /* Do not answer notification callids */ … … 945 945 * 946 946 */ 947 unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)947 sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data) 948 948 { 949 949 /* Do not answer notification callids */ … … 982 982 * 983 983 */ 984 unative_t sys_ipc_hangup(unative_t phoneid)984 sysarg_t sys_ipc_hangup(sysarg_t phoneid) 985 985 { 986 986 phone_t *phone; … … 1008 1008 * 1009 1009 */ 1010 unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,1010 sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, 1011 1011 unsigned int flags) 1012 1012 { … … 1037 1037 ipc_call_free(call); 1038 1038 1039 return (( unative_t) call) | IPC_CALLID_NOTIFICATION;1039 return ((sysarg_t) call) | IPC_CALLID_NOTIFICATION; 1040 1040 } 1041 1041 … … 1051 1051 ipc_call_free(call); 1052 1052 1053 return (( unative_t) call) | IPC_CALLID_ANSWERED;1053 return ((sysarg_t) call) | IPC_CALLID_ANSWERED; 1054 1054 } 1055 1055 … … 1079 1079 } 1080 1080 1081 return ( unative_t) call;1081 return (sysarg_t) call; 1082 1082 } 1083 1083 … … 1085 1085 * 1086 1086 */ 1087 unative_t sys_ipc_poke(void)1087 sysarg_t sys_ipc_poke(void) 1088 1088 { 1089 1089 waitq_unsleep(&TASK->answerbox.wq); … … 1101 1101 * 1102 1102 */ 1103 unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,1103 sysarg_t sys_ipc_register_irq(inr_t inr, devno_t devno, sysarg_t method, 1104 1104 irq_code_t *ucode) 1105 1105 { … … 1118 1118 * 1119 1119 */ 1120 unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)1120 sysarg_t sys_ipc_unregister_irq(inr_t inr, devno_t devno) 1121 1121 { 1122 1122 if (!(cap_get(TASK) & CAP_IRQ_REG)) … … 1135 1135 * 1136 1136 */ 1137 unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)1137 sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg) 1138 1138 { 1139 1139 #ifdef CONFIG_UDEBUG … … 1141 1141 int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t)); 1142 1142 if (rc != 0) 1143 return ( unative_t) rc;1143 return (sysarg_t) rc; 1144 1144 1145 1145 LOG("sys_ipc_connect_kbox(%" PRIu64 ")", taskid_arg.value); … … 1147 1147 return ipc_connect_kbox(taskid_arg.value); 1148 1148 #else 1149 return ( unative_t) ENOTSUP;1149 return (sysarg_t) ENOTSUP; 1150 1150 #endif 1151 1151 } -
kernel/generic/src/lib/memstr.c
r554debd r96b02eb9 62 62 unsigned int i, j; 63 63 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) { 66 66 for (i = 0; i < cnt; i++) 67 67 ((uint8_t *) dst)[i] = ((uint8_t *) src)[i]; 68 68 } 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]; 71 71 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]; 75 75 } 76 76 -
kernel/generic/src/lib/rd.c
r554debd r96b02eb9 96 96 sysinfo_set_item_val("rd.size", NULL, dsize); 97 97 sysinfo_set_item_val("rd.address.physical", NULL, 98 ( unative_t)KA2PA((void *) header + hsize));98 (sysarg_t) KA2PA((void *) header + hsize)); 99 99 100 100 return RE_OK; -
kernel/generic/src/mm/as.c
r554debd r96b02eb9 2000 2000 2001 2001 /** Wrapper for as_area_create(). */ 2002 unative_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)2002 sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags) 2003 2003 { 2004 2004 if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address, 2005 2005 AS_AREA_ATTR_NONE, &anon_backend, NULL)) 2006 return ( unative_t) address;2006 return (sysarg_t) address; 2007 2007 else 2008 return ( unative_t) -1;2008 return (sysarg_t) -1; 2009 2009 } 2010 2010 2011 2011 /** 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);2012 sysarg_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); 2015 2015 } 2016 2016 2017 2017 /** 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);2018 sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags) 2019 { 2020 return (sysarg_t) as_area_change_flags(AS, flags, address); 2021 2021 } 2022 2022 2023 2023 /** 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);2024 sysarg_t sys_as_area_destroy(uintptr_t address) 2025 { 2026 return (sysarg_t) as_area_destroy(AS, address); 2027 2027 } 2028 2028 -
kernel/generic/src/mm/slab.c
r554debd r96b02eb9 612 612 cache->name = name; 613 613 614 if (align < sizeof( unative_t))615 align = sizeof( unative_t);614 if (align < sizeof(sysarg_t)) 615 align = sizeof(sysarg_t); 616 616 617 617 size = ALIGN_UP(size, align); -
kernel/generic/src/proc/program.c
r554debd r96b02eb9 210 210 * 211 211 */ 212 unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)212 sysarg_t sys_program_spawn_loader(char *uspace_name, size_t name_len) 213 213 { 214 214 /* Cap length of name and copy it from userspace. */ … … 219 219 int rc = copy_from_uspace(namebuf, uspace_name, name_len); 220 220 if (rc != 0) 221 return ( unative_t) rc;221 return (sysarg_t) rc; 222 222 223 223 namebuf[name_len] = 0; -
kernel/generic/src/proc/task.c
r554debd r96b02eb9 298 298 * 299 299 */ 300 unative_t sys_task_get_id(task_id_t *uspace_task_id)300 sysarg_t sys_task_get_id(task_id_t *uspace_task_id) 301 301 { 302 302 /* … … 304 304 * the lifespan of the task. 305 305 */ 306 return ( unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,306 return (sysarg_t) copy_to_uspace(uspace_task_id, &TASK->taskid, 307 307 sizeof(TASK->taskid)); 308 308 } … … 318 318 * 319 319 */ 320 unative_t sys_task_set_name(const char *uspace_name, size_t name_len)320 sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len) 321 321 { 322 322 int rc; … … 330 330 rc = copy_from_uspace(namebuf, uspace_name, name_len); 331 331 if (rc != 0) 332 return ( unative_t) rc;332 return (sysarg_t) rc; 333 333 334 334 namebuf[name_len] = '\0'; -
kernel/generic/src/proc/thread.c
r554debd r96b02eb9 755 755 * 756 756 */ 757 unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,757 sysarg_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, 758 758 size_t name_len, thread_id_t *uspace_thread_id) 759 759 { … … 764 764 int rc = copy_from_uspace(namebuf, uspace_name, name_len); 765 765 if (rc != 0) 766 return ( unative_t) rc;766 return (sysarg_t) rc; 767 767 768 768 namebuf[name_len] = 0; … … 779 779 if (rc != 0) { 780 780 free(kernel_uarg); 781 return ( unative_t) rc;781 return (sysarg_t) rc; 782 782 } 783 783 … … 804 804 free(kernel_uarg); 805 805 806 return ( unative_t) rc;806 return (sysarg_t) rc; 807 807 } 808 808 } … … 827 827 free(kernel_uarg); 828 828 829 return ( unative_t) ENOMEM;829 return (sysarg_t) ENOMEM; 830 830 } 831 831 … … 833 833 * 834 834 */ 835 unative_t sys_thread_exit(int uspace_status)835 sysarg_t sys_thread_exit(int uspace_status) 836 836 { 837 837 thread_exit(); … … 849 849 * 850 850 */ 851 unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)851 sysarg_t sys_thread_get_id(thread_id_t *uspace_thread_id) 852 852 { 853 853 /* … … 856 856 * 857 857 */ 858 return ( unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,858 return (sysarg_t) copy_to_uspace(uspace_thread_id, &THREAD->tid, 859 859 sizeof(THREAD->tid)); 860 860 } 861 861 862 862 /** Syscall wrapper for sleeping. */ 863 unative_t sys_thread_usleep(uint32_t usec)863 sysarg_t sys_thread_usleep(uint32_t usec) 864 864 { 865 865 thread_usleep(usec); -
kernel/generic/src/security/cap.c
r554debd r96b02eb9 85 85 * 86 86 */ 87 unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)87 sysarg_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps) 88 88 { 89 89 if (!(cap_get(TASK) & CAP_CAP)) 90 return ( unative_t) EPERM;90 return (sysarg_t) EPERM; 91 91 92 92 sysarg64_t taskid_arg; 93 93 int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t)); 94 94 if (rc != 0) 95 return ( unative_t) rc;95 return (sysarg_t) rc; 96 96 97 97 irq_spinlock_lock(&tasks_lock, true); … … 100 100 if ((!task) || (!context_check(CONTEXT, task->context))) { 101 101 irq_spinlock_unlock(&tasks_lock, true); 102 return ( unative_t) ENOENT;102 return (sysarg_t) ENOENT; 103 103 } 104 104 … … 122 122 * 123 123 */ 124 unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)124 sysarg_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps) 125 125 { 126 126 sysarg64_t taskid_arg; 127 127 int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t)); 128 128 if (rc != 0) 129 return ( unative_t) rc;129 return (sysarg_t) rc; 130 130 131 131 irq_spinlock_lock(&tasks_lock, true); … … 134 134 if ((!task) || (!context_check(CONTEXT, task->context))) { 135 135 irq_spinlock_unlock(&tasks_lock, true); 136 return ( unative_t) ENOENT;136 return (sysarg_t) ENOENT; 137 137 } 138 138 … … 147 147 irq_spinlock_unlock(&TASK->lock, false); 148 148 irq_spinlock_unlock(&tasks_lock, true); 149 return ( unative_t) EPERM;149 return (sysarg_t) EPERM; 150 150 } 151 151 -
kernel/generic/src/synch/futex.c
r554debd r96b02eb9 60 60 61 61 static 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);62 static size_t futex_ht_hash(sysarg_t *key); 63 static bool futex_ht_compare(sysarg_t *key, size_t keys, link_t *item); 64 64 static void futex_ht_remove_callback(link_t *item); 65 65 … … 108 108 * synch.h. 109 109 */ 110 unative_t sys_futex_sleep(uintptr_t uaddr)110 sysarg_t sys_futex_sleep(uintptr_t uaddr) 111 111 { 112 112 futex_t *futex; … … 122 122 if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) { 123 123 page_table_unlock(AS, true); 124 return ( unative_t) ENOENT;124 return (sysarg_t) ENOENT; 125 125 } 126 126 paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE)); … … 136 136 udebug_stoppable_end(); 137 137 #endif 138 return ( unative_t) rc;138 return (sysarg_t) rc; 139 139 } 140 140 … … 145 145 * @return ENOENT if there is no physical mapping for uaddr. 146 146 */ 147 unative_t sys_futex_wakeup(uintptr_t uaddr)147 sysarg_t sys_futex_wakeup(uintptr_t uaddr) 148 148 { 149 149 futex_t *futex; … … 158 158 if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) { 159 159 page_table_unlock(AS, true); 160 return ( unative_t) ENOENT;160 return (sysarg_t) ENOENT; 161 161 } 162 162 paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE)); … … 235 235 * @return Index into futex hash table. 236 236 */ 237 size_t futex_ht_hash( unative_t *key)237 size_t futex_ht_hash(sysarg_t *key) 238 238 { 239 239 return (*key & (FUTEX_HT_SIZE - 1)); … … 247 247 * @return True if the item matches the key. False otherwise. 248 248 */ 249 bool futex_ht_compare( unative_t *key, size_t keys, link_t *item)249 bool futex_ht_compare(sysarg_t *key, size_t keys, link_t *item) 250 250 { 251 251 futex_t *futex; -
kernel/generic/src/synch/smc.c
r554debd r96b02eb9 42 42 #include <synch/smc.h> 43 43 44 unative_t sys_smc_coherence(uintptr_t va, size_t size)44 sysarg_t sys_smc_coherence(uintptr_t va, size_t size) 45 45 { 46 46 if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE)) -
kernel/generic/src/syscall/syscall.c
r554debd r96b02eb9 56 56 57 57 /** 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)58 sysarg_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) 60 60 { 61 61 /* Do userpace accounting */ … … 74 74 #endif 75 75 76 unative_t rc;76 sysarg_t rc; 77 77 if (id < SYSCALL_END) { 78 78 rc = syscall_table[id](a1, a2, a3, a4, a5, a6); -
kernel/generic/src/sysinfo/stats.c
r554debd r96b02eb9 87 87 * 88 88 */ 89 static unative_t get_stats_uptime(struct sysinfo_item *item)89 static sysarg_t get_stats_uptime(struct sysinfo_item *item) 90 90 { 91 91 /* This doesn't have to be very accurate */ -
kernel/generic/src/sysinfo/sysinfo.c
r554debd r96b02eb9 296 296 */ 297 297 void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, 298 unative_t val)298 sysarg_t val) 299 299 { 300 300 /* Protect sysinfo tree consistency */ … … 481 481 sysinfo_indent(depth); 482 482 483 unative_t val;483 sysarg_t val; 484 484 size_t size; 485 485 … … 660 660 * 661 661 */ 662 unative_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)662 sysarg_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size) 663 663 { 664 664 /* … … 679 679 ret.tag = SYSINFO_VAL_DATA; 680 680 681 return ( unative_t) ret.tag;681 return (sysarg_t) ret.tag; 682 682 } 683 683 … … 696 696 * 697 697 */ 698 unative_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,698 sysarg_t sys_sysinfo_get_value(void *path_ptr, size_t path_size, 699 699 void *value_ptr) 700 700 { … … 715 715 rc = EINVAL; 716 716 717 return ( unative_t) rc;717 return (sysarg_t) rc; 718 718 } 719 719 … … 732 732 * 733 733 */ 734 unative_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,734 sysarg_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size, 735 735 void *size_ptr) 736 736 { … … 752 752 rc = EINVAL; 753 753 754 return ( unative_t) rc;754 return (sysarg_t) rc; 755 755 } 756 756 … … 774 774 * 775 775 */ 776 unative_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,776 sysarg_t sys_sysinfo_get_data(void *path_ptr, size_t path_size, 777 777 void *buffer_ptr, size_t buffer_size) 778 778 { … … 797 797 free(ret.data.data); 798 798 799 return ( unative_t) rc;799 return (sysarg_t) rc; 800 800 } 801 801 -
kernel/generic/src/time/clock.c
r554debd r96b02eb9 70 70 * 71 71 */ 72 static unative_t secfrag = 0;72 static sysarg_t secfrag = 0; 73 73 74 74 /** Initialize realtime clock counter … … 100 100 * 101 101 */ 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); 104 104 } 105 105 -
kernel/generic/src/udebug/udebug.c
r554debd r96b02eb9 219 219 * 220 220 */ 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,221 void 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, 223 223 bool end_variant) 224 224 { … … 314 314 IPC_SET_RETVAL(call->data, 0); 315 315 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); 317 317 318 318 /* -
kernel/generic/src/udebug/udebug_ipc.c
r554debd r96b02eb9 210 210 static void udebug_receive_name_read(call_t *call) 211 211 { 212 unative_t uspace_addr;213 unative_t to_copy;212 sysarg_t uspace_addr; 213 sysarg_t to_copy; 214 214 size_t data_size; 215 215 size_t buf_size; … … 257 257 static void udebug_receive_areas_read(call_t *call) 258 258 { 259 unative_t uspace_addr;260 unative_t to_copy;259 sysarg_t uspace_addr; 260 sysarg_t to_copy; 261 261 size_t data_size; 262 262 size_t buf_size; … … 304 304 { 305 305 thread_t *t; 306 unative_t uspace_addr;306 sysarg_t uspace_addr; 307 307 int rc; 308 308 void *buffer; … … 328 328 (no way to distinguish method in answer) */ 329 329 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)); 331 331 call->buffer = buffer; 332 332 … … 341 341 { 342 342 thread_t *t; 343 unative_t uspace_addr;344 unative_t to_copy;343 sysarg_t uspace_addr; 344 sysarg_t to_copy; 345 345 void *buffer; 346 346 int rc; … … 382 382 static void udebug_receive_mem_read(call_t *call) 383 383 { 384 unative_t uspace_dst;385 unative_t uspace_src;384 sysarg_t uspace_dst; 385 sysarg_t uspace_src; 386 386 unsigned size; 387 387 void *buffer; -
kernel/generic/src/udebug/udebug_ops.c
r554debd r96b02eb9 371 371 372 372 /* 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); 374 374 375 375 mutex_lock(&TASK->udebug.lock); … … 385 385 /* Copy down the thread IDs */ 386 386 387 size_t max_ids = buf_size / sizeof( unative_t);387 size_t max_ids = buf_size / sizeof(sysarg_t); 388 388 size_t copied_ids = 0; 389 389 size_t extra_ids = 0; … … 404 404 if (copied_ids < max_ids) { 405 405 /* Using thread struct pointer as identification hash */ 406 id_buffer[copied_ids++] = ( unative_t) thread;406 id_buffer[copied_ids++] = (sysarg_t) thread; 407 407 } else 408 408 extra_ids++; … … 414 414 415 415 *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); 418 418 419 419 return 0; … … 463 463 { 464 464 /* 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); 466 466 467 467 /* On success, this will lock t->udebug.lock. */ … … 478 478 479 479 /* 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)); 481 481 482 482 _thread_op_end(thread); … … 539 539 * 540 540 */ 541 int udebug_mem_read( unative_t uspace_addr, size_t n, void **buffer)541 int udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer) 542 542 { 543 543 /* Verify task state */
Note:
See TracChangeset
for help on using the changeset viewer.