From: Lionel Sambuc <lionel@minix3.org>
Date: Thu, 1 May 2014 14:19:28 +0000 (+0200)
Subject: Remove protocol version of {mode,ino,uid,gid}_t
X-Git-Tag: v3.3.0~326
X-Git-Url: http://zhaoyanbai.com/repos/%22http:/www.isc.org/icons/weatherstation.js?a=commitdiff_plain;h=b6aa3714a1bc9f315b2f6d5244319053ba25bcd2;p=minix.git

Remove protocol version of {mode,ino,uid,gid}_t

Now that we have enough room in the message, remove these types.

Change-Id: Ib734c6f0209b259a14a1189b3886b9c8474e1b9a
---

diff --git a/include/minix/vfsif.h b/include/minix/vfsif.h
index 9ced295a2..8b0c5acec 100644
--- a/include/minix/vfsif.h
+++ b/include/minix/vfsif.h
@@ -82,12 +82,6 @@ typedef struct {
 	gid_t vu_sgroups[NGROUPS_MAX];
 } vfs_ucred_t;
 
-/* Some system types are larger than what the protocol and FSes use */
-typedef u16_t	puid_t;		/* Protocol version of uid_t */
-typedef u16_t	pgid_t;		/* Protocol version of gid_t */
-typedef u16_t	pmode_t;	/* Protocol version of mode_t */
-typedef u32_t	pino_t;		/* Protocol version of ino_t */
-
 /* Request numbers */
 #define REQ_GETNODE	(FS_BASE + 1)	/* Should be removed */
 #define REQ_PUTNODE	(FS_BASE + 2)
diff --git a/lib/libpuffs/path.c b/lib/libpuffs/path.c
index be93ab235..eece52592 100644
--- a/lib/libpuffs/path.c
+++ b/lib/libpuffs/path.c
@@ -29,7 +29,7 @@ char dot2[3] = "..";	/* permissions for . and ..		    */
 
 static char *get_name(char *name, char string[NAME_MAX+1]);
 static int ltraverse(struct puffs_node *pn, char *suffix);
