The Executable and Linkable Format (ELF) is the modern standard for
object files in Unix and Unix-like OSes (e.g., Linux), and even for
OpenVMS. LInux, AIX and probably other implementations of ELF have a
feature in the runtime loader called symbol preemption. When loading
a shared library, the runtime loader examines the library's symbol
table. If there is a global symbol with default visibility, and a
value for that symbol has already been loaded, all references to the
symbol in the library being loaded are rebound to the existing
definition. The existing value thus preempts the definition in the
library.
I'm curious about the history of symbol preemption. It does not exist
in other implementations of shared libraries, such as IBM OS/370 and
its descendants, OpenVMS, and Microsoft Windows NT. ELF apparently
was designed in the mid-1990s. I have found a copy of the System V
Application Binary Interface from April 2001 that describes symbol
preemption in the section on the ELF symbol table.
When was symbol preemption when loading shared objects first
implemented in Unix? Are there versions of Unix that don't do symbol
preemption?
-Paul W.
Random832 <random832 at fastmail.com> writes:
>markus schnalke <meillo at marmaro.de> writes:
>> [2015-11-09 08:58] Doug McIlroy <doug at cs.dartmouth.edu>
>>> things like "cut" and "paste", whose exact provenance
>>> I can't recall.
>>
>> Thanks for reminding me that I wanted to share my portrait of
>> cut(1) with you. (I sent some questions to this list, a few
>> months ago, remember?) Now, here it is:
>>
>> http://marmaro.de/docs/freiesmagazin/cut/cut.en.pdf
>
>Did you happen to find out what GWRL stands for, in the the comments at
>the top of early versions of cut.c and paste.c?
>
>/* cut : cut and paste columns of a table (projection of a relation) (GWRL) */
>/* Release 1.5; handles single backspaces as produced by nroff */
>/* paste: concatenate corresponding lines of each file in parallel. Release 1.4 (GWRL) */
>/* (-s option: serial concatenation like old (127's) paste command */
>
>For that matter, what's the "old (127's) paste command" it refers to?
I know this thread is almost 5 years old, I came across it searching for
something else But as no one could answer these questions back then, I can.
GWRL stands for Gottfried W. R. Luderer, the author of cut(1) and paste(1),
probably around 1978. Those came either from PWB or USG, as he worked with,
or for, Berkley Tague. Thus they made their way into AT&T commercial UNIX,
first into System III and the into System V, and that's why they are missing
from early BSD releases as they didn't get into Research UNIX until the
8th Edition. Also "127" was the internal department number for the Computer
Science Research group at Bell Labs where UNIX originated
Dr. Luderer co-authored this paper in the orginal 1978 BSTJ on UNIX --
https://www.tuhs.org/Archive/Documentation/Papers/BSTJ/bstj57-6-2201.pdf
I knew Dr. Luderer and he was even kind enough to arrange for me stay with his
relatives for a few days in Braunschweig, West Germany (correct county name for
the time) on my first trip to Europe many decades ago. But haven't had contact nor
even thought of him forever until I saw his initials. I also briefly worked for Berk
when he was the department head for 45263 in Whippany Bell Labs before moving to
Murray Hill.
And doing a quick search for him, it looks like he wrote and autobiograhy, which I
am now going to have to purchase
http://www.lulu.com/shop/gottfried-luderer/go-west-young-german/paperback/p…
-Brian
Hi All:
   I looking for the source code to the Maitre'd load balancer. It is
