├── .ci ├── Jenkinsfile ├── README.md ├── artifacts.sh ├── blackduck_source.sh ├── do_release.sh ├── dockerfiles │ ├── Dockerfile.rhel8.6 │ ├── Dockerfile.rhel8.6.release │ └── Dockerfile.rhel9.4 ├── matrix_job.yaml ├── pipeline │ ├── dr_weekly_jjb.yaml │ ├── dr_weekly_matrix.yaml │ ├── release_jjb.yaml │ └── release_matrix_job.yaml ├── proj_jjb.yaml ├── redmine_jjb.yaml ├── redmine_matrix_job.yaml └── scripts │ └── doca_install.sh ├── .github ├── ISSUE_TEMPLATE.md └── PULL_REQUEST_TEMPLATE.md ├── .gitignore ├── .gittemplate ├── CHANGES ├── COPYING ├── LICENSE ├── Makefile.am ├── README ├── README.md ├── autogen.sh ├── config └── m4 │ ├── compiler.m4 │ ├── func.m4 │ ├── nl.m4 │ ├── opt.m4 │ ├── prof.m4 │ └── verbs.m4 ├── configure.ac ├── contrib ├── build_pkg.sh ├── jenkins_tests │ ├── build.sh │ ├── commit.sh │ ├── compiler.sh │ ├── copyright-check-map.yaml │ ├── copyrights.sh │ ├── cov.sh │ ├── cppcheck.sh │ ├── csbuild.sh │ ├── globals.sh │ ├── gtest.sh │ ├── rpm.sh │ ├── style.sh │ ├── test.sh │ ├── tool.sh │ ├── vg.sh │ └── vutil.sh ├── scripts │ ├── libvma.spec.in │ ├── vma.init.in │ └── vma.service.in ├── test_jenkins.sh └── valgrind │ └── valgrind_vma.supp ├── debian ├── changelog.in ├── compat ├── control ├── copyright ├── libvma-dev.install ├── libvma-utils.install ├── libvma.install ├── postinst ├── postrm ├── prerm ├── rules └── watch ├── docs ├── coding-style.md ├── contributing.md └── man │ ├── Makefile.am │ ├── vma.7.in │ ├── vma_stats.8.in │ └── vmad.8.in ├── src ├── Makefile.am ├── state_machine │ ├── Makefile.am │ ├── main.cpp │ ├── sm.cpp │ ├── sm.h │ ├── sm_fifo.cpp │ └── sm_fifo.h ├── stats │ ├── Makefile.am │ ├── stats_data_reader.h │ ├── stats_printer.cpp │ ├── stats_publisher.cpp │ └── stats_reader.cpp ├── utils │ ├── Makefile.am │ ├── asm-arm64.h │ ├── asm-ppc64.h │ ├── asm-x86.h │ ├── asm.h │ ├── atomic.h │ ├── bullseye.h │ ├── clock.h │ ├── compiler.h │ ├── lock_wrapper.h │ ├── rdtsc.h │ └── types.h ├── vlogger │ ├── Makefile.am │ ├── main.cpp │ ├── vlogger.cpp │ └── vlogger.h └── vma │ ├── Makefile.am │ ├── config_parser.c │ ├── config_parser.h │ ├── config_scanner.c │ ├── dev │ ├── allocator.cpp │ ├── allocator.h │ ├── buffer_pool.cpp │ ├── buffer_pool.h │ ├── cq_mgr.cpp │ ├── cq_mgr.h │ ├── cq_mgr.inl │ ├── cq_mgr_mlx5.cpp │ ├── cq_mgr_mlx5.h │ ├── cq_mgr_mlx5.inl │ ├── dm_mgr.cpp │ ├── dm_mgr.h │ ├── gro_mgr.cpp │ ├── gro_mgr.h │ ├── ib_ctx_handler.cpp │ ├── ib_ctx_handler.h │ ├── ib_ctx_handler_collection.cpp │ ├── ib_ctx_handler_collection.h │ ├── net_device_entry.cpp │ ├── net_device_entry.h │ ├── net_device_table_mgr.cpp │ ├── net_device_table_mgr.h │ ├── net_device_val.cpp │ ├── net_device_val.h │ ├── qp_mgr.cpp │ ├── qp_mgr.h │ ├── qp_mgr_eth_direct.cpp │ ├── qp_mgr_eth_direct.h │ ├── qp_mgr_eth_mlx5.cpp │ ├── qp_mgr_eth_mlx5.h │ ├── rfs.cpp │ ├── rfs.h │ ├── rfs_mc.cpp │ ├── rfs_mc.h │ ├── rfs_uc.cpp │ ├── rfs_uc.h │ ├── rfs_uc_tcp_gro.cpp │ ├── rfs_uc_tcp_gro.h │ ├── ring.cpp │ ├── ring.h │ ├── ring_allocation_logic.cpp │ ├── ring_allocation_logic.h │ ├── ring_bond.cpp │ ├── ring_bond.h │ ├── ring_eth_direct.cpp │ ├── ring_eth_direct.h │ ├── ring_profile.cpp │ ├── ring_profile.h │ ├── ring_simple.cpp │ ├── ring_simple.h │ ├── ring_slave.cpp │ ├── ring_slave.h │ ├── ring_tap.cpp │ ├── ring_tap.h │ ├── time_converter.cpp │ ├── time_converter.h │ ├── time_converter_ib_ctx.cpp │ ├── time_converter_ib_ctx.h │ ├── time_converter_ptp.cpp │ ├── time_converter_ptp.h │ ├── wqe_send_handler.cpp │ ├── wqe_send_handler.h │ ├── wqe_send_ib_handler.cpp │ └── wqe_send_ib_handler.h │ ├── event │ ├── command.h │ ├── delta_timer.cpp │ ├── delta_timer.h │ ├── event.h │ ├── event_handler_ibverbs.h │ ├── event_handler_manager.cpp │ ├── event_handler_manager.h │ ├── event_handler_rdma_cm.h │ ├── netlink_event.cpp │ ├── netlink_event.h │ ├── timer_handler.h │ ├── timers_group.h │ ├── vlogger_timer_handler.cpp │ └── vlogger_timer_handler.h │ ├── ib │ ├── base │ │ ├── verbs_extra.cpp │ │ └── verbs_extra.h │ └── mlx5 │ │ ├── ib_mlx5.cpp │ │ ├── ib_mlx5.h │ │ ├── ib_mlx5_dv.cpp │ │ ├── ib_mlx5_dv.h │ │ ├── ib_mlx5_hw.cpp │ │ └── ib_mlx5_hw.h │ ├── infra │ ├── DemoCollMgr.cpp │ ├── DemoCollMgr.h │ ├── DemoObserver.cpp │ ├── DemoObserver.h │ ├── DemoSubject.cpp │ ├── DemoSubject.h │ ├── Makefile.am │ ├── cache_subject_observer.h │ ├── main.cpp │ ├── sender.cpp │ ├── sender.h │ ├── sender_info_dst.cpp │ ├── sender_info_dst.h │ ├── subject_observer.cpp │ └── subject_observer.h │ ├── iomux │ ├── epfd_info.cpp │ ├── epfd_info.h │ ├── epoll_wait_call.cpp │ ├── epoll_wait_call.h │ ├── io_mux_call.cpp │ ├── io_mux_call.h │ ├── poll_call.cpp │ ├── poll_call.h │ ├── select_call.cpp │ └── select_call.h │ ├── libvma.c │ ├── lwip │ ├── cc.c │ ├── cc.h │ ├── cc_cubic.c │ ├── cc_cubic.h │ ├── cc_lwip.c │ ├── cc_none.c │ ├── def.h │ ├── err.h │ ├── init.c │ ├── init.h │ ├── ip.h │ ├── ip_addr.h │ ├── opt.h │ ├── pbuf.c │ ├── pbuf.h │ ├── stats.h │ ├── tcp.c │ ├── tcp.h │ ├── tcp_impl.h │ ├── tcp_in.c │ └── tcp_out.c │ ├── main.cpp │ ├── main.h │ ├── netlink │ ├── Makefile.am │ ├── link_info.cpp │ ├── link_info.h │ ├── neigh_info.cpp │ ├── neigh_info.h │ ├── netlink_compatibility.cpp │ ├── netlink_compatibility.h │ ├── netlink_wrapper.cpp │ ├── netlink_wrapper.h │ ├── route_info.cpp │ ├── route_info.h │ └── test_main.cpp │ ├── proto │ ├── L2_address.cpp │ ├── L2_address.h │ ├── arp.cpp │ ├── arp.h │ ├── dst_entry.cpp │ ├── dst_entry.h │ ├── dst_entry_tcp.cpp │ ├── dst_entry_tcp.h │ ├── dst_entry_udp.cpp │ ├── dst_entry_udp.h │ ├── dst_entry_udp_mc.cpp │ ├── dst_entry_udp_mc.h │ ├── flow_tuple.cpp │ ├── flow_tuple.h │ ├── header.cpp │ ├── header.h │ ├── igmp_handler.cpp │ ├── igmp_handler.h │ ├── igmp_mgr.cpp │ ├── igmp_mgr.h │ ├── ip_address.h │ ├── ip_frag.cpp │ ├── ip_frag.h │ ├── mem_buf_desc.h │ ├── neighbour.cpp │ ├── neighbour.h │ ├── neighbour_observer.h │ ├── neighbour_table_mgr.cpp │ ├── neighbour_table_mgr.h │ ├── netlink_socket_mgr.h │ ├── peer_key.h │ ├── route_entry.cpp │ ├── route_entry.h │ ├── route_rule_table_key.h │ ├── route_table_mgr.cpp │ ├── route_table_mgr.h │ ├── route_val.cpp │ ├── route_val.h │ ├── rule_entry.cpp │ ├── rule_entry.h │ ├── rule_table_mgr.cpp │ ├── rule_table_mgr.h │ ├── rule_val.cpp │ ├── rule_val.h │ ├── vma_lwip.cpp │ └── vma_lwip.h │ ├── sock │ ├── cleanable_obj.h │ ├── fd_collection.cpp │ ├── fd_collection.h │ ├── pipeinfo.cpp │ ├── pipeinfo.h │ ├── pkt_rcvr_sink.h │ ├── pkt_sndr_source.h │ ├── sock-redirect.cpp │ ├── sock-redirect.h │ ├── socket_fd_api.cpp │ ├── socket_fd_api.h │ ├── sockinfo.cpp │ ├── sockinfo.h │ ├── sockinfo_tcp.cpp │ ├── sockinfo_tcp.h │ ├── sockinfo_udp.cpp │ └── sockinfo_udp.h │ ├── util │ ├── agent.cpp │ ├── agent.h │ ├── agent_def.h │ ├── chunk_list.h │ ├── config_parser.y │ ├── config_scanner.l │ ├── data_updater.cpp │ ├── data_updater.h │ ├── hash_map.h │ ├── hash_map.inl │ ├── if.h │ ├── instrumentation.cpp │ ├── instrumentation.h │ ├── libvma.conf │ ├── libvma.h │ ├── list.h │ ├── match.cpp │ ├── sg_array.h │ ├── sock_addr.h │ ├── sys_vars.cpp │ ├── sys_vars.h │ ├── sysctl_reader.h │ ├── to_str.h │ ├── utils.cpp │ ├── utils.h │ ├── valgrind.h │ ├── vma_list.h │ ├── vma_stats.h │ ├── vtypes.h │ ├── wakeup.cpp │ ├── wakeup.h │ ├── wakeup_pipe.cpp │ └── wakeup_pipe.h │ └── vma_extra.h ├── tests ├── Makefile.am ├── README_How_to_update_sockperf_in_VMA.txt ├── TODO ├── api-support-check.py ├── async-echo-client │ ├── async-echo-client.py │ ├── echo-server.py │ └── syncronized-echo-client.py ├── benchmarking_test │ └── Accelerators_Benchmarking.sh ├── bindtodevice │ └── client.py ├── connect-disconnect │ └── client.py ├── extra_api_tests │ ├── socketxtreme │ │ └── server_tcp.c │ └── tcp_zcopy_cb │ │ ├── README │ │ ├── client.c │ │ ├── client.h │ │ ├── main.c │ │ ├── server.c │ │ ├── server.h │ │ ├── types.h │ │ └── utils.c ├── functionality │ ├── getsockname_test.c │ └── iomux │ │ ├── 1epoll_1socket_twice.c │ │ ├── 2epoll_1socket.c │ │ ├── client.py │ │ ├── eclient.py │ │ ├── eserver.py │ │ ├── pclient.py │ │ ├── pserver.py │ │ └── server.py ├── gtest │ ├── Makefile.am │ ├── README │ ├── common │ │ ├── base.cc │ │ ├── base.h │ │ ├── cmn.h │ │ ├── def.h │ │ ├── log.h │ │ ├── sys.cc │ │ ├── sys.h │ │ └── tap.h │ ├── googletest │ │ ├── LICENSE │ │ ├── README.md │ │ ├── include │ │ │ └── gtest │ │ │ │ ├── gtest-death-test.h │ │ │ │ ├── gtest-message.h │ │ │ │ ├── gtest-param-test.h │ │ │ │ ├── gtest-printers.h │ │ │ │ ├── gtest-spi.h │ │ │ │ ├── gtest-test-part.h │ │ │ │ ├── gtest-typed-test.h │ │ │ │ ├── gtest.h │ │ │ │ ├── gtest_pred_impl.h │ │ │ │ ├── gtest_prod.h │ │ │ │ └── internal │ │ │ │ ├── gtest-death-test-internal.h │ │ │ │ ├── gtest-filepath.h │ │ │ │ ├── gtest-internal.h │ │ │ │ ├── gtest-linked_ptr.h │ │ │ │ ├── gtest-param-util-generated.h │ │ │ │ ├── gtest-param-util.h │ │ │ │ ├── gtest-port.h │ │ │ │ ├── gtest-string.h │ │ │ │ ├── gtest-tuple.h │ │ │ │ └── gtest-type-util.h │ │ └── src │ │ │ ├── gtest-all.cc │ │ │ ├── gtest-death-test.cc │ │ │ ├── gtest-filepath.cc │ │ │ ├── gtest-internal-inl.h │ │ │ ├── gtest-port.cc │ │ │ ├── gtest-printers.cc │ │ │ ├── gtest-test-part.cc │ │ │ ├── gtest-typed-test.cc │ │ │ ├── gtest.cc │ │ │ └── gtest_main.cc │ ├── main.cc │ ├── mix │ │ ├── mix_base.cc │ │ ├── mix_base.h │ │ ├── mix_list.cc │ │ └── sg_array.cc │ ├── sock │ │ ├── sock_base.cc │ │ ├── sock_base.h │ │ └── sock_socket.cc │ ├── tcp │ │ ├── tcp_base.cc │ │ ├── tcp_base.h │ │ ├── tcp_bind.cc │ │ ├── tcp_connect.cc │ │ ├── tcp_connect_nb.cc │ │ ├── tcp_event.cc │ │ ├── tcp_send.cc │ │ ├── tcp_send_zc.cc │ │ ├── tcp_sendfile.cc │ │ ├── tcp_sendto.cc │ │ ├── tcp_socket.cc │ │ ├── tcp_sockopt.cc │ │ └── tcp_tls.cc │ ├── udp │ │ ├── udp_base.cc │ │ ├── udp_base.h │ │ ├── udp_bind.cc │ │ ├── udp_connect.cc │ │ ├── udp_send.cc │ │ └── udp_sendto.cc │ ├── vma │ │ ├── vma_base.cc │ │ ├── vma_base.h │ │ ├── vma_ioctl.cc │ │ ├── vma_poll.cc │ │ ├── vma_recvfrom_zcopy.cc │ │ ├── vma_ring.cc │ │ └── vma_sockopt.cc │ └── vmad │ │ ├── vmad_base.cc │ │ ├── vmad_base.h │ │ ├── vmad_bitmap.cc │ │ ├── vmad_flow.cc │ │ ├── vmad_hash.cc │ │ ├── vmad_init.cc │ │ └── vmad_state.cc ├── latency_test │ ├── Makefile.am │ ├── tcp_lat.cpp │ └── udp_lat.c ├── listen │ ├── tcp_client.py │ └── tcp_server.py ├── low_pps_tcp_send_test │ ├── exchange.cpp │ ├── readme.txt │ └── trader.cpp ├── mc_loop_test │ └── mc_loop_test.c ├── multithread_test │ ├── exchange.cpp │ ├── readme.txt │ └── trader.cpp ├── pps_test │ ├── Makefile.am │ └── pps_test.c ├── resource_release_checker │ ├── server_socket_receive_and_recreate_loop.py │ └── server_socket_recreate_loop.py ├── reuse_ud_test.c ├── select_t1.c ├── server_test │ ├── Makefile.am │ ├── client.cc │ ├── client.h │ ├── main.cc │ ├── options.cc │ ├── options.h │ ├── server.cc │ ├── server.h │ ├── vtime.cc │ └── vtime.h ├── simple_fork │ └── fork.py ├── tcp_window_size_exerciser │ ├── Makefile │ ├── README │ ├── tcp_wnd_test.h │ ├── tcp_wnd_test_client.c │ └── tcp_wnd_test_server.c ├── testbed │ ├── README │ └── testbed.c ├── throughput_test │ ├── Makefile.am │ └── bandwidth_test.c ├── timetest │ ├── Makefile.am │ └── timetest.cpp └── vma_perf_envelope │ ├── vma_multiplexers_test.sh │ └── vma_perf_envelope.sh └── tools ├── Makefile.am └── daemon ├── Makefile.am ├── bitmap.h ├── daemon.c ├── daemon.h ├── flow.c ├── hash.c ├── hash.h ├── loop.c ├── message.c ├── nl.c ├── nl.h ├── notify.c ├── store.c ├── tc.c └── tc.h /.ci/Jenkinsfile: -------------------------------------------------------------------------------- 1 | #!/usr/bin/groovy 2 | 3 | // load pipeline functions 4 | // Requires pipeline-github-lib plugin to load library from github 5 | @Library('github.com/Mellanox/ci-demo@stable_media') 6 | def matrix = new com.mellanox.cicd.Matrix() 7 | 8 | matrix.main() 9 | -------------------------------------------------------------------------------- /.ci/artifacts.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -xl 2 | 3 | if [ -d jenkins ]; then 4 | gzip -f ./jenkins/*.tar 2>/dev/null || true 5 | cd ./jenkins/ ; 6 | for f in *.tar.gz ; do [ -e "$f" ] && mv "$f" "${flags}/arch-${name}-$f" ; done ; 7 | cd .. 8 | cd ./jenkins/${flags}; 9 | for f in *.tap ; do [ -e "$f" ] && mv "$f" "${flags}-${name}-$f" ; done ; 10 | for f in *.xml ; do [ -e "$f" ] && mv "$f" "${flags}-${name}-$f" ; done ; 11 | cd ../.. 12 | fi 13 | -------------------------------------------------------------------------------- /.ci/blackduck_source.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -Exel 2 | 3 | topdir=$(git rev-parse --show-toplevel) 4 | cd "$topdir" 5 | 6 | # Check if the variables and pipeline attributes are set 7 | [[ -z "${WORKSPACE}" ]] && { echo "Error: WORKSPACE variable is not set"; exit 1; } 8 | [[ -z "$BLACKDUCK_API_TOKEN" ]] && { echo "Error: BLACKDUCK_API_TOKEN variable is not set"; exit 1; } 9 | [[ ! -d "${WORKSPACE}/logs" ]] && mkdir -p "${WORKSPACE}/logs" 10 | 11 | # Create valid JSON for further authentication in BlackDuck server 12 | json=$(jq -n \ 13 | --arg token "$BLACKDUCK_API_TOKEN" \ 14 | '{"blackduck.url": "https://blackduck.mellanox.com/", "blackduck.api.token": $token }') 15 | 16 | export SPRING_APPLICATION_JSON="$json" 17 | export PROJECT_NAME=LibVMA 18 | export PROJECT_VERSION="$sha1" 19 | export PROJECT_SRC_PATH="$topdir"/src/ 20 | 21 | echo "Running BlackDuck (SRC) on $name" 22 | echo "CONFIG:" 23 | echo " NAME: ${PROJECT_NAME}" 24 | echo " VERSION: ${PROJECT_VERSION}" 25 | echo " SRC_PATH: ${PROJECT_SRC_PATH}" 26 | 27 | # clone BlackDuck 28 | [[ -d /tmp/blackduck ]] && rm -rf /tmp/blackduck 29 | [[ -d ~/.ssh/ ]] || mkdir -p ~/.ssh/ 30 | chmod 600 "${GERRIT_SSH_KEY}" 31 | ssh-keyscan -p 12023 -H git-nbu.nvidia.com >> ~/.ssh/known_hosts 32 | git clone -c core.sshCommand="ssh -i ${GERRIT_SSH_KEY} -l swx-jenkins2-svc" -b master --single-branch --depth=1 ssh://git-nbu.nvidia.com:12023/DevOps/Tools/blackduck /tmp/blackduck 33 | cd /tmp/blackduck 34 | 35 | # disable check errors 36 | set +e 37 | timeout 3600 ./run_bd_scan.sh 38 | exit_code=$? 39 | # enable back 40 | set -e 41 | 42 | # copy run log to a place that jenkins job will archive it 43 | REPORT_NAME="BlackDuck_source_${PROJECT_NAME}_${PROJECT_VERSION}" 44 | cat "log/${PROJECT_NAME}_${PROJECT_VERSION}"*.log > "${WORKSPACE}/logs/${REPORT_NAME}.log" || true 45 | cat "log/${PROJECT_NAME}_${PROJECT_VERSION}"*.log || true 46 | 47 | if [ "$exit_code" == "0" ]; then 48 | cp -v /tmp/blackduck/report/*.pdf "${WORKSPACE}/logs/${REPORT_NAME}.pdf" 49 | fi 50 | 51 | exit $exit_code 52 | -------------------------------------------------------------------------------- /.ci/dockerfiles/Dockerfile.rhel8.6: -------------------------------------------------------------------------------- 1 | ARG HARBOR_URL=nbu-harbor.gtm.nvidia.com 2 | ARG ARCH=x86_64 3 | FROM $HARBOR_URL/hpcx/x86_64/rhel8.6/core:latest 4 | ARG WEBREPO_URL=webrepo.gtm.nvidia.com 5 | 6 | RUN sed -i "s/webrepo/${WEBREPO_URL}/" /etc/yum.repos.d/* && \ 7 | sed -i 's/mirrorlist/#mirrorlist/;s!#baseurl=http://mirror.centos.org!baseurl=http://vault.centos.org!' /etc/yum.repos.d/* && \ 8 | echo "[mlnx-opt]" > /etc/yum.repos.d/mlnx-opt.repo && \ 9 | echo "name=RHEL 8.6 mirror" >> /etc/yum.repos.d/mlnx-opt.repo && \ 10 | echo "baseurl=http://${WEBREPO_URL}/RH/optional/8.6/x86_64/" >> /etc/yum.repos.d/mlnx-opt.repo && \ 11 | echo "enabled=1" >> /etc/yum.repos.d/mlnx-opt.repo && \ 12 | echo "gpgcheck=0" >> /etc/yum.repos.d/mlnx-opt.repo && \ 13 | yum makecache 14 | 15 | RUN yum install --allowerasing -y \ 16 | java-11-openjdk jq git && \ 17 | yum clean all && \ 18 | rm -rf /var/cache/yum 19 | -------------------------------------------------------------------------------- /.ci/dockerfiles/Dockerfile.rhel8.6.release: -------------------------------------------------------------------------------- 1 | ARG HARBOR_URL=nbu-harbor.gtm.nvidia.com 2 | FROM $HARBOR_URL/hpcx/x86_64/rhel8.6/core:latest 3 | ARG WEBREPO_URL=webrepo.gtm.nvidia.com 4 | ARG _UID=6213 5 | ARG _GID=101 6 | ARG _LOGIN=swx-jenkins 7 | ARG _HOME=/var/home/$_LOGIN 8 | 9 | RUN sed -i "s#http://webrepo#http://${WEBREPO_URL}#" /etc/yum.repos.d/* && \ 10 | sed -i 's/mirrorlist/#mirrorlist/;s!#baseurl=http://mirror.centos.org!baseurl=http://vault.centos.org!' /etc/yum.repos.d/* && \ 11 | echo "[mlnx-opt]" > /etc/yum.repos.d/mlnx-opt.repo && \ 12 | echo "name=RHEL 8.6 mirror" >> /etc/yum.repos.d/mlnx-opt.repo && \ 13 | echo "baseurl=http://${WEBREPO_URL}/RH/optional/8.6/x86_64/" >> /etc/yum.repos.d/mlnx-opt.repo && \ 14 | echo "enabled=1" >> /etc/yum.repos.d/mlnx-opt.repo && \ 15 | echo "gpgcheck=0" >> /etc/yum.repos.d/mlnx-opt.repo && \ 16 | yum makecache 17 | 18 | RUN echo "${_LOGIN} ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers && \ 19 | echo "root ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers && \ 20 | mkdir -p ${_HOME} && \ 21 | groupadd -f -g "$_GID" "$_LOGIN" && \ 22 | useradd -u "$_UID" -g "$_GID" -s /bin/bash -m -d ${_HOME} "${_LOGIN}" && \ 23 | chown -R ${_LOGIN} ${_HOME} 24 | 25 | RUN yum install --allowerasing -y \ 26 | git autoconf automake libtool gcc \ 27 | sudo gcc-c++ libibverbs-devel rdma-core \ 28 | librdmacm unzip patch wget make \ 29 | libnl3-devel rpm-build 30 | -------------------------------------------------------------------------------- /.ci/dockerfiles/Dockerfile.rhel9.4: -------------------------------------------------------------------------------- 1 | ARG HARBOR_URL=nbu-harbor.gtm.nvidia.com 2 | ARG ARCH=x86_64 3 | FROM $HARBOR_URL/swx-infra/media/$ARCH/base/rhel:9.4 4 | ARG WEBREPO_URL=webrepo.gtm.nvidia.com 5 | ARG ARCH 6 | ARG _UID=6213 7 | ARG _GID=101 8 | ARG _LOGIN=swx-jenkins 9 | ARG _HOME=/var/home/$_LOGIN 10 | 11 | RUN sed -i "s#http://webrepo#http://${WEBREPO_URL}#" /etc/yum.repos.d/* && \ 12 | sed -i 's/mirrorlist/#mirrorlist/;s!#baseurl=http://mirror.centos.org!baseurl=http://vault.centos.org!' /etc/yum.repos.d/* && \ 13 | echo "[mlnx-9.4-BaseOS]" > /etc/yum.repos.d/mlnx-9.4-BaseOS.repo && \ 14 | echo "name=RHEL 9.4 mirror BaseOS" >> /etc/yum.repos.d/mlnx-9.4-BaseOS.repo && \ 15 | echo "baseurl=http://${WEBREPO_URL}/RH/9.4/$ARCH/BaseOS/" >> /etc/yum.repos.d/mlnx-9.4-BaseOS.repo && \ 16 | echo "enabled=1" >> /etc/yum.repos.d/mlnx-9.4-BaseOS.repo && \ 17 | echo "gpgcheck=0" >> /etc/yum.repos.d/mlnx-9.4-BaseOS.repo && \ 18 | echo "[mlnx-9.4-AppStream]" > /etc/yum.repos.d/mlnx-9.4-AppStream.repo && \ 19 | echo "name=RHEL 9.4 mirror AppStream" >> /etc/yum.repos.d/mlnx-9.4-AppStream.repo && \ 20 | echo "baseurl=http://${WEBREPO_URL}/RH/9.4/$ARCH/AppStream/" >> /etc/yum.repos.d/mlnx-9.4-AppStream.repo && \ 21 | echo "enabled=1" >> /etc/yum.repos.d/mlnx-9.4-AppStream.repo && \ 22 | echo "gpgcheck=0" >> /etc/yum.repos.d/mlnx-9.4-AppStream.repo && \ 23 | yum makecache 24 | 25 | RUN echo "${_LOGIN} ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers && \ 26 | echo "root ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers && \ 27 | mkdir -p ${_HOME} && \ 28 | groupadd -f -g "$_GID" "$_LOGIN" && \ 29 | useradd -u "$_UID" -g "$_GID" -s /bin/bash -m -d ${_HOME} "${_LOGIN}" && \ 30 | chown -R ${_LOGIN} ${_HOME} 31 | 32 | RUN dnf install --allowerasing -y \ 33 | git autoconf automake libtool gcc \ 34 | sudo gcc-c++ libibverbs-devel rdma-core \ 35 | librdmacm unzip patch wget make \ 36 | libnl3-devel rpm-build && \ 37 | dnf clean all && rm -rf /var/cache/dnf/* 38 | -------------------------------------------------------------------------------- /.ci/pipeline/release_matrix_job.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | job: LibVMA-release 3 | registry_host: nbu-harbor.gtm.nvidia.com 4 | registry_auth: swx-infra_harbor_credentials 5 | registry_path: /swx-infra/media/libvma 6 | 7 | kubernetes: 8 | privileged: true 9 | cloud: il-ipp-blossom-prod 10 | nodeSelector: 'beta.kubernetes.io/os=linux' 11 | namespace: swx-media 12 | limits: '{memory: 8Gi, cpu: 7000m}' 13 | requests: '{memory: 8Gi, cpu: 7000m}' 14 | 15 | env: 16 | MAIL_FROM: jenkins@nvidia.com 17 | 18 | volumes: 19 | # Default release location 20 | - {mountPath: /auto/mswg/release/vma, hostPath: /auto/mswg/release/vma} 21 | # User profile for release 22 | - {mountPath: /var/home/swx-jenkins, hostPath: /labhome/swx-jenkins} 23 | 24 | empty_volumes: 25 | - {mountPath: /tmp/source_rpms, memory: true} 26 | 27 | runs_on_dockers: 28 | - { 29 | file: '.ci/dockerfiles/Dockerfile.rhel8.6.release', 30 | name: 'rhel8.6', 31 | uri: '$arch/$name/release', 32 | build_args: '--no-cache', 33 | arch: 'x86_64', 34 | tag: '20250128' 35 | } 36 | 37 | steps: 38 | - name: Release 39 | parallel: false 40 | run: | 41 | .ci/do_release.sh 42 | archiveArtifacts: pkg/build_pkg.log,pkg/packages/*.rpm 43 | 44 | pipeline_start: 45 | shell: action 46 | module: groovy 47 | run: | 48 | echo "Starting release process for LibVMA-${release_tag}" 49 | currentBuild.displayName += "-${release_tag}" 50 | 51 | pipeline_stop: 52 | shell: action 53 | module: groovy 54 | run: | 55 | if (!params.notification_email.isEmpty()) { 56 | mail from: "${MAIL_FROM}", 57 | mimeType: 'text/html', 58 | to: "${notification_email}", 59 | subject: "Release build ended for LibVMA - ${release_tag}", 60 | body: """ 61 |

Tag: ${release_tag}

62 |

Build url: link

63 |

Status: ${currentBuild.currentResult}

