/*

 * Support for executing code in new tasks and threads.

 *

 * Copyright (C) 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 <l4/util/util.h>

#include <exec/elf.h>

#include <exec/external_pager.h>

#include <exec/memory.h>

#include <exec/process.h>

#include <ipc/cap_alloc.h>

#include <ipc/map.h>

#include <ipc/server.h>

#include <stdio.h>

#include <pthread-l4.h>

#include <pthread.h>

#include "pager_object_server.h"

static ExternalPager exec_pager;

static const offset_t initial_stack_size = 16 * L4_PAGESIZE;

/* Start the system pager in a separate thread. */

static long start_pager(ipc_server_config_type &config)

{

  pthread_t pager_thread;

  pthread_attr_t attr;

  pthread_attr_init(&attr);

  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

  ipc_server_init_for(&config, PagerObject, &exec_pager);

  long err = pthread_create(&pager_thread, &attr, ipc_server_start_mainloop, &config);

  if (err)

    return err;

  return ipc_server_start_config_thread(&config, pthread_l4_cap(pager_thread));

}

int main(int argc, char *argv[])

{

  long err;

  if (argc < 3)

  {

    printf("Need a program to run as the region mapper and a main program.\n");

    return 1;

  }

  /* Define the different payloads. */

  char *rm_filename = argv[1];

  char *program_filename = argv[2];

  /* Initialise the memory segments of the region mapper. These are mapped into

     this task so that we may access them. */

  ExplicitSegment rm_stack(Utcb_area_start - initial_stack_size, initial_stack_size, L4_FPAGE_RW);

  Payload *rm_payload;

  if (exec_get_payload(rm_filename, &rm_payload, true))

  {

    printf("Could not initialise region mapper: %s\n", rm_filename);

    return 1;

  }

  if (rm_stack.allocate(true))

  {

    printf("Could not allocate region mapper stack.\n");

    return 1;

  }

  /* Initialise the memory segments of the actual program. These are not mapped

     into this task, instead being accessed by the region mapper in the new

     task. */

  ExplicitSegment program_stack(Utcb_area_start - initial_stack_size * 2, initial_stack_size, L4_FPAGE_RW);

  Payload *program_payload;

  if (exec_get_payload(program_filename, &program_payload, false))

  {

    printf("Could not initialise program: %s\n", program_filename);

    return 1;

  }

  if (program_stack.allocate(true))

  {

    printf("Could not allocate program stack.\n");

    return 1;

  }

  /* Initialise pager regions for the region mapper. */

  for (unsigned int i = 0; i < rm_payload->segments(); i++)

  {

    if (rm_payload->segment(i)->loadable())

      exec_pager.add(rm_payload->segment(i)->region());

  }

  exec_pager.add(rm_stack.region());

  /* Start the pager in a separate thread. */

  ipc_server_config_type config;

  printf("Starting pager thread...\n");

  err = start_pager(config);

  if (err)

  {

    printf("Could not start pager.\n");

    return 1;

  }

  /* Configure the environment for the task, reserving two threads. */

  Process process(2);

  err = process.configure_task();

  if (err)

  {

    printf("Could not configure task.\n");

    return 1;

  }

  /* Configure the environment for the thread, specifying the pager (and

     exception handler plus region mapper). */

  err = process.configure_thread(config.server);

  if (err)

  {

    printf("Could not configure thread.\n");

    return 1;

  }

  /* Create an unbound IPC gate for the region mapper. */

  l4_cap_idx_t ipc_gate = ipc_cap_alloc();

  if (l4_is_invalid_cap(ipc_gate))

  {

    printf("Could not allocate IPC gate capability.\n");

    return 1;

  }

  err = l4_error(l4_factory_create_gate(l4re_env()->factory, ipc_gate, L4_INVALID_CAP, 0));

  if (err)

  {

    printf("Could not create IPC gate.\n");

    return 1;

  }

  /* Define regions employing dataspaces to provide program segments.

     Define capabilities for mapping, including region dataspace capabilities,

     the stack dataspace capability, and the server capability.

     Here, the arrays are sized for the maximum number of regions and

     capabilities, but in practice only the loadable segments are used, leaving

     fewer elements utilised. A terminating entry is employed to indicate the

     limit of utilised elements. */

  struct exec_region rm_regions[rm_payload->segments() + 2];

  struct ipc_mapped_cap rm_mapped_caps[rm_payload->segments() + 3];

  unsigned int rm_index = 0;

  for (unsigned int i = 0; i < rm_payload->segments(); i++)

  {

    Segment *s = rm_payload->segment(i);

    if (s->loadable())

    {

      rm_regions[rm_index] = s->exec_region();

      rm_mapped_caps[rm_index] = (struct ipc_mapped_cap) {process.allocate_cap(), rm_regions[rm_index].ds, L4_CAP_FPAGE_RWS};

      rm_index++;

    }

  }

  /* Introduce the stack region and capability. */

  rm_regions[rm_index] = program_stack.exec_region();

  rm_mapped_caps[rm_index] = (struct ipc_mapped_cap) {process.allocate_cap(), program_stack.exec_region().ds, L4_CAP_FPAGE_RWS};

  rm_index++;

  /* Terminate the region array. */

  rm_regions[rm_index] = (struct exec_region) {0, 0, 0, L4_INVALID_CAP};

  /* Introduce the server capability. */

  l4_cap_idx_t ipc_gate_cap = process.allocate_cap();

  rm_mapped_caps[rm_index] = (struct ipc_mapped_cap) {ipc_gate_cap, ipc_gate, L4_CAP_FPAGE_RWS};

  rm_index++;

  /* Terminate the capability array. */

  rm_mapped_caps[rm_index] = (struct ipc_mapped_cap) {0, L4_INVALID_CAP, 0};

  /* Map these additional capabilities. */

  printf("Map additional capabilities...\n");

  process.map_capabilities(rm_mapped_caps);

  /* Define the IPC gate as an initial capability to be acquired by the region

     mapper via the l4re_env API. The capability index is assigned above when

     mapping the capability and encoded in the entry below. */

  l4re_env_cap_entry_t rm_init_caps[] = {

    l4re_env_cap_entry_t("server", ipc_gate_cap, L4_CAP_FPAGE_RWS),

    l4re_env_cap_entry_t()

    };

  /* NOTE: Environment vector is currently not defined. */

  char *envp[] = {NULL};

  /* Populate a thread stack with argument and environment details for the

     region mapper, plus the initial server capability and region details. */

  printf("Populating region mapper stack...\n");

  Stack rm_st(rm_stack);

  rm_st.set_init_caps(rm_init_caps);

  rm_st.set_regions(rm_regions);

  rm_st.populate(1, argv + 1, envp);

  /* Start the region mapper thread in the appropriate stack. */

  printf("Run region mapper thread...\n");

  err = process.thread_start(rm_payload->entry_point(), rm_st);

  if (err)

  {

    printf("Could not run thread for region mapper.\n");

    return 1;

  }

  /* Configure the environment for the thread, specifying the pager (and

     exception handler plus region mapper). */

  err = process.configure_thread(ipc_gate);

  if (err)

  {

    printf("Could not configure task.\n");

    return 1;

  }

  /* Populate a thread stack with argument and environment details for the

     actual program. The server capability should be assigned to the region

     mapper capability slot already. */

  printf("Populating program stack...\n");

  Stack program_st(program_stack);

  program_st.populate(argc - 2, argv + 2, envp);

  /* Start the program thread in the appropriate stack. */

  printf("Run program thread...\n");

  err = process.thread_start(program_payload->entry_point(), program_st);

  if (err)

  {

    printf("Could not run thread for program.\n");

    return 1;

  }

  printf("Finished.\n");

  while (1)

    l4_sleep_forever();

  return 0;

}

/* vim: tabstop=2 expandtab shiftwidth=2

*/