Date: Wed, 22 Jun 2016 17:30:57 +0000 (UTC) From: Mikhail Teterin <mi@FreeBSD.org> To: ports-committers@freebsd.org, svn-ports-all@freebsd.org, svn-ports-head@freebsd.org Subject: svn commit: r417327 - head/benchmarks/iozone/files Message-ID: <201606221730.u5MHUvTo010891@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: mi Date: Wed Jun 22 17:30:57 2016 New Revision: 417327 URL: https://svnweb.freebsd.org/changeset/ports/417327 Log: Ensure clean build with clang on both amd64 and i386. Respect the SSH-option turned off (rsh was replaced with ssh unconditionally). PR: 210449 Added: head/benchmarks/iozone/files/patch-pit_server.c (contents, props changed) Modified: head/benchmarks/iozone/files/patch-iozone.c head/benchmarks/iozone/files/patch-libasync.c Modified: head/benchmarks/iozone/files/patch-iozone.c ============================================================================== --- head/benchmarks/iozone/files/patch-iozone.c Wed Jun 22 17:23:19 2016 (r417326) +++ head/benchmarks/iozone/files/patch-iozone.c Wed Jun 22 17:30:57 2016 (r417327) @@ -1,27 +1,154 @@ ---- iozone.c.orig 2015-10-20 14:12:13 UTC +Fix warnings from modern compilers -- formats, use of 0 instead of NULL. +Also remove redundant casts and fix printf-formatting. + + -mi +--- iozone.c 2015-10-20 14:12:13.000000000 +0000 +++ iozone.c -@@ -360,6 +360,7 @@ typedef off_t off64_t; - #ifndef SCO_Unixware_gcc - #ifndef UWIN - #ifndef __DragonFly__ -+#ifndef __FreeBSD__ - typedef long long off64_t; - #endif - #endif -@@ -369,6 +370,7 @@ typedef long long off64_t; - #endif - #endif - #endif -+#endif +@@ -8679,5 +8679,5 @@ + if(r_traj_flag) + { +- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&compute_time, (long)0); ++ traj_offset=get_traj(r_traj_fd, &traj_size, &compute_time, 0); + reclen=traj_size; + #if defined(Windows) +@@ -14765,5 +14765,5 @@ + if(r_traj_flag) + { +- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&delay,(long)0); ++ traj_offset=get_traj(r_traj_fd, &traj_size, &delay, 0); + reclen=traj_size; + #if defined(Windows) +@@ -15318,5 +15318,5 @@ + if(r_traj_flag) + { +- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&delay,(long)0); ++ traj_offset=get_traj(r_traj_fd, &traj_size, &delay, 0); + reclen=traj_size; + I_LSEEK(fd,traj_offset,SEEK_SET); +@@ -15878,5 +15878,5 @@ + if(r_traj_flag) + { +- traj_offset=get_traj(r_traj_fd, (long long *)&traj_size,(float *)&delay,(long)0); ++ traj_offset=get_traj(r_traj_fd, &traj_size, &delay, 0); + reclen=traj_size; + #if defined(Windows) +@@ -18745,11 +18745,5 @@ + int xx; + int *yy; +-#ifdef _64BIT_ARCH_ +- long long meme; +- meme = (long long)x; +-#else +- long meme; +- meme = (long)x; +-#endif ++ intptr_t meme = (intptr_t)x; + yy=(int *)x; - #ifdef __AIX__ - #include <fcntl.h> -@@ -23009,7 +23011,7 @@ char *shell; - #ifdef _HPUX_SOURCE - strcpy(shell,"remsh"); - #else -- strcpy(shell,"rsh"); -+ strcpy(shell,"ssh"); - #endif - return; - } +@@ -18770,6 +18764,6 @@ + if(debug1 ) + { +- printf("\nthread created has an id of %lx\n",ts); +- printf("meme %ld\n",meme); ++ printf("\nthread created has an id of %p\n", ts); ++ printf("meme %lld\n", (long long)meme); + } + return((long long)meme); +@@ -22167,5 +22161,5 @@ + fflush(newstdout); + } +- thread_write_test((long)0); ++ thread_write_test(NULL); + break; + #ifdef HAVE_PREAD +@@ -22176,5 +22170,5 @@ + fflush(newstdout); + } +- thread_pwrite_test((long)0); ++ thread_pwrite_test(NULL); + break; + #endif +@@ -22185,5 +22179,5 @@ + fflush(newstdout); + } +- thread_rwrite_test((long)0); ++ thread_rwrite_test(NULL); + break; + case THREAD_READ_TEST : +@@ -22193,5 +22187,5 @@ + fflush(newstdout); + } +- thread_read_test((long)0); ++ thread_read_test(NULL); + break; + #ifdef HAVE_PREAD +@@ -22202,5 +22196,5 @@ + fflush(newstdout); + } +- thread_pread_test((long)0); ++ thread_pread_test(NULL); + break; + #endif +@@ -22211,5 +22205,5 @@ + fflush(newstdout); + } +- thread_rread_test((long)0); ++ thread_rread_test(NULL); + break; + case THREAD_STRIDE_TEST : +@@ -22219,5 +22213,5 @@ + fflush(newstdout); + } +- thread_stride_read_test((long)0); ++ thread_stride_read_test(NULL); + break; + case THREAD_RANDOM_READ_TEST : +@@ -22227,5 +22221,5 @@ + fflush(newstdout); + } +- thread_ranread_test((long)0); ++ thread_ranread_test(NULL); + break; + case THREAD_RANDOM_WRITE_TEST : +@@ -22235,5 +22229,5 @@ + fflush(newstdout); + } +- thread_ranwrite_test((long)0); ++ thread_ranwrite_test(NULL); + break; + case THREAD_REVERSE_READ_TEST : +@@ -22243,5 +22237,5 @@ + fflush(newstdout); + } +- thread_reverse_read_test((long)0); ++ thread_reverse_read_test(NULL); + break; + case THREAD_RANDOM_MIX_TEST : +@@ -22251,5 +22245,5 @@ + fflush(newstdout); + } +- thread_mix_test((long)0); ++ thread_mix_test(NULL); + break; + case THREAD_FWRITE_TEST : +@@ -22259,5 +22253,5 @@ + fflush(newstdout); + } +- thread_fwrite_test((long)0); ++ thread_fwrite_test(NULL); + break; + case THREAD_FREAD_TEST : +@@ -22267,5 +22261,5 @@ + fflush(newstdout); + } +- thread_fread_test((long)0); ++ thread_fread_test(NULL); + break; + case THREAD_CLEANUP_TEST : +@@ -22275,5 +22269,5 @@ + fflush(newstdout); + } +- thread_cleanup_test((long)0); ++ thread_cleanup_test(NULL); + break; + }; Modified: head/benchmarks/iozone/files/patch-libasync.c ============================================================================== --- head/benchmarks/iozone/files/patch-libasync.c Wed Jun 22 17:23:19 2016 (r417326) +++ head/benchmarks/iozone/files/patch-libasync.c Wed Jun 22 17:30:57 2016 (r417327) @@ -1,36 +1,961 @@ ---- libasync.c.orig 2015-10-20 14:12:13 UTC +The bulk of this patch eliminates the gratutious differences between +LP64, LARGEFILE64 and normal cases. The differences are dealt with +in one location and the rest of the code need not differ. + +Most of the other changes deal with printf-formats (%zd for ssize_t +and the like) and other warnings. + + -mi +--- libasync.c 2015-10-20 14:12:13.000000000 +0000 +++ libasync.c -@@ -96,13 +96,13 @@ - +@@ -97,4 +97,13 @@ #include <sys/types.h> #include <aio.h> --#if defined(solaris) || defined(linux) || defined(SCO_Unixware_gcc) || defined(__NetBSD__) -+#if defined(solaris) || defined(linux) || defined(SCO_Unixware_gcc) || defined(__NetBSD__) || defined(__FreeBSD__) ++ ++#if defined(_LARGEFILE64_SOURCE) && !defined(__LP64__) ++# define aio_error aio_error64 ++# define aio_return aio_return64 ++# define aio_read aio_read64 ++# define aio_cancel aio_cancel64 ++# define aio_write aio_write64 ++#endif ++ + #if defined(solaris) || defined(linux) || defined(SCO_Unixware_gcc) || defined(__NetBSD__) #else - #include <sys/timers.h> - #endif - #include <sys/errno.h> - #include <unistd.h> --#ifndef bsd4_4 -+#if !defined(bsd4_4) && !defined(__FreeBSD__) - #include <malloc.h> - #endif - #ifdef VXFS -@@ -119,7 +119,7 @@ - #include <stdlib.h> +@@ -133,9 +142,13 @@ #endif --#if (defined(solaris) && defined(__LP64__)) || defined(__s390x__) || defined(FreeBSD) || defined(__NetBSD__) -+#if (defined(solaris) && defined(__LP64__)) || defined(__s390x__) || defined(__FreeBSD__) || defined(__NetBSD__) - /* If we are building for 64-bit Solaris, all functions that return pointers - * must be declared before they are used; otherwise the compiler will assume - * that they return ints and the top 32 bits of the pointer will be lost, -@@ -135,7 +135,7 @@ - void mbcopy(char *source, char *dest, size_t len); +-void mbcopy(char *source, char *dest, size_t len); ++static void mbcopy(const char *source, char *dest, size_t len); --#if !defined(solaris) && !defined(off64_t) && !defined(_OFF64_T) && !defined(__off64_t_defined) && !defined(SCO_Unixware_gcc) -+#if !defined(solaris) && !defined(off64_t) && !defined(_OFF64_T) && !defined(__off64_t_defined) && !defined(SCO_Unixware_gcc) && !defined(__FreeBSD__) + #if !defined(solaris) && !defined(off64_t) && !defined(_OFF64_T) && !defined(__off64_t_defined) && !defined(SCO_Unixware_gcc) ++# if defined(bsd4_4) ++typedef off_t off64_t; ++# else typedef long long off64_t; ++# endif #endif #if defined(OSFV5) +@@ -151,13 +164,13 @@ + * this structure type. + */ +-char version[] = "Libasync Version $Revision: 3.25 $"; ++static const char version[] = "Libasync Version $Revision: 3.25 $"; + struct cache_ent { + struct aiocb myaiocb; /* For use in small file mode */ + #ifdef _LARGEFILE64_SOURCE + #if defined(__CrayX1__) +- aiocb64_t myaiocb64; /* For use in large file mode */ ++ aiocb64_t myaiocb; /* For use in large file mode */ + #else +- struct aiocb64 myaiocb64; /* For use in large file mode */ +-#endif ++ struct aiocb64 myaiocb; /* For use in large file mode */ ++#endif + #endif + long long fd; /* File descriptor */ +@@ -192,6 +205,6 @@ + long long max_depth; + extern int errno; +-struct cache_ent *alloc_cache(); +-struct cache_ent *incache(); ++static struct cache_ent *alloc_cache(); ++static struct cache_ent *incache(); + void async_init(); + void end_async(); +@@ -275,5 +288,5 @@ + const struct aiocb * const cblist[1] = {&ce->myaiocb}; + #else +- const struct aiocb64 * const cblist[1] = {&ce->myaiocb64}; ++ const struct aiocb64 * const cblist[1] = {&ce->myaiocb}; + #endif + #else +@@ -348,87 +361,26 @@ + if((ce=(struct cache_ent *)incache(gc,fd,offset,size))) + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + while((ret=aio_error(&ce->myaiocb))== EINPROGRESS) + { + async_suspend(ce); + } +-#else +- while((ret=aio_error64(&ce->myaiocb64))== EINPROGRESS) +- { +- async_suspend(ce); +- } +-#endif +-#else +- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS) +- { +- async_suspend(ce); +- } +-#endif + if(ret) + { +- printf("aio_error 1: ret %d %d\n",ret,errno); ++ printf("aio_error 1: ret %zd %d\n",ret,errno); + } +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + retval=aio_return(&ce->myaiocb); +-#else +-#if defined(__CrayX1__) +- retval=aio_return64((aiocb64_t *)&ce->myaiocb64); +-#else +- retval=aio_return64((struct aiocb64 *)&ce->myaiocb64); +-#endif +- +-#endif +-#else +- retval=aio_return(&ce->myaiocb); +-#endif + if(retval > 0) + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + mbcopy((char *)ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval); +-#else +- mbcopy((char *)ce->myaiocb64.aio_buf,(char *)ubuffer,(size_t)retval); +-#endif +-#else +- mbcopy((char *)ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval); +-#endif + } +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- if(retval < ce->myaiocb.aio_nbytes) +-#else +- if(retval < ce->myaiocb64.aio_nbytes) +-#endif +-#else + if(retval < ce->myaiocb.aio_nbytes) +-#endif + { +- printf("aio_return error1: ret %d %d\n",retval,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- printf("aio_return error1: fd %d offset %ld buffer %lx size %d Opcode %d\n", +- ce->myaiocb.aio_fildes, +- ce->myaiocb.aio_offset, +- (long)(ce->myaiocb.aio_buf), +- ce->myaiocb.aio_nbytes, +- ce->myaiocb.aio_lio_opcode +-#else +- printf("aio_return error1: fd %d offset %lld buffer %lx size %d Opcode %d\n", +- ce->myaiocb64.aio_fildes, +- ce->myaiocb64.aio_offset, +- (long)(ce->myaiocb64.aio_buf), +- ce->myaiocb64.aio_nbytes, +- ce->myaiocb64.aio_lio_opcode +-#endif +-#else +- printf("aio_return error1: fd %d offset %d buffer %lx size %d Opcode %d\n", ++ printf("aio_return error1: ret %zd %d\n",retval,errno); ++ printf("aio_return error1: fd %d offset %lld buffer %p size %zd Opcode %d\n", + ce->myaiocb.aio_fildes, +- ce->myaiocb.aio_offset, +- (long)(ce->myaiocb.aio_buf), ++ (long long)ce->myaiocb.aio_offset, ++ ce->myaiocb.aio_buf, + ce->myaiocb.aio_nbytes, + ce->myaiocb.aio_lio_opcode +-#endif + ); + } +@@ -444,13 +396,5 @@ + first_ce=alloc_cache(gc,fd,offset,size,(long long)LIO_READ); + again: +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + ret=aio_read(&first_ce->myaiocb); +-#else +- ret=aio_read64(&first_ce->myaiocb64); +-#endif +-#else +- ret=aio_read(&first_ce->myaiocb); +-#endif + if(ret!=0) + { +@@ -458,5 +402,5 @@ + goto again; + else +- printf("error returned from aio_read(). Ret %d errno %d\n",ret,errno); ++ printf("error returned from aio_read(). Ret %zd errno %d\n",ret,errno); + } + } +@@ -483,13 +427,5 @@ + continue; + ce=alloc_cache(gc,fd,r_offset,a_size,(long long)LIO_READ); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- ret=aio_read(&ce->myaiocb); +-#else +- ret=aio_read64(&ce->myaiocb64); +-#endif +-#else + ret=aio_read(&ce->myaiocb); +-#endif + if(ret!=0) + { +@@ -501,81 +437,25 @@ + if(del_read) /* Wait for the first read to complete */ + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS) + { + async_suspend(first_ce); + } +-#else +- while((ret=aio_error64(&first_ce->myaiocb64))== EINPROGRESS) +- { +- async_suspend(first_ce); +- } +-#endif +-#else +- while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS) +- { +- async_suspend(first_ce); +- } +-#endif + if(ret) +- printf("aio_error 2: ret %d %d\n",ret,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- retval=aio_return(&first_ce->myaiocb); +-#else +- retval=aio_return64(&first_ce->myaiocb64); +-#endif +-#else ++ printf("aio_error 2: ret %zd %d\n",ret,errno); + retval=aio_return(&first_ce->myaiocb); +-#endif +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- if(retval < first_ce->myaiocb.aio_nbytes) +-#else +- if(retval < first_ce->myaiocb64.aio_nbytes) +-#endif +-#else + if(retval < first_ce->myaiocb.aio_nbytes) +-#endif + { +- printf("aio_return error2: ret %d %d\n",retval,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- printf("aio_return error2: fd %d offset %lld buffer %lx size %d Opcode %d\n", ++ printf("aio_return error2: ret %zd %d\n",retval,errno); ++ printf("aio_return error2: fd %d offset %lld buffer %p size %zd Opcode %d\n", + first_ce->myaiocb.aio_fildes, +- first_ce->myaiocb.aio_offset, +- (long)(first_ce->myaiocb.aio_buf), ++ (long long)first_ce->myaiocb.aio_offset, ++ first_ce->myaiocb.aio_buf, + first_ce->myaiocb.aio_nbytes, + first_ce->myaiocb.aio_lio_opcode +-#else +- printf("aio_return error2: fd %d offset %lld buffer %lx size %d Opcode %d\n", +- first_ce->myaiocb64.aio_fildes, +- first_ce->myaiocb64.aio_offset, +- (long)(first_ce->myaiocb64.aio_buf), +- first_ce->myaiocb64.aio_nbytes, +- first_ce->myaiocb64.aio_lio_opcode +-#endif +-#else +- printf("aio_return error2: fd %d offset %d buffer %lx size %d Opcode %d\n", +- first_ce->myaiocb.aio_fildes, +- first_ce->myaiocb.aio_offset, +- (long)(first_ce->myaiocb.aio_buf), +- first_ce->myaiocb.aio_nbytes, +- first_ce->myaiocb.aio_lio_opcode +-#endif + ); + } + if(retval > 0) + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- mbcopy((char *)first_ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval); +-#else +- mbcopy((char *)first_ce->myaiocb64.aio_buf,(char *)ubuffer,(size_t)retval); +-#endif +-#else + mbcopy((char *)first_ce->myaiocb.aio_buf,(char *)ubuffer,(size_t)retval); +-#endif + } + first_ce->direct=0; +@@ -602,5 +482,5 @@ + { + struct cache_ent *ce; +- long temp; ++ intptr_t temp; + ce=(struct cache_ent *)malloc((size_t)sizeof(struct cache_ent)); + if(ce == (struct cache_ent *)0) +@@ -610,31 +490,11 @@ + } + bzero(ce,sizeof(struct cache_ent)); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + ce->myaiocb.aio_fildes=(int)fd; + ce->myaiocb.aio_offset=(off64_t)offset; +- ce->real_address = (char *)malloc((size_t)(size+page_size)); +- temp=(long)ce->real_address; +- temp = (temp+page_size) & ~(page_size-1); +- ce->myaiocb.aio_buf=(volatile void *)temp; +- if(ce->myaiocb.aio_buf == 0) +-#else +- ce->myaiocb64.aio_fildes=(int)fd; +- ce->myaiocb64.aio_offset=(off64_t)offset; +- ce->real_address = (char *)malloc((size_t)(size+page_size)); +- temp=(long)ce->real_address; +- temp = (temp+page_size) & ~(page_size-1); +- ce->myaiocb64.aio_buf=(volatile void *)temp; +- if(ce->myaiocb64.aio_buf == 0) +-#endif +-#else +- ce->myaiocb.aio_fildes=(int)fd; +- ce->myaiocb.aio_offset=(off_t)offset; +- ce->real_address = (char *)malloc((size_t)(size+page_size)); +- temp=(long)ce->real_address; ++ ce->real_address = malloc((size_t)(size+page_size)); ++ temp = (intptr_t)ce->real_address; + temp = (temp+page_size) & ~(page_size-1); + ce->myaiocb.aio_buf=(volatile void *)temp; +- if(ce->myaiocb.aio_buf == 0) +-#endif ++ if(ce->myaiocb.aio_buf == NULL) + { + printf("Malloc failed\n"); +@@ -642,22 +502,8 @@ + } + /*bzero(ce->myaiocb.aio_buf,(size_t)size);*/ +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- ce->myaiocb.aio_reqprio=0; +- ce->myaiocb.aio_nbytes=(size_t)size; +- ce->myaiocb.aio_sigevent.sigev_notify=SIGEV_NONE; +- ce->myaiocb.aio_lio_opcode=(int)op; +-#else +- ce->myaiocb64.aio_reqprio=0; +- ce->myaiocb64.aio_nbytes=(size_t)size; +- ce->myaiocb64.aio_sigevent.sigev_notify=SIGEV_NONE; +- ce->myaiocb64.aio_lio_opcode=(int)op; +-#endif +-#else + ce->myaiocb.aio_reqprio=0; + ce->myaiocb.aio_nbytes=(size_t)size; + ce->myaiocb.aio_sigevent.sigev_notify=SIGEV_NONE; + ce->myaiocb.aio_lio_opcode=(int)op; +-#endif + ce->fd=(int)fd; + ce->forward=0; +@@ -688,6 +534,4 @@ + } + move=gc->head; +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + while(move) + { +@@ -699,26 +543,4 @@ + move=move->forward; + } +-#else +- while(move) +- { +- if((move->fd == fd) && (move->myaiocb64.aio_offset==(off64_t)offset) && +- ((size_t)size==move->myaiocb64.aio_nbytes)) +- { +- return(move); +- } +- move=move->forward; +- } +-#endif +-#else +- while(move) +- { +- if((move->fd == fd) && (move->myaiocb.aio_offset==(off_t)offset) && +- ((size_t)size==move->myaiocb.aio_nbytes)) +- { +- return(move); +- } +- move=move->forward; +- } +-#endif + return(0); + } +@@ -805,24 +627,8 @@ + if(ce==0) + return; +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- while((ret = aio_cancel(0,&ce->myaiocb))==AIO_NOTCANCELED) +-#else +- while((ret = aio_cancel64(0,&ce->myaiocb64))==AIO_NOTCANCELED) +-#endif +-#else + while((ret = aio_cancel(0,&ce->myaiocb))==AIO_NOTCANCELED) +-#endif + ; + +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- ret = aio_return(&ce->myaiocb); +-#else +- ret = aio_return64(&ce->myaiocb64); +-#endif +-#else + ret = aio_return(&ce->myaiocb); +-#endif + ce->direct=0; + takeoff_cache(gc,ce); /* remove from cache */ +@@ -865,98 +671,27 @@ + if((ce=(struct cache_ent *)incache(gc,fd,offset,size))) + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + while((ret=aio_error(&ce->myaiocb))== EINPROGRESS) + { + async_suspend(ce); + } +-#else +- while((ret=aio_error64(&ce->myaiocb64))== EINPROGRESS) +- { +- async_suspend(ce); +- } +-#endif +-#else +- while((ret=aio_error(&ce->myaiocb))== EINPROGRESS) +- { +- async_suspend(ce); +- } +-#endif + if(ret) +- printf("aio_error 3: ret %d %d\n",ret,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- if(ce->oldbuf != ce->myaiocb.aio_buf || +- ce->oldfd != ce->myaiocb.aio_fildes || +- ce->oldsize != ce->myaiocb.aio_nbytes) +-#else +- if(ce->oldbuf != ce->myaiocb64.aio_buf || +- ce->oldfd != ce->myaiocb64.aio_fildes || +- ce->oldsize != ce->myaiocb64.aio_nbytes) +-#endif +-#else +- if(ce->oldbuf != ce->myaiocb.aio_buf || +- ce->oldfd != ce->myaiocb.aio_fildes || +- ce->oldsize != ce->myaiocb.aio_nbytes) +-#endif ++ printf("aio_error 3: ret %zd %d\n",ret,errno); + printf("It changed in flight\n"); + +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- retval=aio_return(&ce->myaiocb); +-#else +- retval=aio_return64(&ce->myaiocb64); +-#endif +-#else + retval=aio_return(&ce->myaiocb); +-#endif + if(retval > 0) + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- *ubuffer=(char *)ce->myaiocb.aio_buf; +-#else +- *ubuffer=(char *)ce->myaiocb64.aio_buf; +-#endif +-#else +- *ubuffer=(char *)ce->myaiocb.aio_buf; +-#endif ++ *ubuffer= (char *)ce->myaiocb.aio_buf; + }else +- *ubuffer=0; +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- if(retval < ce->myaiocb.aio_nbytes) +-#else +- if(retval < ce->myaiocb64.aio_nbytes) +-#endif +-#else ++ *ubuffer= NULL; + if(retval < ce->myaiocb.aio_nbytes) +-#endif + { +- printf("aio_return error4: ret %d %d\n",retval,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- printf("aio_return error4: fd %d offset %lld buffer %lx size %d Opcode %d\n", +- ce->myaiocb.aio_fildes, +- ce->myaiocb.aio_offset, +- (long)(ce->myaiocb.aio_buf), +- ce->myaiocb.aio_nbytes, +- ce->myaiocb.aio_lio_opcode +-#else +- printf("aio_return error4: fd %d offset %lld buffer %lx size %d Opcode %d\n", +- ce->myaiocb64.aio_fildes, +- ce->myaiocb64.aio_offset, +- (long)(ce->myaiocb64.aio_buf), +- ce->myaiocb64.aio_nbytes, +- ce->myaiocb64.aio_lio_opcode +-#endif +-#else +- printf("aio_return error4: fd %d offset %d buffer %lx size %d Opcode %d\n", ++ printf("aio_return error4: ret %zd %d\n",retval,errno); ++ printf("aio_return error4: fd %d offset %lld buffer %p size %zd Opcode %d\n", + ce->myaiocb.aio_fildes, +- ce->myaiocb.aio_offset, +- (long)(ce->myaiocb.aio_buf), ++ (long long)ce->myaiocb.aio_offset, ++ ce->myaiocb.aio_buf, + ce->myaiocb.aio_nbytes, + ce->myaiocb.aio_lio_opcode +-#endif + ); + } +@@ -974,22 +709,8 @@ + /*printf("allocated buffer/read %x offset %d\n",first_ce->myaiocb.aio_buf,offset);*/ + again: +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- first_ce->oldbuf=first_ce->myaiocb.aio_buf; +- first_ce->oldfd=first_ce->myaiocb.aio_fildes; +- first_ce->oldsize=first_ce->myaiocb.aio_nbytes; +- ret=aio_read(&first_ce->myaiocb); +-#else +- first_ce->oldbuf=first_ce->myaiocb64.aio_buf; +- first_ce->oldfd=first_ce->myaiocb64.aio_fildes; +- first_ce->oldsize=first_ce->myaiocb64.aio_nbytes; +- ret=aio_read64(&first_ce->myaiocb64); +-#endif +-#else + first_ce->oldbuf=first_ce->myaiocb.aio_buf; + first_ce->oldfd=first_ce->myaiocb.aio_fildes; + first_ce->oldsize=first_ce->myaiocb.aio_nbytes; + ret=aio_read(&first_ce->myaiocb); +-#endif + if(ret!=0) + { +@@ -997,5 +718,5 @@ + goto again; + else +- printf("error returned from aio_read(). Ret %d errno %d\n",ret,errno); ++ printf("error returned from aio_read(). Ret %zd errno %d\n",ret,errno); + } + } +@@ -1022,22 +743,8 @@ + continue; + ce=alloc_cache(gc,fd,r_offset,a_size,(long long)LIO_READ); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- ce->oldbuf=ce->myaiocb.aio_buf; +- ce->oldfd=ce->myaiocb.aio_fildes; +- ce->oldsize=ce->myaiocb.aio_nbytes; +- ret=aio_read(&ce->myaiocb); +-#else +- ce->oldbuf=ce->myaiocb64.aio_buf; +- ce->oldfd=ce->myaiocb64.aio_fildes; +- ce->oldsize=ce->myaiocb64.aio_nbytes; +- ret=aio_read64(&ce->myaiocb64); +-#endif +-#else + ce->oldbuf=ce->myaiocb.aio_buf; + ce->oldfd=ce->myaiocb.aio_fildes; + ce->oldsize=ce->myaiocb.aio_nbytes; + ret=aio_read(&ce->myaiocb); +-#endif + if(ret!=0) + { +@@ -1049,39 +756,10 @@ + if(del_read) /* Wait for the first read to complete */ + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ + while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS) + { + async_suspend(first_ce); + } +-#else +- while((ret=aio_error64(&first_ce->myaiocb64))== EINPROGRESS) +- { +- async_suspend(first_ce); +- } +-#endif +-#else +- while((ret=aio_error(&first_ce->myaiocb))== EINPROGRESS) +- { +- async_suspend(first_ce); +- } +-#endif + if(ret) +- printf("aio_error 4: ret %d %d\n",ret,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- if(first_ce->oldbuf != first_ce->myaiocb.aio_buf || +- first_ce->oldfd != first_ce->myaiocb.aio_fildes || +- first_ce->oldsize != first_ce->myaiocb.aio_nbytes) +- printf("It changed in flight2\n"); +- retval=aio_return(&first_ce->myaiocb); +-#else +- if(first_ce->oldbuf != first_ce->myaiocb64.aio_buf || +- first_ce->oldfd != first_ce->myaiocb64.aio_fildes || +- first_ce->oldsize != first_ce->myaiocb64.aio_nbytes) +- printf("It changed in flight2\n"); +- retval=aio_return64(&first_ce->myaiocb64); +-#endif +-#else ++ printf("aio_error 4: ret %zd %d\n",ret,errno); + if(first_ce->oldbuf != first_ce->myaiocb.aio_buf || + first_ce->oldfd != first_ce->myaiocb.aio_fildes || +@@ -1089,55 +767,20 @@ + printf("It changed in flight2\n"); + retval=aio_return(&first_ce->myaiocb); +-#endif +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- if(retval < first_ce->myaiocb.aio_nbytes) +-#else +- if(retval < first_ce->myaiocb64.aio_nbytes) +-#endif +-#else + if(retval < first_ce->myaiocb.aio_nbytes) +-#endif + { +- printf("aio_return error5: ret %d %d\n",retval,errno); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- printf("aio_return error5: fd %d offset %lld buffer %lx size %d Opcode %d\n", +- first_ce->myaiocb.aio_fildes, +- first_ce->myaiocb.aio_offset, +- (long)(first_ce->myaiocb.aio_buf), +- first_ce->myaiocb.aio_nbytes, +- first_ce->myaiocb.aio_lio_opcode +-#else +- printf("aio_return error5: fd %d offset %lld buffer %lx size %d Opcode %d\n", +- first_ce->myaiocb64.aio_fildes, +- first_ce->myaiocb64.aio_offset, +- (long)(first_ce->myaiocb64.aio_buf), +- first_ce->myaiocb64.aio_nbytes, +- first_ce->myaiocb64.aio_lio_opcode +-#endif +-#else +- printf("aio_return error5: fd %d offset %ld buffer %lx size %d Opcode %d\n", ++ printf("aio_return error5: ret %zd %d\n",retval,errno); ++ printf("aio_return error5: fd %d offset %lld buffer %p size %zd Opcode %d\n", + first_ce->myaiocb.aio_fildes, +- first_ce->myaiocb.aio_offset, +- (long)(first_ce->myaiocb.aio_buf), ++ (long long)first_ce->myaiocb.aio_offset, ++ first_ce->myaiocb.aio_buf, + first_ce->myaiocb.aio_nbytes, + first_ce->myaiocb.aio_lio_opcode +-#endif + ); + } + if(retval > 0) + { +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- *ubuffer=(char *)first_ce->myaiocb.aio_buf; +-#else +- *ubuffer=(char *)first_ce->myaiocb64.aio_buf; +-#endif +-#else +- *ubuffer=(char *)first_ce->myaiocb.aio_buf; +-#endif ++ *ubuffer= (char *)first_ce->myaiocb.aio_buf; + }else +- *ubuffer=(char *)0; ++ *ubuffer= NULL; + first_ce->direct=1; /* do not delete the buffer */ + takeoff_cache(gc,first_ce); +@@ -1218,30 +861,14 @@ + ce=allocate_write_buffer(gc,fd,offset,size,(long long)LIO_WRITE,depth,0LL,(char *)0,(char *)0); + ce->direct=0; /* not direct. Lib supplies buffer and must free it */ +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- mbcopy(buffer,(char *)(ce->myaiocb.aio_buf),(size_t)size); +-#else +- mbcopy(buffer,(char *)(ce->myaiocb64.aio_buf),(size_t)size); +-#endif +-#else + mbcopy(buffer,(char *)(ce->myaiocb.aio_buf),(size_t)size); +-#endif + async_put_on_write_queue(gc,ce); + /* +- printf("asw: fd %d offset %lld, size %d\n",ce->myaiocb64.aio_fildes, +- ce->myaiocb64.aio_offset, +- ce->myaiocb64.aio_nbytes); ++ printf("asw: fd %d offset %lld, size %zd\n",ce->myaiocb.aio_fildes, ++ ce->myaiocb.aio_offset, ++ ce->myaiocb.aio_nbytes); + */ + + again: +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- ret=aio_write(&ce->myaiocb); +-#else +- ret=aio_write64(&ce->myaiocb64); +-#endif +-#else + ret=aio_write(&ce->myaiocb); +-#endif + if(ret==-1) + { +@@ -1259,11 +886,11 @@ + else + { +- printf("Error in aio_write: ret %d errno %d count %lld\n",ret,errno,gc->w_count); ++ printf("Error in aio_write: ret %zd errno %d count %lld\n",ret,errno,gc->w_count); + /* +- printf("aio_write_no_copy: fd %d buffer %x offset %lld size %d\n", +- ce->myaiocb64.aio_fildes, +- ce->myaiocb64.aio_buf, +- ce->myaiocb64.aio_offset, +- ce->myaiocb64.aio_nbytes); ++ printf("aio_write_no_copy: fd %d buffer %x offset %lld size %zd\n", ++ ce->myaiocb.aio_fildes, ++ ce->myaiocb.aio_buf, ++ ce->myaiocb.aio_offset, ++ ce->myaiocb.aio_nbytes); + */ + exit(177); +@@ -1289,5 +916,5 @@ + { + struct cache_ent *ce; +- long temp; ++ intptr_t temp; + if(fd==0LL) + { +@@ -1304,44 +931,10 @@ + } + bzero(ce,sizeof(struct cache_ent)); +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ +- ce->myaiocb.aio_fildes=(int)fd; +- ce->myaiocb.aio_offset=(off64_t)offset; +- if(!direct) +- { +- ce->real_address = (char *)malloc((size_t)(size+page_size)); +- temp=(long)ce->real_address; +- temp = (temp+page_size) & ~(page_size-1); +- ce->myaiocb.aio_buf=(volatile void *)temp; +- }else +- { +- ce->myaiocb.aio_buf=(volatile void *)buffer; +- ce->real_address=(char *)free_addr; +- } +- if(ce->myaiocb.aio_buf == 0) +-#else +- ce->myaiocb64.aio_fildes=(int)fd; +- ce->myaiocb64.aio_offset=(off64_t)offset; +- if(!direct) +- { +- ce->real_address = (char *)malloc((size_t)(size+page_size)); +- temp=(long)ce->real_address; +- temp = (temp+page_size) & ~(page_size-1); +- ce->myaiocb64.aio_buf=(volatile void *)temp; +- } +- else +- { +- ce->myaiocb64.aio_buf=(volatile void *)buffer; +- ce->real_address=(char *)free_addr; +- } +- if(ce->myaiocb64.aio_buf == 0) +-#endif +-#else + ce->myaiocb.aio_fildes=(int)fd; + ce->myaiocb.aio_offset=(off_t)offset; + if(!direct) + { +- ce->real_address = (char *)malloc((size_t)(size+page_size)); +- temp=(long)ce->real_address; ++ ce->real_address = malloc((size_t)(size+page_size)); ++ temp = (intptr_t)ce->real_address; + temp = (temp+page_size) & ~(page_size-1); + ce->myaiocb.aio_buf=(volatile void *)temp; +@@ -1353,27 +946,12 @@ + } + if(ce->myaiocb.aio_buf == 0) +-#endif + { + printf("Malloc failed 2\n"); + exit(180); + } +-#ifdef _LARGEFILE64_SOURCE +-#ifdef __LP64__ *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201606221730.u5MHUvTo010891>