> From: "Ron Natalie"
> At some point .. and the ability to assign/pass structures got
> supported, though I thought that was the compiler that came with V7.
That is my vague recollection too.
> I'm still annoyed they didn't fix arrays when they fixed structs.
Which aspect? The ability to assign/pass/return arrays, or the funky way that
array naming worked (I'm trying to remember the details, I think it was
something to do with 'arrays' passed as arguments - it was actually a pointer
that was passed, but the declaration didn't have to say 'pointer').
Noel
> From: Tony Finch
> when did C get its cast operator?
Well after that piece of code was written! :-)
I don't recall exactly off the top of my head, but I recall 2-3 notes to
users about the evolution of C post 'vanilla' V6; I think a lot of it was
related to work being done on typetting stuff, hence the moniker
'phototypsetter compiler' which was applied to that 'improved' C.
One of the notes is fairly common, but another I have only in hardcopy
(although I scanned it at one point).
I'll try and turn all of them, along with some notes I made about the
differences between 'vanilla' V6 C and 'phototypsetter C' (which a lot of the
later V6 users started with - I certainly did), into an article on the
Computer History wiki on the early evolution of C.
Noel
PS:
> I recall 2-3 notes to users about the evolution of C post 'vanilla' V6
> ...
> One of the notes is fairly common, but another I have only in hardcopy
> (although I scanned it at one point).
More here:
http://minnie.tuhs.org/pipermail/tuhs/2014-October/005218.html
If anyone knows of any other documentation of C evolution, I'd be interested
in hearing about it for the Computer History wiki page.
Noel
> From: "Steve Johnson"
> The number on the left is a PDP-11 address, probably for some kind of
> control register.
It's the Processor Status Word, which contained the CPU's hardware priority
level, condition codes, etc.
> That's a construction that's left over from B.
I wonder why it was written as "0177776->integ", rather than "*017776"?
Probably the former allowed the C compiler to work out what size the operand
was. (BTW, 'integ' was declared in a structure declaration as follows:
struct {
int integ;
};
(Did the code looked at actually say "0177776->int"? The compiler might have
barfed on a reserved keyword being used like that.)
Noel
Has anyone got a setup where they can run something like nm(1) on the
compiled Third Edition Unix C files and send me the output?
(Alternatively, just send me the .o files, and I'll whip up something to
read their symbols.) I tried to compile the source code on a modern
system by hacking old C to something closer to what GCC will accept,
with commands such as the following.
cc -E dp.c |
sed 's/=\([&|+-]\)/\1=/g;s/struct[ \t]*(/struct {/' |
gcc -w -x c -
However, I stumbled on the use of structure fields on things that aren't
structures, e.g. "0177776->int =| 300"
It has often been told how the Bell Labs law department became the
first non-research department to use Unix, displacing a newly acquired
stand-alone word-processing system that fell short of the department's
hopes because it couldn't number the lines on patent applications,
as USPTO required. When Joe Ossanna heard of this, he told them about
roff and promised to give it line-numbering capability the next day.
They tried it and were hooked. Patent secretaries became remote
members of the fellowship of the Unix lab. In due time the law
department got its own machine.
Less well known is how Unix made it into the head office of AT&T. It
seems that the CEO, Charlie Brown, did not like to be seen wearing
glasses when he read speeches. Somehow his PR assistant learned of
the CAT phototypesetter in the Unix lab and asked whether it might be
possible to use it to produce scripts in large type. Of course it was.
As connections to the top never hurt, the CEO's office was welcomed
as another ouside user. The cost--occasionally having to develop film
for the final copy of a speech--was not onerous.
Having teethed on speeches, the head office realized that Unix could
also be useful for things that didn't need phototypesetting. Other
documents began to accumulate in their directory. By the time we became
aware of it, the hoard came to include minutes of AT&T board meetings.
It didn't seem like a very good idea for us to be keeping records from
the inner sanctum of the corporation on a computer where most everybody
had super-user privileges. A call to the PR guy convinced him of the
wisdom of keeping such things on their own premises. And so the CEO's
office bought a Unix system.
Just as one hears of cars chosen for their cupholders, so were these
users converted to Unix for trivial reasons: line numbers and vanity.
Doug
All, I'm writing a paper based on my June 2016 talk on PDP-7 Unix. As part
of that I was looking at the BCPL -> B -> NB -> C history. And as part of
that, I was reading Ken's B manual, written in 1972:
https://www.bell-labs.com/usr/dmr/www/kbman.pdf
Then I noticed at the end Ken refers to:
Ritchie, D.M. The UNIX Time Sharing System. MM 71-1273-4.
which makes me think that the draft version Doug McIlroy found
(now at http://www.tuhs.org/Archive/PDP-11/Distributions/research/McIlroy_v0/UnixEd…)
must have made it into a full memorandum.
Given that we have the memorandum number, does anybody know if it
would be possible to find it in the archives from what was Bell Labs?
Cheers, Warren
J.F.Ossanna was given unto us in 1928; a prolific programmer, he not only
had a hand in developing Unix but also gave us the ROFF series.
PS: Ada Lovelace, arguably the world's first computer programmer, was
given unto us in 1815; she saw the potential in Charles Babbage's
new-fangled thing.
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will suffer."
On Thu, Dec 8, 2016 at 5:39 AM, Joerg Schilling <schily(a)schily.net> wrote:
> Back to the Bourne Shell:
>
> The original Bourne Shell did not use malloc, but rather had a SIGSEGV
> handler
> that used to extend the "string stack" called "stak" via sbrk() whenever
> the
> code tried to access data beyond the end ot the heap.
>
Right although the 68K was not the first or the only system to have that
problem - again IIRC Series/1 and maybe one of the PE systems. You are
correct then SunOS and >>some<< of the 68000 based system did have the
problem you suggested. And in fact, Masscomp (and Apollo) which used
68000's (but used two of them so could run full VM) could survive that
style of fault (because it never occurred).
BTW: the "conceptual problem" , you mentioned while true, is being a little
harsh. As the one of the 68K designers (Les Crudele) said to me once,
when they wrote the microcode, there were not thinking about instruction
restart - so the issue was that Nick did not save enough state to do it.
The model for the 68000 that they were using was the base/limit PDP-11 and
the original PDP-10. Also at the time, the competition was the 6800, the
8080, Z80, 6502. They were trying to put a PDP-11/70 on chip (without
getting into trouble like CalData did - which Les, Nick and team were very
aware having been DEC and CalData customers before they were at Moto].
While we think of the 68000 family has being 32 bit, the fact is inside it
is a 16 bit system (the barrel shifter and execution functions are 16).
And it was a skunk works project -- the 6809 was Moto's real processor.
It was an experiment done by a couple of rogue engineers that said - hey we
can do better, The fact was they made a chip that was good enough to
actually compete with the Vax in the end, because it was fast enough AND
they had the wisdom to define 32 bits of address space and 32 bit
operations (again having been PDP-11 users), but as Les used to say - part
of the thinking was that while DEC was moving to the Vax, they had hoped to
break into the area that they 16 bits minis claimed - which they in-fact
did.
And if you think in terms of a Clay Christensen's disruption theory, the
fact that VM did not work easily (i.e. was a "worse" technology than the
Vax) was ok - a new breed of customer did not care. 68000 was huge
success, despite Moto marketing ;-)
To me the larger issue with the 68010 was that when Nick did add the
restart microcode, the new '10 microcode actually dumped version dependant
state on the external stack (in Intel terminology -different "step" '10 put
different state on the external stack or worse, could not restart an
instruction that had been saved from a different step processor).
This screw up was a huge issue when we did replaced the "executor" with a
68010, because it meant that all cpu boards had to be the same processor
microcode revision. Masscomp was of course the first to make an MP, so was
the the first firm to run into the issue (I remember debugging it - we
could not reproduce the issue because of course tjt and my own machine's by
chance had "MPU" boards as we called them with the same step -- it was one
of the field service guys that realized that the customer system had a
mixed step board -- i.e. when they replaced a single MPU in the field, the
system stopped working). IIRC: Moto never fixed the '10, as that
processor was reasonably short lived in the open market. They did fix the
microcode in the '20 so the state on the external stack was independent of
stepping.
Clem
*This* is a computer!
http://archive.computerhistory.org/resources/text/EAI/EAI.HYDAC2400.1963.10…
A hybrid analogue/digital box, what could possibly go wrong? And check
out the dudes and dudess supporting it (except she'd better be careful
when moving her chair, in case she takes out a paper tape unit...).
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will suffer."
> Dennis Ritchie's home pages have some info on this
Yeah, I'd read that - I was hoping for some actual technical info on the KS11,
though.
(I'm assuming he has given the name there correctly, or if his memory has
dropped a bit - a thing which human memories do! :-) - since I've never been
able to find a single mention of it, including in the Spare Module Handbook,
which covers other Special Systems products).
> I looked for (but did not find) information on what ""the classical
> PDP-10 style "hi-seg" "low-seg" memory mapping unit"" was.
The best description is in the DECSystem-10 Hardware Reference Manual (mine is
EK-10/20-HR-001, but alas that version appears not to be online - I'll scan my
copy and put it online when I get a chance.) This version:
http://pdp10.nocrew.org/docs/ad-h391a-t1.pdf
does appear to cover it: pp. 5-38 through 5-40 (pp. 352-354 of the PDF) for
the KA10, and pp. 5-15 to 5-30 (pp. 329-344) for the KI10.
The KA10 provided one (optionally) two base/bounds register pairs, where the
base register contains the location in real memory. With two pairs (the
second one applied to high user address space), the high part could be
write-protected, for sharing pure code.
The KI10 provided something similar to this, but more complicated; it included
paging, but also something called User 'Concealed', which allowed proprietary
subroutine packages to be used, while hidden from the rest of the user's code.
> Does anyone have an idea what PDP-10 MMU Dennis may have been referring
> to?
Almost certainly the KA10.
> Here my hypothesis would be that in kernel mode mapping was off, and
> that in user mode there were two segments, each with a base and limit
> into physical memory
Hard to say. Kernel mode might or might not have mapping, and User mode might
have provided one, or two, segments; the KA10 did have an option for
single-segment.
> this setup has an echo in how the later KL-11 MMU was used.
Sorry, what's a KL-11? The only 'KL11' I know of is the serial line board
(M780) which was the predecessor to the DL11.
Noel
Finally took a look at the V1 source.
Referring to http://minnie.tuhs.org/cgi-bin/utree.pl?file=V1/u2.s
Toward the end of the sysexec function there is:
cmp core,$405 / br .+14 is first instruction if file is
/ standard a.out format
bne 1f / branch, if not standard format
mov core+2,r5 / put 2nd word of users program in r5; number of
/ bytes in program text
sub $14,r5 / subtract 12
cmp r5,u.count /
bgt 1f / branch if r5 greater than u.count
mov r5,u.count
jsr r0,readi / read in rest of user's program text
add core+10,u.nread / add size of user data area to u.nread
br 2f
1:
jsr r0,readi / read in rest of file
2:
mov u.nread,u.break / set users program break to end of
/ user code
add $core+14,u.break / plus data area
jsr r0,iclose / does nothing
br sysret3 / return to core image at $core
$core is equated to 040000 in another file (u0.s). In V1 apparently the a.out header was 6 words (http://minnie.tuhs.org/cgi-bin/utree.pl?file=V1/man/man5/a.out.5) not 8, and hence the magic for a standard executable was 0405. It was already used as magic to distinguish a.out format files from other executables. It also shows that indeed 'exec' jumped to the first word of the header (at location $core).
From this I don't think we will find code for the KS-11 in the V1 source. The file http://minnie.tuhs.org/cgi-bin/utree.pl?file=V1/u3.s also seems to support a LSX /MX like approach where each process switch equates a swap.
I'd say that the lost V2 is where memory protection first appeared in Unix, i.e. 1972.
Paul
PS Sorry for writing 'V0' earlier -- I meant V1 all along.
On 2016-12-08 18:18, Paul Ruizendaal <pnr(a)planet.nl> wrote:
>
>>> DEC's Custom Special Systems (CSS) group .. build a simple base/limi
>>> register device, soon after the 11/20 was released.> ... So an early
>>> version of after the original 11/20 port from the PDP-7 had this
>>> however.....
>> Oh, right, I'd forgotten about that: the KS-11 - I've previously enquired to
>> see if anyone had _any_ documentation for this, but so far, nada.
> I was looking for that a few years back. Dennis Ritchie's home pages have
> some info on this (https://www.bell-labs.com/usr/dmr/www/odd.html)
> At the bottom of that page he writes:
>
> ""Back around 1970-71, Unix on the PDP-11/20 ran on hardware that not only did not support virtual memory, but didn't support any kind of hardware memory mapping or protection, for example against writing over the kernel. This was a pain, because we were using the machine for multiple users. When anyone was working on a program, it was considered a courtesy to yell "A.OUT?" before trying it, to warn others to save whatever they were editing.
> [..snip..]
> We knew the PDP-11/45, which did support memory mapping and protection for the kernel and other processes, was coming, but not instantly; in anticipation, we arranged with Digital Special Systems to buy a PDP-11/20 with KS-11 add-on. This was an extra system unit bolted to the processor that made it distinguish kernel from user mode, and provided a classical PDP-10 style "hi-seg" "low-seg" memory mapping unit. I seem to recall that maybe 6 of these had been made when we ordered it.""
>
> My hypothesis is that the very first versions of Unix were using a memory scheme similar to that used in the later LSX and MX derivatives: the kernel resides in lower memory and the user program in upper memory; each process switch implied a swap. Disclaimer: I have not studied the V0 source to verify this hypothesis.
>
> When this topic had my interest I looked for (but did not find) information on what ""the classical PDP-10 style "hi-seg" "low-seg" memory mapping unit"" was. Here my hypothesis would be that in kernel mode mapping was off, and that in user mode there were two segments, each with a base and limit into physical memory -- and that this setup has an echo in how the later KL-11 MMU was used.
>
> Does anyone have an idea what PDP-10 MMU Dennis may have been referring to?
If you read the Wikipedia page about the PDP-10, you'd find the answer.
Basically, kernel mode uses physical memory. User mode have a low
segment and a high segment. This is decided by the high bit of the address.
For each segment, there is a base register and a length register.
Commonly, the low segment stored read/write data, while the high segment
could be shared between processes, and have readonly data/code.
But you could play in other ways with it, if you wanted to.
Essex MUD, as far as I remember, had the game data in a shared hiseg,
which could be written by the program.
So your guessing is pretty good. Not sure I'd say this is similar to how
the later PDP-11 MMU works, though. But I can see someone making the
comparison, since the PDP-11 pages can vary in size, within limits.
Johnny
--
Johnny Billquist || "I'm on a bus
|| on a psychedelic trip
email: bqt(a)softjar.se || Reading murder books
pdp is alive! || tryin' to stay hip" - B. Idol
> From: Clem Cole
> DEC's Custom Special Systems (CSS) group .. build a simple base/limi
> register device, soon after the 11/20 was released.> ... So an early
> version of after the original 11/20 port from the PDP-7 had this
> however.....
Oh, right, I'd forgotten about that: the KS-11 - I've previously enquired to
see if anyone had _any_ documentation for this, but so far, nada.
> I would look at Warren's First Edition work to see if there were dregs
> of this in that code base
Alas, I'd already had that idea (to try and at least re-create a programming
spec, at least, for the KS11). There do not seem to be any traces there,
perhaps because that code came from a document entitled "Preliminary Release
of Unix Implementation", which argues that it's a very early 'version' of V0
(the early 'versions' weren't very formal, there was a continuous process of
change/improvement going on, apparently).
> It is also noted that the 45 class system (45/55/70/44) had "17th"
> address bit - i.e. split I/D space. I believe that this is when "magic
> numbers" were really introduced so that could be supported.
No, they came in first for 'pure text' (0410):
http://minnie.tuhs.org/cgi-bin/utree.pl?file=V4/nsys/ken/sys1.c
which I would expect arrived to minimize swapping on machines with small
amounts of real memmory.
Support for user split-I/D (411) didn't arrive until Version 6:
http://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/sys1.c
although IIRC split I/D in the kernel was supported supported slightly
before it was in user - although V5 didn't:
http://minnie.tuhs.org/cgi-bin/utree.pl?file=V5/usr/sys/conf/mch.s
so it couldn't have been much earlier than V6.
Noel
Which version of Unix first ran on a computer with virtual addressing (address translation) so that a process with non-position independent code (PIC) can be loaded anywhere in RAM that the kernel decided to put it, and memory protection such that no process could accidentally or deliberately access RAM not allocated to it by the kernel (or a SIGSEGV would be delivered to it)?
Put another way, when did Unix processes stop playing Core War with each other? (OK, so long as no more than one is resident at a time, they can't play Core War with each other, but there still needs to be a mechanism to protect the kernel from inadvertent (or advertent) pointer use).
Which is to say, when did Unix run on (and properly use) computers with memory management units (MMU)?
My guess from a quick look at the history of the DEC PDP-11 is that the target computer was likely a PDP-11/35 or PDP-11/40 with a KT11-D "memory management" module.
One imagines that many pointer mistakes (bugs) in assembly or C were discovered and squashed in that version, modulo the historical unhappiness resulting from address zero containing a zero if dereferenced ("NULL pointers") in process address space.
What year did that come about?
By the time I got to Unix (2.8BSD on the Cory Hall DEC PDP-11/70), those features (virtual addresses, memory protection from the kernel) had apparently been part of Unix for a long time - certainly earlier than Version 6.
This is distinct from demand-paged virtual memory which so far as I know was developed on the DEC VAX-11.
curious,
Erik <fair(a)netbsd.org>
> From: "Erik E. Fair" <f
> One imagines that many pointer mistakes (bugs) in assembly or C were
> discovered and squashed in that version, modulo the historical
> unhappiness resulting from address zero containing a zero if
> dereferenced ("NULL pointers") in process address space.
PS: PDP-11 Unix didn't, I think, do much (anything?) to solve the null pointer
problem. (This is for early C versions; I don't know about the later BSD
ones.)
Location 0 was a usable address for both read and write for everything except
'pure-text' (0410 magic word) processes; in those it was only legal for
read. Address 0 mostly did not contain a 0, either; for C programs using the
stock run-time, it contained a 'setd' instruction, except in split I+D
processes, in which case data space location 0 probably (I'm too busy to spin
up my V6 emulator to check) contained some of the program's initialized data
(unless special arrangements had been made).
Noel
> From: "Erik E. Fair"
> Which version of Unix first ran on a computer with virtual addressing
That would be the first version to run on the PDP-11/45; I'm not sure which one
that was, there's not enough left of Version 2 or Version 3 to see; Version 4
definitely ran on the 11/45:
http://minnie.tuhs.org/cgi-bin/utree.pl?file=V4/nsys/ken/45.s
> My guess from a quick look at the history of the DEC PDP-11 is that the
> target computer was likely a PDP-11/35 or PDP-11/40 with a KT11-D
> "memory management" module.
No, they came after the -11/45 (with the KT11-C MMU).
> What year did that come about?
They got one of the first -11/45's, per a Unix history document I'm too busy
to dig up, so 1972.
Noel
I'm not sure if my other reply got though, so I'll try again...
I found the source to the BBN stack in the CSRG CD's it's on CD 4
/sys/deprecated/bbnnet
LINT.bbn 08-Aug-2016 06:37 3.5K
NOTES 08-Aug-2016 06:37 4.6K
RELAY.bbn 08-Aug-2016 06:37 1.2K
SCCS/ 08-Aug-2016 06:37 -
fsm.h 08-Aug-2016 06:37 1.2K
fsmdef.h 08-Aug-2016 06:37 9.6K
hmp.c 08-Aug-2016 06:37 12K
hmp.h 08-Aug-2016 06:37 3.2K
hmp_subr.c 08-Aug-2016 06:37 6.5K
hmp_traps.c 08-Aug-2016 06:37 3.5K
hmp_traps.h 08-Aug-2016 06:37 2.7K
hmp_var.h 08-Aug-2016 06:37 1.4K
ic_output.c 08-Aug-2016 06:37 5.7K
icmp.c 08-Aug-2016 06:37 17K
icmp.h 08-Aug-2016 06:37 3.3K
in.c 08-Aug-2016 06:37 12K
in.h 08-Aug-2016 06:37 2.0K
in_pcb.c 08-Aug-2016 06:37 11K
in_pcb.h 08-Aug-2016 06:37 1.9K
in_proto.c 08-Aug-2016 06:37 4.9K
in_var.h 08-Aug-2016 06:37 2.2K
ip.h 08-Aug-2016 06:37 3.3K
ip_input.c 08-Aug-2016 06:37 29K
ip_output.c 08-Aug-2016 06:37 14K
ip_usrreq.c 08-Aug-2016 06:37 3.8K
macros.h 08-Aug-2016 06:37 4.4K
net.h 08-Aug-2016 06:37 2.4K
nopcb.h 08-Aug-2016 06:37 318
raw_input.c 08-Aug-2016 06:37 9.4K
rdp.h 08-Aug-2016 06:37 15K
rdp_cksum.s 08-Aug-2016 06:3
7 4.4K
rdp_fsm.c 08-Aug-2016 06:37 4.5K
rdp_input.c 08-Aug-2016 06:37 9.6K
rdp_macros.h 08-Aug-2016 06:37 7.9K
rdp_prim.c 08-Aug-2016 06:37 13K
rdp_states.c 08-Aug-2016 06:37 34K
rdp_subr.c 08-Aug-2016 06:37 8.4K
rdp_usrreq.c 08-Aug-2016 06:37 21K
seq.h 08-Aug-2016 06:37 415
sws.h 08-Aug-2016 06:37 326
tcp.h 08-Aug-2016 06:37 8.6K
tcp_input.c 08-Aug-2016 06:37 12K
tcp_prim.c 08-Aug-2016 06:37 9.8K
tcp_procs.c 08-Aug-2016 06:37 28K
tcp_states.c 08-Aug-2016 06:37 20K
tcp_usrreq.c 08-Aug-2016 06:37 22K
udp.c 08-Aug-2016 06:37 5.2K
udp.h 08-Aug-2016 06:37 1.1K
udp_usrreq.c 08-Aug-2016 06:37 7.0K
I've been meaning to try to try to manually mash stuff together but just
haven't gotten around to it.
> ----------
> From: Paul Ruizendaal
> Sent: Thursday, December 1, 2016 4:30 PM
> To: tuhs(a)minnie.tuhs.org
> Subject: [TUHS] looking for 4.1a BSD full kernel source
>
>
> Hi,
>
> I'm trying to find out exactly what was in the 4.1a BSD distribution, as
> far as the kernel is concerned. The image in the CSRG archive comes from a
> tape that had a hard read error and does not include any kernel sources.
> Some of the kernel files were already covered by SCCS around that time,
> but not everything. My main focus is to understand tcp/ip networking in
> 4.1a and whether the kernel could be built with either the Berkeley or the
> BBN network stack.
>
> Does anybody know where I could find a full set of kernel sources for the
> 4.1a BSD kernel?
>
> Many thanks in advance!
>
> Paul
>
Hi
I am sure there must have been an email about this if so, I do apologies.
The below link is from Diomidis Spinellis work, I remember seeinng an email
from him a few months ago requesting some information about the history of
BSD. Looking at it, he has done some amazing work. I look forward to
playing with 386BSD!
https://github.com/dspinellis/unix-history-repo
Hi,
I'm looking for the source code to "Network Unix" as described here:
https://tools.ietf.org/html/rfc681
and/or its later development described here:
https://archive.org/details/networkunixsyste243kell
Actually, I'd be happy with finding the source code to any version of this Network Unix. This version of Unix had fairly wide use in the Arpanet community and was in use at several universities and organizations (e.g.: Rand, BBN, etc.)
Would anybody here know of a surviving copy?
Many thanks in advance,
Paul
Hi Diomidis,
Thanks for that link. This is exactly what I'm trying to ascertain, and I'm finding conflicting evidence.
- The socket API was in a state of flux between October '81 and March '82 (when 4.1a was supposedly cut). By March '82 it was mostly there, but not until later in the year did it fully stabilize.
- The BBN stack did not use the sockets API as late as January '82
- What I currently fathom from the SCCS files is that the socket API implementation was hard coded to use the nascent Berkeley stack.
- But the BBN code was likely in the 4.x BSD source tree, outside of SCCS (Berkeley started out with the BBN code, but it morphed quite quickly and drastically)
- In 1985 the BBN code finally enters SCCS (marked 'deprecated'); this code was integrated with the sockets API, and much developed from its 1982 form
Either the below link is correct (and I think I may have contributed to its view in a private mail to Kirk), or there were two different distributions (4.1a BSD with Berkeley network code and 4BSD with BBN network code). The two may have merged into one in peoples' memories: 35 years is a long time. Finding the actual kernel source for the 4.1a distribution could provide clarity on this point.
Perhaps Bill Joy could shed some light on the issue, but I don't have contact details. Having actual source removes all doubt.
Paul
On 1 Dec 2016, at 10:51 , Diomidis Spinellis wrote:
> The best description I could find is the following:
>
> http://minnie.tuhs.org/pipermail/tuhs/2016-September/007417.html
>
> > The 4.1a distribution had the initial socket interface with a
> > prerelease of the BBN TCP/IP under it. There was wide distribution
> > of 4.1a. The 4.1b distribution had the fast filesystem added and
> > a more mature socket interface (notably the listen/accept model
> > added by Sam Leffler).
>
> Diomidis
>
> On 01/12/2016 10:30, Paul Ruizendaal wrote:
>>
>> Hi,
>>
>> I'm trying to find out exactly what was in the 4.1a BSD distribution, as far as the kernel is concerned. The image in the CSRG archive comes from a tape that had a hard read error and does not include any kernel sources. Some of the kernel files were already covered by SCCS around that time, but not everything. My main focus is to understand tcp/ip networking in 4.1a and whether the kernel could be built with either the Berkeley or the BBN network stack.
>>
>> Does anybody know where I could find a full set of kernel sources for the 4.1a BSD kernel?
>>
>> Many thanks in advance!
>>
>> Paul
>>
>
Hi,
I'm trying to find out exactly what was in the 4.1a BSD distribution, as far as the kernel is concerned. The image in the CSRG archive comes from a tape that had a hard read error and does not include any kernel sources. Some of the kernel files were already covered by SCCS around that time, but not everything. My main focus is to understand tcp/ip networking in 4.1a and whether the kernel could be built with either the Berkeley or the BBN network stack.
Does anybody know where I could find a full set of kernel sources for the 4.1a BSD kernel?
Many thanks in advance!
Paul
Larry McVoy:
I've always morned that he died so early. I would have liked to talk
to him, I love troff to this day.
====
Me too (s/morn/mourn/, of course). I might even have had the
chance to work with him.
The original UNIX crowd were all really neat characters, albeit
sometimes a trifle overly characterful. All nice guys to work
with, too, at least those who were still around when I was at
1127.
Norman Wilson
Toronto ON
We lost J.F.Ossanna in 1977; he had a hand in developing Unix, and was
responsible for "roff" and its descendants. Remember him, the next time
you see "jfo" in documentation.
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will suffer."