Changes in kernel/generic/src/proc/thread.c [7ed8530:2d3ddad] in mainline
- File:
-
- 1 edited
-
kernel/generic/src/proc/thread.c (modified) (30 diffs)
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/src/proc/thread.c
r7ed8530 r2d3ddad 33 33 /** 34 34 * @file 35 * @brief 35 * @brief Thread management functions. 36 36 */ 37 37 … … 94 94 * 95 95 * For locking rules, see declaration thereof. 96 */ 97 SPINLOCK_INITIALIZE(threads_lock); 96 * 97 */ 98 IRQ_SPINLOCK_INITIALIZE(threads_lock); 98 99 99 100 /** AVL tree of all threads. … … 101 102 * When a thread is found in the threads_tree AVL tree, it is guaranteed to 102 103 * exist as long as the threads_lock is held. 103 */ 104 avltree_t threads_tree; 105 106 SPINLOCK_INITIALIZE(tidlock); 107 thread_id_t last_tid = 0; 104 * 105 */ 106 avltree_t threads_tree; 107 108 IRQ_SPINLOCK_STATIC_INITIALIZE(tidlock); 109 static thread_id_t last_tid = 0; 108 110 109 111 static slab_cache_t *thread_slab; 112 110 113 #ifdef CONFIG_FPU 111 114 slab_cache_t *fpu_context_slab; … … 125 128 void *arg = THREAD->thread_arg; 126 129 THREAD->last_cycle = get_cycle(); 127 130 128 131 /* This is where each thread wakes up after its creation */ 129 spinlock_unlock(&THREAD->lock);132 irq_spinlock_unlock(&THREAD->lock, false); 130 133 interrupts_enable(); 131 134 132 135 f(arg); 133 136 134 137 /* Accumulate accounting to the task */ 135 ipl_t ipl = interrupts_disable(); 136 137 spinlock_lock(&THREAD->lock); 138 irq_spinlock_lock(&THREAD->lock, true); 138 139 if (!THREAD->uncounted) { 139 140 thread_update_accounting(true); … … 142 143 uint64_t kcycles = THREAD->kcycles; 143 144 THREAD->kcycles = 0; 144 145 spinlock_unlock(&THREAD->lock);146 145 147 spinlock_lock(&TASK->lock);146 irq_spinlock_pass(&THREAD->lock, &TASK->lock); 148 147 TASK->ucycles += ucycles; 149 148 TASK->kcycles += kcycles; 150 spinlock_unlock(&TASK->lock);149 irq_spinlock_unlock(&TASK->lock, true); 151 150 } else 152 spinlock_unlock(&THREAD->lock); 153 154 interrupts_restore(ipl); 151 irq_spinlock_unlock(&THREAD->lock, true); 155 152 156 153 thread_exit(); 157 /* not reached */ 158 } 159 160 /** Initialization and allocation for thread_t structure */ 161 static int thr_constructor(void *obj, int kmflags) 162 { 163 thread_t *t = (thread_t *) obj; 164 165 spinlock_initialize(&t->lock, "thread_t_lock"); 166 link_initialize(&t->rq_link); 167 link_initialize(&t->wq_link); 168 link_initialize(&t->th_link); 169 154 155 /* Not reached */ 156 } 157 158 /** Initialization and allocation for thread_t structure 159 * 160 */ 161 static int thr_constructor(void *obj, unsigned int kmflags) 162 { 163 thread_t *thread = (thread_t *) obj; 164 165 irq_spinlock_initialize(&thread->lock, "thread_t_lock"); 166 link_initialize(&thread->rq_link); 167 link_initialize(&thread->wq_link); 168 link_initialize(&thread->th_link); 169 170 170 /* call the architecture-specific part of the constructor */ 171 thr_constructor_arch(t );171 thr_constructor_arch(thread); 172 172 173 173 #ifdef CONFIG_FPU 174 174 #ifdef CONFIG_FPU_LAZY 175 t ->saved_fpu_context = NULL;176 #else 177 t ->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags);178 if (!t ->saved_fpu_context)175 thread->saved_fpu_context = NULL; 176 #else /* CONFIG_FPU_LAZY */ 177 thread->saved_fpu_context = slab_alloc(fpu_context_slab, kmflags); 178 if (!thread->saved_fpu_context) 179 179 return -1; 180 #endif 181 #endif 182 183 t ->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);184 if (!t ->kstack) {180 #endif /* CONFIG_FPU_LAZY */ 181 #endif /* CONFIG_FPU */ 182 183 thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags); 184 if (!thread->kstack) { 185 185 #ifdef CONFIG_FPU 186 if (t ->saved_fpu_context)187 slab_free(fpu_context_slab, t ->saved_fpu_context);186 if (thread->saved_fpu_context) 187 slab_free(fpu_context_slab, thread->saved_fpu_context); 188 188 #endif 189 189 return -1; 190 190 } 191 191 192 192 #ifdef CONFIG_UDEBUG 193 mutex_initialize(&t ->udebug.lock, MUTEX_PASSIVE);194 #endif 195 193 mutex_initialize(&thread->udebug.lock, MUTEX_PASSIVE); 194 #endif 195 196 196 return 0; 197 197 } 198 198 199 199 /** Destruction of thread_t object */ 200 static int thr_destructor(void *obj)201 { 202 thread_t *t = (thread_t *) obj;203 200 static size_t thr_destructor(void *obj) 201 { 202 thread_t *thread = (thread_t *) obj; 203 204 204 /* call the architecture-specific part of the destructor */ 205 thr_destructor_arch(t); 206 207 frame_free(KA2PA(t->kstack)); 205 thr_destructor_arch(thread); 206 207 frame_free(KA2PA(thread->kstack)); 208 208 209 #ifdef CONFIG_FPU 209 if (t->saved_fpu_context) 210 slab_free(fpu_context_slab, t->saved_fpu_context); 211 #endif 212 return 1; /* One page freed */ 210 if (thread->saved_fpu_context) 211 slab_free(fpu_context_slab, thread->saved_fpu_context); 212 #endif 213 214 return 1; /* One page freed */ 213 215 } 214 216 … … 221 223 { 222 224 THREAD = NULL; 225 223 226 atomic_set(&nrdy, 0); 224 227 thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0, 225 228 thr_constructor, thr_destructor, 0); 226 229 227 230 #ifdef CONFIG_FPU 228 231 fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t), 229 232 FPU_CONTEXT_ALIGN, NULL, NULL, 0); 230 233 #endif 231 234 232 235 avltree_create(&threads_tree); 233 236 } … … 235 238 /** Make thread ready 236 239 * 237 * Switch thread t to the ready state.240 * Switch thread to the ready state. 238 241 * 239 242 * @param t Thread to make ready. 240 243 * 241 244 */ 242 void thread_ready(thread_t *t) 243 { 244 cpu_t *cpu; 245 runq_t *r; 246 ipl_t ipl; 247 int i, avg; 248 249 ipl = interrupts_disable(); 250 251 spinlock_lock(&t->lock); 252 253 ASSERT(!(t->state == Ready)); 254 255 i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority; 256 257 cpu = CPU; 258 if (t->flags & THREAD_FLAG_WIRED) { 259 ASSERT(t->cpu != NULL); 260 cpu = t->cpu; 245 void thread_ready(thread_t *thread) 246 { 247 irq_spinlock_lock(&thread->lock, true); 248 249 ASSERT(!(thread->state == Ready)); 250 251 int i = (thread->priority < RQ_COUNT - 1) 252 ? ++thread->priority : thread->priority; 253 254 cpu_t *cpu = CPU; 255 if (thread->flags & THREAD_FLAG_WIRED) { 256 ASSERT(thread->cpu != NULL); 257 cpu = thread->cpu; 261 258 } 262 t->state = Ready; 263 spinlock_unlock(&t->lock); 259 thread->state = Ready; 260 261 irq_spinlock_pass(&thread->lock, &(cpu->rq[i].lock)); 264 262 265 263 /* 266 * Append t to respective ready queue on respective processor. 264 * Append thread to respective ready queue 265 * on respective processor. 267 266 */ 268 r = &cpu->rq[i]; 269 spinlock_lock(&r->lock); 270 list_append(&t->rq_link, &r->rq_head); 271 r->n++; 272 spinlock_unlock(&r->lock); 273 267 268 list_append(&thread->rq_link, &cpu->rq[i].rq_head); 269 cpu->rq[i].n++; 270 irq_spinlock_unlock(&(cpu->rq[i].lock), true); 271 274 272 atomic_inc(&nrdy); 275 // FIXME: Why is the avg value n ever read?276 avg = atomic_get(&nrdy) / config.cpu_active;273 // FIXME: Why is the avg value not used 274 // avg = atomic_get(&nrdy) / config.cpu_active; 277 275 atomic_inc(&cpu->nrdy); 278 276 } 277 278 /** Create new thread 279 * 280 * Create a new thread. 281 * 282 * @param func Thread's implementing function. 283 * @param arg Thread's implementing function argument. 284 * @param task Task to which the thread belongs. The caller must 285 * guarantee that the task won't cease to exist during the 286 * call. The task's lock may not be held. 287 * @param flags Thread flags. 288 * @param name Symbolic name (a copy is made). 289 * @param uncounted Thread's accounting doesn't affect accumulated task 290 * accounting. 291 * 292 * @return New thread's structure on success, NULL on failure. 293 * 294 */ 295 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, 296 unsigned int flags, const char *name, bool uncounted) 297 { 298 thread_t *thread = (thread_t *) slab_alloc(thread_slab, 0); 299 if (!thread) 300 return NULL; 301 302 /* Not needed, but good for debugging */ 303 memsetb(thread->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0); 304 305 irq_spinlock_lock(&tidlock, true); 306 thread->tid = ++last_tid; 307 irq_spinlock_unlock(&tidlock, true); 308 309 context_save(&thread->saved_context); 310 context_set(&thread->saved_context, FADDR(cushion), 311 (uintptr_t) thread->kstack, THREAD_STACK_SIZE); 312 313 the_initialize((the_t *) thread->kstack); 314 315 ipl_t ipl = interrupts_disable(); 316 thread->saved_context.ipl = interrupts_read(); 279 317 interrupts_restore(ipl); 280 } 281 282 /** Create new thread 283 * 284 * Create a new thread. 285 * 286 * @param func Thread's implementing function. 287 * @param arg Thread's implementing function argument. 288 * @param task Task to which the thread belongs. The caller must 289 * guarantee that the task won't cease to exist during the 290 * call. The task's lock may not be held. 291 * @param flags Thread flags. 292 * @param name Symbolic name (a copy is made). 293 * @param uncounted Thread's accounting doesn't affect accumulated task 294 * accounting. 295 * 296 * @return New thread's structure on success, NULL on failure. 297 * 298 */ 299 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, 300 int flags, const char *name, bool uncounted) 301 { 302 thread_t *t; 303 ipl_t ipl; 304 305 t = (thread_t *) slab_alloc(thread_slab, 0); 306 if (!t) 307 return NULL; 308 309 /* Not needed, but good for debugging */ 310 memsetb(t->kstack, THREAD_STACK_SIZE * 1 << STACK_FRAMES, 0); 311 312 ipl = interrupts_disable(); 313 spinlock_lock(&tidlock); 314 t->tid = ++last_tid; 315 spinlock_unlock(&tidlock); 316 interrupts_restore(ipl); 317 318 context_save(&t->saved_context); 319 context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack, 320 THREAD_STACK_SIZE); 321 322 the_initialize((the_t *) t->kstack); 323 324 ipl = interrupts_disable(); 325 t->saved_context.ipl = interrupts_read(); 326 interrupts_restore(ipl); 327 328 memcpy(t->name, name, THREAD_NAME_BUFLEN); 329 t->name[THREAD_NAME_BUFLEN - 1] = 0; 330 331 t->thread_code = func; 332 t->thread_arg = arg; 333 t->ticks = -1; 334 t->ucycles = 0; 335 t->kcycles = 0; 336 t->uncounted = uncounted; 337 t->priority = -1; /* start in rq[0] */ 338 t->cpu = NULL; 339 t->flags = flags; 340 t->state = Entering; 341 t->call_me = NULL; 342 t->call_me_with = NULL; 343 344 timeout_initialize(&t->sleep_timeout); 345 t->sleep_interruptible = false; 346 t->sleep_queue = NULL; 347 t->timeout_pending = 0; 348 349 t->in_copy_from_uspace = false; 350 t->in_copy_to_uspace = false; 351 352 t->interrupted = false; 353 t->detached = false; 354 waitq_initialize(&t->join_wq); 355 356 t->rwlock_holder_type = RWLOCK_NONE; 357 358 t->task = task; 359 360 t->fpu_context_exists = 0; 361 t->fpu_context_engaged = 0; 362 363 avltree_node_initialize(&t->threads_tree_node); 364 t->threads_tree_node.key = (uintptr_t) t; 365 318 319 str_cpy(thread->name, THREAD_NAME_BUFLEN, name); 320 321 thread->thread_code = func; 322 thread->thread_arg = arg; 323 thread->ticks = -1; 324 thread->ucycles = 0; 325 thread->kcycles = 0; 326 thread->uncounted = uncounted; 327 thread->priority = -1; /* Start in rq[0] */ 328 thread->cpu = NULL; 329 thread->flags = flags; 330 thread->state = Entering; 331 thread->call_me = NULL; 332 thread->call_me_with = NULL; 333 334 timeout_initialize(&thread->sleep_timeout); 335 thread->sleep_interruptible = false; 336 thread->sleep_queue = NULL; 337 thread->timeout_pending = false; 338 339 thread->in_copy_from_uspace = false; 340 thread->in_copy_to_uspace = false; 341 342 thread->interrupted = false; 343 thread->detached = false; 344 waitq_initialize(&thread->join_wq); 345 346 thread->rwlock_holder_type = RWLOCK_NONE; 347 348 thread->task = task; 349 350 thread->fpu_context_exists = 0; 351 thread->fpu_context_engaged = 0; 352 353 avltree_node_initialize(&thread->threads_tree_node); 354 thread->threads_tree_node.key = (uintptr_t) thread; 355 366 356 #ifdef CONFIG_UDEBUG 367 357 /* Init debugging stuff */ 368 udebug_thread_initialize(&t ->udebug);369 #endif 370 371 /* might depend on previous initialization */372 thread_create_arch(t );373 358 udebug_thread_initialize(&thread->udebug); 359 #endif 360 361 /* Might depend on previous initialization */ 362 thread_create_arch(thread); 363 374 364 if (!(flags & THREAD_FLAG_NOATTACH)) 375 thread_attach(t , task);376 377 return t ;365 thread_attach(thread, task); 366 367 return thread; 378 368 } 379 369 … … 382 372 * Detach thread from all queues, cpus etc. and destroy it. 383 373 * 384 * Assume thread->lock is held!! 385 */ 386 void thread_destroy(thread_t *t) 387 { 388 ASSERT(t->state == Exiting || t->state == Lingering); 389 ASSERT(t->task); 390 ASSERT(t->cpu); 391 392 spinlock_lock(&t->cpu->lock); 393 if (t->cpu->fpu_owner == t) 394 t->cpu->fpu_owner = NULL; 395 spinlock_unlock(&t->cpu->lock); 396 397 spinlock_unlock(&t->lock); 398 399 spinlock_lock(&threads_lock); 400 avltree_delete(&threads_tree, &t->threads_tree_node); 401 spinlock_unlock(&threads_lock); 402 374 * @param thread Thread to be destroyed. 375 * @param irq_res Indicate whether it should unlock thread->lock 376 * in interrupts-restore mode. 377 * 378 */ 379 void thread_destroy(thread_t *thread, bool irq_res) 380 { 381 ASSERT(irq_spinlock_locked(&thread->lock)); 382 ASSERT((thread->state == Exiting) || (thread->state == Lingering)); 383 ASSERT(thread->task); 384 ASSERT(thread->cpu); 385 386 irq_spinlock_lock(&thread->cpu->lock, false); 387 if (thread->cpu->fpu_owner == thread) 388 thread->cpu->fpu_owner = NULL; 389 irq_spinlock_unlock(&thread->cpu->lock, false); 390 391 irq_spinlock_pass(&thread->lock, &threads_lock); 392 393 avltree_delete(&threads_tree, &thread->threads_tree_node); 394 395 irq_spinlock_pass(&threads_lock, &thread->task->lock); 396 403 397 /* 404 398 * Detach from the containing task. 405 399 */ 406 spinlock_lock(&t->task->lock); 407 list_remove(&t->th_link); 408 spinlock_unlock(&t->task->lock); 409 400 list_remove(&thread->th_link); 401 irq_spinlock_unlock(&thread->task->lock, irq_res); 402 410 403 /* 411 404 * Drop the reference to the containing task. 412 405 */ 413 task_release(t->task); 414 415 slab_free(thread_slab, t); 406 task_release(thread->task); 407 slab_free(thread_slab, thread); 416 408 } 417 409 … … 421 413 * threads_tree. 422 414 * 423 * @param t Thread to be attached to the task. 424 * @param task Task to which the thread is to be attached. 425 */ 426 void thread_attach(thread_t *t, task_t *task) 427 { 428 ipl_t ipl; 429 415 * @param t Thread to be attached to the task. 416 * @param task Task to which the thread is to be attached. 417 * 418 */ 419 void thread_attach(thread_t *thread, task_t *task) 420 { 430 421 /* 431 422 * Attach to the specified task. 432 423 */ 433 ipl = interrupts_disable(); 434 spinlock_lock(&task->lock); 435 424 irq_spinlock_lock(&task->lock, true); 425 436 426 /* Hold a reference to the task. */ 437 427 task_hold(task); 438 428 439 429 /* Must not count kbox thread into lifecount */ 440 if (t ->flags & THREAD_FLAG_USPACE)430 if (thread->flags & THREAD_FLAG_USPACE) 441 431 atomic_inc(&task->lifecount); 442 443 list_append(&t->th_link, &task->th_head); 444 spinlock_unlock(&task->lock); 445 432 433 list_append(&thread->th_link, &task->th_head); 434 435 irq_spinlock_pass(&task->lock, &threads_lock); 436 446 437 /* 447 438 * Register this thread in the system-wide list. 448 439 */ 449 spinlock_lock(&threads_lock); 450 avltree_insert(&threads_tree, &t->threads_tree_node); 451 spinlock_unlock(&threads_lock); 452 453 interrupts_restore(ipl); 440 avltree_insert(&threads_tree, &thread->threads_tree_node); 441 irq_spinlock_unlock(&threads_lock, true); 454 442 } 455 443 456 444 /** Terminate thread. 457 445 * 458 * End current thread execution and switch it to the exiting state. All pending 459 * timeouts are executed. 446 * End current thread execution and switch it to the exiting state. 447 * All pending timeouts are executed. 448 * 460 449 */ 461 450 void thread_exit(void) 462 451 { 463 ipl_t ipl;464 465 452 if (THREAD->flags & THREAD_FLAG_USPACE) { 466 453 #ifdef CONFIG_UDEBUG 467 454 /* Generate udebug THREAD_E event */ 468 455 udebug_thread_e_event(); 456 457 /* 458 * This thread will not execute any code or system calls from 459 * now on. 460 */ 461 udebug_stoppable_begin(); 469 462 #endif 470 463 if (atomic_predec(&TASK->lifecount) == 0) { … … 475 468 * can only be created by threads of the same task. 476 469 * We are safe to perform cleanup. 470 * 477 471 */ 478 472 ipc_cleanup(); … … 481 475 } 482 476 } 483 477 484 478 restart: 485 ipl = interrupts_disable(); 486 spinlock_lock(&THREAD->lock); 487 if (THREAD->timeout_pending) { 488 /* busy waiting for timeouts in progress */ 489 spinlock_unlock(&THREAD->lock); 490 interrupts_restore(ipl); 479 irq_spinlock_lock(&THREAD->lock, true); 480 if (THREAD->timeout_pending) { 481 /* Busy waiting for timeouts in progress */ 482 irq_spinlock_unlock(&THREAD->lock, true); 491 483 goto restart; 492 484 } 493 485 494 486 THREAD->state = Exiting; 495 spinlock_unlock(&THREAD->lock); 487 irq_spinlock_unlock(&THREAD->lock, true); 488 496 489 scheduler(); 497 490 498 491 /* Not reached */ 499 while (1) 500 ; 501 } 502 492 while (true); 493 } 503 494 504 495 /** Thread sleep … … 515 506 while (sec > 0) { 516 507 uint32_t period = (sec > 1000) ? 1000 : sec; 517 508 518 509 thread_usleep(period * 1000000); 519 510 sec -= period; … … 523 514 /** Wait for another thread to exit. 524 515 * 525 * @param t Thread to join on exit.526 * @param usec Timeout in microseconds.527 * @param flags Mode of operation.516 * @param thread Thread to join on exit. 517 * @param usec Timeout in microseconds. 518 * @param flags Mode of operation. 528 519 * 529 520 * @return An error code from errno.h or an error code from synch.h. 530 */ 531 int thread_join_timeout(thread_t *t, uint32_t usec, int flags) 532 { 533 ipl_t ipl; 534 int rc; 535 536 if (t == THREAD) 521 * 522 */ 523 int thread_join_timeout(thread_t *thread, uint32_t usec, unsigned int flags) 524 { 525 if (thread == THREAD) 537 526 return EINVAL; 538 527 539 528 /* 540 529 * Since thread join can only be called once on an undetached thread, … … 542 531 */ 543 532 544 ipl = interrupts_disable(); 545 spinlock_lock(&t->lock); 546 ASSERT(!t->detached); 547 spinlock_unlock(&t->lock); 548 interrupts_restore(ipl); 549 550 rc = waitq_sleep_timeout(&t->join_wq, usec, flags); 551 552 return rc; 533 irq_spinlock_lock(&thread->lock, true); 534 ASSERT(!thread->detached); 535 irq_spinlock_unlock(&thread->lock, true); 536 537 return waitq_sleep_timeout(&thread->join_wq, usec, flags); 553 538 } 554 539 … … 558 543 * state, deallocate its resources. 559 544 * 560 * @param t Thread to be detached. 561 */ 562 void thread_detach(thread_t *t) 563 { 564 ipl_t ipl; 565 545 * @param thread Thread to be detached. 546 * 547 */ 548 void thread_detach(thread_t *thread) 549 { 566 550 /* 567 551 * Since the thread is expected not to be already detached, 568 552 * pointer to it must be still valid. 569 553 */ 570 ipl = interrupts_disable(); 571 spinlock_lock(&t->lock); 572 ASSERT(!t->detached); 573 if (t->state == Lingering) { 574 thread_destroy(t); /* unlocks &t->lock */ 575 interrupts_restore(ipl); 554 irq_spinlock_lock(&thread->lock, true); 555 ASSERT(!thread->detached); 556 557 if (thread->state == Lingering) { 558 /* 559 * Unlock &thread->lock and restore 560 * interrupts in thread_destroy(). 561 */ 562 thread_destroy(thread, true); 576 563 return; 577 564 } else { 578 t ->detached = true;565 thread->detached = true; 579 566 } 580 spinlock_unlock(&t->lock);581 i nterrupts_restore(ipl);567 568 irq_spinlock_unlock(&thread->lock, true); 582 569 } 583 570 … … 601 588 * 602 589 * Register a function and its argument to be executed 603 * on next context switch to the current thread. 590 * on next context switch to the current thread. Must 591 * be called with interrupts disabled. 604 592 * 605 593 * @param call_me Out-of-context function. … … 609 597 void thread_register_call_me(void (* call_me)(void *), void *call_me_with) 610 598 { 611 ipl_t ipl; 612 613 ipl = interrupts_disable(); 614 spinlock_lock(&THREAD->lock); 599 irq_spinlock_lock(&THREAD->lock, false); 615 600 THREAD->call_me = call_me; 616 601 THREAD->call_me_with = call_me_with; 617 spinlock_unlock(&THREAD->lock); 618 interrupts_restore(ipl); 602 irq_spinlock_unlock(&THREAD->lock, false); 619 603 } 620 604 621 605 static bool thread_walker(avltree_node_t *node, void *arg) 622 606 { 623 thread_t *t = avltree_get_instance(node, thread_t, threads_tree_node);607 thread_t *thread = avltree_get_instance(node, thread_t, threads_tree_node); 624 608 625 609 uint64_t ucycles, kcycles; 626 610 char usuffix, ksuffix; 627 order_suffix(t ->ucycles, &ucycles, &usuffix);628 order_suffix(t ->kcycles, &kcycles, &ksuffix);629 611 order_suffix(thread->ucycles, &ucycles, &usuffix); 612 order_suffix(thread->kcycles, &kcycles, &ksuffix); 613 630 614 #ifdef __32_BITS__ 631 615 printf("%-6" PRIu64" %-10s %10p %-8s %10p %-3" PRIu32 " %10p %10p %9" 632 PRIu64 "%c %9" PRIu64 "%c ", t ->tid, t->name, t,633 thread_states[t ->state], t->task, t->task->context, t->thread_code,634 t ->kstack, ucycles, usuffix, kcycles, ksuffix);635 #endif 636 616 PRIu64 "%c %9" PRIu64 "%c ", thread->tid, thread->name, thread, 617 thread_states[thread->state], thread->task, thread->task->context, 618 thread->thread_code, thread->kstack, ucycles, usuffix, kcycles, ksuffix); 619 #endif 620 637 621 #ifdef __64_BITS__ 638 622 printf("%-6" PRIu64" %-10s %18p %-8s %18p %-3" PRIu32 " %18p %18p %9" 639 PRIu64 "%c %9" PRIu64 "%c ", t ->tid, t->name, t,640 thread_states[t ->state], t->task, t->task->context, t->thread_code,641 t ->kstack, ucycles, usuffix, kcycles, ksuffix);642 #endif 643 644 if (t ->cpu)645 printf("%-4u", t ->cpu->id);623 PRIu64 "%c %9" PRIu64 "%c ", thread->tid, thread->name, thread, 624 thread_states[thread->state], thread->task, thread->task->context, 625 thread->thread_code, thread->kstack, ucycles, usuffix, kcycles, ksuffix); 626 #endif 627 628 if (thread->cpu) 629 printf("%-4u", thread->cpu->id); 646 630 else 647 631 printf("none"); 648 649 if (t ->state == Sleeping) {632 633 if (thread->state == Sleeping) { 650 634 #ifdef __32_BITS__ 651 printf(" %10p", t ->sleep_queue);652 #endif 653 635 printf(" %10p", thread->sleep_queue); 636 #endif 637 654 638 #ifdef __64_BITS__ 655 printf(" %18p", t ->sleep_queue);639 printf(" %18p", thread->sleep_queue); 656 640 #endif 657 641 } 658 642 659 643 printf("\n"); 660 644 661 645 return true; 662 646 } 663 647 664 /** Print list of threads debug info */ 648 /** Print list of threads debug info 649 * 650 */ 665 651 void thread_print_list(void) 666 652 { 667 ipl_t ipl;668 669 653 /* Messing with thread structures, avoid deadlock */ 670 ipl = interrupts_disable(); 671 spinlock_lock(&threads_lock); 672 673 #ifdef __32_BITS__ 654 irq_spinlock_lock(&threads_lock, true); 655 656 #ifdef __32_BITS__ 674 657 printf("tid name address state task " 675 658 "ctx code stack ucycles kcycles cpu " … … 679 662 "----------\n"); 680 663 #endif 681 664 682 665 #ifdef __64_BITS__ 683 666 printf("tid name address state task " … … 688 671 "------------------\n"); 689 672 #endif 690 673 691 674 avltree_walk(&threads_tree, thread_walker, NULL); 692 693 spinlock_unlock(&threads_lock); 694 interrupts_restore(ipl); 675 676 irq_spinlock_unlock(&threads_lock, true); 695 677 } 696 678 … … 700 682 * interrupts must be already disabled. 701 683 * 702 * @param t Pointer to thread.684 * @param thread Pointer to thread. 703 685 * 704 686 * @return True if thread t is known to the system, false otherwise. 705 */ 706 bool thread_exists(thread_t *t) 707 { 708 avltree_node_t *node; 709 710 node = avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) t)); 687 * 688 */ 689 bool thread_exists(thread_t *thread) 690 { 691 ASSERT(interrupts_disabled()); 692 ASSERT(irq_spinlock_locked(&threads_lock)); 693 694 avltree_node_t *node = 695 avltree_search(&threads_tree, (avltree_key_t) ((uintptr_t) thread)); 711 696 712 697 return node != NULL; … … 718 703 * interrupts must be already disabled. 719 704 * 720 * @param user True to update user accounting, false for kernel. 705 * @param user True to update user accounting, false for kernel. 706 * 721 707 */ 722 708 void thread_update_accounting(bool user) 723 709 { 724 710 uint64_t time = get_cycle(); 725 if (user) { 711 712 ASSERT(interrupts_disabled()); 713 ASSERT(irq_spinlock_locked(&THREAD->lock)); 714 715 if (user) 726 716 THREAD->ucycles += time - THREAD->last_cycle; 727 } else {717 else 728 718 THREAD->kcycles += time - THREAD->last_cycle; 729 }719 730 720 THREAD->last_cycle = time; 731 721 } … … 757 747 thread_t *thread_find_by_id(thread_id_t thread_id) 758 748 { 749 ASSERT(interrupts_disabled()); 750 ASSERT(irq_spinlock_locked(&threads_lock)); 751 759 752 thread_iterator_t iterator; 760 753 … … 774 767 size_t name_len, thread_id_t *uspace_thread_id) 775 768 { 776 thread_t *t;777 char namebuf[THREAD_NAME_BUFLEN];778 uspace_arg_t *kernel_uarg;779 int rc;780 781 769 if (name_len > THREAD_NAME_BUFLEN - 1) 782 770 name_len = THREAD_NAME_BUFLEN - 1; 783 784 rc = copy_from_uspace(namebuf, uspace_name, name_len); 771 772 char namebuf[THREAD_NAME_BUFLEN]; 773 int rc = copy_from_uspace(namebuf, uspace_name, name_len); 785 774 if (rc != 0) 786 775 return (unative_t) rc; 787 776 788 777 namebuf[name_len] = 0; 789 778 790 779 /* 791 780 * In case of failure, kernel_uarg will be deallocated in this function. 792 781 * In case of success, kernel_uarg will be freed in uinit(). 782 * 793 783 */ 794 kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0); 784 uspace_arg_t *kernel_uarg = 785 (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0); 795 786 796 787 rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t)); … … 799 790 return (unative_t) rc; 800 791 } 801 802 t = thread_create(uinit, kernel_uarg, TASK,792 793 thread_t *thread = thread_create(uinit, kernel_uarg, TASK, 803 794 THREAD_FLAG_USPACE | THREAD_FLAG_NOATTACH, namebuf, false); 804 if (t ) {795 if (thread) { 805 796 if (uspace_thread_id != NULL) { 806 int rc; 807 808 rc = copy_to_uspace(uspace_thread_id, &t->tid, 809 sizeof(t->tid)); 797 rc = copy_to_uspace(uspace_thread_id, &thread->tid, 798 sizeof(thread->tid)); 810 799 if (rc != 0) { 811 800 /* … … 813 802 * has already been created. We need to undo its 814 803 * creation now. 804 * 815 805 */ 816 806 817 807 /* 818 808 * The new thread structure is initialized, but … … 820 810 * We can safely deallocate it. 821 811 */ 822 slab_free(thread_slab, t );823 824 812 slab_free(thread_slab, thread); 813 free(kernel_uarg); 814 825 815 return (unative_t) rc; 826 816 } 827 817 } 818 828 819 #ifdef CONFIG_UDEBUG 829 820 /* … … 833 824 * THREAD_B events for threads that already existed 834 825 * and could be detected with THREAD_READ before. 826 * 835 827 */ 836 udebug_thread_b_event_attach(t , TASK);828 udebug_thread_b_event_attach(thread, TASK); 837 829 #else 838 thread_attach(t , TASK);839 #endif 840 thread_ready(t );841 830 thread_attach(thread, TASK); 831 #endif 832 thread_ready(thread); 833 842 834 return 0; 843 835 } else 844 836 free(kernel_uarg); 845 837 846 838 return (unative_t) ENOMEM; 847 839 } … … 853 845 { 854 846 thread_exit(); 847 855 848 /* Unreachable */ 856 849 return 0; … … 863 856 * 864 857 * @return 0 on success or an error code from @ref errno.h. 858 * 865 859 */ 866 860 unative_t sys_thread_get_id(thread_id_t *uspace_thread_id) … … 869 863 * No need to acquire lock on THREAD because tid 870 864 * remains constant for the lifespan of the thread. 865 * 871 866 */ 872 867 return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
Note:
See TracChangeset
for help on using the changeset viewer.
