# Basic Forwarding
## Introduction
Copyright By PowCoder代写 加微信 powcoder
The objective of this exercise is to write a P4 program that
implements basic forwarding. To keep things simple, we will just
implement forwarding for IPv4.
With IPv4 forwarding, the switch must perform the following actions
for every packet: (i) update the source and destination MAC addresses,
(ii) decrement the time-to-live (TTL) in the IP header, and (iii)
forward the packet out the appropriate port.
Your switch will have a single table, which the control plane will
populate with static rules. Each rule will map an IP address to the
MAC address and output port for the next hop. We have already defined
the control plane rules, so you only need to implement the data plane
logic of your P4 program.
We will use the following topology for this exercise. It is a single
pod of a fat-tree topology and henceforth referred to as pod-topo:
Our P4 program will be written for the V1Model architecture implemented
on P4.org’s bmv2 software switch. The architecture file for the V1Model
can be found at: /usr/local/share/p4c/p4include/v1model.p4. This file
desribes the interfaces of the P4 programmable elements in the architecture,
the supported externs, as well as the architecture’s standard metadata
fields. We encourage you to take a look at it.
## Step 1: Run the (incomplete) starter code
The directory with this README also contains a skeleton P4 program,
`basic.p4`, which doesn’t compile. Your job will be to
extend this skeleton program to properly forward IPv4 packets.
Before that, let’s compile the incomplete `basic.p4`
1. In your shell, run:
2. Type `exit` to leave the Mininet command line.
Then, to stop mininet:
And to delete all pcaps, build files, and logs:
make clean
### A note about the control plane
A P4 program defines a packet-processing pipeline, but the rules
within each table are inserted by the control plane. When a rule
matches a packet, its action is invoked with parameters supplied by
the control plane as part of the rule.
In this exercise, we have already implemented the control plane
logic for you. As part of bringing up the Mininet instance, the
`make run` command will install packet-processing rules in the tables of
each switch. These are defined in the `sX-runtime.json` files, where
`X` corresponds to the switch number.
**Important:** We use P4Runtime to install the control plane rules. The
content of files `sX-runtime.json` refer to specific names of tables, keys, and
actions, as defined in the P4Info file produced by the compiler (look for the
file `build/basic.p4.p4info.txt` after executing `make run`). Any changes in the P4
program that add or rename tables, keys, or actions will need to be reflected in
these `sX-runtime.json` files.
## Step 2: Implement L3 forwarding
The `basic.p4` file contains a skeleton P4 program with key pieces of
logic replaced by `TODO` comments. Your implementation should follow
the structure given in this file—replace each `TODO` with logic
implementing the missing piece.
A complete `basic.p4` will contain the following components:
1. Header type definitions for Ethernet (`ethernet_t`) and IPv4 (`ipv4_t`).
2. Parsers for Ethernet and IPv4 that populate `ethernet_t` and `ipv4_t` fields.
3. An action to drop a packet, using `mark_to_drop()`.
4. An action (called `ipv4_forward`) that:
1. Sets the egress port for the next hop.
2. Updates the ethernet destination address with the address of the next hop.
3. Updates the ethernet source address with the address of the switch.
4. Decrements the TTL.
5. A control that:
1. Defines a table that will read an IPv4 destination address, and
invoke either `drop` or `ipv4_forward`.
2. An `apply` block that applies the table.
6. A deparser that selects the order
in which fields inserted into the outgoing packet.
7. A `package` instantiation supplied with the parser, control, and deparser.
> In general, a package also requires instances of checksum verification
> and recomputation controls. These are not necessary for this tutorial
> and are replaced with instantiations of empty controls.
## Step 3: Run your solution
Follow the instructions from Step 1. This time, you should be able to
sucessfully ping between any two hosts in the topology.
#### Cleaning up Mininet
In the latter two cases above, `make run` may leave a Mininet instance
running in the background. Use the following command to clean up
these instances:
程序代写 CS代考 加微信: powcoder QQ: 1823890830 Email: powcoder@163.com