Cleanup: convert K&R-style definitions to ANSI-style in minix/fs

This task is listed in minix wishlist. No functional chamges are
intended.

minix/fs/ext2/balloc.c

@@ -146,11 +146,12 @@ static void check_block_number(block_t block, struct super_block *sp,
 
 /*===========================================================================*
  *                              alloc_block_bit                              *
+ *                              sp: the file system to allocate from
+ *                              goal: try to allocate near this block
+ *                              rip: used for preallocation
  *===========================================================================*/
-static block_t alloc_block_bit(sp, goal, rip)
+static block_t alloc_block_bit(struct super_block *sp, block_t goal,
-struct super_block *sp;		/* the filesystem to allocate from */
+							   struct inode *rip)
-block_t goal;			/* try to allocate near this block */
-struct inode *rip;		/* used for preallocation */
 {
   block_t block = NO_BLOCK;	/* allocated block */
   int word;			/* word in block bitmap */

minix/fs/ext2/ialloc.c

@@ -119,11 +119,13 @@ static int find_group_orlov(struct super_block *sp, struct inode
 
 /*===========================================================================*
  *                              alloc_inode_bit                              *
+ *                              sp: the filesystem to allocate from			 *
+ *                              parent: parent of newly allocated inode		 *
+ *                              is_dir: inode will be a directory if it is	 *
+ *                              		TRUE								 *
  *===========================================================================*/
-static bit_t alloc_inode_bit(sp, parent, is_dir)
+static bit_t alloc_inode_bit(struct super_block *sp, struct inode *parent,
-struct super_block *sp;         /* the filesystem to allocate from */
+							 int is_dir)
-struct inode *parent;		/* parent of newly allocated inode */
-int is_dir;			/* inode will be a directory if it is TRUE */
 {
   int group;
   ino_t inumber = NO_BIT;

minix/fs/ext2/inode.c

@@ -64,7 +64,7 @@ int fs_putnode(ino_t ino_nr, unsigned int count)
 /*===========================================================================*
  *                init_inode_cache                                           *
  *===========================================================================*/
-void init_inode_cache()
+void init_inode_cache(void)
 {
   struct inode *rip;
   struct inodelist *rlp;

minix/fs/ext2/link.c

@@ -192,12 +192,13 @@ ssize_t fs_rdlink(ino_t ino_nr, struct fsdriver_data *data, size_t bytes)
 
 
 /*===========================================================================*
- *				remove_dir				     *
+ *				remove_dir													 *
+ *				rldirp: parent directory									 *
+ *				rip: directory to be removed								 *
+ *				dir_name: name of directory to be removed					 *
  *===========================================================================*/
-static int remove_dir(rldirp, rip, dir_name)
+static int remove_dir(struct inode *rldirp, struct inode *rip,
-struct inode *rldirp;		 	/* parent directory */
+					  const char *dir_name)
-struct inode *rip;			/* directory to be removed */
-const char *dir_name;			/* name of directory to be removed */
 {
   /* A directory file has to be removed. Five conditions have to met:
    * 	- The file must be a directory
@@ -227,12 +228,13 @@ const char *dir_name;			/* name of directory to be removed */
 
 
 /*===========================================================================*
- *				unlink_file				     *
+ *				unlink_file													 *
+ *				dirp: parent directory of file								 *
+ *				rip: inode of file, may be NULL too							 *
+ *				file_name: name of file to be removed						 *
  *===========================================================================*/
-static int unlink_file(dirp, rip, file_name)
+static int unlink_file(struct inode *dirp, struct inode *rip,
-struct inode *dirp;		/* parent directory of file */
+					   const char *file_name)
-struct inode *rip;		/* inode of file, may be NULL too. */
-const char *file_name;		/* name of file to be removed */
 {
 /* Unlink 'file_name'; rip must be the inode of 'file_name' or NULL. */
 
@@ -466,11 +468,11 @@ int fs_trunc(ino_t ino_nr, off_t start, off_t end)
 
 
 /*===========================================================================*
- *				truncate_inode				     *
+ *				truncate_inode												 *
+ *				rip: pointer to inode to be truncated						 *
+ *				newsize: inode must become this size						 *
  *===========================================================================*/
-int truncate_inode(rip, newsize)
+int truncate_inode(register struct inode *rip, off_t newsize)
-register struct inode *rip;	/* pointer to inode to be truncated */
-off_t newsize;			/* inode must become this size */
 {
 /* Set inode to a certain size, freeing any blocks no longer referenced
  * and updating the size in the inode. If the inode is extended, the
@@ -510,11 +512,11 @@ off_t newsize;			/* inode must become this size */
 
 
 /*===========================================================================*
- *				freesp_inode				     *
+ *				freesp_inode												 *
+ *				rip: pointer to inode to be partly freed					 *
+ *				start, end: range of bytes to free (end uninclusive)		 *
  *===========================================================================*/
-static int freesp_inode(rip, start, end)
+static int freesp_inode(register struct inode *rip, off_t start, off_t end)
-register struct inode *rip;	/* pointer to inode to be partly freed */
-off_t start, end;		/* range of bytes to free (end uninclusive) */
 {
 /* Cut an arbitrary hole in an inode. The caller is responsible for checking
  * the reasonableness of the inode type of rip. The reason is this is that
@@ -585,9 +587,7 @@ off_t start, end;		/* range of bytes to free (end uninclusive) */
 /*===========================================================================*
  *				nextblock				     *
  *===========================================================================*/
-static off_t nextblock(pos, block_size)
+static off_t nextblock(off_t pos, int block_size)
-off_t pos;
-unsigned short block_size;
 {
 /* Return the first position in the next block after position 'pos'
  * (unless this is the first position in the current block).
@@ -603,10 +603,7 @@ unsigned short block_size;
 /*===========================================================================*
  *				zeroblock_half				     *
  *===========================================================================*/
-static void zeroblock_half(rip, pos, half)
+static void zeroblock_half(struct inode *rip, off_t pos, int half)
-struct inode *rip;
-off_t pos;
-int half;
 {
 /* Zero the upper or lower 'half' of a block that holds position 'pos'.
  * half can be FIRST_HALF or LAST_HALF.
@@ -633,10 +630,7 @@ int half;
 /*===========================================================================*
  *				zeroblock_range				     *
  *===========================================================================*/
-static void zeroblock_range(rip, pos, len)
+static void zeroblock_range(struct inode *rip, off_t pos, off_t len)
-struct inode *rip;
-off_t pos;
-off_t len;
 {
 /* Zero a range in a block.
  * This function is used to zero a segment of a block.

minix/fs/ext2/main.c

@@ -49,7 +49,7 @@ int main(int argc, char *argv[])
 /*===========================================================================*
  *			       sef_local_startup			     *
  *===========================================================================*/
-static void sef_local_startup()
+static void sef_local_startup(void)
 {
   /* Register init callbacks. */
   sef_setcb_init_fresh(sef_cb_init_fresh);

minix/fs/ext2/path.c

@@ -47,11 +47,11 @@ int fs_lookup(ino_t dir_nr, char *name, struct fsdriver_node *node,
 
 
 /*===========================================================================*
- *				advance					     *
+ *				advance														 *
+ *				dirp: inode for directory to be searched					 *
+ *				string: component name to look for							 *
  *===========================================================================*/
-struct inode *advance(dirp, string)
+struct inode *advance(struct inode *dirp, const char *string)
-struct inode *dirp;		/* inode for directory to be searched */
-const char *string;		/* component name to look for */
 {
 /* Given a directory and a component of a path, look up the component in
  * the directory, find the inode, open it, and return a pointer to its inode
@@ -91,13 +91,14 @@ const char *string;		/* component name to look for */
 
 /*===========================================================================*
  *				search_dir				     *
+ *				ldir_ptr: ptr to inode for dir to search
+ *				string: component to search for
+ *				numb: pointer to inode number
+ *				flag: LOOK_UP, ENTER, DELETE or IS_EMPTY
+ *				ftype: used when ENTER and INCOMPAT_FILETYPE
  *===========================================================================*/
-int search_dir(ldir_ptr, string, numb, flag, ftype)
+int search_dir(register struct inode *ldir_ptr, const char *string,
-register struct inode *ldir_ptr; /* ptr to inode for dir to search */
+			   ino_t *numb, int flag, int ftype)
-const char *string;		 /* component to search for */
-ino_t *numb;			 /* pointer to inode number */
-int flag;			 /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
-int ftype;			 /* used when ENTER and INCOMPAT_FILETYPE */
 {
 /* This function searches the directory whose inode is pointed to by 'ldip':
  * if (flag == ENTER)  enter 'string' in the directory with inode # '*numb';

minix/fs/ext2/read.c

@@ -101,20 +101,22 @@ ssize_t fs_readwrite(ino_t ino_nr, struct fsdriver_data *data, size_t nrbytes,
 
 
 /*===========================================================================*
- *				rw_chunk				     *
+ *				rw_chunk													 *
+ *				rip: pointer to inode for file to be rd/wr					 *
+ *				position: position within file to read or write				 *
+ *				off: off within the current block							 *
+ *				chunk: number of bytes to read or write						 *
+ *				left: max number of bytes wanted after position				 *
+ *				call: FSC_READ, FSC_WRITE, or FSC_PEEK						 *
+ *				data: structure for (remote) user buffer					 *
+ *				buf_off: offset in user buffer								 *
+ *				block_size: block size of FS operating on					 *
+ *				completed: number of bytes copied							 *
  *===========================================================================*/
-static int rw_chunk(rip, position, off, chunk, left, call, data, buf_off,
+static int rw_chunk(register struct inode *rip, u64_t position, unsigned off,
-	block_size, completed)
+					size_t chunk, unsigned left, int call,
-register struct inode *rip;     /* pointer to inode for file to be rd/wr */
+					struct fsdriver_data *data, unsigned buf_off,
-u64_t position;                 /* position within file to read or write */
+					unsigned int block_size, int *completed)
-unsigned off;                   /* off within the current block */
-size_t chunk;                   /* number of bytes to read or write */
-unsigned left;                  /* max number of bytes wanted after position */
-int call;                       /* FSC_READ, FSC_WRITE, or FSC_PEEK */
-struct fsdriver_data *data;     /* structure for (remote) user buffer */
-unsigned buf_off;               /* offset in user buffer */
-unsigned int block_size;        /* block size of FS operating on */
-int *completed;                 /* number of bytes copied */
 {
 /* Read or write (part of) a block. */
 
@@ -196,12 +198,11 @@ int *completed;                 /* number of bytes copied */
 
 
 /*===========================================================================*
- *				read_map				     *
+ *				read_map													 *
+ *				rip: prt to inode to map from								 *
+ *				position: position in file whose blk wanted					 *
  *===========================================================================*/
-block_t read_map(rip, position, opportunistic)
+block_t read_map(register struct inode *rip, off_t position, int opportunistic)
-register struct inode *rip;     /* ptr to inode to map from */
-off_t position;                 /* position in file whose blk wanted */
-int opportunistic;
 {
 /* Given an inode and a position within the corresponding file, locate the
  * block number in which that position is to be found and return it.
@@ -296,11 +297,11 @@ struct buf *get_block_map(register struct inode *rip, u64_t position)
 }
 
 /*===========================================================================*
- *				rd_indir				     *
+ *				rd_indir													 *
+ *				bp: pointer to indirect block								 *
+ *				mindex: index into *bp										 *
  *===========================================================================*/
-block_t rd_indir(bp, mindex)
+block_t rd_indir(struct buf *bp, int mindex)
-struct buf *bp;                 /* pointer to indirect block */
-int mindex;                      /* index into *bp */
 {
   if (bp == NULL)
 	panic("rd_indir() on NULL");
@@ -310,13 +311,14 @@ int mindex;                      /* index into *bp */
 
 
 /*===========================================================================*
- *				rahead					     *
+ *				rahead														 *
+ *				rip : pointer to inode for file to be read					 *
+ *				baselock: block at current position							 *
+ *				position: position within file								 *
+ *				bytes ahead: bytes beyond position for immediate use		 *
  *===========================================================================*/
-static struct buf *rahead(rip, baseblock, position, bytes_ahead)
+static struct buf *rahead(register struct inode *rip, block_t baseblock,
-register struct inode *rip;     /* pointer to inode for file to be read */
+						  u64_t position, unsigned bytes_ahead)
-block_t baseblock;              /* block at current position */
-u64_t position;                 /* position within file */
-unsigned bytes_ahead;           /* bytes beyond position for immediate use */
 {
 /* Fetch a block from the cache or the device.  If a physical read is
  * required, prefetch as many more blocks as convenient into the cache.

minix/fs/ext2/super.c

@@ -65,9 +65,9 @@ static struct group_desc *ondisk_group_descs;
 
 /*===========================================================================*
  *                              read_super                                   *
+ *                              sp: pointer to superblock					 *
  *===========================================================================*/
-int read_super(sp)
+int read_super(register struct super_block *sp)
-register struct super_block *sp; /* pointer to a superblock */
 {
   /* Read a superblock. */
   dev_t dev;
@@ -216,10 +216,10 @@ register struct super_block *sp; /* pointer to a superblock */
 
 
 /*===========================================================================*
- *                              write_super				     *
+ *                              write_super									 *
+ *                              super_block: pointer to a superblock		 *
  *===========================================================================*/
-void write_super(sp)
+void write_super(struct super_block *sp)
-struct super_block *sp; /* pointer to a superblock */
 {
 /* Write a superblock and gdt. */
   int r;

minix/fs/ext2/utility.c

@@ -31,11 +31,11 @@ struct buf *get_block(dev_t dev, block_t block, int how)
 
 
 /*===========================================================================*
- *				conv2					     *
+ *				conv2														 *
+ *				norm: TRUE if no swap, FALSE for byte swap					 *
+ *				w: promotion of 16-bit word to be swapped					 *
  *===========================================================================*/
-unsigned conv2(norm, w)
+unsigned conv2(int norm, int w)
-int norm;			/* TRUE if no swap, FALSE for byte swap */
-int w;				/* promotion of 16-bit word to be swapped */
 {
 /* Possibly swap a 16-bit word between 8086 and 68000 byte order. */
   if (norm) return( (unsigned) w & 0xFFFF);
@@ -44,11 +44,11 @@ int w;				/* promotion of 16-bit word to be swapped */
 
 
 /*===========================================================================*
- *				conv4					     *
+ *				conv4														 *
+ *				norm: TRUE if no swap, FALSE for byte swap					 *
+ *				x: 32-bit long to be byte swapped							 *
  *===========================================================================*/
-long conv4(norm, x)
+long conv4(int norm, long x)
-int norm;			/* TRUE if no swap, FALSE for byte swap */
-long x;				/* 32-bit long to be byte swapped */
 {
 /* Possibly swap a 32-bit long between 8086 and 68000 byte order. */
   unsigned lo, hi;

minix/fs/ext2/write.c

@@ -22,13 +22,13 @@ static void wr_indir(struct buf *bp, int index, block_t block);
 static int empty_indir(struct buf *, struct super_block *);
 
 /*===========================================================================*
- *				write_map				     *
+ *				write_map													 *
+ *				rip: pointer to inode to be changed							 *
+ *				position: file address to be mapped							 *
+ *				new_wblock: block # to be inserted							 *
+ *				op: special actions											 *
  *===========================================================================*/
-int write_map(rip, position, new_wblock, op)
+int write_map(struct inode *rip, off_t position, block_t new_wblock, int op)
-struct inode *rip;		/* pointer to inode to be changed */
-off_t position;			/* file address to be mapped */
-block_t new_wblock;		/* block # to be inserted */
-int op;				/* special actions */
 {
 /* Write a new block into an inode.
  *
@@ -264,12 +264,12 @@ int op;				/* special actions */
 
 
 /*===========================================================================*
- *				wr_indir				     *
+ *				wr_indir													 *
+ *				bp: pointer to indirect block								 *
+ *				wrindex: index into *bp										 *
+ *				block: block to write										 *
  *===========================================================================*/
-static void wr_indir(bp, wrindex, block)
+static void wr_indir(struct buf *bp, int wrindex, block_t block)
-struct buf *bp;			/* pointer to indirect block */
-int wrindex;			/* index into *bp */
-block_t block;			/* block to write */
 {
 /* Given a pointer to an indirect block, write one entry. */
 
@@ -283,10 +283,10 @@ block_t block;			/* block to write */
 
 /*===========================================================================*
  *				empty_indir				     *
+ *				bp: pointer to indirect block
+ *				sb: superblock of device block resides on
  *===========================================================================*/
-static int empty_indir(bp, sb)
+static int empty_indir(struct buf *bp, struct super_block *sb)
-struct buf *bp;			/* pointer to indirect block */
-struct super_block *sb;		/* superblock of device block resides on */
 {
 /* Return nonzero if the indirect block pointed to by bp contains
  * only NO_BLOCK entries.
@@ -300,11 +300,11 @@ struct super_block *sb;		/* superblock of device block resides on */
 }
 
 /*===========================================================================*
- *				new_block				     *
+ *				new_block													 *
+ *				rip: pointer to inode										 *
+ *				position: file pointer										 *
  *===========================================================================*/
-struct buf *new_block(rip, position)
+struct buf *new_block(register struct inode *rip, off_t position)
-register struct inode *rip;	/* pointer to inode */
-off_t position;			/* file pointer */
 {
 /* Acquire a new block and return a pointer to it. */
   struct buf *bp;
@@ -364,10 +364,10 @@ off_t position;			/* file pointer */
 }
 
 /*===========================================================================*
- *				zero_block				     *
+ *				zero_block													 *
+ *				pointer to buffer to zero									 *
  *===========================================================================*/
-void zero_block(bp)
+void zero_block(register struct buf *bp)
-register struct buf *bp;	/* pointer to buffer to zero */
 {
 /* Zero a block. */
   ASSERT(bp->data);

minix/fs/mfs/inode.c

@@ -67,7 +67,7 @@ int fs_putnode(ino_t ino_nr, unsigned int count)
 /*===========================================================================*
  *				init_inode_cache			     *
  *===========================================================================*/
-void init_inode_cache()
+void init_inode_cache(void)
 {
   struct inode *rip;
   struct inodelist *rlp;
@@ -203,8 +203,9 @@ struct inode *find_inode(
 /*===========================================================================*
  *				put_inode				     *
  *===========================================================================*/
-void put_inode(rip)
+void put_inode(
-register struct inode *rip;	/* pointer to inode to be released */
+  register struct inode *rip	/* pointer to inode to be released */
+)
 {
 /* The caller is no longer using this inode.  If no one else is using it either
  * write it back to the disk immediately.  If it has no links, truncate it and
@@ -306,8 +307,9 @@ struct inode *alloc_inode(dev_t dev, mode_t bits, uid_t uid, gid_t gid)
 /*===========================================================================*
  *				wipe_inode				     *
  *===========================================================================*/
-static void wipe_inode(rip)
+static void wipe_inode(
-register struct inode *rip;	/* the inode to be erased */
+  register struct inode *rip	/* the inode to be erased */
+)
 {
 /* Erase some fields in the inode.  This function is called from alloc_inode()
  * when a new inode is to be allocated, and from truncate(), when an existing
@@ -346,8 +348,9 @@ static void free_inode(
 /*===========================================================================*
  *				update_times				     *
  *===========================================================================*/
-void update_times(rip)
+void update_times(
-register struct inode *rip;	/* pointer to inode to be read/written */
+  register struct inode *rip	/* pointer to inode to be read/written */
+)
 {
 /* Various system calls are required by the standard to update atime, ctime,
  * or mtime.  Since updating a time requires sending a message to the clock
@@ -372,9 +375,10 @@ register struct inode *rip;	/* pointer to inode to be read/written */
 /*===========================================================================*
  *				rw_inode				     *
  *===========================================================================*/
-void rw_inode(rip, rw_flag)
+void rw_inode(
-register struct inode *rip;	/* pointer to inode to be read/written */
+  register struct inode *rip,	/* pointer to inode to be read/written */
-int rw_flag;			/* READING or WRITING */
+  int rw_flag			/* READING or WRITING */
+)
 {
 /* An entry in the inode table is to be copied to or from the disk. */
 
@@ -411,11 +415,12 @@ int rw_flag;			/* READING or WRITING */
 /*===========================================================================*
  *				new_icopy				     *
  *===========================================================================*/
-static void new_icopy(rip, dip, direction, norm)
+static void new_icopy(
-register struct inode *rip;	/* pointer to the in-core inode struct */
+  register struct inode *rip,	/* pointer to the in-core inode struct */
-register d2_inode *dip;	/* pointer to the d2_inode struct */
+  register d2_inode *dip,	/* pointer to the d2_inode struct */
-int direction;			/* READING (from disk) or WRITING (to disk) */
+  int direction,			/* READING (from disk) or WRITING (to disk) */
-int norm;			/* TRUE = do not swap bytes; FALSE = swap */
+  int norm			/* TRUE = do not swap bytes; FALSE = swap */
+)
 {
   int i;
 
@@ -452,8 +457,9 @@ int norm;			/* TRUE = do not swap bytes; FALSE = swap */
 /*===========================================================================*
  *				dup_inode				     *
  *===========================================================================*/
-void dup_inode(ip)
+void dup_inode(
-struct inode *ip;		/* The inode to be duplicated. */
+  struct inode *ip		/* The inode to be duplicated. */
+)
 {
 /* This routine is a simplified form of get_inode() for the case where
  * the inode pointer is already known.

minix/fs/mfs/link.c

@@ -181,10 +181,11 @@ ssize_t fs_rdlink(ino_t ino_nr, struct fsdriver_data *data, size_t bytes)
 /*===========================================================================*
  *				remove_dir				     *
  *===========================================================================*/
-static int remove_dir(rldirp, rip, dir_name)
+static int remove_dir(
-struct inode *rldirp;		 	/* parent directory */
+  struct inode *rldirp,		 	/* parent directory */
-struct inode *rip;			/* directory to be removed */
+  struct inode *rip,			/* directory to be removed */
-char dir_name[MFS_NAME_MAX];		/* name of directory to be removed */
+  char dir_name[MFS_NAME_MAX]		/* name of directory to be removed */
+)
 {
   /* A directory file has to be removed. Five conditions have to met:
    * 	- The file must be a directory
@@ -216,10 +217,11 @@ char dir_name[MFS_NAME_MAX];		/* name of directory to be removed */
 /*===========================================================================*
  *				unlink_file				     *
  *===========================================================================*/
-static int unlink_file(dirp, rip, file_name)
+static int unlink_file(
-struct inode *dirp;		/* parent directory of file */
+  struct inode *dirp,		/* parent directory of file */
-struct inode *rip;		/* inode of file, may be NULL too. */
+  struct inode *rip,		/* inode of file, may be NULL too. */
-char file_name[MFS_NAME_MAX];	/* name of file to be removed */
+  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. */
 
@@ -449,9 +451,10 @@ int fs_trunc(ino_t ino_nr, off_t start, off_t end)
 /*===========================================================================*
  *				truncate_inode				     *
  *===========================================================================*/
-int truncate_inode(rip, newsize)
+int truncate_inode(
-register struct inode *rip;	/* pointer to inode to be truncated */
+  register struct inode *rip,	/* pointer to inode to be truncated */
-off_t newsize;			/* inode must become this size */
+  off_t newsize			/* inode must become this size */
+)
 {
 /* Set inode to a certain size, freeing any zones no longer referenced
  * and updating the size in the inode. If the inode is extended, the
@@ -491,9 +494,11 @@ off_t newsize;			/* inode must become this size */
 /*===========================================================================*
  *				freesp_inode				     *
  *===========================================================================*/
-static int freesp_inode(rip, start, end)
+static int freesp_inode(
-register struct inode *rip;	/* pointer to inode to be partly freed */
+  register struct inode *rip,	/* pointer to inode to be partly freed */
-off_t start, end;		/* range of bytes to free (end uninclusive) */
+  off_t start,
+  off_t end		/* range of bytes to free (end uninclusive) */
+)
 {
 /* Cut an arbitrary hole in an inode. The caller is responsible for checking
  * the reasonableness of the inode type of rip. The reason is this is that
@@ -555,9 +560,7 @@ off_t start, end;		/* range of bytes to free (end uninclusive) */
 /*===========================================================================*
  *				nextblock				     *
  *===========================================================================*/
-static off_t nextblock(pos, zone_size)
+static off_t nextblock(off_t pos, int zone_size)
-off_t pos;
-int zone_size;
 {
 /* Return the first position in the next block after position 'pos'
  * (unless this is the first position in the current block).
@@ -573,11 +576,8 @@ int zone_size;
 /*===========================================================================*
  *				zerozone_half				     *
  *===========================================================================*/
-static void zerozone_half(rip, pos, half, zone_size)
+static void zerozone_half(struct inode *rip, off_t pos, int half,
-struct inode *rip;
+						  int zone_size)
-off_t pos;
-int half;
-int zone_size;
 {
 /* Zero the upper or lower 'half' of a zone that holds position 'pos'.
  * half can be FIRST_HALF or LAST_HALF.
@@ -604,10 +604,7 @@ int zone_size;
 /*===========================================================================*
  *				zerozone_range				     *
  *===========================================================================*/
-static void zerozone_range(rip, pos, len)
+static void zerozone_range(struct inode *rip, off_t pos, off_t len)
-struct inode *rip;
-off_t pos;
-off_t len;
 {
 /* Zero an arbitrary byte range in a zone, possibly spanning multiple blocks.
  */

minix/fs/mfs/main.c

@@ -28,7 +28,7 @@ int main(int argc, char *argv[])
 /*===========================================================================*
  *			       sef_local_startup			     *
  *===========================================================================*/
-static void sef_local_startup()
+static void sef_local_startup(void)
 {
   /* Register init callbacks. */
   sef_setcb_init_fresh(sef_cb_init_fresh);

minix/fs/mfs/path.c

@@ -45,9 +45,10 @@ int fs_lookup(ino_t dir_nr, char *name, struct fsdriver_node *node,
 /*===========================================================================*
  *				advance					     *
  *===========================================================================*/
-struct inode *advance(dirp, string)
+struct inode *advance(
-struct inode *dirp;		/* inode for directory to be searched */
+  struct inode *dirp,		/* inode for directory to be searched */
-const char *string;		/* component name to look for */
+  const char *string		/* component name to look for */
+)
 {
 /* Given a directory and a component of a path, look up the component in
  * the directory, find the inode, open it, and return a pointer to its inode
@@ -89,11 +90,12 @@ const char *string;		/* component name to look for */
 /*===========================================================================*
  *				search_dir				     *
  *===========================================================================*/
-int search_dir(ldir_ptr, string, numb, flag)
+int search_dir(
-register struct inode *ldir_ptr; /* ptr to inode for dir to search */
+  register struct inode *ldir_ptr, /* ptr to inode for dir to search */
-const char *string;		 /* component to search for */
+  const char *string,		 /* component to search for */
-ino_t *numb;			 /* pointer to inode number */
+  ino_t *numb,			 /* pointer to inode number */
-int flag;			 /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
+  int flag			 /* LOOK_UP, ENTER, DELETE or IS_EMPTY */
+)
 {
 /* This function searches the directory whose inode is pointed to by 'ldip':
  * if (flag == ENTER)  enter 'string' in the directory with inode # '*numb';

minix/fs/mfs/read.c

@@ -114,18 +114,18 @@ ssize_t fs_readwrite(ino_t ino_nr, struct fsdriver_data *data, size_t nrbytes,
 /*===========================================================================*
  *				rw_chunk				     *
  *===========================================================================*/
-static int rw_chunk(rip, position, off, chunk, left, call, data, buf_off,
+static int rw_chunk(
-	block_size, completed)
+  register struct inode *rip,	/* pointer to inode for file to be rd/wr */
-register struct inode *rip;	/* pointer to inode for file to be rd/wr */
+  u64_t position,			/* position within file to read or write */
-u64_t position;			/* position within file to read or write */
+  unsigned off,			/* off within the current block */
-unsigned off;			/* off within the current block */
+  size_t chunk,			/* number of bytes to read or write */
-size_t chunk;			/* number of bytes to read or write */
+  unsigned left,			/* max number of bytes wanted after position */
-unsigned left;			/* max number of bytes wanted after position */
+  int call,			/* FSC_READ, FSC_WRITE, or FSC_PEEK */
-int call;			/* FSC_READ, FSC_WRITE, or FSC_PEEK */
+  struct fsdriver_data *data,	/* structure for (remote) user buffer */
-struct fsdriver_data *data;	/* structure for (remote) user buffer */
+  unsigned buf_off,		/* offset in user buffer */
-unsigned buf_off;		/* offset in user buffer */
+  unsigned int block_size,	/* block size of FS operating on */
-unsigned int block_size;	/* block size of FS operating on */
+  int *completed			/* number of bytes copied */
-int *completed;			/* number of bytes copied */
+)
 {
 /* Read or write (part of) a block. */
   struct buf *bp = NULL;
@@ -207,10 +207,11 @@ int *completed;			/* number of bytes copied */
 /*===========================================================================*
  *				read_map				     *
  *===========================================================================*/
-block_t read_map(rip, position, opportunistic)
+block_t read_map(
-register struct inode *rip;	/* ptr to inode to map from */
+  register struct inode *rip,	/* ptr to inode to map from */
-off_t position;			/* position in file whose blk wanted */
+  off_t position,			/* position in file whose blk wanted */
-int opportunistic;		/* if nonzero, only use cache for metadata */
+  int opportunistic		/* if nonzero, only use cache for metadata */
+)
 {
 /* Given an inode and a position within the corresponding file, locate the
  * block (not zone) number in which that position is to be found and return it.
@@ -298,9 +299,10 @@ struct buf *get_block_map(register struct inode *rip, u64_t position)
 /*===========================================================================*
  *				rd_indir				     *
  *===========================================================================*/
-zone_t rd_indir(bp, index)
+zone_t rd_indir(
-struct buf *bp;			/* pointer to indirect block */
+  struct buf *bp,			/* pointer to indirect block */
-int index;			/* index into *bp */
+  int index					/* index into *bp */
+)
 {
   struct super_block *sp;
   zone_t zone;
@@ -327,11 +329,12 @@ int index;			/* index into *bp */
 /*===========================================================================*
  *				rahead					     *
  *===========================================================================*/
-static struct buf *rahead(rip, baseblock, position, bytes_ahead)
+static struct buf *rahead(
-register struct inode *rip;	/* pointer to inode for file to be read */
+  register struct inode *rip,	/* pointer to inode for file to be read */
-block_t baseblock;		/* block at current position */
+  block_t baseblock,		/* block at current position */
-u64_t position;			/* position within file */
+  u64_t position,			/* position within file */
-unsigned bytes_ahead;		/* bytes beyond position for immediate use */
+  unsigned bytes_ahead		/* bytes beyond position for immediate use */
+)
 {
 /* Fetch a block from the cache or the device.  If a physical read is
  * required, prefetch as many more blocks as convenient into the cache.

minix/fs/mfs/stats.c

@@ -11,9 +11,10 @@
 /*===========================================================================*
  *				count_free_bits				     *
  *===========================================================================*/
-bit_t count_free_bits(sp, map)
+bit_t count_free_bits(
-struct super_block *sp;		/* the filesystem to allocate from */
+  struct super_block *sp,		/* the filesystem to allocate from */
-int map;			/* IMAP (inode map) or ZMAP (zone map) */
+  int map			/* IMAP (inode map) or ZMAP (zone map) */
+)
 {
 /* Allocate a bit from a bit map and return its bit number. */
   block_t start_block;		/* first bit block */

minix/fs/mfs/super.c

@@ -26,10 +26,11 @@
 /*===========================================================================*
  *				alloc_bit				     *
  *===========================================================================*/
-bit_t alloc_bit(sp, map, origin)
+bit_t alloc_bit(
-struct super_block *sp;		/* the filesystem to allocate from */
+  struct super_block *sp,		/* the filesystem to allocate from */
-int map;			/* IMAP (inode map) or ZMAP (zone map) */
+  int map,			/* IMAP (inode map) or ZMAP (zone map) */
-bit_t origin;			/* number of bit to start searching at */
+  bit_t origin			/* number of bit to start searching at */
+)
 {
 /* Allocate a bit from a bit map and return its bit number. */
 
@@ -108,10 +109,11 @@ bit_t origin;			/* number of bit to start searching at */
 /*===========================================================================*
  *				free_bit				     *
  *===========================================================================*/
-void free_bit(sp, map, bit_returned)
+void free_bit(
-struct super_block *sp;		/* the filesystem to operate on */
+  struct super_block *sp,	/* the filesystem to operate on */
-int map;			/* IMAP (inode map) or ZMAP (zone map) */
+  int map,					/* IMAP (inode map) or ZMAP (zone map) */
-bit_t bit_returned;		/* number of bit to insert into the map */
+  bit_t bit_returned		/* number of bit to insert into the map */
+)
 {
 /* Return a zone or inode by turning off its bitmap bit. */
 

minix/fs/mfs/utility.c

@@ -7,9 +7,10 @@
 /*===========================================================================*
  *				conv2					     *
  *===========================================================================*/
-unsigned conv2(norm, w)
+unsigned conv2(
-int norm;			/* TRUE if no swap, FALSE for byte swap */
+  int norm,			/* TRUE if no swap, FALSE for byte swap */
-int w;				/* promotion of 16-bit word to be swapped */
+  int w				/* promotion of 16-bit word to be swapped */
+)
 {
 /* Possibly swap a 16-bit word between 8086 and 68000 byte order. */
   if (norm) return( (unsigned) w & 0xFFFF);
@@ -20,9 +21,10 @@ int w;				/* promotion of 16-bit word to be swapped */
 /*===========================================================================*
  *				conv4					     *
  *===========================================================================*/
-long conv4(norm, x)
+long conv4(
-int norm;			/* TRUE if no swap, FALSE for byte swap */
+  int norm,			/* TRUE if no swap, FALSE for byte swap */
-long x;				/* 32-bit long to be byte swapped */
+  long x				/* 32-bit long to be byte swapped */
+)
 {
 /* Possibly swap a 32-bit long between 8086 and 68000 byte order. */
   unsigned lo, hi;

minix/fs/mfs/write.c

@@ -25,11 +25,12 @@ static int empty_indir(struct buf *, struct super_block *);
 /*===========================================================================*
  *				write_map				     *
  *===========================================================================*/
-int write_map(rip, position, new_zone, op)
+int write_map(
-struct inode *rip;		/* pointer to inode to be changed */
+  struct inode *rip,		/* pointer to inode to be changed */
-off_t position;			/* file address to be mapped */
+  off_t position,			/* file address to be mapped */
-zone_t new_zone;		/* zone # to be inserted */
+  zone_t new_zone,		/* zone # to be inserted */
-int op;				/* special actions */
+  int op				/* special actions */
+)
 {
 /* Write a new zone into an inode.
  *
@@ -188,10 +189,11 @@ int op;				/* special actions */
 /*===========================================================================*
  *				wr_indir				     *
  *===========================================================================*/
-static void wr_indir(bp, index, zone)
+static void wr_indir(
-struct buf *bp;			/* pointer to indirect block */
+  struct buf *bp,			/* pointer to indirect block */
-int index;			/* index into *bp */
+  int index,			/* index into *bp */
-zone_t zone;			/* zone to write */
+  zone_t zone			/* zone to write */
+)
 {
 /* Given a pointer to an indirect block, write one entry. */
 
@@ -211,9 +213,10 @@ zone_t zone;			/* zone to write */
 /*===========================================================================*
  *				empty_indir				     *
  *===========================================================================*/
-static int empty_indir(bp, sb)
+static int empty_indir(
-struct buf *bp;			/* pointer to indirect block */
+  struct buf *bp,			/* pointer to indirect block */
-struct super_block *sb;		/* superblock of device block resides on */
+  struct super_block *sb		/* superblock of device block resides on */
+)
 {
 /* Return nonzero if the indirect block pointed to by bp contains
  * only NO_ZONE entries.
@@ -230,10 +233,11 @@ struct super_block *sb;		/* superblock of device block resides on */
 /*===========================================================================*
  *				clear_zone				     *
  *===========================================================================*/
-void clear_zone(rip, pos, flag)
+void clear_zone(
-register struct inode *rip;	/* inode to clear */
+  register struct inode *rip,	/* inode to clear */
-off_t __unused pos;		/* points to block to clear */
+  off_t __unused pos,		/* points to block to clear */
-int __unused flag;		/* 1 if called by new_block, 0 otherwise */
+  int __unused flag		/* 1 if called by new_block, 0 otherwise */
+)
 {
 /* Zero a zone, possibly starting in the middle.  The parameter 'pos' gives
  * a byte in the first block to be zeroed.  Clearzone() is called from 
@@ -251,9 +255,10 @@ int __unused flag;		/* 1 if called by new_block, 0 otherwise */
 /*===========================================================================*
  *				new_block				     *
  *===========================================================================*/
-struct buf *new_block(rip, position)
+struct buf *new_block(
-register struct inode *rip;	/* pointer to inode */
+  register struct inode *rip,	/* pointer to inode */
-off_t position;			/* file pointer */
+  off_t position			/* file pointer */
+)
 {
 /* Acquire a new block and return a pointer to it.  Doing so may require
  * allocating a complete zone, and then returning the initial block.
@@ -308,8 +313,9 @@ off_t position;			/* file pointer */
 /*===========================================================================*
  *				zero_block				     *
  *===========================================================================*/
-void zero_block(bp)
+void zero_block(
-register struct buf *bp;	/* pointer to buffer to zero */
+  register struct buf *bp	/* pointer to buffer to zero */
+)
 {
 /* Zero a block. */
   ASSERT(bp->data);