Merge remote-tracking branch 'upstream/master'

61 files changed, 2625 insertions, 1788 deletions

diff --git a/src/cmd/9pfuse/errstr.c b/src/cmd/9pfuse/errstr.c
index e3a122e4..ef5da00f 100644
--- a/src/cmd/9pfuse/errstr.c
+++ b/src/cmd/9pfuse/errstr.c
@@ -21,6 +21,7 @@ static Error errortab[] = {
 	{ "exist", ENOENT },
 	{ "no such", ENOENT },
 	{ "not found", ENOENT },
+	{ "not implemented", ENOSYS},
 	{ "input/output", EIO },
 	{ "timeout", ETIMEDOUT },
 	{ "timed out", ETIMEDOUT },
@@ -42,6 +43,7 @@ static Error errortab[] = {
 	{ "invalid", EINVAL },
 	{ "read-only", EROFS },
 	{ "read only", EROFS },
+	{ "stale ", ESTALE},
 #ifdef EPROTO
 	{ "proto", EPROTO },
 #else
diff --git a/src/cmd/9term/malloc.c b/src/cmd/9term/malloc.c
index 9132235b..7b590bc4 100644
--- a/src/cmd/9term/malloc.c
+++ b/src/cmd/9term/malloc.c
@@ -7,8 +7,6 @@
 #define NOPLAN9DEFINES
 #include <libc.h>
 
-static Lock malloclock;
-
 void*
 p9malloc(ulong n)
 {
@@ -16,9 +14,7 @@ p9malloc(ulong n)
 
 	if(n == 0)
 		n++;
-	lock(&malloclock);
 	v = malloc(n);
-	unlock(&malloclock);
 	print("p9malloc %lud => %p; pc %lux\n", n, v, getcallerpc(&n));
 	return v;
 }
@@ -28,10 +24,8 @@ p9free(void *v)
 {
 	if(v == nil)
 		return;
-	lock(&malloclock);
 	print("p9free %p; pc %lux\n", v, getcallerpc(&v));
 	free(v);
-	unlock(&malloclock);
 }
 
 void*
@@ -42,9 +36,7 @@ p9calloc(ulong a, ulong b)
 	if(a*b == 0)
 		a = b = 1;
 
-	lock(&malloclock);
 	v = calloc(a*b, 1);
-	unlock(&malloclock);
 	print("p9calloc %lud %lud => %p; pc %lux\n", a, b, v, getcallerpc(&a));
 	return v;
 }
@@ -54,9 +46,7 @@ p9realloc(void *v, ulong n)
 {
 	void *vv;
 
-	lock(&malloclock);
 	vv = realloc(v, n);
-	unlock(&malloclock);
 	print("p9realloc %p %lud => %p; pc %lux\n", v, n, vv, getcallerpc(&v));
 	return vv;
 }
diff --git a/src/cmd/acme/exec.c b/src/cmd/acme/exec.c
index 3575c984..f6dc32f4 100644
--- a/src/cmd/acme/exec.c
+++ b/src/cmd/acme/exec.c
@@ -702,7 +702,7 @@ putfile(File *f, int q0, int q1, Rune *namer, int nname)
 	Rune *r;
 	Biobuf *b;
 	char *s, *name;
-	int i, fd, q, ret;
+	int i, fd, q, ret, retc;
 	Dir *d, *d1;
 	Window *w;
 	int isapp;
@@ -766,9 +766,10 @@ putfile(File *f, int q0, int q1, Rune *namer, int nname)
 		goto Rescue2;
 	}
 	ret = Bterm(b);
+	retc = close(fd);
 	free(b);
 	b = nil;
