From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-779193-1521135672-2-17566222181415898301 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, HEADER_FROM_DIFFERENT_DOMAINS 0.25, RCVD_IN_DNSWL_MED -2.3, SPF_PASS -0.001, LANGUAGES en, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='140.211.166.137', Host='smtp4.osuosl.org', Country='US', FromHeader='org', MailFrom='org' X-Spam-charsets: plain='utf-8' X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: driverdev-devel-bounces@linuxdriverproject.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=arctest; t=1521135670; b=OAubSoW7PHGnFNWkr+Ui2lU350fWLzg8q883+bLkQd2g5h3 aJZO1Ri7fYEhlZZs1H6UEOvzqishqZ+il1eU56Lwof1/keV8tYxP9/UF9l+uO5Wp 64wNUI41tU01wif2H2dORQ5/eVYHHfMb34EcItT0bPyZTXTaUpr8AkBg9BsTBp+c GqlJf2T7+unaAbd9bw7tzQx7r8AHUZ5G37EpxHEv2PBxp24ZKMwuG3FMiDV6xMKS yAKud0KYiS3P+1+OHUl9oganazi4BTRrIeQlP3fWC5Uv0F3wNKqYmhzF8RZLdLcr jM99ZxNOzGG7R/GiXtFA0/TDA9ZtuAT/fBY6dYA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=date:from:to:subject:message-id :in-reply-to:references:mime-version:list-id:list-unsubscribe :list-archive:list-post:list-help:list-subscribe:cc:content-type :content-transfer-encoding:sender; s=arctest; t=1521135670; bh=J m+u0AfL9cVsQWMh2hG3rIG9JOBfEy1WNbbOhUu8z8U=; b=grCGei+SM08pv2XQN v5aRh7xC0Xs3Yf4MfuK+RsSuHUDwgUAll22nGUhdu4wcTJDewgVVxbSY17R5vUyh tX9VK10Ck5VdH592MfMM7ihKdn0cWvokVyG89st1svb7Xrj9DyGQVkOx+utMTO39 Z8ZC2/X2fsyaq4thxCc9VqHVzzEJW3ki1B1Lowlo0ZZQfUshRo0F631RR5hVdX+H 8uOYhmtI7t9GXUU0+RxMFwpVeTm/oTVXAKRYy0lhU+fyFijXWNwvruZjxCugstp/ eJ89M7be7v6vow8jBfpic46p1H1znPEj3WMCo6FmrG5hlJ7hgg/qnOFmqsjPTCsf 4X1Gw== ARC-Authentication-Results: i=1; mx3.messagingengine.com; arc=none (no signatures found); dkim=fail (message has been altered; 2048-bit rsa key sha256) header.d=networkplumber-org.20150623.gappssmtp.com header.i=@networkplumber-org.20150623.gappssmtp.com header.b=Uo2Hdoea x-bits=2048 x-keytype=rsa x-algorithm=sha256 x-selector=20150623; dmarc=none (p=none,has-list-id=yes,d=none) header.from=networkplumber.org; iprev=pass policy.iprev=140.211.166.137 (smtp4.osuosl.org); spf=pass smtp.mailfrom=driverdev-devel-bounces@linuxdriverproject.org smtp.helo=fraxinus.osuosl.org; x-aligned-from=fail; x-category=clean score=-100 state=0; x-google-dkim=fail (message has been altered; 2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=KsQXuj1v; x-ptr=fail x-ptr-helo=fraxinus.osuosl.org x-ptr-lookup=smtp4.osuosl.org; x-return-mx=pass smtp.domain=linuxdriverproject.org smtp.result=pass smtp_is_org_domain=yes header.domain=networkplumber.org header.result=pass header_is_org_domain=yes; x-tls=pass version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128 Authentication-Results: mx3.messagingengine.com; arc=none (no signatures found); dkim=fail (message has been altered; 2048-bit rsa key sha256) header.d=networkplumber-org.20150623.gappssmtp.com header.i=@networkplumber-org.20150623.gappssmtp.com header.b=Uo2Hdoea x-bits=2048 x-keytype=rsa x-algorithm=sha256 x-selector=20150623; dmarc=none (p=none,has-list-id=yes,d=none) header.from=networkplumber.org; iprev=pass policy.iprev=140.211.166.137 (smtp4.osuosl.org); spf=pass smtp.mailfrom=driverdev-devel-bounces@linuxdriverproject.org smtp.helo=fraxinus.osuosl.org; x-aligned-from=fail; x-category=clean score=-100 state=0; x-google-dkim=fail (message has been altered; 2048-bit rsa key) header.d=1e100.net header.i=@1e100.net header.b=KsQXuj1v; x-ptr=fail x-ptr-helo=fraxinus.osuosl.org x-ptr-lookup=smtp4.osuosl.org; x-return-mx=pass smtp.domain=linuxdriverproject.org smtp.result=pass smtp_is_org_domain=yes header.domain=networkplumber.org header.result=pass header_is_org_domain=yes; x-tls=pass version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128 X-Remote-Delivered-To: driverdev-devel@osuosl.org X-Google-Smtp-Source: AG47ELsNkPzJ838+ZX4Uh+MRznjf3p04lMIT5u0KJJUf0Eo/W5V9GGjR0c6KljGUN7xJyn1WF2CDVA== Date: Thu, 15 Mar 2018 10:40:52 -0700 From: Stephen Hemminger To: Mohammed Gamal Subject: Re: [PATCH] hv_netvsc: Make sure out channel is fully opened on send Message-ID: <20180315104052.14698f66@xeon-e3> In-Reply-To: <1521131053.30828.1.camel@redhat.com> References: <1520968010-20733-1-git-send-email-mgamal@redhat.com> <20180313123521.5b486da1@xeon-e3> <1521019321.8260.1.camel@redhat.com> <1521131053.30828.1.camel@redhat.com> MIME-Version: 1.0 X-BeenThere: driverdev-devel@linuxdriverproject.org X-Mailman-Version: 2.1.24 List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: otubo@redhat.com, sthemmin@microsoft.com, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, devel@linuxdriverproject.org, vkuznets@redhat.com, davem@davemloft.net Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: T24gVGh1LCAxNSBNYXIgMjAxOCAxNzoyNDoxMyArMDEwMApNb2hhbW1lZCBHYW1hbCA8bWdhbWFs QHJlZGhhdC5jb20+IHdyb3RlOgoKPiBPbiBXZWQsIDIwMTgtMDMtMTQgYXQgMTA6MjIgKzAxMDAs IE1vaGFtbWVkIEdhbWFsIHdyb3RlOgo+ID4gT24gVHVlLCAyMDE4LTAzLTEzIGF0IDEyOjM1IC0w NzAwLCBTdGVwaGVuIEhlbW1pbmdlciB3cm90ZTogIAo+ID4gPiBPbiBUdWUsIDEzIE1hciAyMDE4 IDIwOjA2OjUwICswMTAwCj4gPiA+IE1vaGFtbWVkIEdhbWFsIDxtZ2FtYWxAcmVkaGF0LmNvbT4g d3JvdGU6Cj4gPiA+ICAgCj4gPiA+ID4gRHJpbmcgaGlnaCBuZXR3b3JrIHRyYWZmaWMgY2hhbmdl cyB0byBuZXR3b3JrIGludGVyZmFjZQo+ID4gPiA+IHBhcmFtZXRlcnMKPiA+ID4gPiBzdWNoIGFz IG51bWJlciBvZiBjaGFubmVscyBvciBNVFUgY2FuIGNhdXNlIGEga2VybmVsIHBhbmljIHdpdGgg YQo+ID4gPiA+IE5VTEwKPiA+ID4gPiBwb2ludGVyIGRlcmVmZXJlbmNlLiBUaGlzIGlzIGR1ZSB0 byBuZXR2c2NfZGV2aWNlX3JlbW92ZSgpIGJlaW5nCj4gPiA+ID4gY2FsbGVkIGFuZCBkZWFsbG9j YXRpbmcgdGhlIGNoYW5uZWwgcmluZyBidWZmZXJzLCB3aGljaCBjYW4gdGhlbgo+ID4gPiA+IGJl Cj4gPiA+ID4gYWNjZXNzZWQgYnkgbmV0dnNjX3NlbmRfcGt0KCkgYmVmb3JlIHRoZXkncmUgYWxs b2NhdGVkIG9uIGNhbGxpbmcKPiA+ID4gPiBuZXR2c2NfZGV2aWNlX2FkZCgpCj4gPiA+ID4gCj4g PiA+ID4gVGhlIHBhdGNoIGZpeGVzIHRoaXMgcHJvYmxlbSBieSBjaGVja2luZyB0aGUgY2hhbm5l bCBzdGF0ZSBhbmQKPiA+ID4gPiByZXR1cm5pbmcKPiA+ID4gPiBFTk9ERVYgaWYgbm90IHlldCBv cGVuZWQuIFdlIGFsc28gbW92ZSB0aGUgY2FsbCB0bwo+ID4gPiA+IGh2X3JpbmdidWZfYXZhaWxf cGVyY2VudCgpCj4gPiA+ID4gd2hpY2ggbWF5IGFjY2VzcyB0aGUgdW5pbml0aWFsaXplZCByaW5n IGJ1ZmZlci4KPiA+ID4gPiAKPiA+ID4gPiBTaWduZWQtb2ZmLWJ5OiBNb2hhbW1lZCBHYW1hbCA8 bWdhbWFsQHJlZGhhdC5jb20+Cj4gPiA+ID4gLS0tCj4gPiA+ID4gwqBkcml2ZXJzL25ldC9oeXBl cnYvbmV0dnNjLmMgfCA1ICsrKy0tCj4gPiA+ID4gwqAxIGZpbGUgY2hhbmdlZCwgMyBpbnNlcnRp b25zKCspLCAyIGRlbGV0aW9ucygtKQo+ID4gPiA+IAo+ID4gPiA+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL25ldC9oeXBlcnYvbmV0dnNjLmMKPiA+ID4gPiBiL2RyaXZlcnMvbmV0L2h5cGVydi9uZXR2 c2MuYwo+ID4gPiA+IGluZGV4IDAyNjVkNzAuLjQ0YTgzNTggMTAwNjQ0Cj4gPiA+ID4gLS0tIGEv ZHJpdmVycy9uZXQvaHlwZXJ2L25ldHZzYy5jCj4gPiA+ID4gKysrIGIvZHJpdmVycy9uZXQvaHlw ZXJ2L25ldHZzYy5jCj4gPiA+ID4gQEAgLTc1Nyw3ICs3NTcsNyBAQCBzdGF0aWMgaW5saW5lIGlu dCBuZXR2c2Nfc2VuZF9wa3QoCj4gPiA+ID4gwqAJc3RydWN0IG5ldGRldl9xdWV1ZSAqdHhxID0g bmV0ZGV2X2dldF90eF9xdWV1ZShuZGV2LAo+ID4gPiA+IHBhY2tldC0+cV9pZHgpOwo+ID4gPiA+ IMKgCXU2NCByZXFfaWQ7Cj4gPiA+ID4gwqAJaW50IHJldDsKPiA+ID4gPiAtCXUzMiByaW5nX2F2 YWlsID0gaHZfcmluZ2J1Zl9hdmFpbF9wZXJjZW50KCZvdXRfY2hhbm5lbC0gIAo+ID4gPiA+ID4g b3V0Ym91bmQpOyAgCj4gPiA+ID4gCj4gPiA+ID4gKwl1MzIgcmluZ19hdmFpbDsKPiA+ID4gPiDC oAo+ID4gPiA+IMKgCW52bXNnLmhkci5tc2dfdHlwZSA9IE5WU1BfTVNHMV9UWVBFX1NFTkRfUk5E SVNfUEtUOwo+ID4gPiA+IMKgCWlmIChza2IpCj4gPiA+ID4gQEAgLTc3Myw3ICs3NzMsNyBAQCBz dGF0aWMgaW5saW5lIGludCBuZXR2c2Nfc2VuZF9wa3QoCj4gPiA+ID4gwqAKPiA+ID4gPiDCoAly ZXFfaWQgPSAodWxvbmcpc2tiOwo+ID4gPiA+IMKgCj4gPiA+ID4gLQlpZiAob3V0X2NoYW5uZWwt PnJlc2NpbmQpCj4gPiA+ID4gKwlpZiAob3V0X2NoYW5uZWwtPnJlc2NpbmQgfHwgb3V0X2NoYW5u ZWwtPnN0YXRlICE9Cj4gPiA+ID4gQ0hBTk5FTF9PUEVORURfU1RBVEUpCj4gPiA+ID4gwqAJCXJl dHVybiAtRU5PREVWOwo+ID4gPiA+IMKgCj4gPiA+ID4gwqAJaWYgKHBhY2tldC0+cGFnZV9idWZf Y250KSB7Cj4gPiA+ID4gQEAgLTc5MSw2ICs3OTEsNyBAQCBzdGF0aWMgaW5saW5lIGludCBuZXR2 c2Nfc2VuZF9wa3QoCj4gPiA+ID4gwqAJCQkJwqDCoMKgwqDCoMKgwqBWTUJVU19EQVRBX1BBQ0tF VF9GTEFHX0NPCj4gPiA+ID4gTVAKPiA+ID4gPiBMRVRJT05fUkVRVUVTVEVEKTsKPiA+ID4gPiDC oAl9Cj4gPiA+ID4gwqAKPiA+ID4gPiArCXJpbmdfYXZhaWwgPSBodl9yaW5nYnVmX2F2YWlsX3Bl cmNlbnQoJm91dF9jaGFubmVsLSAgCj4gPiA+ID4gPiBvdXRib3VuZCk7ICAKPiA+ID4gPiAKPiA+ ID4gPiDCoAlpZiAocmV0ID09IDApIHsKPiA+ID4gPiDCoAkJYXRvbWljX2luY19yZXR1cm4oJm52 Y2hhbi0+cXVldWVfc2VuZHMpOwo+ID4gPiA+IMKgICAKPiA+ID4gCj4gPiA+IFRoYW5rcyBmb3Ig eW91ciBwYXRjaC4gWWVzIHRoZXJlIGFyZSByYWNlcyB3aXRoIHRoZSBjdXJyZW50IHVwZGF0ZQo+ ID4gPiBsb2dpYy4gVGhlIHJvb3QgY2F1c2UgZ29lcyBoaWdoZXIgdXAgaW4gdGhlIGZsb3c7IHRo ZSBzZW5kIHF1ZXVlcwo+ID4gPiBzaG91bGQKPiA+ID4gYmUgc3RvcHBlZCBiZWZvcmUgbmV0dnNj X2RldmljZV9yZW1vdmUgaXMgY2FsbGVkLiBTb2x2aW5nIGl0IHdoZXJlCj4gPiA+IHlvdSB0cmll ZAo+ID4gPiB0byBpcyByYWN5IGFuZCBub3QgZ29pbmcgdG8gd29yayByZWxpYWJseS4KPiA+ID4g Cj4gPiA+IE5ldHdvcmsgcGF0Y2hlcyBzaG91bGQgZ28gdG8gbmV0ZGV2QHZnZXIua2VybmVsLm9y Zwo+ID4gPiAKPiA+ID4gWW91IGNhbid0IG1vdmUgdGhlIHJpbmdfYXZhaWwgY2hlY2sgdW50aWwg YWZ0ZXIgdGhlCj4gPiA+IHZtYnVzX3NlbmRwYWNrZXQKPiA+ID4gYmVjYXVzZQo+ID4gPiB0aGF0 IHdpbGwgYnJlYWsgdGhlIGZsb3cgY29udHJvbCBsb2dpYy4KPiA+ID4gICAKPiA+IAo+ID4gV2h5 PyBJIGRvbid0IHNlZSByaW5nX2F2YWlsIGJlaW5nIHVzZWQgYmVmb3JlIHRoYXQgcG9pbnQuICAK PiAKPiBBaCwgc3R1cGlkIG1lLiB2bWJ1c19zZW5kcGFja2V0KCkgd2lsbCB3cml0ZSB0byB0aGUg cmluZyBidWZmZXIgYW5kCj4gdGhhdCBtZWFucyB0aGF0IHJpbmdfYXZhaWwgdmFsdWUgd2lsbCBi ZSBkaWZmZXJlbnQgdGhhbiB0aGUgZXhwZWN0ZWQuCj4gCj4gPiAgIAo+ID4gPiBJbnN0ZWFkLCB5 b3Ugc2hvdWxkIGp1c3QgbW92ZSB0aGUgYXZhaWxfcmVhZCBjaGVjayB1bnRpbCBqdXN0IGFmdGVy Cj4gPiA+IHRoZSBleGlzdGluZyByZXNjaW5kCj4gPiA+IGNoZWNrLgo+ID4gPiAKPiA+ID4gQWxz bywgeW91IHNob3VsZG4ndCBuZWVkIHRvIGNoZWNrIGZvciBPUEVORURfU1RBVEUsIGp1c3QgcmVz Y2luZCBpcwo+ID4gPiBlbm91Z2guICAKPiA+IAo+ID4gVGhhdCByYXJlbHkgbWl0aWdhdGVkIHRo ZSByYWNlLiBjaGFubmVsLT5yZXNjaW5kIGZsYWcgaXMgc2V0IG9uIHZtYnVzCj4gPiBleGl0IC0g Y2FsbGVkIG9uIG1vZHVsZSB1bmxvYWQgLSBhbmQgd2hlbiBhIHJlc2NpbmQgb2ZmZXIgaXMgcmVj ZWl2ZWQKPiA+IGZyb20gdGhlIGhvc3QsIHdoaWNoIEFGQUlDVCBkb2Vzbid0IGhhcHBlbiBvbiBl dmVyeSBjYWxsIHRvCj4gPiBuZXR2c2NfZGV2aWNlX3JlbW92ZSwgc28gaXQncyBxdWl0ZSBwb3Nz aWJsZSB0aGF0IHRoZSByaW5nYnVmZmVyIGlzCj4gPiBhY2Nlc3NlZCBiZWZvcmUgaXQncyBhbGxv Y2F0ZWQgYWdhaW4gb24gY2hhbm5lbCBvcGVuIGFuZCBoZW5jZSB0aGUKPiA+IGNoZWNrIGZvciBP UEVORURfU1RBVCAtIHdoaWNoIGlzIG9ubHkgc2V0IGFmdGVyIGFsbCB2bWJ1cyBkYXRhIGlzCj4g PiBpbml0aWFsaXplZC4KPiA+ICAgCj4gCj4gUGVyaGFwcyBJIGhhdmVuJ3QgYmVlbiBjbGVhciBl bm91Z2guIFRoZSBOVUxMIHBvaW50ZXIgZGVyZWZlcmVuY2UKPiBoYXBwZW5zIGluIHRoZSBjYWxs IHRvIGh2X3JpbmdidWZfYXZhaWxfcGVyY2VudCgpIHdoaWNoIGlzIHVzZWQgdG8KPiBjYWxjdWxh dGUgcmluZ19hdmFpbC7CoAo+IAo+IFNvIHdlIG5lZWQgdG8gc3RvcCB0aGUgcXVldWVzIGJlZm9y ZSBjYWxsaW5nIGl0IGlmIHRoZSBjaGFubmVsJ3MgcmluZwo+IGJ1ZmZlcnMgaGF2ZW4ndCBiZWVu IGFsbG9jYXRlZCB5ZXQsIGJ1dCBPVE9IIHdlIHNob3VsZCBvbmx5IHN0b3AgdGhlCj4gcXVldWVz IGJhc2VkIHVwb24gdGhlIHZhbHVlIG9mIHJpbmdfYXZhaWwsIHNvIHRoaXMgbGVhZHMgaW50byBh IGNoaWNrZW4KPiBhbmQgZWdnIHNpdHVhdGlvbi7CoAo+IAo+IElzIG15IG9ic2VydmF0aW9uIGhl cmUgY29ycmVjdD8gUGxlYXNlIGNvcnJlY3QgbWUgaWYgSSBhbSB3cm9uZywKPiBTdGVwaGVuLgoK VGhpcyBpcyBhIGZhciBtb3JlIGRyYXN0aWMgd29yayBvZiB0aGUgc2h1dGRvd24gbG9naWMgd2hp Y2ggSSBhbSBzdGlsbCB3b3JraW5nCm9uLiBUaGUgY3VycmVudCBuZXR2c2MgZHJpdmVyIGlzIG5v dCBkb2luZyBhIGdvb2Qgam9iIG9mIGhhbmRsaW5nIGNvbmN1cnJlbnQKc2VuZC9yZWNlaXZlcyBk dXJpbmcgcmluZyBjaGFuZ2VzLgoKCkZyb20gYTIyZGExOGI0MWFkNTAyNDM0MGRkZGNjOTg5ZDkx ODk4NzgzNmY2ZCBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogU3RlcGhlbiBIZW1taW5n ZXIgPHN0aGVtbWluQG1pY3Jvc29mdC5jb20+CkRhdGU6IFR1ZSwgNiBGZWIgMjAxOCAxNTowNTox OSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIGh2X25ldHZzYzogY29tbW9uIGRldGFjaCBsb2dpYwoK TWFrZSBjb21tb24gZnVuY3Rpb24gZm9yIGRldGFjaGluZyBpbnRlcm5hbHMgb2YgZGV2aWNlCmR1 cmluZyBjaGFuZ2VzIHRvIE1UVSBhbmQgUlNTLiBNYWtlIHN1cmUgbm8gbW9yZSBwYWNrZXRzCmFy ZSB0cmFuc21pdHRlZCBhbmQgYWxsIHBhY2tldHMgaGF2ZSBiZWVuIHJlY2VpdmVkIGJlZm9yZQpk b2luZyBkZXZpY2UgdGVhcmRvd24uCgpDaGFuZ2VzIHRyYW5zbWl0IGVuYWJsaW5nIGxvZ2ljIHNv IHRoYXQgdHJhbnNtaXQgcXVldWVzIGFyZSBkaXNhYmxlZApkdXJpbmcgdGhlIHBlcmlvZCB3aGVu IGxvd2VyIGRldmljZSBpcyBiZWluZyBjaGFuZ2VkLiBBbmQgZW5hYmxlZApvbmx5IGFmdGVyIHN1 YiBjaGFubmVscyBhcmUgc2V0dXAuIFRoaXMgYXZvaWRzIGlzc3VlIHdoZXJlIGl0IGNvdWxkCmJl IHRoYXQgYSBwYWNrZXQgd2FzIGJlaW5nIHNlbnQgd2hpbGUgc3ViY2hhbm5lbCB3YXMgbm90IGlu aXRpYWxpemVkLgoKU2lnbmVkLW9mZi1ieTogU3RlcGhlbiBIZW1taW5nZXIgPHN0aGVtbWluQG1p Y3Jvc29mdC5jb20+Ci0tLQogZHJpdmVycy9uZXQvaHlwZXJ2L2h5cGVydl9uZXQuaCAgIHwgICAx IC0KIGRyaXZlcnMvbmV0L2h5cGVydi9uZXR2c2MuYyAgICAgICB8ICAyMCArLS0KIGRyaXZlcnMv bmV0L2h5cGVydi9uZXR2c2NfZHJ2LmMgICB8IDI2OCArKysrKysrKysrKysrKysrKysrKystLS0t LS0tLS0tLS0tLS0tLQogZHJpdmVycy9uZXQvaHlwZXJ2L3JuZGlzX2ZpbHRlci5jIHwgIDE0ICst CiA0IGZpbGVzIGNoYW5nZWQsIDE2MCBpbnNlcnRpb25zKCspLCAxNDMgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaHlwZXJ2L2h5cGVydl9uZXQuaCBiL2RyaXZlcnMvbmV0 L2h5cGVydi9oeXBlcnZfbmV0LmgKaW5kZXggY2Q1MzhkNWE3OTg2Li4zMjg2MTAzNmMzZmMgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2h5cGVydi9oeXBlcnZfbmV0LmgKKysrIGIvZHJpdmVycy9u ZXQvaHlwZXJ2L2h5cGVydl9uZXQuaApAQCAtMjEyLDcgKzIxMiw2IEBAIHZvaWQgbmV0dnNjX2No YW5uZWxfY2Iodm9pZCAqY29udGV4dCk7CiBpbnQgbmV0dnNjX3BvbGwoc3RydWN0IG5hcGlfc3Ry dWN0ICpuYXBpLCBpbnQgYnVkZ2V0KTsKIAogdm9pZCBybmRpc19zZXRfc3ViY2hhbm5lbChzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKncpOwotYm9vbCBybmRpc19maWx0ZXJfb3BlbmVkKGNvbnN0IHN0cnVj dCBuZXR2c2NfZGV2aWNlICpudmRldik7CiBpbnQgcm5kaXNfZmlsdGVyX29wZW4oc3RydWN0IG5l dHZzY19kZXZpY2UgKm52ZGV2KTsKIGludCBybmRpc19maWx0ZXJfY2xvc2Uoc3RydWN0IG5ldHZz Y19kZXZpY2UgKm52ZGV2KTsKIHN0cnVjdCBuZXR2c2NfZGV2aWNlICpybmRpc19maWx0ZXJfZGV2 aWNlX2FkZChzdHJ1Y3QgaHZfZGV2aWNlICpkZXYsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9o eXBlcnYvbmV0dnNjLmMgYi9kcml2ZXJzL25ldC9oeXBlcnYvbmV0dnNjLmMKaW5kZXggOGM5NWEz Nzk3YjJmLi4zMWIxYzZjNDMwYmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2h5cGVydi9uZXR2 c2MuYworKysgYi9kcml2ZXJzL25ldC9oeXBlcnYvbmV0dnNjLmMKQEAgLTU3Myw4ICs1NzMsNiBA QCB2b2lkIG5ldHZzY19kZXZpY2VfcmVtb3ZlKHN0cnVjdCBodl9kZXZpY2UgKmRldmljZSkKIAkJ PSBydG5sX2RlcmVmZXJlbmNlKG5ldF9kZXZpY2VfY3R4LT5udmRldik7CiAJaW50IGk7CiAKLQlj YW5jZWxfd29ya19zeW5jKCZuZXRfZGV2aWNlLT5zdWJjaGFuX3dvcmspOwotCiAJbmV0dnNjX3Jl dm9rZV9idWYoZGV2aWNlLCBuZXRfZGV2aWNlKTsKIAogCVJDVV9JTklUX1BPSU5URVIobmV0X2Rl dmljZV9jdHgtPm52ZGV2LCBOVUxMKTsKQEAgLTY2MSwxNCArNjU5LDE4IEBAIHN0YXRpYyB2b2lk IG5ldHZzY19zZW5kX3R4X2NvbXBsZXRlKHN0cnVjdCBuZXR2c2NfZGV2aWNlICpuZXRfZGV2aWNl LAogCXF1ZXVlX3NlbmRzID0KIAkJYXRvbWljX2RlY19yZXR1cm4oJm5ldF9kZXZpY2UtPmNoYW5f dGFibGVbcV9pZHhdLnF1ZXVlX3NlbmRzKTsKIAotCWlmIChuZXRfZGV2aWNlLT5kZXN0cm95ICYm IHF1ZXVlX3NlbmRzID09IDApCi0JCXdha2VfdXAoJm5ldF9kZXZpY2UtPndhaXRfZHJhaW4pOwor CWlmICh1bmxpa2VseShuZXRfZGV2aWNlLT5kZXN0cm95KSkgeworCQlpZiAocXVldWVfc2VuZHMg PT0gMCkKKwkJCXdha2VfdXAoJm5ldF9kZXZpY2UtPndhaXRfZHJhaW4pOworCX0gZWxzZSB7CisJ CXN0cnVjdCBuZXRkZXZfcXVldWUgKnR4cSA9IG5ldGRldl9nZXRfdHhfcXVldWUobmRldiwgcV9p ZHgpOwogCi0JaWYgKG5ldGlmX3R4X3F1ZXVlX3N0b3BwZWQobmV0ZGV2X2dldF90eF9xdWV1ZShu ZGV2LCBxX2lkeCkpICYmCi0JICAgIChodl9yaW5nYnVmX2F2YWlsX3BlcmNlbnQoJmNoYW5uZWwt Pm91dGJvdW5kKSA+IFJJTkdfQVZBSUxfUEVSQ0VOVF9ISVdBVEVSIHx8Ci0JICAgICBxdWV1ZV9z ZW5kcyA8IDEpKSB7Ci0JCW5ldGlmX3R4X3dha2VfcXVldWUobmV0ZGV2X2dldF90eF9xdWV1ZShu ZGV2LCBxX2lkeCkpOwotCQluZGV2X2N0eC0+ZXRoX3N0YXRzLndha2VfcXVldWUrKzsKKwkJaWYg KG5ldGlmX3R4X3F1ZXVlX3N0b3BwZWQodHhxKSAmJgorCQkgICAgKGh2X3JpbmdidWZfYXZhaWxf cGVyY2VudCgmY2hhbm5lbC0+b3V0Ym91bmQpID4gUklOR19BVkFJTF9QRVJDRU5UX0hJV0FURVIg fHwKKwkJICAgICBxdWV1ZV9zZW5kcyA8IDEpKSB7CisJCQluZXRpZl90eF93YWtlX3F1ZXVlKHR4 cSk7CisJCQluZGV2X2N0eC0+ZXRoX3N0YXRzLndha2VfcXVldWUrKzsKKwkJfQogCX0KIH0KIApk aWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaHlwZXJ2L25ldHZzY19kcnYuYyBiL2RyaXZlcnMvbmV0 L2h5cGVydi9uZXR2c2NfZHJ2LmMKaW5kZXggZmFlYTBiZTE4OTI0Li43MjFmYWM3Y2FkODEgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2h5cGVydi9uZXR2c2NfZHJ2LmMKKysrIGIvZHJpdmVycy9u ZXQvaHlwZXJ2L25ldHZzY19kcnYuYwpAQCAtNDYsNyArNDYsOCBAQAogCiAjaW5jbHVkZSAiaHlw ZXJ2X25ldC5oIgogCi0jZGVmaW5lIFJJTkdfU0laRV9NSU4JCTY0CisjZGVmaW5lIFJJTkdfU0la RV9NSU4JNjQKKyNkZWZpbmUgUkVUUllfTUFYCTIwMDAKIAogI2RlZmluZSBMSU5LQ0hBTkdFX0lO VCAoMiAqIEhaKQogI2RlZmluZSBWRl9UQUtFT1ZFUl9JTlQgKEhaIC8gMTApCkBAIC0xMjMsMTAg KzEyNCw4IEBAIHN0YXRpYyBpbnQgbmV0dnNjX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKm5ldCkK IAl9CiAKIAlyZGV2ID0gbnZkZXYtPmV4dGVuc2lvbjsKLQlpZiAoIXJkZXYtPmxpbmtfc3RhdGUp IHsKKwlpZiAoIXJkZXYtPmxpbmtfc3RhdGUpCiAJCW5ldGlmX2NhcnJpZXJfb24obmV0KTsKLQkJ bmV0aWZfdHhfd2FrZV9hbGxfcXVldWVzKG5ldCk7Ci0JfQogCiAJaWYgKHZmX25ldGRldikgewog CQkvKiBTZXR0aW5nIHN5bnRoZXRpYyBkZXZpY2UgdXAgdHJhbnNwYXJlbnRseSBzZXRzCkBAIC0x NDIsMzYgKzE0MSwyNSBAQCBzdGF0aWMgaW50IG5ldHZzY19vcGVuKHN0cnVjdCBuZXRfZGV2aWNl ICpuZXQpCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgbmV0dnNjX2Nsb3NlKHN0cnVjdCBu ZXRfZGV2aWNlICpuZXQpCitzdGF0aWMgaW50IG5ldHZzY193YWl0X3VudGlsX2VtcHR5KHN0cnVj dCBuZXR2c2NfZGV2aWNlICpudmRldikKIHsKLQlzdHJ1Y3QgbmV0X2RldmljZV9jb250ZXh0ICpu ZXRfZGV2aWNlX2N0eCA9IG5ldGRldl9wcml2KG5ldCk7Ci0Jc3RydWN0IG5ldF9kZXZpY2UgKnZm X25ldGRldgotCQk9IHJ0bmxfZGVyZWZlcmVuY2UobmV0X2RldmljZV9jdHgtPnZmX25ldGRldik7 Ci0Jc3RydWN0IG5ldHZzY19kZXZpY2UgKm52ZGV2ID0gcnRubF9kZXJlZmVyZW5jZShuZXRfZGV2 aWNlX2N0eC0+bnZkZXYpOwotCWludCByZXQgPSAwOwotCXUzMiBhcmVhZCwgaSwgbXNlYyA9IDEw LCByZXRyeSA9IDAsIHJldHJ5X21heCA9IDIwOwotCXN0cnVjdCB2bWJ1c19jaGFubmVsICpjaG47 Ci0KLQluZXRpZl90eF9kaXNhYmxlKG5ldCk7Ci0KLQkvKiBObyBuZWVkIHRvIGNsb3NlIHJuZGlz IGZpbHRlciBpZiBpdCBpcyByZW1vdmVkIGFscmVhZHkgKi8KLQlpZiAoIW52ZGV2KQotCQlnb3Rv IG91dDsKLQotCXJldCA9IHJuZGlzX2ZpbHRlcl9jbG9zZShudmRldik7Ci0JaWYgKHJldCAhPSAw KSB7Ci0JCW5ldGRldl9lcnIobmV0LCAidW5hYmxlIHRvIGNsb3NlIGRldmljZSAocmV0ICVkKS5c biIsIHJldCk7Ci0JCXJldHVybiByZXQ7Ci0JfQorCXVuc2lnbmVkIGludCByZXRyeSA9IDA7CisJ aW50IGk7CiAKIAkvKiBFbnN1cmUgcGVuZGluZyBieXRlcyBpbiByaW5nIGFyZSByZWFkICovCi0J d2hpbGUgKHRydWUpIHsKLQkJYXJlYWQgPSAwOworCWZvciAoOzspIHsKKwkJdTMyIGFyZWFkID0g MDsKKwogCQlmb3IgKGkgPSAwOyBpIDwgbnZkZXYtPm51bV9jaG47IGkrKykgewotCQkJY2huID0g bnZkZXYtPmNoYW5fdGFibGVbaV0uY2hhbm5lbDsKKwkJCXN0cnVjdCB2bWJ1c19jaGFubmVsICpj aG4KKwkJCQk9IG52ZGV2LT5jaGFuX3RhYmxlW2ldLmNoYW5uZWw7CisKIAkJCWlmICghY2huKQog CQkJCWNvbnRpbnVlOwogCisJCQkvKiBtYWtlIHN1cmUgcmVjZWl2ZSBub3QgcnVubmluZyBub3cg Ki8KKwkJCW5hcGlfc3luY2hyb25pemUoJm52ZGV2LT5jaGFuX3RhYmxlW2ldLm5hcGkpOworCiAJ CQlhcmVhZCA9IGh2X2dldF9ieXRlc190b19yZWFkKCZjaG4tPmluYm91bmQpOwogCQkJaWYgKGFy ZWFkKQogCQkJCWJyZWFrOwpAQCAtMTgxLDIyICsxNjksNDAgQEAgc3RhdGljIGludCBuZXR2c2Nf Y2xvc2Uoc3RydWN0IG5ldF9kZXZpY2UgKm5ldCkKIAkJCQlicmVhazsKIAkJfQogCi0JCXJldHJ5 Kys7Ci0JCWlmIChyZXRyeSA+IHJldHJ5X21heCB8fCBhcmVhZCA9PSAwKQotCQkJYnJlYWs7CisJ CWlmIChhcmVhZCA9PSAwKQorCQkJcmV0dXJuIDA7CiAKLQkJbXNsZWVwKG1zZWMpOworCQlpZiAo KytyZXRyeSA+IFJFVFJZX01BWCkKKwkJCXJldHVybiAtRVRJTUVET1VUOwogCi0JCWlmIChtc2Vj IDwgMTAwMCkKLQkJCW1zZWMgKj0gMjsKKwkJdXNsZWVwX3JhbmdlKDEwMDAsIDIwMDApOwogCX0K K30KIAotCWlmIChhcmVhZCkgewotCQluZXRkZXZfZXJyKG5ldCwgIlJpbmcgYnVmZmVyIG5vdCBl bXB0eSBhZnRlciBjbG9zaW5nIHJuZGlzXG4iKTsKLQkJcmV0ID0gLUVUSU1FRE9VVDsKK3N0YXRp YyBpbnQgbmV0dnNjX2Nsb3NlKHN0cnVjdCBuZXRfZGV2aWNlICpuZXQpCit7CisJc3RydWN0IG5l dF9kZXZpY2VfY29udGV4dCAqbmV0X2RldmljZV9jdHggPSBuZXRkZXZfcHJpdihuZXQpOworCXN0 cnVjdCBuZXRfZGV2aWNlICp2Zl9uZXRkZXYKKwkJPSBydG5sX2RlcmVmZXJlbmNlKG5ldF9kZXZp Y2VfY3R4LT52Zl9uZXRkZXYpOworCXN0cnVjdCBuZXR2c2NfZGV2aWNlICpudmRldiA9IHJ0bmxf ZGVyZWZlcmVuY2UobmV0X2RldmljZV9jdHgtPm52ZGV2KTsKKwlpbnQgcmV0OworCisJbmV0aWZf dHhfZGlzYWJsZShuZXQpOworCisJLyogTm8gbmVlZCB0byBjbG9zZSBybmRpcyBmaWx0ZXIgaWYg aXQgaXMgcmVtb3ZlZCBhbHJlYWR5ICovCisJaWYgKCFudmRldikKKwkJcmV0dXJuIDA7CisKKwly ZXQgPSBybmRpc19maWx0ZXJfY2xvc2UobnZkZXYpOworCWlmIChyZXQgIT0gMCkgeworCQluZXRk ZXZfZXJyKG5ldCwgInVuYWJsZSB0byBjbG9zZSBkZXZpY2UgKHJldCAlZCkuXG4iLCByZXQpOwor CQlyZXR1cm4gcmV0OwogCX0KIAotb3V0OgorCXJldCA9IG5ldHZzY193YWl0X3VudGlsX2VtcHR5 KG52ZGV2KTsKKwlpZiAocmV0KQorCQluZXRkZXZfZXJyKG5ldCwgIlJpbmcgYnVmZmVyIG5vdCBl bXB0eSBhZnRlciBjbG9zaW5nIHJuZGlzXG4iKTsKKwogCWlmICh2Zl9uZXRkZXYpCiAJCWRldl9j bG9zZSh2Zl9uZXRkZXYpOwogCkBAIC04NDUsMTYgKzg1MSw3NiBAQCBzdGF0aWMgdm9pZCBuZXR2 c2NfZ2V0X2NoYW5uZWxzKHN0cnVjdCBuZXRfZGV2aWNlICpuZXQsCiAJfQogfQogCitzdGF0aWMg aW50IG5ldHZzY19kZXRhY2goc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsCisJCQkgc3RydWN0IG5l dHZzY19kZXZpY2UgKm52ZGV2KQoreworCXN0cnVjdCBuZXRfZGV2aWNlX2NvbnRleHQgKm5kZXZf Y3R4ID0gbmV0ZGV2X3ByaXYobmRldik7CisJc3RydWN0IGh2X2RldmljZSAqaGRldiA9IG5kZXZf Y3R4LT5kZXZpY2VfY3R4OworCWludCByZXQ7CisKKwkvKiBEb24ndCB0cnkgY29udGludWluZyB0 byB0cnkgYW5kIHNldHVwIHN1YiBjaGFubmVscyAqLworCWlmIChjYW5jZWxfd29ya19zeW5jKCZu dmRldi0+c3ViY2hhbl93b3JrKSkKKwkJbnZkZXYtPm51bV9jaG4gPSAxOworCisJLyogSWYgZGV2 aWNlIHdhcyB1cCAocmVjZWl2aW5nKSB0aGVuIHNodXRkb3duICovCisJaWYgKG5ldGlmX3J1bm5p bmcobmRldikpIHsKKwkJbmV0aWZfdHhfZGlzYWJsZShuZGV2KTsKKworCQlyZXQgPSBybmRpc19m aWx0ZXJfY2xvc2UobnZkZXYpOworCQlpZiAocmV0KSB7CisJCQluZXRkZXZfZXJyKG5kZXYsCisJ CQkJICAgInVuYWJsZSB0byBjbG9zZSBkZXZpY2UgKHJldCAlZCkuXG4iLCByZXQpOworCQkJcmV0 dXJuIHJldDsKKwkJfQorCisJCXJldCA9IG5ldHZzY193YWl0X3VudGlsX2VtcHR5KG52ZGV2KTsK KwkJaWYgKHJldCkgeworCQkJbmV0ZGV2X2VycihuZGV2LAorCQkJCSAgICJSaW5nIGJ1ZmZlciBu b3QgZW1wdHkgYWZ0ZXIgY2xvc2luZyBybmRpc1xuIik7CisJCQlyZXR1cm4gcmV0OworCQl9CisJ fQorCisJcm5kaXNfZmlsdGVyX2RldmljZV9yZW1vdmUoaGRldiwgbnZkZXYpOworCXJldHVybiAw OworfQorCitzdGF0aWMgaW50IG5ldHZzY19hdHRhY2goc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYs CisJCQkgc3RydWN0IG5ldHZzY19kZXZpY2VfaW5mbyAqZGV2X2luZm8pCit7CisJc3RydWN0IG5l dF9kZXZpY2VfY29udGV4dCAqbmRldl9jdHggPSBuZXRkZXZfcHJpdihuZGV2KTsKKwlzdHJ1Y3Qg aHZfZGV2aWNlICpoZGV2ID0gbmRldl9jdHgtPmRldmljZV9jdHg7CisJc3RydWN0IG5ldHZzY19k ZXZpY2UgKm52ZGV2OworCXN0cnVjdCBybmRpc19kZXZpY2UgKnJkZXY7CisJaW50IHJldDsKKwor CW52ZGV2ID0gcm5kaXNfZmlsdGVyX2RldmljZV9hZGQoaGRldiwgZGV2X2luZm8pOworCWlmIChJ U19FUlIobnZkZXYpKQorCQlyZXR1cm4gUFRSX0VSUihudmRldik7CisKKwluZXRpZl9jYXJyaWVy X29mZihuZGV2KTsKKworCWlmIChuZXRpZl9ydW5uaW5nKG5kZXYpKSB7CisJCXJldCA9IHJuZGlz X2ZpbHRlcl9vcGVuKG52ZGV2KTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisKKwkJcmRl diA9IG52ZGV2LT5leHRlbnNpb247CisJCWlmICghcmRldi0+bGlua19zdGF0ZSkKKwkJCW5ldGlm X2NhcnJpZXJfb24obmRldik7CisJfQorCisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyBpbnQgbmV0 dnNjX3NldF9jaGFubmVscyhzdHJ1Y3QgbmV0X2RldmljZSAqbmV0LAogCQkJICAgICAgIHN0cnVj dCBldGh0b29sX2NoYW5uZWxzICpjaGFubmVscykKIHsKIAlzdHJ1Y3QgbmV0X2RldmljZV9jb250 ZXh0ICpuZXRfZGV2aWNlX2N0eCA9IG5ldGRldl9wcml2KG5ldCk7Ci0Jc3RydWN0IGh2X2Rldmlj ZSAqZGV2ID0gbmV0X2RldmljZV9jdHgtPmRldmljZV9jdHg7CiAJc3RydWN0IG5ldHZzY19kZXZp Y2UgKm52ZGV2ID0gcnRubF9kZXJlZmVyZW5jZShuZXRfZGV2aWNlX2N0eC0+bnZkZXYpOwogCXVu c2lnbmVkIGludCBvcmlnLCBjb3VudCA9IGNoYW5uZWxzLT5jb21iaW5lZF9jb3VudDsKIAlzdHJ1 Y3QgbmV0dnNjX2RldmljZV9pbmZvIGRldmljZV9pbmZvOwotCWJvb2wgd2FzX29wZW5lZDsKLQlp bnQgcmV0ID0gMDsKKwlpbnQgcmV0OwogCiAJLyogV2UgZG8gbm90IHN1cHBvcnQgc2VwYXJhdGUg Y291bnQgZm9yIHJ4LCB0eCwgb3Igb3RoZXIgKi8KIAlpZiAoY291bnQgPT0gMCB8fApAQCAtODcx LDkgKzkzNyw2IEBAIHN0YXRpYyBpbnQgbmV0dnNjX3NldF9jaGFubmVscyhzdHJ1Y3QgbmV0X2Rl dmljZSAqbmV0LAogCQlyZXR1cm4gLUVJTlZBTDsKIAogCW9yaWcgPSBudmRldi0+bnVtX2NobjsK LQl3YXNfb3BlbmVkID0gcm5kaXNfZmlsdGVyX29wZW5lZChudmRldik7Ci0JaWYgKHdhc19vcGVu ZWQpCi0JCXJuZGlzX2ZpbHRlcl9jbG9zZShudmRldik7CiAKIAltZW1zZXQoJmRldmljZV9pbmZv LCAwLCBzaXplb2YoZGV2aWNlX2luZm8pKTsKIAlkZXZpY2VfaW5mby5udW1fY2huID0gY291bnQ7 CkBAIC04ODIsMjggKzk0NSwxNyBAQCBzdGF0aWMgaW50IG5ldHZzY19zZXRfY2hhbm5lbHMoc3Ry dWN0IG5ldF9kZXZpY2UgKm5ldCwKIAlkZXZpY2VfaW5mby5yZWN2X3NlY3Rpb25zID0gbnZkZXYt PnJlY3Zfc2VjdGlvbl9jbnQ7CiAJZGV2aWNlX2luZm8ucmVjdl9zZWN0aW9uX3NpemUgPSBudmRl di0+cmVjdl9zZWN0aW9uX3NpemU7CiAKLQlybmRpc19maWx0ZXJfZGV2aWNlX3JlbW92ZShkZXYs IG52ZGV2KTsKKwlyZXQgPSBuZXR2c2NfZGV0YWNoKG5ldCwgbnZkZXYpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CiAKLQludmRldiA9IHJuZGlzX2ZpbHRlcl9kZXZpY2VfYWRkKGRldiwgJmRl dmljZV9pbmZvKTsKLQlpZiAoSVNfRVJSKG52ZGV2KSkgewotCQlyZXQgPSBQVFJfRVJSKG52ZGV2 KTsKKwlyZXQgPSBuZXR2c2NfYXR0YWNoKG5ldCwgJmRldmljZV9pbmZvKTsKKwlpZiAocmV0KSB7 CiAJCWRldmljZV9pbmZvLm51bV9jaG4gPSBvcmlnOwotCQludmRldiA9IHJuZGlzX2ZpbHRlcl9k ZXZpY2VfYWRkKGRldiwgJmRldmljZV9pbmZvKTsKLQotCQlpZiAoSVNfRVJSKG52ZGV2KSkgewot CQkJbmV0ZGV2X2VycihuZXQsICJyZXN0b3JpbmcgY2hhbm5lbCBzZXR0aW5nIGZhaWxlZDogJWxk XG4iLAotCQkJCSAgIFBUUl9FUlIobnZkZXYpKTsKLQkJCXJldHVybiByZXQ7Ci0JCX0KKwkJaWYg KG5ldHZzY19hdHRhY2gobmV0LCAmZGV2aWNlX2luZm8pKQorCQkJbmV0ZGV2X2VycihuZXQsICJy ZXN0b3JpbmcgY2hhbm5lbCBzZXR0aW5nIGZhaWxlZFxuIik7CiAJfQogCi0JaWYgKHdhc19vcGVu ZWQpCi0JCXJuZGlzX2ZpbHRlcl9vcGVuKG52ZGV2KTsKLQotCS8qIFdlIG1heSBoYXZlIG1pc3Nl ZCBsaW5rIGNoYW5nZSBub3RpZmljYXRpb25zICovCi0JbmV0X2RldmljZV9jdHgtPmxhc3RfcmVj b25maWcgPSAwOwotCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmbmV0X2RldmljZV9jdHgtPmR3b3Jr LCAwKTsKLQogCXJldHVybiByZXQ7CiB9CiAKQEAgLTk2OSwxMCArMTAyMSw4IEBAIHN0YXRpYyBp bnQgbmV0dnNjX2NoYW5nZV9tdHUoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIGludCBtdHUpCiAJ c3RydWN0IG5ldF9kZXZpY2VfY29udGV4dCAqbmRldmN0eCA9IG5ldGRldl9wcml2KG5kZXYpOwog CXN0cnVjdCBuZXRfZGV2aWNlICp2Zl9uZXRkZXYgPSBydG5sX2RlcmVmZXJlbmNlKG5kZXZjdHgt PnZmX25ldGRldik7CiAJc3RydWN0IG5ldHZzY19kZXZpY2UgKm52ZGV2ID0gcnRubF9kZXJlZmVy ZW5jZShuZGV2Y3R4LT5udmRldik7Ci0Jc3RydWN0IGh2X2RldmljZSAqaGRldiA9IG5kZXZjdHgt PmRldmljZV9jdHg7CiAJaW50IG9yaWdfbXR1ID0gbmRldi0+bXR1OwogCXN0cnVjdCBuZXR2c2Nf ZGV2aWNlX2luZm8gZGV2aWNlX2luZm87Ci0JYm9vbCB3YXNfb3BlbmVkOwogCWludCByZXQgPSAw OwogCiAJaWYgKCFudmRldiB8fCBudmRldi0+ZGVzdHJveSkKQEAgLTk4NSwxMSArMTAzNSw2IEBA IHN0YXRpYyBpbnQgbmV0dnNjX2NoYW5nZV9tdHUoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIGlu dCBtdHUpCiAJCQlyZXR1cm4gcmV0OwogCX0KIAotCW5ldGlmX2RldmljZV9kZXRhY2gobmRldik7 Ci0Jd2FzX29wZW5lZCA9IHJuZGlzX2ZpbHRlcl9vcGVuZWQobnZkZXYpOwotCWlmICh3YXNfb3Bl bmVkKQotCQlybmRpc19maWx0ZXJfY2xvc2UobnZkZXYpOwotCiAJbWVtc2V0KCZkZXZpY2VfaW5m bywgMCwgc2l6ZW9mKGRldmljZV9pbmZvKSk7CiAJZGV2aWNlX2luZm8ubnVtX2NobiA9IG52ZGV2 LT5udW1fY2huOwogCWRldmljZV9pbmZvLnNlbmRfc2VjdGlvbnMgPSBudmRldi0+c2VuZF9zZWN0 aW9uX2NudDsKQEAgLTk5NywzNSArMTA0MiwyNyBAQCBzdGF0aWMgaW50IG5ldHZzY19jaGFuZ2Vf bXR1KHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LCBpbnQgbXR1KQogCWRldmljZV9pbmZvLnJlY3Zf c2VjdGlvbnMgPSBudmRldi0+cmVjdl9zZWN0aW9uX2NudDsKIAlkZXZpY2VfaW5mby5yZWN2X3Nl Y3Rpb25fc2l6ZSA9IG52ZGV2LT5yZWN2X3NlY3Rpb25fc2l6ZTsKIAotCXJuZGlzX2ZpbHRlcl9k ZXZpY2VfcmVtb3ZlKGhkZXYsIG52ZGV2KTsKKwlyZXQgPSBuZXR2c2NfZGV0YWNoKG5kZXYsIG52 ZGV2KTsKKwlpZiAocmV0KQorCQlnb3RvIHJvbGxiYWNrX3ZmOwogCiAJbmRldi0+bXR1ID0gbXR1 OwogCi0JbnZkZXYgPSBybmRpc19maWx0ZXJfZGV2aWNlX2FkZChoZGV2LCAmZGV2aWNlX2luZm8p OwotCWlmIChJU19FUlIobnZkZXYpKSB7Ci0JCXJldCA9IFBUUl9FUlIobnZkZXYpOwotCi0JCS8q IEF0dGVtcHQgcm9sbGJhY2sgdG8gb3JpZ2luYWwgTVRVICovCi0JCW5kZXYtPm10dSA9IG9yaWdf bXR1OwotCQludmRldiA9IHJuZGlzX2ZpbHRlcl9kZXZpY2VfYWRkKGhkZXYsICZkZXZpY2VfaW5m byk7Ci0KLQkJaWYgKHZmX25ldGRldikKLQkJCWRldl9zZXRfbXR1KHZmX25ldGRldiwgb3JpZ19t dHUpOwotCi0JCWlmIChJU19FUlIobnZkZXYpKSB7Ci0JCQluZXRkZXZfZXJyKG5kZXYsICJyZXN0 b3JpbmcgbXR1IGZhaWxlZDogJWxkXG4iLAotCQkJCSAgIFBUUl9FUlIobnZkZXYpKTsKLQkJCXJl dHVybiByZXQ7Ci0JCX0KLQl9CisJcmV0ID0gbmV0dnNjX2F0dGFjaChuZGV2LCAmZGV2aWNlX2lu Zm8pOworCWlmIChyZXQpCisJCWdvdG8gcm9sbGJhY2s7CiAKLQlpZiAod2FzX29wZW5lZCkKLQkJ cm5kaXNfZmlsdGVyX29wZW4obnZkZXYpOworCXJldHVybiAwOwogCi0JbmV0aWZfZGV2aWNlX2F0 dGFjaChuZGV2KTsKK3JvbGxiYWNrOgorCS8qIEF0dGVtcHQgcm9sbGJhY2sgdG8gb3JpZ2luYWwg TVRVICovCisJbmRldi0+bXR1ID0gb3JpZ19tdHU7CiAKLQkvKiBXZSBtYXkgaGF2ZSBtaXNzZWQg bGluayBjaGFuZ2Ugbm90aWZpY2F0aW9ucyAqLwotCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmbmRl dmN0eC0+ZHdvcmssIDApOworCWlmIChuZXR2c2NfYXR0YWNoKG5kZXYsICZkZXZpY2VfaW5mbykp CisJCW5ldGRldl9lcnIobmRldiwgInJlc3RvcmluZyBtdHUgZmFpbGVkXG4iKTsKK3JvbGxiYWNr X3ZmOgorCWlmICh2Zl9uZXRkZXYpCisJCWRldl9zZXRfbXR1KHZmX25ldGRldiwgb3JpZ19tdHUp OwogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTE1MzEsMTEgKzE1NjgsOSBAQCBzdGF0aWMgaW50IG5l dHZzY19zZXRfcmluZ3BhcmFtKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LAogewogCXN0cnVjdCBu ZXRfZGV2aWNlX2NvbnRleHQgKm5kZXZjdHggPSBuZXRkZXZfcHJpdihuZGV2KTsKIAlzdHJ1Y3Qg bmV0dnNjX2RldmljZSAqbnZkZXYgPSBydG5sX2RlcmVmZXJlbmNlKG5kZXZjdHgtPm52ZGV2KTsK LQlzdHJ1Y3QgaHZfZGV2aWNlICpoZGV2ID0gbmRldmN0eC0+ZGV2aWNlX2N0eDsKIAlzdHJ1Y3Qg bmV0dnNjX2RldmljZV9pbmZvIGRldmljZV9pbmZvOwogCXN0cnVjdCBldGh0b29sX3JpbmdwYXJh bSBvcmlnOwogCXUzMiBuZXdfdHgsIG5ld19yeDsKLQlib29sIHdhc19vcGVuZWQ7CiAJaW50IHJl dCA9IDA7CiAKIAlpZiAoIW52ZGV2IHx8IG52ZGV2LT5kZXN0cm95KQpAQCAtMTU2MCwzNCArMTU5 NSwxOCBAQCBzdGF0aWMgaW50IG5ldHZzY19zZXRfcmluZ3BhcmFtKHN0cnVjdCBuZXRfZGV2aWNl ICpuZGV2LAogCWRldmljZV9pbmZvLnJlY3Zfc2VjdGlvbnMgPSBuZXdfcng7CiAJZGV2aWNlX2lu Zm8ucmVjdl9zZWN0aW9uX3NpemUgPSBudmRldi0+cmVjdl9zZWN0aW9uX3NpemU7CiAKLQluZXRp Zl9kZXZpY2VfZGV0YWNoKG5kZXYpOwotCXdhc19vcGVuZWQgPSBybmRpc19maWx0ZXJfb3BlbmVk KG52ZGV2KTsKLQlpZiAod2FzX29wZW5lZCkKLQkJcm5kaXNfZmlsdGVyX2Nsb3NlKG52ZGV2KTsK LQotCXJuZGlzX2ZpbHRlcl9kZXZpY2VfcmVtb3ZlKGhkZXYsIG52ZGV2KTsKLQotCW52ZGV2ID0g cm5kaXNfZmlsdGVyX2RldmljZV9hZGQoaGRldiwgJmRldmljZV9pbmZvKTsKLQlpZiAoSVNfRVJS KG52ZGV2KSkgewotCQlyZXQgPSBQVFJfRVJSKG52ZGV2KTsKKwlyZXQgPSBuZXR2c2NfZGV0YWNo KG5kZXYsIG52ZGV2KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OwogCisJcmV0ID0gbmV0dnNj X2F0dGFjaChuZGV2LCAmZGV2aWNlX2luZm8pOworCWlmIChyZXQpIHsKIAkJZGV2aWNlX2luZm8u c2VuZF9zZWN0aW9ucyA9IG9yaWcudHhfcGVuZGluZzsKIAkJZGV2aWNlX2luZm8ucmVjdl9zZWN0 aW9ucyA9IG9yaWcucnhfcGVuZGluZzsKLQkJbnZkZXYgPSBybmRpc19maWx0ZXJfZGV2aWNlX2Fk ZChoZGV2LCAmZGV2aWNlX2luZm8pOwotCQlpZiAoSVNfRVJSKG52ZGV2KSkgewotCQkJbmV0ZGV2 X2VycihuZGV2LCAicmVzdG9yaW5nIHJpbmdwYXJhbSBmYWlsZWQ6ICVsZFxuIiwKLQkJCQkgICBQ VFJfRVJSKG52ZGV2KSk7Ci0JCQlyZXR1cm4gcmV0OwotCQl9Ci0JfQotCi0JaWYgKHdhc19vcGVu ZWQpCi0JCXJuZGlzX2ZpbHRlcl9vcGVuKG52ZGV2KTsKLQluZXRpZl9kZXZpY2VfYXR0YWNoKG5k ZXYpOwogCi0JLyogV2UgbWF5IGhhdmUgbWlzc2VkIGxpbmsgY2hhbmdlIG5vdGlmaWNhdGlvbnMg Ki8KLQluZGV2Y3R4LT5sYXN0X3JlY29uZmlnID0gMDsKLQlzY2hlZHVsZV9kZWxheWVkX3dvcmso Jm5kZXZjdHgtPmR3b3JrLCAwKTsKKwkJaWYgKG5ldHZzY19hdHRhY2gobmRldiwgJmRldmljZV9p bmZvKSkKKwkJCW5ldGRldl9lcnIobmRldiwgInJlc3RvcmluZyByaW5ncGFyYW0gZmFpbGVkIik7 CisJfQogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTIwNzIsOCArMjA5MSw4IEBAIHN0YXRpYyBpbnQg bmV0dnNjX3Byb2JlKHN0cnVjdCBodl9kZXZpY2UgKmRldiwKIHN0YXRpYyBpbnQgbmV0dnNjX3Jl bW92ZShzdHJ1Y3QgaHZfZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IG5ldF9kZXZpY2VfY29udGV4 dCAqbmRldl9jdHg7Ci0Jc3RydWN0IG5ldF9kZXZpY2UgKnZmX25ldGRldjsKLQlzdHJ1Y3QgbmV0 X2RldmljZSAqbmV0OworCXN0cnVjdCBuZXRfZGV2aWNlICp2Zl9uZXRkZXYsICpuZXQ7CisJc3Ry dWN0IG5ldHZzY19kZXZpY2UgKm52ZGV2OwogCiAJbmV0ID0gaHZfZ2V0X2RydmRhdGEoZGV2KTsK IAlpZiAobmV0ID09IE5VTEwpIHsKQEAgLTIwODMsOCArMjEwMiw2IEBAIHN0YXRpYyBpbnQgbmV0 dnNjX3JlbW92ZShzdHJ1Y3QgaHZfZGV2aWNlICpkZXYpCiAKIAluZGV2X2N0eCA9IG5ldGRldl9w cml2KG5ldCk7CiAKLQluZXRpZl9kZXZpY2VfZGV0YWNoKG5ldCk7Ci0KIAljYW5jZWxfZGVsYXll ZF93b3JrX3N5bmMoJm5kZXZfY3R4LT5kd29yayk7CiAKIAkvKgpAQCAtMjA5MiwxNCArMjEwOSwx OSBAQCBzdGF0aWMgaW50IG5ldHZzY19yZW1vdmUoc3RydWN0IGh2X2RldmljZSAqZGV2KQogCSAq IHJlbW92ZWQuIEFsc28gYmxvY2tzIG10dSBhbmQgY2hhbm5lbCBjaGFuZ2VzLgogCSAqLwogCXJ0 bmxfbG9jaygpOworCiAJdmZfbmV0ZGV2ID0gcnRubF9kZXJlZmVyZW5jZShuZGV2X2N0eC0+dmZf bmV0ZGV2KTsKIAlpZiAodmZfbmV0ZGV2KQogCQluZXR2c2NfdW5yZWdpc3Rlcl92Zih2Zl9uZXRk ZXYpOwogCisJbnZkZXYgPSBydG5sX2RlcmVmZXJlbmNlKG5kZXZfY3R4LT5udmRldik7CisJaWYg KG52ZGV2KSB7CisJCWNhbmNlbF93b3JrX3N5bmMoJm52ZGV2LT5zdWJjaGFuX3dvcmspOworCQly bmRpc19maWx0ZXJfZGV2aWNlX3JlbW92ZShkZXYsIG52ZGV2KTsKKwl9CisKIAl1bnJlZ2lzdGVy X25ldGRldmljZShuZXQpOwogCi0Jcm5kaXNfZmlsdGVyX2RldmljZV9yZW1vdmUoZGV2LAotCQkJ CSAgIHJ0bmxfZGVyZWZlcmVuY2UobmRldl9jdHgtPm52ZGV2KSk7CiAJcnRubF91bmxvY2soKTsK IAogCWh2X3NldF9kcnZkYXRhKGRldiwgTlVMTCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9o eXBlcnYvcm5kaXNfZmlsdGVyLmMgYi9kcml2ZXJzL25ldC9oeXBlcnYvcm5kaXNfZmlsdGVyLmMK aW5kZXggYTk3NDZmOWZiZjRiLi4zY2NiMGM2MjYzYTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0 L2h5cGVydi9ybmRpc19maWx0ZXIuYworKysgYi9kcml2ZXJzL25ldC9oeXBlcnYvcm5kaXNfZmls dGVyLmMKQEAgLTExMjIsNiArMTEyMiw3IEBAIHZvaWQgcm5kaXNfc2V0X3N1YmNoYW5uZWwoc3Ry dWN0IHdvcmtfc3RydWN0ICp3KQogCWZvciAoaSA9IDA7IGkgPCBWUlNTX1NFTkRfVEFCX1NJWkU7 IGkrKykKIAkJbmRldl9jdHgtPnR4X3RhYmxlW2ldID0gaSAlIG52ZGV2LT5udW1fY2huOwogCisJ bmV0aWZfdHhfd2FrZV9hbGxfcXVldWVzKG5kZXYpOwogCXJ0bmxfdW5sb2NrKCk7CiAJcmV0dXJu OwogCkBAIC0xMTMyLDYgKzExMzMsNyBAQCB2b2lkIHJuZGlzX3NldF9zdWJjaGFubmVsKHN0cnVj dCB3b3JrX3N0cnVjdCAqdykKIAogCW52ZGV2LT5tYXhfY2huID0gMTsKIAludmRldi0+bnVtX2No biA9IDE7CisJbmV0aWZfd2FrZV9xdWV1ZShuZGV2KTsKIHVubG9jazoKIAlydG5sX3VubG9jaygp OwogfQpAQCAtMTMyNiw2ICsxMzI4LDggQEAgc3RydWN0IG5ldHZzY19kZXZpY2UgKnJuZGlzX2Zp bHRlcl9kZXZpY2VfYWRkKHN0cnVjdCBodl9kZXZpY2UgKmRldiwKIAogCWlmIChuZXRfZGV2aWNl LT5udW1fY2huID4gMSkKIAkJc2NoZWR1bGVfd29yaygmbmV0X2RldmljZS0+c3ViY2hhbl93b3Jr KTsKKwllbHNlCisJCW5ldGlmX3dha2VfcXVldWUobmV0KTsKIAogb3V0OgogCS8qIGlmIHVuYXZh aWxhYmxlLCBqdXN0IHByb2NlZWQgd2l0aCBvbmUgcXVldWUgKi8KQEAgLTEzNDYsOSArMTM1MCw2 IEBAIHZvaWQgcm5kaXNfZmlsdGVyX2RldmljZV9yZW1vdmUoc3RydWN0IGh2X2RldmljZSAqZGV2 LAogewogCXN0cnVjdCBybmRpc19kZXZpY2UgKnJuZGlzX2RldiA9IG5ldF9kZXYtPmV4dGVuc2lv bjsKIAotCS8qIERvbid0IHRyeSBhbmQgc2V0dXAgc3ViIGNoYW5uZWxzIGlmIGFib3V0IHRvIGhh bHQgKi8KLQljYW5jZWxfd29ya19zeW5jKCZuZXRfZGV2LT5zdWJjaGFuX3dvcmspOwotCiAJLyog SGFsdCBhbmQgcmVsZWFzZSB0aGUgcm5kaXMgZGV2aWNlICovCiAJcm5kaXNfZmlsdGVyX2hhbHRf ZGV2aWNlKG5ldF9kZXYsIHJuZGlzX2Rldik7CiAKQEAgLTEzNzIsMTAgKzEzNzMsMyBAQCBpbnQg cm5kaXNfZmlsdGVyX2Nsb3NlKHN0cnVjdCBuZXR2c2NfZGV2aWNlICpudmRldikKIAogCXJldHVy biBybmRpc19maWx0ZXJfY2xvc2VfZGV2aWNlKG52ZGV2LT5leHRlbnNpb24pOwogfQotCi1ib29s IHJuZGlzX2ZpbHRlcl9vcGVuZWQoY29uc3Qgc3RydWN0IG5ldHZzY19kZXZpY2UgKm52ZGV2KQot ewotCWNvbnN0IHN0cnVjdCBybmRpc19kZXZpY2UgKmRldiA9IG52ZGV2LT5leHRlbnNpb247Ci0K LQlyZXR1cm4gZGV2LT5zdGF0ZSA9PSBSTkRJU19ERVZfREFUQUlOSVRJQUxJWkVEOwotfQotLSAK Mi4xNi4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K ZGV2ZWwgbWFpbGluZyBsaXN0CmRldmVsQGxpbnV4ZHJpdmVycHJvamVjdC5vcmcKaHR0cDovL2Ry aXZlcmRldi5saW51eGRyaXZlcnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8vZHJpdmVyZGV2 LWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stephen Hemminger Subject: Re: [PATCH] hv_netvsc: Make sure out channel is fully opened on send Date: Thu, 15 Mar 2018 10:40:52 -0700 Message-ID: <20180315104052.14698f66@xeon-e3> References: <1520968010-20733-1-git-send-email-mgamal@redhat.com> <20180313123521.5b486da1@xeon-e3> <1521019321.8260.1.camel@redhat.com> <1521131053.30828.1.camel@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Cc: netdev@vger.kernel.org, sthemmin@microsoft.com, otubo@redhat.com, linux-kernel@vger.kernel.org, devel@linuxdriverproject.org, vkuznets@redhat.com, davem@davemloft.net To: Mohammed Gamal Return-path: In-Reply-To: <1521131053.30828.1.camel@redhat.com> Sender: linux-kernel-owner@vger.kernel.org List-Id: netdev.vger.kernel.org On Thu, 15 Mar 2018 17:24:13 +0100 Mohammed Gamal wrote: > On Wed, 2018-03-14 at 10:22 +0100, Mohammed Gamal wrote: > > On Tue, 2018-03-13 at 12:35 -0700, Stephen Hemminger wrote: =20 > > > On Tue, 13 Mar 2018 20:06:50 +0100 > > > Mohammed Gamal wrote: > > > =20 > > > > Dring high network traffic changes to network interface > > > > parameters > > > > such as number of channels or MTU can cause a kernel panic with a > > > > NULL > > > > pointer dereference. This is due to netvsc_device_remove() being > > > > called and deallocating the channel ring buffers, which can then > > > > be > > > > accessed by netvsc_send_pkt() before they're allocated on calling > > > > netvsc_device_add() > > > >=20 > > > > The patch fixes this problem by checking the channel state and > > > > returning > > > > ENODEV if not yet opened. We also move the call to > > > > hv_ringbuf_avail_percent() > > > > which may access the uninitialized ring buffer. > > > >=20 > > > > Signed-off-by: Mohammed Gamal > > > > --- > > > > =C2=A0drivers/net/hyperv/netvsc.c | 5 +++-- > > > > =C2=A01 file changed, 3 insertions(+), 2 deletions(-) > > > >=20 > > > > diff --git a/drivers/net/hyperv/netvsc.c > > > > b/drivers/net/hyperv/netvsc.c > > > > index 0265d70..44a8358 100644 > > > > --- a/drivers/net/hyperv/netvsc.c > > > > +++ b/drivers/net/hyperv/netvsc.c > > > > @@ -757,7 +757,7 @@ static inline int netvsc_send_pkt( > > > > =C2=A0 struct netdev_queue *txq =3D netdev_get_tx_queue(ndev, > > > > packet->q_idx); > > > > =C2=A0 u64 req_id; > > > > =C2=A0 int ret; > > > > - u32 ring_avail =3D hv_ringbuf_avail_percent(&out_channel- =20 > > > > > outbound); =20 > > > >=20 > > > > + u32 ring_avail; > > > > =C2=A0 > > > > =C2=A0 nvmsg.hdr.msg_type =3D NVSP_MSG1_TYPE_SEND_RNDIS_PKT; > > > > =C2=A0 if (skb) > > > > @@ -773,7 +773,7 @@ static inline int netvsc_send_pkt( > > > > =C2=A0 > > > > =C2=A0 req_id =3D (ulong)skb; > > > > =C2=A0 > > > > - if (out_channel->rescind) > > > > + if (out_channel->rescind || out_channel->state !=3D > > > > CHANNEL_OPENED_STATE) > > > > =C2=A0 return -ENODEV; > > > > =C2=A0 > > > > =C2=A0 if (packet->page_buf_cnt) { > > > > @@ -791,6 +791,7 @@ static inline int netvsc_send_pkt( > > > > =C2=A0 =C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0VMBUS_DATA_PACK= ET_FLAG_CO > > > > MP > > > > LETION_REQUESTED); > > > > =C2=A0 } > > > > =C2=A0 > > > > + ring_avail =3D hv_ringbuf_avail_percent(&out_channel- =20 > > > > > outbound); =20 > > > >=20 > > > > =C2=A0 if (ret =3D=3D 0) { > > > > =C2=A0 atomic_inc_return(&nvchan->queue_sends); > > > > =C2=A0 =20 > > >=20 > > > Thanks for your patch. Yes there are races with the current update > > > logic. The root cause goes higher up in the flow; the send queues > > > should > > > be stopped before netvsc_device_remove is called. Solving it where > > > you tried > > > to is racy and not going to work reliably. > > >=20 > > > Network patches should go to netdev@vger.kernel.org > > >=20 > > > You can't move the ring_avail check until after the > > > vmbus_sendpacket > > > because > > > that will break the flow control logic. > > > =20 > >=20 > > Why? I don't see ring_avail being used before that point. =20 >=20 > Ah, stupid me. vmbus_sendpacket() will write to the ring buffer and > that means that ring_avail value will be different than the expected. >=20 > > =20 > > > Instead, you should just move the avail_read check until just after > > > the existing rescind > > > check. > > >=20 > > > Also, you shouldn't need to check for OPENED_STATE, just rescind is > > > enough. =20 > >=20 > > That rarely mitigated the race. channel->rescind flag is set on vmbus > > exit - called on module unload - and when a rescind offer is received > > from the host, which AFAICT doesn't happen on every call to > > netvsc_device_remove, so it's quite possible that the ringbuffer is > > accessed before it's allocated again on channel open and hence the > > check for OPENED_STAT - which is only set after all vmbus data is > > initialized. > > =20 >=20 > Perhaps I haven't been clear enough. The NULL pointer dereference > happens in the call to hv_ringbuf_avail_percent() which is used to > calculate ring_avail.=C2=A0 >=20 > So we need to stop the queues before calling it if the channel's ring > buffers haven't been allocated yet, but OTOH we should only stop the > queues based upon the value of ring_avail, so this leads into a chicken > and egg situation.=C2=A0 >=20 > Is my observation here correct? Please correct me if I am wrong, > Stephen. This is a far more drastic work of the shutdown logic which I am still work= ing on. The current netvsc driver is not doing a good job of handling concurrent send/receives during ring changes. =46rom a22da18b41ad5024340dddcc989d918987836f6d Mon Sep 17 00:00:00 2001 From: Stephen Hemminger Date: Tue, 6 Feb 2018 15:05:19 -0800 Subject: [PATCH] hv_netvsc: common detach logic Make common function for detaching internals of device during changes to MTU and RSS. Make sure no more packets are transmitted and all packets have been received before doing device teardown. Changes transmit enabling logic so that transmit queues are disabled during the period when lower device is being changed. And enabled only after sub channels are setup. This avoids issue where it could be that a packet was being sent while subchannel was not initialized. Signed-off-by: Stephen Hemminger --- drivers/net/hyperv/hyperv_net.h | 1 - drivers/net/hyperv/netvsc.c | 20 +-- drivers/net/hyperv/netvsc_drv.c | 268 +++++++++++++++++++++-------------= ---- drivers/net/hyperv/rndis_filter.c | 14 +- 4 files changed, 160 insertions(+), 143 deletions(-) diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_ne= t.h index cd538d5a7986..32861036c3fc 100644 --- a/drivers/net/hyperv/hyperv_net.h +++ b/drivers/net/hyperv/hyperv_net.h @@ -212,7 +212,6 @@ void netvsc_channel_cb(void *context); int netvsc_poll(struct napi_struct *napi, int budget); =20 void rndis_set_subchannel(struct work_struct *w); -bool rndis_filter_opened(const struct netvsc_device *nvdev); int rndis_filter_open(struct netvsc_device *nvdev); int rndis_filter_close(struct netvsc_device *nvdev); struct netvsc_device *rndis_filter_device_add(struct hv_device *dev, diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c index 8c95a3797b2f..31b1c6c430bb 100644 --- a/drivers/net/hyperv/netvsc.c +++ b/drivers/net/hyperv/netvsc.c @@ -573,8 +573,6 @@ void netvsc_device_remove(struct hv_device *device) =3D rtnl_dereference(net_device_ctx->nvdev); int i; =20 - cancel_work_sync(&net_device->subchan_work); - netvsc_revoke_buf(device, net_device); =20 RCU_INIT_POINTER(net_device_ctx->nvdev, NULL); @@ -661,14 +659,18 @@ static void netvsc_send_tx_complete(struct netvsc_dev= ice *net_device, queue_sends =3D atomic_dec_return(&net_device->chan_table[q_idx].queue_sends); =20 - if (net_device->destroy && queue_sends =3D=3D 0) - wake_up(&net_device->wait_drain); + if (unlikely(net_device->destroy)) { + if (queue_sends =3D=3D 0) + wake_up(&net_device->wait_drain); + } else { + struct netdev_queue *txq =3D netdev_get_tx_queue(ndev, q_idx); =20 - if (netif_tx_queue_stopped(netdev_get_tx_queue(ndev, q_idx)) && - (hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_HI= WATER || - queue_sends < 1)) { - netif_tx_wake_queue(netdev_get_tx_queue(ndev, q_idx)); - ndev_ctx->eth_stats.wake_queue++; + if (netif_tx_queue_stopped(txq) && + (hv_ringbuf_avail_percent(&channel->outbound) > RING_AVAIL_PERCENT_H= IWATER || + queue_sends < 1)) { + netif_tx_wake_queue(txq); + ndev_ctx->eth_stats.wake_queue++; + } } } =20 diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_dr= v.c index faea0be18924..721fac7cad81 100644 --- a/drivers/net/hyperv/netvsc_drv.c +++ b/drivers/net/hyperv/netvsc_drv.c @@ -46,7 +46,8 @@ =20 #include "hyperv_net.h" =20 -#define RING_SIZE_MIN 64 +#define RING_SIZE_MIN 64 +#define RETRY_MAX 2000 =20 #define LINKCHANGE_INT (2 * HZ) #define VF_TAKEOVER_INT (HZ / 10) @@ -123,10 +124,8 @@ static int netvsc_open(struct net_device *net) } =20 rdev =3D nvdev->extension; - if (!rdev->link_state) { + if (!rdev->link_state) netif_carrier_on(net); - netif_tx_wake_all_queues(net); - } =20 if (vf_netdev) { /* Setting synthetic device up transparently sets @@ -142,36 +141,25 @@ static int netvsc_open(struct net_device *net) return 0; } =20 -static int netvsc_close(struct net_device *net) +static int netvsc_wait_until_empty(struct netvsc_device *nvdev) { - struct net_device_context *net_device_ctx =3D netdev_priv(net); - struct net_device *vf_netdev - =3D rtnl_dereference(net_device_ctx->vf_netdev); - struct netvsc_device *nvdev =3D rtnl_dereference(net_device_ctx->nvdev); - int ret =3D 0; - u32 aread, i, msec =3D 10, retry =3D 0, retry_max =3D 20; - struct vmbus_channel *chn; - - netif_tx_disable(net); - - /* No need to close rndis filter if it is removed already */ - if (!nvdev) - goto out; - - ret =3D rndis_filter_close(nvdev); - if (ret !=3D 0) { - netdev_err(net, "unable to close device (ret %d).\n", ret); - return ret; - } + unsigned int retry =3D 0; + int i; =20 /* Ensure pending bytes in ring are read */ - while (true) { - aread =3D 0; + for (;;) { + u32 aread =3D 0; + for (i =3D 0; i < nvdev->num_chn; i++) { - chn =3D nvdev->chan_table[i].channel; + struct vmbus_channel *chn + =3D nvdev->chan_table[i].channel; + if (!chn) continue; =20 + /* make sure receive not running now */ + napi_synchronize(&nvdev->chan_table[i].napi); + aread =3D hv_get_bytes_to_read(&chn->inbound); if (aread) break; @@ -181,22 +169,40 @@ static int netvsc_close(struct net_device *net) break; } =20 - retry++; - if (retry > retry_max || aread =3D=3D 0) - break; + if (aread =3D=3D 0) + return 0; =20 - msleep(msec); + if (++retry > RETRY_MAX) + return -ETIMEDOUT; =20 - if (msec < 1000) - msec *=3D 2; + usleep_range(1000, 2000); } +} =20 - if (aread) { - netdev_err(net, "Ring buffer not empty after closing rndis\n"); - ret =3D -ETIMEDOUT; +static int netvsc_close(struct net_device *net) +{ + struct net_device_context *net_device_ctx =3D netdev_priv(net); + struct net_device *vf_netdev + =3D rtnl_dereference(net_device_ctx->vf_netdev); + struct netvsc_device *nvdev =3D rtnl_dereference(net_device_ctx->nvdev); + int ret; + + netif_tx_disable(net); + + /* No need to close rndis filter if it is removed already */ + if (!nvdev) + return 0; + + ret =3D rndis_filter_close(nvdev); + if (ret !=3D 0) { + netdev_err(net, "unable to close device (ret %d).\n", ret); + return ret; } =20 -out: + ret =3D netvsc_wait_until_empty(nvdev); + if (ret) + netdev_err(net, "Ring buffer not empty after closing rndis\n"); + if (vf_netdev) dev_close(vf_netdev); =20 @@ -845,16 +851,76 @@ static void netvsc_get_channels(struct net_device *ne= t, } } =20 +static int netvsc_detach(struct net_device *ndev, + struct netvsc_device *nvdev) +{ + struct net_device_context *ndev_ctx =3D netdev_priv(ndev); + struct hv_device *hdev =3D ndev_ctx->device_ctx; + int ret; + + /* Don't try continuing to try and setup sub channels */ + if (cancel_work_sync(&nvdev->subchan_work)) + nvdev->num_chn =3D 1; + + /* If device was up (receiving) then shutdown */ + if (netif_running(ndev)) { + netif_tx_disable(ndev); + + ret =3D rndis_filter_close(nvdev); + if (ret) { + netdev_err(ndev, + "unable to close device (ret %d).\n", ret); + return ret; + } + + ret =3D netvsc_wait_until_empty(nvdev); + if (ret) { + netdev_err(ndev, + "Ring buffer not empty after closing rndis\n"); + return ret; + } + } + + rndis_filter_device_remove(hdev, nvdev); + return 0; +} + +static int netvsc_attach(struct net_device *ndev, + struct netvsc_device_info *dev_info) +{ + struct net_device_context *ndev_ctx =3D netdev_priv(ndev); + struct hv_device *hdev =3D ndev_ctx->device_ctx; + struct netvsc_device *nvdev; + struct rndis_device *rdev; + int ret; + + nvdev =3D rndis_filter_device_add(hdev, dev_info); + if (IS_ERR(nvdev)) + return PTR_ERR(nvdev); + + netif_carrier_off(ndev); + + if (netif_running(ndev)) { + ret =3D rndis_filter_open(nvdev); + if (ret) + return ret; + + rdev =3D nvdev->extension; + if (!rdev->link_state) + netif_carrier_on(ndev); + } + + return 0; +} + static int netvsc_set_channels(struct net_device *net, struct ethtool_channels *channels) { struct net_device_context *net_device_ctx =3D netdev_priv(net); - struct hv_device *dev =3D net_device_ctx->device_ctx; struct netvsc_device *nvdev =3D rtnl_dereference(net_device_ctx->nvdev); unsigned int orig, count =3D channels->combined_count; struct netvsc_device_info device_info; - bool was_opened; - int ret =3D 0; + int ret; =20 /* We do not support separate count for rx, tx, or other */ if (count =3D=3D 0 || @@ -871,9 +937,6 @@ static int netvsc_set_channels(struct net_device *net, return -EINVAL; =20 orig =3D nvdev->num_chn; - was_opened =3D rndis_filter_opened(nvdev); - if (was_opened) - rndis_filter_close(nvdev); =20 memset(&device_info, 0, sizeof(device_info)); device_info.num_chn =3D count; @@ -882,28 +945,17 @@ static int netvsc_set_channels(struct net_device *net, device_info.recv_sections =3D nvdev->recv_section_cnt; device_info.recv_section_size =3D nvdev->recv_section_size; =20 - rndis_filter_device_remove(dev, nvdev); + ret =3D netvsc_detach(net, nvdev); + if (ret) + return ret; =20 - nvdev =3D rndis_filter_device_add(dev, &device_info); - if (IS_ERR(nvdev)) { - ret =3D PTR_ERR(nvdev); + ret =3D netvsc_attach(net, &device_info); + if (ret) { device_info.num_chn =3D orig; - nvdev =3D rndis_filter_device_add(dev, &device_info); - - if (IS_ERR(nvdev)) { - netdev_err(net, "restoring channel setting failed: %ld\n", - PTR_ERR(nvdev)); - return ret; - } + if (netvsc_attach(net, &device_info)) + netdev_err(net, "restoring channel setting failed\n"); } =20 - if (was_opened) - rndis_filter_open(nvdev); - - /* We may have missed link change notifications */ - net_device_ctx->last_reconfig =3D 0; - schedule_delayed_work(&net_device_ctx->dwork, 0); - return ret; } =20 @@ -969,10 +1021,8 @@ static int netvsc_change_mtu(struct net_device *ndev,= int mtu) struct net_device_context *ndevctx =3D netdev_priv(ndev); struct net_device *vf_netdev =3D rtnl_dereference(ndevctx->vf_netdev); struct netvsc_device *nvdev =3D rtnl_dereference(ndevctx->nvdev); - struct hv_device *hdev =3D ndevctx->device_ctx; int orig_mtu =3D ndev->mtu; struct netvsc_device_info device_info; - bool was_opened; int ret =3D 0; =20 if (!nvdev || nvdev->destroy) @@ -985,11 +1035,6 @@ static int netvsc_change_mtu(struct net_device *ndev,= int mtu) return ret; } =20 - netif_device_detach(ndev); - was_opened =3D rndis_filter_opened(nvdev); - if (was_opened) - rndis_filter_close(nvdev); - memset(&device_info, 0, sizeof(device_info)); device_info.num_chn =3D nvdev->num_chn; device_info.send_sections =3D nvdev->send_section_cnt; @@ -997,35 +1042,27 @@ static int netvsc_change_mtu(struct net_device *ndev= , int mtu) device_info.recv_sections =3D nvdev->recv_section_cnt; device_info.recv_section_size =3D nvdev->recv_section_size; =20 - rndis_filter_device_remove(hdev, nvdev); + ret =3D netvsc_detach(ndev, nvdev); + if (ret) + goto rollback_vf; =20 ndev->mtu =3D mtu; =20 - nvdev =3D rndis_filter_device_add(hdev, &device_info); - if (IS_ERR(nvdev)) { - ret =3D PTR_ERR(nvdev); - - /* Attempt rollback to original MTU */ - ndev->mtu =3D orig_mtu; - nvdev =3D rndis_filter_device_add(hdev, &device_info); - - if (vf_netdev) - dev_set_mtu(vf_netdev, orig_mtu); - - if (IS_ERR(nvdev)) { - netdev_err(ndev, "restoring mtu failed: %ld\n", - PTR_ERR(nvdev)); - return ret; - } - } + ret =3D netvsc_attach(ndev, &device_info); + if (ret) + goto rollback; =20 - if (was_opened) - rndis_filter_open(nvdev); + return 0; =20 - netif_device_attach(ndev); +rollback: + /* Attempt rollback to original MTU */ + ndev->mtu =3D orig_mtu; =20 - /* We may have missed link change notifications */ - schedule_delayed_work(&ndevctx->dwork, 0); + if (netvsc_attach(ndev, &device_info)) + netdev_err(ndev, "restoring mtu failed\n"); +rollback_vf: + if (vf_netdev) + dev_set_mtu(vf_netdev, orig_mtu); =20 return ret; } @@ -1531,11 +1568,9 @@ static int netvsc_set_ringparam(struct net_device *n= dev, { struct net_device_context *ndevctx =3D netdev_priv(ndev); struct netvsc_device *nvdev =3D rtnl_dereference(ndevctx->nvdev); - struct hv_device *hdev =3D ndevctx->device_ctx; struct netvsc_device_info device_info; struct ethtool_ringparam orig; u32 new_tx, new_rx; - bool was_opened; int ret =3D 0; =20 if (!nvdev || nvdev->destroy) @@ -1560,34 +1595,18 @@ static int netvsc_set_ringparam(struct net_device *= ndev, device_info.recv_sections =3D new_rx; device_info.recv_section_size =3D nvdev->recv_section_size; =20 - netif_device_detach(ndev); - was_opened =3D rndis_filter_opened(nvdev); - if (was_opened) - rndis_filter_close(nvdev); - - rndis_filter_device_remove(hdev, nvdev); - - nvdev =3D rndis_filter_device_add(hdev, &device_info); - if (IS_ERR(nvdev)) { - ret =3D PTR_ERR(nvdev); + ret =3D netvsc_detach(ndev, nvdev); + if (ret) + return ret; =20 + ret =3D netvsc_attach(ndev, &device_info); + if (ret) { device_info.send_sections =3D orig.tx_pending; device_info.recv_sections =3D orig.rx_pending; - nvdev =3D rndis_filter_device_add(hdev, &device_info); - if (IS_ERR(nvdev)) { - netdev_err(ndev, "restoring ringparam failed: %ld\n", - PTR_ERR(nvdev)); - return ret; - } - } - - if (was_opened) - rndis_filter_open(nvdev); - netif_device_attach(ndev); =20 - /* We may have missed link change notifications */ - ndevctx->last_reconfig =3D 0; - schedule_delayed_work(&ndevctx->dwork, 0); + if (netvsc_attach(ndev, &device_info)) + netdev_err(ndev, "restoring ringparam failed"); + } =20 return ret; } @@ -2072,8 +2091,8 @@ static int netvsc_probe(struct hv_device *dev, static int netvsc_remove(struct hv_device *dev) { struct net_device_context *ndev_ctx; - struct net_device *vf_netdev; - struct net_device *net; + struct net_device *vf_netdev, *net; + struct netvsc_device *nvdev; =20 net =3D hv_get_drvdata(dev); if (net =3D=3D NULL) { @@ -2083,8 +2102,6 @@ static int netvsc_remove(struct hv_device *dev) =20 ndev_ctx =3D netdev_priv(net); =20 - netif_device_detach(net); - cancel_delayed_work_sync(&ndev_ctx->dwork); =20 /* @@ -2092,14 +2109,19 @@ static int netvsc_remove(struct hv_device *dev) * removed. Also blocks mtu and channel changes. */ rtnl_lock(); + vf_netdev =3D rtnl_dereference(ndev_ctx->vf_netdev); if (vf_netdev) netvsc_unregister_vf(vf_netdev); =20 + nvdev =3D rtnl_dereference(ndev_ctx->nvdev); + if (nvdev) { + cancel_work_sync(&nvdev->subchan_work); + rndis_filter_device_remove(dev, nvdev); + } + unregister_netdevice(net); =20 - rndis_filter_device_remove(dev, - rtnl_dereference(ndev_ctx->nvdev)); rtnl_unlock(); =20 hv_set_drvdata(dev, NULL); diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_f= ilter.c index a9746f9fbf4b..3ccb0c6263a8 100644 --- a/drivers/net/hyperv/rndis_filter.c +++ b/drivers/net/hyperv/rndis_filter.c @@ -1122,6 +1122,7 @@ void rndis_set_subchannel(struct work_struct *w) for (i =3D 0; i < VRSS_SEND_TAB_SIZE; i++) ndev_ctx->tx_table[i] =3D i % nvdev->num_chn; =20 + netif_tx_wake_all_queues(ndev); rtnl_unlock(); return; =20 @@ -1132,6 +1133,7 @@ void rndis_set_subchannel(struct work_struct *w) =20 nvdev->max_chn =3D 1; nvdev->num_chn =3D 1; + netif_wake_queue(ndev); unlock: rtnl_unlock(); } @@ -1326,6 +1328,8 @@ struct netvsc_device *rndis_filter_device_add(struct = hv_device *dev, =20 if (net_device->num_chn > 1) schedule_work(&net_device->subchan_work); + else + netif_wake_queue(net); =20 out: /* if unavailable, just proceed with one queue */ @@ -1346,9 +1350,6 @@ void rndis_filter_device_remove(struct hv_device *dev, { struct rndis_device *rndis_dev =3D net_dev->extension; =20 - /* Don't try and setup sub channels if about to halt */ - cancel_work_sync(&net_dev->subchan_work); - /* Halt and release the rndis device */ rndis_filter_halt_device(net_dev, rndis_dev); =20 @@ -1372,10 +1373,3 @@ int rndis_filter_close(struct netvsc_device *nvdev) =20 return rndis_filter_close_device(nvdev->extension); } - -bool rndis_filter_opened(const struct netvsc_device *nvdev) -{ - const struct rndis_device *dev =3D nvdev->extension; - - return dev->state =3D=3D RNDIS_DEV_DATAINITIALIZED; -} --=20 2.16.1