sos-code-article7/hwcore/mm_context.c

/* Copyright (C) 2005  David Decotigny

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. 
*/

#include <hwcore/paging.h>
#include <hwcore/irq.h>

#include <sos/assert.h>
#include <sos/list.h>
#include <sos/klibc.h>
#include <sos/physmem.h>
#include <sos/kmem_slab.h>
#include <sos/kmem_vmm.h>

#include "mm_context.h"


/**
 * Definition of an MMU context.
 */
struct sos_mm_context
{
  /** Physical address of the PD for this MMU context */
  sos_paddr_t paddr_PD;

  /** Virtual address where it is mapped into the Kernel space */
  sos_vaddr_t vaddr_PD;

  /** Reference counter for this mm_context */
  sos_ui32_t  ref_cnt;

  /** List of MMU contexts in the system */
  struct sos_mm_context *prev, *next;
};


/**
 * The cache of mm_context structures
 */
struct sos_kslab_cache * cache_struct_mm_context;


/**
 * The current MMU context corresponding to the current configuration
 * of the MMU.
 */
static struct sos_mm_context *current_mm_context = NULL;


/**
 * System-wide list of all the mm_contexts in the system
 */
static struct sos_mm_context *list_mm_context = NULL;
/* The "= NULL" here is FUNDAMENTAL, because paging.c must work
   correctly, ie synch_PDE below must behave reasonably (eg do
   nothing), until the mm_context subsystem has been initialized. */


sos_ret_t sos_mm_context_subsystem_setup()
{
  struct sos_mm_context * initial_mm_context;
  sos_ret_t retval;

  /* Create the new mm_context cache */
  cache_struct_mm_context = sos_kmem_cache_create("struct mm_context",
						  sizeof(struct sos_mm_context),
						  1, 0,
						  SOS_KSLAB_CREATE_MAP);
  if (NULL == cache_struct_mm_context)
    return -SOS_ENOMEM;

  /*
   * Allocate the initial mm_context structure
   */
  initial_mm_context
    = (struct sos_mm_context*) sos_kmem_cache_alloc(cache_struct_mm_context,
						    SOS_KSLAB_ALLOC_ATOMIC);
  if (NULL == initial_mm_context)
    return -SOS_ENOMEM;

  /* Retrieve the address of the current page where the PD lies */
  initial_mm_context->paddr_PD = sos_paging_get_current_PD_paddr();

  /*
   * Map it somewhere in kernel virtual memory
   */

  /* Allocate 1 page of kernel Virtual memory */
  initial_mm_context->vaddr_PD = sos_kmem_vmm_alloc(1, 0);
  if (initial_mm_context->vaddr_PD == 0)
    return -SOS_ENOMEM;

  /* Map the PD at this virtual address: it will thus be mapped 2
     times (1 time for the mirroring, 1 time for mm_context) ! */
  retval = sos_paging_map(initial_mm_context->paddr_PD,
			  initial_mm_context->vaddr_PD,
			  FALSE,
			  SOS_VM_MAP_PROT_READ
			  | SOS_VM_MAP_PROT_WRITE);
  if (SOS_OK != retval)
    return retval;

  /* Initialize the initial list of mm_contexts */
  list_singleton(list_mm_context, initial_mm_context);

  /* We just created this mm_context: mark it as "referenced" */
  initial_mm_context->ref_cnt ++;

  /* We are actually already using it ! */
  initial_mm_context->ref_cnt ++; /* ie reference it a 2nd time ! */
  current_mm_context = initial_mm_context;

  return SOS_OK;
}


struct sos_mm_context * sos_mm_context_create(void)
{
  sos_ui32_t flags;
  struct sos_mm_context *mmctxt;

  /*
   * Allocate the initial mm_context structure
   */
  mmctxt = (struct sos_mm_context*) sos_kmem_cache_alloc(cache_struct_mm_context, 0);
  if (NULL == mmctxt)
    return NULL;

  /* Allocate a new page for the new PD and map it into the kernel */
  mmctxt->vaddr_PD = sos_kmem_vmm_alloc(1, SOS_KMEM_VMM_MAP);
  if (mmctxt->vaddr_PD == 0)
    {
      sos_kmem_cache_free((sos_vaddr_t) mmctxt);
      return NULL;
    }

