list-test: non-standard-type example

Author: nwf

tests/list-test.cc

@@ -284,3 +284,152 @@ int test_list()
 	debug_log("Done testing the list.");
 	return 0;
 }
+
+namespace
+{
+	/**
+	 * \defgroup TypedLinkedObject Non-Standard-Layout Intrusive Lists
+	 *
+	 * We can also use C++'s inheritance system for non-standard-layout classes.
+	 * This requires a bit more work up front, but doesn't rely on `offsetof`.
+	 *
+	 * See `test_non_standard_layout_lists()`
+	 *
+	 * @{
+	 */
+
+	/**
+	 * Linkage cell 1 for TypedLinkedObject
+	 */
+	struct BaseCell1 : public ds::linked_list::cell::PointerF<BaseCell1>
+	{
+	};
+	static_assert(ds::linked_list::cell::HasCellOperationsReset<BaseCell1>);
+
+	/**
+	 * Linkage cell 2 for TypedLinkedObject
+	 */
+	struct BaseCell2 : public ds::linked_list::cell::PointerF<BaseCell2>
+	{
+	};
+	static_assert(ds::linked_list::cell::HasCellOperationsReset<BaseCell2>);
+
+	struct DerivedObject : public BaseCell1, public BaseCell2
+	{
+		int data;
+
+		__always_inline struct BaseCell1 *toCell1()
+		{
+			return static_cast<BaseCell1 *>(this);
+		}
+
+		__always_inline static struct DerivedObject *fromCell1(BaseCell1 *c)
+		{
+			return static_cast<DerivedObject *>(c);
+		}
+
+		/**
+		 * We can even define TypedSentinel "containers" within the derived
+		 * object itself, which is handy if we want this type to maintain things
+		 * like "collections of all instances" or "all instances such that ...".
+		 */
+		static inline ds::linked_list::TypedSentinel<DerivedObject,
+		                                             BaseCell1,
+		                                             &DerivedObject::toCell1,
+		                                             DerivedObject::fromCell1>
+		  sentinel1 = {};
+
+		__always_inline struct BaseCell2 *toCell2()
+		{
+			return static_cast<BaseCell2 *>(this);
+		}
+
+		__always_inline static struct DerivedObject *fromCell2(BaseCell2 *c)
+		{
+			return static_cast<DerivedObject *>(c);
+		}
+
+		DerivedObject()
+		{
+			sentinel1.append(this);
+		}
+
+		~DerivedObject()
+		{
+			ds::linked_list::unsafe_remove(toCell1());
+		}
+	};
+
+	/*
+	 * This is emphatically not a standard layout class, since we have two base
+	 * types with members as well as a member in the derived class itself.
+	 */
+	static_assert(!std::is_standard_layout_v<DerivedObject>);
+
+	/**
+	 * @}
+	 */
+
+} // namespace
+
+ds::linked_list::TypedSentinel<DerivedObject,
+                               BaseCell2,
+                               &DerivedObject::toCell2,
+                               DerivedObject::fromCell2>
+  typedSentinel2 = {};
+
+int test_non_standard_layout_list()
+{
+	debug_log("Testing the non-standard layout list implementation.");
+
+	// Number of elements we will add to the list in the test.
+	static constexpr int NumberOfListElements = 10;
+
+	auto heapAtStart = heap_quota_remaining(MALLOC_CAPABILITY);
+
+	for (int i = 0; i < 10; i++)
+	{
+		auto *d = new DerivedObject();
+		d->data = i;
+
+		// Thread half the objects onto one list; the constructor threads
+		// everything onto the other
+		if (i & 1)
+		{
+			// new runs constructors, so linkages are initialized and we need
+			// not use the emplace variant.
+			typedSentinel2.prepend(d);
+		}
+	}
+
+	// Free all the objects on the typedSentinel2 ring.
+	typedSentinel2.search_safe([](DerivedObject *d) {
+		ds::linked_list::unsafe_remove(d->toCell2());
+
+		// The destructor will manage unlinking us from DerivedObject::sentinel1
+		delete d;
+
+		return false;
+	});
+
+	DerivedObject::sentinel1.search_safe([](DerivedObject *d) {
+		// Nodes still on the list were never part of the typedSentinel2 ring,
+		// so they should have singleton BaseCell2 linkages.
+		TEST(ds::linked_list::is_singleton(d->toCell2()),
+		     "Object has bad Cell2 linkages");
+
+		delete d;
+		return false;
+	});
+
+	// Check that we didn't leak anything in the process
+	auto heapAtEnd = heap_quota_remaining(MALLOC_CAPABILITY);
+	TEST(heapAtStart == heapAtEnd,
+	     "The list leaked {} bytes ({} vs. {})",
+	     heapAtEnd - heapAtStart,
+	     heapAtStart,
+	     heapAtEnd);
+
+	debug_log("Done testing the non-standard layout list.");
+	return 0;
+}

tests/test-runner.cc

@@ -198,6 +198,7 @@ int __cheri_compartment("test_runner") run_tests()
 		run_timed("Futex", test_futex);
 		run_timed("Locks", test_locks);
 		run_timed("List", test_list);
+		run_timed("List (non-standard-layout)", test_non_standard_layout_list);
 		run_timed("Event groups", test_eventgroup);
 		run_timed("Multiwaiter", test_multiwaiter);
 		run_timed("Allocator", test_allocator);

tests/tests.hh

@@ -13,6 +13,7 @@ __cheri_compartment("futex_test") int test_futex();
 __cheri_compartment("queue_test") int test_queue();
 __cheri_compartment("locks_test") int test_locks();
 __cheri_compartment("list_test") int test_list();
+__cheri_compartment("list_test") int test_non_standard_layout_list();
 __cheri_compartment("crash_recovery_test") int test_crash_recovery();
 __cheri_compartment("multiwaiter_test") int test_multiwaiter();
 __cheri_compartment("stack_test") int test_stack();