void *malloc_realloc(malloc_t *heap, void *ptr, size_t n) { void *new_ptr; if (n > MAX_SIZE) return NULL; if (n == 0) { malloc_free(heap, ptr); return NULL; } if (ptr == NULL) return malloc_alloc(heap, n); if (malloc_size(heap, ptr) >= n) return ptr; new_ptr = malloc_alloc(heap, n); if (new_ptr == NULL) return NULL; memcpy(new_ptr, ptr, malloc_size(heap, ptr)); malloc_free(heap, ptr); return new_ptr; }
void task_init() { active_tasks = (struct list_t *)malloc_alloc(sizeof(struct list_t)); list_init(active_tasks); inactive_tasks = (struct list_t *)malloc_alloc(sizeof(struct list_t)); list_init(inactive_tasks); struct task_t *task = (struct task_t *)malloc_alloc(sizeof(struct task_t)); task->sp = 0; task->msg = 0; list_add_first(active_tasks, task); current_task_it = list_first(active_tasks); }
int init_process(struct pcb_s *pcb, int stack_size, func_t* f, int period, int calcul) { /* Function and args */ pcb->entry_point = f; /* Stack allocation */ pcb->size=stack_size; pcb->stack_base = malloc_alloc(stack_size); if(!pcb->stack_base) return 0; /* State and context */ pcb->state = NEW; pcb->sp = ((uint32_t*) (pcb->stack_base + stack_size)) - 1; /* Fill in the stack with CPSR and PC */ *(pcb->sp) = 0x53; pcb->sp --; *(pcb->sp) = (unsigned int) &start_current_process; /* SET RMS attributes */ pcb->calcul = calcul; pcb->period = period; pcb->calcul_remaining = 0; pcb->period_remaining = 0; return 1; }
void sem_down(struct sem_s* sem) { DISABLE_IRQ(); if (sem->val <= 0) { // Initializing "wait_proc" struct waiting_process* wait_proc = (struct waiting_process*) malloc_alloc(sizeof(struct waiting_process)); wait_proc->process = current_process; wait_proc->next = 0; // If the waiting queue is empty, we put our process as the first (and only) waiting element if (sem->waiting == 0) { sem->last_process = wait_proc; sem->queue = wait_proc; } // Otherwise we put it at the end of the queue else { sem->last_process->next = wait_proc; sem->last_process = wait_proc; } sem->waiting += 1; current_process->state = WAITING; ENABLE_IRQ(); while(current_process->state== WAITING){ //DO NOTHING } } else { sem->val -= 1; ENABLE_IRQ(); } }
struct task_t *task_start(task_func_t *task_func) { struct task_t *task = (struct task_t *)malloc_alloc(sizeof(struct task_t)); char *p = malloc_alloc(0x800); p += 0x800; task->sp = (uint32 *)(p); // 2k stack task->msg = 0; task->state = TASK_STATE_ACTIVE; list_init(&task->input_channels); list_init(&task->output_channels); task_create(&task->sp, task_func); list_add_last(active_tasks, task); print_buf("task start:"); print_buf(" t="); print_ptr(task); print_buf(" t->sp="); print_ptr(task->sp); print_buf("\n"); return task; }
struct mutex_s * mutex_create() { struct mutex_s * mutex = (struct mutex_s *) malloc_alloc( sizeof(struct mutex_s)); if (mutex == NULL) { return NULL; } if (mutex_init(mutex) == -1) { malloc_free(mutex); return NULL; } return mutex; }
void *calloc(size_t count, size_t size) { size_t n = count * size; void *ptr; if ((uintmax_t)count * size > (uintmax_t)SIZE_MAX) return NULL; ptr = malloc_alloc(&g_heap, n); if (ptr == NULL) return NULL; cgc_memset(ptr, 0, n); return ptr; }
int create_process(func_t* f, unsigned size, int period, int calcul) { struct pcb_s *pcb; pcb = (struct pcb_s*) malloc_alloc(sizeof(struct pcb_s)); if(!pcb) return 0; if (! ready_queue) {/* First process */ ready_queue = pcb; } else { pcb->next = ready_queue->next; } ready_queue->next = pcb; return init_process(pcb,size,f,period,calcul); }
void sem_down(struct sem_s* sem) { DISABLE_IRQ(); if (sem->val <= 0) { // Initializing "wait_proc" struct waiting_process* wait_proc = (struct waiting_process*) malloc_alloc(sizeof(struct waiting_process)); wait_proc->process = current_process; wait_proc->next = 0; // If the waiting queue is empty, we put our process as the first (and only) waiting element if (sem->waiting == 0) { sem->last_process = wait_proc; sem->queue = wait_proc; } // Otherwise we put it at the end of the queue else { sem->last_process->next = wait_proc; sem->last_process = wait_proc; } sem->waiting += 1; // TODO : Marche pas si c'est le dernier process de sa queue // ... 'va juste changer la valeur de current_process->schedule_queue move_process(current_process, ¤t_process->schedule_queue, waiting) current_process->state = WAITING; ENABLE_IRQ(); // TODO : Schedule instead of doing a while while(current_process->state== WAITING){ //DO NOTHING } } else { sem->val -= 1; ENABLE_IRQ(); } }
void mtx_init(struct mtx_s** mutex){ (*mutex) = (struct mtx_s*) malloc_alloc(sizeof(struct mtx_s)); (*mutex)->owner = 0; sem_init( &( (*mutex)->sem_mtx ), 1); //mutex->pOwnerPid=getpid(); }
void sem_init(struct sem_s** sem, unsigned int val){ *sem = (struct sem_s*) malloc_alloc(sizeof(struct sem_s)); (*sem)->val = val; (*sem)->waiting = 0; (*sem)->queue = 0; }