Quelle  net_timestamping.c   Sprache: C

#include <linux/net_tstamp.h>
#include <sys/time.h>
#include <linux/errqueue.h>
#include "test_progs.h"
#include "network_helpers.h"
#include "net_timestamping.skel.h"

#define CG_NAME "/net-timestamping-test"
#define NSEC_PER_SEC    1000000000LL

static const char addr4_str[] = "127.0.0.1";
static const char addr6_str[] = "::1";
static struct net_timestamping *skel;
static const int cfg_payload_len = 30;
static struct timespec usr_ts;
static u64 delay_tolerance_nsec = 10000000000; /* 10 seconds */
int SK_TS_SCHED;
int SK_TS_TXSW;
int SK_TS_ACK;

static int64_t timespec_to_ns64(struct timespec *ts)
{
 return ts->tv_sec * NSEC_PER_SEC + ts->tv_nsec;
}

static void validate_key(int tskey, int tstype)
{
 static int expected_tskey = -1;

 if (tstype == SCM_TSTAMP_SCHED)
  expected_tskey = cfg_payload_len - 1;

 ASSERT_EQ(expected_tskey, tskey, "tskey mismatch");

 expected_tskey = tskey;
}

static void validate_timestamp(struct timespec *cur, struct timespec *prev)
{
 int64_t cur_ns, prev_ns;

 cur_ns = timespec_to_ns64(cur);
 prev_ns = timespec_to_ns64(prev);

 ASSERT_LT(cur_ns - prev_ns, delay_tolerance_nsec, "latency");
}

static void test_socket_timestamp(struct scm_timestamping *tss, int tstype,
      int tskey)
{
 static struct timespec prev_ts;

 validate_key(tskey, tstype);

 switch (tstype) {
 case SCM_TSTAMP_SCHED:
  validate_timestamp(&tss->ts[0], &usr_ts);
  SK_TS_SCHED += 1;
  break;
 case SCM_TSTAMP_SND:
  validate_timestamp(&tss->ts[0], &prev_ts);
  SK_TS_TXSW += 1;
  break;
 case SCM_TSTAMP_ACK:
  validate_timestamp(&tss->ts[0], &prev_ts);
  SK_TS_ACK += 1;
  break;
 }

 prev_ts = tss->ts[0];
}

static void test_recv_errmsg_cmsg(struct msghdr *msg)
{
 struct sock_extended_err *serr = NULL;
 struct scm_timestamping *tss = NULL;
 struct cmsghdr *cm;

 for (cm = CMSG_FIRSTHDR(msg);
      cm && cm->cmsg_len;
      cm = CMSG_NXTHDR(msg, cm)) {
  if (cm->cmsg_level == SOL_SOCKET &&
      cm->cmsg_type == SCM_TIMESTAMPING) {
   tss = (void *)CMSG_DATA(cm);
  } else if ((cm->cmsg_level == SOL_IP &&
       cm->cmsg_type == IP_RECVERR) ||
      (cm->cmsg_level == SOL_IPV6 &&
       cm->cmsg_type == IPV6_RECVERR) ||
      (cm->cmsg_level == SOL_PACKET &&
       cm->cmsg_type == PACKET_TX_TIMESTAMP)) {
   serr = (void *)CMSG_DATA(cm);
   ASSERT_EQ(serr->ee_origin, SO_EE_ORIGIN_TIMESTAMPING,
      "cmsg type");
  }

  if (serr && tss)
   test_socket_timestamp(tss, serr->ee_info,
           serr->ee_data);
 }
}

static bool socket_recv_errmsg(int fd)
{
 static char ctrl[1024 /* overprovision*/];
 char data[cfg_payload_len];
 static struct msghdr msg;
 struct iovec entry;
 int n = 0;

 memset(&msg, 0, sizeof(msg));
 memset(&entry, 0, sizeof(entry));
 memset(ctrl, 0, sizeof(ctrl));

 entry.iov_base = data;
 entry.iov_len = cfg_payload_len;
 msg.msg_iov = &entry;
 msg.msg_iovlen = 1;
 msg.msg_name = NULL;
 msg.msg_namelen = 0;
 msg.msg_control = ctrl;
 msg.msg_controllen = sizeof(ctrl);

 n = recvmsg(fd, &msg, MSG_ERRQUEUE);
 if (n == -1)
  ASSERT_EQ(errno, EAGAIN, "recvmsg MSG_ERRQUEUE");

 if (n >= 0)
  test_recv_errmsg_cmsg(&msg);

 return n == -1;
}

