第34周：P4 可编程数据平面入门

字数统计: 3.7k字   |   阅读时长≈ 19分

第34周：P4 可编程数据平面入门

目标：理解 P4 编程语言模型，能够编写 P4 程序实现自定义包处理，并使用 BMv2 模拟器运行验证。

1. P4 概述

1.1 P4 是什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
P4（Programming Protocol-independent Packet Processors）：
  - 协议无关的包处理器编程语言
  - 描述数据包如何被解析、处理、转发
  - 与 P4Runtime 配合可下发到交换机

  关键特性：
  - 协议无关（不绑定特定协议）
  - 目标无关（同一程序可运行在 ASIC/FPGA/软件）
  - 现场可重配置（programmable at runtime）

  应用：
  - 自定义协议处理
  - in-network 计算
  - 智能网卡（SmartNIC）编程
  - 快速原型开发

1.2 P4 vs OpenFlow

1
2
3
4
5
6
7
8
9
10
11
OpenFlow：
  - 固定的协议集（以太网、IPv4、IPv6、MPLS 等）
  - 固定的匹配字段
  - 控制器配置流表
  - 限制：不能扩展新协议

P4：
  - 程序员定义协议头
  - 程序员定义匹配-动作
  - 编译器生成目标配置
  - 灵活：可处理任何协议

1.3 P4 架构（v1model）

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
┌──────────────────────────────────────────┐
│  P4 数据面（target-independent）          │
│  ┌────────────────────────────────┐     │
│  │  Parser                        │     │
│  │  解析包头                      │     │
│  └────────┬───────────────────────┘     │
│           ▼                                │
│  ┌────────────────────────────────┐     │
│  │  Match-Action Pipeline         │     │
│  │  Ingress │  Egress             │     │
│  │  - 匹配字段                    │     │
│  │  - 动作（修改、转发、丢弃）    │     │
│  └────────┬───────────────────────┘     │
│           ▼                                │
│  ┌────────────────────────────────┐     │
│  │  Deparser                      │     │
│  │  重组包头                      │     │
│  └────────────────────────────────┘     │
└──────────────────────────────────────────┘
                  │
                  ▼
┌──────────────────────────────────────────┐
│  目标（target-dependent）                  │
│  - BMv2（软件模拟）                        │
│  - Tofino（ASIC）                          │
│  - Netronome（SmartNIC）                   │
│  - 软件交换机                              │
└──────────────────────────────────────────┘

2. P4 语言基础

2.1 程序结构

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
// basic.p4 — P4 程序的基本结构

// 1. 头定义
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;
}

// 2. 元数据结构
struct metadata {
    bit<9>  ingress_port;
    bit<9>  egress_spec;
    bit<32> nhop_ipv4;
    bit<48> dst_mac;
    bit<48> src_mac;
}

// 3. 包解析（栈）
struct headers {
    ethernet_t   ethernet;
    ipv4_t       ipv4;
}

// 4. 解析器
parser MyParser(packet_in pkt, out headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    state start {
        pkt.extract(hdr.ethernet);
        transition select(hdr.ethernet.etherType) {
            0x0800: parse_ipv4;
            default: accept;
        }
    }
    state parse_ipv4 {
        pkt.extract(hdr.ipv4);
        transition accept;
    }
}

// 5. 逆解析器
control MyDeparser(packet_out pkt, in headers hdr) {
    apply {
        pkt.emit(hdr.ethernet);
        pkt.emit(hdr.ipv4);
    }
}

// 6. 入口处理
control MyIngress(inout headers hdr, inout metadata meta,
                  inout standard_metadata_t standard_metadata) {
    apply {
        // 匹配-动作
    }
}

// 7. 出口处理
control MyEgress(inout headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    apply {
    }
}

// 8. 校验和验证
control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
    apply {
        verify_checksum(hdr.ipv4.isValid(),
                         hdr.ipv4.hdrChecksum,
                         { ... },
                         hdr.ipv4.hdrChecksum);
    }
}

