--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Exercise the RDS getsockopt() paths that were converted to the
+ * getsockopt_iter() / sockopt_t callback.
+ *
+ * Three distinct paths are covered:
+ *
+ * - RDS_RECVERR and SO_RDS_TRANSPORT, which now return their int value
+ * through copy_to_iter() and report the written length in opt->optlen.
+ *
+ * - RDS_INFO_*, which pins the userspace buffer with
+ * iov_iter_extract_pages() (including a non-zero starting page offset)
+ * and lets the info producers memcpy the snapshot in under a spinlock.
+ *
+ * The kvec (in-kernel buffer) -> -EOPNOTSUPP path of rds_info_getsockopt()
+ * is not reachable from a userspace getsockopt() and so is not tested here.
+ */
+#include <errno.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <linux/rds.h>
+
+#include "../../kselftest_harness.h"
+
+#ifndef AF_RDS
+#define AF_RDS 21
+#endif
+
+FIXTURE(rds) {
+ int fd;
+};
+
+FIXTURE_SETUP(rds)
+{
+ self->fd = socket(AF_RDS, SOCK_SEQPACKET, 0);
+ if (self->fd < 0)
+ SKIP(return, "AF_RDS unavailable (errno %d) - load the rds module",
+ errno);
+}
+
+FIXTURE_TEARDOWN(rds)
+{
+ if (self->fd >= 0)
+ close(self->fd);
+}
+
+/* RDS_RECVERR defaults to 0 and is reported back as a 4-byte int. */
+TEST_F(rds, recverr_default)
+{
+ socklen_t len = sizeof(int);
+ int val = 0xdeadbeef;
+
+ ASSERT_EQ(0, getsockopt(self->fd, SOL_RDS, RDS_RECVERR, &val, &len));
+ EXPECT_EQ(sizeof(int), len);
+ EXPECT_EQ(0, val);
+}
+
+/* A value set via setsockopt() must be readable back unchanged. */
+TEST_F(rds, recverr_set_get)
+{
+ socklen_t len = sizeof(int);
+ int val = 1;
+
+ ASSERT_EQ(0, setsockopt(self->fd, SOL_RDS, RDS_RECVERR, &val, len));
+
+ val = 0;
+ ASSERT_EQ(0, getsockopt(self->fd, SOL_RDS, RDS_RECVERR, &val, &len));
+ EXPECT_EQ(sizeof(int), len);
+ EXPECT_EQ(1, val);
+}
+
+/* A buffer smaller than an int is rejected with EINVAL, not silently. */
+TEST_F(rds, recverr_short_buffer)
+{
+ socklen_t len = sizeof(int) - 1;
+ char buf[sizeof(int)];
+
+ EXPECT_EQ(-1, getsockopt(self->fd, SOL_RDS, RDS_RECVERR, buf, &len));
+ EXPECT_EQ(EINVAL, errno);
+}
+
+/* An unbound socket reports RDS_TRANS_NONE for SO_RDS_TRANSPORT. */
+TEST_F(rds, transport_unbound)
+{
+ socklen_t len = sizeof(int);
+ int val = 0;
+
+ ASSERT_EQ(0, getsockopt(self->fd, SOL_RDS, SO_RDS_TRANSPORT, &val,
+ &len));
+ EXPECT_EQ(sizeof(int), len);
+ EXPECT_EQ(RDS_TRANS_NONE, (unsigned int)val);
+}
+
+TEST_F(rds, transport_short_buffer)
+{
+ socklen_t len = sizeof(int) - 1;
+ char buf[sizeof(int)];
+
+ EXPECT_EQ(-1, getsockopt(self->fd, SOL_RDS, SO_RDS_TRANSPORT, buf,
+ &len));
+ EXPECT_EQ(EINVAL, errno);
+}
+
+/*
+ * RDS_INFO_COUNTERS with a zero-length buffer is the "probe" call: it must
+ * fail with ENOSPC and report the required snapshot size in optlen.
+ */
+TEST_F(rds, info_counters_probe)
+{
+ socklen_t len = 0;
+
+ EXPECT_EQ(-1, getsockopt(self->fd, SOL_RDS, RDS_INFO_COUNTERS, NULL,
+ &len));
+ EXPECT_EQ(ENOSPC, errno);
+ EXPECT_GT(len, 0);
+ /* The snapshot is an array of fixed-size counter records. */
+ EXPECT_EQ(0, len % (socklen_t)sizeof(struct rds_info_counter));
+}
+
+/*
+ * A real snapshot into an unaligned userspace buffer exercises the
+ * iov_iter_extract_pages() path, including the non-zero offset0 handling
+ * that the patch reworked. Place the buffer at a non-page-aligned address
+ * spanning into the next page to make sure multi-page pinning works too.
+ */
+TEST_F(rds, info_counters_snapshot)
+{
+ struct rds_info_counter *ctr;
+ socklen_t need = 0, len;
+ long pagesz = sysconf(_SC_PAGESIZE);
+ size_t offset, map_len;
+ unsigned int i, n;
+ char *region, *buf;
+ int ret;
+
+ /* Probe for the required size. */
+ getsockopt(self->fd, SOL_RDS, RDS_INFO_COUNTERS, NULL, &need);
+ ASSERT_GT(need, 0);
+
+ /*
+ * Place the buffer at a non-page-aligned offset that runs past the
+ * first page boundary, and size the mapping from the probed length so
+ * the test keeps working if the counter set grows.
+ */
+ offset = pagesz - 64;
+ map_len = ((offset + need + pagesz - 1) / pagesz) * pagesz;
+
+ region = mmap(NULL, map_len, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ ASSERT_NE(MAP_FAILED, region);
+
+ buf = region + offset;
+
+ /*
+ * On success the RDS_INFO path returns the positive per-element size
+ * (lens.each) rather than 0, and writes the full snapshot length back
+ * into optlen.
+ */
+ len = need;
+ ret = getsockopt(self->fd, SOL_RDS, RDS_INFO_COUNTERS, buf, &len);
+ ASSERT_GE(ret, 0) {
+ TH_LOG("getsockopt snapshot failed: errno %d", errno);
+ }
+ EXPECT_EQ(sizeof(struct rds_info_counter), ret);
+ EXPECT_EQ(need, len);
+
+ /* The counter names must be NUL-terminated, non-empty strings. */
+ ctr = (struct rds_info_counter *)buf;
+ n = len / sizeof(*ctr);
+ ASSERT_GT(n, 0);
+ for (i = 0; i < n; i++) {
+ size_t namelen = strnlen((char *)ctr[i].name,
+ sizeof(ctr[i].name));
+
+ EXPECT_GT(namelen, 0);
+ EXPECT_LT(namelen, sizeof(ctr[i].name));
+ }
+
+ munmap(region, map_len);
+}
+
+/*
+ * A non-zero but too-small buffer must report ENOSPC and the full required
+ * length, without corrupting memory past the buffer.
+ */
+TEST_F(rds, info_counters_short_buffer)
+{
+ socklen_t need = 0, len;
+ char small[sizeof(struct rds_info_counter)];
+
+ getsockopt(self->fd, SOL_RDS, RDS_INFO_COUNTERS, NULL, &need);
+ ASSERT_GT(need, 0);
+
+ /* Ask with a buffer guaranteed smaller than the full snapshot. */
+ if (need <= (socklen_t)sizeof(small))
+ SKIP(return, "snapshot fits in one record; nothing to test");
+
+ len = 1; /* < sizeof(struct rds_info_counter) */
+ EXPECT_EQ(-1, getsockopt(self->fd, SOL_RDS, RDS_INFO_COUNTERS, small,
+ &len));
+ EXPECT_EQ(ENOSPC, errno);
+ EXPECT_EQ(need, len);
+}
+
+TEST_HARNESS_MAIN
projects / thirdparty / linux.git / commitdiff
