/*

 * Support for executing code in new tasks and threads.

 *

 * Copyright (C) 2022, 2023 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 <exec/common.h>

#include <fsclient/client.h>

#include <fsserver/resource_server.h>

#include <ipc/cap_alloc.h>

#include <ipc/map.h>

#include <systypes/env.h>

#include <systypes/fcntl.h>

#include <stdio.h>

#include "process_creating.h"

/* Process stack configuration. */

static const offset_t initial_stack_size = 16 * L4_PAGESIZE;

/* Initialise the process creator with the details of a region mapper. */

ProcessCreating::ProcessCreating(const char *rm_filename)

: _rm_filename(rm_filename)

{

}

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

   this task so that we may access them, allowing the external pager in this

   task to use them. */

long ProcessCreating::init_region_mapper()

{

  long err = exec_get_payload(_rm_filename, &_rm_payload, true);

  if (err)

    return err;

  _rm_stack = new ExplicitSegment(Utcb_area_start - initial_stack_size, initial_stack_size, L4_FPAGE_RW);

  return _rm_stack->allocate(true);

}

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

long ProcessCreating::init_program(file_t *file)

{

  long err = exec_get_payload_file(file, &_program_payload, false);

  if (err)

    return err;

  _program_stack = new ExplicitSegment(Utcb_area_start - initial_stack_size * 2, initial_stack_size, L4_FPAGE_RW);

  return _program_stack->allocate(true);

}

/* Initialise an external system-level pager serving the region mapper in a

   created task. The allocated regions requested by the region mapper are

   constrained to an area of memory that must not overlap with the area reserved

   for the program being run. */

long ProcessCreating::init_external_pager(l4_cap_idx_t *pager)

{

  _exec_pager = new ExternalPager(0, 10 * L4_PAGESIZE);

  /* 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());

  }

  /* Include the region mapper's stack region. */

  _exec_pager->add(_rm_stack->region());

  _exec_pager->set_payload(_rm_payload);

  _exec_pager->set_stack(_rm_stack);

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

  long err = ResourceServer(_exec_pager).start_thread(pager);

  if (err)

    return err;

  return L4_EOK;

}

/* Configure the environment for the task. */

long ProcessCreating::configure_task(l4_cap_idx_t pager)

{

  l4_cap_idx_t task, mapped_task;

  long err = _process.configure_task(&task, &mapped_task);

  if (err)

    return err;

  /* Record the task details in the pager for eventual resource deallocation. */

  _exec_pager->set_task(task, mapped_task);

  /* Note the pager as the parent of the new task, recording its capability

     details in the new task. */

  l4_cap_idx_t mapped_parent;

  err = _process.set_parent(pager, &mapped_parent);

  if (err)

    return err;

  _exec_pager->set_parent(pager, mapped_parent);

  return L4_EOK;

}

/* Create an unbound IPC gate for the region mapper and allocate it in the

   created process. */

long ProcessCreating::create_ipc_gate()

{

  _ipc_gate_cap = _process.allocate_cap();

  _ipc_gate = ipc_cap_alloc();

  if (l4_is_invalid_cap(_ipc_gate))

    return -L4_ENOMEM;

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

  if (err)

    return err;

  /* The gate is retained because even after being mapped to the new task,

     releasing it will cause it to be deallocated. */

  _exec_pager->set_gate(_ipc_gate);

  return L4_EOK;

}

/* Initialise and assign a region in a list to the created process. */

void ProcessCreating::init_region(struct exec_region *regions,

                                 struct ipc_mapped_cap *mapped_caps,

                                 struct exec_region &r, unsigned int &index)

{

  l4_cap_idx_t mapped_cap = _process.allocate_cap();

  mapped_caps[index] = (struct ipc_mapped_cap) {mapped_cap, r.ds, L4_CAP_FPAGE_RWS, 0};

  /* Change the region definition to use the allocated capability in the created

     process. */

  regions[index] = r;

  regions[index].ds = mapped_cap;

  index++;

}

/* Initialise the region mapper with details of the payload program regions

   and of the associated capabilities, configure the region mapper thread,

   populate its stack, and start the thread. */

long ProcessCreating::start_region_mapper(l4_cap_idx_t pager)