used to run jobs on lightly used machines. It was developed by Brian
Berhard at Berkeley's Computer Systems Support Group. I have the
technical report for it (dated 17-dec-1985). But haven't run across the
tarball.
thanks
-ron
All, I've had a few subscribers argue that the type checking
thread was still Unix-related, so feel free to keep posting
here in TUHS. But if it does drift away to non-Unix areas,
please pass it over to COFF.
Thanks & apologies for being too trigger-happy!
Cheers, Warren
>> After scrolling through the command list, I wondered how
>> long it was and asked to have it counted. Easy, I thought,
>> just pass it to a wc-like program. But "just pass it" and
>> "wc-like" were not givens as they are in Unix culture.
>> It took several minutes for the gurus to do it--without
>> leaving emacs, if I remember right.
> This is kind of illustrative of the '60s acid trip that
> perpetuates in programming "Everything's a string maaaaan".
> The output is seen as truth because the representation is
> for some reason too hard to get at or too hard to cascade
> through the system.
How did strings get into the discussion? Warner showed how
emacs could be expected to do the job--and more efficiently
than the Unix way, at that: (list-length (command-list-fn)).
The surprise was that this wasn't readily available.
Back then, in fact, you couldn't ask sh for its command
list. help|wc couldn't be done because help wasn't there.
Emacs had a different problem. It had a universal internal
interface--lists rather than strings--yet did not have
a way to cause this particular list to "cascade through
the system". (print(command-list-fn)) was provided, while
(command-list-fn) was hidden.
Doug
Mention of elevators at Tech Square reminds me of visiting there
to see the Lisp machine. I was struck by cultural differences.
At the time we were using Jerqs, where multiple windows ran
like multiple time-sharing sessions. To me that behavior was a
no-brainer. Surprisingly, Lisp-machine windows didn't work that
way; only the user-selected active window got processor time.
The biggest difference was emacs, which no one used at Bell
Labs. Emacs, of course was native to the Lisp machine and
provided a powerful and smoothly extensible environment. For
example, its reflective ability made it easy to display a
list of its commands. "Call elevator" stood out amng mundane
programmering actions like cut, paste and run.
After scrolling through the command list, I wondered how long
it was and asked to have it counted. Easy, I thought, just
pass it to a wc-like program. But "just pass it" and "wc-like"
were not givens as they are in Unix culture. It took several
minutes for the gurus to do it--without leaving emacs, if I
remember right.
Doug
This question comes from a colleague, who works on compilers.
Given the definition `int x;` (without an initializer) in a source file the
corresponding object contains `x` in a "common" section. What this means is
that, at link time, if some object file explicitly allocates an 'x' (e.g.,
by specifying an initializer, so that 'x' appears in the data section for
that object file), use that; otherwise, allocate space for it at link time,
possibly in the BSS. If several source files contain such a declaration,
the linker allocates exactly one 'x' (or whatever identifier) as
appropriate. We've verified that this behavior was present as early as 6th
edition.
The question is, what is the origin of this concept and nomenclature?
FORTRAN, of course, has "common blocks": was that an inspiration for the
name? Where did the idea for the implicit behavior come from (FORTRAN
common blocks are explicit).
My colleague was particularly surprised that this seemed required: even at
this early stage, the `extern` keyword was present, so why bother with this
behavior? Why not, instead, make it a link-time error? Please note that if
two source files have initializers for these variables, then one gets a
multiple-definition link error. The 1988 ANSI standard made this an error
(or at least undefined behavior) but the functionality persists; GCC is
changing its default to prohibit it (my colleague works on clang).
Doug? Ken? Steve?
- Dan C.
Jon Steinhart:
One amusing thing that Steve told me which I think I can share is why the
symmetry of case-esac, if-fi was broken with with do-done; it was because
the od command existed so do-od wouldn't work!
=====
As I heard the story in the UNIX room decades ago (and at least five
years after the event), Steve tried and tried to convince Ken to
rename od so that he could have the symmetry he wanted. Ken was
unmoved.
Norman Wilson
Toronto ON
> From: Clem Cole
> when she found out the elevators were hacked and controlled by the
> student's different computers, she stopped using them and would take
> the stairs
It wasn't quite as major as this makes it sound! A couple of inconspicuous
wires were run from the 'TV 11' on the MIT-AI KA10 machine (the -11 that ran
the Knight displays) into the elevator controller, and run onto the terminals
where the wires from the 'down' call buttons on the 8th and 9th floors went.
So it wasn't anything major, and there was really no need for her to take the
stair (especially 8 flights up :-).
The code is still extant, in 'SYSTEM; TV >'. It only worked (I think) from
Knight TV keyboards; typing 'ESC E' called the elevator to the floor
that keyboard was on (there's a table, 'ELETAB', which gives the physical
floor for each keyboard).
The machine could also open the locked 9th floor door to the machine room
(with an 'ESC D'), and there some other less major things, e.g. print screen
hardcopy. I'm not sure what the hardware in the TV-11 was (this was all run
out of the 'keyboard multiplexor'); it may have been something the AI Lab
built from scratch.
Noel