""" 64 | } 65 | -------------------------------------------------------------------------------- /.ci/redmine_matrix_job.yaml: -------------------------------------------------------------------------------- 1 | --- 2 | job: LibVMA-redmine-issue 3 | 4 | registry_host: harbor.mellanox.com 5 | registry_auth: swx-storage 6 | 7 | kubernetes: 8 | privileged: true 9 | cloud: il-ipp-blossom-prod 10 | namespace: swx-media 11 | nodeSelector: 'beta.kubernetes.io/os=linux' 12 | limits: '{memory: 1Gi, cpu: 1000m}' 13 | requests: '{memory: 1Gi, cpu: 1000m}' 14 | 15 | failFast: false 16 | timeout_minutes: 20 17 | env: 18 | MAIL_FROM: jenkins@nvidia.com 19 | 20 | volumes: 21 | - {mountPath: /hpc/local/inst/hpc-internal-tools, hostPath: /hpc/local/inst/hpc-internal-tools} 22 | 23 | runs_on_dockers: 24 | - {name: 'ub22.04-base', url: 'harbor.mellanox.com/hpcx/x86_64/ubuntu22.04/base', arch: 'x86_64'} 25 | 26 | steps: 27 | - name: Redmine 28 | containerSelector: 29 | - "{name: 'ub22.04-base'}" 30 | run: | 31 | #!/bin/bash -eExl 32 | env 33 | python3 -m pip install six 34 | python3 /hpc/local/inst/hpc-internal-tools/tools/git_tools/git_redmine/update_redmine_from_git_commit_python3.py --update --project_id=9 --on_email_mismatch=warn \ 35 | --on_issue_not_in_project=fail --pr_url=${ghprbPullLink} --commit_id=${ghprbActualCommit} 36 | parallel: false 37 | 38 | pipeline_start: 39 | run: | 40 | printenv 41 | echo "Start" 42 | 43 | pipeline_stop: 44 | shell: action 45 | module: groovy 46 | run: | 47 | mail from: "${MAIL_FROM}", 48 | mimeType: 'text/html', 49 | to: "${MAIL_TO}", 50 | subject: 'Redmine check for build ${currentBuild.number}', 51 | body: """ 52 |

Build url: link

