Diff markup

Differences between /sos/umem_vmm.c (Article 9) and /sos/umem_vmm.c (Article 9.5)

 /* Copyright (C) 2005 David Decotigny          !!  /* Copyright (C) 2005,2006 David Decotigny
                                                    
    This program is free software; you can redi        This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Genera        modify it under the terms of the GNU General Public License
    as published by the Free Software Foundatio        as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any lat        of the License, or (at your option) any later version.
                                                       
    This program is distributed in the hope tha        This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the         but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details        GNU General Public License for more details.
                                                       
    You should have received a copy of the GNU         You should have received a copy of the GNU General Public License
    along with this program; if not, write to t        along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 3        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA.                                               USA. 
 */                                                 */
                                                    
 #include <sos/assert.h>                            #include <sos/assert.h>
 #include <sos/list.h>                              #include <sos/list.h>
 #include <sos/physmem.h>                           #include <sos/physmem.h>
 #include <sos/kmem_slab.h>                         #include <sos/kmem_slab.h>
 #include <drivers/bochs.h>                         #include <drivers/bochs.h>
 #include <hwcore/mm_context.h>                     #include <hwcore/mm_context.h>
 #include <hwcore/paging.h>                         #include <hwcore/paging.h>
 #include <drivers/zero.h>                          #include <drivers/zero.h>
                                                    
 #include "umem_vmm.h"                              #include "umem_vmm.h"
                                                    
                                                    
 struct sos_umem_vmm_as                             struct sos_umem_vmm_as
 {                                                  {
   /** The process that owns this address space       /** The process that owns this address space */
   struct sos_process     * process;                  struct sos_process     * process;
                                                    
   /** The MMU configuration of this address sp       /** The MMU configuration of this address space */
   struct sos_mm_context  * mm_context;               struct sos_mm_context  * mm_context;
                                                    
   /** The list of VRs in this address space */       /** The list of VRs in this address space */
   struct sos_umem_vmm_vr * list_vr;                  struct sos_umem_vmm_vr * list_vr;
                                                    
   /** Heap location */                               /** Heap location */
   sos_uaddr_t heap_start;                            sos_uaddr_t heap_start;
   sos_size_t  heap_size; /**< Updated by sos_u       sos_size_t  heap_size; /**< Updated by sos_umem_vmm_brk() */
                                                    
   /* Memory usage statistics */                      /* Memory usage statistics */
   sos_size_t phys_total; /* shared + private *       sos_size_t phys_total; /* shared + private */
   struct vm_usage                                    struct vm_usage
   {                                                  {
     sos_size_t overall;                                sos_size_t overall;
     sos_size_t ro, rw, code /* all: non readab         sos_size_t ro, rw, code /* all: non readable, read and read/write */;
   } vm_total, vm_shrd;                               } vm_total, vm_shrd;
                                                    
   /* Page fault counters */                          /* Page fault counters */
   sos_size_t pgflt_cow;                              sos_size_t pgflt_cow;
   sos_size_t pgflt_page_in;                          sos_size_t pgflt_page_in;
   sos_size_t pgflt_invalid;                          sos_size_t pgflt_invalid;
 };                                                 };
                                                    
                                                    
 struct sos_umem_vmm_vr                             struct sos_umem_vmm_vr
 {                                                  {
   /** The address space owning this VR */            /** The address space owning this VR */
   struct sos_umem_vmm_as *address_space;             struct sos_umem_vmm_as *address_space;
                                                    
   /** The location of the mapping in user spac       /** The location of the mapping in user space */
   sos_uaddr_t start;                                 sos_uaddr_t start;
   sos_size_t  size;                                  sos_size_t  size;
                                                    
   /** What accesses are allowed (read, write,        /** What accesses are allowed (read, write, exec): @see
       SOS_VM_MAP_PROT_* flags in hwcore/paging           SOS_VM_MAP_PROT_* flags in hwcore/paging.h */
   sos_ui32_t  access_rights;                         sos_ui32_t  access_rights;
                                                    
   /** Flags of the VR. Allowed flags:                /** Flags of the VR. Allowed flags:
    *  - SOS_VR_MAP_SHARED                             *  - SOS_VR_MAP_SHARED
    */                                                 */
   sos_ui32_t  flags;                                 sos_ui32_t  flags;
                                                    
   /**                                                /**
    * The callbacks for the VR called along map        * The callbacks for the VR called along map/unmapping of the
    * resource                                         * resource
    */                                                 */
   struct sos_umem_vmm_vr_ops *ops;                   struct sos_umem_vmm_vr_ops *ops;
                                                    
   /** Description of the resource being mapped       /** Description of the resource being mapped, if any */
   struct sos_umem_vmm_mapped_resource *mapped_       struct sos_umem_vmm_mapped_resource *mapped_resource;
   sos_luoffset_t offset_in_resource;                 sos_luoffset_t offset_in_resource;
                                                    
   /** The VRs of an AS are linked together and       /** The VRs of an AS are linked together and are accessible by way
       of as->list_vr */                                  of as->list_vr */
   struct sos_umem_vmm_vr *prev_in_as, *next_in       struct sos_umem_vmm_vr *prev_in_as, *next_in_as;
                                                    
   /** The VRs mapping a given resource are lin       /** The VRs mapping a given resource are linked together and are
       accessible by way of mapped_resource->li           accessible by way of mapped_resource->list_vr */
   struct sos_umem_vmm_vr *prev_in_mapped_resou       struct sos_umem_vmm_vr *prev_in_mapped_resource, *next_in_mapped_resource;
 };                                                 };
                                                    
                                                    
 /*                                                 /*
  * We use special slab caches to allocate AS a      * We use special slab caches to allocate AS and VR data structures
  */                                                 */
 static struct sos_kslab_cache * cache_of_as;       static struct sos_kslab_cache * cache_of_as;
 static struct sos_kslab_cache * cache_of_vr;       static struct sos_kslab_cache * cache_of_vr;
                                                    
                                                    
 /** Temporary function to debug: list the VRs      /** Temporary function to debug: list the VRs of the given As */
 void sos_dump_as(const struct sos_umem_vmm_as      void sos_dump_as(const struct sos_umem_vmm_as * as, const char *str)
 {                                                  {
   struct sos_umem_vmm_vr *vr;                        struct sos_umem_vmm_vr *vr;
   int nb_vr;                                         int nb_vr;
                                                    
   sos_bochs_printf("AS %p - %s:\n", as, str);        sos_bochs_printf("AS %p - %s:\n", as, str);
   sos_bochs_printf("   physical mem: %x\n",          sos_bochs_printf("   physical mem: %x\n",
                    as->phys_total);                                   as->phys_total);
   sos_bochs_printf("   VM (all/ro+rw/exec) tot       sos_bochs_printf("   VM (all/ro+rw/exec) tot:%x/%x+%x/%x shrd:%x/%x+%x/%x\n",
                    as->vm_total.overall,                              as->vm_total.overall,
                    as->vm_total.ro, as->vm_tot                        as->vm_total.ro, as->vm_total.rw, as->vm_total.code,
                    as->vm_shrd.overall,                               as->vm_shrd.overall,
                    as->vm_shrd.ro, as->vm_shrd                        as->vm_shrd.ro, as->vm_shrd.rw, as->vm_shrd.code);
   sos_bochs_printf("   pgflt cow=%d pgin=%d in       sos_bochs_printf("   pgflt cow=%d pgin=%d inv=%d\n",
                    as->pgflt_cow, as->pgflt_pa                        as->pgflt_cow, as->pgflt_page_in, as->pgflt_invalid);
   list_foreach_named(as->list_vr, vr, nb_vr, p       list_foreach_named(as->list_vr, vr, nb_vr, prev_in_as, next_in_as)
     {                                                  {
       sos_bochs_printf("  VR[%d]=%x: [%x,%x[ (           sos_bochs_printf("  VR[%d]=%x: [%x,%x[ (sz=%x) mr=(%x)+%llx %c%c%c fl=%x\n",
                        nb_vr, (unsigned)vr,                               nb_vr, (unsigned)vr,
                        vr->start, vr->start +                             vr->start, vr->start + vr->size, vr->size,
                        (unsigned)vr->mapped_re                            (unsigned)vr->mapped_resource,
                        vr->offset_in_resource,                            vr->offset_in_resource,
                        (vr->access_rights & SO                            (vr->access_rights & SOS_VM_MAP_PROT_READ)?'r':'-',
                        (vr->access_rights & SO                            (vr->access_rights & SOS_VM_MAP_PROT_WRITE)?'w':'-',
                        (vr->access_rights & SO                            (vr->access_rights & SOS_VM_MAP_PROT_EXEC)?'x':'-',
                        (unsigned)vr->flags);                              (unsigned)vr->flags);
     }                                                  }
   sos_bochs_printf("FIN (%s)\n", str);               sos_bochs_printf("FIN (%s)\n", str);
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * Physical address of THE page (full of 0s) u      * Physical address of THE page (full of 0s) used for anonymous
  * mappings                                         * mappings
  */                                                 */
 sos_paddr_t sos_zero_physpage = 0 /* Initial v     sos_paddr_t sos_zero_physpage = 0 /* Initial value prior to allocation */;
 sos_vaddr_t sos_zero_kernelpage = 0 /* Initial     sos_vaddr_t sos_zero_kernelpage = 0 /* Initial value prior to allocation */;
                                                    
                                                    
 /*                                                 /*
  * Helper functions defined at the bottom of t      * Helper functions defined at the bottom of the file
  */                                                 */
                                                    
 /**                                                /**
  * Helper function to retrieve the first VR to      * Helper function to retrieve the first VR to have a vr->end >= uaddr
  */                                                 */
 static struct sos_umem_vmm_vr *                    static struct sos_umem_vmm_vr *
 find_enclosing_or_next_vr(struct sos_umem_vmm_     find_enclosing_or_next_vr(struct sos_umem_vmm_as * as,
                           sos_uaddr_t uaddr);                                sos_uaddr_t uaddr);
                                                    
                                                    
 /**                                                /**
  * Helper function to retrieve the first VR th      * Helper function to retrieve the first VR that overlaps the given
  * interval, if any                                 * interval, if any
  */                                                 */
 static struct sos_umem_vmm_vr *                    static struct sos_umem_vmm_vr *
 find_first_intersecting_vr(struct sos_umem_vmm     find_first_intersecting_vr(struct sos_umem_vmm_as * as,
                            sos_uaddr_t start_u                                sos_uaddr_t start_uaddr, sos_size_t size);
                                                    
                                                    
 /**                                                /**
  * Helper function to find first address where      * Helper function to find first address where there is enough
  * space. Begin to look for such an interval a      * space. Begin to look for such an interval at or after the given
  * address                                          * address
  *                                                  *
  * @param hint_addr The address where to begin      * @param hint_addr The address where to begin the scan, or NULL
  */                                                 */
 static sos_uaddr_t                                 static sos_uaddr_t
 find_first_free_interval(struct sos_umem_vmm_a     find_first_free_interval(struct sos_umem_vmm_as * as,
                          sos_uaddr_t hint_uadd                              sos_uaddr_t hint_uaddr, sos_size_t size);
                                                    
                                                    
 /** Called each time a VR of the AS changes. D     /** Called each time a VR of the AS changes. Don't cope with any
     underlying physcal mapping/unmapping, COW,         underlying physcal mapping/unmapping, COW, etc... */
 static void                                        static void
 as_account_change_of_vr_protection(struct sos_     as_account_change_of_vr_protection(struct sos_umem_vmm_as * as,
                                    sos_bool_t                                         sos_bool_t is_shared,
                                    sos_size_t                                         sos_size_t size,
                                    sos_ui32_t                                         sos_ui32_t prev_access_rights,
                                    sos_ui32_t                                         sos_ui32_t new_access_rights);
                                                    
                                                    
 sos_ret_t sos_umem_vmm_subsystem_setup()           sos_ret_t sos_umem_vmm_subsystem_setup()
 {                                                  {
   /* Allocate a new kernel physical page mappe       /* Allocate a new kernel physical page mapped into kernel space and
      reset it with 0s */                                reset it with 0s */
   sos_zero_kernelpage = sos_kmem_vmm_alloc(1,        sos_zero_kernelpage = sos_kmem_vmm_alloc(1, SOS_KMEM_VMM_MAP);
   if (sos_zero_kernelpage == (sos_vaddr_t)NULL       if (sos_zero_kernelpage == (sos_vaddr_t)NULL)
     return -SOS_ENOMEM;                                return -SOS_ENOMEM;
   memset((void*)sos_zero_kernelpage, 0x0, SOS_       memset((void*)sos_zero_kernelpage, 0x0, SOS_PAGE_SIZE);
                                                      
   /* Keep a reference to the underlying pphysi       /* Keep a reference to the underlying pphysical page... */
   sos_zero_physpage = sos_paging_get_paddr(sos       sos_zero_physpage = sos_paging_get_paddr(sos_zero_kernelpage);
   SOS_ASSERT_FATAL(NULL != (void*)sos_zero_phy       SOS_ASSERT_FATAL(NULL != (void*)sos_zero_physpage);
   sos_physmem_ref_physpage_at(sos_zero_physpag       sos_physmem_ref_physpage_at(sos_zero_physpage);
                                                    
   /* Allocate the VR/AS caches */                    /* Allocate the VR/AS caches */
   cache_of_as                                        cache_of_as
     = sos_kmem_cache_create("Address space str         = sos_kmem_cache_create("Address space structures",
                             sizeof(struct sos_                                 sizeof(struct sos_umem_vmm_as),
                             1, 0,                                              1, 0,
                             SOS_KSLAB_CREATE_M                                 SOS_KSLAB_CREATE_MAP
                             | SOS_KSLAB_CREATE                                 | SOS_KSLAB_CREATE_ZERO);
   if (! cache_of_as)                                 if (! cache_of_as)
     {                                                  {
       sos_physmem_unref_physpage(sos_zero_phys           sos_physmem_unref_physpage(sos_zero_physpage);
       return -SOS_ENOMEM;                                return -SOS_ENOMEM;
     }                                                  }
                                                    
   cache_of_vr                                        cache_of_vr
     = sos_kmem_cache_create("Virtual Region st         = sos_kmem_cache_create("Virtual Region structures",
                             sizeof(struct sos_                                 sizeof(struct sos_umem_vmm_vr),
                             1, 0,                                              1, 0,
                             SOS_KSLAB_CREATE_M                                 SOS_KSLAB_CREATE_MAP
                             | SOS_KSLAB_CREATE                                 | SOS_KSLAB_CREATE_ZERO);
   if (! cache_of_vr)                                 if (! cache_of_vr)
     {                                                  {
       sos_physmem_unref_physpage(sos_zero_phys           sos_physmem_unref_physpage(sos_zero_physpage);
       sos_kmem_cache_destroy(cache_of_as);               sos_kmem_cache_destroy(cache_of_as);
       return -SOS_ENOMEM;                                return -SOS_ENOMEM;
     }                                                  }
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 struct sos_umem_vmm_as *                           struct sos_umem_vmm_as *
 sos_umem_vmm_create_empty_as(struct sos_proces     sos_umem_vmm_create_empty_as(struct sos_process *owner)
 {                                                  {
   struct sos_umem_vmm_as * as                        struct sos_umem_vmm_as * as
     = (struct sos_umem_vmm_as *) sos_kmem_cach         = (struct sos_umem_vmm_as *) sos_kmem_cache_alloc(cache_of_as, 0);
   if (! as)                                          if (! as)
     return NULL;                                       return NULL;
                                                    
   as->mm_context = sos_mm_context_create();          as->mm_context = sos_mm_context_create();
   if (NULL == as->mm_context)                        if (NULL == as->mm_context)
     {                                                  {
       /* Error */                                        /* Error */
       sos_kmem_cache_free((sos_vaddr_t)as);              sos_kmem_cache_free((sos_vaddr_t)as);
       return NULL;                                       return NULL;
     }                                                  }
                                                    
   as->process = owner;                               as->process = owner;
   return as;                                         return as;
 }                                                  }
                                                    
                                                    
 struct sos_umem_vmm_as *                           struct sos_umem_vmm_as *
 sos_umem_vmm_duplicate_current_thread_as(struc     sos_umem_vmm_duplicate_current_thread_as(struct sos_process *owner)
 {                                                  {
   __label__ undo_creation;                           __label__ undo_creation;
   struct sos_umem_vmm_as * my_as;                    struct sos_umem_vmm_as * my_as;
   struct sos_umem_vmm_vr * model_vr;                 struct sos_umem_vmm_vr * model_vr;
   int nb_vr;                                         int nb_vr;
                                                    
   struct sos_umem_vmm_as * new_as                    struct sos_umem_vmm_as * new_as
     = (struct sos_umem_vmm_as *) sos_kmem_cach         = (struct sos_umem_vmm_as *) sos_kmem_cache_alloc(cache_of_as, 0);
   if (! new_as)                                      if (! new_as)
     return NULL;                                       return NULL;
                                                    
   my_as = sos_process_get_address_space(sos_th       my_as = sos_process_get_address_space(sos_thread_get_current()->process);
   new_as->process = owner;                           new_as->process = owner;
   list_init_named(new_as->list_vr, prev_in_as,       list_init_named(new_as->list_vr, prev_in_as, next_in_as);
                                                    
   /*                                                 /*
    * Switch to the current threads' mm_context        * Switch to the current threads' mm_context, as duplicating it implies
    * being able to configure some of its mappi        * being able to configure some of its mappings as read-only (for
    * COW)                                             * COW)
    */                                                 */
   SOS_ASSERT_FATAL(SOS_OK                            SOS_ASSERT_FATAL(SOS_OK
                    == sos_thread_prepare_user_                        == sos_thread_prepare_user_space_access(my_as,
                                                                                                               (sos_vaddr_t)
                                                                                                                 NULL));
                                                    
   /* Copy the virtual regions */                     /* Copy the virtual regions */
   list_foreach_named(my_as->list_vr, model_vr,       list_foreach_named(my_as->list_vr, model_vr, nb_vr, prev_in_as, next_in_as)
     {                                                  {
       struct sos_umem_vmm_vr * vr;                       struct sos_umem_vmm_vr * vr;
                                                    
       /* Prepare COW on the read/write private           /* Prepare COW on the read/write private mappings */
       if ( !(model_vr->flags & SOS_VR_MAP_SHAR           if ( !(model_vr->flags & SOS_VR_MAP_SHARED)
            && (model_vr->access_rights & SOS_V                && (model_vr->access_rights & SOS_VM_MAP_PROT_WRITE) )
         {                                                  {
           /* Mark the underlying physical page               /* Mark the underlying physical pages (if any) as
              read-only */                                       read-only */
           SOS_ASSERT_FATAL(SOS_OK                            SOS_ASSERT_FATAL(SOS_OK
                            == sos_paging_prepa                                == sos_paging_prepare_COW(model_vr->start,
                                                                                                         model_vr->size));
         }                                                  }
                                                    
       /* Allocate a new virtual region and cop           /* Allocate a new virtual region and copy the 'model' into it */
       vr = (struct sos_umem_vmm_vr *) sos_kmem           vr = (struct sos_umem_vmm_vr *) sos_kmem_cache_alloc(cache_of_vr, 0);
       if (! vr)                                          if (! vr)
         goto undo_creation;                                goto undo_creation;
       memcpy(vr, model_vr, sizeof(*vr));                 memcpy(vr, model_vr, sizeof(*vr));
       vr->address_space = new_as;                        vr->address_space = new_as;
                                                    
       /* Signal the "new" mapping to the under           /* Signal the "new" mapping to the underlying VR mapper */
       if (vr->ops && vr->ops->ref)                       if (vr->ops && vr->ops->ref)
         vr->ops->ref(vr);                                  vr->ops->ref(vr);
                                                    
       /* Insert the new VR into the new AS */            /* Insert the new VR into the new AS */
       list_add_tail_named(new_as->list_vr, vr,           list_add_tail_named(new_as->list_vr, vr, prev_in_as, next_in_as);
                                                    
       /* Insert the new VR into the list of ma           /* Insert the new VR into the list of mappings of the resource */
       list_add_tail_named(model_vr->mapped_res           list_add_tail_named(model_vr->mapped_resource->list_vr, vr,
                           prev_in_mapped_resou                               prev_in_mapped_resource,
                           next_in_mapped_resou                               next_in_mapped_resource);
     }                                                  }
                                                    
   /* Now copy the current MMU configuration */       /* Now copy the current MMU configuration */
   new_as->mm_context = sos_mm_context_duplicat       new_as->mm_context = sos_mm_context_duplicate(my_as->mm_context);
   if (NULL == new_as->mm_context)                    if (NULL == new_as->mm_context)
     goto undo_creation;                                goto undo_creation;
                                                    
   /* Correct behavior */                             /* Correct behavior */
   new_as->heap_start = my_as->heap_start;            new_as->heap_start = my_as->heap_start;
   new_as->heap_size  = my_as->heap_size;             new_as->heap_size  = my_as->heap_size;
   new_as->phys_total = my_as->phys_total;            new_as->phys_total = my_as->phys_total;
   memcpy(& new_as->vm_total, & my_as->vm_total       memcpy(& new_as->vm_total, & my_as->vm_total, sizeof(struct vm_usage));
   memcpy(& new_as->vm_shrd, & my_as->vm_shrd,        memcpy(& new_as->vm_shrd, & my_as->vm_shrd, sizeof(struct vm_usage));
   SOS_ASSERT_FATAL(SOS_OK == sos_thread_end_us       SOS_ASSERT_FATAL(SOS_OK == sos_thread_end_user_space_access());
   return new_as;                                     return new_as;
                                                    
   /* Handle erroneous behavior */                    /* Handle erroneous behavior */
  undo_creation:                                     undo_creation:
   SOS_ASSERT_FATAL(SOS_OK == sos_thread_end_us       SOS_ASSERT_FATAL(SOS_OK == sos_thread_end_user_space_access());
   sos_umem_vmm_delete_as(new_as);                    sos_umem_vmm_delete_as(new_as);
   return NULL;                                       return NULL;
 }                                                  }
                                                    
                                                    
 sos_ret_t                                          sos_ret_t
 sos_umem_vmm_delete_as(struct sos_umem_vmm_as      sos_umem_vmm_delete_as(struct sos_umem_vmm_as * as)
 {                                                  {
   while(! list_is_empty_named(as->list_vr, pre       while(! list_is_empty_named(as->list_vr, prev_in_as, next_in_as))
     {                                                  {
       struct sos_umem_vmm_vr * vr;                       struct sos_umem_vmm_vr * vr;
       vr = list_get_head_named(as->list_vr, pr           vr = list_get_head_named(as->list_vr, prev_in_as, next_in_as);
                                                    
       /* Remove the vr from the lists */                 /* Remove the vr from the lists */
       list_pop_head_named(as->list_vr, prev_in           list_pop_head_named(as->list_vr, prev_in_as, next_in_as);
       list_delete_named(vr->mapped_resource->l           list_delete_named(vr->mapped_resource->list_vr, vr,
                         prev_in_mapped_resourc                             prev_in_mapped_resource,
                         next_in_mapped_resourc                             next_in_mapped_resource);
                                                    
       /* Signal to the underlying VR mapper th           /* Signal to the underlying VR mapper that the mapping is
          suppressed */                                      suppressed */
       if (vr->ops)                                       if (vr->ops)
         {                                                  {
           if (vr->ops->unmap)                                if (vr->ops->unmap)
             vr->ops->unmap(vr, vr->start, vr->                 vr->ops->unmap(vr, vr->start, vr->size);
           if (vr->ops->unref)                                if (vr->ops->unref)
             vr->ops->unref(vr);                                vr->ops->unref(vr);
         }                                                  }
                                                    
       sos_kmem_cache_free((sos_vaddr_t)vr);              sos_kmem_cache_free((sos_vaddr_t)vr);
     }                                                  }
                                                      
   /* Release MMU configuration */                    /* Release MMU configuration */
   if (as->mm_context)                                if (as->mm_context)
     sos_mm_context_unref(as->mm_context);              sos_mm_context_unref(as->mm_context);
                                                    
   /* Now unallocate main address space constru       /* Now unallocate main address space construct */
   sos_kmem_cache_free((sos_vaddr_t)as);              sos_kmem_cache_free((sos_vaddr_t)as);
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 struct sos_process *                               struct sos_process *
 sos_umem_vmm_get_process(struct sos_umem_vmm_a     sos_umem_vmm_get_process(struct sos_umem_vmm_as * as)
 {                                                  {
   return as->process;                                return as->process;
 }                                                  }
                                                    
                                                    
 struct sos_mm_context *                            struct sos_mm_context *
 sos_umem_vmm_get_mm_context(struct sos_umem_vm     sos_umem_vmm_get_mm_context(struct sos_umem_vmm_as * as)
 {                                                  {
   return as->mm_context;                             return as->mm_context;
 }                                                  }
                                                    
                                                    
 struct sos_umem_vmm_vr *                           struct sos_umem_vmm_vr *
 sos_umem_vmm_get_vr_at_address(struct sos_umem     sos_umem_vmm_get_vr_at_address(struct sos_umem_vmm_as * as,
                                sos_uaddr_t uad                                    sos_uaddr_t uaddr)
 {                                                  {
   struct sos_umem_vmm_vr * vr;                       struct sos_umem_vmm_vr * vr;
   vr = find_enclosing_or_next_vr(as, uaddr);         vr = find_enclosing_or_next_vr(as, uaddr);
   if (! vr)                                          if (! vr)
     return NULL;                                       return NULL;
                                                    
   /* Ok uaddr <= vr->end, but do we have uaddr       /* Ok uaddr <= vr->end, but do we have uaddr > vr->start ? */
   if (uaddr < vr->start)                             if (uaddr < vr->start)
     return NULL;                                       return NULL;
                                                    
   return vr;                                         return vr;
 }                                                  }
                                                    
                                                    
 struct sos_umem_vmm_as *                           struct sos_umem_vmm_as *
 sos_umem_vmm_get_as_of_vr(struct sos_umem_vmm_     sos_umem_vmm_get_as_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->address_space;                          return vr->address_space;
 }                                                  }
                                                    
                                                    
 struct sos_umem_vmm_vr_ops *                       struct sos_umem_vmm_vr_ops *
 sos_umem_vmm_get_ops_of_vr(struct sos_umem_vmm     sos_umem_vmm_get_ops_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->ops;                                    return vr->ops;
 }                                                  }
                                                    
                                                    
 sos_ui32_t sos_umem_vmm_get_prot_of_vr(struct      sos_ui32_t sos_umem_vmm_get_prot_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->access_rights;                          return vr->access_rights;
 }                                                  }
                                                    
                                                    
 sos_ui32_t sos_umem_vmm_get_flags_of_vr(struct     sos_ui32_t sos_umem_vmm_get_flags_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->flags;                                  return vr->flags;
 }                                                  }
                                                    
                                                    
 struct sos_umem_vmm_mapped_resource *              struct sos_umem_vmm_mapped_resource *
 sos_umem_vmm_get_mapped_resource_of_vr(struct      sos_umem_vmm_get_mapped_resource_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->mapped_resource;                        return vr->mapped_resource;
 }                                                  }
                                                    
                                                    
 sos_uaddr_t sos_umem_vmm_get_start_of_vr(struc     sos_uaddr_t sos_umem_vmm_get_start_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->start;                                  return vr->start;
 }                                                  }
                                                    
                                                    
 sos_size_t sos_umem_vmm_get_size_of_vr(struct      sos_size_t sos_umem_vmm_get_size_of_vr(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->size;                                   return vr->size;
 }                                                  }
                                                    
                                                    
 sos_luoffset_t sos_umem_vmm_get_offset_in_reso     sos_luoffset_t sos_umem_vmm_get_offset_in_resource(struct sos_umem_vmm_vr * vr)
 {                                                  {
   return vr->offset_in_resource;                     return vr->offset_in_resource;
 }                                                  }
                                                    
                                                    
 sos_ret_t                                          sos_ret_t
 sos_umem_vmm_set_ops_of_vr(struct sos_umem_vmm     sos_umem_vmm_set_ops_of_vr(struct sos_umem_vmm_vr * vr,
                            struct sos_umem_vmm                                struct sos_umem_vmm_vr_ops * ops)
 {                                                  {
   /* Don't allow to overwrite any preceding VR       /* Don't allow to overwrite any preceding VR ops */
   SOS_ASSERT_FATAL(NULL == vr->ops);                 SOS_ASSERT_FATAL(NULL == vr->ops);
                                                    
   vr->ops = ops;                                     vr->ops = ops;
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * When resize asks to map the resource elsewh      * When resize asks to map the resource elsewhere, make sure not to
  * overwrite the offset_in_resource field           * overwrite the offset_in_resource field
  */                                                 */
 #define INTERNAL_MAP_CALLED_FROM_MREMAP (1 <<      #define INTERNAL_MAP_CALLED_FROM_MREMAP (1 << 8)
                                                    
 sos_ret_t                                          sos_ret_t
 sos_umem_vmm_map(struct sos_umem_vmm_as * as,      sos_umem_vmm_map(struct sos_umem_vmm_as * as,
                  sos_uaddr_t * /*in/out*/uaddr                      sos_uaddr_t * /*in/out*/uaddr, sos_size_t size,
                  sos_ui32_t access_rights,                          sos_ui32_t access_rights,
                  sos_ui32_t flags,                                  sos_ui32_t flags,
                  struct sos_umem_vmm_mapped_re                      struct sos_umem_vmm_mapped_resource * resource,
                  sos_luoffset_t offset_in_reso                      sos_luoffset_t offset_in_resource)
 {                                                  {
   __label__ return_mmap;                             __label__ return_mmap;
   sos_uaddr_t hint_uaddr;                            sos_uaddr_t hint_uaddr;
   struct sos_umem_vmm_vr *prev_vr, *next_vr, *       struct sos_umem_vmm_vr *prev_vr, *next_vr, *vr, *preallocated_vr;
   sos_bool_t merge_with_preceding, merge_with_       sos_bool_t merge_with_preceding, merge_with_next, used_preallocated_vr;
   sos_bool_t internal_map_called_from_mremap         sos_bool_t internal_map_called_from_mremap
     = (flags & INTERNAL_MAP_CALLED_FROM_MREMAP         = (flags & INTERNAL_MAP_CALLED_FROM_MREMAP);
                                                    
   sos_ret_t retval     = SOS_OK;                     sos_ret_t retval     = SOS_OK;
   used_preallocated_vr = FALSE;                      used_preallocated_vr = FALSE;
   hint_uaddr           = *uaddr;                     hint_uaddr           = *uaddr;
                                                    
   /* Default mapping address is NULL */              /* Default mapping address is NULL */
   *uaddr = (sos_vaddr_t)NULL;                        *uaddr = (sos_vaddr_t)NULL;
                                                    
   if (! resource)                                    if (! resource)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   if (! resource->mmap)                              if (! resource->mmap)
     return -SOS_EPERM;                                 return -SOS_EPERM;
                                                    
   if (! SOS_IS_PAGE_ALIGNED(hint_uaddr))             if (! SOS_IS_PAGE_ALIGNED(hint_uaddr))
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   if (size <= 0)                                     if (size <= 0)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   size = SOS_PAGE_ALIGN_SUP(size);                   size = SOS_PAGE_ALIGN_SUP(size);
                                                    
   if (flags & SOS_VR_MAP_SHARED)                     if (flags & SOS_VR_MAP_SHARED)
     {                                                  {
       /* Make sure the mapped resource allows            /* Make sure the mapped resource allows the required protection flags */
       if ( ( (access_rights & SOS_VM_MAP_PROT_           if ( ( (access_rights & SOS_VM_MAP_PROT_READ)
              && !(resource->allowed_access_rig                  && !(resource->allowed_access_rights & SOS_VM_MAP_PROT_READ) )
            || ( (access_rights & SOS_VM_MAP_PR                || ( (access_rights & SOS_VM_MAP_PROT_WRITE)
                 && !(resource->allowed_access_                     && !(resource->allowed_access_rights & SOS_VM_MAP_PROT_WRITE) )
            || ( (access_rights & SOS_VM_MAP_PR                || ( (access_rights & SOS_VM_MAP_PROT_EXEC)
                 && !(resource->allowed_access_                     && !(resource->allowed_access_rights & SOS_VM_MAP_PROT_EXEC)) )
         return -SOS_EPERM;                                 return -SOS_EPERM;
     }                                                  }
                                                    
   /* Sanity checks over the offset_in_resource       /* Sanity checks over the offset_in_resource parameter */
   if ( !internal_map_called_from_mremap              if ( !internal_map_called_from_mremap
        && ( resource->flags & SOS_MAPPED_RESOU            && ( resource->flags & SOS_MAPPED_RESOURCE_ANONYMOUS ) )
     /* Initial offset ignored for anonymous ma         /* Initial offset ignored for anonymous mappings */
     {                                                  {
       /* Nothing to check */                             /* Nothing to check */
     }                                                  }
                                                    
   /* Make sure that the offset in resource won       /* Make sure that the offset in resource won't overflow */
   else if (offset_in_resource + size <= offset       else if (offset_in_resource + size <= offset_in_resource)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   /* Filter out unsupported flags */                 /* Filter out unsupported flags */
   access_rights &= (SOS_VM_MAP_PROT_READ             access_rights &= (SOS_VM_MAP_PROT_READ
                     | SOS_VM_MAP_PROT_WRITE                            | SOS_VM_MAP_PROT_WRITE
                     | SOS_VM_MAP_PROT_EXEC);                           | SOS_VM_MAP_PROT_EXEC);
   flags &= (SOS_VR_MAP_SHARED                        flags &= (SOS_VR_MAP_SHARED
             | SOS_VR_MAP_FIXED);                               | SOS_VR_MAP_FIXED);
                                                    
   /* Pre-allocate a new VR. Because once we fo       /* Pre-allocate a new VR. Because once we found a valid slot inside
      the VR list, we don't want the list to be          the VR list, we don't want the list to be altered by another
      process */                                         process */
   preallocated_vr                                    preallocated_vr
     = (struct sos_umem_vmm_vr *)sos_kmem_cache         = (struct sos_umem_vmm_vr *)sos_kmem_cache_alloc(cache_of_vr, 0);
   if (! preallocated_vr)                             if (! preallocated_vr)
     return -SOS_ENOMEM;                                return -SOS_ENOMEM;
                                                    
   /* Compute the user address of the new mappi       /* Compute the user address of the new mapping */
   if (flags & SOS_VR_MAP_FIXED)                      if (flags & SOS_VR_MAP_FIXED)
     {                                                  {
       /*                                                 /*
        * The address is imposed                           * The address is imposed
        */                                                 */
                                                    
       /* Make sure the hint_uaddr hint is vali           /* Make sure the hint_uaddr hint is valid */
       if (hint_uaddr < SOS_PAGING_BASE_USER_AD           if (hint_uaddr < SOS_PAGING_BASE_USER_ADDRESS)
         { retval = -SOS_EINVAL; goto return_mm             { retval = -SOS_EINVAL; goto return_mmap; }
       if (hint_uaddr > SOS_PAGING_TOP_USER_ADD           if (hint_uaddr > SOS_PAGING_TOP_USER_ADDRESS - size)
         { retval = -SOS_EINVAL; goto return_mm             { retval = -SOS_EINVAL; goto return_mmap; }
                                                    
       /* Unmap any overlapped VR */                      /* Unmap any overlapped VR */
       retval = sos_umem_vmm_unmap(as, hint_uad           retval = sos_umem_vmm_unmap(as, hint_uaddr, size);
       if (SOS_OK != retval)                              if (SOS_OK != retval)
         { goto return_mmap; }                              { goto return_mmap; }
     }                                                  }
   else                                               else
     {                                                  {
       /*                                                 /*
        * A free range has to be determined                * A free range has to be determined
        */                                                 */
                                                    
       /* Find a suitable free VR */                      /* Find a suitable free VR */
       hint_uaddr = find_first_free_interval(as           hint_uaddr = find_first_free_interval(as, hint_uaddr, size);
       if (! hint_uaddr)                                  if (! hint_uaddr)
         { retval = -SOS_ENOMEM; goto return_mm             { retval = -SOS_ENOMEM; goto return_mmap; }
     }                                                  }
                                                    
   /* For anonymous resource mappings, set the        /* For anonymous resource mappings, set the initial
      offset_in_resource to the initial virtual          offset_in_resource to the initial virtual start address in user
      space */                                           space */
   if ( !internal_map_called_from_mremap              if ( !internal_map_called_from_mremap
        && (resource->flags & SOS_MAPPED_RESOUR            && (resource->flags & SOS_MAPPED_RESOURCE_ANONYMOUS ) )
     offset_in_resource = hint_uaddr;                   offset_in_resource = hint_uaddr;
                                                    
   /* Lookup next and previous VR, if any. This       /* Lookup next and previous VR, if any. This will allow us to merge
      the regions, when possible */                      the regions, when possible */
   next_vr = find_enclosing_or_next_vr(as, hint       next_vr = find_enclosing_or_next_vr(as, hint_uaddr);
   if (next_vr)                                       if (next_vr)
     {                                                  {
       /* Find previous VR, if any */                     /* Find previous VR, if any */
       prev_vr = next_vr->prev_in_as;                     prev_vr = next_vr->prev_in_as;
       /* The list is curcular: it may happen t           /* The list is curcular: it may happen that we looped over the
          tail of the list (ie the list is a si              tail of the list (ie the list is a singleton) */
       if (prev_vr->start > hint_uaddr)                   if (prev_vr->start > hint_uaddr)
         prev_vr = NULL; /* No preceding VR */              prev_vr = NULL; /* No preceding VR */
     }                                                  }
   else                                               else
     {                                                  {
       /* Otherwise we went beyond the last VR            /* Otherwise we went beyond the last VR */
       prev_vr = list_get_tail_named(as->list_v           prev_vr = list_get_tail_named(as->list_vr, prev_in_as, next_in_as);
     }                                                  }
                                                    
   /* Merge with preceding VR ? */                    /* Merge with preceding VR ? */
   merge_with_preceding                               merge_with_preceding
     = ( (NULL != prev_vr)                              = ( (NULL != prev_vr)
         && (prev_vr->mapped_resource == resour             && (prev_vr->mapped_resource == resource)
         && (prev_vr->offset_in_resource + prev             && (prev_vr->offset_in_resource + prev_vr->size == offset_in_resource)
         && (prev_vr->start + prev_vr->size ==              && (prev_vr->start + prev_vr->size == hint_uaddr)
         && (prev_vr->flags == flags)                       && (prev_vr->flags == flags)
         && (prev_vr->access_rights == access_r             && (prev_vr->access_rights == access_rights) );
                                                    
   /* Merge with next VR ? */                         /* Merge with next VR ? */
   merge_with_next                                    merge_with_next
     = ( (NULL != next_vr)                              = ( (NULL != next_vr)
         && (next_vr->mapped_resource == resour             && (next_vr->mapped_resource == resource)
         && (offset_in_resource + size == next_             && (offset_in_resource + size == next_vr->offset_in_resource)
         && (hint_uaddr + size == next_vr->star             && (hint_uaddr + size == next_vr->start)
         && (next_vr->flags == flags)                       && (next_vr->flags == flags)
         && (next_vr->access_rights == access_r             && (next_vr->access_rights == access_rights) );
                                                    
   if (merge_with_preceding && merge_with_next)       if (merge_with_preceding && merge_with_next)
     {                                                  {
       /* Widen the prev_vr VR to encompass bot           /* Widen the prev_vr VR to encompass both the new VR and the next_vr */
       vr = prev_vr;                                      vr = prev_vr;
       vr->size += size + next_vr->size;                  vr->size += size + next_vr->size;
                                                          
       /* Remove the next_vr VR */                        /* Remove the next_vr VR */
       list_delete_named(as->list_vr, next_vr,            list_delete_named(as->list_vr, next_vr, prev_in_as, next_in_as);
       list_delete_named(next_vr->mapped_resour           list_delete_named(next_vr->mapped_resource->list_vr, next_vr,
                         prev_in_mapped_resourc                             prev_in_mapped_resource, next_in_mapped_resource);
                                                    
       if (next_vr->ops && next_vr->ops->unref)           if (next_vr->ops && next_vr->ops->unref)
         next_vr->ops->unref(next_vr);                      next_vr->ops->unref(next_vr);
                                                    
       sos_kmem_vmm_free((sos_vaddr_t) next_vr)           sos_kmem_vmm_free((sos_vaddr_t) next_vr);
     }                                                  }
   else if (merge_with_preceding)                     else if (merge_with_preceding)
     {                                                  {
       /* Widen the prev_vr VR to encompass the           /* Widen the prev_vr VR to encompass the new VR */
       vr = prev_vr;                                      vr = prev_vr;
       vr->size += size;                                  vr->size += size;
     }                                                  }
   else if (merge_with_next)                          else if (merge_with_next)
     {                                                  {
       /* Widen the next_vr VR to encompass the           /* Widen the next_vr VR to encompass the new VR */
       vr = next_vr;                                      vr = next_vr;
       vr->start -= size;                                 vr->start -= size;
       vr->size  += size;                                 vr->size  += size;
     }                                                  }
   else                                               else
     {                                                  {
       /* Allocate a brand new VR and insert it           /* Allocate a brand new VR and insert it into the list */
                                                    
       vr = preallocated_vr;                              vr = preallocated_vr;
       used_preallocated_vr = TRUE;                       used_preallocated_vr = TRUE;
                                                    
       vr->start              = hint_uaddr;               vr->start              = hint_uaddr;
       vr->size               = size;                     vr->size               = size;
       vr->access_rights      = access_rights;            vr->access_rights      = access_rights;
       vr->flags              = flags;                    vr->flags              = flags;
       vr->mapped_resource    = resource;                 vr->mapped_resource    = resource;
       vr->offset_in_resource = offset_in_resou           vr->offset_in_resource = offset_in_resource;
                                                    
       /* Insert VR in address space */                   /* Insert VR in address space */
       vr->address_space      = as;                       vr->address_space      = as;
       if (prev_vr)                                       if (prev_vr)
         list_insert_after_named(as->list_vr, p             list_insert_after_named(as->list_vr, prev_vr, vr,
                                 prev_in_as, ne                                     prev_in_as, next_in_as);
       else                                               else
         list_add_head_named(as->list_vr, vr, p             list_add_head_named(as->list_vr, vr, prev_in_as, next_in_as);
                                                   >>  
       list_add_tail_named(vr->mapped_resource-           list_add_tail_named(vr->mapped_resource->list_vr, vr,
                           prev_in_mapped_resou                               prev_in_mapped_resource,
                           next_in_mapped_resou                               next_in_mapped_resource);
                                                          
       /* Signal the resource we are mapping it           /* Signal the resource we are mapping it */
       if (resource && resource->mmap)                    if (resource && resource->mmap)
         {                                                  {
           retval = resource->mmap(vr);                       retval = resource->mmap(vr);
           if (SOS_OK != retval)                              if (SOS_OK != retval)
             {                                                  {
               retval = sos_umem_vmm_unmap(as,                    retval = sos_umem_vmm_unmap(as, vr->start, vr->size);
               goto return_mmap;                                  goto return_mmap;
             }                                                  }
                                                    
           /* The page_in method is MANDATORY f               /* The page_in method is MANDATORY for mapped resources */
           SOS_ASSERT_FATAL(vr->ops && vr->ops-               SOS_ASSERT_FATAL(vr->ops && vr->ops->page_in);
         }                                                  }
                                                    
       if (vr->ops && vr->ops->ref)                       if (vr->ops && vr->ops->ref)
         vr->ops->ref(vr);                                  vr->ops->ref(vr);
     }                                                  }
                                                    
   /* Ok, fine, we got it right ! Return the ad       /* Ok, fine, we got it right ! Return the address to the caller */
   *uaddr = hint_uaddr;                               *uaddr = hint_uaddr;
   as_account_change_of_vr_protection(as, vr->f       as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                      size, 0,                                           size, 0, vr->access_rights);
   retval = SOS_OK;                                   retval = SOS_OK;
                                                    
  return_mmap:                                       return_mmap:
   if (! used_preallocated_vr)                        if (! used_preallocated_vr)
     sos_kmem_vmm_free((sos_vaddr_t)preallocate         sos_kmem_vmm_free((sos_vaddr_t)preallocated_vr);
                                                        
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 sos_ret_t                                          sos_ret_t
 sos_umem_vmm_unmap(struct sos_umem_vmm_as * as     sos_umem_vmm_unmap(struct sos_umem_vmm_as * as,
                    sos_uaddr_t uaddr, sos_size                        sos_uaddr_t uaddr, sos_size_t size)
 {                                                  {
   struct sos_umem_vmm_vr *vr, *preallocated_vr       struct sos_umem_vmm_vr *vr, *preallocated_vr;
   sos_bool_t need_to_setup_mmu;                      sos_bool_t need_to_setup_mmu;
   sos_bool_t used_preallocated_vr;                   sos_bool_t used_preallocated_vr;
                                                    
   if (! SOS_IS_PAGE_ALIGNED(uaddr))                  if (! SOS_IS_PAGE_ALIGNED(uaddr))
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   if (size <= 0)                                     if (size <= 0)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   size = SOS_PAGE_ALIGN_SUP(size);                   size = SOS_PAGE_ALIGN_SUP(size);
                                                    
   /* Make sure the uaddr is valid */                 /* Make sure the uaddr is valid */
   if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)          if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   if (uaddr > SOS_PAGING_TOP_USER_ADDRESS - si       if (uaddr > SOS_PAGING_TOP_USER_ADDRESS - size)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   /* In some cases, the unmapping might imply        /* In some cases, the unmapping might imply a VR to be split into
      2. Actually, allocating a new VR can be a          2. Actually, allocating a new VR can be a blocking operation, but
      actually we can block now, it won't do no          actually we can block now, it won't do no harm. But we must be
      careful not to block later, while alterin          careful not to block later, while altering the VR lists: that's
      why we pre-allocate now. */                        why we pre-allocate now. */
   used_preallocated_vr = FALSE;                      used_preallocated_vr = FALSE;
   preallocated_vr                                    preallocated_vr
     = (struct sos_umem_vmm_vr *)sos_kmem_cache         = (struct sos_umem_vmm_vr *)sos_kmem_cache_alloc(cache_of_vr, 0);
   if (! preallocated_vr)                             if (! preallocated_vr)
     return -SOS_ENOMEM;                                return -SOS_ENOMEM;
                                                    
   /* Find any VR intersecting with the given i       /* Find any VR intersecting with the given interval */
   vr = find_first_intersecting_vr(as, uaddr, s       vr = find_first_intersecting_vr(as, uaddr, size);
                                                    
   /* Unmap (part of) the VR covered by [uaddr        /* Unmap (part of) the VR covered by [uaddr .. uaddr+size[ */
   while (NULL != vr)                                 while (NULL != vr)
     {                                                  {
       /* Went past the end of the *circular* l           /* Went past the end of the *circular* list => back at the
          beginning ? */                                     beginning ? */
       if (vr->start + vr->size <= uaddr)                 if (vr->start + vr->size <= uaddr)
         /* Yes, stop now */                                /* Yes, stop now */
         break;                                             break;
                                                    
       /* Went beyond the region to unmap ? */            /* Went beyond the region to unmap ? */
       if (uaddr + size <= vr->start)                     if (uaddr + size <= vr->start)
         /* Yes, stop now */                                /* Yes, stop now */
         break;                                             break;
                                                    
       /* VR totally unmapped ? */                        /* VR totally unmapped ? */
       if ((vr->start >= uaddr)                           if ((vr->start >= uaddr)
           && (vr->start + vr->size <= uaddr +                && (vr->start + vr->size <= uaddr + size))
         {                                                  {
           struct sos_umem_vmm_vr *next_vr;                   struct sos_umem_vmm_vr *next_vr;
                                                    
           /* Yes: signal we remove it complete               /* Yes: signal we remove it completely */
           if (vr->ops && vr->ops->unmap)                     if (vr->ops && vr->ops->unmap)
             vr->ops->unmap(vr, vr->start, vr->                 vr->ops->unmap(vr, vr->start, vr->size);
                                                    
           /* Remove it from the AS list now */               /* Remove it from the AS list now */
           next_vr = vr->next_in_as;                          next_vr = vr->next_in_as;
           if (next_vr == vr) /* singleton ? */               if (next_vr == vr) /* singleton ? */
             next_vr = NULL;                                    next_vr = NULL;
           list_delete_named(as->list_vr, vr, p               list_delete_named(as->list_vr, vr, prev_in_as, next_in_as);
                                                    
           /* Remove from the list of VRs mappi               /* Remove from the list of VRs mapping the resource */
           list_delete_named(vr->mapped_resourc               list_delete_named(vr->mapped_resource->list_vr, vr,
                             prev_in_mapped_res                                 prev_in_mapped_resource,
                             next_in_mapped_res                                 next_in_mapped_resource);
                                                    
           if (vr->ops && vr->ops->unref)                     if (vr->ops && vr->ops->unref)
             vr->ops->unref(vr);                                vr->ops->unref(vr);
                                                              
           as_account_change_of_vr_protection(a               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                              v                                                  vr->size, vr->access_rights, 0);
           sos_kmem_vmm_free((sos_vaddr_t)vr);                sos_kmem_vmm_free((sos_vaddr_t)vr);
                                                          
           /* Prepare next iteration */                       /* Prepare next iteration */
           vr = next_vr;                                      vr = next_vr;
           continue;                                          continue;
         }                                                  }
                                                    
       /* unmapped region lies completely INSID           /* unmapped region lies completely INSIDE the the VR */
       else if ( (vr->start < uaddr)                      else if ( (vr->start < uaddr)
                 && (vr->start + vr->size > uad                     && (vr->start + vr->size > uaddr + size) )
         {                                                  {
           /* VR has to be split into 2 */                    /* VR has to be split into 2 */
                                                    
           /* Use the preallocated VR and copy                /* Use the preallocated VR and copy the VR into it */
           used_preallocated_vr = TRUE;                       used_preallocated_vr = TRUE;
           memcpy(preallocated_vr, vr, sizeof(*               memcpy(preallocated_vr, vr, sizeof(*vr));
                                                    
           /* Adjust the start/size of both VRs               /* Adjust the start/size of both VRs */
           preallocated_vr->start = uaddr + siz               preallocated_vr->start = uaddr + size;
           preallocated_vr->size  = vr->start +               preallocated_vr->size  = vr->start + vr->size - (uaddr + size);
           preallocated_vr->offset_in_resource                preallocated_vr->offset_in_resource += uaddr + size - vr->start;
           vr->size                                           vr->size                             = uaddr - vr->start;
                                                    
           /* Insert the new VR into the list *               /* Insert the new VR into the list */
           list_insert_after_named(as->list_vr,               list_insert_after_named(as->list_vr, vr, preallocated_vr,
                                   prev_in_as,                                        prev_in_as, next_in_as);
           list_add_tail_named(vr->mapped_resou               list_add_tail_named(vr->mapped_resource->list_vr, preallocated_vr,
                               prev_in_mapped_r                                   prev_in_mapped_resource,
                               next_in_mapped_r                                   next_in_mapped_resource);
                                                    
           /* Signal the changes to the underly               /* Signal the changes to the underlying resource */
           if (vr->ops && vr->ops->unmap)                     if (vr->ops && vr->ops->unmap)
             vr->ops->unmap(vr, uaddr, size);                   vr->ops->unmap(vr, uaddr, size);
           if (preallocated_vr->ops && prealloc               if (preallocated_vr->ops && preallocated_vr->ops->ref)
             preallocated_vr->ops->ref(prealloc                 preallocated_vr->ops->ref(preallocated_vr);
                                                    
           /* Account for change in VRs */                    /* Account for change in VRs */
           as_account_change_of_vr_protection(a               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                              s                                                  size, vr->access_rights, 0);
                                                    
           /* No need to go further */                        /* No need to go further */
           break;                                             break;
         }                                                  }
                                                    
       /* Unmapped region only affects the STAR           /* Unmapped region only affects the START address of the VR */
       else if (uaddr <= vr->start)                       else if (uaddr <= vr->start)
         {                                                  {
           sos_size_t translation = uaddr + siz               sos_size_t translation = uaddr + size - vr->start;
                                                    
           /* Shift the VR */                                 /* Shift the VR */
           vr->size               -= translatio               vr->size               -= translation;
           vr->offset_in_resource += translatio               vr->offset_in_resource += translation;
           vr->start              += translatio               vr->start              += translation;
                                                              
           /* Signal unmapping */                             /* Signal unmapping */
           if (vr->ops && vr->ops->unmap)                     if (vr->ops && vr->ops->unmap)
             vr->ops->unmap(vr, uaddr + size,                   vr->ops->unmap(vr, uaddr + size,
                            translation);                                      translation);
                                                              
           /* Account for change in VRs */                    /* Account for change in VRs */
           as_account_change_of_vr_protection(a               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                              t                                                  translation,
                                              v                                                  vr->access_rights, 0);
                                                    
           /* No need to go further, we reached               /* No need to go further, we reached the last VR that
              overlaps the unmapped region */                    overlaps the unmapped region */
           break;                                             break;
         }                                                  }
                                                    
       /* Unmapped region only affects the ENDI           /* Unmapped region only affects the ENDING address of the VR */
       else if (uaddr + size >= vr->start + vr-           else if (uaddr + size >= vr->start + vr->size)
         {                                                  {
           sos_size_t unmapped_size = vr->start               sos_size_t unmapped_size = vr->start + vr->size - uaddr;
                                                    
           /* Resize VR */                                    /* Resize VR */
           vr->size = uaddr - vr->start;                      vr->size = uaddr - vr->start;
                                                              
           /* Signal unmapping */                             /* Signal unmapping */
           if (vr->ops && vr->ops->unmap)                     if (vr->ops && vr->ops->unmap)
             vr->ops->unmap(vr, uaddr, unmapped                 vr->ops->unmap(vr, uaddr, unmapped_size);
                                                    
           /* Account for change in VRs */                    /* Account for change in VRs */
           as_account_change_of_vr_protection(a               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                              u                                                  unmapped_size,
                                              v                                                  vr->access_rights, 0);
                                                              
           vr = vr->next_in_as;                               vr = vr->next_in_as;
           continue;                                          continue;
         }                                                  }
                                                    
       sos_display_fatal_error("BUG uaddr=%x sz           sos_display_fatal_error("BUG uaddr=%x sz=%x vr_start=%x, vr_sz=%x",
                               uaddr, size, vr-                                   uaddr, size, vr->start, vr->size);
     }                                                  }
                                                    
   need_to_setup_mmu = (sos_thread_get_current(       need_to_setup_mmu = (sos_thread_get_current()->squatted_mm_context
                        != as->mm_context);                                != as->mm_context);
   if (need_to_setup_mmu)                             if (need_to_setup_mmu)
     SOS_ASSERT_FATAL(SOS_OK                            SOS_ASSERT_FATAL(SOS_OK
                      == sos_thread_prepare_use                          == sos_thread_prepare_user_space_access(as,
                                                                                                                 (sos_vaddr_t)
                                                                                                                   NULL));
   {                                                  {
     sos_size_t sz_unmapped = sos_paging_unmap_ !!      sos_ret_t sz_unmapped = sos_paging_unmap_interval(uaddr, size);
     SOS_ASSERT_FATAL(sz_unmapped >= 0);                SOS_ASSERT_FATAL(sz_unmapped >= 0);
     as->phys_total -= sz_unmapped;                     as->phys_total -= sz_unmapped;
   }                                                  }
   if (need_to_setup_mmu)                             if (need_to_setup_mmu)
     SOS_ASSERT_FATAL(SOS_OK == sos_thread_end_         SOS_ASSERT_FATAL(SOS_OK == sos_thread_end_user_space_access());
                                                    
   if (! used_preallocated_vr)                        if (! used_preallocated_vr)
     sos_kmem_vmm_free((sos_vaddr_t)preallocate         sos_kmem_vmm_free((sos_vaddr_t)preallocated_vr);
                                                    
   return SOS_OK;                                     return SOS_OK;
 }                                                  }
                                                    
                                                    
 sos_ret_t                                          sos_ret_t
 sos_umem_vmm_chprot(struct sos_umem_vmm_as * a     sos_umem_vmm_chprot(struct sos_umem_vmm_as * as,
                     sos_uaddr_t uaddr, sos_siz                         sos_uaddr_t uaddr, sos_size_t size,
                     sos_ui32_t new_access_righ                         sos_ui32_t new_access_rights)
 {                                                  {
   struct sos_umem_vmm_vr *start_vr, *vr,             struct sos_umem_vmm_vr *start_vr, *vr,
     *preallocated_middle_vr, *preallocated_rig         *preallocated_middle_vr, *preallocated_right_vr;
   sos_bool_t used_preallocated_middle_vr, used       sos_bool_t used_preallocated_middle_vr, used_preallocated_right_vr;
                                                    
   if (! SOS_IS_PAGE_ALIGNED(uaddr))                  if (! SOS_IS_PAGE_ALIGNED(uaddr))
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   if (size <= 0)                                     if (size <= 0)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   size = SOS_PAGE_ALIGN_SUP(size);                   size = SOS_PAGE_ALIGN_SUP(size);
                                                    
   /* Make sure the uaddr is valid */                 /* Make sure the uaddr is valid */
   if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)          if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
   if (uaddr > SOS_PAGING_TOP_USER_ADDRESS - si       if (uaddr > SOS_PAGING_TOP_USER_ADDRESS - size)
     return -SOS_EINVAL;                                return -SOS_EINVAL;
                                                    
   /* Pre-allocate 2 new VRs (same reason as fo       /* Pre-allocate 2 new VRs (same reason as for unmap). Because chprot
      may imply at most 2 regions to be split *          may imply at most 2 regions to be split */
   used_preallocated_middle_vr = FALSE;               used_preallocated_middle_vr = FALSE;
   used_preallocated_right_vr  = FALSE;               used_preallocated_right_vr  = FALSE;
   preallocated_middle_vr                             preallocated_middle_vr
     = (struct sos_umem_vmm_vr *)sos_kmem_cache         = (struct sos_umem_vmm_vr *)sos_kmem_cache_alloc(cache_of_vr, 0);
   if (! preallocated_middle_vr)                      if (! preallocated_middle_vr)
     return -SOS_ENOMEM;                                return -SOS_ENOMEM;
   preallocated_right_vr                              preallocated_right_vr
     = (struct sos_umem_vmm_vr *)sos_kmem_cache         = (struct sos_umem_vmm_vr *)sos_kmem_cache_alloc(cache_of_vr, 0);
   if (! preallocated_right_vr)                       if (! preallocated_right_vr)
     {                                                  {
       sos_kmem_vmm_free((sos_vaddr_t)prealloca           sos_kmem_vmm_free((sos_vaddr_t)preallocated_middle_vr);
       return -SOS_ENOMEM;                                return -SOS_ENOMEM;
     }                                                  }
                                                    
   /* Find any VR intersecting with the given i       /* Find any VR intersecting with the given interval */
   start_vr = find_first_intersecting_vr(as, ua       start_vr = find_first_intersecting_vr(as, uaddr, size);
   if (NULL == start_vr)                              if (NULL == start_vr)
     return SOS_OK;                                     return SOS_OK;
                                                    
   /* First of all: make sure we are allowed to       /* First of all: make sure we are allowed to change the access
      rights of all the VRs concerned by the ch          rights of all the VRs concerned by the chprot */
   vr = start_vr;                                     vr = start_vr;
   while (TRUE)                                       while (TRUE)
     {                                                  {
       /* Went past the end of the *circular* l           /* Went past the end of the *circular* list => back at the
          begining ? */                                      begining ? */
       if (vr->start + vr->size <= uaddr)                 if (vr->start + vr->size <= uaddr)
         /* Yes, stop now */                                /* Yes, stop now */
         break;                                             break;
                                                    
       /* Went beyond the region to chprot ? */           /* Went beyond the region to chprot ? */
       if (uaddr + size < vr->start)                      if (uaddr + size < vr->start)
         /* Yes, stop now */                                /* Yes, stop now */
         break;                                             break;
                                                    
       if (vr->flags & SOS_VR_MAP_SHARED)                 if (vr->flags & SOS_VR_MAP_SHARED)
         {                                                  {
           /* Make sure the mapped resource all               /* Make sure the mapped resource allows the required
              protection flags */                                protection flags */
           if ( ( (new_access_rights & SOS_VM_M               if ( ( (new_access_rights & SOS_VM_MAP_PROT_READ)
                  && !(vr->mapped_resource->all                      && !(vr->mapped_resource->allowed_access_rights
                       & SOS_VM_MAP_PROT_READ)                            & SOS_VM_MAP_PROT_READ) )
                || ( (new_access_rights & SOS_V                    || ( (new_access_rights & SOS_VM_MAP_PROT_WRITE)
                     && !(vr->mapped_resource->                         && !(vr->mapped_resource->allowed_access_rights
                          & SOS_VM_MAP_PROT_WRI                              & SOS_VM_MAP_PROT_WRITE) )
                || ( (new_access_rights & SOS_V                    || ( (new_access_rights & SOS_VM_MAP_PROT_EXEC)
                     && !(vr->mapped_resource->                         && !(vr->mapped_resource->allowed_access_rights
                          & SOS_VM_MAP_PROT_EXE                              & SOS_VM_MAP_PROT_EXEC) ) )
             return -SOS_EPERM;                                 return -SOS_EPERM;
         }                                                  }
                                                    
       vr = vr->next_in_as;                               vr = vr->next_in_as;
     }                                                  }
                                                    
   /* Change the access rights of the VRs cover       /* Change the access rights of the VRs covered by [uaddr
      .. uaddr+size[ */                                  .. uaddr+size[ */
   vr = start_vr;                                     vr = start_vr;
   while (TRUE)                                       while (TRUE)
     {                                                  {
                                                    
       /* Went past the end of the *circular* l           /* Went past the end of the *circular* list => back at the
          begining ? */                                      begining ? */
       if (vr->start + vr->size <= uaddr)                 if (vr->start + vr->size <= uaddr)
         /* Yes, stop now */                                /* Yes, stop now */
         break;                                             break;
                                                    
       /* Went beyond the region to chprot ? */           /* Went beyond the region to chprot ? */
       if (uaddr + size <= vr->start)                     if (uaddr + size <= vr->start)
         /* Yes, stop now */                                /* Yes, stop now */
         break;                                             break;
                                                    
       /* Access rights unchanged ? */                    /* Access rights unchanged ? */
       if (vr->access_rights == new_access_righ           if (vr->access_rights == new_access_rights)
         /* nop */                                          /* nop */
         {                                                  {
           vr = vr->next_in_as;                               vr = vr->next_in_as;
           continue;                                          continue;
         }                                                  }
                                                   
       /* VR totally chprot ? */                         /* VR totally chprot ? */
       if ((vr->start >= uaddr)                          if ((vr->start >= uaddr)
           && (vr->start + vr->size <= uaddr +               && (vr->start + vr->size <= uaddr + size))
         {                                                 {
           /* Account for change in VRs */                   /* Account for change in VRs */
           as_account_change_of_vr_protection(               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                                                                                vr->size, vr->access_rights,
                                                                                                new_access_rights);
           vr->access_rights = new_access_righ               vr->access_rights = new_access_rights;
                                                   
           if (vr->flags & SOS_VR_MAP_SHARED)                if (vr->flags & SOS_VR_MAP_SHARED)
             /* For shared mappings: effective                 /* For shared mappings: effectively change the access
                rights of the physical pages                      rights of the physical pages  */
             sos_paging_set_prot_of_interval(v                 sos_paging_set_prot_of_interval(vr->start, vr->size,
                                             n                                                 new_access_rights);
           else                                              else
             /* Private mapping */                             /* Private mapping */
             {                                                 {
               /* For private mappings, we set                   /* For private mappings, we set the new access_rights
                  only if it becomes read-only                      only if it becomes read-only. For private mappings
                  that become writable, we don                      that become writable, we don't do anything: we keep
                  the access rights unchanged                       the access rights unchanged to preserve the COW
                  semantics */                                      semantics */
               if (! (new_access_rights & SOS_                   if (! (new_access_rights & SOS_VM_MAP_PROT_WRITE))
                 sos_paging_set_prot_of_interv                     sos_paging_set_prot_of_interval(vr->start, vr->size,
                                                                                                   new_access_rights);
             }                                                 }
                                                   
           vr = vr->next_in_as;                              vr = vr->next_in_as;
           continue;                                         continue;
         }                                                 }
                                                   
       /* chprot region lies completely INSIDE           /* chprot region lies completely INSIDE the VR */
       else if ( (vr->start < uaddr)                     else if ( (vr->start < uaddr)
                 && (vr->start + vr->size > ua                     && (vr->start + vr->size > uaddr + size) )
         {                                                 {
           /* VR has to be split into 3 */                   /* VR has to be split into 3 */
                                                   
           /* Use the preallocated VRs and cop               /* Use the preallocated VRs and copy the VR into them */
           SOS_ASSERT_FATAL(! used_preallocate               SOS_ASSERT_FATAL(! used_preallocated_middle_vr);
           SOS_ASSERT_FATAL(! used_preallocate               SOS_ASSERT_FATAL(! used_preallocated_right_vr);
           used_preallocated_middle_vr = TRUE;               used_preallocated_middle_vr = TRUE;
           memcpy(preallocated_middle_vr, vr,                memcpy(preallocated_middle_vr, vr, sizeof(*vr));
           used_preallocated_right_vr = TRUE;                used_preallocated_right_vr = TRUE;
           memcpy(preallocated_right_vr, vr, s               memcpy(preallocated_right_vr, vr, sizeof(*vr));
                                                   
           /* Adjust the start/size of the VRs               /* Adjust the start/size of the VRs */
           preallocated_middle_vr->start = uad               preallocated_middle_vr->start = uaddr;
           preallocated_middle_vr->size  = siz               preallocated_middle_vr->size  = size;
           preallocated_right_vr->start  = uad               preallocated_right_vr->start  = uaddr + size;
           preallocated_right_vr->size   = vr-               preallocated_right_vr->size   = vr->start + vr->size
                                             -                                                 - (uaddr + size);
           preallocated_middle_vr->offset_in_r               preallocated_middle_vr->offset_in_resource
             += uaddr - vr->start;                             += uaddr - vr->start;
           preallocated_right_vr->offset_in_re               preallocated_right_vr->offset_in_resource
             += uaddr + size - vr->start;                      += uaddr + size - vr->start;
           vr->size = uaddr - vr->start;                     vr->size = uaddr - vr->start;
                                                   
           /* Account for change in VRs */                   /* Account for change in VRs */
           preallocated_middle_vr->access_righ               preallocated_middle_vr->access_rights = new_access_rights;
           as_account_change_of_vr_protection(               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                                                                                size, vr->access_rights,
                                                                                                new_access_rights);
                                                   
           /* Insert the new VRs into the list               /* Insert the new VRs into the lists */
           list_insert_after_named(as->list_vr               list_insert_after_named(as->list_vr, vr, preallocated_middle_vr,
                                   prev_in_as,                                       prev_in_as, next_in_as);
           list_insert_after_named(as->list_vr               list_insert_after_named(as->list_vr, preallocated_middle_vr,
                                   preallocate                                       preallocated_right_vr,
                                   prev_in_as,                                       prev_in_as, next_in_as);
                                                   
           list_add_tail_named(vr->mapped_reso               list_add_tail_named(vr->mapped_resource->list_vr,
                               preallocated_mi                                   preallocated_middle_vr,
                               prev_in_mapped_                                   prev_in_mapped_resource,
                               next_in_mapped_                                   next_in_mapped_resource);
           list_add_tail_named(vr->mapped_reso               list_add_tail_named(vr->mapped_resource->list_vr,
                               preallocated_ri                                   preallocated_right_vr,
                               prev_in_mapped_                                   prev_in_mapped_resource,
                               next_in_mapped_                                   next_in_mapped_resource);
                                                   
           /* Effectively change the access ri               /* Effectively change the access rights of the physical pages */
           if (!(preallocated_middle_vr->flags               if (!(preallocated_middle_vr->flags & SOS_VR_MAP_SHARED)
               && (new_access_rights & SOS_VM_                   && (new_access_rights & SOS_VM_MAP_PROT_WRITE))
             /* For private mappings with writ                 /* For private mappings with write access, prepare for COW */
             sos_paging_prepare_COW(preallocat                 sos_paging_prepare_COW(preallocated_middle_vr->start,
                                    preallocat                                        preallocated_middle_vr->size);
           else                                              else
             sos_paging_set_prot_of_interval(p                 sos_paging_set_prot_of_interval(preallocated_middle_vr->start,
                                             p                                                 preallocated_middle_vr->size,
                                             n                                                 new_access_rights);
                                                   
           if (preallocated_right_vr->ops && p               if (preallocated_right_vr->ops && preallocated_right_vr->ops->ref)
             preallocated_right_vr->ops->ref(p                 preallocated_right_vr->ops->ref(preallocated_right_vr);
           if (preallocated_middle_vr->ops &&                if (preallocated_middle_vr->ops && preallocated_middle_vr->ops->ref)
             preallocated_middle_vr->ops->ref(                 preallocated_middle_vr->ops->ref(preallocated_middle_vr);
                                                   
           /* No need to go further */                       /* No need to go further */
           break;                                            break;
         }                                                 }
                                                   
       /* Chprot region only affects the START           /* Chprot region only affects the START address of the VR */
       else if (uaddr <= vr->start)                      else if (uaddr <= vr->start)
         {                                                 {
           /* Split the region into 2 */                     /* Split the region into 2 */
           sos_uoffset_t offset_in_region = ua               sos_uoffset_t offset_in_region = uaddr + size - vr->start;
                                                   
           /* Use the preallocated VRs and cop               /* Use the preallocated VRs and copy the VR into them */
           SOS_ASSERT_FATAL(! used_preallocate               SOS_ASSERT_FATAL(! used_preallocated_middle_vr);
           used_preallocated_middle_vr = TRUE;               used_preallocated_middle_vr = TRUE;
           memcpy(preallocated_middle_vr, vr,                memcpy(preallocated_middle_vr, vr, sizeof(*vr));
                                                   
           /* Adjust the start/size of the VRs               /* Adjust the start/size of the VRs */
           preallocated_middle_vr->start += of               preallocated_middle_vr->start += offset_in_region;
           preallocated_middle_vr->size  -= of               preallocated_middle_vr->size  -= offset_in_region;
           vr->size                       = of               vr->size                       = offset_in_region;
           preallocated_middle_vr->offset_in_r               preallocated_middle_vr->offset_in_resource += offset_in_region;
                                                   
           /* Account for change in VRs */                   /* Account for change in VRs */
           as_account_change_of_vr_protection(               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                                                                                vr->size,
                                                                                                vr->access_rights,
                                                                                                new_access_rights);
           vr->access_rights = new_access_righ               vr->access_rights = new_access_rights;
                                                   
           /* Insert the new VR into the lists               /* Insert the new VR into the lists */
           list_insert_after_named(as->list_vr               list_insert_after_named(as->list_vr, vr,
                                   preallocate                                       preallocated_middle_vr,
                                   prev_in_as,                                       prev_in_as, next_in_as);
           list_add_tail_named(vr->mapped_reso               list_add_tail_named(vr->mapped_resource->list_vr,
                               preallocated_mi                                   preallocated_middle_vr,
                               prev_in_mapped_                                   prev_in_mapped_resource,
                               next_in_mapped_                                   next_in_mapped_resource);
                                                   
           /* Effectively change the access ri               /* Effectively change the access rights of the physical pages */
           if (!(vr->flags & SOS_VR_MAP_SHARED               if (!(vr->flags & SOS_VR_MAP_SHARED)
               && (new_access_rights & SOS_VM_                   && (new_access_rights & SOS_VM_MAP_PROT_WRITE))
             /* For private mappings with writ                 /* For private mappings with write access, prepare for COW */
             sos_paging_prepare_COW(vr->start,                 sos_paging_prepare_COW(vr->start, vr->size);
           else                                              else
             sos_paging_set_prot_of_interval(v                 sos_paging_set_prot_of_interval(vr->start, vr->size,
                                             n                                                 new_access_rights);
                                                   
           if (preallocated_middle_vr->ops &&                if (preallocated_middle_vr->ops && preallocated_middle_vr->ops->ref)
             preallocated_middle_vr->ops->ref(                 preallocated_middle_vr->ops->ref(preallocated_middle_vr);
                                                   
           /* Ne need to go further (we reache               /* Ne need to go further (we reached the last VR that
              overlaps the given interval to c                  overlaps the given interval to chprot) */
           break;                                            break;
         }                                                 }
                                                   
       /* Chprot region only affects the ENDIN           /* Chprot region only affects the ENDING address of the VR */
       else if (uaddr + size >= vr->start + vr           else if (uaddr + size >= vr->start + vr->size)
         {                                                 {
           /* Split the region into 2 */                     /* Split the region into 2 */
           sos_uoffset_t offset_in_region = ua               sos_uoffset_t offset_in_region = uaddr - vr->start;
                                                   
           /* Use the preallocated VRs and cop               /* Use the preallocated VRs and copy the VR into them */
           SOS_ASSERT_FATAL(! used_preallocate               SOS_ASSERT_FATAL(! used_preallocated_right_vr);
           used_preallocated_right_vr = TRUE;                used_preallocated_right_vr = TRUE;
           memcpy(preallocated_right_vr, vr, s               memcpy(preallocated_right_vr, vr, sizeof(*vr));
                                                   
           /* Adjust the start/size of the VRs               /* Adjust the start/size of the VRs */
           preallocated_right_vr->start                      preallocated_right_vr->start        += offset_in_region;
           preallocated_right_vr->size                       preallocated_right_vr->size         -= offset_in_region;
           vr->size                                          vr->size                             = offset_in_region;
           preallocated_right_vr->offset_in_re               preallocated_right_vr->offset_in_resource += offset_in_region;
                                                   
           /* Account for change in VRs */                   /* Account for change in VRs */
           as_account_change_of_vr_protection(               as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                                                                                preallocated_right_vr->size,
                                                                                                vr->access_rights,
                                                                                                new_access_rights);
           preallocated_right_vr->access_right               preallocated_right_vr->access_rights = new_access_rights;
                                                   
           /* Insert the new VR into the lists               /* Insert the new VR into the lists */
           list_insert_after_named(as->list_vr               list_insert_after_named(as->list_vr, vr,
                                   preallocate                                       preallocated_right_vr,
                                   prev_in_as,                                       prev_in_as, next_in_as);
           list_add_tail_named(vr->mapped_reso               list_add_tail_named(vr->mapped_resource->list_vr,
                               preallocated_ri                                   preallocated_right_vr,
                               prev_in_mapped_                                   prev_in_mapped_resource,
                               next_in_mapped_                                   next_in_mapped_resource);
                                                   
           /* Effectively change the access ri               /* Effectively change the access rights of the physical pages */
           if (!(preallocated_right_vr->flags                if (!(preallocated_right_vr->flags & SOS_VR_MAP_SHARED)
               && (new_access_rights & SOS_VM_                   && (new_access_rights & SOS_VM_MAP_PROT_WRITE))
             /* For private mappings with writ                 /* For private mappings with write access, prepare for COW */
             sos_paging_prepare_COW(preallocat                 sos_paging_prepare_COW(preallocated_right_vr->start,
                                    preallocat                                        preallocated_right_vr->size);
           else                                              else
             sos_paging_set_prot_of_interval(p                 sos_paging_set_prot_of_interval(preallocated_right_vr->start,
                                             p                                                 preallocated_right_vr->size,
                                             n                                                 new_access_rights);
                                                   
           if (preallocated_right_vr->ops && p               if (preallocated_right_vr->ops && preallocated_right_vr->ops->ref)
             preallocated_right_vr->ops->ref(p                 preallocated_right_vr->ops->ref(preallocated_right_vr);
                                                   
           vr = vr->next_in_as;                              vr = vr->next_in_as;
           continue;                                         continue;
         }                                                 }
                                                   
       sos_display_fatal_error("BUG");                   sos_display_fatal_error("BUG");
     }                                                 }
                                                   
   if (! used_preallocated_middle_vr)                if (! used_preallocated_middle_vr)
     sos_kmem_vmm_free((sos_vaddr_t)preallocat         sos_kmem_vmm_free((sos_vaddr_t)preallocated_middle_vr);
   if (! used_preallocated_right_vr)                 if (! used_preallocated_right_vr)
     sos_kmem_vmm_free((sos_vaddr_t)preallocat         sos_kmem_vmm_free((sos_vaddr_t)preallocated_right_vr);
                                                   >>  
                                                   >>    return SOS_OK;
                                                   >>  }
                                                   >>  
                                                   >>  
                                                   >>  sos_ret_t
                                                   >>  sos_umem_vmm_sync(struct sos_umem_vmm_as * as,
                                                   >>                    sos_uaddr_t uaddr, sos_size_t size,
                                                   >>                    sos_ui32_t flags)
                                                   >>  {
                                                   >>    if (! SOS_IS_PAGE_ALIGNED(uaddr))
                                                   >>      return -SOS_EINVAL;
                                                   >>    if (size <= 0)
                                                   >>      return -SOS_EINVAL;
                                                   >>    size = SOS_PAGE_ALIGN_SUP(size);
                                                   >>  
                                                   >>    /* Make sure the uaddr is valid */
                                                   >>    if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)
                                                   >>      return -SOS_EINVAL;
                                                   >>    if (uaddr > SOS_PAGING_TOP_USER_ADDRESS - size)
                                                   >>      return -SOS_EINVAL;
                                                   >>  
                                                   >>    /* Go from page to page, and for each dirty page in the region, call
                                                   >>       the sync_page method */
                                                   >>    while (TRUE)
                                                   >>      {
                                                   >>        struct sos_umem_vmm_vr *vr;
                                                   >>  
                                                   >>        if (size <= 0)
                                                   >>          break;
                                                   >>  
                                                   >>        /* Find any VR intersecting with the given interval */
                                                   >>        vr = find_first_intersecting_vr(as, uaddr, size);
                                                   >>        if (NULL == vr)
                                                   >>          break;
                                                   >>  
                                                   >>        /* For private or anonymous mappings => no backing store */
                                                   >>        if ( !(vr->flags & SOS_VR_MAP_SHARED)
                                                   >>             || (vr->mapped_resource->flags & SOS_MAPPED_RESOURCE_ANONYMOUS)
                                                   >>  
                                                   >>             /* Likewise for non msync-able regions */
                                                   >>             || ! vr->ops->sync_page )
                                                   >>          {
                                                   >>            if (size <= vr->size)
                                                   >>              break;
                                                   >>  
                                                   >>            uaddr += vr->size;
                                                   >>            size  -= vr->size;
                                                   >>          }
                                                   >>  
                                                   >>        /* Find the next dirty page in this VR */
                                                   >>        for ( ; (size > 0)
                                                   >>                && (uaddr - vr->start < vr->size) ;
                                                   >>              uaddr += SOS_PAGE_SIZE,
                                                   >>                size -= SOS_PAGE_SIZE)
                                                   >>          if (sos_paging_is_dirty(uaddr))
                                                   >>            {
                                                   >>              /* Synchronize it with its backing store */
                                                   >>              vr->ops->sync_page(vr, uaddr, flags);
                                                   >>              uaddr += SOS_PAGE_SIZE;
                                                   >>              size  -= SOS_PAGE_SIZE;
                                                   >>              break;
                                                   >>            }
                                                   >>      }
                                                   
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t                                         sos_ret_t
 sos_umem_vmm_resize(struct sos_umem_vmm_as *      sos_umem_vmm_resize(struct sos_umem_vmm_as * as,
                     sos_uaddr_t old_uaddr, so                         sos_uaddr_t old_uaddr, sos_size_t old_size,
                     sos_uaddr_t *new_uaddr, s                         sos_uaddr_t *new_uaddr, sos_size_t new_size,
                     sos_ui32_t flags)                                 sos_ui32_t flags)
 {                                                 {
   sos_luoffset_t new_offset_in_resource;            sos_luoffset_t new_offset_in_resource;
   sos_bool_t must_move_vr = FALSE;                  sos_bool_t must_move_vr = FALSE;
   struct sos_umem_vmm_vr *vr, *prev_vr, *next       struct sos_umem_vmm_vr *vr, *prev_vr, *next_vr;
                                                   
   /* Make sure the new uaddr is valid */            /* Make sure the new uaddr is valid */
   if (*new_uaddr < SOS_PAGING_BASE_USER_ADDRE       if (*new_uaddr < SOS_PAGING_BASE_USER_ADDRESS)
     return -SOS_EINVAL;                               return -SOS_EINVAL;
   if (*new_uaddr > SOS_PAGING_TOP_USER_ADDRES       if (*new_uaddr > SOS_PAGING_TOP_USER_ADDRESS - new_size)
     return -SOS_EINVAL;                               return -SOS_EINVAL;
                                                   
   old_uaddr = SOS_PAGE_ALIGN_INF(old_uaddr);        old_uaddr = SOS_PAGE_ALIGN_INF(old_uaddr);
   old_size  = SOS_PAGE_ALIGN_SUP(old_size);         old_size  = SOS_PAGE_ALIGN_SUP(old_size);
   if (! SOS_IS_PAGE_ALIGNED(*new_uaddr))            if (! SOS_IS_PAGE_ALIGNED(*new_uaddr))
     return -SOS_EINVAL;                               return -SOS_EINVAL;
   if (new_size <= 0)                                if (new_size <= 0)
     return -SOS_EINVAL;                               return -SOS_EINVAL;
   new_size = SOS_PAGE_ALIGN_SUP(new_size);          new_size = SOS_PAGE_ALIGN_SUP(new_size);
                                                     
   /* Lookup a VR overlapping the address rang       /* Lookup a VR overlapping the address range */
   vr = find_first_intersecting_vr(as, old_uad       vr = find_first_intersecting_vr(as, old_uaddr, old_size);
   if (! vr)                                         if (! vr)
     return -SOS_EINVAL;                               return -SOS_EINVAL;
                                                     
   /* Make sure there is exactly ONE VR overla       /* Make sure there is exactly ONE VR overlapping the area */
   if ( (vr->start > old_uaddr)                      if ( (vr->start > old_uaddr)
        || (vr->start + vr->size < old_uaddr +            || (vr->start + vr->size < old_uaddr + old_size) )
     return -SOS_EINVAL;                               return -SOS_EINVAL;
                                                   
   /* Retrieve the prev/next VR if they exist        /* Retrieve the prev/next VR if they exist (the VR are on circular
      list) */                                          list) */
   prev_vr = vr->prev_in_as;                         prev_vr = vr->prev_in_as;
   if (prev_vr->start >= vr->start)                  if (prev_vr->start >= vr->start)
     prev_vr = NULL;                                   prev_vr = NULL;
   next_vr = vr->prev_in_as;                         next_vr = vr->prev_in_as;
   if (next_vr->start <= vr->start)                  if (next_vr->start <= vr->start)
     next_vr = NULL;                                   next_vr = NULL;
                                                   
   /*                                                /*
    * Compute new offset inside the mapped res        * Compute new offset inside the mapped resource, if any
    */                                                */
                                                   
   /* Don't allow to resize if the uaddr goes        /* Don't allow to resize if the uaddr goes beyond the 'offset 0' of
      the resource */                                   the resource */
   if ( (*new_uaddr < vr->start)                     if ( (*new_uaddr < vr->start)
        && (vr->start - *new_uaddr > vr->offse            && (vr->start - *new_uaddr > vr->offset_in_resource) )
     return -SOS_EINVAL;                               return -SOS_EINVAL;
                                                     
   /* Compute new offset in the resource (over       /* Compute new offset in the resource (overflow-safe) */
   if (vr->start > *new_uaddr)                       if (vr->start > *new_uaddr)
     new_offset_in_resource                            new_offset_in_resource
       = vr->offset_in_resource                          = vr->offset_in_resource
       - (vr->start - *new_uaddr);                       - (vr->start - *new_uaddr);
   else                                              else
     new_offset_in_resource                            new_offset_in_resource
       = vr->offset_in_resource                          = vr->offset_in_resource
       + (*new_uaddr - vr->start);                       + (*new_uaddr - vr->start);
                                                   
   /* If other VRs would be affected by this r       /* If other VRs would be affected by this resizing, then the VR must
      be moved */                                       be moved */
   if (prev_vr && (prev_vr->start + prev_vr->s       if (prev_vr && (prev_vr->start + prev_vr->size > *new_uaddr))
     must_move_vr |= TRUE;                             must_move_vr |= TRUE;
   if (next_vr && (next_vr->start < *new_uaddr       if (next_vr && (next_vr->start < *new_uaddr + new_size))
     must_move_vr |= TRUE;                             must_move_vr |= TRUE;
                                                   
   /* If VR would be out-of-user-space, it mus       /* If VR would be out-of-user-space, it must be moved */
   if (*new_uaddr < SOS_PAGING_BASE_USER_ADDRE       if (*new_uaddr < SOS_PAGING_BASE_USER_ADDRESS)
     must_move_vr |= TRUE;                             must_move_vr |= TRUE;
   if (*new_uaddr > SOS_PAGING_TOP_USER_ADDRES       if (*new_uaddr > SOS_PAGING_TOP_USER_ADDRESS - new_size)
     must_move_vr |= TRUE;                             must_move_vr |= TRUE;
                                                   
   /* The VR must be moved but the user forbid       /* The VR must be moved but the user forbids it */
   if ( must_move_vr && !(flags & SOS_VR_REMAP       if ( must_move_vr && !(flags & SOS_VR_REMAP_MAYMOVE) )
     return -SOS_EINVAL;                               return -SOS_EINVAL;
                                                   
   /* If the VR must be moved, we simply map t       /* If the VR must be moved, we simply map the resource elsewhere and
      unmap the current VR */                           unmap the current VR */
   if (must_move_vr)                                 if (must_move_vr)
     {                                                 {
       sos_uaddr_t uaddr, result_uaddr;                  sos_uaddr_t uaddr, result_uaddr;
       sos_ret_t retval;                                 sos_ret_t retval;
                                                   
       result_uaddr = *new_uaddr;                        result_uaddr = *new_uaddr;
       retval = sos_umem_vmm_map(as, & result_           retval = sos_umem_vmm_map(as, & result_uaddr, new_size,
                                 vr->access_ri                                     vr->access_rights,
                                 vr->flags | I                                     vr->flags | INTERNAL_MAP_CALLED_FROM_MREMAP,
                                 vr->mapped_re                                     vr->mapped_resource,
                                 new_offset_in                                     new_offset_in_resource);
       if (SOS_OK != retval)                             if (SOS_OK != retval)
         return retval;                                    return retval;
                                                   
       /* Remap the physical pages at their ne           /* Remap the physical pages at their new address */
       for (uaddr = vr->start ;                          for (uaddr = vr->start ;
            uaddr < vr->start + vr->size ;                    uaddr < vr->start + vr->size ;
            uaddr += SOS_PAGE_SIZE)                           uaddr += SOS_PAGE_SIZE)
         {                                                 {
           sos_paddr_t paddr;                                sos_paddr_t paddr;
           sos_ui32_t  prot;                                 sos_ui32_t  prot;
           sos_uaddr_t vaddr;                                sos_uaddr_t vaddr;
                                                             
           if (uaddr < *new_uaddr)                           if (uaddr < *new_uaddr)
             continue;                                         continue;
           if (uaddr > *new_uaddr + new_size)                if (uaddr > *new_uaddr + new_size)
             continue;                                         continue;
                                                   
           /* Compute destination virtual addr               /* Compute destination virtual address (should be
              overflow-safe) */                                 overflow-safe) */
           if (vr->start >= *new_uaddr)                      if (vr->start >= *new_uaddr)
             vaddr = result_uaddr                              vaddr = result_uaddr
               + (uaddr - vr->start)                             + (uaddr - vr->start)
               + (vr->start - *new_uaddr);                       + (vr->start - *new_uaddr);
           else                                              else
             vaddr = result_uaddr                              vaddr = result_uaddr
               + (uaddr - vr->start)                             + (uaddr - vr->start)
               - (*new_uaddr - vr->start);                       - (*new_uaddr - vr->start);
                                                   
           paddr = sos_paging_get_paddr(uaddr)               paddr = sos_paging_get_paddr(uaddr);
           if (! paddr)                                      if (! paddr)
             /* No physical page mapped at thi                 /* No physical page mapped at this address yet */
             continue;                                         continue;
                                                   
           prot  = sos_paging_get_prot(uaddr);               prot  = sos_paging_get_prot(uaddr);
           SOS_ASSERT_FATAL(prot);                           SOS_ASSERT_FATAL(prot);
                                                   
           /* Remap it at its destination addr               /* Remap it at its destination address */
           retval = sos_paging_map(paddr, vadd               retval = sos_paging_map(paddr, vaddr, TRUE, prot);
           if (SOS_OK != retval)                             if (SOS_OK != retval)
             {                                                 {
               sos_umem_vmm_unmap(as, result_u                   sos_umem_vmm_unmap(as, result_uaddr, new_size);
               return retval;                                    return retval;
             }                                                 }
         }                                                 }
                                                   
       retval = sos_umem_vmm_unmap(as, vr->sta           retval = sos_umem_vmm_unmap(as, vr->start, vr->size);
       if (SOS_OK != retval)                             if (SOS_OK != retval)
         {                                                 {
           sos_umem_vmm_unmap(as, result_uaddr               sos_umem_vmm_unmap(as, result_uaddr, new_size);
           return retval;                                    return retval;
         }                                                 }
                                                   
       *new_uaddr = result_uaddr;                        *new_uaddr = result_uaddr;
       return retval;                                    return retval;
     }                                                 }
                                                   
   /* Otherwise we simply resize the VR, takin       /* Otherwise we simply resize the VR, taking care of unmapping
      what's been unmapped  */                          what's been unmapped  */
                                                   
   if (*new_uaddr + new_size < vr->start + vr-       if (*new_uaddr + new_size < vr->start + vr->size)
     sos_umem_vmm_unmap(as, *new_uaddr + new_s         sos_umem_vmm_unmap(as, *new_uaddr + new_size,
                        vr->start + vr->size -                            vr->start + vr->size - (*new_uaddr + new_size));
   else                                              else
     {                                                 {
       as_account_change_of_vr_protection(as,            as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                          *new                                              *new_uaddr + new_size
                                            -                                                 - (vr->start + vr->size),
                                          0, v                                              0, vr->access_rights);
       vr->size += *new_uaddr + new_size - (vr           vr->size += *new_uaddr + new_size - (vr->start + vr->size);
     }                                                 }
                                                     
   if (*new_uaddr > vr->start)                       if (*new_uaddr > vr->start)
     sos_umem_vmm_unmap(as, vr->start, *new_ua         sos_umem_vmm_unmap(as, vr->start, *new_uaddr - vr->start);
   else                                              else
     {                                                 {
       as_account_change_of_vr_protection(as,            as_account_change_of_vr_protection(as, vr->flags & SOS_VR_MAP_SHARED,
                                          vr->                                              vr->start - *new_uaddr,
                                          0, v                                              0, vr->access_rights);
       vr->size  += vr->start - *new_uaddr;              vr->size  += vr->start - *new_uaddr;
       vr->start  = *new_uaddr;                          vr->start  = *new_uaddr;
       vr->offset_in_resource = new_offset_in_           vr->offset_in_resource = new_offset_in_resource; 
     }                                                 }
                                                   
   SOS_ASSERT_FATAL(vr->start == *new_uaddr);        SOS_ASSERT_FATAL(vr->start == *new_uaddr);
   SOS_ASSERT_FATAL(vr->size  == new_size);          SOS_ASSERT_FATAL(vr->size  == new_size);
   SOS_ASSERT_FATAL(vr->offset_in_resource ==        SOS_ASSERT_FATAL(vr->offset_in_resource == new_offset_in_resource);
                                                   
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t sos_umem_vmm_try_resolve_page_fault     sos_ret_t sos_umem_vmm_try_resolve_page_fault(sos_uaddr_t uaddr,
                                                                                                 sos_bool_t write_access,
                                                                                                 sos_bool_t user_access)
 {                                                 {
   struct sos_process     *process = sos_threa       struct sos_process     *process = sos_thread_get_current()->process;
   struct sos_umem_vmm_as *as;                       struct sos_umem_vmm_as *as;
   struct sos_umem_vmm_vr *vr;                       struct sos_umem_vmm_vr *vr;
                                                   
   if (! process)                                    if (! process)
     return -SOS_EFAULT;                               return -SOS_EFAULT;
                                                   
   as = sos_process_get_address_space(process)       as = sos_process_get_address_space(process);
   if (! as)                                         if (! as)
     return -SOS_EFAULT;                               return -SOS_EFAULT;
                                                   
   vr = find_first_intersecting_vr(as, uaddr,        vr = find_first_intersecting_vr(as, uaddr, 1);
   if (! vr)                                         if (! vr)
     return -SOS_EFAULT;                               return -SOS_EFAULT;
                                                   
   /* Write on a read-only VR */                     /* Write on a read-only VR */
   if (write_access && !(vr->access_rights & S       if (write_access && !(vr->access_rights & SOS_VM_MAP_PROT_WRITE))
     return -SOS_EFAULT;                               return -SOS_EFAULT;
                                                   
   /* Write on a COW VR */                           /* Write on a COW VR */
   if (write_access && !(vr->flags & SOS_VR_MA       if (write_access && !(vr->flags & SOS_VR_MAP_SHARED))
     {                                                 {
       if (SOS_OK == sos_paging_try_resolve_CO           if (SOS_OK == sos_paging_try_resolve_COW(uaddr))
         {                                                 {
           as->pgflt_cow ++;                                 as->pgflt_cow ++;
           return SOS_OK;                                    return SOS_OK;
         }                                                 }
     }                                                 }
                                                   
   /* Ask the underlying resource to resolve t       /* Ask the underlying resource to resolve the page fault */
   if (SOS_OK != vr->ops->page_in(vr, uaddr, w       if (SOS_OK != vr->ops->page_in(vr, uaddr, write_access))
     {                                                 {
       as->pgflt_invalid ++;                             as->pgflt_invalid ++;
       return -SOS_EFAULT;                               return -SOS_EFAULT;
     }                                                 }
                                                   
   as->phys_total += SOS_PAGE_SIZE;                  as->phys_total += SOS_PAGE_SIZE;
   as->pgflt_page_in ++;                             as->pgflt_page_in ++;
                                                   
   /* For a private mapping, keep the mapping        /* For a private mapping, keep the mapping read-only */
   if (!(vr->flags & SOS_VR_MAP_SHARED))             if (!(vr->flags & SOS_VR_MAP_SHARED))
     {                                                 {
       sos_paging_prepare_COW(SOS_PAGE_ALIGN_I           sos_paging_prepare_COW(SOS_PAGE_ALIGN_INF(uaddr),
                              SOS_PAGE_SIZE);                                   SOS_PAGE_SIZE);
     }                                                 }
                                                   
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_ret_t                                         sos_ret_t
 sos_umem_vmm_init_heap(struct sos_umem_vmm_as     sos_umem_vmm_init_heap(struct sos_umem_vmm_as * as,
                        sos_uaddr_t heap_start                            sos_uaddr_t heap_start)
 {                                                 {
   SOS_ASSERT_FATAL(! as->heap_start);               SOS_ASSERT_FATAL(! as->heap_start);
                                                   
   as->heap_start = heap_start;                      as->heap_start = heap_start;
   as->heap_size  = 0;                               as->heap_size  = 0;
   return SOS_OK;                                    return SOS_OK;
 }                                                 }
                                                   
                                                   
 sos_uaddr_t                                       sos_uaddr_t
 sos_umem_vmm_brk(struct sos_umem_vmm_as * as,     sos_umem_vmm_brk(struct sos_umem_vmm_as * as,
                  sos_uaddr_t new_top_uaddr)                        sos_uaddr_t new_top_uaddr)
 {                                                 {
   sos_uaddr_t new_start;                            sos_uaddr_t new_start;
   sos_size_t  new_size;                             sos_size_t  new_size;
   SOS_ASSERT_FATAL(as->heap_start);                 SOS_ASSERT_FATAL(as->heap_start);
                                                   
   if (! new_top_uaddr)                              if (! new_top_uaddr)
     return as->heap_start + as->heap_size;            return as->heap_start + as->heap_size;
                                                   
   if (new_top_uaddr == as->heap_start + as->h       if (new_top_uaddr == as->heap_start + as->heap_size)
     return as->heap_start + as->heap_size;            return as->heap_start + as->heap_size;
                                                    
   if (new_top_uaddr < as->heap_start)               if (new_top_uaddr < as->heap_start)
     return (sos_uaddr_t)NULL;                         return (sos_uaddr_t)NULL;
                                                   
   new_top_uaddr = SOS_PAGE_ALIGN_SUP(new_top_       new_top_uaddr = SOS_PAGE_ALIGN_SUP(new_top_uaddr);
   new_start = as->heap_start;                       new_start = as->heap_start;
   new_size  = new_top_uaddr - as->heap_start;       new_size  = new_top_uaddr - as->heap_start;
                                                   
   /* First call to brk: we must map /dev/zero       /* First call to brk: we must map /dev/zero */
   if (! as->heap_size)                              if (! as->heap_size)
     {                                                 {
       if (SOS_OK != sos_dev_zero_map(as, & as           if (SOS_OK != sos_dev_zero_map(as, & as->heap_start,
                                      new_size                                          new_size,
                                      SOS_VM_M                                          SOS_VM_MAP_PROT_READ
                                      | SOS_VM                                          | SOS_VM_MAP_PROT_WRITE,
                                      0 /* pri                                          0 /* private non-fixed */))
         return (sos_uaddr_t)NULL;                         return (sos_uaddr_t)NULL;
                                                   
       as->heap_size = new_size;                         as->heap_size = new_size;
       return as->heap_start + as->heap_size;            return as->heap_start + as->heap_size;
     }                                                 }
                                                   
   /* Otherwise we just have to unmap or resiz       /* Otherwise we just have to unmap or resize the region */
   if (new_size <= 0)                                if (new_size <= 0)
     {                                                 {
       if (SOS_OK != sos_umem_vmm_unmap(as,              if (SOS_OK != sos_umem_vmm_unmap(as,
                                        as->he                                            as->heap_start, as->heap_size))
         return (sos_uaddr_t)NULL;                         return (sos_uaddr_t)NULL;
     }                                                 }
   else                                              else
     {                                                 {
       if (SOS_OK != sos_umem_vmm_resize(as,             if (SOS_OK != sos_umem_vmm_resize(as,
                                         as->h                                             as->heap_start, as->heap_size,
                                         & new                                             & new_start, new_size,
                                         0))                                               0))
         return (sos_uaddr_t)NULL;                         return (sos_uaddr_t)NULL;
     }                                                 }
                                                   
   SOS_ASSERT_FATAL(new_start == as->heap_star       SOS_ASSERT_FATAL(new_start == as->heap_start);
   as->heap_size = new_size;                         as->heap_size = new_size;
   return new_top_uaddr;                             return new_top_uaddr;
 }                                                 }
                                                   
                                                   
 static struct sos_umem_vmm_vr *                   static struct sos_umem_vmm_vr *
 find_enclosing_or_next_vr(struct sos_umem_vmm     find_enclosing_or_next_vr(struct sos_umem_vmm_as * as,
                           sos_uaddr_t uaddr)                                sos_uaddr_t uaddr)
 {                                                 {
   struct sos_umem_vmm_vr *vr;                       struct sos_umem_vmm_vr *vr;
   int nb_vr;                                        int nb_vr;
                                                   
   if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)         if (uaddr < SOS_PAGING_BASE_USER_ADDRESS)
     return NULL;                                      return NULL;
   if (uaddr > SOS_PAGING_TOP_USER_ADDRESS)          if (uaddr > SOS_PAGING_TOP_USER_ADDRESS)
     return NULL;                                      return NULL;
                                                   
   list_foreach_named(as->list_vr, vr, nb_vr,        list_foreach_named(as->list_vr, vr, nb_vr, prev_in_as, next_in_as)
     {                                                 {
       /* Equivalent to "if (uaddr < vr->start           /* Equivalent to "if (uaddr < vr->start + vr->size)" but more
          robust (resilient to integer overflo              robust (resilient to integer overflows) */
       if (uaddr <= vr->start + (vr->size - 1)           if (uaddr <= vr->start + (vr->size - 1))
         return vr;                                        return vr;
     }                                                 }
                                                   
   return NULL;                                      return NULL;
 }                                                 }
                                                   
                                                   
 static struct sos_umem_vmm_vr *                   static struct sos_umem_vmm_vr *
 find_first_intersecting_vr(struct sos_umem_vm     find_first_intersecting_vr(struct sos_umem_vmm_as * as,
                            sos_uaddr_t start_                                sos_uaddr_t start_uaddr, sos_size_t size)
 {                                                 {
   struct sos_umem_vmm_vr * vr;                      struct sos_umem_vmm_vr * vr;
   vr = find_enclosing_or_next_vr(as, start_ua       vr = find_enclosing_or_next_vr(as, start_uaddr);
   if (! vr)                                         if (! vr)
     return NULL;                                      return NULL;
                                                   
   if (start_uaddr + size <= vr->start)              if (start_uaddr + size <= vr->start)
     return NULL;                                      return NULL;
                                                   
   return vr;                                        return vr;
 }                                                 }
                                                   
                                                   
 static sos_uaddr_t                                static sos_uaddr_t
 find_first_free_interval(struct sos_umem_vmm_     find_first_free_interval(struct sos_umem_vmm_as * as,
                          sos_uaddr_t hint_uad                              sos_uaddr_t hint_uaddr, sos_size_t size)
 {                                                 {
   struct sos_umem_vmm_vr * initial_vr, * vr;        struct sos_umem_vmm_vr * initial_vr, * vr;
                                                   
   if (hint_uaddr < SOS_PAGING_BASE_USER_ADDRE       if (hint_uaddr < SOS_PAGING_BASE_USER_ADDRESS)
     hint_uaddr = SOS_PAGING_BASE_USER_ADDRESS         hint_uaddr = SOS_PAGING_BASE_USER_ADDRESS;
                                                   
   if (hint_uaddr > SOS_PAGING_TOP_USER_ADDRES       if (hint_uaddr > SOS_PAGING_TOP_USER_ADDRESS - size + 1)
     return (sos_uaddr_t)NULL;                         return (sos_uaddr_t)NULL;
                                                   
   initial_vr = vr = find_enclosing_or_next_vr       initial_vr = vr = find_enclosing_or_next_vr(as, hint_uaddr);
   if (! vr)                                         if (! vr)
     /* Great, there is nothing after ! */             /* Great, there is nothing after ! */
     return hint_uaddr;                                return hint_uaddr;
                                                   
   /* Scan the remaining VRs in the list */          /* Scan the remaining VRs in the list */
   do                                                do
     {                                                 {
       /* Is there enough space /before/ that            /* Is there enough space /before/ that VR ? */
       if (hint_uaddr + size <= vr->start)               if (hint_uaddr + size <= vr->start)
         /* Great ! */                                     /* Great ! */
         return hint_uaddr;                                return hint_uaddr;
                                                   
       /* Is there any VR /after/ this one, or           /* Is there any VR /after/ this one, or do we have to wrap back
          at the begining of the user space ?               at the begining of the user space ? */
       if (vr->next_in_as->start >= hint_uaddr           if (vr->next_in_as->start >= hint_uaddr)
         /* Ok, the next VR is really after us             /* Ok, the next VR is really after us */
         hint_uaddr = vr->start + vr->size;                hint_uaddr = vr->start + vr->size;
       else                                              else
         {                                                 {
           /* No: wrapping up */                             /* No: wrapping up */
                                                   
           /* Is there any space before the en               /* Is there any space before the end of user space ? */
           if (hint_uaddr <= SOS_PAGING_TOP_US               if (hint_uaddr <= SOS_PAGING_TOP_USER_ADDRESS - size)
             return hint_uaddr;                                return hint_uaddr;
                                                   
           hint_uaddr = SOS_PAGING_BASE_USER_A               hint_uaddr = SOS_PAGING_BASE_USER_ADDRESS;
         }                                                 }
                                                   
       /* Prepare to look after this VR */               /* Prepare to look after this VR */
       vr = vr->next_in_as;                              vr = vr->next_in_as;
     }                                                 }
   while (vr != initial_vr);                         while (vr != initial_vr);
                                                   
   /* Reached the end of the list and did not        /* Reached the end of the list and did not find anything ?... Look
      at the space after the last VR */                 at the space after the last VR */
                                                   
   return (sos_uaddr_t)NULL;                         return (sos_uaddr_t)NULL;
 }                                                 }
                                                   
                                                   
 static void                                       static void
 as_account_change_of_vr_protection(struct sos     as_account_change_of_vr_protection(struct sos_umem_vmm_as * as,
                                    sos_bool_t                                        sos_bool_t is_shared,
                                    sos_size_t                                        sos_size_t size,
                                    sos_ui32_t                                        sos_ui32_t prev_access_rights,
                                    sos_ui32_t                                        sos_ui32_t new_access_rights)
 {                                                 {
   if (prev_access_rights == new_access_rights       if (prev_access_rights == new_access_rights)
     return;                                           return;
                                                   
 #define _UPDATE_VMSTAT(field,is_increment) \      #define _UPDATE_VMSTAT(field,is_increment) \
   ({ if (is_increment > 0) \                        ({ if (is_increment > 0) \
        as->field += size; \                              as->field += size; \
      else \                                            else \
        { SOS_ASSERT_FATAL(as->field >= size);            { SOS_ASSERT_FATAL(as->field >= size); as->field -= size; } })
 #define UPDATE_VMSTAT(field,is_increment) \       #define UPDATE_VMSTAT(field,is_increment) \
   ({ if (is_shared) _UPDATE_VMSTAT(vm_shrd.fi       ({ if (is_shared) _UPDATE_VMSTAT(vm_shrd.field, is_increment); \
      _UPDATE_VMSTAT(vm_total.field, is_increm          _UPDATE_VMSTAT(vm_total.field, is_increment); \
      SOS_ASSERT_FATAL(as->vm_total.field >= a          SOS_ASSERT_FATAL(as->vm_total.field >= as->vm_shrd.field); })
                                                   
   if ( (new_access_rights & SOS_VM_MAP_PROT_W       if ( (new_access_rights & SOS_VM_MAP_PROT_WRITE)
        && !(prev_access_rights & SOS_VM_MAP_P            && !(prev_access_rights & SOS_VM_MAP_PROT_WRITE))
     {                                                 {
       UPDATE_VMSTAT(rw, +1);                            UPDATE_VMSTAT(rw, +1);
       if (prev_access_rights & SOS_VM_MAP_PRO           if (prev_access_rights & SOS_VM_MAP_PROT_READ)
         UPDATE_VMSTAT(ro, -1);                            UPDATE_VMSTAT(ro, -1);
     }                                                 }
   else if ( !(new_access_rights & SOS_VM_MAP_       else if ( !(new_access_rights & SOS_VM_MAP_PROT_WRITE)
             && (prev_access_rights & SOS_VM_M                 && (prev_access_rights & SOS_VM_MAP_PROT_WRITE))
     {                                                 {
       if (new_access_rights & SOS_VM_MAP_PROT           if (new_access_rights & SOS_VM_MAP_PROT_READ)
         UPDATE_VMSTAT(ro, +1);                            UPDATE_VMSTAT(ro, +1);
       UPDATE_VMSTAT(rw, -1);                            UPDATE_VMSTAT(rw, -1);
     }                                                 }
   else if (new_access_rights & SOS_VM_MAP_PRO       else if (new_access_rights & SOS_VM_MAP_PROT_READ)
     UPDATE_VMSTAT(ro, +1);                            UPDATE_VMSTAT(ro, +1);
   else if (!(new_access_rights & SOS_VM_MAP_P       else if (!(new_access_rights & SOS_VM_MAP_PROT_READ))
     UPDATE_VMSTAT(ro, -1);                            UPDATE_VMSTAT(ro, -1);
                                                   
   if ( (new_access_rights & SOS_VM_MAP_PROT_E       if ( (new_access_rights & SOS_VM_MAP_PROT_EXEC)
        && !(prev_access_rights & SOS_VM_MAP_P            && !(prev_access_rights & SOS_VM_MAP_PROT_EXEC))
     {                                                 {
       UPDATE_VMSTAT(code, +1);                          UPDATE_VMSTAT(code, +1);
     }                                                 }
   else if ( !(new_access_rights & SOS_VM_MAP_       else if ( !(new_access_rights & SOS_VM_MAP_PROT_EXEC)
             && (prev_access_rights & SOS_VM_M                 && (prev_access_rights & SOS_VM_MAP_PROT_EXEC))
     {                                                 {
       UPDATE_VMSTAT(code, -1);                          UPDATE_VMSTAT(code, -1);
     }                                                 }
                                                   
   if (new_access_rights && !prev_access_right       if (new_access_rights && !prev_access_rights)
     UPDATE_VMSTAT(overall, +1);                       UPDATE_VMSTAT(overall, +1);
   else if (!new_access_rights && prev_access_       else if (!new_access_rights && prev_access_rights)
     UPDATE_VMSTAT(overall, -1);                       UPDATE_VMSTAT(overall, -1);
                                                   
 }                                                 }