sched/addrenv, binfmt: Always allocate address environment from heap

Instead of using a volatile storage for the address environment in the
binfmt / loadinfo structures, always allocate the address environment
from kheap.

This serves two purposes:
- If the task creation fails, any kernel thread that depends on the
  address environment created during task creation will not lose their
  mappings (because they hold a reference to it)
- The current address environment variable (g_addrenv) will NEVER contain
  a stale / incorrect value
- Releasing the address environment is simplified as any pointer given
  to addrenv_drop() can be assumed to be heap memory
- Makes the kludge function addrenv_clear_current irrelevant, as the
  system will NEVER have invalid mappings any more

sched/addrenv/addrenv.c

@@ -86,35 +86,6 @@ static void addrenv_destroy(FAR void *arg)
   kmm_free(addrenv);
 }
 
-/****************************************************************************
- * Name: addrenv_clear_current
- *
- * Description:
- *   Clear the current addrenv from g_addrenv, if it matches the input.
- *
- * Input Parameters:
- *   addrenv - Pointer to the addrenv to free.
- *
- * Returned Value:
- *   None.
- *
- ****************************************************************************/
-
-static void addrenv_clear_current(FAR const addrenv_t *addrenv)
-{
-  int i;
-
-  /* Mark no address environment */
-
-  for (i = 0; i < CONFIG_SMP_NCPUS; i++)
-    {
-      if (addrenv == g_addrenv[i])
-        {
-          g_addrenv[i] = NULL;
-        }
-    }
-}
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -237,62 +208,26 @@ int addrenv_switch(FAR struct tcb_s *tcb)
  *   Allocate an address environment for a new process.
  *
  * Input Parameters:
- *   tcb   - The tcb of the newly created task.
- *   ttype - The type of the task.
+ *   None
  *
  * Returned Value:
- *   This is a NuttX internal function so it follows the convention that
- *   0 (OK) is returned on success and a negated errno is returned on
- *   failure.
+ *   Pointer to the new address environment, or NULL if out of memory.
  *
  ****************************************************************************/
 
-int addrenv_allocate(FAR struct tcb_s *tcb, uint8_t ttype)
+FAR struct addrenv_s *addrenv_allocate(void)
 {
-  int ret = OK;
+  FAR struct addrenv_s *addrenv;
 
-  if ((ttype & TCB_FLAG_TTYPE_MASK) == TCB_FLAG_TTYPE_KERNEL)
+  addrenv = (FAR struct addrenv_s *)kmm_zalloc(sizeof(struct addrenv_s));
+  if (addrenv)
     {
-      tcb->addrenv_own = NULL;
-    }
-  else
-    {
-      tcb->addrenv_own = (FAR struct addrenv_s *)
-        kmm_zalloc(sizeof(struct addrenv_s));
-      if (tcb->addrenv_own == NULL)
-        {
-          ret = -ENOMEM;
-        }
+      /* Take reference so this won't get freed */
+
+      addrenv->refs = 1;
     }
 
-  return ret;
-}
-
-/****************************************************************************
- * Name: addrenv_free
- *
- * Description:
- *   Free an address environment for a process.
- *
- * Input Parameters:
- *   tcb - The tcb of the task.
- *
- * Returned Value:
- *   This is a NuttX internal function so it follows the convention that
- *   0 (OK) is returned on success and a negated errno is returned on
- *   failure.
- *
- ****************************************************************************/
-
-int addrenv_free(FAR struct tcb_s *tcb)
-{
-  if (tcb->addrenv_own != NULL)
-    {
-      kmm_free(tcb->addrenv_own);
-      tcb->addrenv_own = NULL;
-    }
-
-  return OK;
+  return addrenv;
 }
 
 /****************************************************************************
@@ -313,24 +248,12 @@ int addrenv_free(FAR struct tcb_s *tcb)
  *
  ****************************************************************************/
 
-int addrenv_attach(FAR struct tcb_s *tcb,
-                   FAR const struct addrenv_s *addrenv)
+int addrenv_attach(FAR struct tcb_s *tcb, FAR struct addrenv_s *addrenv)
 {
-  int ret;
-
-  /* Clone the address environment for us */
-
-  ret = up_addrenv_clone(&addrenv->addrenv, &tcb->addrenv_own->addrenv);
-  if (ret < 0)
-    {
-      berr("ERROR: up_addrenv_clone failed: %d\n", ret);
-      return ret;
-    }
-
   /* Attach the address environment */
 
+  tcb->addrenv_own = addrenv;
   tcb->addrenv_curr = tcb->addrenv_own;
-  tcb->addrenv_own->refs = 1;
 
   return OK;
 }
@@ -452,14 +375,6 @@ int addrenv_restore(void)
 {
   FAR struct tcb_s *tcb = this_task();
   addrenv_give(tcb->addrenv_curr);
-
-  if (tcb->addrenv_own == NULL)
-    {
-      /* Kernel thread, clear g_addrenv, as it is not valid any more */
-
-      addrenv_clear_current(tcb->addrenv_curr);
-    }
-
   tcb->addrenv_curr = tcb->addrenv_own;
   return addrenv_switch(tcb);
 }

sched/task/task_init.c

@@ -97,12 +97,11 @@ int nxtask_init(FAR struct task_tcb_s *tcb, const char *name, int priority,
 #endif
 
 #ifdef CONFIG_ARCH_ADDRENV
-  /* Allocate address environment for the task */
+  /* Kernel threads do not own any address environment */
 
-  ret = addrenv_allocate(&tcb->cmn, tcb->cmn.flags);
-  if (ret < 0)
+  if ((ttype & TCB_FLAG_TTYPE_MASK) == TCB_FLAG_TTYPE_KERNEL)
     {
-      return ret;
+      tcb->cmn.addrenv_own = NULL;
     }
 #endif
 
@@ -111,7 +110,7 @@ int nxtask_init(FAR struct task_tcb_s *tcb, const char *name, int priority,
   ret = group_allocate(tcb, tcb->cmn.flags);
   if (ret < 0)
     {
-      goto errout_with_addrenv;
+      return ret;
     }
 
   /* Duplicate the parent tasks environment */
@@ -201,10 +200,6 @@ errout_with_group:
 
   group_leave(&tcb->cmn);
 
-errout_with_addrenv:
-#ifdef CONFIG_ARCH_ADDRENV
-  addrenv_free(&tcb->cmn);
-#endif
   return ret;
 }