From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from shards.monkeyblade.net ([23.128.96.9]:52668 "EHLO shards.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726339AbeKBNOd (ORCPT ); Fri, 2 Nov 2018 09:14:33 -0400 Received: from localhost (unknown [IPv6:2601:601:9f80:35cd::cf9]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) (Authenticated sender: davem-davemloft) by shards.monkeyblade.net (Postfix) with ESMTPSA id B40E813E2B9AB for ; Thu, 1 Nov 2018 21:08:51 -0700 (PDT) Date: Thu, 01 Nov 2018 21:08:51 -0700 (PDT) Message-Id: <20181101.210851.1053714430074274962.davem@davemloft.net> To: stable@vger.kernel.org Subject: [PATCHES] Sparc From: David Miller Mime-Version: 1.0 Content-Type: Multipart/Mixed; boundary="--Next_Part(Thu_Nov__1_21_08_51_2018_706)--" Content-Transfer-Encoding: 7bit Sender: stable-owner@vger.kernel.org List-ID: ----Next_Part(Thu_Nov__1_21_08_51_2018_706)-- Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Please queue up the following sparc bug fixes for v4.18 and v4.19 -stable, respectively. Thanks! ----Next_Part(Thu_Nov__1_21_08_51_2018_706)-- Content-Type: Application/Octet-Stream Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="sparc_418.mbox" RnJvbSAyZGRjMzRmYWNjODg2ZTQ2MmMxMjBhZmQwMzY2NzBjZjgyOTZiNmVkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiRGF2aWQgUy4gTWlsbGVyIiA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5l dD4KRGF0ZTogRnJpLCAyNiBPY3QgMjAxOCAxNToxMTo1NiAtMDcwMApTdWJqZWN0OiBbUEFUQ0gg MS84XSBzcGFyYzY0OiBFeHBvcnQgX19ub2RlX2Rpc3RhbmNlLgoKWyBVcHN0cmVhbSBjb21taXQg MmI0NzkyZWFhOWY1NTM3NjQwNDdkMTU3MzY1ZWQ4Yjc3ODc3NTFhMyBdCgpTb21lIGRyaXZlcnMg cmVmZXJlbmNlIGl0IHZpYSBub2RlX2Rpc3RhbmNlKCksIGZvciBleGFtcGxlIHRoZQpOVk1FIGhv c3QgZHJpdmVyIGNvcmUuCgpFUlJPUjogIl9fbm9kZV9kaXN0YW5jZSIgW2RyaXZlcnMvbnZtZS9o b3N0L252bWUtY29yZS5rb10gdW5kZWZpbmVkIQptYWtlWzFdOiAqKiogW3NjcmlwdHMvTWFrZWZp bGUubW9kcG9zdDo5MjogX19tb2Rwb3N0XSBFcnJvciAxCgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBT LiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogYXJjaC9zcGFyYy9tbS9pbml0XzY0 LmMgfCAxICsKIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKQoKZGlmZiAtLWdpdCBhL2Fy Y2gvc3BhcmMvbW0vaW5pdF82NC5jIGIvYXJjaC9zcGFyYy9tbS9pbml0XzY0LmMKaW5kZXggZjM5 NjA0OGEwZDY4Li4zOTgyMmY2MTFjMDEgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvbW0vaW5pdF82 NC5jCisrKyBiL2FyY2gvc3BhcmMvbW0vaW5pdF82NC5jCkBAIC0xMzgzLDYgKzEzODMsNyBAQCBp bnQgX19ub2RlX2Rpc3RhbmNlKGludCBmcm9tLCBpbnQgdG8pCiAJfQogCXJldHVybiBudW1hX2xh dGVuY3lbZnJvbV1bdG9dOwogfQorRVhQT1JUX1NZTUJPTChfX25vZGVfZGlzdGFuY2UpOwogCiBz dGF0aWMgaW50IF9faW5pdCBmaW5kX2Jlc3RfbnVtYV9ub2RlX2Zvcl9tbGdyb3VwKHN0cnVjdCBt ZGVzY19tbGdyb3VwICpncnApCiB7Ci0tIAoyLjE5LjEKCgpGcm9tIDhiMTA0MzQ2MWM1YWNiYWFh ZDJhODQ5NDk5YjgxOGMwNDliYjVhMzYgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206IERh dmlkIE1pbGxlciA8ZGF2ZW1AcmVkaGF0LmNvbT4KRGF0ZTogVGh1LCAyNSBPY3QgMjAxOCAyMDoz Njo0NiAtMDcwMApTdWJqZWN0OiBbUEFUQ0ggMi84XSBzcGFyYzY0OiBNYWtlIGNvcnJ1cHRlZCB1 c2VyIHN0YWNrcyBtb3JlIGRlYnVnZ2FibGUuCgpbIFVwc3RyZWFtIGNvbW1pdCA1YjRmYzM4ODJh NjQ5Yzk0MTFkZDBkY2FkMmRkYjc4ZTkxMWQzNDBlIF0KClJpZ2h0IG5vdyBpZiB3ZSBnZXQgYSBj b3JydXB0ZWQgdXNlciBzdGFjayBmcmFtZSB3ZSBkbyBhCmRvX2V4aXQoU0lHSUxMKSB3aGljaCBp cyBub3QgaGVscGZ1bC4KCklmIHVuZGVyIGEgZGVidWdnZXIsIHRoaXMgYmVoYXZpb3IgY2F1c2Vz IHRoZSBpbmZlcmlvciBwcm9jZXNzIHRvCmV4aXQuICBTbyB0aGUgcmVnaXN0ZXIgYW5kIG90aGVy IHN0YXRlIGNhbm5vdCBiZSBleGFtaW5lZCBhdCB0aGUgdGltZQpvZiB0aGUgZXZlbnQuCgpJbnN0 ZWFkLCBjb25kaXRpb25hbGx5IGxvZyBhIHJhdGUgbGltaXRlZCBrZXJuZWwgbG9nIG1lc3NhZ2Ug YW5kIHRoZW4KZm9yY2UgYSBTSUdTRUdWLgoKV2l0aCBiaXRzIGFuZCBpZGVhcyBib3Jyb3dlZCAo YXMgdXN1YWwpIGZyb20gcG93ZXJwYy4KClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8 ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBhcmNoL3NwYXJjL2luY2x1ZGUvYXNtL3N3aXRjaF90 b182NC5oIHwgIDMgKystCiBhcmNoL3NwYXJjL2tlcm5lbC9wcm9jZXNzXzY0LmMgICAgICAgIHwg MjUgKysrKysrKysrKysrKysrKysrKy0tLS0tLQogYXJjaC9zcGFyYy9rZXJuZWwvcnRyYXBfNjQu UyAgICAgICAgICB8ICAxICsKIGFyY2gvc3BhcmMva2VybmVsL3NpZ25hbDMyLmMgICAgICAgICAg fCAxMiArKysrKysrKysrLS0KIGFyY2gvc3BhcmMva2VybmVsL3NpZ25hbF82NC5jICAgICAgICAg fCAgNiArKysrKy0KIDUgZmlsZXMgY2hhbmdlZCwgMzcgaW5zZXJ0aW9ucygrKSwgMTAgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9zd2l0Y2hfdG9fNjQu aCBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vc3dpdGNoX3RvXzY0LmgKaW5kZXggNGZmMjliMTQw NmE5Li5iMWQ0ZTJlMzIxMGYgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vc3dp dGNoX3RvXzY0LmgKKysrIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9zd2l0Y2hfdG9fNjQuaApA QCAtNjcsNiArNjcsNyBAQCBkbyB7CXNhdmVfYW5kX2NsZWFyX2ZwdSgpOwkJCQkJCVwKIH0gd2hp bGUoMCkKIAogdm9pZCBzeW5jaHJvbml6ZV91c2VyX3N0YWNrKHZvaWQpOwotdm9pZCBmYXVsdF9p bl91c2VyX3dpbmRvd3Modm9pZCk7CitzdHJ1Y3QgcHRfcmVnczsKK3ZvaWQgZmF1bHRfaW5fdXNl cl93aW5kb3dzKHN0cnVjdCBwdF9yZWdzICopOwogCiAjZW5kaWYgLyogX19TUEFSQzY0X1NXSVRD SF9UT182NF9IICovCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9wcm9jZXNzXzY0LmMg Yi9hcmNoL3NwYXJjL2tlcm5lbC9wcm9jZXNzXzY0LmMKaW5kZXggNmMwODYwODZjYThmLi41OWVh ZjYyMjdhZjEgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMva2VybmVsL3Byb2Nlc3NfNjQuYworKysg Yi9hcmNoL3NwYXJjL2tlcm5lbC9wcm9jZXNzXzY0LmMKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNs dWRlIDxsaW51eC9zeXNycS5oPgogI2luY2x1ZGUgPGxpbnV4L25taS5oPgogI2luY2x1ZGUgPGxp bnV4L2NvbnRleHRfdHJhY2tpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC9zaWduYWwuaD4KIAogI2lu Y2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxhc20vcGFnZS5oPgpAQCAtNTIxLDcg KzUyMiwxMiBAQCBzdGF0aWMgdm9pZCBzdGFja191bmFsaWduZWQodW5zaWduZWQgbG9uZyBzcCkK IAlmb3JjZV9zaWdfZmF1bHQoU0lHQlVTLCBCVVNfQURSQUxOLCAodm9pZCBfX3VzZXIgKikgc3As IDAsIGN1cnJlbnQpOwogfQogCi12b2lkIGZhdWx0X2luX3VzZXJfd2luZG93cyh2b2lkKQorc3Rh dGljIGNvbnN0IGNoYXIgdXdmYXVsdDMyW10gPSBLRVJOX0lORk8gXAorCSIlc1slZF06IGJhZCBy ZWdpc3RlciB3aW5kb3cgZmF1bHQ6IFNQICUwOGx4IChvcmlnX3NwICUwOGx4KSBUUEMgJTA4bHgg TzcgJTA4bHhcbiI7CitzdGF0aWMgY29uc3QgY2hhciB1d2ZhdWx0NjRbXSA9IEtFUk5fSU5GTyBc CisJIiVzWyVkXTogYmFkIHJlZ2lzdGVyIHdpbmRvdyBmYXVsdDogU1AgJTAxNmx4IChvcmlnX3Nw ICUwMTZseCkgVFBDICUwOGx4IE83ICUwMTZseFxuIjsKKwordm9pZCBmYXVsdF9pbl91c2VyX3dp bmRvd3Moc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCiB7CiAJc3RydWN0IHRocmVhZF9pbmZvICp0ID0g Y3VycmVudF90aHJlYWRfaW5mbygpOwogCXVuc2lnbmVkIGxvbmcgd2luZG93OwpAQCAtNTM0LDkg KzU0MCw5IEBAIHZvaWQgZmF1bHRfaW5fdXNlcl93aW5kb3dzKHZvaWQpCiAJCWRvIHsKIAkJCXN0 cnVjdCByZWdfd2luZG93ICpyd2luID0gJnQtPnJlZ193aW5kb3dbd2luZG93XTsKIAkJCWludCB3 aW5zaXplID0gc2l6ZW9mKHN0cnVjdCByZWdfd2luZG93KTsKLQkJCXVuc2lnbmVkIGxvbmcgc3A7 CisJCQl1bnNpZ25lZCBsb25nIHNwLCBvcmlnX3NwOwogCi0JCQlzcCA9IHQtPnJ3YnVmX3N0a3B0 cnNbd2luZG93XTsKKwkJCW9yaWdfc3AgPSBzcCA9IHQtPnJ3YnVmX3N0a3B0cnNbd2luZG93XTsK IAogCQkJaWYgKHRlc3RfdGhyZWFkXzY0Yml0X3N0YWNrKHNwKSkKIAkJCQlzcCArPSBTVEFDS19C SUFTOwpAQCAtNTQ3LDggKzU1MywxNiBAQCB2b2lkIGZhdWx0X2luX3VzZXJfd2luZG93cyh2b2lk KQogCQkJCXN0YWNrX3VuYWxpZ25lZChzcCk7CiAKIAkJCWlmICh1bmxpa2VseShjb3B5X3RvX3Vz ZXIoKGNoYXIgX191c2VyICopc3AsCi0JCQkJCQkgIHJ3aW4sIHdpbnNpemUpKSkKKwkJCQkJCSAg cndpbiwgd2luc2l6ZSkpKSB7CisJCQkJaWYgKHNob3dfdW5oYW5kbGVkX3NpZ25hbHMpCisJCQkJ CXByaW50a19yYXRlbGltaXRlZChpc19jb21wYXRfdGFzaygpID8KKwkJCQkJCQkgICB1d2ZhdWx0 MzIgOiB1d2ZhdWx0NjQsCisJCQkJCQkJICAgY3VycmVudC0+Y29tbSwgY3VycmVudC0+cGlkLAor CQkJCQkJCSAgIHNwLCBvcmlnX3NwLAorCQkJCQkJCSAgIHJlZ3MtPnRwYywKKwkJCQkJCQkgICBy ZWdzLT51X3JlZ3NbVVJFR19JN10pOwogCQkJCWdvdG8gYmFyZjsKKwkJCX0KIAkJfSB3aGlsZSAo d2luZG93LS0pOwogCX0KIAlzZXRfdGhyZWFkX3dzYXZlZCgwKTsKQEAgLTU1Niw4ICs1NzAsNyBA QCB2b2lkIGZhdWx0X2luX3VzZXJfd2luZG93cyh2b2lkKQogCiBiYXJmOgogCXNldF90aHJlYWRf d3NhdmVkKHdpbmRvdyArIDEpOwotCXVzZXJfZXhpdCgpOwotCWRvX2V4aXQoU0lHSUxMKTsKKwlm b3JjZV9zaWcoU0lHU0VHViwgY3VycmVudCk7CiB9CiAKIGFzbWxpbmthZ2UgbG9uZyBzcGFyY19k b19mb3JrKHVuc2lnbmVkIGxvbmcgY2xvbmVfZmxhZ3MsCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJj L2tlcm5lbC9ydHJhcF82NC5TIGIvYXJjaC9zcGFyYy9rZXJuZWwvcnRyYXBfNjQuUwppbmRleCBm NjUyODg4NGEyYzguLmUxN2VjZWRhN2RlMCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwv cnRyYXBfNjQuUworKysgYi9hcmNoL3NwYXJjL2tlcm5lbC9ydHJhcF82NC5TCkBAIC0zOSw2ICsz OSw3IEBAIF9faGFuZGxlX3ByZWVtcHRpb246CiAJCSB3cnByCQkJJWcwLCBSVFJBUF9QU1RBVEVf SVJRT0ZGLCAlcHN0YXRlCiAKIF9faGFuZGxlX3VzZXJfd2luZG93czoKKwkJYWRkCQkJJXNwLCBQ VFJFR1NfT0ZGLCAlbzAKIAkJY2FsbAkJCWZhdWx0X2luX3VzZXJfd2luZG93cwogNjYxOgkJIHdy cHIJCQklZzAsIFJUUkFQX1BTVEFURSwgJXBzdGF0ZQogCQkvKiBJZiB1c2Vyc3BhY2UgaXMgdXNp bmcgQURJLCBpdCBjb3VsZCBwb3RlbnRpYWxseSBwYXNzCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJj L2tlcm5lbC9zaWduYWwzMi5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvc2lnbmFsMzIuYwppbmRleCA0 NGQzNzlkYjNmNjQuLjRjNWIzZmNiZWQ5NCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwv c2lnbmFsMzIuYworKysgYi9hcmNoL3NwYXJjL2tlcm5lbC9zaWduYWwzMi5jCkBAIC0zNzEsNyAr MzcxLDExIEBAIHN0YXRpYyBpbnQgc2V0dXBfZnJhbWUzMihzdHJ1Y3Qga3NpZ25hbCAqa3NpZywg c3RydWN0IHB0X3JlZ3MgKnJlZ3MsCiAJCWdldF9zaWdmcmFtZShrc2lnLCByZWdzLCBzaWdmcmFt ZV9zaXplKTsKIAkKIAlpZiAoaW52YWxpZF9mcmFtZV9wb2ludGVyKHNmLCBzaWdmcmFtZV9zaXpl KSkgewotCQlkb19leGl0KFNJR0lMTCk7CisJCWlmIChzaG93X3VuaGFuZGxlZF9zaWduYWxzKQor CQkJcHJfaW5mbygiJXNbJWRdIGJhZCBmcmFtZSBpbiBzZXR1cF9mcmFtZTMyOiAlMDhseCBUUEMg JTA4bHggTzcgJTA4bHhcbiIsCisJCQkJY3VycmVudC0+Y29tbSwgY3VycmVudC0+cGlkLCAodW5z aWduZWQgbG9uZylzZiwKKwkJCQlyZWdzLT50cGMsIHJlZ3MtPnVfcmVnc1tVUkVHX0k3XSk7CisJ CWZvcmNlX3NpZ3NlZ3Yoa3NpZy0+c2lnLCBjdXJyZW50KTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJ fQogCkBAIC01MDEsNyArNTA1LDExIEBAIHN0YXRpYyBpbnQgc2V0dXBfcnRfZnJhbWUzMihzdHJ1 Y3Qga3NpZ25hbCAqa3NpZywgc3RydWN0IHB0X3JlZ3MgKnJlZ3MsCiAJCWdldF9zaWdmcmFtZShr c2lnLCByZWdzLCBzaWdmcmFtZV9zaXplKTsKIAkKIAlpZiAoaW52YWxpZF9mcmFtZV9wb2ludGVy KHNmLCBzaWdmcmFtZV9zaXplKSkgewotCQlkb19leGl0KFNJR0lMTCk7CisJCWlmIChzaG93X3Vu aGFuZGxlZF9zaWduYWxzKQorCQkJcHJfaW5mbygiJXNbJWRdIGJhZCBmcmFtZSBpbiBzZXR1cF9y dF9mcmFtZTMyOiAlMDhseCBUUEMgJTA4bHggTzcgJTA4bHhcbiIsCisJCQkJY3VycmVudC0+Y29t bSwgY3VycmVudC0+cGlkLCAodW5zaWduZWQgbG9uZylzZiwKKwkJCQlyZWdzLT50cGMsIHJlZ3Mt PnVfcmVnc1tVUkVHX0k3XSk7CisJCWZvcmNlX3NpZ3NlZ3Yoa3NpZy0+c2lnLCBjdXJyZW50KTsK IAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9z aWduYWxfNjQuYyBiL2FyY2gvc3BhcmMva2VybmVsL3NpZ25hbF82NC5jCmluZGV4IDQ4MzY2ZTVl YjViMi4uZTlkZTE4MDNhMjJlIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2tlcm5lbC9zaWduYWxf NjQuYworKysgYi9hcmNoL3NwYXJjL2tlcm5lbC9zaWduYWxfNjQuYwpAQCAtMzcwLDcgKzM3MCwx MSBAQCBzZXR1cF9ydF9mcmFtZShzdHJ1Y3Qga3NpZ25hbCAqa3NpZywgc3RydWN0IHB0X3JlZ3Mg KnJlZ3MpCiAJCWdldF9zaWdmcmFtZShrc2lnLCByZWdzLCBzZl9zaXplKTsKIAogCWlmIChpbnZh bGlkX2ZyYW1lX3BvaW50ZXIgKHNmKSkgewotCQlkb19leGl0KFNJR0lMTCk7CS8qIHdvbid0IHJl dHVybiwgYWN0dWFsbHkgKi8KKwkJaWYgKHNob3dfdW5oYW5kbGVkX3NpZ25hbHMpCisJCQlwcl9p bmZvKCIlc1slZF0gYmFkIGZyYW1lIGluIHNldHVwX3J0X2ZyYW1lOiAlMDE2bHggVFBDICUwMTZs eCBPNyAlMDE2bHhcbiIsCisJCQkJY3VycmVudC0+Y29tbSwgY3VycmVudC0+cGlkLCAodW5zaWdu ZWQgbG9uZylzZiwKKwkJCQlyZWdzLT50cGMsIHJlZ3MtPnVfcmVnc1tVUkVHX0k3XSk7CisJCWZv cmNlX3NpZ3NlZ3Yoa3NpZy0+c2lnLCBjdXJyZW50KTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQog Ci0tIAoyLjE5LjEKCgpGcm9tIGY3NzI4N2I3NjVhOTYxNTVhNGY5ODU0ZTEyMTVmZWJiMzQ5ZjVl NjggTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206ICJEYXZpZCBTLiBNaWxsZXIiIDxkYXZl bUBkYXZlbWxvZnQubmV0PgpEYXRlOiBTdW4sIDE0IE9jdCAyMDE4IDIwOjE5OjMxIC0wNzAwClN1 YmplY3Q6IFtQQVRDSCAzLzhdIHNwYXJjNjQ6IE1ha2UgcHJvY19pZCBzaWduZWQuCgpbIFVwc3Ry ZWFtIGNvbW1pdCBiM2UxZWI4ZTdhYzlhYWEyODM5ODk0OTY2NTFkOTkyNjdjNGNhZDZjIF0KClNv IHRoYXQgd2hlbiBpdCBpcyB1bnNldCwgaWUuICctMScsIHVzZXJzcGFjZSBjYW4gc2VlIGl0CnBy b3Blcmx5LgoKU2lnbmVkLW9mZi1ieTogRGF2aWQgUy4gTWlsbGVyIDxkYXZlbUBkYXZlbWxvZnQu bmV0PgotLS0KIGFyY2gvc3BhcmMvaW5jbHVkZS9hc20vY3B1ZGF0YV82NC5oIHwgMiArLQogMSBm aWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEv YXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9jcHVkYXRhXzY0LmggYi9hcmNoL3NwYXJjL2luY2x1ZGUv YXNtL2NwdWRhdGFfNjQuaAppbmRleCA2NjZkNmI1YzA0NDAuLjljM2ZjMDNhYmU5YSAxMDA2NDQK LS0tIGEvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9jcHVkYXRhXzY0LmgKKysrIGIvYXJjaC9zcGFy Yy9pbmNsdWRlL2FzbS9jcHVkYXRhXzY0LmgKQEAgLTI4LDcgKzI4LDcgQEAgdHlwZWRlZiBzdHJ1 Y3QgewogCXVuc2lnbmVkIHNob3J0CXNvY2tfaWQ7CS8qIHBoeXNpY2FsIHBhY2thZ2UgKi8KIAl1 bnNpZ25lZCBzaG9ydAljb3JlX2lkOwogCXVuc2lnbmVkIHNob3J0ICBtYXhfY2FjaGVfaWQ7CS8q IGdyb3VwaW5ncyBvZiBoaWdoZXN0IHNoYXJlZCBjYWNoZSAqLwotCXVuc2lnbmVkIHNob3J0CXBy b2NfaWQ7CS8qIHN0cmFuZCAoYWthIEhXIHRocmVhZCkgaWQgKi8KKwlzaWduZWQgc2hvcnQJcHJv Y19pZDsJLyogc3RyYW5kIChha2EgSFcgdGhyZWFkKSBpZCAqLwogfSBjcHVpbmZvX3NwYXJjOwog CiBERUNMQVJFX1BFUl9DUFUoY3B1aW5mb19zcGFyYywgX19jcHVfZGF0YSk7Ci0tIAoyLjE5LjEK CgpGcm9tIGRmNWEwNzcxZjJlNTM0NTljZjBhZGM5MGU2MTRmNTkyMTBhZGNkMjUgTW9uIFNlcCAx NyAwMDowMDowMCAyMDAxCkZyb206ICJEYXZpZCBTLiBNaWxsZXIiIDxkYXZlbUBkYXZlbWxvZnQu bmV0PgpEYXRlOiBTdW4sIDE0IE9jdCAyMDE4IDIwOjIyOjI4IC0wNzAwClN1YmplY3Q6IFtQQVRD SCA0LzhdIHNwYXJjNjQ6IFNldCAlbDQgcHJvcGVybHkgb24gdHJhcCByZXR1cm4gYWZ0ZXIgaGFu ZGxpbmcKIHNpZ25hbHMuCgpbIFVwc3RyZWFtIGNvbW1pdCBkMWYxZjk4YzZkMTcwOGE5MDQzNmUx YTNiMmFmZjVlOTM5NDY3MzFiIF0KCklmIHdlIGRpZCBzb21lIHNpZ25hbCBwcm9jZXNzaW5nLCB3 ZSBoYXZlIHRvIHJlbG9hZCB0aGUgcHRfcmVncwp0c3RhdGUgcmVnaXN0ZXIgYmVjYXVzZSBpdCdz IHZhbHVlIG1heSBoYXZlIGNoYW5nZWQuCgpJbiBkb2luZyBzbyB3ZSBhbHNvIGhhdmUgdG8gZXh0 cmFjdCB0aGUgJXBpbCB2YWx1ZSBjb250YWluZWQgaW4gdGhlcmUKYW5yZSBsb2FkIHRoYXQgaW50 byAlbDQuCgpUaGlzIHZhbHVlIGlzIGF0IGJpdCAyMCBhbmQgdGh1cyBuZWVkcyB0byBiZSBzaGlm dGVkIGRvd24gYmVmb3JlIHdlCmxhdGVyIHdyaXRlIGl0IGludG8gdGhlICVwaWwgcmVnaXN0ZXIu CgpNb3N0IG9mIHRoZSB0aW1lIHRoaXMgaXMgaGFybWxlc3MgYXMgd2UgYXJlIHJldHVybmluZyB0 byB1c2Vyc3BhY2UKYW5kIHRoZSAlcGlsIGlzIHplcm8gZm9yIHRoYXQgY2FzZS4KClNpZ25lZC1v ZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBhcmNoL3Nw YXJjL2tlcm5lbC9ydHJhcF82NC5TIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlv bnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2tlcm5lbC9ydHJh cF82NC5TIGIvYXJjaC9zcGFyYy9rZXJuZWwvcnRyYXBfNjQuUwppbmRleCBlMTdlY2VkYTdkZTAu LjI5YWEzNGYxMTcyMCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9rZXJuZWwvcnRyYXBfNjQuUwor KysgYi9hcmNoL3NwYXJjL2tlcm5lbC9ydHJhcF82NC5TCkBAIC04NSw4ICs4NSw5IEBAIF9faGFu ZGxlX3NpZ25hbDoKIAkJbGR4CQkJWyVzcCArIFBUUkVHU19PRkYgKyBQVF9WOV9UU1RBVEVdLCAl bDEKIAkJc2V0aGkJCQklaGkoMHhmIDw8IDIwKSwgJWw0CiAJCWFuZAkJCSVsMSwgJWw0LCAlbDQK KwkJYW5kbgkJCSVsMSwgJWw0LCAlbDEKIAkJYmEscHQJCQkleGNjLCBfX2hhbmRsZV9wcmVlbXB0 aW9uX2NvbnRpbnVlCi0JCSBhbmRuCQkJJWwxLCAlbDQsICVsMQorCQkgc3JsCQkJJWw0LCAyMCwg JWw0CiAKIAkJLyogV2hlbiByZXR1cm5pbmcgZnJvbSBhIE5NSSAoJXBpbD09MTUpIGludGVycnVw dCB3ZSB3YW50IHRvCiAJCSAqIGF2b2lkIHJ1bm5pbmcgc29mdGlycXMsIGRvaW5nIElSUSB0cmFj aW5nLCBwcmVlbXB0aW5nLCBldGMuCi0tIAoyLjE5LjEKCgpGcm9tIGEzODU4ZWIzN2I4MDdmODE4 MWNlZjAwZGQ5NWQ1OTNmYWQ0YTAwN2MgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZyb206ICJE YXZpZCBTLiBNaWxsZXIiIDxkYXZlbUBkYXZlbWxvZnQubmV0PgpEYXRlOiBXZWQsIDMxIE9jdCAy MDE4IDE4OjMwOjIxIC0wNzAwClN1YmplY3Q6IFtQQVRDSCA1LzhdIHNwYXJjNjQ6IFdpcmUgdXAg Y29tcGF0IGdldHBlZXJuYW1lIGFuZCBnZXRzb2NrbmFtZS4KClsgVXBzdHJlYW0gY29tbWl0IDFm MmI1YjhlMmRmNDU5MWZiY2E0MzBhZmY5YzVhMDcyZGNjMGY0MDggXQoKRml4ZXM6IDhiMzBjYTcz YjdjYyAoInNwYXJjOiBBZGQgYWxsIG5lY2Vzc2FyeSBkaXJlY3Qgc29ja2V0IHN5c3RlbSBjYWxs cy4iKQpSZXBvcnRlZC1ieTogSm9zZXBoIE15ZXJzICA8am9zZXBoQGNvZGVzb3VyY2VyeS5jb20+ ClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0t CiBhcmNoL3NwYXJjL2tlcm5lbC9zeXN0YmxzXzY0LlMgfCA0ICsrLS0KIDEgZmlsZSBjaGFuZ2Vk LCAyIGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFy Yy9rZXJuZWwvc3lzdGJsc182NC5TIGIvYXJjaC9zcGFyYy9rZXJuZWwvc3lzdGJsc182NC5TCmlu ZGV4IDM4N2VmOTkzODgwYS4uMjU2OTk0NjJhZDViIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2tl cm5lbC9zeXN0YmxzXzY0LlMKKysrIGIvYXJjaC9zcGFyYy9rZXJuZWwvc3lzdGJsc182NC5TCkBA IC00Nyw5ICs0Nyw5IEBAIHN5c19jYWxsX3RhYmxlMzI6CiAJLndvcmQgc3lzX3JlY3Zmcm9tLCBz eXNfc2V0cmV1aWQxNiwgc3lzX3NldHJlZ2lkMTYsIHN5c19yZW5hbWUsIGNvbXBhdF9zeXNfdHJ1 bmNhdGUKIC8qMTMwKi8JLndvcmQgY29tcGF0X3N5c19mdHJ1bmNhdGUsIHN5c19mbG9jaywgY29t cGF0X3N5c19sc3RhdDY0LCBzeXNfc2VuZHRvLCBzeXNfc2h1dGRvd24KIAkud29yZCBzeXNfc29j a2V0cGFpciwgc3lzX21rZGlyLCBzeXNfcm1kaXIsIGNvbXBhdF9zeXNfdXRpbWVzLCBjb21wYXRf c3lzX3N0YXQ2NAotLyoxNDAqLwkud29yZCBzeXNfc2VuZGZpbGU2NCwgc3lzX25pc19zeXNjYWxs LCBjb21wYXRfc3lzX2Z1dGV4LCBzeXNfZ2V0dGlkLCBjb21wYXRfc3lzX2dldHJsaW1pdAorLyox NDAqLwkud29yZCBzeXNfc2VuZGZpbGU2NCwgc3lzX2dldHBlZXJuYW1lLCBjb21wYXRfc3lzX2Z1 dGV4LCBzeXNfZ2V0dGlkLCBjb21wYXRfc3lzX2dldHJsaW1pdAogCS53b3JkIGNvbXBhdF9zeXNf c2V0cmxpbWl0LCBzeXNfcGl2b3Rfcm9vdCwgc3lzX3ByY3RsLCBzeXNfcGNpY29uZmlnX3JlYWQs IHN5c19wY2ljb25maWdfd3JpdGUKLS8qMTUwKi8JLndvcmQgc3lzX25pc19zeXNjYWxsLCBzeXNf aW5vdGlmeV9pbml0LCBzeXNfaW5vdGlmeV9hZGRfd2F0Y2gsIHN5c19wb2xsLCBzeXNfZ2V0ZGVu dHM2NAorLyoxNTAqLwkud29yZCBzeXNfZ2V0c29ja25hbWUsIHN5c19pbm90aWZ5X2luaXQsIHN5 c19pbm90aWZ5X2FkZF93YXRjaCwgc3lzX3BvbGwsIHN5c19nZXRkZW50czY0CiAJLndvcmQgY29t cGF0X3N5c19mY250bDY0LCBzeXNfaW5vdGlmeV9ybV93YXRjaCwgY29tcGF0X3N5c19zdGF0ZnMs IGNvbXBhdF9zeXNfZnN0YXRmcywgc3lzX29sZHVtb3VudAogLyoxNjAqLwkud29yZCBjb21wYXRf c3lzX3NjaGVkX3NldGFmZmluaXR5LCBjb21wYXRfc3lzX3NjaGVkX2dldGFmZmluaXR5LCBzeXNf Z2V0ZG9tYWlubmFtZSwgc3lzX3NldGRvbWFpbm5hbWUsIHN5c19uaXNfc3lzY2FsbAogCS53b3Jk IHN5c19xdW90YWN0bCwgc3lzX3NldF90aWRfYWRkcmVzcywgY29tcGF0X3N5c19tb3VudCwgY29t cGF0X3N5c191c3RhdCwgc3lzX3NldHhhdHRyCi0tIAoyLjE5LjEKCgpGcm9tIDgzYmVjMTljOTI5 YmYzMjMwNGM5NTliMTczZTg0YWMxYTI4NDUyMGQgTW9uIFNlcCAxNyAwMDowMDowMCAyMDAxCkZy b206ICJEYXZpZCBTLiBNaWxsZXIiIDxkYXZlbUBkYXZlbWxvZnQubmV0PgpEYXRlOiBGcmksIDEy IE9jdCAyMDE4IDEwOjMxOjU4IC0wNzAwClN1YmplY3Q6IFtQQVRDSCA2LzhdIHNwYXJjOiBGaXgg c2luZ2xlLXBjciBwZXJmIGV2ZW50IGNvdW50ZXIgbWFuYWdlbWVudC4KClsgVXBzdHJlYW0gY29t bWl0IGNmZGMzMTcwZDIxNDA0NmI5NTA5MTgzZmU5Yjk1NDRkYzY0NGQ0MGIgXQoKSXQgaXMgaW1w b3J0YW50IHRvIGNsZWFyIHRoZSBody0+c3RhdGUgdmFsdWUgZm9yIG5vbi1zdG9wcGVkIGV2ZW50 cwp3aGVuIHRoZXkgYXJlIGFkZGVkIGludG8gdGhlIFBNVS4gIE90aGVyd2lzZSB3aGVuIHRoZSBl dmVudCBpcwpzY2hlZHVsZWQgb3V0LCB3ZSB3b24ndCByZWFkIHRoZSBjb3VudGVyIGJlY2F1c2Ug SEVTX1VQVE9EQVRFIGlzIHN0aWxsCnNldC4gIFRoaXMgYnJlYWtzICdwZXJmIHN0YXQnIGFuZCBz aW1pbGFyIHVzZSBjYXNlcywgY2F1c2luZyBhbGwgdGhlCmV2ZW50cyB0byBzaG93IHplcm8uCgpU aGlzIHdvcmtlZCBmb3IgbXVsdGktcGNyIGJlY2F1c2Ugd2UgbWFrZSBleHBsaWNpdCBzcGFyY19w bXVfc3RhcnQoKQpjYWxscyBpbiBjYWxjdWxhdGVfbXVsdGlwbGVfcGNycygpLiAgY2FsY3VsYXRl X3NpbmdsZV9wY3IoKSBkb2Vzbid0IGRvCnRoaXMgYmVjYXVzZSB0aGUgaWRlYSB0aGVyZSBpcyB0 byBhY2N1bXVsYXRlIGFsbCBvZiB0aGUgY291bnRlcgpzZXR0aW5ncyBpbnRvIHRoZSBzaW5nbGUg cGNyIHZhbHVlLiAgU28gd2UgaGF2ZSB0byBhZGQgZXhwbGljaXQKaHctPnN0YXRlIGhhbmRsaW5n IHRoZXJlLgoKTGlrZSB4ODYsIHdlIHVzZSB0aGUgUEVSRl9IRVNfQVJDSCBiaXQgdG8gdHJhY2sg dHJ1bHkgc3RvcHBlZCBldmVudHMKc28gdGhhdCB3ZSBkb24ndCBhY2NpZGVudGx5IHN0YXJ0IHRo ZW0gb24gYSByZWxvYWQuCgpSZWxhdGVkIHRvIGFsbCBvZiB0aGlzLCBzcGFyY19wbXVfc3RhcnQo KSBpcyBtaXNzaW5nIGEgdXNlcnBhZ2UgdXBkYXRlCnNvIGFkZCBpdC4KClNpZ25lZC1vZmYtYnk6 IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBhcmNoL3NwYXJjL2tl cm5lbC9wZXJmX2V2ZW50LmMgfCAxNyArKysrKysrKysrKysrLS0tLQogMSBmaWxlIGNoYW5nZWQs IDEzIGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFy Yy9rZXJuZWwvcGVyZl9ldmVudC5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvcGVyZl9ldmVudC5jCmlu ZGV4IGQzMTQ5YmFhYTMzYy4uYTRjYzI2YmQ4OWEyIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2tl cm5lbC9wZXJmX2V2ZW50LmMKKysrIGIvYXJjaC9zcGFyYy9rZXJuZWwvcGVyZl9ldmVudC5jCkBA IC05MjcsNiArOTI3LDggQEAgc3RhdGljIHZvaWQgcmVhZF9pbl9hbGxfY291bnRlcnMoc3RydWN0 IGNwdV9od19ldmVudHMgKmNwdWMpCiAJCQlzcGFyY19wZXJmX2V2ZW50X3VwZGF0ZShjcCwgJmNw LT5odywKIAkJCQkJCWNwdWMtPmN1cnJlbnRfaWR4W2ldKTsKIAkJCWNwdWMtPmN1cnJlbnRfaWR4 W2ldID0gUElDX05PX0lOREVYOworCQkJaWYgKGNwLT5ody5zdGF0ZSAmIFBFUkZfSEVTX1NUT1BQ RUQpCisJCQkJY3AtPmh3LnN0YXRlIHw9IFBFUkZfSEVTX0FSQ0g7CiAJCX0KIAl9CiB9CkBAIC05 NTksMTAgKzk2MSwxMiBAQCBzdGF0aWMgdm9pZCBjYWxjdWxhdGVfc2luZ2xlX3BjcihzdHJ1Y3Qg Y3B1X2h3X2V2ZW50cyAqY3B1YykKIAogCQllbmMgPSBwZXJmX2V2ZW50X2dldF9lbmMoY3B1Yy0+ ZXZlbnRzW2ldKTsKIAkJY3B1Yy0+cGNyWzBdICY9IH5tYXNrX2Zvcl9pbmRleChpZHgpOwotCQlp ZiAoaHdjLT5zdGF0ZSAmIFBFUkZfSEVTX1NUT1BQRUQpCisJCWlmIChod2MtPnN0YXRlICYgUEVS Rl9IRVNfQVJDSCkgewogCQkJY3B1Yy0+cGNyWzBdIHw9IG5vcF9mb3JfaW5kZXgoaWR4KTsKLQkJ ZWxzZQorCQl9IGVsc2UgewogCQkJY3B1Yy0+cGNyWzBdIHw9IGV2ZW50X2VuY29kaW5nKGVuYywg aWR4KTsKKwkJCWh3Yy0+c3RhdGUgPSAwOworCQl9CiAJfQogb3V0OgogCWNwdWMtPnBjclswXSB8 PSBjcHVjLT5ldmVudFswXS0+aHcuY29uZmlnX2Jhc2U7CkBAIC05ODgsNiArOTkyLDkgQEAgc3Rh dGljIHZvaWQgY2FsY3VsYXRlX211bHRpcGxlX3BjcnMoc3RydWN0IGNwdV9od19ldmVudHMgKmNw dWMpCiAKIAkJY3B1Yy0+Y3VycmVudF9pZHhbaV0gPSBpZHg7CiAKKwkJaWYgKGNwLT5ody5zdGF0 ZSAmIFBFUkZfSEVTX0FSQ0gpCisJCQljb250aW51ZTsKKwogCQlzcGFyY19wbXVfc3RhcnQoY3As IFBFUkZfRUZfUkVMT0FEKTsKIAl9CiBvdXQ6CkBAIC0xMDc5LDYgKzEwODYsOCBAQCBzdGF0aWMg dm9pZCBzcGFyY19wbXVfc3RhcnQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgZmxhZ3Mp CiAJZXZlbnQtPmh3LnN0YXRlID0gMDsKIAogCXNwYXJjX3BtdV9lbmFibGVfZXZlbnQoY3B1Yywg JmV2ZW50LT5odywgaWR4KTsKKworCXBlcmZfZXZlbnRfdXBkYXRlX3VzZXJwYWdlKGV2ZW50KTsK IH0KIAogc3RhdGljIHZvaWQgc3BhcmNfcG11X3N0b3Aoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50 LCBpbnQgZmxhZ3MpCkBAIC0xMzcxLDkgKzEzODAsOSBAQCBzdGF0aWMgaW50IHNwYXJjX3BtdV9h ZGQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgZWZfZmxhZ3MpCiAJY3B1Yy0+ZXZlbnRz W24wXSA9IGV2ZW50LT5ody5ldmVudF9iYXNlOwogCWNwdWMtPmN1cnJlbnRfaWR4W24wXSA9IFBJ Q19OT19JTkRFWDsKIAotCWV2ZW50LT5ody5zdGF0ZSA9IFBFUkZfSEVTX1VQVE9EQVRFOworCWV2 ZW50LT5ody5zdGF0ZSA9IFBFUkZfSEVTX1VQVE9EQVRFIHwgUEVSRl9IRVNfU1RPUFBFRDsKIAlp ZiAoIShlZl9mbGFncyAmIFBFUkZfRUZfU1RBUlQpKQotCQlldmVudC0+aHcuc3RhdGUgfD0gUEVS Rl9IRVNfU1RPUFBFRDsKKwkJZXZlbnQtPmh3LnN0YXRlIHw9IFBFUkZfSEVTX0FSQ0g7CiAKIAkv KgogCSAqIElmIGdyb3VwIGV2ZW50cyBzY2hlZHVsaW5nIHRyYW5zYWN0aW9uIHdhcyBzdGFydGVk LAotLSAKMi4xOS4xCgoKRnJvbSBkMjUyMGNkZmFlNDQ5MTViOTU4MmE3ZTY1Y2EzMDI1MDJjOThi NGIzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiRGF2aWQgUy4gTWlsbGVyIiA8ZGF2 ZW1AZGF2ZW1sb2Z0Lm5ldD4KRGF0ZTogV2VkLCAxNyBPY3QgMjAxOCAyMToyODowMSAtMDcwMApT dWJqZWN0OiBbUEFUQ0ggNy84XSBzcGFyYzogRml4IHN5c2NhbGwgZmFsbGJhY2sgYnVncyBpbiBW RFNPLgoKWyBVcHN0cmVhbSBjb21taXQgNzc2Y2ExNTQzYjVmZTY3M2FhZjFiZWIyNDRmY2MyNDI5 ZDM3ODA4MyBdCgpGaXJzdCwgdGhlIHRyYXAgbnVtYmVyIGZvciAzMi1iaXQgc3lzY2FsbHMgaXMg MHgxMC4KCkFsc28sIG9ubHkgbmVnYXRlIHRoZSByZXR1cm4gdmFsdWUgd2hlbiBzeXNjYWxsIGVy cm9yIGlzIGluZGljYXRlZCBieQp0aGUgY2FycnkgYml0IGJlaW5nIHNldC4KClNpZ25lZC1vZmYt Ynk6IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBhcmNoL3NwYXJj L3Zkc28vdmNsb2NrX2dldHRpbWUuYyB8IDEyICsrKysrKysrKysrLQogdG9vbHMvcGVyZi91dGls L2V2ZW50LmMgICAgICAgICAgfCAgNSArKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAxNiBpbnNlcnRp b25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy92ZHNvL3ZjbG9j a19nZXR0aW1lLmMgYi9hcmNoL3NwYXJjL3Zkc28vdmNsb2NrX2dldHRpbWUuYwppbmRleCAzZmVi M2Q5NjBjYTUuLjc1ZGNhOWFhYjczNyAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy92ZHNvL3ZjbG9j a19nZXR0aW1lLmMKKysrIGIvYXJjaC9zcGFyYy92ZHNvL3ZjbG9ja19nZXR0aW1lLmMKQEAgLTMz LDkgKzMzLDE5IEBACiAjZGVmaW5lCVRJQ0tfUFJJVl9CSVQJKDFVTEwgPDwgNjMpCiAjZW5kaWYK IAorI2lmZGVmCUNPTkZJR19TUEFSQzY0CiAjZGVmaW5lIFNZU0NBTExfU1RSSU5HCQkJCQkJCVwK IAkidGEJMHg2ZDsiCQkJCQkJCVwKLQkic3ViCSUlZzAsICUlbzAsICUlbzA7IgkJCQkJXAorCSJi Y3MsYQkxZjsiCQkJCQkJCVwKKwkiIHN1YgklJWcwLCAlJW8wLCAlJW8wOyIJCQkJCVwKKwkiMToi CisjZWxzZQorI2RlZmluZSBTWVNDQUxMX1NUUklORwkJCQkJCQlcCisJInRhCTB4MTA7IgkJCQkJ CQlcCisJImJjcyxhCTFmOyIJCQkJCQkJXAorCSIgc3ViCSUlZzAsICUlbzAsICUlbzA7IgkJCQkJ XAorCSIxOiIKKyNlbmRpZgogCiAjZGVmaW5lIFNZU0NBTExfQ0xPQkJFUlMJCQkJCQlcCiAJImYw IiwgImYxIiwgImYyIiwgImYzIiwgImY0IiwgImY1IiwgImY2IiwgImY3IiwJCQlcCkZyb20gMDE2 NmRkNmQ3YmZjMWNhNzBmNDg0NjI4MTYxOTcwYTI0ODgzMGQxYSBNb24gU2VwIDE3IDAwOjAwOjAw IDIwMDEKRnJvbTogIkRhdmlkIFMuIE1pbGxlciIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+CkRhdGU6 IEZyaSwgMTIgT2N0IDIwMTggMTA6MzM6MjAgLTA3MDAKU3ViamVjdDogW1BBVENIIDgvOF0gc3Bh cmM6IFRocm90dGxlIHBlcmYgZXZlbnRzIHByb3Blcmx5LgoKWyBVcHN0cmVhbSBjb21taXQgNDU1 YWRiMzE3NGQyYzg1MThjZWYxYTYxMTQwYzIxMWY2YWMyMjRkMiBdCgpMaWtlIHg4NiBhbmQgYXJt LCBjYWxsIHBlcmZfc2FtcGxlX2V2ZW50X3Rvb2soKSBpbiBwZXJmIGV2ZW50Ck5NSSBpbnRlcnJ1 cHQgaGFuZGxlci4KClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1s b2Z0Lm5ldD4KLS0tCiBhcmNoL3NwYXJjL2tlcm5lbC9wZXJmX2V2ZW50LmMgfCA5ICsrKysrKysr KwogMSBmaWxlIGNoYW5nZWQsIDkgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2FyY2gvc3Bh cmMva2VybmVsL3BlcmZfZXZlbnQuYyBiL2FyY2gvc3BhcmMva2VybmVsL3BlcmZfZXZlbnQuYwpp bmRleCBhNGNjMjZiZDg5YTIuLjY3YjNlNmIzY2U1ZCAxMDA2NDQKLS0tIGEvYXJjaC9zcGFyYy9r ZXJuZWwvcGVyZl9ldmVudC5jCisrKyBiL2FyY2gvc3BhcmMva2VybmVsL3BlcmZfZXZlbnQuYwpA QCAtMjQsNiArMjQsNyBAQAogI2luY2x1ZGUgPGFzbS9jcHVkYXRhLmg+CiAjaW5jbHVkZSA8bGlu dXgvdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGxpbnV4L2F0b21pYy5oPgorI2luY2x1ZGUgPGxpbnV4 L3NjaGVkL2Nsb2NrLmg+CiAjaW5jbHVkZSA8YXNtL25taS5oPgogI2luY2x1ZGUgPGFzbS9wY3Iu aD4KICNpbmNsdWRlIDxhc20vY2FjaGVmbHVzaC5oPgpAQCAtMTYxMiw2ICsxNjEzLDggQEAgc3Rh dGljIGludCBfX2twcm9iZXMgcGVyZl9ldmVudF9ubWlfaGFuZGxlcihzdHJ1Y3Qgbm90aWZpZXJf YmxvY2sgKnNlbGYsCiAJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgZGF0YTsKIAlzdHJ1Y3QgY3B1 X2h3X2V2ZW50cyAqY3B1YzsKIAlzdHJ1Y3QgcHRfcmVncyAqcmVnczsKKwl1NjQgZmluaXNoX2Ns b2NrOworCXU2NCBzdGFydF9jbG9jazsKIAlpbnQgaTsKIAogCWlmICghYXRvbWljX3JlYWQoJmFj dGl2ZV9ldmVudHMpKQpAQCAtMTYyNSw2ICsxNjI4LDggQEAgc3RhdGljIGludCBfX2twcm9iZXMg cGVyZl9ldmVudF9ubWlfaGFuZGxlcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnNlbGYsCiAJCXJl dHVybiBOT1RJRllfRE9ORTsKIAl9CiAKKwlzdGFydF9jbG9jayA9IHNjaGVkX2Nsb2NrKCk7CisK IAlyZWdzID0gYXJncy0+cmVnczsKIAogCWNwdWMgPSB0aGlzX2NwdV9wdHIoJmNwdV9od19ldmVu dHMpOwpAQCAtMTY2Myw2ICsxNjY4LDEwIEBAIHN0YXRpYyBpbnQgX19rcHJvYmVzIHBlcmZfZXZl bnRfbm1pX2hhbmRsZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLAogCQkJc3BhcmNfcG11 X3N0b3AoZXZlbnQsIDApOwogCX0KIAorCWZpbmlzaF9jbG9jayA9IHNjaGVkX2Nsb2NrKCk7CisK KwlwZXJmX3NhbXBsZV9ldmVudF90b29rKGZpbmlzaF9jbG9jayAtIHN0YXJ0X2Nsb2NrKTsKKwog CXJldHVybiBOT1RJRllfU1RPUDsKIH0KIAotLSAKMi4xOS4xCgo= ----Next_Part(Thu_Nov__1_21_08_51_2018_706)-- Content-Type: Text/Plain; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="sparc_419.mbox" >>From dd6bdff3a6573eb93d5ea786ecb319aeb0134ef0 Mon Sep 17 00:00:00 2001 From: "David S. Miller" Date: Fri, 26 Oct 2018 15:11:56 -0700 Subject: [PATCH 1/3] sparc64: Export __node_distance. [ Upstream commit 2b4792eaa9f553764047d157365ed8b7787751a3 ] Some drivers reference it via node_distance(), for example the NVME host driver core. ERROR: "__node_distance" [drivers/nvme/host/nvme-core.ko] undefined! make[1]: *** [scripts/Makefile.modpost:92: __modpost] Error 1 Signed-off-by: David S. Miller --- arch/sparc/mm/init_64.c | 1 + 1 file changed, 1 insertion(+) diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c index f396048a0d68..39822f611c01 100644 --- a/arch/sparc/mm/init_64.c +++ b/arch/sparc/mm/init_64.c @@ -1383,6 +1383,7 @@ int __node_distance(int from, int to) } return numa_latency[from][to]; } +EXPORT_SYMBOL(__node_distance); static int __init find_best_numa_node_for_mlgroup(struct mdesc_mlgroup *grp) { -- 2.19.1 >>From 2835fa1d7c211c2367f8ec488306a00c01b63472 Mon Sep 17 00:00:00 2001 From: David Miller Date: Thu, 25 Oct 2018 20:36:46 -0700 Subject: [PATCH 2/3] sparc64: Make corrupted user stacks more debuggable. [ Upstream commit 5b4fc3882a649c9411dd0dcad2ddb78e911d340e ] Right now if we get a corrupted user stack frame we do a do_exit(SIGILL) which is not helpful. If under a debugger, this behavior causes the inferior process to exit. So the register and other state cannot be examined at the time of the event. Instead, conditionally log a rate limited kernel log message and then force a SIGSEGV. With bits and ideas borrowed (as usual) from powerpc. Signed-off-by: David S. Miller --- arch/sparc/include/asm/switch_to_64.h | 3 ++- arch/sparc/kernel/process_64.c | 25 +++++++++++++++++++------ arch/sparc/kernel/rtrap_64.S | 1 + arch/sparc/kernel/signal32.c | 12 ++++++++++-- arch/sparc/kernel/signal_64.c | 6 +++++- 5 files changed, 37 insertions(+), 10 deletions(-) diff --git a/arch/sparc/include/asm/switch_to_64.h b/arch/sparc/include/asm/switch_to_64.h index 4ff29b1406a9..b1d4e2e3210f 100644 --- a/arch/sparc/include/asm/switch_to_64.h +++ b/arch/sparc/include/asm/switch_to_64.h @@ -67,6 +67,7 @@ do { save_and_clear_fpu(); \ } while(0) void synchronize_user_stack(void); -void fault_in_user_windows(void); +struct pt_regs; +void fault_in_user_windows(struct pt_regs *); #endif /* __SPARC64_SWITCH_TO_64_H */ diff --git a/arch/sparc/kernel/process_64.c b/arch/sparc/kernel/process_64.c index 6c086086ca8f..59eaf6227af1 100644 --- a/arch/sparc/kernel/process_64.c +++ b/arch/sparc/kernel/process_64.c @@ -36,6 +36,7 @@ #include #include #include +#include #include #include @@ -521,7 +522,12 @@ static void stack_unaligned(unsigned long sp) force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *) sp, 0, current); } -void fault_in_user_windows(void) +static const char uwfault32[] = KERN_INFO \ + "%s[%d]: bad register window fault: SP %08lx (orig_sp %08lx) TPC %08lx O7 %08lx\n"; +static const char uwfault64[] = KERN_INFO \ + "%s[%d]: bad register window fault: SP %016lx (orig_sp %016lx) TPC %08lx O7 %016lx\n"; + +void fault_in_user_windows(struct pt_regs *regs) { struct thread_info *t = current_thread_info(); unsigned long window; @@ -534,9 +540,9 @@ void fault_in_user_windows(void) do { struct reg_window *rwin = &t->reg_window[window]; int winsize = sizeof(struct reg_window); - unsigned long sp; + unsigned long sp, orig_sp; - sp = t->rwbuf_stkptrs[window]; + orig_sp = sp = t->rwbuf_stkptrs[window]; if (test_thread_64bit_stack(sp)) sp += STACK_BIAS; @@ -547,8 +553,16 @@ void fault_in_user_windows(void) stack_unaligned(sp); if (unlikely(copy_to_user((char __user *)sp, - rwin, winsize))) + rwin, winsize))) { + if (show_unhandled_signals) + printk_ratelimited(is_compat_task() ? + uwfault32 : uwfault64, + current->comm, current->pid, + sp, orig_sp, + regs->tpc, + regs->u_regs[UREG_I7]); goto barf; + } } while (window--); } set_thread_wsaved(0); @@ -556,8 +570,7 @@ void fault_in_user_windows(void) barf: set_thread_wsaved(window + 1); - user_exit(); - do_exit(SIGILL); + force_sig(SIGSEGV, current); } asmlinkage long sparc_do_fork(unsigned long clone_flags, diff --git a/arch/sparc/kernel/rtrap_64.S b/arch/sparc/kernel/rtrap_64.S index 4073e2b87dd0..29aa34f11720 100644 --- a/arch/sparc/kernel/rtrap_64.S +++ b/arch/sparc/kernel/rtrap_64.S @@ -39,6 +39,7 @@ __handle_preemption: wrpr %g0, RTRAP_PSTATE_IRQOFF, %pstate __handle_user_windows: + add %sp, PTREGS_OFF, %o0 call fault_in_user_windows 661: wrpr %g0, RTRAP_PSTATE, %pstate /* If userspace is using ADI, it could potentially pass diff --git a/arch/sparc/kernel/signal32.c b/arch/sparc/kernel/signal32.c index 44d379db3f64..4c5b3fcbed94 100644 --- a/arch/sparc/kernel/signal32.c +++ b/arch/sparc/kernel/signal32.c @@ -371,7 +371,11 @@ static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs, get_sigframe(ksig, regs, sigframe_size); if (invalid_frame_pointer(sf, sigframe_size)) { - do_exit(SIGILL); + if (show_unhandled_signals) + pr_info("%s[%d] bad frame in setup_frame32: %08lx TPC %08lx O7 %08lx\n", + current->comm, current->pid, (unsigned long)sf, + regs->tpc, regs->u_regs[UREG_I7]); + force_sigsegv(ksig->sig, current); return -EINVAL; } @@ -501,7 +505,11 @@ static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs, get_sigframe(ksig, regs, sigframe_size); if (invalid_frame_pointer(sf, sigframe_size)) { - do_exit(SIGILL); + if (show_unhandled_signals) + pr_info("%s[%d] bad frame in setup_rt_frame32: %08lx TPC %08lx O7 %08lx\n", + current->comm, current->pid, (unsigned long)sf, + regs->tpc, regs->u_regs[UREG_I7]); + force_sigsegv(ksig->sig, current); return -EINVAL; } diff --git a/arch/sparc/kernel/signal_64.c b/arch/sparc/kernel/signal_64.c index 48366e5eb5b2..e9de1803a22e 100644 --- a/arch/sparc/kernel/signal_64.c +++ b/arch/sparc/kernel/signal_64.c @@ -370,7 +370,11 @@ setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs) get_sigframe(ksig, regs, sf_size); if (invalid_frame_pointer (sf)) { - do_exit(SIGILL); /* won't return, actually */ + if (show_unhandled_signals) + pr_info("%s[%d] bad frame in setup_rt_frame: %016lx TPC %016lx O7 %016lx\n", + current->comm, current->pid, (unsigned long)sf, + regs->tpc, regs->u_regs[UREG_I7]); + force_sigsegv(ksig->sig, current); return -EINVAL; } -- 2.19.1 >>From 42dffdd95a8faacd7df0e369040b0f441594757b Mon Sep 17 00:00:00 2001 From: "David S. Miller" Date: Wed, 31 Oct 2018 18:30:21 -0700 Subject: [PATCH 3/3] sparc64: Wire up compat getpeername and getsockname. [ Upstream commit 1f2b5b8e2df4591fbca430aff9c5a072dcc0f408 ] Fixes: 8b30ca73b7cc ("sparc: Add all necessary direct socket system calls.") Reported-by: Joseph Myers Signed-off-by: David S. Miller --- arch/sparc/kernel/systbls_64.S | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/arch/sparc/kernel/systbls_64.S b/arch/sparc/kernel/systbls_64.S index bb68c805b891..ff9389a1c9f3 100644 --- a/arch/sparc/kernel/systbls_64.S +++ b/arch/sparc/kernel/systbls_64.S @@ -47,9 +47,9 @@ sys_call_table32: .word sys_recvfrom, sys_setreuid16, sys_setregid16, sys_rename, compat_sys_truncate /*130*/ .word compat_sys_ftruncate, sys_flock, compat_sys_lstat64, sys_sendto, sys_shutdown .word sys_socketpair, sys_mkdir, sys_rmdir, compat_sys_utimes, compat_sys_stat64 -/*140*/ .word sys_sendfile64, sys_nis_syscall, compat_sys_futex, sys_gettid, compat_sys_getrlimit +/*140*/ .word sys_sendfile64, sys_getpeername, compat_sys_futex, sys_gettid, compat_sys_getrlimit .word compat_sys_setrlimit, sys_pivot_root, sys_prctl, sys_pciconfig_read, sys_pciconfig_write -/*150*/ .word sys_nis_syscall, sys_inotify_init, sys_inotify_add_watch, sys_poll, sys_getdents64 +/*150*/ .word sys_getsockname, sys_inotify_init, sys_inotify_add_watch, sys_poll, sys_getdents64 .word compat_sys_fcntl64, sys_inotify_rm_watch, compat_sys_statfs, compat_sys_fstatfs, sys_oldumount /*160*/ .word compat_sys_sched_setaffinity, compat_sys_sched_getaffinity, sys_getdomainname, sys_setdomainname, sys_nis_syscall .word sys_quotactl, sys_set_tid_address, compat_sys_mount, compat_sys_ustat, sys_setxattr -- 2.19.1 ----Next_Part(Thu_Nov__1_21_08_51_2018_706)----