// 9. 校验和更新
control MyComputeChecksum(inout headers hdr, inout metadata meta) {
    apply {
        update_checksum(hdr.ipv4.isValid(),
                         hdr.ipv4.hdrChecksum,
                         { ... },
                         hdr.ipv4.hdrChecksum);
    }
}

// 10. 组合
V1Switch(MyParser, MyVerifyChecksum, MyIngress, MyEgress,
         MyComputeChecksum, MyDeparser) main;

2.2 数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// === 基础类型 ===
bit<N>      // N 位无符号整数
varbit<N>   // N 位可变长
int<N>      // N 位有符号整数
bool        // 布尔

// === 复合类型 ===
header      // 包头
struct      // 字段集合
header_union // 联合（互斥的头）
list        // 列表
tuple       // 元组

// === 字符串和错误 ===
string
error       // NoError, PacketTooShort, NoMatch, ...

// === 特殊类型 ===
Header<header_t>        // 头
Headers<H1, H2, ...>    // 头栈
Metadata<M1, M2, ...>   // 元数据
P4List<T, N>            // 列表

2.3 解析器详解

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
parser MyParser(packet_in pkt, out headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    state start {
        // extract：解析一个头
        pkt.extract(hdr.ethernet);
        // transition：转移到下一个状态
        transition select(hdr.ethernet.etherType) {
            // 0x0800 = IPv4
            0x0800 &&& 0xFFFF: parse_ipv4;
            0x86DD            : parse_ipv6;
            0x0806            : parse_arp;
            default           : accept;
        }
    }

    state parse_ipv4 {
        pkt.extract(hdr.ipv4);
        // verify：验证条件
        verify(hdr.ipv4.version == 4, error.PacketTooShort);
        // 嵌套选择
        transition select(hdr.ipv4.protocol) {
            6  : parse_tcp;   // TCP
            17 : parse_udp;   // UDP
            default: accept;
        }
    }

    state parse_tcp {
        pkt.extract(hdr.tcp);
        transition accept;
    }

    state parse_udp {
        pkt.extract(hdr.udp);
        transition accept;
    }
}

2.4 Match-Action 详解

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
control MyIngress(inout headers hdr, inout metadata meta,
                  inout standard_metadata_t standard_metadata) {
    // 动作定义
    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
        hdr.ethernet.dstAddr = dstAddr;
        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
        standard_metadata.egress_spec = port;
    }

    action drop() {
        mark_to_drop();
    }

    action ipv4_lpm() {
        // 后续填充
    }

    // 匹配-动作表
    table ipv4_lpm_l3 {
        key = {
            hdr.ipv4.dstAddr: lpm;  // LPM 匹配
        }
        actions = {
            ipv4_forward;   // 匹配的 action
            drop;
        }
        size = 1024;          // 表大小
        default_action = drop();  // 默认动作
    }

    apply {
        // 表应用
        if (hdr.ipv4.isValid()) {
            ipv4_lpm_l3.apply();
        } else {
            // 广播
            standard_metadata.egress_spec = ...;
        }
    }
}

3. 搭建 BMv2 环境

3.1 安装

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
# 方式 1：使用 Docker（推荐）
docker pull p4lang/behavioral-model

# 方式 2：源码编译（Ubuntu）
sudo apt-get update
sudo apt-get install -y \
    automake \
    cmake \
    libgmp-dev \
    libpcap-dev \
    libboost-dev \
    libboost-thread-dev \
    libboost-program-options-dev \
    libboost-system-dev \
    libssl-dev \
    libtool \
    pkg-config \
    python3-scapy

# 克隆并编译
git clone https://github.com/p4lang/behavioral-model.git
cd behavioral-model
./autogen.sh
./configure
make -j$(nproc)
sudo make install
sudo ldconfig

# 安装 P4 编译器
git clone https://github.com/p4lang/p4c.git
cd p4c
mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install

3.2 安装 P4Runtime

1
2
# P4Runtime shell
pip install p4runtime-shell

3.3 验证安装

1
2
3
4
5
simple_switch --help
# Usage: simple_switch [options] <json file>

p4c --help
# P4-16 compiler

4. basic.p4 示例

