Consider a sharable resource with the following characteristics: 1) as long as there are fewer than three processes using the resource, new processes, new processes can start using it right away. 2)Once there are three processes using the resource, all three must leave before any new processes can begin using it. We realize that counters are needed to keep track of how many processes are waiting and active and that these counters are themselves shared resources that must be protected with mutual exclusion. So we might create the following solution: 1 semaphore mutex =1, block =0;
2 int active=0; waiting =0;
3 boolean must_wait=false;
4
5 semWait(mutex);
6 if(must_wait) {
7 ++waiting;
8 semSignal(mutex);
9 semWait(block);
10 semWait(mutex);
11 --waiting;
12 }
13 ++active;
14 must_wait = active ==3;
15 semSignal(mutex);
16
17 /*critical section*/
18 semWait(mutex);
19 --active;
20 if(active == 0) {
21 int n;
22 if (waiting < 3) n=waiting;
23 else n=3;
24 while (n>0) {
25 semSignal(block);
26 --n;
27 }
28 must_wait=false;
29 }
30 semSignal(mutex);

The solution appears to do everything right: all accesses to the shared variables are protected by mutual exclusion, processes do not block themselves while in the mutual exclusion, new processes are prevented from using the resource if there are (or were) three active users, and the last process to depart unblocks up to three waiting processes.

The program is nevertheless incorrect. Explain why.
Suppose we change the if in line 6 to a while. Does this solve any problem in the program? Do any difficulties remain?