An Explainer on Unix’s Most Notorious Code Comment

I don't see an explanation of this comment at all. I don't think it's the context switching in general that we're not expected to understand, since it's pretty much the same in v7 but the comment is gone. Dmr actually explained the problem on his website (https://www.bell-labs.com/usr/dmr/www/odd.html). savu is used to save the current call stack, retu is used to switch to a saved call stack. The problem is that the function which did the savu was not necessarily the same as the function that does the retu, so after retu the function could have the call stack of a different function. As dmr explained, this worked with the PDP-11 compiler but not with the interdata compiler. In V7 the stack switching was moved into separate functions, save and resume. save retured 0 and resume returned 1 so that an if statement could be used to check if the return from save was actually that of resume after the stack switch (the same trick as that of fork). This way the code that was to be executed after a stack switch was in the same function and stack frame as the one that did the save (as opposed to swtch).

(EDIT: I was wrong about v7 save/resume at first)

Note that Lions doesn't explain this either, he assumed that the difficulty was with with u_rsav and u_ssav, but those are still in v7 with the comment gone (he probably wasn't that wrong though, it really is confusing, but it's just not what the comment refers to)

It's worth noting that I find "unconventional" control flow like this tends to only puzzle those who started programming at the "structured" level where function calls always nest neatly, and so they have never entertained the possibility of it being any different from that.

However, the machine itself doesn't have any real notion of "call" and "return", and although dedicated instructions may be provided for convenience, all a call amounts to is "remember where in the code you were, and go somewhere else" and return is "use the saved information to go back".

It then follows that, if this saved information be not precisely that of the immediately preceding call, the processor can be caused to "return" somewhere else; and that is the basis of coroutines and process switching. Call and return are simply a convenient abstraction atop the sequential instruction stream the processor executes.

I ported V6 back in the day, I continually would come back to this comment from different code path, always mystified, one day I came to it and it was obvious ....

Essentially this was the days before save/restore were in the C library - savu/aretu are an equivalent that works differently (you savu() somewhere and aretu() somewhere else, it was sad because aretu() played stack games so unlike save() savu() didn't just return a different value on return)

Essentially v6 was a swapping system, fork() (or newproc() in the kernel) worked by allocating memory and making a copy of an app in memory, if there wasn't enough memory it would pretend to swap out the existing process, then mark it as the new process and set a flag (SSWAP), this is the case when it's returning - a process is being swapped in, part way through it realises it's really this special case and this code returns into newproc() as the new process

Is the actual talk available somewhere? Much as I like reading a blog post, I'd much rather first watch the actual presentation by Arun Thomas, which was _clearly_ worth watching by far more than just the audience of Systems We Love.

Link to the comment in V6 at Diomidis Spinellis' unix-history-repo:

https://github.com/dspinellis/unix-history-repo/blob/Researc...

> Unix v6 was released in 1975. “It was roughly 9,000 lines of code,”

has anyone perused it? 9k is tiny.. is there any value, either direct or extrapolated, in lending it the mindshare?

If I recall correctly, Lion's Commentary covered this pretty well. Just search for swtch but roughly sections 6.9, 8.9, 8.15 and 15.9. Lions refers to understanding it as joining the 2238 club.

http://www.c-c-g.de/attachments/article/211/lions_book_comme...

I thought this was going to be about "Unwarranted chumminess with the compiler" - in the original C implementation of regular expressions and subsequently copied into every language port thereafter.

Related, a talk on the famous mv error, "Values of β may give rise to dom!" from !!Con 2016: https://www.youtube.com/watch?v=FyLnF9U18rY