RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

* API CHANGE: thread_create no longer uses malloc

Browse Source
This commit is contained in:
Kaspar Schleiser 2010-10-25 15:40:01 +02:00
parent 2acc036831
commit f945b72067
11 changed files with 68 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
core/include/flags.h
View File

@ -15,9 +15,9 @@
#ifndef _FLAGS_H
#define _FLAGS_H
#define CREATE_WOUT_YIELD 4
#define CREATE_SLEEPING 1
#define EXPECTS_REPLY 2
#define AUTO_FREE 2
#define CREATE_WOUT_YIELD 4
#define CREATE_STACKTEST 8
/**

6
core/include/thread.h
View File

@ -19,7 +19,9 @@
/**
* @brief Creates a new thread.
* This version will allocate it's stack itself using malloc.
*
*
* @param cb Address of preallocated tcb structure
* @param stack Lowest address of preallocated stack space
* @param stacksize
* @param flags Options:
* YIELD: force context switch.
@ -32,7 +34,7 @@
*
* @return returns <0 on error, pid of newly created task else.
*/
int thread_create(int stacksize, char priority, int flags, void (*function) (void), const char* name);
int thread_create(tcb *cb, char *stack, int stacksize, char priority, int flags, void (*function) (void), const char* name);
/**
* @brief returns the status of a process.

11
core/kernel_init.c
View File

@ -41,6 +41,7 @@ volatile int lpm_prevent_sleep = 0;
extern void main(void);
extern void fk_switch_context_exit(void);
void fk_idle(void) {
while(1) {
if (lpm_prevent_sleep) {
@ -57,6 +58,12 @@ void fk_idle(void) {
const char *main_name = "main";
const char *idle_name = "idle";
static tcb main_tcb;
static char main_stack[KERNEL_CONF_STACKSIZE_MAIN];
static tcb idle_tcb;
static char idle_stack[KERNEL_CONF_STACKSIZE_IDLE];
#ifdef MODULE_AUTO_INIT
#define MAIN_FUNC auto_init
#else
@ -70,11 +77,11 @@ void kernel_init(void)
scheduler_init();
if (thread_create(KERNEL_CONF_STACKSIZE_IDLE, PRIORITY_IDLE, CREATE_WOUT_YIELD | CREATE_STACKTEST, fk_idle, idle_name) < 0) {
if (thread_create(&main_tcb, main_stack, sizeof(main_stack), PRIORITY_IDLE, CREATE_WOUT_YIELD | CREATE_STACKTEST, fk_idle, idle_name) < 0) {
printf("kernel_init(): error creating idle task.\n");
}
if (thread_create(KERNEL_CONF_STACKSIZE_MAIN, PRIORITY_MAIN, CREATE_WOUT_YIELD | CREATE_STACKTEST, MAIN_FUNC, main_name) < 0) {
if (thread_create(&idle_tcb, idle_stack, sizeof(idle_stack), PRIORITY_MAIN, CREATE_WOUT_YIELD | CREATE_STACKTEST, MAIN_FUNC, main_name) < 0) {
printf("kernel_init(): error creating main task.\n");
}

9
core/scheduler.c
View File

@ -149,12 +149,17 @@ extern void fk_switch_context_exit(void);
void fk_task_exit(void) {
DEBUG("fk_task_exit(): ending task %s...\n", fk_thread->name);
tcb* thread = (tcb*)fk_thread;
dINT();
fk_threads[fk_thread->pid] = NULL;
num_tasks--;
sched_set_status((tcb*)fk_thread, STATUS_STOPPED);
sched_set_status(thread, STATUS_STOPPED);
// if ( thread->flags & AUTO_FREE ) {
// free(thread)->stack_start);
// free(thread);
// }
free(((tcb*)fk_thread)->stack_start);
fk_thread = NULL;
fk_switch_context_exit();
}

55
core/thread.c
View File

@ -74,7 +74,7 @@ int fk_measure_stack_free(char* stack) {
return space;
}
int thread_create(int stacksize, char priority, int flags, void (*function) (void), const char* name)
int thread_create(tcb *cb, char *stack, int stacksize, char priority, int flags, void (*function) (void), const char* name)
{
/* stacksize must be a multitude of 4 for alignment and stacktest */
// assert( ((stacksize & 0x03) == 0) && (stacksize > 0) );
@ -86,20 +86,6 @@ int thread_create(int stacksize, char priority, int flags, void (*function) (voi
return -EINVAL;
}
tcb *pd = (tcb*)malloc(sizeof(tcb));
if ( pd == NULL) {
DEBUG("thread_create(): out of memory\n");
return -ENOMEM;
}
char *stack = (char*)malloc(stacksize);
if (stack==NULL)
{
DEBUG("thread_create(): out of memory\n");
free (pd);
return -ENOMEM;
}
if (flags & CREATE_STACKTEST) {
/* assign each int of the stack the value of it's address */
unsigned int *stackmax = (unsigned int*) ((char*)stack + stacksize);
@ -120,8 +106,8 @@ int thread_create(int stacksize, char priority, int flags, void (*function) (voi
int pid = 0;
while (pid < MAXTHREADS) {
if (fk_threads[pid] == NULL) {
fk_threads[pid] = pd;
pd->pid = pid;
fk_threads[pid] = cb;
cb->pid = pid;
break;
}
pid++;
@ -130,42 +116,39 @@ int thread_create(int stacksize, char priority, int flags, void (*function) (voi
if (pid == MAXTHREADS) {
DEBUG("thread_create(): too many threads!\n");
free (pd);
free (stack);
if (! inISR()) {
eINT();
}
return -EOVERFLOW;
}
pd->sp = fk_stack_init(function,stack+stacksize);
pd->stack_start = stack;
pd->stack_size = stacksize;
cb->sp = fk_stack_init(function,stack+stacksize);
cb->stack_start = stack;
cb->stack_size = stacksize;
pd->priority = priority;
pd->status = 0;
cb->priority = priority;
cb->status = 0;
pd->name = name;
cb->name = name;
pd->wait_data = NULL;
cb->wait_data = NULL;
pd->msg_queue.data = 0;
pd->msg_queue.priority = 0;
pd->msg_queue.next = NULL;
cb->msg_queue.data = 0;
cb->msg_queue.priority = 0;
cb->msg_queue.next = NULL;
pd->rq_entry.data = (unsigned int) pd;
pd->rq_entry.next = NULL;
pd->rq_entry.prev = NULL;
cb->rq_entry.data = (unsigned int) cb;
cb->rq_entry.next = NULL;
cb->rq_entry.prev = NULL;
num_tasks++;
DEBUG("Created thread %s. PID: %u. Priority: %u.\n", name, pd->pid, priority);
DEBUG("Created thread %s. PID: %u. Priority: %u.\n", name, cb->pid, priority);
if (flags & CREATE_SLEEPING) {
sched_set_status(pd, STATUS_SLEEPING);
sched_set_status(cb, STATUS_SLEEPING);
} else {
sched_set_status(pd, STATUS_PENDING);
sched_set_status(cb, STATUS_PENDING);
if (!(flags & CREATE_WOUT_YIELD)) {
if (! inISR()) {
eINT();

10
drivers/cc110x/cc1100_phy.c
View File

@ -94,11 +94,15 @@ static const pm_table_t handler_table;
static const char *cc1100_event_handler_name = "cc1100_event_handler";
static mutex_t cc1100_mutex;
volatile int cc1100_mutex_pid;
static uint16_t cc1100_event_handler_pid;
static void cc1100_event_handler_function(void);
static swtimer_t cc1100_watch_dog;
static uint64_t cc1100_watch_dog_period = 0;
static uint16_t cc1100_event_handler_pid;
static void cc1100_event_handler_function(void);
static tcb event_handler_tcb;
static char event_handler_stack[KERNEL_CONF_STACKSIZE_MAIN];
/*---------------------------------------------------------------------------*/
// Sequence number buffer management data structures
/*---------------------------------------------------------------------------*/
@ -188,7 +192,7 @@ void cc1100_phy_init()
mutex_init(&cc1100_mutex);
// Allocate event numbers and start cc1100 event process
cc1100_event_handler_pid = thread_create(2500, PRIORITY_CC1100, CREATE_STACKTEST,
cc1100_event_handler_pid = thread_create(&event_handler_tcb, event_handler_stack, sizeof(event_handler_stack), PRIORITY_CC1100, CREATE_STACKTEST,
cc1100_event_handler_function, cc1100_event_handler_name);
// Active watchdog for the first time

5
projects/pingpong/main.c
View File

@ -15,13 +15,16 @@ void second_thread(void) {
}
}
tcb second_thread_tcb;
char second_thread_stack[KERNEL_CONF_STACKSIZE_MAIN];
int main(void)
{
printf("Hello world!\n");
msg m;
int pid = thread_create(KERNEL_CONF_STACKSIZE_MAIN, PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, second_thread, "pong");
int pid = thread_create(&second_thread_tcb, second_thread_stack, sizeof(second_thread_stack), PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, second_thread, "pong");
m.content.value = 1;

5
projects/pingpong_sync/main.c
View File

@ -15,13 +15,16 @@ void second_thread(void) {
}
}
tcb second_thread_tcb;
char second_thread_stack[8192];
int main(void)
{
printf("Hello world!\n");
msg m;
int pid = thread_create(8192, PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, second_thread, "pong");
int pid = thread_create(&second_thread_tcb, second_thread_stack, sizeof(second_thread_stack), PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, second_thread, "pong");
m.content.value = 1;

4
projects/test_sleep/main.c
View File

@ -18,6 +18,8 @@ void second_thread(void) {
}
}
tcb second_thread_tcb;
char second_thread_stack[KERNEL_CONF_STACKSIZE_DEFAULT];
int main(void)
{
@ -25,7 +27,7 @@ int main(void)
printf("Hello world!\n");
int pid = thread_create(KERNEL_CONF_STACKSIZE_DEFAULT, PRIORITY_MAIN-1, CREATE_STACKTEST | CREATE_SLEEPING | CREATE_WOUT_YIELD, second_thread, "sleeper");
int pid = thread_create(&second_thread_tcb, second_thread_stack, sizeof(second_thread_stack), PRIORITY_MAIN-1, CREATE_STACKTEST | CREATE_SLEEPING | CREATE_WOUT_YIELD, second_thread, "sleeper");
if (pid < 0) {
puts("Error creating second_thread! Stopping test.");

5
projects/test_thread_exit/main.c
View File

@ -9,8 +9,11 @@ void second_thread(void) {
puts("2nd: running...");
}
tcb second_thread_tcb;
char second_thread_stack[8192];
int main(void)
{
int pid = thread_create(8192, PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, second_thread, "nr2");
int pid = thread_create(&second_thread_tcb, second_thread_stack, sizeof(second_thread_stack), PRIORITY_MAIN-1, CREATE_WOUT_YIELD | CREATE_STACKTEST, second_thread, "nr2");
puts("Main thread exiting...");
}

6
sys/uart0.c
View File

@ -13,15 +13,19 @@ int uart0_handler_pid;
static char buffer[UART0_BUFSIZE];
static tcb uart0_thread_tcb;
static char uart0_thread_stack[KERNEL_CONF_STACKSIZE_MAIN];
static void uart0_loop() {
chardev_loop(&uart0_ringbuffer);
}
void board_uart0_init() {
ringbuffer_init(&uart0_ringbuffer, buffer, UART0_BUFSIZE);
int pid = thread_create(KERNEL_CONF_STACKSIZE_MAIN, PRIORITY_MAIN-1, CREATE_STACKTEST, uart0_loop, "uart0");
int pid = thread_create(&uart0_thread_tcb, uart0_thread_stack, sizeof(uart0_thread_stack), PRIORITY_MAIN-1, CREATE_STACKTEST, uart0_loop, "uart0");
uart0_handler_pid = pid;
puts("uart0_init() [OK]");
printf("%i\n", sizeof(uart0_thread_stack));
}
void uart0_handle_incoming(int c) {