From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from shards.monkeyblade.net ([184.105.139.130]:55146 "EHLO shards.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750967AbdALTG6 (ORCPT ); Thu, 12 Jan 2017 14:06:58 -0500 Received: from localhost (unknown [66.187.232.66]) (Authenticated sender: davem-davemloft) by shards.monkeyblade.net (Postfix) with ESMTPSA id 3F88512141B4F for ; Thu, 12 Jan 2017 09:56:05 -0800 (PST) Date: Thu, 12 Jan 2017 13:55:10 -0500 (EST) Message-Id: <20170112.135510.905380628057229394.davem@davemloft.net> To: stable@vger.kernel.org Subject: [PATCHES] Networking From: David Miller Mime-Version: 1.0 Content-Type: Multipart/Mixed; boundary="--Next_Part(Thu_Jan_12_13_55_10_2017_630)--" Content-Transfer-Encoding: 7bit Sender: stable-owner@vger.kernel.org List-ID: ----Next_Part(Thu_Jan_12_13_55_10_2017_630)-- Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Please queue up the following networking bug fixes for 4.4.x and 4.9.x -stable, respectively. Thanks! ----Next_Part(Thu_Jan_12_13_55_10_2017_630)-- Content-Type: Application/Octet-Stream Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="net_44.mbox" RnJvbSAzYmZmMzhlNzM1Y2RjMDgwNjNiN2MwNGJiNTY0OTg1NzQxZGZlOGNmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBzdGVwaGVuIGhlbW1pbmdlciA8c3RlcGhlbkBuZXR3b3JrcGx1 bWJlci5vcmc+CkRhdGU6IFR1ZSwgNiBEZWMgMjAxNiAxMzo0Mzo1NCAtMDgwMApTdWJqZWN0OiBb UEFUQ0ggMDEvMTldIG5ldHZzYzogcmVkdWNlIG1heGltdW0gR1NPIHNpemUKClsgVXBzdHJlYW0g Y29tbWl0IGE1MGFmODZkZDQ5ZWUxODUxZDFjY2YwNmRkMDAxOWMwNWI5NWUyOTcgXQoKSHlwZXIt ViAoYW5kIEF6dXJlKSBzdXBwb3J0IHVzaW5nIE5WR1JFIHdoaWNoIHJlcXVpcmVzIHNvbWUgZXh0 cmEgc3BhY2UKZm9yIGVuY2Fwc3VsYXRpb24gaGVhZGVycy4gQmVjYXVzZSBvZiB0aGlzIHRoZSBs YXJnZXN0IGFsbG93ZWQgVFNPCnBhY2tldCBpcyByZWR1Y2VkLgoKRm9yIG9sZGVyIHJlbGVhc2Vz LCBoYXJkIGNvZGUgYSBmaXhlZCByZWR1Y2VkIHZhbHVlLiAgRm9yIG5leHQgcmVsZWFzZSwKdGhl cmUgaXMgYSBiZXR0ZXIgc29sdXRpb24gd2hpY2ggdXNlcyByZXN1bHQgb2YgaG9zdCBvZmZsb2Fk Cm5lZ290aWF0aW9uLgoKU2lnbmVkLW9mZi1ieTogU3RlcGhlbiBIZW1taW5nZXIgPHN0aGVtbWlu QG1pY3Jvc29mdC5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2 ZW1sb2Z0Lm5ldD4KLS0tCiBkcml2ZXJzL25ldC9oeXBlcnYvbmV0dnNjX2Rydi5jIHwgMyArKysK IDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL25l dC9oeXBlcnYvbmV0dnNjX2Rydi5jIGIvZHJpdmVycy9uZXQvaHlwZXJ2L25ldHZzY19kcnYuYwpp bmRleCA0MDliNDhlLi43YTYwMWQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9oeXBlcnYvbmV0 dnNjX2Rydi5jCisrKyBiL2RyaXZlcnMvbmV0L2h5cGVydi9uZXR2c2NfZHJ2LmMKQEAgLTQwLDYg KzQwLDggQEAKIAogI2luY2x1ZGUgImh5cGVydl9uZXQuaCIKIAorLyogUmVzdHJpY3QgR1NPIHNp emUgdG8gYWNjb3VudCBmb3IgTlZHUkUgKi8KKyNkZWZpbmUgTkVUVlNDX0dTT19NQVhfU0laRQk2 Mjc2OAogCiAjZGVmaW5lIFJJTkdfU0laRV9NSU4gNjQKIHN0YXRpYyBpbnQgcmluZ19zaXplID0g MTI4OwpAQCAtODUyLDYgKzg1NCw3IEBAIHN0YXRpYyBpbnQgbmV0dnNjX3NldF9jaGFubmVscyhz dHJ1Y3QgbmV0X2RldmljZSAqbmV0LAogCQl9CiAJCWdvdG8gcmVjb3ZlcjsKIAl9CisJbmV0aWZf c2V0X2dzb19tYXhfc2l6ZShuZXQsIE5FVFZTQ19HU09fTUFYX1NJWkUpOwogCiAgb3V0OgogCW5l dHZzY19vcGVuKG5ldCk7Ci0tIAoyLjcuNAoKCkZyb20gNzRjZjFiMTVjMDgxOWNmZDM3YWRiMWRj NDNjMTQ2NDdkZTRmMzg0NCBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogRGFuIENhcnBl bnRlciA8ZGFuLmNhcnBlbnRlckBvcmFjbGUuY29tPgpEYXRlOiBXZWQsIDcgRGVjIDIwMTYgMTQ6 MjI6MDMgKzAzMDAKU3ViamVjdDogW1BBVENIIDAyLzE5XSBzZXJfZ2lnYXNldDogcmV0dXJuIC1F Tk9NRU0gb24gZXJyb3IgaW5zdGVhZCBvZiBzdWNjZXNzCgpbIFVwc3RyZWFtIGNvbW1pdCA5M2E5 N2M1MGNiZjFjMDA3Y2FmMTJkYjVjYzIzZTBkNWI5Yzg0NzNjIF0KCklmIHdlIGNhbid0IGFsbG9j YXRlIHRoZSByZXNvdXJjZXMgaW4gZ2lnYXNldF9pbml0ZHJpdmVyKCkgdGhlbiB3ZQpzaG91bGQg cmV0dXJuIC1FTk9NRU0gaW5zdGVhZCBvZiB6ZXJvLgoKRml4ZXM6IDI4NjliMjNlNGI5NSAoIltQ QVRDSF0gZHJpdmVycy9pc2RuL2dpZ2FzZXQ6IG5ldyBNMTAxIGRyaXZlciAodjIpIikKU2lnbmVk LW9mZi1ieTogRGFuIENhcnBlbnRlciA8ZGFuLmNhcnBlbnRlckBvcmFjbGUuY29tPgpTaWduZWQt b2ZmLWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogZHJpdmVy cy9pc2RuL2dpZ2FzZXQvc2VyLWdpZ2FzZXQuYyB8IDQgKysrLQogMSBmaWxlIGNoYW5nZWQsIDMg aW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9n aWdhc2V0L3Nlci1naWdhc2V0LmMgYi9kcml2ZXJzL2lzZG4vZ2lnYXNldC9zZXItZ2lnYXNldC5j CmluZGV4IDJhNTA2ZmUuLjc0YmYxYTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaXNkbi9naWdhc2V0 L3Nlci1naWdhc2V0LmMKKysrIGIvZHJpdmVycy9pc2RuL2dpZ2FzZXQvc2VyLWdpZ2FzZXQuYwpA QCAtNzYyLDggKzc2MiwxMCBAQCBzdGF0aWMgaW50IF9faW5pdCBzZXJfZ2lnYXNldF9pbml0KHZv aWQpCiAJZHJpdmVyID0gZ2lnYXNldF9pbml0ZHJpdmVyKEdJR0FTRVRfTUlOT1IsIEdJR0FTRVRf TUlOT1JTLAogCQkJCSAgICBHSUdBU0VUX01PRFVMRU5BTUUsIEdJR0FTRVRfREVWTkFNRSwKIAkJ CQkgICAgJm9wcywgVEhJU19NT0RVTEUpOwotCWlmICghZHJpdmVyKQorCWlmICghZHJpdmVyKSB7 CisJCXJjID0gLUVOT01FTTsKIAkJZ290byBlcnJvcjsKKwl9CiAKIAlyYyA9IHR0eV9yZWdpc3Rl cl9sZGlzYyhOX0dJR0FTRVRfTTEwMSwgJmdpZ2FzZXRfbGRpc2MpOwogCWlmIChyYyAhPSAwKSB7 Ci0tIAoyLjcuNAoKCkZyb20gODZhMzYzNDI5ZTE1MTQyZTg2MmM1YjA5Njc5YzliYmRiNzBiY2Nj ZiBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogRGF2aWQgQWhlcm4gPGRzYUBjdW11bHVz bmV0d29ya3MuY29tPgpEYXRlOiBXZWQsIDE0IERlYyAyMDE2IDE0OjMxOjExIC0wODAwClN1Ympl Y3Q6IFtQQVRDSCAwMy8xOV0gbmV0OiB2cmY6IERyb3AgY29ubnRyYWNrIGRhdGEgYWZ0ZXIgcGFz cyB0aHJvdWdoIFZSRgogZGV2aWNlIG9uIFR4CgpbIFVwc3RyZWFtIGNvbW1pdCBlYjYzZWNjMTcw NmIzZTA5NGQwZjU3NDM4YjZjMjA2N2NmYzI5OWYyIF0KCkxvY2FsbHkgb3JpZ2luYXRlZCB0cmFm ZmljIGluIGEgVlJGIGZhaWxzIGluIHRoZSBwcmVzZW5jZSBvZiBhIFBPU1RST1VUSU5HCnJ1bGUu IEZvciBleGFtcGxlLAoKICAgICQgaXB0YWJsZXMgLXQgbmF0IC1BIFBPU1RST1VUSU5HIC1zIDEx LjEuMS4wLzI0ICAtaiBNQVNRVUVSQURFCiAgICAkIHBpbmcgLUkgcmVkIC1jMSAxMS4xLjEuMwog ICAgcGluZzogV2FybmluZzogc291cmNlIGFkZHJlc3MgbWlnaHQgYmUgc2VsZWN0ZWQgb24gZGV2 aWNlIG90aGVyIHRoYW4gcmVkLgogICAgUElORyAxMS4xLjEuMyAoMTEuMS4xLjMpIGZyb20gMTEu MS4xLjIgcmVkOiA1Nig4NCkgYnl0ZXMgb2YgZGF0YS4KICAgIHBpbmc6IHNlbmRtc2c6IE9wZXJh dGlvbiBub3QgcGVybWl0dGVkCgpXb3JzZSwgdGhlIGFib3ZlIGNhdXNlcyByYW5kb20gY29ycnVw dGlvbiByZXN1bHRpbmcgaW4gYSBwYW5pYyBpbiByYW5kb20KcGxhY2VzIChJIGhhdmUgbm90IHNl ZW4gYSBjb25zaXN0ZW50IGJhY2t0cmFjZSkuCgpDYWxsIG5mX3Jlc2V0IHRvIGRyb3AgdGhlIGNv bm50cmFjayBpbmZvIGZvbGxvd2luZyB0aGUgcGFzcyB0aHJvdWdoIHRoZQpWUkYgZGV2aWNlLiAg VGhlIG5mX3Jlc2V0IGlzIG5lZWRlZCBvbiBUeCBidXQgbm90IFJ4IGJlY2F1c2Ugb2YgdGhlIG9y ZGVyCmluIHdoaWNoIE5GX0hPT0sncyBhcmUgaGl0OiBvbiBSeCB0aGUgVlJGIGRldmljZSBpcyBh ZnRlciB0aGUgcmVhbCBpbmdyZXNzCmRldmljZSBhbmQgb24gVHggaXQgaXMgaXMgYmVmb3JlIHRo ZSByZWFsIGVncmVzcyBkZXZpY2UuIENvbm5lY3Rpb24KdHJhY2tpbmcgc2hvdWxkIGJlIHRpZWQg dG8gdGhlIHJlYWwgZWdyZXNzIGRldmljZSBhbmQgbm90IHRoZSBWUkYgZGV2aWNlLgoKRml4ZXM6 IDhmNTgzMzZkM2Y3OGEgKCJuZXQ6IEFkZCBldGhlcm5ldCBoZWFkZXIgZm9yIHBhc3MgdGhyb3Vn aCBWUkYgZGV2aWNlIikKRml4ZXM6IDM1NDAyZTMxMzY2MzQgKCJuZXQ6IEFkZCBJUHY2IHN1cHBv cnQgdG8gVlJGIGRldmljZSIpClNpZ25lZC1vZmYtYnk6IERhdmlkIEFoZXJuIDxkc2FAY3VtdWx1 c25ldHdvcmtzLmNvbT4KU2lnbmVkLW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZl bWxvZnQubmV0PgotLS0KIGRyaXZlcnMvbmV0L3ZyZi5jIHwgNCArKysrCiAxIGZpbGUgY2hhbmdl ZCwgNCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdnJmLmMgYi9kcml2 ZXJzL25ldC92cmYuYwppbmRleCA5MDNiZGE0Li44NmY1OWNhIDEwMDY0NAotLS0gYS9kcml2ZXJz L25ldC92cmYuYworKysgYi9kcml2ZXJzL25ldC92cmYuYwpAQCAtNDEwLDYgKzQxMCw4IEBAIHN0 YXRpYyBpbnQgdnJmX2ZpbmlzaF9vdXRwdXQ2KHN0cnVjdCBuZXQgKm5ldCwgc3RydWN0IHNvY2sg KnNrLAogCXN0cnVjdCBpbjZfYWRkciAqbmV4dGhvcDsKIAlpbnQgcmV0OwogCisJbmZfcmVzZXQo c2tiKTsKKwogCXNrYi0+cHJvdG9jb2wgPSBodG9ucyhFVEhfUF9JUFY2KTsKIAlza2ItPmRldiA9 IGRldjsKIApAQCAtNTIxLDYgKzUyMyw4IEBAIHN0YXRpYyBpbnQgdnJmX2ZpbmlzaF9vdXRwdXQo c3RydWN0IG5ldCAqbmV0LCBzdHJ1Y3Qgc29jayAqc2ssIHN0cnVjdCBza19idWZmICpzCiAJdTMy IG5leHRob3A7CiAJaW50IHJldCA9IC1FSU5WQUw7CiAKKwluZl9yZXNldChza2IpOworCiAJLyog QmUgcGFyYW5vaWQsIHJhdGhlciB0aGFuIHRvbyBjbGV2ZXIuICovCiAJaWYgKHVubGlrZWx5KHNr Yl9oZWFkcm9vbShza2IpIDwgaGhfbGVuICYmIGRldi0+aGVhZGVyX29wcykpIHsKIAkJc3RydWN0 IHNrX2J1ZmYgKnNrYjI7Ci0tIAoyLjcuNAoKCkZyb20gYzViN2M3OGE0ODJmNWIwYzU1YjhjYTc3 YzFhOWIwMDBlZTY4OGQ2YiBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogRGF2ZSBKb25l cyA8ZGF2ZWpAY29kZW1vbmtleS5vcmcudWs+CkRhdGU6IFRodSwgMjIgRGVjIDIwMTYgMTE6MTY6 MjIgLTA1MDAKU3ViamVjdDogW1BBVENIIDA0LzE5XSBpcHY2OiBoYW5kbGUgLUVGQVVMVCBmcm9t IHNrYl9jb3B5X2JpdHMKClsgVXBzdHJlYW0gY29tbWl0IGE5OGY5MTc1ODk5NWNiNTk2MTFlNjEz MThkZGRkOGE2OTU2YjUyYzMgXQoKQnkgc2V0dGluZyBjZXJ0YWluIHNvY2tldCBvcHRpb25zIG9u IGlwdjYgcmF3IHNvY2tldHMsIHdlIGNhbiBjb25mdXNlIHRoZQpsZW5ndGggY2FsY3VsYXRpb24g aW4gcmF3djZfcHVzaF9wZW5kaW5nX2ZyYW1lcyB0cmlnZ2VyaW5nIGEgQlVHX09OLgoKUklQOiAw MDEwOls8ZmZmZmZmZmY4MTdjNjM5MD5dIFs8ZmZmZmZmZmY4MTdjNjM5MD5dIHJhd3Y2X3NlbmRt c2crMHhjMzAvMHhjNDAKUlNQOiAwMDE4OmZmZmY4ODFmNmM0YTdjMTggIEVGTEFHUzogMDAwMTAy ODIKUkFYOiAwMDAwMDAwMGZmZmZmZmYyIFJCWDogZmZmZjg4MWY2YzY4MTY4MCBSQ1g6IDAwMDAw MDAwMDAwMDAwMDIKUkRYOiBmZmZmODgxZjZjNGE3Y2Y4IFJTSTogMDAwMDAwMDAwMDAwMDAzMCBS REk6IGZmZmY4ODFmZWQwZjZhMDAKUkJQOiBmZmZmODgxZjZjNGE3ZGE4IFIwODogMDAwMDAwMDAw MDAwMDAwMCBSMDk6IDAwMDAwMDAwMDAwMDAwMDkKUjEwOiBmZmZmODgxZmVkMGY2YTAwIFIxMTog MDAwMDAwMDAwMDAwMDAwOSBSMTI6IDAwMDAwMDAwMDAwMDAwMzAKUjEzOiBmZmZmODgxZmVkMGY2 YTAwIFIxNDogZmZmZjg4MWZlZTM5YmEwMCBSMTU6IGZmZmY4ODFmZWZhOTNhODAKCkNhbGwgVHJh Y2U6CiBbPGZmZmZmZmZmODExOGJhMjM+XSA/IHVubWFwX3BhZ2VfcmFuZ2UrMHg2OTMvMHg4MzAK IFs8ZmZmZmZmZmY4MTc3MjY5Nz5dIGluZXRfc2VuZG1zZysweDY3LzB4YTAKIFs8ZmZmZmZmZmY4 MTZkOTNmOD5dIHNvY2tfc2VuZG1zZysweDM4LzB4NTAKIFs8ZmZmZmZmZmY4MTZkOTgyZj5dIFNZ U0Nfc2VuZHRvKzB4ZWYvMHgxNzAKIFs8ZmZmZmZmZmY4MTZkYTI3ZT5dIFN5U19zZW5kdG8rMHhl LzB4MTAKIFs8ZmZmZmZmZmY4MTAwMjkxMD5dIGRvX3N5c2NhbGxfNjQrMHg1MC8weGEwCiBbPGZm ZmZmZmZmODE3ZjdjYmM+XSBlbnRyeV9TWVNDQUxMNjRfc2xvd19wYXRoKzB4MjUvMHgyNQoKSGFu ZGxlIGJ5IGp1bXBpbmcgdG8gdGhlIGZhaWx1cmUgcGF0aCBpZiBza2JfY29weV9iaXRzIGdldHMg YW4gRUZBVUxULgoKUmVwcm9kdWNlcjoKCiNpbmNsdWRlIDxzdGRpby5oPgojaW5jbHVkZSA8c3Rk bGliLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVkZSA8 c3lzL3R5cGVzLmg+CiNpbmNsdWRlIDxzeXMvc29ja2V0Lmg+CiNpbmNsdWRlIDxuZXRpbmV0L2lu Lmg+CgojZGVmaW5lIExFTiA1MDQKCmludCBtYWluKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCnsK CWludCBmZDsKCWludCB6ZXJvID0gMDsKCWNoYXIgYnVmW0xFTl07CgoJbWVtc2V0KGJ1ZiwgMCwg TEVOKTsKCglmZCA9IHNvY2tldChBRl9JTkVUNiwgU09DS19SQVcsIDcpOwoKCXNldHNvY2tvcHQo ZmQsIFNPTF9JUFY2LCBJUFY2X0NIRUNLU1VNLCAmemVybywgNCk7CglzZXRzb2Nrb3B0KGZkLCBT T0xfSVBWNiwgSVBWNl9EU1RPUFRTLCAmYnVmLCBMRU4pOwoKCXNlbmR0byhmZCwgYnVmLCAxLCAw LCAoc3RydWN0IHNvY2thZGRyICopIGJ1ZiwgMTEwKTsKfQoKU2lnbmVkLW9mZi1ieTogRGF2ZSBK b25lcyA8ZGF2ZWpAY29kZW1vbmtleS5vcmcudWs+ClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1p bGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBuZXQvaXB2Ni9yYXcuYyB8IDYgKysrKyst CiAxIGZpbGUgY2hhbmdlZCwgNSBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0t Z2l0IGEvbmV0L2lwdjYvcmF3LmMgYi9uZXQvaXB2Ni9yYXcuYwppbmRleCA5OTE0MDk4Li44YmNh OTBkIDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9yYXcuYworKysgYi9uZXQvaXB2Ni9yYXcuYwpAQCAt NTg5LDcgKzU4OSwxMSBAQCBzdGF0aWMgaW50IHJhd3Y2X3B1c2hfcGVuZGluZ19mcmFtZXMoc3Ry dWN0IHNvY2sgKnNrLCBzdHJ1Y3QgZmxvd2k2ICpmbDYsCiAJfQogCiAJb2Zmc2V0ICs9IHNrYl90 cmFuc3BvcnRfb2Zmc2V0KHNrYik7Ci0JQlVHX09OKHNrYl9jb3B5X2JpdHMoc2tiLCBvZmZzZXQs ICZjc3VtLCAyKSk7CisJZXJyID0gc2tiX2NvcHlfYml0cyhza2IsIG9mZnNldCwgJmNzdW0sIDIp OworCWlmIChlcnIgPCAwKSB7CisJCWlwNl9mbHVzaF9wZW5kaW5nX2ZyYW1lcyhzayk7CisJCWdv dG8gb3V0OworCX0KIAogCS8qIGluIGNhc2UgY2tzdW0gd2FzIG5vdCBpbml0aWFsaXplZCAqLwog CWlmICh1bmxpa2VseShjc3VtKSkKLS0gCjIuNy40CgoKRnJvbSBiNWYxZjE5YmIxMTBjMjg2NTc5 YTBjNDIyZjkwNWU3YjcyNDY4ODkyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5p ZWwgQm9ya21hbm4gPGRhbmllbEBpb2dlYXJib3gubmV0PgpEYXRlOiBXZWQsIDIxIERlYyAyMDE2 IDE4OjA0OjExICswMTAwClN1YmplY3Q6IFtQQVRDSCAwNS8xOV0gbmV0LCBzY2hlZDogZml4IHNv ZnQgbG9ja3VwIGluIHRjX2NsYXNzaWZ5CgpbIFVwc3RyZWFtIGNvbW1pdCA2MjgxODVjZmRkZjFk ZmI3MDFjNGVmZTJjZmQ3MmNmNWIwOWY1NzAyIF0KClNoYWhhciByZXBvcnRlZCBhIHNvZnQgbG9j a3VwIGluIHRjX2NsYXNzaWZ5KCksIHdoZXJlIHdlIHJ1biBpbnRvIGFuCmVuZGxlc3MgbG9vcCB3 aGVuIHdhbGtpbmcgdGhlIGNsYXNzaWZpZXIgY2hhaW4gZHVlIHRvIHRwLT5uZXh0ID09IHRwCndo aWNoIGlzIGEgc3RhdGUgd2Ugc2hvdWxkIG5ldmVyIHJ1biBpbnRvLiBUaGUgaXNzdWUgb25seSBz ZWVtcyB0bwp0cmlnZ2VyIHVuZGVyIGxvYWQgaW4gdGhlIHRjIGNvbnRyb2wgcGF0aC4KCldoYXQg aGFwcGVucyBpcyB0aGF0IGluIHRjX2N0bF90ZmlsdGVyKCksIHRocmVhZCBBIGFsbG9jYXRlcyBh IG5ldwp0cCwgaW5pdGlhbGl6ZXMgaXQsIHNldHMgdHBfY3JlYXRlZCB0byAxLCBhbmQgY2FsbHMg aW50byB0cC0+b3BzLT5jaGFuZ2UoKQp3aXRoIGl0LiBJbiB0aGF0IGNsYXNzaWZpZXIgY2FsbGJh Y2sgd2UgaGFkIHRvIHVubG9jay9sb2NrIHRoZSBydG5sCm11dGV4IGFuZCByZXR1cm5lZCB3aXRo IC1FQUdBSU4uIE9uZSByZWFzb24gd2h5IHdlIG5lZWQgdG8gZHJvcCB0aGVyZQppcywgZm9yIGV4 YW1wbGUsIHRoYXQgd2UgbmVlZCB0byByZXF1ZXN0IGFuIGFjdGlvbiBtb2R1bGUgdG8gYmUgbG9h ZGVkLgoKVGhpcyBoYXBwZW5zIHZpYSB0Y2ZfZXh0c192YWxpZGF0ZSgpIC0+IHRjZl9hY3Rpb25f aW5pdC9fMSgpIG1lYW5pbmcKYWZ0ZXIgd2UgbG9hZGVkIGFuZCBmb3VuZCB0aGUgcmVxdWVzdGVk IGFjdGlvbiwgd2UgbmVlZCB0byByZWRvIHRoZQp3aG9sZSByZXF1ZXN0IHNvIHdlIGRvbid0IHJh Y2UgYWdhaW5zdCBvdGhlcnMuIFdoaWxlIHdlIGhhZCB0byB1bmxvY2sKcnRubCBpbiB0aGF0IHRp bWUsIHRocmVhZCBCJ3MgcmVxdWVzdCB3YXMgcHJvY2Vzc2VkIG5leHQgb24gdGhhdCBDUFUuClRo cmVhZCBCIGFkZGVkIGEgbmV3IHRwIGluc3RhbmNlIHN1Y2Nlc3NmdWxseSB0byB0aGUgY2xhc3Np ZmllciBjaGFpbi4KV2hlbiB0aHJlYWQgQSByZXR1cm5lZCBncmFiYmluZyB0aGUgcnRubCBtdXRl eCBhZ2FpbiwgcHJvcGFnYXRpbmcgLUVBR0FJTgphbmQgZGVzdHJveWluZyBpdHMgdHAgaW5zdGFu Y2Ugd2hpY2ggbmV2ZXIgZ290IGxpbmtlZCwgd2UgZ290byByZXBsYXkKYW5kIHJlZG8gQSdzIHJl cXVlc3QuCgpUaGlzIHRpbWUgd2hlbiB3YWxraW5nIHRoZSBjbGFzc2lmaWVyIGNoYWluIGluIHRj X2N0bF90ZmlsdGVyKCkgZm9yCmNoZWNraW5nIGZvciBleGlzdGluZyB0cCBpbnN0YW5jZXMgd2Ug aGFkIGEgcHJpb3JpdHkgbWF0Y2ggYW5kIGZvdW5kCnRoZSB0cCBpbnN0YW5jZSB0aGF0IHdhcyBj cmVhdGVkIGFuZCBsaW5rZWQgYnkgdGhyZWFkIEIuIE5vdyBjYWxsaW5nCmFnYWluIGludG8gdHAt Pm9wcy0+Y2hhbmdlKCkgd2l0aCB0aGF0IHRwIHdhcyBzdWNjZXNzZnVsIGFuZCByZXR1cm5lZAp3 aXRob3V0IGVycm9yLgoKdHBfY3JlYXRlZCB3YXMgbmV2ZXIgY2xlYXJlZCBpbiB0aGUgc2Vjb25k IHJvdW5kLCB0aHVzIGtlcm5lbCB0aGlua3MKdGhhdCB3ZSBuZWVkIHRvIGxpbmsgaXQgaW50byB0 aGUgY2xhc3NpZmllciBjaGFpbiAob25jZSBhZ2FpbikuIHRwIGFuZAoqYmFjayBwb2ludCB0byB0 aGUgc2FtZSBvYmplY3QgZHVlIHRvIHRoZSBtYXRjaCB3ZSBoYWQgZWFybGllciBvbi4gVGh1cwpm b3IgdGhyZWFkIEIncyBhbHJlYWR5IHB1YmxpYyB0cCwgd2UgcmVzZXQgdHAtPm5leHQgdG8gdHAg aXRzZWxmIGFuZApsaW5rIGl0IGludG8gdGhlIGNoYWluLCB3aGljaCBldmVudHVhbGx5IGNhdXNl cyB0aGUgbWVudGlvbmVkIGVuZGxlc3MKbG9vcCBpbiB0Y19jbGFzc2lmeSgpIG9uY2UgYSBwYWNr ZXQgaGl0cyB0aGUgZGF0YSBwYXRoLgoKRml4IGlzIHRvIGNsZWFyIHRwX2NyZWF0ZWQgYXQgdGhl IGJlZ2lubmluZyBvZiBlYWNoIHJlcXVlc3QsIGFsc28gd2hlbgp3ZSByZXBsYXkgaXQuIE9uIHRo ZSBwYXRocyB0aGF0IGNhbiBjYXVzZSAtRUFHQUlOIHdlIGFscmVhZHkgZGVzdHJveQp0aGUgb3Jp Z2luYWwgdHAgaW5zdGFuY2Ugd2UgaGFkIGFuZCBvbiByZXBsYXkgd2UgcmVhbGx5IG5lZWQgdG8g c3RhcnQKZnJvbSBzY3JhdGNoLiBJdCBzZWVtcyB0aGF0IHRoaXMgaXNzdWUgd2FzIGZpcnN0IGlu dHJvZHVjZWQgaW4gY29tbWl0CjEyMTg2YmU3ZDJlMSAoIm5ldF9jbHM6IGZpeCB1bmNvbmZpZ3Vy ZWQgc3RydWN0IHRjZl9wcm90byBrZWVwcyBjaGFpbmluZwphbmQgYXZvaWQga2VybmVsIHBhbmlj IHdoZW4gd2UgdXNlIGNsc19jZ3JvdXAiKS4KCkZpeGVzOiAxMjE4NmJlN2QyZTEgKCJuZXRfY2xz OiBmaXggdW5jb25maWd1cmVkIHN0cnVjdCB0Y2ZfcHJvdG8ga2VlcHMgY2hhaW5pbmcgYW5kIGF2 b2lkIGtlcm5lbCBwYW5pYyB3aGVuIHdlIHVzZSBjbHNfY2dyb3VwIikKUmVwb3J0ZWQtYnk6IFNo YWhhciBLbGVpbiA8c2hhaGFya0BtZWxsYW5veC5jb20+ClNpZ25lZC1vZmYtYnk6IERhbmllbCBC b3JrbWFubiA8ZGFuaWVsQGlvZ2VhcmJveC5uZXQ+CkNjOiBDb25nIFdhbmcgPHhpeW91Lndhbmdj b25nQGdtYWlsLmNvbT4KQWNrZWQtYnk6IEVyaWMgRHVtYXpldCA8ZWR1bWF6ZXRAZ29vZ2xlLmNv bT4KVGVzdGVkLWJ5OiBTaGFoYXIgS2xlaW4gPHNoYWhhcmtAbWVsbGFub3guY29tPgpTaWduZWQt b2ZmLWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogbmV0L3Nj aGVkL2Nsc19hcGkuYyB8IDQgKysrLQogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwg MSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9jbHNfYXBpLmMgYi9uZXQvc2No ZWQvY2xzX2FwaS5jCmluZGV4IGVjYzE5MDQuLjIwYjJmODYgMTAwNjQ0Ci0tLSBhL25ldC9zY2hl ZC9jbHNfYXBpLmMKKysrIGIvbmV0L3NjaGVkL2Nsc19hcGkuYwpAQCAtMTM3LDEzICsxMzcsMTUg QEAgc3RhdGljIGludCB0Y19jdGxfdGZpbHRlcihzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3Qg bmxtc2doZHIgKm4pCiAJdW5zaWduZWQgbG9uZyBjbDsKIAl1bnNpZ25lZCBsb25nIGZoOwogCWlu dCBlcnI7Ci0JaW50IHRwX2NyZWF0ZWQgPSAwOworCWludCB0cF9jcmVhdGVkOwogCiAJaWYgKChu LT5ubG1zZ190eXBlICE9IFJUTV9HRVRURklMVEVSKSAmJgogCSAgICAhbmV0bGlua19uc19jYXBh YmxlKHNrYiwgbmV0LT51c2VyX25zLCBDQVBfTkVUX0FETUlOKSkKIAkJcmV0dXJuIC1FUEVSTTsK IAogcmVwbGF5OgorCXRwX2NyZWF0ZWQgPSAwOworCiAJZXJyID0gbmxtc2dfcGFyc2Uobiwgc2l6 ZW9mKCp0KSwgdGNhLCBUQ0FfTUFYLCBOVUxMKTsKIAlpZiAoZXJyIDwgMCkKIAkJcmV0dXJuIGVy cjsKLS0gCjIuNy40CgoKRnJvbSA0OTkxOTVhODg5NDBmYWRmMTQ2YTU1ZjVjMzVmNmMyOWFkMWU5 NDU5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBGbG9yaWFuIEZhaW5lbGxpIDxmLmZh aW5lbGxpQGdtYWlsLmNvbT4KRGF0ZTogVHVlLCAyNyBEZWMgMjAxNiAxODoyMzowNiAtMDgwMApT dWJqZWN0OiBbUEFUQ0ggMDYvMTldIG5ldDogc3RtbWFjOiBGaXggcmFjZSBiZXR3ZWVuIHN0bW1h Y19kcnZfcHJvYmUgYW5kCiBzdG1tYWNfb3BlbgoKWyBVcHN0cmVhbSBjb21taXQgNTcwMTY1OTAw NGQ2ODA4NTE4MmQyZmQ0MTk5Yzc5MTcyMTY1ZmE2NSBdCgpUaGVyZSBpcyBjdXJyZW50bHkgYSBz bWFsbCB3aW5kb3cgZHVyaW5nIHdoaWNoIHRoZSBuZXR3b3JrIGRldmljZSByZWdpc3RlcmVkIGJ5 CnN0bW1hYyBjYW4gYmUgbWFkZSB2aXNpYmxlLCB5ZXQgYWxsIHJlc291cmNlcywgaW5jbHVkaW5n IGFuZCBjbG9jayBhbmQgTURJTyBidXMKaGF2ZSBub3QgaGFkIGEgY2hhbmNlIHRvIGJlIHNldCB1 cCwgdGhpcyBjYW4gbGVhZCB0byB0aGUgZm9sbG93aW5nIGVycm9yIHRvCm9jY3VyOgoKWyAgNDcz LjkxOTM1OF0gc3RtbWFjZXRoIDAwMDA6MDE6MDAuMCAodW5uYW1lZCBuZXRfZGV2aWNlKSAodW5p bml0aWFsaXplZCk6CiAgICAgICAgICAgICAgICBzdG1tYWNfZHZyX3Byb2JlOiB3YXJuaW5nOiBj YW5ub3QgZ2V0IENTUiBjbG9jawpbICA0NzMuOTE5MzgyXSBzdG1tYWNldGggMDAwMDowMTowMC4w OiBubyByZXNldCBjb250cm9sIGZvdW5kClsgIDQ3My45MTk0MTJdIHN0bW1hYyAtIHVzZXIgSUQ6 IDB4MTAsIFN5bm9wc3lzIElEOiAweDQyClsgIDQ3My45MTk0MjldIHN0bW1hY2V0aCAwMDAwOjAx OjAwLjA6IERNQSBIVyBjYXBhYmlsaXR5IHJlZ2lzdGVyIHN1cHBvcnRlZApbICA0NzMuOTE5NDM2 XSBzdG1tYWNldGggMDAwMDowMTowMC4wOiBSWCBDaGVja3N1bSBPZmZsb2FkIEVuZ2luZSBzdXBw b3J0ZWQKWyAgNDczLjkxOTQ0M10gc3RtbWFjZXRoIDAwMDA6MDE6MDAuMDogVFggQ2hlY2tzdW0g aW5zZXJ0aW9uIHN1cHBvcnRlZApbICA0NzMuOTE5NDUxXSBzdG1tYWNldGggMDAwMDowMTowMC4w ICh1bm5hbWVkIG5ldF9kZXZpY2UpICh1bmluaXRpYWxpemVkKToKICAgICAgICAgICAgICAgIEVu YWJsZSBSWCBNaXRpZ2F0aW9uIHZpYSBIVyBXYXRjaGRvZyBUaW1lcgpbICA0NzMuOTIxMzk1XSBs aWJwaHk6IFBIWSBzdG1tYWMtMTowMCBub3QgZm91bmQKWyAgNDczLjkyMTQxN10gc3RtbWFjZXRo IDAwMDA6MDE6MDAuMCBldGgwOiBDb3VsZCBub3QgYXR0YWNoIHRvIFBIWQpbICA0NzMuOTIxNDI3 XSBzdG1tYWNldGggMDAwMDowMTowMC4wIGV0aDA6IHN0bW1hY19vcGVuOiBDYW5ub3QgYXR0YWNo IHRvCiAgICAgICAgICAgICAgICBQSFkgKGVycm9yOiAtMTkpClsgIDQ3My45NTk3MTBdIGxpYnBo eTogc3RtbWFjOiBwcm9iZWQKWyAgNDczLjk1OTcyNF0gc3RtbWFjZXRoIDAwMDA6MDE6MDAuMCBl dGgwOiBQSFkgSUQgMDE0MTBjYzIgYXQgMCBJUlEgUE9MTAogICAgICAgICAgICAgICAgKHN0bW1h Yy0xOjAwKSBhY3RpdmUKWyAgNDczLjk1OTcyOF0gc3RtbWFjZXRoIDAwMDA6MDE6MDAuMCBldGgw OiBQSFkgSUQgMDE0MTBjYzIgYXQgMSBJUlEgUE9MTAogICAgICAgICAgICAgICAgKHN0bW1hYy0x OjAxKQpbICA0NzMuOTU5NzMxXSBzdG1tYWNldGggMDAwMDowMTowMC4wIGV0aDA6IFBIWSBJRCAw MTQxMGNjMiBhdCAyIElSUSBQT0xMCiAgICAgICAgICAgICAgICAoc3RtbWFjLTE6MDIpClsgIDQ3 My45NTk3MzRdIHN0bW1hY2V0aCAwMDAwOjAxOjAwLjAgZXRoMDogUEhZIElEIDAxNDEwY2MyIGF0 IDMgSVJRIFBPTEwKICAgICAgICAgICAgICAgIChzdG1tYWMtMTowMykKCkZpeCB0aGlzIGJ5IG1h a2luZyBzdXJlIHRoYXQgcmVnaXN0ZXJfbmV0ZGV2KCkgaXMgdGhlIGxhc3QgdGhpbmcgYmVpbmcg ZG9uZSwKd2hpY2ggZ3VhcmFudGVlcyB0aGF0IHRoZSBjbG9jayBhbmQgdGhlIE1ESU8gYnVzIGFy ZSBhdmFpbGFibGUuCgpGaXhlczogNGJmY2JkN2FiY2UyICgic3RtbWFjOiBNb3ZlIHRoZSBtZGlv X3JlZ2lzdGVyL191bnJlZ2lzdGVyIGluIHByb2JlL3JlbW92ZSIpClJlcG9ydGVkLWJ5OiBLd2Vo LCBIb2NrIExlb25nIDxob2NrLmxlb25nLmt3ZWhAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBG bG9yaWFuIEZhaW5lbGxpIDxmLmZhaW5lbGxpQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogRGF2 aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0PgotLS0KIGRyaXZlcnMvbmV0L2V0aGVy bmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMgfCAyMiArKysrKysrKysrKysrLS0tLS0t LS0tCiAxIGZpbGUgY2hhbmdlZCwgMTMgaW5zZXJ0aW9ucygrKSwgOSBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfbWFp bi5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYwpp bmRleCBhNWI4NjllLi40YjEwMGVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9z dG1pY3JvL3N0bW1hYy9zdG1tYWNfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0 bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMKQEAgLTI5MzksMTIgKzI5MzksNiBAQCBpbnQgc3Rt bWFjX2R2cl9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXZpY2UsCiAJc3Bpbl9sb2NrX2luaXQoJnBy aXYtPmxvY2spOwogCXNwaW5fbG9ja19pbml0KCZwcml2LT50eF9sb2NrKTsKIAotCXJldCA9IHJl Z2lzdGVyX25ldGRldihuZGV2KTsKLQlpZiAocmV0KSB7Ci0JCXByX2VycigiJXM6IEVSUk9SICVp IHJlZ2lzdGVyaW5nIHRoZSBkZXZpY2VcbiIsIF9fZnVuY19fLCByZXQpOwotCQlnb3RvIGVycm9y X25ldGRldl9yZWdpc3RlcjsKLQl9Ci0KIAkvKiBJZiBhIHNwZWNpZmljIGNsa19jc3IgdmFsdWUg aXMgcGFzc2VkIGZyb20gdGhlIHBsYXRmb3JtCiAJICogdGhpcyBtZWFucyB0aGF0IHRoZSBDU1Ig Q2xvY2sgUmFuZ2Ugc2VsZWN0aW9uIGNhbm5vdCBiZQogCSAqIGNoYW5nZWQgYXQgcnVuLXRpbWUg YW5kIGl0IGlzIGZpeGVkLiBWaWNldmVyc2EgdGhlIGRyaXZlcidsbCB0cnkgdG8KQEAgLTI5Njks MTEgKzI5NjMsMjEgQEAgaW50IHN0bW1hY19kdnJfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2aWNl LAogCQl9CiAJfQogCi0JcmV0dXJuIDA7CisJcmV0ID0gcmVnaXN0ZXJfbmV0ZGV2KG5kZXYpOwor CWlmIChyZXQpIHsKKwkJbmV0ZGV2X2Vycihwcml2LT5kZXYsICIlczogRVJST1IgJWkgcmVnaXN0 ZXJpbmcgdGhlIGRldmljZVxuIiwKKwkJCSAgIF9fZnVuY19fLCByZXQpOworCQlnb3RvIGVycm9y X25ldGRldl9yZWdpc3RlcjsKKwl9CisKKwlyZXR1cm4gcmV0OwogCi1lcnJvcl9tZGlvX3JlZ2lz dGVyOgotCXVucmVnaXN0ZXJfbmV0ZGV2KG5kZXYpOwogZXJyb3JfbmV0ZGV2X3JlZ2lzdGVyOgor CWlmIChwcml2LT5wY3MgIT0gU1RNTUFDX1BDU19SR01JSSAmJgorCSAgICBwcml2LT5wY3MgIT0g U1RNTUFDX1BDU19UQkkgJiYKKwkgICAgcHJpdi0+cGNzICE9IFNUTU1BQ19QQ1NfUlRCSSkKKwkJ c3RtbWFjX21kaW9fdW5yZWdpc3RlcihuZGV2KTsKK2Vycm9yX21kaW9fcmVnaXN0ZXI6CiAJbmV0 aWZfbmFwaV9kZWwoJnByaXYtPm5hcGkpOwogZXJyb3JfaHdfaW5pdDoKIAljbGtfZGlzYWJsZV91 bnByZXBhcmUocHJpdi0+cGNsayk7Ci0tIAoyLjcuNAoKCkZyb20gYzY1MDcwMGQ2Nzk4ZDQ5YjBl YzU5YmMzYmRiYmE2OTZhZmIzMTA0YiBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogTm9h IE9zaGVyb3ZpY2ggPG5vYW9zQG1lbGxhbm94LmNvbT4KRGF0ZTogV2VkLCAyOCBEZWMgMjAxNiAx NDo1ODozMiArMDIwMApTdWJqZWN0OiBbUEFUQ0ggMDcvMTldIG5ldC9tbHg1OiBDaGVjayBGVyBs aW1pdGF0aW9ucyBvbiBsb2dfbWF4X3FwIGJlZm9yZQogc2V0dGluZyBpdAoKWyBVcHN0cmVhbSBj b21taXQgODgzMzcxYzQ1M2I5MzdmOWViNTgxZmI0OTE1MjEwODY1OTgyNzM2ZiBdCgpXaGVuIHNl dHRpbmcgSENBIGNhcGFiaWxpdGllcywgc2V0IGxvZ19tYXhfcXAgdG8gYmUgdGhlIG1pbmltdW0K YmV0d2VlbiB0aGUgc2VsZWN0ZWQgcHJvZmlsZSdzIHZhbHVlIGFuZCB0aGUgSENBIGxpbWl0YXRp b24uCgpGaXhlczogOTM4ZmU4M2M4ZGNiICgnbmV0L21seDVfY29yZTogTmV3IGRldmljZSBjYXBh YmlsaXRpZXMuLi4nKQpTaWduZWQtb2ZmLWJ5OiBOb2EgT3NoZXJvdmljaCA8bm9hb3NAbWVsbGFu b3guY29tPgpTaWduZWQtb2ZmLWJ5OiBTYWVlZCBNYWhhbWVlZCA8c2FlZWRtQG1lbGxhbm94LmNv bT4KU2lnbmVkLW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0Pgot LS0KIGRyaXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDUvY29yZS9tYWluLmMgfCA3ICsr KysrKysKIDEgZmlsZSBjaGFuZ2VkLCA3IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2 ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg1L2NvcmUvbWFpbi5jIGIvZHJpdmVycy9uZXQv ZXRoZXJuZXQvbWVsbGFub3gvbWx4NS9jb3JlL21haW4uYwppbmRleCA2Y2Y2ZDkzLi41NTJjZDYw IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg1L2NvcmUvbWFp bi5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDUvY29yZS9tYWluLmMK QEAgLTQzMiw2ICs0MzIsMTMgQEAgc3RhdGljIGludCBoYW5kbGVfaGNhX2NhcChzdHJ1Y3QgbWx4 NV9jb3JlX2RldiAqZGV2KQogCU1MWDVfU0VUKGNtZF9oY2FfY2FwLCBzZXRfaGNhX2NhcCwgcGtl eV90YWJsZV9zaXplLAogCQkgdG9fZndfcGtleV9zeigxMjgpKTsKIAorCS8qIENoZWNrIGxvZ19t YXhfcXAgZnJvbSBIQ0EgY2FwcyB0byBzZXQgaW4gY3VycmVudCBwcm9maWxlICovCisJaWYgKE1M WDVfQ0FQX0dFTl9NQVgoZGV2LCBsb2dfbWF4X3FwKSA8IHByb2ZpbGVbcHJvZl9zZWxdLmxvZ19t YXhfcXApIHsKKwkJbWx4NV9jb3JlX3dhcm4oZGV2LCAibG9nX21heF9xcCB2YWx1ZSBpbiBjdXJy ZW50IHByb2ZpbGUgaXMgJWQsIGNoYW5naW5nIGl0IHRvIEhDQSBjYXBhYmlsaXR5IGxpbWl0ICgl ZClcbiIsCisJCQkgICAgICAgcHJvZmlsZVtwcm9mX3NlbF0ubG9nX21heF9xcCwKKwkJCSAgICAg ICBNTFg1X0NBUF9HRU5fTUFYKGRldiwgbG9nX21heF9xcCkpOworCQlwcm9maWxlW3Byb2Zfc2Vs XS5sb2dfbWF4X3FwID0gTUxYNV9DQVBfR0VOX01BWChkZXYsIGxvZ19tYXhfcXApOworCX0KIAlp ZiAocHJvZi0+bWFzayAmIE1MWDVfUFJPRl9NQVNLX1FQX1NJWkUpCiAJCU1MWDVfU0VUKGNtZF9o Y2FfY2FwLCBzZXRfaGNhX2NhcCwgbG9nX21heF9xcCwKIAkJCSBwcm9mLT5sb2dfbWF4X3FwKTsK LS0gCjIuNy40CgoKRnJvbSA3NjFjOGVhNjJkNGRlN2NhNTQxNGNjMDcxZjc0MWE0MjU2OTU1NmY5 IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBFbGkgQ29oZW4gPGVsaUBtZWxsYW5veC5j b20+CkRhdGU6IFdlZCwgMjggRGVjIDIwMTYgMTQ6NTg6MzQgKzAyMDAKU3ViamVjdDogW1BBVENI IDA4LzE5XSBuZXQvbWx4NTogQXZvaWQgc2hhZG93aW5nIG51bWFfbm9kZQoKWyBVcHN0cmVhbSBj b21taXQgZDE1MWQ3M2RjYzk5ZGU4N2M2M2JkZWZlYmNjNGNiNjlkZTFjZGM0MCBdCgpBdm9pZCB1 c2luZyBhIGxvY2FsIHZhcmlhYmxlIG5hbWVkIG51bWFfbm9kZSB0byBhdm9pZCBzaGFkb3dpbmcg YSBwdWJsaWMKb25lLgoKRml4ZXM6IGRiMDU4YTE4NmY5OCAoJ25ldC9tbHg1X2NvcmU6IFNldCBp cnEgYWZmaW5pdHkgaGludHMnKQpTaWduZWQtb2ZmLWJ5OiBFbGkgQ29oZW4gPGVsaUBtZWxsYW5v eC5jb20+ClNpZ25lZC1vZmYtYnk6IFNhZWVkIE1haGFtZWVkIDxzYWVlZG1AbWVsbGFub3guY29t PgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0t LQogZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVsbGFub3gvbWx4NS9jb3JlL21haW4uYyB8IDMgKy0t CiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVsbGFub3gvbWx4NS9jb3JlL21haW4uYyBiL2Ry aXZlcnMvbmV0L2V0aGVybmV0L21lbGxhbm94L21seDUvY29yZS9tYWluLmMKaW5kZXggNTUyY2Q2 MC4uYmExMTVlYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvbWVsbGFub3gvbWx4 NS9jb3JlL21haW4uYworKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9tZWxsYW5veC9tbHg1L2Nv cmUvbWFpbi5jCkBAIC01MTIsNyArNTEyLDYgQEAgc3RhdGljIGludCBtbHg1X2lycV9zZXRfYWZm aW5pdHlfaGludChzdHJ1Y3QgbWx4NV9jb3JlX2RldiAqbWRldiwgaW50IGkpCiAJc3RydWN0IG1s eDVfcHJpdiAqcHJpdiAgPSAmbWRldi0+cHJpdjsKIAlzdHJ1Y3QgbXNpeF9lbnRyeSAqbXNpeCA9 IHByaXYtPm1zaXhfYXJyOwogCWludCBpcnEgICAgICAgICAgICAgICAgID0gbXNpeFtpICsgTUxY NV9FUV9WRUNfQ09NUF9CQVNFXS52ZWN0b3I7Ci0JaW50IG51bWFfbm9kZSAgICAgICAgICAgPSBw cml2LT5udW1hX25vZGU7CiAJaW50IGVycjsKIAogCWlmICghemFsbG9jX2NwdW1hc2tfdmFyKCZw cml2LT5pcnFfaW5mb1tpXS5tYXNrLCBHRlBfS0VSTkVMKSkgewpAQCAtNTIwLDcgKzUxOSw3IEBA IHN0YXRpYyBpbnQgbWx4NV9pcnFfc2V0X2FmZmluaXR5X2hpbnQoc3RydWN0IG1seDVfY29yZV9k ZXYgKm1kZXYsIGludCBpKQogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKLQljcHVtYXNrX3NldF9j cHUoY3B1bWFza19sb2NhbF9zcHJlYWQoaSwgbnVtYV9ub2RlKSwKKwljcHVtYXNrX3NldF9jcHUo Y3B1bWFza19sb2NhbF9zcHJlYWQoaSwgcHJpdi0+bnVtYV9ub2RlKSwKIAkJCXByaXYtPmlycV9p bmZvW2ldLm1hc2spOwogCiAJZXJyID0gaXJxX3NldF9hZmZpbml0eV9oaW50KGlycSwgcHJpdi0+ aXJxX2luZm9baV0ubWFzayk7Ci0tIAoyLjcuNAoKCkZyb20gNDVhOGU1YTU3YzFjNTM4ZWMwNTQ4 ZDQ1OTY2N2MyZmZkYTIzYjIxNiBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogUmVpdGVy IFdvbGZnYW5nIDx3cjAxMTIzNThAZ21haWwuY29tPgpEYXRlOiBTYXQsIDMxIERlYyAyMDE2IDIx OjExOjU3ICswMTAwClN1YmplY3Q6IFtQQVRDSCAwOS8xOV0gZHJvcF9tb25pdG9yOiBhZGQgbWlz c2luZyBjYWxsIHRvIGdlbmxtc2dfZW5kCgpbIFVwc3RyZWFtIGNvbW1pdCA0MjAwNDYyZDg4ZjQ3 ZjM3NTliZGY0NzA1Zjg3ZTIwN2IwZjViMmU0IF0KClVwZGF0ZSBubG1zZ19sZW4gZmllbGQgd2l0 aCBnZW5sbXNnX2VuZCB0byBlbmFibGUgdXNlcnNwYWNlIHByb2Nlc3NpbmcKdXNpbmcgbmxtc2df bmV4dCBoZWxwZXIuIEFsc28gYWRkcyBlcnJvciBoYW5kbGluZy4KClNpZ25lZC1vZmYtYnk6IFJl aXRlciBXb2xmZ2FuZyA8d3IwMTEyMzU4QGdtYWlsLmNvbT4KQWNrZWQtYnk6IE5laWwgSG9ybWFu IDxuaG9ybWFuQHR1eGRyaXZlci5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8 ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBuZXQvY29yZS9kcm9wX21vbml0b3IuYyB8IDMzICsr KysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDI0IGluc2Vy dGlvbnMoKyksIDkgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbmV0L2NvcmUvZHJvcF9tb25p dG9yLmMgYi9uZXQvY29yZS9kcm9wX21vbml0b3IuYwppbmRleCAyNTJlMTU1Li4zOGQzOWIwIDEw MDY0NAotLS0gYS9uZXQvY29yZS9kcm9wX21vbml0b3IuYworKysgYi9uZXQvY29yZS9kcm9wX21v bml0b3IuYwpAQCAtODAsNiArODAsNyBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKnJlc2V0X3Bl cl9jcHVfZGF0YShzdHJ1Y3QgcGVyX2NwdV9kbV9kYXRhICpkYXRhKQogCXN0cnVjdCBubGF0dHIg Km5sYTsKIAlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdm9p ZCAqbXNnX2hlYWRlcjsKIAogCWFsID0gc2l6ZW9mKHN0cnVjdCBuZXRfZG1fYWxlcnRfbXNnKTsK IAlhbCArPSBkbV9oaXRfbGltaXQgKiBzaXplb2Yoc3RydWN0IG5ldF9kbV9kcm9wX3BvaW50KTsK QEAgLTg3LDE3ICs4OCwzMSBAQCBzdGF0aWMgc3RydWN0IHNrX2J1ZmYgKnJlc2V0X3Blcl9jcHVf ZGF0YShzdHJ1Y3QgcGVyX2NwdV9kbV9kYXRhICpkYXRhKQogCiAJc2tiID0gZ2VubG1zZ19uZXco YWwsIEdGUF9LRVJORUwpOwogCi0JaWYgKHNrYikgewotCQlnZW5sbXNnX3B1dChza2IsIDAsIDAs ICZuZXRfZHJvcF9tb25pdG9yX2ZhbWlseSwKLQkJCQkwLCBORVRfRE1fQ01EX0FMRVJUKTsKLQkJ bmxhID0gbmxhX3Jlc2VydmUoc2tiLCBOTEFfVU5TUEVDLAotCQkJCSAgc2l6ZW9mKHN0cnVjdCBu ZXRfZG1fYWxlcnRfbXNnKSk7Ci0JCW1zZyA9IG5sYV9kYXRhKG5sYSk7Ci0JCW1lbXNldChtc2cs IDAsIGFsKTsKLQl9IGVsc2UgewotCQltb2RfdGltZXIoJmRhdGEtPnNlbmRfdGltZXIsIGppZmZp ZXMgKyBIWiAvIDEwKTsKKwlpZiAoIXNrYikKKwkJZ290byBlcnI7CisKKwltc2dfaGVhZGVyID0g Z2VubG1zZ19wdXQoc2tiLCAwLCAwLCAmbmV0X2Ryb3BfbW9uaXRvcl9mYW1pbHksCisJCQkJIDAs IE5FVF9ETV9DTURfQUxFUlQpOworCWlmICghbXNnX2hlYWRlcikgeworCQlubG1zZ19mcmVlKHNr Yik7CisJCXNrYiA9IE5VTEw7CisJCWdvdG8gZXJyOworCX0KKwlubGEgPSBubGFfcmVzZXJ2ZShz a2IsIE5MQV9VTlNQRUMsCisJCQkgIHNpemVvZihzdHJ1Y3QgbmV0X2RtX2FsZXJ0X21zZykpOwor CWlmICghbmxhKSB7CisJCW5sbXNnX2ZyZWUoc2tiKTsKKwkJc2tiID0gTlVMTDsKKwkJZ290byBl cnI7CiAJfQorCW1zZyA9IG5sYV9kYXRhKG5sYSk7CisJbWVtc2V0KG1zZywgMCwgYWwpOworCWdl bmxtc2dfZW5kKHNrYiwgbXNnX2hlYWRlcik7CisJZ290byBvdXQ7CiAKK2VycjoKKwltb2RfdGlt ZXIoJmRhdGEtPnNlbmRfdGltZXIsIGppZmZpZXMgKyBIWiAvIDEwKTsKK291dDoKIAlzcGluX2xv Y2tfaXJxc2F2ZSgmZGF0YS0+bG9jaywgZmxhZ3MpOwogCXN3YXAoZGF0YS0+c2tiLCBza2IpOwog CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRhdGEtPmxvY2ssIGZsYWdzKTsKLS0gCjIuNy40CgoK RnJvbSA2MmYyM2I1ODEwYzdjYmZmOWEwYjc0ZmIxYzZhNGQ3MzA1NGJlMjQwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBSZWl0ZXIgV29sZmdhbmcgPHdyMDExMjM1OEBnbWFpbC5jb20+ CkRhdGU6IFR1ZSwgMyBKYW4gMjAxNyAwMTozOToxMCArMDEwMApTdWJqZWN0OiBbUEFUQ0ggMTAv MTldIGRyb3BfbW9uaXRvcjogY29uc2lkZXIgaW5zZXJ0ZWQgZGF0YSBpbiBnZW5sbXNnX2VuZAoK WyBVcHN0cmVhbSBjb21taXQgM2I0OGFiMjI0OGU2MTQwODkxMGU3OTJmZTg0ZDZlYzQ2NjA4NGMx YSBdCgpGaW5hbCBubG1zZ19sZW4gZmllbGQgdXBkYXRlIG11c3QgcmVmbGVjdCBpbnNlcnRlZCBu ZXRfZG1fZHJvcF9wb2ludApkYXRhLgoKVGhpcyBwYXRjaCBkZXBlbmRzIG9uIHByZXZpb3VzIHBh dGNoOgoiZHJvcF9tb25pdG9yOiBhZGQgbWlzc2luZyBjYWxsIHRvIGdlbmxtc2dfZW5kIgoKU2ln bmVkLW9mZi1ieTogUmVpdGVyIFdvbGZnYW5nIDx3cjAxMTIzNThAZ21haWwuY29tPgpBY2tlZC1i eTogTmVpbCBIb3JtYW4gPG5ob3JtYW5AdHV4ZHJpdmVyLmNvbT4KU2lnbmVkLW9mZi1ieTogRGF2 aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0PgotLS0KIG5ldC9jb3JlL2Ryb3BfbW9u aXRvci5jIHwgOCArKysrKysrLQogMSBmaWxlIGNoYW5nZWQsIDcgaW5zZXJ0aW9ucygrKSwgMSBk ZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL25ldC9jb3JlL2Ryb3BfbW9uaXRvci5jIGIvbmV0L2Nv cmUvZHJvcF9tb25pdG9yLmMKaW5kZXggMzhkMzliMC4uYTIyNzAxODggMTAwNjQ0Ci0tLSBhL25l dC9jb3JlL2Ryb3BfbW9uaXRvci5jCisrKyBiL25ldC9jb3JlL2Ryb3BfbW9uaXRvci5jCkBAIC0x MDcsNyArMTA3LDYgQEAgc3RhdGljIHN0cnVjdCBza19idWZmICpyZXNldF9wZXJfY3B1X2RhdGEo c3RydWN0IHBlcl9jcHVfZG1fZGF0YSAqZGF0YSkKIAl9CiAJbXNnID0gbmxhX2RhdGEobmxhKTsK IAltZW1zZXQobXNnLCAwLCBhbCk7Ci0JZ2VubG1zZ19lbmQoc2tiLCBtc2dfaGVhZGVyKTsKIAln b3RvIG91dDsKIAogZXJyOgpAQCAtMTE3LDYgKzExNiwxMyBAQCBvdXQ6CiAJc3dhcChkYXRhLT5z a2IsIHNrYik7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGF0YS0+bG9jaywgZmxhZ3MpOwog CisJaWYgKHNrYikgeworCQlzdHJ1Y3Qgbmxtc2doZHIgKm5saCA9IChzdHJ1Y3Qgbmxtc2doZHIg Kilza2ItPmRhdGE7CisJCXN0cnVjdCBnZW5sbXNnaGRyICpnbmxoID0gKHN0cnVjdCBnZW5sbXNn aGRyICopbmxtc2dfZGF0YShubGgpOworCisJCWdlbmxtc2dfZW5kKHNrYiwgZ2VubG1zZ19kYXRh KGdubGgpKTsKKwl9CisKIAlyZXR1cm4gc2tiOwogfQogCi0tIAoyLjcuNAoKCkZyb20gZGZkOWZj OGMxNmNmZDJkOTVjYWIwMjM5YzJlZjExMzRlMzI0MDNmNCBNb24gU2VwIDE3IDAwOjAwOjAwIDIw MDEKRnJvbTogTWljaGFsIFRlc2FyIDxtdGVzYXJAcmVkaGF0LmNvbT4KRGF0ZTogTW9uLCAyIEph biAyMDE3IDE0OjM4OjM2ICswMTAwClN1YmplY3Q6IFtQQVRDSCAxMS8xOV0gaWdtcDogTWFrZSBp Z21wIGdyb3VwIG1lbWJlciBSRkMgMzM3NiBjb21wbGlhbnQKClsgVXBzdHJlYW0gY29tbWl0IDdh YmFiYjc4MjY5MGUwM2I3ODY1N2UyN2JkMDUxZTIwMTYzYWYyZDYgXQoKNS4yLiBBY3Rpb24gb24g UmVjZXB0aW9uIG9mIGEgUXVlcnkKCiBXaGVuIGEgc3lzdGVtIHJlY2VpdmVzIGEgUXVlcnksIGl0 IGRvZXMgbm90IHJlc3BvbmQgaW1tZWRpYXRlbHkuCiBJbnN0ZWFkLCBpdCBkZWxheXMgaXRzIHJl c3BvbnNlIGJ5IGEgcmFuZG9tIGFtb3VudCBvZiB0aW1lLCBib3VuZGVkCiBieSB0aGUgTWF4IFJl c3AgVGltZSB2YWx1ZSBkZXJpdmVkIGZyb20gdGhlIE1heCBSZXNwIENvZGUgaW4gdGhlCiByZWNl aXZlZCBRdWVyeSBtZXNzYWdlLiAgQSBzeXN0ZW0gbWF5IHJlY2VpdmUgYSB2YXJpZXR5IG9mIFF1 ZXJpZXMgb24KIGRpZmZlcmVudCBpbnRlcmZhY2VzIGFuZCBvZiBkaWZmZXJlbnQga2luZHMgKGUu Zy4sIEdlbmVyYWwgUXVlcmllcywKIEdyb3VwLVNwZWNpZmljIFF1ZXJpZXMsIGFuZCBHcm91cC1h bmQtU291cmNlLVNwZWNpZmljIFF1ZXJpZXMpLCBlYWNoCiBvZiB3aGljaCBtYXkgcmVxdWlyZSBp dHMgb3duIGRlbGF5ZWQgcmVzcG9uc2UuCgogQmVmb3JlIHNjaGVkdWxpbmcgYSByZXNwb25zZSB0 byBhIFF1ZXJ5LCB0aGUgc3lzdGVtIG11c3QgZmlyc3QKIGNvbnNpZGVyIHByZXZpb3VzbHkgc2No ZWR1bGVkIHBlbmRpbmcgcmVzcG9uc2VzIGFuZCBpbiBtYW55IGNhc2VzCiBzY2hlZHVsZSBhIGNv bWJpbmVkIHJlc3BvbnNlLiAgVGhlcmVmb3JlLCB0aGUgc3lzdGVtIG11c3QgYmUgYWJsZSB0bwog bWFpbnRhaW4gdGhlIGZvbGxvd2luZyBzdGF0ZToKCiBvIEEgdGltZXIgcGVyIGludGVyZmFjZSBm b3Igc2NoZWR1bGluZyByZXNwb25zZXMgdG8gR2VuZXJhbCBRdWVyaWVzLgoKIG8gQSBwZXItZ3Jv dXAgYW5kIGludGVyZmFjZSB0aW1lciBmb3Igc2NoZWR1bGluZyByZXNwb25zZXMgdG8gR3JvdXAt CiAgIFNwZWNpZmljIGFuZCBHcm91cC1hbmQtU291cmNlLVNwZWNpZmljIFF1ZXJpZXMuCgogbyBB IHBlci1ncm91cCBhbmQgaW50ZXJmYWNlIGxpc3Qgb2Ygc291cmNlcyB0byBiZSByZXBvcnRlZCBp biB0aGUKICAgcmVzcG9uc2UgdG8gYSBHcm91cC1hbmQtU291cmNlLVNwZWNpZmljIFF1ZXJ5LgoK IFdoZW4gYSBuZXcgUXVlcnkgd2l0aCB0aGUgUm91dGVyLUFsZXJ0IG9wdGlvbiBhcnJpdmVzIG9u IGFuCiBpbnRlcmZhY2UsIHByb3ZpZGVkIHRoZSBzeXN0ZW0gaGFzIHN0YXRlIHRvIHJlcG9ydCwg YSBkZWxheSBmb3IgYQogcmVzcG9uc2UgaXMgcmFuZG9tbHkgc2VsZWN0ZWQgaW4gdGhlIHJhbmdl ICgwLCBbTWF4IFJlc3AgVGltZV0pIHdoZXJlCiBNYXggUmVzcCBUaW1lIGlzIGRlcml2ZWQgZnJv bSBNYXggUmVzcCBDb2RlIGluIHRoZSByZWNlaXZlZCBRdWVyeQogbWVzc2FnZS4gIFRoZSBmb2xs b3dpbmcgcnVsZXMgYXJlIHRoZW4gdXNlZCB0byBkZXRlcm1pbmUgaWYgYSBSZXBvcnQKIG5lZWRz IHRvIGJlIHNjaGVkdWxlZCBhbmQgdGhlIHR5cGUgb2YgUmVwb3J0IHRvIHNjaGVkdWxlLiAgVGhl IHJ1bGVzCiBhcmUgY29uc2lkZXJlZCBpbiBvcmRlciBhbmQgb25seSB0aGUgZmlyc3QgbWF0Y2hp bmcgcnVsZSBpcyBhcHBsaWVkLgoKIDEuIElmIHRoZXJlIGlzIGEgcGVuZGluZyByZXNwb25zZSB0 byBhIHByZXZpb3VzIEdlbmVyYWwgUXVlcnkKICAgIHNjaGVkdWxlZCBzb29uZXIgdGhhbiB0aGUg c2VsZWN0ZWQgZGVsYXksIG5vIGFkZGl0aW9uYWwgcmVzcG9uc2UKICAgIG5lZWRzIHRvIGJlIHNj aGVkdWxlZC4KCiAyLiBJZiB0aGUgcmVjZWl2ZWQgUXVlcnkgaXMgYSBHZW5lcmFsIFF1ZXJ5LCB0 aGUgaW50ZXJmYWNlIHRpbWVyIGlzCiAgICB1c2VkIHRvIHNjaGVkdWxlIGEgcmVzcG9uc2UgdG8g dGhlIEdlbmVyYWwgUXVlcnkgYWZ0ZXIgdGhlCiAgICBzZWxlY3RlZCBkZWxheS4gIEFueSBwcmV2 aW91c2x5IHBlbmRpbmcgcmVzcG9uc2UgdG8gYSBHZW5lcmFsCiAgICBRdWVyeSBpcyBjYW5jZWxl ZC4KLS04PC0tCgpDdXJyZW50bHkgdGhlIHRpbWVyIGlzIHJlYXJtZWQgd2l0aCBuZXcgcmFuZG9t IGV4cGlyYXRpb24gdGltZSBmb3IKZXZlcnkgaW5jb21pbmcgcXVlcnkgcmVnYXJkbGVzcyBvZiBw b3NzaWJseSBhbHJlYWR5IHBlbmRpbmcgcmVwb3J0LgpXaGljaCBpcyBub3QgYWxpZ25lZCB3aXRo IHRoZSBhYm92ZSBSRkUuCkl0IGFsc28gbWlnaHQgaGFwcGVuIHRoYXQgaGlnaGVyIHJhdGUgb2Yg aW5jb21pbmcgcXVlcmllcyBjYW4KcG9zdHBvbmUgdGhlIHJlcG9ydCBhZnRlciB0aGUgZXhwaXJh dGlvbiB0aW1lIG9mIHRoZSBmaXJzdCBxdWVyeQpjYXVzaW5nIGdyb3VwIG1lbWJlcnNoaXAgbG9z cy4KCk5vdyB0aGUgcGVyIGludGVyZmFjZSBnZW5lcmFsIHF1ZXJ5IHRpbWVyIGlzIHJlYXJtZWQg b25seQp3aGVuIHRoZXJlIGlzIG5vIHBlbmRpbmcgcmVwb3J0IGFscmVhZHkgc2NoZWR1bGVkIG9u IHRoYXQgaW50ZXJmYWNlIG9yCnRoZSBuZXdseSBzZWxlY3RlZCBleHBpcmF0aW9uIHRpbWUgaXMg YmVmb3JlIHRoZSBhbHJlYWR5IHBlbmRpbmcKc2NoZWR1bGVkIHJlcG9ydC4KClNpZ25lZC1vZmYt Ynk6IE1pY2hhbCBUZXNhciA8bXRlc2FyQHJlZGhhdC5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlk IFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBuZXQvaXB2NC9pZ21wLmMgfCA3 ICsrKysrKy0KIDEgZmlsZSBjaGFuZ2VkLCA2IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkK CmRpZmYgLS1naXQgYS9uZXQvaXB2NC9pZ21wLmMgYi9uZXQvaXB2NC9pZ21wLmMKaW5kZXggYjMw ODZjZi4uMTdhZGZkYSAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvaWdtcC5jCisrKyBiL25ldC9pcHY0 L2lnbXAuYwpAQCAtMjI1LDkgKzIyNSwxNCBAQCBzdGF0aWMgdm9pZCBpZ21wX3N0YXJ0X3RpbWVy KHN0cnVjdCBpcF9tY19saXN0ICppbSwgaW50IG1heF9kZWxheSkKIHN0YXRpYyB2b2lkIGlnbXBf Z3Ffc3RhcnRfdGltZXIoc3RydWN0IGluX2RldmljZSAqaW5fZGV2KQogewogCWludCB0diA9IHBy YW5kb21fdTMyKCkgJSBpbl9kZXYtPm1yX21heGRlbGF5OworCXVuc2lnbmVkIGxvbmcgZXhwID0g amlmZmllcyArIHR2ICsgMjsKKworCWlmIChpbl9kZXYtPm1yX2dxX3J1bm5pbmcgJiYKKwkgICAg dGltZV9hZnRlcl9lcShleHAsIChpbl9kZXYtPm1yX2dxX3RpbWVyKS5leHBpcmVzKSkKKwkJcmV0 dXJuOwogCiAJaW5fZGV2LT5tcl9ncV9ydW5uaW5nID0gMTsKLQlpZiAoIW1vZF90aW1lcigmaW5f ZGV2LT5tcl9ncV90aW1lciwgamlmZmllcyt0disyKSkKKwlpZiAoIW1vZF90aW1lcigmaW5fZGV2 LT5tcl9ncV90aW1lciwgZXhwKSkKIAkJaW5fZGV2X2hvbGQoaW5fZGV2KTsKIH0KIAotLSAKMi43 LjQKCgpGcm9tIDhhNmM3MDE0NGRmMjY4NWJlOTY0OGUzNmU4Yjc3ZTkxZDNlNGYyYWQgTW9uIFNl cCAxNyAwMDowMDowMCAyMDAxCkZyb206IEFsZXhhbmRlciBEdXljayA8YWxleGFuZGVyLmguZHV5 Y2tAaW50ZWwuY29tPgpEYXRlOiBNb24sIDIgSmFuIDIwMTcgMTM6MzI6NTQgLTA4MDAKU3ViamVj dDogW1BBVENIIDEyLzE5XSBpcHY0OiBEbyBub3QgYWxsb3cgTUFJTiB0byBiZSBhbGlhcyBmb3Ig bmV3IExPQ0FMIHcvCiBjdXN0b20gcnVsZXMKClsgVXBzdHJlYW0gY29tbWl0IDUzNTBkNTRmNmNk MTJlYWZmNjIzZTg5MDc0NGM3OWI3MDBiZDNmMTcgXQoKSW4gdGhlIGNhc2Ugb2YgY3VzdG9tIHJ1 bGVzIGJlaW5nIHByZXNlbnQgd2UgbmVlZCB0byBoYW5kbGUgdGhlIGNhc2Ugb2YgdGhlCkxPQ0FM IHRhYmxlIGJlaW5nIGludGlhbGl6ZWQgYWZ0ZXIgdGhlIG5ldyBydWxlIGhhcyBiZWVuIGFkZGVk LiAgVG8gYWRkcmVzcwp0aGF0IEkgYW0gYWRkaW5nIGEgbmV3IGNoZWNrIHNvIHRoYXQgd2UgY2Fu IG1ha2UgY2VydGFpbiB3ZSBkb24ndCB1c2UgYW4KYWxpYXMgb2YgTUFJTiBmb3IgTE9DQUwgd2hl biBhbGxvY2F0aW5nIGEgbmV3IHRhYmxlLgoKRml4ZXM6IDBkZGNmNDNkNWQ0YSAoImlwdjQ6IEZJ QiBMb2NhbC9NQUlOIHRhYmxlIGNvbGxhcHNlIikKUmVwb3J0ZWQtYnk6IE9saXZlciBCcnVuZWwg PGpqa0BqamFja3kuY29tPgpTaWduZWQtb2ZmLWJ5OiBBbGV4YW5kZXIgRHV5Y2sgPGFsZXhhbmRl ci5oLmR1eWNrQGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZl bUBkYXZlbWxvZnQubmV0PgotLS0KIG5ldC9pcHY0L2ZpYl9mcm9udGVuZC5jIHwgMiArLQogMSBm aWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEv bmV0L2lwdjQvZmliX2Zyb250ZW5kLmMgYi9uZXQvaXB2NC9maWJfZnJvbnRlbmQuYwppbmRleCA2 MzU2NmVjLi40ZTYwZGFlIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9maWJfZnJvbnRlbmQuYworKysg Yi9uZXQvaXB2NC9maWJfZnJvbnRlbmQuYwpAQCAtODUsNyArODUsNyBAQCBzdHJ1Y3QgZmliX3Rh YmxlICpmaWJfbmV3X3RhYmxlKHN0cnVjdCBuZXQgKm5ldCwgdTMyIGlkKQogCWlmICh0YikKIAkJ cmV0dXJuIHRiOwogCi0JaWYgKGlkID09IFJUX1RBQkxFX0xPQ0FMKQorCWlmIChpZCA9PSBSVF9U QUJMRV9MT0NBTCAmJiAhbmV0LT5pcHY0LmZpYl9oYXNfY3VzdG9tX3J1bGVzKQogCQlhbGlhcyA9 IGZpYl9uZXdfdGFibGUobmV0LCBSVF9UQUJMRV9NQUlOKTsKIAogCXRiID0gZmliX3RyaWVfdGFi bGUoaWQsIGFsaWFzKTsKLS0gCjIuNy40CgoKRnJvbSAwYjVhYTQ5NTY5MDkzMWJmNDcxOWEyOTEz MGY2ZWExY2JhMDc5NmUyIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBoYXllc3dhbmcg PGhheWVzd2FuZ0ByZWFsdGVrLmNvbT4KRGF0ZTogVHVlLCAxMCBKYW4gMjAxNyAxNzowNDowNiAr MDgwMApTdWJqZWN0OiBbUEFUQ0ggMTMvMTldIHI4MTUyOiBzcGxpdCBydGw4MTUyX3N1c3BlbmQg ZnVuY3Rpb24KClsgVXBzdHJlYW0gY29tbWl0IDhmYjI4MDYxNjg3OGI4MWMwNzkwYTBjMzNhY2Jl ZWM1OWM1NzExZjQgXQoKU3BsaXQgcnRsODE1Ml9zdXNwZW5kKCkgaW50byBydGw4MTUyX3N5c3Rl bV9zdXNwZW5kKCkgYW5kCnJ0bDgxNTJfcnVtdGltZV9zdXNwZW5kKCkuCgpTaWduZWQtb2ZmLWJ5 OiBIYXllcyBXYW5nIDxoYXllc3dhbmdAcmVhbHRlay5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlk IFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBkcml2ZXJzL25ldC91c2Ivcjgx NTIuYyB8IDU3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0t LS0KIDEgZmlsZSBjaGFuZ2VkLCA0MCBpbnNlcnRpb25zKCspLCAxNyBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL25ldC91c2IvcjgxNTIuYyBiL2RyaXZlcnMvbmV0L3VzYi9yODE1 Mi5jCmluZGV4IDJmYjYzN2EuLjdhNmQ0MDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3VzYi9y ODE1Mi5jCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9yODE1Mi5jCkBAIC0zNDQ2LDM5ICszNDQ2LDYy IEBAIHN0YXRpYyBib29sIGRlbGF5X2F1dG9zdXNwZW5kKHN0cnVjdCByODE1MiAqdHApCiAJCXJl dHVybiBmYWxzZTsKIH0KIAotc3RhdGljIGludCBydGw4MTUyX3N1c3BlbmQoc3RydWN0IHVzYl9p bnRlcmZhY2UgKmludGYsIHBtX21lc3NhZ2VfdCBtZXNzYWdlKQorc3RhdGljIGludCBydGw4MTUy X3J1bXRpbWVfc3VzcGVuZChzdHJ1Y3QgcjgxNTIgKnRwKQogewotCXN0cnVjdCByODE1MiAqdHAg PSB1c2JfZ2V0X2ludGZkYXRhKGludGYpOwogCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYgPSB0 cC0+bmV0ZGV2OwogCWludCByZXQgPSAwOwogCi0JbXV0ZXhfbG9jaygmdHAtPmNvbnRyb2wpOwot Ci0JaWYgKFBNU0dfSVNfQVVUTyhtZXNzYWdlKSkgewotCQlpZiAobmV0aWZfcnVubmluZyhuZXRk ZXYpICYmIGRlbGF5X2F1dG9zdXNwZW5kKHRwKSkgeworCWlmIChuZXRpZl9ydW5uaW5nKG5ldGRl dikgJiYgdGVzdF9iaXQoV09SS19FTkFCTEUsICZ0cC0+ZmxhZ3MpKSB7CisJCWlmIChkZWxheV9h dXRvc3VzcGVuZCh0cCkpIHsKIAkJCXJldCA9IC1FQlVTWTsKIAkJCWdvdG8gb3V0MTsKIAkJfQog Ci0JCXNldF9iaXQoU0VMRUNUSVZFX1NVU1BFTkQsICZ0cC0+ZmxhZ3MpOwotCX0gZWxzZSB7Ci0J CW5ldGlmX2RldmljZV9kZXRhY2gobmV0ZGV2KTsKKwkJY2xlYXJfYml0KFdPUktfRU5BQkxFLCAm dHAtPmZsYWdzKTsKKwkJdXNiX2tpbGxfdXJiKHRwLT5pbnRyX3VyYik7CisJCW5hcGlfZGlzYWJs ZSgmdHAtPm5hcGkpOworCQlydGxfc3RvcF9yeCh0cCk7CisJCXJ0bF9ydW50aW1lX3N1c3BlbmRf ZW5hYmxlKHRwLCB0cnVlKTsKKwkJbmFwaV9lbmFibGUoJnRwLT5uYXBpKTsKIAl9CiAKKwlzZXRf Yml0KFNFTEVDVElWRV9TVVNQRU5ELCAmdHAtPmZsYWdzKTsKKworb3V0MToKKwlyZXR1cm4gcmV0 OworfQorCitzdGF0aWMgaW50IHJ0bDgxNTJfc3lzdGVtX3N1c3BlbmQoc3RydWN0IHI4MTUyICp0 cCkKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2ID0gdHAtPm5ldGRldjsKKwlpbnQgcmV0 ID0gMDsKKworCW5ldGlmX2RldmljZV9kZXRhY2gobmV0ZGV2KTsKKwogCWlmIChuZXRpZl9ydW5u aW5nKG5ldGRldikgJiYgdGVzdF9iaXQoV09SS19FTkFCTEUsICZ0cC0+ZmxhZ3MpKSB7CiAJCWNs ZWFyX2JpdChXT1JLX0VOQUJMRSwgJnRwLT5mbGFncyk7CiAJCXVzYl9raWxsX3VyYih0cC0+aW50 cl91cmIpOwogCQluYXBpX2Rpc2FibGUoJnRwLT5uYXBpKTsKLQkJaWYgKHRlc3RfYml0KFNFTEVD VElWRV9TVVNQRU5ELCAmdHAtPmZsYWdzKSkgewotCQkJcnRsX3N0b3BfcngodHApOwotCQkJcnRs X3J1bnRpbWVfc3VzcGVuZF9lbmFibGUodHAsIHRydWUpOwotCQl9IGVsc2UgewotCQkJY2FuY2Vs X2RlbGF5ZWRfd29ya19zeW5jKCZ0cC0+c2NoZWR1bGUpOwotCQkJdHAtPnJ0bF9vcHMuZG93bih0 cCk7Ci0JCX0KKwkJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZ0cC0+c2NoZWR1bGUpOworCQl0 cC0+cnRsX29wcy5kb3duKHRwKTsKIAkJbmFwaV9lbmFibGUoJnRwLT5uYXBpKTsKIAl9Ci1vdXQx OgorCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBydGw4MTUyX3N1c3BlbmQoc3RydWN0 IHVzYl9pbnRlcmZhY2UgKmludGYsIHBtX21lc3NhZ2VfdCBtZXNzYWdlKQoreworCXN0cnVjdCBy ODE1MiAqdHAgPSB1c2JfZ2V0X2ludGZkYXRhKGludGYpOworCWludCByZXQ7CisKKwltdXRleF9s b2NrKCZ0cC0+Y29udHJvbCk7CisKKwlpZiAoUE1TR19JU19BVVRPKG1lc3NhZ2UpKQorCQlyZXQg PSBydGw4MTUyX3J1bXRpbWVfc3VzcGVuZCh0cCk7CisJZWxzZQorCQlyZXQgPSBydGw4MTUyX3N5 c3RlbV9zdXNwZW5kKHRwKTsKKwogCW11dGV4X3VubG9jaygmdHAtPmNvbnRyb2wpOwogCiAJcmV0 dXJuIHJldDsKLS0gCjIuNy40CgoKRnJvbSA3ODYzOTcyMTg4MDBhZDkwZDFjMDVkZTBjMGI5Mzk0 NTRmYmZkNDE2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBoYXllc3dhbmcgPGhheWVz d2FuZ0ByZWFsdGVrLmNvbT4KRGF0ZTogVHVlLCAxMCBKYW4gMjAxNyAxNzowNDowNyArMDgwMApT dWJqZWN0OiBbUEFUQ0ggMTQvMTldIHI4MTUyOiBmaXggcnggaXNzdWUgZm9yIHJ1bnRpbWUgc3Vz cGVuZAoKWyBVcHN0cmVhbSBjb21taXQgNzVkYzY5MmVkYTExNGNiMjM0YTQ2Y2IxMTg5M2E5YzNl YTUyMDkzNCBdCgpQYXVzZSB0aGUgcnggYW5kIG1ha2Ugc3VyZSB0aGUgcnggZmlmbyBpcyBlbXB0 eSB3aGVuIHRoZSBhdXRvc3VzcGVuZApvY2N1cnMuCgpJZiB0aGUgcnggZGF0YSBjb21lcyB3aGVu IHRoZSBkcml2ZXIgaXMgY2FuY2VsaW5nIHRoZSByeCB1cmIsIHRoZSBob3N0CmNvbnRyb2xsZXIg d291bGQgc3RvcCBnZXR0aW5nIHRoZSBkYXRhIGZyb20gdGhlIGRldmljZSBhbmQgY29udGludWUK aXQgYWZ0ZXIgbmV4dCByeCB1cmIgaXMgc3VibWl0dGVkLiBUaGF0IGlzLCBvbmUgY29udGludWlu ZyBkYXRhIGlzCnNwbGl0IGludG8gdHdvIGRpZmZlcmVudCB1cmIgYnVmZmVycy4gVGhhdCBsZXQg dGhlIGRyaXZlciB0YWtlIHRoZQpkYXRhIGFzIGEgcnggZGVzY3JpcHRvciwgYW5kIHVuZXhwZWN0 ZWQgYmVoYXZpb3IgaGFwcGVucy4KClNpZ25lZC1vZmYtYnk6IEhheWVzIFdhbmcgPGhheWVzd2Fu Z0ByZWFsdGVrLmNvbT4KU2lnbmVkLW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZl bWxvZnQubmV0PgotLS0KIGRyaXZlcnMvbmV0L3VzYi9yODE1Mi5jIHwgMzEgKysrKysrKysrKysr KysrKysrKysrKysrKysrKy0tLQogMSBmaWxlIGNoYW5nZWQsIDI4IGluc2VydGlvbnMoKyksIDMg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdXNiL3I4MTUyLmMgYi9kcml2 ZXJzL25ldC91c2IvcjgxNTIuYwppbmRleCA3YTZkNDA1Li4zMmI3ZWM5IDEwMDY0NAotLS0gYS9k cml2ZXJzL25ldC91c2IvcjgxNTIuYworKysgYi9kcml2ZXJzL25ldC91c2IvcjgxNTIuYwpAQCAt MzQ1MiwxNyArMzQ1Miw0MiBAQCBzdGF0aWMgaW50IHJ0bDgxNTJfcnVtdGltZV9zdXNwZW5kKHN0 cnVjdCByODE1MiAqdHApCiAJaW50IHJldCA9IDA7CiAKIAlpZiAobmV0aWZfcnVubmluZyhuZXRk ZXYpICYmIHRlc3RfYml0KFdPUktfRU5BQkxFLCAmdHAtPmZsYWdzKSkgeworCQl1MzIgcmNyID0g MDsKKwogCQlpZiAoZGVsYXlfYXV0b3N1c3BlbmQodHApKSB7CiAJCQlyZXQgPSAtRUJVU1k7CiAJ CQlnb3RvIG91dDE7CiAJCX0KIAorCQlpZiAobmV0aWZfY2Fycmllcl9vayhuZXRkZXYpKSB7CisJ CQl1MzIgb2NwX2RhdGE7CisKKwkJCXJjciA9IG9jcF9yZWFkX2R3b3JkKHRwLCBNQ1VfVFlQRV9Q TEEsIFBMQV9SQ1IpOworCQkJb2NwX2RhdGEgPSByY3IgJiB+UkNSX0FDUFRfQUxMOworCQkJb2Nw X3dyaXRlX2R3b3JkKHRwLCBNQ1VfVFlQRV9QTEEsIFBMQV9SQ1IsIG9jcF9kYXRhKTsKKwkJCXJ4 ZHlfZ2F0ZWRfZW4odHAsIHRydWUpOworCQkJb2NwX2RhdGEgPSBvY3BfcmVhZF9ieXRlKHRwLCBN Q1VfVFlQRV9QTEEsCisJCQkJCQkgUExBX09PQl9DVFJMKTsKKwkJCWlmICghKG9jcF9kYXRhICYg UlhGSUZPX0VNUFRZKSkgeworCQkJCXJ4ZHlfZ2F0ZWRfZW4odHAsIGZhbHNlKTsKKwkJCQlvY3Bf d3JpdGVfZHdvcmQodHAsIE1DVV9UWVBFX1BMQSwgUExBX1JDUiwgcmNyKTsKKwkJCQlyZXQgPSAt RUJVU1k7CisJCQkJZ290byBvdXQxOworCQkJfQorCQl9CisKIAkJY2xlYXJfYml0KFdPUktfRU5B QkxFLCAmdHAtPmZsYWdzKTsKIAkJdXNiX2tpbGxfdXJiKHRwLT5pbnRyX3VyYik7Ci0JCW5hcGlf ZGlzYWJsZSgmdHAtPm5hcGkpOwotCQlydGxfc3RvcF9yeCh0cCk7CisKIAkJcnRsX3J1bnRpbWVf c3VzcGVuZF9lbmFibGUodHAsIHRydWUpOwotCQluYXBpX2VuYWJsZSgmdHAtPm5hcGkpOworCisJ CWlmIChuZXRpZl9jYXJyaWVyX29rKG5ldGRldikpIHsKKwkJCW5hcGlfZGlzYWJsZSgmdHAtPm5h cGkpOworCQkJcnRsX3N0b3BfcngodHApOworCQkJcnhkeV9nYXRlZF9lbih0cCwgZmFsc2UpOwor CQkJb2NwX3dyaXRlX2R3b3JkKHRwLCBNQ1VfVFlQRV9QTEEsIFBMQV9SQ1IsIHJjcik7CisJCQlu YXBpX2VuYWJsZSgmdHAtPm5hcGkpOworCQl9CiAJfQogCiAJc2V0X2JpdChTRUxFQ1RJVkVfU1VT UEVORCwgJnRwLT5mbGFncyk7Ci0tIAoyLjcuNAoKCkZyb20gY2FkNmY2YTEwODg4MTljNjU4M2Fk NWYwNDAwMmQ5ZWI4YTUwZTQ0YyBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogSGVyYmVy dCBYdSA8aGVyYmVydEBnb25kb3IuYXBhbmEub3JnLmF1PgpEYXRlOiBUdWUsIDEwIEphbiAyMDE3 IDEyOjI0OjAxIC0wODAwClN1YmplY3Q6IFtQQVRDSCAxNS8xOV0gZ3JvOiBFbnRlciBzbG93LXBh dGggaWYgdGhlcmUgaXMgbm8gdGFpbHJvb20KClsgVXBzdHJlYW0gY29tbWl0IDEyNzJjZTg3ZmEw MTdjYTRjZjMyOTIwNzY0ZDg3OTY1NmI3YTAwNWEgXQoKVGhlIEdSTyBwYXRoIGhhcyBhIGZhc3Qt cGF0aCB3aGVyZSB3ZSBhdm9pZCBjYWxsaW5nIHBza2JfbWF5X3B1bGwKYW5kIHBza2JfZXhwYW5k IGJ5IGRpcmVjdGx5IGFjY2Vzc2luZyBmcmFnMC4gIEhvd2V2ZXIsIHRoaXMgc2hvdWxkCm9ubHkg YmUgZG9uZSBpZiB3ZSBoYXZlIGVub3VnaCB0YWlscm9vbSBpbiB0aGUgc2tiIGFzIG90aGVyd2lz ZQp3ZSdsbCBoYXZlIHRvIGV4cGFuZCBpdCBsYXRlciBhbnl3YXkuCgpUaGlzIHBhdGNoIGFkZHMg dGhlIGNoZWNrIGJ5IGNhcHBpbmcgZnJhZzBfbGVuIHdpdGggdGhlIHNrYiB0YWlscm9vbS4KCkZp eGVzOiBjYjE4OTc4Y2JmNDUgKCJncm86IE9wZW4tY29kZSBmaW5hbCBwc2tiX21heV9wdWxsIikK UmVwb3J0ZWQtYnk6IFNsYXZhIFNod2FydHNtYW4gPHNsYXZhc2hAbWVsbGFub3guY29tPgpTaWdu ZWQtb2ZmLWJ5OiBIZXJiZXJ0IFh1IDxoZXJiZXJ0QGdvbmRvci5hcGFuYS5vcmcuYXU+ClNpZ25l ZC1vZmYtYnk6IEVyaWMgRHVtYXpldCA8ZWR1bWF6ZXRAZ29vZ2xlLmNvbT4KU2lnbmVkLW9mZi1i eTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0PgotLS0KIG5ldC9jb3JlL2Rl di5jIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24o LSkKCmRpZmYgLS1naXQgYS9uZXQvY29yZS9kZXYuYyBiL25ldC9jb3JlL2Rldi5jCmluZGV4IDlj YTc0OWMuLmVlNmM3YjAgMTAwNjQ0Ci0tLSBhL25ldC9jb3JlL2Rldi5jCisrKyBiL25ldC9jb3Jl L2Rldi5jCkBAIC00MTg3LDcgKzQxODcsOCBAQCBzdGF0aWMgdm9pZCBza2JfZ3JvX3Jlc2V0X29m ZnNldChzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQogCSAgICBwaW5mby0+bnJfZnJhZ3MgJiYKIAkgICAg IVBhZ2VIaWdoTWVtKHNrYl9mcmFnX3BhZ2UoZnJhZzApKSkgewogCQlOQVBJX0dST19DQihza2Ip LT5mcmFnMCA9IHNrYl9mcmFnX2FkZHJlc3MoZnJhZzApOwotCQlOQVBJX0dST19DQihza2IpLT5m cmFnMF9sZW4gPSBza2JfZnJhZ19zaXplKGZyYWcwKTsKKwkJTkFQSV9HUk9fQ0Ioc2tiKS0+ZnJh ZzBfbGVuID0gbWluKHNrYl9mcmFnX3NpemUoZnJhZzApLAorCQkJCQkJICBza2ItPmVuZCAtIHNr Yi0+dGFpbCk7CiAJfQogfQogCi0tIAoyLjcuNAoKCkZyb20gYWM5YzgxNDI4MWZlN2Q2MWQyZWM0 YzA2YWY3YjViMTEzOTJjOTA0NyBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogRXJpYyBE dW1hemV0IDxlZHVtYXpldEBnb29nbGUuY29tPgpEYXRlOiBUdWUsIDEwIEphbiAyMDE3IDE5OjUy OjQzIC0wODAwClN1YmplY3Q6IFtQQVRDSCAxNi8xOV0gZ3JvOiB1c2UgbWluX3QoKSBpbiBza2Jf Z3JvX3Jlc2V0X29mZnNldCgpCgpbIFVwc3RyZWFtIGNvbW1pdCA3Y2ZkNWZkNWE5ODEzZjE0MzAy OTBkMjBjMGZlYWQ5YjQ1ODJhMzA3IF0KCk9uIDMyYml0IGFyY2hlcywgKHNrYi0+ZW5kIC0gc2ti LT5kYXRhKSBpcyBub3QgJ3Vuc2lnbmVkIGludCcsCnNvIHdlIHNoYWxsIHVzZSBtaW5fdCgpIGlu c3RlYWQgb2YgbWluKCkgdG8gYXZvaWQgYSBjb21waWxlciBlcnJvci4KCkZpeGVzOiAxMjcyY2U4 N2ZhMDEgKCJncm86IEVudGVyIHNsb3ctcGF0aCBpZiB0aGVyZSBpcyBubyB0YWlscm9vbSIpClJl cG9ydGVkLWJ5OiBrZXJuZWwgdGVzdCByb2JvdCA8ZmVuZ2d1YW5nLnd1QGludGVsLmNvbT4KU2ln bmVkLW9mZi1ieTogRXJpYyBEdW1hemV0IDxlZHVtYXpldEBnb29nbGUuY29tPgpTaWduZWQtb2Zm LWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogbmV0L2NvcmUv ZGV2LmMgfCA1ICsrKy0tCiAxIGZpbGUgY2hhbmdlZCwgMyBpbnNlcnRpb25zKCspLCAyIGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL25ldC9jb3JlL2Rldi5jIGIvbmV0L2NvcmUvZGV2LmMKaW5k ZXggZWU2YzdiMC4uNmYyMDNjNyAxMDA2NDQKLS0tIGEvbmV0L2NvcmUvZGV2LmMKKysrIGIvbmV0 L2NvcmUvZGV2LmMKQEAgLTQxODcsOCArNDE4Nyw5IEBAIHN0YXRpYyB2b2lkIHNrYl9ncm9fcmVz ZXRfb2Zmc2V0KHN0cnVjdCBza19idWZmICpza2IpCiAJICAgIHBpbmZvLT5ucl9mcmFncyAmJgog CSAgICAhUGFnZUhpZ2hNZW0oc2tiX2ZyYWdfcGFnZShmcmFnMCkpKSB7CiAJCU5BUElfR1JPX0NC KHNrYiktPmZyYWcwID0gc2tiX2ZyYWdfYWRkcmVzcyhmcmFnMCk7Ci0JCU5BUElfR1JPX0NCKHNr YiktPmZyYWcwX2xlbiA9IG1pbihza2JfZnJhZ19zaXplKGZyYWcwKSwKLQkJCQkJCSAgc2tiLT5l bmQgLSBza2ItPnRhaWwpOworCQlOQVBJX0dST19DQihza2IpLT5mcmFnMF9sZW4gPSBtaW5fdCh1 bnNpZ25lZCBpbnQsCisJCQkJCQkgICAgc2tiX2ZyYWdfc2l6ZShmcmFnMCksCisJCQkJCQkgICAg c2tiLT5lbmQgLSBza2ItPnRhaWwpOwogCX0KIH0KIAotLSAKMi43LjQKCgpGcm9tIGFmZGRmNTk5 ZTRkZGQ5MDJjMDIwOGYwMTk0ZTgyY2VkNzdjYjNhNmEgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAx CkZyb206IEhlcmJlcnQgWHUgPGhlcmJlcnRAZ29uZG9yLmFwYW5hLm9yZy5hdT4KRGF0ZTogVHVl LCAxMCBKYW4gMjAxNyAxMjoyNDoxNSAtMDgwMApTdWJqZWN0OiBbUEFUQ0ggMTcvMTldIGdybzog RGlzYWJsZSBmcmFnMCBvcHRpbWl6YXRpb24gb24gSVB2NiBleHQgaGVhZGVycwoKWyBVcHN0cmVh bSBjb21taXQgNTdlYTUyYTg2NTE0NGFlZGJjZDYxOWVlMDA4MTE1NWU2NThiNmY3ZCBdCgpUaGUg R1JPIGZhc3QgcGF0aCBjYWNoZXMgdGhlIGZyYWcwIGFkZHJlc3MuICBUaGlzIGFkZHJlc3MgYmVj b21lcwppbnZhbGlkIGlmIGZyYWcwIGlzIG1vZGlmaWVkIGJ5IHBza2JfbWF5X3B1bGwgb3IgaXRz IHZhcmlhbnRzLgpTbyB3aGVuZXZlciB0aGF0IGhhcHBlbnMgd2UgbXVzdCBkaXNhYmxlIHRoZSBm cmFnMCBvcHRpbWl6YXRpb24uCgpUaGlzIGlzIHVzdWFsbHkgZG9uZSB0aHJvdWdoIHRoZSBjb21i aW5hdGlvbiBvZiBncm9faGVhZGVyX2hhcmQKYW5kIGdyb19oZWFkZXJfc2xvdywgaG93ZXZlciwg dGhlIElQdjYgZXh0ZW5zaW9uIGhlYWRlciBwYXRoIGRpZAp0aGUgcHVsbGluZyBkaXJlY3RseSBh bmQgd291bGQgY29udGludWUgdG8gdXNlIHRoZSBHUk8gZmFzdCBwYXRoCmluY29ycmVjdGx5LgoK VGhpcyBwYXRjaCBmaXhlcyBpdCBieSBkaXNhYmxpbmcgdGhlIGZhc3QgcGF0aCB3aGVuIHdlIGVu dGVyIHRoZQpJUHY2IGV4dGVuc2lvbiBoZWFkZXIgcGF0aC4KCkZpeGVzOiA3OGE0NzhkMGVmZDkg KCJncm86IElubGluZSBza2JfZ3JvX2hlYWRlciBhbmQgY2FjaGUgZnJhZzAgdmlydHVhbCBhZGRy ZXNzIikKUmVwb3J0ZWQtYnk6IFNsYXZhIFNod2FydHNtYW4gPHNsYXZhc2hAbWVsbGFub3guY29t PgpTaWduZWQtb2ZmLWJ5OiBIZXJiZXJ0IFh1IDxoZXJiZXJ0QGdvbmRvci5hcGFuYS5vcmcuYXU+ ClNpZ25lZC1vZmYtYnk6IEVyaWMgRHVtYXpldCA8ZWR1bWF6ZXRAZ29vZ2xlLmNvbT4KU2lnbmVk LW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0PgotLS0KIGluY2x1 ZGUvbGludXgvbmV0ZGV2aWNlLmggfCA5ICsrKysrKystLQogbmV0L2lwdjYvaXA2X29mZmxvYWQu YyAgICB8IDEgKwogMiBmaWxlcyBjaGFuZ2VkLCA4IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9uZXRkZXZpY2UuaCBiL2luY2x1ZGUvbGlu dXgvbmV0ZGV2aWNlLmgKaW5kZXggOWQ2MDI1Ny4uOTNhNmEyYyAxMDA2NDQKLS0tIGEvaW5jbHVk ZS9saW51eC9uZXRkZXZpY2UuaAorKysgYi9pbmNsdWRlL2xpbnV4L25ldGRldmljZS5oCkBAIC0y MzI1LDE0ICsyMzI1LDE5IEBAIHN0YXRpYyBpbmxpbmUgaW50IHNrYl9ncm9faGVhZGVyX2hhcmQo c3RydWN0IHNrX2J1ZmYgKnNrYiwgdW5zaWduZWQgaW50IGhsZW4pCiAJcmV0dXJuIE5BUElfR1JP X0NCKHNrYiktPmZyYWcwX2xlbiA8IGhsZW47CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBza2Jf Z3JvX2ZyYWcwX2ludmFsaWRhdGUoc3RydWN0IHNrX2J1ZmYgKnNrYikKK3sKKwlOQVBJX0dST19D Qihza2IpLT5mcmFnMCA9IE5VTEw7CisJTkFQSV9HUk9fQ0Ioc2tiKS0+ZnJhZzBfbGVuID0gMDsK K30KKwogc3RhdGljIGlubGluZSB2b2lkICpza2JfZ3JvX2hlYWRlcl9zbG93KHN0cnVjdCBza19i dWZmICpza2IsIHVuc2lnbmVkIGludCBobGVuLAogCQkJCQl1bnNpZ25lZCBpbnQgb2Zmc2V0KQog ewogCWlmICghcHNrYl9tYXlfcHVsbChza2IsIGhsZW4pKQogCQlyZXR1cm4gTlVMTDsKIAotCU5B UElfR1JPX0NCKHNrYiktPmZyYWcwID0gTlVMTDsKLQlOQVBJX0dST19DQihza2IpLT5mcmFnMF9s ZW4gPSAwOworCXNrYl9ncm9fZnJhZzBfaW52YWxpZGF0ZShza2IpOwogCXJldHVybiBza2ItPmRh dGEgKyBvZmZzZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY2L2lwNl9vZmZsb2FkLmMgYi9u ZXQvaXB2Ni9pcDZfb2ZmbG9hZC5jCmluZGV4IGVmZTYyNjguLjIyNWY1ZjcgMTAwNjQ0Ci0tLSBh L25ldC9pcHY2L2lwNl9vZmZsb2FkLmMKKysrIGIvbmV0L2lwdjYvaXA2X29mZmxvYWQuYwpAQCAt MTk2LDYgKzE5Niw3IEBAIHN0YXRpYyBzdHJ1Y3Qgc2tfYnVmZiAqKmlwdjZfZ3JvX3JlY2VpdmUo c3RydWN0IHNrX2J1ZmYgKipoZWFkLAogCW9wcyA9IHJjdV9kZXJlZmVyZW5jZShpbmV0Nl9vZmZs b2Fkc1twcm90b10pOwogCWlmICghb3BzIHx8ICFvcHMtPmNhbGxiYWNrcy5ncm9fcmVjZWl2ZSkg ewogCQlfX3Bza2JfcHVsbChza2IsIHNrYl9ncm9fb2Zmc2V0KHNrYikpOworCQlza2JfZ3JvX2Zy YWcwX2ludmFsaWRhdGUoc2tiKTsKIAkJcHJvdG8gPSBpcHY2X2dzb19wdWxsX2V4dGhkcnMoc2ti LCBwcm90byk7CiAJCXNrYl9ncm9fcHVsbChza2IsIC1za2JfdHJhbnNwb3J0X29mZnNldChza2Ip KTsKIAkJc2tiX3Jlc2V0X3RyYW5zcG9ydF9oZWFkZXIoc2tiKTsKLS0gCjIuNy40CgoKRnJvbSBi MGRmYzY1N2FmMTJlZTM2NjA5OGEwZWE3MTMwNTY1ZTI1ZDhkYmE3IE1vbiBTZXAgMTcgMDA6MDA6 MDAgMjAwMQpGcm9tOiBEYXZpZCBBaGVybiA8ZHNhQGN1bXVsdXNuZXR3b3Jrcy5jb20+CkRhdGU6 IFR1ZSwgMTAgSmFuIDIwMTcgMTQ6Mzc6MzUgLTA4MDAKU3ViamVjdDogW1BBVENIIDE4LzE5XSBu ZXQ6IGlwdjQ6IEZpeCBtdWx0aXBhdGggc2VsZWN0aW9uIHdpdGggdnJmCgpbIFVwc3RyZWFtIGNv bW1pdCA3YTE4YzViOWZiMzFhOTk5YWZjNjJiMGU2MDk3OGFhODk2ZmM4OWU5IF0KCmZpYl9zZWxl Y3RfcGF0aCBkb2VzIG5vdCBjYWxsIGZpYl9zZWxlY3RfbXVsdGlwYXRoIGlmIG9pZiBpcyBzZXQg aW4gdGhlCmZsb3cgc3RydWN0LiBGb3IgVlJGIHVzZSBjYXNlcyBvaWYgaXMgYWx3YXlzIHNldCwg c28gbXVsdGlwYXRoIHJvdXRlCnNlbGVjdGlvbiBpcyBieXBhc3NlZC4gVXNlIHRoZSBGTE9XSV9G TEFHX1NLSVBfTkhfT0lGIHRvIHNraXAgdGhlIG9pZgpjaGVjayBzaW1pbGFyIHRvIHdoYXQgaXMg ZG9uZSBpbiBmaWJfdGFibGVfbG9va3VwLgoKQWRkIHNhZGRyIGFuZCBwcm90byB0byB0aGUgZmxv dyBzdHJ1Y3QgZm9yIHRoZSBmaWIgbG9va3VwIGRvbmUgYnkgdGhlClZSRiBkcml2ZXIgdG8gYmV0 dGVyIG1hdGNoIGhhc2ggY29tcHV0YXRpb24gZm9yIGEgZmxvdy4KCkZpeGVzOiA2MTNkMDliMzBm OGIgKCJuZXQ6IFVzZSBWUkYgZGV2aWNlIGluZGV4IGZvciBsb29rdXBzIG9uIFRYIikKU2lnbmVk LW9mZi1ieTogRGF2aWQgQWhlcm4gPGRzYUBjdW11bHVzbmV0d29ya3MuY29tPgpTaWduZWQtb2Zm LWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogZHJpdmVycy9u ZXQvdnJmLmMgICAgICAgIHwgMiArKwogbmV0L2lwdjQvZmliX3NlbWFudGljcy5jIHwgOSArKysr KysrLS0KIDIgZmlsZXMgY2hhbmdlZCwgOSBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3ZyZi5jIGIvZHJpdmVycy9uZXQvdnJmLmMKaW5kZXgg ODZmNTljYS4uYmM3OTViOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdnJmLmMKKysrIGIvZHJp dmVycy9uZXQvdnJmLmMKQEAgLTMwMSw3ICszMDEsOSBAQCBzdGF0aWMgbmV0ZGV2X3R4X3QgdnJm X3Byb2Nlc3NfdjRfb3V0Ym91bmQoc3RydWN0IHNrX2J1ZmYgKnNrYiwKIAkJLmZsb3dpNF90b3Mg PSBSVF9UT1MoaXA0aC0+dG9zKSwKIAkJLmZsb3dpNF9mbGFncyA9IEZMT1dJX0ZMQUdfQU5ZU1JD IHwgRkxPV0lfRkxBR19MM01ERVZfU1JDIHwKIAkJCQlGTE9XSV9GTEFHX1NLSVBfTkhfT0lGLAor CQkuZmxvd2k0X3Byb3RvID0gaXA0aC0+cHJvdG9jb2wsCiAJCS5kYWRkciA9IGlwNGgtPmRhZGRy LAorCQkuc2FkZHIgPSBpcDRoLT5zYWRkciwKIAl9OwogCiAJaWYgKHZyZl9zZW5kX3Y0X3ByZXAo c2tiLCAmZmw0LCB2cmZfZGV2KSkKZGlmZiAtLWdpdCBhL25ldC9pcHY0L2ZpYl9zZW1hbnRpY3Mu YyBiL25ldC9pcHY0L2ZpYl9zZW1hbnRpY3MuYwppbmRleCBmZmU5NWQ5Li44NDBiNDUwIDEwMDY0 NAotLS0gYS9uZXQvaXB2NC9maWJfc2VtYW50aWNzLmMKKysrIGIvbmV0L2lwdjQvZmliX3NlbWFu dGljcy5jCkBAIC0xNTg4LDggKzE1ODgsMTMgQEAgdm9pZCBmaWJfc2VsZWN0X211bHRpcGF0aChz dHJ1Y3QgZmliX3Jlc3VsdCAqcmVzLCBpbnQgaGFzaCkKIHZvaWQgZmliX3NlbGVjdF9wYXRoKHN0 cnVjdCBuZXQgKm5ldCwgc3RydWN0IGZpYl9yZXN1bHQgKnJlcywKIAkJICAgICBzdHJ1Y3QgZmxv d2k0ICpmbDQsIGludCBtcF9oYXNoKQogeworCWJvb2wgb2lmX2NoZWNrOworCisJb2lmX2NoZWNr ID0gKGZsNC0+Zmxvd2k0X29pZiA9PSAwIHx8CisJCSAgICAgZmw0LT5mbG93aTRfZmxhZ3MgJiBG TE9XSV9GTEFHX1NLSVBfTkhfT0lGKTsKKwogI2lmZGVmIENPTkZJR19JUF9ST1VURV9NVUxUSVBB VEgKLQlpZiAocmVzLT5maS0+ZmliX25ocyA+IDEgJiYgZmw0LT5mbG93aTRfb2lmID09IDApIHsK KwlpZiAocmVzLT5maS0+ZmliX25ocyA+IDEgJiYgb2lmX2NoZWNrKSB7CiAJCWlmIChtcF9oYXNo IDwgMCkKIAkJCW1wX2hhc2ggPSBnZXRfaGFzaF9mcm9tX2Zsb3dpNChmbDQpID4+IDE7CiAKQEAg LTE1OTksNyArMTYwNCw3IEBAIHZvaWQgZmliX3NlbGVjdF9wYXRoKHN0cnVjdCBuZXQgKm5ldCwg c3RydWN0IGZpYl9yZXN1bHQgKnJlcywKICNlbmRpZgogCWlmICghcmVzLT5wcmVmaXhsZW4gJiYK IAkgICAgcmVzLT50YWJsZS0+dGJfbnVtX2RlZmF1bHQgPiAxICYmCi0JICAgIHJlcy0+dHlwZSA9 PSBSVE5fVU5JQ0FTVCAmJiAhZmw0LT5mbG93aTRfb2lmKQorCSAgICByZXMtPnR5cGUgPT0gUlRO X1VOSUNBU1QgJiYgb2lmX2NoZWNrKQogCQlmaWJfc2VsZWN0X2RlZmF1bHQoZmw0LCByZXMpOwog CiAJaWYgKCFmbDQtPnNhZGRyKQotLSAKMi43LjQKCgpGcm9tIDdiMDc2OTAyZTZjN2RkODZmOGFi OWNjYzZlMWNhNTc2NDZjOTFlYmEgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206IERhdmlk IEFoZXJuIDxkc2FAY3VtdWx1c25ldHdvcmtzLmNvbT4KRGF0ZTogVHVlLCAxMCBKYW4gMjAxNyAx NToyMjoyNSAtMDgwMApTdWJqZWN0OiBbUEFUQ0ggMTkvMTldIG5ldDogdnJmOiBkbyBub3QgYWxs b3cgdGFibGUgaWQgMAoKWyBVcHN0cmVhbSBjb21taXQgMjRjNjNiYmMxOGUyNWQ1ZDg0Mzk0MjJh YTVmZDJkNjYzOTBiODhlYiBdCgpGcmFuayByZXBvcnRlZCB0aGF0IHZyZiBkZXZpY2VzIGNhbiBi ZSBjcmVhdGVkIHdpdGggYSB0YWJsZSBpZCBvZiAwLgpUaGlzIGJyZWFrcyBtYW55IG9mIHRoZSBy dW4gdGltZSB0YWJsZSBpZCBjaGVja3MgYW5kIHNob3VsZCBub3QgYmUKYWxsb3dlZC4gRGV0ZWN0 IHRoaXMgY29uZGl0aW9uIGF0IGNyZWF0ZSB0aW1lIGFuZCBmYWlsIHdpdGggRUlOVkFMLgoKRml4 ZXM6IDE5MzEyNWRiZDhlYiAoIm5ldDogSW50cm9kdWNlIFZSRiBkZXZpY2UgZHJpdmVyIikKUmVw b3J0ZWQtYnk6IEZyYW5rIEtlbGxlcm1hbm4gPGZyYW5rLmtlbGxlcm1hbm5AYXRvcy5uZXQ+ClNp Z25lZC1vZmYtYnk6IERhdmlkIEFoZXJuIDxkc2FAY3VtdWx1c25ldHdvcmtzLmNvbT4KU2lnbmVk LW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQubmV0PgotLS0KIGRyaXZl cnMvbmV0L3ZyZi5jIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3ZyZi5jIGIvZHJpdmVycy9uZXQvdnJmLmMKaW5kZXggYmM3 OTViOC4uZDZiNjE5NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdnJmLmMKKysrIGIvZHJpdmVy cy9uZXQvdnJmLmMKQEAgLTkyNSw2ICs5MjUsOCBAQCBzdGF0aWMgaW50IHZyZl9uZXdsaW5rKHN0 cnVjdCBuZXQgKnNyY19uZXQsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCXJldHVybiAtRUlO VkFMOwogCiAJdnJmLT50Yl9pZCA9IG5sYV9nZXRfdTMyKGRhdGFbSUZMQV9WUkZfVEFCTEVdKTsK KwlpZiAodnJmLT50Yl9pZCA9PSBSVF9UQUJMRV9VTlNQRUMpCisJCXJldHVybiAtRUlOVkFMOwog CiAJZGV2LT5wcml2X2ZsYWdzIHw9IElGRl9MM01ERVZfTUFTVEVSOwogCi0tIAoyLjcuNAoK ----Next_Part(Thu_Jan_12_13_55_10_2017_630)-- Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="net_49.mbox" >>From 501cfa4d001500e50ce519512616a2442093e13d Mon Sep 17 00:00:00 2001 From: David Ahern Date: Wed, 14 Dec 2016 11:06:18 -0800 Subject: [PATCH 01/37] net: vrf: Fix NAT within a VRF [ Upstream commit a0f37efa82253994b99623dbf41eea8dd0ba169b ] Connection tracking with VRF is broken because the pass through the VRF device drops the connection tracking info. Removing the call to nf_reset allows DNAT and MASQUERADE to work across interfaces within a VRF. Fixes: 73e20b761acf ("net: vrf: Add support for PREROUTING rules on vrf device") Signed-off-by: David Ahern Signed-off-by: David S. Miller --- drivers/net/vrf.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c index 820de6a..5b995c4 100644 --- a/drivers/net/vrf.c +++ b/drivers/net/vrf.c @@ -850,8 +850,6 @@ static struct sk_buff *vrf_rcv_nfhook(u8 pf, unsigned int hook, { struct net *net = dev_net(dev); - nf_reset(skb); - if (NF_HOOK(pf, hook, net, NULL, skb, dev, NULL, vrf_rcv_finish) < 0) skb = NULL; /* kfree_skb(skb) handled by nf code */ -- 2.7.4 >>From 9e335a84c686a198a10d7170f8c694a4bf1cbc2d Mon Sep 17 00:00:00 2001 From: David Ahern Date: Wed, 14 Dec 2016 14:31:11 -0800 Subject: [PATCH 02/37] net: vrf: Drop conntrack data after pass through VRF device on Tx [ Upstream commit eb63ecc1706b3e094d0f57438b6c2067cfc299f2 ] Locally originated traffic in a VRF fails in the presence of a POSTROUTING rule. For example, $ iptables -t nat -A POSTROUTING -s 11.1.1.0/24 -j MASQUERADE $ ping -I red -c1 11.1.1.3 ping: Warning: source address might be selected on device other than red. PING 11.1.1.3 (11.1.1.3) from 11.1.1.2 red: 56(84) bytes of data. ping: sendmsg: Operation not permitted Worse, the above causes random corruption resulting in a panic in random places (I have not seen a consistent backtrace). Call nf_reset to drop the conntrack info following the pass through the VRF device. The nf_reset is needed on Tx but not Rx because of the order in which NF_HOOK's are hit: on Rx the VRF device is after the real ingress device and on Tx it is is before the real egress device. Connection tracking should be tied to the real egress device and not the VRF device. Fixes: 8f58336d3f78a ("net: Add ethernet header for pass through VRF device") Fixes: 35402e3136634 ("net: Add IPv6 support to VRF device") Signed-off-by: David Ahern Signed-off-by: David S. Miller --- drivers/net/vrf.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c index 5b995c4..3cb3588 100644 --- a/drivers/net/vrf.c +++ b/drivers/net/vrf.c @@ -371,6 +371,8 @@ static int vrf_finish_output6(struct net *net, struct sock *sk, struct in6_addr *nexthop; int ret; + nf_reset(skb); + skb->protocol = htons(ETH_P_IPV6); skb->dev = dev; @@ -552,6 +554,8 @@ static int vrf_finish_output(struct net *net, struct sock *sk, struct sk_buff *s u32 nexthop; int ret = -EINVAL; + nf_reset(skb); + /* Be paranoid, rather than too clever. */ if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) { struct sk_buff *skb2; -- 2.7.4 >>From 4960643b24acd5f1ac693b0eb6a9252538a76483 Mon Sep 17 00:00:00 2001 From: Xin Long Date: Thu, 15 Dec 2016 23:05:52 +0800 Subject: [PATCH 03/37] sctp: sctp_transport_lookup_process should rcu_read_unlock when transport is null [ Upstream commit 08abb79542c9e8c367d1d8e44fe1026868d3f0a7 ] Prior to this patch, sctp_transport_lookup_process didn't rcu_read_unlock when it failed to find a transport by sctp_addrs_lookup_transport. This patch is to fix it by moving up rcu_read_unlock right before checking transport and also to remove the out path. Fixes: 1cceda784980 ("sctp: fix the issue sctp_diag uses lock_sock in rcu_read_lock") Signed-off-by: Xin Long Acked-by: Marcelo Ricardo Leitner Signed-off-by: David S. Miller --- net/sctp/socket.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/net/sctp/socket.c b/net/sctp/socket.c index f23ad91..ca12aa3 100644 --- a/net/sctp/socket.c +++ b/net/sctp/socket.c @@ -4479,9 +4479,10 @@ int sctp_transport_lookup_process(int (*cb)(struct sctp_transport *, void *), rcu_read_lock(); transport = sctp_addrs_lookup_transport(net, laddr, paddr); - if (!transport || !sctp_transport_hold(transport)) + if (!transport || !sctp_transport_hold(transport)) { + rcu_read_unlock(); goto out; - + } rcu_read_unlock(); err = cb(transport, p); sctp_transport_put(transport); -- 2.7.4 >>From 44dec74396881da932e5d50ffac7e7b9bdcda86c Mon Sep 17 00:00:00 2001 From: Willem de Bruijn Date: Thu, 22 Dec 2016 18:19:16 -0500 Subject: [PATCH 04/37] inet: fix IP(V6)_RECVORIGDSTADDR for udp sockets [ Upstream commit 39b2dd765e0711e1efd1d1df089473a8dd93ad48 ] Socket cmsg IP(V6)_RECVORIGDSTADDR checks that port range lies within the packet. For sockets that have transport headers pulled, transport offset can be negative. Use signed comparison to avoid overflow. Fixes: e6afc8ace6dd ("udp: remove headers from UDP packets before queueing") Reported-by: Nisar Jagabar Signed-off-by: Willem de Bruijn Signed-off-by: David S. Miller --- net/ipv4/ip_sockglue.c | 2 +- net/ipv6/datagram.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c index b8a2d63..e869773 100644 --- a/net/ipv4/ip_sockglue.c +++ b/net/ipv4/ip_sockglue.c @@ -137,7 +137,7 @@ static void ip_cmsg_recv_dstaddr(struct msghdr *msg, struct sk_buff *skb) const struct iphdr *iph = ip_hdr(skb); __be16 *ports = (__be16 *)skb_transport_header(skb); - if (skb_transport_offset(skb) + 4 > skb->len) + if (skb_transport_offset(skb) + 4 > (int)skb->len) return; /* All current transport protocols have the port numbers in the diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c index ccf4055..8616d17 100644 --- a/net/ipv6/datagram.c +++ b/net/ipv6/datagram.c @@ -700,7 +700,7 @@ void ip6_datagram_recv_specific_ctl(struct sock *sk, struct msghdr *msg, struct sockaddr_in6 sin6; __be16 *ports = (__be16 *) skb_transport_header(skb); - if (skb_transport_offset(skb) + 4 <= skb->len) { + if (skb_transport_offset(skb) + 4 <= (int)skb->len) { /* All current transport protocols have the port numbers in the * first four bytes of the transport header and this function is * written with this assumption in mind. -- 2.7.4 >>From 234fdeb0974828952d834f4f9e0737ec9fa61fe1 Mon Sep 17 00:00:00 2001 From: Dave Jones Date: Thu, 22 Dec 2016 11:16:22 -0500 Subject: [PATCH 05/37] ipv6: handle -EFAULT from skb_copy_bits [ Upstream commit a98f91758995cb59611e61318dddd8a6956b52c3 ] By setting certain socket options on ipv6 raw sockets, we can confuse the length calculation in rawv6_push_pending_frames triggering a BUG_ON. RIP: 0010:[] [] rawv6_sendmsg+0xc30/0xc40 RSP: 0018:ffff881f6c4a7c18 EFLAGS: 00010282 RAX: 00000000fffffff2 RBX: ffff881f6c681680 RCX: 0000000000000002 RDX: ffff881f6c4a7cf8 RSI: 0000000000000030 RDI: ffff881fed0f6a00 RBP: ffff881f6c4a7da8 R08: 0000000000000000 R09: 0000000000000009 R10: ffff881fed0f6a00 R11: 0000000000000009 R12: 0000000000000030 R13: ffff881fed0f6a00 R14: ffff881fee39ba00 R15: ffff881fefa93a80 Call Trace: [] ? unmap_page_range+0x693/0x830 [] inet_sendmsg+0x67/0xa0 [] sock_sendmsg+0x38/0x50 [] SYSC_sendto+0xef/0x170 [] SyS_sendto+0xe/0x10 [] do_syscall_64+0x50/0xa0 [] entry_SYSCALL64_slow_path+0x25/0x25 Handle by jumping to the failure path if skb_copy_bits gets an EFAULT. Reproducer: #include #include #include #include #include #include #include #define LEN 504 int main(int argc, char* argv[]) { int fd; int zero = 0; char buf[LEN]; memset(buf, 0, LEN); fd = socket(AF_INET6, SOCK_RAW, 7); setsockopt(fd, SOL_IPV6, IPV6_CHECKSUM, &zero, 4); setsockopt(fd, SOL_IPV6, IPV6_DSTOPTS, &buf, LEN); sendto(fd, buf, 1, 0, (struct sockaddr *) buf, 110); } Signed-off-by: Dave Jones Signed-off-by: David S. Miller --- net/ipv6/raw.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c index 054a1d8..869ffc7 100644 --- a/net/ipv6/raw.c +++ b/net/ipv6/raw.c @@ -589,7 +589,11 @@ static int rawv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6, } offset += skb_transport_offset(skb); - BUG_ON(skb_copy_bits(skb, offset, &csum, 2)); + err = skb_copy_bits(skb, offset, &csum, 2); + if (err < 0) { + ip6_flush_pending_frames(sk); + goto out; + } /* in case cksum was not initialized */ if (unlikely(csum)) -- 2.7.4 >>From e55e6ccbfa137bcdb750561ba6c281752a24fc1b Mon Sep 17 00:00:00 2001 From: Daniel Borkmann Date: Wed, 21 Dec 2016 18:04:11 +0100 Subject: [PATCH 06/37] net, sched: fix soft lockup in tc_classify [ Upstream commit 628185cfddf1dfb701c4efe2cfd72cf5b09f5702 ] Shahar reported a soft lockup in tc_classify(), where we run into an endless loop when walking the classifier chain due to tp->next == tp which is a state we should never run into. The issue only seems to trigger under load in the tc control path. What happens is that in tc_ctl_tfilter(), thread A allocates a new tp, initializes it, sets tp_created to 1, and calls into tp->ops->change() with it. In that classifier callback we had to unlock/lock the rtnl mutex and returned with -EAGAIN. One reason why we need to drop there is, for example, that we need to request an action module to be loaded. This happens via tcf_exts_validate() -> tcf_action_init/_1() meaning after we loaded and found the requested action, we need to redo the whole request so we don't race against others. While we had to unlock rtnl in that time, thread B's request was processed next on that CPU. Thread B added a new tp instance successfully to the classifier chain. When thread A returned grabbing the rtnl mutex again, propagating -EAGAIN and destroying its tp instance which never got linked, we goto replay and redo A's request. This time when walking the classifier chain in tc_ctl_tfilter() for checking for existing tp instances we had a priority match and found the tp instance that was created and linked by thread B. Now calling again into tp->ops->change() with that tp was successful and returned without error. tp_created was never cleared in the second round, thus kernel thinks that we need to link it into the classifier chain (once again). tp and *back point to the same object due to the match we had earlier on. Thus for thread B's already public tp, we reset tp->next to tp itself and link it into the chain, which eventually causes the mentioned endless loop in tc_classify() once a packet hits the data path. Fix is to clear tp_created at the beginning of each request, also when we replay it. On the paths that can cause -EAGAIN we already destroy the original tp instance we had and on replay we really need to start from scratch. It seems that this issue was first introduced in commit 12186be7d2e1 ("net_cls: fix unconfigured struct tcf_proto keeps chaining and avoid kernel panic when we use cls_cgroup"). Fixes: 12186be7d2e1 ("net_cls: fix unconfigured struct tcf_proto keeps chaining and avoid kernel panic when we use cls_cgroup") Reported-by: Shahar Klein Signed-off-by: Daniel Borkmann Cc: Cong Wang Acked-by: Eric Dumazet Tested-by: Shahar Klein Signed-off-by: David S. Miller --- net/sched/cls_api.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c index b05d4a2..c1a4b5d 100644 --- a/net/sched/cls_api.c +++ b/net/sched/cls_api.c @@ -148,13 +148,15 @@ static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n) unsigned long cl; unsigned long fh; int err; - int tp_created = 0; + int tp_created; if ((n->nlmsg_type != RTM_GETTFILTER) && !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) return -EPERM; replay: + tp_created = 0; + err = nlmsg_parse(n, sizeof(*t), tca, TCA_MAX, NULL); if (err < 0) return err; -- 2.7.4 >>From 46e7b8c9f109e91e6a0447e0ab6ad7937ae9a6e9 Mon Sep 17 00:00:00 2001 From: Florian Fainelli Date: Tue, 27 Dec 2016 18:23:06 -0800 Subject: [PATCH 07/37] net: stmmac: Fix race between stmmac_drv_probe and stmmac_open [ Upstream commit 5701659004d68085182d2fd4199c79172165fa65 ] There is currently a small window during which the network device registered by stmmac can be made visible, yet all resources, including and clock and MDIO bus have not had a chance to be set up, this can lead to the following error to occur: [ 473.919358] stmmaceth 0000:01:00.0 (unnamed net_device) (uninitialized): stmmac_dvr_probe: warning: cannot get CSR clock [ 473.919382] stmmaceth 0000:01:00.0: no reset control found [ 473.919412] stmmac - user ID: 0x10, Synopsys ID: 0x42 [ 473.919429] stmmaceth 0000:01:00.0: DMA HW capability register supported [ 473.919436] stmmaceth 0000:01:00.0: RX Checksum Offload Engine supported [ 473.919443] stmmaceth 0000:01:00.0: TX Checksum insertion supported [ 473.919451] stmmaceth 0000:01:00.0 (unnamed net_device) (uninitialized): Enable RX Mitigation via HW Watchdog Timer [ 473.921395] libphy: PHY stmmac-1:00 not found [ 473.921417] stmmaceth 0000:01:00.0 eth0: Could not attach to PHY [ 473.921427] stmmaceth 0000:01:00.0 eth0: stmmac_open: Cannot attach to PHY (error: -19) [ 473.959710] libphy: stmmac: probed [ 473.959724] stmmaceth 0000:01:00.0 eth0: PHY ID 01410cc2 at 0 IRQ POLL (stmmac-1:00) active [ 473.959728] stmmaceth 0000:01:00.0 eth0: PHY ID 01410cc2 at 1 IRQ POLL (stmmac-1:01) [ 473.959731] stmmaceth 0000:01:00.0 eth0: PHY ID 01410cc2 at 2 IRQ POLL (stmmac-1:02) [ 473.959734] stmmaceth 0000:01:00.0 eth0: PHY ID 01410cc2 at 3 IRQ POLL (stmmac-1:03) Fix this by making sure that register_netdev() is the last thing being done, which guarantees that the clock and the MDIO bus are available. Fixes: 4bfcbd7abce2 ("stmmac: Move the mdio_register/_unregister in probe/remove") Reported-by: Kweh, Hock Leong Signed-off-by: Florian Fainelli Signed-off-by: David S. Miller --- drivers/net/ethernet/stmicro/stmmac/stmmac_main.c | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c index caf069a..b2893fb 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c @@ -3349,12 +3349,6 @@ int stmmac_dvr_probe(struct device *device, spin_lock_init(&priv->lock); spin_lock_init(&priv->tx_lock); - ret = register_netdev(ndev); - if (ret) { - pr_err("%s: ERROR %i registering the device\n", __func__, ret); - goto error_netdev_register; - } - /* If a specific clk_csr value is passed from the platform * this means that the CSR Clock Range selection cannot be * changed at run-time and it is fixed. Viceversa the driver'll try to @@ -3376,15 +3370,24 @@ int stmmac_dvr_probe(struct device *device, if (ret < 0) { pr_debug("%s: MDIO bus (id: %d) registration failed", __func__, priv->plat->bus_id); - goto error_mdio_register; + goto error_napi_register; } } - return 0; + ret = register_netdev(ndev); + if (ret) { + pr_err("%s: ERROR %i registering the device\n", __func__, ret); + goto error_netdev_register; + } + + return ret; -error_mdio_register: - unregister_netdev(ndev); error_netdev_register: + if (priv->hw->pcs != STMMAC_PCS_RGMII && + priv->hw->pcs != STMMAC_PCS_TBI && + priv->hw->pcs != STMMAC_PCS_RTBI) + stmmac_mdio_unregister(ndev); +error_napi_register: netif_napi_del(&priv->napi); error_hw_init: clk_disable_unprepare(priv->pclk); -- 2.7.4 >>From 8941acf18f6391e66edfd0fbb349545d593b70da Mon Sep 17 00:00:00 2001 From: Paul Blakey Date: Wed, 28 Dec 2016 14:54:47 +0200 Subject: [PATCH 08/37] net/sched: cls_flower: Fix missing addr_type in classify [ Upstream commit 0df0f207aab4f42e5c96a807adf9a6845b69e984 ] Since we now use a non zero mask on addr_type, we are matching on its value (IPV4/IPV6). So before this fix, matching on enc_src_ip/enc_dst_ip failed in SW/classify path since its value was zero. This patch sets the proper value of addr_type for encapsulated packets. Fixes: 970bfcd09791 ('net/sched: cls_flower: Use mask for addr_type') Signed-off-by: Paul Blakey Reviewed-by: Hadar Hen Zion Acked-by: Jiri Pirko Signed-off-by: David S. Miller --- net/sched/cls_flower.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/net/sched/cls_flower.c b/net/sched/cls_flower.c index 9044424..eee299b 100644 --- a/net/sched/cls_flower.c +++ b/net/sched/cls_flower.c @@ -149,10 +149,14 @@ static int fl_classify(struct sk_buff *skb, const struct tcf_proto *tp, switch (ip_tunnel_info_af(info)) { case AF_INET: + skb_key.enc_control.addr_type = + FLOW_DISSECTOR_KEY_IPV4_ADDRS; skb_key.enc_ipv4.src = key->u.ipv4.src; skb_key.enc_ipv4.dst = key->u.ipv4.dst; break; case AF_INET6: + skb_key.enc_control.addr_type = + FLOW_DISSECTOR_KEY_IPV6_ADDRS; skb_key.enc_ipv6.src = key->u.ipv6.src; skb_key.enc_ipv6.dst = key->u.ipv6.dst; break; -- 2.7.4 >>From 0e3eacd0148368b59477d83881e9165ff7ec594f Mon Sep 17 00:00:00 2001 From: Noa Osherovich Date: Wed, 28 Dec 2016 14:58:32 +0200 Subject: [PATCH 09/37] net/mlx5: Check FW limitations on log_max_qp before setting it [ Upstream commit 883371c453b937f9eb581fb4915210865982736f ] When setting HCA capabilities, set log_max_qp to be the minimum between the selected profile's value and the HCA limitation. Fixes: 938fe83c8dcb ('net/mlx5_core: New device capabilities...') Signed-off-by: Noa Osherovich Signed-off-by: Saeed Mahameed Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/main.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c index ada24e1..332769c 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c @@ -468,6 +468,13 @@ static int handle_hca_cap(struct mlx5_core_dev *dev) MLX5_SET(cmd_hca_cap, set_hca_cap, pkey_table_size, to_fw_pkey_sz(dev, 128)); + /* Check log_max_qp from HCA caps to set in current profile */ + if (MLX5_CAP_GEN_MAX(dev, log_max_qp) < profile[prof_sel].log_max_qp) { + mlx5_core_warn(dev, "log_max_qp value in current profile is %d, changing it to HCA capability limit (%d)\n", + profile[prof_sel].log_max_qp, + MLX5_CAP_GEN_MAX(dev, log_max_qp)); + profile[prof_sel].log_max_qp = MLX5_CAP_GEN_MAX(dev, log_max_qp); + } if (prof->mask & MLX5_PROF_MASK_QP_SIZE) MLX5_SET(cmd_hca_cap, set_hca_cap, log_max_qp, prof->log_max_qp); -- 2.7.4 >>From efeec3a3f5504fc1947488337a62c7c0d16dd1a7 Mon Sep 17 00:00:00 2001 From: Daniel Jurgens Date: Wed, 28 Dec 2016 14:58:33 +0200 Subject: [PATCH 10/37] net/mlx5: Cancel recovery work in remove flow [ Upstream commit 689a248df83b6032edc57e86267b4e5cc8d7174e ] If there is pending delayed work for health recovery it must be canceled if the device is being unloaded. Fixes: 05ac2c0b7438 ("net/mlx5: Fix race between PCI error handlers and health work") Signed-off-by: Daniel Jurgens Signed-off-by: Saeed Mahameed Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/main.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c index 332769c..15b7e60 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c @@ -1159,6 +1159,8 @@ static int mlx5_unload_one(struct mlx5_core_dev *dev, struct mlx5_priv *priv, { int err = 0; + mlx5_drain_health_wq(dev); + mutex_lock(&dev->intf_state_mutex); if (test_bit(MLX5_INTERFACE_STATE_DOWN, &dev->intf_state)) { dev_warn(&dev->pdev->dev, "%s: interface is down, NOP\n", @@ -1319,10 +1321,9 @@ static pci_ers_result_t mlx5_pci_err_detected(struct pci_dev *pdev, mlx5_enter_error_state(dev); mlx5_unload_one(dev, priv, false); - /* In case of kernel call save the pci state and drain health wq */ + /* In case of kernel call save the pci state */ if (state) { pci_save_state(pdev); - mlx5_drain_health_wq(dev); mlx5_pci_disable_device(dev); } -- 2.7.4 >>From dda931a2cffceb97eae26545c2f8b72d75c724a0 Mon Sep 17 00:00:00 2001 From: Eli Cohen Date: Wed, 28 Dec 2016 14:58:34 +0200 Subject: [PATCH 11/37] net/mlx5: Avoid shadowing numa_node [ Upstream commit d151d73dcc99de87c63bdefebcc4cb69de1cdc40 ] Avoid using a local variable named numa_node to avoid shadowing a public one. Fixes: db058a186f98 ('net/mlx5_core: Set irq affinity hints') Signed-off-by: Eli Cohen Signed-off-by: Saeed Mahameed Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/main.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c index 15b7e60..92bd13d 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c @@ -547,7 +547,6 @@ static int mlx5_irq_set_affinity_hint(struct mlx5_core_dev *mdev, int i) struct mlx5_priv *priv = &mdev->priv; struct msix_entry *msix = priv->msix_arr; int irq = msix[i + MLX5_EQ_VEC_COMP_BASE].vector; - int numa_node = priv->numa_node; int err; if (!zalloc_cpumask_var(&priv->irq_info[i].mask, GFP_KERNEL)) { @@ -555,7 +554,7 @@ static int mlx5_irq_set_affinity_hint(struct mlx5_core_dev *mdev, int i) return -ENOMEM; } - cpumask_set_cpu(cpumask_local_spread(i, numa_node), + cpumask_set_cpu(cpumask_local_spread(i, priv->numa_node), priv->irq_info[i].mask); err = irq_set_affinity_hint(irq, priv->irq_info[i].mask); -- 2.7.4 >>From 6bd939c40912e6eec51d52ef251b785333df6b18 Mon Sep 17 00:00:00 2001 From: Maor Gottlieb Date: Wed, 28 Dec 2016 14:58:35 +0200 Subject: [PATCH 12/37] net/mlx5: Mask destination mac value in ethtool steering rules [ Upstream commit 077b1e8069b9b74477b01d28f6b83774dc19a142 ] We need to mask the destination mac value with the destination mac mask when adding steering rule via ethtool. Fixes: 1174fce8d1410 ('net/mlx5e: Support l3/l4 flow type specs in ethtool flow steering') Signed-off-by: Maor Gottlieb Signed-off-by: Saeed Mahameed Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c b/drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c index d17c242..90e81ae 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_fs_ethtool.c @@ -247,6 +247,7 @@ static int set_flow_attrs(u32 *match_c, u32 *match_v, } if (fs->flow_type & FLOW_MAC_EXT && !is_zero_ether_addr(fs->m_ext.h_dest)) { + mask_spec(fs->m_ext.h_dest, fs->h_ext.h_dest, ETH_ALEN); ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, outer_headers_c, dmac_47_16), fs->m_ext.h_dest); -- 2.7.4 >>From c83b1b583a985fe44ece2ca24abea71611393114 Mon Sep 17 00:00:00 2001 From: Mohamad Haj Yahia Date: Wed, 28 Dec 2016 14:58:37 +0200 Subject: [PATCH 13/37] net/mlx5: Prevent setting multicast macs for VFs [ Upstream commit ccce1700263d8b5b219359d04180492a726cea16 ] Need to check that VF mac address entered by the admin user is either zero or unicast mac. Multicast mac addresses are prohibited. Fixes: 77256579c6b4 ('net/mlx5: E-Switch, Introduce Vport administration functions') Signed-off-by: Mohamad Haj Yahia Signed-off-by: Saeed Mahameed Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/eswitch.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c b/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c index be1f733..c7011ef 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/eswitch.c @@ -1703,7 +1703,7 @@ int mlx5_eswitch_set_vport_mac(struct mlx5_eswitch *esw, if (!ESW_ALLOWED(esw)) return -EPERM; - if (!LEGAL_VPORT(esw, vport)) + if (!LEGAL_VPORT(esw, vport) || is_multicast_ether_addr(mac)) return -EINVAL; mutex_lock(&esw->state_lock); -- 2.7.4 >>From 4ea5db6017b45457d2c50a42e067b20968a6720c Mon Sep 17 00:00:00 2001 From: Saeed Mahameed Date: Wed, 28 Dec 2016 14:58:41 +0200 Subject: [PATCH 14/37] net/mlx5e: Don't sync netdev state when not registered [ Upstream commit 610e89e05c3f28a7394935aa6b91f99548c4fd3c ] Skip setting netdev vxlan ports and netdev rx_mode on driver load when netdev is not yet registered. Synchronizing with netdev state is needed only on reset flow where the netdev remains registered for the whole reset period. This also fixes an access before initialization of net_device.addr_list_lock - which for some reason initialized on register_netdev - where we queued set_rx_mode work on driver load before netdev registration. Fixes: 26e59d8077a3 ("net/mlx5e: Implement mlx5e interface attach/detach callbacks") Signed-off-by: Saeed Mahameed Reported-by: Sebastian Ott Reviewed-by: Mohamad Haj Yahia Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index 246d98e..307b270 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -3773,14 +3773,7 @@ static void mlx5e_nic_enable(struct mlx5e_priv *priv) mlx5_lag_add(mdev, netdev); - if (mlx5e_vxlan_allowed(mdev)) { - rtnl_lock(); - udp_tunnel_get_rx_info(netdev); - rtnl_unlock(); - } - mlx5e_enable_async_events(priv); - queue_work(priv->wq, &priv->set_rx_mode_work); if (MLX5_CAP_GEN(mdev, vport_group_manager)) { mlx5_query_nic_vport_mac_address(mdev, 0, rep.hw_id); @@ -3790,6 +3783,18 @@ static void mlx5e_nic_enable(struct mlx5e_priv *priv) rep.priv_data = priv; mlx5_eswitch_register_vport_rep(esw, 0, &rep); } + + if (netdev->reg_state != NETREG_REGISTERED) + return; + + /* Device already registered: sync netdev system state */ + if (mlx5e_vxlan_allowed(mdev)) { + rtnl_lock(); + udp_tunnel_get_rx_info(netdev); + rtnl_unlock(); + } + + queue_work(priv->wq, &priv->set_rx_mode_work); } static void mlx5e_nic_disable(struct mlx5e_priv *priv) -- 2.7.4 >>From c078e5909b40fdf6ac4294ce493600498825f709 Mon Sep 17 00:00:00 2001 From: Saeed Mahameed Date: Wed, 28 Dec 2016 14:58:42 +0200 Subject: [PATCH 15/37] net/mlx5e: Disable netdev after close [ Upstream commit 37f304d10030bb425c19099e7b955d9c3ec4cba3 ] Disable netdev should come after it was closed, although no harm of doing it before -hence the MLX5E_STATE_DESTROYING bit- but it is more natural this way. Fixes: 26e59d8077a3 ("net/mlx5e: Implement mlx5e interface attach/detach callbacks") Signed-off-by: Saeed Mahameed Reviewed-by: Mohamad Haj Yahia Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c index 307b270..5dc3e24 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -3942,10 +3942,6 @@ void mlx5e_detach_netdev(struct mlx5_core_dev *mdev, struct net_device *netdev) const struct mlx5e_profile *profile = priv->profile; set_bit(MLX5E_STATE_DESTROYING, &priv->state); - if (profile->disable) - profile->disable(priv); - - flush_workqueue(priv->wq); rtnl_lock(); if (netif_running(netdev)) @@ -3953,6 +3949,10 @@ void mlx5e_detach_netdev(struct mlx5_core_dev *mdev, struct net_device *netdev) netif_device_detach(netdev); rtnl_unlock(); + if (profile->disable) + profile->disable(priv); + flush_workqueue(priv->wq); + mlx5e_destroy_q_counter(priv); profile->cleanup_rx(priv); mlx5e_close_drop_rq(priv); -- 2.7.4 >>From b6484b1c5e7ad5191307b45f41a3bba917123ada Mon Sep 17 00:00:00 2001 From: Mathias Krause Date: Wed, 28 Dec 2016 17:52:15 +0100 Subject: [PATCH 16/37] rtnl: stats - add missing netlink message size checks [ Upstream commit 4775cc1f2d5abca894ac32774eefc22c45347d1c ] We miss to check if the netlink message is actually big enough to contain a struct if_stats_msg. Add a check to prevent userland from sending us short messages that would make us access memory beyond the end of the message. Fixes: 10c9ead9f3c6 ("rtnetlink: add new RTM_GETSTATS message to dump...") Signed-off-by: Mathias Krause Cc: Roopa Prabhu Signed-off-by: David S. Miller --- net/core/rtnetlink.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c index a6196cf..b7f9ae7 100644 --- a/net/core/rtnetlink.c +++ b/net/core/rtnetlink.c @@ -3886,6 +3886,9 @@ static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh) u32 filter_mask; int err; + if (nlmsg_len(nlh) < sizeof(*ifsm)) + return -EINVAL; + ifsm = nlmsg_data(nlh); if (ifsm->ifindex > 0) dev = __dev_get_by_index(net, ifsm->ifindex); @@ -3935,6 +3938,9 @@ static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb) cb->seq = net->dev_base_seq; + if (nlmsg_len(cb->nlh) < sizeof(*ifsm)) + return -EINVAL; + ifsm = nlmsg_data(cb->nlh); filter_mask = ifsm->filter_mask; if (!filter_mask) -- 2.7.4 >>From 1c0bd98c345cb615972a9f8ce5bbad53ea880132 Mon Sep 17 00:00:00 2001 From: Wei Zhang Date: Thu, 29 Dec 2016 16:45:04 +0800 Subject: [PATCH 17/37] net: fix incorrect original ingress device index in PKTINFO [ Upstream commit f0c16ba8933ed217c2688b277410b2a37ba81591 ] When we send a packet for our own local address on a non-loopback interface (e.g. eth0), due to the change had been introduced from commit 0b922b7a829c ("net: original ingress device index in PKTINFO"), the original ingress device index would be set as the loopback interface. However, the packet should be considered as if it is being arrived via the sending interface (eth0), otherwise it would break the expectation of the userspace application (e.g. the DHCPRELEASE message from dhcp_release binary would be ignored by the dnsmasq daemon, since it come from lo which is not the interface dnsmasq bind to) Fixes: 0b922b7a829c ("net: original ingress device index in PKTINFO") Acked-by: David Ahern Signed-off-by: Wei Zhang Signed-off-by: David S. Miller --- net/ipv4/ip_sockglue.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c index e869773..f226f408 100644 --- a/net/ipv4/ip_sockglue.c +++ b/net/ipv4/ip_sockglue.c @@ -1202,8 +1202,14 @@ void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb) * which has interface index (iif) as the first member of the * underlying inet{6}_skb_parm struct. This code then overlays * PKTINFO_SKB_CB and in_pktinfo also has iif as the first - * element so the iif is picked up from the prior IPCB + * element so the iif is picked up from the prior IPCB. If iif + * is the loopback interface, then return the sending interface + * (e.g., process binds socket to eth0 for Tx which is + * redirected to loopback in the rtable/dst). */ + if (pktinfo->ipi_ifindex == LOOPBACK_IFINDEX) + pktinfo->ipi_ifindex = inet_iif(skb); + pktinfo->ipi_spec_dst.s_addr = fib_compute_spec_dst(skb); } else { pktinfo->ipi_ifindex = 0; -- 2.7.4 >>From c2736efebfed992e05763f1ec50ecd9cd4b804ac Mon Sep 17 00:00:00 2001 From: David Ahern Date: Thu, 29 Dec 2016 15:29:03 -0800 Subject: [PATCH 18/37] net: ipv4: dst for local input routes should use l3mdev if relevant [ Upstream commit f5a0aab84b74de68523599817569c057c7ac1622 ] IPv4 output routes already use l3mdev device instead of loopback for dst's if it is applicable. Change local input routes to do the same. This fixes icmp responses for unreachable UDP ports which are directed to the wrong table after commit 9d1a6c4ea43e4 because local_input routes use the loopback device. Moving from ingress device to loopback loses the L3 domain causing responses based on the dst to get to lost. Fixes: 9d1a6c4ea43e4 ("net: icmp_route_lookup should use rt dev to determine L3 domain") Signed-off-by: David Ahern Signed-off-by: David S. Miller --- net/ipv4/route.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/net/ipv4/route.c b/net/ipv4/route.c index 2a57566..8197b06 100644 --- a/net/ipv4/route.c +++ b/net/ipv4/route.c @@ -1902,7 +1902,8 @@ out: return err; } } - rth = rt_dst_alloc(net->loopback_dev, flags | RTCF_LOCAL, res.type, + rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev, + flags | RTCF_LOCAL, res.type, IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache); if (!rth) goto e_nobufs; -- 2.7.4 >>From 5a132f59f6fe185a85b168ee11136f7862111eeb Mon Sep 17 00:00:00 2001 From: Reiter Wolfgang Date: Sat, 31 Dec 2016 21:11:57 +0100 Subject: [PATCH 19/37] drop_monitor: add missing call to genlmsg_end [ Upstream commit 4200462d88f47f3759bdf4705f87e207b0f5b2e4 ] Update nlmsg_len field with genlmsg_end to enable userspace processing using nlmsg_next helper. Also adds error handling. Signed-off-by: Reiter Wolfgang Acked-by: Neil Horman Signed-off-by: David S. Miller --- net/core/drop_monitor.c | 33 ++++++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/net/core/drop_monitor.c b/net/core/drop_monitor.c index 72cfb0c..5de61aa 100644 --- a/net/core/drop_monitor.c +++ b/net/core/drop_monitor.c @@ -80,6 +80,7 @@ static struct sk_buff *reset_per_cpu_data(struct per_cpu_dm_data *data) struct nlattr *nla; struct sk_buff *skb; unsigned long flags; + void *msg_header; al = sizeof(struct net_dm_alert_msg); al += dm_hit_limit * sizeof(struct net_dm_drop_point); @@ -87,17 +88,31 @@ static struct sk_buff *reset_per_cpu_data(struct per_cpu_dm_data *data) skb = genlmsg_new(al, GFP_KERNEL); - if (skb) { - genlmsg_put(skb, 0, 0, &net_drop_monitor_family, - 0, NET_DM_CMD_ALERT); - nla = nla_reserve(skb, NLA_UNSPEC, - sizeof(struct net_dm_alert_msg)); - msg = nla_data(nla); - memset(msg, 0, al); - } else { - mod_timer(&data->send_timer, jiffies + HZ / 10); + if (!skb) + goto err; + + msg_header = genlmsg_put(skb, 0, 0, &net_drop_monitor_family, + 0, NET_DM_CMD_ALERT); + if (!msg_header) { + nlmsg_free(skb); + skb = NULL; + goto err; + } + nla = nla_reserve(skb, NLA_UNSPEC, + sizeof(struct net_dm_alert_msg)); + if (!nla) { + nlmsg_free(skb); + skb = NULL; + goto err; } + msg = nla_data(nla); + memset(msg, 0, al); + genlmsg_end(skb, msg_header); + goto out; +err: + mod_timer(&data->send_timer, jiffies + HZ / 10); +out: spin_lock_irqsave(&data->lock, flags); swap(data->skb, skb); spin_unlock_irqrestore(&data->lock, flags); -- 2.7.4 >>From e606a46798f5b6829d535877671e988e9e0e02c8 Mon Sep 17 00:00:00 2001 From: Reiter Wolfgang Date: Tue, 3 Jan 2017 01:39:10 +0100 Subject: [PATCH 20/37] drop_monitor: consider inserted data in genlmsg_end [ Upstream commit 3b48ab2248e61408910e792fe84d6ec466084c1a ] Final nlmsg_len field update must reflect inserted net_dm_drop_point data. This patch depends on previous patch: "drop_monitor: add missing call to genlmsg_end" Signed-off-by: Reiter Wolfgang Acked-by: Neil Horman Signed-off-by: David S. Miller --- net/core/drop_monitor.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/net/core/drop_monitor.c b/net/core/drop_monitor.c index 5de61aa..ca2c9c8 100644 --- a/net/core/drop_monitor.c +++ b/net/core/drop_monitor.c @@ -107,7 +107,6 @@ static struct sk_buff *reset_per_cpu_data(struct per_cpu_dm_data *data) } msg = nla_data(nla); memset(msg, 0, al); - genlmsg_end(skb, msg_header); goto out; err: @@ -117,6 +116,13 @@ static struct sk_buff *reset_per_cpu_data(struct per_cpu_dm_data *data) swap(data->skb, skb); spin_unlock_irqrestore(&data->lock, flags); + if (skb) { + struct nlmsghdr *nlh = (struct nlmsghdr *)skb->data; + struct genlmsghdr *gnlh = (struct genlmsghdr *)nlmsg_data(nlh); + + genlmsg_end(skb, genlmsg_data(gnlh)); + } + return skb; } -- 2.7.4 >>From 64e0f8601bf0e45f088f8879df8f79944451394f Mon Sep 17 00:00:00 2001 From: Ian Kumlien Date: Mon, 2 Jan 2017 09:18:35 +0100 Subject: [PATCH 21/37] flow_dissector: Update pptp handling to avoid null pointer deref. [ Upstream commit d0af683407a26a4437d8fa6e283ea201f2ae8146 ] __skb_flow_dissect can be called with a skb or a data packet, either can be NULL. All calls seems to have been moved to __skb_header_pointer except the pptp handling which is still calling skb_header_pointer. skb_header_pointer will use skb->data and thus: [ 109.556866] BUG: unable to handle kernel NULL pointer dereference at 0000000000000080 [ 109.557102] IP: [] __skb_flow_dissect+0xa88/0xce0 [ 109.557263] PGD 0 [ 109.557338] [ 109.557484] Oops: 0000 [#1] SMP [ 109.557562] Modules linked in: chaoskey [ 109.557783] CPU: 2 PID: 0 Comm: swapper/2 Not tainted 4.9.0 #79 [ 109.557867] Hardware name: Supermicro A1SRM-LN7F/LN5F/A1SRM-LN7F-2758, BIOS 1.0c 11/04/2015 [ 109.557957] task: ffff94085c27bc00 task.stack: ffffb745c0068000 [ 109.558041] RIP: 0010:[] [] __skb_flow_dissect+0xa88/0xce0 [ 109.558203] RSP: 0018:ffff94087fc83d40 EFLAGS: 00010206 [ 109.558286] RAX: 0000000000000130 RBX: ffffffff8975bf80 RCX: ffff94084fab6800 [ 109.558373] RDX: 0000000000000010 RSI: 000000000000000c RDI: 0000000000000000 [ 109.558460] RBP: 0000000000000b88 R08: 0000000000000000 R09: 0000000000000022 [ 109.558547] R10: 0000000000000008 R11: ffff94087fc83e04 R12: 0000000000000000 [ 109.558763] R13: ffff94084fab6800 R14: ffff94087fc83e04 R15: 000000000000002f [ 109.558979] FS: 0000000000000000(0000) GS:ffff94087fc80000(0000) knlGS:0000000000000000 [ 109.559326] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 109.559539] CR2: 0000000000000080 CR3: 0000000281809000 CR4: 00000000001026e0 [ 109.559753] Stack: [ 109.559957] 000000000000000c ffff94084fab6822 0000000000000001 ffff94085c2b5fc0 [ 109.560578] 0000000000000001 0000000000002000 0000000000000000 0000000000000000 [ 109.561200] 0000000000000000 0000000000000000 0000000000000000 0000000000000000 [ 109.561820] Call Trace: [ 109.562027] [ 109.562108] [] ? eth_get_headlen+0x7a/0xf0 [ 109.562522] [] ? igb_poll+0x96a/0xe80 [ 109.562737] [] ? net_rx_action+0x20b/0x350 [ 109.562953] [] ? __do_softirq+0xe8/0x280 [ 109.563169] [] ? irq_exit+0xaa/0xb0 [ 109.563382] [] ? do_IRQ+0x4b/0xc0 [ 109.563597] [] ? common_interrupt+0x7f/0x7f [ 109.563810] [ 109.563890] [] ? cpuidle_enter_state+0x130/0x2c0 [ 109.564304] [] ? cpuidle_enter_state+0x120/0x2c0 [ 109.564520] [] ? cpu_startup_entry+0x19f/0x1f0 [ 109.564737] [] ? start_secondary+0x12a/0x140 [ 109.564950] Code: 83 e2 20 a8 80 0f 84 60 01 00 00 c7 04 24 08 00 00 00 66 85 d2 0f 84 be fe ff ff e9 69 fe ff ff 8b 34 24 89 f2 83 c2 04 66 85 c0 <41> 8b 84 24 80 00 00 00 0f 49 d6 41 8d 31 01 d6 41 2b 84 24 84 [ 109.569959] RIP [] __skb_flow_dissect+0xa88/0xce0 [ 109.570245] RSP [ 109.570453] CR2: 0000000000000080 Fixes: ab10dccb1160 ("rps: Inspect PPTP encapsulated by GRE to get flow hash") Signed-off-by: Ian Kumlien Signed-off-by: David S. Miller --- net/core/flow_dissector.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index c6d8207..32e4e01 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -445,8 +445,9 @@ bool __skb_flow_dissect(const struct sk_buff *skb, if (hdr->flags & GRE_ACK) offset += sizeof(((struct pptp_gre_header *)0)->ack); - ppp_hdr = skb_header_pointer(skb, nhoff + offset, - sizeof(_ppp_hdr), _ppp_hdr); + ppp_hdr = __skb_header_pointer(skb, nhoff + offset, + sizeof(_ppp_hdr), + data, hlen, _ppp_hdr); if (!ppp_hdr) goto out_bad; -- 2.7.4 >>From 0d094f9e59706a3046b2eaf551732038866dd928 Mon Sep 17 00:00:00 2001 From: Michal Tesar Date: Mon, 2 Jan 2017 14:38:36 +0100 Subject: [PATCH 22/37] igmp: Make igmp group member RFC 3376 compliant [ Upstream commit 7ababb782690e03b78657e27bd051e20163af2d6 ] 5.2. Action on Reception of a Query When a system receives a Query, it does not respond immediately. Instead, it delays its response by a random amount of time, bounded by the Max Resp Time value derived from the Max Resp Code in the received Query message. A system may receive a variety of Queries on different interfaces and of different kinds (e.g., General Queries, Group-Specific Queries, and Group-and-Source-Specific Queries), each of which may require its own delayed response. Before scheduling a response to a Query, the system must first consider previously scheduled pending responses and in many cases schedule a combined response. Therefore, the system must be able to maintain the following state: o A timer per interface for scheduling responses to General Queries. o A per-group and interface timer for scheduling responses to Group- Specific and Group-and-Source-Specific Queries. o A per-group and interface list of sources to be reported in the response to a Group-and-Source-Specific Query. When a new Query with the Router-Alert option arrives on an interface, provided the system has state to report, a delay for a response is randomly selected in the range (0, [Max Resp Time]) where Max Resp Time is derived from Max Resp Code in the received Query message. The following rules are then used to determine if a Report needs to be scheduled and the type of Report to schedule. The rules are considered in order and only the first matching rule is applied. 1. If there is a pending response to a previous General Query scheduled sooner than the selected delay, no additional response needs to be scheduled. 2. If the received Query is a General Query, the interface timer is used to schedule a response to the General Query after the selected delay. Any previously pending response to a General Query is canceled. --8<-- Currently the timer is rearmed with new random expiration time for every incoming query regardless of possibly already pending report. Which is not aligned with the above RFE. It also might happen that higher rate of incoming queries can postpone the report after the expiration time of the first query causing group membership loss. Now the per interface general query timer is rearmed only when there is no pending report already scheduled on that interface or the newly selected expiration time is before the already pending scheduled report. Signed-off-by: Michal Tesar Signed-off-by: David S. Miller --- net/ipv4/igmp.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c index 15db786..32a08bc 100644 --- a/net/ipv4/igmp.c +++ b/net/ipv4/igmp.c @@ -219,9 +219,14 @@ static void igmp_start_timer(struct ip_mc_list *im, int max_delay) static void igmp_gq_start_timer(struct in_device *in_dev) { int tv = prandom_u32() % in_dev->mr_maxdelay; + unsigned long exp = jiffies + tv + 2; + + if (in_dev->mr_gq_running && + time_after_eq(exp, (in_dev->mr_gq_timer).expires)) + return; in_dev->mr_gq_running = 1; - if (!mod_timer(&in_dev->mr_gq_timer, jiffies+tv+2)) + if (!mod_timer(&in_dev->mr_gq_timer, exp)) in_dev_hold(in_dev); } -- 2.7.4 >>From 936a42dd615006e49e9f0b6014330b86f692ae6c Mon Sep 17 00:00:00 2001 From: Alexander Duyck Date: Mon, 2 Jan 2017 13:32:54 -0800 Subject: [PATCH 23/37] ipv4: Do not allow MAIN to be alias for new LOCAL w/ custom rules [ Upstream commit 5350d54f6cd12eaff623e890744c79b700bd3f17 ] In the case of custom rules being present we need to handle the case of the LOCAL table being intialized after the new rule has been added. To address that I am adding a new check so that we can make certain we don't use an alias of MAIN for LOCAL when allocating a new table. Fixes: 0ddcf43d5d4a ("ipv4: FIB Local/MAIN table collapse") Reported-by: Oliver Brunel Signed-off-by: Alexander Duyck Signed-off-by: David S. Miller --- net/ipv4/fib_frontend.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c index 161fc0f..3e4f183 100644 --- a/net/ipv4/fib_frontend.c +++ b/net/ipv4/fib_frontend.c @@ -85,7 +85,7 @@ struct fib_table *fib_new_table(struct net *net, u32 id) if (tb) return tb; - if (id == RT_TABLE_LOCAL) + if (id == RT_TABLE_LOCAL && !net->ipv4.fib_has_custom_rules) alias = fib_new_table(net, RT_TABLE_MAIN); tb = fib_trie_table(id, alias); -- 2.7.4 >>From e888a3b2b419b4d7729b35f5ed83dda17939f7ee Mon Sep 17 00:00:00 2001 From: David Ahern Date: Tue, 3 Jan 2017 09:37:55 -0800 Subject: [PATCH 24/37] net: vrf: Add missing Rx counters [ Upstream commit 926d93a33e59b2729afdbad357233c17184de9d2 ] The move from rx-handler to L3 receive handler inadvertantly dropped the rx counters. Restore them. Fixes: 74b20582ac38 ("net: l3mdev: Add hook in ip and ipv6") Reported-by: Dinesh Dutt Signed-off-by: David Ahern Signed-off-by: David S. Miller --- drivers/net/vrf.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c index 3cb3588..809a796 100644 --- a/drivers/net/vrf.c +++ b/drivers/net/vrf.c @@ -968,6 +968,7 @@ static struct sk_buff *vrf_ip6_rcv(struct net_device *vrf_dev, */ need_strict = rt6_need_strict(&ipv6_hdr(skb)->daddr); if (!ipv6_ndisc_frame(skb) && !need_strict) { + vrf_rx_stats(vrf_dev, skb->len); skb->dev = vrf_dev; skb->skb_iif = vrf_dev->ifindex; @@ -1009,6 +1010,8 @@ static struct sk_buff *vrf_ip_rcv(struct net_device *vrf_dev, goto out; } + vrf_rx_stats(vrf_dev, skb->len); + skb_push(skb, skb->mac_len); dev_queue_xmit_nit(skb, vrf_dev); skb_pull(skb, skb->mac_len); -- 2.7.4 >>From 6753205ca80ed9a0aa3cb983f92cd9ac33c1e1b0 Mon Sep 17 00:00:00 2001 From: Daniel Borkmann Date: Sat, 7 Jan 2017 00:26:33 +0100 Subject: [PATCH 25/37] bpf: change back to orig prog on too many passes [ Upstream commit 9d5ecb09d525469abd1a10c096cb5a17206523f2 ] If after too many passes still no image could be emitted, then swap back to the original program as we do in all other cases and don't use the one with blinding. Fixes: 959a75791603 ("bpf, x86: add support for constant blinding") Signed-off-by: Daniel Borkmann Acked-by: Alexei Starovoitov Signed-off-by: David S. Miller --- arch/x86/net/bpf_jit_comp.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index fe04a04..15f7436 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -1172,6 +1172,8 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog) set_memory_ro((unsigned long)header, header->pages); prog->bpf_func = (void *)image; prog->jited = 1; + } else { + prog = orig_prog; } out_addrs: -- 2.7.4 >>From d8bb61086e84956d2b6bc146471c0c12fe73729a Mon Sep 17 00:00:00 2001 From: Florian Fainelli Date: Sat, 7 Jan 2017 21:01:56 -0800 Subject: [PATCH 26/37] net: dsa: bcm_sf2: Do not clobber b53_switch_ops [ Upstream commit a4c61b92b3a4cbda35bb0251a5063a68f0861b2c ] We make the bcm_sf2 driver override ds->ops which points to b53_switch_ops since b53_switch_alloc() did the assignent. This is all well and good until a second b53 switch comes in, and ends up using the bcm_sf2 operations. Make a proper local copy, substitute the ds->ops pointer and then override the operations. Fixes: f458995b9ad8 ("net: dsa: bcm_sf2: Utilize core B53 driver when possible") Signed-off-by: Florian Fainelli Reviewed-by: Andrew Lunn Signed-off-by: David S. Miller --- drivers/net/dsa/bcm_sf2.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c index 9ec33b5..2f9f910 100644 --- a/drivers/net/dsa/bcm_sf2.c +++ b/drivers/net/dsa/bcm_sf2.c @@ -982,6 +982,7 @@ static int bcm_sf2_sw_probe(struct platform_device *pdev) const char *reg_names[BCM_SF2_REGS_NUM] = BCM_SF2_REGS_NAME; struct device_node *dn = pdev->dev.of_node; struct b53_platform_data *pdata; + struct dsa_switch_ops *ops; struct bcm_sf2_priv *priv; struct b53_device *dev; struct dsa_switch *ds; @@ -995,6 +996,10 @@ static int bcm_sf2_sw_probe(struct platform_device *pdev) if (!priv) return -ENOMEM; + ops = devm_kzalloc(&pdev->dev, sizeof(*ops), GFP_KERNEL); + if (!ops) + return -ENOMEM; + dev = b53_switch_alloc(&pdev->dev, &bcm_sf2_io_ops, priv); if (!dev) return -ENOMEM; @@ -1014,6 +1019,8 @@ static int bcm_sf2_sw_probe(struct platform_device *pdev) ds = dev->ds; /* Override the parts that are non-standard wrt. normal b53 devices */ + memcpy(ops, ds->ops, sizeof(*ops)); + ds->ops = ops; ds->ops->get_tag_protocol = bcm_sf2_sw_get_tag_protocol; ds->ops->setup = bcm_sf2_sw_setup; ds->ops->get_phy_flags = bcm_sf2_sw_get_phy_flags; -- 2.7.4 >>From 9af108aef47c3ba6869a2fdb87bfe910f52c79cd Mon Sep 17 00:00:00 2001 From: Florian Fainelli Date: Sat, 7 Jan 2017 21:01:57 -0800 Subject: [PATCH 27/37] net: dsa: bcm_sf2: Utilize nested MDIO read/write [ Upstream commit 2cfe8f8290bd28cf1ee67db914a6e76cf8e6437b ] We are implementing a MDIO bus which is behind another one, so use the nested version of the accessors to get lockdep annotations correct. Fixes: 461cd1b03e32 ("net: dsa: bcm_sf2: Register our slave MDIO bus") Signed-off-by: Florian Fainelli Reviewed-by: Andrew Lunn Signed-off-by: David S. Miller --- drivers/net/dsa/bcm_sf2.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/drivers/net/dsa/bcm_sf2.c b/drivers/net/dsa/bcm_sf2.c index 2f9f910..2ce7ae9 100644 --- a/drivers/net/dsa/bcm_sf2.c +++ b/drivers/net/dsa/bcm_sf2.c @@ -393,7 +393,7 @@ static int bcm_sf2_sw_mdio_read(struct mii_bus *bus, int addr, int regnum) if (addr == BRCM_PSEUDO_PHY_ADDR && priv->indir_phy_mask & BIT(addr)) return bcm_sf2_sw_indir_rw(priv, 1, addr, regnum, 0); else - return mdiobus_read(priv->master_mii_bus, addr, regnum); + return mdiobus_read_nested(priv->master_mii_bus, addr, regnum); } static int bcm_sf2_sw_mdio_write(struct mii_bus *bus, int addr, int regnum, @@ -407,7 +407,7 @@ static int bcm_sf2_sw_mdio_write(struct mii_bus *bus, int addr, int regnum, if (addr == BRCM_PSEUDO_PHY_ADDR && priv->indir_phy_mask & BIT(addr)) bcm_sf2_sw_indir_rw(priv, 0, addr, regnum, val); else - mdiobus_write(priv->master_mii_bus, addr, regnum, val); + mdiobus_write_nested(priv->master_mii_bus, addr, regnum, val); return 0; } -- 2.7.4 >>From c006857a93c7c5022d3c881c879d93ecd674b9a1 Mon Sep 17 00:00:00 2001 From: hayeswang Date: Tue, 10 Jan 2017 17:04:06 +0800 Subject: [PATCH 28/37] r8152: split rtl8152_suspend function [ Upstream commit 8fb280616878b81c0790a0c33acbeec59c5711f4 ] Split rtl8152_suspend() into rtl8152_system_suspend() and rtl8152_rumtime_suspend(). Signed-off-by: Hayes Wang Signed-off-by: David S. Miller --- drivers/net/usb/r8152.c | 57 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 17 deletions(-) diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c index efb84f0..1d1fc37 100644 --- a/drivers/net/usb/r8152.c +++ b/drivers/net/usb/r8152.c @@ -3576,39 +3576,62 @@ static bool delay_autosuspend(struct r8152 *tp) return false; } -static int rtl8152_suspend(struct usb_interface *intf, pm_message_t message) +static int rtl8152_rumtime_suspend(struct r8152 *tp) { - struct r8152 *tp = usb_get_intfdata(intf); struct net_device *netdev = tp->netdev; int ret = 0; - mutex_lock(&tp->control); - - if (PMSG_IS_AUTO(message)) { - if (netif_running(netdev) && delay_autosuspend(tp)) { + if (netif_running(netdev) && test_bit(WORK_ENABLE, &tp->flags)) { + if (delay_autosuspend(tp)) { ret = -EBUSY; goto out1; } - set_bit(SELECTIVE_SUSPEND, &tp->flags); - } else { - netif_device_detach(netdev); + clear_bit(WORK_ENABLE, &tp->flags); + usb_kill_urb(tp->intr_urb); + napi_disable(&tp->napi); + rtl_stop_rx(tp); + tp->rtl_ops.autosuspend_en(tp, true); + napi_enable(&tp->napi); } + set_bit(SELECTIVE_SUSPEND, &tp->flags); + +out1: + return ret; +} + +static int rtl8152_system_suspend(struct r8152 *tp) +{ + struct net_device *netdev = tp->netdev; + int ret = 0; + + netif_device_detach(netdev); + if (netif_running(netdev) && test_bit(WORK_ENABLE, &tp->flags)) { clear_bit(WORK_ENABLE, &tp->flags); usb_kill_urb(tp->intr_urb); napi_disable(&tp->napi); - if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) { - rtl_stop_rx(tp); - tp->rtl_ops.autosuspend_en(tp, true); - } else { - cancel_delayed_work_sync(&tp->schedule); - tp->rtl_ops.down(tp); - } + cancel_delayed_work_sync(&tp->schedule); + tp->rtl_ops.down(tp); napi_enable(&tp->napi); } -out1: + + return ret; +} + +static int rtl8152_suspend(struct usb_interface *intf, pm_message_t message) +{ + struct r8152 *tp = usb_get_intfdata(intf); + int ret; + + mutex_lock(&tp->control); + + if (PMSG_IS_AUTO(message)) + ret = rtl8152_rumtime_suspend(tp); + else + ret = rtl8152_system_suspend(tp); + mutex_unlock(&tp->control); return ret; -- 2.7.4 >>From 52746c2fe0aee121081e4ce28766cbccb1aaf25a Mon Sep 17 00:00:00 2001 From: hayeswang Date: Tue, 10 Jan 2017 17:04:07 +0800 Subject: [PATCH 29/37] r8152: fix rx issue for runtime suspend [ Upstream commit 75dc692eda114cb234a46cb11893a9c3ea520934 ] Pause the rx and make sure the rx fifo is empty when the autosuspend occurs. If the rx data comes when the driver is canceling the rx urb, the host controller would stop getting the data from the device and continue it after next rx urb is submitted. That is, one continuing data is split into two different urb buffers. That let the driver take the data as a rx descriptor, and unexpected behavior happens. Signed-off-by: Hayes Wang Signed-off-by: David S. Miller --- drivers/net/usb/r8152.c | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c index 1d1fc37..4b5cb16 100644 --- a/drivers/net/usb/r8152.c +++ b/drivers/net/usb/r8152.c @@ -3582,17 +3582,42 @@ static int rtl8152_rumtime_suspend(struct r8152 *tp) int ret = 0; if (netif_running(netdev) && test_bit(WORK_ENABLE, &tp->flags)) { + u32 rcr = 0; + if (delay_autosuspend(tp)) { ret = -EBUSY; goto out1; } + if (netif_carrier_ok(netdev)) { + u32 ocp_data; + + rcr = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR); + ocp_data = rcr & ~RCR_ACPT_ALL; + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data); + rxdy_gated_en(tp, true); + ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, + PLA_OOB_CTRL); + if (!(ocp_data & RXFIFO_EMPTY)) { + rxdy_gated_en(tp, false); + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, rcr); + ret = -EBUSY; + goto out1; + } + } + clear_bit(WORK_ENABLE, &tp->flags); usb_kill_urb(tp->intr_urb); - napi_disable(&tp->napi); - rtl_stop_rx(tp); + tp->rtl_ops.autosuspend_en(tp, true); - napi_enable(&tp->napi); + + if (netif_carrier_ok(netdev)) { + napi_disable(&tp->napi); + rtl_stop_rx(tp); + rxdy_gated_en(tp, false); + ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, rcr); + napi_enable(&tp->napi); + } } set_bit(SELECTIVE_SUSPEND, &tp->flags); -- 2.7.4 >>From 597031f66434870163bcf5fac8c29f6d0db5c06a Mon Sep 17 00:00:00 2001 From: Florian Fainelli Date: Mon, 9 Jan 2017 11:58:34 -0800 Subject: [PATCH 30/37] net: dsa: Ensure validity of dst->ds[0] [ Upstream commit faf3a932fbeb77860226a8323eacb835edc98648 ] It is perfectly possible to have non zero indexed switches being present in a DSA switch tree, in such a case, we will be deferencing a NULL pointer while dsa_cpu_port_ethtool_{setup,restore}. Be more defensive and ensure that dst->ds[0] is valid before doing anything with it. Fixes: 0c73c523cf73 ("net: dsa: Initialize CPU port ethtool ops per tree") Signed-off-by: Florian Fainelli Reviewed-by: Vivien Didelot Signed-off-by: David S. Miller --- net/dsa/dsa2.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/net/dsa/dsa2.c b/net/dsa/dsa2.c index 5fff951..da38621 100644 --- a/net/dsa/dsa2.c +++ b/net/dsa/dsa2.c @@ -394,9 +394,11 @@ static int dsa_dst_apply(struct dsa_switch_tree *dst) return err; } - err = dsa_cpu_port_ethtool_setup(dst->ds[0]); - if (err) - return err; + if (dst->ds[0]) { + err = dsa_cpu_port_ethtool_setup(dst->ds[0]); + if (err) + return err; + } /* If we use a tagging format that doesn't have an ethertype * field, make sure that all packets from this point on get @@ -433,7 +435,8 @@ static void dsa_dst_unapply(struct dsa_switch_tree *dst) dsa_ds_unapply(dst, ds); } - dsa_cpu_port_ethtool_restore(dst->ds[0]); + if (dst->ds[0]) + dsa_cpu_port_ethtool_restore(dst->ds[0]); pr_info("DSA: tree %d unapplied\n", dst->tree); dst->applied = false; -- 2.7.4 >>From ebcb2f33f7258ad041003398b854744371fd61a9 Mon Sep 17 00:00:00 2001 From: "Anna, Suman" Date: Mon, 9 Jan 2017 21:48:56 -0600 Subject: [PATCH 31/37] net: add the AF_QIPCRTR entries to family name tables [ Upstream commit 5d722b3024f6762addb8642ffddc9f275b5107ae ] Commit bdabad3e363d ("net: Add Qualcomm IPC router") introduced a new address family. Update the family name tables accordingly so that the lockdep initialization can use the proper names for this family. Cc: Courtney Cavin Cc: Bjorn Andersson Signed-off-by: Suman Anna Signed-off-by: David S. Miller --- net/core/sock.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/net/core/sock.c b/net/core/sock.c index 00a074d..bc6543f 100644 --- a/net/core/sock.c +++ b/net/core/sock.c @@ -222,7 +222,7 @@ static const char *const af_family_key_strings[AF_MAX+1] = { "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN" , "sk_lock-AF_PHONET" , "sk_lock-AF_IEEE802154", "sk_lock-AF_CAIF" , "sk_lock-AF_ALG" , "sk_lock-AF_NFC" , "sk_lock-AF_VSOCK" , "sk_lock-AF_KCM" , - "sk_lock-AF_MAX" + "sk_lock-AF_QIPCRTR", "sk_lock-AF_MAX" }; static const char *const af_family_slock_key_strings[AF_MAX+1] = { "slock-AF_UNSPEC", "slock-AF_UNIX" , "slock-AF_INET" , @@ -239,7 +239,7 @@ static const char *const af_family_slock_key_strings[AF_MAX+1] = { "slock-AF_RXRPC" , "slock-AF_ISDN" , "slock-AF_PHONET" , "slock-AF_IEEE802154", "slock-AF_CAIF" , "slock-AF_ALG" , "slock-AF_NFC" , "slock-AF_VSOCK" ,"slock-AF_KCM" , - "slock-AF_MAX" + "slock-AF_QIPCRTR", "slock-AF_MAX" }; static const char *const af_family_clock_key_strings[AF_MAX+1] = { "clock-AF_UNSPEC", "clock-AF_UNIX" , "clock-AF_INET" , @@ -256,7 +256,7 @@ static const char *const af_family_clock_key_strings[AF_MAX+1] = { "clock-AF_RXRPC" , "clock-AF_ISDN" , "clock-AF_PHONET" , "clock-AF_IEEE802154", "clock-AF_CAIF" , "clock-AF_ALG" , "clock-AF_NFC" , "clock-AF_VSOCK" , "clock-AF_KCM" , - "clock-AF_MAX" + "clock-AF_QIPCRTR", "clock-AF_MAX" }; /* -- 2.7.4 >>From 232ef16cd693ffd121cb5dba2aef7d66c350779d Mon Sep 17 00:00:00 2001 From: Herbert Xu Date: Tue, 10 Jan 2017 12:24:01 -0800 Subject: [PATCH 32/37] gro: Enter slow-path if there is no tailroom [ Upstream commit 1272ce87fa017ca4cf32920764d879656b7a005a ] The GRO path has a fast-path where we avoid calling pskb_may_pull and pskb_expand by directly accessing frag0. However, this should only be done if we have enough tailroom in the skb as otherwise we'll have to expand it later anyway. This patch adds the check by capping frag0_len with the skb tailroom. Fixes: cb18978cbf45 ("gro: Open-code final pskb_may_pull") Reported-by: Slava Shwartsman Signed-off-by: Herbert Xu Signed-off-by: Eric Dumazet Signed-off-by: David S. Miller --- net/core/dev.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/net/core/dev.c b/net/core/dev.c index 6666b28..7b4fa1e 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -4453,7 +4453,8 @@ static void skb_gro_reset_offset(struct sk_buff *skb) pinfo->nr_frags && !PageHighMem(skb_frag_page(frag0))) { NAPI_GRO_CB(skb)->frag0 = skb_frag_address(frag0); - NAPI_GRO_CB(skb)->frag0_len = skb_frag_size(frag0); + NAPI_GRO_CB(skb)->frag0_len = min(skb_frag_size(frag0), + skb->end - skb->tail); } } -- 2.7.4 >>From d6a3b358455606aa77f865c8ed66a1b4bfeacada Mon Sep 17 00:00:00 2001 From: Eric Dumazet Date: Tue, 10 Jan 2017 19:52:43 -0800 Subject: [PATCH 33/37] gro: use min_t() in skb_gro_reset_offset() [ Upstream commit 7cfd5fd5a9813f1430290d20c0fead9b4582a307 ] On 32bit arches, (skb->end - skb->data) is not 'unsigned int', so we shall use min_t() instead of min() to avoid a compiler error. Fixes: 1272ce87fa01 ("gro: Enter slow-path if there is no tailroom") Reported-by: kernel test robot Signed-off-by: Eric Dumazet Signed-off-by: David S. Miller --- net/core/dev.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/net/core/dev.c b/net/core/dev.c index 7b4fa1e..e1d731f 100644 --- a/net/core/dev.c +++ b/net/core/dev.c @@ -4453,8 +4453,9 @@ static void skb_gro_reset_offset(struct sk_buff *skb) pinfo->nr_frags && !PageHighMem(skb_frag_page(frag0))) { NAPI_GRO_CB(skb)->frag0 = skb_frag_address(frag0); - NAPI_GRO_CB(skb)->frag0_len = min(skb_frag_size(frag0), - skb->end - skb->tail); + NAPI_GRO_CB(skb)->frag0_len = min_t(unsigned int, + skb_frag_size(frag0), + skb->end - skb->tail); } } -- 2.7.4 >>From bfb32bc40b9716b5e7029f72ddab52de04aae347 Mon Sep 17 00:00:00 2001 From: Herbert Xu Date: Tue, 10 Jan 2017 12:24:15 -0800 Subject: [PATCH 34/37] gro: Disable frag0 optimization on IPv6 ext headers [ Upstream commit 57ea52a865144aedbcd619ee0081155e658b6f7d ] The GRO fast path caches the frag0 address. This address becomes invalid if frag0 is modified by pskb_may_pull or its variants. So whenever that happens we must disable the frag0 optimization. This is usually done through the combination of gro_header_hard and gro_header_slow, however, the IPv6 extension header path did the pulling directly and would continue to use the GRO fast path incorrectly. This patch fixes it by disabling the fast path when we enter the IPv6 extension header path. Fixes: 78a478d0efd9 ("gro: Inline skb_gro_header and cache frag0 virtual address") Reported-by: Slava Shwartsman Signed-off-by: Herbert Xu Signed-off-by: Eric Dumazet Signed-off-by: David S. Miller --- include/linux/netdevice.h | 9 +++++++-- net/ipv6/ip6_offload.c | 1 + 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index e16a2a9..d83590e 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -2502,14 +2502,19 @@ static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen) return NAPI_GRO_CB(skb)->frag0_len < hlen; } +static inline void skb_gro_frag0_invalidate(struct sk_buff *skb) +{ + NAPI_GRO_CB(skb)->frag0 = NULL; + NAPI_GRO_CB(skb)->frag0_len = 0; +} + static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen, unsigned int offset) { if (!pskb_may_pull(skb, hlen)) return NULL; - NAPI_GRO_CB(skb)->frag0 = NULL; - NAPI_GRO_CB(skb)->frag0_len = 0; + skb_gro_frag0_invalidate(skb); return skb->data + offset; } diff --git a/net/ipv6/ip6_offload.c b/net/ipv6/ip6_offload.c index 89c59e6..fc7b401 100644 --- a/net/ipv6/ip6_offload.c +++ b/net/ipv6/ip6_offload.c @@ -191,6 +191,7 @@ static struct sk_buff **ipv6_gro_receive(struct sk_buff **head, ops = rcu_dereference(inet6_offloads[proto]); if (!ops || !ops->callbacks.gro_receive) { __pskb_pull(skb, skb_gro_offset(skb)); + skb_gro_frag0_invalidate(skb); proto = ipv6_gso_pull_exthdrs(skb, proto); skb_gro_pull(skb, -skb_transport_offset(skb)); skb_reset_transport_header(skb); -- 2.7.4 >>From 4dc62f9bfa1aab5b763c90a70aa69bb81f226cf0 Mon Sep 17 00:00:00 2001 From: Gil Rockah Date: Tue, 10 Jan 2017 22:33:38 +0200 Subject: [PATCH 35/37] net/mlx5e: Remove WARN_ONCE from adaptive moderation code [ Upstream commit 0bbcc0a8fc394d01988fe0263ccf7fddb77a12c3 ] When trying to do interface down or changing interface configuration under heavy traffic, some of the adaptive moderation corner cases can occur and leave a WARN_ONCE call trace in the kernel log. Those WARN_ONCE are meant for debug only, and should have been inserted only under debug. We avoid such call traces by removing those WARN_ONCE. Fixes: cb3c7fd4f839 ("net/mlx5e: Support adaptive RX coalescing") Signed-off-by: Gil Rockah Signed-off-by: Saeed Mahameed Signed-off-by: David S. Miller --- drivers/net/ethernet/mellanox/mlx5/core/en_rx_am.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx_am.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx_am.c index 1fffe48..cbfac06 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx_am.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx_am.c @@ -109,7 +109,6 @@ static bool mlx5e_am_on_top(struct mlx5e_rx_am *am) switch (am->tune_state) { case MLX5E_AM_PARKING_ON_TOP: case MLX5E_AM_PARKING_TIRED: - WARN_ONCE(true, "mlx5e_am_on_top: PARKING\n"); return true; case MLX5E_AM_GOING_RIGHT: return (am->steps_left > 1) && (am->steps_right == 1); @@ -123,7 +122,6 @@ static void mlx5e_am_turn(struct mlx5e_rx_am *am) switch (am->tune_state) { case MLX5E_AM_PARKING_ON_TOP: case MLX5E_AM_PARKING_TIRED: - WARN_ONCE(true, "mlx5e_am_turn: PARKING\n"); break; case MLX5E_AM_GOING_RIGHT: am->tune_state = MLX5E_AM_GOING_LEFT; @@ -144,7 +142,6 @@ static int mlx5e_am_step(struct mlx5e_rx_am *am) switch (am->tune_state) { case MLX5E_AM_PARKING_ON_TOP: case MLX5E_AM_PARKING_TIRED: - WARN_ONCE(true, "mlx5e_am_step: PARKING\n"); break; case MLX5E_AM_GOING_RIGHT: if (am->profile_ix == (MLX5E_PARAMS_AM_NUM_PROFILES - 1)) @@ -282,10 +279,8 @@ static void mlx5e_am_calc_stats(struct mlx5e_rx_am_sample *start, u32 delta_us = ktime_us_delta(end->time, start->time); unsigned int npkts = end->pkt_ctr - start->pkt_ctr; - if (!delta_us) { - WARN_ONCE(true, "mlx5e_am_calc_stats: delta_us=0\n"); + if (!delta_us) return; - } curr_stats->ppms = (npkts * USEC_PER_MSEC) / delta_us; curr_stats->epms = (MLX5E_AM_NEVENTS * USEC_PER_MSEC) / delta_us; -- 2.7.4 >>From d1b76429e5c66febb75939f050619f82d25b5361 Mon Sep 17 00:00:00 2001 From: David Ahern Date: Tue, 10 Jan 2017 14:37:35 -0800 Subject: [PATCH 36/37] net: ipv4: Fix multipath selection with vrf [ Upstream commit 7a18c5b9fb31a999afc62b0e60978aa896fc89e9 ] fib_select_path does not call fib_select_multipath if oif is set in the flow struct. For VRF use cases oif is always set, so multipath route selection is bypassed. Use the FLOWI_FLAG_SKIP_NH_OIF to skip the oif check similar to what is done in fib_table_lookup. Add saddr and proto to the flow struct for the fib lookup done by the VRF driver to better match hash computation for a flow. Fixes: 613d09b30f8b ("net: Use VRF device index for lookups on TX") Signed-off-by: David Ahern Signed-off-by: David S. Miller --- drivers/net/vrf.c | 2 ++ net/ipv4/fib_semantics.c | 9 +++++++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c index 809a796..12b8085 100644 --- a/drivers/net/vrf.c +++ b/drivers/net/vrf.c @@ -263,7 +263,9 @@ static netdev_tx_t vrf_process_v4_outbound(struct sk_buff *skb, .flowi4_iif = LOOPBACK_IFINDEX, .flowi4_tos = RT_TOS(ip4h->tos), .flowi4_flags = FLOWI_FLAG_ANYSRC | FLOWI_FLAG_SKIP_NH_OIF, + .flowi4_proto = ip4h->protocol, .daddr = ip4h->daddr, + .saddr = ip4h->saddr, }; struct net *net = dev_net(vrf_dev); struct rtable *rt; diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c index 388d3e2..a8508b7 100644 --- a/net/ipv4/fib_semantics.c +++ b/net/ipv4/fib_semantics.c @@ -1617,8 +1617,13 @@ void fib_select_multipath(struct fib_result *res, int hash) void fib_select_path(struct net *net, struct fib_result *res, struct flowi4 *fl4, int mp_hash) { + bool oif_check; + + oif_check = (fl4->flowi4_oif == 0 || + fl4->flowi4_flags & FLOWI_FLAG_SKIP_NH_OIF); + #ifdef CONFIG_IP_ROUTE_MULTIPATH - if (res->fi->fib_nhs > 1 && fl4->flowi4_oif == 0) { + if (res->fi->fib_nhs > 1 && oif_check) { if (mp_hash < 0) mp_hash = get_hash_from_flowi4(fl4) >> 1; @@ -1628,7 +1633,7 @@ void fib_select_path(struct net *net, struct fib_result *res, #endif if (!res->prefixlen && res->table->tb_num_default > 1 && - res->type == RTN_UNICAST && !fl4->flowi4_oif) + res->type == RTN_UNICAST && oif_check) fib_select_default(fl4, res); if (!fl4->saddr) -- 2.7.4 >>From be6eb70b61aa2cbaf772ef53cfe0706ecf904aea Mon Sep 17 00:00:00 2001 From: David Ahern Date: Tue, 10 Jan 2017 15:22:25 -0800 Subject: [PATCH 37/37] net: vrf: do not allow table id 0 [ Upstream commit 24c63bbc18e25d5d8439422aa5fd2d66390b88eb ] Frank reported that vrf devices can be created with a table id of 0. This breaks many of the run time table id checks and should not be allowed. Detect this condition at create time and fail with EINVAL. Fixes: 193125dbd8eb ("net: Introduce VRF device driver") Reported-by: Frank Kellermann Signed-off-by: David Ahern Signed-off-by: David S. Miller --- drivers/net/vrf.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c index 12b8085..95cf1d8 100644 --- a/drivers/net/vrf.c +++ b/drivers/net/vrf.c @@ -1239,6 +1239,8 @@ static int vrf_newlink(struct net *src_net, struct net_device *dev, return -EINVAL; vrf->tb_id = nla_get_u32(data[IFLA_VRF_TABLE]); + if (vrf->tb_id == RT_TABLE_UNSPEC) + return -EINVAL; dev->priv_flags |= IFF_L3MDEV_MASTER; -- 2.7.4 ----Next_Part(Thu_Jan_12_13_55_10_2017_630)----