fixfmt: fix all usages of %u so that u is a type, not a modifier

The rest of the world uses %u to mean unsigned decimal. Plan 9
uses it as a modifier, which is arguably better, but what can we do?
You don't always get to pick the standard.

This change modifies libc/fmt so that %u is unsigned decimal, and
modifies most uses of it so the kernel almost boots. Almost. Obviously
we didn't get them all yet.

It hangs in ipconfig.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>

acme/bin/source/acd/acme.c

@@ -76,7 +76,7 @@ return 1;
 		return 0;
 
 	q1--;	/* > */
-	sprint(buf, "#%lud,#%lud", q0, q1);
+	sprint(buf, "#%lu,#%lu", q0, q1);
 	DPRINT(2, "setaddr %s\n", buf);
 	if(!winsetaddr(w, buf, 1))
 		return 0;
@@ -129,7 +129,7 @@ markplay(Window *w, uint32_t q0)
 	if(w->data < 0)
 		w->data = winopenfile(w, "data");
 
-	sprint(buf, "#%lud", q0);
+	sprint(buf, "#%lu", q0);
 	DPRINT(2, "addr %s\n", buf);
 	if(!winsetaddr(w, buf, 1) || !winsetaddr(w, "-0", 1))
 		return 0;

acme/bin/source/acd/mmc.c

@@ -214,7 +214,7 @@ dumptoc(Toc *t)
 
 	fprint(1, "%d tracks\n", t->ntrack);
 	for(i=0; i<t->ntrack; i++)
-		print("%d. %M-%M (%lud-%lud)\n", i+1,
+		print("%d. %M-%M (%lu-%lu)\n", i+1,
 			t->track[i].start, t->track[i].end,
 			t->track[i].bstart, t->track[i].bend);
 }

acme/bin/source/win/fs.c

@@ -75,7 +75,7 @@ fswrite(Req *r)
 		i = newpipewin(pid, t);
 		free(s);
 		s = emalloc(32);
-		sprint(s, "%lud", (uint32_t)i);
+		sprint(s, "%lu", (uint32_t)i);
 		r->fid->aux = s;
 		r->ofcall.count = r->ifcall.count;
 		respond(r, nil);

acme/bin/source/win/main.c

@@ -229,7 +229,7 @@ __sendinput(Window *w, uint32_t q0, uint32_t q1)
 		eq = &q;
 	r->aux = nil;
 	if(debug)
-		fprint(2, "read returns %lud-%lud: %.*q\n", q0, q0+n, n, r->ofcall.data);
+		fprint(2, "read returns %lu-%lu: %.*q\n", q0, q0+n, n, r->ofcall.data);
 	respond(r, nil);
 	return n;
 }
@@ -244,7 +244,7 @@ _sendinput(Window *w, uint32_t q0, uint32_t *q1)
 	if(!n || !eraseinput)
 		return n;
 	/* erase q0 to q0+n */
-	sprint(buf, "#%lud,#%lud", q0, q0+n);
+	sprint(buf, "#%lu,#%lu", q0, q0+n);
 	winsetaddr(w, buf, 0);
 	write(w->data, buf, 0);
 	*q1 -= n;
@@ -424,7 +424,7 @@ mainctl(void *v)
 	pendingK = 0;
 	for(;;){
 		if(debug)
-			fprint(2, "input range %lud-%lud\n", hostpt, endpt);
+			fprint(2, "input range %lu-%lu\n", hostpt, endpt);
 		e = recvp(w->cevent);
 		if(debug)
 			fprint(2, "msg: %C %C %d %d %d %d %q\n",
@@ -443,7 +443,7 @@ mainctl(void *v)
 			break;
 
 		case 'S':	/* output to stdout */
-			sprint(tmp, "#%lud", hostpt);
+			sprint(tmp, "#%lu", hostpt);
 			winsetaddr(w, tmp, 0);
 			write(w->data, e->b, e->nb);
 			pendingS += e->nr;
@@ -475,7 +475,7 @@ mainctl(void *v)
 				if(pendingS < 0)
 					fprint(2, "win: pendingS = %d\n", pendingS);
 				if(e->q0 != hostpt)
-					fprint(2, "win: insert at %d expected %lud\n", e->q0, hostpt);
+					fprint(2, "win: insert at %d expected %lu\n", e->q0, hostpt);
 				endpt += delta;
 				hostpt += delta;
 				sendp(writechan, nil);

acme/wiki/src/wiki.c

@@ -81,7 +81,7 @@ wikiput(Wiki *w)
 	}
 	write(fd, p, Blinelen(b));
 
-	snprint(buf, sizeof buf, "D%lud\n", w->time);
+	snprint(buf, sizeof buf, "D%lu\n", w->time);
 	if(email)
 		snprint(buf+strlen(buf), sizeof(buf)-strlen(buf), "A%s\n", email);
 
@@ -100,7 +100,7 @@ wikiput(Wiki *w)
 
 	werrstr("");
 	if((n=write(fd, "", 0)) != 0){
-		fprint(2, "Wiki commit %lud %d %d: %r\n", w->time, fd, n);
+		fprint(2, "Wiki commit %lu %d %d: %r\n", w->time, fd, n);
 		close(fd);
 		return -1;
 	}
@@ -320,15 +320,15 @@ expand(Window *w, Event *e, Event *eacme)
 		return e;
 	}
 
-	q0 = eval(w, "#%lud-/\\[/", e->q0);
+	q0 = eval(w, "#%lu-/\\[/", e->q0);
 	if(q0 < 0)
 		return eacme;
-	if(eval(w, "#%lud+/\\]/", q0) < e->q0)	/* [ closes before us */
+	if(eval(w, "#%lu+/\\]/", q0) < e->q0)	/* [ closes before us */
 		return eacme;
-	q1 = eval(w, "#%lud+/\\]/", e->q1);
+	q1 = eval(w, "#%lu+/\\]/", e->q1);
 	if(q1 < 0)
 		return eacme;
-	if((x=eval(w, "#%lud-/\\[/", q1))==-1 || x > e->q1)	/* ] opens after us */
+	if((x=eval(w, "#%lu-/\\[/", q1))==-1 || x > e->q1)	/* ] opens after us */
 		return eacme;
 	e->q0 = q0+1;
 	e->q1 = q1;

sys/doc/prog4.ms