static void test_socket_timestamping(int fd)
{
 while (!socket_recv_errmsg(fd));

 ASSERT_EQ(SK_TS_SCHED, 1, "SCM_TSTAMP_SCHED");
 ASSERT_EQ(SK_TS_TXSW, 1, "SCM_TSTAMP_SND");
 ASSERT_EQ(SK_TS_ACK, 1, "SCM_TSTAMP_ACK");

 SK_TS_SCHED = 0;
 SK_TS_TXSW = 0;
 SK_TS_ACK = 0;
}

static void test_tcp(int family, bool enable_socket_timestamping)
{
 struct net_timestamping__bss *bss;
 char buf[cfg_payload_len];
 int sfd = -1, cfd = -1;
 unsigned int sock_opt;
 struct netns_obj *ns;
 int cg_fd;
 int ret;

 cg_fd = test__join_cgroup(CG_NAME);
 if (!ASSERT_OK_FD(cg_fd, "join cgroup"))
  return;

 ns = netns_new("net_timestamping_ns", true);
 if (!ASSERT_OK_PTR(ns, "create ns"))
  goto out;

 skel = net_timestamping__open_and_load();
 if (!ASSERT_OK_PTR(skel, "open and load skel"))
  goto out;

 if (!ASSERT_OK(net_timestamping__attach(skel), "attach skel"))
  goto out;

 skel->links.skops_sockopt =
  bpf_program__attach_cgroup(skel->progs.skops_sockopt, cg_fd);
 if (!ASSERT_OK_PTR(skel->links.skops_sockopt, "attach cgroup"))
  goto out;

 bss = skel->bss;
 memset(bss, 0, sizeof(*bss));

 skel->bss->monitored_pid = getpid();

 sfd = start_server(family, SOCK_STREAM,
      family == AF_INET6 ? addr6_str : addr4_str, 0, 0);
 if (!ASSERT_OK_FD(sfd, "start_server"))
  goto out;

 cfd = connect_to_fd(sfd, 0);
 if (!ASSERT_OK_FD(cfd, "connect_to_fd_server"))
  goto out;

 if (enable_socket_timestamping) {
  sock_opt = SOF_TIMESTAMPING_SOFTWARE |
      SOF_TIMESTAMPING_OPT_ID |
      SOF_TIMESTAMPING_TX_SCHED |
      SOF_TIMESTAMPING_TX_SOFTWARE |
      SOF_TIMESTAMPING_TX_ACK;
  ret = setsockopt(cfd, SOL_SOCKET, SO_TIMESTAMPING,
     (char *) &sock_opt, sizeof(sock_opt));
  if (!ASSERT_OK(ret, "setsockopt SO_TIMESTAMPING"))
   goto out;

  ret = clock_gettime(CLOCK_REALTIME, &usr_ts);
  if (!ASSERT_OK(ret, "get user time"))
   goto out;
 }

 ret = write(cfd, buf, sizeof(buf));
 if (!ASSERT_EQ(ret, sizeof(buf), "send to server"))
  goto out;

 if (enable_socket_timestamping)
  test_socket_timestamping(cfd);

 ASSERT_EQ(bss->nr_active, 1, "nr_active");
 ASSERT_EQ(bss->nr_snd, 2, "nr_snd");
 ASSERT_EQ(bss->nr_sched, 1, "nr_sched");
 ASSERT_EQ(bss->nr_txsw, 1, "nr_txsw");
 ASSERT_EQ(bss->nr_ack, 1, "nr_ack");

out:
 if (sfd >= 0)
  close(sfd);
 if (cfd >= 0)
  close(cfd);
 net_timestamping__destroy(skel);
 netns_free(ns);
 close(cg_fd);
}

void test_net_timestamping(void)
{
 if (test__start_subtest("INET4: bpf timestamping"))
  test_tcp(AF_INET, false);
 if (test__start_subtest("INET4: bpf and socket timestamping"))
  test_tcp(AF_INET, true);
 if (test__start_subtest("INET6: bpf timestamping"))
  test_tcp(AF_INET6, false);
 if (test__start_subtest("INET6: bpf and socket timestamping"))
  test_tcp(AF_INET6, true);
}