|
Interface: TaskManager Arquivos: taskmanager.h Última atualização: 15/06/2005 Autor: Luiz Henrique Shigunov |
Descrição Estruturas |
| Funções para o sistema | |
|
xxxx - AtomicAdd - Adiciona atomicamente xxxx - AtomicDec - Decrementa atomicamente xxxx - AtomicInc - Incrementa atomicamente xxxx - AtomicSub - Subtrai atomicamente 0x00 - CancelWait - Cancela a espera de uma tarefa 0x01 - CreateTask - Cria uma tarefa 0x02 - CreateThread - Cria uma linha de execução 0x03 - DelTaskInfo - Retira dados armazenados na estrutura da tarefa 0x04 - DelThreadInfo - Retira dados armazenados na estrutura da linha de execução 0x2d - Destroyable - Marca a tarefa destrutível 0x30 - DestroyableThread - Marca a linha de execução destrutível 0x05 - DestroyTask - Destrói uma tarefa 0x06 - DestroyThread - Destrói uma linha de execução 0x18 - GetLastError - Obtém informações sobre o último erro 0x07 - GetMsCounter - Obtém o contador de ms 0x26 - GetParentTaskHandle - Obtém a referência para o pai da tarefa 0x27 - GetTaskHandleID - Obtém a referência para a tarefa 0x08 - GetTaskHandle - Obtém a referência para a tarefa 0x28 - GetTaskID - Obtém o identificador da tarefa 0x09 - GetTaskInfo - Obtém dados armazenados na estrutura da tarefa 0x1d - GetTaskMMap - Obtém o mapeamento de memória da tarefa 0x29 - GetThreadHandleID - Obtém a referência para linha de execução 0x0a - GetThreadHandle - Obtém a referência para linha de execução |
0x2a - GetThreadID - Obtém o identificador da linha de execução 0x0b - GetThreadInfo - Obtém dados armazenados na estrutura da linha de execução 0x0c - GetThreadStatus - Obtém o estado da linha de execução 0x0d - LockRead - Obtém o sincronizador do tipo leitura/escrita para leitura 0x0e - LockWrite - Obtém o sincronizador do tipo leitura/escrita para escrita 0x0f - P - Obtém um semáforo 0x10 - Resume - Ativa uma linha de execução parada 0x11 - Schedule - Muda de tarefa, mas não salva os registradores 0x2e - SetLastError - Define o último erro ocorrido 0x12 - SetTaskInfo - Guarda dados na estrutura da tarefa 0x13 - SetThreadInfo - Guarda dados na estrutura da linha de execução 0x14 - SpinLock - Obtém um spinlock 0x15 - SpinUnlock - Libera um spinlock 0x16 - Suspend - Suspende uma linha de execução 0x17 - ToUserLevel - Retorna para o espaço do usuário 0x2f - UndestroyableThread - Marca a linha de execução indestrutível 0x19 - UnlockRW - Libera um sincronizador do tipo leitura/escrita 0x1a - V - Libera um semáforo 0x1b - Wait - Suspende uma linha de execução por um determinado tempo 0x1e - WaitQueueAdd - Adiciona uma linha de execução numa fila de espera 0x1f - WaitQueueWakeup - Acorda todas as linhas de execução duma fila de espera 0x1c - Yield - Muda de tarefa salvando os registradores |
| Funções para o usuário | |
|
0x20 - UCreateThread - Cria uma linha de execução 0x21 - UDestroyThread - Destrói uma linha de execução 0x31 - UGetLastError - Obtém informações sobre o último erro 0x2b - UGetParentTaskID - Obtém o identificador do pai da tarefa 0x2c - UGetTaskID - Obtém o identificador da tarefa |
0x22 - UGetThreadID - Obtém o identificador da linha de execução 0x23 - UP - Obtém um semáforo 0x32 - USetLastError - Define o último erro ocorrido 0x24 - UTryP - Tenta obter um semáforo 0x25 - UV - Libera um semáforo |
Esta página descreve a interface TaskManager.
O administrador de tarefas é responsável por administrar as tarefas (processos) e as diversas linhas de execução (thread) que uma tarefa possa ter, por fornecer serviços de sincronização de linhas de execução, por armazenar dados associados a tarefas e linhas de execução, por fornecer dados sobre as tarefas e linhas de execução e por fornecer eventos sobre tarefas e linhas de execução.
Todo tarefa criada com esta interface possui:
Uma tarefa pode ser do sistema e nesse caso não tem um mapeamento de memória próprio, mas usa o mapeamento corrente. Sendo assim, uma linha de execução de uma tarefa do sistema não deve acessar a área de memória do usuário.
Cada linha de execução (thread) criada com esta interface tem o seguinte:
É a linha de execução que executa algum código. Uma tarefa tem uma ou várias linhas de execução, sendo que cada uma tem o mesmo tempo e frequência de execução na tarefa.
O ModulOS usa o mesmo conceito de árvore de tarefas/processos que o sistema Unix, ou seja, a tarefa que cria uma tarefa passa a ser a mãe (pai, no caso de processos) da tarefa criada e a tarefa criada a filha. Existindo assim uma árvore de tarefas.
Para um módulo do sistema criar uma tarefa que execute em modo usuário, é feito o seguinte: o módulo chama a função CreateTask com o ponto de início onde a linha de execução criada junto com a tarefa vai começar a executar. Esse ponto tem que estar dentro da área de memória do sistema.
A função que for executada pela linha de execução deve carregar o código que quiser na área de memória do usuário e depois chamar a função ToUserLevel para passar a executar o código carregado em modo usuário.
Sempre que uma linha de execução que execute código em modo usuário passar a executar código do sistema, ela deve ser marcada indestrutível e quando retornar deve ser marcada destrutível novamente. Isso porque os módulos do sistema assumem que a linha de execução que está executando código do sistema não será destruída. Se ela poder ser destruída, semáforos, estruturas de dados, etc podem ficar num estado indefinido.
Como as linhas de execução indestrutíveis ficam impedidas de serem destruídas muito cuidado deve ser tomado com as linhas de execução que ficam paradas em sincronizadores. Para impedir que uma linha de execução fique indestrutível para sempre as linhas de execução que podem ficar paradas em sincronizadores devem ser marcadas como interruptíveis.
Quando uma linha de execução marcada interruptível obter um sincronizador, a função que obtém o sincronizador pode retornar um código de erro indicando que o sincronizador não foi obtido porque a linha de execução está sendo destruida.
Vários mecanismo estão disponíveis para sincronizar as linhas de execução. Entre eles: semáforos, spin locks, leitores/escritores.
Muito cuidado deve ser tomado na utilização de sincronizadores. Eles só devem ser usados para a proteção de dados do próprio módulo para evitar bloqueios mortais ("deadlocks").
Muitos módulos necessitam guardar informações sobre cada tarefa e/ou linha de execução. Um jeito seria cada módulo manter uma estrutura que relacionasse a tarefa e/ou linha de execução com os dados. Porém, esse método tem certos inconvenientes. Entre eles: maior quantidade de memória necessária (além dos dados precisa de uma estrutura de armazenamento e busca); tempo de acesso maior (tem que procurar na estrutura onde está a informação) e problemas de sincronizar o acesso a essa estrutura.
Pensando nisso, foi criado um mecanismo para permitir que informações de um módulo fossem guardadas na estrutura da tarefa e/ou linha de execução. Com isso se economiza memória, o tempo de acesso é mais rápido (um ponteiro para a tarefa e linha de execução correntes estão disponíveis) e o problema de sincronizar o acesso fica minimizado se for utilizado apenas a tarefa ou linha de execução correntes.
São oferecidas várias funções para inserir, retirar, atualizar ou obter essas informações armazenadas na tarefa ou linha de execução.
O módulo que implementar esta interface deve gerar os eventos definidos em TaskManagerE.
typedef struct {
void *data[4];
} TaskManager_RWSync;
Esta é a estrutura de um sincronizador do tipo leitor/escritor, onde várias linhas de execução podem ler e somente uma pode escrever.
Não é um sincronizador recursivo, ou seja, se uma mesma linha de execução chamar a função LockWrite mais de uma vez ela será bloqueada.
Esta estrutura deve ser iniciada com zero.
typedef struct {
int count;
void *data;
} TaskManager_Semaphore;
Esta é a estrutura de um sincronizador do tipo semáforo.
É um sincronizador não recursivo.
count deve ser iniciado com o valor inicial do semáforo e data com NULL. Se count for menor ou igual a 0, a função P bloqueia.
typedef struct {
void *data;
} TaskManager_WaitQueue;
Esta é a estrutura de um sincronizador do tipo fila de espera, onde várias linhas de execução esperam um evento e são todas retiradas quando o evento acontece.
data deve ser iniciado com NULL.
Estas estruturas são definidas aqui para permitir criar estaticamente um sincronizador. Isso é importante para alguns módulos para evitar recursão.
Estas funções são de uso exclusivo dos módulos do sistema.
void TaskManager_AtomicAdd(unsigned int *var, unsigned int value);
Esta função é uma função inline, ou seja, é como uma macro e, por isso, não precisa ser especifica no usedfunctions do .spec do módulo.
Ela adiciona atomicamente value em var.
void TaskManager_AtomicDec(unsigned int *var);
Esta função é uma função inline, ou seja, é como uma macro e, por isso, não precisa ser especifica no usedfunctions do .spec do módulo.
Ela decrementa atomicamente var.
void TaskManager_AtomicInc(unsigned int *var);
Esta função é uma função inline, ou seja, é como uma macro e, por isso, não precisa ser especifica no usedfunctions do .spec do módulo.
Ela incrementa atomicamente var.
void TaskManager_AtomicSub(unsigned int *var, unsigned int value);
Esta função é uma função inline, ou seja, é como uma macro e, por isso, não precisa ser especifica no usedfunctions do .spec do módulo.
Ela subtrai atomicamente value de var.
int TaskManager_CancelWait(TaskManager_Thread *thread, int prop);
Esta função cancela a espera da linha thread.
thread tem que estar marcada indestrutível.
prop deve ser 0 ou a soma de:
int TaskManager_CreateTask(void *startCode, void *arg, int prop, TaskManager_Task **task, TaskManager_Thread **thread);
Esta função cria uma tarefa e uma linha de execução.
A linha de execução criada vai começar a executar no ponto startCode, que tem que estar dentro da área de memória dos módulos do sistema, e vai ter como parâmetro arg. Se a linha de execução retornar ela é terminada.
prop tem o seguinte formato:
| Bit | Descrição |
|---|---|
| 0 | 1 - TaskManager_CREATE_SUS - linha de execução criada suspensa |
| 1 | 1 - TaskManager_CREATE_SYSTEM - tarefa do sistema |
| 24-31 | prioridade da tarefa |
A prioridade da tarefa varia de 0-100, sendo 0 a tarefa idle, ou seja, só é executada quando não existirem outras tarefas não idle.
Tarefas com prioridade maior ou igual a 60 devem ser usadas pelo sistema apenas.
A linha de execução criada vai estar marcada indestrutível e responsabilidade de quem chama marca-la destrutível.
Em caso de sucesso, task e thread conterão a referência para a tarefa e para a linha de execução.
int TaskManager_CreateThread(TaskManager_Task *task, void *startCode, void *arg, int prop, TaskManager_Thread **thread);
Esta função cria uma linha de execução para a tarefa task que vai começar a executar em startCode e vai ter como parâmetro arg. Se a linha de execução retornar ela é terminada.
Se task for NULL, a linha será criada na tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
startCode tem que estar dentro da área de memória dos módulos do sistema.
prop deve ser 0 ou:
A linha de execução criada vai estar marcada indestrutível e responsabilidade de quem a cria marca-la destrutível.
Em caso de sucesso, thread conterá a referência para a linha de execução.
void *TaskManager_DelTaskInfo(TaskManager_Task *task, SysModManager_Module *module);
Esta função retira a entrada do módulo module da estrutura da tarefa task.
Se task for NULL, será retirado da tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
Utilize as macros IS_PTR_ERROR e PTR_TO_ERROR para saber se ocorreu erro e para obter o erro respectivamente.
void *TaskManager_DelThreadInfo(TaskManager_Thread *thread, SysModManager_Module *module);
Esta função retira a entrada do módulo module da estrutura da linha de execução thread.
Se thread for NULL, será retirado da linha de execução chamadora.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
Utilize as macros IS_PTR_ERROR e PTR_TO_ERROR para saber se ocorreu erro e para obter o erro respectivamente.
void TaskManager_Destroyable(TaskManager_Task *task);
Esta função marca a tarefa task destrutível e tem que ser chamada a mesma quantidade de vezes que a tarefa foi marcada indestrutível para a tarefa se tornar destrutível.
Se task for NULL, a tarefa chamadora será usada.
Quando uma tarefa marcada destrutível for destruida ela será destruida imediatamente.
Se a tarefa task já estiver sendo destruida e se a linha de execução chamadora pertencer à essa tarefa, a linha de execução será destruida, ou seja, a função não retornará.
void TaskManager_DestroyableThread(TaskManager_Thread *thread);
Esta função marca a linha de execução thread destrutível e tem que ser chamada a mesma quantidade de vezes que a função UndestroyableThread para a linha de execução se tornar destrutível.
Se thread for NULL, a linha de execução chamadora será usada.
Quando uma linha de execução marcada destrutível for destruida ela será destruida imediatamente.
Se thread for NULL e se a linha de execução chamadora já estiver sendo destruida a linha de execução será destruida, ou seja, a função não retornará.
int TaskManager_DestroyTask(TaskManager_Task *task);
Esta função destrói a tarefa task e as suas linhas de execução também.
Se o task for NULL, a tarefa chamadora será terminada.
task tem que estar marcada indestrutível.
Lembre-se que uma tarefa executando código do sistema já está marcada indestrutível, ou seja, se task for NULL você não precisa chamar a função UndestroyableThread e se task não for NULL ela já está marcada indestrutível ou você não poderia usar task.
Antes de destruir cada linha de execução da tarefa, o evento ThreadDestroyed é disparado e antes de destruir a tarefa o evento TaskDestroyed é disparado.
Para receber esses eventos, o módulo tem que implementar a interface TaskManagerE.
int TaskManager_DestroyThread(TaskManager_Thread *thread);
Esta função destrói a linha de execução thread.
Se thread for NULL, a linha de execução chamadora será terminada.
thread tem que estar marcada indestrutível.
Antes de destruir a linha de execução, o evento ThreadDestroyed é disparado.
Para receber esse evento, o módulo tem que implementar a interface TaskManagerE.
long TaskManager_GetLastError(const char **name, int *function);
Esta função obtém o último erro ocorrido definido pela função SetLastError.
name é opcional e pode ser NULL. Caso não seja NULL, receberá o ponteiro para o nome da interface ou módulo que gerou o erro.
Se name tiver o nome da interface o valor retornado pela função terá o bit mais alto igual a 1 (o número será negativo). Caso contrário, name terá o nome do módulo que gerou o erro.
Isso foi feito dessa maneira para permitir que implementações de interfaces possam especificar seus próprios erros.
function é opcional e pode ser NULL. Caso não seja NULL, receberá o número da função que gerou o erro.
unsigned int TaskManager_GetMsCounter(void);
Esta função obtém o valor do contador de milessegundos(ms). Esse contador é incrementado a cada ms.
Com isso, uma tarefa pode ter um contador de ms.
TaskManager_Task *TaskManager_GetParentTaskHandle(TaskManager_Task *task);
Esta função obtém a referência para o pai da tarefa task.
Se task for NULL, obtém da tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
Em caso de sucesso, a tarefa pai será marcada indestrutível e é responsabilidade de quem chama marcar a tarefa pai destrutível quando terminar de usar a referência.
A referência para o pai da tarefa.
TaskManager_Task *TaskManager_GetTaskHandleID(int taskID);
Esta função obtém a referência para a tarefa com ID taskID.
Se taskID for zero, obtém da tarefa chamadora.
Em caso de sucesso, a tarefa será marcada indestrutível e é responsabilidade de quem chama marcar a tarefa destrutível quando terminar de usar a referência.
A referência para a tarefa ou NULL se ID inválido.
TaskManager_Task *TaskManager_GetTaskHandle(TaskManager_Thread *thread);
Esta função obtém a referência para a tarefa da linha de execução thread.
Se thread for NULL, obtém da linha de execução chamadora.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
Em caso de sucesso, a tarefa será marcada indestrutível e é responsabilidade de quem chama marcar a tarefa destrutível quando terminar de usar a referência.
int TaskManager_GetTaskID(TaskManager_Task *task);
Esta função obtém o ID da tarefa task.
Se task for NULL, obtém da tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
void *TaskManager_GetTaskInfo(TaskManager_Task *task, SysModManager_Module *module);
Esta função obtém os dados do módulo module da estrutura da tarefa task.
Se task for NULL será obtido da tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
Utilize as macros IS_PTR_ERROR e PTR_TO_ERROR para saber se ocorreu erro e para obter o erro respectivamente.
int TaskManager_GetTaskMMap(TaskManager_Task *task);
Esta função obtém o mapeamento de memória da tarefa task.
Se task for NULL, será obtido da tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
O mapeamento de mória da tarefa.
TaskManager_Thread *TaskManager_GetThreadHandleID(TaskManager_Task *task, int threadID);
Esta função obtém a referência para a linha de execução com ID threadID da tarefa task.
Se threadID for zero, obtém da linha de execução chamadora.
Se task for NULL, usa a tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
Em caso de sucesso, a linha de execução será marcada indestrutível e é responsabilidade de quem chama marcar a linha de execução destrutível quando terminar de usar a referência.
A referência para a linha de execução ou NULL se ID inválido.
TaskManager_Thread *TaskManager_GetThreadHandle(void);
Esta função obtém a referência para a linha de execução chamadora.
Em caso de sucesso, a linha de execução será marcada indestrutível e é responsabilidade de quem chama marcar a linha de execução destrutível quando terminar de usar a referência.
A referência para a linha de execução.
int TaskManager_GetThreadID(TaskManager_Thread *thread);
Esta função obtém o ID da linha de execução thread.
Se thread for NULL, obtém da linha de execução chamadora.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
void *TaskManager_GetThreadInfo(TaskManager_Thread *thread, SysModManager_Module *module);
Esta função obtém os dados do módulo module da estrutura da linha de execução thread.
Se thread for NULL, será obtido da linha de execução chamadora.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
Utilize as macros IS_PTR_ERROR e PTR_TO_ERROR para saber se ocorreu erro e para obter o erro respectivamente.
int TaskManager_GetThreadStatus(TaskManager_Thread *thread);
Esta função obtém o estado da linha de execução thread.
Se thread for NULL, será obtido da linha de execução chamadora.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
int TaskManager_LockRead(TaskManager_RWSync *rw, int prop);
Esta função obtém o sincronizador rw para leitura.
prop deve ser 0 ou:
int TaskManager_LockWrite(TaskManager_RWSync *rw, int prop);
Esta função obtém o sincronizador rw para escrita.
prop deve ser 0 ou:
int TaskManager_P(TaskManager_Semaphore *semaphore, int prop, unsigned int timeout);
Esta função obtém o semáforo semaphore.
Se a linha de execução bloquear ela ficará bloqueada por no máximo timeout milisegundos. Porém, se timeout for zero a linha de execução ficará bloqueada até obter o semáforo.
prop deve ser 0 ou:
int TaskManager_Resume(TaskManager_Thread *thread, int prop);
Esta função ativa a linha de execução thread. A linha de execução chamadora pode perder a CPU.
thread tem que estar marcada indestrutível.
prop deve ser 0 ou o soma de:
void TaskManager_Schedule(void);
Esta função implementa o algoritmo de escalonamento, mudando de tarefa de acordo com a política escolhida. Mas ela não salva os registradores da CPU e as interrupções devem estar desabilitadas antes de chamá-la.
long TaskManager_SetLastError(long error, const char *name, int function);
Esta função define o último erro ocorrido que pode ser obtido pela função GetLastError.
error é o código de erro, name o nome da interface ou módulo que gerou o erro e function o número da função que gerou o erro.
name não pode ser NULL. Se error tiver o bit mais alto igual a 1 (se error for negativo), name tem que ter o nome da interface que gerou o erro. Caso contrário deve ter o nome do módulo que gerou o erro.
Isso foi feito para permitir que os módulos possam ter seus próprios códigos de erro.
void *TaskManager_SetTaskInfo(TaskManager_Task *task, SysModManager_Module *module, void *info, int prop);
Esta função guarda os dados info do módulo module na estrutura da tarefa task.
Se task for NULL, será armazenado na tarefa chamadora.
Caso task seja diferente de NULL, task tem que estar marcada indestrutível.
prop pode ser:
Se o módulo module já tiver dados na estrutura da tarefa, estes serão atualizados se prop for 0.
Utilize as macros IS_PTR_ERROR e PTR_TO_ERROR para saber se ocorreu erro e para obter o erro respectivamente.
void *TaskManager_SetThreadInfo(TaskManager_Thread *thread, SysModManager_Module *module, void *info, int prop);
Esta função guarda os dados info do módulo module na estrutura da linha de execução thread.
Se thread for NULL, será armazenado na linha de execução chamadora.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
prop pode ser:
Se o módulo module já tiver dados na estrutura da linha, estes serão atualizados se prop for 0.
Utilize as macros IS_PTR_ERROR e PTR_TO_ERROR para saber se ocorreu erro e para obter o erro respectivamente.
void TaskManager_SpinLock(int *lock);
Esta função garante exclusividade de execução depois que é chamada, ou seja, garante que o código depois da chamada da funções só estará sendo executado por um processador ao mesmo tempo.
Só deve ser chamada para garantir exclusividade de código que não bloqueia. É indicada para operações rápidas. As interrupções podem estar desabilitadas depois da chamada da função.
lock deve ser iniciado com 0, antes de começar a ser utilizado.
void TaskManager_SpinUnlock(int *lock);
Esta função libera o sincronizador.
int TaskManager_Suspend(TaskManager_Thread *thread);
Esta função suspende a linha de execução thread.
Se thread for NULL, a linha de execução chamadora será suspensa.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
void TaskManager_ToUserLevel(TaskManager_Regs *regs);
Esta função retorna para o espaço de execução do usuário definindo os valores dos registradores da máquina para regs.
Cada arquitetura define regs de uma maneira. Por isso, é preciso utilizar o arquivo .h específico dessa arquitetura para ter a definição de regs.
Esta função é utilizada para mudar para o espaço do usuário depois de criar uma tarefa.
void TaskManager_UndestroyableThread(void);
Esta função marca a linha de execução e a tarefa chamadora indestrutível.
A função DestroyableThread tem que ser chamada a mesma quantidade de vezes que esta para a linha de execução se tornar destrutível.
Quando uma linha de execução marcada indestrutível for destruida ela só será destruida quando ela estiver marcada destrutível.
Se a tarefa/linha de execução chamadora já estiver sendo destruida, a linha de execução será destruida, ou seja, a função não retornará.
int TaskManager_UnlockRW(TaskManager_RWSync *rw, int prop);
Esta função libera o sincronizador rw tanto da leitura como da escrita. Quem chama pode perder a CPU.
prop pode ser:
int TaskManager_V(TaskManager_Semaphore *semaphore, int prop);
Esta função libera o semáforo semaphore. Quem chama pode perder a CPU.
prop pode ser:
int TaskManager_Wait(TaskManager_Thread *thread, unsigned int time);
Esta função suspende a linha thread por time milisegundos.
Se thread for NULL, a linha de execução chamadora é suspensa.
Caso thread seja diferente de NULL, thread tem que estar marcada indestrutível.
int TaskManager_WaitQueueAdd(TaskManager_WaitQueue *waitQ, TaskManager_Semaphore *sem, int prop);
Esta função adiciona a linha de execução chamadora na fila de espera waitQ, suspende-a e chama V para o semáforo sem.
prop deve ser 0 ou:
int TaskManager_WaitQueueWakeup(TaskManager_WaitQueue *waitQ);
Esta função acorda todas as linhas na fila de espera waitQ.
void TaskManager_Yield(void);
Esta função cede a CPU, ou seja, indica que a linha de execução não tem o que fazer. Mas, ao contrário de Schedule, ela salva os registradores da CPU e as interrupções não precisam estar desabilitadas (mas podem estar) antes de chamá-la.
Nada.
Estas funções foram projetadas para os módulos do usuário.
int TaskManager_UCreateThread(void *stack, void *startCode, int prop);
Do usuário.
Esta função cria uma linha de execução para a tarefa chamadora.
A linha de execução criada vai começar a executar em startCode com o endereço da pilha em stack.
prop deve ser 0 ou:
int TaskManager_UDestroyThread(int threadID, void *stack, unsigned int size);
Do usuário.
Esta função destrói a linha de execução threadID.
Se threadID for 0, a linha de execução chamadora será destruida.
Antes da linha de execução ser destruida a pilha stack de tamanho size é liberada.
long TaskManager_UGetLastError(char *name, int *function);
Do usuário.
Esta função obtém o último erro ocorrido definido pela função SetLastError ou USetLastError.
name é opcional e pode ser NULL. Caso não seja NULL, receberá o nome da interface ou módulo que gerou o erro. name tem que ter no mínimo 32 bytes de tamanho.
Se name tiver o nome da interface o valor retornado pela função terá o bit mais alto igual a 1 (o número será negativo). Caso contrário, name terá o nome do módulo que gerou o erro.
Isso foi feito dessa maneira para permitir que implementações de interfaces possam especificar seus próprios erros.
function é opcional e pode ser NULL. Caso não seja NULL, receberá o número da função que gerou o erro.
int TaskManager_UGetParentTaskID(void);
Do usuário.
Esta função obtém o identificador do pai da tarefa chamadora.
O identificador do pai da tarefa.
int TaskManager_UGetTaskID(void);
Do usuário.
Esta função obtém o identificador da tarefa chamadora.
int TaskManager_UGetThreadID(void);
Do usuário.
Esta função obtém o identificador da linha de execução chamadora.
O identificador da linha de execução.
int TaskManager_UP(TaskManager_Semaphore *semaphore);
Do usuário.
Esta função obtém o semáforo semaphore.
long TaskManager_USetLastError(long error, const char *name, int function);
Do usuário.
Esta função define o último erro ocorrido que pode ser obtido pela função UGetLastError.
error é o código de erro, name o nome da interface ou módulo que gerou o erro e function o número da função que gerou o erro.
name não pode ser NULL e pode ter no máximo 32 caracteres incluindo o zero final. Se error tiver o bit mais alto igual a 1 (se error for negativo), name tem que ter o nome da interface que gerou o erro. Caso contrário deve ter o nome do módulo que gerou o erro.
Isso foi feito para permitir que os módulos possam ter seus próprios códigos de erro.
int TaskManager_UTryP(TaskManager_Semaphore *semaphore);
Do usuário.
Esta função tenta obter o semáforo semaphore, ou seja, obtém o semáforo se estiver disponível.
int TaskManager_UV(TaskManager_Semaphore *semaphore);
Do usuário.
Esta função libera o semáforo semaphore. Quem chama pode perder a CPU.