| 1 | The following changes since commit 43ab9a5376c95c61ae898a222c4d04bdf60e239b: | 1 | The following changes since commit 92f8c6fef13b31ba222c4d20ad8afd2b79c4c28e: |
|---|---|---|---|
| 2 | 2 | ||
| 3 | hw/i386/vmport: fix missing definitions with non-log trace backends (2017-12-21 22:52:28 +0000) | 3 | Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20210525' into staging (2021-05-25 16:17:06 +0100) |
| 4 | 4 | ||
| 5 | are available in the git repository at: | 5 | are available in the git repository at: |
| 6 | 6 | ||
| 7 | https://github.com/jasowang/qemu.git tags/net-pull-request | 7 | https://github.com/jasowang/qemu.git tags/net-pull-request |
| 8 | 8 | ||
| 9 | for you to fetch changes up to 0065e915192cdf83c2700bb377e5323c2649476e: | 9 | for you to fetch changes up to 90322e646e87c1440661cb3ddbc0cc94309d8a4f: |
| 10 | 10 | ||
| 11 | qemu-doc: Update the deprecation information of -tftp, -bootp, -redir and -smb (2017-12-22 10:06:05 +0800) | 11 | MAINTAINERS: Added eBPF maintainers information. (2021-06-04 15:25:46 +0800) |
| 12 | 12 | ||
| 13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
| 14 | 14 | ||
| 15 | ---------------------------------------------------------------- | 15 | ---------------------------------------------------------------- |
| 16 | Ed Swierk via Qemu-devel (2): | 16 | Andrew Melnychenko (7): |
| 17 | e1000, e1000e: Move per-packet TX offload flags out of context state | 17 | net/tap: Added TUNSETSTEERINGEBPF code. |
| 18 | e1000: Separate TSO and non-TSO contexts, fixing UDP TX corruption | 18 | net: Added SetSteeringEBPF method for NetClientState. |
| 19 | ebpf: Added eBPF RSS program. | ||
| 20 | ebpf: Added eBPF RSS loader. | ||
| 21 | virtio-net: Added eBPF RSS to virtio-net. | ||
| 22 | docs: Added eBPF documentation. | ||
| 23 | MAINTAINERS: Added eBPF maintainers information. | ||
| 19 | 24 | ||
| 20 | Mark Cave-Ayland (13): | 25 | MAINTAINERS | 8 + |
| 21 | net: move CRC32 calculation from compute_mcast_idx() into its own net_crc32() function | 26 | configure | 8 +- |
| 22 | net: introduce net_crc32_le() function | 27 | docs/devel/ebpf_rss.rst | 125 +++++++++ |
| 23 | pcnet: switch pcnet over to use net_crc32_le() | 28 | docs/devel/index.rst | 1 + |
| 24 | eepro100: switch eepro100 e100_compute_mcast_idx() over to use net_crc32() | 29 | ebpf/ebpf_rss-stub.c | 40 +++ |
| 25 | sunhme: switch sunhme over to use net_crc32_le() | 30 | ebpf/ebpf_rss.c | 165 ++++++++++++ |
| 26 | sungem: fix multicast filter CRC calculation | 31 | ebpf/ebpf_rss.h | 44 ++++ |
| 27 | eepro100: use inline net_crc32() and bitshift instead of compute_mcast_idx() | 32 | ebpf/meson.build | 1 + |
| 28 | opencores_eth: use inline net_crc32() and bitshift instead of compute_mcast_idx() | 33 | ebpf/rss.bpf.skeleton.h | 431 +++++++++++++++++++++++++++++++ |
| 29 | lan9118: use inline net_crc32() and bitshift instead of compute_mcast_idx() | 34 | ebpf/trace-events | 4 + |
| 30 | ftgmac100: use inline net_crc32() and bitshift instead of compute_mcast_idx() | 35 | ebpf/trace.h | 1 + |
| 31 | ne2000: use inline net_crc32() and bitshift instead of compute_mcast_idx() | 36 | hw/net/vhost_net.c | 3 + |
| 32 | rtl8139: use inline net_crc32() and bitshift instead of compute_mcast_idx() | 37 | hw/net/virtio-net.c | 116 ++++++++- |
| 33 | net: remove unused compute_mcast_idx() function | 38 | include/hw/virtio/virtio-net.h | 4 + |
| 34 | 39 | include/net/net.h | 2 + | |
| 35 | Thomas Huth (3): | 40 | meson.build | 23 ++ |
| 36 | net: Remove the legacy "-net channel" parameter | 41 | meson_options.txt | 2 + |
| 37 | qemu-doc: The "-net nic" option can be used with "netdev=...", too | 42 | net/tap-bsd.c | 5 + |
| 38 | qemu-doc: Update the deprecation information of -tftp, -bootp, -redir and -smb | 43 | net/tap-linux.c | 13 + |
| 39 | 44 | net/tap-linux.h | 1 + | |
| 40 | hw/net/e1000.c | 92 ++++++++++++++++++++++++++++---------------------- | 45 | net/tap-solaris.c | 5 + |
| 41 | hw/net/e1000e.c | 4 +-- | 46 | net/tap-stub.c | 5 + |
| 42 | hw/net/e1000e_core.c | 16 ++++----- | 47 | net/tap.c | 9 + |
| 43 | hw/net/e1000e_core.h | 2 ++ | 48 | net/tap_int.h | 1 + |
| 44 | hw/net/e1000x_common.h | 2 -- | 49 | net/vhost-vdpa.c | 2 + |
| 45 | hw/net/eepro100.c | 32 +++--------------- | 50 | tools/ebpf/Makefile.ebpf | 21 ++ |
| 46 | hw/net/ftgmac100.c | 2 +- | 51 | tools/ebpf/rss.bpf.c | 571 +++++++++++++++++++++++++++++++++++++++++ |
| 47 | hw/net/lan9118.c | 3 +- | 52 | 27 files changed, 1607 insertions(+), 4 deletions(-) |
| 48 | hw/net/ne2000.c | 4 ++- | 53 | create mode 100644 docs/devel/ebpf_rss.rst |
| 49 | hw/net/opencores_eth.c | 3 +- | 54 | create mode 100644 ebpf/ebpf_rss-stub.c |
| 50 | hw/net/pcnet.c | 22 ++---------- | 55 | create mode 100644 ebpf/ebpf_rss.c |
| 51 | hw/net/rtl8139.c | 2 +- | 56 | create mode 100644 ebpf/ebpf_rss.h |
| 52 | hw/net/sungem.c | 5 ++- | 57 | create mode 100644 ebpf/meson.build |
| 53 | hw/net/sunhme.c | 25 +------------- | 58 | create mode 100644 ebpf/rss.bpf.skeleton.h |
| 54 | include/net/net.h | 5 ++- | 59 | create mode 100644 ebpf/trace-events |
| 55 | include/net/slirp.h | 2 -- | 60 | create mode 100644 ebpf/trace.h |
| 56 | net/net.c | 40 +++++++++++++++------- | 61 | create mode 100755 tools/ebpf/Makefile.ebpf |
| 57 | net/slirp.c | 34 ------------------- | 62 | create mode 100644 tools/ebpf/rss.bpf.c |
| 58 | qemu-doc.texi | 38 +++++++++++---------- | ||
| 59 | qemu-options.hx | 14 ++++---- | ||
| 60 | 20 files changed, 144 insertions(+), 203 deletions(-) | ||
| 61 | 63 | ||
| 62 | 64 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Ed Swierk via Qemu-devel <qemu-devel@nongnu.org> | ||
| 2 | 1 | ||
| 3 | sum_needed and cptse flags are received from the guest within each | ||
| 4 | transmit data descriptor. They are not part of the offload context; | ||
| 5 | instead, they determine how to apply a previously received context to | ||
| 6 | the packet being transmitted: | ||
| 7 | |||
| 8 | - If cptse is set, perform both segmentation and checksum offload | ||
| 9 | using the parameters in the TSO context; otherwise just do checksum | ||
| 10 | offload. (Currently the e1000 device incorrectly stores only one | ||
| 11 | context, which will be fixed in a subsequent patch.) | ||
| 12 | |||
| 13 | - Depending on the bits set in sum_needed, possibly perform L4 | ||
| 14 | checksum offload and/or IP checksum offload, using the parameters in | ||
| 15 | the appropriate context. | ||
| 16 | |||
| 17 | Move these flags out of struct e1000x_txd_props, which is otherwise | ||
| 18 | dedicated to storing values from a context descriptor, and into the | ||
| 19 | per-packet TX struct. | ||
| 20 | |||
| 21 | Signed-off-by: Ed Swierk <eswierk@skyportsystems.com> | ||
| 22 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 23 | --- | ||
| 24 | hw/net/e1000.c | 30 ++++++++++++++++-------------- | ||
| 25 | hw/net/e1000e.c | 4 ++-- | ||
| 26 | hw/net/e1000e_core.c | 16 ++++++++-------- | ||
| 27 | hw/net/e1000e_core.h | 2 ++ | ||
| 28 | hw/net/e1000x_common.h | 2 -- | ||
| 29 | 5 files changed, 28 insertions(+), 26 deletions(-) | ||
| 30 | |||
| 31 | diff --git a/hw/net/e1000.c b/hw/net/e1000.c | ||
| 32 | index XXXXXXX..XXXXXXX 100644 | ||
| 33 | --- a/hw/net/e1000.c | ||
| 34 | +++ b/hw/net/e1000.c | ||
| 35 | @@ -XXX,XX +XXX,XX @@ typedef struct E1000State_st { | ||
| 36 | unsigned char data[0x10000]; | ||
| 37 | uint16_t size; | ||
| 38 | unsigned char vlan_needed; | ||
| 39 | + unsigned char sum_needed; | ||
| 40 | + bool cptse; | ||
| 41 | e1000x_txd_props props; | ||
| 42 | uint16_t tso_frames; | ||
| 43 | } tx; | ||
| 44 | @@ -XXX,XX +XXX,XX @@ xmit_seg(E1000State *s) | ||
| 45 | unsigned int frames = s->tx.tso_frames, css, sofar; | ||
| 46 | struct e1000_tx *tp = &s->tx; | ||
| 47 | |||
| 48 | - if (tp->props.tse && tp->props.cptse) { | ||
| 49 | + if (tp->props.tse && tp->cptse) { | ||
| 50 | css = tp->props.ipcss; | ||
| 51 | DBGOUT(TXSUM, "frames %d size %d ipcss %d\n", | ||
| 52 | frames, tp->size, css); | ||
| 53 | @@ -XXX,XX +XXX,XX @@ xmit_seg(E1000State *s) | ||
| 54 | } | ||
| 55 | } else /* UDP */ | ||
| 56 | stw_be_p(tp->data+css+4, len); | ||
| 57 | - if (tp->props.sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 58 | + if (tp->sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 59 | unsigned int phsum; | ||
| 60 | // add pseudo-header length before checksum calculation | ||
| 61 | void *sp = tp->data + tp->props.tucso; | ||
| 62 | @@ -XXX,XX +XXX,XX @@ xmit_seg(E1000State *s) | ||
| 63 | tp->tso_frames++; | ||
| 64 | } | ||
| 65 | |||
| 66 | - if (tp->props.sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 67 | + if (tp->sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 68 | putsum(tp->data, tp->size, tp->props.tucso, | ||
| 69 | tp->props.tucss, tp->props.tucse); | ||
| 70 | } | ||
| 71 | - if (tp->props.sum_needed & E1000_TXD_POPTS_IXSM) { | ||
| 72 | + if (tp->sum_needed & E1000_TXD_POPTS_IXSM) { | ||
| 73 | putsum(tp->data, tp->size, tp->props.ipcso, | ||
| 74 | tp->props.ipcss, tp->props.ipcse); | ||
| 75 | } | ||
| 76 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 77 | } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) { | ||
| 78 | // data descriptor | ||
| 79 | if (tp->size == 0) { | ||
| 80 | - tp->props.sum_needed = le32_to_cpu(dp->upper.data) >> 8; | ||
| 81 | + tp->sum_needed = le32_to_cpu(dp->upper.data) >> 8; | ||
| 82 | } | ||
| 83 | - tp->props.cptse = (txd_lower & E1000_TXD_CMD_TSE) ? 1 : 0; | ||
| 84 | + tp->cptse = (txd_lower & E1000_TXD_CMD_TSE) ? 1 : 0; | ||
| 85 | } else { | ||
| 86 | // legacy descriptor | ||
| 87 | - tp->props.cptse = 0; | ||
| 88 | + tp->cptse = 0; | ||
| 89 | } | ||
| 90 | |||
| 91 | if (e1000x_vlan_enabled(s->mac_reg) && | ||
| 92 | e1000x_is_vlan_txd(txd_lower) && | ||
| 93 | - (tp->props.cptse || txd_lower & E1000_TXD_CMD_EOP)) { | ||
| 94 | + (tp->cptse || txd_lower & E1000_TXD_CMD_EOP)) { | ||
| 95 | tp->vlan_needed = 1; | ||
| 96 | stw_be_p(tp->vlan_header, | ||
| 97 | le16_to_cpu(s->mac_reg[VET])); | ||
| 98 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 99 | } | ||
| 100 | |||
| 101 | addr = le64_to_cpu(dp->buffer_addr); | ||
| 102 | - if (tp->props.tse && tp->props.cptse) { | ||
| 103 | + if (tp->props.tse && tp->cptse) { | ||
| 104 | msh = tp->props.hdr_len + tp->props.mss; | ||
| 105 | do { | ||
| 106 | bytes = split_size; | ||
| 107 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 108 | } | ||
| 109 | split_size -= bytes; | ||
| 110 | } while (bytes && split_size); | ||
| 111 | - } else if (!tp->props.tse && tp->props.cptse) { | ||
| 112 | + } else if (!tp->props.tse && tp->cptse) { | ||
| 113 | // context descriptor TSE is not set, while data descriptor TSE is set | ||
| 114 | DBGOUT(TXERR, "TCP segmentation error\n"); | ||
| 115 | } else { | ||
| 116 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 117 | |||
| 118 | if (!(txd_lower & E1000_TXD_CMD_EOP)) | ||
| 119 | return; | ||
| 120 | - if (!(tp->props.tse && tp->props.cptse && tp->size < tp->props.hdr_len)) { | ||
| 121 | + if (!(tp->props.tse && tp->cptse && tp->size < tp->props.hdr_len)) { | ||
| 122 | xmit_seg(s); | ||
| 123 | } | ||
| 124 | tp->tso_frames = 0; | ||
| 125 | - tp->props.sum_needed = 0; | ||
| 126 | + tp->sum_needed = 0; | ||
| 127 | tp->vlan_needed = 0; | ||
| 128 | tp->size = 0; | ||
| 129 | - tp->props.cptse = 0; | ||
| 130 | + tp->cptse = 0; | ||
| 131 | } | ||
| 132 | |||
| 133 | static uint32_t | ||
| 134 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription vmstate_e1000 = { | ||
| 135 | VMSTATE_UINT16(tx.props.mss, E1000State), | ||
| 136 | VMSTATE_UINT16(tx.size, E1000State), | ||
| 137 | VMSTATE_UINT16(tx.tso_frames, E1000State), | ||
| 138 | - VMSTATE_UINT8(tx.props.sum_needed, E1000State), | ||
| 139 | + VMSTATE_UINT8(tx.sum_needed, E1000State), | ||
| 140 | VMSTATE_INT8(tx.props.ip, E1000State), | ||
| 141 | VMSTATE_INT8(tx.props.tcp, E1000State), | ||
| 142 | VMSTATE_BUFFER(tx.header, E1000State), | ||
| 143 | diff --git a/hw/net/e1000e.c b/hw/net/e1000e.c | ||
| 144 | index XXXXXXX..XXXXXXX 100644 | ||
| 145 | --- a/hw/net/e1000e.c | ||
| 146 | +++ b/hw/net/e1000e.c | ||
| 147 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription e1000e_vmstate_tx = { | ||
| 148 | .version_id = 1, | ||
| 149 | .minimum_version_id = 1, | ||
| 150 | .fields = (VMStateField[]) { | ||
| 151 | - VMSTATE_UINT8(props.sum_needed, struct e1000e_tx), | ||
| 152 | + VMSTATE_UINT8(sum_needed, struct e1000e_tx), | ||
| 153 | VMSTATE_UINT8(props.ipcss, struct e1000e_tx), | ||
| 154 | VMSTATE_UINT8(props.ipcso, struct e1000e_tx), | ||
| 155 | VMSTATE_UINT16(props.ipcse, struct e1000e_tx), | ||
| 156 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription e1000e_vmstate_tx = { | ||
| 157 | VMSTATE_INT8(props.ip, struct e1000e_tx), | ||
| 158 | VMSTATE_INT8(props.tcp, struct e1000e_tx), | ||
| 159 | VMSTATE_BOOL(props.tse, struct e1000e_tx), | ||
| 160 | - VMSTATE_BOOL(props.cptse, struct e1000e_tx), | ||
| 161 | + VMSTATE_BOOL(cptse, struct e1000e_tx), | ||
| 162 | VMSTATE_BOOL(skip_cp, struct e1000e_tx), | ||
| 163 | VMSTATE_END_OF_LIST() | ||
| 164 | } | ||
| 165 | diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c | ||
| 166 | index XXXXXXX..XXXXXXX 100644 | ||
| 167 | --- a/hw/net/e1000e_core.c | ||
| 168 | +++ b/hw/net/e1000e_core.c | ||
| 169 | @@ -XXX,XX +XXX,XX @@ e1000e_rss_parse_packet(E1000ECore *core, | ||
| 170 | static void | ||
| 171 | e1000e_setup_tx_offloads(E1000ECore *core, struct e1000e_tx *tx) | ||
| 172 | { | ||
| 173 | - if (tx->props.tse && tx->props.cptse) { | ||
| 174 | + if (tx->props.tse && tx->cptse) { | ||
| 175 | net_tx_pkt_build_vheader(tx->tx_pkt, true, true, tx->props.mss); | ||
| 176 | net_tx_pkt_update_ip_checksums(tx->tx_pkt); | ||
| 177 | e1000x_inc_reg_if_not_full(core->mac, TSCTC); | ||
| 178 | return; | ||
| 179 | } | ||
| 180 | |||
| 181 | - if (tx->props.sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 182 | + if (tx->sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 183 | net_tx_pkt_build_vheader(tx->tx_pkt, false, true, 0); | ||
| 184 | } | ||
| 185 | |||
| 186 | - if (tx->props.sum_needed & E1000_TXD_POPTS_IXSM) { | ||
| 187 | + if (tx->sum_needed & E1000_TXD_POPTS_IXSM) { | ||
| 188 | net_tx_pkt_update_ip_hdr_checksum(tx->tx_pkt); | ||
| 189 | } | ||
| 190 | } | ||
| 191 | @@ -XXX,XX +XXX,XX @@ e1000e_process_tx_desc(E1000ECore *core, | ||
| 192 | return; | ||
| 193 | } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) { | ||
| 194 | /* data descriptor */ | ||
| 195 | - tx->props.sum_needed = le32_to_cpu(dp->upper.data) >> 8; | ||
| 196 | - tx->props.cptse = (txd_lower & E1000_TXD_CMD_TSE) ? 1 : 0; | ||
| 197 | + tx->sum_needed = le32_to_cpu(dp->upper.data) >> 8; | ||
| 198 | + tx->cptse = (txd_lower & E1000_TXD_CMD_TSE) ? 1 : 0; | ||
| 199 | e1000e_process_ts_option(core, dp); | ||
| 200 | } else { | ||
| 201 | /* legacy descriptor */ | ||
| 202 | e1000e_process_ts_option(core, dp); | ||
| 203 | - tx->props.cptse = 0; | ||
| 204 | + tx->cptse = 0; | ||
| 205 | } | ||
| 206 | |||
| 207 | addr = le64_to_cpu(dp->buffer_addr); | ||
| 208 | @@ -XXX,XX +XXX,XX @@ e1000e_process_tx_desc(E1000ECore *core, | ||
| 209 | tx->skip_cp = false; | ||
| 210 | net_tx_pkt_reset(tx->tx_pkt); | ||
| 211 | |||
| 212 | - tx->props.sum_needed = 0; | ||
| 213 | - tx->props.cptse = 0; | ||
| 214 | + tx->sum_needed = 0; | ||
| 215 | + tx->cptse = 0; | ||
| 216 | } | ||
| 217 | } | ||
| 218 | |||
| 219 | diff --git a/hw/net/e1000e_core.h b/hw/net/e1000e_core.h | ||
| 220 | index XXXXXXX..XXXXXXX 100644 | ||
| 221 | --- a/hw/net/e1000e_core.h | ||
| 222 | +++ b/hw/net/e1000e_core.h | ||
| 223 | @@ -XXX,XX +XXX,XX @@ struct E1000Core { | ||
| 224 | e1000x_txd_props props; | ||
| 225 | |||
| 226 | bool skip_cp; | ||
| 227 | + unsigned char sum_needed; | ||
| 228 | + bool cptse; | ||
| 229 | struct NetTxPkt *tx_pkt; | ||
| 230 | } tx[E1000E_NUM_QUEUES]; | ||
| 231 | |||
| 232 | diff --git a/hw/net/e1000x_common.h b/hw/net/e1000x_common.h | ||
| 233 | index XXXXXXX..XXXXXXX 100644 | ||
| 234 | --- a/hw/net/e1000x_common.h | ||
| 235 | +++ b/hw/net/e1000x_common.h | ||
| 236 | @@ -XXX,XX +XXX,XX @@ void e1000x_update_regs_on_autoneg_done(uint32_t *mac, uint16_t *phy); | ||
| 237 | void e1000x_increase_size_stats(uint32_t *mac, const int *size_regs, int size); | ||
| 238 | |||
| 239 | typedef struct e1000x_txd_props { | ||
| 240 | - unsigned char sum_needed; | ||
| 241 | uint8_t ipcss; | ||
| 242 | uint8_t ipcso; | ||
| 243 | uint16_t ipcse; | ||
| 244 | @@ -XXX,XX +XXX,XX @@ typedef struct e1000x_txd_props { | ||
| 245 | int8_t ip; | ||
| 246 | int8_t tcp; | ||
| 247 | bool tse; | ||
| 248 | - bool cptse; | ||
| 249 | } e1000x_txd_props; | ||
| 250 | |||
| 251 | void e1000x_read_tx_ctx_descr(struct e1000_context_desc *d, | ||
| 252 | -- | ||
| 253 | 2.7.4 | ||
| 254 | |||
| 255 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Ed Swierk via Qemu-devel <qemu-devel@nongnu.org> | ||
| 2 | 1 | ||
| 3 | The device is supposed to maintain two distinct contexts for transmit | ||
| 4 | offloads: one has parameters for both segmentation and checksum | ||
| 5 | offload, the other only for checksum offload. The guest driver can | ||
| 6 | send two context descriptors, one for each context (the TSE flag | ||
| 7 | specifies which). Then the guest can refer to one or the other context | ||
| 8 | in subsequent transmit data descriptors, depending on what offloads it | ||
| 9 | wants applied to each packet. | ||
| 10 | |||
| 11 | Currently the e1000 device stores just one context, and misinterprets | ||
| 12 | the TSE flags in the context and data descriptors. This is often okay: | ||
| 13 | Linux happens to send a fresh context descriptor before every data | ||
| 14 | descriptor, so forgetting the other context doesn't matter. Windows | ||
| 15 | does rely on separate contexts for TSO vs. non-TSO packets, but for | ||
| 16 | mostly-TCP traffic the two contexts have identical TCP-specific | ||
| 17 | offload parameters so confusing them doesn't matter. | ||
| 18 | |||
| 19 | One case where this confusion matters is when a Windows guest sets up | ||
| 20 | a TSO context for TCP and a non-TSO context for UDP, and then | ||
| 21 | transmits both TCP and UDP traffic in parallel. The e1000 device | ||
| 22 | sometimes ends up using TCP-specific parameters while doing checksum | ||
| 23 | offload on a UDP datagram: it writes the checksum to offset 16 (the | ||
| 24 | correct location for a TCP checksum), stomping on two bytes of UDP | ||
| 25 | data, and leaving the wrong value in the actual UDP checksum field at | ||
| 26 | offset 6. (Even worse, the host network stack may then recompute the | ||
| 27 | UDP checksum, "correcting" it to match the corrupt data before sending | ||
| 28 | it out a physical interface.) | ||
| 29 | |||
| 30 | Correct this by tracking the TSO context independently of the non-TSO | ||
| 31 | context, and selecting the appropriate context based on the TSE flag | ||
| 32 | in each transmit data descriptor. | ||
| 33 | |||
| 34 | Signed-off-by: Ed Swierk <eswierk@skyportsystems.com> | ||
| 35 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 36 | --- | ||
| 37 | hw/net/e1000.c | 70 +++++++++++++++++++++++++++++++++------------------------- | ||
| 38 | 1 file changed, 40 insertions(+), 30 deletions(-) | ||
| 39 | |||
| 40 | diff --git a/hw/net/e1000.c b/hw/net/e1000.c | ||
| 41 | index XXXXXXX..XXXXXXX 100644 | ||
| 42 | --- a/hw/net/e1000.c | ||
| 43 | +++ b/hw/net/e1000.c | ||
| 44 | @@ -XXX,XX +XXX,XX @@ typedef struct E1000State_st { | ||
| 45 | unsigned char sum_needed; | ||
| 46 | bool cptse; | ||
| 47 | e1000x_txd_props props; | ||
| 48 | + e1000x_txd_props tso_props; | ||
| 49 | uint16_t tso_frames; | ||
| 50 | } tx; | ||
| 51 | |||
| 52 | @@ -XXX,XX +XXX,XX @@ xmit_seg(E1000State *s) | ||
| 53 | uint16_t len; | ||
| 54 | unsigned int frames = s->tx.tso_frames, css, sofar; | ||
| 55 | struct e1000_tx *tp = &s->tx; | ||
| 56 | + struct e1000x_txd_props *props = tp->cptse ? &tp->tso_props : &tp->props; | ||
| 57 | |||
| 58 | - if (tp->props.tse && tp->cptse) { | ||
| 59 | - css = tp->props.ipcss; | ||
| 60 | + if (tp->cptse) { | ||
| 61 | + css = props->ipcss; | ||
| 62 | DBGOUT(TXSUM, "frames %d size %d ipcss %d\n", | ||
| 63 | frames, tp->size, css); | ||
| 64 | - if (tp->props.ip) { /* IPv4 */ | ||
| 65 | + if (props->ip) { /* IPv4 */ | ||
| 66 | stw_be_p(tp->data+css+2, tp->size - css); | ||
| 67 | stw_be_p(tp->data+css+4, | ||
| 68 | lduw_be_p(tp->data + css + 4) + frames); | ||
| 69 | } else { /* IPv6 */ | ||
| 70 | stw_be_p(tp->data+css+4, tp->size - css); | ||
| 71 | } | ||
| 72 | - css = tp->props.tucss; | ||
| 73 | + css = props->tucss; | ||
| 74 | len = tp->size - css; | ||
| 75 | - DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", tp->props.tcp, css, len); | ||
| 76 | - if (tp->props.tcp) { | ||
| 77 | - sofar = frames * tp->props.mss; | ||
| 78 | + DBGOUT(TXSUM, "tcp %d tucss %d len %d\n", props->tcp, css, len); | ||
| 79 | + if (props->tcp) { | ||
| 80 | + sofar = frames * props->mss; | ||
| 81 | stl_be_p(tp->data+css+4, ldl_be_p(tp->data+css+4)+sofar); /* seq */ | ||
| 82 | - if (tp->props.paylen - sofar > tp->props.mss) { | ||
| 83 | + if (props->paylen - sofar > props->mss) { | ||
| 84 | tp->data[css + 13] &= ~9; /* PSH, FIN */ | ||
| 85 | } else if (frames) { | ||
| 86 | e1000x_inc_reg_if_not_full(s->mac_reg, TSCTC); | ||
| 87 | } | ||
| 88 | - } else /* UDP */ | ||
| 89 | + } else { /* UDP */ | ||
| 90 | stw_be_p(tp->data+css+4, len); | ||
| 91 | + } | ||
| 92 | if (tp->sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 93 | unsigned int phsum; | ||
| 94 | // add pseudo-header length before checksum calculation | ||
| 95 | - void *sp = tp->data + tp->props.tucso; | ||
| 96 | + void *sp = tp->data + props->tucso; | ||
| 97 | |||
| 98 | phsum = lduw_be_p(sp) + len; | ||
| 99 | phsum = (phsum >> 16) + (phsum & 0xffff); | ||
| 100 | @@ -XXX,XX +XXX,XX @@ xmit_seg(E1000State *s) | ||
| 101 | } | ||
| 102 | |||
| 103 | if (tp->sum_needed & E1000_TXD_POPTS_TXSM) { | ||
| 104 | - putsum(tp->data, tp->size, tp->props.tucso, | ||
| 105 | - tp->props.tucss, tp->props.tucse); | ||
| 106 | + putsum(tp->data, tp->size, props->tucso, props->tucss, props->tucse); | ||
| 107 | } | ||
| 108 | if (tp->sum_needed & E1000_TXD_POPTS_IXSM) { | ||
| 109 | - putsum(tp->data, tp->size, tp->props.ipcso, | ||
| 110 | - tp->props.ipcss, tp->props.ipcse); | ||
| 111 | + putsum(tp->data, tp->size, props->ipcso, props->ipcss, props->ipcse); | ||
| 112 | } | ||
| 113 | if (tp->vlan_needed) { | ||
| 114 | memmove(tp->vlan, tp->data, 4); | ||
| 115 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 116 | |||
| 117 | s->mit_ide |= (txd_lower & E1000_TXD_CMD_IDE); | ||
| 118 | if (dtype == E1000_TXD_CMD_DEXT) { /* context descriptor */ | ||
| 119 | - e1000x_read_tx_ctx_descr(xp, &tp->props); | ||
| 120 | - tp->tso_frames = 0; | ||
| 121 | - if (tp->props.tucso == 0) { /* this is probably wrong */ | ||
| 122 | - DBGOUT(TXSUM, "TCP/UDP: cso 0!\n"); | ||
| 123 | - tp->props.tucso = tp->props.tucss + (tp->props.tcp ? 16 : 6); | ||
| 124 | + if (le32_to_cpu(xp->cmd_and_length) & E1000_TXD_CMD_TSE) { | ||
| 125 | + e1000x_read_tx_ctx_descr(xp, &tp->tso_props); | ||
| 126 | + tp->tso_frames = 0; | ||
| 127 | + } else { | ||
| 128 | + e1000x_read_tx_ctx_descr(xp, &tp->props); | ||
| 129 | } | ||
| 130 | return; | ||
| 131 | } else if (dtype == (E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D)) { | ||
| 132 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 133 | } | ||
| 134 | |||
| 135 | addr = le64_to_cpu(dp->buffer_addr); | ||
| 136 | - if (tp->props.tse && tp->cptse) { | ||
| 137 | - msh = tp->props.hdr_len + tp->props.mss; | ||
| 138 | + if (tp->cptse) { | ||
| 139 | + msh = tp->tso_props.hdr_len + tp->tso_props.mss; | ||
| 140 | do { | ||
| 141 | bytes = split_size; | ||
| 142 | if (tp->size + bytes > msh) | ||
| 143 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 144 | bytes = MIN(sizeof(tp->data) - tp->size, bytes); | ||
| 145 | pci_dma_read(d, addr, tp->data + tp->size, bytes); | ||
| 146 | sz = tp->size + bytes; | ||
| 147 | - if (sz >= tp->props.hdr_len && tp->size < tp->props.hdr_len) { | ||
| 148 | - memmove(tp->header, tp->data, tp->props.hdr_len); | ||
| 149 | + if (sz >= tp->tso_props.hdr_len | ||
| 150 | + && tp->size < tp->tso_props.hdr_len) { | ||
| 151 | + memmove(tp->header, tp->data, tp->tso_props.hdr_len); | ||
| 152 | } | ||
| 153 | tp->size = sz; | ||
| 154 | addr += bytes; | ||
| 155 | if (sz == msh) { | ||
| 156 | xmit_seg(s); | ||
| 157 | - memmove(tp->data, tp->header, tp->props.hdr_len); | ||
| 158 | - tp->size = tp->props.hdr_len; | ||
| 159 | + memmove(tp->data, tp->header, tp->tso_props.hdr_len); | ||
| 160 | + tp->size = tp->tso_props.hdr_len; | ||
| 161 | } | ||
| 162 | split_size -= bytes; | ||
| 163 | } while (bytes && split_size); | ||
| 164 | - } else if (!tp->props.tse && tp->cptse) { | ||
| 165 | - // context descriptor TSE is not set, while data descriptor TSE is set | ||
| 166 | - DBGOUT(TXERR, "TCP segmentation error\n"); | ||
| 167 | } else { | ||
| 168 | split_size = MIN(sizeof(tp->data) - tp->size, split_size); | ||
| 169 | pci_dma_read(d, addr, tp->data + tp->size, split_size); | ||
| 170 | @@ -XXX,XX +XXX,XX @@ process_tx_desc(E1000State *s, struct e1000_tx_desc *dp) | ||
| 171 | |||
| 172 | if (!(txd_lower & E1000_TXD_CMD_EOP)) | ||
| 173 | return; | ||
| 174 | - if (!(tp->props.tse && tp->cptse && tp->size < tp->props.hdr_len)) { | ||
| 175 | + if (!(tp->cptse && tp->size < tp->tso_props.hdr_len)) { | ||
| 176 | xmit_seg(s); | ||
| 177 | } | ||
| 178 | tp->tso_frames = 0; | ||
| 179 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription vmstate_e1000_full_mac_state = { | ||
| 180 | |||
| 181 | static const VMStateDescription vmstate_e1000 = { | ||
| 182 | .name = "e1000", | ||
| 183 | - .version_id = 2, | ||
| 184 | + .version_id = 3, | ||
| 185 | .minimum_version_id = 1, | ||
| 186 | .pre_save = e1000_pre_save, | ||
| 187 | .post_load = e1000_post_load, | ||
| 188 | @@ -XXX,XX +XXX,XX @@ static const VMStateDescription vmstate_e1000 = { | ||
| 189 | VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, RA, 32), | ||
| 190 | VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, MTA, 128), | ||
| 191 | VMSTATE_UINT32_SUB_ARRAY(mac_reg, E1000State, VFTA, 128), | ||
| 192 | + VMSTATE_UINT8_V(tx.tso_props.ipcss, E1000State, 3), | ||
| 193 | + VMSTATE_UINT8_V(tx.tso_props.ipcso, E1000State, 3), | ||
| 194 | + VMSTATE_UINT16_V(tx.tso_props.ipcse, E1000State, 3), | ||
| 195 | + VMSTATE_UINT8_V(tx.tso_props.tucss, E1000State, 3), | ||
| 196 | + VMSTATE_UINT8_V(tx.tso_props.tucso, E1000State, 3), | ||
| 197 | + VMSTATE_UINT16_V(tx.tso_props.tucse, E1000State, 3), | ||
| 198 | + VMSTATE_UINT32_V(tx.tso_props.paylen, E1000State, 3), | ||
| 199 | + VMSTATE_UINT8_V(tx.tso_props.hdr_len, E1000State, 3), | ||
| 200 | + VMSTATE_UINT16_V(tx.tso_props.mss, E1000State, 3), | ||
| 201 | + VMSTATE_INT8_V(tx.tso_props.ip, E1000State, 3), | ||
| 202 | + VMSTATE_INT8_V(tx.tso_props.tcp, E1000State, 3), | ||
| 203 | VMSTATE_END_OF_LIST() | ||
| 204 | }, | ||
| 205 | .subsections = (const VMStateDescription*[]) { | ||
| 206 | -- | ||
| 207 | 2.7.4 | ||
| 208 | |||
| 209 | diff view generated by jsdifflib |
| 1 | From: Thomas Huth <thuth@redhat.com> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | The information how to update the deprecated parameters was too scarce, | 3 | Additional code that will be used for eBPF setting steering routine. |
| 4 | so that some people did not update to the new syntax yet. Provide some | ||
| 5 | more information to make sure that it is clear how to update from the | ||
| 6 | old syntax to the new one. | ||
| 7 | 4 | ||
| 8 | Signed-off-by: Thomas Huth <thuth@redhat.com> | 5 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> |
| 9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 6 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 10 | --- | 7 | --- |
| 11 | qemu-doc.texi | 33 +++++++++++++++++++++------------ | 8 | net/tap-linux.h | 1 + |
| 12 | 1 file changed, 21 insertions(+), 12 deletions(-) | 9 | 1 file changed, 1 insertion(+) |
| 13 | 10 | ||
| 14 | diff --git a/qemu-doc.texi b/qemu-doc.texi | 11 | diff --git a/net/tap-linux.h b/net/tap-linux.h |
| 15 | index XXXXXXX..XXXXXXX 100644 | 12 | index XXXXXXX..XXXXXXX 100644 |
| 16 | --- a/qemu-doc.texi | 13 | --- a/net/tap-linux.h |
| 17 | +++ b/qemu-doc.texi | 14 | +++ b/net/tap-linux.h |
| 18 | @@ -XXX,XX +XXX,XX @@ combined with ``-vnc tls-creds=tls0' | 15 | @@ -XXX,XX +XXX,XX @@ |
| 19 | 16 | #define TUNSETQUEUE _IOW('T', 217, int) | |
| 20 | @subsection -tftp (since 2.6.0) | 17 | #define TUNSETVNETLE _IOW('T', 220, int) |
| 21 | 18 | #define TUNSETVNETBE _IOW('T', 222, int) | |
| 22 | -The ``-tftp /some/dir'' argument is now a synonym for setting | 19 | +#define TUNSETSTEERINGEBPF _IOR('T', 224, int) |
| 23 | -the ``-netdev user,tftp=/some/dir' argument. The new syntax | 20 | |
| 24 | -allows different settings to be provided per NIC. | 21 | #endif |
| 25 | +The ``-tftp /some/dir'' argument is replaced by | ||
| 26 | +``-netdev user,id=x,tftp=/some/dir'', either accompanied with | ||
| 27 | +``-device ...,netdev=x'' (for pluggable NICs) or ``-net nic,netdev=x'' | ||
| 28 | +(for embedded NICs). The new syntax allows different settings to be | ||
| 29 | +provided per NIC. | ||
| 30 | |||
| 31 | @subsection -bootp (since 2.6.0) | ||
| 32 | |||
| 33 | -The ``-bootp /some/file'' argument is now a synonym for setting | ||
| 34 | -the ``-netdev user,bootp=/some/file' argument. The new syntax | ||
| 35 | -allows different settings to be provided per NIC. | ||
| 36 | +The ``-bootp /some/file'' argument is replaced by | ||
| 37 | +``-netdev user,id=x,bootp=/some/file'', either accompanied with | ||
| 38 | +``-device ...,netdev=x'' (for pluggable NICs) or ``-net nic,netdev=x'' | ||
| 39 | +(for embedded NICs). The new syntax allows different settings to be | ||
| 40 | +provided per NIC. | ||
| 41 | |||
| 42 | @subsection -redir (since 2.6.0) | ||
| 43 | |||
| 44 | -The ``-redir ARGS'' argument is now a synonym for setting | ||
| 45 | -the ``-netdev user,hostfwd=ARGS'' argument instead. The new | ||
| 46 | -syntax allows different settings to be provided per NIC. | ||
| 47 | +The ``-redir [tcp|udp]:hostport:[guestaddr]:guestport'' argument is | ||
| 48 | +replaced by ``-netdev | ||
| 49 | +user,id=x,hostfwd=[tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport'', | ||
| 50 | +either accompanied with ``-device ...,netdev=x'' (for pluggable NICs) or | ||
| 51 | +``-net nic,netdev=x'' (for embedded NICs). The new syntax allows different | ||
| 52 | +settings to be provided per NIC. | ||
| 53 | |||
| 54 | @subsection -smb (since 2.6.0) | ||
| 55 | |||
| 56 | -The ``-smb /some/dir'' argument is now a synonym for setting | ||
| 57 | -the ``-netdev user,smb=/some/dir'' argument instead. The new | ||
| 58 | -syntax allows different settings to be provided per NIC. | ||
| 59 | +The ``-smb /some/dir'' argument is replaced by | ||
| 60 | +``-netdev user,id=x,smb=/some/dir'', either accompanied with | ||
| 61 | +``-device ...,netdev=x'' (for pluggable NICs) or ``-net nic,netdev=x'' | ||
| 62 | +(for embedded NICs). The new syntax allows different settings to be | ||
| 63 | +provided per NIC. | ||
| 64 | |||
| 65 | @subsection -net vlan (since 2.9.0) | ||
| 66 | 22 | ||
| 67 | -- | 23 | -- |
| 68 | 2.7.4 | 24 | 2.7.4 |
| 69 | 25 | ||
| 70 | 26 | diff view generated by jsdifflib |
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | This provides a standard ethernet CRC32 little-endian implementation. | 3 | For now, that method supported only by Linux TAP. |
| 4 | Linux TAP uses TUNSETSTEERINGEBPF ioctl. | ||
| 4 | 5 | ||
| 5 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | 6 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> |
| 6 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
| 7 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
| 8 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 9 | --- | 8 | --- |
| 10 | include/net/net.h | 2 ++ | 9 | include/net/net.h | 2 ++ |
| 11 | net/net.c | 22 ++++++++++++++++++++++ | 10 | net/tap-bsd.c | 5 +++++ |
| 12 | 2 files changed, 24 insertions(+) | 11 | net/tap-linux.c | 13 +++++++++++++ |
| 12 | net/tap-solaris.c | 5 +++++ | ||
| 13 | net/tap-stub.c | 5 +++++ | ||
| 14 | net/tap.c | 9 +++++++++ | ||
| 15 | net/tap_int.h | 1 + | ||
| 16 | 7 files changed, 40 insertions(+) | ||
| 13 | 17 | ||
| 14 | diff --git a/include/net/net.h b/include/net/net.h | 18 | diff --git a/include/net/net.h b/include/net/net.h |
| 15 | index XXXXXXX..XXXXXXX 100644 | 19 | index XXXXXXX..XXXXXXX 100644 |
| 16 | --- a/include/net/net.h | 20 | --- a/include/net/net.h |
| 17 | +++ b/include/net/net.h | 21 | +++ b/include/net/net.h |
| 18 | @@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_port_find(int hub_id); | 22 | @@ -XXX,XX +XXX,XX @@ typedef int (SetVnetBE)(NetClientState *, bool); |
| 19 | void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd); | 23 | typedef struct SocketReadState SocketReadState; |
| 20 | 24 | typedef void (SocketReadStateFinalize)(SocketReadState *rs); | |
| 21 | #define POLYNOMIAL_BE 0x04c11db6 | 25 | typedef void (NetAnnounce)(NetClientState *); |
| 22 | +#define POLYNOMIAL_LE 0xedb88320 | 26 | +typedef bool (SetSteeringEBPF)(NetClientState *, int); |
| 23 | uint32_t net_crc32(const uint8_t *p, int len); | 27 | |
| 24 | +uint32_t net_crc32_le(const uint8_t *p, int len); | 28 | typedef struct NetClientInfo { |
| 25 | unsigned compute_mcast_idx(const uint8_t *ep); | 29 | NetClientDriver type; |
| 26 | 30 | @@ -XXX,XX +XXX,XX @@ typedef struct NetClientInfo { | |
| 27 | #define vmstate_offset_macaddr(_state, _field) \ | 31 | SetVnetLE *set_vnet_le; |
| 28 | diff --git a/net/net.c b/net/net.c | 32 | SetVnetBE *set_vnet_be; |
| 33 | NetAnnounce *announce; | ||
| 34 | + SetSteeringEBPF *set_steering_ebpf; | ||
| 35 | } NetClientInfo; | ||
| 36 | |||
| 37 | struct NetClientState { | ||
| 38 | diff --git a/net/tap-bsd.c b/net/tap-bsd.c | ||
| 29 | index XXXXXXX..XXXXXXX 100644 | 39 | index XXXXXXX..XXXXXXX 100644 |
| 30 | --- a/net/net.c | 40 | --- a/net/tap-bsd.c |
| 31 | +++ b/net/net.c | 41 | +++ b/net/tap-bsd.c |
| 32 | @@ -XXX,XX +XXX,XX @@ uint32_t net_crc32(const uint8_t *p, int len) | 42 | @@ -XXX,XX +XXX,XX @@ int tap_fd_get_ifname(int fd, char *ifname) |
| 33 | return crc; | 43 | { |
| 44 | return -1; | ||
| 34 | } | 45 | } |
| 35 | 46 | + | |
| 36 | +uint32_t net_crc32_le(const uint8_t *p, int len) | 47 | +int tap_fd_set_steering_ebpf(int fd, int prog_fd) |
| 37 | +{ | 48 | +{ |
| 38 | + uint32_t crc; | 49 | + return -1; |
| 39 | + int carry, i, j; | 50 | +} |
| 40 | + uint8_t b; | 51 | diff --git a/net/tap-linux.c b/net/tap-linux.c |
| 52 | index XXXXXXX..XXXXXXX 100644 | ||
| 53 | --- a/net/tap-linux.c | ||
| 54 | +++ b/net/tap-linux.c | ||
| 55 | @@ -XXX,XX +XXX,XX @@ int tap_fd_get_ifname(int fd, char *ifname) | ||
| 56 | pstrcpy(ifname, sizeof(ifr.ifr_name), ifr.ifr_name); | ||
| 57 | return 0; | ||
| 58 | } | ||
| 41 | + | 59 | + |
| 42 | + crc = 0xffffffff; | 60 | +int tap_fd_set_steering_ebpf(int fd, int prog_fd) |
| 43 | + for (i = 0; i < len; i++) { | 61 | +{ |
| 44 | + b = *p++; | 62 | + if (ioctl(fd, TUNSETSTEERINGEBPF, (void *) &prog_fd) != 0) { |
| 45 | + for (j = 0; j < 8; j++) { | 63 | + error_report("Issue while setting TUNSETSTEERINGEBPF:" |
| 46 | + carry = (crc & 0x1) ^ (b & 0x01); | 64 | + " %s with fd: %d, prog_fd: %d", |
| 47 | + crc >>= 1; | 65 | + strerror(errno), fd, prog_fd); |
| 48 | + b >>= 1; | 66 | + |
| 49 | + if (carry) { | 67 | + return -1; |
| 50 | + crc ^= POLYNOMIAL_LE; | ||
| 51 | + } | ||
| 52 | + } | ||
| 53 | + } | 68 | + } |
| 54 | + | 69 | + |
| 55 | + return crc; | 70 | + return 0; |
| 71 | +} | ||
| 72 | diff --git a/net/tap-solaris.c b/net/tap-solaris.c | ||
| 73 | index XXXXXXX..XXXXXXX 100644 | ||
| 74 | --- a/net/tap-solaris.c | ||
| 75 | +++ b/net/tap-solaris.c | ||
| 76 | @@ -XXX,XX +XXX,XX @@ int tap_fd_get_ifname(int fd, char *ifname) | ||
| 77 | { | ||
| 78 | return -1; | ||
| 79 | } | ||
| 80 | + | ||
| 81 | +int tap_fd_set_steering_ebpf(int fd, int prog_fd) | ||
| 82 | +{ | ||
| 83 | + return -1; | ||
| 84 | +} | ||
| 85 | diff --git a/net/tap-stub.c b/net/tap-stub.c | ||
| 86 | index XXXXXXX..XXXXXXX 100644 | ||
| 87 | --- a/net/tap-stub.c | ||
| 88 | +++ b/net/tap-stub.c | ||
| 89 | @@ -XXX,XX +XXX,XX @@ int tap_fd_get_ifname(int fd, char *ifname) | ||
| 90 | { | ||
| 91 | return -1; | ||
| 92 | } | ||
| 93 | + | ||
| 94 | +int tap_fd_set_steering_ebpf(int fd, int prog_fd) | ||
| 95 | +{ | ||
| 96 | + return -1; | ||
| 97 | +} | ||
| 98 | diff --git a/net/tap.c b/net/tap.c | ||
| 99 | index XXXXXXX..XXXXXXX 100644 | ||
| 100 | --- a/net/tap.c | ||
| 101 | +++ b/net/tap.c | ||
| 102 | @@ -XXX,XX +XXX,XX @@ static void tap_poll(NetClientState *nc, bool enable) | ||
| 103 | tap_write_poll(s, enable); | ||
| 104 | } | ||
| 105 | |||
| 106 | +static bool tap_set_steering_ebpf(NetClientState *nc, int prog_fd) | ||
| 107 | +{ | ||
| 108 | + TAPState *s = DO_UPCAST(TAPState, nc, nc); | ||
| 109 | + assert(nc->info->type == NET_CLIENT_DRIVER_TAP); | ||
| 110 | + | ||
| 111 | + return tap_fd_set_steering_ebpf(s->fd, prog_fd) == 0; | ||
| 56 | +} | 112 | +} |
| 57 | + | 113 | + |
| 58 | unsigned compute_mcast_idx(const uint8_t *ep) | 114 | int tap_get_fd(NetClientState *nc) |
| 59 | { | 115 | { |
| 60 | return net_crc32(ep, ETH_ALEN) >> 26; | 116 | TAPState *s = DO_UPCAST(TAPState, nc, nc); |
| 117 | @@ -XXX,XX +XXX,XX @@ static NetClientInfo net_tap_info = { | ||
| 118 | .set_vnet_hdr_len = tap_set_vnet_hdr_len, | ||
| 119 | .set_vnet_le = tap_set_vnet_le, | ||
| 120 | .set_vnet_be = tap_set_vnet_be, | ||
| 121 | + .set_steering_ebpf = tap_set_steering_ebpf, | ||
| 122 | }; | ||
| 123 | |||
| 124 | static TAPState *net_tap_fd_init(NetClientState *peer, | ||
| 125 | diff --git a/net/tap_int.h b/net/tap_int.h | ||
| 126 | index XXXXXXX..XXXXXXX 100644 | ||
| 127 | --- a/net/tap_int.h | ||
| 128 | +++ b/net/tap_int.h | ||
| 129 | @@ -XXX,XX +XXX,XX @@ int tap_fd_set_vnet_be(int fd, int vnet_is_be); | ||
| 130 | int tap_fd_enable(int fd); | ||
| 131 | int tap_fd_disable(int fd); | ||
| 132 | int tap_fd_get_ifname(int fd, char *ifname); | ||
| 133 | +int tap_fd_set_steering_ebpf(int fd, int prog_fd); | ||
| 134 | |||
| 135 | #endif /* NET_TAP_INT_H */ | ||
| 61 | -- | 136 | -- |
| 62 | 2.7.4 | 137 | 2.7.4 |
| 63 | 138 | ||
| 64 | 139 | diff view generated by jsdifflib |
| 1 | From: Thomas Huth <thuth@redhat.com> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Looks like we missed to document that it is also possible to specify | 3 | RSS program and Makefile to build it. |
| 4 | a netdev with "-net nic" - which is very useful if you want to | 4 | The bpftool used to generate '.h' file. |
| 5 | configure your on-board NIC to use a backend that has been specified | 5 | The data in that file may be loaded by libbpf. |
| 6 | with "-netdev". | 6 | EBPF compilation is not required for building qemu. |
| 7 | You can use Makefile if you need to regenerate rss.bpf.skeleton.h. | ||
| 7 | 8 | ||
| 8 | Signed-off-by: Thomas Huth <thuth@redhat.com> | 9 | Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com> |
| 10 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> | ||
| 9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 11 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 10 | --- | 12 | --- |
| 11 | qemu-options.hx | 14 ++++++++------ | 13 | tools/ebpf/Makefile.ebpf | 21 ++ |
| 12 | 1 file changed, 8 insertions(+), 6 deletions(-) | 14 | tools/ebpf/rss.bpf.c | 571 +++++++++++++++++++++++++++++++++++++++++++++++ |
| 15 | 2 files changed, 592 insertions(+) | ||
| 16 | create mode 100755 tools/ebpf/Makefile.ebpf | ||
| 17 | create mode 100644 tools/ebpf/rss.bpf.c | ||
| 13 | 18 | ||
| 14 | diff --git a/qemu-options.hx b/qemu-options.hx | 19 | diff --git a/tools/ebpf/Makefile.ebpf b/tools/ebpf/Makefile.ebpf |
| 15 | index XXXXXXX..XXXXXXX 100644 | 20 | new file mode 100755 |
| 16 | --- a/qemu-options.hx | 21 | index XXXXXXX..XXXXXXX |
| 17 | +++ b/qemu-options.hx | 22 | --- /dev/null |
| 18 | @@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev, | 23 | +++ b/tools/ebpf/Makefile.ebpf |
| 19 | "-netdev hubport,id=str,hubid=n\n" | 24 | @@ -XXX,XX +XXX,XX @@ |
| 20 | " configure a hub port on QEMU VLAN 'n'\n", QEMU_ARCH_ALL) | 25 | +OBJS = rss.bpf.o |
| 21 | DEF("net", HAS_ARG, QEMU_OPTION_net, | 26 | + |
| 22 | - "-net nic[,vlan=n][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n" | 27 | +LLC ?= llc |
| 23 | - " old way to create a new NIC and connect it to VLAN 'n'\n" | 28 | +CLANG ?= clang |
| 24 | - " (use the '-device devtype,netdev=str' option if possible instead)\n" | 29 | +INC_FLAGS = `$(CLANG) -print-file-name=include` |
| 25 | + "-net nic[,vlan=n][,netdev=nd][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n" | 30 | +EXTRA_CFLAGS ?= -O2 -emit-llvm -fno-stack-protector |
| 26 | + " configure or create an on-board (or machine default) NIC and\n" | 31 | + |
| 27 | + " connect it either to VLAN 'n' or the netdev 'nd' (for pluggable\n" | 32 | +all: $(OBJS) |
| 28 | + " NICs please use '-device devtype,netdev=nd' instead)\n" | 33 | + |
| 29 | "-net dump[,vlan=n][,file=f][,len=n]\n" | 34 | +.PHONY: clean |
| 30 | " dump traffic on vlan 'n' to file 'f' (max n bytes per packet)\n" | 35 | + |
| 31 | "-net none use it alone to have zero network devices. If no -net option\n" | 36 | +clean: |
| 32 | @@ -XXX,XX +XXX,XX @@ DEF("net", HAS_ARG, QEMU_OPTION_net, | 37 | + rm -f $(OBJS) |
| 33 | " old way to initialize a host network interface\n" | 38 | + |
| 34 | " (use the -netdev option if possible instead)\n", QEMU_ARCH_ALL) | 39 | +$(OBJS): %.o:%.c |
| 35 | STEXI | 40 | + $(CLANG) $(INC_FLAGS) \ |
| 36 | -@item -net nic[,vlan=@var{n}][,macaddr=@var{mac}][,model=@var{type}] [,name=@var{name}][,addr=@var{addr}][,vectors=@var{v}] | 41 | + -D__KERNEL__ -D__ASM_SYSREG_H \ |
| 37 | +@item -net nic[,vlan=@var{n}][,netdev=@var{nd}][,macaddr=@var{mac}][,model=@var{type}] [,name=@var{name}][,addr=@var{addr}][,vectors=@var{v}] | 42 | + -I../include $(LINUXINCLUDE) \ |
| 38 | @findex -net | 43 | + $(EXTRA_CFLAGS) -c $< -o -| $(LLC) -march=bpf -filetype=obj -o $@ |
| 39 | -Create a new Network Interface Card and connect it to VLAN @var{n} (@var{n} | 44 | + bpftool gen skeleton rss.bpf.o > rss.bpf.skeleton.h |
| 40 | -= 0 is the default). The NIC is an e1000 by default on the PC | 45 | + cp rss.bpf.skeleton.h ../../ebpf/ |
| 41 | +Configure or create an on-board (or machine default) Network Interface Card | 46 | diff --git a/tools/ebpf/rss.bpf.c b/tools/ebpf/rss.bpf.c |
| 42 | +(NIC) and connect it either to VLAN @var{n} (@var{n} = 0 is the default), or | 47 | new file mode 100644 |
| 43 | +to the netdev @var{nd}. The NIC is an e1000 by default on the PC | 48 | index XXXXXXX..XXXXXXX |
| 44 | target. Optionally, the MAC address can be changed to @var{mac}, the | 49 | --- /dev/null |
| 45 | device address set to @var{addr} (PCI cards only), | 50 | +++ b/tools/ebpf/rss.bpf.c |
| 46 | and a @var{name} can be assigned for use in monitor commands. | 51 | @@ -XXX,XX +XXX,XX @@ |
| 52 | +/* | ||
| 53 | + * eBPF RSS program | ||
| 54 | + * | ||
| 55 | + * Developed by Daynix Computing LTD (http://www.daynix.com) | ||
| 56 | + * | ||
| 57 | + * Authors: | ||
| 58 | + * Andrew Melnychenko <andrew@daynix.com> | ||
| 59 | + * Yuri Benditovich <yuri.benditovich@daynix.com> | ||
| 60 | + * | ||
| 61 | + * This work is licensed under the terms of the GNU GPL, version 2. See | ||
| 62 | + * the COPYING file in the top-level directory. | ||
| 63 | + * | ||
| 64 | + * Prepare: | ||
| 65 | + * Requires llvm, clang, bpftool, linux kernel tree | ||
| 66 | + * | ||
| 67 | + * Build rss.bpf.skeleton.h: | ||
| 68 | + * make -f Makefile.ebpf clean all | ||
| 69 | + */ | ||
| 70 | + | ||
| 71 | +#include <stddef.h> | ||
| 72 | +#include <stdbool.h> | ||
| 73 | +#include <linux/bpf.h> | ||
| 74 | + | ||
| 75 | +#include <linux/in.h> | ||
| 76 | +#include <linux/if_ether.h> | ||
| 77 | +#include <linux/ip.h> | ||
| 78 | +#include <linux/ipv6.h> | ||
| 79 | + | ||
| 80 | +#include <linux/udp.h> | ||
| 81 | +#include <linux/tcp.h> | ||
| 82 | + | ||
| 83 | +#include <bpf/bpf_helpers.h> | ||
| 84 | +#include <bpf/bpf_endian.h> | ||
| 85 | +#include <linux/virtio_net.h> | ||
| 86 | + | ||
| 87 | +#define INDIRECTION_TABLE_SIZE 128 | ||
| 88 | +#define HASH_CALCULATION_BUFFER_SIZE 36 | ||
| 89 | + | ||
| 90 | +struct rss_config_t { | ||
| 91 | + __u8 redirect; | ||
| 92 | + __u8 populate_hash; | ||
| 93 | + __u32 hash_types; | ||
| 94 | + __u16 indirections_len; | ||
| 95 | + __u16 default_queue; | ||
| 96 | +} __attribute__((packed)); | ||
| 97 | + | ||
| 98 | +struct toeplitz_key_data_t { | ||
| 99 | + __u32 leftmost_32_bits; | ||
| 100 | + __u8 next_byte[HASH_CALCULATION_BUFFER_SIZE]; | ||
| 101 | +}; | ||
| 102 | + | ||
| 103 | +struct packet_hash_info_t { | ||
| 104 | + __u8 is_ipv4; | ||
| 105 | + __u8 is_ipv6; | ||
| 106 | + __u8 is_udp; | ||
| 107 | + __u8 is_tcp; | ||
| 108 | + __u8 is_ipv6_ext_src; | ||
| 109 | + __u8 is_ipv6_ext_dst; | ||
| 110 | + __u8 is_fragmented; | ||
| 111 | + | ||
| 112 | + __u16 src_port; | ||
| 113 | + __u16 dst_port; | ||
| 114 | + | ||
| 115 | + union { | ||
| 116 | + struct { | ||
| 117 | + __be32 in_src; | ||
| 118 | + __be32 in_dst; | ||
| 119 | + }; | ||
| 120 | + | ||
| 121 | + struct { | ||
| 122 | + struct in6_addr in6_src; | ||
| 123 | + struct in6_addr in6_dst; | ||
| 124 | + struct in6_addr in6_ext_src; | ||
| 125 | + struct in6_addr in6_ext_dst; | ||
| 126 | + }; | ||
| 127 | + }; | ||
| 128 | +}; | ||
| 129 | + | ||
| 130 | +struct bpf_map_def SEC("maps") | ||
| 131 | +tap_rss_map_configurations = { | ||
| 132 | + .type = BPF_MAP_TYPE_ARRAY, | ||
| 133 | + .key_size = sizeof(__u32), | ||
| 134 | + .value_size = sizeof(struct rss_config_t), | ||
| 135 | + .max_entries = 1, | ||
| 136 | +}; | ||
| 137 | + | ||
| 138 | +struct bpf_map_def SEC("maps") | ||
| 139 | +tap_rss_map_toeplitz_key = { | ||
| 140 | + .type = BPF_MAP_TYPE_ARRAY, | ||
| 141 | + .key_size = sizeof(__u32), | ||
| 142 | + .value_size = sizeof(struct toeplitz_key_data_t), | ||
| 143 | + .max_entries = 1, | ||
| 144 | +}; | ||
| 145 | + | ||
| 146 | +struct bpf_map_def SEC("maps") | ||
| 147 | +tap_rss_map_indirection_table = { | ||
| 148 | + .type = BPF_MAP_TYPE_ARRAY, | ||
| 149 | + .key_size = sizeof(__u32), | ||
| 150 | + .value_size = sizeof(__u16), | ||
| 151 | + .max_entries = INDIRECTION_TABLE_SIZE, | ||
| 152 | +}; | ||
| 153 | + | ||
| 154 | +static inline void net_rx_rss_add_chunk(__u8 *rss_input, size_t *bytes_written, | ||
| 155 | + const void *ptr, size_t size) { | ||
| 156 | + __builtin_memcpy(&rss_input[*bytes_written], ptr, size); | ||
| 157 | + *bytes_written += size; | ||
| 158 | +} | ||
| 159 | + | ||
| 160 | +static inline | ||
| 161 | +void net_toeplitz_add(__u32 *result, | ||
| 162 | + __u8 *input, | ||
| 163 | + __u32 len | ||
| 164 | + , struct toeplitz_key_data_t *key) { | ||
| 165 | + | ||
| 166 | + __u32 accumulator = *result; | ||
| 167 | + __u32 leftmost_32_bits = key->leftmost_32_bits; | ||
| 168 | + __u32 byte; | ||
| 169 | + | ||
| 170 | + for (byte = 0; byte < HASH_CALCULATION_BUFFER_SIZE; byte++) { | ||
| 171 | + __u8 input_byte = input[byte]; | ||
| 172 | + __u8 key_byte = key->next_byte[byte]; | ||
| 173 | + __u8 bit; | ||
| 174 | + | ||
| 175 | + for (bit = 0; bit < 8; bit++) { | ||
| 176 | + if (input_byte & (1 << 7)) { | ||
| 177 | + accumulator ^= leftmost_32_bits; | ||
| 178 | + } | ||
| 179 | + | ||
| 180 | + leftmost_32_bits = | ||
| 181 | + (leftmost_32_bits << 1) | ((key_byte & (1 << 7)) >> 7); | ||
| 182 | + | ||
| 183 | + input_byte <<= 1; | ||
| 184 | + key_byte <<= 1; | ||
| 185 | + } | ||
| 186 | + } | ||
| 187 | + | ||
| 188 | + *result = accumulator; | ||
| 189 | +} | ||
| 190 | + | ||
| 191 | + | ||
| 192 | +static inline int ip6_extension_header_type(__u8 hdr_type) | ||
| 193 | +{ | ||
| 194 | + switch (hdr_type) { | ||
| 195 | + case IPPROTO_HOPOPTS: | ||
| 196 | + case IPPROTO_ROUTING: | ||
| 197 | + case IPPROTO_FRAGMENT: | ||
| 198 | + case IPPROTO_ICMPV6: | ||
| 199 | + case IPPROTO_NONE: | ||
| 200 | + case IPPROTO_DSTOPTS: | ||
| 201 | + case IPPROTO_MH: | ||
| 202 | + return 1; | ||
| 203 | + default: | ||
| 204 | + return 0; | ||
| 205 | + } | ||
| 206 | +} | ||
| 207 | +/* | ||
| 208 | + * According to | ||
| 209 | + * https://www.iana.org/assignments/ipv6-parameters/ipv6-parameters.xhtml | ||
| 210 | + * we expect that there are would be no more than 11 extensions in IPv6 header, | ||
| 211 | + * also there is 27 TLV options for Destination and Hop-by-hop extensions. | ||
| 212 | + * Need to choose reasonable amount of maximum extensions/options we may | ||
| 213 | + * check to find ext src/dst. | ||
| 214 | + */ | ||
| 215 | +#define IP6_EXTENSIONS_COUNT 11 | ||
| 216 | +#define IP6_OPTIONS_COUNT 30 | ||
| 217 | + | ||
| 218 | +static inline int parse_ipv6_ext(struct __sk_buff *skb, | ||
| 219 | + struct packet_hash_info_t *info, | ||
| 220 | + __u8 *l4_protocol, size_t *l4_offset) | ||
| 221 | +{ | ||
| 222 | + int err = 0; | ||
| 223 | + | ||
| 224 | + if (!ip6_extension_header_type(*l4_protocol)) { | ||
| 225 | + return 0; | ||
| 226 | + } | ||
| 227 | + | ||
| 228 | + struct ipv6_opt_hdr ext_hdr = {}; | ||
| 229 | + | ||
| 230 | + for (unsigned int i = 0; i < IP6_EXTENSIONS_COUNT; ++i) { | ||
| 231 | + | ||
| 232 | + err = bpf_skb_load_bytes_relative(skb, *l4_offset, &ext_hdr, | ||
| 233 | + sizeof(ext_hdr), BPF_HDR_START_NET); | ||
| 234 | + if (err) { | ||
| 235 | + goto error; | ||
| 236 | + } | ||
| 237 | + | ||
| 238 | + if (*l4_protocol == IPPROTO_ROUTING) { | ||
| 239 | + struct ipv6_rt_hdr ext_rt = {}; | ||
| 240 | + | ||
| 241 | + err = bpf_skb_load_bytes_relative(skb, *l4_offset, &ext_rt, | ||
| 242 | + sizeof(ext_rt), BPF_HDR_START_NET); | ||
| 243 | + if (err) { | ||
| 244 | + goto error; | ||
| 245 | + } | ||
| 246 | + | ||
| 247 | + if ((ext_rt.type == IPV6_SRCRT_TYPE_2) && | ||
| 248 | + (ext_rt.hdrlen == sizeof(struct in6_addr) / 8) && | ||
| 249 | + (ext_rt.segments_left == 1)) { | ||
| 250 | + | ||
| 251 | + err = bpf_skb_load_bytes_relative(skb, | ||
| 252 | + *l4_offset + offsetof(struct rt2_hdr, addr), | ||
| 253 | + &info->in6_ext_dst, sizeof(info->in6_ext_dst), | ||
| 254 | + BPF_HDR_START_NET); | ||
| 255 | + if (err) { | ||
| 256 | + goto error; | ||
| 257 | + } | ||
| 258 | + | ||
| 259 | + info->is_ipv6_ext_dst = 1; | ||
| 260 | + } | ||
| 261 | + | ||
| 262 | + } else if (*l4_protocol == IPPROTO_DSTOPTS) { | ||
| 263 | + struct ipv6_opt_t { | ||
| 264 | + __u8 type; | ||
| 265 | + __u8 length; | ||
| 266 | + } __attribute__((packed)) opt = {}; | ||
| 267 | + | ||
| 268 | + size_t opt_offset = sizeof(ext_hdr); | ||
| 269 | + | ||
| 270 | + for (unsigned int j = 0; j < IP6_OPTIONS_COUNT; ++j) { | ||
| 271 | + err = bpf_skb_load_bytes_relative(skb, *l4_offset + opt_offset, | ||
| 272 | + &opt, sizeof(opt), BPF_HDR_START_NET); | ||
| 273 | + if (err) { | ||
| 274 | + goto error; | ||
| 275 | + } | ||
| 276 | + | ||
| 277 | + if (opt.type == IPV6_TLV_HAO) { | ||
| 278 | + err = bpf_skb_load_bytes_relative(skb, | ||
| 279 | + *l4_offset + opt_offset | ||
| 280 | + + offsetof(struct ipv6_destopt_hao, addr), | ||
| 281 | + &info->in6_ext_src, sizeof(info->in6_ext_src), | ||
| 282 | + BPF_HDR_START_NET); | ||
| 283 | + if (err) { | ||
| 284 | + goto error; | ||
| 285 | + } | ||
| 286 | + | ||
| 287 | + info->is_ipv6_ext_src = 1; | ||
| 288 | + break; | ||
| 289 | + } | ||
| 290 | + | ||
| 291 | + opt_offset += (opt.type == IPV6_TLV_PAD1) ? | ||
| 292 | + 1 : opt.length + sizeof(opt); | ||
| 293 | + | ||
| 294 | + if (opt_offset + 1 >= ext_hdr.hdrlen * 8) { | ||
| 295 | + break; | ||
| 296 | + } | ||
| 297 | + } | ||
| 298 | + } else if (*l4_protocol == IPPROTO_FRAGMENT) { | ||
| 299 | + info->is_fragmented = true; | ||
| 300 | + } | ||
| 301 | + | ||
| 302 | + *l4_protocol = ext_hdr.nexthdr; | ||
| 303 | + *l4_offset += (ext_hdr.hdrlen + 1) * 8; | ||
| 304 | + | ||
| 305 | + if (!ip6_extension_header_type(ext_hdr.nexthdr)) { | ||
| 306 | + return 0; | ||
| 307 | + } | ||
| 308 | + } | ||
| 309 | + | ||
| 310 | + return 0; | ||
| 311 | +error: | ||
| 312 | + return err; | ||
| 313 | +} | ||
| 314 | + | ||
| 315 | +static __be16 parse_eth_type(struct __sk_buff *skb) | ||
| 316 | +{ | ||
| 317 | + unsigned int offset = 12; | ||
| 318 | + __be16 ret = 0; | ||
| 319 | + int err = 0; | ||
| 320 | + | ||
| 321 | + err = bpf_skb_load_bytes_relative(skb, offset, &ret, sizeof(ret), | ||
| 322 | + BPF_HDR_START_MAC); | ||
| 323 | + if (err) { | ||
| 324 | + return 0; | ||
| 325 | + } | ||
| 326 | + | ||
| 327 | + switch (bpf_ntohs(ret)) { | ||
| 328 | + case ETH_P_8021AD: | ||
| 329 | + offset += 4; | ||
| 330 | + case ETH_P_8021Q: | ||
| 331 | + offset += 4; | ||
| 332 | + err = bpf_skb_load_bytes_relative(skb, offset, &ret, sizeof(ret), | ||
| 333 | + BPF_HDR_START_MAC); | ||
| 334 | + default: | ||
| 335 | + break; | ||
| 336 | + } | ||
| 337 | + | ||
| 338 | + if (err) { | ||
| 339 | + return 0; | ||
| 340 | + } | ||
| 341 | + | ||
| 342 | + return ret; | ||
| 343 | +} | ||
| 344 | + | ||
| 345 | +static inline int parse_packet(struct __sk_buff *skb, | ||
| 346 | + struct packet_hash_info_t *info) | ||
| 347 | +{ | ||
| 348 | + int err = 0; | ||
| 349 | + | ||
| 350 | + if (!info || !skb) { | ||
| 351 | + return -1; | ||
| 352 | + } | ||
| 353 | + | ||
| 354 | + size_t l4_offset = 0; | ||
| 355 | + __u8 l4_protocol = 0; | ||
| 356 | + __u16 l3_protocol = bpf_ntohs(parse_eth_type(skb)); | ||
| 357 | + if (l3_protocol == 0) { | ||
| 358 | + err = -1; | ||
| 359 | + goto error; | ||
| 360 | + } | ||
| 361 | + | ||
| 362 | + if (l3_protocol == ETH_P_IP) { | ||
| 363 | + info->is_ipv4 = 1; | ||
| 364 | + | ||
| 365 | + struct iphdr ip = {}; | ||
| 366 | + err = bpf_skb_load_bytes_relative(skb, 0, &ip, sizeof(ip), | ||
| 367 | + BPF_HDR_START_NET); | ||
| 368 | + if (err) { | ||
| 369 | + goto error; | ||
| 370 | + } | ||
| 371 | + | ||
| 372 | + info->in_src = ip.saddr; | ||
| 373 | + info->in_dst = ip.daddr; | ||
| 374 | + info->is_fragmented = !!ip.frag_off; | ||
| 375 | + | ||
| 376 | + l4_protocol = ip.protocol; | ||
| 377 | + l4_offset = ip.ihl * 4; | ||
| 378 | + } else if (l3_protocol == ETH_P_IPV6) { | ||
| 379 | + info->is_ipv6 = 1; | ||
| 380 | + | ||
| 381 | + struct ipv6hdr ip6 = {}; | ||
| 382 | + err = bpf_skb_load_bytes_relative(skb, 0, &ip6, sizeof(ip6), | ||
| 383 | + BPF_HDR_START_NET); | ||
| 384 | + if (err) { | ||
| 385 | + goto error; | ||
| 386 | + } | ||
| 387 | + | ||
| 388 | + info->in6_src = ip6.saddr; | ||
| 389 | + info->in6_dst = ip6.daddr; | ||
| 390 | + | ||
| 391 | + l4_protocol = ip6.nexthdr; | ||
| 392 | + l4_offset = sizeof(ip6); | ||
| 393 | + | ||
| 394 | + err = parse_ipv6_ext(skb, info, &l4_protocol, &l4_offset); | ||
| 395 | + if (err) { | ||
| 396 | + goto error; | ||
| 397 | + } | ||
| 398 | + } | ||
| 399 | + | ||
| 400 | + if (l4_protocol != 0 && !info->is_fragmented) { | ||
| 401 | + if (l4_protocol == IPPROTO_TCP) { | ||
| 402 | + info->is_tcp = 1; | ||
| 403 | + | ||
| 404 | + struct tcphdr tcp = {}; | ||
| 405 | + err = bpf_skb_load_bytes_relative(skb, l4_offset, &tcp, sizeof(tcp), | ||
| 406 | + BPF_HDR_START_NET); | ||
| 407 | + if (err) { | ||
| 408 | + goto error; | ||
| 409 | + } | ||
| 410 | + | ||
| 411 | + info->src_port = tcp.source; | ||
| 412 | + info->dst_port = tcp.dest; | ||
| 413 | + } else if (l4_protocol == IPPROTO_UDP) { /* TODO: add udplite? */ | ||
| 414 | + info->is_udp = 1; | ||
| 415 | + | ||
| 416 | + struct udphdr udp = {}; | ||
| 417 | + err = bpf_skb_load_bytes_relative(skb, l4_offset, &udp, sizeof(udp), | ||
| 418 | + BPF_HDR_START_NET); | ||
| 419 | + if (err) { | ||
| 420 | + goto error; | ||
| 421 | + } | ||
| 422 | + | ||
| 423 | + info->src_port = udp.source; | ||
| 424 | + info->dst_port = udp.dest; | ||
| 425 | + } | ||
| 426 | + } | ||
| 427 | + | ||
| 428 | + return 0; | ||
| 429 | + | ||
| 430 | +error: | ||
| 431 | + return err; | ||
| 432 | +} | ||
| 433 | + | ||
| 434 | +static inline __u32 calculate_rss_hash(struct __sk_buff *skb, | ||
| 435 | + struct rss_config_t *config, struct toeplitz_key_data_t *toe) | ||
| 436 | +{ | ||
| 437 | + __u8 rss_input[HASH_CALCULATION_BUFFER_SIZE] = {}; | ||
| 438 | + size_t bytes_written = 0; | ||
| 439 | + __u32 result = 0; | ||
| 440 | + int err = 0; | ||
| 441 | + struct packet_hash_info_t packet_info = {}; | ||
| 442 | + | ||
| 443 | + err = parse_packet(skb, &packet_info); | ||
| 444 | + if (err) { | ||
| 445 | + return 0; | ||
| 446 | + } | ||
| 447 | + | ||
| 448 | + if (packet_info.is_ipv4) { | ||
| 449 | + if (packet_info.is_tcp && | ||
| 450 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_TCPv4) { | ||
| 451 | + | ||
| 452 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 453 | + &packet_info.in_src, | ||
| 454 | + sizeof(packet_info.in_src)); | ||
| 455 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 456 | + &packet_info.in_dst, | ||
| 457 | + sizeof(packet_info.in_dst)); | ||
| 458 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 459 | + &packet_info.src_port, | ||
| 460 | + sizeof(packet_info.src_port)); | ||
| 461 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 462 | + &packet_info.dst_port, | ||
| 463 | + sizeof(packet_info.dst_port)); | ||
| 464 | + } else if (packet_info.is_udp && | ||
| 465 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_UDPv4) { | ||
| 466 | + | ||
| 467 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 468 | + &packet_info.in_src, | ||
| 469 | + sizeof(packet_info.in_src)); | ||
| 470 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 471 | + &packet_info.in_dst, | ||
| 472 | + sizeof(packet_info.in_dst)); | ||
| 473 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 474 | + &packet_info.src_port, | ||
| 475 | + sizeof(packet_info.src_port)); | ||
| 476 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 477 | + &packet_info.dst_port, | ||
| 478 | + sizeof(packet_info.dst_port)); | ||
| 479 | + } else if (config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_IPv4) { | ||
| 480 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 481 | + &packet_info.in_src, | ||
| 482 | + sizeof(packet_info.in_src)); | ||
| 483 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 484 | + &packet_info.in_dst, | ||
| 485 | + sizeof(packet_info.in_dst)); | ||
| 486 | + } | ||
| 487 | + } else if (packet_info.is_ipv6) { | ||
| 488 | + if (packet_info.is_tcp && | ||
| 489 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_TCPv6) { | ||
| 490 | + | ||
| 491 | + if (packet_info.is_ipv6_ext_src && | ||
| 492 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_TCP_EX) { | ||
| 493 | + | ||
| 494 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 495 | + &packet_info.in6_ext_src, | ||
| 496 | + sizeof(packet_info.in6_ext_src)); | ||
| 497 | + } else { | ||
| 498 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 499 | + &packet_info.in6_src, | ||
| 500 | + sizeof(packet_info.in6_src)); | ||
| 501 | + } | ||
| 502 | + if (packet_info.is_ipv6_ext_dst && | ||
| 503 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_TCP_EX) { | ||
| 504 | + | ||
| 505 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 506 | + &packet_info.in6_ext_dst, | ||
| 507 | + sizeof(packet_info.in6_ext_dst)); | ||
| 508 | + } else { | ||
| 509 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 510 | + &packet_info.in6_dst, | ||
| 511 | + sizeof(packet_info.in6_dst)); | ||
| 512 | + } | ||
| 513 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 514 | + &packet_info.src_port, | ||
| 515 | + sizeof(packet_info.src_port)); | ||
| 516 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 517 | + &packet_info.dst_port, | ||
| 518 | + sizeof(packet_info.dst_port)); | ||
| 519 | + } else if (packet_info.is_udp && | ||
| 520 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_UDPv6) { | ||
| 521 | + | ||
| 522 | + if (packet_info.is_ipv6_ext_src && | ||
| 523 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_UDP_EX) { | ||
| 524 | + | ||
| 525 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 526 | + &packet_info.in6_ext_src, | ||
| 527 | + sizeof(packet_info.in6_ext_src)); | ||
| 528 | + } else { | ||
| 529 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 530 | + &packet_info.in6_src, | ||
| 531 | + sizeof(packet_info.in6_src)); | ||
| 532 | + } | ||
| 533 | + if (packet_info.is_ipv6_ext_dst && | ||
| 534 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_UDP_EX) { | ||
| 535 | + | ||
| 536 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 537 | + &packet_info.in6_ext_dst, | ||
| 538 | + sizeof(packet_info.in6_ext_dst)); | ||
| 539 | + } else { | ||
| 540 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 541 | + &packet_info.in6_dst, | ||
| 542 | + sizeof(packet_info.in6_dst)); | ||
| 543 | + } | ||
| 544 | + | ||
| 545 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 546 | + &packet_info.src_port, | ||
| 547 | + sizeof(packet_info.src_port)); | ||
| 548 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 549 | + &packet_info.dst_port, | ||
| 550 | + sizeof(packet_info.dst_port)); | ||
| 551 | + | ||
| 552 | + } else if (config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_IPv6) { | ||
| 553 | + if (packet_info.is_ipv6_ext_src && | ||
| 554 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_IP_EX) { | ||
| 555 | + | ||
| 556 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 557 | + &packet_info.in6_ext_src, | ||
| 558 | + sizeof(packet_info.in6_ext_src)); | ||
| 559 | + } else { | ||
| 560 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 561 | + &packet_info.in6_src, | ||
| 562 | + sizeof(packet_info.in6_src)); | ||
| 563 | + } | ||
| 564 | + if (packet_info.is_ipv6_ext_dst && | ||
| 565 | + config->hash_types & VIRTIO_NET_RSS_HASH_TYPE_IP_EX) { | ||
| 566 | + | ||
| 567 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 568 | + &packet_info.in6_ext_dst, | ||
| 569 | + sizeof(packet_info.in6_ext_dst)); | ||
| 570 | + } else { | ||
| 571 | + net_rx_rss_add_chunk(rss_input, &bytes_written, | ||
| 572 | + &packet_info.in6_dst, | ||
| 573 | + sizeof(packet_info.in6_dst)); | ||
| 574 | + } | ||
| 575 | + } | ||
| 576 | + } | ||
| 577 | + | ||
| 578 | + if (bytes_written) { | ||
| 579 | + net_toeplitz_add(&result, rss_input, bytes_written, toe); | ||
| 580 | + } | ||
| 581 | + | ||
| 582 | + return result; | ||
| 583 | +} | ||
| 584 | + | ||
| 585 | +SEC("tun_rss_steering") | ||
| 586 | +int tun_rss_steering_prog(struct __sk_buff *skb) | ||
| 587 | +{ | ||
| 588 | + | ||
| 589 | + struct rss_config_t *config; | ||
| 590 | + struct toeplitz_key_data_t *toe; | ||
| 591 | + | ||
| 592 | + __u32 key = 0; | ||
| 593 | + __u32 hash = 0; | ||
| 594 | + | ||
| 595 | + config = bpf_map_lookup_elem(&tap_rss_map_configurations, &key); | ||
| 596 | + toe = bpf_map_lookup_elem(&tap_rss_map_toeplitz_key, &key); | ||
| 597 | + | ||
| 598 | + if (config && toe) { | ||
| 599 | + if (!config->redirect) { | ||
| 600 | + return config->default_queue; | ||
| 601 | + } | ||
| 602 | + | ||
| 603 | + hash = calculate_rss_hash(skb, config, toe); | ||
| 604 | + if (hash) { | ||
| 605 | + __u32 table_idx = hash % config->indirections_len; | ||
| 606 | + __u16 *queue = 0; | ||
| 607 | + | ||
| 608 | + queue = bpf_map_lookup_elem(&tap_rss_map_indirection_table, | ||
| 609 | + &table_idx); | ||
| 610 | + | ||
| 611 | + if (queue) { | ||
| 612 | + return *queue; | ||
| 613 | + } | ||
| 614 | + } | ||
| 615 | + | ||
| 616 | + return config->default_queue; | ||
| 617 | + } | ||
| 618 | + | ||
| 619 | + return -1; | ||
| 620 | +} | ||
| 621 | + | ||
| 622 | +char _license[] SEC("license") = "GPL v2"; | ||
| 47 | -- | 623 | -- |
| 48 | 2.7.4 | 624 | 2.7.4 |
| 49 | 625 | ||
| 50 | 626 | diff view generated by jsdifflib |
| 1 | From: Thomas Huth <thuth@redhat.com> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | It has never been documented, so hardly anybody knows about this | 3 | Added function that loads RSS eBPF program. |
| 4 | parameter, and it is marked as deprecated since QEMU v2.6. | 4 | Added stub functions for RSS eBPF loader. |
| 5 | Time to let it go now. | 5 | Added meson and configuration options. |
| 6 | 6 | ||
| 7 | Reviewed-by: Samuel Thibault <samuel.thibault@ens-lyon.org> | 7 | By default, eBPF feature enabled if libbpf is present in the build system. |
| 8 | Signed-off-by: Thomas Huth <thuth@redhat.com> | 8 | libbpf checked in configuration shell script and meson script. |
| 9 | |||
| 10 | Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com> | ||
| 11 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> | ||
| 9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 12 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 10 | --- | 13 | --- |
| 11 | include/net/slirp.h | 2 -- | 14 | configure | 8 +- |
| 12 | net/net.c | 7 ------- | 15 | ebpf/ebpf_rss-stub.c | 40 +++++ |
| 13 | net/slirp.c | 34 ---------------------------------- | 16 | ebpf/ebpf_rss.c | 165 ++++++++++++++++++ |
| 14 | qemu-doc.texi | 5 ----- | 17 | ebpf/ebpf_rss.h | 44 +++++ |
| 15 | 4 files changed, 48 deletions(-) | 18 | ebpf/meson.build | 1 + |
| 19 | ebpf/rss.bpf.skeleton.h | 431 ++++++++++++++++++++++++++++++++++++++++++++++++ | ||
| 20 | ebpf/trace-events | 4 + | ||
| 21 | ebpf/trace.h | 1 + | ||
| 22 | meson.build | 23 +++ | ||
| 23 | meson_options.txt | 2 + | ||
| 24 | 10 files changed, 718 insertions(+), 1 deletion(-) | ||
| 25 | create mode 100644 ebpf/ebpf_rss-stub.c | ||
| 26 | create mode 100644 ebpf/ebpf_rss.c | ||
| 27 | create mode 100644 ebpf/ebpf_rss.h | ||
| 28 | create mode 100644 ebpf/meson.build | ||
| 29 | create mode 100644 ebpf/rss.bpf.skeleton.h | ||
| 30 | create mode 100644 ebpf/trace-events | ||
| 31 | create mode 100644 ebpf/trace.h | ||
| 16 | 32 | ||
| 17 | diff --git a/include/net/slirp.h b/include/net/slirp.h | 33 | diff --git a/configure b/configure |
| 34 | index XXXXXXX..XXXXXXX 100755 | ||
| 35 | --- a/configure | ||
| 36 | +++ b/configure | ||
| 37 | @@ -XXX,XX +XXX,XX @@ vhost_vsock="$default_feature" | ||
| 38 | vhost_user="no" | ||
| 39 | vhost_user_blk_server="auto" | ||
| 40 | vhost_user_fs="$default_feature" | ||
| 41 | +bpf="auto" | ||
| 42 | kvm="auto" | ||
| 43 | hax="auto" | ||
| 44 | hvf="auto" | ||
| 45 | @@ -XXX,XX +XXX,XX @@ for opt do | ||
| 46 | ;; | ||
| 47 | --enable-membarrier) membarrier="yes" | ||
| 48 | ;; | ||
| 49 | + --disable-bpf) bpf="disabled" | ||
| 50 | + ;; | ||
| 51 | + --enable-bpf) bpf="enabled" | ||
| 52 | + ;; | ||
| 53 | --disable-blobs) blobs="false" | ||
| 54 | ;; | ||
| 55 | --with-pkgversion=*) pkgversion="$optarg" | ||
| 56 | @@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available | ||
| 57 | vhost-user vhost-user backend support | ||
| 58 | vhost-user-blk-server vhost-user-blk server support | ||
| 59 | vhost-vdpa vhost-vdpa kernel backend support | ||
| 60 | + bpf BPF kernel support | ||
| 61 | spice spice | ||
| 62 | spice-protocol spice-protocol | ||
| 63 | rbd rados block device (rbd) | ||
| 64 | @@ -XXX,XX +XXX,XX @@ if test "$skip_meson" = no; then | ||
| 65 | -Dattr=$attr -Ddefault_devices=$default_devices \ | ||
| 66 | -Ddocs=$docs -Dsphinx_build=$sphinx_build -Dinstall_blobs=$blobs \ | ||
| 67 | -Dvhost_user_blk_server=$vhost_user_blk_server -Dmultiprocess=$multiprocess \ | ||
| 68 | - -Dfuse=$fuse -Dfuse_lseek=$fuse_lseek -Dguest_agent_msi=$guest_agent_msi \ | ||
| 69 | + -Dfuse=$fuse -Dfuse_lseek=$fuse_lseek -Dguest_agent_msi=$guest_agent_msi -Dbpf=$bpf\ | ||
| 70 | $(if test "$default_features" = no; then echo "-Dauto_features=disabled"; fi) \ | ||
| 71 | -Dtcg_interpreter=$tcg_interpreter \ | ||
| 72 | $cross_arg \ | ||
| 73 | diff --git a/ebpf/ebpf_rss-stub.c b/ebpf/ebpf_rss-stub.c | ||
| 74 | new file mode 100644 | ||
| 75 | index XXXXXXX..XXXXXXX | ||
| 76 | --- /dev/null | ||
| 77 | +++ b/ebpf/ebpf_rss-stub.c | ||
| 78 | @@ -XXX,XX +XXX,XX @@ | ||
| 79 | +/* | ||
| 80 | + * eBPF RSS stub file | ||
| 81 | + * | ||
| 82 | + * Developed by Daynix Computing LTD (http://www.daynix.com) | ||
| 83 | + * | ||
| 84 | + * Authors: | ||
| 85 | + * Yuri Benditovich <yuri.benditovich@daynix.com> | ||
| 86 | + * | ||
| 87 | + * This work is licensed under the terms of the GNU GPL, version 2. See | ||
| 88 | + * the COPYING file in the top-level directory. | ||
| 89 | + */ | ||
| 90 | + | ||
| 91 | +#include "qemu/osdep.h" | ||
| 92 | +#include "ebpf/ebpf_rss.h" | ||
| 93 | + | ||
| 94 | +void ebpf_rss_init(struct EBPFRSSContext *ctx) | ||
| 95 | +{ | ||
| 96 | + | ||
| 97 | +} | ||
| 98 | + | ||
| 99 | +bool ebpf_rss_is_loaded(struct EBPFRSSContext *ctx) | ||
| 100 | +{ | ||
| 101 | + return false; | ||
| 102 | +} | ||
| 103 | + | ||
| 104 | +bool ebpf_rss_load(struct EBPFRSSContext *ctx) | ||
| 105 | +{ | ||
| 106 | + return false; | ||
| 107 | +} | ||
| 108 | + | ||
| 109 | +bool ebpf_rss_set_all(struct EBPFRSSContext *ctx, struct EBPFRSSConfig *config, | ||
| 110 | + uint16_t *indirections_table, uint8_t *toeplitz_key) | ||
| 111 | +{ | ||
| 112 | + return false; | ||
| 113 | +} | ||
| 114 | + | ||
| 115 | +void ebpf_rss_unload(struct EBPFRSSContext *ctx) | ||
| 116 | +{ | ||
| 117 | + | ||
| 118 | +} | ||
| 119 | diff --git a/ebpf/ebpf_rss.c b/ebpf/ebpf_rss.c | ||
| 120 | new file mode 100644 | ||
| 121 | index XXXXXXX..XXXXXXX | ||
| 122 | --- /dev/null | ||
| 123 | +++ b/ebpf/ebpf_rss.c | ||
| 124 | @@ -XXX,XX +XXX,XX @@ | ||
| 125 | +/* | ||
| 126 | + * eBPF RSS loader | ||
| 127 | + * | ||
| 128 | + * Developed by Daynix Computing LTD (http://www.daynix.com) | ||
| 129 | + * | ||
| 130 | + * Authors: | ||
| 131 | + * Andrew Melnychenko <andrew@daynix.com> | ||
| 132 | + * Yuri Benditovich <yuri.benditovich@daynix.com> | ||
| 133 | + * | ||
| 134 | + * This work is licensed under the terms of the GNU GPL, version 2. See | ||
| 135 | + * the COPYING file in the top-level directory. | ||
| 136 | + */ | ||
| 137 | + | ||
| 138 | +#include "qemu/osdep.h" | ||
| 139 | +#include "qemu/error-report.h" | ||
| 140 | + | ||
| 141 | +#include <bpf/libbpf.h> | ||
| 142 | +#include <bpf/bpf.h> | ||
| 143 | + | ||
| 144 | +#include "hw/virtio/virtio-net.h" /* VIRTIO_NET_RSS_MAX_TABLE_LEN */ | ||
| 145 | + | ||
| 146 | +#include "ebpf/ebpf_rss.h" | ||
| 147 | +#include "ebpf/rss.bpf.skeleton.h" | ||
| 148 | +#include "trace.h" | ||
| 149 | + | ||
| 150 | +void ebpf_rss_init(struct EBPFRSSContext *ctx) | ||
| 151 | +{ | ||
| 152 | + if (ctx != NULL) { | ||
| 153 | + ctx->obj = NULL; | ||
| 154 | + } | ||
| 155 | +} | ||
| 156 | + | ||
| 157 | +bool ebpf_rss_is_loaded(struct EBPFRSSContext *ctx) | ||
| 158 | +{ | ||
| 159 | + return ctx != NULL && ctx->obj != NULL; | ||
| 160 | +} | ||
| 161 | + | ||
| 162 | +bool ebpf_rss_load(struct EBPFRSSContext *ctx) | ||
| 163 | +{ | ||
| 164 | + struct rss_bpf *rss_bpf_ctx; | ||
| 165 | + | ||
| 166 | + if (ctx == NULL) { | ||
| 167 | + return false; | ||
| 168 | + } | ||
| 169 | + | ||
| 170 | + rss_bpf_ctx = rss_bpf__open(); | ||
| 171 | + if (rss_bpf_ctx == NULL) { | ||
| 172 | + trace_ebpf_error("eBPF RSS", "can not open eBPF RSS object"); | ||
| 173 | + goto error; | ||
| 174 | + } | ||
| 175 | + | ||
| 176 | + bpf_program__set_socket_filter(rss_bpf_ctx->progs.tun_rss_steering_prog); | ||
| 177 | + | ||
| 178 | + if (rss_bpf__load(rss_bpf_ctx)) { | ||
| 179 | + trace_ebpf_error("eBPF RSS", "can not load RSS program"); | ||
| 180 | + goto error; | ||
| 181 | + } | ||
| 182 | + | ||
| 183 | + ctx->obj = rss_bpf_ctx; | ||
| 184 | + ctx->program_fd = bpf_program__fd( | ||
| 185 | + rss_bpf_ctx->progs.tun_rss_steering_prog); | ||
| 186 | + ctx->map_configuration = bpf_map__fd( | ||
| 187 | + rss_bpf_ctx->maps.tap_rss_map_configurations); | ||
| 188 | + ctx->map_indirections_table = bpf_map__fd( | ||
| 189 | + rss_bpf_ctx->maps.tap_rss_map_indirection_table); | ||
| 190 | + ctx->map_toeplitz_key = bpf_map__fd( | ||
| 191 | + rss_bpf_ctx->maps.tap_rss_map_toeplitz_key); | ||
| 192 | + | ||
| 193 | + return true; | ||
| 194 | +error: | ||
| 195 | + rss_bpf__destroy(rss_bpf_ctx); | ||
| 196 | + ctx->obj = NULL; | ||
| 197 | + | ||
| 198 | + return false; | ||
| 199 | +} | ||
| 200 | + | ||
| 201 | +static bool ebpf_rss_set_config(struct EBPFRSSContext *ctx, | ||
| 202 | + struct EBPFRSSConfig *config) | ||
| 203 | +{ | ||
| 204 | + uint32_t map_key = 0; | ||
| 205 | + | ||
| 206 | + if (!ebpf_rss_is_loaded(ctx)) { | ||
| 207 | + return false; | ||
| 208 | + } | ||
| 209 | + if (bpf_map_update_elem(ctx->map_configuration, | ||
| 210 | + &map_key, config, 0) < 0) { | ||
| 211 | + return false; | ||
| 212 | + } | ||
| 213 | + return true; | ||
| 214 | +} | ||
| 215 | + | ||
| 216 | +static bool ebpf_rss_set_indirections_table(struct EBPFRSSContext *ctx, | ||
| 217 | + uint16_t *indirections_table, | ||
| 218 | + size_t len) | ||
| 219 | +{ | ||
| 220 | + uint32_t i = 0; | ||
| 221 | + | ||
| 222 | + if (!ebpf_rss_is_loaded(ctx) || indirections_table == NULL || | ||
| 223 | + len > VIRTIO_NET_RSS_MAX_TABLE_LEN) { | ||
| 224 | + return false; | ||
| 225 | + } | ||
| 226 | + | ||
| 227 | + for (; i < len; ++i) { | ||
| 228 | + if (bpf_map_update_elem(ctx->map_indirections_table, &i, | ||
| 229 | + indirections_table + i, 0) < 0) { | ||
| 230 | + return false; | ||
| 231 | + } | ||
| 232 | + } | ||
| 233 | + return true; | ||
| 234 | +} | ||
| 235 | + | ||
| 236 | +static bool ebpf_rss_set_toepliz_key(struct EBPFRSSContext *ctx, | ||
| 237 | + uint8_t *toeplitz_key) | ||
| 238 | +{ | ||
| 239 | + uint32_t map_key = 0; | ||
| 240 | + | ||
| 241 | + /* prepare toeplitz key */ | ||
| 242 | + uint8_t toe[VIRTIO_NET_RSS_MAX_KEY_SIZE] = {}; | ||
| 243 | + | ||
| 244 | + if (!ebpf_rss_is_loaded(ctx) || toeplitz_key == NULL) { | ||
| 245 | + return false; | ||
| 246 | + } | ||
| 247 | + memcpy(toe, toeplitz_key, VIRTIO_NET_RSS_MAX_KEY_SIZE); | ||
| 248 | + *(uint32_t *)toe = ntohl(*(uint32_t *)toe); | ||
| 249 | + | ||
| 250 | + if (bpf_map_update_elem(ctx->map_toeplitz_key, &map_key, toe, | ||
| 251 | + 0) < 0) { | ||
| 252 | + return false; | ||
| 253 | + } | ||
| 254 | + return true; | ||
| 255 | +} | ||
| 256 | + | ||
| 257 | +bool ebpf_rss_set_all(struct EBPFRSSContext *ctx, struct EBPFRSSConfig *config, | ||
| 258 | + uint16_t *indirections_table, uint8_t *toeplitz_key) | ||
| 259 | +{ | ||
| 260 | + if (!ebpf_rss_is_loaded(ctx) || config == NULL || | ||
| 261 | + indirections_table == NULL || toeplitz_key == NULL) { | ||
| 262 | + return false; | ||
| 263 | + } | ||
| 264 | + | ||
| 265 | + if (!ebpf_rss_set_config(ctx, config)) { | ||
| 266 | + return false; | ||
| 267 | + } | ||
| 268 | + | ||
| 269 | + if (!ebpf_rss_set_indirections_table(ctx, indirections_table, | ||
| 270 | + config->indirections_len)) { | ||
| 271 | + return false; | ||
| 272 | + } | ||
| 273 | + | ||
| 274 | + if (!ebpf_rss_set_toepliz_key(ctx, toeplitz_key)) { | ||
| 275 | + return false; | ||
| 276 | + } | ||
| 277 | + | ||
| 278 | + return true; | ||
| 279 | +} | ||
| 280 | + | ||
| 281 | +void ebpf_rss_unload(struct EBPFRSSContext *ctx) | ||
| 282 | +{ | ||
| 283 | + if (!ebpf_rss_is_loaded(ctx)) { | ||
| 284 | + return; | ||
| 285 | + } | ||
| 286 | + | ||
| 287 | + rss_bpf__destroy(ctx->obj); | ||
| 288 | + ctx->obj = NULL; | ||
| 289 | +} | ||
| 290 | diff --git a/ebpf/ebpf_rss.h b/ebpf/ebpf_rss.h | ||
| 291 | new file mode 100644 | ||
| 292 | index XXXXXXX..XXXXXXX | ||
| 293 | --- /dev/null | ||
| 294 | +++ b/ebpf/ebpf_rss.h | ||
| 295 | @@ -XXX,XX +XXX,XX @@ | ||
| 296 | +/* | ||
| 297 | + * eBPF RSS header | ||
| 298 | + * | ||
| 299 | + * Developed by Daynix Computing LTD (http://www.daynix.com) | ||
| 300 | + * | ||
| 301 | + * Authors: | ||
| 302 | + * Andrew Melnychenko <andrew@daynix.com> | ||
| 303 | + * Yuri Benditovich <yuri.benditovich@daynix.com> | ||
| 304 | + * | ||
| 305 | + * This work is licensed under the terms of the GNU GPL, version 2. See | ||
| 306 | + * the COPYING file in the top-level directory. | ||
| 307 | + */ | ||
| 308 | + | ||
| 309 | +#ifndef QEMU_EBPF_RSS_H | ||
| 310 | +#define QEMU_EBPF_RSS_H | ||
| 311 | + | ||
| 312 | +struct EBPFRSSContext { | ||
| 313 | + void *obj; | ||
| 314 | + int program_fd; | ||
| 315 | + int map_configuration; | ||
| 316 | + int map_toeplitz_key; | ||
| 317 | + int map_indirections_table; | ||
| 318 | +}; | ||
| 319 | + | ||
| 320 | +struct EBPFRSSConfig { | ||
| 321 | + uint8_t redirect; | ||
| 322 | + uint8_t populate_hash; | ||
| 323 | + uint32_t hash_types; | ||
| 324 | + uint16_t indirections_len; | ||
| 325 | + uint16_t default_queue; | ||
| 326 | +} __attribute__((packed)); | ||
| 327 | + | ||
| 328 | +void ebpf_rss_init(struct EBPFRSSContext *ctx); | ||
| 329 | + | ||
| 330 | +bool ebpf_rss_is_loaded(struct EBPFRSSContext *ctx); | ||
| 331 | + | ||
| 332 | +bool ebpf_rss_load(struct EBPFRSSContext *ctx); | ||
| 333 | + | ||
| 334 | +bool ebpf_rss_set_all(struct EBPFRSSContext *ctx, struct EBPFRSSConfig *config, | ||
| 335 | + uint16_t *indirections_table, uint8_t *toeplitz_key); | ||
| 336 | + | ||
| 337 | +void ebpf_rss_unload(struct EBPFRSSContext *ctx); | ||
| 338 | + | ||
| 339 | +#endif /* QEMU_EBPF_RSS_H */ | ||
| 340 | diff --git a/ebpf/meson.build b/ebpf/meson.build | ||
| 341 | new file mode 100644 | ||
| 342 | index XXXXXXX..XXXXXXX | ||
| 343 | --- /dev/null | ||
| 344 | +++ b/ebpf/meson.build | ||
| 345 | @@ -0,0 +1 @@ | ||
| 346 | +common_ss.add(when: libbpf, if_true: files('ebpf_rss.c'), if_false: files('ebpf_rss-stub.c')) | ||
| 347 | diff --git a/ebpf/rss.bpf.skeleton.h b/ebpf/rss.bpf.skeleton.h | ||
| 348 | new file mode 100644 | ||
| 349 | index XXXXXXX..XXXXXXX | ||
| 350 | --- /dev/null | ||
| 351 | +++ b/ebpf/rss.bpf.skeleton.h | ||
| 352 | @@ -XXX,XX +XXX,XX @@ | ||
| 353 | +/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ | ||
| 354 | + | ||
| 355 | +/* THIS FILE IS AUTOGENERATED! */ | ||
| 356 | +#ifndef __RSS_BPF_SKEL_H__ | ||
| 357 | +#define __RSS_BPF_SKEL_H__ | ||
| 358 | + | ||
| 359 | +#include <stdlib.h> | ||
| 360 | +#include <bpf/libbpf.h> | ||
| 361 | + | ||
| 362 | +struct rss_bpf { | ||
| 363 | + struct bpf_object_skeleton *skeleton; | ||
| 364 | + struct bpf_object *obj; | ||
| 365 | + struct { | ||
| 366 | + struct bpf_map *tap_rss_map_configurations; | ||
| 367 | + struct bpf_map *tap_rss_map_indirection_table; | ||
| 368 | + struct bpf_map *tap_rss_map_toeplitz_key; | ||
| 369 | + } maps; | ||
| 370 | + struct { | ||
| 371 | + struct bpf_program *tun_rss_steering_prog; | ||
| 372 | + } progs; | ||
| 373 | + struct { | ||
| 374 | + struct bpf_link *tun_rss_steering_prog; | ||
| 375 | + } links; | ||
| 376 | +}; | ||
| 377 | + | ||
| 378 | +static void | ||
| 379 | +rss_bpf__destroy(struct rss_bpf *obj) | ||
| 380 | +{ | ||
| 381 | + if (!obj) | ||
| 382 | + return; | ||
| 383 | + if (obj->skeleton) | ||
| 384 | + bpf_object__destroy_skeleton(obj->skeleton); | ||
| 385 | + free(obj); | ||
| 386 | +} | ||
| 387 | + | ||
| 388 | +static inline int | ||
| 389 | +rss_bpf__create_skeleton(struct rss_bpf *obj); | ||
| 390 | + | ||
| 391 | +static inline struct rss_bpf * | ||
| 392 | +rss_bpf__open_opts(const struct bpf_object_open_opts *opts) | ||
| 393 | +{ | ||
| 394 | + struct rss_bpf *obj; | ||
| 395 | + | ||
| 396 | + obj = (struct rss_bpf *)calloc(1, sizeof(*obj)); | ||
| 397 | + if (!obj) | ||
| 398 | + return NULL; | ||
| 399 | + if (rss_bpf__create_skeleton(obj)) | ||
| 400 | + goto err; | ||
| 401 | + if (bpf_object__open_skeleton(obj->skeleton, opts)) | ||
| 402 | + goto err; | ||
| 403 | + | ||
| 404 | + return obj; | ||
| 405 | +err: | ||
| 406 | + rss_bpf__destroy(obj); | ||
| 407 | + return NULL; | ||
| 408 | +} | ||
| 409 | + | ||
| 410 | +static inline struct rss_bpf * | ||
| 411 | +rss_bpf__open(void) | ||
| 412 | +{ | ||
| 413 | + return rss_bpf__open_opts(NULL); | ||
| 414 | +} | ||
| 415 | + | ||
| 416 | +static inline int | ||
| 417 | +rss_bpf__load(struct rss_bpf *obj) | ||
| 418 | +{ | ||
| 419 | + return bpf_object__load_skeleton(obj->skeleton); | ||
| 420 | +} | ||
| 421 | + | ||
| 422 | +static inline struct rss_bpf * | ||
| 423 | +rss_bpf__open_and_load(void) | ||
| 424 | +{ | ||
| 425 | + struct rss_bpf *obj; | ||
| 426 | + | ||
| 427 | + obj = rss_bpf__open(); | ||
| 428 | + if (!obj) | ||
| 429 | + return NULL; | ||
| 430 | + if (rss_bpf__load(obj)) { | ||
| 431 | + rss_bpf__destroy(obj); | ||
| 432 | + return NULL; | ||
| 433 | + } | ||
| 434 | + return obj; | ||
| 435 | +} | ||
| 436 | + | ||
| 437 | +static inline int | ||
| 438 | +rss_bpf__attach(struct rss_bpf *obj) | ||
| 439 | +{ | ||
| 440 | + return bpf_object__attach_skeleton(obj->skeleton); | ||
| 441 | +} | ||
| 442 | + | ||
| 443 | +static inline void | ||
| 444 | +rss_bpf__detach(struct rss_bpf *obj) | ||
| 445 | +{ | ||
| 446 | + return bpf_object__detach_skeleton(obj->skeleton); | ||
| 447 | +} | ||
| 448 | + | ||
| 449 | +static inline int | ||
| 450 | +rss_bpf__create_skeleton(struct rss_bpf *obj) | ||
| 451 | +{ | ||
| 452 | + struct bpf_object_skeleton *s; | ||
| 453 | + | ||
| 454 | + s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s)); | ||
| 455 | + if (!s) | ||
| 456 | + return -1; | ||
| 457 | + obj->skeleton = s; | ||
| 458 | + | ||
| 459 | + s->sz = sizeof(*s); | ||
| 460 | + s->name = "rss_bpf"; | ||
| 461 | + s->obj = &obj->obj; | ||
| 462 | + | ||
| 463 | + /* maps */ | ||
| 464 | + s->map_cnt = 3; | ||
| 465 | + s->map_skel_sz = sizeof(*s->maps); | ||
| 466 | + s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz); | ||
| 467 | + if (!s->maps) | ||
| 468 | + goto err; | ||
| 469 | + | ||
| 470 | + s->maps[0].name = "tap_rss_map_configurations"; | ||
| 471 | + s->maps[0].map = &obj->maps.tap_rss_map_configurations; | ||
| 472 | + | ||
| 473 | + s->maps[1].name = "tap_rss_map_indirection_table"; | ||
| 474 | + s->maps[1].map = &obj->maps.tap_rss_map_indirection_table; | ||
| 475 | + | ||
| 476 | + s->maps[2].name = "tap_rss_map_toeplitz_key"; | ||
| 477 | + s->maps[2].map = &obj->maps.tap_rss_map_toeplitz_key; | ||
| 478 | + | ||
| 479 | + /* programs */ | ||
| 480 | + s->prog_cnt = 1; | ||
| 481 | + s->prog_skel_sz = sizeof(*s->progs); | ||
| 482 | + s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz); | ||
| 483 | + if (!s->progs) | ||
| 484 | + goto err; | ||
| 485 | + | ||
| 486 | + s->progs[0].name = "tun_rss_steering_prog"; | ||
| 487 | + s->progs[0].prog = &obj->progs.tun_rss_steering_prog; | ||
| 488 | + s->progs[0].link = &obj->links.tun_rss_steering_prog; | ||
| 489 | + | ||
| 490 | + s->data_sz = 8088; | ||
| 491 | + s->data = (void *)"\ | ||
| 492 | +\x7f\x45\x4c\x46\x02\x01\x01\0\0\0\0\0\0\0\0\0\x01\0\xf7\0\x01\0\0\0\0\0\0\0\0\ | ||
| 493 | +\0\0\0\0\0\0\0\0\0\0\0\x18\x1d\0\0\0\0\0\0\0\0\0\0\x40\0\0\0\0\0\x40\0\x0a\0\ | ||
| 494 | +\x01\0\xbf\x18\0\0\0\0\0\0\xb7\x01\0\0\0\0\0\0\x63\x1a\x4c\xff\0\0\0\0\xbf\xa7\ | ||
| 495 | +\0\0\0\0\0\0\x07\x07\0\0\x4c\xff\xff\xff\x18\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 496 | +\xbf\x72\0\0\0\0\0\0\x85\0\0\0\x01\0\0\0\xbf\x06\0\0\0\0\0\0\x18\x01\0\0\0\0\0\ | ||
| 497 | +\0\0\0\0\0\0\0\0\0\xbf\x72\0\0\0\0\0\0\x85\0\0\0\x01\0\0\0\xbf\x07\0\0\0\0\0\0\ | ||
| 498 | +\x18\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\x15\x06\x66\x02\0\0\0\0\xbf\x79\0\0\ | ||
| 499 | +\0\0\0\0\x15\x09\x64\x02\0\0\0\0\x71\x61\0\0\0\0\0\0\x55\x01\x01\0\0\0\0\0\x05\ | ||
| 500 | +\0\x5d\x02\0\0\0\0\xb7\x01\0\0\0\0\0\0\x63\x1a\xc0\xff\0\0\0\0\x7b\x1a\xb8\xff\ | ||
| 501 | +\0\0\0\0\x7b\x1a\xb0\xff\0\0\0\0\x7b\x1a\xa8\xff\0\0\0\0\x7b\x1a\xa0\xff\0\0\0\ | ||
| 502 | +\0\x63\x1a\x98\xff\0\0\0\0\x7b\x1a\x90\xff\0\0\0\0\x7b\x1a\x88\xff\0\0\0\0\x7b\ | ||
| 503 | +\x1a\x80\xff\0\0\0\0\x7b\x1a\x78\xff\0\0\0\0\x7b\x1a\x70\xff\0\0\0\0\x7b\x1a\ | ||
| 504 | +\x68\xff\0\0\0\0\x7b\x1a\x60\xff\0\0\0\0\x7b\x1a\x58\xff\0\0\0\0\x7b\x1a\x50\ | ||
| 505 | +\xff\0\0\0\0\x15\x08\x4c\x02\0\0\0\0\x6b\x1a\xd0\xff\0\0\0\0\xbf\xa3\0\0\0\0\0\ | ||
| 506 | +\0\x07\x03\0\0\xd0\xff\xff\xff\xbf\x81\0\0\0\0\0\0\xb7\x02\0\0\x0c\0\0\0\xb7\ | ||
| 507 | +\x04\0\0\x02\0\0\0\xb7\x05\0\0\0\0\0\0\x85\0\0\0\x44\0\0\0\x67\0\0\0\x20\0\0\0\ | ||
| 508 | +\x77\0\0\0\x20\0\0\0\x55\0\x11\0\0\0\0\0\xb7\x02\0\0\x10\0\0\0\x69\xa1\xd0\xff\ | ||
| 509 | +\0\0\0\0\xbf\x13\0\0\0\0\0\0\xdc\x03\0\0\x10\0\0\0\x15\x03\x02\0\0\x81\0\0\x55\ | ||
| 510 | +\x03\x0c\0\xa8\x88\0\0\xb7\x02\0\0\x14\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\ | ||
| 511 | +\xd0\xff\xff\xff\xbf\x81\0\0\0\0\0\0\xb7\x04\0\0\x02\0\0\0\xb7\x05\0\0\0\0\0\0\ | ||
| 512 | +\x85\0\0\0\x44\0\0\0\x69\xa1\xd0\xff\0\0\0\0\x67\0\0\0\x20\0\0\0\x77\0\0\0\x20\ | ||
| 513 | +\0\0\0\x15\0\x01\0\0\0\0\0\x05\0\x2f\x02\0\0\0\0\x15\x01\x2e\x02\0\0\0\0\x7b\ | ||
| 514 | +\x9a\x30\xff\0\0\0\0\x15\x01\x57\0\x86\xdd\0\0\x55\x01\x3b\0\x08\0\0\0\x7b\x7a\ | ||
| 515 | +\x20\xff\0\0\0\0\xb7\x07\0\0\x01\0\0\0\x73\x7a\x50\xff\0\0\0\0\xb7\x01\0\0\0\0\ | ||
| 516 | +\0\0\x63\x1a\xe0\xff\0\0\0\0\x7b\x1a\xd8\xff\0\0\0\0\x7b\x1a\xd0\xff\0\0\0\0\ | ||
| 517 | +\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\xd0\xff\xff\xff\xbf\x81\0\0\0\0\0\0\xb7\x02\0\ | ||
| 518 | +\0\0\0\0\0\xb7\x04\0\0\x14\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\0\0\0\x67\ | ||
| 519 | +\0\0\0\x20\0\0\0\x77\0\0\0\x20\0\0\0\x55\0\x1a\x02\0\0\0\0\x69\xa1\xd6\xff\0\0\ | ||
| 520 | +\0\0\x55\x01\x01\0\0\0\0\0\xb7\x07\0\0\0\0\0\0\x61\xa1\xdc\xff\0\0\0\0\x63\x1a\ | ||
| 521 | +\x5c\xff\0\0\0\0\x61\xa1\xe0\xff\0\0\0\0\x63\x1a\x60\xff\0\0\0\0\x73\x7a\x56\ | ||
| 522 | +\xff\0\0\0\0\x71\xa9\xd9\xff\0\0\0\0\x71\xa1\xd0\xff\0\0\0\0\x67\x01\0\0\x02\0\ | ||
| 523 | +\0\0\x57\x01\0\0\x3c\0\0\0\x7b\x1a\x40\xff\0\0\0\0\x79\xa7\x20\xff\0\0\0\0\xbf\ | ||
| 524 | +\x91\0\0\0\0\0\0\x57\x01\0\0\xff\0\0\0\x15\x01\x19\0\0\0\0\0\x71\xa1\x56\xff\0\ | ||
| 525 | +\0\0\0\x55\x01\x17\0\0\0\0\0\x57\x09\0\0\xff\0\0\0\x15\x09\x7a\x01\x11\0\0\0\ | ||
| 526 | +\x55\x09\x14\0\x06\0\0\0\xb7\x01\0\0\x01\0\0\0\x73\x1a\x53\xff\0\0\0\0\xb7\x01\ | ||
| 527 | +\0\0\0\0\0\0\x63\x1a\xe0\xff\0\0\0\0\x7b\x1a\xd8\xff\0\0\0\0\x7b\x1a\xd0\xff\0\ | ||
| 528 | +\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\xd0\xff\xff\xff\xbf\x81\0\0\0\0\0\0\x79\ | ||
| 529 | +\xa2\x40\xff\0\0\0\0\xb7\x04\0\0\x14\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\ | ||
| 530 | +\0\0\0\x67\0\0\0\x20\0\0\0\x77\0\0\0\x20\0\0\0\x55\0\xf4\x01\0\0\0\0\x69\xa1\ | ||
| 531 | +\xd0\xff\0\0\0\0\x6b\x1a\x58\xff\0\0\0\0\x69\xa1\xd2\xff\0\0\0\0\x6b\x1a\x5a\ | ||
| 532 | +\xff\0\0\0\0\x71\xa1\x50\xff\0\0\0\0\x15\x01\xd4\0\0\0\0\0\x71\x62\x03\0\0\0\0\ | ||
| 533 | +\0\x67\x02\0\0\x08\0\0\0\x71\x61\x02\0\0\0\0\0\x4f\x12\0\0\0\0\0\0\x71\x63\x04\ | ||
| 534 | +\0\0\0\0\0\x71\x61\x05\0\0\0\0\0\x67\x01\0\0\x08\0\0\0\x4f\x31\0\0\0\0\0\0\x67\ | ||
| 535 | +\x01\0\0\x10\0\0\0\x4f\x21\0\0\0\0\0\0\x71\xa2\x53\xff\0\0\0\0\x79\xa0\x30\xff\ | ||
| 536 | +\0\0\0\0\x15\x02\x06\x01\0\0\0\0\xbf\x12\0\0\0\0\0\0\x57\x02\0\0\x02\0\0\0\x15\ | ||
| 537 | +\x02\x03\x01\0\0\0\0\x61\xa1\x5c\xff\0\0\0\0\x63\x1a\xa0\xff\0\0\0\0\x61\xa1\ | ||
| 538 | +\x60\xff\0\0\0\0\x63\x1a\xa4\xff\0\0\0\0\x69\xa1\x58\xff\0\0\0\0\x6b\x1a\xa8\ | ||
| 539 | +\xff\0\0\0\0\x69\xa1\x5a\xff\0\0\0\0\x6b\x1a\xaa\xff\0\0\0\0\x05\0\x65\x01\0\0\ | ||
| 540 | +\0\0\xb7\x01\0\0\x01\0\0\0\x73\x1a\x51\xff\0\0\0\0\xb7\x01\0\0\0\0\0\0\x7b\x1a\ | ||
| 541 | +\xf0\xff\0\0\0\0\x7b\x1a\xe8\xff\0\0\0\0\x7b\x1a\xe0\xff\0\0\0\0\x7b\x1a\xd8\ | ||
| 542 | +\xff\0\0\0\0\x7b\x1a\xd0\xff\0\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\xd0\xff\ | ||
| 543 | +\xff\xff\xb7\x01\0\0\x28\0\0\0\x7b\x1a\x40\xff\0\0\0\0\xbf\x81\0\0\0\0\0\0\xb7\ | ||
| 544 | +\x02\0\0\0\0\0\0\xb7\x04\0\0\x28\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\0\0\ | ||
| 545 | +\0\x67\0\0\0\x20\0\0\0\x77\0\0\0\x20\0\0\0\x55\0\x10\x01\0\0\0\0\x79\xa1\xe0\ | ||
| 546 | +\xff\0\0\0\0\x63\x1a\x64\xff\0\0\0\0\x77\x01\0\0\x20\0\0\0\x63\x1a\x68\xff\0\0\ | ||
| 547 | +\0\0\x79\xa1\xd8\xff\0\0\0\0\x63\x1a\x5c\xff\0\0\0\0\x77\x01\0\0\x20\0\0\0\x63\ | ||
| 548 | +\x1a\x60\xff\0\0\0\0\x79\xa1\xe8\xff\0\0\0\0\x63\x1a\x6c\xff\0\0\0\0\x77\x01\0\ | ||
| 549 | +\0\x20\0\0\0\x63\x1a\x70\xff\0\0\0\0\x79\xa1\xf0\xff\0\0\0\0\x63\x1a\x74\xff\0\ | ||
| 550 | +\0\0\0\x77\x01\0\0\x20\0\0\0\x63\x1a\x78\xff\0\0\0\0\x71\xa9\xd6\xff\0\0\0\0\ | ||
| 551 | +\x25\x09\xff\0\x3c\0\0\0\xb7\x01\0\0\x01\0\0\0\x6f\x91\0\0\0\0\0\0\x18\x02\0\0\ | ||
| 552 | +\x01\0\0\0\0\0\0\0\0\x18\0\x1c\x5f\x21\0\0\0\0\0\0\x55\x01\x01\0\0\0\0\0\x05\0\ | ||
| 553 | +\xf8\0\0\0\0\0\xb7\x01\0\0\0\0\0\0\x6b\x1a\xfe\xff\0\0\0\0\xb7\x01\0\0\x28\0\0\ | ||
| 554 | +\0\x7b\x1a\x40\xff\0\0\0\0\xbf\xa1\0\0\0\0\0\0\x07\x01\0\0\x8c\xff\xff\xff\x7b\ | ||
| 555 | +\x1a\x18\xff\0\0\0\0\xbf\xa1\0\0\0\0\0\0\x07\x01\0\0\x7c\xff\xff\xff\x7b\x1a\ | ||
| 556 | +\x10\xff\0\0\0\0\xb7\x01\0\0\0\0\0\0\x7b\x1a\x28\xff\0\0\0\0\x7b\x7a\x20\xff\0\ | ||
| 557 | +\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\xfe\xff\xff\xff\xbf\x81\0\0\0\0\0\0\x79\ | ||
| 558 | +\xa2\x40\xff\0\0\0\0\xb7\x04\0\0\x02\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\ | ||
| 559 | +\0\0\0\x67\0\0\0\x20\0\0\0\x77\0\0\0\x20\0\0\0\x15\0\x01\0\0\0\0\0\x05\0\x90\ | ||
| 560 | +\x01\0\0\0\0\xbf\x91\0\0\0\0\0\0\x15\x01\x23\0\x3c\0\0\0\x15\x01\x59\0\x2c\0\0\ | ||
| 561 | +\0\x55\x01\x5a\0\x2b\0\0\0\xb7\x01\0\0\0\0\0\0\x63\x1a\xf8\xff\0\0\0\0\xbf\xa3\ | ||
| 562 | +\0\0\0\0\0\0\x07\x03\0\0\xf8\xff\xff\xff\xbf\x81\0\0\0\0\0\0\x79\xa2\x40\xff\0\ | ||
| 563 | +\0\0\0\xb7\x04\0\0\x04\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\0\0\0\xbf\x01\ | ||
| 564 | +\0\0\0\0\0\0\x67\x01\0\0\x20\0\0\0\x77\x01\0\0\x20\0\0\0\x55\x01\x03\x01\0\0\0\ | ||
| 565 | +\0\x71\xa1\xfa\xff\0\0\0\0\x55\x01\x4b\0\x02\0\0\0\x71\xa1\xf9\xff\0\0\0\0\x55\ | ||
| 566 | +\x01\x49\0\x02\0\0\0\x71\xa1\xfb\xff\0\0\0\0\x55\x01\x47\0\x01\0\0\0\x79\xa2\ | ||
| 567 | +\x40\xff\0\0\0\0\x07\x02\0\0\x08\0\0\0\xbf\x81\0\0\0\0\0\0\x79\xa3\x18\xff\0\0\ | ||
| 568 | +\0\0\xb7\x04\0\0\x10\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\0\0\0\xbf\x01\0\ | ||
| 569 | +\0\0\0\0\0\x67\x01\0\0\x20\0\0\0\x77\x01\0\0\x20\0\0\0\x55\x01\xf2\0\0\0\0\0\ | ||
| 570 | +\xb7\x01\0\0\x01\0\0\0\x73\x1a\x55\xff\0\0\0\0\x05\0\x39\0\0\0\0\0\xb7\x01\0\0\ | ||
| 571 | +\0\0\0\0\x6b\x1a\xf8\xff\0\0\0\0\xb7\x09\0\0\x02\0\0\0\xb7\x07\0\0\x1e\0\0\0\ | ||
| 572 | +\x05\0\x0e\0\0\0\0\0\x79\xa2\x38\xff\0\0\0\0\x0f\x29\0\0\0\0\0\0\xbf\x92\0\0\0\ | ||
| 573 | +\0\0\0\x07\x02\0\0\x01\0\0\0\x71\xa3\xff\xff\0\0\0\0\x67\x03\0\0\x03\0\0\0\x2d\ | ||
| 574 | +\x23\x02\0\0\0\0\0\x79\xa7\x20\xff\0\0\0\0\x05\0\x2b\0\0\0\0\0\x07\x07\0\0\xff\ | ||
| 575 | +\xff\xff\xff\xbf\x72\0\0\0\0\0\0\x67\x02\0\0\x20\0\0\0\x77\x02\0\0\x20\0\0\0\ | ||
| 576 | +\x15\x02\xf9\xff\0\0\0\0\x7b\x9a\x38\xff\0\0\0\0\x79\xa1\x40\xff\0\0\0\0\x0f\ | ||
| 577 | +\x19\0\0\0\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\xf8\xff\xff\xff\xbf\x81\0\0\0\ | ||
| 578 | +\0\0\0\xbf\x92\0\0\0\0\0\0\xb7\x04\0\0\x02\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\ | ||
| 579 | +\0\x44\0\0\0\xbf\x01\0\0\0\0\0\0\x67\x01\0\0\x20\0\0\0\x77\x01\0\0\x20\0\0\0\ | ||
| 580 | +\x55\x01\x94\0\0\0\0\0\x71\xa2\xf8\xff\0\0\0\0\x55\x02\x0f\0\xc9\0\0\0\x07\x09\ | ||
| 581 | +\0\0\x02\0\0\0\xbf\x81\0\0\0\0\0\0\xbf\x92\0\0\0\0\0\0\x79\xa3\x10\xff\0\0\0\0\ | ||
| 582 | +\xb7\x04\0\0\x10\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\0\0\0\xbf\x01\0\0\0\ | ||
| 583 | +\0\0\0\x67\x01\0\0\x20\0\0\0\x77\x01\0\0\x20\0\0\0\x55\x01\x87\0\0\0\0\0\xb7\ | ||
| 584 | +\x01\0\0\x01\0\0\0\x73\x1a\x54\xff\0\0\0\0\x79\xa7\x20\xff\0\0\0\0\x05\0\x07\0\ | ||
| 585 | +\0\0\0\0\xb7\x09\0\0\x01\0\0\0\x15\x02\xd1\xff\0\0\0\0\x71\xa9\xf9\xff\0\0\0\0\ | ||
| 586 | +\x07\x09\0\0\x02\0\0\0\x05\0\xce\xff\0\0\0\0\xb7\x01\0\0\x01\0\0\0\x73\x1a\x56\ | ||
| 587 | +\xff\0\0\0\0\x71\xa1\xff\xff\0\0\0\0\x67\x01\0\0\x03\0\0\0\x79\xa2\x40\xff\0\0\ | ||
| 588 | +\0\0\x0f\x12\0\0\0\0\0\0\x07\x02\0\0\x08\0\0\0\x7b\x2a\x40\xff\0\0\0\0\x71\xa9\ | ||
| 589 | +\xfe\xff\0\0\0\0\x25\x09\x0e\0\x3c\0\0\0\xb7\x01\0\0\x01\0\0\0\x6f\x91\0\0\0\0\ | ||
| 590 | +\0\0\x18\x02\0\0\x01\0\0\0\0\0\0\0\0\x18\0\x1c\x5f\x21\0\0\0\0\0\0\x55\x01\x01\ | ||
| 591 | +\0\0\0\0\0\x05\0\x07\0\0\0\0\0\x79\xa1\x28\xff\0\0\0\0\x07\x01\0\0\x01\0\0\0\ | ||
| 592 | +\x7b\x1a\x28\xff\0\0\0\0\x67\x01\0\0\x20\0\0\0\x77\x01\0\0\x20\0\0\0\x55\x01\ | ||
| 593 | +\x82\xff\x0b\0\0\0\x05\0\x10\xff\0\0\0\0\x15\x09\xf8\xff\x87\0\0\0\x05\0\xfd\ | ||
| 594 | +\xff\0\0\0\0\x71\xa1\x51\xff\0\0\0\0\x79\xa0\x30\xff\0\0\0\0\x15\x01\x17\x01\0\ | ||
| 595 | +\0\0\0\x71\x62\x03\0\0\0\0\0\x67\x02\0\0\x08\0\0\0\x71\x61\x02\0\0\0\0\0\x4f\ | ||
| 596 | +\x12\0\0\0\0\0\0\x71\x63\x04\0\0\0\0\0\x71\x61\x05\0\0\0\0\0\x67\x01\0\0\x08\0\ | ||
| 597 | +\0\0\x4f\x31\0\0\0\0\0\0\x67\x01\0\0\x10\0\0\0\x4f\x21\0\0\0\0\0\0\x71\xa2\x53\ | ||
| 598 | +\xff\0\0\0\0\x15\x02\x3d\0\0\0\0\0\xbf\x12\0\0\0\0\0\0\x57\x02\0\0\x10\0\0\0\ | ||
| 599 | +\x15\x02\x3a\0\0\0\0\0\xbf\xa2\0\0\0\0\0\0\x07\x02\0\0\x5c\xff\xff\xff\x71\xa4\ | ||
| 600 | +\x54\xff\0\0\0\0\xbf\x23\0\0\0\0\0\0\x15\x04\x02\0\0\0\0\0\xbf\xa3\0\0\0\0\0\0\ | ||
| 601 | +\x07\x03\0\0\x7c\xff\xff\xff\x67\x01\0\0\x38\0\0\0\xc7\x01\0\0\x38\0\0\0\x65\ | ||
| 602 | +\x01\x01\0\xff\xff\xff\xff\xbf\x32\0\0\0\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\ | ||
| 603 | +\x6c\xff\xff\xff\x71\xa5\x55\xff\0\0\0\0\xbf\x34\0\0\0\0\0\0\x15\x05\x02\0\0\0\ | ||
| 604 | +\0\0\xbf\xa4\0\0\0\0\0\0\x07\x04\0\0\x8c\xff\xff\xff\x65\x01\x01\0\xff\xff\xff\ | ||
| 605 | +\xff\xbf\x43\0\0\0\0\0\0\x61\x21\x04\0\0\0\0\0\x67\x01\0\0\x20\0\0\0\x61\x24\0\ | ||
| 606 | +\0\0\0\0\0\x4f\x41\0\0\0\0\0\0\x7b\x1a\xa0\xff\0\0\0\0\x61\x21\x08\0\0\0\0\0\ | ||
| 607 | +\x61\x22\x0c\0\0\0\0\0\x67\x02\0\0\x20\0\0\0\x4f\x12\0\0\0\0\0\0\x7b\x2a\xa8\ | ||
| 608 | +\xff\0\0\0\0\x61\x31\0\0\0\0\0\0\x61\x32\x04\0\0\0\0\0\x61\x34\x08\0\0\0\0\0\ | ||
| 609 | +\x61\x33\x0c\0\0\0\0\0\x69\xa5\x5a\xff\0\0\0\0\x6b\x5a\xc2\xff\0\0\0\0\x69\xa5\ | ||
| 610 | +\x58\xff\0\0\0\0\x6b\x5a\xc0\xff\0\0\0\0\x67\x03\0\0\x20\0\0\0\x4f\x43\0\0\0\0\ | ||
| 611 | +\0\0\x7b\x3a\xb8\xff\0\0\0\0\x67\x02\0\0\x20\0\0\0\x4f\x12\0\0\0\0\0\0\x7b\x2a\ | ||
| 612 | +\xb0\xff\0\0\0\0\x05\0\x6b\0\0\0\0\0\x71\xa2\x52\xff\0\0\0\0\x15\x02\x04\0\0\0\ | ||
| 613 | +\0\0\xbf\x12\0\0\0\0\0\0\x57\x02\0\0\x04\0\0\0\x15\x02\x01\0\0\0\0\0\x05\0\xf7\ | ||
| 614 | +\xfe\0\0\0\0\x57\x01\0\0\x01\0\0\0\x15\x01\xd3\0\0\0\0\0\x61\xa1\x5c\xff\0\0\0\ | ||
| 615 | +\0\x63\x1a\xa0\xff\0\0\0\0\x61\xa1\x60\xff\0\0\0\0\x63\x1a\xa4\xff\0\0\0\0\x05\ | ||
| 616 | +\0\x5e\0\0\0\0\0\x71\xa2\x52\xff\0\0\0\0\x15\x02\x1e\0\0\0\0\0\xbf\x12\0\0\0\0\ | ||
| 617 | +\0\0\x57\x02\0\0\x20\0\0\0\x15\x02\x1b\0\0\0\0\0\xbf\xa2\0\0\0\0\0\0\x07\x02\0\ | ||
| 618 | +\0\x5c\xff\xff\xff\x71\xa4\x54\xff\0\0\0\0\xbf\x23\0\0\0\0\0\0\x15\x04\x02\0\0\ | ||
| 619 | +\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\x7c\xff\xff\xff\x57\x01\0\0\0\x01\0\0\ | ||
| 620 | +\x15\x01\x01\0\0\0\0\0\xbf\x32\0\0\0\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\x03\0\0\x6c\ | ||
| 621 | +\xff\xff\xff\x71\xa5\x55\xff\0\0\0\0\xbf\x34\0\0\0\0\0\0\x15\x05\x02\0\0\0\0\0\ | ||
| 622 | +\xbf\xa4\0\0\0\0\0\0\x07\x04\0\0\x8c\xff\xff\xff\x15\x01\xc3\xff\0\0\0\0\x05\0\ | ||
| 623 | +\xc1\xff\0\0\0\0\xb7\x09\0\0\x3c\0\0\0\x79\xa7\x20\xff\0\0\0\0\x67\0\0\0\x20\0\ | ||
| 624 | +\0\0\x77\0\0\0\x20\0\0\0\x15\0\xa5\xfe\0\0\0\0\x05\0\xb0\0\0\0\0\0\x15\x09\x07\ | ||
| 625 | +\xff\x87\0\0\0\x05\0\xa2\xfe\0\0\0\0\xbf\x12\0\0\0\0\0\0\x57\x02\0\0\x08\0\0\0\ | ||
| 626 | +\x15\x02\xab\0\0\0\0\0\xbf\xa2\0\0\0\0\0\0\x07\x02\0\0\x5c\xff\xff\xff\x71\xa4\ | ||
| 627 | +\x54\xff\0\0\0\0\xbf\x23\0\0\0\0\0\0\x15\x04\x02\0\0\0\0\0\xbf\xa3\0\0\0\0\0\0\ | ||
| 628 | +\x07\x03\0\0\x7c\xff\xff\xff\x57\x01\0\0\x40\0\0\0\x15\x01\x01\0\0\0\0\0\xbf\ | ||
| 629 | +\x32\0\0\0\0\0\0\x61\x23\x04\0\0\0\0\0\x67\x03\0\0\x20\0\0\0\x61\x24\0\0\0\0\0\ | ||
| 630 | +\0\x4f\x43\0\0\0\0\0\0\x7b\x3a\xa0\xff\0\0\0\0\x61\x23\x08\0\0\0\0\0\x61\x22\ | ||
| 631 | +\x0c\0\0\0\0\0\x67\x02\0\0\x20\0\0\0\x4f\x32\0\0\0\0\0\0\x7b\x2a\xa8\xff\0\0\0\ | ||
| 632 | +\0\x15\x01\x1c\0\0\0\0\0\x71\xa1\x55\xff\0\0\0\0\x15\x01\x1a\0\0\0\0\0\x61\xa1\ | ||
| 633 | +\x98\xff\0\0\0\0\x67\x01\0\0\x20\0\0\0\x61\xa2\x94\xff\0\0\0\0\x4f\x21\0\0\0\0\ | ||
| 634 | +\0\0\x7b\x1a\xb8\xff\0\0\0\0\x61\xa1\x90\xff\0\0\0\0\x67\x01\0\0\x20\0\0\0\x61\ | ||
| 635 | +\xa2\x8c\xff\0\0\0\0\x05\0\x19\0\0\0\0\0\xb7\x01\0\0\x01\0\0\0\x73\x1a\x52\xff\ | ||
| 636 | +\0\0\0\0\xb7\x01\0\0\0\0\0\0\x7b\x1a\xd0\xff\0\0\0\0\xbf\xa3\0\0\0\0\0\0\x07\ | ||
| 637 | +\x03\0\0\xd0\xff\xff\xff\xbf\x81\0\0\0\0\0\0\x79\xa2\x40\xff\0\0\0\0\xb7\x04\0\ | ||
| 638 | +\0\x08\0\0\0\xb7\x05\0\0\x01\0\0\0\x85\0\0\0\x44\0\0\0\x67\0\0\0\x20\0\0\0\x77\ | ||
| 639 | +\0\0\0\x20\0\0\0\x55\0\x7d\0\0\0\0\0\x05\0\x88\xfe\0\0\0\0\xb7\x09\0\0\x2b\0\0\ | ||
| 640 | +\0\x05\0\xc6\xff\0\0\0\0\x61\xa1\x78\xff\0\0\0\0\x67\x01\0\0\x20\0\0\0\x61\xa2\ | ||
| 641 | +\x74\xff\0\0\0\0\x4f\x21\0\0\0\0\0\0\x7b\x1a\xb8\xff\0\0\0\0\x61\xa1\x70\xff\0\ | ||
| 642 | +\0\0\0\x67\x01\0\0\x20\0\0\0\x61\xa2\x6c\xff\0\0\0\0\x4f\x21\0\0\0\0\0\0\x7b\ | ||
| 643 | +\x1a\xb0\xff\0\0\0\0\xb7\x01\0\0\0\0\0\0\x07\x07\0\0\x04\0\0\0\x61\x03\0\0\0\0\ | ||
| 644 | +\0\0\xb7\x05\0\0\0\0\0\0\x05\0\x4e\0\0\0\0\0\xaf\x52\0\0\0\0\0\0\xbf\x75\0\0\0\ | ||
| 645 | +\0\0\0\x0f\x15\0\0\0\0\0\0\x71\x55\0\0\0\0\0\0\x67\x03\0\0\x01\0\0\0\xbf\x50\0\ | ||
| 646 | +\0\0\0\0\0\x77\0\0\0\x07\0\0\0\x4f\x03\0\0\0\0\0\0\xbf\x40\0\0\0\0\0\0\x67\0\0\ | ||
| 647 | +\0\x39\0\0\0\xc7\0\0\0\x3f\0\0\0\x5f\x30\0\0\0\0\0\0\xaf\x02\0\0\0\0\0\0\xbf\ | ||
| 648 | +\x50\0\0\0\0\0\0\x77\0\0\0\x06\0\0\0\x57\0\0\0\x01\0\0\0\x67\x03\0\0\x01\0\0\0\ | ||
| 649 | +\x4f\x03\0\0\0\0\0\0\xbf\x40\0\0\0\0\0\0\x67\0\0\0\x3a\0\0\0\xc7\0\0\0\x3f\0\0\ | ||
| 650 | +\0\x5f\x30\0\0\0\0\0\0\xaf\x02\0\0\0\0\0\0\x67\x03\0\0\x01\0\0\0\xbf\x50\0\0\0\ | ||
| 651 | +\0\0\0\x77\0\0\0\x05\0\0\0\x57\0\0\0\x01\0\0\0\x4f\x03\0\0\0\0\0\0\xbf\x40\0\0\ | ||
| 652 | +\0\0\0\0\x67\0\0\0\x3b\0\0\0\xc7\0\0\0\x3f\0\0\0\x5f\x30\0\0\0\0\0\0\xaf\x02\0\ | ||
| 653 | +\0\0\0\0\0\x67\x03\0\0\x01\0\0\0\xbf\x50\0\0\0\0\0\0\x77\0\0\0\x04\0\0\0\x57\0\ | ||
| 654 | +\0\0\x01\0\0\0\x4f\x03\0\0\0\0\0\0\xbf\x40\0\0\0\0\0\0\x67\0\0\0\x3c\0\0\0\xc7\ | ||
| 655 | +\0\0\0\x3f\0\0\0\x5f\x30\0\0\0\0\0\0\xaf\x02\0\0\0\0\0\0\xbf\x50\0\0\0\0\0\0\ | ||
| 656 | +\x77\0\0\0\x03\0\0\0\x57\0\0\0\x01\0\0\0\x67\x03\0\0\x01\0\0\0\x4f\x03\0\0\0\0\ | ||
| 657 | +\0\0\xbf\x40\0\0\0\0\0\0\x67\0\0\0\x3d\0\0\0\xc7\0\0\0\x3f\0\0\0\x5f\x30\0\0\0\ | ||
| 658 | +\0\0\0\xaf\x02\0\0\0\0\0\0\xbf\x50\0\0\0\0\0\0\x77\0\0\0\x02\0\0\0\x57\0\0\0\ | ||
| 659 | +\x01\0\0\0\x67\x03\0\0\x01\0\0\0\x4f\x03\0\0\0\0\0\0\xbf\x40\0\0\0\0\0\0\x67\0\ | ||
| 660 | +\0\0\x3e\0\0\0\xc7\0\0\0\x3f\0\0\0\x5f\x30\0\0\0\0\0\0\xaf\x02\0\0\0\0\0\0\xbf\ | ||
| 661 | +\x50\0\0\0\0\0\0\x77\0\0\0\x01\0\0\0\x57\0\0\0\x01\0\0\0\x67\x03\0\0\x01\0\0\0\ | ||
| 662 | +\x4f\x03\0\0\0\0\0\0\x57\x04\0\0\x01\0\0\0\x87\x04\0\0\0\0\0\0\x5f\x34\0\0\0\0\ | ||
| 663 | +\0\0\xaf\x42\0\0\0\0\0\0\x57\x05\0\0\x01\0\0\0\x67\x03\0\0\x01\0\0\0\x4f\x53\0\ | ||
| 664 | +\0\0\0\0\0\x07\x01\0\0\x01\0\0\0\xbf\x25\0\0\0\0\0\0\x15\x01\x0b\0\x24\0\0\0\ | ||
| 665 | +\xbf\xa2\0\0\0\0\0\0\x07\x02\0\0\xa0\xff\xff\xff\x0f\x12\0\0\0\0\0\0\x71\x24\0\ | ||
| 666 | +\0\0\0\0\0\xbf\x40\0\0\0\0\0\0\x67\0\0\0\x38\0\0\0\xc7\0\0\0\x38\0\0\0\xb7\x02\ | ||
| 667 | +\0\0\0\0\0\0\x65\0\xa9\xff\xff\xff\xff\xff\xbf\x32\0\0\0\0\0\0\x05\0\xa7\xff\0\ | ||
| 668 | +\0\0\0\xbf\x21\0\0\0\0\0\0\x67\x01\0\0\x20\0\0\0\x77\x01\0\0\x20\0\0\0\x15\x01\ | ||
| 669 | +\x0e\0\0\0\0\0\x71\x63\x06\0\0\0\0\0\x71\x64\x07\0\0\0\0\0\x67\x04\0\0\x08\0\0\ | ||
| 670 | +\0\x4f\x34\0\0\0\0\0\0\x3f\x41\0\0\0\0\0\0\x2f\x41\0\0\0\0\0\0\x1f\x12\0\0\0\0\ | ||
| 671 | +\0\0\x63\x2a\x50\xff\0\0\0\0\xbf\xa2\0\0\0\0\0\0\x07\x02\0\0\x50\xff\xff\xff\ | ||
| 672 | +\x18\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x85\0\0\0\x01\0\0\0\x55\0\x05\0\0\0\0\0\ | ||
| 673 | +\x71\x61\x08\0\0\0\0\0\x71\x60\x09\0\0\0\0\0\x67\0\0\0\x08\0\0\0\x4f\x10\0\0\0\ | ||
| 674 | +\0\0\0\x95\0\0\0\0\0\0\0\x69\0\0\0\0\0\0\0\x05\0\xfd\xff\0\0\0\0\x02\0\0\0\x04\ | ||
| 675 | +\0\0\0\x0a\0\0\0\x01\0\0\0\0\0\0\0\x02\0\0\0\x04\0\0\0\x28\0\0\0\x01\0\0\0\0\0\ | ||
| 676 | +\0\0\x02\0\0\0\x04\0\0\0\x02\0\0\0\x80\0\0\0\0\0\0\0\x47\x50\x4c\x20\x76\x32\0\ | ||
| 677 | +\0\0\0\0\0\x10\0\0\0\0\0\0\0\x01\x7a\x52\0\x08\x7c\x0b\x01\x0c\0\0\0\x18\0\0\0\ | ||
| 678 | +\x18\0\0\0\0\0\0\0\0\0\0\0\xd8\x13\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 679 | +\0\0\0\0\0\0\0\0\0\0\0\0\xa0\0\0\0\x04\0\xf1\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 680 | +\0\x60\x02\0\0\0\0\x03\0\x20\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x3f\x02\0\0\0\0\ | ||
| 681 | +\x03\0\xd0\x0f\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xed\x01\0\0\0\0\x03\0\x10\x10\0\0\0\ | ||
| 682 | +\0\0\0\0\0\0\0\0\0\0\0\xd4\x01\0\0\0\0\x03\0\x20\x10\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 683 | +\0\xa3\x01\0\0\0\0\x03\0\xb8\x12\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x63\x01\0\0\0\0\ | ||
| 684 | +\x03\0\x48\x10\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x2a\x01\0\0\0\0\x03\0\x10\x13\0\0\0\ | ||
| 685 | +\0\0\0\0\0\0\0\0\0\0\0\xe1\0\0\0\0\0\x03\0\xa0\x13\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 686 | +\x2e\x02\0\0\0\0\x03\0\x28\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x68\x02\0\0\0\0\x03\ | ||
| 687 | +\0\xc0\x13\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x36\x02\0\0\0\0\x03\0\xc8\x13\0\0\0\0\0\ | ||
| 688 | +\0\0\0\0\0\0\0\0\0\x22\x01\0\0\0\0\x03\0\xe8\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 689 | +\x02\x01\0\0\0\0\x03\0\x40\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xd9\0\0\0\0\0\x03\0\ | ||
| 690 | +\xf8\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x26\x02\0\0\0\0\x03\0\x20\x0e\0\0\0\0\0\0\ | ||
| 691 | +\0\0\0\0\0\0\0\0\xcc\x01\0\0\0\0\x03\0\x60\x06\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x9b\ | ||
| 692 | +\x01\0\0\0\0\x03\0\xc8\x06\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x5b\x01\0\0\0\0\x03\0\ | ||
| 693 | +\x20\x07\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x7c\x01\0\0\0\0\x03\0\x48\x08\0\0\0\0\0\0\ | ||
| 694 | +\0\0\0\0\0\0\0\0\x53\x01\0\0\0\0\x03\0\xb8\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x1a\ | ||
| 695 | +\x01\0\0\0\0\x03\0\xe0\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x84\x01\0\0\0\0\x03\0\ | ||
| 696 | +\xb8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x1e\x02\0\0\0\0\x03\0\xd8\x09\0\0\0\0\0\0\0\ | ||
| 697 | +\0\0\0\0\0\0\0\xc4\x01\0\0\0\0\x03\0\x70\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\ | ||
| 698 | +\x01\0\0\0\0\x03\0\xa8\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x74\x01\0\0\0\0\x03\0\ | ||
| 699 | +\xf0\x0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x4b\x01\0\0\0\0\x03\0\0\x0a\0\0\0\0\0\0\0\ | ||
| 700 | +\0\0\0\0\0\0\0\x12\x01\0\0\0\0\x03\0\x10\x0a\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xfa\0\ | ||
| 701 | +\0\0\0\0\x03\0\xc0\x0a\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x58\x02\0\0\0\0\x03\0\x88\ | ||
| 702 | +\x0a\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x02\0\0\0\0\x03\0\xb8\x0a\0\0\0\0\0\0\0\0\ | ||
| 703 | +\0\0\0\0\0\0\xe5\x01\0\0\0\0\x03\0\xc0\x0f\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xbc\x01\ | ||
| 704 | +\0\0\0\0\x03\0\0\x0e\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x8b\x01\0\0\0\0\x03\0\x18\x0e\ | ||
| 705 | +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xd1\0\0\0\0\0\x03\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 706 | +\0\0\x50\x02\0\0\0\0\x03\0\x20\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x0e\x02\0\0\0\0\ | ||
| 707 | +\x03\0\x48\x0f\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x6c\x01\0\0\0\0\x03\0\xb0\x04\0\0\0\ | ||
| 708 | +\0\0\0\0\0\0\0\0\0\0\0\x43\x01\0\0\0\0\x03\0\xc8\x0c\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 709 | +\0\xc9\0\0\0\0\0\x03\0\xf8\x0c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x06\x02\0\0\0\0\x03\ | ||
| 710 | +\0\xd0\x0a\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x3b\x01\0\0\0\0\x03\0\x98\x0b\0\0\0\0\0\ | ||
| 711 | +\0\0\0\0\0\0\0\0\0\xf2\0\0\0\0\0\x03\0\xb8\x0b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x48\ | ||
| 712 | +\x02\0\0\0\0\x03\0\xf0\x0b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xfe\x01\0\0\0\0\x03\0\ | ||
| 713 | +\xf8\x0b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xdd\x01\0\0\0\0\x03\0\0\x0c\0\0\0\0\0\0\0\ | ||
| 714 | +\0\0\0\0\0\0\0\xb4\x01\0\0\0\0\x03\0\x30\x0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x0a\ | ||
| 715 | +\x01\0\0\0\0\x03\0\x90\x0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xc1\0\0\0\0\0\x03\0\xa8\ | ||
| 716 | +\x0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xba\0\0\0\0\0\x03\0\xd0\x01\0\0\0\0\0\0\0\0\0\ | ||
| 717 | +\0\0\0\0\0\xf6\x01\0\0\0\0\x03\0\xe0\x0d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xac\x01\0\ | ||
| 718 | +\0\0\0\x03\0\x30\x0e\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x33\x01\0\0\0\0\x03\0\x80\x0e\ | ||
| 719 | +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xea\0\0\0\0\0\x03\0\x98\x0e\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 720 | +\0\0\0\0\0\0\0\x03\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x6b\0\0\0\x11\0\x06\ | ||
| 721 | +\0\0\0\0\0\0\0\0\0\x07\0\0\0\0\0\0\0\x25\0\0\0\x11\0\x05\0\0\0\0\0\0\0\0\0\x14\ | ||
| 722 | +\0\0\0\0\0\0\0\x82\0\0\0\x11\0\x05\0\x28\0\0\0\0\0\0\0\x14\0\0\0\0\0\0\0\x01\0\ | ||
| 723 | +\0\0\x11\0\x05\0\x14\0\0\0\0\0\0\0\x14\0\0\0\0\0\0\0\x40\0\0\0\x12\0\x03\0\0\0\ | ||
| 724 | +\0\0\0\0\0\0\xd8\x13\0\0\0\0\0\0\x28\0\0\0\0\0\0\0\x01\0\0\0\x3a\0\0\0\x50\0\0\ | ||
| 725 | +\0\0\0\0\0\x01\0\0\0\x3c\0\0\0\x80\x13\0\0\0\0\0\0\x01\0\0\0\x3b\0\0\0\x1c\0\0\ | ||
| 726 | +\0\0\0\0\0\x01\0\0\0\x38\0\0\0\0\x74\x61\x70\x5f\x72\x73\x73\x5f\x6d\x61\x70\ | ||
| 727 | +\x5f\x74\x6f\x65\x70\x6c\x69\x74\x7a\x5f\x6b\x65\x79\0\x2e\x74\x65\x78\x74\0\ | ||
| 728 | +\x6d\x61\x70\x73\0\x74\x61\x70\x5f\x72\x73\x73\x5f\x6d\x61\x70\x5f\x63\x6f\x6e\ | ||
| 729 | +\x66\x69\x67\x75\x72\x61\x74\x69\x6f\x6e\x73\0\x74\x75\x6e\x5f\x72\x73\x73\x5f\ | ||
| 730 | +\x73\x74\x65\x65\x72\x69\x6e\x67\x5f\x70\x72\x6f\x67\0\x2e\x72\x65\x6c\x74\x75\ | ||
| 731 | +\x6e\x5f\x72\x73\x73\x5f\x73\x74\x65\x65\x72\x69\x6e\x67\0\x5f\x6c\x69\x63\x65\ | ||
| 732 | +\x6e\x73\x65\0\x2e\x72\x65\x6c\x2e\x65\x68\x5f\x66\x72\x61\x6d\x65\0\x74\x61\ | ||
| 733 | +\x70\x5f\x72\x73\x73\x5f\x6d\x61\x70\x5f\x69\x6e\x64\x69\x72\x65\x63\x74\x69\ | ||
| 734 | +\x6f\x6e\x5f\x74\x61\x62\x6c\x65\0\x72\x73\x73\x2e\x62\x70\x66\x2e\x63\0\x2e\ | ||
| 735 | +\x73\x74\x72\x74\x61\x62\0\x2e\x73\x79\x6d\x74\x61\x62\0\x4c\x42\x42\x30\x5f\ | ||
| 736 | +\x39\0\x4c\x42\x42\x30\x5f\x38\x39\0\x4c\x42\x42\x30\x5f\x36\x39\0\x4c\x42\x42\ | ||
| 737 | +\x30\x5f\x35\x39\0\x4c\x42\x42\x30\x5f\x31\x39\0\x4c\x42\x42\x30\x5f\x31\x30\ | ||
| 738 | +\x39\0\x4c\x42\x42\x30\x5f\x39\x38\0\x4c\x42\x42\x30\x5f\x37\x38\0\x4c\x42\x42\ | ||
| 739 | +\x30\x5f\x34\x38\0\x4c\x42\x42\x30\x5f\x31\x38\0\x4c\x42\x42\x30\x5f\x38\x37\0\ | ||
| 740 | +\x4c\x42\x42\x30\x5f\x34\x37\0\x4c\x42\x42\x30\x5f\x33\x37\0\x4c\x42\x42\x30\ | ||
| 741 | +\x5f\x31\x37\0\x4c\x42\x42\x30\x5f\x31\x30\x37\0\x4c\x42\x42\x30\x5f\x39\x36\0\ | ||
| 742 | +\x4c\x42\x42\x30\x5f\x37\x36\0\x4c\x42\x42\x30\x5f\x36\x36\0\x4c\x42\x42\x30\ | ||
| 743 | +\x5f\x34\x36\0\x4c\x42\x42\x30\x5f\x33\x36\0\x4c\x42\x42\x30\x5f\x32\x36\0\x4c\ | ||
| 744 | +\x42\x42\x30\x5f\x31\x30\x36\0\x4c\x42\x42\x30\x5f\x36\x35\0\x4c\x42\x42\x30\ | ||
| 745 | +\x5f\x34\x35\0\x4c\x42\x42\x30\x5f\x33\x35\0\x4c\x42\x42\x30\x5f\x34\0\x4c\x42\ | ||
| 746 | +\x42\x30\x5f\x35\x34\0\x4c\x42\x42\x30\x5f\x34\x34\0\x4c\x42\x42\x30\x5f\x32\ | ||
| 747 | +\x34\0\x4c\x42\x42\x30\x5f\x31\x30\x34\0\x4c\x42\x42\x30\x5f\x39\x33\0\x4c\x42\ | ||
| 748 | +\x42\x30\x5f\x38\x33\0\x4c\x42\x42\x30\x5f\x35\x33\0\x4c\x42\x42\x30\x5f\x34\ | ||
| 749 | +\x33\0\x4c\x42\x42\x30\x5f\x32\x33\0\x4c\x42\x42\x30\x5f\x31\x30\x33\0\x4c\x42\ | ||
| 750 | +\x42\x30\x5f\x38\x32\0\x4c\x42\x42\x30\x5f\x35\x32\0\x4c\x42\x42\x30\x5f\x31\ | ||
| 751 | +\x30\x32\0\x4c\x42\x42\x30\x5f\x39\x31\0\x4c\x42\x42\x30\x5f\x38\x31\0\x4c\x42\ | ||
| 752 | +\x42\x30\x5f\x37\x31\0\x4c\x42\x42\x30\x5f\x36\x31\0\x4c\x42\x42\x30\x5f\x35\ | ||
| 753 | +\x31\0\x4c\x42\x42\x30\x5f\x34\x31\0\x4c\x42\x42\x30\x5f\x32\x31\0\x4c\x42\x42\ | ||
| 754 | +\x30\x5f\x31\x31\0\x4c\x42\x42\x30\x5f\x31\x31\x31\0\x4c\x42\x42\x30\x5f\x31\ | ||
| 755 | +\x30\x31\0\x4c\x42\x42\x30\x5f\x38\x30\0\x4c\x42\x42\x30\x5f\x36\x30\0\x4c\x42\ | ||
| 756 | +\x42\x30\x5f\x35\x30\0\x4c\x42\x42\x30\x5f\x31\x30\0\x4c\x42\x42\x30\x5f\x31\ | ||
| 757 | +\x31\x30\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 758 | +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xaa\ | ||
| 759 | +\0\0\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xa0\x1a\0\0\0\0\0\0\x71\x02\0\ | ||
| 760 | +\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x1a\0\0\0\x01\0\0\ | ||
| 761 | +\0\x06\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x40\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 762 | +\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x5a\0\0\0\x01\0\0\0\x06\0\0\0\0\0\0\ | ||
| 763 | +\0\0\0\0\0\0\0\0\0\x40\0\0\0\0\0\0\0\xd8\x13\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x08\0\ | ||
| 764 | +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x56\0\0\0\x09\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 765 | +\0\x60\x1a\0\0\0\0\0\0\x30\0\0\0\0\0\0\0\x09\0\0\0\x03\0\0\0\x08\0\0\0\0\0\0\0\ | ||
| 766 | +\x10\0\0\0\0\0\0\0\x20\0\0\0\x01\0\0\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x18\ | ||
| 767 | +\x14\0\0\0\0\0\0\x3c\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\ | ||
| 768 | +\0\0\0\x6c\0\0\0\x01\0\0\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x54\x14\0\0\0\0\0\ | ||
| 769 | +\0\x07\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x78\0\0\ | ||
| 770 | +\0\x01\0\0\0\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x60\x14\0\0\0\0\0\0\x30\0\0\0\0\ | ||
| 771 | +\0\0\0\0\0\0\0\0\0\0\0\x08\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x74\0\0\0\x09\0\0\0\0\ | ||
| 772 | +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x1a\0\0\0\0\0\0\x10\0\0\0\0\0\0\0\x09\0\0\0\ | ||
| 773 | +\x07\0\0\0\x08\0\0\0\0\0\0\0\x10\0\0\0\0\0\0\0\xb2\0\0\0\x02\0\0\0\0\0\0\0\0\0\ | ||
| 774 | +\0\0\0\0\0\0\0\0\0\0\x90\x14\0\0\0\0\0\0\xd0\x05\0\0\0\0\0\0\x01\0\0\0\x39\0\0\ | ||
| 775 | +\0\x08\0\0\0\0\0\0\0\x18\0\0\0\0\0\0\0"; | ||
| 776 | + | ||
| 777 | + return 0; | ||
| 778 | +err: | ||
| 779 | + bpf_object__destroy_skeleton(s); | ||
| 780 | + return -1; | ||
| 781 | +} | ||
| 782 | + | ||
| 783 | +#endif /* __RSS_BPF_SKEL_H__ */ | ||
| 784 | diff --git a/ebpf/trace-events b/ebpf/trace-events | ||
| 785 | new file mode 100644 | ||
| 786 | index XXXXXXX..XXXXXXX | ||
| 787 | --- /dev/null | ||
| 788 | +++ b/ebpf/trace-events | ||
| 789 | @@ -XXX,XX +XXX,XX @@ | ||
| 790 | +# See docs/devel/tracing.txt for syntax documentation. | ||
| 791 | + | ||
| 792 | +# ebpf-rss.c | ||
| 793 | +ebpf_error(const char *s1, const char *s2) "error in %s: %s" | ||
| 794 | diff --git a/ebpf/trace.h b/ebpf/trace.h | ||
| 795 | new file mode 100644 | ||
| 796 | index XXXXXXX..XXXXXXX | ||
| 797 | --- /dev/null | ||
| 798 | +++ b/ebpf/trace.h | ||
| 799 | @@ -0,0 +1 @@ | ||
| 800 | +#include "trace/trace-ebpf.h" | ||
| 801 | diff --git a/meson.build b/meson.build | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | 802 | index XXXXXXX..XXXXXXX 100644 |
| 19 | --- a/include/net/slirp.h | 803 | --- a/meson.build |
| 20 | +++ b/include/net/slirp.h | 804 | +++ b/meson.build |
| 21 | @@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict); | 805 | @@ -XXX,XX +XXX,XX @@ if not get_option('fuse_lseek').disabled() |
| 22 | 806 | endif | |
| 23 | int net_slirp_redir(const char *redir_str); | 807 | endif |
| 24 | 808 | ||
| 25 | -int net_slirp_parse_legacy(QemuOptsList *opts_list, const char *optarg, int *ret); | 809 | +# libbpf |
| 26 | - | 810 | +libbpf = dependency('libbpf', required: get_option('bpf'), method: 'pkg-config') |
| 27 | int net_slirp_smb(const char *exported_dir); | 811 | +if libbpf.found() and not cc.links(''' |
| 28 | 812 | + #include <bpf/libbpf.h> | |
| 29 | void hmp_info_usernet(Monitor *mon, const QDict *qdict); | 813 | + int main(void) |
| 30 | diff --git a/net/net.c b/net/net.c | 814 | + { |
| 815 | + bpf_object__destroy_skeleton(NULL); | ||
| 816 | + return 0; | ||
| 817 | + }''', dependencies: libbpf) | ||
| 818 | + libbpf = not_found | ||
| 819 | + if get_option('bpf').enabled() | ||
| 820 | + error('libbpf skeleton test failed') | ||
| 821 | + else | ||
| 822 | + warning('libbpf skeleton test failed, disabling') | ||
| 823 | + endif | ||
| 824 | +endif | ||
| 825 | + | ||
| 826 | if get_option('cfi') | ||
| 827 | cfi_flags=[] | ||
| 828 | # Check for dependency on LTO | ||
| 829 | @@ -XXX,XX +XXX,XX @@ endif | ||
| 830 | config_host_data.set('CONFIG_GTK', gtk.found()) | ||
| 831 | config_host_data.set('CONFIG_LIBATTR', have_old_libattr) | ||
| 832 | config_host_data.set('CONFIG_LIBCAP_NG', libcap_ng.found()) | ||
| 833 | +config_host_data.set('CONFIG_EBPF', libbpf.found()) | ||
| 834 | config_host_data.set('CONFIG_LIBISCSI', libiscsi.found()) | ||
| 835 | config_host_data.set('CONFIG_LIBNFS', libnfs.found()) | ||
| 836 | config_host_data.set('CONFIG_RBD', rbd.found()) | ||
| 837 | @@ -XXX,XX +XXX,XX @@ if have_system | ||
| 838 | 'backends', | ||
| 839 | 'backends/tpm', | ||
| 840 | 'chardev', | ||
| 841 | + 'ebpf', | ||
| 842 | 'hw/9pfs', | ||
| 843 | 'hw/acpi', | ||
| 844 | 'hw/adc', | ||
| 845 | @@ -XXX,XX +XXX,XX @@ subdir('accel') | ||
| 846 | subdir('plugins') | ||
| 847 | subdir('bsd-user') | ||
| 848 | subdir('linux-user') | ||
| 849 | +subdir('ebpf') | ||
| 850 | + | ||
| 851 | +common_ss.add(libbpf) | ||
| 852 | |||
| 853 | bsd_user_ss.add(files('gdbstub.c')) | ||
| 854 | specific_ss.add_all(when: 'CONFIG_BSD_USER', if_true: bsd_user_ss) | ||
| 855 | @@ -XXX,XX +XXX,XX @@ summary_info += {'RDMA support': config_host.has_key('CONFIG_RDMA')} | ||
| 856 | summary_info += {'PVRDMA support': config_host.has_key('CONFIG_PVRDMA')} | ||
| 857 | summary_info += {'fdt support': fdt_opt == 'disabled' ? false : fdt_opt} | ||
| 858 | summary_info += {'libcap-ng support': libcap_ng.found()} | ||
| 859 | +summary_info += {'bpf support': libbpf.found()} | ||
| 860 | # TODO: add back protocol and server version | ||
| 861 | summary_info += {'spice support': config_host.has_key('CONFIG_SPICE')} | ||
| 862 | summary_info += {'rbd support': rbd.found()} | ||
| 863 | diff --git a/meson_options.txt b/meson_options.txt | ||
| 31 | index XXXXXXX..XXXXXXX 100644 | 864 | index XXXXXXX..XXXXXXX 100644 |
| 32 | --- a/net/net.c | 865 | --- a/meson_options.txt |
| 33 | +++ b/net/net.c | 866 | +++ b/meson_options.txt |
| 34 | @@ -XXX,XX +XXX,XX @@ int net_init_clients(void) | 867 | @@ -XXX,XX +XXX,XX @@ option('bzip2', type : 'feature', value : 'auto', |
| 35 | 868 | description: 'bzip2 support for DMG images') | |
| 36 | int net_client_parse(QemuOptsList *opts_list, const char *optarg) | 869 | option('cap_ng', type : 'feature', value : 'auto', |
| 37 | { | 870 | description: 'cap_ng support') |
| 38 | -#if defined(CONFIG_SLIRP) | 871 | +option('bpf', type : 'feature', value : 'auto', |
| 39 | - int ret; | 872 | + description: 'eBPF support') |
| 40 | - if (net_slirp_parse_legacy(opts_list, optarg, &ret)) { | 873 | option('cocoa', type : 'feature', value : 'auto', |
| 41 | - return ret; | 874 | description: 'Cocoa user interface (macOS only)') |
| 42 | - } | 875 | option('curl', type : 'feature', value : 'auto', |
| 43 | -#endif | ||
| 44 | - | ||
| 45 | if (!qemu_opts_parse_noisily(opts_list, optarg, true)) { | ||
| 46 | return -1; | ||
| 47 | } | ||
| 48 | diff --git a/net/slirp.c b/net/slirp.c | ||
| 49 | index XXXXXXX..XXXXXXX 100644 | ||
| 50 | --- a/net/slirp.c | ||
| 51 | +++ b/net/slirp.c | ||
| 52 | @@ -XXX,XX +XXX,XX @@ int net_init_slirp(const Netdev *netdev, const char *name, | ||
| 53 | |||
| 54 | return ret; | ||
| 55 | } | ||
| 56 | - | ||
| 57 | -int net_slirp_parse_legacy(QemuOptsList *opts_list, const char *optarg, int *ret) | ||
| 58 | -{ | ||
| 59 | - if (strcmp(opts_list->name, "net") != 0 || | ||
| 60 | - strncmp(optarg, "channel,", strlen("channel,")) != 0) { | ||
| 61 | - return 0; | ||
| 62 | - } | ||
| 63 | - | ||
| 64 | - error_report("The '-net channel' option is deprecated. " | ||
| 65 | - "Please use '-netdev user,guestfwd=...' instead."); | ||
| 66 | - | ||
| 67 | - /* handle legacy -net channel,port:chr */ | ||
| 68 | - optarg += strlen("channel,"); | ||
| 69 | - | ||
| 70 | - if (QTAILQ_EMPTY(&slirp_stacks)) { | ||
| 71 | - struct slirp_config_str *config; | ||
| 72 | - | ||
| 73 | - config = g_malloc(sizeof(*config)); | ||
| 74 | - pstrcpy(config->str, sizeof(config->str), optarg); | ||
| 75 | - config->flags = SLIRP_CFG_LEGACY; | ||
| 76 | - config->next = slirp_configs; | ||
| 77 | - slirp_configs = config; | ||
| 78 | - *ret = 0; | ||
| 79 | - } else { | ||
| 80 | - Error *err = NULL; | ||
| 81 | - *ret = slirp_guestfwd(QTAILQ_FIRST(&slirp_stacks), optarg, 1, &err); | ||
| 82 | - if (*ret < 0) { | ||
| 83 | - error_report_err(err); | ||
| 84 | - } | ||
| 85 | - } | ||
| 86 | - | ||
| 87 | - return 1; | ||
| 88 | -} | ||
| 89 | - | ||
| 90 | diff --git a/qemu-doc.texi b/qemu-doc.texi | ||
| 91 | index XXXXXXX..XXXXXXX 100644 | ||
| 92 | --- a/qemu-doc.texi | ||
| 93 | +++ b/qemu-doc.texi | ||
| 94 | @@ -XXX,XX +XXX,XX @@ The ``-smb /some/dir'' argument is now a synonym for setting | ||
| 95 | the ``-netdev user,smb=/some/dir'' argument instead. The new | ||
| 96 | syntax allows different settings to be provided per NIC. | ||
| 97 | |||
| 98 | -@subsection -net channel (since 2.6.0) | ||
| 99 | - | ||
| 100 | -The ``--net channel,ARGS'' argument is now a synonym for setting | ||
| 101 | -the ``-netdev user,guestfwd=ARGS'' argument instead. | ||
| 102 | - | ||
| 103 | @subsection -net vlan (since 2.9.0) | ||
| 104 | |||
| 105 | The ``-net vlan=NN'' argument is partially replaced with the | ||
| 106 | -- | 876 | -- |
| 107 | 2.7.4 | 877 | 2.7.4 |
| 108 | 878 | ||
| 109 | 879 | diff view generated by jsdifflib |
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Separate out the standard ethernet CRC32 calculation into a new net_crc32() | 3 | When RSS is enabled the device tries to load the eBPF program |
| 4 | function, renaming the constant POLYNOMIAL to POLYNOMIAL_BE to make it clear | 4 | to select RX virtqueue in the TUN. If eBPF can be loaded |
| 5 | that this is a big-endian CRC32 calculation. | 5 | the RSS will function also with vhost (works with kernel 5.8 and later). |
| 6 | 6 | Software RSS is used as a fallback with vhost=off when eBPF can't be loaded | |
| 7 | As part of the constant rename, remove the duplicate definition of POLYNOMIAL | 7 | or when hash population requested by the guest. |
| 8 | from eepro100.c and use the new POLYNOMIAL_BE constant instead. | 8 | |
| 9 | 9 | Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com> | |
| 10 | Once this is complete remove the existing CRC32 implementation from | 10 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> |
| 11 | compute_mcast_idx() and call the new net_crc32() function in its place. | ||
| 12 | |||
| 13 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 14 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
| 15 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 11 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 16 | --- | 12 | --- |
| 17 | hw/net/eepro100.c | 4 +--- | 13 | hw/net/vhost_net.c | 3 ++ |
| 18 | include/net/net.h | 3 ++- | 14 | hw/net/virtio-net.c | 116 +++++++++++++++++++++++++++++++++++++++-- |
| 19 | net/net.c | 16 +++++++++++----- | 15 | include/hw/virtio/virtio-net.h | 4 ++ |
| 20 | 3 files changed, 14 insertions(+), 9 deletions(-) | 16 | net/vhost-vdpa.c | 2 + |
| 21 | 17 | 4 files changed, 122 insertions(+), 3 deletions(-) | |
| 22 | diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c | 18 | |
| 23 | index XXXXXXX..XXXXXXX 100644 | 19 | diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c |
| 24 | --- a/hw/net/eepro100.c | 20 | index XXXXXXX..XXXXXXX 100644 |
| 25 | +++ b/hw/net/eepro100.c | 21 | --- a/hw/net/vhost_net.c |
| 26 | @@ -XXX,XX +XXX,XX @@ static const uint16_t eepro100_mdi_mask[] = { | 22 | +++ b/hw/net/vhost_net.c |
| 27 | 0xffff, 0xffff, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, | 23 | @@ -XXX,XX +XXX,XX @@ static const int kernel_feature_bits[] = { |
| 24 | VIRTIO_NET_F_MTU, | ||
| 25 | VIRTIO_F_IOMMU_PLATFORM, | ||
| 26 | VIRTIO_F_RING_PACKED, | ||
| 27 | + VIRTIO_NET_F_HASH_REPORT, | ||
| 28 | VHOST_INVALID_FEATURE_BIT | ||
| 28 | }; | 29 | }; |
| 29 | 30 | ||
| 30 | -#define POLYNOMIAL 0x04c11db6 | 31 | @@ -XXX,XX +XXX,XX @@ static const int user_feature_bits[] = { |
| 31 | - | 32 | VIRTIO_NET_F_MTU, |
| 32 | static E100PCIDeviceInfo *eepro100_get_class(EEPRO100State *s); | 33 | VIRTIO_F_IOMMU_PLATFORM, |
| 33 | 34 | VIRTIO_F_RING_PACKED, | |
| 34 | /* From FreeBSD (locally modified). */ | 35 | + VIRTIO_NET_F_RSS, |
| 35 | @@ -XXX,XX +XXX,XX @@ static unsigned e100_compute_mcast_idx(const uint8_t *ep) | 36 | + VIRTIO_NET_F_HASH_REPORT, |
| 36 | crc <<= 1; | 37 | |
| 37 | b >>= 1; | 38 | /* This bit implies RARP isn't sent by QEMU out of band */ |
| 38 | if (carry) { | 39 | VIRTIO_NET_F_GUEST_ANNOUNCE, |
| 39 | - crc = ((crc ^ POLYNOMIAL) | carry); | 40 | diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c |
| 40 | + crc = ((crc ^ POLYNOMIAL_BE) | carry); | 41 | index XXXXXXX..XXXXXXX 100644 |
| 41 | } | 42 | --- a/hw/net/virtio-net.c |
| 42 | } | 43 | +++ b/hw/net/virtio-net.c |
| 43 | } | 44 | @@ -XXX,XX +XXX,XX @@ static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features, |
| 44 | diff --git a/include/net/net.h b/include/net/net.h | 45 | return features; |
| 45 | index XXXXXXX..XXXXXXX 100644 | 46 | } |
| 46 | --- a/include/net/net.h | 47 | |
| 47 | +++ b/include/net/net.h | 48 | - virtio_clear_feature(&features, VIRTIO_NET_F_RSS); |
| 48 | @@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_port_find(int hub_id); | 49 | - virtio_clear_feature(&features, VIRTIO_NET_F_HASH_REPORT); |
| 49 | 50 | + if (!ebpf_rss_is_loaded(&n->ebpf_rss)) { | |
| 50 | void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd); | 51 | + virtio_clear_feature(&features, VIRTIO_NET_F_RSS); |
| 51 | 52 | + } | |
| 52 | -#define POLYNOMIAL 0x04c11db6 | 53 | features = vhost_net_get_features(get_vhost_net(nc->peer), features); |
| 53 | +#define POLYNOMIAL_BE 0x04c11db6 | 54 | vdev->backend_features = features; |
| 54 | +uint32_t net_crc32(const uint8_t *p, int len); | 55 | |
| 55 | unsigned compute_mcast_idx(const uint8_t *ep); | 56 | @@ -XXX,XX +XXX,XX @@ static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd, |
| 56 | 57 | } | |
| 57 | #define vmstate_offset_macaddr(_state, _field) \ | 58 | } |
| 58 | diff --git a/net/net.c b/net/net.c | 59 | |
| 59 | index XXXXXXX..XXXXXXX 100644 | 60 | +static void virtio_net_detach_epbf_rss(VirtIONet *n); |
| 60 | --- a/net/net.c | 61 | + |
| 61 | +++ b/net/net.c | 62 | static void virtio_net_disable_rss(VirtIONet *n) |
| 62 | @@ -XXX,XX +XXX,XX @@ int net_client_parse(QemuOptsList *opts_list, const char *optarg) | ||
| 63 | |||
| 64 | /* From FreeBSD */ | ||
| 65 | /* XXX: optimize */ | ||
| 66 | -unsigned compute_mcast_idx(const uint8_t *ep) | ||
| 67 | +uint32_t net_crc32(const uint8_t *p, int len) | ||
| 68 | { | 63 | { |
| 69 | uint32_t crc; | 64 | if (n->rss_data.enabled) { |
| 70 | int carry, i, j; | 65 | trace_virtio_net_rss_disable(); |
| 71 | uint8_t b; | 66 | } |
| 72 | 67 | n->rss_data.enabled = false; | |
| 73 | crc = 0xffffffff; | 68 | + |
| 74 | - for (i = 0; i < 6; i++) { | 69 | + virtio_net_detach_epbf_rss(n); |
| 75 | - b = *ep++; | 70 | +} |
| 76 | + for (i = 0; i < len; i++) { | 71 | + |
| 77 | + b = *p++; | 72 | +static bool virtio_net_attach_ebpf_to_backend(NICState *nic, int prog_fd) |
| 78 | for (j = 0; j < 8; j++) { | 73 | +{ |
| 79 | carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01); | 74 | + NetClientState *nc = qemu_get_peer(qemu_get_queue(nic), 0); |
| 80 | crc <<= 1; | 75 | + if (nc == NULL || nc->info->set_steering_ebpf == NULL) { |
| 81 | b >>= 1; | 76 | + return false; |
| 82 | if (carry) { | 77 | + } |
| 83 | - crc = ((crc ^ POLYNOMIAL) | carry); | 78 | + |
| 84 | + crc = ((crc ^ POLYNOMIAL_BE) | carry); | 79 | + return nc->info->set_steering_ebpf(nc, prog_fd); |
| 85 | } | 80 | +} |
| 86 | } | 81 | + |
| 87 | } | 82 | +static void rss_data_to_rss_config(struct VirtioNetRssData *data, |
| 88 | - return crc >> 26; | 83 | + struct EBPFRSSConfig *config) |
| 89 | + | 84 | +{ |
| 90 | + return crc; | 85 | + config->redirect = data->redirect; |
| 91 | +} | 86 | + config->populate_hash = data->populate_hash; |
| 92 | + | 87 | + config->hash_types = data->hash_types; |
| 93 | +unsigned compute_mcast_idx(const uint8_t *ep) | 88 | + config->indirections_len = data->indirections_len; |
| 94 | +{ | 89 | + config->default_queue = data->default_queue; |
| 95 | + return net_crc32(ep, ETH_ALEN) >> 26; | 90 | +} |
| 96 | } | 91 | + |
| 97 | 92 | +static bool virtio_net_attach_epbf_rss(VirtIONet *n) | |
| 98 | QemuOptsList qemu_netdev_opts = { | 93 | +{ |
| 94 | + struct EBPFRSSConfig config = {}; | ||
| 95 | + | ||
| 96 | + if (!ebpf_rss_is_loaded(&n->ebpf_rss)) { | ||
| 97 | + return false; | ||
| 98 | + } | ||
| 99 | + | ||
| 100 | + rss_data_to_rss_config(&n->rss_data, &config); | ||
| 101 | + | ||
| 102 | + if (!ebpf_rss_set_all(&n->ebpf_rss, &config, | ||
| 103 | + n->rss_data.indirections_table, n->rss_data.key)) { | ||
| 104 | + return false; | ||
| 105 | + } | ||
| 106 | + | ||
| 107 | + if (!virtio_net_attach_ebpf_to_backend(n->nic, n->ebpf_rss.program_fd)) { | ||
| 108 | + return false; | ||
| 109 | + } | ||
| 110 | + | ||
| 111 | + return true; | ||
| 112 | +} | ||
| 113 | + | ||
| 114 | +static void virtio_net_detach_epbf_rss(VirtIONet *n) | ||
| 115 | +{ | ||
| 116 | + virtio_net_attach_ebpf_to_backend(n->nic, -1); | ||
| 117 | +} | ||
| 118 | + | ||
| 119 | +static bool virtio_net_load_ebpf(VirtIONet *n) | ||
| 120 | +{ | ||
| 121 | + if (!virtio_net_attach_ebpf_to_backend(n->nic, -1)) { | ||
| 122 | + /* backend does't support steering ebpf */ | ||
| 123 | + return false; | ||
| 124 | + } | ||
| 125 | + | ||
| 126 | + return ebpf_rss_load(&n->ebpf_rss); | ||
| 127 | +} | ||
| 128 | + | ||
| 129 | +static void virtio_net_unload_ebpf(VirtIONet *n) | ||
| 130 | +{ | ||
| 131 | + virtio_net_attach_ebpf_to_backend(n->nic, -1); | ||
| 132 | + ebpf_rss_unload(&n->ebpf_rss); | ||
| 133 | } | ||
| 134 | |||
| 135 | static uint16_t virtio_net_handle_rss(VirtIONet *n, | ||
| 136 | @@ -XXX,XX +XXX,XX @@ static uint16_t virtio_net_handle_rss(VirtIONet *n, | ||
| 137 | goto error; | ||
| 138 | } | ||
| 139 | n->rss_data.enabled = true; | ||
| 140 | + | ||
| 141 | + if (!n->rss_data.populate_hash) { | ||
| 142 | + if (!virtio_net_attach_epbf_rss(n)) { | ||
| 143 | + /* EBPF must be loaded for vhost */ | ||
| 144 | + if (get_vhost_net(qemu_get_queue(n->nic)->peer)) { | ||
| 145 | + warn_report("Can't load eBPF RSS for vhost"); | ||
| 146 | + goto error; | ||
| 147 | + } | ||
| 148 | + /* fallback to software RSS */ | ||
| 149 | + warn_report("Can't load eBPF RSS - fallback to software RSS"); | ||
| 150 | + n->rss_data.enabled_software_rss = true; | ||
| 151 | + } | ||
| 152 | + } else { | ||
| 153 | + /* use software RSS for hash populating */ | ||
| 154 | + /* and detach eBPF if was loaded before */ | ||
| 155 | + virtio_net_detach_epbf_rss(n); | ||
| 156 | + n->rss_data.enabled_software_rss = true; | ||
| 157 | + } | ||
| 158 | + | ||
| 159 | trace_virtio_net_rss_enable(n->rss_data.hash_types, | ||
| 160 | n->rss_data.indirections_len, | ||
| 161 | temp.b); | ||
| 162 | @@ -XXX,XX +XXX,XX @@ static ssize_t virtio_net_receive_rcu(NetClientState *nc, const uint8_t *buf, | ||
| 163 | return -1; | ||
| 164 | } | ||
| 165 | |||
| 166 | - if (!no_rss && n->rss_data.enabled) { | ||
| 167 | + if (!no_rss && n->rss_data.enabled && n->rss_data.enabled_software_rss) { | ||
| 168 | int index = virtio_net_process_rss(nc, buf, size); | ||
| 169 | if (index >= 0) { | ||
| 170 | NetClientState *nc2 = qemu_get_subqueue(n->nic, index); | ||
| 171 | @@ -XXX,XX +XXX,XX @@ static int virtio_net_post_load_device(void *opaque, int version_id) | ||
| 172 | } | ||
| 173 | |||
| 174 | if (n->rss_data.enabled) { | ||
| 175 | + n->rss_data.enabled_software_rss = n->rss_data.populate_hash; | ||
| 176 | + if (!n->rss_data.populate_hash) { | ||
| 177 | + if (!virtio_net_attach_epbf_rss(n)) { | ||
| 178 | + if (get_vhost_net(qemu_get_queue(n->nic)->peer)) { | ||
| 179 | + warn_report("Can't post-load eBPF RSS for vhost"); | ||
| 180 | + } else { | ||
| 181 | + warn_report("Can't post-load eBPF RSS - " | ||
| 182 | + "fallback to software RSS"); | ||
| 183 | + n->rss_data.enabled_software_rss = true; | ||
| 184 | + } | ||
| 185 | + } | ||
| 186 | + } | ||
| 187 | + | ||
| 188 | trace_virtio_net_rss_enable(n->rss_data.hash_types, | ||
| 189 | n->rss_data.indirections_len, | ||
| 190 | sizeof(n->rss_data.key)); | ||
| 191 | @@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp) | ||
| 192 | n->qdev = dev; | ||
| 193 | |||
| 194 | net_rx_pkt_init(&n->rx_pkt, false); | ||
| 195 | + | ||
| 196 | + if (virtio_has_feature(n->host_features, VIRTIO_NET_F_RSS)) { | ||
| 197 | + virtio_net_load_ebpf(n); | ||
| 198 | + } | ||
| 199 | } | ||
| 200 | |||
| 201 | static void virtio_net_device_unrealize(DeviceState *dev) | ||
| 202 | @@ -XXX,XX +XXX,XX @@ static void virtio_net_device_unrealize(DeviceState *dev) | ||
| 203 | VirtIONet *n = VIRTIO_NET(dev); | ||
| 204 | int i, max_queues; | ||
| 205 | |||
| 206 | + if (virtio_has_feature(n->host_features, VIRTIO_NET_F_RSS)) { | ||
| 207 | + virtio_net_unload_ebpf(n); | ||
| 208 | + } | ||
| 209 | + | ||
| 210 | /* This will stop vhost backend if appropriate. */ | ||
| 211 | virtio_net_set_status(vdev, 0); | ||
| 212 | |||
| 213 | @@ -XXX,XX +XXX,XX @@ static void virtio_net_instance_init(Object *obj) | ||
| 214 | device_add_bootindex_property(obj, &n->nic_conf.bootindex, | ||
| 215 | "bootindex", "/ethernet-phy@0", | ||
| 216 | DEVICE(n)); | ||
| 217 | + | ||
| 218 | + ebpf_rss_init(&n->ebpf_rss); | ||
| 219 | } | ||
| 220 | |||
| 221 | static int virtio_net_pre_save(void *opaque) | ||
| 222 | diff --git a/include/hw/virtio/virtio-net.h b/include/hw/virtio/virtio-net.h | ||
| 223 | index XXXXXXX..XXXXXXX 100644 | ||
| 224 | --- a/include/hw/virtio/virtio-net.h | ||
| 225 | +++ b/include/hw/virtio/virtio-net.h | ||
| 226 | @@ -XXX,XX +XXX,XX @@ | ||
| 227 | #include "qemu/option_int.h" | ||
| 228 | #include "qom/object.h" | ||
| 229 | |||
| 230 | +#include "ebpf/ebpf_rss.h" | ||
| 231 | + | ||
| 232 | #define TYPE_VIRTIO_NET "virtio-net-device" | ||
| 233 | OBJECT_DECLARE_SIMPLE_TYPE(VirtIONet, VIRTIO_NET) | ||
| 234 | |||
| 235 | @@ -XXX,XX +XXX,XX @@ typedef struct VirtioNetRscChain { | ||
| 236 | |||
| 237 | typedef struct VirtioNetRssData { | ||
| 238 | bool enabled; | ||
| 239 | + bool enabled_software_rss; | ||
| 240 | bool redirect; | ||
| 241 | bool populate_hash; | ||
| 242 | uint32_t hash_types; | ||
| 243 | @@ -XXX,XX +XXX,XX @@ struct VirtIONet { | ||
| 244 | Notifier migration_state; | ||
| 245 | VirtioNetRssData rss_data; | ||
| 246 | struct NetRxPkt *rx_pkt; | ||
| 247 | + struct EBPFRSSContext ebpf_rss; | ||
| 248 | }; | ||
| 249 | |||
| 250 | void virtio_net_set_netclient_name(VirtIONet *n, const char *name, | ||
| 251 | diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c | ||
| 252 | index XXXXXXX..XXXXXXX 100644 | ||
| 253 | --- a/net/vhost-vdpa.c | ||
| 254 | +++ b/net/vhost-vdpa.c | ||
| 255 | @@ -XXX,XX +XXX,XX @@ const int vdpa_feature_bits[] = { | ||
| 256 | VIRTIO_NET_F_MTU, | ||
| 257 | VIRTIO_F_IOMMU_PLATFORM, | ||
| 258 | VIRTIO_F_RING_PACKED, | ||
| 259 | + VIRTIO_NET_F_RSS, | ||
| 260 | + VIRTIO_NET_F_HASH_REPORT, | ||
| 261 | VIRTIO_NET_F_GUEST_ANNOUNCE, | ||
| 262 | VIRTIO_NET_F_STATUS, | ||
| 263 | VHOST_INVALID_FEATURE_BIT | ||
| 99 | -- | 264 | -- |
| 100 | 2.7.4 | 265 | 2.7.4 |
| 101 | 266 | ||
| 102 | 267 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | Instead of lnc_mchash() using its own implementation, we can simply call | ||
| 4 | net_crc32_le() directly and apply the bit shift inline. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
| 8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
| 9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 10 | --- | ||
| 11 | hw/net/pcnet.c | 22 ++-------------------- | ||
| 12 | 1 file changed, 2 insertions(+), 20 deletions(-) | ||
| 13 | |||
| 14 | diff --git a/hw/net/pcnet.c b/hw/net/pcnet.c | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/hw/net/pcnet.c | ||
| 17 | +++ b/hw/net/pcnet.c | ||
| 18 | @@ -XXX,XX +XXX,XX @@ | ||
| 19 | #include "qemu/osdep.h" | ||
| 20 | #include "hw/qdev.h" | ||
| 21 | #include "net/net.h" | ||
| 22 | +#include "net/eth.h" | ||
| 23 | #include "qemu/timer.h" | ||
| 24 | #include "qemu/sockets.h" | ||
| 25 | #include "sysemu/sysemu.h" | ||
| 26 | @@ -XXX,XX +XXX,XX @@ static inline void pcnet_rmd_store(PCNetState *s, struct pcnet_RMD *rmd, | ||
| 27 | be16_to_cpu(hdr->ether_type)); \ | ||
| 28 | } while (0) | ||
| 29 | |||
| 30 | -#define MULTICAST_FILTER_LEN 8 | ||
| 31 | - | ||
| 32 | -static inline uint32_t lnc_mchash(const uint8_t *ether_addr) | ||
| 33 | -{ | ||
| 34 | -#define LNC_POLYNOMIAL 0xEDB88320UL | ||
| 35 | - uint32_t crc = 0xFFFFFFFF; | ||
| 36 | - int idx, bit; | ||
| 37 | - uint8_t data; | ||
| 38 | - | ||
| 39 | - for (idx = 0; idx < 6; idx++) { | ||
| 40 | - for (data = *ether_addr++, bit = 0; bit < MULTICAST_FILTER_LEN; bit++) { | ||
| 41 | - crc = (crc >> 1) ^ (((crc ^ data) & 1) ? LNC_POLYNOMIAL : 0); | ||
| 42 | - data >>= 1; | ||
| 43 | - } | ||
| 44 | - } | ||
| 45 | - return crc; | ||
| 46 | -#undef LNC_POLYNOMIAL | ||
| 47 | -} | ||
| 48 | - | ||
| 49 | #define CRC(crc, ch) (crc = (crc >> 8) ^ crctab[(crc ^ (ch)) & 0xff]) | ||
| 50 | |||
| 51 | /* generated using the AUTODIN II polynomial | ||
| 52 | @@ -XXX,XX +XXX,XX @@ static inline int ladr_match(PCNetState *s, const uint8_t *buf, int size) | ||
| 53 | s->csr[10] & 0xff, s->csr[10] >> 8, | ||
| 54 | s->csr[11] & 0xff, s->csr[11] >> 8 | ||
| 55 | }; | ||
| 56 | - int index = lnc_mchash(hdr->ether_dhost) >> 26; | ||
| 57 | + int index = net_crc32_le(hdr->ether_dhost, ETH_ALEN) >> 26; | ||
| 58 | return !!(ladr[index >> 3] & (1 << (index & 7))); | ||
| 59 | } | ||
| 60 | return 0; | ||
| 61 | -- | ||
| 62 | 2.7.4 | ||
| 63 | |||
| 64 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | Instead of e100_compute_mcast_idx() using its own implementation, we can | ||
| 4 | simply call net_crc32() directly and apply the bit shift inline. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Reviewed-by: Stefan Weil <sw@weilnetz.de> | ||
| 8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
| 9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 10 | --- | ||
| 11 | hw/net/eepro100.c | 28 ++++------------------------ | ||
| 12 | 1 file changed, 4 insertions(+), 24 deletions(-) | ||
| 13 | |||
| 14 | diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/hw/net/eepro100.c | ||
| 17 | +++ b/hw/net/eepro100.c | ||
| 18 | @@ -XXX,XX +XXX,XX @@ | ||
| 19 | #include "hw/hw.h" | ||
| 20 | #include "hw/pci/pci.h" | ||
| 21 | #include "net/net.h" | ||
| 22 | +#include "net/eth.h" | ||
| 23 | #include "hw/nvram/eeprom93xx.h" | ||
| 24 | #include "sysemu/sysemu.h" | ||
| 25 | #include "sysemu/dma.h" | ||
| 26 | @@ -XXX,XX +XXX,XX @@ static const uint16_t eepro100_mdi_mask[] = { | ||
| 27 | |||
| 28 | static E100PCIDeviceInfo *eepro100_get_class(EEPRO100State *s); | ||
| 29 | |||
| 30 | -/* From FreeBSD (locally modified). */ | ||
| 31 | -static unsigned e100_compute_mcast_idx(const uint8_t *ep) | ||
| 32 | -{ | ||
| 33 | - uint32_t crc; | ||
| 34 | - int carry, i, j; | ||
| 35 | - uint8_t b; | ||
| 36 | - | ||
| 37 | - crc = 0xffffffff; | ||
| 38 | - for (i = 0; i < 6; i++) { | ||
| 39 | - b = *ep++; | ||
| 40 | - for (j = 0; j < 8; j++) { | ||
| 41 | - carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01); | ||
| 42 | - crc <<= 1; | ||
| 43 | - b >>= 1; | ||
| 44 | - if (carry) { | ||
| 45 | - crc = ((crc ^ POLYNOMIAL_BE) | carry); | ||
| 46 | - } | ||
| 47 | - } | ||
| 48 | - } | ||
| 49 | - return (crc & BITS(7, 2)) >> 2; | ||
| 50 | -} | ||
| 51 | - | ||
| 52 | /* Read a 16 bit control/status (CSR) register. */ | ||
| 53 | static uint16_t e100_read_reg2(EEPRO100State *s, E100RegisterOffset addr) | ||
| 54 | { | ||
| 55 | @@ -XXX,XX +XXX,XX @@ static void set_multicast_list(EEPRO100State *s) | ||
| 56 | uint8_t multicast_addr[6]; | ||
| 57 | pci_dma_read(&s->dev, s->cb_address + 10 + i, multicast_addr, 6); | ||
| 58 | TRACE(OTHER, logout("multicast entry %s\n", nic_dump(multicast_addr, 6))); | ||
| 59 | - unsigned mcast_idx = e100_compute_mcast_idx(multicast_addr); | ||
| 60 | + unsigned mcast_idx = (net_crc32(multicast_addr, ETH_ALEN) & | ||
| 61 | + BITS(7, 2)) >> 2; | ||
| 62 | assert(mcast_idx < 64); | ||
| 63 | s->mult[mcast_idx >> 3] |= (1 << (mcast_idx & 7)); | ||
| 64 | } | ||
| 65 | @@ -XXX,XX +XXX,XX @@ static ssize_t nic_receive(NetClientState *nc, const uint8_t * buf, size_t size) | ||
| 66 | if (s->configuration[21] & BIT(3)) { | ||
| 67 | /* Multicast all bit is set, receive all multicast frames. */ | ||
| 68 | } else { | ||
| 69 | - unsigned mcast_idx = e100_compute_mcast_idx(buf); | ||
| 70 | + unsigned mcast_idx = (net_crc32(buf, ETH_ALEN) & BITS(7, 2)) >> 2; | ||
| 71 | assert(mcast_idx < 64); | ||
| 72 | if (s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))) { | ||
| 73 | /* Multicast frame is allowed in hash table. */ | ||
| 74 | -- | ||
| 75 | 2.7.4 | ||
| 76 | |||
| 77 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | Instead of sunhme_crc32_le() using its own implementation, we can simply call | ||
| 4 | net_crc32_le() directly and apply the bit shift inline. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Reviewed-by: Eric Blake <eblake@redhat.com> | ||
| 8 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
| 9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 10 | --- | ||
| 11 | hw/net/sunhme.c | 25 +------------------------ | ||
| 12 | 1 file changed, 1 insertion(+), 24 deletions(-) | ||
| 13 | |||
| 14 | diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c | ||
| 15 | index XXXXXXX..XXXXXXX 100644 | ||
| 16 | --- a/hw/net/sunhme.c | ||
| 17 | +++ b/hw/net/sunhme.c | ||
| 18 | @@ -XXX,XX +XXX,XX @@ static inline void sunhme_set_rx_ring_nr(SunHMEState *s, int i) | ||
| 19 | s->erxregs[HME_ERXI_RING >> 2] = ring; | ||
| 20 | } | ||
| 21 | |||
| 22 | -#define POLYNOMIAL_LE 0xedb88320 | ||
| 23 | -static uint32_t sunhme_crc32_le(const uint8_t *p, int len) | ||
| 24 | -{ | ||
| 25 | - uint32_t crc; | ||
| 26 | - int carry, i, j; | ||
| 27 | - uint8_t b; | ||
| 28 | - | ||
| 29 | - crc = 0xffffffff; | ||
| 30 | - for (i = 0; i < len; i++) { | ||
| 31 | - b = *p++; | ||
| 32 | - for (j = 0; j < 8; j++) { | ||
| 33 | - carry = (crc & 0x1) ^ (b & 0x01); | ||
| 34 | - crc >>= 1; | ||
| 35 | - b >>= 1; | ||
| 36 | - if (carry) { | ||
| 37 | - crc = crc ^ POLYNOMIAL_LE; | ||
| 38 | - } | ||
| 39 | - } | ||
| 40 | - } | ||
| 41 | - | ||
| 42 | - return crc; | ||
| 43 | -} | ||
| 44 | - | ||
| 45 | #define MIN_BUF_SIZE 60 | ||
| 46 | |||
| 47 | static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf, | ||
| 48 | @@ -XXX,XX +XXX,XX @@ static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf, | ||
| 49 | trace_sunhme_rx_filter_bcast_match(); | ||
| 50 | } else if (s->macregs[HME_MACI_RXCFG >> 2] & HME_MAC_RXCFG_HENABLE) { | ||
| 51 | /* Didn't match local address, check hash filter */ | ||
| 52 | - int mcast_idx = sunhme_crc32_le(buf, 6) >> 26; | ||
| 53 | + int mcast_idx = net_crc32_le(buf, ETH_ALEN) >> 26; | ||
| 54 | if (!(s->macregs[(HME_MACI_HASHTAB0 >> 2) - (mcast_idx >> 4)] & | ||
| 55 | (1 << (mcast_idx & 0xf)))) { | ||
| 56 | /* Didn't match hash filter */ | ||
| 57 | -- | ||
| 58 | 2.7.4 | ||
| 59 | |||
| 60 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | From the Linux sungem driver, we know that the multicast filter CRC is | ||
| 4 | implemented using ether_crc_le() which isn't the same as calling zlib's | ||
| 5 | crc32() function (the zlib implementation requires a complemented initial value | ||
| 6 | and also returns the complemented result). | ||
| 7 | |||
| 8 | Fix the multicast filter by simply using the new net_crc32_le() function. | ||
| 9 | |||
| 10 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 11 | Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | ||
| 12 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 13 | --- | ||
| 14 | hw/net/sungem.c | 5 ++--- | ||
| 15 | 1 file changed, 2 insertions(+), 3 deletions(-) | ||
| 16 | |||
| 17 | diff --git a/hw/net/sungem.c b/hw/net/sungem.c | ||
| 18 | index XXXXXXX..XXXXXXX 100644 | ||
| 19 | --- a/hw/net/sungem.c | ||
| 20 | +++ b/hw/net/sungem.c | ||
| 21 | @@ -XXX,XX +XXX,XX @@ | ||
| 22 | #include "hw/pci/pci.h" | ||
| 23 | #include "qemu/log.h" | ||
| 24 | #include "net/net.h" | ||
| 25 | +#include "net/eth.h" | ||
| 26 | #include "net/checksum.h" | ||
| 27 | #include "hw/net/mii.h" | ||
| 28 | #include "sysemu/sysemu.h" | ||
| 29 | #include "trace.h" | ||
| 30 | -/* For crc32 */ | ||
| 31 | -#include <zlib.h> | ||
| 32 | |||
| 33 | #define TYPE_SUNGEM "sungem" | ||
| 34 | |||
| 35 | @@ -XXX,XX +XXX,XX @@ static ssize_t sungem_receive(NetClientState *nc, const uint8_t *buf, | ||
| 36 | } | ||
| 37 | |||
| 38 | /* Get MAC crc */ | ||
| 39 | - mac_crc = crc32(~0, buf, 6); | ||
| 40 | + mac_crc = net_crc32_le(buf, ETH_ALEN); | ||
| 41 | |||
| 42 | /* Packet isn't for me ? */ | ||
| 43 | rx_cond = sungem_check_rx_mac(s, buf, mac_crc); | ||
| 44 | -- | ||
| 45 | 2.7.4 | ||
| 46 | |||
| 47 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | This makes it much easier to compare the multicast CRC calculation endian and | ||
| 4 | bitshift against the Linux driver implementation. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 8 | --- | ||
| 9 | hw/net/eepro100.c | 2 +- | ||
| 10 | 1 file changed, 1 insertion(+), 1 deletion(-) | ||
| 11 | |||
| 12 | diff --git a/hw/net/eepro100.c b/hw/net/eepro100.c | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/hw/net/eepro100.c | ||
| 15 | +++ b/hw/net/eepro100.c | ||
| 16 | @@ -XXX,XX +XXX,XX @@ static ssize_t nic_receive(NetClientState *nc, const uint8_t * buf, size_t size) | ||
| 17 | rfd_status |= 0x0004; | ||
| 18 | } else if (s->configuration[20] & BIT(6)) { | ||
| 19 | /* Multiple IA bit set. */ | ||
| 20 | - unsigned mcast_idx = compute_mcast_idx(buf); | ||
| 21 | + unsigned mcast_idx = net_crc32(buf, ETH_ALEN) >> 26; | ||
| 22 | assert(mcast_idx < 64); | ||
| 23 | if (s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))) { | ||
| 24 | TRACE(RXTX, logout("%p accepted, multiple IA bit set\n", s)); | ||
| 25 | -- | ||
| 26 | 2.7.4 | ||
| 27 | |||
| 28 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | This makes it much easier to compare the multicast CRC calculation endian and | ||
| 4 | bitshift against the Linux driver implementation. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 8 | --- | ||
| 9 | hw/net/opencores_eth.c | 3 ++- | ||
| 10 | 1 file changed, 2 insertions(+), 1 deletion(-) | ||
| 11 | |||
| 12 | diff --git a/hw/net/opencores_eth.c b/hw/net/opencores_eth.c | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/hw/net/opencores_eth.c | ||
| 15 | +++ b/hw/net/opencores_eth.c | ||
| 16 | @@ -XXX,XX +XXX,XX @@ | ||
| 17 | #include "hw/net/mii.h" | ||
| 18 | #include "hw/sysbus.h" | ||
| 19 | #include "net/net.h" | ||
| 20 | +#include "net/eth.h" | ||
| 21 | #include "sysemu/sysemu.h" | ||
| 22 | #include "trace.h" | ||
| 23 | |||
| 24 | @@ -XXX,XX +XXX,XX @@ static ssize_t open_eth_receive(NetClientState *nc, | ||
| 25 | if (memcmp(buf, bcast_addr, sizeof(bcast_addr)) == 0) { | ||
| 26 | miss = GET_REGBIT(s, MODER, BRO); | ||
| 27 | } else if ((buf[0] & 0x1) || GET_REGBIT(s, MODER, IAM)) { | ||
| 28 | - unsigned mcast_idx = compute_mcast_idx(buf); | ||
| 29 | + unsigned mcast_idx = net_crc32(buf, ETH_ALEN) >> 26; | ||
| 30 | miss = !(s->regs[HASH0 + mcast_idx / 32] & | ||
| 31 | (1 << (mcast_idx % 32))); | ||
| 32 | trace_open_eth_receive_mcast( | ||
| 33 | -- | ||
| 34 | 2.7.4 | ||
| 35 | |||
| 36 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | This makes it much easier to compare the multicast CRC calculation endian and | ||
| 4 | bitshift against the Linux driver implementation. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 8 | --- | ||
| 9 | hw/net/lan9118.c | 3 ++- | ||
| 10 | 1 file changed, 2 insertions(+), 1 deletion(-) | ||
| 11 | |||
| 12 | diff --git a/hw/net/lan9118.c b/hw/net/lan9118.c | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/hw/net/lan9118.c | ||
| 15 | +++ b/hw/net/lan9118.c | ||
| 16 | @@ -XXX,XX +XXX,XX @@ | ||
| 17 | #include "qemu/osdep.h" | ||
| 18 | #include "hw/sysbus.h" | ||
| 19 | #include "net/net.h" | ||
| 20 | +#include "net/eth.h" | ||
| 21 | #include "hw/devices.h" | ||
| 22 | #include "sysemu/sysemu.h" | ||
| 23 | #include "hw/ptimer.h" | ||
| 24 | @@ -XXX,XX +XXX,XX @@ static int lan9118_filter(lan9118_state *s, const uint8_t *addr) | ||
| 25 | } | ||
| 26 | } else { | ||
| 27 | /* Hash matching */ | ||
| 28 | - hash = compute_mcast_idx(addr); | ||
| 29 | + hash = net_crc32(addr, ETH_ALEN) >> 26; | ||
| 30 | if (hash & 0x20) { | ||
| 31 | return (s->mac_hashh >> (hash & 0x1f)) & 1; | ||
| 32 | } else { | ||
| 33 | -- | ||
| 34 | 2.7.4 | ||
| 35 | |||
| 36 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | This makes it much easier to compare the multicast CRC calculation endian and | ||
| 4 | bitshift against the Linux driver implementation. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 8 | --- | ||
| 9 | hw/net/ftgmac100.c | 2 +- | ||
| 10 | 1 file changed, 1 insertion(+), 1 deletion(-) | ||
| 11 | |||
| 12 | diff --git a/hw/net/ftgmac100.c b/hw/net/ftgmac100.c | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/hw/net/ftgmac100.c | ||
| 15 | +++ b/hw/net/ftgmac100.c | ||
| 16 | @@ -XXX,XX +XXX,XX @@ static int ftgmac100_filter(FTGMAC100State *s, const uint8_t *buf, size_t len) | ||
| 17 | } | ||
| 18 | |||
| 19 | /* TODO: this does not seem to work for ftgmac100 */ | ||
| 20 | - mcast_idx = compute_mcast_idx(buf); | ||
| 21 | + mcast_idx = net_crc32(buf, ETH_ALEN) >> 26; | ||
| 22 | if (!(s->math[mcast_idx / 32] & (1 << (mcast_idx % 32)))) { | ||
| 23 | return 0; | ||
| 24 | } | ||
| 25 | -- | ||
| 26 | 2.7.4 | ||
| 27 | |||
| 28 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 2 | 1 | ||
| 3 | This makes it much easier to compare the multicast CRC calculation endian and | ||
| 4 | bitshift against the Linux driver implementation. | ||
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 8 | --- | ||
| 9 | hw/net/ne2000.c | 4 +++- | ||
| 10 | 1 file changed, 3 insertions(+), 1 deletion(-) | ||
| 11 | |||
| 12 | diff --git a/hw/net/ne2000.c b/hw/net/ne2000.c | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/hw/net/ne2000.c | ||
| 15 | +++ b/hw/net/ne2000.c | ||
| 16 | @@ -XXX,XX +XXX,XX @@ | ||
| 17 | */ | ||
| 18 | #include "qemu/osdep.h" | ||
| 19 | #include "hw/pci/pci.h" | ||
| 20 | +#include "net/net.h" | ||
| 21 | +#include "net/eth.h" | ||
| 22 | #include "ne2000.h" | ||
| 23 | #include "hw/loader.h" | ||
| 24 | #include "sysemu/sysemu.h" | ||
| 25 | @@ -XXX,XX +XXX,XX @@ ssize_t ne2000_receive(NetClientState *nc, const uint8_t *buf, size_t size_) | ||
| 26 | /* multicast */ | ||
| 27 | if (!(s->rxcr & 0x08)) | ||
| 28 | return size; | ||
| 29 | - mcast_idx = compute_mcast_idx(buf); | ||
| 30 | + mcast_idx = net_crc32(buf, ETH_ALEN) >> 26; | ||
| 31 | if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7)))) | ||
| 32 | return size; | ||
| 33 | } else if (s->mem[0] == buf[0] && | ||
| 34 | -- | ||
| 35 | 2.7.4 | ||
| 36 | |||
| 37 | diff view generated by jsdifflib |
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Now that all of the callers have been converted to compute the multicast index | 3 | Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com> |
| 4 | inline using new net CRC functions, this function can now be dropped. | 4 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> |
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 5 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 8 | --- | 6 | --- |
| 9 | net/net.c | 5 ----- | 7 | docs/devel/ebpf_rss.rst | 125 ++++++++++++++++++++++++++++++++++++++++++++++++ |
| 10 | 1 file changed, 5 deletions(-) | 8 | docs/devel/index.rst | 1 + |
| 9 | 2 files changed, 126 insertions(+) | ||
| 10 | create mode 100644 docs/devel/ebpf_rss.rst | ||
| 11 | 11 | ||
| 12 | diff --git a/net/net.c b/net/net.c | 12 | diff --git a/docs/devel/ebpf_rss.rst b/docs/devel/ebpf_rss.rst |
| 13 | new file mode 100644 | ||
| 14 | index XXXXXXX..XXXXXXX | ||
| 15 | --- /dev/null | ||
| 16 | +++ b/docs/devel/ebpf_rss.rst | ||
| 17 | @@ -XXX,XX +XXX,XX @@ | ||
| 18 | +=========================== | ||
| 19 | +eBPF RSS virtio-net support | ||
| 20 | +=========================== | ||
| 21 | + | ||
| 22 | +RSS(Receive Side Scaling) is used to distribute network packets to guest virtqueues | ||
| 23 | +by calculating packet hash. Usually every queue is processed then by a specific guest CPU core. | ||
| 24 | + | ||
| 25 | +For now there are 2 RSS implementations in qemu: | ||
| 26 | +- 'in-qemu' RSS (functions if qemu receives network packets, i.e. vhost=off) | ||
| 27 | +- eBPF RSS (can function with also with vhost=on) | ||
| 28 | + | ||
| 29 | +eBPF support (CONFIG_EBPF) is enabled by 'configure' script. | ||
| 30 | +To enable eBPF RSS support use './configure --enable-bpf'. | ||
| 31 | + | ||
| 32 | +If steering BPF is not set for kernel's TUN module, the TUN uses automatic selection | ||
| 33 | +of rx virtqueue based on lookup table built according to calculated symmetric hash | ||
| 34 | +of transmitted packets. | ||
| 35 | +If steering BPF is set for TUN the BPF code calculates the hash of packet header and | ||
| 36 | +returns the virtqueue number to place the packet to. | ||
| 37 | + | ||
| 38 | +Simplified decision formula: | ||
| 39 | + | ||
| 40 | +.. code:: C | ||
| 41 | + | ||
| 42 | + queue_index = indirection_table[hash(<packet data>)%<indirection_table size>] | ||
| 43 | + | ||
| 44 | + | ||
| 45 | +Not for all packets, the hash can/should be calculated. | ||
| 46 | + | ||
| 47 | +Note: currently, eBPF RSS does not support hash reporting. | ||
| 48 | + | ||
| 49 | +eBPF RSS turned on by different combinations of vhost-net, vitrio-net and tap configurations: | ||
| 50 | + | ||
| 51 | +- eBPF is used: | ||
| 52 | + | ||
| 53 | + tap,vhost=off & virtio-net-pci,rss=on,hash=off | ||
| 54 | + | ||
| 55 | +- eBPF is used: | ||
| 56 | + | ||
| 57 | + tap,vhost=on & virtio-net-pci,rss=on,hash=off | ||
| 58 | + | ||
| 59 | +- 'in-qemu' RSS is used: | ||
| 60 | + | ||
| 61 | + tap,vhost=off & virtio-net-pci,rss=on,hash=on | ||
| 62 | + | ||
| 63 | +- eBPF is used, hash population feature is not reported to the guest: | ||
| 64 | + | ||
| 65 | + tap,vhost=on & virtio-net-pci,rss=on,hash=on | ||
| 66 | + | ||
| 67 | +If CONFIG_EBPF is not set then only 'in-qemu' RSS is supported. | ||
| 68 | +Also 'in-qemu' RSS, as a fallback, is used if the eBPF program failed to load or set to TUN. | ||
| 69 | + | ||
| 70 | +RSS eBPF program | ||
| 71 | +---------------- | ||
| 72 | + | ||
| 73 | +RSS program located in ebpf/rss.bpf.skeleton.h generated by bpftool. | ||
| 74 | +So the program is part of the qemu binary. | ||
| 75 | +Initially, the eBPF program was compiled by clang and source code located at tools/ebpf/rss.bpf.c. | ||
| 76 | +Prerequisites to recompile the eBPF program (regenerate ebpf/rss.bpf.skeleton.h): | ||
| 77 | + | ||
| 78 | + llvm, clang, kernel source tree, bpftool | ||
| 79 | + Adjust Makefile.ebpf to reflect the location of the kernel source tree | ||
| 80 | + | ||
| 81 | + $ cd tools/ebpf | ||
| 82 | + $ make -f Makefile.ebpf | ||
| 83 | + | ||
| 84 | +Current eBPF RSS implementation uses 'bounded loops' with 'backward jump instructions' which present in the last kernels. | ||
| 85 | +Overall eBPF RSS works on kernels 5.8+. | ||
| 86 | + | ||
| 87 | +eBPF RSS implementation | ||
| 88 | +----------------------- | ||
| 89 | + | ||
| 90 | +eBPF RSS loading functionality located in ebpf/ebpf_rss.c and ebpf/ebpf_rss.h. | ||
| 91 | + | ||
| 92 | +The `struct EBPFRSSContext` structure that holds 4 file descriptors: | ||
| 93 | + | ||
| 94 | +- ctx - pointer of the libbpf context. | ||
| 95 | +- program_fd - file descriptor of the eBPF RSS program. | ||
| 96 | +- map_configuration - file descriptor of the 'configuration' map. This map contains one element of 'struct EBPFRSSConfig'. This configuration determines eBPF program behavior. | ||
| 97 | +- map_toeplitz_key - file descriptor of the 'Toeplitz key' map. One element of the 40byte key prepared for the hashing algorithm. | ||
| 98 | +- map_indirections_table - 128 elements of queue indexes. | ||
| 99 | + | ||
| 100 | +`struct EBPFRSSConfig` fields: | ||
| 101 | + | ||
| 102 | +- redirect - "boolean" value, should the hash be calculated, on false - `default_queue` would be used as the final decision. | ||
| 103 | +- populate_hash - for now, not used. eBPF RSS doesn't support hash reporting. | ||
| 104 | +- hash_types - binary mask of different hash types. See `VIRTIO_NET_RSS_HASH_TYPE_*` defines. If for packet hash should not be calculated - `default_queue` would be used. | ||
| 105 | +- indirections_len - length of the indirections table, maximum 128. | ||
| 106 | +- default_queue - the queue index that used for packet that shouldn't be hashed. For some packets, the hash can't be calculated(g.e ARP). | ||
| 107 | + | ||
| 108 | +Functions: | ||
| 109 | + | ||
| 110 | +- `ebpf_rss_init()` - sets ctx to NULL, which indicates that EBPFRSSContext is not loaded. | ||
| 111 | +- `ebpf_rss_load()` - creates 3 maps and loads eBPF program from the rss.bpf.skeleton.h. Returns 'true' on success. After that, program_fd can be used to set steering for TAP. | ||
| 112 | +- `ebpf_rss_set_all()` - sets values for eBPF maps. `indirections_table` length is in EBPFRSSConfig. `toeplitz_key` is VIRTIO_NET_RSS_MAX_KEY_SIZE aka 40 bytes array. | ||
| 113 | +- `ebpf_rss_unload()` - close all file descriptors and set ctx to NULL. | ||
| 114 | + | ||
| 115 | +Simplified eBPF RSS workflow: | ||
| 116 | + | ||
| 117 | +.. code:: C | ||
| 118 | + | ||
| 119 | + struct EBPFRSSConfig config; | ||
| 120 | + config.redirect = 1; | ||
| 121 | + config.hash_types = VIRTIO_NET_RSS_HASH_TYPE_UDPv4 | VIRTIO_NET_RSS_HASH_TYPE_TCPv4; | ||
| 122 | + config.indirections_len = VIRTIO_NET_RSS_MAX_TABLE_LEN; | ||
| 123 | + config.default_queue = 0; | ||
| 124 | + | ||
| 125 | + uint16_t table[VIRTIO_NET_RSS_MAX_TABLE_LEN] = {...}; | ||
| 126 | + uint8_t key[VIRTIO_NET_RSS_MAX_KEY_SIZE] = {...}; | ||
| 127 | + | ||
| 128 | + struct EBPFRSSContext ctx; | ||
| 129 | + ebpf_rss_init(&ctx); | ||
| 130 | + ebpf_rss_load(&ctx); | ||
| 131 | + ebpf_rss_set_all(&ctx, &config, table, key); | ||
| 132 | + if (net_client->info->set_steering_ebpf != NULL) { | ||
| 133 | + net_client->info->set_steering_ebpf(net_client, ctx->program_fd); | ||
| 134 | + } | ||
| 135 | + ... | ||
| 136 | + ebpf_unload(&ctx); | ||
| 137 | + | ||
| 138 | + | ||
| 139 | +NetClientState SetSteeringEBPF() | ||
| 140 | +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | ||
| 141 | + | ||
| 142 | +For now, `set_steering_ebpf()` method supported by Linux TAP NetClientState. The method requires an eBPF program file descriptor as an argument. | ||
| 143 | diff --git a/docs/devel/index.rst b/docs/devel/index.rst | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | 144 | index XXXXXXX..XXXXXXX 100644 |
| 14 | --- a/net/net.c | 145 | --- a/docs/devel/index.rst |
| 15 | +++ b/net/net.c | 146 | +++ b/docs/devel/index.rst |
| 16 | @@ -XXX,XX +XXX,XX @@ uint32_t net_crc32_le(const uint8_t *p, int len) | 147 | @@ -XXX,XX +XXX,XX @@ Contents: |
| 17 | return crc; | 148 | qom |
| 18 | } | 149 | block-coroutine-wrapper |
| 19 | 150 | multi-process | |
| 20 | -unsigned compute_mcast_idx(const uint8_t *ep) | 151 | + ebpf_rss |
| 21 | -{ | ||
| 22 | - return net_crc32(ep, ETH_ALEN) >> 26; | ||
| 23 | -} | ||
| 24 | - | ||
| 25 | QemuOptsList qemu_netdev_opts = { | ||
| 26 | .name = "netdev", | ||
| 27 | .implied_opt_name = "type", | ||
| 28 | -- | 152 | -- |
| 29 | 2.7.4 | 153 | 2.7.4 |
| 30 | 154 | ||
| 31 | 155 | diff view generated by jsdifflib |
| 1 | From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | 1 | From: Andrew Melnychenko <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | This makes it much easier to compare the multicast CRC calculation endian and | 3 | Signed-off-by: Yuri Benditovich <yuri.benditovich@daynix.com> |
| 4 | bitshift against the Linux driver implementation. | 4 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> |
| 5 | |||
| 6 | Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 5 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 8 | --- | 6 | --- |
| 9 | hw/net/rtl8139.c | 2 +- | 7 | MAINTAINERS | 8 ++++++++ |
| 10 | 1 file changed, 1 insertion(+), 1 deletion(-) | 8 | 1 file changed, 8 insertions(+) |
| 11 | 9 | ||
| 12 | diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c | 10 | diff --git a/MAINTAINERS b/MAINTAINERS |
| 13 | index XXXXXXX..XXXXXXX 100644 | 11 | index XXXXXXX..XXXXXXX 100644 |
| 14 | --- a/hw/net/rtl8139.c | 12 | --- a/MAINTAINERS |
| 15 | +++ b/hw/net/rtl8139.c | 13 | +++ b/MAINTAINERS |
| 16 | @@ -XXX,XX +XXX,XX @@ static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t | 14 | @@ -XXX,XX +XXX,XX @@ F: include/hw/remote/proxy-memory-listener.h |
| 17 | return size; | 15 | F: hw/remote/iohub.c |
| 18 | } | 16 | F: include/hw/remote/iohub.h |
| 19 | 17 | ||
| 20 | - int mcast_idx = compute_mcast_idx(buf); | 18 | +EBPF: |
| 21 | + int mcast_idx = net_crc32(buf, ETH_ALEN) >> 26; | 19 | +M: Jason Wang <jasowang@redhat.com> |
| 22 | 20 | +R: Andrew Melnychenko <andrew@daynix.com> | |
| 23 | if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7)))) | 21 | +R: Yuri Benditovich <yuri.benditovich@daynix.com> |
| 24 | { | 22 | +S: Maintained |
| 23 | +F: ebpf/* | ||
| 24 | +F: tools/ebpf/* | ||
| 25 | + | ||
| 26 | Build and test automation | ||
| 27 | ------------------------- | ||
| 28 | Build and test automation, general continuous integration | ||
| 25 | -- | 29 | -- |
| 26 | 2.7.4 | 30 | 2.7.4 |
| 27 | 31 | ||
| 28 | 32 | diff view generated by jsdifflib |