4.1 完整代码

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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
// basic.p4 — 简单的 P4 程序：转发 IPv4 包
#include <core.p4>
#include <v1model.p4>

// === 头定义 ===
const bit<16> TYPE_IPV4 = 0x800;
const bit<8> TYPE_TCP   = 6;
const bit<8> TYPE_UDP   = 17;

#define MAX_PORTS 256

typedef bit<9>  egressSpec_t;
typedef bit<48> macAddr_t;
typedef bit<32> ip4Addr_t;

header ethernet_t {
    macAddr_t dstAddr;
    macAddr_t 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;
    ip4Addr_t srcAddr;
    ip4Addr_t dstAddr;
}

header tcp_t {
    bit<16> srcPort;
    bit<16> dstPort;
    bit<32> seqNo;
    bit<32> ackNo;
    bit<4>  dataOffset;
    bit<3>  res;
    bit<3>  ecn;
    bit<6>  ctrl;
    bit<16> window;
    bit<16> checksum;
    bit<16> urgentPtr;
}

struct metadata {
    /* empty */
}

struct headers {
    ethernet_t   ethernet;
    ipv4_t       ipv4;
    tcp_t        tcp;
}

// === 解析器 ===
parser MyParser(packet_in pkt, out headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    state start {
        transition parse_ethernet;
    }

    state parse_ethernet {
        pkt.extract(hdr.ethernet);
        transition select(hdr.ethernet.etherType) {
            TYPE_IPV4: parse_ipv4;
            default: accept;
        }
    }

    state parse_ipv4 {
        pkt.extract(hdr.ipv4);
        verify(hdr.ipv4.version == 4, error.PacketTooShort);
        transition select(hdr.ipv4.protocol) {
            TYPE_TCP: parse_tcp;
            default: accept;
        }
    }

    state parse_tcp {
        pkt.extract(hdr.tcp);
        transition accept;
    }
}

// === 逆解析器 ===
control MyDeparser(packet_out pkt, in headers hdr) {
    apply {
        pkt.emit(hdr.ethernet);
        pkt.emit(hdr.ipv4);
        // 注意：TCP 头根据需要发送
    }
}

// === 校验和验证 ===
control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
    apply {
        verify_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);
    }
}

// === 校验和计算 ===
control MyComputeChecksum(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);
    }
}

// === 入口处理 ===
control MyIngress(inout headers hdr, inout metadata meta,
                  inout standard_metadata_t standard_metadata) {
    action drop() {
        mark_to_drop();
    }

    action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
        // 交换 MAC
        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
        hdr.ethernet.dstAddr = dstAddr;
        // TTL 减 1
        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
        // 设置出口
        standard_metadata.egress_spec = port;
    }

    table ipv4_lpm {
        key = {
            hdr.ipv4.dstAddr: lpm;
        }
        actions = {
            ipv4_forward;
            drop;
        }
        size = 1024;
        default_action = drop();
    }

    apply {
        if (hdr.ipv4.isValid()) {
            ipv4_lpm.apply();
        }
    }
}

// === 出口处理 ===
control MyEgress(inout headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    apply {
        // 出口阶段可省略
    }
}

// === 组合 ===
V1Switch(MyParser, MyVerifyChecksum, MyIngress, MyEgress,
         MyComputeChecksum, MyDeparser) main;

4.2 编译

1
2
3
4
5
# 编译为 JSON（BMv2 目标）
p4c --target bmv2 --arch v1model --output basic.json basic.p4

# 编译为 P4Info（用于 P4Runtime）
p4c --target bmv2 --arch v1model --p4runtime-files basic_p4info.txt --output basic.json basic.p4

4.3 运行 BMv2

1
2
3
4
5
6
7
8
9
10
# 启动 simple_switch
sudo simple_switch -i 0@veth0 -i 1@veth1 -i 2@veth2 basic.json

# 参数：
# -i 0@veth0  — 端口 0 映射到 veth0
# -i 1@veth1  — 端口 1 映射到 veth1
# basic.json  — 编译输出

# 启动后查看日志
simple_switch --log-level info ...

