Ticket #14755: TestFileAppend.cpp

/******************************************************************************
 * $Header: /CommonBe/agmsmith/Programming/AppendStressTest/RCS/TestFileAppend.cpp,v 1.7 2018/12/07 21:04:42 agmsmith Exp $
 *
 * Stress test the Haiku file systems by repeatedly appending lots of stuff to
 * a file.  Then read it back and see if it has gone corrupt.
 *
 * In more detail, open the file for append, then repeat a few thousand times
 * (number of times specified by a command line argument): write a
 * pseudo-random number of bytes to the end of the file, wait a few seconds.
 * Then reset the pseudo-random number generator and try reading back the same
 * data.
 *
 * The contents of this source code file are MIT licensed.
 *
 * Copyright (c) 2018 by Alexander G. M. Smith.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

/* Standard C Library. */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

/* BeOS Things */

#include <OS.h> // For snooze().
#include <SupportDefs.h> // For bigtime_t.

/* Our global things. */

const int MAX_BUFFER = 0x10000; /* Needs to be a power of 2. */
char g_Buffer [MAX_BUFFER + 1];
char g_CompareBuffer [MAX_BUFFER + 1];
int g_FileHandle = -1;

char g_FileName[128] = "/tmp/AppendTestFile"; // Will append a serial number.


/* Replicate a source string to fill a destination string to a given length.
Doesn't NUL terminate the destination.  Returns the destination string or NULL
if something went wrong (like empty source string or bad pointers). */

char * strreplicate (char *dest, const char *src, int count)
{
  if (count < 0 || dest == NULL || src == NULL || src[0] == 0)
    return NULL;

  const char *SrcPntr = src;
  char *DestPntr = dest;
  char *EndPntr = dest + count;

  while (DestPntr < EndPntr)
  {
    *DestPntr++ = *SrcPntr++;
    if (*SrcPntr == 0)
      SrcPntr = src;
  }
  return dest;
}


/* Express the cycle number as a string and repeat it to fill the buffer to a
random size (from 0 to MAX_BUFFER-1).  Return the random size used. */

int FillBufferWithCycleNumber (int iCycle)
{
  char NumberString [32];
  sprintf (NumberString, "%d ", iCycle);

  int DataSize = random () & (MAX_BUFFER - 1);
  strreplicate (g_Buffer, NumberString, DataSize);
  if (DataSize > 0)
    g_Buffer [DataSize - 1] = '\n';

  return DataSize;
}


/* Opens the test file in append mode, writes a random number of bytes to it
using the iCycle as content (replicates it as an ASCII string to fill
g_Buffer), then closes the file.  Returns 0 on success, an error code if
something goes wrong. */

int WriteAppendCycle (int iCycle)
{
  int ErrorCode = 0;

  int AmountToWrite = FillBufferWithCycleNumber (iCycle);

  ssize_t AmountWritten = write (g_FileHandle, g_Buffer, AmountToWrite);

  if (AmountWritten != AmountToWrite)
  {
    ErrorCode = errno;
    printf ("Write failed on cycle %d, error code %08X (%s).\n",
      iCycle, ErrorCode, strerror (ErrorCode));
  }

  return ErrorCode;
}


/* Read the file to see if the contents match the written cycles. */

int TestContents (int FileHandle, int CycleCount)
{
  int iCycle;
  for (iCycle = 0; iCycle < CycleCount; iCycle++)
  {
    int AmountToRead = FillBufferWithCycleNumber (iCycle);

    ssize_t AmountRead = read (FileHandle, g_CompareBuffer, AmountToRead);

    if (AmountRead != AmountToRead)
    {
      int ErrorCode = errno;
      printf ("Failed while reading cycle %d, error code %08X (%s).\n",
        iCycle, ErrorCode, strerror (ErrorCode));
      return ErrorCode;
    }

    if (memcmp (g_Buffer, g_CompareBuffer, AmountToRead) != 0)
    {
      printf ("Corruption detected!  Contents different for cycle %d.\n",
        iCycle);
      return -1;
    }
  }
  return 0;
}


