Convert type names

Standardize on Rust-inspired type names.
Note, that `uintptr` is retained over `usize`
as an integer pointer type; the latter is
standard in Rust, but honestly looks a little
strange in C.

Signed-off-by: Dan Cross <cross@gajendra.net>

amd64/include/u.h

@@ -8,6 +8,18 @@
  */
 
 #define nil		((void*)0)
+
+typedef	unsigned char	u8;
+typedef	signed char	i8;
+typedef	unsigned short	u16;
+typedef signed short	i16;
+typedef	unsigned int	u32;
+typedef signed int	i32;
+typedef	unsigned long long u64;
+typedef signed long long i64;
+typedef u64 		usize;
+typedef	i64		isize;
+
 typedef	unsigned char	uint8_t;
 typedef signed char	int8_t;
 typedef	unsigned short	uint16_t;
@@ -21,9 +33,8 @@ typedef	long long	int64_t;
 typedef uint64_t	uintptr;
 typedef uint64_t	uintptr_t;
 typedef int64_t		intptr_t;
-typedef uint64_t	usize;
 typedef unsigned long	size_t;
-typedef	uint32_t	Rune;
+typedef	u32	Rune;
 typedef union FPdbleword FPdbleword;
 typedef uint64_t	jmp_buf[10]; // for registers.
 

riscv/include/u.h

@@ -8,6 +8,18 @@
  */
 
 #define nil		((void*)0)
+
+typedef	unsigned char	u8;
+typedef	signed char	i8;
+typedef	unsigned short	u16;
+typedef	signed short	i16;
+typedef	unsigned int	u32;
+typedef	signed int	i32;
+typedef	unsigned long long u64;
+typedef	signed long long i64;
+typedef	u64		usize;
+typedef	i64		isize;
+
 typedef	unsigned char	uint8_t;
 typedef signed char	int8_t;
 typedef	unsigned short	uint16_t;

sys/src/9/386/aoe.h

@@ -44,41 +44,41 @@ enum {
 };
 
 typedef struct {
-	uint8_t dst[Eaddrlen];
-	uint8_t src[Eaddrlen];
-	uint8_t type[2];
-	uint8_t verflag;
-	uint8_t error;
-	uint8_t major[2];
-	uint8_t minor;
-	uint8_t cmd;
-	uint8_t tag[4];
-	uint8_t payload[];
+	u8 dst[Eaddrlen];
+	u8 src[Eaddrlen];
+	u8 type[2];
+	u8 verflag;
+	u8 error;
+	u8 major[2];
+	u8 minor;
+	u8 cmd;
+	u8 tag[4];
+	u8 payload[];
 } Aoehdr;
 
 #define AOEHDRSZ offsetof(Aoehdr, payload[0])
 
 typedef struct {
 	Aoehdr;
-	uint8_t aflag;
-	uint8_t errfeat;
-	uint8_t scnt;
-	uint8_t cmdstat;
-	uint8_t lba[6];
-	uint8_t res[2];
-	uint8_t _payload[];
+	u8 aflag;
+	u8 errfeat;
+	u8 scnt;
+	u8 cmdstat;
+	u8 lba[6];
+	u8 res[2];
+	u8 _payload[];
 } Aoeata;
 
 #define AOEATASZ offsetof(Aoeata, payload[0])
 
 typedef struct {
 	Aoehdr;
-	uint8_t bufcnt[2];
-	uint8_t fwver[2];
-	uint8_t scnt;
-	uint8_t verccmd;
-	uint8_t cslen[2];
-	uint8_t payload[];
+	u8 bufcnt[2];
+	u8 fwver[2];
+	u8 scnt;
+	u8 verccmd;
+	u8 cslen[2];
+	u8 payload[];
 } Aoeqc;
 
 #define AOEQCSZ offsetof(Aoeqc, payload[0])

sys/src/9/386/devrtc.c

@@ -58,8 +58,8 @@ Dirtab rtcdir[] = {
 	{"rtc", {Qrtc, 0}, 0, 0664},
 };
 
-static uint32_t rtc2sec(Rtc *);
-static void sec2rtc(uint32_t, Rtc *);
+static u32 rtc2sec(Rtc *);
+static void sec2rtc(u32, Rtc *);
 
 void
 rtcinit(void)
@@ -80,8 +80,8 @@ rtcwalk(Chan *c, Chan *nc, char **name, int nname)
 	return devwalk(c, nc, name, nname, rtcdir, nelem(rtcdir), devgen);
 }
 
-static int32_t
-rtcstat(Chan *c, uint8_t *dp, int32_t n)
+static i32
+rtcstat(Chan *c, u8 *dp, i32 n)
 {
 	return devstat(c, dp, n, rtcdir, nelem(rtcdir), devgen);
 }
@@ -91,7 +91,7 @@ rtcopen(Chan *c, int omode)
 {
 	Proc *up = externup();
 	omode = openmode(omode);
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 	case Qrtc:
 		if(strcmp(up->user, eve) != 0 && omode != OREAD)
 			error(Eperm);
@@ -110,10 +110,10 @@ rtcclose(Chan *c)
 
 #define GETBCD(o) ((bcdclock[o] & 0xf) + 10 * (bcdclock[o] >> 4))
 
-static int32_t
+static i32
 rtcextract(void)
 {
-	uint8_t bcdclock[Nbcd];
+	u8 bcdclock[Nbcd];
 	Rtc rtc;
 	int i;
 
@@ -164,11 +164,11 @@ rtcextract(void)
 
 static Lock nvrtlock;
 
-int32_t
+i32
 rtctime(void)
 {
 	int i;
-	int32_t t, ot;
+	i32 t, ot;
 
 	ilock(&nvrtlock);
 
@@ -187,18 +187,18 @@ rtctime(void)
 	return t;
 }
 
-static int32_t
-rtcread(Chan *c, void *buf, int32_t n, int64_t off)
+static i32
+rtcread(Chan *c, void *buf, i32 n, i64 off)
 {
 	Proc *up = externup();
-	uint32_t t;
+	u32 t;
 	char *a, *start;
-	uint32_t offset = off;
+	u32 offset = off;
 
 	if(c->qid.type & QTDIR)
 		return devdirread(c, buf, n, rtcdir, nelem(rtcdir), devgen);
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 	case Qrtc:
 		t = rtctime();
 		n = readnum(offset, buf, n, t, 12);
@@ -235,22 +235,22 @@ rtcread(Chan *c, void *buf, int32_t n, int64_t off)
 
 #define PUTBCD(n, o) bcdclock[o] = (n % 10) | (((n / 10) % 10) << 4)
 
-static int32_t
-rtcwrite(Chan *c, void *buf, int32_t n, int64_t off)
+static i32
+rtcwrite(Chan *c, void *buf, i32 n, i64 off)
 {
 	Proc *up = externup();
 	int t;
 	char *a, *start;
 	Rtc rtc;
-	uint32_t secs;
-	uint8_t bcdclock[Nbcd];
+	u32 secs;
+	u8 bcdclock[Nbcd];
 	char *cp, *ep;
-	uint32_t offset = off;
+	u32 offset = off;
 
 	if(offset != 0)
 		error(Ebadarg);
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 	case Qrtc:
 		/*
 		 *  read the time
@@ -397,10 +397,10 @@ yrsize(int y)
 /*
  *  compute seconds since Jan 1 1970
  */
-static uint32_t
+static u32
 rtc2sec(Rtc *rtc)
 {
-	uint32_t secs;
+	u32 secs;
 	int i;
 	int *d2m;
 
@@ -433,10 +433,10 @@ rtc2sec(Rtc *rtc)
  *  compute rtc from seconds since Jan 1 1970
  */
 static void
-sec2rtc(uint32_t secs, Rtc *rtc)
+sec2rtc(u32 secs, Rtc *rtc)
 {
 	int d;
-	int32_t hms, day;
+	i32 hms, day;
 	int *d2m;
 
 	/*
@@ -481,10 +481,10 @@ sec2rtc(uint32_t secs, Rtc *rtc)
 	return;
 }
 
-uint8_t
+u8
 nvramread(int addr)
 {
-	uint8_t data;
+	u8 data;
 
 	ilock(&nvrtlock);
 	outb(Paddr, addr);
@@ -495,7 +495,7 @@ nvramread(int addr)
 }
 
 void
-nvramwrite(int addr, uint8_t data)
+nvramwrite(int addr, u8 data)
 {
 	ilock(&nvrtlock);
 	outb(Paddr, addr);

sys/src/9/386/ether8169.c

@@ -196,10 +196,10 @@ enum {			    /* Cplusc */
 
 typedef struct D D; /* Transmit/Receive Descriptor */
 struct D {
-	uint32_t control;
-	uint32_t vlan;
-	uint32_t addrlo;
-	uint32_t addrhi;
+	u32 control;
+	u32 vlan;
+	u32 addrlo;
+	u32 addrhi;
 };
 
 enum {			      /* Transmit Descriptor control */
@@ -250,19 +250,19 @@ enum { /* Ring sizes  (<= 1024) */
 
 typedef struct Dtcc Dtcc;
 struct Dtcc {
-	uint64_t txok;
-	uint64_t rxok;
-	uint64_t txer;
-	uint32_t rxer;
-	uint16_t misspkt;
-	uint16_t fae;
-	uint32_t tx1col;
-	uint32_t txmcol;
-	uint64_t rxokph;
-	uint64_t rxokbrd;
-	uint32_t rxokmu;
-	uint16_t txabt;
-	uint16_t txundrn;
+	u64 txok;
+	u64 rxok;
+	u64 txer;
+	u32 rxer;
+	u16 misspkt;
+	u16 fae;
+	u32 tx1col;
+	u32 txmcol;
+	u64 rxokph;
+	u64 rxokbrd;
+	u32 rxokmu;
+	u16 txabt;
+	u16 txundrn;
 };
 
 enum {					    /* Variants */
@@ -289,7 +289,7 @@ typedef struct Ctlr {
 	int phyv; /* PHY version */
 	int pcie; /* flag: pci-express device? */
 
-	uint64_t mchash; /* multicast hash */
+	u64 mchash; /* multicast hash */
 
 	Mii *mii;
 
@@ -345,8 +345,8 @@ static Ctlr *rtl8169ctlrtail;
 #define csr16r(c, r) (ins((c)->port + (r)))
 #define csr32r(c, r) (inl((c)->port + (r)))
 #define csr8w(c, r, b) (outb((c)->port + (r), (uint8_t)(b)))
-#define csr16w(c, r, w) (outs((c)->port + (r), (uint16_t)(w)))
-#define csr32w(c, r, l) (outl((c)->port + (r), (uint32_t)(l)))
+#define csr16w(c, r, w) (outs((c)->port + (r), (u16)(w)))
+#define csr32w(c, r, l) (outl((c)->port + (r), (u32)(l)))
 
 static int
 rtl8169miimir(Mii *mii, int pa, int ra)
@@ -477,13 +477,13 @@ enum {
 	Bytemask = (1 << 8) - 1,
 };
 
-static uint32_t
-ethercrcbe(unsigned char *addr, int32_t len)
+static u32
+ethercrcbe(unsigned char *addr, i32 len)
 {
 	int i, j;
-	uint32_t c, crc, carry;
+	u32 c, crc, carry;
 
-	crc = (uint32_t)~0UL;
+	crc = (u32)~0UL;
 	for(i = 0; i < len; i++){
 		c = addr[i];
 		for(j = 0; j < 8; j++){
@@ -497,8 +497,8 @@ ethercrcbe(unsigned char *addr, int32_t len)
 	return crc;
 }
 
-static uint32_t
-swabl(uint32_t l)
+static u32
+swabl(u32 l)
 {
 	return (l >> 24) | ((l >> 8) & (Bytemask << 8)) |
 	       ((l << 8) & (Bytemask << 16)) | (l << 24);
@@ -534,8 +534,8 @@ rtl8169multicast(void *ether, unsigned char *eaddr, int add)
 	iunlock(&ctlr->ilock);
 }
 
-static int32_t
-rtl8169ifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
+static i32
+rtl8169ifstat(Ether *edev, void *a, i32 n, u32 offset)
 {
 	Proc *up = externup();
 	char *p, *s, *e;
@@ -647,7 +647,7 @@ rtl8169halt(Ctlr *ctlr)
 static int
 rtl8169reset(Ctlr *ctlr)
 {
-	uint32_t r;
+	u32 r;
 	int timeo;
 
 	/*
@@ -694,8 +694,8 @@ rtl8169replenish(Ctlr *ctlr)
 				break;
 			}
 			ctlr->rb[rdt] = bp;
-			d->addrlo = (uint32_t)PADDR(bp->rp);
-			d->addrhi = (uint32_t)(PADDR(bp->rp) >> 32);
+			d->addrlo = (u32)PADDR(bp->rp);
+			d->addrhi = (u32)(PADDR(bp->rp) >> 32);
 			coherence();
 		} else
 			iprint("i8169: rx overrun\n");
@@ -710,10 +710,10 @@ static int
 rtl8169init(Ether *edev)
 {
 	int i;
-	uint32_t r;
+	u32 r;
 	Block *bp;
 	Ctlr *ctlr;
-	uint8_t cplusc;
+	u8 cplusc;
 
 	ctlr = edev->ctlr;
 	ilock(&ctlr->ilock);
@@ -1007,8 +1007,8 @@ rtl8169transmit(Ether *edev)
 			break;
 
 		d = &ctlr->td[x];
-		d->addrlo = (uint32_t)PADDR(bp->rp);
-		d->addrhi = (uint32_t)(PADDR(bp->rp) >> 32);
+		d->addrlo = (u32)PADDR(bp->rp);
+		d->addrhi = (u32)(PADDR(bp->rp) >> 32);
 		ctlr->tb[x] = bp;
 		coherence();
 		d->control |= Own | Fs | Ls | BLEN(bp);
@@ -1034,7 +1034,7 @@ rtl8169receive(Ether *edev)
 	int rdh, passed;
 	Block *bp;
 	Ctlr *ctlr;
-	uint32_t control;
+	u32 control;
 
 	ctlr = edev->ctlr;
 
@@ -1107,7 +1107,7 @@ rtl8169interrupt(Ureg *u, void *arg)
 {
 	Ctlr *ctlr;
 	Ether *edev;
-	uint32_t isr;
+	u32 isr;
 
 	edev = arg;
 	ctlr = edev->ctlr;
@@ -1273,7 +1273,7 @@ rtl8169pci(void)
 static int
 rtl8169pnp(Ether *edev)
 {
-	uint32_t r;
+	u32 r;
 	Ctlr *ctlr;
 	unsigned char ea[Eaddrlen];
 	static int once;

sys/src/9/386/ether82557.c

@@ -111,12 +111,12 @@ enum {			      /* Mcr */
 
 typedef struct Rfd {
 	int field;
-	uint32_t link;
-	uint32_t rbd;
-	uint16_t count;
-	uint16_t size;
+	u32 link;
+	u32 rbd;
+	u16 count;
+	u16 size;
 
-	uint8_t data[1700];
+	u8 data[1700];
 } Rfd;
 
 enum { /* field */
@@ -147,20 +147,20 @@ enum { /* count */
 
 typedef struct Cb Cb;
 typedef struct Cb {
-	uint16_t status;
-	uint16_t command;
-	uint32_t link;
+	u16 status;
+	u16 command;
+	u32 link;
 	union {
-		uint8_t data[24]; /* CbIAS + CbConfigure */
+		u8 data[24]; /* CbIAS + CbConfigure */
 		struct {
-			uint32_t tbd;
-			uint16_t count;
-			uint8_t threshold;
-			uint8_t number;
-
-			uint32_t tba;
-			uint16_t tbasz;
-			uint16_t pad;
+			u32 tbd;
+			u16 count;
+			u8 threshold;
+			u8 number;
+
+			u32 tba;
+			u16 tbasz;
+			u16 pad;
 		};
 	};
 
@@ -204,7 +204,7 @@ typedef struct Ctlr {
 	int active;
 
 	int eepromsz; /* address size in bits */
-	uint16_t *eeprom;
+	u16 *eeprom;
 
 	Lock miilock;
 
@@ -220,7 +220,7 @@ typedef struct Ctlr {
 	Lock cblock; /* transmit side */
 	int action;
 	int nop;
-	uint8_t configdata[24];
+	u8 configdata[24];
 	int threshold;
 	int ncb;
 	Cb *cbr;
@@ -231,13 +231,13 @@ typedef struct Ctlr {
 	int cbqmaxhw;
 
 	Lock dlock; /* dump statistical counters */
-	uint32_t dump[17];
+	u32 dump[17];
 } Ctlr;
 
 static Ctlr *ctlrhead;
 static Ctlr *ctlrtail;
 
-static uint8_t configdata[24] = {
+static u8 configdata[24] = {
 	0x16, /* byte count */
 	0x08, /* Rx/Tx FIFO limit */
 	0x00, /* adaptive IFS */
@@ -268,8 +268,8 @@ static uint8_t configdata[24] = {
 #define csr16r(c, r) (ins((c)->port + (r)))
 #define csr32r(c, r) (inl((c)->port + (r)))
 #define csr8w(c, r, b) (outb((c)->port + (r), (int)(b)))
-#define csr16w(c, r, w) (outs((c)->port + (r), (uint16_t)(w)))
-#define csr32w(c, r, l) (outl((c)->port + (r), (uint32_t)(l)))
+#define csr16w(c, r, w) (outs((c)->port + (r), (u16)(w)))
+#define csr32w(c, r, l) (outl((c)->port + (r), (u32)(l)))
 
 static void
 command(Ctlr *ctlr, int c, int v)
@@ -332,7 +332,7 @@ command(Ctlr *ctlr, int c, int v)
 }
 
 static Block *
-rfdalloc(uint32_t link)
+rfdalloc(u32 link)
 {
 	Block *bp;
 	Rfd *rfd;
@@ -413,13 +413,13 @@ attach(Ether *ether)
 
 static int miir(Ctlr *, int, int);
 
-static int32_t
-ifstat(Ether *ether, void *a, int32_t n, uint32_t offset)
+static i32
+ifstat(Ether *ether, void *a, i32 n, u32 offset)
 {
 	char *p;
 	int i, len, phyaddr;
 	Ctlr *ctlr;
-	uint32_t dump[17];
+	u32 dump[17];
 
 	ctlr = ether->ctlr;
 	lock(&ctlr->dlock);
@@ -593,7 +593,7 @@ promiscuous(void *arg, int on)
 }
 
 static void
-multicast(void *ether, uint8_t *addr, int add)
+multicast(void *ether, u8 *addr, int add)
 {
 	USED(addr);
 	/*
@@ -771,7 +771,7 @@ ctlrinit(Ctlr *ctlr)
 	int i;
 	Block *bp;
 	Rfd *rfd;
-	uint32_t link;
+	u32 link;
 
 	/*
 	 * Create the Receive Frame Area (RFA) as a ring of allocated
@@ -917,7 +917,7 @@ reread:
 
 	if(ctlr->eepromsz == 0){
 		ctlr->eepromsz = 8 - size;
-		ctlr->eeprom = malloc((1 << ctlr->eepromsz) * sizeof(uint16_t));
+		ctlr->eeprom = malloc((1 << ctlr->eepromsz) * sizeof(u16));
 		goto reread;
 	}
 
@@ -1044,7 +1044,7 @@ reset(Ether *ether)
 {
 	int anar, anlpar, bmcr, bmsr, i, k, medium, phyaddr, x;
 	unsigned short sum;
-	uint8_t ea[Eaddrlen];
+	u8 ea[Eaddrlen];
 	Ctlr *ctlr;
 
 	if(ctlrhead == nil)

sys/src/9/386/etherigbe.c

@@ -372,11 +372,11 @@ enum {			       /* Receive Delay Timer Ring */
 
 typedef struct Rd { /* Receive Descriptor */
 	uint addr[2];
-	uint16_t length;
-	uint16_t checksum;
+	u16 length;
+	u16 checksum;
 	unsigned char status;
 	unsigned char errors;
-	uint16_t special;
+	u16 special;
 } Rd;
 
 enum {		     /* Rd status */
@@ -406,10 +406,10 @@ struct Td { /* Transmit Descriptor */
 		struct {      /* Context */
 			unsigned char ipcss;
 			unsigned char ipcso;
-			uint16_t ipcse;
+			u16 ipcse;
 			unsigned char tucss;
 			unsigned char tucso;
-			uint16_t tucse;
+			u16 tucse;
 		};
 	};
 	uint control;
@@ -469,7 +469,7 @@ struct Ctlr {
 	int started;
 	int id;
 	int cls;
-	uint16_t eeprom[0x40];
+	u16 eeprom[0x40];
 
 	QLock alock; /* attach */
 	void *alloc; /* receive/transmit descriptors */
@@ -504,7 +504,7 @@ struct Ctlr {
 	uint tcpcs;
 
 	unsigned char ra[Eaddrlen]; /* receive address */
-	uint32_t mta[128];	    /* multicast table array */
+	u32 mta[128];	    /* multicast table array */
 
 	Rendez rrendez;
 	int rim;
@@ -604,13 +604,13 @@ static char *statistics[Nstatistics] = {
 	"TCP Segmentation Context Fail",
 };
 
-static int32_t
-igbeifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
+static i32
+igbeifstat(Ether *edev, void *a, i32 n, u32 offset)
 {
 	Ctlr *ctlr;
 	char *p, *s, *e;
 	int i, l, r;
-	uint64_t tuvl, ruvl;
+	u64 tuvl, ruvl;
 
 	ctlr = edev->ctlr;
 	qlock(&ctlr->slock);
@@ -630,10 +630,10 @@ igbeifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
 		case Torl:
 		case Totl:
 			ruvl = r;
-			ruvl += ((uint64_t)csr32r(ctlr, Statistics + (i + 1) * 4)) << 32;
+			ruvl += ((u64)csr32r(ctlr, Statistics + (i + 1) * 4)) << 32;
 			tuvl = ruvl;
 			tuvl += ctlr->statistics[i];
-			tuvl += ((uint64_t)ctlr->statistics[i + 1]) << 32;
+			tuvl += ((u64)ctlr->statistics[i + 1]) << 32;
 			if(tuvl == 0)
 				continue;
 			ctlr->statistics[i] = tuvl;
@@ -704,8 +704,8 @@ static Cmdtab igbectlmsg[] = {
 	{CMrdtr, "rdtr", 2},
 };
 
-static int32_t
-igbectl(Ether *edev, void *buf, int32_t n)
+static i32
+igbectl(Ether *edev, void *buf, i32 n)
 {
 	Proc *up = externup();
 	int v;
@@ -1032,8 +1032,8 @@ igbetransmit(Ether *edev)
 		if((bp = qget(edev->oq)) == nil)
 			break;
 		td = &ctlr->tdba[tdt];
-		td->addr[0] = (uint32_t)PADDR(bp->rp);
-		td->addr[1] = (uint32_t)(PADDR(bp->rp) >> 32);
+		td->addr[0] = (u32)PADDR(bp->rp);
+		td->addr[1] = (u32)(PADDR(bp->rp) >> 32);
 		td->control = ((BLEN(bp) & LenMASK) << LenSHIFT);
 		td->control |= Dext | Ifcs | Teop | DtypeDD;
 		ctlr->tb[tdt] = bp;
@@ -1073,8 +1073,8 @@ igbereplenish(Ctlr *ctlr)
 				break;
 			}
 			ctlr->rb[rdt] = bp;
-			rd->addr[0] = (uint32_t)PADDR(bp->rp);
-			rd->addr[1] = (uint32_t)(PADDR(bp->rp) >> 32);
+			rd->addr[0] = (u32)PADDR(bp->rp);
+			rd->addr[1] = (u32)(PADDR(bp->rp) >> 32);
 		}
 		coherence();
 		rd->status = 0;
@@ -1687,7 +1687,7 @@ at93c46io(Ctlr *ctlr, char *op, int data)
 static int
 at93c46r(Ctlr *ctlr)
 {
-	uint16_t sum;
+	u16 sum;
 	char rop[20];
 	int addr, areq, bits, data, eecd, i;
 

sys/src/9/386/etherm10g.c

@@ -106,13 +106,13 @@ enum {
 
 typedef union {
 	uint i[2];
-	uint8_t c[8];
+	u8 c[8];
 } Cmd;
 
-typedef uint32_t Slot;
+typedef u32 Slot;
 typedef struct {
-	uint16_t cksum;
-	uint16_t len;
+	u16 cksum;
+	u16 len;
 } Slotparts;
 
 enum {
@@ -123,14 +123,14 @@ enum {
 };
 
 typedef struct {
-	uint32_t high;
-	uint32_t low;
-	uint16_t hdroff;
-	uint16_t len;
-	uint8_t pad;
-	uint8_t nrdma;
-	uint8_t chkoff;
-	uint8_t flags;
+	u32 high;
+	u32 low;
+	u16 hdroff;
+	u16 len;
+	u8 pad;
+	u8 nrdma;
+	u8 chkoff;
+	u8 flags;
 } Send;
 
 typedef struct {
@@ -140,14 +140,14 @@ typedef struct {
 	Block **bring;
 	//	uchar	*wcfifo;	/* what the heck is a w/c fifo? */
 	int size; /* of buffers in the z8's memory */
-	uint32_t segsz;
+	u32 segsz;
 	uint n;	  /* rxslots */
 	uint m;	  /* mask; rxslots must be a power of two */
 	uint i;	  /* number of segments (not frames) queued */
 	uint cnt; /* number of segments sent by the card */
 
-	uint32_t npkt;
-	int64_t nbytes;
+	u32 npkt;
+	i64 nbytes;
 } Tx;
 
 typedef struct {
@@ -167,7 +167,7 @@ static Bpool bgpool = {
 
 typedef struct {
 	Bpool *pool;	 /* free buffers */
-	uint32_t *lanai; /* rx ring; we have no permanent host shadow */
+	u32 *lanai; /* rx ring; we have no permanent host shadow */
 	Block **host;	 /* called "info" in myricom driver */
 			 //	uchar	*wcfifo;	/* cmd submission fifo */
 	uint m;
@@ -179,19 +179,19 @@ typedef struct {
 
 /* dma mapped.  unix network byte order. */
 typedef struct {
-	uint8_t txcnt[4];
-	uint8_t linkstat[4];
-	uint8_t dlink[4];
-	uint8_t derror[4];
-	uint8_t drunt[4];
-	uint8_t doverrun[4];
-	uint8_t dnosm[4];
-	uint8_t dnobg[4];
-	uint8_t nrdma[4];
-	uint8_t txstopped;
-	uint8_t down;
-	uint8_t updated;
-	uint8_t valid;
+	u8 txcnt[4];
+	u8 linkstat[4];
+	u8 dlink[4];
+	u8 derror[4];
+	u8 drunt[4];
+	u8 doverrun[4];
+	u8 dnosm[4];
+	u8 dnobg[4];
+	u8 nrdma[4];
+	u8 txstopped;
+	u8 down;
+	u8 updated;
+	u8 valid;
 } Stats;
 
 enum {
@@ -202,7 +202,7 @@ enum {
 
 typedef struct {
 	Slot *entry;
-	uint64_t busaddr;
+	u64 busaddr;
 	uint m;
 	uint n;
 	uint i;
@@ -213,7 +213,7 @@ typedef struct Ctlr {
 	QLock QLock;
 	int state;
 	int kprocs;
-	uint64_t port;
+	u64 port;
 	Pcidev *pcidev;
 	Ctlr *next;
 	int active;
@@ -224,32 +224,32 @@ typedef struct Ctlr {
 	int ramsz;
 	unsigned char *ram;
 
-	uint32_t *irqack;
-	uint32_t *irqdeass;
-	uint32_t *coal;
+	u32 *irqack;
+	u32 *irqdeass;
+	u32 *coal;
 
 	char eprom[Epromsz];
-	uint32_t serial; /* unit serial number */
+	u32 serial; /* unit serial number */
 
 	QLock cmdl;
 	Cmd *cmd;      /* address of command return */
-	uint64_t cprt; /* bus address of command */
+	u64 cprt; /* bus address of command */
 
-	uint64_t boot; /* boot address */
+	u64 boot; /* boot address */
 
 	Done done;
 	Tx tx;
 	Rx sm;
 	Rx bg;
 	Stats *stats;
-	uint64_t statsprt;
+	u64 statsprt;
 
 	Rendez rxrendez;
 	Rendez txrendez;
 
 	int msi;
-	uint32_t linkstat;
-	uint32_t nrdma;
+	u32 linkstat;
+	u32 nrdma;
 } Ctlr;
 
 static Ctlr *ctlrs;
@@ -354,7 +354,7 @@ whichfw(Pcidev *p)
 {
 	char *s;
 	int i, off, lanes, ecrc;
-	uint32_t cap;
+	u32 cap;
 
 	/* check the number of configured lanes. */
 	off = pcicap(p, PciCapPCIe);
@@ -424,35 +424,35 @@ parseeprom(Ctlr *c)
 	return 0;
 }
 
-static uint16_t
-pbit16(uint16_t i)
+static u16
+pbit16(u16 i)
 {
-	uint16_t j;
-	uint8_t *p;
+	u16 j;
+	u8 *p;
 
-	p = (uint8_t *)&j;
+	p = (u8 *)&j;
 	p[1] = i;
 	p[0] = i >> 8;
 	return j;
 }
 
-static uint16_t
-gbit16(uint8_t i[2])
+static u16
+gbit16(u8 i[2])
 {
-	uint16_t j;
+	u16 j;
 
 	j = i[1];
 	j |= i[0] << 8;
 	return j;
 }
 
-static uint32_t
-pbit32(uint32_t i)
+static u32
+pbit32(u32 i)
 {
-	uint32_t j;
-	uint8_t *p;
+	u32 j;
+	u8 *p;
 
-	p = (uint8_t *)&j;
+	p = (u8 *)&j;
 	p[3] = i;
 	p[2] = i >> 8;
 	p[1] = i >> 16;
@@ -460,10 +460,10 @@ pbit32(uint32_t i)
 	return j;
 }
 
-static uint32_t
-gbit32(uint8_t i[4])
+static u32
+gbit32(u8 i[4])
 {
-	uint32_t j;
+	u32 j;
 
 	j = i[3];
 	j |= i[2] << 8;
@@ -490,11 +490,11 @@ prepcmd(uint *cmd, int i)
  * 40 byte = 5 int pad.
  */
 
-uint32_t
-cmd(Ctlr *c, int type, uint64_t data)
+u32
+cmd(Ctlr *c, int type, u64 data)
 {
 	Proc *up = externup();
-	uint32_t buf[16], i;
+	u32 buf[16], i;
 	Cmd *cmd;
 
 	qlock(&c->cmdl);
@@ -530,11 +530,11 @@ cmd(Ctlr *c, int type, uint64_t data)
 	return ~0; /* silence! */
 }
 
-uint32_t
-maccmd(Ctlr *c, int type, uint8_t *mac)
+u32
+maccmd(Ctlr *c, int type, u8 *mac)
 {
 	Proc *up = externup();
-	uint32_t buf[16], i;
+	u32 buf[16], i;
 	Cmd *cmd;
 
 	qlock(&c->cmdl);
@@ -576,11 +576,11 @@ enum {
 	DMAwrite = 0x1,
 };
 
-uint32_t
-dmatestcmd(Ctlr *c, int type, uint64_t addr, int len)
+u32
+dmatestcmd(Ctlr *c, int type, u64 addr, int len)
 {
 	Proc *up = externup();
-	uint32_t buf[16], i;
+	u32 buf[16], i;
 
 	memset(buf, 0, sizeof buf);
 	memset(c->cmd, Noconf, sizeof *c->cmd);
@@ -610,11 +610,11 @@ dmatestcmd(Ctlr *c, int type, uint64_t addr, int len)
 	return ~0; /* silence! */
 }
 
-uint32_t
+u32
 rdmacmd(Ctlr *c, int on)
 {
 	Proc *up = externup();
-	uint32_t buf[16], i;
+	u32 buf[16], i;
 
 	memset(buf, 0, sizeof buf);
 	c->cmd->i[0] = 0;
@@ -649,14 +649,14 @@ loadfw(Ctlr *c, int *align)
 	int i;
 
 	if((*align = whichfw(c->pcidev)) == 4 * KiB){
-		f = (uint32_t *)fw4k;
+		f = (u32 *)fw4k;
 		sz = sizeof fw4k;
 	} else {
-		f = (uint32_t *)fw2k;
+		f = (u32 *)fw2k;
 		sz = sizeof fw2k;
 	}
 
-	s = (uint32_t *)(c->ram + Fwoffset);
+	s = (u32 *)(c->ram + Fwoffset);
 	for(i = 0; i < sz / 4; i++)
 		s[i] = f[i];
 	return sz & ~3;
@@ -722,13 +722,13 @@ kickthebaby(Pcidev *p, Ctlr *c)
 #endif
 
 typedef struct {
-	uint8_t len[4];
-	uint8_t type[4];
+	u8 len[4];
+	u8 type[4];
 	char version[128];
-	uint8_t globals[4];
-	uint8_t ramsz[4];
-	uint8_t specs[4];
-	uint8_t specssz[4];
+	u8 globals[4];
+	u8 ramsz[4];
+	u8 specs[4];
+	u8 specssz[4];
 } Fwhdr;
 
 enum {
@@ -739,7 +739,7 @@ enum {
 };
 
 static char *
-fwtype(uint32_t type)
+fwtype(u32 type)
 {
 	switch(type){
 	case Tmx:
@@ -757,14 +757,14 @@ fwtype(uint32_t type)
 static int
 chkfw(Ctlr *c)
 {
-	uintptr_t off;
+	uintptr off;
 	Fwhdr *h;
-	uint32_t type;
+	u32 type;
 
 	off = gbit32(c->ram + 0x3c);
-	dprint("firmware %llx\n", (uint64_t)off);
+	dprint("firmware %llx\n", (u64)off);
 	if((off & 3) || off + sizeof *h > c->ramsz){
-		print("!m10g: bad firmware %llx\n", (uint64_t)off);
+		print("!m10g: bad firmware %llx\n", (u64)off);
 		return -1;
 	}
 	h = (Fwhdr *)(c->ram + off);
@@ -790,7 +790,7 @@ static int
 reset(Ether *e, Ctlr *c)
 {
 	Proc *up = externup();
-	uint32_t i, sz;
+	u32 i, sz;
 
 	if(waserror()){
 		print("m10g: reset error\n");
@@ -803,11 +803,11 @@ reset(Ether *e, Ctlr *c)
 
 	cmd(c, CSintrqsz, c->done.n * sizeof *c->done.entry);
 	cmd(c, CSintrqdma, c->done.busaddr);
-	c->irqack = (uint32_t *)(c->ram + cmd(c, CGirqackoff, 0));
+	c->irqack = (u32 *)(c->ram + cmd(c, CGirqackoff, 0));
 	/* required only if we're not doing msi? */
-	c->irqdeass = (uint32_t *)(c->ram + cmd(c, CGirqdeassoff, 0));
+	c->irqdeass = (u32 *)(c->ram + cmd(c, CGirqdeassoff, 0));
 	/* this is the driver default, why fiddle with this? */
-	c->coal = (uint32_t *)(c->ram + cmd(c, CGcoaloff, 0));
+	c->coal = (u32 *)(c->ram + cmd(c, CGcoaloff, 0));
 	*c->coal = pbit32(25);
 
 	dprint("dma stats:\n");
@@ -854,8 +854,8 @@ ctlrfree(Ctlr *c)
 static int
 setmem(Pcidev *p, Ctlr *c)
 {
-	uint32_t i;
-	uint64_t raddr;
+	u32 i;
+	u64 raddr;
 	Done *d;
 	void *mem;
 
@@ -920,7 +920,7 @@ smbfree(Block *b)
 {
 	Bpool *p;
 
-	b->rp = b->wp = (uint8_t *)ROUNDUP((uintptr_t)b->base, 4 * KiB);
+	b->rp = b->wp = (u8 *)ROUNDUP((uintptr)b->base, 4 * KiB);
 	b->flag &= ~(Bpktck | Btcpck | Budpck | Bipck);
 
 	p = &smpool;
@@ -937,7 +937,7 @@ bgbfree(Block *b)
 {
 	Bpool *p;
 
-	b->rp = b->wp = (uint8_t *)ROUNDUP((uintptr_t)b->base, 4 * KiB);
+	b->rp = b->wp = (u8 *)ROUNDUP((uintptr)b->base, 4 * KiB);
 	b->flag &= ~(Bpktck | Btcpck | Budpck | Bipck);
 
 	p = &bgpool;
@@ -952,7 +952,7 @@ bgbfree(Block *b)
 static void
 replenish(Rx *rx)
 {
-	uint32_t buf[16], i, idx, e;
+	u32 buf[16], i, idx, e;
 	Bpool *p;
 	Block *b;
 
@@ -966,7 +966,7 @@ replenish(Rx *rx)
 		idx = rx->cnt & rx->m;
 		for(i = 0; i < 8; i++){
 			b = balloc(rx);
-			buf[i * 2] = pbit32((uint64_t)PADDR(b->wp) >> 32);
+			buf[i * 2] = pbit32((u64)PADDR(b->wp) >> 32);
 			buf[i * 2 + 1] = pbit32(PADDR(b->wp));
 			rx->host[idx + i] = b;
 			assert(b);
@@ -1027,7 +1027,7 @@ open0(Ether *e, Ctlr *c)
 	entries = cmd(c, CGrxrgsz, 0) / 8;
 	c->sm.pool = &smpool;
 	cmd(c, CSsmallsz, c->sm.pool->size);
-	c->sm.lanai = (uint32_t *)(c->ram + cmd(c, CGsmallrxoff, 0));
+	c->sm.lanai = (u32 *)(c->ram + cmd(c, CGsmallrxoff, 0));
 	c->sm.n = entries;
 	c->sm.m = entries - 1;
 	c->sm.host = emalign(entries * sizeof *c->sm.host);
@@ -1035,7 +1035,7 @@ open0(Ether *e, Ctlr *c)
 	c->bg.pool = &bgpool;
 	c->bg.pool->size = nextpow(2 + e->Netif.maxmtu); /* 2-byte alignment pad */
 	cmd(c, CSbigsz, c->bg.pool->size);
-	c->bg.lanai = (uint32_t *)(c->ram + cmd(c, CGbigrxoff, 0));
+	c->bg.lanai = (u32 *)(c->ram + cmd(c, CGbigrxoff, 0));
 	c->bg.n = entries;
 	c->bg.m = entries - 1;
 	c->bg.host = emalign(entries * sizeof *c->bg.host);
@@ -1066,7 +1066,7 @@ static Block *
 nextblock(Ctlr *c)
 {
 	uint i;
-	uint16_t l, k;
+	u16 l, k;
 	Block *b;
 	Done *d;
 	Rx *rx;
@@ -1083,7 +1083,7 @@ nextblock(Ctlr *c)
 	k = sp->cksum;
 	s[i] = 0;
 	d->i++;
-	l = gbit16((uint8_t *)&l);
+	l = gbit16((u8 *)&l);
 	//dprint("nextb: i=%d l=%d\n", d->i, l);
 	rx = whichrx(c, l);
 	if(rx->i >= rx->cnt){
@@ -1144,7 +1144,7 @@ m10rx(void *v)
 }
 
 static void
-txcleanup(Tx *tx, uint32_t n)
+txcleanup(Tx *tx, u32 n)
 {
 	Block *b;
 	uint j, l, m;
@@ -1221,7 +1221,7 @@ submittx(Tx *tx, int n)
 static int
 nsegments(Block *b, int segsz)
 {
-	uintptr_t bus, end, slen, len;
+	uintptr bus, end, slen, len;
 	int i;
 
 	bus = PADDR(b->rp);
@@ -1240,9 +1240,9 @@ nsegments(Block *b, int segsz)
 static void
 m10gtransmit(Ether *e)
 {
-	uint16_t slen;
-	uint32_t i, cnt, rdma, nseg, count, end, bus, len, segsz;
-	uint8_t flags;
+	u16 slen;
+	u32 i, cnt, rdma, nseg, count, end, bus, len, segsz;
+	u8 flags;
 	Block *b;
 	Ctlr *c;
 	Send *s, *s0, *s0m8;
@@ -1299,7 +1299,7 @@ m10gtransmit(Ether *e)
 static void
 checkstats(Ether *e, Ctlr *c, Stats *s)
 {
-	uint32_t i;
+	u32 i;
 
 	if(s->updated == 0)
 		return;
@@ -1417,8 +1417,8 @@ lstcount(Block *b)
 	return i;
 }
 
-static int32_t
-m10gifstat(Ether *e, void *v, int32_t n, uint32_t off)
+static i32
+m10gifstat(Ether *e, void *v, i32 n, u32 off)
 {
 	int l, lim;
 	char *p;
@@ -1470,7 +1470,7 @@ m10gifstat(Ether *e, void *v, int32_t n, uint32_t off)
 		c->tx.cnt, c->tx.n, c->tx.i,
 		c->sm.cnt, c->sm.i, c->sm.pool->n, lstcount(c->sm.pool->head),
 		c->bg.cnt, c->bg.i, c->bg.pool->n, lstcount(c->bg.pool->head),
-		c->tx.segsz, gbit32((uint8_t *)c->coal));
+		c->tx.segsz, gbit32((u8 *)c->coal));
 
 	n = readstr(off, v, n, p);
 	free(p);
@@ -1537,8 +1537,8 @@ static Cmdtab ctab[] = {
 	{CMrxring, "rxring", 1},
 };
 
-static int32_t
-m10gctl(Ether *e, void *v, int32_t n)
+static i32
+m10gctl(Ether *e, void *v, i32 n)
 {
 	Proc *up = externup();
 	int i;
@@ -1611,7 +1611,7 @@ static int mcctab[] = {CSleavemc, CSjoinmc};
 static char *mcntab[] = {"leave", "join"};
 
 static void
-m10gmulticast(void *v, uint8_t *ea, int on)
+m10gmulticast(void *v, u8 *ea, int on)
 {
 	Ether *e;
 	int i;

sys/src/9/386/i8042.c

@@ -770,7 +770,7 @@ void (*kbdmouse)(int);
 static int nokeyb = 1;
 
 static Lock i8042lock;
-static uint8_t ccc;
+static u8 ccc;
 static void (*auxputc)(int, int);
 
 enum {
@@ -941,7 +941,7 @@ inready(void)
 void
 i8042systemreset(void)
 {
-	uint16_t *s = KADDR(0x472);
+	u16 *s = KADDR(0x472);
 	int i, x;
 
 	if(nokeyb)
@@ -1005,7 +1005,7 @@ i8042auxcmd(int cmd)
 }
 
 int
-i8042auxcmds(uint8_t *cmd, int ncmd)
+i8042auxcmds(u8 *cmd, int ncmd)
 {
 	int i;
 
@@ -1293,7 +1293,7 @@ mousecmd(int cmd)
 }
 
 static int
-mousecmds(uint8_t *cmd, int ncmd)
+mousecmds(u8 *cmd, int ncmd)
 {
 	int i;
 
@@ -1329,14 +1329,14 @@ outbyte(int port, int c)
 	return 0;
 }
 
-static int32_t
-mouserwrite(Chan *c, void *vbuf, int32_t len, int64_t off64)
+static i32
+mouserwrite(Chan *c, void *vbuf, i32 len, i64 off64)
 {
 	return mousecmds(vbuf, len);
 }
 
-static int32_t
-mouseread(Chan *c, void *vbuf, int32_t len, int64_t off64)
+static i32
+mouseread(Chan *c, void *vbuf, i32 len, i64 off64)
 {
 	return qread(mouseq, vbuf, len);
 }
@@ -1430,8 +1430,8 @@ keybinit(void)
 	iunlock(&i8042lock);
 }
 
-static int32_t
-keybread(Chan *c, void *vbuf, int32_t len, int64_t off64)
+static i32
+keybread(Chan *c, void *vbuf, i32 len, i64 off64)
 {
 	return qread(keybq, vbuf, len);
 }
@@ -1454,7 +1454,7 @@ keybenable(void)
 }
 
 void
-kbdputmap(uint16_t m, uint16_t scanc, Rune r)
+kbdputmap(u16 m, u16 scanc, Rune r)
 {
 	if(scanc >= Nscan)
 		error(Ebadarg);

sys/src/9/386/pci.c

@@ -107,10 +107,10 @@ tbdffmt(Fmt *fmt)
 	return r;
 }
 
-static uint32_t
+static u32
 pcibarsize(Pcidev *p, int rno)
 {
-	uint32_t v, size;
+	u32 v, size;
 
 	v = pcicfgr32(p, rno);
 	pcicfgw32(p, rno, 0xFFFFFFF0);
@@ -311,33 +311,33 @@ pcilscan(int bno, char *path, Pcidev **list)
 
 typedef struct Bridge Bridge;
 struct Bridge {
-	uint16_t vid;
-	uint16_t did;
-	uint8_t (*get)(Pcidev *, uint8_t);
-	void (*set)(Pcidev *, uint8_t, uint8_t);
+	u16 vid;
+	u16 did;
+	u8 (*get)(Pcidev *, u8);
+	void (*set)(Pcidev *, u8, u8);
 };
 
 typedef struct Slot Slot;
 struct Slot {
-	uint8_t bus;		 // Pci bus number
-	uint8_t dev;		 // Pci device number
-	uint8_t maps[12];	 // Avoid structs!  Link and mask.
-	uint8_t slot;		 // Add-in/built-in slot
-	uint8_t reserved;
+	u8 bus;		 // Pci bus number
+	u8 dev;		 // Pci device number
+	u8 maps[12];	 // Avoid structs!  Link and mask.
+	u8 slot;		 // Add-in/built-in slot
+	u8 reserved;
 };
 
 typedef struct Router Router;
 struct Router {
-	uint8_t signature[4];	     // Routing table signature
-	uint8_t version[2];	     // Version number
-	uint8_t size[2];	     // Total table size
-	uint8_t bus;		     // Interrupt router bus number
-	uint8_t devfn;		     // Router's devfunc
-	uint8_t pciirqs[2];	     // Exclusive PCI irqs
-	uint8_t compat[4];	     // Compatible PCI interrupt router
-	uint8_t miniport[4];	     // Miniport data
-	uint8_t reserved[11];
-	uint8_t checksum;
+	u8 signature[4];	     // Routing table signature
+	u8 version[2];	     // Version number
+	u8 size[2];	     // Total table size
+	u8 bus;		     // Interrupt router bus number
+	u8 devfn;		     // Router's devfunc
+	u8 pciirqs[2];	     // Exclusive PCI irqs
+	u8 compat[4];	     // Compatible PCI interrupt router
+	u8 miniport[4];	     // Miniport data
+	u8 reserved[11];
+	u8 checksum;
 };
 
 static void

sys/src/9/386/uarti8250.c

@@ -170,12 +170,12 @@ static Uart i8250uart[2] = {
 #define csr8w(c, r, v) outb((c)->io + (r), (c)->sticky[(r)] | (v))
 #define csr8o(c, r, v) outb((c)->io + (r), (v))
 
-static int32_t
-i8250status(Uart *uart, void *buf, int32_t n, int32_t offset)
+static i32
+i8250status(Uart *uart, void *buf, i32 n, i32 offset)
 {
 	char *p;
 	Ctlr *ctlr;
-	uint8_t ier, lcr, mcr, msr;
+	u8 ier, lcr, mcr, msr;
 
 	ctlr = uart->regs;
 	p = malloc(READSTR);
@@ -410,7 +410,7 @@ i8250bits(Uart *uart, int bits)
 static int
 i8250baud(Uart *uart, int baud)
 {
-	uint32_t bgc;
+	u32 bgc;
 	Ctlr *ctlr;
 
 	/*

sys/src/9/386/vganvidia.c

@@ -69,7 +69,7 @@ enum {
 #define SKIPS 8
 
 struct {
-	uint32_t *dmabase;
+	u32 *dmabase;
 	int dmacurrent;
 	int dmaput;
 	int dmafree;
@@ -98,7 +98,7 @@ static void
 nvidiaenable(VGAscr *scr)
 {
 	Pcidev *p;
-	uint32_t *q;
+	u32 *q;
 	int tmp;
 
 	if(scr->mmio)
@@ -122,7 +122,7 @@ nvidiaenable(VGAscr *scr)
 	switch(scr->id & 0x0ff0){
 	case 0x0020:
 	case 0x00A0:
-		q = (void *)((uint8_t *)scr->mmio + Pfb);
+		q = (void *)((u8 *)scr->mmio + Pfb);
 		tmp = *q;
 		if(tmp & 0x0100){
 			scr->storage = ((tmp >> 12) & 0x0F) * 1024 + 1024 * 2;
@@ -145,7 +145,7 @@ nvidiaenable(VGAscr *scr)
 		scr->storage = (((tmp >> 4) & 127) + 1) * 1024 * 1024;
 		break;
 	default:
-		q = (void *)((uint8_t *)scr->mmio + Pfb + 0x020C);
+		q = (void *)((u8 *)scr->mmio + Pfb + 0x020C);
 		tmp = (*q >> 20) & 0xFFF;
 		if(tmp == 0)
 			tmp = 16;
@@ -166,10 +166,10 @@ nvidiacurdisable(VGAscr *scr)
 static void
 nvidiacurload(VGAscr *scr, Cursor *curs)
 {
-	uint32_t *p;
+	u32 *p;
 	int i, j;
-	uint16_t c, s;
-	uint32_t tmp;
+	u16 c, s;
+	u32 tmp;
 
 	if(scr->mmio == 0)
 		return;
@@ -179,7 +179,7 @@ nvidiacurload(VGAscr *scr, Cursor *curs)
 	switch(scr->id & 0x0ff0){
 	case 0x0020:
 	case 0x00A0:
-		p = (void *)((uint8_t *)scr->mmio + Pramin + 0x1E00 * 4);
+		p = (void *)((u8 *)scr->mmio + Pramin + 0x1E00 * 4);
 		break;
 	default:
 		/*
@@ -188,7 +188,7 @@ nvidiacurload(VGAscr *scr, Cursor *curs)
 		 * expected.
 		 */
 		tmp = scr->apsize - 96 * 1024;
-		p = (void *)((uint8_t *)scr->vaddr + tmp);
+		p = (void *)((u8 *)scr->vaddr + tmp);
 		vgaxo(Crtx, 0x30, 0x80 | (tmp >> 17));
 		vgaxo(Crtx, 0x31, (tmp >> 11) << 2);
 		vgaxo(Crtx, 0x2F, tmp >> 24);
@@ -228,12 +228,12 @@ nvidiacurload(VGAscr *scr, Cursor *curs)
 static int
 nvidiacurmove(VGAscr *scr, Point p)
 {
-	uint32_t *cursorpos;
+	u32 *cursorpos;
 
 	if(scr->mmio == 0)
 		return 1;
 
-	cursorpos = (void *)((uint8_t *)scr->mmio + hwCurPos);
+	cursorpos = (void *)((u8 *)scr->mmio + hwCurPos);
 	*cursorpos = ((p.y + scr->Cursor.offset.y) << 16) | ((p.x + scr->Cursor.offset.x) & 0xFFFF);
 
 	return 0;
@@ -257,23 +257,23 @@ nvidiacurenable(VGAscr *scr)
 void
 writeput(VGAscr *scr, int data)
 {
-	uint8_t *p, scratch;
-	uint32_t *fifo;
+	u8 *p, scratch;
+	u32 *fifo;
 
 	outb(0x3D0, 0);
 	p = scr->vaddr;
 	scratch = *p;
-	fifo = (void *)((uint8_t *)scr->mmio + Fifo);
+	fifo = (void *)((u8 *)scr->mmio + Fifo);
 	fifo[0x10] = (data << 2);
 	USED(scratch);
 }
 
-uint32_t
+u32
 readget(VGAscr *scr)
 {
-	uint32_t *fifo;
+	u32 *fifo;
 
-	fifo = (void *)((uint8_t *)scr->mmio + Fifo);
+	fifo = (void *)((u8 *)scr->mmio + Fifo);
 	return (fifo[0x0011] >> 2);
 }
 
@@ -287,7 +287,7 @@ nvdmakickoff(VGAscr *scr)
 }
 
 static void
-nvdmanext(uint32_t data)
+nvdmanext(u32 data)
 {
 	nv.dmabase[nv.dmacurrent++] = data;
 }
@@ -323,7 +323,7 @@ nvdmawait(VGAscr *scr, int size)
 }
 
 static void
-nvdmastart(VGAscr *scr, uint32_t tag, int size)
+nvdmastart(VGAscr *scr, u32 tag, int size)
 {
 	if(nv.dmafree <= size)
 		nvdmawait(scr, size);
@@ -334,10 +334,10 @@ nvdmastart(VGAscr *scr, uint32_t tag, int size)
 static void
 waitforidle(VGAscr *scr)
 {
-	uint32_t *pgraph;
+	u32 *pgraph;
 	int x;
 
-	pgraph = (void *)((uint8_t *)scr->mmio + Pgraph);
+	pgraph = (void *)((u8 *)scr->mmio + Pgraph);
 
 	x = 0;
 	while((readget(scr) != nv.dmaput) && x++ < 1000000)
@@ -356,7 +356,7 @@ waitforidle(VGAscr *scr)
 static void
 nvresetgraphics(VGAscr *scr)
 {
-	uint32_t surfaceFormat, patternFormat, rectFormat, lineFormat;
+	u32 surfaceFormat, patternFormat, rectFormat, lineFormat;
 	int pitch, i;
 
 	pitch = scr->gscreen->width * BY2WD;
@@ -367,7 +367,7 @@ nvresetgraphics(VGAscr *scr)
 	 */
 	if(nv.dmabase == nil){
 		if(scr->storage <= scr->apsize)
-			nv.dmabase = (uint32_t *)((uint8_t *)scr->vaddr + scr->storage - 128 * 1024);
+			nv.dmabase = (u32 *)((u8 *)scr->vaddr + scr->storage - 128 * 1024);
 		else {
 			nv.dmabase = (void *)vmap(scr->paddr + scr->storage - 128 * 1024, 128 * 1024);
 			if(nv.dmabase == 0){
@@ -456,7 +456,7 @@ nvresetgraphics(VGAscr *scr)
 }
 
 static int
-nvidiahwfill(VGAscr *scr, Rectangle r, uint32_t sval)
+nvidiahwfill(VGAscr *scr, Rectangle r, u32 sval)
 {
 	nvdmastart(scr, RECT_SOLID_COLOR, 1);
 	nvdmanext(sval);
@@ -492,7 +492,7 @@ nvidiahwscroll(VGAscr *scr, Rectangle r, Rectangle sr)
 void
 nvidiablank(VGAscr *scr, int blank)
 {
-	uint8_t seq1, crtc1A;
+	u8 seq1, crtc1A;
 
 	seq1 = vgaxi(Seqx, 1) & ~0x20;
 	crtc1A = vgaxi(Crtx, 0x1A) & ~0xC0;

sys/src/9/386/vgavesa.c

@@ -34,7 +34,7 @@ enum {
 };
 
 static void *hardscreen;
-static uint8_t modebuf[0x1000];
+static u8 modebuf[0x1000];
 
 #define WORD(p) ((p)[0] | ((p)[1] << 8))
 #define LONG(p) ((p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24))
@@ -47,11 +47,11 @@ static uint8_t modebuf[0x1000];
 	(p)[2] = (v) >> 16; \
 	(p)[3] = (v) >> 24
 
-static uint8_t *
+static u8 *
 vbesetup(Ureg *u, int ax)
 {
 	// Yes, it's a PA, but it's a real mode PA, and 32 bits are fine.
-	uint32_t pa;
+	u32 pa;
 
 	pa = PADDR(RMBUF);
 	memset(modebuf, 0, sizeof modebuf);
@@ -67,7 +67,7 @@ vbecall(Ureg *u)
 {
 	Proc *up = externup();
 	Chan *creg, *cmem;
-	uint32_t pa;
+	u32 pa;
 
 	cmem = namec("/dev/realmodemem", Aopen, ORDWR, 0);
 	if(waserror()){
@@ -101,7 +101,7 @@ static void
 vbecheck(void)
 {
 	Ureg u;
-	uint8_t *p;
+	u8 *p;
 
 	p = vbesetup(&u, 0x4F00);
 	strcpy((char *)p, "VBE2");
@@ -122,10 +122,10 @@ vbegetmode(void)
 	return u.bx;
 }
 
-static uint8_t *
+static u8 *
 vbemodeinfo(int mode)
 {
-	uint8_t *p;
+	u8 *p;
 	Ureg u;
 
 	p = vbesetup(&u, 0x4F01);
@@ -138,8 +138,8 @@ static void
 vesalinear(VGAscr *scr, int _1, int _2)
 {
 	int i, mode, size, havesize;
-	uint8_t *p;
-	uint32_t paddr;
+	u8 *p;
+	u32 paddr;
 	Pcidev *pci;
 
 	if(hardscreen){
@@ -209,13 +209,13 @@ static void
 vesaflush(VGAscr *scr, Rectangle r)
 {
 	int t, w, wid, off;
-	uint32_t *hp, *sp, *esp;
+	u32 *hp, *sp, *esp;
 
 	if(hardscreen == nil)
 		return;
 	if(rectclip(&r, scr->gscreen->r) == 0)
 		return;
-	sp = (uint32_t *)(scr->gscreendata->bdata + scr->gscreen->zero);
+	sp = (u32 *)(scr->gscreendata->bdata + scr->gscreen->zero);
 	t = (r.max.x * scr->gscreen->depth + 2 * BI2WD - 1) / BI2WD;
 	w = (r.min.x * scr->gscreen->depth) / BI2WD;
 	w = (t - w) * BY2WD;

sys/src/9/aarch64/main.c

@@ -11,6 +11,6 @@
 #include <u.h>
 
 void
-main(uint64_t mbmagic, uintptr_t mbaddress)
+main(u64 mbmagic, uintptr mbaddress)
 {
 }

sys/src/9/amd64/acpi.h

@@ -200,17 +200,17 @@ struct Atable {
 	Atable *parent;	   /* Parent pointer */
 	Atable **children; /* children of this node (an array). */
 	Dirtab *cdirs;	   /* child directory entries of this node. */
-	size_t nchildren;  /* count of this node's children */
+	usize nchildren;  /* count of this node's children */
 	Atable *next;	   /* Pointer to the next sibling. */
 
-	size_t rawsize; /* Total size of raw table */
-	uint8_t *raw;	/* Raw data. */
+	usize rawsize; /* Total size of raw table */
+	u8 *raw;	/* Raw data. */
 };
 
 struct Gpe {
-	uintptr_t stsio; /* port used for status */
+	uintptr stsio; /* port used for status */
 	int stsbit;	 /* bit number */
-	uintptr_t enio;	 /* port used for enable */
+	uintptr enio;	 /* port used for enable */
 	int enbit;	 /* bit number */
 	int nb;		 /* event number */
 	char *obj;	 /* handler object  */
@@ -224,22 +224,22 @@ struct Parse {
 
 struct Regio {
 	void *arg;
-	uint8_t (*get8)(uintptr_t, void *);
-	void (*set8)(uintptr_t, uint8_t, void *);
-	uint16_t (*get16)(uintptr_t, void *);
-	void (*set16)(uintptr_t, uint16_t, void *);
-	uint32_t (*get32)(uintptr_t, void *);
-	void (*set32)(uintptr_t, uint32_t, void *);
-	uint64_t (*get64)(uintptr_t, void *);
-	void (*set64)(uintptr_t, uint64_t, void *);
+	u8 (*get8)(uintptr, void *);
+	void (*set8)(uintptr, u8, void *);
+	u16 (*get16)(uintptr, void *);
+	void (*set16)(uintptr, u16, void *);
+	u32 (*get32)(uintptr, void *);
+	void (*set32)(uintptr, u32, void *);
+	u64 (*get64)(uintptr, void *);
+	void (*set64)(uintptr, u64, void *);
 };
 
 struct Reg {
 	char *name;
 	int spc;	  /* io space */
-	uint64_t base;	  /* address, physical */
+	u64 base;	  /* address, physical */
 	unsigned char *p; /* address, kmapped */
-	uint64_t len;
+	u64 len;
 	int tbdf;
 	int accsz; /* access size */
 };
@@ -247,11 +247,11 @@ struct Reg {
 /* Generic address structure.
  */
 struct Gas {
-	uint8_t spc;   /* address space id */
-	uint8_t len;   /* register size in bits */
-	uint8_t off;   /* bit offset */
-	uint8_t accsz; /* 1: byte; 2: word; 3: dword; 4: qword */
-	uint64_t addr; /* address (or acpi encoded tbdf + reg) */
+	u8 spc;   /* address space id */
+	u8 len;   /* register size in bits */
+	u8 off;   /* bit offset */
+	u8 accsz; /* 1: byte; 2: word; 3: dword; 4: qword */
+	u64 addr; /* address (or acpi encoded tbdf + reg) */
 } __attribute__((packed));
 
 /* Root system description table pointer.
@@ -267,53 +267,53 @@ struct Gas {
 #define RSDPTR "RSD PTR "
 
 struct Rsdp {
-	uint8_t signature[8]; /* "RSD PTR " */
-	uint8_t rchecksum;
-	uint8_t oemid[6];
-	uint8_t revision;
-	uint8_t raddr[4]; /* RSDT */
-	uint8_t length[4];
-	uint8_t xaddr[8];  /* XSDT */
-	uint8_t xchecksum; /* XSDT */
-	uint8_t _33_[3];   /* reserved */
+	u8 signature[8]; /* "RSD PTR " */
+	u8 rchecksum;
+	u8 oemid[6];
+	u8 revision;
+	u8 raddr[4]; /* RSDT */
+	u8 length[4];
+	u8 xaddr[8];  /* XSDT */
+	u8 xchecksum; /* XSDT */
+	u8 _33_[3];   /* reserved */
 } __attribute__((packed));
 
 /* Header for ACPI description tables
  */
 struct Sdthdr {
-	uint8_t sig[4]; /* "FACP" or whatever */
-	uint8_t length[4];
-	uint8_t rev;
-	uint8_t csum;
-	uint8_t oemid[6];
-	uint8_t oemtblid[8];
-	uint8_t oemrev[4];
-	uint8_t creatorid[4];
-	uint8_t creatorrev[4];
+	u8 sig[4]; /* "FACP" or whatever */
+	u8 length[4];
+	u8 rev;
+	u8 csum;
+	u8 oemid[6];
+	u8 oemtblid[8];
+	u8 oemrev[4];
+	u8 creatorid[4];
+	u8 creatorrev[4];
 } __attribute__((packed));
 
 /* Firmware ACPI control structure
  */
 struct Facs {
-	uint8_t sig[4];
-	uint32_t len;
-	uint32_t hwsig;
-	uint32_t wakingv;
-	uint32_t glock;
-	uint32_t flags;
-	uint64_t xwakingv;
-	uint8_t vers;
-	uint8_t reserved1[3];
-	uint32_t ospmflags;
-	uint8_t reserved2[24];
+	u8 sig[4];
+	u32 len;
+	u32 hwsig;
+	u32 wakingv;
+	u32 glock;
+	u32 flags;
+	u64 xwakingv;
+	u8 vers;
+	u8 reserved1[3];
+	u32 ospmflags;
+	u8 reserved2[24];
 } __attribute__((packed));
 
 /* Maximum System Characteristics table
  */
 struct Msct {
-	size_t ndoms;	/* number of discovered domains */
+	usize ndoms;	/* number of discovered domains */
 	int nclkdoms;	/* number of clock domains */
-	uint64_t maxpa; /* max physical address */
+	u64 maxpa; /* max physical address */
 	Mdom *dom;	/* domain information list */
 };
 
@@ -322,7 +322,7 @@ struct Mdom {
 	int start;	 /* start dom id */
 	int end;	 /* end dom id */
 	int maxproc;	 /* max processor capacity */
-	uint64_t maxmem; /* max memory capacity */
+	u64 maxmem; /* max memory capacity */
 };
 
 /* Multiple APIC description table
@@ -332,7 +332,7 @@ struct Mdom {
  * Only enabled devices are linked, others are filtered out.
  */
 struct Madt {
-	uint64_t lapicpa; /* local APIC addr */
+	u64 lapicpa; /* local APIC addr */
 	int pcat;	  /* the machine has PC/AT 8259s */
 	Apicst *st;	  /* list of Apic related structures */
 };
@@ -347,8 +347,8 @@ struct Apicst {
 		} lapic;
 		struct {
 			int id;		/* io apic id */
-			uint32_t ibase; /* interrupt base addr. */
-			uint64_t addr;	/* base address */
+			u32 ibase; /* interrupt base addr. */
+			u64 addr;	/* base address */
 		} ioapic, iosapic;
 		struct {
 			int irq;   /* bus intr. source (ISA only) */
@@ -406,8 +406,8 @@ struct Srat {
 		} lapic;
 		struct {
 			int dom;       /* proximity domain */
-			uint64_t addr; /* base address */
-			uint64_t len;
+			u64 addr; /* base address */
+			u64 len;
 			int hplug; /* hot pluggable */
 			int nvram; /* non volatile */
 		} mem;
@@ -422,7 +422,7 @@ struct Srat {
 /* System locality information table
  */
 struct Slit {
-	uint64_t rowlen;
+	u64 rowlen;
 	SlEntry **e;
 };
 
@@ -439,49 +439,49 @@ struct SlEntry {
  * Has address for the DSDT.
  */
 struct Fadt {
-	uint32_t facs;
-	uint32_t dsdt;
+	u32 facs;
+	u32 dsdt;
 	/* 1 reserved */
-	uint8_t pmprofile;
-	uint16_t sciint;
-	uint32_t smicmd;
-	uint8_t acpienable;
-	uint8_t acpidisable;
-	uint8_t s4biosreq;
-	uint8_t pstatecnt;
-	uint32_t pm1aevtblk;
-	uint32_t pm1bevtblk;
-	uint32_t pm1acntblk;
-	uint32_t pm1bcntblk;
-	uint32_t pm2cntblk;
-	uint32_t pmtmrblk;
-	uint32_t gpe0blk;
-	uint32_t gpe1blk;
-	uint8_t pm1evtlen;
-	uint8_t pm1cntlen;
-	uint8_t pm2cntlen;
-	uint8_t pmtmrlen;
-	uint8_t gpe0blklen;
-	uint8_t gpe1blklen;
-	uint8_t gp1base;
-	uint8_t cstcnt;
-	uint16_t plvl2lat;
-	uint16_t plvl3lat;
-	uint16_t flushsz;
-	uint16_t flushstride;
-	uint8_t dutyoff;
-	uint8_t dutywidth;
-	uint8_t dayalrm;
-	uint8_t monalrm;
-	uint8_t century;
-	uint16_t iapcbootarch;
+	u8 pmprofile;
+	u16 sciint;
+	u32 smicmd;
+	u8 acpienable;
+	u8 acpidisable;
+	u8 s4biosreq;
+	u8 pstatecnt;
+	u32 pm1aevtblk;
+	u32 pm1bevtblk;
+	u32 pm1acntblk;
+	u32 pm1bcntblk;
+	u32 pm2cntblk;
+	u32 pmtmrblk;
+	u32 gpe0blk;
+	u32 gpe1blk;
+	u8 pm1evtlen;
+	u8 pm1cntlen;
+	u8 pm2cntlen;
+	u8 pmtmrlen;
+	u8 gpe0blklen;
+	u8 gpe1blklen;
+	u8 gp1base;
+	u8 cstcnt;
+	u16 plvl2lat;
+	u16 plvl3lat;
+	u16 flushsz;
+	u16 flushstride;
+	u8 dutyoff;
+	u8 dutywidth;
+	u8 dayalrm;
+	u8 monalrm;
+	u8 century;
+	u16 iapcbootarch;
 	/* 1 reserved */
-	uint32_t flags;
+	u32 flags;
 	Gas resetreg;
-	uint8_t resetval;
+	u8 resetval;
 	/* 3 reserved */
-	uint64_t xfacs;
-	uint64_t xdsdt;
+	u64 xfacs;
+	u64 xdsdt;
 	Gas xpm1aevtblk;
 	Gas xpm1bevtblk;
 	Gas xpm1acntblk;
@@ -495,9 +495,9 @@ struct Fadt {
 /* XSDT/RSDT. 4/8 byte addresses starting at p.
  */
 struct Xsdt {
-	size_t len;
-	size_t asize;
-	uint8_t *p;
+	usize len;
+	usize asize;
+	u8 *p;
 };
 
 /* DMAR.
@@ -518,9 +518,9 @@ struct DevScope {
 struct Drhd {
 	int flags;
 	int segment;
-	uintptr_t rba;
-	uintptr_t all;	      // This drhd scope is for everything.
-	size_t nscope;
+	uintptr rba;
+	uintptr all;	      // This drhd scope is for everything.
+	usize nscope;
 	struct DevScope *scopes;
 };
 
@@ -535,8 +535,8 @@ struct Dmar {
 
 int acpiinit(void);
 Atable *mkatable(Atable *parent,
-		 int type, char *name, uint8_t *raw,
-		 size_t rawsize, size_t addsize);
+		 int type, char *name, u8 *raw,
+		 usize rawsize, usize addsize);
 Atable *finatable(Atable *t, PSlice *slice);
 Atable *finatable_nochildren(Atable *t);
 
@@ -544,4 +544,4 @@ extern Atable *apics;
 extern Atable *dmar;
 extern Atable *srat;
 
-extern uintmem acpimblocksize(uintmem, int *);
+extern u64 acpimblocksize(u64, int *);

sys/src/9/amd64/ahci.h

@@ -93,17 +93,17 @@ enum {
 };
 
 typedef struct {
-	uint32_t cap;
-	uint32_t ghc;
-	uint32_t isr;
-	uint32_t pi; /* ports implemented */
-	uint32_t ver;
-	uint32_t ccc; /* coaleasing control */
-	uint32_t cccports;
-	uint32_t emloc;
-	uint32_t emctl;
-	uint32_t cap2; /* host capabilities extended */
-	uint32_t bohc; /* bios/os handoff control and status */
+	u32 cap;
+	u32 ghc;
+	u32 isr;
+	u32 pi; /* ports implemented */
+	u32 ver;
+	u32 ccc; /* coaleasing control */
+	u32 cccports;
+	u32 emloc;
+	u32 emctl;
+	u32 cap2; /* host capabilities extended */
+	u32 bohc; /* bios/os handoff control and status */
 } Ahba;
 
 enum {
@@ -196,24 +196,24 @@ enum {
 #define sactive scr3
 
 typedef struct {
-	uint32_t list; /* PxCLB must be 1kb aligned. */
-	uint32_t listhi;
-	uint32_t fis; /* 256-byte aligned */
-	uint32_t fishi;
-	uint32_t isr;
-	uint32_t ie; /* interrupt enable */
-	uint32_t cmd;
-	uint32_t res1;
-	uint32_t task;
-	uint32_t sig;
-	uint32_t scr0;
-	uint32_t scr2;
-	uint32_t scr1;
-	uint32_t scr3;
-	uint32_t ci;		/* command issue */
-	uint32_t ntf;		/* scr4 */
-	uint32_t fbs;		/* FIS-based switching control */
-	uint32_t devslp;	/* device sleep */
+	u32 list; /* PxCLB must be 1kb aligned. */
+	u32 listhi;
+	u32 fis; /* 256-byte aligned */
+	u32 fishi;
+	u32 isr;
+	u32 ie; /* interrupt enable */
+	u32 cmd;
+	u32 res1;
+	u32 task;
+	u32 sig;
+	u32 scr0;
+	u32 scr2;
+	u32 scr1;
+	u32 scr3;
+	u32 ci;		/* command issue */
+	u32 ntf;		/* scr4 */
+	u32 fbs;		/* FIS-based switching control */
+	u32 devslp;	/* device sleep */
 	unsigned char res2[40]; /* reserved */
 	unsigned char vendor[16];
 } Aport;
@@ -243,7 +243,7 @@ typedef struct {
 	unsigned char *p;
 	unsigned char *r;
 	unsigned char *u;
-	uint32_t *devicebits;
+	u32 *devicebits;
 } Afis;
 
 enum {
@@ -260,18 +260,18 @@ enum {
 
 /* in hosts memory; memory mapped */
 typedef struct {
-	uint32_t flags;
-	uint32_t len;
-	uint32_t ctab;
-	uint32_t ctabhi;
+	u32 flags;
+	u32 len;
+	u32 ctab;
+	u32 ctabhi;
 	unsigned char reserved[16];
 } Alist;
 
 typedef struct {
-	uint32_t dba;
-	uint32_t dbahi;
-	uint32_t pad;
-	uint32_t count;
+	u32 dba;
+	u32 dbahi;
+	u32 pad;
+	u32 count;
 } Aprdt;
 
 typedef struct {

sys/src/9/amd64/apic.c

@@ -79,22 +79,22 @@ enum {			     /* Tdc */
        DivX1 = 0x0000000b,   /* Divide by 1 */
 };
 
-uint8_t *apicbase;
+u8 *apicbase;
 static int apmachno = 1;
 
 Apic xlapic[Napic];
 Mach *xlapicmachptr[Napic]; /* maintained, but unused */
 
-static uint32_t
+static u32
 apicrget(int r)
 {
-	return *((volatile uint32_t *)(apicbase + r));
+	return *((volatile u32 *)(apicbase + r));
 }
 
 static void
-apicrput(int r, uint32_t data)
+apicrput(int r, u32 data)
 {
-	*((volatile uint32_t *)(apicbase + r)) = data;
+	*((volatile u32 *)(apicbase + r)) = data;
 }
 
 int
@@ -116,7 +116,7 @@ apicisr(int vecno)
 }
 
 void
-apicinit(int apicno, uintmem pa, int isbp)
+apicinit(int apicno, u64 pa, int isbp)
 {
 	Apic *apic;
 
@@ -224,8 +224,8 @@ int
 apiconline(void)
 {
 	Apic *apic;
-	uint64_t tsc;
-	uint32_t dfr, ver;
+	u64 tsc;
+	u32 dfr, ver;
 	int apicno, nlvt;
 
 	if(apicbase == nil)
@@ -373,11 +373,11 @@ apictimerenab(void)
 }
 
 void
-apictimerset(uint64_t next)
+apictimerset(u64 next)
 {
 	Mpl pl;
 	Apic *apic;
-	int64_t period;
+	i64 period;
 
 	apic = &xlapic[(apicrget(Id) >> 24) & 0xff];
 
@@ -401,9 +401,9 @@ apictimerset(uint64_t next)
 }
 
 void
-apicsipi(int apicno, uintmem pa)
+apicsipi(int apicno, u64 pa)
 {
-	uint32_t crhi;
+	u32 crhi;
 
 	/*
 	 * SIPI - Start-up IPI.
@@ -418,7 +418,8 @@ apicsipi(int apicno, uintmem pa)
 
 	for(int i = 0; i < 2; i++){
 		apicrput(Ichi, crhi);
-		apicrput(Iclo, DSnone | TMedge | MTsipi | ((uint32_t)pa / (4 * KiB)));
+		apicrput(Iclo,
+			 DSnone | TMedge | MTsipi | ((u32)pa / (4 * KiB)));
 		microdelay(200);
 	}
 }

sys/src/9/amd64/apic.h

@@ -20,8 +20,8 @@ typedef struct Apic Apic;
 
 struct Ioapic {
 	Lock l;		 /* IOAPIC: register access */
-	uint32_t *addr;	 /* IOAPIC: register base */
-	uintptr_t paddr; /* physical address */
+	u32 *addr;	 /* IOAPIC: register base */
+	uintptr paddr; /* physical address */
 	int nrdt;	 /* IOAPIC: size of RDT */
 	int gsib;	 /* IOAPIC: global RDT index */
 };
@@ -29,14 +29,14 @@ struct Ioapic {
 struct Lapic {
 	int machno; /* APIC */
 
-	uint32_t lvt[6];
+	u32 lvt[6];
 	int nlvt;
 	int ver;
 
-	int64_t hz; /* APIC Timer frequency */
-	int64_t max;
-	int64_t min;
-	int64_t div;
+	i64 hz; /* APIC Timer frequency */
+	i64 max;
+	i64 min;
+	i64 div;
 };
 
 struct Apic {
@@ -91,12 +91,12 @@ extern Apic xioapic[Napic];
 extern Mach *xlapicmachptr[Napic]; /* maintained, but unused */
 
 #define l16get(p) (((p)[1] << 8) | (p)[0])
-#define l32get(p) (((uint32_t)l16get(p + 2) << 16) | l16get(p))
-#define l64get(p) (((uint64_t)l32get(p + 4) << 32) | l32get(p))
+#define l32get(p) (((u32)l16get(p + 2) << 16) | l16get(p))
+#define l64get(p) (((u64)l32get(p + 4) << 32) | l32get(p))
 
 extern void apicdump(void);
 extern void apictimerenab(void);
 extern void ioapicdump(void);
 
-extern int pcimsienable(Pcidev *, uint64_t);
+extern int pcimsienable(Pcidev *, u64);
 extern int pcimsimask(Pcidev *, int);

sys/src/9/amd64/arch.c

@@ -58,7 +58,7 @@ decref(Ref *r)
 void
 procrestore(Proc *p)
 {
-	uint64_t t;
+	u64 t;
 
 	if(p->kp)
 		return;
@@ -77,7 +77,7 @@ procrestore(Proc *p)
 void
 procsave(Proc *p)
 {
-	uint64_t t;
+	u64 t;
 
 	cycles(&t);
 	p->pcycles += t;
@@ -125,7 +125,7 @@ idlehands(void)
 }
 
 void
-ureg2gdb(Ureg *u, uintptr_t *g)
+ureg2gdb(Ureg *u, uintptr *g)
 {
 	g[GDB_AX] = u->ax;
 	g[GDB_BX] = u->bx;
@@ -158,7 +158,7 @@ ureg2gdb(Ureg *u, uintptr_t *g)
 }
 
 void
-gdb2ureg(uintptr_t *g, Ureg *u)
+gdb2ureg(uintptr *g, Ureg *u)
 {
 	u->ax = g[GDB_AX];
 	u->bx = g[GDB_BX];

sys/src/9/amd64/archamd64.c

@@ -24,7 +24,7 @@ typedef enum CpuHypervisor {
 static int
 cpuidinit(void)
 {
-	uint32_t eax, info[4];
+	u32 eax, info[4];
 
 	/*
 	 * Standard CPUID functions.
@@ -53,7 +53,7 @@ cpuidinit(void)
 }
 
 int
-cpuidinfo(uint32_t eax, uint32_t ecx, uint32_t info[4])
+cpuidinfo(u32 eax, u32 ecx, u32 info[4])
 {
 	if(machp()->CPU.ncpuinfos == 0 && cpuidinit() == 0)
 		return 0;
@@ -70,7 +70,7 @@ cpuidinfo(uint32_t eax, uint32_t ecx, uint32_t info[4])
 }
 
 char *
-cpuidname(uint32_t *info0)
+cpuidname(u32 *info0)
 {
 	char *vendorid;
 
@@ -92,7 +92,7 @@ cpuidname(uint32_t *info0)
 CpuHypervisor
 cpuhypervisor()
 {
-	uint32_t info[4];
+	u32 info[4];
 	if(cpuid(0x40000000, 0, info)){
 		char *hypname = (char *)&info[1];
 		if(!memcmp("KVMKVMKVM\0\0\0", hypname, 12)){
@@ -102,10 +102,10 @@ cpuhypervisor()
 	return CpuHypervisorUnknown;
 }
 
-static int64_t
+static i64
 cpuidhz_hypervisor()
 {
-	uint32_t info[4];
+	u32 info[4];
 	if(cpuid(0x40000010, 0, info)){
 		return info[0] * 1000;
 	}
@@ -113,12 +113,12 @@ cpuidhz_hypervisor()
 	return 0;
 }
 
-static int64_t
-cpuidhz(uint32_t *info0, uint32_t *info1, CpuHypervisor hypervisor)
+static i64
+cpuidhz(u32 *info0, u32 *info1, CpuHypervisor hypervisor)
 {
 	int f = -1, r;
-	int64_t hz;
-	uint64_t msr;
+	i64 hz;
+	u64 msr;
 	char *vendorid;
 
 	vendorid = cpuidname(info0);
@@ -127,12 +127,12 @@ cpuidhz(uint32_t *info0, uint32_t *info1, CpuHypervisor hypervisor)
 	DBG("vendorid: %s\n", vendorid);
 	DBG("CPUID Signature: %d\n", info1[0]);
 
-	uint8_t family_ext = (info1[0] & 0xff00000) >> 20;
-	uint8_t model_ext = (info1[0] & 0xf0000) >> 16;
-	uint8_t proctype = (info1[0] & 0x3000) >> 12;
-	uint8_t family = (info1[0] & 0xf00) >> 8;
-	uint8_t model = (info1[0] & 0xf0) >> 4;
-	uint8_t stepping = (info1[0] & 0xf);
+	u8 family_ext = (info1[0] & 0xff00000) >> 20;
+	u8 model_ext = (info1[0] & 0xf0000) >> 16;
+	u8 proctype = (info1[0] & 0x3000) >> 12;
+	u8 family = (info1[0] & 0xf00) >> 8;
+	u8 model = (info1[0] & 0xf0) >> 4;
+	u8 stepping = (info1[0] & 0xf);
 	print("CPUID family %x model %x proctype %x stepping %x model_ext %x family_ext %x hypervisor: %d\n",
 	      family, model, proctype, stepping, model_ext, family_ext, hypervisor);
 
@@ -144,7 +144,7 @@ cpuidhz(uint32_t *info0, uint32_t *info1, CpuHypervisor hypervisor)
 	}
 
 	if(strcmp("GenuineIntel", vendorid) == 0){
-		uint32_t cpusig = info1[0] & 0x0fff3ff0;
+		u32 cpusig = info1[0] & 0x0fff3ff0;
 		print("CPU Signature: %x\n", cpusig);
 
 		switch(cpusig){
@@ -276,7 +276,7 @@ cpuidhz(uint32_t *info0, uint32_t *info1, CpuHypervisor hypervisor)
 		}
 		DBG("cpuidhz: 0x2a: %#llx hz %lld\n", rdmsr(0x2a), hz);
 	} else if(strcmp("AuthenticAMD", vendorid) == 0){
-		uint32_t cpusig = info1[0] & 0x0fff0ff0;
+		u32 cpusig = info1[0] & 0x0fff0ff0;
 		print("CPU Signature: %x\n", cpusig);
 
 		switch(cpusig){
@@ -323,7 +323,7 @@ void
 cpuiddump(void)
 {
 	int i;
-	uint32_t info[4];
+	u32 info[4];
 
 	if(!DBGFLG)
 		return;
@@ -343,11 +343,11 @@ cpuiddump(void)
 	}
 }
 
-int64_t
+i64
 archhz(void)
 {
-	int64_t hz;
-	uint32_t info0[4], info1[4];
+	i64 hz;
+	u32 info0[4], info1[4];
 
 	if(!cpuidinfo(0, 0, info0)){
 		iprint("archhz: cpuidinfo(0, 0) failed\n");
@@ -374,7 +374,7 @@ archhz(void)
 int
 archmmu(void)
 {
-	uint32_t info[4];
+	u32 info[4];
 
 	/*
 	 * Should the check for machp()->machno != 0 be here
@@ -426,9 +426,9 @@ archmmu(void)
 static int
 fmtP(Fmt *f)
 {
-	uintmem pa;
+	u64 pa;
 
-	pa = va_arg(f->args, uintmem);
+	pa = va_arg(f->args, u64);
 
 	if(f->flags & FmtSharp)
 		return fmtprint(f, "%#16.16llx", pa);
@@ -449,9 +449,9 @@ fmtL(Fmt *f)
 static int
 fmtR(Fmt *f)
 {
-	uint64_t r;
+	u64 r;
 
-	r = va_arg(f->args, uint64_t);
+	r = va_arg(f->args, u64);
 
 	return fmtprint(f, "%#16.16llx", r);
 }
@@ -460,9 +460,9 @@ fmtR(Fmt *f)
 static int
 fmtW(Fmt *f)
 {
-	uint64_t va;
+	u64 va;
 
-	va = va_arg(f->args, uint64_t);
+	va = va_arg(f->args, u64);
 	return fmtprint(f, "%#llx=0x[%llx][%llx][%llx][%llx][%llx]", va,
 			PTLX(va, 3), PTLX(va, 2), PTLX(va, 1), PTLX(va, 0),
 			va & ((1 << PGSHFT) - 1));
@@ -497,7 +497,7 @@ archidle(void)
 void
 microdelay(int microsecs)
 {
-	uint64_t r, t;
+	u64 r, t;
 
 	r = rdtsc();
 	for(t = r + (sys->cyclefreq * microsecs) / 1000000ull; r < t; r = rdtsc())
@@ -507,7 +507,7 @@ microdelay(int microsecs)
 void
 millidelay(int millisecs)
 {
-	uint64_t r, t;
+	u64 r, t;
 
 	r = rdtsc();
 	for(t = r + (sys->cyclefreq * millisecs) / 1000ull; r < t; r = rdtsc())

sys/src/9/amd64/backtrace.c

@@ -9,9 +9,9 @@
 #include "amd64.h"
 
 int
-backtrace_list(uintptr_t pc, uintptr_t fp, uintptr_t *pcs, size_t nr_slots)
+backtrace_list(uintptr pc, uintptr fp, uintptr *pcs, usize nr_slots)
 {
-	size_t nr_pcs = 0;
+	usize nr_pcs = 0;
 	while(fp && nr_pcs < nr_slots){
 		/* could put some sanity checks in here... */
 		pcs[nr_pcs++] = pc;
@@ -22,8 +22,8 @@ backtrace_list(uintptr_t pc, uintptr_t fp, uintptr_t *pcs, size_t nr_slots)
 		 * function that called us.  this was necessary in case we called as the
 		 * last instruction in a function (would have to never return).  not
 		 * sure how necessary this still is. */
-		pc = *(uintptr_t *)(fp + sizeof(uintptr_t)) - 1;
-		fp = *(uintptr_t *)fp;
+		pc = *(uintptr *)(fp + sizeof(uintptr)) - 1;
+		fp = *(uintptr *)fp;
 	}
 	return nr_pcs;
 }

sys/src/9/amd64/backtrace.h

@@ -20,16 +20,16 @@ typedef struct eipdebuginfo {
 	const char *eip_fn_name;	// Name of function containing EIP
 					//  - Note: not null terminated!
 	int eip_fn_namelen;		// Length of function name
-	uintptr_t eip_fn_addr;		// Address of start of function
+	uintptr eip_fn_addr;		// Address of start of function
 	int eip_fn_narg;		// Number of function arguments
 } eipdebuginfo_t;
 
-int debuginfo_eip(uintptr_t eip, eipdebuginfo_t *info);
+int debuginfo_eip(uintptr eip, eipdebuginfo_t *info);
 void *debug_get_fn_addr(char *fn_name);
 
 /* Returns a PC/EIP in the function that called us, preferably near the call
  * site.  Returns 0 when we can't jump back any farther. */
-static inline uintptr_t
+static inline uintptr
 get_caller_pc(void)
 {
 	unsigned long *ebp = (unsigned long *)read_bp();

sys/src/9/amd64/cbscreen.c

@@ -110,7 +110,7 @@ int didswcursorinit;
 static void *softscreen;
 
 int
-screensize(int x, int y, int z, uint32_t chan)
+screensize(int x, int y, int z, u32 chan)
 {
 	Proc *up = externup();
 	VGAscr *scr;
@@ -197,7 +197,7 @@ screenaperture(int size, int align)
 	 * The driver will tell the card to use it.
 	 */
 	size = ROUNDUP(sizeof(size), 4 * KiB);
-	scr->paddr = (uint64_t)malloc(size);
+	scr->paddr = (u64)malloc(size);
 	if(scr->paddr == 0)
 		return -1;
 	scr->vaddr = vmap(scr->paddr, size);
@@ -209,7 +209,7 @@ screenaperture(int size, int align)
 }
 
 unsigned char *
-attachscreen(Rectangle *r, uint32_t *chan, int *d, int *width, int *softscreen)
+attachscreen(Rectangle *r, u32 *chan, int *d, int *width, int *softscreen)
 {
 	VGAscr *scr;
 
@@ -300,10 +300,10 @@ flushmemscreen(Rectangle r)
 }
 
 void
-getcolor(uint32_t p, uint32_t *pr, uint32_t *pg, uint32_t *pb)
+getcolor(u32 p, u32 *pr, u32 *pg, u32 *pb)
 {
 	VGAscr *scr;
-	uint32_t x;
+	u32 x;
 
 	scr = &vgascreen[0];
 	if(scr->gscreen == nil)
@@ -327,7 +327,7 @@ getcolor(uint32_t p, uint32_t *pr, uint32_t *pg, uint32_t *pb)
 }
 
 int
-setpalette(uint32_t p, uint32_t r, uint32_t g, uint32_t b)
+setpalette(u32 p, u32 r, u32 g, u32 b)
 {
 	VGAscr *scr;
 
@@ -349,7 +349,7 @@ setpalette(uint32_t p, uint32_t r, uint32_t g, uint32_t b)
  * is trying to set a colormap and the card is in one of these modes.
  */
 int
-setcolor(uint32_t p, uint32_t r, uint32_t g, uint32_t b)
+setcolor(u32 p, u32 r, u32 g, u32 b)
 {
 	VGAscr *scr;
 	int x;
@@ -489,10 +489,10 @@ blankscreen(int blank)
 }
 
 void
-vgalinearaddr(VGAscr *scr, uint32_t paddr, int size)
+vgalinearaddr(VGAscr *scr, u32 paddr, int size)
 {
 	int x, nsize;
-	uint32_t npaddr;
+	u32 npaddr;
 
 	/*
 	 * new approach.  instead of trying to resize this

sys/src/9/amd64/cbvga.c

@@ -32,7 +32,7 @@ Lock vgascreenlock;
 int drawdebug;
 
 void
-vgaimageinit(uint32_t chan)
+vgaimageinit(u32 chan)
 {
 	if(back == nil){
 		back = allocmemimage(Rect(0, 0, 1, 1), chan); /* RSC BUG */
@@ -221,7 +221,7 @@ vgablank(VGAscr *scr, int blank)
 }
 
 void
-addvgaseg(char *name, uint32_t pa, uint32_t size)
+addvgaseg(char *name, u32 pa, u32 size)
 {
 	Physseg seg;
 

sys/src/9/amd64/cga.c

@@ -72,7 +72,7 @@ cgablinkoff(void)
 static void
 cgacursor(void)
 {
-	uint8_t *cga;
+	u8 *cga;
 
 	cgaregw(0x0e, (cgapos / 2 >> 8) & 0xff);
 	cgaregw(0x0f, cgapos / 2 & 0xff);
@@ -89,7 +89,7 @@ void
 cgaputc(int c)
 {
 	int i;
-	uint8_t *cga, *p;
+	u8 *cga, *p;
 
 	cga = CGA;
 
@@ -126,7 +126,7 @@ cgaprint(int off, char *fmt, ...)
 {
 	va_list va;
 	char buf[128];
-	uint8_t *cga;
+	u8 *cga;
 	int i, n;
 
 	va_start(va, fmt);
@@ -144,7 +144,7 @@ cgaprint(int off, char *fmt, ...)
 int
 cgaclearln(int off, int c)
 {
-	uint8_t *cga;
+	u8 *cga;
 	int i;
 
 	cga = CGA;
@@ -159,7 +159,7 @@ cgaclearln(int off, int c)
  * debug
  */
 void
-cgaprinthex(uintptr_t x)
+cgaprinthex(uintptr x)
 {
 	char str[30];
 	char *s;
@@ -188,7 +188,7 @@ cgaconsputs(char *s, int n)
 void
 cgapost(int code)
 {
-	uint8_t *cga;
+	u8 *cga;
 
 	static char hex[] = "0123456789ABCDEF";
 
@@ -199,10 +199,10 @@ cgapost(int code)
 	cga[Width * Height - Postcodelen * 2 + 3] = Attr;
 }
 
-static int32_t
-cgaread(Chan *c, void *vbuf, int32_t len, int64_t off)
+static i32
+cgaread(Chan *c, void *vbuf, i32 len, i64 off)
 {
-	uint8_t *cga;
+	u8 *cga;
 	extern int panicking;
 	if(panicking)
 		error("cgaread: kernel panic");
@@ -215,10 +215,10 @@ cgaread(Chan *c, void *vbuf, int32_t len, int64_t off)
 	return len;
 }
 
-static int32_t
-cgawrite(Chan *c, void *vbuf, int32_t len, int64_t off)
+static i32
+cgawrite(Chan *c, void *vbuf, i32 len, i64 off)
 {
-	uint8_t *cga;
+	u8 *cga;
 	extern int panicking;
 	if(panicking)
 		error("cgawrite: kernel panic");

sys/src/9/amd64/ctype.c

@@ -2,7 +2,7 @@
 #include <libc.h>
 #include <ctype.h>
 
-uint8_t _ctype[256] =
+u8 _ctype[256] =
 	{
 		/*	 0	 1	 2	 3	 4	 5	 6	 7  */
 

sys/src/9/amd64/dat.h

@@ -21,7 +21,7 @@ typedef struct MFPU MFPU;
 typedef struct MMMU MMMU;
 typedef struct NIX NIX;
 typedef struct Mach Mach;
-typedef uint64_t Mpl;
+typedef u64 Mpl;
 typedef struct Page Page;
 typedef struct Pcidev Pcidev;
 typedef struct PAMap PAMap;
@@ -31,11 +31,11 @@ typedef struct PmcCtl PmcCtl;
 typedef struct PmcWait PmcWait;
 typedef struct PMMU PMMU;
 typedef struct PNOTIFY PNOTIFY;
-typedef uint64_t PTE;
+typedef u64 PTE;
 typedef struct Proc Proc;
 typedef struct Sys Sys;
 typedef struct Stackframe Stackframe;
-typedef uint64_t uintmem; /* Physical address (hideous) */
+typedef u64 uintmem; /* Physical address (hideous) */
 typedef struct Ureg Ureg;
 typedef struct Vctl Vctl;
 
@@ -87,32 +87,32 @@ enum regnames {
  */
 
 struct Lock {
-	uint32_t key;
+	u32 key;
 	int isilock;
 	Mpl pl;
-	uintptr_t _pc;
+	uintptr _pc;
 	Proc *p;
 	Mach *m;
-	uint64_t lockcycles;
+	u64 lockcycles;
 };
 
 struct Label {
-	uintptr_t sp;
-	uintptr_t pc;
-	uintptr_t fp;
-	uintptr_t _pad[13];
+	uintptr sp;
+	uintptr pc;
+	uintptr fp;
+	uintptr _pad[13];
 };
 
 struct Fxsave {
-	uint16_t fcw;		/* x87 control word */
-	uint16_t fsw;		/* x87 status word */
-	uint8_t ftw;		/* x87 tag word */
-	uint8_t zero;		/* 0 */
-	uint16_t fop;		/* last x87 opcode */
-	uint64_t rip;		/* last x87 instruction pointer */
-	uint64_t rdp;		/* last x87 data pointer */
-	uint32_t mxcsr;		/* MMX control and status */
-	uint32_t mxcsrmask;	/* supported MMX feature bits */
+	u16 fcw;		/* x87 control word */
+	u16 fsw;		/* x87 status word */
+	u8 ftw;		/* x87 tag word */
+	u8 zero;		/* 0 */
+	u16 fop;		/* last x87 opcode */
+	u64 rip;		/* last x87 instruction pointer */
+	u64 rdp;		/* last x87 data pointer */
+	u32 mxcsr;		/* MMX control and status */
+	u32 mxcsrmask;	/* supported MMX feature bits */
 	unsigned char st[128];	/* shared 64-bit media and x87 regs */
 	unsigned char xmm[256]; /* 128-bit media regs */
 	unsigned char ign[96];	/* reserved, ignored */
@@ -142,20 +142,20 @@ struct PNOTIFY {
 };
 
 struct Confmem {
-	uintptr_t base;
+	uintptr base;
 	usize npage;
-	uintptr_t kbase;
-	uintptr_t klimit;
+	uintptr kbase;
+	uintptr klimit;
 };
 
 struct Conf {
-	uint32_t nproc;	   /* processes */
+	u32 nproc;	   /* processes */
 	Confmem mem[4];	   /* physical memory */
-	uint64_t npage;	   /* total physical pages of memory */
+	u64 npage;	   /* total physical pages of memory */
 	usize upages;	   /* user page pool */
-	uint32_t copymode; /* 0 is copy on write, 1 is copy on reference */
-	uint32_t ialloc;   /* max interrupt time allocation in bytes */
-	uint32_t nimage;   /* number of page cache image headers */
+	u32 copymode; /* 0 is copy on write, 1 is copy on reference */
+	u32 ialloc;   /* max interrupt time allocation in bytes */
+	u32 nimage;   /* number of page cache image headers */
 };
 
 enum {
@@ -168,7 +168,7 @@ enum {
  *  CPU stuff in Mach.
  */
 struct MCPU {
-	uint32_t cpuinfo[3][4]; /*  CPUID Functions 0, 1, and 5 (n.b.: 2-4 are invalid) */
+	u32 cpuinfo[3][4]; /*  CPUID Functions 0, 1, and 5 (n.b.: 2-4 are invalid) */
 	int ncpuinfos;		/* number of standard entries */
 	int ncpuinfoe;		/* number of extended entries */
 	int isintelcpu;		/*  */
@@ -178,9 +178,9 @@ struct MCPU {
  *  FPU stuff in Mach.
  */
 struct MFPU {
-	uint16_t fcw;	    /* x87 control word */
-	uint32_t mxcsr;	    /* MMX control and status */
-	uint32_t mxcsrmask; /* supported MMX feature bits */
+	u16 fcw;	    /* x87 control word */
+	u32 mxcsr;	    /* MMX control and status */
+	u32 mxcsrmask; /* supported MMX feature bits */
 };
 
 struct NIX {
@@ -192,7 +192,7 @@ struct NIX {
  *  MMU stuff in Mach.
  */
 struct MMMU {
-	uintptr_t cr2;
+	uintptr cr2;
 	Page *pml4;	 /* pml4 for this processor */
 	Page pml4kludge; /* NIX KLUDGE: we need a page */
 };
@@ -222,7 +222,7 @@ struct ICC {
  */
 struct PmcCtl {
 	Ref r;
-	uint32_t _coreno;
+	u32 _coreno;
 	int enab;
 	int user;
 	int os;
@@ -240,7 +240,7 @@ struct PmcWait {
 struct PmcCtr {
 	int stale;
 	PmcWait *wq;
-	uint64_t ctr;
+	u64 ctr;
 	int ctrset;
 	PmcCtl PmcCtl;
 	int ctlset;
@@ -266,12 +266,12 @@ enum {
  */
 struct Mach {
 	/* WARNING! Known to assembly! */
-	uintptr_t self; /* %gs:0 still gives us a Mach* */
-	uint64_t splpc; /* pc of last caller to splhi */
+	uintptr self; /* %gs:0 still gives us a Mach* */
+	u64 splpc; /* pc of last caller to splhi */
 
 	Proc *proc;	   /* current process on this processor */
-	uintptr_t stack;   /* mach stack, kstack is in proc->kstack */
-	uintptr_t rathole; /* to save a reg in syscallentry */
+	uintptr stack;   /* mach stack, kstack is in proc->kstack */
+	uintptr rathole; /* to save a reg in syscallentry */
 	Proc *externup;	   /* Forsyth recommends we replace the global up with this. */
 	/* end warning, I think */
 
@@ -286,15 +286,15 @@ struct Mach {
 	void *gdt;
 	void *tss;
 
-	uint64_t ticks; /* of the clock since boot time */
+	u64 ticks; /* of the clock since boot time */
 	Label sched;	/* scheduler wakeup */
 	Lock alarmlock; /* access to alarm list */
 	void *alarm;	/* alarms bound to this clock */
 	int inclockintr;
 
 	Proc *readied;	     /* old runproc, only relevant if kernel booted with nosmp (-n append) */
-	uint64_t schedticks; /* next forced context switch, same as above */
-	uint64_t qstart;     /* time when up started running */
+	u64 schedticks; /* next forced context switch, same as above */
+	u64 qstart;     /* time when up started running */
 	int qexpired;	     /* quantum expired */
 
 	int tlbfault;
@@ -310,10 +310,10 @@ struct Mach {
 	int lastintr;
 
 	Lock apictimerlock;
-	uint64_t cyclefreq; /* Frequency of user readable cycle counter */
-	int64_t cpuhz;
+	u64 cyclefreq; /* Frequency of user readable cycle counter */
+	i64 cpuhz;
 	int cpumhz;
-	uint64_t rdtsc;
+	u64 rdtsc;
 
 	Lock pmclock;
 	PmcCtr pmc[PmcMaxCtrs];
@@ -331,7 +331,7 @@ static_assert(sizeof(Mach) <= PGSZ, "Mach is too big");
 
 struct Stackframe {
 	Stackframe *next;
-	uintptr_t pc;
+	uintptr pc;
 };
 
 /*
@@ -395,7 +395,7 @@ extern Sys *const sys;
 #define PHYSADDRSIZE (1ULL << 46)
 
 struct PAMap {
-	uintmem addr;
+	u64 addr;
 	usize size;
 	int type;
 	PAMap *next;
@@ -442,12 +442,12 @@ struct {
 
 struct ISAConf {
 	char *type;
-	uintptr_t port;
+	uintptr port;
 	int irq;
-	uint32_t dma;
-	uintptr_t mem;
+	u32 dma;
+	uintptr mem;
 	usize size;
-	uint32_t freq;
+	u32 freq;
 
 	int nopt;
 	char *opt[NISAOPT];

sys/src/9/amd64/devacpi.c

@@ -49,22 +49,22 @@ enum {
 /* what do we need to round up to? */
 #define ATABLEBUFSZ ROUNDUP(sizeof(Atable), 128)
 
-static uint64_t lastpath;
+static u64 lastpath;
 static PSlice emptyslice;
 static Atable **atableindex;
 static Rsdp *rsd = nil;
 static Queue *acpiev;
 Dev acpidevtab;
 
-static uint16_t pm1status;
+static u16 pm1status;
 static int v = 0;
 /* Table of ACPI ports we own. We just burn 64k of bss here rather
  * than look them up in a function each time they're used. */
-static uint8_t acpiport[1 << 16];
-static int32_t acpiioread(Chan *c, void *a, int32_t n, int64_t off);
-static int32_t acpiiowrite(Chan *c, void *a, int32_t n, int64_t off);
-static int32_t acpimemread(Chan *c, void *a, int32_t n, int64_t off);
-static int32_t acpiintrread(Chan *c, void *a, int32_t n, int64_t off);
+static u8 acpiport[1 << 16];
+static i32 acpiioread(Chan *c, void *a, i32 n, isize off);
+static i32 acpiiowrite(Chan *c, void *a, i32 n, isize off);
+static i32 acpimemread(Chan *c, void *a, i32 n, isize off);
+static i32 acpiintrread(Chan *c, void *a, i32 n, isize off);
 
 static void acpiintr(Ureg *, void *);
 
@@ -137,9 +137,9 @@ static char *regnames[] = {
  */
 struct Acpilist {
 	struct Acpilist *next;
-	uintptr_t base;
-	size_t size;
-	int8_t raw[];
+	uintptr base;
+	usize size;
+	u8 raw[];
 };
 typedef struct Acpilist Acpilist;
 static Acpilist *acpilists;
@@ -150,7 +150,7 @@ static Acpilist *acpilists;
  * so size matters.
  */
 static Acpilist *
-findlist(uintptr_t base, uint size)
+findlist(uintptr base, uint size)
 {
 	Acpilist *a = acpilists;
 	if(v)
@@ -171,8 +171,8 @@ findlist(uintptr_t base, uint size)
  */
 Atable *
 mkatable(Atable *parent,
-	 int type, char *name, uint8_t *raw,
-	 size_t rawsize, size_t addsize)
+	 int type, char *name, u8 *raw,
+	 usize rawsize, usize addsize)
 {
 	void *m;
 	Atable *t;
@@ -200,7 +200,7 @@ mkatable(Atable *parent,
 Atable *
 finatable(Atable *t, PSlice *slice)
 {
-	size_t n;
+	usize n;
 	Atable *tail;
 	Dirtab *dirs;
 
@@ -214,7 +214,7 @@ finatable(Atable *t, PSlice *slice)
 	dirs[2] = (Dirtab){"raw", t->rqid, t->rawsize, 0444};
 	dirs[3] = (Dirtab){"table", t->tqid, 0, 0444};
 	dirs[4] = (Dirtab){"ctl", t->tqid, 0, 0666};
-	for(size_t i = 0; i < n; i++){
+	for(usize i = 0; i < n; i++){
 		strlcpy(dirs[i + NQtypes].name, t->children[i]->name, KNAMELEN);
 		dirs[i + NQtypes].qid = t->children[i]->qid;
 		dirs[i + NQtypes].length = 0;
@@ -263,100 +263,100 @@ acpiregid(char *s)
  * TODO(rminnich): Fix these if we're ever on a different-endian machine.
  * They are specific to little-endian processors and are not portable.
  */
-static uint8_t
-mget8(uintptr_t p, void *unused)
+static u8
+mget8(uintptr p, void *unused)
 {
-	uint8_t *cp = (uint8_t *)p;
+	u8 *cp = (u8 *)p;
 	return *cp;
 }
 
 static void
-mset8(uintptr_t p, uint8_t v, void *unused)
+mset8(uintptr p, u8 v, void *unused)
 {
-	uint8_t *cp = (uint8_t *)p;
+	u8 *cp = (u8 *)p;
 	*cp = v;
 }
 
-static uint16_t
-mget16(uintptr_t p, void *unused)
+static u16
+mget16(uintptr p, void *unused)
 {
-	uint16_t *cp = (uint16_t *)p;
+	u16 *cp = (u16 *)p;
 	return *cp;
 }
 
 static void
-mset16(uintptr_t p, uint16_t v, void *unused)
+mset16(uintptr p, u16 v, void *unused)
 {
-	uint16_t *cp = (uint16_t *)p;
+	u16 *cp = (u16 *)p;
 	*cp = v;
 }
 
-static uint32_t
-mget32(uintptr_t p, void *unused)
+static u32
+mget32(uintptr p, void *unused)
 {
-	uint32_t *cp = (uint32_t *)p;
+	u32 *cp = (u32 *)p;
 	return *cp;
 }
 
 static void
-mset32(uintptr_t p, uint32_t v, void *unused)
+mset32(uintptr p, u32 v, void *unused)
 {
-	uint32_t *cp = (uint32_t *)p;
+	u32 *cp = (u32 *)p;
 	*cp = v;
 }
 
-static uint64_t
-mget64(uintptr_t p, void *unused)
+static u64
+mget64(uintptr p, void *unused)
 {
-	uint64_t *cp = (uint64_t *)p;
+	u64 *cp = (u64 *)p;
 	return *cp;
 }
 
 static void
-mset64(uintptr_t p, uint64_t v, void *unused)
+mset64(uintptr p, u64 v, void *unused)
 {
-	uint64_t *cp = (uint64_t *)p;
+	u64 *cp = (u64 *)p;
 	*cp = v;
 }
 
-static uint8_t
-ioget8(uintptr_t p, void *unused)
+static u8
+ioget8(uintptr p, void *unused)
 {
 	return inb(p);
 }
 
 static void
-ioset8(uintptr_t p, uint8_t v, void *unused)
+ioset8(uintptr p, u8 v, void *unused)
 {
 	outb(p, v);
 }
 
-static uint16_t
-ioget16(uintptr_t p, void *unused)
+static u16
+ioget16(uintptr p, void *unused)
 {
 	return ins(p);
 }
 
 static void
-ioset16(uintptr_t p, uint16_t v, void *unused)
+ioset16(uintptr p, u16 v, void *unused)
 {
 	outs(p, v);
 }
 
-static uint32_t
-ioget32(uintptr_t p, void *unused)
+static u32
+ioget32(uintptr p, void *unused)
 {
 	return inl(p);
 }
 
 static void
-ioset32(uintptr_t p, uint32_t v, void *unused)
+ioset32(uintptr p, u32 v, void *unused)
 {
 	outl(p, v);
 }
 
-static uint8_t
-cfgget8(uintptr_t p, void *r)
+static u8
+cfgget8(uintptr p, void *r)
 {
 	Reg *ro = r;
 	Pcidev d;
@@ -366,7 +366,7 @@ cfgget8(uintptr_t p, void *r)
 }
 
 static void
-cfgset8(uintptr_t p, uint8_t v, void *r)
+cfgset8(uintptr p, u8 v, void *r)
 {
 	Reg *ro = r;
 	Pcidev d;
@@ -375,8 +375,8 @@ cfgset8(uintptr_t p, uint8_t v, void *r)
 	pcicfgw8(&d, p, v);
 }
 
-static uint16_t
-cfgget16(uintptr_t p, void *r)
+static u16
+cfgget16(uintptr p, void *r)
 {
 	Reg *ro = r;
 	Pcidev d;
@@ -386,7 +386,7 @@ cfgget16(uintptr_t p, void *r)
 }
 
 static void
-cfgset16(uintptr_t p, uint16_t v, void *r)
+cfgset16(uintptr p, u16 v, void *r)
 {
 	Reg *ro = r;
 	Pcidev d;
@@ -395,8 +395,8 @@ cfgset16(uintptr_t p, uint16_t v, void *r)
 	pcicfgw16(&d, p, v);
 }
 
-static uint32_t
-cfgget32(uintptr_t p, void *r)
+static u32
+cfgget32(uintptr p, void *r)
 {
 	Reg *ro = r;
 	Pcidev d;
@@ -406,7 +406,7 @@ cfgget32(uintptr_t p, void *r)
 }
 
 static void
-cfgset32(uintptr_t p, uint32_t v, void *r)
+cfgset32(uintptr p, u32 v, void *r)
 {
 	Reg *ro = r;
 	Pcidev d;
@@ -434,8 +434,8 @@ static struct Regio cfgio = {
  * Copy memory, 1/2/4/8-bytes at a time, to/from a region.
  */
 static long
-regcpy(Regio *dio, uintptr_t da, Regio *sio,
-       uintptr_t sa, long len, int align)
+regcpy(Regio *dio, uintptr da, Regio *sio,
+       uintptr sa, long len, int align)
 {
 	int n, i;
 
@@ -476,10 +476,10 @@ regcpy(Regio *dio, uintptr_t da, Regio *sio,
  * All units in bytes.
  */
 static long
-regio(Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
+regio(Reg *r, void *p, u32 len, uintptr off, int iswr)
 {
 	Regio rio;
-	uintptr_t rp;
+	uintptr rp;
 
 	print("reg%s %s %#p %#p %#lx sz=%d\n",
 	      iswr ? "out" : "in", r->name, p, off, len, r->accsz);
@@ -498,7 +498,7 @@ regio(Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
 			r->p = KADDR(r->base);
 		if(r->p == nil)
 			error("regio: KADDR failed");
-		rp = (uintptr_t)r->p + off;
+		rp = (uintptr)r->p + off;
 		rio = memio;
 		break;
 	case Rsysio:
@@ -520,32 +520,34 @@ regio(Reg *r, void *p, uint32_t len, uintptr_t off, int iswr)
 		error("region not supported");
 	}
 	if(iswr)
-		regcpy(&rio, rp, &memio, (uintptr_t)p, len, r->accsz);
+		regcpy(&rio, rp, &memio, (uintptr)p, len, r->accsz);
 	else
-		regcpy(&memio, (uintptr_t)p, &rio, rp, len, r->accsz);
+		regcpy(&memio, (uintptr)p, &rio, rp, len, r->accsz);
 	return len;
 }
 
 /*
  * Compute and return SDT checksum: '0' is a correct sum.
  */
-static uint8_t
+static u8
 sdtchecksum(void *addr, int len)
 {
-	uint8_t *p, sum;
+	u8 *p;
+	unsigned int sum;
 
 	sum = 0;
 	if(v)
 		print("check %p %d\n", addr, len);
 	for(p = addr; len-- > 0; p++)
 		sum += *p;
+	sum &= 0xFF;  // The checksum is only the low 8 bits.
 	if(v)
 		print("sum is 0x%x\n", sum);
-	return sum;
+	return (u8)sum;
 }
 
 static void *
-sdtmap(uintptr_t pa, size_t want, size_t *n, int cksum)
+sdtmap(uintptr pa, usize want, usize *n, int cksum)
 {
 	Sdthdr *sdt;
 	Acpilist *p;
@@ -559,10 +561,10 @@ sdtmap(uintptr_t pa, size_t want, size_t *n, int cksum)
 	sdt = KADDR(pa);
 	if(want){
 		/* realistically, we get a full page, and acpica seems to know that somehow. */
-		uintptr_t endaddress = (uintptr_t)sdt;
+		uintptr endaddress = (uintptr)sdt;
 		endaddress += want + 0xfff;
 		endaddress &= ~0xfff;
-		want = endaddress - (uintptr_t)sdt;
+		want = endaddress - (uintptr)sdt;
 		*n = want;
 	} else {
 		if(v){
@@ -602,9 +604,9 @@ sdtmap(uintptr_t pa, size_t want, size_t *n, int cksum)
 }
 
 static int
-loadfacs(uintptr_t pa)
+loadfacs(uintptr pa)
 {
-	size_t n;
+	usize n;
 	facs = sdtmap(pa, 0, &n, 0);
 	if(facs == nil)
 		return -1;
@@ -628,10 +630,10 @@ loadfacs(uintptr_t pa)
 }
 
 static void
-loaddsdt(uintptr_t pa)
+loaddsdt(uintptr pa)
 {
-	size_t n;
-	uint8_t *dsdtp;
+	usize n;
+	u8 *dsdtp;
 
 	dsdtp = sdtmap(pa, 0, &n, 1);
 	if(v)
@@ -643,7 +645,7 @@ loaddsdt(uintptr_t pa)
 }
 
 static void
-gasget(Gas *gas, uint8_t *p)
+gasget(Gas *gas, u8 *p)
 {
 	gas->spc = p[0];
 	gas->len = p[1];
@@ -711,7 +713,7 @@ dumpfadt(char *start, char *end, Fadt *fp)
 }
 
 static Atable *
-parsefadt(Atable *parent, char *name, uint8_t *p, size_t rawsize)
+parsefadt(Atable *parent, char *name, u8 *p, usize rawsize)
 {
 	Atable *t;
 	Fadt *fp;
@@ -789,11 +791,11 @@ parsefadt(Atable *parent, char *name, uint8_t *p, size_t rawsize)
 		loadfacs(fp->facs);
 
 	if(v)
-		print("x %p %p %p \n", fp, (void *)fp->xdsdt, (void *)(uint64_t)fp->dsdt);
+		print("x %p %p %p \n", fp, (void *)fp->xdsdt, (void *)(u64)fp->dsdt);
 
 	if(v)
 		print("fp->xdsdt %#llx facs %#llx\n", fp->xdsdt, fp->dsdt);
-	if(fp->xdsdt == (uint64_t)fp->dsdt) /* acpica */
+	if(fp->xdsdt == (u64)fp->dsdt) /* acpica */
 		loaddsdt(fp->xdsdt);
 	else
 		loaddsdt(fp->dsdt);
@@ -834,12 +836,12 @@ dumpmsct(char *start, char *end, Atable *table)
  * Else we should remove this code.
  */
 static Atable *
-parsemsct(Atable *parent, char *name, uint8_t *raw, size_t rawsize)
+parsemsct(Atable *parent, char *name, u8 *raw, usize rawsize)
 {
 	Atable *t;
-	uint8_t *r, *re;
+	u8 *r, *re;
 	Msct *msct;
-	size_t off, nmdom;
+	usize off, nmdom;
 	int i;
 
 	re = raw + rawsize;
@@ -932,10 +934,10 @@ dumpsrat(char *start, char *end, Atable *table)
 }
 
 static Atable *
-parsesrat(Atable *parent, char *name, uint8_t *p, size_t rawsize)
+parsesrat(Atable *parent, char *name, u8 *p, usize rawsize)
 {
 	Atable *t, *tt;
-	uint8_t *pe;
+	u8 *pe;
 	int stlen, flags;
 	PSlice slice;
 	char buf[16];
@@ -1035,13 +1037,13 @@ cmpslitent(void *v1, void *v2)
 
 static Atable *
 parseslit(Atable *parent,
-	  char *name, uint8_t *raw, size_t rawsize)
+	  char *name, u8 *raw, usize rawsize)
 {
 	Atable *t;
-	uint8_t *r, *re;
+	u8 *r, *re;
 	int i;
 	SlEntry *se;
-	size_t addsize, rowlen;
+	usize addsize, rowlen;
 	void *p;
 
 	addsize = sizeof(*slit);
@@ -1228,14 +1230,14 @@ dumpmadt(char *start, char *end, Atable *apics)
 }
 
 static Atable *
-parsemadt(Atable *parent, char *name, uint8_t *p, size_t size)
+parsemadt(Atable *parent, char *name, u8 *p, usize size)
 {
 	Atable *t, *tt;
-	uint8_t *pe;
+	u8 *pe;
 	Madt *mt;
 	Apicst *st, *l;
 	int id;
-	size_t stlen;
+	usize stlen;
 	char buf[16];
 	int i;
 	PSlice slice;
@@ -1359,7 +1361,7 @@ parsemadt(Atable *parent, char *name, uint8_t *p, size_t size)
 }
 
 static Atable *
-parsedmar(Atable *parent, char *name, uint8_t *raw, size_t rawsize)
+parsedmar(Atable *parent, char *name, u8 *raw, usize rawsize)
 {
 	Atable *t, *tt;
 	int i;
@@ -1450,7 +1452,7 @@ parsedmar(Atable *parent, char *name, uint8_t *raw, size_t rawsize)
  */
 static Atable *
 parsessdt(Atable *parent,
-	  char *name, uint8_t *raw, size_t size)
+	  char *name, u8 *raw, usize size)
 {
 	Atable *t;
 	Sdthdr *h;
@@ -1470,7 +1472,7 @@ parsessdt(Atable *parent,
 }
 
 static char *
-dumptable(char *start, char *end, char *sig, uint8_t *p, int l)
+dumptable(char *start, char *end, char *sig, u8 *p, int l)
 {
 	int n, i;
 
@@ -1496,10 +1498,10 @@ dumptable(char *start, char *end, char *sig, uint8_t *p, int l)
 static char *
 seprinttable(char *s, char *e, Atable *t)
 {
-	uint8_t *p;
+	u8 *p;
 	int i, n;
 
-	p = (uint8_t *)t->tbl; /* include header */
+	p = (u8 *)t->tbl; /* include header */
 	n = t->rawsize;
 	s = seprint(s, e, "%s @ %#p\n", t->name, p);
 	for(i = 0; i < n; i++){
@@ -1513,7 +1515,7 @@ seprinttable(char *s, char *e, Atable *t)
 }
 
 void *
-rsdsearch(void *start, uintptr_t size)
+rsdsearch(void *start, uintptr size)
 {
 	if(rsd != nil)
 		return rsd;
@@ -1542,7 +1544,7 @@ rsdsearch(void *start, uintptr_t size)
 typedef struct Parser {
 	char *sig;
 	Atable *(*parse)(Atable *parent,
-			 char *name, uint8_t *raw, size_t rawsize);
+			 char *name, u8 *raw, usize rawsize);
 } Parser;
 
 static Parser ptable[] = {
@@ -1566,10 +1568,10 @@ parsexsdt(Atable *root)
 	Sdthdr *sdt;
 	Atable *table;
 	PSlice slice;
-	size_t l, end;
-	uintptr_t dhpa;
+	usize l, end;
+	uintptr dhpa;
 	//Atable *n;
-	uint8_t *tbl;
+	u8 *tbl;
 	if(v)
 		print("1\n");
 	psliceinit(&slice);
@@ -1608,7 +1610,7 @@ parsexsdt(Atable *root)
 void
 makeindex(Atable *root)
 {
-	uint64_t index;
+	u64 index;
 
 	if(root == nil)
 		return;
@@ -1622,7 +1624,7 @@ static void
 parsersdptr(void)
 {
 	int asize, cksum;
-	uintptr_t sdtpa;
+	uintptr sdtpa;
 
 	/* Find the root pointer. */
 	/*
@@ -1645,8 +1647,8 @@ parsersdptr(void)
 	if(v)
 		print("/* RSDP */ Rsdp = {%08c, %x, %06c, %x, %p, %d, %p, %x}\n",
 		      rsd->signature, rsd->rchecksum, rsd->oemid, rsd->revision,
-		      *(uint32_t *)rsd->raddr, *(uint32_t *)rsd->length,
-		      *(uint64_t *)rsd->xaddr, rsd->xchecksum);
+		      *(u32 *)rsd->raddr, *(u32 *)rsd->length,
+		      *(u64 *)rsd->xaddr, rsd->xchecksum);
 
 	if(v)
 		print("acpi: RSD PTR@ %#p, physaddr $%p length %ud %#llx rev %d\n",
@@ -1711,7 +1713,7 @@ static Atable *
 genatable(Chan *c)
 {
 	Atable *a;
-	uint64_t ai;
+	u64 ai;
 
 	ai = c->qid.path >> QIndexShift;
 	assert(ai < lastpath);
@@ -1765,12 +1767,12 @@ dumpGas(char *start, char *end, char *prefix, Gas *g)
 		start = seprint(start, end, "[pci ");
 		start =
 			seprint(start, end, "dev %#p ",
-				(uint32_t)(g->addr >> 32) & 0xFFFF);
+				(u32)(g->addr >> 32) & 0xFFFF);
 		start =
 			seprint(start, end, "fn %#p ",
-				(uint32_t)(g->addr & 0xFFFF0000) >> 16);
+				(u32)(g->addr & 0xFFFF0000) >> 16);
 		start =
-			seprint(start, end, "adr %#p ", (uint32_t)(g->addr & 0xFFFF));
+			seprint(start, end, "adr %#p ", (u32)(g->addr & 0xFFFF));
 		break;
 	case Rfixedhw:
 		start = seprint(start, end, "[hw ");
@@ -1785,7 +1787,7 @@ dumpGas(char *start, char *end, char *prefix, Gas *g)
 }
 
 static unsigned int
-getbanked(uintptr_t ra, uintptr_t rb, int sz)
+getbanked(uintptr ra, uintptr rb, int sz)
 {
 	unsigned int r;
 
@@ -1816,7 +1818,7 @@ getbanked(uintptr_t ra, uintptr_t rb, int sz)
 }
 
 static unsigned int
-setbanked(uintptr_t ra, uintptr_t rb, int sz, int val)
+setbanked(uintptr ra, uintptr rb, int sz, int val)
 {
 	unsigned int r;
 	if(v)
@@ -1976,7 +1978,7 @@ startgpes(void)
 }
 
 static void
-acpiioalloc(uint16_t addr, int len)
+acpiioalloc(u16 addr, int len)
 {
 	if(ioalloc(addr, len, 1, "ACPI") < 0)
 		return;
@@ -2101,7 +2103,7 @@ acpiwalk(Chan *c, Chan *nc, char **name, int nname)
 }
 
 static int
-acpistat(Chan *c, uint8_t *dp, int n)
+acpistat(Chan *c, u8 *dp, int n)
 {
 	Atable *a = genatable(c);
 
@@ -2133,8 +2135,8 @@ static int tlen;
  * start at 0 in Qraw. We need this special read so we can make sense of pointers in tables,
  * which are physical addresses.
  */
-static int32_t
-acpimemread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+acpimemread(Chan *c, void *a, i32 n, isize off)
 {
 	Proc *up = externup();
 	Acpilist *l;
@@ -2154,7 +2156,7 @@ acpimemread(Chan *c, void *a, int32_t n, int64_t off)
 	if(v)
 		print("ACPI Qraw: rsd %p %p %d %p\n", rsd, a, n, (void *)off);
 	if(off == 0){
-		uint32_t pa = (uint32_t)PADDR(rsd);
+		u32 pa = (u32)PADDR(rsd);
 		print("FIND RSD\n");
 		print("PA OF rsd is %lx\n", pa);
 		return readmem(0, a, n, &pa, sizeof(pa));
@@ -2171,7 +2173,7 @@ acpimemread(Chan *c, void *a, int32_t n, int64_t off)
 	l = findlist(off, n);
 	/* we don't load all the lists, so this may be a new one. */
 	if(!l){
-		size_t _;
+		usize _;
 		if(sdtmap(off, n, &_, 0) == nil){
 			static char msg[256];
 			snprint(msg, sizeof(msg), "unable to map acpi@%p/%d", off, n);
@@ -2195,8 +2197,8 @@ acpimemread(Chan *c, void *a, int32_t n, int64_t off)
 /*
  * acpiintrread waits on the acpiev Queue.
  */
-static int32_t
-acpiintrread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+acpiintrread(Chan *c, void *a, i32 n, isize off)
 {
 	if(acpienable())
 		error("Can't enable ACPI");
@@ -2210,13 +2212,13 @@ acpiintrread(Chan *c, void *a, int32_t n, int64_t off)
 /* acpiioread only lets you read one of each type for now.
  * i.e. one byte, word, or long.
  */
-static int32_t
-acpiioread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+acpiioread(Chan *c, void *a, i32 n, isize off)
 {
 	int port, pm1aevtblk;
-	uint8_t *p;
-	uint16_t *sp;
-	uint32_t *lp;
+	u8 *p;
+	u16 *sp;
+	u32 *lp;
 
 	pm1aevtblk = (int)fadt->pm1aevtblk;
 	port = off;
@@ -2261,13 +2263,13 @@ acpiioread(Chan *c, void *a, int32_t n, int64_t off)
 	return -1;
 }
 
-static int32_t
-acpiiowrite(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+acpiiowrite(Chan *c, void *a, i32 n, isize off)
 {
 	int port, pm1aevtblk;
-	uint8_t *p;
-	uint16_t *sp;
-	uint32_t *lp;
+	u8 *p;
+	u16 *sp;
+	u32 *lp;
 
 	port = off;
 	pm1aevtblk = (int)fadt->pm1aevtblk;
@@ -2312,8 +2314,8 @@ acpiiowrite(Chan *c, void *a, int32_t n, int64_t off)
 // Actually, this function doesn't do this right now for pretty or table.
 // It dumps the same table at every level. Working on it.
 // It does the right thing for raw.
-static int32_t
-acpiread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+acpiread(Chan *c, void *a, i32 n, isize off)
 {
 	long q;
 	Atable *t;
@@ -2373,18 +2375,18 @@ acpiread(Chan *c, void *a, int32_t n, int64_t off)
 	return -1;
 }
 
-static int32_t
-acpiwrite(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+acpiwrite(Chan *c, void *a, i32 n, isize off)
 {
 	error("not yet");
 	return -1;
 #if 0
-	int acpiirq(uint32_t tbdf, int irq);
+	int acpiirq(u32 tbdf, int irq);
 	Proc *up = externup();
 	Cmdtab *ct;
 	Cmdbuf *cb;
 
-	uint32_t tbdf;
+	u32 tbdf;
 	int irq;
 
 	if (c->qid.path == Qio){
@@ -2480,7 +2482,7 @@ pretty(Atable *atbl, char *start, char *end, void *arg)
 static char *
 raw(Atable *atbl, char *start, char *end, void *unused_arg)
 {
-	size_t len = MIN(end - start, atbl->rawsize);
+	usize len = MIN(end - start, atbl->rawsize);
 
 	memmove(start, atbl->raw, len);
 

sys/src/9/amd64/devarch.c

@@ -18,9 +18,9 @@
 
 typedef struct Cpuflag {
 	const char *name; /* short name (linux-like)*/
-	uint32_t eax;	  /* input eax */
-	uint8_t infoidx;  /* index of info result */
-	uint8_t bitidx;	  /* feature bit in info result */
+	u32 eax;	  /* input eax */
+	u8 infoidx;  /* index of info result */
+	u8 bitidx;	  /* feature bit in info result */
 } Cpuflag;
 
 // Below infoidxs equate to: 0=eax 1=ebx 2=ecx 3=edx
@@ -987,8 +987,8 @@ struct IOMap {
 	IOMap *next;
 	int reserved;
 	char tag[13];
-	uint32_t start;
-	uint32_t end;
+	u32 start;
+	u32 end;
 };
 
 static struct
@@ -1013,7 +1013,7 @@ enum {
 	Qmax = 32,
 };
 
-typedef int32_t Rdwrfn(Chan *, void *, int32_t, int64_t);
+typedef i32 Rdwrfn(Chan *, void *, i32, i64);
 
 static Rdwrfn *readfn[Qmax];
 static Rdwrfn *writefn[Qmax];
@@ -1290,8 +1290,8 @@ archwalk(Chan *c, Chan *nc, char **name, int nname)
 	return devwalk(c, nc, name, nname, archdir, narchdir, devgen);
 }
 
-static int32_t
-archstat(Chan *c, uint8_t *dp, int32_t n)
+static i32
+archstat(Chan *c, u8 *dp, i32 n)
 {
 	return devstat(c, dp, n, archdir, narchdir, devgen);
 }
@@ -1311,17 +1311,17 @@ enum {
 	Linelen = 31,
 };
 
-static int32_t
-archread(Chan *c, void *a, int32_t n, int64_t offset)
+static i32
+archread(Chan *c, void *a, i32 n, i64 offset)
 {
 	char *buf, *p;
 	int port;
-	uint16_t *sp;
-	uint32_t *lp;
+	u16 *sp;
+	u32 *lp;
 	IOMap *map;
 	Rdwrfn *fn;
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 
 	case Qdir:
 		return devdirread(c, a, n, archdir, narchdir, devgen);
@@ -1367,7 +1367,7 @@ archread(Chan *c, void *a, int32_t n, int64_t offset)
 	n = n / Linelen;
 	offset = offset / Linelen;
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 	case Qioalloc:
 		lock(&iomap.l);
 		for(map = iomap.map; n > 0 && map != nil; map = map->next){
@@ -1409,16 +1409,16 @@ archread(Chan *c, void *a, int32_t n, int64_t offset)
 	return n;
 }
 
-static int32_t
-archwrite(Chan *c, void *a, int32_t n, int64_t offset)
+static i32
+archwrite(Chan *c, void *a, i32 n, i64 offset)
 {
 	char *p;
 	int port;
-	uint16_t *sp;
-	uint32_t *lp;
+	u16 *sp;
+	u32 *lp;
 	Rdwrfn *fn;
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 
 	case Qiob:
 		p = a;
@@ -1484,12 +1484,12 @@ nop(void)
 
 void (*coherence)(void) = mfence;
 
-static int32_t
-cputyperead(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+cputyperead(Chan *c, void *a, i32 n, i64 off)
 {
 	char buf[512], *s, *e;
 	char *vendorid;
-	uint32_t info0[4];
+	u32 info0[4];
 
 	s = buf;
 	e = buf + sizeof buf;
@@ -1508,7 +1508,7 @@ cputyperead(Chan *c, void *a, int32_t n, int64_t off)
 static void
 get_cpuid_limits(int *num_basic, int *num_hypervisor, int *num_extended)
 {
-	uint32_t info[4];
+	u32 info[4];
 
 	*num_basic = 0;
 	*num_hypervisor = 0;
@@ -1527,11 +1527,11 @@ get_cpuid_limits(int *num_basic, int *num_hypervisor, int *num_extended)
 
 // Given an index into the valid cpuids, and the number of each range of values,
 // return the appropriate EAX value.
-static int32_t
-itoeax(int i, uint32_t num_basic, uint32_t num_hyp, uint32_t num_ext)
+static i32
+itoeax(int i, u32 num_basic, u32 num_hyp, u32 num_ext)
 {
-	uint32_t first_hyp = num_basic;
-	uint32_t first_ext = num_basic + num_hyp;
+	u32 first_hyp = num_basic;
+	u32 first_ext = num_basic + num_hyp;
 	if(i >= first_ext){
 		return 0x80000000 + i - first_ext;
 	} else if(i >= first_hyp){
@@ -1542,19 +1542,19 @@ itoeax(int i, uint32_t num_basic, uint32_t num_hyp, uint32_t num_ext)
 }
 
 // Output hex values of all valid cpuid values
-static int32_t
-cpuidrawread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+cpuidrawread(Chan *c, void *a, i32 n, i64 off)
 {
 	char buf[4096];
 	char *s = buf;
 	char *e = buf + sizeof buf;
-	uint32_t info[4];
+	u32 info[4];
 
 	int num_basic = 0, num_hyp = 0, num_ext = 0;
 	get_cpuid_limits(&num_basic, &num_hyp, &num_ext);
 
 	for(int i = 0; i < num_basic + num_hyp + num_ext; i++){
-		uint32_t eax = itoeax(i, num_basic, num_hyp, num_ext);
+		u32 eax = itoeax(i, num_basic, num_hyp, num_ext);
 		if(!cpuid(eax, 0, info)){
 			continue;
 		}
@@ -1566,13 +1566,13 @@ cpuidrawread(Chan *c, void *a, int32_t n, int64_t off)
 }
 
 // Output cpu flag shortnames from cpuid values
-static int32_t
-cpuidflagsread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+cpuidflagsread(Chan *c, void *a, i32 n, i64 off)
 {
 	char buf[4096];
 	char *s = buf;
 	char *e = buf + sizeof buf;
-	uint32_t info[4];
+	u32 info[4];
 
 	int num_basic = 0, num_hyp = 0, num_ext = 0;
 	get_cpuid_limits(&num_basic, &num_hyp, &num_ext);
@@ -1580,7 +1580,7 @@ cpuidflagsread(Chan *c, void *a, int32_t n, int64_t off)
 	int num_flags = nelem(cpuflags);
 
 	for(int i = 0; i < num_basic + num_hyp + num_ext; i++){
-		uint32_t eax = itoeax(i, num_basic, num_hyp, num_ext);
+		u32 eax = itoeax(i, num_basic, num_hyp, num_ext);
 		if(!cpuid(eax, 0, info)){
 			continue;
 		}
@@ -1638,15 +1638,15 @@ archreset(void)
 /*
  *  return value and speed of timer
  */
-uint64_t
-fastticks(uint64_t *hz)
+u64
+fastticks(u64 *hz)
 {
 	if(hz != nil)
 		*hz = machp()->cpuhz;
 	return rdtsc();
 }
 
-uint32_t
+u32
 ms(void)
 {
 	return fastticks2us(rdtsc());
@@ -1656,15 +1656,15 @@ ms(void)
  *  set next timer interrupt
  */
 void
-timerset(uint64_t x)
+timerset(u64 x)
 {
-	extern void apictimerset(uint64_t);
+	extern void apictimerset(u64);
 
 	apictimerset(x);
 }
 
 void
-cycles(uint64_t *t)
+cycles(u64 *t)
 {
 	*t = rdtsc();
 }
@@ -1672,7 +1672,7 @@ cycles(uint64_t *t)
 void
 delay(int millisecs)
 {
-	uint64_t r, t;
+	u64 r, t;
 
 	if(millisecs <= 0)
 		millisecs = 1;
@@ -1685,10 +1685,10 @@ delay(int millisecs)
  *  performance measurement ticks.  must be low overhead.
  *  doesn't have to count over a second.
  */
-uint64_t
+u64
 perfticks(void)
 {
-	uint64_t x;
+	u64 x;
 
 	//	if(m->havetsc)
 	cycles(&x);

sys/src/9/amd64/deviig.c

@@ -106,11 +106,11 @@ iigclose(Chan *c)
 {
 }
 
-static int32_t
-iigread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+iigread(Chan *c, void *a, i32 n, i64 off)
 {
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 
 	case Qdir:
 		return devdirread(c, a, n, iigdir, nelem(iigdir), devgen);
@@ -146,12 +146,12 @@ iigctl(Cmdbuf *cb)
 	cmderror(cb, "bad IIG control message");
 }
 
-static int32_t
-iigwrite(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+iigwrite(Chan *c, void *a, i32 n, i64 off)
 {
 	Proc *up = externup();
 	Cmdbuf *cb;
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 	case Qdir:
 		error(Eperm);
 

sys/src/9/amd64/devpmc.c

@@ -32,9 +32,9 @@ enum {
 	PmcCtlRdStr = 4 * 1024,
 };
 
-#define PMCTYPE(x) (((uintptr_t)x) & 0xffful)
-#define PMCID(x) (((uintptr_t)x) >> 12)
-#define PMCQID(i, t) ((((uintptr_t)i) << 12) | (t))
+#define PMCTYPE(x) (((uintptr)x) & 0xffful)
+#define PMCID(x) (((uintptr)x) >> 12)
+#define PMCQID(i, t) ((((uintptr)i) << 12) | (t))
 
 Dirtab *pmctab;
 static int npmctab;
@@ -190,8 +190,8 @@ pmcwalk(Chan *c, Chan *nc, char **name, int nname)
 	return devwalk(c, nc, name, nname, nil, 0, pmcgen);
 }
 
-static int32_t
-pmcstat(Chan *c, uint8_t *dp, int32_t n)
+static i32
+pmcstat(Chan *c, u8 *dp, i32 n)
 {
 	return devstat(c, dp, n, nil, 0, pmcgen);
 }
@@ -209,15 +209,15 @@ pmcclose(Chan *c)
 {
 }
 
-static int32_t
-pmcread(Chan *c, void *a, int32_t n, int64_t offset)
+static i32
+pmcread(Chan *c, void *a, i32 n, i64 offset)
 {
 	Proc *up = externup();
-	uint32_t type, id;
+	u32 type, id;
 	PmcCtl p;
 	char *s;
-	uint64_t v;
-	uint64_t coreno;
+	u64 v;
+	u64 coreno;
 
 	type = PMCTYPE(c->qid.path);
 	id = PMCID(c->qid.path);
@@ -234,7 +234,7 @@ pmcread(Chan *c, void *a, int32_t n, int64_t offset)
 		free(s);
 		nexterror();
 	}
-	coreno = (uint64_t)c->aux;
+	coreno = (u64)c->aux;
 	p._coreno = coreno;
 	switch(type){
 	case Qdata:
@@ -296,7 +296,7 @@ typedef struct AcCtrArg AcCtrArg;
 struct AcCtrArg {
 	int regno;
 	int coreno;
-	uint64_t v;
+	u64 v;
 };
 
 void
@@ -327,17 +327,17 @@ acpmcsetctr(void)
 	return;
 }
 
-static int32_t
-pmcwrite(Chan *c, void *a, int32_t n, int64_t mm)
+static i32
+pmcwrite(Chan *c, void *a, i32 n, i64 mm)
 {
 	Proc *up = externup();
 	Cmdbuf *cb;
 	Cmdtab *ct;
-	uint32_t type;
+	u32 type;
 	char str[64]; /* 0x0000000000000000\0 */
 	AcPmcArg p;
 	AcCtrArg ctr;
-	uint64_t coreno;
+	u64 coreno;
 	Mach *mp;
 
 	if(c->qid.type == QTDIR)
@@ -348,7 +348,7 @@ pmcwrite(Chan *c, void *a, int32_t n, int64_t mm)
 		error(Ebadctl);
 
 	pmcnull(&p.PmcCtl);
-	coreno = (uint64_t)c->aux;
+	coreno = (u64)c->aux;
 	p.coreno = coreno;
 	type = PMCTYPE(c->qid.path);
 	p.regno = PMCID(c->qid.path);

sys/src/9/amd64/devusb.c

@@ -810,13 +810,13 @@ usbstat(Chan *c, unsigned char *db, int n)
  * Only when we are sure we
  * are not exceeding b/w might we consider adjusting it.
  */
-static uint32_t
+static u32
 usbload(int speed, int maxpkt)
 {
 	enum { Hostns = 1000,
 	       Hubns = 333 };
-	uint32_t l;
-	uint32_t bs;
+	u32 l;
+	u32 bs;
 
 	l = 0;
 	bs = 10UL * maxpkt;
@@ -941,8 +941,8 @@ usbclose(Chan *c)
 	putep(ep);
 }
 
-static int32_t
-ctlread(Chan *c, void *a, int32_t n, int64_t offset)
+static i32
+ctlread(Chan *c, void *a, i32 n, i64 offset)
 {
 	Proc *up = externup();
 	int q;
@@ -1002,8 +1002,8 @@ ctlread(Chan *c, void *a, int32_t n, int64_t offset)
 /*
  * Fake root hub emulation.
  */
-static int32_t
-rhubread(Ep *ep, void *a, int32_t n)
+static i32
+rhubread(Ep *ep, void *a, i32 n)
 {
 	char *b;
 
@@ -1019,8 +1019,8 @@ rhubread(Ep *ep, void *a, int32_t n)
 	return n;
 }
 
-static int32_t
-rhubwrite(Ep *ep, void *a, int32_t n)
+static i32
+rhubwrite(Ep *ep, void *a, i32 n)
 {
 	unsigned char *s;
 	int cmd;
@@ -1058,8 +1058,8 @@ rhubwrite(Ep *ep, void *a, int32_t n)
 	return n;
 }
 
-static int32_t
-usbread(Chan *c, void *a, int32_t n, int64_t offset)
+static i32
+usbread(Chan *c, void *a, i32 n, i64 offset)
 {
 	Proc *up = externup();
 	int q;
@@ -1105,7 +1105,7 @@ usbread(Chan *c, void *a, int32_t n, int64_t offset)
 	return n;
 }
 
-static int32_t
+static i32
 pow2(int n)
 {
 	return 1 << n;
@@ -1114,7 +1114,7 @@ pow2(int n)
 static void
 setmaxpkt(Ep *ep, char *s)
 {
-	int32_t spp; /* samples per packet */
+	i32 spp; /* samples per packet */
 
 	if(ep->dev->speed == Highspeed)
 		spp = (ep->hz * ep->pollival * ep->ntds + 7999) / 8000;
@@ -1137,8 +1137,8 @@ setmaxpkt(Ep *ep, char *s)
  * of the endpoint. The actual controller driver will look
  * at them to setup the endpoints as dictated.
  */
-static int32_t
-epctl(Ep *ep, Chan *c, void *a, int32_t n)
+static i32
+epctl(Ep *ep, Chan *c, void *a, i32 n)
 {
 	Proc *up = externup();
 	int i, l, mode, nb, tt;
@@ -1350,8 +1350,8 @@ epctl(Ep *ep, Chan *c, void *a, int32_t n)
 	return n;
 }
 
-static int32_t
-usbctl(void *a, int32_t n)
+static i32
+usbctl(void *a, i32 n)
 {
 	Proc *up = externup();
 	Cmdtab *ct;
@@ -1390,8 +1390,8 @@ usbctl(void *a, int32_t n)
 	return n;
 }
 
-static int32_t
-ctlwrite(Chan *c, void *a, int32_t n)
+static i32
+ctlwrite(Chan *c, void *a, i32 n)
 {
 	Proc *up = externup();
 	int q;
@@ -1422,8 +1422,8 @@ ctlwrite(Chan *c, void *a, int32_t n)
 	return n;
 }
 
-static int32_t
-usbwrite(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+usbwrite(Chan *c, void *a, i32 n, i64 off)
 {
 	Proc *up = externup();
 	int nr, q;

sys/src/9/amd64/devvga.c

@@ -75,7 +75,7 @@ static Cmdtab vgactlmsg[] = {
 };
 
 static long
-rmemrw(int isr, void *a, long n, int64_t off)
+rmemrw(int isr, void *a, long n, i64 off)
 {
 	if(off < 0 || n < 0)
 		error("bad offset/count");
@@ -84,7 +84,7 @@ rmemrw(int isr, void *a, long n, int64_t off)
 			return 0;
 		if(off + n >= MB)
 			n = MB - off;
-		memmove(a, KADDR((uintptr_t)off), n);
+		memmove(a, KADDR((uintptr)off), n);
 	} else {
 		/* realmode buf page ok, allow vga framebuf's access */
 		if(off >= MB)
@@ -99,19 +99,19 @@ rmemrw(int isr, void *a, long n, int64_t off)
 			error("off < 0xa0000");
 		if(off + n > 0xB0000 + 0x10000)
 			error("off+n > 0xb0000+0x10000");
-		memmove(KADDR((uintptr_t)off), a, n);
+		memmove(KADDR((uintptr)off), a, n);
 	}
 	return n;
 }
 
-static int32_t
-rmemread(Chan *_, void *a, int32_t n, int64_t off)
+static i32
+rmemread(Chan *_, void *a, i32 n, i64 off)
 {
 	return rmemrw(1, a, n, off);
 }
 
-static int32_t
-rmemwrite(Chan *_, void *a, int32_t n, int64_t off)
+static i32
+rmemwrite(Chan *_, void *a, i32 n, i64 off)
 {
 	return rmemrw(0, a, n, off);
 }
@@ -154,7 +154,7 @@ vgaopen(Chan *c, int omode)
 	static char *openctl = "openctl\n";
 
 	scr = &vgascreen[0];
-	if((uint32_t)c->qid.path == Qvgaovlctl){
+	if((u32)c->qid.path == Qvgaovlctl){
 		if(scr->dev && scr->dev->ovlctl)
 			scr->dev->ovlctl(scr, c, openctl, strlen(openctl));
 		else
@@ -171,7 +171,7 @@ vgaclose(Chan *c)
 	static char *closectl = "closectl\n";
 
 	scr = &vgascreen[0];
-	if((uint32_t)c->qid.path == Qvgaovlctl)
+	if((u32)c->qid.path == Qvgaovlctl)
 		if(scr->dev && scr->dev->ovlctl){
 			if(waserror()){
 				print("ovlctl error: %s\n", up->errstr);
@@ -182,17 +182,17 @@ vgaclose(Chan *c)
 		}
 }
 
-static int32_t
-vgaread(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+vgaread(Chan *c, void *a, i32 n, i64 off)
 {
 	Proc *up = externup();
 	int len;
 	char *p, *s;
 	VGAscr *scr;
-	uint32_t offset = off;
+	u32 offset = off;
 	char chbuf[30];
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 
 	case Qdir:
 		return devdirread(c, a, n, vgadir, nelem(vgadir), devgen);
@@ -463,15 +463,15 @@ vgactl(Cmdbuf *cb)
 
 char Enooverlay[] = "No overlay support";
 
-static int32_t
-vgawrite(Chan *c, void *a, int32_t n, int64_t off)
+static i32
+vgawrite(Chan *c, void *a, i32 n, i64 off)
 {
 	Proc *up = externup();
-	uint32_t offset = off;
+	u32 offset = off;
 	Cmdbuf *cb;
 	VGAscr *scr;
 
-	switch((uint32_t)c->qid.path){
+	switch((u32)c->qid.path){
 
 	case Qdir:
 		error(Eperm);

sys/src/9/amd64/ether8139.c

@@ -198,7 +198,7 @@ typedef struct Ctlr {
 
 	int pcie; /* flag: pci-express device? */
 
-	uint64_t mchash; /* multicast hash */
+	u64 mchash; /* multicast hash */
 
 	int rcr;		/* receive configuration register */
 	unsigned char *rbstart; /* receive buffer */
@@ -254,11 +254,11 @@ enum {
 	Bytemask = (1 << 8) - 1,
 };
 
-static uint32_t
-ethercrcbe(unsigned char *addr, int32_t len)
+static u32
+ethercrcbe(unsigned char *addr, i32 len)
 {
 	int i, j;
-	uint64_t c, crc, carry;
+	u64 c, crc, carry;
 
 	crc = ~0UL;
 	for(i = 0; i < len; i++){
@@ -274,8 +274,8 @@ ethercrcbe(unsigned char *addr, int32_t len)
 	return crc;
 }
 
-static uint32_t
-swabl(uint32_t l)
+static u32
+swabl(u32 l)
 {
 	return (l >> 24) | ((l >> 8) & (Bytemask << 8)) |
 	       ((l << 8) & (Bytemask << 16)) | (l << 24);
@@ -311,8 +311,8 @@ rtl8139multicast(void *ether, unsigned char *eaddr, int add)
 	iunlock(&ctlr->ilock);
 }
 
-static int32_t
-rtl8139ifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
+static i32
+rtl8139ifstat(Ether *edev, void *a, i32 n, u32 offset)
 {
 	int l;
 	char *p;
@@ -412,7 +412,7 @@ static void
 rtl8139init(Ether *edev)
 {
 	int i;
-	uint32_t r;
+	u32 r;
 	Ctlr *ctlr;
 	unsigned char *alloc;
 
@@ -432,7 +432,7 @@ rtl8139init(Ether *edev)
 	/*
 	 * Receiver
 	 */
-	alloc = (unsigned char *)ROUNDUP((uint64_t)ctlr->alloc, 32);
+	alloc = (unsigned char *)ROUNDUP((u64)ctlr->alloc, 32);
 	ctlr->rbstart = alloc;
 	alloc += ctlr->rblen + 16;
 	memset(ctlr->rbstart, 0, ctlr->rblen + 16);
@@ -516,7 +516,7 @@ rtl8139txstart(Ether *edev)
 		size = BLEN(bp);
 
 		td = &ctlr->td[ctlr->tdh];
-		if(((int64_t)bp->rp) & 0x03){
+		if(((i64)bp->rp) & 0x03){
 			memmove(td->data, bp->rp, size);
 			freeb(bp);
 			csr32w(ctlr, td->tsad, PADDR(td->data));
@@ -549,7 +549,7 @@ rtl8139receive(Ether *edev)
 {
 	Block *bp;
 	Ctlr *ctlr;
-	uint16_t capr;
+	u16 capr;
 	unsigned char cr, *p;
 	int l, length, status;
 
@@ -651,7 +651,7 @@ rtl8139interrupt(Ureg *ureg, void *arg)
 		if(ctlr->alloc == nil){
 			print("rtl8139interrupt: interrupt for unattached Ctlr "
 			      "%#p port %#p\n",
-			      ctlr, (void *)(int64_t)ctlr->port);
+			      ctlr, (void *)(i64)ctlr->port);
 			return; /* not attached yet (shouldn't happen) */
 		}
 		if(isr & (Fovw | PunLc | Rxovw | Rer | Rok)){

sys/src/9/amd64/ether82563.c

@@ -349,12 +349,12 @@ typedef struct Rd Rd;
 typedef struct Td Td;
 
 struct Rd { /* Receive Descriptor */
-	uint32_t addr[2];
-	uint16_t length;
-	uint16_t checksum;
-	uint8_t status;
-	uint8_t errors;
-	uint16_t special;
+	u32 addr[2];
+	u16 length;
+	u16 checksum;
+	u8 status;
+	u8 errors;
+	u16 special;
 };
 
 enum {		     /* Rd status */
@@ -378,9 +378,9 @@ enum {		    /* Rd errors */
 };
 
 struct Td {		  /* Transmit Descriptor */
-	uint32_t addr[2]; /* Data */
-	uint32_t control;
-	uint32_t status;
+	u32 addr[2]; /* Data */
+	u32 control;
+	u32 status;
 };
 
 enum {			     /* Tdesc control */
@@ -410,10 +410,10 @@ enum {			 /* Tdesc status */
 };
 
 typedef struct {
-	uint16_t *reg;
-	uint32_t *reg32;
-	uint16_t base;
-	uint16_t lim;
+	u16 *reg;
+	u32 *reg32;
+	u16 base;
+	u16 lim;
 } Flash;
 
 enum {
@@ -521,7 +521,7 @@ struct Ctlr {
 	Ether *edev;
 	int active;
 	int type;
-	uint16_t eeprom[0x40];
+	u16 eeprom[0x40];
 
 	QLock alock; /* attach */
 	int attached;
@@ -552,8 +552,8 @@ struct Ctlr {
 	uint tcpcs;
 	uint speeds[4];
 
-	uint8_t ra[Eaddrlen]; /* receive address */
-	uint32_t mta[128];    /* multicast table array */
+	u8 ra[Eaddrlen]; /* receive address */
+	u32 mta[128];    /* multicast table array */
 
 	Rendez rrendez;
 	int rim;
@@ -668,13 +668,13 @@ static char *statistics[] = {
 
 static int i82563reset(Ctlr *);
 
-static int32_t
-i82563ifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
+static i32
+i82563ifstat(Ether *edev, void *a, i32 n, u32 offset)
 {
 	Ctlr *ctlr;
 	char *s, *p, *e, *stat;
 	int i, r;
-	uint64_t tuvl, ruvl;
+	u64 tuvl, ruvl;
 
 	ctlr = edev->ctlr;
 	qlock(&ctlr->slock);
@@ -695,10 +695,10 @@ i82563ifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
 		case Torl:
 		case Totl:
 			ruvl = r;
-			ruvl += (uint64_t)csr32r(ctlr, Statistics + (i + 1) * 4) << 32;
+			ruvl += (u64)csr32r(ctlr, Statistics + (i + 1) * 4) << 32;
 			tuvl = ruvl;
 			tuvl += ctlr->statistics[i];
-			tuvl += (uint64_t)ctlr->statistics[i + 1] << 32;
+			tuvl += (u64)ctlr->statistics[i + 1] << 32;
 			if(tuvl == 0)
 				continue;
 			ctlr->statistics[i] = tuvl;
@@ -754,8 +754,8 @@ i82563ifstat(Ether *edev, void *a, int32_t n, uint32_t offset)
 	return n;
 }
 
-static int32_t
-i82563ctl(Ether *_1, void *_2, int32_t _3)
+static i32
+i82563ctl(Ether *_1, void *_2, i32 _3)
 {
 	error(Enonexist);
 	return 0;
@@ -803,7 +803,7 @@ mcasttblsize(Ctlr *ctlr)
 }
 
 static void
-i82563multicast(void *arg, uint8_t *addr, int on)
+i82563multicast(void *arg, u8 *addr, int on)
 {
 	int bit, x;
 	Ctlr *ctlr;
@@ -847,7 +847,7 @@ i82563rballoc(void)
 static void
 i82563rbfree(Block *b)
 {
-	b->rp = b->wp = (uint8_t *)PGROUND((uintptr)b->base);
+	b->rp = b->wp = (u8 *)PGROUND((uintptr)b->base);
 	b->flag &= ~(Bipck | Budpck | Btcpck | Bpktck);
 	ilock(&i82563rblock);
 	b->next = i82563rbpool;
@@ -892,8 +892,8 @@ i82563txinit(Ctlr *ctlr)
 		}
 	memset(ctlr->tdba, 0, Ntd * sizeof(Td));
 	coherence();
-	csr32w(ctlr, Tdbal, (uint32_t)PADDR(ctlr->tdba));
-	csr32w(ctlr, Tdbah, (uint32_t)(PADDR(ctlr->tdba) >> 32));
+	csr32w(ctlr, Tdbal, (u32)PADDR(ctlr->tdba));
+	csr32w(ctlr, Tdbah, (u32)(PADDR(ctlr->tdba) >> 32));
 	csr32w(ctlr, Tdlen, Ntd * sizeof(Td));
 	ctlr->tdh = PREV(0, Ntd);
 	csr32w(ctlr, Tdh, 0);
@@ -964,8 +964,8 @@ i82563transmit(Ether *edev)
 		if((bp = qget(edev->oq)) == nil)
 			break;
 		td = &ctlr->tdba[tdt];
-		td->addr[0] = (uint32_t)PADDR(bp->rp);
-		td->addr[1] = (uint32_t)(PADDR(bp->rp) >> 32);
+		td->addr[0] = (u32)PADDR(bp->rp);
+		td->addr[1] = (u32)(PADDR(bp->rp) >> 32);
 		td->control = Ide | Rs | Ifcs | Teop | BLEN(bp);
 		ctlr->tb[tdt] = bp;
 		/* note size of queue of tds awaiting transmission */
@@ -1005,8 +1005,8 @@ i82563replenish(Ctlr *ctlr)
 			panic("#l%d: 82563: all %d rx buffers in use, nrbfull %d",
 			      ctlr->edev->ctlrno, Nrb, nrbfull);
 		ctlr->rb[rdt] = bp;
-		rd->addr[0] = (uint32_t)PADDR(bp->rp);
-		rd->addr[1] = (uint32_t)(PADDR(bp->rp) >> 32);
+		rd->addr[0] = (u32)PADDR(bp->rp);
+		rd->addr[1] = (u32)(PADDR(bp->rp) >> 32);
 		rd->status = 0;
 		ctlr->rdfree++;
 		rdt = NEXT(rdt, Nrd);
@@ -1047,8 +1047,8 @@ i82563rxinit(Ctlr *ctlr)
 		break;
 	}
 
-	csr32w(ctlr, Rdbal, (uint32_t)PADDR(ctlr->rdba));
-	csr32w(ctlr, Rdbah, (uint32_t)(PADDR(ctlr->rdba) >> 32));
+	csr32w(ctlr, Rdbal, (u32)PADDR(ctlr->rdba));
+	csr32w(ctlr, Rdbah, (u32)(PADDR(ctlr->rdba) >> 32));
 	csr32w(ctlr, Rdlen, Nrd * sizeof(Rd));
 	ctlr->rdh = ctlr->rdt = 0;
 	csr32w(ctlr, Rdh, 0);
@@ -1239,7 +1239,7 @@ phyread(Ctlr *ctlr, int reg)
 }
 
 static uint
-phywrite(Ctlr *ctlr, int reg, uint16_t val)
+phywrite(Ctlr *ctlr, int reg, u16 val)
 {
 	uint phy, i;
 
@@ -1258,8 +1258,8 @@ phywrite(Ctlr *ctlr, int reg, uint16_t val)
 	return 0;
 }
 
-static uint32_t
-kmrnread(Ctlr *ctlr, uint32_t reg_addr)
+static u32
+kmrnread(Ctlr *ctlr, u32 reg_addr)
 {
 	csr32w(ctlr, Kumctrlsta, ((reg_addr << Kumctrlstaoffshift) & Kumctrlstaoff) | Kumctrlstaren); /* write register address */
 	microdelay(2);
@@ -1267,7 +1267,7 @@ kmrnread(Ctlr *ctlr, uint32_t reg_addr)
 }
 
 static void
-kmrnwrite(Ctlr *ctlr, uint32_t reg_addr, uint16_t data)
+kmrnwrite(Ctlr *ctlr, u32 reg_addr, u16 data)
 {
 	csr32w(ctlr, Kumctrlsta, ((reg_addr << Kumctrlstaoffshift) & Kumctrlstaoff) | data);
 	microdelay(2);
@@ -1300,8 +1300,8 @@ static void
 k1fix(Ctlr *ctlr)
 {
 	int txtmout; /* units of 10µs */
-	uint32_t fextnvm6, status;
-	uint16_t reg;
+	u32 fextnvm6, status;
+	u16 reg;
 	Ether *edev;
 
 	edev = ctlr->edev;
@@ -1606,7 +1606,7 @@ i82563detach0(Ctlr *ctlr)
 		break;
 	case i218:
 		// after pxe or 9fat boot, pba is always 0xe0012 on i218 => 32K
-		ctlr->pbs = (ctlr->pba >> 16) + (uint16_t)ctlr->pba;
+		ctlr->pbs = (ctlr->pba >> 16) + (u16)ctlr->pba;
 		csr32w(ctlr, Pbs, ctlr->pbs);
 		break;
 	}
@@ -1667,10 +1667,10 @@ i82563shutdown(Ether *ether)
 	i82563detach(ether->ctlr);
 }
 
-static uint16_t
+static u16
 eeread(Ctlr *ctlr, int adr)
 {
-	uint32_t n;
+	u32 n;
 
 	csr32w(ctlr, Eerd, EEstart | adr << 2);
 	for(n = 1000000; (csr32r(ctlr, Eerd) & EEdone) == 0 && n-- > 0;)
@@ -1684,7 +1684,7 @@ eeread(Ctlr *ctlr, int adr)
 static int
 eeload(Ctlr *ctlr)
 {
-	uint16_t sum;
+	u16 sum;
 	int data, adr;
 
 	sum = 0;
@@ -1699,7 +1699,7 @@ eeload(Ctlr *ctlr)
 static int
 fcycle(Ctlr *_, Flash *f)
 {
-	uint16_t s, i;
+	u16 s, i;
 
 	s = f->reg[Fsts];
 	if((s & Fvalid) == 0)
@@ -1717,8 +1717,8 @@ fcycle(Ctlr *_, Flash *f)
 static int
 fread(Ctlr *ctlr, Flash *f, int ladr)
 {
-	uint16_t s;
-	uint32_t n;
+	u16 s;
+	u32 n;
 
 	delay(1);
 	if(fcycle(ctlr, f) == -1)
@@ -1742,9 +1742,9 @@ fread(Ctlr *ctlr, Flash *f, int ladr)
 }
 
 static int
-fread32(Ctlr *c, Flash *f, int ladr, uint32_t *data)
+fread32(Ctlr *c, Flash *f, int ladr, u32 *data)
 {
-	uint32_t s;
+	u32 s;
 	int timeout;
 
 	delay(1);
@@ -1787,8 +1787,8 @@ done:
 static int
 fload16(Ctlr *ctlr)
 {
-	uint32_t data, io, r, adr;
-	uint16_t sum;
+	u32 data, io, r, adr;
+	u16 sum;
 	Flash f;
 
 	io = ctlr->pcidev->mem[1].bar & ~0x0f;
@@ -1822,17 +1822,17 @@ fload32(Ctlr *c)
 {
 	// nic points to the address pointed to by the first pci BAR
 	Flash f = {
-		.reg32 = (uint32_t *)&c->nic[0xe000 / 4],
+		.reg32 = (u32 *)&c->nic[0xe000 / 4],
 		.lim = (((csr32r(c, 0xC) >> 1) & 0x1F) + 1) << 12,
 	};
 
-	uint32_t w;
+	u32 w;
 	int r = f.lim >> 1;
 	if(fread32(c, &f, r + 0x24, &w) == -1 || (w & 0xC000) != 0x8000){
 		r = 0;
 	}
 
-	uint16_t sum = 0;
+	u16 sum = 0;
 	for(int adr = 0; adr < 0x20; adr++){
 		if(fread32(c, &f, r + adr * 4, &w) == -1){
 			return -1;
@@ -1849,7 +1849,7 @@ static int
 invmload(Ctlr *c)
 {
 	int i, a;
-	uint32_t w;
+	u32 w;
 
 	memset(c->eeprom, 0xFF, sizeof(c->eeprom));
 	for(i = 0; i < 64; i++){
@@ -1980,7 +1980,7 @@ static void
 i82563pci(void)
 {
 	int type;
-	uint32_t io;
+	u32 io;
 	void *mem;
 	Pcidev *p;
 	Ctlr *ctlr;

sys/src/9/amd64/etherif.h

@@ -18,14 +18,14 @@ struct Ether {
 
 	int ctlrno;
 	int tbdf; /* type+busno+devno+funcno */
-	uint8_t ea[Eaddrlen];
+	u8 ea[Eaddrlen];
 
 	void (*attach)(Ether *); /* filled in by reset routine */
 	void (*detach)(Ether *);
 	void (*transmit)(Ether *);
 	void (*interrupt)(Ureg *, void *);
-	int32_t (*ifstat)(Ether *, void *, int32_t, uint32_t);
-	int32_t (*ctl)(Ether *, void *, int32_t); /* custom ctl messages */
+	i32 (*ifstat)(Ether *, void *, i32, u32);
+	i32 (*ctl)(Ether *, void *, i32); /* custom ctl messages */
 	void (*power)(Ether *, int);		  /* power on/off */
 	void (*shutdown)(Ether *);		  /* shutdown hardware before reboot */
 	void *ctlr;
@@ -37,7 +37,7 @@ struct Ether {
 
 extern Block *etheriq(Ether *, Block *, int);
 extern void addethercard(char *, int (*)(Ether *));
-extern uint32_t ethercrc(unsigned char *, int);
+extern u32 ethercrc(unsigned char *, int);
 extern int parseether(unsigned char *, char *);
 
 #define NEXT(x, l) (((x) + 1) % (l))

sys/src/9/amd64/fns.h

@@ -14,7 +14,7 @@ int acpiinit(void);
 void acpistart(void);
 int mpacpi(int);
 void actrapenable(int, char *(*)(Ureg *, void *), void *, char *);
-int aoutldseg(void *v, uintptr_t *entryp, Ldseg **rp, char *mach, uint32_t minpgsz);
+int aoutldseg(void *v, uintptr *entryp, Ldseg **rp, char *mach, u32 minpgsz);
 void apicipi(int);
 void apicpri(int);
 void acsysret(void);
@@ -32,27 +32,27 @@ int archmmu(void);
 void noerrorsleft(void);
 void archinit(void);
 void archreset(void);
-int64_t archhz(void);
+i64 archhz(void);
 int cgaprint(int off, char *fmt, ...);
 int cgaclearln(int off, int c);
 void cgaconsputs(char *, int);
 void cgainit(void);
 void cgapost(int);
-void checkpa(char *, uintmem);
+void checkpa(char *, u64);
 #define clearmmucache() /* x86 doesn't have one */
 void (*coherence)(void);
 int corecolor(int);
-uint32_t cpuid(uint32_t, uint32_t, uint32_t[4]);
-int cpuidinfo(uint32_t, uint32_t, uint32_t[4]);
-char *cpuidname(uint32_t *);
+u32 cpuid(u32, u32, u32[4]);
+int cpuidinfo(u32, u32, u32[4]);
+char *cpuidname(u32 *);
 int dbgprint(char *, ...);
 int decref(Ref *);
 void delay(int);
 void dumpmmu(Proc *);
-void dumpmmuwalk(const PTE *pml4, uint64_t pa);
-void dumpptepg(int lvl, uintptr_t pa);
+void dumpmmuwalk(const PTE *pml4, u64 pa);
+void dumpptepg(int lvl, uintptr pa);
 #define evenaddr(x) /* x86 doesn't care */
-int fpudevprocio(Proc *, void *, int32_t, uintptr_t, int);
+int fpudevprocio(Proc *, void *, i32, uintptr, int);
 void fpuinit(void);
 void fpunoted(void);
 void fpunotify(Ureg *);
@@ -63,7 +63,7 @@ void fpusysrfork(Ureg *);
 void fpusysrforkchild(Proc *, Proc *);
 Mach *getac(Proc *, int);
 char *getconf(char *);
-void gdb2ureg(uintptr_t *g, Ureg *u);
+void gdb2ureg(uintptr *g, Ureg *u);
 void halt(void);
 void hardhalt(void);
 void mouseenable(void);
@@ -73,20 +73,20 @@ void mouseenable(void);
 void i8250console(char *);
 void i8250uartconsole(Uart *, char *);
 void *i8250alloc(int, int, int);
-int64_t i8254hz(uint32_t *info0, uint32_t *info1);
+i64 i8254hz(u32 *info0, u32 *info1);
 void idlehands(void);
 void acidthandlers(void);
 void idthandlers(void);
 int inb(int);
 int incref(Ref *);
 void insb(int, void *, int);
-uint16_t ins(int);
+u16 ins(int);
 void inss(int, void *, int);
-uint32_t inl(int);
+u32 inl(int);
 void insl(int, void *, int);
 int intrdisable(void *);
 void *intrenable(int, void (*)(Ureg *, void *), void *, int, char *);
-void invlpg(uintptr_t);
+void invlpg(uintptr);
 void iofree(int);
 void ioinit(void);
 int iounused(int, int);
@@ -102,27 +102,27 @@ void lfence(void);
 void links(void);
 void machinit(void);
 void mach0init(void);
-void mapraminit(uint64_t, uint64_t);
-void mapupainit(uint64_t, uint32_t);
+void mapraminit(u64, u64);
+void mapupainit(u64, u32);
 void meminit(void);
 void mfence(void);
 void mmuflushtlb(void);
 void mmukflushtlb(void);
 void mmuinit(void);
-void mmukphysmap(PTE *pml4, uintmem, PTE, usize);
-int mmukmapsync(uint64_t);
-uintmem mmuphysaddr(const PTE *pml4, uintptr_t);
-int mmuwalk(const PTE *pml4, uintptr_t, int, const PTE **);
-int multiboot(uint32_t, uint32_t, int);
+void mmukphysmap(PTE *pml4, u64, PTE, usize);
+int mmukmapsync(u64);
+u64 mmuphysaddr(const PTE *pml4, uintptr);
+int mmuwalk(const PTE *pml4, uintptr, int, const PTE **);
+int multiboot(u32, u32, int);
 void ndnr(void);
 unsigned char nvramread(int);
 void nvramwrite(int, unsigned char);
 void optionsinit(char *);
 void outb(int, int);
 void outsb(int, void *, int);
-void outs(int, uint16_t);
+void outs(int, u16);
 void outss(int, void *, int);
-void outl(int, uint32_t);
+void outl(int, u32);
 void outsl(int, void *, int);
 int pcicap(Pcidev *, int);
 int pcicfgr8(Pcidev *, int);
@@ -145,54 +145,54 @@ void pcishowdev(Pcidev *);
 int pickcore(int, int);
 void pamapdump(void);
 void pamapinit(void);
-void pamapinsert(uintmem, usize, int);
+void pamapinsert(u64, usize, int);
 void pamapmerge(void);
 void printcpufreq(void);
 void putac(Mach *);
-void *rsdsearch(void *start, uintptr_t size);
+void *rsdsearch(void *start, uintptr size);
 void runapcore(int);
 int screenprint(char *, ...); /* debugging */
 void sfence(void);
 void spldone(void);
-uint64_t splhi(void);
-uint64_t spllo(void);
-void splx(uint64_t);
-void splxpc(uint64_t);
+u64 splhi(void);
+u64 spllo(void);
+void splx(u64);
+void splxpc(u64);
 void kstackok(void);	      /* panic if kstack guards garbaged, works with and without externup */
 Stackframe *stackframe(void); /* l64v.S */
 void stacksnippet(void);
 void stopac(void);
 void syncclock(void);
 void syscall(unsigned int scallnr, Ureg *ureg);
-void *sysexecregs(uintptr_t, uint32_t, void *);
-uintptr_t sysexecstack(uintptr_t, int);
+void *sysexecregs(uintptr, u32, void *);
+uintptr sysexecstack(uintptr, int);
 void sysprocsetup(Proc *);
-void tssrsp0(Mach *, uint64_t);
+void tssrsp0(Mach *, u64);
 void trapenable(int, void (*)(Ureg *, void *), void *, char *);
 void trapinit(void);
 void trap(Ureg *);
 void umeminit(void);
-void ureg2gdb(Ureg *u, uintptr_t *g);
+void ureg2gdb(Ureg *u, uintptr *g);
 int userureg(Ureg *);
-void *vmap(uintptr_t, usize);
+void *vmap(uintptr, usize);
 void vsvminit(int, int, Mach *);
 void vunmap(void *, usize);
 
-extern uint64_t cr0get(void);
-extern void cr0put(uint64_t);
-extern uint64_t cr2get(void);
-extern uint64_t cr3get(void);
-extern uintmem pml4get(void);
-extern void cr3put(uint64_t);
-extern uint64_t cr4get(void);
-extern void cr4put(uint64_t);
+extern u64 cr0get(void);
+extern void cr0put(u64);
+extern u64 cr2get(void);
+extern u64 cr3get(void);
+extern u64 pml4get(void);
+extern void cr3put(u64);
+extern u64 cr4get(void);
+extern void cr4put(u64);
 extern void gdtget(void *);
-extern void gdtput(int, uint64_t, uint16_t);
-extern void idtput(int, uint64_t);
-extern uint64_t rdmsr(uint32_t);
-extern uint64_t rdtsc(void);
-extern void trput(uint64_t);
-extern void wrmsr(uint32_t, uint64_t);
+extern void gdtput(int, u64, u16);
+extern void idtput(int, u64);
+extern u64 rdmsr(u32);
+extern u64 rdtsc(void);
+extern void trput(u64);
+extern void wrmsr(u32, u64);
 
 // TODO(aki): once we figure this out, these will go.
 extern int infected_with_std(void);
@@ -204,19 +204,19 @@ extern Mpl splhi(void);
 extern Mpl spllo(void);
 extern void splx(Mpl);
 
-int cas32(void *, uint32_t, uint32_t);
-int cas64(void *, uint64_t, uint64_t);
+int cas32(void *, u32, u32);
+int cas64(void *, u64, u64);
 int tas32(void *);
-uint64_t fas64(uint64_t *, uint64_t);
+u64 fas64(u64 *, u64);
 
-#define CASU(p, e, n) cas64((p), (uint64_t)(e), (uint64_t)(n))
-#define CASV(p, e, n) cas64((p), (uint64_t)(e), (uint64_t)(n))
-#define CASP(p, e, n) cas64((p), (uint64_t)(e), (uint64_t)(n))
+#define CASU(p, e, n) cas64((p), (u64)(e), (u64)(n))
+#define CASV(p, e, n) cas64((p), (u64)(e), (u64)(n))
+#define CASP(p, e, n) cas64((p), (u64)(e), (u64)(n))
 #define CASW(p, e, n) cas32((p), (e), (n))
 #define TAS(addr) tas32((addr))
-#define FASP(p, v) ((void *)fas64((uint64_t *)(p), (uint64_t)(v)))
+#define FASP(p, v) ((void *)fas64((u64 *)(p), (u64)(v)))
 
-void touser(uintptr_t);
+void touser(uintptr);
 void syscallentry(void);
 void acsyscallentry(void);
 void syscallreturn(void);
@@ -227,11 +227,11 @@ void sysrforkret(void);
 
 #define dcflush(a, b)
 
-#define PTR2UINT(p) ((uintptr_t)(p))
+#define PTR2UINT(p) ((uintptr)(p))
 #define UINT2PTR(i) ((void *)(i))
 
-void *KADDR(uintptr_t);
-uintmem PADDR(void *);
+void *KADDR(uintptr);
+u64 PADDR(void *);
 
 #define BIOSSEG(a) KADDR(((uint)(a)) << 4)
 
@@ -240,14 +240,14 @@ uintmem PADDR(void *);
  */
 extern int apiceoi(int);
 extern void apicipi(int);
-extern void apicinit(int, uintmem, int);
+extern void apicinit(int, u64, int);
 extern int apicisr(int);
 extern int apiconline(void);
 extern void apicpri(int);
-extern void apicsipi(int, uintmem);
+extern void apicsipi(int, u64);
 extern void apicnmi(int, int, int);
 
-extern void ioapicinit(int, int, uintmem);
+extern void ioapicinit(int, int, u64);
 extern void ioapiconline(void);
 
 /*
@@ -268,7 +268,7 @@ extern int i8259isr(int);
  * mp.c
  */
 extern int mpsinit(int);
-void *sigscan(uint8_t *address, int length, char *signature);
+void *sigscan(u8 *address, int length, char *signature);
 
 /*
  * sipi.c
@@ -283,7 +283,7 @@ void DONE(void);
 
 /* all these go to 0x3f8 */
 void hi(char *s);
-void hihex(uint64_t x);
+void hihex(u64 x);
 
 Mach *machp(void);
 static inline Proc *
@@ -309,7 +309,7 @@ void die(char *);
 void dumpgpr(Ureg *ureg);
 
 /* debug support. */
-int backtrace_list(uintptr_t pc, uintptr_t fp, uintptr_t *pcs, size_t nr_slots);
+int backtrace_list(uintptr pc, uintptr fp, uintptr *pcs, usize nr_slots);
 
 /* horror */
 static inline void

sys/src/9/amd64/fpu.c

@@ -84,7 +84,7 @@ fpurestore(Fxsave *fxsave)
 }
 
 int
-fpudevprocio(Proc *proc, void *a, int32_t n, uintptr_t offset, int write)
+fpudevprocio(Proc *proc, void *a, i32 n, uintptr offset, int write)
 {
 	/*
 	 * Called from procdevtab.read and procdevtab.write
@@ -96,7 +96,7 @@ fpudevprocio(Proc *proc, void *a, int32_t n, uintptr_t offset, int write)
 	if(offset >= sizeof(Fxsave))
 		return 0;
 
-	uint8_t *p = (uint8_t *)&proc->FPU.fxsave;
+	u8 *p = (u8 *)&proc->FPU.fxsave;
 
 	switch(write){
 	default:
@@ -201,7 +201,7 @@ static char *
 xfpuxm(Ureg *ureg, void *v)
 {
 	Proc *up = externup();
-	uint32_t mxcsr;
+	u32 mxcsr;
 	char *cm;
 
 	// #XM - SIMD Floating Point Exception (Vector 19).
@@ -253,12 +253,12 @@ void
 fpuinit(void)
 {
 	// It's assumed there is an integrated FPU, so Em is cleared;
-	uint64_t cr0 = cr0get();
+	u64 cr0 = cr0get();
 	cr0 &= ~Em;
 	cr0 |= Ne | Mp;
 	cr0put(cr0);
 
-	uint64_t cr4 = cr4get();
+	u64 cr4 = cr4get();
 	cr4 |= Osxmmexcpt | Osfxsr;
 	cr4put(cr4);
 

sys/src/9/amd64/i8254.c

@@ -87,12 +87,12 @@ i8254set(int port, int hz)
 	}
 }
 
-int64_t
-i8254hz(uint32_t *info0, uint32_t *info1)
+i64
+i8254hz(u32 *info0, u32 *info1)
 {
-	uint32_t ax;
-	uint64_t a, b;
-	int64_t aamcycles, incr, loops, x, y;
+	u32 ax;
+	u64 a, b;
+	i64 aamcycles, incr, loops, x, y;
 
 	/*
 	 * Use the cpuid family info to get the

sys/src/9/amd64/io.h

@@ -313,12 +313,12 @@ typedef struct Pcicap Pcicap;
 struct Pcicap {
 	struct Pcidev *dev; /* link to the device structure */
 	Pcicap *link;	    /* next capability or NULL */
-	uint8_t vndr;	    /* vendor code */
-	uint8_t caplen;	    /* length in the config area */
-	uint8_t type;	    /* capability config type */
-	uint8_t bar;	    /* BAR index in the device structure 0 - 5 */
-	uint32_t offset;    /* offset within BAR */
-	uint32_t length;    /* length in the memory or IO space */
+	u8 vndr;	    /* vendor code */
+	u8 caplen;	    /* length in the config area */
+	u8 type;	    /* capability config type */
+	u8 bar;	    /* BAR index in the device structure 0 - 5 */
+	u32 offset;    /* offset within BAR */
+	u32 length;    /* length in the memory or IO space */
 };
 
 /* Linked list of capabilities is added to the PCI device descriptor
@@ -331,10 +331,10 @@ typedef struct Pcidev Pcidev;
 struct Pcidev {
 	int tbdf; /* type+bus+device+function */
 	char *path;
-	uint16_t vid; /* vendor ID */
-	uint16_t did; /* device ID */
+	u16 vid; /* vendor ID */
+	u16 did; /* device ID */
 
-	uint16_t pcr;
+	u16 pcr;
 
 	unsigned char rid;
 	unsigned char ccrp;
@@ -344,12 +344,12 @@ struct Pcidev {
 	unsigned char ltr;
 
 	struct {
-		uint32_t bar; /* base address */
+		u32 bar; /* base address */
 		int size;
 	} mem[6];
 
 	struct {
-		uint32_t bar;
+		u32 bar;
 		int size;
 	} rom;
 	unsigned char intl; /* interrupt line */
@@ -360,10 +360,10 @@ struct Pcidev {
 
 	Pcidev *bridge; /* down a bus */
 	struct {
-		uint32_t bar;
+		u32 bar;
 		int size;
 	} ioa, mema;
 	Pcicap *caplist;
-	uint32_t capcnt;
+	u32 capcnt;
 	Pcicap **capidx;
 };

sys/src/9/amd64/ioapic.c

@@ -40,8 +40,8 @@ struct Rbus {
 struct Rdt {
 	Apic *apic;
 	int intin;
-	uint32_t lo;
-	uint32_t hi;
+	u32 lo;
+	u32 hi;
 
 	int ref;     /* could map to multiple busses */
 	int enabled; /* times enabled */
@@ -80,7 +80,7 @@ static int map_edge_level[4] = {
 /* TODO: use the slice library for this. */
 typedef struct {
 	Vctl v;
-	uint32_t lo;
+	u32 lo;
 	int valid;
 } Vinfo;
 static Vinfo todo[1 << 13];
@@ -105,25 +105,25 @@ readtodo(void)
 	return todostring;
 }
 
-static uint32_t
+static u32
 ioapicread(Apic *apic, int reg)
 {
-	volatile uint32_t *sel = apic->Ioapic.addr + Ioregsel;
-	volatile uint32_t *data = apic->Ioapic.addr + Iowin;
+	volatile u32 *sel = apic->Ioapic.addr + Ioregsel;
+	volatile u32 *data = apic->Ioapic.addr + Iowin;
 	*sel = reg;
 	return *data;
 }
 static void
-ioapicwrite(Apic *apic, int reg, uint32_t val)
+ioapicwrite(Apic *apic, int reg, u32 val)
 {
-	volatile uint32_t *sel = apic->Ioapic.addr + Ioregsel;
-	volatile uint32_t *data = apic->Ioapic.addr + Iowin;
+	volatile u32 *sel = apic->Ioapic.addr + Ioregsel;
+	volatile u32 *data = apic->Ioapic.addr + Iowin;
 	*sel = reg;
 	*data = val;
 }
 
 static void
-rtblget(Apic *apic, int sel, uint32_t *hi, uint32_t *lo)
+rtblget(Apic *apic, int sel, u32 *hi, u32 *lo)
 {
 	sel = Ioredtbl + 2 * sel;
 
@@ -132,7 +132,7 @@ rtblget(Apic *apic, int sel, uint32_t *hi, uint32_t *lo)
 }
 
 static void
-rtblput(Apic *apic, int sel, uint32_t hi, uint32_t lo)
+rtblput(Apic *apic, int sel, u32 hi, u32 lo)
 {
 	sel = Ioredtbl + 2 * sel;
 
@@ -155,11 +155,11 @@ rdtlookup(Apic *apic, int intin)
 }
 
 static int
-compatible(uint32_t new, uint32_t old)
+compatible(u32 new, u32 old)
 {
-	uint32_t newtop = new & ~0xff;
-	uint32_t oldtop = old & ~0xff;
-	uint32_t newvno = new & 0xff;
+	u32 newtop = new & ~0xff;
+	u32 oldtop = old & ~0xff;
+	u32 newvno = new & 0xff;
 	print("compatible: new 0x%x, old 0x%x\n", new, old);
 	if(new == old)
 		return 1;
@@ -172,7 +172,7 @@ compatible(uint32_t new, uint32_t old)
 }
 
 static void
-ioapicintrinit(int busno, int apicno, int intin, int devno, int fno, uint32_t lo)
+ioapicintrinit(int busno, int apicno, int intin, int devno, int fno, u32 lo)
 {
 	Rbus *rbus;
 	Rdt *rdt;
@@ -269,7 +269,7 @@ acpi_make_rdt(Vctl *v, int irq, int bustype, int busno, int devno, int fno)
 {
 	Atable *at;
 	Apicst *st, *lst;
-	uint32_t lo = 0;
+	u32 lo = 0;
 	int pol, edge_level, ioapic_nr, gsi_irq;
 	//print("acpi_make_rdt(0x%x %d %d 0x%x)\n", tbdf, irq, busno, devno);
 	//die("acpi.make.rdt)\n");
@@ -325,7 +325,7 @@ acpi_make_rdt(Vctl *v, int irq, int bustype, int busno, int devno, int fno)
 }
 
 void
-ioapicinit(int id, int ibase, uintptr_t pa)
+ioapicinit(int id, int ibase, uintptr pa)
 {
 	Apic *apic;
 
@@ -369,7 +369,7 @@ ioapicdump(void)
 	Rbus *rbus;
 	Rdt *rdt;
 	Apic *apic;
-	uint32_t hi, lo;
+	u32 hi, lo;
 
 	if(!DBGFLG)
 		return;
@@ -422,7 +422,7 @@ irqenable(void)
 {
 	int i;
 	Apic *apic;
-	uint32_t hi, lo;
+	u32 hi, lo;
 
 	for(apic = xioapic; apic < &xioapic[Napic]; apic++){
 		if(!apic->useable || apic->Ioapic.addr == nil)
@@ -443,7 +443,7 @@ irqenable(void)
 static int dfpolicy = 0;
 
 static void
-ioapicintrdd(uint32_t *hi, uint32_t *lo)
+ioapicintrdd(u32 *hi, u32 *lo)
 {
 	int i;
 	static int df;
@@ -526,7 +526,7 @@ static int
 intrenablemsi(Vctl *v, Pcidev *p)
 {
 	uint vno, lo, hi;
-	uint64_t msivec;
+	u64 msivec;
 
 	vno = nextvec();
 
@@ -536,7 +536,7 @@ intrenablemsi(Vctl *v, Pcidev *p)
 	if(lo & Lm)
 		lo |= MTlp;
 
-	msivec = (uint64_t)hi << 32 | lo;
+	msivec = (u64)hi << 32 | lo;
 	if(pcimsienable(p, msivec) == -1)
 		return -1;
 	v->isr = apicisr;
@@ -762,7 +762,7 @@ bus_irq_setup(Vctl *v)
 }
 
 int
-acpiirq(uint32_t tbdf, int gsi)
+acpiirq(u32 tbdf, int gsi)
 {
 	Proc *up = externup();
 	int ioapic_nr;

sys/src/9/amd64/main.c

@@ -24,12 +24,12 @@
 
 Conf conf; /* XXX - must go - gag */
 
-static uintptr_t sp; /* XXX - must go - user stack of init proc */
+static uintptr sp; /* XXX - must go - user stack of init proc */
 
 /* Next time you see a system with cores/sockets running at different clock rates, on x86,
  * let me know. AFAIK, it no longer happens. So the BSP hz is good for the AP hz.
  */
-int64_t hz;
+i64 hz;
 
 Sys *const sys = UINT2PTR(KSYS);
 
@@ -40,7 +40,7 @@ Sys *const sys = UINT2PTR(KSYS);
  * set it all up.
  */
 char *cputype = "amd64";
-static int64_t oargc;
+static i64 oargc;
 static char *oargv[128];
 static char oargb[4096];
 static int oargblen;
@@ -68,7 +68,7 @@ static int showpost = 0;
 // code always compiles, and macros usually break that rule. The cost in space
 // and time of this bit of extra code is so small as to not matter.
 void
-post(char *msg, uint8_t terminal)
+post(char *msg, u8 terminal)
 {
 	if(!showpost)
 		return;
@@ -79,9 +79,9 @@ post(char *msg, uint8_t terminal)
 	outb(0x80, terminal);
 }
 void *
-sigscan(uint8_t *address, int length, char *signature)
+sigscan(u8 *address, int length, char *signature)
 {
-	uint8_t *e, *p;
+	u8 *e, *p;
 	int siglength;
 
 	e = address + length;
@@ -100,7 +100,7 @@ sigscan(uint8_t *address, int length, char *signature)
  *	pretty printing below, so it doesn't need to be accurate
  */
 static int
-ktextaddr(uintptr_t pc)
+ktextaddr(uintptr pc)
 {
 	return (pc & KTZERO) == KTZERO;
 }
@@ -118,11 +118,11 @@ stacksnippet(void)
 void
 machp_bad(void)
 {
-	static uintptr_t trace[256];
-	uintptr_t badpc;
+	static uintptr trace[256];
+	uintptr badpc;
 	int i;
 
-	badpc = (uintptr_t)getcallerpc();
+	badpc = (uintptr)getcallerpc();
 	for(i = 0; i < nelem(trace); i++){
 		if(trace[i] == badpc)
 			return;
@@ -222,7 +222,7 @@ void
 squidboy(Mach *mach)
 {
 	// FIX QEMU. extern int64_t hz;
-	int64_t hz;
+	i64 hz;
 
 	sys->machptr[mach->machno] = mach;
 	/*
@@ -341,7 +341,7 @@ nixsquids(void)
 {
 	Mach *mach;
 	int i;
-	uint64_t now, start;
+	u64 now, start;
 
 	/* Not AC for now :-) */
 	numtcs = MACHMAX;
@@ -411,7 +411,7 @@ hi(char *s)
 }
 
 void
-hihex(uint64_t x)
+hihex(u64 x)
 {
 	const char *hex = "0123456789abcdef";
 	for(int i = 60; i >= 0; i -= 4)
@@ -445,7 +445,7 @@ die(char *s)
 }
 
 void
-badcall(uint64_t where, uint64_t what)
+badcall(u64 where, u64 what)
 {
 	hi("Bad call from function ");
 	hihex(where);
@@ -465,7 +465,7 @@ errstr(char *s, int i)
 static int x = 0x123456;
 
 void
-main(Mach *mach, uint32_t mbmagic, uint32_t mbaddress)
+main(Mach *mach, u32 mbmagic, u32 mbaddress)
 {
 	int postterminal = 1;
 	USED(postterminal);
@@ -494,7 +494,7 @@ main(Mach *mach, uint32_t mbmagic, uint32_t mbaddress)
 
 	// The kernel maps the first 4GiB before entry to main().  If the
 	// image is too big, we will fail to boot properly.
-	if((uintptr_t)end - KZERO > 4ULL * GiB)
+	if((uintptr)end - KZERO > 4ULL * GiB)
 		panic("main: kernel too big: image ends after 4GiB");
 
 	/*
@@ -515,7 +515,7 @@ main(Mach *mach, uint32_t mbmagic, uint32_t mbaddress)
 	 * needs machp()->machno, sys->machptr[] set, and
 	 * also 'up' set to nil.
 	 */
-	cgapost(sizeof(uintptr_t) * 8);
+	cgapost(sizeof(uintptr) * 8);
 
 	mallocinit();
 	pamapinit();
@@ -658,10 +658,10 @@ init0(void)
 }
 
 void
-bootargs(uintptr_t base)
+bootargs(uintptr base)
 {
 	int i;
-	uint32_t ssize;
+	u32 ssize;
 	char **av, *p;
 
 	/*
@@ -724,7 +724,7 @@ userinit(void)
 	 * AMD64 stack must be quad-aligned.
 	 */
 	p->sched.pc = PTR2UINT(init0);
-	p->sched.sp = PTR2UINT(p->kstack + KSTACK - sizeof(up->arg) - sizeof(uintptr_t));
+	p->sched.sp = PTR2UINT(p->kstack + KSTACK - sizeof(up->arg) - sizeof(uintptr));
 	p->sched.sp = STACKALIGN(p->sched.sp);
 
 	/*
@@ -830,7 +830,7 @@ shutdown(int ispanic)
 }
 
 void
-reboot(void *v, void *w, int32_t i)
+reboot(void *v, void *w, i32 i)
 {
 	panic("reboot\n");
 }

sys/src/9/amd64/map.c

@@ -17,7 +17,7 @@
 #define _PADDR(va) PTR2UINT(((uintptr)(va)) - KZERO)
 
 void *
-KADDR(uintptr_t pa)
+KADDR(uintptr pa)
 {
 	if(pa < KZERO)
 		return _KADDR(pa);
@@ -25,10 +25,10 @@ KADDR(uintptr_t pa)
 	return UINT2PTR(pa);
 }
 
-uintmem
+u64
 PADDR(void *va)
 {
-	uintmem pa;
+	u64 pa;
 
 	pa = PTR2UINT(va);
 	if(pa >= KZERO)

sys/src/9/amd64/memory.c

@@ -52,9 +52,9 @@ meminit(void)
 			continue;
 		if(cx >= nelem(conf.mem))
 			continue;
-		uintmem lo = ROUNDUP(m->addr, PGSZ);
+		u64 lo = ROUNDUP(m->addr, PGSZ);
 		conf.mem[cx].base = lo;
-		uintmem hi = ROUNDDN(m->addr + m->size, PGSZ);
+		u64 hi = ROUNDDN(m->addr + m->size, PGSZ);
 		conf.mem[cx].npage = (hi - lo) / PGSZ;
 		conf.npage += conf.mem[cx].npage;
 		DBG("cm %d: addr %#llx npage %lu\n",
@@ -75,7 +75,7 @@ meminit(void)
 static void
 setphysmembounds(void)
 {
-	uintmem pmstart, pmend;
+	u64 pmstart, pmend;
 
 	pmstart = ROUNDUP(PADDR(end), 2 * MiB);
 	pmend = pmstart;

sys/src/9/amd64/mmu.c

@@ -87,7 +87,7 @@ tabs(int n)
 }
 
 void
-dumpptepg(int lvl, uintptr_t pa)
+dumpptepg(int lvl, uintptr pa)
 {
 	PTE *pte;
 	int tab, i;
@@ -278,11 +278,11 @@ mmurelease(Proc *proc)
 }
 
 static void
-checkpte(const PTE *pml4, uintmem ppn, void *a)
+checkpte(const PTE *pml4, u64 ppn, void *a)
 {
 	int l;
 	const PTE *pte;
-	uint64_t addr;
+	u64 addr;
 	char buf[240], *s;
 
 	addr = PTR2UINT(a);
@@ -315,10 +315,10 @@ Panic:
 	panic("%s", buf);
 }
 
-static uintmem
+static u64
 pteflags(uint attr)
 {
-	uintmem flags;
+	u64 flags;
 
 	flags = 0;
 	if(attr & ~(PTEVALID | PTEWRITE | PTERONLY | PTEUSER | PTEUNCACHED | PTENOEXEC))
@@ -360,7 +360,7 @@ allocptpage(Proc *p, int level)
  * For 1*GiB pages, we use two levels.
  */
 void
-mmuput(uintptr_t va, Page *pg, uint attr)
+mmuput(uintptr va, Page *pg, uint attr)
 {
 	Proc *up;
 	int pgsz;
@@ -437,7 +437,7 @@ mmuput(uintptr_t va, Page *pg, uint attr)
 static Lock vmaplock;
 
 int
-mmukmapsync(uint64_t va)
+mmukmapsync(u64 va)
 {
 	USED(va);
 
@@ -454,7 +454,7 @@ mmukpmap4(PTE *pml4, uintptr va)
 }
 
 static PTE *
-mmukpmap3(PTE *pml3, uintmem pa, uintptr va, PTE attr, usize size)
+mmukpmap3(PTE *pml3, u64 pa, uintptr va, PTE attr, usize size)
 {
 	PTE p3e = pml3[PML3X(va)];
 
@@ -490,7 +490,7 @@ mmukpmap3(PTE *pml3, uintmem pa, uintptr va, PTE attr, usize size)
 }
 
 static PTE *
-mmukpmap2(PTE *pml2, uintmem pa, uintptr va, PTE attr, usize size)
+mmukpmap2(PTE *pml2, u64 pa, uintptr va, PTE attr, usize size)
 {
 	PTE p2e = pml2[PML2X(va)];
 
@@ -526,7 +526,7 @@ mmukpmap2(PTE *pml2, uintmem pa, uintptr va, PTE attr, usize size)
 }
 
 static void
-mmukpmap1(PTE *pml1, uintmem pa, uintptr va, PTE attr)
+mmukpmap1(PTE *pml1, u64 pa, uintptr va, PTE attr)
 {
 	PTE p1e = pml1[PML1X(va)];
 	if((p1e & PteP) != 0 && PPN(p1e) != pa)
@@ -540,7 +540,7 @@ mmukpmap1(PTE *pml1, uintmem pa, uintptr va, PTE attr)
  * Called only after the va range is known to be unoccupied.
  */
 void
-mmukphysmap(PTE *pml4, uintmem pa, PTE attr, usize size)
+mmukphysmap(PTE *pml4, u64 pa, PTE attr, usize size)
 {
 	usize pgsz = 0;
 	Mpl pl;
@@ -580,9 +580,9 @@ mmukphysmap(PTE *pml4, uintmem pa, PTE attr, usize size)
  * vmap() is required to access them.
  */
 void *
-vmap(uintptr_t pa, usize size)
+vmap(uintptr pa, usize size)
 {
-	uintptr_t va;
+	uintptr va;
 	usize o, sz;
 
 	DBG("vmap(%#p, %lu) pc=%#p\n", pa, size, getcallerpc());
@@ -631,7 +631,7 @@ vmap(uintptr_t pa, usize size)
 void
 vunmap(void *v, usize size)
 {
-	uintptr_t va;
+	uintptr va;
 
 	DBG("vunmap(%#p, %lu)\n", v, size);
 
@@ -654,7 +654,7 @@ vunmap(void *v, usize size)
 }
 
 int
-mmuwalk(const PTE *pml4, uintptr_t va, int level, const PTE **ret)
+mmuwalk(const PTE *pml4, uintptr va, int level, const PTE **ret)
 {
 	Mpl pl;
 
@@ -700,7 +700,7 @@ mmuphysaddr(const PTE *pml4, uintptr va)
 {
 	int l;
 	const PTE *pte;
-	uintmem mask, pa;
+	u64 mask, pa;
 
 	/*
 	 * Given a VA, find the PA.
@@ -729,9 +729,9 @@ Page mach0pml4;
 void
 mmuinit(void)
 {
-	uint8_t *p;
+	u8 *p;
 	Page *page;
-	uint64_t r;
+	u64 r;
 
 	archmmu();
 	DBG("mach%d: %#p pml4 %#p npgsz %d\n", machp()->machno, machp(), machp()->MMU.pml4, sys->npgsz);

sys/src/9/amd64/msi.c

@@ -69,7 +69,7 @@ blacklist(Pcidev *p)
 }
 
 int
-pcimsienable(Pcidev *p, uint64_t vec)
+pcimsienable(Pcidev *p, u64 vec)
 {
 	uint c, f, d, datao, lopri, dmode, logical;
 

sys/src/9/amd64/multiboot.c

@@ -15,22 +15,22 @@
 
 typedef struct Mbi Mbi;
 struct Mbi {
-	uint32_t flags;
-	uint32_t memlower;
-	uint32_t memupper;
-	uint32_t bootdevice;
-	uint32_t cmdline;
-	uint32_t modscount;
-	uint32_t modsaddr;
-	uint32_t syms[4];
-	uint32_t mmaplength;
-	uint32_t mmapaddr;
-	uint32_t driveslength;
-	uint32_t drivesaddr;
-	uint32_t configtable;
-	uint32_t bootloadername;
-	uint32_t apmtable;
-	uint32_t vbe[6];
+	u32 flags;
+	u32 memlower;
+	u32 memupper;
+	u32 bootdevice;
+	u32 cmdline;
+	u32 modscount;
+	u32 modsaddr;
+	u32 syms[4];
+	u32 mmaplength;
+	u32 mmapaddr;
+	u32 driveslength;
+	u32 drivesaddr;
+	u32 configtable;
+	u32 bootloadername;
+	u32 apmtable;
+	u32 vbe[6];
 };
 
 enum {				     /* flags */
@@ -50,18 +50,18 @@ enum {				     /* flags */
 
 typedef struct Mod Mod;
 struct Mod {
-	uint32_t modstart;
-	uint32_t modend;
-	uint32_t string;
-	uint32_t reserved;
+	u32 modstart;
+	u32 modend;
+	u32 string;
+	u32 reserved;
 };
 
 typedef struct MMap MMap;
 struct MMap {
-	uint32_t size;
-	uint32_t base[2];
-	uint32_t length[2];
-	uint32_t type;
+	u32 size;
+	u32 base[2];
+	u32 length[2];
+	u32 type;
 };
 
 static int
@@ -104,14 +104,14 @@ mbtypename(int type)
 }
 
 int
-multiboot(uint32_t magic, uint32_t pmbi, int vflag)
+multiboot(u32 magic, u32 pmbi, int vflag)
 {
 	char *p;
 	int i, n;
 	Mbi *mbi;
 	Mod *mod;
 	MMap *mmap;
-	uint64_t addr, len;
+	u64 addr, len;
 
 	if(vflag)
 		print("magic %#x pmbi %#x\n", magic, pmbi);
@@ -132,8 +132,8 @@ multiboot(uint32_t magic, uint32_t pmbi, int vflag)
 		mmap = KADDR(mbi->mmapaddr);
 		n = 0;
 		while(n < mbi->mmaplength){
-			addr = (((uint64_t)mmap->base[1]) << 32) | mmap->base[0];
-			len = (((uint64_t)mmap->length[1]) << 32) | mmap->length[0];
+			addr = (((u64)mmap->base[1]) << 32) | mmap->base[0];
+			len = (((u64)mmap->length[1]) << 32) | mmap->length[0];
 			if(vflag){
 				print("%s (%u)", mbtypename(mmap->type), mmap->type);
 			} else {

sys/src/9/amd64/pamap.c

@@ -61,7 +61,7 @@ pamapdump(void)
 }
 
 PAMap *
-pamapnew(uintmem addr, usize size, int type)
+pamapnew(u64 addr, usize size, int type)
 {
 	PAMap *m = malloc(sizeof(*m));
 	assert(m != nil);
@@ -75,7 +75,7 @@ pamapnew(uintmem addr, usize size, int type)
 }
 
 static void
-pamapclearrange(uintmem addr, usize size, int type)
+pamapclearrange(u64 addr, usize size, int type)
 {
 	PAMap **ppp = &pamap, *np = pamap;
 	while(np != nil && size > 0){
@@ -107,7 +107,7 @@ pamapclearrange(uintmem addr, usize size, int type)
 		// it becomes empty.
 		if(np->addr < addr){
 			assert(addr < np->addr + np->size);
-			uintmem osize = np->size;
+			u64 osize = np->size;
 			np->size = addr - np->addr;
 			PAMap *tp = pamapnew(addr, osize - np->size, np->type);
 			tp->next = np->next;
@@ -144,7 +144,7 @@ pamapclearrange(uintmem addr, usize size, int type)
 }
 
 void
-pamapinsert(uintmem addr, usize size, int type)
+pamapinsert(u64 addr, usize size, int type)
 {
 	PAMap *np, *pp, **ppp;
 

sys/src/9/amd64/physalloc.c

@@ -21,7 +21,7 @@
 #include "acpi.h"
 
 #define ISPOWEROF2(x) (((x) != 0) && !((x) & ((x)-1)))
-#define UNO ((uintmem)1)
+#define UNO ((u64)1)
 
 enum {
 	BKmin = 21, /* Minimum lg2 */
@@ -38,8 +38,8 @@ enum {
 
 typedef struct Buddy Buddy;
 struct Buddy {
-	int16_t tag; /* Used or Avail */
-	int16_t kval;
+	i16 tag; /* Used or Avail */
+	i16 kval;
 	uint next;
 	uint prev;
 	void *p;
@@ -52,14 +52,14 @@ struct Buddy {
  */
 typedef struct Bal Bal;
 struct Bal {
-	uintmem base;
-	uint64_t size;
+	u64 base;
+	u64 size;
 	usize nfree;
 	usize nblocks;
 	int kmin;	/* Minimum lg2 */
 	int kmax;	/* Maximum lg2 */
-	uintmem bminsz; /* minimum block sz */
-	uintmem memory;
+	u64 bminsz; /* minimum block sz */
+	u64 memory;
 	uint kspan;
 
 	Buddy *blocks;
@@ -88,7 +88,7 @@ seprintphysstats(char *s, char *e)
 }
 
 static void
-xphysfree(Bal *b, uintmem data, uint64_t size)
+xphysfree(Bal *b, u64 data, u64 size)
 {
 	uint i;
 	Buddy *l, *p;
@@ -177,7 +177,7 @@ S1:
 }
 
 void
-physfree(uintmem data, uint64_t size)
+physfree(u64 data, u64 size)
 {
 	Bal *b;
 	int i;
@@ -193,7 +193,7 @@ physfree(uintmem data, uint64_t size)
 }
 
 static void *
-xphystag(Bal *b, uintmem data)
+xphystag(Bal *b, u64 data)
 {
 	uint i;
 	Buddy *blocks;
@@ -209,7 +209,7 @@ xphystag(Bal *b, uintmem data)
 }
 
 void *
-phystag(uintmem data)
+phystag(u64 data)
 {
 	Bal *b;
 	int i;
@@ -222,7 +222,7 @@ phystag(uintmem data)
 	return nil;
 }
 
-static uint8_t lg2table[256] = {
+static u8 lg2table[256] = {
 	0,
 	0,
 	1,
@@ -482,9 +482,9 @@ static uint8_t lg2table[256] = {
 };
 
 static int
-lg2floor(uint64_t w)
+lg2floor(u64 w)
 {
-	uint64_t hi, lo;
+	u64 hi, lo;
 
 	if((lo = (w >> 48)) != 0){
 		if((hi = (lo >> 8)) != 0)
@@ -506,13 +506,13 @@ lg2floor(uint64_t w)
 	return lg2table[w];
 }
 
-static uintmem
-xphysalloc(Bal *b, uint64_t size, void *tag)
+static u64
+xphysalloc(Bal *b, u64 size, void *tag)
 {
 	uint i, j, k;
 	Buddy *l, *p;
 	Buddy *avail, *blocks;
-	uintmem m;
+	u64 m;
 
 	DBG("physalloc\n");
 	assert(b->size > 0);
@@ -587,11 +587,11 @@ xphysalloc(Bal *b, uint64_t size, void *tag)
 	return m;
 }
 
-uintmem
-physalloc(uint64_t size, int *colorp, void *tag)
+u64
+physalloc(u64 size, int *colorp, void *tag)
 {
 	int i, color;
-	uintmem m;
+	u64 m;
 
 	m = 0;
 
@@ -651,7 +651,7 @@ physallocdump(void)
 }
 
 static int
-plop(Bal *b, uintmem a, int k, int type)
+plop(Bal *b, u64 a, int k, int type)
 {
 	uint i;
 	Buddy *l;
@@ -668,7 +668,7 @@ plop(Bal *b, uintmem a, int k, int type)
 }
 
 static int
-iimbchunk(Bal *b, uintmem a, uintmem e, int type)
+iimbchunk(Bal *b, u64 a, u64 e, int type)
 {
 	int k;
 	uint s;
@@ -708,12 +708,12 @@ iimbchunk(Bal *b, uintmem a, uintmem e, int type)
  * Called from umeminit to initialize user memory allocators.
  */
 void
-physinit(uintmem a, uint64_t size)
+physinit(u64 a, u64 size)
 {
-	uintmem dtsz;
+	u64 dtsz;
 	Bal *b;
 	int i, dom;
-	uintmem addr, len;
+	u64 addr, len;
 
 	DBG("physinit %#llx %#llx\n", a, size);
 

sys/src/9/amd64/pmcio.c

@@ -47,7 +47,7 @@ pmcnregs(void)
 static int
 pmcuserenab(int enable)
 {
-	uint64_t cr4;
+	u64 cr4;
 
 	cr4 = cr4get();
 	if(enable){
@@ -101,9 +101,9 @@ pmctrans(PmcCtl *p)
 }
 
 static int
-getctl(PmcCtl *p, uint32_t regno)
+getctl(PmcCtl *p, u32 regno)
 {
-	uint64_t r, e, u;
+	u64 r, e, u;
 
 	r = rdmsr(regno + PerfEvtbase);
 	p->enab = (r & PeCtEna) != 0;
@@ -138,7 +138,7 @@ extern int pmcdebug;
 static int
 setctl(PmcCtl *p, int regno)
 {
-	uint64_t v, e, u;
+	u64 v, e, u;
 	char *toks[2];
 	char str[KNAMELEN];
 
@@ -232,14 +232,14 @@ pmcdescstr(char *str, int nstr)
 	return ns;
 }
 
-static uint64_t
-getctr(uint32_t regno)
+static u64
+getctr(u32 regno)
 {
 	return rdmsr(regno + PerfCtrbase);
 }
 
 static int
-setctr(uint64_t v, uint32_t regno)
+setctr(u64 v, u32 regno)
 {
 	wrmsr(regno + PerfCtrbase, v);
 	return 0;
@@ -328,12 +328,12 @@ shouldipi(Mach *mp)
 	return 1;
 }
 
-uint64_t
-pmcgetctr(uint32_t coreno, uint32_t regno)
+u64
+pmcgetctr(u32 coreno, u32 regno)
 {
 	PmcCtr *p;
 	Mach *mp;
-	uint64_t v;
+	u64 v;
 
 	if(coreno == machp()->machno){
 		v = getctr(regno);
@@ -360,7 +360,7 @@ pmcgetctr(uint32_t coreno, uint32_t regno)
 }
 
 int
-pmcsetctr(uint32_t coreno, uint64_t v, uint32_t regno)
+pmcsetctr(u32 coreno, u64 v, u32 regno)
 {
 	PmcCtr *p;
 	Mach *mp;
@@ -403,7 +403,7 @@ ctl2ctl(PmcCtl *dctl, PmcCtl *sctl)
 }
 
 int
-pmcsetctl(uint32_t coreno, PmcCtl *pctl, uint32_t regno)
+pmcsetctl(u32 coreno, PmcCtl *pctl, u32 regno)
 {
 	PmcCtr *p;
 	Mach *mp;
@@ -424,7 +424,7 @@ pmcsetctl(uint32_t coreno, PmcCtl *pctl, uint32_t regno)
 }
 
 int
-pmcgetctl(uint32_t coreno, PmcCtl *pctl, uint32_t regno)
+pmcgetctl(u32 coreno, PmcCtl *pctl, u32 regno)
 {
 	PmcCtr *p;
 	Mach *mp;

sys/src/9/amd64/qmalloc.c

@@ -133,10 +133,10 @@ struct Private {
 #define QLIST quicklist
 
 static void *
-qmallocalign(usize nbytes, uintptr_t align, int32_t offset, usize span)
+qmallocalign(usize nbytes, uintptr align, i32 offset, usize span)
 {
 	Qlist *qlist;
-	uintptr_t aligned;
+	uintptr aligned;
 	Header **pp, *p, *q, *r;
 	uint naligned, nunits, n;
 
@@ -377,7 +377,7 @@ qfreeinternal(void *ap)
 	rover = q;
 }
 
-uint32_t
+u32
 msize(void *ap)
 {
 	Header *p;
@@ -405,9 +405,9 @@ mallocreadfmt(char *s, char *e)
 		    "%llu memory\n"
 		    "%d pagesize\n"
 		    "%llu kernel\n",
-		    (uint64_t)conf.npage * PGSZ,
+		    (u64)conf.npage * PGSZ,
 		    PGSZ,
-		    (uint64_t)conf.npage - conf.upages);
+		    (u64)conf.npage - conf.upages);
 
 	t = 0;
 	for(i = 0; i <= NQUICK; i++){
@@ -451,8 +451,8 @@ mallocreadfmt(char *s, char *e)
 	MUNLOCK;
 }
 
-int32_t
-mallocreadsummary(Chan *c, void *a, int32_t n, int32_t offset)
+i32
+mallocreadsummary(Chan *c, void *a, i32 n, i32 offset)
 {
 	char *alloc;
 
@@ -520,7 +520,7 @@ free(void *ap)
 }
 
 void *
-malloc(uint32_t size)
+malloc(u32 size)
 {
 	void *v;
 
@@ -531,7 +531,7 @@ malloc(uint32_t size)
 }
 
 void *
-mallocz(uint32_t size, int clr)
+mallocz(u32 size, int clr)
 {
 	void *v;
 
@@ -542,7 +542,7 @@ mallocz(uint32_t size, int clr)
 }
 
 void *
-mallocalign(uint32_t nbytes, uint32_t align, int32_t offset, uint32_t span)
+mallocalign(u32 nbytes, u32 align, i32 offset, u32 span)
 {
 	void *v;
 
@@ -556,7 +556,7 @@ mallocalign(uint32_t nbytes, uint32_t align, int32_t offset, uint32_t span)
 }
 
 void *
-smalloc(uint32_t size)
+smalloc(u32 size)
 {
 	Proc *up = externup();
 	void *v;
@@ -567,11 +567,11 @@ smalloc(uint32_t size)
 }
 
 void *
-realloc(void *ap, uint32_t size)
+realloc(void *ap, u32 size)
 {
 	void *v;
 	Header *p;
-	uint32_t osize;
+	u32 osize;
 	uint nunits, ounits;
 
 	/*
@@ -647,7 +647,7 @@ realloc(void *ap, uint32_t size)
 }
 
 void
-setmalloctag(void *v, uint32_t i)
+setmalloctag(void *v, u32 i)
 {
 }
 

sys/src/9/amd64/ratrace.c

@@ -48,11 +48,11 @@ cwrite(int fd, char *path, char *cmd, int len)
 void
 reader(void *v)
 {
-	uintptr_t cfd, tfd, forking = 0, pid, newpid;
+	uintptr cfd, tfd, forking = 0, pid, newpid;
 	char *ctl, *truss;
 	Str *s;
 
-	pid = (int)(uintptr_t)v;
+	pid = (int)(uintptr)v;
 	ctl = smprint("/proc/%d/ctl", pid);
 	if((cfd = open(ctl, OWRITE)) < 0)
 		die(smprint("%s: %r", ctl));
@@ -83,7 +83,7 @@ reader(void *v)
 
 			rf = strdup(s->buf);
 			if(tokenize(rf, a, 8) == 5){
-				uint32_t flags;
+				u32 flags;
 
 				flags = strtoul(a[4], 0, 16);
 				if(flags & RFPROC)
@@ -149,7 +149,7 @@ usage(void)
 void
 threadmain(int argc, char **argv)
 {
-	uintptr_t pid;
+	uintptr pid;
 	char *cmd = nil;
 	char **args = nil;
 
@@ -191,7 +191,7 @@ threadmain(int argc, char **argv)
 
 	out = chancreate(sizeof(char *), 0);
 	quit = chancreate(sizeof(char *), 0);
-	forkc = chancreate(sizeof(uint32_t *), 0);
+	forkc = chancreate(sizeof(u32 *), 0);
 	nread++;
 	procrfork(writer, nil, Stacksize, 0);
 	reader((void *)pid);

sys/src/9/amd64/screen.c

@@ -110,7 +110,7 @@ int didswcursorinit;
 static void *softscreen;
 
 int
-screensize(int x, int y, int z, uint32_t chan)
+screensize(int x, int y, int z, u32 chan)
 {
 	Proc *up = externup();
 	VGAscr *scr;
@@ -195,7 +195,7 @@ screenaperture(int size, int align)
 	 * The driver will tell the card to use it.
 	 */
 	size = ROUNDUP(sizeof(size), 4 * KiB);
-	scr->paddr = (uint64_t)malloc(size);
+	scr->paddr = (u64)malloc(size);
 	if(scr->paddr == 0)
 		return -1;
 	scr->vaddr = vmap(scr->paddr, size);
@@ -207,7 +207,7 @@ screenaperture(int size, int align)
 }
 
 unsigned char *
-attachscreen(Rectangle *r, uint32_t *chan, int *d, int *width, int *softscreen)
+attachscreen(Rectangle *r, u32 *chan, int *d, int *width, int *softscreen)
 {
 	VGAscr *scr;
 
@@ -298,10 +298,10 @@ flushmemscreen(Rectangle r)
 }
 
 void
-getcolor(uint32_t p, uint32_t *pr, uint32_t *pg, uint32_t *pb)
+getcolor(u32 p, u32 *pr, u32 *pg, u32 *pb)
 {
 	VGAscr *scr;
-	uint32_t x;
+	u32 x;
 
 	scr = &vgascreen[0];
 	if(scr->gscreen == nil)
@@ -325,7 +325,7 @@ getcolor(uint32_t p, uint32_t *pr, uint32_t *pg, uint32_t *pb)
 }
 
 int
-setpalette(uint32_t p, uint32_t r, uint32_t g, uint32_t b)
+setpalette(u32 p, u32 r, u32 g, u32 b)
 {
 	VGAscr *scr;
 	int d;
@@ -352,7 +352,7 @@ setpalette(uint32_t p, uint32_t r, uint32_t g, uint32_t b)
  * is trying to set a colormap and the card is in one of these modes.
  */
 int
-setcolor(uint32_t p, uint32_t r, uint32_t g, uint32_t b)
+setcolor(u32 p, u32 r, u32 g, u32 b)
 {
 	VGAscr *scr;
 	int x;
@@ -514,7 +514,7 @@ vgalinearpciid(VGAscr *scr, int vid, int did)
 void
 vgalinearpci(VGAscr *scr)
 {
-	uint32_t paddr;
+	u32 paddr;
 	int i, size, best;
 	Pcidev *p;
 
@@ -552,10 +552,10 @@ vgalinearpci(VGAscr *scr)
 }
 
 void
-vgalinearaddr(VGAscr *scr, uint32_t paddr, int size)
+vgalinearaddr(VGAscr *scr, u32 paddr, int size)
 {
 	int x, nsize;
-	uint32_t npaddr;
+	u32 npaddr;
 
 	/*
 	 * new approach.  instead of trying to resize this

sys/src/9/amd64/screen.h

@@ -61,8 +61,8 @@ enum {
 #define vgai(port) inb(port)
 #define vgao(port, data) outb(port, data)
 
-extern int vgaxi(int32_t, unsigned char);
-extern int vgaxo(int32_t, unsigned char, unsigned char);
+extern int vgaxi(i32, unsigned char);
+extern int vgaxo(i32, unsigned char, unsigned char);
 
 /*
  */
@@ -78,9 +78,9 @@ struct VGAdev {
 	void (*page)(VGAscr *, int);
 	void (*linear)(VGAscr *, int, int);
 	void (*drawinit)(VGAscr *);
-	int (*fill)(VGAscr *, Rectangle, uint32_t);
+	int (*fill)(VGAscr *, Rectangle, u32);
 	void (*ovlctl)(VGAscr *, Chan *, void *, int);
-	int (*ovlwrite)(VGAscr *, void *, int, int64_t);
+	int (*ovlwrite)(VGAscr *, void *, int, i64);
 	void (*flush)(VGAscr *, Rectangle);
 };
 
@@ -103,29 +103,29 @@ struct VGAscr {
 	Pcidev *pci;
 
 	VGAcur *cur;
-	uint32_t storage;
+	u32 storage;
 	Cursor Cursor;
 
 	int useflush;
 
-	uint32_t paddr; /* frame buffer */
+	u32 paddr; /* frame buffer */
 	void *vaddr;
 	int apsize;
 
-	uint32_t io; /* device specific registers */
-	uint32_t *mmio;
+	u32 io; /* device specific registers */
+	u32 *mmio;
 
-	uint32_t colormap[Pcolours][3];
+	u32 colormap[Pcolours][3];
 	int palettedepth;
 
 	Memimage *gscreen;
 	Memdata *gscreendata;
 	Memsubfont *memdefont;
 
-	int (*fill)(VGAscr *, Rectangle, uint32_t);
+	int (*fill)(VGAscr *, Rectangle, u32);
 	int (*scroll)(VGAscr *, Rectangle, Rectangle);
 	void (*blank)(VGAscr *, int);
-	uint32_t id; /* internal identifier for driver use */
+	u32 id; /* internal identifier for driver use */
 	int isblank;
 	int overlayinit;
 };
@@ -144,13 +144,13 @@ extern void mouseresize(void);
 extern int hwaccel; /* use hw acceleration; default on */
 extern int hwblank; /* use hw blanking; default on */
 extern int panning; /* use virtual screen panning; default off */
-extern void addvgaseg(char *, uint32_t, uint32_t);
-extern unsigned char *attachscreen(Rectangle *, uint32_t *, int *, int *, int *);
+extern void addvgaseg(char *, u32, u32);
+extern unsigned char *attachscreen(Rectangle *, u32 *, int *, int *, int *);
 extern void flushmemscreen(Rectangle);
 extern int cursoron(int);
 extern void cursoroff(int);
 extern void setcursor(Cursor *);
-extern int screensize(int, int, int, uint32_t);
+extern int screensize(int, int, int, u32);
 extern int screenaperture(int, int);
 extern Rectangle physgscreenr; /* actual monitor size */
 extern void blankscreen(int);
@@ -165,7 +165,7 @@ extern void swcursorunhide(void);
 extern void deletescreenimage(void);
 extern void resetscreenimage(void);
 extern int drawhasclients(void);
-extern uint32_t blanktime;
+extern u32 blanktime;
 extern void setscreenimageclipr(Rectangle);
 extern void drawflush(void);
 extern int drawidletime(void);
@@ -173,10 +173,10 @@ extern QLock drawlock;
 
 /* vga.c */
 extern void vgascreenwin(VGAscr *);
-extern void vgaimageinit(uint32_t);
+extern void vgaimageinit(u32);
 extern void vgalinearpciid(VGAscr *, int, int);
 extern void vgalinearpci(VGAscr *);
-extern void vgalinearaddr(VGAscr *, uint32_t, int);
+extern void vgalinearaddr(VGAscr *, u32, int);
 
 extern void drawblankscreen(int);
 extern void vgablank(VGAscr *, int);

sys/src/9/amd64/sdata.c

@@ -264,7 +264,7 @@ typedef struct Ctlr Ctlr;
 typedef struct Drive Drive;
 
 typedef struct Prd { /* Physical Region Descriptor */
-	uint32_t pa; /* Physical Base Address */
+	u32 pa; /* Physical Base Address */
 	int count;
 } Prd;
 
@@ -301,9 +301,9 @@ typedef struct Ctlr {
 	int done;
 
 	/* interrupt counts */
-	uint32_t intnil;  /* no drive */
-	uint32_t intbusy; /* controller still busy */
-	uint32_t intok;	  /* normal */
+	u32 intnil;  /* no drive */
+	u32 intbusy; /* controller still busy */
+	u32 intok;	  /* normal */
 
 	Lock l; /* register access */
 } Ctlr;
@@ -312,11 +312,11 @@ typedef struct Drive {
 	Ctlr *ctlr;
 
 	int dev;
-	uint16_t info[256];
+	u16 info[256];
 	int c;		 /* cylinder */
 	int h;		 /* head */
 	int s;		 /* sector */
-	int64_t sectors; /* total */
+	i64 sectors; /* total */
 	int secsize;	 /* sector size */
 
 	int dma; /* DMA R/W possible */
@@ -325,18 +325,18 @@ typedef struct Drive {
 	int rwmctl;
 
 	int pkt; /* PACKET device, length of pktcmd */
-	uint8_t pktcmd[16];
+	u8 pktcmd[16];
 	int pktdma; /* this PACKET command using dma */
 
-	uint8_t sense[18];
-	uint8_t inquiry[48];
+	u8 sense[18];
+	u8 inquiry[48];
 
 	QLock ql;    /* drive access */
 	int command; /* current command */
 	int write;
-	uint8_t *data;
+	u8 *data;
 	int dlen;
-	uint8_t *limit;
+	u8 *limit;
 	int count; /* sectors */
 	int block; /* R/W bytes per block */
 	int status;
@@ -344,9 +344,9 @@ typedef struct Drive {
 	int flags; /* internal flags */
 
 	/* interrupt counts */
-	uint32_t intcmd; /* commands */
-	uint32_t intrd;	 /* reads */
-	uint32_t intwr;	 /* writes */
+	u32 intcmd; /* commands */
+	u32 intrd;	 /* reads */
+	u32 intwr;	 /* writes */
 } Drive;
 
 enum {			  /* internal flags */
@@ -376,7 +376,7 @@ pc87415ienable(Ctlr *ctlr)
 }
 
 static void
-atadumpstate(Drive *drive, uint8_t *cmd, int64_t lba, int count)
+atadumpstate(Drive *drive, u8 *cmd, i64 lba, int count)
 {
 	Prd *prd;
 	Pcidev *p;
@@ -625,9 +625,9 @@ ataidentify(int cmdport, int ctlport, int dev, int pkt, void *info)
 
 	if(DEBUG & DbgIDENTIFY){
 		int i;
-		uint16_t *sp;
+		u16 *sp;
 
-		sp = (uint16_t *)info;
+		sp = (u16 *)info;
 		for(i = 0; i < 256; i++){
 			if(i && (i % 16) == 0)
 				print("\n");
@@ -645,9 +645,9 @@ atadrive(int cmdport, int ctlport, int dev)
 {
 	Drive *drive;
 	int as, i, pkt;
-	static uint8_t buf[512];
-	uint8_t *p;
-	uint16_t iconfig, *sp;
+	static u8 buf[512];
+	u8 *p;
+	u16 iconfig, *sp;
 
 	atadebug(0, 0, "identify: port 0x%X dev 0x%2.2X\n", cmdport, dev);
 	pkt = 1;
@@ -707,7 +707,7 @@ retry:
 		}
 		if(drive->info[Icapabilities] & Mlba){
 			if(drive->info[Icsfs + 1] & Maddr48){
-				drive->sectors = drive->info[Ilba48] | (drive->info[Ilba48 + 1] << 16) | ((int64_t)drive->info[Ilba48 + 2] << 32);
+				drive->sectors = drive->info[Ilba48] | (drive->info[Ilba48 + 1] << 16) | ((i64)drive->info[Ilba48 + 2] << 32);
 				drive->flags |= Lba48;
 			} else {
 				drive->sectors = (drive->info[Ilba + 1] << 16) | drive->info[Ilba];
@@ -991,7 +991,7 @@ atasetsense(Drive *drive, int status, int key, int asc, int ascq)
 }
 
 static int
-atamodesense(Drive *drive, uint8_t *cmd)
+atamodesense(Drive *drive, u8 *cmd)
 {
 	int len;
 
@@ -1010,7 +1010,7 @@ atamodesense(Drive *drive, uint8_t *cmd)
 		return atasetsense(drive, SDcheck, 0x05, 0x20, 1);
 	memset(drive->data, 0, 8);
 	drive->data[0] = sizeof(drive->info) >> 8;
-	drive->data[1] = (uint8_t)sizeof(drive->info);
+	drive->data[1] = (u8)sizeof(drive->info);
 	memmove(drive->data + 8, drive->info, sizeof(drive->info));
 	drive->data += 8 + sizeof(drive->info);
 
@@ -1107,7 +1107,7 @@ static int
 atadmasetup(Drive *drive, int len)
 {
 	Prd *prd;
-	uint32_t pa;
+	u32 pa;
 	Ctlr *ctlr;
 	int bmiba, bmisx, count, i, span;
 
@@ -1267,7 +1267,7 @@ atapktinterrupt(Drive *drive)
 }
 
 static int
-atapktio(Drive *drive, uint8_t *cmd, int clen)
+atapktio(Drive *drive, u8 *cmd, int clen)
 {
 	Proc *up = externup();
 	Ctlr *ctlr;
@@ -1362,7 +1362,7 @@ atapktio(Drive *drive, uint8_t *cmd, int clen)
 	return r;
 }
 
-static uint8_t cmd48[256] = {
+static u8 cmd48[256] = {
 	[Crs] = Crs48,
 	[Crd] = Crd48,
 	[Crdq] = Crdq48,
@@ -1374,10 +1374,10 @@ static uint8_t cmd48[256] = {
 };
 
 static int
-atageniostart(Drive *drive, uint64_t lba)
+atageniostart(Drive *drive, u64 lba)
 {
 	Ctlr *ctlr;
-	uint8_t cmd;
+	u8 cmd;
 	int as, c, cmdport, ctlport, h, len, s, use48;
 
 	use48 = 0;
@@ -1490,12 +1490,12 @@ atagenioretry(Drive *drive)
 }
 
 static int
-atagenio(Drive *drive, uint8_t *cmd, int clen)
+atagenio(Drive *drive, u8 *cmd, int clen)
 {
 	Proc *up = externup();
-	uint8_t *p;
+	u8 *p;
 	Ctlr *ctlr;
-	int64_t lba, len;
+	i64 lba, len;
 	int count, maxio;
 
 	/*
@@ -1606,7 +1606,7 @@ atagenio(Drive *drive, uint8_t *cmd, int clen)
 		/* ata commands only go to 48-bit lba */
 		if(cmd[2] || cmd[3])
 			return atasetsense(drive, SDcheck, 3, 0xc, 2);
-		lba = (uint64_t)cmd[4] << 40 | (uint64_t)cmd[5] << 32;
+		lba = (u64)cmd[4] << 40 | (u64)cmd[5] << 32;
 		lba |= cmd[6] << 24 | cmd[7] << 16 | cmd[8] << 8 | cmd[9];
 		count = cmd[10] << 24 | cmd[11] << 16 | cmd[12] << 8 | cmd[13];
 	} else {
@@ -1672,7 +1672,7 @@ atario(SDreq *r)
 	Ctlr *ctlr;
 	Drive *drive;
 	SDunit *unit;
-	uint8_t cmd10[10], *cmdp, *p;
+	u8 cmd10[10], *cmdp, *p;
 	int clen, reqstatus, status;
 
 	unit = r->unit;

sys/src/9/amd64/sdiahci.c

@@ -154,10 +154,10 @@ struct Drive {
 	unsigned char state;
 	unsigned char smartrs;
 
-	uint64_t sectors;
-	uint32_t secsize;
-	uint32_t intick; /* start tick of current transfer */
-	uint32_t lastseen;
+	u64 sectors;
+	u32 secsize;
+	u32 intick; /* start tick of current transfer */
+	u32 lastseen;
 	int wait;
 	unsigned char mode; /* DMautoneg, satai or sataii */
 	unsigned char active;
@@ -167,15 +167,15 @@ struct Drive {
 	char model[40 + 1];
 
 	int infosz;
-	uint16_t *info;
-	uint16_t tinyinfo[2]; /* used iff malloc fails */
+	u16 *info;
+	u16 tinyinfo[2]; /* used iff malloc fails */
 
 	int driveno; /* ctlr*NCtlrdrv + unit */
 	/* controller port # != driveno when not all ports are enabled */
 	int portno;
 
-	uint32_t lastintr0;
-	uint32_t intrs;
+	u32 lastintr0;
+	u32 intrs;
 };
 
 struct Ctlr {
@@ -189,7 +189,7 @@ struct Ctlr {
 
 	/* virtual register addresses */
 	unsigned char *mmio;
-	uint32_t *lmmio;
+	u32 *lmmio;
 	Ahba *hba;
 
 	/* phyical register address */
@@ -200,8 +200,8 @@ struct Ctlr {
 	int ndrive;
 	int mport; /* highest drive # (0-origin) on ich9 at least */
 
-	uint32_t lastintr0;
-	uint32_t intrs; /* not attributable to any drive */
+	u32 lastintr0;
+	u32 intrs; /* not attributable to any drive */
 };
 
 struct Asleep {
@@ -229,7 +229,7 @@ static char stab[] = {
 	[0] = 'i', 'm', [8] = 't', 'c', 'p', 'e', [16] = 'N', 'I', 'W', 'B', 'D', 'C', 'H', 'S', 'T', 'F', 'X'};
 
 static void
-serrstr(uint32_t r, char *s, char *e)
+serrstr(u32 r, char *s, char *e)
 {
 	int i;
 
@@ -400,7 +400,7 @@ asleep(int ms)
 static int
 ahciportreset(Aportc *c)
 {
-	uint32_t *cmd, i;
+	u32 *cmd, i;
 	Aport *p;
 
 	p = c->p;
@@ -479,7 +479,7 @@ ahciflushcache(Aportc *pc)
 	return 0;
 }
 
-static uint16_t
+static u16
 gbit16(void *a)
 {
 	unsigned char *i;
@@ -488,10 +488,10 @@ gbit16(void *a)
 	return i[1] << 8 | i[0];
 }
 
-static uint32_t
+static u32
 gbit32(void *a)
 {
-	uint32_t j;
+	u32 j;
 	unsigned char *i;
 
 	i = a;
@@ -502,13 +502,13 @@ gbit32(void *a)
 	return j;
 }
 
-static uint64_t
+static u64
 gbit64(void *a)
 {
 	unsigned char *i;
 
 	i = a;
-	return (uint64_t)gbit32(i + 4) << 32 | gbit32(a);
+	return (u64)gbit32(i + 4) << 32 | gbit32(a);
 }
 
 static int
@@ -533,11 +533,11 @@ ahciidentify0(Aportc *pc, void *id, int atapi)
 	return ahciwait(pc, 3 * 1000);
 }
 
-static int64_t
-ahciidentify(Aportc *pc, uint16_t *id)
+static i64
+ahciidentify(Aportc *pc, u16 *id)
 {
 	int i, sig;
-	int64_t s;
+	i64 s;
 	Aportm *pm;
 
 	pm = pc->pm;
@@ -655,7 +655,7 @@ ahcicomreset(Aportc *pc)
 static int
 ahciidle(Aport *port)
 {
-	uint32_t *p, i, r;
+	u32 *p, i, r;
 
 	p = &port->cmd;
 	if((*p & Arun) == 0)
@@ -723,13 +723,13 @@ setupfis(Afis *f)
 	f->p = f->base + 0x20;
 	f->r = f->base + 0x40;
 	f->u = f->base + 0x60;
-	f->devicebits = (uint32_t *)(f->base + 0x58);
+	f->devicebits = (u32 *)(f->base + 0x58);
 }
 
 static void
 ahciwakeup(Aport *p)
 {
-	uint16_t s;
+	u16 s;
 
 	s = p->sstatus;
 	if((s & Intpm) != Intslumber && (s & Intpm) != Intpartpwr)
@@ -809,7 +809,7 @@ ahcidisable(Ahba *h)
 }
 
 static int
-countbits(uint32_t u)
+countbits(u32 u)
 {
 	int n;
 
@@ -837,7 +837,7 @@ ahciconf(Ctlr *ctlr)
 		pcicfgw16(ctlr->pci, 0x92, pcicfgr16(ctlr->pci, 0x92) | 0xf);
 	}
 
-	uint32_t u = h->cap;
+	u32 u = h->cap;
 	dprint("#S/sd%c: type %s port %#p: sss %ld ncs %ld coal %ld "
 	       "%ld ports, led %ld clo %ld ems %ld\n",
 	       ctlr->sdev->idno, tname[ctlr->type], h,
@@ -849,7 +849,7 @@ ahciconf(Ctlr *ctlr)
 }
 
 static void
-idmove(char *p, uint16_t *a, int n)
+idmove(char *p, u16 *a, int n)
 {
 	int i;
 	char *op, *e;
@@ -871,13 +871,13 @@ idmove(char *p, uint16_t *a, int n)
 static int
 identify(Drive *d)
 {
-	uint16_t *id;
-	int64_t osectors, s;
+	u16 *id;
+	i64 osectors, s;
 	unsigned char oserial[21];
 	SDunit *u;
 
 	if(d->info == nil){
-		d->infosz = 512 * sizeof(uint16_t);
+		d->infosz = 512 * sizeof(u16);
 		d->info = malloc(d->infosz);
 	}
 	if(d->info == nil){
@@ -929,10 +929,10 @@ clearci(Aport *p)
 static void
 updatedrive(Drive *d)
 {
-	uint32_t cause, serr, s0, pr, ewake;
+	u32 cause, serr, s0, pr, ewake;
 	char *name;
 	Aport *p;
-	static uint32_t last;
+	static u32 last;
 
 	pr = 1;
 	ewake = 0;
@@ -1009,7 +1009,7 @@ updatedrive(Drive *d)
 }
 
 static void
-pstatus(Drive *d, uint32_t s)
+pstatus(Drive *d, u32 s)
 {
 	/*
 	 * s is masked with Devdet.
@@ -1153,7 +1153,7 @@ westerndigitalhung(Drive *d)
 	}
 }
 
-static uint16_t olds[NCtlr * NCtlrdrv];
+static u16 olds[NCtlr * NCtlrdrv];
 
 static int
 doportreset(Drive *d)
@@ -1193,7 +1193,7 @@ statechange(Drive *d)
 static void
 checkdrive(Drive *d, int i)
 {
-	uint16_t s;
+	u16 s;
 	char *name;
 
 	if(d == nil){
@@ -1316,9 +1316,9 @@ satakproc(void *v)
 }
 
 static void
-isctlrjabbering(Ctlr *c, uint32_t cause)
+isctlrjabbering(Ctlr *c, u32 cause)
 {
-	uint32_t now;
+	u32 now;
 
 	now = TK2MS(sys->ticks);
 	if(now > c->lastintr0){
@@ -1336,7 +1336,7 @@ isctlrjabbering(Ctlr *c, uint32_t cause)
 static void
 isdrivejabbering(Drive *d)
 {
-	uint32_t now;
+	u32 now;
 
 	now = TK2MS(sys->ticks);
 	if(now > d->lastintr0){
@@ -1354,7 +1354,7 @@ static void
 iainterrupt(Ureg *u, void *a)
 {
 	int i;
-	uint32_t cause, mask;
+	u32 cause, mask;
 	Ctlr *c;
 	Drive *d;
 
@@ -1393,7 +1393,7 @@ static void
 awaitspinup(Drive *d)
 {
 	int ms;
-	uint16_t s;
+	u16 s;
 	char *name;
 
 	ilock(&d->Lock);
@@ -1541,7 +1541,7 @@ iaonline(SDunit *unit)
 
 /* returns locked list! */
 static Alist *
-ahcibuild(Drive *d, unsigned char *cmd, void *data, int n, int64_t lba)
+ahcibuild(Drive *d, unsigned char *cmd, void *data, int n, i64 lba)
 {
 	unsigned char *c, acmd, dir, llba;
 	Alist *l;
@@ -1584,7 +1584,7 @@ ahcibuild(Drive *d, unsigned char *cmd, void *data, int n, int64_t lba)
 	c[14] = 0;	/* r */
 	c[15] = 0;	/* control */
 
-	*(uint32_t *)(c + 16) = 0;
+	*(u32 *)(c + 16) = 0;
 
 	l->flags = 1 << 16 | Lpref | 0x5; /* Lpref ?? */
 	if(dir == Write)
@@ -1636,9 +1636,9 @@ ahcibuildpkt(Aportm *pm, SDreq *r, void *data, int n)
 	c[6] = n >> 8; /* cylinder hi		lba hi	23:16 */
 	c[7] = Obs;
 
-	*(uint32_t *)(c + 8) = 0;
-	*(uint32_t *)(c + 12) = 0;
-	*(uint32_t *)(c + 16) = 0;
+	*(u32 *)(c + 8) = 0;
+	*(u32 *)(c + 12) = 0;
+	*(u32 *)(c + 16) = 0;
 
 	l->flags = 1 << 16 | Lpref | Latapi | 0x5;
 	if(r->write != 0 && data)
@@ -1661,7 +1661,7 @@ ahcibuildpkt(Aportm *pm, SDreq *r, void *data, int n)
 static int
 waitready(Drive *d)
 {
-	uint32_t s, i, delta;
+	u32 s, i, delta;
 
 	for(i = 0; i < 15000; i += 250){
 		if(d->state == Dreset || d->state == Dportreset ||
@@ -1834,7 +1834,7 @@ iario(SDreq *r)
 {
 	Proc *up = externup();
 	int i, n, count, try, max, flag, task;
-	int64_t lba;
+	i64 lba;
 	char *name;
 	unsigned char *cmd, *data;
 	Aport *p;
@@ -2060,7 +2060,7 @@ static SDev *
 iapnp(void)
 {
 	int n, nunit, type;
-	uintptr_t io;
+	uintptr io;
 	Ctlr *c;
 	Pcidev *p;
 	SDev *head, *tail, *s;
@@ -2093,7 +2093,7 @@ iapnp(void)
 			      Tname(c), io, p->did);
 			continue;
 		}
-		c->lmmio = (uint32_t *)c->mmio;
+		c->lmmio = (u32 *)c->mmio;
 		c->pci = p;
 		c->type = type;
 
@@ -2186,7 +2186,7 @@ iarctl(SDunit *u, char *p, int l)
 static void
 runflushcache(Drive *d)
 {
-	int32_t t0;
+	i32 t0;
 
 	t0 = sys->ticks;
 	if(flushcache(d) != 0)
@@ -2354,7 +2354,7 @@ portr(char *p, char *e, uint x)
 static char *
 iartopctl(SDev *sdev, char *p, char *e)
 {
-	uint32_t cap;
+	u32 cap;
 	char pr[25];
 	Ahba *hba;
 	Ctlr *ctlr;

sys/src/9/amd64/sipi.c

@@ -28,9 +28,9 @@ sipi(void)
 	Apic *apic;
 	volatile Mach *mach;
 	int apicno, i;
-	volatile uint64_t *sipiptr;
-	uintmem sipipa;
-	uint8_t *p;
+	volatile u64 *sipiptr;
+	u64 sipipa;
+	u8 *p;
 	extern void squidboy(int);
 	usize apsize;
 

sys/src/9/amd64/syscall.c

@@ -25,7 +25,7 @@
 extern int nosmp;
 
 typedef struct {
-	uintptr_t ip;
+	uintptr ip;
 	Ureg *arg0;
 	char *arg1;
 	char msg[ERRMAX];
@@ -37,7 +37,7 @@ typedef struct {
  *   Return user to state before notify()
  */
 void
-noted(Ureg *cur, uintptr_t arg0)
+noted(Ureg *cur, uintptr arg0)
 {
 	Proc *up = externup();
 	NFrame *nf;
@@ -106,8 +106,8 @@ noted(Ureg *cur, uintptr_t arg0)
 		nf->arg0 = &nf->ureg;
 		cur->bp = PTR2UINT(nf->arg0);
 		//	nf->ip = 0;
-		cur->di = (uint64_t)nf->arg0;
-		cur->si = (uint64_t)nf->arg1;
+		cur->di = (u64)nf->arg0;
+		cur->si = (u64)nf->arg1;
 		cur->sp = PTR2UINT(nf);
 		break;
 	default:
@@ -137,7 +137,7 @@ notify(Ureg *ureg)
 	int l;
 	Mpl pl;
 	Note note;
-	uintptr_t sp;
+	uintptr sp;
 	NFrame *nf;
 
 	/*
@@ -244,13 +244,13 @@ void
 syscall(unsigned int scallnr, Ureg *ureg)
 {
 	// can only handle 6 args right now.
-	uintptr_t a0, a1, a2, a3;
-	uintptr_t a4, a5;
-	uint64_t *retptr;
+	uintptr a0, a1, a2, a3;
+	uintptr a4, a5;
+	u64 *retptr;
 
 	Proc *up = externup();
 	if(up->plan9){
-		uint64_t *a = (void *)ureg->sp;
+		u64 *a = (void *)ureg->sp;
 		scallnr = ureg->bp + 1024;
 		if(0)
 			print("up %p plan9 %d sp %#lx bp %#lx\n", up, up->plan9, ureg->sp, scallnr);
@@ -259,7 +259,7 @@ syscall(unsigned int scallnr, Ureg *ureg)
 		switch(scallnr){
 		case SEEK:	  // oseek
 			retptr = (void *)a[i++];
-			validaddr(retptr, sizeof(uint64_t), 1);
+			validaddr(retptr, sizeof(u64), 1);
 			break;
 		}
 		a0 = a[i++];
@@ -279,9 +279,9 @@ syscall(unsigned int scallnr, Ureg *ureg)
 	if(0)
 		iprint("Syscall %d, %lx, %lx, %lx %lx %lx %lx\n", scallnr, a0, a1, a2, a3, a4, a5);
 	char *e;
-	uintptr_t sp;
+	uintptr sp;
 	int s;
-	int64_t startns, stopns;
+	i64 startns, stopns;
 	Ar0 ar0;
 	static Ar0 zar0;
 
@@ -418,7 +418,7 @@ syscall(unsigned int scallnr, Ureg *ureg)
 	}
 
 	if(up->strace_on){
-		uint8_t what = 'X';
+		u8 what = 'X';
 		stopns = todget(nil);
 		if(scallnr == RFORK && a0 & RFPROC && ar0.i > 0)
 			what = 'F';
@@ -429,7 +429,7 @@ syscall(unsigned int scallnr, Ureg *ureg)
 	}
 
 	if(up->procctl == Proc_tracesyscall){
-		uint8_t what = 'X';
+		u8 what = 'X';
 		stopns = todget(nil);
 		up->procctl = Proc_stopme;
 		if(scallnr == RFORK && a0 & RFPROC && ar0.i > 0)
@@ -468,10 +468,10 @@ syscall(unsigned int scallnr, Ureg *ureg)
 		hi("done kexit\n");
 }
 
-uintptr_t
-sysexecstack(uintptr_t stack, int argc)
+uintptr
+sysexecstack(uintptr stack, int argc)
 {
-	uintptr_t sp;
+	uintptr sp;
 	/*
 	 * Given a current bottom-of-stack and a count
 	 * of pointer arguments to be pushed onto it followed
@@ -503,10 +503,10 @@ sysexecstack(uintptr_t stack, int argc)
 }
 
 void *
-sysexecregs(uintptr_t entry, uint32_t ssize, void *tos)
+sysexecregs(uintptr entry, u32 ssize, void *tos)
 {
 	Proc *up = externup();
-	uintptr_t *sp;
+	uintptr *sp;
 	Ureg *ureg;
 
 	// We made sure it was correctly aligned in sysexecstack, above.
@@ -514,13 +514,13 @@ sysexecregs(uintptr_t entry, uint32_t ssize, void *tos)
 		print("your stack is wrong: stacksize is not 16-byte aligned: %d\n", ssize);
 		panic("misaligned stack in sysexecregs");
 	}
-	sp = (uintptr_t *)(USTKTOP - ssize);
+	sp = (uintptr *)(USTKTOP - ssize);
 
 	ureg = up->dbgreg;
 	ureg->sp = PTR2UINT(sp);
 	ureg->ip = entry;
 	ureg->type = 64; /* fiction for acid */
-	ureg->dx = (uintptr_t)tos;
+	ureg->dx = (uintptr)tos;
 
 	/*
 	 * return the address of kernel/user shared data

sys/src/9/amd64/tcore.c

@@ -138,10 +138,10 @@ extern int notify(Ureg *);
  * interrupted while issuing the ICC.
  */
 int
-runac(Mach *mp, APfunc func, int flushtlb, void *a, int32_t n)
+runac(Mach *mp, APfunc func, int flushtlb, void *a, i32 n)
 {
 	Proc *up = externup();
-	uint8_t *dpg, *spg;
+	u8 *dpg, *spg;
 
 	if(n > sizeof(mp->NIX.icc->data))
 		panic("runac: args too long");
@@ -241,7 +241,7 @@ runacore(void)
 	void (*fn)(void);
 	int rc, flush, s;
 	char *n;
-	uint64_t t1;
+	u64 t1;
 
 	if(waserror())
 		panic("runacore: error: %s\n", up->errstr);

sys/src/9/amd64/trap.c

@@ -36,8 +36,8 @@ static Vctl *vctl[256];
 
 typedef struct Intrtime Intrtime;
 struct Intrtime {
-	uint64_t count;
-	uint64_t cycles;
+	u64 count;
+	u64 cycles;
 };
 static Intrtime intrtimes[256];
 
@@ -149,17 +149,17 @@ intrdisable(void *vector)
 	return 0;
 }
 
-static int32_t
-irqmapread(Chan *c, void *vbuf, int32_t n, int64_t offset)
+static i32
+irqmapread(Chan *c, void *vbuf, i32 n, i64 offset)
 {
 	char *readtodo(void);
 	return readstr(offset, vbuf, n, readtodo());
 }
 
-static int32_t
-irqmapwrite(Chan *c, void *buf, int32_t n, int64_t offset)
+static i32
+irqmapwrite(Chan *c, void *buf, i32 n, i64 offset)
 {
-	int acpiirq(uint32_t tbdf, int irq);
+	int acpiirq(u32 tbdf, int irq);
 	int t, b, d, f, irq;
 	int *p[] = {&t, &b, &d, &f, &irq};
 	Cmdbuf *cb;
@@ -174,20 +174,20 @@ irqmapwrite(Chan *c, void *buf, int32_t n, int64_t offset)
 	return -1;
 }
 
-static int32_t
-irqenablewrite(Chan *c, void *vbuf, int32_t n, int64_t offset)
+static i32
+irqenablewrite(Chan *c, void *vbuf, i32 n, i64 offset)
 {
 	void irqenable(void);
 	irqenable();
 	return n;
 }
 
-static int32_t
-irqallocread(Chan *c, void *vbuf, int32_t n, int64_t offset)
+static i32
+irqallocread(Chan *c, void *vbuf, i32 n, i64 offset)
 {
 	char *buf, *p, str[2 * (11 + 1) + 2 * (20 + 1) + (KNAMELEN + 1) + (8 + 1) + 1];
 	int m, vno;
-	int32_t oldn;
+	i32 oldn;
 	Intrtime *t;
 	Vctl *v;
 
@@ -325,7 +325,7 @@ void
 intrtime(int vno)
 {
 	Proc *up = externup();
-	uint64_t diff, x;
+	u64 diff, x;
 
 	x = perfticks();
 	diff = x - machp()->perf.intrts;
@@ -351,7 +351,7 @@ void
 kexit(Ureg *u)
 {
 	Proc *up = externup();
-	uint64_t t;
+	u64 t;
 	Tos *tos;
 	Mach *mp;
 
@@ -388,11 +388,11 @@ kstackok(void)
 	Proc *up = externup();
 
 	if(up == nil){
-		uintptr_t *stk = (uintptr_t *)machp()->stack;
+		uintptr *stk = (uintptr *)machp()->stack;
 		if(*stk != STACKGUARD)
 			panic("trap: mach %d machstk went through bottom %p\n", machp()->machno, machp()->stack);
 	} else {
-		uintptr_t *stk = (uintptr_t *)up->kstack;
+		uintptr *stk = (uintptr *)up->kstack;
 		if(*stk != STACKGUARD)
 			panic("trap: proc %d kstack went through bottom %p\n", up->pid, up->kstack);
 	}
@@ -430,7 +430,7 @@ trap(Ureg *ureg)
 	// cache the previous vno to see what might be causing
 	// trouble
 	vno = ureg->type;
-	uint64_t gsbase = rdmsr(GSbase);
+	u64 gsbase = rdmsr(GSbase);
 	//if (sce > scx) iprint("====================");
 	lastvno = vno;
 	if(gsbase < KZERO)
@@ -629,7 +629,7 @@ static void
 dumpstackwithureg(Ureg *ureg)
 {
 	Proc *up = externup();
-	uintptr_t l, v, i, estack;
+	uintptr l, v, i, estack;
 	//	extern char etext;
 	int x;
 
@@ -644,9 +644,9 @@ dumpstackwithureg(Ureg *ureg)
 	i = 0;
 	if(up != nil
 	   //	&& (uintptr)&l >= (uintptr)up->kstack
-	   && (uintptr_t)&l <= (uintptr_t)up->kstack + KSTACK)
-		estack = (uintptr_t)up->kstack + KSTACK;
-	else if((uintptr_t)&l >= machp()->stack && (uintptr_t)&l <= machp()->stack + MACHSTKSZ)
+	   && (uintptr)&l <= (uintptr)up->kstack + KSTACK)
+		estack = (uintptr)up->kstack + KSTACK;
+	else if((uintptr)&l >= machp()->stack && (uintptr)&l <= machp()->stack + MACHSTKSZ)
 		estack = machp()->stack + MACHSTKSZ;
 	else {
 		if(up != nil)
@@ -657,9 +657,9 @@ dumpstackwithureg(Ureg *ureg)
 	}
 	x += iprint("estackx %#p\n", estack);
 
-	for(l = (uintptr_t)&l; l < estack; l += sizeof(uintptr_t)){
-		v = *(uintptr_t *)l;
-		if((KTZERO < v && v < (uintptr_t)&etext) || ((uintptr_t)&l < v && v < estack) || estack - l < 256){
+	for(l = (uintptr)&l; l < estack; l += sizeof(uintptr)){
+		v = *(uintptr *)l;
+		if((KTZERO < v && v < (uintptr)&etext) || ((uintptr)&l < v && v < estack) || estack - l < 256){
 			x += iprint("%#16.16p=%#16.16p ", l, v);
 			i++;
 		}
@@ -714,7 +714,7 @@ static void
 faultamd64(Ureg *ureg, void *v)
 {
 	Proc *up = externup();
-	uint64_t addr;
+	u64 addr;
 	int ftype, user, insyscall;
 	char buf[ERRMAX];
 
@@ -769,7 +769,7 @@ faultamd64(Ureg *ureg, void *v)
 /*
  *  return the userpc the last exception happened at
  */
-uintptr_t
+uintptr
 userpc(Ureg *ureg)
 {
 	Proc *up = externup();
@@ -785,7 +785,7 @@ userpc(Ureg *ureg)
 void
 setregisters(Ureg *ureg, char *pureg, char *uva, int n)
 {
-	uint64_t cs, flags, ss;
+	u64 cs, flags, ss;
 
 	ss = ureg->ss;
 	flags = ureg->flags;
@@ -806,7 +806,7 @@ setkernur(Ureg *ureg, Proc *p)
 	ureg->sp = p->sched.sp + BY2SE;
 }
 
-uintptr_t
+uintptr
 dbgpc(Proc *p)
 {
 	Ureg *ureg;

sys/src/9/amd64/usbehci.h

@@ -165,20 +165,20 @@ enum {
  * Capability registers (hw)
  */
 struct Ecapio {
-	uint32_t cap;	    /* 00 controller capability register */
-	uint32_t parms;	    /* 04 structural parameters register */
-	uint32_t capparms;  /* 08 capability parameters */
-	uint32_t portroute; /* 0c not on the CS5536 */
+	u32 cap;	    /* 00 controller capability register */
+	u32 parms;	    /* 04 structural parameters register */
+	u32 capparms;  /* 08 capability parameters */
+	u32 portroute; /* 0c not on the CS5536 */
 };
 
 /*
  * Debug port registers (hw)
  */
 struct Edbgio {
-	uint32_t csw;	       /* control and status */
-	uint32_t pid;	       /* USB pid */
+	u32 csw;	       /* control and status */
+	u32 pid;	       /* USB pid */
 	unsigned char data[8]; /* data buffer */
-	uint32_t addr;	       /* device and endpoint addresses */
+	u32 addr;	       /* device and endpoint addresses */
 };
 #endif
 
@@ -199,14 +199,14 @@ struct Ctlr {
 	Eopio *opio;   /* Operational i/o regs */
 
 	int nframes;	  /* 1024, 512, or 256 frames in the list */
-	uint32_t *frames; /* periodic frame list (hw) */
+	u32 *frames; /* periodic frame list (hw) */
 	Qh *qhs;	  /* async Qh circular list for bulk/ctl */
 	Qtree *tree;	  /* tree of Qhs for the periodic list */
 	int ntree;	  /* number of dummy qhs in tree */
 	Qh *intrqhs;	  /* list of (not dummy) qhs in tree  */
 	Isoio *iso;	  /* list of active Iso I/O */
-	uint32_t load;
-	uint32_t isoload;
+	u32 load;
+	u32 isoload;
 	int nintr;    /* number of interrupts attended */
 	int ntdintr;  /* number of intrs. with something to do */
 	int nqhintr;  /* number of async td intrs. */
@@ -223,16 +223,16 @@ struct Ctlr {
  * Operational registers (hw)
  */
 struct Eopio {
-	uint32_t cmd;			/* 00 command */
-	uint32_t sts;			/* 04 status */
-	uint32_t intr;			/* 08 interrupt enable */
-	uint32_t frno;			/* 0c frame index */
-	uint32_t seg;			/* 10 bits 63:32 of EHCI datastructs (unused) */
-	uint32_t frbase;		/* 14 frame list base addr, 4096-byte boundary */
-	uint32_t link;			/* 18 link for async list */
+	u32 cmd;			/* 00 command */
+	u32 sts;			/* 04 status */
+	u32 intr;			/* 08 interrupt enable */
+	u32 frno;			/* 0c frame index */
+	u32 seg;			/* 10 bits 63:32 of EHCI datastructs (unused) */
+	u32 frbase;		/* 14 frame list base addr, 4096-byte boundary */
+	u32 link;			/* 18 link for async list */
 	unsigned char d2c[0x40 - 0x1c]; /* 1c dummy */
-	uint32_t config;		/* 40 1: all ports default-routed to this HC */
-	uint32_t portsc[1];		/* 44 Port status and control, one per port */
+	u32 config;		/* 40 1: all ports default-routed to this HC */
+	u32 portsc[1];		/* 44 Port status and control, one per port */
 };
 
 extern int ehcidebug;

sys/src/9/amd64/usbehcipc.c

@@ -157,7 +157,7 @@ scanpci(void)
 {
 	static int already = 0;
 	int i;
-	uint32_t io;
+	u32 io;
 	Ctlr *ctlr;
 	Pcidev *p;
 	Ecapio *capio;

sys/src/9/amd64/usbohci.c

@@ -181,10 +181,10 @@ enum {
  * Endpoint descriptor. (first 4 words used by hardware)
  */
 struct Ed {
-	uint32_t ctrl;
-	uint32_t tail; /* transfer descriptor */
-	uint32_t head;
-	uint32_t nexted;
+	u32 ctrl;
+	u32 tail; /* transfer descriptor */
+	u32 head;
+	u32 nexted;
 
 	Ed *next;  /* sw; in free list or next in list */
 	Td *tds;   /* in use by current xfer; all for iso */
@@ -201,13 +201,13 @@ struct Qio {
 	Ed *ed;		/* to place Tds on it */
 	int sched;	/* queue number (intr/iso) */
 	int toggle;	/* Tddata0/Tddata1 */
-	uint32_t usbid; /* device/endpoint address */
+	u32 usbid; /* device/endpoint address */
 	int tok;	/* Tdsetup, Tdtokin, Tdtokout */
-	int64_t iotime; /* last I/O time; to hold interrupt polls */
+	i64 iotime; /* last I/O time; to hold interrupt polls */
 	int debug;	/* for the endpoint */
 	char *err;	/* error status */
 	int state;	/* Qidle -> Qinstall -> Qrun -> Qdone | Qclose */
-	int32_t bw;	/* load (intr/iso) */
+	i32 bw;	/* load (intr/iso) */
 };
 
 struct Ctlio {
@@ -221,8 +221,8 @@ struct Isoio {
 	int nframes;   /* number of frames for a full second */
 	Td *atds;      /* Tds avail for further I/O */
 	int navail;    /* number of avail Tds */
-	uint32_t frno; /* next frame number avail for I/O */
-	uint32_t left; /* remainder after rounding Hz to samples/ms */
+	u32 frno; /* next frame number avail for I/O */
+	u32 left; /* remainder after rounding Hz to samples/ms */
 	int nerrs;     /* consecutive errors on iso I/O */
 };
 
@@ -231,33 +231,33 @@ struct Isoio {
  * First block is used by hardware (aligned to 32).
  */
 struct Td {
-	uint32_t ctrl;
-	uint32_t cbp; /* current buffer pointer */
-	uint32_t nexttd;
-	uint32_t be;
-	uint16_t offsets[8]; /* used by Iso Tds only */
+	u32 ctrl;
+	u32 cbp; /* current buffer pointer */
+	u32 nexttd;
+	u32 be;
+	u16 offsets[8]; /* used by Iso Tds only */
 
-	uint32_t nbytes; /* bytes in this Td */
-	uint32_t cbp0;	 /* initial value for cbp */
-	uint32_t last;	 /* true for last Td in Qio */
-	uint32_t _160[5];
+	u32 nbytes; /* bytes in this Td */
+	u32 cbp0;	 /* initial value for cbp */
+	u32 last;	 /* true for last Td in Qio */
+	u32 _160[5];
 
 	Td *next;  /* in free or Ed tds list */
 	Td *anext; /* in avail td list (iso) */
 	Ep *ep;	   /* using this Td for I/O */
 	Qio *io;   /* using this Td for I/O */
 	Block *bp; /* data for this Td */
-	uint64_t _64[3];
+	u64 _64[3];
 };
 
 /*
  * Host controller communication area (hardware)
  */
 struct Hcca {
-	uint32_t intrtable[32];
-	uint16_t framenumber;
-	uint16_t _16;
-	uint32_t donehead;
+	u32 intrtable[32];
+	u16 framenumber;
+	u16 _16;
+	u32 donehead;
 	unsigned char reserved[116];
 };
 
@@ -266,44 +266,44 @@ struct Hcca {
  */
 struct Ohci {
 	/* control and status group */
-	uint32_t revision;    /*00*/
-	uint32_t control;     /*04*/
-	uint32_t cmdsts;      /*08*/
-	uint32_t intrsts;     /*0c*/
-	uint32_t intrenable;  /*10*/
-	uint32_t intrdisable; /*14*/
+	u32 revision;    /*00*/
+	u32 control;     /*04*/
+	u32 cmdsts;      /*08*/
+	u32 intrsts;     /*0c*/
+	u32 intrenable;  /*10*/
+	u32 intrdisable; /*14*/
 
 	/* memory pointer group */
-	uint32_t hcca;	       /*18*/
-	uint32_t periodcurred; /*1c*/
-	uint32_t ctlheaded;    /*20*/
-	uint32_t ctlcurred;    /*24*/
-	uint32_t bulkheaded;   /*28*/
-	uint32_t bulkcurred;   /*2c*/
-	uint32_t donehead;     /*30*/
+	u32 hcca;	       /*18*/
+	u32 periodcurred; /*1c*/
+	u32 ctlheaded;    /*20*/
+	u32 ctlcurred;    /*24*/
+	u32 bulkheaded;   /*28*/
+	u32 bulkcurred;   /*2c*/
+	u32 donehead;     /*30*/
 
 	/* frame counter group */
-	uint32_t fminterval;	/*34*/
-	uint32_t fmremaining;	/*38*/
-	uint32_t fmnumber;	/*3c*/
-	uint32_t periodicstart; /*40*/
-	uint32_t lsthreshold;	/*44*/
+	u32 fminterval;	/*34*/
+	u32 fmremaining;	/*38*/
+	u32 fmnumber;	/*3c*/
+	u32 periodicstart; /*40*/
+	u32 lsthreshold;	/*44*/
 
 	/* root hub group */
-	uint32_t rhdesca;	/*48*/
-	uint32_t rhdescb;	/*4c*/
-	uint32_t rhsts;		/*50*/
-	uint32_t rhportsts[15]; /*54*/
-	uint32_t _640[20];	/*90*/
+	u32 rhdesca;	/*48*/
+	u32 rhdescb;	/*4c*/
+	u32 rhsts;		/*50*/
+	u32 rhportsts[15]; /*54*/
+	u32 _640[20];	/*90*/
 
 	/* unknown */
-	uint32_t hostueaddr;	  /*e0*/
-	uint32_t hostuests;	  /*e4*/
-	uint32_t hosttimeoutctrl; /*e8*/
-	uint32_t _32_1;		  /*ec*/
-	uint32_t _32_2;		  /*f0*/
-	uint32_t hostrevision;	  /*f4*/
-	uint32_t _64[2];
+	u32 hostueaddr;	  /*e0*/
+	u32 hostuests;	  /*e4*/
+	u32 hosttimeoutctrl; /*e8*/
+	u32 _32_1;		  /*ec*/
+	u32 _32_2;		  /*f0*/
+	u32 hostrevision;	  /*f4*/
+	u32 _64[2];
 	/*100*/
 };
 
@@ -313,7 +313,7 @@ struct Ohci {
 struct Qtree {
 	int nel;
 	int depth;
-	uint32_t *bw;
+	u32 *bw;
 	Ed **root;
 };
 
@@ -400,7 +400,7 @@ static char *errmsgs[] =
 		[Tdnotacc] = "not accessed"};
 
 static void *
-pa2ptr(uint32_t pa)
+pa2ptr(u32 pa)
 {
 	if(pa == 0)
 		return nil;
@@ -408,7 +408,7 @@ pa2ptr(uint32_t pa)
 		return KADDR(pa);
 }
 
-static uint32_t
+static u32
 ptr2pa(void *p)
 {
 	if(p == nil)
@@ -528,9 +528,9 @@ unlinkbulk(Ctlr *ctlr, Ed *ed)
 }
 
 static void
-edsetaddr(Ed *ed, uint32_t addr)
+edsetaddr(Ed *ed, u32 addr)
 {
-	uint32_t ctrl;
+	u32 ctrl;
 
 	ctrl = ed->ctrl & ~((Epmax << 7) | Devmax);
 	ctrl |= (addr & ((Epmax << 7) | Devmax));
@@ -569,7 +569,7 @@ edmaxpkt(Ed *ed)
 static void
 edsetmaxpkt(Ed *ed, int m)
 {
-	uint32_t c;
+	u32 c;
 
 	c = ed->ctrl & ~(Edmpsmask << Edmpsshift);
 	ed->ctrl = c | ((m & Edmpsmask) << Edmpsshift);
@@ -615,7 +615,7 @@ tdalloc(void)
 	memset(td, 0, sizeof(Td));
 	unlock(&tdpool.l);
 
-	if(((uint64_t)td & 0xF) != 0)
+	if(((u64)td & 0xF) != 0)
 		panic("usbohci: tdalloc td 0x%p (not 16-aligned)", td);
 	return td;
 }
@@ -724,10 +724,10 @@ flog2lower(int n)
 }
 
 static int
-pickschedq(Qtree *qt, int pollival, uint32_t bw, uint32_t limit)
+pickschedq(Qtree *qt, int pollival, u32 bw, u32 limit)
 {
 	int i, j, d, upperb, q;
-	uint32_t best, worst, total;
+	u32 best, worst, total;
 
 	d = flog2lower(pollival);
 	if(d > qt->depth)
@@ -979,7 +979,7 @@ seprintep(char *s, char *e, Ep *ep)
 }
 
 static char *
-seprintctl(char *s, char *se, uint32_t ctl)
+seprintctl(char *s, char *se, u32 ctl)
 {
 	s = seprint(s, se, "en=");
 	if((ctl & Cple) != 0)
@@ -1057,7 +1057,7 @@ static void
 isodtdinit(Ep *ep, Isoio *iso, Td *td)
 {
 	Block *bp;
-	int32_t size;
+	i32 size;
 	int i;
 
 	bp = td->bp;
@@ -1269,7 +1269,7 @@ interrupt(Ureg *ureg, void *arg)
 	Td *td, *ntd;
 	Hci *hp;
 	Ctlr *ctlr;
-	uint32_t status, curred;
+	u32 status, curred;
 	int i, frno;
 
 	hp = arg;
@@ -1409,7 +1409,7 @@ epiodone(void *a)
 }
 
 static void
-epiowait(Ctlr *ctlr, Qio *io, int tmout, uint32_t n)
+epiowait(Ctlr *ctlr, Qio *io, int tmout, u32 n)
 {
 	Proc *up = externup();
 	Ed *ed;
@@ -1455,8 +1455,8 @@ epiowait(Ctlr *ctlr, Qio *io, int tmout, uint32_t n)
  * To make it work for control transfers, the caller may
  * lock the Qio for the entire control transfer.
  */
-static int32_t
-epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
+static i32
+epio(Ep *ep, Qio *io, void *a, i32 count, int mustlock)
 {
 	Proc *up = externup();
 	Ed *ed;
@@ -1466,8 +1466,8 @@ epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
 	unsigned char *c;
 	Td *td, *ltd, *ntd, *td0;
 	int last, ntds, tmout;
-	int32_t tot, n;
-	uint32_t load;
+	i32 tot, n;
+	u32 load;
 
 	ed = io->ed;
 	ctlr = ep->hp->Hciimpl.aux;
@@ -1607,14 +1607,14 @@ clrhalt(Ep *ep)
 	}
 }
 
-static int32_t
-epread(Ep *ep, void *a, int32_t count)
+static i32
+epread(Ep *ep, void *a, i32 count)
 {
 	Proc *up = externup();
 	Ctlio *cio;
 	Qio *io;
 	char buf[80];
-	uint64_t delta;
+	u64 delta;
 
 	if(ep->aux == nil)
 		panic("epread: not open");
@@ -1685,12 +1685,12 @@ epread(Ep *ep, void *a, int32_t count)
  * Upon errors on the data phase we must still run the status
  * phase or the device may cease responding in the future.
  */
-static int32_t
-epctlio(Ep *ep, Ctlio *cio, void *a, int32_t count)
+static i32
+epctlio(Ep *ep, Ctlio *cio, void *a, i32 count)
 {
 	Proc *up = externup();
 	unsigned char *c;
-	int32_t len;
+	i32 len;
 
 	ddeprint("epctlio: cio %#p ep%d.%d count %ld\n",
 		 cio, ep->dev->nb, ep->nb, count);
@@ -1770,11 +1770,11 @@ epctlio(Ep *ep, Ctlio *cio, void *a, int32_t count)
  * Put new samples in the dummy Td.
  * BUG: This does only a transfer per Td. We could do up to 8.
  */
-static int32_t
-putsamples(Ctlr *ctlr, Ep *ep, Isoio *iso, unsigned char *b, int32_t count)
+static i32
+putsamples(Ctlr *ctlr, Ep *ep, Isoio *iso, unsigned char *b, i32 count)
 {
 	Td *td;
-	uint32_t n;
+	u32 n;
 
 	td = pa2ptr(iso->Qio.ed->tail);
 	n = count;
@@ -1791,11 +1791,11 @@ putsamples(Ctlr *ctlr, Ep *ep, Isoio *iso, unsigned char *b, int32_t count)
 	return n;
 }
 
-static int32_t
-episowrite(Ep *ep, void *a, int32_t count)
+static i32
+episowrite(Ep *ep, void *a, i32 count)
 {
 	Proc *up = externup();
-	int32_t tot, nw;
+	i32 tot, nw;
 	char *err;
 	unsigned char *b;
 	Ctlr *ctlr;
@@ -1857,15 +1857,15 @@ episowrite(Ep *ep, void *a, int32_t count)
 	return tot;
 }
 
-static int32_t
-epwrite(Ep *ep, void *a, int32_t count)
+static i32
+epwrite(Ep *ep, void *a, i32 count)
 {
 	Proc *up = externup();
 	Qio *io;
 	Ctlio *cio;
-	uint32_t delta;
+	u32 delta;
 	unsigned char *b;
-	int32_t tot, nw;
+	i32 tot, nw;
 
 	if(ep->aux == nil)
 		panic("ohci: epwrite: not open");
@@ -2028,7 +2028,7 @@ epopen(Ep *ep)
 	Ctlr *ctlr;
 	Qio *io;
 	Ctlio *cio;
-	uint32_t usbid;
+	u32 usbid;
 
 	ctlr = ep->hp->Hciimpl.aux;
 	deprint("ohci: epopen ep%d.%d\n", ep->dev->nb, ep->nb);
@@ -2251,7 +2251,7 @@ portstatus(Hci *hp, int port)
 {
 	int v;
 	Ctlr *ub;
-	uint32_t ohcistatus;
+	u32 ohcistatus;
 
 	/*
 	 * We must return status bits as a
@@ -2290,11 +2290,11 @@ static void
 dumpohci(Ctlr *ctlr)
 {
 	int i;
-	uint32_t *ohci;
+	u32 *ohci;
 
 	ohci = &ctlr->ohci->revision;
 	print("ohci registers: \n");
-	for(i = 0; i < sizeof(Ohci) / sizeof(uint32_t); i++)
+	for(i = 0; i < sizeof(Ohci) / sizeof(u32); i++)
 		if(i < 3 || ohci[i] != 0)
 			print("\t[%#2.2x]\t%#8.8lx\n", i * 4, ohci[i]);
 	print("\n");
@@ -2306,7 +2306,7 @@ init(Hci *hp)
 	Ctlr *ctlr;
 	Ohci *ohci;
 	int i;
-	uint32_t ival, ctrl, fmi;
+	u32 ival, ctrl, fmi;
 
 	ctlr = hp->Hciimpl.aux;
 	dprint("ohci %#p init\n", ctlr->ohci);
@@ -2369,7 +2369,7 @@ init(Hci *hp)
 static void
 scanpci(void)
 {
-	uint32_t mem;
+	u32 mem;
 	Ctlr *ctlr;
 	Pcidev *p;
 	int i;

sys/src/9/amd64/usbuhci.c

@@ -155,9 +155,9 @@ struct Ctlr {
 	Qh *qhs;	  /* list of Qhs for this controller */
 	Qh *qh[Tmax];	  /* Dummy Qhs to insert Qhs after */
 	Isoio *iso;	  /* list of active iso I/O */
-	uint32_t *frames; /* frame list (used by hw) */
-	uint32_t load;	  /* max load for a single frame */
-	uint32_t isoload; /* max iso load for a single frame */
+	u32 *frames; /* frame list (used by hw) */
+	u32 load;	  /* max load for a single frame */
+	u32 isoload; /* max iso load for a single frame */
 	int nintr;	  /* number of interrupts attended */
 	int ntdintr;	  /* number of intrs. with something to do */
 	int nqhintr;	  /* number of intrs. for Qhs */
@@ -171,7 +171,7 @@ struct Qio {
 	int usbid;	 /* usb address for endpoint/device */
 	int toggle;	 /* Tddata0/Tddata1 */
 	int tok;	 /* Tdtoksetup, Tdtokin, Tdtokout */
-	uint32_t iotime; /* time of last I/O */
+	u32 iotime; /* time of last I/O */
 	int debug;	 /* debug flag from the endpoint */
 	char *err;	 /* error string */
 };
@@ -195,7 +195,7 @@ struct Isoio {
 	Td *tdi;	     /* next td processed by interrupt */
 	char *err;	     /* error string */
 	int nerrs;	     /* nb of consecutive I/O errors */
-	int32_t nleft;	     /* number of bytes left from last write */
+	i32 nleft;	     /* number of bytes left from last write */
 	int debug;	     /* debug flag from the endpoint */
 	Isoio *next;	     /* in list of active Isoios */
 	Td *tdps[Nframes];   /* pointer to Td used for i-th frame or nil */
@@ -236,11 +236,11 @@ struct Qhpool {
  * The Ctlr lock protects change of state for Qhs in use.
  */
 struct Qh {
-	uint32_t link;	/* link to next horiz. item (eg. Qh) */
-	uint32_t elink; /* link to element (eg. Td; updated by hw) */
+	u32 link;	/* link to next horiz. item (eg. Qh) */
+	u32 elink; /* link to element (eg. Td; updated by hw) */
 
-	uint32_t state; /* Qidle -> Qinstall -> Qrun -> Qdone | Qclose */
-	uint32_t _32;
+	u32 state; /* Qidle -> Qinstall -> Qrun -> Qdone | Qclose */
+	u32 _32;
 
 	Qio *io;  /* for this queue */
 	Qh *next; /* in active or free list */
@@ -260,13 +260,13 @@ struct Qh {
  * is free to use it and can be the only one using it.
  */
 struct Td {
-	uint32_t link;	 /* Link to next Td or Qh */
-	uint32_t csw;	 /* control and status word (updated by hw) */
-	uint32_t token;	 /* endpt, device, pid */
-	uint32_t buffer; /* buffer pointer */
+	u32 link;	 /* Link to next Td or Qh */
+	u32 csw;	 /* control and status word (updated by hw) */
+	u32 token;	 /* endpt, device, pid */
+	u32 buffer; /* buffer pointer */
 
 	Td *next;	     /* in qh or Isoio or free list */
-	uint32_t ndata;	     /* bytes available/used at data */
+	u32 ndata;	     /* bytes available/used at data */
 	unsigned char *data; /* pointer to actual data */
 	void *buff;	     /* allocated data, for large transfers */
 
@@ -455,7 +455,7 @@ isodump(Isoio *iso, int all)
 }
 
 static int
-sameptr(void *p, uintmem l)
+sameptr(void *p, u64 l)
 {
 	if(l & QHterm)
 		return p == nil;
@@ -491,7 +491,7 @@ qhdump(Qh *qh, char *pref)
 	char buf[256];
 	char *s;
 	char *se;
-	uintmem td;
+	u64 td;
 	int i;
 
 	s = buf;
@@ -611,7 +611,7 @@ tdalloc(void)
 
 	memset(td, 0, sizeof(Td));
 	td->link = Tdterm;
-	assert(((uint64_t)td & 0xF) == 0);
+	assert(((u64)td & 0xF) == 0);
 	return td;
 }
 
@@ -706,7 +706,7 @@ qhalloc(Ctlr *ctlr, Qh *prev, Qio *io, char *tag)
 		iunlock(&ctlr->l);
 	}
 
-	if(((uint64_t)qh & 0xF) != 0)
+	if(((u64)qh & 0xF) != 0)
 		panic("usbuhci: qhalloc qh 0x%p (not 16-aligned)", qh);
 	return qh;
 }
@@ -788,7 +788,7 @@ isocanwrite(void *a)
 }
 
 static void
-tdisoinit(Isoio *iso, Td *td, int32_t count)
+tdisoinit(Isoio *iso, Td *td, i32 count)
 {
 	td->ndata = count;
 	td->token = ((count - 1) << 21) | ((iso->usbid & 0x7FF) << 8) | iso->tok;
@@ -981,11 +981,11 @@ interrupt(Ureg *ureg, void *a)
  * iso->tdu is the next place to put data. When it gets full
  * it is activated and tdu advanced.
  */
-static int32_t
-putsamples(Isoio *iso, unsigned char *b, int32_t count)
+static i32
+putsamples(Isoio *iso, unsigned char *b, i32 count)
 {
-	int32_t tot;
-	int32_t n;
+	i32 tot;
+	i32 n;
 
 	for(tot = 0; isocanwrite(iso) && tot < count; tot += n){
 		n = count - tot;
@@ -1006,8 +1006,8 @@ putsamples(Isoio *iso, unsigned char *b, int32_t count)
  * Queue data for writing and return error status from
  * last writes done, to maintain buffered data.
  */
-static int32_t
-episowrite(Ep *ep, Isoio *iso, void *a, int32_t count)
+static i32
+episowrite(Ep *ep, Isoio *iso, void *a, i32 count)
 {
 	Proc *up = externup();
 	Ctlr *ctlr;
@@ -1074,7 +1074,7 @@ episowrite(Ep *ep, Isoio *iso, void *a, int32_t count)
 /*
  * Available data is kept at tdu and following tds, up to tdi (excluded).
  */
-static int32_t
+static i32
 episoread(Ep *ep, Isoio *iso, void *a, int count)
 {
 	Proc *up = externup();
@@ -1219,7 +1219,7 @@ epiodone(void *a)
 }
 
 static void
-epiowait(Ctlr *ctlr, Qio *io, int tmout, uint32_t load)
+epiowait(Ctlr *ctlr, Qio *io, int tmout, u32 load)
 {
 	Proc *up = externup();
 	Qh *qh;
@@ -1265,18 +1265,18 @@ epiowait(Ctlr *ctlr, Qio *io, int tmout, uint32_t load)
  * To make it work for control transfers, the caller may
  * lock the Qio for the entire control transfer.
  */
-static int32_t
-epio(Ep *ep, Qio *io, void *a, int32_t count, int mustlock)
+static i32
+epio(Ep *ep, Qio *io, void *a, i32 count, int mustlock)
 {
 	Proc *up = externup();
 	Td *td, *ltd, *td0, *ntd;
 	Ctlr *ctlr;
 	Qh *qh;
-	int32_t n, tot;
+	i32 n, tot;
 	char buf[128];
 	unsigned char *c;
 	int saved, ntds, tmout;
-	uint32_t load;
+	u32 load;
 	char *err;
 
 	qh = io->qh;
@@ -1414,15 +1414,15 @@ clrhalt(Ep *ep)
 	}
 }
 
-static int32_t
-epread(Ep *ep, void *a, int32_t count)
+static i32
+epread(Ep *ep, void *a, i32 count)
 {
 	Proc *up = externup();
 	Ctlio *cio;
 	Qio *io;
 	Isoio *iso;
 	char buf[160];
-	uint32_t delta;
+	u32 delta;
 
 	ddeprint("uhci: epread\n");
 	if(ep->aux == nil)
@@ -1494,12 +1494,12 @@ epread(Ep *ep, void *a, int32_t count)
  * Upon errors on the data phase we must still run the status
  * phase or the device may cease responding in the future.
  */
-static int32_t
-epctlio(Ep *ep, Ctlio *cio, void *a, int32_t count)
+static i32
+epctlio(Ep *ep, Ctlio *cio, void *a, i32 count)
 {
 	Proc *up = externup();
 	unsigned char *c;
-	int32_t len;
+	i32 len;
 
 	ddeprint("epctlio: cio %#p ep%d.%d count %ld\n",
 		 cio, ep->dev->nb, ep->nb, count);
@@ -1569,14 +1569,14 @@ epctlio(Ep *ep, Ctlio *cio, void *a, int32_t count)
 	return count;
 }
 
-static int32_t
-epwrite(Ep *ep, void *a, int32_t count)
+static i32
+epwrite(Ep *ep, void *a, i32 count)
 {
 	Proc *up = externup();
 	Ctlio *cio;
 	Isoio *iso;
 	Qio *io;
-	uint32_t delta;
+	u32 delta;
 	char *b;
 	int tot;
 	int nw;
@@ -1829,11 +1829,11 @@ cancelio(Ctlr *ctlr, Qio *io)
 }
 
 static void
-cancelisoio(Ctlr *ctlr, Isoio *iso, int pollival, uint32_t load)
+cancelisoio(Ctlr *ctlr, Isoio *iso, int pollival, u32 load)
 {
 	Proc *up = externup();
 	Isoio **il;
-	uint32_t *lp;
+	u32 *lp;
 	int i;
 	int frno;
 	Td *td;
@@ -2175,7 +2175,7 @@ uhcimeminit(Ctlr *ctlr)
 	if(0)
 		qh->link = PADDR(ctlr->qhs);
 
-	frsize = Nframes * sizeof(uint32_t);
+	frsize = Nframes * sizeof(u32);
 	ctlr->frames = mallocalign(frsize, frsize, 0, 0);
 	if(ctlr->frames == nil)
 		panic("uhci reset: no memory");

sys/src/9/amd64/vga.c

@@ -32,7 +32,7 @@ Lock vgascreenlock;
 int drawdebug;
 
 void
-vgaimageinit(uint32_t chan)
+vgaimageinit(u32 chan)
 {
 	if(back == nil){
 		back = allocmemimage(Rect(0, 0, 1, 1), chan); /* RSC BUG */
@@ -256,7 +256,7 @@ vgablank(VGAscr *scr, int blank)
 }
 
 void
-addvgaseg(char *name, uint32_t pa, uint32_t size)
+addvgaseg(char *name, u32 pa, u32 size)
 {
 	Physseg seg;
 

sys/src/9/amd64/vgax.c

@@ -24,7 +24,7 @@
 static Lock vgaxlock; /* access to index registers */
 
 int
-vgaxi(int32_t port, unsigned char index)
+vgaxi(i32 port, unsigned char index)
 {
 	unsigned char data;
 
@@ -70,7 +70,7 @@ vgaxi(int32_t port, unsigned char index)
 }
 
 int
-vgaxo(int32_t port, unsigned char index, unsigned char data)
+vgaxo(i32 port, unsigned char index, unsigned char data)
 {
 	ilock(&vgaxlock);
 	switch(port){

sys/src/9/amd64/vsvm.c

@@ -24,24 +24,24 @@
 #include "ureg.h"
 
 typedef struct Gd Gd;
-typedef uint64_t Sd;
-typedef uint16_t Ss;
+typedef u64 Sd;
+typedef u16 Ss;
 typedef struct Tss Tss;
 
 struct Gd {
 	Sd sd;
-	uint64_t hi;
+	u64 hi;
 };
 
 struct Tss {
-	uint32_t _0_;
-	uint32_t rsp0[2];
-	uint32_t rsp1[2];
-	uint32_t rsp2[2];
-	uint32_t _28_[2];
-	uint32_t ist[14];
-	uint16_t _92_[5];
-	uint16_t iomap;
+	u32 _0_;
+	u32 rsp0[2];
+	u32 rsp1[2];
+	u32 rsp2[2];
+	u32 _28_[2];
+	u32 ist[14];
+	u16 _92_[5];
+	u16 iomap;
 };
 
 enum {
@@ -69,7 +69,7 @@ static Gd idt64[Nidt];
 static Gd acidt64[Nidt]; /* NIX application core IDT */
 
 static Sd
-mksd(uint64_t base, uint64_t limit, uint64_t bits, uint64_t *upper)
+mksd(u64 base, u64 limit, u64 bits, u64 *upper)
 {
 	Sd sd;
 
@@ -83,7 +83,7 @@ mksd(uint64_t base, uint64_t limit, uint64_t bits, uint64_t *upper)
 }
 
 static void
-mkgd(Gd *gd, uint64_t offset, Ss ss, uint64_t bits, int ist)
+mkgd(Gd *gd, u64 offset, Ss ss, u64 bits, int ist)
 {
 	Sd sd;
 
@@ -96,10 +96,10 @@ mkgd(Gd *gd, uint64_t offset, Ss ss, uint64_t bits, int ist)
 }
 
 static void
-idtinit(Gd *gd, uintptr_t offset)
+idtinit(Gd *gd, uintptr offset)
 {
 	int ist, v;
-	uint64_t dpl;
+	u64 dpl;
 
 	for(v = 0; v < Nidt; v++){
 		ist = 0;
@@ -122,7 +122,7 @@ idtinit(Gd *gd, uintptr_t offset)
 }
 
 void
-tssrsp0(Mach *mach, uintptr_t sp)
+tssrsp0(Mach *mach, uintptr sp)
 {
 	Tss *tss;
 
@@ -132,7 +132,7 @@ tssrsp0(Mach *mach, uintptr_t sp)
 }
 
 static void
-tssinit(Mach *mach, uintptr_t sp)
+tssinit(Mach *mach, uintptr sp)
 {
 	int ist;
 	Tss *tss;
@@ -160,7 +160,7 @@ void
 vsvminit(int size, int nixtype, Mach *mach)
 {
 	Sd *sd;
-	uint64_t r;
+	u64 r;
 	if(mach->machno == 0){
 		idtinit(idt64, PTR2UINT(idthandlers));
 		idtinit(acidt64, PTR2UINT(acidthandlers));
@@ -200,8 +200,8 @@ vsvminit(int size, int nixtype, Mach *mach)
 	 * as-is. For the SS, 8 is added and you get the DS
 	 * shown above.
 	 */
-	r = ((uint64_t)SSEL(SiU32CS, SsRPL3)) << 48;
-	r |= ((uint64_t)SSEL(SiCS, SsRPL0)) << 32;
+	r = ((u64)SSEL(SiU32CS, SsRPL3)) << 48;
+	r |= ((u64)SSEL(SiCS, SsRPL0)) << 32;
 	wrmsr(Star, r);
 
 	if(nixtype != NIXAC)

sys/src/9/boot/boot.h

@@ -44,7 +44,7 @@ extern void key(int, Method *);
 extern int outin(char *, char *, int);
 extern int plumb(char *, char *, int *, char *);
 extern int readfile(char *, char *, int);
-extern int32_t readn(int, void *, int32_t);
+extern i32 readn(int, void *, i32);
 extern void run(char *file, ...);
 extern int sendmsg(int, char *);
 extern void setenv(char *, char *);

sys/src/9/boot/bootcache.c

@@ -11,7 +11,7 @@
 #include <libc.h>
 #include <../boot/boot.h>
 
-uint8_t statbuf[Statsz];
+u8 statbuf[Statsz];
 
 int
 cache(int fd)

sys/src/9/boot/bootip.c

@@ -13,13 +13,13 @@
 
 #include "boot.h"
 
-static uint8_t fsip[IPaddrlen];
-static uint8_t auip[IPaddrlen];
+static u8 fsip[IPaddrlen];
+static u8 auip[IPaddrlen];
 static char mpoint[32];
 
-static int isvalidip(uint8_t *);
-static void netndb(char *, uint8_t *);
-static void netenv(char *, uint8_t *);
+static int isvalidip(u8 *);
+static void netndb(char *, u8 *);
+static void netenv(char *, u8 *);
 
 void
 configip(int bargc, char **bargv, int needfs)
@@ -152,7 +152,7 @@ connecttcp(void)
 }
 
 static int
-isvalidip(uint8_t *ip)
+isvalidip(u8 *ip)
 {
 	if(ipcmp(ip, IPnoaddr) == 0)
 		return 0;
@@ -162,7 +162,7 @@ isvalidip(uint8_t *ip)
 }
 
 static void
-netenv(char *attr, uint8_t *ip)
+netenv(char *attr, u8 *ip)
 {
 	int fd, n;
 	char buf[128];
@@ -183,7 +183,7 @@ netenv(char *attr, uint8_t *ip)
 }
 
 static void
-netndb(char *attr, uint8_t *ip)
+netndb(char *attr, u8 *ip)
 {
 	int fd, n, c;
 	char buf[1024];

sys/src/9/boot/doauthenticate.c

@@ -15,8 +15,8 @@
 static char *pbmsg = "AS protocol botch";
 static char *ccmsg = "can't connect to AS";
 
-int32_t
-readn(int fd, void *buf, int32_t len)
+i32
+readn(int fd, void *buf, i32 len)
 {
 	int m, n;
 	char *p;

sys/src/9/boot/settime.c

@@ -13,7 +13,7 @@
 #include <fcall.h>
 #include "../boot/boot.h"
 
-static int32_t lusertime(char *);
+static i32 lusertime(char *);
 
 char *timeserver = "#s/boot";
 
@@ -149,11 +149,11 @@ yrsize(int y)
 /*
  *  compute seconds since Jan 1 1970
  */
-static int32_t
+static i32
 lusertime(char *argbuf)
 {
 	char *buf;
-	uint32_t secs;
+	u32 secs;
 	int i, y, m;
 	int *d2m;
 

sys/src/9/ip/arp.c

@@ -72,7 +72,7 @@ arpinit(Fs *f)
  *  create a new arp entry for an ip address.
  */
 static Arpent *
-newarp6(Arp *arp, uint8_t *ip, Ipifc *ifc, int addrxt)
+newarp6(Arp *arp, u8 *ip, Ipifc *ifc, int addrxt)
 {
 	uint t;
 	Block *next, *xp;
@@ -210,12 +210,12 @@ cleanarpent(Arp *arp, Arpent *a)
  *  waiting for ip->mac to be resolved.
  */
 Arpent *
-arpget(Arp *arp, Block *bp, int version, Ipifc *ifc, uint8_t *ip, uint8_t *mac)
+arpget(Arp *arp, Block *bp, int version, Ipifc *ifc, u8 *ip, u8 *mac)
 {
 	int hash;
 	Arpent *a;
 	Medium *type = ifc->medium;
-	uint8_t v6ip[IPaddrlen];
+	u8 v6ip[IPaddrlen];
 
 	if(version == V4){
 		v4tov6(v6ip, ip);
@@ -273,7 +273,7 @@ arprelease(Arp *arp, Arpent *arpen)
  * called with arp locked
  */
 Block *
-arpresolve(Arp *arp, Arpent *a, Medium *type, uint8_t *mac)
+arpresolve(Arp *arp, Arpent *a, Medium *type, u8 *mac)
 {
 	Block *bp;
 	Arpent *f, **l;
@@ -301,7 +301,7 @@ arpresolve(Arp *arp, Arpent *a, Medium *type, uint8_t *mac)
 }
 
 void
-arpenter(Fs *fs, int version, uint8_t *ip, uint8_t *mac, int n, int refresh)
+arpenter(Fs *fs, int version, u8 *ip, u8 *mac, int n, int refresh)
 {
 	Proc *up = externup();
 	Arp *arp;
@@ -310,7 +310,7 @@ arpenter(Fs *fs, int version, uint8_t *ip, uint8_t *mac, int n, int refresh)
 	Ipifc *ifc;
 	Medium *type;
 	Block *bp, *next;
-	uint8_t v6ip[IPaddrlen];
+	u8 v6ip[IPaddrlen];
 
 	arp = fs->arp;
 
@@ -415,7 +415,7 @@ arpwrite(Fs *fs, char *s, int len)
 	Arpent *a, *fl, **l;
 	Medium *medium;
 	char *f[4], buf[256];
-	uint8_t ip[IPaddrlen], mac[MAClen];
+	u8 ip[IPaddrlen], mac[MAClen];
 
 	arp = fs->arp;
 
@@ -529,14 +529,14 @@ enum {
 char *aformat = "%-6.6s %-8.8s %-40.40I %-32.32s\n";
 
 static void
-convmac(char *p, char *ep, uint8_t *mac, int n)
+convmac(char *p, char *ep, u8 *mac, int n)
 {
 	while(n-- > 0)
 		p = seprint(p, ep, "%2.2x", *mac++);
 }
 
 int
-arpread(Arp *arp, char *p, uint32_t offset, int len)
+arpread(Arp *arp, char *p, u32 offset, int len)
 {
 	Arpent *a;
 	int n;
@@ -574,9 +574,9 @@ rxmitsols(Arp *arp)
 	Block *next, *xp;
 	Arpent *a, *b, **l;
 	Fs *f;
-	uint8_t ipsrc[IPaddrlen];
+	u8 ipsrc[IPaddrlen];
 	Ipifc *ifc = nil;
-	int32_t nrxt;
+	i32 nrxt;
 
 	qlock(&arp->ql);
 	f = arp->f;
@@ -671,7 +671,7 @@ rxmitproc(void *v)
 {
 	Proc *up = externup();
 	Arp *arp = v;
-	int32_t wakeupat;
+	i32 wakeupat;
 
 	arp->rxmitp = up;
 	//print("arp rxmitproc started\n");

sys/src/9/ip/devip.c

@@ -65,7 +65,7 @@ Queue *qlog;
 
 extern void nullmediumlink(void);
 extern void pktmediumlink(void);
-int32_t ndbwrite(Fs *f, char *a, uint32_t off, int n);
+i32 ndbwrite(Fs *f, char *a, u32 off, int n);
 
 static int
 ip3gen(Chan *c, int i, Dir *dp)
@@ -139,7 +139,7 @@ ip1gen(Chan *c, int i, Dir *dp)
 	int prot;
 	int len = 0;
 	Fs *f;
-	extern uint32_t kerndate;
+	extern u32 kerndate;
 
 	f = ipfs[c->devno];
 
@@ -343,7 +343,7 @@ ipwalk(Chan *c, Chan *nc, char **name, int nname)
 }
 
 static int
-ipstat(Chan *c, uint8_t *db, int n)
+ipstat(Chan *c, u8 *db, int n)
 {
 	return devstat(c, db, n, nil, 0, ipgen);
 }
@@ -526,7 +526,7 @@ ipremove(Chan *c)
 }
 
 static int
-ipwstat(Chan *c, uint8_t *dp, int n)
+ipwstat(Chan *c, u8 *dp, int n)
 {
 	Dir d;
 	Conv *cv;
@@ -621,15 +621,15 @@ enum {
 	Statelen = 32 * 1024,
 };
 
-static int32_t
-ipread(Chan *ch, void *a, int32_t n, int64_t off)
+static i32
+ipread(Chan *ch, void *a, i32 n, i64 off)
 {
 	Conv *c;
 	Proto *x;
 	char *buf, *p;
-	int32_t rv;
+	i32 rv;
 	Fs *f;
-	uint32_t offset = off;
+	u32 offset = off;
 
 	f = ipfs[ch->devno];
 
@@ -713,7 +713,7 @@ ipread(Chan *ch, void *a, int32_t n, int64_t off)
 }
 
 static Block *
-ipbread(Chan *ch, int32_t n, int64_t offset)
+ipbread(Chan *ch, i32 n, i64 offset)
 {
 	Conv *c;
 	Proto *x;
@@ -772,7 +772,7 @@ setluniqueport(Conv *c, int lport)
  * is lport in use by anyone?
  */
 static int
-lportinuse(Proto *p, uint16_t lport)
+lportinuse(Proto *p, u16 lport)
 {
 	int x;
 
@@ -843,8 +843,8 @@ setladdrport(Conv *c, char *str, int announcing)
 {
 	char *p;
 	char *rv;
-	uint16_t lport;
-	uint8_t addr[IPaddrlen];
+	u16 lport;
+	u8 addr[IPaddrlen];
 
 	/*
 	 *  ignore restricted part if it exists.  it's
@@ -1087,18 +1087,18 @@ ttlctlmsg(Conv *c, Cmdbuf *cb)
 		c->ttl = atoi(cb->f[1]);
 }
 
-static int32_t
-ipwrite(Chan *ch, void *v, int32_t n, int64_t off)
+static i32
+ipwrite(Chan *ch, void *v, i32 n, i64 off)
 {
 	Proc *up = externup();
 	Conv *c;
 	Proto *x;
 	char *p;
 	Cmdbuf *cb;
-	uint8_t ia[IPaddrlen], ma[IPaddrlen];
+	u8 ia[IPaddrlen], ma[IPaddrlen];
 	Fs *f;
 	char *a;
-	uint32_t offset = off;
+	u32 offset = off;
 
 	a = v;
 	f = ipfs[ch->devno];
@@ -1194,8 +1194,8 @@ ipwrite(Chan *ch, void *v, int32_t n, int64_t off)
 	return n;
 }
 
-static int32_t
-ipbwrite(Chan *ch, Block *bp, int64_t offset)
+static i32
+ipbwrite(Chan *ch, Block *bp, i64 offset)
 {
 	Conv *c;
 	Proto *x;
@@ -1274,7 +1274,7 @@ Fsproto(Fs *f, Proto *p)
  *  built in
  */
 int
-Fsbuiltinproto(Fs *f, uint8_t proto)
+Fsbuiltinproto(Fs *f, u8 proto)
 {
 	return f->t2p[proto] != nil;
 }
@@ -1377,7 +1377,7 @@ Fsconnected(Conv *c, char *msg)
 }
 
 Proto *
-Fsrcvpcol(Fs *f, uint8_t proto)
+Fsrcvpcol(Fs *f, u8 proto)
 {
 	if(f->ipmux)
 		return f->ipmux;
@@ -1386,7 +1386,7 @@ Fsrcvpcol(Fs *f, uint8_t proto)
 }
 
 Proto *
-Fsrcvpcolx(Fs *f, uint8_t proto)
+Fsrcvpcolx(Fs *f, u8 proto)
 {
 	return f->t2p[proto];
 }
@@ -1395,7 +1395,8 @@ Fsrcvpcolx(Fs *f, uint8_t proto)
  *  called with protocol locked
  */
 Conv *
-Fsnewcall(Conv *c, uint8_t *raddr, uint16_t rport, uint8_t *laddr, uint16_t lport, uint8_t version)
+Fsnewcall(Conv *c, u8 *raddr, u16 rport, u8 *laddr, u16 lport,
+	  u8 version)
 {
 	Conv *nc;
 	Conv **l;
@@ -1439,8 +1440,8 @@ Fsnewcall(Conv *c, uint8_t *raddr, uint16_t rport, uint8_t *laddr, uint16_t lpor
 	return nc;
 }
 
-int32_t
-ndbwrite(Fs *f, char *a, uint32_t off, int n)
+i32
+ndbwrite(Fs *f, char *a, u32 off, int n)
 {
 	if(off > strlen(f->ndb))
 		error(Eio);
@@ -1453,7 +1454,7 @@ ndbwrite(Fs *f, char *a, uint32_t off, int n)
 	return n;
 }
 
-uint32_t
+u32
 scalednconv(void)
 {
 	if(cpuserver && conf.npage * PGSZ >= 128 * MB)

sys/src/9/ip/eipconvtest.c

@@ -27,16 +27,16 @@ uint8_t prefixvals[256] =
 		[0xFF] 8 | Isprefix,
 };
 
-uint8_t v4prefix[16] = {
+u8 v4prefix[16] = {
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0xff, 0xff,
 	0, 0, 0, 0};
 
 void
-hnputl(void *p, uint32_t v)
+hnputl(void *p, u32 v)
 {
-	uint8_t *a;
+	u8 *a;
 
 	a = p;
 	a[0] = v >> 24;
@@ -51,18 +51,18 @@ eipconv(va_list *arg, Fconv *f)
 	char buf[8 * 5];
 	static char *efmt = "%.2lux%.2lux%.2lux%.2lux%.2lux%.2lux";
 	static char *ifmt = "%d.%d.%d.%d";
-	uint8_t *p, ip[16];
-	uint32_t *lp;
-	uint16_t s;
+	u8 *p, ip[16];
+	u32 *lp;
+	u16 s;
 	int i, j, n, eln, eli;
 
 	switch(f->chr){
 	case 'E': /* Ethernet address */
-		p = va_arg(*arg, uint8_t *);
+		p = va_arg(*arg, u8 *);
 		sprint(buf, efmt, p[0], p[1], p[2], p[3], p[4], p[5]);
 		break;
 	case 'I': /* Ip address */
-		p = va_arg(*arg, uint8_t *);
+		p = va_arg(*arg, u8 *);
 	common:
 		if(memcmp(p, v4prefix, 12) == 0)
 			sprint(buf, ifmt, p[12], p[13], p[14], p[15]);
@@ -95,17 +95,17 @@ eipconv(va_list *arg, Fconv *f)
 		}
 		break;
 	case 'i': /* v6 address as 4 longs */
-		lp = va_arg(*arg, uint32_t *);
+		lp = va_arg(*arg, u32 *);
 		for(i = 0; i < 4; i++)
 			hnputl(ip + 4 * i, *lp++);
 		p = ip;
 		goto common;
 	case 'V': /* v4 ip address */
-		p = va_arg(*arg, uint8_t *);
+		p = va_arg(*arg, u8 *);
 		sprint(buf, ifmt, p[0], p[1], p[2], p[3]);
 		break;
 	case 'M': /* ip mask */
-		p = va_arg(*arg, uint8_t *);
+		p = va_arg(*arg, u8 *);
 
 		/* look for a prefix mask */
 		for(i = 0; i < 16; i++)
@@ -128,10 +128,10 @@ eipconv(va_list *arg, Fconv *f)
 		strcpy(buf, "(eipconv)");
 	}
 	strconv(buf, f);
-	return sizeof(uint8_t *);
+	return sizeof(u8 *);
 }
 
-uint8_t testvec[11][16] =
+u8 testvec[11][16] =
 	{
 		{
 			0,

sys/src/9/ip/esp.c

@@ -57,9 +57,9 @@ enum {
 };
 
 struct Esphdr {
-	uint8_t espspi[4]; /* Security parameter index */
-	uint8_t espseq[4]; /* Sequence number */
-	uint8_t payload[];
+	u8 espspi[4]; /* Security parameter index */
+	u8 espseq[4]; /* Sequence number */
+	u8 payload[];
 };
 
 /*
@@ -73,16 +73,16 @@ struct Esphdr {
  */
 struct Esp4hdr {
 	/* ipv4 header */
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* Identification */
-	uint8_t frag[2];   /* Fragment information */
-	uint8_t Unused;
-	uint8_t espproto;   /* Protocol */
-	uint8_t espplen[2]; /* Header plus data length */
-	uint8_t espsrc[4];  /* Ip source */
-	uint8_t espdst[4];  /* Ip destination */
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* Identification */
+	u8 frag[2];   /* Fragment information */
+	u8 Unused;
+	u8 espproto;   /* Protocol */
+	u8 espplen[2]; /* Header plus data length */
+	u8 espsrc[4];  /* Ip source */
+	u8 espdst[4];  /* Ip destination */
 
 	Esphdr;
 };
@@ -94,30 +94,30 @@ struct Esp6hdr {
 };
 
 struct Esptail {
-	uint8_t pad;
-	uint8_t nexthdr;
+	u8 pad;
+	u8 nexthdr;
 };
 
 /* IP-version-dependent data */
 typedef struct Versdep Versdep;
 struct Versdep {
-	uint32_t version;
-	uint32_t iphdrlen;
-	uint32_t hdrlen; /* iphdrlen + esp hdr len */
-	uint32_t spi;
-	uint8_t laddr[IPaddrlen];
-	uint8_t raddr[IPaddrlen];
+	u32 version;
+	u32 iphdrlen;
+	u32 hdrlen; /* iphdrlen + esp hdr len */
+	u32 spi;
+	u8 laddr[IPaddrlen];
+	u8 raddr[IPaddrlen];
 };
 
 /* header as seen by the user */
 struct Userhdr {
-	uint8_t nexthdr; /* next protocol */
-	uint8_t unused[3];
+	u8 nexthdr; /* next protocol */
+	u8 unused[3];
 };
 
 struct Esppriv {
-	uint64_t in;
-	uint32_t inerrors;
+	u64 in;
+	u32 inerrors;
 };
 
 /*
@@ -126,44 +126,44 @@ struct Esppriv {
 struct Espcb {
 	int incoming;
 	int header; /* user-level header */
-	uint32_t spi;
-	uint32_t seq;	 /* last seq sent */
-	uint32_t window; /* for replay attacks */
+	u32 spi;
+	u32 seq;	 /* last seq sent */
+	u32 window; /* for replay attacks */
 
 	char *espalg;
 	void *espstate; /* other state for esp */
 	int espivlen;	/* in bytes */
 	int espblklen;
-	int (*cipher)(Espcb *, uint8_t *buf, int len);
+	int (*cipher)(Espcb *, u8 *buf, int len);
 
 	char *ahalg;
 	void *ahstate; /* other state for esp */
 	int ahlen;     /* auth data length in bytes */
 	int ahblklen;
-	int (*auth)(Espcb *, uint8_t *buf, int len, uint8_t *hash);
+	int (*auth)(Espcb *, u8 *buf, int len, u8 *hash);
 	DigestState *ds;
 };
 
 struct Algorithm {
 	char *name;
 	int keylen; /* in bits */
-	void (*init)(Espcb *, char *name, uint8_t *key, unsigned keylen);
+	void (*init)(Espcb *, char *name, u8 *key, unsigned keylen);
 };
 
-static Conv *convlookup(Proto *esp, uint32_t spi);
+static Conv *convlookup(Proto *esp, u32 spi);
 static char *setalg(Espcb *ecb, char **f, int n, Algorithm *alg);
 static void espkick(void *x);
 
-static void nullespinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void des3espinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void aescbcespinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void aesctrespinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void desespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n);
+static void nullespinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void des3espinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void aescbcespinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void aesctrespinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void desespinit(Espcb *ecb, char *name, u8 *k, unsigned n);
 
-static void nullahinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void shaahinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void aesahinit(Espcb *, char *, uint8_t *key, unsigned keylen);
-static void md5ahinit(Espcb *, char *, uint8_t *key, unsigned keylen);
+static void nullahinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void shaahinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void aesahinit(Espcb *, char *, u8 *key, unsigned keylen);
+static void md5ahinit(Espcb *, char *, u8 *key, unsigned keylen);
 
 static Algorithm espalg[] =
 	{
@@ -212,7 +212,7 @@ static char *
 espconnect(Conv *c, char **argv, int argc)
 {
 	char *p, *pp, *e = nil;
-	uint32_t spi;
+	u32 spi;
 	Espcb *ecb = (Espcb *)c->ptcl;
 
 	switch(argc){
@@ -335,7 +335,7 @@ getverslens(int version, Versdep *vp)
 }
 
 static void
-getpktspiaddrs(uint8_t *pkt, Versdep *vp)
+getpktspiaddrs(u8 *pkt, Versdep *vp)
 {
 	Esp4hdr *eh4;
 	Esp6hdr *eh6;
@@ -366,7 +366,7 @@ static void
 espkick(void *x)
 {
 	int nexthdr, payload, pad, align;
-	uint8_t *auth;
+	u8 *auth;
 	Block *bp;
 	Conv *c = x;
 	Esp4hdr *eh4;
@@ -472,7 +472,7 @@ espiput(Proto *esp, Ipifc *ipifc, Block *bp)
 {
 	Proc *up = externup();
 	int payload, nexthdr;
-	uint8_t *auth, *espspi;
+	u8 *auth, *espspi;
 	Conv *c;
 	Espcb *ecb;
 	Esptail *et;
@@ -669,7 +669,7 @@ espremote(Conv *c, char *buf, int len)
 }
 
 static Conv *
-convlookup(Proto *esp, uint32_t spi)
+convlookup(Proto *esp, u32 spi)
 {
 	Conv *c, **p;
 	Espcb *ecb;
@@ -686,7 +686,7 @@ convlookup(Proto *esp, uint32_t spi)
 static char *
 setalg(Espcb *ecb, char **f, int n, Algorithm *alg)
 {
-	uint8_t *key;
+	u8 *key;
 	int c, nbyte, nchar;
 	uint i;
 
@@ -736,13 +736,13 @@ setalg(Espcb *ecb, char **f, int n, Algorithm *alg)
  */
 
 static int
-nullcipher(Espcb *espcb, uint8_t *c, int i)
+nullcipher(Espcb *espcb, u8 *c, int i)
 {
 	return 1;
 }
 
 static void
-nullespinit(Espcb *ecb, char *name, uint8_t *c, unsigned keylen)
+nullespinit(Espcb *ecb, char *name, u8 *c, unsigned keylen)
 {
 	ecb->espalg = name;
 	ecb->espblklen = 1;
@@ -751,13 +751,13 @@ nullespinit(Espcb *ecb, char *name, uint8_t *c, unsigned keylen)
 }
 
 static int
-nullauth(Espcb *espcb, uint8_t *c, int i, uint8_t *d)
+nullauth(Espcb *espcb, u8 *c, int i, u8 *d)
 {
 	return 1;
 }
 
 static void
-nullahinit(Espcb *ecb, char *name, uint8_t *c, unsigned keylen)
+nullahinit(Espcb *ecb, char *name, u8 *c, unsigned keylen)
 {
 	ecb->ahalg = name;
 	ecb->ahblklen = 1;
@@ -770,10 +770,11 @@ nullahinit(Espcb *ecb, char *name, uint8_t *c, unsigned keylen)
  */
 
 static void
-seanq_hmac_sha1(uint8_t hash[SHA1dlen], uint8_t *t, int32_t tlen, uint8_t *key, int32_t klen)
+seanq_hmac_sha1(u8 hash[SHA1dlen], u8 *t, i32 tlen, u8 *key,
+		i32 klen)
 {
 	int i;
-	uint8_t ipad[Hmacblksz + 1], opad[Hmacblksz + 1], innerhash[SHA1dlen];
+	u8 ipad[Hmacblksz + 1], opad[Hmacblksz + 1], innerhash[SHA1dlen];
 	DigestState *digest;
 
 	memset(ipad, 0x36, Hmacblksz);
@@ -790,20 +791,20 @@ seanq_hmac_sha1(uint8_t hash[SHA1dlen], uint8_t *t, int32_t tlen, uint8_t *key,
 }
 
 static int
-shaauth(Espcb *ecb, uint8_t *t, int tlen, uint8_t *auth)
+shaauth(Espcb *ecb, u8 *t, int tlen, u8 *auth)
 {
 	int r;
-	uint8_t hash[SHA1dlen];
+	u8 hash[SHA1dlen];
 
 	memset(hash, 0, SHA1dlen);
-	seanq_hmac_sha1(hash, t, tlen, (uint8_t *)ecb->ahstate, BITS2BYTES(128));
+	seanq_hmac_sha1(hash, t, tlen, (u8 *)ecb->ahstate, BITS2BYTES(128));
 	r = memcmp(auth, hash, ecb->ahlen) == 0;
 	memmove(auth, hash, ecb->ahlen);
 	return r;
 }
 
 static void
-shaahinit(Espcb *ecb, char *name, uint8_t *key, unsigned klen)
+shaahinit(Espcb *ecb, char *name, u8 *key, unsigned klen)
 {
 	if(klen != 128)
 		panic("shaahinit: bad keylen");
@@ -823,13 +824,13 @@ shaahinit(Espcb *ecb, char *name, uint8_t *key, unsigned klen)
 
 /* ah_aes_xcbc_mac_96, rfc3566 */
 static int
-aesahauth(Espcb *ecb, uint8_t *t, int tlen, uint8_t *auth)
+aesahauth(Espcb *ecb, u8 *t, int tlen, u8 *auth)
 {
 	int r;
-	uint8_t hash[AESdlen];
+	u8 hash[AESdlen];
 
 	memset(hash, 0, AESdlen);
-	ecb->ds = hmac_aes(t, tlen, (uint8_t *)ecb->ahstate, BITS2BYTES(96), hash,
+	ecb->ds = hmac_aes(t, tlen, (u8 *)ecb->ahstate, BITS2BYTES(96), hash,
 			   ecb->ds);
 	r = memcmp(auth, hash, ecb->ahlen) == 0;
 	memmove(auth, hash, ecb->ahlen);
@@ -837,7 +838,7 @@ aesahauth(Espcb *ecb, uint8_t *t, int tlen, uint8_t *auth)
 }
 
 static void
-aesahinit(Espcb *ecb, char *name, uint8_t *key, unsigned klen)
+aesahinit(Espcb *ecb, char *name, u8 *key, unsigned klen)
 {
 	if(klen != 128)
 		panic("aesahinit: keylen not 128");
@@ -852,10 +853,10 @@ aesahinit(Espcb *ecb, char *name, uint8_t *key, unsigned klen)
 }
 
 static int
-aescbccipher(Espcb *ecb, uint8_t *p, int n) /* 128-bit blocks */
+aescbccipher(Espcb *ecb, u8 *p, int n) /* 128-bit blocks */
 {
-	uint8_t tmp[AESbsize], q[AESbsize];
-	uint8_t *pp, *tp, *ip, *eip, *ep;
+	u8 tmp[AESbsize], q[AESbsize];
+	u8 *pp, *tp, *ip, *eip, *ep;
 	AESstate *ds = ecb->espstate;
 
 	ep = p + n;
@@ -889,9 +890,9 @@ aescbccipher(Espcb *ecb, uint8_t *p, int n) /* 128-bit blocks */
 }
 
 static void
-aescbcespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
+aescbcespinit(Espcb *ecb, char *name, u8 *k, unsigned n)
 {
-	uint8_t key[Aeskeysz], ivec[Aeskeysz];
+	u8 key[Aeskeysz], ivec[Aeskeysz];
 	int i;
 
 	n = BITS2BYTES(n);
@@ -910,10 +911,10 @@ aescbcespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
 }
 
 static int
-aesctrcipher(Espcb *ecb, uint8_t *p, int n) /* 128-bit blocks */
+aesctrcipher(Espcb *ecb, u8 *p, int n) /* 128-bit blocks */
 {
-	uint8_t tmp[AESbsize], q[AESbsize];
-	uint8_t *pp, *tp, *ip, *eip, *ep;
+	u8 tmp[AESbsize], q[AESbsize];
+	u8 *pp, *tp, *ip, *eip, *ep;
 	AESstate *ds = ecb->espstate;
 
 	ep = p + n;
@@ -947,9 +948,9 @@ aesctrcipher(Espcb *ecb, uint8_t *p, int n) /* 128-bit blocks */
 }
 
 static void
-aesctrespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
+aesctrespinit(Espcb *ecb, char *name, u8 *k, unsigned n)
 {
-	uint8_t key[Aesblk], ivec[Aesblk];
+	u8 key[Aesblk], ivec[Aesblk];
 	int i;
 
 	n = BITS2BYTES(n);
@@ -972,10 +973,11 @@ aesctrespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
  */
 
 static void
-seanq_hmac_md5(uint8_t hash[MD5dlen], uint8_t *t, int32_t tlen, uint8_t *key, int32_t klen)
+seanq_hmac_md5(u8 hash[MD5dlen], u8 *t, i32 tlen, u8 *key,
+	       i32 klen)
 {
 	int i;
-	uint8_t ipad[Hmacblksz + 1], opad[Hmacblksz + 1], innerhash[MD5dlen];
+	u8 ipad[Hmacblksz + 1], opad[Hmacblksz + 1], innerhash[MD5dlen];
 	DigestState *digest;
 
 	memset(ipad, 0x36, Hmacblksz);
@@ -992,20 +994,20 @@ seanq_hmac_md5(uint8_t hash[MD5dlen], uint8_t *t, int32_t tlen, uint8_t *key, in
 }
 
 static int
-md5auth(Espcb *ecb, uint8_t *t, int tlen, uint8_t *auth)
+md5auth(Espcb *ecb, u8 *t, int tlen, u8 *auth)
 {
-	uint8_t hash[MD5dlen];
+	u8 hash[MD5dlen];
 	int r;
 
 	memset(hash, 0, MD5dlen);
-	seanq_hmac_md5(hash, t, tlen, (uint8_t *)ecb->ahstate, BITS2BYTES(128));
+	seanq_hmac_md5(hash, t, tlen, (u8 *)ecb->ahstate, BITS2BYTES(128));
 	r = memcmp(auth, hash, ecb->ahlen) == 0;
 	memmove(auth, hash, ecb->ahlen);
 	return r;
 }
 
 static void
-md5ahinit(Espcb *ecb, char *name, uint8_t *key, unsigned klen)
+md5ahinit(Espcb *ecb, char *name, u8 *key, unsigned klen)
 {
 	if(klen != 128)
 		panic("md5ahinit: bad keylen");
@@ -1023,7 +1025,7 @@ md5ahinit(Espcb *ecb, char *name, uint8_t *key, unsigned klen)
  */
 
 static int
-descipher(Espcb *ecb, uint8_t *p, int n)
+descipher(Espcb *ecb, u8 *p, int n)
 {
 	DESstate *ds = ecb->espstate;
 
@@ -1038,7 +1040,7 @@ descipher(Espcb *ecb, uint8_t *p, int n)
 }
 
 static int
-des3cipher(Espcb *ecb, uint8_t *p, int n)
+des3cipher(Espcb *ecb, u8 *p, int n)
 {
 	DES3state *ds = ecb->espstate;
 
@@ -1053,9 +1055,9 @@ des3cipher(Espcb *ecb, uint8_t *p, int n)
 }
 
 static void
-desespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
+desespinit(Espcb *ecb, char *name, u8 *k, unsigned n)
 {
-	uint8_t key[Desblk], ivec[Desblk];
+	u8 key[Desblk], ivec[Desblk];
 	int i;
 
 	n = BITS2BYTES(n);
@@ -1075,9 +1077,9 @@ desespinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
 }
 
 static void
-des3espinit(Espcb *ecb, char *name, uint8_t *k, unsigned n)
+des3espinit(Espcb *ecb, char *name, u8 *k, unsigned n)
 {
-	uint8_t key[3][Desblk], ivec[Desblk];
+	u8 key[3][Desblk], ivec[Desblk];
 	int i;
 
 	n = BITS2BYTES(n);

sys/src/9/ip/ethermedium.c

@@ -20,12 +20,12 @@
 
 typedef struct Etherhdr Etherhdr;
 struct Etherhdr {
-	uint8_t d[6];
-	uint8_t s[6];
-	uint8_t t[2];
+	u8 d[6];
+	u8 s[6];
+	u8 t[2];
 };
 
-static uint8_t ipbroadcast[IPaddrlen] = {
+static u8 ipbroadcast[IPaddrlen] = {
 	0xff,
 	0xff,
 	0xff,
@@ -44,22 +44,22 @@ static uint8_t ipbroadcast[IPaddrlen] = {
 	0xff,
 };
 
-static uint8_t etherbroadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+static u8 etherbroadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
 static void etherread4(void *a);
 static void etherread6(void *a);
 static void etherbind(Ipifc *ifc, int argc, char **argv);
 static void etherunbind(Ipifc *ifc);
-static void etherbwrite(Ipifc *ifc, Block *bp, int version, uint8_t *ip);
-static void etheraddmulti(Ipifc *ifc, uint8_t *a, uint8_t *ia);
-static void etherremmulti(Ipifc *ifc, uint8_t *a, uint8_t *ia);
-static Block *multicastarp(Fs *f, Arpent *a, Medium *, uint8_t *mac);
+static void etherbwrite(Ipifc *ifc, Block *bp, int version, u8 *ip);
+static void etheraddmulti(Ipifc *ifc, u8 *a, u8 *ia);
+static void etherremmulti(Ipifc *ifc, u8 *a, u8 *ia);
+static Block *multicastarp(Fs *f, Arpent *a, Medium *, u8 *mac);
 static void sendarp(Ipifc *ifc, Arpent *a);
-static void sendgarp(Ipifc *ifc, uint8_t *);
-static int multicastea(uint8_t *ea, uint8_t *ip);
+static void sendgarp(Ipifc *ifc, u8 *);
+static int multicastea(u8 *ea, u8 *ip);
 static void recvarpproc(void *);
 static void resolveaddr6(Ipifc *ifc, Arpent *a);
-static void etherpref2addr(uint8_t *pref, uint8_t *ea);
+static void etherpref2addr(u8 *pref, u8 *ea);
 
 Medium ethermedium =
 	{
@@ -118,18 +118,18 @@ enum {
 
 typedef struct Etherarp Etherarp;
 struct Etherarp {
-	uint8_t d[6];
-	uint8_t s[6];
-	uint8_t type[2];
-	uint8_t hrd[2];
-	uint8_t pro[2];
-	uint8_t hln;
-	uint8_t pln;
-	uint8_t op[2];
-	uint8_t sha[6];
-	uint8_t spa[4];
-	uint8_t tha[6];
-	uint8_t tpa[4];
+	u8 d[6];
+	u8 s[6];
+	u8 type[2];
+	u8 hrd[2];
+	u8 pro[2];
+	u8 hln;
+	u8 pln;
+	u8 op[2];
+	u8 sha[6];
+	u8 spa[4];
+	u8 tha[6];
+	u8 tpa[4];
 };
 
 static char *nbmsg = "nonblocking";
@@ -288,11 +288,11 @@ etherunbind(Ipifc *ifc)
  *  called by ipoput with a single block to write with ifc rlock'd
  */
 static void
-etherbwrite(Ipifc *ifc, Block *bp, int version, uint8_t *ip)
+etherbwrite(Ipifc *ifc, Block *bp, int version, u8 *ip)
 {
 	Etherhdr *eh;
 	Arpent *a;
-	uint8_t mac[6];
+	u8 mac[6];
 	Etherrock *er = ifc->arg;
 
 	/* get mac address of destination */
@@ -423,9 +423,9 @@ etherread6(void *a)
 }
 
 static void
-etheraddmulti(Ipifc *ifc, uint8_t *a, uint8_t *b)
+etheraddmulti(Ipifc *ifc, u8 *a, u8 *b)
 {
-	uint8_t mac[6];
+	u8 mac[6];
 	char buf[64];
 	Etherrock *er = ifc->arg;
 	int version;
@@ -445,9 +445,9 @@ etheraddmulti(Ipifc *ifc, uint8_t *a, uint8_t *b)
 }
 
 static void
-etherremmulti(Ipifc *ifc, uint8_t *a, uint8_t *b)
+etherremmulti(Ipifc *ifc, u8 *a, u8 *b)
 {
-	uint8_t mac[6];
+	u8 mac[6];
 	char buf[64];
 	Etherrock *er = ifc->arg;
 	int version;
@@ -525,7 +525,7 @@ resolveaddr6(Ipifc *ifc, Arpent *a)
 	int sflag;
 	Block *bp;
 	Etherrock *er = ifc->arg;
-	uint8_t ipsrc[IPaddrlen];
+	u8 ipsrc[IPaddrlen];
 
 	/* don't do anything if it's been less than a second since the last */
 	if(NOW - a->ctime < ReTransTimer){
@@ -560,7 +560,7 @@ resolveaddr6(Ipifc *ifc, Arpent *a)
  *  send a gratuitous arp to refresh arp caches
  */
 static void
-sendgarp(Ipifc *ifc, uint8_t *ip)
+sendgarp(Ipifc *ifc, u8 *ip)
 {
 	int n;
 	Block *bp;
@@ -600,8 +600,8 @@ recvarp(Ipifc *ifc)
 	int n;
 	Block *ebp, *rbp;
 	Etherarp *e, *r;
-	uint8_t ip[IPaddrlen];
-	static uint8_t eprinted[4];
+	u8 ip[IPaddrlen];
+	static u8 eprinted[4];
 	Etherrock *er = ifc->arg;
 
 	ebp = er->achan->dev->bread(er->achan, ifc->maxtu, 0);
@@ -708,7 +708,7 @@ recvarpproc(void *v)
 }
 
 static int
-multicastea(uint8_t *ea, uint8_t *ip)
+multicastea(u8 *ea, u8 *ip)
 {
 	int x;
 
@@ -739,7 +739,7 @@ multicastea(uint8_t *ea, uint8_t *ip)
  *  IP address.
  */
 static Block *
-multicastarp(Fs *f, Arpent *a, Medium *medium, uint8_t *mac)
+multicastarp(Fs *f, Arpent *a, Medium *medium, u8 *mac)
 {
 	/* is it broadcast? */
 	switch(ipforme(f, a->ip)){
@@ -771,7 +771,7 @@ ethermediumlink(void)
 }
 
 static void
-etherpref2addr(uint8_t *pref, uint8_t *ea)
+etherpref2addr(u8 *pref, u8 *ea)
 {
 	pref[8] = ea[0] | 0x2;
 	pref[9] = ea[1];

sys/src/9/ip/gre.c

@@ -55,33 +55,33 @@ enum {
 typedef struct GREhdr GREhdr;
 struct GREhdr {
 	/* ip header */
-	uint8_t vihl;	 /* Version and header length */
-	uint8_t tos;	 /* Type of service */
-	uint8_t len[2];	 /* packet length (including headers) */
-	uint8_t id[2];	 /* Identification */
-	uint8_t frag[2]; /* Fragment information */
-	uint8_t ttl;
-	uint8_t proto;	  /* Protocol */
-	uint8_t cksum[2]; /* checksum */
-	uint8_t src[4];	  /* Ip source */
-	uint8_t dst[4];	  /* Ip destination */
+	u8 vihl;	 /* Version and header length */
+	u8 tos;	 /* Type of service */
+	u8 len[2];	 /* packet length (including headers) */
+	u8 id[2];	 /* Identification */
+	u8 frag[2]; /* Fragment information */
+	u8 ttl;
+	u8 proto;	  /* Protocol */
+	u8 cksum[2]; /* checksum */
+	u8 src[4];	  /* Ip source */
+	u8 dst[4];	  /* Ip destination */
 
 	/* gre header */
-	uint8_t flags[2];
-	uint8_t eproto[2]; /* encapsulation protocol */
+	u8 flags[2];
+	u8 eproto[2]; /* encapsulation protocol */
 };
 
 typedef struct GREpriv GREpriv;
 struct GREpriv {
 	/* non-MIB stats */
-	uint32_t lenerr; /* short packet */
+	u32 lenerr; /* short packet */
 };
 
 typedef struct Bring Bring;
 struct Bring {
 	Block *ring[Nring];
-	int32_t produced;
-	int32_t consumed;
+	i32 produced;
+	i32 consumed;
 };
 
 typedef struct GREconv GREconv;
@@ -89,14 +89,14 @@ struct GREconv {
 	int raw;
 
 	/* Retunnelling information.  v4 only */
-	uint8_t north[4]; /* HA */
-	uint8_t south[4]; /* Base station */
-	uint8_t hoa[4];	  /* Home address */
-	uint8_t coa[4];	  /* Careof address */
-	uint32_t seq;	  /* Current sequence # */
+	u8 north[4]; /* HA */
+	u8 south[4]; /* Base station */
+	u8 hoa[4];	  /* Home address */
+	u8 coa[4];	  /* Careof address */
+	u32 seq;	  /* Current sequence # */
 	int dlsusp;	  /* Downlink suspended? */
 	int ulsusp;	  /* Uplink suspended? */
-	uint32_t ulkey;	  /* GRE key */
+	u32 ulkey;	  /* GRE key */
 
 	QLock lock;	  /* Lock for rings */
 	Bring dlpending;  /* Ring of pending packets */
@@ -106,8 +106,8 @@ struct GREconv {
 
 typedef struct Metablock Metablock;
 struct Metablock {
-	uint8_t *rp;
-	uint32_t seq;
+	u8 *rp;
+	u32 seq;
 };
 
 static char *grectlcooked(Conv *, int, char **);
@@ -178,14 +178,14 @@ static struct {
 	},
 };
 
-static uint8_t nulladdr[4];
+static u8 nulladdr[4];
 static char *sessend = "session end";
 
 static void grekick(void *x, Block *bp);
 //static char *gresetup(Conv *, char *, char *, char *);
 
-uint32_t grepdin, grepdout, grebdin, grebdout;
-uint32_t grepuin, grepuout, grebuin, grebuout;
+u32 grepdin, grepdout, grebdin, grebdout;
+u32 grepuin, grepuout, grebuin, grebuout;
 
 static Block *
 getring(Bring *r)
@@ -336,7 +336,7 @@ grekick(void *x, Block *bp)
 	Conv *c;
 	GREconv *grec;
 	GREhdr *gre;
-	uint8_t laddr[IPaddrlen], raddr[IPaddrlen];
+	u8 laddr[IPaddrlen], raddr[IPaddrlen];
 
 	if(bp == nil)
 		return;
@@ -386,8 +386,8 @@ gredownlink(Conv *c, Block *bp)
 	GREconv *grec;
 	GREhdr *gre;
 	int hdrlen, suspended, extra;
-	uint16_t flags;
-	uint32_t seq;
+	u16 flags;
+	u32 seq;
 
 	gre = (GREhdr *)bp->rp;
 	if(gre->ttl == 1){
@@ -421,8 +421,8 @@ gredownlink(Conv *c, Block *bp)
 	 * The outgoing packet only has the sequence number set.  Make room
 	 * for the sequence number.
 	 */
-	if(hdrlen != sizeof(uint32_t)){
-		extra = hdrlen - sizeof(uint32_t);
+	if(hdrlen != sizeof(u32)){
+		extra = hdrlen - sizeof(u32);
 		if(extra < 0 && bp->rp - bp->base < -extra){
 			print("gredownlink: cannot add sequence number\n");
 			freeb(bp);
@@ -430,7 +430,7 @@ gredownlink(Conv *c, Block *bp)
 		}
 		memmove(bp->rp + extra, bp->rp, sizeof(GREhdr));
 		bp->rp += extra;
-		assert(BLEN(bp) >= sizeof(GREhdr) + sizeof(uint32_t));
+		assert(BLEN(bp) >= sizeof(GREhdr) + sizeof(u32));
 		gre = (GREhdr *)bp->rp;
 	}
 	seq = grec->seq++;
@@ -515,7 +515,7 @@ greuplink(Conv *c, Block *bp)
 {
 	GREconv *grec;
 	GREhdr *gre;
-	uint16_t flags;
+	u16 flags;
 
 	gre = (GREhdr *)bp->rp;
 	if(gre->ttl == 1)
@@ -539,7 +539,7 @@ greuplink(Conv *c, Block *bp)
 
 		if((flags & GRE_key) == 0){
 			/* Make room for the key */
-			if(bp->rp - bp->base < sizeof(uint32_t)){
+			if(bp->rp - bp->base < sizeof(u32)){
 				print("%V can't add key\n", gre->src);
 				freeb(bp);
 				return;
@@ -575,8 +575,8 @@ static void
 greiput(Proto *proto, Ipifc *ipifc, Block *bp)
 {
 	int len, hdrlen;
-	uint16_t eproto, flags;
-	uint8_t raddr[IPaddrlen];
+	u16 eproto, flags;
+	u8 raddr[IPaddrlen];
 	Conv *c, **p;
 	GREconv *grec;
 	GREhdr *gre;
@@ -752,7 +752,7 @@ static char *
 grectlretunnel(Conv *c, int i, char **argv)
 {
 	GREconv *grec;
-	uint8_t ipaddr[4];
+	u8 ipaddr[4];
 
 	grec = c->ptcl;
 	if(memcmp(grec->hoa, nulladdr, sizeof grec->hoa))
@@ -777,7 +777,7 @@ grectlretunnel(Conv *c, int i, char **argv)
 static char *
 grectlreport(Conv *c, int i, char **argv)
 {
-	uint32_t seq;
+	u32 seq;
 	Block *bp;
 	Bring *r;
 	GREconv *grec;
@@ -793,7 +793,7 @@ grectlreport(Conv *c, int i, char **argv)
 
 		assert(bp && bp->rp - bp->base >= sizeof(Metablock));
 		m = (Metablock *)bp->base;
-		if((int32_t)(seq - m->seq) <= 0)
+		if((i32)(seq - m->seq) <= 0)
 			break;
 
 		r->ring[r->consumed & Ringmask] = nil;

sys/src/9/ip/icmp.c

@@ -17,22 +17,22 @@
 #include "ip.h"
 
 typedef struct Icmp {
-	uint8_t vihl;	    /* Version and header length */
-	uint8_t tos;	    /* Type of service */
-	uint8_t length[2];  /* packet length */
-	uint8_t id[2];	    /* Identification */
-	uint8_t frag[2];    /* Fragment information */
-	uint8_t ttl;	    /* Time to live */
-	uint8_t proto;	    /* Protocol */
-	uint8_t ipcksum[2]; /* Header checksum */
-	uint8_t src[4];	    /* Ip source */
-	uint8_t dst[4];	    /* Ip destination */
-	uint8_t type;
-	uint8_t code;
-	uint8_t cksum[2];
-	uint8_t icmpid[2];
-	uint8_t seq[2];
-	uint8_t data[1];
+	u8 vihl;	    /* Version and header length */
+	u8 tos;	    /* Type of service */
+	u8 length[2];  /* packet length */
+	u8 id[2];	    /* Identification */
+	u8 frag[2];    /* Fragment information */
+	u8 ttl;	    /* Time to live */
+	u8 proto;	    /* Protocol */
+	u8 ipcksum[2]; /* Header checksum */
+	u8 src[4];	    /* Ip source */
+	u8 dst[4];	    /* Ip destination */
+	u8 type;
+	u8 code;
+	u8 cksum[2];
+	u8 icmpid[2];
+	u8 seq[2];
+	u8 data[1];
 } Icmp;
 
 enum { /* Packet Types */
@@ -103,11 +103,11 @@ static char *statnames[Nstats] =
 
 typedef struct Icmppriv Icmppriv;
 struct Icmppriv {
-	uint32_t stats[Nstats];
+	u32 stats[Nstats];
 
 	/* message counts */
-	uint32_t in[Maxtype + 1];
-	uint32_t out[Maxtype + 1];
+	u32 in[Maxtype + 1];
+	u32 out[Maxtype + 1];
 };
 
 static void icmpkick(void *x, Block *);
@@ -196,7 +196,7 @@ icmpkick(void *x, Block *bp)
 }
 
 extern void
-icmpttlexceeded(Fs *f, uint8_t *ia, Block *bp)
+icmpttlexceeded(Fs *f, u8 *ia, Block *bp)
 {
 	Block *nbp;
 	Icmp *p, *np;
@@ -227,7 +227,7 @@ icmpunreachable(Fs *f, Block *bp, int code, int seq)
 	Block *nbp;
 	Icmp *p, *np;
 	int i;
-	uint8_t addr[IPaddrlen];
+	u8 addr[IPaddrlen];
 
 	p = (Icmp *)bp->rp;
 
@@ -276,8 +276,8 @@ goticmpkt(Proto *icmp, Block *bp)
 {
 	Conv **c, *s;
 	Icmp *p;
-	uint8_t dst[IPaddrlen];
-	uint16_t recid;
+	u8 dst[IPaddrlen];
+	u16 recid;
 
 	p = (Icmp *)bp->rp;
 	v4tov6(dst, p->src);
@@ -300,7 +300,7 @@ static Block *
 mkechoreply(Block *bp)
 {
 	Icmp *q;
-	uint8_t ip[4];
+	u8 ip[4];
 
 	q = (Icmp *)bp->rp;
 	q->vihl = IP_VER4;
@@ -430,8 +430,8 @@ icmpadvise(Proto *icmp, Block *bp, char *msg)
 {
 	Conv **c, *s;
 	Icmp *p;
-	uint8_t dst[IPaddrlen];
-	uint16_t recid;
+	u8 dst[IPaddrlen];
+	u16 recid;
 
 	p = (Icmp *)bp->rp;
 	v4tov6(dst, p->dst);

sys/src/9/ip/icmp6.c

@@ -117,16 +117,16 @@ struct Ndpkt {
 #define NDPKTSZ offsetof(Ndpkt, payload[0])
 
 typedef struct Icmppriv6 {
-	uint32_t stats[Nstats6];
+	u32 stats[Nstats6];
 
 	/* message counts */
-	uint32_t in[Maxtype6 + 1];
-	uint32_t out[Maxtype6 + 1];
+	u32 in[Maxtype6 + 1];
+	u32 out[Maxtype6 + 1];
 } Icmppriv6;
 
 typedef struct Icmpcb6 {
 	QLock ql;
-	uint8_t headers;
+	u8 headers;
 } Icmpcb6;
 
 char *icmpnames6[Maxtype6 + 1] =
@@ -220,7 +220,7 @@ newIPICMP(int packetlen)
 void
 icmpadvise6(Proto *icmp, Block *bp, char *msg)
 {
-	uint16_t recid;
+	u16 recid;
 	Conv **c, *s;
 	IPICMP *p;
 
@@ -241,7 +241,7 @@ icmpadvise6(Proto *icmp, Block *bp, char *msg)
 static void
 icmpkick6(void *x, Block *bp)
 {
-	uint8_t laddr[IPaddrlen], raddr[IPaddrlen];
+	u8 laddr[IPaddrlen], raddr[IPaddrlen];
 	Conv *c = x;
 	IPICMP *p;
 	Icmppriv6 *ipriv = c->p->priv;
@@ -300,8 +300,8 @@ icmpctl6(Conv *c, char **argv, int argc)
 static void
 goticmpkt6(Proto *icmp, Block *bp, int muxkey)
 {
-	uint16_t recid;
-	uint8_t *addr;
+	u16 recid;
+	u8 *addr;
 	Conv **c, *s;
 	IPICMP *p = (IPICMP *)bp->rp;
 
@@ -329,7 +329,7 @@ goticmpkt6(Proto *icmp, Block *bp, int muxkey)
 static Block *
 mkechoreply6(Block *bp, Ipifc *ifc)
 {
-	uint8_t addr[IPaddrlen];
+	u8 addr[IPaddrlen];
 	IPICMP *p = (IPICMP *)(bp->rp);
 
 	ipmove(addr, p->src);
@@ -350,7 +350,7 @@ mkechoreply6(Block *bp, Ipifc *ifc)
  * 	and tuni == TARG_UNI => neighbor reachability.
  */
 extern void
-icmpns(Fs *f, uint8_t *src, int suni, uint8_t *targ, int tuni, uint8_t *mac)
+icmpns(Fs *f, u8 *src, int suni, u8 *targ, int tuni, u8 *mac)
 {
 	Block *nbp;
 	Ndpkt *np;
@@ -393,7 +393,7 @@ icmpns(Fs *f, uint8_t *src, int suni, uint8_t *targ, int tuni, uint8_t *mac)
  * sends out an ICMPv6 neighbor advertisement. pktflags == RSO flags.
  */
 extern void
-icmpna(Fs *f, uint8_t *src, uint8_t *dst, uint8_t *targ, uint8_t *mac, uint8_t flags)
+icmpna(Fs *f, u8 *src, u8 *dst, u8 *targ, u8 *mac, u8 flags)
 {
 	Block *nbp;
 	Ndpkt *np;
@@ -556,7 +556,7 @@ static int
 valid(Proto *icmp, Ipifc *ipifc, Block *bp, Icmppriv6 *ipriv)
 {
 	int sz, osz, unsp, n, ttl, iplen, pktsz;
-	uint8_t *packet;
+	u8 *packet;
 	IPICMP *p;
 	Ndpkt *np;
 
@@ -676,7 +676,7 @@ err:
 }
 
 static int
-targettype(Fs *f, Ipifc *ifc, uint8_t *target)
+targettype(Fs *f, Ipifc *ifc, u8 *target)
 {
 	Iplifc *lifc;
 	int t;
@@ -704,9 +704,9 @@ icmpiput6(Proto *icmp, Ipifc *ipifc, Block *bp)
 {
 	int type;
 	char *msg, m2[128];
-	uint8_t pktflags;
-	uint8_t *packet, *src;
-	uint8_t lsrc[IPaddrlen];
+	u8 pktflags;
+	u8 *packet, *src;
+	u8 lsrc[IPaddrlen];
 	Block *r;
 	IPICMP *p;
 	Icmppriv6 *ipriv;

sys/src/9/ip/igmp.c

@@ -35,24 +35,24 @@ enum {
 typedef struct IGMPpkt IGMPpkt;
 struct IGMPpkt {
 	/* ip header */
-	uint8_t vihl;	 /* Version and header length */
-	uint8_t tos;	 /* Type of service */
-	uint8_t len[2];	 /* packet length (including headers) */
-	uint8_t id[2];	 /* Identification */
-	uint8_t frag[2]; /* Fragment information */
-	uint8_t Unused;
-	uint8_t proto;		/* Protocol */
-	uint8_t cksum[2];	/* checksum of ip portion */
-	uint8_t src[IPaddrlen]; /* Ip source */
-	uint8_t dst[IPaddrlen]; /* Ip destination */
+	u8 vihl;	 /* Version and header length */
+	u8 tos;	 /* Type of service */
+	u8 len[2];	 /* packet length (including headers) */
+	u8 id[2];	 /* Identification */
+	u8 frag[2]; /* Fragment information */
+	u8 Unused;
+	u8 proto;		/* Protocol */
+	u8 cksum[2];	/* checksum of ip portion */
+	u8 src[IPaddrlen]; /* Ip source */
+	u8 dst[IPaddrlen]; /* Ip destination */
 
 	/* igmp header */
-	uint8_t vertype; /* version and type */
-	uint8_t unused;
-	uint8_t igmpcksum[2];	  /* checksum of igmp portion */
-	uint8_t group[IPaddrlen]; /* multicast group */
+	u8 vertype; /* version and type */
+	u8 unused;
+	u8 igmpcksum[2];	  /* checksum of igmp portion */
+	u8 group[IPaddrlen]; /* multicast group */
 
-	uint8_t payload[];
+	u8 payload[];
 };
 
 #define IGMPPKTSZ offsetof(IGMPpkt, payload[0])
@@ -81,14 +81,14 @@ Proto igmp;
 extern Fs fs;
 
 static struct Stats {
-	uint32_t inqueries;
-	uint32_t outqueries;
-	uint32_t inreports;
-	uint32_t outreports;
+	u32 inqueries;
+	u32 outqueries;
+	u32 inreports;
+	u32 outreports;
 } stats;
 
 void
-igmpsendreport(Medium *m, uint8_t *addr)
+igmpsendreport(Medium *m, u8 *addr)
 {
 	IGMPpkt *p;
 	Block *bp;
@@ -123,7 +123,7 @@ igmpproc(void *a)
 {
 	IGMPrep *rp, **lrp;
 	Multicast *mp, **lmp;
-	uint8_t ip[IPaddrlen];
+	u8 ip[IPaddrlen];
 
 	USED(a);
 

sys/src/9/ip/inferno.c

@@ -33,7 +33,7 @@ commonerror(void)
 }
 
 int
-bootpread(char *c, uint32_t u, int i)
+bootpread(char *c, u32 u, int i)
 {
 	return 0;
 }

sys/src/9/ip/ip.c

@@ -48,7 +48,7 @@ static char *statnames[] =
  */
 #define BKFG(xp) ((Ipfrag *)((xp)->base))
 
-uint16_t ipcsum(uint8_t *);
+u16 ipcsum(u8 *);
 Block *ip4reassemble(IP *, int, Block *, Ip4hdr *);
 void ipfragfree4(IP *, Fragment4 *);
 Fragment4 *ipfragallo4(IP *);
@@ -131,8 +131,8 @@ ipoput4(Fs *f, Block *bp, int gating, int ttl, int tos, Conv *c)
 {
 	Proc *up = externup();
 	Ipifc *ifc;
-	uint8_t *gate;
-	uint32_t fragoff;
+	u8 *gate;
+	u32 fragoff;
 	Block *xp, *nb;
 	Ip4hdr *eh, *feh;
 	int lid, len, seglen, chunk, dlen, blklen, offset, medialen;
@@ -320,9 +320,9 @@ ipiput4(Fs *f, Ipifc *ifc, Block *bp)
 	int hop, tos, proto, olen;
 	Ip4hdr *h;
 	Proto *p;
-	uint16_t frag;
+	u16 frag;
 	int notforme;
-	uint8_t *dp, v6dst[IPaddrlen];
+	u8 *dp, v6dst[IPaddrlen];
 	IP *ip;
 	Route *r;
 	Conv conv;
@@ -481,9 +481,9 @@ Block *
 ip4reassemble(IP *ip, int offset, Block *bp, Ip4hdr *ih)
 {
 	int fend;
-	uint16_t id;
+	u16 id;
 	Fragment4 *f, *fnext;
-	uint32_t src, dst;
+	u32 src, dst;
 	Block *bl, **l, *last, *prev;
 	int ovlap, len, fragsize, pktposn;
 
@@ -692,11 +692,11 @@ ipfragallo4(IP *ip)
 	return f;
 }
 
-uint16_t
-ipcsum(uint8_t *addr)
+u16
+ipcsum(u8 *addr)
 {
 	int len;
-	uint32_t sum;
+	u32 sum;
 
 	sum = 0;
 	len = (addr[0] & 0xf) << 2;

sys/src/9/ip/ip.h

@@ -111,33 +111,33 @@ enum {
 struct Fragment4 {
 	Block *blist;
 	Fragment4 *next;
-	uint32_t src;
-	uint32_t dst;
-	uint16_t id;
-	uint32_t age;
+	u32 src;
+	u32 dst;
+	u16 id;
+	u32 age;
 };
 
 struct Fragment6 {
 	Block *blist;
 	Fragment6 *next;
-	uint8_t src[IPaddrlen];
-	uint8_t dst[IPaddrlen];
+	u8 src[IPaddrlen];
+	u8 dst[IPaddrlen];
 	uint id;
-	uint32_t age;
+	u32 age;
 };
 
 struct Ipfrag {
-	uint16_t foff;
-	uint16_t flen;
+	u16 foff;
+	u16 flen;
 
-	uint8_t payload[];
+	u8 payload[];
 };
 
 #define IPFRAGSZ offsetof(Ipfrag, payload[0])
 
 /* an instance of IP */
 struct IP {
-	uint64_t stats[Nipstats];
+	u64 stats[Nipstats];
 
 	QLock fraglock4;
 	Fragment4 *flisthead4;
@@ -154,16 +154,16 @@ struct IP {
 
 /* on the wire packet header */
 struct Ip4hdr {
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* ip->identification */
-	uint8_t frag[2];   /* Fragment information */
-	uint8_t ttl;	   /* Time to live */
-	uint8_t proto;	   /* Protocol */
-	uint8_t cksum[2];  /* Header checksum */
-	uint8_t src[4];	   /* IP source */
-	uint8_t dst[4];	   /* IP destination */
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* ip->identification */
+	u8 frag[2];   /* Fragment information */
+	u8 ttl;	   /* Time to live */
+	u8 proto;	   /* Protocol */
+	u8 cksum[2];  /* Header checksum */
+	u8 src[4];	   /* IP source */
+	u8 dst[4];	   /* IP destination */
 };
 
 /*
@@ -180,11 +180,11 @@ struct Conv {
 	uint tos;	  /* type of service */
 	int ignoreadvice; /* don't terminate connection on icmp errors */
 
-	uint8_t ipversion;
-	uint8_t laddr[IPaddrlen]; /* local IP address */
-	uint8_t raddr[IPaddrlen]; /* remote IP address */
-	uint16_t lport;		  /* local port number */
-	uint16_t rport;		  /* remote port number */
+	u8 ipversion;
+	u8 laddr[IPaddrlen]; /* local IP address */
+	u8 raddr[IPaddrlen]; /* remote IP address */
+	u16 lport;		  /* local port number */
+	u16 rport;		  /* remote port number */
 
 	char *owner; /* protections */
 	int perm;
@@ -219,7 +219,7 @@ struct Conv {
 	void *ptcl; /* protocol specific stuff */
 
 	Route *r;      /* last route used */
-	uint32_t rgen; /* routetable generation for *r */
+	u32 rgen; /* routetable generation for *r */
 };
 
 struct Medium {
@@ -230,46 +230,46 @@ struct Medium {
 	int maclen; /* mac address length  */
 	void (*bind)(Ipifc *, int, char **);
 	void (*unbind)(Ipifc *);
-	void (*bwrite)(Ipifc *ifc, Block *b, int version, uint8_t *ip);
+	void (*bwrite)(Ipifc *ifc, Block *b, int version, u8 *ip);
 
 	/* for arming interfaces to receive multicast */
-	void (*addmulti)(Ipifc *ifc, uint8_t *a, uint8_t *ia);
-	void (*remmulti)(Ipifc *ifc, uint8_t *a, uint8_t *ia);
+	void (*addmulti)(Ipifc *ifc, u8 *a, u8 *ia);
+	void (*remmulti)(Ipifc *ifc, u8 *a, u8 *ia);
 
 	/* process packets written to 'data' */
 	void (*pktin)(Fs *f, Ipifc *ifc, Block *bp);
 
 	/* routes for router boards */
-	void (*addroute)(Ipifc *ifc, int, uint8_t *, uint8_t *, uint8_t *, int);
-	void (*remroute)(Ipifc *ifc, int, uint8_t *, uint8_t *);
+	void (*addroute)(Ipifc *ifc, int, u8 *, u8 *, u8 *, int);
+	void (*remroute)(Ipifc *ifc, int, u8 *, u8 *);
 	void (*flushroutes)(Ipifc *ifc);
 
 	/* for routing multicast groups */
-	void (*joinmulti)(Ipifc *ifc, uint8_t *a, uint8_t *ia);
-	void (*leavemulti)(Ipifc *ifc, uint8_t *a, uint8_t *ia);
+	void (*joinmulti)(Ipifc *ifc, u8 *a, u8 *ia);
+	void (*leavemulti)(Ipifc *ifc, u8 *a, u8 *ia);
 
 	/* address resolution */
-	void (*ares)(Fs *, int, uint8_t *, uint8_t *, int, int); /* resolve */
-	void (*areg)(Ipifc *, uint8_t *);			 /* register */
+	void (*ares)(Fs *, int, u8 *, u8 *, int, int); /* resolve */
+	void (*areg)(Ipifc *, u8 *);			 /* register */
 
 	/* v6 address generation */
-	void (*pref2addr)(uint8_t *pref, uint8_t *ea);
+	void (*pref2addr)(u8 *pref, u8 *ea);
 
 	int unbindonclose; /* if non-zero, unbind on last close */
 };
 
 /* logical interface associated with a physical one */
 struct Iplifc {
-	uint8_t local[IPaddrlen];
-	uint8_t mask[IPaddrlen];
-	uint8_t remote[IPaddrlen];
-	uint8_t net[IPaddrlen];
-	uint8_t tentative; /* =1 => v6 dup disc on, =0 => confirmed unique */
-	uint8_t onlink;	   /* =1 => onlink, =0 offlink. */
-	uint8_t autoflag;  /* v6 autonomous flag */
-	int32_t validlt;   /* v6 valid lifetime */
-	int32_t preflt;	   /* v6 preferred lifetime */
-	int32_t origint;   /* time when addr was added */
+	u8 local[IPaddrlen];
+	u8 mask[IPaddrlen];
+	u8 remote[IPaddrlen];
+	u8 net[IPaddrlen];
+	u8 tentative; /* =1 => v6 dup disc on, =0 => confirmed unique */
+	u8 onlink;	   /* =1 => onlink, =0 offlink. */
+	u8 autoflag;  /* v6 autonomous flag */
+	i32 validlt;   /* v6 valid lifetime */
+	i32 preflt;	   /* v6 preferred lifetime */
+	i32 origint;   /* time when addr was added */
 	Iplink *link;	   /* addresses linked to this lifc */
 	Iplifc *next;
 };
@@ -280,7 +280,7 @@ struct Iplink {
 	Iplifc *lifc;
 	Iplink *selflink; /* next link for this local address */
 	Iplink *lifclink; /* next link for this ifc */
-	uint32_t expire;
+	u32 expire;
 	Iplink *next; /* free list */
 	int ref;
 };
@@ -318,20 +318,20 @@ struct Ipifc {
 
 	/* these are used so that we can unbind on the fly */
 	Lock idlock;
-	uint8_t ifcid; /* incremented each 'bind/unbind/add/remove' */
+	u8 ifcid; /* incremented each 'bind/unbind/add/remove' */
 	int ref;       /* number of proc's using this ipifc */
 	Rendez wait;   /* where unbinder waits for ref == 0 */
 	int unbinding;
 
-	uint8_t mac[MAClen]; /* MAC address */
+	u8 mac[MAClen]; /* MAC address */
 
 	Iplifc *lifc; /* logical interfaces on this physical one */
 
-	uint32_t in, out;	/* message statistics */
-	uint32_t inerr, outerr; /* ... */
+	u32 in, out;	/* message statistics */
+	u32 inerr, outerr; /* ... */
 
-	uint8_t sendra6; /* flag: send router advs on this ifc */
-	uint8_t recvra6; /* flag: recv router advs on this ifc */
+	u8 sendra6; /* flag: send router advs on this ifc */
+	u8 recvra6; /* flag: recv router advs on this ifc */
 	Routerparams rp; /* router parameters as in RFC 2461, pp.40—43.
 					used only if node is router */
 };
@@ -340,8 +340,8 @@ struct Ipifc {
  *  one per multicast-lifc pair used by a Conv
  */
 struct Ipmulti {
-	uint8_t ma[IPaddrlen];
-	uint8_t ia[IPaddrlen];
+	u8 ma[IPaddrlen];
+	u8 ia[IPaddrlen];
 	Ipmulti *next;
 };
 
@@ -368,7 +368,7 @@ struct Ipht {
 };
 void iphtadd(Ipht *, Conv *);
 void iphtrem(Ipht *, Conv *);
-Conv *iphtlook(Ipht *ht, uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp);
+Conv *iphtlook(Ipht *ht, u8 *sa, u16 sp, u8 *da, u16 dp);
 
 /*
  *  one per multiplexed protocol
@@ -400,7 +400,7 @@ struct Proto {
 	int nc;	      /* number of conversations */
 	int ac;
 	Qid qid; /* qid for protocol directory */
-	uint16_t nextrport;
+	u16 nextrport;
 
 	void *priv;
 };
@@ -431,16 +431,16 @@ struct Fs {
 
 	char ndb[1024]; /* an ndb entry for this interface */
 	int ndbvers;
-	int32_t ndbmtime;
+	i32 ndbmtime;
 };
 
 /* one per default router known to host */
 struct v6router {
-	uint8_t inuse;
+	u8 inuse;
 	Ipifc *ifc;
 	int ifcid;
-	uint8_t routeraddr[IPaddrlen];
-	int32_t ltorigin;
+	u8 routeraddr[IPaddrlen];
+	i32 ltorigin;
 	Routerparams rp;
 };
 
@@ -453,17 +453,17 @@ struct v6params {
 };
 
 int Fsconnected(Conv *, char *);
-Conv *Fsnewcall(Conv *, uint8_t *, uint16_t, uint8_t *, uint16_t, uint8_t);
+Conv *Fsnewcall(Conv *, u8 *, u16, u8 *, u16, u8);
 int Fspcolstats(char *, int);
 int Fsproto(Fs *, Proto *);
-int Fsbuiltinproto(Fs *, uint8_t);
+int Fsbuiltinproto(Fs *, u8);
 Conv *Fsprotoclone(Proto *, char *);
-Proto *Fsrcvpcol(Fs *, uint8_t);
-Proto *Fsrcvpcolx(Fs *, uint8_t);
+Proto *Fsrcvpcol(Fs *, u8);
+Proto *Fsrcvpcolx(Fs *, u8);
 char *Fsstdconnect(Conv *, char **, int);
 char *Fsstdannounce(Conv *, char **, int);
 char *Fsstdbind(Conv *, char **, int);
-uint32_t scalednconv(void);
+u32 scalednconv(void);
 void closeconv(Conv *);
 /*
  *  logging
@@ -491,11 +491,11 @@ void netloginit(Fs *);
 void netlogopen(Fs *);
 void netlogclose(Fs *);
 void netlogctl(Fs *, char *, int);
-int32_t netlogread(Fs *, void *, uint32_t, int32_t);
+i32 netlogread(Fs *, void *, u32, i32);
 void netlog(Fs *, int, char *, ...);
 void ifcloginit(Fs *);
-int32_t ifclogread(Fs *, Chan *, void *, uint32_t, int32_t);
-void ifclog(Fs *, uint8_t *, int);
+i32 ifclogread(Fs *, Chan *, void *, u32, i32);
+void ifclog(Fs *, u8 *, int);
 void ifclogopen(Fs *, Chan *);
 void ifclogclose(Fs *, Chan *);
 
@@ -534,24 +534,24 @@ struct RouteTree {
 	Route *right;
 	Route *left;
 	Route *mid;
-	uint8_t depth;
-	uint8_t type;
-	uint8_t ifcid; /* must match ifc->id */
+	u8 depth;
+	u8 type;
+	u8 ifcid; /* must match ifc->id */
 	Ipifc *ifc;
 	char tag[4];
 	int ref;
 };
 
 struct V4route {
-	uint32_t address;
-	uint32_t endaddress;
-	uint8_t gate[IPv4addrlen];
+	u32 address;
+	u32 endaddress;
+	u8 gate[IPv4addrlen];
 };
 
 struct V6route {
-	uint32_t address[IPllen];
-	uint32_t endaddress[IPllen];
-	uint8_t gate[IPaddrlen];
+	u32 address[IPllen];
+	u32 endaddress[IPllen];
+	u8 gate[IPaddrlen];
 };
 
 struct Route {
@@ -562,17 +562,17 @@ struct Route {
 		V4route v4;
 	};
 };
-extern void v4addroute(Fs *f, char *tag, uint8_t *a, uint8_t *mask, uint8_t *gate, int type);
-extern void v6addroute(Fs *f, char *tag, uint8_t *a, uint8_t *mask, uint8_t *gate, int type);
-extern void v4delroute(Fs *f, uint8_t *a, uint8_t *mask, int dolock);
-extern void v6delroute(Fs *f, uint8_t *a, uint8_t *mask, int dolock);
-extern Route *v4lookup(Fs *f, uint8_t *a, Conv *c);
-extern Route *v6lookup(Fs *f, uint8_t *a, Conv *c);
-extern int32_t routeread(Fs *f, char *, uint32_t, int);
-extern int32_t routewrite(Fs *f, Chan *, char *, int);
+extern void v4addroute(Fs *f, char *tag, u8 *a, u8 *mask, u8 *gate, int type);
+extern void v6addroute(Fs *f, char *tag, u8 *a, u8 *mask, u8 *gate, int type);
+extern void v4delroute(Fs *f, u8 *a, u8 *mask, int dolock);
+extern void v6delroute(Fs *f, u8 *a, u8 *mask, int dolock);
+extern Route *v4lookup(Fs *f, u8 *a, Conv *c);
+extern Route *v6lookup(Fs *f, u8 *a, Conv *c);
+extern i32 routeread(Fs *f, char *, u32, int);
+extern i32 routewrite(Fs *f, Chan *, char *, int);
 extern void routetype(int, char *);
 extern void ipwalkroutes(Fs *, Routewalk *);
-extern void convroute(Route *, uint8_t *, uint8_t *, uint8_t *, char *, int *);
+extern void convroute(Route *, u8 *, u8 *, u8 *, char *, int *);
 
 /*
  *  devip.c
@@ -593,56 +593,58 @@ extern IPaux *newipaux(char *, char *);
  *  arp.c
  */
 struct Arpent {
-	uint8_t ip[IPaddrlen];
-	uint8_t mac[MAClen];
+	u8 ip[IPaddrlen];
+	u8 mac[MAClen];
 	Medium *type; /* media type */
 	Arpent *hash;
 	Block *hold;
 	Block *last;
 	uint ctime; /* time entry was created or refreshed */
 	uint utime; /* time entry was last used */
-	uint8_t state;
+	u8 state;
 	Arpent *nextrxt; /* re-transmit chain */
 	uint rtime;	 /* time for next retransmission */
-	uint8_t rxtsrem;
+	u8 rxtsrem;
 	Ipifc *ifc;
-	uint8_t ifcid; /* must match ifc->id */
+	u8 ifcid; /* must match ifc->id */
 };
 
 extern void arpinit(Fs *);
-extern int arpread(Arp *, char *, uint32_t, int);
+extern int arpread(Arp *, char *, u32, int);
 extern int arpwrite(Fs *, char *, int);
-extern Arpent *arpget(Arp *, Block *bp, int version, Ipifc *ifc, uint8_t *ip, uint8_t *h);
+extern Arpent *arpget(Arp *, Block *bp, int version, Ipifc *ifc, u8 *ip,
+		      u8 *h);
 extern void arprelease(Arp *, Arpent *a);
-extern Block *arpresolve(Arp *, Arpent *a, Medium *type, uint8_t *mac);
-extern void arpenter(Fs *, int version, uint8_t *ip, uint8_t *mac, int len, int norefresh);
+extern Block *arpresolve(Arp *, Arpent *a, Medium *type, u8 *mac);
+extern void arpenter(Fs *, int version, u8 *ip, u8 *mac, int len,
+		     int norefresh);
 
 /*
  * ipaux.c
  */
 
-extern int myetheraddr(uint8_t *, char *);
-extern int64_t parseip(uint8_t *, char *);
-extern int64_t parseipmask(uint8_t *, char *);
-extern char *v4parseip(uint8_t *, char *);
-extern void maskip(uint8_t *from, uint8_t *mask, uint8_t *to);
-extern int parsemac(uint8_t *to, char *from, int len);
-extern uint8_t *defmask(uint8_t *);
-extern int isv4(uint8_t *);
-extern void v4tov6(uint8_t *v6, uint8_t *v4);
-extern int v6tov4(uint8_t *v4, uint8_t *v6);
+extern int myetheraddr(u8 *, char *);
+extern i64 parseip(u8 *, char *);
+extern i64 parseipmask(u8 *, char *);
+extern char *v4parseip(u8 *, char *);
+extern void maskip(u8 *from, u8 *mask, u8 *to);
+extern int parsemac(u8 *to, char *from, int len);
+extern u8 *defmask(u8 *);
+extern int isv4(u8 *);
+extern void v4tov6(u8 *v6, u8 *v4);
+extern int v6tov4(u8 *v4, u8 *v6);
 extern int eipfmt(Fmt *);
 
 #define ipmove(x, y) memmove(x, y, IPaddrlen)
 #define ipcmp(x, y) ((x)[IPaddrlen - 1] != (y)[IPaddrlen - 1] || memcmp(x, y, IPaddrlen))
 
-extern uint8_t IPv4bcast[IPaddrlen];
-extern uint8_t IPv4bcastobs[IPaddrlen];
-extern uint8_t IPv4allsys[IPaddrlen];
-extern uint8_t IPv4allrouter[IPaddrlen];
-extern uint8_t IPnoaddr[IPaddrlen];
-extern uint8_t v4prefix[IPaddrlen];
-extern uint8_t IPallbits[IPaddrlen];
+extern u8 IPv4bcast[IPaddrlen];
+extern u8 IPv4bcastobs[IPaddrlen];
+extern u8 IPv4allsys[IPaddrlen];
+extern u8 IPv4allrouter[IPaddrlen];
+extern u8 IPnoaddr[IPaddrlen];
+extern u8 v4prefix[IPaddrlen];
+extern u8 IPallbits[IPaddrlen];
 
 #define NOW TK2MS(sys->machptr[0]->ticks)
 
@@ -658,29 +660,29 @@ extern Medium pktmedium;
  */
 extern Medium *ipfindmedium(char *name);
 extern void addipmedium(Medium *med);
-extern int ipforme(Fs *, uint8_t *addr);
-extern int iptentative(Fs *, uint8_t *addr);
-extern int ipisbm(uint8_t *);
-extern int ipismulticast(uint8_t *);
-extern Ipifc *findipifc(Fs *, uint8_t *remote, int type);
-extern void findlocalip(Fs *, uint8_t *local, uint8_t *remote);
-extern int ipv4local(Ipifc *ifc, uint8_t *addr);
-extern int ipv6local(Ipifc *ifc, uint8_t *addr);
-extern int ipv6anylocal(Ipifc *ifc, uint8_t *addr);
-extern Iplifc *iplocalonifc(Ipifc *ifc, uint8_t *ip);
-extern int ipproxyifc(Fs *f, Ipifc *ifc, uint8_t *ip);
-extern int ipismulticast(uint8_t *ip);
+extern int ipforme(Fs *, u8 *addr);
+extern int iptentative(Fs *, u8 *addr);
+extern int ipisbm(u8 *);
+extern int ipismulticast(u8 *);
+extern Ipifc *findipifc(Fs *, u8 *remote, int type);
+extern void findlocalip(Fs *, u8 *local, u8 *remote);
+extern int ipv4local(Ipifc *ifc, u8 *addr);
+extern int ipv6local(Ipifc *ifc, u8 *addr);
+extern int ipv6anylocal(Ipifc *ifc, u8 *addr);
+extern Iplifc *iplocalonifc(Ipifc *ifc, u8 *ip);
+extern int ipproxyifc(Fs *f, Ipifc *ifc, u8 *ip);
+extern int ipismulticast(u8 *ip);
 extern int ipisbooting(void);
 extern int ipifccheckin(Ipifc *ifc, Medium *med);
 extern void ipifccheckout(Ipifc *ifc);
 extern int ipifcgrab(Ipifc *ifc);
-extern void ipifcaddroute(Fs *, int, uint8_t *, uint8_t *, uint8_t *, int);
-extern void ipifcremroute(Fs *, int, uint8_t *, uint8_t *);
-extern void ipifcremmulti(Conv *c, uint8_t *ma, uint8_t *ia);
-extern void ipifcaddmulti(Conv *c, uint8_t *ma, uint8_t *ia);
+extern void ipifcaddroute(Fs *, int, u8 *, u8 *, u8 *, int);
+extern void ipifcremroute(Fs *, int, u8 *, u8 *);
+extern void ipifcremmulti(Conv *c, u8 *ma, u8 *ia);
+extern void ipifcaddmulti(Conv *c, u8 *ma, u8 *ia);
 extern char *ipifcrem(Ipifc *ifc, char **argv, int argc);
 extern char *ipifcadd(Ipifc *ifc, char **argv, int argc, int tentative, Iplifc *lifcp);
-extern int32_t ipselftabread(Fs *, char *a, uint32_t offset, int n);
+extern i32 ipselftabread(Fs *, char *a, u32 offset, int n);
 extern char *ipifcadd6(Ipifc *ifc, char **argv, int argc);
 /*
  *  ip.c
@@ -688,22 +690,22 @@ extern char *ipifcadd6(Ipifc *ifc, char **argv, int argc);
 extern void iprouting(Fs *, int);
 extern void icmpnoconv(Fs *, Block *);
 extern void icmpcantfrag(Fs *, Block *, int);
-extern void icmpttlexceeded(Fs *, uint8_t *, Block *);
-extern uint16_t ipcsum(uint8_t *);
+extern void icmpttlexceeded(Fs *, u8 *, Block *);
+extern u16 ipcsum(u8 *);
 extern void ipiput4(Fs *, Ipifc *, Block *);
 extern void ipiput6(Fs *, Ipifc *, Block *);
 extern int ipoput4(Fs *, Block *, int, int, int, Conv *);
 extern int ipoput6(Fs *, Block *, int, int, int, Conv *);
 extern int ipstats(Fs *, char *, int);
-extern uint16_t ptclbsum(uint8_t *, int);
-extern uint16_t ptclcsum(Block *, int, int);
+extern u16 ptclbsum(u8 *, int);
+extern u16 ptclcsum(Block *, int, int);
 extern void ip_init(Fs *);
-extern void update_mtucache(uint8_t *, uint32_t);
-extern uint32_t restrict_mtu(uint8_t *, uint32_t);
+extern void update_mtucache(u8 *, u32);
+extern u32 restrict_mtu(u8 *, u32);
 /*
  * bootp.c
  */
-extern int bootpread(char *, uint32_t, int);
+extern int bootpread(char *, u32, int);
 
 /*
  *  resolving inferno/plan9 differences
@@ -719,4 +721,4 @@ extern Chan *chandial(char *, char *, char *, Chan **);
 /*
  *  global to all of the stack
  */
-extern void (*igmpreportfn)(Ipifc *, uint8_t *);
+extern void (*igmpreportfn)(Ipifc *, u8 *);

sys/src/9/ip/ipaux.c

@@ -43,93 +43,93 @@ char *v6hdrtypes[Maxhdrtype] =
 /*
  *  well known IPv6 addresses
  */
-uint8_t v6Unspecified[IPaddrlen] = {
+u8 v6Unspecified[IPaddrlen] = {
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
-uint8_t v6loopback[IPaddrlen] = {
+u8 v6loopback[IPaddrlen] = {
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0x01};
 
-uint8_t v6linklocal[IPaddrlen] = {
+u8 v6linklocal[IPaddrlen] = {
 	0xfe, 0x80, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
-uint8_t v6linklocalmask[IPaddrlen] = {
+u8 v6linklocalmask[IPaddrlen] = {
 	0xff, 0xff, 0xff, 0xff,
 	0xff, 0xff, 0xff, 0xff,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
 int v6llpreflen = 8; /* link-local prefix length in bytes */
 
-uint8_t v6multicast[IPaddrlen] = {
+u8 v6multicast[IPaddrlen] = {
 	0xff, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
-uint8_t v6multicastmask[IPaddrlen] = {
+u8 v6multicastmask[IPaddrlen] = {
 	0xff, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
 int v6mcpreflen = 1; /* multicast prefix length */
 
-uint8_t v6allnodesN[IPaddrlen] = {
+u8 v6allnodesN[IPaddrlen] = {
 	0xff, 0x01, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0x01};
-uint8_t v6allroutersN[IPaddrlen] = {
+u8 v6allroutersN[IPaddrlen] = {
 	0xff, 0x01, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0x02};
-uint8_t v6allnodesNmask[IPaddrlen] = {
+u8 v6allnodesNmask[IPaddrlen] = {
 	0xff, 0xff, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
 int v6aNpreflen = 2; /* all nodes (N) prefix */
 
-uint8_t v6allnodesL[IPaddrlen] = {
+u8 v6allnodesL[IPaddrlen] = {
 	0xff, 0x02, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0x01};
-uint8_t v6allroutersL[IPaddrlen] = {
+u8 v6allroutersL[IPaddrlen] = {
 	0xff, 0x02, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0x02};
-uint8_t v6allnodesLmask[IPaddrlen] = {
+u8 v6allnodesLmask[IPaddrlen] = {
 	0xff, 0xff, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0};
 int v6aLpreflen = 2; /* all nodes (L) prefix */
 
-uint8_t v6solicitednode[IPaddrlen] = {
+u8 v6solicitednode[IPaddrlen] = {
 	0xff, 0x02, 0, 0,
 	0, 0, 0, 0,
 	0, 0, 0, 0x01,
 	0xff, 0, 0, 0};
-uint8_t v6solicitednodemask[IPaddrlen] = {
+u8 v6solicitednodemask[IPaddrlen] = {
 	0xff, 0xff, 0xff, 0xff,
 	0xff, 0xff, 0xff, 0xff,
 	0xff, 0xff, 0xff, 0xff,
 	0xff, 0x0, 0x0, 0x0};
 int v6snpreflen = 13;
 
-uint16_t
+u16
 ptclcsum(Block *bp, int offset, int len)
 {
-	uint8_t *addr;
-	uint32_t losum, hisum;
-	uint16_t csum;
+	u8 *addr;
+	u32 losum, hisum;
+	u16 csum;
 	int odd, blocklen, x;
 
 	/* Correct to front of data area */
@@ -185,10 +185,10 @@ enum {
 	Isprefix = 16,
 };
 
-#define CLASS(p) ((*(uint8_t *)(p)) >> 6)
+#define CLASS(p) ((*(u8 *)(p)) >> 6)
 
 void
-ipv62smcast(uint8_t *smcast, uint8_t *a)
+ipv62smcast(u8 *smcast, u8 *a)
 {
 	assert(IPaddrlen == 16);
 	memmove(smcast, v6solicitednode, IPaddrlen);
@@ -201,7 +201,7 @@ ipv62smcast(uint8_t *smcast, uint8_t *a)
  *  parse a hex mac address
  */
 int
-parsemac(uint8_t *to, char *from, int len)
+parsemac(u8 *to, char *from, int len)
 {
 	char nip[4];
 	char *p;
@@ -228,10 +228,10 @@ parsemac(uint8_t *to, char *from, int len)
 /*
  *  hashing tcp, udp, ... connections
  */
-uint32_t
-iphash(uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp)
+u32
+iphash(u8 *sa, u16 sp, u8 *da, u16 dp)
 {
-	uint32_t kludge;
+	u32 kludge;
 	kludge = ((sa[IPaddrlen - 1] << 24) ^ (sp << 16) ^ (da[IPaddrlen - 1] << 8) ^ dp);
 	return kludge % Nipht;
 #if 0
@@ -244,7 +244,7 @@ iphash(uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp)
 void
 iphtadd(Ipht *ht, Conv *c)
 {
-	uint32_t hv;
+	u32 hv;
 	Iphash *h;
 
 	hv = iphash(c->raddr, c->rport, c->laddr, c->lport);
@@ -275,7 +275,7 @@ iphtadd(Ipht *ht, Conv *c)
 void
 iphtrem(Ipht *ht, Conv *c)
 {
-	uint32_t hv;
+	u32 hv;
 	Iphash **l, *h;
 
 	hv = iphash(c->raddr, c->rport, c->laddr, c->lport);
@@ -298,9 +298,9 @@ iphtrem(Ipht *ht, Conv *c)
  *	announced && *,*
  */
 Conv *
-iphtlook(Ipht *ht, uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp)
+iphtlook(Ipht *ht, u8 *sa, u16 sp, u8 *da, u16 dp)
 {
-	uint32_t hv;
+	u32 hv;
 	Iphash *h;
 	Conv *c;
 

sys/src/9/ip/ipifc.c

@@ -36,11 +36,11 @@ Medium *media[Maxmedia] = {0};
  *  cache of local addresses (addresses we answer to)
  */
 struct Ipself {
-	uint8_t a[IPaddrlen];
+	u8 a[IPaddrlen];
 	Ipself *hnext; /* next address in the hash table */
 	Iplink *link;  /* binding twixt Ipself and Ipifc */
-	uint32_t expire;
-	uint8_t type; /* type of address */
+	u32 expire;
+	u8 type; /* type of address */
 	int ref;
 	Ipself *next; /* free list */
 };
@@ -59,8 +59,8 @@ struct Ipselftab {
 typedef struct Ipmcast Ipmcast;
 struct Ipmcast {
 	Ipmcast *next;
-	uint8_t ma[IPaddrlen]; /* multicast address */
-	uint8_t ia[IPaddrlen]; /* interface address */
+	u8 ma[IPaddrlen]; /* multicast address */
+	u8 ia[IPaddrlen]; /* interface address */
 };
 
 /* quick hash for ip addresses */
@@ -68,11 +68,11 @@ struct Ipmcast {
 
 static char tifc[] = "ifc ";
 
-static void addselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uint8_t *a, int type);
-static void remselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uint8_t *a);
+static void addselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, u8 *a, int type);
+static void remselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, u8 *a);
 static char *ipifcjoinmulti(Ipifc *ifc, char **argv, int argc);
 static char *ipifcleavemulti(Ipifc *ifc, char **argv, int argc);
-static void ipifcregisterproxy(Fs *, Ipifc *, uint8_t *);
+static void ipifcregisterproxy(Fs *, Ipifc *, u8 *);
 static char *ipifcremlifc(Ipifc *, Iplifc *);
 
 /*
@@ -377,8 +377,8 @@ char *
 ipifcadd(Ipifc *ifc, char **argv, int argc, int tentative, Iplifc *lifcp)
 {
 	int i, type, mtu, sendnbrdisc = 0;
-	uint8_t ip[IPaddrlen], mask[IPaddrlen], rem[IPaddrlen];
-	uint8_t bcast[IPaddrlen], net[IPaddrlen];
+	u8 ip[IPaddrlen], mask[IPaddrlen], rem[IPaddrlen];
+	u8 bcast[IPaddrlen], net[IPaddrlen];
 	Iplifc *lifc, **l;
 	Fs *f;
 
@@ -597,7 +597,7 @@ char *
 ipifcrem(Ipifc *ifc, char **argv, int argc)
 {
 	char *rv;
-	uint8_t ip[IPaddrlen], mask[IPaddrlen], rem[IPaddrlen];
+	u8 ip[IPaddrlen], mask[IPaddrlen], rem[IPaddrlen];
 	Iplifc *lifc;
 
 	if(argc < 3)
@@ -633,7 +633,7 @@ ipifcrem(Ipifc *ifc, char **argv, int argc)
  * TRIP linecards
  */
 void
-ipifcaddroute(Fs *f, int vers, uint8_t *addr, uint8_t *mask, uint8_t *gate, int type)
+ipifcaddroute(Fs *f, int vers, u8 *addr, u8 *mask, u8 *gate, int type)
 {
 	Medium *m;
 	Conv **cp, **e;
@@ -651,7 +651,7 @@ ipifcaddroute(Fs *f, int vers, uint8_t *addr, uint8_t *mask, uint8_t *gate, int
 }
 
 void
-ipifcremroute(Fs *f, int vers, uint8_t *addr, uint8_t *mask)
+ipifcremroute(Fs *f, int vers, u8 *addr, u8 *mask)
 {
 	Medium *m;
 	Conv **cp, **e;
@@ -837,7 +837,7 @@ ipifcinit(Fs *f)
  *	called with c->car locked
  */
 static void
-addselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uint8_t *a, int type)
+addselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, u8 *a, int type)
 {
 	Ipself *p;
 	Iplink *lp;
@@ -908,7 +908,7 @@ static void
 iplinkfree(Iplink *p)
 {
 	Iplink **l, *np;
-	uint32_t now = NOW;
+	u32 now = NOW;
 
 	l = &freeiplink;
 	for(np = *l; np; np = *l){
@@ -928,7 +928,7 @@ static void
 ipselffree(Ipself *p)
 {
 	Ipself **l, *np;
-	uint32_t now = NOW;
+	u32 now = NOW;
 
 	l = &freeipself;
 	for(np = *l; np; np = *l){
@@ -950,7 +950,7 @@ ipselffree(Ipself *p)
  *	called with c->car locked
  */
 static void
-remselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, uint8_t *a)
+remselfcache(Fs *f, Ipifc *ifc, Iplifc *lifc, u8 *a)
 {
 	Ipself *p, **l;
 	Iplink *link, **l_self, **l_lifc;
@@ -1033,8 +1033,8 @@ enum {
 	Nstformat = 41,
 };
 
-int32_t
-ipselftabread(Fs *f, char *cp, uint32_t offset, int n)
+i32
+ipselftabread(Fs *f, char *cp, u32 offset, int n)
 {
 	int i, m, nifc, off;
 	Ipself *p;
@@ -1062,7 +1062,7 @@ ipselftabread(Fs *f, char *cp, uint32_t offset, int n)
 }
 
 int
-iptentative(Fs *f, uint8_t *addr)
+iptentative(Fs *f, u8 *addr)
 {
 	Ipself *p;
 
@@ -1082,7 +1082,7 @@ iptentative(Fs *f, uint8_t *addr)
  *	Rmcast
  */
 int
-ipforme(Fs *f, uint8_t *addr)
+ipforme(Fs *f, u8 *addr)
 {
 	Ipself *p;
 
@@ -1103,12 +1103,12 @@ ipforme(Fs *f, uint8_t *addr)
  *  return nil.
  */
 Ipifc *
-findipifc(Fs *f, uint8_t *remote, int type)
+findipifc(Fs *f, u8 *remote, int type)
 {
 	Ipifc *ifc, *x;
 	Iplifc *lifc;
 	Conv **cp, **e;
-	uint8_t gnet[IPaddrlen], xmask[IPaddrlen];
+	u8 gnet[IPaddrlen], xmask[IPaddrlen];
 
 	x = nil;
 	memset(xmask, 0, IPaddrlen);
@@ -1154,7 +1154,7 @@ enum {
 };
 
 int
-v6addrtype(uint8_t *addr)
+v6addrtype(u8 *addr)
 {
 	if(isv4(addr) || ipcmp(addr, IPnoaddr) == 0)
 		return unknownv6;
@@ -1169,7 +1169,7 @@ v6addrtype(uint8_t *addr)
 			  (lifc)->origint + (lifc)->preflt >= NOW / 1000)
 
 static void
-findprimaryipv6(Fs *f, uint8_t *local)
+findprimaryipv6(Fs *f, u8 *local)
 {
 	int atype, atypel;
 	Conv **cp, **e;
@@ -1204,7 +1204,7 @@ findprimaryipv6(Fs *f, uint8_t *local)
  *  returns first ip address configured
  */
 static void
-findprimaryipv4(Fs *f, uint8_t *local)
+findprimaryipv4(Fs *f, u8 *local)
 {
 	Conv **cp, **e;
 	Ipifc *ifc;
@@ -1228,11 +1228,11 @@ findprimaryipv4(Fs *f, uint8_t *local)
  *  local and return the ifc for that address
  */
 void
-findlocalip(Fs *f, uint8_t *local, uint8_t *remote)
+findlocalip(Fs *f, u8 *local, u8 *remote)
 {
 	int version, atype = unspecifiedv6, atypel = unknownv6;
 	int atyper, deprecated;
-	uint8_t gate[IPaddrlen], gnet[IPaddrlen];
+	u8 gate[IPaddrlen], gnet[IPaddrlen];
 	Ipifc *ifc;
 	Iplifc *lifc;
 	Route *r;
@@ -1313,7 +1313,7 @@ out:
  *  return first v4 address associated with an interface
  */
 int
-ipv4local(Ipifc *ifc, uint8_t *addr)
+ipv4local(Ipifc *ifc, u8 *addr)
 {
 	Iplifc *lifc;
 
@@ -1330,7 +1330,7 @@ ipv4local(Ipifc *ifc, uint8_t *addr)
  *  return first v6 address associated with an interface
  */
 int
-ipv6local(Ipifc *ifc, uint8_t *addr)
+ipv6local(Ipifc *ifc, u8 *addr)
 {
 	Iplifc *lifc;
 
@@ -1344,7 +1344,7 @@ ipv6local(Ipifc *ifc, uint8_t *addr)
 }
 
 int
-ipv6anylocal(Ipifc *ifc, uint8_t *addr)
+ipv6anylocal(Ipifc *ifc, u8 *addr)
 {
 	Iplifc *lifc;
 
@@ -1361,7 +1361,7 @@ ipv6anylocal(Ipifc *ifc, uint8_t *addr)
  *  see if this address is bound to the interface
  */
 Iplifc *
-iplocalonifc(Ipifc *ifc, uint8_t *ip)
+iplocalonifc(Ipifc *ifc, u8 *ip)
 {
 	Iplifc *lifc;
 
@@ -1375,10 +1375,10 @@ iplocalonifc(Ipifc *ifc, uint8_t *ip)
  *  See if we're proxying for this address on this interface
  */
 int
-ipproxyifc(Fs *f, Ipifc *ifc, uint8_t *ip)
+ipproxyifc(Fs *f, Ipifc *ifc, u8 *ip)
 {
 	Route *r;
-	uint8_t net[IPaddrlen];
+	u8 net[IPaddrlen];
 	Iplifc *lifc;
 
 	/* see if this is a direct connected pt to pt address */
@@ -1399,7 +1399,7 @@ ipproxyifc(Fs *f, Ipifc *ifc, uint8_t *ip)
  *  return multicast version if any
  */
 int
-ipismulticast(uint8_t *ip)
+ipismulticast(u8 *ip)
 {
 	if(isv4(ip)){
 		if(ip[IPv4off] >= 0xe0 && ip[IPv4off] < 0xf0)
@@ -1409,7 +1409,7 @@ ipismulticast(uint8_t *ip)
 	return 0;
 }
 int
-ipisbm(uint8_t *ip)
+ipisbm(u8 *ip)
 {
 	if(isv4(ip)){
 		if(ip[IPv4off] >= 0xe0 && ip[IPv4off] < 0xf0)
@@ -1425,7 +1425,7 @@ ipisbm(uint8_t *ip)
  *  add a multicast address to an interface, called with c->car locked
  */
 void
-ipifcaddmulti(Conv *c, uint8_t *ma, uint8_t *ia)
+ipifcaddmulti(Conv *c, u8 *ma, u8 *ia)
 {
 	Proc *up = externup();
 	Ipifc *ifc;
@@ -1466,7 +1466,7 @@ ipifcaddmulti(Conv *c, uint8_t *ma, uint8_t *ia)
  *  remove a multicast address from an interface, called with c->car locked
  */
 void
-ipifcremmulti(Conv *c, uint8_t *ma, uint8_t *ia)
+ipifcremmulti(Conv *c, u8 *ma, u8 *ia)
 {
 	Proc *up = externup();
 	Ipmulti *multi, **l;
@@ -1529,13 +1529,13 @@ ipifcleavemulti(Ipifc *ifc, char **argv, int argc)
 }
 
 static void
-ipifcregisterproxy(Fs *f, Ipifc *ifc, uint8_t *ip)
+ipifcregisterproxy(Fs *f, Ipifc *ifc, u8 *ip)
 {
 	Conv **cp, **e;
 	Ipifc *nifc;
 	Iplifc *lifc;
 	Medium *m;
-	uint8_t net[IPaddrlen];
+	u8 net[IPaddrlen];
 
 	/* register the address on any network that will proxy for us */
 	e = &f->ipifc->conv[f->ipifc->nc];
@@ -1613,11 +1613,11 @@ char *
 ipifcadd6(Ipifc *ifc, char **argv, int argc)
 {
 	int plen = 64;
-	int32_t origint = NOW / 1000, preflt = ~0L, validlt = ~0L;
+	i32 origint = NOW / 1000, preflt = ~0L, validlt = ~0L;
 	char addr[Maxv6repr], preflen[6];
 	char *params[3];
-	uint8_t autoflag = 1, onlink = 1;
-	uint8_t prefix[IPaddrlen];
+	u8 autoflag = 1, onlink = 1;
+	u8 prefix[IPaddrlen];
 	Iplifc *lifc;
 
 	switch(argc){

sys/src/9/ip/ipmux.c

@@ -25,18 +25,18 @@ typedef struct Ipmux Ipmux;
 
 typedef struct Myip4hdr Myip4hdr;
 struct Myip4hdr {
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* ip->identification */
-	uint8_t frag[2];   /* Fragment information */
-	uint8_t ttl;	   /* Time to live */
-	uint8_t proto;	   /* Protocol */
-	uint8_t cksum[2];  /* Header checksum */
-	uint8_t src[4];	   /* IP source */
-	uint8_t dst[4];	   /* IP destination */
-
-	uint8_t data[1]; /* start of data */
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* ip->identification */
+	u8 frag[2];   /* Fragment information */
+	u8 ttl;	   /* Time to live */
+	u8 proto;	   /* Protocol */
+	u8 cksum[2];  /* Header checksum */
+	u8 src[4];	   /* IP source */
+	u8 dst[4];	   /* IP destination */
+
+	u8 data[1]; /* start of data */
 };
 Myip4hdr *ipoff = 0;
 
@@ -75,16 +75,16 @@ char *ftname[] =
 struct Ipmux {
 	Ipmux *yes;
 	Ipmux *no;
-	uint8_t type;	 /* type of field(Txxxx) */
-	uint8_t ctype;	 /* tupe of comparison(Cxxxx) */
-	uint8_t len;	 /* length in bytes of item to compare */
-	uint8_t n;	 /* number of items val points to */
+	u8 type;	 /* type of field(Txxxx) */
+	u8 ctype;	 /* tupe of comparison(Cxxxx) */
+	u8 len;	 /* length in bytes of item to compare */
+	u8 n;	 /* number of items val points to */
 	short off;	 /* offset of comparison */
 	short eoff;	 /* end offset of comparison */
-	uint8_t skiphdr; /* should offset start after ipheader */
-	uint8_t *val;
-	uint8_t *mask;
-	uint8_t *e; /* val+n*len*/
+	u8 skiphdr; /* should offset start after ipheader */
+	u8 *val;
+	u8 *mask;
+	u8 *e; /* val+n*len*/
 
 	int ref; /* so we can garbage collect */
 	Conv *conv;
@@ -133,12 +133,12 @@ parseop(char **pp)
 	p = skipwhite(p);
 	if(strncmp(p, "dst", 3) == 0){
 		type = Tdst;
-		off = (int64_t)(ipoff->dst);
+		off = (i64)(ipoff->dst);
 		len = IPv4addrlen;
 		p += 3;
 	} else if(strncmp(p, "src", 3) == 0){
 		type = Tsrc;
-		off = (int64_t)(ipoff->src);
+		off = (i64)(ipoff->src);
 		len = IPv4addrlen;
 		p += 3;
 	} else if(strncmp(p, "ifc", 3) == 0){
@@ -148,7 +148,7 @@ parseop(char **pp)
 		p += 3;
 	} else if(strncmp(p, "proto", 5) == 0){
 		type = Tproto;
-		off = (int64_t) & (ipoff->proto);
+		off = (i64) & (ipoff->proto);
 		len = 1;
 		p += 5;
 	} else if(strncmp(p, "data", 4) == 0 || strncmp(p, "iph", 3) == 0){
@@ -221,7 +221,7 @@ hextoi(char *p)
 }
 
 static void
-parseval(uint8_t *v, char *p, int len)
+parseval(u8 *v, char *p, int len)
 {
 	while(*p && len-- > 0){
 		*v++ = hextoi(p);
@@ -237,7 +237,7 @@ parsemux(char *p)
 	char *val;
 	char *mask;
 	char *vals[20];
-	uint8_t *v;
+	u8 *v;
 
 	/* parse operand */
 	f = parseop(&p);
@@ -345,8 +345,8 @@ ipmuxcmp(Ipmux *a, Ipmux *b)
 		return n;
 
 	/* compare offsets, call earlier ones more specific */
-	n = (a->off + ((int)a->skiphdr) * (int64_t)ipoff->data) -
-	    (b->off + ((int)b->skiphdr) * (int64_t)ipoff->data);
+	n = (a->off + ((int)a->skiphdr) * (i64)ipoff->data) -
+	    (b->off + ((int)b->skiphdr) * (i64)ipoff->data);
 	if(n != 0)
 		return n;
 
@@ -660,7 +660,7 @@ ipmuxiput(Proto *p, Ipifc *ifc, Block *bp)
 {
 	int len, hl;
 	Fs *f = p->f;
-	uint8_t *m, *h, *v, *e, *ve, *hp;
+	u8 *m, *h, *v, *e, *ve, *hp;
 	Conv *c;
 	Ipmux *mux;
 	Myip4hdr *ip;
@@ -695,27 +695,27 @@ ipmuxiput(Proto *p, Ipifc *ifc, Block *bp)
 				goto yes;
 			break;
 		case Cshort:
-			if(*((uint16_t *)mux->val) == *(uint16_t *)hp)
+			if(*((u16 *)mux->val) == *(u16 *)hp)
 				goto yes;
 			break;
 		case Cmshort:
-			if((*(uint16_t *)hp & (*((uint16_t *)mux->mask))) == *((uint16_t *)mux->val))
+			if((*(u16 *)hp & (*((u16 *)mux->mask))) == *((u16 *)mux->val))
 				goto yes;
 			break;
 		case Cint32_t:
-			if(*((uint32_t *)mux->val) == *(uint32_t *)hp)
+			if(*((u32 *)mux->val) == *(u32 *)hp)
 				goto yes;
 			break;
 		case Cmint32_t:
-			if((*(uint32_t *)hp & (*((uint32_t *)mux->mask))) == *((uint32_t *)mux->val))
+			if((*(u32 *)hp & (*((u32 *)mux->mask))) == *((u32 *)mux->val))
 				goto yes;
 			break;
 		case Cifc:
-			if(*((uint32_t *)mux->val) == *(uint32_t *)(ifc->lifc->local + IPv4off))
+			if(*((u32 *)mux->val) == *(u32 *)(ifc->lifc->local + IPv4off))
 				goto yes;
 			break;
 		case Cmifc:
-			if((*(uint32_t *)(ifc->lifc->local + IPv4off) & (*((uint32_t *)mux->mask))) == *((uint32_t *)mux->val))
+			if((*(u32 *)(ifc->lifc->local + IPv4off) & (*((u32 *)mux->mask))) == *((u32 *)mux->val))
 				goto yes;
 			break;
 		default:
@@ -771,7 +771,7 @@ static int
 ipmuxsprint(Ipmux *mux, int level, char *buf, int len)
 {
 	int i, j, n;
-	uint8_t *v;
+	u8 *v;
 
 	n = 0;
 	for(i = 0; i < level; i++)
@@ -781,8 +781,8 @@ ipmuxsprint(Ipmux *mux, int level, char *buf, int len)
 		return n;
 	}
 	n += snprint(buf + n, len - n, "h[%d:%d]&",
-		     mux->off + ((int)mux->skiphdr) * ((int64_t)ipoff->data),
-		     mux->off + (((int)mux->skiphdr) * ((int64_t)ipoff->data)) + mux->len - 1);
+		     mux->off + ((int)mux->skiphdr) * ((i64)ipoff->data),
+		     mux->off + (((int)mux->skiphdr) * ((i64)ipoff->data)) + mux->len - 1);
 	for(i = 0; i < mux->len; i++)
 		n += snprint(buf + n, len - n, "%2.2x", mux->mask[i]);
 	n += snprint(buf + n, len - n, "=");

sys/src/9/ip/iproute.c

@@ -24,7 +24,7 @@ static void calcd(Route *);
 static Route *v4freelist;
 static Route *v6freelist;
 static RWlock routelock;
-static uint32_t v4routegeneration, v6routegeneration;
+static u32 v4routegeneration, v6routegeneration;
 
 static void
 freeroute(Route *r)
@@ -90,7 +90,7 @@ addqueue(Route **q, Route *r)
  *   compare 2 v6 addresses
  */
 static int
-lcmp(uint32_t *a, uint32_t *b)
+lcmp(u32 *a, u32 *b)
 {
 	int i;
 
@@ -295,12 +295,12 @@ addnode(Fs *f, Route **cur, Route *new)
 #define V4H(a) ((a & 0x07ffffff) >> (32 - Lroot - 5))
 
 void
-v4addroute(Fs *f, char *tag, uint8_t *a, uint8_t *mask, uint8_t *gate, int type)
+v4addroute(Fs *f, char *tag, u8 *a, u8 *mask, u8 *gate, int type)
 {
 	Route *p;
-	uint32_t sa;
-	uint32_t m;
-	uint32_t ea;
+	u32 sa;
+	u32 m;
+	u32 ea;
 	int h, eh;
 
 	m = nhgetl(mask);
@@ -333,11 +333,11 @@ v4addroute(Fs *f, char *tag, uint8_t *a, uint8_t *mask, uint8_t *gate, int type)
 #define ISDFLT(a, mask, tag) ((ipcmp((a), v6Unspecified) == 0) && (ipcmp((mask), v6Unspecified) == 0) && (strcmp((tag), "ra") != 0))
 
 void
-v6addroute(Fs *f, char *tag, uint8_t *a, uint8_t *mask, uint8_t *gate, int type)
+v6addroute(Fs *f, char *tag, u8 *a, u8 *mask, u8 *gate, int type)
 {
 	Route *p;
-	uint32_t sa[IPllen], ea[IPllen];
-	uint32_t x, y;
+	u32 sa[IPllen], ea[IPllen];
+	u32 x, y;
 	int h, eh;
 
 	/*
@@ -403,12 +403,12 @@ looknode(Route **cur, Route *r)
 }
 
 void
-v4delroute(Fs *f, uint8_t *a, uint8_t *mask, int dolock)
+v4delroute(Fs *f, u8 *a, u8 *mask, int dolock)
 {
 	Route **r, *p;
 	Route rt;
 	int h, eh;
-	uint32_t m;
+	u32 m;
 
 	m = nhgetl(mask);
 	rt.v4.address = nhgetl(a) & m;
@@ -444,12 +444,12 @@ v4delroute(Fs *f, uint8_t *a, uint8_t *mask, int dolock)
 }
 
 void
-v6delroute(Fs *f, uint8_t *a, uint8_t *mask, int dolock)
+v6delroute(Fs *f, u8 *a, u8 *mask, int dolock)
 {
 	Route **r, *p;
 	Route rt;
 	int h, eh;
-	uint32_t x, y;
+	u32 x, y;
 
 	for(h = 0; h < IPllen; h++){
 		x = nhgetl(a + 4 * h);
@@ -488,11 +488,11 @@ v6delroute(Fs *f, uint8_t *a, uint8_t *mask, int dolock)
 }
 
 Route *
-v4lookup(Fs *f, uint8_t *a, Conv *c)
+v4lookup(Fs *f, u8 *a, Conv *c)
 {
 	Route *p, *q;
-	uint32_t la;
-	uint8_t gate[IPaddrlen];
+	u32 la;
+	u8 gate[IPaddrlen];
 	Ipifc *ifc;
 
 	if(c != nil && c->r != nil && c->r->RouteTree.ifc != nil && c->rgen == v4routegeneration)
@@ -532,13 +532,13 @@ v4lookup(Fs *f, uint8_t *a, Conv *c)
 }
 
 Route *
-v6lookup(Fs *f, uint8_t *a, Conv *c)
+v6lookup(Fs *f, u8 *a, Conv *c)
 {
 	Route *p, *q;
-	uint32_t la[IPllen];
+	u32 la[IPllen];
 	int h;
-	uint32_t x, y;
-	uint8_t gate[IPaddrlen];
+	u32 x, y;
+	u8 gate[IPaddrlen];
 	Ipifc *ifc;
 
 	if(memcmp(a, v4prefix, IPv4off) == 0){
@@ -626,7 +626,7 @@ routetype(int type, char *p)
 static char *rformat = "%-15I %-4M %-15I %4.4s %4.4s %3s\n";
 
 void
-convroute(Route *r, uint8_t *addr, uint8_t *mask, uint8_t *gate, char *t, int *nifc)
+convroute(Route *r, u8 *addr, u8 *mask, u8 *gate, char *t, int *nifc)
 {
 	int i;
 
@@ -661,7 +661,7 @@ sprintroute(Route *r, Routewalk *rw)
 {
 	int nifc, n;
 	char t[5], *iname, ifbuf[5];
-	uint8_t addr[IPaddrlen], mask[IPaddrlen], gate[IPaddrlen];
+	u8 addr[IPaddrlen], mask[IPaddrlen], gate[IPaddrlen];
 	char *p;
 
 	convroute(r, addr, mask, gate, t, &nifc);
@@ -729,8 +729,8 @@ ipwalkroutes(Fs *f, Routewalk *rw)
 	runlock(&routelock);
 }
 
-int32_t
-routeread(Fs *f, char *p, uint32_t offset, int n)
+i32
+routeread(Fs *f, char *p, u32 offset, int n)
 {
 	Routewalk rw;
 
@@ -750,9 +750,9 @@ routeread(Fs *f, char *p, uint32_t offset, int n)
 void
 delroute(Fs *f, Route *r, int dolock)
 {
-	uint8_t addr[IPaddrlen];
-	uint8_t mask[IPaddrlen];
-	uint8_t gate[IPaddrlen];
+	u8 addr[IPaddrlen];
+	u8 mask[IPaddrlen];
+	u8 gate[IPaddrlen];
 	char t[5];
 	int nifc;
 
@@ -788,7 +788,7 @@ routeflush(Fs *f, Route *r, char *tag)
 }
 
 Route *
-iproute(Fs *fs, uint8_t *ip)
+iproute(Fs *fs, u8 *ip)
 {
 	if(isv4(ip))
 		return v4lookup(fs, ip + IPv4off, nil);
@@ -801,7 +801,7 @@ printroute(Route *r)
 {
 	int nifc;
 	char t[5], *iname, ifbuf[5];
-	uint8_t addr[IPaddrlen], mask[IPaddrlen], gate[IPaddrlen];
+	u8 addr[IPaddrlen], mask[IPaddrlen], gate[IPaddrlen];
 
 	convroute(r, addr, mask, gate, t, &nifc);
 	iname = "-";
@@ -812,16 +812,16 @@ printroute(Route *r)
 	print(rformat, addr, mask, gate, t, r->RouteTree.tag, iname);
 }
 
-int32_t
+i32
 routewrite(Fs *f, Chan *c, char *p, int n)
 {
 	Proc *up = externup();
 	int h, changed;
 	char *tag;
 	Cmdbuf *cb;
-	uint8_t addr[IPaddrlen];
-	uint8_t mask[IPaddrlen];
-	uint8_t gate[IPaddrlen];
+	u8 addr[IPaddrlen];
+	u8 mask[IPaddrlen];
+	u8 gate[IPaddrlen];
 	IPaux *a, *na;
 	Route *q;
 

sys/src/9/ip/ipv6.c

@@ -33,7 +33,7 @@ Fragment6 *ipfragallo6(IP *);
 void ipfragfree6(IP *, Fragment6 *);
 Block *procopts(Block *bp);
 static Block *procxtns(IP *ip, Block *bp, int doreasm);
-int unfraglen(Block *bp, uint8_t *nexthdr, int setfh);
+int unfraglen(Block *bp, u8 *nexthdr, int setfh);
 
 int
 ipoput6(Fs *f, Block *bp, int gating, int ttl, int tos, Conv *c)
@@ -41,7 +41,7 @@ ipoput6(Fs *f, Block *bp, int gating, int ttl, int tos, Conv *c)
 	Proc *up = externup();
 	int medialen, len, chunk, uflen, flen, seglen, lid, offset, fragoff;
 	int morefrags, blklen, rv = 0, tentative;
-	uint8_t *gate, nexthdr;
+	u8 *gate, nexthdr;
 	Block *xp, *nb;
 	Fraghdr6 fraghdr;
 	IP *ip;
@@ -234,8 +234,8 @@ void
 ipiput6(Fs *f, Ipifc *ifc, Block *bp)
 {
 	int hl, hop, tos, notforme, tentative;
-	uint8_t proto;
-	uint8_t v6dst[IPaddrlen];
+	u8 proto;
+	u8 v6dst[IPaddrlen];
 	IP *ip;
 	Ip6hdr *h;
 	Proto *p;
@@ -401,7 +401,7 @@ static Block *
 procxtns(IP *ip, Block *bp, int doreasm)
 {
 	int offset;
-	uint8_t proto;
+	u8 proto;
 	Ip6hdr *h;
 
 	h = (Ip6hdr *)bp->rp;
@@ -426,9 +426,9 @@ procxtns(IP *ip, Block *bp, int doreasm)
  * field of the last header in the "Unfragmentable part" is set to FH.
  */
 int
-unfraglen(Block *bp, uint8_t *nexthdr, int setfh)
+unfraglen(Block *bp, u8 *nexthdr, int setfh)
 {
-	uint8_t *p, *q;
+	u8 *p, *q;
 	int ufl, hs;
 
 	p = bp->rp;
@@ -463,7 +463,7 @@ ip6reassemble(IP *ip, int uflen, Block *bp, Ip6hdr *ih)
 {
 	int fend, offset, ovlap, len, fragsize, pktposn;
 	uint id;
-	uint8_t src[IPaddrlen], dst[IPaddrlen];
+	u8 src[IPaddrlen], dst[IPaddrlen];
 	Block *bl, **l, *last, *prev;
 	Fraghdr6 *fraghdr;
 	Fragment6 *f, *fnext;

sys/src/9/ip/ipv6.h

@@ -124,21 +124,21 @@ typedef struct Fraghdr6 Fraghdr6;
 
 /* we do this in case there's padding at the end of Ip6hdr */
 #define IPV6HDR                                                              \
-	uint8_t vcf[4];	     /* version:4, traffic class:8, flow label:20 */ \
-	uint8_t ploadlen[2]; /* payload length: packet length - 40 */        \
-	uint8_t proto;	     /* next header type */                          \
-	uint8_t ttl;	     /* hop limit */                                 \
-	uint8_t src[IPaddrlen];                                              \
-	uint8_t dst[IPaddrlen]
+	u8 vcf[4];	     /* version:4, traffic class:8, flow label:20 */ \
+	u8 ploadlen[2];      /* payload length: packet length - 40 */        \
+	u8 proto;	     /* next header type */                          \
+	u8 ttl;	             /* hop limit */                                 \
+	u8 src[IPaddrlen];                                                   \
+	u8 dst[IPaddrlen]
 
 struct Ip6hdr {
 	IPV6HDR;
-	uint8_t payload[];
+	u8 payload[];
 };
 
 struct Opthdr { /* unused */
-	uint8_t nexthdr;
-	uint8_t len;
+	u8 nexthdr;
+	u8 len;
 };
 
 /*
@@ -148,34 +148,34 @@ struct Opthdr { /* unused */
  * against type 0 header.
  */
 struct Routinghdr { /* unused */
-	uint8_t nexthdr;
-	uint8_t len;
-	uint8_t rtetype;
-	uint8_t segrem;
+	u8 nexthdr;
+	u8 len;
+	u8 rtetype;
+	u8 segrem;
 };
 
 struct Fraghdr6 {
-	uint8_t nexthdr;
-	uint8_t res;
-	uint8_t offsetRM[2]; /* Offset, Res, M flag */
-	uint8_t id[4];
+	u8 nexthdr;
+	u8 res;
+	u8 offsetRM[2]; /* Offset, Res, M flag */
+	u8 id[4];
 };
 
-extern uint8_t v6allnodesN[IPaddrlen];
-extern uint8_t v6allnodesL[IPaddrlen];
-extern uint8_t v6allroutersN[IPaddrlen];
-extern uint8_t v6allroutersL[IPaddrlen];
-extern uint8_t v6allnodesNmask[IPaddrlen];
-extern uint8_t v6allnodesLmask[IPaddrlen];
-extern uint8_t v6solicitednode[IPaddrlen];
-extern uint8_t v6solicitednodemask[IPaddrlen];
-extern uint8_t v6Unspecified[IPaddrlen];
-extern uint8_t v6loopback[IPaddrlen];
-extern uint8_t v6loopbackmask[IPaddrlen];
-extern uint8_t v6linklocal[IPaddrlen];
-extern uint8_t v6linklocalmask[IPaddrlen];
-extern uint8_t v6multicast[IPaddrlen];
-extern uint8_t v6multicastmask[IPaddrlen];
+extern u8 v6allnodesN[IPaddrlen];
+extern u8 v6allnodesL[IPaddrlen];
+extern u8 v6allroutersN[IPaddrlen];
+extern u8 v6allroutersL[IPaddrlen];
+extern u8 v6allnodesNmask[IPaddrlen];
+extern u8 v6allnodesLmask[IPaddrlen];
+extern u8 v6solicitednode[IPaddrlen];
+extern u8 v6solicitednodemask[IPaddrlen];
+extern u8 v6Unspecified[IPaddrlen];
+extern u8 v6loopback[IPaddrlen];
+extern u8 v6loopbackmask[IPaddrlen];
+extern u8 v6linklocal[IPaddrlen];
+extern u8 v6linklocalmask[IPaddrlen];
+extern u8 v6multicast[IPaddrlen];
+extern u8 v6multicastmask[IPaddrlen];
 
 extern int v6llpreflen;
 extern int v6mcpreflen;
@@ -185,9 +185,9 @@ extern int v6aLpreflen;
 
 extern int ReTransTimer;
 
-void ipv62smcast(uint8_t *, uint8_t *);
-void icmpns(Fs *f, uint8_t *src, int suni, uint8_t *targ, int tuni, uint8_t *mac);
-void icmpna(Fs *f, uint8_t *src, uint8_t *dst, uint8_t *targ, uint8_t *mac, uint8_t flags);
+void ipv62smcast(u8 *, u8 *);
+void icmpns(Fs *f, u8 *src, int suni, u8 *targ, int tuni, u8 *mac);
+void icmpna(Fs *f, u8 *src, u8 *dst, u8 *targ, u8 *mac, u8 flags);
 void icmpttlexceeded6(Fs *f, Ipifc *ifc, Block *bp);
 void icmppkttoobig6(Fs *f, Ipifc *ifc, Block *bp);
 void icmphostunr(Fs *f, Ipifc *ifc, Block *bp, int code, int free);

sys/src/9/ip/loopbackmedium.c

@@ -62,7 +62,7 @@ loopbackunbind(Ipifc *ifc)
 }
 
 static void
-loopbackbwrite(Ipifc *ifc, Block *bp, int i, uint8_t *c)
+loopbackbwrite(Ipifc *ifc, Block *bp, int i, u8 *c)
 {
 	LB *lb;
 

sys/src/9/ip/netdevmedium.c

@@ -18,7 +18,7 @@
 
 static void netdevbind(Ipifc *ifc, int argc, char **argv);
 static void netdevunbind(Ipifc *ifc);
-static void netdevbwrite(Ipifc *ifc, Block *bp, int version, uint8_t *ip);
+static void netdevbwrite(Ipifc *ifc, Block *bp, int version, u8 *ip);
 static void netdevread(void *a);
 
 typedef struct Netdevrock Netdevrock;
@@ -91,7 +91,7 @@ netdevunbind(Ipifc *ifc)
  *  called by ipoput with a single block to write
  */
 static void
-netdevbwrite(Ipifc *ifc, Block *bp, int i, uint8_t *c)
+netdevbwrite(Ipifc *ifc, Block *bp, int i, u8 *c)
 {
 	Netdevrock *er = ifc->arg;
 

sys/src/9/ip/netlog.c

@@ -31,7 +31,7 @@ struct Netlog {
 	int len;
 
 	int logmask;		   /* mask of things to debug */
-	uint8_t iponly[IPaddrlen]; /* ip address to print debugging for */
+	u8 iponly[IPaddrlen]; /* ip address to print debugging for */
 	int iponlyset;
 
 	QLock ql;
@@ -171,8 +171,8 @@ netlogready(void *a)
 	return f->alog->len;
 }
 
-int32_t
-netlogread(Fs *f, void *a, uint32_t u, int32_t n)
+i32
+netlogread(Fs *f, void *a, u32 u, i32 n)
 {
 	Proc *up = externup();
 	int i, d;

sys/src/9/ip/nullmedium.c

@@ -28,7 +28,7 @@ nullunbind(Ipifc *ipifc)
 }
 
 static void
-nullbwrite(Ipifc *ipifc, Block *block, int i, uint8_t *c)
+nullbwrite(Ipifc *ipifc, Block *block, int i, u8 *c)
 {
 	error("nullbwrite");
 }

sys/src/9/ip/pktmedium.c

@@ -18,7 +18,7 @@
 
 static void pktbind(Ipifc *, int, char **);
 static void pktunbind(Ipifc *);
-static void pktbwrite(Ipifc *, Block *, int, uint8_t *);
+static void pktbwrite(Ipifc *, Block *, int, u8 *);
 static void pktin(Fs *, Ipifc *, Block *);
 
 Medium pktmedium =
@@ -57,7 +57,7 @@ pktunbind(Ipifc *ipifc)
  *  called by ipoput with a single packet to write
  */
 static void
-pktbwrite(Ipifc *ifc, Block *bp, int i, uint8_t *c)
+pktbwrite(Ipifc *ifc, Block *bp, int i, u8 *c)
 {
 	/* enqueue onto the conversation's rq */
 	bp = concatblock(bp);

sys/src/9/ip/ptclbsum.c

@@ -64,7 +64,7 @@
 		ADDCARRY(sum);                                                    \
 	}
 
-static const uint32_t in_masks[] = {
+static const u32 in_masks[] = {
 	/*0 bytes*/ /*1 byte*/ /*2 bytes*/		/*3 bytes*/
 	0x00000000, 0x000000FF, 0x0000FFFF, 0x00FFFFFF, /* offset 0 */
 	0x00000000, 0x0000FF00, 0x00FFFF00, 0xFFFFFF00, /* offset 1 */
@@ -73,33 +73,33 @@ static const uint32_t in_masks[] = {
 };
 
 union l_util {
-	uint16_t s[2];
-	uint32_t l;
+	u16 s[2];
+	u32 l;
 };
 union q_util {
-	uint16_t s[4];
-	uint32_t l[2];
-	uint64_t q;
+	u16 s[4];
+	u32 l[2];
+	u64 q;
 };
 
-static uint64_t
+static u64
 in_cksumdata(const void *buf, int len)
 {
-	const uint32_t *lw = (const uint32_t *)buf;
-	uint64_t sum = 0;
-	uint64_t prefilled;
+	const u32 *lw = (const u32 *)buf;
+	u64 sum = 0;
+	u64 prefilled;
 	int offset;
 	union q_util q_util;
 
 	if((3 & (long)lw) == 0 && len == 20){
-		sum = (uint64_t)lw[0] + lw[1] + lw[2] + lw[3] + lw[4];
+		sum = (u64)lw[0] + lw[1] + lw[2] + lw[3] + lw[4];
 		REDUCE32;
 		return sum;
 	}
 
 	if((offset = 3 & (long)lw) != 0){
-		const uint32_t *masks = in_masks + (offset << 2);
-		lw = (uint32_t *)(((long)lw) - offset);
+		const u32 *masks = in_masks + (offset << 2);
+		lw = (u32 *)(((long)lw) - offset);
 		sum = *lw++ & masks[len >= 3 ? 3 : len];
 		len -= 4 - offset;
 		if(len <= 0){
@@ -135,7 +135,7 @@ in_cksumdata(const void *buf, int len)
 	 */
 	prefilled = lw[0];
 	while((len -= 32) >= 4){
-		uint64_t prefilling = lw[8];
+		u64 prefilling = lw[8];
 		sum += prefilled + lw[1] + lw[2] + lw[3] + lw[4] + lw[5] + lw[6] + lw[7];
 		lw += 8;
 		prefilled = prefilling;
@@ -147,26 +147,26 @@ in_cksumdata(const void *buf, int len)
 		len += 32;
 	}
 	while((len -= 16) >= 0){
-		sum += (uint64_t)lw[0] + lw[1] + lw[2] + lw[3];
+		sum += (u64)lw[0] + lw[1] + lw[2] + lw[3];
 		lw += 4;
 	}
 	len += 16;
 	while((len -= 4) >= 0){
-		sum += (uint64_t)*lw++;
+		sum += (u64)*lw++;
 	}
 	len += 4;
 	if(len > 0)
-		sum += (uint64_t)(in_masks[len] & *lw);
+		sum += (u64)(in_masks[len] & *lw);
 	REDUCE32;
 	return sum;
 }
-uint16_t
-ptclbsum(uint8_t *addr, int len)
+u16
+ptclbsum(u8 *addr, int len)
 {
-	uint64_t sum = in_cksumdata(addr, len);
+	u64 sum = in_cksumdata(addr, len);
 	union q_util q_util;
 	union l_util l_util;
 	REDUCE16;
-	return ((sum & (uint16_t)0x00ffU) << 8) |
-	       ((sum & (uint16_t)0xff00U) >> 8);
+	return ((sum & (u16)0x00ffU) << 8) |
+	       ((sum & (u16)0xff00U) >> 8);
 }

sys/src/9/ip/rudp.c

@@ -50,53 +50,53 @@ enum {
 typedef struct Udphdr Udphdr;
 struct Udphdr {
 	/* ip header */
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* Identification */
-	uint8_t frag[2];   /* Fragment information */
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* Identification */
+	u8 frag[2];   /* Fragment information */
 
 	/* pseudo header starts here */
-	uint8_t Unused;
-	uint8_t udpproto;   /* Protocol */
-	uint8_t udpplen[2]; /* Header plus data length */
-	uint8_t udpsrc[4];  /* Ip source */
-	uint8_t udpdst[4];  /* Ip destination */
+	u8 Unused;
+	u8 udpproto;   /* Protocol */
+	u8 udpplen[2]; /* Header plus data length */
+	u8 udpsrc[4];  /* Ip source */
+	u8 udpdst[4];  /* Ip destination */
 
 	/* udp header */
-	uint8_t udpsport[2]; /* Source port */
-	uint8_t udpdport[2]; /* Destination port */
-	uint8_t udplen[2];   /* data length */
-	uint8_t udpcksum[2]; /* Checksum */
+	u8 udpsport[2]; /* Source port */
+	u8 udpdport[2]; /* Destination port */
+	u8 udplen[2];   /* data length */
+	u8 udpcksum[2]; /* Checksum */
 };
 
 typedef struct Rudphdr Rudphdr;
 struct Rudphdr {
 	/* ip header */
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* Identification */
-	uint8_t frag[2];   /* Fragment information */
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* Identification */
+	u8 frag[2];   /* Fragment information */
 
 	/* pseudo header starts here */
-	uint8_t Unused;
-	uint8_t udpproto;   /* Protocol */
-	uint8_t udpplen[2]; /* Header plus data length */
-	uint8_t udpsrc[4];  /* Ip source */
-	uint8_t udpdst[4];  /* Ip destination */
+	u8 Unused;
+	u8 udpproto;   /* Protocol */
+	u8 udpplen[2]; /* Header plus data length */
+	u8 udpsrc[4];  /* Ip source */
+	u8 udpdst[4];  /* Ip destination */
 
 	/* udp header */
-	uint8_t udpsport[2]; /* Source port */
-	uint8_t udpdport[2]; /* Destination port */
-	uint8_t udplen[2];   /* data length (includes rudp header) */
-	uint8_t udpcksum[2]; /* Checksum */
+	u8 udpsport[2]; /* Source port */
+	u8 udpdport[2]; /* Destination port */
+	u8 udplen[2];   /* data length (includes rudp header) */
+	u8 udpcksum[2]; /* Checksum */
 
 	/* rudp header */
-	uint8_t relseq[4];  /* id of this packet (or 0) */
-	uint8_t relsgen[4]; /* generation/time stamp */
-	uint8_t relack[4];  /* packet being acked (or 0) */
-	uint8_t relagen[4]; /* generation/time stamp */
+	u8 relseq[4];  /* id of this packet (or 0) */
+	u8 relsgen[4]; /* generation/time stamp */
+	u8 relack[4];  /* packet being acked (or 0) */
+	u8 relagen[4]; /* generation/time stamp */
 };
 
 /*
@@ -108,8 +108,8 @@ struct Reliable {
 
 	Reliable *next;
 
-	uint8_t addr[IPaddrlen]; /* always V6 when put here */
-	uint16_t port;
+	u8 addr[IPaddrlen]; /* always V6 when put here */
+	u16 port;
 
 	Block *unacked;	    /* unacked msg list */
 	Block *unackedtail; /*  and its tail */
@@ -117,14 +117,14 @@ struct Reliable {
 	int timeout; /* time since first unacked msg sent */
 	int xmits;   /* number of times first unacked msg sent */
 
-	uint32_t sndseq; /* next packet to be sent */
-	uint32_t sndgen; /*  and its generation */
+	u32 sndseq; /* next packet to be sent */
+	u32 sndgen; /*  and its generation */
 
-	uint32_t rcvseq; /* last packet received */
-	uint32_t rcvgen; /*  and its generation */
+	u32 rcvseq; /* last packet received */
+	u32 rcvgen; /*  and its generation */
 
-	uint32_t acksent; /* last ack sent */
-	uint32_t ackrcvd; /* last msg for which ack was rcvd */
+	u32 acksent; /* last ack sent */
+	u32 ackrcvd; /* last msg for which ack was rcvd */
 
 	/* flow control */
 	QLock lock;
@@ -135,10 +135,10 @@ struct Reliable {
 /* MIB II counters */
 typedef struct Rudpstats Rudpstats;
 struct Rudpstats {
-	uint32_t rudpInDatagrams;
-	uint32_t rudpNoPorts;
-	uint32_t rudpInErrors;
-	uint32_t rudpOutDatagrams;
+	u32 rudpInDatagrams;
+	u32 rudpNoPorts;
+	u32 rudpInErrors;
+	u32 rudpOutDatagrams;
 };
 
 typedef struct Rudppriv Rudppriv;
@@ -149,17 +149,17 @@ struct Rudppriv {
 	Rudpstats ustats;
 
 	/* non-MIB stats */
-	uint32_t csumerr; /* checksum errors */
-	uint32_t lenerr;  /* short packet */
-	uint32_t rxmits;  /* # of retransmissions */
-	uint32_t orders;  /* # of out of order pkts */
+	u32 csumerr; /* checksum errors */
+	u32 lenerr;  /* short packet */
+	u32 rxmits;  /* # of retransmissions */
+	u32 orders;  /* # of out of order pkts */
 
 	/* keeping track of the ack kproc */
 	int ackprocstarted;
 	QLock apl;
 };
 
-static uint32_t generation = 0;
+static u32 generation = 0;
 //static Rendez rend;
 
 /*
@@ -168,8 +168,8 @@ static uint32_t generation = 0;
 typedef struct Rudpcb Rudpcb;
 struct Rudpcb {
 	QLock ql;
-	uint8_t headers;
-	uint8_t randdrop;
+	u8 headers;
+	u8 randdrop;
 	Reliable *r;
 };
 
@@ -177,10 +177,10 @@ struct Rudpcb {
  * local functions
  */
 void relsendack(Conv *, Reliable *, int);
-int reliput(Conv *, Block *, uint8_t *, uint16_t);
-Reliable *relstate(Rudpcb *, uint8_t *, uint16_t, char *);
+int reliput(Conv *, Block *, u8 *, u16);
+Reliable *relstate(Rudpcb *, u8 *, u16, char *);
 void relput(Reliable *);
-void relforget(Conv *, uint8_t *, int, int);
+void relforget(Conv *, u8 *, int, int);
 void relackproc(void *);
 void relackq(Reliable *, Block *);
 void relhangup(Conv *, Reliable *);
@@ -334,8 +334,8 @@ rudpkick(void *x)
 	Proc *up = externup();
 	Conv *c = x;
 	Udphdr *uh;
-	uint16_t rport;
-	uint8_t laddr[IPaddrlen], raddr[IPaddrlen];
+	u16 rport;
+	u8 laddr[IPaddrlen], raddr[IPaddrlen];
 	Block *bp;
 	Rudpcb *ucb;
 	Rudphdr *rh;
@@ -464,11 +464,11 @@ rudpiput(Proto *rudp, Ipifc *ifc, Block *bp)
 	Udphdr *uh;
 	Conv *c;
 	Rudpcb *ucb;
-	uint8_t raddr[IPaddrlen], laddr[IPaddrlen];
-	uint16_t rport, lport;
+	u8 raddr[IPaddrlen], laddr[IPaddrlen];
+	u16 rport, lport;
 	Rudppriv *upriv;
 	Fs *f;
-	uint8_t *p;
+	u8 *p;
 
 	upriv = rudp->priv;
 	f = rudp->f;
@@ -594,7 +594,7 @@ char *
 rudpctl(Conv *c, char **f, int n)
 {
 	Rudpcb *ucb;
-	uint8_t ip[IPaddrlen];
+	u8 ip[IPaddrlen];
 	int x;
 
 	ucb = (Rudpcb *)c->ptcl;
@@ -630,8 +630,8 @@ void
 rudpadvise(Proto *rudp, Block *bp, char *msg)
 {
 	Udphdr *h;
-	uint8_t source[IPaddrlen], dest[IPaddrlen];
-	uint16_t psource, pdest;
+	u8 source[IPaddrlen], dest[IPaddrlen];
+	u16 psource, pdest;
 	Conv *s, **p;
 
 	h = (Udphdr *)(bp->rp);
@@ -760,7 +760,7 @@ loop:
  *  get the state record for a conversation
  */
 Reliable *
-relstate(Rudpcb *ucb, uint8_t *addr, uint16_t port, char *from)
+relstate(Rudpcb *ucb, u8 *addr, u16 port, char *from)
 {
 	Reliable *r, **l;
 
@@ -815,7 +815,7 @@ relput(Reliable *r)
  *  forget a Reliable state
  */
 void
-relforget(Conv *c, uint8_t *ip, int port, int originator)
+relforget(Conv *c, u8 *ip, int port, int originator)
 {
 	Rudpcb *ucb;
 	Reliable *r, **l;
@@ -843,7 +843,7 @@ relforget(Conv *c, uint8_t *ip, int port, int originator)
  *  called with ucb locked.
  */
 int
-reliput(Conv *c, Block *bp, uint8_t *addr, uint16_t port)
+reliput(Conv *c, Block *bp, u8 *addr, u16 port)
 {
 	Block *nbp;
 	Rudpcb *ucb;
@@ -851,7 +851,7 @@ reliput(Conv *c, Block *bp, uint8_t *addr, uint16_t port)
 	Udphdr *uh;
 	Reliable *r;
 	Rudphdr *rh;
-	uint32_t seq, ack, sgen, agen, ackreal;
+	u32 seq, ack, sgen, agen, ackreal;
 	int rv = -1;
 
 	/* get fields */

sys/src/9/ip/tcp.c

@@ -123,48 +123,48 @@ struct Tcptimer {
  */
 typedef struct Tcp4hdr Tcp4hdr;
 struct Tcp4hdr {
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* Identification */
-	uint8_t frag[2];   /* Fragment information */
-	uint8_t Unused;
-	uint8_t proto;
-	uint8_t tcplen[2];
-	uint8_t tcpsrc[4];
-	uint8_t tcpdst[4];
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* Identification */
+	u8 frag[2];   /* Fragment information */
+	u8 Unused;
+	u8 proto;
+	u8 tcplen[2];
+	u8 tcpsrc[4];
+	u8 tcpdst[4];
 	/* same as v6 from here on */
-	uint8_t tcpsport[2];
-	uint8_t tcpdport[2];
-	uint8_t tcpseq[4];
-	uint8_t tcpack[4];
-	uint8_t tcpflag[2];
-	uint8_t tcpwin[2];
-	uint8_t tcpcksum[2];
-	uint8_t tcpurg[2];
+	u8 tcpsport[2];
+	u8 tcpdport[2];
+	u8 tcpseq[4];
+	u8 tcpack[4];
+	u8 tcpflag[2];
+	u8 tcpwin[2];
+	u8 tcpcksum[2];
+	u8 tcpurg[2];
 	/* Options segment */
-	uint8_t tcpopt[1];
+	u8 tcpopt[1];
 };
 
 typedef struct Tcp6hdr Tcp6hdr;
 struct Tcp6hdr {
-	uint8_t vcf[4];
-	uint8_t ploadlen[2];
-	uint8_t proto;
-	uint8_t ttl;
-	uint8_t tcpsrc[IPaddrlen];
-	uint8_t tcpdst[IPaddrlen];
+	u8 vcf[4];
+	u8 ploadlen[2];
+	u8 proto;
+	u8 ttl;
+	u8 tcpsrc[IPaddrlen];
+	u8 tcpdst[IPaddrlen];
 	/* same as v4 from here on */
-	uint8_t tcpsport[2];
-	uint8_t tcpdport[2];
-	uint8_t tcpseq[4];
-	uint8_t tcpack[4];
-	uint8_t tcpflag[2];
-	uint8_t tcpwin[2];
-	uint8_t tcpcksum[2];
-	uint8_t tcpurg[2];
+	u8 tcpsport[2];
+	u8 tcpdport[2];
+	u8 tcpseq[4];
+	u8 tcpack[4];
+	u8 tcpflag[2];
+	u8 tcpwin[2];
+	u8 tcpcksum[2];
+	u8 tcpurg[2];
 	/* Options segment */
-	uint8_t tcpopt[1];
+	u8 tcpopt[1];
 };
 
 /*
@@ -175,17 +175,17 @@ struct Tcp6hdr {
  */
 typedef struct Tcp Tcp;
 struct Tcp {
-	uint16_t source;
-	uint16_t dest;
-	uint32_t seq;
-	uint32_t ack;
-	uint8_t flags;
-	uint8_t update;
-	uint16_t ws;  /* window scale option */
-	uint32_t wnd; /* prescaled window*/
-	uint16_t urg;
-	uint16_t mss; /* max segment size option (if not zero) */
-	uint16_t len; /* size of data */
+	u16 source;
+	u16 dest;
+	u32 seq;
+	u32 ack;
+	u8 flags;
+	u8 update;
+	u16 ws;  /* window scale option */
+	u32 wnd; /* prescaled window*/
+	u16 urg;
+	u16 mss; /* max segment size option (if not zero) */
+	u16 len; /* size of data */
 };
 
 /*
@@ -197,7 +197,7 @@ struct Reseq {
 	Reseq *next;
 	Tcp seg;
 	Block *bp;
-	uint16_t length;
+	u16 length;
 };
 
 /*
@@ -205,53 +205,53 @@ struct Reseq {
  */
 typedef struct Tcpctl Tcpctl;
 struct Tcpctl {
-	uint8_t state; /* Connection state */
-	uint8_t type;  /* Listening or active connection */
-	uint8_t code;  /* Icmp code */
+	u8 state; /* Connection state */
+	u8 type;  /* Listening or active connection */
+	u8 code;  /* Icmp code */
 	struct {
-		uint32_t una; /* Unacked data pointer */
-		uint32_t nxt; /* Next sequence expected */
-		uint32_t ptr; /* Data pointer */
-		uint32_t wnd; /* Tcp send window */
-		uint32_t urg; /* Urgent data pointer */
-		uint32_t wl2;
+		u32 una; /* Unacked data pointer */
+		u32 nxt; /* Next sequence expected */
+		u32 ptr; /* Data pointer */
+		u32 wnd; /* Tcp send window */
+		u32 urg; /* Urgent data pointer */
+		u32 wl2;
 		uint scale; /* how much to right shift window */
 			    /* in xmitted packets */
 		/* to implement tahoe and reno TCP */
-		uint32_t dupacks; /* number of duplicate acks rcvd */
-		uint32_t partialack;
+		u32 dupacks; /* number of duplicate acks rcvd */
+		u32 partialack;
 		int recovery;	/* loss recovery flag */
 		int retransmit; /* retransmit 1 packet @ una flag */
 		int rto;
-		uint32_t rxt; /* right window marker for recovery */
+		u32 rxt; /* right window marker for recovery */
 			      /* "recover" rfc3782 */
 	} snd;
 	struct {
-		uint32_t nxt;  /* Receive pointer to next uint8_t slot */
-		uint32_t wnd;  /* Receive window incoming */
-		uint32_t wsnt; /* Last wptr sent.  important to */
+		u32 nxt;  /* Receive pointer to next uint8_t slot */
+		u32 wnd;  /* Receive window incoming */
+		u32 wsnt; /* Last wptr sent.  important to */
 		/* track for large bdp */
-		uint32_t wptr;
-		uint32_t urg;	 /* Urgent pointer */
-		uint32_t ackptr; /* last acked sequence */
+		u32 wptr;
+		u32 urg;	 /* Urgent pointer */
+		u32 ackptr; /* last acked sequence */
 		int blocked;
 		uint scale; /* how much to left shift window in */
 			    /* rcv'd packets */
 	} rcv;
-	uint32_t iss;	   /* Initial sequence number */
-	uint32_t cwind;	   /* Congestion window */
-	uint32_t abcbytes; /* appropriate byte counting rfc 3465 */
+	u32 iss;	   /* Initial sequence number */
+	u32 cwind;	   /* Congestion window */
+	u32 abcbytes; /* appropriate byte counting rfc 3465 */
 	uint scale;	   /* desired snd.scale */
-	uint32_t ssthresh; /* Slow start threshold */
+	u32 ssthresh; /* Slow start threshold */
 	int resent;	   /* Bytes just resent */
 	int irs;	   /* Initial received squence */
-	uint16_t mss;	   /* Maximum segment size */
+	u16 mss;	   /* Maximum segment size */
 	int rerecv;	   /* Overlap of data rerecevived */
-	uint32_t window;   /* Our receive window (queue) */
+	u32 window;   /* Our receive window (queue) */
 	uint qscale;	   /* Log2 of our receive window (queue) */
-	uint8_t backoff;   /* Exponential backoff counter */
+	u8 backoff;   /* Exponential backoff counter */
 	int backedoff;	   /* ms we've backed off for rexmits */
-	uint8_t flags;	   /* State flags */
+	u8 flags;	   /* State flags */
 	Reseq *reseq;	   /* Resequencing queue */
 	int nreseq;
 	int reseqlen;
@@ -259,13 +259,13 @@ struct Tcpctl {
 	Tcptimer acktimer;  /* Acknowledge timer */
 	Tcptimer rtt_timer; /* Round trip timer */
 	Tcptimer katimer;   /* keep alive timer */
-	uint32_t rttseq;    /* Round trip sequence */
+	u32 rttseq;    /* Round trip sequence */
 	int srtt;	    /* Smoothed round trip */
 	int mdev;	    /* Mean deviation of round trip */
 	int kacounter;	    /* count down for keep alive */
 	uint sndsyntime;    /* time syn sent */
-	uint32_t time;	    /* time Finwait2 or Syn_received was sent */
-	uint32_t timeuna;   /* snd.una when time was set */
+	u32 time;	    /* time Finwait2 or Syn_received was sent */
+	u32 timeuna;   /* snd.una when time was set */
 	int nochecksum;	    /* non-zero means don't send checksums */
 	int flgcnt;	    /* number of flags in the sequence (FIN,SEQ) */
 
@@ -292,18 +292,18 @@ typedef struct Limbo Limbo;
 struct Limbo {
 	Limbo *next;
 
-	uint8_t laddr[IPaddrlen];
-	uint8_t raddr[IPaddrlen];
-	uint16_t lport;
-	uint16_t rport;
-	uint32_t irs;	   /* initial received sequence */
-	uint32_t iss;	   /* initial sent sequence */
-	uint16_t mss;	   /* mss from the other end */
-	uint16_t rcvscale; /* how much to scale rcvd windows */
-	uint16_t sndscale; /* how much to scale sent windows */
-	uint32_t lastsend; /* last time we sent a synack */
-	uint8_t version;   /* v4 or v6 */
-	uint8_t rexmits;   /* number of retransmissions */
+	u8 laddr[IPaddrlen];
+	u8 raddr[IPaddrlen];
+	u16 lport;
+	u16 rport;
+	u32 irs;	   /* initial received sequence */
+	u32 iss;	   /* initial sent sequence */
+	u16 mss;	   /* mss from the other end */
+	u16 rcvscale; /* how much to scale rcvd windows */
+	u16 sndscale; /* how much to scale sent windows */
+	u32 lastsend; /* last time we sent a synack */
+	u8 version;   /* v4 or v6 */
+	u8 rexmits;   /* number of retransmissions */
 };
 
 int tcp_irtt = DEF_RTT; /* Initial guess at round trip time */
@@ -396,7 +396,7 @@ struct Tcppriv {
 	QLock apl;
 	int ackprocstarted;
 
-	uint64_t stats[Nstats];
+	u64 stats[Nstats];
 };
 
 /*
@@ -410,10 +410,10 @@ struct Tcppriv {
  */
 int tcpporthogdefense = 0;
 
-static int addreseq(Fs *, Tcpctl *, Tcppriv *, Tcp *, Block *, uint16_t);
+static int addreseq(Fs *, Tcpctl *, Tcppriv *, Tcp *, Block *, u16);
 static int dumpreseq(Tcpctl *);
-static void getreseq(Tcpctl *, Tcp *, Block **, uint16_t *);
-static void limbo(Conv *, uint8_t *, uint8_t *, Tcp *, int);
+static void getreseq(Tcpctl *, Tcp *, Block **, u16 *);
+static void limbo(Conv *, u8 *, u8 *, Tcp *, int);
 static void limborexmit(Proto *);
 static void localclose(Conv *, char *);
 static void procsyn(Conv *, Tcp *);
@@ -424,19 +424,19 @@ static void tcpoutput(Conv *);
 static void tcprcvwin(Conv *);
 static void tcprxmit(Conv *);
 static void tcpsetkacounter(Tcpctl *);
-static void tcpsetscale(Conv *, Tcpctl *, uint16_t, uint16_t);
+static void tcpsetscale(Conv *, Tcpctl *, u16, u16);
 static void tcpsettimer(Tcpctl *);
 static void tcpsndsyn(Conv *, Tcpctl *);
 static void tcpstart(Conv *, int);
 static void tcpsynackrtt(Conv *);
 static void tcptimeout(void *);
-static int tcptrim(Tcpctl *, Tcp *, Block **, uint16_t *);
+static int tcptrim(Tcpctl *, Tcp *, Block **, u16 *);
 
 static void
-tcpsetstate(Conv *s, uint8_t newstate)
+tcpsetstate(Conv *s, u8 newstate)
 {
 	Tcpctl *tcb;
-	uint8_t oldstate;
+	u8 oldstate;
 	Tcppriv *tpriv;
 
 	tpriv = s->p->priv;
@@ -616,7 +616,7 @@ tcpkick(void *x)
 	poperror();
 }
 
-static int seq_lt(uint32_t, uint32_t);
+static int seq_lt(u32, u32);
 
 static void
 tcprcvwin(Conv *s) /* Call with tcb locked */
@@ -667,7 +667,7 @@ tcpacktimer(void *v)
 static void
 tcpcongestion(Tcpctl *tcb)
 {
-	uint32_t inflight;
+	u32 inflight;
 
 	inflight = tcb->snd.nxt - tcb->snd.una;
 	if(inflight > tcb->cwind)
@@ -852,7 +852,7 @@ localclose(Conv *s, char *reason) /* called with tcb locked */
 
 /* mtu (- TCP + IP hdr len) of 1st hop */
 static int
-tcpmtu(Proto *tcp, uint8_t *addr, int version, uint *scale)
+tcpmtu(Proto *tcp, u8 *addr, int version, uint *scale)
 {
 	Ipifc *ifc;
 	int mtu;
@@ -1023,9 +1023,9 @@ htontcp6(Tcp *tcph, Block *data, Tcp6hdr *ph, Tcpctl *tcb)
 {
 	int dlen;
 	Tcp6hdr *h;
-	uint16_t csum;
-	uint16_t hdrlen, optpad = 0;
-	uint8_t *opt;
+	u16 csum;
+	u16 hdrlen, optpad = 0;
+	u8 *opt;
 
 	hdrlen = TCP6_HDRSIZE;
 	if(tcph->flags & SYN){
@@ -1106,9 +1106,9 @@ htontcp4(Tcp *tcph, Block *data, Tcp4hdr *ph, Tcpctl *tcb)
 {
 	int dlen;
 	Tcp4hdr *h;
-	uint16_t csum;
-	uint16_t hdrlen, optpad = 0;
-	uint8_t *opt;
+	u16 csum;
+	u16 hdrlen, optpad = 0;
+	u8 *opt;
 
 	hdrlen = TCP4_HDRSIZE;
 	if(tcph->flags & SYN){
@@ -1179,9 +1179,9 @@ static int
 ntohtcp6(Tcp *tcph, Block **bpp)
 {
 	Tcp6hdr *h;
-	uint8_t *optr;
-	uint16_t hdrlen;
-	uint16_t optlen;
+	u8 *optr;
+	u16 hdrlen;
+	u16 optlen;
 	int n;
 
 	*bpp = pullupblock(*bpp, TCP6_PKT + TCP6_HDRSIZE);
@@ -1242,9 +1242,9 @@ static int
 ntohtcp4(Tcp *tcph, Block **bpp)
 {
 	Tcp4hdr *h;
-	uint8_t *optr;
-	uint16_t hdrlen;
-	uint16_t optlen;
+	u8 *optr;
+	u16 hdrlen;
+	u16 optlen;
 	int n;
 
 	*bpp = pullupblock(*bpp, TCP4_PKT + TCP4_HDRSIZE);
@@ -1329,10 +1329,11 @@ tcpsndsyn(Conv *s, Tcpctl *tcb)
 }
 
 void
-sndrst(Proto *tcp, uint8_t *source, uint8_t *dest, uint16_t length, Tcp *seg, uint8_t version, char *reason)
+sndrst(Proto *tcp, u8 *source, u8 *dest, u16 length, Tcp *seg,
+       u8 version, char *reason)
 {
 	Block *hbp;
-	uint8_t rflags;
+	u8 rflags;
 	Tcppriv *tpriv;
 	Tcp4hdr ph4;
 	Tcp6hdr ph6;
@@ -1541,7 +1542,7 @@ sndsynack(Proto *tcp, Limbo *lp)
  *  called with proto locked
  */
 static void
-limbo(Conv *s, uint8_t *source, uint8_t *dest, Tcp *seg, int version)
+limbo(Conv *s, u8 *source, u8 *dest, Tcp *seg, int version)
 {
 	Limbo *lp, **l;
 	Tcppriv *tpriv;
@@ -1604,7 +1605,7 @@ limborexmit(Proto *tcp)
 	Limbo **l, *lp;
 	int h;
 	int seen;
-	uint32_t now;
+	u32 now;
 
 	tpriv = tcp->priv;
 
@@ -1650,7 +1651,7 @@ limborexmit(Proto *tcp)
  *  called with proto locked
  */
 static void
-limborst(Conv *s, Tcp *segp, uint8_t *src, uint8_t *dst, uint8_t version)
+limborst(Conv *s, Tcp *segp, u8 *src, u8 *dst, u8 version)
 {
 	Limbo *lp, **l;
 	int h;
@@ -1698,7 +1699,7 @@ initialwindow(Tcpctl *tcb)
  *  called with proto locked
  */
 static Conv *
-tcpincoming(Conv *s, Tcp *segp, uint8_t *src, uint8_t *dst, uint8_t version)
+tcpincoming(Conv *s, Tcp *segp, u8 *src, u8 *dst, u8 version)
 {
 	Conv *new;
 	Tcpctl *tcb;
@@ -1829,7 +1830,7 @@ tcpincoming(Conv *s, Tcp *segp, uint8_t *src, uint8_t *dst, uint8_t version)
 }
 
 static int
-seq_within(uint32_t x, uint32_t low, uint32_t high)
+seq_within(u32 x, u32 low, u32 high)
 {
 	if(low <= high){
 		if(low <= x && x <= high)
@@ -1842,25 +1843,25 @@ seq_within(uint32_t x, uint32_t low, uint32_t high)
 }
 
 static int
-seq_lt(uint32_t x, uint32_t y)
+seq_lt(u32 x, u32 y)
 {
 	return (int)(x - y) < 0;
 }
 
 static int
-seq_le(uint32_t x, uint32_t y)
+seq_le(u32 x, u32 y)
 {
 	return (int)(x - y) <= 0;
 }
 
 static int
-seq_gt(uint32_t x, uint32_t y)
+seq_gt(u32 x, u32 y)
 {
 	return (int)(x - y) > 0;
 }
 
 static int
-seq_ge(uint32_t x, uint32_t y)
+seq_ge(u32 x, u32 y)
 {
 	return (int)(x - y) >= 0;
 }
@@ -1892,7 +1893,7 @@ update(Conv *s, Tcp *seg)
 {
 	int rtt, delta;
 	Tcpctl *tcb;
-	uint32_t acked;
+	u32 acked;
 	Tcppriv *tpriv;
 
 	if(seg->update)
@@ -2074,12 +2075,12 @@ tcpiput(Proto *tcp, Ipifc *ipifc, Block *bp)
 	Tcp6hdr *h6;
 	int hdrlen;
 	Tcpctl *tcb;
-	uint16_t length, csum;
-	uint8_t source[IPaddrlen], dest[IPaddrlen];
+	u16 length, csum;
+	u8 source[IPaddrlen], dest[IPaddrlen];
 	Conv *s;
 	Fs *f;
 	Tcppriv *tpriv;
-	uint8_t version;
+	u8 version;
 
 	f = tcp->f;
 	tpriv = tcp->priv;
@@ -2552,10 +2553,10 @@ tcpoutput(Conv *s)
 	Tcpctl *tcb;
 	Block *hbp, *bp;
 	int sndcnt;
-	uint32_t ssize, dsize, sent;
+	u32 ssize, dsize, sent;
 	Fs *f;
 	Tcppriv *tpriv;
-	uint8_t version;
+	u8 version;
 
 	f = s->p->f;
 	tpriv = s->p->priv;
@@ -2917,7 +2918,7 @@ tcprxmit(Conv *s)
 {
 	Tcpctl *tcb;
 	Tcppriv *tpriv;
-	uint32_t tcwind, tptr;
+	u32 tcwind, tptr;
 
 	tcb = (Tcpctl *)s->ptcl;
 	tcb->flags |= RETRAN | FORCE;
@@ -3055,7 +3056,7 @@ dumpreseq(Tcpctl *tcb)
 }
 
 static void
-logreseq(Fs *f, Reseq *r, uint32_t n)
+logreseq(Fs *f, Reseq *r, u32 n)
 {
 	char *s;
 
@@ -3075,7 +3076,7 @@ logreseq(Fs *f, Reseq *r, uint32_t n)
 }
 
 static int
-addreseq(Fs *f, Tcpctl *tcb, Tcppriv *tpriv, Tcp *seg, Block *bp, uint16_t length)
+addreseq(Fs *f, Tcpctl *tcb, Tcppriv *tpriv, Tcp *seg, Block *bp, u16 length)
 {
 	Reseq *rp, **rr;
 	int qmax;
@@ -3124,7 +3125,7 @@ addreseq(Fs *f, Tcpctl *tcb, Tcppriv *tpriv, Tcp *seg, Block *bp, uint16_t lengt
 }
 
 static void
-getreseq(Tcpctl *tcb, Tcp *seg, Block **bp, uint16_t *length)
+getreseq(Tcpctl *tcb, Tcp *seg, Block **bp, u16 *length)
 {
 	Reseq *rp;
 
@@ -3145,10 +3146,10 @@ getreseq(Tcpctl *tcb, Tcp *seg, Block **bp, uint16_t *length)
 }
 
 static int
-tcptrim(Tcpctl *tcb, Tcp *seg, Block **bp, uint16_t *length)
+tcptrim(Tcpctl *tcb, Tcp *seg, Block **bp, u16 *length)
 {
-	uint16_t len;
-	uint8_t accept;
+	u16 len;
+	u8 accept;
 	int dupcnt, excess;
 
 	accept = 0;
@@ -3189,7 +3190,7 @@ tcptrim(Tcpctl *tcb, Tcp *seg, Block **bp, uint16_t *length)
 			dupcnt--;
 		}
 		if(dupcnt > 0){
-			pullblock(bp, (uint16_t)dupcnt);
+			pullblock(bp, (u16)dupcnt);
 			seg->seq += dupcnt;
 			*length -= dupcnt;
 
@@ -3219,9 +3220,9 @@ tcpadvise(Proto *tcp, Block *bp, char *msg)
 	Tcp4hdr *h4;
 	Tcp6hdr *h6;
 	Tcpctl *tcb;
-	uint8_t source[IPaddrlen];
-	uint8_t dest[IPaddrlen];
-	uint16_t psource, pdest;
+	u8 source[IPaddrlen];
+	u8 dest[IPaddrlen];
+	u16 psource, pdest;
 	Conv *s, **p;
 
 	h4 = (Tcp4hdr *)(bp->rp);
@@ -3397,7 +3398,7 @@ tcpinit(Fs *fs)
 }
 
 static void
-tcpsetscale(Conv *s, Tcpctl *tcb, uint16_t rcvscale, uint16_t sndscale)
+tcpsetscale(Conv *s, Tcpctl *tcb, u16 rcvscale, u16 sndscale)
 {
 	/*
 	 * guess at reasonable queue sizes.  there's no current way

sys/src/9/ip/udp.c

@@ -42,47 +42,47 @@ enum {
 typedef struct Udp4hdr Udp4hdr;
 struct Udp4hdr {
 	/* ip header */
-	uint8_t vihl;	   /* Version and header length */
-	uint8_t tos;	   /* Type of service */
-	uint8_t length[2]; /* packet length */
-	uint8_t id[2];	   /* Identification */
-	uint8_t frag[2];   /* Fragment information */
-	uint8_t Unused;
-	uint8_t udpproto;	     /* Protocol */
-	uint8_t udpplen[2];	     /* Header plus data length */
-	uint8_t udpsrc[IPv4addrlen]; /* Ip source */
-	uint8_t udpdst[IPv4addrlen]; /* Ip destination */
+	u8 vihl;	   /* Version and header length */
+	u8 tos;	   /* Type of service */
+	u8 length[2]; /* packet length */
+	u8 id[2];	   /* Identification */
+	u8 frag[2];   /* Fragment information */
+	u8 Unused;
+	u8 udpproto;	     /* Protocol */
+	u8 udpplen[2];	     /* Header plus data length */
+	u8 udpsrc[IPv4addrlen]; /* Ip source */
+	u8 udpdst[IPv4addrlen]; /* Ip destination */
 
 	/* udp header */
-	uint8_t udpsport[2]; /* Source port */
-	uint8_t udpdport[2]; /* Destination port */
-	uint8_t udplen[2];   /* data length */
-	uint8_t udpcksum[2]; /* Checksum */
+	u8 udpsport[2]; /* Source port */
+	u8 udpdport[2]; /* Destination port */
+	u8 udplen[2];   /* data length */
+	u8 udpcksum[2]; /* Checksum */
 };
 
 typedef struct Udp6hdr Udp6hdr;
 struct Udp6hdr {
-	uint8_t viclfl[4];
-	uint8_t len[2];
-	uint8_t nextheader;
-	uint8_t hoplimit;
-	uint8_t udpsrc[IPaddrlen];
-	uint8_t udpdst[IPaddrlen];
+	u8 viclfl[4];
+	u8 len[2];
+	u8 nextheader;
+	u8 hoplimit;
+	u8 udpsrc[IPaddrlen];
+	u8 udpdst[IPaddrlen];
 
 	/* udp header */
-	uint8_t udpsport[2]; /* Source port */
-	uint8_t udpdport[2]; /* Destination port */
-	uint8_t udplen[2];   /* data length */
-	uint8_t udpcksum[2]; /* Checksum */
+	u8 udpsport[2]; /* Source port */
+	u8 udpdport[2]; /* Destination port */
+	u8 udplen[2];   /* data length */
+	u8 udpcksum[2]; /* Checksum */
 };
 
 /* MIB II counters */
 typedef struct Udpstats Udpstats;
 struct Udpstats {
-	uint64_t udpInDatagrams;
-	uint32_t udpNoPorts;
-	uint32_t udpInErrors;
-	uint64_t udpOutDatagrams;
+	u64 udpInDatagrams;
+	u32 udpNoPorts;
+	u32 udpInErrors;
+	u64 udpOutDatagrams;
 };
 
 typedef struct Udppriv Udppriv;
@@ -93,8 +93,8 @@ struct Udppriv {
 	Udpstats ustats;
 
 	/* non-MIB stats */
-	uint32_t csumerr; /* checksum errors */
-	uint32_t lenerr;  /* short packet */
+	u32 csumerr; /* checksum errors */
+	u32 lenerr;  /* short packet */
 };
 
 void (*etherprofiler)(char *name, int qlen);
@@ -106,7 +106,7 @@ void udpkick(void *x, Block *bp);
 typedef struct Udpcb Udpcb;
 struct Udpcb {
 	QLock ql;
-	uint8_t headers;
+	u8 headers;
 };
 
 static char *
@@ -185,8 +185,8 @@ udpkick(void *x, Block *bp)
 	Conv *c = x;
 	Udp4hdr *uh4;
 	Udp6hdr *uh6;
-	uint16_t rport;
-	uint8_t laddr[IPaddrlen], raddr[IPaddrlen];
+	u16 rport;
+	u8 laddr[IPaddrlen], raddr[IPaddrlen];
 	Udpcb *ucb;
 	int dlen, ptcllen;
 	Udppriv *upriv;
@@ -331,13 +331,13 @@ udpiput(Proto *udp, Ipifc *ifc, Block *bp)
 	Udp6hdr *uh6;
 	Conv *c;
 	Udpcb *ucb;
-	uint8_t raddr[IPaddrlen], laddr[IPaddrlen];
-	uint16_t rport, lport;
+	u8 raddr[IPaddrlen], laddr[IPaddrlen];
+	u16 rport, lport;
 	Udppriv *upriv;
 	Fs *f;
 	int version;
 	int ottl, oviclfl, olen;
-	uint8_t *p;
+	u8 *p;
 
 	upriv = udp->priv;
 	f = udp->f;
@@ -536,8 +536,8 @@ udpadvise(Proto *udp, Block *bp, char *msg)
 {
 	Udp4hdr *h4;
 	Udp6hdr *h6;
-	uint8_t source[IPaddrlen], dest[IPaddrlen];
-	uint16_t psource, pdest;
+	u8 source[IPaddrlen], dest[IPaddrlen];
+	u16 psource, pdest;
 	Conv *s, **p;
 	int version;
 

sys/src/9/port/alarm.c

@@ -21,7 +21,7 @@ alarmkproc(void *v)
 {
 	Proc *up = externup();
 	Proc *rp;
-	uint64_t now;
+	u64 now;
 
 	for(;;){
 		now = sys->ticks;
@@ -53,7 +53,7 @@ void
 checkalarms(void)
 {
 	Proc *p;
-	uint64_t now;
+	u64 now;
 
 	p = alarms._head;
 	now = sys->ticks;
@@ -62,12 +62,12 @@ checkalarms(void)
 		wakeup(&alarmr);
 }
 
-uint64_t
-procalarm(uint64_t time)
+u64
+procalarm(u64 time)
 {
 	Proc *up = externup();
 	Proc **l, *f;
-	uint64_t when, old;
+	u64 when, old;
 
 	if(up->alarm)
 		old = TK2MS(up->alarm - sys->ticks);