4.4 下发流表

1
2
3
4
5
6
7
# 通过 simple_switch_CLI
simple_switch_CLI --thrift-port 9090

# 在 CLI 中：
# table_add ipv4_lpm ipv4_forward 10.0.0.1/32 => 00:11:22:33:44:55 1
# table_add ipv4_lpm ipv4_forward 10.0.0.2/32 => 00:11:22:33:44:66 2
# table_add ipv4_lpm ipv4_forward 0.0.0.0/0  => 00:00:00:00:00:00 1

4.5 测试

1
2
3
4
5
# 准备发送包
python3 send.py  # 见下面

# 抓包
tcpdump -i veth1 -nn

5. 实践：P4 IPv4 路由器

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
151
152
153
154
155
156
157
158
159
// router.p4 — 完整的 IPv4 路由器

#include <core.p4>
#include <v1model.p4>

// === 常量与类型 ===
const bit<16> TYPE_IPV4 = 0x800;
const bit<16> TYPE_ARP  = 0x806;

#define MAX_PORTS 256
#define MAX_ROUTES 65536

typedef bit<9>  egressSpec_t;
typedef bit<48> macAddr_t;
typedef bit<32> ip4Addr_t;

header ethernet_t {
    macAddr_t dstAddr;
    macAddr_t 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;
    ip4Addr_t srcAddr;
    ip4Addr_t dstAddr;
}

header arp_t {
    bit<16> htype;
    bit<16> ptype;
    bit<8>  hlen;
    bit<8>  plen;
    bit<16> oper;
    macAddr_t sha;
    ip4Addr_t spa;
    macAddr_t tha;
    ip4Addr_t tpa;
}

struct metadata {
    ip4Addr_t nhop_ipv4;
    macAddr_t nhop_mac;
    egressSpec_t egress_port;
}

struct headers {
    ethernet_t ethernet;
    ipv4_t     ipv4;
    arp_t      arp;
}

parser MyParser(packet_in pkt, out headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    state start {
        pkt.extract(hdr.ethernet);
        transition select(hdr.ethernet.etherType) {
            TYPE_IPV4: parse_ipv4;
            TYPE_ARP : parse_arp;
            default: accept;
        }
    }

    state parse_ipv4 {
        pkt.extract(hdr.ipv4);
        verify(hdr.ipv4.version == 4, error.PacketTooShort);
        transition accept;
    }

    state parse_arp {
        pkt.extract(hdr.arp);
        transition accept;
    }
}

control MyDeparser(packet_out pkt, in headers hdr) {
    apply {
        pkt.emit(hdr.ethernet);
        pkt.emit(hdr.ipv4);
    }
}

control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
    apply {
        verify_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);
    }
}

control MyComputeChecksum(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);
    }
}

control MyIngress(inout headers hdr, inout metadata meta,
                  inout standard_metadata_t standard_metadata) {
    // 动作
    action drop() {
        mark_to_drop();
    }

    action ipv4_forward(egressSpec_t egress_port, macAddr_t dstAddr) {
        meta.egress_port = egress_port;
        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
        hdr.ethernet.dstAddr = dstAddr;
        hdr.ipv4.ttl = hdr.ipv4.ttl - 1;
        standard_metadata.egress_spec = egress_port;
    }

    // 路由表
    table ipv4_lpm {
        key = {
            hdr.ipv4.dstAddr: lpm;
        }
        actions = {
            ipv4_forward;
            drop;
        }
        size = 1024;
        default_action = drop();
    }

    apply {
        if (hdr.ipv4.isValid() && hdr.ipv4.ttl > 0) {
            ipv4_lpm.apply();
        } else {
            mark_to_drop();
        }
    }
}

control MyEgress(inout headers hdr, inout metadata meta,
                 inout standard_metadata_t standard_metadata) {
    apply {
        // 出口处理（如镜像、QoS）
    }
}

V1Switch(MyParser, MyVerifyChecksum, MyIngress, MyEgress,
         MyComputeChecksum, MyDeparser) main;
1
2
3
4
5
6
7
8
9
10
11
# 编译
p4c --target bmv2 --arch v1model --output router.json router.p4

