Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 1061 → Rev 1062

/kernel/trunk/generic/include/proc/task.h
37,6 → 37,7
/** Task structure. */
struct task {
SPINLOCK_DECLARE(lock);
char *name;
link_t th_head; /**< List of threads contained in this task. */
link_t tasks_link; /**< Link to other tasks within the system. */
as_t *as; /**< Address space. */
52,7 → 53,7
extern link_t tasks_head;
 
extern void task_init(void);
extern task_t *task_create(as_t *as);
extern task_t *task_run_program(void * program_addr);
extern task_t *task_create(as_t *as, char *name);
extern task_t *task_run_program(void *program_addr, char *name);
 
#endif
/kernel/trunk/generic/include/proc/thread.h
59,7 → 59,10
#define X_WIRED (1<<0)
#define X_STOLEN (1<<1)
 
/** Thread structure. There is one per thread. */
struct thread {
char *name;
link_t rq_link; /**< Run queue link. */
link_t wq_link; /**< Wait queue link. */
link_t th_link; /**< Links to threads within containing task. */
125,7 → 128,7
extern link_t threads_head; /**< List of all threads in the system. */
 
extern void thread_init(void);
extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags);
extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name);
extern void thread_ready(thread_t *t);
extern void thread_exit(void);
 
/kernel/trunk/generic/src/proc/scheduler.c
617,7 → 617,6
/* We are going to mess with scheduler structures,
* let's not be interrupted */
ipl = interrupts_disable();
printf("Scheduler dump:\n");
for (cpu=0;cpu < config.cpu_count; cpu++) {
 
if (!cpus[cpu].active)
624,8 → 623,8
continue;
 
spinlock_lock(&cpus[cpu].lock);
printf("cpu%d: nrdy: %d, needs_relink: %d\n",
cpus[cpu].id, atomic_get(&cpus[cpu].nrdy), cpus[cpu].needs_relink);
printf("cpu%d: address=%P, nrdy=%d, needs_relink=%d\n",
cpus[cpu].id, &cpus[cpu], atomic_get(&cpus[cpu].nrdy), cpus[cpu].needs_relink);
for (i=0; i<RQ_COUNT; i++) {
r = &cpus[cpu].rq[i];
/kernel/trunk/generic/src/proc/task.c
62,11 → 62,12
* Create new task with no threads.
*
* @param as Task's address space.
* @param name Symbolic name.
*
* @return New task's structure
*
*/
task_t *task_create(as_t *as)
task_t *task_create(as_t *as, char *name)
{
ipl_t ipl;
task_t *ta;
78,6 → 79,7
list_initialize(&ta->th_head);
list_initialize(&ta->tasks_link);
ta->as = as;
ta->name = name;
 
ipc_answerbox_init(&ta->answerbox);
101,9 → 103,12
 
/** Create new task with 1 thread and run it
*
* @param programe_addr Address of program executable image.
* @param name Program name.
*
* @return Task of the running program or NULL on error
*/
task_t * task_run_program(void *program_addr)
task_t * task_run_program(void *program_addr, char *name)
{
as_t *as;
as_area_t *a;
119,9 → 124,9
return NULL;
}
task = task_create(as);
task = task_create(as, name);
t = thread_create(uinit, (void *)((elf_header_t *)program_addr)->e_entry,
task, THREAD_USER_STACK);
task, 0, "uinit");
/*
* Create the data as_area.
148,8 → 153,8
for (cur=tasks_head.next; cur!=&tasks_head; cur=cur->next) {
t = list_get_instance(cur, task_t, tasks_link);
spinlock_lock(&t->lock);
printf("Task: %Q ActiveCalls: %d", t->taskid,
atomic_get(&t->active_calls));
printf("%s: address=%P, taskid=%Q, as=%P, ActiveCalls: %d",
t->name, t, t->taskid, t->as, atomic_get(&t->active_calls));
for (i=0; i < IPC_MAX_PHONES; i++) {
if (t->phones[i].callee)
printf(" Ph(%d): %P ", i,t->phones[i].callee);
/kernel/trunk/generic/src/proc/thread.c
248,11 → 248,12
* @param arg Thread's implementing function argument.
* @param task Task to which the thread belongs.
* @param flags Thread flags.
* @param name Symbolic name.
*
* @return New thread's structure on success, NULL on failure.
*
*/
thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags)
thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name)
{
thread_t *t;
ipl_t ipl;
279,6 → 280,7
t->saved_context.ipl = interrupts_read();
interrupts_restore(ipl);
t->name = name;
t->thread_code = func;
t->thread_arg = arg;
t->ticks = -1;
409,9 → 411,12
 
for (cur=threads_head.next; cur!=&threads_head; cur=cur->next) {
t = list_get_instance(cur, thread_t, threads_link);
printf("Thr: %d(%s) ", t->tid, thread_states[t->state]);
printf("%s: address=%P, tid=%d, state=%s, task=%P, code=%P, stack=%P, cpu=",
t->name, t, t->tid, thread_states[t->state], t->task, t->thread_code, t->kstack);
if (t->cpu)
printf("cpu%d ", t->cpu->id);
else
printf("none");
printf("\n");
}
 
/kernel/trunk/generic/src/main/kinit.c
80,7 → 80,7
* not mess together with kcpulb threads.
* Just a beautification.
*/
if ((t = thread_create(kmp, NULL, TASK, 0))) {
if ((t = thread_create(kmp, NULL, TASK, 0, "kmp"))) {
spinlock_lock(&t->lock);
t->flags |= X_WIRED;
t->cpu = &cpus[0];
105,7 → 105,7
*/
for (i = 0; i < config.cpu_count; i++) {
 
if ((t = thread_create(kcpulb, NULL, TASK, 0))) {
if ((t = thread_create(kcpulb, NULL, TASK, 0, "kcpulb"))) {
spinlock_lock(&t->lock);
t->flags |= X_WIRED;
t->cpu = &cpus[i];
126,7 → 126,7
/*
* Create kernel console.
*/
if ((t = thread_create(kconsole, "kconsole", TASK, 0)))
if ((t = thread_create(kconsole, "kconsole", TASK, 0, "kconsole")))
thread_ready(t);
else
panic("thread_create/kconsole\n");
142,7 → 142,7
if (init.tasks[i].addr % FRAME_SIZE)
panic("init[%d].addr is not frame aligned", i);
 
utask = task_run_program((void *) init.tasks[i].addr);
utask = task_run_program((void *) init.tasks[i].addr, "USPACE");
if (utask) {
if (!ipc_phone_0)
ipc_phone_0 = &utask->answerbox;
/kernel/trunk/generic/src/main/main.c
196,7 → 196,7
/*
* Create kernel task.
*/
k = task_create(AS_KERNEL);
k = task_create(AS_KERNEL, "KERNEL");
if (!k)
panic("can't create kernel task\n");
203,7 → 203,7
/*
* Create the first thread.
*/
t = thread_create(kinit, NULL, k, 0);
t = thread_create(kinit, NULL, k, 0, "kinit");
if (!t)
panic("can't create kinit thread\n");
thread_ready(t);