TUHS October 2018

tuhs@tuhs.org

56 participants
47 discussions

by norman＠nose.cita.utoronto.ca

I've assembled some notes from old manuals and other sources on the formats used for on-disk file systems through the Seventh Edition: http://www.cita.utoronto.ca/~norman/old-unix/old-fs.html Additional notes, comments on style, and whatnot are welcome. (It may be sensible to send anything in the last two categories directly to me, rather than to the whole list.)

2 years, 7 months

Re: [TUHS] Old Unix manuals, TMs, etc

by Warren Toomey

----- Forwarded message from meljmel-unix(a)yahoo.com ----- Warren, Thanks for your help. To my amazement in one day I received 8 requests for the documents you posted on the TUHS mailing list for me. If you think it's appropriate you can post that everything has been claimed. I will be mailing the Unix TMs and other papers to Robert Swierczek <rmswierczek(a)gmail.com> who said he will scan any one-of-a-kind items and make them available to you and TUHS. The manuals/books will be going to someone else who very much wanted them. Mel ----- End forwarded message -----

5 years, 6 months

Usenix: no official Unix 50th celebration, apparently

by Warren Toomey

Hi all, I've just heard that the Usenix board of directors do not want to explicitly celebrate the 50th anniversary of Unix. It's been suggested that we, the TUHS members, both lobby the board and also offer our assistance to help organisation such a celebration. Who, on the list, would put their hands up to help organising something that coincided with the 2019 Usenix ATC in July 2019? I'd like to get the bare bones of an organising team, then approach the Usenix board, offer our help and ask them to support us. What do you think? 11 months to go. Thanks, Warren P.S. Nokia Bell Labs are also going to organise something, possibly a month earlier but I have no solid details yet.

5 years, 11 months

Unix APIs: elegant or not?

by Warren Toomey

I was just reading this book review: http://www.pathsensitive.com/2018/10/book-review-philosophy-of-software.html and came across these paragraphs: <book quote> The mechanism for file IO provided by the Unix operating system and its descendants, such as Linux, is a beautiful example of a deep interface. There are only five basic system calls for I/O, with simple signatures: int open(const char* path, int flags, mode_t permissions); ssize_t read(int fd, void* buffer, size_t count); ssize_t write(int fd, const void* buffer, size_t count); off_t lseek(int fd, off_t offset, int referencePosition); int close(int fd); </book quote> The POSIX file API is a great example, but not of a deep interface. Rather, it’s a great example of how code with a very complicated interface may look deceptively simple when reduced to C-style function signatures. It’s a stateful API with interesting orderings and interactions between calls. The flags and permissions parameters of open hide an enormous amount of complexity, with hidden requirements like “exactly one of these five bits should be specified.” open may return 20 different error codes, each with their own meaning, and many with references to specific implementations. The authors of SibylIFS tried to write down an exact description of the open interface. Their annotated version[1] of the POSIX standard is over 3000 words. Not counting basic machinery, it took them over 200 lines[2] to write down the properties of open in higher-order logic, and another 70 to give the interactions between open and close. [1]: https://github.com/sibylfs/sibylfs_src/blob/8a7f53ba58654249b0ec0725ce38878… [2]: https://github.com/sibylfs/sibylfs_src/blob/8a7f53ba58654249b0ec0725ce38878… I just thought it was a thought-provoking comment on the apparent elegance of the Unix file API that actually has some subtle complexity. Cheers, Warren

6 years, 1 month

Archaic yacc C grammar

by Lars Brinkhoff

