RDMA: provide kernel-symbol stub so RDMA_Transporter-t links in CI

`RDMA_Transporter-t` is registered via `NDB_ADD_TEST` in
`storage/ndb/src/common/transporter/CMakeLists.txt`. The target
returns silently from the macro when `WITH_UNIT_TESTS=OFF`, but
the option defaults to ON whenever `WITHOUT_SERVER=OFF` (see
`CMakeLists.txt:843-849`), which is the standard configure
RonDB CI uses for a release build. Under that combination the
test executable is created, and the link step has been failing
since the target was first added:

    storage/ndb/src/common/transporter/CMakeFiles/
        RDMA_Transporter-t.dir/build.make:130:
    undefined reference to
      `copy(unsigned int*&, SectionSegmentPool&,
            SegmentedSectionPtr const&)'

Root cause is independent of the RDMA-side code. `Packer.cpp`
(part of the `ndbtransport` convenience library that the test
binary links against) emits an unconditional explicit
instantiation:

    template void Packer::pack<Packer::SegmentedSectionArg>(
        Uint32 *theData, SegmentedSectionArg section) const;

That instantiation references the free function

    bool copy(unsigned int *&, SectionSegmentPool &,
              SegmentedSectionPtr const &);

whose definition lives on the kernel side of the build,
alongside the `SegmentSubPool` / `SegmentedSectionPtr`
implementations. None of the libraries the test depends on
(`ndbtransport`, `ndbmgmapi`, `ndbgeneral`, `ndbportlib`,
`${NDB_RDMA_LIBRARIES}`, `mytap`) define the symbol, so the
linker cannot resolve it. Whether or not the call path is
reachable at runtime is irrelevant -- the explicit template
instantiation forces emission of the reference at compile
time.

The standalone harness `build_scripts/build_and_test_rdma_
transporter.sh` already works around the same issue by
generating a tiny stub source on the fly and linking it
into a hand-built test binary. This change bakes the same
stub into the regular CMake build so the
`WITH_UNIT_TESTS=ON` CI path can link `RDMA_Transporter-t`
without dragging in any kernel-side libraries.

Changes
-------

`storage/ndb/src/common/transporter/RDMA_Transporter_test_stubs.cpp`
(new file)
  - Defines `bool copy(unsigned int *&, SectionSegmentPool &,
    SegmentedSectionPtr const &)` as an abort-stub. The wire-format
    TAP cases exercised by the test executable touch only the
    pure helpers `encode_msg_header` /
    `validate_msg_header` and small in-anonymous-namespace
    routines; none of those paths invoke
    `Packer::pack<SegmentedSectionArg>`, so the stub is never
    reached at runtime. If a future test addition does hit it
    the abort produces a clear diagnostic identifying the stub
    by name. Opaque forward declarations of
    `SectionSegmentPool` / `SegmentedSectionPtr` keep the file
    free of kernel-side header dependencies.

`storage/ndb/src/common/transporter/CMakeLists.txt`
  - Adds `RDMA_Transporter_test_stubs.cpp` as a second source
    file to the existing `NDB_ADD_TEST(RDMA_Transporter-t ...)`
    block. The stub is compiled per-target only -- it does not
    enter the `ndbtransport` convenience library and so cannot
    leak into any non-test code path. A comment block above the
    `NDB_ADD_TEST` call documents why the companion source
    exists.

Verification
------------

Built with the exact configure command from the original bug
report:

    cmake -S . -B build-lab \
      -DCMAKE_BUILD_TYPE=Release \
      -DWITH_NDB_RDMA=ON \
      -DWITHOUT_SERVER=OFF \
      -DWITH_NDBCLUSTER_STORAGE_ENGINE=ON \
      -DCMAKE_INSTALL_PREFIX=/opt/rondb-24.10-rdma-port
    cmake --build build-lab --target RDMA_Transporter-t

Result: `RDMA_Transporter-t` builds and links cleanly.

Running the binary:

    1..1
    ok 1 - RDMA_Transporter

The standalone harness
`build_scripts/build_and_test_rdma_transporter.sh` is
unchanged; it still works because its hand-built link line
already includes its own runtime-generated stub, and the new
in-tree companion source is gated on the regular CMake
`NDB_ADD_TEST` target.

No runtime behaviour changes. The production `ndbtransport`
library is byte-identical; only the standalone test binary
gains the additional translation unit.

Author: elemberger-peak

storage/ndb/src/common/transporter/CMakeLists.txt

@@ -60,8 +60,22 @@ ENDIF()
 # validate_msg_header logic exercised by the tests does not touch any
 # verbs or socket APIs, but the rest of the translation unit still does,
 # so we link against ${NDB_RDMA_LIBRARIES} to resolve those references.
+#
+# RDMA_Transporter_test_stubs.cpp is a tiny companion source that
+# provides an abort-stub for the kernel-side `copy(SectionSegmentPool&,
+# SegmentedSectionPtr const&)` symbol that Packer.cpp's explicit
+# `Packer::pack<SegmentedSectionArg>` instantiation references. None
+# of the wire-format helpers exercised by the TAP cases actually call
+# into that code path, but without the stub the test executable fails
+# to link because none of the libraries we depend on define the
+# kernel-side symbol. The same workaround is applied at runtime by
+# build_scripts/build_and_test_rdma_transporter.sh; this baked-in
+# stub keeps the WITH_UNIT_TESTS=ON CI build working too. See
+# RDMA_Transporter_test_stubs.cpp for the rationale.
 IF(NDB_RDMA_TRANSPORTER_SUPPORTED)
-  NDB_ADD_TEST(RDMA_Transporter-t RDMA_Transporter.cpp
+  NDB_ADD_TEST(RDMA_Transporter-t
+               RDMA_Transporter.cpp
+               RDMA_Transporter_test_stubs.cpp
                LIBS ndbtransport ndbmgmapi ndbgeneral ndbportlib
                     ${NDB_RDMA_LIBRARIES})
 ENDIF()

storage/ndb/src/common/transporter/RDMA_Transporter_test_stubs.cpp

@@ -0,0 +1,79 @@
+/*
+   Copyright (c) 2026, Hopsworks and/or its affiliates.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License, version 2.0,
+   as published by the Free Software Foundation.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License, version 2.0, for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+*/
+
+/*
+ * Kernel-only symbol stubs for the RDMA_Transporter-t test binary.
+ *
+ * Why this file exists
+ * --------------------
+ * Packer.cpp (compiled into the ndbtransport convenience library that
+ * the test executable links against) emits an unconditional explicit
+ * template instantiation:
+ *
+ *     template void Packer::pack<Packer::SegmentedSectionArg>(
+ *         Uint32 *theData, SegmentedSectionArg section) const;
+ *
+ * That instantiation references the free function
+ *     bool copy(unsigned int *&, SectionSegmentPool &,
+ *               SegmentedSectionPtr const &);
+ * which is defined on the kernel side of the build (alongside the
+ * SegmentSubPool / SegmentedSectionPtr implementations) and is NOT
+ * part of any of the libraries the RDMA_Transporter-t target links
+ * against (ndbtransport, ndbmgmapi, ndbgeneral, ndbportlib,
+ * ${NDB_RDMA_LIBRARIES}, mytap). The result is an unresolved-symbol
+ * link error at the test binary even though the wire-format helpers
+ * exercised by the unit tests never invoke this code path.
+ *
+ * `build_scripts/build_and_test_rdma_transporter.sh` already works
+ * around this for its standalone build by generating an equivalent
+ * stub file on the fly. This source file bakes the same stub into
+ * the regular CMake build so the WITH_UNIT_TESTS=ON CI build can
+ * also link RDMA_Transporter-t without dragging in any kernel-side
+ * libraries.
+ *
+ * Safety
+ * ------
+ * If anything ever reaches the stubbed function at runtime the
+ * program aborts with a diagnostic message identifying which stub
+ * fired. The wire-format TAP suite must never reach it: the test
+ * exercises only `encode_msg_header` / `validate_msg_header` and
+ * pure helpers in the anonymous namespace; none of those paths call
+ * into `Packer::pack` at all. The abort is purely a defensive
+ * tripwire for a future test addition that would otherwise silently
+ * link against a sentinel.
+ */
+#include <cstdio>
+#include <cstdlib>
+
+/*
+ * Opaque forward declarations of the kernel-side types so the stub
+ * signature matches the symbol expected by Packer.cpp's template
+ * instantiation without dragging in the actual kernel headers.
+ */
+struct SectionSegmentPool;
+struct SegmentedSectionPtr;
+
+extern "C" void __rdma_test_abort_stub(const char *name) {
+  std::fprintf(stderr, "rdma test stub called: %s\n", name);
+  std::abort();
+}
+
+bool copy(unsigned int *& /*dst*/, SectionSegmentPool & /*pool*/,
+          SegmentedSectionPtr const & /*src*/) {
+  __rdma_test_abort_stub("copy(SegmentedSectionPtr)");
+  return false;
+}