-	if(ret < 0) {
+	if(ret < 0 || retc < 0) {
 		warning(nil, "can't write file %s: %r\n", name);
 		goto Rescue2; // flush or close failed
 	}
@@ -788,10 +789,9 @@ putfile(File *f, int q0, int q1, Rune *namer, int nname)
 			// in case we don't have read permission.
 			// (The create above worked, so we probably
 			// still have write permission.)
-			close(fd);
 			fd = open(name, OWRITE);
-
 			d1 = dirfstat(fd);
+			close(fd);
 			if(d1 != nil){
 				free(d);
 				d = d1;
@@ -824,11 +824,11 @@ putfile(File *f, int q0, int q1, Rune *namer, int nname)
 	if(b != nil) {
 		Bterm(b);
 		free(b);
+		close(fd);
 	}
 	free(h);
 	fbuffree(s);
 	fbuffree(r);
-	close(fd);
 	/* fall through */
 
     Rescue1:
diff --git a/src/cmd/acme/rows.c b/src/cmd/acme/rows.c
index 83c64594..7a64fabf 100644
--- a/src/cmd/acme/rows.c
+++ b/src/cmd/acme/rows.c
@@ -316,7 +316,7 @@ rowclean(Row *row)
 void
 rowdump(Row *row, char *file)
 {
-	int i, j, fd, m, n, dumped;
+	int i, j, fd, m, n, start, dumped;
 	uint q0, q1;
 	Biobuf *b;
 	char *buf, *a, *fontname;
@@ -434,9 +434,17 @@ rowdump(Row *row, char *file)
 			m = min(RBUFSIZE, w->tag.file->b.nc);
 			bufread(&w->tag.file->b, 0, r, m);
 			n = 0;
-			while(n<m && r[n]!='\n')
-				n++;
-			Bprint(b, "%.*S\n", n, r);
+			while(n<m) {
+				start = n;
+				while(n<m && r[n]!='\n')
+					n++;
+				Bprint(b, "%.*S", n-start, r+start);
+				if(n<m) {
+					Bputc(b, 0xff); // \n in tag becomes 0xff byte (invalid UTF)
+					n++;
+				}
+			}
+			Bprint(b, "\n");
 			if(dumped){
 				q0 = 0;
 				q1 = t->file->b.nc;
@@ -719,6 +727,10 @@ rowload(Row *row, char *file, int initing)
 		if(l == nil)
 			goto Rescue2;
 		l[Blinelen(b)-1] = 0;
+		/* convert 0xff in multiline tag back to \n */
+		for(i = 0; l[i] != 0; i++)
+			if((uchar)l[i] == 0xff)
+				l[i] = '\n';
 		r = bytetorune(l+5*12, &nr);
 		ns = -1;
 		for(n=0; n<nr; n++){
diff --git a/src/cmd/auth/factotum/confirm.c b/src/cmd/auth/factotum/confirm.c
index 105a46db..8451e8ae 100644
--- a/src/cmd/auth/factotum/confirm.c
+++ b/src/cmd/auth/factotum/confirm.c
@@ -128,17 +128,33 @@ needkeywrite(char *s)
 int
 needkey(Conv *c, Attr *a)
 {
+	ulong u;
+
 	if(c == nil || *needkeyinuse == 0)
 		return -1;
 
 	lbappend(&needkeybuf, "needkey tag=%lud %A", c->tag, a);
 	flog("needkey %A", a);
-	return nbrecvul(c->keywait);
+
+	// Note: This code used to "return nbrecvul(c->keywait)."
+	// In Jan 2020 we changed nbrecvul to match Plan 9 and
+	// the man page and return 0 on "no data available" instead
+	// of -1. This new code with an explicit nbrecv preserves the
+	// code's old semantics, distinguishing a sent 0 from "no data".
+	// That said, this code seems to return -1 unconditionally:
+	// the c->keywait channel is unbuffered, and the only sending
+	// to it is done with an nbsendul, which won't block waiting for
+	// a receiver. So there is no sender for nbrecv to find here.
+	if(nbrecv(c->keywait, &u) < 0)
+		return -1;
+	return u;
 }
 
 int
 badkey(Conv *c, Key *k, char *msg, Attr *a)
 {
+	ulong u;
+
 	if(c == nil || *needkeyinuse == 0)
 		return -1;
 
@@ -146,5 +162,17 @@ badkey(Conv *c, Key *k, char *msg, Attr *a)
 		c->tag, k->attr, k->privattr, msg, a);
 	flog("badkey %A / %N / %s / %A",
 		k->attr, k->privattr, msg, a);
-	return nbrecvul(c->keywait);
+
+	// Note: This code used to "return nbrecvul(c->keywait)."
+	// In Jan 2020 we changed nbrecvul to match Plan 9 and
+	// the man page and return 0 on "no data available" instead
+	// of -1. This new code with an explicit nbrecv preserves the
+	// code's old semantics, distinguishing a sent 0 from "no data".
+	// That said, this code seems to return -1 unconditionally:
+	// the c->keywait channel is unbuffered, and the only sending
+	// to it is done with an nbsendul, which won't block waiting for
+	// a receiver. So there is no sender for nbrecv to find here.
+	if(nbrecv(c->keywait, &u) < 0)
+		return -1;
+	return u;
 }
diff --git a/src/cmd/compress/compress.c b/src/cmd/compress/compress.c
new file mode 100755
index 00000000..808762ca
--- /dev/null
+++ b/src/cmd/compress/compress.c
@@ -0,0 +1,1274 @@
+/*
+ * compress - File compression ala IEEE Computer, June 1984.
+ *
+ * Algorithm from "A Technique for High Performance Data Compression",
+ * Terry A. Welch, IEEE Computer Vol 17, No 6 (June 1984), pp 8-19.
+ *
+ * Usage: compress [-dfvc] [-b bits] [file ...]
+ * Inputs:
+ *	-b:	limit the max number of bits/code.
+ *	-c:	write output on stdout, don't remove original.
+ *	-d:	decompress instead.
+ *	-f:	Forces output file to be generated, even if one already
+ *		exists, and even if no space is saved by compressing.
+ *		If -f is not used, the user will be prompted if stdin is
+ *		a tty, otherwise, the output file will not be overwritten.
+ *	-v:	Write compression statistics
+ *
+ * 	file ...: Files to be compressed.  If none specified, stdin is used.
+ * Outputs:
+ *	file.Z:	Compressed form of file with same mode, owner, and utimes
+ * 		or stdout (if stdin used as input)
+ *
+ * Assumptions:
+ *	When filenames are given, replaces with the compressed version
+ *	(.Z suffix) only if the file decreases in size.
+ * Algorithm:
+ * 	Modified Lempel-Ziv method (LZW).  Basically finds common
+ * substrings and replaces them with a variable size code.  This is
+ * deterministic, and can be done on the fly.  Thus, the decompression
+ * procedure needs no input table, but tracks the way the table was built.
+
+ * Authors:	Spencer W. Thomas	(decvax!harpo!utah-cs!utah-gr!thomas)
+ *		Jim McKie		(decvax!mcvax!jim)
+ *		Steve Davies		(decvax!vax135!petsd!peora!srd)
+ *		Ken Turkowski		(decvax!decwrl!turtlevax!ken)
+ *		James A. Woods		(decvax!ihnp4!ames!jaw)
+ *		Joe Orost		(decvax!vax135!petsd!joe)
+ */
+
+#ifndef USED
+#  define USED(x) if(x);else
+#endif
+
+#define _PLAN9_SOURCE
+#define _BSD_EXTENSION
+#define _POSIX_SOURCE
+
+#include <u.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <utime.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#define	min(a,b)	((a>b) ? b : a)
+
+#define BITS	16
+#define HSIZE	69001		/* 95% occupancy */
+
+/*
+ * a code_int must be able to hold 2**BITS values of type int, and also -1
+ */
+typedef long	code_int;
+typedef long	count_int;
+
+static char rcs_ident[] = "$Header: compress.c,v 4.0 85/07/30 12:50:00 joe Release $";
+
+uchar magic_header[] = { 0x1F, 0x9D };	/* 1F 9D */
+
+/* Defines for third byte of header */
+#define BIT_MASK	0x1f
+#define BLOCK_MASK	0x80
+/* Masks 0x40 and 0x20 are free.  I think 0x20 should mean that there is
+	a fourth header byte (for expansion).
+*/
+#define INIT_BITS 9			/* initial number of bits/code */
+
+#define ARGVAL() (*++(*argv) || (--argc && *++argv))
+
+int n_bits;				/* number of bits/code */
+int maxbits = BITS;			/* user settable max # bits/code */
+code_int maxcode;			/* maximum code, given n_bits */
+code_int maxmaxcode = 1 << BITS;	/* should NEVER generate this code */
+
+#define MAXCODE(n_bits)	((1 << (n_bits)) - 1)
+
+count_int htab[HSIZE];
+ushort codetab[HSIZE];
+
+#define htabof(i)	htab[i]
+#define codetabof(i)	codetab[i]
+
+code_int hsize = HSIZE;			/* for dynamic table sizing */
+count_int fsize;
+
+/*
+ * To save much memory, we overlay the table used by compress() with those
+ * used by decompress().  The tab_prefix table is the same size and type
+ * as the codetab.  The tab_suffix table needs 2**BITS characters.  We
+ * get this from the beginning of htab.  The output stack uses the rest
+ * of htab, and contains characters.  There is plenty of room for any
+ * possible stack (stack used to be 8000 characters).
+ */
+
+#define tab_prefixof(i)	codetabof(i)
+#define tab_suffixof(i)	((uchar *)(htab))[i]
+#define de_stack		((uchar *)&tab_suffixof(1<<BITS))
+
+code_int free_ent = 0;			/* first unused entry */
+int exit_stat = 0;
+
+void	cl_block(void);
+void	cl_hash(count_int);
+void	compress(void);
+void	copystat(char *, char *);
+void	decompress(void);
+int	foreground(void);
+code_int getcode(void);
+void	onintr(int);
+void	oops(int);
+void	output(code_int);
+void	prratio(FILE *, long, long);
+void	version(void);
+void	writeerr(void);
+
+void
+Usage(void)
+{
+#ifdef DEBUG
+	fprintf(stderr,"Usage: compress [-cdfDV] [-b maxbits] [file ...]\n");
+#else
+	fprintf(stderr,"Usage: compress [-cdfvV] [-b maxbits] [file ...]\n");
+#endif /* DEBUG */
+}
+
+int debug = 0;
+int nomagic = 0;	/* Use a 3-byte magic number header, unless old file */
+int zcat_flg = 0;	/* Write output on stdout, suppress messages */
+int quiet = 1;		/* don't tell me about compression */
+
+/*
+ * block compression parameters -- after all codes are used up,
+ * and compression rate changes, start over.
+ */
+int block_compress = BLOCK_MASK;
+int clear_flg = 0;
+long ratio = 0;
+#define CHECK_GAP 10000	/* ratio check interval */
+count_int checkpoint = CHECK_GAP;
+/*
+ * the next two codes should not be changed lightly, as they must not
+ * lie within the contiguous general code space.
+ */
+#define FIRST	257	/* first free entry */
+#define	CLEAR	256	/* table clear output code */
+
+int force = 0;
+char ofname [100];
+#ifdef DEBUG
+int verbose = 0;
+#endif /* DEBUG */
+void (*bgnd_flag)(int);
+
+int do_decomp = 0;
+
+int
+main(argc, argv)
+int argc;
+char **argv;
+{
+	int overwrite = 0;	/* Do not overwrite unless given -f flag */
+	char tempname[512];
+	char **filelist, **fileptr;
+	char *cp;
+	struct stat statbuf;
+
+	if ( (bgnd_flag = signal ( SIGINT, SIG_IGN )) != SIG_IGN ) {
+		signal(SIGINT, onintr);
+		signal(SIGSEGV, oops);
+	}
+
+	filelist = fileptr = (char **)(malloc(argc * sizeof(*argv)));
+	*filelist = NULL;
+
+	if((cp = strrchr(argv[0], '/')) != 0)
+		cp++;
+	else
+		cp = argv[0];
+	if(strcmp(cp, "uncompress") == 0)
+		do_decomp = 1;
+	else if(strcmp(cp, "zcat") == 0) {
+		do_decomp = 1;
+		zcat_flg = 1;
+	}
+
+	/*
+	 * Argument Processing
+	 * All flags are optional.
+	 * -C	generate output compatible with compress 2.0.
+	 * -D	debug
+	 * -V	print Version; debug verbose
+	 * -b maxbits	maxbits.  If -b is specified, then maxbits MUST be
+	 *		given also.
+	 * -c	cat all output to stdout
+	 * -d	do_decomp
+	 * -f	force overwrite of output file
+	 * -n	no header: useful to uncompress old files
+	 * -v	unquiet
+	 * if a string is left, must be an input filename.
+	 */
+	for (argc--, argv++; argc > 0; argc--, argv++) {
+	if (**argv == '-') {	/* A flag argument */
+		while (*++(*argv)) {	/* Process all flags in this arg */
+		switch (**argv) {
+		case 'C':
+			block_compress = 0;
+			break;
+#ifdef DEBUG
+		case 'D':
+			debug = 1;
+			break;
+		case 'V':
+			verbose = 1;
+			version();
+			break;
+#else
+		case 'V':
+			version();
+			break;
+#endif
+		case 'b':
+			if (!ARGVAL()) {
+				fprintf(stderr, "Missing maxbits\n");
+				Usage();
+				exit(1);
+			}
+			maxbits = atoi(*argv);
+			goto nextarg;
+		case 'c':
+			zcat_flg = 1;
+			break;
+		case 'd':
+			do_decomp = 1;
+			break;
+		case 'f':
+		case 'F':
+			overwrite = 1;
+			force = 1;
+			break;
+		case 'n':
+			nomagic = 1;
+			break;
+		case 'q':
+			quiet = 1;
+			break;
+		case 'v':
+			quiet = 0;
+			break;
+		default:
+			fprintf(stderr, "Unknown flag: '%c'; ", **argv);
+			Usage();
+			exit(1);
+		}
+		}
+	} else {			/* Input file name */
+		*fileptr++ = *argv;	/* Build input file list */
+		*fileptr = NULL;
+		/* process nextarg; */
+	}
+nextarg:
+		continue;
+	}
+
+	if(maxbits < INIT_BITS) maxbits = INIT_BITS;
+	if (maxbits > BITS) maxbits = BITS;
+	maxmaxcode = 1 << maxbits;
+
+	if (*filelist != NULL) {
+	for (fileptr = filelist; *fileptr; fileptr++) {
+		exit_stat = 0;
+		if (do_decomp != 0) {			/* DECOMPRESSION */
+		/* Check for .Z suffix */
+		if (strcmp(*fileptr + strlen(*fileptr) - 2, ".Z") != 0) {
+			/* No .Z: tack one on */
+			strcpy(tempname, *fileptr);
+			strcat(tempname, ".Z");
+			*fileptr = tempname;
+		}
+		/* Open input file */
+		if ((freopen(*fileptr, "r", stdin)) == NULL) {
+			perror(*fileptr);
+			continue;
+		}
+		/* Check the magic number */
+		if (nomagic == 0) {
+			if ((getchar() != (magic_header[0] & 0xFF))
+			|| (getchar() != (magic_header[1] & 0xFF))) {
+				fprintf(stderr, "%s: not in compressed format\n",
+					*fileptr);
+				continue;
+			}
+			maxbits = getchar();	/* set -b from file */
+			block_compress = maxbits & BLOCK_MASK;
+			maxbits &= BIT_MASK;
+			maxmaxcode = 1 << maxbits;
+			if(maxbits > BITS) {
+				fprintf(stderr,
+		"%s: compressed with %d bits, can only handle %d bits\n",
+					*fileptr, maxbits, BITS);
+				continue;
+			}
+		}
+		/* Generate output filename */
+		strcpy(ofname, *fileptr);
+		ofname[strlen(*fileptr) - 2] = '\0';  /* Strip off .Z */
+		} else {				/* COMPRESSION */
+		if (strcmp(*fileptr + strlen(*fileptr) - 2, ".Z") == 0) {
+			fprintf(stderr,
+				"%s: already has .Z suffix -- no change\n",
+				*fileptr);
+			continue;
+		}
+		/* Open input file */
+		if ((freopen(*fileptr, "r", stdin)) == NULL) {
+			perror(*fileptr);
+			continue;
+		}
+		(void) stat(*fileptr, &statbuf);
+		fsize = (long) statbuf.st_size;
+		/*
+		 * tune hash table size for small files -- ad hoc,
+		 * but the sizes match earlier #defines, which
+		 * serve as upper bounds on the number of output codes.
+		 */
+		hsize = HSIZE;
+		if (fsize < (1 << 12))
+			hsize = min(5003, HSIZE);
+		else if (fsize < (1 << 13))
+			hsize = min(9001, HSIZE);
+		else if (fsize < (1 << 14))
+			hsize = min (18013, HSIZE);
+		else if (fsize < (1 << 15))
+			hsize = min (35023, HSIZE);
+		else if (fsize < 47000)
+			hsize = min (50021, HSIZE);
+
+		/* Generate output filename */
+		strcpy(ofname, *fileptr);
+#ifndef BSD4_2
+		if ((cp=strrchr(ofname,'/')) != NULL)
+			cp++;
+		else
+			cp = ofname;
+		/*
+		 *** changed 12 to 25;  should be NAMELEN-3, but I don't want
+		 * to fight the headers.	ehg 5 Nov 92 **
+		 */
+		if (strlen(cp) > 25) {
+			fprintf(stderr, "%s: filename too long to tack on .Z\n",
+				cp);
+			continue;
+		}
+#endif
+		strcat(ofname, ".Z");
+		}
+		/* Check for overwrite of existing file */
+		if (overwrite == 0 && zcat_flg == 0 &&
+		   stat(ofname, &statbuf) == 0) {
+			char response[2];
+
+			response[0] = 'n';
+			fprintf(stderr, "%s already exists;", ofname);
+			if (foreground()) {
+				fprintf(stderr,
+				    " do you wish to overwrite %s (y or n)? ",
+					ofname);
+				fflush(stderr);
+				(void) read(2, response, 2);
+				while (response[1] != '\n')
+					if (read(2, response+1, 1) < 0) {
+						/* Ack! */
+						perror("stderr");
+						break;
+					}
+			}
+			if (response[0] != 'y') {
+				fprintf(stderr, "\tnot overwritten\n");
+				continue;
+			}
+		}
+		if(zcat_flg == 0) {		/* Open output file */
+			if (freopen(ofname, "w", stdout) == NULL) {
+				perror(ofname);
+				continue;
+			}
+			if(!quiet)
+				fprintf(stderr, "%s: ", *fileptr);
+		}
+
+		/* Actually do the compression/decompression */
+		if (do_decomp == 0)
+			compress();
+#ifndef DEBUG
+		else
+			decompress();
+#else
+		else if (debug == 0)
+			decompress();
+		else
+			printcodes();
+		if (verbose)
+			dump_tab();
+#endif						/* DEBUG */
+		if(zcat_flg == 0) {
+			copystat(*fileptr, ofname);	/* Copy stats */
+			if (exit_stat == 1 || !quiet)
+				putc('\n', stderr);
+		}
+	}
+	} else {		/* Standard input */
+	if (do_decomp == 0) {
+		compress();
+#ifdef DEBUG
+		if(verbose)
+			dump_tab();
+#endif
+		if(!quiet)
+			putc('\n', stderr);
+	} else {
+		/* Check the magic number */
+		if (nomagic == 0) {
+		if ((getchar()!=(magic_header[0] & 0xFF))
+		 || (getchar()!=(magic_header[1] & 0xFF))) {
+			fprintf(stderr, "stdin: not in compressed format\n");
+			exit(1);
+		}
+		maxbits = getchar();	/* set -b from file */
+		block_compress = maxbits & BLOCK_MASK;
+		maxbits &= BIT_MASK;
+		maxmaxcode = 1 << maxbits;
+		fsize = 100000;		/* assume stdin large for USERMEM */
+		if(maxbits > BITS) {
+			fprintf(stderr,
+			"stdin: compressed with %d bits, can only handle %d bits\n",
+			maxbits, BITS);
+			exit(1);
+		}
+		}
+#ifndef DEBUG
+		decompress();
+#else
+		if (debug == 0)
+			decompress();
+		else
+			printcodes();
+		if (verbose)
+			dump_tab();
+#endif						/* DEBUG */
+	}
+	}
+	exit(exit_stat);
+	return 0;
+}
+
+static int offset;
+long in_count = 1;		/* length of input */
+long bytes_out;			/* length of compressed output */
+long out_count = 0;		/* # of codes output (for debugging) */
+
+/*
+ * compress stdin to stdout
+ *
+ * Algorithm:  use open addressing double hashing (no chaining) on the
+ * prefix code / next character combination.  We do a variant of Knuth's
+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+ * secondary probe.  Here, the modular division first probe is gives way
+ * to a faster exclusive-or manipulation.  Also do block compression with
+ * an adaptive reset, whereby the code table is cleared when the compression
+ * ratio decreases, but after the table fills.  The variable-length output
+ * codes are re-sized at this point, and a special CLEAR code is generated
+ * for the decompressor.  Late addition:  construct the table according to
+ * file size for noticeable speed improvement on small files.  Please direct
+ * questions about this implementation to ames!jaw.
+ */
+void
+compress(void)
+{
+	code_int ent, hsize_reg;
+	code_int i;
+	int c, disp, hshift;
+	long fcode;
+
+	if (nomagic == 0) {
+		putchar(magic_header[0]);
+		putchar(magic_header[1]);
+		putchar((char)(maxbits | block_compress));
+		if(ferror(stdout))
+			writeerr();
+	}
+	offset = 0;
+	bytes_out = 3;		/* includes 3-byte header mojo */
+	out_count = 0;
+	clear_flg = 0;
+	ratio = 0;
+	in_count = 1;
+	checkpoint = CHECK_GAP;
+	maxcode = MAXCODE(n_bits = INIT_BITS);
+	free_ent = (block_compress? FIRST: 256);
+
+	ent = getchar ();
+
+	hshift = 0;
+	for (fcode = (long)hsize;  fcode < 65536L; fcode *= 2)
+		hshift++;
+	hshift = 8 - hshift;		/* set hash code range bound */
+
+	hsize_reg = hsize;
+	cl_hash( (count_int) hsize_reg);		/* clear hash table */
+
+	while ((c = getchar()) != EOF) {
+		in_count++;
+		fcode = (long) (((long) c << maxbits) + ent);
+	 	i = ((c << hshift) ^ ent);	/* xor hashing */
+
+		if (htabof (i) == fcode) {
+			ent = codetabof(i);
+			continue;
+		} else if ((long)htabof(i) < 0 )	/* empty slot */
+			goto nomatch;
+	 	disp = hsize_reg - i;	/* secondary hash (after G. Knott) */
+		if (i == 0)
+			disp = 1;
+probe:
+		if ((i -= disp) < 0)
+			i += hsize_reg;
+
+		if (htabof (i) == fcode) {
+			ent = codetabof(i);
+			continue;
+		}
+		if ((long)htabof(i) > 0)
+			goto probe;
+nomatch:
+		output((code_int)ent);
+		out_count++;
+	 	ent = c;
+		if (free_ent < maxmaxcode) {
+	 		codetabof(i) = free_ent++;	/* code -> hashtable */
+			htabof(i) = fcode;
+		} else if ((count_int)in_count >= checkpoint && block_compress)
+			cl_block ();
+	}
+	/*
+	* Put out the final code.
+	*/
+	output( (code_int)ent );
+	out_count++;
+	output( (code_int)-1 );
+
+	/*
+	* Print out stats on stderr
+	*/
+	if(zcat_flg == 0 && !quiet) {
+#ifdef DEBUG
+	fprintf( stderr,
+		"%ld chars in, %ld codes (%ld bytes) out, compression factor: ",
+		in_count, out_count, bytes_out );
+	prratio( stderr, in_count, bytes_out );
+	fprintf( stderr, "\n");
+	fprintf( stderr, "\tCompression as in compact: " );
+	prratio( stderr, in_count-bytes_out, in_count );
+	fprintf( stderr, "\n");
+	fprintf( stderr, "\tLargest code (of last block) was %d (%d bits)\n",
+		free_ent - 1, n_bits );
+#else /* !DEBUG */
+	fprintf( stderr, "Compression: " );
+	prratio( stderr, in_count-bytes_out, in_count );
+#endif /* DEBUG */
+	}
+	if(bytes_out > in_count)	/* exit(2) if no savings */
+		exit_stat = 2;
+}
+
+/*
+ * TAG( output )
+ *
+ * Output the given code.
+ * Inputs:
+ * 	code:	A n_bits-bit integer.  If == -1, then EOF.  This assumes
+ *		that n_bits =< (long)wordsize - 1.
+ * Outputs:
+ * 	Outputs code to the file.
+ * Assumptions:
+ *	Chars are 8 bits long.
+ * Algorithm:
+ * 	Maintain a BITS character long buffer (so that 8 codes will
+ * fit in it exactly).  When the buffer fills up empty it and start over.
+ */
+
+static char buf[BITS];
+
+uchar lmask[9] = {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00};
+uchar rmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
+
+void
+output( code )
+code_int  code;
+{
+#ifdef DEBUG
+	static int col = 0;
+#endif
+	int r_off = offset, bits= n_bits;
+	char *bp = buf;
+
+#ifdef DEBUG
+	if (verbose)
+		fprintf(stderr, "%5d%c", code,
+			(col+=6) >= 74? (col = 0, '\n'): ' ');
+#endif
+	if (code >= 0) {
+		/*
+		 * byte/bit numbering on the VAX is simulated by the
+		 * following code
+		 */
+		/*
+		 * Get to the first byte.
+		 */
+		bp += (r_off >> 3);
+		r_off &= 7;
+		/*
+		 * Since code is always >= 8 bits, only need to mask the first
+		 * hunk on the left.
+		 */
+		*bp = (*bp & rmask[r_off]) | (code << r_off) & lmask[r_off];
+		bp++;
+		bits -=  8 - r_off;
+		code >>= 8 - r_off;
+		/* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
+		if ( bits >= 8 ) {
+			*bp++ = code;
+			code >>= 8;
+			bits -= 8;
+		}
+		/* Last bits. */
+		if(bits)
+			*bp = code;
+
+		offset += n_bits;
+		if ( offset == (n_bits << 3) ) {
+			bp = buf;
+			bits = n_bits;
+			bytes_out += bits;
+			do {
+				putchar(*bp++);
+			} while(--bits);
+			offset = 0;
+		}
+
+		/*
+		 * If the next entry is going to be too big for the code size,
+		 * then increase it, if possible.
+		 */
+		if ( free_ent > maxcode || (clear_flg > 0)) {
+			/*
+			* Write the whole buffer, because the input side won't
+			* discover the size increase until after it has read it.
+			*/
+			if ( offset > 0 ) {
+				if( fwrite( buf, 1, n_bits, stdout ) != n_bits)
+					writeerr();
+				bytes_out += n_bits;
+			}
+			offset = 0;
+
+			if ( clear_flg ) {
+				maxcode = MAXCODE (n_bits = INIT_BITS);
+				clear_flg = 0;
+			} else {
+				n_bits++;
+				if ( n_bits == maxbits )
+					maxcode = maxmaxcode;
+				else
+					maxcode = MAXCODE(n_bits);
+			}
+#ifdef DEBUG
+			if ( debug ) {
+				fprintf(stderr,
+					"\nChange to %d bits\n", n_bits);
+				col = 0;
+			}
+#endif
+		}
+	} else {
+		/*
+		 * At EOF, write the rest of the buffer.
+		 */
+		if ( offset > 0 )
+			fwrite( buf, 1, (offset + 7) / 8, stdout );
+		bytes_out += (offset + 7) / 8;
+		offset = 0;
+		fflush( stdout );
+#ifdef DEBUG
+		if ( verbose )
+			fprintf( stderr, "\n" );
+#endif
+		if( ferror( stdout ) )
+			writeerr();
+	}
+}
+
+/*
+ * Decompress stdin to stdout.  This routine adapts to the codes in the
+ * file building the "string" table on-the-fly; requiring no table to
+ * be stored in the compressed file.  The tables used herein are shared
+ * with those of the compress() routine.  See the definitions above.
+ */
+void
+decompress(void)
+{
+	int finchar;
+	code_int code, oldcode, incode;
+	uchar *stackp;
+
+	/*
+	* As above, initialize the first 256 entries in the table.
+	*/
+	maxcode = MAXCODE(n_bits = INIT_BITS);
+	for (code = 255; code >= 0; code--) {
+		tab_prefixof(code) = 0;
+		tab_suffixof(code) = (uchar)code;
+	}
+	free_ent = (block_compress? FIRST: 256);
+
+	finchar = oldcode = getcode();
+	if(oldcode == -1)		/* EOF already? */
+		return;			/* Get out of here */
+	putchar((char)finchar);		/* first code must be 8 bits = char */
+	if(ferror(stdout))		/* Crash if can't write */
+		writeerr();
+	stackp = de_stack;
+
+	while ((code = getcode()) > -1) {
+		if ((code == CLEAR) && block_compress) {
+			for (code = 255; code >= 0; code--)
+				tab_prefixof(code) = 0;
+			clear_flg = 1;
+			free_ent = FIRST - 1;
+			if ((code = getcode()) == -1)	/* O, untimely death! */
+				break;
+		}
+		incode = code;
+		/*
+		 * Special case for KwKwK string.
+		 */
+		if (code >= free_ent) {
+			*stackp++ = finchar;
+			code = oldcode;
+		}
+
+		/*
+		 * Generate output characters in reverse order
+		 */
+		while (code >= 256) {
+			*stackp++ = tab_suffixof(code);
+			code = tab_prefixof(code);
+		}
+		*stackp++ = finchar = tab_suffixof(code);
+
+		/*
+		 * And put them out in forward order
+		 */
+		do {
+			putchar(*--stackp);
+		} while (stackp > de_stack);
+
+		/*
+		 * Generate the new entry.
+		 */
+		if ( (code=free_ent) < maxmaxcode ) {
+			tab_prefixof(code) = (ushort)oldcode;
+			tab_suffixof(code) = finchar;
+			free_ent = code+1;
+		}
+		/*
+		 * Remember previous code.
+		 */
+		oldcode = incode;
+	}
+	fflush(stdout);
+	if(ferror(stdout))
+		writeerr();
+}
+
+/*
+ * TAG( getcode )
+ *
+ * Read one code from the standard input.  If EOF, return -1.
+ * Inputs:
+ * 	stdin
+ * Outputs:
+ * 	code or -1 is returned.
+ */
+code_int
+getcode()
+{
+	int r_off, bits;
+	code_int code;
+	static int offset = 0, size = 0;
+	static uchar buf[BITS];
+	uchar *bp = buf;
+
+	if ( clear_flg > 0 || offset >= size || free_ent > maxcode ) {
+		/*
+		 * If the next entry will be too big for the current code
+		 * size, then we must increase the size.  This implies reading
+		 * a new buffer full, too.
+		 */
+		if ( free_ent > maxcode ) {
+			n_bits++;
+			if ( n_bits == maxbits )
+				maxcode = maxmaxcode; /* won't get any bigger now */
+			else
+				maxcode = MAXCODE(n_bits);
+		}
+		if ( clear_flg > 0) {
+			maxcode = MAXCODE(n_bits = INIT_BITS);
+			clear_flg = 0;
+		}
+		size = fread(buf, 1, n_bits, stdin);
+		if (size <= 0)
+			return -1;			/* end of file */
+		offset = 0;
+		/* Round size down to integral number of codes */
+		size = (size << 3) - (n_bits - 1);
+	}
+	r_off = offset;
+	bits = n_bits;
+	/*
+	 * Get to the first byte.
+	 */
+	bp += (r_off >> 3);
+	r_off &= 7;
+	/* Get first part (low order bits) */
+	code = (*bp++ >> r_off);
+	bits -= (8 - r_off);
+	r_off = 8 - r_off;		/* now, offset into code word */
+	/* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
+	if (bits >= 8) {
+		code |= *bp++ << r_off;
+		r_off += 8;
+		bits -= 8;
+	}
+	/* high order bits. */
+	code |= (*bp & rmask[bits]) << r_off;
+	offset += n_bits;
+	return code;
+}
+
+#ifdef DEBUG
+printcodes()
+{
+	/*
+	* Just print out codes from input file.  For debugging.
+	*/
+	code_int code;
+	int col = 0, bits;
+
+	bits = n_bits = INIT_BITS;
+	maxcode = MAXCODE(n_bits);
+	free_ent = ((block_compress) ? FIRST : 256 );
+	while ( ( code = getcode() ) >= 0 ) {
+	if ( (code == CLEAR) && block_compress ) {
+			free_ent = FIRST - 1;
+			clear_flg = 1;
+	}
+	else if ( free_ent < maxmaxcode )
+		free_ent++;
+	if ( bits != n_bits ) {
+		fprintf(stderr, "\nChange to %d bits\n", n_bits );
+		bits = n_bits;
+		col = 0;
+	}
+	fprintf(stderr, "%5d%c", code, (col+=6) >= 74 ? (col = 0, '\n') : ' ' );
+	}
+	putc( '\n', stderr );
+	exit( 0 );
+}
+
+code_int sorttab[1<<BITS];	/* sorted pointers into htab */
+
+#define STACK_SIZE	15000
+
+dump_tab()	/* dump string table */
+{
+	int i, first, c, ent;
+	int stack_top = STACK_SIZE;
+
+	if(do_decomp == 0) {	/* compressing */
+	int flag = 1;
+
+	for(i=0; i<hsize; i++) {	/* build sort pointers */
+		if((long)htabof(i) >= 0) {
+			sorttab[codetabof(i)] = i;
+		}
+	}
+	first = block_compress ? FIRST : 256;
+	for(i = first; i < free_ent; i++) {
+		fprintf(stderr, "%5d: \"", i);
+		de_stack[--stack_top] = '\n';
+		de_stack[--stack_top] = '"';
+		stack_top = in_stack((htabof(sorttab[i])>>maxbits)&0xff,
+	stack_top);
+		for(ent=htabof(sorttab[i]) & ((1<<maxbits)-1);
+			ent > 256;
+			ent=htabof(sorttab[ent]) & ((1<<maxbits)-1)) {
+			stack_top = in_stack(htabof(sorttab[ent]) >> maxbits,
+						stack_top);
+		}
+		stack_top = in_stack(ent, stack_top);
+		fwrite( &de_stack[stack_top], 1, STACK_SIZE-stack_top, stderr);
+			stack_top = STACK_SIZE;
+	}
+	} else if(!debug) {	/* decompressing */
+
+	for ( i = 0; i < free_ent; i++ ) {
+		ent = i;
+		c = tab_suffixof(ent);
+		if ( isascii(c) && isprint(c) )
+		fprintf( stderr, "%5d: %5d/'%c'  \"",
+				ent, tab_prefixof(ent), c );
+		else
+		fprintf( stderr, "%5d: %5d/\\%03o \"",
+				ent, tab_prefixof(ent), c );
+		de_stack[--stack_top] = '\n';
+		de_stack[--stack_top] = '"';
+		for ( ; ent != NULL;
+			ent = (ent >= FIRST ? tab_prefixof(ent) : NULL) ) {
+		stack_top = in_stack(tab_suffixof(ent), stack_top);
+		}
+		fwrite( &de_stack[stack_top], 1, STACK_SIZE - stack_top, stderr );
+		stack_top = STACK_SIZE;
+	}
+	}
+}
+
+int
+in_stack(int c, int stack_top)
+{
+	if ( (isascii(c) && isprint(c) && c != '\\') || c == ' ' ) {
+		de_stack[--stack_top] = c;
+	} else {
+		switch( c ) {
+		case '\n': de_stack[--stack_top] = 'n'; break;
+		case '\t': de_stack[--stack_top] = 't'; break;
+		case '\b': de_stack[--stack_top] = 'b'; break;
+		case '\f': de_stack[--stack_top] = 'f'; break;
+		case '\r': de_stack[--stack_top] = 'r'; break;
+		case '\\': de_stack[--stack_top] = '\\'; break;
+		default:
+	 	de_stack[--stack_top] = '0' + c % 8;
+	 	de_stack[--stack_top] = '0' + (c / 8) % 8;
+	 	de_stack[--stack_top] = '0' + c / 64;
+	 	break;
+		}
+		de_stack[--stack_top] = '\\';
+	}
+	return stack_top;
+}
+#endif /* DEBUG */
+
+void
+writeerr(void)
+{
+	perror(ofname);
+	unlink(ofname);
+	exit(1);
+}
+
+void
+copystat(ifname, ofname)
+char *ifname, *ofname;
+{
+	int mode;
+	time_t timep[2];			/* should be struct utimbuf */
+	struct stat statbuf;
+
+	fclose(stdout);
+	if (stat(ifname, &statbuf)) {		/* Get stat on input file */
+		perror(ifname);
+		return;
+	}
+	if (!S_ISREG(statbuf.st_mode)) {
+		if (quiet)
+			fprintf(stderr, "%s: ", ifname);
+		fprintf(stderr, " -- not a regular file: unchanged");
+		exit_stat = 1;
+	} else if (exit_stat == 2 && !force) {
+		/* No compression: remove file.Z */
+		if (!quiet)
+			fprintf(stderr, " -- file unchanged");
+	} else {			/* Successful Compression */
+		exit_stat = 0;
+		mode = statbuf.st_mode & 0777;
+		if (chmod(ofname, mode))		/* Copy modes */
+			perror(ofname);
+		/* Copy ownership */
+		chown(ofname, statbuf.st_uid, statbuf.st_gid);
+		timep[0] = statbuf.st_atime;
+		timep[1] = statbuf.st_mtime;
+		/* Update last accessed and modified times */
+		utime(ofname, (struct utimbuf *)timep);
+//		if (unlink(ifname))	/* Remove input file */
+//			perror(ifname);
+		return;			/* success */
+	}
+
+	/* Unsuccessful return -- one of the tests failed */
+	if (unlink(ofname))
+		perror(ofname);
+}
+
+/*
+ * This routine returns 1 if we are running in the foreground and stderr
+ * is a tty.
+ */
+int
+foreground(void)
+{
+	if(bgnd_flag)			/* background? */
+		return 0;
+	else				/* foreground */
+		return isatty(2);	/* and stderr is a tty */
+}
+
+void
+onintr(int x)
+{
+	USED(x);
+	unlink(ofname);
+	exit(1);
+}
+
+void
+oops(int x)		/* wild pointer -- assume bad input */
+{
+	USED(x);
+	if (do_decomp == 1)
+		fprintf(stderr, "uncompress: corrupt input\n");
+	unlink(ofname);
+	exit(1);
+}
+
+void
+cl_block(void)		/* table clear for block compress */
+{
+	long rat;
+
+	checkpoint = in_count + CHECK_GAP;
+#ifdef DEBUG
+	if ( debug ) {
+		fprintf ( stderr, "count: %ld, ratio: ", in_count );
+		prratio ( stderr, in_count, bytes_out );
+		fprintf ( stderr, "\n");
+	}
+#endif /* DEBUG */
+
+	if (in_count > 0x007fffff) {	/* shift will overflow */
+		rat = bytes_out >> 8;
+		if (rat == 0)		/* Don't divide by zero */
+			rat = 0x7fffffff;
+		else
+			rat = in_count / rat;
+	} else
+		rat = (in_count << 8) / bytes_out;	/* 8 fractional bits */
+	if (rat > ratio)
+		ratio = rat;
+	else {
+		ratio = 0;
+#ifdef DEBUG
+		if (verbose)
+			dump_tab();	/* dump string table */
+#endif
+		cl_hash((count_int)hsize);
+		free_ent = FIRST;
+		clear_flg = 1;
+		output((code_int)CLEAR);
+#ifdef DEBUG
+		if (debug)
+			fprintf(stderr, "clear\n");
+#endif /* DEBUG */
+	}
+}
+
+void
+cl_hash(count_int hsize)		/* reset code table */
+{
+	count_int *htab_p = htab+hsize;
+	long i;
+	long m1 = -1;
+
+	i = hsize - 16;
+ 	do {				/* might use Sys V memset(3) here */
+		*(htab_p-16) = m1;
+		*(htab_p-15) = m1;
+		*(htab_p-14) = m1;
+		*(htab_p-13) = m1;
+		*(htab_p-12) = m1;
+		*(htab_p-11) = m1;
+		*(htab_p-10) = m1;
+		*(htab_p-9) = m1;
+		*(htab_p-8) = m1;
+		*(htab_p-7) = m1;
+		*(htab_p-6) = m1;
+		*(htab_p-5) = m1;
+		*(htab_p-4) = m1;
+		*(htab_p-3) = m1;
+		*(htab_p-2) = m1;
+		*(htab_p-1) = m1;
+		htab_p -= 16;
+	} while ((i -= 16) >= 0);
+	for ( i += 16; i > 0; i-- )
+		*--htab_p = m1;
+}
+
+void
+prratio(stream, num, den)
+FILE *stream;
+long num, den;
+{
+	int q;				/* Doesn't need to be long */
+
+	if(num > 214748L)		/* 2147483647/10000 */
+		q = num / (den / 10000L);
+	else
+		q = 10000L * num / den;	/* Long calculations, though */
+	if (q < 0) {
+		putc('-', stream);
+		q = -q;
+	}
+	fprintf(stream, "%d.%02d%%", q / 100, q % 100);
+}
+
+void
+version(void)
+{
+	fprintf(stderr, "%s\n", rcs_ident);
+	fprintf(stderr, "Options: ");
+#ifdef DEBUG
+	fprintf(stderr, "DEBUG, ");
+#endif
+#ifdef BSD4_2
+	fprintf(stderr, "BSD4_2, ");
+#endif
+	fprintf(stderr, "BITS = %d\n", BITS);
+}
+
+/*
+ * The revision-history novel:
+ *
+ * $Header: compress.c,v 4.0 85/07/30 12:50:00 joe Release $
+ * $Log:	compress.c,v $
+ * Revision 4.0  85/07/30  12:50:00  joe
+ * Removed ferror() calls in output routine on every output except first.
+ * Prepared for release to the world.
+ *
+ * Revision 3.6  85/07/04  01:22:21  joe
+ * Remove much wasted storage by overlaying hash table with the tables
+ * used by decompress: tab_suffix[1<<BITS], stack[8000].  Updated USERMEM
+ * computations.  Fixed dump_tab() DEBUG routine.
+ *
+ * Revision 3.5  85/06/30  20:47:21  jaw
+ * Change hash function to use exclusive-or.  Rip out hash cache.  These
+ * speedups render the megamemory version defunct, for now.  Make decoder
+ * stack global.  Parts of the RCS trunks 2.7, 2.6, and 2.1 no longer apply.
+ *
+ * Revision 3.4  85/06/27  12:00:00  ken
+ * Get rid of all floating-point calculations by doing all compression ratio
+ * calculations in fixed point.
+ *
+ * Revision 3.3  85/06/24  21:53:24  joe
+ * Incorporate portability suggestion for M_XENIX.  Got rid of text on #else
+ * and #endif lines.  Cleaned up #ifdefs for vax and interdata.
+ *
+ * Revision 3.2  85/06/06  21:53:24  jaw
+ * Incorporate portability suggestions for Z8000, IBM PC/XT from mailing list.
+ * Default to "quiet" output (no compression statistics).
+ *
+ * Revision 3.1  85/05/12  18:56:13  jaw
+ * Integrate decompress() stack speedups (from early pointer mods by McKie).
+ * Repair multi-file USERMEM gaffe.  Unify 'force' flags to mimic semantics
+ * of SVR2 'pack'.  Streamline block-compress table clear logic.  Increase
+ * output byte count by magic number size.
+ *
+ * Revision 3.0	84/11/27  11:50:00  petsd!joe
+ * Set HSIZE depending on BITS.  Set BITS depending on USERMEM.  Unrolled
+ * loops in clear routines.  Added "-C" flag for 2.0 compatibility.  Used
+ * unsigned compares on Perkin-Elmer.  Fixed foreground check.
+ *
+ * Revision 2.7	84/11/16  19:35:39  ames!jaw
+ * Cache common hash codes based on input statistics; this improves
+ * performance for low-density raster images.  Pass on #ifdef bundle
+ * from Turkowski.
+ *
+ * Revision 2.6	84/11/05  19:18:21  ames!jaw
+ * Vary size of hash tables to reduce time for small files.
+ * Tune PDP-11 hash function.
+ *
+ * Revision 2.5	84/10/30  20:15:14  ames!jaw
+ * Junk chaining; replace with the simpler (and, on the VAX, faster)
+ * double hashing, discussed within.  Make block compression standard.
+ *
+ * Revision 2.4	84/10/16  11:11:11  ames!jaw
+ * Introduce adaptive reset for block compression, to boost the rate
+ * another several percent.  (See mailing list notes.)
+ *
+ * Revision 2.3	84/09/22  22:00:00  petsd!joe
+ * Implemented "-B" block compress.  Implemented REVERSE sorting of tab_next.
+ * Bug fix for last bits.  Changed fwrite to putchar loop everywhere.
+ *
+ * Revision 2.2	84/09/18  14:12:21  ames!jaw
+ * Fold in news changes, small machine typedef from thomas,
+ * #ifdef interdata from joe.
+ *
+ * Revision 2.1	84/09/10  12:34:56  ames!jaw
+ * Configured fast table lookup for 32-bit machines.
+ * This cuts user time in half for b <= FBITS, and is useful for news batching
+ * from VAX to PDP sites.  Also sped up decompress() [fwrite->putc] and
+ * added signal catcher [plus beef in writeerr()] to delete effluvia.
+ *
+ * Revision 2.0	84/08/28  22:00:00  petsd!joe
+ * Add check for foreground before prompting user.  Insert maxbits into
+ * compressed file.  Force file being uncompressed to end with ".Z".
+ * Added "-c" flag and "zcat".  Prepared for release.
+ *
+ * Revision 1.10  84/08/24  18:28:00  turtlevax!ken
+ * Will only compress regular files (no directories), added a magic number
+ * header (plus an undocumented -n flag to handle old files without headers),
+ * added -f flag to force overwriting of possibly existing destination file,
+ * otherwise the user is prompted for a response.  Will tack on a .Z to a
+ * filename if it doesn't have one when decompressing.  Will only replace
+ * file if it was compressed.
+ *
+ * Revision 1.9  84/08/16  17:28:00  turtlevax!ken
+ * Removed scanargs(), getopt(), added .Z extension and unlimited number of
+ * filenames to compress.  Flags may be clustered (-Ddvb12) or separated
+ * (-D -d -v -b 12), or combination thereof.  Modes and other status is
+ * copied with copystat().  -O bug for 4.2 seems to have disappeared with
+ * 1.8.
+ *
+ * Revision 1.8  84/08/09  23:15:00  joe
+ * Made it compatible with vax version, installed jim's fixes/enhancements
+ *
+ * Revision 1.6  84/08/01  22:08:00  joe
+ * Sped up algorithm significantly by sorting the compress chain.
+ *
+ * Revision 1.5  84/07/13  13:11:00  srd
+ * Added C version of vax asm routines.  Changed structure to arrays to
+ * save much memory.  Do unsigned compares where possible (faster on
+ * Perkin-Elmer)
+ *
+ * Revision 1.4  84/07/05  03:11:11  thomas
+ * Clean up the code a little and lint it.  (Lint complains about all
+ * the regs used in the asm, but I'm not going to "fix" this.)
+ *
+ * Revision 1.3  84/07/05  02:06:54  thomas
+ * Minor fixes.
+ *
+ * Revision 1.2  84/07/05  00:27:27  thomas
+ * Add variable bit length output.
+ */
diff --git a/src/cmd/compress/mkfile b/src/cmd/compress/mkfile
new file mode 100755
index 00000000..5af1958d
--- /dev/null
+++ b/src/cmd/compress/mkfile
@@ -0,0 +1,15 @@
+<$PLAN9/src/mkhdr
+
+TARG=\
+	compress \
+	zcat \
+	uncompress
+
+$O.uncompress:Q: $O.compress
+	cp $prereq $target
+
+$O.zcat:Q: $O.compress
+	cp $prereq $target
+
+<$PLAN9/src/mkmany
+
diff --git a/src/cmd/devdraw/devdraw.c b/src/cmd/devdraw/devdraw.c
index 086574ef..b4c373ad 100644
--- a/src/cmd/devdraw/devdraw.c
+++ b/src/cmd/devdraw/devdraw.c
@@ -55,10 +55,7 @@ gfx_replacescreenimage(Client *c, Memimage *m)
 		_freememimage(om);
 	}
 	qunlock(&c->drawlk);
-
-	qlock(&c->eventlk);
-	c->mouse.resized = 1;
-	qunlock(&c->eventlk);
+	gfx_mouseresized(c);
 }
 
 static void
diff --git a/src/cmd/devdraw/devdraw.h b/src/cmd/devdraw/devdraw.h
index 4980ed90..6829ab32 100644
--- a/src/cmd/devdraw/devdraw.h
+++ b/src/cmd/devdraw/devdraw.h
@@ -187,6 +187,7 @@ void	gfx_keystroke(Client*, int);
 void	gfx_main(void);
 void	gfx_mousetrack(Client*, int, int, int, uint);
 void	gfx_replacescreenimage(Client*, Memimage*);
+void	gfx_mouseresized(Client*);
 void	gfx_started(void);
 
 // rpc_* routines are called on the RPC thread,
diff --git a/src/cmd/devdraw/mac-screen.m b/src/cmd/devdraw/mac-screen.m
index e02a2524..c6e58341 100644
--- a/src/cmd/devdraw/mac-screen.m
+++ b/src/cmd/devdraw/mac-screen.m
@@ -510,7 +510,7 @@ void
 rpc_resizeimg(Client *c)
 {
 	DrawView *view = (__bridge DrawView*)c->view;
-	dispatch_sync(dispatch_get_main_queue(), ^(void){
+	dispatch_async(dispatch_get_main_queue(), ^(void){
 		[view resizeimg];
 	});
 }
@@ -518,7 +518,6 @@ rpc_resizeimg(Client *c)
 - (void)resizeimg {
 	[self initimg];
 	gfx_replacescreenimage(self.client, self.img);
-	[self sendmouse:0];
 }
 
 - (void)windowDidResize:(NSNotification *)notification {
@@ -561,6 +560,10 @@ rpc_resizewindow(Client *c, Rectangle r)
         [self sendmouse:0];
 }
 
+- (void)windowDidResignKey:(id)arg {
+	gfx_abortcompose(self.client);
+}
+
 - (void)mouseMoved:(NSEvent*)e{ [self getmouse:e];}
 - (void)mouseDown:(NSEvent*)e{ [self getmouse:e];}
 - (void)mouseDragged:(NSEvent*)e{ [self getmouse:e];}
@@ -930,6 +933,13 @@ rpc_setmouse(Client *c, Point p)
 
 - (NSApplicationPresentationOptions)window:(id)arg
 		willUseFullScreenPresentationOptions:(NSApplicationPresentationOptions)proposedOptions {
+	// The default for full-screen is to auto-hide the dock and menu bar,
+	// but the menu bar in particular comes back when the cursor is just
+	// near the top of the screen, which makes acme's top tag line very difficult to use.
+	// Disable the menu bar entirely.
+	// In theory this code disables the dock entirely too, but if you drag the mouse
+	// down far enough off the bottom of the screen the dock still unhides.
+	// That's OK.
 	NSApplicationPresentationOptions o;
 	o = proposedOptions;
 	o &= ~(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar);
@@ -938,16 +948,21 @@ rpc_setmouse(Client *c, Point p)
 }
 
 - (void)windowWillEnterFullScreen:(NSNotification*)notification {
-	// TODO: This should only be done if the window
-	// is on the screen with the dock.
-	// But how can you tell which window has the dock?
+	// This is a heavier-weight way to make sure the menu bar and dock go away,
+	// but this affects all screens even though the app is running on full screen
+	// on only one screen, so it's not great. The behavior from the
+	// willUseFullScreenPresentationOptions seems to be enough for now.
+	/*
 	[[NSApplication sharedApplication]
 		setPresentationOptions:NSApplicationPresentationHideMenuBar | NSApplicationPresentationHideDock];
+	*/
 }
 
 - (void)windowDidExitFullScreen:(NSNotification*)notification {
+	/*
 	[[NSApplication sharedApplication]
 		setPresentationOptions:NSApplicationPresentationDefault];
+	*/
 }
 @end
 
diff --git a/src/cmd/devdraw/srv.c b/src/cmd/devdraw/srv.c
index bfeb7c38..570091bc 100644
--- a/src/cmd/devdraw/srv.c
+++ b/src/cmd/devdraw/srv.c
@@ -37,6 +37,8 @@ usage(void)
 void
 threadmain(int argc, char **argv)
 {
+	char *p;
+
 	ARGBEGIN{
 	case 'D':		/* for good ps -a listings */
 		break;
@@ -52,6 +54,10 @@ threadmain(int argc, char **argv)
 		usage();
 	}ARGEND
 
+	fmtinstall('H', encodefmt);
+	if((p = getenv("DEVDRAWTRACE")) != nil)
+		trace = atoi(p);
+
 	if(srvname == nil) {
 		client0 = mallocz(sizeof(Client), 1);
 		if(client0 == nil){
@@ -395,11 +401,30 @@ matchmouse(Client *c)
 }
 
 void
+gfx_mouseresized(Client *c)
+{
+	gfx_mousetrack(c, -1, -1, -1, -1);
+}
+
+void
 gfx_mousetrack(Client *c, int x, int y, int b, uint ms)
 {
 	Mouse *m;
 
 	qlock(&c->eventlk);
+	if(x == -1 && y == -1 && b == -1 && ms == -1) {
+		Mouse *copy;
+		// repeat last mouse event for resize
+		if(c->mouse.ri == 0)
+			copy = &c->mouse.m[nelem(c->mouse.m)-1];
+		else
+			copy = &c->mouse.m[c->mouse.ri-1];
+		x = copy->xy.x;
+		y = copy->xy.y;
+		b = copy->buttons;
+		ms = copy->msec;
+		c->mouse.resized = 1;
+	}
 	if(x < c->mouserect.min.x)
 		x = c->mouserect.min.x;
 	if(x > c->mouserect.max.x)
diff --git a/src/cmd/devdraw/x11-inc.h b/src/cmd/devdraw/x11-inc.h
index dca3ebcd..ab4c2505 100644
--- a/src/cmd/devdraw/x11-inc.h
+++ b/src/cmd/devdraw/x11-inc.h
@@ -17,6 +17,7 @@
 #include <X11/IntrinsicP.h>
 #include <X11/StringDefs.h>
 #ifdef SHOWEVENT
+#include <stdio.h>
 #include "../rio/showevent/ShowEvent.c"
 #endif
 
diff --git a/src/cmd/devdraw/x11-screen.c b/src/cmd/devdraw/x11-screen.c
index 8026e1e6..62f49f2f 100644
--- a/src/cmd/devdraw/x11-screen.c
+++ b/src/cmd/devdraw/x11-screen.c
@@ -44,7 +44,7 @@ static Xwin*
 newxwin(Client *c)
 {
 	Xwin *w;
-	
+
 	w = mallocz(sizeof *w, 1);
 	if(w == nil)
 		sysfatal("out of memory");
@@ -59,7 +59,7 @@ static Xwin*
 findxwin(XDrawable d)
 {
 	Xwin *w, **l;
-	
+
 	for(l=&_x.windows; (w=*l) != nil; l=&w->next) {
 		if(w->drawable == d) {
 			/* move to front */
@@ -550,8 +550,6 @@ xattach(Client *client, char *label, char *winsize)
 		havemin = 0;
 	}
 	w = newxwin(client);
-	w->screenrect = Rect(0, 0, WidthOfScreen(xscreen), HeightOfScreen(xscreen));
-	w->windowrect = r;
 
 	memset(&attr, 0, sizeof attr);
 	attr.colormap = _x.cmap;
@@ -658,7 +656,7 @@ xattach(Client *client, char *label, char *winsize)
 		_x.losefocus = XInternAtom(_x.display, "_9WM_LOSE_FOCUS", False);
 		_x.wmprotos = XInternAtom(_x.display, "WM_PROTOCOLS", False);
 	}
-	
+
 	atoms[0] = _x.takefocus;
 	atoms[1] = _x.losefocus;
 	XChangeProperty(_x.display, w->drawable, _x.wmprotos, XA_ATOM, 32,
@@ -679,6 +677,8 @@ xattach(Client *client, char *label, char *winsize)
 		}
 	}else
 		fprint(2, "XGetWindowAttributes: bad attrs\n");
+	w->screenrect = Rect(0, 0, WidthOfScreen(xscreen), HeightOfScreen(xscreen));
+	w->windowrect = r;
 
 	/*
 	 * Allocate our local backing store.
@@ -700,7 +700,7 @@ xattach(Client *client, char *label, char *winsize)
 		_x.gcsimplesrc 	= xgc(w->screenpm, FillStippled, -1);
 		_x.gczero	= xgc(w->screenpm, -1, -1);
 		_x.gcreplsrc	= xgc(w->screenpm, FillTiled, -1);
-	
+
 		pmid = XCreatePixmap(_x.display, w->drawable, 1, 1, 1);
 		_x.gcfill0	= xgc(pmid, FillSolid, 0);
 		_x.gccopy0	= xgc(pmid, -1, -1);
@@ -729,7 +729,7 @@ rpc_setlabel(Client *client, char *label)
 {
 	Xwin *w = (Xwin*)client->view;
 	XTextProperty name;
-	
+
 	/*
 	 * Label and other properties required by ICCCCM.
 	 */
@@ -1032,7 +1032,7 @@ _xreplacescreenimage(Client *client)
 	XDrawable pixmap;
 	Rectangle r;
 	Xwin *w;
-	
+
 	w = (Xwin*)client->view;
 	r = w->newscreenr;
 	pixmap = XCreatePixmap(_x.display, w->drawable, Dx(r), Dy(r), _x.depth);
@@ -1042,7 +1042,9 @@ _xreplacescreenimage(Client *client)
 	w->nextscreenpm = pixmap;
 	w->screenr = r;
 	client->mouserect = r;
+	xunlock();
 	gfx_replacescreenimage(client, m);
+	xlock();
 	return 1;
 }
 
@@ -1527,7 +1529,7 @@ __xputsnarf(char *data)
 {
 	XButtonEvent e;
 	Xwin *w;
-	
+
 	if(strlen(data) >= SnarfSize)
 		return;
 	qlock(&clip.lk);
@@ -1730,7 +1732,7 @@ rpc_bouncemouse(Client *c, Mouse m)
 	Xwin *w = (Xwin*)c->view;
 	XButtonEvent e;
 	XWindow dw;
-	
+
 	xlock();
 	e.type = ButtonPress;
 	e.state = 0;
diff --git a/src/cmd/draw/clock.c b/src/cmd/draw/clock.c
index b804e1f4..b5d028b6 100644
--- a/src/cmd/draw/clock.c
+++ b/src/cmd/draw/clock.c
@@ -25,7 +25,6 @@ redraw(Image *screen)
 	static int rad;
 	int i;
 	int anghr, angmin;
-	static Tm tms;
 	static Tm ntms;
 
 	ntm = time(0);
@@ -36,7 +35,6 @@ redraw(Image *screen)
 	anghr = 90-(ntms.hour*5 + ntms.min/12)*6;
 	angmin = 90-ntms.min*6;
 	tm = ntm;
-	tms = ntms;
 	r = screen->r;
 	c = divpt(addpt(r.min, r.max), 2);
 	rad = Dx(r) < Dy(r) ? Dx(r) : Dy(r);
diff --git a/src/cmd/rio/mkfile b/src/cmd/rio/mkfile
index 8b8ea46a..20202e22 100644
--- a/src/cmd/rio/mkfile
+++ b/src/cmd/rio/mkfile
@@ -16,7 +16,7 @@ RIOFILES=\
 CFLAGS=$CFLAGS -DDEBUG
 HFILES=dat.h fns.h
 
-TARG=rio xshove
+TARG=rio winwatch xshove
 
 # need to add lib64 when it exists (on x86-64), but
 # Darwin complains about the nonexistant directory
diff --git a/src/cmd/rio/winwatch.c b/src/cmd/rio/winwatch.c
new file mode 100644
index 00000000..1a93e78c
--- /dev/null
+++ b/src/cmd/rio/winwatch.c
@@ -0,0 +1,524 @@
+/*
+ * slightly modified from
+ * https://github.com/fhs/misc/blob/master/cmd/winwatch/winwatch.c
+ * so as to deal with memory leaks and certain X errors
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <regexp.h>
+#include <fmt.h>
+#include "../devdraw/x11-inc.h"
+
+AUTOLIB(X11);
+
+typedef struct Win Win;
+struct Win {
+	XWindow n;
+	int dirty;
+	char *label;
+	Rectangle r;
+};
+
+XDisplay *dpy;
+XWindow root;
+Atom net_active_window;
+Reprog *exclude = nil;
+Win *win;
+int nwin;
+int mwin;
+int onwin;
+int rows, cols;
+int sortlabels;
+int showwmnames;
+Font *font;
+Image *lightblue;
+
+XErrorHandler oldxerrorhandler;
+
+enum {
+	PAD = 3,
+	MARGIN = 5
+};
+
+static jmp_buf savebuf;
+
+int
+winwatchxerrorhandler(XDisplay *disp, XErrorEvent *xe)
+{
+	char buf[100];
+
+	XGetErrorText(disp, xe->error_code, buf, 100);
+	fprint(2, "winwatch: X error %s, request code %d\n",
+	    buf, xe->request_code);
+	XFlush(disp);
+	XSync(disp, False);
+	XSetErrorHandler(oldxerrorhandler);
+	longjmp(savebuf, 1);
+	return(0);  /* Not reached */
+}
+
+void*
+erealloc(void *v, ulong n)
+{
+	v = realloc(v, n);
+	if(v==nil)
+		sysfatal("out of memory reallocating");
+	return v;
+}
+
+char*
+estrdup(char *s)
+{
+	s = strdup(s);
+	if(s==nil)
+		sysfatal("out of memory allocating");
+	return(s);
+}
+
+char*
+getproperty(XWindow w, Atom a)
+{
+	uchar *p;
+	int fmt;
+	Atom type;
+	ulong n, dummy;
+	int s;
+
+	n = 100;
+	p = nil;
+	oldxerrorhandler = XSetErrorHandler(winwatchxerrorhandler);
+	s = XGetWindowProperty(dpy, w, a, 0, 100L, 0,
+	    AnyPropertyType, &type, &fmt, &n, &dummy, &p);
+	XFlush(dpy);
+	XSync(dpy, False);
+	XSetErrorHandler(oldxerrorhandler);
+	if(s!=0){
+		XFree(p);
+		return(nil);
+	}
+
+	return((char*)p);
+}
+
+XWindow
+findname(XWindow w)
+{
+	int i;
+	uint nxwin;
+	XWindow dw1, dw2, *xwin;
+	char *p;
+	int s;
+	Atom net_wm_name;
+
+	p = getproperty(w, XA_WM_NAME);
+	if(p){
+		free(p);
+		return(w);
+	}
+
+	net_wm_name = XInternAtom(dpy, "_NET_WM_NAME", FALSE);
+	p = getproperty(w, net_wm_name);
+	if(p){
+		free(p);
+		return(w);
+	}
+
+	oldxerrorhandler = XSetErrorHandler(winwatchxerrorhandler);
+	s = XQueryTree(dpy, w, &dw1, &dw2, &xwin, &nxwin);
+	XFlush(dpy);
+	XSync(dpy, False);
+	XSetErrorHandler(oldxerrorhandler);
+	if(s == 0) {
+		if (xwin != NULL)
+			XFree(xwin);
+		return 0;
+	}
+
+	for (i = 0; i < nxwin; i++) {
+		w = findname(xwin[i]);
+		if (w != 0) {
+			XFree(xwin);
+			return w;
+		}
+	}
+	XFree(xwin);
+
+	return 0;
+}
+
+int
+wcmp(const void *w1, const void *w2)
+{
+	return *(XWindow *) w1 - *(XWindow *) w2;
+}
+
+/* unicode-aware case-insensitive strcmp,  taken from golang’s gc/subr.c */
+
+int
+_cistrcmp(char *p, char *q)
+{
+	Rune rp, rq;
+
+	while(*p || *q) {
+		if(*p == 0)
+			return +1;
+		if(*q == 0)
+			return -1;
+		p += chartorune(&rp, p);
+		q += chartorune(&rq, q);
+		rp = tolowerrune(rp);
+		rq = tolowerrune(rq);
+		if(rp < rq)
+			return -1;
+		if(rp > rq)
+			return +1;
+	}
+	return 0;
+}
+
+int
+winlabelcmp(const void *w1, const void *w2)
+{
+	const Win *p1 = (Win *) w1;
+	const Win *p2 = (Win *) w2;
+	return _cistrcmp(p1->label, p2->label);
+}
+
+void
+refreshwin(void)
+{
+	XWindow dw1, dw2, *xwin;
+	XClassHint class;
+	XWindowAttributes attr;
+	char *label;
+	char *wmname;
+	int i, nw;
+	uint nxwin;
+	Status s;
+	Atom net_wm_name;
+
+
+	oldxerrorhandler = XSetErrorHandler(winwatchxerrorhandler);
+	s = XQueryTree(dpy, root, &dw1, &dw2, &xwin, &nxwin);
+	XFlush(dpy);
+	XSync(dpy, False);
+	XSetErrorHandler(oldxerrorhandler);
+	if(s==0){
+		if(xwin!=NULL)
+			XFree(xwin);
+		return;
+	}
+	qsort(xwin, nxwin, sizeof(xwin[0]), wcmp);
+
+	nw = 0;
+	for(i=0; i<nxwin; i++){
+		memset(&attr, 0, sizeof attr);
+		xwin[i] = findname(xwin[i]);
+		if(xwin[i]==0)
+			continue;
+
+		oldxerrorhandler = XSetErrorHandler(winwatchxerrorhandler);
+		s = XGetWindowAttributes(dpy, xwin[i], &attr);
+		XFlush(dpy);
+		XSync(dpy, False);
+		XSetErrorHandler(oldxerrorhandler);
+		if(s==0)
+			continue;
+		if (attr.width <= 0 ||
+		    attr.override_redirect ||
+		    attr.map_state != IsViewable)
+			continue;
+
+		oldxerrorhandler = XSetErrorHandler(winwatchxerrorhandler);
+		s = XGetClassHint(dpy, xwin[i], &class);
+		XFlush(dpy);
+		XSync(dpy, False);
+		XSetErrorHandler(oldxerrorhandler);
+
+		if(s==0)
+			continue;
+
+		if (exclude!=nil && regexec(exclude, class.res_name, nil, 0)) {
+			free(class.res_name);
+			free(class.res_class);
+			continue;
+		}
+
+		net_wm_name = XInternAtom(dpy, "_NET_WM_NAME", FALSE);
+		wmname = getproperty(xwin[i], net_wm_name);
+
+		if(wmname==nil){
+			wmname = getproperty(xwin[i], XA_WM_NAME);
+			if(wmname==nil){
+				free(class.res_name);
+				free(class.res_class);
+				continue;
+			}
+		}
+
+		label = class.res_name;
+		if(showwmnames==1)
+			label = wmname;
+
+		if(nw<nwin && win[nw].n==xwin[i] && strcmp(win[nw].label, label)==0) {
+			nw++;
+			free(wmname);
+			free(class.res_name);
+			free(class.res_class);
+			continue;
+		}
+
+		if(nw<nwin){
+			free(win[nw].label);
+			win[nw].label = nil;
+		}
+
+		if(nw>=mwin){
+			mwin += 8;
+			win = erealloc(win, mwin * sizeof(win[0]));
+		}
+		win[nw].n = xwin[i];
+		win[nw].label = estrdup(label);
+		win[nw].dirty = 1;
+		win[nw].r = Rect(0, 0, 0, 0);
+		free(wmname);
+		free(class.res_name);
+		free(class.res_class);
+		nw++;
+	}
+
+	oldxerrorhandler = XSetErrorHandler(winwatchxerrorhandler);
+	XFree(xwin);
+	XFlush(dpy);
+	XSync(dpy, False);
+	XSetErrorHandler(oldxerrorhandler);
+
+	while(nwin>nw)
+		free(win[--nwin].label);
+	nwin = nw;
+
+	if(sortlabels==1)
+		qsort(win, nwin, sizeof(struct Win), winlabelcmp);
+}
+
+void
+drawnowin(int i)
+{
+	Rectangle r;
+
+	r = Rect(0, 0, (Dx(screen->r) - 2 * MARGIN + PAD) / cols - PAD, font->height);
+	r = rectaddpt(
+	        rectaddpt(r,
+	            Pt(MARGIN + (PAD + Dx(r)) * (i / rows),
+ 	                MARGIN + (PAD + Dy(r)) * (i % rows))),
+	        screen->r.min);
+	draw(screen, insetrect(r, -1), lightblue, nil, ZP);
+}
+
+void
+drawwin(int i)
+{
+	draw(screen, win[i].r, lightblue, nil, ZP);
+	_string(screen, addpt(win[i].r.min, Pt(2, 0)), display->black, ZP,
+	    font, win[i].label, nil, strlen(win[i].label),
+	    win[i].r, nil, ZP, SoverD);
+	border(screen, win[i].r, 1, display->black, ZP);
+	win[i].dirty = 0;
+}
+
+int
+geometry(void)
+{
+	int i, ncols, z;
+	Rectangle r;
+
+	z = 0;
+	rows = (Dy(screen->r) - 2 * MARGIN + PAD) / (font->height + PAD);
+	if(rows*cols<nwin || rows*cols>=nwin*2){
+		ncols = 1;
+		if(nwin>0)
+			ncols = (nwin + rows - 1) / rows;
+		if(ncols!=cols){
+			cols = ncols;
+			z = 1;
+		}
+	}
+
+	r = Rect(0, 0, (Dx(screen->r) - 2 * MARGIN + PAD) / cols - PAD, font->height);
+	for(i=0; i<nwin; i++)
+		win[i].r =
+		    rectaddpt(
+		        rectaddpt(r,
+		            Pt(MARGIN + (PAD + Dx(r)) * (i / rows),
+		                MARGIN + (PAD + Dy(r)) * (i % rows))),
+		        screen->r.min);
+
+	return z;
+}
+
+void
+redraw(Image *screen, int all)
+{
+	int i;
+
+	all |= geometry();
+	if(all)
+		draw(screen, screen->r, lightblue, nil, ZP);
+	for(i=0; i<nwin; i++)
+		if(all || win[i].dirty)
+			drawwin(i);
+	if(!all)
+		for (; i<onwin; i++)
+			drawnowin(i);
+	onwin = nwin;
+}
+
+void
+eresized(int new)
+{
+	if(new && getwindow(display, Refmesg)<0)
+		fprint(2, "can't reattach to window");
+	geometry();
+	redraw(screen, 1);
+}
+
+
+void
+selectwin(XWindow win)
+{
+	XEvent ev;
+	long mask;
+
+	memset(&ev, 0, sizeof ev);
+	ev.xclient.type = ClientMessage;
+	ev.xclient.serial = 0;
+	ev.xclient.send_event = True;
+	ev.xclient.message_type = net_active_window;
+	ev.xclient.window = win;
+	ev.xclient.format = 32;
+	mask = SubstructureRedirectMask | SubstructureNotifyMask;
+
+	XSendEvent(dpy, root, False, mask, &ev);
+	XMapRaised(dpy, win);
+	XSync(dpy, False);
+}
+
+void
+click(Mouse m)
+{
+	int i, j;
+
+	if(m.buttons==0 || (m.buttons&~4))
+		return;
+
+	for(i=0; i<nwin; i++)
+		if(ptinrect(m.xy, win[i].r))
+			break;
+	if(i==nwin)
+		return;
+
+	do
+		m = emouse();
+	while(m.buttons==4);
+
+	if(m.buttons!=0){
+		do
+			m = emouse();
+		while(m.buttons);
+		return;
+	}
+	for(j=0; j<nwin; j++)
+		if(ptinrect(m.xy, win[j].r))
+			break;
+	if(j==i)
+		selectwin(win[i].n);
+}
+
+void
+usage(void)
+{
+	fprint(2,
+	    "usage: winwatch [-e exclude] [-W winsize] [-f font] [-n] [-s]\n");
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	char *fontname;
+	int Etimer;
+	Event e;
+
+	sortlabels = 0;
+	showwmnames = 0;
+	fontname = "/lib/font/bit/lucsans/unicode.8.font";
+
+	ARGBEGIN {
+	case 'W':
+		winsize = EARGF(usage());
+		break;
+	case 'f':
+		fontname = EARGF(usage());
+		break;
+	case 'e':
+		exclude = regcomp(EARGF(usage()));
+		if(exclude==nil)
+			sysfatal("Bad regexp");
+		break;
+	case 's':
+		sortlabels = 1;
+		break;
+	case 'n':
+		showwmnames = 1;
+		break;
+	default:
+		usage();
+	} ARGEND;
+
+	if(argc)
+	    usage();
+
+	/* moved up from original winwatch.c for p9p because there can be only one but we want to restart when needed */
+	einit(Emouse | Ekeyboard);
+	Etimer = etimer(0, 1000);
+
+	dpy = XOpenDisplay("");
+	if(dpy==nil)
+		sysfatal("open display: %r");
+
+	root = DefaultRootWindow(dpy);
+	net_active_window = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
+
+	initdraw(0, 0, "winwatch");
+	lightblue = allocimagemix(display, DPalebluegreen, DWhite);
+	if(lightblue==nil)
+		sysfatal("allocimagemix: %r");
+	font = openfont(display, fontname);
+	if(font==nil)
+		sysfatal("font '%s' not found", fontname);
+
+	/* reentry point upon X server errors */
+	setjmp(savebuf);
+
+	refreshwin();
+	redraw(screen, 1);
+	for(;;){
+		switch(eread(Emouse|Ekeyboard|Etimer, &e)){
+		case Ekeyboard:
+			if(e.kbdc==0x7F || e.kbdc=='q')
+				exits(0);
+			break;
+		case Emouse:
+			if(e.mouse.buttons)
+				click(e.mouse);
+			/* fall through  */
+		default:		/* Etimer */
+			refreshwin();
+			redraw(screen, 0);
+			break;
+		}
+	}
+}
diff --git a/src/cmd/rio/xshove.c b/src/cmd/rio/xshove.c
index e235874e..7358987e 100644
--- a/src/cmd/rio/xshove.c
+++ b/src/cmd/rio/xshove.c
@@ -27,6 +27,7 @@ struct Win
 	int y;
 	int dx;
 	int dy;
+	char *idstr;
 	char *class;
 	char *instance;
 	char *name;
@@ -143,6 +144,9 @@ getinfo(void)
 		if(attr.width <= 0 || attr.override_redirect || attr.map_state != IsViewable)
 			continue;
 		ww->xw = xwin[i];
+		char idstr[9];
+		snprint(idstr, sizeof(idstr), "%08x", (uint)ww->xw);
+		ww->idstr = strdup(idstr);
 		ww->x = attr.x;
 		ww->y = attr.y;
 		ww->dx = attr.width;
@@ -196,7 +200,8 @@ shove(char *name, char *geom)
 	for(i=0; i<nw; i++){
 		Win *ww = &w[i];
 		if(ww->instance && strstr(ww->instance, name)
-		   || ww->class && strstr(ww->class, name)){
+		   || ww->class && strstr(ww->class, name)
+		   || ww->idstr && strstr(ww->idstr, name)){
 			int value_mask;
 			XWindowChanges e;
 
diff --git a/src/cmd/tar.c b/src/cmd/tar.c
index 61e9c4a6..6698675e 100644
--- a/src/cmd/tar.c
+++ b/src/cmd/tar.c
@@ -179,7 +179,6 @@ static int
 push(int fd, char *cmd, int input, Pushstate *ps)
 {
 	int nfd, pifds[2];
-	String *s;
 
 	ps->open = 0;
 	ps->fd = fd;
@@ -197,11 +196,7 @@ push(int fd, char *cmd, int input, Pushstate *ps)
 			dup(pifds[Rd], Stdin);
 		close(pifds[input? Rd: Wr]);
 		dup(fd, (input? Stdin: Stdout));
-		s = s_new();
-		if (cmd[0] != '/')
-			s_append(s, "/bin/");
-		s_append(s, cmd);
-		execl(s_to_c(s), cmd, nil);
+		execl(cmd, cmd, nil);
 		sysfatal("can't exec %s: %r", cmd);
 	default:
 		nfd = pifds[input? Rd: Wr];
diff --git a/src/cmd/venti/srv/buildindex.c b/src/cmd/venti/srv/buildindex.c
index faf4b414..540f0fdc 100644
--- a/src/cmd/venti/srv/buildindex.c
+++ b/src/cmd/venti/srv/buildindex.c
@@ -164,7 +164,7 @@ threadmain(int argc, char *argv[])
 	}
 
 	/* wait for arena procs to finish */
-	for(nfinish=0; nfinish<napart; nfinish++)
+	for(; nfinish<napart; nfinish++)
 		recvp(arenadonechan);
 
 	/* tell index procs to finish */
diff --git a/src/lib9/debugmalloc.c b/src/lib9/debugmalloc.c
index 51a2c61f..744af835 100644
--- a/src/lib9/debugmalloc.c
+++ b/src/lib9/debugmalloc.c
@@ -6,7 +6,6 @@
  * The Unix libc routines cannot be trusted to do their own locking.
  * Sad but apparently true.
  */
-static Lock malloclock;
 static int mallocpid;
 
 /*
@@ -112,11 +111,9 @@ p9malloc(ulong n)
 	if(n == 0)
 		n++;
 /*fprint(2, "%s %d malloc\n", argv0, getpid()); */
-	lock(&malloclock);
 	mallocpid = getpid();
 	v = malloc(n+Overhead);
 	v = mark(v, getcallerpc(&n), n, MallocMagic);
-	unlock(&malloclock);
 /*fprint(2, "%s %d donemalloc\n", argv0, getpid()); */
 	return v;
 }
@@ -128,11 +125,9 @@ p9free(void *v)
 		return;
 
 /*fprint(2, "%s %d free\n", argv0, getpid()); */
-	lock(&malloclock);
 	mallocpid = getpid();
 	v = mark(v, getcallerpc(&v), 0, FreeMagic);
 	free(v);
-	unlock(&malloclock);
 /*fprint(2, "%s %d donefree\n", argv0, getpid()); */
 }
 
@@ -142,11 +137,9 @@ p9calloc(ulong a, ulong b)
 	void *v;
 
 /*fprint(2, "%s %d calloc\n", argv0, getpid()); */
-	lock(&malloclock);
 	mallocpid = getpid();
 	v = calloc(a*b+Overhead, 1);
 	v = mark(v, getcallerpc(&a), a*b, CallocMagic);
-	unlock(&malloclock);
 /*fprint(2, "%s %d donecalloc\n", argv0, getpid()); */
 	return v;
 }
@@ -155,12 +148,10 @@ void*
 p9realloc(void *v, ulong n)
 {
 /*fprint(2, "%s %d realloc\n", argv0, getpid()); */
-	lock(&malloclock);
 	mallocpid = getpid();
 	v = mark(v, getcallerpc(&v), 0, CheckMagic);
 	v = realloc(v, n+Overhead);
 	v = mark(v, getcallerpc(&v), n, ReallocMagic);
-	unlock(&malloclock);
 /*fprint(2, "%s %d donerealloc\n", argv0, getpid()); */
 	return v;
 }
diff --git a/src/lib9/fmt/fmt.c b/src/lib9/fmt/fmt.c
index 9c3f45d3..a86482c3 100644
--- a/src/lib9/fmt/fmt.c
+++ b/src/lib9/fmt/fmt.c
@@ -1,102 +1,107 @@
 /* Copyright (c) 2002-2006 Lucent Technologies; see LICENSE */
 #include <stdarg.h>
 #include <string.h>
+#include <stdatomic.h>
 #include "plan9.h"
 #include "fmt.h"
 #include "fmtdef.h"
 
 enum
 {
-	Maxfmt = 64
+	Maxfmt = 128
 };
 
 typedef struct Convfmt Convfmt;
 struct Convfmt
 {
 	int	c;
-	volatile	Fmts	fmt;	/* for spin lock in fmtfmt; avoids race due to write order */
+	Fmts	fmt;
 };
 
 static struct
 {
-	/* lock by calling __fmtlock, __fmtunlock */
-	int	nfmt;
+	/*
+	 * lock updates to fmt by calling __fmtlock, __fmtunlock.
+	 * reads can start at nfmt and work backward without
+	 * further locking. later fmtinstalls take priority over earlier
+	 * ones because of the backwards loop.
+	 * once installed, a format is never overwritten.
+	 */
+	_Atomic int	nfmt;
 	Convfmt	fmt[Maxfmt];
-} fmtalloc;
-
-static Convfmt knownfmt[] = {
-	' ',	__flagfmt,
-	'#',	__flagfmt,
-	'%',	__percentfmt,
-	'\'',	__flagfmt,
-	'+',	__flagfmt,
-	',',	__flagfmt,
-	'-',	__flagfmt,
-	'C',	__runefmt,	/* Plan 9 addition */
-	'E',	__efgfmt,
-#ifndef PLAN9PORT
-	'F',	__efgfmt,	/* ANSI only */
-#endif
-	'G',	__efgfmt,
-#ifndef PLAN9PORT
-	'L',	__flagfmt,	/* ANSI only */
-#endif
-	'S',	__runesfmt,	/* Plan 9 addition */
-	'X',	__ifmt,
-	'b',	__ifmt,		/* Plan 9 addition */
-	'c',	__charfmt,
-	'd',	__ifmt,
-	'e',	__efgfmt,
-	'f',	__efgfmt,
-	'g',	__efgfmt,
-	'h',	__flagfmt,
-#ifndef PLAN9PORT
-	'i',	__ifmt,		/* ANSI only */
-#endif
-	'l',	__flagfmt,
-	'n',	__countfmt,
-	'o',	__ifmt,
-	'p',	__ifmt,
-	'r',	__errfmt,
-	's',	__strfmt,
-#ifdef PLAN9PORT
-	'u',	__flagfmt,
-#else
-	'u',	__ifmt,
-#endif
-	'x',	__ifmt,
-	0,	nil,
+} fmtalloc = {
+	#ifdef PLAN9PORT
+		ATOMIC_VAR_INIT(27),
+	#else
+		ATOMIC_VAR_INIT(30),
+	#endif
+	{
+		{' ',	__flagfmt},
+		{'#',	__flagfmt},
+		{'%',	__percentfmt},
+		{'\'',	__flagfmt},
+		{'+',	__flagfmt},
+		{',',	__flagfmt},
+		{'-',	__flagfmt},
+		{'C',	__runefmt},	/* Plan 9 addition */
+		{'E',	__efgfmt},
+	#ifndef PLAN9PORT
+		{'F',	__efgfmt},	/* ANSI only */
+	#endif
+		{'G',	__efgfmt},
+	#ifndef PLAN9PORT
+		{'L',	__flagfmt},	/* ANSI only */
+	#endif
+		{'S',	__runesfmt},	/* Plan 9 addition */
+		{'X',	__ifmt},
+		{'b',	__ifmt},		/* Plan 9 addition */
+		{'c',	__charfmt},
+		{'d',	__ifmt},
+		{'e',	__efgfmt},
+		{'f',	__efgfmt},
+		{'g',	__efgfmt},
+		{'h',	__flagfmt},
+	#ifndef PLAN9PORT
+		{'i',	__ifmt},		/* ANSI only */
+	#endif
+		{'l',	__flagfmt},
+		{'n',	__countfmt},
+		{'o',	__ifmt},
+		{'p',	__ifmt},
+		{'r',	__errfmt},
+		{'s',	__strfmt},
+	#ifdef PLAN9PORT
+		{'u',	__flagfmt},
+	#else
+		{'u',	__ifmt},
+	#endif
+		{'x',	__ifmt},
+	}
 };
 
-
 int	(*fmtdoquote)(int);
 
 /*
- * __fmtwlock() must be set
+ * __fmtlock() must be set
  */
 static int
 __fmtinstall(int c, Fmts f)
 {
-	Convfmt *p, *ep;
+	Convfmt *p;
+	int i;
 
 	if(c<=0 || c>=65536)
 		return -1;
 	if(!f)
 		f = __badfmt;
 
-	ep = &fmtalloc.fmt[fmtalloc.nfmt];
-	for(p=fmtalloc.fmt; p<ep; p++)
-		if(p->c == c)
-			break;
-
-	if(p == &fmtalloc.fmt[Maxfmt])
+	i = atomic_load(&fmtalloc.nfmt);
+	if(i == Maxfmt)
 		return -1;
-
+	p = &fmtalloc.fmt[i];
+	p->c = c;
 	p->fmt = f;
-	if(p == ep){	/* installing a new format character */
-		fmtalloc.nfmt++;
-		p->c = c;
-	}
+	atomic_store(&fmtalloc.nfmt, i+1);
 
 	return 0;
 }
@@ -106,43 +111,21 @@ fmtinstall(int c, int (*f)(Fmt*))
 {
 	int ret;
 
-	__fmtwlock();
+	__fmtlock();
 	ret = __fmtinstall(c, f);
-	__fmtwunlock();
+	__fmtunlock();
 	return ret;
 }
 
 static Fmts
 fmtfmt(int c)
 {
-	Convfmt *p, *ep, *kp;
-
-	/* conflict-free check - common case */
-	__fmtrlock();
-	ep = &fmtalloc.fmt[fmtalloc.nfmt];
-	for(p=fmtalloc.fmt; p<ep; p++)
-		if(p->c == c){
-			__fmtrunlock();
+	Convfmt *p, *ep;
+
+	ep = &fmtalloc.fmt[atomic_load(&fmtalloc.nfmt)];
+	for(p=ep; p-- > fmtalloc.fmt; )
+		if(p->c == c)
 			return p->fmt;
-		}
-	__fmtrunlock();
-
-	/* is this a predefined format char? */
-	for(kp=knownfmt; kp->c; kp++){
-		if(kp->c == c){
-			__fmtwlock();
-			/* double-check fmtinstall didn't happen */
-			for(p=fmtalloc.fmt; p<ep; p++){
-				if(p->c == c){
-					__fmtwunlock();
-					return p->fmt;
-				}
-			}
-			__fmtinstall(kp->c, kp->fmt);
-			__fmtwunlock();
-			return kp->fmt;
-		}
-	}
 
 	return __badfmt;
 }
diff --git a/src/lib9/fmt/fmtdef.h b/src/lib9/fmt/fmtdef.h
index d547184d..2bafd36d 100644
--- a/src/lib9/fmt/fmtdef.h
+++ b/src/lib9/fmt/fmtdef.h
@@ -36,10 +36,8 @@ void *       __fmtflush(Fmt *f, void *t, int len);
 int          __fmtpad(Fmt *f, int n);
 double       __fmtpow10(int n);
 int          __fmtrcpy(Fmt *f, const void *vm, int n);
-void         __fmtrlock(void);
-void         __fmtrunlock(void);
-void         __fmtwlock(void);
-void         __fmtwunlock(void);
+void         __fmtlock(void);
+void         __fmtunlock(void);
 int          __ifmt(Fmt *f);
 int          __isInf(double d, int sign);
 int          __isNaN(double d);
diff --git a/src/lib9/fmt/fmtlock.c b/src/lib9/fmt/fmtlock.c
index eb9cd845..cabe05f4 100644
--- a/src/lib9/fmt/fmtlock.c
+++ b/src/lib9/fmt/fmtlock.c
@@ -5,21 +5,11 @@
 #include "fmtdef.h"
 
 void
-__fmtrlock(void)
+__fmtlock(void)
 {
 }
 
 void
-__fmtrunlock(void)
-{
-}
-
-void
-__fmtwlock(void)
-{
-}
-
-void
-__fmtwunlock(void)
+__fmtunlock(void)
 {
 }
diff --git a/src/lib9/fmtlock2.c b/src/lib9/fmtlock2.c
index b755daa3..d711e6d4 100644
--- a/src/lib9/fmtlock2.c
+++ b/src/lib9/fmtlock2.c
@@ -1,28 +1,16 @@
 #include <u.h>
 #include <libc.h>
 
-static RWLock fmtlock;
+static Lock fmtlock;
 
 void
-__fmtrlock(void)
+__fmtlock(void)
 {
-	rlock(&fmtlock);
+	lock(&fmtlock);
 }
 
 void
-__fmtrunlock(void)
+__fmtunlock(void)
 {
-	runlock(&fmtlock);
-}
-
-void
-__fmtwlock(void)
-{
-	wlock(&fmtlock);
-}
-
-void
-__fmtwunlock(void)
-{
-	wunlock(&fmtlock);
+	unlock(&fmtlock);
 }
diff --git a/src/lib9/getenv.c b/src/lib9/getenv.c
index 384196cf..5dfc8577 100644
--- a/src/lib9/getenv.c
+++ b/src/lib9/getenv.c
@@ -16,11 +16,5 @@ p9getenv(char *s)
 int
 p9putenv(char *s, char *v)
 {
-	char *t;
-
-	t = smprint("%s=%s", s, v);
-	if(t == nil)
-		return -1;
-	putenv(t);
-	return 0;
+	return setenv(s, v, 1);
 }
diff --git a/src/lib9/malloc.c b/src/lib9/malloc.c
index 33593aa2..695ff8bc 100644
--- a/src/lib9/malloc.c
+++ b/src/lib9/malloc.c
@@ -7,50 +7,31 @@
 #define NOPLAN9DEFINES
 #include <libc.h>
 
-static Lock malloclock;
 
 void*
 p9malloc(ulong n)
 {
-	void *v;
-
 	if(n == 0)
 		n++;
-	lock(&malloclock);
-	v = malloc(n);
-	unlock(&malloclock);
-	return v;
+	return malloc(n);
 }
 
 void
 p9free(void *v)
 {
-	if(v == nil)
-		return;
-	lock(&malloclock);
 	free(v);
-	unlock(&malloclock);
 }
 
 void*
 p9calloc(ulong a, ulong b)
 {
-	void *v;
-
 	if(a*b == 0)
 		a = b = 1;
-
-	lock(&malloclock);
-	v = calloc(a*b, 1);
-	unlock(&malloclock);
-	return v;
+	return calloc(a, b);
 }
 
 void*
 p9realloc(void *v, ulong n)
 {
-	lock(&malloclock);
-	v = realloc(v, n);
-	unlock(&malloclock);
-	return v;
+	return realloc(v, n);
 }
diff --git a/src/libdraw/getsubfont.c b/src/libdraw/getsubfont.c
index ec4ccfe3..1cc234ef 100644
--- a/src/libdraw/getsubfont.c
+++ b/src/libdraw/getsubfont.c
@@ -53,15 +53,25 @@ _getsubfont(Display *d, char *name)
 static int
 defaultpipe(void)
 {
-	int p[2];
+	int p[2], pid;
 
-	// assuming defontdata (<5k) fits in pipe buffer.
-	// especially reasonable since p9pipe is actually
-	// a socket pair.
+	// Used to assume that defontdata (<5k) fit in the
+	// pipe buffer, especially since p9pipe is actually
+	// a socket pair. But OpenBSD in particular saw hangs,
+	// so feed the pipe it the "right" way with a subprocess.
 	if(pipe(p) < 0)
 		return -1;
-	write(p[1], defontdata, sizeof defontdata);
-	close(p[1]);
+	if((pid = fork()) < 0) {
+		close(p[0]);
+		close(p[1]);
+		return -1;
+	}
+	if(pid == 0) {
+		close(p[0]);
+		write(p[1], defontdata, sizeof defontdata);
+		close(p[1]);
+		_exit(0);
+	}
 	return p[0];
 }
 
diff --git a/src/libdraw/mouse.c b/src/libdraw/mouse.c
index 64a7f73d..382efae5 100644
--- a/src/libdraw/mouse.c
+++ b/src/libdraw/mouse.c
@@ -52,8 +52,12 @@ _ioproc(void *arg)
 	one = 1;
 	resized = 0;
 	for(;;){
-		if(_displayrdmouse(mc->display, &m, &resized) < 0)
+		if(_displayrdmouse(mc->display, &m, &resized) < 0) {
+			if(postnote(PNPROC, getpid(), "hangup") < 0)
+				fprint(2, "postnote: %r\n");
+			sleep(10*1000);
 			threadexitsall("mouse read error");
+		}
 		if(resized)
 			send(mc->resizec, &one);
 		send(mc->c, &m);
diff --git a/src/libmach/FreeBSD.c b/src/libmach/FreeBSD.c
index 80c8935a..de8647c6 100644
--- a/src/libmach/FreeBSD.c
+++ b/src/libmach/FreeBSD.c
@@ -30,8 +30,8 @@ struct PtraceRegs
 	int pid;
 };
 
-static int ptracerw(Map*, Seg*, ulong, void*, uint, int);
-static int ptraceregrw(Regs*, char*, ulong*, int);
+static int ptracerw(Map*, Seg*, u64int, void*, uint, int);
+static int ptraceregrw(Regs*, char*, u64int*, int);
 
 void
 unmapproc(Map *map)
@@ -92,7 +92,7 @@ detachproc(int pid)
 }
 
 static int
-ptracerw(Map *map, Seg *seg, ulong addr, void *v, uint n, int isr)
+ptracerw(Map *map, Seg *seg, u64int addr, void *v, uint n, int isr)
 {
 	int i;
 	u32int u;
@@ -167,7 +167,7 @@ reg2freebsd(char *reg)
 }
 
 static int
-ptraceregrw(Regs *regs, char *name, ulong *val, int isr)
+ptraceregrw(Regs *regs, char *name, u64int *val, int isr)
 {
 	int pid;
 	ulong addr;
diff --git a/src/libthread/OpenBSD-386.c b/src/libthread/386-ucontext.c
index 89bfedcd..3afa9513 100644
--- a/src/libthread/OpenBSD-386.c
+++ b/src/libthread/386-ucontext.c
@@ -5,7 +5,7 @@ makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
 {
 	int *sp;
 
-	sp = (int*)ucp->uc_stack.ss_sp+ucp->uc_stack.ss_size/4;
+	sp = USPALIGN(ucp, 4);
 	sp -= argc;
 	memmove(sp, &argc+1, argc*sizeof(int));
 	*--sp = 0;		/* return address */
diff --git a/src/libthread/BSD.c b/src/libthread/BSD.c
deleted file mode 100644
index 737c0a63..00000000
--- a/src/libthread/BSD.c
+++ /dev/null
@@ -1,403 +0,0 @@
-#undef exits
-#undef _exits
-
-extern int __isthreaded;
-
-/*
- * spin locks
- */
-extern int _tas(int*);
-
-void
-_threadunlock(Lock *l, ulong pc)
-{
-	USED(pc);
-
-	l->held = 0;
-}
-
-int
-_threadlock(Lock *l, int block, ulong pc)
-{
-	int i;
-
-	USED(pc);
-
-	/* once fast */
-	if(!_tas(&l->held))
-		return 1;
-	if(!block)
-		return 0;
-
-	/* a thousand times pretty fast */
-	for(i=0; i<1000; i++){
-		if(!_tas(&l->held))
-			return 1;
-		sleep(0);
-	}
-	/* increasingly slow */
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(1);
-	}
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(10);
-	}
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(100);
-	}
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(1000);
-	}
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(10*1000);
-	}
-	/* now nice and slow */
-	for(i=0; i<1000; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(100*1000);
-	}
-	/* take your time */
-	while(_tas(&l->held))
-		usleep(1000*1000);
-	return 1;
-}
-
-/*
- * For libc.
- */
-
-typedef struct {
-	volatile long	access_lock;
-	volatile long	lock_owner;
-	volatile char	*fname;
-	volatile int	lineno;
-} spinlock_t;
-
-void
-_spinlock(spinlock_t *lk)
-{
-	lock((Lock*)&lk->access_lock);
-}
-
-void
-_spinunlock(spinlock_t *lk)
-{
-	unlock((Lock*)&lk->access_lock);
-}
-
-
-
-/*
- * sleep and wakeup
- */
-static void
-ign(int x)
-{
-	USED(x);
-}
-
-static void /*__attribute__((constructor))*/
-ignusr1(int restart)
-{
-	struct sigaction sa;
-
-	memset(&sa, 0, sizeof sa);
-	sa.sa_handler = ign;
-	sigemptyset(&sa.sa_mask);
-	sigaddset(&sa.sa_mask, SIGUSR1);
-	if(restart)
-		sa.sa_flags = SA_RESTART;
-	sigaction(SIGUSR1, &sa, nil);
-}
-
-void
-_procsleep(_Procrendez *r)
-{
-	sigset_t mask;
-
-	/*
-	 * Go to sleep.
-	 *
-	 * Block USR1, set the handler to interrupt system calls,
-	 * unlock the vouslock so our waker can wake us,
-	 * and then suspend.
-	 */
-again:
-	r->asleep = 1;
-	r->pid = getpid();
-
-	sigprocmask(SIG_SETMASK, nil, &mask);
-	sigaddset(&mask, SIGUSR1);
-	sigprocmask(SIG_SETMASK, &mask, nil);
-	ignusr1(0);
-	unlock(r->l);
-	sigdelset(&mask, SIGUSR1);
-	sigsuspend(&mask);
-
-	/*
-	 * We're awake.  Make USR1 not interrupt system calls.
-	 */
-	lock(r->l);
-	ignusr1(1);
-	if(r->asleep && r->pid == getpid()){
-		/* Didn't really wake up - signal from something else */
-		goto again;
-	}
-}
-
-void
-_procwakeup(_Procrendez *r)
-{
-	if(r->asleep){
-		r->asleep = 0;
-		assert(r->pid >= 1);
-		kill(r->pid, SIGUSR1);
-	}
-}
-
-void
-_procwakeupandunlock(_Procrendez *r)
-{
-	_procwakeup(r);
-	unlock(r->l);
-}
-
-
-/*
- * process creation and exit
- */
-typedef struct Stackfree Stackfree;
-struct Stackfree
-{
-	Stackfree	*next;
-	int	pid;
-};
-static Lock stacklock;
-static Stackfree *stackfree;
-
-static void
-delayfreestack(uchar *stk)
-{
-	Stackfree *sf;
-
-	sf = (Stackfree*)stk;
-	sf->pid = getpid();
-	lock(&stacklock);
-	sf->next = stackfree;
-	stackfree = sf;
-	unlock(&stacklock);
-}
-
-static void
-dofreestacks(void)
-{
-	Stackfree *sf, *last, *next;
-
-	if(stackfree==nil || !canlock(&stacklock))
-		return;
-
-	for(last=nil,sf=stackfree; sf; last=sf,sf=next){
-		next = sf->next;
-		if(sf->pid >= 1 && kill(sf->pid, 0) < 0 && errno == ESRCH){
-			free(sf);
-			if(last)
-				last->next = next;
-			else
-				stackfree = next;
-			sf = last;
-		}
-	}
-	unlock(&stacklock);
-}
-
-static int
-startprocfn(void *v)
-{
-	void **a;
-	uchar *stk;
-	void (*fn)(void*);
-	Proc *p;
-
-	a = (void**)v;
-	fn = a[0];
-	p = a[1];
-	stk = a[2];
-	free(a);
-	p->osprocid = getpid();
-
-	(*fn)(p);
-
-	delayfreestack(stk);
-	_exit(0);
-	return 0;
-}
-
-void
-_procstart(Proc *p, void (*fn)(Proc*))
-{
-	void **a;
-	uchar *stk;
-	int pid;
-
-	dofreestacks();
-	a = malloc(3*sizeof a[0]);
-	if(a == nil)
-		sysfatal("_procstart malloc: %r");
-	stk = malloc(65536);
-	if(stk == nil)
-		sysfatal("_procstart malloc stack: %r");
-
-	a[0] = fn;
-	a[1] = p;
-	a[2] = stk;
-
-	pid = rfork_thread(RFPROC|RFMEM|RFNOWAIT, stk+65536-64, startprocfn, a);
-	if(pid < 0){
-		fprint(2, "_procstart rfork_thread: %r\n");
-		abort();
-	}
-}
-
-static char *threadexitsmsg;
-void
-sigusr2handler(int s)
-{
-/*	fprint(2, "%d usr2 %d\n", time(0), getpid()); */
-	if(threadexitsmsg)
-		_exits(threadexitsmsg);
-}
-
-void
-threadexitsall(char *msg)
-{
-	static int pid[1024];
-	int i, npid, mypid;
-	Proc *p;
-
-	if(msg == nil)
-		msg = "";
-
-	/*
-	 * Only one guy, ever, gets to run this.
-	 * If two guys do it, inevitably they end up
-	 * tripping over each other in the underlying
-	 * C library exit() implementation, which is
-	 * trying to run the atexit handlers and apparently
-	 * not thread safe.  This has been observed on
-	 * both Linux and OpenBSD.  Sigh.
-	 */
-	{
-		static Lock onelock;
-		if(!canlock(&onelock))
-			_exits(threadexitsmsg);
-		threadexitsmsg = msg;
-	}
-
-	if(msg == nil)
-		msg = "";
-	mypid = getpid();
-	lock(&_threadprocslock);
-	threadexitsmsg = msg;
-	npid = 0;
-	for(p=_threadprocs; p; p=p->next)
-		if(p->osprocid != mypid && p->osprocid >= 1)
-			pid[npid++] = p->osprocid;
-	for(i=0; i<npid; i++)
-		kill(pid[i], SIGUSR2);
-	unlock(&_threadprocslock);
-	exits(msg);
-}
-
-/*
- * per-process data, indexed by pid
- */
-typedef struct Perproc Perproc;
-struct Perproc
-{
-	int		pid;
-	Proc	*proc;
-};
-
-static Lock perlock;
-static Perproc perproc[1024];
-#define P ((Proc*)-1)
-
-static Perproc*
-myperproc(void)
-{
-	int i, pid, h;
-	Perproc *p;
-
-	pid = getpid();
-	h = pid%nelem(perproc);
-	for(i=0; i<nelem(perproc); i++){
-		p = &perproc[(i+h)%nelem(perproc)];
-		if(p->pid == pid)
-			return p;
-		if(p->pid == 0){
-			print("found 0 at %d (h=%d)\n", (i+h)%nelem(perproc), h);
-			break;
-		}
-	}
-	fprint(2, "myperproc %d: cannot find self\n", pid);
-	abort();
-	return nil;
-}
-
-static Perproc*
-newperproc(void)
-{
-	int i, pid, h;
-	Perproc *p;
-
-	lock(&perlock);
-	pid = getpid();
-	h = pid%nelem(perproc);
-	for(i=0; i<nelem(perproc); i++){
-		p = &perproc[(i+h)%nelem(perproc)];
-		if(p->pid == pid || p->pid == -1 || p->pid == 0){
-			p->pid = pid;
-			unlock(&perlock);
-			return p;
-		}
-	}
-	fprint(2, "newperproc %d: out of procs\n", pid);
-	abort();
-	return nil;
-}
-
-Proc*
-_threadproc(void)
-{
-	return myperproc()->proc;
-}
-
-void
-_threadsetproc(Proc *p)
-{
-	Perproc *pp;
-
-	if(p)
-		p->osprocid = getpid();
-	pp = newperproc();
-	pp->proc = p;
-	if(p == nil)
-		pp->pid = -1;
-}
-
-void
-_threadpexit(void)
-{
-	_exit(0);
-}
diff --git a/src/libthread/COPYRIGHT b/src/libthread/COPYRIGHT
index f4ee354e..d0820965 100644
--- a/src/libthread/COPYRIGHT
+++ b/src/libthread/COPYRIGHT
@@ -45,9 +45,9 @@ Contains parts of an earlier library that has:
 
 ===
 
-The above notices do *NOT* apply to Linux-sparc64-context.S 
-or to Linux-sparc64-swapcontext.c.  Those are functions from 
+The above notices do *NOT* apply to Linux-sparc64-context.S
+or to sparc64-ucontext.c.  Those are functions from
 the GNU C library and are provided for systems that use the GNU C
-library but somehow are missing those functions.  They are 
+library but somehow are missing those functions.  They are
 distributed under the Lesser GPL; see COPYING.SPARC64-CONTEXT.
 
diff --git a/src/libthread/Darwin-386-asm.s b/src/libthread/Darwin-386-asm.s
deleted file mode 100644
index 46c96e94..00000000
--- a/src/libthread/Darwin-386-asm.s
+++ /dev/null
@@ -1,52 +0,0 @@
-.globl _tas
-_tas:
-	movl $0xCAFEBABE, %eax
-	movl 4(%esp), %ecx
-	xchgl %eax, 0(%ecx)
-	ret
-
-.globl _getmcontext
-_getmcontext:
-	movl	4(%esp), %eax
-
-	movl	%fs, 8(%eax)
-	movl	%es, 12(%eax)
-	movl	%ds, 16(%eax)
-	movl	%ss, 76(%eax)
-	movl	%edi, 20(%eax)
-	movl	%esi, 24(%eax)
-	movl	%ebp, 28(%eax)
-	movl	%ebx, 36(%eax)
-	movl	%edx, 40(%eax)		 
-	movl	%ecx, 44(%eax)
-
-	movl	$1, 48(%eax)	/* %eax */
-	movl	(%esp), %ecx	/* %eip */
-	movl	%ecx, 60(%eax)
-	leal	4(%esp), %ecx	/* %esp */
-	movl	%ecx, 72(%eax)
-
-	movl	44(%eax), %ecx	/* restore %ecx */
-	movl	$0, %eax
-	ret
-
-.globl _setmcontext
-_setmcontext:
-	movl	4(%esp), %eax
-
-	movl	8(%eax), %fs
-	movl	12(%eax), %es
-	movl	16(%eax), %ds
-	movl	76(%eax), %ss
-	movl	20(%eax), %edi
-	movl	24(%eax), %esi
-	movl	28(%eax), %ebp
-	movl	36(%eax), %ebx
-	movl	40(%eax), %edx
-	movl	44(%eax), %ecx
-
-	movl	72(%eax), %esp
-	pushl	60(%eax)	/* new %eip */
-	movl	48(%eax), %eax
-	ret
-
diff --git a/src/libthread/Darwin-386.c b/src/libthread/Darwin-386.c
deleted file mode 100644
index b138e420..00000000
--- a/src/libthread/Darwin-386.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "threadimpl.h"
-
-void
-makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
-{
-	int *sp;
-
-	sp = (int*)ucp->uc_stack.ss_sp+ucp->uc_stack.ss_size/4;
-	sp -= argc;
-	/*
-	 * Stack pointer at call instruction (before return address
-	 * gets pushed) must be 16-byte aligned.
-	 */
-	if((uintptr)sp%4)
-		abort();
-	while((uintptr)sp%16)
-		sp--;
-	memmove(sp, &argc+1, argc*sizeof(int));
-	*--sp = 0;		/* return address */
-	ucp->uc_mcontext.mc_eip = (long)func;
-	ucp->uc_mcontext.mc_esp = (int)sp;
-}
-
-int
-swapcontext(ucontext_t *oucp, ucontext_t *ucp)
-{
-	if(getcontext(oucp) == 0)
-		setcontext(ucp);
-	return 0;
-}
diff --git a/src/libthread/Darwin-power-asm.s b/src/libthread/Darwin-power-asm.s
deleted file mode 100644
index a064b5ea..00000000
--- a/src/libthread/Darwin-power-asm.s
+++ /dev/null
@@ -1,83 +0,0 @@
-/* get FPR and VR use flags with sc 0x7FF3 */
-/* get vsave with mfspr reg, 256 */
-
-.text
-.align 2
-
-.globl	__getmcontext
-
-__getmcontext:				/* xxx: instruction scheduling */
-	mflr	r0
-	mfcr	r5
-	mfctr	r6
-	mfxer	r7
-	stw	r0, 0*4(r3)
-	stw	r5, 1*4(r3)
-	stw	r6, 2*4(r3)
-	stw	r7, 3*4(r3)
-
-	stw	r1, 4*4(r3)
-	stw	r2, 5*4(r3)
-	li	r5, 1			/* return value for setmcontext */
-	stw	r5, 6*4(r3)
-
-	stw	r13, (0+7)*4(r3)	/* callee-save GPRs */
-	stw	r14, (1+7)*4(r3)	/* xxx: block move */
-	stw	r15, (2+7)*4(r3)
-	stw	r16, (3+7)*4(r3)
-	stw	r17, (4+7)*4(r3)
-	stw	r18, (5+7)*4(r3)
-	stw	r19, (6+7)*4(r3)
-	stw	r20, (7+7)*4(r3)
-	stw	r21, (8+7)*4(r3)
-	stw	r22, (9+7)*4(r3)
-	stw	r23, (10+7)*4(r3)
-	stw	r24, (11+7)*4(r3)
-	stw	r25, (12+7)*4(r3)
-	stw	r26, (13+7)*4(r3)
-	stw	r27, (14+7)*4(r3)
-	stw	r28, (15+7)*4(r3)
-	stw	r29, (16+7)*4(r3)
-	stw	r30, (17+7)*4(r3)
-	stw	r31, (18+7)*4(r3)
-
-	li	r3, 0			/* return */
-	blr
-
-.globl	__setmcontext
-
-__setmcontext:
-	lwz	r13, (0+7)*4(r3)	/* callee-save GPRs */
-	lwz	r14, (1+7)*4(r3)	/* xxx: block move */
-	lwz	r15, (2+7)*4(r3)
-	lwz	r16, (3+7)*4(r3)
-	lwz	r17, (4+7)*4(r3)
-	lwz	r18, (5+7)*4(r3)
-	lwz	r19, (6+7)*4(r3)
-	lwz	r20, (7+7)*4(r3)
-	lwz	r21, (8+7)*4(r3)
-	lwz	r22, (9+7)*4(r3)
-	lwz	r23, (10+7)*4(r3)
-	lwz	r24, (11+7)*4(r3)
-	lwz	r25, (12+7)*4(r3)
-	lwz	r26, (13+7)*4(r3)
-	lwz	r27, (14+7)*4(r3)
-	lwz	r28, (15+7)*4(r3)
-	lwz	r29, (16+7)*4(r3)
-	lwz	r30, (17+7)*4(r3)
-	lwz	r31, (18+7)*4(r3)
-
-	lwz	r1, 4*4(r3)
-	lwz	r2, 5*4(r3)
-
-	lwz	r0, 0*4(r3)
-	mtlr	r0
-	lwz	r0, 1*4(r3)
-	mtcr	r0			/* mtcrf 0xFF, r0 */
-	lwz	r0, 2*4(r3)
-	mtctr	r0
-	lwz	r0, 3*4(r3)
-	mtxer	r0
-
-	lwz	r3,	6*4(r3)
-	blr
diff --git a/src/libthread/Darwin-x86_64-swapcontext.c b/src/libthread/Darwin-x86_64-swapcontext.c
deleted file mode 100644
index 27931456..00000000
--- a/src/libthread/Darwin-x86_64-swapcontext.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "threadimpl.h"
-
-void
-makecontext(ucontext_t *uc, void (*fn)(void), int argc, ...)
-{
-	uintptr *sp;
-	va_list arg;
-
-//fprint(2, "makecontext %d\n", argc);
-	if(argc != 2)
-		sysfatal("libthread: makecontext misused");
-	va_start(arg, argc);
-	uc->mc.di = va_arg(arg, uint);
-	uc->mc.si = va_arg(arg, uint);
-//fprint(2, "%ux %ux\n", uc->mc.di, uc->mc.si);
-	va_end(arg);
-
-	sp = (uintptr*)((char*)uc->uc_stack.ss_sp+uc->uc_stack.ss_size);
-	*--sp = 0;  // fn's return address
-	*--sp = (uintptr)fn;  // return address of setcontext
-	uc->mc.sp = (uintptr)sp;
-}
-
-int
-swapcontext(ucontext_t *oucp, ucontext_t *ucp)
-{
-	if(getcontext(oucp) == 0)
-		setcontext(ucp);
-	return 0;
-}
diff --git a/src/libthread/FreeBSD-386-asm.s b/src/libthread/FreeBSD-386-asm.s
deleted file mode 100644
index 42169853..00000000
--- a/src/libthread/FreeBSD-386-asm.s
+++ /dev/null
@@ -1,52 +0,0 @@
-.globl _tas
-_tas:
-	movl $0xCAFEBABE, %eax
-	movl 4(%esp), %ecx
-	xchgl %eax, 0(%ecx)
-	ret
-
-.globl getmcontext
-getmcontext:
-	movl	4(%esp), %eax
-
-	movl	%fs, 8(%eax)
-	movl	%es, 12(%eax)
-	movl	%ds, 16(%eax)
-	movl	%ss, 76(%eax)
-	movl	%edi, 20(%eax)
-	movl	%esi, 24(%eax)
-	movl	%ebp, 28(%eax)
-	movl	%ebx, 36(%eax)
-	movl	%edx, 40(%eax)		 
-	movl	%ecx, 44(%eax)
-
-	movl	$1, 48(%eax)	/* %eax */
-	movl	(%esp), %ecx	/* %eip */
-	movl	%ecx, 60(%eax)
-	leal	4(%esp), %ecx	/* %esp */
-	movl	%ecx, 72(%eax)
-
-	movl	44(%eax), %ecx	/* restore %ecx */
-	movl	$0, %eax
-	ret
-
-.globl setmcontext
-setmcontext:
-	movl	4(%esp), %eax
-
-	movl	8(%eax), %fs
-	movl	12(%eax), %es
-	movl	16(%eax), %ds
-	movl	76(%eax), %ss
-	movl	20(%eax), %edi
-	movl	24(%eax), %esi
-	movl	28(%eax), %ebp
-	movl	36(%eax), %ebx
-	movl	40(%eax), %edx
-	movl	44(%eax), %ecx
-
-	movl	72(%eax), %esp
-	pushl	60(%eax)	/* new %eip */
-	movl	48(%eax), %eax
-	ret
-
diff --git a/src/libthread/FreeBSD.c b/src/libthread/FreeBSD.c
deleted file mode 100644
index 5c282465..00000000
--- a/src/libthread/FreeBSD.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "threadimpl.h"
-
-#include "BSD.c"
-
-/*
- * FreeBSD 4 and earlier needs the context functions.
- */
-void
-makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
-{
-	int *sp;
-
-	sp = (int*)ucp->uc_stack.ss_sp+ucp->uc_stack.ss_size/4;
-	sp -= argc;
-	memmove(sp, &argc+1, argc*sizeof(int));
-	*--sp = 0;		/* return address */
-	ucp->uc_mcontext.mc_eip = (long)func;
-	ucp->uc_mcontext.mc_esp = (int)sp;
-}
-
-int
-swapcontext(ucontext_t *oucp, ucontext_t *ucp)
-{
-	if(getcontext(oucp) == 0)
-		setcontext(ucp);
-	return 0;
-}
-
-void
-_pthreadinit(void)
-{
-	__isthreaded = 1;
-	signal(SIGUSR2, sigusr2handler);
-}
diff --git a/src/libthread/Linux-386-asm.s b/src/libthread/Linux-386-asm.s
deleted file mode 100644
index 197f12b5..00000000
--- a/src/libthread/Linux-386-asm.s
+++ /dev/null
@@ -1,7 +0,0 @@
-.globl _tas
-_tas:
-	movl $0xCAFEBABE, %eax
-	movl 4(%esp), %ecx
-	xchgl %eax, 0(%ecx)
-	ret
-
diff --git a/src/libthread/Linux-arm-asm.s b/src/libthread/Linux-arm-asm.s
index 5a285bf2..9bd54f8a 100644
--- a/src/libthread/Linux-arm-asm.s
+++ b/src/libthread/Linux-arm-asm.s
@@ -1,16 +1,5 @@
- 
-.globl _tas
-_tas:
-	mov	r3, #0xCA000000
-	add	r3, r3, #0xFE0000
-	add	r3, r3, #0xBA00
-	add	r3, r3, #0xBE
-	swp	r3, r3, [r0]
-	mov	r0, r3
-	mov	pc, lr
-
-.globl getmcontext
-getmcontext:
+.globl mygetmcontext
+mygetmcontext:
 	str	r1, [r0,#4]
 	str	r2, [r0,#8]
 	str	r3, [r0,#12]
@@ -32,8 +21,8 @@ getmcontext:
 	mov	r0, #0
 	mov	pc, lr
 
-.globl setmcontext
-setmcontext:
+.globl mysetmcontext
+mysetmcontext:
 	ldr	r1, [r0,#4]
 	ldr	r2, [r0,#8]
 	ldr	r3, [r0,#12]
@@ -50,4 +39,3 @@ setmcontext:
 	ldr	r14, [r0,#56]
 	ldr	r0, [r0]
 	mov	pc, lr
-
diff --git a/src/libthread/Linux-arm-context.s b/src/libthread/Linux-arm-context.s
deleted file mode 100644
index 9bd54f8a..00000000
--- a/src/libthread/Linux-arm-context.s
+++ /dev/null
@@ -1,41 +0,0 @@
-.globl mygetmcontext
-mygetmcontext:
-	str	r1, [r0,#4]
-	str	r2, [r0,#8]
-	str	r3, [r0,#12]
-	str	r4, [r0,#16]
-	str	r5, [r0,#20]
-	str	r6, [r0,#24]
-	str	r7, [r0,#28]
-	str	r8, [r0,#32]
-	str	r9, [r0,#36]
-	str	r10, [r0,#40]
-	str	r11, [r0,#44]
-	str	r12, [r0,#48]
-	str	r13, [r0,#52]
-	str	r14, [r0,#56]
-	/* store 1 as r0-to-restore */
-	mov	r1, #1
-	str	r1, [r0]
-	/* return 0 */
-	mov	r0, #0
-	mov	pc, lr
-
-.globl mysetmcontext
-mysetmcontext:
-	ldr	r1, [r0,#4]
-	ldr	r2, [r0,#8]
-	ldr	r3, [r0,#12]
-	ldr	r4, [r0,#16]
-	ldr	r5, [r0,#20]
-	ldr	r6, [r0,#24]
-	ldr	r7, [r0,#28]
-	ldr	r8, [r0,#32]
-	ldr	r9, [r0,#36]
-	ldr	r10, [r0,#40]
-	ldr	r11, [r0,#44]
-	ldr	r12, [r0,#48]
-	ldr	r13, [r0,#52]
-	ldr	r14, [r0,#56]
-	ldr	r0, [r0]
-	mov	pc, lr
diff --git a/src/libthread/Linux-power-asm.s b/src/libthread/Linux-power-asm.s
deleted file mode 100644
index d6e21c15..00000000
--- a/src/libthread/Linux-power-asm.s
+++ /dev/null
@@ -1,16 +0,0 @@
-	.globl	_tas
-_tas:
-	li	%r0, 0
-	mr	%r4, %r3
-	lis	%r5, 0xcafe
-	ori	%r5, %r5, 0xbabe
-1:
-	lwarx	%r3, %r0, %r4
-	cmpwi	%r3, 0
-	bne	2f
-	stwcx.	%r5, %r0, %r4
-	bne-	1b
-2:
-	sync
-	blr
-
diff --git a/src/libthread/Linux-sparc64-asm.s b/src/libthread/Linux-sparc64-asm.s
deleted file mode 100644
index 422a1b24..00000000
--- a/src/libthread/Linux-sparc64-asm.s
+++ /dev/null
@@ -1,16 +0,0 @@
-! Actually sparc32 assembly. 
-! Debian's sparc64 port is a 32-bit user space.
-
-	.section	".text", #alloc, #execinstr
-	.align		8
-	.skip		16
-	.global _tas
-!	.type	_tas,2
-_tas:
-	or	%g0,1,%o1
-	swap	[%o0],%o1	! o0 points to lock; key is first word
-	retl
-	mov	%o1, %o0
-
-   	.size	_tas,(.-_tas)
-
diff --git a/src/libthread/Linux.c b/src/libthread/Linux.c
deleted file mode 100644
index 31577e87..00000000
--- a/src/libthread/Linux.c
+++ /dev/null
@@ -1,462 +0,0 @@
-#include "threadimpl.h"
-
-#undef exits
-#undef _exits
-
-static int
-timefmt(Fmt *fmt)
-{
-	static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-	vlong ns;
-	Tm tm;
-	ns = nsec();
-	tm = *localtime(time(0));
-	return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
-		mon[tm.mon], tm.mday, tm.hour, tm.min, tm.sec,
-		(int)(ns%1000000000)/1000000);
-}
-
-/*
- * spin locks
- */
-extern int _tas(int*);
-
-void
-_threadunlock(Lock *l, ulong pc)
-{
-	USED(pc);
-
-	l->held = 0;
-}
-
-int
-_threadlock(Lock *l, int block, ulong pc)
-{
-	int i;
-static int first=1;
-if(first) {first=0; fmtinstall('\001', timefmt);}
-
-	USED(pc);
-
-	/* once fast */
-	if(!_tas(&l->held))
-		return 1;
-	if(!block)
-		return 0;
-
-	/* a thousand times pretty fast */
-	for(i=0; i<1000; i++){
-		if(!_tas(&l->held))
-			return 1;
-		sched_yield();
-	}
-	/* now increasingly slow */
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(1);
-	}
-fprint(2, "%\001 %s: lock loop1 %p from %lux\n", argv0, l, pc);
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(10);
-	}
-fprint(2, "%\001 %s: lock loop2 %p from %lux\n", argv0, l, pc);
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(100);
-	}
-fprint(2, "%\001 %s: lock loop3 %p from %lux\n", argv0, l, pc);
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(1000);
-	}
-fprint(2, "%\001 %s: lock loop4 %p from %lux\n", argv0, l, pc);
-	for(i=0; i<10; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(10*1000);
-	}
-fprint(2, "%\001 %s: lock loop5 %p from %lux\n", argv0, l, pc);
-	for(i=0; i<1000; i++){
-		if(!_tas(&l->held))
-			return 1;
-		usleep(100*1000);
-	}
-fprint(2, "%\001 %s: lock loop6 %p from %lux\n", argv0, l, pc);
-	/* take your time */
-	while(_tas(&l->held))
-		usleep(1000*1000);
-	return 1;
-}
-
-/*
- * sleep and wakeup
- */
-static void
-ign(int x)
-{
-	USED(x);
-}
-
-static void /*__attribute__((constructor))*/
-ignusr1(int restart)
-{
-	struct sigaction sa;
-
-	memset(&sa, 0, sizeof sa);
-	sa.sa_handler = ign;
-	sigemptyset(&sa.sa_mask);
-	sigaddset(&sa.sa_mask, SIGUSR1);
-	if(restart)
-		sa.sa_flags = SA_RESTART;
-	sigaction(SIGUSR1, &sa, nil);
-}
-
-void
-_procsleep(_Procrendez *r)
-{
-	sigset_t mask;
-
-	/*
-	 * Go to sleep.
-	 *
-	 * Block USR1, set the handler to interrupt system calls,
-	 * unlock the vouslock so our waker can wake us,
-	 * and then suspend.
-	 */
-again:
-	r->asleep = 1;
-	r->pid = getpid();
-
-	sigprocmask(SIG_SETMASK, nil, &mask);
-	sigaddset(&mask, SIGUSR1);
-	sigprocmask(SIG_SETMASK, &mask, nil);
-	ignusr1(0);
-	unlock(r->l);
-	sigdelset(&mask, SIGUSR1);
-	sigsuspend(&mask);
-
-	/*
-	 * We're awake.  Make USR1 not interrupt system calls.
-	 */
-	lock(r->l);
-	ignusr1(1);
-	if(r->asleep && r->pid == getpid()){
-		/* Didn't really wake up - signal from something else */
-		goto again;
-	}
-}
-
-void
-_procwakeupandunlock(_Procrendez *r)
-{
-	int pid;
-
-	pid = 0;
-	if(r->asleep){
-		r->asleep = 0;
-		assert(r->pid >= 1);
-		pid = r->pid;
-	}
-	assert(r->l);
-	unlock(r->l);
-	if(pid)
-		kill(pid, SIGUSR1);
-}
-
-/*
- * process creation and exit
- */
-typedef struct Stackfree Stackfree;
-struct Stackfree
-{
-	Stackfree	*next;
-	int	pid;
-	int	pid1;
-};
-static Lock stacklock;
-static Stackfree *stackfree;
-
-static void
-delayfreestack(uchar *stk, int pid, int pid1)
-{
-	Stackfree *sf;
-
-	sf = (Stackfree*)stk;
-	sf->pid = pid;
-	sf->pid1 = pid1;
-	lock(&stacklock);
-	sf->next = stackfree;
-	stackfree = sf;
-	unlock(&stacklock);
-}
-
-static void
-dofreestacks(void)
-{
-	Stackfree *sf, *last, *next;
-
-	if(stackfree==nil || !canlock(&stacklock))
-		return;
-
-	for(last=nil,sf=stackfree; sf; last=sf,sf=next){
-		next = sf->next;
-		if(sf->pid >= 1 && kill(sf->pid, 0) < 0 && errno == ESRCH)
-		if(sf->pid1 >= 1 && kill(sf->pid1, 0) < 0 && errno == ESRCH){
-			free(sf);
-			if(last)
-				last->next = next;
-			else
-				stackfree = next;
-			sf = last;
-		}
-	}
-	unlock(&stacklock);
-}
-
-static int
-startprocfn(void *v)
-{
-	void **a;
-	uchar *stk;
-	void (*fn)(void*);
-	Proc *p;
-	int pid0, pid1;
-
-	a = (void**)v;
-	fn = a[0];
-	p = a[1];
-	stk = a[2];
-	pid0 = (int)a[4];
-	pid1 = getpid();
-	free(a);
-	p->osprocid = pid1;
-
-	(*fn)(p);
-
-	delayfreestack(stk, pid0, pid1);
-	_exit(0);
-	return 0;
-}
-
-/*
- * indirect through here so that parent need not wait for child zombie
- *
- * slight race - if child exits and then another process starts before we
- * manage to exit, we'll be running on a freed stack.
- */
-static int
-trampnowait(void *v)
-{
-	void **a;
-	int *kidpid;
-
-	a = (void*)v;
-	kidpid = a[3];
-	a[4] = (void*)getpid();
-	*kidpid = clone(startprocfn, a[2]+65536-512, CLONE_VM|CLONE_FILES, a);
-	_exit(0);
-	return 0;
-}
-
-void
-_procstart(Proc *p, void (*fn)(Proc*))
-{
-	void **a;
-	uchar *stk;
-	int pid, kidpid, status;
-
-	dofreestacks();
-	a = malloc(5*sizeof a[0]);
-	if(a == nil)
-		sysfatal("_procstart malloc: %r");
-	stk = malloc(65536);
-	if(stk == nil)
-		sysfatal("_procstart malloc stack: %r");
-
-	a[0] = fn;
-	a[1] = p;
-	a[2] = stk;
-	a[3] = &kidpid;
-	kidpid = -1;
-
-	pid = clone(trampnowait, stk+65536-16, CLONE_VM|CLONE_FILES, a);
-	if(pid > 0)
-		if(wait4(pid, &status, __WALL, 0) < 0)
-			fprint(2, "ffork wait4: %r\n");
-	if(pid < 0 || kidpid < 0){
-		fprint(2, "_procstart clone: %r\n");
-		abort();
-	}
-}
-
-static char *threadexitsmsg;
-void
-sigusr2handler(int s)
-{
-/*	fprint(2, "%d usr2 %d\n", time(0), getpid()); */
-	if(threadexitsmsg)
-		_exits(threadexitsmsg);
-}
-
-void
-threadexitsall(char *msg)
-{
-	static int pid[1024];
-	int i, npid, mypid;
-	Proc *p;
-
-	if(msg == nil)
-		msg = "";
-
-	/*
-	 * Only one guy, ever, gets to run this.
-	 * If two guys do it, inevitably they end up
-	 * tripping over each other in the underlying
-	 * C library exit() implementation, which is
-	 * trying to run the atexit handlers and apparently
-	 * not thread safe.  This has been observed on
-	 * both Linux and OpenBSD.  Sigh.
-	 */
-	{
-		static Lock onelock;
-		if(!canlock(&onelock))
-			_exits(threadexitsmsg);
-		threadexitsmsg = msg;
-	}
-
-	mypid = getpid();
-	lock(&_threadprocslock);
-	npid = 0;
-	for(p=_threadprocs; p; p=p->next)
-		if(p->osprocid != mypid && p->osprocid >= 1)
-			pid[npid++] = p->osprocid;
-	for(i=0; i<npid; i++)
-		kill(pid[i], SIGUSR2);
-	unlock(&_threadprocslock);
-	exits(msg);
-}
-
-/*
- * per-process data, indexed by pid
- *
- * could use modify_ldt and a segment register
- * to avoid the many calls to getpid(), but i don't
- * care -- this is compatibility code.  linux 2.6 with
- * nptl is a good enough pthreads to avoid this whole file.
- */
-typedef struct Perproc Perproc;
-struct Perproc
-{
-	int		pid;
-	Proc	*proc;
-};
-
-static Lock perlock;
-static Perproc perproc[1024];
-#define P ((Proc*)-1)
-
-static Perproc*
-myperproc(void)
-{
-	int i, pid, h;
-	Perproc *p;
-
-	pid = getpid();
-	h = pid%nelem(perproc);
-	for(i=0; i<nelem(perproc); i++){
-		p = &perproc[(i+h)%nelem(perproc)];
-		if(p->pid == pid)
-			return p;
-		if(p->pid == 0){
-			print("found 0 at %d (h=%d)\n", (i+h)%nelem(perproc), h);
-			break;
-		}
-	}
-	fprint(2, "myperproc %d (%s): cannot find self\n", pid, argv0);
-	abort();
-	return nil;
-}
-
-static Perproc*
-newperproc(void)
-{
-	int i, pid, h;
-	Perproc *p;
-
-	lock(&perlock);
-	pid = getpid();
-	h = pid%nelem(perproc);
-	for(i=0; i<nelem(perproc); i++){
-		p = &perproc[(i+h)%nelem(perproc)];
-		if(p->pid == pid || p->pid == -1 || p->pid == 0){
-			p->pid = pid;
-			unlock(&perlock);
-			return p;
-		}
-	}
-	fprint(2, "newperproc %d: out of procs\n", pid);
-	abort();
-	return nil;
-}
-
-Proc*
-_threadproc(void)
-{
-	return myperproc()->proc;
-}
-
-void
-_threadsetproc(Proc *p)
-{
-	Perproc *pp;
-
-	if(p)
-		p->osprocid = getpid();
-	pp = newperproc();
-	pp->proc = p;
-	if(p == nil)
-		pp->pid = -1;
-}
-
-void
-_pthreadinit(void)
-{
-	signal(SIGUSR2, sigusr2handler);
-}
-
-void
-_threadpexit(void)
-{
-	_exit(0);
-}
-
-#ifdef __arm__
-void
-makecontext(ucontext_t *uc, void (*fn)(void), int argc, ...)
-{
-	int i, *sp;
-	va_list arg;
-
-	sp = (int*)uc->uc_stack.ss_sp+uc->uc_stack.ss_size/4;
-	va_start(arg, argc);
-	for(i=0; i<4 && i<argc; i++)
-		uc->uc_mcontext.gregs[i] = va_arg(arg, uint);
-	va_end(arg);
-	uc->uc_mcontext.gregs[13] = (uint)sp;
-	uc->uc_mcontext.gregs[14] = (uint)fn;
-}
-
-int
-swapcontext(ucontext_t *oucp, const ucontext_t *ucp)
-{
-	if(getcontext(oucp) == 0)
-		setcontext(ucp);
-	return 0;
-}
-#endif
diff --git a/src/libthread/NetBSD.c b/src/libthread/NetBSD.c
index 37dabe9c..2b14146b 100644
--- a/src/libthread/NetBSD.c
+++ b/src/libthread/NetBSD.c
@@ -1 +1,437 @@
-#include "Linux.c"
+#include "threadimpl.h"
+
+#undef exits
+#undef _exits
+
+static int
+timefmt(Fmt *fmt)
+{
+	static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+	vlong ns;
+	Tm tm;
+	ns = nsec();
+	tm = *localtime(time(0));
+	return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
+		mon[tm.mon], tm.mday, tm.hour, tm.min, tm.sec,
+		(int)(ns%1000000000)/1000000);
+}
+
+/*
+ * spin locks
+ */
+extern int _tas(int*);
+
+void
+_threadunlock(Lock *l, ulong pc)
+{
+	USED(pc);
+
+	l->held = 0;
+}
+
+int
+_threadlock(Lock *l, int block, ulong pc)
+{
+	int i;
+static int first=1;
+if(first) {first=0; fmtinstall('\001', timefmt);}
+
+	USED(pc);
+
+	/* once fast */
+	if(!_tas(&l->held))
+		return 1;
+	if(!block)
+		return 0;
+
+	/* a thousand times pretty fast */
+	for(i=0; i<1000; i++){
+		if(!_tas(&l->held))
+			return 1;
+		sched_yield();
+	}
+	/* now increasingly slow */
+	for(i=0; i<10; i++){
+		if(!_tas(&l->held))
+			return 1;
+		usleep(1);
+	}
+fprint(2, "%\001 %s: lock loop1 %p from %lux\n", argv0, l, pc);
+	for(i=0; i<10; i++){
+		if(!_tas(&l->held))
+			return 1;
+		usleep(10);
+	}
+fprint(2, "%\001 %s: lock loop2 %p from %lux\n", argv0, l, pc);
+	for(i=0; i<10; i++){
+		if(!_tas(&l->held))
+			return 1;
+		usleep(100);
+	}
+fprint(2, "%\001 %s: lock loop3 %p from %lux\n", argv0, l, pc);
+	for(i=0; i<10; i++){
+		if(!_tas(&l->held))
+			return 1;
+		usleep(1000);
+	}
+fprint(2, "%\001 %s: lock loop4 %p from %lux\n", argv0, l, pc);
+	for(i=0; i<10; i++){
+		if(!_tas(&l->held))
+			return 1;
+		usleep(10*1000);
+	}
+fprint(2, "%\001 %s: lock loop5 %p from %lux\n", argv0, l, pc);
+	for(i=0; i<1000; i++){
+		if(!_tas(&l->held))
+			return 1;
+		usleep(100*1000);
+	}
+fprint(2, "%\001 %s: lock loop6 %p from %lux\n", argv0, l, pc);
+	/* take your time */
+	while(_tas(&l->held))
+		usleep(1000*1000);
+	return 1;
+}
+
+/*
+ * sleep and wakeup
+ */
+static void
+ign(int x)
+{
+	USED(x);
+}
+
+static void /*__attribute__((constructor))*/
+ignusr1(int restart)
+{
+	struct sigaction sa;
+
+	memset(&sa, 0, sizeof sa);
+	sa.sa_handler = ign;
+	sigemptyset(&sa.sa_mask);
+	sigaddset(&sa.sa_mask, SIGUSR1);
+	if(restart)
+		sa.sa_flags = SA_RESTART;
+	sigaction(SIGUSR1, &sa, nil);
+}
+
+void
+_procsleep(_Procrendez *r)
+{
+	sigset_t mask;
+
+	/*
+	 * Go to sleep.
+	 *
+	 * Block USR1, set the handler to interrupt system calls,
+	 * unlock the vouslock so our waker can wake us,
+	 * and then suspend.
+	 */
+again:
+	r->asleep = 1;
+	r->pid = getpid();
+
+	sigprocmask(SIG_SETMASK, nil, &mask);
+	sigaddset(&mask, SIGUSR1);
+	sigprocmask(SIG_SETMASK, &mask, nil);
+	ignusr1(0);
+	unlock(r->l);
+	sigdelset(&mask, SIGUSR1);
+	sigsuspend(&mask);
+
+	/*
+	 * We're awake.  Make USR1 not interrupt system calls.
+	 */
+	lock(r->l);
+	ignusr1(1);
+	if(r->asleep && r->pid == getpid()){
+		/* Didn't really wake up - signal from something else */
+		goto again;
+	}
+}
+
+void
+_procwakeupandunlock(_Procrendez *r)
+{
+	int pid;
+
+	pid = 0;
+	if(r->asleep){
+		r->asleep = 0;
+		assert(r->pid >= 1);
+		pid = r->pid;
+	}
+	assert(r->l);
+	unlock(r->l);
+	if(pid)
+		kill(pid, SIGUSR1);
+}
+
+/*
+ * process creation and exit
+ */
+typedef struct Stackfree Stackfree;
+struct Stackfree
+{
+	Stackfree	*next;
+	int	pid;
+	int	pid1;
+};
+static Lock stacklock;
+static Stackfree *stackfree;
+
+static void
+delayfreestack(uchar *stk, int pid, int pid1)
+{
+	Stackfree *sf;
+
+	sf = (Stackfree*)stk;
+	sf->pid = pid;
+	sf->pid1 = pid1;
+	lock(&stacklock);
+	sf->next = stackfree;
+	stackfree = sf;
+	unlock(&stacklock);
+}
+
+static void
+dofreestacks(void)
+{
+	Stackfree *sf, *last, *next;
+
+	if(stackfree==nil || !canlock(&stacklock))
+		return;
+
+	for(last=nil,sf=stackfree; sf; last=sf,sf=next){
+		next = sf->next;
+		if(sf->pid >= 1 && kill(sf->pid, 0) < 0 && errno == ESRCH)
+		if(sf->pid1 >= 1 && kill(sf->pid1, 0) < 0 && errno == ESRCH){
+			free(sf);
+			if(last)
+				last->next = next;
+			else
+				stackfree = next;
+			sf = last;
+		}
+	}
+	unlock(&stacklock);
+}
+
+static int
+startprocfn(void *v)
+{
+	void **a;
+	uchar *stk;
+	void (*fn)(void*);
+	Proc *p;
+	int pid0, pid1;
+
+	a = (void**)v;
+	fn = a[0];
+	p = a[1];
+	stk = a[2];
+	pid0 = (int)a[4];
+	pid1 = getpid();
+	free(a);
+	p->osprocid = pid1;
+
+	(*fn)(p);
+
+	delayfreestack(stk, pid0, pid1);
+	_exit(0);
+	return 0;
+}
+
+/*
+ * indirect through here so that parent need not wait for child zombie
+ *
+ * slight race - if child exits and then another process starts before we
+ * manage to exit, we'll be running on a freed stack.
+ */
+static int
+trampnowait(void *v)
+{
+	void **a;
+	int *kidpid;
+
+	a = (void*)v;
+	kidpid = a[3];
+	a[4] = (void*)getpid();
+	*kidpid = clone(startprocfn, a[2]+65536-512, CLONE_VM|CLONE_FILES, a);
+	_exit(0);
+	return 0;
+}
+
+void
+_procstart(Proc *p, void (*fn)(Proc*))
+{
+	void **a;
+	uchar *stk;
+	int pid, kidpid, status;
+
+	dofreestacks();
+	a = malloc(5*sizeof a[0]);
+	if(a == nil)
+		sysfatal("_procstart malloc: %r");
+	stk = malloc(65536);
+	if(stk == nil)
+		sysfatal("_procstart malloc stack: %r");
+
+	a[0] = fn;
+	a[1] = p;
+	a[2] = stk;
+	a[3] = &kidpid;
+	kidpid = -1;
+
+	pid = clone(trampnowait, stk+65536-16, CLONE_VM|CLONE_FILES, a);
+	if(pid > 0)
+		if(wait4(pid, &status, __WALL, 0) < 0)
+			fprint(2, "ffork wait4: %r\n");
+	if(pid < 0 || kidpid < 0){
+		fprint(2, "_procstart clone: %r\n");
+		abort();
+	}
+}
+
+static char *threadexitsmsg;
+void
+sigusr2handler(int s)
+{
+/*	fprint(2, "%d usr2 %d\n", time(0), getpid()); */
+	if(threadexitsmsg)
+		_exits(threadexitsmsg);
+}
+
+void
+threadexitsall(char *msg)
+{
+	static int pid[1024];
+	int i, npid, mypid;
+	Proc *p;
+
+	if(msg == nil)
+		msg = "";
+
+	/*
+	 * Only one guy, ever, gets to run this.
+	 * If two guys do it, inevitably they end up
+	 * tripping over each other in the underlying
+	 * C library exit() implementation, which is
+	 * trying to run the atexit handlers and apparently
+	 * not thread safe.  This has been observed on
+	 * both Linux and OpenBSD.  Sigh.
+	 */
+	{
+		static Lock onelock;
+		if(!canlock(&onelock))
+			_exits(threadexitsmsg);
+		threadexitsmsg = msg;
+	}
+
+	mypid = getpid();
+	lock(&_threadprocslock);
+	npid = 0;
+	for(p=_threadprocs; p; p=p->next)
+		if(p->osprocid != mypid && p->osprocid >= 1)
+			pid[npid++] = p->osprocid;
+	for(i=0; i<npid; i++)
+		kill(pid[i], SIGUSR2);
+	unlock(&_threadprocslock);
+	exits(msg);
+}
+
+/*
+ * per-process data, indexed by pid
+ *
+ * could use modify_ldt and a segment register
+ * to avoid the many calls to getpid(), but i don't
+ * care -- this is compatibility code.  linux 2.6 with
+ * nptl is a good enough pthreads to avoid this whole file.
+ */
+typedef struct Perproc Perproc;
+struct Perproc
+{
+	int		pid;
+	Proc	*proc;
+};
+
+static Lock perlock;
+static Perproc perproc[1024];
+#define P ((Proc*)-1)
+
+static Perproc*
+myperproc(void)
+{
+	int i, pid, h;
+	Perproc *p;
+
+	pid = getpid();
+	h = pid%nelem(perproc);
+	for(i=0; i<nelem(perproc); i++){
+		p = &perproc[(i+h)%nelem(perproc)];
+		if(p->pid == pid)
+			return p;
+		if(p->pid == 0){
+			print("found 0 at %d (h=%d)\n", (i+h)%nelem(perproc), h);
+			break;
+		}
+	}
+	fprint(2, "myperproc %d (%s): cannot find self\n", pid, argv0);
+	abort();
+	return nil;
+}
+
+static Perproc*
+newperproc(void)
+{
+	int i, pid, h;
+	Perproc *p;
+
+	lock(&perlock);
+	pid = getpid();
+	h = pid%nelem(perproc);
+	for(i=0; i<nelem(perproc); i++){
+		p = &perproc[(i+h)%nelem(perproc)];
+		if(p->pid == pid || p->pid == -1 || p->pid == 0){
+			p->pid = pid;
+			unlock(&perlock);
+			return p;
+		}
+	}
+	fprint(2, "newperproc %d: out of procs\n", pid);
+	abort();
+	return nil;
+}
+
+Proc*
+_threadproc(void)
+{
+	return myperproc()->proc;
+}
+
+void
+_threadsetproc(Proc *p)
+{
+	Perproc *pp;
+
+	if(p)
+		p->osprocid = getpid();
+	pp = newperproc();
+	pp->proc = p;
+	if(p == nil)
+		pp->pid = -1;
+}
+
+void
+_pthreadinit(void)
+{
+	signal(SIGUSR2, sigusr2handler);
+}
+
+void
+_threadpexit(void)
+{
+	_exit(0);
+}
diff --git a/src/libthread/OpenBSD-386-asm.s b/src/libthread/OpenBSD-386-asm.s
index dad1b536..ed18d2f0 100644
--- a/src/libthread/OpenBSD-386-asm.s
+++ b/src/libthread/OpenBSD-386-asm.s
@@ -1 +1,45 @@
-#include "FreeBSD-386-asm.s"
+.globl getmcontext
+getmcontext:
+	movl	4(%esp), %eax
+
+	movl	%fs, 8(%eax)
+	movl	%es, 12(%eax)
+	movl	%ds, 16(%eax)
+	movl	%ss, 76(%eax)
+	movl	%edi, 20(%eax)
+	movl	%esi, 24(%eax)
+	movl	%ebp, 28(%eax)
+	movl	%ebx, 36(%eax)
+	movl	%edx, 40(%eax)
+	movl	%ecx, 44(%eax)
+
+	movl	$1, 48(%eax)	/* %eax */
+	movl	(%esp), %ecx	/* %eip */
+	movl	%ecx, 60(%eax)
+	leal	4(%esp), %ecx	/* %esp */
+	movl	%ecx, 72(%eax)
+
+	movl	44(%eax), %ecx	/* restore %ecx */
+	movl	$0, %eax
+	ret
+
+.globl setmcontext
+setmcontext:
+	movl	4(%esp), %eax
+
+	movl	8(%eax), %fs
+	movl	12(%eax), %es
+	movl	16(%eax), %ds
+	movl	76(%eax), %ss
+	movl	20(%eax), %edi
+	movl	24(%eax), %esi
+	movl	28(%eax), %ebp
+	movl	36(%eax), %ebx
+	movl	40(%eax), %edx
+	movl	44(%eax), %ecx
+
+	movl	72(%eax), %esp
+	pushl	60(%eax)	/* new %eip */
+	movl	48(%eax), %eax
+	ret
+
diff --git a/src/libthread/OpenBSD-power-asm.S b/src/libthread/OpenBSD-power-asm.S
index 03b46e7b..36035eb5 100644
--- a/src/libthread/OpenBSD-power-asm.S
+++ b/src/libthread/OpenBSD-power-asm.S
@@ -1,18 +1,3 @@
-ENTRY(_tas)
-	li	%r0, 0
-	mr	%r4, %r3
-	lis	%r5, 0xcafe
-	ori	%r5, %r5, 0xbabe
-1:
-	lwarx	%r3, %r0, %r4
-	cmpwi	%r3, 0
-	bne	2f
-	stwcx.	%r5, %r0, %r4
-	bne-	1b
-2:
-	sync
-	blr
-
 ENTRY(_getmcontext)				/* xxx: instruction scheduling */
 	mflr	%r0
 	mfcr	%r5
diff --git a/src/libthread/OpenBSD-power.c b/src/libthread/OpenBSD-power.c
deleted file mode 100644
index eab711f2..00000000
--- a/src/libthread/OpenBSD-power.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "threadimpl.h"
-
-void
-makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
-{
-	ulong *sp, *tos;
-	va_list arg;
-
-	tos = (ulong*)ucp->uc_stack.ss_sp+ucp->uc_stack.ss_size/sizeof(ulong);
-	sp = (ulong*)((ulong)(tos-16) & ~15);
-	ucp->mc.pc = (long)func;
-	ucp->mc.sp = (long)sp;
-	va_start(arg, argc);
-	ucp->mc.r3 = va_arg(arg, long);
-	va_end(arg);
-}
-
-int
-swapcontext(ucontext_t *oucp, ucontext_t *ucp)
-{
-	if(getcontext(oucp) == 0)
-		setcontext(ucp);
-	return 0;
-}
diff --git a/src/libthread/OpenBSD.c b/src/libthread/OpenBSD.c
deleted file mode 100644
index 80a50977..00000000
--- a/src/libthread/OpenBSD.c
+++ /dev/null
@@ -1,145 +0,0 @@
-#include "threadimpl.h"
-#include "BSD.c"
-
-#include <dlfcn.h>
-
-struct thread_tag {
-	struct thread_tag	*next;
-	spinlock_t		l;
-	volatile int		key;
-	void			*data;
-};
-
-static spinlock_t mlock;
-static spinlock_t dl_lock;
-static spinlock_t tag_lock;
-static struct thread_tag *thread_tag_store = nil;
-static uint nextkey = 0;
-
-void
-_thread_malloc_lock(void)
-{
-	_spinlock(&mlock);
-}
-
-void
-_thread_malloc_unlock(void)
-{
-	_spinunlock(&mlock);
-}
-
-void
-_thread_malloc_init(void)
-{
-}
-
-/*
- * for ld.so
- */
-void
-_thread_dl_lock(int t)
-{
-	if(t)
-		_spinunlock(&dl_lock);
-	else
-		_spinlock(&dl_lock);
-}
-
-/*
- * for libc
- */
-static void
-_thread_tag_init(void **tag)
-{
-	struct thread_tag *t;
-
-	_spinlock(&tag_lock);
-	if(*tag == nil) {
-		t = malloc(sizeof (*t));
-		if(t != nil) {
-			memset(&t->l, 0, sizeof(t->l));
-			t->key = nextkey++;
-			*tag = t;
-		}
-	}
-	_spinunlock(&tag_lock);
-}
-
-void
-_thread_tag_lock(void **tag)
-{
-	struct thread_tag *t;
-
-	if(*tag == nil)
-		_thread_tag_init(tag);
-	t = *tag;
-	_spinlock(&t->l);
-}
-
-void
-_thread_tag_unlock(void **tag)
-{
-	struct thread_tag *t;
-
-	if(*tag == nil)
-		_thread_tag_init(tag);
-	t = *tag;
-	_spinunlock(&t->l);
-}
-
-static void *
-_thread_tag_insert(struct thread_tag *t, void *v)
-{
-	t->data = v;
-	t->next = thread_tag_store;
-	thread_tag_store = t;
-	return t;
-}
-
-static void *
-_thread_tag_lookup(struct thread_tag *tag, int size)
-{
-	struct thread_tag *t;
-	void *p;
-
-	_spinlock(&tag->l);
-	for(t = thread_tag_store; t != nil; t = t->next)
-		if(t->key == tag->key)
-			break;
-	if(t == nil) {
-		p = malloc(size);
-		if(p == nil) {
-			_spinunlock(&tag->l);
-			return nil;
-		}
-		_thread_tag_insert(tag, p);
-	}
-	_spinunlock(&tag->l);
-	return tag->data;
-}
-
-void *
-_thread_tag_storage(void **tag, void *storage, size_t n, void *err)
-{
-	struct thread_tag *t;
-	void *r;
-
-	if(*tag == nil)
-		_thread_tag_init(tag);
-	t = *tag;
-
-	r = _thread_tag_lookup(t, n);
-	if(r == nil)
-		r = err;
-	else
-		memcpy(r, storage, n);
-	return r;
-}
-
-void
-_pthreadinit(void)
-{
-	__isthreaded = 1;
-	dlctl(nil, DL_SETTHREADLCK, _thread_dl_lock);
-	signal(SIGUSR2, sigusr2handler);
-}
diff --git a/src/libthread/README.Linux b/src/libthread/README.Linux
deleted file mode 100644
index 04c491a8..00000000
--- a/src/libthread/README.Linux
+++ /dev/null
@@ -1,40 +0,0 @@
-Thread support on Linux is confused by the recent thread local storage (TLS)
-support that has been put into the ELF tool chain.  The TLS libraries are 
-installed in /lib/tls on most Linux systems.
-
-We provide two different implementations of the os-dependent parts
-of libthread for Linux.  The first is intended for use on Linux 2.4 and earlier
-kernels, which do not support TLS.  It is in Linux.c and Linuxasm.c and
-does not use the pthread interface.  The second is intended for Linux 2.6
-and later kernels, which do support TLS.  It is in pthread.c and uses the
-standard pthread interface.  It expects to be linked against the TLS-aware
-thread library aka NPTL.
-
-If you use Linux.c and Linuxasm.c with TLS libraries, they do not
-set up the TLS properly so you will get incorrect programs.
-For example, there will only be one errno among all the procs
-in your program instead of one per proc.  The pthread NPTL
-implementation is needed to use the TLS libraries properly.
-
-If you use pthread.c without TLS libraries (i.e., with the old Linux
-pthread library known as LinuxThreads), then you will also get
-incorrect programs, although more obviously so.  The LinuxThreads
-library assumes it can look at the stack pointer to distinguish between
-threads, but libthread does its own stack management, breaking this
-assumption.  If you run a pthread-compiled program with the 
-LinuxThreads library, LinuxThreads itself will cause a segmentation
-fault in __pthread_getspecific() the first time it is called from a
-non-standard stack.
-
-So, it is important that you compile binaries that match your
-system's choice of TLS vs. not-TLS libraries.  The hard part is figuring
-out which your system has chosen.  Plan9port looks at the kernel
-version you are running and assumes that on kernels that support
-TLS (2.6+) you will be using TLS.
-
-Apparently Gentoo and maybe other distributions do not follow this rule.
-They use non-TLS libraries even on kernels that can support TLS.
-To accomodate them, you can add a line SYSVERSION=2.4 to $PLAN9/config
-to force the build to think you are running an old kernel.
-The INSTALL script sets up this file automatically on Linux systems.
-
diff --git a/src/libthread/Linux-arm-swapcontext.c b/src/libthread/arm-ucontext.c
index fc0dfdda..512ca973 100644
--- a/src/libthread/Linux-arm-swapcontext.c
+++ b/src/libthread/arm-ucontext.c
@@ -6,7 +6,7 @@ makecontext(ucontext_t *uc, void (*fn)(void), int argc, ...)
 	int i, *sp;
 	va_list arg;
 
-	sp = (int*)uc->uc_stack.ss_sp+uc->uc_stack.ss_size/4;
+	sp = USPALIGN(uc, 4);
 	va_start(arg, argc);
 	for(i=0; i<4 && i<argc; i++)
 		(&uc->uc_mcontext.arm_r0)[i] = va_arg(arg, uint);
diff --git a/src/libthread/mkfile b/src/libthread/mkfile
index f621ac60..8a77a316 100644
--- a/src/libthread/mkfile
+++ b/src/libthread/mkfile
@@ -16,8 +16,6 @@ OFILES=\
 <$PLAN9/src/mksyslib
 
 HFILES=thread.h threadimpl.h
-FreeBSD.$O: BSD.c
-NetBSD.$O: Linux.c
 
 tprimes: test/tprimes.$O
 	9l -o $target test/$target.$O
@@ -26,6 +24,8 @@ tspawn: test/tspawn.$O
 tspawnloop: test/tspawnloop.$O
 	9l -o $target test/$target.$O
 
+tprimes tspawn tspawnloop: $PLAN9/lib/$LIB
+
 %.$O: %.c
 	$CC -o $target $CFLAGS -I. $stem.c
 
@@ -39,8 +39,8 @@ OpenBSD-%-asm.$O:	OpenBSD-%-asm.S
 Linux-sparc64-context.$O: Linux-sparc64-context.S
 	$CC -m64 -mcpu=v9 $CFLAGS Linux-sparc64-context.S
 
-Linux-sparc64-swapcontext.$O: Linux-sparc64-swapcontext.c
-	$CC -m64 -mcpu=v9 $CFLAGS Linux-sparc64-swapcontext.c
+sparc64-ucontext.$O: sparc64-ucontext.c
+	$CC -m64 -mcpu=v9 $CFLAGS sparc64-ucontext.c
 
 test:V: tprimes tspawn
 	primes 1 10007 >p1.txt
@@ -52,4 +52,5 @@ test:V: tprimes tspawn
 	echo tspawn should take 3 seconds, not 6
 	$PLAN9/bin/time ./tspawn sleep 3 >/dev/null
 
-CLEANFILES=p1.txt p2.txt tp1.txt tp2.txt test/*.$O
+CLEANFILES=p1.txt p2.txt tp1.txt tp2.txt test/*.$O tprimes tspawn
+
diff --git a/src/libthread/Darwin-power.c b/src/libthread/power-ucontext.c
index 3f2bf566..32a8e931 100644
--- a/src/libthread/Darwin-power.c
+++ b/src/libthread/power-ucontext.c
@@ -6,12 +6,14 @@ makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...)
 	ulong *sp, *tos;
 	va_list arg;
 
-	tos = (ulong*)ucp->uc_stack.ss_sp+ucp->uc_stack.ss_size/sizeof(ulong);
-	sp = tos - 16;
+	if(argc != 2)
+		sysfatal("libthread: makecontext misused");
+	sp = USPALIGN(ucp, 16);
 	ucp->mc.pc = (long)func;
 	ucp->mc.sp = (long)sp;
 	va_start(arg, argc);
 	ucp->mc.r3 = va_arg(arg, long);
+	ucp->mc.r4 = va_arg(arg, long);
 	va_end(arg);
 }
 
diff --git a/src/libthread/sparc-ucontext.h b/src/libthread/sparc-ucontext.h
deleted file mode 100644
index 36b88171..00000000
--- a/src/libthread/sparc-ucontext.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#define	setcontext(u)	_setmcontext(&(u)->mc)
-#define	getcontext(u)	_getmcontext(&(u)->mc)
-typedef struct mcontext mcontext_t;
-typedef struct ucontext ucontext_t;
-struct mcontext
-{
-	int	r[16];
-};
-
-struct ucontext
-{
-	struct {
-		void *ss_sp;
-		uint ss_size;
-	} uc_stack;
-	sigset_t uc_sigmask;
-	mcontext_t mc;
-};
-
-void makecontext(ucontext_t*, void(*)(void), int, ...);
-int swapcontext(ucontext_t*, ucontext_t*);
-int _getmcontext(mcontext_t*);
-void _setmcontext(mcontext_t*);
diff --git a/src/libthread/Linux-sparc64-swapcontext.c b/src/libthread/sparc64-ucontext.c
index e4800c19..e4800c19 100644
--- a/src/libthread/Linux-sparc64-swapcontext.c
+++ b/src/libthread/sparc64-ucontext.c
diff --git a/src/libthread/stkmalloc.c b/src/libthread/stkmalloc.c
new file mode 100644
index 00000000..083aea1b
--- /dev/null
+++ b/src/libthread/stkmalloc.c
@@ -0,0 +1,13 @@
+#include "threadimpl.h"
+
+void*
+_threadstkalloc(int n)
+{
+	return malloc(n);
+}
+
+void
+_threadstkfree(void *v, int n)
+{
+	free(v);
+}
diff --git a/src/libthread/stkmmap.c b/src/libthread/stkmmap.c
new file mode 100644
index 00000000..f4a24630
--- /dev/null
+++ b/src/libthread/stkmmap.c
@@ -0,0 +1,25 @@
+#include <u.h>
+#include <sys/mman.h>
+#include "threadimpl.h"
+
+#ifndef MAP_STACK
+#define MAP_STACK 0
+#endif
+
+void*
+_threadstkalloc(int n)
+{
+	void *p;
+
+	p = mmap(nil, n, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON|MAP_STACK, -1, 0);
+	if(p == (void*)-1)
+		return nil;
+	return p;
+}
+
+void
+_threadstkfree(void *v, int n)
+{
+	if(n > 0)
+		munmap(v, n);
+}
diff --git a/src/libthread/sysofiles.sh b/src/libthread/sysofiles.sh
index 9eeea606..20811cdf 100644
--- a/src/libthread/sysofiles.sh
+++ b/src/libthread/sysofiles.sh
@@ -2,40 +2,27 @@
 
 test -f $PLAN9/config && . $PLAN9/config
 
-tag="$OBJTYPE-$SYSNAME-${SYSVERSION:-`uname -r`}-${CC9:-cc}"
-case "$tag" in
-*-Linux-2.[0-5]*)
-	# will have to fix this for linux power pc
-	echo ${SYSNAME}-${OBJTYPE}-asm.o $SYSNAME.o
+case "$SYSNAME" in
+NetBSD)
+	echo ${SYSNAME}-${OBJTYPE}-asm.o $SYSNAME.o stkmalloc.o
 	;;
-*-FreeBSD-[0-4].*)
-	echo ${SYSNAME}-${OBJTYPE}-asm.o $SYSNAME.o
-	;;
-*-NetBSD-*)
-	echo ${SYSNAME}-${OBJTYPE}-asm.o $SYSNAME.o
-	;;
-*-Darwin-10.[5-6].* | *-Darwin-[89].*)
-	echo ${SYSNAME}-${OBJTYPE}-asm.o $SYSNAME-${OBJTYPE}.o pthread.o
-	;;
-*-OpenBSD-*)
-	echo ${SYSNAME}-${OBJTYPE}-asm.o ${SYSNAME}-${OBJTYPE}.o pthread.o
+OpenBSD)
+	echo pthread.o stkmmap.o
 	;;
 *)
-	echo pthread.o
+	echo pthread.o stkmalloc.o
 esac
 
-case "$OBJTYPE-$SYSNAME" in
-sparc64-Linux)
-	# Debian glibc doesn't supply swapcontext, makecontext
-	# so we supply our own copy from the latest glibc.
-	echo Linux-sparc64-context.o Linux-sparc64-swapcontext.o
-	;;
-arm-Linux)
-	# ARM doesn't supply them either.
-	echo Linux-arm-context.o Linux-arm-swapcontext.o
-	;;
-x86_64-Darwin)
-	echo Darwin-x86_64-asm.o Darwin-x86_64-swapcontext.o
+# Various libc don't supply swapcontext, makecontext, so we do.
+case "$SYSNAME-$OBJTYPE" in
+Darwin-x86_64 | Linux-arm | Linux-sparc64 | NetBSD-arm | OpenBSD-386 | OpenBSD-power | OpenBSD-x86_64)
+	echo $OBJTYPE-ucontext.o
 	;;
 esac
 
+# A few libc don't supply setcontext, getcontext, so we do.
+case "$SYSNAME-$OBJTYPE" in
+Darwin-x86_64 | Linux-arm | Linux-sparc64 | OpenBSD-386 | OpenBSD-power | OpenBSD-x86_64)
+	echo $SYSNAME-$OBJTYPE-asm.o
+	;;
+esac
diff --git a/src/libthread/thread.c b/src/libthread/thread.c
index d041efcc..f657b5b2 100644
--- a/src/libthread/thread.c
+++ b/src/libthread/thread.c
@@ -109,7 +109,7 @@ threadalloc(void (*fn)(void*), void *arg, uint stack)
 	ulong z;
 
 	/* allocate the task and stack together */
-	t = malloc(sizeof *t+stack);
+	t = malloc(sizeof *t);
 	if(t == nil)
 		sysfatal("threadalloc malloc: %r");
 	memset(t, 0, sizeof *t);
@@ -122,7 +122,9 @@ threadalloc(void (*fn)(void*), void *arg, uint stack)
 	/* do a reasonable initialization */
 	if(stack == 0)
 		return t;
-	t->stk = (uchar*)(t+1);
+	t->stk = _threadstkalloc(stack);
+	if(t->stk == nil)
+		sysfatal("threadalloc malloc stack: %r");
 	t->stksize = stack;
 	memset(&t->context.uc, 0, sizeof t->context.uc);
 	sigemptyset(&zero);
@@ -134,10 +136,16 @@ threadalloc(void (*fn)(void*), void *arg, uint stack)
 		sysfatal("threadalloc getcontext: %r");
 //print("makecontext sp=%p t=%p startfn=%p\n", (char*)t->stk+t->stksize, t, t->startfn);
 
-	/* call makecontext to do the real work. */
-	/* leave a few words open on both ends */
-	t->context.uc.uc_stack.ss_sp = (void*)(t->stk+8);
-	t->context.uc.uc_stack.ss_size = t->stksize-64;
+	/*
+	 * Call makecontext to do the real work.
+	 * To avoid various mistakes on other system software,
+	 * debuggers, and so on, don't get too close to both
+	 * ends of the stack. Just staying away is much easier
+	 * than debugging everything (outside our control)
+	 * that has off-by-one errors.
+	 */
+	t->context.uc.uc_stack.ss_sp = (void*)(t->stk+64);
+	t->context.uc.uc_stack.ss_size = t->stksize-2*64;
 #if defined(__sun__) && !defined(__MAKECONTEXT_V2_SOURCE)		/* sigh */
 	/* can avoid this with __MAKECONTEXT_V2_SOURCE but only on SunOS 5.9 */
 	t->context.uc.uc_stack.ss_sp =
@@ -353,6 +361,7 @@ Top:
 		delthreadinproc(p, t);
 		p->nthread--;
 /*print("nthread %d\n", p->nthread); */
+		_threadstkfree(t->stk, t->stksize);
 		free(t);
 	}
 
@@ -509,6 +518,8 @@ needstack(int n)
 	_Thread *t;
 
 	t = proc()->thread;
+	if(t->stk == nil)
+		return;
 
 	if((char*)&t <= (char*)t->stk
 	|| (char*)&t - (char*)t->stk < 256+n){
diff --git a/src/libthread/threadimpl.h b/src/libthread/threadimpl.h
index 76ca57e5..cceb1b8e 100644
--- a/src/libthread/threadimpl.h
+++ b/src/libthread/threadimpl.h
@@ -15,15 +15,6 @@
 #include "libc.h"
 #include "thread.h"
 
-#if defined(__FreeBSD__) && __FreeBSD__ < 5
-extern	int		getmcontext(mcontext_t*);
-extern	void		setmcontext(mcontext_t*);
-#define	setcontext(u)	setmcontext(&(u)->uc_mcontext)
-#define	getcontext(u)	getmcontext(&(u)->uc_mcontext)
-extern	int		swapcontext(ucontext_t*, ucontext_t*);
-extern	void		makecontext(ucontext_t*, void(*)(), int, ...);
-#endif
-
 #if defined(__APPLE__)
 	/*
 	 * OS X before 10.5 (Leopard) does not provide
@@ -64,20 +55,6 @@ extern	void		makecontext(ucontext_t*, void(*)(), int, ...);
 extern pid_t rfork_thread(int, void*, int(*)(void*), void*);
 #endif
 
-/* THIS DOES NOT WORK!  Don't do this!
-(At least, not on Solaris.  Maybe this is right for Linux,
-in which case it should say if defined(__linux__) && defined(__sun__),
-but surely the latter would be defined(__sparc__).
-
-#if defined(__sun__)
-#	define mcontext libthread_mcontext
-#	define mcontext_t libthread_mcontext_t
-#	define ucontext libthread_ucontext
-#	define ucontext_t libthread_ucontext_t
-#	include "sparc-ucontext.h"
-#endif
-*/
-
 #if defined(__arm__)
 int mygetmcontext(ulong*);
 void mysetmcontext(const ulong*);
@@ -209,3 +186,8 @@ extern void _threadsetupdaemonize(void);
 extern void _threaddodaemonize(char*);
 extern void _threadpexit(void);
 extern void _threaddaemonize(void);
+extern void *_threadstkalloc(int);
+extern void _threadstkfree(void*, int);
+
+#define USPALIGN(ucp, align) \
+	(void*)((((uintptr)(ucp)->uc_stack.ss_sp+(ucp)->uc_stack.ss_size)-(align))&~((align)-1))
diff --git a/src/libthread/OpenBSD-x86_64.c b/src/libthread/x86_64-ucontext.c
index 27931456..5d1aaefc 100644
--- a/src/libthread/OpenBSD-x86_64.c
+++ b/src/libthread/x86_64-ucontext.c
@@ -6,16 +6,14 @@ makecontext(ucontext_t *uc, void (*fn)(void), int argc, ...)
 	uintptr *sp;
 	va_list arg;
 
-//fprint(2, "makecontext %d\n", argc);
 	if(argc != 2)
 		sysfatal("libthread: makecontext misused");
 	va_start(arg, argc);
 	uc->mc.di = va_arg(arg, uint);
 	uc->mc.si = va_arg(arg, uint);
-//fprint(2, "%ux %ux\n", uc->mc.di, uc->mc.si);
 	va_end(arg);
 
-	sp = (uintptr*)((char*)uc->uc_stack.ss_sp+uc->uc_stack.ss_size);
+	sp = USPALIGN(uc, 16);
 	*--sp = 0;  // fn's return address
 	*--sp = (uintptr)fn;  // return address of setcontext
 	uc->mc.sp = (uintptr)sp;