aboutsummaryrefslogtreecommitdiffstats
path: root/docs/report/introduction/introduction.rst
blob: 5470cca4e9df8f955bc6264ab275be820c08f26b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
Report Structure
================

FD.io |csit-release| report contains system performance and functional
testing data of |vpp-release|. `PDF version of this report`_ is
available for download.

|csit-release| report is structured as follows:

#. INTRODUCTION: General introduction to FD.io |csit-release|.

   - **Introduction**: This section.
   - **Test Scenarios Overview**: A brief overview of test scenarios
     covered in this report.
   - **Physical Testbeds**: Description of physical testbeds.
   - **Test Methodology**: Performance benchmarking and functional test
     methodologies.

#. VPP PERFORMANCE: VPP performance tests executed in physical
   FD.io testbeds.

   - **Overview**: Tested logical topologies, test coverage and naming
     specifics.
   - **Release Notes**: Changes in |csit-release|, added tests,
     environment or methodology changes, known issues.
   - **Packet Throughput**: NDR, PDR throughput graphs based on results
     from repeated same test job executions to verify repeatibility of
     measurements.
   - **Speedup Multi-Core**: NDR, PDR throughput multi-core speedup
     graphs based on results from test job executions.
   - **Packet Latency**: Latency graphs based on results from test job
     executions.
   - **Soak Tests**: Long duration soak tests are executed using PLRsearch
     algorithm.
   - **NFV Service Density**: Network Function Virtualization (NFV) service
     density tests focus on measuring total per server throughput at varied NFV
     service "packing" densities with vswitch providing host dataplane.
   - **Comparisons**: Performance comparisons between VPP releases and
     between different testbed types.
   - **Throughput Trending**: References to continuous VPP performance
     trending.
   - **Test Environment**: Performance test environment configuration.
   - **Documentation**: Pointers to CSIT source code documentation for VPP
     performance tests.

#. DPDK PERFORMANCE: DPDK performance tests executed in physical
   FD.io testbeds.

   - **Overview**: Tested logical topologies, test coverage.
   - **Release Notes**: Changes in |csit-release|, known issues.
   - **Packet Throughput**: NDR, PDR throughput graphs based on results
     from repeated same test job executions to verify repeatibility of
     measurements.
   - **Packet Latency**: Latency graphs based on results from test job
     executions.
   - **Comparisons**: Performance comparisons between DPDK releases and
     between different testbed types.
   - **Throughput Trending**: References to regular DPDK performance
     trending.
   - **Test Environment**: Performance test environment configuration.
   - **Documentation**: Pointers to CSIT source code documentation for
     DPDK performance tests.

#. VPP DEVICE: VPP functional tests executed in physical FD.io
   testbeds using containers.

   - **Overview**: Tested virtual topologies, test coverage and naming
     specifics;
   - **Release Notes**: Changes in |csit-release|, added tests,
     environment or methodology changes, known issues.
   - **Integration Tests**: Functional test environment configuration.
   - **Documentation**: Pointers to CSIT source code documentation for
     VPP functional tests.

#. VPP FUNCTIONAL: VPP functional tests executed in virtual FD.io
   testbeds.

   - **Overview**: Tested virtual topologies, test coverage and naming
     specifics;
   - **Release Notes**: Changes in |csit-release|, added tests,
     environment or methodology changes, known issues.
   - **Test Environment**: Functional test environment configuration.
   - **Documentation**: Pointers to CSIT source code documentation for
     VPP functional tests.

#. HONEYCOMB FUNCTIONAL: Honeycomb functional tests executed in
   virtual FD.io testbeds.

   - **Overview**: Tested virtual topologies, test coverage and naming
     specifics;
   - **Release Notes**: Changes in |csit-release|, known issues.
   - **Test Environment**: Functional test environment configuration.
   - **Documentation**: Pointers to CSIT source code documentation for
     Honeycomb functional tests.

#. DETAILED RESULTS: Detailed result tables auto-generated from CSIT
   test job executions using RF (Robot Framework) output files as
   sources.

   - **VPP Performance NDR/PDR**: VPP NDR/PDR throughput and latency.
   - **VPP Performance MRR**: VPP MRR throughput.
   - **DPDK Performance**: DPDK Testpmd and L3fwd NDR/PDR throughput
     and latency.
   - **VPP Functional**: Detailed VPP functional results.
   - **Honeycomb Functional**: Detailed HoneyComb functional results.

#. TEST CONFIGURATION: VPP DUT configuration data based on VPP API
   Test (VAT) Commands History auto-generated from CSIT test job
   executions using RF output files as sources.

   - **VPP Performance NDR/PDR**: Configuration data.
   - **VPP Performance MRR**: Configuration data.
   - **VPP Functional**: Configuration data.

#. TEST OPERATIONAL DATA: VPP DUT operational data auto-generated
   from CSIT test job executions using RFoutput files as sources.

   - **VPP Performance NDR/PDR**: VPP `show run` outputs under test
     load.

#. CSIT FRAMEWORK DOCUMENTATION: Description of the overall FD.io
   CSIT framework.

   - **Design**: Framework modular design hierarchy.
   - **Test naming**: Test naming convention.
   - **Presentation and Analytics Layer**: Description of PAL CSIT
     analytics module.
   - **CSIT RF Tags Descriptions**: CSIT RF Tags used for test suite and
     test case grouping and selection.

..
    #. DMM FUNCTIONAL: DMM functional tests executed in
       virtual FD.io testbeds.

       - **Overview**: Tested virtual topologies, test coverage and naming
         specifics;
       - **Release Notes**: Changes in |csit-release|, known issues.
       - **Test Environment**: Functional test environment configuration.
       - **Documentation**: Pointers to CSIT source code documentation for
         DMM functional tests.

    #. NSH_SFC FUNCTIONAL: NSH_SFC functional tests executed in
       virtual FD.io testbeds.

       - **Overview**: Tested virtual topologies, test coverage and naming
         specifics;
       - **Release Notes**: Changes in |csit-release|, known issues.
       - **Test Environment**: Functional test environment configuration.
       - **Documentation**: Pointers to CSIT source code documentation for
         NSH_SFC functional tests.
bute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */ }
# Copyright (c) 2016 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

export WS_ROOT=$(CURDIR)
export BR=$(WS_ROOT)/build-root
CCACHE_DIR?=$(BR)/.ccache
SHELL:=/bin/bash
GDB?=gdb
PLATFORM?=vpp
SAMPLE_PLUGIN?=no
STARTUP_DIR?=$(PWD)
MACHINE=$(shell uname -m)
SUDO?=sudo -E
DPDK_CONFIG?=no-pci

,:=,
define disable_plugins
$(if $(1), \
  "plugins {" \
  $(patsubst %,"plugin %_plugin.so { disable }",$(subst $(,), ,$(1))) \
  " }" \
  ,)
endef

MINIMAL_STARTUP_CONF="							\
unix { 									\
	interactive 							\
	cli-listen /run/vpp/cli.sock					\
	gid $(shell id -g)						\
	$(if $(wildcard startup.vpp),"exec startup.vpp",)		\
}									\
$(if $(DPDK_CONFIG), "dpdk { $(DPDK_CONFIG) }",)			\
$(call disable_plugins,$(DISABLED_PLUGINS))				\
"

GDB_ARGS= -ex "handle SIGUSR1 noprint nostop"

#
# OS Detection
#
# We allow Darwin (MacOS) for docs generation; VPP build will still fail.
ifneq ($(shell uname),Darwin)
OS_ID        = $(shell grep '^ID=' /etc/os-release | cut -f2- -d= | sed -e 's/\"//g')
OS_VERSION_ID= $(shell grep '^VERSION_ID=' /etc/os-release | cut -f2- -d= | sed -e 's/\"//g')
endif

ifeq ($(filter ubuntu debian,$(OS_ID)),$(OS_ID))
PKG=deb
else ifeq ($(filter rhel centos fedora,$(OS_ID)),$(OS_ID))
PKG=rpm
endif

# +libganglia1-dev if building the gmond plugin

DEB_DEPENDS  = curl build-essential autoconf automake ccache
DEB_DEPENDS += debhelper dkms git libtool libapr1-dev dh-systemd dh-python
DEB_DEPENDS += libconfuse-dev git-review exuberant-ctags cscope pkg-config
DEB_DEPENDS += lcov chrpath autoconf libnuma-dev
DEB_DEPENDS += python3-all python3-setuptools check
DEB_DEPENDS += libffi-dev python3-ply libmbedtls-dev
DEB_DEPENDS += cmake ninja-build uuid-dev python3-jsonschema python3-yaml
DEB_DEPENDS += python3-venv  # ensurepip
DEB_DEPENDS += python3-dev   # needed for python3 -m pip install psutil
DEB_DEPENDS += libnl-3-dev libnl-route-3-dev
# python3.6 on 16.04 requires python36-dev

LIBFFI=libffi6 # works on all but 20.04 and debian-testing

ifeq ($(OS_VERSION_ID),18.04)
	DEB_DEPENDS += python-dev python-all python-pip python-virtualenv
	DEB_DEPENDS += libssl-dev
	DEB_DEPENDS += clang-9 clang-format-10
else ifeq ($(OS_VERSION_ID),20.04)
	DEB_DEPENDS += python3-virtualenv
	DEB_DEPENDS += libssl-dev
	DEB_DEPENDS += libelf-dev # for libbpf (af_xdp)
	DEB_DEPENDS += clang-format-10
	LIBFFI=libffi7
else ifeq ($(OS_VERSION_ID),20.10)
        DEB_DEPENDS += python3-virtualenv
        DEB_DEPENDS += libssl-dev
        DEB_DEPENDS += libelf-dev # for libbpf (af_xdp)
        DEB_DEPENDS += clang-format-10
        LIBFFI=libffi8ubuntu1
else ifeq ($(OS_ID)-$(OS_VERSION_ID),debian-10)
	DEB_DEPENDS += python3-virtualenv virtualenv
	DEB_DEPENDS += libssl-dev
	DEB_DEPENDS += libelf-dev # for libbpf (af_xdp)
else
	DEB_DEPENDS += libssl-dev
	DEB_DEPENDS += libelf-dev # for libbpf (af_xdp)
	LIBFFI=libffi7
endif

DEB_DEPENDS += $(LIBFFI)

RPM_DEPENDS  = redhat-lsb glibc-static
RPM_DEPENDS += apr-devel
RPM_DEPENDS += numactl-devel
RPM_DEPENDS += check check-devel
RPM_DEPENDS += selinux-policy selinux-policy-devel
RPM_DEPENDS += ninja-build
RPM_DEPENDS += libuuid-devel
RPM_DEPENDS += mbedtls-devel
RPM_DEPENDS += ccache
RPM_DEPENDS += xmlto
RPM_DEPENDS += elfutils-libelf-devel
RPM_DEPENDS += libnl3-devel

ifeq ($(OS_ID),fedora)
	RPM_DEPENDS += dnf-utils
	RPM_DEPENDS += subunit subunit-devel
	RPM_DEPENDS += compat-openssl10-devel
	RPM_DEPENDS += python3-devel  # needed for python3 -m pip install psutil
	RPM_DEPENDS += python3-ply  # for vppapigen
	RPM_DEPENDS += python3-virtualenv python3-jsonschema
	RPM_DEPENDS += cmake
	RPM_DEPENDS_GROUPS = 'C Development Tools and Libraries'
