diff mbox series

[3/7] lib: Fix non-ANSI function declarations

Message ID 20250206212145.7732-4-sandeen@redhat.com (mailing list archive)
State New
Headers show
Series fstests: enable sparse checking & fix fallout | expand

Commit Message

Eric Sandeen Feb. 6, 2025, 9:19 p.m. UTC
lib/ was full of non-ANSI function declarations, fix them to make
sparse happier.

Signed-off-by: Eric Sandeen <sandeen@redhat.com>
---
 lib/dataascii.c    | 59 +++++++++++++++++++++-----------------------
 lib/databin.c      | 28 ++++++++++-----------
 lib/datapid.c      | 32 +++++++++---------------
 lib/file_lock.c    | 12 ++-------
 lib/forker.c       | 19 ++++++---------
 lib/pattern.c      | 14 ++---------
 lib/random_range.c | 61 ++++++++++++++--------------------------------
 lib/str_to_bytes.c |  9 +++----
 lib/tlibio.c       | 50 ++++++++++++++++++-------------------
 lib/write_log.c    | 32 ++++++++----------------
 10 files changed, 119 insertions(+), 197 deletions(-)

Comments

Darrick J. Wong Feb. 6, 2025, 10:39 p.m. UTC | #1
On Thu, Feb 06, 2025 at 03:19:58PM -0600, Eric Sandeen wrote:
> lib/ was full of non-ANSI function declarations, fix them to make
> sparse happier.
> 
> Signed-off-by: Eric Sandeen <sandeen@redhat.com>

K&R, you mean?

"databingen", hah.

Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>

--D

