examples/fdpicxip, testing/fs/xipfs: A DT_NEEDED library is one instance.

Both the demo and the test asserted that each running instance of a module
gets its own copy of a library named in DT_NEEDED: two instances adding
their own seed each saw a total of seed*3.

That was true of the loader that walked DT_NEEDED itself.  The loader now
hands the work to dlopen(), which returns the object already in the module
registry rather than loading a second copy of it, so there is one library
and one set of its globals, shared by every module that names it.  The
module's own data stays private per instance, because exec() loads the
module afresh each time.

What an instance can still assert on its own is that every add it made
landed in the library, so that is what it checks; the totals interleave and
the final one counts both.  The test additionally checks the consequences:
the library is pinned once rather than once per instance, and its
destructor runs once, at the last close, holding what both instances built
up.

Assisted-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Marco Casaroli <marco.casaroli@gmail.com>

Author: casaroli

examples/fdpicxip/cxxuser_bin.h

@@ -144,7 +144,7 @@ static const unsigned char g_cxxuser[] =
   0x34, 0x4b, 0x03, 0x93, 0x30, 0x46, 0xff, 0xf7, 0x35, 0xff, 0x03, 0x98,
   0xa1, 0x46, 0xff, 0xf7, 0x45, 0xff, 0xba, 0xf1, 0x01, 0x0a, 0xa1, 0x46,
   0xf4, 0xd1, 0xff, 0xf7, 0x49, 0xff, 0x06, 0xeb, 0x46, 0x0a, 0xa1, 0x46,
-  0x50, 0x45, 0x18, 0xbf, 0x45, 0xf0, 0x08, 0x05, 0xff, 0xf7, 0x40, 0xff,
+  0x50, 0x45, 0xb8, 0xbf, 0x45, 0xf0, 0x08, 0x05, 0xff, 0xf7, 0x40, 0xff,
   0xa1, 0x46, 0x03, 0x46, 0x00, 0x2d, 0x38, 0xd1, 0x2c, 0x4a, 0x7a, 0x44,
   0x2c, 0x49, 0xcd, 0xe9, 0x00, 0xa2, 0x06, 0x20, 0x32, 0x46, 0x79, 0x44,
   0xff, 0xf7, 0x5a, 0xff, 0xb8, 0xf1, 0x03, 0x0f, 0xa1, 0x46, 0x1a, 0xdd,
@@ -175,7 +175,7 @@ static const unsigned char g_cxxuser[] =
   0x69, 0x72, 0x73, 0x74, 0x3a, 0x20, 0x25, 0x73, 0x0a, 0x00, 0x5b, 0x75,
   0x73, 0x65, 0x72, 0x20, 0x25, 0x64, 0x5d, 0x20, 0x6c, 0x69, 0x62, 0x72,
   0x61, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x20, 0x3d, 0x20,
-  0x25, 0x64, 0x20, 0x28, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64,
+  0x25, 0x64, 0x20, 0x28, 0x61, 0x74, 0x20, 0x6c, 0x65, 0x61, 0x73, 0x74,
   0x20, 0x25, 0x64, 0x29, 0x20, 0x2d, 0x2d, 0x20, 0x25, 0x73, 0x0a, 0x00,
   0x25, 0x64, 0x00, 0x5b, 0x75, 0x73, 0x65, 0x72, 0x5d, 0x20, 0x63, 0x61,
   0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x20,

examples/fdpicxip/fdpicxip_main.c