else ifeq ($(OS_ID)-$(OS_VERSION_ID),centos-8)
	RPM_DEPENDS += yum-utils
	RPM_DEPENDS += compat-openssl10 openssl-devel
	RPM_DEPENDS += python2-devel python36-devel python3-ply
	RPM_DEPENDS += python3-virtualenv python3-jsonschema
	RPM_DEPENDS += cmake
	RPM_DEPENDS_GROUPS = 'Development Tools'
else
	RPM_DEPENDS += yum-utils
	RPM_DEPENDS += openssl-devel
	RPM_DEPENDS += python36-ply  # for vppapigen
	RPM_DEPENDS += python3-devel python3-pip
	RPM_DEPENDS += python-virtualenv python36-jsonschema
	RPM_DEPENDS += devtoolset-9 devtoolset-9-libasan-devel
	RPM_DEPENDS += cmake3
	RPM_DEPENDS_GROUPS = 'Development Tools'
endif

# +ganglia-devel if building the ganglia plugin

RPM_DEPENDS += chrpath libffi-devel rpm-build

RPM_DEPENDS_DEBUG  = glibc-debuginfo e2fsprogs-debuginfo
RPM_DEPENDS_DEBUG += krb5-debuginfo openssl-debuginfo
RPM_DEPENDS_DEBUG += zlib-debuginfo nss-softokn-debuginfo
RPM_DEPENDS_DEBUG += yum-plugin-auto-update-debug-info

ifneq ($(wildcard $(STARTUP_DIR)/startup.conf),)
        STARTUP_CONF ?= $(STARTUP_DIR)/startup.conf
endif

ifeq ($(findstring y,$(UNATTENDED)),y)
CONFIRM=-y
FORCE=--force-yes
endif

TARGETS = vpp

ifneq ($(SAMPLE_PLUGIN),no)
TARGETS += sample-plugin
endif

define banner
	@echo "========================================================================"
	@echo " $(1)"
	@echo "========================================================================"
	@echo " "
endef

.PHONY: help
help:
	@echo "Make Targets:"
	@echo " install-dep[s]       - install software dependencies"
	@echo " wipe                 - wipe all products of debug build "
	@echo " wipe-release         - wipe all products of release build "
	@echo " build                - build debug binaries"
	@echo " build-release        - build release binaries"
	@echo " build-coverity       - build coverity artifacts"
	@echo " rebuild              - wipe and build debug binaries"
	@echo " rebuild-release      - wipe and build release binaries"
	@echo " run                  - run debug binary"
	@echo " run-release          - run release binary"
	@echo " debug                - run debug binary with debugger"
	@echo " debug-release        - run release binary with debugger"
	@echo " test                 - build and run tests"
	@echo " test-help            - show help on test framework"
	@echo " run-vat              - run vpp-api-test tool"
	@echo " pkg-deb              - build DEB packages"
	@echo " pkg-deb-debug        - build DEB debug packages"
	@echo " pkg-snap             - build SNAP package"
	@echo " snap-clean           - clean up snap build environment"
	@echo " pkg-rpm              - build RPM packages"
	@echo " install-ext-dep[s]   - install external development dependencies"
	@echo " ctags                - (re)generate ctags database"
	@echo " gtags                - (re)generate gtags database"
	@echo " cscope               - (re)generate cscope database"
	@echo " compdb               - (re)generate compile_commands.json"
	@echo " checkstyle           - check coding style"
	@echo " checkstyle-commit    - check commit message format"
	@echo " checkstyle-test      - check test framework coding style"
	@echo " checkstyle-test-diff - check test framework coding style (only changed files)"
	@echo " checkstyle-api       - check api for incompatible changes"
	@echo " fixstyle             - fix coding style"
	@echo " doxygen              - (re)generate documentation"
	@echo " bootstrap-doxygen    - setup Doxygen dependencies"
	@echo " wipe-doxygen         - wipe all generated documentation"
	@echo " checkfeaturelist     - check FEATURE.yaml according to schema"
	@echo " featurelist          - dump feature list in markdown"
	@echo " json-api-files       - (re)-generate json api files"
	@echo " json-api-files-debug - (re)-generate json api files for debug target"
	@echo " go-api-files         - (re)-generate golang api files"
	@echo " docs                 - Build the Sphinx documentation"
	@echo " docs-venv            - Build the virtual environment for the Sphinx docs"
	@echo " docs-clean           - Remove the generated files from the Sphinx docs"
	@echo " stats-fs-help        - Help to build the stats segment file system"
	@echo ""
	@echo "Make Arguments:"
	@echo " V=[0|1]                  - set build verbosity level"
	@echo " STARTUP_CONF=<path>      - startup configuration file"
	@echo "                            (e.g. /etc/vpp/startup.conf)"
	@echo " STARTUP_DIR=<path>       - startup directory (e.g. /etc/vpp)"
	@echo "                            It also sets STARTUP_CONF if"
	@echo "                            startup.conf file is present"
	@echo " GDB=<path>               - gdb binary to use for debugging"
	@echo " PLATFORM=<name>          - target platform. default is vpp"
	@echo " TEST=<filter>            - apply filter to test set, see test-help"
	@echo " DPDK_CONFIG=<conf>       - add specified dpdk config commands to"
	@echo "                            autogenerated startup.conf"
	@echo "                            (e.g. \"no-pci\" )"
	@echo " SAMPLE_PLUGIN=yes        - in addition build/run/debug sample plugin"
	@echo " DISABLED_PLUGINS=<list>  - comma separated list of plugins which"
	@echo "                            should not be loaded"
	@echo ""
	@echo "Current Argument Values:"
	@echo " V                 = $(V)"
	@echo " STARTUP_CONF      = $(STARTUP_CONF)"
	@echo " STARTUP_DIR       = $(STARTUP_DIR)"
	@echo " GDB               = $(GDB)"
	@echo " PLATFORM          = $(PLATFORM)"
	@echo " DPDK_VERSION      = $(DPDK_VERSION)"
	@echo " DPDK_CONFIG       = $(DPDK_CONFIG)"
	@echo " SAMPLE_PLUGIN     = $(SAMPLE_PLUGIN)"
	@echo " DISABLED_PLUGINS  = $(DISABLED_PLUGINS)"

$(BR)/.deps.ok:
ifeq ($(findstring y,$(UNATTENDED)),y)
	make install-dep
endif
ifeq ($(filter ubuntu debian,$(OS_ID)),$(OS_ID))
	@MISSING=$$(apt-get install -y -qq -s $(DEB_DEPENDS) | grep "^Inst ") ; \
	if [ -n "$$MISSING" ] ; then \
	  echo "\nPlease install missing packages: \n$$MISSING\n" ; \
	  echo "by executing \"make install-dep\"\n" ; \
	  exit 1 ; \
	fi ; \
	exit 0
else ifneq ("$(wildcard /etc/redhat-release)","")
	@for i in $(RPM_DEPENDS) ; do \
	    RPM=$$(basename -s .rpm "$${i##*/}" | cut -d- -f1,2,3,4)  ;	\
	    MISSING+=$$(rpm -q $$RPM | grep "^package")	   ;    \
	done							   ;	\
	if [ -n "$$MISSING" ] ; then \
	  echo "Please install missing RPMs: \n$$MISSING\n" ; \
	  echo "by executing \"make install-dep\"\n" ; \
	  exit 1 ; \
	fi ; \
	exit 0
endif
	@touch $@

.PHONY: bootstrap
bootstrap:
	@echo "'make bootstrap' is not needed anymore"

.PHONY: install-dep
install-dep:
ifeq ($(filter ubuntu debian,$(OS_ID)),$(OS_ID))
	@sudo -E apt-get update
	@sudo -E apt-get $(APT_ARGS) $(CONFIRM) $(FORCE) install $(DEB_DEPENDS)
else ifneq ("$(wildcard /etc/redhat-release)","")
ifeq ($(OS_ID),rhel)
	@sudo -E yum-config-manager --enable rhel-server-rhscl-7-rpms
	@sudo -E yum groupinstall $(CONFIRM) $(RPM_DEPENDS_GROUPS)
	@sudo -E yum install $(CONFIRM) $(RPM_DEPENDS)
	@sudo -E debuginfo-install $(CONFIRM) glibc openssl-libs mbedtls-devel zlib
else ifeq ($(OS_ID)-$(OS_VERSION_ID),centos-8)
	@sudo -E dnf install $(CONFIRM) dnf-plugins-core epel-release
	@sudo -E dnf config-manager --set-enabled \
          $(shell dnf repolist all 2>/dev/null|grep -i powertools|cut -d' ' -f1)
	@sudo -E dnf groupinstall $(CONFIRM) $(RPM_DEPENDS_GROUPS)
	@sudo -E dnf install $(CONFIRM) $(RPM_DEPENDS)
else ifeq ($(OS_ID),centos)
	@sudo -E yum install $(CONFIRM) centos-release-scl-rh epel-release
	@sudo -E yum groupinstall $(CONFIRM) $(RPM_DEPENDS_GROUPS)
	@sudo -E yum install $(CONFIRM) $(RPM_DEPENDS)
	@sudo -E yum install $(CONFIRM) --enablerepo=base-debuginfo $(RPM_DEPENDS_DEBUG)
else ifeq ($(OS_ID),fedora)
	@sudo -E dnf groupinstall $(CONFIRM) $(RPM_DEPENDS_GROUPS)
	@sudo -E dnf install $(CONFIRM) $(RPM_DEPENDS)
	@sudo -E debuginfo-install $(CONFIRM) glibc openssl-libs mbedtls-devel zlib
endif
else
	$(error "This option currently works only on Ubuntu, Debian, RHEL, or CentOS systems")
endif
	git config commit.template .git_commit_template.txt

.PHONY: install-deps
install-deps: install-dep

define make
	@make -C $(BR) PLATFORM=$(PLATFORM) TAG=$(1) $(2)
endef

$(BR)/scripts/.version:
ifneq ("$(wildcard /etc/redhat-release)","")
	$(shell $(BR)/scripts/version rpm-string > $(BR)/scripts/.version)
else
	$(shell $(BR)/scripts/version > $(BR)/scripts/.version)
endif

DIST_FILE = $(BR)/vpp-$(shell src/scripts/version).tar
DIST_SUBDIR = vpp-$(shell src/scripts/version|cut -f1 -d-)

.PHONY: dist
dist:
	@if git rev-parse 2> /dev/null ; then \
	    git archive \
	      --prefix=$(DIST_SUBDIR)/ \
	      --format=tar \
	      -o $(DIST_FILE) \
	    HEAD ; \
	    git describe --long > $(BR)/.version ; \
	else \
	    (cd .. ; tar -cf $(DIST_FILE) $(DIST_SUBDIR) --exclude=*.tar) ; \
	    src/scripts/version > $(BR)/.version ; \
	fi
	@tar --append \
	  --file $(DIST_FILE) \
	  --transform='s,.*/.version,$(DIST_SUBDIR)/src/scripts/.version,' \
	  $(BR)/.version
	@$(RM) $(BR)/.version $(DIST_FILE).xz
	@xz -v --threads=0 $(DIST_FILE)
	@$(RM) $(BR)/vpp-latest.tar.xz
	@ln -rs $(DIST_FILE).xz $(BR)/vpp-latest.tar.xz