> ---
>  lib/dataascii.c    | 59 +++++++++++++++++++++-----------------------
>  lib/databin.c      | 28 ++++++++++-----------
>  lib/datapid.c      | 32 +++++++++---------------
>  lib/file_lock.c    | 12 ++-------
>  lib/forker.c       | 19 ++++++---------
>  lib/pattern.c      | 14 ++---------
>  lib/random_range.c | 61 ++++++++++++++--------------------------------
>  lib/str_to_bytes.c |  9 +++----
>  lib/tlibio.c       | 50 ++++++++++++++++++-------------------
>  lib/write_log.c    | 32 ++++++++----------------
>  10 files changed, 119 insertions(+), 197 deletions(-)
> 
> diff --git a/lib/dataascii.c b/lib/dataascii.c
> index e2509f8d..d11609ee 100644
> --- a/lib/dataascii.c
> +++ b/lib/dataascii.c
> @@ -17,18 +17,18 @@
>  static char Errmsg[80];
>  
>  int
> -dataasciigen(listofchars, buffer, bsize, offset)
> -char *listofchars;	/* a null terminated list of characters */
> -char *buffer;
> -int bsize;
> -int offset;
> +dataasciigen(
> +	char *listofchars,	/* a null terminated list of characters */
> +	char *buffer,
> +	int bsize,
> +	int offset)
>  {
> -   int cnt;
> -   int total;
> -   int ind;	/* index into CHARS array */
> -   char *chr;
> -   int chars_size;
> -   char *charlist;
> +	int cnt;
> +	int total;
> +	int ind;	/* index into CHARS array */
> +	char *chr;
> +	int chars_size;
> +	char *charlist;
>  
>  	chr=buffer;
>  	total=offset+bsize;
> @@ -52,19 +52,19 @@ int offset;
>  }	/* end of dataasciigen */
>  
>  int
> -dataasciichk(listofchars, buffer, bsize, offset, errmsg)
> -char *listofchars;	/* a null terminated list of characters */
> -char *buffer;
> -int bsize;
> -int offset;
> -char **errmsg;
> +dataasciichk(
> +	char *listofchars,	/* a null terminated list of characters */
> +	char *buffer,
> +	int bsize,
> +	int offset,
> +	char **errmsg)
>  {
> -   int cnt;
> -   int total;
> -   int ind;	/* index into CHARS array */
> -   char *chr;
> -   int chars_size;
> -   char *charlist;
> +	int cnt;
> +	int total;
> +	int ind;	/* index into CHARS array */
> +	char *chr;
> +	int chars_size;
> +	char *charlist;
>  
>  	chr=buffer;
>  	total=offset+bsize;
> @@ -104,15 +104,12 @@ char **errmsg;
>   * main for doing unit testing
>   ***********************************************************************/
>  int
> -main(ac, ag)
> -int ac;
> -char **ag;
> +main(int ac, char **ag)
>  {
> -
> -int size=1023;
> -char *buffer;
> -int ret;
> -char *errmsg;
> +    int size=1023;
> +    char *buffer;
> +    int ret;
> +    char *errmsg;
>  
>      if ((buffer=(char *)malloc(size)) == NULL ) {
>          perror("malloc");
> diff --git a/lib/databin.c b/lib/databin.c
> index 8a36dff3..000d0d1a 100644
> --- a/lib/databin.c
> +++ b/lib/databin.c
> @@ -16,13 +16,13 @@
>  static char Errmsg[80];
>  
>  void
> -databingen (mode, buffer, bsize, offset)
> -int mode;	/* either a, c, r, o, z or C */
> -unsigned char *buffer;	/* buffer pointer */
> -int bsize;	/* size of buffer */
> -int offset;	/* offset into the file where buffer starts */
> +databingen(
> +	int mode,	/* either a, c, r, o, z or C */
> +	unsigned char *buffer,	/* buffer pointer */
> +	int bsize,	/* size of buffer */
> +	int offset)	/* offset into the file where buffer starts */
>  {
> -int ind;
> +	int ind;
>  
>          switch (mode)
>          {
> @@ -63,12 +63,12 @@ int ind;
>   *      < 0  : no error
>   ***********************************************************************/
>  int
> -databinchk(mode, buffer, bsize, offset, errmsg)
> -int mode;	/* either a, c, r, z, o, or C */
> -unsigned char *buffer;	/* buffer pointer */
> -int bsize;	/* size of buffer */
> -int offset;	/* offset into the file where buffer starts */
> -char **errmsg;
> +databinchk(
> +	int mode,	/* either a, c, r, z, o, or C */
> +	unsigned char *buffer,	/* buffer pointer */
> +	int bsize,	/* size of buffer */
> +	int offset,	/* offset into the file where buffer starts */
> +	char **errmsg)
>  {
>  	int cnt;
>  	unsigned char *chr;
> @@ -138,9 +138,7 @@ char **errmsg;
>   * main for doing unit testing
>   ***********************************************************************/
>  int
> -main(ac, ag)
> -int ac;
> -char **ag;
> +main(int ac, char **ag)
>  {
>  
>      int size=1023;
> diff --git a/lib/datapid.c b/lib/datapid.c
> index 15af8871..6786323d 100644
> --- a/lib/datapid.c
> +++ b/lib/datapid.c
> @@ -57,15 +57,13 @@ static char Errmsg[80];
>   * Thus, offset 8 is in middle of word 1
>   ***********************************************************************/
>  int
> -datapidgen(pid, buffer, bsize, offset)
> -int pid;
> -char *buffer;
> -int bsize;
> -int offset;
> +datapidgen(
> +	int pid,
> +	char *buffer,
> +	int bsize,
> +	int offset)
>  {
>  	return -1;	/* not support on non-64 bits word machines  */
> -
> -
>  } 
>  
>  /***********************************************************************
> @@ -73,12 +71,7 @@ int offset;
>   *
>   ***********************************************************************/
>  int
> -datapidchk(pid, buffer, bsize, offset, errmsg)
> -int pid;
> -char *buffer;
> -int bsize;
> -int offset;
> -char **errmsg;
> +datapidchk(int pid, char *buffer, int bsize, int offset, char **errmsg)
>  {
>      if ( errmsg != NULL ) {
>          *errmsg = Errmsg;
> @@ -94,15 +87,12 @@ char **errmsg;
>   * main for doing unit testing
>   ***********************************************************************/
>  int
> -main(ac, ag)
> -int ac;
> -char **ag;
> +main( int ac, char **ag)
>  {
> -
> -int size=1234;
> -char *buffer;
> -int ret;
> -char *errmsg;
> +    int size=1234;
> +    char *buffer;
> +    int ret;
> +    char *errmsg;
>  
>      if ((buffer=(char *)malloc(size)) == NULL ) {
>          perror("malloc");
> diff --git a/lib/file_lock.c b/lib/file_lock.c
> index f0791489..6d87e281 100644
> --- a/lib/file_lock.c
> +++ b/lib/file_lock.c
> @@ -34,10 +34,7 @@ static char errmsg[256];
>   * It will loop if the LOCK_NB flags is NOT set.
>   ***********************************************************************/
>  int
> -file_lock(fd, flags, errormsg)
> -int fd;
> -int flags;
> -char **errormsg;
> +file_lock(int fd, int flags, char **errormsg)
>  {
>          register int cmd, ret;
>          struct flock flocks;
> @@ -109,12 +106,7 @@ char **errormsg;
>   * It will loop if the LOCK_NB flags is NOT set.
>   ***********************************************************************/
>  int
> -record_lock(fd, flags, start, len, errormsg)
> -int fd;
> -int flags;
> -int start;
> -int len;
> -char **errormsg;
> +record_lock(int fd, int flags, int start, int len, char **errormsg)
>  {
>          register int cmd, ret;
>          struct flock flocks;
> diff --git a/lib/forker.c b/lib/forker.c
> index 63d8fcdb..10920ddb 100644
> --- a/lib/forker.c
> +++ b/lib/forker.c
> @@ -105,8 +105,7 @@ int Forker_npids=0;             /* number of entries in Forker_pids */
>   *  !0 : if fork failed, the return value will be the errno.
>   ***********************************************************************/
>  int
> -background(prefix)
> -char *prefix;
> +background(char *prefix)
>  {
>    switch (fork()) {
>    case -1:
> @@ -131,12 +130,12 @@ char *prefix;
>   * 
>   ***********************************************************************/
>  int
> -forker(ncopies, mode, prefix)
> -int ncopies;
> -int mode;	/* 0 - all childern of parent, 1 - only 1 direct child */
> -char *prefix;   /* if ! NULL, an message will be printed to stderr */
> -		/* if fork fails.  The prefix (program name) will */
> -	        /* preceed the message */
> +forker(
> +    int ncopies,
> +    int mode,		/* 0: all childern of parent, 1: only 1 direct child */
> +    char *prefix)   	/* if ! NULL, an message will be printed to stderr */
> +			/* if fork fails.  The prefix (program name) will */
> +			/* preceed the message */
>  {
>      int cnt;
>      int pid;
> @@ -210,9 +209,7 @@ char *prefix;   /* if ! NULL, an message will be printed to stderr */
>   */
>  
>  int
> -main(argc, argv)
> -int argc;
> -char **argv;
> +main(int argc, char **argv)
>  {
>      int ncopies=1;
>      int mode=0;
> diff --git a/lib/pattern.c b/lib/pattern.c
> index d622b935..20bbdc97 100644
> --- a/lib/pattern.c
> +++ b/lib/pattern.c
> @@ -12,12 +12,7 @@
>   */
>  
>  int
> -pattern_check(buf, buflen, pat, patlen, patshift)
> -char	*buf;
> -int	buflen;
> -char	*pat;
> -int	patlen;
> -int	patshift;
> +pattern_check(char *buf, int buflen, char *pat, int patlen, int patshift)
>  {
>      int		nb, ncmp, nleft;
>      char	*cp;
> @@ -79,12 +74,7 @@ int	patshift;
>  }
>  
>  int
> -pattern_fill(buf, buflen, pat, patlen, patshift)
> -char	*buf;
> -int	buflen;
> -char	*pat;
> -int	patlen;
> -int	patshift;
> +pattern_fill(char *buf, int buflen, char *pat, int patlen, int patshift)
>  {
>      int		trans, ncopied, nleft;
>      char	*cp;
> diff --git a/lib/random_range.c b/lib/random_range.c
> index 3fa01f0d..680bf71c 100644
> --- a/lib/random_range.c
> +++ b/lib/random_range.c
> @@ -73,14 +73,14 @@ static int       str_to_int();
>  static long long divider(long long, long long, long long, long long);
>  
>  int
> -parse_ranges(str, defmin, defmax, defmult, parse_func, rangeptr, errptr)
> -char	*str;
> -int	defmin;
> -int	defmax;
> -int	defmult;
> -int	(*parse_func)();
> -char	**rangeptr;
> -char	**errptr;
> +parse_ranges(
> +	char *str,
> +	int defmin,
> +	int defmax,
> +	int defmult,
> +	int (*parse_func)(),
> +	char **rangeptr,
> +	char **errptr)
>  {
>  	int		ncommas;
>  	char		*tmpstr, *cp, *tok, *n1str, *n2str, *multstr;
> @@ -194,9 +194,7 @@ char	**errptr;
>   */
>  
>  static int
> -str_to_int(str, ip)
> -char	*str;
> -int	*ip;
> +str_to_int(char *str, int *ip)
>  {
>  	char	c;
>  
> @@ -214,25 +212,19 @@ int	*ip;
>   */
>  
>  int
> -range_min(rbuf, r)
> -char	*rbuf;
> -int	r;
> +range_min(char *rbuf, int r)
>  {
>  	return ((struct range *)rbuf)[r].min;
>  }
>  
>  int
> -range_max(rbuf, r)
> -char	*rbuf;
> -int	r;
> +range_max(char *rbuf, int r)
>  {
>  	return ((struct range *)rbuf)[r].max;
>  }
>  
>  int
> -range_mult(rbuf, r)
> -char	*rbuf;
> -int	r;
> +range_mult(char *rbuf, int r)
>  {
>  	return ((struct range *)rbuf)[r].mult;
>  }
> @@ -263,11 +255,7 @@ int	r;
>   *****************************************************************************/
>  
>  long
> -random_range(min, max, mult, errp)
> -int	min;
> -int	max;
> -int	mult;
> -char	**errp;
> +random_range(int min, int max, int mult, char **errp)
>  {
>  	int     	r, nmults, orig_min, orig_max, orig_mult, tmp;
>  	extern long	lrand48();
> @@ -333,11 +321,7 @@ char	**errp;
>   * Just like random_range, but all values are longs.
>   */
>  long
> -random_rangel(min, max, mult, errp)
> -long	min;
> -long	max;
> -long	mult;
> -char	**errp;
> +random_range1(long min, long max, long mult, char **errp)
>  {
>  	long     	r, nmults, orig_min, orig_max, orig_mult, tmp;
>  	extern long	lrand48();
> @@ -424,11 +408,7 @@ char	**errp;
>   *  Attempts to be just like random_range, but everything is long long (64 bit)
>   */
>  long long
> -random_rangell(min, max, mult, errp)
> -long long	min;
> -long long	max;
> -long long	mult;
> -char		**errp;
> +random_rangell(long long min, long long max, long long mult, char **errp)
>  {
>  	long long     	r, nmults, orig_min, orig_max, orig_mult, tmp;
>          long long	randnum;
> @@ -588,8 +568,7 @@ printf("   diff = %lld, half = %lld,   med = %lld\n", diff, half, med);
>   *****************************************************************************/
>  
>  void
> -random_range_seed(s)
> -long    s;
> +random_range_seed(long s)
>  {
>      extern void srand48();
>  
> @@ -652,9 +631,7 @@ random_bit(long mask)
>  /*
>   *  The following is a unit test main function for random_bit().
>   */
> -main(argc, argv)
> -int argc;
> -char **argv;
> +main(int argc, char **argv)
>  {
>      int ind;
>      int cnt, iter;
> @@ -695,9 +672,7 @@ char **argv;
>  #define MEG  1024*1024*1024
>  #define GIG 1073741824
>  int
> -main(argc, argv)
> -int argc;
> -char **argv;
> +main(int argc, char **argv)
>  {
>      int ind;
>      int cnt, iter=10;
> diff --git a/lib/str_to_bytes.c b/lib/str_to_bytes.c
> index 2f6b2b92..20cd2a0f 100644
> --- a/lib/str_to_bytes.c
> +++ b/lib/str_to_bytes.c
> @@ -42,8 +42,7 @@
>  #define T_MULT	1099511627776	/* tera or 2^40 */
>  
>  int
> -str_to_bytes(s)
> -char    *s;
> +str_to_bytes(char *s)
>  {
>      char    mult, junk;
>      int	    nconv;
> @@ -77,8 +76,7 @@ char    *s;
>  }
>  
>  long
> -str_to_lbytes(s)
> -char    *s;
> +str_to_lbytes(char *s)
>  {
>      char    mult, junk;
>      long    nconv;
> @@ -117,8 +115,7 @@ char    *s;
>   */
>  
>  long long
> -str_to_llbytes(s)
> -char    *s;
> +str_to_llbytes(char *s)
>  {
>      char    mult, junk;
>      long    nconv;
> diff --git a/lib/tlibio.c b/lib/tlibio.c
> index f7259734..3c23bf4d 100644
> --- a/lib/tlibio.c
> +++ b/lib/tlibio.c
> @@ -143,13 +143,13 @@ static int Debug_level = 0;
>   ***********************************************************************/
>  
>  int
> -stride_bounds(offset, stride, nstrides, bytes_per_stride, min, max)
> -int	offset;
> -int	stride;
> -int	nstrides;
> -int	bytes_per_stride;
> -int	*min;
> -int	*max;
> +stride_bounds(
> +	int offset,
> +	int stride,
> +	int nstrides,
> +	int bytes_per_stride,
> +	int *min,
> +	int *max)
>  {
>  	int	nbytes, min_byte, max_byte;
>  
> @@ -443,14 +443,14 @@ lio_random_methods(long curr_mask)
>   * (rrl 04/96)
>   ***********************************************************************/
>  int
> -lio_write_buffer(fd, method, buffer, size, sig, errmsg, wrd)
> -int fd;		/* open file descriptor */
> -int method;	/* contains io type and wait method bitmask */
> -char *buffer;	/* pointer to buffer */
> -int size;	/* the size of the io */
> -int sig;	/* signal to use if async io */
> -char **errmsg;	/* char pointer that will be updated to point to err message */
> -long wrd;	/* to allow future features, use zero for now */
> +lio_write_buffer(
> +    int fd,		/* open file descriptor */
> +    int method,		/* contains io type and wait method bitmask */
> +    char *buffer,	/* pointer to buffer */
> +    int size,		/* the size of the io */
> +    int sig,		/* signal to use if async io */
> +    char **errmsg,	/* char pointer that will be updated to point to err message */
> +    long wrd)		/* to allow future features, use zero for now */
>  {
>      int ret = 0;	/* syscall return or used to get random method */
>  #ifndef linux
> @@ -640,14 +640,14 @@ long wrd;	/* to allow future features, use zero for now */
>   * (rrl 04/96)
>   ***********************************************************************/
>  int
> -lio_read_buffer(fd, method, buffer, size, sig, errmsg, wrd)
> -int fd;		/* open file descriptor */
> -int method;	/* contains io type and wait method bitmask */
> -char *buffer;	/* pointer to buffer */
> -int size;	/* the size of the io */
> -int sig;	/* signal to use if async io */
> -char **errmsg;	/* char pointer that will be updated to point to err message */
> -long wrd;	/* to allow future features, use zero for now */
> +lio_read_buffer(
> +    int fd,		/* open file descriptor */
> +    int method,		/* contains io type and wait method bitmask */
> +    char *buffer,	/* pointer to buffer */
> +    int size,		/* the size of the io */
> +    int sig,		/* signal to use if async io */
> +    char **errmsg,	/* char pointer that will be updated to point to err message */
> +    long wrd)		/* to allow future features, use zero for now */
>  {
>      int ret = 0;	/* syscall return or used to get random method */
>  #ifndef linux
> @@ -1031,9 +1031,7 @@ struct unit_info_t {
>  };
>  
>  int
> -main(argc, argv)
> -int argc;
> -char **argv;
> +main(int argc, char **argv)
>  {
>      extern char *optarg;
>      extern int optind;
> diff --git a/lib/write_log.c b/lib/write_log.c
> index cdc72593..c82cc1f4 100644
> --- a/lib/write_log.c
> +++ b/lib/write_log.c
> @@ -87,10 +87,7 @@ static int	wlog_rec_unpack();
>   */
>  
>  int
> -wlog_open(wfile, trunc, mode)
> -struct wlog_file	*wfile;
> -int			trunc;
> -int			mode;
> +wlog_open(struct wlog_file *wfile, int trunc, int mode)
>  {
>  	int	omask, oflags;
>  
> @@ -138,8 +135,7 @@ int			mode;
>   */
>  
>  int
> -wlog_close(wfile)
> -struct wlog_file	*wfile;
> +wlog_close(struct wlog_file *wfile)
>  {
>  	close(wfile->w_afd);
>  	close(wfile->w_rfd);
> @@ -173,10 +169,7 @@ struct wlog_file	*wfile;
>   */
>  
>  int
> -wlog_record_write(wfile, wrec, offset)
> -struct wlog_file	*wfile;
> -struct wlog_rec		*wrec;
> -long			offset;
> +wlog_record_write(struct wlog_file *wfile, struct wlog_rec *wrec, long offset)
>  {
>      int		reclen;
>      char	wbuf[WLOG_REC_MAX_SIZE + 2];
> @@ -221,11 +214,11 @@ long			offset;
>   */
>  
>  int
> -wlog_scan_backward(wfile, nrecs, func, data)
> -struct wlog_file	*wfile;
> -int 			nrecs;
> -int 			(*func)();
> -long			data;
> +wlog_scan_backward(
> +	struct wlog_file	*wfile,
> +	int 			nrecs,
> +	int 			(*func)(),
> +	long			data)
>  {
>  	int			fd, leftover, nbytes, offset, recnum, reclen;
>  	char    		buf[BSIZE*32], *bufend, *cp, *bufstart;
> @@ -351,10 +344,7 @@ long			data;
>   */
>  
>  static int
> -wlog_rec_pack(wrec, buf, flag)
> -struct wlog_rec	*wrec;
> -char		*buf;
> -int             flag;
> +wlog_rec_pack(struct wlog_rec *wrec, char *buf, int flag)
>  {
>  	char			*file, *host, *pattern;
>  	struct wlog_rec_disk	*wrecd;
> @@ -400,9 +390,7 @@ int             flag;
>  }
>  
>  static int
> -wlog_rec_unpack(wrec, buf)
> -struct wlog_rec	*wrec;
> -char		*buf;
> +wlog_rec_unpack(struct wlog_rec *wrec, char *buf)
>  {
>  	char			*file, *host, *pattern;
>  	struct wlog_rec_disk	*wrecd;
> -- 
> 2.48.0
> 
>
Christoph Hellwig Feb. 7, 2025, 4:59 a.m. UTC | #2
On Thu, Feb 06, 2025 at 03:19:58PM -0600, Eric Sandeen wrote:
> lib/ was full of non-ANSI function declarations, fix them to make
> sparse happier.

Oh fun.  Great to get this fixed up.

The path also seems to have a few formatting fixups in the area,
but I'm not going to nitpick on this code..

Reviewed-by: Christoph Hellwig <hch@lst.de>
diff mbox series

Patch

diff --git a/lib/dataascii.c b/lib/dataascii.c
index e2509f8d..d11609ee 100644
--- a/lib/dataascii.c
+++ b/lib/dataascii.c
@@ -17,18 +17,18 @@ 
 static char Errmsg[80];
 
 int
-dataasciigen(listofchars, buffer, bsize, offset)
-char *listofchars;	/* a null terminated list of characters */
-char *buffer;
-int bsize;
-int offset;
+dataasciigen(
+	char *listofchars,	/* a null terminated list of characters */
+	char *buffer,
+	int bsize,
+	int offset)
 {
-   int cnt;
-   int total;
-   int ind;	/* index into CHARS array */
-   char *chr;
-   int chars_size;
-   char *charlist;
+	int cnt;
+	int total;
+	int ind;	/* index into CHARS array */
+	char *chr;
+	int chars_size;
+	char *charlist;
 
 	chr=buffer;
 	total=offset+bsize;
@@ -52,19 +52,19 @@  int offset;
 }	/* end of dataasciigen */
 
 int
-dataasciichk(listofchars, buffer, bsize, offset, errmsg)
-char *listofchars;	/* a null terminated list of characters */
-char *buffer;
-int bsize;
-int offset;
-char **errmsg;
+dataasciichk(
+	char *listofchars,	/* a null terminated list of characters */
+	char *buffer,
+	int bsize,
+	int offset,
+	char **errmsg)
 {
-   int cnt;
-   int total;
-   int ind;	/* index into CHARS array */
-   char *chr;
-   int chars_size;
-   char *charlist;
+	int cnt;
+	int total;
+	int ind;	/* index into CHARS array */
+	char *chr;
+	int chars_size;
+	char *charlist;
 
 	chr=buffer;
 	total=offset+bsize;
@@ -104,15 +104,12 @@  char **errmsg;
  * main for doing unit testing
  ***********************************************************************/
 int
-main(ac, ag)
-int ac;
-char **ag;
+main(int ac, char **ag)
 {
-
-int size=1023;
-char *buffer;
-int ret;
-char *errmsg;
+    int size=1023;
+    char *buffer;
+    int ret;
+    char *errmsg;
 
     if ((buffer=(char *)malloc(size)) == NULL ) {
         perror("malloc");
diff --git a/lib/databin.c b/lib/databin.c
index 8a36dff3..000d0d1a 100644
--- a/lib/databin.c
+++ b/lib/databin.c
@@ -16,13 +16,13 @@ 
 static char Errmsg[80];
 
 void
-databingen (mode, buffer, bsize, offset)
-int mode;	/* either a, c, r, o, z or C */
-unsigned char *buffer;	/* buffer pointer */
-int bsize;	/* size of buffer */
-int offset;	/* offset into the file where buffer starts */
+databingen(
+	int mode,	/* either a, c, r, o, z or C */
+	unsigned char *buffer,	/* buffer pointer */
+	int bsize,	/* size of buffer */
+	int offset)	/* offset into the file where buffer starts */
 {
-int ind;
+	int ind;
 
         switch (mode)
         {
@@ -63,12 +63,12 @@  int ind;
  *      < 0  : no error
  ***********************************************************************/
 int
-databinchk(mode, buffer, bsize, offset, errmsg)
-int mode;	/* either a, c, r, z, o, or C */
-unsigned char *buffer;	/* buffer pointer */
-int bsize;	/* size of buffer */
-int offset;	/* offset into the file where buffer starts */
-char **errmsg;
+databinchk(
+	int mode,	/* either a, c, r, z, o, or C */
+	unsigned char *buffer,	/* buffer pointer */
+	int bsize,	/* size of buffer */
+	int offset,	/* offset into the file where buffer starts */
+	char **errmsg)
 {
 	int cnt;
 	unsigned char *chr;
@@ -138,9 +138,7 @@  char **errmsg;
  * main for doing unit testing
  ***********************************************************************/
 int
-main(ac, ag)
-int ac;
-char **ag;
+main(int ac, char **ag)
 {
 
     int size=1023;
diff --git a/lib/datapid.c b/lib/datapid.c
index 15af8871..6786323d 100644
--- a/lib/datapid.c
+++ b/lib/datapid.c
@@ -57,15 +57,13 @@  static char Errmsg[80];
  * Thus, offset 8 is in middle of word 1
  ***********************************************************************/
 int
-datapidgen(pid, buffer, bsize, offset)
-int pid;
-char *buffer;
-int bsize;
-int offset;
+datapidgen(
+	int pid,
+	char *buffer,
+	int bsize,
+	int offset)
 {
 	return -1;	/* not support on non-64 bits word machines  */
-
-
 } 
 
 /***********************************************************************
@@ -73,12 +71,7 @@  int offset;
  *
  ***********************************************************************/
 int
-datapidchk(pid, buffer, bsize, offset, errmsg)
-int pid;
-char *buffer;
-int bsize;
-int offset;
-char **errmsg;
+datapidchk(int pid, char *buffer, int bsize, int offset, char **errmsg)
 {
     if ( errmsg != NULL ) {
         *errmsg = Errmsg;
@@ -94,15 +87,12 @@  char **errmsg;
  * main for doing unit testing
  ***********************************************************************/
 int
-main(ac, ag)
-int ac;
-char **ag;
+main( int ac, char **ag)
 {
-
-int size=1234;
-char *buffer;
-int ret;
-char *errmsg;
+    int size=1234;
+    char *buffer;
+    int ret;
+    char *errmsg;
 
     if ((buffer=(char *)malloc(size)) == NULL ) {
         perror("malloc");
diff --git a/lib/file_lock.c b/lib/file_lock.c
index f0791489..6d87e281 100644
--- a/lib/file_lock.c
+++ b/lib/file_lock.c
@@ -34,10 +34,7 @@  static char errmsg[256];
  * It will loop if the LOCK_NB flags is NOT set.
  ***********************************************************************/
 int
-file_lock(fd, flags, errormsg)
-int fd;
-int flags;
-char **errormsg;
+file_lock(int fd, int flags, char **errormsg)
 {
         register int cmd, ret;
         struct flock flocks;
@@ -109,12 +106,7 @@  char **errormsg;
  * It will loop if the LOCK_NB flags is NOT set.
  ***********************************************************************/
 int
-record_lock(fd, flags, start, len, errormsg)
-int fd;
-int flags;
-int start;
-int len;
-char **errormsg;
+record_lock(int fd, int flags, int start, int len, char **errormsg)
 {
         register int cmd, ret;
         struct flock flocks;
diff --git a/lib/forker.c b/lib/forker.c
index 63d8fcdb..10920ddb 100644
--- a/lib/forker.c
+++ b/lib/forker.c
@@ -105,8 +105,7 @@  int Forker_npids=0;             /* number of entries in Forker_pids */
  *  !0 : if fork failed, the return value will be the errno.
  ***********************************************************************/
 int
-background(prefix)
-char *prefix;
+background(char *prefix)
 {
   switch (fork()) {
   case -1:
@@ -131,12 +130,12 @@  char *prefix;
  * 
  ***********************************************************************/
 int
-forker(ncopies, mode, prefix)
-int ncopies;
-int mode;	/* 0 - all childern of parent, 1 - only 1 direct child */
-char *prefix;   /* if ! NULL, an message will be printed to stderr */
-		/* if fork fails.  The prefix (program name) will */
-	        /* preceed the message */
+forker(
+    int ncopies,
+    int mode,		/* 0: all childern of parent, 1: only 1 direct child */
+    char *prefix)   	/* if ! NULL, an message will be printed to stderr */
+			/* if fork fails.  The prefix (program name) will */
+			/* preceed the message */
 {
     int cnt;
     int pid;
@@ -210,9 +209,7 @@  char *prefix;   /* if ! NULL, an message will be printed to stderr */
  */
 
 int
-main(argc, argv)
-int argc;
-char **argv;
+main(int argc, char **argv)
 {
     int ncopies=1;
     int mode=0;
diff --git a/lib/pattern.c b/lib/pattern.c
index d622b935..20bbdc97 100644
--- a/lib/pattern.c
+++ b/lib/pattern.c
@@ -12,12 +12,7 @@ 
  */
 
 int
-pattern_check(buf, buflen, pat, patlen, patshift)
-char	*buf;
-int	buflen;
-char	*pat;
-int	patlen;
-int	patshift;
+pattern_check(char *buf, int buflen, char *pat, int patlen, int patshift)
 {
     int		nb, ncmp, nleft;
     char	*cp;
@@ -79,12 +74,7 @@  int	patshift;
 }
 
 int
-pattern_fill(buf, buflen, pat, patlen, patshift)
-char	*buf;
-int	buflen;
-char	*pat;
-int	patlen;
-int	patshift;
+pattern_fill(char *buf, int buflen, char *pat, int patlen, int patshift)
 {
     int		trans, ncopied, nleft;
     char	*cp;
diff --git a/lib/random_range.c b/lib/random_range.c
index 3fa01f0d..680bf71c 100644
--- a/lib/random_range.c
+++ b/lib/random_range.c
@@ -73,14 +73,14 @@  static int       str_to_int();
 static long long divider(long long, long long, long long, long long);
 
 int
-parse_ranges(str, defmin, defmax, defmult, parse_func, rangeptr, errptr)
-char	*str;
-int	defmin;
-int	defmax;
-int	defmult;
-int	(*parse_func)();
-char	**rangeptr;
-char	**errptr;
+parse_ranges(
+	char *str,
+	int defmin,
+	int defmax,
+	int defmult,
+	int (*parse_func)(),
+	char **rangeptr,
+	char **errptr)
 {
 	int		ncommas;
 	char		*tmpstr, *cp, *tok, *n1str, *n2str, *multstr;
@@ -194,9 +194,7 @@  char	**errptr;
  */
 
 static int
-str_to_int(str, ip)
-char	*str;
-int	*ip;
+str_to_int(char *str, int *ip)
 {
 	char	c;
 
@@ -214,25 +212,19 @@  int	*ip;
  */
 
 int
-range_min(rbuf, r)
-char	*rbuf;
-int	r;
+range_min(char *rbuf, int r)
 {
 	return ((struct range *)rbuf)[r].min;
 }
 
 int
-range_max(rbuf, r)
-char	*rbuf;
-int	r;
+range_max(char *rbuf, int r)
 {
 	return ((struct range *)rbuf)[r].max;
 }
 
 int
-range_mult(rbuf, r)
-char	*rbuf;
-int	r;
+range_mult(char *rbuf, int r)
 {
 	return ((struct range *)rbuf)[r].mult;
 }
@@ -263,11 +255,7 @@  int	r;
  *****************************************************************************/
 
 long
-random_range(min, max, mult, errp)
-int	min;
-int	max;
-int	mult;
-char	**errp;
+random_range(int min, int max, int mult, char **errp)
 {
 	int     	r, nmults, orig_min, orig_max, orig_mult, tmp;
 	extern long	lrand48();
@@ -333,11 +321,7 @@  char	**errp;
  * Just like random_range, but all values are longs.
  */
 long
-random_rangel(min, max, mult, errp)
-long	min;
-long	max;
-long	mult;
-char	**errp;
+random_range1(long min, long max, long mult, char **errp)
 {
 	long     	r, nmults, orig_min, orig_max, orig_mult, tmp;
 	extern long	lrand48();
@@ -424,11 +408,7 @@  char	**errp;
  *  Attempts to be just like random_range, but everything is long long (64 bit)
  */
 long long
-random_rangell(min, max, mult, errp)
-long long	min;
-long long	max;
-long long	mult;
-char		**errp;
+random_rangell(long long min, long long max, long long mult, char **errp)
 {
 	long long     	r, nmults, orig_min, orig_max, orig_mult, tmp;
         long long	randnum;
@@ -588,8 +568,7 @@  printf("   diff = %lld, half = %lld,   med = %lld\n", diff, half, med);
  *****************************************************************************/
 
 void
-random_range_seed(s)
-long    s;
+random_range_seed(long s)
 {
     extern void srand48();
 
@@ -652,9 +631,7 @@  random_bit(long mask)
 /*
  *  The following is a unit test main function for random_bit().
  */
-main(argc, argv)
-int argc;
-char **argv;
+main(int argc, char **argv)
 {
     int ind;
     int cnt, iter;
@@ -695,9 +672,7 @@  char **argv;
 #define MEG  1024*1024*1024
 #define GIG 1073741824
 int
-main(argc, argv)
-int argc;
-char **argv;
+main(int argc, char **argv)
 {
     int ind;
     int cnt, iter=10;
diff --git a/lib/str_to_bytes.c b/lib/str_to_bytes.c
index 2f6b2b92..20cd2a0f 100644
--- a/lib/str_to_bytes.c
+++ b/lib/str_to_bytes.c
@@ -42,8 +42,7 @@ 
 #define T_MULT	1099511627776	/* tera or 2^40 */
 
 int
-str_to_bytes(s)
-char    *s;
+str_to_bytes(char *s)
 {
     char    mult, junk;
     int	    nconv;
@@ -77,8 +76,7 @@  char    *s;
 }
 
 long
-str_to_lbytes(s)
-char    *s;
+str_to_lbytes(char *s)
 {
     char    mult, junk;
     long    nconv;
@@ -117,8 +115,7 @@  char    *s;
  */
 
 long long
-str_to_llbytes(s)
-char    *s;
+str_to_llbytes(char *s)
 {
     char    mult, junk;
     long    nconv;
diff --git a/lib/tlibio.c b/lib/tlibio.c
index f7259734..3c23bf4d 100644
--- a/lib/tlibio.c
+++ b/lib/tlibio.c
@@ -143,13 +143,13 @@  static int Debug_level = 0;
  ***********************************************************************/
 
 int
-stride_bounds(offset, stride, nstrides, bytes_per_stride, min, max)
-int	offset;
-int	stride;
-int	nstrides;
-int	bytes_per_stride;
-int	*min;
-int	*max;
+stride_bounds(
+	int offset,
+	int stride,
+	int nstrides,
+	int bytes_per_stride,
+	int *min,
+	int *max)
 {
 	int	nbytes, min_byte, max_byte;
 
@@ -443,14 +443,14 @@  lio_random_methods(long curr_mask)
  * (rrl 04/96)
  ***********************************************************************/
 int
-lio_write_buffer(fd, method, buffer, size, sig, errmsg, wrd)
-int fd;		/* open file descriptor */
-int method;	/* contains io type and wait method bitmask */
-char *buffer;	/* pointer to buffer */
-int size;	/* the size of the io */
-int sig;	/* signal to use if async io */
-char **errmsg;	/* char pointer that will be updated to point to err message */
-long wrd;	/* to allow future features, use zero for now */
+lio_write_buffer(
+    int fd,		/* open file descriptor */
+    int method,		/* contains io type and wait method bitmask */
+    char *buffer,	/* pointer to buffer */
+    int size,		/* the size of the io */
+    int sig,		/* signal to use if async io */
+    char **errmsg,	/* char pointer that will be updated to point to err message */
+    long wrd)		/* to allow future features, use zero for now */
 {
     int ret = 0;	/* syscall return or used to get random method */
 #ifndef linux
@@ -640,14 +640,14 @@  long wrd;	/* to allow future features, use zero for now */
  * (rrl 04/96)
  ***********************************************************************/
 int
-lio_read_buffer(fd, method, buffer, size, sig, errmsg, wrd)
-int fd;		/* open file descriptor */
-int method;	/* contains io type and wait method bitmask */
-char *buffer;	/* pointer to buffer */
-int size;	/* the size of the io */
-int sig;	/* signal to use if async io */
-char **errmsg;	/* char pointer that will be updated to point to err message */
-long wrd;	/* to allow future features, use zero for now */
+lio_read_buffer(
+    int fd,		/* open file descriptor */
+    int method,		/* contains io type and wait method bitmask */
+    char *buffer,	/* pointer to buffer */
+    int size,		/* the size of the io */
+    int sig,		/* signal to use if async io */
+    char **errmsg,	/* char pointer that will be updated to point to err message */
+    long wrd)		/* to allow future features, use zero for now */
 {
     int ret = 0;	/* syscall return or used to get random method */
 #ifndef linux
@@ -1031,9 +1031,7 @@  struct unit_info_t {
 };
 
 int
-main(argc, argv)
-int argc;
-char **argv;
+main(int argc, char **argv)
 {
     extern char *optarg;
     extern int optind;
diff --git a/lib/write_log.c b/lib/write_log.c
index cdc72593..c82cc1f4 100644
--- a/lib/write_log.c
+++ b/lib/write_log.c
@@ -87,10 +87,7 @@  static int	wlog_rec_unpack();
  */
 
 int
-wlog_open(wfile, trunc, mode)
-struct wlog_file	*wfile;
-int			trunc;
-int			mode;
+wlog_open(struct wlog_file *wfile, int trunc, int mode)
 {
 	int	omask, oflags;
 
@@ -138,8 +135,7 @@  int			mode;
  */
 
 int
-wlog_close(wfile)
-struct wlog_file	*wfile;
+wlog_close(struct wlog_file *wfile)
 {
 	close(wfile->w_afd);
 	close(wfile->w_rfd);
@@ -173,10 +169,7 @@  struct wlog_file	*wfile;
  */
 
 int
-wlog_record_write(wfile, wrec, offset)
-struct wlog_file	*wfile;
-struct wlog_rec		*wrec;
-long			offset;
+wlog_record_write(struct wlog_file *wfile, struct wlog_rec *wrec, long offset)
 {
     int		reclen;
     char	wbuf[WLOG_REC_MAX_SIZE + 2];
@@ -221,11 +214,11 @@  long			offset;
  */
 
 int
-wlog_scan_backward(wfile, nrecs, func, data)
-struct wlog_file	*wfile;
-int 			nrecs;
-int 			(*func)();
-long			data;
+wlog_scan_backward(
+	struct wlog_file	*wfile,
+	int 			nrecs,
+	int 			(*func)(),
+	long			data)
 {
 	int			fd, leftover, nbytes, offset, recnum, reclen;
 	char    		buf[BSIZE*32], *bufend, *cp, *bufstart;
@@ -351,10 +344,7 @@  long			data;
  */
 
 static int
-wlog_rec_pack(wrec, buf, flag)
-struct wlog_rec	*wrec;
-char		*buf;
-int             flag;
+wlog_rec_pack(struct wlog_rec *wrec, char *buf, int flag)
 {
 	char			*file, *host, *pattern;
 	struct wlog_rec_disk	*wrecd;
@@ -400,9 +390,7 @@  int             flag;
 }
 
 static int
-wlog_rec_unpack(wrec, buf)
-struct wlog_rec	*wrec;
-char		*buf;
+wlog_rec_unpack(struct wlog_rec *wrec, char *buf)
 {
 	char			*file, *host, *pattern;
 	struct wlog_rec_disk	*wrecd;