# 运行
simple_switch -i 0@veth0 -i 1@veth1 router.json

# 简单流表 CLI
simple_switch_CLI --thrift-port 9090 <<EOF
table_add ipv4_lpm ipv4_forward 10.0.0.0/24 => 1 00:00:00:00:00:01
table_add ipv4_lpm ipv4_forward 0.0.0.0/0 => 1 00:00:00:00:00:01
EOF

6. P4Runtime

6.1 P4Runtime 概念

1
2
3
4
5
6
7
8
9
10
11
P4Runtime = P4 程序的运行时 API

  客户端：控制器（Python/Go/C++）
  服务器：交换机（BMv2、Tofino）
  协议：gRPC

  提供能力：
  - 读取转发元素
  - 写入流表条目
  - 编程 Counter、Meter、Register
  - 读取包计数

6.2 Python 控制示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# p4runtime_client.py — 简单的 P4Runtime 客户端
from p4runtime_lib import helper
import google.rpc.status_pb2 as status

# 连接到 simple_switch
p4info_helper = helper.P4InfoHelper("router_p4info.txt")
s = helper.SwitchConnection("127.0.0.1:50051")

# 写入流表
te = p4info_helper.buildTableEntry(
    table_name="MyIngress.ipv4_lpm",
    match_fields={
        "hdr.ipv4.dstAddr": ("10.0.0.0", 24)
    },
    action_name="MyIngress.ipv4_forward",
    action_params={
        "port": 1,
        "dstAddr": "00:00:00:00:00:01"
    }
)
s.WriteTableEntry(te)

7. 主流 P4 目标

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BMv2（Behavioral Model）：
  - 软件模拟器
  - 教学、原型开发
  - 性能较低但兼容性好

Tofino（Intel/Barefoot）：
  - ASIC 芯片
  - 6.5 Tbps 吞吐
  - 业界标准

Netronome SmartNIC：
  - 基于 ARM 的智能网卡
  - 支持 P4 编程

CPL（Compile to Pipeline Language）：
  - 将 P4 编译为 P4C
  - 兼容性较好

P4CPU（软件目标）：
  - P4 在通用 CPU 上运行
  - 适合研究

8. 调试工具

8.1 simple_switch_CLI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
simple_switch_CLI --thrift-port 9090

# 帮助
help
# 列出所有表
table_info
# 显示表内容
table_dump ipv4_lpm
# 计数
counter_read <counter_name> <index>
# 寄存器
register_read <reg_name> <index>
# Mirror
mirroring_add <mirror_id> <port>

8.2 抓包分析

1
2
3
4
5
# 启动 BMv2 时开启日志
simple_switch --nanolog <file> router.json

# Wireshark 解析 P4 模拟的包
# 选 Tools → Lua Scripts → 加载 p4 解析脚本

8.3 nanomsg 日志

1
2
3
4
5
# 启动时输出 nanomsg
simple_switch --nanolog ipc:///tmp/bm-log --log-level info router.json

# 订阅日志
nanomsgcat ipc:///tmp/bm-log

9. 实践：编写和测试 P4 程序

9.1 实验环境

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
#!/bin/bash
# p4_lab.sh — P4 完整实验

set -e

# 1. 创建 veth pair 作为 P4 交换机的"端口"
ip link add veth-p4-0 type veth peer name veth-p4-host-0
ip link add veth-p4-1 type veth peer name veth-p4-host-1
ip link set veth-p4-host-0 up
ip link set veth-p4-host-1 up
ip link set veth-p4-0 up
ip link set veth-p4-1 up

# 2. 给 veth 配置 IP（模拟两个主机）
ip addr add 10.0.0.1/24 dev veth-p4-host-0
ip addr add 10.0.0.2/24 dev veth-p4-host-1

# 3. 启动 simple_switch
# (后台运行)
simple_switch -i 0@veth-p4-0 -i 1@veth-p4-1 --thrift-port 9090 \
    --log-file /tmp/simple_switch.log \
    router.json &
SW_PID=$!
sleep 1

# 4. 通过 CLI 下发流表
simple_switch_CLI --thrift-port 9090 <<EOF
table_set_default ipv4_lpm drop
table_add ipv4_lpm ipv4_forward 10.0.0.0/24 => 1 00:00:00:00:00:02
EOF

# 5. 测试
echo "=== Test 1: ping 模拟主机 ==="
ping -c 2 10.0.0.2

# 6. 抓包观察
echo "=== Test 2: 抓包观察 ==="
timeout 3 tcpdump -i veth-p4-0 -nn icmp

# 清理
kill $SW_PID
ip link del veth-p4-0
ip link del veth-p4-1

9.2 完整 P4 工具链

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# === 工具链命令 ===
# 1. 编译
p4c --target bmv2 --arch v1model --output basic.json basic.p4

# 2. 模拟运行
simple_switch basic.json

# 3. 配置流表
simple_switch_CLI --thrift-port 9090 < commands.txt

# 4. 调试
simple_switch --debugger --nanolog ipc:///tmp/bm-log basic.json

# 5. 测试
python3 -c "
from scapy.all import *
p = Ether()/IP(dst='10.0.0.2')/ICMP()
sendp(p, iface='veth-p4-0')
"

# 6. 编译 Tofino 目标
p4c --target tofino --arch v1model --output basic.tofino basic.p4

10. 进阶主题

10.1 P4-14 vs P4-16

1
2
3
4
5
6
7
8
9
P4-14（已废弃）：
  - 旧版 P4
  - 简单的头/表/动作模型

P4-16（当前）：
  - 引入 parser、control 块结构
  - arch 抽象
  - 类型系统更丰富
  - 推荐学习

10.2 PSA（Portable Switch Architecture）

1
2
3
4
5
6
7
8
9
10
11
PSA = P4 标准架构（取代 v1model）

  - 简化 P4 程序
  - 标准化的 match-action stages
  - 跨厂商可移植

  关键结构：
  - Ingress pipeline
  - Egress pipeline
  - Traffic manager
  - Packet replication

10.3 性能调优

1
2
3
4
5
6
7
8
9
10
11
12
13
// 表大小
table ipv4_lpm {
    size = 1000000;  // 预分配（影响芯片资源）
}

// 精确匹配 vs 三态 vs LPM
key = {
    hdr.ipv4.dstAddr: exact;  // 精确
    hdr.ipv4.dstAddr: ternary;  // 通配
    hdr.ipv4.dstAddr: lpm;  // 前缀
}

// 优化：常用字段优先匹配

10.4 P4 与 P4Runtime 集成

1
2
3
4
5
6
7
8
9
10
11
# 安装 P4Runtime shell
pip install p4runtime-shell

# 启动 P4Runtime 服务
p4runtime-sh --grpc-addr 127.0.0.1:50051 \
    --device-id 0 \
    --election-id 0 \
    --config basic.p4info.txt,basic.json

# 客户端
p4runtime-sh --grpc-addr 127.0.0.1:50051

11. 主流 P4 工具/产品

工具/产品 用途 备注
BMv2 软件模拟 学习首选
P4C 编译器 p4lang/p4c
PI P4Runtime 实现 P4Runtime server
Stratum SDN 操作系统 ONF 项目
ONOS SDN 控制器 支持 P4
Tofino Barefoot ASIC 6.5Tbps
SDE Switch Development Env Intel 配套
Netronome 智能网卡 P4 编程
Xilinx P4 FPGA 目标 适合原型

12. 学习路径

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
入门路径：

Week 1-2: P4 语言基础
  - 学习 header、parser、match-action
  - 编写 basic.p4

Week 3-4: BMv2 实践
  - 安装 BMv2
  - 编译运行 P4 程序
  - 下发流表测试

Week 5-6: 进阶 P4
  - checksum 计算
  - tunnel 处理
  - 多表联动

Week 7-8: P4Runtime
  - Python/Go 客户端
  - 实时控制
  - 集成控制器

进阶：
  - PSA 架构
  - Tofino 实际硬件
  - 性能调优
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870