.PHONY: build
build: $(BR)/.deps.ok
	$(call make,$(PLATFORM)_debug,$(addsuffix -install,$(TARGETS)))

.PHONY: wipedist
wipedist:
	@$(RM) $(BR)/*.tar.xz

.PHONY: wipe
wipe: wipedist test-wipe $(BR)/.deps.ok
	$(call make,$(PLATFORM)_debug,$(addsuffix -wipe,$(TARGETS)))
	@find . -type f -name "*.api.json" ! -path "./test/*" -exec rm {} \;

.PHONY: rebuild
rebuild: wipe build

.PHONY: build-release
build-release: $(BR)/.deps.ok
	$(call make,$(PLATFORM),$(addsuffix -install,$(TARGETS)))

.PHONY: wipe-release
wipe-release: test-wipe $(BR)/.deps.ok
	$(call make,$(PLATFORM),$(addsuffix -wipe,$(TARGETS)))

.PHONY: rebuild-release
rebuild-release: wipe-release build-release

libexpand = $(subst $(subst ,, ),:,$(foreach lib,$(1),$(BR)/install-$(2)-native/vpp/$(lib)/$(3)))

export TEST_DIR ?= $(WS_ROOT)/test
export RND_SEED ?= $(shell python3 -c 'import time; print(time.time())')

define test
	$(if $(filter-out $(3),retest),make -C $(BR) PLATFORM=$(1) TAG=$(2) vpp-install,)
	$(eval libs:=lib lib64)
	make -C test \
	  VPP_BUILD_DIR=$(BR)/build-$(2)-native \
	  VPP_BIN=$(BR)/install-$(2)-native/vpp/bin/vpp \
	  VPP_PLUGIN_PATH=$(call libexpand,$(libs),$(2),vpp_plugins) \
	  VPP_TEST_PLUGIN_PATH=$(call libexpand,$(libs),$(2),vpp_api_test_plugins) \
	  VPP_INSTALL_PATH=$(BR)/install-$(2)-native/ \
	  LD_LIBRARY_PATH=$(call libexpand,$(libs),$(2),) \
	  EXTENDED_TESTS=$(EXTENDED_TESTS) \
	  PYTHON=$(PYTHON) \
	  OS_ID=$(OS_ID) \
	  RND_SEED=$(RND_SEED) \
	  CACHE_OUTPUT=$(CACHE_OUTPUT) \
	  $(3)
endef

.PHONY: test
test:
	$(call test,vpp,vpp,test)

.PHONY: test-debug
test-debug:
	$(call test,vpp,vpp_debug,test)

.PHONY: test-gcov
test-gcov:
	$(call test,vpp,vpp_gcov,test)

.PHONY: test-all
test-all:
	$(eval EXTENDED_TESTS=yes)
	$(call test,vpp,vpp,test)

.PHONY: test-all-debug
test-all-debug:
	$(eval EXTENDED_TESTS=yes)
	$(call test,vpp,vpp_debug,test)

.PHONY: papi-wipe
papi-wipe: test-wipe-papi
	$(call banner,"This command is deprecated. Please use 'test-wipe-papi'")

.PHONY: test-wipe-papi
test-wipe-papi:
	@make -C test wipe-papi

.PHONY: test-help
test-help:
	@make -C test help

.PHONY: test-wipe
test-wipe:
	@make -C test wipe

.PHONY: test-shell
test-shell:
	$(call test,vpp,vpp,shell)

.PHONY: test-shell-debug
test-shell-debug:
	$(call test,vpp,vpp_debug,shell)

.PHONY: test-shell-gcov
test-shell-gcov:
	$(call test,vpp,vpp_gcov,shell)

.PHONY: test-dep
test-dep:
	@make -C test test-dep

.PHONY: test-doc
test-doc:
	@make -C test doc

.PHONY: test-wipe-doc
test-wipe-doc:
	@make -C test wipe-doc

.PHONY: test-cov
test-cov:
	$(eval EXTENDED_TESTS=yes)
	$(call test,vpp,vpp_gcov,cov)

.PHONY: test-wipe-cov
test-wipe-cov:
	@make -C test wipe-cov

.PHONY: test-wipe-all
test-wipe-all:
	@make -C test wipe-all

.PHONY: test-checkstyle
test-checkstyle:
	@make -C test checkstyle

.PHONY: test-checkstyle-diff
test-checkstyle-diff:
	@make -C test checkstyle-diff

.PHONY: test-refresh-deps
test-refresh-deps:
	@make -C test refresh-deps

.PHONY: retest
retest:
	$(call test,vpp,vpp,retest)

.PHONY: retest-debug
retest-debug:
	$(call test,vpp,vpp_debug,retest)

.PHONY: retest-all
retest-all:
	$(eval EXTENDED_TESTS=yes)
	$(call test,vpp,vpp,retest)

.PHONY: retest-all-debug
retest-all-debug:
	$(eval EXTENDED_TESTS=yes)
	$(call test,vpp,vpp_debug,retest)

.PHONY: test-start-vpp-in-gdb
test-start-vpp-in-gdb:
	$(call test,vpp,vpp,start-gdb)

.PHONY: test-start-vpp-debug-in-gdb
test-start-vpp-debug-in-gdb:
	$(call test,vpp,vpp_debug,start-gdb)

ifeq ("$(wildcard $(STARTUP_CONF))","")
define run
	@echo "WARNING: STARTUP_CONF not defined or file doesn't exist."
	@echo "         Running with minimal startup config: $(MINIMAL_STARTUP_CONF)\n"
	@cd $(STARTUP_DIR) && \
	  $(SUDO) $(2) $(1)/vpp/bin/vpp $(MINIMAL_STARTUP_CONF)
endef
else
define run
	@cd $(STARTUP_DIR) && \
	  $(SUDO) $(2) $(1)/vpp/bin/vpp $(shell cat $(STARTUP_CONF) | sed -e 's/#.*//')
endef
endif

%.files: .FORCE
	@find src -name '*.[chS]' > $@

.FORCE:

.PHONY: run
run:
	$(call run, $(BR)/install-$(PLATFORM)_debug-native)

.PHONY: run-release
run-release:
	$(call run, $(BR)/install-$(PLATFORM)-native)

.PHONY: debug
debug:
	$(call run, $(BR)/install-$(PLATFORM)_debug-native,$(GDB) $(GDB_ARGS) --args)

.PHONY: build-coverity
build-coverity:
	$(call make,$(PLATFORM)_coverity,install-packages)
	@make -C build-root PLATFORM=vpp TAG=vpp_coverity libmemif-install

.PHONY: debug-release
debug-release:
	$(call run, $(BR)/install-$(PLATFORM)-native,$(GDB) $(GDB_ARGS) --args)

.PHONY: build-vat
build-vat:
	$(call make,$(PLATFORM)_debug,vpp-api-test-install)

.PHONY: run-vat
run-vat:
	@$(SUDO) $(BR)/install-$(PLATFORM)_debug-native/vpp/bin/vpp_api_test

.PHONY: pkg-deb
pkg-deb:
	$(call make,$(PLATFORM),vpp-package-deb)

.PHONY: pkg-snap
pkg-snap:
	cd extras/snap ;			\
        ./prep ;				\
	SNAPCRAFT_BUILD_ENVIRONMENT_MEMORY=8G 	\
	SNAPCRAFT_BUILD_ENVIRONMENT_CPU=6 	\
	snapcraft --debug

.PHONY: snap-clean
snap-clean:
	cd extras/snap ;			\
        snapcraft clean ;			\
	rm -f *.snap *.tgz

.PHONY: pkg-deb-debug
pkg-deb-debug:
	$(call make,$(PLATFORM)_debug,vpp-package-deb)

.PHONY: pkg-rpm
pkg-rpm: dist
	make -C extras/rpm

.PHONY: pkg-srpm
pkg-srpm: dist
	make -C extras/rpm srpm

.PHONY: install-ext-deps
install-ext-deps:
	make -C build/external install-$(PKG)

.PHONY: install-ext-dep
install-ext-dep: install-ext-deps

.PHONY: json-api-files
json-api-files:
	$(WS_ROOT)/src/tools/vppapigen/generate_json.py

.PHONY: json-api-files-debug
json-api-files-debug:
	$(WS_ROOT)/src/tools/vppapigen/generate_json.py --debug-target

.PHONY: go-api-files
go-api-files: json-api-files
	$(WS_ROOT)/src/tools/vppapigen/generate_go.py

.PHONY: ctags
ctags: ctags.files
	@ctags --totals --tag-relative=yes -L $<
	@rm $<

.PHONY: gtags
gtags: ctags
	@gtags --gtagslabel=ctags

.PHONY: cscope
cscope: cscope.files
	@cscope -b -q -v

.PHONY: compdb
compdb:
	@ninja -C build-root/build-vpp_debug-native/vpp build.ninja
	@ninja -C build-root/build-vpp_debug-native/vpp -t compdb | \
	  src/scripts/compdb_cleanup.py > compile_commands.json

.PHONY: checkstyle
checkstyle: checkfeaturelist
	@extras/scripts/checkstyle.sh

.PHONY: checkstyle-commit
checkstyle-commit:
	@extras/scripts/check_commit_msg.sh

.PHONY: checkstyle-test
checkstyle-test: test-checkstyle

.PHONY: checkstyle-all
checkstyle-all: checkstyle-commit checkstyle checkstyle-test

.PHONY: fixstyle
fixstyle:
	@extras/scripts/checkstyle.sh --fix

.PHONY: checkstyle-api
checkstyle-api:
	@extras/scripts/crcchecker.py --check-patchset

# necessary because Bug 1696324 - Update to python3.6 breaks PyYAML dependencies
# Status:	CLOSED CANTFIX
# https://bugzilla.redhat.com/show_bug.cgi?id=1696324
.PHONY: centos-pyyaml
centos-pyyaml:
ifeq ($(OS_ID)-$(OS_VERSION_ID),centos-8)
	@sudo -E yum install $(CONFIRM) python3-pyyaml
endif

.PHONY: featurelist
featurelist: centos-pyyaml
	@extras/scripts/fts.py --all --markdown

.PHONY: checkfeaturelist
checkfeaturelist: centos-pyyaml
	@extras/scripts/fts.py --validate --all


# Build vpp_stats_fs

.PHONY: stats-fs-install
stats-fs-install:
	@extras/vpp_stats_fs/install.sh install

.PHONY: stats-fs-start
stats-fs-start:
	@extras/vpp_stats_fs/install.sh start

.PHONY: stats-fs-cleanup
stats-fs-cleanup:
	@extras/vpp_stats_fs/install.sh cleanup

.PHONY: stats-fs-help
stats-fs-help:
	@extras/vpp_stats_fs/install.sh help

.PHONY: stats-fs-force-unmount
stats-fs-force-unmount:
	@extras/vpp_stats_fs/install.sh unmount

.PHONY: stats-fs-stop
stats-fs-stop:
	@extras/vpp_stats_fs/install.sh stop

#
# Build the documentation
#

# Doxygen configuration and our utility scripts
export DOXY_DIR ?= $(WS_ROOT)/doxygen

define make-doxy
	@OS_ID="$(OS_ID)" make -C $(DOXY_DIR) $@
endef

.PHONY: bootstrap-doxygen
bootstrap-doxygen:
	$(call make-doxy)

.PHONY: doxygen
doxygen: bootstrap-doxygen
	$(call make-doxy)

.PHONY: wipe-doxygen
wipe-doxygen:
	$(call make-doxy)

# Sphinx Documents
export DOCS_DIR = $(WS_ROOT)/docs
export VENV_DIR = $(WS_ROOT)/sphinx_venv
export SPHINX_SCRIPTS_DIR = $(WS_ROOT)/docs/scripts

.PHONY: docs-venv
docs-venv:
	@($(SPHINX_SCRIPTS_DIR)/sphinx-make.sh venv)

.PHONY: docs
docs: $(DOCS_DIR)
	@($(SPHINX_SCRIPTS_DIR)/sphinx-make.sh html)

.PHONY: docs-clean
docs-clean:
	@rm -rf $(DOCS_DIR)/_build
	@rm -rf $(VENV_DIR)

.PHONY: pkg-verify
pkg-verify: install-dep $(BR)/.deps.ok install-ext-deps
	$(call banner,"Building for PLATFORM=vpp using gcc")
	@make -C build-root PLATFORM=vpp TAG=vpp wipe-all install-packages
	$(call banner,"Building sample-plugin")
	@make -C build-root PLATFORM=vpp TAG=vpp sample-plugin-install
	$(call banner,"Building libmemif")
	@make -C build-root PLATFORM=vpp TAG=vpp libmemif-install
	$(call banner,"Building $(PKG) packages")
	@make pkg-$(PKG)

MAKE_VERIFY_GATE_OS ?= ubuntu-18.04
.PHONY: verify
verify: pkg-verify
ifeq ($(OS_ID)-$(OS_VERSION_ID),$(MAKE_VERIFY_GATE_OS))
	$(call banner,"Testing vppapigen")
	@src/tools/vppapigen/test_vppapigen.py
	$(call banner,"Running tests")
	@make COMPRESS_FAILED_TEST_LOGS=yes RETRIES=3 test
else
	$(call banner,"Skipping tests. Tests under 'make verify' supported on $(MAKE_VERIFY_GATE_OS)")
