Changeset fbcfc4da in mainline for kernel/generic/src
- Timestamp:
- 2009-12-03T19:25:17Z (16 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 9510be2
- Parents:
- cb3d641a (diff), 22e6802 (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. - Location:
- kernel/generic/src
- Files:
-
- 13 edited
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/console/console.c
rcb3d641a rfbcfc4da 319 319 320 320 if (size > PAGE_SIZE) 321 return ELIMIT;321 return (unative_t) ELIMIT; 322 322 323 323 if (size > 0) { 324 324 data = (char *) malloc(size + 1, 0); 325 325 if (!data) 326 return ENOMEM;326 return (unative_t) ENOMEM; 327 327 328 328 rc = copy_from_uspace(data, buf, size); 329 329 if (rc) { 330 330 free(data); 331 return rc;331 return (unative_t) rc; 332 332 } 333 333 data[size] = 0; -
kernel/generic/src/console/kconsole.c
rcb3d641a rfbcfc4da 289 289 290 290 char tmp[STR_BOUNDS(MAX_CMDLINE)]; 291 wstr_ nstr(tmp, current + beg, position - beg + 1);291 wstr_to_str(tmp, position - beg + 1, current + beg); 292 292 293 293 int found; … … 665 665 666 666 char cmdline[STR_BOUNDS(MAX_CMDLINE)]; 667 wstr_ nstr(cmdline, tmp, STR_BOUNDS(MAX_CMDLINE));667 wstr_to_str(cmdline, STR_BOUNDS(MAX_CMDLINE), tmp); 668 668 669 669 if ((!kcon) && (len == 4) && (str_lcmp(cmdline, "exit", 4) == 0)) -
kernel/generic/src/ipc/ipc.c
rcb3d641a rfbcfc4da 62 62 63 63 static slab_cache_t *ipc_call_slab; 64 static slab_cache_t *ipc_answerbox_slab; 64 65 65 66 /** Initialize a call structure. … … 96 97 } 97 98 98 /** Initialize a statically allocated call structure.99 *100 * @param call Statically allocated kernel call structure to be101 * initialized.102 */103 void ipc_call_static_init(call_t *call)104 {105 _ipc_call_init(call);106 call->flags |= IPC_CALL_STATIC_ALLOC;107 }108 109 99 /** Deallocate a call structure. 110 100 * … … 113 103 void ipc_call_free(call_t *call) 114 104 { 115 ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));116 105 /* Check to see if we have data in the IPC_M_DATA_SEND buffer. */ 117 106 if (call->buffer) … … 130 119 spinlock_initialize(&box->irq_lock, "ipc_box_irqlock"); 131 120 waitq_initialize(&box->wq); 121 link_initialize(&box->sync_box_link); 132 122 list_initialize(&box->connected_phones); 133 123 list_initialize(&box->calls); … … 179 169 int ipc_call_sync(phone_t *phone, call_t *request) 180 170 { 181 answerbox_t sync_box; 182 183 ipc_answerbox_init(&sync_box, TASK); 171 answerbox_t *sync_box; 172 ipl_t ipl; 173 174 sync_box = slab_alloc(ipc_answerbox_slab, 0); 175 ipc_answerbox_init(sync_box, TASK); 176 177 /* 178 * Put the answerbox on the TASK's list of synchronous answerboxes so 179 * that it can be cleaned up if the call is interrupted. 180 */ 181 ipl = interrupts_disable(); 182 spinlock_lock(&TASK->lock); 183 list_append(&sync_box->sync_box_link, &TASK->sync_box_head); 184 spinlock_unlock(&TASK->lock); 185 interrupts_restore(ipl); 184 186 185 187 /* We will receive data in a special box. */ 186 request->callerbox = &sync_box;188 request->callerbox = sync_box; 187 189 188 190 ipc_call(phone, request); 189 if (!ipc_wait_for_call(&sync_box, SYNCH_NO_TIMEOUT, 190 SYNCH_FLAGS_INTERRUPTIBLE)) 191 if (!ipc_wait_for_call(sync_box, SYNCH_NO_TIMEOUT, 192 SYNCH_FLAGS_INTERRUPTIBLE)) { 193 /* The answerbox and the call will be freed by ipc_cleanup(). */ 191 194 return EINTR; 195 } 196 197 /* 198 * The answer arrived without interruption so we can remove the 199 * answerbox from the TASK's list of synchronous answerboxes. 200 */ 201 (void) interrupts_disable(); 202 spinlock_lock(&TASK->lock); 203 list_remove(&sync_box->sync_box_link); 204 spinlock_unlock(&TASK->lock); 205 interrupts_restore(ipl); 206 207 slab_free(ipc_answerbox_slab, sync_box); 192 208 return EOK; 193 209 } … … 520 536 int i; 521 537 call_t *call; 538 ipl_t ipl; 522 539 523 540 /* Disconnect all our phones ('ipc_phone_hangup') */ … … 545 562 spinlock_unlock(&TASK->answerbox.lock); 546 563 547 /* Wait for all async answers to arrive */ 564 /* Wait for all answers to interrupted synchronous calls to arrive */ 565 ipl = interrupts_disable(); 566 while (!list_empty(&TASK->sync_box_head)) { 567 answerbox_t *box = list_get_instance(TASK->sync_box_head.next, 568 answerbox_t, sync_box_link); 569 570 list_remove(&box->sync_box_link); 571 call = ipc_wait_for_call(box, SYNCH_NO_TIMEOUT, 572 SYNCH_FLAGS_NONE); 573 ipc_call_free(call); 574 slab_free(ipc_answerbox_slab, box); 575 } 576 interrupts_restore(ipl); 577 578 /* Wait for all answers to asynchronous calls to arrive */ 548 579 while (1) { 549 580 /* Go through all phones, until all are FREE... */ … … 552 583 for (i = 0; i < IPC_MAX_PHONES; i++) { 553 584 if (TASK->phones[i].state == IPC_PHONE_HUNGUP && 554 atomic_get(&TASK->phones[i].active_calls) == 0) 585 atomic_get(&TASK->phones[i].active_calls) == 0) { 555 586 TASK->phones[i].state = IPC_PHONE_FREE; 587 TASK->phones[i].callee = NULL; 588 } 556 589 557 590 /* Just for sure, we might have had some … … 574 607 ASSERT((call->flags & IPC_CALL_ANSWERED) || 575 608 (call->flags & IPC_CALL_NOTIF)); 576 ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));577 609 578 610 /* … … 593 625 ipc_call_slab = slab_cache_create("ipc_call", sizeof(call_t), 0, NULL, 594 626 NULL, 0); 627 ipc_answerbox_slab = slab_cache_create("ipc_answerbox", 628 sizeof(answerbox_t), 0, NULL, NULL, 0); 595 629 } 596 630 -
kernel/generic/src/ipc/irq.c
rcb3d641a rfbcfc4da 418 418 case CMD_ACCEPT: 419 419 return IRQ_ACCEPT; 420 break;421 420 case CMD_DECLINE: 422 421 default: -
kernel/generic/src/ipc/sysipc.c
rcb3d641a rfbcfc4da 61 61 { \ 62 62 if (phoneid > IPC_MAX_PHONES) { \ 63 err ;\63 err \ 64 64 } \ 65 65 phone = &TASK->phones[phoneid]; \ … … 122 122 case IPC_M_DATA_READ: 123 123 return 1; 124 break;125 124 default: 126 125 return 0; … … 376 375 phone_t *cloned_phone; 377 376 GET_CHECK_PHONE(cloned_phone, IPC_GET_ARG1(call->data), 378 return ENOENT );377 return ENOENT;); 379 378 phones_lock(cloned_phone, phone); 380 379 if ((cloned_phone->state != IPC_PHONE_CONNECTED) || … … 531 530 unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data) 532 531 { 533 call_t call;532 call_t *call; 534 533 phone_t *phone; 535 534 int res; 536 535 int rc; 537 536 538 GET_CHECK_PHONE(phone, phoneid, return ENOENT );539 540 ipc_call_static_init(&call);541 IPC_SET_METHOD(call .data, method);542 IPC_SET_ARG1(call .data, arg1);543 IPC_SET_ARG2(call .data, arg2);544 IPC_SET_ARG3(call .data, arg3);537 GET_CHECK_PHONE(phone, phoneid, return ENOENT;); 538 539 call = ipc_call_alloc(0); 540 IPC_SET_METHOD(call->data, method); 541 IPC_SET_ARG1(call->data, arg1); 542 IPC_SET_ARG2(call->data, arg2); 543 IPC_SET_ARG3(call->data, arg3); 545 544 /* 546 545 * To achieve deterministic behavior, zero out arguments that are beyond 547 546 * the limits of the fast version. 548 547 */ 549 IPC_SET_ARG4(call .data, 0);550 IPC_SET_ARG5(call .data, 0);551 552 if (!(res = request_preprocess( &call, phone))) {548 IPC_SET_ARG4(call->data, 0); 549 IPC_SET_ARG5(call->data, 0); 550 551 if (!(res = request_preprocess(call, phone))) { 553 552 #ifdef CONFIG_UDEBUG 554 553 udebug_stoppable_begin(); 555 554 #endif 556 rc = ipc_call_sync(phone, &call);555 rc = ipc_call_sync(phone, call); 557 556 #ifdef CONFIG_UDEBUG 558 557 udebug_stoppable_end(); 559 558 #endif 560 if (rc != EOK) 559 if (rc != EOK) { 560 /* The call will be freed by ipc_cleanup(). */ 561 561 return rc; 562 process_answer(&call); 562 } 563 process_answer(call); 563 564 564 565 } else { 565 IPC_SET_RETVAL(call.data, res); 566 } 567 rc = STRUCT_TO_USPACE(&data->args, &call.data.args); 566 IPC_SET_RETVAL(call->data, res); 567 } 568 rc = STRUCT_TO_USPACE(&data->args, &call->data.args); 569 ipc_call_free(call); 568 570 if (rc != 0) 569 571 return rc; … … 584 586 ipc_data_t *reply) 585 587 { 586 call_t call;588 call_t *call; 587 589 phone_t *phone; 588 590 int res; 589 591 int rc; 590 592 591 ipc_call_static_init(&call); 592 rc = copy_from_uspace(&call.data.args, &question->args, 593 sizeof(call.data.args)); 594 if (rc != 0) 593 GET_CHECK_PHONE(phone, phoneid, return ENOENT;); 594 595 call = ipc_call_alloc(0); 596 rc = copy_from_uspace(&call->data.args, &question->args, 597 sizeof(call->data.args)); 598 if (rc != 0) { 599 ipc_call_free(call); 595 600 return (unative_t) rc; 596 597 GET_CHECK_PHONE(phone, phoneid, return ENOENT); 598 599 if (!(res = request_preprocess( &call, phone))) {601 } 602 603 604 if (!(res = request_preprocess(call, phone))) { 600 605 #ifdef CONFIG_UDEBUG 601 606 udebug_stoppable_begin(); 602 607 #endif 603 rc = ipc_call_sync(phone, &call);608 rc = ipc_call_sync(phone, call); 604 609 #ifdef CONFIG_UDEBUG 605 610 udebug_stoppable_end(); 606 611 #endif 607 if (rc != EOK) 612 if (rc != EOK) { 613 /* The call will be freed by ipc_cleanup(). */ 608 614 return rc; 609 process_answer(&call); 615 } 616 process_answer(call); 610 617 } else 611 IPC_SET_RETVAL(call.data, res); 612 613 rc = STRUCT_TO_USPACE(&reply->args, &call.data.args); 618 IPC_SET_RETVAL(call->data, res); 619 620 rc = STRUCT_TO_USPACE(&reply->args, &call->data.args); 621 ipc_call_free(call); 614 622 if (rc != 0) 615 623 return rc; … … 658 666 return IPC_CALLRET_TEMPORARY; 659 667 660 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL );668 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL;); 661 669 662 670 call = ipc_call_alloc(0); … … 697 705 return IPC_CALLRET_TEMPORARY; 698 706 699 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL );707 GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL;); 700 708 701 709 call = ipc_call_alloc(0); … … 747 755 call->flags |= IPC_CALL_FORWARDED; 748 756 749 GET_CHECK_PHONE(phone, phoneid, { 757 GET_CHECK_PHONE(phone, phoneid, { 750 758 IPC_SET_RETVAL(call->data, EFORWARD); 751 759 ipc_answer(&TASK->answerbox, call); … … 952 960 phone_t *phone; 953 961 954 GET_CHECK_PHONE(phone, phoneid, return ENOENT );962 GET_CHECK_PHONE(phone, phoneid, return ENOENT;); 955 963 956 964 if (ipc_phone_hangup(phone)) … … 991 999 992 1000 if (call->flags & IPC_CALL_NOTIF) { 993 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));994 995 1001 /* Set in_phone_hash to the interrupt counter */ 996 1002 call->data.phone = (void *) call->priv; … … 1005 1011 if (call->flags & IPC_CALL_ANSWERED) { 1006 1012 process_answer(call); 1007 1008 ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));1009 1013 1010 1014 if (call->flags & IPC_CALL_DISCARD_ANSWER) { -
kernel/generic/src/lib/elf.c
rcb3d641a rfbcfc4da 163 163 case PT_LOAD: 164 164 return load_segment(entry, elf, as); 165 break;166 165 case PT_DYNAMIC: 167 166 case PT_INTERP: … … 182 181 default: 183 182 return EE_UNSUPPORTED; 184 break;185 183 } 186 184 return EE_OK; -
kernel/generic/src/lib/string.c
rcb3d641a rfbcfc4da 537 537 * null-terminated and containing only complete characters. 538 538 * 539 * @param d st Destination buffer.539 * @param dest Destination buffer. 540 540 * @param count Size of the destination buffer (must be > 0). 541 541 * @param src Source string. … … 571 571 * have to be null-terminated. 572 572 * 573 * @param d st Destination buffer.573 * @param dest Destination buffer. 574 574 * @param count Size of the destination buffer (must be > 0). 575 575 * @param src Source string. … … 596 596 } 597 597 598 /** Copy NULL-terminated wide string to string 599 * 600 * Copy source wide string @a src to destination buffer @a dst. 601 * No more than @a size bytes are written. NULL-terminator is always 602 * written after the last succesfully copied character (i.e. if the 603 * destination buffer is has at least 1 byte, it will be always 604 * NULL-terminated). 605 * 606 * @param src Source wide string. 607 * @param dst Destination buffer. 608 * @param count Size of the destination buffer. 609 * 610 */ 611 void wstr_nstr(char *dst, const wchar_t *src, size_t size) 612 { 613 /* No space for the NULL-terminator in the buffer */ 614 if (size == 0) 615 return; 616 598 /** Convert wide string to string. 599 * 600 * Convert wide string @a src to string. The output is written to the buffer 601 * specified by @a dest and @a size. @a size must be non-zero and the string 602 * written will always be well-formed. 603 * 604 * @param dest Destination buffer. 605 * @param size Size of the destination buffer. 606 * @param src Source wide string. 607 */ 608 void wstr_to_str(char *dest, size_t size, const wchar_t *src) 609 { 617 610 wchar_t ch; 618 size_t src_idx = 0; 619 size_t dst_off = 0; 611 size_t src_idx; 612 size_t dest_off; 613 614 /* There must be space for a null terminator in the buffer. */ 615 ASSERT(size > 0); 616 617 src_idx = 0; 618 dest_off = 0; 620 619 621 620 while ((ch = src[src_idx++]) != 0) { 622 if (chr_encode(ch, d st, &dst_off, size) != EOK)621 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) 623 622 break; 624 623 } 625 626 if (dst_off >= size) 627 dst[size - 1] = 0; 628 else 629 dst[dst_off] = 0; 624 625 dest[dest_off] = '\0'; 630 626 } 631 627 -
kernel/generic/src/mm/backend_phys.c
rcb3d641a rfbcfc4da 40 40 #include <arch/types.h> 41 41 #include <mm/as.h> 42 #include <mm/page.h> 42 43 #include <mm/frame.h> 43 44 #include <mm/slab.h> -
kernel/generic/src/proc/task.c
rcb3d641a rfbcfc4da 54 54 #include <func.h> 55 55 #include <string.h> 56 #include <memstr.h> 56 57 #include <syscall/copy.h> 57 58 #include <macros.h> … … 75 76 static task_id_t task_counter = 0; 76 77 78 static slab_cache_t *task_slab; 79 77 80 /* Forward declarations. */ 78 81 static void task_kill_internal(task_t *); 82 static int tsk_constructor(void *, int); 79 83 80 84 /** Initialize kernel tasks support. */ … … 83 87 TASK = NULL; 84 88 avltree_create(&tasks_tree); 89 task_slab = slab_cache_create("task_slab", sizeof(task_t), 0, 90 tsk_constructor, NULL, 0); 85 91 } 86 92 … … 128 134 } 129 135 136 int tsk_constructor(void *obj, int kmflags) 137 { 138 task_t *ta = obj; 139 int i; 140 141 atomic_set(&ta->refcount, 0); 142 atomic_set(&ta->lifecount, 0); 143 atomic_set(&ta->active_calls, 0); 144 145 spinlock_initialize(&ta->lock, "task_ta_lock"); 146 mutex_initialize(&ta->futexes_lock, MUTEX_PASSIVE); 147 148 list_initialize(&ta->th_head); 149 list_initialize(&ta->sync_box_head); 150 151 ipc_answerbox_init(&ta->answerbox, ta); 152 for (i = 0; i < IPC_MAX_PHONES; i++) 153 ipc_phone_init(&ta->phones[i]); 154 155 #ifdef CONFIG_UDEBUG 156 /* Init kbox stuff */ 157 ta->kb.thread = NULL; 158 ipc_answerbox_init(&ta->kb.box, ta); 159 mutex_initialize(&ta->kb.cleanup_lock, MUTEX_PASSIVE); 160 #endif 161 162 return 0; 163 } 164 130 165 /** Create new task with no threads. 131 166 * … … 140 175 ipl_t ipl; 141 176 task_t *ta; 142 int i; 143 144 ta = (task_t *) malloc(sizeof(task_t), 0); 145 177 178 ta = (task_t *) slab_alloc(task_slab, 0); 146 179 task_create_arch(ta); 147 148 spinlock_initialize(&ta->lock, "task_ta_lock");149 list_initialize(&ta->th_head);150 180 ta->as = as; 151 152 181 memcpy(ta->name, name, TASK_NAME_BUFLEN); 153 182 ta->name[TASK_NAME_BUFLEN - 1] = 0; 154 183 155 atomic_set(&ta->refcount, 0);156 atomic_set(&ta->lifecount, 0);157 184 ta->context = CONTEXT; 158 159 185 ta->capabilities = 0; 160 186 ta->cycles = 0; … … 165 191 166 192 /* Init kbox stuff */ 167 ipc_answerbox_init(&ta->kb.box, ta);168 ta->kb.thread = NULL;169 mutex_initialize(&ta->kb.cleanup_lock, MUTEX_PASSIVE);170 193 ta->kb.finished = false; 171 194 #endif 172 195 173 ipc_answerbox_init(&ta->answerbox, ta); 174 for (i = 0; i < IPC_MAX_PHONES; i++) 175 ipc_phone_init(&ta->phones[i]); 176 if ((ipc_phone_0) && (context_check(ipc_phone_0->task->context, 177 ta->context))) 196 if ((ipc_phone_0) && 197 (context_check(ipc_phone_0->task->context, ta->context))) 178 198 ipc_phone_connect(&ta->phones[0], ipc_phone_0); 179 atomic_set(&ta->active_calls, 0); 180 181 mutex_initialize(&ta->futexes_lock, MUTEX_PASSIVE); 199 182 200 btree_create(&ta->futexes); 183 201 184 202 ipl = interrupts_disable(); 185 186 /*187 * Increment address space reference count.188 */189 203 atomic_inc(&as->refcount); 190 191 204 spinlock_lock(&tasks_lock); 192 205 ta->taskid = ++task_counter; … … 229 242 as_destroy(t->as); 230 243 231 free(t);244 slab_free(task_slab, t); 232 245 TASK = NULL; 233 246 } -
kernel/generic/src/proc/thread.c
rcb3d641a rfbcfc4da 501 501 void thread_sleep(uint32_t sec) 502 502 { 503 thread_usleep(sec * 1000000); 503 /* Sleep in 1000 second steps to support 504 full argument range */ 505 while (sec > 0) { 506 uint32_t period = (sec > 1000) ? 1000 : sec; 507 508 thread_usleep(period * 1000000); 509 sec -= period; 510 } 504 511 } 505 512 … … 575 582 { 576 583 waitq_t wq; 577 584 578 585 waitq_initialize(&wq); 579 586 580 587 (void) waitq_sleep_timeout(&wq, usec, SYNCH_FLAGS_NON_BLOCKING); 581 588 } … … 812 819 } 813 820 821 /** Syscall wrapper for sleeping. */ 822 unative_t sys_thread_usleep(uint32_t usec) 823 { 824 thread_usleep(usec); 825 return 0; 826 } 827 814 828 /** @} 815 829 */ -
kernel/generic/src/synch/futex.c
rcb3d641a rfbcfc4da 90 90 /** Initialize kernel futex structure. 91 91 * 92 * @param futex 92 * @param futex Kernel futex structure. 93 93 */ 94 94 void futex_initialize(futex_t *futex) … … 102 102 /** Sleep in futex wait queue. 103 103 * 104 * @param uaddr Userspace address of the futex counter. 105 * @param usec If non-zero, number of microseconds this thread is willing to 106 * sleep. 107 * @param flags Select mode of operation. 108 * 109 * @return One of ESYNCH_TIMEOUT, ESYNCH_OK_ATOMIC and ESYNCH_OK_BLOCKED. See 110 * synch.h. If there is no physical mapping for uaddr ENOENT is returned. 111 */ 112 unative_t sys_futex_sleep_timeout(uintptr_t uaddr, uint32_t usec, int flags) 104 * @param uaddr Userspace address of the futex counter. 105 * 106 * @return If there is no physical mapping for uaddr ENOENT is 107 * returned. Otherwise returns a wait result as defined in 108 * synch.h. 109 */ 110 unative_t sys_futex_sleep(uintptr_t uaddr) 113 111 { 114 112 futex_t *futex; … … 140 138 udebug_stoppable_begin(); 141 139 #endif 142 rc = waitq_sleep_timeout(&futex->wq, usec, flags | 143 SYNCH_FLAGS_INTERRUPTIBLE); 144 140 rc = waitq_sleep_timeout(&futex->wq, 0, SYNCH_FLAGS_INTERRUPTIBLE); 145 141 #ifdef CONFIG_UDEBUG 146 142 udebug_stoppable_end(); … … 151 147 /** Wakeup one thread waiting in futex wait queue. 152 148 * 153 * @param uaddr 154 * 155 * @return 149 * @param uaddr Userspace address of the futex counter. 150 * 151 * @return ENOENT if there is no physical mapping for uaddr. 156 152 */ 157 153 unative_t sys_futex_wakeup(uintptr_t uaddr) … … 190 186 * If the structure does not exist already, a new one is created. 191 187 * 192 * @param paddr 193 * 194 * @return 188 * @param paddr Physical address of the userspace futex counter. 189 * 190 * @return Address of the kernel futex structure. 195 191 */ 196 192 futex_t *futex_find(uintptr_t paddr) … … 284 280 /** Compute hash index into futex hash table. 285 281 * 286 * @param key Address where the key (i.e. physical address of futex counter) is287 * 288 * 289 * @return 282 * @param key Address where the key (i.e. physical address of futex 283 * counter) is stored. 284 * 285 * @return Index into futex hash table. 290 286 */ 291 287 size_t futex_ht_hash(unative_t *key) … … 296 292 /** Compare futex hash table item with a key. 297 293 * 298 * @param key Address where the key (i.e. physical address of futex counter) is299 * 300 * 301 * @return 294 * @param key Address where the key (i.e. physical address of futex 295 * counter) is stored. 296 * 297 * @return True if the item matches the key. False otherwise. 302 298 */ 303 299 bool futex_ht_compare(unative_t *key, size_t keys, link_t *item) … … 313 309 /** Callback for removal items from futex hash table. 314 310 * 315 * @param item 311 * @param item Item removed from the hash table. 316 312 */ 317 313 void futex_ht_remove_callback(link_t *item) -
kernel/generic/src/syscall/syscall.c
rcb3d641a rfbcfc4da 111 111 (syshandler_t) sys_thread_exit, 112 112 (syshandler_t) sys_thread_get_id, 113 (syshandler_t) sys_thread_usleep, 113 114 114 115 (syshandler_t) sys_task_get_id, … … 117 118 118 119 /* Synchronization related syscalls. */ 119 (syshandler_t) sys_futex_sleep _timeout,120 (syshandler_t) sys_futex_sleep, 120 121 (syshandler_t) sys_futex_wakeup, 121 122 (syshandler_t) sys_smc_coherence, -
kernel/generic/src/udebug/udebug_ops.c
rcb3d641a rfbcfc4da 50 50 #include <udebug/udebug.h> 51 51 #include <udebug/udebug_ops.h> 52 #include <memstr.h> 52 53 53 54 /**
Note:
See TracChangeset
for help on using the changeset viewer.