  /* Retrieve its physical address */
  mmctxt->paddr_PD = sos_paging_get_paddr(mmctxt->vaddr_PD);
  if (mmctxt->paddr_PD == 0)
    {
      sos_kmem_cache_free((sos_vaddr_t) mmctxt);
      return NULL;
    }

  /* Copy the current hardware MMU address translation tables */
  if (SOS_OK != sos_paging_copy_kernel_space(mmctxt->vaddr_PD,
					     current_mm_context->vaddr_PD))
    {
      sos_kmem_cache_free((sos_vaddr_t) mmctxt);
      return NULL;
    }

  /* Mark the mm_context as "referenced" */
  mmctxt->ref_cnt = 1;

  /* Add it to the list of MMU contexts */
  sos_disable_IRQs(flags);
  list_add_tail(list_mm_context, mmctxt);
  sos_restore_IRQs(flags);

  return mmctxt;
}


sos_ret_t sos_mm_context_unref(struct sos_mm_context *mmctxt)
{
  sos_ui32_t flags;

  sos_disable_IRQs(flags);

  /* A valid mmctxt is one which is not yet unreferenced */
  SOS_ASSERT_FATAL(mmctxt->ref_cnt > 0);

  /* Unreference it */
  mmctxt->ref_cnt --;

  /* If somebody is still using it, don't release it now */
  if (mmctxt->ref_cnt > 0)
    {
      sos_restore_IRQs(flags);
      return SOS_OK;
    }

  /* If nobody uses it, then it cannot be the current mm_context ! */
  SOS_ASSERT_FATAL(mmctxt != current_mm_context);

  /* Remove it from the list of mm_contexts */
  list_delete(list_mm_context, mmctxt);

  sos_restore_IRQs(flags);

  /* Remove all user mappings (if any) */
  sos_paging_dispose(mmctxt->vaddr_PD);

  /* Unmap the PD from the kernel */
  sos_kmem_vmm_free(mmctxt->vaddr_PD);

  memset(mmctxt, 0x0, sizeof(*mmctxt));

  return SOS_OK;
}


sos_ret_t sos_mm_context_ref(struct sos_mm_context *mmctxt)
{
  sos_ui32_t flags;

  sos_disable_IRQs(flags);

  /* A valid mmctxt is one which is not yet unreferenced */
  SOS_ASSERT_FATAL(mmctxt->ref_cnt > 0);

  /* Reference it once again */
  mmctxt->ref_cnt ++;

  sos_restore_IRQs(flags);

  return SOS_OK;
}


sos_ret_t sos_mm_context_switch_to(struct sos_mm_context *mmctxt)
{
  SOS_ASSERT_FATAL(NULL != mmctxt);
  SOS_ASSERT_FATAL(mmctxt->ref_cnt > 0);
  SOS_ASSERT_FATAL(current_mm_context->ref_cnt > 0);
  if (mmctxt != current_mm_context)
    {
      sos_ui32_t flags;
      struct sos_mm_context * prev_mm_context = current_mm_context;

      /* This is the most dangerous part of the whole thing. If we set
	 the wrong MMU configuration in mmctxt, this will hang or
	 reboot the machine... */
      sos_paging_set_current_PD_paddr(mmctxt->paddr_PD);

      /* Exchange the mm_contexts */
      current_mm_context = mmctxt;

      /* Update the reference counts */
      sos_disable_IRQs(flags);
      mmctxt->ref_cnt ++;
      sos_mm_context_unref(prev_mm_context);
      sos_restore_IRQs(flags);
    }

  return SOS_OK;
}


struct sos_mm_context *get_current_mm_context()
{
  SOS_ASSERT_FATAL(current_mm_context->ref_cnt > 0);
  return current_mm_context;
}


/* ******************************************************
 * Reserved functions
 */


sos_ret_t sos_mm_context_synch_kernel_PDE(unsigned int index_in_pd,
					  sos_ui32_t pde)
{
  sos_ui32_t flags;
  struct sos_mm_context * dest_mm_context;
  int nb_mm_contexts;

  sos_disable_IRQs(flags);
  list_foreach_forward(list_mm_context, dest_mm_context, nb_mm_contexts)
    {
      sos_ui32_t * dest_pd;

      SOS_ASSERT_FATAL(dest_mm_context->ref_cnt > 0);

      dest_pd = (sos_ui32_t*) dest_mm_context->vaddr_PD;
      dest_pd[index_in_pd] = pde;
    }
  sos_restore_IRQs(flags);

  return SOS_OK;
}