Hello, This is Alan Snyder's C grammar. It's supposedly for yacc, but it's probably using some really ancient version. Maybe from when Alan did a stint at Bell labs and converted yacc from B to C. Does anyone recognize this type of yacc input? I don't have the corresponding yacc version, and the one in V6 isn't happy about this file. What would it take to update the grammar for V6 yacc? Add in some %term, replace \\ with %%? # C GRAMMAR # # 28 May 1978 # # Alan Snyder # # 26 acceptable conflicts: 2 S/R conflicts for (parsing) ambiguity between declarators and function_declarators 1 S/R conflict for the C ELSE ambiguity 4 R/R conflicts for the (parsing) problem with regard to integer constants as initial_values 12 R/R conflicts for the (parsing) problem with regard to identifiers in function calls 1 R/R conflict for the (parsing) problem with regard to identifiers in goto statements 4 R/R conflicts and 1 S/R conflict for TYPEDEFs 1 S/R conflict for ambiguous cast types (int ()) = (int x()) not (int (x)) Approximate description: 18 S/R ( shift 37 reduce 141 50 S/R ( shift 37 reduce 71 81 S/R ( shift 37 reduce 71 113 R/R ( reduce 141 reduce 140 113 R/R ( reduce 159 reduce 140 113 R/R * reduce 159 reduce 141 113 S/R : shift 199 reduce 141 183 R/R , reduce 203 reduce 24 183 R/R } reduce 203 reduce 24 204 R/R ( reduce 159 reduce 140 206 R/R ( reduce 148 reduce 139 207 R/R ( reduce 147 reduce 139 208 R/R ( reduce 145 reduce 139 209 R/R ( reduce 144 reduce 139 210 R/R ( reduce 146 reduce 139 211 R/R ( reduce 149 reduce 139 212 R/R ( reduce 150 reduce 139 215 R/R ( reduce 159 reduce 140 215 R/R ; reduce 159 reduce 138 225 R/R ( reduce 151 reduce 139 228 R/R ( reduce 159 reduce 140 284 R/R , reduce 203 reduce 25 284 R/R } reduce 203 reduce 25 291 S/R ) shift 339 reduce 165 343 R/R ( reduce 153 reduce 139 360 S/R ELSE shift 369 reduce 94 # # terminal symbols # ';' '}' '{' ']' '[' ')' '(' ':' ',' '.' '?' '~' '!' '&' '|' '^' '%' '/' '*' '-' '+' '=' '<' '>' '++' '--' '==' '!=' '<=' '>=' '<<' '>>' '->' '=op' '&&' '||' 'c' INT CHAR FLOAT DOUBLE STRUCT AUTO STATIC EXTERN RETURN GOTO IF ELSE SWITCH BREAK CONTINUE WHILE DO FOR DEFAULT CASE ENTRY REGISTER SIZEOF LONG SHORT UNSIGNED TYPEDEF 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' identifier integer floatcon string # precedence information # \< ',' \> '=' '=op' \> '?' ':' \< '||' \< '&&' \< '|' \< '^' \< '&' \< '==' '!=' \< '<' '>' '<=' '>=' \< '<<' '>>' \< '+' '-' \< '*' '/' '%' \> '!' '~' \> '++' '--' SIZEOF \< '[' '(' '.' '->' \\ # external definitions # program: program external_definition | external_definition: declaration | function_definition function_definition: function_specification function_body {afdef(#1,#2);} function_specification: decl_specifiers function_declarator {val=afdcl(1);} | function_declarator {val=afdcl(0);} function_body: formal_declarations compound_statement {val=#2;} formal_declarations: formal_decl_list {afpdcl();} | {afpdcl();} compound_statement: begin declaration_list statement_list end {val=#3;} | begin statement_list end {val=#2;} init_declarator_list: init_declarator | init_declarator_list ',' init_declarator init_declarator: $declarator initializer {aidecl();} | declarator {aidecl();} | function_declarator {adeclr(maktyp());} initializer: initial_value | '{' initial_value_expression_list '}' | '{' initial_value_expression_list ',' '}' initial_value_expression_list: initial_value_expression | initial_value_expression_list ',' initial_value_expression initial_value: integer {inz(i_int,#1);} | '-' integer {inz(i_int,-#2);} | floatcon {inz(i_float,#1);} | '-' floatcon {inz(i_negfloat,#2);} | identifier {inz(i_idn,#1);} | '&' identifier {inz(i_idn,#2);} | string {inz(i_string,#1);} initial_value_expression: constant {inz(i_int,#1);} | initial_value # declarations # declaration_list: declaration | declaration_list declaration declaration: decl_specifiers init_declarator_list ';' | literal_type_specifier ';' decl_specifiers: type_specifier {attrib(-1,#1);} | sc_specifier type_specifier {attrib(#1,#2);} | type_specifier sc_specifier {attrib(#2,#1);} type_specifier: type_identifier | literal_type_specifier literal_type_specifier: INT {val=TINT;} | CHAR {val=TCHAR;} | FLOAT {val=TFLOAT;} | DOUBLE {val=TDOUBLE;} | LONG {val=TINT;} | LONG INT {val=TINT;} | SHORT {val=TINT;} | SHORT INT {val=TINT;} | LONG FLOAT {val=TDOUBLE;} | UNSIGNED {val=TINT;} | UNSIGNED INT {val=TINT;} | struct '{' type_decl_list '}' {val=astruct(NULL,#3);} | struct $identifier '{' type_decl_list '}' {val=astruct(#2,#4);} | struct identifier {val=aostruct(#2);} sc_specifier: AUTO {val=c_auto;} | STATIC {val=c_static;} | EXTERN {val=c_extern;} | REGISTER {val=c_auto;} | TYPEDEF {val=c_typedef;} declarator_list: declarator | declarator_list ',' declarator declarator: dclr {val=adeclr(maktyp());} | identifier ':' constant {val=adeclr(afield(#1,#3));} | ':' constant {val=adeclr(afield(-1,#2));} $declarator: dclr {aiinz(adeclr(maktyp()));} dclr: '*' dclr {val=adclr(#2,MPTR);} | dclr '(' ')' {val=adclr(#1,MFUNC);} | dclr '[' ']' {val=adclr(#1,MARRAY,1);} | dclr '[' constant ']' {val=adclr(#1,MARRAY,#3);} | identifier {val=adclr(0,0);} | '(' dclr ')' {val=#2;} function_declarator: '*' function_declarator {val=adclr(#2,MPTR);} | function_declarator '(' ')' {val=adclr(#1,MFUNC);} | function_declarator '[' ']' {val=adclr(#1,MARRAY,1);} | function_declarator '[' constant ']' {val=adclr(#1,MARRAY,#3);} | identifier '(' ')' {val=adclr(adclr(0,0),MFUNC); parml=0;} | identifier '(' parameter_list ')' {val=adclr(adclr(0,0),MFUNC); parml=#3;} | '(' function_declarator ')' {val=#2;} parameter_list: identifier {val=push(#1);} | parameter_list ',' identifier {push(#3);} formal_decl_list: formal_declaration | formal_decl_list formal_declaration formal_declaration: type_declaration | REGISTER type_declaration type_decl_list: type_declaration | type_decl_list type_declaration type_declaration: $type_specifier declarator_list ';' {in_type_def=0; val=#2;} $type_specifier: type_specifier {in_type_def=1; attrib(-1,#1);} # statements # statement_list: statement | statement_list statement {val=astmtl(#1,#2);} statement: expression ';' {val=aexprstmt(#1);} | compound_statement | IF '(' expression ')' statement {val=aif(#3,#5,0);} | IF '(' expression ')' statement ELSE statement {val=aif(#3,#5,#7);} | while '(' expression ')' statement {val=awhile(#3,#5);} | for '(' .expression ';' .expression ';' .expression ')' statement {val=afor(#3,#5,#7,#9);} | do statement WHILE '(' expression ')' ';' {val=ado(#2,#5);} | switch '(' expression ')' statement {val=aswitch(#3,#5);} | CASE constant ':' statement {val=acase(#2,#4);} | DEFAULT ':' statement {val=adefault(#3);} | BREAK ';' {val=abreak();} | CONTINUE ';' {val=acontinue();} | RETURN ';' {val=areturn(0);} | RETURN expression ';' {val=areturn(#2);} | GOTO lexpression ';' {val=agoto(#2);} | identifier ':' statement {val=alabel(#1,#3);} | ENTRY identifier ':' statement {val=aentry(#2,#4);} | ';' {val=anull();} # expressions # .expression: expression | {val=0;} expression_list: expression \= '=' | expression_list ',' expression {val=aelist(#1,#3);} expression: expression '*' expression {val=node(n_times,#1,#3);} | expression '/' expression {val=node(n_div,#1,#3);} | expression '%' expression {val=node(n_mod,#1,#3);} | expression '+' expression {val=node(n_plus,#1,#3);} | expression '-' expression {val=node(n_minus,#1,#3);} | expression '<<' expression {val=node(n_ls,#1,#3);} | expression '>>' expression {val=node(n_rs,#1,#3);} | expression '<' expression {val=node(n_lt,#1,#3);} | expression '>' expression {val=node(n_gt,#1,#3);} | expression '<=' expression {val=node(n_le,#1,#3);} | expression '>=' expression {val=node(n_ge,#1,#3);} | expression '==' expression {val=node(n_eq,#1,#3);} | expression '!=' expression {val=node(n_ne,#1,#3);} | expression '&' expression {val=node(n_band,#1,#3);} | expression '^' expression {val=node(n_bxor,#1,#3);} | expression '|' expression {val=node(n_bior,#1,#3);} | expression '&&' expression {val=node(n_tv_and,#1,#3);} | expression '||' expression {val=node(n_tv_or,#1,#3);} | expression '?' expression ':' expression {val=node(n_qmark,#1,node(n_colon,#3,#5));} | expression '=' expression {val=node(n_assign,#1,#3);} | expression '=op' expression {val=node(n_ars+#2,#1,#3);} | expression ',' expression {val=node(n_comma,#1,#3);} | term # the following productions are ordered very carefully so that the desired thing is done in the case of a R/R conflict # lexpression: expression | identifier {val=aidn(alidn(#1));} fterm: term | identifier {val=aidn(afidn(#1));} type_identifier: identifier {val=atidn(#1);} term: term '++' {val=node(n_inca,#1);} | term '--' {val=node(n_deca,#1);} | '*' term {val=node(n_star,#2);} | '&' term {val=node(n_addr,#2);} | '-' term {val=node(n_uminus,#2);} | '!' term {val=node(n_tvnot,#2);} | '~' term {val=node(n_bnot,#2);} | '++' term {val=node(n_incb,#2);} | '--' term {val=node(n_decb,#2);} | SIZEOF term {val=node(n_sizeof,#2);} | SIZEOF '(' cast_type ')' \= SIZEOF {val=node(n_int,1);} # hack # | '(' cast_type ')' term \= '++' {val=#4;} # hack # | term '[' expression ']' {val=asubscript(#1,#3);} | fterm '(' expression_list ')' {val=acall(#1,#3);} | fterm '(' ')' {val=acall(#1,0);} | term '.' identifier {val=adot(#1,#3);} | term '->' identifier {val=aptr(#1,#3);} | identifier {val=aidn(aeidn(#1));} | integer {val=node(n_int,#1);} | floatcon {val=node(n_float,#1);} | string {val=node(n_string,#1);} | '(' expression ')' {val=#2;} cast_type: literal_type_specifier null_decl null_decl: # empty # | '(' ')' | '(' null_decl ')' '(' ')' | '*' null_decl | null_decl '[' ']' | null_decl '[' constant ']' | '(' null_decl ')' while: WHILE {apshw();} do: DO {apshd();} for: FOR {apshf();} switch: SWITCH {apshs();} struct: STRUCT {strlev++;} $identifier: identifier {val=astridn(#1);} begin: '{' {abegin();} end: '}' {aend();} constant: constant '*' constant {val=#1*#3;} | constant '/' constant {val=#1/#3;} | constant '%' constant {val=#1%#3;} | constant '+' constant {val=#1+#3;} | constant '-' constant {val=#1-#3;} | constant '<<' constant {val=#1<<#3;} | constant '>>' constant {val=#1>>#3;} | constant '<' constant {val=#1<#3;} | constant '>' constant {val=#1>#3;} | constant '<=' constant {val=#1<=#3;} | constant '>=' constant {val=#1>=#3;} | constant '==' constant {val=#1==#3;} | constant '!=' constant {val=#1!=#3;} | constant '&' constant {val=#1} | constant '^' constant {val=#1^#3;} | constant '|' constant {val=#1|#3;} | constant '&&' constant {val=#1&} | constant '||' constant {val=#1||#3;} | constant '?' constant ':' constant {val=(#1?#3:#5);} | c_term c_term: '-' c_term {val= -#2;} | '!' c_term {val= !#2;} | '~' c_term {val= ~#2;} | integer | '(' constant ')' {val=#2;}

6 years, 1 month

Reconstructed and newly set UNIX Manual

by Angelo Papenhoff

The last couple of days I worked on re-setting the V3-V6 manuals. I reconstructed V5 from the scan as best I could, unfortunately some pages were missing. You can find everything I used to do this here, please read the BUGS section: https://github.com/aap/unixman The results can be found here, as HTML and PDF: http://squoze.net/UNIX/v3man/ http://squoze.net/UNIX/v4man/ http://squoze.net/UNIX/v5man/ http://squoze.net/UNIX/v6man/ Reconstructing V1 and V2 n?roff source and converting the tty 37 output to ps is something I want to do too, but for now this was exhausting enough. Now for the questions that I arose while I was doing this: Are there scans of the V4 and V6 manual to check my pdfs against? Where does the V5 manual come from? As explained in the README, some pages are missing and some pages seem to be earlier than V4. Is there another V5 manual that one could check against? Why is lc (the LIL compiler) not in the TOC but has a page? And most importantly: is the old troff really lost? I would love to set the manual on the original systems at some point (and write a CAT -> ps converter, which should be fun). Doing all this work made me wish we still had earlier versions of UNIX and its tools around. Have fun with this! aap

6 years, 1 month

First ARPAnet transmission

by Dave Horsfall

Of interest to the old farts here... At 22:30 (but which timezone?) on this day in 1969 the first packet got as far as "lo" (for "login") then crashed on the "g". More details over on http://en.wikipedia.org/wiki/Leonard_Kleinrock#ARPANET (with thanks to Bill Cheswick for the link). -- Dave

6 years, 1 month

Re: [TUHS] Archaic yacc C grammar

by jnc＠mercury.lcs.mit.edu

> From: Steve Johnson > references that were checked using the pointer type of the structure > pointer. My code was a nightmare, and some of the old Unix code was at > least a bad dream. I had a 'fun' experience with this when I went to do the pipe splice() system call (after the discussion here). I elected to do it in V6, which I i) had running, and ii) know like the back of my hand. Alas! V6 uses 'int *' everywhere for pointers to structures. It also, in the pipe code, uses constructs like '(p+1)' to provide wait channels. When I wrote the new code, I naturally declared my pointers as 'struct inode *ip', or whatever. However, when I went to do 'sleep(ip+1)', the wrong thing happened! And since V6 C didn't have coercions, I couldn't win that way. IIRC, I finally resorted to declaring an 'int *xip', and doing an 'xip = ip' before finally doing my 'sleep(xip+1)'. Gack! Noel

6 years, 1 month

C entry keyword

by Steve Simon

“entry” was a reserved word in K&R Ed.1, my personal favourite C trivia. I have never seen it used outside fortran on mainframes though. -Steve

6 years, 1 month

Re: [TUHS] Another one (Was: In memoriam: Jon Postel)

by jnc＠mercury.lcs.mit.edu

> From: Dave Horsfall > We lost ... on this day An email from someone on a related topic has reminded me of someone else you should make sure is only your list (not sure if you already have him): J. C. R. Licklider; we lost him on June 26, 1990. He didn't write much code himself, but the work of people he funded (e.g. Doug Engelbart, the ARPANet guys, Multics, etc, etc, etc) to work on his vision has led to today's computerized, information-rich world. For people who only know today's networked world, the change from what came before, and thus his impact on the world (since his ideas and the work of people he sponsored led, directly and indirectly, to much of it), is probably hard to truly fathom. He is, in my estimation, one of the most important and influential computer scientists of all. I wonder how many computer science people had more of an impact; the list is surely pretty short. Babbage; Turing; who else? Noel

6 years, 1 month

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

1994

1993

1992

1991

1990

TUHS October 2018