asynchronous - aio_write() が間違った動作をするのはなぜですか?

Question

aio_write を使用して 2 つのファイルを書き込みたいとします。

32KBのバッファを使用し、1ファイルに対してaio_writeを2048回繰り返します。(ファイルサイズは64MB)

ただし、結果は 64MB ではなく、サイズは 64MB + 32KB になりました。

また、ファイルがガベージで書き込まれることもあります。ファイルに「A」を記入したい。

私を助けてください。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <aio.h>
#include <fcntl.h>
#include <siginfo.h>

#define TNAME           "testAio.c"
#define BUFFER_SIZE     32 * 1024 //(32 * 1024 * 1024)
#define FILE_COUNT      2
#define FILE_PATH       256
#define FALSE           0
#define TRUE            1

int main ()
{
    char           sTmpFileName[FILE_COUNT][FILE_PATH];
    char         * sBuf;
    char         * sAlignedBuf;
    int           sFd[FILE_COUNT];
    struct aiocb  sAiocb[FILE_COUNT];
    int           sError;
    int           sRet;
    int           i;
    int           j;
    int           sWritten[FILE_COUNT];
    int           sWrittenSize;
    int           sWrittenCnt;
    int           sFrequence = 2048;

    sBuf = (char*) malloc( BUFFER_SIZE + 512 );

sAlignedBuf = (char*)( ((long)sBuf) + (512 -  ((long)sBuf) % 512));

    memset( sAlignedBuf, 0x41, BUFFER_SIZE );

    for( i = 0; i < FILE_COUNT; i++ )
    {
        memset( &sAiocb[i], 0, sizeof(struct aiocb) );

        sAiocb[i].aio_buf = sAlignedBuf;
        sAiocb[i].aio_nbytes = BUFFER_SIZE;

        snprintf( sTmpFileName[i],
                  FILE_PATH,
                  "testAio_%d",
                  i);

        unlink( sTmpFileName[i] );

        sFd[i] = open( sTmpFileName[i],
                       O_CREAT | O_RDWR | O_EXCL |
                       O_DIRECT | O_LARGEFILE,
                       S_IRUSR | S_IWUSR );

        sAiocb[i].aio_fildes = sFd[i];

        if( sFd[i] == -1 )
        {
            printf( TNAME " Error at open(): %s\n", strerror( errno ) );
            exit(1);
        }
    }

    for( j = 0; j < sFrequence; j++ )
    {
        for( i = 0; i < FILE_COUNT; i++ )
        {
            if( sWrittenSize = aio_write( &sAiocb[i] ) == -1 )
            {
                printf( TNAME " Error at aio_write(): %s\n", strerror( errno ) );

                close( sFd[i] );

                exit(2);
            }

            sAiocb[i].aio_offset += sAiocb[i].aio_nbytes;

            // printf( "offset %ld\n", sAiocb[i].aio_offset );
        }
    }

    printf( "offset %ld %ld\n",
            sAiocb[0].aio_offset,
            sAiocb[1].aio_offset );

    /* Wait until completion */
    i = 0;
    sWritten[0] = FALSE;
    sWritten[1] = FALSE;
    sWrittenCnt = 0;
    while( 1 )
    {
        sError = aio_error( &sAiocb[i] );

        if( sError != EINPROGRESS )
        {
            if( sWritten[i] == FALSE )
            {
                sWrittenCnt++;
                sWritten[i] = TRUE;
            }
        }

        if( sWrittenCnt == FILE_COUNT )
        {
            break;
        }

        i = (i + 1) % FILE_COUNT;
    }


    for( i = 0; i < FILE_COUNT; i++ )
    {
        sError = aio_error( &sAiocb[i] );
        sRet = aio_return( &sAiocb[i] );

        if( sError != 0 )
        {

            printf( TNAME " Error at aio_error() : %d, %s\n",
                    i,
                    strerror( sError ) );

            close( sFd[i] );

            exit(2);
        }

        if( sRet != BUFFER_SIZE )
        {
            printf( TNAME " Error at aio_return()\n" );

            close( sFd[i] );

            exit(2);
        }
    }

    for( i = 0; i < FILE_COUNT; i++ )
    {
        close( sFd[i] );
    }

    printf( "Test PASSED\n" );

    return 0;
}