From 8ee6f62f5ffc70d78fed91d28d1ca0594c4b2e22 Mon Sep 17 00:00:00 2001 From: "jc_.kim" Date: Mon, 29 May 2017 19:48:09 +0900 Subject: [PATCH] Remove unnecessary code in sem_wait and sem_post sem_wait_for_isr and sem_post_from_isr are not needed because of using sem protocol --- os/include/tinyara/semaphore.h | 16 ----- os/kernel/semaphore/sem_post.c | 87 +-------------------------- os/kernel/semaphore/sem_wait.c | 130 +---------------------------------------- 3 files changed, 2 insertions(+), 231 deletions(-) diff --git a/os/include/tinyara/semaphore.h b/os/include/tinyara/semaphore.h index b84ee5b..cce4375 100644 --- a/os/include/tinyara/semaphore.h +++ b/os/include/tinyara/semaphore.h @@ -109,22 +109,6 @@ extern "C" { /**************************************************************************** * Public Function Prototypes ****************************************************************************/ -/** - * @brief This function attempts to lock the semaphore referenced by 'sem' - * which will be posted from interrupt handler. - * This function should have nothing to do with the priority inheritance. - * This function should not be called from interrupt handler. - * @since Tizen RT v1.0 - */ -int sem_wait_for_isr(FAR sem_t *sem); - -/** - * @brief Interrupt handler releases the semaphore referenced by 'sem'. - * This function should have nothing to do with the priority inheritance. - * This function should be called from interrupt handler. - * @since Tizen RT v1.0 - */ -int sem_post_from_isr(FAR sem_t *sem); /**************************************************************************** * Name: sem_reset diff --git a/os/kernel/semaphore/sem_post.c b/os/kernel/semaphore/sem_post.c index 2a1ea5e..43d948c 100644 --- a/os/kernel/semaphore/sem_post.c +++ b/os/kernel/semaphore/sem_post.c @@ -1,6 +1,6 @@ /**************************************************************************** * - * Copyright 2016 Samsung Electronics All Rights Reserved. + * Copyright 2016-2017 Samsung Electronics All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -195,88 +195,3 @@ int sem_post(FAR sem_t *sem) return ret; } - -/**************************************************************************** - * Name: sem_post_from_isr - * - * Description: - * When an interrupt handler has finished with a semaphore, it will call - * sem_post_from_isr(). This function unlocks the semaphore referenced by sem - * by performing the semaphore unlock operation on that semaphore. - * This function should have nothing to do with the priority inheritance. - * - * If the semaphore value resulting from this operation is positive, then - * no tasks were blocked waiting for the semaphore to become unlocked; the - * semaphore is simply incremented. - * - * If the value of the semaphore resulting from this operation is zero, - * then one of the tasks blocked waiting for the semaphore shall be - * allowed to return successfully from its call to sem_wait_for_isr(). - * - * Parameters: - * sem - Semaphore descriptor - * - * Return Value: - * 0 (OK) or -1 (ERROR) if unsuccessful - * - * Assumptions: - * This function may be called from an interrupt handler. - * - ****************************************************************************/ - -int sem_post_from_isr(FAR sem_t *sem) -{ - FAR struct tcb_s *stcb = NULL; - irqstate_t saved_state; - int ret = ERROR; - - /* Make sure we were supplied with a valid semaphore. */ - - if (sem) { - /* The following operations must be performed with interrupts - * disabled because sem_post() may be called from an interrupt - * handler. - */ - - saved_state = irqsave(); - - /* Perform the semaphore unlock operation. */ - - ASSERT(sem->semcount < SEM_VALUE_MAX); - sem->semcount++; - - /* If the result of of semaphore unlock is non-positive, then - * there must be some task waiting for the semaphore. - */ - - if (sem->semcount <= 0) { - /* Check if there are any tasks in the waiting for semaphore - * task list that are waiting for this semaphore. This is a - * prioritized list so the first one we encounter is the one - * that we want. - */ - - for (stcb = (FAR struct tcb_s *)g_waitingforsemaphore.head; (stcb && stcb->waitsem != sem); stcb = stcb->flink) ; - - if (stcb) { - /* It is, let the task take the semaphore */ - - stcb->waitsem = NULL; - - /* Restart the waiting task. */ - - up_unblock_task(stcb); - } - } - - ret = OK; - - /* Interrupts may now be enabled. */ - - irqrestore(saved_state); - } else { - set_errno(EINVAL); - } - - return ret; -} diff --git a/os/kernel/semaphore/sem_wait.c b/os/kernel/semaphore/sem_wait.c index 4684d99..7e4aaf7 100644 --- a/os/kernel/semaphore/sem_wait.c +++ b/os/kernel/semaphore/sem_wait.c @@ -1,6 +1,6 @@ /**************************************************************************** * - * Copyright 2016 Samsung Electronics All Rights Reserved. + * Copyright 2016-2017 Samsung Electronics All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -231,131 +231,3 @@ int sem_wait(FAR sem_t *sem) irqrestore(saved_state); return ret; } - -/**************************************************************************** - * Name: sem_wait_for_isr - * - * Description: - * This function attempts to lock the semaphore referenced by 'sem' - * which will be posted from interrupt handler. - * This function should have nothing to do with the priority inheritance. - * If the semaphore value is (<=) zero, then the calling task will not return - * until it successfully acquires the lock. - * - * Parameters: - * sem - Semaphore descriptor. - * - * Return Value: - * 0 (OK), or -1 (ERROR) is unsuccessful - * If this function returns -1 (ERROR), then the cause of the failure will - * be reported in 'errno' as: - * - EINVAL: Invalid attempt to get the semaphore - * - EINTR: The wait was interrupted by the receipt of a signal. - * - * Assumptions: - * - ****************************************************************************/ - -int sem_wait_for_isr(FAR sem_t *sem) -{ - FAR struct tcb_s *rtcb = (FAR struct tcb_s *)g_readytorun.head; - irqstate_t saved_state; - int ret = ERROR; - - /* This API should not be called from interrupt handlers */ - - DEBUGASSERT(up_interrupt_context() == false); - - /* Assume any errors reported are due to invalid arguments. */ - set_errno(EINVAL); - - - /* The following operations must be performed with interrupts - * disabled because sem_post() may be called from an interrupt - * handler. - */ - saved_state = irqsave(); - - /* sem_wait() is a cancellation point */ - if (enter_cancellation_point()) { - /* If there is a pending cancellation, then do not perform - * the wait. Exit now with ECANCELED. - */ - set_errno(ECANCELED); - leave_cancellation_point(); - irqrestore(saved_state); - return ERROR; - } - - if (sem) { - - /* Check if the lock is available */ - - if (sem->semcount > 0) { - /* It is, let the task take the semaphore. */ - - sem->semcount--; - rtcb->waitsem = NULL; - - ret = OK; - } - - /* The semaphore is NOT available, We will have to block the - * current thread of execution. - */ - - else { - /* First, verify that the task is not already waiting on a - * semaphore - */ - - ASSERT(rtcb->waitsem == NULL); - - /* Handle the POSIX semaphore (but don't set the owner yet) */ - - sem->semcount--; - - /* Save the waited on semaphore in the TCB */ - - rtcb->waitsem = sem; - - - /* Add the TCB to the prioritized semaphore wait queue */ - - set_errno(0); - - up_block_task(rtcb, TSTATE_WAIT_SEM); - - /* When we resume at this point, either (1) the semaphore has been - * assigned to this thread of execution, or (2) the semaphore wait - * has been interrupted by a signal or a timeout. We can detect these - * latter cases be examining the errno value. - * - * In the event that the semaphore wait was interrupted by a signal or - * a timeout, certain semaphore clean-up operations have already been - * performed (see sem_waitirq.c). Specifically: - * - * - sem_canceled() was called to restore the priority of all threads - * that hold a reference to the semaphore, - * - The semaphore count was decremented, and - * - tcb->waitsem was nullifed. - * - * It is necesaary to do these things in sem_waitirq.c because a long - * time may elapse between the time that the signal was issued and - * this thread is awakened and this leaves a door open to several - * race conditions. - */ - - if (get_errno() != EINTR && get_errno() != ETIMEDOUT) { - ret = OK; - } - } - - /* Interrupts may now be enabled. */ - } - - leave_cancellation_point(); - irqrestore(saved_state); - - return ret; -} -- 2.7.4