P4 (P4_16) switch: Broadcast

Based on https://github.com/p4lang/p4app/tree/master/examples/broadcast.p4app and http://lists.p4.org/pipermail/p4-dev_lists.p4.org/2017-April/002742.html, I write this lab.

[topology]

Three hosts, i.e. h1, h2, and h3 are connecting to P4 switch (s1).

H1 will send a packet with (Destination IP=255.255.255.255) and h2 and h3 will receive the packet.

[basic.p4]

#include <core.p4>

#include <v1model.p4>

#include "header.p4"

#include "parser.p4"

control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {

action rewrite_mac(bit<48> smac) {

hdr.ethernet.srcAddr = smac;

}

action _drop() {

mark_to_drop();

}

table send_frame {

actions = {

rewrite_mac;

_drop;

NoAction;

}

key = {

standard_metadata.egress_port: exact;

}

size = 256;

default_action = NoAction();

}

apply {

if (hdr.ipv4.isValid()) {

send_frame.apply();

}

}

}

control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {

action _drop() {

mark_to_drop();

}

action set_nhop(bit<32> nhop_ipv4, bit<9> port) {

meta.ingress_metadata.nhop_ipv4 = nhop_ipv4;

standard_metadata.egress_spec = port;

hdr.ipv4.ttl = hdr.ipv4.ttl + 8w255;

}

action broadcast() {

standard_metadata.mcast_grp = 1;

meta.ingress_metadata.nhop_ipv4 = hdr.ipv4.dstAddr;

hdr.ipv4.ttl = hdr.ipv4.ttl + 8w255;

}

action set_dmac(bit<48> dmac) {

hdr.ethernet.dstAddr = dmac;

}

table ipv4_lpm {

actions = {

_drop;

set_nhop;

broadcast;

NoAction;

}

key = {

hdr.ipv4.dstAddr: lpm;

}

size = 1024;

default_action = NoAction();

}

table forward {

actions = {

set_dmac;

_drop;

NoAction;

}

key = {

meta.ingress_metadata.nhop_ipv4: exact;

}

size = 512;

default_action = NoAction();

}

apply {

if (hdr.ipv4.isValid()) {

ipv4_lpm.apply();

forward.apply();

}

}

}

V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;

[test_topo.py]

import os

from mininet.net import Mininet

from mininet.topo import Topo

from mininet.log import setLogLevel, info

from mininet.cli import CLI

from mininet.node import RemoteController

from p4_mininet import P4Switch, P4Host

import argparse

from time import sleep

parser = argparse.ArgumentParser(description='Mininet demo')

parser.add_argument('--behavioral-exe', help='Path to behavioral executable',

type=str, action="store", required=False, default='simple_switch' )

parser.add_argument('--thrift-port', help='Thrift server port for table updates',

type=int, action="store", default=9090)

parser.add_argument('--num-hosts', help='Number of hosts to connect to switch',

type=int, action="store", default=2)

parser.add_argument('--mode', choices=['l2', 'l3'], type=str, default='l3')

parser.add_argument('--json', help='Path to JSON config file',

type=str, action="store", required=True)

parser.add_argument('--pcap-dump', help='Dump packets on interfaces to pcap files',

type=str, action="store", required=False, default=False)

args = parser.parse_args()

class SingleSwitchTopo(Topo):

def __init__(self, sw_path, json_path, thrift_port, pcap_dump, **opts):

Topo.__init__(self, **opts)

switch1 = self.addSwitch('s1', sw_path = sw_path, json_path = json_path, thrift_port = thrift_port,cls = P4Switch ,pcap_dump = pcap_dump)

host1 = self.addHost('h1', mac = '00:00:00:00:00:01')

host2 = self.addHost('h2', mac = '00:00:00:00:00:02')

host3 = self.addHost('h3', mac = '00:00:00:00:00:03')

self.addLink(host1, switch1, port1 = 0, port2 = 1)

self.addLink(host2, switch1, port1 = 0, port2 = 2)

self.addLink(host3, switch1, port1 = 0, port2 = 3)

def main():

topo = SingleSwitchTopo(args.behavioral_exe, args.json, args.thrift_port, args.pcap_dump)