{

  /* Define regions employing dataspaces to provide program segments. */

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

  /* Define capabilities for mapping, including region dataspace capabilities,

     the stack dataspace capability, plus the pager capability. */

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

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

  unsigned int rm_index = 0;

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

  {

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

    if (s->loadable())

      init_region(rm_regions, rm_mapped_caps, s->exec_region(), rm_index);

  }

  /* Introduce the stack region and capability. */

  init_region(rm_regions, rm_mapped_caps, _program_stack->exec_region(), rm_index);

  /* Terminate the region array. */

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

  /* Introduce the server capability and terminate the capability array. */

  rm_mapped_caps[rm_index++] = (struct ipc_mapped_cap) {_ipc_gate_cap, _ipc_gate, L4_CAP_FPAGE_RWS, L4_FPAGE_C_OBJ_RIGHTS};

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

  /* Map these additional capabilities. */

  long err = _process.map_capabilities(rm_mapped_caps, false);

  if (err)

    return err;

  /* 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(ENV_INTERNAL_PAGER_NAME, _ipc_gate_cap, L4_CAP_FPAGE_RWS),

    l4re_env_cap_entry_t()

    };

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

  const char *envp[] = {NULL};

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

     exception handler plus region mapper). */

  l4_cap_idx_t mapped_pager = L4_INVALID_CAP;

  err = _process.configure_thread(pager, &mapped_pager);

  if (err)

    return err;

  _exec_pager->set_pager(pager, mapped_pager);

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

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

  const char *argv[] = {_rm_filename};

  Stack rm_st(*_rm_stack);

  rm_st.set_init_caps(rm_init_caps);

  rm_st.set_regions(rm_regions);

  rm_st.populate(1, argv, envp);

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

  l4_cap_idx_t thread, mapped_thread;

  err = _process.thread_start(_rm_payload->entry_point(), rm_st, &thread, &mapped_thread);

  if (err)

    return err;

  _exec_pager->add_thread(thread, mapped_thread);

  return L4_EOK;

}

/* Configure a thread for a program, populate its stack, and start the

   thread. */

long ProcessCreating::start_program(int argc, const char *argv[])

{

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

  const char *envp[] = {NULL};

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

     exception handler plus region mapper). */

  l4_cap_idx_t mapped_pager = _ipc_gate_cap;

  long err = _process.configure_thread(_ipc_gate, &mapped_pager);

  if (err)

    return err;

  /* Obtain the filesystem capability for exporting to the task. */

  l4_cap_idx_t fsserver_cap = _process.allocate_cap();

  l4_cap_idx_t fsserver = l4re_env_get_cap(ENV_FILESYSTEM_SERVER_NAME);

  /* Define the capabilities to be mapped for the filesystem. */

  struct ipc_mapped_cap program_mapped_caps[] = {

    {fsserver_cap, fsserver, L4_CAP_FPAGE_RWS, L4_FPAGE_C_OBJ_RIGHTS},

    {0, L4_INVALID_CAP, 0, 0},

    };

  /* Map these additional capabilities. */

  err = _process.map_capabilities(program_mapped_caps, false);

  if (err)

    return err;

  /* Define initial capabilities to be acquired by the region mapper via the

     l4re_env API. Each capability index is assigned above when mapping the

     capability and encoded in the entry below. */

  l4re_env_cap_entry_t program_init_caps[] = {

    l4re_env_cap_entry_t(ENV_FILESYSTEM_SERVER_NAME, fsserver_cap, L4_CAP_FPAGE_RWS),

    l4re_env_cap_entry_t()

    };

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

  Stack program_st(*_program_stack);

  program_st.set_init_caps(program_init_caps);

  program_st.populate(argc, argv, envp);

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

  l4_cap_idx_t thread, mapped_thread;

  err = _process.thread_start(_program_payload->entry_point(), program_st, &thread, &mapped_thread);

  if (err)

    return err;

  _exec_pager->add_thread(thread, mapped_thread);

  return L4_EOK;

}

/* Start a new process for the payload indicated by the first of the given

   program arguments, returning a reference to the pager as an object for

   interacting with the process. */

long ProcessCreating::start(int argc, const char *argv[], l4_cap_idx_t *process)

{

  std::lock_guard<std::mutex> guard(_lock);

  /* Open the program file, handling any error conditions. If successfully

     opened, it will be closed when the process terminates. */

  file_t *file = client_open(argv[0], O_RDONLY);

  long err;

  if (file == NULL)

    return -L4_EIO;

  if (!client_opened(file))

  {

    err = file->error;

    client_close(file);

    return err;

  }

  /* Initialise the different elements of the process. */

  err = init_region_mapper();

  if (err)

    return err;

  err = init_program(file);

  if (err)

    return err;

  err = init_external_pager(process);

  if (err)

    return err;

  err = configure_task(*process);

  if (err)

    return err;

  err = create_ipc_gate();

  if (err)

    return err;

  err = start_region_mapper(*process);

  if (err)

    return err;

  err = start_program(argc, argv);

  if (err)

    return err;

  /* Discard instances created to initialise the process. The region mapper

     relies on resources associated with its payload and stack and so these

     cannot be deleted immediately. Instead, they are released when the pager is

     deallocated.

     NOTE: The region mapper payload could be retained instead of being

           reconstructed each time. */

  delete _program_payload;

  delete _program_stack;

  return L4_EOK;

}

/* vim: tabstop=2 expandtab shiftwidth=2

*/