i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed global variables to match our coding style guide.

Browse Source 
Removed thread_kill_thread_nowait().
Renamed thread_init_percpu().
Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@7011 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2004-03-17 15:29:45 +00:00
parent bd3f643494
commit 0f00c4fff9
1 changed files with 65 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/kernel/core/thread.c
+65 -72
View File
@@ -49,22 +49,22 @@ struct thread_key {
spinlock thread_spinlock = 0; spinlock thread_spinlock = 0;
// thread list // thread list
static struct thread *idle_threads[MAX_BOOT_CPUS]; static struct thread *sIdleThreads[B_MAX_CPU_COUNT];
static void *thread_hash = NULL; static void *sThreadHash = NULL;
static thread_id next_thread_id = 1; static thread_id sNextThreadID = 1;
static sem_id gSnoozeSem = -1; static sem_id sSnoozeSem = -1;
// death stacks - used temporarily as a thread cleans itself up // death stacks - used temporarily as a thread cleans itself up
struct death_stack { struct death_stack {
region_id rid; region_id area;
addr address; addr_t address;
bool in_use; bool in_use;
}; };
static struct death_stack *death_stacks; static struct death_stack *sDeathStacks;
static unsigned int num_death_stacks; static unsigned int sNumDeathStacks;
static unsigned int volatile death_stack_bitmap; static unsigned int volatile sDeathStackBitmap;
static sem_id death_stack_sem; static sem_id sDeathStackSem;
// The dead queue is used as a pool from which to retrieve and reuse previously // The dead queue is used as a pool from which to retrieve and reuse previously
// allocated thread structs when creating a new thread. It should be gone once // allocated thread structs when creating a new thread. It should be gone once
@@ -156,7 +156,7 @@ create_thread_struct(const char *name)
strlcpy(t->name, name, B_OS_NAME_LENGTH); strlcpy(t->name, name, B_OS_NAME_LENGTH);
t->id = atomic_add(&next_thread_id, 1); t->id = atomic_add(&sNextThreadID, 1);
t->team = NULL; t->team = NULL;
t->cpu = NULL; t->cpu = NULL;
t->sem_blocking = -1; t->sem_blocking = -1;
@@ -247,7 +247,7 @@ _create_user_thread_kentry(void)
thread->in_kernel = false; thread->in_kernel = false;
// jump to the entry point in user space // jump to the entry point in user space
arch_thread_enter_uspace(thread, (addr)thread->entry, thread->args1, thread->args2); arch_thread_enter_uspace(thread, (addr_t)thread->entry, thread->args1, thread->args2);
// never get here // never get here
return 0; return 0;
@@ -282,7 +282,7 @@ create_thread(const char *name, team_id teamID, thread_func entry, void *args1,
cpu_status state; cpu_status state;
char stack_name[64]; char stack_name[64];
bool abort = false; bool abort = false;
addr mainThreadStackBase = USER_STACK_REGION + USER_STACK_REGION_SIZE; addr_t mainThreadStackBase = USER_STACK_REGION + USER_STACK_REGION_SIZE;
t = create_thread_struct(name); t = create_thread_struct(name);
if (t == NULL) if (t == NULL)
@@ -298,7 +298,7 @@ create_thread(const char *name, team_id teamID, thread_func entry, void *args1,
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
// insert into global list // insert into global list
hash_insert(thread_hash, t); hash_insert(sThreadHash, t);
RELEASE_THREAD_LOCK(); RELEASE_THREAD_LOCK();
GRAB_TEAM_LOCK(); GRAB_TEAM_LOCK();
@@ -315,7 +315,7 @@ create_thread(const char *name, team_id teamID, thread_func entry, void *args1,
RELEASE_TEAM_LOCK(); RELEASE_TEAM_LOCK();
if (abort) { if (abort) {
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
hash_remove(thread_hash, t); hash_remove(sThreadHash, t);
RELEASE_THREAD_LOCK(); RELEASE_THREAD_LOCK();
} }
restore_interrupts(state); restore_interrupts(state);
@@ -467,14 +467,14 @@ dump_thread_info(int argc, char **argv)
id = atoi(argv[1]); id = atoi(argv[1]);
// walk through the thread list, trying to match name or id // walk through the thread list, trying to match name or id
hash_open(thread_hash, &i); hash_open(sThreadHash, &i);
while ((t = hash_next(thread_hash, &i)) != NULL) { while ((t = hash_next(sThreadHash, &i)) != NULL) {
if ((t->name && strcmp(argv[1], t->name) == 0) || t->id == id) { if ((t->name && strcmp(argv[1], t->name) == 0) || t->id == id) {
_dump_thread_info(t); _dump_thread_info(t);
break; break;
} }
} }
hash_close(thread_hash, &i, false); hash_close(sThreadHash, &i, false);
return 0; return 0;
} }
@@ -485,8 +485,8 @@ dump_thread_list(int argc, char **argv)
struct thread *t; struct thread *t;
struct hash_iterator i; struct hash_iterator i;
hash_open(thread_hash, &i); hash_open(sThreadHash, &i);
while ((t = hash_next(thread_hash, &i)) != NULL) { while ((t = hash_next(sThreadHash, &i)) != NULL) {
dprintf("%p", t); dprintf("%p", t);
if (t->name != NULL) if (t->name != NULL)
dprintf("\t%32s", t->name); dprintf("\t%32s", t->name);
@@ -500,7 +500,7 @@ dump_thread_list(int argc, char **argv)
dprintf("\tNOCPU"); dprintf("\tNOCPU");
dprintf("\t0x%lx\n", t->kernel_stack_base); dprintf("\t0x%lx\n", t->kernel_stack_base);
} }
hash_close(thread_hash, &i, false); hash_close(sThreadHash, &i, false);
return 0; return 0;
} }
@@ -572,14 +572,14 @@ get_death_stack(void)
unsigned int bit; unsigned int bit;
int i; int i;
acquire_sem(death_stack_sem); acquire_sem(sDeathStackSem);
// grap the thread lock, find a free spot and release // grap the thread lock, find a free spot and release
state = disable_interrupts(); state = disable_interrupts();
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
bit = death_stack_bitmap; bit = sDeathStackBitmap;
bit = (~bit)&~((~bit)-1); bit = (~bit)&~((~bit)-1);
death_stack_bitmap |= bit; sDeathStackBitmap |= bit;
RELEASE_THREAD_LOCK(); RELEASE_THREAD_LOCK();
// sanity checks // sanity checks
@@ -594,7 +594,7 @@ get_death_stack(void)
bit >>= 1; bit >>= 1;
} }
TRACE(("get_death_stack: returning 0x%lx\n", death_stacks[i].address)); TRACE(("get_death_stack: returning 0x%lx\n", sDeathStacks[i].address));
return i; return i;
} }
@@ -605,18 +605,18 @@ put_death_stack_and_reschedule(unsigned int index)
{ {
TRACE(("put_death_stack...: passed %d\n", index)); TRACE(("put_death_stack...: passed %d\n", index));
if (index >= num_death_stacks) if (index >= sNumDeathStacks)
panic("put_death_stack: passed invalid stack index %d\n", index); panic("put_death_stack: passed invalid stack index %d\n", index);
if (!(death_stack_bitmap & (1 << index))) if (!(sDeathStackBitmap & (1 << index)))
panic("put_death_stack: passed invalid stack index %d\n", index); panic("put_death_stack: passed invalid stack index %d\n", index);
disable_interrupts(); disable_interrupts();
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
death_stack_bitmap &= ~(1 << index); sDeathStackBitmap &= ~(1 << index);
release_sem_etc(death_stack_sem, 1, B_DO_NOT_RESCHEDULE); release_sem_etc(sDeathStackSem, 1, B_DO_NOT_RESCHEDULE);
scheduler_reschedule(); scheduler_reschedule();
} }
@@ -675,7 +675,7 @@ thread_exit2(void *_args)
remove_thread_from_team(team_get_kernel_team(), args.t); remove_thread_from_team(team_get_kernel_team(), args.t);
RELEASE_TEAM_LOCK(); RELEASE_TEAM_LOCK();
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
hash_remove(thread_hash, args.t); hash_remove(sThreadHash, args.t);
RELEASE_THREAD_LOCK(); RELEASE_THREAD_LOCK();
// ToDo: is this correct at this point? // ToDo: is this correct at this point?
@@ -803,8 +803,8 @@ thread_exit(void)
// set the new kernel stack officially to the death stack, wont be really switched until // set the new kernel stack officially to the death stack, wont be really switched until
// the next function is called. This bookkeeping must be done now before a context switch // the next function is called. This bookkeeping must be done now before a context switch
// happens, or the processor will interrupt to the old stack // happens, or the processor will interrupt to the old stack
t->kernel_stack_region_id = death_stacks[death_stack].rid; t->kernel_stack_region_id = sDeathStacks[death_stack].area;
t->kernel_stack_base = death_stacks[death_stack].address; t->kernel_stack_base = sDeathStacks[death_stack].address;
// we will continue in thread_exit2(), on the new stack // we will continue in thread_exit2(), on the new stack
arch_thread_switch_kstack_and_call(t, t->kernel_stack_base + KSTACK_SIZE, thread_exit2, &args); arch_thread_switch_kstack_and_call(t, t->kernel_stack_base + KSTACK_SIZE, thread_exit2, &args);
@@ -814,13 +814,6 @@ thread_exit(void)
} }
int
thread_kill_thread_nowait(thread_id id)
{
return send_signal_etc(id, SIGKILLTHR, B_DO_NOT_RESCHEDULE);
}
static void static void
thread_kthread_exit(void) thread_kthread_exit(void)
{ {
@@ -856,7 +849,7 @@ thread_get_thread_struct_locked(thread_id id)
key.id = id; key.id = id;
return hash_lookup(thread_hash, &key); return hash_lookup(sThreadHash, &key);
} }
@@ -989,7 +982,7 @@ thread_dequeue_id(struct thread_queue *q, thread_id thr_id)
} }
int status_t
thread_init(kernel_args *ka) thread_init(kernel_args *ka)
{ {
struct thread *t; struct thread *t;
@@ -998,17 +991,17 @@ thread_init(kernel_args *ka)
TRACE(("thread_init: entry\n")); TRACE(("thread_init: entry\n"));
// create the thread hash table // create the thread hash table
thread_hash = hash_init(15, (addr)&t->all_next - (addr)t, sThreadHash = hash_init(15, (addr_t)&t->all_next - (addr_t)t,
&thread_struct_compare, &thread_struct_hash); &thread_struct_compare, &thread_struct_hash);
// zero out the dead thread structure q // zero out the dead thread structure q
memset(&dead_q, 0, sizeof(dead_q)); memset(&dead_q, 0, sizeof(dead_q));
// allocate snooze sem // allocate snooze sem
gSnoozeSem = create_sem(0, "snooze sem"); sSnoozeSem = create_sem(0, "snooze sem");
if (gSnoozeSem < 0) { if (sSnoozeSem < 0) {
panic("error creating snooze sem\n"); panic("error creating snooze sem\n");
return gSnoozeSem; return sSnoozeSem;
} }
// create an idle thread for each cpu // create an idle thread for each cpu
@@ -1034,43 +1027,43 @@ thread_init(kernel_args *ka)
t->kernel_stack_base = region->base; t->kernel_stack_base = region->base;
vm_put_region(region); vm_put_region(region);
hash_insert(thread_hash, t); hash_insert(sThreadHash, t);
insert_thread_into_team(t->team, t); insert_thread_into_team(t->team, t);
idle_threads[i] = t; sIdleThreads[i] = t;
if (i == 0) if (i == 0)
arch_thread_set_current_thread(t); arch_thread_set_current_thread(t);
t->cpu = &cpu[i]; t->cpu = &cpu[i];
} }
// create a set of death stacks // create a set of death stacks
num_death_stacks = smp_get_num_cpus(); sNumDeathStacks = smp_get_num_cpus();
if (num_death_stacks > 8*sizeof(death_stack_bitmap)) { if (sNumDeathStacks > 8*sizeof(sDeathStackBitmap)) {
/* /*
* clamp values for really beefy machines * clamp values for really beefy machines
*/ */
num_death_stacks = 8*sizeof(death_stack_bitmap); sNumDeathStacks = 8*sizeof(sDeathStackBitmap);
} }
death_stack_bitmap = 0; sDeathStackBitmap = 0;
death_stacks = (struct death_stack *)malloc(num_death_stacks * sizeof(struct death_stack)); sDeathStacks = (struct death_stack *)malloc(sNumDeathStacks * sizeof(struct death_stack));
if (death_stacks == NULL) { if (sDeathStacks == NULL) {
panic("error creating death stacks\n"); panic("error creating death stacks\n");
return ENOMEM; return B_NO_MEMORY;
} }
{ {
char temp[64]; char temp[64];
for (i = 0; i < num_death_stacks; i++) { for (i = 0; i < sNumDeathStacks; i++) {
sprintf(temp, "death_stack%d", i); sprintf(temp, "death_stack%d", i);
death_stacks[i].rid = create_area(temp, (void **)&death_stacks[i].address, sDeathStacks[i].area = create_area(temp, (void **)&sDeathStacks[i].address,
B_ANY_KERNEL_ADDRESS, KSTACK_SIZE, B_FULL_LOCK, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA); B_ANY_KERNEL_ADDRESS, KSTACK_SIZE, B_FULL_LOCK, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);
if (death_stacks[i].rid < 0) { if (sDeathStacks[i].area < 0) {
panic("error creating death stacks\n"); panic("error creating death stacks\n");
return death_stacks[i].rid; return sDeathStacks[i].area;
} }
death_stacks[i].in_use = false; sDeathStacks[i].in_use = false;
} }
} }
death_stack_sem = create_sem(num_death_stacks, "death_stack_noavail_sem"); sDeathStackSem = create_sem(sNumDeathStacks, "death_stack_noavail_sem");
// set up some debugger commands // set up some debugger commands
add_debugger_command("threads", &dump_thread_list, "list all threads"); add_debugger_command("threads", &dump_thread_list, "list all threads");
@@ -1079,15 +1072,15 @@ thread_init(kernel_args *ka)
add_debugger_command("next_all", &dump_next_thread_in_all_list, "dump the next thread in the global list of the last thread viewed"); add_debugger_command("next_all", &dump_next_thread_in_all_list, "dump the next thread in the global list of the last thread viewed");
add_debugger_command("next_team", &dump_next_thread_in_team, "dump the next thread in the team of the last thread viewed"); add_debugger_command("next_team", &dump_next_thread_in_team, "dump the next thread in the team of the last thread viewed");
return 0; return B_OK;
} }
int status_t
thread_init_percpu(int cpu_num) thread_per_cpu_init(int32 cpu_num)
{ {
arch_thread_set_current_thread(idle_threads[cpu_num]); arch_thread_set_current_thread(sIdleThreads[cpu_num]);
return 0; return B_OK;
} }
@@ -1260,7 +1253,7 @@ fill_thread_info(struct thread *thread, thread_info *info, size_t size)
strlcpy(info->name, thread->name, B_OS_NAME_LENGTH); strlcpy(info->name, thread->name, B_OS_NAME_LENGTH);
if (thread->state == B_THREAD_WAITING) { if (thread->state == B_THREAD_WAITING) {
if (thread->sem_blocking == gSnoozeSem) if (thread->sem_blocking == sSnoozeSem)
info->state = B_THREAD_ASLEEP; info->state = B_THREAD_ASLEEP;
else if (thread->sem_blocking == thread->msg.read_sem) else if (thread->sem_blocking == thread->msg.read_sem)
info->state = B_THREAD_RECEIVING; info->state = B_THREAD_RECEIVING;
@@ -1328,10 +1321,10 @@ _get_next_thread_info(team_id team, int32 *_cookie, thread_info *info, size_t si
state = disable_interrupts(); state = disable_interrupts();
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
if (slot >= next_thread_id) if (slot >= sNextThreadID)
goto err; goto err;
while (slot < next_thread_id while (slot < sNextThreadID
&& (!(thread = thread_get_thread_struct_locked(slot)) || thread->team->id != team)) && (!(thread = thread_get_thread_struct_locked(slot)) || thread->team->id != team))
slot++; slot++;
@@ -1364,12 +1357,12 @@ find_thread(const char *name)
GRAB_THREAD_LOCK(); GRAB_THREAD_LOCK();
// ToDo: this might not be in the same order as find_thread() in BeOS // ToDo: this might not be in the same order as find_thread() in BeOS
// which could be theoreticly problematic. // which could be theoretically problematic.
// ToDo: scanning the whole list with the thread lock held isn't exactly // ToDo: scanning the whole list with the thread lock held isn't exactly
// cheap either - although this function is probably used very rarely. // cheap either - although this function is probably used very rarely.
hash_open(thread_hash, &iterator); hash_open(sThreadHash, &iterator);
while ((thread = hash_next(thread_hash, &iterator)) != NULL) { while ((thread = hash_next(sThreadHash, &iterator)) != NULL) {
// Search through hash // Search through hash
if (thread->name != NULL && !strcmp(thread->name, name)) { if (thread->name != NULL && !strcmp(thread->name, name)) {
thread_id id = thread->id; thread_id id = thread->id;
@@ -1445,7 +1438,7 @@ snooze_etc(bigtime_t timeout, int timebase, uint32 flags)
if (timebase != B_SYSTEM_TIMEBASE) if (timebase != B_SYSTEM_TIMEBASE)
return B_BAD_VALUE; return B_BAD_VALUE;
status = acquire_sem_etc(gSnoozeSem, 1, B_ABSOLUTE_TIMEOUT | flags, timeout); status = acquire_sem_etc(sSnoozeSem, 1, B_ABSOLUTE_TIMEOUT | flags, timeout);
if (status == B_TIMED_OUT || status == B_WOULD_BLOCK) if (status == B_TIMED_OUT || status == B_WOULD_BLOCK)
return B_OK; return B_OK;