Regarding semaphore up() and mutex_unlock() in linux kernel - linux-kernel

Question

I want to know why we can use the semaphore up() in interrupt context while the same variant of mutex i.e mutex_unlock() cannot be used in interrupt context.
Below is snippet from kernel
/**
* mutex_unlock - release the mutex
* #lock: the mutex to be released
*
* Unlock a mutex that has been locked by this task previously.
*
* This function must not be used in interrupt context. Unlocking
* of a not locked mutex is not allowed.
*
* This function is similar to (but not equivalent to) up().
*/
void __sched mutex_unlock(struct mutex *lock)
{
#ifndef CONFIG_DEBUG_LOCK_ALLOC
if (__mutex_unlock_fast(lock))
return;
#endif
__mutex_unlock_slowpath(lock, _RET_IP_);
}EXPORT_SYMBOL(mutex_unlock);
/**
* up - release the semaphore
* #sem: the semaphore to release
*
* Release the semaphore. Unlike mutexes, up() may be called from any
* context and even by tasks which have never called down().
*/
void up(struct semaphore *sem)
{
unsigned long flags;
raw_spin_lock_irqsave(&sem->lock, flags);
if (likely(list_empty(&sem->wait_list)))
sem->count++;
else
__up(sem);
raw_spin_unlock_irqrestore(&sem->lock, flags);
}
EXPORT_SYMBOL(up);

Answer 1

mutex_unlock takes a mutex-internal spinlock in a non-irq-safe
fashion - e.g. raw_spin_lock may sleep if CONFIG_PREEMPT_RT is set - so if the timing is right, your mutex_unlock in IRQ context will deadlock.