Changeset 201abde in mainline


Ignore:
Timestamp:
2007-04-07T20:06:52Z (18 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7e58979
Parents:
6adbe3c2
Message:

make thread ID 64 bit (task ID is 64 bit already)
cleanup thread syscalls

Files:
32 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/arm32/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/ia32/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/ia32xen/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/ia64/include/types.h

    r6adbe3c2 r201abde  
    7171
    7272typedef uint8_t bool;
     73typedef uint64_t thread_id_t;
    7374typedef uint64_t task_id_t;
    7475typedef uint32_t context_id_t;

  • kernel/arch/mips32/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/ppc32/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/ppc64/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/arch/sparc64/include/types.h

    r6adbe3c2 r201abde  
    6363
    6464typedef uint8_t bool;
     65typedef uint64_t thread_id_t;
    6566typedef uint64_t task_id_t;
    6667typedef uint32_t context_id_t;

  • kernel/generic/include/interrupt.h

    r6adbe3c2 r201abde  
    4949{ \
    5050        if (istate_from_uspace(istate)) { \
    51                 klog_printf("Task %lld killed due to an exception at %p.", TASK->taskid, istate_get_pc(istate)); \
     51                klog_printf("Task %llu killed due to an exception at %p.", TASK->taskid, istate_get_pc(istate)); \
    5252                klog_printf("  " cmd, ##__VA_ARGS__); \
    5353                task_kill(TASK->taskid); \

  • kernel/generic/include/proc/task.h

    r6adbe3c2 r201abde  
    9191         * certain extent.
    9292         */
    93         atomic_t active_calls; 
     93        atomic_t active_calls;
    9494       
    9595        /** Architecture specific task data. */
    96         task_arch_t arch;       
     96        task_arch_t arch;
    9797       
    9898        /**

  • kernel/generic/include/proc/thread.h

    r6adbe3c2 r201abde  
    194194        int priority;
    195195        /** Thread ID. */
    196         uint32_t tid;
     196        thread_id_t tid;
    197197       
    198198        /** Architecture-specific data. */
    … …  
    249249
    250250/* Thread syscall prototypes. */
    251 unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name);
    252 unative_t sys_thread_exit(int uspace_status);
    253 unative_t sys_thread_get_id(void);
     251extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id);
     252extern unative_t sys_thread_exit(int uspace_status);
     253extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);
    254254
    255255#endif

  • kernel/generic/src/adt/btree.c

    r6adbe3c2 r201abde  
    971971                printf("(");
    972972                for (i = 0; i < node->keys; i++) {
    973                         printf("%lld%s", node->key[i], i < node->keys - 1 ? "," : "");
     973                        printf("%llu%s", node->key[i], i < node->keys - 1 ? "," : "");
    974974                        if (node->depth && node->subtree[i]) {
    975975                                list_append(&node->subtree[i]->bfs_link, &head);
    … …  
    993993                printf("(");
    994994                for (i = 0; i < node->keys; i++)
    995                         printf("%lld%s", node->key[i], i < node->keys - 1 ? "," : "");
     995                        printf("%llu%s", node->key[i], i < node->keys - 1 ? "," : "");
    996996                printf(")");
    997997        }

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

    r6adbe3c2 r201abde  
    714714int cmd_set4(cmd_arg_t *argv)
    715715{
    716         uint32_t *addr ;
     716        uint32_t *addr;
    717717        uint32_t arg1 = argv[1].intval;
    718718        bool pointer = false;

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

    r6adbe3c2 r201abde  
    503503        for (tmp=task->answerbox.calls.next; tmp != &task->answerbox.calls;tmp = tmp->next) {
    504504                call = list_get_instance(tmp, call_t, link);
    505                 printf("Callid: %p Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
     505                printf("Callid: %p Srctask:%llu M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
    506506                       call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
    507507                       IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);
    … …  
    513513             tmp = tmp->next) {
    514514                call = list_get_instance(tmp, call_t, link);
    515                 printf("Callid: %p Srctask:%lld M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
     515                printf("Callid: %p Srctask:%llu M:%d A1:%d A2:%d A3:%d Flags:%x\n",call,
    516516                       call->sender->taskid, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
    517517                       IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), call->flags);

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

    r6adbe3c2 r201abde  
    451451                         * Entering state is unexpected.
    452452                         */
    453                         panic("tid%d: unexpected state %s\n", THREAD->tid,
     453                        panic("tid%llu: unexpected state %s\n", THREAD->tid,
    454454                                thread_states[THREAD->state]);
    455455                        break;
    … …  
    504504
    505505#ifdef SCHEDULER_VERBOSE
    506         printf("cpu%d: tid %d (priority=%d, ticks=%lld, nrdy=%ld)\n",
     506        printf("cpu%d: tid %llu (priority=%d, ticks=%llu, nrdy=%ld)\n",
    507507            CPU->id, THREAD->tid, THREAD->priority, THREAD->ticks,
    508508            atomic_get(&CPU->nrdy));
    … …  
    640640                                spinlock_lock(&t->lock);
    641641#ifdef KCPULB_VERBOSE
    642                                 printf("kcpulb%d: TID %d -> cpu%d, nrdy=%ld, "
     642                                printf("kcpulb%d: TID %llu -> cpu%d, nrdy=%ld, "
    643643                                    "avg=%nd\n", CPU->id, t->tid, CPU->id,
    644644                                    atomic_get(&CPU->nrdy),
    … …  
    723723                                cur = cur->next) {
    724724                                t = list_get_instance(cur, thread_t, rq_link);
    725                                 printf("%d(%s) ", t->tid,
     725                                printf("%llu(%s) ", t->tid,
    726726                                    thread_states[t->state]);
    727727                        }

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

    r6adbe3c2 r201abde  
    400400                        order(task_get_accounting(t), &cycles, &suffix);
    401401                       
    402                         printf("%-6lld %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
     402                        printf("%-6llu %-10s %-3ld %#10zx %#10zx %9llu%c %7zd "
    403403                            "%6zd", t->taskid, t->name, t->context, t, t->as,
    404404                            cycles, suffix, t->refcount,
    … …  
    487487        ipc_cleanup();
    488488        futex_cleanup();
    489         klog_printf("Cleanup of task %lld completed.", TASK->taskid);
     489        klog_printf("Cleanup of task %llu completed.", TASK->taskid);
    490490}
    491491

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

    r6adbe3c2 r201abde  
    9595
    9696SPINLOCK_INITIALIZE(tidlock);
    97 uint32_t last_tid = 0;
     97thread_id_t last_tid = 0;
    9898
    9999static slab_cache_t *thread_slab;
    … …  
    581581                        order(t->cycles, &cycles, &suffix);
    582582                       
    583                         printf("%-6zd %-10s %#10zx %-8s %#10zx %-3ld %#10zx "
     583                        printf("%-6llu %-10s %#10zx %-8s %#10zx %-3ld %#10zx "
    584584                            "%#10zx %9llu%c ", t->tid, t->name, t,
    585585                            thread_states[t->state], t->task, t->task->context,
    … …  
    637637 *
    638638 */
    639 unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
     639unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id)
    640640{
    641641        thread_t *t;
    642642        char namebuf[THREAD_NAME_BUFLEN];
    643643        uspace_arg_t *kernel_uarg;
    644         uint32_t tid;
    645644        int rc;
    646645
    … …  
    659658            false);
    660659        if (t) {
    661                 tid = t->tid;
    662660                thread_ready(t);
    663                 return (unative_t) tid;
    664         } else {
     661                if (uspace_thread_id != NULL)
     662                        return (unative_t) copy_to_uspace(uspace_thread_id, &t->tid,
     663                        sizeof(t->tid));
     664                else
     665                        return 0;
     666        } else
    665667                free(kernel_uarg);
    666         }
    667668
    668669        return (unative_t) ENOMEM;
    … …  
    681682/** Syscall for getting TID.
    682683 *
    683  * @return Thread ID.
    684  */
    685 unative_t sys_thread_get_id(void)
     684 * @param uspace_thread_id Userspace address of 8-byte buffer where to store
     685 * current thread ID.
     686 *
     687 * @return 0 on success or an error code from @ref errno.h.
     688 */
     689unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
    686690{
    687691        /*
    … …  
    689693         * remains constant for the lifespan of the thread.
    690694         */
    691         return THREAD->tid;
     695        return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
     696            sizeof(THREAD->tid));
    692697}
    693698

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

    r6adbe3c2 r201abde  
    101101                rc = syscall_table[id](a1, a2, a3, a4);
    102102        else {
    103                 klog_printf("TASK %lld: Unknown syscall id %d",TASK->taskid,id);
     103                klog_printf("TASK %llu: Unknown syscall id %d",TASK->taskid,id);
    104104                task_kill(TASK->taskid);
    105105                thread_exit();

  • kernel/test/fpu/fpu1.c

    r6adbe3c2 r201abde  
    127127                if ((int) (100000000 * e) != E_10e8) {
    128128                        if (!sh_quiet)
    129                                 printf("tid%d: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
     129                                printf("tid%llu: e*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
    130130                        atomic_inc(&threads_fault);
    131131                        break;
    … …  
    162162                if ((int) (1000000 * pi) != PI_10e8) {
    163163                        if (!sh_quiet)
    164                                 printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
     164                                printf("tid%llu: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
    165165                        atomic_inc(&threads_fault);
    166166                        break;
    … …  
    169169                if ((int) (100000000 * pi) != PI_10e8) {
    170170                        if (!sh_quiet)
    171                                 printf("tid%d: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
     171                                printf("tid%llu: pi*10e8=%zd should be %zd\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
    172172                        atomic_inc(&threads_fault);
    173173                        break;

  • kernel/test/fpu/mips2.c

    r6adbe3c2 r201abde  
    7373                if (arg != after_arg) {
    7474                        if (!sh_quiet)
    75                                 printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     75                                printf("General reg tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
    7676                        atomic_inc(&threads_fault);
    7777                        break;
    … …  
    105105                if (arg != after_arg) {
    106106                        if (!sh_quiet)
    107                                 printf("General reg tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     107                                printf("General reg tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
    108108                        atomic_inc(&threads_fault);
    109109                        break;

  • kernel/test/fpu/sse1.c

    r6adbe3c2 r201abde  
    7373                if (arg != after_arg) {
    7474                        if (!sh_quiet)
    75                                 printf("tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     75                                printf("tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
    7676                        atomic_inc(&threads_fault);
    7777                        break;
    … …  
    105105                if (arg != after_arg) {
    106106                        if (!sh_quiet)
    107                                 printf("tid%d: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
     107                                printf("tid%llu: arg(%d) != %d\n", THREAD->tid, arg, after_arg);
    108108                        atomic_inc(&threads_fault);
    109109                        break;

  • kernel/test/mm/falloc2.c

    r6adbe3c2 r201abde  
    5959        if (frames == NULL) {
    6060                if (!sh_quiet)
    61                         printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
     61                        printf("Thread #%llu (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
    6262                atomic_inc(&thread_fail);
    6363                atomic_dec(&thread_count);
    … …  
    7070                for (order = 0; order <= MAX_ORDER; order++) {
    7171                        if (!sh_quiet)
    72                                 printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
     72                                printf("Thread #%llu (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
    7373                       
    7474                        allocated = 0;
    … …  
    8383                       
    8484                        if (!sh_quiet)
    85                                 printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
     85                                printf("Thread #%llu (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
    8686                       
    8787                        if (!sh_quiet)
    88                                 printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
     88                                printf("Thread #%llu (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
    8989                       
    9090                        for (i = 0; i < allocated; i++) {
    … …  
    9292                                        if (((uint8_t *) frames[i])[k] != val) {
    9393                                                if (!sh_quiet)
    94                                                         printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
     94                                                        printf("Thread #%llu (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
    9595                                                atomic_inc(&thread_fail);
    9696                                                goto cleanup;
    … …  
    101101                       
    102102                        if (!sh_quiet)
    103                                 printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
     103                                printf("Thread #%llu (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
    104104                }
    105105        }
    … …  
    109109       
    110110        if (!sh_quiet)
    111                 printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
     111                printf("Thread #%llu (cpu%d): Exiting\n", THREAD->tid, CPU->id);
    112112        atomic_dec(&thread_count);
    113113}

  • kernel/test/mm/slab1.c

    r6adbe3c2 r201abde  
    138138       
    139139        if (!sh_quiet)
    140                 printf("Starting thread #%d...\n", THREAD->tid);
     140                printf("Starting thread #%llu...\n", THREAD->tid);
    141141       
    142142        for (j = 0; j < 10; j++) {
    … …  
    152152       
    153153        if (!sh_quiet)
    154                 printf("Thread #%d finished\n", THREAD->tid);
     154                printf("Thread #%llu finished\n", THREAD->tid);
    155155       
    156156        semaphore_up(&thr_sem);

  • kernel/test/mm/slab2.c

    r6adbe3c2 r201abde  
    151151       
    152152        if (!sh_quiet)
    153                 printf("Starting thread #%d...\n",THREAD->tid);
     153                printf("Starting thread #%llu...\n",THREAD->tid);
    154154
    155155        /* Alloc all */
    156156        if (!sh_quiet)
    157                 printf("Thread #%d allocating...\n", THREAD->tid);
     157                printf("Thread #%llu allocating...\n", THREAD->tid);
    158158       
    159159        while (1) {
    … …  
    167167       
    168168        if (!sh_quiet)
    169                 printf("Thread #%d releasing...\n", THREAD->tid);
     169                printf("Thread #%llu releasing...\n", THREAD->tid);
    170170       
    171171        while (data) {
    … …  
    177177       
    178178        if (!sh_quiet)
    179                 printf("Thread #%d allocating...\n", THREAD->tid);
     179                printf("Thread #%llu allocating...\n", THREAD->tid);
    180180       
    181181        while (1) {
    … …  
    189189       
    190190        if (!sh_quiet)
    191                 printf("Thread #%d releasing...\n", THREAD->tid);
     191                printf("Thread #%llu releasing...\n", THREAD->tid);
    192192       
    193193        while (data) {
    … …  
    199199       
    200200        if (!sh_quiet)
    201                 printf("Thread #%d finished\n", THREAD->tid);
     201                printf("Thread #%llu finished\n", THREAD->tid);
    202202       
    203203        slab_print_list();

  • kernel/test/synch/rwlock3.c

    r6adbe3c2 r201abde  
    4646       
    4747        if (!sh_quiet)
    48                 printf("cpu%d, tid %d: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
     48                printf("cpu%d, tid %llu: trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
    4949       
    5050        rwlock_read_lock(&rwlock);
    … …  
    5252       
    5353        if (!sh_quiet) {
    54                 printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);               
    55                 printf("cpu%d, tid %d: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);         
     54                printf("cpu%d, tid %llu: success\n", CPU->id, THREAD->tid);             
     55                printf("cpu%d, tid %llu: trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);       
    5656        }
    5757
    … …  
    6060       
    6161        if (!sh_quiet)
    62                 printf("cpu%d, tid %d: success\n", CPU->id, THREAD->tid);
     62                printf("cpu%d, tid %llu: success\n", CPU->id, THREAD->tid);
    6363       
    6464        atomic_dec(&thread_count);

  • kernel/test/synch/rwlock4.c

    r6adbe3c2 r201abde  
    7575       
    7676        if (!sh_quiet)
    77                 printf("cpu%d, tid %d w+ (%d)\n", CPU->id, THREAD->tid, to);
     77                printf("cpu%d, tid %llu w+ (%d)\n", CPU->id, THREAD->tid, to);
    7878       
    7979        rc = rwlock_write_lock_timeout(&rwlock, to);
    8080        if (SYNCH_FAILED(rc)) {
    8181                if (!sh_quiet)
    82                         printf("cpu%d, tid %d w!\n", CPU->id, THREAD->tid);
     82                        printf("cpu%d, tid %llu w!\n", CPU->id, THREAD->tid);
    8383                atomic_dec(&thread_count);
    8484                return;
    … …  
    8686       
    8787        if (!sh_quiet)
    88                 printf("cpu%d, tid %d w=\n", CPU->id, THREAD->tid);
     88                printf("cpu%d, tid %llu w=\n", CPU->id, THREAD->tid);
    8989
    9090        if (rwlock.readers_in) {
    … …  
    107107       
    108108        if (!sh_quiet)
    109                 printf("cpu%d, tid %d w-\n", CPU->id, THREAD->tid);
     109                printf("cpu%d, tid %llu w-\n", CPU->id, THREAD->tid);
    110110        atomic_dec(&thread_count);
    111111}
    … …  
    120120       
    121121        if (!sh_quiet)
    122                 printf("cpu%d, tid %d r+ (%d)\n", CPU->id, THREAD->tid, to);
     122                printf("cpu%d, tid %llu r+ (%d)\n", CPU->id, THREAD->tid, to);
    123123       
    124124        rc = rwlock_read_lock_timeout(&rwlock, to);
    125125        if (SYNCH_FAILED(rc)) {
    126126                if (!sh_quiet)
    127                         printf("cpu%d, tid %d r!\n", CPU->id, THREAD->tid);
     127                        printf("cpu%d, tid %llu r!\n", CPU->id, THREAD->tid);
    128128                atomic_dec(&thread_count);
    129129                return;
    … …  
    131131       
    132132        if (!sh_quiet)
    133                 printf("cpu%d, tid %d r=\n", CPU->id, THREAD->tid);
     133                printf("cpu%d, tid %llu r=\n", CPU->id, THREAD->tid);
    134134       
    135135        thread_usleep(30000);
    … …  
    137137       
    138138        if (!sh_quiet)
    139                 printf("cpu%d, tid %d r-\n", CPU->id, THREAD->tid);
     139                printf("cpu%d, tid %llu r-\n", CPU->id, THREAD->tid);
    140140        atomic_dec(&thread_count);
    141141}

  • kernel/test/synch/semaphore2.c

    r6adbe3c2 r201abde  
    6868       
    6969        to = random(20000);
    70         printf("cpu%d, tid %d down+ (%d)\n", CPU->id, THREAD->tid, to);
     70        printf("cpu%d, tid %llu down+ (%d)\n", CPU->id, THREAD->tid, to);
    7171        rc = semaphore_down_timeout(&sem, to);
    7272        if (SYNCH_FAILED(rc)) {
    73                 printf("cpu%d, tid %d down!\n", CPU->id, THREAD->tid);
     73                printf("cpu%d, tid %llu down!\n", CPU->id, THREAD->tid);
    7474                return;
    7575        }
    7676       
    77         printf("cpu%d, tid %d down=\n", CPU->id, THREAD->tid); 
     77        printf("cpu%d, tid %llu down=\n", CPU->id, THREAD->tid);       
    7878        thread_usleep(random(30000));
    7979       
    8080        semaphore_up(&sem);
    81         printf("cpu%d, tid %d up\n", CPU->id, THREAD->tid);
     81        printf("cpu%d, tid %llu up\n", CPU->id, THREAD->tid);
    8282}
    8383

  • kernel/test/thread/thread1.c

    r6adbe3c2 r201abde  
    4949        while (atomic_get(&finish)) {
    5050                if (!sh_quiet)
    51                         printf("%d ", (int) (THREAD->tid));
     51                        printf("%llu ", THREAD->tid);
    5252                thread_usleep(100000);
    5353        }

  • uspace/libc/generic/thread.c

    r6adbe3c2 r201abde  
    125125 * @param arg Argument to be passed to thread.
    126126 * @param name Symbolic name of the thread.
    127  *
    128  * @return TID of the new thread on success or -1 on failure.
    129  */
    130 int thread_create(void (* function)(void *), void *arg, char *name)
     127 * @param tid Thread ID of the newly created thread.
     128 *
     129 * @return Zero on success or a code from @ref errno.h on failure.
     130 */
     131int thread_create(void (* function)(void *), void *arg, char *name, thread_id_t *tid)
    131132{
    132133        char *stack;
    … …  
    149150        uarg->uspace_uarg = uarg;
    150151       
    151         return __SYSCALL2(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name);
     152        return __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name, (sysarg_t) tid);
    152153}
    153154
    … …  
    167168 * @param thread TID.
    168169 */
    169 void thread_detach(int thread)
     170void thread_detach(thread_id_t thread)
    170171{
    171172}
    … …  
    179180 * @return Thread exit status.
    180181 */
    181 int thread_join(int thread)
     182int thread_join(thread_id_t thread)
    182183{
    183184}
    … …  
    187188 * @return Current thread ID.
    188189 */
    189 int thread_get_id(void)
    190 {
    191         return __SYSCALL0(SYS_THREAD_GET_ID);
     190thread_id_t thread_get_id(void)
     191{
     192        thread_id_t thread_id;
     193
     194        (void) __SYSCALL1(SYS_THREAD_GET_ID, (sysarg_t) &thread_id);
     195
     196        return thread_id;
    192197}
    193198

  • uspace/libc/include/thread.h

    r6adbe3c2 r201abde  
    4040#include <types.h>
    4141
     42typedef uint64_t thread_id_t;
     43
    4244extern void __thread_entry(void);
    4345extern void __thread_main(uspace_arg_t *uarg);
    4446
    45 extern int thread_create(void (* function)(void *arg), void *arg, char *name);
     47extern int thread_create(void (* function)(void *), void *arg, char *name, thread_id_t *tid);
    4648extern void thread_exit(int status);
    47 extern void thread_detach(int thread);
    48 extern int thread_join(int thread);
    49 extern int thread_get_id(void);
     49extern void thread_detach(thread_id_t thread);
     50extern int thread_join(thread_id_t thread);
     51extern thread_id_t thread_get_id(void);
    5052extern tcb_t * __make_tls(void);
    5153extern tcb_t * __alloc_tls(void **data, size_t size);

  • uspace/tester/thread/thread1.c

    r6adbe3c2 r201abde  
    4646        while (atomic_get(&finish)) {
    4747                if (!sh_quiet)
    48                         printf("%d ", thread_get_id());
     48                        printf("%llu ", thread_get_id());
    4949                usleep(100000);
    5050        }
    … …  
    6161
    6262        for (i = 0; i < THREADS; i++) { 
    63                 int t;
    64                 if ((t = thread_create(threadtest, NULL, "threadtest")) < 0) {
     63                if (thread_create(threadtest, NULL, "threadtest", NULL) < 0) {
    6564                        if (!quiet)
    6665                                printf("Could not create thread %d\n", i);
Note: See TracChangeset for help on using the changeset viewer.