""" 53 | sh 'echo "Finish"' 54 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | ## Subject 2 | 3 | ## Issue type 4 | - [ ] Bug report 5 | - [ ] Feature request 6 | 7 | ## Configuration: 8 | * Product version 9 | * OS 10 | * OFED 11 | * Hardware 12 | 13 | ## Actual behavior: 14 | 15 | ## Expected behavior: 16 | 17 | ## Steps to reproduce: 18 | -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | ## Description 2 | Please provide a summary of the change. 3 | 4 | ##### What 5 | _Subject: what this PR is doing in one line._ 6 | 7 | ##### Why ? 8 | _Justification for the PR. If there is existing issue/bug please reference._ 9 | 10 | ##### How ? 11 | _It is optional but for complex PRs please provide information about the design, 12 | architecture, approach, etc._ 13 | 14 | ## Change type 15 | What kind of change does this PR introduce? 16 | - [ ] Bugfix 17 | - [ ] Feature 18 | - [ ] Code style update 19 | - [ ] Refactoring (no functional changes, no api changes) 20 | - [ ] Build related changes 21 | - [ ] CI related changes 22 | - [ ] Documentation content changes 23 | - [ ] Tests 24 | - [ ] Other 25 | 26 | ## Check list 27 | - [ ] Code follows the style de facto guidelines of this project 28 | - [ ] Comments have been inserted in hard to understand places 29 | - [ ] Documentation has been updated (if necessary) 30 | - [ ] Test has been added (if possible) 31 | 32 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Object files 2 | *.o 3 | *.lo 4 | *.la 5 | 6 | # Libraries 7 | .libs 8 | *.lib 9 | *.a 10 | 11 | # Shared objects 12 | *.so 13 | *.so.* 14 | 15 | # Dependencies 16 | .dirstamp 17 | .deps 18 | 19 | # Automake 20 | Makefile.in 21 | Makefile 22 | aclocal.m4 23 | autom4te.cache/ 24 | config.h 25 | config.h.in 26 | config.h.in~ 27 | config.log 28 | config.status 29 | config/aux/config.guess 30 | config/aux/config.sub 31 | config/aux/install-sh 32 | config/aux/missing 33 | config/aux/decomp 34 | config/aux/ltmain.sh 35 | config/aux/compile 36 | config/aux/depcomp 37 | config/m4/libtool.m4 38 | config/m4/ltoptions.m4 39 | config/m4/ltsugar.m4 40 | config/m4/ltversion.m4 41 | config/m4/lt~obsolete.m4 42 | configure 43 | libtool 44 | 45 | # Tool 46 | cov-int/ 47 | jenkins/ 48 | 49 | # IDE files 50 | .cproject 51 | .project 52 | tags 53 | .vs/ 54 | obj/ 55 | *.sln 56 | *.vcxproj 57 | *.vcxproj.filters 58 | *.vcxproj.user 59 | VTune Profiler Results/ 60 | 61 | # VMA specific 62 | src/utils/timetest 63 | src/stats/vma_stats 64 | src/vlogger/vlogger_test 65 | src/state_machine/state_machine_test 66 | stamp-h1 67 | 68 | # build products 69 | VMA_VERSION 70 | build/libvma.spec 71 | debian/changelog 72 | contrib/scripts/vma.init 73 | contrib/scripts/vma.service 74 | tools/daemon/vmad 75 | -------------------------------------------------------------------------------- /.gittemplate: -------------------------------------------------------------------------------- 1 | issue: 2 | 3 | log:
4 | 5 | reviewed by: 6 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 2 | SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 3 | 4 | This software is available to you under a choice of one of two 5 | licenses. You may choose to be licensed under the terms of the GNU 6 | General Public License (GPL) Version 2, available from the file 7 | COPYING in the main directory of this source tree, or the 8 | BSD – 2- Clause license below: 9 | 10 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 11 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 12 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 13 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 14 | -------------------------------------------------------------------------------- /Makefile.am: -------------------------------------------------------------------------------- 1 | SUBDIRS := src tools docs/man 2 | 3 | 4 | DIST_SUBDIRS := src tests tools docs/man 5 | 6 | noinst_SCRIPTS = \ 7 | $(wildcard contrib/scripts/*) 8 | 9 | EXTRA_DIST = \ 10 | contrib \ 11 | debian \ 12 | LICENSE \ 13 | CHANGES \ 14 | README 15 | 16 | 17 | .PHONY: tests 18 | 19 | mydocdir = $(if $(docdir),$(docdir),${datadir}/doc/$(distdir)) 20 | mydoc_DATA = README CHANGES 21 | 22 | install-exec-hook: 23 | if command -v systemctl >/dev/null 2>&1; then \ 24 | mkdir -p $(DESTDIR)$(prefix)/lib/systemd/system/; \ 25 | cp $(top_builddir)/contrib/scripts/vma.service $(DESTDIR)$(prefix)/lib/systemd/system/vma.service; \ 26 | chmod 644 $(DESTDIR)$(prefix)/lib/systemd/system/vma.service; \ 27 | fi 28 | 29 | uninstall-hook: 30 | if command -v systemctl >/dev/null 2>&1; then \ 31 | rm -rf $(DESTDIR)$(prefix)/lib/systemd/system/vma.service; \ 32 | fi 33 | 34 | install-all: install 35 | 36 | uninstall-all: uninstall 37 | 38 | tests: 39 | $(MAKE) 40 | $(MAKE) -C tests/gtest 41 | $(MAKE) -C tests/latency_test 42 | $(MAKE) -C tests/throughput_test 43 | $(MAKE) -C tests/pps_test 44 | 45 | demo: 46 | $(MAKE) 47 | $(MAKE) -C src/vma/infra 48 | 49 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![GitHub version](https://badge.fury.io/gh/mellanox%2Flibvma.svg)](https://badge.fury.io/gh/mellanox%2Flibvma) 2 | [![Coverity Scan Build Status](https://scan.coverity.com/projects/8025/badge.svg)](https://scan.coverity.com/projects/libvma) 3 | 4 | ### Introduction 5 | NVIDIA Messaging Accelerator (VMA) boosts performance for message-based and streaming applications such as those found in financial services market data environments and Web2.0 clusters. It allows application written over standard socket API 6 | to run over Ethernet and/or Infiniband from user-space with full network stack bypass. 7 | 8 | The [VMA architecture](https://github.com/Mellanox/libvma/wiki/Architecture) page includes additional information. 9 | 10 | ### Download 11 | Get all download and installation information [here](https://github.com/Mellanox/libvma/wiki/Downloads). 12 | or some quick instruction in order to [build VMA from source](https://github.com/Mellanox/libvma/wiki/Build-Instruction). 13 | 14 | ### Technical Support 15 | Have a question? please open a [github issue](https://github.com/Mellanox/libvma/issues) or contact support@mellanox.com. 16 | 17 | ### Additional Information 18 | * Refer to the libvma [README](https://github.com/Mellanox/libvma/blob/master/README) 19 | * Messaging Accelerator [VMA](https://www.mellanox.com/products/software/accelerator-software/vma?mtag=vma) page 20 | * Check out the rest of the Wiki pages in this project 21 | -------------------------------------------------------------------------------- /autogen.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | set -e 4 | rm -rf autom4te.cache 5 | mkdir -p config 6 | autoreconf -v --install || exit 1 7 | rm -rf autom4te.cache 8 | 9 | exit 0 10 | 11 | -------------------------------------------------------------------------------- /config/m4/func.m4: -------------------------------------------------------------------------------- 1 | # 2 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | # Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | # 6 | # func.m4 - Collection of functions 7 | 8 | ########################## 9 | # Configure functions 10 | # 11 | # Some helper script functions 12 | # 13 | AC_DEFUN([FUNC_CONFIGURE_INIT], 14 | [ 15 | show_section_title() 16 | { 17 | cat < /dev/null`" = "x"], 50 | [AC_MSG_RESULT([not found]) 51 | AC_MSG_WARN([Expected file $2/$3 not found]) 52 | AC_MSG_ERROR([Cannot continue])], 53 | [AC_MSG_RESULT([($2)])] 54 | ) 55 | ] 56 | ) 57 | ] 58 | ) 59 | ]) 60 | -------------------------------------------------------------------------------- /config/m4/opt.m4: -------------------------------------------------------------------------------- 1 | # 2 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | # Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | # 6 | # opt.m4 - Macros to control optimization 7 | 8 | ########################## 9 | # Logging control 10 | # 11 | # VMA defined log levels 12 | # 13 | AC_DEFUN([OPT_VMA_LOGGING], 14 | [ 15 | AC_DEFINE(DEFINED_VLOG_INIT, -2, VMA Log Init Definition) 16 | AC_DEFINE(DEFINED_VLOG_NONE, -1, VMA Log None Definition) 17 | AC_DEFINE(DEFINED_VLOG_PANIC, 0, VMA Log Panic Definition) 18 | AC_DEFINE(DEFINED_VLOG_ERROR, 1, VMA Log Error Definition) 19 | AC_DEFINE(DEFINED_VLOG_WARNING, 2, VMA Log Warning Definition) 20 | AC_DEFINE(DEFINED_VLOG_INFO, 3, VMA Log Info Definition) 21 | AC_DEFINE(DEFINED_VLOG_DETAILS, 4, VMA Log Details Definition) 22 | AC_DEFINE(DEFINED_VLOG_DEBUG, 5, VMA Log Debug Definition) 23 | AC_DEFINE(DEFINED_VLOG_FINE, 6, VMA Log Fine Definition) 24 | AC_DEFINE(DEFINED_VLOG_FINER, 7, VMA Log Finer Definition) 25 | AC_DEFINE(DEFINED_VLOG_ALL, 8, VMA Log All Definition) 26 | 27 | AC_ARG_ENABLE([opt-log], 28 | AS_HELP_STRING([--enable-opt-log], 29 | [Optimize latency (none, medium, high) by limiting max log level (default=medium)]),, 30 | enableval=medium) 31 | AC_MSG_CHECKING([for logging optimization]) 32 | enable_opt_log=DEFINED_VLOG_ALL 33 | case "$enableval" in 34 | no | none) 35 | ;; 36 | yes | medium) 37 | enable_opt_log=DEFINED_VLOG_DEBUG 38 | ;; 39 | high) 40 | enable_opt_log=DEFINED_VLOG_DETAILS 41 | ;; 42 | *) 43 | AC_MSG_ERROR([Unrecognized --enable-opt-log parameter as $enableval]) 44 | ;; 45 | esac 46 | AC_DEFINE_UNQUOTED([VMA_MAX_DEFINED_LOG_LEVEL], [$enable_opt_log], [Log optimization level]) 47 | AC_MSG_RESULT([$enableval]) 48 | ]) 49 | -------------------------------------------------------------------------------- /contrib/jenkins_tests/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -eExl 2 | 3 | source $(dirname $0)/globals.sh 4 | 5 | echo "Checking for building with gcc ..." 6 | 7 | cd $WORKSPACE 8 | 9 | rm -rf ${build_dir} 10 | mkdir -p ${build_dir} 11 | cd ${build_dir} 12 | 13 | # Set symbolic links to default build and install 14 | ln -s "${build_dir}/0/install" "${install_dir}" 15 | 16 | build_list="\ 17 | default: \ 18 | debug:--enable-opt-log=no --enable-debug" 19 | 20 | 21 | build_tap=${WORKSPACE}/${prefix}/build.tap 22 | echo "1..$(echo $build_list | tr " " "\n" | wc -l)" > $build_tap 23 | 24 | test_id=0 25 | for build in $build_list; do 26 | IFS=':' read build_name build_option <<< "$build" 27 | mkdir -p ${build_dir}/${test_id} 28 | cd ${build_dir}/${test_id} 29 | test_exec='${WORKSPACE}/configure --prefix=${build_dir}/${test_id}/install $build_option $jenkins_test_custom_configure && make $make_opt install' 30 | do_check_result "$test_exec" "$test_id" "$build_name" "$build_tap" "${build_dir}/build-${test_id}" 31 | cd ${build_dir} 32 | test_id=$((test_id+1)) 33 | done 34 | 35 | 36 | echo "[${0##*/}]..................exit code = $rc" 37 | exit $rc 38 | -------------------------------------------------------------------------------- /contrib/jenkins_tests/commit.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -xeEl 2 | 3 | source $(dirname $0)/globals.sh 4 | 5 | echo "Checking for commit message ..." 6 | 7 | cd $WORKSPACE 8 | 9 | rm -rf $commit_dir 10 | mkdir -p $commit_dir 11 | cd $commit_dir 12 | 13 | commit_tap=${WORKSPACE}/${prefix}/commit_test.tap 14 | rm -rf $commit_tap 15 | out_log=${commit_dir}/output.log 16 | 17 | function current_head() 18 | { 19 | echo ${ghprbActualCommit:=HEAD} 20 | } 21 | 22 | function current_ancestor() 23 | { 24 | git merge-base origin/master HEAD 25 | } 26 | 27 | function current_commits() 28 | { 29 | git log --pretty=%H $(current_ancestor)..$(current_head) 30 | } 31 | 32 | function check_commit() 33 | { 34 | echo "1..$(echo $(current_commits) | tr " " "\n" | wc -l)" > $commit_tap 35 | nerrors=0 36 | test_id=1 37 | 38 | for sha in $(current_commits); do 39 | ret=0 40 | test_name=$(echo ${sha:0:7}) 41 | 42 | echo "#${test_id} commit: ${test_name}" >>${out_log} 2>&1 43 | 44 | commit_subject=$(git log --format=%B -n 1 "${sha}" | head -n2) 45 | commit_body=$(git log --format=%B -n 1 "${sha}" | awk '{if(NR>2)print}') 46 | 47 | if [ 0 -eq "${#commit_subject}" -o "${#commit_subject}" -gt 72 ]; then 48 | echo "Commit message subject should be less than 72 characters" >>${out_log} 2>&1 49 | ret=$((ret+1)) 50 | fi 51 | 52 | if [[ "${commit_subject}" == *. ]]; then 53 | echo "Commit message subject should not have period at the end" >>${out_log} 2>&1 54 | ret=$((ret+1)) 55 | fi 56 | 57 | if [ -z "$(echo ${commit_body} | grep 'Signed-off-by')" ]; then 58 | echo "Commit message body should have 'Signed-off-by'" >>${out_log} 2>&1 59 | ret=$((ret+1)) 60 | fi 61 | 62 | if [ $ret -eq 0 ]; then 63 | echo -e "ok ${test_name}" >> $commit_tap 64 | else 65 | echo -e "not ok ${test_name}: error ${ret} see ${out_log}" >> $commit_tap 66 | nerrors=$(($ret+$nerrors)) 67 | ret=0 68 | fi 69 | 70 | test_id=$((test_id+1)) 71 | done 72 | } 73 | 74 | check_commit 75 | 76 | do_archive "${out_log}" 77 | rc=$(($rc+$nerrors)) 78 | 79 | echo "[${0##*/}]..................exit code = $rc" 80 | exit $rc 81 | -------------------------------------------------------------------------------- /contrib/jenkins_tests/compiler.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -eExl 2 | 3 | source $(dirname $0)/globals.sh 4 | 5 | echo "Checking for compiler ..." 6 | 7 | cd $WORKSPACE 8 | 9 | rm -rf $compiler_dir 10 | mkdir -p $compiler_dir 11 | cd $compiler_dir 12 | 13 | compiler_list="clang:clang++:dev/clang-9.0.1 icc:icpc:intel/ics-18.0.4 icc:icpc:intel/ics-19.1.1 gcc:g++:dev/gcc-8.3.0 gcc:g++:dev/gcc-9.3.0 gcc:g++:dev/gcc-10.1.0" 14 | 15 | compiler_tap=${WORKSPACE}/${prefix}/compiler.tap 16 | echo "1..$(echo $compiler_list | tr " " "\n" | wc -l)" > $compiler_tap 17 | 18 | test_id=0 19 | for compiler in $compiler_list; do 20 | IFS=':' read cc cxx module <<< "$compiler" 21 | mkdir -p ${compiler_dir}/${test_id} 22 | cd ${compiler_dir}/${test_id} 23 | [ -z "$module" ] && test_name=$($cc --version | head -n 1) || test_name="$module" 24 | [ ! -z "$module" ] && do_module "$module" 25 | echo "======================================================" 26 | $cc --version 27 | echo 28 | test_exec='${WORKSPACE}/configure --prefix=$compiler_dir-$cc CC=$cc CXX=$cxx $jenkins_test_custom_configure && make $make_opt all' 29 | do_check_result "$test_exec" "$test_id" "$test_name" "$compiler_tap" "${compiler_dir}/compiler-${test_id}" 30 | [ ! -z "$module" ] && module unload "$module" 31 | cd ${compiler_dir} 32 | test_id=$((test_id+1)) 33 | done 34 | 35 | echo "[${0##*/}]..................exit code = $rc" 36 | exit $rc 37 | -------------------------------------------------------------------------------- /contrib/jenkins_tests/copyright-check-map.yaml: -------------------------------------------------------------------------------- 1 | general: 2 | exclude: 3 | - "\\.git.*" 4 | - "\\.ci.*" 5 | - "\\.dockers.*" 6 | - "build.*" 7 | - "contrib/jenkins_tests.*" 8 | - "contrib/valgrind.*" 9 | - "contrib/xlio-bench.*" 10 | - "contrib/.*\\.sh" 11 | - "debian.*" 12 | - ".*\\.pdf" 13 | - ".*Makefile\\.am" 14 | - ".*CHANGES" 15 | - ".*LICENSE" 16 | - ".*NOTICE" 17 | - ".*README" 18 | - ".*COPYING" 19 | - ".*TODO" 20 | - ".*license" 21 | - ".*\\.md" 22 | - ".*configure\\.ac" 23 | - ".*Jenkinsfile" 24 | - ".*\\.docx" 25 | - ".*\\.txt" 26 | - ".*\\.log" 27 | - ".*\\.cmake" 28 | - ".*\\.png" 29 | - ".*\\.conf" 30 | - ".*autogen\\.sh" 31 | # 32 | # Auto generated files 33 | # 34 | - ".*src/vma/config_parser.*" 35 | - ".*src/vma/config_scanner\\.c" 36 | 37 | dual_gpl_2_bsd_2_no_license: 38 | validate-spdx-license: True 39 | include: 40 | - ".*" 41 | exclude: 42 | - ".*src/vma/lwip/.*" 43 | - ".*tests/gtest/common/tap\\.h" 44 | - ".*tests/gtest/googletest/.*" 45 | - ".*src/vma/util/list\\.h" 46 | - ".*contrib/scripts/libvma\\.spec\\.in" 47 | - ".*contrib/scripts/vma\\.service\\.in" 48 | - ".*docs/man/.*\\.in" 49 | -------------------------------------------------------------------------------- /contrib/jenkins_tests/copyrights.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -xvEe -o pipefail 4 | 5 | source $(dirname $0)/globals.sh 6 | 7 | if [ -z "$WORKSPACE" ]; then 8 | echo "ERROR: WORKSPACE variable is empty" 9 | exit 1 10 | fi 11 | 12 | if [ ! -d "$WORKSPACE" ]; then 13 | echo "ERROR: $WORKSPACE does not exist" 14 | exit 1 15 | fi 16 | 17 | if [[ -z $GITHUB_TOKEN ]]; then 18 | echo "ERROR: GITHUB_TOKEN variable is empty" 19 | exit 1 20 | fi 21 | 22 | cpp_files=' "extensions": [".c", ".cc", ".cpp", "c++", ".h", ".hpp", ".cs", ".inl", ".l", ".y"],' 23 | sed -i "s/.*\"extensions\": \[\"\.c\".*/$cpp_files/g" /opt/nvidia/ProjectConfig/header-types.json 24 | 25 | cat /opt/nvidia/ProjectConfig/header-types.json 26 | 27 | /opt/nvidia/header_check.py \ 28 | --config ${WORKSPACE}/contrib/jenkins_tests/copyright-check-map.yaml \ 29 | --path ${WORKSPACE} \ 30 | --git-repo ${WORKSPACE} | tee copyrights.log 31 | exit_code=$? 32 | echo "exit_code=${exit_code}" 33 | # Correct error code is not returned by the script 34 | set +eE 35 | grep -rn ERROR copyrights.log 36 | exit_code=$? 37 | set -eE 38 | if [ ${exit_code} -eq 0 ]; then 39 | echo "Please refer to https://confluence.nvidia.com/pages/viewpage.action?pageId=788418816" 40 | /opt/nvidia/header_check.py \ 41 | --config contrib/jenkins_tests/copyright-check-map.yaml \ 42 | --path ${WORKSPACE} \ 43 | --repair \ 44 | --git-repo ${WORKSPACE} | tee copyrights_repair.log 45 | # create list of modified files 46 | files=$(git status | grep 'modified:' | awk '{print $NF}' ) 47 | mkdir $WORKSPACE/repaired_files/ 48 | cp --parents $files $WORKSPACE/repaired_files/ 49 | cd $WORKSPACE/repaired_files/ 50 | tar -czf $WORKSPACE/copyright_repaired_files.tar.gz . 51 | exit 1 52 | fi 53 | -------------------------------------------------------------------------------- /contrib/jenkins_tests/tool.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -eExl 2 | 3 | source $(dirname $0)/globals.sh 4 | 5 | echo "Checking for tool ..." 6 | 7 | # Check dependencies 8 | if [ $(test -d ${install_dir} >/dev/null 2>&1 || echo $?) ]; then 9 | echo "[SKIP] Not found ${install_dir} : build should be done before this stage" 10 | exit 1 11 | fi 12 | 13 | cd $WORKSPACE 14 | 15 | rm -rf $tool_dir 16 | mkdir -p $tool_dir 17 | cd $tool_dir 18 | 19 | tool_list="daemon" 20 | 21 | tool_tap=${WORKSPACE}/${prefix}/tool.tap 22 | echo "1..$(echo $tool_list | tr " " "\n" | wc -l)" > $tool_tap 23 | 24 | function check_daemon() 25 | { 26 | local ret=0 27 | local out_log=$1 28 | local service="vma" 29 | 30 | rm -rf ${out_log} 31 | eval "${sudo_cmd} pkill -9 ${prj_service} 2>/dev/null || true" 32 | 33 | if systemctl >/dev/null 2>&1; then 34 | service=${install_dir}/sbin/${prj_service} 35 | service_arg=${install_dir}/lib/systemd/system/vma.service 36 | 37 | echo "System has been booted with SystemD" >> ${out_log} 38 | echo "daemon check output: ${service}" >> ${out_log} 39 | 40 | if [ $(sudo systemd-analyze verify ${service_arg} >>${out_log} 2>&1 || echo $?) ]; then 41 | ret=1 42 | fi 43 | sleep 3 44 | if [ $(sudo ${service} >>${out_log} 2>&1 || echo $?) ]; then 45 | ret=1 46 | fi 47 | sleep 3 48 | if [ "0" == "$ret" -a "" == "$(pgrep ${prj_service})" ]; then 49 | ret=1 50 | fi 51 | sudo pkill -9 ${prj_service} >>${out_log} 2>&1 52 | sleep 3 53 | if [ "0" == "$ret" -a "" != "$(pgrep ${prj_service})" ]; then 54 | ret=1 55 | fi 56 | fi 57 | 58 | eval "${sudo_cmd} pkill -9 ${prj_service} 2>/dev/null || true" 59 | 60 | echo "$ret" 61 | } 62 | 63 | test_id=0 64 | for tool in $tool_list; do 65 | mkdir -p ${tool_dir}/${tool} 66 | cd ${tool_dir}/${tool} 67 | test_id=$((test_id+1)) 68 | test_exec="[ 0 = $(check_daemon "${tool_dir}/${tool}/output.log") ]" 69 | do_check_result "$test_exec" "$test_id" "$tool" "$tool_tap" "${tool_dir}/tool-${test_id}" 70 | do_archive "${tool_dir}/${tool}/output.log" 71 | cd ${tool_dir} 72 | done 73 | 74 | echo "[${0##*/}]..................exit code = $rc" 75 | exit $rc 76 | -------------------------------------------------------------------------------- /contrib/scripts/vma.service.in: -------------------------------------------------------------------------------- 1 | [Unit] 2 | Description=VMA Daemon 3 | After=network.target 4 | 5 | [Service] 6 | Type=forking 7 | Restart=on-failure 8 | ExecStart=@prefix@/sbin/vmad 9 | RestartForceExitStatus=1 SIGTERM 10 | 11 | [Install] 12 | WantedBy=multi-user.target 13 | -------------------------------------------------------------------------------- /debian/changelog.in: -------------------------------------------------------------------------------- 1 | libvma (@VERSION@-@PRJ_LIBRARY_RELEASE@) release; urgency=low 2 | 3 | * Please refer to CHANGES for full changelog. 4 | 5 | -- NVIDIA CORPORATION @BUILD_DATE_CHANGELOG@ 6 | -------------------------------------------------------------------------------- /debian/compat: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /debian/libvma-dev.install: -------------------------------------------------------------------------------- 1 | usr/include/mellanox/vma_extra.h 2 | libvma-debug.so usr/lib 3 | -------------------------------------------------------------------------------- /debian/libvma-utils.install: -------------------------------------------------------------------------------- 1 | usr/bin/vma_stats 2 | usr/share/man/man8/vma_stats.* 3 | -------------------------------------------------------------------------------- /debian/libvma.install: -------------------------------------------------------------------------------- 1 | usr/lib/libvma*.so.* 2 | usr/lib/libvma.so 3 | usr/share/doc/libvma/README 4 | usr/share/doc/libvma/CHANGES 5 | usr/sbin/ 6 | etc/libvma.conf 7 | etc/ 8 | contrib/scripts/vma.service lib/systemd/system 9 | usr/share/man/man7/vma.* 10 | usr/share/man/man8/vmad.* 11 | -------------------------------------------------------------------------------- /debian/postinst: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | /sbin/ldconfig 4 | 5 | if command -v systemctl >/dev/null 2>&1; then 6 | systemctl --no-reload enable vma.service >/dev/null 2>&1 || true 7 | fi 8 | -------------------------------------------------------------------------------- /debian/postrm: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | /sbin/ldconfig 3 | if command -v systemctl >/dev/null 2>&1; then 4 | systemctl --system daemon-reload >/dev/null 2>&1 || true 5 | fi 6 | -------------------------------------------------------------------------------- /debian/prerm: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if command -v systemctl >/dev/null 2>&1; then 4 | systemctl --no-reload disable vma.service >/dev/null 2>&1 || true 5 | systemctl stop vma.service || true 6 | fi 7 | -------------------------------------------------------------------------------- /debian/rules: -------------------------------------------------------------------------------- 1 | #!/usr/bin/make -f 2 | # -*- mode: makefile; coding: utf-8 -*- 3 | 4 | #export DH_VERBOSE=1 5 | 6 | %: 7 | dh $@ 8 | 9 | build: build-debug 10 | @echo "Using extra configuration options: ${configure_options}" 11 | ./configure --with-ofed=/usr --prefix=/usr \ 12 | --libdir=/usr/lib --includedir=/usr/include --sysconfdir=/etc \ 13 | ${configure_options} 14 | 15 | build-debug: 16 | ./configure --with-ofed=/usr --prefix=/usr \ 17 | --libdir=/usr/lib --includedir=/usr/include --sysconfdir=/etc \ 18 | --enable-opt-log=none --enable-debug ${configure_options} 19 | make 20 | cp -f src/vma/.libs/libvma.so libvma-debug.so 21 | make clean 22 | 23 | 24 | # Commands not to run 25 | override_dh_auto_configure: 26 | 27 | # Workaround for missing dependency information in libmongoclient package 28 | override_dh_shlibdeps: 29 | dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info 30 | -------------------------------------------------------------------------------- /debian/watch: -------------------------------------------------------------------------------- 1 | # Compulsory line, this is a version 4 file 2 | version=4 3 | 4 | # GitHub hosted projects 5 | opts="filenamemangle=s%(?:.*?)?v?(\d[\d.]*)\.tar\.gz%libvma-$1.tar.gz%" \ 6 | https://github.com/mellanox/libvma/tags \ 7 | (?:.*?/)?v?(\d[\d.]*)\.tar\.gz debian uupdate 8 | -------------------------------------------------------------------------------- /docs/man/Makefile.am: -------------------------------------------------------------------------------- 1 | vma_man_pages = \ 2 | vma.7 \ 3 | vmad.8 \ 4 | vma_stats.8 5 | 6 | man_MANS = $(vma_man_pages) 7 | CLEANFILES = $(vma_man_pages) 8 | EXTRA_DIST = \ 9 | $(vma_man_pages:.7=.7.in) \ 10 | $(vma_man_pages:.8=.8.in) 11 | 12 | %.7: %.7.in 13 | @cp $< $@ 14 | @sed -i 's/#BUILD_DATE#/@BUILD_DATE@/g' $@ 15 | @sed -i 's/#VMA_LIBRARY_MAJOR#/@VMA_LIBRARY_MAJOR@/g' $@ 16 | @sed -i 's/#VMA_LIBRARY_MINOR#/@VMA_LIBRARY_MINOR@/g' $@ 17 | @sed -i 's/#VMA_LIBRARY_REVISION#/@VMA_LIBRARY_REVISION@/g' $@ 18 | 19 | %.8: %.8.in 20 | @cp $< $@ 21 | @sed -i 's/#BUILD_DATE#/@BUILD_DATE@/g' $@ 22 | @sed -i 's/#VMA_LIBRARY_MAJOR#/@VMA_LIBRARY_MAJOR@/g' $@ 23 | @sed -i 's/#VMA_LIBRARY_MINOR#/@VMA_LIBRARY_MINOR@/g' $@ 24 | @sed -i 's/#VMA_LIBRARY_REVISION#/@VMA_LIBRARY_REVISION@/g' $@ 25 | -------------------------------------------------------------------------------- /docs/man/vma.7.in: -------------------------------------------------------------------------------- 1 | .\" -*- groff -*- 2 | .\" 3 | .TH VMA 7 "#BUILD_DATE#" libvma "VMA(#VMA_LIBRARY_MAJOR#.#VMA_LIBRARY_MINOR#.#VMA_LIBRARY_REVISION#) User's Manual" 4 | .SH NAME 5 | VMA \- NVIDIA Messaging Accelerator (VMA) library. 6 | 7 | .SH SYNOPSIS 8 | .B libvma.so 9 | 10 | .SH DESCRIPTION 11 | .B VMA 12 | NVIDIA Messaging Accelerator (VMA) boosts performance for message-based 13 | and streaming applications such as those found in financial services market 14 | data environments and Web2.0 clusters. It allows application written over 15 | standard socket API to run over Ethernet and/or Infiniband from user-space 16 | with full network stack bypass. The result is a reduction in latency by as 17 | much as 300%, an increase in application throughput by as much as 200%, higher 18 | packets rates and better CPU utilization as compared to applications running 19 | on standard Ethernet or InfiniBand interconnect networks. 20 | 21 | .SH FILES 22 | .I /etc/libvma.conf 23 | .RS 24 | The system wide configuration file. Look inside libvma.conf for instructions 25 | and examples. 26 | .RE 27 | .I /usr/share/doc/libvma/README.txt 28 | .RS 29 | General VMA Library description. 30 | .RE 31 | .I /usr/share/doc/libvma/VMA_VERSION 32 | .RS 33 | VMA Library version information. 34 | .RE 35 | 36 | .SH SEE ALSO 37 | .BR vmad (8), 38 | .BR vma_stats (8) 39 | 40 | .SH "AUTHORS" 41 | .TP 42 | NVIDIA CORPORATION 43 | -------------------------------------------------------------------------------- /docs/man/vmad.8.in: -------------------------------------------------------------------------------- 1 | .\" -*- groff -*- 2 | .\" 3 | .TH VMA 8 "#BUILD_DATE#" libvma "VMA(#VMA_LIBRARY_MAJOR#.#VMA_LIBRARY_MINOR#.#VMA_LIBRARY_REVISION#) User's Manual" 4 | .SH NAME 5 | vmad \- NVIDIA Messaging Accelerator (VMA) daemon. 6 | 7 | .SH SYNOPSIS 8 | .B vmad 9 | [\-\-console] [\-\-pid,-p \fInum\fP] [\-\-fid,-f \fInum\fP] 10 | [\-\-force-rst] [\-\-verbose,\-v \fIlevel\fP] 11 | 12 | .SH DESCRIPTION 13 | vmad is the daemon program for vma (7). 14 | 15 | vmad can be configured using command-line options 16 | 17 | The options are as follows: 18 | .sp 19 | \fB\-\-console\fP 20 | Enable foreground mode. 21 | .TP 22 | \fB\-\-pid,\-p \fP\fInum\fP 23 | Set prime number as maximum of processes per node. 24 | .TP 25 | \fB\-\-fid,\-f \fP\fInum\fP 26 | Set prime number as maximum of sockets per process. 27 | .TP 28 | \fB\-\-force\-rst\fP 29 | Force internal RST. 30 | .TP 31 | \fB\-\-verbose,\-v \fP\fIlevel\fP 32 | Output verbose level 33 | .TP 34 | 35 | .SH SEE ALSO 36 | .BR vma (7), 37 | .BR vma_stats (8) 38 | 39 | .SH "AUTHORS" 40 | .TP 41 | NVIDIA CORPORATION 42 | -------------------------------------------------------------------------------- /src/Makefile.am: -------------------------------------------------------------------------------- 1 | SUBDIRS := utils vlogger state_machine stats vma 2 | -------------------------------------------------------------------------------- /src/state_machine/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS := -I$(top_srcdir)/src 2 | 3 | noinst_LTLIBRARIES = libstate_machine.la 4 | libstate_machine_la_LDFLAGS = -static 5 | libstate_machine_la_SOURCES = \ 6 | sm_fifo.cpp \ 7 | sm.cpp \ 8 | sm_fifo.h \ 9 | sm.h 10 | 11 | 12 | noinst_PROGRAMS = state_machine_test 13 | state_machine_test_LDADD = \ 14 | libstate_machine.la \ 15 | $(top_builddir)/src/utils/libutils.la \ 16 | $(top_builddir)/src/vlogger/libvlogger.la 17 | 18 | state_machine_test_SOURCES = main.cpp 19 | 20 | state_machine_test_DEPENDENCIES = \ 21 | libstate_machine.la \ 22 | $(top_builddir)/src/utils/libutils.la \ 23 | $(top_builddir)/src/vlogger/libvlogger.la 24 | -------------------------------------------------------------------------------- /src/state_machine/sm_fifo.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "sm_fifo.h" 9 | 10 | bool sm_fifo::is_empty() 11 | { 12 | return m_sm_event_fifo.empty(); 13 | } 14 | 15 | void sm_fifo::push_back(int element, void* ev_data) 16 | { 17 | sm_fifo_entry_t fe; 18 | fe.ev_data = ev_data; 19 | fe.event = element; 20 | m_sm_event_fifo.push_back(fe); 21 | } 22 | 23 | // Return the first element in the fifo. 24 | // in case the fifo is empty: ret.event = -1 25 | sm_fifo_entry_t sm_fifo::pop_front() 26 | { 27 | sm_fifo_entry_t ret; 28 | ret.event = -1; 29 | ret.ev_data = NULL; 30 | if (!m_sm_event_fifo.empty()) { 31 | ret = m_sm_event_fifo.front(); 32 | m_sm_event_fifo.pop_front(); 33 | } 34 | return ret; 35 | } 36 | 37 | //code coverage 38 | #if 0 39 | void sm_fifo::debug_print_fifo() 40 | { 41 | int i = 1; 42 | sm_event_list_t::iterator tmp = m_sm_event_fifo.begin(); 43 | for (sm_event_list_t::iterator tmp = m_sm_event_fifo.begin(); tmp != m_sm_event_fifo.end(); tmp++) { 44 | printf("element num %d is %d\n",i , tmp->event); 45 | i++; 46 | } 47 | } 48 | #endif 49 | 50 | -------------------------------------------------------------------------------- /src/state_machine/sm_fifo.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef V_SM_FIFO_H 9 | #define V_SM_FIFO_H 10 | 11 | #include 12 | #include 13 | 14 | typedef struct { 15 | int event; 16 | void* ev_data; 17 | } sm_fifo_entry_t; 18 | 19 | typedef std::deque sm_event_list_t; 20 | 21 | 22 | class sm_fifo 23 | { 24 | public: 25 | bool is_empty(); 26 | void push_back(int element, void* ev_data); 27 | sm_fifo_entry_t pop_front(); 28 | void debug_print_fifo(); 29 | 30 | private: 31 | sm_event_list_t m_sm_event_fifo; 32 | }; 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/stats/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS := -I$(top_srcdir)/src ${LIBNL_CFLAGS} 2 | 3 | noinst_LTLIBRARIES = libstats.la 4 | libstats_la_LDFLAGS = -static 5 | libstats_la_SOURCES = \ 6 | stats_printer.cpp \ 7 | stats_publisher.cpp \ 8 | stats_data_reader.h 9 | 10 | bin_PROGRAMS = vma_stats 11 | vma_stats_LDADD= -lrt \ 12 | libstats.la \ 13 | $(top_builddir)/src/utils/libutils.la \ 14 | $(top_builddir)/src/vlogger/libvlogger.la 15 | vma_stats_SOURCES = stats_reader.cpp 16 | vma_stats_DEPENDENCIES = \ 17 | libstats.la \ 18 | $(top_builddir)/src/vlogger/libvlogger.la 19 | -------------------------------------------------------------------------------- /src/stats/stats_data_reader.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef STATS_DATA_READER_H 9 | #define STATS_DATA_READER_H 10 | 11 | #include 12 | #include "utils/lock_wrapper.h" 13 | #include "vma/event/timer_handler.h" 14 | 15 | typedef std::map< void*, std::pair > stats_read_map_t; 16 | 17 | typedef struct { 18 | int size; 19 | void* shm_addr; 20 | } data_addr_and_size_t; 21 | 22 | class stats_data_reader : public timer_handler 23 | { 24 | public: 25 | stats_data_reader(); 26 | void handle_timer_expired(void *ctx); 27 | void register_to_timer(); 28 | void add_data_reader(void* local_addr, void* shm_addr, int size); 29 | void* pop_data_reader(void* local_addr); 30 | 31 | private: 32 | void* m_timer_handler; 33 | stats_read_map_t m_data_map; 34 | lock_spin m_lock_data_map; 35 | }; 36 | 37 | #endif //STATS_DATA_READER_H 38 | -------------------------------------------------------------------------------- /src/utils/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS := -I$(top_srcdir)/src 2 | 3 | noinst_LTLIBRARIES = libutils.la 4 | libutils_la_LDFLAGS = -static 5 | libutils_la_LIBADD = -lrt 6 | libutils_la_SOURCES = \ 7 | asm-arm64.h \ 8 | asm-ppc64.h \ 9 | asm-x86.h \ 10 | asm.h \ 11 | atomic.h \ 12 | bullseye.h \ 13 | clock.h \ 14 | lock_wrapper.h \ 15 | rdtsc.h \ 16 | types.h \ 17 | compiler.h 18 | -------------------------------------------------------------------------------- /src/utils/asm-arm64.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2014-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef ASMARM64_H_ 9 | #define ASMARM64_H_ 10 | 11 | #include 12 | #include 13 | 14 | #define COPY_64B_NT(dst, src) \ 15 | *dst++ = *src++; \ 16 | *dst++ = *src++; \ 17 | *dst++ = *src++; \ 18 | *dst++ = *src++; \ 19 | *dst++ = *src++; \ 20 | *dst++ = *src++; \ 21 | *dst++ = *src++; \ 22 | *dst++ = *src++ 23 | 24 | #define mb() asm volatile("dsb sy" ::: "memory") 25 | #define rmb() asm volatile("dsb ld" ::: "memory") 26 | #define wmb() asm volatile("dsb st" ::: "memory") 27 | #define wc_wmb() wmb() 28 | 29 | /** 30 | * Add to the atomic variable. 31 | * @param i integer value to add. 32 | * @param v pointer of type atomic_t. 33 | * @return Value before add. 34 | */ 35 | static inline int atomic_fetch_and_add(int i, volatile int *ptr) 36 | { 37 | return __atomic_fetch_add(ptr, i, __ATOMIC_ACQUIRE); 38 | } 39 | 40 | /** 41 | * Read RDTSC register 42 | */ 43 | static inline void gettimeoftsc(unsigned long long *p_tscval) 44 | { 45 | // Read Time Stamp Counter 46 | asm volatile("isb" : : : "memory"); 47 | asm volatile("mrs %0, cntvct_el0" : "=r" ((unsigned long long)*p_tscval)); 48 | } 49 | 50 | /** 51 | * Cache Line Prefetch - Arch specific! 52 | */ 53 | #ifndef L1_CACHE_BYTES 54 | #define L1_CACHE_BYTES 64 55 | #endif 56 | 57 | static inline void prefetch(void *x) 58 | { 59 | //__builtin_prefetch(); 60 | asm volatile("prfm pldl1keep, %a0\n" : : "p" (x)); 61 | } 62 | 63 | static inline void prefetch_range(void *addr, size_t len) 64 | { 65 | char *cp = (char*)addr; 66 | char *end = (char*)addr + len; 67 | for (; cp < end; cp += L1_CACHE_BYTES) 68 | prefetch(cp); 69 | } 70 | 71 | 72 | 73 | #endif 74 | -------------------------------------------------------------------------------- /src/utils/asm-ppc64.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2014-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef ASMPPC64_H_ 9 | #define ASMPPC64_H_ 10 | 11 | #include 12 | #include 13 | 14 | #define COPY_64B_NT(dst, src) \ 15 | *dst++ = *src++; \ 16 | *dst++ = *src++; \ 17 | *dst++ = *src++; \ 18 | *dst++ = *src++; \ 19 | *dst++ = *src++; \ 20 | *dst++ = *src++; \ 21 | *dst++ = *src++; \ 22 | *dst++ = *src++ 23 | 24 | #define mb() asm volatile("sync" ::: "memory") 25 | #define rmb() asm volatile("lwsync" ::: "memory") 26 | #define wmb() rmb() 27 | #define wc_wmb() mb() 28 | 29 | /** 30 | * Add to the atomic variable. 31 | * @param i integer value to add. 32 | * @param v pointer of type atomic_t. 33 | * @return Value before add. 34 | */ 35 | static inline int atomic_fetch_and_add(int i, volatile int *ptr) 36 | { 37 | #ifdef __ATOMIC_ACQUIRE 38 | return __atomic_fetch_add(ptr, i, __ATOMIC_ACQUIRE); 39 | #else 40 | return __sync_fetch_and_add(ptr, i); 41 | #endif 42 | } 43 | 44 | 45 | /** 46 | * Read RDTSC register 47 | */ 48 | static inline void gettimeoftsc(unsigned long long *p_tscval) 49 | { 50 | asm volatile ("mftb %0" : "=r" (*p_tscval) : ); 51 | } 52 | 53 | /** 54 | * Cache Line Prefetch - Arch specific! 55 | */ 56 | #ifndef L1_CACHE_BYTES 57 | #define L1_CACHE_BYTES 128 58 | #endif 59 | 60 | static inline void prefetch(void *x) 61 | { 62 | //__builtin_prefetch(); 63 | __asm__ __volatile__ ("dcbt 0,%0,1" : : "r" (x)); 64 | } 65 | 66 | static inline void prefetch_range(void *addr, size_t len) 67 | { 68 | char *cp = (char*)addr; 69 | char *end = (char*)addr + len; 70 | for (; cp < end; cp += L1_CACHE_BYTES) 71 | prefetch(cp); 72 | } 73 | 74 | 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /src/utils/asm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef ASM_H_ 9 | #define ASM_H_ 10 | 11 | #if defined(__aarch64__) 12 | #include "asm-arm64.h" 13 | #elif defined(__powerpc64__) 14 | #include "asm-ppc64.h" 15 | #elif defined(__x86_64__) 16 | #include "asm-x86.h" 17 | #else 18 | #error No architecture specific memory barrier definitions found! 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /src/utils/bullseye.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | /* 9 | * Bullseye Coverage Definitions 10 | */ 11 | #ifndef BULLSEYE_H_ 12 | #define BULLSEYE_H_ 13 | 14 | #ifndef _BullseyeCoverage 15 | #define _BullseyeCoverage 0 16 | #endif 17 | 18 | #if _BullseyeCoverage 19 | #define BULLSEYE_EXCLUDE_BLOCK_START "BullseyeCoverage save off"; 20 | #define BULLSEYE_EXCLUDE_BLOCK_END "BullseyeCoverage restore"; 21 | #else 22 | #define BULLSEYE_EXCLUDE_BLOCK_START 23 | #define BULLSEYE_EXCLUDE_BLOCK_END 24 | #endif 25 | 26 | 27 | #endif /* BULLSEYE_H_ */ 28 | -------------------------------------------------------------------------------- /src/utils/compiler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef SRC_UTILS_COMPILER_H_ 9 | #define SRC_UTILS_COMPILER_H_ 10 | 11 | /** 12 | * Macro for marking functions as having public visibility. 13 | */ 14 | #if defined(DEFINED_EXPORT_SYMBOL) 15 | #define EXPORT_SYMBOL __attribute__((__visibility__("default"))) 16 | #else 17 | #define EXPORT_SYMBOL 18 | #endif 19 | 20 | #endif /* SRC_UTILS_COMPILER_H_ */ 21 | 22 | -------------------------------------------------------------------------------- /src/utils/types.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef TYPES_H 9 | #define TYPES_H 10 | 11 | #include 12 | 13 | #ifndef IN 14 | #define IN 15 | #endif 16 | 17 | #ifndef OUT 18 | #define OUT 19 | #endif 20 | 21 | #ifndef INOUT 22 | #define INOUT 23 | #endif 24 | 25 | #ifndef likely 26 | #define likely(x) __builtin_expect(!!(x), 1) 27 | #endif 28 | 29 | #ifndef unlikely 30 | #define unlikely(x) __builtin_expect(!!(x), 0) 31 | #endif 32 | 33 | #ifndef NOT_IN_USE 34 | #define NOT_IN_USE(a) ((void)(a)) 35 | #endif 36 | 37 | #endif //TYPES_H 38 | -------------------------------------------------------------------------------- /src/vlogger/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CPPFLAGS := -I$(top_srcdir)/src 2 | 3 | noinst_LTLIBRARIES = libvlogger.la 4 | libvlogger_la_LDFLAGS = -static 5 | libvlogger_la_LIBADD = -lrt 6 | libvlogger_la_SOURCES = vlogger.cpp vlogger.h 7 | 8 | noinst_PROGRAMS = vlogger_test 9 | vlogger_test_LDADD = \ 10 | $(top_builddir)/src/utils/libutils.la \ 11 | libvlogger.la 12 | vlogger_test_SOURCES = main.cpp 13 | -------------------------------------------------------------------------------- /src/vlogger/main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include 9 | 10 | #include "vlogger.h" 11 | 12 | #if _BullseyeCoverage 13 | #pragma BullseyeCoverage off 14 | #endif 15 | 16 | int main(int argc, char **argv) 17 | { 18 | vlog_levels_t vlog_levels_init = VLOG_WARNING; 19 | if (argc > 1) 20 | vlog_levels_init = (vlog_levels_t)atoi(argv[1]); 21 | 22 | printf(">> starting vlogger in level: %d\n", (int)vlog_levels_init); 23 | vlog_start("Voltaire Logger test module: ", vlog_levels_init); 24 | 25 | vlog_printf(VLOG_PANIC, "%s: test log_print in level VLOG_PANIC\n", __func__); 26 | vlog_printf(VLOG_ERROR, "%s: test log_print in level VLOG_ERROR\n", __func__); 27 | vlog_printf(VLOG_WARNING, "%s: test log_print in level VLOG_WARNING\n", __func__); 28 | vlog_printf(VLOG_INFO, "%s: test log_print in level VLOG_INFO\n", __func__); 29 | vlog_printf(VLOG_DEBUG, "%s: test log_print in level VLOG_DEBUG\n", __func__); 30 | vlog_printf(VLOG_FUNC, "%s: test log_print in level VLOG_FUNC\n", __func__); 31 | vlog_printf(VLOG_FUNC_ALL, "%s: test log_print in level VLOG_FUNC_ALL\n", __func__); 32 | 33 | usleep(10000); 34 | 35 | vlog_stop(); 36 | 37 | return 0; 38 | } 39 | 40 | #if _BullseyeCoverage 41 | #pragma BullseyeCoverage on 42 | #endif 43 | -------------------------------------------------------------------------------- /src/vma/dev/allocator.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef SRC_VMA_DEV_ALLOCATOR_H_ 8 | #define SRC_VMA_DEV_ALLOCATOR_H_ 9 | 10 | #include "vlogger/vlogger.h" 11 | #include "ib_ctx_handler_collection.h" 12 | 13 | 14 | class ib_ctx_handler; 15 | typedef std::unordered_map lkey_map_ib_ctx_map_t; 16 | 17 | class vma_allocator { 18 | public: 19 | vma_allocator(); 20 | vma_allocator(alloc_t alloc_func, free_t free_func); 21 | ~vma_allocator(); 22 | void* alloc_and_reg_mr(size_t size, ib_ctx_handler *p_ib_ctx_h, void *ptr = NULL); 23 | uint32_t find_lkey_by_ib_ctx(ib_ctx_handler *p_ib_ctx_h) const; 24 | void register_memory(size_t size, ib_ctx_handler *p_ib_ctx_h, uint64_t access); 25 | void deregister_memory(); 26 | private: 27 | void align_simple_malloc(size_t sz_bytes); 28 | bool hugetlb_alloc(size_t sz_bytes); 29 | bool hugetlb_mmap_alloc(); 30 | bool hugetlb_sysv_alloc(); 31 | lkey_map_ib_ctx_map_t m_lkey_map_ib_ctx; 32 | int m_shmid; 33 | size_t m_length; 34 | void *m_data_block; 35 | alloc_mode_t m_mem_alloc_type; 36 | alloc_t m_memalloc; 37 | free_t m_memfree; 38 | }; 39 | 40 | #endif /* SRC_VMA_DEV_ALLOCATOR_H_ */ 41 | -------------------------------------------------------------------------------- /src/vma/dev/cq_mgr_mlx5.inl: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef CQ_MGR_MLX5_INL_H 9 | #define CQ_MGR_MLX5_INL_H 10 | 11 | #include "dev/cq_mgr_mlx5.h" 12 | 13 | #if defined(DEFINED_DIRECT_VERBS) 14 | 15 | /**/ 16 | /** inlining functions can only help if they are implemented before their usage **/ 17 | /**/ 18 | inline struct mlx5_cqe64* cq_mgr_mlx5::check_cqe(void) 19 | { 20 | struct mlx5_cqe64* cqe = (struct mlx5_cqe64 *)(((uint8_t *)m_mlx5_cq.cq_buf) + 21 | ((m_mlx5_cq.cq_ci & (m_mlx5_cq.cqe_count - 1)) << m_mlx5_cq.cqe_size_log)); 22 | /* 23 | * CQE ownership is defined by Owner bit in the CQE. 24 | * The value indicating SW ownership is flipped every 25 | * time CQ wraps around. 26 | * */ 27 | if (likely((MLX5_CQE_OPCODE(cqe->op_own)) != MLX5_CQE_INVALID) && 28 | !((MLX5_CQE_OWNER(cqe->op_own)) ^ !!(m_mlx5_cq.cq_ci & m_mlx5_cq.cqe_count))) { 29 | return cqe; 30 | } 31 | 32 | return NULL; 33 | } 34 | 35 | #endif /* DEFINED_DIRECT_VERBS */ 36 | #endif//CQ_MGR_MLX5_INL_H 37 | -------------------------------------------------------------------------------- /src/vma/dev/dm_mgr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef DM_MGR_H 8 | #define DM_MGR_H 9 | 10 | #include "vma/ib/base/verbs_extra.h" 11 | #include "vma/util/vma_stats.h" 12 | 13 | class mem_buf_desc_t; 14 | class ib_ctx_handler; 15 | 16 | #if defined(DEFINED_DIRECT_VERBS) 17 | #if defined(DEFINED_IBV_DM) 18 | 19 | #define DM_COMPLETION_THRESHOLD 8192 20 | 21 | class dm_mgr { 22 | public: 23 | 24 | dm_mgr(); 25 | bool allocate_resources(ib_ctx_handler* ib_ctx, ring_stats_t* ring_stats); 26 | void release_resources(); 27 | bool copy_data(struct mlx5_wqe_data_seg* seg, uint8_t* src, uint32_t length, mem_buf_desc_t* buff); 28 | void release_data(mem_buf_desc_t* buff); 29 | inline bool is_completion_need() { return m_allocation - m_used < DM_COMPLETION_THRESHOLD; }; 30 | 31 | private: 32 | 33 | struct ibv_mr *m_p_dm_mr; 34 | vma_ibv_dm *m_p_ibv_dm; 35 | ring_stats_t *m_p_ring_stat; 36 | size_t m_allocation; // Size of device memory buffer (bytes) 37 | size_t m_used; // Next available index inside the buffer 38 | size_t m_head; // Device memory used bytes 39 | }; 40 | 41 | #else 42 | 43 | /* cppcheck-suppress ctuOneDefinitionRuleViolation */ 44 | class dm_mgr { 45 | public: 46 | inline bool allocate_resources(ib_ctx_handler* ib_ctx, ring_stats_t* ring_stats) { NOT_IN_USE(ib_ctx); NOT_IN_USE(ring_stats); return false; }; 47 | inline void release_resources() {}; 48 | inline bool copy_data(struct mlx5_wqe_data_seg* seg, uint8_t* src, uint32_t length, mem_buf_desc_t* buff) { NOT_IN_USE(seg); NOT_IN_USE(src); NOT_IN_USE(length); NOT_IN_USE(buff); return false; }; 49 | inline void release_data(mem_buf_desc_t* buff) { NOT_IN_USE(buff); }; 50 | inline bool is_completion_need() { return false; }; 51 | }; 52 | 53 | #endif /* DEFINED_IBV_DM */ 54 | #endif /* DEFINED_DIRECT_VERBS */ 55 | #endif /* DM_MGR_H */ 56 | -------------------------------------------------------------------------------- /src/vma/dev/gro_mgr.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "vma/dev/gro_mgr.h" 8 | #include "vma/dev/rfs_uc_tcp_gro.h" 9 | 10 | #define MODULE_NAME "gro_mgr" 11 | 12 | gro_mgr::gro_mgr(uint32_t flow_max, uint32_t buf_max) : m_n_flow_max(flow_max), m_n_buf_max(buf_max), m_n_flow_count(0) 13 | { 14 | m_p_rfs_arr = new rfs_uc_tcp_gro*[flow_max]; 15 | BULLSEYE_EXCLUDE_BLOCK_START 16 | if (!m_p_rfs_arr) { 17 | __log_panic("could not allocate memory"); 18 | } 19 | BULLSEYE_EXCLUDE_BLOCK_END 20 | } 21 | 22 | gro_mgr::~gro_mgr() 23 | { 24 | delete [] m_p_rfs_arr; 25 | } 26 | 27 | bool gro_mgr::reserve_stream(rfs_uc_tcp_gro* rfs_uc_tcp_gro) 28 | { 29 | if (is_stream_max()) return false; 30 | 31 | m_p_rfs_arr[m_n_flow_count] = rfs_uc_tcp_gro; 32 | m_n_flow_count++; 33 | return true; 34 | } 35 | 36 | bool gro_mgr::is_stream_max() 37 | { 38 | return (m_n_flow_count >= m_n_flow_max); 39 | } 40 | 41 | 42 | 43 | void gro_mgr::flush_all(void* pv_fd_ready_array) 44 | { 45 | for (uint32_t i = 0; i < m_n_flow_count; i++) { 46 | m_p_rfs_arr[i]->flush(pv_fd_ready_array); 47 | } 48 | m_n_flow_count = 0; 49 | } 50 | -------------------------------------------------------------------------------- /src/vma/dev/gro_mgr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef GRO_MGR_H_ 8 | #define GRO_MGR_H_ 9 | 10 | #include 11 | 12 | #define MAX_AGGR_BYTE_PER_STREAM 0xFFFF 13 | #define MAX_GRO_BUFS 32 14 | 15 | class rfs_uc_tcp_gro; 16 | 17 | class gro_mgr 18 | { 19 | public: 20 | gro_mgr(uint32_t flow_max, uint32_t buf_max); 21 | bool reserve_stream(rfs_uc_tcp_gro* rfs_uc_tcp_gro); 22 | bool is_stream_max(); 23 | inline uint32_t get_buf_max() { return m_n_buf_max;} 24 | inline uint32_t get_byte_max() { return MAX_AGGR_BYTE_PER_STREAM;} 25 | void flush_all(void* pv_fd_ready_array); 26 | virtual ~gro_mgr(); 27 | 28 | private: 29 | const uint32_t m_n_flow_max; 30 | const uint32_t m_n_buf_max; 31 | 32 | uint32_t m_n_flow_count; 33 | 34 | rfs_uc_tcp_gro** m_p_rfs_arr; 35 | }; 36 | 37 | #endif /* GRO_MGR_H_ */ 38 | -------------------------------------------------------------------------------- /src/vma/dev/ib_ctx_handler_collection.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef IB_CTX_HANDLER_COLLECTION_H 9 | #define IB_CTX_HANDLER_COLLECTION_H 10 | 11 | #include 12 | 13 | #include "vma/ib/base/verbs_extra.h" 14 | #include "ib_ctx_handler.h" 15 | 16 | typedef std::unordered_map ib_context_map_t; 17 | 18 | class ib_ctx_handler_collection 19 | { 20 | public: 21 | ib_ctx_handler_collection(); 22 | ~ib_ctx_handler_collection(); 23 | 24 | void update_tbl(const char *ifa_name = NULL); 25 | void print_val_tbl(); 26 | 27 | inline ib_context_map_t* get_ib_cxt_list() { 28 | return (m_ib_ctx_map.size() ? &m_ib_ctx_map : NULL); 29 | } 30 | ib_ctx_handler* get_ib_ctx(const char *ifa_name); 31 | void del_ib_ctx(ib_ctx_handler* ib_ctx); 32 | 33 | private: 34 | ib_context_map_t m_ib_ctx_map; 35 | }; 36 | 37 | extern ib_ctx_handler_collection* g_p_ib_ctx_handler_collection; 38 | 39 | #endif 40 | -------------------------------------------------------------------------------- /src/vma/dev/net_device_entry.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef NET_DEVICE_ENTRY_H 9 | #define NET_DEVICE_ENTRY_H 10 | 11 | #include "net_device_val.h" 12 | #include "vma/infra/cache_subject_observer.h" 13 | #include "vma/proto/ip_address.h" 14 | #include "vma/event/timer_handler.h" 15 | 16 | #define MAX_CMA_ID_BIND_TRIAL_COUNT 10 17 | #define CMA_ID_BIND_TIMER_PERIOD_MSEC 100 18 | 19 | class net_device_entry : public cache_entry_subject , public event_handler_ibverbs, public timer_handler 20 | { 21 | public: 22 | friend class net_device_table_mgr; 23 | 24 | net_device_entry(in_addr_t local_ip, net_device_val* ndv); 25 | virtual ~net_device_entry(); 26 | 27 | bool get_val(INOUT net_device_val* &val); 28 | bool is_valid() { return m_is_valid; }; // m_val is NULL at first 29 | 30 | virtual void handle_event_ibverbs_cb(void *ev_data, void *ctx); 31 | 32 | void handle_timer_expired(void* user_data); 33 | 34 | private: 35 | 36 | bool m_is_valid; 37 | size_t m_cma_id_bind_trial_count; 38 | void* m_timer_handle; 39 | net_device_val::bond_type m_bond; 40 | int timer_count; 41 | }; 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /src/vma/dev/qp_mgr_eth_direct.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | #ifndef SRC_VMA_DEV_QP_MGR_ETH_DIRECT_H_ 7 | #define SRC_VMA_DEV_QP_MGR_ETH_DIRECT_H_ 8 | 9 | #include "qp_mgr_eth_mlx5.h" 10 | 11 | #if defined(DEFINED_DIRECT_VERBS) 12 | 13 | class qp_mgr_eth_direct: public qp_mgr_eth_mlx5 14 | { 15 | public: 16 | qp_mgr_eth_direct(struct qp_mgr_desc *desc, 17 | const uint32_t tx_num_wr, const uint16_t vlan); 18 | virtual ~qp_mgr_eth_direct(); 19 | virtual cq_mgr* init_tx_cq_mgr(void); 20 | virtual void up(); 21 | virtual void down(); 22 | virtual uint32_t get_rx_max_wr_num() { return 0;}; 23 | virtual bool fill_hw_descriptors(vma_mlx_hw_device_data &data); 24 | protected: 25 | virtual int prepare_ibv_qp(vma_ibv_qp_init_attr& qp_init_attr); 26 | }; 27 | 28 | #endif /* DEFINED_DIRECT_VERBS */ 29 | 30 | #endif /* SRC_VMA_DEV_QP_MGR_ETH_DIRECT_H_ */ 31 | -------------------------------------------------------------------------------- /src/vma/dev/rfs_mc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef RFS_MC_H 9 | #define RFS_MC_H 10 | 11 | #include "vma/dev/rfs.h" 12 | 13 | 14 | /** 15 | * @class rfs_mc 16 | * 17 | * Object to manages the sink list of a MC flow 18 | * This object is used for maintaining the sink list and dispatching packets 19 | * 20 | */ 21 | 22 | 23 | class rfs_mc : public rfs 24 | { 25 | public: 26 | rfs_mc(flow_tuple *flow_spec_5t, ring_slave *p_ring, rfs_rule_filter* rule_filter = NULL, int32_t flow_tag_id = 0); 27 | 28 | virtual bool rx_dispatch_packet(mem_buf_desc_t* p_rx_wc_buf_desc, void* pv_fd_ready_array); 29 | 30 | protected: 31 | virtual bool prepare_flow_spec(); 32 | }; 33 | 34 | 35 | #endif /* RFS_MC_H */ 36 | -------------------------------------------------------------------------------- /src/vma/dev/rfs_uc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef RFS_UC_H 9 | #define RFS_UC_H 10 | 11 | #include "vma/dev/rfs.h" 12 | 13 | 14 | /** 15 | * @class rfs_uc 16 | * 17 | * Object to manages the sink list of a UC flow 18 | * This object is used for maintaining the sink list and dispatching packets 19 | * 20 | */ 21 | 22 | 23 | class rfs_uc : public rfs 24 | { 25 | public: 26 | rfs_uc(flow_tuple *flow_spec_5t, ring_slave *p_ring, 27 | rfs_rule_filter* rule_filter = NULL, uint32_t flow_tag_id = 0); 28 | 29 | virtual bool rx_dispatch_packet(mem_buf_desc_t* p_rx_wc_buf_desc, void* pv_fd_ready_array); 30 | 31 | protected: 32 | virtual bool prepare_flow_spec(); 33 | }; 34 | 35 | 36 | #endif /* RFS_UC_H */ 37 | -------------------------------------------------------------------------------- /src/vma/dev/rfs_uc_tcp_gro.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef RFS_UC_TCP_GRO_H 9 | #define RFS_UC_TCP_GRO_H 10 | 11 | #include "vma/dev/rfs_uc.h" 12 | #include 13 | /** 14 | * @class rfs_uc_tcp_gro 15 | * 16 | * Object to manages the sink list of a UC TCP GRO flow 17 | * This object is used for maintaining the sink list and dispatching packets 18 | * 19 | */ 20 | 21 | struct gro_mem_buf_desc { 22 | mem_buf_desc_t* p_first; 23 | mem_buf_desc_t* p_last; 24 | iphdr* p_ip_h; 25 | tcphdr* p_tcp_h; 26 | uint32_t buf_count; 27 | uint32_t next_seq; 28 | uint32_t ack; 29 | uint32_t ts_present; 30 | uint32_t tsval; 31 | uint32_t tsecr; 32 | uint16_t ip_tot_len; 33 | uint16_t wnd; 34 | } typedef gro_mem_buf_desc_t; 35 | 36 | class gro_mgr; 37 | 38 | class rfs_uc_tcp_gro : public rfs_uc 39 | { 40 | public: 41 | rfs_uc_tcp_gro(flow_tuple *flow_spec_5t, ring_slave *p_ring, 42 | rfs_rule_filter* rule_filter = NULL, uint32_t flow_tag_id = 0); 43 | 44 | virtual bool rx_dispatch_packet(mem_buf_desc_t* p_rx_wc_buf_desc, void* pv_fd_ready_array); 45 | 46 | void flush(void* pv_fd_ready_array); 47 | 48 | private: 49 | 50 | inline void flush_gro_desc(void* pv_fd_ready_array); 51 | inline void add_packet(mem_buf_desc_t* mem_buf_desc, iphdr* p_ip_h, tcphdr* p_tcp_h); 52 | inline void init_gro_desc(mem_buf_desc_t* mem_buf_desc, iphdr* p_ip_h, tcphdr* p_tcp_h); 53 | inline bool tcp_ip_check(mem_buf_desc_t* mem_buf_desc, iphdr* p_ip_h, tcphdr* p_tcp_h); 54 | inline bool timestamp_check(tcphdr* p_tcp_h); 55 | 56 | gro_mgr* m_p_gro_mgr; 57 | bool m_b_active; 58 | bool m_b_reserved; 59 | struct gro_mem_buf_desc m_gro_desc; 60 | uint32_t m_n_buf_max; 61 | uint32_t m_n_byte_max; 62 | struct tcp_pcb *m_pcb; 63 | }; 64 | 65 | 66 | #endif /* RFS_UC_TCP_GRO_H */ 67 | -------------------------------------------------------------------------------- /src/vma/dev/ring.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "ring.h" 9 | #include "vma/proto/route_table_mgr.h" 10 | 11 | #undef MODULE_NAME 12 | #define MODULE_NAME "ring" 13 | #undef MODULE_HDR 14 | #define MODULE_HDR MODULE_NAME "%d:%s() " 15 | 16 | ring::ring() : 17 | m_p_n_rx_channel_fds(NULL), m_parent(NULL) 18 | { 19 | m_if_index = 0; 20 | 21 | print_val(); 22 | } 23 | 24 | ring::~ring() 25 | { 26 | } 27 | 28 | void ring::print_val() 29 | { 30 | ring_logdbg("%d: %p: parent %p", 31 | m_if_index, this, ((uintptr_t)this == (uintptr_t)m_parent ? 0 : m_parent)); 32 | } 33 | -------------------------------------------------------------------------------- /src/vma/dev/ring_eth_direct.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef SRC_VMA_DEV_RING_ETH_DIRECT_H_ 8 | #define SRC_VMA_DEV_RING_ETH_DIRECT_H_ 9 | 10 | #include 11 | #include "dev/ring_simple.h" 12 | 13 | 14 | typedef std::pair pair_void_size_t; 15 | typedef std::pair pair_mr_ref_t; 16 | namespace std { 17 | template<> 18 | class hash 19 | { 20 | public: 21 | size_t operator()(const pair_void_size_t &key) const 22 | { 23 | hash_hash; 24 | return _hash((uint64_t)key.first ^ key.second); 25 | } 26 | }; 27 | } 28 | 29 | typedef std::unordered_map addr_len_mr_map_t; 30 | 31 | class ring_eth_direct : public ring_eth 32 | { 33 | public: 34 | ring_eth_direct(int if_index, 35 | vma_external_mem_attr *ext_ring_attr, ring *parent = NULL); 36 | virtual ~ring_eth_direct(); 37 | virtual qp_mgr* create_qp_mgr(struct qp_mgr_desc *desc); 38 | // memory handler 39 | virtual int reg_mr(void *addr, size_t length, uint32_t &lkey); 40 | virtual int dereg_mr(void *addr, size_t length); 41 | // dummy functions to block memory usage and internal thread 42 | virtual void init_tx_buffers(uint32_t count); 43 | virtual mem_buf_desc_t* mem_buf_tx_get(ring_user_id_t id, bool b_block, int n_num_mem_bufs = 1); 44 | virtual int drain_and_proccess(cq_type_t cq_type); 45 | virtual int poll_and_process_element_rx(uint64_t* p_cq_poll_sn, 46 | void* pv_fd_ready_array); 47 | private: 48 | vma_external_mem_attr m_ring_attr; 49 | addr_len_mr_map_t m_mr_map; 50 | }; 51 | 52 | 53 | #endif /* SRC_VMA_DEV_RING_ETH_DIRECT_H_ */ 54 | -------------------------------------------------------------------------------- /src/vma/dev/ring_profile.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef SRC_VMA_DEV_RING_PROFILE_H_ 8 | #define SRC_VMA_DEV_RING_PROFILE_H_ 9 | 10 | #include 11 | #include "net_device_val.h" 12 | #include "vma_extra.h" 13 | 14 | #define START_RING_INDEX 1 // beneath it's not defined 15 | 16 | class ring_profile; 17 | class ring_profiles_collection; 18 | 19 | 20 | typedef std::unordered_map ring_profile_map_t; 21 | 22 | extern ring_profiles_collection *g_p_ring_profile; 23 | 24 | 25 | class ring_profile 26 | { 27 | public: 28 | ring_profile(); 29 | ring_profile(const vma_ring_type_attr *ring_desc); 30 | vma_ring_type get_ring_type() {return m_ring_desc.ring_type;} 31 | struct vma_ring_type_attr* get_desc(){return &m_ring_desc;} 32 | bool operator==(const vma_ring_type_attr &p2); 33 | const char* to_str(){ return m_str.c_str();} 34 | const char* get_vma_ring_type_str(); 35 | private: 36 | void create_string(); 37 | std::string m_str; 38 | vma_ring_type_attr m_ring_desc; 39 | }; 40 | 41 | class ring_profiles_collection 42 | { 43 | public: 44 | ring_profiles_collection(); 45 | ~ring_profiles_collection(); 46 | vma_ring_profile_key add_profile(vma_ring_type_attr *profile); 47 | ring_profile* get_profile(vma_ring_profile_key key); 48 | 49 | private: 50 | ring_profile_map_t m_profs_map; 51 | vma_ring_profile_key m_curr_idx; 52 | }; 53 | #endif /* SRC_VMA_DEV_RING_PROFILE_H_ */ 54 | -------------------------------------------------------------------------------- /src/vma/dev/time_converter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef TIME_CONVERTER_H 9 | #define TIME_CONVERTER_H 10 | 11 | #include 12 | #include 13 | 14 | #include "vma/util/sys_vars.h" 15 | #include "vma/sock/cleanable_obj.h" 16 | #include "vma/event/timer_handler.h" 17 | 18 | class net_device_val; 19 | typedef std::unordered_map net_device_map_t; 20 | 21 | class ctx_timestamping_params_t { 22 | public: 23 | 24 | uint64_t hca_core_clock; 25 | uint64_t sync_hw_clock; 26 | struct timespec sync_systime; 27 | 28 | ctx_timestamping_params_t() : hca_core_clock(0), sync_hw_clock(0) { 29 | sync_systime.tv_sec = 0; 30 | sync_systime.tv_nsec = 0; 31 | } 32 | }; 33 | 34 | class time_converter : public timer_handler, public cleanable_obj 35 | { 36 | public: 37 | time_converter(): m_timer_handle(NULL), m_converter_status(TS_CONVERSION_MODE_DISABLE) {}; 38 | virtual ~time_converter() = 0; 39 | 40 | virtual void convert_hw_time_to_system_time(uint64_t hwtime, struct timespec* systime) = 0; 41 | virtual void handle_timer_expired(void* user_data) = 0; 42 | virtual void clean_obj(); 43 | ts_conversion_mode_t get_converter_status() { return m_converter_status; }; 44 | 45 | static ts_conversion_mode_t update_device_converters_status(net_device_map_t& net_devices); 46 | 47 | protected: 48 | void* m_timer_handle; 49 | ts_conversion_mode_t m_converter_status; 50 | 51 | static uint32_t get_single_converter_status(struct ibv_context* ctx); 52 | }; 53 | 54 | // pure virtual destructor implementation 55 | inline time_converter::~time_converter() { } 56 | 57 | #endif //TIME_CONVERTER_H 58 | -------------------------------------------------------------------------------- /src/vma/dev/time_converter_ib_ctx.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef TIME_CONVERTER_IB_CTX_H 9 | #define TIME_CONVERTER_IB_CTX_H 10 | 11 | #include 12 | #include 13 | #include "time_converter.h" 14 | 15 | 16 | class time_converter_ib_ctx : public time_converter 17 | { 18 | public: 19 | time_converter_ib_ctx(struct ibv_context* ctx, ts_conversion_mode_t ctx_time_converter_mode, uint64_t hca_core_clock); 20 | 21 | virtual ~time_converter_ib_ctx() {}; 22 | 23 | void convert_hw_time_to_system_time(uint64_t hwtime, struct timespec* systime); 24 | void handle_timer_expired(void* user_data); 25 | uint64_t get_hca_core_clock(); 26 | 27 | private: 28 | struct ibv_context* m_p_ibv_context; 29 | ctx_timestamping_params_t m_ctx_convert_parmeters[2]; 30 | int m_ctx_parmeters_id; 31 | 32 | void fix_hw_clock_deviation(); 33 | inline void calculate_delta(struct timespec& hw_to_timespec, uint64_t hca_core_clock, uint64_t hw_time_diff); 34 | bool sync_clocks(struct timespec* st, uint64_t* hw_clock); 35 | }; 36 | 37 | #endif // TIME_CONVERTER_IB_CTX_H 38 | -------------------------------------------------------------------------------- /src/vma/dev/time_converter_ptp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef TIME_CONVERTER_PTP_H 9 | #define TIME_CONVERTER_PTP_H 10 | 11 | #include 12 | #include "vma/event/timer_handler.h" 13 | #include 14 | #include "time_converter.h" 15 | 16 | #ifdef DEFINED_IBV_CLOCK_INFO 17 | 18 | class time_converter_ptp : public time_converter 19 | { 20 | public: 21 | time_converter_ptp(struct ibv_context* ctx); 22 | virtual ~time_converter_ptp() {}; 23 | 24 | inline void convert_hw_time_to_system_time(uint64_t hwtime, struct timespec* systime); 25 | virtual void handle_timer_expired(void* user_data); 26 | 27 | private: 28 | struct ibv_context* m_p_ibv_context; 29 | 30 | vma_ibv_clock_info m_clock_values[2]; 31 | int m_clock_values_id; 32 | }; 33 | 34 | #endif // DEFINED_IBV_CLOCK_INFO 35 | #endif // TIME_CONVERTER_PTP_H 36 | -------------------------------------------------------------------------------- /src/vma/dev/wqe_send_handler.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "wqe_send_handler.h" 9 | 10 | wqe_send_handler::wqe_send_handler() 11 | { 12 | } 13 | 14 | wqe_send_handler::~wqe_send_handler() 15 | { 16 | } 17 | 18 | void wqe_send_handler::init_inline_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge) 19 | { 20 | init_not_inline_wqe(wqe_to_init, sge_list, num_sge); 21 | enable_inline(wqe_to_init); 22 | } 23 | 24 | void wqe_send_handler::init_not_inline_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge) 25 | { 26 | init_wqe(wqe_to_init, sge_list, num_sge); 27 | enable_hw_csum(wqe_to_init); 28 | } 29 | 30 | void wqe_send_handler::init_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge) 31 | { 32 | memset(&wqe_to_init, 0, sizeof(wqe_to_init)); 33 | 34 | wqe_to_init.num_sge = num_sge; 35 | vma_send_wr_opcode(wqe_to_init) = VMA_IBV_WR_SEND; 36 | wqe_to_init.next = NULL; 37 | wqe_to_init.sg_list = sge_list; 38 | wqe_to_init.wr_id = 0; 39 | } 40 | -------------------------------------------------------------------------------- /src/vma/dev/wqe_send_handler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "vma/ib/base/verbs_extra.h" 8 | #include "vma/util/to_str.h" 9 | 10 | #ifndef IB_WQE_TEMPLATE_H 11 | #define IB_WQE_TEMPLATE_H 12 | 13 | class wqe_send_handler: public tostr 14 | { 15 | public: 16 | wqe_send_handler(); 17 | virtual ~wqe_send_handler(); 18 | 19 | void init_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge); 20 | void init_inline_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge); 21 | void init_not_inline_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge); 22 | 23 | inline vma_ibv_wr_opcode set_opcode(vma_ibv_send_wr &wqe, vma_ibv_wr_opcode opcode) { 24 | vma_ibv_wr_opcode last_opcode = vma_send_wr_opcode(wqe); 25 | vma_send_wr_opcode(wqe) = opcode; 26 | return last_opcode; 27 | } 28 | 29 | #ifndef DEFINED_SW_CSUM 30 | inline void enable_hw_csum (vma_ibv_send_wr &send_wqe) { vma_send_wr_send_flags(send_wqe) |= VMA_IBV_SEND_IP_CSUM; } 31 | inline void disable_hw_csum (vma_ibv_send_wr &send_wqe) { vma_send_wr_send_flags(send_wqe) &= ~VMA_IBV_SEND_IP_CSUM; } 32 | #else 33 | inline void enable_hw_csum (vma_ibv_send_wr &) {} 34 | inline void disable_hw_csum (vma_ibv_send_wr &) {} 35 | #endif 36 | 37 | #ifdef DEFINED_TSO 38 | inline void enable_tso(vma_ibv_send_wr &wr, void *hdr, uint16_t hdr_sz, uint16_t mss) { 39 | vma_send_wr_opcode(wr) = VMA_IBV_WR_TSO; 40 | wr.tso.hdr = hdr; 41 | wr.tso.hdr_sz = hdr_sz; 42 | wr.tso.mss = mss; 43 | } 44 | #endif /* DEFINED_TSO */ 45 | 46 | inline void enable_inline (vma_ibv_send_wr &send_wqe) { vma_send_wr_send_flags(send_wqe) |= VMA_IBV_SEND_INLINE; } 47 | }; 48 | 49 | #endif /* IB_WQE_TEMPLATE_H */ 50 | -------------------------------------------------------------------------------- /src/vma/dev/wqe_send_ib_handler.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "wqe_send_ib_handler.h" 8 | 9 | wqe_send_ib_handler::wqe_send_ib_handler() 10 | { 11 | } 12 | 13 | wqe_send_ib_handler::~wqe_send_ib_handler() 14 | { 15 | } 16 | 17 | void wqe_send_ib_handler::init_path_record(vma_ibv_send_wr &wqe_to_init, struct ibv_ah *ah, uint32_t rem_qkey, uint32_t rem_qpn) 18 | { 19 | wqe_to_init.wr.ud.ah = ah; 20 | wqe_to_init.wr.ud.remote_qkey = rem_qkey; 21 | wqe_to_init.wr.ud.remote_qpn = rem_qpn; 22 | } 23 | 24 | void wqe_send_ib_handler::init_ib_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge, 25 | struct ibv_ah *ah, uint32_t rem_qpn, uint32_t rem_qkey) 26 | { 27 | wqe_send_handler::init_wqe(wqe_to_init, sge_list, num_sge); 28 | init_path_record(wqe_to_init, ah, rem_qkey, rem_qpn); 29 | } 30 | 31 | void wqe_send_ib_handler::init_inline_ib_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge, 32 | struct ibv_ah *ah, uint32_t rem_qpn, uint32_t rem_qkey) 33 | { 34 | wqe_send_handler::init_inline_wqe(wqe_to_init, sge_list, num_sge); 35 | init_path_record(wqe_to_init, ah, rem_qkey, rem_qpn); 36 | } 37 | 38 | void wqe_send_ib_handler::init_not_inline_ib_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge, 39 | struct ibv_ah *ah, uint32_t rem_qpn, uint32_t rem_qkey) 40 | { 41 | wqe_send_handler::init_not_inline_wqe(wqe_to_init, sge_list, num_sge); 42 | init_path_record(wqe_to_init, ah, rem_qkey, rem_qpn); 43 | } 44 | -------------------------------------------------------------------------------- /src/vma/dev/wqe_send_ib_handler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "wqe_send_handler.h" 8 | #include "vma/util/vtypes.h" 9 | 10 | #ifndef WQE_TEMPLATE_SEND_IB_H_ 11 | #define WQE_TEMPLATE_SEND_IB_H_ 12 | 13 | class wqe_send_ib_handler: public wqe_send_handler 14 | { 15 | public: 16 | wqe_send_ib_handler(); 17 | virtual ~wqe_send_ib_handler(); 18 | 19 | void init_ib_wqe(vma_ibv_send_wr &wqe_to_init, struct ibv_sge* sge_list, uint32_t num_sge, struct ibv_ah *ah, uint32_t rem_qpn, uint32_t rem_qkey); 20 | void init_inline_ib_wqe(vma_ibv_send_wr & wqe_to_init, struct ibv_sge *sge_list, uint32_t num_sge, struct ibv_ah *ah, uint32_t rem_qpn, uint32_t rem_qkey); 21 | void init_not_inline_ib_wqe(vma_ibv_send_wr & wqe_to_init, struct ibv_sge *sge_list, uint32_t num_sge, struct ibv_ah *ah, uint32_t rem_qpn, uint32_t rem_qkey); 22 | 23 | private: 24 | void init_path_record(vma_ibv_send_wr & wqe_to_init, struct ibv_ah *ah, uint32_t rem_qkey, uint32_t rem_qpn); 25 | }; 26 | 27 | #endif /* WQE_TEMPLATE_SEND_IB_H_ */ 28 | -------------------------------------------------------------------------------- /src/vma/event/command.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | * 6 | * command.h 7 | */ 8 | 9 | #ifndef COMMAND_H_ 10 | #define COMMAND_H_ 11 | 12 | #include "vma/netlink/netlink_wrapper.h" 13 | #include "vma/util/to_str.h" 14 | #include "vma/event/timer_handler.h" 15 | 16 | class command : public tostr 17 | { 18 | public: 19 | command(){}; 20 | virtual ~command(){}; 21 | virtual void execute() = 0; 22 | private: 23 | //block copy ctor 24 | command(const command &command); 25 | }; 26 | 27 | class command_netlink: public command , public timer_handler 28 | { 29 | public: 30 | command_netlink(netlink_wrapper *executer): m_ntl_executer(executer) {}; 31 | 32 | virtual void execute() { 33 | if (m_ntl_executer) { 34 | m_ntl_executer->handle_events(); 35 | } 36 | } 37 | 38 | const std::string to_str() const 39 | { 40 | return(string("command_netlink")); 41 | } 42 | 43 | virtual void handle_timer_expired(void* a) { 44 | NOT_IN_USE(a); 45 | m_ntl_executer->neigh_timer_expired(); 46 | } 47 | 48 | 49 | private: 50 | netlink_wrapper *m_ntl_executer; 51 | 52 | }; 53 | 54 | #endif /* COMMAND_H_ */ 55 | -------------------------------------------------------------------------------- /src/vma/event/event.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef EVENT_H 9 | #define EVENT_H 10 | 11 | #include 12 | #include 13 | #include 14 | #include "utils/bullseye.h" 15 | #include "vma/util/to_str.h" 16 | 17 | class event : public tostr { 18 | public: 19 | enum type{ 20 | UNKNOWN_EVENT, 21 | SEND_EVENT, 22 | DROP_EVENT 23 | }; 24 | 25 | type m_type; 26 | event(void* notifier=NULL) : m_type(UNKNOWN_EVENT), m_notifier(notifier) {} 27 | virtual ~event() {}; 28 | 29 | virtual const std::string to_str() const 30 | { 31 | char outstr[1024]; 32 | sprintf(outstr, "EVENT_TYPE=%s NOTIFIER_PTR=%llu", typeid(*this).name(), (long long unsigned int)m_notifier); 33 | return std::string(outstr); 34 | } 35 | 36 | private: 37 | void* m_notifier; 38 | }; 39 | 40 | 41 | #endif /* EVENT_H */ 42 | -------------------------------------------------------------------------------- /src/vma/event/event_handler_ibverbs.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef EVENT_HANDLER_IBVERBS_H 9 | #define EVENT_HANDLER_IBVERBS_H 10 | 11 | /* 12 | * @class event_handler 13 | * An object registers with event_handler_manager to get event notification callbacks for the registered HCA context. 14 | * This callback function will be called when an event was received on the appropritae channel with the appropritae id. 15 | * The channels can be shared between several objects, but the id's in each channel has to be unic. 16 | */ 17 | class event_handler_ibverbs 18 | { 19 | public: 20 | virtual ~event_handler_ibverbs() {}; 21 | virtual void handle_event_ibverbs_cb(void* ev_data, void* user_data) = 0; 22 | }; 23 | 24 | #endif //EVENT_HANDLER_IBVERBS_H 25 | -------------------------------------------------------------------------------- /src/vma/event/event_handler_rdma_cm.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef EVENT_HANDLER_RDMA_CM_H 9 | #define EVENT_HANDLER_RDMA_CM_H 10 | 11 | #include 12 | 13 | /* 14 | * @class event_handler 15 | * An object registers with event_handler_manager to get event notification callbacks for the registered rdma_cm id's. 16 | * This callback function will be called when an event was received on the appropritae channel with the appropritae id. 17 | * The channels can be shared between several objects, but the id's in each channel has to be unic. 18 | */ 19 | class event_handler_rdma_cm 20 | { 21 | public: 22 | virtual ~event_handler_rdma_cm() {}; 23 | virtual void handle_event_rdma_cm_cb(struct rdma_cm_event* p_event) = 0; 24 | }; 25 | 26 | #endif //EVENT_HANDLER_RDMA_CM_H 27 | -------------------------------------------------------------------------------- /src/vma/event/timer_handler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef TIMER_HANDLER_H 9 | #define TIMER_HANDLER_H 10 | 11 | /** 12 | * simple timer notification. 13 | * Any class that inherit timer_handler should also inherit cleanable_obj, and use clean_obj instead of delete. 14 | * It must implement the clean_obj method to delete the object from the internal thread. 15 | */ 16 | class timer_handler 17 | { 18 | public: 19 | virtual ~timer_handler() {}; 20 | virtual void handle_timer_expired(void* user_data) = 0; 21 | }; 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /src/vma/event/timers_group.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef TIMERS_GROUP_H 9 | #define TIMERS_GROUP_H 10 | 11 | /* 12 | * This is an API for batching timers into groups. 13 | * Instead of registering each timer separately into the internal thread, the group is registered once, 14 | * and the timers are registered to the group. 15 | * The registration to the group is still done through the internal thread. 16 | * The group must be deleted through the internal thread (must implement clean_obj interface). 17 | * Registering to group must be used with register_timer_event() and unregister_timer_event() only. 18 | */ 19 | class timers_group : public timer_handler { 20 | public: 21 | virtual ~timers_group() {}; 22 | // execute all the timers registered to the group 23 | // according to the internal group logic. 24 | virtual void handle_timer_expired(void* user_data) = 0; 25 | 26 | protected: 27 | friend class event_handler_manager; 28 | // add a new timer 29 | virtual void add_new_timer(timer_node_t* node, timer_handler* handler, void* user_data) = 0; 30 | 31 | // remove timer from list and free it. 32 | // called for stopping (unregistering) a timer 33 | virtual void remove_timer(timer_node_t* node) = 0; 34 | }; 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/vma/event/vlogger_timer_handler.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | 11 | #include "vlogger_timer_handler.h" 12 | #include "timer_handler.h" 13 | #include "event_handler_manager.h" 14 | 15 | vlogger_timer_handler* g_p_vlogger_timer_handler = NULL; 16 | 17 | vlogger_timer_handler::vlogger_timer_handler():m_timer_handle(NULL) 18 | { 19 | if (g_p_event_handler_manager) { 20 | /* failure in allocating m_timer_handle will result in throwing an exception by called methods */ 21 | m_timer_handle = g_p_event_handler_manager->register_timer_event(UPDATE_VLOGGER_LEVELS_INTERVAL, this, PERIODIC_TIMER, 0); 22 | } 23 | } 24 | 25 | vlogger_timer_handler::~vlogger_timer_handler() 26 | { 27 | if (m_timer_handle) { 28 | g_p_event_handler_manager->unregister_timer_event(this, m_timer_handle); 29 | m_timer_handle = NULL; 30 | } 31 | } 32 | 33 | void vlogger_timer_handler::handle_timer_expired(void* user_data) 34 | { 35 | NOT_IN_USE(user_data); 36 | if (g_p_vlogger_level) 37 | g_vlogger_level = *g_p_vlogger_level; 38 | if (g_p_vlogger_details) 39 | g_vlogger_details = *g_p_vlogger_details; 40 | } 41 | 42 | 43 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /src/vma/event/vlogger_timer_handler.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef VLOGGER_TIMER_HANDLER_H 9 | #define VLOGGER_TIMER_HANDLER_H 10 | 11 | #include "timer_handler.h" 12 | 13 | #define UPDATE_VLOGGER_LEVELS_INTERVAL 100 14 | 15 | class vlogger_timer_handler : public timer_handler 16 | { 17 | public: 18 | vlogger_timer_handler(); 19 | ~vlogger_timer_handler(); 20 | private: 21 | void handle_timer_expired(void* user_data); 22 | 23 | void* m_timer_handle; 24 | }; 25 | 26 | extern vlogger_timer_handler* g_p_vlogger_timer_handler; 27 | 28 | #endif /*VLOGGER_TIMER_HANDLER_H*/ 29 | -------------------------------------------------------------------------------- /src/vma/ib/mlx5/ib_mlx5_dv.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifdef HAVE_CONFIG_H 8 | #include "config.h" 9 | #endif 10 | 11 | #if defined(DEFINED_DIRECT_VERBS) && (DEFINED_DIRECT_VERBS == 3) 12 | 13 | #include "vma/ib/mlx5/ib_mlx5.h" 14 | 15 | int vma_ib_mlx5dv_init_obj(struct mlx5dv_obj *obj, uint64_t type) 16 | { 17 | int ret = 0; 18 | 19 | ret = mlx5dv_init_obj(obj, type); 20 | 21 | return ret; 22 | } 23 | 24 | int vma_ib_mlx5_req_notify_cq(vma_ib_mlx5_cq_t *mlx5_cq, int solicited) 25 | { 26 | uint64_t doorbell; 27 | uint32_t sn; 28 | uint32_t ci; 29 | uint32_t cmd; 30 | 31 | sn = mlx5_cq->cq_sn & 3; 32 | ci = mlx5_cq->cq_ci & 0xffffff; 33 | cmd = solicited ? MLX5_CQ_DB_REQ_NOT_SOL : MLX5_CQ_DB_REQ_NOT; 34 | 35 | doorbell = sn << 28 | cmd | ci; 36 | doorbell <<= 32; 37 | doorbell |= mlx5_cq->cq_num; 38 | 39 | mlx5_cq->dbrec[VMA_IB_MLX5_CQ_ARM_DB] = htonl(sn << 28 | cmd | ci); 40 | 41 | /* 42 | * Make sure that the doorbell record in host memory is 43 | * written before ringing the doorbell via PCI WC MMIO. 44 | */ 45 | wmb(); 46 | 47 | *(uint64_t *)((uint8_t *)mlx5_cq->uar + MLX5_CQ_DOORBELL) = htonll(doorbell); 48 | 49 | wc_wmb(); 50 | 51 | return 0; 52 | } 53 | 54 | void vma_ib_mlx5_get_cq_event(vma_ib_mlx5_cq_t *mlx5_cq, int count) 55 | { 56 | mlx5_cq->cq_sn += count; 57 | } 58 | 59 | #endif /* (DEFINED_DIRECT_VERBS == 3) */ 60 | -------------------------------------------------------------------------------- /src/vma/ib/mlx5/ib_mlx5_dv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef SRC_VMA_IB_MLX5_DV_H_ 8 | #define SRC_VMA_IB_MLX5_DV_H_ 9 | 10 | #ifndef SRC_VMA_IB_MLX5_H_ 11 | #error "Use instead." 12 | #endif 13 | 14 | #if defined(DEFINED_DIRECT_VERBS) && (DEFINED_DIRECT_VERBS == 3) 15 | 16 | #endif /* (DEFINED_DIRECT_VERBS == 3) */ 17 | 18 | #endif /* SRC_VMA_IB_MLX5_DV_H_ */ 19 | -------------------------------------------------------------------------------- /src/vma/ib/mlx5/ib_mlx5_hw.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef SRC_VMA_IB_MLX5_HW_H_ 8 | #define SRC_VMA_IB_MLX5_HW_H_ 9 | 10 | #ifndef SRC_VMA_IB_MLX5_H_ 11 | #error "Use instead." 12 | #endif 13 | 14 | #if defined(DEFINED_DIRECT_VERBS) && (DEFINED_DIRECT_VERBS == 2) 15 | 16 | #include 17 | 18 | /* This structures duplicate mlx5dv.h (rdma-core upstream) 19 | * to use upstream specific approach as a basis 20 | */ 21 | struct mlx5dv_qp { 22 | volatile uint32_t *dbrec; 23 | struct { 24 | void *buf; 25 | uint32_t wqe_cnt; 26 | uint32_t stride; 27 | } sq; 28 | struct { 29 | void *buf; 30 | uint32_t wqe_cnt; 31 | uint32_t stride; 32 | } rq; 33 | struct { 34 | void *reg; 35 | uint32_t size; 36 | } bf; 37 | uint64_t comp_mask; 38 | }; 39 | 40 | struct mlx5dv_cq { 41 | void *buf; 42 | volatile uint32_t *dbrec; 43 | uint32_t cqe_cnt; 44 | uint32_t cqe_size; 45 | void *cq_uar; 46 | uint32_t cqn; 47 | uint64_t comp_mask; 48 | }; 49 | 50 | struct mlx5dv_obj { 51 | struct { 52 | struct ibv_qp *in; 53 | struct mlx5dv_qp *out; 54 | } qp; 55 | struct { 56 | struct ibv_cq *in; 57 | struct mlx5dv_cq *out; 58 | } cq; 59 | }; 60 | 61 | enum mlx5dv_obj_type { 62 | MLX5DV_OBJ_QP = 1 << 0, 63 | MLX5DV_OBJ_CQ = 1 << 1, 64 | }; 65 | 66 | #endif /* (DEFINED_DIRECT_VERBS == 2) */ 67 | 68 | #endif /* SRC_VMA_IB_MLX5_HW_H_ */ 69 | -------------------------------------------------------------------------------- /src/vma/infra/DemoCollMgr.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "DemoCollMgr.h" 9 | 10 | Demo_Coll_Mgr1::Demo_Coll_Mgr1() : cache_collection_mgr, demo_subject_1_value_t>("lock: Demo_Coll_Mgr1") 11 | { 12 | printf("created collection mgr: char --> int\n"); 13 | 14 | } 15 | 16 | Demo_Subject1* Demo_Coll_Mgr1::create_new_entry(key_class key, const observer* obs) 17 | { 18 | NOT_IN_USE(obs); 19 | return new Demo_Subject1(key.get_actual_key()); 20 | } 21 | 22 | Demo_Coll_Mgr1::~Demo_Coll_Mgr1() 23 | { 24 | 25 | } 26 | 27 | Demo_Coll_Mgr2::Demo_Coll_Mgr2() : cache_collection_mgr, demo_subject_2_value_t>("lock: Demo_Coll_Mgr2") 28 | { 29 | printf("created collection mgr: int --> uint \n"); 30 | 31 | } 32 | 33 | Demo_Subject2* Demo_Coll_Mgr2::create_new_entry(key_class key, const observer* obs) 34 | { 35 | NOT_IN_USE(obs); 36 | return new Demo_Subject2(key.get_actual_key()); 37 | } 38 | 39 | 40 | Demo_Coll_Mgr2::~Demo_Coll_Mgr2() 41 | { 42 | 43 | } 44 | 45 | 46 | -------------------------------------------------------------------------------- /src/vma/infra/DemoCollMgr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef DEMOCOLLMGR_H_ 9 | #define DEMOCOLLMGR_H_ 10 | 11 | #include "cache_subject_observer.h" 12 | #include "DemoSubject.h" 13 | 14 | class Demo_Coll_Mgr1 : public cache_table_mgr, demo_subject_1_value_t> 15 | { 16 | public: 17 | Demo_Coll_Mgr1(); 18 | virtual ~Demo_Coll_Mgr1(); 19 | virtual Demo_Subject1* create_new_entry(key_class, const observer*); 20 | }; 21 | 22 | class Demo_Coll_Mgr2 : public cache_table_mgr, demo_subject_2_value_t> 23 | { 24 | public: 25 | Demo_Coll_Mgr2(); 26 | virtual ~Demo_Coll_Mgr2(); 27 | virtual Demo_Subject2* create_new_entry(key_class, const observer*); 28 | }; 29 | 30 | #endif /* DEMOCOLLMGR_H_ */ 31 | -------------------------------------------------------------------------------- /src/vma/infra/DemoObserver.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | * 6 | * DemoObserver.h 7 | */ 8 | 9 | #ifndef DEMOOBSERVER_H_ 10 | #define DEMOOBSERVER_H_ 11 | 12 | #include 13 | #include 14 | #include 15 | #include "cache_subject_observer.h" 16 | #include "DemoSubject.h" 17 | #include "DemoCollMgr.h" 18 | using namespace std; 19 | 20 | class Demo_Observer : public cache_observer 21 | { 22 | public: 23 | Demo_Observer(); 24 | virtual ~Demo_Observer(); 25 | 26 | void register_to_subjects(Demo_Coll_Mgr1 *coll_for_subjects_1, Demo_Coll_Mgr2 *coll_for_subjects_2); 27 | bool start_test(Demo_Coll_Mgr1 *coll_for_subjects_1, Demo_Coll_Mgr2 *coll_for_subjects_2); 28 | 29 | void notify_cb(); //hide cache_observer function for testing 30 | 31 | private: 32 | 33 | void update_subject_1(demo_subject_1_key_t key, demo_subject_1_value_t value); //sets value of subject type-1 corresponding to key 34 | void update_subject_2(demo_subject_2_key_t key, demo_subject_2_value_t value); //sets value of subject type-2 corresponding to key 35 | 36 | void get_subject_1(demo_subject_1_key_t key); //prints value of subject type-1 corresponding to key 37 | void get_subject_2(demo_subject_2_key_t key); //prints value of subject type-2 corresponding to key 38 | 39 | //Demo_Coll_Mgr1* m_coll_for_subjects_1; //collection mgr for subjects type-1 40 | //Demo_Coll_Mgr2* m_coll_for_subjects_2; //collection mgr for subjects type-2 41 | 42 | map m_subjects_1_list; //list of observed subjects type-1 43 | map m_subjects_2_list; //list of observed subjects type-2 44 | 45 | }; 46 | 47 | #endif /* DEMOOBSERVER_H_ */ 48 | -------------------------------------------------------------------------------- /src/vma/infra/DemoSubject.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | * 6 | * DemoSubject.h 7 | */ 8 | 9 | 10 | #include "DemoSubject.h" 11 | 12 | Demo_Subject1::Demo_Subject1(demo_subject_1_key_t key_1) 13 | : cache_entry_subject, demo_subject_1_value_t>(key_class(key_1), "lock: Demo_Subject1") 14 | { 15 | 16 | printf("new subject of type 1: \n"); 17 | 18 | printf("\t key = %c, no value \n", key_1); 19 | 20 | } 21 | 22 | Demo_Subject1::Demo_Subject1(demo_subject_1_key_t key_1, demo_subject_1_value_t val_1) 23 | : cache_entry_subject, demo_subject_1_value_t>(key_class(key_1)) 24 | { 25 | 26 | set_val(val_1); 27 | 28 | printf("new subject of type 1: \n"); 29 | 30 | printf("\t key = %c, value = %d\n", key_1, val_1); 31 | 32 | } 33 | 34 | Demo_Subject1::~Demo_Subject1() 35 | { 36 | 37 | } 38 | 39 | Demo_Subject2::Demo_Subject2(demo_subject_2_key_t key_2) 40 | : cache_entry_subject, demo_subject_2_value_t>(key_class(key_2), "lock: Demo_Subject2") 41 | { 42 | 43 | printf("new subject of type 2: \n"); 44 | 45 | printf("\t key = %d, no value \n", key_2); 46 | 47 | } 48 | 49 | Demo_Subject2::Demo_Subject2(demo_subject_2_key_t key_2, demo_subject_2_value_t val_2) 50 | : cache_entry_subject, demo_subject_2_value_t>(key_class(key_2)) 51 | { 52 | 53 | set_val(val_2); 54 | 55 | printf("new subject of type 1: \n"); 56 | 57 | printf("\t key = %d, value = %d\n", key_2, val_2); 58 | 59 | } 60 | 61 | Demo_Subject2::~Demo_Subject2() 62 | { 63 | 64 | } 65 | -------------------------------------------------------------------------------- /src/vma/infra/DemoSubject.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | * 6 | * DemoSubject.h 7 | */ 8 | 9 | #ifndef DEMOSUBJECT_H_ 10 | #define DEMOSUBJECT_H_ 11 | 12 | #include "cache_subject_observer.h" 13 | #include 14 | 15 | template 16 | class key_class : public tostr 17 | { 18 | public: 19 | key_class(Key key) { m_key = (uint32_t)key; }; 20 | key_class(){}; 21 | 22 | const std::string to_str() const 23 | { 24 | char s[20]; 25 | /* cppcheck-suppress wrongPrintfScanfArgNum */ 26 | snprintf(s, sizeof(s), "%d.%d.%d.%d", NIPQUAD(m_key)); 27 | return(std::string(s)); 28 | } 29 | 30 | void set_actual_key(Key key) { m_key = (uint32_t)key; }; 31 | 32 | uint32_t get_actual_key() { return m_key; }; 33 | private: 34 | uint32_t m_key; 35 | }; 36 | 37 | typedef char demo_subject_1_key_t; 38 | typedef int demo_subject_1_value_t; 39 | typedef cache_entry_subject, demo_subject_1_value_t> Demo_Subject1_t; 40 | 41 | class Demo_Subject1 : public Demo_Subject1_t 42 | { 43 | public: 44 | Demo_Subject1(demo_subject_1_key_t key_1); 45 | Demo_Subject1(demo_subject_1_key_t key_1, demo_subject_1_value_t val_1); 46 | 47 | virtual inline bool get_val(INOUT demo_subject_1_value_t & val) { val = m_val; return true; }; 48 | 49 | inline void update_val(IN demo_subject_1_value_t & val) { this->set_val(val); }; 50 | 51 | virtual ~Demo_Subject1(); 52 | }; 53 | 54 | typedef int demo_subject_2_key_t; 55 | typedef uint demo_subject_2_value_t; 56 | 57 | class Demo_Subject2 : public cache_entry_subject, demo_subject_2_value_t> 58 | { 59 | public: 60 | Demo_Subject2(demo_subject_2_key_t key_2); 61 | Demo_Subject2(demo_subject_2_key_t key_2, demo_subject_2_value_t val_2); 62 | 63 | virtual inline bool get_val(INOUT demo_subject_2_value_t & val) { val = m_val; return true; }; 64 | 65 | inline void update_val(IN demo_subject_2_value_t & val) { this->set_val(val); }; 66 | 67 | virtual ~Demo_Subject2(); 68 | }; 69 | 70 | #endif /* DEMOSUBJECT_H_ */ 71 | -------------------------------------------------------------------------------- /src/vma/infra/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CFLAGS = -Wall -g #-O3 2 | 3 | AM_CPPFLAGS := \ 4 | -I$(top_srcdir)/src 5 | 6 | noinst_HEADERS = \ 7 | sender.h \ 8 | subject_observer.h \ 9 | cache_subject_observer.h \ 10 | DemoSubject.h \ 11 | DemoCollMgr.h \ 12 | DemoObserver.h 13 | 14 | EXTRA_DIST = \ 15 | cache_subject_observer.h \ 16 | main.cpp \ 17 | DemoSubject.cpp \ 18 | DemoCollMgr.cpp \ 19 | DemoObserver.cpp \ 20 | DemoCollMgr.h \ 21 | DemoObserver.h \ 22 | DemoSubject.h 23 | 24 | noinst_LTLIBRARIES = libinfra.la 25 | libinfra_la_LDFLAGS = -static 26 | libinfra_la_SOURCES = \ 27 | sender.cpp \ 28 | subject_observer.cpp 29 | 30 | # This section is disabled 31 | # (just keep one for future use) 32 | #noinst_PROGRAMS = cache_test 33 | 34 | #cache_test_LDADD = \ 35 | # libinfra.la 36 | 37 | #cache_test_SOURCES = \ 38 | # main.cpp \ 39 | # cache_subject_observer.h \ 40 | # DemoSubject.cpp \ 41 | # DemoCollMgr.cpp \ 42 | # DemoObserver.cpp \ 43 | # DemoCollMgr.h \ 44 | # DemoObserver.h \ 45 | # DemoSubject.h 46 | 47 | #cache_test_CXXFLAGS = -g 48 | 49 | #cache_test_DEPENDENCIES = \ 50 | # libinfra.la \ 51 | # $(top_builddir)/src/vlogger/libvlogger.la 52 | 53 | -------------------------------------------------------------------------------- /src/vma/infra/main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "DemoObserver.h" 9 | 10 | int main() 11 | { 12 | 13 | Demo_Observer *o1 = new Demo_Observer(); 14 | Demo_Observer *o2 = new Demo_Observer(); 15 | 16 | //collection mgr, subjects type-1 17 | Demo_Coll_Mgr1 *coll_for_subjects_1 = new Demo_Coll_Mgr1(); 18 | //collection mgr, subjects type-2 19 | Demo_Coll_Mgr2 *coll_for_subjects_2 = new Demo_Coll_Mgr2(); 20 | 21 | o1->register_to_subjects(coll_for_subjects_1, coll_for_subjects_2); 22 | o2->register_to_subjects(coll_for_subjects_1, coll_for_subjects_2); 23 | 24 | o1->start_test(coll_for_subjects_1, coll_for_subjects_2); 25 | 26 | delete o1; 27 | delete o2; 28 | delete coll_for_subjects_1; 29 | delete coll_for_subjects_2; 30 | 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /src/vma/infra/sender.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2013-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | /* 8 | * sender.cpp 9 | * 10 | * Created on: Feb 28, 2013 11 | * Author: olgas 12 | */ 13 | 14 | #include "vma/infra/sender.h" 15 | 16 | send_data::send_data(const send_info *si) 17 | { 18 | BULLSEYE_EXCLUDE_BLOCK_START 19 | if(si == NULL) { 20 | m_iov.iov_base = NULL; 21 | m_iov.iov_len = 0; 22 | return; 23 | } 24 | BULLSEYE_EXCLUDE_BLOCK_END 25 | 26 | uint8_t* buff = NULL; 27 | size_t total_len = 0; 28 | 29 | for(uint32_t i = 0;i < si->m_sz_iov;i++){ 30 | total_len += si->m_p_iov[i].iov_len; 31 | } 32 | 33 | buff = new uint8_t[total_len]; 34 | BULLSEYE_EXCLUDE_BLOCK_START 35 | if (NULL == buff) { 36 | m_iov.iov_base = NULL; 37 | m_iov.iov_len = 0; 38 | return; 39 | } 40 | BULLSEYE_EXCLUDE_BLOCK_END 41 | 42 | memcpy_fromiovec(buff, si->m_p_iov, si->m_sz_iov, 0, total_len); 43 | m_iov.iov_base = buff; 44 | m_iov.iov_len = total_len; 45 | } 46 | 47 | send_data::~send_data() 48 | { 49 | if(m_iov.iov_base) { 50 | delete[]((uint8_t *)m_iov.iov_base); 51 | } 52 | } 53 | 54 | -------------------------------------------------------------------------------- /src/vma/infra/sender.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef SEND_INFO 9 | #define SEND_INFO 10 | 11 | #include "utils/bullseye.h" 12 | #include "vlogger/vlogger.h" 13 | #include "vma/util/to_str.h" 14 | #include "vma/util/utils.h" 15 | #include "vma/event/event.h" 16 | #include "vma/proto/header.h" 17 | 18 | class event; 19 | 20 | 21 | class send_info : tostr 22 | { 23 | public: 24 | send_info(iovec *iov, size_t sz): 25 | m_p_iov(iov), 26 | m_sz_iov(sz){}; 27 | virtual ~send_info(){}; 28 | 29 | iovec *m_p_iov; 30 | size_t m_sz_iov; 31 | }; 32 | 33 | class neigh_send_info : public send_info 34 | { 35 | public: 36 | neigh_send_info(iovec *iov, size_t sz, header *hdr, uint8_t proto, 37 | uint32_t mtu, uint8_t tos): 38 | send_info(iov, sz), m_p_header(hdr),m_mtu(mtu), m_tos(tos), m_protocol(proto){}; 39 | header *m_p_header; 40 | uint32_t m_mtu; 41 | uint8_t m_tos; 42 | uint8_t m_protocol; 43 | }; 44 | 45 | class send_data 46 | { 47 | public: 48 | send_data(const send_info *si); 49 | virtual ~send_data(); 50 | iovec m_iov; 51 | }; 52 | 53 | class neigh_send_data : public send_data 54 | { 55 | public: 56 | neigh_send_data(const neigh_send_info *nsi): send_data((const send_info*)nsi), 57 | m_header(new header(*(nsi->m_p_header))), 58 | m_mtu(nsi->m_mtu), 59 | m_tos(nsi->m_tos), 60 | m_protocol(nsi->m_protocol) 61 | { 62 | }; 63 | 64 | virtual ~neigh_send_data() 65 | { 66 | if(m_header) { 67 | delete m_header; 68 | } 69 | }; 70 | 71 | header *m_header; 72 | uint32_t m_mtu; 73 | uint8_t m_tos; 74 | uint8_t m_protocol; 75 | }; 76 | 77 | class send_event : public event 78 | { 79 | public: 80 | send_event(send_info s_info): m_send_info(s_info) { m_type = SEND_EVENT; }; 81 | 82 | send_info m_send_info; 83 | 84 | }; 85 | 86 | #endif /* SEND_INFO */ 87 | -------------------------------------------------------------------------------- /src/vma/infra/sender_info_dst.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "sender_info_dst.h" 9 | 10 | sender::send_info_dst(ibv_send_wr *send_wqe, dst_entry *dst_entry): sender::send_info(send_wqe) 11 | { 12 | 13 | } 14 | -------------------------------------------------------------------------------- /src/vma/infra/sender_info_dst.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef SENDER_INFO_DST_H 9 | #define SENDER_INFO_DST_H 10 | 11 | #include "sender.h" 12 | #include "proto/dst_entry.h" 13 | 14 | class sender::send_info_dst: public sender::send_info 15 | { 16 | public: 17 | sender::send_info_dst(ibv_send_wr *send_wqe, dst_entry *dst_entry): m_p_send_wqe(send_wqe) {}; 18 | sender::send_info_dst(): m_p_send_wqe(NULL) {}; 19 | virtual ~send_info() {}; 20 | 21 | dst_entry *m_p_send_wqe; 22 | 23 | }; 24 | 25 | 26 | 27 | #endif /* SENDER_INFO_DST_H */ 28 | -------------------------------------------------------------------------------- /src/vma/infra/subject_observer.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "vlogger/vlogger.h" 9 | #include "vma/infra/subject_observer.h" 10 | 11 | #define MODULE_NAME "subject_observer" 12 | 13 | #define sub_obs_logerr __log_info_err 14 | #define sub_obs_logwarn __log_info_warn 15 | #define sub_obs_loginfo __log_info_info 16 | #define sub_obs_logdbg __log_info_dbg 17 | #define sub_obs_logfunc __log_info_func 18 | #define sub_obs_logfuncall __log_info_funcall 19 | 20 | 21 | bool subject::register_observer(IN const observer* const new_observer) 22 | { 23 | if (new_observer == NULL) { 24 | // sub_obs_logdbg("[%s] observer (NULL)", to_str()); 25 | return false; 26 | } 27 | 28 | auto_unlocker lock(m_lock); 29 | if (m_observers.count((observer *)new_observer) > 0) { 30 | // sub_obs_logdbg("[%s] Observer is already registered (%p)", to_str(), new_observer); 31 | return false; 32 | } 33 | m_observers.insert((observer *)new_observer); 34 | // sub_obs_logdbg("[%s] Successfully registered new_observer %s", to_str(), new_observer->to_str()); 35 | return true; 36 | } 37 | 38 | bool subject::unregister_observer(IN const observer * const old_observer) 39 | { 40 | if (old_observer == NULL) { 41 | // sub_obs_logdbg("[%s] observer (NULL)", to_str()); 42 | return false; 43 | } 44 | 45 | auto_unlocker lock(m_lock); 46 | m_observers.erase((observer *)old_observer); 47 | // sub_obs_logdbg("[%s] Successfully unregistered old_observer %s",to_str(), old_observer->to_str()); 48 | return true; 49 | } 50 | 51 | void subject::notify_observers(event* ev /*=NULL*/) 52 | { 53 | // sub_obs_logdbg("[%s]", to_str()); 54 | 55 | auto_unlocker lock(m_lock); 56 | for (observers_t::iterator iter = m_observers.begin(); iter != m_observers.end(); iter++) { 57 | if (ev) 58 | (*iter)->notify_cb(ev); 59 | else 60 | (*iter)->notify_cb(); 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/vma/infra/subject_observer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | /* This class implements subject observer design pattern */ 9 | 10 | #ifndef SUBJECT_OBSERVER_H 11 | #define SUBJECT_OBSERVER_H 12 | 13 | #include 14 | #include "utils/lock_wrapper.h" 15 | #include "vma/util/vtypes.h" 16 | #include "vma/util/to_str.h" 17 | #include "vma/event/event.h" 18 | 19 | class observer 20 | { 21 | public: 22 | virtual ~observer() {}; 23 | virtual void notify_cb() { return; }; 24 | virtual void notify_cb(event * ev) { NOT_IN_USE(ev); notify_cb(); }; 25 | }; 26 | 27 | typedef std::unordered_set observers_t; 28 | 29 | class subject 30 | { 31 | public: 32 | subject(const char* lock_name = "lock(subject)") : m_lock(lock_name) {}; 33 | virtual ~subject() {}; 34 | bool register_observer(IN const observer* const new_observer); 35 | bool unregister_observer(IN const observer* const old_observer); 36 | void notify_observers(event * ev = NULL); 37 | 38 | protected: 39 | lock_mutex_recursive m_lock; 40 | observers_t m_observers; // list of pointers of all observers (using stl::set for uniqueness - preventing duplicates) 41 | }; 42 | 43 | #endif /* SUBJECT_OBSERVER_H */ 44 | -------------------------------------------------------------------------------- /src/vma/iomux/poll_call.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef _POLL_CALL_H 9 | #define _POLL_CALL_H 10 | 11 | #include 12 | 13 | #include "io_mux_call.h" 14 | 15 | /** 16 | * @class poll_call 17 | * Functor for poll() 18 | */ 19 | class poll_call : public io_mux_call 20 | { 21 | public: 22 | /** 23 | * Create a poll call. 24 | * @param rfds_buffer Array of at least nfds ints. 25 | * @param lookup_buffer Array of at least nfds ints. 26 | * @param extra_fds_buffer Array of at least (1 + nfds) pollfd-s. 27 | * 28 | * Rest of the arguments are the same as for poll() library function. 29 | * @throws io_mux_call::io_error 30 | */ 31 | poll_call(int *off_rfds_buffer, offloaded_mode_t *off_modes_buffer, int *lookup_buffer, 32 | pollfd *working_fds_arr, pollfd *fds, nfds_t nfds, int timeout, const sigset_t *__sigmask = NULL); 33 | 34 | /// @override 35 | virtual void set_offloaded_rfd_ready(int fd_index); 36 | virtual void set_offloaded_wfd_ready(int fd_index); 37 | virtual void set_offloaded_efd_ready(int fd_index, int errors); 38 | 39 | /// @override 40 | virtual void prepare_to_block(); 41 | 42 | /// @override 43 | virtual bool wait_os(bool zero_timeout); 44 | 45 | /// @override 46 | virtual bool wait(const timeval &elapsed); 47 | 48 | /// @override 49 | virtual bool is_timeout(const timeval &elapsed); 50 | 51 | /// @override 52 | virtual void set_rfd_ready(int fd); 53 | 54 | /// @override 55 | virtual void set_wfd_ready(int fd); 56 | 57 | /// @override 58 | virtual void set_efd_ready(int fd, int errors); 59 | 60 | private: 61 | /// Parameters for the call 62 | pollfd * m_fds; 63 | const nfds_t m_nfds; 64 | int m_timeout; 65 | 66 | int * const m_lookup_buffer; 67 | pollfd * const m_orig_fds; 68 | 69 | void copy_to_orig_fds(); 70 | 71 | }; 72 | 73 | #endif 74 | -------------------------------------------------------------------------------- /src/vma/iomux/select_call.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef _SELECT_CALL_H 9 | #define _SELECT_CALL_H 10 | 11 | #include 12 | 13 | #include "io_mux_call.h" 14 | 15 | /** 16 | * @class poll_call 17 | * Functor for poll() 18 | */ 19 | class select_call : public io_mux_call 20 | { 21 | public: 22 | /** 23 | * Create a select call. 24 | * @param fds_buffer Array of at least nfds ints. 25 | * 26 | * Rest of the arguments are the same as for select() library function. 27 | * @throws io_mux_call::io_error 28 | */ 29 | select_call(int *off_fds_buffer, offloaded_mode_t *off_modes_buffer, 30 | int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, timeval *timeout, const sigset_t *__sigmask = NULL); 31 | 32 | /// @override 33 | virtual void set_offloaded_rfd_ready(int fd_index); 34 | virtual void set_offloaded_wfd_ready(int fd_index); 35 | 36 | /// @override 37 | virtual void prepare_to_poll(); 38 | 39 | /// @override 40 | virtual void prepare_to_block(); 41 | 42 | /// @override 43 | virtual bool wait_os(bool zero_timeout); 44 | 45 | /// @override 46 | virtual bool wait(const timeval &elapsed); 47 | 48 | /// @override 49 | virtual bool is_timeout(const timeval &elapsed); 50 | 51 | /// @override 52 | virtual void set_rfd_ready(int fd); 53 | virtual void set_wfd_ready(int fd); 54 | virtual void set_efd_ready(int fd, int errors); 55 | 56 | private: 57 | /// Parameters for the call 58 | const int m_nfds; 59 | fd_set * m_readfds; 60 | fd_set * const m_writefds; 61 | fd_set * const m_exceptfds; 62 | timeval * const m_timeout; 63 | 64 | fd_set m_orig_readfds; 65 | fd_set m_orig_writefds; 66 | fd_set m_orig_exceptfds; 67 | int m_nfds_with_cq; 68 | bool m_b_run_prepare_to_poll; 69 | // int *m_exclude_os_fds; 70 | // int m_n_exclude_fds; 71 | // int m_rfd_count; 72 | 73 | fd_set m_os_rfds; 74 | fd_set m_os_wfds; 75 | 76 | fd_set m_cq_rfds; 77 | 78 | }; 79 | 80 | #endif 81 | -------------------------------------------------------------------------------- /src/vma/libvma.c: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | extern int vma_init(void); 9 | extern int vma_exit(void); 10 | 11 | int __attribute__((constructor)) sock_redirect_lib_load_constructor(void) 12 | { 13 | return vma_init(); 14 | } 15 | 16 | int __attribute__((destructor)) sock_redirect_lib_load_destructor(void) 17 | { 18 | return vma_exit(); 19 | } 20 | -------------------------------------------------------------------------------- /src/vma/lwip/cc_none.c: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "vma/lwip/cc.h" 8 | #include "vma/lwip/tcp.h" 9 | 10 | #if TCP_CC_ALGO_MOD 11 | 12 | static void none_cc_conn_init(struct tcp_pcb *pcb); 13 | 14 | struct cc_algo none_cc_algo = { 15 | .name = "none_cc", 16 | .conn_init = none_cc_conn_init, 17 | }; 18 | 19 | static void 20 | none_cc_conn_init(struct tcp_pcb *pcb) 21 | { 22 | pcb->cwnd = UINT32_MAX; 23 | } 24 | 25 | #endif //TCP_CC_ALGO_MOD 26 | -------------------------------------------------------------------------------- /src/vma/lwip/init.c: -------------------------------------------------------------------------------- 1 | /** 2 | * @file 3 | * Modules initialization 4 | * 5 | */ 6 | 7 | /* 8 | * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 9 | * All rights reserved. 10 | * 11 | * Redistribution and use in source and binary forms, with or without modification, 12 | * are permitted provided that the following conditions are met: 13 | * 14 | * 1. Redistributions of source code must retain the above copyright notice, 15 | * this list of conditions and the following disclaimer. 16 | * 2. Redistributions in binary form must reproduce the above copyright notice, 17 | * this list of conditions and the following disclaimer in the documentation 18 | * and/or other materials provided with the distribution. 19 | * 3. The name of the author may not be used to endorse or promote products 20 | * derived from this software without specific prior written permission. 21 | * 22 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 23 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 24 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 25 | * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 26 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 27 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 30 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 31 | * OF SUCH DAMAGE. 32 | * 33 | * This file is part of the lwIP TCP/IP stack. 34 | * 35 | * Author: Adam Dunkels 36 | * 37 | */ 38 | 39 | #include "lwip/opt.h" 40 | 41 | #include "lwip/init.h" 42 | #include "lwip/stats.h" 43 | #include "lwip/pbuf.h" 44 | #include "lwip/ip.h" 45 | #include "lwip/tcp_impl.h" 46 | 47 | 48 | /** 49 | * Perform Sanity check of user-configurable values, and initialize all modules. 50 | */ 51 | void 52 | lwip_init(void) 53 | { 54 | /* Modules initialization */ 55 | stats_init(); 56 | pbuf_init(); 57 | tcp_init(); 58 | } 59 | -------------------------------------------------------------------------------- /src/vma/lwip/init.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 3 | * All rights reserved. 4 | * 5 | * Redistribution and use in source and binary forms, with or without modification, 6 | * are permitted provided that the following conditions are met: 7 | * 8 | * 1. Redistributions of source code must retain the above copyright notice, 9 | * this list of conditions and the following disclaimer. 10 | * 2. Redistributions in binary form must reproduce the above copyright notice, 11 | * this list of conditions and the following disclaimer in the documentation 12 | * and/or other materials provided with the distribution. 13 | * 3. The name of the author may not be used to endorse or promote products 14 | * derived from this software without specific prior written permission. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 19 | * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 21 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 24 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 25 | * OF SUCH DAMAGE. 26 | * 27 | * This file is part of the lwIP TCP/IP stack. 28 | * 29 | * Author: Adam Dunkels 30 | * 31 | */ 32 | #ifndef __LWIP_INIT_H__ 33 | #define __LWIP_INIT_H__ 34 | 35 | #include "lwip/opt.h" 36 | 37 | #ifdef __cplusplus 38 | extern "C" { 39 | #endif 40 | 41 | /* Modules initialization */ 42 | void lwip_init(void); 43 | 44 | #ifdef __cplusplus 45 | } 46 | #endif 47 | 48 | #endif /* __LWIP_INIT_H__ */ 49 | -------------------------------------------------------------------------------- /src/vma/main.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef MAIN_H 9 | #define MAIN_H 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | void print_vma_global_settings(); 17 | void check_locked_mem(); 18 | void set_env_params(); 19 | void prepare_fork(); 20 | 21 | extern "C" void sock_redirect_main(void); 22 | extern "C" void sock_redirect_exit(void); 23 | 24 | extern bool g_init_ibv_fork_done; 25 | 26 | #endif //MAIN_H 27 | -------------------------------------------------------------------------------- /src/vma/netlink/Makefile.am: -------------------------------------------------------------------------------- 1 | AM_CFLAGS = -Wall -g #-O3 2 | 3 | AM_CPPFLAGS := \ 4 | -I$(top_srcdir)/src \ 5 | ${LIBNL_CFLAGS} 6 | 7 | noinst_LTLIBRARIES = libnetlink.la 8 | libnetlink_la_LDFLAGS = -static 9 | libnetlink_la_SOURCES = \ 10 | neigh_info.cpp \ 11 | route_info.cpp \ 12 | link_info.cpp \ 13 | netlink_compatibility.cpp \ 14 | netlink_wrapper.cpp 15 | 16 | EXTRA_DIST = \ 17 | test_main.cpp 18 | 19 | # This section is disabled 20 | # (just keep one for future use) 21 | #noinst_PROGRAMS = nl_test 22 | 23 | #nl_test_LDADD = -lrt -ldl -lpthread -libverbs -lrdmacm \ 24 | # ${LIBNL_LIBS} \ 25 | # libnetlink.la \ 26 | # $(top_builddir)/src/vlogger/libvlogger.la 27 | 28 | #nl_test_SOURCES = \ 29 | # neigh_info.cpp \ 30 | # route_info.cpp \ 31 | # link_info.cpp \ 32 | # netlink_compatibility.cpp \ 33 | # netlink_wrapper.cpp \ 34 | # ../infra/subject_observer.cpp \ 35 | # ../event/netlink_event.cpp \ 36 | # test_main.cpp \ 37 | # link_info.h \ 38 | # neigh_info.h \ 39 | # netlink_compatibility.h \ 40 | # netlink_wrapper.h \ 41 | # route_info.h 42 | 43 | #nl_test_CXXFLAGS = -g 44 | 45 | #nl_test_DEPENDENCIES = \ 46 | # libnetlink.la \ 47 | # $(top_builddir)/src/vlogger/libvlogger.la 48 | -------------------------------------------------------------------------------- /src/vma/netlink/link_info.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "link_info.h" 9 | #include "vlogger/vlogger.h" 10 | 11 | #define MODULE_NAME "netlink_event" 12 | 13 | #define ADDR_MAX_STR_LEN (128) 14 | 15 | 16 | netlink_link_info::netlink_link_info(struct rtnl_link* link): 17 | /*arptype(0),*/ broadcast_str(""), addr_family(0), flags(0), ifindex( 18 | 0), /*mode(0),*/ master_ifindex(0), mtu( 19 | 0), name(""), operstate(0), txqlen( 20 | 0) 21 | { 22 | fill(link); 23 | } 24 | 25 | void netlink_link_info::fill(struct rtnl_link* link) 26 | { 27 | if (link) { 28 | //arptype=rtnl_link_get_arptype(link); 29 | addr_family=rtnl_link_get_family(link); 30 | flags=rtnl_link_get_flags(link); 31 | ifindex=rtnl_link_get_ifindex(link); 32 | master_ifindex=rtnl_link_get_master(link); 33 | mtu=rtnl_link_get_mtu(link); 34 | txqlen=rtnl_link_get_txqlen(link); 35 | operstate=rtnl_link_get_operstate(link); 36 | //mode=rtnl_link_get_linkmode(link); 37 | 38 | nl_addr* addr; 39 | char addr_str[ADDR_MAX_STR_LEN + 1]; 40 | 41 | const char* namestr=rtnl_link_get_name(link); 42 | if (namestr) { 43 | name = namestr; 44 | } 45 | 46 | addr = rtnl_link_get_broadcast(link); 47 | if (addr) { 48 | broadcast_str = nl_addr2str(addr, addr_str, ADDR_MAX_STR_LEN); 49 | } 50 | 51 | } 52 | } 53 | 54 | const std::string netlink_link_info::get_operstate2str() const { 55 | char operstate_str[256]; 56 | return rtnl_link_operstate2str(operstate,operstate_str, 255); 57 | } 58 | -------------------------------------------------------------------------------- /src/vma/netlink/neigh_info.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include 9 | #include "neigh_info.h" 10 | 11 | #define ADDR_MAX_STR_LEN (128) 12 | 13 | netlink_neigh_info::netlink_neigh_info(struct rtnl_neigh* neigh) : 14 | dst_addr_str(""), dst_addr(NULL), dst_addr_len(0), flags(0), ifindex( 15 | 0), lladdr_str(""), lladdr(NULL), lladdr_len(0), state( 16 | 0), type(0) 17 | { 18 | fill(neigh); 19 | } 20 | 21 | void netlink_neigh_info::fill(struct rtnl_neigh* neigh) 22 | { 23 | if (!neigh) 24 | return; 25 | 26 | nl_addr* addr; 27 | char addr_str[ADDR_MAX_STR_LEN + 1]; 28 | 29 | addr = rtnl_neigh_get_dst(neigh); 30 | if (addr) { 31 | dst_addr_str = nl_addr2str(addr, addr_str, ADDR_MAX_STR_LEN); 32 | dst_addr = (unsigned char*)nl_addr_get_binary_addr(addr); 33 | dst_addr_len = nl_addr_get_len(addr); 34 | } 35 | 36 | addr = rtnl_neigh_get_lladdr(neigh); 37 | if (addr) { 38 | lladdr_str = nl_addr2str(addr, addr_str, ADDR_MAX_STR_LEN); 39 | lladdr = (unsigned char*)nl_addr_get_binary_addr(addr); 40 | lladdr_len = nl_addr_get_len(addr); 41 | } 42 | //addr_family = rtnl_neigh_get_family(neigh); 43 | flags = rtnl_neigh_get_flags(neigh); 44 | ifindex = rtnl_neigh_get_ifindex(neigh); 45 | state = rtnl_neigh_get_state(neigh); 46 | type = rtnl_neigh_get_type(neigh); 47 | } 48 | 49 | 50 | -------------------------------------------------------------------------------- /src/vma/netlink/route_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef NETLINK_ROUTE_INFO_H_ 9 | #define NETLINK_ROUTE_INFO_H_ 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | #include "vma/proto/route_val.h" 16 | 17 | class netlink_route_info 18 | { 19 | public: 20 | 21 | netlink_route_info(struct rtnl_route* nl_route_obj); 22 | ~netlink_route_info(); 23 | 24 | route_val* get_route_val() { return m_route_val; }; 25 | 26 | private: 27 | // fill all attributes using the provided netlink original route 28 | void fill(struct rtnl_route* nl_route_obj); 29 | 30 | route_val* m_route_val; 31 | }; 32 | 33 | #endif /* NETLINK_ROUTE_INFO_H_ */ 34 | -------------------------------------------------------------------------------- /src/vma/proto/L2_address.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "utils/bullseye.h" 9 | #include "vlogger/vlogger.h" 10 | #include "vma/proto/L2_address.h" 11 | 12 | 13 | #define MODULE_NAME "L2_addr" 14 | 15 | #define L2_panic __log_panic 16 | #define L2_logerr __log_info_err 17 | #define L2_logwarn __log_info_warn 18 | #define L2_loginfo __log_info_info 19 | #define L2_logdbg __log_info_dbg 20 | #define L2_logfunc __log_info_func 21 | #define L2_logfuncall __log_info_funcall 22 | 23 | L2_address::L2_address(address_t const address, addrlen_t const len) 24 | { 25 | set(address, len); 26 | } 27 | 28 | void L2_address::set(address_t const address, addrlen_t const len) 29 | { 30 | BULLSEYE_EXCLUDE_BLOCK_START 31 | if (len <= 0 || len > L2_ADDR_MAX) 32 | L2_panic("len = %lu", len); 33 | 34 | if (address == NULL) 35 | L2_panic("address == NULL"); 36 | BULLSEYE_EXCLUDE_BLOCK_END 37 | 38 | // Copy the new address 39 | m_len = len; 40 | memcpy((void*)m_p_raw_address, (void*)address, m_len); 41 | } 42 | 43 | bool L2_address::compare(L2_address const& other) const 44 | { 45 | if (other.m_len != m_len) 46 | return false; 47 | return (!memcmp((void*)other.m_p_raw_address, (void*)m_p_raw_address, m_len)); 48 | } 49 | 50 | const std::string ETH_addr::to_str() const 51 | { 52 | char s[100] = ""; 53 | if (m_len > 0) 54 | sprintf(s, ETH_HW_ADDR_PRINT_FMT, ETH_HW_ADDR_PRINT_ADDR(m_p_raw_address)); 55 | return (std::string(s)); 56 | } 57 | 58 | const std::string IPoIB_addr::to_str() const 59 | { 60 | char s[100] = ""; 61 | if (m_len > 0) 62 | sprintf(s, IPOIB_HW_ADDR_PRINT_FMT, IPOIB_HW_ADDR_PRINT_ADDR(m_p_raw_address)); 63 | return (std::string(s)); 64 | } 65 | 66 | void IPoIB_addr::extract_qpn() 67 | { 68 | unsigned char rem_qpn[4]; 69 | 70 | rem_qpn[0] = m_p_raw_address[3]; 71 | rem_qpn[1] = m_p_raw_address[2]; 72 | rem_qpn[2] = m_p_raw_address[1]; 73 | rem_qpn[3] = 0; 74 | memcpy(&m_qpn, rem_qpn, 4); 75 | L2_logdbg("qpn = %#x", m_qpn); 76 | } 77 | 78 | 79 | -------------------------------------------------------------------------------- /src/vma/proto/arp.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | #include 11 | #include "vma/proto/arp.h" 12 | #include "vma/util/vtypes.h" 13 | #include 14 | 15 | /* ARP message types (opcodes) */ 16 | #define ARP_REQUEST 0x0001 17 | 18 | #define HWTYPE_ETHERNET 0x0001 19 | #define HWTYPE_IB 0x0020 20 | #define IPv4_ALEN 0x04 21 | #define ETHADDR_COPY(dst, src) memcpy(dst, src, ETH_ALEN) 22 | #define IBADDR_COPY(dst, src) memcpy(dst, src, IPOIB_HW_ADDR_LEN) 23 | 24 | void set_eth_arp_hdr(eth_arp_hdr *p_arph, in_addr_t ipsrc_addr, in_addr_t ipdst_addr, const uint8_t* hwsrc_addr, const uint8_t* hwdst_addr) 25 | { 26 | p_arph->m_hwtype = htons(HWTYPE_ETHERNET); 27 | p_arph->m_proto = htons(ETH_P_IP); 28 | p_arph->m_hwlen = ETH_ALEN; 29 | p_arph->m_protolen = IPv4_ALEN; 30 | p_arph->m_opcode = htons(ARP_REQUEST); 31 | ETHADDR_COPY(p_arph->m_shwaddr, hwsrc_addr); 32 | p_arph->m_sipaddr = ipsrc_addr; 33 | ETHADDR_COPY(p_arph->m_dhwaddr, hwdst_addr); 34 | p_arph->m_dipaddr = ipdst_addr; 35 | } 36 | 37 | void set_ib_arp_hdr(ib_arp_hdr* p_arph, in_addr_t ipsrc_addr, in_addr_t ipdst_addr, const uint8_t* hwsrc_addr, const uint8_t* hwdst_addr) 38 | { 39 | p_arph->m_hwtype = htons(HWTYPE_IB); 40 | p_arph->m_proto = htons(ETH_P_IP); 41 | p_arph->m_hwlen = IPOIB_HW_ADDR_LEN; 42 | p_arph->m_protolen = IPv4_ALEN; 43 | p_arph->m_opcode = htons(ARP_REQUEST); 44 | IBADDR_COPY(p_arph->m_shwaddr, hwsrc_addr); 45 | p_arph->m_sipaddr = ipsrc_addr; 46 | if(hwdst_addr) 47 | IBADDR_COPY(p_arph->m_dhwaddr, hwdst_addr); 48 | p_arph->m_dipaddr = ipdst_addr; 49 | } 50 | -------------------------------------------------------------------------------- /src/vma/proto/arp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef ARP_H 9 | #define ARP_H 10 | 11 | #include 12 | #include 13 | #include "vma/util/vtypes.h" 14 | 15 | struct __attribute__ ((packed)) eth_arp_hdr 16 | { 17 | uint16_t m_hwtype; 18 | uint16_t m_proto; 19 | uint8_t m_hwlen; 20 | uint8_t m_protolen; 21 | uint16_t m_opcode; 22 | uint8_t m_shwaddr[ETH_ALEN]; 23 | uint32_t m_sipaddr; 24 | uint8_t m_dhwaddr[ETH_ALEN]; 25 | uint32_t m_dipaddr; 26 | }; 27 | 28 | void set_eth_arp_hdr(eth_arp_hdr* p_arph, in_addr_t ipsrc_addr, in_addr_t ipdst_addr, const uint8_t* hwsrc_addr, const uint8_t* hwdst_addr); 29 | 30 | struct __attribute__ ((packed)) ib_arp_hdr 31 | { 32 | uint16_t m_hwtype; 33 | uint16_t m_proto; 34 | uint8_t m_hwlen; 35 | uint8_t m_protolen; 36 | uint16_t m_opcode; 37 | uint8_t m_shwaddr[IPOIB_HW_ADDR_LEN]; 38 | uint32_t m_sipaddr; 39 | uint8_t m_dhwaddr[IPOIB_HW_ADDR_LEN]; 40 | uint32_t m_dipaddr; 41 | }; 42 | 43 | void set_ib_arp_hdr(ib_arp_hdr* p_arph, in_addr_t ipsrc_addr, in_addr_t ipdst_addr, const uint8_t* hwsrc_addr, const uint8_t* hwdst_addr); 44 | 45 | 46 | #endif 47 | -------------------------------------------------------------------------------- /src/vma/proto/dst_entry_udp_mc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef DST_ENTRY_UDP_MC_H 9 | #define DST_ENTRY_UDP_MC_H 10 | 11 | #include "vma/proto/dst_entry_udp.h" 12 | 13 | class dst_entry_udp_mc : public dst_entry_udp 14 | { 15 | public: 16 | dst_entry_udp_mc(in_addr_t dst_ip, uint16_t dst_port, uint16_t src_port, 17 | in_addr_t mc_tx_if_ip, bool mc_b_loopback, socket_data &sock_data, 18 | resource_allocation_key &ring_alloc_logic); 19 | virtual ~dst_entry_udp_mc(); 20 | 21 | virtual bool conf_l2_hdr_and_snd_wqe_ib(); 22 | 23 | protected: 24 | ip_address m_mc_tx_if_ip; 25 | bool m_b_mc_loopback_enabled; 26 | 27 | virtual void set_src_addr(); 28 | virtual bool resolve_net_dev(bool is_connect=false); 29 | }; 30 | 31 | #endif /* DST_ENTRY_UDP_MC_H */ 32 | -------------------------------------------------------------------------------- /src/vma/proto/igmp_mgr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "vma/proto/igmp_handler.h" 9 | #include 10 | 11 | #ifndef IGMP_MANAGER_H 12 | #define IGMP_MANAGER_H 13 | 14 | 15 | typedef std::unordered_map igmp_hdlr_map_t; 16 | 17 | class igmp_mgr : public lock_mutex 18 | { 19 | public: 20 | igmp_mgr() {}; 21 | ~igmp_mgr(); 22 | void process_igmp_packet(struct iphdr* p_ip_h, in_addr_t local_if); 23 | 24 | private: 25 | igmp_hdlr_map_t m_igmp_hash; 26 | igmp_handler* get_igmp_handler(const igmp_key &key, uint8_t igmp_code); 27 | }; 28 | 29 | extern igmp_mgr *g_p_igmp_mgr; 30 | 31 | #endif 32 | 33 | -------------------------------------------------------------------------------- /src/vma/proto/ip_address.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef IP_ADDRESS_H 9 | #define IP_ADDRESS_H 10 | 11 | #include 12 | #include "vma/util/to_str.h" 13 | #include "vma/util/vtypes.h" 14 | 15 | /* coverity[missing_move_assignment] */ 16 | class ip_address : public tostr 17 | { 18 | public: 19 | ip_address(in_addr_t ip): m_ip(ip){}; 20 | ~ip_address(){}; 21 | 22 | const std::string to_str() const 23 | { 24 | char s[20]; 25 | /* cppcheck-suppress wrongPrintfScanfArgNum */ 26 | sprintf(s, "%d.%d.%d.%d", NIPQUAD(m_ip)); 27 | return(std::string(s)); 28 | } 29 | 30 | in_addr_t get_in_addr() const { return m_ip; }; 31 | bool is_mc() { return (IN_MULTICAST_N(m_ip)); }; 32 | 33 | bool operator==(const ip_address &ip) const { return (m_ip == ip.get_in_addr()); }; 34 | 35 | private: 36 | in_addr_t m_ip; 37 | }; 38 | 39 | namespace std { 40 | template<> 41 | class hash 42 | { 43 | public: 44 | size_t operator()(const ip_address &key) const 45 | { 46 | hash_hash; 47 | return _hash(key.get_in_addr()); 48 | } 49 | }; 50 | } 51 | 52 | 53 | #endif /* IP_ADDRESS_H */ 54 | -------------------------------------------------------------------------------- /src/vma/proto/neighbour_observer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | 9 | #ifndef NEIGHBOUR_OBSERVER_H 10 | #define NEIGHBOUR_OBSERVER_H 11 | 12 | #include "vma/util/sys_vars.h" 13 | #include "vma/infra/subject_observer.h" 14 | 15 | class neigh_observer : public observer 16 | { 17 | public: 18 | virtual transport_type_t get_obs_transport_type() const = 0; 19 | }; 20 | 21 | #endif /* NEIGHBOUR_OBSERVER_H */ 22 | -------------------------------------------------------------------------------- /src/vma/proto/neighbour_table_mgr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef NEIGHBOUR_TABLE_MGR_H 9 | #define NEIGHBOUR_TABLE_MGR_H 10 | 11 | #include "vma/proto/neighbour.h" 12 | #include "vma/infra/cache_subject_observer.h" 13 | 14 | class neigh_table_mgr : public cache_table_mgr, public observer 15 | { 16 | public: 17 | neigh_table_mgr(); 18 | ~neigh_table_mgr(); 19 | virtual void notify_cb(event * event); 20 | rdma_event_channel* m_neigh_cma_event_channel; 21 | bool register_observer(neigh_key, 22 | const cache_observer *, 23 | cache_entry_subject **); 24 | 25 | private: 26 | /* This function will retrieve neigh transport type by the following actions: 27 | * 1. go to route manager table and get route entry according to the peer ip 28 | * 2. get netdev from route entry 29 | * 3. get transport type from netdev 30 | */ 31 | neigh_entry* create_new_entry(neigh_key neigh_key, const observer* dst); 32 | }; 33 | 34 | extern neigh_table_mgr *g_p_neigh_table_mgr; 35 | 36 | 37 | #endif /* NEIGHBOUR_TABLE_MGR_H */ 38 | -------------------------------------------------------------------------------- /src/vma/proto/peer_key.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | #ifndef __PEER_KEY_H__ 7 | #define __PEER_KEY_H__ 8 | 9 | /** 10 | * Use union for representing ip:port as one uint64_t primitive, 11 | * 12 | * NOTE: this type provides implicit cast to uint64_t. Hence, it natively supports containers such as map and hash. 13 | */ 14 | union peer_key { 15 | public: 16 | peer_key(uint32_t _ip, uint16_t _port) : ip(_ip), port(_port){} 17 | operator uint64_t() const {return key;} // this saves the need for operator< and for operator== and for operator size_t() with map/hash 18 | 19 | private: 20 | uint64_t key; 21 | 22 | struct { 23 | uint32_t ip; 24 | uint32_t port; // 32 bits for making sure all bits of key are initialized 25 | }; 26 | }; 27 | 28 | #endif /* ! __PEER_KEY_H__ */ 29 | -------------------------------------------------------------------------------- /src/vma/proto/route_entry.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef ROUTE_ENTRY_H 9 | #define ROUTE_ENTRY_H 10 | 11 | #include "vma/util/if.h" 12 | #include 13 | 14 | #include "vma/proto/route_rule_table_key.h" 15 | #include "vma/infra/cache_subject_observer.h" 16 | #include "vma/dev/net_device_entry.h" 17 | #include "route_val.h" 18 | #include "rule_entry.h" 19 | 20 | class route_entry : public cache_entry_subject, public cache_observer 21 | { 22 | public: 23 | friend class route_table_mgr; 24 | 25 | route_entry(route_rule_table_key rtk); 26 | virtual ~route_entry(); 27 | 28 | bool get_val(INOUT route_val* &val); 29 | void set_val(IN route_val* &val); 30 | 31 | net_device_val* get_net_dev_val() { return m_p_net_dev_val; } 32 | 33 | inline void set_entry_valid() { m_is_valid = true; } 34 | inline bool is_valid() { return m_is_valid && m_val && m_val->is_valid(); }; //m_val is NULL at first 35 | 36 | virtual void notify_cb(); 37 | 38 | void set_str(); 39 | const string to_str() const { return m_str; }; 40 | 41 | inline rule_entry* get_rule_entry() const { return m_p_rr_entry; }; 42 | 43 | private: 44 | net_device_entry* m_p_net_dev_entry; 45 | net_device_val* m_p_net_dev_val; 46 | bool m_b_offloaded_net_dev; 47 | bool m_is_valid; 48 | string m_str; 49 | rule_entry* m_p_rr_entry; 50 | 51 | void register_to_net_device(); 52 | void unregister_to_net_device(); 53 | }; 54 | 55 | #endif /* ROUTE_ENTRY_H */ 56 | -------------------------------------------------------------------------------- /src/vma/proto/rule_entry.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "rule_entry.h" 9 | #include "rule_table_mgr.h" 10 | #include "vma/infra/cache_subject_observer.h" 11 | 12 | #define MODULE_NAME "rre" 13 | #undef MODULE_HDR_INFO 14 | #define MODULE_HDR_INFO MODULE_NAME "[%s]:%d:%s() " 15 | #undef __INFO__ 16 | #define __INFO__ to_str().c_str() 17 | 18 | #define rr_entry_logdbg __log_info_dbg 19 | 20 | rule_entry::rule_entry(route_rule_table_key rrk) : 21 | cache_entry_subject*>(rrk) 22 | { 23 | m_val = &values; 24 | } 25 | 26 | bool rule_entry::get_val(INOUT std::deque* &val) 27 | { 28 | rr_entry_logdbg(""); 29 | val = m_val; 30 | return is_valid(); 31 | } 32 | 33 | -------------------------------------------------------------------------------- /src/vma/proto/rule_entry.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef RULE_ENTRY_H 9 | #define RULE_ENTRY_H 10 | 11 | #include "vma/infra/cache_subject_observer.h" 12 | #include "vma/proto/route_rule_table_key.h" 13 | #include "rule_val.h" 14 | 15 | 16 | // This class represent an entry in rule table cashed history. 17 | class rule_entry : public cache_entry_subject*> 18 | { 19 | public: 20 | friend class rule_table_mgr; 21 | 22 | rule_entry(route_rule_table_key rrk); 23 | 24 | bool get_val(INOUT std::deque* &val); 25 | 26 | inline bool is_valid(){ 27 | /* TODO for future rules live updates */ 28 | /* for (std::deque::iterator val = m_val->begin(); val != m_val->end(); val++) { 29 | if (!(*val)->is_valid()) { 30 | return false; 31 | } 32 | } */ 33 | return !m_val->empty(); 34 | } 35 | 36 | inline const string to_str() const { return get_key().to_str(); }; 37 | 38 | private: 39 | std::deque values; 40 | }; 41 | 42 | #endif /* RULE_ENTRY_H */ 43 | -------------------------------------------------------------------------------- /src/vma/proto/rule_table_mgr.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef RULE_TABLE_MGR_H 9 | #define RULE_TABLE_MGR_H 10 | 11 | #include 12 | #include 13 | #include "vma/infra/cache_subject_observer.h" 14 | #include "vma/proto/netlink_socket_mgr.h" 15 | #include "rule_entry.h" 16 | 17 | /* 18 | * This class manages routing rule related operation such as getting rules from kernel, 19 | * finding table ID for given destination info and cashing usage history for rule table. 20 | */ 21 | class rule_table_mgr : public netlink_socket_mgr, public cache_table_mgr*> 22 | { 23 | public: 24 | rule_table_mgr(); 25 | 26 | rule_entry* create_new_entry(route_rule_table_key key, const observer *obs); 27 | void update_entry(rule_entry* p_ent); 28 | bool rule_resolve(route_rule_table_key key, std::deque &table_id_list); 29 | 30 | protected: 31 | virtual bool parse_entry(struct nl_object *nl_obj, void *p_val_context); 32 | virtual void update_tbl(); 33 | 34 | private: 35 | 36 | void parse_attr(struct rtnl_rule *rule, rule_val *p_val); 37 | 38 | bool find_rule_val(route_rule_table_key key, std::deque* &p_val); 39 | bool is_matching_rule(route_rule_table_key rrk, rule_val* p_val); 40 | }; 41 | 42 | extern rule_table_mgr* g_p_rule_table_mgr; 43 | 44 | #endif /* RULE_TABLE_MGR_H */ 45 | -------------------------------------------------------------------------------- /src/vma/sock/cleanable_obj.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef CLEANABLE_OBJ_H_ 9 | #define CLEANABLE_OBJ_H_ 10 | 11 | // This interface should be implemented by classes that we do not want to delete explicitly. 12 | // For example, classes that inherit timer_handler should be deleted only from the context of the internal thread. 13 | // Instead of calling delete for the object, call clean_obj() which should handle the deletion of the object. 14 | class cleanable_obj 15 | { 16 | public: 17 | cleanable_obj(){ m_b_cleaned = false; }; 18 | 19 | virtual ~cleanable_obj(){}; 20 | 21 | /* This function should be used just for objects that 22 | * was allocated via new() (not by new[], nor by placement new, nor a local object on the stack, 23 | * nor a namespace-scope / global, nor a member of another object; but by plain ordinary new) 24 | */ 25 | virtual void clean_obj(){ 26 | set_cleaned(); 27 | delete this; 28 | }; 29 | 30 | bool is_cleaned(){ return m_b_cleaned; }; 31 | 32 | protected: 33 | 34 | void set_cleaned(){ m_b_cleaned = true; }; 35 | 36 | private: 37 | 38 | bool m_b_cleaned; // indicate that clean_obj() was called. 39 | }; 40 | 41 | #endif /* CLEANABLE_OBJ_H_ */ 42 | -------------------------------------------------------------------------------- /src/vma/sock/pkt_rcvr_sink.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef PKT_RECVR_SINK_H 9 | #define PKT_RECVR_SINK_H 10 | 11 | class mem_buf_desc_t; 12 | class flow_tuple_with_local_if; 13 | class ring; 14 | 15 | /* 16 | * Class pkt_rcvr_sink 17 | * An object must implement pkt_rcvr_sink to register with ib_conn_mgr_base 18 | * The rx_joined_notify_cb() will be called when the IBCM is ready to start 19 | * receiving packets (MC join is complete and CQ is mapped). 20 | * The rx_diconnect_notify_cb() will be called before the IB stops receiving 21 | * packets (CQ is being removed and MC leave is called). 22 | * The rx_pkt_notify_cb() will be called when a ip packet is in the ready q for the socket. 23 | * The implementing object should register the information and release calling context immediately. 24 | * When no packet receivers (or transmitters) are registered the objects will be deleted 25 | */ 26 | class pkt_rcvr_sink 27 | { 28 | public: 29 | virtual ~pkt_rcvr_sink() {}; 30 | 31 | // Callback from lower layer notifying new receive packets 32 | // Return: 'true' if object queuing this receive packet 33 | // 'false' if not interested in this receive packet 34 | virtual bool rx_input_cb(mem_buf_desc_t* p_rx_pkt_mem_buf_desc_info, void* pv_fd_ready_array) = 0; 35 | 36 | // Callback from lower layer notifying completion of RX registration process 37 | virtual void rx_add_ring_cb(flow_tuple_with_local_if &flow_key, ring* p_ring) = 0; 38 | 39 | // Callback from lower layer notifying before RX resources deallocation 40 | virtual void rx_del_ring_cb(flow_tuple_with_local_if &flow_key, ring* p_ring) = 0; 41 | }; 42 | 43 | #endif 44 | -------------------------------------------------------------------------------- /src/vma/sock/pkt_sndr_source.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef PKT_SNDR_SOURCE_H 9 | #define PKT_SNDR_SOURCE_H 10 | 11 | /** 12 | * @class pkt_sndr_source 13 | * An object must implement pkt_sndr_source to register with ib_conn_mgr_base 14 | * When no packet transmitters (or receivers) are registered the objects will be 15 | * deleted. 16 | */ 17 | class pkt_sndr_source 18 | { 19 | public: 20 | virtual ~pkt_sndr_source() {}; 21 | }; 22 | 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/vma/util/data_updater.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "data_updater.h" 8 | 9 | data_updater::~data_updater() 10 | { 11 | 12 | } 13 | 14 | header_ttl_updater::header_ttl_updater(uint8_t ttl, bool is_multicast) 15 | : data_updater() 16 | , m_ttl(ttl) 17 | , m_is_multicast(is_multicast) 18 | { 19 | 20 | } 21 | 22 | bool header_ttl_updater::update_field(dst_entry &dst) 23 | { 24 | if ((IN_MULTICAST_N(dst.get_dst_addr()) && m_is_multicast) || 25 | (!IN_MULTICAST_N(dst.get_dst_addr()) && !m_is_multicast)) { 26 | dst.set_ip_ttl(m_ttl); 27 | } 28 | return true; 29 | } 30 | 31 | header_pcp_updater::header_pcp_updater(uint8_t pcp) 32 | : data_updater() 33 | , m_pcp(pcp) 34 | { 35 | 36 | } 37 | 38 | bool header_pcp_updater::update_field(dst_entry &dst) 39 | { 40 | return dst.set_pcp(m_pcp); 41 | } 42 | 43 | header_tos_updater::header_tos_updater(uint8_t tos) 44 | : data_updater() 45 | , m_tos(tos) 46 | { 47 | 48 | } 49 | 50 | bool header_tos_updater::update_field(dst_entry &dst) 51 | { 52 | dst.set_ip_tos(m_tos); 53 | return true; 54 | } 55 | 56 | ring_alloc_logic_updater::ring_alloc_logic_updater(int fd, lock_base & socket_lock, 57 | resource_allocation_key & ring_alloc_logic, 58 | socket_stats_t* socket_stats) 59 | : data_updater() 60 | , m_fd(fd) 61 | , m_socket_lock(socket_lock) 62 | , m_key(ring_alloc_logic) 63 | , m_sock_stats(socket_stats) 64 | { 65 | 66 | } 67 | 68 | bool ring_alloc_logic_updater::update_field(dst_entry &dst) 69 | { 70 | if (dst.update_ring_alloc_logic(m_fd, m_socket_lock, m_key)) 71 | m_sock_stats->counters.n_tx_migrations++; 72 | 73 | return true; 74 | } 75 | -------------------------------------------------------------------------------- /src/vma/util/data_updater.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef SRC_VMA_UTIL_DATA_UPDATER_H_ 8 | #define SRC_VMA_UTIL_DATA_UPDATER_H_ 9 | 10 | #include "vma/proto/dst_entry.h" 11 | 12 | class data_updater { 13 | public: 14 | data_updater() {}; 15 | virtual ~data_updater() = 0; 16 | virtual bool update_field(dst_entry &dst) = 0; 17 | }; 18 | 19 | class header_ttl_updater: public data_updater { 20 | public: 21 | header_ttl_updater(uint8_t ttl, bool is_unicast); 22 | virtual ~header_ttl_updater() {}; 23 | virtual bool update_field(dst_entry &hdr); 24 | private: 25 | uint8_t m_ttl; 26 | bool m_is_multicast; 27 | }; 28 | 29 | class header_pcp_updater: public data_updater { 30 | public: 31 | header_pcp_updater(uint8_t pcp); 32 | virtual ~header_pcp_updater() {}; 33 | virtual bool update_field(dst_entry &hdr); 34 | private: 35 | uint32_t m_pcp; 36 | }; 37 | 38 | class header_tos_updater: public data_updater { 39 | public: 40 | header_tos_updater(uint8_t pcp); 41 | virtual ~header_tos_updater() {}; 42 | virtual bool update_field(dst_entry &hdr); 43 | private: 44 | uint8_t m_tos; 45 | }; 46 | 47 | class ring_alloc_logic_updater: public data_updater { 48 | public: 49 | ring_alloc_logic_updater(int fd, lock_base & socket_lock, 50 | resource_allocation_key & ring_alloc_logic, 51 | socket_stats_t* socket_stats); 52 | virtual ~ring_alloc_logic_updater() {}; 53 | virtual bool update_field(dst_entry &hdr); 54 | private: 55 | int m_fd; 56 | lock_base & m_socket_lock; 57 | resource_allocation_key & m_key; 58 | socket_stats_t* m_sock_stats; 59 | }; 60 | #endif /* SRC_VMA_UTIL_DATA_UPDATER_H_ */ 61 | -------------------------------------------------------------------------------- /src/vma/util/if.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef VMA_IF_H_ 9 | #define VMA_IF_H_ 10 | 11 | #include 12 | #include 13 | 14 | /* defined in net/if.h but that conflicts with linux/if.h... */ 15 | extern "C" unsigned int if_nametoindex (__const char *__ifname) __THROW; 16 | extern "C" char *if_indextoname (unsigned int __ifindex, char *__ifname) __THROW; 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /src/vma/util/to_str.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | /* This class should be inherited by all classed that need to be printed 9 | */ 10 | #ifndef TO_STR_H_ 11 | #define TO_STR_H_ 12 | 13 | #include 14 | 15 | /* coverity[missing_move_assignment] */ 16 | class tostr 17 | { 18 | public: 19 | virtual ~tostr(){}; 20 | virtual const std::string to_str() const { return std::string(""); }; 21 | }; 22 | 23 | #endif /* TO_STR_H_ */ 24 | -------------------------------------------------------------------------------- /src/vma/util/valgrind.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef VMA_VALGRIND_H_ 9 | #define VMA_VALGRIND_H_ 10 | 11 | #ifdef HAVE_CONFIG_H 12 | # include "config.h" 13 | #endif 14 | 15 | /* Valgrind compatibility */ 16 | #ifndef NVALGRIND 17 | # include 18 | # ifndef VALGRIND_MAKE_MEM_DEFINED 19 | # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE(p, n) 20 | # endif 21 | # ifndef VALGRIND_MAKE_MEM_UNDEFINED 22 | # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE(p, n) 23 | # endif 24 | #else 25 | # define VALGRIND_MAKE_MEM_DEFINED(p, n) 26 | # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 27 | # define VALGRIND_MAKE_MEM_NOACCESS(p, n) 28 | # define VALGRIND_CREATE_MEMPOOL(n,p,x) 29 | # define VALGRIND_DESTROY_MEMPOOL(p) 30 | # define VALGRIND_MEMPOOL_ALLOC(n,p,x) 31 | # define VALGRIND_MEMPOOL_FREE(n,p) 32 | # define RUNNING_ON_VALGRIND 0 33 | #endif 34 | 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /src/vma/util/wakeup.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "utils/bullseye.h" 9 | #include "vlogger/vlogger.h" 10 | #include "wakeup.h" 11 | #include 12 | 13 | #define MODULE_NAME "wakeup" 14 | 15 | #define wkup_logpanic __log_info_panic 16 | #define wkup_logerr __log_info_err 17 | #define wkup_logwarn __log_info_warn 18 | #define wkup_loginfo __log_info_info 19 | #define wkup_logdbg __log_info_dbg 20 | #define wkup_logfunc __log_info_func 21 | #define wkup_logfuncall __log_info_funcall 22 | #define wkup_entry_dbg __log_entry_dbg 23 | 24 | #undef MODULE_HDR_INFO 25 | #define MODULE_HDR_INFO MODULE_NAME "[epfd=%d]:%d:%s() " 26 | #undef __INFO__ 27 | #define __INFO__ m_epfd 28 | 29 | wakeup::wakeup() 30 | { 31 | m_epfd = 0; 32 | m_is_sleeping = 0; 33 | memset(&m_ev, 0, sizeof(m_ev)); 34 | } 35 | void wakeup::going_to_sleep() 36 | { 37 | BULLSEYE_EXCLUDE_BLOCK_START 38 | if(likely(m_epfd)) 39 | m_is_sleeping++; 40 | else 41 | { 42 | wkup_logerr(" m_epfd is not initialized - cannot use wakeup mechanism\n"); 43 | m_is_sleeping = 0; 44 | } 45 | BULLSEYE_EXCLUDE_BLOCK_END 46 | } 47 | 48 | void wakeup::wakeup_set_epoll_fd(int epfd) 49 | { 50 | m_epfd = epfd; 51 | } 52 | -------------------------------------------------------------------------------- /src/vma/util/wakeup.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef WAKEUP_H 9 | #define WAKEUP_H 10 | 11 | /** 12 | * wakeup class that adds a wakeup functionality to socket (tcp and udp) and epoll. 13 | */ 14 | #include 15 | #include "utils/lock_wrapper.h" 16 | 17 | class wakeup 18 | { 19 | public: 20 | wakeup(void); 21 | virtual ~wakeup() {}; 22 | virtual void do_wakeup() = 0; 23 | virtual bool is_wakeup_fd(int fd) = 0; 24 | virtual void remove_wakeup_fd() = 0; 25 | void going_to_sleep(); 26 | void return_from_sleep() { --m_is_sleeping; }; 27 | 28 | protected: 29 | virtual void wakeup_set_epoll_fd(int epfd); 30 | int m_is_sleeping; 31 | 32 | //lock_spin_recursive m_wakeup_lock; This lock is not needed for now. Maybe we will need it for epoll. 33 | 34 | int m_epfd; 35 | struct epoll_event m_ev; 36 | }; 37 | 38 | #endif /* WAKEUP_H */ 39 | -------------------------------------------------------------------------------- /src/vma/util/wakeup_pipe.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef WAKEUP_PIPE_H 9 | #define WAKEUP_PIPE_H 10 | 11 | /** 12 | * wakeup class that adds a wakeup functionality to socket (tcp and udp) and epoll using a pipe. 13 | */ 14 | #include "wakeup.h" 15 | #include "utils/atomic.h" 16 | 17 | class wakeup_pipe : public wakeup 18 | { 19 | public: 20 | wakeup_pipe(void); 21 | ~wakeup_pipe(); 22 | virtual void do_wakeup(); 23 | virtual inline bool is_wakeup_fd(int fd) 24 | { 25 | return fd == g_wakeup_pipes[0]; 26 | }; 27 | virtual void remove_wakeup_fd(); 28 | 29 | private: 30 | static int g_wakeup_pipes[2]; 31 | static atomic_t ref_count; 32 | }; 33 | 34 | #endif /* WAKEUP_PIPE_H */ 35 | -------------------------------------------------------------------------------- /tests/Makefile.am: -------------------------------------------------------------------------------- 1 | SUBDIRS := timetest gtest latency_test pps_test throughput_test 2 | 3 | EXTRA_DIST = \ 4 | timetest \ 5 | gtest \ 6 | async-echo-client \ 7 | benchmarking_test \ 8 | connect-disconnect \ 9 | extra_api_tests \ 10 | functionality \ 11 | listen \ 12 | low_pps_tcp_send_test \ 13 | mc_loop_test \ 14 | multithread_test \ 15 | server_test \ 16 | vma_perf_envelope \ 17 | reuse_ud_test.c \ 18 | select_t1.c 19 | -------------------------------------------------------------------------------- /tests/README_How_to_update_sockperf_in_VMA.txt: -------------------------------------------------------------------------------- 1 | As of Oct 2015, sockperf was entirely splitted out of VMA. 2 | sockperf is anyhow a standalone project in github (and previously in googlecode). 3 | Recently sockperf started to have an *.rpm and *.deb for itself. 4 | Resources: 5 | https://github.com/Mellanox/sockperf 6 | http://rpmfind.net/linux/rpm2html/search.php?query=sockperf 7 | -------------------------------------------------------------------------------- /tests/TODO: -------------------------------------------------------------------------------- 1 | - setsockopt tests 2 | - fork 3 | - ip fragmentation tests 4 | - multicast tests 5 | 6 | -------------------------------------------------------------------------------- /tests/api-support-check.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | #@copyright: 8 | #@author: Avner BenHanoch 9 | 10 | #@date: 18Oct2015 11 | # 12 | # This script performs ioctl/fcntl/setsockopt tests for verifying VMA coverage and behavior 13 | 14 | # example for usage: 15 | # LD_PRELOAD=libvma.so VMA_EXCEPTION_HANDLING=1 ./tests/api-support-check.py 16 | # 17 | import socket, sys, fcntl 18 | import struct, os 19 | 20 | def test_ioctl(sock): 21 | ifname = 'eth0' 22 | addr = socket.inet_ntoa(fcntl.ioctl( 23 | sock.fileno(), 24 | 0x8915, # SIOCGIFADDR 25 | struct.pack('256s', ifname) 26 | )[20:24]) 27 | return "ioctl test: %s=%s" % (ifname, addr) 28 | 29 | def test_fcntl(sock): 30 | rv = fcntl.fcntl(sock, fcntl.F_SETFL, os.O_NDELAY) 31 | 32 | lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0) 33 | rv = fcntl.fcntl(sock, fcntl.F_SETLKW, lockdata) 34 | return "fcntl test: returned with data of len=" + str(len(rv)) 35 | 36 | if __name__ == "__main__": 37 | print "testing TCP:" 38 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 39 | print test_ioctl(s) 40 | print test_fcntl(s) 41 | print "setsockopt test..."; s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) 42 | print "getsockopt test..."; s.getsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) 43 | 44 | print "testing UDP:" 45 | s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 46 | print test_ioctl(s) 47 | print test_fcntl(s) 48 | print "setsockopt test..."; s.setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1) 49 | print "getsockopt test..."; s.getsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1) 50 | -------------------------------------------------------------------------------- /tests/async-echo-client/echo-server.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | 8 | """ 9 | A simple echo server 10 | """ 11 | 12 | import socket, sys 13 | 14 | if (len(sys.argv) <3): 15 | print "Incorrect parameter : " + sys.argv[0] + " server-ip server-port" 16 | sys.exit(-1) 17 | 18 | 19 | host = sys.argv[1] 20 | port = int(sys.argv[2]) 21 | 22 | backlog = 5 23 | size = 1024 24 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 25 | s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 26 | s.bind((host,port)) 27 | s.listen(backlog) 28 | while 1: 29 | client, address = s.accept() 30 | data = client.recv(size) 31 | if data: 32 | client.send(data) 33 | client.close() 34 | -------------------------------------------------------------------------------- /tests/bindtodevice/client.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | #@copyright: 8 | #@author: Alex Rosenbaum 9 | 10 | #@date: 18May2016 11 | # 12 | # 13 | # 14 | # 15 | import socket, time, sys 16 | 17 | if (len(sys.argv) <3): 18 | print "In correct parameter : " + sys.argv[0] + " dst_ip_address dst_port src_ifname" 19 | sys.exit(-1) 20 | 21 | 22 | print "UDP target IP:port=<", sys.argv[1], ":", sys.argv[2], ">" 23 | print "ifname:", sys.argv[3] 24 | 25 | sock=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 26 | sock.setblocking(0) 27 | sock.setsockopt(socket.SOL_SOCKET, 25, sys.argv[3]+'\0') # SO_BINDTODEVICE 28 | sock.sendto("HELLO WORLD", (sys.argv[1], int(sys.argv[2]))) 29 | time.sleep(1) 30 | sock.close() 31 | -------------------------------------------------------------------------------- /tests/extra_api_tests/tcp_zcopy_cb/README: -------------------------------------------------------------------------------- 1 | Test Name: 2 | extra_APIs_callback 3 | 4 | Author(s): 5 | Ahmad Shanably ashanably@asaltech.com 6 | 7 | Short description: 8 | This is a client server test built to test callback functionality 9 | of VMA extra API for TCP connection. 10 | 11 | Supported OSes: 12 | Linux 13 | 14 | Description: 15 | This test used to filter received packet using user defined function that is registered 16 | by extra vma APIs (register_recv_callback()) and then choose one of following action: 17 | - receive packet using general receive functions. 18 | - free buffer that contain previously held packet, and then hold new received packet 19 | - drop received packet 20 | 21 | This test uses TCP connection that have empty queue and handle received packet from application thread 22 | 23 | Known issues: 24 | None. 25 | 26 | To do: 27 | None -------------------------------------------------------------------------------- /tests/extra_api_tests/tcp_zcopy_cb/client.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2014-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef _CLIENT_H_ 8 | #define _CLIENT_H_ 9 | 10 | int client_main(); 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /tests/extra_api_tests/tcp_zcopy_cb/server.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2014-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef _SERVER_H_ 8 | #define _SERVER_H_ 9 | 10 | int server_main(); 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /tests/extra_api_tests/tcp_zcopy_cb/types.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2014-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef _TYPES_H_ 8 | #define _TYPES_H_ 9 | 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | int make_socket_non_blocking (int sfd); 16 | int select_read(int *fd, int sec, int usec); 17 | int sync_side(int sock, int front); 18 | 19 | enum callback_return{ 20 | RECV, 21 | HOLD, 22 | DROP 23 | } ; 24 | 25 | struct __attribute__ ((packed)) config_t { 26 | int server; 27 | char sip[20]; 28 | char mngip[20]; 29 | int port; 30 | int nonBlocking; 31 | int reuseAddr; 32 | enum callback_return callbackReturn; 33 | }; 34 | 35 | struct __attribute__ ((packed)) pending_packet_t{ 36 | int valid; 37 | int iovec_size; 38 | struct iovec iov[10]; 39 | struct vma_info_t *vma_info; 40 | }; 41 | 42 | #define INVALID_SOCKET -1 43 | 44 | #define CHECK_VALUE(verb, act_val, exp_val, cmd) if((exp_val) != (act_val)){ \ 45 | printf("Error in %s, expected value %d, actual value %d\n", \ 46 | (verb), (exp_val), (act_val)); \ 47 | cmd; \ 48 | } 49 | 50 | #define CHECK_NOT_EQUAL(verb, act_val, exp_val, cmd) if((exp_val) == (act_val)){ \ 51 | printf("Error in %s\n", (verb)); \ 52 | cmd; \ 53 | } 54 | 55 | #endif 56 | -------------------------------------------------------------------------------- /tests/gtest/README: -------------------------------------------------------------------------------- 1 | VMA Testing Environment 2 | ======================= 3 | 4 | This set of tests is based on Google Test C++ environment 5 | https://github.com/google/googletest 6 | 7 | Testing VMA Extended API 8 | ------------------------ 9 | 1. Enable EXTRA_API_ENABLED in tests/gtest/vma/vma_base.cc 10 | 2. Compile the gtests by issuing from VMA root directory: 11 | make -C tests/gtest 12 | 3. Launch tests by issuing: 13 | LD_PRELOAD=/libvma.so tests/gtest/gtest --addr=client_ip:server_ip 14 | 15 | Testing Environment 16 | ------------------- 17 | The VMA Extended API gtest environment requires that there be two interfaces 18 | connected back to back or via a switch. One is the server and the other is the 19 | client. 20 | 21 | -------------------------------------------------------------------------------- /tests/gtest/common/base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_COMMON_BASE_H_ 8 | #define TESTS_GTEST_COMMON_BASE_H_ 9 | 10 | #define DO_WHILE0(x) \ 11 | do { \ 12 | x \ 13 | } while (0) 14 | 15 | #define EXPECT_LE_ERRNO(val1, val2) \ 16 | DO_WHILE0(EXPECT_LE((val1), (val2)); \ 17 | if (val1 > val2) { log_trace("Failed. errno = %d\n", errno); }) 18 | 19 | #define EXPECT_EQ_ERRNO(val1, val2) \ 20 | DO_WHILE0(EXPECT_EQ((val1), (val2)); \ 21 | if (val1 != val2) { log_trace("Failed. errno = %d\n", errno); }) 22 | 23 | /** 24 | * Base class for tests 25 | */ 26 | class test_base { 27 | public: 28 | static int sock_noblock(int fd); 29 | static int event_wait(struct epoll_event *event); 30 | static int wait_fork(int pid); 31 | static int set_socket_rcv_timeout(int fd, int timeout_sec); 32 | static void handle_signal(int signo); 33 | 34 | protected: 35 | test_base(); 36 | virtual ~test_base(); 37 | 38 | protected: 39 | virtual void cleanup(); 40 | virtual void init(); 41 | bool barrier(); 42 | void barrier_fork(int pid, bool sync_parent = false); 43 | bool child_fork_exit() { 44 | return m_break_signal; 45 | } 46 | 47 | struct sockaddr_in client_addr; 48 | struct sockaddr_in server_addr; 49 | struct sockaddr_in remote_addr; 50 | struct sockaddr_in bogus_addr; 51 | uint16_t port; 52 | uint16_t bogus_port; 53 | 54 | private: 55 | static void *thread_func(void *arg); 56 | 57 | pthread_barrier_t m_barrier; 58 | int m_efd; 59 | uint64_t m_efd_signal; 60 | static int m_break_signal; 61 | }; 62 | 63 | #endif /* TESTS_GTEST_COMMON_BASE_H_ */ 64 | -------------------------------------------------------------------------------- /tests/gtest/common/cmn.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_COMMON_CMN_H_ 8 | #define TESTS_GTEST_COMMON_CMN_H_ 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | namespace cmn { 15 | 16 | class test_skip_exception : public std::exception { 17 | public: 18 | test_skip_exception(const std::string& reason = "") : m_reason("[ SKIPPED ] ") { 19 | m_reason += reason; 20 | } 21 | virtual ~test_skip_exception() _GLIBCXX_NOTHROW { 22 | } 23 | 24 | const char* what() const _GLIBCXX_NOTHROW { 25 | return m_reason.c_str(); 26 | } 27 | 28 | private: 29 | std::string m_reason; 30 | }; 31 | 32 | #define SKIP_TRUE(_expr, _reason) \ 33 | if (!(_expr)) { \ 34 | log_warn(_reason "\n"); \ 35 | GTEST_SKIP(); \ 36 | } 37 | 38 | } /* namespace: cmn */ 39 | 40 | #endif /* TESTS_GTEST_COMMON_CMN_H_ */ 41 | -------------------------------------------------------------------------------- /tests/gtest/common/log.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_COMMON_LOG_H_ 8 | #define TESTS_GTEST_COMMON_LOG_H_ 9 | 10 | extern struct gtest_configure_t gtest_conf; 11 | 12 | #define log_fatal(fmt, ...) \ 13 | do { \ 14 | if (gtest_conf.log_level > 0) { \ 15 | fprintf(stderr, "[ FATAL ] " fmt, ##__VA_ARGS__); \ 16 | } \ 17 | exit(1); \ 18 | } while (0) 19 | 20 | #define log_error(fmt, ...) \ 21 | do { \ 22 | if (gtest_conf.log_level > 1) \ 23 | fprintf(stderr, "[ ERROR ] " fmt, ##__VA_ARGS__); \ 24 | } while (0) 25 | 26 | #define log_warn(fmt, ...) \ 27 | do { \ 28 | if (gtest_conf.log_level > 2) \ 29 | fprintf(stderr, "[ WARN ] " fmt, ##__VA_ARGS__); \ 30 | } while (0) 31 | 32 | #define log_info(fmt, ...) \ 33 | do { \ 34 | if (gtest_conf.log_level > 3) \ 35 | printf("\033[0;3%sm" "[ INFO ] " fmt "\033[m", "4", ##__VA_ARGS__); \ 36 | } while (0) 37 | 38 | #define log_trace(fmt, ...) \ 39 | do { \ 40 | if (gtest_conf.log_level > 4) \ 41 | printf("\033[0;3%sm" "[ TRACE ] " fmt "\033[m", "7", ##__VA_ARGS__); \ 42 | } while (0) 43 | 44 | #endif /* TESTS_GTEST_COMMON_LOG_H_ */ 45 | -------------------------------------------------------------------------------- /tests/gtest/googletest/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2008, Google Inc. 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are 6 | met: 7 | 8 | * Redistributions of source code must retain the above copyright 9 | notice, this list of conditions and the following disclaimer. 10 | * Redistributions in binary form must reproduce the above 11 | copyright notice, this list of conditions and the following disclaimer 12 | in the documentation and/or other materials provided with the 13 | distribution. 14 | * Neither the name of Google Inc. nor the names of its 15 | contributors may be used to endorse or promote products derived from 16 | this software without specific prior written permission. 17 | 18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | -------------------------------------------------------------------------------- /tests/gtest/googletest/README.md: -------------------------------------------------------------------------------- 1 | # Google Test 2 | 3 | This directory contains minimum set of needed source code of Google Test release-1.7.0 4 | (see full package at https://github.com/google/googletest/releases/tag/release-1.7.0) 5 | with following back ported commits: 6 | 7 | 1. commit 15dde751ff5ea0f21f2a7182186be4564f30adc7 8 | Author: Arseny Aprelev 9 | Date: Mon Oct 1 16:47:09 2018 -0400 10 | 11 | Merge 2ce0685f76a4db403b7b2650433a584c150f2108 into 75e834700d19aa373b428c7c746f951737354c28 12 | 13 | Closes #1544 14 | With refinements and changes 15 | 16 | PiperOrigin-RevId: 215273083 17 | 18 | 2. commit 59f90a338bce2376b540ee239cf4e269bf6d68ad (HEAD) 19 | Author: durandal 20 | Date: Tue Oct 23 15:31:17 2018 -0400 21 | 22 | Googletest export 23 | 24 | Honor GTEST_SKIP() in SetUp(). 25 | 26 | PiperOrigin-RevId: 218387359 27 | -------------------------------------------------------------------------------- /tests/gtest/googletest/src/gtest_main.cc: -------------------------------------------------------------------------------- 1 | // Copyright 2006, Google Inc. 2 | // All rights reserved. 3 | // 4 | // Redistribution and use in source and binary forms, with or without 5 | // modification, are permitted provided that the following conditions are 6 | // met: 7 | // 8 | // * Redistributions of source code must retain the above copyright 9 | // notice, this list of conditions and the following disclaimer. 10 | // * Redistributions in binary form must reproduce the above 11 | // copyright notice, this list of conditions and the following disclaimer 12 | // in the documentation and/or other materials provided with the 13 | // distribution. 14 | // * Neither the name of Google Inc. nor the names of its 15 | // contributors may be used to endorse or promote products derived from 16 | // this software without specific prior written permission. 17 | // 18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | 30 | #include 31 | 32 | #include "gtest/gtest.h" 33 | 34 | GTEST_API_ int main(int argc, char **argv) { 35 | printf("Running main() from gtest_main.cc\n"); 36 | testing::InitGoogleTest(&argc, argv); 37 | return RUN_ALL_TESTS(); 38 | } 39 | -------------------------------------------------------------------------------- /tests/gtest/mix/mix_base.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | #include "common/def.h" 7 | 8 | #include "mix_base.h" 9 | 10 | void mix_base::SetUp() 11 | { 12 | errno = EOK; 13 | } 14 | 15 | void mix_base::TearDown() 16 | { 17 | 18 | } 19 | 20 | -------------------------------------------------------------------------------- /tests/gtest/mix/mix_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | #ifndef TESTS_GTEST_MIX_BASE_H_ 7 | #define TESTS_GTEST_MIX_BASE_H_ 8 | 9 | #include "common/def.h" 10 | #include "common/log.h" 11 | #include "common/sys.h" 12 | #include "common/base.h" 13 | 14 | 15 | class mix_base : public testing::Test, public test_base 16 | { 17 | protected: 18 | virtual void SetUp(); 19 | virtual void TearDown(); 20 | }; 21 | 22 | #endif //TESTS_GTEST_MIX_VASE_H_ 23 | 24 | -------------------------------------------------------------------------------- /tests/gtest/sock/sock_base.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | 12 | #include "sock_base.h" 13 | 14 | void sock_base::SetUp() 15 | { 16 | errno = EOK; 17 | } 18 | 19 | void sock_base::TearDown() 20 | { 21 | } 22 | -------------------------------------------------------------------------------- /tests/gtest/sock/sock_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_SOCK_BASE_H_ 8 | #define TESTS_GTEST_SOCK_BASE_H_ 9 | 10 | 11 | /** 12 | * SOCK Base class for tests 13 | */ 14 | class sock_base : public testing::Test, public test_base { 15 | protected: 16 | virtual void SetUp(); 17 | virtual void TearDown(); 18 | }; 19 | 20 | #endif /* TESTS_GTEST_SOCK_BASE_H_ */ 21 | -------------------------------------------------------------------------------- /tests/gtest/tcp/tcp_base.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | 12 | #include "tcp_base.h" 13 | 14 | void tcp_base::SetUp() 15 | { 16 | errno = EOK; 17 | } 18 | 19 | void tcp_base::TearDown() 20 | { 21 | } 22 | 23 | int tcp_base::sock_create(bool reuse_addr) 24 | { 25 | int rc; 26 | int fd; 27 | int opt_val = (reuse_addr ? 1 : 0); 28 | 29 | fd = socket(PF_INET, SOCK_STREAM, IPPROTO_IP); 30 | if (fd < 0) { 31 | log_error("failed socket() %s\n", strerror(errno)); 32 | return -1; 33 | } 34 | 35 | rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt_val, sizeof(opt_val)); 36 | if (rc < 0) { 37 | log_error("failed setsockopt(SO_REUSEADDR) %s\n", strerror(errno)); 38 | goto err; 39 | } 40 | 41 | return fd; 42 | 43 | err: 44 | close(fd); 45 | 46 | return (-1); 47 | } 48 | 49 | int tcp_base::sock_create_nb(void) 50 | { 51 | int rc; 52 | int fd; 53 | int opt_val = 0; 54 | 55 | fd = socket(PF_INET, SOCK_STREAM, IPPROTO_IP); 56 | if (fd < 0) { 57 | log_error("failed socket() %s\n", strerror(errno)); 58 | goto err; 59 | } 60 | 61 | rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt_val, sizeof(opt_val)); 62 | if (rc < 0) { 63 | log_error("failed setsockopt(SO_REUSEADDR) %s\n", strerror(errno)); 64 | goto err; 65 | } 66 | 67 | rc = test_base::sock_noblock(fd); 68 | if (rc < 0) { 69 | log_error("failed sock_noblock() %s\n", strerror(errno)); 70 | goto err; 71 | } 72 | 73 | return fd; 74 | 75 | err: 76 | close(fd); 77 | 78 | return (-1); 79 | } 80 | -------------------------------------------------------------------------------- /tests/gtest/tcp/tcp_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_TCP_BASE_H_ 8 | #define TESTS_GTEST_TCP_BASE_H_ 9 | 10 | 11 | /** 12 | * TCP Base class for tests 13 | */ 14 | class tcp_base : virtual public testing::Test, virtual public test_base { 15 | public: 16 | static int sock_create(bool reuse_addr = false); 17 | static int sock_create_nb(void); 18 | 19 | protected: 20 | virtual void SetUp(); 21 | virtual void TearDown(); 22 | void peer_wait(int fd) { 23 | char keep_alive_check = 1; 24 | struct timeval tv; 25 | 26 | tv.tv_sec = 3; 27 | tv.tv_usec = 0; 28 | setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (const char*)&tv, sizeof tv); 29 | while (0 < send(fd, &keep_alive_check, sizeof(keep_alive_check), MSG_NOSIGNAL)) { 30 | usleep(100); 31 | } 32 | return ; 33 | } 34 | }; 35 | 36 | #endif /* TESTS_GTEST_TCP_BASE_H_ */ 37 | -------------------------------------------------------------------------------- /tests/gtest/tcp/tcp_connect_nb.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | 12 | #include "tcp_base.h" 13 | 14 | class tcp_connect_nb : public tcp_base {}; 15 | 16 | /** 17 | * @test tcp_connect_nb.ti_1 18 | * @brief 19 | * Loop of blocking connect() to ip on the same node 20 | * @details 21 | */ 22 | TEST_F(tcp_connect_nb, ti_1) { 23 | } 24 | -------------------------------------------------------------------------------- /tests/gtest/tcp/tcp_sendto.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | 12 | #include "tcp_base.h" 13 | 14 | 15 | class tcp_sendto : public tcp_base {}; 16 | 17 | /** 18 | * @test tcp_sendto.ti_1 19 | * @brief 20 | * send() invalid socket fd 21 | * @details 22 | */ 23 | TEST_F(tcp_sendto, ti_1) { 24 | int rc = EOK; 25 | int fd; 26 | char buf[] = "hello"; 27 | 28 | fd = tcp_base::sock_create(); 29 | ASSERT_LE(0, fd); 30 | 31 | errno = EOK; 32 | rc = bind(fd, (struct sockaddr *)&client_addr, sizeof(client_addr)); 33 | EXPECT_EQ(EOK, errno); 34 | EXPECT_EQ(0, rc); 35 | 36 | errno = EOK; 37 | rc = sendto(0xFF, (void *)buf, sizeof(buf), 0, 38 | (struct sockaddr *)&server_addr, sizeof(server_addr)); 39 | EXPECT_EQ(EBADF, errno); 40 | EXPECT_EQ(-1, rc); 41 | 42 | close(fd); 43 | } 44 | 45 | /** 46 | * @test tcp_sendto.ti_2 47 | * @brief 48 | * send() no connection 49 | * @details 50 | */ 51 | TEST_F(tcp_sendto, ti_2) { 52 | int rc = EOK; 53 | int fd; 54 | char buf[] = "hello"; 55 | 56 | fd = tcp_base::sock_create(); 57 | ASSERT_LE(0, fd); 58 | 59 | errno = EOK; 60 | rc = bind(fd, (struct sockaddr *)&client_addr, sizeof(client_addr)); 61 | EXPECT_EQ(EOK, errno); 62 | EXPECT_EQ(0, rc); 63 | 64 | errno = EOK; 65 | (void)signal(SIGPIPE, SIG_IGN); 66 | rc = sendto(fd, (void *)buf, sizeof(buf), 0, 67 | (struct sockaddr *)&server_addr, sizeof(server_addr)); 68 | EXPECT_EQ(EPIPE, errno); 69 | EXPECT_EQ(-1, rc); 70 | (void)signal(SIGPIPE, SIG_DFL); 71 | 72 | close(fd); 73 | } 74 | -------------------------------------------------------------------------------- /tests/gtest/tcp/tcp_socket.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | 12 | #include "tcp_base.h" 13 | 14 | class tcp_socket : public tcp_base {}; 15 | 16 | /** 17 | * @test tcp_socket.ti_1 18 | * @brief 19 | * Create TCP socket 20 | * @details 21 | */ 22 | TEST_F(tcp_socket, ti_1) { 23 | int fd; 24 | 25 | fd = socket(PF_INET, SOCK_STREAM, IPPROTO_IP); 26 | EXPECT_LE(0, fd); 27 | EXPECT_EQ(errno, EOK); 28 | 29 | close(fd); 30 | } 31 | -------------------------------------------------------------------------------- /tests/gtest/udp/udp_base.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | 12 | #include "udp_base.h" 13 | 14 | void udp_base::SetUp() 15 | { 16 | errno = EOK; 17 | } 18 | 19 | void udp_base::TearDown() 20 | { 21 | } 22 | 23 | int udp_base::sock_create(void) 24 | { 25 | int rc; 26 | int fd; 27 | int opt_val = 0; 28 | 29 | fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); 30 | if (fd < 0) { 31 | log_error("failed socket() %s\n", strerror(errno)); 32 | goto err; 33 | } 34 | 35 | rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt_val, sizeof(opt_val)); 36 | if (rc < 0) { 37 | log_error("failed setsockopt(SO_REUSEADDR) %s\n", strerror(errno)); 38 | goto err; 39 | } 40 | 41 | return fd; 42 | 43 | err: 44 | close(fd); 45 | 46 | return (-1); 47 | } 48 | 49 | int udp_base::sock_create_nb(void) 50 | { 51 | int rc; 52 | int fd; 53 | int opt_val = 0; 54 | 55 | fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP); 56 | if (fd < 0) { 57 | log_error("failed socket() %s\n", strerror(errno)); 58 | goto err; 59 | } 60 | 61 | rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt_val, sizeof(opt_val)); 62 | if (rc < 0) { 63 | log_error("failed setsockopt(SO_REUSEADDR) %s\n", strerror(errno)); 64 | goto err; 65 | } 66 | 67 | rc = test_base::sock_noblock(fd); 68 | if (rc < 0) { 69 | log_error("failed sock_noblock() %s\n", strerror(errno)); 70 | goto err; 71 | } 72 | 73 | return fd; 74 | 75 | err: 76 | close(fd); 77 | 78 | return (-1); 79 | } 80 | -------------------------------------------------------------------------------- /tests/gtest/udp/udp_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_UDP_BASE_H_ 8 | #define TESTS_GTEST_UDP_BASE_H_ 9 | 10 | 11 | /** 12 | * UDP Base class for tests 13 | */ 14 | class udp_base : public testing::Test, public test_base { 15 | public: 16 | static int sock_create(void); 17 | static int sock_create_nb(void); 18 | 19 | protected: 20 | virtual void SetUp(); 21 | virtual void TearDown(); 22 | }; 23 | 24 | #endif /* TESTS_GTEST_UDP_BASE_H_ */ 25 | -------------------------------------------------------------------------------- /tests/gtest/vma/vma_base.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | #include "common/cmn.h" 12 | 13 | #include "vma_base.h" 14 | 15 | void vma_base::SetUp() 16 | { 17 | errno = EOK; 18 | 19 | #if defined(EXTRA_API_ENABLED) && (EXTRA_API_ENABLED == 1) 20 | vma_api = vma_get_api(); 21 | SKIP_TRUE(vma_api, "vma test suite should be launched under libvma.so"); 22 | #else 23 | SKIP_TRUE(0, "Tests should be compiled as make CPPFLAGS=-DEXTRA_API_ENABLED=1") 24 | #endif /* EXTRA_API_ENABLED */ 25 | } 26 | 27 | void vma_base::TearDown() 28 | { 29 | } 30 | -------------------------------------------------------------------------------- /tests/gtest/vma/vma_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_VMA_BASE_H_ 8 | #define TESTS_GTEST_VMA_BASE_H_ 9 | 10 | #include 11 | 12 | /** 13 | * To enable vma tests you need to set below EXTRA_API_ENABLED to 1 14 | * or you can add the following CPPFLAG during compilation 'make CPPFLAGS="-DEXTRA_API_ENABLED=1"' 15 | */ 16 | #ifndef EXTRA_API_ENABLED 17 | #define EXTRA_API_ENABLED 0 18 | #endif 19 | 20 | /** 21 | * VMA Base class for tests 22 | */ 23 | class vma_base : virtual public testing::Test, virtual public test_base { 24 | protected: 25 | virtual void SetUp(); 26 | virtual void TearDown(); 27 | 28 | protected: 29 | #if defined(EXTRA_API_ENABLED) && (EXTRA_API_ENABLED == 1) 30 | struct vma_api_t *vma_api; 31 | #endif /* EXTRA_API_ENABLED */ 32 | }; 33 | 34 | #endif /* TESTS_GTEST_VMA_BASE_H_ */ 35 | -------------------------------------------------------------------------------- /tests/gtest/vmad/vmad_base.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #ifndef TESTS_GTEST_VMAD_BASE_H_ 8 | #define TESTS_GTEST_VMAD_BASE_H_ 9 | 10 | 11 | /** 12 | * VMAD Base class for tests 13 | */ 14 | class vmad_base : public testing::Test, public test_base { 15 | protected: 16 | virtual void SetUp(); 17 | virtual void TearDown(); 18 | 19 | int msg_init(pid_t pid); 20 | int msg_exit(pid_t pid); 21 | 22 | protected: 23 | pid_t m_self_pid; 24 | pid_t m_vmad_pid; 25 | 26 | const char *m_base_name; 27 | 28 | /* socket used for communication with daemon */ 29 | int m_sock_fd; 30 | 31 | /* file descriptor that is tracked by daemon */ 32 | int m_pid_fd; 33 | 34 | /* unix socket name 35 | * size should be less than sockaddr_un.sun_path 36 | */ 37 | char m_sock_file[100]; 38 | 39 | /* name of pid file */ 40 | char m_pid_file[100]; 41 | 42 | /* server address */ 43 | struct sockaddr_un m_server_addr; 44 | }; 45 | 46 | #endif /* TESTS_GTEST_VMAD_BASE_H_ */ 47 | -------------------------------------------------------------------------------- /tests/gtest/vmad/vmad_state.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | #include "common/def.h" 8 | #include "common/log.h" 9 | #include "common/sys.h" 10 | #include "common/base.h" 11 | #include "common/cmn.h" 12 | 13 | #include "vmad_base.h" 14 | 15 | #include "src/vma/util/agent_def.h" 16 | #include "src/vma/lwip/tcp.h" 17 | 18 | class vmad_state : public vmad_base { 19 | protected: 20 | void SetUp() 21 | { 22 | vmad_base::SetUp(); 23 | 24 | m_pid = 0x53544154; 25 | memset(&m_data, 0, sizeof(m_data)); 26 | m_data.hdr.code = VMA_MSG_STATE; 27 | m_data.hdr.ver = VMA_AGENT_VER; 28 | m_data.hdr.pid = m_pid; 29 | } 30 | void TearDown() 31 | { 32 | vmad_base::TearDown(); 33 | } 34 | 35 | protected: 36 | struct vma_msg_state m_data; 37 | pid_t m_pid; 38 | }; 39 | 40 | /** 41 | * @test vmad_state.ti_1 42 | * @brief 43 | * Send valid VMA_MSG_STATE 44 | * @details 45 | */ 46 | TEST_F(vmad_state, ti_1) { 47 | int rc = 0; 48 | 49 | rc = vmad_base::msg_init(m_pid); 50 | ASSERT_LT(0, rc); 51 | 52 | m_data.fid = 0; 53 | m_data.state = ESTABLISHED; 54 | m_data.type = SOCK_STREAM; 55 | m_data.src_ip = client_addr.sin_addr.s_addr; 56 | m_data.src_port = client_addr.sin_port; 57 | m_data.dst_ip = server_addr.sin_addr.s_addr; 58 | m_data.dst_port = server_addr.sin_port; 59 | 60 | errno = 0; 61 | rc = send(m_sock_fd, &m_data, sizeof(m_data), 0); 62 | EXPECT_EQ(0, errno); 63 | EXPECT_EQ((int)sizeof(m_data), rc); 64 | 65 | rc = vmad_base::msg_exit(m_pid); 66 | ASSERT_LT(0, rc); 67 | } 68 | -------------------------------------------------------------------------------- /tests/latency_test/Makefile.am: -------------------------------------------------------------------------------- 1 | noinst_PROGRAMS = udp_lat tcp_lat 2 | 3 | AM_CPPFLAGS := \ 4 | -I$(top_builddir)/. -I$(top_srcdir)/. \ 5 | -I$(top_builddir)/src -I$(top_srcdir)/src 6 | 7 | udp_lat_SOURCES = udp_lat.c 8 | udp_lat_LDADD = -lrt 9 | 10 | tcp_lat_SOURCES = tcp_lat.cpp 11 | tcp_lat_LDADD = \ 12 | $(top_builddir)/src/utils/libutils.la 13 | 14 | udp_lat_DEPENDENCIES = Makefile.am Makefile.in Makefile 15 | tcp_lat_DEPENDENCIES = Makefile.am Makefile.in Makefile 16 | 17 | 18 | -------------------------------------------------------------------------------- /tests/listen/tcp_client.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | 8 | import sys 9 | from socket import * 10 | import time 11 | from collections import deque 12 | 13 | serverHost = sys.argv[1] 14 | serverPort = int(sys.argv[2]) 15 | l = [] 16 | d = deque() 17 | i = 0 18 | while True: 19 | time.sleep(0.001) 20 | sock = socket(AF_INET, SOCK_STREAM) 21 | sock.setblocking(0) 22 | sock.connect_ex((serverHost, serverPort)) # connect to server on the port 23 | #sock.send("Hello world") # send the data 24 | i += 1 25 | print "%s: Connecting #%03d..." % (time.strftime("%Y-%m-%d %H:%M:%S"), i) 26 | if len(d) == 10000: d.pop().close() 27 | d.append(sock) 28 | -------------------------------------------------------------------------------- /tests/listen/tcp_server.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | 8 | from socket import * 9 | import fcntl, os, sys 10 | import time 11 | from collections import deque 12 | 13 | 14 | BACKLOG=10 15 | myHost = sys.argv[1] 16 | myPort = int(sys.argv[2]) 17 | s = socket(AF_INET, SOCK_STREAM) # create a TCP socket 18 | s.bind((myHost, myPort)) 19 | s.listen(BACKLOG) 20 | d = deque() 21 | while True: 22 | #time.sleep(2) 23 | conn, addr = s.accept() 24 | if len(d) == 100: 25 | time.sleep(0.001) 26 | sock=d.pop() 27 | print "%s: Closing an accepted socket %s..." % (time.strftime("%Y-%m-%d %H:%M:%S"), str(sock)) 28 | sock.close() 29 | d.append(conn) 30 | -------------------------------------------------------------------------------- /tests/low_pps_tcp_send_test/readme.txt: -------------------------------------------------------------------------------- 1 | To compile it you simply need to run the following commands: 2 | >g++ -lpthread exchange.cpp -o exchange 3 | >g++ -lpthread -lrt trader.cpp -o trader 4 | 5 | The test app includes two applications - exchange and trader: 6 | Exchange: 7 | 1. Opens a MC socket and sends MC packets in a predefined rate (one every 10usec by default). 8 | 2. Open a UC TCP socket and blocks on recvfrom(). 9 | a. If an ORDER packet is received --> send ORD_ACK 10 | b. If a keep alive packet is received --> send KA_ACK 11 | 3. Every X MC packets (configurable) --> send a MC QUOTE packet. 12 | 13 | Trader: 14 | 1. Open one MC socket and one TCP socket. 15 | 2. On thread #1, the MC socket blocks on recv(). If it encounters the QUOTE packet it immediately sends a TPC ORDER packet through the TCP socket, and and measure the time it the send operation took. 16 | 3. On thread #2 (optional), the TCP socket blocks on recv(): 17 | a. Receives reply for ORDER packet (i.e. ORD_ACK) 18 | b. Receives reply for keep alive packet (i.e. KA_ACK) 19 | 4. On thread #3 (optional), the TCP socket send keep alive packet every X usecs (configurable) 20 | 21 | Running the application: 22 | 1. First run the exchange app on one server and then the trader on another. 23 | 2. If you run the app with no parameters (or with --help flag) you will get a usage print. 24 | All of the configurable parameters are described along with their default parameters. 25 | 3. There are only 2 mandatory parameters for the trader app (local interface IP and peer UC IP), and one mandatory parameter for the exchange app (local interface IP). 26 | 4. Make sure to attach each thread to different core, there are parameters to control it. 27 | 28 | -------------------------------------------------------------------------------- /tests/pps_test/Makefile.am: -------------------------------------------------------------------------------- 1 | noinst_PROGRAMS = pps_test 2 | 3 | AM_CPPFLAGS := \ 4 | -I$(top_builddir)/. -I$(top_srcdir)/. 5 | 6 | pps_test_SOURCES = pps_test.c 7 | pps_test_DEPENDENCIES = Makefile.am Makefile.in Makefile 8 | 9 | -------------------------------------------------------------------------------- /tests/resource_release_checker/server_socket_recreate_loop.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | #@copyright: 8 | #@author: Alex Rosenbaum 9 | 10 | #@date: 20160520 11 | # 12 | # 13 | import socket, select, os, time, sys, fcntl, errno 14 | 15 | def main(): 16 | 17 | argv = sys.argv 18 | if (len(argv) < 2): 19 | print "Incorrect parameter : " + argv[0] + " server-ip server-port-lower" 20 | sys.exit(-1) 21 | 22 | # read configuration 23 | IP = argv[1] 24 | PORT = int(argv[2]) 25 | 26 | loops = 4 27 | while loops > 0: 28 | print "socket create..." 29 | sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 30 | sock.bind((IP, int(PORT))) 31 | print ".. created ... sleep before continueing..." 32 | time.sleep (4) 33 | print "socket closing ..." 34 | sock.close() 35 | print ".. closed ... sleep before continueing..." 36 | time.sleep (4) 37 | loops -= 1 38 | 39 | if __name__ == "__main__": 40 | main() 41 | -------------------------------------------------------------------------------- /tests/server_test/Makefile.am: -------------------------------------------------------------------------------- 1 | noinst_PROGRAMS = server_perf 2 | 3 | AM_CPPFLAGS := \ 4 | -I$(top_builddir)/. \ 5 | -I$(top_builddir)/include 6 | 7 | server_perf_LDADD = -lboost_thread 8 | server_perf_SOURCES = server.cc client.cc main.cc options.cc vtime.cc 9 | server_perf_CXXFLAGS = -g 10 | 11 | 12 | -------------------------------------------------------------------------------- /tests/server_test/client.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef _CLIENT_H_ 9 | #define _CLIENT_H_ 10 | 11 | #include "vtime.h" 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | class options; 20 | 21 | class client { 22 | public: 23 | client(const options& opts); 24 | 25 | void run(); 26 | private: 27 | 28 | struct request { 29 | uint32_t id; 30 | uint64_t send_time; 31 | }; 32 | 33 | 34 | class connection : private boost::noncopyable { 35 | public: 36 | connection(unsigned id, const std::string& server, unsigned port, 37 | size_t packet_rate); 38 | ~connection(); 39 | 40 | void operator()(); 41 | 42 | std::string destination() const; 43 | 44 | private: 45 | struct packet { 46 | uint64_t psn; 47 | uint64_t send_time; 48 | }; 49 | 50 | const unsigned m_id; 51 | size_t m_packet_rate; 52 | size_t m_head, m_tail; 53 | struct sockaddr_in m_dest_addr; 54 | int m_sockfd; 55 | int m_epfd; 56 | packet m_sendbuf; 57 | packet m_recvbuf; 58 | uint64_t m_psn; 59 | size_t m_recv_count; 60 | size_t m_send_count; 61 | vtime::time_t m_start_time; 62 | vtime::time_t m_rtt_sum; 63 | }; 64 | 65 | typedef boost::shared_ptr connection_ptr; 66 | 67 | std::vector m_connections; 68 | }; 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /tests/server_test/main.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "client.h" 9 | #include "server.h" 10 | #include "options.h" 11 | 12 | 13 | int main(int argc, char **argv) 14 | { 15 | options opts(argc, argv); 16 | 17 | if (opts.is_server()) { 18 | server s(opts); 19 | s.run(); 20 | } else { 21 | client c(opts); 22 | c.run(); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /tests/server_test/options.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #include "options.h" 9 | 10 | #include 11 | #include 12 | 13 | 14 | options::options (int argc, char **argv) : 15 | m_port(13737), 16 | m_packet_rate(0), 17 | m_num_threads(1), 18 | m_window(65536) 19 | { 20 | char c; 21 | while ((c = getopt (argc, argv, "t:p:r:w:")) != -1) { 22 | switch (c) { 23 | case 't': 24 | m_num_threads = atoi(optarg); 25 | break; 26 | case 'p': 27 | m_port = atoi(optarg); 28 | break; 29 | case 'r': 30 | m_packet_rate = atol(optarg); 31 | break; 32 | case 'w': 33 | m_window = atol(optarg); 34 | break; 35 | } 36 | } 37 | 38 | if (optind < argc) { 39 | m_server = argv[optind]; 40 | } 41 | } 42 | 43 | const std::string options::server() const { 44 | return m_server; 45 | } 46 | 47 | unsigned options::port() const { 48 | return m_port; 49 | } 50 | 51 | unsigned options::packet_rate() const { 52 | return m_packet_rate; 53 | } 54 | 55 | unsigned options::num_threads() const { 56 | return m_num_threads; 57 | } 58 | 59 | size_t options::window() const { 60 | return m_window; 61 | } 62 | 63 | bool options::is_server() const { 64 | return m_server.empty(); 65 | } 66 | -------------------------------------------------------------------------------- /tests/server_test/options.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef _OPTIONS_H_ 9 | #define _OPTIONS_H_ 10 | 11 | #include 12 | 13 | class options { 14 | public: 15 | options (int argc, char **argv); 16 | 17 | const std::string server() const; 18 | 19 | unsigned port() const; 20 | 21 | unsigned packet_rate() const; 22 | 23 | unsigned num_threads() const; 24 | 25 | size_t window() const; 26 | 27 | bool is_server() const; 28 | 29 | private: 30 | std::string m_server; 31 | unsigned m_port; 32 | unsigned m_packet_rate; 33 | unsigned m_num_threads; 34 | size_t m_window; /* NUmber of requests to remember */ 35 | }; 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /tests/server_test/server.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef _SERVER_H_ 9 | #define _SERVER_H_ 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | class options; 16 | 17 | class server { 18 | public: 19 | server(const options& opts); 20 | ~server(); 21 | void run(); 22 | private: 23 | 24 | class worker : private boost::noncopyable { 25 | public: 26 | worker(int id, int sockfd); 27 | ~worker(); 28 | 29 | void operator()(); 30 | 31 | void process_message(); 32 | 33 | private: 34 | int m_id; 35 | int m_recv_sockfd; 36 | int m_reply_sockfd; 37 | int m_epfd; 38 | std::vector m_buffer; 39 | }; 40 | 41 | typedef boost::shared_ptr worker_ptr; 42 | 43 | int m_udp_sockfd; 44 | int m_tcp_sockfd; 45 | int m_epfd; 46 | std::vector m_workers; 47 | }; 48 | 49 | #endif 50 | -------------------------------------------------------------------------------- /tests/simple_fork/fork.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | # 3 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 4 | # Copyright (c) 2015-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 | # SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 6 | # 7 | 8 | 9 | #LD_PRELOAD=libvma.so ./fork.py 10 | #VMA_MEM_ALLOC_TYPE=2 LD_PRELOAD=libvma.so ./fork.py 11 | #VMA_MEM_ALLOC_TYPE=2 VMA_LOG_FILE="/tmp/libvma.log.%d" VMA_TRACELEVEL=4 LD_PRELOAD=libvma.so ./fork.py 12 | 13 | import os 14 | import socket 15 | 16 | def child(): 17 | print 'A new child ', os.getpid( ) 18 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 19 | s.close() 20 | os._exit(0) 21 | 22 | def parent(): 23 | i = 0 24 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 25 | while True: 26 | i = i + 1 27 | newpid = os.fork() 28 | if newpid == 0: 29 | child() 30 | else: 31 | pids = (os.getpid(), newpid) 32 | print "parent: %d, child: %d" % pids 33 | if i == 5: break 34 | s.close() 35 | 36 | parent() 37 | 38 | -------------------------------------------------------------------------------- /tests/tcp_window_size_exerciser/Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | # Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | # SPDX-License-Identifier: GPL-2.0-only or BSD-3-Clause 5 | # 6 | # This software is available to you under a choice of one of two 7 | # licenses. You may choose to be licensed under the terms of the GNU 8 | # General Public License (GPL) Version 2, available from the file 9 | # COPYING in the main directory of this source tree, or the 10 | # BSD license below: 11 | # 12 | # Redistribution and use in source and binary forms, with or 13 | # without modification, are permitted provided that the following 14 | # conditions are met: 15 | # 16 | # - Redistributions of source code must retain the above 17 | # copyright notice, this list of conditions and the following 18 | # disclaimer. 19 | # 20 | # - Redistributions in binary form must reproduce the above 21 | # copyright notice, this list of conditions and the following 22 | # disclaimer in the documentation and/or other materials 23 | # provided with the distribution. 24 | # 25 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 | # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 | # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 | # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 | # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 | # SOFTWARE. 33 | # 34 | 35 | CC = gcc 36 | LDFLAGS += -lrt 37 | TARGETS = client server 38 | 39 | all: $(TARGETS) 40 | 41 | client: tcp_wnd_test_client.c 42 | $(CC) $(LDFLAGS) $^ -o client 43 | 44 | server: tcp_wnd_test_server.c 45 | $(CC) $(LDFLAGS) $^ -o server 46 | 47 | clean: 48 | rm -f $(TARGETS) 49 | -------------------------------------------------------------------------------- /tests/tcp_window_size_exerciser/README: -------------------------------------------------------------------------------- 1 | Test Name: 2 | TCP window size exerciser 3 | 4 | Author(s): 5 | Daniel Libenson danielli@mellanox.com 6 | 7 | Short description: 8 | This is a client server test that built to exercise the tcp window size. 9 | 10 | Supported OSes: 11 | Linux 12 | 13 | Description: 14 | This is a client server test that built to exercise the TCP window size changing during traffic. 15 | - TCP window size changed due to the use of setsockopt function with SO_RCVBUF parameter. 16 | 17 | How to use: 18 | 1. Compile the code using the Make file or running next commands from Shell command line: 19 | Client -> $ gcc -lrt tcp_hang_test_client.c -o client 20 | Server -> $ gcc -lrt tcp_hang_test_server.c -o server 21 | 22 | 2. Run server side - don't forget to update all relevant parameters like IP and port 23 | $ ./server -i 9.9.9.4 -p 5000 -s 1000000 -t 10 -m 500 -M 30000 -c 122 24 | 25 | -i: Server IP 26 | -p: Server port 27 | -s: Sleep time interval [msec] 28 | -t: Update receive window size every # seconds 29 | -m: Minimal receive window size [bytes] 30 | -M: Maximum receive window size [bytes] 31 | -c: Client message size 32 | Example: ./server -i 9.9.9.4 -p 5000 -s 1000000 -t 10 -m 500 -M 30000 -c 122 33 | 34 | 4. Run client side - don't forget to update LD_PRELOAD path and all other parameters like IP and port 35 | $ LD_PRELOAD=libvma.so ./client.o -i 9.9.9.3 -s 9.9.9.4 -p 5000 -m 122 36 | 37 | -i: Client IP 38 | -s: Server IP 39 | -p: Server port 40 | -m: Client -> Server message size [bytes](1000> X >=4) 41 | Example: ./client -i 9.9.9.3 -s 9.9.9.4 -p 5000 -m 122 42 | 43 | Known issues: 44 | The hang may appear after 10-15 seconds if VMA version is lower than 8.1.4. 45 | 46 | To do: 47 | None -------------------------------------------------------------------------------- /tests/tcp_window_size_exerciser/tcp_wnd_test.h: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifndef _CLIENT_H_ 9 | #define _TCP_WND_TEST_H_ 10 | 11 | #define BUFFER_SIZE (0x400) 12 | #define MAX_MESSAGE_SIZE (255) 13 | #define MIN_MESSAGE_SIZE (4) 14 | 15 | #endif 16 | -------------------------------------------------------------------------------- /tests/testbed/README: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Mellanox/libvma/bef0769c24c1c649639147204f9a5830cc3bc04f/tests/testbed/README -------------------------------------------------------------------------------- /tests/throughput_test/Makefile.am: -------------------------------------------------------------------------------- 1 | noinst_PROGRAMS = udp_perf 2 | 3 | AM_CPPFLAGS := \ 4 | -I$(top_builddir)/. -I$(top_srcdir)/. 5 | 6 | udp_perf_LDADD = -lrt 7 | udp_perf_SOURCES = bandwidth_test.c 8 | udp_perf_DEPENDENCIES = Makefile.am Makefile.in Makefile 9 | 10 | 11 | -------------------------------------------------------------------------------- /tests/timetest/Makefile.am: -------------------------------------------------------------------------------- 1 | noinst_PROGRAMS = timetest 2 | 3 | AM_CPPFLAGS := -I$(top_builddir)/src 4 | 5 | timetest_LDADD = -lrt $(top_builddir)/src/utils/libutils.la 6 | timetest_SOURCES = timetest.cpp 7 | -------------------------------------------------------------------------------- /tools/Makefile.am: -------------------------------------------------------------------------------- 1 | SUBDIRS := \ 2 | daemon 3 | 4 | EXTRA_DIST = \ 5 | daemon 6 | -------------------------------------------------------------------------------- /tools/daemon/Makefile.am: -------------------------------------------------------------------------------- 1 | sbin_PROGRAMS = vmad 2 | 3 | vmad_LDADD = 4 | 5 | vmad_CPPFLAGS = \ 6 | -I$(top_srcdir)/src \ 7 | -I$(top_srcdir)/src/vma 8 | 9 | vmad_LDFLAGS = 10 | vmad_CFLAGS = 11 | 12 | vmad_SOURCES = \ 13 | daemon.c \ 14 | loop.c \ 15 | hash.c \ 16 | store.c \ 17 | flow.c \ 18 | message.c \ 19 | notify.c \ 20 | nl.c \ 21 | tc.c 22 | 23 | noinst_HEADERS = \ 24 | daemon.h \ 25 | hash.h \ 26 | bitmap.h \ 27 | nl.h \ 28 | tc.h 29 | -------------------------------------------------------------------------------- /tools/daemon/store.c: -------------------------------------------------------------------------------- 1 | /* 2 | * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES 3 | * Copyright (c) 2001-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 4 | * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause 5 | */ 6 | 7 | 8 | #ifdef HAVE_CONFIG_H 9 | #include "config.h" 10 | #endif 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | 18 | #include "hash.h" 19 | #include "tc.h" 20 | #include "daemon.h" 21 | 22 | 23 | int open_store(void); 24 | void close_store(void); 25 | 26 | static void free_store_pid(void *ptr); 27 | 28 | 29 | int open_store(void) 30 | { 31 | daemon_cfg.ht = hash_create(&free_store_pid, daemon_cfg.opt.max_pid_num); 32 | 33 | return (NULL == daemon_cfg.ht ? -EFAULT : 0); 34 | } 35 | 36 | void close_store(void) 37 | { 38 | hash_destroy(daemon_cfg.ht); 39 | } 40 | 41 | static void free_store_pid(void *ptr) 42 | { 43 | struct store_pid *value; 44 | 45 | if (ptr) { 46 | value = (struct store_pid *)ptr; 47 | hash_destroy(value->ht); 48 | free(value); 49 | } 50 | } 51 | --------------------------------------------------------------------------------