test_astlpc.c (4e8264b705d3575bea8312d6467d5fd9fb440caf) test_astlpc.c (3a540664c5fbf8cabeca0c1a1af27b1b979eb253)
1/* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
2
3#ifdef HAVE_CONFIG_H
4#include "config.h"
5#endif
6
1/* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
2
3#ifdef HAVE_CONFIG_H
4#include "config.h"
5#endif
6
7#define ASTLPC_VER_CUR 2
7#include "astlpc.c"
8
9#ifdef pr_fmt
10#undef pr_fmt
11#define pr_fmt(x) "test: " x
12#endif
13
14#include "libmctp-astlpc.h"

--- 161 unchanged lines hidden (view full) ---

176 assert(ep->mctp);
177
178 /* Inject KCS registers */
179 ep->mmio.kcs = kcs;
180
181 /* Initialise the binding */
182 ep->astlpc = mctp_astlpc_init(mode, MCTP_BTU, lpc_mem,
183 &astlpc_direct_mmio_ops, &ep->mmio);
8#include "astlpc.c"
9
10#ifdef pr_fmt
11#undef pr_fmt
12#define pr_fmt(x) "test: " x
13#endif
14
15#include "libmctp-astlpc.h"

--- 161 unchanged lines hidden (view full) ---

177 assert(ep->mctp);
178
179 /* Inject KCS registers */
180 ep->mmio.kcs = kcs;
181
182 /* Initialise the binding */
183 ep->astlpc = mctp_astlpc_init(mode, MCTP_BTU, lpc_mem,
184 &astlpc_direct_mmio_ops, &ep->mmio);
185 assert(ep->astlpc);
184
185 return mctp_register_bus(ep->mctp, &ep->astlpc->binding, eid);
186}
187
188static void endpoint_destroy(struct astlpc_endpoint *ep)
189{
190 mctp_astlpc_destroy(ep->astlpc);
191 mctp_destroy(ep->mctp);

--- 515 unchanged lines hidden (view full) ---

707
708 /* Make sure it doesn't fail, bad command should be discarded */
709 assert(rc == 0);
710
711 endpoint_destroy(&bmc);
712 free(lpc_mem);
713}
714
186
187 return mctp_register_bus(ep->mctp, &ep->astlpc->binding, eid);
188}
189
190static void endpoint_destroy(struct astlpc_endpoint *ep)
191{
192 mctp_astlpc_destroy(ep->astlpc);
193 mctp_destroy(ep->mctp);

--- 515 unchanged lines hidden (view full) ---

709
710 /* Make sure it doesn't fail, bad command should be discarded */
711 assert(rc == 0);
712
713 endpoint_destroy(&bmc);
714 free(lpc_mem);
715}
716
717#define BUFFER_MIN ASTLPC_PACKET_SIZE(MCTP_PACKET_SIZE(MCTP_BTU))
718
719static void astlpc_test_buffers_rx_offset_overflow(void)
720{
721 struct mctp_astlpc_layout l = {
722 .rx = { UINT32_MAX, BUFFER_MIN },
723 .tx = { control_size, BUFFER_MIN },
724 };
725
726 assert(!mctp_astlpc_layout_validate(&l));
727}
728
729static void astlpc_test_buffers_tx_offset_overflow(void)
730{
731 struct mctp_astlpc_layout l = {
732 .rx = { control_size, BUFFER_MIN },
733 .tx = { UINT32_MAX, BUFFER_MIN },
734 };
735
736 assert(!mctp_astlpc_layout_validate(&l));
737}
738
739static void astlpc_test_buffers_rx_size_overflow(void)
740{
741 struct mctp_astlpc_layout l = {
742 .rx = { control_size + BUFFER_MIN, UINT32_MAX },
743 .tx = { control_size, BUFFER_MIN },
744 };
745
746 assert(!mctp_astlpc_layout_validate(&l));
747}
748
749static void astlpc_test_buffers_tx_size_overflow(void)
750{
751 struct mctp_astlpc_layout l = {
752 .rx = { control_size, BUFFER_MIN },
753 .tx = { control_size + BUFFER_MIN, UINT32_MAX },
754 };
755
756 assert(!mctp_astlpc_layout_validate(&l));
757}
758
759static void astlpc_test_buffers_rx_window_violation(void)
760{
761 struct mctp_astlpc_layout l = {
762 .rx = { LPC_WIN_SIZE - BUFFER_MIN + 1, BUFFER_MIN },
763 .tx = { control_size, BUFFER_MIN },
764 };
765
766 assert(!mctp_astlpc_layout_validate(&l));
767}
768
769static void astlpc_test_buffers_tx_window_violation(void)
770{
771 struct mctp_astlpc_layout l = {
772 .rx = { control_size, BUFFER_MIN },
773 .tx = { LPC_WIN_SIZE - BUFFER_MIN + 1, BUFFER_MIN },
774 };
775
776 assert(!mctp_astlpc_layout_validate(&l));
777}
778
779static void astlpc_test_buffers_rx_size_fails_btu(void)
780{
781 struct mctp_astlpc_layout l = {
782 .rx = { control_size, BUFFER_MIN - 1 },
783 .tx = { control_size + BUFFER_MIN, BUFFER_MIN },
784 };
785
786 assert(!mctp_astlpc_layout_validate(&l));
787}
788
789static void astlpc_test_buffers_tx_size_fails_btu(void)
790{
791 struct mctp_astlpc_layout l = {
792 .rx = { control_size, BUFFER_MIN },
793 .tx = { control_size + BUFFER_MIN, BUFFER_MIN - 1 },
794 };
795
796 assert(!mctp_astlpc_layout_validate(&l));
797}
798
799static void astlpc_test_buffers_overlap_rx_low(void)
800{
801 struct mctp_astlpc_layout l = {
802 .rx = { control_size, 2 * BUFFER_MIN },
803 .tx = { control_size + BUFFER_MIN, 2 * BUFFER_MIN },
804 };
805
806 assert(!mctp_astlpc_layout_validate(&l));
807}
808
809static void astlpc_test_buffers_overlap_tx_low(void)
810{
811 struct mctp_astlpc_layout l = {
812 .rx = { control_size + BUFFER_MIN, 2 * BUFFER_MIN },
813 .tx = { control_size, 2 * BUFFER_MIN },
814 };
815
816 assert(!mctp_astlpc_layout_validate(&l));
817}
818
819static void astlpc_test_buffers_overlap_exact(void)
820{
821 struct mctp_astlpc_layout l = {
822 .rx = { control_size, 2 * BUFFER_MIN },
823 .tx = { control_size, 2 * BUFFER_MIN },
824 };
825
826 assert(!mctp_astlpc_layout_validate(&l));
827}
828
829static void astlpc_test_buffers_overlap_control(void)
830{
831 struct mctp_astlpc_layout l = {
832 .rx = { 0, BUFFER_MIN },
833 .tx = { control_size + BUFFER_MIN, BUFFER_MIN },
834 };
835
836 assert(!mctp_astlpc_layout_validate(&l));
837}
838
839static void astlpc_test_buffers_bad_host_proposal(void)
840{
841 struct astlpc_endpoint bmc, host;
842 struct mctp_lpcmap_hdr *hdr;
843 uint8_t kcs[2] = { 0 };
844 void *lpc_mem;
845
846 /* Test harness initialisation */
847 lpc_mem = calloc(1, 1 * 1024 * 1024);
848 assert(lpc_mem);
849
850 /* BMC initialisation */
851 endpoint_init(&bmc, 8, MCTP_BINDING_ASTLPC_MODE_BMC, &kcs, lpc_mem);
852
853 /* Host initialisation */
854 endpoint_init(&host, 9, MCTP_BINDING_ASTLPC_MODE_HOST, &kcs, lpc_mem);
855
856 /*
857 * Now that the host has initialised the control area, break
858 * something before polling the BMC
859 */
860 hdr = lpc_mem;
861 hdr->layout.rx_size = 0;
862
863 mctp_astlpc_poll(bmc.astlpc);
864
865 /* Make sure the BMC has not set the channel to active */
866 assert(!(kcs[MCTP_ASTLPC_KCS_REG_STATUS] & KCS_STATUS_CHANNEL_ACTIVE));
867
868 endpoint_destroy(&host);
869 endpoint_destroy(&bmc);
870 free(lpc_mem);
871}
872
873static void astlpc_test_buffers_bad_bmc_proposal(void)
874{
875 struct astlpc_endpoint bmc, host;
876 struct mctp_lpcmap_hdr *hdr;
877 uint8_t kcs[2] = { 0 };
878 void *lpc_mem;
879 int rc;
880
881 /* Test harness initialisation */
882 lpc_mem = calloc(1, 1 * 1024 * 1024);
883 assert(lpc_mem);
884
885 /* BMC initialisation */
886 endpoint_init(&bmc, 8, MCTP_BINDING_ASTLPC_MODE_BMC, &kcs, lpc_mem);
887
888 /*
889 * Now that the BMC has initialised the control area, break something
890 * before initialising the host
891 */
892 hdr = lpc_mem;
893 hdr->layout.rx_size = 0;
894
895 /* Host initialisation: Fails due to bad layout */
896 rc = endpoint_init(&host, 9, MCTP_BINDING_ASTLPC_MODE_HOST, &kcs,
897 lpc_mem);
898 assert(rc < 0);
899
900 endpoint_destroy(&host);
901 endpoint_destroy(&bmc);
902 free(lpc_mem);
903}
904
905static void astlpc_test_buffers_bad_bmc_negotiation(void)
906{
907 struct astlpc_endpoint bmc, host;
908 struct mctp_lpcmap_hdr *hdr;
909 uint8_t kcs[2] = { 0 };
910 void *lpc_mem;
911 int rc;
912
913 /* Test harness initialisation */
914 lpc_mem = calloc(1, 1 * 1024 * 1024);
915 assert(lpc_mem);
916
917 /* BMC initialisation */
918 endpoint_init(&bmc, 8, MCTP_BINDING_ASTLPC_MODE_BMC, &kcs, lpc_mem);
919
920 /* Host initialisation */
921 endpoint_init(&host, 9, MCTP_BINDING_ASTLPC_MODE_HOST, &kcs, lpc_mem);
922
923 mctp_astlpc_poll(bmc.astlpc);
924
925 /*
926 * Now that the BMC has initialised the control area, break something
927 * before polling the host
928 */
929 hdr = lpc_mem;
930 hdr->layout.rx_size = 0;
931
932 rc = mctp_astlpc_poll(host.astlpc);
933 assert(rc < 0);
934
935 endpoint_destroy(&host);
936 endpoint_destroy(&bmc);
937 free(lpc_mem);
938}
939
715/* clang-format off */
716#define TEST_CASE(test) { #test, test }
717static const struct {
718 const char *name;
719 void (*test)(void);
720} astlpc_tests[] = {
721 TEST_CASE(astlpc_test_simple_init),
722 TEST_CASE(astlpc_test_bad_version),

--- 5 unchanged lines hidden (view full) ---

728 TEST_CASE(astlpc_test_host_before_bmc),
729 TEST_CASE(astlpc_test_simple_message_bmc_to_host),
730 TEST_CASE(astlpc_test_simple_message_host_to_bmc),
731 TEST_CASE(astlpc_test_packetised_message_bmc_to_host),
732 TEST_CASE(astlpc_test_simple_indirect_message_bmc_to_host),
733 TEST_CASE(astlpc_test_host_tx_bmc_gone),
734 TEST_CASE(astlpc_test_poll_not_ready),
735 TEST_CASE(astlpc_test_undefined_command),
940/* clang-format off */
941#define TEST_CASE(test) { #test, test }
942static const struct {
943 const char *name;
944 void (*test)(void);
945} astlpc_tests[] = {
946 TEST_CASE(astlpc_test_simple_init),
947 TEST_CASE(astlpc_test_bad_version),

--- 5 unchanged lines hidden (view full) ---

953 TEST_CASE(astlpc_test_host_before_bmc),
954 TEST_CASE(astlpc_test_simple_message_bmc_to_host),
955 TEST_CASE(astlpc_test_simple_message_host_to_bmc),
956 TEST_CASE(astlpc_test_packetised_message_bmc_to_host),
957 TEST_CASE(astlpc_test_simple_indirect_message_bmc_to_host),
958 TEST_CASE(astlpc_test_host_tx_bmc_gone),
959 TEST_CASE(astlpc_test_poll_not_ready),
960 TEST_CASE(astlpc_test_undefined_command),
961 TEST_CASE(astlpc_test_buffers_rx_offset_overflow),
962 TEST_CASE(astlpc_test_buffers_tx_offset_overflow),
963 TEST_CASE(astlpc_test_buffers_rx_size_overflow),
964 TEST_CASE(astlpc_test_buffers_tx_size_overflow),
965 TEST_CASE(astlpc_test_buffers_rx_window_violation),
966 TEST_CASE(astlpc_test_buffers_tx_window_violation),
967 TEST_CASE(astlpc_test_buffers_rx_size_fails_btu),
968 TEST_CASE(astlpc_test_buffers_tx_size_fails_btu),
969 TEST_CASE(astlpc_test_buffers_overlap_rx_low),
970 TEST_CASE(astlpc_test_buffers_overlap_tx_low),
971 TEST_CASE(astlpc_test_buffers_bad_host_proposal),
972 TEST_CASE(astlpc_test_buffers_bad_bmc_proposal),
973 TEST_CASE(astlpc_test_buffers_bad_bmc_negotiation),
974 TEST_CASE(astlpc_test_buffers_overlap_exact),
975 TEST_CASE(astlpc_test_buffers_overlap_control),
736};
737/* clang-format on */
738
739#ifndef BUILD_ASSERT
740#define BUILD_ASSERT(x) \
741 do { \
742 (void)sizeof(char[0 - (!(x))]); \
743 } while (0)

--- 17 unchanged lines hidden --- 		976};
977/* clang-format on */
978
979#ifndef BUILD_ASSERT
980#define BUILD_ASSERT(x) \
981 do { \
982 (void)sizeof(char[0 - (!(x))]); \
983 } while (0)

--- 17 unchanged lines hidden ---