/*  * 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