From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 96F48C433DB for ; Tue, 12 Jan 2021 03:42:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 51552225AC for ; Tue, 12 Jan 2021 03:42:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727610AbhALDmA (ORCPT ); Mon, 11 Jan 2021 22:42:00 -0500 Received: from mx21.baidu.com ([220.181.3.85]:53948 "EHLO baidu.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726343AbhALDmA (ORCPT ); Mon, 11 Jan 2021 22:42:00 -0500 X-Greylist: delayed 1858 seconds by postgrey-1.27 at vger.kernel.org; Mon, 11 Jan 2021 22:41:58 EST Received: from BC-Mail-Ex31.internal.baidu.com (unknown [172.31.51.25]) by Forcepoint Email with ESMTPS id D0BEE5127D500165F05B; Tue, 12 Jan 2021 10:54:15 +0800 (CST) Received: from BJHW-Mail-Ex15.internal.baidu.com (10.127.64.38) by BC-Mail-Ex31.internal.baidu.com (172.31.51.25) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.2044.4; Tue, 12 Jan 2021 10:54:15 +0800 Received: from BJHW-Mail-Ex15.internal.baidu.com ([100.100.100.38]) by BJHW-Mail-Ex15.internal.baidu.com ([100.100.100.38]) with mapi id 15.01.2106.006; Tue, 12 Jan 2021 10:54:15 +0800 From: "Li,Rongqing" To: Alexander Duyck CC: Netdev , intel-wired-lan , =?utf-8?B?QmrDtnJuIFTDtnBlbA==?= Subject: RE: [PATCH] igb: avoid premature Rx buffer reuse Thread-Topic: [PATCH] igb: avoid premature Rx buffer reuse Thread-Index: AQHW6Fvbto35lVctrkuLVJL42A+U1qojSruA Date: Tue, 12 Jan 2021 02:54:15 +0000 Message-ID: <65a7da2dc20c4fa5b69270f078026100@baidu.com> References: <1609990905-29220-1-git-send-email-lirongqing@baidu.com> In-Reply-To: Accept-Language: zh-CN, en-US Content-Language: zh-CN X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [172.22.198.23] Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogQWxleGFuZGVyIER1eWNr IFttYWlsdG86YWxleGFuZGVyLmR1eWNrQGdtYWlsLmNvbV0NCj4gU2VudDogVHVlc2RheSwgSmFu dWFyeSAxMiwgMjAyMSA0OjU0IEFNDQo+IFRvOiBMaSxSb25ncWluZyA8bGlyb25ncWluZ0BiYWlk dS5jb20+DQo+IENjOiBOZXRkZXYgPG5ldGRldkB2Z2VyLmtlcm5lbC5vcmc+OyBpbnRlbC13aXJl ZC1sYW4NCj4gPGludGVsLXdpcmVkLWxhbkBsaXN0cy5vc3Vvc2wub3JnPjsgQmrDtnJuIFTDtnBl bCA8Ympvcm4udG9wZWxAaW50ZWwuY29tPg0KPiBTdWJqZWN0OiBSZTogW1BBVENIXSBpZ2I6IGF2 b2lkIHByZW1hdHVyZSBSeCBidWZmZXIgcmV1c2UNCj4gDQo+IE9uIFdlZCwgSmFuIDYsIDIwMjEg YXQgNzo1MyBQTSBMaSBSb25nUWluZyA8bGlyb25ncWluZ0BiYWlkdS5jb20+IHdyb3RlOg0KPiA+ DQo+ID4gVGhlIHBhZ2UgcmVjeWNsZSBjb2RlLCBpbmNvcnJlY3RseSwgcmVsaWVkIG9uIHRoYXQg YSBwYWdlIGZyYWdtZW50DQo+ID4gY291bGQgbm90IGJlIGZyZWVkIGluc2lkZSB4ZHBfZG9fcmVk aXJlY3QoKS4gVGhpcyBhc3N1bXB0aW9uIGxlYWRzIHRvDQo+ID4gdGhhdCBwYWdlIGZyYWdtZW50 cyB0aGF0IGFyZSB1c2VkIGJ5IHRoZSBzdGFjay9YRFAgcmVkaXJlY3QgY2FuIGJlDQo+ID4gcmV1 c2VkIGFuZCBvdmVyd3JpdHRlbi4NCj4gPg0KPiA+IFRvIGF2b2lkIHRoaXMsIHN0b3JlIHRoZSBw YWdlIGNvdW50IHByaW9yIGludm9raW5nIHhkcF9kb19yZWRpcmVjdCgpLg0KPiA+DQo+ID4gRml4 ZXM6IDljYmM5NDhiNWEyMCAoImlnYjogYWRkIFhEUCBzdXBwb3J0IikNCj4gPiBTaWduZWQtb2Zm LWJ5OiBMaSBSb25nUWluZyA8bGlyb25ncWluZ0BiYWlkdS5jb20+DQo+ID4gQ2M6IEJqw7ZybiBU w7ZwZWwgPGJqb3JuLnRvcGVsQGludGVsLmNvbT4NCj4gDQo+IEknbSBub3Qgc3VyZSB3aGF0IHlv dSBhcmUgdGFsa2luZyBhYm91dCBoZXJlLiBXZSBhbGxvdyBmb3IgYSAwIHRvIDEgY291bnQNCj4g ZGlmZmVyZW5jZSBpbiB0aGUgcGFnZWNvdW50IGJpYXMuIFRoZSBpZGVhIGlzIHRoZSBkcml2ZXIg c2hvdWxkIGJlIGhvbGRpbmcgb250bw0KPiBhdCBsZWFzdCBvbmUgcmVmZXJlbmNlIGZyb20gdGhl IGRyaXZlciBhdCBhbGwgdGltZXMuDQo+IEFyZSB5b3Ugc2F5aW5nIHRoYXQgaXMgbm90IHRoZSBj YXNlPw0KPiANCj4gQXMgZmFyIGFzIHRoZSBjb2RlIGl0c2VsZiB3ZSBob2xkIG9udG8gdGhlIHBh Z2UgYXMgbG9uZyBhcyBvdXIgZGlmZmVyZW5jZSBkb2VzDQo+IG5vdCBleGNlZWQgMS4gU28gc3Bl Y2lmaWNhbGx5IGlmIHRoZSBYRFAgY2FsbCBpcyBmcmVlaW5nIHRoZSBwYWdlIHRoZSBwYWdlIGl0 c2VsZg0KPiBzaG91bGQgc3RpbGwgYmUgdmFsaWQgYXMgdGhlIHJlZmVyZW5jZSBjb3VudCBzaG91 bGRuJ3QgZHJvcCBiZWxvdyAxLCBhbmQgaW4gdGhhdA0KPiBjYXNlIHRoZSBkcml2ZXIgc2hvdWxk IGJlIGhvbGRpbmcgdGhhdCBvbmUgcmVmZXJlbmNlIHRvIHRoZSBwYWdlLg0KPiANCj4gV2hlbiB3 ZSBwZXJmb3JtIG91ciBjaGVjayB3ZSBhcmUgcGVyZm9ybWluZyBpdCBzdWNoIGF0IG91dHB1dCBv ZiBlaXRoZXIgMCBpZg0KPiB0aGUgcGFnZSBpcyBmcmVlZCwgb3IgMSBpZiB0aGUgcGFnZSBpcyBu b3QgZnJlZWQgYXJlIGFjY2VwdGFibGUgZm9yIHVzIHRvIGFsbG93DQo+IHJldXNlLiBUaGUga2V5 IGJpdCBpcyBpbiBpZ2JfY2xlYW5fcnhfaXJxIHdoZXJlIHdlIHdpbGwgZmxpcCB0aGUgYnVmZmVy IGZvciB0aGUNCj4gSUdCX1hEUF9UWCB8IElHQl9YRFBfUkVESVIgY2FzZSBhbmQganVzdCBpbmNy ZW1lbnQgdGhlIHBhZ2VjbnRfYmlhcw0KPiBpbmRpY2F0aW5nIHRoYXQgdGhlIHBhZ2Ugd2FzIGRy b3BwZWQgaW4gdGhlIG5vbi1mbGlwcGVkIGNhc2UuDQo+IA0KPiBBcmUgeW91IHBlcmhhcHMgc2Vl aW5nIGEgZnVuY3Rpb24gdGhhdCBpcyByZXR1cm5pbmcgYW4gZXJyb3IgYW5kIHN0aWxsIGNvbnN1 bWluZw0KPiB0aGUgcGFnZT8gSWYgc28gdGhhdCBtaWdodCBleHBsYWluIHdoYXQgeW91IGFyZSBz ZWVpbmcuDQo+IEhvd2V2ZXIgdGhlIGJ1ZyB3b3VsZCBiZSBpbiB0aGUgb3RoZXIgZHJpdmVyIG5v dCB0aGlzIG9uZS4gVGhlDQo+IHhkcF9kb19yZWRpcmVjdCBmdW5jdGlvbiBpcyBub3Qgc3VwcG9z ZWQgdG8gZnJlZSB0aGUgcGFnZSBpZiBpdCByZXR1cm5zIGFuIGVycm9yLg0KPiBJdCBpcyBzdXBw b3NlZCB0byBsZWF2ZSB0aGF0IHVwIHRvIHRoZSBmdW5jdGlvbiB0aGF0IGNhbGxlZCB4ZHBfZG9f cmVkaXJlY3QuDQo+IA0KPiA+IC0tLQ0KPiA+ICBkcml2ZXJzL25ldC9ldGhlcm5ldC9pbnRlbC9p Z2IvaWdiX21haW4uYyB8IDIyICsrKysrKysrKysrKysrKy0tLS0tLS0NCj4gPiAgMSBmaWxlIGNo YW5nZWQsIDE1IGluc2VydGlvbnMoKyksIDcgZGVsZXRpb25zKC0pDQo+ID4NCj4gPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvaW50ZWwvaWdiL2lnYl9tYWluLmMNCj4gPiBiL2Ry aXZlcnMvbmV0L2V0aGVybmV0L2ludGVsL2lnYi9pZ2JfbWFpbi5jDQo+ID4gaW5kZXggMDNmNzhm ZGIwZGNkLi4zZTBkOTAzY2Y5MTkgMTAwNjQ0DQo+ID4gLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJu ZXQvaW50ZWwvaWdiL2lnYl9tYWluLmMNCj4gPiArKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9p bnRlbC9pZ2IvaWdiX21haW4uYw0KPiA+IEBAIC04MjMyLDcgKzgyMzIsOCBAQCBzdGF0aWMgaW5s aW5lIGJvb2wgaWdiX3BhZ2VfaXNfcmVzZXJ2ZWQoc3RydWN0DQo+IHBhZ2UgKnBhZ2UpDQo+ID4g ICAgICAgICByZXR1cm4gKHBhZ2VfdG9fbmlkKHBhZ2UpICE9IG51bWFfbWVtX2lkKCkpIHx8DQo+ ID4gcGFnZV9pc19wZm1lbWFsbG9jKHBhZ2UpOyAgfQ0KPiA+DQo+ID4gLXN0YXRpYyBib29sIGln Yl9jYW5fcmV1c2VfcnhfcGFnZShzdHJ1Y3QgaWdiX3J4X2J1ZmZlciAqcnhfYnVmZmVyKQ0KPiA+ ICtzdGF0aWMgYm9vbCBpZ2JfY2FuX3JldXNlX3J4X3BhZ2Uoc3RydWN0IGlnYl9yeF9idWZmZXIg KnJ4X2J1ZmZlciwNCj4gPiArDQo+IGludA0KPiA+ICtyeF9idWZfcGdjbnQpDQo+ID4gIHsNCj4g PiAgICAgICAgIHVuc2lnbmVkIGludCBwYWdlY250X2JpYXMgPSByeF9idWZmZXItPnBhZ2VjbnRf YmlhczsNCj4gPiAgICAgICAgIHN0cnVjdCBwYWdlICpwYWdlID0gcnhfYnVmZmVyLT5wYWdlOyBA QCAtODI0Myw3ICs4MjQ0LDcgQEANCj4gPiBzdGF0aWMgYm9vbCBpZ2JfY2FuX3JldXNlX3J4X3Bh Z2Uoc3RydWN0IGlnYl9yeF9idWZmZXIgKnJ4X2J1ZmZlcikNCj4gPg0KPiA+ICAjaWYgKFBBR0Vf U0laRSA8IDgxOTIpDQo+ID4gICAgICAgICAvKiBpZiB3ZSBhcmUgb25seSBvd25lciBvZiBwYWdl IHdlIGNhbiByZXVzZSBpdCAqLw0KPiA+IC0gICAgICAgaWYgKHVubGlrZWx5KChwYWdlX3JlZl9j b3VudChwYWdlKSAtIHBhZ2VjbnRfYmlhcykgPiAxKSkNCj4gPiArICAgICAgIGlmICh1bmxpa2Vs eSgocnhfYnVmX3BnY250IC0gcGFnZWNudF9iaWFzKSA+IDEpKQ0KPiA+ICAgICAgICAgICAgICAg ICByZXR1cm4gZmFsc2U7DQo+ID4gICNlbHNlDQo+IEkgd291bGQgbmVlZCBtb3JlIGluZm8gb24g dGhlIGFjdHVhbCBpc3N1ZS4gSWYgbm90aGluZyBlbHNlIGl0IG1pZ2h0IGJlIHVzZWZ1bCB0bw0K PiBoYXZlIGFuIGV4YW1wbGUgd2hlcmUgeW91IHByaW50IG91dCB0aGUgcGFnZV9yZWZfY291bnQg dmVyc3VzIHRoZQ0KPiBwYWdlY250X2JpYXMgYXQgYSBmZXcgcG9pbnRzIHRvIHZlcmlmeSBleGFj dGx5IHdoYXQgaXMgZ29pbmcgb24uIEFzIEkgc2FpZCBiZWZvcmUNCj4gaWYgdGhlIGlzc3VlIGlz IHRoZSB4ZHBfZG9fcmVkaXJlY3QgcmV0dXJuaW5nIGFuIGVycm9yIGFuZCBzdGlsbCBjb25zdW1p bmcgdGhlDQo+IHBhZ2UgdGhlbiB0aGUgYnVnIGlzIGVsc2V3aGVyZSBhbmQgbm90IGhlcmUuDQoN Cg0KVGhpcyBwYXRjaCBpcyBzYW1lIGFzIDc1YWFiNGUxMGFlNmE0NTkzYTYwZjY2ZDEzZGU3NTVk NGU5MWY0MDANCg0KDQpjb21taXQgNzVhYWI0ZTEwYWU2YTQ1OTNhNjBmNjZkMTNkZTc1NWQ0ZTkx ZjQwMA0KQXV0aG9yOiBCasO2cm4gVMO2cGVsIDxiam9ybi50b3BlbEBpbnRlbC5jb20+DQpEYXRl OiAgIFR1ZSBBdWcgMjUgMTk6Mjc6MzQgMjAyMCArMDIwMA0KDQogICAgaTQwZTogYXZvaWQgcHJl bWF0dXJlIFJ4IGJ1ZmZlciByZXVzZQ0KICAgIA0KICAgIFRoZSBwYWdlIHJlY3ljbGUgY29kZSwg aW5jb3JyZWN0bHksIHJlbGllZCBvbiB0aGF0IGEgcGFnZSBmcmFnbWVudA0KICAgIGNvdWxkIG5v dCBiZSBmcmVlZCBpbnNpZGUgeGRwX2RvX3JlZGlyZWN0KCkuIFRoaXMgYXNzdW1wdGlvbiBsZWFk cyB0bw0KICAgIHRoYXQgcGFnZSBmcmFnbWVudHMgdGhhdCBhcmUgdXNlZCBieSB0aGUgc3RhY2sv WERQIHJlZGlyZWN0IGNhbiBiZQ0KICAgIHJldXNlZCBhbmQgb3ZlcndyaXR0ZW4uDQogICAgDQog ICAgVG8gYXZvaWQgdGhpcywgc3RvcmUgdGhlIHBhZ2UgY291bnQgcHJpb3IgaW52b2tpbmcgeGRw X2RvX3JlZGlyZWN0KCkuDQogICAgDQogICAgTG9uZ2VyIGV4cGxhbmF0aW9uOg0KICAgIA0KICAg IEludGVsIE5JQ3MgaGF2ZSBhIHJlY3ljbGUgbWVjaGFuaXNtLiBUaGUgbWFpbiBpZGVhIGlzIHRo YXQgYSBwYWdlIGlzDQogICAgc3BsaXQgaW50byB0d28gcGFydHMuIE9uZSBwYXJ0IGlzIG93bmVk IGJ5IHRoZSBkcml2ZXIsIG9uZSBwYXJ0IG1pZ2h0DQogICAgYmUgb3duZWQgYnkgc29tZW9uZSBl bHNlLCBzdWNoIGFzIHRoZSBzdGFjay4NCiAgICANCiAgICB0MDogUGFnZSBpcyBhbGxvY2F0ZWQs IGFuZCBwdXQgb24gdGhlIFJ4IHJpbmcNCiAgICAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0t LS0NCiAgICB1c2VkIGJ5IE5JQyAtPnwgdXBwZXIgYnVmZmVyDQogICAgKHJ4X2J1ZmZlcikgICAr LS0tLS0tLS0tLS0tLS0tDQogICAgICAgICAgICAgICAgICB8IGxvd2VyIGJ1ZmZlcg0KICAgICAg ICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLQ0KICAgICAgcGFnZSBjb3VudCAgPT0gVVNIUlRf TUFYDQogICAgICByeF9idWZmZXItPnBhZ2VjbnRfYmlhcyA9PSBVU0hSVF9NQVgNCiAgICANCiAg ICB0MTogQnVmZmVyIGlzIHJlY2VpdmVkLCBhbmQgcGFzc2VkIHRvIHRoZSBzdGFjayAoZS5nLikN CiAgICAgICAgICAgICAgICAgICstLS0tLS0tLS0tLS0tLS0NCiAgICAgICAgICAgICAgICAgIHwg dXBwZXIgYnVmZiAoc2tiKQ0KICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLS0tLQ0KICAg IHVzZWQgYnkgTklDIC0+fCBsb3dlciBidWZmZXINCiAgICAocnhfYnVmZmVyKSAgICstLS0tLS0t LS0tLS0tLS0NCiAgICAgIHBhZ2UgY291bnQgID09IFVTSFJUX01BWA0KICAgICAgcnhfYnVmZmVy LT5wYWdlY250X2JpYXMgPT0gVVNIUlRfTUFYIC0gMQ0KICAgIHQyOiBCdWZmZXIgaXMgcmVjZWl2 ZWQsIGFuZCByZWRpcmVjdGVkDQogICAgICAgICAgICAgICAgICArLS0tLS0tLS0tLS0tLS0tDQog ICAgICAgICAgICAgICAgICB8IHVwcGVyIGJ1ZmYgKHNrYikNCiAgICAgICAgICAgICAgICAgICst LS0tLS0tLS0tLS0tLS0NCiAgICB1c2VkIGJ5IE5JQyAtPnwgbG93ZXIgYnVmZmVyDQogICAgKHJ4 X2J1ZmZlcikgICArLS0tLS0tLS0tLS0tLS0tDQogICAgDQogICAgTm93LCBwcmlvciBjYWxsaW5n IHhkcF9kb19yZWRpcmVjdCgpOg0KICAgICAgcGFnZSBjb3VudCAgPT0gVVNIUlRfTUFYDQogICAg ICByeF9idWZmZXItPnBhZ2VjbnRfYmlhcyA9PSBVU0hSVF9NQVggLSAyDQogICAgDQogICAgVGhp cyBtZWFucyB0aGF0IGJ1ZmZlciAqY2Fubm90KiBiZSBmbGlwcGVkL3JldXNlZCwgYmVjYXVzZSB0 aGUgc2tiIGlzDQogICAgc3RpbGwgdXNpbmcgaXQuDQogICAgDQogICAgVGhlIHByb2JsZW0gYXJp c2VzIHdoZW4geGRwX2RvX3JlZGlyZWN0KCkgYWN0dWFsbHkgZnJlZXMgdGhlDQogICAgc2VnbWVu dC4gVGhlbiB3ZSBnZXQ6DQogICAgICBwYWdlIGNvdW50ICA9PSBVU0hSVF9NQVggLSAxDQogICAg ICByeF9idWZmZXItPnBhZ2VjbnRfYmlhcyA9PSBVU0hSVF9NQVggLSAyDQogICAgDQogICAgRnJv bSBhIHJlY3ljbGUgcGVyc3BlY3RpdmUsIHRoZSBidWZmZXIgY2FuIGJlIGZsaXBwZWQgYW5kIHJl dXNlZCwNCiAgICB3aGljaCBtZWFucyB0aGF0IHRoZSBza2IgZGF0YSBhcmVhIGlzIHBhc3NlZCB0 byB0aGUgUnggSFcgcmluZyENCiAgICANCiAgICBUbyB3b3JrIGFyb3VuZCB0aGlzLCB0aGUgcGFn ZSBjb3VudCBpcyBzdG9yZWQgcHJpb3IgY2FsbGluZw0KICAgIHhkcF9kb19yZWRpcmVjdCgpLg0K ICAgIA0KICAgIE5vdGUgdGhhdCB0aGlzIGlzIG5vdCBvcHRpbWFsLCBzaW5jZSB0aGUgTklDIGNv dWxkIGFjdHVhbGx5IHJldXNlIHRoZQ0KICAgICJsb3dlciBidWZmZXIiIGFnYWluLiBIb3dldmVy LCB0aGVuIHdlIG5lZWQgdG8gdHJhY2sgd2hldGhlcg0KICAgIFhEUF9SRURJUkVDVCBjb25zdW1l ZCB0aGUgYnVmZmVyIG9yIG5vdC4NCiAgICANCiAgICBGaXhlczogZDkzMTRjNDc0ZDRmICgiaTQw ZTogYWRkIHN1cHBvcnQgZm9yIFhEUF9SRURJUkVDVCIpDQogICAgUmVwb3J0ZWQtYW5kLWFuYWx5 emVkLWJ5OiBMaSBSb25nUWluZyA8bGlyb25ncWluZ0BiYWlkdS5jb20+DQogICAgU2lnbmVkLW9m Zi1ieTogQmrDtnJuIFTDtnBlbCA8Ympvcm4udG9wZWxAaW50ZWwuY29tPg0KICAgIFRlc3RlZC1i eTogR2VvcmdlIEt1cnV2aW5ha3VubmVsIDxnZW9yZ2Uua3VydXZpbmFrdW5uZWxAaW50ZWwuY29t Pg0KICAgIFNpZ25lZC1vZmYtYnk6IFRvbnkgTmd1eWVuIDxhbnRob255Lmwubmd1eWVuQGludGVs LmNvbT4NCg0KDQpUaGFua3MNCg0KLUxpDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Li,Rongqing Date: Tue, 12 Jan 2021 02:54:15 +0000 Subject: [Intel-wired-lan] [PATCH] igb: avoid premature Rx buffer reuse In-Reply-To: References: <1609990905-29220-1-git-send-email-lirongqing@baidu.com> Message-ID: <65a7da2dc20c4fa5b69270f078026100@baidu.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: intel-wired-lan@osuosl.org List-ID: > -----Original Message----- > From: Alexander Duyck [mailto:alexander.duyck at gmail.com] > Sent: Tuesday, January 12, 2021 4:54 AM > To: Li,Rongqing > Cc: Netdev ; intel-wired-lan > ; Bj?rn T?pel > Subject: Re: [PATCH] igb: avoid premature Rx buffer reuse > > On Wed, Jan 6, 2021 at 7:53 PM Li RongQing wrote: > > > > The page recycle code, incorrectly, relied on that a page fragment > > could not be freed inside xdp_do_redirect(). This assumption leads to > > that page fragments that are used by the stack/XDP redirect can be > > reused and overwritten. > > > > To avoid this, store the page count prior invoking xdp_do_redirect(). > > > > Fixes: 9cbc948b5a20 ("igb: add XDP support") > > Signed-off-by: Li RongQing > > Cc: Bj?rn T?pel > > I'm not sure what you are talking about here. We allow for a 0 to 1 count > difference in the pagecount bias. The idea is the driver should be holding onto > at least one reference from the driver at all times. > Are you saying that is not the case? > > As far as the code itself we hold onto the page as long as our difference does > not exceed 1. So specifically if the XDP call is freeing the page the page itself > should still be valid as the reference count shouldn't drop below 1, and in that > case the driver should be holding that one reference to the page. > > When we perform our check we are performing it such at output of either 0 if > the page is freed, or 1 if the page is not freed are acceptable for us to allow > reuse. The key bit is in igb_clean_rx_irq where we will flip the buffer for the > IGB_XDP_TX | IGB_XDP_REDIR case and just increment the pagecnt_bias > indicating that the page was dropped in the non-flipped case. > > Are you perhaps seeing a function that is returning an error and still consuming > the page? If so that might explain what you are seeing. > However the bug would be in the other driver not this one. The > xdp_do_redirect function is not supposed to free the page if it returns an error. > It is supposed to leave that up to the function that called xdp_do_redirect. > > > --- > > drivers/net/ethernet/intel/igb/igb_main.c | 22 +++++++++++++++------- > > 1 file changed, 15 insertions(+), 7 deletions(-) > > > > diff --git a/drivers/net/ethernet/intel/igb/igb_main.c > > b/drivers/net/ethernet/intel/igb/igb_main.c > > index 03f78fdb0dcd..3e0d903cf919 100644 > > --- a/drivers/net/ethernet/intel/igb/igb_main.c > > +++ b/drivers/net/ethernet/intel/igb/igb_main.c > > @@ -8232,7 +8232,8 @@ static inline bool igb_page_is_reserved(struct > page *page) > > return (page_to_nid(page) != numa_mem_id()) || > > page_is_pfmemalloc(page); } > > > > -static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer) > > +static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer, > > + > int > > +rx_buf_pgcnt) > > { > > unsigned int pagecnt_bias = rx_buffer->pagecnt_bias; > > struct page *page = rx_buffer->page; @@ -8243,7 +8244,7 @@ > > static bool igb_can_reuse_rx_page(struct igb_rx_buffer *rx_buffer) > > > > #if (PAGE_SIZE < 8192) > > /* if we are only owner of page we can reuse it */ > > - if (unlikely((page_ref_count(page) - pagecnt_bias) > 1)) > > + if (unlikely((rx_buf_pgcnt - pagecnt_bias) > 1)) > > return false; > > #else > I would need more info on the actual issue. If nothing else it might be useful to > have an example where you print out the page_ref_count versus the > pagecnt_bias at a few points to verify exactly what is going on. As I said before > if the issue is the xdp_do_redirect returning an error and still consuming the > page then the bug is elsewhere and not here. This patch is same as 75aab4e10ae6a4593a60f66d13de755d4e91f400 commit 75aab4e10ae6a4593a60f66d13de755d4e91f400 Author: Bj?rn T?pel Date: Tue Aug 25 19:27:34 2020 +0200 i40e: avoid premature Rx buffer reuse The page recycle code, incorrectly, relied on that a page fragment could not be freed inside xdp_do_redirect(). This assumption leads to that page fragments that are used by the stack/XDP redirect can be reused and overwritten. To avoid this, store the page count prior invoking xdp_do_redirect(). Longer explanation: Intel NICs have a recycle mechanism. The main idea is that a page is split into two parts. One part is owned by the driver, one part might be owned by someone else, such as the stack. t0: Page is allocated, and put on the Rx ring +--------------- used by NIC ->| upper buffer (rx_buffer) +--------------- | lower buffer +--------------- page count == USHRT_MAX rx_buffer->pagecnt_bias == USHRT_MAX t1: Buffer is received, and passed to the stack (e.g.) +--------------- | upper buff (skb) +--------------- used by NIC ->| lower buffer (rx_buffer) +--------------- page count == USHRT_MAX rx_buffer->pagecnt_bias == USHRT_MAX - 1 t2: Buffer is received, and redirected +--------------- | upper buff (skb) +--------------- used by NIC ->| lower buffer (rx_buffer) +--------------- Now, prior calling xdp_do_redirect(): page count == USHRT_MAX rx_buffer->pagecnt_bias == USHRT_MAX - 2 This means that buffer *cannot* be flipped/reused, because the skb is still using it. The problem arises when xdp_do_redirect() actually frees the segment. Then we get: page count == USHRT_MAX - 1 rx_buffer->pagecnt_bias == USHRT_MAX - 2 From a recycle perspective, the buffer can be flipped and reused, which means that the skb data area is passed to the Rx HW ring! To work around this, the page count is stored prior calling xdp_do_redirect(). Note that this is not optimal, since the NIC could actually reuse the "lower buffer" again. However, then we need to track whether XDP_REDIRECT consumed the buffer or not. Fixes: d9314c474d4f ("i40e: add support for XDP_REDIRECT") Reported-and-analyzed-by: Li RongQing Signed-off-by: Bj?rn T?pel Tested-by: George Kuruvinakunnel Signed-off-by: Tony Nguyen Thanks -Li