@@ -268,7 +268,7 @@ system call, which includes a set of integers (pids and times) and a string (the
 This information is formatted free-form; here is the statement in the kernel that
 generates the message:
 .P1
-n = snprint(a, n, "%d %lud %lud %lud %q",
+n = snprint(a, n, "%d %lu %lu %lu %q",
 	wq->w.pid,
 	wq->w.time[TUser], wq->w.time[TSys], wq->w.time[TReal],
 	wq->w.msg);

sys/doc/prog4.ps

@@ -4880,9 +4880,9 @@ mark
 (snprint\(a,) 1268 5532 w
 (n,) 1983 5532 w
 ("%d) 2178 5532 w
-(%lud) 2438 5532 w
-(%lud) 2763 5532 w
-(%lud) 3088 5532 w
+(%lu) 2438 5532 w
+(%lu) 2763 5532 w
+(%lu) 3088 5532 w
 (%q",) 3413 5532 w
 (wq->w.pid,) 1528 5642 w
 (wq->w.time[TUser],) 1528 5752 w

sys/lib/dist/cmd/touchfs.c

@@ -64,7 +64,7 @@ main(int argc, char **argv)
 			exits("notdone");
 		}
 
-		Bprint(&bout, "%q %q %q %q %lud %q\n",
+		Bprint(&bout, "%q %q %q %q %lu %q\n",
 			f[0], f[1], f[2], f[3], d, f[5]);
 
 		size = strtoul(f[5], 0, 0);

sys/src/9/386/ether8169.c

@@ -555,31 +555,31 @@ rtl8169ifstat(Ether* edev, void* a, int32_t n, uint32_t offset)
 	l = snprint(p, READSTR, "TxOk: %llud\n", dtcc->txok);
 	l += snprint(p+l, READSTR-l, "RxOk: %llud\n", dtcc->rxok);
 	l += snprint(p+l, READSTR-l, "TxEr: %llud\n", dtcc->txer);
-	l += snprint(p+l, READSTR-l, "RxEr: %ud\n", dtcc->rxer);
-	l += snprint(p+l, READSTR-l, "MissPkt: %ud\n", dtcc->misspkt);
-	l += snprint(p+l, READSTR-l, "FAE: %ud\n", dtcc->fae);
-	l += snprint(p+l, READSTR-l, "Tx1Col: %ud\n", dtcc->tx1col);
-	l += snprint(p+l, READSTR-l, "TxMCol: %ud\n", dtcc->txmcol);
+	l += snprint(p+l, READSTR-l, "RxEr: %u\n", dtcc->rxer);
+	l += snprint(p+l, READSTR-l, "MissPkt: %u\n", dtcc->misspkt);
+	l += snprint(p+l, READSTR-l, "FAE: %u\n", dtcc->fae);
+	l += snprint(p+l, READSTR-l, "Tx1Col: %u\n", dtcc->tx1col);
+	l += snprint(p+l, READSTR-l, "TxMCol: %u\n", dtcc->txmcol);
 	l += snprint(p+l, READSTR-l, "RxOkPh: %llud\n", dtcc->rxokph);
 	l += snprint(p+l, READSTR-l, "RxOkBrd: %llud\n", dtcc->rxokbrd);
-	l += snprint(p+l, READSTR-l, "RxOkMu: %ud\n", dtcc->rxokmu);
-	l += snprint(p+l, READSTR-l, "TxAbt: %ud\n", dtcc->txabt);
-	l += snprint(p+l, READSTR-l, "TxUndrn: %ud\n", dtcc->txundrn);
-
-	l += snprint(p+l, READSTR-l, "txdu: %ud\n", ctlr->txdu);
-	l += snprint(p+l, READSTR-l, "tcpf: %ud\n", ctlr->tcpf);
-	l += snprint(p+l, READSTR-l, "udpf: %ud\n", ctlr->udpf);
-	l += snprint(p+l, READSTR-l, "ipf: %ud\n", ctlr->ipf);
-	l += snprint(p+l, READSTR-l, "fovf: %ud\n", ctlr->fovf);
-	l += snprint(p+l, READSTR-l, "ierrs: %ud\n", ctlr->ierrs);
-	l += snprint(p+l, READSTR-l, "rer: %ud\n", ctlr->rer);
-	l += snprint(p+l, READSTR-l, "rdu: %ud\n", ctlr->rdu);
-	l += snprint(p+l, READSTR-l, "punlc: %ud\n", ctlr->punlc);
-	l += snprint(p+l, READSTR-l, "fovw: %ud\n", ctlr->fovw);
+	l += snprint(p+l, READSTR-l, "RxOkMu: %u\n", dtcc->rxokmu);
+	l += snprint(p+l, READSTR-l, "TxAbt: %u\n", dtcc->txabt);
+	l += snprint(p+l, READSTR-l, "TxUndrn: %u\n", dtcc->txundrn);
+
+	l += snprint(p+l, READSTR-l, "txdu: %u\n", ctlr->txdu);
+	l += snprint(p+l, READSTR-l, "tcpf: %u\n", ctlr->tcpf);
+	l += snprint(p+l, READSTR-l, "udpf: %u\n", ctlr->udpf);
+	l += snprint(p+l, READSTR-l, "ipf: %u\n", ctlr->ipf);
+	l += snprint(p+l, READSTR-l, "fovf: %u\n", ctlr->fovf);
+	l += snprint(p+l, READSTR-l, "ierrs: %u\n", ctlr->ierrs);
+	l += snprint(p+l, READSTR-l, "rer: %u\n", ctlr->rer);
+	l += snprint(p+l, READSTR-l, "rdu: %u\n", ctlr->rdu);
+	l += snprint(p+l, READSTR-l, "punlc: %u\n", ctlr->punlc);
+	l += snprint(p+l, READSTR-l, "fovw: %u\n", ctlr->fovw);
 
 	l += snprint(p+l, READSTR-l, "tcr: %#8.8ux\n", ctlr->tcr);
 	l += snprint(p+l, READSTR-l, "rcr: %#8.8ux\n", ctlr->rcr);
-	l += snprint(p+l, READSTR-l, "multicast: %ud\n", ctlr->mcast);
+	l += snprint(p+l, READSTR-l, "multicast: %u\n", ctlr->mcast);
 
 	if(ctlr->mii != nil && ctlr->mii->curphy != nil){
 		l += snprint(p+l, READSTR, "phy:   ");

sys/src/9/386/ether82557.c

@@ -449,22 +449,22 @@ ifstat(Ether* ether, void* a, int32_t n, uint32_t offset)
 	unlock(&ctlr->dlock);
 
 	p = malloc(READSTR);
-	len = snprint(p, READSTR, "transmit good frames: %lud\n", dump[0]);
-	len += snprint(p+len, READSTR-len, "transmit maximum collisions errors: %lud\n", dump[1]);
-	len += snprint(p+len, READSTR-len, "transmit late collisions errors: %lud\n", dump[2]);
-	len += snprint(p+len, READSTR-len, "transmit underrun errors: %lud\n", dump[3]);
-	len += snprint(p+len, READSTR-len, "transmit lost carrier sense: %lud\n", dump[4]);
-	len += snprint(p+len, READSTR-len, "transmit deferred: %lud\n", dump[5]);
-	len += snprint(p+len, READSTR-len, "transmit single collisions: %lud\n", dump[6]);
-	len += snprint(p+len, READSTR-len, "transmit multiple collisions: %lud\n", dump[7]);
-	len += snprint(p+len, READSTR-len, "transmit total collisions: %lud\n", dump[8]);
-	len += snprint(p+len, READSTR-len, "receive good frames: %lud\n", dump[9]);
-	len += snprint(p+len, READSTR-len, "receive CRC errors: %lud\n", dump[10]);
-	len += snprint(p+len, READSTR-len, "receive alignment errors: %lud\n", dump[11]);
-	len += snprint(p+len, READSTR-len, "receive resource errors: %lud\n", dump[12]);
-	len += snprint(p+len, READSTR-len, "receive overrun errors: %lud\n", dump[13]);
-	len += snprint(p+len, READSTR-len, "receive collision detect errors: %lud\n", dump[14]);
-	len += snprint(p+len, READSTR-len, "receive short frame errors: %lud\n", dump[15]);
+	len = snprint(p, READSTR, "transmit good frames: %lu\n", dump[0]);
+	len += snprint(p+len, READSTR-len, "transmit maximum collisions errors: %lu\n", dump[1]);
+	len += snprint(p+len, READSTR-len, "transmit late collisions errors: %lu\n", dump[2]);
+	len += snprint(p+len, READSTR-len, "transmit underrun errors: %lu\n", dump[3]);
+	len += snprint(p+len, READSTR-len, "transmit lost carrier sense: %lu\n", dump[4]);
+	len += snprint(p+len, READSTR-len, "transmit deferred: %lu\n", dump[5]);
+	len += snprint(p+len, READSTR-len, "transmit single collisions: %lu\n", dump[6]);
+	len += snprint(p+len, READSTR-len, "transmit multiple collisions: %lu\n", dump[7]);
+	len += snprint(p+len, READSTR-len, "transmit total collisions: %lu\n", dump[8]);
+	len += snprint(p+len, READSTR-len, "receive good frames: %lu\n", dump[9]);
+	len += snprint(p+len, READSTR-len, "receive CRC errors: %lu\n", dump[10]);
+	len += snprint(p+len, READSTR-len, "receive alignment errors: %lu\n", dump[11]);
+	len += snprint(p+len, READSTR-len, "receive resource errors: %lu\n", dump[12]);
+	len += snprint(p+len, READSTR-len, "receive overrun errors: %lu\n", dump[13]);
+	len += snprint(p+len, READSTR-len, "receive collision detect errors: %lu\n", dump[14]);
+	len += snprint(p+len, READSTR-len, "receive short frame errors: %lu\n", dump[15]);
 	len += snprint(p+len, READSTR-len, "nop: %d\n", ctlr->nop);
 	if(ctlr->cbqmax > ctlr->cbqmaxhw)
 		ctlr->cbqmaxhw = ctlr->cbqmax;

sys/src/9/386/etherigbe.c

@@ -647,21 +647,21 @@ igbeifstat(Ether* edev, void* a, int32_t n, uint32_t offset)
 			ctlr->statistics[i] += r;
 			if(ctlr->statistics[i] == 0)
 				continue;
-			l += snprint(p+l, READSTR-l, "%s: %ud %ud\n",
+			l += snprint(p+l, READSTR-l, "%s: %u %u\n",
 				s, ctlr->statistics[i], r);
 			break;
 		}
 	}
 
-	l += snprint(p+l, READSTR-l, "lintr: %ud %ud\n",
+	l += snprint(p+l, READSTR-l, "lintr: %u %u\n",
 		ctlr->lintr, ctlr->lsleep);
-	l += snprint(p+l, READSTR-l, "rintr: %ud %ud\n",
+	l += snprint(p+l, READSTR-l, "rintr: %u %u\n",
 		ctlr->rintr, ctlr->rsleep);
-	l += snprint(p+l, READSTR-l, "tintr: %ud %ud\n",
+	l += snprint(p+l, READSTR-l, "tintr: %u %u\n",
 		ctlr->tintr, ctlr->txdw);
-	l += snprint(p+l, READSTR-l, "ixcs: %ud %ud %ud\n",
+	l += snprint(p+l, READSTR-l, "ixcs: %u %u %u\n",
 		ctlr->ixsm, ctlr->ipcs, ctlr->tcpcs);
-	l += snprint(p+l, READSTR-l, "rdtr: %ud\n", ctlr->rdtr);
+	l += snprint(p+l, READSTR-l, "rdtr: %u\n", ctlr->rdtr);
 	l += snprint(p+l, READSTR-l, "Ctrlext: %08x\n", csr32r(ctlr, Ctrlext));
 
 	l += snprint(p+l, READSTR-l, "eeprom:");

sys/src/9/386/etherm10g.c

@@ -319,11 +319,11 @@ pciecap(Pcidev *p, int cap)
 	off = 0x100;
 	while(((i = pcicfgr32(p, off))&0xffff) != cap){
 		off = i >> 20;
-		print("pciecap offset = %ud\n",  off);
+		print("pciecap offset = %u\n",  off);
 		if(off < 0x100 || off >= 4*KiB - 1)
 			return 0;
 	}
-	print("pciecap found = %ud\n",  off);
+	print("pciecap found = %u\n",  off);
 	return off;
 }
 
@@ -363,7 +363,7 @@ whichfw(Pcidev *p)
 	if(off != 0){
 		off += AercCCR;
 		cap = pcicfgr32(p, off);
-		print("%ud cap\n", cap);
+		print("%u cap\n", cap);
 	}
 	ecrc = (cap>>4) & 0xf;
 	/* if we don't like the aerc, kick it here. */
@@ -510,13 +510,13 @@ cmd(Ctlr *c, int type, uint64_t data)
 			i = gbit32(cmd->c);
 			qunlock(&c->cmdl);
 			if(cmd->i[1] != 0)
-				dprint("[%ux]", i);
+				dprint("[%x]", i);
 			return i;
 		}
 		tsleep(&up->sleep, return0, 0, 1);
 	}
 	qunlock(&c->cmdl);
-	iprint("m10g: cmd timeout [%ux %ux] cmd=%d\n",
+	iprint("m10g: cmd timeout [%x %x] cmd=%d\n",
 		cmd->i[0], cmd->i[1], type);
 	error(Etimeout);
 	return ~0;			/* silence! */
@@ -550,13 +550,13 @@ maccmd(Ctlr *c, int type, uint8_t *mac)
 			i = gbit32(cmd->c);
 			qunlock(&c->cmdl);
 			if(cmd->i[1] != 0)
-				dprint("[%ux]", i);
+				dprint("[%x]", i);
 			return i;
 		}
 		tsleep(&up->sleep, return0, 0, 1);
 	}
 	qunlock(&c->cmdl);
-	iprint("m10g: maccmd timeout [%ux %ux] cmd=%d\n",
+	iprint("m10g: maccmd timeout [%x %x] cmd=%d\n",
 		cmd->i[0], cmd->i[1], type);
 	error(Etimeout);
 	return ~0;			/* silence! */
@@ -685,7 +685,7 @@ bootfw(Ctlr *c)
 			break;
 		delay(1);
 	}
-	dprint("[%ux %ux]", gbit32(cmd->c), gbit32(cmd->c+4));
+	dprint("[%x %x]", gbit32(cmd->c), gbit32(cmd->c+4));
 	if(i == 20){
 		print("m10g: cannot load fw\n");
 		return -1;
@@ -706,7 +706,7 @@ kickthebaby(Pcidev *p, Ctlr *c)
 	pcicfgw32(p, 0x18 + c->boot, 0xfffffff0);
 	code = pcicfgr32(p, 0x14 + c->boot);
 
-	dprint("reboot status = %ux\n", code);
+	dprint("reboot status = %x\n", code);
 	if(code != 0xfffffff0)
 		return -1;
 	return 0;
@@ -763,7 +763,7 @@ chkfw(Ctlr *c)
 	type = gbit32(h->type);
 	dprint("\t" "type	%s\n", fwtype(type));
 	dprint("\t" "vers	%s\n", h->version);
-	dprint("\t" "ramsz	%ux\n", gbit32(h->ramsz));
+	dprint("\t" "ramsz	%x\n", gbit32(h->ramsz));
 	if(type != Teth){
 		print("!m10g: bad card type %s\n", fwtype(type));
 		return -1;
@@ -800,11 +800,11 @@ reset(Ether *e, Ctlr *c)
 	rdmacmd(c, 1);
 	sz = c->tx.segsz;
 	i = dmatestcmd(c, DMAread, c->done.busaddr, sz);
-	print("\t" "read: %ud MB/s\n", ((i>>16)*sz*2)/(i&0xffff));
+	print("\t" "read: %u MB/s\n", ((i>>16)*sz*2)/(i&0xffff));
 	i = dmatestcmd(c, DMAwrite, c->done.busaddr, sz);
-	print("\t" "write: %ud MB/s\n", ((i>>16)*sz*2)/(i&0xffff));
+	print("\t" "write: %u MB/s\n", ((i>>16)*sz*2)/(i&0xffff));
 	i = dmatestcmd(c, DMAwrite|DMAread, c->done.busaddr, sz);
-	print("\t" "r/w: %ud MB/s\n", ((i>>16)*sz*2*2)/(i&0xffff));
+	print("\t" "r/w: %u MB/s\n", ((i>>16)*sz*2*2)/(i&0xffff));
 	memset(c->done.entry, 0, c->done.n * sizeof *c->done.entry);
 
 	maccmd(c, CSmac, c->ra);
@@ -850,7 +850,7 @@ setmem(Pcidev *p, Ctlr *c)
 		print("m10g: can't map %8.8lux\n", p->mem[0].bar);
 		return -1;
 	}
-	dprint("%llux <- vmap(mem[0].size = %ux)\n", raddr, p->mem[0].size);
+	dprint("%llux <- vmap(mem[0].size = %x)\n", raddr, p->mem[0].size);
 	c->port = raddr;
 	c->ram = mem;
 	c->cmd = malign(sizeof *c->cmd);
@@ -1149,7 +1149,7 @@ txcleanup(Tx *tx, uint32_t n)
 		if(tx->cnt == tx->i)
 			return;
 		if(l++ == m){
-			iprint("tx ovrun: %ud %uld\n", n, tx->npkt);
+			iprint("tx ovrun: %u %lu\n", n, tx->npkt);
 			return;
 		}
 	}
@@ -1414,18 +1414,18 @@ m10gifstat(Ether *e, void *v, int32_t n, uint32_t off)
 
 	// l +=
 	snprint(p+l, lim,
-		"txcnt = %ud\n"	  "linkstat = %ud\n" 	"dlink = %ud\n"
-		"derror = %ud\n"  "drunt = %ud\n" 	"doverrun = %ud\n"
-		"dnosm = %ud\n"	  "dnobg = %ud\n"	"nrdma = %ud\n"
-		"txstopped = %ud\n" "down = %ud\n" 	"updated = %ud\n"
-		"valid = %ud\n\n"
-		"tx pkt = %uld\n" "tx bytes = %lld\n"
-		"tx cnt = %ud\n"  "tx n = %ud\n"	"tx i = %ud\n"
-		"sm cnt = %ud\n"  "sm i = %ud\n"	"sm n = %ud\n"
-		"sm lst = %ud\n"
-		"bg cnt = %ud\n"  "bg i = %ud\n"	"bg n = %ud\n"
-		"bg lst = %ud\n"
-		"segsz = %ud\n"   "coal = %d\n",
+		"txcnt = %u\n"	  "linkstat = %u\n" 	"dlink = %u\n"
+		"derror = %u\n"  "drunt = %u\n" 	"doverrun = %u\n"
+		"dnosm = %u\n"	  "dnobg = %u\n"	"nrdma = %u\n"
+		"txstopped = %u\n" "down = %u\n" 	"updated = %u\n"
+		"valid = %u\n\n"
+		"tx pkt = %lu\n" "tx bytes = %lld\n"
+		"tx cnt = %u\n"  "tx n = %u\n"	"tx i = %u\n"
+		"sm cnt = %u\n"  "sm i = %u\n"	"sm n = %u\n"
+		"sm lst = %u\n"
+		"bg cnt = %u\n"  "bg i = %u\n"	"bg n = %u\n"
+		"bg lst = %u\n"
+		"segsz = %u\n"   "coal = %d\n",
 		gbit32(s.txcnt),  gbit32(s.linkstat),	gbit32(s.dlink),
 		gbit32(s.derror), gbit32(s.drunt),	gbit32(s.doverrun),
 		gbit32(s.dnosm),  gbit32(s.dnobg),	gbit32(s.nrdma),

sys/src/9/386/sdiahci.c

@@ -1323,7 +1323,7 @@ isctlrjabbering(Ctlr *c, uint32_t cause)
 		c->lastintr0 = now;
 	}
 	if (++c->intrs > Maxintrspertick) {
-		iprint("sdiahci: %lud intrs per tick for no serviced "
+		iprint("sdiahci: %lu intrs per tick for no serviced "
 			"drive; cause %#lux mport %d\n",
 			c->intrs, cause, c->mport);
 		c->intrs = 0;
@@ -1341,7 +1341,7 @@ isdrivejabbering(Drive *d)
 		d->lastintr0 = now;
 	}
 	if (++d->intrs > Maxintrspertick) {
-		iprint("sdiahci: %lud interrupts per tick for %s\n",
+		iprint("sdiahci: %lu interrupts per tick for %s\n",
 			d->intrs, d->unit->SDperm.name);
 		d->intrs = 0;
 	}
@@ -2194,7 +2194,7 @@ print("iarctl: nil u->dev->ctlr\n");
 		o->ci, o->isr, o->sig, o->sstatus);
 	if(d->unit == nil)
 		panic("iarctl: nil d->unit");
-	p = seprint(p, e, "geometry %llud %lud\n", d->sectors, d->unit->secsize);
+	p = seprint(p, e, "geometry %llud %lu\n", d->sectors, d->unit->secsize);
 	return p - op;
 }
 

sys/src/9/386/uartpci.c

@@ -30,7 +30,7 @@ uartpci(int ctlrno, Pcidev* p, int barno, int n, int freq, char* name)
 	io = p->mem[barno].bar & ~0x01;
 	snprint(buf, sizeof(buf), "%s%d", pciphysuart.name, ctlrno);
 	if(ioalloc(io, p->mem[barno].size, 0, buf) < 0){
-		print("uartpci: I/O 0x%uX in use\n", io);
+		print("uartpci: I/O 0x%X in use\n", io);
 		return nil;
 	}
 

sys/src/9/amd64/acore.c

@@ -185,7 +185,7 @@ actrap(Ureg *u)
 	if(u->type < nelem(acvctl)){
 		v = acvctl[u->type];
 		if(v != nil){
-			DBG("actrap: cpu%d: %ulld\n", machp()->machno, u->type);
+			DBG("actrap: cpu%d: %llu\n", machp()->machno, u->type);
 			n = v->f(u, v->a);
 			if(n != nil)
 				goto Post;
@@ -212,7 +212,7 @@ actrap(Ureg *u)
 		DBG("actrap: cpu%d: PF cr2 %#ullx\n", machp()->machno, cr2get());
 		break;
 	default:
-		print("actrap: cpu%d: %ulld\n", machp()->machno, u->type);
+		print("actrap: cpu%d: %llu\n", machp()->machno, u->type);
 	}
 Post:
 	m->NIX.icc->rc = ICCTRAP;

sys/src/9/amd64/acore.c.old

@@ -109,7 +109,7 @@ actrap(Ureg *u)
 		print("actrap: cpu%d: PF\n", machp()->machno);
 		break;
 	default:
-		print("actrap: cpu%d: %ulld\n", machp()->machno, u->type);
+		print("actrap: cpu%d: %llu\n", machp()->machno, u->type);
 	}
 	m->icc->rc = ICCTRAP;
 	m->cr2 = cr2get();
@@ -311,7 +311,7 @@ kproc("testproc", testproc, up);
 		switch(rc){
 		case ICCTRAP:
 			m->cr2 = up->ac->cr2;
-			DBG("runacore: trap %ulld cr2 %#ullx ureg %#p\n",
+			DBG("runacore: trap %llu cr2 %#ullx ureg %#p\n",
 				ureg->type, m->cr2, ureg);
 			if(ureg->type == IdtIPI){
 				if(up->procctl || up->nnote)

sys/src/9/amd64/asm.c

@@ -301,7 +301,7 @@ asmwalkalloc(usize size)
 	assert(size == PTSZ && sys->vmunused+size <= sys->vmunmapped);
 
 	if(!ALIGNED(sys->vmunused, PTSZ)){
-		DBG("asmwalkalloc: %ulld wasted\n",
+		DBG("asmwalkalloc: %llu wasted\n",
 			ROUNDUP(sys->vmunused, PTSZ) - sys->vmunused);
 		sys->vmunused = ROUNDUP(sys->vmunused, PTSZ);
 	}
@@ -411,7 +411,7 @@ asmmeminit(void)
 //  hi = 600*MiB;
 		conf.mem[cx].npage = (hi - lo)/PGSZ;
 		conf.npage += conf.mem[cx].npage;
-		print("cm %d: addr %#llux npage %lud\n",
+		print("cm %d: addr %#llux npage %lu\n",
 			cx, conf.mem[cx].base, conf.mem[cx].npage);
 		cx++;
 #endif /* ConfCrap */
@@ -426,7 +426,7 @@ asmmeminit(void)
 	conf.upages = conf.npage;
 	i = (sys->vmend - sys->vmstart)/PGSZ;		/* close enough */
 	conf.ialloc = (i/2)*PGSZ;
-	print("npage %llud upage %lud kpage %d\n",
+	print("npage %llud upage %lu kpage %d\n",
 		conf.npage, conf.upages, i);
 
 #endif /* ConfCrap */

sys/src/9/amd64/devacpi.c

@@ -132,7 +132,7 @@ acpirsdptr(void)
 #if 0
 	assert(sizeof(Sdthdr) == 36);
 
-	DBG("acpi: RSD PTR@ %#p, physaddr %#ux length %ud %#llux rev %d\n",
+	DBG("acpi: RSD PTR@ %#p, physaddr %#ux length %u %#llux rev %d\n",
 		rsd, l32get(rsd->raddr), l32get(rsd->length),
 		l64get(rsd->xaddr), rsd->revision);
 

sys/src/9/amd64/devarch.c

@@ -531,7 +531,7 @@ cputyperead(Chan* c, void *a, int32_t n, int64_t off)
 	int i, k;
 
 	e = buf+sizeof buf;
-	s = seprint(buf, e, "%s %ud\n", "AMD64", machp()->cpumhz);
+	s = seprint(buf, e, "%s %u\n", "AMD64", machp()->cpumhz);
 	k = machp()->CPU.ncpuinfoe - machp()->CPU.ncpuinfos;
 	if(k > 4)
 		k = 4;

sys/src/9/amd64/devusb.c

@@ -308,7 +308,7 @@ seprintep(char *s, char *se, Ep *ep, int all)
 	else
 		s = seprint(s, se, " idle");
 	if(all){
-		s = seprint(s, se, " load %uld", ep->load);
+		s = seprint(s, se, " load %lu", ep->load);
 		s = seprint(s, se, " ref %ld addr %#p", ep->r.ref, ep);
 		s = seprint(s, se, " idx %d", ep->idx);
 		if(ep->name != nil)

sys/src/9/amd64/devvga.c

@@ -235,12 +235,12 @@ vgaread(Chan* c, void* a, int32_t n, int64_t off)
 					physgscreenr.max.x, physgscreenr.max.y);
 		}
 
-		len += snprint(p+len, READSTR-len, "blank time %lud idle %d state %s\n",
+		len += snprint(p+len, READSTR-len, "blank time %lu idle %d state %s\n",
 			blanktime, drawidletime(), scr->isblank ? "off" : "on");
 		len += snprint(p+len, READSTR-len, "hwaccel %s\n", hwaccel ? "on" : "off");
 		len += snprint(p+len, READSTR-len, "hwblank %s\n", hwblank ? "on" : "off");
 		len += snprint(p+len, READSTR-len, "panning %s\n", panning ? "on" : "off");
-		len += snprint(p+len, READSTR-len, "addr p 0x%lux v 0x%p size 0x%ux\n", scr->paddr, scr->vaddr, scr->apsize);
+		len += snprint(p+len, READSTR-len, "addr p 0x%lux v 0x%p size 0x%x\n", scr->paddr, scr->vaddr, scr->apsize);
 		USED(len);
 
 		n = readstr(offset, a, n, p);

sys/src/9/amd64/ether8139.c

@@ -323,7 +323,7 @@ rtl8139ifstat(Ether* edev, void* a, int32_t n, uint32_t offset)
 	if(p == nil)
 		error(Enomem);
 	l = snprint(p, READSTR, "rcr %#8.8ux\n", ctlr->rcr);
-	l += snprint(p+l, READSTR-l, "multicast %ud\n", ctlr->mcast);
+	l += snprint(p+l, READSTR-l, "multicast %u\n", ctlr->mcast);
 	l += snprint(p+l, READSTR-l, "ierrs %d\n", ctlr->ierrs);
 	l += snprint(p+l, READSTR-l, "etxth %d\n", ctlr->etxth);
 	l += snprint(p+l, READSTR-l, "taligned %d\n", ctlr->taligned);

sys/src/9/amd64/ether82563.c

@@ -703,16 +703,16 @@ i82563ifstat(Ether* edev, void* a, int32_t n, uint32_t offset)
 			ctlr->statistics[i] += r;
 			if(ctlr->statistics[i] == 0)
 				continue;
-			p = seprint(p, e, "%s: %ud %ud\n", stat,
+			p = seprint(p, e, "%s: %u %u\n", stat,
 				ctlr->statistics[i], r);
 			break;
 		}
 	}
 
-	p = seprint(p, e, "lintr: %ud %ud\n", ctlr->lintr, ctlr->lsleep);
-	p = seprint(p, e, "rintr: %ud %ud\n", ctlr->rintr, ctlr->rsleep);
-	p = seprint(p, e, "tintr: %ud %ud\n", ctlr->tintr, ctlr->txdw);
-	p = seprint(p, e, "ixcs: %ud %ud %ud\n", ctlr->ixsm, ctlr->ipcs, ctlr->tcpcs);
+	p = seprint(p, e, "lintr: %u %u\n", ctlr->lintr, ctlr->lsleep);
+	p = seprint(p, e, "rintr: %u %u\n", ctlr->rintr, ctlr->rsleep);
+	p = seprint(p, e, "tintr: %u %u\n", ctlr->tintr, ctlr->txdw);
+	p = seprint(p, e, "ixcs: %u %u %u\n", ctlr->ixsm, ctlr->ipcs, ctlr->tcpcs);
 	p = seprint(p, e, "ctrl: %.8ux\n", csr32r(ctlr, Ctrl));
 	p = seprint(p, e, "ctrlext: %.8ux\n", csr32r(ctlr, Ctrlext));
 	p = seprint(p, e, "status: %.8ux\n", csr32r(ctlr, Status));
@@ -721,7 +721,7 @@ i82563ifstat(Ether* edev, void* a, int32_t n, uint32_t offset)
 	p = seprint(p, e, "pbs: %dKB\n", ctlr->pbs);
 	p = seprint(p, e, "pba: %#.8ux\n", ctlr->pba);
 
-	p = seprint(p, e, "speeds: 10:%ud 100:%ud 1000:%ud ?:%ud\n",
+	p = seprint(p, e, "speeds: 10:%u 100:%u 1000:%u ?:%u\n",
 		ctlr->speeds[0], ctlr->speeds[1], ctlr->speeds[2], ctlr->speeds[3]);
 	p = seprint(p, e, "type: %s\n", tname[ctlr->type]);
 	p = seprint(p, e, "nrbfull (rcv blocks outstanding): %d\n", nrbfull);

sys/src/9/amd64/mmu.c

@@ -646,7 +646,7 @@ vmap(uintptr_t pa, usize size)
 	uintptr_t va;
 	usize o, sz;
 
-	DBG("vmap(%#p, %lud) pc=%#p\n", pa, size, getcallerpc(&pa));
+	DBG("vmap(%#p, %lu) pc=%#p\n", pa, size, getcallerpc());
 
 	if(machp()->machno != 0)
 		print("vmap: machp()->machno != 0");
@@ -677,7 +677,7 @@ vmap(uintptr_t pa, usize size)
 	sz = ROUNDUP(size+o, PGSZ);
 
 	if(pa == 0){
-		print("vmap(0, %lud) pc=%#p\n", size, getcallerpc(&pa));
+		print("vmap(0, %lu) pc=%#p\n", size, getcallerpc());
 		return nil;
 	}
 	ilock(&vmaplock);
@@ -687,7 +687,7 @@ vmap(uintptr_t pa, usize size)
 	}
 	iunlock(&vmaplock);
 
-	DBG("vmap(%#p, %lud) => %#p\n", pa+o, size, va+o);
+	DBG("vmap(%#p, %lu) => %#p\n", pa+o, size, va+o);
 
 	return UINT2PTR(va + o);
 }
@@ -697,7 +697,7 @@ vunmap(void* v, usize size)
 {
 	uintptr_t va;
 
-	DBG("vunmap(%#p, %lud)\n", v, size);
+	DBG("vunmap(%#p, %lu)\n", v, size);
 
 	if(machp()->machno != 0)
 		print("vmap: machp()->machno != 0");
@@ -714,7 +714,7 @@ vunmap(void* v, usize size)
 	 * resources used for the allocation (e.g. page table
 	 * pages).
 	 */
-	DBG("vunmap(%#p, %lud)\n", v, size);
+	DBG("vunmap(%#p, %lu)\n", v, size);
 }
 
 int

sys/src/9/amd64/mp.c

@@ -423,7 +423,7 @@ mpsinit(int maxcores)
 		panic("NO _MP_ table");
 	}
 	if(DBGFLG){
-		DBG("_MP_ @ %#p, addr %#ux length %ud rev %d",
+		DBG("_MP_ @ %#p, addr %#ux length %u rev %d",
 			mp, l32get(mp->addr), mp->length, mp->revision);
 		for(i = 0; i < sizeof(mp->feature); i++)
 			DBG(" %2.2#ux", mp->feature[i]);

sys/src/9/amd64/multiboot.c

@@ -112,7 +112,7 @@ multiboot(uint32_t magic, uint32_t pmbi, int vflag)
 			switch(mmap->type){
 			default:
 				if(vflag)
-					print("type %ud", mmap->type);
+					print("type %u", mmap->type);
 				break;
 			case 1:
 				if(vflag)

sys/src/9/amd64/physalloc.c

@@ -81,7 +81,7 @@ seprintphysstats(char *s,  char *e)
 	for(i = 0; i < Ndoms; i++){
 		b = &bal[i];
 		if(b->size > 0)
-			s = seprint(s, e, "%uld/%uld %ulldK color %d blocks avail\n",
+			s = seprint(s, e, "%lu/%lu %lluK color %d blocks avail\n",
 				b->nfree, b->nblocks, b->bminsz/KiB, i);
 	}
 	unlock(&budlock);
@@ -114,7 +114,7 @@ S1:
 	 */
 	l = &blocks[BLOCK(b,i)];
 	l->p = nil;
-	DBG("\tbsl: BLOCK(b,i) %d index %ulld kval %d\n",
+	DBG("\tbsl: BLOCK(b,i) %d index %llu kval %d\n",
 		BLOCK(b,i), BLOCK(b,i)/((1<<l->kval)/b->bminsz), l->kval);
 	if((BLOCK(b,i)/((1<<l->kval)/b->bminsz)) & 1)	/* simpler test? */
 		p = l - (1<<l->kval)/b->bminsz;
@@ -514,7 +514,7 @@ physinit(uintmem a, uint64_t size)
 			if(!ISPOWEROF2(sys->pmend))
 				b->kspan++;
 			dtsz = sizeof(Buddy)*(UNO<<(b->kspan-b->kmin+1));
-			DBG("kspan %ud (arrysz = %llud)\n", b->kspan, dtsz);
+			DBG("kspan %u (arrysz = %llud)\n", b->kspan, dtsz);
 			b->blocks = malloc(dtsz);
 			if(b->blocks == nil)
 				panic("physinit: no blocks");

sys/src/9/amd64/qmalloc.c

@@ -418,7 +418,7 @@ mallocreadfmt(char* s, char* e)
 		QLOCK(&qlist->lk);
 		for(q = qlist->first; q != nil; q = q->s.next){
 //			if(q->s.size != i)
-//				p = seprint(p, e, "q%d\t%#p\t%ud\n",
+//				p = seprint(p, e, "q%d\t%#p\t%u\n",
 //					i, q, q->s.size);
 			n++;
 		}
@@ -428,7 +428,7 @@ mallocreadfmt(char* s, char* e)
 //			p = seprint(p, e, "q%d %d\n", i, n);
 		t += n * i*sizeof(Header);
 	}
-	p = seprint(p, e, "quick: %ud bytes total\n", t);
+	p = seprint(p, e, "quick: %u bytes total\n", t);
 
 	MLOCK;
 	if((q = rover) != nil){
@@ -439,16 +439,16 @@ mallocreadfmt(char* s, char* e)
 //			p = seprint(p, e, "m%d\t%#p\n", q->s.size, q);
 		} while((q = q->s.next) != rover);
 
-		p = seprint(p, e, "rover: %d blocks %ud bytes total\n",
+		p = seprint(p, e, "rover: %d blocks %u bytes total\n",
 			i, t*sizeof(Header));
 	}
-	p = seprint(p, e, "total allocated %lud, %ud remaining\n",
+	p = seprint(p, e, "total allocated %lu, %u remaining\n",
 		(tailptr-tailbase)*sizeof(Header), tailnunits*sizeof(Header));
 
 	for(i = 0; i < nelem(qstats); i++){
 		if(qstats[i] == 0)
 			continue;
-		p = seprint(p, e, "%s %ud\n", qstatstr[i], qstats[i]);
+		p = seprint(p, e, "%s %u\n", qstatstr[i], qstats[i]);
 	}
 	MUNLOCK;
 }
@@ -480,14 +480,14 @@ mallocsummary(void)
 		QLOCK(&qlist->lk);
 		for(q = qlist->first; q != nil; q = q->s.next){
 			if(q->s.size != i)
-				DBG("q%d\t%#p\t%ud\n", i, q, q->s.size);
+				DBG("q%d\t%#p\t%u\n", i, q, q->s.size);
 			n++;
 		}
 		QUNLOCK(&qlist->lk);
 
 		t += n * i*sizeof(Header);
 	}
-	print("quick: %ud bytes total\n", t);
+	print("quick: %u bytes total\n", t);
 
 	MLOCK;
 	if((q = rover) != nil){
@@ -500,16 +500,16 @@ mallocsummary(void)
 	MUNLOCK;
 
 	if(i != 0){
-		print("rover: %d blocks %ud bytes total\n",
+		print("rover: %d blocks %u bytes total\n",
 			i, t*sizeof(Header));
 	}
-	print("total allocated %lud, %ud remaining\n",
+	print("total allocated %lu, %u remaining\n",
 		(tailptr-tailbase)*sizeof(Header), tailnunits*sizeof(Header));
 
 	for(i = 0; i < nelem(qstats); i++){
 		if(qstats[i] == 0)
 			continue;
-		print("%s %ud\n", qstatstr[i], qstats[i]);
+		print("%s %u\n", qstatstr[i], qstats[i]);
 	}
 }
 
@@ -664,7 +664,7 @@ mallocinit(void)
 	tailbase = UINT2PTR(sys->vmunused);
 	tailptr = tailbase;
 	tailnunits = NUNITS(sys->vmend - sys->vmunused);
-	print("base %#p ptr %#p nunits %ud\n", tailbase, tailptr, tailnunits);
+	print("base %#p ptr %#p nunits %u\n", tailbase, tailptr, tailnunits);
 }
 
 static int

sys/src/9/amd64/sdata.c

@@ -390,7 +390,7 @@ atadumpstate(Drive* drive, uint8_t* cmd, int64_t lba, int count)
 
 	ctlr = drive->ctlr;
 	print("sdata: command %2.2uX\n", ctlr->command);
-	print("data %8.8p limit %8.8p dlen %d status %uX error %uX\n",
+	print("data %8.8p limit %8.8p dlen %d status %X error %X\n",
 		drive->data, drive->limit, drive->dlen,
 		drive->status, drive->error);
 	if(cmd != nil){
@@ -444,7 +444,7 @@ atadebug(int cmdport, int ctlport, char* fmt, ...)
 	if(cmdport){
 		if(buf[n-1] == '\n')
 			n--;
-		n += snprint(buf+n, PRINTSIZE-n, " ataregs 0x%uX:",
+		n += snprint(buf+n, PRINTSIZE-n, " ataregs 0x%X:",
 			cmdport);
 		for(i = Features; i < Command; i++)
 			n += snprint(buf+n, PRINTSIZE-n, " 0x%2.2uX",
@@ -464,7 +464,7 @@ ataready(int cmdport, int ctlport, int dev, int reset, int ready, int micro)
 {
 	int as;
 
-	atadebug(cmdport, ctlport, "ataready: dev %uX reset %uX ready %uX",
+	atadebug(cmdport, ctlport, "ataready: dev %X reset %X ready %X",
 		dev, reset, ready);
 
 	for(;;){
@@ -647,7 +647,7 @@ atadrive(int cmdport, int ctlport, int dev)
 	uint8_t *p;
 	uint16_t iconfig, *sp;
 
-	atadebug(0, 0, "identify: port 0x%uX dev 0x%2.2uX\n", cmdport, dev);
+	atadebug(0, 0, "identify: port 0x%X dev 0x%2.2uX\n", cmdport, dev);
 	pkt = 1;
 retry:
 	as = ataidentify(cmdport, ctlport, dev, pkt, buf);
@@ -725,12 +725,12 @@ retry:
 	atadmamode(drive);
 
 	if(DEBUG & DbgCONFIG){
-		print("dev %2.2uX port %uX config %4.4uX capabilities %4.4uX",
+		print("dev %2.2uX port %X config %4.4uX capabilities %4.4uX",
 			dev, cmdport, iconfig, drive->info[Icapabilities]);
 		print(" mwdma %4.4uX", drive->info[Imwdma]);
 		if(drive->info[Ivalid] & 0x04)
 			print(" udma %4.4uX", drive->info[Iudma]);
-		print(" dma %8.8uX rwm %ud", drive->dma, drive->rwm);
+		print(" dma %8.8uX rwm %u", drive->dma, drive->rwm);
 		if(drive->flags&Lba48)
 			print("\tLLBA sectors %lld", drive->sectors);
 		print("\n");
@@ -852,7 +852,7 @@ tryedd1:
 	 * exist and the EDD won't take, so try again with Dev1.
 	 */
 	error = inb(cmdport+Error);
-	atadebug(cmdport, ctlport, "ataprobe: dev %uX", dev);
+	atadebug(cmdport, ctlport, "ataprobe: dev %X", dev);
 	if((error & ~0x80) != 0x01){
 		if(dev == Dev1)
 			goto release;
@@ -961,7 +961,7 @@ atastat(SDev *sdev, char *p, char *e)
 	Ctlr *ctlr = sdev->ctlr;
 
 	return seprint(p, e, "%s ata port %X ctl %X irq %d "
-		"intr-ok %lud intr-busy %lud intr-nil-drive %lud\n",
+		"intr-ok %lu intr-busy %lu intr-nil-drive %lu\n",
 		sdev->name, ctlr->cmdport, ctlr->ctlport, ctlr->irq,
 		ctlr->intok, ctlr->intbusy, ctlr->intnil);
 }
@@ -2262,13 +2262,13 @@ atarctl(SDunit* unit, char* p, int l)
 		n += snprint(p+n, l-n, " dma %8.8uX dmactl %8.8uX",
 			drive->dma, drive->dmactl);
 	if(drive->rwm)
-		n += snprint(p+n, l-n, " rwm %ud rwmctl %ud",
+		n += snprint(p+n, l-n, " rwm %u rwmctl %u",
 			drive->rwm, drive->rwmctl);
 	if(drive->flags&Lba48)
 		n += snprint(p+n, l-n, " lba48always %s",
 			(drive->flags&Lba48always) ? "on" : "off");
 	n += snprint(p+n, l-n, "\n");
-	n += snprint(p+n, l-n, "interrupts read %lud write %lud cmds %lud\n",
+	n += snprint(p+n, l-n, "interrupts read %lu write %lu cmds %lu\n",
 		drive->intrd, drive->intwr, drive->intcmd);
 	if(drive->sectors){
 		n += snprint(p+n, l-n, "geometry %lld %d",

sys/src/9/amd64/tcore.c

@@ -260,7 +260,7 @@ runacore(void)
 		case ICCTRAP:
 			s = splhi();
 			machp()->MMU.cr2 = up->ac->MMU.cr2;
-			DBG("runacore: trap %ulld cr2 %#ullx ureg %#p\n",
+			DBG("runacore: trap %llu cr2 %#ullx ureg %#p\n",
 				ureg->type, machp()->MMU.cr2, ureg);
 			switch(ureg->type){
 			case IdtIPI:

sys/src/9/amd64/usbehcipc.c

@@ -254,7 +254,7 @@ reset(Hci *hp)
 	capio = ctlr->capio;
 	hp->nports = capio->parms & Cnports;
 
-	ddprint("echi: %s, ncc %lud npcc %lud\n",
+	ddprint("echi: %s, ncc %lu npcc %lu\n",
 		capio->parms & 0x10000 ? "leds" : "no leds",
 		(capio->parms >> 12) & 0xf, (capio->parms >> 8) & 0xf);
 	ddprint("ehci: routing %s, %sport power ctl, %d ports\n",

sys/src/9/amd64/usbohci.c

@@ -848,10 +848,10 @@ seprinttd(char *s, char *e, Td *td, int iso)
 			s = seprint(s, e, " d%d", (td->ctrl & Tddata1) ? 1 : 0);
 		else
 			s = seprint(s, e, " d-");
-		s = seprint(s, e, " ec=%uld", (td->ctrl >> Tderrshift) & Tderrmask);
+		s = seprint(s, e, " ec=%lu", (td->ctrl >> Tderrshift) & Tderrmask);
 	}else{
-		s = seprint(s, e, " fc=%uld", (td->ctrl >> Tdfcshift) & Tdfcmask);
-		s = seprint(s, e, " sf=%uld", td->ctrl & Tdsfmask);
+		s = seprint(s, e, " fc=%lu", (td->ctrl >> Tdfcshift) & Tdfcmask);
+		s = seprint(s, e, " sf=%lu", td->ctrl & Tdsfmask);
 	}
 	s = seprint(s, e, " cbp0 %#p cbp %#p next %#p be %#p %s",
 		td->cbp0, td->cbp, td->nexttd, td->be, td->last ? "last" : "");
@@ -866,7 +866,7 @@ seprinttd(char *s, char *e, Td *td, int iso)
 	s = seprint(s, e, "\n\t\t");
 	/* we use only offsets[0] */
 	i = 0;
-	s = seprint(s, e, "[%d] %#ux cc=%#ux sz=%ud\n", i, td->offsets[i],
+	s = seprint(s, e, "[%d] %#ux cc=%#ux sz=%u\n", i, td->offsets[i],
 		(td->offsets[i] >> Tdiccshift) & Tdiccmask,
 		td->offsets[i] & 0x7FF);
 	return s;
@@ -929,8 +929,8 @@ dumped(Ed *ed)
 		s = seprint(s, e, " out");
 	if(edhalted(ed))
 		s = seprint(s, e, " hlt");
-	s = seprint(s, e, " ep%uld.%uld", (ed->ctrl>>7)&Epmax, ed->ctrl&0x7f);
-	s = seprint(s, e, " maxpkt %uld", (ed->ctrl>>Edmpsshift)&Edmpsmask);
+	s = seprint(s, e, " ep%lu.%lu", (ed->ctrl>>7)&Epmax, ed->ctrl&0x7f);
+	s = seprint(s, e, " maxpkt %lu", (ed->ctrl>>Edmpsshift)&Edmpsmask);
 	seprint(s, e, " tail %#p head %#p next %#p\n",ed->tail,ed->head,ed->nexted);
 	print("%s", buf);
 	free(buf);
@@ -977,7 +977,7 @@ seprintep(char* s, char* e, Ep *ep)
 	case Tiso:
 		iso = ep->aux;
 		s = seprintio(s, e, &iso->Qio, "w");
-		s = seprint(s, e, "\tntds %d avail %d frno %uld left %uld next avail %#p\n",
+		s = seprint(s, e, "\tntds %d avail %d frno %lu left %lu next avail %#p\n",
 			iso->nframes, iso->navail, iso->frno, iso->left, iso->atds);
 		break;
 	}
@@ -1074,7 +1074,7 @@ isodtdinit(Ep *ep, Isoio *iso, Td *td)
 	if(size > ep->maxpkt){
 		print("ohci: ep%d.%d: size > maxpkt\n",
 			ep->dev->nb, ep->nb);
-		print("size = %uld max = %ld\n", size, ep->maxpkt);
+		print("size = %lu max = %ld\n", size, ep->maxpkt);
 		size = ep->maxpkt;
 	}
 	td->nbytes = size;
@@ -1197,7 +1197,7 @@ qhinterrupt(Ctlr *ctrl, Ep *ep, Qio *io, Td *td, int n)
 		td->last = 1;
 		break;
 	default:
-		panic("ohci: td cc %ud unknown", err);
+		panic("ohci: td cc %u unknown", err);
 	}
 
 	if(td->last != 0){

sys/src/9/amd64/usbuhci.c

@@ -415,7 +415,7 @@ seprinttd(char *s, char *se, Td *td)
 		s = seprint(s, se, " BADPID");
 	}
 	s = seprint(s, se, "\n\t  buffer %#ulx data %#p", td->buffer, td->data);
-	s = seprint(s, se, " ndata %uld sbuff %#p buff %#p",
+	s = seprint(s, se, " ndata %lu sbuff %#p buff %#p",
 		td->ndata, td->sbuff, td->buff);
 	if(td->ndata > 0)
 		s = seprintdata(s, se, td->data, td->ndata);
@@ -838,7 +838,7 @@ isointerrupt(Ctlr *ctlr, Isoio* iso)
 				iso->err = errmsg(err);
 				diprint("isointerrupt: tdi %#p error %#ux %s\n",
 					tdi, err, iso->err);
-				diprint("ctlr load %uld\n", ctlr->load);
+				diprint("ctlr load %lu\n", ctlr->load);
 			}
 			tdi->ndata = 0;
 		}else
@@ -902,7 +902,7 @@ qhinterrupt(Ctlr *ctlr, Qh *qh)
 				qh->io->err = errmsg(td->csw & Tderrors);
 				dqprint("qhinterrupt: td %#p error %#ux %s\n",
 					td, err, qh->io->err);
-				dqprint("ctlr load %uld\n", ctlr->load);
+				dqprint("ctlr load %lu\n", ctlr->load);
 			}
 			break;
 		}
@@ -1228,7 +1228,7 @@ epiowait(Ctlr *ctlr, Qio *io, int tmout, uint32_t load)
 	int timedout;
 
 	qh = io->qh;
-	ddqprint("uhci io %#p sleep on qh %#p state %uld\n", io, qh, qh->state);
+	ddqprint("uhci io %#p sleep on qh %#p state %lu\n", io, qh, qh->state);
 	timedout = 0;
 	if(waserror()){
 		dqprint("uhci io %#p qh %#p timed out\n", io, qh);
@@ -1285,7 +1285,7 @@ epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
 	ctlr = ep->hp->Hciimpl.aux;
 	io->debug = ep->debug;
 	tmout = ep->tmout;
-	ddeprint("epio: %s ep%d.%d io %#p count %ld load %uld\n",
+	ddeprint("epio: %s ep%d.%d io %#p count %ld load %lu\n",
 		io->tok == Tdtokin ? "in" : "out",
 		ep->dev->nb, ep->nb, io, count, ctlr->load);
 	if((debug > 1 || ep->debug > 1) && io->tok != Tdtokin){
@@ -1333,7 +1333,7 @@ epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
 		panic("epio: no td");
 
 	ltd->csw |= Tdioc;	/* the last one interrupts */
-	ddeprint("uhci: load %uld ctlr load %uld\n", load, ctlr->load);
+	ddeprint("uhci: load %lu ctlr load %lu\n", load, ctlr->load);
 	ilock(&ctlr->l);
 	if(qh->state != Qclose){
 		io->iotime = TK2MS(machp()->ticks);
@@ -1655,7 +1655,7 @@ isoopen(Ep *ep)
 		print("usb: uhci: bandwidth may be exceeded\n");
 	ctlr->load += ep->load;
 	ctlr->isoload += ep->load;
-	dprint("uhci: load %uld isoload %uld\n", ctlr->load, ctlr->isoload);
+	dprint("uhci: load %lu isoload %lu\n", ctlr->load, ctlr->isoload);
 	iunlock(&ctlr->l);
 
 	/*

sys/src/9/boot/console.c

@@ -176,7 +176,7 @@ keybscan(uint8_t code, char *out, int len)
 	if(c > sizeof kbtab){
 		c |= keyup;
 		if(c != 0xFF)	/* these come fairly often: CAPSLOCK U Y */
-			fprint(2, "unknown key %ux\n", c);
+			debug("unknown key %x\n", c);
 		return off;
 	}
 

sys/src/9/boot/nopsession.c

@@ -40,7 +40,7 @@ rpc(int fd, int type)
 		l += n;
 	}
 	if(convM2S(buf, &hdr, n) == 0){
-		print("%ux %ux %ux\n", buf[0], buf[1], buf[2]);
+		print("%x %x %x\n", buf[0], buf[1], buf[2]);
 		fatal("rpc format");
 	}
 	if(hdr.tag != NOTAG)

sys/src/9/ip/chandial.c

@@ -76,7 +76,7 @@ call(char *clone, char *dest, DS *ds)
 	name[n] = 0;
 	for(p = name; *p == ' '; p++)
 		;
-	snprint(name, sizeof name, "%lud", strtoul(p, 0, 0));
+	snprint(name, sizeof name, "%lu", strtoul(p, 0, 0));
 	p = strrchr(clone, '/');
 	*p = 0;
 	if(ds->dir)

sys/src/9/ip/devip.c

@@ -194,7 +194,7 @@ ipgen(Chan *c, char* j, Dirtab* dir, int mm, int s, Dir *dp)
 	case Qtopdir:
 		if(s == DEVDOTDOT){
 			mkqid(&q, QID(0, 0, Qtopdir), 0, QTDIR);
-			snprint(up->genbuf, sizeof up->genbuf, "#I%lud", c->dev);
+			snprint(up->genbuf, sizeof up->genbuf, "#I%lu", c->dev);
 			devdir(c, q, up->genbuf, 0, network, 0555, dp);
 			return 1;
 		}
@@ -217,7 +217,7 @@ ipgen(Chan *c, char* j, Dirtab* dir, int mm, int s, Dir *dp)
 	case Qprotodir:
 		if(s == DEVDOTDOT){
 			mkqid(&q, QID(0, 0, Qtopdir), 0, QTDIR);
-			snprint(up->genbuf, sizeof up->genbuf, "#I%lud", c->dev);
+			snprint(up->genbuf, sizeof up->genbuf, "#I%lu", c->dev);
 			devdir(c, q, up->genbuf, 0, network, 0555, dp);
 			return 1;
 		}
@@ -661,7 +661,7 @@ ipread(Chan *ch, void *a, int32_t n, int64_t off)
 		return netlogread(f, a, offset, n);
 	case Qctl:
 		buf = smalloc(16);
-		snprint(buf, 16, "%lud", CONV(ch->qid));
+		snprint(buf, 16, "%lu", CONV(ch->qid));
 		rv = readstr(offset, p, n, buf);
 		free(buf);
 		return rv;

sys/src/9/ip/eipconvtest.c

@@ -92,7 +92,7 @@ common:
 				} else if(i != 0)
 					n += sprint(buf+n, ":");
 				s = (p[i]<<8) + p[i+1];
-				n += sprint(buf+n, "%ux", s);
+				n += sprint(buf+n, "%x", s);
 			}
 		}
 		break;

sys/src/9/ip/esp.c

@@ -445,7 +445,7 @@ espkick(void *x)
 		payload + pad + Esptaillen, auth);
 
 	qunlock(&c->ql);
-	/* print("esp: pass down: %uld\n", BLEN(bp)); */
+	/* print("esp: pass down: %lu\n", BLEN(bp)); */
 	if (vers.version == V4)
 		ipoput4(c->p->f, bp, 0, c->ttl, c->tos, c);
 	else
@@ -485,7 +485,7 @@ espiput(Proto *esp, Ipifc *ipifc, Block *bp)
 	c = convlookup(esp, vers.spi);
 	if(c == nil) {
 		qunlock(esp);
-		netlog(f, Logesp, "esp: no conv %I -> %I!%lud\n", vers.raddr,
+		netlog(f, Logesp, "esp: no conv %I -> %I!%lu\n", vers.raddr,
 			vers.laddr, vers.spi);
 		icmpnoconv(f, bp);
 		freeblist(bp);
@@ -502,7 +502,7 @@ espiput(Proto *esp, Ipifc *ipifc, Block *bp)
 
 	if(BLEN(bp) < vers.hdrlen + ecb->espivlen + Esptaillen + ecb->ahlen) {
 		qunlock(&c->ql);
-		netlog(f, Logesp, "esp: short block %I -> %I!%lud\n", vers.raddr,
+		netlog(f, Logesp, "esp: short block %I -> %I!%lu\n", vers.raddr,
 			vers.laddr, vers.spi);
 		freeb(bp);
 		return;
@@ -516,7 +516,7 @@ espiput(Proto *esp, Ipifc *ipifc, Block *bp)
 	if(!ecb->auth(ecb, espspi, auth - espspi, auth)) {
 		qunlock(&c->ql);
 print("esp: bad auth %I -> %I!%ld\n", vers.raddr, vers.laddr, vers.spi);
-		netlog(f, Logesp, "esp: bad auth %I -> %I!%lud\n", vers.raddr,
+		netlog(f, Logesp, "esp: bad auth %I -> %I!%lu\n", vers.raddr,
 			vers.laddr, vers.spi);
 		freeb(bp);
 		return;
@@ -525,7 +525,7 @@ print("esp: bad auth %I -> %I!%ld\n", vers.raddr, vers.laddr, vers.spi);
 	payload = BLEN(bp) - vers.hdrlen - ecb->ahlen;
 	if(payload <= 0 || payload % 4 != 0 || payload % ecb->espblklen != 0) {
 		qunlock(&c->ql);
-		netlog(f, Logesp, "esp: bad length %I -> %I!%lud payload=%d BLEN=%lud\n",
+		netlog(f, Logesp, "esp: bad length %I -> %I!%lu payload=%d BLEN=%lu\n",
 			vers.raddr, vers.laddr, vers.spi, payload, BLEN(bp));
 		freeb(bp);
 		return;
@@ -535,7 +535,7 @@ print("esp: bad auth %I -> %I!%ld\n", vers.raddr, vers.laddr, vers.spi);
 	if(!ecb->cipher(ecb, bp->rp + vers.hdrlen, payload)) {
 		qunlock(&c->ql);
 print("esp: cipher failed %I -> %I!%ld: %s\n", vers.raddr, vers.laddr, vers.spi, up->errstr);
-		netlog(f, Logesp, "esp: cipher failed %I -> %I!%lud: %s\n",
+		netlog(f, Logesp, "esp: cipher failed %I -> %I!%lu: %s\n",
 			vers.raddr, vers.laddr, vers.spi, up->errstr);
 		freeb(bp);
 		return;
@@ -547,7 +547,7 @@ print("esp: cipher failed %I -> %I!%ld: %s\n", vers.raddr, vers.laddr, vers.spi,
 	nexthdr = et->nexthdr;
 	if(payload <= 0) {
 		qunlock(&c->ql);
-		netlog(f, Logesp, "esp: short packet after decrypt %I -> %I!%lud\n",
+		netlog(f, Logesp, "esp: short packet after decrypt %I -> %I!%lu\n",
 			vers.raddr, vers.laddr, vers.spi);
 		freeb(bp);
 		return;
@@ -567,11 +567,11 @@ print("esp: cipher failed %I -> %I!%ld: %s\n", vers.raddr, vers.laddr, vers.spi,
 	/* ingress filtering here? */
 
 	if(qfull(c->rq)){
-		netlog(f, Logesp, "esp: qfull %I -> %I.%uld\n", vers.raddr,
+		netlog(f, Logesp, "esp: qfull %I -> %I.%lu\n", vers.raddr,
 			vers.laddr, vers.spi);
 		freeblist(bp);
 	}else {
-//		print("esp: pass up: %uld\n", BLEN(bp));
+//		print("esp: pass up: %lu\n", BLEN(bp));
 		qpass(c->rq, bp);	/* pass packet up the read queue */
 	}
 
@@ -623,7 +623,7 @@ espstats(Proto *esp, char *buf, int len)
 	Esppriv *upriv;
 
 	upriv = esp->priv;
-	return snprint(buf, len, "%llud %lud\n",
+	return snprint(buf, len, "%llud %lu\n",
 		upriv->in,
 		upriv->inerrors);
 }
@@ -636,7 +636,7 @@ esplocal(Conv *c, char *buf, int len)
 
 	qlock(&c->ql);
 	if(ecb->incoming)
-		n = snprint(buf, len, "%I!%uld\n", c->laddr, ecb->spi);
+		n = snprint(buf, len, "%I!%lu\n", c->laddr, ecb->spi);
 	else
 		n = snprint(buf, len, "%I\n", c->laddr);
 	qunlock(&c->ql);
@@ -653,7 +653,7 @@ espremote(Conv *c, char *buf, int len)
 	if(ecb->incoming)
 		n = snprint(buf, len, "%I\n", c->raddr);
 	else
-		n = snprint(buf, len, "%I!%uld\n", c->raddr, ecb->spi);
+		n = snprint(buf, len, "%I!%lu\n", c->raddr, ecb->spi);
 	qunlock(&c->ql);
 	return n;
 }

sys/src/9/ip/gre.c

@@ -230,8 +230,8 @@ grestate(Conv *c, char *state, int n)
 	grec = c->ptcl;
 	p    = state;
 	ep   = p + n;
-	p    = seprint(p, ep, "%s%s%s%shoa %V north %V south %V seq %ulx "
-	 "pending %uld  %uld buffered dl %uld %uld ul %uld %uld ulkey %.8ulx\n",
+	p    = seprint(p, ep, "%s%s%s%shoa %V north %V south %V seq %lx "
+	 "pending %lu  %lu buffered dl %lu %lu ul %lu %lu ulkey %.8ulx\n",
 			c->inuse? "Open ": "Closed ",
 			grec->raw? "raw ": "",
 			grec->dlsusp? "DL suspended ": "",
@@ -683,7 +683,7 @@ grestats(Proto *gre, char *buf, int len)
 
 	gpriv = gre->priv;
 	return snprint(buf, len,
-		"gre: %lud %lud %lud %lud %lud %lud %lud %lud, lenerrs %lud\n",
+		"gre: %lu %lu %lu %lu %lu %lu %lu %lu, lenerrs %lu\n",
 		grepdin, grepdout, grepuin, grepuout,
 		grebdin, grebdout, grebuin, grebuout, gpriv->lenerr);
 }

sys/src/9/ip/icmp.c

@@ -465,12 +465,12 @@ icmpstats(Proto *icmp, char *buf, int len)
 	p = buf;
 	e = p+len;
 	for(i = 0; i < Nstats; i++)
-		p = seprint(p, e, "%s: %lud\n", statnames[i], priv->stats[i]);
+		p = seprint(p, e, "%s: %lu\n", statnames[i], priv->stats[i]);
 	for(i = 0; i <= Maxtype; i++){
 		if(icmpnames[i])
-			p = seprint(p, e, "%s: %lud %lud\n", icmpnames[i], priv->in[i], priv->out[i]);
+			p = seprint(p, e, "%s: %lu %lu\n", icmpnames[i], priv->in[i], priv->out[i]);
 		else
-			p = seprint(p, e, "%d: %lud %lud\n", i, priv->in[i], priv->out[i]);
+			p = seprint(p, e, "%d: %lu %lu\n", i, priv->in[i], priv->out[i]);
 	}
 	return p - buf;
 }

sys/src/9/ip/icmp6.c

@@ -849,13 +849,13 @@ icmpstats6(Proto *icmp6, char *buf, int len)
 	p = buf;
 	e = p+len;
 	for(i = 0; i < Nstats6; i++)
-		p = seprint(p, e, "%s: %lud\n", statnames6[i], priv->stats[i]);
+		p = seprint(p, e, "%s: %lu\n", statnames6[i], priv->stats[i]);
 	for(i = 0; i <= Maxtype6; i++)
 		if(icmpnames6[i])
-			p = seprint(p, e, "%s: %lud %lud\n", icmpnames6[i],
+			p = seprint(p, e, "%s: %lu %lu\n", icmpnames6[i],
 				priv->in[i], priv->out[i]);
 		else if (0)
-			p = seprint(p, e, "%d: %lud %lud\n", i, priv->in[i],
+			p = seprint(p, e, "%d: %lu %lu\n", i, priv->in[i],
 				priv->out[i]);
 	return p - buf;
 }

sys/src/9/ip/ip.c

@@ -371,7 +371,7 @@ ipiput4(Fs *f, Ipifc *ifc, Block *bp)
 		hl = (h->vihl&0xF)<<2;
 		if(hl < (IP_HLEN4<<2)) {
 			ip->stats[InHdrErrors]++;
-			netlog(f, Logip, "ip: %V bad hivl %ux\n", h->src, h->vihl);
+			netlog(f, Logip, "ip: %V bad hivl %x\n", h->src, h->vihl);
 			freeblist(bp);
 			return;
 		}

sys/src/9/ip/ipifc.c

@@ -228,7 +228,7 @@ ipifcunbind(Ipifc *ifc)
 
 char sfixedformat[] = "device %s maxtu %d sendra %d recvra %d mflag %d oflag"
 " %d maxraint %d minraint %d linkmtu %d reachtime %d rxmitra %d ttl %d routerlt"
-" %d pktin %lud pktout %lud errin %lud errout %lud\n";
+" %d pktin %lu pktout %lu errin %lu errout %lu\n";
 
 char slineformat[] = "	%-40I %-10M %-40I %-12lud %-12lud\n";
 

sys/src/9/ip/ipv6.c

@@ -277,7 +277,7 @@ ipiput6(Fs *f, Ipifc *ifc, Block *bp)
 	/* Check header version */
 	if(BLKIPVER(bp) != IP_VER6) {
 		ip->stats[InHdrErrors]++;
-		netlog(f, Logip, "ip: bad version %ux\n", (h->vcf[0]&0xF0)>>2);
+		netlog(f, Logip, "ip: bad version %x\n", (h->vcf[0]&0xF0)>>2);
 		freeblist(bp);
 		return;
 	}

sys/src/9/ip/rudp.c

@@ -447,7 +447,7 @@ rudpkick(void *x)
 
 	upriv->ustats.rudpOutDatagrams++;
 
-	DPRINT("sent: %lud/%lud, %lud/%lud\n",
+	DPRINT("sent: %lu/%lu, %lu/%lu\n",
 		r->sndseq, r->sndgen, r->rcvseq, r->rcvgen);
 
 	doipoput(c, f, bp, 0, c->ttl, c->tos);
@@ -673,7 +673,7 @@ rudpstats(Proto *rudp, char *buf, int len)
 	Rudppriv *upriv;
 
 	upriv = rudp->priv;
-	return snprint(buf, len, "%lud %lud %lud %lud %lud %lud\n",
+	return snprint(buf, len, "%lu %lu %lu %lu %lu %lu\n",
 		upriv->ustats.rudpInDatagrams,
 		upriv->ustats.rudpNoPorts,
 		upriv->ustats.rudpInErrors,
@@ -788,7 +788,7 @@ relstate(Rudpcb *ucb, uint8_t *addr, uint16_t port, char *from)
 		while(generation == 0)
 			generation = rand();
 
-		DPRINT("from %s new state %lud for %I!%ud\n",
+		DPRINT("from %s new state %lu for %I!%u\n",
 		        from, generation, addr, port);
 
 		r = smalloc(sizeof(Reliable));
@@ -877,7 +877,7 @@ reliput(Conv *c, Block *bp, uint8_t *addr, uint16_t port)
 	ucb = (Rudpcb*)c->ptcl;
 	r = relstate(ucb, addr, port, "input");
 
-	DPRINT("rcvd %lud/%lud, %lud/%lud, r->sndgen = %lud\n",
+	DPRINT("rcvd %lu/%lu, %lu/%lu, r->sndgen = %lu\n",
 		seq, sgen, ack, agen, r->sndgen);
 
 	/* if acking an incorrect generation, ignore */
@@ -898,7 +898,7 @@ reliput(Conv *c, Block *bp, uint8_t *addr, uint16_t port)
 
 		/* new connection */
 		if(r->rcvgen != 0){
-			DPRINT("new con r->rcvgen = %lud, sgen = %lud\n", r->rcvgen, sgen);
+			DPRINT("new con r->rcvgen = %lu, sgen = %lu\n", r->rcvgen, sgen);
 			relhangup(c, r);
 		}
 		r->rcvgen = sgen;
@@ -910,7 +910,7 @@ reliput(Conv *c, Block *bp, uint8_t *addr, uint16_t port)
 		while(r->unacked != nil && INSEQ(ack, r->ackrcvd, r->sndseq)){
 			nbp = r->unacked;
 			r->unacked = nbp->list;
-			DPRINT("%lud/%lud acked, r->sndgen = %lud\n",
+			DPRINT("%lu/%lu acked, r->sndgen = %lu\n",
 			       ack, agen, r->sndgen);
 			freeb(nbp);
 			r->ackrcvd = NEXTSEQ(r->ackrcvd);
@@ -943,7 +943,7 @@ reliput(Conv *c, Block *bp, uint8_t *addr, uint16_t port)
 	if(seq != NEXTSEQ(r->rcvseq)){
 		relsendack(c, r, 0);	/* tell him we got it already */
 		upriv->orders++;
-		DPRINT("out of sequence %lud not %lud\n", seq, NEXTSEQ(r->rcvseq));
+		DPRINT("out of sequence %lu not %lu\n", seq, NEXTSEQ(r->rcvseq));
 		goto out;
 	}
 	r->rcvseq = seq;
@@ -1002,7 +1002,7 @@ relsendack(Conv *c, Reliable *r, int hangup)
 	uh->udpcksum[1] = 0;
 	hnputs(uh->udpcksum, ptclcsum(bp, UDP_IPHDR, UDP_RHDRSIZE));
 
-	DPRINT("sendack: %lud/%lud, %lud/%lud\n", 0L, r->sndgen, r->rcvseq, r->rcvgen);
+	DPRINT("sendack: %lu/%lu, %lu/%lu\n", 0L, r->sndgen, r->rcvseq, r->rcvgen);
 	doipoput(c, f, bp, 0, c->ttl, c->tos);
 }
 
@@ -1062,6 +1062,6 @@ relrexmit(Conv *c, Reliable *r)
 
 	upriv->rxmits++;
 	np = copyblock(r->unacked, blocklen(r->unacked));
-	DPRINT("rxmit r->ackrvcd+1 = %lud\n", r->ackrcvd+1);
+	DPRINT("rxmit r->ackrvcd+1 = %lu\n", r->ackrcvd+1);
 	doipoput(c, f, np, 0, c->ttl, c->tos);
 }

sys/src/9/ip/tcp.c

@@ -506,8 +506,8 @@ tcpstate(Conv *c, char *state, int n)
 	s = (Tcpctl*)(c->ptcl);
 
 	return snprint(state, n,
-		"%s qin %d qout %d rq %d.%d srtt %d mdev %d sst %lud cwin %lud "
-		"swin %lud>>%d rwin %lud>>%d qscale %d timer.start %d "
+		"%s qin %d qout %d rq %d.%d srtt %d mdev %d sst %lu cwin %lu "
+		"swin %lu>>%d rwin %lu>>%d qscale %d timer.start %d "
 		"timer.count %d rerecv %d katimer.start %d katimer.count %d\n",
 		tcpstates[s->state],
 		c->rq ? qlen(c->rq) : 0,
@@ -644,7 +644,7 @@ tcprcvwin(Conv *s)				/* Call with tcb locked */
 	if(w != tcb->rcv.wnd)
 	if(w>>tcb->rcv.scale == 0 || tcb->window > 4*tcb->mss && w < tcb->mss/4){
 		tcb->rcv.blocked = 1;
-		netlog(s->p->f, Logtcp, "tcprcvwin: window %lud qlen %d ws %ud lport %d\n",
+		netlog(s->p->f, Logtcp, "tcprcvwin: window %lu qlen %d ws %u lport %d\n",
 			tcb->window, qlen(s->rq), tcb->rcv.scale, s->lport);
 	}
 	tcb->rcv.wnd = w;
@@ -1730,7 +1730,7 @@ tcpincoming(Conv *s, Tcp *segp, uint8_t *src, uint8_t *dst, uint8_t version)
 	/* find a call in limbo */
 	h = hashipa(src, segp->source);
 	for(l = &tpriv->lht[h]; (lp = *l) != nil; l = &lp->next){
-		netlog(s->p->f, Logtcp, "tcpincoming s %I!%ud/%I!%ud d %I!%ud/%I!%ud v %d/%d\n",
+		netlog(s->p->f, Logtcp, "tcpincoming s %I!%u/%I!%u d %I!%u/%I!%u v %d/%d\n",
 			src, segp->source, lp->raddr, lp->rport,
 			dst, segp->dest, lp->laddr, lp->lport,
 			version, lp->version
@@ -1920,7 +1920,7 @@ update(Conv *s, Tcp *seg)
 	/* catch zero-window updates, update window & recover */
 	if(tcb->snd.wnd == 0 && seg->wnd > 0 &&
 	    seq_lt(seg->ack, tcb->snd.ptr)){
-		netlog(s->p->f, Logtcp, "tcp: zwu ack %lud una %lud ptr %lud win %lud\n",
+		netlog(s->p->f, Logtcp, "tcp: zwu ack %lu una %lu ptr %lu win %lu\n",
 			seg->ack,  tcb->snd.una, tcb->snd.ptr, seg->wnd);
 		tcb->snd.wnd = seg->wnd;
 		goto recovery;
@@ -1941,12 +1941,12 @@ recovery:
 			tcb->snd.rxt = tcb->snd.nxt;
 			tcpcongestion(tcb);
 			tcb->cwind = tcb->ssthresh + 3*tcb->mss;
-			netlog(s->p->f, Logtcpwin, "recovery inflate %ld ss %ld @%lud\n",
+			netlog(s->p->f, Logtcpwin, "recovery inflate %ld ss %ld @%lu\n",
 				tcb->cwind, tcb->ssthresh, tcb->snd.rxt);
 			tcprxmit(s);
 		}else{
 			tpriv->stats[RecoveryNoSeq]++;
-			netlog(s->p->f, Logtcpwin, "!recov %lud not ≤ %lud %ld\n",
+			netlog(s->p->f, Logtcpwin, "!recov %lu not ≤ %lu %ld\n",
 				tcb->snd.rxt, seg->ack, tcb->snd.rxt - seg->ack);
 			/* don't enter fast retransmit, don't change ssthresh */
 		}
@@ -2304,7 +2304,7 @@ reset:
 	if(tcb->state != Syn_received && (seg.flags & RST) == 0){
 		if(tcpporthogdefense
 		&& seq_within(seg.ack, tcb->snd.una-(1<<31), tcb->snd.una-(1<<29))){
-			print("stateless hog %I.%d->%I.%d f %ux %lux - %lux - %lux\n",
+			print("stateless hog %I.%d->%I.%d f %x %lux - %lux - %lux\n",
 				source, seg.source, dest, seg.dest, seg.flags,
 				tcb->snd.una-(1<<31), seg.ack, tcb->snd.una-(1<<29));
 			localclose(s, "stateless hog");
@@ -2315,8 +2315,8 @@ reset:
 	tcprcvwin(s);
 	if(tcptrim(tcb, &seg, &bp, &length) == -1) {
 		if(seg.seq+1 != tcb->rcv.nxt || length != 1)
-		netlog(f, Logtcp, "tcp: trim: !inwind: seq %lud-%lud win "
-			"%lud-%lud l %d from %I\n", seg.seq,
+		netlog(f, Logtcp, "tcp: trim: !inwind: seq %lu-%lu win "
+			"%lu-%lu l %d from %I\n", seg.seq,
 			seg.seq + length - 1, tcb->rcv.nxt,
 			tcb->rcv.nxt + tcb->rcv.wnd-1, length, s->raddr);
 		update(s, &seg);
@@ -2993,7 +2993,7 @@ tcptimeout(void *arg)
 			localclose(s, Etimedout);
 			break;
 		}
-		netlog(s->p->f, Logtcprxmt, "rxm %d/%d %ldms %lud rto %d %lud %s\n",
+		netlog(s->p->f, Logtcprxmt, "rxm %d/%d %ldms %lu rto %d %lu %s\n",
 			tcb->srtt, tcb->mdev, NOW - tcb->time,
 			tcb->snd.una - tcb->timeuna, tcb->snd.rto, tcb->snd.ptr,
 			tcpstates[s->state]);
@@ -3012,7 +3012,7 @@ tcptimeout(void *arg)
 			tpriv->stats[RecoveryRTO]++;
 			tcb->snd.rxt = tcb->snd.nxt;
 			netlog(s->p->f, Logtcpwin,
-				"rto recovery rxt @%lud\n", tcb->snd.nxt);
+				"rto recovery rxt @%lu\n", tcb->snd.nxt);
 		}
 
 		tcb->abcbytes = 0;
@@ -3092,7 +3092,7 @@ logreseq(Fs *f, Reseq *r, uint32_t n)
 		else if(r->seg.seq != n)
 			s = "hole";
 		if(s != nil)
-			netlog(f, Logtcp, "%s %lud-%lud (%ld) %#ux\n", s,
+			netlog(f, Logtcp, "%s %lu-%lu (%ld) %#ux\n", s,
 				n, r->seg.seq, r->seg.seq - n, r->seg.flags);
 		n = r->seg.seq + r->seg.len;
 	}
@@ -3442,8 +3442,8 @@ tcpsetscale(Conv *s, Tcpctl *tcb, uint16_t rcvscale, uint16_t sndscale)
 		tcb->qscale = Maxqscale;
 
 	if(rcvscale != tcb->rcv.scale)
-		netlog(s->p->f, Logtcp, "tcpsetscale: window %lud "
-			"qlen %d >> window %ud lport %d\n",
+		netlog(s->p->f, Logtcp, "tcpsetscale: window %lu "
+			"qlen %d >> window %u lport %d\n",
 			tcb->window, qlen(s->rq), QMAX<<tcb->qscale, s->lport);
 	tcb->window = QMAX << tcb->qscale;
 	tcb->ssthresh = tcb->window;

sys/src/9/ip/udp.c

@@ -596,8 +596,8 @@ udpstats(Proto *udp, char *buf, int len)
 	Udppriv *upriv;
 
 	upriv = udp->priv;
-	return snprint(buf, len, "InDatagrams: %llud\nNoPorts: %lud\n"
-		"InErrors: %lud\nOutDatagrams: %llud\n",
+	return snprint(buf, len, "InDatagrams: %llud\nNoPorts: %lu\n"
+		"InErrors: %lu\nOutDatagrams: %llud\n",
 		upriv->ustats.udpInDatagrams,
 		upriv->ustats.udpNoPorts,
 		upriv->ustats.udpInErrors,

sys/src/9/port/allocb.c

@@ -88,7 +88,7 @@ iallocb(int size)
 				active.exiting = 1;
 				exit(0);
 			}
-			iprint("iallocb: limited %lud/%lud\n",
+			iprint("iallocb: limited %lu/%lu\n",
 				ialloc.bytes, conf.ialloc);
 		}
 		return nil;
@@ -100,7 +100,7 @@ iallocb(int size)
 				active.exiting = 1;
 				exit(0);
 			}
-			iprint("iallocb: no memory %lud/%lud\n",
+			iprint("iallocb: no memory %lu/%lu\n",
 				ialloc.bytes, conf.ialloc);
 		}
 		return nil;
@@ -179,5 +179,5 @@ checkb(Block *b, char *msg)
 void
 iallocsummary(void)
 {
-	print("ialloc %lud/%lud\n", ialloc.bytes, conf.ialloc);
+	print("ialloc %lu/%lu\n", ialloc.bytes, conf.ialloc);
 }

sys/src/9/port/cache.c

@@ -524,7 +524,7 @@ cupdate(Chan *c, uint8_t *buf, int len, int64_t off)
 			len -= o;
 			offset += o;
 			if(len <= 0) {
-if(f && p->start + p->len > f->start) print("CACHE: p->start=%uld p->len=%d f->start=%uld\n", p->start, p->len, f->start);
+if(f && p->start + p->len > f->start) print("CACHE: p->start=%lu p->len=%d f->start=%lu\n", p->start, p->len, f->start);
 				qunlock(&mc->QLock);
 				return;
 			}

sys/src/9/port/devbridge.c

@@ -354,7 +354,7 @@ bridgeread(Chan *c, void *a, int32_t n, int64_t off)
 		n = readstr(off, a, n, c->aux);
 		return n;
 	case Qstats:
-		snprint(buf, sizeof(buf), "hit=%uld miss=%uld copy=%uld\n",
+		snprint(buf, sizeof(buf), "hit=%lu miss=%lu copy=%lu\n",
 			b->hit, b->miss, b->copy);
 		n = readstr(off, a, n, buf);
 		return n;
@@ -467,7 +467,7 @@ bridgegen(Chan *c, char *_, Dirtab*__, int ___, int s, Dir *dp)
 			return -1;
 		dt = dirtab[TYPE(c->qid)];
 		if(dt == nil)
-			panic("bridgegen: unknown type: %lud", TYPE(c->qid));
+			panic("bridgegen: unknown type: %lu", TYPE(c->qid));
 		devdir(c, c->qid, dt->name, dt->length, eve, dt->perm, dp);
 		return 1;
 	case Qtopdir:
@@ -597,7 +597,7 @@ portbind(Bridge *b, int argc, char *argv[])
 		// get directory name
 		n = devtab[ctl->qid.type]->read(ctl, buf, sizeof(buf)-1, 0);
 		buf[n] = 0;
-		snprint(path, sizeof(path), "%s/%lud/data", dev, strtoul(buf, 0, 0));
+		snprint(path, sizeof(path), "%s/%lu/data", dev, strtoul(buf, 0, 0));
 
 		// setup connection to be promiscuous
 		snprint(buf, sizeof(buf), "connect -1");

sys/src/9/port/devcons.c

@@ -649,11 +649,11 @@ consread(Chan *c, void *buf, int32_t n, int64_t off)
 		return n;
 
 	case Qdebug:
-		s = seprint(tmp, tmp + sizeof tmp, "locks %uld\n", lockstats.locks);
-		s = seprint(s, tmp + sizeof tmp, "glare %uld\n", lockstats.glare);
-		s = seprint(s, tmp + sizeof tmp, "inglare %uld\n", lockstats.inglare);
-		s = seprint(s, tmp + sizeof tmp, "qlock %uld\n", qlockstats.qlock);
-		seprint(s, tmp + sizeof tmp, "qlockq %uld\n", qlockstats.qlockq);
+		s = seprint(tmp, tmp + sizeof tmp, "locks %lu\n", lockstats.locks);
+		s = seprint(s, tmp + sizeof tmp, "glare %lu\n", lockstats.glare);
+		s = seprint(s, tmp + sizeof tmp, "inglare %lu\n", lockstats.inglare);
+		s = seprint(s, tmp + sizeof tmp, "qlock %lu\n", qlockstats.qlock);
+		seprint(s, tmp + sizeof tmp, "qlockq %lu\n", qlockstats.qlockq);
 		return readstr(offset, buf, n, tmp);
 		break;
 

sys/src/9/port/devmnt.c

@@ -1037,7 +1037,7 @@ mountmux(Mnt *mnt, Mntrpc *r)
 		l = &q->list;
 	}
 	unlock(&mnt->l);
-	print("unexpected reply tag %ud; type %d\n", r->reply.tag, r->reply.type);
+	print("unexpected reply tag %u; type %d\n", r->reply.tag, r->reply.type);
 }
 
 /*

sys/src/9/port/devprobe.c

@@ -227,7 +227,7 @@ proberead(Chan *c, void *a, int32_t n, int64_t offset)
 		buf = malloc(READSTR);
 		i = 0;
 		qlock(&probeslk);
-		i += snprint(buf + i, READSTR - i, "logsize %lud\n", logsize);
+		i += snprint(buf + i, READSTR - i, "logsize %lu\n", logsize);
 		for(p = probes; p != nil; p = p->next)
 			i += snprint(buf + i, READSTR - i, "probe %p new %s\n",
 				p->func, p->name);
@@ -236,7 +236,7 @@ proberead(Chan *c, void *a, int32_t n, int64_t offset)
 			if (p->enabled)
 				i += snprint(buf + i, READSTR - i, "probe %s on\n",
 				p->name);
-		i += snprint(buf + i, READSTR - i, "#probehits %lud, in queue %lud\n",
+		i += snprint(buf + i, READSTR - i, "#probehits %lu, in queue %lu\n",
 				pw, pw-pr);
 		snprint(buf + i, READSTR - i, "#probelog %p\n", probelog);
 		qunlock(&probeslk);

sys/src/9/port/devproc.c

@@ -246,7 +246,7 @@ procgen(Chan *c, char *name, Dirtab *tab, int j, int s, Dir *dp)
 
 		if((p = psincref(s)) == nil || (pid = p->pid) == 0)
 			return 0;
-		snprint(up->genbuf, sizeof up->genbuf, "%ud", pid);
+		snprint(up->genbuf, sizeof up->genbuf, "%u", pid);
 		/*
 		 * String comparison is done in devwalk so
 		 * name must match its formatted pid.
@@ -639,7 +639,7 @@ procqidwidth(Chan *c)
 {
 	char buf[32];
 
-	return sprint(buf, "%lud", c->qid.vers);
+	return sprint(buf, "%lu", c->qid.vers);
 }
 
 int
@@ -1156,7 +1156,7 @@ print("Qgdbregs: va %p, rptr +offset %p, n %d\n", va, rptr+offset, n);
 		poperror();
 		qunlock(&p->qwaitr);
 		psdecref(p);
-		n = snprint(va, n, "%d %lud %lud %lud %q",
+		n = snprint(va, n, "%d %lu %lu %lu %q",
 			wq->w.pid,
 			wq->w.time[TUser], wq->w.time[TSys], wq->w.time[TReal],
 			wq->w.msg);

sys/src/9/port/devsd.c

@@ -1161,7 +1161,7 @@ sdread(Chan *c, void *a, int32_t n, int64_t off)
 		if(unit->sectors){
 			if(unit->dev->ifc->rctl == nil)
 				l += snprint(p+l, mm-l,
-					"geometry %llud %lud\n",
+					"geometry %llud %lu\n",
 					unit->sectors, unit->secsize);
 			pp = unit->part;
 			for(i = 0; i < unit->npart; i++){

sys/src/9/port/devtrace.c

@@ -543,7 +543,7 @@ traceread(Chan *c, void *a, int32_t n, int64_t offset)
 		i = 0;
 		qlock(&traceslock);
 		buf = malloc(READSTR);
-		i += snprint(buf + i, READSTR - i, "logsize %lud\n", logsize);
+		i += snprint(buf + i, READSTR - i, "logsize %lu\n", logsize);
 		for(p = traces; p != nil; p = p->next)
 			i += snprint(buf + i, READSTR - i, "trace %p %p new %s\n",
 				p->start, p->end, p->name);

sys/src/9/port/edf.c

@@ -129,7 +129,7 @@ edfinit(Proc*p)
 		edfinited++;
 	}
 	now = ms();
-	DPRINT("%lud edfinit %d[%s]\n", now, p->pid, statename[p->state]);
+	DPRINT("%lu edfinit %d[%s]\n", now, p->pid, statename[p->state]);
 	p->edf = malloc(sizeof(Edf));
 	if(p->edf == nil)
 		error(Enomem);
@@ -150,7 +150,7 @@ deadlineintr(Ureg* ureg, Timer *t)
 
 	p = t->ta;
 	now = ms();
-	DPRINT("%lud deadlineintr %d[%s]\n", now, p->pid, statename[p->state]);
+	DPRINT("%lu deadlineintr %d[%s]\n", now, p->pid, statename[p->state]);
 	/* If we're interrupting something other than the proc pointed to by t->a,
 	 * we've already achieved recheduling, so we need not do anything
 	 * Otherwise, we must cause a reschedule, but if we call sched()
@@ -200,7 +200,7 @@ release(Proc *p)
 		}
 		e->d = e->r + e->D;
 		e->S = e->C;
-		DPRINT("%lud release %d[%s], r=%lud, d=%lud, t=%lud, S=%lud\n",
+		DPRINT("%lu release %d[%s], r=%lu, d=%lu, t=%lu, S=%lu\n",
 			now, p->pid, statename[p->state], e->r, e->d, e->t, e->S);
 		if(p->trace){
 			nowns = todget(nil);
@@ -208,8 +208,8 @@ release(Proc *p)
 			proctrace(p, SDeadline, nowns + 1000LL*e->D);
 		}
 	}else{
-		DPRINT("%lud release %d[%s], too late t=%lud, called from %#p\n",
-			now, p->pid, statename[p->state], e->t, getcallerpc(&p));
+		DPRINT("%lu release %d[%s], too late t=%lu, called from %#p\n",
+			now, p->pid, statename[p->state], e->t, getcallerpc());
 	}
 }
 
@@ -229,7 +229,7 @@ releaseintr(Ureg* ureg, Timer *t)
 	if((edflock(p)) == nil)
 		return;
 	sch = procsched(p);
-	DPRINT("%lud releaseintr %d[%s]\n", now, p->pid, statename[p->state]);
+	DPRINT("%lu releaseintr %d[%s]\n", now, p->pid, statename[p->state]);
 	switch(p->state){
 	default:
 		edfunlock();
@@ -293,7 +293,7 @@ edfrecord(Proc *p)
 		if(e->S <= used){
 			if(p->trace)
 				proctrace(p, SSlice, 0);
-			DPRINT("%lud edfrecord slice used up\n", now);
+			DPRINT("%lu edfrecord slice used up\n", now);
 			e->d = now;
 			e->S = 0;
 		}else
@@ -330,7 +330,7 @@ edfrun(Proc *p, int edfpri)
 			tns = 20;
 		e->Timer.tns = 1000LL * tns;	/* µs to ns */
 		if(e->Timer.tt == nil || e->Timer.tf != deadlineintr){
-			DPRINT("%lud edfrun, deadline=%lud\n", now, tns);
+			DPRINT("%lu edfrun, deadline=%lu\n", now, tns);
 		}else{
 			DPRINT("v");
 		}
@@ -403,13 +403,13 @@ edfadmit(Proc *p)
 		e->d = 0;
 		release(p);
 		if (p == up){
-			DPRINT("%lud edfadmit self %d[%s], release now: r=%lud d=%lud t=%lud\n",
+			DPRINT("%lu edfadmit self %d[%s], release now: r=%lu d=%lu t=%lu\n",
 				now, p->pid, statename[p->state], e->r, e->d, e->t);
 			/* We're already running */
 			edfrun(p, 1);
 		}else{
 			/* We're releasing another proc */
-			DPRINT("%lud edfadmit other %d[%s], release now: r=%lud d=%lud t=%lud\n",
+			DPRINT("%lu edfadmit other %d[%s], release now: r=%lu d=%lu t=%lu\n",
 				now, p->pid, statename[p->state], e->r, e->d, e->t);
 			p->Timer.ta = p;
 			edfunlock();
@@ -422,10 +422,10 @@ edfadmit(Proc *p)
 		e->t = r->edf->t;
 		psdecref(r);
 		if (p == up){
-			DPRINT("%lud edfadmit self %d[%s], release at %lud\n",
+			DPRINT("%lu edfadmit self %d[%s], release at %lu\n",
 				now, p->pid, statename[p->state], e->t);
 		}else{
-			DPRINT("%lud edfadmit other %d[%s], release at %lud\n",
+			DPRINT("%lu edfadmit other %d[%s], release at %lu\n",
 				now, p->pid, statename[p->state], e->t);
 			if(e->Timer.tt == nil){
 				e->Timer.tf = releaseintr;
@@ -450,7 +450,7 @@ edfstop(Proc *p)
 	Edf *e;
 
 	if(e = edflock(p)){
-		DPRINT("%lud edfstop %d[%s]\n", now, p->pid, statename[p->state]);
+		DPRINT("%lu edfstop %d[%s]\n", now, p->pid, statename[p->state]);
 		if(p->trace)
 			proctrace(p, SExpel, 0);
 		e->flags &= ~Admitted;
@@ -545,7 +545,7 @@ edfready(Proc *p)
 				e->Timer.tf = releaseintr;
 				e->Timer.ta = p;
 				timeradd(&e->Timer);
-				DPRINT("%lud edfready %d[%s], release=%lud\n",
+				DPRINT("%lu edfready %d[%s], release=%lu\n",
 					now, p->pid, statename[p->state], e->t);
 			}
 			if(p->state == Running && (e->flags & (Yield|Yieldonblock)) == 0 && (e->flags & Extratime)){
@@ -560,13 +560,13 @@ edfready(Proc *p)
 				edfunlock();
 				return 0;	/* Stick on runq[PriExtra] */
 			}
-			DPRINT("%lud edfready %d[%s] wait release at %lud\n",
+			DPRINT("%lu edfready %d[%s] wait release at %lu\n",
 				now, p->pid, statename[p->state], e->t);
 			p->state = Waitrelease;
 			edfunlock();
 			return 1;	/* Make runnable later */
 		}
-		DPRINT("%lud edfready %d %s release now\n", now, p->pid, statename[p->state]);
+		DPRINT("%lu edfready %d %s release now\n", now, p->pid, statename[p->state]);
 		/* release now */
 		release(p);
 	}
@@ -663,7 +663,7 @@ testschedulability(Proc *theproc)
 		case Dl:
 			H += p->edf->C;
 			Cb = 0;
-			DPRINT("\tStep %3d, Ticks %lud, pid %d, deadline, H += %lud → %lud, Cb = %lud\n",
+			DPRINT("\tStep %3d, Ticks %lu, pid %d, deadline, H += %lu → %lu, Cb = %lu\n",
 				steps, ticks, p->pid, p->edf->C, H, Cb);
 			if (H+Cb>ticks){
 				DPRINT("not schedulable\n");
@@ -674,7 +674,7 @@ testschedulability(Proc *theproc)
 			testenq(p);
 			break;
 		case Rl:
-			DPRINT("\tStep %3d, Ticks %lud, pid %d, release, G  %lud, C%lud\n",
+			DPRINT("\tStep %3d, Ticks %lu, pid %d, release, G  %lu, C%lu\n",
 				steps, ticks, p->pid, p->edf->C, G);
 			if(ticks && G <= ticks){
 				DPRINT("schedulable\n");

sys/src/9/port/image.c

@@ -113,7 +113,7 @@ initimage(void)
 {
 	Image *i, *ie;
 
-	DBG("initimage: %uld images\n", conf.nimage);
+	DBG("initimage: %lu images\n", conf.nimage);
 	imagealloc.mru = malloc(conf.nimage*sizeof(Image));
 	if(imagealloc.mru == nil)
 		panic("imagealloc: no memory");
@@ -142,7 +142,7 @@ imagereclaim(void)
 	/* Somebody is already cleaning the page cache */
 	if(!canqlock(&imagealloc.ireclaim))
 		return;
-	DBG("imagereclaim maxt %ulld noluck %d nolock %d\n",
+	DBG("imagereclaim maxt %llu noluck %d nolock %d\n",
 		irstats.maxt, irstats.noluck, irstats.nolock);
 	ticks0 = fastticks(nil);
 	if(!canlock(&imagealloc.Lock)){

sys/src/9/port/page.c

@@ -45,7 +45,7 @@ seprintpagestats(char *s, char *e)
 	lock(&pga.l);
 	for(i = 0; i < sys->npgsz; i++)
 		if(sys->pgsz[i] != 0)
-			s = seprint(s, e, "%uld/%d %dK user pages avail\n",
+			s = seprint(s, e, "%lu/%d %dK user pages avail\n",
 				pga.pgsza[i].freecount,
 				pga.pgsza[i].npages.ref, sys->pgsz[i]/KiB);
 	unlock(&pga.l);

sys/src/9/port/pager.c

@@ -203,7 +203,7 @@ freepages(int si, int once)
 	for(; si < sys->npgsz; si++){
 		pa = &pga.pgsza[si];
 		if(pa->freecount > 0){
-			DBG("kickpager() up %#p: releasing %udK pages\n",
+			DBG("kickpager() up %#p: releasing %uK pages\n",
 				up, sys->pgsz[si]/KiB);
 			lock(&pga.l);
 			if(pa->freecount == 0){
@@ -294,7 +294,7 @@ kickpager(int pgszi, int color)
 		pageouttext(pgszi, color);
 		tryalloc(pgszi, color);
 		if(hascolor(pa->head, color)){
-			DBG("kickpager() found %uld free\n", pa->freecount);
+			DBG("kickpager() found %lu free\n", pa->freecount);
 			goto Done;
 		}
 	}
@@ -306,7 +306,7 @@ kickpager(int pgszi, int color)
 	freepages(pgszi+1, 1);
 	tryalloc(pgszi, color);
 	if(hascolor(pa->head, color)){
-		DBG("kickpager() found %uld free\n", pa->freecount);
+		DBG("kickpager() found %lu free\n", pa->freecount);
 		goto Done;
 	}
 
@@ -318,7 +318,7 @@ kickpager(int pgszi, int color)
 	freepages(0, 0);
 	tryalloc(pgszi, color);
 	if(pa->freecount > 0){
-		DBG("kickpager() found %uld free\n", pa->freecount);
+		DBG("kickpager() found %lu free\n", pa->freecount);
 		goto Done;
 	}
 
@@ -341,7 +341,7 @@ Done:
 void
 pagersummary(void)
 {
-	print("ntext %uld nbig %uld nall %uld\n",
+	print("ntext %lu nbig %lu nall %lu\n",
 		pstats.ntext, pstats.nbig, pstats.nall);
 	print("no swap\n");
 }

sys/src/9/port/proc.c

@@ -1249,7 +1249,7 @@ pexit(char *exitstr, int freemem)
 	if(0 && up->nfullq > 0)
 		iprint(" %s=%d", up->text, up->nfullq);
 	if(0 && up->nicc > 0)
-		iprint(" [%s nicc %ud tctime %ulld actime %ulld]\n",
+		iprint(" [%s nicc %u tctime %llu actime %llu]\n",
 			up->text, up->nicc, up->tctime, up->actime);
 	if(up->syscalltrace != nil)
 		free(up->syscalltrace);
@@ -1459,7 +1459,7 @@ dumpaproc(Proc *p)
 	s = p->psstate;
 	if(s == 0)
 		s = statename[p->state];
-	print("%3d:%10s pc %#p dbgpc %#p  %8s (%s) ut %ld st %ld bss %#p qpc %#p nl %d nd %lud lpc %#p pri %lud\n",
+	print("%3d:%10s pc %#p dbgpc %#p  %8s (%s) ut %ld st %ld bss %#p qpc %#p nl %d nd %lu lpc %#p pri %lu\n",
 		p->pid, p->text, p->pc, dbgpc(p), s, statename[p->state],
 		p->time[0], p->time[1], bss, p->qpc, p->nlocks,
 	      p->delaysched, p->lastlock ? 0/*p->lastlock->pc*/ : 0, p->priority);
@@ -1547,7 +1547,7 @@ scheddump(void)
 				continue;
 			print("sch%ld rq%ld:", sch - run, rq-sch->runq);
 			for(p = rq->head; p; p = p->rnext)
-				print(" %d(%lud)", p->pid, machp()->ticks - p->readytime);
+				print(" %d(%lu)", p->pid, machp()->ticks - p->readytime);
 			print("\n");
 			delay(150);
 		}

sys/src/9/port/ps.c

@@ -123,7 +123,7 @@ psinit(int nproc)
 
 	procalloc.free = malloc(nproc*sizeof(Proc));
 	if(procalloc.free == nil)
-		panic("cannot allocate %ud procs (%udMB)\n", nproc, nproc*sizeof(Proc)/(1024*1024));
+		panic("cannot allocate %u procs (%uMB)\n", nproc, nproc*sizeof(Proc)/(1024*1024));
 	procalloc.arena = procalloc.free;
 
 	p = procalloc.free;

sys/src/9/port/qio.c

@@ -70,9 +70,9 @@ ixsummary(void)
 {
 	debugging ^= 1;
 	iallocsummary();
-	print("pad %lud, concat %lud, pullup %lud, copy %lud\n",
+	print("pad %lu, concat %lu, pullup %lu, copy %lu\n",
 		padblockcnt, concatblockcnt, pullupblockcnt, copyblockcnt);
-	print("consume %lud, produce %lud, qcopy %lud\n",
+	print("consume %lu, produce %lu, qcopy %lu\n",
 		consumecnt, producecnt, qcopycnt);
 }
 

sys/src/9/port/rmap.c

@@ -58,7 +58,7 @@ rmapfree(RMap* rmap, uintptr_t addr, uint size)
 		}else{
 			do{
 				if(mp >= rmap->mapend){
-					print("mapfree: %s: losing 0x%luX, %ud\n", rmap->name, addr, size);
+					print("mapfree: %s: losing 0x%luX, %u\n", rmap->name, addr, size);
 					break;
 				}
 				t = mp->addr;

sys/src/9/port/syscallfmt.c

@@ -228,7 +228,7 @@ syscallfmt(uint8_t what, int syscallno, Ar0 *ar0, uint64_t start, uint64_t stop,
 		i[0] = va_arg(list, int);
 		a = va_arg(list, char*);
 		l = va_arg(list, unsigned long);
-		fmtprint(&fmt, "%d %#p %lud", i[0], a, l);
+		fmtprint(&fmt, "%d %#p %lu", i[0], a, l);
 		break;
 	case NOTIFY:
 	case SEGDETACH:
@@ -246,7 +246,7 @@ syscallfmt(uint8_t what, int syscallno, Ar0 *ar0, uint64_t start, uint64_t stop,
 	case SEGFLUSH:
 		v = va_arg(list, void*);
 		l = va_arg(list, unsigned long);
-		fmtprint(&fmt, "%#p %lud", v, l);
+		fmtprint(&fmt, "%#p %lu", v, l);
 		break;
 	case UNMOUNT:
 		a = va_arg(list, char*);
@@ -290,7 +290,7 @@ syscallfmt(uint8_t what, int syscallno, Ar0 *ar0, uint64_t start, uint64_t stop,
 		a = va_arg(list, char*);
 		fmtuserstring(&fmt, a, " ");
 		l = va_arg(list, unsigned long);
-		fmtprint(&fmt, "%lud", l);
+		fmtprint(&fmt, "%lu", l);
 		break;
 	case WSTAT:
 	case STAT:
@@ -301,7 +301,7 @@ syscallfmt(uint8_t what, int syscallno, Ar0 *ar0, uint64_t start, uint64_t stop,
 	case AWAIT:
 		a = va_arg(list, char*);
 		l = va_arg(list, unsigned long);
-		fmtprint(&fmt, "%#p %lud", a, l);
+		fmtprint(&fmt, "%#p %lu", a, l);
 		break;
 	case MOUNT:
 		i[0] = va_arg(list, int);
@@ -393,10 +393,10 @@ syscallfmt(uint8_t what, int syscallno, Ar0 *ar0, uint64_t start, uint64_t stop,
 	case AWAIT:
 		if(ar0->i > 0){
 			fmtuserstring(&fmt, a, " ");
-			fmtprint(&fmt, "%lud = %d", l, ar0->i);
+			fmtprint(&fmt, "%lu = %d", l, ar0->i);
 		}
 		else{
-			fmtprint(&fmt, "%#p/\"\" %lud = %d", a, l, ar0->i);
+			fmtprint(&fmt, "%#p/\"\" %lu = %d", a, l, ar0->i);
 			errstr = up->errstr;
 		}
 		break;
@@ -404,20 +404,20 @@ syscallfmt(uint8_t what, int syscallno, Ar0 *ar0, uint64_t start, uint64_t stop,
 	case ERRSTR:
 		if(ar0->i > 0){
 			fmtuserstring(&fmt, a, " ");
-			fmtprint(&fmt, "%lud = %d", l, ar0->i);
+			fmtprint(&fmt, "%lu = %d", l, ar0->i);
 		}
 		else{
-			fmtprint(&fmt, "\"\" %lud = %d", l, ar0->i);
+			fmtprint(&fmt, "\"\" %lu = %d", l, ar0->i);
 			errstr = up->errstr;
 		}
 		break;
 	case FD2PATH:
 		if(ar0->i > 0){
 			fmtuserstring(&fmt, a, " ");
-			fmtprint(&fmt, "%lud = %d", l, ar0->i);
+			fmtprint(&fmt, "%lu = %d", l, ar0->i);
 		}
 		else{
-			fmtprint(&fmt, "\"\" %lud = %d", l, ar0->i);
+			fmtprint(&fmt, "\"\" %lu = %d", l, ar0->i);
 			errstr = up->errstr;
 		}
 		break;

sys/src/9/port/sysproc.c

@@ -865,7 +865,7 @@ sysawait(Ar0* ar0, ...)
 		ar0->i = -1;
 		return;
 	}
-	i = snprint(p, n, "%d %lud %lud %lud %q",
+	i = snprint(p, n, "%d %lu %lu %lu %q",
 		w.pid,
 		w.time[TUser], w.time[TSys], w.time[TReal],
 		w.msg);

sys/src/9/port/syszio.c

@@ -391,7 +391,7 @@ ziorw(int fd, Zio *io, int nio, usize count, int64_t offset, int iswrite)
 	kio = nil;
 
 	io = validaddr(io, sizeof io[0] * nio, 1);
-	DBG("ziorw %d io%#p[%d] %uld %lld\n", fd, io, nio, count, offset);
+	DBG("ziorw %d io%#p[%d] %lu %lld\n", fd, io, nio, count, offset);
 	if(DBGFLG)
 		for(i = 0; i < nio; i++)
 			print("\tio%#p[%d] = %Z %s\n",

sys/src/9/port/usbehci.c

@@ -596,7 +596,7 @@ schedq(Ctlr *ctlr, Qh *qh, int pollival)
 
 	bw = qh->io->bw;
 	q = pickschedq(ctlr->tree, pollival, 0, ~0);
-	ddqprint("ehci: sched %#p q %d, ival %d, bw %uld\n",
+	ddqprint("ehci: sched %#p q %d, ival %d, bw %lu\n",
 		qh->io, q, pollival, bw);
 	if(q < 0){
 		print("ehci: no room for ed\n");
@@ -825,7 +825,7 @@ qhlinktd(Qh *qh, Td *td)
 static char*
 seprintlink(char *s, char *se, char *name, uint32_t l, int typed)
 {
-	s = seprint(s, se, "%s %ulx", name, l);
+	s = seprint(s, se, "%s %lx", name, l);
 	if((l & Lterm) != 0)
 		return seprint(s, se, "T");
 	if(typed == 0)
@@ -857,7 +857,7 @@ seprintitd(char *s, char *se, Itd *td)
 
 	s = seprint(s, se, "itd %#p", td);
 	rw = (b1 & Itdin) ? "in" : "out";
-	s = seprint(s, se, " %s ep %uld dev %uld max %uld mult %uld",
+	s = seprint(s, se, " %s ep %lu dev %lu max %lu mult %lu",
 		rw, (b0>>8)&Epmax, (b0&Devmax),
 		td->buffer[1] & 0x7ff, b1 & 3);
 	s = seprintlink(s, se, " link", td->link, 1);
@@ -876,9 +876,9 @@ seprintitd(char *s, char *se, Itd *td)
 			flags[4] = 't';
 		flags[5] = 0;
 		s = seprint(s, se, "\ttd%d %s", i, flags);
-		s = seprint(s, se, " len %uld", (td->csw[i] >> 16) & 0x7ff);
-		s = seprint(s, se, " pg %uld", (td->csw[i] >> 12) & 0x7);
-		s = seprint(s, se, " off %uld\n", td->csw[i] & 0xfff);
+		s = seprint(s, se, " len %lu", (td->csw[i] >> 16) & 0x7ff);
+		s = seprint(s, se, " pg %lu", (td->csw[i] >> 12) & 0x7);
+		s = seprint(s, se, " off %lu\n", td->csw[i] & 0xfff);
 	}
 	s = seprint(s, se, "\tbuffs:");
 	for(i = 0; i < nelem(td->buffer); i++)
@@ -897,11 +897,11 @@ seprintsitd(char *s, char *se, Sitd *td)
 		return seprint(s, se, "<nil sitd>\n");
 	s = seprint(s, se, "sitd %#p", td);
 	rw = (td->epc & Stdin) ? 'r' : 'w';
-	s = seprint(s, se, " %c ep %uld dev %uld",
+	s = seprint(s, se, " %c ep %lu dev %lu",
 		rw, (td->epc>>8)&0xf, td->epc&0x7f);
-	s = seprint(s, se, " max %uld", (td->csw >> 16) & 0x3ff);
-	s = seprint(s, se, " hub %uld", (td->epc >> 16) & 0x7f);
-	s = seprint(s, se, " port %uld\n", (td->epc >> 24) & 0x7f);
+	s = seprint(s, se, " max %lu", (td->csw >> 16) & 0x3ff);
+	s = seprint(s, se, " hub %lu", (td->epc >> 16) & 0x7f);
+	s = seprint(s, se, " port %lu\n", (td->epc >> 24) & 0x7f);
 	memset(flags, '-', 7);
 	if((td->csw & Stdactive) != 0)
 		flags[0] = 'a';
@@ -921,9 +921,9 @@ seprintsitd(char *s, char *se, Sitd *td)
 	ss = (td->csw & Stddcs) ? 'c' : 's';
 	pg = (td->csw & Stdpg) ? '1' : '0';
 	s = seprint(s, se, "\t%s %cs pg%c", flags, ss, pg);
-	s = seprint(s, se, " b0 %#lux b1 %#lux off %uld\n",
+	s = seprint(s, se, " b0 %#lux b1 %#lux off %lu\n",
 		td->buffer[0] >> 12, td->buffer[1] >> 12, td->buffer[0] & 0xfff);
-	s = seprint(s, se, "\ttpos %c tcnt %uld",
+	s = seprint(s, se, "\ttpos %c tcnt %lu",
 		pc[(td->buffer[0]>>3)&3], td->buffer[1] & 7);
 	s = seprint(s, se, " ssm %#lux csm %#lux cspm %#lux",
 		td->mfs & 0xff, (td->mfs>>8) & 0xff, (td->csw>>8) & 0xff);
@@ -983,8 +983,8 @@ seprinttd(char *s, char *se, Td *td, char *tag)
 	t = (td->csw & Tddata1) ? '1' : '0';
 	ss = (td->csw & Tddcs) ? 'c' : 's';
 	s = seprint(s, se, "\n\td%c %s %cs", t, flags, ss);
-	s = seprint(s, se, " max %uld", maxtdlen(td));
-	s = seprint(s, se, " pg %uld off %#lux\n",
+	s = seprint(s, se, " max %lu", maxtdlen(td));
+	s = seprint(s, se, " pg %lu off %#lux\n",
 		(td->csw >> Tdpgshift) & Tdpgmask, td->buffer[0] & 0xFFF);
 	s = seprint(s, se, "\tbuffs:");
 	for(i = 0; i < nelem(td->buffer); i++)
@@ -1031,16 +1031,16 @@ qhdump(Qh *qh)
 		tag = qh->io->tag;
 	se = buf+sizeof(buf);
 	s = seprint(buf, se, "%s %#p", tag, qh);
-	s = seprint(s, se, " ep %uld dev %uld",
+	s = seprint(s, se, " ep %lu dev %lu",
 		(qh->eps0>>8)&0xf, qh->eps0&0x7f);
-	s = seprint(s, se, " hub %uld", (qh->eps1 >> 16) & 0x7f);
-	s = seprint(s, se, " port %uld", (qh->eps1 >> 23) & 0x7f);
+	s = seprint(s, se, " hub %lu", (qh->eps1 >> 16) & 0x7f);
+	s = seprint(s, se, " port %lu", (qh->eps1 >> 23) & 0x7f);
 	s = seprintlink(s, se, " link", qh->link, 1);
 	seprint(s, se, "  clink %#lux", qh->tclink);
 	print("%s\n", buf);
-	s = seprint(buf, se, "\tnrld %uld", (qh->eps0 >> Qhrlcshift) & Qhrlcmask);
-	s = seprint(s, se, " nak %uld", (qh->alink >> 1) & 0xf);
-	s = seprint(s, se, " max %uld ", qhmaxpkt(qh));
+	s = seprint(buf, se, "\tnrld %lu", (qh->eps0 >> Qhrlcshift) & Qhrlcmask);
+	s = seprint(s, se, " nak %lu", (qh->alink >> 1) & 0xf);
+	s = seprint(s, se, " max %lu ", qhmaxpkt(qh));
 	if((qh->eps0 & Qhnhctl) != 0)
 		s = seprint(s, se, "c");
 	if((qh->eps0 & Qhhrl) != 0)
@@ -1050,7 +1050,7 @@ qhdump(Qh *qh)
 	if((qh->eps0 & Qhint) != 0)
 		s = seprint(s, se, "i");
 	s = seprint(s, se, " %s", speed[(qh->eps0 >> 12) & 3]);
-	s = seprint(s, se, " mult %uld", (qh->eps1 >> Qhmultshift) & Qhmultmask);
+	s = seprint(s, se, " mult %lu", (qh->eps1 >> Qhmultshift) & Qhmultmask);
 	seprint(s, se, " scm %#lux ism %#lux\n",
 		(qh->eps1 >> 8 & 0xff), qh->eps1 & 0xff);
 	print("%s\n", buf);
@@ -1072,11 +1072,11 @@ isodump(Isoio* iso, int all)
 		print("<nil iso>\n");
 		return;
 	}
-	print("iso %#p %s %s speed state %d nframes %d maxsz %uld",
+	print("iso %#p %s %s speed state %d nframes %d maxsz %lu",
 		iso, iso->tok == Tdtokin ? "in" : "out",
 		iso->hs ? "high" : "full",
 		iso->state, iso->nframes, iso->maxsize);
-	print(" td0 %uld tdi %#p tdu %#p data %#p\n",
+	print(" td0 %lu tdi %#p tdu %#p data %#p\n",
 		iso->td0frno, iso->tdi, iso->tdu, iso->data);
 	if(iso->err != nil)
 		print("\terr %s\n", iso->err);
@@ -1138,7 +1138,7 @@ dump(Hci *hp)
 		ctlr->capio, ctlr->frames, ctlr->nframes,
 		ctlr->nintr, ctlr->ntdintr);
 	print(" nqhintr %d nisointr %d\n", ctlr->nqhintr, ctlr->nisointr);
-	print("\tcmd %#lux sts %#lux intr %#lux frno %uld",
+	print("\tcmd %#lux sts %#lux intr %#lux frno %lu",
 		opio->cmd, opio->sts, opio->intr, opio->frno);
 	print(" base %#lux link %#lux fr0 %#lux\n",
 		opio->frbase, opio->link, ctlr->frames[0]);
@@ -1350,7 +1350,7 @@ isohsinterrupt(Ctlr *ctlr, Isoio *iso)
 				iso->err = ierrmsg(err);
 				diprint("isohsintr: tdi %#p error %#ux %s\n",
 					tdi, err, iso->err);
-				diprint("ctlr load %uld\n", ctlr->load);
+				diprint("ctlr load %lu\n", ctlr->load);
 			}
 			tdi->ndata = 0;
 		}else
@@ -1415,7 +1415,7 @@ isofsinterrupt(Ctlr *ctlr, Isoio *iso)
 				iso->err = serrmsg(err);
 				diprint("isofsintr: tdi %#p error %#ux %s\n",
 					stdi, err, iso->err);
-				diprint("ctlr load %uld\n", ctlr->load);
+				diprint("ctlr load %lu\n", ctlr->load);
 			}
 			stdi->ndata = 0;
 		}else
@@ -1539,7 +1539,7 @@ ehciintr(Hci *hp)
 				ctlr->nintr, ctlr->ntdintr);
 			print(" nqhintr %d nisointr %d\n",
 				ctlr->nqhintr, ctlr->nisointr);
-			print("\tcmd %#lux sts %#lux intr %#lux frno %uld",
+			print("\tcmd %#lux sts %#lux intr %#lux frno %lu",
 				opio->cmd, opio->sts, opio->intr, opio->frno);
 		}
 
@@ -1968,7 +1968,7 @@ episoread(Ep *ep, Isoio *iso, void *a, int32_t count)
 	iunlock(&ctlr->l);
 	qunlock(&iso->QLock);
 	poperror();
-	diprint("uhci: episoread: %#p %uld bytes err '%s'\n", iso, tot, iso->err);
+	diprint("uhci: episoread: %#p %lu bytes err '%s'\n", iso, tot, iso->err);
 	if(iso->err != nil)
 		error(iso->err);
 	return tot;
@@ -2315,7 +2315,7 @@ epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
 	ctlr = ep->hp->Hciimpl.aux;
 	io->debug = ep->debug;
 	tmout = ep->tmout;
-	ddeprint("epio: %s ep%d.%d io %#p count %ld load %uld\n",
+	ddeprint("epio: %s ep%d.%d io %#p count %ld load %lu\n",
 		io->tok == Tdtokin ? "in" : "out",
 		ep->dev->nb, ep->nb, io, count, ctlr->load);
 	if((ehcidebug > 1 || ep->debug > 1) && io->tok != Tdtokin){
@@ -2365,7 +2365,7 @@ epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
 	ltd->csw |= Tdioc;		/* the last one interrupts */
 	coherence();
 
-	ddeprint("ehci: load %uld ctlr load %uld\n", load, ctlr->load);
+	ddeprint("ehci: load %lu ctlr load %lu\n", load, ctlr->load);
 	if(ehcidebug > 1 || ep->debug > 1)
 		dumptd(td0, "epio: put: ");
 
@@ -2775,8 +2775,8 @@ isoopen(Ctlr *ctlr, Ep *ep)
 	ctlr->load += ep->load;
 	ctlr->isoload += ep->load;
 	ctlr->nreqs++;
-	dprint("ehci: load %uld isoload %uld\n", ctlr->load, ctlr->isoload);
-	diprint("iso nframes %d pollival %uld ival %d maxpkt %uld ntds %d\n",
+	dprint("ehci: load %lu isoload %lu\n", ctlr->load, ctlr->isoload);
+	diprint("iso nframes %d pollival %lu ival %d maxpkt %lu ntds %d\n",
 		iso->nframes, ep->pollival, ival, ep->maxpkt, ep->ntds);
 	iunlock(&ctlr->l);
 	if(ctlr->poll.does)

sys/src/9/root/big.c

@@ -20,7 +20,7 @@ main(int argc, char *argv[])
 	if (argc > 1)
 		num = strtoul(argv[1], 0, 0);
 	size = num * 0x200000ULL;
-	print("Try to malloc %ulld bytes\n", size);
+	print("Try to malloc %llu bytes\n", size);
 	c = mallocz(size, 1);
 	print("Did it\n");
 	while(1);

sys/src/9/root/bigloop.c

@@ -18,7 +18,7 @@ main(int argc, char *argv[])
 
 	if (argc > 1)
 		num = strtoul(argv[1], 0, 0);
-	print("Try to malloc %ulld bytes in %ld loops\n", num*0x200000ULL, num);
+	print("Try to malloc %llu bytes in %ld loops\n", num*0x200000ULL, num);
 	for(i = 0; i < num; i++)
 		if (sbrk(0x200000) == nil){
 			print("%d sbrk failed\n", i);

sys/src/cmd/9660srv/main.c

@@ -554,7 +554,7 @@ showdir(int fd, Dir *s)
 	strcpy(m_time, ctime(s->mtime));
 	if(p=strchr(m_time, '\n'))	/* assign = */
 		*p = 0;
-	fprint(fd, "name=\"%s\" qid=(0x%llux,%lud) type=%d dev=%d \
+	fprint(fd, "name=\"%s\" qid=(0x%llux,%lu) type=%d dev=%d \
 mode=0x%8.8lux=0%luo atime=%s mtime=%s length=%lld uid=\"%s\" gid=\"%s\"...",
 		s->name, s->qid.path, s->qid.vers, s->type, s->dev,
 		s->mode, s->mode,

sys/src/cmd/acid/builtin.c

@@ -1025,7 +1025,7 @@ patom(uint8_t type, Store *res)
 		Bprint(bout, "%d", (int)res->ival&0xffff);
 		break;
 	case 'U':
-		Bprint(bout, "%lud", (uint32_t)res->ival);
+		Bprint(bout, "%lu", (uint32_t)res->ival);
 		break;
 	case 'Z':
 		Bprint(bout, "%llud", res->ival);

sys/src/cmd/acid/main.c

@@ -534,7 +534,7 @@ checkqid(int f1, int pid)
 	close(fd);
 
 	if(d1->qid.path != d2->qid.path || d1->qid.vers != d2->qid.vers || d1->qid.type != d2->qid.type){
-		print("path %llux %llux vers %lud %lud type %d %d\n",
+		print("path %llux %llux vers %lu %lu type %d %d\n",
 			d1->qid.path, d2->qid.path, d1->qid.vers, d2->qid.vers, d1->qid.type, d2->qid.type);
 		print("warning: image does not match text for pid %d\n", pid);
 	}

sys/src/cmd/acme/ecmd.c

@@ -683,9 +683,9 @@ printposn(Text *t, int charsonly)
 		/* check if addr ends with '\n' */
 		if(addr.r.q1>0 && addr.r.q1>addr.r.q0 && textreadc(t, addr.r.q1-1)=='\n')
 			--l2;
-		warning(nil, "%lud", l1);
+		warning(nil, "%lu", l1);
 		if(l2 != l1)
-			warning(nil, ",%lud", l2);
+			warning(nil, ",%lu", l2);
 		warning(nil, "\n");
 		return;
 	}

sys/src/cmd/acme/elog.c

@@ -112,7 +112,7 @@ elogflush(File *f)
 	b.nr = f->elog.nr;
 	switch(f->elog.type){
 	default:
-		warning(nil, "unknown elog type 0x%ux\n", f->elog.type);
+		warning(nil, "unknown elog type 0x%x\n", f->elog.type);
 		break;
 	case Null:
 		break;
@@ -267,7 +267,7 @@ elogapply(File *f)
 		bufread(log, up, (Rune*)&b, Buflogsize);
 		switch(b.type){
 		default:
-			fprint(2, "elogapply: 0x%ux\n", b.type);
+			fprint(2, "elogapply: 0x%x\n", b.type);
 			abort();
 			break;
 

sys/src/cmd/acme/file.c

@@ -231,7 +231,7 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
 		}
 		switch(u.type){
 		default:
-			fprint(2, "undo: 0x%ux\n", u.type);
+			fprint(2, "undo: 0x%x\n", u.type);
 			abort();
 			break;
 

sys/src/cmd/aquarela/cifscmd.c

@@ -175,7 +175,7 @@ cmdopen(SmbClient *c, int argc, char *argv[])
 		}
 		return (errclass << 16) | error;
 	}
-	print("fid 0x%.4ux attr 0x%.4ux time %ld size %lud accessallowed %ud\n",
+	print("fid 0x%.4ux attr 0x%.4ux time %ld size %lu accessallowed %u\n",
 		fid, attr, mtime, size, accessallowed);
 	return 0;
 }

sys/src/cmd/aquarela/dump.c

@@ -73,7 +73,7 @@ nbnsdumpmessageresource(NbnsMessageResource *r, char *name)
 	case NbnsResourceClassIn: print(" IN"); break;
 	default: print(" ???");
 	}
-	print(" ttl: %lud", r->ttl);
+	print(" ttl: %lu", r->ttl);
 	if (r->rdlength) {
 		int i;
 		print(" rdata: ");

sys/src/cmd/aquarela/nbdgramdump.c

@@ -21,7 +21,7 @@ nbdgramdump(NbDgram *s)
 	case NbDgramDirectUnique:
 	case NbDgramDirectGroup:
 	case NbDgramBroadcast:
-		print("\tlength %ud offset %ud srcname %B dstname %B\n",
+		print("\tlength %u offset %u srcname %B dstname %B\n",
 			s->datagram.length, s->datagram.offset, s->datagram.srcname, s->datagram.dstname);
 		break;
 	}

sys/src/cmd/aquarela/nbname.c

@@ -303,7 +303,7 @@ nbremotenametableadd(NbName name, uint8_t *ipaddr, uint32_t ttl)
 	}
 	ipmove(p->ipaddr, ipaddr);
 	p->expire = time(nil) + ttl;
-//print("nbremotenametableadd: %B ttl %lud expire %ld\n", p->name, ttl, p->expire);
+//print("nbremotenametableadd: %B ttl %lu expire %ld\n", p->name, ttl, p->expire);
 	qunlock(&nbremotenametable);
 	return 1;
 }

sys/src/cmd/aquarela/smbcomlocking.c

@@ -65,7 +65,7 @@ smbcomlockingandx(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 	timeout = smbnhgetl(pdata); pdata += 4;
 	numberofunlocks = smbnhgets(pdata); pdata += 2;
 	numberoflocks = smbnhgets(pdata);
-	smblogprint(h->command, "smbcomlockingandx: fid 0x%.4ux locktype 0x%.2ux oplocklevel 0x%.2ux timeout %lud numberofunlocks %d numberoflocks %ud\n",
+	smblogprint(h->command, "smbcomlockingandx: fid 0x%.4ux locktype 0x%.2ux oplocklevel 0x%.2ux timeout %lu numberofunlocks %d numberoflocks %u\n",
 		fid, locktype, oplocklevel, timeout, numberofunlocks, numberoflocks);
 	large = locktype & 0x10;
 	locktype &= ~0x10;

sys/src/cmd/aquarela/smbcommon.c

@@ -19,7 +19,7 @@ int
 smbcheckwordcount(char *name, SmbHeader *h, uint16_t wordcount)
 {
 	if (h->wordcount != wordcount) {
-		smblogprint(-1, "smb%s: word count not %ud\n", name, wordcount);
+		smblogprint(-1, "smb%s: word count not %u\n", name, wordcount);
 		return 0;
 	}
 	return 1;
@@ -32,7 +32,7 @@ smbcheckwordandbytecount(char *name, SmbHeader *h, uint16_t wordcount,
 	uint16_t bytecount;
 	uint8_t *bdata;
 	if (h->wordcount != wordcount) {
-		smblogprint(-1, "smb%s: word count not %ud\n", name, wordcount);
+		smblogprint(-1, "smb%s: word count not %u\n", name, wordcount);
 		return 0;
 	}
 	bdata = *bdatap;

sys/src/cmd/aquarela/smbcomopen.c

@@ -153,7 +153,7 @@ openfile(SmbSession *s, SmbTree *t, char *path, uint16_t mode,
 	if (s->fidmap == nil)
 		s->fidmap = smbidmapnew();
 	*fidp = smbidmapadd(s->fidmap, f);
-//smblogprint(h->command, "REPLY:\n t->id=0x%ux fid=%d path=%s\n", t->id, *fidp, path);
+//smblogprint(h->command, "REPLY:\n t->id=0x%x fid=%d path=%s\n", t->id, *fidp, path);
 	smblogprintif(smbglobals.log.fids, "openfile: 0x%.4ux/0x%.4ux %s\n", t->id, *fidp, path);
 	if (actionp)
 		*actionp = action;
@@ -582,7 +582,7 @@ smbcomntcreateandx(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 
 	smblogprint(h->command, "namelength %d\n", namelength);
 	smblogprint(h->command, "flags 0x%.8lux\n", flags);
-	smblogprint(h->command, "rootdirectoryfid %lud\n", rootdirectoryfid);
+	smblogprint(h->command, "rootdirectoryfid %lu\n", rootdirectoryfid);
 	smblogprint(h->command, "desiredaccess 0x%.8lux", desiredaccess);
 	smbsblutlogprint(h->command, dasblut, desiredaccess);
 	smblogprint(h->command, "\n");

sys/src/cmd/aquarela/smbcomsessionsetupandx.c

@@ -76,13 +76,13 @@ smbcomsessionsetupandx(SmbSession *s, SmbHeader *h, uint8_t *pdata,
 	pdata += 4;
 	s->peerinfo.capabilities = smbnhgetl(pdata); /*pdata += 4;*/
 smbloglock();
-smblogprint(h->command, "andxcommand: %s offset %ud\n", smboptable[andxcommand].name, andxoffset);
-smblogprint(h->command, "client.maxbuffersize: %ud\n", s->peerinfo.maxlen);
-smblogprint(h->command, "client.maxmpxcount: %ud\n", s->client.maxmpxcount);
-smblogprint(h->command, "vcnumber: %ud\n", vcnumber);
+smblogprint(h->command, "andxcommand: %s offset %u\n", smboptable[andxcommand].name, andxoffset);
+smblogprint(h->command, "client.maxbuffersize: %u\n", s->peerinfo.maxlen);
+smblogprint(h->command, "client.maxmpxcount: %u\n", s->client.maxmpxcount);
+smblogprint(h->command, "vcnumber: %u\n", vcnumber);
 smblogprint(h->command, "sessionkey: 0x%.8lux\n", sessionkey);
-smblogprint(h->command, "caseinsensitivepasswordlength: %ud\n", caseinsensitivepasswordlength);
-smblogprint(h->command, "casesensitivepasswordlength: %ud\n", casesensitivepasswordlength);
+smblogprint(h->command, "caseinsensitivepasswordlength: %u\n", caseinsensitivepasswordlength);
+smblogprint(h->command, "casesensitivepasswordlength: %u\n", casesensitivepasswordlength);
 smblogprint(h->command, "clientcapabilities: 0x%.8lux\n", s->peerinfo.capabilities);
 smblogunlock();
 

sys/src/cmd/aquarela/smbcomsetinfo.c

@@ -100,7 +100,7 @@ smbcomsetinformation(SmbSession *s, SmbHeader *h, uint8_t *pdata,
 	if (!smbbuffergetstring(b, h, SMB_STRING_PATH, &name))
 		return SmbProcessResultFormat;
 	smblogprint(h->command,
-		"smbcomsetinformation: attr 0x%.4ux utime %lud path %s\n",
+		"smbcomsetinformation: attr 0x%.4ux utime %lu path %s\n",
 		attr, utime, name);
 	if (utime) {
 		Dir d;

sys/src/cmd/aquarela/smbcomtransaction.c

@@ -52,7 +52,7 @@ smbcomtransaction(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 		}
 		goto done;
 	}
-	smblogprint(h->command, "smbcomtransaction: %s scount %ud tpcount %lud tdcount %lud maxscount %lud maxpcount %lud maxdcount %lud\n",
+	smblogprint(h->command, "smbcomtransaction: %s scount %u tpcount %lu tdcount %lu maxscount %lu maxpcount %lu maxdcount %lu\n",
 		s->transaction.in.name, s->transaction.in.scount, s->transaction.in.tpcount, s->transaction.in.tdcount,
 		s->transaction.in.maxscount, s->transaction.in.maxpcount, s->transaction.in.maxdcount);
 	smbbufferfree(&s->transaction.out.parameters);
@@ -105,7 +105,7 @@ smbcomtransaction2(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 		}
 		goto done;
 	}
-	smblogprint(h->command, "smbcomtransaction2: scount %ud tpcount %lud tdcount %lud maxscount %lud maxpcount %lud maxdcount %lud\n",
+	smblogprint(h->command, "smbcomtransaction2: scount %u tpcount %lu tdcount %lu maxscount %lu maxpcount %lu maxdcount %lu\n",
 		s->transaction.in.scount, s->transaction.in.tpcount, s->transaction.in.tdcount,
 		s->transaction.in.maxscount, s->transaction.in.maxpcount, s->transaction.in.maxdcount);
 	smbbufferfree(&s->transaction.out.parameters);

sys/src/cmd/aquarela/smbcomtreeconnectandx.c

@@ -76,13 +76,13 @@ smbcomtreeconnectandx(SmbSession *s, SmbHeader *h, uint8_t *pdata,
 	flags = smbnhgets(pdata); pdata += 2;
 	passwordlength = smbnhgets(pdata); //pdata += 2;
 //	bytecount = smbnhgets(pdata); pdata += 2;
-smblogprint(h->command, "passwordlength: %ud\n", passwordlength);
+smblogprint(h->command, "passwordlength: %u\n", passwordlength);
 smblogprint(h->command, "flags: 0x%.4ux\n", flags);
 	if (!smbbuffergetbytes(b, nil, passwordlength)) {
 		smblogprint(h->command, "smbcomtreeconnectandx: not enough bytes for password\n");
 		goto fmtfail;
 	}
-smblogprint(h->command, "offset %lud limit %lud\n", smbbufferreadoffset(b), smbbufferwriteoffset(b));
+smblogprint(h->command, "offset %lu limit %lu\n", smbbufferreadoffset(b), smbbufferwriteoffset(b));
 	if (!smbbuffergetstring(b, h, SMB_STRING_PATH, &path)
 		|| !smbbuffergetstr(b, 0, &service)) {
 		smblogprint(h->command, "smbcomtreeconnectandx: not enough bytes for strings\n");

sys/src/cmd/aquarela/smbcomwrite.c

@@ -49,7 +49,7 @@ smbtruncatefile(SmbSession *s, SmbFile *f, int64_t offset)
 		int nfd;
 		char *fullpath;
 		if (offset > INMEMORYTRUNCTHRESH) {
-			smblogprint(-1, "smbcomwrite: truncation beyond %lud not supported\n", offset);
+			smblogprint(-1, "smbcomwrite: truncation beyond %lu not supported\n", offset);
 			pr = SmbProcessResultUnimp;
 			goto done;
 		}

sys/src/cmd/aquarela/smblisten.c

@@ -76,7 +76,7 @@ tcpreader(void *a)
 		flags = buf[1];
 		length = nhgets(buf + 2) | ((flags & 1) << 16);
 		if (length > buflen - 4) {
-			print("nbss: too much data (%ud)\n", length);
+			print("nbss: too much data (%u)\n", length);
 			goto die;
 		}
 		n = readn(s->fd, buf + 4, length);

sys/src/cmd/aquarela/smbrap2.c

@@ -241,7 +241,7 @@ netshareenum(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 	if (!smbbuffergets(inparam, &level))
 		return SmbProcessResultFormat;
 	
-	smblogprintif(smbglobals.log.rap2, "netshareenum(%lud, %lud)\n",
+	smblogprintif(smbglobals.log.rap2, "netshareenum(%lu, %lu)\n",
 		level, smbbufferwritespace(outdata));
 
 	if (level != 1)
@@ -275,7 +275,7 @@ netserverenum2(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 		goto done;
 	}
 	
-	smblogprintif(smbglobals.log.rap2, "netserverenum2(%lud, %lud, 0x%.8lux, %s)\n",
+	smblogprintif(smbglobals.log.rap2, "netserverenum2(%lu, %lu, 0x%.8lux, %s)\n",
 		level, smbbufferwritespace(outdata), servertype, domain);
 
 	if (level > 1)
@@ -330,7 +330,7 @@ netsharegetinfo(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 		goto done;
 	}
 	
-	smblogprintif(smbglobals.log.rap2, "netsharegetinfo(%s, %lud, %lud)\n",
+	smblogprintif(smbglobals.log.rap2, "netsharegetinfo(%s, %lu, %lu)\n",
 		netname, level, smbbufferwritespace(outdata));
 
 	if (level > 2)
@@ -368,7 +368,7 @@ netservergetinfo(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 		goto done;
 	}
 	
-	smblogprintif(smbglobals.log.rap2, "netservergetinfo(%lud, %lud)\n",
+	smblogprintif(smbglobals.log.rap2, "netservergetinfo(%lu, %lu)\n",
 		level, smbbufferwritespace(outdata));
 
 	if (level > 1)
@@ -398,7 +398,7 @@ netwkstagetinfo(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 		goto done;
 	}
 	
-	smblogprintif(smbglobals.log.rap2, "netwkstagetinfo(%lud, %lud)\n",
+	smblogprintif(smbglobals.log.rap2, "netwkstagetinfo(%lu, %lu)\n",
 		level, smbbufferwritespace(outdata));
 
 	if (level != 10)
@@ -467,7 +467,7 @@ smbrap2(SmbSession *s)
 		goto done;
 	}
 	if (pno > nelem(raptable) || raptable[pno].name == nil) {
-		smblogprint(-1, "smbrap2: unsupported procedure %ud\n", pno);
+		smblogprint(-1, "smbrap2: unsupported procedure %u\n", pno);
 		pr = SmbProcessResultUnimp;
 		goto done;
 	}

sys/src/cmd/aquarela/smbtrans2find.c

@@ -283,7 +283,7 @@ smbtrans2findnext2(SmbSession *s, SmbHeader *h)
 		goto done;
 	}
 	smblogprintif(debug,
-		"smbtrans2findnext2: sid %d scount %d infolevel 0x%.4ux resumekey %lud flags 0x%.4ux filename %s\n",
+		"smbtrans2findnext2: sid %d scount %d infolevel 0x%.4ux resumekey %lu flags 0x%.4ux filename %s\n",
 		sid, scount, infolevel, resumekey, flags, filename);
 
 	if (infolevel != SMB_INFO_STANDARD && infolevel != SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {

sys/src/cmd/aquarela/testnbdgram.c

@@ -87,7 +87,7 @@ deliver(void *, NbDgram *s)
 		goto done;
 	}
 */
-	print("%s: period %ludms version %d.%d type 0x%.8lux browserversion %d.%d comment %s\n",
+	print("%s: period %lums version %d.%d type 0x%.8lux browserversion %d.%d comment %s\n",
 		servername, periodicity, versionmajor, versionminor, type, (signature >> 8) & 0xff, signature & 0xff, comment);
 done:
 	free(errmsg);

sys/src/cmd/archfs.c

@@ -42,7 +42,7 @@ emalloc(int32_t sz)
 
 	v = malloc(sz);
 	if(v == nil)
-		sysfatal("malloc %lud fails", sz);
+		sysfatal("malloc %lu fails", sz);
 	memset(v, 0, sz);
 	return v;
 }

sys/src/cmd/auth/authsrv.c

@@ -199,7 +199,7 @@ challengebox(Ticketreq *tr)
 	memset(buf, 0, sizeof(buf));
 	buf[0] = AuthOK;
 	chal = lnrand(MAXNETCHAL);
-	snprint(buf+1, sizeof buf - 1, "%lud", chal);
+	snprint(buf+1, sizeof buf - 1, "%lu", chal);
 	if(write(1, buf, NETCHLEN+1) < 0)
 		exits(0);
 	if(readn(0, buf, NETCHLEN) < 0)
@@ -717,7 +717,7 @@ mschap(Ticketreq *tr)
 		exits(0);
 
 	if(debug)
-		replyerror("mschap-ok %s/%s(%s) %ux",
+		replyerror("mschap-ok %s/%s(%s) %x",
 			tr->uid, tr->hostid, raddr);
 
 	nthash(hash, secret);

sys/src/cmd/auth/factotum/confirm.c

@@ -118,7 +118,7 @@ confirmqueue(Req *r, Fsstate *fss)
 	for(i=0; i<fss->nconf; i++)
 		if(fss->conf[i].canuse == -1){
 			n++;
-			snprint(msg, sizeof msg, "confirm tag=%lud %A", fss->conf[i].tag, fss->conf[i].key->attr);
+			snprint(msg, sizeof msg, "confirm tag=%lu %A", fss->conf[i].tag, fss->conf[i].key->attr);
 			logbufappend(&confbuf, msg);
 		}
 	if(n == 0){
@@ -203,7 +203,7 @@ needkeyqueue(Req *r, Fsstate *fss)
 	if(*needkeyinuse == 0)
 		return -1;
 
-	snprint(msg, sizeof msg, "needkey tag=%lud %s", r->tag, fss->keyinfo);
+	snprint(msg, sizeof msg, "needkey tag=%lu %s", r->tag, fss->keyinfo);
 	logbufappend(&needkeybuf, msg);
 	*needlast = r;
 	r->aux = nil;

sys/src/cmd/auth/factotum/rpc.c

@@ -224,7 +224,7 @@ rpcrdwrlog(Fsstate *fss, char *rdwr, uint n, int ophase, int ret)
 
 	if(!debug)
 		return;
-	snprint(pre, sizeof pre, "%d: %s %ud in phase %s yields phase %s",
+	snprint(pre, sizeof pre, "%d: %s %u in phase %s yields phase %s",
 		fss->seqnum, rdwr, n, phasename(fss, ophase, buf0), phasename(fss, fss->phase, buf1));
 	logret(pre, fss, ret);
 }

sys/src/cmd/auth/guard.srv.c

@@ -79,7 +79,7 @@ main(int argc, char *argv[])
 	 * challenge-response
 	 */
 	chal = lnrand(MAXNETCHAL);
-	snprint(buf, sizeof buf, "challenge: %lud\nresponse: ", chal);
+	snprint(buf, sizeof buf, "challenge: %lu\nresponse: ", chal);
 	n = strlen(buf) + 1;
 	if(write(1, buf, n) != n){
 		if(debug)
@@ -118,7 +118,7 @@ main(int argc, char *argv[])
 				r = smprint("%.*s%s", Pinlen,
 					"******************", resp + Pinlen);
 			syslog(0, AUTHLOG,
-				"g-fail %s@%s: %s: resp %s to chal %lud",
+				"g-fail %s@%s: %s: resp %s to chal %lu",
 				user, raddr, err, r, chal);
 			free(r);
 		}

sys/src/cmd/auth/keyfs.c

@@ -484,7 +484,7 @@ Read(Fid *f)
 		if(!f->user->expire)
 			strcpy(data, "never\n");
 		else
-			sprint(data, "%lud\n", f->user->expire);
+			sprint(data, "%lu\n", f->user->expire);
 		if(n > strlen(data))
 			n = strlen(data);
 		thdr.count = n;
@@ -494,7 +494,7 @@ Read(Fid *f)
 			thdr.count = 0;
 			return 0;
 		}
-		sprint(data, "%lud\n", f->user->bad);
+		sprint(data, "%lu\n", f->user->bad);
 		if(n > strlen(data))
 			n = strlen(data);
 		thdr.count = n;
@@ -504,7 +504,7 @@ Read(Fid *f)
 			thdr.count = 0;
 			return 0;
 		}
-		sprint(data, "%ud\n", f->user->warnings);
+		sprint(data, "%u\n", f->user->warnings);
 		if(n > strlen(data))
 			n = strlen(data);
 		thdr.count = n;

sys/src/cmd/auth/lib/netcheck.c

@@ -36,7 +36,7 @@ netresp(char *key, int32_t chal, char *answer)
 	uint8_t buf[8];
 
 	memset(buf, 0, 8);
-	snprint((char *)buf, sizeof buf, "%lud", chal);
+	snprint((char *)buf, sizeof buf, "%lu", chal);
 	if(encrypt(key, buf, 8) < 0)
 		error("can't encrypt response");
 	chal = (buf[0]<<24)+(buf[1]<<16)+(buf[2]<<8)+buf[3];
@@ -96,7 +96,7 @@ smartcheck(void *key, int32_t chal, char *response)
 	uint8_t buf[2*8];
 	int i, c, cslo, cshi;
 
-	snprint((char*)buf, sizeof buf, "%lud        ", chal);
+	snprint((char*)buf, sizeof buf, "%lu        ", chal);
 	cslo = 0x52;
 	cshi = cslo;
 	for(i = 0; i < 8; i++){