-static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
+static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
 	puffs_node **res_inop, size_t *offsetp, int *symlinkp);
 
 /*===========================================================================*
@@ -129,8 +129,8 @@ int fs_lookup(void)
  *                             parse_path				     *
  *===========================================================================*/
 static int parse_path(
-	pino_t dir_ino,
-	pino_t root_ino,
+	ino_t dir_ino,
+	ino_t root_ino,
 	int flags,
 	struct puffs_node **res_inop,
 	size_t *offsetp,
diff --git a/lib/libsffs/inode.c b/lib/libsffs/inode.c
index 7ef877fac..937e6453f 100644
--- a/lib/libsffs/inode.c
+++ b/lib/libsffs/inode.c
@@ -65,7 +65,7 @@ struct inode *init_inode(void)
 /*===========================================================================*
  *				find_inode				     *
  *===========================================================================*/
-struct inode *find_inode(pino_t ino_nr)
+struct inode *find_inode(ino_t ino_nr)
 {
 /* Get an inode based on its inode number. Do not increase its reference count.
  */
diff --git a/lib/libsffs/lookup.c b/lib/libsffs/lookup.c
index ca484649b..f61c08a9e 100644
--- a/lib/libsffs/lookup.c
+++ b/lib/libsffs/lookup.c
@@ -57,7 +57,7 @@ static int access_as_dir(
 /* Check whether the given inode may be accessed as directory.
  * Return OK or an appropriate error code.
  */
-  pmode_t mode;
+  mode_t mode;
 
   assert(attr->a_mask & SFFS_ATTR_MODE);
 
diff --git a/lib/libsffs/proto.h b/lib/libsffs/proto.h
index fb4e119ac..fb4131243 100644
--- a/lib/libsffs/proto.h
+++ b/lib/libsffs/proto.h
@@ -13,7 +13,7 @@ void put_handle(struct inode *ino);
 
 /* inode.c */
 struct inode *init_inode(void);
-struct inode *find_inode(pino_t ino_nr);
+struct inode *find_inode(ino_t ino_nr);
 void get_inode(struct inode *ino);
 void put_inode(struct inode *ino);
 void link_inode(struct inode *parent, struct inode *ino);
@@ -57,7 +57,7 @@ int do_read(void);
 int do_getdents(void);
 
 /* stat.c */
-pmode_t get_mode(struct inode *ino, int mode);
+mode_t get_mode(struct inode *ino, int mode);
 int do_stat(void);
 int do_chmod(void);
 int do_utime(void);
diff --git a/lib/libsffs/stat.c b/lib/libsffs/stat.c
index f4d5225d0..76f2fae89 100644
--- a/lib/libsffs/stat.c
+++ b/lib/libsffs/stat.c
@@ -15,7 +15,7 @@
 /*===========================================================================*
  *				get_mode				     *
  *===========================================================================*/
-pmode_t get_mode(struct inode *ino, int mode)
+mode_t get_mode(struct inode *ino, int mode)
 {
 /* Return the mode for an inode, given the inode and the retrieved mode.
  */
@@ -45,7 +45,7 @@ int do_stat(void)
   struct sffs_attr attr;
   struct stat stat;
   char path[PATH_MAX];
-  pino_t ino_nr;
+  ino_t ino_nr;
   int r;
 
   ino_nr = m_in.m_vfs_fs_stat.inode;
diff --git a/lib/libvtreefs/inode.c b/lib/libvtreefs/inode.c
index 002d0d1e2..c7fdda1b5 100644
--- a/lib/libvtreefs/inode.c
+++ b/lib/libvtreefs/inode.c
@@ -426,7 +426,7 @@ struct inode *get_inode_by_index(struct inode *parent, index_t index)
 /*===========================================================================*
  *				find_inode				     *
  *===========================================================================*/
-struct inode *find_inode(pino_t num)
+struct inode *find_inode(ino_t num)
 {
 	/* Retrieve an inode by inode number.
 	 */
@@ -442,7 +442,7 @@ struct inode *find_inode(pino_t num)
 /*===========================================================================*
  *				get_inode				     *
  *===========================================================================*/
-struct inode *get_inode(pino_t num)
+struct inode *get_inode(ino_t num)
 {
 	/* Retrieve an inode by inode number, and increase its reference count.
 	 */
diff --git a/lib/libvtreefs/path.c b/lib/libvtreefs/path.c
index 18bf37260..a06c9709c 100644
--- a/lib/libvtreefs/path.c
+++ b/lib/libvtreefs/path.c
@@ -10,7 +10,7 @@ static int access_as_dir(struct inode *node, vfs_ucred_t *ucred)
 	/* Check whether the given inode may be accessed as directory.
 	 * Return OK or an appropriate error code.
 	 */
-	pmode_t mask;
+	mode_t mask;
 	int i;
 
 	/* The inode must be a directory to begin with. */
diff --git a/lib/libvtreefs/proto.h b/lib/libvtreefs/proto.h
index 0dc0e7cf2..6c558da73 100644
--- a/lib/libvtreefs/proto.h
+++ b/lib/libvtreefs/proto.h
@@ -5,8 +5,8 @@
 void init_inodes(unsigned int inodes, struct inode_stat *stat, index_t
 	nr_indexed_entries);
 void cleanup_inodes(void);
-struct inode *find_inode(pino_t num);
-struct inode *get_inode(pino_t num);
+struct inode *find_inode(ino_t num);
+struct inode *get_inode(ino_t num);
 void put_inode(struct inode *node);
 void ref_inode(struct inode *node);
 int get_inode_number(struct inode *node);
diff --git a/servers/ext2/const.h b/servers/ext2/const.h
index f6da636af..17ddd30cb 100644
--- a/servers/ext2/const.h
+++ b/servers/ext2/const.h
@@ -55,7 +55,7 @@
 
 #define SUPER_BLOCK_BYTES       (1024)         /* bytes offset */
 
-#define ROOT_INODE      ((pino_t) 2)   /* inode number for root directory */
+#define ROOT_INODE      ((ino_t) 2)   /* inode number for root directory */
 #define BOOT_BLOCK      ((block_t) 0) /* block number of boot block */
 #define START_BLOCK     ((block_t) 2) /* first block of FS (not counting SB) */
 #define BLOCK_ADDRESS_BYTES	4     /* bytes per address */
diff --git a/servers/ext2/ialloc.c b/servers/ext2/ialloc.c
index 9d88baf0e..6cb18106d 100644
--- a/servers/ext2/ialloc.c
+++ b/servers/ext2/ialloc.c
@@ -29,7 +29,7 @@ static void wipe_inode(struct inode *rip);
 /*===========================================================================*
  *                alloc_inode                                                *
  *===========================================================================*/
-struct inode *alloc_inode(struct inode *parent, pmode_t bits)
+struct inode *alloc_inode(struct inode *parent, mode_t bits)
 {
 /* Allocate a free inode on parent's dev, and return a pointer to it. */
 
@@ -125,7 +125,7 @@ struct inode *parent;		/* parent of newly allocated inode */
 int is_dir;			/* inode will be a directory if it is TRUE */
 {
   int group;
-  pino_t inumber = NO_BIT;
+  ino_t inumber = NO_BIT;
   bit_t bit;
   struct buf *bp;
   struct group_desc *gd;
diff --git a/servers/ext2/inode.c b/servers/ext2/inode.c
index eb7799e1f..945363426 100644
--- a/servers/ext2/inode.c
+++ b/servers/ext2/inode.c
@@ -120,7 +120,7 @@ static void unhash_inode(struct inode *node)
  *===========================================================================*/
 struct inode *get_inode(
   dev_t dev,          /* device on which inode resides */
-  pino_t numb         /* inode number (ANSI: may not be unshort) */
+  ino_t numb         /* inode number (ANSI: may not be unshort) */
 )
 {
 /* Find the inode in the hash table. If it is not there, get a free inode
@@ -198,7 +198,7 @@ struct inode *get_inode(
  *===========================================================================*/
 struct inode *find_inode(
   dev_t dev,          /* device on which inode resides */
-  pino_t numb         /* inode number (ANSI: may not be unshort) */
+  ino_t numb         /* inode number (ANSI: may not be unshort) */
 )
 {
 /* Find the inode specified by the inode and device number. */
diff --git a/servers/ext2/inode.h b/servers/ext2/inode.h
index 135e70200..6ea66c180 100644
--- a/servers/ext2/inode.h
+++ b/servers/ext2/inode.h
@@ -71,7 +71,7 @@ EXTERN struct inode {
 
     /* The following items are not present on the disk. */
     dev_t i_dev;                /* which device is the inode on */
-    pino_t i_num;               /* inode number on its (minor) device */
+    ino_t i_num;               /* inode number on its (minor) device */
     int i_count;                /* # times inode used; 0 means slot is free */
     struct super_block *i_sp;   /* pointer to super block for inode's device */
     char i_dirt;                /* CLEAN or DIRTY */
diff --git a/servers/ext2/link.c b/servers/ext2/link.c
index 03d273bcd..c779774dc 100644
--- a/servers/ext2/link.c
+++ b/servers/ext2/link.c
@@ -271,7 +271,7 @@ char file_name[NAME_MAX + 1]; /* name of file to be removed */
 {
 /* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
 
-  pino_t numb;			/* inode number */
+  ino_t numb;			/* inode number */
   int	r;
 
   /* If rip is not NULL, it is used to get faster access to the inode. */
@@ -310,7 +310,7 @@ int fs_rename()
   int odir, ndir;			/* TRUE iff {old|new} file is dir */
   int same_pdir = 0;			/* TRUE iff parent dirs are the same */
   char old_name[NAME_MAX + 1], new_name[NAME_MAX + 1];
-  pino_t numb;
+  ino_t numb;
   phys_bytes len;
 
   /* Copy the last component of the old name */
@@ -334,7 +334,7 @@ int fs_rename()
   NUL(new_name, len, sizeof(new_name));
 
   /* Get old dir inode */
-  if( (old_dirp = get_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_rename.dir_old)) == NULL)
+  if( (old_dirp = get_inode(fs_dev, fs_m_in.m_vfs_fs_rename.dir_old)) == NULL)
 	return(err_code);
 
   old_ip = advance(old_dirp, old_name, IGN_PERM);
@@ -350,7 +350,7 @@ int fs_rename()
   }
 
   /* Get new dir inode */
-  if ((new_dirp = get_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){
+  if ((new_dirp = get_inode(fs_dev, fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){
 	put_inode(old_ip);
 	put_inode(old_dirp);
 	return(err_code);
@@ -483,7 +483,7 @@ int fs_rename()
 		r = search_dir(new_dirp, new_name, &numb, ENTER, IGN_PERM,
 					old_ip->i_mode & I_TYPE);
 		if(r == OK) {
-			(void) search_dir(old_dirp, old_name, (pino_t *) 0,
+			(void) search_dir(old_dirp, old_name, NULL,
 					  DELETE, IGN_PERM, 0);
 		}
 	}
@@ -551,7 +551,7 @@ off_t newsize;			/* inode must become this size */
  * writing is done.
  */
   int r;
-  pmode_t file_type;
+  mode_t file_type;
 
   discard_preallocated_blocks(rip);
 
diff --git a/servers/ext2/open.c b/servers/ext2/open.c
index 6597eddb6..c9159345a 100644
--- a/servers/ext2/open.c
+++ b/servers/ext2/open.c
@@ -12,7 +12,7 @@
 #include "super.h"
 #include <minix/vfsif.h>
 
-static struct inode *new_node(struct inode *ldirp, char *string, pmode_t
+static struct inode *new_node(struct inode *ldirp, char *string, mode_t
 	bits, block_t z0);
 
 
@@ -118,7 +118,7 @@ int fs_mknod()
 int fs_mkdir()
 {
   int r1, r2;			/* status codes */
-  pino_t dot, dotdot;		/* inode numbers for . and .. */
+  ino_t dot, dotdot;		/* inode numbers for . and .. */
   struct inode *rip, *ldirp;
   char lastc[NAME_MAX + 1];         /* last component */
   phys_bytes len;
@@ -213,8 +213,7 @@ int fs_slink()
 	  return(EINVAL);
 
   /* Create the inode for the symlink. */
-  sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES),
-		   (block_t) 0);
+  sip = new_node(ldirp, string, (I_SYMBOLIC_LINK | RWX_MODES), 0);
 
   /* If we can then create fast symlink (store it in inode),
    * Otherwise allocate a disk block for the contents of the symlink and
@@ -278,7 +277,7 @@ int fs_slink()
  *				new_node				     *
  *===========================================================================*/
 static struct inode *new_node(struct inode *ldirp,
-	char *string, pmode_t bits, block_t b0)
+	char *string, mode_t bits, block_t b0)
 {
 /* New_node() is called by fs_open(), fs_mknod(), and fs_mkdir().
  * In all cases it allocates a new inode, makes a directory entry for it in
diff --git a/servers/ext2/path.c b/servers/ext2/path.c
index 444094f5f..6fdc84bf1 100644
--- a/servers/ext2/path.c
+++ b/servers/ext2/path.c
@@ -29,7 +29,7 @@ char dot2[3] = "..";	/* permissions for . and ..		    */
 
 static char *get_name(char *name, char string[NAME_MAX+1]);
 static int ltraverse(struct inode *rip, char *suffix);
-static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
+static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
 	inode **res_inop, size_t *offsetp, int *symlinkp);
 
 /*===========================================================================*
@@ -41,7 +41,7 @@ int fs_lookup()
   int r, r1, flags, symlinks;
   unsigned int len;
   size_t offset = 0, path_size;
-  pino_t dir_ino, root_ino;
+  ino_t dir_ino, root_ino;
   struct inode *rip;
 
   grant		= fs_m_in.m_vfs_fs_lookup.grant_path;
@@ -121,8 +121,8 @@ int fs_lookup()
  *                             parse_path				     *
  *===========================================================================*/
 static int parse_path(dir_ino, root_ino, flags, res_inop, offsetp, symlinkp)
-pino_t dir_ino;
-pino_t root_ino;
+ino_t dir_ino;
+ino_t root_ino;
 int flags;
 struct inode **res_inop;
 size_t *offsetp;
@@ -370,7 +370,7 @@ int chk_perm;			/* check permissions when string is looked up*/
  * the directory, find the inode, open it, and return a pointer to its inode
  * slot.
  */
-  pino_t numb;
+  ino_t numb;
   struct inode *rip;
 
   /* If 'string' is empty, return an error. */
@@ -483,7 +483,7 @@ char string[NAME_MAX+1];	/* component extracted from 'old_name' */
 int search_dir(ldir_ptr, string, numb, flag, check_permissions, ftype)
 register struct inode *ldir_ptr; /* ptr to inode for dir to search */
 const char string[NAME_MAX + 1];	 /* component to search for */
-pino_t *numb;			 /* pointer to inode number */
+ino_t *numb;			 /* pointer to inode number */
 int flag;			 /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
 int check_permissions;		 /* check permissions when flag is !IS_EMPTY */
 int ftype;			 /* used when ENTER and
@@ -502,7 +502,7 @@ int ftype;			 /* used when ENTER and
   register struct ext2_disk_dir_desc  *prev_dp = NULL;
   register struct buf *bp = NULL;
   int i, r, e_hit, t, match;
-  pmode_t bits;
+  mode_t bits;
   off_t pos;
   unsigned new_slots;
   int extended = 0;
@@ -576,10 +576,10 @@ int ftype;			 /* used when ENTER and
 			r = OK;
 			if (flag == IS_EMPTY) r = ENOTEMPTY;
 			else if (flag == DELETE) {
-				if (dp->d_name_len >= sizeof(pino_t)) {
+				if (dp->d_name_len >= sizeof(ino_t)) {
 					/* Save d_ino for recovery. */
-					t = dp->d_name_len - sizeof(pino_t);
-					*((pino_t *) &dp->d_name[t])= dp->d_ino;
+					t = dp->d_name_len - sizeof(ino_t);
+					*((ino_t *) &dp->d_name[t])= dp->d_ino;
 				}
 				dp->d_ino = NO_ENTRY;	/* erase entry */
 				lmfs_markdirty(bp);
@@ -619,7 +619,7 @@ int ftype;			 /* used when ENTER and
 				}
 			} else {
 				/* 'flag' is LOOK_UP */
-				*numb = (pino_t) conv4(le_CPU, dp->d_ino);
+				*numb = (ino_t) conv4(le_CPU, dp->d_ino);
 			}
 			assert(lmfs_dev(bp) != NO_DEV);
 			put_block(bp, DIRECTORY_BLOCK);
diff --git a/servers/ext2/protect.c b/servers/ext2/protect.c
index d3e6315b0..bbd732ef2 100644
--- a/servers/ext2/protect.c
+++ b/servers/ext2/protect.c
@@ -18,7 +18,7 @@ int fs_chmod()
 /* Perform the chmod(name, mode) system call. */
 
   register struct inode *rip;
-  pmode_t mode;
+  mode_t mode;
 
   mode = fs_m_in.m_vfs_fs_chmod.mode;
 
@@ -72,7 +72,7 @@ int fs_chown()
 /*===========================================================================*
  *				forbidden				     *
  *===========================================================================*/
-int forbidden(register struct inode *rip, pmode_t access_desired)
+int forbidden(struct inode *rip, mode_t access_desired)
 {
 /* Given a pointer to an inode, 'rip', and the access desired, determine
  * if the access is allowed, and if not why not.  The routine looks up the
@@ -81,7 +81,7 @@ int forbidden(register struct inode *rip, pmode_t access_desired)
  */
 
   register struct inode *old_rip = rip;
-  register pmode_t bits, perm_bits;
+  mode_t bits, perm_bits;
   int r, shift;
 
   /* Isolate the relevant rwx bits from the mode. */
diff --git a/servers/ext2/proto.h b/servers/ext2/proto.h
index 2f4682687..f7f890d52 100644
--- a/servers/ext2/proto.h
+++ b/servers/ext2/proto.h
@@ -19,15 +19,15 @@ block_t alloc_block(struct inode *rip, block_t goal);
 void free_block(struct super_block *sp, bit_t bit);
 
 /* ialloc.c */
-struct inode *alloc_inode(struct inode *parent, pmode_t bits);
+struct inode *alloc_inode(struct inode *parent, mode_t bits);
 void free_inode(struct inode *rip);
 
 /* inode.c */
 void dup_inode(struct inode *ip);
-struct inode *find_inode(dev_t dev, pino_t numb);
+struct inode *find_inode(dev_t dev, ino_t numb);
 int fs_putnode(void);
 void init_inode_cache(void);
-struct inode *get_inode(dev_t dev, pino_t numb);
+struct inode *get_inode(dev_t dev, ino_t numb);
 void put_inode(struct inode *rip);
 void update_times(struct inode *rip);
 void rw_inode(struct inode *rip, int rw_flag);
@@ -62,14 +62,14 @@ int fs_slink(void);
 int fs_lookup(void);
 struct inode *advance(struct inode *dirp, char string[NAME_MAX + 1], int
 	chk_perm);
-int search_dir(struct inode *ldir_ptr, const char string [NAME_MAX + 1], pino_t
+int search_dir(struct inode *ldir_ptr, const char string [NAME_MAX + 1], ino_t
 	*numb, int flag, int check_permissions, int ftype);
 
 /* protect.c */
 int fs_chmod(void);
 int fs_chown(void);
 int fs_getdents(void);
-int forbidden(struct inode *rip, pmode_t access_desired);
+int forbidden(struct inode *rip, mode_t access_desired);
 int read_only(struct inode *ip);
 
 /* read.c */
diff --git a/servers/ext2/stadir.c b/servers/ext2/stadir.c
index 706bfa9c5..df491a573 100644
--- a/servers/ext2/stadir.c
+++ b/servers/ext2/stadir.c
@@ -23,7 +23,7 @@ static int stat_inode(
 /* Common code for stat and fstat system calls. */
 
   struct stat statbuf;
-  pmode_t mo;
+  mode_t mo;
   int r, s;
 
   /* Update the atime, ctime, and mtime fields in the inode, if need be. */
diff --git a/servers/iso9660fs/inode.c b/servers/iso9660fs/inode.c
index 07ba73bf0..e3e122fed 100644
--- a/servers/iso9660fs/inode.c
+++ b/servers/iso9660fs/inode.c
@@ -86,7 +86,7 @@ struct dir_record *get_free_dir_record(void)
  *				get_dir_record				     *
  *===========================================================================*/
 struct dir_record *get_dir_record(id_dir_record)
-pino_t id_dir_record;
+ino_t id_dir_record;
 {
   struct dir_record *dir = NULL;
   u32_t address;
@@ -209,8 +209,8 @@ u32_t address;
 
   /* Set physical address of the dir record */
   dir->d_phy_addr = address;
-  dir->d_ino_nr = (pino_t) address; /* u32_t e ino_t are the same datatype so
-				     * the cast is safe */
+  dir->d_ino_nr = address;
+
   return(OK);
 }
 
diff --git a/servers/iso9660fs/inode.h b/servers/iso9660fs/inode.h
index 79c4c7b9e..d0e7bddcf 100644
--- a/servers/iso9660fs/inode.h
+++ b/servers/iso9660fs/inode.h
@@ -18,10 +18,10 @@ struct dir_record {
 
   /* Memory attrs */
   u8_t d_count;			/* Count if the dir_record is in use or not */
-  pmode_t d_mode;		/* file type, protection, etc. */
+  mode_t d_mode;			/* file type, protection, etc. */
 /*   struct hash_idi_entry *id; */	/* id associated */
   u32_t d_phy_addr;		/* physical address of this dir record */
-  pino_t d_ino_nr;		/* inode number (identical to the address) */
+  ino_t d_ino_nr;		/* inode number (identical to the address) */
   char d_mountpoint;		/* true if mounted on */
   struct dir_record *d_next;	/* In case the file consists in more file sections
 				   this points to the next one */
diff --git a/servers/iso9660fs/path.c b/servers/iso9660fs/path.c
index fd7a5daf5..73c55a2fb 100644
--- a/servers/iso9660fs/path.c
+++ b/servers/iso9660fs/path.c
@@ -6,7 +6,7 @@
 #include "buf.h"
 
 static char *get_name(char *name, char string[NAME_MAX+1]);
-static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
+static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
 	dir_record **res_inop, size_t *offsetp);
 
 
@@ -82,7 +82,7 @@ int fs_lookup() {
 int search_dir(
 	register struct dir_record *ldir_ptr,	/* dir record parent */
 	char string[NAME_MAX],			/* component to search for */
-	pino_t *numb				/* pointer to new dir record */
+	ino_t *numb				/* pointer to new dir record */
 ) {
   struct dir_record *dir_tmp;
   register struct buf *bp;
@@ -182,8 +182,8 @@ int search_dir(
  *                             parse_path				     *
  *===========================================================================*/
 static int parse_path(
-pino_t dir_ino,
-pino_t root_ino,
+ino_t dir_ino,
+ino_t root_ino,
 int flags,
 struct dir_record **res_inop,
 size_t *offsetp
@@ -195,7 +195,7 @@ size_t *offsetp
 
   /* Find starting inode inode according to the request message */
   if ((start_dir = get_dir_record(dir_ino)) == NULL) {
-    printf("ISOFS: couldn't find starting inode %u\n", dir_ino);
+    printf("ISOFS: couldn't find starting inode %llu\n", dir_ino);
     return(ENOENT);
   }
   
@@ -292,7 +292,7 @@ struct dir_record **resp;		/* resulting inode */
 
   register struct dir_record *rip = NULL;
   int r;
-  pino_t numb;
+  ino_t numb;
 
   /* If 'string' is empty, yield same inode straight away. */
   if (string[0] == '\0') {
diff --git a/servers/iso9660fs/proto.h b/servers/iso9660fs/proto.h
index 52b5d051b..faa39aaac 100644
--- a/servers/iso9660fs/proto.h
+++ b/servers/iso9660fs/proto.h
@@ -19,7 +19,7 @@ int create_dir_record(struct dir_record *dir, char *buffer, u32_t
 int create_ext_attr(struct ext_attr_rec *ext, char *buffer);
 int fs_getnode(void);
 int fs_putnode(void);
-struct dir_record *get_dir_record(pino_t id_dir);
+struct dir_record *get_dir_record(ino_t id_dir);
 struct dir_record *get_free_dir_record(void);
 struct ext_attr_rec *get_free_ext_attr(void);
 struct dir_record *load_dir_record_from_disk(u32_t address);
@@ -38,7 +38,7 @@ int fs_unmount(void);
 int fs_lookup(void);
 int advance(struct dir_record *dirp, char string[NAME_MAX], struct
 	dir_record **resp);
-int search_dir(struct dir_record *ldir_ptr,char string [NAME_MAX],pino_t *numb);
+int search_dir(struct dir_record *ldir_ptr, char string [NAME_MAX], ino_t *numb);
 
 /* read.c */
 int fs_read(void);
diff --git a/servers/iso9660fs/read.c b/servers/iso9660fs/read.c
index 75c2ac21d..ff5738a3b 100644
--- a/servers/iso9660fs/read.c
+++ b/servers/iso9660fs/read.c
@@ -143,7 +143,7 @@ int fs_bread(void)
 int fs_getdents(void)
 {
   struct dir_record *dir;
-  pino_t ino;
+  ino_t ino;
   cp_grant_id_t gid;
   size_t block_size;
   off_t pos, block_pos, block, cur_pos, tmpbuf_offset, userbuf_off;
diff --git a/servers/mfs/const.h b/servers/mfs/const.h
index 31b515722..5ea8e5eef 100644
--- a/servers/mfs/const.h
+++ b/servers/mfs/const.h
@@ -60,7 +60,7 @@
 
 #define END_OF_FILE   (-104)	/* eof detected */
 
-#define ROOT_INODE   ((pino_t) 1)	/* inode number for root directory */
+#define ROOT_INODE   ((ino_t) 1)	/* inode number for root directory */
 #define BOOT_BLOCK  ((block_t) 0)	/* block number of boot block */
 #define SUPER_BLOCK_BYTES  (1024)	/* bytes offset */
 #define START_BLOCK ((block_t) 2)	/* first block of FS (not counting SB) */
diff --git a/servers/mfs/inode.c b/servers/mfs/inode.c
index 69f6d4b44..3cabfe749 100644
--- a/servers/mfs/inode.c
+++ b/servers/mfs/inode.c
@@ -25,7 +25,7 @@
 
 static void addhash_inode(struct inode *node);
 
-static void free_inode(dev_t dev, pino_t numb);
+static void free_inode(dev_t dev, ino_t numb);
 static void new_icopy(struct inode *rip, d2_inode *dip, int direction,
 	int norm);
 static void unhash_inode(struct inode *node);
@@ -123,7 +123,7 @@ static void unhash_inode(struct inode *node)
  *===========================================================================*/
 struct inode *get_inode(
   dev_t dev,			/* device on which inode resides */
-  pino_t numb			/* inode number */
+  ino_t numb			/* inode number */
 )
 {
 /* Find the inode in the hash table. If it is not there, get a free inode
@@ -185,7 +185,7 @@ struct inode *get_inode(
  *===========================================================================*/
 struct inode *find_inode(
   dev_t dev,			/* device on which inode resides */
-  pino_t numb			/* inode number */
+  ino_t numb			/* inode number */
 )
 {
 /* Find the inode specified by the inode and device number.
@@ -255,7 +255,7 @@ register struct inode *rip;	/* pointer to inode to be released */
 /*===========================================================================*
  *				alloc_inode				     *
  *===========================================================================*/
-struct inode *alloc_inode(dev_t dev, pmode_t bits)
+struct inode *alloc_inode(dev_t dev, mode_t bits)
 {
 /* Allocate a free inode on 'dev', and return a pointer to it. */
 
@@ -333,7 +333,7 @@ register struct inode *rip;	/* the inode to be erased */
  *===========================================================================*/
 static void free_inode(
   dev_t dev,			/* on which device is the inode? */
-  pino_t inumb			/* number of the inode to be freed */
+  ino_t inumb			/* number of the inode to be freed */
 )
 {
 /* Return an inode to the pool of unallocated inodes. */
@@ -428,7 +428,7 @@ int norm;			/* TRUE = do not swap bytes; FALSE = swap */
 
   if (direction == READING) {
 	/* Copy V2.x inode to the in-core table, swapping bytes if need be. */
-	rip->i_mode    = (pmode_t) conv2(norm,dip->d2_mode);
+	rip->i_mode    = (mode_t) conv2(norm,dip->d2_mode);
 	rip->i_uid     = (uid_t) conv2(norm,dip->d2_uid);
 	rip->i_nlinks  = (nlink_t) conv2(norm,dip->d2_nlinks);
 	rip->i_gid     = (gid_t) conv2(norm,dip->d2_gid);
diff --git a/servers/mfs/inode.h b/servers/mfs/inode.h
index dee01ed87..a5354c78f 100644
--- a/servers/mfs/inode.h
+++ b/servers/mfs/inode.h
@@ -30,7 +30,7 @@ EXTERN struct inode {
   
   /* The following items are not present on the disk. */
   dev_t i_dev;			/* which device is the inode on */
-  pino_t i_num;			/* inode number on its (minor) device */
+  ino_t i_num;			/* inode number on its (minor) device */
   int i_count;			/* # times inode used; 0 means slot is free */
   unsigned int i_ndzones;	/* # direct zones (Vx_NR_DZONES) */
   unsigned int i_nindirs;	/* # indirect zones per indirect block */
diff --git a/servers/mfs/link.c b/servers/mfs/link.c
index 32358485d..b76356e13 100644
--- a/servers/mfs/link.c
+++ b/servers/mfs/link.c
@@ -252,7 +252,7 @@ char file_name[MFS_NAME_MAX];	/* name of file to be removed */
 {
 /* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
 
-  pino_t numb;			/* inode number */
+  ino_t numb;			/* inode number */
   int	r;
 
   /* If rip is not NULL, it is used to get faster access to the inode. */
@@ -291,7 +291,7 @@ int fs_rename()
   int odir, ndir;			/* TRUE iff {old|new} file is dir */
   int same_pdir;			/* TRUE iff parent dirs are the same */
   char old_name[MFS_NAME_MAX], new_name[MFS_NAME_MAX];
-  pino_t numb;
+  ino_t numb;
   phys_bytes len;
   
   /* Copy the last component of the old name */
@@ -328,7 +328,7 @@ int fs_rename()
   }
 
   /* Get new dir inode */ 
-  if ((new_dirp = get_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){
+  if ((new_dirp = get_inode(fs_dev, fs_m_in.m_vfs_fs_rename.dir_new)) == NULL){
         put_inode(old_ip);
         put_inode(old_dirp);
         return(err_code);
@@ -527,7 +527,7 @@ off_t newsize;			/* inode must become this size */
  * writing is done.
  */
   int r;
-  pmode_t file_type;
+  mode_t file_type;
 
   file_type = rip->i_mode & I_TYPE;	/* check to see if file is special */
   if (file_type == I_CHAR_SPECIAL || file_type == I_BLOCK_SPECIAL)
diff --git a/servers/mfs/mount.c b/servers/mfs/mount.c
index ec832e9b3..797b81854 100644
--- a/servers/mfs/mount.c
+++ b/servers/mfs/mount.c
@@ -129,7 +129,7 @@ int fs_mountpoint()
  */
   register struct inode *rip;
   int r = OK;
-  pmode_t bits;
+  mode_t bits;
   
   /* Temporarily open the file. */
   if( (rip = get_inode(fs_dev, fs_m_in.m_vfs_fs_mountpoint.inode)) == NULL)
diff --git a/servers/mfs/open.c b/servers/mfs/open.c
index 0af6366d0..fba0d3094 100644
--- a/servers/mfs/open.c
+++ b/servers/mfs/open.c
@@ -7,7 +7,7 @@
 #include "super.h"
 #include <minix/vfsif.h>
 
-static struct inode *new_node(struct inode *ldirp, char *string, pmode_t
+static struct inode *new_node(struct inode *ldirp, char *string, mode_t
 	bits, zone_t z0);
 
 /*===========================================================================*
@@ -106,7 +106,7 @@ int fs_mknod()
 int fs_mkdir()
 {
   int r1, r2;			/* status codes */
-  pino_t dot, dotdot;		/* inode numbers for . and .. */
+  ino_t dot, dotdot;		/* inode numbers for . and .. */
   struct inode *rip, *ldirp;
   char lastc[MFS_NAME_MAX];         /* last component */
   phys_bytes len;
@@ -155,7 +155,7 @@ int fs_mkdir()
 	  /* It was not possible to enter . or .. probably disk was full -
 	   * links counts haven't been touched. */
 	  if(search_dir(ldirp, lastc, NULL, DELETE, IGN_PERM) != OK)
-		  panic("Dir disappeared: %ul", rip->i_num);
+		  panic("Dir disappeared: %llu", rip->i_num);
 	  rip->i_nlinks--;	/* undo the increment done in new_node() */
   }
   IN_MARKDIRTY(rip);		/* either way, i_nlinks has changed */
@@ -193,8 +193,7 @@ int fs_slink()
 	  return(EINVAL);
 
   /* Create the inode for the symlink. */
-  sip = new_node(ldirp, string, (pmode_t) (I_SYMBOLIC_LINK | RWX_MODES),
-		   (zone_t) 0);
+  sip = new_node(ldirp, string, (I_SYMBOLIC_LINK | RWX_MODES), 0);
 
   /* Allocate a disk block for the contents of the symlink.
    * Copy contents of symlink (the name pointed to) into first disk block. */
@@ -250,7 +249,7 @@ int fs_slink()
  *				new_node				     *
  *===========================================================================*/
 static struct inode *new_node(struct inode *ldirp,
-	char *string, pmode_t bits, zone_t z0)
+	char *string, mode_t bits, zone_t z0)
 {
 /* New_node() is called by fs_open(), fs_mknod(), and fs_mkdir().  
  * In all cases it allocates a new inode, makes a directory entry for it in
diff --git a/servers/mfs/path.c b/servers/mfs/path.c
index 33e687d29..14800a4e2 100644
--- a/servers/mfs/path.c
+++ b/servers/mfs/path.c
@@ -27,7 +27,7 @@ char dot2[3] = "..";	/* permissions for . and ..		    */
 
 static char *get_name(char *name, char string[MFS_NAME_MAX+1]);
 static int ltraverse(struct inode *rip, char *suffix);
-static int parse_path(pino_t dir_ino, pino_t root_ino, int flags, struct
+static int parse_path(ino_t dir_ino, ino_t root_ino, int flags, struct
 	inode **res_inop, size_t *offsetp, int *symlinkp);
 
 
@@ -121,8 +121,8 @@ int fs_lookup()
  *                             parse_path				     *
  *===========================================================================*/
 static int parse_path(
-pino_t dir_ino,
-pino_t root_ino,
+ino_t dir_ino,
+ino_t root_ino,
 int flags,
 struct inode **res_inop,
 size_t *offsetp,
@@ -355,7 +355,7 @@ int chk_perm;			/* check permissions when string is looked up*/
  * the directory, find the inode, open it, and return a pointer to its inode
  * slot.
  */
-  pino_t numb;
+  ino_t numb;
   struct inode *rip;
 
   /* If 'string' is empty, return an error. */
@@ -463,7 +463,7 @@ char string[MFS_NAME_MAX+1];	/* component extracted from 'old_name' */
 int search_dir(ldir_ptr, string, numb, flag, check_permissions)
 register struct inode *ldir_ptr; /* ptr to inode for dir to search */
 char string[MFS_NAME_MAX];		 /* component to search for */
-pino_t *numb;			 /* pointer to inode number */
+ino_t *numb;			 /* pointer to inode number */
 int flag;			 /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
 int check_permissions;		 /* check permissions when flag is !IS_EMPTY */
 {
@@ -479,7 +479,7 @@ int check_permissions;		 /* check permissions when flag is !IS_EMPTY */
   register struct direct *dp = NULL;
   register struct buf *bp = NULL;
   int i, r, e_hit, t, match;
-  pmode_t bits;
+  mode_t bits;
   off_t pos;
   unsigned new_slots, old_slots;
   struct super_block *sp;
@@ -558,8 +558,8 @@ int check_permissions;		 /* check permissions when flag is !IS_EMPTY */
 			if (flag == IS_EMPTY) r = ENOTEMPTY;
 			else if (flag == DELETE) {
 				/* Save d_ino for recovery. */
-				t = MFS_NAME_MAX - sizeof(pino_t);
-				*((pino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
+				t = MFS_NAME_MAX - sizeof(ino_t);
+				*((ino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
 				dp->mfs_d_ino = NO_ENTRY;	/* erase entry */
 				MARKDIRTY(bp);
 				ldir_ptr->i_update |= CTIME | MTIME;
@@ -568,7 +568,7 @@ int check_permissions;		 /* check permissions when flag is !IS_EMPTY */
 					ldir_ptr->i_last_dpos = pos;
 			} else {
 				sp = ldir_ptr->i_sp;	/* 'flag' is LOOK_UP */
-				*numb = (pino_t) conv4(sp->s_native,
+				*numb = (ino_t) conv4(sp->s_native,
 						      (int) dp->mfs_d_ino);
 			}
 			assert(lmfs_dev(bp) != NO_DEV);
diff --git a/servers/mfs/protect.c b/servers/mfs/protect.c
index c17712852..ee069e26d 100644
--- a/servers/mfs/protect.c
+++ b/servers/mfs/protect.c
@@ -14,7 +14,7 @@ int fs_chmod()
 /* Perform the chmod(name, mode) system call. */
 
   register struct inode *rip;
-  pmode_t mode;
+  mode_t mode;
 
   mode = fs_m_in.m_vfs_fs_chmod.mode;
   
@@ -73,7 +73,7 @@ int fs_chown()
 /*===========================================================================*
  *				forbidden				     *
  *===========================================================================*/
-int forbidden(register struct inode *rip, pmode_t access_desired)
+int forbidden(struct inode *rip, mode_t access_desired)
 {
 /* Given a pointer to an inode, 'rip', and the access desired, determine
  * if the access is allowed, and if not why not.  The routine looks up the
@@ -82,7 +82,7 @@ int forbidden(register struct inode *rip, pmode_t access_desired)
  */
 
   register struct inode *old_rip = rip;
-  register pmode_t bits, perm_bits;
+  mode_t bits, perm_bits;
   int r, shift;
 
   /* Isolate the relevant rwx bits from the mode. */
diff --git a/servers/mfs/proto.h b/servers/mfs/proto.h
index 2f402ff33..6d9557692 100644
--- a/servers/mfs/proto.h
+++ b/servers/mfs/proto.h
@@ -19,12 +19,12 @@ zone_t alloc_zone(dev_t dev, zone_t z);
 void free_zone(dev_t dev, zone_t numb);
 
 /* inode.c */
-struct inode *alloc_inode(dev_t dev, pmode_t bits);
+struct inode *alloc_inode(dev_t dev, mode_t bits);
 void dup_inode(struct inode *ip);
-struct inode *find_inode(dev_t dev, pino_t numb);
+struct inode *find_inode(dev_t dev, ino_t numb);
 int fs_putnode(void);
 void init_inode_cache(void);
-struct inode *get_inode(dev_t dev, pino_t numb);
+struct inode *get_inode(dev_t dev, ino_t numb);
 void put_inode(struct inode *rip);
 void update_times(struct inode *rip);
 void rw_inode(struct inode *rip, int rw_flag);
@@ -59,7 +59,7 @@ int fs_slink(void);
 int fs_lookup(void);
 struct inode *advance(struct inode *dirp, char string[MFS_NAME_MAX], int
 	chk_perm);
-int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], pino_t
+int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], ino_t
 	*numb, int flag, int check_permissions);
 
 
@@ -67,7 +67,7 @@ int search_dir(struct inode *ldir_ptr, char string [MFS_NAME_MAX], pino_t
 int fs_chmod(void);
 int fs_chown(void);
 int fs_getdents(void);
-int forbidden(struct inode *rip, pmode_t access_desired);
+int forbidden(struct inode *rip, mode_t access_desired);
 int read_only(struct inode *ip);
 
 /* read.c */
diff --git a/servers/mfs/read.c b/servers/mfs/read.c
index 0d928efba..694e3caf7 100644
--- a/servers/mfs/read.c
+++ b/servers/mfs/read.c
@@ -38,7 +38,7 @@ int fs_readwrite(void)
   r = OK;
   
   /* Find the inode referred */
-  if ((rip = find_inode(fs_dev, (pino_t) fs_m_in.m_vfs_fs_readwrite.inode)) == NULL)
+  if ((rip = find_inode(fs_dev, fs_m_in.m_vfs_fs_readwrite.inode)) == NULL)
 	return(EINVAL);
 
   mode_word = rip->i_mode & I_TYPE;
@@ -608,7 +608,7 @@ int fs_getdents(void)
   register struct inode *rip;
   int o, r, done;
   unsigned int block_size, len, reclen;
-  pino_t ino;
+  ino_t ino;
   cp_grant_id_t gid;
   size_t size, tmpbuf_off, userbuf_off;
   off_t pos, off, block_pos, new_pos, ent_pos;
diff --git a/servers/mfs/stadir.c b/servers/mfs/stadir.c
index 3f2ba0039..446697e53 100644
--- a/servers/mfs/stadir.c
+++ b/servers/mfs/stadir.c
@@ -50,7 +50,7 @@ static int stat_inode(
 /* Common code for stat and fstat system calls. */
 
   struct stat statbuf;
-  pmode_t mo;
+  mode_t mo;
   int r, s;
 
   /* Update the atime, ctime, and mtime fields in the inode, if need be. */
diff --git a/servers/mfs/super.c b/servers/mfs/super.c
index 2d5f8f21f..b31edb2c7 100644
--- a/servers/mfs/super.c
+++ b/servers/mfs/super.c
@@ -273,7 +273,7 @@ int read_super(struct super_block *sp)
 
   /* If the super block has the wrong byte order, swap the fields; the magic
    * number doesn't need conversion. */
-  sp->s_ninodes =          (pino_t) conv4(native, (int) sp->s_ninodes);
+  sp->s_ninodes =           (ino_t) conv4(native, (int) sp->s_ninodes);
   sp->s_nzones =          (zone1_t) conv2(native, (int) sp->s_nzones);
   sp->s_imap_blocks =       (short) conv2(native, (int) sp->s_imap_blocks);
   sp->s_zmap_blocks =       (short) conv2(native, (int) sp->s_zmap_blocks);
diff --git a/servers/pfs/buf.h b/servers/pfs/buf.h
index b8d90f839..cd31f7e84 100644
--- a/servers/pfs/buf.h
+++ b/servers/pfs/buf.h
@@ -11,7 +11,7 @@ struct buf {
   /* Header portion of the buffer. */
   struct buf *b_next;           /* used to link all free bufs in a chain */
   struct buf *b_prev;           /* used to link all free bufs the other way */
-  pino_t b_num;			/* inode number on minor device */
+  ino_t b_num;			/* inode number on minor device */
   dev_t b_dev;                  /* major | minor device where block resides */
   int b_bytes;                  /* Number of bytes allocated in bp */
   int b_count;			/* Number of users of this buffer */
diff --git a/servers/pfs/buffer.c b/servers/pfs/buffer.c
index ce1399088..825ca1b52 100644
--- a/servers/pfs/buffer.c
+++ b/servers/pfs/buffer.c
@@ -5,7 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-static struct buf *new_block(dev_t dev, pino_t inum);
+static struct buf *new_block(dev_t dev, ino_t inum);
 
 /*===========================================================================*
  *                              buf_pool                                     *
@@ -23,7 +23,7 @@ void buf_pool(void)
 /*===========================================================================*
  *				get_block				     *
  *===========================================================================*/
-struct buf *get_block(dev_t dev, pino_t inum)
+struct buf *get_block(dev_t dev, ino_t inum)
 {
   struct buf *bp = front;
 
@@ -43,7 +43,7 @@ struct buf *get_block(dev_t dev, pino_t inum)
 /*===========================================================================*
  *				new_block				     *
  *===========================================================================*/
-static struct buf *new_block(dev_t dev, pino_t inum)
+static struct buf *new_block(dev_t dev, ino_t inum)
 {
 /* Allocate a new buffer and add it to the double linked buffer list */
   struct buf *bp;
@@ -77,7 +77,7 @@ static struct buf *new_block(dev_t dev, pino_t inum)
 /*===========================================================================*
  *				put_block				     *
  *===========================================================================*/
-void put_block(dev_t dev, pino_t inum)
+void put_block(dev_t dev, ino_t inum)
 {
   struct buf *bp;
 
diff --git a/servers/pfs/inode.c b/servers/pfs/inode.c
index 29a2d198f..e988cd8dc 100644
--- a/servers/pfs/inode.c
+++ b/servers/pfs/inode.c
@@ -38,7 +38,7 @@ int fs_putnode(message *fs_m_in, message *fs_m_out)
   rip = find_inode(fs_m_in->m_vfs_fs_putnode.inode);
 
   if(!rip) {
-	  printf("%s:%d put_inode: inode #%ld not found\n", __FILE__,
+	  printf("%s:%d put_inode: inode #%llu not found\n", __FILE__,
 		 __LINE__, fs_m_in->m_vfs_fs_putnode.inode);
 	  panic("fs_putnode failed");
   }
@@ -119,7 +119,7 @@ static void unhash_inode(struct inode * const node)
  *===========================================================================*/
 struct inode *get_inode(
   dev_t dev,		/* device on which inode resides */
-  pino_t numb		/* inode number */
+  ino_t numb		/* inode number */
 )
 {
 /* Find the inode in the hash table. If it is not there, get a free inode
@@ -173,7 +173,7 @@ struct inode *get_inode(
 /*===========================================================================*
  *				find_inode        			     *
  *===========================================================================*/
-struct inode *find_inode(pino_t numb	/* inode number */)
+struct inode *find_inode(ino_t numb	/* inode number */)
 {
 /* Find the inode specified by the inode and device number.
  */
@@ -237,13 +237,13 @@ struct inode *rip;	/* pointer to inode to be released */
 /*===========================================================================*
  *				alloc_inode				     *
  *===========================================================================*/
-struct inode *alloc_inode(dev_t dev, pmode_t bits, uid_t uid, gid_t gid)
+struct inode *alloc_inode(dev_t dev, mode_t bits, uid_t uid, gid_t gid)
 {
 /* Allocate a free inode on 'dev', and return a pointer to it. */
 
   register struct inode *rip;
   bit_t b;
-  pino_t i_num;
+  ino_t i_num;
   int print_oos_msg = 1;
 
   b = alloc_bit();
@@ -254,7 +254,7 @@ struct inode *alloc_inode(dev_t dev, pmode_t bits, uid_t uid, gid_t gid)
 	print_oos_msg = 0;	/* Don't repeat message */
 	return(NULL);
   }
-  i_num = (pino_t) b;
+  i_num = (ino_t) b;
   print_oos_msg = 1;
 
 
@@ -308,7 +308,7 @@ struct inode *rip;
 
   bit_t b;
 
-  if (rip->i_num <= (pino_t) 0 || rip->i_num >= (pino_t) PFS_NR_INODES) return;
+  if (rip->i_num <= 0 || rip->i_num >= PFS_NR_INODES) return;
   b = (bit_t) rip->i_num;
   free_bit(b);
 }
diff --git a/servers/pfs/inode.h b/servers/pfs/inode.h
index 4559bbec0..897ba7aca 100644
--- a/servers/pfs/inode.h
+++ b/servers/pfs/inode.h
@@ -7,7 +7,7 @@
 #include <sys/queue.h>
 
 EXTERN struct inode {
-  pmode_t i_mode;		/* file type, protection, etc. */
+  mode_t i_mode;		/* file type, protection, etc. */
   nlink_t i_nlinks;		/* how many links to this file */
   uid_t i_uid;			/* user id of the file's owner */
   gid_t i_gid;			/* group number */
diff --git a/servers/pfs/proto.h b/servers/pfs/proto.h
index 37383f451..d19151f0b 100644
--- a/servers/pfs/proto.h
+++ b/servers/pfs/proto.h
@@ -8,20 +8,20 @@ struct buf;
 struct inode;
 
 /* buffer.c */
-struct buf *get_block(dev_t dev, pino_t inum);
-void put_block(dev_t dev, pino_t inum);
+struct buf *get_block(dev_t dev, ino_t inum);
+void put_block(dev_t dev, ino_t inum);
 
 /* cache.c */
 void buf_pool(void);
 
 /* inode.c */
-struct inode *alloc_inode(dev_t dev, pmode_t mode, uid_t uid, gid_t gid);
+struct inode *alloc_inode(dev_t dev, mode_t mode, uid_t uid, gid_t gid);
 void dup_inode(struct inode *ip);
-struct inode *find_inode(pino_t numb);
+struct inode *find_inode(ino_t numb);
 void free_inode(struct inode *rip);
 int fs_putnode(message *fs_m_in, message *fs_m_out);
 void init_inode_cache(void);
-struct inode *get_inode(dev_t dev, pino_t numb);
+struct inode *get_inode(dev_t dev, ino_t numb);
 void put_inode(struct inode *rip);
 void update_times(struct inode *rip);
 void wipe_inode(struct inode *rip);
diff --git a/servers/pfs/read.c b/servers/pfs/read.c
index 7a5100fb3..d7a8ff877 100644
--- a/servers/pfs/read.c
+++ b/servers/pfs/read.c
@@ -14,7 +14,7 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
   struct buf *bp;
   cp_grant_id_t gid;
   off_t position, f_size;
-  unsigned int nrbytes, cum_io;
+  size_t nrbytes, cum_io;
   mode_t mode_word;
   struct inode *rip;
   ino_t inumb;
@@ -33,7 +33,7 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
   /* Get the values from the request message */
   rw_flag = (fs_m_in->m_type == REQ_READ ? READING : WRITING);
   gid = fs_m_in->m_vfs_fs_readwrite.grant;
-  nrbytes = (unsigned) fs_m_in->m_vfs_fs_readwrite.nbytes;
+  nrbytes = fs_m_in->m_vfs_fs_readwrite.nbytes;
 
   /* We can't read beyond the max file position */
   if (nrbytes > PIPE_BUF) return(EFBIG);
@@ -87,7 +87,7 @@ int fs_readwrite(message *fs_m_in, message *fs_m_out)
 	if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME;
   }
 
-  fs_m_out->m_fs_vfs_readwrite.nbytes = (size_t) cum_io;
+  fs_m_out->m_fs_vfs_readwrite.nbytes = cum_io;
   fs_m_out->m_fs_vfs_readwrite.seek_pos = rip->i_size;
 
   put_inode(rip);
diff --git a/servers/pfs/stadir.c b/servers/pfs/stadir.c
index f0d27150a..c6aa2aad0 100644
--- a/servers/pfs/stadir.c
+++ b/servers/pfs/stadir.c
@@ -14,7 +14,7 @@ static int stat_inode(
 )
 {
 /* Common code for stat and fstat system calls. */
-  pmode_t type;
+  mode_t type;
   struct stat statbuf;
   u32_t blocks; /* The unit of this is 512 */
   int r, s;
diff --git a/servers/procfs/type.h b/servers/procfs/type.h
index bdfd8aa59..d2f72acd5 100644
--- a/servers/procfs/type.h
+++ b/servers/procfs/type.h
@@ -68,7 +68,7 @@ struct load {
  */
 struct file {
 	char *name;		/* file name, maximum length PNAME_MAX */
-	pmode_t mode;		/* file mode, including file type */
+	mode_t mode;		/* file mode, including file type */
 	data_t data;		/* custom data associated with this file */
 };
 
diff --git a/servers/vfs/request.c b/servers/vfs/request.c
index 64b6fb8ad..5aa1acd04 100644
--- a/servers/vfs/request.c
+++ b/servers/vfs/request.c
@@ -828,7 +828,7 @@ int req_readsuper(
  *===========================================================================*/
 static int req_readwrite_actual(endpoint_t fs_e, ino_t inode_nr, off_t pos,
 	int rw_flag, endpoint_t user_e, vir_bytes user_addr,
-	unsigned int num_of_bytes, off_t *new_posp, unsigned int *cum_iop,
+	unsigned int num_of_bytes, off_t *new_posp, size_t *cum_iop,
 	int cpflag)
 {
   struct vmnt *vmp;