/*

 * A system pager implementation residing in a separate task.

 *

 * 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 <l4/sys/task.h>

#include <l4/util/util.h>

#include <ipc/cap_alloc.h>

#include <ipc/map.h>

#include <ipc/mem_ipc.h>

#include <mem/memory_utils.h>

#include <systypes/base.h>

#include <stdio.h>

#include "external_pager.h"

#include "parent_pager_object_server.h"

#define DEBUG 0

/* A simple system pager also acting as a region mapper. */

ExternalPager::ExternalPager(address_t start, address_t end)

: ExecPager(start, end)

{

}

ipc_server_default_config_type ExternalPager::config()

{

  return config_ParentPagerObject;

}

/* Close the pager. */

void ExternalPager::close()

{

  printf("External pager closing...\n");

  /* Remove pager regions to avoid unmapping them twice. */

  remove(_rm_stack->region());

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

    remove(_rm_payload->segment(i)->region());

  /* Delete the pager resources. */

  if (_rm_payload != NULL)

    delete _rm_payload;

  if (_rm_stack != NULL)

    delete _rm_stack;

  /* Unmap all remaining regions. */

  AvailableMemoryArea::iterator it;

  for (it = _area.begin(); it != _area.end(); it++)

  {

    MemoryArea *r = *it;

    if (r->is_mapped())

      ipc_detach_dataspace((void *) r->dataspace_start());

  }

  /* Free all capabilities. */

  Capabilities::iterator itc;

  for (itc = _dataspaces.begin(); itc != _dataspaces.end(); itc++)

    ipc_cap_free_um(*itc);

  /* Notify the monitor. */

  if (_monitor != NULL)

    _monitor->pager_ended();

}

/* Capability management. */

void ExternalPager::set_pager(l4_cap_idx_t cap, l4_cap_idx_t mapped_cap)

{

  _pager = cap;

  _mapped_pager = mapped_cap;

}

void ExternalPager::set_parent(l4_cap_idx_t cap, l4_cap_idx_t mapped_cap)

{

  _parent = cap;

  _mapped_parent = mapped_cap;

}

void ExternalPager::set_task(l4_cap_idx_t cap, l4_cap_idx_t mapped_cap)

{

  _task = cap;

  _mapped_task = mapped_cap;

}

void ExternalPager::set_thread(l4_cap_idx_t cap, l4_cap_idx_t mapped_cap)

{

  _thread = cap;

  _mapped_thread = mapped_cap;

}

/* Lifecycle management. */

void ExternalPager::set_monitor(ProcessMonitor *monitor)

{

  _monitor = monitor;

}

/* Manage pager resources. */

void ExternalPager::set_payload(Payload *payload)

{

  _rm_payload = payload;

}

void ExternalPager::set_stack(ExplicitSegment *stack)

{

  _rm_stack = stack;

}

/* Handle a general exception. */

long ExternalPager::exception(l4_exc_regs_t regs, l4_snd_fpage_t *region)

{

  (void) region;

  printf("ExternalPager::exception(...) -> pfa = %lx, pc = %lx\n", l4_utcb_exc_pfa(&regs), l4_utcb_exc_pc(&regs));

  while (1)

    l4_sleep_forever();

  return L4_EOK;

}

/* Handle a page fault using any configured regions. */

long ExternalPager::page_fault(l4_umword_t pfa, l4_umword_t pc, l4_snd_fpage_t *region)

{

  l4_umword_t addr = pfa & ~7UL, flags = pfa & 7;

#if DEBUG

  printf("page_fault(%lx, %lx) -> %lx (%lx) -> ", pfa, pc, addr, flags);

#endif

  /* Obtain a region supporting the fault address. */

  MemoryArea *r, *parent;

  long err = _area.find(addr, &r, &parent);

  if (!err)

  {

    l4_addr_t page_addr = trunc(addr, L4_PAGESIZE);

    map_flags_t map_flags = map_flags_for_fault(flags);

    region->fpage = l4_fpage(r->dataspace_start() + (page_addr - r->area_start()), L4_PAGESHIFT, map_flags & r->flags());

    region->snd_base = page_addr;

#if DEBUG

    printf("%lx...%lx from %lx...%lx offset %lx size %d rights %x ds %lx\n",

           r->area_start(), region->snd_base,

           r->dataspace_start(), l4_fpage_memaddr(region->fpage),

           addr - r->area_start(),

           l4_fpage_size(region->fpage),

           l4_fpage_rights(region->fpage),

           r->dataspace());

    printf("%lx -> ", addr);

    for (unsigned int i = 0; i < sizeof(l4_umword_t); i++)

      printf("%02x", *((unsigned char *)(r->dataspace_start() + (addr - r->area_start()) + i)));

    printf("\n");

#endif

    if (r->flags() & L4RE_RM_F_W)

      l4_touch_rw((const void *) (r->dataspace_start() + (page_addr - r->area_start())), L4_PAGESIZE);

    else

      l4_touch_ro((const void *) (r->dataspace_start() + (page_addr - r->area_start())), L4_PAGESIZE);

    return L4_EOK;

  }

  printf("not mapped at %lx for pc %lx\n", addr, pc);

  return err;

}

/* Attach a region for provision when page faults occur. This is required in

   the initialisation of a program by the C library which requires a region

   mapper. */

long ExternalPager::attach(address_t *start, address_t size, map_flags_t flags,

                           l4_cap_idx_t ds, address_t offset,

                           unsigned char align)

{

  // NOTE: Determine the purpose of offset.

  (void) offset;

  MemoryArea *area;

  long err = ExecPager::find(start, &size, flags, align, &area);

  /* Without an error, attach the dataspace. */

  if (!err)

  {

    /* Attach the provided dataspace within this task.

       This is only done in this implementation to support the paging

       mechanism. In a region mapper residing within the actual task, the

       dataspace's map operation would be invoked to obtain mappings. */

    l4_addr_t ds_start;

    err = ipc_attach_dataspace(ds, size, (void **) &ds_start);

    if (err)

      return err;

    l4_touch_rw((const void *) ds_start, size);

    MappedRegion r(*start, *start + size, flags & L4RE_DS_F_RIGHTS_MASK, ds, ds_start);

    area->add(r);

    /* Record dataspaces separately. */

    _dataspaces.insert(ds);

  }

  /* Discard the imported dataspace if its region cannot be accommodated. */

  else

    ipc_cap_free_um(ds);

  return err;

}

/* Receive signals from a task. */

long ExternalPager::signal(unsigned long sig, unsigned long val)

{

  /* Handle the termination event of the internal pager. */

  if (sig == 0)

  {

    printf("Signal from internal pager.\n");

    /* For some reason, threads cannot be released by the process, so they are

       also unmapped on its behalf. */

    if (l4_is_valid_cap(_thread))

    {

      ipc_cap_free_um(_thread);

      ipc_unmap_capability(_task, _mapped_thread);

      _thread = L4_INVALID_CAP;

      /* Parent and pager/region mapper. Freeing the pager after the thread

         should avoid warnings about invalid pager capabilities. */

      ipc_unmap_capability(_task, _mapped_parent);

      ipc_unmap_capability(_task, _mapped_pager);

    }

  }

  return L4_EOK;

}

/* vim: tabstop=2 expandtab shiftwidth=2

*/