From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from out1.zte.com.cn (out1.zte.com.cn [202.103.147.172]) by dpdk.org (Postfix) with ESMTP id 72DF07CC0 for ; Thu, 24 Aug 2017 13:07:06 +0200 (CEST) X-scanvirus: By SEG_CYREN AntiVirus Engine X-scanresult: CLEAN X-MAILFROM: X-RCPTTO: X-FROMIP: 10.30.3.20 X-SEG-Scaned: 1 X-Received: unknown,10.30.3.20,20170824190241 Received: from unknown (HELO mse01.zte.com.cn) (10.30.3.20) by localhost with (AES256-SHA encrypted) SMTP; 24 Aug 2017 11:02:41 -0000 Received: from notes_smtp.zte.com.cn ([10.30.1.239]) by mse01.zte.com.cn with ESMTP id v7OB6pXk022921; Thu, 24 Aug 2017 19:06:51 +0800 (GMT-8) (envelope-from xie.rongqiang@zte.com.cn) In-Reply-To: <1632315.BKOmf88xrI@xps> References: <201706300758.v5U7wu8t037841@mse01.zte.com.cn> <5305497.JiKmSDtoNP@xps> <201708160250.v7G2o6Nb040299@mse01.zte.com.cn> <1632315.BKOmf88xrI@xps> To: Thomas Monjalon Cc: Declan Doherty , dev@dpdk.org, jingjing.wu@intel.com MIME-Version: 1.0 X-KeepSent: 0F0A74DE:083B00E8-48258186:003CA76C; type=4; name=$KeepSent X-Mailer: Lotus Notes Release 8.5.3 September 15, 2011 Message-ID: From: xie.rongqiang@zte.com.cn Date: Thu, 24 Aug 2017 19:07:25 +0800 X-MIMETrack: Serialize by Router on notes_smtp/zte_ltd(Release 9.0.1FP7|August 17, 2016) at 2017-08-24 19:06:39, Serialize complete at 2017-08-24 19:06:39 X-MAIL: mse01.zte.com.cn v7OB6pXk022921 X-HQIP: 127.0.0.1 Content-Type: text/plain; charset="GB2312" Content-Transfer-Encoding: base64 X-Content-Filtered-By: Mailman/MimeDel 2.1.15 Subject: [dpdk-dev] =?gb2312?b?tPC4tDogUmU6ICC08Li0OiBSZTogIFtQQVRDSF0g?= =?gb2312?b?YXBwL3Rlc3RwbWQ6YWRkIGJvbmQgdHlwZSBkZXNjcmlwdGlvbg==?= X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 24 Aug 2017 11:07:09 -0000 SGksDQogICBJIG1ha2UgYSBuZXcgcGF0Y2ggZm9yIHRoaXMgaXNzdWUgYmVjYXNlIHRoZSBwcmV2 aW91cyBwYXRjaCBoYXMgZGVsZXRlIA0Kd2hlbiB0aGUgdmVyc2lvbiAxNy4wOCByZWxlYXNlLg0K IA0KICAgVGhlIHdlYnNpdGUgaXMgaHR0cDovL3d3dy5kcGRrLm9yZy9kZXYvcGF0Y2h3b3JrL3Bh dGNoLzI3ODUxLyxUaGFuayANCnlvdS4NCg0KDQpUaG9tYXMgTW9uamFsb24gPHRob21hc0Btb25q YWxvbi5uZXQ+INC009ogMjAxNy8wOC8yNCAwNDoyMjoxNzoNCg0KPiC3orz+yMs6ICBUaG9tYXMg TW9uamFsb24gPHRob21hc0Btb25qYWxvbi5uZXQ+DQo+IMrVvP7IyzogIHhpZS5yb25ncWlhbmdA enRlLmNvbS5jbiwgRGVjbGFuIERvaGVydHkgDQo+IDxkZWNsYW4uZG9oZXJ0eUBpbnRlbC5jb20+ LCANCj4gs63LzTogZGV2QGRwZGsub3JnLCBqaW5namluZy53dUBpbnRlbC5jb20NCj4gyNXG2jog IDIwMTcvMDgvMjQgMDQ6MjMNCj4g1vfM4jogUmU6IFtkcGRrLWRldl0gtPC4tDogUmU6ICBbUEFU Q0hdIGFwcC90ZXN0cG1kOmFkZCBib25kIHR5cGUgDQpkZXNjcmlwdGlvbg0KPiANCj4gMTYvMDgv MjAxNyAwNDozMSwgeGllLnJvbmdxaWFuZ0B6dGUuY29tLmNuOg0KPiA+IEkgYW0gc29ycnkgdG8g cmVwbHkgc28gbGF0ZSBmb3Igc29tZSByZWFzb24uDQo+ID4gDQo+ID4gQW5kIGkgZmlndXJlIG91 dCB0d28gd2F5cyB0byBpbXBsZW1lbnQgdGhpcyBraW5kIG9mIHRoaW5ncyBpbnNpZGUgdGhlIA0K PiA+IGJvbmRpbmcgY29kZSwNCj4gPiANCj4gPiBGaXJzdCxpZiBjYW4gdGhlIGZ1bmN0aW9uIHJ0 ZV9ldGhfYm9uZF9tb2RlX2dldCgpIHJldHVybiBzdHJpbmcsIHNvIHdlIA0KY2FuIA0KPiA+IHBy aW50DQo+IA0KPiBObyBpdCBpcyBiZXR0ZXIgdG8gdXNlIGludGVnZXJzIGluIEFQSS4NCj4gDQo+ ID4gdGhlIGJvbmQgbW9kZSBzdHJhaWdodCwgYnV0IGluIHRoaXMgd2F5LCB3ZSBuZWVkIGZpeCB0 aGUgb3RoZXIgYyANCnNvdXJjZSANCj4gPiB3aGVyZSBjYWxsIHRoZSBmdW5jdGlvbi4gDQo+ID4g DQo+ID4gU2Vjb25kLCB3ZSBhZGQgYW4gaW50ZXJmYWNlIHJldHVybiBib25kIG1vZGUgc3RyaW5n LCBpbiB0aGlzIHdheSwgd2UgDQpqdXN0IA0KPiA+IGNhbGwgaXQgaW4gZnVuY3Rpb24NCj4gDQo+ IFllcyBhIG5ldyBmdW5jdGlvbiB0byBjb252ZXJ0IGludGVnZXIgdG8gc3RyaW5nIHNlZW1zIGJl dHRlci4NCj4gDQo+IEF0IHRoZSBlbmQsIERlY2xhbiBzaG91bGQgYXBwcm92ZS9kZWNpZGUuDQo+ IA0KPiA+IGNtZF9zaG93X2JvbmRpbmdfY29uZmlnX3BhcnNlZCgpLg0KPiA+IA0KPiA+IEZpbmFs bHksIHdoaWNoIHdheSBkbyB5b3UgYWdyZWUgbW9yZT8gDQo+ID4gDQo+ID4gTG9va2luZyBmb3J3 YXJkIHRvIHlvdXIgZWFybHkgcmVwbHksVGhhbmsgeW91ci4gDQo+ID4gDQo+ID4gDQo+ID4gVGhv bWFzIE1vbmphbG9uIDx0aG9tYXNAbW9uamFsb24ubmV0PiAgMjAxNy8wNy8wMyAwMjoxMTo1MjoN Cj4gPiANCj4gPiA+IDogIFRob21hcyBNb25qYWxvbiA8dGhvbWFzQG1vbmphbG9uLm5ldD4NCj4g PiA+IDogIERlY2xhbiBEb2hlcnR5IDxkZWNsYW4uZG9oZXJ0eUBpbnRlbC5jb20+LCANCj4gPiA+ IDogZGV2QGRwZGsub3JnLCBSb25nUWlhbmcgWGllIDx4aWUucm9uZ3FpYW5nQHp0ZS5jb20uY24+ LCANCj4gPiA+IGppbmdqaW5nLnd1QGludGVsLmNvbQ0KPiA+ID4gOiAgMjAxNy8wNy8wMyAwMjox Mg0KPiA+ID4gOiBSZTogW2RwZGstZGV2XSBbUEFUQ0hdIGFwcC90ZXN0cG1kOmFkZCBib25kIHR5 cGUgZGVzY3JpcHRpb24NCj4gPiA+IA0KPiA+ID4gMzAvMDYvMjAxNyAxNzozOSwgRGVjbGFuIERv aGVydHk6DQo+ID4gPiA+IE9uIDMwLzA2LzE3IDA4OjU2LCBSb25nUWlhbmcgWGllIHdyb3RlOg0K PiA+ID4gPiA+IEluIGZ1bmN0aW9uIGNtZF9zaG93X2JvbmRpbmdfY29uZmlnX3BhcnNlZCgpIHVz ZWQgbnVtYmVyIA0KcmVwcmVzZW50DQo+ID4gPiA+ID4gdGhlIGJvbmQgdHlwZSxpbiBvcmRlciBt b3JlIGRldGFpbGVkLGFkZCBib25kIHR5cGUgZGVzY3JpcHRpb24NCj4gPiA+ID4gPiBvdGhlcndp c2Ugd2UgbWF5IGNvbmZ1c2VkIGFib3V0IHRoZSBudW1iZXIgdHlwZS4NCj4gPiA+ID4gPiBBbmQg YWxzbyx0aGUgcHJpbWFyeSBwb3J0IGp1c3QgdXNlIGluIG1vZGUgYWN0aXZlIGJhY2t1cCBhbmQg DQp0bGIsDQo+ID4gPiA+ID4gc28sd2hlbiB0aGUgbW9kZSBpcyBhY3RpdmUgYmFja3VwIG9yIHRs YiBzaG93IHRoZSBwcmltYXJ5IHBvcnQgDQppbmZvDQo+ID4gPiA+ID4gbWF5IGJlIG1vcmUgYXBw cm9wcmlhdGUuDQo+ID4gPiA+ID4gDQo+ID4gPiA+ID4gU2lnbmVkLW9mZi1ieTogUm9uZ1FpYW5n IFhpZSA8eGllLnJvbmdxaWFuZ0B6dGUuY29tLmNuPg0KPiA+ID4gPiA+IC0tLQ0KPiA+ID4gPiA+ ICAgYXBwL3Rlc3QtcG1kL2NtZGxpbmUuYyB8IDE3ICsrKysrKysrKysrLS0tLS0tDQo+ID4gPiA+ ID4gICAxIGZpbGUgY2hhbmdlZCwgMTEgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkNCj4g PiA+ID4gPiANCj4gPiA+ID4gPiBkaWZmIC0tZ2l0IGEvYXBwL3Rlc3QtcG1kL2NtZGxpbmUuYyBi L2FwcC90ZXN0LXBtZC9jbWRsaW5lLmMNCj4gPiA+ID4gPiBpbmRleCBmZjhmZmQyLi40NTg0NWE0 IDEwMDY0NA0KPiA+ID4gPiA+IC0tLSBhL2FwcC90ZXN0LXBtZC9jbWRsaW5lLmMNCj4gPiA+ID4g PiArKysgYi9hcHAvdGVzdC1wbWQvY21kbGluZS5jDQo+ID4gPiA+ID4gQEAgLTQzOTAsNyArNDM5 MCw5IEBAIHN0YXRpYyB2b2lkIGNtZF9zaG93X2JvbmRpbmdfY29uZmlnX3BhcnNlZA0KPiA+ID4g KHZvaWQgKnBhcnNlZF9yZXN1bHQsDQo+ID4gPiA+ID4gICAgICAgICBwcmludGYoIlx0RmFpbGVk IHRvIGdldCBib25kaW5nIG1vZGUgZm9yIHBvcnQgPSAlZFxuIiwgDQo+ID4gcG9ydF9pZCk7DQo+ ID4gPiA+ID4gICAgICAgICByZXR1cm47DQo+ID4gPiA+ID4gICAgICB9IGVsc2UNCj4gPiA+ID4g PiAtICAgICAgcHJpbnRmKCJcdEJvbmRpbmcgbW9kZTogJWRcbiIsIGJvbmRpbmdfbW9kZSk7DQo+ ID4gPiA+ID4gKyAgICAgIHByaW50ZigiXHRCb25kaW5nIG1vZGU6ICVkICIsIGJvbmRpbmdfbW9k ZSk7DQo+ID4gPiA+ID4gKyAgIHByaW50ZigiWzA6Um91bmQgUm9iaW4sIDE6QWN0aXZlIEJhY2t1 cCwgMjpCYWxhbmNlLCANCjM6QnJvYWRjYXN0LCANCj4gPiAiKTsNCj4gPiA+ID4gPiArICAgcHJp bnRmKCJcblx0XHRcdDQ6ODAyLjNBRCwgNTpBZGFwdGl2ZSBUTEIsIDY6QWRhcHRpdmUgTG9hZCAN Cj4gPiA+IEJhbGFuY2luZ11cbiIpOw0KPiA+ID4gPiA+IA0KPiA+ID4gPiANCj4gPiA+ID4gR29v ZCBpZGVhLCBidXQgaXQgd291bGQgYmUgY2xlYXJlciBpZiB3ZSBqdXN0IHJldHVybmVkIHRoZSBh Y3R1YWwgDQptb2RlIA0KPiA+IA0KPiA+ID4gPiBzdHJpbmcgc28gdGhlIHVzZXIgZG9lc24ndCBu ZWVkIHRvIHBhcnNlIGl0IHRoZW1zZWx2ZXMsIGxpa2UgDQpiZWxvdy4NCj4gPiA+ID4gDQo+ID4g PiA+IC0gICAgICAgfSBlbHNlDQo+ID4gPiA+IC0gICAgICAgICAgICAgICBwcmludGYoIlx0Qm9u ZGluZyBtb2RlOiAlZCAiLCBib25kaW5nX21vZGUpOw0KPiA+ID4gPiAtICAgICAgIHByaW50Zigi WzA6Um91bmQgUm9iaW4sIDE6QWN0aXZlIEJhY2t1cCwgMjpCYWxhbmNlLCANCj4gPiAzOkJyb2Fk Y2FzdCwgIik7DQo+ID4gPiA+IC0gICAgICAgcHJpbnRmKCJcblx0XHRcdDQ6ODAyLjNBRCwgNTpB ZGFwdGl2ZSBUTEIsIDY6QWRhcHRpdmUgTG9hZCANCg0KPiA+ID4gPiBCYWxhbmNpbmddXG4iKTsN Cj4gPiA+ID4gKyAgICAgICB9DQo+ID4gPiA+ICsNCj4gPiA+ID4gKyAgICAgICBwcmludGYoIlx0 Qm9uZGluZyBtb2RlOiAlZCAoIiwgYm9uZGluZ19tb2RlKTsNCj4gPiA+ID4gKyAgICAgICBzd2l0 Y2ggKGJvbmRpbmdfbW9kZSkgew0KPiA+ID4gPiArICAgICAgIGNhc2UgQk9ORElOR19NT0RFX1JP VU5EX1JPQklOOg0KPiA+ID4gPiArICAgICAgICAgICAgICAgcHJpbnRmKCJyb3VuZC1yb2JpbiIp Ow0KPiA+ID4gPiArICAgICAgICAgICAgICAgYnJlYWs7DQo+ID4gPiA+ICsgICAgICAgY2FzZSBC T05ESU5HX01PREVfQUNUSVZFX0JBQ0tVUDoNCj4gPiA+ID4gKyAgICAgICAgICAgICAgIHByaW50 ZigiYWN0aXZlLWJhY2t1cCIpOw0KPiA+ID4gPiArICAgICAgICAgICAgICAgYnJlYWs7DQo+ID4g PiA+ICsgICAgICAgY2FzZSBCT05ESU5HX01PREVfQkFMQU5DRToNCj4gPiA+ID4gKyAgICAgICAg ICAgICAgIHByaW50ZigibGluay1hZ2dyZWdhdGlvbiIpOw0KPiA+ID4gPiArICAgICAgICAgICAg ICAgYnJlYWs7DQo+ID4gPiA+ICsgICAgICAgY2FzZSBCT05ESU5HX01PREVfQlJPQURDQVNUOg0K PiA+ID4gPiArICAgICAgICAgICAgICAgcHJpbnRmKCJicm9hZGNhc3QiKTsNCj4gPiA+ID4gKyAg ICAgICAgICAgICAgIGJyZWFrOw0KPiA+ID4gPiArICAgICAgIGNhc2UgQk9ORElOR19NT0RFXzgw MjNBRDoNCj4gPiA+ID4gKyAgICAgICAgICAgICAgIHByaW50ZigibGluay1hZ2dyZWdhdGlvbi04 MDIuM2FkIik7DQo+ID4gPiA+ICsgICAgICAgICAgICAgICBicmVhazsNCj4gPiA+ID4gKyAgICAg ICBjYXNlIEJPTkRJTkdfTU9ERV9UTEI6DQo+ID4gPiA+ICsgICAgICAgICAgICAgICBwcmludGYo InRyYW5zbWl0LWxvYWQtYmFsYW5jaW5nIik7DQo+ID4gPiA+ICsgICAgICAgICAgICAgICBicmVh azsNCj4gPiA+ID4gKyAgICAgICBjYXNlIEJPTkRJTkdfTU9ERV9BTEI6DQo+ID4gPiA+ICsgICAg ICAgICAgICAgICBwcmludGYoImFkYXB0aXZlLWxvYWQtYmFsYW5jaW5nIik7DQo+ID4gPiA+ICsg ICAgICAgICAgICAgICBicmVhazsNCj4gPiA+ID4gKyAgICAgICBkZWZhdWx0Og0KPiA+ID4gPiAr ICAgICAgICAgICAgICAgcHJpbnRmKCJ1bmtub3duLW1vZGUiKTsNCj4gPiA+ID4gKyAgICAgICB9 DQo+ID4gPiA+ICsgICAgICAgcHJpbnRmKCIpXG4iKTsNCj4gPiA+IA0KPiA+ID4gSSB3b3VsZCBz YXkgbm8uDQo+ID4gPiBDYW4gd2UgdGhpbmsgaG93IHRvIGltcGxlbWVudCB0aGlzIGtpbmQgb2Yg dGhpbmdzIGluc2lkZSB0aGUgYm9uZGluZyANCg0KPiA+IGNvZGU/DQo+ID4gPiANCj4gPiA+IA0K PiA+IA0KPiANCj4gDQo+IA0KPiANCg0K >From orika@mellanox.com Thu Aug 24 13:53:26 2017 Return-Path: Received: from EUR01-VE1-obe.outbound.protection.outlook.com (mail-ve1eur01on0089.outbound.protection.outlook.com [104.47.1.89]) by dpdk.org (Postfix) with ESMTP id 89C0E7D24 for ; Thu, 24 Aug 2017 13:53:26 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=xyPtCiVQHr4F2Jj4G8yf3zTFsFs3ZdeSsgRO/oBp130=; b=bSrLgUPJW6h14DsrQqLuSDu/AgkfgpRTpwSBtbBD0oskWmv+zlOibs+JnonufAGHBPDb5u52VTboTNxFQbqIrtWWM4EOVqwr7U/VK/Nx9SyGWiuOFIVKY3neQ3wdw/gCqDHhbqFAoQ00NfiDNeyNUFjaoD4s/1E+dIPDSH+CcKo= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=orika@mellanox.com; Received: from localhost.localdomain (82.166.227.17) by HE1PR05MB3212.eurprd05.prod.outlook.com (2603:10a6:7:35::10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.1.1362.18; Thu, 24 Aug 2017 11:53:15 +0000 From: Ori Kam To: dev@dpdk.org Cc: thomas@monjalon.net, orika@mellanox.com Date: Thu, 24 Aug 2017 14:52:28 +0300 Message-Id: <1503575548-3025-1-git-send-email-orika@mellanox.com> X-Mailer: git-send-email 1.7.1 MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [82.166.227.17] X-ClientProxiedBy: AM5PR0502CA0021.eurprd05.prod.outlook.com (2603:10a6:203:91::31) To HE1PR05MB3212.eurprd05.prod.outlook.com (2603:10a6:7:35::10) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: c8bd1b39-29a5-4984-dfee-08d4eae6b492 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(2017030254152)(300000503095)(300135400095)(48565401081)(201703131423075)(201703031133081)(201702281549075)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:HE1PR05MB3212; X-Microsoft-Exchange-Diagnostics: 1; HE1PR05MB3212; 3:IF+m7s8pwM+X6myyPwjkGlD5fuhbVhgvXqGauJmB3JZebePEZs8p92A9Ti7DFvRCM9SKH1+kzd6QkaGonga3iokhGaFSc4OIygdlziHz7xuP0501TWh2c3v2NM+MGhV4JQbyWnYQT7JNXkWw0DmQxnhslvhl1yqZBPbq8FjtKuGA9EBH1ZNEufTB6VPz2AzB3cWTHzTa2SCHbcWNlvg87B+HoX4aKiCd84aYXmfJOC+PHuuyhIQERU+92JCpijw1; 25:ZrooMrjGz+lBEqqO2Vjwu5/FndF4TnNshTxsgG/C2fllvpDbOVLwUPPmSBZI+QByv8xLER0lliJ2AgL1ZTFKidfCkG9J4LyDxms1kRuvpvHwj35HlrDP90DjghVFdI4qVJQxc9MmJc26WOECy+V8EvBr/xyperIW/UORhyGYwJl1HHZMCfJ2XViUvvqGmJsSx3XRwFRdfxN/WuQnvALpdxBPYw+VxC60F4F83/n66TDTPcoafnSGfdhnfqP85AgzW5USPwLP79OzsTMBXO3GQMNvDEF6R9DX4tjJFv4MXX6TZyX1M/1135eHCYTtSkB26Ktwk1s9Wk5YVtSwqG9vjQ==; 31:U9AnQS5usEPoUfSIVzsQ4hDSjBUPVfS5tTBLFBcKjtI+JKW/JfA1+05/kJsgWxDR03IXqzdS5dAWomrH7PSA+8vMx8NSGvXOYid3onbDzIu0aOJ/LzuOREeX/EZLbuHt5uobJOU0VZ3BAbzH17egmhXn8e/PKXBOsVUlBI/jcAA5ai2jiMDJATk4EbVozp36n+0JYSocblEpFuZVZ6KzW3boe45DIyhFnzqyoj6vMMY= X-MS-TrafficTypeDiagnostic: HE1PR05MB3212: X-LD-Processed: a652971c-7d2e-4d9b-a6a4-d149256f461b,ExtAddr X-Microsoft-Exchange-Diagnostics: 1; HE1PR05MB3212; 20:KI2Ig4GqkGybKkmgBwy9YhXRoajOHiz4iZOBjpd2/6w8NTzuaJ9RLt8oEVybzcnyq4W8hkl39fhKgCliLR/zT7TkSKJZbh22jxK0neXbUHPodevaJsrzunoIhQAoelqxlhDGDs6XMN8vIHa4RW3ldormdjZjIb4eNNEoB/8eMo4IqL+bShIG2Q0yNjBETZyu1cqXdYTp55ZaEtYX0Pgg6Seo+JHhbcDuJg92S8IZb1pCoMqbwr29QqVVGI3Ph5UKphc1O0Kkl0zsoAQhAd9Zoc+kDwTpqk2JHY7N8yZIWpGPP6R5gJumVS3A8EOh+wBa1KEH1jfRIXvyp6h0kU1LLGnYcTF134uQzLawJ2GbnsZiJ9yz/vLzRn8Nc5eaP1Zlv25PsGdqtCKXauzgLqxX5qM2d2GaOgsb98UATCTVLtXkU7v3ccK4yqLBulE0rXvLXacUkHPamsE67SGKgt93+iHdMKswMpxOUx3tq88Jip+CMWJFlVMoV0gkGfxsK8xP; 4:TVY6KkR9QndGJeZ1R9dih49O+GfiWvVTJel+auH9AjVu3bAc0hRN9dORz4EgEf2gF4Org1zQdU9PBILQ1HQmUnu+VAZ7vF75rT4si/T8aKS+vIf8U7CgDi2XVokNtcaEs097ntxXZYjvmRINUv6LJfkPbCN2MPCJ3l9OnvDEIJEYexVV9PJWTiGiBz+3+lwhGctJmTrkWFTHIlhC5uMlxREtS/ap+7H4hU1NRDzV/UnjUvmkJZnNkIXG6kyOBHnwPOIybYpTNE2YGMNID+uZjY0HlUpJN06gDIEIDGHe8uo= X-Exchange-Antispam-Report-Test: UriScan:(116097685857584); X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(601004)(2401047)(8121501046)(5005006)(100000703101)(100105400095)(10201501046)(3002001)(93006095)(93001095)(6055026)(6041248)(20161123555025)(20161123560025)(20161123558100)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123562025)(20161123564025)(6072148)(201708071742011)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:HE1PR05MB3212; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:HE1PR05MB3212; X-Forefront-PRVS: 04097B7F7F X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(7370300001)(4630300001)(6009001)(6069001)(39860400002)(199003)(189002)(101416001)(81166006)(5660300001)(6116002)(189998001)(6506006)(68736007)(81156014)(4326008)(50226002)(36756003)(478600001)(33646002)(8676002)(6486002)(97736004)(6916009)(50986999)(25786009)(6666003)(48376002)(50466002)(6512007)(575784001)(86362001)(66066001)(7350300001)(5003940100001)(47776003)(3846002)(42186005)(7736002)(2361001)(53936002)(2906002)(105586002)(2351001)(107886003)(106356001)(110136004)(305945005); DIR:OUT; SFP:1101; SCL:1; SRVR:HE1PR05MB3212; H:localhost.localdomain; FPR:; SPF:None; PTR:InfoNoRecords; A:1; MX:1; LANG:en; Received-SPF: None (protection.outlook.com: mellanox.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; HE1PR05MB3212; 23:ckY28fdD81wpFvACu1tS4gM4wRDypjvU9fuzTY4PG?= =?us-ascii?Q?iQIGiFtoTYNA5/6fFddQZ7oG407imXmZUCMpyW+rlcCk0JKKiPCVrQGxbval?= =?us-ascii?Q?Ax8oyvPwQVPL1fHpjk65aoToNQoqSM/dqZyO0iaMwGi/fscm9bkeWu1HJhij?= =?us-ascii?Q?3puYRTyhMzyIfWiQjyYLcB/fXqT69GcZZsRbffdhqAVOrMfjPoudTuAcVQMG?= =?us-ascii?Q?cpNnYqQF7R7o3x86xvnqWrcthE6EBfTn1YY0uDlMB8AqeIY010jLodjdAqu6?= =?us-ascii?Q?gAxw7xmn1F+r4KDrDJZ8G7WTk2yRT4Hl6ECdl61Fca6lUFR+5+Uy4JRO1R3M?= =?us-ascii?Q?5cnj/ZYz0Fb/s3exhlfI+AirPJuTRSJ4EK5STo/BqmjnmTWjPjcr0ocgCRfp?= =?us-ascii?Q?28V2j++9qi9Eq5kSYBLf+mfJX8kHWYLoTC3yWKi8Q7tRsLsAhxvDBCIkbFHG?= =?us-ascii?Q?CNXFaJP0a/XempqgwhaokZgZqP02Qx/Bba56WH6TWcWZzTtE2EpGVSHFd7YF?= =?us-ascii?Q?XTu15vgwgU0GXYXRt1faegLnkf3zWIAQ3WxqHFh9t2NybwmDKcO/t0Pj7cw4?= =?us-ascii?Q?0QksyNDJTH89ClOs02qE9fVImw+Y1mO2mVGj58L/98BL7Oo2OYQ/NNHx6XOw?= =?us-ascii?Q?x/vkB46zxSVeB8JPD49I9jkN2c8pwt+v0NEjXWgWxrmpYpgK5mWovVQsGfv5?= =?us-ascii?Q?ytK/f5MG0Fw3nFrD2SaGdghqXD2Us8mORGd1UbQXwJ+SYyh+KDJ2H2MqEPKC?= =?us-ascii?Q?SiM/5LkzXOdopx3Vpst1SuGfcXqAEAjlR4GVNrZAwtJhyJS7EbhLrQeJhnYy?= =?us-ascii?Q?qQ9aFauMwgsG8kwrkNzsMj/7hF8FLeQleEzkfjkxXE7EzY7cAU9g+EAVsv3P?= =?us-ascii?Q?bGKtIjvNmwqeJmt9jdVDaE8rTvObGwfO8f/Qp3JIjbbInITOfZpH1fPTjskI?= =?us-ascii?Q?/Jw2QnxrVuh4ixsP4AJI/DxIaL1WHdCbHGZWrziO0Dysmnd0tVic1sgQBYtk?= =?us-ascii?Q?nAx/Ga5KxhbDb1QdEEKZ0dJDmfrcIzkohxClEGy+/AuDYtT8iINr1JwGa1dX?= =?us-ascii?Q?OHGImRm+kfp8qr6kFZThZew5o9hTkHR/pJK5nsQDcHKp3nwXtyOtz/x2SM3A?= =?us-ascii?Q?eiI5/j66osN3CA/rqF9/znnVrRGOTwUene9qLS5zNS/ybFjd7SYFQ=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; HE1PR05MB3212; 6:bzE/lZ7PSCQvQoj7WsLa3lg28DowpfDLm+sSZ6VvGN4CSnhprsFKc1nXgr8Q7hu8CC15nev9KkaL4NOT6a68e6Q5DT2la7Yyg1/QNIFOSIiwM4v9r4DAFDOPPlB8rd61QVSorBgntLVWht/E8ql1AgrnEPtVkWIK/lT9cgvhMC+KjYStQBI4yC9FcDb4bmUr8BcKSPqPulgoxe892byUpPlK6w/aqOzBz/KlNNiQFB5d5ydPV0VaprWWKyRnEl8V+CQJAwqCRZ0CEgQYB1acrG4JQZ3fzID8/YDy4KhHxUtIwicl9MRF0bsBFDh/9Q5ONaBUpp7Q9khHxqxufQn2sg==; 5:scYzGC1dJZceLdTYuvq76baa7UsHFuwivb1C/xVVZ/q0aVodFIASJUbjJMoiZ5GTUzBYHyfHwbRs62uY4rCB3UphHQtrifcVRhx9o6uawPu6+w/ruXzHqbXxFXN+u+SdIPJOY2B1Pe5o9bH54YebOGe2c1t+JFe2AmQFiiHGPTk=; 24:V4S/KKvBI9h6CzVG8xKDQOsh+jDPTZQOxTsLKogV3WUtXpQ7Mz+CakkYQ7vbmAfO4vBuRolvixHP6BxuxwKWvOTTjsbtHD8z58r1zEc3mZ0=; 7:JbMkEPwtfmZ4cs59fHr2DSjtbIxfOdj719mVhGJmqVXYn14DlmimysXTeK5vbGqGlioPhnMslTDZZ3W1Eod/R05hXOn+aByv9kiz4VphajSCwUqAxPkSZFDU/BclvAnT+kfF6yflGAovt0SDNUDxisMF6Ar7SH95OonnnWtdN37u8k4hxq/JY2OpkTGOyFWPAjLlOukV+dLOoHMnSEAVf6JcXzeDBUK8mL595v+bgBc= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 24 Aug 2017 11:53:15.3047 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: HE1PR05MB3212 Subject: [dpdk-dev] [RFC v1] examples/flow_filtering: demo of simple rte flow X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 24 Aug 2017 11:53:26 -0000 This application shows a simple usage of the rte_flow API for hardware filtering offloading. In this demo we are filtering specific IP to specific target queue, while sending all the rest of the packets to other queue. Included in this commit is a simple python script file for sending custom packets. Signed-off-by: Ori Kam --- examples/flow_filtering/Makefile | 17 ++ examples/flow_filtering/flow_blocks.c | 122 +++++++++++++++ examples/flow_filtering/main.c | 233 ++++++++++++++++++++++++++++ examples/flow_filtering/test-flowy.scapy.py | 28 ++++ 4 files changed, 400 insertions(+) create mode 100644 examples/flow_filtering/Makefile create mode 100644 examples/flow_filtering/flow_blocks.c create mode 100644 examples/flow_filtering/main.c create mode 100755 examples/flow_filtering/test-flowy.scapy.py diff --git a/examples/flow_filtering/Makefile b/examples/flow_filtering/Makefile new file mode 100644 index 0000000..6e5295d --- /dev/null +++ b/examples/flow_filtering/Makefile @@ -0,0 +1,17 @@ +ifeq ($(RTE_SDK),) +$(error "Please define RTE_SDK environment variable") +endif + +# Default target, can be overridden by command line or environment +RTE_TARGET ?= x86_64-native-linuxapp-gcc + +include $(RTE_SDK)/mk/rte.vars.mk + +APP = flow + +SRCS-y := main.c + +CFLAGS += -g3 +CFLAGS += $(WERROR_FLAGS) + +include $(RTE_SDK)/mk/rte.extapp.mk diff --git a/examples/flow_filtering/flow_blocks.c b/examples/flow_filtering/flow_blocks.c new file mode 100644 index 0000000..cb8b06d --- /dev/null +++ b/examples/flow_filtering/flow_blocks.c @@ -0,0 +1,122 @@ +/*- + * BSD LICENSE + * + * Copyright 2017 Mellanox. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of 6WIND S.A. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#define MAX_PATTERN_NUM 4 + + +static struct rte_flow * +generate_ipv4_rule(uint8_t port_id, uint16_t rx_q, + uint32_t src_ip, uint32_t src_mask, + uint32_t dest_ip, uint32_t dest_mask) +{ + struct rte_flow_attr attr; + struct rte_flow_item pattern[MAX_PATTERN_NUM]; + struct rte_flow_action action[MAX_PATTERN_NUM]; + struct rte_flow *flow; + struct rte_flow_error error; + + memset(pattern, 0, sizeof(pattern)); + memset(action, 0, sizeof(action)); + + /* + * create the action sequence. + * one action only, move packet to queue + */ + struct rte_flow_action_queue queue = { .index = rx_q }; + + action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE; + action[0].conf = &queue; + + action[1].type = RTE_FLOW_ACTION_TYPE_END; + + /* + * set the rule attribute. + * in this case only ingress packets will be checked. + */ + memset(&attr, 0, sizeof(struct rte_flow_attr)); + attr.ingress = 1; + + /* + * set the first level of the pattern (eth). + * since in this example we just want to get the + * ipv4 we set this level to allow all. + */ + struct rte_flow_item_eth eth_spec; + struct rte_flow_item_eth eth_mask; + memset(ð_spec, 0, sizeof(struct rte_flow_item_eth)); + memset(ð_mask, 0, sizeof(struct rte_flow_item_eth)); + eth_spec.type = 0; + eth_mask.type = 0; + pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH; + pattern[0].spec = ð_spec; + pattern[0].mask = ð_mask; + + /* + * setting the second level of the pattern (vlan). + * since in this example we just want to get the + * ipv4 we also set this level to allow all. + */ + struct rte_flow_item_vlan vlan_spec; + struct rte_flow_item_vlan vlan_mask; + memset(&vlan_spec, 0, sizeof(struct rte_flow_item_vlan)); + memset(&vlan_mask, 0, sizeof(struct rte_flow_item_vlan)); + pattern[1].type = RTE_FLOW_ITEM_TYPE_VLAN; + pattern[1].spec = &vlan_spec; + pattern[1].mask = &vlan_mask; + + /* + * setting the third level of the pattern (ip). + * in this example this is the level we care about + * so we set it according to the parameters. + */ + struct rte_flow_item_ipv4 ip_spec; + struct rte_flow_item_ipv4 ip_mask; + memset(&ip_spec, 0, sizeof(struct rte_flow_item_ipv4)); + memset(&ip_mask, 0, sizeof(struct rte_flow_item_ipv4)); + ip_spec.hdr.dst_addr = htonl(dest_ip); + ip_mask.hdr.dst_addr = dest_mask; + ip_spec.hdr.src_addr = htonl(src_ip); + ip_mask.hdr.src_addr = src_mask; + pattern[2].type = RTE_FLOW_ITEM_TYPE_IPV4; + pattern[2].spec = &ip_spec; + pattern[2].mask = &ip_mask; + + /* the final level must be always type end */ + pattern[3].type = RTE_FLOW_ITEM_TYPE_END; + + int res = rte_flow_validate(port_id, &attr, pattern, action, &error); + printf("\nrule validation result = %d\n", res); + flow = rte_flow_create(port_id, &attr, pattern, action, &error); + + return flow; +} + diff --git a/examples/flow_filtering/main.c b/examples/flow_filtering/main.c new file mode 100644 index 0000000..733d008 --- /dev/null +++ b/examples/flow_filtering/main.c @@ -0,0 +1,233 @@ +/*- + * BSD LICENSE + * + * Copyright 2017 Mellanox. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of 6WIND S.A. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static volatile bool force_quit; + +static uint8_t port_id; +static uint16_t nr_queues = 5; +static uint8_t selected_queue = 1; +struct rte_mempool *mbuf_pool; + +#include "flow_blocks.c" + +static inline void +print_ether_addr(const char *what, struct ether_addr *eth_addr) +{ + char buf[ETHER_ADDR_FMT_SIZE]; + ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr); + printf("%s%s", what, buf); +} + +static void +main_loop(void) +{ + struct rte_mbuf *mbufs[32]; + struct ether_hdr *eth_hdr; + uint16_t nb_rx; + uint16_t i; + uint16_t j; + + while (!force_quit) { + for (i = 0; i < nr_queues; i++) { + nb_rx = rte_eth_rx_burst(port_id, + i, mbufs, 32); + if (nb_rx) { + for (j = 0; j < nb_rx; j++) { + struct rte_mbuf *m = mbufs[j]; + + eth_hdr = rte_pktmbuf_mtod(m, + struct ether_hdr *); + print_ether_addr("src=", + ð_hdr->s_addr); + print_ether_addr(" - dst=", + ð_hdr->d_addr); + printf(" - queue=0x%x", + (unsigned int)i); + printf("\n"); + + rte_pktmbuf_free(m); + } + } + } + } + + /* closing and releasing resources */ + rte_eth_dev_stop(port_id); + rte_eth_dev_close(port_id); +} + +static void +assert_link_status(void) +{ + struct rte_eth_link link; + + memset(&link, 0, sizeof(link)); + rte_eth_link_get(port_id, &link); + if (link.link_status == ETH_LINK_DOWN) + rte_exit(EXIT_FAILURE, ":: error: link is still down\n"); +} + +static void +init_port(void) +{ + int ret; + uint16_t i; + struct rte_eth_conf port_conf = { + .rxmode = { + .split_hdr_size = 0, + /**< Header Split disabled */ + .header_split = 0, + /**< IP checksum offload disabled */ + .hw_ip_checksum = 0, + /**< VLAN filtering disabled */ + .hw_vlan_filter = 0, + /**< Jumbo Frame Support disabled */ + .jumbo_frame = 0, + /**< CRC stripped by hardware */ + .hw_strip_crc = 1, + }, + }; + + printf(":: initializing port: %d\n", port_id); + ret = rte_eth_dev_configure(port_id, + nr_queues, nr_queues, &port_conf); + if (ret < 0) { + rte_exit(EXIT_FAILURE, + ":: cannot configure device: err=%d, port=%u\n", + ret, port_id); + } + + /* only set Rx queues: something we care only so far */ + for (i = 0; i < nr_queues; i++) { + ret = rte_eth_rx_queue_setup(port_id, i, 512, + rte_eth_dev_socket_id(port_id), + NULL, + mbuf_pool); + if (ret < 0) { + rte_exit(EXIT_FAILURE, + ":: Rx queue setup failed: err=%d, port=%u\n", + ret, port_id); + } + } + + /* + * create rule for send packet with + * destination ip = 192.168.1.1 to queue number 1 + */ + generate_ipv4_rule(port_id, selected_queue, + 0x0, 0x0, + 0xc0a80101, 0xffffffff); + + rte_eth_promiscuous_enable(port_id); + + ret = rte_eth_dev_start(port_id); + if (ret < 0) { + rte_exit(EXIT_FAILURE, + "rte_eth_dev_start:err=%d, port=%u\n", + ret, port_id); + } + + assert_link_status(); + + printf(":: initializing port: %d done\n", port_id); +} + +static void +signal_handler(int signum) +{ + if (signum == SIGINT || signum == SIGTERM) { + printf("\n\nSignal %d received, preparing to exit...\n", + signum); + force_quit = true; + } +} + +int +main(int argc, char **argv) +{ + int ret; + uint8_t nr_ports; + + ret = rte_eal_init(argc, argv); + if (ret < 0) + rte_exit(EXIT_FAILURE, ":: invalid EAL arguments\n"); + + force_quit = false; + signal(SIGINT, signal_handler); + signal(SIGTERM, signal_handler); + + nr_ports = rte_eth_dev_count(); + if (nr_ports == 0) + rte_exit(EXIT_FAILURE, ":: no Ethernet ports found\n"); + port_id = 0; + if (nr_ports != 1) { + printf(":: warn: %d ports detected, but we use only one: port %u\n", + nr_ports, port_id); + } + mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", 4096, 128, 0, + RTE_MBUF_DEFAULT_BUF_SIZE, + rte_socket_id()); + if (mbuf_pool == NULL) + rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n"); + + init_port(); + + main_loop(); + + return 0; +} diff --git a/examples/flow_filtering/test-flowy.scapy.py b/examples/flow_filtering/test-flowy.scapy.py new file mode 100755 index 0000000..46758ed --- /dev/null +++ b/examples/flow_filtering/test-flowy.scapy.py @@ -0,0 +1,28 @@ +#!/usr/bin/python + +import sys +import getopt +from scapy.all import * + +def main(argv): + interface_id = None + + try: + opts, args = getopt.getopt(argv,"hi:",["interface="]) + except getopt.GetoptError: + print('test-flowy.scapy.py -i ') + sys.exit(2) + for opt, arg in opts: + if opt == '-i': + interface_id = arg + if interface_id == None: + print('test-flowy.scapy.py -i ') + sys.exit(2) + + for i in range (1, 7): + ip = "192.168.1." + str(i) + p = Ether(src="02:00:00:01:02:3" + str(i), dst="24:8a:07:8d:ae:ae")/Dot1Q(vlan = 0x123)/IP(dst = ip) + sendp(p, iface = interface_id, count=1) + +if __name__ == "__main__": + main(sys.argv[1:]) -- 1.8.3.1