#controller1 = RemoteController('controller1', ip = '10.108.148.148')

net = Mininet(topo = topo, host = P4Host, controller = None)

net.start()

sleep(1)

print('\033[0;32m'),

print "Gotcha!"

print('\033[0m')

CLI(net)

try:

net.stop()

except:

print('\033[0;31m'),

print('Stop error! Trying sudo mn -c')

print('\033[0m')

os.system('sudo mn -c')

print('\033[0;32m'),

print ('Stop successfully!')

print('\033[0m')

if __name__ == '__main__':

setLogLevel('info')

main()

[start_test_topo.py]

import os

os.system("sudo python test_topo.py --behavioral-exe /home/vagrant/behavioral-model/targets/simple_switch/simple_switch --json basic.json")

[cmd.txt]

table_add forward set_dmac 255.255.255.255 => ff:ff:ff:ff:ff:ff

table_add ipv4_lpm broadcast 255.255.255.255/32 =>

mc_mgrp_create 1

mc_node_create 0 1

mc_node_associate 1 0

mc_node_create 1 2

mc_node_associate 1 1

mc_node_create 2 3

mc_node_associate 1 2

[cmd_add.py]

import os

os.system('sudo /home/vagrant/behavioral-model/targets/simple_switch/simple_switch_CLI --thrift-port=9090 < /home/p4/mytest/p4-broadcast/cmd.txt')

[bcast_send.py]

#!/usr/bin/env python

from socket import *

s = socket(AF_INET, SOCK_DGRAM)

s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

s.sendto('hello everyone', ('255.255.255.255', 1234))

[bcast_receive.py]

#!/usr/bin/env python

import sys

from socket import *

s = socket(AF_INET, SOCK_DGRAM)

s.bind(('', 1234))

sys.stderr.write("received '%s' from %s\n" % s.recvfrom(1024))

[header.p4]

#ifndef __HEADER_P4__

#define __HEADER_P4__ 1

struct ingress_metadata_t {

bit<32> nhop_ipv4;

}

header ethernet_t {

bit<48> dstAddr;

bit<48> srcAddr;

bit<16> etherType;

}

header ipv4_t {

bit<4> version;

bit<4> ihl;

bit<8> diffserv;

bit<16> totalLen;

bit<16> identification;

bit<3> flags;

bit<13> fragOffset;

bit<8> ttl;

bit<8> protocol;

bit<16> hdrChecksum;

bit<32> srcAddr;

bit<32> dstAddr;

}

struct metadata {

@name("ingress_metadata")

ingress_metadata_t ingress_metadata;

}

struct headers {

@name("ethernet")

ethernet_t ethernet;

@name("ipv4")

ipv4_t ipv4;

}

#endif // __HEADER_H__

[parser.p4]

parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {

state parse_ethernet {

packet.extract(hdr.ethernet);

transition select(hdr.ethernet.etherType) {

16w0x800: parse_ipv4;

default: accept;

}

}

state parse_ipv4 {

packet.extract(hdr.ipv4);

transition accept;

}

state start {

transition parse_ethernet;

}

}

control DeparserImpl(packet_out packet, in headers hdr) {

apply {

packet.emit(hdr.ethernet);

packet.emit(hdr.ipv4);

}

}

control verifyChecksum(inout headers hdr, inout metadata meta) {

apply { }

}

control computeChecksum(inout headers hdr, inout metadata meta) {

apply {

update_checksum(

hdr.ipv4.isValid(),

{ hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv,

hdr.ipv4.totalLen, hdr.ipv4.identification,

hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl,

hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr },

hdr.ipv4.hdrChecksum,

HashAlgorithm.csum16);

}

}

[p4_mininet.py]

# Copyright 2013-present Barefoot Networks, Inc.

#

# 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.

#

from mininet.net import Mininet

from mininet.node import Switch, Host

from mininet.log import setLogLevel, info, error, debug

from mininet.moduledeps import pathCheck

from sys import exit

import os

import tempfile

import socket

class P4Host(Host):

def config(self, **params):

r = super(Host, self).config(**params)

self.defaultIntf().rename("eth0")

for off in ["rx", "tx", "sg"]:

