/*

 * Test dataspace operations.

 *

 * Copyright (C) 2020, 2021, 2022 Paul Boddie <paul@boddie.org.uk>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of

 * the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301, USA

 */

#include <l4/re/env.h>

#include <l4/sys/err.h>

#include <systypes/fcntl.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <time.h>

#include <system_error>

#include <thread>

#include <ipc/thread.h>

#include <fsclient/file.h>

#include <mem/memory_utils.h>

/* Test parameters affected by capability limits. */

const unsigned long NUMBER_OF_FILES = 10;

const unsigned int START_LIMIT = 10;

const unsigned int ACTIVITY_ITERATIONS = 20;

/* Test parameters unaffected by any capability limits. */

const unsigned int MAP_PAGES = 20;

const unsigned int REGION_ITERATIONS = 20;

/* An activity opening and reading from a file. */

static long activity(file_t *context, unsigned long fileid, unsigned int start_page)

{

  unsigned long step = page(1);

  unsigned long sample = page(1);

  /* Allocate a buffer for sampling from the file. */

  char buf[sample + 1];

  /* Invoke the open method to receive the file reference. */

  file_t file;

  long err = file_context_open(&file, O_RDONLY, context);

  if (err)

  {

    printf("Could not obtain file for %ld @ page %d: %s\n", fileid, start_page, l4sys_errtostr(err));

    return err;

  }

  /* A region of the file is mapped. */

  err = file_mmap(&file, page(start_page), page(MAP_PAGES), 0, 0, file_region_flags(file.flags));

  if (err)

  {

    printf("Could not map file region for %ld @ page %d: %s\n", fileid, start_page, l4sys_errtostr(err));

    file_close(&file);

    return err;

  }

  /* Read the region a number of times. */

  for (unsigned int read_counter = 0; read_counter < REGION_ITERATIONS; read_counter++)

  {

    for (unsigned long offset = 0; offset < file_populated_span(&file); offset += step)

    {

      unsigned long remaining = file_populated_span(&file) - offset;

      unsigned long sample_remaining = remaining < sample ? remaining : sample;

      strncpy(buf, (file.memory + offset), sample_remaining);

      buf[sample_remaining] = '\0';

      /* Test the data obtained. */

      unsigned long filepos = file.start_pos + offset;

      unsigned long _fileid = 0, _filepos = 0;

      char *sep = strchr(buf, ':');

      if (sep != NULL)

      {

        *sep = '\0'; sep++;

        _fileid = atol(buf); _filepos = atol(sep);

      }

      if ((fileid != _fileid) || (filepos != _filepos))

        printf("! %ld:%ld is not %ld:%ld\n", _fileid, _filepos, fileid, filepos);

    }

  }

  file_close(&file);

  return L4_EOK;

}

static long activity_iterate(file_t *context, unsigned long fileid, unsigned int start_page)

{

  long err;

  /* Open the file, read pages, close the file, over and over. */

  for (unsigned int iteration = 0; iteration < ACTIVITY_ITERATIONS; iteration++)

  {

    err = activity(context, fileid, start_page);

    if (err)

      break;

  }

  return err;

}

static long context_for_file(unsigned long fileid, file_t *file, l4_cap_idx_t server)

{

  long err = file_context(file, server);

  if (err)

  {

    printf("Could not obtain context: %s\n", l4sys_errtostr(err));

    file_close(file);

    return err;

  }

  /* Write the filename. */

  sprintf(file->memory, "%ld", fileid);

  return L4_EOK;

}

int main(void)

{

  long err;

  /* Introduce concurrency control. */

  err = ipc_thread_init();

  if (err)

  {

    printf("Initialisation error: %s\n", l4sys_errtostr(err));

    return 1;

  }

  /* Retain activity and context details. */

  std::thread *activities[NUMBER_OF_FILES * START_LIMIT];

  file_t contexts[NUMBER_OF_FILES];

  /* Obtain access to the filesystem. */

  l4_cap_idx_t server = l4re_env_get_cap("server");

  /* Obtain opener contexts for the files. */

  unsigned long fileid;

  for (fileid = 0; fileid < NUMBER_OF_FILES; fileid++)

  {

    err = context_for_file(fileid, &contexts[fileid], server);

    if (err)

    {

      printf("Context allocation failed.\n");

      return 1;

    }

  }

  /* Start threads accessing all the files. */

  printf("Starting threads...\n");

  time_t t = time(NULL);

  int current = 0;

  unsigned long errors = 0;

  for (fileid = 0; fileid < NUMBER_OF_FILES; fileid++)

  {

    for (unsigned int start_page = 0; start_page < START_LIMIT; start_page++)

    {

      try

      {

        activities[current++] = new std::thread(activity_iterate, &contexts[fileid], fileid, start_page);

      }

      catch (const std::system_error &exc)

      {

        errors++;

      }

    }

  }

  /* Wait for the threads. */

  int limit = current;

  printf("Waiting for %d threads...\n", limit);

  for (current = 0; current < limit; current++)

    activities[current]->join();

  /* Discard the contexts. */

  for (fileid = 0; fileid < NUMBER_OF_FILES; fileid++)

    file_close(&contexts[fileid]);

  t = time(NULL) - t;

  printf("Activities completed in %ld seconds (with %ld threads not started).\n", t, errors);

  return 0;

}

// vim: tabstop=2 expandtab shiftwidth=2