int main (int argc, char **argv)
{
  // Fix up the file name to have the team number appended so it is unique.

  thread_info MyThreadInfo;
  get_thread_info (find_thread(NULL), &MyThreadInfo);
  sprintf (g_FileName + strlen (g_FileName), "-%d", (int) MyThreadInfo.team);

  if (argc < 2)
  {
    printf ("%s CycleCount [DelaySeconds]

Stress test the appending of data to a file, since there seems to be a
Haiku OS bug related to this in 2018.  The command line argument specifies
the number of write cycles to do.  The file is opened in append mode, then
repeated cycles write a pseudo-random number of bytes from 0 to %d.
There's an optional delay between cycles, specified in seconds (can be a
decimal fraction).  Once all the cycles are done, it reopens the
\"%s\" file and reads it back to see if it is correct.

Written by Alexander G. M. Smith.  MIT licensed.
$Header: /CommonBe/agmsmith/Programming/AppendStressTest/RCS/TestFileAppend.cpp,v 1.7 2018/12/07 21:04:42 agmsmith Exp $
Compiled on " __DATE__ " at " __TIME__ ".\n",
    argv[0], MAX_BUFFER-1, g_FileName);
    return 1;
  }

  int CycleCount = 0;
  double DelaySeconds = 0.0;
  bigtime_t DelayMicroseconds = 0;
  int ErrorCode = 0;
  int iCycle;

  CycleCount = atoi (argv[1]);
  if (CycleCount < 0)
    CycleCount = 0;

  if (argc >= 3)
    DelaySeconds = atof (argv[2]);
  if (DelaySeconds < 0.0)
    DelaySeconds = 0.0;
  DelayMicroseconds = bigtime_t (DelaySeconds * 1000000);

  if (unlink (g_FileName) == 0)
    printf ("Removed \"%s\" from previous run.\n", g_FileName);

  srandom (1234567890); // Reset random number generator to start of sequence.

  printf ("Doing %d append cycles.  Waiting %0.6f seconds between cycles.\n",
    CycleCount, DelaySeconds);

  g_FileHandle = open (g_FileName, O_RDWR | O_APPEND | O_CREAT, 0644);
  if (g_FileHandle < 0)
  {
    ErrorCode = errno;
    printf (
      "Unable to open file \"%s\" for appending, error code %08X (%s).\n",
      g_FileName, ErrorCode, strerror (ErrorCode));
    return 10;
  }

  for (iCycle = 0; iCycle < CycleCount; iCycle++)
  {
    snooze (DelayMicroseconds);
    ErrorCode = WriteAppendCycle (iCycle);
    if (ErrorCode != 0)
      return 10;
    write (STDOUT_FILENO, ".", 1); // Unbuffered, unlike printf.
  }

  close (g_FileHandle);

  printf ("\nReading back the file to see if the contents are correct.\n");

  g_FileHandle = open (g_FileName, O_RDONLY);
  if (g_FileHandle < 0)
  {
    ErrorCode = errno;
    printf (
      "Unable to reopen file \"%s\" for reading, error code %08X (%s).\n",
      g_FileName, ErrorCode, strerror (ErrorCode));
    return 10;
  }

  srandom (1234567890);
  ErrorCode = TestContents (g_FileHandle, CycleCount);

  close (g_FileHandle);

  if (ErrorCode != 0)
    return 10;

  printf ("Test was successful.\n");
  return 0;
}


/******************************************************************************
 * $Log: TestFileAppend.cpp,v $
 * Revision 1.7  2018/12/07 21:04:42  agmsmith
 * Append a serial number to the file name to make it easier to run
 * multiple copies of the test.
 *
 * Revision 1.6  2018/12/05 21:11:01  agmsmith
 * Now open the file for append just once at the beginning, not on
 * every write cycle.  That's how syslog_daemon does it in Haiku.
 *
 * Revision 1.5  2018/12/05 17:07:50  agmsmith
 * Add a time delay between write cycles.
 *
 * Revision 1.4  2018/08/26 16:42:38  agmsmith
 * First working version.
 *
 * Revision 1.3  2018/08/26 14:34:07  agmsmith
 * Wrote the documentation.
 *
 * Revision 1.2  2017/09/28 17:04:44  agmsmith
 * Added RCS headers to the source.
 */