cmd = "/sbin/ethtool --offload eth0 %s off" % off

self.cmd(cmd)

# disable IPv6

self.cmd("sysctl -w net.ipv6.conf.all.disable_ipv6=1")

self.cmd("sysctl -w net.ipv6.conf.default.disable_ipv6=1")

self.cmd("sysctl -w net.ipv6.conf.lo.disable_ipv6=1")

return r

def describe(self):

print "**********"

print self.name

print "default interface: %s\t%s\t%s" %(

self.defaultIntf().name,

self.defaultIntf().IP(),

self.defaultIntf().MAC()

)

print "**********"

class P4Switch(Switch):

"""P4 virtual switch"""

device_id = 0

def __init__(self, name, sw_path = None, json_path = None,

thrift_port = None,

pcap_dump = False,

log_console = False,

verbose = False,

device_id = None,

enable_debugger = False,

**kwargs):

Switch.__init__(self, name, **kwargs)

assert(sw_path)

assert(json_path)

# make sure that the provided sw_path is valid

pathCheck(sw_path)

# make sure that the provided JSON file exists

if not os.path.isfile(json_path):

error("Invalid JSON file.\n")

exit(1)

self.sw_path = sw_path

self.json_path = json_path

self.verbose = verbose

logfile = "/tmp/p4s.{}.log".format(self.name)

self.output = open(logfile, 'w')

self.thrift_port = thrift_port

self.pcap_dump = pcap_dump

self.enable_debugger = enable_debugger

self.log_console = log_console

if device_id is not None:

self.device_id = device_id

P4Switch.device_id = max(P4Switch.device_id, device_id)

else:

self.device_id = P4Switch.device_id

P4Switch.device_id += 1

self.nanomsg = "ipc:///tmp/bm-{}-log.ipc".format(self.device_id)

@classmethod

def setup(cls):

pass

def check_switch_started(self, pid):

"""While the process is running (pid exists), we check if the Thrift

server has been started. If the Thrift server is ready, we assume that

the switch was started successfully. This is only reliable if the Thrift

server is started at the end of the init process"""

while True:

if not os.path.exists(os.path.join("/proc", str(pid))):

return False

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.settimeout(0.5)

result = sock.connect_ex(("localhost", self.thrift_port))

if result == 0:

return True

def start(self, controllers):

"Start up a new P4 switch"

info("Starting P4 switch {}.\n".format(self.name))

args = [self.sw_path]

for port, intf in self.intfs.items():

if not intf.IP():

args.extend(['-i', str(port) + "@" + intf.name])

#wuwzhs edit in 2017/11/10

#args.extend(['-i 3@veth1'])

if self.pcap_dump:

args.append("--pcap")

# args.append("--useFiles")

if self.thrift_port:

args.extend(['--thrift-port', str(self.thrift_port)])

if self.nanomsg:

args.extend(['--nanolog', self.nanomsg])

args.extend(['--device-id', str(self.device_id)])

P4Switch.device_id += 1

args.append(self.json_path)

if self.enable_debugger:

args.append("--debugger")

if self.log_console:

args.append("--log-console")

logfile = "/tmp/p4s.{}.log".format(self.name)

info(' '.join(args) + "\n")

pid = None

with tempfile.NamedTemporaryFile() as f:

# self.cmd(' '.join(args) + ' > /dev/null 2>&1 &')

self.cmd(' '.join(args) + ' >' + logfile + ' 2>&1 & echo $! >> ' + f.name)

pid = int(f.read())

debug("P4 switch {} PID is {}.\n".format(self.name, pid))

if not self.check_switch_started(pid):

error("P4 switch {} did not start correctly.\n".format(self.name))

exit(1)

info("P4 switch {} has been started.\n".format(self.name))

def stop(self):

"Terminate P4 switch."

self.output.flush()

self.cmd('kill %' + self.sw_path)

self.cmd('wait')

self.deleteIntfs()

def attach(self, intf):

"Connect a data port"

assert(0)

def detach(self, intf):

"Disconnect a data port"

assert(0)

[Execution]

Dr. Chih-Heng Ke (smallko@gmail.com)

Department of Computer Science and Information Engineering,

National Quemoy University, Kinmen, Taiwan.