Skip to content

O
OpenXG-UPF
Commit 54339cbc authored by 吴洲洋's avatar 吴洲洋
Browse files
Options

add build and run script

parent 07fb5a3d
Hide whitespace changes
Inline Side-by-side
Showing with 1284 additions and 5 deletions
etc/template/config_system.template 0 → 100755
View file @ 54339cbc
set interface state if_n3 up
set interface ip address if_n3 @gtpu_entry_ip@/24
set interface state if_n6 up
set interface ip address if_n6 @gtpu_export_ip@/24
create gtpu tunnel src @gtpu_entry_ip@ dst @gnb_gtpu_ip@ teid 1 encap-vrf-id 0 decap-next node ip4-lookup
ip route add @ue_ip@/24 via gtpu_tunnel0
ip route add 0.0.0.0/0 via if_n6 @gtpu_export_ip@
etc/template/n4.template 0 → 100755
View file @ 54339cbc
gnb: @gnb@
smf : @smf@
upf : @upf@
logSize : @logSize@
etc/template/startup_original.template 0 → 100755
View file @ 54339cbc
unix {
nodaemon
log /var/log/upf/vpp/vpp.log
full-coredump
interactive
gid vpp
cli-listen /run/vpp/cli.sock
exec /opt/5gc/config_system.sh
logsize 100
}
api-trace {
on
}
api-segment {
gid vpp
}
logging
{
default-log-level info
default-syslog-log-level info
}
statseg {
default
per-node-counters on
}
cpu {
main-core @MAINCORE@
corelist-workers @WORKERCORE@
scheduler-policy fifo
scheduler-priority 50
}
#buffers {
#buffers-per-numa 128000
#Default is 2048
#}
dpdk {
dev default {
num-rx-queues 1
}
dev @PCI_ADDR_ID_ENTRY@
{
name if_n3
num-rx-queues 2
num-tx-queues 2
}
dev @PCI_ADDR_ID_EXPORT@
{
name if_n6
num-rx-queues 1
}
uio-driver vfio-pci
no-multi-seg
socket-mem 2048,2048
no-tx-checksum-offload
}
heapsize 2G
plugins {
path /usr/lib/x86_64-linux-gnu/vpp_plugins
plugin default { enable }
plugin dpdk_plugin.so { enable }
plugin gtpu_plugin.so { enable }
plugin upf_plugin.so { enable }
}
etc/upf.yaml 0 → 100755
View file @ 54339cbc
vpp:
system:
gtpu_entry_ip: 192.168.10.20
gtpu_export_ip: 172.16.30.10
gnb_gtpu_ip: 192.168.10.100
ip_link:
ueip: 192.169.0.0
ueIPPrefix: 24
snatInter: ens32
snatIP: 192.168.2.239
vppHost: ens40
gtpu_entry: ens38
gtpu_export: ens39
cpu: 3f
n4:
smf: 192.168.199.18
upf: 192.168.2.239
logSize: 100
plugin/yq 0 → 100755
View file @ 54339cbc
File added
scripts/build_upf.sh 0 → 100755
View file @ 54339cbc
#!/bin/bash
current="$PWD"
base=$(dirname "$PWD")
VPPPATH="$base/src/vppe"
VPPINSTALL="$base/install/vpp"
BUILD_ROOT="build-root"
configure="$base/etc"
N4SRC="$base/src/upf-n4/cmd/upf/main"
N4PATH="$base/install/n4"
function pre_install(){
sudo apt-get install make
sudo apt-get install cmake
sudo apt-get install ccache
sudo apt-get install dpkg-buildpackage
cd $base/src/vppe
$base/src/vppe/pre_install.sh
}
function vpp(){
echo "start build vpp"
cd $VPPPATH
clear_all
make pkg-deb-debug
make_package debug
echo "build vpp success"
echo "unpack buptvpp.tar.gz start..."
sudo tar -zxvf $VPPINSTALL/buptvppe.tar.gz -C $VPPINSTALL > /dev/null 2>&1;
echo "unpack buptvpp.tar.gz finished!!!"
sleep 1;
#install
echo "install buptvppe start..."
sudo dpkg -i $VPPINSTALL/build-root/*.deb
sudo systemctl disable vpp;
sudo systemctl stop vpp
#rm install package
sudo rm -rf $VPPINSTALL
clear_all
sleep 1;
echo "install buptvppe finished!!!"
return 0
}
function make_package()
{
#clear
rm -rf $VPPPATH/${BUILD_ROOT}/.ccache;
find $VPPPATH/${BUILD_ROOT}/ -name '*.c' -type f -print -exec rm -rf {} \;
find $VPPPATH/${BUILD_ROOT}/ -name '*.o' -type f -print -exec rm -rf {} \;
find $VPPPATH/${BUILD_ROOT}/ -name '*.o.cmd' -type f -print -exec rm -rf {} \;
find $VPPPATH/${BUILD_ROOT}/ -name '*.debug' -type f -print -exec rm -rf {} \;
find $VPPPATH/${BUILD_ROOT}/ -name '*.api.json' -type f -print -exec rm -rf {} \;
rm -rf $VPPPATH/${BUILD_ROOT}/build-test;
#pkg
vpp_tar_gz="buptvppe.tar.gz"
cd $VPPPATH
sudo tar -zcvf $vpp_tar_gz ${BUILD_ROOT} > /dev/null 2>&1;
sudo rm -rf $VPPINSTALL
sudo mkdir -p $VPPINSTALL
sudo mv $VPPPATH/$vpp_tar_gz $VPPINSTALL
}
function install_golang() {
rm -rf /tmp/go1.15.6.linux-amd64.tar.*
wget -P /tmp https://studygolang.com/dl/golang/go1.15.6.linux-amd64.tar.gz
rm -rf $base/go
mkdir -p $base/go
tar xvf /tmp/go1.15.6.linux-amd64.tar.gz -C /usr/local
sed -i -e '/GOROOT/d' ~/.bashrc
sed -i -e '/GOBIN/d' ~/.bashrc
sed -i -e '/GOPATH/d' ~/.bashrc
sed -i -e '/GO111MODULE/d' ~/.bashrc
sed -i -e '/GOPROXY/d' ~/.bashrc
echo "export GOROOT=\"/usr/local/go\"" >> ~/.bashrc
echo "export GOBIN=\"/usr/local/go/bin\"" >> ~/.bashrc
echo "export GOPATH=\"$base/go\"" >> ~/.bashrc
echo "export PATH=\$PATH:\$GOBIN" >> ~/.bashrc
echo "export GO111MODULE=on" >> ~/.bashrc
echo "export GOPROXY=https://goproxy.cn" >> ~/.bashrc
source ~/.bashrc
}
function n4(){
echo "start build 5GN4"
cd $N4SRC
go build
echo "build 5GN4 success"
mkdir -p $N4PATH
mv $N4SRC/main $N4PATH
}
function clear_all()
{
cd $VPPPATH
make wipe
rm -rf $VPPPATH/${BUILD_ROOT}/build-test;
rm -rf $VPPPATH/${BUILD_ROOT}/build-vpp_debug-native;
rm -rf $VPPPATH/${BUILD_ROOT}/build-vpp-native;
rm -rf $VPPPATH/${BUILD_ROOT}/install-vpp-native;
rm -rf $VPPPATH/${BUILD_ROOT}/install-vpp_debug-native;
rm -rf $VPPPATH/${BUILD_ROOT}/*.deb
rm -rf $VPPPATH/${BUILD_ROOT}/vpp_20.05-rc0~582*
rm -rf $VPPPATH/build/external/downloads/*
}
function help()
{
echo " "
echo "Usage: build_upf [OPTION]..."
echo "--pre_install Pre-installation of dependencies required by UPF"
echo "--install_golang Configure golang's compilation environment"
echo "--vpp Build vpp"
echo "--n4 Build N4"
echo "--c Remove files generated by previous compilation "
}
function main() {
if [ $# -eq 0 ];
then
help
exit
fi
until [ -z "$1" ]; do
case "$1" in
--all)
pre_install
install_golang
vpp
n4
shift
;;
--pre_install)
pre_install
shift
;;
--install_golang)
install_golang
shift
;;
--vpp)
vpp
shift
;;
--n4)
n4
shift
;;
--c)
clear_all
shift
;;
esac
done
exit 0
}
main "$@"
scripts/dpdk-devbind.py 0 → 100755
View file @ 54339cbc
#! /usr/bin/env python
# SPDX-License-Identifier: BSD-3-Clause
# Copyright(c) 2010-2014 Intel Corporation
#
from __future__ import print_function
import sys
import os
import getopt
import subprocess
from os.path import exists, abspath, dirname, basename
# The PCI base class for all devices
network_class = {'Class': '02', 'Vendor': None, 'Device': None,
'SVendor': None, 'SDevice': None}
acceleration_class = {'Class': '12', 'Vendor': None, 'Device': None,
'SVendor': None, 'SDevice': None}
ifpga_class = {'Class': '12', 'Vendor': '8086', 'Device': '0b30',
'SVendor': None, 'SDevice': None}
encryption_class = {'Class': '10', 'Vendor': None, 'Device': None,
'SVendor': None, 'SDevice': None}
intel_processor_class = {'Class': '0b', 'Vendor': '8086', 'Device': None,
'SVendor': None, 'SDevice': None}
cavium_sso = {'Class': '08', 'Vendor': '177d', 'Device': 'a04b,a04d',
'SVendor': None, 'SDevice': None}
cavium_fpa = {'Class': '08', 'Vendor': '177d', 'Device': 'a053',
'SVendor': None, 'SDevice': None}
cavium_pkx = {'Class': '08', 'Vendor': '177d', 'Device': 'a0dd,a049',
'SVendor': None, 'SDevice': None}
cavium_tim = {'Class': '08', 'Vendor': '177d', 'Device': 'a051',
'SVendor': None, 'SDevice': None}
cavium_zip = {'Class': '12', 'Vendor': '177d', 'Device': 'a037',
'SVendor': None, 'SDevice': None}
avp_vnic = {'Class': '05', 'Vendor': '1af4', 'Device': '1110',
'SVendor': None, 'SDevice': None}
octeontx2_sso = {'Class': '08', 'Vendor': '177d', 'Device': 'a0f9,a0fa',
'SVendor': None, 'SDevice': None}
octeontx2_npa = {'Class': '08', 'Vendor': '177d', 'Device': 'a0fb,a0fc',
'SVendor': None, 'SDevice': None}
octeontx2_dma = {'Class': '08', 'Vendor': '177d', 'Device': 'a081',
'SVendor': None, 'SDevice': None}
intel_ioat_bdw = {'Class': '08', 'Vendor': '8086', 'Device': '6f20,6f21,6f22,6f23,6f24,6f25,6f26,6f27,6f2e,6f2f',
'SVendor': None, 'SDevice': None}
intel_ioat_skx = {'Class': '08', 'Vendor': '8086', 'Device': '2021',
'SVendor': None, 'SDevice': None}
intel_ntb_skx = {'Class': '06', 'Vendor': '8086', 'Device': '201c',
'SVendor': None, 'SDevice': None}
network_devices = [network_class, cavium_pkx, avp_vnic, ifpga_class]
baseband_devices = [acceleration_class]
crypto_devices = [encryption_class, intel_processor_class]
eventdev_devices = [cavium_sso, cavium_tim, octeontx2_sso]
mempool_devices = [cavium_fpa, octeontx2_npa]
compress_devices = [cavium_zip]
misc_devices = [intel_ioat_bdw, intel_ioat_skx, intel_ntb_skx, octeontx2_dma]
# global dict ethernet devices present. Dictionary indexed by PCI address.
# Each device within this is itself a dictionary of device properties
devices = {}
# list of supported DPDK drivers
dpdk_drivers = ["igb_uio", "vfio-pci", "uio_pci_generic"]
# list of currently loaded kernel modules
loaded_modules = None
# command-line arg flags
b_flag = None
status_flag = False
force_flag = False
args = []
def usage():
'''Print usage information for the program'''
argv0 = basename(sys.argv[0])
print("""
Usage:
------
%(argv0)s [options] DEVICE1 DEVICE2 ....
where DEVICE1, DEVICE2 etc, are specified via PCI "domain:bus:slot.func" syntax
or "bus:slot.func" syntax. For devices bound to Linux kernel drivers, they may
also be referred to by Linux interface name e.g. eth0, eth1, em0, em1, etc.
Options:
--help, --usage:
Display usage information and quit
-s, --status:
Print the current status of all known network, crypto, event
and mempool devices.
For each device, it displays the PCI domain, bus, slot and function,
along with a text description of the device. Depending upon whether the
device is being used by a kernel driver, the igb_uio driver, or no
driver, other relevant information will be displayed:
* the Linux interface name e.g. if=eth0
* the driver being used e.g. drv=igb_uio
* any suitable drivers not currently using that device
e.g. unused=igb_uio
NOTE: if this flag is passed along with a bind/unbind option, the
status display will always occur after the other operations have taken
place.
--status-dev:
Print the status of given device group. Supported device groups are:
"net", "baseband", "crypto", "event", "mempool" and "compress"
-b driver, --bind=driver:
Select the driver to use or \"none\" to unbind the device
-u, --unbind:
Unbind a device (Equivalent to \"-b none\")
--force:
By default, network devices which are used by Linux - as indicated by
having routes in the routing table - cannot be modified. Using the
--force flag overrides this behavior, allowing active links to be
forcibly unbound.
WARNING: This can lead to loss of network connection and should be used
with caution.
Examples:
---------
To display current device status:
%(argv0)s --status
To display current network device status:
%(argv0)s --status-dev net
To bind eth1 from the current driver and move to use igb_uio
%(argv0)s --bind=igb_uio eth1
To unbind 0000:01:00.0 from using any driver
%(argv0)s -u 0000:01:00.0
To bind 0000:02:00.0 and 0000:02:00.1 to the ixgbe kernel driver
%(argv0)s -b ixgbe 02:00.0 02:00.1
""" % locals()) # replace items from local variables
# This is roughly compatible with check_output function in subprocess module
# which is only available in python 2.7.
def check_output(args, stderr=None):
'''Run a command and capture its output'''
return subprocess.Popen(args, stdout=subprocess.PIPE,
stderr=stderr).communicate()[0]
# check if a specific kernel module is loaded
def module_is_loaded(module):
global loaded_modules
if loaded_modules:
return module in loaded_modules
# Get list of sysfs modules (both built-in and dynamically loaded)
sysfs_path = '/sys/module/'
# Get the list of directories in sysfs_path
sysfs_mods = [m for m in os.listdir(sysfs_path)
if os.path.isdir(os.path.join(sysfs_path, m))]
# special case for vfio_pci (module is named vfio-pci,
# but its .ko is named vfio_pci)
sysfs_mods = [a if a != 'vfio_pci' else 'vfio-pci' for a in sysfs_mods]
loaded_modules = sysfs_mods
return module in sysfs_mods
def check_modules():
'''Checks that igb_uio is loaded'''
global dpdk_drivers
# list of supported modules
mods = [{"Name": driver, "Found": False} for driver in dpdk_drivers]
# first check if module is loaded
for mod in mods:
if module_is_loaded(mod["Name"]):
mod["Found"] = True
# check if we have at least one loaded module
if True not in [mod["Found"] for mod in mods] and b_flag is not None:
print("Warning: no supported DPDK kernel modules are loaded", file=sys.stderr)
# change DPDK driver list to only contain drivers that are loaded
dpdk_drivers = [mod["Name"] for mod in mods if mod["Found"]]
def has_driver(dev_id):
'''return true if a device is assigned to a driver. False otherwise'''
return "Driver_str" in devices[dev_id]
def get_pci_device_details(dev_id, probe_lspci):
'''This function gets additional details for a PCI device'''
device = {}
if probe_lspci:
extra_info = check_output(["lspci", "-vmmks", dev_id]).splitlines()
# parse lspci details
for line in extra_info:
if len(line) == 0:
continue
name, value = line.decode().split("\t", 1)
name = name.strip(":") + "_str"
device[name] = value
# check for a unix interface name
device["Interface"] = ""
for base, dirs, _ in os.walk("/sys/bus/pci/devices/%s/" % dev_id):
if "net" in dirs:
device["Interface"] = \
",".join(os.listdir(os.path.join(base, "net")))
break
# check if a port is used for ssh connection
device["Ssh_if"] = False
device["Active"] = ""
return device
def clear_data():
'''This function clears any old data'''
global devices
devices = {}
def get_device_details(devices_type):
'''This function populates the "devices" dictionary. The keys used are
the pci addresses (domain:bus:slot.func). The values are themselves
dictionaries - one for each NIC.'''
global devices
global dpdk_drivers
# first loop through and read details for all devices
# request machine readable format, with numeric IDs and String
dev = {}
dev_lines = check_output(["lspci", "-Dvmmnnk"]).splitlines()
for dev_line in dev_lines:
if len(dev_line) == 0:
if device_type_match(dev, devices_type):
# Replace "Driver" with "Driver_str" to have consistency of
# of dictionary key names
if "Driver" in dev.keys():
dev["Driver_str"] = dev.pop("Driver")
if "Module" in dev.keys():
dev["Module_str"] = dev.pop("Module")
# use dict to make copy of dev
devices[dev["Slot"]] = dict(dev)
# Clear previous device's data
dev = {}
else:
name, value = dev_line.decode().split("\t", 1)
value_list = value.rsplit(' ', 1)
if len(value_list) > 1:
# String stored in <name>_str
dev[name.rstrip(":") + '_str'] = value_list[0]
# Numeric IDs
dev[name.rstrip(":")] = value_list[len(value_list) - 1] \
.rstrip("]").lstrip("[")
if devices_type == network_devices:
# check what is the interface if any for an ssh connection if
# any to this host, so we can mark it later.
ssh_if = []
route = check_output(["ip", "-o", "route"])
# filter out all lines for 169.254 routes
route = "\n".join(filter(lambda ln: not ln.startswith("169.254"),
route.decode().splitlines()))
rt_info = route.split()
for i in range(len(rt_info) - 1):
if rt_info[i] == "dev":
ssh_if.append(rt_info[i+1])
# based on the basic info, get extended text details
for d in devices.keys():
if not device_type_match(devices[d], devices_type):
continue
# get additional info and add it to existing data
devices[d] = devices[d].copy()
# No need to probe lspci
devices[d].update(get_pci_device_details(d, False).items())
if devices_type == network_devices:
for _if in ssh_if:
if _if in devices[d]["Interface"].split(","):
devices[d]["Ssh_if"] = True
devices[d]["Active"] = "*Active*"
break
# add igb_uio to list of supporting modules if needed
if "Module_str" in devices[d]:
for driver in dpdk_drivers:
if driver not in devices[d]["Module_str"]:
devices[d]["Module_str"] = \
devices[d]["Module_str"] + ",%s" % driver
else:
devices[d]["Module_str"] = ",".join(dpdk_drivers)
# make sure the driver and module strings do not have any duplicates
if has_driver(d):
modules = devices[d]["Module_str"].split(",")
if devices[d]["Driver_str"] in modules:
modules.remove(devices[d]["Driver_str"])
devices[d]["Module_str"] = ",".join(modules)
def device_type_match(dev, devices_type):
for i in range(len(devices_type)):
param_count = len(
[x for x in devices_type[i].values() if x is not None])
match_count = 0
if dev["Class"][0:2] == devices_type[i]["Class"]:
match_count = match_count + 1
for key in devices_type[i].keys():
if key != 'Class' and devices_type[i][key]:
value_list = devices_type[i][key].split(',')
for value in value_list:
if value.strip(' ') == dev[key]:
match_count = match_count + 1
# count must be the number of non None parameters to match
if match_count == param_count:
return True
return False
def dev_id_from_dev_name(dev_name):
'''Take a device "name" - a string passed in by user to identify a NIC
device, and determine the device id - i.e. the domain:bus:slot.func - for
it, which can then be used to index into the devices array'''
# check if it's already a suitable index
if dev_name in devices:
return dev_name
# check if it's an index just missing the domain part
elif "0000:" + dev_name in devices:
return "0000:" + dev_name
else:
# check if it's an interface name, e.g. eth1
for d in devices.keys():
if dev_name in devices[d]["Interface"].split(","):
return devices[d]["Slot"]
# if nothing else matches - error
raise ValueError("Unknown device: %s. "
"Please specify device in \"bus:slot.func\" format" % dev_name)
def unbind_one(dev_id, force):
'''Unbind the device identified by "dev_id" from its current driver'''
dev = devices[dev_id]
if not has_driver(dev_id):
print("Notice: %s %s %s is not currently managed by any driver" %
(dev["Slot"], dev["Device_str"], dev["Interface"]), file=sys.stderr)
return
# prevent us disconnecting ourselves
if dev["Ssh_if"] and not force:
print("Warning: routing table indicates that interface %s is active. "
"Skipping unbind" % dev_id, file=sys.stderr)
return
# write to /sys to unbind
filename = "/sys/bus/pci/drivers/%s/unbind" % dev["Driver_str"]
try:
f = open(filename, "a")
except:
sys.exit("Error: unbind failed for %s - Cannot open %s" %
(dev_id, filename))
f.write(dev_id)
f.close()
def bind_one(dev_id, driver, force):
'''Bind the device given by "dev_id" to the driver "driver". If the device
is already bound to a different driver, it will be unbound first'''
dev = devices[dev_id]
saved_driver = None # used to rollback any unbind in case of failure
# prevent disconnection of our ssh session
if dev["Ssh_if"] and not force:
print("Warning: routing table indicates that interface %s is active. "
"Not modifying" % dev_id, file=sys.stderr)
return
# unbind any existing drivers we don't want
if has_driver(dev_id):
if dev["Driver_str"] == driver:
print("Notice: %s already bound to driver %s, skipping" %
(dev_id, driver), file=sys.stderr)
return
else:
saved_driver = dev["Driver_str"]
unbind_one(dev_id, force)
dev["Driver_str"] = "" # clear driver string
# For kernels >= 3.15 driver_override can be used to specify the driver
# for a device rather than relying on the driver to provide a positive
# match of the device. The existing process of looking up
# the vendor and device ID, adding them to the driver new_id,
# will erroneously bind other devices too which has the additional burden
# of unbinding those devices
if driver in dpdk_drivers:
filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
if os.path.exists(filename):
try:
f = open(filename, "w")
except:
print("Error: bind failed for %s - Cannot open %s"
% (dev_id, filename), file=sys.stderr)
return
try:
f.write("%s" % driver)
f.close()
except:
print("Error: bind failed for %s - Cannot write driver %s to "
"PCI ID " % (dev_id, driver), file=sys.stderr)
return
# For kernels < 3.15 use new_id to add PCI id's to the driver
else:
filename = "/sys/bus/pci/drivers/%s/new_id" % driver
try:
f = open(filename, "w")
except:
print("Error: bind failed for %s - Cannot open %s"
% (dev_id, filename), file=sys.stderr)
return
try:
# Convert Device and Vendor Id to int to write to new_id
f.write("%04x %04x" % (int(dev["Vendor"],16),
int(dev["Device"], 16)))
f.close()
except:
print("Error: bind failed for %s - Cannot write new PCI ID to "
"driver %s" % (dev_id, driver), file=sys.stderr)
return
# do the bind by writing to /sys
filename = "/sys/bus/pci/drivers/%s/bind" % driver
try:
f = open(filename, "a")
except:
print("Error: bind failed for %s - Cannot open %s"
% (dev_id, filename), file=sys.stderr)
if saved_driver is not None: # restore any previous driver
bind_one(dev_id, saved_driver, force)
return
try:
f.write(dev_id)
f.close()
except:
# for some reason, closing dev_id after adding a new PCI ID to new_id
# results in IOError. however, if the device was successfully bound,
# we don't care for any errors and can safely ignore IOError
tmp = get_pci_device_details(dev_id, True)
if "Driver_str" in tmp and tmp["Driver_str"] == driver:
return
print("Error: bind failed for %s - Cannot bind to driver %s"
% (dev_id, driver), file=sys.stderr)
if saved_driver is not None: # restore any previous driver
bind_one(dev_id, saved_driver, force)
return
# For kernels > 3.15 driver_override is used to bind a device to a driver.
# Before unbinding it, overwrite driver_override with empty string so that
# the device can be bound to any other driver
filename = "/sys/bus/pci/devices/%s/driver_override" % dev_id
if os.path.exists(filename):
try:
f = open(filename, "w")
except:
sys.exit("Error: unbind failed for %s - Cannot open %s"
% (dev_id, filename))
try:
f.write("\00")
f.close()
except:
sys.exit("Error: unbind failed for %s - Cannot open %s"
% (dev_id, filename))
def unbind_all(dev_list, force=False):
"""Unbind method, takes a list of device locations"""
if dev_list[0] == "dpdk":
for d in devices.keys():
if "Driver_str" in devices[d]:
if devices[d]["Driver_str"] in dpdk_drivers:
unbind_one(devices[d]["Slot"], force)
return
try:
dev_list = map(dev_id_from_dev_name, dev_list)
except ValueError as ex:
print(ex)
sys.exit(1)
for d in dev_list:
unbind_one(d, force)
def bind_all(dev_list, driver, force=False):
"""Bind method, takes a list of device locations"""
global devices
# a common user error is to forget to specify the driver the devices need to
# be bound to. check if the driver is a valid device, and if it is, show
# a meaningful error.
try:
dev_id_from_dev_name(driver)
# if we've made it this far, this means that the "driver" was a valid
# device string, so it's probably not a valid driver name.
sys.exit("Error: Driver '%s' does not look like a valid driver. " \
"Did you forget to specify the driver to bind devices to?" % driver)
except ValueError:
# driver generated error - it's not a valid device ID, so all is well
pass
# check if we're attempting to bind to a driver that isn't loaded
if not module_is_loaded(driver):
sys.exit("Error: Driver '%s' is not loaded." % driver)
try:
dev_list = map(dev_id_from_dev_name, dev_list)
except ValueError as ex:
sys.exit(ex)
for d in dev_list:
bind_one(d, driver, force)
# For kernels < 3.15 when binding devices to a generic driver
# (i.e. one that doesn't have a PCI ID table) using new_id, some devices
# that are not bound to any other driver could be bound even if no one has
# asked them to. hence, we check the list of drivers again, and see if
# some of the previously-unbound devices were erroneously bound.
if not os.path.exists("/sys/bus/pci/devices/%s/driver_override" % d):
for d in devices.keys():
# skip devices that were already bound or that we know should be bound
if "Driver_str" in devices[d] or d in dev_list:
continue
# update information about this device
devices[d] = dict(devices[d].items() +
get_pci_device_details(d, True).items())
# check if updated information indicates that the device was bound
if "Driver_str" in devices[d]:
unbind_one(d, force)
def display_devices(title, dev_list, extra_params=None):
'''Displays to the user the details of a list of devices given in
"dev_list". The "extra_params" parameter, if given, should contain a string
with %()s fields in it for replacement by the named fields in each
device's dictionary.'''
strings = [] # this holds the strings to print. We sort before printing
print("\n%s" % title)
print("="*len(title))
if len(dev_list) == 0:
strings.append("<none>")
else:
for dev in dev_list:
if extra_params is not None:
strings.append("%s '%s %s' %s" % (dev["Slot"],
dev["Device_str"],
dev["Device"],
extra_params % dev))
else:
strings.append("%s '%s'" % (dev["Slot"], dev["Device_str"]))
# sort before printing, so that the entries appear in PCI order
strings.sort()
print("\n".join(strings)) # print one per line
def show_device_status(devices_type, device_name):
global dpdk_drivers
kernel_drv = []
dpdk_drv = []
no_drv = []
# split our list of network devices into the three categories above
for d in devices.keys():
if device_type_match(devices[d], devices_type):
if not has_driver(d):
no_drv.append(devices[d])
continue
if devices[d]["Driver_str"] in dpdk_drivers:
dpdk_drv.append(devices[d])
else:
kernel_drv.append(devices[d])
n_devs = len(dpdk_drv) + len(kernel_drv) + len(no_drv)
# don't bother displaying anything if there are no devices
if n_devs == 0:
msg = "No '%s' devices detected" % device_name
print("")
print(msg)
print("".join('=' * len(msg)))
return
# print each category separately, so we can clearly see what's used by DPDK
if len(dpdk_drv) != 0:
display_devices("%s devices using DPDK-compatible driver" % device_name,
dpdk_drv, "drv=%(Driver_str)s unused=%(Module_str)s")
if len(kernel_drv) != 0:
display_devices("%s devices using kernel driver" % device_name, kernel_drv,
"if=%(Interface)s drv=%(Driver_str)s "
"unused=%(Module_str)s %(Active)s")
if len(no_drv) != 0:
display_devices("Other %s devices" % device_name, no_drv,
"unused=%(Module_str)s")
def show_status():
'''Function called when the script is passed the "--status" option.
Displays to the user what devices are bound to the igb_uio driver, the
kernel driver or to no driver'''
if status_dev == "net" or status_dev == "all":
show_device_status(network_devices, "Network")
if status_dev == "baseband" or status_dev == "all":
show_device_status(baseband_devices, "Baseband")
if status_dev == "crypto" or status_dev == "all":
show_device_status(crypto_devices, "Crypto")
if status_dev == "event" or status_dev == "all":
show_device_status(eventdev_devices, "Eventdev")
if status_dev == "mempool" or status_dev == "all":
show_device_status(mempool_devices, "Mempool")
if status_dev == "compress" or status_dev == "all":
show_device_status(compress_devices , "Compress")
if status_dev == "misc" or status_dev == "all":
show_device_status(misc_devices, "Misc (rawdev)")
def parse_args():
'''Parses the command-line arguments given by the user and takes the
appropriate action for each'''
global b_flag
global status_flag
global status_dev
global force_flag
global args
if len(sys.argv) <= 1:
usage()
sys.exit(0)
try:
opts, args = getopt.getopt(sys.argv[1:], "b:us",
["help", "usage", "status", "status-dev=",
"force", "bind=", "unbind", ])
except getopt.GetoptError as error:
print(str(error))
print("Run '%s --usage' for further information" % sys.argv[0])
sys.exit(1)
for opt, arg in opts:
if opt == "--help" or opt == "--usage":
usage()
sys.exit(0)
if opt == "--status-dev":
status_flag = True
status_dev = arg
if opt == "--status" or opt == "-s":
status_flag = True
status_dev = "all"
if opt == "--force":
force_flag = True
if opt == "-b" or opt == "-u" or opt == "--bind" or opt == "--unbind":
if b_flag is not None:
sys.exit("Error: binding and unbinding are mutually exclusive")
if opt == "-u" or opt == "--unbind":
b_flag = "none"
else:
b_flag = arg
def do_arg_actions():
'''do the actual action requested by the user'''
global b_flag
global status_flag
global force_flag
global args
if b_flag is None and not status_flag:
print("Error: No action specified for devices. "
"Please give a -b or -u option", file=sys.stderr)
usage()
sys.exit(1)
if b_flag is not None and len(args) == 0:
print("Error: No devices specified.", file=sys.stderr)
usage()
sys.exit(1)
if b_flag == "none" or b_flag == "None":
unbind_all(args, force_flag)
elif b_flag is not None:
bind_all(args, b_flag, force_flag)
if status_flag:
if b_flag is not None:
clear_data()
# refresh if we have changed anything
get_device_details(network_devices)
get_device_details(baseband_devices)
get_device_details(crypto_devices)
get_device_details(eventdev_devices)
get_device_details(mempool_devices)
get_device_details(compress_devices)
get_device_details(misc_devices)
show_status()
def main():
'''program main function'''
# check if lspci is installed, suppress any output
with open(os.devnull, 'w') as devnull:
ret = subprocess.call(['which', 'lspci'],
stdout=devnull, stderr=devnull)
if ret != 0:
sys.exit("'lspci' not found - please install 'pciutils'")
parse_args()
check_modules()
clear_data()
get_device_details(network_devices)
get_device_details(baseband_devices)
get_device_details(crypto_devices)
get_device_details(eventdev_devices)
get_device_details(mempool_devices)
get_device_details(compress_devices)
get_device_details(misc_devices)
do_arg_actions()
if __name__ == "__main__":
main()
scripts/run_upf.sh 0 → 100755
View file @ 54339cbc
#!/bin/bash
current="$PWD"
base=$(dirname "$PWD")
VPPPATH="$base/src/vppe"
VPPINSTALL="$base/upf/vpp"
BUILD_ROOT="build-root"
configure="$base/etc"
arp="$base/src/setuniarp"
config_system=""
VPPPROCESS="vpp"
VPPCMD="/usr/bin/vpp -c /etc/vpp/startup_debug.conf"
N4PROCESS="main"
N4PATH="$base/install/n4"
UEIP=""
PREFIX=""
INTER=""
MAC=""
VPPEXPORT=""
ARPPROCESS="setuniarp"
UE_IP=""
UE_IP_PREFIX=""
SNAT_INTER=""
SNAT_IP=""
VPPHOST=""
DPDK_EXPORT=""
DPDK_ENTRY=""
DPDK_ENTRY_PCI=""
DPDK_EXPORT_PCI=""
DRIVE=""
function init_configure(){
yaml="$1"
# vpp
mkdir -p /opt/5gc
cp -r $configure/template /opt/5gc
$base/plugin/configure -i $yaml -o /opt/5gc
cp /opt/5gc/config_system.sh /opt/5gc
cp /opt/5gc/startup_debug.conf /etc/vpp
cp $base/plugin/yq $current
# arp
UEIP=$($current/yq r $yaml vpp.ip_link.ueip)
PREFIX=$($current/yq r $yaml vpp.ip_link.ueIPPrefix)
INTER=$($current/yq r $yaml vpp.ip_link.vppHost)
VPPEXPORT=$($current/yq r $yaml vpp.system.gtpu_export_ip)
MAC=$(ifconfig $INTER|grep ether|awk '{print $2}')
# nat
UE_IP=$($current/yq r $yaml vpp.ip_link.ueip)
UE_IP_PREFIX=$($current/yq r $yaml vpp.ip_link.ueIPPrefix)
SNAT_INTER=$($current/yq r $yaml vpp.ip_link.snatInter)
SNAT_IP=$($current/yq r $yaml vpp.ip_link.snatIP)
VPPHOST=$($current/yq r $yaml vpp.ip_link.vppHost)
DPDK_EXPORT=$($current/yq r $yaml vpp.ip_link.gtpu_export)
DPDK_ENTRY=$($current/yq r $yaml vpp.ip_link.gtpu_entry)
rm -rf $current/yq
}
function start_vpp() {
cmd="$VPPCMD"
install_dpdk_kmod
run_nat
echo Y | sudo tee /sys/module/vfio/parameters/enable_unsafe_noiommu_mode
$cmd >/dev/null 2>&1 &
sleep 1s
pid=$(pidof $VPPPROCESS)
if test -z "$pid"; then
echo "vpp startup failed"
else
echo "vpp $pid startup success"
fi
}
function start_n4() {
$N4PATH/main -c /opt/5gc/n4_config.yaml >/dev/null 2>&1 &
sleep 1s
pid2=$(pidof $N4PROCESS)
if test -z "$pid2"; then
echo "n4 startup failed"
else
echo "n4 $pid2 startup success"
fi
}
function start_arp() {
echo "start arp"
echo "$arp"/setuniarp $INTER $MAC "$UEIP/$PREFIX" $VPPEXPORT
"$arp"/setuniarp $INTER $MAC "$UEIP/$PREFIX" $VPPEXPORT >/dev/null 2>&1 &
sleep 1s
pid2=$(pidof $ARPPROCESS)
if test -z "$pid2"; then
echo "arp startup failed"
else
echo "arp $pid2 startup success"
fi
exit 0
}
function close_vpp() {
pid=$(pidof $VPPPROCESS)
if test -z "$pid"; then
echo "vpp $pid is not startup"
else
echo "kill vpp $pid"
kill -9 ${pid}
fi
}
function close_n4() {
pid=$(pidof $N4PROCESS)
if test -z "$pid"; then
echo "n4 $pid is not startup"
else
echo "kill n4 $pid"
kill -9 ${pid}
fi
}
function close_arp() {
pid=$(pidof $ARPPROCESS)
if test -z "$pid"; then
echo "arp $pid is not startup"
else
echo "kill arp $pid"
kill -9 ${pid}
fi
}
function install_dpdk_kmod() {
sudo modprobe vfio-pci;
insmod_result=$?
exec_result $insmod_result
return 0;
}
function exec_result()
{
if [ $1 -ne 0 ]; then
echo "insmod vfio-pci.ko false"
fi
echo "insmod vfio-pci.ko success!!!"
}
function run_nat(){
echo "$UE_IP"
echo "$UE_IP_PREFIX"
echo "$SNAT_INTER"
echo "$SNAT_IP"
echo "$VPPHOST"
echo "$DPDK_EXPORT"
echo "$DPDK_ENTRY"
sudo ifconfig $DPDK_EXPORT down
sudo ifconfig $DPDK_ENTRY down
sudo ethtool -K "$SNAT_INTER" gro off;
sudo ethtool -K "$SNAT_INTER" tso off;
sudo ethtool -K "$SNAT_INTER" sg off;
#del
sudo iptables -t nat -D POSTROUTING -s "$UE_IP/$UE_IP_PREFIX" -j SNAT --to-source "$SNAT_IP"
iptables -t mangle -D POSTROUTING -p tcp --tcp-flags SYN,RST SYN -o "$SNAT_INTER" -j TCPMSS --set-mss 1300
#add
sudo iptables -t nat -A POSTROUTING -s "$UE_IP/$UE_IP_PREFIX" -j SNAT --to-source "$SNAT_IP"
iptables -t mangle -A POSTROUTING -p tcp --tcp-flags SYN,RST SYN -o "$SNAT_INTER" -j TCPMSS --set-mss 1300
#system
echo "1" > /proc/sys/net/ipv4/ip_forward
}
function help()
{
echo " "
echo "Usage: build_upf [OPTION]..."
echo "--start Start UPF"
echo "--close Close UPF"
}
function install_depence(){
cp $base/plugin/yq $current > /dev/null 2>&1
cp $base/plugin/replace/replace $current > /dev/null 2>&1
}
function unbind(){
python3 $current/dpdk-devbind.py -u 0000:$DPDK_EXPORT_PCI ;
python3 $current/dpdk-devbind.py -u 0000:$DPDK_EXPORT_PCI;
python3 $current/dpdk-devbind.py -b $DRIVE $DPDK_EXPORT_PCI
sleep 1
python3 $current/dpdk-devbind.py -b $DRIVE $DPDK_EXPORT_PCI
sleep 1
ifconfig $DPDK_EXPORT down;
sleep 1
ifconfig $DPDK_ENTRY down;
sleep 1
}
function main() {
install_depence
if [ $# -eq 0 ];
then
help
exit
fi
until [ -z "$1" ]; do
case "$1" in
-o)
init_configure $2
start_vpp
start_n4
start_arp
shift
;;
--close)
close_vpp
close_n4
close_arp
# unbind
shift
;;
esac
done
return 0
}
main "$@"
src/vppe/build/external/Makefile
View file @ 54339cbc
......@@ -53,12 +53,12 @@ config: dpdk-config rdma-core-config
##############################################################################
# .deb packaging
##############################################################################
PKG_VERSION=20.05
PKG_SUFFIX=8
#PKG_VERSION=20.05
#PKG_SUFFIX=8
DEB_VER := $(PKG_VERSION)
DEB_ARCH=$(shell dpkg --print-architecture 2> /dev/null)
DEB_ARCH=amd64
#DEB_ARCH=amd64
DEV_DEB=vpp-ext-deps_$(DEB_VER)-$(PKG_SUFFIX)_$(DEB_ARCH).deb
INSTALLED_VER=$(shell dpkg-query --showformat='$${Version}' --show vpp-ext-deps 2> /dev/null)
......
src/vppe/pre_install.sh
View file @ 54339cbc
#!/bin/bash
tar -zxvf git_bak.tar.gz
mv ./git_bak/.git ./
apt install epel-release
apt install cmake3
apt install ninja-build
......
src/vppe/src/CMakeLists.txt
View file @ 54339cbc
......@@ -30,8 +30,8 @@ execute_process(
OUTPUT_STRIP_TRAILING_WHITESPACE
)
string(CONCAT VPP_VERSION "v20.05-rc0~582-g1339dce8f")
string(CONCAT VPP_LIB_VERSION "20.05")
#string(CONCAT VPP_VERSION "v20.05-rc0~582-g1339dce8f")
#string(CONCAT VPP_LIB_VERSION "20.05")
string(REPLACE "-" ";" VPP_LIB_VERSION ${VPP_VERSION})
list(GET VPP_LIB_VERSION 0 VPP_LIB_VERSION)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment