How does priority inheritance solve priority inversion?

Priority inheritance makes the kernel temporarily raise the priority of a task that holds a mutex to match the highest-priority task currently blocked waiting on that mutex. So in the classic scenario, the moment the High task blocks on the mutex held by Low, the kernel boosts Low to High's priority. Now medium-priority tasks can no longer preempt Low, because Low is (temporarily) running at High's priority, so Low keeps the CPU, races through its critical section, and releases the mutex quickly; at that point Low drops back to its real priority and High immediately acquires the mutex and runs. The effect is to convert unbounded inversion back into bounded inversion: High still waits, but only for the critical-section duration, not for arbitrary medium-priority work. This is exactly the fix that was uploaded to Mars Pathfinder. The key implementation point for an interview is that this is why you protect shared resources with a mutex rather than a plain binary semaphore, FreeRTOS mutexes implement priority inheritance, while bare semaphores do not, so guarding a resource with a semaphore leaves you exposed to unbounded inversion. Inheritance bounds the blocking; it doesn't make it zero, so you still account for one critical section of blocking in your timing analysis.