I'm trying to understand the intricacies of this change.

processes = List {
    head:  ListLink(Some(RoundRobinProcessNode {
        proc: Some($PROCESS),
        next: ListLink(None)
    }),
}

In the current version using for node in self.processes.iter() {, we

1. create a ListIterator with cur: Some(RoundRobinProcessNode { proc: Some($PROCESS), next: ListLink(None) })
2. (implicitly) pull the first element from the ListIterator: Iterator through Iterator::next(). This will set cur: None and returns a Some(RoundRobinProcessNode { proc: Some($PROCESS), next: ListLink(None) }) for the loop iteration as node.
3. Given that first_head is None, set first_head = Some(node).
4. Check node.proc, which is Some(proc). However, proc.ready() = false. We perform self.processes.push_tail(self.processes.pop_head().unwrap()), which will first set head of the list to None, then set next of proc to None, and finally set head of the list to proc.
   This translates to the list effectively not being changed.
5. Do step 2 & 3.
6. Given that first_head is Some(first_head), and first_head == node, break out of the loop, returning SchedulingDecision::TrySleep.

In contrast, the newly proposed changes would do the following:

1. Run self.processes.head(), which returns Some(RoundRobinProcessNode { proc: Some($PROCESS), next: ListLink(None) }) as Some(node).
2. Do step 3 & 4 from above.
3. Do step 1.
4. Do step 6 from above.

From reading over this code, I can't really make out the difference between two approaches. I suspect I may be missing something which probably has to do with the mutation going on of the list while iterating over it.

Could you perhaps try to clarify exactly what is going on here?

In general though, this code is very complicated to understand. I tried to address this some time ago, along with the inefficiencies we have here through our use of push_tail: #2845. Maybe that's worth going back to? The fact that this scheduling code if of quadratic complexity is pretty crazy.

Good find, and this really emphasizes why we should just not allow code that uses .unwrap(), no matter how much we trust the programmer. It's just too hard to write correct code!

I think what is happening here is that today if there is only one entry in the process array, the .iter() loop only executes once, and so the loop ends with both a) next == None and return Sleep never being called.

With this patch, the loop will run twice when the processes array is 1 item long, so the return will be hit the second time.

Merging this seems good to me, but I of course would be in favor of removing that .unwrap().