OS_RESULT rt_tsk_prio (OS_TID task_id, U8 new_prio) { /* Change execution priority of a task to "new_prio". */ P_TCB p_task; if (task_id == 0) { /* Change execution priority of calling task. */ os_tsk.run->prio = new_prio; run:if (rt_rdy_prio() > new_prio) { rt_put_prio (&os_rdy, os_tsk.run); os_tsk.run->state = READY; rt_dispatch (NULL); } return (OS_R_OK); } /* Find the task in the "os_active_TCB" array. */ if (task_id > os_maxtaskrun || os_active_TCB[task_id-1] == NULL) { /* Task with "task_id" not found or not started. */ return (OS_R_NOK); } p_task = os_active_TCB[task_id-1]; p_task->prio = new_prio; if (p_task == os_tsk.run) { goto run; } rt_resort_prio (p_task); if (p_task->state == READY) { /* Task enqueued in a ready list. */ p_task = rt_get_first (&os_rdy); rt_dispatch (p_task); } return (OS_R_OK); }
OS_RESULT rt_mut_delete (OS_ID mutex) { /* Delete a mutex object */ P_MUCB p_MCB = mutex; P_TCB p_TCB; __DMB(); /* Restore owner task's priority. */ if (p_MCB->level != 0) { p_MCB->owner->prio = p_MCB->prio; if (p_MCB->owner != os_tsk.run) { rt_resort_prio (p_MCB->owner); } } while (p_MCB->p_lnk != NULL) { /* A task is waiting for mutex. */ p_TCB = rt_get_first ((P_XCB)p_MCB); rt_ret_val(p_TCB, 0/*osOK*/); rt_rmv_dly(p_TCB); p_TCB->state = READY; rt_put_prio (&os_rdy, p_TCB); } if (os_rdy.p_lnk && (os_rdy.p_lnk->prio > os_tsk.run->prio)) { /* preempt running task */ rt_put_prio (&os_rdy, os_tsk.run); os_tsk.run->state = READY; rt_dispatch (NULL); } p_MCB->cb_type = 0; return (OS_R_OK); }
OS_RESULT rt_mut_wait (OS_ID mutex, U16 timeout) { /* Wait for a mutex, continue when mutex is free. */ P_MUCB p_MCB = mutex; if (p_MCB->level == 0) { p_MCB->owner = os_tsk.run; p_MCB->prio = os_tsk.run->prio; goto inc; } if (p_MCB->owner == os_tsk.run) { /* OK, running task is the owner of this mutex. */ inc:p_MCB->level++; return (OS_R_OK); } /* Mutex owned by another task, wait until released. */ if (timeout == 0) { return (OS_R_TMO); } /* Raise the owner task priority if lower than current priority. */ /* This priority inversion is called priority inheritance. */ if (p_MCB->prio < os_tsk.run->prio) { p_MCB->owner->prio = os_tsk.run->prio; rt_resort_prio (p_MCB->owner); } if (p_MCB->p_lnk != NULL) { rt_put_prio ((P_XCB)p_MCB, os_tsk.run); } else { p_MCB->p_lnk = os_tsk.run; os_tsk.run->p_lnk = NULL; os_tsk.run->p_rlnk = (P_TCB)p_MCB; } rt_block(timeout, WAIT_MUT); return (OS_R_TMO); }
OS_RESULT rt_mut_delete (OS_ID mutex) { /* Delete a mutex object */ P_MUCB p_MCB = mutex; P_TCB p_TCB; P_MUCB p_mlnk; U8 prio; if (p_MCB->level != 0U) { p_TCB = p_MCB->owner; /* Remove mutex from task mutex owner list. */ p_mlnk = p_TCB->p_mlnk; if (p_mlnk == p_MCB) { p_TCB->p_mlnk = p_MCB->p_mlnk; } else { while (p_mlnk) { if (p_mlnk->p_mlnk == p_MCB) { p_mlnk->p_mlnk = p_MCB->p_mlnk; break; } p_mlnk = p_mlnk->p_mlnk; } } /* Restore owner task's priority. */ prio = p_TCB->prio_base; p_mlnk = p_TCB->p_mlnk; while (p_mlnk) { if ((p_mlnk->p_lnk != NULL) && (p_mlnk->p_lnk->prio > prio)) { /* A task with higher priority is waiting for mutex. */ prio = p_mlnk->p_lnk->prio; } p_mlnk = p_mlnk->p_mlnk; } if (p_TCB->prio != prio) { p_TCB->prio = prio; if (p_TCB != os_tsk.run) { rt_resort_prio (p_TCB); } } } while (p_MCB->p_lnk != NULL) { /* A task is waiting for mutex. */ p_TCB = rt_get_first ((P_XCB)p_MCB); rt_ret_val(p_TCB, 0U/*osOK*/); rt_rmv_dly(p_TCB); p_TCB->state = READY; rt_put_prio (&os_rdy, p_TCB); } if ((os_rdy.p_lnk != NULL) && (os_rdy.p_lnk->prio > os_tsk.run->prio)) { /* preempt running task */ rt_put_prio (&os_rdy, os_tsk.run); os_tsk.run->state = READY; rt_dispatch (NULL); } p_MCB->cb_type = 0U; return (OS_R_OK); }