@@ -111,9 +111,10 @@ static int extent_info_path(FAR const char *path,
  *
  * Stages a library and a module that needs it, then runs two instances.
  * Both share one mapped copy of each object's code, executed in place from
- * flash, while each instance gets private copies of both the module's data
- * and the library's.  If the library's state were shared, the two totals
- * would interleave instead of each reaching seed*3.
+ * flash.  Each instance gets its own copy of the module's data, because
+ * exec() loads the module afresh; the library is opened with dlopen() and
+ * so there is one of it, data included.  The totals therefore interleave,
+ * and each instance checks only that its own adds all landed.
  ****************************************************************************/
 
 static int stage_blob(FAR const char *path, FAR const unsigned char *data,

examples/fdpicxip/modules/Makefile

@@ -46,10 +46,10 @@ CPU ?= cortex-m3
 
 FDPICDIR  = $(NUTTX_DIR)/tools/fdpic
 MODULE_MK = $(FDPICDIR)/nuttx-fdpic.mk
-EMBED     = $(FDPICDIR)/fdpic-embed
+EMBED     = $(FDPICDIR)/fdpic-embed.py
 
 # Where each generated header goes, and its path from the repository root --
-# fdpic-embed puts that on line 2, which is what nxstyle wants.
+# fdpic-embed.py puts that on line 2, which is what nxstyle wants.
 
 DEMODIR = ..
 DEMOREL = apps/examples/fdpicxip
@@ -127,7 +127,7 @@ lazymod.fdpic: lazymod.c
 	$(BUILD) MODULE=lazymod SRCS=lazymod.c BINDNOW=
 
 # missingsym is linked with the bare .fdpic target rather than the default
-# 'verify' one, because it is exactly what fdpic-verify is meant to catch.
+# 'verify' one, because it is exactly what fdpic-verify.sh is meant to catch.
 
 missingsym.fdpic: missingsym.c
 	$(BUILD) MODULE=missingsym SRCS=missingsym.c missingsym.fdpic

examples/fdpicxip/modules/cxxuser.cpp

@@ -28,9 +28,12 @@
  *   - constructors ran, in both objects.  Neither magic can be right by
  *     accident: an unconstructed global is zero.
  *   - the library's constructors ran before this module's, which is the
- *     ordering DT_NEEDED implies and the loader has to honour.
- *   - the library's data is private per instance.  One copy of its code
- *     sits in flash; the totals do not interleave.
+ *     ordering DT_NEEDED implies and the loader has to honour.  They ran
+ *     once, for the one library, not once per instance.
+ *   - the library is one object shared by both instances.  DT_NEEDED is
+ *     loaded with dlopen(), which returns what is already in the module
+ *     registry, so the totals interleave rather than each reaching seed*3.
+ *     Each instance can still see every add it made.
  */
 
 #include <fcntl.h>
@@ -87,7 +90,7 @@ static Instance g_self;
 #define USER_FAIL_OWN_CTOR  0x01
 #define USER_FAIL_LIB_CTOR  0x02
 #define USER_FAIL_ORDER     0x04
-#define USER_FAIL_PRIVATE   0x08
+#define USER_FAIL_SHARED    0x08
 
 /****************************************************************************
  * Name: record
@@ -188,12 +191,17 @@ extern "C" int main(int argc, char *argv[])
       usleep(100000);
     }
 
-  if (shape_total() != seed * 3)
+  /* The other instance is adding to the same library at the same time, so
+   * the total is not this instance's alone.  What must hold is that every
+   * add this instance made landed in it.
+   */
+
+  if (shape_total() < seed * 3)
     {
-      fails |= USER_FAIL_PRIVATE;
+      fails |= USER_FAIL_SHARED;
     }
 
-  syslog(LOG_INFO, "[user %d] library total = %d (expected %d) -- %s\n",
+  syslog(LOG_INFO, "[user %d] library total = %d (at least %d) -- %s\n",
          seed, shape_total(), seed * 3,
          fails == 0 ? "PASS" : "FAIL");
 

examples/fdpicxip/modules/libcounter.c

@@ -23,8 +23,11 @@
 /* A shared library with its own state.
  *
  * g_calls is the interesting part: it lives in the library's writable
- * segment, and each task that loads the library gets a private copy.  The
- * library's code, meanwhile, is mapped once and executed in place.
+ * segment, and there is one of it.  A library named in DT_NEEDED is opened
+ * with dlopen(), which hands back the instance already in the module
+ * registry, so every task that names this library counts into the same
+ * g_calls.  The library's code, meanwhile, is mapped once and executed in
+ * place.
  */
 
 /****************************************************************************

examples/fdpicxip/modules/libshape.cpp

@@ -31,8 +31,10 @@
  * this is here to catch does not announce itself.
  *
  * m_total is the second half: it lives in the library's writable segment,
- * which is copied once per running instance, so two tasks sharing this
- * library's flash-resident code still count independently.
+ * of which there is one.  A library named in DT_NEEDED is opened with
+ * dlopen(), which returns the object already in the module registry, so
+ * two tasks naming this library share its data as well as its
+ * flash-resident code, and m_total ends up counting both of them.
  */
 
 #include <fcntl.h>

examples/fdpicxip/modules/user.c

@@ -20,8 +20,12 @@
  *
  ****************************************************************************/
 
-/* Uses libcounter.so.  Two instances run concurrently: if the library's
- * data were shared between them the totals would interleave.
+/* Uses libcounter.so.  Two instances run concurrently, and there is one
+ * library between them: DT_NEEDED is loaded with dlopen(), which returns
+ * the object already in the registry rather than a second copy of it, so
+ * the totals interleave and the final one counts both instances' bumps.
+ * What each instance can assert on its own is that every bump it made
+ * landed somewhere it can still see.
  *
  * libcounter is also a *leaf* library -- it calls nothing outside itself,
  * so it has no PLT and therefore no DT_PLTGOT.  The loader has to fall back
@@ -56,13 +60,13 @@ int main(int argc, char *argv[])
       usleep(100000);
     }
 
-  syslog(LOG_INFO, "[user %d] library total = %d (expected %d) -- %s\n",
+  syslog(LOG_INFO, "[user %d] library total = %d (at least %d) -- %s\n",
          seed, counter_total(), seed * 3,
-         counter_total() == seed * 3 ? "PASS" : "FAIL");
+         counter_total() >= seed * 3 ? "PASS" : "FAIL");
 
   /* Reported through the exit status as well as the log, so a test can
    * assert on it rather than a human reading the console.
    */
 
-  return counter_total() == seed * 3 ? EXIT_SUCCESS : EXIT_FAILURE;
+  return counter_total() >= seed * 3 ? EXIT_SUCCESS : EXIT_FAILURE;
 }