net/mptcp/token_test.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <kunit/test.h>
0003
0004 #include "protocol.h"
0005
0006 static struct mptcp_subflow_request_sock *build_req_sock(struct kunit *test)
0007 {
0008     struct mptcp_subflow_request_sock *req;
0009
0010     req = kunit_kzalloc(test, sizeof(struct mptcp_subflow_request_sock),
0011                 GFP_USER);
0012     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, req);
0013     mptcp_token_init_request((struct request_sock *)req);
0014     sock_net_set((struct sock *)req, &init_net);
0015     return req;
0016 }
0017
0018 static void mptcp_token_test_req_basic(struct kunit *test)
0019 {
0020     struct mptcp_subflow_request_sock *req = build_req_sock(test);
0021     struct mptcp_sock *null_msk = NULL;
0022
0023     KUNIT_ASSERT_EQ(test, 0,
0024             mptcp_token_new_request((struct request_sock *)req));
0025     KUNIT_EXPECT_NE(test, 0, (int)req->token);
0026     KUNIT_EXPECT_PTR_EQ(test, null_msk, mptcp_token_get_sock(&init_net, req->token));
0027
0028     /* cleanup */
0029     mptcp_token_destroy_request((struct request_sock *)req);
0030 }
0031
0032 static struct inet_connection_sock *build_icsk(struct kunit *test)
0033 {
0034     struct inet_connection_sock *icsk;
0035
0036     icsk = kunit_kzalloc(test, sizeof(struct inet_connection_sock),
0037                  GFP_USER);
0038     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, icsk);
0039     return icsk;
0040 }
0041
0042 static struct mptcp_subflow_context *build_ctx(struct kunit *test)
0043 {
0044     struct mptcp_subflow_context *ctx;
0045
0046     ctx = kunit_kzalloc(test, sizeof(struct mptcp_subflow_context),
0047                 GFP_USER);
0048     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ctx);
0049     return ctx;
0050 }
0051
0052 static struct mptcp_sock *build_msk(struct kunit *test)
0053 {
0054     struct mptcp_sock *msk;
0055
0056     msk = kunit_kzalloc(test, sizeof(struct mptcp_sock), GFP_USER);
0057     KUNIT_EXPECT_NOT_ERR_OR_NULL(test, msk);
0058     refcount_set(&((struct sock *)msk)->sk_refcnt, 1);
0059     sock_net_set((struct sock *)msk, &init_net);
0060     return msk;
0061 }
0062
0063 static void mptcp_token_test_msk_basic(struct kunit *test)
0064 {
0065     struct inet_connection_sock *icsk = build_icsk(test);
0066     struct mptcp_subflow_context *ctx = build_ctx(test);
0067     struct mptcp_sock *msk = build_msk(test);
0068     struct mptcp_sock *null_msk = NULL;
0069     struct sock *sk;
0070
0071     rcu_assign_pointer(icsk->icsk_ulp_data, ctx);
0072     ctx->conn = (struct sock *)msk;
0073     sk = (struct sock *)msk;
0074
0075     KUNIT_ASSERT_EQ(test, 0,
0076             mptcp_token_new_connect((struct sock *)icsk));
0077     KUNIT_EXPECT_NE(test, 0, (int)ctx->token);
0078     KUNIT_EXPECT_EQ(test, ctx->token, msk->token);
0079     KUNIT_EXPECT_PTR_EQ(test, msk, mptcp_token_get_sock(&init_net, ctx->token));
0080     KUNIT_EXPECT_EQ(test, 2, (int)refcount_read(&sk->sk_refcnt));
0081
0082     mptcp_token_destroy(msk);
0083     KUNIT_EXPECT_PTR_EQ(test, null_msk, mptcp_token_get_sock(&init_net, ctx->token));
0084 }
0085
0086 static void mptcp_token_test_accept(struct kunit *test)
0087 {
0088     struct mptcp_subflow_request_sock *req = build_req_sock(test);
0089     struct mptcp_sock *msk = build_msk(test);
0090
0091     KUNIT_ASSERT_EQ(test, 0,
0092             mptcp_token_new_request((struct request_sock *)req));
0093     msk->token = req->token;
0094     mptcp_token_accept(req, msk);
0095     KUNIT_EXPECT_PTR_EQ(test, msk, mptcp_token_get_sock(&init_net, msk->token));
0096
0097     /* this is now a no-op */
0098     mptcp_token_destroy_request((struct request_sock *)req);
0099     KUNIT_EXPECT_PTR_EQ(test, msk, mptcp_token_get_sock(&init_net, msk->token));
0100
0101     /* cleanup */
0102     mptcp_token_destroy(msk);
0103 }
0104
0105 static void mptcp_token_test_destroyed(struct kunit *test)
0106 {
0107     struct mptcp_subflow_request_sock *req = build_req_sock(test);
0108     struct mptcp_sock *msk = build_msk(test);
0109     struct mptcp_sock *null_msk = NULL;
0110     struct sock *sk;
0111
0112     sk = (struct sock *)msk;
0113
0114     KUNIT_ASSERT_EQ(test, 0,
0115             mptcp_token_new_request((struct request_sock *)req));
0116     msk->token = req->token;
0117     mptcp_token_accept(req, msk);
0118
0119     /* simulate race on removal */
0120     refcount_set(&sk->sk_refcnt, 0);
0121     KUNIT_EXPECT_PTR_EQ(test, null_msk, mptcp_token_get_sock(&init_net, msk->token));
0122
0123     /* cleanup */
0124     mptcp_token_destroy(msk);
0125 }
0126
0127 static struct kunit_case mptcp_token_test_cases[] = {
0128     KUNIT_CASE(mptcp_token_test_req_basic),
0129     KUNIT_CASE(mptcp_token_test_msk_basic),
0130     KUNIT_CASE(mptcp_token_test_accept),
0131     KUNIT_CASE(mptcp_token_test_destroyed),
0132     {}
0133 };
0134
0135 static struct kunit_suite mptcp_token_suite = {
0136     .name = "mptcp-token",
0137     .test_cases = mptcp_token_test_cases,
0138 };
0139
0140 kunit_test_suite(mptcp_token_suite);
0141
0142 MODULE_LICENSE("GPL");