endif
N_CTRL_EVT_RESET); return session_send_evt_to_thread (s, 0, s->thread_index, evt_type); } void session_send_rpc_evt_to_thread_force (u32 thread_index, void *fp, void *rpc_args) { session_send_evt_to_thread (fp, rpc_args, thread_index, SESSION_CTRL_EVT_RPC); } void session_send_rpc_evt_to_thread (u32 thread_index, void *fp, void *rpc_args) { if (thread_index != vlib_get_thread_index ()) session_send_rpc_evt_to_thread_force (thread_index, fp, rpc_args); else { void (*fnp) (void *) = fp; fnp (rpc_args); } } void session_add_self_custom_tx_evt (transport_connection_t * tc, u8 has_prio) { session_t *s = session_get (tc->s_index, tc->thread_index); ASSERT (s->thread_index == vlib_get_thread_index ()); ASSERT (s->session_state != SESSION_STATE_TRANSPORT_DELETED); if (!(s->flags & SESSION_F_CUSTOM_TX)) { s->flags |= SESSION_F_CUSTOM_TX; if (svm_fifo_set_event (s->tx_fifo) || transport_connection_is_descheduled (tc)) { session_evt_elt_t *elt; session_worker_t *wrk; wrk = session_main_get_worker (tc->thread_index); if (has_prio) elt = session_evt_alloc_new (wrk); else elt = session_evt_alloc_old (wrk); elt->evt.session_index = tc->s_index; elt->evt.event_type = SESSION_IO_EVT_TX; tc->flags &= ~TRANSPORT_CONNECTION_F_DESCHED; if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT)) vlib_node_set_interrupt_pending (wrk->vm, session_queue_node.index); } } } void sesssion_reschedule_tx (transport_connection_t * tc) { session_worker_t *wrk = session_main_get_worker (tc->thread_index); session_evt_elt_t *elt; ASSERT (tc->thread_index == vlib_get_thread_index ()); elt = session_evt_alloc_new (wrk); elt->evt.session_index = tc->s_index; elt->evt.event_type = SESSION_IO_EVT_TX; if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT)) vlib_node_set_interrupt_pending (wrk->vm, session_queue_node.index); } static void session_program_transport_ctrl_evt (session_t * s, session_evt_type_t evt) { u32 thread_index = vlib_get_thread_index (); session_evt_elt_t *elt; session_worker_t *wrk; /* If we are in the handler thread, or being called with the worker barrier * held, just append a new event to pending disconnects vector. */ if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index) { wrk = session_main_get_worker (s->thread_index); elt = session_evt_alloc_ctrl (wrk); clib_memset (&elt->evt, 0, sizeof (session_event_t)); elt->evt.session_handle = session_handle (s); elt->evt.event_type = evt; if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT)) vlib_node_set_interrupt_pending (wrk->vm, session_queue_node.index); } else session_send_ctrl_evt_to_thread (s, evt); } session_t * session_alloc (u32 thread_index) { session_worker_t *wrk = &session_main.wrk[thread_index]; session_t *s; u8 will_expand = 0; pool_get_aligned_will_expand (wrk->sessions, will_expand, CLIB_CACHE_LINE_BYTES); /* If we have peekers, let them finish */ if (PREDICT_FALSE (will_expand && vlib_num_workers ())) { clib_rwlock_writer_lock (&wrk->peekers_rw_locks); pool_get_aligned (wrk->sessions, s, CLIB_CACHE_LINE_BYTES); clib_rwlock_writer_unlock (&wrk->peekers_rw_locks); } else { pool_get_aligned (wrk->sessions, s, CLIB_CACHE_LINE_BYTES); } clib_memset (s, 0, sizeof (*s)); s->session_index = s - wrk->sessions; s->thread_index = thread_index; s->app_index = APP_INVALID_INDEX; return s; } void session_free (session_t * s) { if (CLIB_DEBUG) { u8 thread_index = s->thread_index; clib_memset (s, 0xFA, sizeof (*s)); pool_put (session_main.wrk[thread_index].sessions, s); return; } SESSION_EVT (SESSION_EVT_FREE, s); pool_put (session_main.wrk[s->thread_index].sessions, s); } u8 session_is_valid (u32 si, u8 thread_index) { session_t *s; transport_connection_t *tc; s = pool_elt_at_index (session_main.wrk[thread_index].sessions, si); if (s->thread_index != thread_index || s->session_index != si) return 0; if (s->session_state == SESSION_STATE_TRANSPORT_DELETED || s->session_state <= SESSION_STATE_LISTENING) return 1; if (s->session_state == SESSION_STATE_CONNECTING && (s->flags & SESSION_F_HALF_OPEN)) return 1; tc = session_get_transport (s); if (s->connection_index != tc->c_index || s->thread_index != tc->thread_index || tc->s_index != si) return 0; return 1; } static void session_cleanup_notify (session_t * s, session_cleanup_ntf_t ntf) { app_worker_t *app_wrk; app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (!app_wrk) return; app_worker_cleanup_notify (app_wrk, s, ntf); } void session_free_w_fifos (session_t * s) { session_cleanup_notify (s, SESSION_CLEANUP_SESSION); segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); } /** * Cleans up session and lookup table. * * Transport connection must still be valid. */ static void session_delete (session_t * s) { int rv; /* Delete from the main lookup table. */ if ((rv = session_lookup_del_session (s))) clib_warning ("session %u hash delete rv %d", s->session_index, rv); session_free_w_fifos (s); } void session_cleanup_half_open (session_handle_t ho_handle) { session_t *ho = session_get_from_handle (ho_handle); /* App transports can migrate their half-opens */ if (ho->flags & SESSION_F_IS_MIGRATING) { /* Session still migrating, move to closed state to signal that the * session should be removed. */ if (ho->connection_index == ~0) { ho->session_state = SESSION_STATE_CLOSED; return; } /* Migrated transports are no longer half-opens */ transport_cleanup (session_get_transport_proto (ho), ho->connection_index, ho->app_index /* overloaded */); } else transport_cleanup_half_open (session_get_transport_proto (ho), ho->connection_index); session_free (ho); } static void session_half_open_free (session_t *ho) { app_worker_t *app_wrk; ASSERT (vlib_get_thread_index () <= 1); app_wrk = app_worker_get (ho->app_wrk_index); app_worker_del_half_open (app_wrk, ho); session_free (ho); } static void session_half_open_free_rpc (void *args) { session_t *ho = ho_session_get (pointer_to_uword (args)); session_half_open_free (ho); } void session_half_open_delete_notify (transport_connection_t *tc) { /* Notification from ctrl thread accepted without rpc */ if (!tc->thread_index) { session_half_open_free (ho_session_get (tc->s_index)); } else { void *args = uword_to_pointer ((uword) tc->s_index, void *); session_send_rpc_evt_to_thread_force (0, session_half_open_free_rpc, args); } } void session_half_open_migrate_notify (transport_connection_t *tc) { session_t *ho; ho = ho_session_get (tc->s_index); ho->flags |= SESSION_F_IS_MIGRATING; ho->connection_index = ~0; } int session_half_open_migrated_notify (transport_connection_t *tc) { session_t *ho; ho = ho_session_get (tc->s_index); /* App probably detached so the half-open must be cleaned up */ if (ho->session_state == SESSION_STATE_CLOSED) { session_half_open_delete_notify (tc); return -1; } ho->connection_index = tc->c_index; /* Overload app index for half-open with new thread */ ho->app_index = tc->thread_index; return 0; } session_t * session_alloc_for_connection (transport_connection_t * tc) { session_t *s; u32 thread_index = tc->thread_index; ASSERT (thread_index == vlib_get_thread_index () || transport_protocol_is_cl (tc->proto)); s = session_alloc (thread_index); s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4); s->session_state = SESSION_STATE_CLOSED; /* Attach transport to session and vice versa */ s->connection_index = tc->c_index; tc->s_index = s->session_index; return s; } session_t * session_alloc_for_half_open (transport_connection_t *tc) { session_t *s; s = ho_session_alloc (); s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4); s->connection_index = tc->c_index; tc->s_index = s->session_index; return s; } /** * Discards bytes from buffer chain * * It discards n_bytes_to_drop starting at first buffer after chain_b */ always_inline void session_enqueue_discard_chain_bytes (vlib_main_t * vm, vlib_buffer_t * b, vlib_buffer_t ** chain_b, u32 n_bytes_to_drop) { vlib_buffer_t *next = *chain_b; u32 to_drop = n_bytes_to_drop; ASSERT (b->flags & VLIB_BUFFER_NEXT_PRESENT); while (to_drop && (next->flags & VLIB_BUFFER_NEXT_PRESENT)) { next = vlib_get_buffer (vm, next->next_buffer); if (next->current_length > to_drop) { vlib_buffer_advance (next, to_drop); to_drop = 0; } else { to_drop -= next->current_length; next->current_length = 0; } } *chain_b = next; if (to_drop == 0) b->total_length_not_including_first_buffer -= n_bytes_to_drop; } /** * Enqueue buffer chain tail */ always_inline int session_enqueue_chain_tail (session_t * s, vlib_buffer_t * b, u32 offset, u8 is_in_order) { vlib_buffer_t *chain_b; u32 chain_bi, len, diff; vlib_main_t *vm = vlib_get_main (); u8 *data; u32 written = 0; int rv = 0; if (is_in_order && offset) { diff = offset - b->current_length; if (diff > b->total_length_not_including_first_buffer) return 0; chain_b = b; session_enqueue_discard_chain_bytes (vm, b, &chain_b, diff); chain_bi = vlib_get_buffer_index (vm, chain_b); } else chain_bi = b->next_buffer; do { chain_b = vlib_get_buffer (vm, chain_bi); data = vlib_buffer_get_current (chain_b); len = chain_b->current_length; if (!len) continue; if (is_in_order) { rv = svm_fifo_enqueue (s->rx_fifo, len, data); if (rv == len) { written += rv; } else if (rv < len) { return (rv > 0) ? (written + rv) : written; } else if (rv > len) { written += rv; /* written more than what was left in chain */ if (written > b->total_length_not_including_first_buffer) return written; /* drop the bytes that have already been delivered */ session_enqueue_discard_chain_bytes (vm, b, &chain_b, rv - len); } } else { rv = svm_fifo_enqueue_with_offset (s->rx_fifo, offset, len, data); if (rv) { clib_warning ("failed to enqueue multi-buffer seg"); return -1; } offset += len; } } while ((chain_bi = (chain_b->flags & VLIB_BUFFER_NEXT_PRESENT) ? chain_b->next_buffer : 0)); if (is_in_order) return written; return 0; } void session_fifo_tuning (session_t * s, svm_fifo_t * f, session_ft_action_t act, u32 len) { if (s->flags & SESSION_F_CUSTOM_FIFO_TUNING) { app_worker_t *app_wrk = app_worker_get (s->app_wrk_index); app_worker_session_fifo_tuning (app_wrk, s, f, act, len); if (CLIB_ASSERT_ENABLE) { segment_manager_t *sm; sm = segment_manager_get (f->segment_manager); ASSERT (f->shr->size >= 4096); ASSERT (f->shr->size <= sm->max_fifo_size); } } } /* * Enqueue data for delivery to session peer. Does not notify peer of enqueue * event but on request can queue notification events for later delivery by * calling stream_server_flush_enqueue_events(). * * @param tc Transport connection which is to be enqueued data * @param b Buffer to be enqueued * @param offset Offset at which to start enqueueing if out-of-order * @param queue_event Flag to indicate if peer is to be notified or if event * is to be queued. The former is useful when more data is * enqueued and only one event is to be generated. * @param is_in_order Flag to indicate if data is in order * @return Number of bytes enqueued or a negative value if enqueueing failed. */ int session_enqueue_stream_connection (transport_connection_t * tc, vlib_buffer_t * b, u32 offset, u8 queue_event, u8 is_in_order) { session_t *s; int enqueued = 0, rv, in_order_off; s = session_get (tc->s_index, tc->thread_index); if (is_in_order) { enqueued = svm_fifo_enqueue (s->rx_fifo, b->current_length, vlib_buffer_get_current (b)); if (PREDICT_FALSE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) && enqueued >= 0)) { in_order_off = enqueued > b->current_length ? enqueued : 0; rv = session_enqueue_chain_tail (s, b, in_order_off, 1); if (rv > 0) enqueued += rv; } } else { rv = svm_fifo_enqueue_with_offset (s->rx_fifo, offset, b->current_length, vlib_buffer_get_current (b)); if (PREDICT_FALSE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) && !rv)) session_enqueue_chain_tail (s, b, offset + b->current_length, 0); /* if something was enqueued, report even this as success for ooo * segment handling */ return rv; } if (queue_event) { /* Queue RX event on this fifo. Eventually these will need to be flushed * by calling stream_server_flush_enqueue_events () */ session_worker_t *wrk; wrk = session_main_get_worker (s->thread_index); if (!(s->flags & SESSION_F_RX_EVT)) { s->flags |= SESSION_F_RX_EVT; vec_add1 (wrk->session_to_enqueue[tc->proto], s->session_index); } session_fifo_tuning (s, s->rx_fifo, SESSION_FT_ACTION_ENQUEUED, 0); } return enqueued; } int session_enqueue_dgram_connection (session_t * s, session_dgram_hdr_t * hdr, vlib_buffer_t * b, u8 proto, u8 queue_event) { int rv; ASSERT (svm_fifo_max_enqueue_prod (s->rx_fifo) >= b->current_length + sizeof (*hdr)); if (PREDICT_TRUE (!(b->flags & VLIB_BUFFER_NEXT_PRESENT))) { /* *INDENT-OFF* */ svm_fifo_seg_t segs[2] = { { (u8 *) hdr, sizeof (*hdr) }, { vlib_buffer_get_current (b), b->current_length } }; /* *INDENT-ON* */ rv = svm_fifo_enqueue_segments (s->rx_fifo, segs, 2, 0 /* allow_partial */ ); } else { vlib_main_t *vm = vlib_get_main (); svm_fifo_seg_t *segs = 0, *seg; vlib_buffer_t *it = b; u32 n_segs = 1; vec_add2 (segs, seg, 1); seg->data = (u8 *) hdr; seg->len = sizeof (*hdr); while (it) { vec_add2 (segs, seg, 1); seg->data = vlib_buffer_get_current (it); seg->len = it->current_length; n_segs++; if (!(it->flags & VLIB_BUFFER_NEXT_PRESENT)) break; it = vlib_get_buffer (vm, it->next_buffer); } rv = svm_fifo_enqueue_segments (s->rx_fifo, segs, n_segs, 0 /* allow partial */ ); vec_free (segs); } if (queue_event && rv > 0) { /* Queue RX event on this fifo. Eventually these will need to be flushed * by calling stream_server_flush_enqueue_events () */ session_worker_t *wrk; wrk = session_main_get_worker (s->thread_index); if (!(s->flags & SESSION_F_RX_EVT)) { s->flags |= SESSION_F_RX_EVT; vec_add1 (wrk->session_to_enqueue[proto], s->session_index); } session_fifo_tuning (s, s->rx_fifo, SESSION_FT_ACTION_ENQUEUED, 0); } return rv > 0 ? rv : 0; } int session_tx_fifo_peek_bytes (transport_connection_t * tc, u8 * buffer, u32 offset, u32 max_bytes) { session_t *s = session_get (tc->s_index, tc->thread_index); return svm_fifo_peek (s->tx_fifo, offset, max_bytes, buffer); } u32 session_tx_fifo_dequeue_drop (transport_connection_t * tc, u32 max_bytes) { session_t *s = session_get (tc->s_index, tc->thread_index); u32 rv; rv = svm_fifo_dequeue_drop (s->tx_fifo, max_bytes); session_fifo_tuning (s, s->tx_fifo, SESSION_FT_ACTION_DEQUEUED, rv); if (svm_fifo_needs_deq_ntf (s->tx_fifo, max_bytes)) session_dequeue_notify (s); return rv; } static inline int session_notify_subscribers (u32 app_index, session_t * s, svm_fifo_t * f, session_evt_type_t evt_type) { app_worker_t *app_wrk; application_t *app; int i; app = application_get (app_index); if (!app) return -1; for (i = 0; i < f->shr->n_subscribers; i++) { app_wrk = application_get_worker (app, f->shr->subscribers[i]); if (!app_wrk) continue; if (app_worker_lock_and_send_event (app_wrk, s, evt_type)) return -1; } return 0; } /** * Notify session peer that new data has been enqueued. * * @param s Stream session for which the event is to be generated. * @param lock Flag to indicate if call should lock message queue. * * @return 0 on success or negative number if failed to send notification. */ static inline int session_enqueue_notify_inline (session_t * s) { app_worker_t *app_wrk; u32 session_index; u8 n_subscribers; session_index = s->session_index; n_subscribers = svm_fifo_n_subscribers (s->rx_fifo); app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (PREDICT_FALSE (!app_wrk)) { SESSION_DBG ("invalid s->app_index = %d", s->app_wrk_index); return 0; } SESSION_EVT (SESSION_EVT_ENQ, s, svm_fifo_max_dequeue_prod (s->rx_fifo)); s->flags &= ~SESSION_F_RX_EVT; /* Application didn't confirm accept yet */ if (PREDICT_FALSE (s->session_state == SESSION_STATE_ACCEPTING)) return 0; if (PREDICT_FALSE (app_worker_lock_and_send_event (app_wrk, s, SESSION_IO_EVT_RX))) return -1; if (PREDICT_FALSE (n_subscribers)) { s = session_get (session_index, vlib_get_thread_index ()); return session_notify_subscribers (app_wrk->app_index, s, s->rx_fifo, SESSION_IO_EVT_RX); } return 0; } int session_enqueue_notify (session_t * s) { return session_enqueue_notify_inline (s); } static void session_enqueue_notify_rpc (void *arg) { u32 session_index = pointer_to_uword (arg); session_t *s; s = session_get_if_valid (session_index, vlib_get_thread_index ()); if (!s) return; session_enqueue_notify (s); } /** * Like session_enqueue_notify, but can be called from a thread that does not * own the session. */ void session_enqueue_notify_thread (session_handle_t sh) { u32 thread_index = session_thread_from_handle (sh); u32 session_index = session_index_from_handle (sh); /* * Pass session index (u32) as opposed to handle (u64) in case pointers * are not 64-bit. */ session_send_rpc_evt_to_thread (thread_index, session_enqueue_notify_rpc, uword_to_pointer (session_index, void *)); } int session_dequeue_notify (session_t * s) { app_worker_t *app_wrk; svm_fifo_clear_deq_ntf (s->tx_fifo); app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (PREDICT_FALSE (!app_wrk)) return -1; if (PREDICT_FALSE (app_worker_lock_and_send_event (app_wrk, s, SESSION_IO_EVT_TX))) return -1; if (PREDICT_FALSE (s->tx_fifo->shr->n_subscribers)) return session_notify_subscribers (app_wrk->app_index, s, s->tx_fifo, SESSION_IO_EVT_TX); return 0; } /** * Flushes queue of sessions that are to be notified of new data * enqueued events. * * @param thread_index Thread index for which the flush is to be performed. * @return 0 on success or a positive number indicating the number of * failures due to API queue being full. */ int session_main_flush_enqueue_events (u8 transport_proto, u32 thread_index) { session_worker_t *wrk = session_main_get_worker (thread_index); session_t *s; int i, errors = 0; u32 *indices; indices = wrk->session_to_enqueue[transport_proto]; for (i = 0; i < vec_len (indices); i++) { s = session_get_if_valid (indices[i], thread_index); if (PREDICT_FALSE (!s)) { errors++; continue; } session_fifo_tuning (s, s->rx_fifo, SESSION_FT_ACTION_ENQUEUED, 0 /* TODO/not needed */ ); if (PREDICT_FALSE (session_enqueue_notify_inline (s))) errors++; } vec_reset_length (indices); wrk->session_to_enqueue[transport_proto] = indices; return errors; } int session_main_flush_all_enqueue_events (u8 transport_proto) { vlib_thread_main_t *vtm = vlib_get_thread_main (); int i, errors = 0; for (i = 0; i < 1 + vtm->n_threads; i++) errors += session_main_flush_enqueue_events (transport_proto, i); return errors; } int session_stream_connect_notify (transport_connection_t * tc, session_error_t err) { u32 opaque = 0, new_ti, new_si; app_worker_t *app_wrk; session_t *s = 0, *ho; /* * Cleanup half-open table */ session_lookup_del_half_open (tc); ho = ho_session_get (tc->s_index); opaque = ho->opaque; app_wrk = app_worker_get_if_valid (ho->app_wrk_index); if (!app_wrk) return -1; if (err) return app_worker_connect_notify (app_wrk, s, err, opaque); s = session_alloc_for_connection (tc); s->session_state = SESSION_STATE_CONNECTING; s->app_wrk_index = app_wrk->wrk_index; new_si = s->session_index; new_ti = s->thread_index; if ((err = app_worker_init_connected (app_wrk, s))) { session_free (s); app_worker_connect_notify (app_wrk, 0, err, opaque); return -1; } s = session_get (new_si, new_ti); s->session_state = SESSION_STATE_READY; session_lookup_add_connection (tc, session_handle (s)); if (app_worker_connect_notify (app_wrk, s, SESSION_E_NONE, opaque)) { session_lookup_del_connection (tc); /* Avoid notifying app about rejected session cleanup */ s = session_get (new_si, new_ti); segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); return -1; } return 0; } typedef union session_switch_pool_reply_args_ { struct { u32 session_index; u16 thread_index; u8 is_closed; }; u64 as_u64; } session_switch_pool_reply_args_t; STATIC_ASSERT (sizeof (session_switch_pool_reply_args_t) <= sizeof (uword), "switch pool reply args size"); static void session_switch_pool_reply (void *arg) { session_switch_pool_reply_args_t rargs; session_t *s; rargs.as_u64 = pointer_to_uword (arg); s = session_get_if_valid (rargs.session_index, rargs.thread_index); if (!s) return; /* Session closed during migration. Clean everything up */ if (rargs.is_closed) { transport_cleanup (session_get_transport_proto (s), s->connection_index, s->thread_index); segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); return; } /* Notify app that it has data on the new session */ session_enqueue_notify (s); } typedef struct _session_switch_pool_args { u32 session_index; u32 thread_index; u32 new_thread_index; u32 new_session_index; } session_switch_pool_args_t; /** * Notify old thread of the session pool switch */ static void session_switch_pool (void *cb_args) { session_switch_pool_args_t *args = (session_switch_pool_args_t *) cb_args; session_switch_pool_reply_args_t rargs; session_handle_t new_sh; segment_manager_t *sm; app_worker_t *app_wrk; session_t *s; ASSERT (args->thread_index == vlib_get_thread_index ()); s = session_get (args->session_index, args->thread_index); /* Check if session closed during migration */ rargs.is_closed = s->session_state >= SESSION_STATE_TRANSPORT_CLOSING; transport_cleanup (session_get_transport_proto (s), s->connection_index, s->thread_index); app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (app_wrk) { /* Cleanup fifo segment slice state for fifos */ sm = app_worker_get_connect_segment_manager (app_wrk); segment_manager_detach_fifo (sm, &s->rx_fifo); segment_manager_detach_fifo (sm, &s->tx_fifo); /* Notify app, using old session, about the migration event */ if (!rargs.is_closed) { new_sh = session_make_handle (args->new_session_index, args->new_thread_index); app_worker_migrate_notify (app_wrk, s, new_sh); } } /* Trigger app read and fifo updates on the new thread */ rargs.session_index = args->new_session_index; rargs.thread_index = args->new_thread_index; session_send_rpc_evt_to_thread (args->new_thread_index, session_switch_pool_reply, uword_to_pointer (rargs.as_u64, void *)); session_free (s); clib_mem_free (cb_args); } /** * Move dgram session to the right thread */ int session_dgram_connect_notify (transport_connection_t * tc, u32 old_thread_index, session_t ** new_session) { session_t *new_s; session_switch_pool_args_t *rpc_args; segment_manager_t *sm; app_worker_t *app_wrk; /* * Clone half-open session to the right thread. */ new_s = session_clone_safe (tc->s_index, old_thread_index); new_s->connection_index = tc->c_index; new_s->session_state = SESSION_STATE_READY; new_s->flags |= SESSION_F_IS_MIGRATING; if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP)) session_lookup_add_connection (tc, session_handle (new_s)); app_wrk = app_worker_get_if_valid (new_s->app_wrk_index); if (app_wrk) { /* New set of fifos attached to the same shared memory */ sm = app_worker_get_connect_segment_manager (app_wrk); segment_manager_attach_fifo (sm, &new_s->rx_fifo, new_s); segment_manager_attach_fifo (sm, &new_s->tx_fifo, new_s); } /* * Ask thread owning the old session to clean it up and make us the tx * fifo owner */ rpc_args = clib_mem_alloc (sizeof (*rpc_args)); rpc_args->new_session_index = new_s->session_index; rpc_args->new_thread_index = new_s->thread_index; rpc_args->session_index = tc->s_index; rpc_args->thread_index = old_thread_index; session_send_rpc_evt_to_thread (rpc_args->thread_index, session_switch_pool, rpc_args); tc->s_index = new_s->session_index; new_s->connection_index = tc->c_index; *new_session = new_s; return 0; } /** * Notification from transport that connection is being closed. * * A disconnect is sent to application but state is not removed. Once * disconnect is acknowledged by application, session disconnect is called. * Ultimately this leads to close being called on transport (passive close). */ void session_transport_closing_notify (transport_connection_t * tc) { app_worker_t *app_wrk; session_t *s; s = session_get (tc->s_index, tc->thread_index); if (s->session_state >= SESSION_STATE_TRANSPORT_CLOSING) return; /* Wait for reply from app before sending notification as the * accept might be rejected */ if (s->session_state == SESSION_STATE_ACCEPTING) { s->session_state = SESSION_STATE_TRANSPORT_CLOSING; return; } s->session_state = SESSION_STATE_TRANSPORT_CLOSING; app_wrk = app_worker_get (s->app_wrk_index); app_worker_close_notify (app_wrk, s); } /** * Notification from transport that connection is being deleted * * This removes the session if it is still valid. It should be called only on * previously fully established sessions. For instance failed connects should * call stream_session_connect_notify and indicate that the connect has * failed. */ void session_transport_delete_notify (transport_connection_t * tc) { session_t *s; /* App might've been removed already */ if (!(s = session_get_if_valid (tc->s_index, tc->thread_index))) return; switch (s->session_state) { case SESSION_STATE_CREATED: /* Session was created but accept notification was not yet sent to the * app. Cleanup everything. */ session_lookup_del_session (s); segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); break; case SESSION_STATE_ACCEPTING: case SESSION_STATE_TRANSPORT_CLOSING: case SESSION_STATE_CLOSING: case SESSION_STATE_TRANSPORT_CLOSED: /* If transport finishes or times out before we get a reply * from the app, mark transport as closed and wait for reply * before removing the session. Cleanup session table in advance * because transport will soon be closed and closed sessions * are assumed to have been removed from the lookup table */ session_lookup_del_session (s); s->session_state = SESSION_STATE_TRANSPORT_DELETED; session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT); svm_fifo_dequeue_drop_all (s->tx_fifo); break; case SESSION_STATE_APP_CLOSED: /* Cleanup lookup table as transport needs to still be valid. * Program transport close to ensure that all session events * have been cleaned up. Once transport close is called, the * session is just removed because both transport and app have * confirmed the close*/ session_lookup_del_session (s); s->session_state = SESSION_STATE_TRANSPORT_DELETED; session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT); svm_fifo_dequeue_drop_all (s->tx_fifo); session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_CLOSE); break; case SESSION_STATE_TRANSPORT_DELETED: break; case SESSION_STATE_CLOSED: session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT); session_delete (s); break; default: clib_warning ("session state %u", s->session_state); session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT); session_delete (s); break; } } /** * Notification from transport that it is closed * * Should be called by transport, prior to calling delete notify, once it * knows that no more data will be exchanged. This could serve as an * early acknowledgment of an active close especially if transport delete * can be delayed a long time, e.g., tcp time-wait. */ void session_transport_closed_notify (transport_connection_t * tc) { app_worker_t *app_wrk; session_t *s; if (!(s = session_get_if_valid (tc->s_index, tc->thread_index))) return; /* Transport thinks that app requested close but it actually didn't. * Can happen for tcp: * 1)if fin and rst are received in close succession. * 2)if app shutdown the connection. */ if (s->session_state == SESSION_STATE_READY) { session_transport_closing_notify (tc); svm_fifo_dequeue_drop_all (s->tx_fifo); s->session_state = SESSION_STATE_TRANSPORT_CLOSED; } /* If app close has not been received or has not yet resulted in * a transport close, only mark the session transport as closed */ else if (s->session_state <= SESSION_STATE_CLOSING) { s->session_state = SESSION_STATE_TRANSPORT_CLOSED; } /* If app also closed, switch to closed */ else if (s->session_state == SESSION_STATE_APP_CLOSED) s->session_state = SESSION_STATE_CLOSED; app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (app_wrk) app_worker_transport_closed_notify (app_wrk, s); } /** * Notify application that connection has been reset. */ void session_transport_reset_notify (transport_connection_t * tc) { app_worker_t *app_wrk; session_t *s; s = session_get (tc->s_index, tc->thread_index); svm_fifo_dequeue_drop_all (s->tx_fifo); if (s->session_state >= SESSION_STATE_TRANSPORT_CLOSING) return; if (s->session_state == SESSION_STATE_ACCEPTING) { s->session_state = SESSION_STATE_TRANSPORT_CLOSING; return; } s->session_state = SESSION_STATE_TRANSPORT_CLOSING; app_wrk = app_worker_get (s->app_wrk_index); app_worker_reset_notify (app_wrk, s); } int session_stream_accept_notify (transport_connection_t * tc) { app_worker_t *app_wrk; session_t *s; s = session_get (tc->s_index, tc->thread_index); app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (!app_wrk) return -1; if (s->session_state != SESSION_STATE_CREATED) return 0; s->session_state = SESSION_STATE_ACCEPTING; if (app_worker_accept_notify (app_wrk, s)) { /* On transport delete, no notifications should be sent. Unless, the * accept is retried and successful. */ s->session_state = SESSION_STATE_CREATED; return -1; } return 0; } /** * Accept a stream session. Optionally ping the server by callback. */ int session_stream_accept (transport_connection_t * tc, u32 listener_index, u32 thread_index, u8 notify) { session_t *s; int rv; s = session_alloc_for_connection (tc); s->listener_handle = ((u64) thread_index << 32) | (u64) listener_index; s->session_state = SESSION_STATE_CREATED; if ((rv = app_worker_init_accepted (s))) { session_free (s); return rv; } session_lookup_add_connection (tc, session_handle (s)); /* Shoulder-tap the server */ if (notify) { app_worker_t *app_wrk = app_worker_get (s->app_wrk_index); if ((rv = app_worker_accept_notify (app_wrk, s))) { session_lookup_del_session (s); segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); return rv; } } return 0; } int session_dgram_accept (transport_connection_t * tc, u32 listener_index, u32 thread_index) { app_worker_t *app_wrk; session_t *s; int rv; s = session_alloc_for_connection (tc); s->listener_handle = ((u64) thread_index << 32) | (u64) listener_index; if ((rv = app_worker_init_accepted (s))) { session_free (s); return rv; } session_lookup_add_connection (tc, session_handle (s)); app_wrk = app_worker_get (s->app_wrk_index); if ((rv = app_worker_accept_notify (app_wrk, s))) { session_lookup_del_session (s); segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); return rv; } return 0; } int session_open_cl (session_endpoint_cfg_t *rmt, session_handle_t *rsh) { transport_connection_t *tc; transport_endpoint_cfg_t *tep; app_worker_t *app_wrk; session_handle_t sh; session_t *s; int rv; tep = session_endpoint_to_transport_cfg (rmt); rv = transport_connect (rmt->transport_proto, tep); if (rv < 0) { SESSION_DBG ("Transport failed to open connection."); return rv; } tc = transport_get_half_open (rmt->transport_proto, (u32) rv); /* For dgram type of service, allocate session and fifos now */ app_wrk = app_worker_get (rmt->app_wrk_index); s = session_alloc_for_connection (tc); s->app_wrk_index = app_wrk->wrk_index; s->session_state = SESSION_STATE_OPENED; if (app_worker_init_connected (app_wrk, s)) { session_free (s); return -1; } sh = session_handle (s); *rsh = sh; session_lookup_add_connection (tc, sh); return app_worker_connect_notify (app_wrk, s, SESSION_E_NONE, rmt->opaque); } int session_open_vc (session_endpoint_cfg_t *rmt, session_handle_t *rsh) { transport_connection_t *tc; transport_endpoint_cfg_t *tep; app_worker_t *app_wrk; session_t *ho; int rv; tep = session_endpoint_to_transport_cfg (rmt); rv = transport_connect (rmt->transport_proto, tep); if (rv < 0) { SESSION_DBG ("Transport failed to open connection."); return rv; } tc = transport_get_half_open (rmt->transport_proto, (u32) rv); app_wrk = app_worker_get (rmt->app_wrk_index); /* If transport offers a vc service, only allocate established * session once the connection has been established. * In the meantime allocate half-open session for tracking purposes * associate half-open connection to it and add session to app-worker * half-open table. These are needed to allocate the established * session on transport notification, and to cleanup the half-open * session if the app detaches before connection establishment. */ ho = session_alloc_for_half_open (tc); ho->app_wrk_index = app_wrk->wrk_index; ho->ho_index = app_worker_add_half_open (app_wrk, session_handle (ho)); ho->opaque = rmt->opaque; *rsh = session_handle (ho); if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP)) session_lookup_add_half_open (tc, tc->c_index); return 0; } int session_open_app (session_endpoint_cfg_t *rmt, session_handle_t *rsh) { transport_endpoint_cfg_t *tep_cfg = session_endpoint_to_transport_cfg (rmt); /* Not supported for now */ *rsh = SESSION_INVALID_HANDLE; return transport_connect (rmt->transport_proto, tep_cfg); } typedef int (*session_open_service_fn) (session_endpoint_cfg_t *, session_handle_t *); /* *INDENT-OFF* */ static session_open_service_fn session_open_srv_fns[TRANSPORT_N_SERVICES] = { session_open_vc, session_open_cl, session_open_app, }; /* *INDENT-ON* */ /** * Ask transport to open connection to remote transport endpoint. * * Stores handle for matching request with reply since the call can be * asynchronous. For instance, for TCP the 3-way handshake must complete * before reply comes. Session is only created once connection is established. * * @param app_index Index of the application requesting the connect * @param st Session type requested. * @param tep Remote transport endpoint * @param opaque Opaque data (typically, api_context) the application expects * on open completion. */ int session_open (session_endpoint_cfg_t *rmt, session_handle_t *rsh) { transport_service_type_t tst; tst = transport_protocol_service_type (rmt->transport_proto); return session_open_srv_fns[tst](rmt, rsh); } /** * Ask transport to listen on session endpoint. * * @param s Session for which listen will be called. Note that unlike * established sessions, listen sessions are not associated to a * thread. * @param sep Local endpoint to be listened on. */ int session_listen (session_t * ls, session_endpoint_cfg_t * sep) { transport_endpoint_t *tep; int tc_index; u32 s_index; /* Transport bind/listen */ tep = session_endpoint_to_transport (sep); s_index = ls->session_index; tc_index = transport_start_listen (session_get_transport_proto (ls), s_index, tep); if (tc_index < 0) return tc_index; /* Attach transport to session. Lookup tables are populated by the app * worker because local tables (for ct sessions) are not backed by a fib */ ls = listen_session_get (s_index); ls->connection_index = tc_index; return 0; } /** * Ask transport to stop listening on local transport endpoint. * * @param s Session to stop listening on. It must be in state LISTENING. */ int session_stop_listen (session_t * s) { transport_proto_t tp = session_get_transport_proto (s); transport_connection_t *tc; if (s->session_state != SESSION_STATE_LISTENING) return SESSION_E_NOLISTEN; tc = transport_get_listener (tp, s->connection_index); /* If no transport, assume everything was cleaned up already */ if (!tc) return SESSION_E_NONE; if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP)) session_lookup_del_connection (tc); transport_stop_listen (tp, s->connection_index); return 0; } /** * Initialize session half-closing procedure. * * Note that half-closing will not change the state of the session. */ void session_half_close (session_t *s) { if (!s) return; session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_HALF_CLOSE); } /** * Initialize session closing procedure. * * Request is always sent to session node to ensure that all outstanding * requests are served before transport is notified. */ void session_close (session_t * s) { if (!s) return; if (s->session_state >= SESSION_STATE_CLOSING) { /* Session will only be removed once both app and transport * acknowledge the close */ if (s->session_state == SESSION_STATE_TRANSPORT_CLOSED || s->session_state == SESSION_STATE_TRANSPORT_DELETED) session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_CLOSE); return; } /* App closed so stop propagating dequeue notifications */ svm_fifo_clear_deq_ntf (s->tx_fifo); s->session_state = SESSION_STATE_CLOSING; session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_CLOSE); } /** * Force a close without waiting for data to be flushed */ void session_reset (session_t * s) { if (s->session_state >= SESSION_STATE_CLOSING) return; /* Drop all outstanding tx data */ svm_fifo_dequeue_drop_all (s->tx_fifo); s->session_state = SESSION_STATE_CLOSING; session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_RESET); } /** * Notify transport the session can be half-disconnected. * * Must be called from the session's thread. */ void session_transport_half_close (session_t *s) { /* Only READY session can be half-closed */ if (s->session_state != SESSION_STATE_READY) { return; } transport_half_close (session_get_transport_proto (s), s->connection_index, s->thread_index); } /** * Notify transport the session can be disconnected. This should eventually * result in a delete notification that allows us to cleanup session state. * Called for both active/passive disconnects. * * Must be called from the session's thread. */ void session_transport_close (session_t * s) { if (s->session_state >= SESSION_STATE_APP_CLOSED) { if (s->session_state == SESSION_STATE_TRANSPORT_CLOSED) s->session_state = SESSION_STATE_CLOSED; /* If transport is already deleted, just free the session */ else if (s->session_state >= SESSION_STATE_TRANSPORT_DELETED) session_free_w_fifos (s); return; } /* If the tx queue wasn't drained, the transport can continue to try * sending the outstanding data (in closed state it cannot). It MUST however * at one point, either after sending everything or after a timeout, call * delete notify. This will finally lead to the complete cleanup of the * session. */ s->session_state = SESSION_STATE_APP_CLOSED; transport_close (session_get_transport_proto (s), s->connection_index, s->thread_index); } /** * Force transport close */ void session_transport_reset (session_t * s) { if (s->session_state >= SESSION_STATE_APP_CLOSED) { if (s->session_state == SESSION_STATE_TRANSPORT_CLOSED) s->session_state = SESSION_STATE_CLOSED; else if (s->session_state >= SESSION_STATE_TRANSPORT_DELETED) session_free_w_fifos (s); return; } s->session_state = SESSION_STATE_APP_CLOSED; transport_reset (session_get_transport_proto (s), s->connection_index, s->thread_index); } /** * Cleanup transport and session state. * * Notify transport of the cleanup and free the session. This should * be called only if transport reported some error and is already * closed. */ void session_transport_cleanup (session_t * s) { /* Delete from main lookup table before we axe the the transport */ session_lookup_del_session (s); if (s->session_state != SESSION_STATE_TRANSPORT_DELETED) transport_cleanup (session_get_transport_proto (s), s->connection_index, s->thread_index); /* Since we called cleanup, no delete notification will come. So, make * sure the session is properly freed. */ segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo); session_free (s); } /** * Allocate worker mqs in share-able segment * * That can only be a newly created memfd segment, that must be mapped * by all apps/stack users unless private rx mqs are enabled. */ void session_vpp_wrk_mqs_alloc (session_main_t *smm) { u32 mq_q_length = 2048, evt_size = sizeof (session_event_t); fifo_segment_t *mqs_seg = &smm->wrk_mqs_segment; svm_msg_q_cfg_t _cfg, *cfg = &_cfg; uword mqs_seg_size; int i; mq_q_length = clib_max (mq_q_length, smm->configured_wrk_mq_length); svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = { { mq_q_length, evt_size, 0 }, { mq_q_length >> 1, 256, 0 } }; cfg->consumer_pid = 0; cfg->n_rings = 2; cfg->q_nitems = mq_q_length; cfg->ring_cfgs = rc; /* * Compute mqs segment size based on rings config and leave space * for passing extended configuration messages, i.e., data allocated * outside of the rings. If provided with a config value, accept it * if larger than minimum size. */ mqs_seg_size = svm_msg_q_size_to_alloc (cfg) * vec_len (smm->wrk); mqs_seg_size = mqs_seg_size + (32 << 10); mqs_seg_size = clib_max (mqs_seg_size, smm->wrk_mqs_segment_size); mqs_seg->ssvm.ssvm_size = mqs_seg_size; mqs_seg->ssvm.my_pid = getpid (); mqs_seg->ssvm.name = format (0, "%s%c", "session: wrk-mqs-segment", 0); if (ssvm_server_init (&mqs_seg->ssvm, SSVM_SEGMENT_MEMFD)) { clib_warning ("failed to initialize queue segment"); return; } fifo_segment_init (mqs_seg); /* Special fifo segment that's filled only with mqs */ mqs_seg->h->n_mqs = vec_len (smm->wrk); for (i = 0; i < vec_len (smm->wrk); i++) smm->wrk[i].vpp_event_queue = fifo_segment_msg_q_alloc (mqs_seg, i, cfg); } fifo_segment_t * session_main_get_wrk_mqs_segment (void) { return &session_main.wrk_mqs_segment; } u64 session_segment_handle (session_t * s) { svm_fifo_t *f; if (!s->rx_fifo) return SESSION_INVALID_HANDLE; f = s->rx_fifo; return segment_manager_make_segment_handle (f->segment_manager, f->segment_index); } /* *INDENT-OFF* */ static session_fifo_rx_fn *session_tx_fns[TRANSPORT_TX_N_FNS] = { session_tx_fifo_peek_and_snd, session_tx_fifo_dequeue_and_snd, session_tx_fifo_dequeue_internal, session_tx_fifo_dequeue_and_snd }; /* *INDENT-ON* */ void session_register_transport (transport_proto_t transport_proto, const transport_proto_vft_t * vft, u8 is_ip4, u32 output_node) { session_main_t *smm = &session_main; session_type_t session_type; u32 next_index = ~0; session_type = session_type_from_proto_and_ip (transport_proto, is_ip4); vec_validate (smm->session_type_to_next, session_type); vec_validate (smm->session_tx_fns, session_type); if (output_node != ~0) next_index = vlib_node_add_next (vlib_get_main (), session_queue_node.index, output_node); smm->session_type_to_next[session_type] = next_index; smm->session_tx_fns[session_type] = session_tx_fns[vft->transport_options.tx_type]; } transport_proto_t session_add_transport_proto (void) { session_main_t *smm = &session_main; session_worker_t *wrk; u32 thread; smm->last_transport_proto_type += 1; for (thread = 0; thread < vec_len (smm->wrk); thread++) { wrk = session_main_get_worker (thread); vec_validate (wrk->session_to_enqueue, smm->last_transport_proto_type); } return smm->last_transport_proto_type; } transport_connection_t * session_get_transport (session_t * s) { if (s->session_state != SESSION_STATE_LISTENING) return transport_get_connection (session_get_transport_proto (s), s->connection_index, s->thread_index); else return transport_get_listener (session_get_transport_proto (s), s->connection_index); } void session_get_endpoint (session_t * s, transport_endpoint_t * tep, u8 is_lcl) { if (s->session_state != SESSION_STATE_LISTENING) return transport_get_endpoint (session_get_transport_proto (s), s->connection_index, s->thread_index, tep, is_lcl); else return transport_get_listener_endpoint (session_get_transport_proto (s), s->connection_index, tep, is_lcl); } int session_transport_attribute (session_t *s, u8 is_get, transport_endpt_attr_t *attr) { if (s->session_state < SESSION_STATE_READY) return -1; return transport_connection_attribute (session_get_transport_proto (s), s->connection_index, s->thread_index, is_get, attr); } transport_connection_t * listen_session_get_transport (session_t * s) { return transport_get_listener (session_get_transport_proto (s), s->connection_index); } void session_queue_run_on_main_thread (vlib_main_t * vm) { ASSERT (vlib_get_thread_index () == 0); vlib_node_set_interrupt_pending (vm, session_queue_node.index); } static clib_error_t * session_manager_main_enable (vlib_main_t * vm) { session_main_t *smm = &session_main; vlib_thread_main_t *vtm = vlib_get_thread_main (); u32 num_threads, preallocated_sessions_per_worker; session_worker_t *wrk; int i; /* We only initialize once and do not de-initialized on disable */ if (smm->is_initialized) goto done; num_threads = 1 /* main thread */ + vtm->n_threads; if (num_threads < 1) return clib_error_return (0, "n_thread_stacks not set"); /* Allocate cache line aligned worker contexts */ vec_validate_aligned (smm->wrk, num_threads - 1, CLIB_CACHE_LINE_BYTES); for (i = 0; i < num_threads; i++) { wrk = &smm->wrk[i]; wrk->ctrl_head = clib_llist_make_head (wrk->event_elts, evt_list); wrk->new_head = clib_llist_make_head (wrk->event_elts, evt_list); wrk->old_head = clib_llist_make_head (wrk->event_elts, evt_list); wrk->pending_connects = clib_llist_make_head (wrk->event_elts, evt_list); wrk->vm = vlib_get_main_by_index (i); wrk->last_vlib_time = vlib_time_now (vm); wrk->last_vlib_us_time = wrk->last_vlib_time * CLIB_US_TIME_FREQ; wrk->timerfd = -1; vec_validate (wrk->session_to_enqueue, smm->last_transport_proto_type); if (num_threads > 1) clib_rwlock_init (&smm->wrk[i].peekers_rw_locks); if (!smm->no_adaptive && smm->use_private_rx_mqs) session_wrk_enable_adaptive_mode (wrk); } /* Allocate vpp event queues segment and queue */ session_vpp_wrk_mqs_alloc (smm); /* Initialize segment manager properties */ segment_manager_main_init (); /* Preallocate sessions */ if (smm->preallocated_sessions) { if (num_threads == 1) { pool_init_fixed (smm->wrk[0].sessions, smm->preallocated_sessions); } else { int j; preallocated_sessions_per_worker = (1.1 * (f64) smm->preallocated_sessions / (f64) (num_threads - 1)); for (j = 1; j < num_threads; j++) { pool_init_fixed (smm->wrk[j].sessions, preallocated_sessions_per_worker); } } } session_lookup_init (); app_namespaces_init (); transport_init (); smm->is_initialized = 1; done: smm->is_enabled = 1; /* Enable transports */ transport_enable_disable (vm, 1); session_debug_init (); return 0; } static void session_manager_main_disable (vlib_main_t * vm) { transport_enable_disable (vm, 0 /* is_en */ ); } void session_node_enable_disable (u8 is_en) { u8 mstate = is_en ? VLIB_NODE_STATE_INTERRUPT : VLIB_NODE_STATE_DISABLED; u8 state = is_en ? VLIB_NODE_STATE_POLLING : VLIB_NODE_STATE_DISABLED; session_main_t *sm = &session_main; vlib_main_t *vm; vlib_node_t *n; int n_vlibs, i; n_vlibs = vlib_get_n_threads (); for (i = 0; i < n_vlibs; i++) { vm = vlib_get_main_by_index (i); /* main thread with workers and not polling */ if (i == 0 && n_vlibs > 1) { vlib_node_set_state (vm, session_queue_node.index, mstate); if (is_en) { session_main_get_worker (0)->state = SESSION_WRK_INTERRUPT; vlib_node_set_state (vm, session_queue_process_node.index, state); n = vlib_get_node (vm, session_queue_process_node.index); vlib_start_process (vm, n->runtime_index); } else { vlib_process_signal_event_mt (vm, session_queue_process_node.index, SESSION_Q_PROCESS_STOP, 0); } if (!sm->poll_main) continue; } vlib_node_set_state (vm, session_queue_node.index, state); } if (sm->use_private_rx_mqs) application_enable_rx_mqs_nodes (is_en); } clib_error_t * vnet_session_enable_disable (vlib_main_t * vm, u8 is_en) { clib_error_t *error = 0; if (is_en) { if (session_main.is_enabled) return 0; error = session_manager_main_enable (vm); session_node_enable_disable (is_en); } else { session_main.is_enabled = 0; session_manager_main_disable (vm); session_node_enable_disable (is_en); } return error; } clib_error_t * session_main_init (vlib_main_t * vm) { session_main_t *smm = &session_main; smm->is_enabled = 0; smm->session_enable_asap = 0; smm->poll_main = 0; smm->use_private_rx_mqs = 0; smm->no_adaptive = 0; smm->last_transport_proto_type = TRANSPORT_PROTO_SRTP; return 0; } static clib_error_t * session_main_loop_init (vlib_main_t * vm) { session_main_t *smm = &session_main; if (smm->session_enable_asap) { vlib_worker_thread_barrier_sync (vm); vnet_session_enable_disable (vm, 1 /* is_en */ ); vlib_worker_thread_barrier_release (vm); } return 0; } VLIB_INIT_FUNCTION (session_main_init); VLIB_MAIN_LOOP_ENTER_FUNCTION (session_main_loop_init); static clib_error_t * session_config_fn (vlib_main_t * vm, unformat_input_t * input) { session_main_t *smm = &session_main; u32 nitems; uword tmp; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "wrk-mq-length %d", &nitems)) { if (nitems >= 2048) smm->configured_wrk_mq_length = nitems; else clib_warning ("event queue length %d too small, ignored", nitems); } else if (unformat (input, "preallocated-sessions %d", &smm->preallocated_sessions)) ; else if (unformat (input, "v4-session-table-buckets %d", &smm->configured_v4_session_table_buckets)) ; else if (unformat (input, "v4-halfopen-table-buckets %d", &smm->configured_v4_halfopen_table_buckets)) ; else if (unformat (input, "v6-session-table-buckets %d", &smm->configured_v6_session_table_buckets)) ; else if (unformat (input, "v6-halfopen-table-buckets %d", &smm->configured_v6_halfopen_table_buckets)) ; else if (unformat (input, "v4-session-table-memory %U", unformat_memory_size, &tmp)) { if (tmp >= 0x100000000) return clib_error_return (0, "memory size %llx (%lld) too large", tmp, tmp); smm->configured_v4_session_table_memory = tmp; } else if (unformat (input, "v4-halfopen-table-memory %U", unformat_memory_size, &tmp)) { if (tmp >= 0x100000000) return clib_error_return (0, "memory size %llx (%lld) too large", tmp, tmp); smm->configured_v4_halfopen_table_memory = tmp; } else if (unformat (input, "v6-session-table-memory %U", unformat_memory_size, &tmp)) { if (tmp >= 0x100000000) return clib_error_return (0, "memory size %llx (%lld) too large", tmp, tmp); smm->configured_v6_session_table_memory = tmp; } else if (unformat (input, "v6-halfopen-table-memory %U", unformat_memory_size, &tmp)) { if (tmp >= 0x100000000) return clib_error_return (0, "memory size %llx (%lld) too large", tmp, tmp); smm->configured_v6_halfopen_table_memory = tmp; } else if (unformat (input, "local-endpoints-table-memory %U", unformat_memory_size, &tmp)) { if (tmp >= 0x100000000) return clib_error_return (0, "memory size %llx (%lld) too large", tmp, tmp); smm->local_endpoints_table_memory = tmp; } else if (unformat (input, "local-endpoints-table-buckets %d", &smm->local_endpoints_table_buckets)) ; else if (unformat (input, "enable")) smm->session_enable_asap = 1; else if (unformat (input, "use-app-socket-api")) (void) appns_sapi_enable_disable (1 /* is_enable */); else if (unformat (input, "poll-main")) smm->poll_main = 1; else if (unformat (input, "use-private-rx-mqs")) smm->use_private_rx_mqs = 1; else if (unformat (input, "no-adaptive")) smm->no_adaptive = 1; /* * Deprecated but maintained for compatibility */ else if (unformat (input, "evt_qs_memfd_seg")) ; else if (unformat (input, "segment-baseva 0x%lx", &tmp)) ; else if (unformat (input, "evt_qs_seg_size %U", unformat_memory_size, &tmp)) ; else if (unformat (input, "event-queue-length %d", &nitems)) { if (nitems >= 2048) smm->configured_wrk_mq_length = nitems; else clib_warning ("event queue length %d too small, ignored", nitems); } else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); } return 0; } VLIB_CONFIG_FUNCTION (session_config_fn, "session"); /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */