From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 294D9C3527C for ; Sat, 9 Apr 2022 04:52:36 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id C45E984585; Sat, 9 Apr 2022 04:52:35 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id LV5Fcq7zKbCU; Sat, 9 Apr 2022 04:52:33 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp1.osuosl.org (Postfix) with ESMTPS id DB64E8462B; Sat, 9 Apr 2022 04:52:32 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id B257CC0033; Sat, 9 Apr 2022 04:52:32 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by lists.linuxfoundation.org (Postfix) with ESMTP id C84F5C002C for ; Sat, 9 Apr 2022 04:52:31 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id AB07060F57 for ; Sat, 9 Apr 2022 04:52:31 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp3.osuosl.org (amavisd-new); dkim=pass (2048-bit key) header.d=infradead.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id y4ID5t6CbVgw for ; Sat, 9 Apr 2022 04:52:29 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.8.0 Received: from bombadil.infradead.org (bombadil.infradead.org [IPv6:2607:7c80:54:e::133]) by smtp3.osuosl.org (Postfix) with ESMTPS id 0F18C60EF1 for ; Sat, 9 Apr 2022 04:52:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc: To:From:Sender:Reply-To:Content-ID:Content-Description; bh=lhrI7Npx42D1AuR/cMyqCoOjrZczBcvFSvpyDVoTBuM=; b=Sjapi7eI4Jh86xiPLIzL2g0V1J mjcOCE9buuik3xQceo12VbO7h4X1i/S8+EGUcf1u3xFqviUr0IXMxs/3Qij4rUA/BVYuftFH0B+QL 15jKW5DOWLXn3fZpnfOdPjT+8sq7nSyHdBxT6coOufp9mqpgHjMXvI28DvNWovru926kmp5e+ex7c /jYKn9KuBgqzsQrl/W/fJF4dNs6aceGzPpdLj4fBSiNAx7tFXGHLE6PclN+/DWpkJQW8eCCHQlhYf t5bRpzLnnxe4LGnXML4qPk3asM8WCBUpA/jrjYRG0MkY4Dc8Ud6n31tOOsdykMc3zj9OSK9AysXdb fD5Kz47g==; Received: from 213-147-167-116.nat.highway.webapn.at ([213.147.167.116] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.94.2 #2 (Red Hat Linux)) id 1nd354-0021dK-Sw; Sat, 09 Apr 2022 04:52:15 +0000 From: Christoph Hellwig To: Jens Axboe Subject: [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-Id: <20220409045043.23593-25-hch@lst.de> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> MIME-Version: 1.0 X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html Cc: jfs-discussion@lists.sourceforge.net, linux-nvme@lists.infradead.org, virtualization@lists.linux-foundation.org, linux-mm@kvack.org, dm-devel@redhat.com, target-devel@vger.kernel.org, linux-mtd@lists.infradead.org, drbd-dev@lists.linbit.com, linux-s390@vger.kernel.org, linux-nilfs@vger.kernel.org, linux-scsi@vger.kernel.org, cluster-devel@redhat.com, xen-devel@lists.xenproject.org, linux-ext4@vger.kernel.org, linux-um@lists.infradead.org, nbd@other.debian.org, linux-block@vger.kernel.org, linux-bcache@vger.kernel.org, ceph-devel@vger.kernel.org, Coly Li , linux-raid@vger.kernel.org, "Martin K . Petersen" , linux-mmc@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-xfs@vger.kernel.org, =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , ocfs2-devel@oss.oracle.com, linux-fsdevel@vger.kernel.org, ntfs3@lists.linux.dev, linux-btrfs@vger.kernel.org X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" SnVzdCB1c2UgYSBub24temVybyBtYXhfZGlzY2FyZF9zZWN0b3JzIGFzIGFuIGluZGljYXRvciBm b3IgZGlzY2FyZApzdXBwb3J0LCBzaW1pbGFyIHRvIHdoYXQgaXMgZG9uZSBmb3Igd3JpdGUgemVy b2VzLgoKVGhlIG9ubHkgcGxhY2VzIHdoZXJlIG5lZWRzIHNwZWNpYWwgYXR0ZW50aW9uIGlzIHRo ZSBSQUlENSBkcml2ZXIsCndoaWNoIG11c3QgY2xlYXIgZGlzY2FyZCBzdXBwb3J0IGZvciBzZWN1 cml0eSByZWFzb25zIGJ5IGRlZmF1bHQsCmV2ZW4gaWYgdGhlIGRlZmF1bHQgc3RhY2tpbmcgcnVs ZXMgd291bGQgYWxsb3cgZm9yIGl0LgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcg PGhjaEBsc3QuZGU+ClJldmlld2VkLWJ5OiBNYXJ0aW4gSy4gUGV0ZXJzZW4gPG1hcnRpbi5wZXRl cnNlbkBvcmFjbGUuY29tPgpBY2tlZC1ieTogQ2hyaXN0b3BoIELDtmhtd2FsZGVyIDxjaHJpc3Rv cGguYm9laG13YWxkZXJAbGluYml0LmNvbT4gW2J0cmZzXQpBY2tlZC1ieTogQ29seSBMaSA8Y29s eWxpQHN1c2UuZGU+IFtiY2FjaGVdCi0tLQogYXJjaC91bS9kcml2ZXJzL3ViZF9rZXJuLmMgICAg ICAgICAgfCAgMiAtLQogYmxvY2svYmxrLWNvcmUuYyAgICAgICAgICAgICAgICAgICAgfCAgMiAr LQogYmxvY2svYmxrLWxpYi5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogYmxvY2svYmxr LW1xLWRlYnVnZnMuYyAgICAgICAgICAgICAgfCAgMSAtCiBibG9jay9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgICB8ICAzICstLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbWFpbi5jICAg ICAgfCAgMiArLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYyAgICAgICAgfCAxOSArKy0t LS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jICB8ICAz ICstLQogZHJpdmVycy9ibG9jay9sb29wLmMgICAgICAgICAgICAgICAgfCAxMSArKystLS0tLS0t LQogZHJpdmVycy9ibG9jay9uYmQuYyAgICAgICAgICAgICAgICAgfCAgNSArLS0tLQogZHJpdmVy cy9ibG9jay9udWxsX2Jsay9tYWluLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL2Jsb2NrL3JiZC5j ICAgICAgICAgICAgICAgICB8ICAxIC0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jICAg ICAgIHwgIDIgLS0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaCAgIHwgIDMgLS0t CiBkcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYyAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Js b2NrL3hlbi1ibGtiYWNrL3hlbmJ1cy5jICB8ICAyICstCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtm cm9udC5jICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYyAgICAg ICB8ICAxIC0KIGRyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYyAgICAgICAgIHwgIDQgKystLQog ZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYyAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv YmNhY2hlL3N5c2ZzLmMgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvbWQvZG0tY2FjaGUtdGFy Z2V0LmMgICAgICAgIHwgIDkgKy0tLS0tLS0tCiBkcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5j ICAgICAgICB8ICA5ICstLS0tLS0tLQogZHJpdmVycy9tZC9kbS1sb2ctd3JpdGVzLmMgICAgICAg ICAgfCAgMyArLS0KIGRyaXZlcnMvbWQvZG0tcmFpZC5jICAgICAgICAgICAgICAgIHwgIDkgKyst LS0tLS0tCiBkcml2ZXJzL21kL2RtLXRhYmxlLmMgICAgICAgICAgICAgICB8ICA5ICsrLS0tLS0t LQogZHJpdmVycy9tZC9kbS10aGluLmMgICAgICAgICAgICAgICAgfCAxMSArLS0tLS0tLS0tLQog ZHJpdmVycy9tZC9kbS5jICAgICAgICAgICAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv bWQtbGluZWFyLmMgICAgICAgICAgICAgIHwgMTEgKy0tLS0tLS0tLS0KIGRyaXZlcnMvbWQvcmFp ZDAuYyAgICAgICAgICAgICAgICAgIHwgIDcgLS0tLS0tLQogZHJpdmVycy9tZC9yYWlkMS5jICAg ICAgICAgICAgICAgICAgfCAxNiArLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL21kL3JhaWQxMC5j ICAgICAgICAgICAgICAgICB8IDE4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tZC9yYWlk NS1jYWNoZS5jICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9tZC9yYWlkNS5jICAgICAgICAg ICAgICAgICAgfCAxMiArKysrLS0tLS0tLS0KIGRyaXZlcnMvbW1jL2NvcmUvcXVldWUuYyAgICAg ICAgICAgIHwgIDEgLQogZHJpdmVycy9tdGQvbXRkX2Jsa2RldnMuYyAgICAgICAgICAgfCAgMSAt CiBkcml2ZXJzL252bWUvaG9zdC9jb3JlLmMgICAgICAgICAgICB8ICA2ICsrLS0tLQogZHJpdmVy cy9zMzkwL2Jsb2NrL2Rhc2RfZmJhLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL3Njc2kvc2QuYyAg ICAgICAgICAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9kZXZp Y2UuYyB8ICAyICstCiBmcy9idHJmcy9leHRlbnQtdHJlZS5jICAgICAgICAgICAgICB8ICA0ICsr LS0KIGZzL2J0cmZzL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0 L2ZpbGUuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0L3N1cGVyLmMgICAg ICAgICAgICAgICAgICAgIHwgMTAgKysrLS0tLS0tLQogZnMvZXh0NC9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgfCAxMCArKystLS0tLS0tCiBmcy9leHQ0L3N1cGVyLmMgICAgICAgICAgICAg ICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZzL2YyZnMvZjJmcy5oICAgICAgICAgICAgICAgICAg ICAgIHwgIDMgKy0tCiBmcy9mYXQvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgICB8ICAyICst CiBmcy9mYXQvaW5vZGUuYyAgICAgICAgICAgICAgICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZz L2dmczIvcmdycC5jICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2piZDIvam91cm5h bC5jICAgICAgICAgICAgICAgICAgIHwgIDcgKystLS0tLQogZnMvamZzL2lvY3RsLmMgICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQogZnMvamZzL3N1cGVyLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgOCArKy0tLS0tLQogZnMvbmlsZnMyL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgfCAg MiArLQogZnMvbnRmczMvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvbnRm czMvc3VwZXIuYyAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvb2NmczIvaW9jdGwuYyAg ICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMveGZzL3hmc19kaXNjYXJkLmMgICAgICAgICAg ICAgICAgfCAgMiArLQogZnMveGZzL3hmc19zdXBlci5jICAgICAgICAgICAgICAgICAgfCAxMiAr KysrLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvYmxrZGV2LmggICAgICAgICAgICAgIHwgIDIgLS0K IG1tL3N3YXBmaWxlLmMgICAgICAgICAgICAgICAgICAgICAgIHwgMTcgKystLS0tLS0tLS0tLS0t LS0KIDYxIGZpbGVzIGNoYW5nZWQsIDcyIGluc2VydGlvbnMoKyksIDI0NiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvdWJkX2tlcm4uYyBiL2FyY2gvdW0vZHJpdmVy cy91YmRfa2Vybi5jCmluZGV4IGIwMzI2OWZhZWY3MTQuLjA4NWZmZGY5OGU1N2UgMTAwNjQ0Ci0t LSBhL2FyY2gvdW0vZHJpdmVycy91YmRfa2Vybi5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy91YmRf a2Vybi5jCkBAIC00ODMsNyArNDgzLDYgQEAgc3RhdGljIHZvaWQgdWJkX2hhbmRsZXIodm9pZCkK IAkJCWlmICgoaW9fcmVxLT5lcnJvciA9PSBCTEtfU1RTX05PVFNVUFApICYmIChyZXFfb3AoaW9f cmVxLT5yZXEpID09IFJFUV9PUF9ESVNDQVJEKSkgewogCQkJCWJsa19xdWV1ZV9tYXhfZGlzY2Fy ZF9zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKIAkJCQlibGtfcXVldWVfbWF4X3dyaXRlX3pl cm9lc19zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKLQkJCQlibGtfcXVldWVfZmxhZ19jbGVh cihRVUVVRV9GTEFHX0RJU0NBUkQsIGlvX3JlcS0+cmVxLT5xKTsKIAkJCX0KIAkJCWJsa19tcV9l bmRfcmVxdWVzdChpb19yZXEtPnJlcSwgaW9fcmVxLT5lcnJvcik7CiAJCQlrZnJlZShpb19yZXEp OwpAQCAtODAzLDcgKzgwMiw2IEBAIHN0YXRpYyBpbnQgdWJkX29wZW5fZGV2KHN0cnVjdCB1YmQg KnViZF9kZXYpCiAJCXViZF9kZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQgPSBT RUNUT1JfU0laRTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnModWJkX2Rldi0+cXVl dWUsIFVCRF9NQVhfUkVRVUVTVCk7CiAJCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3Rv cnModWJkX2Rldi0+cXVldWUsIFVCRF9NQVhfUkVRVUVTVCk7Ci0JCWJsa19xdWV1ZV9mbGFnX3Nl dChRVUVVRV9GTEFHX0RJU0NBUkQsIHViZF9kZXYtPnF1ZXVlKTsKIAl9CiAJYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfTk9OUk9ULCB1YmRfZGV2LT5xdWV1ZSk7CiAJcmV0dXJuIDA7CmRp ZmYgLS1naXQgYS9ibG9jay9ibGstY29yZS5jIGIvYmxvY2svYmxrLWNvcmUuYwppbmRleCA5Mzdi YjZiODYzMzE3Li5iNWMzYTgwNDkxMzRjIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY29yZS5jCisr KyBiL2Jsb2NrL2Jsay1jb3JlLmMKQEAgLTgyMCw3ICs4MjAsNyBAQCB2b2lkIHN1Ym1pdF9iaW9f bm9hY2N0KHN0cnVjdCBiaW8gKmJpbykKIAogCXN3aXRjaCAoYmlvX29wKGJpbykpIHsKIAljYXNl IFJFUV9PUF9ESVNDQVJEOgotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQorCQlpZiAoIWJk ZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSkKIAkJCWdvdG8gbm90X3N1cHBvcnRlZDsKIAkJ YnJlYWs7CiAJY2FzZSBSRVFfT1BfU0VDVVJFX0VSQVNFOgpkaWZmIC0tZ2l0IGEvYmxvY2svYmxr LWxpYi5jIGIvYmxvY2svYmxrLWxpYi5jCmluZGV4IDJhZTMyYTcyMjg1MWMuLjhiNGI2NmQzYTli ZmMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1saWIuYworKysgYi9ibG9jay9ibGstbGliLmMKQEAg LTUzLDcgKzUzLDcgQEAgaW50IF9fYmxrZGV2X2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2Rl dmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCQlv cCA9IFJFUV9PUF9TRUNVUkVfRVJBU0U7CiAJfSBlbHNlIHsKLQkJaWYgKCFibGtfcXVldWVfZGlz Y2FyZChxKSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAJCW9wID0gUkVRX09QX0RJU0NBUkQ7CiAJfQpkaWZmIC0tZ2l0IGEv YmxvY2svYmxrLW1xLWRlYnVnZnMuYyBiL2Jsb2NrL2Jsay1tcS1kZWJ1Z2ZzLmMKaW5kZXggYWEw MzQ5ZTlmMDgzYi4uZmQxMTFjNTAwMTI1NiAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLW1xLWRlYnVn ZnMuYworKysgYi9ibG9jay9ibGstbXEtZGVidWdmcy5jCkBAIC0xMTMsNyArMTEzLDYgQEAgc3Rh dGljIGNvbnN0IGNoYXIgKmNvbnN0IGJsa19xdWV1ZV9mbGFnX25hbWVbXSA9IHsKIAlRVUVVRV9G TEFHX05BTUUoRkFJTF9JTyksCiAJUVVFVUVfRkxBR19OQU1FKE5PTlJPVCksCiAJUVVFVUVfRkxB R19OQU1FKElPX1NUQVQpLAotCVFVRVVFX0ZMQUdfTkFNRShESVNDQVJEKSwKIAlRVUVVRV9GTEFH X05BTUUoTk9YTUVSR0VTKSwKIAlRVUVVRV9GTEFHX05BTUUoQUREX1JBTkRPTSksCiAJUVVFVUVf RkxBR19OQU1FKFNFQ0VSQVNFKSwKZGlmZiAtLWdpdCBhL2Jsb2NrL2lvY3RsLmMgYi9ibG9jay9p b2N0bC5jCmluZGV4IGFkMzc3MWIyNjhiODEuLmMyY2QzYmE1MjkwY2UgMTAwNjQ0Ci0tLSBhL2Js b2NrL2lvY3RsLmMKKysrIGIvYmxvY2svaW9jdGwuYwpAQCAtODcsMTQgKzg3LDEzIEBAIHN0YXRp YyBpbnQgYmxrX2lvY3RsX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlLAogewogCXVpbnQ2NF90IHJhbmdlWzJdOwogCXVpbnQ2NF90IHN0YXJ0LCBsZW47Ci0J c3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShiZGV2KTsKIAlzdHJ1Y3Qg aW5vZGUgKmlub2RlID0gYmRldi0+YmRfaW5vZGU7CiAJaW50IGVycjsKIAogCWlmICghKG1vZGUg JiBGTU9ERV9XUklURSkpCiAJCXJldHVybiAtRUJBREY7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQlyZXR1cm4g LUVPUE5PVFNVUFA7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIocmFuZ2UsICh2b2lkIF9fdXNlciAq KWFyZywgc2l6ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJi ZF9tYWluLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMKaW5kZXggZWFlNjI5YzRm NmVhZi4uYTY5NDc1ZTU5MjgyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf bWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX21haW4uYwpAQCAtOTQyLDcgKzk0 Miw3IEBAIGludCBkcmJkX3NlbmRfc2l6ZXMoc3RydWN0IGRyYmRfcGVlcl9kZXZpY2UgKnBlZXJf ZGV2aWNlLCBpbnQgdHJpZ2dlcl9yZXBseSwgZW51CiAJCQljcHVfdG9fYmUzMihiZGV2X2FsaWdu bWVudF9vZmZzZXQoYmRldikpOwogCQlwLT5xbGltLT5pb19taW4gPSBjcHVfdG9fYmUzMihiZGV2 X2lvX21pbihiZGV2KSk7CiAJCXAtPnFsaW0tPmlvX29wdCA9IGNwdV90b19iZTMyKGJkZXZfaW9f b3B0KGJkZXYpKTsKLQkJcC0+cWxpbS0+ZGlzY2FyZF9lbmFibGVkID0gYmxrX3F1ZXVlX2Rpc2Nh cmQocSk7CisJCXAtPnFsaW0tPmRpc2NhcmRfZW5hYmxlZCA9ICEhYmRldl9tYXhfZGlzY2FyZF9z ZWN0b3JzKGJkZXYpOwogCQlwdXRfbGRldihkZXZpY2UpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBy ZXF1ZXN0X3F1ZXVlICpxID0gZGV2aWNlLT5ycV9xdWV1ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv YmxvY2svZHJiZC9kcmJkX25sLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9ubC5jCmluZGV4 IGQ0ZGFjYzMyOWFjMmUuLmI1NWU1ZmNjMjFlMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv ZHJiZC9kcmJkX25sLmMKKysrIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYwpAQCAtMTIx MCw3ICsxMjEwLDcgQEAgc3RhdGljIHZvaWQgZGVjaWRlX29uX2Rpc2NhcmRfc3VwcG9ydChzdHJ1 Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwKIAkJZmlyc3RfcGVlcl9kZXZpY2UoZGV2aWNlKS0+Y29u bmVjdGlvbjsKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGRldmljZS0+cnFfcXVldWU7CiAK LQlpZiAoYmRldiAmJiAhYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldi0+YmFja2luZ19iZGV2LT5iZF9k aXNrLT5xdWV1ZSkpCisJaWYgKGJkZXYgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2 LT5iYWNraW5nX2JkZXYpKQogCQlnb3RvIG5vdF9zdXBwb3J0ZWQ7CiAKIAlpZiAoY29ubmVjdGlv bi0+Y3N0YXRlID49IENfQ09OTkVDVEVEICYmCkBAIC0xMjMwLDMwICsxMjMwLDE2IEBAIHN0YXRp YyB2b2lkIGRlY2lkZV9vbl9kaXNjYXJkX3N1cHBvcnQoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZp Y2UsCiAJICovCiAJYmxrX3F1ZXVlX2Rpc2NhcmRfZ3JhbnVsYXJpdHkocSwgNTEyKTsKIAlxLT5s aW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9ycyA9IGRyYmRfbWF4X2Rpc2NhcmRfc2VjdG9ycyhjb25u ZWN0aW9uKTsKLQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAlx LT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0KIAkJZHJiZF9tYXhfZGlzY2FyZF9z ZWN0b3JzKGNvbm5lY3Rpb24pOwogCXJldHVybjsKIAogbm90X3N1cHBvcnRlZDoKLQlibGtfcXVl dWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwogCWJsa19xdWV1ZV9kaXNjYXJk X2dyYW51bGFyaXR5KHEsIDApOwogCXEtPmxpbWl0cy5tYXhfZGlzY2FyZF9zZWN0b3JzID0gMDsK IAlxLT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0gMDsKIH0KIAotc3RhdGljIHZv aWQgZml4dXBfZGlzY2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpx KQotewotCS8qIFRvIGF2b2lkIGNvbmZ1c2lvbiwgaWYgdGhpcyBxdWV1ZSBkb2VzIG5vdCBzdXBw b3J0IGRpc2NhcmQsIGNsZWFyCi0JICogbWF4X2Rpc2NhcmRfc2VjdG9ycywgd2hpY2ggaXMgd2hh dCBsc2JsayAtRCByZXBvcnRzIHRvIHRoZSB1c2VyLgotCSAqIE9sZGVyIGtlcm5lbHMgZ290IHRo aXMgd3JvbmcgaW4gInN0YWNrIGxpbWl0cyIuCi0JICogKi8KLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKSB7Ci0JCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIDApOwotCQlibGtf cXVldWVfZGlzY2FyZF9ncmFudWxhcml0eShxLCAwKTsKLQl9Ci19Ci0KIHN0YXRpYyB2b2lkIGZp eHVwX3dyaXRlX3plcm9lcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwgc3RydWN0IHJlcXVl c3RfcXVldWUgKnEpCiB7CiAJLyogRml4dXAgbWF4X3dyaXRlX3plcm9lc19zZWN0b3JzIGFmdGVy IGJsa19zdGFja19saW1pdHMoKToKQEAgLTEzMDAsNyArMTI4Niw2IEBAIHN0YXRpYyB2b2lkIGRy YmRfc2V0dXBfcXVldWVfcGFyYW0oc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBk cmJkX2JhY2tpCiAJCWJsa19zdGFja19saW1pdHMoJnEtPmxpbWl0cywgJmItPmxpbWl0cywgMCk7 CiAJCWRpc2tfdXBkYXRlX3JlYWRhaGVhZChkZXZpY2UtPnZkaXNrKTsKIAl9Ci0JZml4dXBfZGlz Y2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHEpOwogCWZpeHVwX3dyaXRlX3plcm9lcyhkZXZpY2UsIHEp OwogfQogCkBAIC0xNDQ3LDcgKzE0MzIsNyBAQCBzdGF0aWMgdm9pZCBzYW5pdGl6ZV9kaXNrX2Nv bmYoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBkaXNrX2NvbmYgKmRpcwogCWlm IChkaXNrX2NvbmYtPmFsX2V4dGVudHMgPiBkcmJkX2FsX2V4dGVudHNfbWF4KG5iYykpCiAJCWRp c2tfY29uZi0+YWxfZXh0ZW50cyA9IGRyYmRfYWxfZXh0ZW50c19tYXgobmJjKTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhi ZGV2KSkgewogCQlpZiAoZGlza19jb25mLT5yc19kaXNjYXJkX2dyYW51bGFyaXR5KSB7CiAJCQlk aXNrX2NvbmYtPnJzX2Rpc2NhcmRfZ3JhbnVsYXJpdHkgPSAwOyAvKiBkaXNhYmxlIGZlYXR1cmUg Ki8KIAkJCWRyYmRfaW5mbyhkZXZpY2UsICJyc19kaXNjYXJkX2dyYW51bGFyaXR5IGZlYXR1cmUg ZGlzYWJsZWRcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2 ZXIuYyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX3JlY2VpdmVyLmMKaW5kZXggMGI0YzdkZTQ2 Mzk4OS4uOGE0YTQ3ZGE1NmZlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf cmVjZWl2ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC0x NTc1LDExICsxNTc1LDEwIEBAIGludCBkcmJkX2lzc3VlX2Rpc2NhcmRfb3JfemVyb19vdXQoc3Ry dWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHNlY3Rvcl90IHN0YXJ0LCB1CiAKIHN0YXRpYyBib29s IGNhbl9kb19yZWxpYWJsZV9kaXNjYXJkcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSkKIHsK LQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGRldmljZS0+bGRldi0+ YmFja2luZ19iZGV2KTsKIAlzdHJ1Y3QgZGlza19jb25mICpkYzsKIAlib29sIGNhbl9kbzsKIAot CWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoZGV2aWNlLT5sZGV2LT5iYWNraW5nX2JkZXYpKQogCQlyZXR1cm4gZmFsc2U7CiAKIAlyY3Vf cmVhZF9sb2NrKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYyBiL2RyaXZlcnMv YmxvY2svbG9vcC5jCmluZGV4IDhkODAwZDQ2ZTQ5ODUuLjBlMDYxYzk4OTZlZmYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCkBAIC0z MTQsMTUgKzMxNCwxMiBAQCBzdGF0aWMgaW50IGxvX2ZhbGxvY2F0ZShzdHJ1Y3QgbG9vcF9kZXZp Y2UgKmxvLCBzdHJ1Y3QgcmVxdWVzdCAqcnEsIGxvZmZfdCBwb3MsCiAKIAltb2RlIHw9IEZBTExP Q19GTF9LRUVQX1NJWkU7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKGxvLT5sb19xdWV1ZSkp IHsKLQkJcmV0ID0gLUVPUE5PVFNVUFA7Ci0JCWdvdG8gb3V0OwotCX0KKwlpZiAoIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhsby0+bG9fZGV2aWNlKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOwog CiAJcmV0ID0gZmlsZS0+Zl9vcC0+ZmFsbG9jYXRlKGZpbGUsIG1vZGUsIHBvcywgYmxrX3JxX2J5 dGVzKHJxKSk7CiAJaWYgKHVubGlrZWx5KHJldCAmJiByZXQgIT0gLUVJTlZBTCAmJiByZXQgIT0g LUVPUE5PVFNVUFApKQotCQlyZXQgPSAtRUlPOwotIG91dDoKKwkJcmV0dXJuIC1FSU87CiAJcmV0 dXJuIHJldDsKIH0KIApAQCAtNzg3LDEyICs3ODQsMTAgQEAgc3RhdGljIHZvaWQgbG9vcF9jb25m aWdfZGlzY2FyZChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvKQogCQlxLT5saW1pdHMuZGlzY2FyZF9n cmFudWxhcml0eSA9IGdyYW51bGFyaXR5OwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9y cyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKIAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNf c2VjdG9ycyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFV RVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJfSBlbHNlIHsKIAkJcS0+bGltaXRzLmRpc2NhcmRfZ3Jh bnVsYXJpdHkgPSAwOwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCAwKTsKIAkJ YmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhxLCAwKTsKLQkJYmxrX3F1ZXVlX2Zs YWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAl9CiAJcS0+bGltaXRzLmRpc2NhcmRf YWxpZ25tZW50ID0gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbmJkLmMgYi9kcml2 ZXJzL2Jsb2NrL25iZC5jCmluZGV4IDVhMWY5ODQ5NGRkZGYuLjQ3MjlhZWY4YzY0NjIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYmxvY2svbmJkLmMKKysrIGIvZHJpdmVycy9ibG9jay9uYmQuYwpAQCAt MTIzMSw4ICsxMjMxLDYgQEAgc3RhdGljIHZvaWQgbmJkX3BhcnNlX2ZsYWdzKHN0cnVjdCBuYmRf ZGV2aWNlICpuYmQpCiAJCXNldF9kaXNrX3JvKG5iZC0+ZGlzaywgdHJ1ZSk7CiAJZWxzZQogCQlz ZXRfZGlza19ybyhuYmQtPmRpc2ssIGZhbHNlKTsKLQlpZiAoY29uZmlnLT5mbGFncyAmIE5CRF9G TEFHX1NFTkRfVFJJTSkKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwg bmJkLT5kaXNrLT5xdWV1ZSk7CiAJaWYgKGNvbmZpZy0+ZmxhZ3MgJiBOQkRfRkxBR19TRU5EX0ZM VVNIKSB7CiAJCWlmIChjb25maWctPmZsYWdzICYgTkJEX0ZMQUdfU0VORF9GVUEpCiAJCQlibGtf cXVldWVfd3JpdGVfY2FjaGUobmJkLT5kaXNrLT5xdWV1ZSwgdHJ1ZSwgdHJ1ZSk7CkBAIC0xMzE5 LDggKzEzMTcsNyBAQCBzdGF0aWMgdm9pZCBuYmRfY29uZmlnX3B1dChzdHJ1Y3QgbmJkX2Rldmlj ZSAqbmJkKQogCQluYmQtPnRhZ19zZXQudGltZW91dCA9IDA7CiAJCW5iZC0+ZGlzay0+cXVldWUt PmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJbmJkLT5kaXNrLT5xdWV1ZS0+bGlt aXRzLmRpc2NhcmRfYWxpZ25tZW50ID0gMDsKLQkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3Rv cnMobmJkLT5kaXNrLT5xdWV1ZSwgVUlOVF9NQVgpOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIG5iZC0+ZGlzay0+cXVldWUpOworCQlibGtfcXVldWVfbWF4X2Rp c2NhcmRfc2VjdG9ycyhuYmQtPmRpc2stPnF1ZXVlLCAwKTsKIAogCQltdXRleF91bmxvY2soJm5i ZC0+Y29uZmlnX2xvY2spOwogCQluYmRfcHV0KG5iZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Js b2NrL251bGxfYmxrL21haW4uYyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCmluZGV4 IDA1YjExMjBlNjYyMzQuLmY2NDkzYTllODVlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv bnVsbF9ibGsvbWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCkBAIC0x NzY3LDcgKzE3NjcsNiBAQCBzdGF0aWMgdm9pZCBudWxsX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBu dWxsYiAqbnVsbGIpCiAJbnVsbGItPnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gbnVs bGItPmRldi0+YmxvY2tzaXplOwogCW51bGxiLT5xLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQg PSBudWxsYi0+ZGV2LT5ibG9ja3NpemU7CiAJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMo bnVsbGItPnEsIFVJTlRfTUFYID4+IDkpOwotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFH X0RJU0NBUkQsIG51bGxiLT5xKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZp Y2Vfb3BlcmF0aW9ucyBudWxsX2Jpb19vcHMgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2Nr L3JiZC5jIGIvZHJpdmVycy9ibG9jay9yYmQuYwppbmRleCBiODQ0NDMyYmFkMjBiLi4yYjIxZjcx N2NjZTFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3JiZC5jCisrKyBiL2RyaXZlcnMvYmxv Y2svcmJkLmMKQEAgLTQ5NDIsNyArNDk0Miw2IEBAIHN0YXRpYyBpbnQgcmJkX2luaXRfZGlzayhz dHJ1Y3QgcmJkX2RldmljZSAqcmJkX2RldikKIAlibGtfcXVldWVfaW9fb3B0KHEsIHJiZF9kZXYt Pm9wdHMtPmFsbG9jX3NpemUpOwogCiAJaWYgKHJiZF9kZXYtPm9wdHMtPnRyaW0pIHsKLQkJYmxr X3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJCXEtPmxpbWl0cy5kaXNj YXJkX2dyYW51bGFyaXR5ID0gcmJkX2Rldi0+b3B0cy0+YWxsb2Nfc2l6ZTsKIAkJYmxrX3F1ZXVl X21heF9kaXNjYXJkX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNFQ1RPUl9TSElGVCk7CiAJ CWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNF Q1RPUl9TSElGVCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1jbHQuYyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCmluZGV4IGI2NmU4ODQwYjk0YjguLmVmYTk5 YTM4ODQ1MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCisrKyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCkBAIC0xMzY0LDggKzEzNjQsNiBAQCBzdGF0 aWMgdm9pZCBzZXR1cF9yZXF1ZXN0X3F1ZXVlKHN0cnVjdCBybmJkX2NsdF9kZXYgKmRldikKIAli bGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPnF1ZXVlLCBkZXYtPm1heF9kaXNjYXJk X3NlY3RvcnMpOwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5CT0gZGV2 LT5kaXNjYXJkX2dyYW51bGFyaXR5OwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2FsaWdu bWVudAk9IGRldi0+ZGlzY2FyZF9hbGlnbm1lbnQ7Ci0JaWYgKGRldi0+bWF4X2Rpc2NhcmRfc2Vj dG9ycykKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgZGV2LT5xdWV1 ZSk7CiAJaWYgKGRldi0+c2VjdXJlX2Rpc2NhcmQpCiAJCWJsa19xdWV1ZV9mbGFnX3NldChRVUVV RV9GTEFHX1NFQ0VSQVNFLCBkZXYtPnF1ZXVlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay9ybmJkL3JuYmQtc3J2LWRldi5oIGIvZHJpdmVycy9ibG9jay9ybmJkL3JuYmQtc3J2LWRldi5o CmluZGV4IGY4MmZiYjRiYmRhOGUuLjFmN2UxYzhmZDRkOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv YmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaAorKysgYi9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1z cnYtZGV2LmgKQEAgLTQ5LDkgKzQ5LDYgQEAgc3RhdGljIGlubGluZSBpbnQgcm5iZF9kZXZfZ2V0 X3NlY3VyZV9kaXNjYXJkKGNvbnN0IHN0cnVjdCBybmJkX2RldiAqZGV2KQogCiBzdGF0aWMgaW5s aW5lIGludCBybmJkX2Rldl9nZXRfbWF4X2Rpc2NhcmRfc2VjdHMoY29uc3Qgc3RydWN0IHJuYmRf ZGV2ICpkZXYpCiB7Ci0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShkZXYt PmJkZXYpKSkKLQkJcmV0dXJuIDA7Ci0KIAlyZXR1cm4gYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KGRldi0+YmRldik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svdmlydGlvX2Jsay5j IGIvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKaW5kZXggYThiY2YzZjY2NGFmMS4uNmNjZjE1 MjUzZGVlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKKysrIGIvZHJp dmVycy9ibG9jay92aXJ0aW9fYmxrLmMKQEAgLTg4OCw4ICs4ODgsNiBAQCBzdGF0aWMgaW50IHZp cnRibGtfcHJvYmUoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCiAJCQl2ID0gc2dfZWxlbXM7 CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWdtZW50cyhxLAogCQkJCQkgICAgICAgbWluKHYs IE1BWF9ESVNDQVJEX1NFR01FTlRTKSk7Ci0KLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZM QUdfRElTQ0FSRCwgcSk7CiAJfQogCiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJU SU9fQkxLX0ZfV1JJVEVfWkVST0VTKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrYmFjay94ZW5idXMuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2sveGVuYnVzLmMKaW5k ZXggOGI2OTFmZTUwNDc1Zi4uODNjZDA4MDQxZTZiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay94ZW4tYmxrYmFjay94ZW5idXMuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hl bmJ1cy5jCkBAIC01ODMsNyArNTgzLDcgQEAgc3RhdGljIHZvaWQgeGVuX2Jsa2JrX2Rpc2NhcmQo c3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQsIHN0cnVjdCBiYWNrZW5kX2luZm8KIAlpZiAo IXhlbmJ1c19yZWFkX3Vuc2lnbmVkKGRldi0+bm9kZW5hbWUsICJkaXNjYXJkLWVuYWJsZSIsIDEp KQogCQlyZXR1cm47CiAKLQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKSB7CiAJCWVyciA9IHhlbmJ1c19wcmludGYoeGJ0LCBk ZXYtPm5vZGVuYW1lLAogCQkJImRpc2NhcmQtZ3JhbnVsYXJpdHkiLCAiJXUiLAogCQkJcS0+bGlt aXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrZnJvbnQuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2Zyb250LmMKaW5kZXggMDAzMDU2ZDRm N2Y1Zi4uMjUzYmY4MzVhY2ExZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay94ZW4tYmxrZnJv bnQuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jCkBAIC05NDQsNyArOTQ0LDYg QEAgc3RhdGljIHZvaWQgYmxraWZfc2V0X3F1ZXVlX2xpbWl0cyhzdHJ1Y3QgYmxrZnJvbnRfaW5m byAqaW5mbykKIAlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19WSVJULCBycSk7CiAKIAlp ZiAoaW5mby0+ZmVhdHVyZV9kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX0RJU0NBUkQsIHJxKTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMocnEsIGdl dF9jYXBhY2l0eShnZCkpOwogCQlycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkgPSBpbmZv LT5kaXNjYXJkX2dyYW51bGFyaXR5ID86CiAJCQkJCQkgaW5mby0+cGh5c2ljYWxfc2VjdG9yX3Np emU7CkBAIC0xNjA2LDcgKzE2MDUsNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgYmxraWZfaW50ZXJy dXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAkJCQlibGtpZl9yZXEocmVxKS0+ZXJyb3IgPSBC TEtfU1RTX05PVFNVUFA7CiAJCQkJaW5mby0+ZmVhdHVyZV9kaXNjYXJkID0gMDsKIAkJCQlpbmZv LT5mZWF0dXJlX3NlY2Rpc2NhcmQgPSAwOwotCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfRElTQ0FSRCwgcnEpOwogCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdf U0VDRVJBU0UsIHJxKTsKIAkJCX0KIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay96cmFtL3pyYW1fZHJ2LmMgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwppbmRleCBl OTQ3NGIwMjAxMmRlLi41OWZmNDQ0YmY2Yzc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3py YW0venJhbV9kcnYuYworKysgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwpAQCAtMTk1 Miw3ICsxOTUyLDYgQEAgc3RhdGljIGludCB6cmFtX2FkZCh2b2lkKQogCWJsa19xdWV1ZV9pb19v cHQoenJhbS0+ZGlzay0+cXVldWUsIFBBR0VfU0laRSk7CiAJenJhbS0+ZGlzay0+cXVldWUtPmxp bWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gUEFHRV9TSVpFOwogCWJsa19xdWV1ZV9tYXhfZGlz Y2FyZF9zZWN0b3JzKHpyYW0tPmRpc2stPnF1ZXVlLCBVSU5UX01BWCk7Ci0JYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgenJhbS0+ZGlzay0+cXVldWUpOwogCiAJLyoKIAkg KiB6cmFtX2Jpb19kaXNjYXJkKCkgd2lsbCBjbGVhciBhbGwgbG9naWNhbCBibG9ja3MgaWYgbG9n aWNhbCBibG9jawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jIGIvZHJp dmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jCmluZGV4IGZkZDAxOTRmODRkZDAuLmUyN2Y2N2YwNmE0 MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYworKysgYi9kcml2ZXJz L21kL2JjYWNoZS9yZXF1ZXN0LmMKQEAgLTEwMDUsNyArMTAwNSw3IEBAIHN0YXRpYyB2b2lkIGNh Y2hlZF9kZXZfd3JpdGUoc3RydWN0IGNhY2hlZF9kZXYgKmRjLCBzdHJ1Y3Qgc2VhcmNoICpzKQog CQliaW9fZ2V0KHMtPmlvcC5iaW8pOwogCiAJCWlmIChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElT Q0FSRCAmJgotCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2 KSkpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGRjLT5iZGV2KSkKIAkJCWdvdG8g aW5zZXJ0X2RhdGE7CiAKIAkJLyogSS9PIHJlcXVlc3Qgc2VudCB0byBiYWNraW5nIGRldmljZSAq LwpAQCAtMTExNSw3ICsxMTE1LDcgQEAgc3RhdGljIHZvaWQgZGV0YWNoZWRfZGV2X2RvX3JlcXVl c3Qoc3RydWN0IGJjYWNoZV9kZXZpY2UgKmQsIHN0cnVjdCBiaW8gKmJpbywKIAliaW8tPmJpX3By aXZhdGUgPSBkZGlwOwogCiAJaWYgKChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYK LQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2KSkpCisJICAg ICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGMtPmJkZXYpKQogCQliaW8tPmJpX2VuZF9pbyhi aW8pOwogCWVsc2UKIAkJc3VibWl0X2Jpb19ub2FjY3QoYmlvKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWQvYmNhY2hlL3N1cGVyLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zdXBlci5jCmluZGV4IGJm M2RlMTQ5ZDNjOWYuLjJmNDllMzExNDJmNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hl L3N1cGVyLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYwpAQCAtOTczLDcgKzk3Myw2 IEBAIHN0YXRpYyBpbnQgYmNhY2hlX2RldmljZV9pbml0KHN0cnVjdCBiY2FjaGVfZGV2aWNlICpk LCB1bnNpZ25lZCBpbnQgYmxvY2tfc2l6ZSwKIAogCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX05PTlJPVCwgZC0+ZGlzay0+cXVldWUpOwogCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfQUREX1JBTkRPTSwgZC0+ZGlzay0+cXVldWUpOwotCWJsa19xdWV1ZV9mbGFnX3NldChR VUVVRV9GTEFHX0RJU0NBUkQsIGQtPmRpc2stPnF1ZXVlKTsKIAogCWJsa19xdWV1ZV93cml0ZV9j YWNoZShxLCB0cnVlLCB0cnVlKTsKIApAQCAtMjM1MCw3ICsyMzQ5LDcgQEAgc3RhdGljIGludCBy ZWdpc3Rlcl9jYWNoZShzdHJ1Y3QgY2FjaGVfc2IgKnNiLCBzdHJ1Y3QgY2FjaGVfc2JfZGlzayAq c2JfZGlzaywKIAljYS0+YmRldi0+YmRfaG9sZGVyID0gY2E7CiAJY2EtPnNiX2Rpc2sgPSBzYl9k aXNrOwogCi0JaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSkKKwlp ZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKChiZGV2KSkpCiAJCWNhLT5kaXNjYXJkID0gQ0FD SEVfRElTQ0FSRCgmY2EtPnNiKTsKIAogCXJldCA9IGNhY2hlX2FsbG9jKGNhKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWQvYmNhY2hlL3N5c2ZzLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zeXNmcy5j CmluZGV4IGQxMDI5ZDcxZmYzYmMuLmM2ZjY3NzA1OTIxNGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWQvYmNhY2hlL3N5c2ZzLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3lzZnMuYwpAQCAtMTE1 MSw3ICsxMTUxLDcgQEAgU1RPUkUoX19iY2hfY2FjaGUpCiAJaWYgKGF0dHIgPT0gJnN5c2ZzX2Rp c2NhcmQpIHsKIAkJYm9vbCB2ID0gc3RydG91bF9vcl9yZXR1cm4oYnVmKTsKIAotCQlpZiAoYmxr X3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoY2EtPmJkZXYpKSkKKwkJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhjYS0+YmRldikpCiAJCQljYS0+ZGlzY2FyZCA9IHY7CiAKIAkJaWYg KHYgIT0gQ0FDSEVfRElTQ0FSRCgmY2EtPnNiKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9k bS1jYWNoZS10YXJnZXQuYyBiL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMKaW5kZXggNzgw YTYxYmM2Y2MwMy4uMjhjNWRlOGVjYTRhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1jYWNo ZS10YXJnZXQuYworKysgYi9kcml2ZXJzL21kL2RtLWNhY2hlLXRhcmdldC5jCkBAIC0zMzI5LDEz ICszMzI5LDYgQEAgc3RhdGljIGludCBjYWNoZV9pdGVyYXRlX2RldmljZXMoc3RydWN0IGRtX3Rh cmdldCAqdGksCiAJcmV0dXJuIHI7CiB9CiAKLXN0YXRpYyBib29sIG9yaWdpbl9kZXZfc3VwcG9y dHNfZGlzY2FyZChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpvcmlnaW5fYmRldikKLXsKLQlzdHJ1Y3Qg cmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKG9yaWdpbl9iZGV2KTsKLQotCXJldHVy biBibGtfcXVldWVfZGlzY2FyZChxKTsKLX0KLQogLyoKICAqIElmIGRpc2NhcmRfcGFzc2Rvd24g d2FzIGVuYWJsZWQgdmVyaWZ5IHRoYXQgdGhlIG9yaWdpbiBkZXZpY2UKICAqIHN1cHBvcnRzIGRp c2NhcmRzLiAgRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlmIG5vdC4KQEAgLTMzNDksNyArMzM0 Miw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25faWZfbm90X3N1cHBvcnRlZChzdHJ1 Y3QgY2FjaGUgKmNhY2hlKQogCWlmICghY2FjaGUtPmZlYXR1cmVzLmRpc2NhcmRfcGFzc2Rvd24p CiAJCXJldHVybjsKIAotCWlmICghb3JpZ2luX2Rldl9zdXBwb3J0c19kaXNjYXJkKG9yaWdpbl9i ZGV2KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhvcmlnaW5fYmRldikpCiAJCXJl YXNvbiA9ICJkaXNjYXJkIHVuc3VwcG9ydGVkIjsKIAogCWVsc2UgaWYgKG9yaWdpbl9saW1pdHMt Pm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjYWNoZS0+c2VjdG9yc19wZXJfYmxvY2spCmRpZmYgLS1n aXQgYS9kcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jIGIvZHJpdmVycy9tZC9kbS1jbG9uZS10 YXJnZXQuYwppbmRleCAxMjgzMTZhNzNkMDE2Li44MTFiMGE1Mzc5ZDAzIDEwMDY0NAotLS0gYS9k cml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tY2xvbmUtdGFy Z2V0LmMKQEAgLTIwMTYsMTMgKzIwMTYsNiBAQCBzdGF0aWMgdm9pZCBjbG9uZV9yZXN1bWUoc3Ry dWN0IGRtX3RhcmdldCAqdGkpCiAJZG9fd2FrZXIoJmNsb25lLT53YWtlci53b3JrKTsKIH0KIAot c3RhdGljIGJvb2wgYmRldl9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2KQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoYmRldik7 Ci0KLQlyZXR1cm4gKHEgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQocSkpOwotfQotCiAvKgogICogSWYg ZGlzY2FyZF9wYXNzZG93biB3YXMgZW5hYmxlZCB2ZXJpZnkgdGhhdCB0aGUgZGVzdGluYXRpb24g ZGV2aWNlIHN1cHBvcnRzCiAgKiBkaXNjYXJkcy4gRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlm IG5vdC4KQEAgLTIwMzYsNyArMjAyOSw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25f aWZfbm90X3N1cHBvcnRlZChzdHJ1Y3QgY2xvbmUgKmNsb25lKQogCWlmICghdGVzdF9iaXQoRE1f Q0xPTkVfRElTQ0FSRF9QQVNTRE9XTiwgJmNsb25lLT5mbGFncykpCiAJCXJldHVybjsKIAotCWlm ICghYmRldl9zdXBwb3J0c19kaXNjYXJkcyhkZXN0X2RldikpCisJaWYgKCFiZGV2X21heF9kaXNj YXJkX3NlY3RvcnMoZGVzdF9kZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAJZWxzZSBpZiAoZGVzdF9saW1pdHMtPm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjbG9uZS0+cmVn aW9uX3NpemUpCiAJCXJlYXNvbiA9ICJtYXggZGlzY2FyZCBzZWN0b3JzIHNtYWxsZXIgdGhhbiBh IHJlZ2lvbiI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy13cml0ZXMuYyBiL2RyaXZl cnMvbWQvZG0tbG9nLXdyaXRlcy5jCmluZGV4IGM5ZDAzNmQ2YmIyZWUuLmUxOTQyMjZjODllNTQg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tbG9nLXdyaXRlcy5jCisrKyBiL2RyaXZlcnMvbWQv ZG0tbG9nLXdyaXRlcy5jCkBAIC04NjYsOSArODY2LDggQEAgc3RhdGljIGludCBsb2dfd3JpdGVz X21lc3NhZ2Uoc3RydWN0IGRtX3RhcmdldCAqdGksIHVuc2lnbmVkIGFyZ2MsIGNoYXIgKiphcmd2 LAogc3RhdGljIHZvaWQgbG9nX3dyaXRlc19pb19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRzKQogewogCXN0cnVjdCBsb2dfd3JpdGVzX2MgKmxj ID0gdGktPnByaXZhdGU7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1 ZShsYy0+ZGV2LT5iZGV2KTsKIAotCWlmICghcSB8fCAhYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsK KwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhsYy0+ZGV2LT5iZGV2KSkgewogCQlsYy0+ ZGV2aWNlX3N1cHBvcnRzX2Rpc2NhcmQgPSBmYWxzZTsKIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51 bGFyaXR5ID0gbGMtPnNlY3RvcnNpemU7CiAJCWxpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA9 IChVSU5UX01BWCA+PiBTRUNUT1JfU0hJRlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1y YWlkLmMgYi9kcml2ZXJzL21kL2RtLXJhaWQuYwppbmRleCAyYjI2NDM1YTY5NDZlLi45NTI2Y2Ni ZWRhZmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXJhaWQuYworKysgYi9kcml2ZXJzL21k L2RtLXJhaWQuYwpAQCAtMjk2MywxMyArMjk2Myw4IEBAIHN0YXRpYyB2b2lkIGNvbmZpZ3VyZV9k aXNjYXJkX3N1cHBvcnQoc3RydWN0IHJhaWRfc2V0ICpycykKIAlyYWlkNDU2ID0gcnNfaXNfcmFp ZDQ1Nihycyk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcnMtPnJhaWRfZGlza3M7IGkrKykgewotCQlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcTsKLQotCQlpZiAoIXJzLT5kZXZbaV0ucmRldi5iZGV2KQot CQkJY29udGludWU7Ci0KLQkJcSA9IGJkZXZfZ2V0X3F1ZXVlKHJzLT5kZXZbaV0ucmRldi5iZGV2 KTsKLQkJaWYgKCFxIHx8ICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwkJaWYgKCFycy0+ZGV2W2ld LnJkZXYuYmRldiB8fAorCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhycy0+ZGV2W2ld LnJkZXYuYmRldikpCiAJCQlyZXR1cm47CiAKIAkJaWYgKHJhaWQ0NTYpIHsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWQvZG0tdGFibGUuYyBiL2RyaXZlcnMvbWQvZG0tdGFibGUuYwppbmRleCBkNDY4 MzlmYWEwY2E1Li4wZGZmNjkwN2ZkMDBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXRhYmxl LmMKKysrIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCkBAIC0xODg4LDkgKzE4ODgsNyBAQCBzdGF0 aWMgYm9vbCBkbV90YWJsZV9zdXBwb3J0c19ub3dhaXQoc3RydWN0IGRtX3RhYmxlICp0KQogc3Rh dGljIGludCBkZXZpY2Vfbm90X2Rpc2NhcmRfY2FwYWJsZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IGRtX2RldiAqZGV2LAogCQkJCSAgICAgIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBs ZW4sIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9x dWV1ZShkZXYtPmJkZXYpOwotCi0JcmV0dXJuICFibGtfcXVldWVfZGlzY2FyZChxKTsKKwlyZXR1 cm4gIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPmJkZXYpOwogfQogCiBzdGF0aWMgYm9v bCBkbV90YWJsZV9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgZG1fdGFibGUgKnQpCkBAIC0xOTcw LDE1ICsxOTY4LDEyIEBAIGludCBkbV90YWJsZV9zZXRfcmVzdHJpY3Rpb25zKHN0cnVjdCBkbV90 YWJsZSAqdCwgc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsCiAJCWJsa19xdWV1ZV9mbGFnX2NsZWFy KFFVRVVFX0ZMQUdfTk9XQUlULCBxKTsKIAogCWlmICghZG1fdGFibGVfc3VwcG9ydHNfZGlzY2Fy ZHModCkpIHsKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsK LQkJLyogTXVzdCBhbHNvIGNsZWFyIGRpc2NhcmQgbGltaXRzLi4uICovCiAJCXEtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzID0gMDsKIAkJcS0+bGltaXRzLm1heF9od19kaXNjYXJkX3NlY3Rv cnMgPSAwOwogCQlxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IDA7CiAJCXEtPmxpbWl0 cy5kaXNjYXJkX2FsaWdubWVudCA9IDA7CiAJCXEtPmxpbWl0cy5kaXNjYXJkX21pc2FsaWduZWQg PSAwOwotCX0gZWxzZQotCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBx KTsKKwl9CiAKIAlpZiAoZG1fdGFibGVfc3VwcG9ydHNfc2VjdXJlX2VyYXNlKHQpKQogCQlibGtf cXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19TRUNFUkFTRSwgcSk7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kL2RtLXRoaW4uYyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCmluZGV4IDRkMjVkMGUyNzAz MTMuLmVkZWQ0YmNjNDU0NWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGhpbi5jCisrKyBi L2RyaXZlcnMvbWQvZG0tdGhpbi5jCkBAIC0yODAyLDEzICsyODAyLDYgQEAgc3RhdGljIHZvaWQg cmVxdWV1ZV9iaW9zKHN0cnVjdCBwb29sICpwb29sKQogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBCaW5kaW5nIG9m IGNvbnRyb2wgdGFyZ2V0cyB0byBhIHBvb2wgb2JqZWN0CiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLXN0YXRpYyBib29s IGRhdGFfZGV2X3N1cHBvcnRzX2Rpc2NhcmQoc3RydWN0IHBvb2xfYyAqcHQpCi17Ci0Jc3RydWN0 IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShwdC0+ZGF0YV9kZXYtPmJkZXYpOwot Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKHEpOwotfQotCiBzdGF0aWMgYm9vbCBpc19mYWN0 b3Ioc2VjdG9yX3QgYmxvY2tfc2l6ZSwgdWludDMyX3QgbikKIHsKIAlyZXR1cm4gIXNlY3Rvcl9k aXYoYmxvY2tfc2l6ZSwgbik7CkBAIC0yODI4LDcgKzI4MjEsNyBAQCBzdGF0aWMgdm9pZCBkaXNh YmxlX3Bhc3Nkb3duX2lmX25vdF9zdXBwb3J0ZWQoc3RydWN0IHBvb2xfYyAqcHQpCiAJaWYgKCFw dC0+YWRqdXN0ZWRfcGYuZGlzY2FyZF9wYXNzZG93bikKIAkJcmV0dXJuOwogCi0JaWYgKCFkYXRh X2Rldl9zdXBwb3J0c19kaXNjYXJkKHB0KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhwdC0+ZGF0YV9kZXYtPmJkZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAKIAllbHNlIGlmIChkYXRhX2xpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA8IHBvb2wtPnNl Y3RvcnNfcGVyX2Jsb2NrKQpAQCAtNDA1Nyw4ICs0MDUwLDYgQEAgc3RhdGljIHZvaWQgcG9vbF9p b19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgc3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRz KQogCQkvKgogCQkgKiBNdXN0IGV4cGxpY2l0bHkgZGlzYWxsb3cgc3RhY2tpbmcgZGlzY2FyZCBs aW1pdHMgb3RoZXJ3aXNlIHRoZQogCQkgKiBibG9jayBsYXllciB3aWxsIHN0YWNrIHRoZW0gaWYg cG9vbCdzIGRhdGEgZGV2aWNlIGhhcyBzdXBwb3J0LgotCQkgKiBRVUVVRV9GTEFHX0RJU0NBUkQg d291bGRuJ3QgYmUgc2V0IGJ1dCB0aGVyZSBpcyBubyB3YXkgZm9yIHRoZQotCQkgKiB1c2VyIHRv IHNlZSB0aGF0LCBzbyBtYWtlIHN1cmUgdG8gc2V0IGFsbCBkaXNjYXJkIGxpbWl0cyB0byAwLgog CQkgKi8KIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJcmV0dXJuOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9tZC9kbS5jIGIvZHJpdmVycy9tZC9kbS5jCmluZGV4IDNjNWZhZDdj NGVlNjguLmRiYmY2NGNlN2U5MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0uYworKysgYi9k cml2ZXJzL21kL2RtLmMKQEAgLTk1NSw3ICs5NTUsNiBAQCB2b2lkIGRpc2FibGVfZGlzY2FyZChz dHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCiAKIAkvKiBkZXZpY2UgZG9lc24ndCByZWFsbHkgc3Vw cG9ydCBESVNDQVJELCBkaXNhYmxlIGl0ICovCiAJbGltaXRzLT5tYXhfZGlzY2FyZF9zZWN0b3Jz ID0gMDsKLQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIG1kLT5xdWV1 ZSk7CiB9CiAKIHZvaWQgZGlzYWJsZV93cml0ZV96ZXJvZXMoc3RydWN0IG1hcHBlZF9kZXZpY2Ug Km1kKQpAQCAtOTgyLDcgKzk4MSw3IEBAIHN0YXRpYyB2b2lkIGNsb25lX2VuZGlvKHN0cnVjdCBi aW8gKmJpbykKIAogCWlmICh1bmxpa2VseShlcnJvciA9PSBCTEtfU1RTX1RBUkdFVCkpIHsKIAkJ aWYgKGJpb19vcChiaW8pID09IFJFUV9PUF9ESVNDQVJEICYmCi0JCSAgICAhcS0+bGltaXRzLm1h eF9kaXNjYXJkX3NlY3RvcnMpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+ YmlfYmRldikpCiAJCQlkaXNhYmxlX2Rpc2NhcmQobWQpOwogCQllbHNlIGlmIChiaW9fb3AoYmlv KSA9PSBSRVFfT1BfV1JJVEVfWkVST0VTICYmCiAJCQkgIXEtPmxpbWl0cy5tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLWxpbmVhci5jIGIvZHJpdmVy cy9tZC9tZC1saW5lYXIuYwppbmRleCAwZjU1YjA3OTM3MWIxLi4xMzhhM2IyNWM1YzgyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kL21kLWxpbmVhci5jCisrKyBiL2RyaXZlcnMvbWQvbWQtbGluZWFy LmMKQEAgLTY0LDcgKzY0LDYgQEAgc3RhdGljIHN0cnVjdCBsaW5lYXJfY29uZiAqbGluZWFyX2Nv bmYoc3RydWN0IG1kZGV2ICptZGRldiwgaW50IHJhaWRfZGlza3MpCiAJc3RydWN0IGxpbmVhcl9j b25mICpjb25mOwogCXN0cnVjdCBtZF9yZGV2ICpyZGV2OwogCWludCBpLCBjbnQ7Ci0JYm9vbCBk aXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJY29uZiA9IGt6YWxsb2Moc3RydWN0X3NpemUo Y29uZiwgZGlza3MsIHJhaWRfZGlza3MpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWNvbmYpCkBAIC05 Niw5ICs5NSw2IEBAIHN0YXRpYyBzdHJ1Y3QgbGluZWFyX2NvbmYgKmxpbmVhcl9jb25mKHN0cnVj dCBtZGRldiAqbWRkZXYsIGludCByYWlkX2Rpc2tzKQogCiAJCWNvbmYtPmFycmF5X3NlY3RvcnMg Kz0gcmRldi0+c2VjdG9yczsKIAkJY250Kys7Ci0KLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJk ZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsK IAl9CiAJaWYgKGNudCAhPSByYWlkX2Rpc2tzKSB7CiAJCXByX3dhcm4oIm1kL2xpbmVhcjolczog bm90IGVub3VnaCBkcml2ZXMgcHJlc2VudC4gQWJvcnRpbmchXG4iLApAQCAtMTA2LDExICsxMDIs NiBAQCBzdGF0aWMgc3RydWN0IGxpbmVhcl9jb25mICpsaW5lYXJfY29uZihzdHJ1Y3QgbWRkZXYg Km1kZGV2LCBpbnQgcmFpZF9kaXNrcykKIAkJZ290byBvdXQ7CiAJfQogCi0JaWYgKCFkaXNjYXJk X3N1cHBvcnRlZCkKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBt ZGRldi0+cXVldWUpOwotCWVsc2UKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElT Q0FSRCwgbWRkZXYtPnF1ZXVlKTsKLQogCS8qCiAJICogSGVyZSB3ZSBjYWxjdWxhdGUgdGhlIGRl dmljZSBvZmZzZXRzLgogCSAqLwpAQCAtMjUyLDcgKzI0Myw3IEBAIHN0YXRpYyBib29sIGxpbmVh cl9tYWtlX3JlcXVlc3Qoc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IGJpbyAqYmlvKQogCQlz dGFydF9zZWN0b3IgKyBkYXRhX29mZnNldDsKIAogCWlmICh1bmxpa2VseSgoYmlvX29wKGJpbykg PT0gUkVRX09QX0RJU0NBUkQpICYmCi0JCSAgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkgeworCQkgICAgICFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoYmlvLT5iaV9iZGV2KSkpIHsKIAkJLyogSnVzdCBpZ25vcmUgaXQgKi8KIAkJYmlvX2VuZGlv KGJpbyk7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDAuYyBiL2RyaXZl cnMvbWQvcmFpZDAuYwppbmRleCBiMjFlMTAxMTgzZjQ0Li43MjMxZjVlMWVhYTczIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQwLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMC5jCkBAIC0zOTks NyArMzk5LDYgQEAgc3RhdGljIGludCByYWlkMF9ydW4oc3RydWN0IG1kZGV2ICptZGRldikKIAlj b25mID0gbWRkZXYtPnByaXZhdGU7CiAJaWYgKG1kZGV2LT5xdWV1ZSkgewogCQlzdHJ1Y3QgbWRf cmRldiAqcmRldjsKLQkJYm9vbCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJCWJsa19x dWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2LT5jaHVua19zZWN0b3JzKTsK IAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2 LT5jaHVua19zZWN0b3JzKTsKQEAgLTQxMiwxMyArNDExLDcgQEAgc3RhdGljIGludCByYWlkMF9y dW4oc3RydWN0IG1kZGV2ICptZGRldikKIAkJcmRldl9mb3JfZWFjaChyZGV2LCBtZGRldikgewog CQkJZGlza19zdGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJCSAg cmRldi0+ZGF0YV9vZmZzZXQgPDwgOSk7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUocmRldi0+YmRldikpKQotCQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJ fQotCQlpZiAoIWRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVF VUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwotCQllbHNlCi0JCQlibGtfcXVldWVfZmxh Z19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCX0KIAogCS8qIGNhbGN1 bGF0ZSBhcnJheSBkZXZpY2Ugc2l6ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkMS5j IGIvZHJpdmVycy9tZC9yYWlkMS5jCmluZGV4IGQ4MWI4OTY4NTVmOWYuLjNkYTc0OWQxNTBhMTcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDEuYworKysgYi9kcml2ZXJzL21kL3JhaWQxLmMK QEAgLTgwMiw3ICs4MDIsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9iaW9fbGlzdChzdHJ1Y3QgcjFj b25mICpjb25mLCBzdHJ1Y3QgYmlvICpiaW8pCiAJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2 LT5mbGFncykpIHsKIAkJCWJpb19pb19lcnJvcihiaW8pOwogCQl9IGVsc2UgaWYgKHVubGlrZWx5 KChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9k aXNjYXJkKGJpby0+YmlfYmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICov CiAJCQliaW9fZW5kaW8oYmlvKTsKIAkJZWxzZQpAQCAtMTgyNiw4ICsxODI2LDYgQEAgc3RhdGlj IGludCByYWlkMV9hZGRfZGlzayhzdHJ1Y3QgbWRkZXYgKm1kZGV2LCBzdHJ1Y3QgbWRfcmRldiAq cmRldikKIAkJCWJyZWFrOwogCQl9CiAJfQotCWlmIChtZGRldi0+cXVldWUgJiYgYmxrX3F1ZXVl X2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQotCQlibGtfcXVldWVfZmxhZ19z ZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCXByaW50X2NvbmYoY29uZik7 CiAJcmV0dXJuIGVycjsKIH0KQEAgLTMxMDYsNyArMzEwNCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFf cnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJaW50IGk7CiAJc3RydWN0IG1kX3JkZXYgKnJkZXY7 CiAJaW50IHJldDsKLQlib29sIGRpc2NhcmRfc3VwcG9ydGVkID0gZmFsc2U7CiAKIAlpZiAobWRk ZXYtPmxldmVsICE9IDEpIHsKIAkJcHJfd2FybigibWQvcmFpZDE6JXM6IHJhaWQgbGV2ZWwgbm90 IHNldCB0byBtaXJyb3JpbmcgKCVkKVxuIiwKQEAgLTMxNDEsOCArMzEzOCw2IEBAIHN0YXRpYyBp bnQgcmFpZDFfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQljb250aW51ZTsKIAkJZGlza19z dGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJICByZGV2LT5kYXRh X29mZnNldCA8PCA5KTsKLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJk ZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAl9CiAKIAltZGRldi0+ ZGVncmFkZWQgPSAwOwpAQCAtMzE3OSwxNSArMzE3NCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFfcnVu KHN0cnVjdCBtZGRldiAqbWRkZXYpCiAKIAltZF9zZXRfYXJyYXlfc2VjdG9ycyhtZGRldiwgcmFp ZDFfc2l6ZShtZGRldiwgMCwgMCkpOwogCi0JaWYgKG1kZGV2LT5xdWV1ZSkgewotCQlpZiAoZGlz Y2FyZF9zdXBwb3J0ZWQpCi0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJE LAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIo UVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJICBtZGRldi0+cXVldWUpOwotCX0KLQogCXJldCA9 IG1kX2ludGVncml0eV9yZWdpc3RlcihtZGRldik7CiAJaWYgKHJldCkgewogCQltZF91bnJlZ2lz dGVyX3RocmVhZCgmbWRkZXYtPnRocmVhZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQx MC5jIGIvZHJpdmVycy9tZC9yYWlkMTAuYwppbmRleCA3ODE2YzhiMmU4MDg3Li4zNmE0NjAwMTVj ZjU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxMC5jCisrKyBiL2RyaXZlcnMvbWQvcmFp ZDEwLmMKQEAgLTg4OCw3ICs4ODgsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9wZW5kaW5nX3dyaXRl cyhzdHJ1Y3QgcjEwY29uZiAqY29uZikKIAkJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5m bGFncykpIHsKIAkJCQliaW9faW9fZXJyb3IoYmlvKTsKIAkJCX0gZWxzZSBpZiAodW5saWtlbHko KGJpb19vcChiaW8pID09ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkJICAgICFibGtfcXVldWVf ZGlzY2FyZChiaW8tPmJpX2JkZXYtPmJkX2Rpc2stPnF1ZXVlKSkpCisJCQkJCSAgICAhYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+YmlfYmRldikpKQogCQkJCS8qIEp1c3QgaWdub3JlIGl0 ICovCiAJCQkJYmlvX2VuZGlvKGJpbyk7CiAJCQllbHNlCkBAIC0xMDgzLDcgKzEwODMsNyBAQCBz dGF0aWMgdm9pZCByYWlkMTBfdW5wbHVnKHN0cnVjdCBibGtfcGx1Z19jYiAqY2IsIGJvb2wgZnJv bV9zY2hlZHVsZSkKIAkJaWYgKHRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkgewogCQkJ YmlvX2lvX2Vycm9yKGJpbyk7CiAJCX0gZWxzZSBpZiAodW5saWtlbHkoKGJpb19vcChiaW8pID09 ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICovCiAJCQliaW9fZW5kaW8o YmlvKTsKIAkJZWxzZQpAQCAtMjE0NCw4ICsyMTQ0LDYgQEAgc3RhdGljIGludCByYWlkMTBfYWRk X2Rpc2soc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IG1kX3JkZXYgKnJkZXYpCiAJCXJjdV9h c3NpZ25fcG9pbnRlcihwLT5yZGV2LCByZGV2KTsKIAkJYnJlYWs7CiAJfQotCWlmIChtZGRldi0+ cXVldWUgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQot CQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwog CiAJcHJpbnRfY29uZihjb25mKTsKIAlyZXR1cm4gZXJyOwpAQCAtNDA2OSw3ICs0MDY3LDYgQEAg c3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJc2VjdG9yX3Qgc2l6 ZTsKIAlzZWN0b3JfdCBtaW5fb2Zmc2V0X2RpZmYgPSAwOwogCWludCBmaXJzdCA9IDE7Ci0JYm9v bCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJaWYgKG1kZGV2X2luaXRfd3JpdGVzX3Bl bmRpbmcobWRkZXYpIDwgMCkKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC00MTQwLDIwICs0MTM3LDkg QEAgc3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQkJCSAgcmRl di0+ZGF0YV9vZmZzZXQgPDwgOSk7CiAKIAkJZGlzay0+aGVhZF9wb3NpdGlvbiA9IDA7Ci0KLQkJ aWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRp c2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJZmlyc3QgPSAwOwogCX0KIAotCWlmIChtZGRldi0+ cXVldWUpIHsKLQkJaWYgKGRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCW1kZGV2LT5xdWV1ZSk7Ci0JCWVsc2UKLQkJCWJs a19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCSAgbWRkZXYtPnF1 ZXVlKTsKLQl9CiAJLyogbmVlZCB0byBjaGVjayB0aGF0IGV2ZXJ5IGJsb2NrIGhhcyBhdCBsZWFz dCBvbmUgd29ya2luZyBtaXJyb3IgKi8KIAlpZiAoIWVub3VnaChjb25mLCAtMSkpIHsKIAkJcHJf ZXJyKCJtZC9yYWlkMTA6JXM6IG5vdCBlbm91Z2ggb3BlcmF0aW9uYWwgbWlycm9ycy5cbiIsCmRp ZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQ1LWNhY2hlLmMgYi9kcml2ZXJzL21kL3JhaWQ1LWNh Y2hlLmMKaW5kZXggYTdkNTBmZjkwMjBhOC4uYzNjYmY5YTU3NGEzOSAxMDA2NDQKLS0tIGEvZHJp dmVycy9tZC9yYWlkNS1jYWNoZS5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDUtY2FjaGUuYwpAQCAt MTMxOCw3ICsxMzE4LDcgQEAgc3RhdGljIHZvaWQgcjVsX3dyaXRlX3N1cGVyX2FuZF9kaXNjYXJk X3NwYWNlKHN0cnVjdCByNWxfbG9nICpsb2csCiAKIAlyNWxfd3JpdGVfc3VwZXIobG9nLCBlbmQp OwogCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShiZGV2KSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCXJldHVybjsKIAogCW1kZGV2ID0g bG9nLT5yZGV2LT5tZGRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDUuYyBiL2RyaXZl cnMvbWQvcmFpZDUuYwppbmRleCAwYmJhZTBlNjM4NjY2Li41OWY5MWUzOTJhMmFlIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQ1LmMKKysrIGIvZHJpdmVycy9tZC9yYWlkNS5jCkBAIC03Nzc2 LDE0ICs3Nzc2LDEwIEBAIHN0YXRpYyBpbnQgcmFpZDVfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYp CiAJCSAqIEEgYmV0dGVyIGlkZWEgbWlnaHQgYmUgdG8gdHVybiBESVNDQVJEIGludG8gV1JJVEVf WkVST0VTCiAJCSAqIHJlcXVlc3RzLCBhcyB0aGF0IGlzIHJlcXVpcmVkIHRvIGJlIHNhZmUuCiAJ CSAqLwotCQlpZiAoZGV2aWNlc19oYW5kbGVfZGlzY2FyZF9zYWZlbHkgJiYKLQkJICAgIG1kZGV2 LT5xdWV1ZS0+bGltaXRzLm1heF9kaXNjYXJkX3NlY3RvcnMgPj0gKHN0cmlwZSA+PiA5KSAmJgot CQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA+PSBzdHJpcGUp Ci0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJbWRkZXYt PnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVND QVJELAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKKwkJaWYgKCFkZXZpY2VzX2hhbmRsZV9kaXNjYXJk X3NhZmVseSB8fAorCQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9y cyA8IChzdHJpcGUgPj4gOSkgfHwKKwkJICAgIG1kZGV2LT5xdWV1ZS0+bGltaXRzLmRpc2NhcmRf Z3JhbnVsYXJpdHkgPCBzdHJpcGUpCisJCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyht ZGRldi0+cXVldWUsIDApOwogCiAJCWJsa19xdWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVl dWUsIFVJTlRfTUFYKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMg Yi9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMKaW5kZXggYzY5YjJkOWRmNmYxNi4uY2FjNjMxNTAx MGEzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9xdWV1ZS5jCisrKyBiL2RyaXZlcnMv bW1jL2NvcmUvcXVldWUuYwpAQCAtMTgzLDcgKzE4Myw2IEBAIHN0YXRpYyB2b2lkIG1tY19xdWV1 ZV9zZXR1cF9kaXNjYXJkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLAogCWlmICghbWF4X2Rpc2Nh cmQpCiAJCXJldHVybjsKIAotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFHX0RJU0NBUkQs IHEpOwogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIG1heF9kaXNjYXJkKTsKIAlx LT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IGNhcmQtPnByZWZfZXJhc2UgPDwgOTsKIAkv KiBncmFudWxhcml0eSBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gbWF4LiBkaXNjYXJkICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jIGIvZHJpdmVycy9tdGQvbXRkX2Js a2RldnMuYwppbmRleCA2NGQyYjA5M2YxMTRiLi5mNzMxNzIxMTE0NjU1IDEwMDY0NAotLS0gYS9k cml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jCisrKyBiL2RyaXZlcnMvbXRkL210ZF9ibGtkZXZzLmMK QEAgLTM3Nyw3ICszNzcsNiBAQCBpbnQgYWRkX210ZF9ibGt0cmFuc19kZXYoc3RydWN0IG10ZF9i bGt0cmFuc19kZXYgKm5ldykKIAlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0FERF9S QU5ET00sIG5ldy0+cnEpOwogCiAJaWYgKHRyLT5kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFn X3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIG5ldy0+cnEpOwogCQlibGtfcXVldWVfbWF4X2Rpc2Nh cmRfc2VjdG9ycyhuZXctPnJxLCBVSU5UX01BWCk7CiAJCW5ldy0+cnEtPmxpbWl0cy5kaXNjYXJk X2dyYW51bGFyaXR5ID0gdHItPmJsa3NpemU7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l L2hvc3QvY29yZS5jIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCmluZGV4IGVmYjg1YzZkOGUy ZDUuLjdlMDdkZDY5MjYyYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwor KysgYi9kcml2ZXJzL252bWUvaG9zdC9jb3JlLmMKQEAgLTE2MDcsMTAgKzE2MDcsOCBAQCBzdGF0 aWMgdm9pZCBudm1lX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBzdHJ1Y3Qg bnZtZV9ucyAqbnMpCiAJc3RydWN0IHJlcXVlc3RfcXVldWUgKnF1ZXVlID0gZGlzay0+cXVldWU7 CiAJdTMyIHNpemUgPSBxdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUocXVldWUpOwogCi0JaWYgKGN0 cmwtPm1heF9kaXNjYXJkX3NlY3RvcnMgPT0gMCkgewotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKTsKKwlpZiAoY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9y cyA9PSAwKQogCQlyZXR1cm47Ci0JfQogCiAJQlVJTERfQlVHX09OKFBBR0VfU0laRSAvIHNpemVv ZihzdHJ1Y3QgbnZtZV9kc21fcmFuZ2UpIDwKIAkJCU5WTUVfRFNNX01BWF9SQU5HRVMpOwpAQCAt MTYxOSw3ICsxNjE3LDcgQEAgc3RhdGljIHZvaWQgbnZtZV9jb25maWdfZGlzY2FyZChzdHJ1Y3Qg Z2VuZGlzayAqZGlzaywgc3RydWN0IG52bWVfbnMgKm5zKQogCXF1ZXVlLT5saW1pdHMuZGlzY2Fy ZF9ncmFudWxhcml0eSA9IHNpemU7CiAKIAkvKiBJZiBkaXNjYXJkIGlzIGFscmVhZHkgZW5hYmxl ZCwgZG9uJ3QgcmVzZXQgcXVldWUgbGltaXRzICovCi0JaWYgKGJsa19xdWV1ZV9mbGFnX3Rlc3Rf YW5kX3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKSkKKwlpZiAocXVldWUtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzKQogCQlyZXR1cm47CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRf c2VjdG9ycyhxdWV1ZSwgY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9ycyk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3MzOTAvYmxvY2svZGFzZF9mYmEuYyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCmluZGV4IGUwODRmNGRlZGRkZGQuLjhiZDU2NjVkYjkxOTggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvczM5MC9ibG9jay9kYXNkX2ZiYS5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCkBAIC03OTEsNyArNzkxLDYgQEAgc3RhdGljIHZvaWQgZGFzZF9mYmFfc2V0dXBfYmxrX3F1 ZXVlKHN0cnVjdCBkYXNkX2Jsb2NrICpibG9jaykKIAogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9z ZWN0b3JzKHEsIG1heF9kaXNjYXJkX3NlY3RvcnMpOwogCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMocSwgbWF4X2Rpc2NhcmRfc2VjdG9ycyk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBpbnQgZGFzZF9mYmFfcGVfaGFu ZGxlcihzdHJ1Y3QgZGFzZF9kZXZpY2UgKmRldmljZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2Nz aS9zZC5jIGIvZHJpdmVycy9zY3NpL3NkLmMKaW5kZXggYTM5MDY3OWNmNDU4NC4uNDQ0NDc5NjU3 YjdmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NkLmMKKysrIGIvZHJpdmVycy9zY3NpL3Nk LmMKQEAgLTc5Nyw3ICs3OTcsNiBAQCBzdGF0aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1 Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25lZCBpbnQgbW9kZSkKIAljYXNlIFNEX0xCUF9GVUxM OgogCWNhc2UgU0RfTEJQX0RJU0FCTEU6CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3Jz KHEsIDApOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwog CQlyZXR1cm47CiAKIAljYXNlIFNEX0xCUF9VTk1BUDoKQEAgLTgzMCw3ICs4MjksNiBAQCBzdGF0 aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25l ZCBpbnQgbW9kZSkKIAl9CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCBtYXhf YmxvY2tzICogKGxvZ2ljYWxfYmxvY2tfc2l6ZSA+PiA5KSk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBibGtfc3RhdHVzX3Qgc2Rfc2V0 dXBfdW5tYXBfY21uZChzdHJ1Y3Qgc2NzaV9jbW5kICpjbWQpCmRpZmYgLS1naXQgYS9kcml2ZXJz L3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3Jl X2RldmljZS5jCmluZGV4IGMzZTI1YmFjOTBkNTkuLjZjYjlmODc4NDMyNzggMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0 L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC04MzgsNyArODM4LDcgQEAgYm9vbCB0YXJnZXRfY29u ZmlndXJlX3VubWFwX2Zyb21fcXVldWUoc3RydWN0IHNlX2Rldl9hdHRyaWIgKmF0dHJpYiwKIAlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwogCWludCBibG9j a19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmRldik7CiAKLQlpZiAoIWJsa19xdWV1 ZV9kaXNjYXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQly ZXR1cm4gZmFsc2U7CiAKIAlhdHRyaWItPm1heF91bm1hcF9sYmFfY291bnQgPQpkaWZmIC0tZ2l0 IGEvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKaW5kZXgg ZjQ3NzAzNWEyYWMyMy4uZWZkOGRlYjNhYjdlOCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50 LXRyZWUuYworKysgYi9mcy9idHJmcy9leHRlbnQtdHJlZS5jCkBAIC0xMjkxLDcgKzEyOTEsNyBA QCBzdGF0aWMgaW50IGRvX2Rpc2NhcmRfZXh0ZW50KHN0cnVjdCBidHJmc19pb19zdHJpcGUgKnN0 cmlwZSwgdTY0ICpieXRlcykKIAkJcmV0ID0gYnRyZnNfcmVzZXRfZGV2aWNlX3pvbmUoZGV2X3Jl cGxhY2UtPnRndGRldiwgcGh5cywgbGVuLAogCQkJCQkgICAgICAmZGlzY2FyZGVkKTsKIAkJZGlz Y2FyZGVkICs9IHNyY19kaXNjOwotCX0gZWxzZSBpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUoc3RyaXBlLT5kZXYtPmJkZXYpKSkgeworCX0gZWxzZSBpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHN0cmlwZS0+ZGV2LT5iZGV2KSkgewogCQlyZXQgPSBidHJmc19pc3N1ZV9k aXNjYXJkKGRldi0+YmRldiwgcGh5cywgbGVuLCAmZGlzY2FyZGVkKTsKIAl9IGVsc2UgewogCQly ZXQgPSAwOwpAQCAtNTk4Nyw3ICs1OTg3LDcgQEAgc3RhdGljIGludCBidHJmc190cmltX2ZyZWVf ZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2UsIHU2NCAqdHJpbW1lZCkKIAkqdHJp bW1lZCA9IDA7CiAKIAkvKiBEaXNjYXJkIG5vdCBzdXBwb3J0ZWQgPSBub3RoaW5nIHRvIGRvLiAq LwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoZGV2aWNlLT5iZGV2KSkp CisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGV2aWNlLT5iZGV2KSkKIAkJcmV0dXJu IDA7CiAKIAkvKiBOb3Qgd3JpdGFibGUgPSBub3RoaW5nIHRvIGRvLiAqLwpkaWZmIC0tZ2l0IGEv ZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggZjQ2ZTcxMDYxOTQyZC4u MDk2YmIwZGEwM2YxYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJm cy9pb2N0bC5jCkBAIC01MDEsNyArNTAxLDcgQEAgc3RhdGljIG5vaW5saW5lIGludCBidHJmc19p b2N0bF9maXRyaW0oc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8sCiAJCWlmICghZGV2aWNl LT5iZGV2KQogCQkJY29udGludWU7CiAJCXEgPSBiZGV2X2dldF9xdWV1ZShkZXZpY2UtPmJkZXYp OwotCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwkJaWYgKGJkZXZfbWF4X2Rpc2NhcmRf c2VjdG9ycyhkZXZpY2UtPmJkZXYpKSB7CiAJCQludW1fZGV2aWNlcysrOwogCQkJbWlubGVuID0g bWluX3QodTY0LCBxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSwKIAkJCQkgICAgIG1pbmxl bik7CmRpZmYgLS1naXQgYS9mcy9leGZhdC9maWxlLmMgYi9mcy9leGZhdC9maWxlLmMKaW5kZXgg MmY1MTMwMDU5MjM2Ni4uNzY1ZTRmNjNkZDE4ZCAxMDA2NDQKLS0tIGEvZnMvZXhmYXQvZmlsZS5j CisrKyBiL2ZzL2V4ZmF0L2ZpbGUuYwpAQCAtMzU4LDcgKzM1OCw3IEBAIHN0YXRpYyBpbnQgZXhm YXRfaW9jdGxfZml0cmltKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHVuc2lnbmVkIGxvbmcgYXJnKQog CWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0dXJuIC1FUEVSTTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoaW5v ZGUtPmlfc2ItPnNfYmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zy b21fdXNlcigmcmFuZ2UsIChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZywgc2l6ZW9m KHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy9leGZhdC9zdXBlci5jIGIvZnMvZXhmYXQvc3VwZXIu YwppbmRleCA4Y2EyMWU3OTE3ZDE2Li5iZTA3ODhlY2FmMjBlIDEwMDY0NAotLS0gYS9mcy9leGZh dC9zdXBlci5jCisrKyBiL2ZzL2V4ZmF0L3N1cGVyLmMKQEAgLTYyNywxMyArNjI3LDkgQEAgc3Rh dGljIGludCBleGZhdF9maWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBm c19jb250ZXh0ICpmYykKIAlpZiAob3B0cy0+YWxsb3dfdXRpbWUgPT0gKHVuc2lnbmVkIHNob3J0 KS0xKQogCQlvcHRzLT5hbGxvd191dGltZSA9IH5vcHRzLT5mc19kbWFzayAmIDAwMjI7CiAKLQlp ZiAob3B0cy0+ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0 X3F1ZXVlKHNiLT5zX2JkZXYpOwotCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJ CWV4ZmF0X3dhcm4oc2IsICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRo ZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JCQlvcHRzLT5kaXNjYXJkID0g MDsKLQkJfQorCWlmIChvcHRzLT5kaXNjYXJkICYmICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMo c2ItPnNfYmRldikpIHsKKwkJZXhmYXRfd2FybihzYiwgIm1vdW50aW5nIHdpdGggXCJkaXNjYXJk XCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2NhcmQiKTsKKwkJ b3B0cy0+ZGlzY2FyZCA9IDA7CiAJfQogCiAJc2ItPnNfZmxhZ3MgfD0gU0JfTk9ESVJBVElNRTsK ZGlmZiAtLWdpdCBhL2ZzL2V4dDQvaW9jdGwuYyBiL2ZzL2V4dDQvaW9jdGwuYwppbmRleCA5OTIy MjljYTJkODMwLi42ZTNiOWVlYTEyNmY0IDEwMDY0NAotLS0gYS9mcy9leHQ0L2lvY3RsLmMKKysr IGIvZnMvZXh0NC9pb2N0bC5jCkBAIC0xMDQ0LDcgKzEwNDQsNiBAQCBzdGF0aWMgaW50IGV4dDRf aW9jdGxfY2hlY2twb2ludChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJ X191MzIgZmxhZ3MgPSAwOwogCXVuc2lnbmVkIGludCBmbHVzaF9mbGFncyA9IDA7CiAJc3RydWN0 IHN1cGVyX2Jsb2NrICpzYiA9IGZpbGVfaW5vZGUoZmlscCktPmlfc2I7Ci0Jc3RydWN0IHJlcXVl c3RfcXVldWUgKnE7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIoJmZsYWdzLCAoX191MzIgX191c2Vy ICopYXJnLAogCQkJCXNpemVvZihfX3UzMikpKQpAQCAtMTA2NSwxMCArMTA2NCw4IEBAIHN0YXRp YyBpbnQgZXh0NF9pb2N0bF9jaGVja3BvaW50KHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBs b25nIGFyZykKIAlpZiAoZmxhZ3MgJiB+RVhUNF9JT0NfQ0hFQ0tQT0lOVF9GTEFHX1ZBTElEKQog CQlyZXR1cm4gLUVJTlZBTDsKIAotCXEgPSBiZGV2X2dldF9xdWV1ZShFWFQ0X1NCKHNiKS0+c19q b3VybmFsLT5qX2Rldik7Ci0JaWYgKCFxKQotCQlyZXR1cm4gLUVOWElPOwotCWlmICgoZmxhZ3Mg JiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYgIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQor CWlmICgoZmxhZ3MgJiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYKKwkgICAgIWJkZXZf bWF4X2Rpc2NhcmRfc2VjdG9ycyhFWFQ0X1NCKHNiKS0+c19qb3VybmFsLT5qX2RldikpCiAJCXJl dHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChmbGFncyAmIEVYVDRfSU9DX0NIRUNLUE9JTlRfRkxB R19EUllfUlVOKQpAQCAtMTM5MywxNCArMTM5MCwxMyBAQCBzdGF0aWMgbG9uZyBfX2V4dDRfaW9j dGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJn KQogCiAJY2FzZSBGSVRSSU06CiAJewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZf Z2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQlzdHJ1Y3QgZnN0cmltX3JhbmdlIHJhbmdlOwogCQlp bnQgcmV0ID0gMDsKIAogCQlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCQlyZXR1cm4g LUVQRVJNOwogCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCWlmICghYmRldl9tYXhf ZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCiAJ CS8qCmRpZmYgLS1naXQgYS9mcy9leHQ0L3N1cGVyLmMgYi9mcy9leHQ0L3N1cGVyLmMKaW5kZXgg ODE3NDllYWRkZjRjMS4uOTNmNGU0ZTllMjYzMSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9zdXBlci5j CisrKyBiL2ZzL2V4dDQvc3VwZXIuYwpAQCAtNTQ1OCwxMyArNTQ1OCw5IEBAIHN0YXRpYyBpbnQg X19leHQ0X2ZpbGxfc3VwZXIoc3RydWN0IGZzX2NvbnRleHQgKmZjLCBzdHJ1Y3Qgc3VwZXJfYmxv Y2sgKnNiKQogCQkJZ290byBmYWlsZWRfbW91bnQ5OwogCX0KIAotCWlmICh0ZXN0X29wdChzYiwg RElTQ0FSRCkpIHsKLQkJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShz Yi0+c19iZGV2KTsKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJCWV4dDRfbXNnKHNi LCBLRVJOX1dBUk5JTkcsCi0JCQkJICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwg YnV0ICIKLQkJCQkgInRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JfQor CWlmICh0ZXN0X29wdChzYiwgRElTQ0FSRCkgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhz Yi0+c19iZGV2KSkKKwkJZXh0NF9tc2coc2IsIEtFUk5fV0FSTklORywKKwkJCSAibW91bnRpbmcg d2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCB0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQg ZGlzY2FyZCIpOwogCiAJaWYgKGVzLT5zX2Vycm9yX2NvdW50KQogCQltb2RfdGltZXIoJnNiaS0+ c19lcnJfcmVwb3J0LCBqaWZmaWVzICsgMzAwKkhaKTsgLyogNSBtaW51dGVzICovCmRpZmYgLS1n aXQgYS9mcy9mMmZzL2YyZnMuaCBiL2ZzL2YyZnMvZjJmcy5oCmluZGV4IGNkMWU2NWJjZjBiMDQu LjBlYTlhNWZhN2MxZGQgMTAwNjQ0Ci0tLSBhL2ZzL2YyZnMvZjJmcy5oCisrKyBiL2ZzL2YyZnMv ZjJmcy5oCkBAIC00MzgxLDggKzQzODEsNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgZjJmc19od19z aG91bGRfZGlzY2FyZChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkpCiAKIHN0YXRpYyBpbmxpbmUg Ym9vbCBmMmZzX2JkZXZfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYp CiB7Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSB8fAot CSAgICAgICBiZGV2X2lzX3pvbmVkKGJkZXYpOworCXJldHVybiBiZGV2X21heF9kaXNjYXJkX3Nl Y3RvcnMoYmRldikgfHwgYmRldl9pc196b25lZChiZGV2KTsKIH0KIAogc3RhdGljIGlubGluZSBi b29sIGYyZnNfaHdfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSkKZGlm ZiAtLWdpdCBhL2ZzL2ZhdC9maWxlLmMgYi9mcy9mYXQvZmlsZS5jCmluZGV4IGE1YTMwOWZjYzdm YWYuLmU0YzdkMTBlODAxMjkgMTAwNjQ0Ci0tLSBhL2ZzL2ZhdC9maWxlLmMKKysrIGIvZnMvZmF0 L2ZpbGUuYwpAQCAtMTMzLDcgKzEzMyw3IEBAIHN0YXRpYyBpbnQgZmF0X2lvY3RsX2ZpdHJpbShz dHJ1Y3QgaW5vZGUgKmlub2RlLCB1bnNpZ25lZCBsb25nIGFyZykKIAlpZiAoIWNhcGFibGUoQ0FQ X1NZU19BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJk KHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAl1c2VyX3JhbmdlID0gKHN0cnVjdCBmc3RyaW1fcmFuZ2UgX191 c2VyICopYXJnOwpkaWZmIC0tZ2l0IGEvZnMvZmF0L2lub2RlLmMgYi9mcy9mYXQvaW5vZGUuYwpp bmRleCBiZjYwNTFiZGYxZDFkLi4zZDFhZmI5NWE5MjVhIDEwMDY0NAotLS0gYS9mcy9mYXQvaW5v ZGUuYworKysgYi9mcy9mYXQvaW5vZGUuYwpAQCAtMTg3MiwxMyArMTg3Miw5IEBAIGludCBmYXRf ZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpkYXRhLCBpbnQgc2lsZW50 LCBpbnQgaXN2ZmF0LAogCQlnb3RvIG91dF9mYWlsOwogCX0KIAotCWlmIChzYmktPm9wdGlvbnMu ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNi LT5zX2JkZXYpOwotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQotCQkJZmF0X21zZyhzYiwg S0VSTl9XQVJOSU5HLAotCQkJCQkibW91bnRpbmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1 dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCX0KKwlp ZiAoc2JpLT5vcHRpb25zLmRpc2NhcmQgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhzYi0+ c19iZGV2KSkKKwkJZmF0X21zZyhzYiwgS0VSTl9XQVJOSU5HLAorCQkJIm1vdW50aW5nIHdpdGgg XCJkaXNjYXJkXCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2Nh cmQiKTsKIAogCWZhdF9zZXRfc3RhdGUoc2IsIDEsIDApOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0 IGEvZnMvZ2ZzMi9yZ3JwLmMgYi9mcy9nZnMyL3JncnAuYwppbmRleCA4MDFhZDlmNGYyYmVmLi43 ZjIwYWM5MTMzYmM2IDEwMDY0NAotLS0gYS9mcy9nZnMyL3JncnAuYworKysgYi9mcy9nZnMyL3Jn cnAuYwpAQCAtMTQwNSw3ICsxNDA1LDcgQEAgaW50IGdmczJfZml0cmltKHN0cnVjdCBmaWxlICpm aWxwLCB2b2lkIF9fdXNlciAqYXJncCkKIAlpZiAoIXRlc3RfYml0KFNERl9KT1VSTkFMX0xJVkUs ICZzZHAtPnNkX2ZsYWdzKSkKIAkJcmV0dXJuIC1FUk9GUzsKIAotCWlmICghYmxrX3F1ZXVlX2Rp c2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2RwLT5zZF92ZnMtPnNf YmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmciwg YXJncCwgc2l6ZW9mKHIpKSkKZGlmZiAtLWdpdCBhL2ZzL2piZDIvam91cm5hbC5jIGIvZnMvamJk Mi9qb3VybmFsLmMKaW5kZXggZmNhY2FmYTQ1MTBkMS4uMTlkMjI2Y2Q0ZmY0ZCAxMDA2NDQKLS0t IGEvZnMvamJkMi9qb3VybmFsLmMKKysrIGIvZnMvamJkMi9qb3VybmFsLmMKQEAgLTE3NjIsNyAr MTc2Miw2IEBAIHN0YXRpYyBpbnQgX19qYmQyX2pvdXJuYWxfZXJhc2Uoam91cm5hbF90ICpqb3Vy bmFsLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJdW5zaWduZWQgbG9uZyBibG9jaywgbG9nX29mZnNl dDsgLyogbG9naWNhbCAqLwogCXVuc2lnbmVkIGxvbmcgbG9uZyBwaHlzX2Jsb2NrLCBibG9ja19z dGFydCwgYmxvY2tfc3RvcDsgLyogcGh5c2ljYWwgKi8KIAlsb2ZmX3QgYnl0ZV9zdGFydCwgYnl0 ZV9zdG9wLCBieXRlX2NvdW50OwotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRf cXVldWUoam91cm5hbC0+al9kZXYpOwogCiAJLyogZmxhZ3MgbXVzdCBiZSBzZXQgdG8gZWl0aGVy IGRpc2NhcmQgb3IgemVyb291dCAqLwogCWlmICgoZmxhZ3MgJiB+SkJEMl9KT1VSTkFMX0ZMVVNI X1ZBTElEKSB8fCAhZmxhZ3MgfHwKQEAgLTE3NzAsMTAgKzE3NjksOCBAQCBzdGF0aWMgaW50IF9f amJkMl9qb3VybmFsX2VyYXNlKGpvdXJuYWxfdCAqam91cm5hbCwgdW5zaWduZWQgaW50IGZsYWdz KQogCQkJKGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX1pFUk9PVVQpKSkKIAkJcmV0dXJuIC1F SU5WQUw7CiAKLQlpZiAoIXEpCi0JCXJldHVybiAtRU5YSU87Ci0KLQlpZiAoKGZsYWdzICYgSkJE Ml9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwlpZiAo KGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmCisJICAgICFiZGV2X21heF9k aXNjYXJkX3NlY3RvcnMoam91cm5hbC0+al9kZXYpKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAK IAkvKgpkaWZmIC0tZ2l0IGEvZnMvamZzL2lvY3RsLmMgYi9mcy9qZnMvaW9jdGwuYwppbmRleCAw M2E4NDVhYjRmMDA5Li4zNTdhZTZlNWMzNmVjIDEwMDY0NAotLS0gYS9mcy9qZnMvaW9jdGwuYwor KysgYi9mcy9qZnMvaW9jdGwuYwpAQCAtMTE3LDcgKzExNyw3IEBAIGxvbmcgamZzX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIAkJ aWYgKCFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQogCQkJcmV0dXJuIC1FUEVSTTsKIAotCQlpZiAo IWJsa19xdWV1ZV9kaXNjYXJkKHEpKSB7CisJCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KHNiLT5zX2JkZXYpKSB7CiAJCQlqZnNfd2FybigiRklUUklNIG5vdCBzdXBwb3J0ZWQgb24gZGV2 aWNlIik7CiAJCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJCX0KZGlmZiAtLWdpdCBhL2ZzL2pmcy9z dXBlci5jIGIvZnMvamZzL3N1cGVyLmMKaW5kZXggZjFhMTNhNzRjZGRmMy4uODVkNGY0NGYyYWM0 ZCAxMDA2NDQKLS0tIGEvZnMvamZzL3N1cGVyLmMKKysrIGIvZnMvamZzL3N1cGVyLmMKQEAgLTM3 MiwxOSArMzcyLDE2IEBAIHN0YXRpYyBpbnQgcGFyc2Vfb3B0aW9ucyhjaGFyICpvcHRpb25zLCBz dHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzNjQgKm5ld0xWU2l6ZSwKIAkJfQogCiAJCWNhc2UgT3B0 X2Rpc2NhcmQ6Ci0JCXsKLQkJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVl dWUoc2ItPnNfYmRldik7CiAJCQkvKiBpZiBzZXQgdG8gMSwgZXZlbiBjb3B5aW5nIGZpbGVzIHdp bGwgY2F1c2UKIAkJCSAqIHRyaW1taW5nIDpPCiAJCQkgKiAtPiB1c2VyIGhhcyBtb3JlIGNvbnRy b2wgb3ZlciB0aGUgb25saW5lIHRyaW1taW5nCiAJCQkgKi8KIAkJCXNiaS0+bWluYmxrc190cmlt ID0gNjQ7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCQlpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJCSpmbGFnIHw9IEpGU19ESVNDQVJEOwogCQkJ ZWxzZQogCQkJCXByX2VycigiSkZTOiBkaXNjYXJkIG9wdGlvbiBub3Qgc3VwcG9ydGVkIG9uIGRl dmljZVxuIik7CiAJCQlicmVhazsKLQkJfQogCiAJCWNhc2UgT3B0X25vZGlzY2FyZDoKIAkJCSpm bGFnICY9IH5KRlNfRElTQ0FSRDsKQEAgLTM5MiwxMCArMzg5LDkgQEAgc3RhdGljIGludCBwYXJz ZV9vcHRpb25zKGNoYXIgKm9wdGlvbnMsIHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHM2NCAqbmV3 TFZTaXplLAogCiAJCWNhc2UgT3B0X2Rpc2NhcmRfbWluYmxrOgogCQl7Ci0JCQlzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQkJY2hhciAqbWlu Ymxrc190cmltID0gYXJnc1swXS5mcm9tOwogCQkJaW50IHJjOwotCQkJaWYgKGJsa19xdWV1ZV9k aXNjYXJkKHEpKSB7CisJCQlpZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYp KSB7CiAJCQkJKmZsYWcgfD0gSkZTX0RJU0NBUkQ7CiAJCQkJcmMgPSBrc3RydG91aW50KG1pbmJs a3NfdHJpbSwgMCwKIAkJCQkJCSZzYmktPm1pbmJsa3NfdHJpbSk7CmRpZmYgLS1naXQgYS9mcy9u aWxmczIvaW9jdGwuYyBiL2ZzL25pbGZzMi9pb2N0bC5jCmluZGV4IGZlYzE5NGE2NjZmNGIuLjUy YjczZjU1OGZjYjEgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9pb2N0bC5jCisrKyBiL2ZzL25pbGZz Mi9pb2N0bC5jCkBAIC0xMDU5LDcgKzEwNTksNyBAQCBzdGF0aWMgaW50IG5pbGZzX2lvY3RsX3Ry aW1fZnMoc3RydWN0IGlub2RlICppbm9kZSwgdm9pZCBfX3VzZXIgKmFyZ3ApCiAJaWYgKCFjYXBh YmxlKENBUF9TWVNfQURNSU4pKQogCQlyZXR1cm4gLUVQRVJNOwogCi0JaWYgKCFibGtfcXVldWVf ZGlzY2FyZChxKSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhuaWxmcy0+bnNfYmRl dikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmcmFuZ2Us IGFyZ3AsIHNpemVvZihyYW5nZSkpKQpkaWZmIC0tZ2l0IGEvZnMvbnRmczMvZmlsZS5jIGIvZnMv bnRmczMvZmlsZS5jCmluZGV4IDc4N2I1M2I5ODRlZTEuLmU3NjMyMzYxNjkzMzEgMTAwNjQ0Ci0t LSBhL2ZzL250ZnMzL2ZpbGUuYworKysgYi9mcy9udGZzMy9maWxlLmMKQEAgLTI4LDcgKzI4LDcg QEAgc3RhdGljIGludCBudGZzX2lvY3RsX2ZpdHJpbShzdHJ1Y3QgbnRmc19zYl9pbmZvICpzYmks IHVuc2lnbmVkIGxvbmcgYXJnKQogCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0 dXJuIC1FUEVSTTsKIAotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21h eF9kaXNjYXJkX3NlY3RvcnMoc2JpLT5zYi0+c19iZGV2KSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQ OwogCiAJdXNlcl9yYW5nZSA9IChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZzsKZGlm ZiAtLWdpdCBhL2ZzL250ZnMzL3N1cGVyLmMgYi9mcy9udGZzMy9zdXBlci5jCmluZGV4IGNkMzBl ODFhYmJjZTAuLmM3MzQwODViY2NlNGEgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMzL3N1cGVyLmMKKysr IGIvZnMvbnRmczMvc3VwZXIuYwpAQCAtOTEzLDcgKzkxMyw3IEBAIHN0YXRpYyBpbnQgbnRmc19m aWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBmc19jb250ZXh0ICpmYykK IAl9CiAKIAlycSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwotCWlmIChibGtfcXVldWVfZGlzY2Fy ZChycSkgJiYgcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5KSB7CisJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSAmJiBycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkp IHsKIAkJc2JpLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51 bGFyaXR5OwogCQlzYmktPmRpc2NhcmRfZ3JhbnVsYXJpdHlfbWFza19pbnYgPQogCQkJfih1NjQp KHNiaS0+ZGlzY2FyZF9ncmFudWxhcml0eSAtIDEpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvaW9j dGwuYyBiL2ZzL29jZnMyL2lvY3RsLmMKaW5kZXggZjU5NDYxZDg1ZGE0NS4uOWI3OGVmMTAzYWRh NiAxMDA2NDQKLS0tIGEvZnMvb2NmczIvaW9jdGwuYworKysgYi9mcy9vY2ZzMi9pb2N0bC5jCkBA IC05MTAsNyArOTEwLDcgQEAgbG9uZyBvY2ZzMl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5z aWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJCWlmICghY2FwYWJsZShDQVBfU1lT X0FETUlOKSkKIAkJCXJldHVybiAtRVBFUk07CiAKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChx KSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2ItPnNfYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZyYW5nZSwgYXJncCwgc2l6 ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Rpc2NhcmQuYyBiL2ZzL3hmcy94 ZnNfZGlzY2FyZC5jCmluZGV4IDAxOTFkZThjZTljZWQuLmE0ZTY2MDlkNjE2YjcgMTAwNjQ0Ci0t LSBhL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCisrKyBiL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCkBAIC0x NjIsNyArMTYyLDcgQEAgeGZzX2lvY190cmltKAogCiAJaWYgKCFjYXBhYmxlKENBUF9TWVNfQURN SU4pKQogCQlyZXR1cm4gLUVQRVJNOwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMobXAtPm1fZGRldl90YXJncC0+YnRfYmRldikpCiAJ CXJldHVybiAtRU9QTk9UU1VQUDsKIAogCS8qCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3N1cGVy LmMgYi9mcy94ZnMveGZzX3N1cGVyLmMKaW5kZXggNTRiZTlkNjQwOTNlZC4uYTI3NmI4MTExZjYz NiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19zdXBlci5jCisrKyBiL2ZzL3hmcy94ZnNfc3VwZXIu YwpAQCAtMTYwOCwxNCArMTYwOCwxMCBAQCB4ZnNfZnNfZmlsbF9zdXBlcigKIAkJCWdvdG8gb3V0 X2ZpbGVzdHJlYW1fdW5tb3VudDsKIAl9CiAKLQlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSkgewot CQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwot Ci0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJCXhmc193YXJuKG1wLCAibW91bnRp bmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMg bm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCQkJbXAtPm1fZmVhdHVyZXMgJj0gflhGU19GRUFUX0RJ U0NBUkQ7Ci0JCX0KKwlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSAmJiAhYmRldl9tYXhfZGlzY2Fy ZF9zZWN0b3JzKHNiLT5zX2JkZXYpKSB7CisJCXhmc193YXJuKG1wLAorCSJtb3VudGluZyB3aXRo IFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNj YXJkIik7CisJCW1wLT5tX2ZlYXR1cmVzICY9IH5YRlNfRkVBVF9ESVNDQVJEOwogCX0KIAogCWlm ICh4ZnNfaGFzX3JlZmxpbmsobXApKSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Jsa2Rl di5oIGIvaW5jbHVkZS9saW51eC9ibGtkZXYuaAppbmRleCBjZTE2MjQ3ZDNhZmFiLi43NjdhYjIy ZTEwNTJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1ZGUv bGludXgvYmxrZGV2LmgKQEAgLTU0MCw3ICs1NDAsNiBAQCBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSB7 CiAjZGVmaW5lIFFVRVVFX0ZMQUdfTk9OUk9UCTYJLyogbm9uLXJvdGF0aW9uYWwgZGV2aWNlIChT U0QpICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfVklSVAkJUVVFVUVfRkxBR19OT05ST1QgLyogcGFy YXZpcnQgZGV2aWNlICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfSU9fU1RBVAk3CS8qIGRvIGRpc2sv cGFydGl0aW9ucyBJTyBhY2NvdW50aW5nICovCi0jZGVmaW5lIFFVRVVFX0ZMQUdfRElTQ0FSRAk4 CS8qIHN1cHBvcnRzIERJU0NBUkQgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19OT1hNRVJHRVMJOQkv KiBObyBleHRlbmRlZCBtZXJnZXMgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19BRERfUkFORE9NCTEw CS8qIENvbnRyaWJ1dGVzIHRvIHJhbmRvbSBwb29sICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfU0VD RVJBU0UJMTEJLyogc3VwcG9ydHMgc2VjdXJlIGVyYXNlICovCkBAIC01ODIsNyArNTgxLDYgQEAg Ym9vbCBibGtfcXVldWVfZmxhZ190ZXN0X2FuZF9zZXQodW5zaWduZWQgaW50IGZsYWcsIHN0cnVj dCByZXF1ZXN0X3F1ZXVlICpxKTsKIAl0ZXN0X2JpdChRVUVVRV9GTEFHX1NUQUJMRV9XUklURVMs ICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfaW9fc3RhdChxKQl0ZXN0X2Jp dChRVUVVRV9GTEFHX0lPX1NUQVQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVl dWVfYWRkX3JhbmRvbShxKQl0ZXN0X2JpdChRVUVVRV9GTEFHX0FERF9SQU5ET00sICYocSktPnF1 ZXVlX2ZsYWdzKQotI2RlZmluZSBibGtfcXVldWVfZGlzY2FyZChxKQl0ZXN0X2JpdChRVUVVRV9G TEFHX0RJU0NBUkQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfem9uZV9y ZXNldGFsbChxKQlcCiAJdGVzdF9iaXQoUVVFVUVfRkxBR19aT05FX1JFU0VUQUxMLCAmKHEpLT5x dWV1ZV9mbGFncykKICNkZWZpbmUgYmxrX3F1ZXVlX3NlY3VyZV9lcmFzZShxKSBcCmRpZmYgLS1n aXQgYS9tbS9zd2FwZmlsZS5jIGIvbW0vc3dhcGZpbGUuYwppbmRleCA0MDY5ZjE3YTgyYzhlLi41 ZDljZWRmOWU3Yjg0IDEwMDY0NAotLS0gYS9tbS9zd2FwZmlsZS5jCisrKyBiL21tL3N3YXBmaWxl LmMKQEAgLTI5NTcsMjAgKzI5NTcsNiBAQCBzdGF0aWMgaW50IHNldHVwX3N3YXBfbWFwX2FuZF9l eHRlbnRzKHN0cnVjdCBzd2FwX2luZm9fc3RydWN0ICpwLAogCXJldHVybiBucl9leHRlbnRzOwog fQogCi0vKgotICogSGVscGVyIHRvIHN5c19zd2Fwb24gZGV0ZXJtaW5pbmcgaWYgYSBnaXZlbiBz d2FwCi0gKiBiYWNraW5nIGRldmljZSBxdWV1ZSBzdXBwb3J0cyBESVNDQVJEIG9wZXJhdGlvbnMu Ci0gKi8KLXN0YXRpYyBib29sIHN3YXBfZGlzY2FyZGFibGUoc3RydWN0IHN3YXBfaW5mb19zdHJ1 Y3QgKnNpKQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoc2kt PmJkZXYpOwotCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJcmV0dXJuIGZhbHNlOwot Ci0JcmV0dXJuIHRydWU7Ci19Ci0KIFNZU0NBTExfREVGSU5FMihzd2Fwb24sIGNvbnN0IGNoYXIg X191c2VyICosIHNwZWNpYWxmaWxlLCBpbnQsIHN3YXBfZmxhZ3MpCiB7CiAJc3RydWN0IHN3YXBf aW5mb19zdHJ1Y3QgKnA7CkBAIC0zMTMyLDcgKzMxMTgsOCBAQCBTWVNDQUxMX0RFRklORTIoc3dh cG9uLCBjb25zdCBjaGFyIF9fdXNlciAqLCBzcGVjaWFsZmlsZSwgaW50LCBzd2FwX2ZsYWdzKQog CQkJCQkgc2l6ZW9mKGxvbmcpLAogCQkJCQkgR0ZQX0tFUk5FTCk7CiAKLQlpZiAocC0+YmRldiAm JiAoc3dhcF9mbGFncyAmIFNXQVBfRkxBR19ESVNDQVJEKSAmJiBzd2FwX2Rpc2NhcmRhYmxlKHAp KSB7CisJaWYgKChzd2FwX2ZsYWdzICYgU1dBUF9GTEFHX0RJU0NBUkQpICYmCisJICAgIHAtPmJk ZXYgJiYgYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHAtPmJkZXYpKSB7CiAJCS8qCiAJCSAqIFdo ZW4gZGlzY2FyZCBpcyBlbmFibGVkIGZvciBzd2FwIHdpdGggbm8gcGFydGljdWxhcgogCQkgKiBw b2xpY3kgZmxhZ2dlZCwgd2Ugc2V0IGFsbCBzd2FwIGRpc2NhcmQgZmxhZ3MgaGVyZSBpbgotLSAK Mi4zMC4yCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpW aXJ0dWFsaXphdGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91 bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlz dGluZm8vdmlydHVhbGl6YXRpb24= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 65BDD7E3 for ; Sat, 9 Apr 2022 04:52:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc: To:From:Sender:Reply-To:Content-ID:Content-Description; bh=lhrI7Npx42D1AuR/cMyqCoOjrZczBcvFSvpyDVoTBuM=; b=Sjapi7eI4Jh86xiPLIzL2g0V1J mjcOCE9buuik3xQceo12VbO7h4X1i/S8+EGUcf1u3xFqviUr0IXMxs/3Qij4rUA/BVYuftFH0B+QL 15jKW5DOWLXn3fZpnfOdPjT+8sq7nSyHdBxT6coOufp9mqpgHjMXvI28DvNWovru926kmp5e+ex7c /jYKn9KuBgqzsQrl/W/fJF4dNs6aceGzPpdLj4fBSiNAx7tFXGHLE6PclN+/DWpkJQW8eCCHQlhYf t5bRpzLnnxe4LGnXML4qPk3asM8WCBUpA/jrjYRG0MkY4Dc8Ud6n31tOOsdykMc3zj9OSK9AysXdb fD5Kz47g==; Received: from 213-147-167-116.nat.highway.webapn.at ([213.147.167.116] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.94.2 #2 (Red Hat Linux)) id 1nd354-0021dK-Sw; Sat, 09 Apr 2022 04:52:15 +0000 From: Christoph Hellwig To: Jens Axboe Cc: dm-devel@redhat.com, linux-xfs@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-um@lists.infradead.org, linux-block@vger.kernel.org, drbd-dev@lists.linbit.com, nbd@other.debian.org, ceph-devel@vger.kernel.org, virtualization@lists.linux-foundation.org, xen-devel@lists.xenproject.org, linux-bcache@vger.kernel.org, linux-raid@vger.kernel.org, linux-mmc@vger.kernel.org, linux-mtd@lists.infradead.org, linux-nvme@lists.infradead.org, linux-s390@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux-btrfs@vger.kernel.org, linux-ext4@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, cluster-devel@redhat.com, jfs-discussion@lists.sourceforge.net, linux-nilfs@vger.kernel.org, ntfs3@lists.linux.dev, ocfs2-devel@oss.oracle.com, linux-mm@kvack.org, "Martin K . Petersen" , =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , Coly Li Subject: [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-Id: <20220409045043.23593-25-hch@lst.de> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> Precedence: bulk X-Mailing-List: ntfs3@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html Just use a non-zero max_discard_sectors as an indicator for discard support, similar to what is done for write zeroes. The only places where needs special attention is the RAID5 driver, which must clear discard support for security reasons by default, even if the default stacking rules would allow for it. Signed-off-by: Christoph Hellwig Reviewed-by: Martin K. Petersen Acked-by: Christoph Böhmwalder [btrfs] Acked-by: Coly Li [bcache] --- arch/um/drivers/ubd_kern.c | 2 -- block/blk-core.c | 2 +- block/blk-lib.c | 2 +- block/blk-mq-debugfs.c | 1 - block/ioctl.c | 3 +-- drivers/block/drbd/drbd_main.c | 2 +- drivers/block/drbd/drbd_nl.c | 19 ++----------------- drivers/block/drbd/drbd_receiver.c | 3 +-- drivers/block/loop.c | 11 +++-------- drivers/block/nbd.c | 5 +---- drivers/block/null_blk/main.c | 1 - drivers/block/rbd.c | 1 - drivers/block/rnbd/rnbd-clt.c | 2 -- drivers/block/rnbd/rnbd-srv-dev.h | 3 --- drivers/block/virtio_blk.c | 2 -- drivers/block/xen-blkback/xenbus.c | 2 +- drivers/block/xen-blkfront.c | 2 -- drivers/block/zram/zram_drv.c | 1 - drivers/md/bcache/request.c | 4 ++-- drivers/md/bcache/super.c | 3 +-- drivers/md/bcache/sysfs.c | 2 +- drivers/md/dm-cache-target.c | 9 +-------- drivers/md/dm-clone-target.c | 9 +-------- drivers/md/dm-log-writes.c | 3 +-- drivers/md/dm-raid.c | 9 ++------- drivers/md/dm-table.c | 9 ++------- drivers/md/dm-thin.c | 11 +---------- drivers/md/dm.c | 3 +-- drivers/md/md-linear.c | 11 +---------- drivers/md/raid0.c | 7 ------- drivers/md/raid1.c | 16 +--------------- drivers/md/raid10.c | 18 ++---------------- drivers/md/raid5-cache.c | 2 +- drivers/md/raid5.c | 12 ++++-------- drivers/mmc/core/queue.c | 1 - drivers/mtd/mtd_blkdevs.c | 1 - drivers/nvme/host/core.c | 6 ++---- drivers/s390/block/dasd_fba.c | 1 - drivers/scsi/sd.c | 2 -- drivers/target/target_core_device.c | 2 +- fs/btrfs/extent-tree.c | 4 ++-- fs/btrfs/ioctl.c | 2 +- fs/exfat/file.c | 2 +- fs/exfat/super.c | 10 +++------- fs/ext4/ioctl.c | 10 +++------- fs/ext4/super.c | 10 +++------- fs/f2fs/f2fs.h | 3 +-- fs/fat/file.c | 2 +- fs/fat/inode.c | 10 +++------- fs/gfs2/rgrp.c | 2 +- fs/jbd2/journal.c | 7 ++----- fs/jfs/ioctl.c | 2 +- fs/jfs/super.c | 8 ++------ fs/nilfs2/ioctl.c | 2 +- fs/ntfs3/file.c | 2 +- fs/ntfs3/super.c | 2 +- fs/ocfs2/ioctl.c | 2 +- fs/xfs/xfs_discard.c | 2 +- fs/xfs/xfs_super.c | 12 ++++-------- include/linux/blkdev.h | 2 -- mm/swapfile.c | 17 ++--------------- 61 files changed, 72 insertions(+), 246 deletions(-) diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c index b03269faef714..085ffdf98e57e 100644 --- a/arch/um/drivers/ubd_kern.c +++ b/arch/um/drivers/ubd_kern.c @@ -483,7 +483,6 @@ static void ubd_handler(void) if ((io_req->error == BLK_STS_NOTSUPP) && (req_op(io_req->req) == REQ_OP_DISCARD)) { blk_queue_max_discard_sectors(io_req->req->q, 0); blk_queue_max_write_zeroes_sectors(io_req->req->q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, io_req->req->q); } blk_mq_end_request(io_req->req, io_req->error); kfree(io_req); @@ -803,7 +802,6 @@ static int ubd_open_dev(struct ubd *ubd_dev) ubd_dev->queue->limits.discard_alignment = SECTOR_SIZE; blk_queue_max_discard_sectors(ubd_dev->queue, UBD_MAX_REQUEST); blk_queue_max_write_zeroes_sectors(ubd_dev->queue, UBD_MAX_REQUEST); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, ubd_dev->queue); } blk_queue_flag_set(QUEUE_FLAG_NONROT, ubd_dev->queue); return 0; diff --git a/block/blk-core.c b/block/blk-core.c index 937bb6b863317..b5c3a8049134c 100644 --- a/block/blk-core.c +++ b/block/blk-core.c @@ -820,7 +820,7 @@ void submit_bio_noacct(struct bio *bio) switch (bio_op(bio)) { case REQ_OP_DISCARD: - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) goto not_supported; break; case REQ_OP_SECURE_ERASE: diff --git a/block/blk-lib.c b/block/blk-lib.c index 2ae32a722851c..8b4b66d3a9bfc 100644 --- a/block/blk-lib.c +++ b/block/blk-lib.c @@ -53,7 +53,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, return -EOPNOTSUPP; op = REQ_OP_SECURE_ERASE; } else { - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return -EOPNOTSUPP; op = REQ_OP_DISCARD; } diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index aa0349e9f083b..fd111c5001256 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -113,7 +113,6 @@ static const char *const blk_queue_flag_name[] = { QUEUE_FLAG_NAME(FAIL_IO), QUEUE_FLAG_NAME(NONROT), QUEUE_FLAG_NAME(IO_STAT), - QUEUE_FLAG_NAME(DISCARD), QUEUE_FLAG_NAME(NOXMERGES), QUEUE_FLAG_NAME(ADD_RANDOM), QUEUE_FLAG_NAME(SECERASE), diff --git a/block/ioctl.c b/block/ioctl.c index ad3771b268b81..c2cd3ba5290ce 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -87,14 +87,13 @@ static int blk_ioctl_discard(struct block_device *bdev, fmode_t mode, { uint64_t range[2]; uint64_t start, len; - struct request_queue *q = bdev_get_queue(bdev); struct inode *inode = bdev->bd_inode; int err; if (!(mode & FMODE_WRITE)) return -EBADF; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return -EOPNOTSUPP; if (copy_from_user(range, (void __user *)arg, sizeof(range))) diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c index eae629c4f6eaf..a69475e592822 100644 --- a/drivers/block/drbd/drbd_main.c +++ b/drivers/block/drbd/drbd_main.c @@ -942,7 +942,7 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enu cpu_to_be32(bdev_alignment_offset(bdev)); p->qlim->io_min = cpu_to_be32(bdev_io_min(bdev)); p->qlim->io_opt = cpu_to_be32(bdev_io_opt(bdev)); - p->qlim->discard_enabled = blk_queue_discard(q); + p->qlim->discard_enabled = !!bdev_max_discard_sectors(bdev); put_ldev(device); } else { struct request_queue *q = device->rq_queue; diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c index d4dacc329ac2e..b55e5fcc21e1f 100644 --- a/drivers/block/drbd/drbd_nl.c +++ b/drivers/block/drbd/drbd_nl.c @@ -1210,7 +1210,7 @@ static void decide_on_discard_support(struct drbd_device *device, first_peer_device(device)->connection; struct request_queue *q = device->rq_queue; - if (bdev && !blk_queue_discard(bdev->backing_bdev->bd_disk->queue)) + if (bdev && !bdev_max_discard_sectors(bdev->backing_bdev)) goto not_supported; if (connection->cstate >= C_CONNECTED && @@ -1230,30 +1230,16 @@ static void decide_on_discard_support(struct drbd_device *device, */ blk_queue_discard_granularity(q, 512); q->limits.max_discard_sectors = drbd_max_discard_sectors(connection); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); q->limits.max_write_zeroes_sectors = drbd_max_discard_sectors(connection); return; not_supported: - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); blk_queue_discard_granularity(q, 0); q->limits.max_discard_sectors = 0; q->limits.max_write_zeroes_sectors = 0; } -static void fixup_discard_if_not_supported(struct request_queue *q) -{ - /* To avoid confusion, if this queue does not support discard, clear - * max_discard_sectors, which is what lsblk -D reports to the user. - * Older kernels got this wrong in "stack limits". - * */ - if (!blk_queue_discard(q)) { - blk_queue_max_discard_sectors(q, 0); - blk_queue_discard_granularity(q, 0); - } -} - static void fixup_write_zeroes(struct drbd_device *device, struct request_queue *q) { /* Fixup max_write_zeroes_sectors after blk_stack_limits(): @@ -1300,7 +1286,6 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backi blk_stack_limits(&q->limits, &b->limits, 0); disk_update_readahead(device->vdisk); } - fixup_discard_if_not_supported(q); fixup_write_zeroes(device, q); } @@ -1447,7 +1432,7 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *dis if (disk_conf->al_extents > drbd_al_extents_max(nbc)) disk_conf->al_extents = drbd_al_extents_max(nbc); - if (!blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(bdev)) { if (disk_conf->rs_discard_granularity) { disk_conf->rs_discard_granularity = 0; /* disable feature */ drbd_info(device, "rs_discard_granularity feature disabled\n"); diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c index 0b4c7de463989..8a4a47da56fe9 100644 --- a/drivers/block/drbd/drbd_receiver.c +++ b/drivers/block/drbd/drbd_receiver.c @@ -1575,11 +1575,10 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u static bool can_do_reliable_discards(struct drbd_device *device) { - struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); struct disk_conf *dc; bool can_do; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(device->ldev->backing_bdev)) return false; rcu_read_lock(); diff --git a/drivers/block/loop.c b/drivers/block/loop.c index 8d800d46e4985..0e061c9896eff 100644 --- a/drivers/block/loop.c +++ b/drivers/block/loop.c @@ -314,15 +314,12 @@ static int lo_fallocate(struct loop_device *lo, struct request *rq, loff_t pos, mode |= FALLOC_FL_KEEP_SIZE; - if (!blk_queue_discard(lo->lo_queue)) { - ret = -EOPNOTSUPP; - goto out; - } + if (!bdev_max_discard_sectors(lo->lo_device)) + return -EOPNOTSUPP; ret = file->f_op->fallocate(file, mode, pos, blk_rq_bytes(rq)); if (unlikely(ret && ret != -EINVAL && ret != -EOPNOTSUPP)) - ret = -EIO; - out: + return -EIO; return ret; } @@ -787,12 +784,10 @@ static void loop_config_discard(struct loop_device *lo) q->limits.discard_granularity = granularity; blk_queue_max_discard_sectors(q, max_discard_sectors); blk_queue_max_write_zeroes_sectors(q, max_discard_sectors); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } else { q->limits.discard_granularity = 0; blk_queue_max_discard_sectors(q, 0); blk_queue_max_write_zeroes_sectors(q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); } q->limits.discard_alignment = 0; } diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c index 5a1f98494dddf..4729aef8c6462 100644 --- a/drivers/block/nbd.c +++ b/drivers/block/nbd.c @@ -1231,8 +1231,6 @@ static void nbd_parse_flags(struct nbd_device *nbd) set_disk_ro(nbd->disk, true); else set_disk_ro(nbd->disk, false); - if (config->flags & NBD_FLAG_SEND_TRIM) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, nbd->disk->queue); if (config->flags & NBD_FLAG_SEND_FLUSH) { if (config->flags & NBD_FLAG_SEND_FUA) blk_queue_write_cache(nbd->disk->queue, true, true); @@ -1319,8 +1317,7 @@ static void nbd_config_put(struct nbd_device *nbd) nbd->tag_set.timeout = 0; nbd->disk->queue->limits.discard_granularity = 0; nbd->disk->queue->limits.discard_alignment = 0; - blk_queue_max_discard_sectors(nbd->disk->queue, UINT_MAX); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, nbd->disk->queue); + blk_queue_max_discard_sectors(nbd->disk->queue, 0); mutex_unlock(&nbd->config_lock); nbd_put(nbd); diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c index 05b1120e66234..f6493a9e85ed3 100644 --- a/drivers/block/null_blk/main.c +++ b/drivers/block/null_blk/main.c @@ -1767,7 +1767,6 @@ static void null_config_discard(struct nullb *nullb) nullb->q->limits.discard_granularity = nullb->dev->blocksize; nullb->q->limits.discard_alignment = nullb->dev->blocksize; blk_queue_max_discard_sectors(nullb->q, UINT_MAX >> 9); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, nullb->q); } static const struct block_device_operations null_bio_ops = { diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c index b844432bad20b..2b21f717cce1a 100644 --- a/drivers/block/rbd.c +++ b/drivers/block/rbd.c @@ -4942,7 +4942,6 @@ static int rbd_init_disk(struct rbd_device *rbd_dev) blk_queue_io_opt(q, rbd_dev->opts->alloc_size); if (rbd_dev->opts->trim) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); q->limits.discard_granularity = rbd_dev->opts->alloc_size; blk_queue_max_discard_sectors(q, objset_bytes >> SECTOR_SHIFT); blk_queue_max_write_zeroes_sectors(q, objset_bytes >> SECTOR_SHIFT); diff --git a/drivers/block/rnbd/rnbd-clt.c b/drivers/block/rnbd/rnbd-clt.c index b66e8840b94b8..efa99a3884507 100644 --- a/drivers/block/rnbd/rnbd-clt.c +++ b/drivers/block/rnbd/rnbd-clt.c @@ -1364,8 +1364,6 @@ static void setup_request_queue(struct rnbd_clt_dev *dev) blk_queue_max_discard_sectors(dev->queue, dev->max_discard_sectors); dev->queue->limits.discard_granularity = dev->discard_granularity; dev->queue->limits.discard_alignment = dev->discard_alignment; - if (dev->max_discard_sectors) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, dev->queue); if (dev->secure_discard) blk_queue_flag_set(QUEUE_FLAG_SECERASE, dev->queue); diff --git a/drivers/block/rnbd/rnbd-srv-dev.h b/drivers/block/rnbd/rnbd-srv-dev.h index f82fbb4bbda8e..1f7e1c8fd4d9b 100644 --- a/drivers/block/rnbd/rnbd-srv-dev.h +++ b/drivers/block/rnbd/rnbd-srv-dev.h @@ -49,9 +49,6 @@ static inline int rnbd_dev_get_secure_discard(const struct rnbd_dev *dev) static inline int rnbd_dev_get_max_discard_sects(const struct rnbd_dev *dev) { - if (!blk_queue_discard(bdev_get_queue(dev->bdev))) - return 0; - return bdev_max_discard_sectors(dev->bdev); } diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c index a8bcf3f664af1..6ccf15253dee1 100644 --- a/drivers/block/virtio_blk.c +++ b/drivers/block/virtio_blk.c @@ -888,8 +888,6 @@ static int virtblk_probe(struct virtio_device *vdev) v = sg_elems; blk_queue_max_discard_segments(q, min(v, MAX_DISCARD_SEGMENTS)); - - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } if (virtio_has_feature(vdev, VIRTIO_BLK_F_WRITE_ZEROES)) { diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c index 8b691fe50475f..83cd08041e6b3 100644 --- a/drivers/block/xen-blkback/xenbus.c +++ b/drivers/block/xen-blkback/xenbus.c @@ -583,7 +583,7 @@ static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info if (!xenbus_read_unsigned(dev->nodename, "discard-enable", 1)) return; - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(bdev)) { err = xenbus_printf(xbt, dev->nodename, "discard-granularity", "%u", q->limits.discard_granularity); diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c index 003056d4f7f5f..253bf835aca1f 100644 --- a/drivers/block/xen-blkfront.c +++ b/drivers/block/xen-blkfront.c @@ -944,7 +944,6 @@ static void blkif_set_queue_limits(struct blkfront_info *info) blk_queue_flag_set(QUEUE_FLAG_VIRT, rq); if (info->feature_discard) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, rq); blk_queue_max_discard_sectors(rq, get_capacity(gd)); rq->limits.discard_granularity = info->discard_granularity ?: info->physical_sector_size; @@ -1606,7 +1605,6 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id) blkif_req(req)->error = BLK_STS_NOTSUPP; info->feature_discard = 0; info->feature_secdiscard = 0; - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, rq); blk_queue_flag_clear(QUEUE_FLAG_SECERASE, rq); } break; diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index e9474b02012de..59ff444bf6c76 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1952,7 +1952,6 @@ static int zram_add(void) blk_queue_io_opt(zram->disk->queue, PAGE_SIZE); zram->disk->queue->limits.discard_granularity = PAGE_SIZE; blk_queue_max_discard_sectors(zram->disk->queue, UINT_MAX); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, zram->disk->queue); /* * zram_bio_discard() will clear all logical blocks if logical block diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c index fdd0194f84dd0..e27f67f06a428 100644 --- a/drivers/md/bcache/request.c +++ b/drivers/md/bcache/request.c @@ -1005,7 +1005,7 @@ static void cached_dev_write(struct cached_dev *dc, struct search *s) bio_get(s->iop.bio); if (bio_op(bio) == REQ_OP_DISCARD && - !blk_queue_discard(bdev_get_queue(dc->bdev))) + !bdev_max_discard_sectors(dc->bdev)) goto insert_data; /* I/O request sent to backing device */ @@ -1115,7 +1115,7 @@ static void detached_dev_do_request(struct bcache_device *d, struct bio *bio, bio->bi_private = ddip; if ((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bdev_get_queue(dc->bdev))) + !bdev_max_discard_sectors(dc->bdev)) bio->bi_end_io(bio); else submit_bio_noacct(bio); diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c index bf3de149d3c9f..2f49e31142f62 100644 --- a/drivers/md/bcache/super.c +++ b/drivers/md/bcache/super.c @@ -973,7 +973,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size, blk_queue_flag_set(QUEUE_FLAG_NONROT, d->disk->queue); blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, d->disk->queue); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, d->disk->queue); blk_queue_write_cache(q, true, true); @@ -2350,7 +2349,7 @@ static int register_cache(struct cache_sb *sb, struct cache_sb_disk *sb_disk, ca->bdev->bd_holder = ca; ca->sb_disk = sb_disk; - if (blk_queue_discard(bdev_get_queue(bdev))) + if (bdev_max_discard_sectors((bdev))) ca->discard = CACHE_DISCARD(&ca->sb); ret = cache_alloc(ca); diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c index d1029d71ff3bc..c6f677059214d 100644 --- a/drivers/md/bcache/sysfs.c +++ b/drivers/md/bcache/sysfs.c @@ -1151,7 +1151,7 @@ STORE(__bch_cache) if (attr == &sysfs_discard) { bool v = strtoul_or_return(buf); - if (blk_queue_discard(bdev_get_queue(ca->bdev))) + if (bdev_max_discard_sectors(ca->bdev)) ca->discard = v; if (v != CACHE_DISCARD(&ca->sb)) { diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c index 780a61bc6cc03..28c5de8eca4a0 100644 --- a/drivers/md/dm-cache-target.c +++ b/drivers/md/dm-cache-target.c @@ -3329,13 +3329,6 @@ static int cache_iterate_devices(struct dm_target *ti, return r; } -static bool origin_dev_supports_discard(struct block_device *origin_bdev) -{ - struct request_queue *q = bdev_get_queue(origin_bdev); - - return blk_queue_discard(q); -} - /* * If discard_passdown was enabled verify that the origin device * supports discards. Disable discard_passdown if not. @@ -3349,7 +3342,7 @@ static void disable_passdown_if_not_supported(struct cache *cache) if (!cache->features.discard_passdown) return; - if (!origin_dev_supports_discard(origin_bdev)) + if (!bdev_max_discard_sectors(origin_bdev)) reason = "discard unsupported"; else if (origin_limits->max_discard_sectors < cache->sectors_per_block) diff --git a/drivers/md/dm-clone-target.c b/drivers/md/dm-clone-target.c index 128316a73d016..811b0a5379d03 100644 --- a/drivers/md/dm-clone-target.c +++ b/drivers/md/dm-clone-target.c @@ -2016,13 +2016,6 @@ static void clone_resume(struct dm_target *ti) do_waker(&clone->waker.work); } -static bool bdev_supports_discards(struct block_device *bdev) -{ - struct request_queue *q = bdev_get_queue(bdev); - - return (q && blk_queue_discard(q)); -} - /* * If discard_passdown was enabled verify that the destination device supports * discards. Disable discard_passdown if not. @@ -2036,7 +2029,7 @@ static void disable_passdown_if_not_supported(struct clone *clone) if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags)) return; - if (!bdev_supports_discards(dest_dev)) + if (!bdev_max_discard_sectors(dest_dev)) reason = "discard unsupported"; else if (dest_limits->max_discard_sectors < clone->region_size) reason = "max discard sectors smaller than a region"; diff --git a/drivers/md/dm-log-writes.c b/drivers/md/dm-log-writes.c index c9d036d6bb2ee..e194226c89e54 100644 --- a/drivers/md/dm-log-writes.c +++ b/drivers/md/dm-log-writes.c @@ -866,9 +866,8 @@ static int log_writes_message(struct dm_target *ti, unsigned argc, char **argv, static void log_writes_io_hints(struct dm_target *ti, struct queue_limits *limits) { struct log_writes_c *lc = ti->private; - struct request_queue *q = bdev_get_queue(lc->dev->bdev); - if (!q || !blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(lc->dev->bdev)) { lc->device_supports_discard = false; limits->discard_granularity = lc->sectorsize; limits->max_discard_sectors = (UINT_MAX >> SECTOR_SHIFT); diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c index 2b26435a6946e..9526ccbedafba 100644 --- a/drivers/md/dm-raid.c +++ b/drivers/md/dm-raid.c @@ -2963,13 +2963,8 @@ static void configure_discard_support(struct raid_set *rs) raid456 = rs_is_raid456(rs); for (i = 0; i < rs->raid_disks; i++) { - struct request_queue *q; - - if (!rs->dev[i].rdev.bdev) - continue; - - q = bdev_get_queue(rs->dev[i].rdev.bdev); - if (!q || !blk_queue_discard(q)) + if (!rs->dev[i].rdev.bdev || + !bdev_max_discard_sectors(rs->dev[i].rdev.bdev)) return; if (raid456) { diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c index d46839faa0ca5..0dff6907fd00d 100644 --- a/drivers/md/dm-table.c +++ b/drivers/md/dm-table.c @@ -1888,9 +1888,7 @@ static bool dm_table_supports_nowait(struct dm_table *t) static int device_not_discard_capable(struct dm_target *ti, struct dm_dev *dev, sector_t start, sector_t len, void *data) { - struct request_queue *q = bdev_get_queue(dev->bdev); - - return !blk_queue_discard(q); + return !bdev_max_discard_sectors(dev->bdev); } static bool dm_table_supports_discards(struct dm_table *t) @@ -1970,15 +1968,12 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, q); if (!dm_table_supports_discards(t)) { - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); - /* Must also clear discard limits... */ q->limits.max_discard_sectors = 0; q->limits.max_hw_discard_sectors = 0; q->limits.discard_granularity = 0; q->limits.discard_alignment = 0; q->limits.discard_misaligned = 0; - } else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); + } if (dm_table_supports_secure_erase(t)) blk_queue_flag_set(QUEUE_FLAG_SECERASE, q); diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c index 4d25d0e270313..eded4bcc4545f 100644 --- a/drivers/md/dm-thin.c +++ b/drivers/md/dm-thin.c @@ -2802,13 +2802,6 @@ static void requeue_bios(struct pool *pool) /*---------------------------------------------------------------- * Binding of control targets to a pool object *--------------------------------------------------------------*/ -static bool data_dev_supports_discard(struct pool_c *pt) -{ - struct request_queue *q = bdev_get_queue(pt->data_dev->bdev); - - return blk_queue_discard(q); -} - static bool is_factor(sector_t block_size, uint32_t n) { return !sector_div(block_size, n); @@ -2828,7 +2821,7 @@ static void disable_passdown_if_not_supported(struct pool_c *pt) if (!pt->adjusted_pf.discard_passdown) return; - if (!data_dev_supports_discard(pt)) + if (!bdev_max_discard_sectors(pt->data_dev->bdev)) reason = "discard unsupported"; else if (data_limits->max_discard_sectors < pool->sectors_per_block) @@ -4057,8 +4050,6 @@ static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits) /* * Must explicitly disallow stacking discard limits otherwise the * block layer will stack them if pool's data device has support. - * QUEUE_FLAG_DISCARD wouldn't be set but there is no way for the - * user to see that, so make sure to set all discard limits to 0. */ limits->discard_granularity = 0; return; diff --git a/drivers/md/dm.c b/drivers/md/dm.c index 3c5fad7c4ee68..dbbf64ce7e927 100644 --- a/drivers/md/dm.c +++ b/drivers/md/dm.c @@ -955,7 +955,6 @@ void disable_discard(struct mapped_device *md) /* device doesn't really support DISCARD, disable it */ limits->max_discard_sectors = 0; - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue); } void disable_write_zeroes(struct mapped_device *md) @@ -982,7 +981,7 @@ static void clone_endio(struct bio *bio) if (unlikely(error == BLK_STS_TARGET)) { if (bio_op(bio) == REQ_OP_DISCARD && - !q->limits.max_discard_sectors) + !bdev_max_discard_sectors(bio->bi_bdev)) disable_discard(md); else if (bio_op(bio) == REQ_OP_WRITE_ZEROES && !q->limits.max_write_zeroes_sectors) diff --git a/drivers/md/md-linear.c b/drivers/md/md-linear.c index 0f55b079371b1..138a3b25c5c82 100644 --- a/drivers/md/md-linear.c +++ b/drivers/md/md-linear.c @@ -64,7 +64,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) struct linear_conf *conf; struct md_rdev *rdev; int i, cnt; - bool discard_supported = false; conf = kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL); if (!conf) @@ -96,9 +95,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) conf->array_sectors += rdev->sectors; cnt++; - - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; } if (cnt != raid_disks) { pr_warn("md/linear:%s: not enough drives present. Aborting!\n", @@ -106,11 +102,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) goto out; } - if (!discard_supported) - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); - else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); - /* * Here we calculate the device offsets. */ @@ -252,7 +243,7 @@ static bool linear_make_request(struct mddev *mddev, struct bio *bio) start_sector + data_offset; if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) { + !bdev_max_discard_sectors(bio->bi_bdev))) { /* Just ignore it */ bio_endio(bio); } else { diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c index b21e101183f44..7231f5e1eaa73 100644 --- a/drivers/md/raid0.c +++ b/drivers/md/raid0.c @@ -399,7 +399,6 @@ static int raid0_run(struct mddev *mddev) conf = mddev->private; if (mddev->queue) { struct md_rdev *rdev; - bool discard_supported = false; blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors); blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors); @@ -412,13 +411,7 @@ static int raid0_run(struct mddev *mddev) rdev_for_each(rdev, mddev) { disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; } - if (!discard_supported) - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); - else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); } /* calculate array device size */ diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index d81b896855f9f..3da749d150a17 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -802,7 +802,7 @@ static void flush_bio_list(struct r1conf *conf, struct bio *bio) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -1826,8 +1826,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev) break; } } - if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); print_conf(conf); return err; } @@ -3106,7 +3104,6 @@ static int raid1_run(struct mddev *mddev) int i; struct md_rdev *rdev; int ret; - bool discard_supported = false; if (mddev->level != 1) { pr_warn("md/raid1:%s: raid level not set to mirroring (%d)\n", @@ -3141,8 +3138,6 @@ static int raid1_run(struct mddev *mddev) continue; disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; } mddev->degraded = 0; @@ -3179,15 +3174,6 @@ static int raid1_run(struct mddev *mddev) md_set_array_sectors(mddev, raid1_size(mddev, 0, 0)); - if (mddev->queue) { - if (discard_supported) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); - } - ret = md_integrity_register(mddev); if (ret) { md_unregister_thread(&mddev->thread); diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c index 7816c8b2e8087..36a460015cf58 100644 --- a/drivers/md/raid10.c +++ b/drivers/md/raid10.c @@ -888,7 +888,7 @@ static void flush_pending_writes(struct r10conf *conf) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -1083,7 +1083,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -2144,8 +2144,6 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev) rcu_assign_pointer(p->rdev, rdev); break; } - if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); print_conf(conf); return err; @@ -4069,7 +4067,6 @@ static int raid10_run(struct mddev *mddev) sector_t size; sector_t min_offset_diff = 0; int first = 1; - bool discard_supported = false; if (mddev_init_writes_pending(mddev) < 0) return -ENOMEM; @@ -4140,20 +4137,9 @@ static int raid10_run(struct mddev *mddev) rdev->data_offset << 9); disk->head_position = 0; - - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; first = 0; } - if (mddev->queue) { - if (discard_supported) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); - } /* need to check that every block has at least one working mirror */ if (!enough(conf, -1)) { pr_err("md/raid10:%s: not enough operational mirrors.\n", diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c index a7d50ff9020a8..c3cbf9a574a39 100644 --- a/drivers/md/raid5-cache.c +++ b/drivers/md/raid5-cache.c @@ -1318,7 +1318,7 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log, r5l_write_super(log, end); - if (!blk_queue_discard(bdev_get_queue(bdev))) + if (!bdev_max_discard_sectors(bdev)) return; mddev = log->rdev->mddev; diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c index 0bbae0e638666..59f91e392a2ae 100644 --- a/drivers/md/raid5.c +++ b/drivers/md/raid5.c @@ -7776,14 +7776,10 @@ static int raid5_run(struct mddev *mddev) * A better idea might be to turn DISCARD into WRITE_ZEROES * requests, as that is required to be safe. */ - if (devices_handle_discard_safely && - mddev->queue->limits.max_discard_sectors >= (stripe >> 9) && - mddev->queue->limits.discard_granularity >= stripe) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); + if (!devices_handle_discard_safely || + mddev->queue->limits.max_discard_sectors < (stripe >> 9) || + mddev->queue->limits.discard_granularity < stripe) + blk_queue_max_discard_sectors(mddev->queue, 0); blk_queue_max_hw_sectors(mddev->queue, UINT_MAX); } diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c index c69b2d9df6f16..cac6315010a3d 100644 --- a/drivers/mmc/core/queue.c +++ b/drivers/mmc/core/queue.c @@ -183,7 +183,6 @@ static void mmc_queue_setup_discard(struct request_queue *q, if (!max_discard) return; - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); blk_queue_max_discard_sectors(q, max_discard); q->limits.discard_granularity = card->pref_erase << 9; /* granularity must not be greater than max. discard */ diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c index 64d2b093f114b..f731721114655 100644 --- a/drivers/mtd/mtd_blkdevs.c +++ b/drivers/mtd/mtd_blkdevs.c @@ -377,7 +377,6 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new) blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq); if (tr->discard) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, new->rq); blk_queue_max_discard_sectors(new->rq, UINT_MAX); new->rq->limits.discard_granularity = tr->blksize; } diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index efb85c6d8e2d5..7e07dd69262a7 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -1607,10 +1607,8 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns) struct request_queue *queue = disk->queue; u32 size = queue_logical_block_size(queue); - if (ctrl->max_discard_sectors == 0) { - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, queue); + if (ctrl->max_discard_sectors == 0) return; - } BUILD_BUG_ON(PAGE_SIZE / sizeof(struct nvme_dsm_range) < NVME_DSM_MAX_RANGES); @@ -1619,7 +1617,7 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns) queue->limits.discard_granularity = size; /* If discard is already enabled, don't reset queue limits */ - if (blk_queue_flag_test_and_set(QUEUE_FLAG_DISCARD, queue)) + if (queue->limits.max_discard_sectors) return; blk_queue_max_discard_sectors(queue, ctrl->max_discard_sectors); diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c index e084f4deddddd..8bd5665db9198 100644 --- a/drivers/s390/block/dasd_fba.c +++ b/drivers/s390/block/dasd_fba.c @@ -791,7 +791,6 @@ static void dasd_fba_setup_blk_queue(struct dasd_block *block) blk_queue_max_discard_sectors(q, max_discard_sectors); blk_queue_max_write_zeroes_sectors(q, max_discard_sectors); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } static int dasd_fba_pe_handler(struct dasd_device *device, diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index a390679cf4584..444479657b7fd 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -797,7 +797,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode) case SD_LBP_FULL: case SD_LBP_DISABLE: blk_queue_max_discard_sectors(q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); return; case SD_LBP_UNMAP: @@ -830,7 +829,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode) } blk_queue_max_discard_sectors(q, max_blocks * (logical_block_size >> 9)); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd) diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c index c3e25bac90d59..6cb9f87843278 100644 --- a/drivers/target/target_core_device.c +++ b/drivers/target/target_core_device.c @@ -838,7 +838,7 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib, struct request_queue *q = bdev_get_queue(bdev); int block_size = bdev_logical_block_size(bdev); - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return false; attrib->max_unmap_lba_count = diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index f477035a2ac23..efd8deb3ab7e8 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c @@ -1291,7 +1291,7 @@ static int do_discard_extent(struct btrfs_io_stripe *stripe, u64 *bytes) ret = btrfs_reset_device_zone(dev_replace->tgtdev, phys, len, &discarded); discarded += src_disc; - } else if (blk_queue_discard(bdev_get_queue(stripe->dev->bdev))) { + } else if (bdev_max_discard_sectors(stripe->dev->bdev)) { ret = btrfs_issue_discard(dev->bdev, phys, len, &discarded); } else { ret = 0; @@ -5987,7 +5987,7 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, u64 *trimmed) *trimmed = 0; /* Discard not supported = nothing to do. */ - if (!blk_queue_discard(bdev_get_queue(device->bdev))) + if (!bdev_max_discard_sectors(device->bdev)) return 0; /* Not writable = nothing to do. */ diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index f46e71061942d..096bb0da03f1c 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -501,7 +501,7 @@ static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info, if (!device->bdev) continue; q = bdev_get_queue(device->bdev); - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(device->bdev)) { num_devices++; minlen = min_t(u64, q->limits.discard_granularity, minlen); diff --git a/fs/exfat/file.c b/fs/exfat/file.c index 2f51300592366..765e4f63dd18d 100644 --- a/fs/exfat/file.c +++ b/fs/exfat/file.c @@ -358,7 +358,7 @@ static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(inode->i_sb->s_bdev)) return -EOPNOTSUPP; if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range))) diff --git a/fs/exfat/super.c b/fs/exfat/super.c index 8ca21e7917d16..be0788ecaf20e 100644 --- a/fs/exfat/super.c +++ b/fs/exfat/super.c @@ -627,13 +627,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc) if (opts->allow_utime == (unsigned short)-1) opts->allow_utime = ~opts->fs_dmask & 0022; - if (opts->discard) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - - if (!blk_queue_discard(q)) { - exfat_warn(sb, "mounting with \"discard\" option, but the device does not support discard"); - opts->discard = 0; - } + if (opts->discard && !bdev_max_discard_sectors(sb->s_bdev)) { + exfat_warn(sb, "mounting with \"discard\" option, but the device does not support discard"); + opts->discard = 0; } sb->s_flags |= SB_NODIRATIME; diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c index 992229ca2d830..6e3b9eea126f4 100644 --- a/fs/ext4/ioctl.c +++ b/fs/ext4/ioctl.c @@ -1044,7 +1044,6 @@ static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg) __u32 flags = 0; unsigned int flush_flags = 0; struct super_block *sb = file_inode(filp)->i_sb; - struct request_queue *q; if (copy_from_user(&flags, (__u32 __user *)arg, sizeof(__u32))) @@ -1065,10 +1064,8 @@ static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg) if (flags & ~EXT4_IOC_CHECKPOINT_FLAG_VALID) return -EINVAL; - q = bdev_get_queue(EXT4_SB(sb)->s_journal->j_dev); - if (!q) - return -ENXIO; - if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) + if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && + !bdev_max_discard_sectors(EXT4_SB(sb)->s_journal->j_dev)) return -EOPNOTSUPP; if (flags & EXT4_IOC_CHECKPOINT_FLAG_DRY_RUN) @@ -1393,14 +1390,13 @@ static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) case FITRIM: { - struct request_queue *q = bdev_get_queue(sb->s_bdev); struct fstrim_range range; int ret = 0; if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; /* diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 81749eaddf4c1..93f4e4e9e2631 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -5458,13 +5458,9 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) goto failed_mount9; } - if (test_opt(sb, DISCARD)) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - if (!blk_queue_discard(q)) - ext4_msg(sb, KERN_WARNING, - "mounting with \"discard\" option, but " - "the device does not support discard"); - } + if (test_opt(sb, DISCARD) && !bdev_max_discard_sectors(sb->s_bdev)) + ext4_msg(sb, KERN_WARNING, + "mounting with \"discard\" option, but the device does not support discard"); if (es->s_error_count) mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */ diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index cd1e65bcf0b04..0ea9a5fa7c1dd 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4381,8 +4381,7 @@ static inline bool f2fs_hw_should_discard(struct f2fs_sb_info *sbi) static inline bool f2fs_bdev_support_discard(struct block_device *bdev) { - return blk_queue_discard(bdev_get_queue(bdev)) || - bdev_is_zoned(bdev); + return bdev_max_discard_sectors(bdev) || bdev_is_zoned(bdev); } static inline bool f2fs_hw_support_discard(struct f2fs_sb_info *sbi) diff --git a/fs/fat/file.c b/fs/fat/file.c index a5a309fcc7faf..e4c7d10e80129 100644 --- a/fs/fat/file.c +++ b/fs/fat/file.c @@ -133,7 +133,7 @@ static int fat_ioctl_fitrim(struct inode *inode, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; user_range = (struct fstrim_range __user *)arg; diff --git a/fs/fat/inode.c b/fs/fat/inode.c index bf6051bdf1d1d..3d1afb95a925a 100644 --- a/fs/fat/inode.c +++ b/fs/fat/inode.c @@ -1872,13 +1872,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, goto out_fail; } - if (sbi->options.discard) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - if (!blk_queue_discard(q)) - fat_msg(sb, KERN_WARNING, - "mounting with \"discard\" option, but " - "the device does not support discard"); - } + if (sbi->options.discard && !bdev_max_discard_sectors(sb->s_bdev)) + fat_msg(sb, KERN_WARNING, + "mounting with \"discard\" option, but the device does not support discard"); fat_set_state(sb, 1, 0); return 0; diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c index 801ad9f4f2bef..7f20ac9133bc6 100644 --- a/fs/gfs2/rgrp.c +++ b/fs/gfs2/rgrp.c @@ -1405,7 +1405,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp) if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) return -EROFS; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sdp->sd_vfs->s_bdev)) return -EOPNOTSUPP; if (copy_from_user(&r, argp, sizeof(r))) diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c index fcacafa4510d1..19d226cd4ff4d 100644 --- a/fs/jbd2/journal.c +++ b/fs/jbd2/journal.c @@ -1762,7 +1762,6 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) unsigned long block, log_offset; /* logical */ unsigned long long phys_block, block_start, block_stop; /* physical */ loff_t byte_start, byte_stop, byte_count; - struct request_queue *q = bdev_get_queue(journal->j_dev); /* flags must be set to either discard or zeroout */ if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags || @@ -1770,10 +1769,8 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) (flags & JBD2_JOURNAL_FLUSH_ZEROOUT))) return -EINVAL; - if (!q) - return -ENXIO; - - if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) + if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && + !bdev_max_discard_sectors(journal->j_dev)) return -EOPNOTSUPP; /* diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c index 03a845ab4f009..357ae6e5c36ec 100644 --- a/fs/jfs/ioctl.c +++ b/fs/jfs/ioctl.c @@ -117,7 +117,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(sb->s_bdev)) { jfs_warn("FITRIM not supported on device"); return -EOPNOTSUPP; } diff --git a/fs/jfs/super.c b/fs/jfs/super.c index f1a13a74cddf3..85d4f44f2ac4d 100644 --- a/fs/jfs/super.c +++ b/fs/jfs/super.c @@ -372,19 +372,16 @@ static int parse_options(char *options, struct super_block *sb, s64 *newLVSize, } case Opt_discard: - { - struct request_queue *q = bdev_get_queue(sb->s_bdev); /* if set to 1, even copying files will cause * trimming :O * -> user has more control over the online trimming */ sbi->minblks_trim = 64; - if (blk_queue_discard(q)) + if (bdev_max_discard_sectors(sb->s_bdev)) *flag |= JFS_DISCARD; else pr_err("JFS: discard option not supported on device\n"); break; - } case Opt_nodiscard: *flag &= ~JFS_DISCARD; @@ -392,10 +389,9 @@ static int parse_options(char *options, struct super_block *sb, s64 *newLVSize, case Opt_discard_minblk: { - struct request_queue *q = bdev_get_queue(sb->s_bdev); char *minblks_trim = args[0].from; int rc; - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(sb->s_bdev)) { *flag |= JFS_DISCARD; rc = kstrtouint(minblks_trim, 0, &sbi->minblks_trim); diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c index fec194a666f4b..52b73f558fcb1 100644 --- a/fs/nilfs2/ioctl.c +++ b/fs/nilfs2/ioctl.c @@ -1059,7 +1059,7 @@ static int nilfs_ioctl_trim_fs(struct inode *inode, void __user *argp) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(nilfs->ns_bdev)) return -EOPNOTSUPP; if (copy_from_user(&range, argp, sizeof(range))) diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c index 787b53b984ee1..e763236169331 100644 --- a/fs/ntfs3/file.c +++ b/fs/ntfs3/file.c @@ -28,7 +28,7 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sbi->sb->s_bdev)) return -EOPNOTSUPP; user_range = (struct fstrim_range __user *)arg; diff --git a/fs/ntfs3/super.c b/fs/ntfs3/super.c index cd30e81abbce0..c734085bcce4a 100644 --- a/fs/ntfs3/super.c +++ b/fs/ntfs3/super.c @@ -913,7 +913,7 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) } rq = bdev_get_queue(bdev); - if (blk_queue_discard(rq) && rq->limits.discard_granularity) { + if (bdev_max_discard_sectors(bdev) && rq->limits.discard_granularity) { sbi->discard_granularity = rq->limits.discard_granularity; sbi->discard_granularity_mask_inv = ~(u64)(sbi->discard_granularity - 1); diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c index f59461d85da45..9b78ef103ada6 100644 --- a/fs/ocfs2/ioctl.c +++ b/fs/ocfs2/ioctl.c @@ -910,7 +910,7 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; if (copy_from_user(&range, argp, sizeof(range))) diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c index 0191de8ce9ced..a4e6609d616b7 100644 --- a/fs/xfs/xfs_discard.c +++ b/fs/xfs/xfs_discard.c @@ -162,7 +162,7 @@ xfs_ioc_trim( if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(mp->m_ddev_targp->bt_bdev)) return -EOPNOTSUPP; /* diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c index 54be9d64093ed..a276b8111f636 100644 --- a/fs/xfs/xfs_super.c +++ b/fs/xfs/xfs_super.c @@ -1608,14 +1608,10 @@ xfs_fs_fill_super( goto out_filestream_unmount; } - if (xfs_has_discard(mp)) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - - if (!blk_queue_discard(q)) { - xfs_warn(mp, "mounting with \"discard\" option, but " - "the device does not support discard"); - mp->m_features &= ~XFS_FEAT_DISCARD; - } + if (xfs_has_discard(mp) && !bdev_max_discard_sectors(sb->s_bdev)) { + xfs_warn(mp, + "mounting with \"discard\" option, but the device does not support discard"); + mp->m_features &= ~XFS_FEAT_DISCARD; } if (xfs_has_reflink(mp)) { diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index ce16247d3afab..767ab22e1052a 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -540,7 +540,6 @@ struct request_queue { #define QUEUE_FLAG_NONROT 6 /* non-rotational device (SSD) */ #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */ #define QUEUE_FLAG_IO_STAT 7 /* do disk/partitions IO accounting */ -#define QUEUE_FLAG_DISCARD 8 /* supports DISCARD */ #define QUEUE_FLAG_NOXMERGES 9 /* No extended merges */ #define QUEUE_FLAG_ADD_RANDOM 10 /* Contributes to random pool */ #define QUEUE_FLAG_SECERASE 11 /* supports secure erase */ @@ -582,7 +581,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); test_bit(QUEUE_FLAG_STABLE_WRITES, &(q)->queue_flags) #define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags) #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags) -#define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags) #define blk_queue_zone_resetall(q) \ test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags) #define blk_queue_secure_erase(q) \ diff --git a/mm/swapfile.c b/mm/swapfile.c index 4069f17a82c8e..5d9cedf9e7b84 100644 --- a/mm/swapfile.c +++ b/mm/swapfile.c @@ -2957,20 +2957,6 @@ static int setup_swap_map_and_extents(struct swap_info_struct *p, return nr_extents; } -/* - * Helper to sys_swapon determining if a given swap - * backing device queue supports DISCARD operations. - */ -static bool swap_discardable(struct swap_info_struct *si) -{ - struct request_queue *q = bdev_get_queue(si->bdev); - - if (!blk_queue_discard(q)) - return false; - - return true; -} - SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) { struct swap_info_struct *p; @@ -3132,7 +3118,8 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) sizeof(long), GFP_KERNEL); - if (p->bdev && (swap_flags & SWAP_FLAG_DISCARD) && swap_discardable(p)) { + if ((swap_flags & SWAP_FLAG_DISCARD) && + p->bdev && bdev_max_discard_sectors(p->bdev)) { /* * When discard is enabled for swap with no particular * policy flagged, we set all swap discard flags here in -- 2.30.2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.sourceforge.net (lists.sourceforge.net [216.105.38.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 44DBAC4167D for ; Sat, 9 Apr 2022 04:52:47 +0000 (UTC) Received: from [127.0.0.1] (helo=sfs-ml-1.v29.lw.sourceforge.com) by sfs-ml-1.v29.lw.sourceforge.com with esmtp (Exim 4.94.2) (envelope-from ) id 1nd35a-0002kK-Ki; Sat, 09 Apr 2022 04:52:45 +0000 Received: from [172.30.20.202] (helo=mx.sourceforge.net) by sfs-ml-1.v29.lw.sourceforge.com with esmtps (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1nd35Y-0002jr-Lv; Sat, 09 Apr 2022 04:52:43 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sourceforge.net; s=x; h=Content-Transfer-Encoding:Content-Type:MIME-Version :References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=lhrI7Npx42D1AuR/cMyqCoOjrZczBcvFSvpyDVoTBuM=; b=dThtKU8LkN1PZzpAvWeBKP5LG+ 0rINQNbWnzfd8wr9wFQf1mLd9TXf+3bOO/0IOrixNrmfkjZY+siysxOeXy+S42JowUgQ0Ro8Y4PCA PhZo+bxb1wVAv5wjGmokzmkpJ5uRcNwe8zFaJP1bSV7rtcUP41z5VEU9onB6EHYyILDU=; DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sf.net; s=x ; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References: In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=lhrI7Npx42D1AuR/cMyqCoOjrZczBcvFSvpyDVoTBuM=; b=lFdivjdnc9a3qqSiOw7R++fRwj sZkMXNc0gjK4SqI+Jy9Iszq17a9f4kUOiX7/UupCiFeJux7GUzNVwnm9Llt34i63UAAODsuIjDtYk nYeeVNC5mG2ahyFXu8AKEHYbyADULUyUEGY7Hj6Q8A6ff9n+s9oE4qgwDYBftiEaLEmA=; Received: from bombadil.infradead.org ([198.137.202.133]) by sfi-mx-2.v28.lw.sourceforge.com with esmtps (TLS1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.94.2) id 1nd35U-0001BS-6q; Sat, 09 Apr 2022 04:52:43 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc: To:From:Sender:Reply-To:Content-ID:Content-Description; bh=lhrI7Npx42D1AuR/cMyqCoOjrZczBcvFSvpyDVoTBuM=; b=Sjapi7eI4Jh86xiPLIzL2g0V1J mjcOCE9buuik3xQceo12VbO7h4X1i/S8+EGUcf1u3xFqviUr0IXMxs/3Qij4rUA/BVYuftFH0B+QL 15jKW5DOWLXn3fZpnfOdPjT+8sq7nSyHdBxT6coOufp9mqpgHjMXvI28DvNWovru926kmp5e+ex7c /jYKn9KuBgqzsQrl/W/fJF4dNs6aceGzPpdLj4fBSiNAx7tFXGHLE6PclN+/DWpkJQW8eCCHQlhYf t5bRpzLnnxe4LGnXML4qPk3asM8WCBUpA/jrjYRG0MkY4Dc8Ud6n31tOOsdykMc3zj9OSK9AysXdb fD5Kz47g==; Received: from 213-147-167-116.nat.highway.webapn.at ([213.147.167.116] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.94.2 #2 (Red Hat Linux)) id 1nd354-0021dK-Sw; Sat, 09 Apr 2022 04:52:15 +0000 From: Christoph Hellwig To: Jens Axboe Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-Id: <20220409045043.23593-25-hch@lst.de> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> MIME-Version: 1.0 X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html X-Headers-End: 1nd35U-0001BS-6q Subject: [f2fs-dev] [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD X-BeenThere: linux-f2fs-devel@lists.sourceforge.net X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jfs-discussion@lists.sourceforge.net, linux-nvme@lists.infradead.org, virtualization@lists.linux-foundation.org, linux-mm@kvack.org, dm-devel@redhat.com, target-devel@vger.kernel.org, linux-mtd@lists.infradead.org, drbd-dev@lists.linbit.com, linux-s390@vger.kernel.org, linux-nilfs@vger.kernel.org, linux-scsi@vger.kernel.org, cluster-devel@redhat.com, xen-devel@lists.xenproject.org, linux-ext4@vger.kernel.org, linux-um@lists.infradead.org, nbd@other.debian.org, linux-block@vger.kernel.org, linux-bcache@vger.kernel.org, ceph-devel@vger.kernel.org, Coly Li , linux-raid@vger.kernel.org, "Martin K . Petersen" , linux-mmc@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-xfs@vger.kernel.org, =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , ocfs2-devel@oss.oracle.com, linux-fsdevel@vger.kernel.org, ntfs3@lists.linux.dev, linux-btrfs@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net SnVzdCB1c2UgYSBub24temVybyBtYXhfZGlzY2FyZF9zZWN0b3JzIGFzIGFuIGluZGljYXRvciBm b3IgZGlzY2FyZApzdXBwb3J0LCBzaW1pbGFyIHRvIHdoYXQgaXMgZG9uZSBmb3Igd3JpdGUgemVy b2VzLgoKVGhlIG9ubHkgcGxhY2VzIHdoZXJlIG5lZWRzIHNwZWNpYWwgYXR0ZW50aW9uIGlzIHRo ZSBSQUlENSBkcml2ZXIsCndoaWNoIG11c3QgY2xlYXIgZGlzY2FyZCBzdXBwb3J0IGZvciBzZWN1 cml0eSByZWFzb25zIGJ5IGRlZmF1bHQsCmV2ZW4gaWYgdGhlIGRlZmF1bHQgc3RhY2tpbmcgcnVs ZXMgd291bGQgYWxsb3cgZm9yIGl0LgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcg PGhjaEBsc3QuZGU+ClJldmlld2VkLWJ5OiBNYXJ0aW4gSy4gUGV0ZXJzZW4gPG1hcnRpbi5wZXRl cnNlbkBvcmFjbGUuY29tPgpBY2tlZC1ieTogQ2hyaXN0b3BoIELDtmhtd2FsZGVyIDxjaHJpc3Rv cGguYm9laG13YWxkZXJAbGluYml0LmNvbT4gW2J0cmZzXQpBY2tlZC1ieTogQ29seSBMaSA8Y29s eWxpQHN1c2UuZGU+IFtiY2FjaGVdCi0tLQogYXJjaC91bS9kcml2ZXJzL3ViZF9rZXJuLmMgICAg ICAgICAgfCAgMiAtLQogYmxvY2svYmxrLWNvcmUuYyAgICAgICAgICAgICAgICAgICAgfCAgMiAr LQogYmxvY2svYmxrLWxpYi5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogYmxvY2svYmxr LW1xLWRlYnVnZnMuYyAgICAgICAgICAgICAgfCAgMSAtCiBibG9jay9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgICB8ICAzICstLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbWFpbi5jICAg ICAgfCAgMiArLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYyAgICAgICAgfCAxOSArKy0t LS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jICB8ICAz ICstLQogZHJpdmVycy9ibG9jay9sb29wLmMgICAgICAgICAgICAgICAgfCAxMSArKystLS0tLS0t LQogZHJpdmVycy9ibG9jay9uYmQuYyAgICAgICAgICAgICAgICAgfCAgNSArLS0tLQogZHJpdmVy cy9ibG9jay9udWxsX2Jsay9tYWluLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL2Jsb2NrL3JiZC5j ICAgICAgICAgICAgICAgICB8ICAxIC0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jICAg ICAgIHwgIDIgLS0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaCAgIHwgIDMgLS0t CiBkcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYyAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Js b2NrL3hlbi1ibGtiYWNrL3hlbmJ1cy5jICB8ICAyICstCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtm cm9udC5jICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYyAgICAg ICB8ICAxIC0KIGRyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYyAgICAgICAgIHwgIDQgKystLQog ZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYyAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv YmNhY2hlL3N5c2ZzLmMgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvbWQvZG0tY2FjaGUtdGFy Z2V0LmMgICAgICAgIHwgIDkgKy0tLS0tLS0tCiBkcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5j ICAgICAgICB8ICA5ICstLS0tLS0tLQogZHJpdmVycy9tZC9kbS1sb2ctd3JpdGVzLmMgICAgICAg ICAgfCAgMyArLS0KIGRyaXZlcnMvbWQvZG0tcmFpZC5jICAgICAgICAgICAgICAgIHwgIDkgKyst LS0tLS0tCiBkcml2ZXJzL21kL2RtLXRhYmxlLmMgICAgICAgICAgICAgICB8ICA5ICsrLS0tLS0t LQogZHJpdmVycy9tZC9kbS10aGluLmMgICAgICAgICAgICAgICAgfCAxMSArLS0tLS0tLS0tLQog ZHJpdmVycy9tZC9kbS5jICAgICAgICAgICAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv bWQtbGluZWFyLmMgICAgICAgICAgICAgIHwgMTEgKy0tLS0tLS0tLS0KIGRyaXZlcnMvbWQvcmFp ZDAuYyAgICAgICAgICAgICAgICAgIHwgIDcgLS0tLS0tLQogZHJpdmVycy9tZC9yYWlkMS5jICAg ICAgICAgICAgICAgICAgfCAxNiArLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL21kL3JhaWQxMC5j ICAgICAgICAgICAgICAgICB8IDE4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tZC9yYWlk NS1jYWNoZS5jICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9tZC9yYWlkNS5jICAgICAgICAg ICAgICAgICAgfCAxMiArKysrLS0tLS0tLS0KIGRyaXZlcnMvbW1jL2NvcmUvcXVldWUuYyAgICAg ICAgICAgIHwgIDEgLQogZHJpdmVycy9tdGQvbXRkX2Jsa2RldnMuYyAgICAgICAgICAgfCAgMSAt CiBkcml2ZXJzL252bWUvaG9zdC9jb3JlLmMgICAgICAgICAgICB8ICA2ICsrLS0tLQogZHJpdmVy cy9zMzkwL2Jsb2NrL2Rhc2RfZmJhLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL3Njc2kvc2QuYyAg ICAgICAgICAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9kZXZp Y2UuYyB8ICAyICstCiBmcy9idHJmcy9leHRlbnQtdHJlZS5jICAgICAgICAgICAgICB8ICA0ICsr LS0KIGZzL2J0cmZzL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0 L2ZpbGUuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0L3N1cGVyLmMgICAg ICAgICAgICAgICAgICAgIHwgMTAgKysrLS0tLS0tLQogZnMvZXh0NC9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgfCAxMCArKystLS0tLS0tCiBmcy9leHQ0L3N1cGVyLmMgICAgICAgICAgICAg ICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZzL2YyZnMvZjJmcy5oICAgICAgICAgICAgICAgICAg ICAgIHwgIDMgKy0tCiBmcy9mYXQvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgICB8ICAyICst CiBmcy9mYXQvaW5vZGUuYyAgICAgICAgICAgICAgICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZz L2dmczIvcmdycC5jICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2piZDIvam91cm5h bC5jICAgICAgICAgICAgICAgICAgIHwgIDcgKystLS0tLQogZnMvamZzL2lvY3RsLmMgICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQogZnMvamZzL3N1cGVyLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgOCArKy0tLS0tLQogZnMvbmlsZnMyL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgfCAg MiArLQogZnMvbnRmczMvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvbnRm czMvc3VwZXIuYyAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvb2NmczIvaW9jdGwuYyAg ICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMveGZzL3hmc19kaXNjYXJkLmMgICAgICAgICAg ICAgICAgfCAgMiArLQogZnMveGZzL3hmc19zdXBlci5jICAgICAgICAgICAgICAgICAgfCAxMiAr KysrLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvYmxrZGV2LmggICAgICAgICAgICAgIHwgIDIgLS0K IG1tL3N3YXBmaWxlLmMgICAgICAgICAgICAgICAgICAgICAgIHwgMTcgKystLS0tLS0tLS0tLS0t LS0KIDYxIGZpbGVzIGNoYW5nZWQsIDcyIGluc2VydGlvbnMoKyksIDI0NiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvdWJkX2tlcm4uYyBiL2FyY2gvdW0vZHJpdmVy cy91YmRfa2Vybi5jCmluZGV4IGIwMzI2OWZhZWY3MTQuLjA4NWZmZGY5OGU1N2UgMTAwNjQ0Ci0t LSBhL2FyY2gvdW0vZHJpdmVycy91YmRfa2Vybi5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy91YmRf a2Vybi5jCkBAIC00ODMsNyArNDgzLDYgQEAgc3RhdGljIHZvaWQgdWJkX2hhbmRsZXIodm9pZCkK IAkJCWlmICgoaW9fcmVxLT5lcnJvciA9PSBCTEtfU1RTX05PVFNVUFApICYmIChyZXFfb3AoaW9f cmVxLT5yZXEpID09IFJFUV9PUF9ESVNDQVJEKSkgewogCQkJCWJsa19xdWV1ZV9tYXhfZGlzY2Fy ZF9zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKIAkJCQlibGtfcXVldWVfbWF4X3dyaXRlX3pl cm9lc19zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKLQkJCQlibGtfcXVldWVfZmxhZ19jbGVh cihRVUVVRV9GTEFHX0RJU0NBUkQsIGlvX3JlcS0+cmVxLT5xKTsKIAkJCX0KIAkJCWJsa19tcV9l bmRfcmVxdWVzdChpb19yZXEtPnJlcSwgaW9fcmVxLT5lcnJvcik7CiAJCQlrZnJlZShpb19yZXEp OwpAQCAtODAzLDcgKzgwMiw2IEBAIHN0YXRpYyBpbnQgdWJkX29wZW5fZGV2KHN0cnVjdCB1YmQg KnViZF9kZXYpCiAJCXViZF9kZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQgPSBT RUNUT1JfU0laRTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnModWJkX2Rldi0+cXVl dWUsIFVCRF9NQVhfUkVRVUVTVCk7CiAJCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3Rv cnModWJkX2Rldi0+cXVldWUsIFVCRF9NQVhfUkVRVUVTVCk7Ci0JCWJsa19xdWV1ZV9mbGFnX3Nl dChRVUVVRV9GTEFHX0RJU0NBUkQsIHViZF9kZXYtPnF1ZXVlKTsKIAl9CiAJYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfTk9OUk9ULCB1YmRfZGV2LT5xdWV1ZSk7CiAJcmV0dXJuIDA7CmRp ZmYgLS1naXQgYS9ibG9jay9ibGstY29yZS5jIGIvYmxvY2svYmxrLWNvcmUuYwppbmRleCA5Mzdi YjZiODYzMzE3Li5iNWMzYTgwNDkxMzRjIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY29yZS5jCisr KyBiL2Jsb2NrL2Jsay1jb3JlLmMKQEAgLTgyMCw3ICs4MjAsNyBAQCB2b2lkIHN1Ym1pdF9iaW9f bm9hY2N0KHN0cnVjdCBiaW8gKmJpbykKIAogCXN3aXRjaCAoYmlvX29wKGJpbykpIHsKIAljYXNl IFJFUV9PUF9ESVNDQVJEOgotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQorCQlpZiAoIWJk ZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSkKIAkJCWdvdG8gbm90X3N1cHBvcnRlZDsKIAkJ YnJlYWs7CiAJY2FzZSBSRVFfT1BfU0VDVVJFX0VSQVNFOgpkaWZmIC0tZ2l0IGEvYmxvY2svYmxr LWxpYi5jIGIvYmxvY2svYmxrLWxpYi5jCmluZGV4IDJhZTMyYTcyMjg1MWMuLjhiNGI2NmQzYTli ZmMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1saWIuYworKysgYi9ibG9jay9ibGstbGliLmMKQEAg LTUzLDcgKzUzLDcgQEAgaW50IF9fYmxrZGV2X2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2Rl dmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCQlv cCA9IFJFUV9PUF9TRUNVUkVfRVJBU0U7CiAJfSBlbHNlIHsKLQkJaWYgKCFibGtfcXVldWVfZGlz Y2FyZChxKSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAJCW9wID0gUkVRX09QX0RJU0NBUkQ7CiAJfQpkaWZmIC0tZ2l0IGEv YmxvY2svYmxrLW1xLWRlYnVnZnMuYyBiL2Jsb2NrL2Jsay1tcS1kZWJ1Z2ZzLmMKaW5kZXggYWEw MzQ5ZTlmMDgzYi4uZmQxMTFjNTAwMTI1NiAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLW1xLWRlYnVn ZnMuYworKysgYi9ibG9jay9ibGstbXEtZGVidWdmcy5jCkBAIC0xMTMsNyArMTEzLDYgQEAgc3Rh dGljIGNvbnN0IGNoYXIgKmNvbnN0IGJsa19xdWV1ZV9mbGFnX25hbWVbXSA9IHsKIAlRVUVVRV9G TEFHX05BTUUoRkFJTF9JTyksCiAJUVVFVUVfRkxBR19OQU1FKE5PTlJPVCksCiAJUVVFVUVfRkxB R19OQU1FKElPX1NUQVQpLAotCVFVRVVFX0ZMQUdfTkFNRShESVNDQVJEKSwKIAlRVUVVRV9GTEFH X05BTUUoTk9YTUVSR0VTKSwKIAlRVUVVRV9GTEFHX05BTUUoQUREX1JBTkRPTSksCiAJUVVFVUVf RkxBR19OQU1FKFNFQ0VSQVNFKSwKZGlmZiAtLWdpdCBhL2Jsb2NrL2lvY3RsLmMgYi9ibG9jay9p b2N0bC5jCmluZGV4IGFkMzc3MWIyNjhiODEuLmMyY2QzYmE1MjkwY2UgMTAwNjQ0Ci0tLSBhL2Js b2NrL2lvY3RsLmMKKysrIGIvYmxvY2svaW9jdGwuYwpAQCAtODcsMTQgKzg3LDEzIEBAIHN0YXRp YyBpbnQgYmxrX2lvY3RsX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlLAogewogCXVpbnQ2NF90IHJhbmdlWzJdOwogCXVpbnQ2NF90IHN0YXJ0LCBsZW47Ci0J c3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShiZGV2KTsKIAlzdHJ1Y3Qg aW5vZGUgKmlub2RlID0gYmRldi0+YmRfaW5vZGU7CiAJaW50IGVycjsKIAogCWlmICghKG1vZGUg JiBGTU9ERV9XUklURSkpCiAJCXJldHVybiAtRUJBREY7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQlyZXR1cm4g LUVPUE5PVFNVUFA7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIocmFuZ2UsICh2b2lkIF9fdXNlciAq KWFyZywgc2l6ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJi ZF9tYWluLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMKaW5kZXggZWFlNjI5YzRm NmVhZi4uYTY5NDc1ZTU5MjgyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf bWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX21haW4uYwpAQCAtOTQyLDcgKzk0 Miw3IEBAIGludCBkcmJkX3NlbmRfc2l6ZXMoc3RydWN0IGRyYmRfcGVlcl9kZXZpY2UgKnBlZXJf ZGV2aWNlLCBpbnQgdHJpZ2dlcl9yZXBseSwgZW51CiAJCQljcHVfdG9fYmUzMihiZGV2X2FsaWdu bWVudF9vZmZzZXQoYmRldikpOwogCQlwLT5xbGltLT5pb19taW4gPSBjcHVfdG9fYmUzMihiZGV2 X2lvX21pbihiZGV2KSk7CiAJCXAtPnFsaW0tPmlvX29wdCA9IGNwdV90b19iZTMyKGJkZXZfaW9f b3B0KGJkZXYpKTsKLQkJcC0+cWxpbS0+ZGlzY2FyZF9lbmFibGVkID0gYmxrX3F1ZXVlX2Rpc2Nh cmQocSk7CisJCXAtPnFsaW0tPmRpc2NhcmRfZW5hYmxlZCA9ICEhYmRldl9tYXhfZGlzY2FyZF9z ZWN0b3JzKGJkZXYpOwogCQlwdXRfbGRldihkZXZpY2UpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBy ZXF1ZXN0X3F1ZXVlICpxID0gZGV2aWNlLT5ycV9xdWV1ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv YmxvY2svZHJiZC9kcmJkX25sLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9ubC5jCmluZGV4 IGQ0ZGFjYzMyOWFjMmUuLmI1NWU1ZmNjMjFlMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv ZHJiZC9kcmJkX25sLmMKKysrIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYwpAQCAtMTIx MCw3ICsxMjEwLDcgQEAgc3RhdGljIHZvaWQgZGVjaWRlX29uX2Rpc2NhcmRfc3VwcG9ydChzdHJ1 Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwKIAkJZmlyc3RfcGVlcl9kZXZpY2UoZGV2aWNlKS0+Y29u bmVjdGlvbjsKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGRldmljZS0+cnFfcXVldWU7CiAK LQlpZiAoYmRldiAmJiAhYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldi0+YmFja2luZ19iZGV2LT5iZF9k aXNrLT5xdWV1ZSkpCisJaWYgKGJkZXYgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2 LT5iYWNraW5nX2JkZXYpKQogCQlnb3RvIG5vdF9zdXBwb3J0ZWQ7CiAKIAlpZiAoY29ubmVjdGlv bi0+Y3N0YXRlID49IENfQ09OTkVDVEVEICYmCkBAIC0xMjMwLDMwICsxMjMwLDE2IEBAIHN0YXRp YyB2b2lkIGRlY2lkZV9vbl9kaXNjYXJkX3N1cHBvcnQoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZp Y2UsCiAJICovCiAJYmxrX3F1ZXVlX2Rpc2NhcmRfZ3JhbnVsYXJpdHkocSwgNTEyKTsKIAlxLT5s aW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9ycyA9IGRyYmRfbWF4X2Rpc2NhcmRfc2VjdG9ycyhjb25u ZWN0aW9uKTsKLQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAlx LT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0KIAkJZHJiZF9tYXhfZGlzY2FyZF9z ZWN0b3JzKGNvbm5lY3Rpb24pOwogCXJldHVybjsKIAogbm90X3N1cHBvcnRlZDoKLQlibGtfcXVl dWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwogCWJsa19xdWV1ZV9kaXNjYXJk X2dyYW51bGFyaXR5KHEsIDApOwogCXEtPmxpbWl0cy5tYXhfZGlzY2FyZF9zZWN0b3JzID0gMDsK IAlxLT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0gMDsKIH0KIAotc3RhdGljIHZv aWQgZml4dXBfZGlzY2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpx KQotewotCS8qIFRvIGF2b2lkIGNvbmZ1c2lvbiwgaWYgdGhpcyBxdWV1ZSBkb2VzIG5vdCBzdXBw b3J0IGRpc2NhcmQsIGNsZWFyCi0JICogbWF4X2Rpc2NhcmRfc2VjdG9ycywgd2hpY2ggaXMgd2hh dCBsc2JsayAtRCByZXBvcnRzIHRvIHRoZSB1c2VyLgotCSAqIE9sZGVyIGtlcm5lbHMgZ290IHRo aXMgd3JvbmcgaW4gInN0YWNrIGxpbWl0cyIuCi0JICogKi8KLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKSB7Ci0JCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIDApOwotCQlibGtf cXVldWVfZGlzY2FyZF9ncmFudWxhcml0eShxLCAwKTsKLQl9Ci19Ci0KIHN0YXRpYyB2b2lkIGZp eHVwX3dyaXRlX3plcm9lcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwgc3RydWN0IHJlcXVl c3RfcXVldWUgKnEpCiB7CiAJLyogRml4dXAgbWF4X3dyaXRlX3plcm9lc19zZWN0b3JzIGFmdGVy IGJsa19zdGFja19saW1pdHMoKToKQEAgLTEzMDAsNyArMTI4Niw2IEBAIHN0YXRpYyB2b2lkIGRy YmRfc2V0dXBfcXVldWVfcGFyYW0oc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBk cmJkX2JhY2tpCiAJCWJsa19zdGFja19saW1pdHMoJnEtPmxpbWl0cywgJmItPmxpbWl0cywgMCk7 CiAJCWRpc2tfdXBkYXRlX3JlYWRhaGVhZChkZXZpY2UtPnZkaXNrKTsKIAl9Ci0JZml4dXBfZGlz Y2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHEpOwogCWZpeHVwX3dyaXRlX3plcm9lcyhkZXZpY2UsIHEp OwogfQogCkBAIC0xNDQ3LDcgKzE0MzIsNyBAQCBzdGF0aWMgdm9pZCBzYW5pdGl6ZV9kaXNrX2Nv bmYoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBkaXNrX2NvbmYgKmRpcwogCWlm IChkaXNrX2NvbmYtPmFsX2V4dGVudHMgPiBkcmJkX2FsX2V4dGVudHNfbWF4KG5iYykpCiAJCWRp c2tfY29uZi0+YWxfZXh0ZW50cyA9IGRyYmRfYWxfZXh0ZW50c19tYXgobmJjKTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhi ZGV2KSkgewogCQlpZiAoZGlza19jb25mLT5yc19kaXNjYXJkX2dyYW51bGFyaXR5KSB7CiAJCQlk aXNrX2NvbmYtPnJzX2Rpc2NhcmRfZ3JhbnVsYXJpdHkgPSAwOyAvKiBkaXNhYmxlIGZlYXR1cmUg Ki8KIAkJCWRyYmRfaW5mbyhkZXZpY2UsICJyc19kaXNjYXJkX2dyYW51bGFyaXR5IGZlYXR1cmUg ZGlzYWJsZWRcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2 ZXIuYyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX3JlY2VpdmVyLmMKaW5kZXggMGI0YzdkZTQ2 Mzk4OS4uOGE0YTQ3ZGE1NmZlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf cmVjZWl2ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC0x NTc1LDExICsxNTc1LDEwIEBAIGludCBkcmJkX2lzc3VlX2Rpc2NhcmRfb3JfemVyb19vdXQoc3Ry dWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHNlY3Rvcl90IHN0YXJ0LCB1CiAKIHN0YXRpYyBib29s IGNhbl9kb19yZWxpYWJsZV9kaXNjYXJkcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSkKIHsK LQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGRldmljZS0+bGRldi0+ YmFja2luZ19iZGV2KTsKIAlzdHJ1Y3QgZGlza19jb25mICpkYzsKIAlib29sIGNhbl9kbzsKIAot CWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoZGV2aWNlLT5sZGV2LT5iYWNraW5nX2JkZXYpKQogCQlyZXR1cm4gZmFsc2U7CiAKIAlyY3Vf cmVhZF9sb2NrKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYyBiL2RyaXZlcnMv YmxvY2svbG9vcC5jCmluZGV4IDhkODAwZDQ2ZTQ5ODUuLjBlMDYxYzk4OTZlZmYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCkBAIC0z MTQsMTUgKzMxNCwxMiBAQCBzdGF0aWMgaW50IGxvX2ZhbGxvY2F0ZShzdHJ1Y3QgbG9vcF9kZXZp Y2UgKmxvLCBzdHJ1Y3QgcmVxdWVzdCAqcnEsIGxvZmZfdCBwb3MsCiAKIAltb2RlIHw9IEZBTExP Q19GTF9LRUVQX1NJWkU7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKGxvLT5sb19xdWV1ZSkp IHsKLQkJcmV0ID0gLUVPUE5PVFNVUFA7Ci0JCWdvdG8gb3V0OwotCX0KKwlpZiAoIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhsby0+bG9fZGV2aWNlKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOwog CiAJcmV0ID0gZmlsZS0+Zl9vcC0+ZmFsbG9jYXRlKGZpbGUsIG1vZGUsIHBvcywgYmxrX3JxX2J5 dGVzKHJxKSk7CiAJaWYgKHVubGlrZWx5KHJldCAmJiByZXQgIT0gLUVJTlZBTCAmJiByZXQgIT0g LUVPUE5PVFNVUFApKQotCQlyZXQgPSAtRUlPOwotIG91dDoKKwkJcmV0dXJuIC1FSU87CiAJcmV0 dXJuIHJldDsKIH0KIApAQCAtNzg3LDEyICs3ODQsMTAgQEAgc3RhdGljIHZvaWQgbG9vcF9jb25m aWdfZGlzY2FyZChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvKQogCQlxLT5saW1pdHMuZGlzY2FyZF9n cmFudWxhcml0eSA9IGdyYW51bGFyaXR5OwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9y cyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKIAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNf c2VjdG9ycyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFV RVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJfSBlbHNlIHsKIAkJcS0+bGltaXRzLmRpc2NhcmRfZ3Jh bnVsYXJpdHkgPSAwOwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCAwKTsKIAkJ YmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhxLCAwKTsKLQkJYmxrX3F1ZXVlX2Zs YWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAl9CiAJcS0+bGltaXRzLmRpc2NhcmRf YWxpZ25tZW50ID0gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbmJkLmMgYi9kcml2 ZXJzL2Jsb2NrL25iZC5jCmluZGV4IDVhMWY5ODQ5NGRkZGYuLjQ3MjlhZWY4YzY0NjIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYmxvY2svbmJkLmMKKysrIGIvZHJpdmVycy9ibG9jay9uYmQuYwpAQCAt MTIzMSw4ICsxMjMxLDYgQEAgc3RhdGljIHZvaWQgbmJkX3BhcnNlX2ZsYWdzKHN0cnVjdCBuYmRf ZGV2aWNlICpuYmQpCiAJCXNldF9kaXNrX3JvKG5iZC0+ZGlzaywgdHJ1ZSk7CiAJZWxzZQogCQlz ZXRfZGlza19ybyhuYmQtPmRpc2ssIGZhbHNlKTsKLQlpZiAoY29uZmlnLT5mbGFncyAmIE5CRF9G TEFHX1NFTkRfVFJJTSkKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwg bmJkLT5kaXNrLT5xdWV1ZSk7CiAJaWYgKGNvbmZpZy0+ZmxhZ3MgJiBOQkRfRkxBR19TRU5EX0ZM VVNIKSB7CiAJCWlmIChjb25maWctPmZsYWdzICYgTkJEX0ZMQUdfU0VORF9GVUEpCiAJCQlibGtf cXVldWVfd3JpdGVfY2FjaGUobmJkLT5kaXNrLT5xdWV1ZSwgdHJ1ZSwgdHJ1ZSk7CkBAIC0xMzE5 LDggKzEzMTcsNyBAQCBzdGF0aWMgdm9pZCBuYmRfY29uZmlnX3B1dChzdHJ1Y3QgbmJkX2Rldmlj ZSAqbmJkKQogCQluYmQtPnRhZ19zZXQudGltZW91dCA9IDA7CiAJCW5iZC0+ZGlzay0+cXVldWUt PmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJbmJkLT5kaXNrLT5xdWV1ZS0+bGlt aXRzLmRpc2NhcmRfYWxpZ25tZW50ID0gMDsKLQkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3Rv cnMobmJkLT5kaXNrLT5xdWV1ZSwgVUlOVF9NQVgpOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIG5iZC0+ZGlzay0+cXVldWUpOworCQlibGtfcXVldWVfbWF4X2Rp c2NhcmRfc2VjdG9ycyhuYmQtPmRpc2stPnF1ZXVlLCAwKTsKIAogCQltdXRleF91bmxvY2soJm5i ZC0+Y29uZmlnX2xvY2spOwogCQluYmRfcHV0KG5iZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Js b2NrL251bGxfYmxrL21haW4uYyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCmluZGV4 IDA1YjExMjBlNjYyMzQuLmY2NDkzYTllODVlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv bnVsbF9ibGsvbWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCkBAIC0x NzY3LDcgKzE3NjcsNiBAQCBzdGF0aWMgdm9pZCBudWxsX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBu dWxsYiAqbnVsbGIpCiAJbnVsbGItPnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gbnVs bGItPmRldi0+YmxvY2tzaXplOwogCW51bGxiLT5xLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQg PSBudWxsYi0+ZGV2LT5ibG9ja3NpemU7CiAJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMo bnVsbGItPnEsIFVJTlRfTUFYID4+IDkpOwotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFH X0RJU0NBUkQsIG51bGxiLT5xKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZp Y2Vfb3BlcmF0aW9ucyBudWxsX2Jpb19vcHMgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2Nr L3JiZC5jIGIvZHJpdmVycy9ibG9jay9yYmQuYwppbmRleCBiODQ0NDMyYmFkMjBiLi4yYjIxZjcx N2NjZTFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3JiZC5jCisrKyBiL2RyaXZlcnMvYmxv Y2svcmJkLmMKQEAgLTQ5NDIsNyArNDk0Miw2IEBAIHN0YXRpYyBpbnQgcmJkX2luaXRfZGlzayhz dHJ1Y3QgcmJkX2RldmljZSAqcmJkX2RldikKIAlibGtfcXVldWVfaW9fb3B0KHEsIHJiZF9kZXYt Pm9wdHMtPmFsbG9jX3NpemUpOwogCiAJaWYgKHJiZF9kZXYtPm9wdHMtPnRyaW0pIHsKLQkJYmxr X3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJCXEtPmxpbWl0cy5kaXNj YXJkX2dyYW51bGFyaXR5ID0gcmJkX2Rldi0+b3B0cy0+YWxsb2Nfc2l6ZTsKIAkJYmxrX3F1ZXVl X21heF9kaXNjYXJkX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNFQ1RPUl9TSElGVCk7CiAJ CWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNF Q1RPUl9TSElGVCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1jbHQuYyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCmluZGV4IGI2NmU4ODQwYjk0YjguLmVmYTk5 YTM4ODQ1MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCisrKyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCkBAIC0xMzY0LDggKzEzNjQsNiBAQCBzdGF0 aWMgdm9pZCBzZXR1cF9yZXF1ZXN0X3F1ZXVlKHN0cnVjdCBybmJkX2NsdF9kZXYgKmRldikKIAli bGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPnF1ZXVlLCBkZXYtPm1heF9kaXNjYXJk X3NlY3RvcnMpOwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5CT0gZGV2 LT5kaXNjYXJkX2dyYW51bGFyaXR5OwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2FsaWdu bWVudAk9IGRldi0+ZGlzY2FyZF9hbGlnbm1lbnQ7Ci0JaWYgKGRldi0+bWF4X2Rpc2NhcmRfc2Vj dG9ycykKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgZGV2LT5xdWV1 ZSk7CiAJaWYgKGRldi0+c2VjdXJlX2Rpc2NhcmQpCiAJCWJsa19xdWV1ZV9mbGFnX3NldChRVUVV RV9GTEFHX1NFQ0VSQVNFLCBkZXYtPnF1ZXVlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay9ybmJkL3JuYmQtc3J2LWRldi5oIGIvZHJpdmVycy9ibG9jay9ybmJkL3JuYmQtc3J2LWRldi5o CmluZGV4IGY4MmZiYjRiYmRhOGUuLjFmN2UxYzhmZDRkOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv YmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaAorKysgYi9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1z cnYtZGV2LmgKQEAgLTQ5LDkgKzQ5LDYgQEAgc3RhdGljIGlubGluZSBpbnQgcm5iZF9kZXZfZ2V0 X3NlY3VyZV9kaXNjYXJkKGNvbnN0IHN0cnVjdCBybmJkX2RldiAqZGV2KQogCiBzdGF0aWMgaW5s aW5lIGludCBybmJkX2Rldl9nZXRfbWF4X2Rpc2NhcmRfc2VjdHMoY29uc3Qgc3RydWN0IHJuYmRf ZGV2ICpkZXYpCiB7Ci0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShkZXYt PmJkZXYpKSkKLQkJcmV0dXJuIDA7Ci0KIAlyZXR1cm4gYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KGRldi0+YmRldik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svdmlydGlvX2Jsay5j IGIvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKaW5kZXggYThiY2YzZjY2NGFmMS4uNmNjZjE1 MjUzZGVlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKKysrIGIvZHJp dmVycy9ibG9jay92aXJ0aW9fYmxrLmMKQEAgLTg4OCw4ICs4ODgsNiBAQCBzdGF0aWMgaW50IHZp cnRibGtfcHJvYmUoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCiAJCQl2ID0gc2dfZWxlbXM7 CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWdtZW50cyhxLAogCQkJCQkgICAgICAgbWluKHYs IE1BWF9ESVNDQVJEX1NFR01FTlRTKSk7Ci0KLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZM QUdfRElTQ0FSRCwgcSk7CiAJfQogCiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJU SU9fQkxLX0ZfV1JJVEVfWkVST0VTKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrYmFjay94ZW5idXMuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2sveGVuYnVzLmMKaW5k ZXggOGI2OTFmZTUwNDc1Zi4uODNjZDA4MDQxZTZiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay94ZW4tYmxrYmFjay94ZW5idXMuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hl bmJ1cy5jCkBAIC01ODMsNyArNTgzLDcgQEAgc3RhdGljIHZvaWQgeGVuX2Jsa2JrX2Rpc2NhcmQo c3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQsIHN0cnVjdCBiYWNrZW5kX2luZm8KIAlpZiAo IXhlbmJ1c19yZWFkX3Vuc2lnbmVkKGRldi0+bm9kZW5hbWUsICJkaXNjYXJkLWVuYWJsZSIsIDEp KQogCQlyZXR1cm47CiAKLQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKSB7CiAJCWVyciA9IHhlbmJ1c19wcmludGYoeGJ0LCBk ZXYtPm5vZGVuYW1lLAogCQkJImRpc2NhcmQtZ3JhbnVsYXJpdHkiLCAiJXUiLAogCQkJcS0+bGlt aXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrZnJvbnQuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2Zyb250LmMKaW5kZXggMDAzMDU2ZDRm N2Y1Zi4uMjUzYmY4MzVhY2ExZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay94ZW4tYmxrZnJv bnQuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jCkBAIC05NDQsNyArOTQ0LDYg QEAgc3RhdGljIHZvaWQgYmxraWZfc2V0X3F1ZXVlX2xpbWl0cyhzdHJ1Y3QgYmxrZnJvbnRfaW5m byAqaW5mbykKIAlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19WSVJULCBycSk7CiAKIAlp ZiAoaW5mby0+ZmVhdHVyZV9kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX0RJU0NBUkQsIHJxKTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMocnEsIGdl dF9jYXBhY2l0eShnZCkpOwogCQlycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkgPSBpbmZv LT5kaXNjYXJkX2dyYW51bGFyaXR5ID86CiAJCQkJCQkgaW5mby0+cGh5c2ljYWxfc2VjdG9yX3Np emU7CkBAIC0xNjA2LDcgKzE2MDUsNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgYmxraWZfaW50ZXJy dXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAkJCQlibGtpZl9yZXEocmVxKS0+ZXJyb3IgPSBC TEtfU1RTX05PVFNVUFA7CiAJCQkJaW5mby0+ZmVhdHVyZV9kaXNjYXJkID0gMDsKIAkJCQlpbmZv LT5mZWF0dXJlX3NlY2Rpc2NhcmQgPSAwOwotCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfRElTQ0FSRCwgcnEpOwogCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdf U0VDRVJBU0UsIHJxKTsKIAkJCX0KIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay96cmFtL3pyYW1fZHJ2LmMgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwppbmRleCBl OTQ3NGIwMjAxMmRlLi41OWZmNDQ0YmY2Yzc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3py YW0venJhbV9kcnYuYworKysgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwpAQCAtMTk1 Miw3ICsxOTUyLDYgQEAgc3RhdGljIGludCB6cmFtX2FkZCh2b2lkKQogCWJsa19xdWV1ZV9pb19v cHQoenJhbS0+ZGlzay0+cXVldWUsIFBBR0VfU0laRSk7CiAJenJhbS0+ZGlzay0+cXVldWUtPmxp bWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gUEFHRV9TSVpFOwogCWJsa19xdWV1ZV9tYXhfZGlz Y2FyZF9zZWN0b3JzKHpyYW0tPmRpc2stPnF1ZXVlLCBVSU5UX01BWCk7Ci0JYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgenJhbS0+ZGlzay0+cXVldWUpOwogCiAJLyoKIAkg KiB6cmFtX2Jpb19kaXNjYXJkKCkgd2lsbCBjbGVhciBhbGwgbG9naWNhbCBibG9ja3MgaWYgbG9n aWNhbCBibG9jawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jIGIvZHJp dmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jCmluZGV4IGZkZDAxOTRmODRkZDAuLmUyN2Y2N2YwNmE0 MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYworKysgYi9kcml2ZXJz L21kL2JjYWNoZS9yZXF1ZXN0LmMKQEAgLTEwMDUsNyArMTAwNSw3IEBAIHN0YXRpYyB2b2lkIGNh Y2hlZF9kZXZfd3JpdGUoc3RydWN0IGNhY2hlZF9kZXYgKmRjLCBzdHJ1Y3Qgc2VhcmNoICpzKQog CQliaW9fZ2V0KHMtPmlvcC5iaW8pOwogCiAJCWlmIChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElT Q0FSRCAmJgotCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2 KSkpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGRjLT5iZGV2KSkKIAkJCWdvdG8g aW5zZXJ0X2RhdGE7CiAKIAkJLyogSS9PIHJlcXVlc3Qgc2VudCB0byBiYWNraW5nIGRldmljZSAq LwpAQCAtMTExNSw3ICsxMTE1LDcgQEAgc3RhdGljIHZvaWQgZGV0YWNoZWRfZGV2X2RvX3JlcXVl c3Qoc3RydWN0IGJjYWNoZV9kZXZpY2UgKmQsIHN0cnVjdCBiaW8gKmJpbywKIAliaW8tPmJpX3By aXZhdGUgPSBkZGlwOwogCiAJaWYgKChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYK LQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2KSkpCisJICAg ICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGMtPmJkZXYpKQogCQliaW8tPmJpX2VuZF9pbyhi aW8pOwogCWVsc2UKIAkJc3VibWl0X2Jpb19ub2FjY3QoYmlvKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWQvYmNhY2hlL3N1cGVyLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zdXBlci5jCmluZGV4IGJm M2RlMTQ5ZDNjOWYuLjJmNDllMzExNDJmNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hl L3N1cGVyLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYwpAQCAtOTczLDcgKzk3Myw2 IEBAIHN0YXRpYyBpbnQgYmNhY2hlX2RldmljZV9pbml0KHN0cnVjdCBiY2FjaGVfZGV2aWNlICpk LCB1bnNpZ25lZCBpbnQgYmxvY2tfc2l6ZSwKIAogCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX05PTlJPVCwgZC0+ZGlzay0+cXVldWUpOwogCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfQUREX1JBTkRPTSwgZC0+ZGlzay0+cXVldWUpOwotCWJsa19xdWV1ZV9mbGFnX3NldChR VUVVRV9GTEFHX0RJU0NBUkQsIGQtPmRpc2stPnF1ZXVlKTsKIAogCWJsa19xdWV1ZV93cml0ZV9j YWNoZShxLCB0cnVlLCB0cnVlKTsKIApAQCAtMjM1MCw3ICsyMzQ5LDcgQEAgc3RhdGljIGludCBy ZWdpc3Rlcl9jYWNoZShzdHJ1Y3QgY2FjaGVfc2IgKnNiLCBzdHJ1Y3QgY2FjaGVfc2JfZGlzayAq c2JfZGlzaywKIAljYS0+YmRldi0+YmRfaG9sZGVyID0gY2E7CiAJY2EtPnNiX2Rpc2sgPSBzYl9k aXNrOwogCi0JaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSkKKwlp ZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKChiZGV2KSkpCiAJCWNhLT5kaXNjYXJkID0gQ0FD SEVfRElTQ0FSRCgmY2EtPnNiKTsKIAogCXJldCA9IGNhY2hlX2FsbG9jKGNhKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWQvYmNhY2hlL3N5c2ZzLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zeXNmcy5j CmluZGV4IGQxMDI5ZDcxZmYzYmMuLmM2ZjY3NzA1OTIxNGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWQvYmNhY2hlL3N5c2ZzLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3lzZnMuYwpAQCAtMTE1 MSw3ICsxMTUxLDcgQEAgU1RPUkUoX19iY2hfY2FjaGUpCiAJaWYgKGF0dHIgPT0gJnN5c2ZzX2Rp c2NhcmQpIHsKIAkJYm9vbCB2ID0gc3RydG91bF9vcl9yZXR1cm4oYnVmKTsKIAotCQlpZiAoYmxr X3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoY2EtPmJkZXYpKSkKKwkJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhjYS0+YmRldikpCiAJCQljYS0+ZGlzY2FyZCA9IHY7CiAKIAkJaWYg KHYgIT0gQ0FDSEVfRElTQ0FSRCgmY2EtPnNiKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9k bS1jYWNoZS10YXJnZXQuYyBiL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMKaW5kZXggNzgw YTYxYmM2Y2MwMy4uMjhjNWRlOGVjYTRhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1jYWNo ZS10YXJnZXQuYworKysgYi9kcml2ZXJzL21kL2RtLWNhY2hlLXRhcmdldC5jCkBAIC0zMzI5LDEz ICszMzI5LDYgQEAgc3RhdGljIGludCBjYWNoZV9pdGVyYXRlX2RldmljZXMoc3RydWN0IGRtX3Rh cmdldCAqdGksCiAJcmV0dXJuIHI7CiB9CiAKLXN0YXRpYyBib29sIG9yaWdpbl9kZXZfc3VwcG9y dHNfZGlzY2FyZChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpvcmlnaW5fYmRldikKLXsKLQlzdHJ1Y3Qg cmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKG9yaWdpbl9iZGV2KTsKLQotCXJldHVy biBibGtfcXVldWVfZGlzY2FyZChxKTsKLX0KLQogLyoKICAqIElmIGRpc2NhcmRfcGFzc2Rvd24g d2FzIGVuYWJsZWQgdmVyaWZ5IHRoYXQgdGhlIG9yaWdpbiBkZXZpY2UKICAqIHN1cHBvcnRzIGRp c2NhcmRzLiAgRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlmIG5vdC4KQEAgLTMzNDksNyArMzM0 Miw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25faWZfbm90X3N1cHBvcnRlZChzdHJ1 Y3QgY2FjaGUgKmNhY2hlKQogCWlmICghY2FjaGUtPmZlYXR1cmVzLmRpc2NhcmRfcGFzc2Rvd24p CiAJCXJldHVybjsKIAotCWlmICghb3JpZ2luX2Rldl9zdXBwb3J0c19kaXNjYXJkKG9yaWdpbl9i ZGV2KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhvcmlnaW5fYmRldikpCiAJCXJl YXNvbiA9ICJkaXNjYXJkIHVuc3VwcG9ydGVkIjsKIAogCWVsc2UgaWYgKG9yaWdpbl9saW1pdHMt Pm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjYWNoZS0+c2VjdG9yc19wZXJfYmxvY2spCmRpZmYgLS1n aXQgYS9kcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jIGIvZHJpdmVycy9tZC9kbS1jbG9uZS10 YXJnZXQuYwppbmRleCAxMjgzMTZhNzNkMDE2Li44MTFiMGE1Mzc5ZDAzIDEwMDY0NAotLS0gYS9k cml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tY2xvbmUtdGFy Z2V0LmMKQEAgLTIwMTYsMTMgKzIwMTYsNiBAQCBzdGF0aWMgdm9pZCBjbG9uZV9yZXN1bWUoc3Ry dWN0IGRtX3RhcmdldCAqdGkpCiAJZG9fd2FrZXIoJmNsb25lLT53YWtlci53b3JrKTsKIH0KIAot c3RhdGljIGJvb2wgYmRldl9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2KQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoYmRldik7 Ci0KLQlyZXR1cm4gKHEgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQocSkpOwotfQotCiAvKgogICogSWYg ZGlzY2FyZF9wYXNzZG93biB3YXMgZW5hYmxlZCB2ZXJpZnkgdGhhdCB0aGUgZGVzdGluYXRpb24g ZGV2aWNlIHN1cHBvcnRzCiAgKiBkaXNjYXJkcy4gRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlm IG5vdC4KQEAgLTIwMzYsNyArMjAyOSw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25f aWZfbm90X3N1cHBvcnRlZChzdHJ1Y3QgY2xvbmUgKmNsb25lKQogCWlmICghdGVzdF9iaXQoRE1f Q0xPTkVfRElTQ0FSRF9QQVNTRE9XTiwgJmNsb25lLT5mbGFncykpCiAJCXJldHVybjsKIAotCWlm ICghYmRldl9zdXBwb3J0c19kaXNjYXJkcyhkZXN0X2RldikpCisJaWYgKCFiZGV2X21heF9kaXNj YXJkX3NlY3RvcnMoZGVzdF9kZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAJZWxzZSBpZiAoZGVzdF9saW1pdHMtPm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjbG9uZS0+cmVn aW9uX3NpemUpCiAJCXJlYXNvbiA9ICJtYXggZGlzY2FyZCBzZWN0b3JzIHNtYWxsZXIgdGhhbiBh IHJlZ2lvbiI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy13cml0ZXMuYyBiL2RyaXZl cnMvbWQvZG0tbG9nLXdyaXRlcy5jCmluZGV4IGM5ZDAzNmQ2YmIyZWUuLmUxOTQyMjZjODllNTQg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tbG9nLXdyaXRlcy5jCisrKyBiL2RyaXZlcnMvbWQv ZG0tbG9nLXdyaXRlcy5jCkBAIC04NjYsOSArODY2LDggQEAgc3RhdGljIGludCBsb2dfd3JpdGVz X21lc3NhZ2Uoc3RydWN0IGRtX3RhcmdldCAqdGksIHVuc2lnbmVkIGFyZ2MsIGNoYXIgKiphcmd2 LAogc3RhdGljIHZvaWQgbG9nX3dyaXRlc19pb19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRzKQogewogCXN0cnVjdCBsb2dfd3JpdGVzX2MgKmxj ID0gdGktPnByaXZhdGU7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1 ZShsYy0+ZGV2LT5iZGV2KTsKIAotCWlmICghcSB8fCAhYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsK KwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhsYy0+ZGV2LT5iZGV2KSkgewogCQlsYy0+ ZGV2aWNlX3N1cHBvcnRzX2Rpc2NhcmQgPSBmYWxzZTsKIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51 bGFyaXR5ID0gbGMtPnNlY3RvcnNpemU7CiAJCWxpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA9 IChVSU5UX01BWCA+PiBTRUNUT1JfU0hJRlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1y YWlkLmMgYi9kcml2ZXJzL21kL2RtLXJhaWQuYwppbmRleCAyYjI2NDM1YTY5NDZlLi45NTI2Y2Ni ZWRhZmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXJhaWQuYworKysgYi9kcml2ZXJzL21k L2RtLXJhaWQuYwpAQCAtMjk2MywxMyArMjk2Myw4IEBAIHN0YXRpYyB2b2lkIGNvbmZpZ3VyZV9k aXNjYXJkX3N1cHBvcnQoc3RydWN0IHJhaWRfc2V0ICpycykKIAlyYWlkNDU2ID0gcnNfaXNfcmFp ZDQ1Nihycyk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcnMtPnJhaWRfZGlza3M7IGkrKykgewotCQlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcTsKLQotCQlpZiAoIXJzLT5kZXZbaV0ucmRldi5iZGV2KQot CQkJY29udGludWU7Ci0KLQkJcSA9IGJkZXZfZ2V0X3F1ZXVlKHJzLT5kZXZbaV0ucmRldi5iZGV2 KTsKLQkJaWYgKCFxIHx8ICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwkJaWYgKCFycy0+ZGV2W2ld LnJkZXYuYmRldiB8fAorCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhycy0+ZGV2W2ld LnJkZXYuYmRldikpCiAJCQlyZXR1cm47CiAKIAkJaWYgKHJhaWQ0NTYpIHsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWQvZG0tdGFibGUuYyBiL2RyaXZlcnMvbWQvZG0tdGFibGUuYwppbmRleCBkNDY4 MzlmYWEwY2E1Li4wZGZmNjkwN2ZkMDBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXRhYmxl LmMKKysrIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCkBAIC0xODg4LDkgKzE4ODgsNyBAQCBzdGF0 aWMgYm9vbCBkbV90YWJsZV9zdXBwb3J0c19ub3dhaXQoc3RydWN0IGRtX3RhYmxlICp0KQogc3Rh dGljIGludCBkZXZpY2Vfbm90X2Rpc2NhcmRfY2FwYWJsZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IGRtX2RldiAqZGV2LAogCQkJCSAgICAgIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBs ZW4sIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9x dWV1ZShkZXYtPmJkZXYpOwotCi0JcmV0dXJuICFibGtfcXVldWVfZGlzY2FyZChxKTsKKwlyZXR1 cm4gIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPmJkZXYpOwogfQogCiBzdGF0aWMgYm9v bCBkbV90YWJsZV9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgZG1fdGFibGUgKnQpCkBAIC0xOTcw LDE1ICsxOTY4LDEyIEBAIGludCBkbV90YWJsZV9zZXRfcmVzdHJpY3Rpb25zKHN0cnVjdCBkbV90 YWJsZSAqdCwgc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsCiAJCWJsa19xdWV1ZV9mbGFnX2NsZWFy KFFVRVVFX0ZMQUdfTk9XQUlULCBxKTsKIAogCWlmICghZG1fdGFibGVfc3VwcG9ydHNfZGlzY2Fy ZHModCkpIHsKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsK LQkJLyogTXVzdCBhbHNvIGNsZWFyIGRpc2NhcmQgbGltaXRzLi4uICovCiAJCXEtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzID0gMDsKIAkJcS0+bGltaXRzLm1heF9od19kaXNjYXJkX3NlY3Rv cnMgPSAwOwogCQlxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IDA7CiAJCXEtPmxpbWl0 cy5kaXNjYXJkX2FsaWdubWVudCA9IDA7CiAJCXEtPmxpbWl0cy5kaXNjYXJkX21pc2FsaWduZWQg PSAwOwotCX0gZWxzZQotCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBx KTsKKwl9CiAKIAlpZiAoZG1fdGFibGVfc3VwcG9ydHNfc2VjdXJlX2VyYXNlKHQpKQogCQlibGtf cXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19TRUNFUkFTRSwgcSk7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kL2RtLXRoaW4uYyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCmluZGV4IDRkMjVkMGUyNzAz MTMuLmVkZWQ0YmNjNDU0NWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGhpbi5jCisrKyBi L2RyaXZlcnMvbWQvZG0tdGhpbi5jCkBAIC0yODAyLDEzICsyODAyLDYgQEAgc3RhdGljIHZvaWQg cmVxdWV1ZV9iaW9zKHN0cnVjdCBwb29sICpwb29sKQogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBCaW5kaW5nIG9m IGNvbnRyb2wgdGFyZ2V0cyB0byBhIHBvb2wgb2JqZWN0CiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLXN0YXRpYyBib29s IGRhdGFfZGV2X3N1cHBvcnRzX2Rpc2NhcmQoc3RydWN0IHBvb2xfYyAqcHQpCi17Ci0Jc3RydWN0 IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShwdC0+ZGF0YV9kZXYtPmJkZXYpOwot Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKHEpOwotfQotCiBzdGF0aWMgYm9vbCBpc19mYWN0 b3Ioc2VjdG9yX3QgYmxvY2tfc2l6ZSwgdWludDMyX3QgbikKIHsKIAlyZXR1cm4gIXNlY3Rvcl9k aXYoYmxvY2tfc2l6ZSwgbik7CkBAIC0yODI4LDcgKzI4MjEsNyBAQCBzdGF0aWMgdm9pZCBkaXNh YmxlX3Bhc3Nkb3duX2lmX25vdF9zdXBwb3J0ZWQoc3RydWN0IHBvb2xfYyAqcHQpCiAJaWYgKCFw dC0+YWRqdXN0ZWRfcGYuZGlzY2FyZF9wYXNzZG93bikKIAkJcmV0dXJuOwogCi0JaWYgKCFkYXRh X2Rldl9zdXBwb3J0c19kaXNjYXJkKHB0KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhwdC0+ZGF0YV9kZXYtPmJkZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAKIAllbHNlIGlmIChkYXRhX2xpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA8IHBvb2wtPnNl Y3RvcnNfcGVyX2Jsb2NrKQpAQCAtNDA1Nyw4ICs0MDUwLDYgQEAgc3RhdGljIHZvaWQgcG9vbF9p b19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgc3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRz KQogCQkvKgogCQkgKiBNdXN0IGV4cGxpY2l0bHkgZGlzYWxsb3cgc3RhY2tpbmcgZGlzY2FyZCBs aW1pdHMgb3RoZXJ3aXNlIHRoZQogCQkgKiBibG9jayBsYXllciB3aWxsIHN0YWNrIHRoZW0gaWYg cG9vbCdzIGRhdGEgZGV2aWNlIGhhcyBzdXBwb3J0LgotCQkgKiBRVUVVRV9GTEFHX0RJU0NBUkQg d291bGRuJ3QgYmUgc2V0IGJ1dCB0aGVyZSBpcyBubyB3YXkgZm9yIHRoZQotCQkgKiB1c2VyIHRv IHNlZSB0aGF0LCBzbyBtYWtlIHN1cmUgdG8gc2V0IGFsbCBkaXNjYXJkIGxpbWl0cyB0byAwLgog CQkgKi8KIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJcmV0dXJuOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9tZC9kbS5jIGIvZHJpdmVycy9tZC9kbS5jCmluZGV4IDNjNWZhZDdj NGVlNjguLmRiYmY2NGNlN2U5MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0uYworKysgYi9k cml2ZXJzL21kL2RtLmMKQEAgLTk1NSw3ICs5NTUsNiBAQCB2b2lkIGRpc2FibGVfZGlzY2FyZChz dHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCiAKIAkvKiBkZXZpY2UgZG9lc24ndCByZWFsbHkgc3Vw cG9ydCBESVNDQVJELCBkaXNhYmxlIGl0ICovCiAJbGltaXRzLT5tYXhfZGlzY2FyZF9zZWN0b3Jz ID0gMDsKLQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIG1kLT5xdWV1 ZSk7CiB9CiAKIHZvaWQgZGlzYWJsZV93cml0ZV96ZXJvZXMoc3RydWN0IG1hcHBlZF9kZXZpY2Ug Km1kKQpAQCAtOTgyLDcgKzk4MSw3IEBAIHN0YXRpYyB2b2lkIGNsb25lX2VuZGlvKHN0cnVjdCBi aW8gKmJpbykKIAogCWlmICh1bmxpa2VseShlcnJvciA9PSBCTEtfU1RTX1RBUkdFVCkpIHsKIAkJ aWYgKGJpb19vcChiaW8pID09IFJFUV9PUF9ESVNDQVJEICYmCi0JCSAgICAhcS0+bGltaXRzLm1h eF9kaXNjYXJkX3NlY3RvcnMpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+ YmlfYmRldikpCiAJCQlkaXNhYmxlX2Rpc2NhcmQobWQpOwogCQllbHNlIGlmIChiaW9fb3AoYmlv KSA9PSBSRVFfT1BfV1JJVEVfWkVST0VTICYmCiAJCQkgIXEtPmxpbWl0cy5tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLWxpbmVhci5jIGIvZHJpdmVy cy9tZC9tZC1saW5lYXIuYwppbmRleCAwZjU1YjA3OTM3MWIxLi4xMzhhM2IyNWM1YzgyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kL21kLWxpbmVhci5jCisrKyBiL2RyaXZlcnMvbWQvbWQtbGluZWFy LmMKQEAgLTY0LDcgKzY0LDYgQEAgc3RhdGljIHN0cnVjdCBsaW5lYXJfY29uZiAqbGluZWFyX2Nv bmYoc3RydWN0IG1kZGV2ICptZGRldiwgaW50IHJhaWRfZGlza3MpCiAJc3RydWN0IGxpbmVhcl9j b25mICpjb25mOwogCXN0cnVjdCBtZF9yZGV2ICpyZGV2OwogCWludCBpLCBjbnQ7Ci0JYm9vbCBk aXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJY29uZiA9IGt6YWxsb2Moc3RydWN0X3NpemUo Y29uZiwgZGlza3MsIHJhaWRfZGlza3MpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWNvbmYpCkBAIC05 Niw5ICs5NSw2IEBAIHN0YXRpYyBzdHJ1Y3QgbGluZWFyX2NvbmYgKmxpbmVhcl9jb25mKHN0cnVj dCBtZGRldiAqbWRkZXYsIGludCByYWlkX2Rpc2tzKQogCiAJCWNvbmYtPmFycmF5X3NlY3RvcnMg Kz0gcmRldi0+c2VjdG9yczsKIAkJY250Kys7Ci0KLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJk ZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsK IAl9CiAJaWYgKGNudCAhPSByYWlkX2Rpc2tzKSB7CiAJCXByX3dhcm4oIm1kL2xpbmVhcjolczog bm90IGVub3VnaCBkcml2ZXMgcHJlc2VudC4gQWJvcnRpbmchXG4iLApAQCAtMTA2LDExICsxMDIs NiBAQCBzdGF0aWMgc3RydWN0IGxpbmVhcl9jb25mICpsaW5lYXJfY29uZihzdHJ1Y3QgbWRkZXYg Km1kZGV2LCBpbnQgcmFpZF9kaXNrcykKIAkJZ290byBvdXQ7CiAJfQogCi0JaWYgKCFkaXNjYXJk X3N1cHBvcnRlZCkKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBt ZGRldi0+cXVldWUpOwotCWVsc2UKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElT Q0FSRCwgbWRkZXYtPnF1ZXVlKTsKLQogCS8qCiAJICogSGVyZSB3ZSBjYWxjdWxhdGUgdGhlIGRl dmljZSBvZmZzZXRzLgogCSAqLwpAQCAtMjUyLDcgKzI0Myw3IEBAIHN0YXRpYyBib29sIGxpbmVh cl9tYWtlX3JlcXVlc3Qoc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IGJpbyAqYmlvKQogCQlz dGFydF9zZWN0b3IgKyBkYXRhX29mZnNldDsKIAogCWlmICh1bmxpa2VseSgoYmlvX29wKGJpbykg PT0gUkVRX09QX0RJU0NBUkQpICYmCi0JCSAgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkgeworCQkgICAgICFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoYmlvLT5iaV9iZGV2KSkpIHsKIAkJLyogSnVzdCBpZ25vcmUgaXQgKi8KIAkJYmlvX2VuZGlv KGJpbyk7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDAuYyBiL2RyaXZl cnMvbWQvcmFpZDAuYwppbmRleCBiMjFlMTAxMTgzZjQ0Li43MjMxZjVlMWVhYTczIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQwLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMC5jCkBAIC0zOTks NyArMzk5LDYgQEAgc3RhdGljIGludCByYWlkMF9ydW4oc3RydWN0IG1kZGV2ICptZGRldikKIAlj b25mID0gbWRkZXYtPnByaXZhdGU7CiAJaWYgKG1kZGV2LT5xdWV1ZSkgewogCQlzdHJ1Y3QgbWRf cmRldiAqcmRldjsKLQkJYm9vbCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJCWJsa19x dWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2LT5jaHVua19zZWN0b3JzKTsK IAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2 LT5jaHVua19zZWN0b3JzKTsKQEAgLTQxMiwxMyArNDExLDcgQEAgc3RhdGljIGludCByYWlkMF9y dW4oc3RydWN0IG1kZGV2ICptZGRldikKIAkJcmRldl9mb3JfZWFjaChyZGV2LCBtZGRldikgewog CQkJZGlza19zdGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJCSAg cmRldi0+ZGF0YV9vZmZzZXQgPDwgOSk7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUocmRldi0+YmRldikpKQotCQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJ fQotCQlpZiAoIWRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVF VUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwotCQllbHNlCi0JCQlibGtfcXVldWVfZmxh Z19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCX0KIAogCS8qIGNhbGN1 bGF0ZSBhcnJheSBkZXZpY2Ugc2l6ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkMS5j IGIvZHJpdmVycy9tZC9yYWlkMS5jCmluZGV4IGQ4MWI4OTY4NTVmOWYuLjNkYTc0OWQxNTBhMTcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDEuYworKysgYi9kcml2ZXJzL21kL3JhaWQxLmMK QEAgLTgwMiw3ICs4MDIsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9iaW9fbGlzdChzdHJ1Y3QgcjFj b25mICpjb25mLCBzdHJ1Y3QgYmlvICpiaW8pCiAJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2 LT5mbGFncykpIHsKIAkJCWJpb19pb19lcnJvcihiaW8pOwogCQl9IGVsc2UgaWYgKHVubGlrZWx5 KChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9k aXNjYXJkKGJpby0+YmlfYmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICov CiAJCQliaW9fZW5kaW8oYmlvKTsKIAkJZWxzZQpAQCAtMTgyNiw4ICsxODI2LDYgQEAgc3RhdGlj IGludCByYWlkMV9hZGRfZGlzayhzdHJ1Y3QgbWRkZXYgKm1kZGV2LCBzdHJ1Y3QgbWRfcmRldiAq cmRldikKIAkJCWJyZWFrOwogCQl9CiAJfQotCWlmIChtZGRldi0+cXVldWUgJiYgYmxrX3F1ZXVl X2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQotCQlibGtfcXVldWVfZmxhZ19z ZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCXByaW50X2NvbmYoY29uZik7 CiAJcmV0dXJuIGVycjsKIH0KQEAgLTMxMDYsNyArMzEwNCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFf cnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJaW50IGk7CiAJc3RydWN0IG1kX3JkZXYgKnJkZXY7 CiAJaW50IHJldDsKLQlib29sIGRpc2NhcmRfc3VwcG9ydGVkID0gZmFsc2U7CiAKIAlpZiAobWRk ZXYtPmxldmVsICE9IDEpIHsKIAkJcHJfd2FybigibWQvcmFpZDE6JXM6IHJhaWQgbGV2ZWwgbm90 IHNldCB0byBtaXJyb3JpbmcgKCVkKVxuIiwKQEAgLTMxNDEsOCArMzEzOCw2IEBAIHN0YXRpYyBp bnQgcmFpZDFfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQljb250aW51ZTsKIAkJZGlza19z dGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJICByZGV2LT5kYXRh X29mZnNldCA8PCA5KTsKLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJk ZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAl9CiAKIAltZGRldi0+ ZGVncmFkZWQgPSAwOwpAQCAtMzE3OSwxNSArMzE3NCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFfcnVu KHN0cnVjdCBtZGRldiAqbWRkZXYpCiAKIAltZF9zZXRfYXJyYXlfc2VjdG9ycyhtZGRldiwgcmFp ZDFfc2l6ZShtZGRldiwgMCwgMCkpOwogCi0JaWYgKG1kZGV2LT5xdWV1ZSkgewotCQlpZiAoZGlz Y2FyZF9zdXBwb3J0ZWQpCi0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJE LAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIo UVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJICBtZGRldi0+cXVldWUpOwotCX0KLQogCXJldCA9 IG1kX2ludGVncml0eV9yZWdpc3RlcihtZGRldik7CiAJaWYgKHJldCkgewogCQltZF91bnJlZ2lz dGVyX3RocmVhZCgmbWRkZXYtPnRocmVhZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQx MC5jIGIvZHJpdmVycy9tZC9yYWlkMTAuYwppbmRleCA3ODE2YzhiMmU4MDg3Li4zNmE0NjAwMTVj ZjU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxMC5jCisrKyBiL2RyaXZlcnMvbWQvcmFp ZDEwLmMKQEAgLTg4OCw3ICs4ODgsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9wZW5kaW5nX3dyaXRl cyhzdHJ1Y3QgcjEwY29uZiAqY29uZikKIAkJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5m bGFncykpIHsKIAkJCQliaW9faW9fZXJyb3IoYmlvKTsKIAkJCX0gZWxzZSBpZiAodW5saWtlbHko KGJpb19vcChiaW8pID09ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkJICAgICFibGtfcXVldWVf ZGlzY2FyZChiaW8tPmJpX2JkZXYtPmJkX2Rpc2stPnF1ZXVlKSkpCisJCQkJCSAgICAhYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+YmlfYmRldikpKQogCQkJCS8qIEp1c3QgaWdub3JlIGl0 ICovCiAJCQkJYmlvX2VuZGlvKGJpbyk7CiAJCQllbHNlCkBAIC0xMDgzLDcgKzEwODMsNyBAQCBz dGF0aWMgdm9pZCByYWlkMTBfdW5wbHVnKHN0cnVjdCBibGtfcGx1Z19jYiAqY2IsIGJvb2wgZnJv bV9zY2hlZHVsZSkKIAkJaWYgKHRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkgewogCQkJ YmlvX2lvX2Vycm9yKGJpbyk7CiAJCX0gZWxzZSBpZiAodW5saWtlbHkoKGJpb19vcChiaW8pID09 ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICovCiAJCQliaW9fZW5kaW8o YmlvKTsKIAkJZWxzZQpAQCAtMjE0NCw4ICsyMTQ0LDYgQEAgc3RhdGljIGludCByYWlkMTBfYWRk X2Rpc2soc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IG1kX3JkZXYgKnJkZXYpCiAJCXJjdV9h c3NpZ25fcG9pbnRlcihwLT5yZGV2LCByZGV2KTsKIAkJYnJlYWs7CiAJfQotCWlmIChtZGRldi0+ cXVldWUgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQot CQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwog CiAJcHJpbnRfY29uZihjb25mKTsKIAlyZXR1cm4gZXJyOwpAQCAtNDA2OSw3ICs0MDY3LDYgQEAg c3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJc2VjdG9yX3Qgc2l6 ZTsKIAlzZWN0b3JfdCBtaW5fb2Zmc2V0X2RpZmYgPSAwOwogCWludCBmaXJzdCA9IDE7Ci0JYm9v bCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJaWYgKG1kZGV2X2luaXRfd3JpdGVzX3Bl bmRpbmcobWRkZXYpIDwgMCkKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC00MTQwLDIwICs0MTM3LDkg QEAgc3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQkJCSAgcmRl di0+ZGF0YV9vZmZzZXQgPDwgOSk7CiAKIAkJZGlzay0+aGVhZF9wb3NpdGlvbiA9IDA7Ci0KLQkJ aWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRp c2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJZmlyc3QgPSAwOwogCX0KIAotCWlmIChtZGRldi0+ cXVldWUpIHsKLQkJaWYgKGRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCW1kZGV2LT5xdWV1ZSk7Ci0JCWVsc2UKLQkJCWJs a19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCSAgbWRkZXYtPnF1 ZXVlKTsKLQl9CiAJLyogbmVlZCB0byBjaGVjayB0aGF0IGV2ZXJ5IGJsb2NrIGhhcyBhdCBsZWFz dCBvbmUgd29ya2luZyBtaXJyb3IgKi8KIAlpZiAoIWVub3VnaChjb25mLCAtMSkpIHsKIAkJcHJf ZXJyKCJtZC9yYWlkMTA6JXM6IG5vdCBlbm91Z2ggb3BlcmF0aW9uYWwgbWlycm9ycy5cbiIsCmRp ZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQ1LWNhY2hlLmMgYi9kcml2ZXJzL21kL3JhaWQ1LWNh Y2hlLmMKaW5kZXggYTdkNTBmZjkwMjBhOC4uYzNjYmY5YTU3NGEzOSAxMDA2NDQKLS0tIGEvZHJp dmVycy9tZC9yYWlkNS1jYWNoZS5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDUtY2FjaGUuYwpAQCAt MTMxOCw3ICsxMzE4LDcgQEAgc3RhdGljIHZvaWQgcjVsX3dyaXRlX3N1cGVyX2FuZF9kaXNjYXJk X3NwYWNlKHN0cnVjdCByNWxfbG9nICpsb2csCiAKIAlyNWxfd3JpdGVfc3VwZXIobG9nLCBlbmQp OwogCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShiZGV2KSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCXJldHVybjsKIAogCW1kZGV2ID0g bG9nLT5yZGV2LT5tZGRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDUuYyBiL2RyaXZl cnMvbWQvcmFpZDUuYwppbmRleCAwYmJhZTBlNjM4NjY2Li41OWY5MWUzOTJhMmFlIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQ1LmMKKysrIGIvZHJpdmVycy9tZC9yYWlkNS5jCkBAIC03Nzc2 LDE0ICs3Nzc2LDEwIEBAIHN0YXRpYyBpbnQgcmFpZDVfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYp CiAJCSAqIEEgYmV0dGVyIGlkZWEgbWlnaHQgYmUgdG8gdHVybiBESVNDQVJEIGludG8gV1JJVEVf WkVST0VTCiAJCSAqIHJlcXVlc3RzLCBhcyB0aGF0IGlzIHJlcXVpcmVkIHRvIGJlIHNhZmUuCiAJ CSAqLwotCQlpZiAoZGV2aWNlc19oYW5kbGVfZGlzY2FyZF9zYWZlbHkgJiYKLQkJICAgIG1kZGV2 LT5xdWV1ZS0+bGltaXRzLm1heF9kaXNjYXJkX3NlY3RvcnMgPj0gKHN0cmlwZSA+PiA5KSAmJgot CQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA+PSBzdHJpcGUp Ci0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJbWRkZXYt PnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVND QVJELAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKKwkJaWYgKCFkZXZpY2VzX2hhbmRsZV9kaXNjYXJk X3NhZmVseSB8fAorCQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9y cyA8IChzdHJpcGUgPj4gOSkgfHwKKwkJICAgIG1kZGV2LT5xdWV1ZS0+bGltaXRzLmRpc2NhcmRf Z3JhbnVsYXJpdHkgPCBzdHJpcGUpCisJCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyht ZGRldi0+cXVldWUsIDApOwogCiAJCWJsa19xdWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVl dWUsIFVJTlRfTUFYKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMg Yi9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMKaW5kZXggYzY5YjJkOWRmNmYxNi4uY2FjNjMxNTAx MGEzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9xdWV1ZS5jCisrKyBiL2RyaXZlcnMv bW1jL2NvcmUvcXVldWUuYwpAQCAtMTgzLDcgKzE4Myw2IEBAIHN0YXRpYyB2b2lkIG1tY19xdWV1 ZV9zZXR1cF9kaXNjYXJkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLAogCWlmICghbWF4X2Rpc2Nh cmQpCiAJCXJldHVybjsKIAotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFHX0RJU0NBUkQs IHEpOwogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIG1heF9kaXNjYXJkKTsKIAlx LT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IGNhcmQtPnByZWZfZXJhc2UgPDwgOTsKIAkv KiBncmFudWxhcml0eSBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gbWF4LiBkaXNjYXJkICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jIGIvZHJpdmVycy9tdGQvbXRkX2Js a2RldnMuYwppbmRleCA2NGQyYjA5M2YxMTRiLi5mNzMxNzIxMTE0NjU1IDEwMDY0NAotLS0gYS9k cml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jCisrKyBiL2RyaXZlcnMvbXRkL210ZF9ibGtkZXZzLmMK QEAgLTM3Nyw3ICszNzcsNiBAQCBpbnQgYWRkX210ZF9ibGt0cmFuc19kZXYoc3RydWN0IG10ZF9i bGt0cmFuc19kZXYgKm5ldykKIAlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0FERF9S QU5ET00sIG5ldy0+cnEpOwogCiAJaWYgKHRyLT5kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFn X3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIG5ldy0+cnEpOwogCQlibGtfcXVldWVfbWF4X2Rpc2Nh cmRfc2VjdG9ycyhuZXctPnJxLCBVSU5UX01BWCk7CiAJCW5ldy0+cnEtPmxpbWl0cy5kaXNjYXJk X2dyYW51bGFyaXR5ID0gdHItPmJsa3NpemU7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l L2hvc3QvY29yZS5jIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCmluZGV4IGVmYjg1YzZkOGUy ZDUuLjdlMDdkZDY5MjYyYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwor KysgYi9kcml2ZXJzL252bWUvaG9zdC9jb3JlLmMKQEAgLTE2MDcsMTAgKzE2MDcsOCBAQCBzdGF0 aWMgdm9pZCBudm1lX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBzdHJ1Y3Qg bnZtZV9ucyAqbnMpCiAJc3RydWN0IHJlcXVlc3RfcXVldWUgKnF1ZXVlID0gZGlzay0+cXVldWU7 CiAJdTMyIHNpemUgPSBxdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUocXVldWUpOwogCi0JaWYgKGN0 cmwtPm1heF9kaXNjYXJkX3NlY3RvcnMgPT0gMCkgewotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKTsKKwlpZiAoY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9y cyA9PSAwKQogCQlyZXR1cm47Ci0JfQogCiAJQlVJTERfQlVHX09OKFBBR0VfU0laRSAvIHNpemVv ZihzdHJ1Y3QgbnZtZV9kc21fcmFuZ2UpIDwKIAkJCU5WTUVfRFNNX01BWF9SQU5HRVMpOwpAQCAt MTYxOSw3ICsxNjE3LDcgQEAgc3RhdGljIHZvaWQgbnZtZV9jb25maWdfZGlzY2FyZChzdHJ1Y3Qg Z2VuZGlzayAqZGlzaywgc3RydWN0IG52bWVfbnMgKm5zKQogCXF1ZXVlLT5saW1pdHMuZGlzY2Fy ZF9ncmFudWxhcml0eSA9IHNpemU7CiAKIAkvKiBJZiBkaXNjYXJkIGlzIGFscmVhZHkgZW5hYmxl ZCwgZG9uJ3QgcmVzZXQgcXVldWUgbGltaXRzICovCi0JaWYgKGJsa19xdWV1ZV9mbGFnX3Rlc3Rf YW5kX3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKSkKKwlpZiAocXVldWUtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzKQogCQlyZXR1cm47CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRf c2VjdG9ycyhxdWV1ZSwgY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9ycyk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3MzOTAvYmxvY2svZGFzZF9mYmEuYyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCmluZGV4IGUwODRmNGRlZGRkZGQuLjhiZDU2NjVkYjkxOTggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvczM5MC9ibG9jay9kYXNkX2ZiYS5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCkBAIC03OTEsNyArNzkxLDYgQEAgc3RhdGljIHZvaWQgZGFzZF9mYmFfc2V0dXBfYmxrX3F1 ZXVlKHN0cnVjdCBkYXNkX2Jsb2NrICpibG9jaykKIAogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9z ZWN0b3JzKHEsIG1heF9kaXNjYXJkX3NlY3RvcnMpOwogCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMocSwgbWF4X2Rpc2NhcmRfc2VjdG9ycyk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBpbnQgZGFzZF9mYmFfcGVfaGFu ZGxlcihzdHJ1Y3QgZGFzZF9kZXZpY2UgKmRldmljZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2Nz aS9zZC5jIGIvZHJpdmVycy9zY3NpL3NkLmMKaW5kZXggYTM5MDY3OWNmNDU4NC4uNDQ0NDc5NjU3 YjdmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NkLmMKKysrIGIvZHJpdmVycy9zY3NpL3Nk LmMKQEAgLTc5Nyw3ICs3OTcsNiBAQCBzdGF0aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1 Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25lZCBpbnQgbW9kZSkKIAljYXNlIFNEX0xCUF9GVUxM OgogCWNhc2UgU0RfTEJQX0RJU0FCTEU6CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3Jz KHEsIDApOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwog CQlyZXR1cm47CiAKIAljYXNlIFNEX0xCUF9VTk1BUDoKQEAgLTgzMCw3ICs4MjksNiBAQCBzdGF0 aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25l ZCBpbnQgbW9kZSkKIAl9CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCBtYXhf YmxvY2tzICogKGxvZ2ljYWxfYmxvY2tfc2l6ZSA+PiA5KSk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBibGtfc3RhdHVzX3Qgc2Rfc2V0 dXBfdW5tYXBfY21uZChzdHJ1Y3Qgc2NzaV9jbW5kICpjbWQpCmRpZmYgLS1naXQgYS9kcml2ZXJz L3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3Jl X2RldmljZS5jCmluZGV4IGMzZTI1YmFjOTBkNTkuLjZjYjlmODc4NDMyNzggMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0 L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC04MzgsNyArODM4LDcgQEAgYm9vbCB0YXJnZXRfY29u ZmlndXJlX3VubWFwX2Zyb21fcXVldWUoc3RydWN0IHNlX2Rldl9hdHRyaWIgKmF0dHJpYiwKIAlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwogCWludCBibG9j a19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmRldik7CiAKLQlpZiAoIWJsa19xdWV1 ZV9kaXNjYXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQly ZXR1cm4gZmFsc2U7CiAKIAlhdHRyaWItPm1heF91bm1hcF9sYmFfY291bnQgPQpkaWZmIC0tZ2l0 IGEvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKaW5kZXgg ZjQ3NzAzNWEyYWMyMy4uZWZkOGRlYjNhYjdlOCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50 LXRyZWUuYworKysgYi9mcy9idHJmcy9leHRlbnQtdHJlZS5jCkBAIC0xMjkxLDcgKzEyOTEsNyBA QCBzdGF0aWMgaW50IGRvX2Rpc2NhcmRfZXh0ZW50KHN0cnVjdCBidHJmc19pb19zdHJpcGUgKnN0 cmlwZSwgdTY0ICpieXRlcykKIAkJcmV0ID0gYnRyZnNfcmVzZXRfZGV2aWNlX3pvbmUoZGV2X3Jl cGxhY2UtPnRndGRldiwgcGh5cywgbGVuLAogCQkJCQkgICAgICAmZGlzY2FyZGVkKTsKIAkJZGlz Y2FyZGVkICs9IHNyY19kaXNjOwotCX0gZWxzZSBpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUoc3RyaXBlLT5kZXYtPmJkZXYpKSkgeworCX0gZWxzZSBpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHN0cmlwZS0+ZGV2LT5iZGV2KSkgewogCQlyZXQgPSBidHJmc19pc3N1ZV9k aXNjYXJkKGRldi0+YmRldiwgcGh5cywgbGVuLCAmZGlzY2FyZGVkKTsKIAl9IGVsc2UgewogCQly ZXQgPSAwOwpAQCAtNTk4Nyw3ICs1OTg3LDcgQEAgc3RhdGljIGludCBidHJmc190cmltX2ZyZWVf ZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2UsIHU2NCAqdHJpbW1lZCkKIAkqdHJp bW1lZCA9IDA7CiAKIAkvKiBEaXNjYXJkIG5vdCBzdXBwb3J0ZWQgPSBub3RoaW5nIHRvIGRvLiAq LwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoZGV2aWNlLT5iZGV2KSkp CisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGV2aWNlLT5iZGV2KSkKIAkJcmV0dXJu IDA7CiAKIAkvKiBOb3Qgd3JpdGFibGUgPSBub3RoaW5nIHRvIGRvLiAqLwpkaWZmIC0tZ2l0IGEv ZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggZjQ2ZTcxMDYxOTQyZC4u MDk2YmIwZGEwM2YxYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJm cy9pb2N0bC5jCkBAIC01MDEsNyArNTAxLDcgQEAgc3RhdGljIG5vaW5saW5lIGludCBidHJmc19p b2N0bF9maXRyaW0oc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8sCiAJCWlmICghZGV2aWNl LT5iZGV2KQogCQkJY29udGludWU7CiAJCXEgPSBiZGV2X2dldF9xdWV1ZShkZXZpY2UtPmJkZXYp OwotCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwkJaWYgKGJkZXZfbWF4X2Rpc2NhcmRf c2VjdG9ycyhkZXZpY2UtPmJkZXYpKSB7CiAJCQludW1fZGV2aWNlcysrOwogCQkJbWlubGVuID0g bWluX3QodTY0LCBxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSwKIAkJCQkgICAgIG1pbmxl bik7CmRpZmYgLS1naXQgYS9mcy9leGZhdC9maWxlLmMgYi9mcy9leGZhdC9maWxlLmMKaW5kZXgg MmY1MTMwMDU5MjM2Ni4uNzY1ZTRmNjNkZDE4ZCAxMDA2NDQKLS0tIGEvZnMvZXhmYXQvZmlsZS5j CisrKyBiL2ZzL2V4ZmF0L2ZpbGUuYwpAQCAtMzU4LDcgKzM1OCw3IEBAIHN0YXRpYyBpbnQgZXhm YXRfaW9jdGxfZml0cmltKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHVuc2lnbmVkIGxvbmcgYXJnKQog CWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0dXJuIC1FUEVSTTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoaW5v ZGUtPmlfc2ItPnNfYmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zy b21fdXNlcigmcmFuZ2UsIChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZywgc2l6ZW9m KHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy9leGZhdC9zdXBlci5jIGIvZnMvZXhmYXQvc3VwZXIu YwppbmRleCA4Y2EyMWU3OTE3ZDE2Li5iZTA3ODhlY2FmMjBlIDEwMDY0NAotLS0gYS9mcy9leGZh dC9zdXBlci5jCisrKyBiL2ZzL2V4ZmF0L3N1cGVyLmMKQEAgLTYyNywxMyArNjI3LDkgQEAgc3Rh dGljIGludCBleGZhdF9maWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBm c19jb250ZXh0ICpmYykKIAlpZiAob3B0cy0+YWxsb3dfdXRpbWUgPT0gKHVuc2lnbmVkIHNob3J0 KS0xKQogCQlvcHRzLT5hbGxvd191dGltZSA9IH5vcHRzLT5mc19kbWFzayAmIDAwMjI7CiAKLQlp ZiAob3B0cy0+ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0 X3F1ZXVlKHNiLT5zX2JkZXYpOwotCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJ CWV4ZmF0X3dhcm4oc2IsICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRo ZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JCQlvcHRzLT5kaXNjYXJkID0g MDsKLQkJfQorCWlmIChvcHRzLT5kaXNjYXJkICYmICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMo c2ItPnNfYmRldikpIHsKKwkJZXhmYXRfd2FybihzYiwgIm1vdW50aW5nIHdpdGggXCJkaXNjYXJk XCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2NhcmQiKTsKKwkJ b3B0cy0+ZGlzY2FyZCA9IDA7CiAJfQogCiAJc2ItPnNfZmxhZ3MgfD0gU0JfTk9ESVJBVElNRTsK ZGlmZiAtLWdpdCBhL2ZzL2V4dDQvaW9jdGwuYyBiL2ZzL2V4dDQvaW9jdGwuYwppbmRleCA5OTIy MjljYTJkODMwLi42ZTNiOWVlYTEyNmY0IDEwMDY0NAotLS0gYS9mcy9leHQ0L2lvY3RsLmMKKysr IGIvZnMvZXh0NC9pb2N0bC5jCkBAIC0xMDQ0LDcgKzEwNDQsNiBAQCBzdGF0aWMgaW50IGV4dDRf aW9jdGxfY2hlY2twb2ludChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJ X191MzIgZmxhZ3MgPSAwOwogCXVuc2lnbmVkIGludCBmbHVzaF9mbGFncyA9IDA7CiAJc3RydWN0 IHN1cGVyX2Jsb2NrICpzYiA9IGZpbGVfaW5vZGUoZmlscCktPmlfc2I7Ci0Jc3RydWN0IHJlcXVl c3RfcXVldWUgKnE7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIoJmZsYWdzLCAoX191MzIgX191c2Vy ICopYXJnLAogCQkJCXNpemVvZihfX3UzMikpKQpAQCAtMTA2NSwxMCArMTA2NCw4IEBAIHN0YXRp YyBpbnQgZXh0NF9pb2N0bF9jaGVja3BvaW50KHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBs b25nIGFyZykKIAlpZiAoZmxhZ3MgJiB+RVhUNF9JT0NfQ0hFQ0tQT0lOVF9GTEFHX1ZBTElEKQog CQlyZXR1cm4gLUVJTlZBTDsKIAotCXEgPSBiZGV2X2dldF9xdWV1ZShFWFQ0X1NCKHNiKS0+c19q b3VybmFsLT5qX2Rldik7Ci0JaWYgKCFxKQotCQlyZXR1cm4gLUVOWElPOwotCWlmICgoZmxhZ3Mg JiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYgIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQor CWlmICgoZmxhZ3MgJiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYKKwkgICAgIWJkZXZf bWF4X2Rpc2NhcmRfc2VjdG9ycyhFWFQ0X1NCKHNiKS0+c19qb3VybmFsLT5qX2RldikpCiAJCXJl dHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChmbGFncyAmIEVYVDRfSU9DX0NIRUNLUE9JTlRfRkxB R19EUllfUlVOKQpAQCAtMTM5MywxNCArMTM5MCwxMyBAQCBzdGF0aWMgbG9uZyBfX2V4dDRfaW9j dGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJn KQogCiAJY2FzZSBGSVRSSU06CiAJewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZf Z2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQlzdHJ1Y3QgZnN0cmltX3JhbmdlIHJhbmdlOwogCQlp bnQgcmV0ID0gMDsKIAogCQlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCQlyZXR1cm4g LUVQRVJNOwogCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCWlmICghYmRldl9tYXhf ZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCiAJ CS8qCmRpZmYgLS1naXQgYS9mcy9leHQ0L3N1cGVyLmMgYi9mcy9leHQ0L3N1cGVyLmMKaW5kZXgg ODE3NDllYWRkZjRjMS4uOTNmNGU0ZTllMjYzMSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9zdXBlci5j CisrKyBiL2ZzL2V4dDQvc3VwZXIuYwpAQCAtNTQ1OCwxMyArNTQ1OCw5IEBAIHN0YXRpYyBpbnQg X19leHQ0X2ZpbGxfc3VwZXIoc3RydWN0IGZzX2NvbnRleHQgKmZjLCBzdHJ1Y3Qgc3VwZXJfYmxv Y2sgKnNiKQogCQkJZ290byBmYWlsZWRfbW91bnQ5OwogCX0KIAotCWlmICh0ZXN0X29wdChzYiwg RElTQ0FSRCkpIHsKLQkJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShz Yi0+c19iZGV2KTsKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJCWV4dDRfbXNnKHNi LCBLRVJOX1dBUk5JTkcsCi0JCQkJICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwg YnV0ICIKLQkJCQkgInRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JfQor CWlmICh0ZXN0X29wdChzYiwgRElTQ0FSRCkgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhz Yi0+c19iZGV2KSkKKwkJZXh0NF9tc2coc2IsIEtFUk5fV0FSTklORywKKwkJCSAibW91bnRpbmcg d2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCB0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQg ZGlzY2FyZCIpOwogCiAJaWYgKGVzLT5zX2Vycm9yX2NvdW50KQogCQltb2RfdGltZXIoJnNiaS0+ c19lcnJfcmVwb3J0LCBqaWZmaWVzICsgMzAwKkhaKTsgLyogNSBtaW51dGVzICovCmRpZmYgLS1n aXQgYS9mcy9mMmZzL2YyZnMuaCBiL2ZzL2YyZnMvZjJmcy5oCmluZGV4IGNkMWU2NWJjZjBiMDQu LjBlYTlhNWZhN2MxZGQgMTAwNjQ0Ci0tLSBhL2ZzL2YyZnMvZjJmcy5oCisrKyBiL2ZzL2YyZnMv ZjJmcy5oCkBAIC00MzgxLDggKzQzODEsNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgZjJmc19od19z aG91bGRfZGlzY2FyZChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkpCiAKIHN0YXRpYyBpbmxpbmUg Ym9vbCBmMmZzX2JkZXZfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYp CiB7Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSB8fAot CSAgICAgICBiZGV2X2lzX3pvbmVkKGJkZXYpOworCXJldHVybiBiZGV2X21heF9kaXNjYXJkX3Nl Y3RvcnMoYmRldikgfHwgYmRldl9pc196b25lZChiZGV2KTsKIH0KIAogc3RhdGljIGlubGluZSBi b29sIGYyZnNfaHdfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSkKZGlm ZiAtLWdpdCBhL2ZzL2ZhdC9maWxlLmMgYi9mcy9mYXQvZmlsZS5jCmluZGV4IGE1YTMwOWZjYzdm YWYuLmU0YzdkMTBlODAxMjkgMTAwNjQ0Ci0tLSBhL2ZzL2ZhdC9maWxlLmMKKysrIGIvZnMvZmF0 L2ZpbGUuYwpAQCAtMTMzLDcgKzEzMyw3IEBAIHN0YXRpYyBpbnQgZmF0X2lvY3RsX2ZpdHJpbShz dHJ1Y3QgaW5vZGUgKmlub2RlLCB1bnNpZ25lZCBsb25nIGFyZykKIAlpZiAoIWNhcGFibGUoQ0FQ X1NZU19BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJk KHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAl1c2VyX3JhbmdlID0gKHN0cnVjdCBmc3RyaW1fcmFuZ2UgX191 c2VyICopYXJnOwpkaWZmIC0tZ2l0IGEvZnMvZmF0L2lub2RlLmMgYi9mcy9mYXQvaW5vZGUuYwpp bmRleCBiZjYwNTFiZGYxZDFkLi4zZDFhZmI5NWE5MjVhIDEwMDY0NAotLS0gYS9mcy9mYXQvaW5v ZGUuYworKysgYi9mcy9mYXQvaW5vZGUuYwpAQCAtMTg3MiwxMyArMTg3Miw5IEBAIGludCBmYXRf ZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpkYXRhLCBpbnQgc2lsZW50 LCBpbnQgaXN2ZmF0LAogCQlnb3RvIG91dF9mYWlsOwogCX0KIAotCWlmIChzYmktPm9wdGlvbnMu ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNi LT5zX2JkZXYpOwotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQotCQkJZmF0X21zZyhzYiwg S0VSTl9XQVJOSU5HLAotCQkJCQkibW91bnRpbmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1 dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCX0KKwlp ZiAoc2JpLT5vcHRpb25zLmRpc2NhcmQgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhzYi0+ c19iZGV2KSkKKwkJZmF0X21zZyhzYiwgS0VSTl9XQVJOSU5HLAorCQkJIm1vdW50aW5nIHdpdGgg XCJkaXNjYXJkXCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2Nh cmQiKTsKIAogCWZhdF9zZXRfc3RhdGUoc2IsIDEsIDApOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0 IGEvZnMvZ2ZzMi9yZ3JwLmMgYi9mcy9nZnMyL3JncnAuYwppbmRleCA4MDFhZDlmNGYyYmVmLi43 ZjIwYWM5MTMzYmM2IDEwMDY0NAotLS0gYS9mcy9nZnMyL3JncnAuYworKysgYi9mcy9nZnMyL3Jn cnAuYwpAQCAtMTQwNSw3ICsxNDA1LDcgQEAgaW50IGdmczJfZml0cmltKHN0cnVjdCBmaWxlICpm aWxwLCB2b2lkIF9fdXNlciAqYXJncCkKIAlpZiAoIXRlc3RfYml0KFNERl9KT1VSTkFMX0xJVkUs ICZzZHAtPnNkX2ZsYWdzKSkKIAkJcmV0dXJuIC1FUk9GUzsKIAotCWlmICghYmxrX3F1ZXVlX2Rp c2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2RwLT5zZF92ZnMtPnNf YmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmciwg YXJncCwgc2l6ZW9mKHIpKSkKZGlmZiAtLWdpdCBhL2ZzL2piZDIvam91cm5hbC5jIGIvZnMvamJk Mi9qb3VybmFsLmMKaW5kZXggZmNhY2FmYTQ1MTBkMS4uMTlkMjI2Y2Q0ZmY0ZCAxMDA2NDQKLS0t IGEvZnMvamJkMi9qb3VybmFsLmMKKysrIGIvZnMvamJkMi9qb3VybmFsLmMKQEAgLTE3NjIsNyAr MTc2Miw2IEBAIHN0YXRpYyBpbnQgX19qYmQyX2pvdXJuYWxfZXJhc2Uoam91cm5hbF90ICpqb3Vy bmFsLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJdW5zaWduZWQgbG9uZyBibG9jaywgbG9nX29mZnNl dDsgLyogbG9naWNhbCAqLwogCXVuc2lnbmVkIGxvbmcgbG9uZyBwaHlzX2Jsb2NrLCBibG9ja19z dGFydCwgYmxvY2tfc3RvcDsgLyogcGh5c2ljYWwgKi8KIAlsb2ZmX3QgYnl0ZV9zdGFydCwgYnl0 ZV9zdG9wLCBieXRlX2NvdW50OwotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRf cXVldWUoam91cm5hbC0+al9kZXYpOwogCiAJLyogZmxhZ3MgbXVzdCBiZSBzZXQgdG8gZWl0aGVy IGRpc2NhcmQgb3IgemVyb291dCAqLwogCWlmICgoZmxhZ3MgJiB+SkJEMl9KT1VSTkFMX0ZMVVNI X1ZBTElEKSB8fCAhZmxhZ3MgfHwKQEAgLTE3NzAsMTAgKzE3NjksOCBAQCBzdGF0aWMgaW50IF9f amJkMl9qb3VybmFsX2VyYXNlKGpvdXJuYWxfdCAqam91cm5hbCwgdW5zaWduZWQgaW50IGZsYWdz KQogCQkJKGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX1pFUk9PVVQpKSkKIAkJcmV0dXJuIC1F SU5WQUw7CiAKLQlpZiAoIXEpCi0JCXJldHVybiAtRU5YSU87Ci0KLQlpZiAoKGZsYWdzICYgSkJE Ml9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwlpZiAo KGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmCisJICAgICFiZGV2X21heF9k aXNjYXJkX3NlY3RvcnMoam91cm5hbC0+al9kZXYpKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAK IAkvKgpkaWZmIC0tZ2l0IGEvZnMvamZzL2lvY3RsLmMgYi9mcy9qZnMvaW9jdGwuYwppbmRleCAw M2E4NDVhYjRmMDA5Li4zNTdhZTZlNWMzNmVjIDEwMDY0NAotLS0gYS9mcy9qZnMvaW9jdGwuYwor KysgYi9mcy9qZnMvaW9jdGwuYwpAQCAtMTE3LDcgKzExNyw3IEBAIGxvbmcgamZzX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIAkJ aWYgKCFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQogCQkJcmV0dXJuIC1FUEVSTTsKIAotCQlpZiAo IWJsa19xdWV1ZV9kaXNjYXJkKHEpKSB7CisJCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KHNiLT5zX2JkZXYpKSB7CiAJCQlqZnNfd2FybigiRklUUklNIG5vdCBzdXBwb3J0ZWQgb24gZGV2 aWNlIik7CiAJCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJCX0KZGlmZiAtLWdpdCBhL2ZzL2pmcy9z dXBlci5jIGIvZnMvamZzL3N1cGVyLmMKaW5kZXggZjFhMTNhNzRjZGRmMy4uODVkNGY0NGYyYWM0 ZCAxMDA2NDQKLS0tIGEvZnMvamZzL3N1cGVyLmMKKysrIGIvZnMvamZzL3N1cGVyLmMKQEAgLTM3 MiwxOSArMzcyLDE2IEBAIHN0YXRpYyBpbnQgcGFyc2Vfb3B0aW9ucyhjaGFyICpvcHRpb25zLCBz dHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzNjQgKm5ld0xWU2l6ZSwKIAkJfQogCiAJCWNhc2UgT3B0 X2Rpc2NhcmQ6Ci0JCXsKLQkJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVl dWUoc2ItPnNfYmRldik7CiAJCQkvKiBpZiBzZXQgdG8gMSwgZXZlbiBjb3B5aW5nIGZpbGVzIHdp bGwgY2F1c2UKIAkJCSAqIHRyaW1taW5nIDpPCiAJCQkgKiAtPiB1c2VyIGhhcyBtb3JlIGNvbnRy b2wgb3ZlciB0aGUgb25saW5lIHRyaW1taW5nCiAJCQkgKi8KIAkJCXNiaS0+bWluYmxrc190cmlt ID0gNjQ7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCQlpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJCSpmbGFnIHw9IEpGU19ESVNDQVJEOwogCQkJ ZWxzZQogCQkJCXByX2VycigiSkZTOiBkaXNjYXJkIG9wdGlvbiBub3Qgc3VwcG9ydGVkIG9uIGRl dmljZVxuIik7CiAJCQlicmVhazsKLQkJfQogCiAJCWNhc2UgT3B0X25vZGlzY2FyZDoKIAkJCSpm bGFnICY9IH5KRlNfRElTQ0FSRDsKQEAgLTM5MiwxMCArMzg5LDkgQEAgc3RhdGljIGludCBwYXJz ZV9vcHRpb25zKGNoYXIgKm9wdGlvbnMsIHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHM2NCAqbmV3 TFZTaXplLAogCiAJCWNhc2UgT3B0X2Rpc2NhcmRfbWluYmxrOgogCQl7Ci0JCQlzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQkJY2hhciAqbWlu Ymxrc190cmltID0gYXJnc1swXS5mcm9tOwogCQkJaW50IHJjOwotCQkJaWYgKGJsa19xdWV1ZV9k aXNjYXJkKHEpKSB7CisJCQlpZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYp KSB7CiAJCQkJKmZsYWcgfD0gSkZTX0RJU0NBUkQ7CiAJCQkJcmMgPSBrc3RydG91aW50KG1pbmJs a3NfdHJpbSwgMCwKIAkJCQkJCSZzYmktPm1pbmJsa3NfdHJpbSk7CmRpZmYgLS1naXQgYS9mcy9u aWxmczIvaW9jdGwuYyBiL2ZzL25pbGZzMi9pb2N0bC5jCmluZGV4IGZlYzE5NGE2NjZmNGIuLjUy YjczZjU1OGZjYjEgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9pb2N0bC5jCisrKyBiL2ZzL25pbGZz Mi9pb2N0bC5jCkBAIC0xMDU5LDcgKzEwNTksNyBAQCBzdGF0aWMgaW50IG5pbGZzX2lvY3RsX3Ry aW1fZnMoc3RydWN0IGlub2RlICppbm9kZSwgdm9pZCBfX3VzZXIgKmFyZ3ApCiAJaWYgKCFjYXBh YmxlKENBUF9TWVNfQURNSU4pKQogCQlyZXR1cm4gLUVQRVJNOwogCi0JaWYgKCFibGtfcXVldWVf ZGlzY2FyZChxKSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhuaWxmcy0+bnNfYmRl dikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmcmFuZ2Us IGFyZ3AsIHNpemVvZihyYW5nZSkpKQpkaWZmIC0tZ2l0IGEvZnMvbnRmczMvZmlsZS5jIGIvZnMv bnRmczMvZmlsZS5jCmluZGV4IDc4N2I1M2I5ODRlZTEuLmU3NjMyMzYxNjkzMzEgMTAwNjQ0Ci0t LSBhL2ZzL250ZnMzL2ZpbGUuYworKysgYi9mcy9udGZzMy9maWxlLmMKQEAgLTI4LDcgKzI4LDcg QEAgc3RhdGljIGludCBudGZzX2lvY3RsX2ZpdHJpbShzdHJ1Y3QgbnRmc19zYl9pbmZvICpzYmks IHVuc2lnbmVkIGxvbmcgYXJnKQogCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0 dXJuIC1FUEVSTTsKIAotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21h eF9kaXNjYXJkX3NlY3RvcnMoc2JpLT5zYi0+c19iZGV2KSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQ OwogCiAJdXNlcl9yYW5nZSA9IChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZzsKZGlm ZiAtLWdpdCBhL2ZzL250ZnMzL3N1cGVyLmMgYi9mcy9udGZzMy9zdXBlci5jCmluZGV4IGNkMzBl ODFhYmJjZTAuLmM3MzQwODViY2NlNGEgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMzL3N1cGVyLmMKKysr IGIvZnMvbnRmczMvc3VwZXIuYwpAQCAtOTEzLDcgKzkxMyw3IEBAIHN0YXRpYyBpbnQgbnRmc19m aWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBmc19jb250ZXh0ICpmYykK IAl9CiAKIAlycSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwotCWlmIChibGtfcXVldWVfZGlzY2Fy ZChycSkgJiYgcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5KSB7CisJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSAmJiBycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkp IHsKIAkJc2JpLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51 bGFyaXR5OwogCQlzYmktPmRpc2NhcmRfZ3JhbnVsYXJpdHlfbWFza19pbnYgPQogCQkJfih1NjQp KHNiaS0+ZGlzY2FyZF9ncmFudWxhcml0eSAtIDEpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvaW9j dGwuYyBiL2ZzL29jZnMyL2lvY3RsLmMKaW5kZXggZjU5NDYxZDg1ZGE0NS4uOWI3OGVmMTAzYWRh NiAxMDA2NDQKLS0tIGEvZnMvb2NmczIvaW9jdGwuYworKysgYi9mcy9vY2ZzMi9pb2N0bC5jCkBA IC05MTAsNyArOTEwLDcgQEAgbG9uZyBvY2ZzMl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5z aWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJCWlmICghY2FwYWJsZShDQVBfU1lT X0FETUlOKSkKIAkJCXJldHVybiAtRVBFUk07CiAKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChx KSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2ItPnNfYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZyYW5nZSwgYXJncCwgc2l6 ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Rpc2NhcmQuYyBiL2ZzL3hmcy94 ZnNfZGlzY2FyZC5jCmluZGV4IDAxOTFkZThjZTljZWQuLmE0ZTY2MDlkNjE2YjcgMTAwNjQ0Ci0t LSBhL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCisrKyBiL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCkBAIC0x NjIsNyArMTYyLDcgQEAgeGZzX2lvY190cmltKAogCiAJaWYgKCFjYXBhYmxlKENBUF9TWVNfQURN SU4pKQogCQlyZXR1cm4gLUVQRVJNOwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMobXAtPm1fZGRldl90YXJncC0+YnRfYmRldikpCiAJ CXJldHVybiAtRU9QTk9UU1VQUDsKIAogCS8qCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3N1cGVy LmMgYi9mcy94ZnMveGZzX3N1cGVyLmMKaW5kZXggNTRiZTlkNjQwOTNlZC4uYTI3NmI4MTExZjYz NiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19zdXBlci5jCisrKyBiL2ZzL3hmcy94ZnNfc3VwZXIu YwpAQCAtMTYwOCwxNCArMTYwOCwxMCBAQCB4ZnNfZnNfZmlsbF9zdXBlcigKIAkJCWdvdG8gb3V0 X2ZpbGVzdHJlYW1fdW5tb3VudDsKIAl9CiAKLQlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSkgewot CQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwot Ci0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJCXhmc193YXJuKG1wLCAibW91bnRp bmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMg bm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCQkJbXAtPm1fZmVhdHVyZXMgJj0gflhGU19GRUFUX0RJ U0NBUkQ7Ci0JCX0KKwlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSAmJiAhYmRldl9tYXhfZGlzY2Fy ZF9zZWN0b3JzKHNiLT5zX2JkZXYpKSB7CisJCXhmc193YXJuKG1wLAorCSJtb3VudGluZyB3aXRo IFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNj YXJkIik7CisJCW1wLT5tX2ZlYXR1cmVzICY9IH5YRlNfRkVBVF9ESVNDQVJEOwogCX0KIAogCWlm ICh4ZnNfaGFzX3JlZmxpbmsobXApKSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Jsa2Rl di5oIGIvaW5jbHVkZS9saW51eC9ibGtkZXYuaAppbmRleCBjZTE2MjQ3ZDNhZmFiLi43NjdhYjIy ZTEwNTJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1ZGUv bGludXgvYmxrZGV2LmgKQEAgLTU0MCw3ICs1NDAsNiBAQCBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSB7 CiAjZGVmaW5lIFFVRVVFX0ZMQUdfTk9OUk9UCTYJLyogbm9uLXJvdGF0aW9uYWwgZGV2aWNlIChT U0QpICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfVklSVAkJUVVFVUVfRkxBR19OT05ST1QgLyogcGFy YXZpcnQgZGV2aWNlICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfSU9fU1RBVAk3CS8qIGRvIGRpc2sv cGFydGl0aW9ucyBJTyBhY2NvdW50aW5nICovCi0jZGVmaW5lIFFVRVVFX0ZMQUdfRElTQ0FSRAk4 CS8qIHN1cHBvcnRzIERJU0NBUkQgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19OT1hNRVJHRVMJOQkv KiBObyBleHRlbmRlZCBtZXJnZXMgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19BRERfUkFORE9NCTEw CS8qIENvbnRyaWJ1dGVzIHRvIHJhbmRvbSBwb29sICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfU0VD RVJBU0UJMTEJLyogc3VwcG9ydHMgc2VjdXJlIGVyYXNlICovCkBAIC01ODIsNyArNTgxLDYgQEAg Ym9vbCBibGtfcXVldWVfZmxhZ190ZXN0X2FuZF9zZXQodW5zaWduZWQgaW50IGZsYWcsIHN0cnVj dCByZXF1ZXN0X3F1ZXVlICpxKTsKIAl0ZXN0X2JpdChRVUVVRV9GTEFHX1NUQUJMRV9XUklURVMs ICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfaW9fc3RhdChxKQl0ZXN0X2Jp dChRVUVVRV9GTEFHX0lPX1NUQVQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVl dWVfYWRkX3JhbmRvbShxKQl0ZXN0X2JpdChRVUVVRV9GTEFHX0FERF9SQU5ET00sICYocSktPnF1 ZXVlX2ZsYWdzKQotI2RlZmluZSBibGtfcXVldWVfZGlzY2FyZChxKQl0ZXN0X2JpdChRVUVVRV9G TEFHX0RJU0NBUkQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfem9uZV9y ZXNldGFsbChxKQlcCiAJdGVzdF9iaXQoUVVFVUVfRkxBR19aT05FX1JFU0VUQUxMLCAmKHEpLT5x dWV1ZV9mbGFncykKICNkZWZpbmUgYmxrX3F1ZXVlX3NlY3VyZV9lcmFzZShxKSBcCmRpZmYgLS1n aXQgYS9tbS9zd2FwZmlsZS5jIGIvbW0vc3dhcGZpbGUuYwppbmRleCA0MDY5ZjE3YTgyYzhlLi41 ZDljZWRmOWU3Yjg0IDEwMDY0NAotLS0gYS9tbS9zd2FwZmlsZS5jCisrKyBiL21tL3N3YXBmaWxl LmMKQEAgLTI5NTcsMjAgKzI5NTcsNiBAQCBzdGF0aWMgaW50IHNldHVwX3N3YXBfbWFwX2FuZF9l eHRlbnRzKHN0cnVjdCBzd2FwX2luZm9fc3RydWN0ICpwLAogCXJldHVybiBucl9leHRlbnRzOwog fQogCi0vKgotICogSGVscGVyIHRvIHN5c19zd2Fwb24gZGV0ZXJtaW5pbmcgaWYgYSBnaXZlbiBz d2FwCi0gKiBiYWNraW5nIGRldmljZSBxdWV1ZSBzdXBwb3J0cyBESVNDQVJEIG9wZXJhdGlvbnMu Ci0gKi8KLXN0YXRpYyBib29sIHN3YXBfZGlzY2FyZGFibGUoc3RydWN0IHN3YXBfaW5mb19zdHJ1 Y3QgKnNpKQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoc2kt PmJkZXYpOwotCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJcmV0dXJuIGZhbHNlOwot Ci0JcmV0dXJuIHRydWU7Ci19Ci0KIFNZU0NBTExfREVGSU5FMihzd2Fwb24sIGNvbnN0IGNoYXIg X191c2VyICosIHNwZWNpYWxmaWxlLCBpbnQsIHN3YXBfZmxhZ3MpCiB7CiAJc3RydWN0IHN3YXBf aW5mb19zdHJ1Y3QgKnA7CkBAIC0zMTMyLDcgKzMxMTgsOCBAQCBTWVNDQUxMX0RFRklORTIoc3dh cG9uLCBjb25zdCBjaGFyIF9fdXNlciAqLCBzcGVjaWFsZmlsZSwgaW50LCBzd2FwX2ZsYWdzKQog CQkJCQkgc2l6ZW9mKGxvbmcpLAogCQkJCQkgR0ZQX0tFUk5FTCk7CiAKLQlpZiAocC0+YmRldiAm JiAoc3dhcF9mbGFncyAmIFNXQVBfRkxBR19ESVNDQVJEKSAmJiBzd2FwX2Rpc2NhcmRhYmxlKHAp KSB7CisJaWYgKChzd2FwX2ZsYWdzICYgU1dBUF9GTEFHX0RJU0NBUkQpICYmCisJICAgIHAtPmJk ZXYgJiYgYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHAtPmJkZXYpKSB7CiAJCS8qCiAJCSAqIFdo ZW4gZGlzY2FyZCBpcyBlbmFibGVkIGZvciBzd2FwIHdpdGggbm8gcGFydGljdWxhcgogCQkgKiBw b2xpY3kgZmxhZ2dlZCwgd2Ugc2V0IGFsbCBzd2FwIGRpc2NhcmQgZmxhZ3MgaGVyZSBpbgotLSAK Mi4zMC4yCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkxpbnV4LWYyZnMtZGV2ZWwgbWFpbGluZyBsaXN0CkxpbnV4LWYyZnMtZGV2ZWxAbGlzdHMuc291 cmNlZm9yZ2UubmV0Cmh0dHBzOi8vbGlzdHMuc291cmNlZm9yZ2UubmV0L2xpc3RzL2xpc3RpbmZv L2xpbnV4LWYyZnMtZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 466CBC43219 for ; Sat, 9 Apr 2022 04:52:32 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-542-AvJ418hNPwuG2cqGnSZFeg-1; Sat, 09 Apr 2022 00:52:28 -0400 X-MC-Unique: AvJ418hNPwuG2cqGnSZFeg-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.rdu2.redhat.com [10.11.54.7]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 3A0E980B710; Sat, 9 Apr 2022 04:52:26 +0000 (UTC) Received: from mm-prod-listman-01.mail-001.prod.us-east-1.aws.redhat.com (mm-prod-listman-01.mail-001.prod.us-east-1.aws.redhat.com [10.30.29.100]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1EA8B141512C; Sat, 9 Apr 2022 04:52:26 +0000 (UTC) Received: from mm-prod-listman-01.mail-001.prod.us-east-1.aws.redhat.com (localhost [IPv6:::1]) by mm-prod-listman-01.mail-001.prod.us-east-1.aws.redhat.com (Postfix) with ESMTP id D06CB194034C; Sat, 9 Apr 2022 04:52:25 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.rdu2.redhat.com [10.11.54.1]) by mm-prod-listman-01.mail-001.prod.us-east-1.aws.redhat.com (Postfix) with ESMTP id E00BB1940349 for ; Sat, 9 Apr 2022 04:52:24 +0000 (UTC) Received: by smtp.corp.redhat.com (Postfix) id D433C40CFD0B; Sat, 9 Apr 2022 04:52:24 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast01.extmail.prod.ext.rdu2.redhat.com [10.11.55.17]) by smtp.corp.redhat.com (Postfix) with ESMTPS id CEF0D40CFD0A for ; Sat, 9 Apr 2022 04:52:24 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-2.mimecast.com [207.211.31.81]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id A578485A5BC for ; Sat, 9 Apr 2022 04:52:24 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-671-Oe40zqOVNbyeWqQ5AnUj-A-1; Sat, 09 Apr 2022 00:52:22 -0400 X-MC-Unique: Oe40zqOVNbyeWqQ5AnUj-A-1 Received: from 213-147-167-116.nat.highway.webapn.at ([213.147.167.116] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.94.2 #2 (Red Hat Linux)) id 1nd354-0021dK-Sw; Sat, 09 Apr 2022 04:52:15 +0000 From: Christoph Hellwig To: Jens Axboe Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-Id: <20220409045043.23593-25-hch@lst.de> In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> MIME-Version: 1.0 X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.84 on 10.11.54.1 Subject: [dm-devel] [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.29 Precedence: list List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jfs-discussion@lists.sourceforge.net, linux-nvme@lists.infradead.org, virtualization@lists.linux-foundation.org, linux-mm@kvack.org, dm-devel@redhat.com, target-devel@vger.kernel.org, linux-mtd@lists.infradead.org, drbd-dev@lists.linbit.com, linux-s390@vger.kernel.org, linux-nilfs@vger.kernel.org, linux-scsi@vger.kernel.org, cluster-devel@redhat.com, xen-devel@lists.xenproject.org, linux-ext4@vger.kernel.org, linux-um@lists.infradead.org, nbd@other.debian.org, linux-block@vger.kernel.org, linux-bcache@vger.kernel.org, ceph-devel@vger.kernel.org, Coly Li , linux-raid@vger.kernel.org, "Martin K . Petersen" , linux-mmc@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-xfs@vger.kernel.org, =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , ocfs2-devel@oss.oracle.com, linux-fsdevel@vger.kernel.org, ntfs3@lists.linux.dev, linux-btrfs@vger.kernel.org Errors-To: dm-devel-bounces@redhat.com Sender: "dm-devel" X-Scanned-By: MIMEDefang 2.85 on 10.11.54.7 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 SnVzdCB1c2UgYSBub24temVybyBtYXhfZGlzY2FyZF9zZWN0b3JzIGFzIGFuIGluZGljYXRvciBm b3IgZGlzY2FyZApzdXBwb3J0LCBzaW1pbGFyIHRvIHdoYXQgaXMgZG9uZSBmb3Igd3JpdGUgemVy b2VzLgoKVGhlIG9ubHkgcGxhY2VzIHdoZXJlIG5lZWRzIHNwZWNpYWwgYXR0ZW50aW9uIGlzIHRo ZSBSQUlENSBkcml2ZXIsCndoaWNoIG11c3QgY2xlYXIgZGlzY2FyZCBzdXBwb3J0IGZvciBzZWN1 cml0eSByZWFzb25zIGJ5IGRlZmF1bHQsCmV2ZW4gaWYgdGhlIGRlZmF1bHQgc3RhY2tpbmcgcnVs ZXMgd291bGQgYWxsb3cgZm9yIGl0LgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcg PGhjaEBsc3QuZGU+ClJldmlld2VkLWJ5OiBNYXJ0aW4gSy4gUGV0ZXJzZW4gPG1hcnRpbi5wZXRl cnNlbkBvcmFjbGUuY29tPgpBY2tlZC1ieTogQ2hyaXN0b3BoIELDtmhtd2FsZGVyIDxjaHJpc3Rv cGguYm9laG13YWxkZXJAbGluYml0LmNvbT4gW2J0cmZzXQpBY2tlZC1ieTogQ29seSBMaSA8Y29s eWxpQHN1c2UuZGU+IFtiY2FjaGVdCi0tLQogYXJjaC91bS9kcml2ZXJzL3ViZF9rZXJuLmMgICAg ICAgICAgfCAgMiAtLQogYmxvY2svYmxrLWNvcmUuYyAgICAgICAgICAgICAgICAgICAgfCAgMiAr LQogYmxvY2svYmxrLWxpYi5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogYmxvY2svYmxr LW1xLWRlYnVnZnMuYyAgICAgICAgICAgICAgfCAgMSAtCiBibG9jay9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgICB8ICAzICstLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbWFpbi5jICAg ICAgfCAgMiArLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYyAgICAgICAgfCAxOSArKy0t LS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jICB8ICAz ICstLQogZHJpdmVycy9ibG9jay9sb29wLmMgICAgICAgICAgICAgICAgfCAxMSArKystLS0tLS0t LQogZHJpdmVycy9ibG9jay9uYmQuYyAgICAgICAgICAgICAgICAgfCAgNSArLS0tLQogZHJpdmVy cy9ibG9jay9udWxsX2Jsay9tYWluLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL2Jsb2NrL3JiZC5j ICAgICAgICAgICAgICAgICB8ICAxIC0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jICAg ICAgIHwgIDIgLS0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaCAgIHwgIDMgLS0t CiBkcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYyAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Js b2NrL3hlbi1ibGtiYWNrL3hlbmJ1cy5jICB8ICAyICstCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtm cm9udC5jICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYyAgICAg ICB8ICAxIC0KIGRyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYyAgICAgICAgIHwgIDQgKystLQog ZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYyAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv YmNhY2hlL3N5c2ZzLmMgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvbWQvZG0tY2FjaGUtdGFy Z2V0LmMgICAgICAgIHwgIDkgKy0tLS0tLS0tCiBkcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5j ICAgICAgICB8ICA5ICstLS0tLS0tLQogZHJpdmVycy9tZC9kbS1sb2ctd3JpdGVzLmMgICAgICAg ICAgfCAgMyArLS0KIGRyaXZlcnMvbWQvZG0tcmFpZC5jICAgICAgICAgICAgICAgIHwgIDkgKyst LS0tLS0tCiBkcml2ZXJzL21kL2RtLXRhYmxlLmMgICAgICAgICAgICAgICB8ICA5ICsrLS0tLS0t LQogZHJpdmVycy9tZC9kbS10aGluLmMgICAgICAgICAgICAgICAgfCAxMSArLS0tLS0tLS0tLQog ZHJpdmVycy9tZC9kbS5jICAgICAgICAgICAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv bWQtbGluZWFyLmMgICAgICAgICAgICAgIHwgMTEgKy0tLS0tLS0tLS0KIGRyaXZlcnMvbWQvcmFp ZDAuYyAgICAgICAgICAgICAgICAgIHwgIDcgLS0tLS0tLQogZHJpdmVycy9tZC9yYWlkMS5jICAg ICAgICAgICAgICAgICAgfCAxNiArLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL21kL3JhaWQxMC5j ICAgICAgICAgICAgICAgICB8IDE4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tZC9yYWlk NS1jYWNoZS5jICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9tZC9yYWlkNS5jICAgICAgICAg ICAgICAgICAgfCAxMiArKysrLS0tLS0tLS0KIGRyaXZlcnMvbW1jL2NvcmUvcXVldWUuYyAgICAg ICAgICAgIHwgIDEgLQogZHJpdmVycy9tdGQvbXRkX2Jsa2RldnMuYyAgICAgICAgICAgfCAgMSAt CiBkcml2ZXJzL252bWUvaG9zdC9jb3JlLmMgICAgICAgICAgICB8ICA2ICsrLS0tLQogZHJpdmVy cy9zMzkwL2Jsb2NrL2Rhc2RfZmJhLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL3Njc2kvc2QuYyAg ICAgICAgICAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9kZXZp Y2UuYyB8ICAyICstCiBmcy9idHJmcy9leHRlbnQtdHJlZS5jICAgICAgICAgICAgICB8ICA0ICsr LS0KIGZzL2J0cmZzL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0 L2ZpbGUuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0L3N1cGVyLmMgICAg ICAgICAgICAgICAgICAgIHwgMTAgKysrLS0tLS0tLQogZnMvZXh0NC9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgfCAxMCArKystLS0tLS0tCiBmcy9leHQ0L3N1cGVyLmMgICAgICAgICAgICAg ICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZzL2YyZnMvZjJmcy5oICAgICAgICAgICAgICAgICAg ICAgIHwgIDMgKy0tCiBmcy9mYXQvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgICB8ICAyICst CiBmcy9mYXQvaW5vZGUuYyAgICAgICAgICAgICAgICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZz L2dmczIvcmdycC5jICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2piZDIvam91cm5h bC5jICAgICAgICAgICAgICAgICAgIHwgIDcgKystLS0tLQogZnMvamZzL2lvY3RsLmMgICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQogZnMvamZzL3N1cGVyLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgOCArKy0tLS0tLQogZnMvbmlsZnMyL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgfCAg MiArLQogZnMvbnRmczMvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvbnRm czMvc3VwZXIuYyAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvb2NmczIvaW9jdGwuYyAg ICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMveGZzL3hmc19kaXNjYXJkLmMgICAgICAgICAg ICAgICAgfCAgMiArLQogZnMveGZzL3hmc19zdXBlci5jICAgICAgICAgICAgICAgICAgfCAxMiAr KysrLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvYmxrZGV2LmggICAgICAgICAgICAgIHwgIDIgLS0K IG1tL3N3YXBmaWxlLmMgICAgICAgICAgICAgICAgICAgICAgIHwgMTcgKystLS0tLS0tLS0tLS0t LS0KIDYxIGZpbGVzIGNoYW5nZWQsIDcyIGluc2VydGlvbnMoKyksIDI0NiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvdWJkX2tlcm4uYyBiL2FyY2gvdW0vZHJpdmVy cy91YmRfa2Vybi5jCmluZGV4IGIwMzI2OWZhZWY3MTQuLjA4NWZmZGY5OGU1N2UgMTAwNjQ0Ci0t LSBhL2FyY2gvdW0vZHJpdmVycy91YmRfa2Vybi5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy91YmRf a2Vybi5jCkBAIC00ODMsNyArNDgzLDYgQEAgc3RhdGljIHZvaWQgdWJkX2hhbmRsZXIodm9pZCkK IAkJCWlmICgoaW9fcmVxLT5lcnJvciA9PSBCTEtfU1RTX05PVFNVUFApICYmIChyZXFfb3AoaW9f cmVxLT5yZXEpID09IFJFUV9PUF9ESVNDQVJEKSkgewogCQkJCWJsa19xdWV1ZV9tYXhfZGlzY2Fy ZF9zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKIAkJCQlibGtfcXVldWVfbWF4X3dyaXRlX3pl cm9lc19zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKLQkJCQlibGtfcXVldWVfZmxhZ19jbGVh cihRVUVVRV9GTEFHX0RJU0NBUkQsIGlvX3JlcS0+cmVxLT5xKTsKIAkJCX0KIAkJCWJsa19tcV9l bmRfcmVxdWVzdChpb19yZXEtPnJlcSwgaW9fcmVxLT5lcnJvcik7CiAJCQlrZnJlZShpb19yZXEp OwpAQCAtODAzLDcgKzgwMiw2IEBAIHN0YXRpYyBpbnQgdWJkX29wZW5fZGV2KHN0cnVjdCB1YmQg KnViZF9kZXYpCiAJCXViZF9kZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQgPSBT RUNUT1JfU0laRTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnModWJkX2Rldi0+cXVl dWUsIFVCRF9NQVhfUkVRVUVTVCk7CiAJCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3Rv cnModWJkX2Rldi0+cXVldWUsIFVCRF9NQVhfUkVRVUVTVCk7Ci0JCWJsa19xdWV1ZV9mbGFnX3Nl dChRVUVVRV9GTEFHX0RJU0NBUkQsIHViZF9kZXYtPnF1ZXVlKTsKIAl9CiAJYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfTk9OUk9ULCB1YmRfZGV2LT5xdWV1ZSk7CiAJcmV0dXJuIDA7CmRp ZmYgLS1naXQgYS9ibG9jay9ibGstY29yZS5jIGIvYmxvY2svYmxrLWNvcmUuYwppbmRleCA5Mzdi YjZiODYzMzE3Li5iNWMzYTgwNDkxMzRjIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY29yZS5jCisr KyBiL2Jsb2NrL2Jsay1jb3JlLmMKQEAgLTgyMCw3ICs4MjAsNyBAQCB2b2lkIHN1Ym1pdF9iaW9f bm9hY2N0KHN0cnVjdCBiaW8gKmJpbykKIAogCXN3aXRjaCAoYmlvX29wKGJpbykpIHsKIAljYXNl IFJFUV9PUF9ESVNDQVJEOgotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQorCQlpZiAoIWJk ZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSkKIAkJCWdvdG8gbm90X3N1cHBvcnRlZDsKIAkJ YnJlYWs7CiAJY2FzZSBSRVFfT1BfU0VDVVJFX0VSQVNFOgpkaWZmIC0tZ2l0IGEvYmxvY2svYmxr LWxpYi5jIGIvYmxvY2svYmxrLWxpYi5jCmluZGV4IDJhZTMyYTcyMjg1MWMuLjhiNGI2NmQzYTli ZmMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1saWIuYworKysgYi9ibG9jay9ibGstbGliLmMKQEAg LTUzLDcgKzUzLDcgQEAgaW50IF9fYmxrZGV2X2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2Rl dmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCQlv cCA9IFJFUV9PUF9TRUNVUkVfRVJBU0U7CiAJfSBlbHNlIHsKLQkJaWYgKCFibGtfcXVldWVfZGlz Y2FyZChxKSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAJCW9wID0gUkVRX09QX0RJU0NBUkQ7CiAJfQpkaWZmIC0tZ2l0IGEv YmxvY2svYmxrLW1xLWRlYnVnZnMuYyBiL2Jsb2NrL2Jsay1tcS1kZWJ1Z2ZzLmMKaW5kZXggYWEw MzQ5ZTlmMDgzYi4uZmQxMTFjNTAwMTI1NiAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLW1xLWRlYnVn ZnMuYworKysgYi9ibG9jay9ibGstbXEtZGVidWdmcy5jCkBAIC0xMTMsNyArMTEzLDYgQEAgc3Rh dGljIGNvbnN0IGNoYXIgKmNvbnN0IGJsa19xdWV1ZV9mbGFnX25hbWVbXSA9IHsKIAlRVUVVRV9G TEFHX05BTUUoRkFJTF9JTyksCiAJUVVFVUVfRkxBR19OQU1FKE5PTlJPVCksCiAJUVVFVUVfRkxB R19OQU1FKElPX1NUQVQpLAotCVFVRVVFX0ZMQUdfTkFNRShESVNDQVJEKSwKIAlRVUVVRV9GTEFH X05BTUUoTk9YTUVSR0VTKSwKIAlRVUVVRV9GTEFHX05BTUUoQUREX1JBTkRPTSksCiAJUVVFVUVf RkxBR19OQU1FKFNFQ0VSQVNFKSwKZGlmZiAtLWdpdCBhL2Jsb2NrL2lvY3RsLmMgYi9ibG9jay9p b2N0bC5jCmluZGV4IGFkMzc3MWIyNjhiODEuLmMyY2QzYmE1MjkwY2UgMTAwNjQ0Ci0tLSBhL2Js b2NrL2lvY3RsLmMKKysrIGIvYmxvY2svaW9jdGwuYwpAQCAtODcsMTQgKzg3LDEzIEBAIHN0YXRp YyBpbnQgYmxrX2lvY3RsX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlLAogewogCXVpbnQ2NF90IHJhbmdlWzJdOwogCXVpbnQ2NF90IHN0YXJ0LCBsZW47Ci0J c3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShiZGV2KTsKIAlzdHJ1Y3Qg aW5vZGUgKmlub2RlID0gYmRldi0+YmRfaW5vZGU7CiAJaW50IGVycjsKIAogCWlmICghKG1vZGUg JiBGTU9ERV9XUklURSkpCiAJCXJldHVybiAtRUJBREY7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQlyZXR1cm4g LUVPUE5PVFNVUFA7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIocmFuZ2UsICh2b2lkIF9fdXNlciAq KWFyZywgc2l6ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJi ZF9tYWluLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMKaW5kZXggZWFlNjI5YzRm NmVhZi4uYTY5NDc1ZTU5MjgyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf bWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX21haW4uYwpAQCAtOTQyLDcgKzk0 Miw3IEBAIGludCBkcmJkX3NlbmRfc2l6ZXMoc3RydWN0IGRyYmRfcGVlcl9kZXZpY2UgKnBlZXJf ZGV2aWNlLCBpbnQgdHJpZ2dlcl9yZXBseSwgZW51CiAJCQljcHVfdG9fYmUzMihiZGV2X2FsaWdu bWVudF9vZmZzZXQoYmRldikpOwogCQlwLT5xbGltLT5pb19taW4gPSBjcHVfdG9fYmUzMihiZGV2 X2lvX21pbihiZGV2KSk7CiAJCXAtPnFsaW0tPmlvX29wdCA9IGNwdV90b19iZTMyKGJkZXZfaW9f b3B0KGJkZXYpKTsKLQkJcC0+cWxpbS0+ZGlzY2FyZF9lbmFibGVkID0gYmxrX3F1ZXVlX2Rpc2Nh cmQocSk7CisJCXAtPnFsaW0tPmRpc2NhcmRfZW5hYmxlZCA9ICEhYmRldl9tYXhfZGlzY2FyZF9z ZWN0b3JzKGJkZXYpOwogCQlwdXRfbGRldihkZXZpY2UpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBy ZXF1ZXN0X3F1ZXVlICpxID0gZGV2aWNlLT5ycV9xdWV1ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv YmxvY2svZHJiZC9kcmJkX25sLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9ubC5jCmluZGV4 IGQ0ZGFjYzMyOWFjMmUuLmI1NWU1ZmNjMjFlMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv ZHJiZC9kcmJkX25sLmMKKysrIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYwpAQCAtMTIx MCw3ICsxMjEwLDcgQEAgc3RhdGljIHZvaWQgZGVjaWRlX29uX2Rpc2NhcmRfc3VwcG9ydChzdHJ1 Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwKIAkJZmlyc3RfcGVlcl9kZXZpY2UoZGV2aWNlKS0+Y29u bmVjdGlvbjsKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGRldmljZS0+cnFfcXVldWU7CiAK LQlpZiAoYmRldiAmJiAhYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldi0+YmFja2luZ19iZGV2LT5iZF9k aXNrLT5xdWV1ZSkpCisJaWYgKGJkZXYgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2 LT5iYWNraW5nX2JkZXYpKQogCQlnb3RvIG5vdF9zdXBwb3J0ZWQ7CiAKIAlpZiAoY29ubmVjdGlv bi0+Y3N0YXRlID49IENfQ09OTkVDVEVEICYmCkBAIC0xMjMwLDMwICsxMjMwLDE2IEBAIHN0YXRp YyB2b2lkIGRlY2lkZV9vbl9kaXNjYXJkX3N1cHBvcnQoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZp Y2UsCiAJICovCiAJYmxrX3F1ZXVlX2Rpc2NhcmRfZ3JhbnVsYXJpdHkocSwgNTEyKTsKIAlxLT5s aW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9ycyA9IGRyYmRfbWF4X2Rpc2NhcmRfc2VjdG9ycyhjb25u ZWN0aW9uKTsKLQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAlx LT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0KIAkJZHJiZF9tYXhfZGlzY2FyZF9z ZWN0b3JzKGNvbm5lY3Rpb24pOwogCXJldHVybjsKIAogbm90X3N1cHBvcnRlZDoKLQlibGtfcXVl dWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwogCWJsa19xdWV1ZV9kaXNjYXJk X2dyYW51bGFyaXR5KHEsIDApOwogCXEtPmxpbWl0cy5tYXhfZGlzY2FyZF9zZWN0b3JzID0gMDsK IAlxLT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0gMDsKIH0KIAotc3RhdGljIHZv aWQgZml4dXBfZGlzY2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpx KQotewotCS8qIFRvIGF2b2lkIGNvbmZ1c2lvbiwgaWYgdGhpcyBxdWV1ZSBkb2VzIG5vdCBzdXBw b3J0IGRpc2NhcmQsIGNsZWFyCi0JICogbWF4X2Rpc2NhcmRfc2VjdG9ycywgd2hpY2ggaXMgd2hh dCBsc2JsayAtRCByZXBvcnRzIHRvIHRoZSB1c2VyLgotCSAqIE9sZGVyIGtlcm5lbHMgZ290IHRo aXMgd3JvbmcgaW4gInN0YWNrIGxpbWl0cyIuCi0JICogKi8KLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKSB7Ci0JCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIDApOwotCQlibGtf cXVldWVfZGlzY2FyZF9ncmFudWxhcml0eShxLCAwKTsKLQl9Ci19Ci0KIHN0YXRpYyB2b2lkIGZp eHVwX3dyaXRlX3plcm9lcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwgc3RydWN0IHJlcXVl c3RfcXVldWUgKnEpCiB7CiAJLyogRml4dXAgbWF4X3dyaXRlX3plcm9lc19zZWN0b3JzIGFmdGVy IGJsa19zdGFja19saW1pdHMoKToKQEAgLTEzMDAsNyArMTI4Niw2IEBAIHN0YXRpYyB2b2lkIGRy YmRfc2V0dXBfcXVldWVfcGFyYW0oc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBk cmJkX2JhY2tpCiAJCWJsa19zdGFja19saW1pdHMoJnEtPmxpbWl0cywgJmItPmxpbWl0cywgMCk7 CiAJCWRpc2tfdXBkYXRlX3JlYWRhaGVhZChkZXZpY2UtPnZkaXNrKTsKIAl9Ci0JZml4dXBfZGlz Y2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHEpOwogCWZpeHVwX3dyaXRlX3plcm9lcyhkZXZpY2UsIHEp OwogfQogCkBAIC0xNDQ3LDcgKzE0MzIsNyBAQCBzdGF0aWMgdm9pZCBzYW5pdGl6ZV9kaXNrX2Nv bmYoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBkaXNrX2NvbmYgKmRpcwogCWlm IChkaXNrX2NvbmYtPmFsX2V4dGVudHMgPiBkcmJkX2FsX2V4dGVudHNfbWF4KG5iYykpCiAJCWRp c2tfY29uZi0+YWxfZXh0ZW50cyA9IGRyYmRfYWxfZXh0ZW50c19tYXgobmJjKTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhi ZGV2KSkgewogCQlpZiAoZGlza19jb25mLT5yc19kaXNjYXJkX2dyYW51bGFyaXR5KSB7CiAJCQlk aXNrX2NvbmYtPnJzX2Rpc2NhcmRfZ3JhbnVsYXJpdHkgPSAwOyAvKiBkaXNhYmxlIGZlYXR1cmUg Ki8KIAkJCWRyYmRfaW5mbyhkZXZpY2UsICJyc19kaXNjYXJkX2dyYW51bGFyaXR5IGZlYXR1cmUg ZGlzYWJsZWRcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2 ZXIuYyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX3JlY2VpdmVyLmMKaW5kZXggMGI0YzdkZTQ2 Mzk4OS4uOGE0YTQ3ZGE1NmZlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf cmVjZWl2ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC0x NTc1LDExICsxNTc1LDEwIEBAIGludCBkcmJkX2lzc3VlX2Rpc2NhcmRfb3JfemVyb19vdXQoc3Ry dWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHNlY3Rvcl90IHN0YXJ0LCB1CiAKIHN0YXRpYyBib29s IGNhbl9kb19yZWxpYWJsZV9kaXNjYXJkcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSkKIHsK LQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGRldmljZS0+bGRldi0+ YmFja2luZ19iZGV2KTsKIAlzdHJ1Y3QgZGlza19jb25mICpkYzsKIAlib29sIGNhbl9kbzsKIAot CWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoZGV2aWNlLT5sZGV2LT5iYWNraW5nX2JkZXYpKQogCQlyZXR1cm4gZmFsc2U7CiAKIAlyY3Vf cmVhZF9sb2NrKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYyBiL2RyaXZlcnMv YmxvY2svbG9vcC5jCmluZGV4IDhkODAwZDQ2ZTQ5ODUuLjBlMDYxYzk4OTZlZmYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCkBAIC0z MTQsMTUgKzMxNCwxMiBAQCBzdGF0aWMgaW50IGxvX2ZhbGxvY2F0ZShzdHJ1Y3QgbG9vcF9kZXZp Y2UgKmxvLCBzdHJ1Y3QgcmVxdWVzdCAqcnEsIGxvZmZfdCBwb3MsCiAKIAltb2RlIHw9IEZBTExP Q19GTF9LRUVQX1NJWkU7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKGxvLT5sb19xdWV1ZSkp IHsKLQkJcmV0ID0gLUVPUE5PVFNVUFA7Ci0JCWdvdG8gb3V0OwotCX0KKwlpZiAoIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhsby0+bG9fZGV2aWNlKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOwog CiAJcmV0ID0gZmlsZS0+Zl9vcC0+ZmFsbG9jYXRlKGZpbGUsIG1vZGUsIHBvcywgYmxrX3JxX2J5 dGVzKHJxKSk7CiAJaWYgKHVubGlrZWx5KHJldCAmJiByZXQgIT0gLUVJTlZBTCAmJiByZXQgIT0g LUVPUE5PVFNVUFApKQotCQlyZXQgPSAtRUlPOwotIG91dDoKKwkJcmV0dXJuIC1FSU87CiAJcmV0 dXJuIHJldDsKIH0KIApAQCAtNzg3LDEyICs3ODQsMTAgQEAgc3RhdGljIHZvaWQgbG9vcF9jb25m aWdfZGlzY2FyZChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvKQogCQlxLT5saW1pdHMuZGlzY2FyZF9n cmFudWxhcml0eSA9IGdyYW51bGFyaXR5OwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9y cyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKIAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNf c2VjdG9ycyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFV RVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJfSBlbHNlIHsKIAkJcS0+bGltaXRzLmRpc2NhcmRfZ3Jh bnVsYXJpdHkgPSAwOwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCAwKTsKIAkJ YmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhxLCAwKTsKLQkJYmxrX3F1ZXVlX2Zs YWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAl9CiAJcS0+bGltaXRzLmRpc2NhcmRf YWxpZ25tZW50ID0gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbmJkLmMgYi9kcml2 ZXJzL2Jsb2NrL25iZC5jCmluZGV4IDVhMWY5ODQ5NGRkZGYuLjQ3MjlhZWY4YzY0NjIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYmxvY2svbmJkLmMKKysrIGIvZHJpdmVycy9ibG9jay9uYmQuYwpAQCAt MTIzMSw4ICsxMjMxLDYgQEAgc3RhdGljIHZvaWQgbmJkX3BhcnNlX2ZsYWdzKHN0cnVjdCBuYmRf ZGV2aWNlICpuYmQpCiAJCXNldF9kaXNrX3JvKG5iZC0+ZGlzaywgdHJ1ZSk7CiAJZWxzZQogCQlz ZXRfZGlza19ybyhuYmQtPmRpc2ssIGZhbHNlKTsKLQlpZiAoY29uZmlnLT5mbGFncyAmIE5CRF9G TEFHX1NFTkRfVFJJTSkKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwg bmJkLT5kaXNrLT5xdWV1ZSk7CiAJaWYgKGNvbmZpZy0+ZmxhZ3MgJiBOQkRfRkxBR19TRU5EX0ZM VVNIKSB7CiAJCWlmIChjb25maWctPmZsYWdzICYgTkJEX0ZMQUdfU0VORF9GVUEpCiAJCQlibGtf cXVldWVfd3JpdGVfY2FjaGUobmJkLT5kaXNrLT5xdWV1ZSwgdHJ1ZSwgdHJ1ZSk7CkBAIC0xMzE5 LDggKzEzMTcsNyBAQCBzdGF0aWMgdm9pZCBuYmRfY29uZmlnX3B1dChzdHJ1Y3QgbmJkX2Rldmlj ZSAqbmJkKQogCQluYmQtPnRhZ19zZXQudGltZW91dCA9IDA7CiAJCW5iZC0+ZGlzay0+cXVldWUt PmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJbmJkLT5kaXNrLT5xdWV1ZS0+bGlt aXRzLmRpc2NhcmRfYWxpZ25tZW50ID0gMDsKLQkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3Rv cnMobmJkLT5kaXNrLT5xdWV1ZSwgVUlOVF9NQVgpOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIG5iZC0+ZGlzay0+cXVldWUpOworCQlibGtfcXVldWVfbWF4X2Rp c2NhcmRfc2VjdG9ycyhuYmQtPmRpc2stPnF1ZXVlLCAwKTsKIAogCQltdXRleF91bmxvY2soJm5i ZC0+Y29uZmlnX2xvY2spOwogCQluYmRfcHV0KG5iZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Js b2NrL251bGxfYmxrL21haW4uYyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCmluZGV4 IDA1YjExMjBlNjYyMzQuLmY2NDkzYTllODVlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv bnVsbF9ibGsvbWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCkBAIC0x NzY3LDcgKzE3NjcsNiBAQCBzdGF0aWMgdm9pZCBudWxsX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBu dWxsYiAqbnVsbGIpCiAJbnVsbGItPnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gbnVs bGItPmRldi0+YmxvY2tzaXplOwogCW51bGxiLT5xLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQg PSBudWxsYi0+ZGV2LT5ibG9ja3NpemU7CiAJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMo bnVsbGItPnEsIFVJTlRfTUFYID4+IDkpOwotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFH X0RJU0NBUkQsIG51bGxiLT5xKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZp Y2Vfb3BlcmF0aW9ucyBudWxsX2Jpb19vcHMgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2Nr L3JiZC5jIGIvZHJpdmVycy9ibG9jay9yYmQuYwppbmRleCBiODQ0NDMyYmFkMjBiLi4yYjIxZjcx N2NjZTFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3JiZC5jCisrKyBiL2RyaXZlcnMvYmxv Y2svcmJkLmMKQEAgLTQ5NDIsNyArNDk0Miw2IEBAIHN0YXRpYyBpbnQgcmJkX2luaXRfZGlzayhz dHJ1Y3QgcmJkX2RldmljZSAqcmJkX2RldikKIAlibGtfcXVldWVfaW9fb3B0KHEsIHJiZF9kZXYt Pm9wdHMtPmFsbG9jX3NpemUpOwogCiAJaWYgKHJiZF9kZXYtPm9wdHMtPnRyaW0pIHsKLQkJYmxr X3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJCXEtPmxpbWl0cy5kaXNj YXJkX2dyYW51bGFyaXR5ID0gcmJkX2Rldi0+b3B0cy0+YWxsb2Nfc2l6ZTsKIAkJYmxrX3F1ZXVl X21heF9kaXNjYXJkX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNFQ1RPUl9TSElGVCk7CiAJ CWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNF Q1RPUl9TSElGVCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1jbHQuYyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCmluZGV4IGI2NmU4ODQwYjk0YjguLmVmYTk5 YTM4ODQ1MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCisrKyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCkBAIC0xMzY0LDggKzEzNjQsNiBAQCBzdGF0 aWMgdm9pZCBzZXR1cF9yZXF1ZXN0X3F1ZXVlKHN0cnVjdCBybmJkX2NsdF9kZXYgKmRldikKIAli bGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPnF1ZXVlLCBkZXYtPm1heF9kaXNjYXJk X3NlY3RvcnMpOwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5CT0gZGV2 LT5kaXNjYXJkX2dyYW51bGFyaXR5OwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2FsaWdu bWVudAk9IGRldi0+ZGlzY2FyZF9hbGlnbm1lbnQ7Ci0JaWYgKGRldi0+bWF4X2Rpc2NhcmRfc2Vj dG9ycykKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgZGV2LT5xdWV1 ZSk7CiAJaWYgKGRldi0+c2VjdXJlX2Rpc2NhcmQpCiAJCWJsa19xdWV1ZV9mbGFnX3NldChRVUVV RV9GTEFHX1NFQ0VSQVNFLCBkZXYtPnF1ZXVlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay9ybmJkL3JuYmQtc3J2LWRldi5oIGIvZHJpdmVycy9ibG9jay9ybmJkL3JuYmQtc3J2LWRldi5o CmluZGV4IGY4MmZiYjRiYmRhOGUuLjFmN2UxYzhmZDRkOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv YmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaAorKysgYi9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1z cnYtZGV2LmgKQEAgLTQ5LDkgKzQ5LDYgQEAgc3RhdGljIGlubGluZSBpbnQgcm5iZF9kZXZfZ2V0 X3NlY3VyZV9kaXNjYXJkKGNvbnN0IHN0cnVjdCBybmJkX2RldiAqZGV2KQogCiBzdGF0aWMgaW5s aW5lIGludCBybmJkX2Rldl9nZXRfbWF4X2Rpc2NhcmRfc2VjdHMoY29uc3Qgc3RydWN0IHJuYmRf ZGV2ICpkZXYpCiB7Ci0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShkZXYt PmJkZXYpKSkKLQkJcmV0dXJuIDA7Ci0KIAlyZXR1cm4gYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KGRldi0+YmRldik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svdmlydGlvX2Jsay5j IGIvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKaW5kZXggYThiY2YzZjY2NGFmMS4uNmNjZjE1 MjUzZGVlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKKysrIGIvZHJp dmVycy9ibG9jay92aXJ0aW9fYmxrLmMKQEAgLTg4OCw4ICs4ODgsNiBAQCBzdGF0aWMgaW50IHZp cnRibGtfcHJvYmUoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCiAJCQl2ID0gc2dfZWxlbXM7 CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWdtZW50cyhxLAogCQkJCQkgICAgICAgbWluKHYs IE1BWF9ESVNDQVJEX1NFR01FTlRTKSk7Ci0KLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZM QUdfRElTQ0FSRCwgcSk7CiAJfQogCiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJU SU9fQkxLX0ZfV1JJVEVfWkVST0VTKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrYmFjay94ZW5idXMuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2sveGVuYnVzLmMKaW5k ZXggOGI2OTFmZTUwNDc1Zi4uODNjZDA4MDQxZTZiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay94ZW4tYmxrYmFjay94ZW5idXMuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hl bmJ1cy5jCkBAIC01ODMsNyArNTgzLDcgQEAgc3RhdGljIHZvaWQgeGVuX2Jsa2JrX2Rpc2NhcmQo c3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQsIHN0cnVjdCBiYWNrZW5kX2luZm8KIAlpZiAo IXhlbmJ1c19yZWFkX3Vuc2lnbmVkKGRldi0+bm9kZW5hbWUsICJkaXNjYXJkLWVuYWJsZSIsIDEp KQogCQlyZXR1cm47CiAKLQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKSB7CiAJCWVyciA9IHhlbmJ1c19wcmludGYoeGJ0LCBk ZXYtPm5vZGVuYW1lLAogCQkJImRpc2NhcmQtZ3JhbnVsYXJpdHkiLCAiJXUiLAogCQkJcS0+bGlt aXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrZnJvbnQuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2Zyb250LmMKaW5kZXggMDAzMDU2ZDRm N2Y1Zi4uMjUzYmY4MzVhY2ExZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay94ZW4tYmxrZnJv bnQuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jCkBAIC05NDQsNyArOTQ0LDYg QEAgc3RhdGljIHZvaWQgYmxraWZfc2V0X3F1ZXVlX2xpbWl0cyhzdHJ1Y3QgYmxrZnJvbnRfaW5m byAqaW5mbykKIAlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19WSVJULCBycSk7CiAKIAlp ZiAoaW5mby0+ZmVhdHVyZV9kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX0RJU0NBUkQsIHJxKTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMocnEsIGdl dF9jYXBhY2l0eShnZCkpOwogCQlycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkgPSBpbmZv LT5kaXNjYXJkX2dyYW51bGFyaXR5ID86CiAJCQkJCQkgaW5mby0+cGh5c2ljYWxfc2VjdG9yX3Np emU7CkBAIC0xNjA2LDcgKzE2MDUsNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgYmxraWZfaW50ZXJy dXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAkJCQlibGtpZl9yZXEocmVxKS0+ZXJyb3IgPSBC TEtfU1RTX05PVFNVUFA7CiAJCQkJaW5mby0+ZmVhdHVyZV9kaXNjYXJkID0gMDsKIAkJCQlpbmZv LT5mZWF0dXJlX3NlY2Rpc2NhcmQgPSAwOwotCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfRElTQ0FSRCwgcnEpOwogCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdf U0VDRVJBU0UsIHJxKTsKIAkJCX0KIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay96cmFtL3pyYW1fZHJ2LmMgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwppbmRleCBl OTQ3NGIwMjAxMmRlLi41OWZmNDQ0YmY2Yzc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3py YW0venJhbV9kcnYuYworKysgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwpAQCAtMTk1 Miw3ICsxOTUyLDYgQEAgc3RhdGljIGludCB6cmFtX2FkZCh2b2lkKQogCWJsa19xdWV1ZV9pb19v cHQoenJhbS0+ZGlzay0+cXVldWUsIFBBR0VfU0laRSk7CiAJenJhbS0+ZGlzay0+cXVldWUtPmxp bWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gUEFHRV9TSVpFOwogCWJsa19xdWV1ZV9tYXhfZGlz Y2FyZF9zZWN0b3JzKHpyYW0tPmRpc2stPnF1ZXVlLCBVSU5UX01BWCk7Ci0JYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgenJhbS0+ZGlzay0+cXVldWUpOwogCiAJLyoKIAkg KiB6cmFtX2Jpb19kaXNjYXJkKCkgd2lsbCBjbGVhciBhbGwgbG9naWNhbCBibG9ja3MgaWYgbG9n aWNhbCBibG9jawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jIGIvZHJp dmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jCmluZGV4IGZkZDAxOTRmODRkZDAuLmUyN2Y2N2YwNmE0 MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYworKysgYi9kcml2ZXJz L21kL2JjYWNoZS9yZXF1ZXN0LmMKQEAgLTEwMDUsNyArMTAwNSw3IEBAIHN0YXRpYyB2b2lkIGNh Y2hlZF9kZXZfd3JpdGUoc3RydWN0IGNhY2hlZF9kZXYgKmRjLCBzdHJ1Y3Qgc2VhcmNoICpzKQog CQliaW9fZ2V0KHMtPmlvcC5iaW8pOwogCiAJCWlmIChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElT Q0FSRCAmJgotCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2 KSkpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGRjLT5iZGV2KSkKIAkJCWdvdG8g aW5zZXJ0X2RhdGE7CiAKIAkJLyogSS9PIHJlcXVlc3Qgc2VudCB0byBiYWNraW5nIGRldmljZSAq LwpAQCAtMTExNSw3ICsxMTE1LDcgQEAgc3RhdGljIHZvaWQgZGV0YWNoZWRfZGV2X2RvX3JlcXVl c3Qoc3RydWN0IGJjYWNoZV9kZXZpY2UgKmQsIHN0cnVjdCBiaW8gKmJpbywKIAliaW8tPmJpX3By aXZhdGUgPSBkZGlwOwogCiAJaWYgKChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYK LQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2KSkpCisJICAg ICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGMtPmJkZXYpKQogCQliaW8tPmJpX2VuZF9pbyhi aW8pOwogCWVsc2UKIAkJc3VibWl0X2Jpb19ub2FjY3QoYmlvKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWQvYmNhY2hlL3N1cGVyLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zdXBlci5jCmluZGV4IGJm M2RlMTQ5ZDNjOWYuLjJmNDllMzExNDJmNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hl L3N1cGVyLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYwpAQCAtOTczLDcgKzk3Myw2 IEBAIHN0YXRpYyBpbnQgYmNhY2hlX2RldmljZV9pbml0KHN0cnVjdCBiY2FjaGVfZGV2aWNlICpk LCB1bnNpZ25lZCBpbnQgYmxvY2tfc2l6ZSwKIAogCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX05PTlJPVCwgZC0+ZGlzay0+cXVldWUpOwogCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfQUREX1JBTkRPTSwgZC0+ZGlzay0+cXVldWUpOwotCWJsa19xdWV1ZV9mbGFnX3NldChR VUVVRV9GTEFHX0RJU0NBUkQsIGQtPmRpc2stPnF1ZXVlKTsKIAogCWJsa19xdWV1ZV93cml0ZV9j YWNoZShxLCB0cnVlLCB0cnVlKTsKIApAQCAtMjM1MCw3ICsyMzQ5LDcgQEAgc3RhdGljIGludCBy ZWdpc3Rlcl9jYWNoZShzdHJ1Y3QgY2FjaGVfc2IgKnNiLCBzdHJ1Y3QgY2FjaGVfc2JfZGlzayAq c2JfZGlzaywKIAljYS0+YmRldi0+YmRfaG9sZGVyID0gY2E7CiAJY2EtPnNiX2Rpc2sgPSBzYl9k aXNrOwogCi0JaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSkKKwlp ZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKChiZGV2KSkpCiAJCWNhLT5kaXNjYXJkID0gQ0FD SEVfRElTQ0FSRCgmY2EtPnNiKTsKIAogCXJldCA9IGNhY2hlX2FsbG9jKGNhKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWQvYmNhY2hlL3N5c2ZzLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zeXNmcy5j CmluZGV4IGQxMDI5ZDcxZmYzYmMuLmM2ZjY3NzA1OTIxNGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWQvYmNhY2hlL3N5c2ZzLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3lzZnMuYwpAQCAtMTE1 MSw3ICsxMTUxLDcgQEAgU1RPUkUoX19iY2hfY2FjaGUpCiAJaWYgKGF0dHIgPT0gJnN5c2ZzX2Rp c2NhcmQpIHsKIAkJYm9vbCB2ID0gc3RydG91bF9vcl9yZXR1cm4oYnVmKTsKIAotCQlpZiAoYmxr X3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoY2EtPmJkZXYpKSkKKwkJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhjYS0+YmRldikpCiAJCQljYS0+ZGlzY2FyZCA9IHY7CiAKIAkJaWYg KHYgIT0gQ0FDSEVfRElTQ0FSRCgmY2EtPnNiKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9k bS1jYWNoZS10YXJnZXQuYyBiL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMKaW5kZXggNzgw YTYxYmM2Y2MwMy4uMjhjNWRlOGVjYTRhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1jYWNo ZS10YXJnZXQuYworKysgYi9kcml2ZXJzL21kL2RtLWNhY2hlLXRhcmdldC5jCkBAIC0zMzI5LDEz ICszMzI5LDYgQEAgc3RhdGljIGludCBjYWNoZV9pdGVyYXRlX2RldmljZXMoc3RydWN0IGRtX3Rh cmdldCAqdGksCiAJcmV0dXJuIHI7CiB9CiAKLXN0YXRpYyBib29sIG9yaWdpbl9kZXZfc3VwcG9y dHNfZGlzY2FyZChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpvcmlnaW5fYmRldikKLXsKLQlzdHJ1Y3Qg cmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKG9yaWdpbl9iZGV2KTsKLQotCXJldHVy biBibGtfcXVldWVfZGlzY2FyZChxKTsKLX0KLQogLyoKICAqIElmIGRpc2NhcmRfcGFzc2Rvd24g d2FzIGVuYWJsZWQgdmVyaWZ5IHRoYXQgdGhlIG9yaWdpbiBkZXZpY2UKICAqIHN1cHBvcnRzIGRp c2NhcmRzLiAgRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlmIG5vdC4KQEAgLTMzNDksNyArMzM0 Miw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25faWZfbm90X3N1cHBvcnRlZChzdHJ1 Y3QgY2FjaGUgKmNhY2hlKQogCWlmICghY2FjaGUtPmZlYXR1cmVzLmRpc2NhcmRfcGFzc2Rvd24p CiAJCXJldHVybjsKIAotCWlmICghb3JpZ2luX2Rldl9zdXBwb3J0c19kaXNjYXJkKG9yaWdpbl9i ZGV2KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhvcmlnaW5fYmRldikpCiAJCXJl YXNvbiA9ICJkaXNjYXJkIHVuc3VwcG9ydGVkIjsKIAogCWVsc2UgaWYgKG9yaWdpbl9saW1pdHMt Pm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjYWNoZS0+c2VjdG9yc19wZXJfYmxvY2spCmRpZmYgLS1n aXQgYS9kcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jIGIvZHJpdmVycy9tZC9kbS1jbG9uZS10 YXJnZXQuYwppbmRleCAxMjgzMTZhNzNkMDE2Li44MTFiMGE1Mzc5ZDAzIDEwMDY0NAotLS0gYS9k cml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tY2xvbmUtdGFy Z2V0LmMKQEAgLTIwMTYsMTMgKzIwMTYsNiBAQCBzdGF0aWMgdm9pZCBjbG9uZV9yZXN1bWUoc3Ry dWN0IGRtX3RhcmdldCAqdGkpCiAJZG9fd2FrZXIoJmNsb25lLT53YWtlci53b3JrKTsKIH0KIAot c3RhdGljIGJvb2wgYmRldl9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2KQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoYmRldik7 Ci0KLQlyZXR1cm4gKHEgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQocSkpOwotfQotCiAvKgogICogSWYg ZGlzY2FyZF9wYXNzZG93biB3YXMgZW5hYmxlZCB2ZXJpZnkgdGhhdCB0aGUgZGVzdGluYXRpb24g ZGV2aWNlIHN1cHBvcnRzCiAgKiBkaXNjYXJkcy4gRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlm IG5vdC4KQEAgLTIwMzYsNyArMjAyOSw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25f aWZfbm90X3N1cHBvcnRlZChzdHJ1Y3QgY2xvbmUgKmNsb25lKQogCWlmICghdGVzdF9iaXQoRE1f Q0xPTkVfRElTQ0FSRF9QQVNTRE9XTiwgJmNsb25lLT5mbGFncykpCiAJCXJldHVybjsKIAotCWlm ICghYmRldl9zdXBwb3J0c19kaXNjYXJkcyhkZXN0X2RldikpCisJaWYgKCFiZGV2X21heF9kaXNj YXJkX3NlY3RvcnMoZGVzdF9kZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAJZWxzZSBpZiAoZGVzdF9saW1pdHMtPm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjbG9uZS0+cmVn aW9uX3NpemUpCiAJCXJlYXNvbiA9ICJtYXggZGlzY2FyZCBzZWN0b3JzIHNtYWxsZXIgdGhhbiBh IHJlZ2lvbiI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy13cml0ZXMuYyBiL2RyaXZl cnMvbWQvZG0tbG9nLXdyaXRlcy5jCmluZGV4IGM5ZDAzNmQ2YmIyZWUuLmUxOTQyMjZjODllNTQg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tbG9nLXdyaXRlcy5jCisrKyBiL2RyaXZlcnMvbWQv ZG0tbG9nLXdyaXRlcy5jCkBAIC04NjYsOSArODY2LDggQEAgc3RhdGljIGludCBsb2dfd3JpdGVz X21lc3NhZ2Uoc3RydWN0IGRtX3RhcmdldCAqdGksIHVuc2lnbmVkIGFyZ2MsIGNoYXIgKiphcmd2 LAogc3RhdGljIHZvaWQgbG9nX3dyaXRlc19pb19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRzKQogewogCXN0cnVjdCBsb2dfd3JpdGVzX2MgKmxj ID0gdGktPnByaXZhdGU7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1 ZShsYy0+ZGV2LT5iZGV2KTsKIAotCWlmICghcSB8fCAhYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsK KwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhsYy0+ZGV2LT5iZGV2KSkgewogCQlsYy0+ ZGV2aWNlX3N1cHBvcnRzX2Rpc2NhcmQgPSBmYWxzZTsKIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51 bGFyaXR5ID0gbGMtPnNlY3RvcnNpemU7CiAJCWxpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA9 IChVSU5UX01BWCA+PiBTRUNUT1JfU0hJRlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1y YWlkLmMgYi9kcml2ZXJzL21kL2RtLXJhaWQuYwppbmRleCAyYjI2NDM1YTY5NDZlLi45NTI2Y2Ni ZWRhZmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXJhaWQuYworKysgYi9kcml2ZXJzL21k L2RtLXJhaWQuYwpAQCAtMjk2MywxMyArMjk2Myw4IEBAIHN0YXRpYyB2b2lkIGNvbmZpZ3VyZV9k aXNjYXJkX3N1cHBvcnQoc3RydWN0IHJhaWRfc2V0ICpycykKIAlyYWlkNDU2ID0gcnNfaXNfcmFp ZDQ1Nihycyk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcnMtPnJhaWRfZGlza3M7IGkrKykgewotCQlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcTsKLQotCQlpZiAoIXJzLT5kZXZbaV0ucmRldi5iZGV2KQot CQkJY29udGludWU7Ci0KLQkJcSA9IGJkZXZfZ2V0X3F1ZXVlKHJzLT5kZXZbaV0ucmRldi5iZGV2 KTsKLQkJaWYgKCFxIHx8ICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwkJaWYgKCFycy0+ZGV2W2ld LnJkZXYuYmRldiB8fAorCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhycy0+ZGV2W2ld LnJkZXYuYmRldikpCiAJCQlyZXR1cm47CiAKIAkJaWYgKHJhaWQ0NTYpIHsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWQvZG0tdGFibGUuYyBiL2RyaXZlcnMvbWQvZG0tdGFibGUuYwppbmRleCBkNDY4 MzlmYWEwY2E1Li4wZGZmNjkwN2ZkMDBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXRhYmxl LmMKKysrIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCkBAIC0xODg4LDkgKzE4ODgsNyBAQCBzdGF0 aWMgYm9vbCBkbV90YWJsZV9zdXBwb3J0c19ub3dhaXQoc3RydWN0IGRtX3RhYmxlICp0KQogc3Rh dGljIGludCBkZXZpY2Vfbm90X2Rpc2NhcmRfY2FwYWJsZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IGRtX2RldiAqZGV2LAogCQkJCSAgICAgIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBs ZW4sIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9x dWV1ZShkZXYtPmJkZXYpOwotCi0JcmV0dXJuICFibGtfcXVldWVfZGlzY2FyZChxKTsKKwlyZXR1 cm4gIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPmJkZXYpOwogfQogCiBzdGF0aWMgYm9v bCBkbV90YWJsZV9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgZG1fdGFibGUgKnQpCkBAIC0xOTcw LDE1ICsxOTY4LDEyIEBAIGludCBkbV90YWJsZV9zZXRfcmVzdHJpY3Rpb25zKHN0cnVjdCBkbV90 YWJsZSAqdCwgc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsCiAJCWJsa19xdWV1ZV9mbGFnX2NsZWFy KFFVRVVFX0ZMQUdfTk9XQUlULCBxKTsKIAogCWlmICghZG1fdGFibGVfc3VwcG9ydHNfZGlzY2Fy ZHModCkpIHsKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsK LQkJLyogTXVzdCBhbHNvIGNsZWFyIGRpc2NhcmQgbGltaXRzLi4uICovCiAJCXEtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzID0gMDsKIAkJcS0+bGltaXRzLm1heF9od19kaXNjYXJkX3NlY3Rv cnMgPSAwOwogCQlxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IDA7CiAJCXEtPmxpbWl0 cy5kaXNjYXJkX2FsaWdubWVudCA9IDA7CiAJCXEtPmxpbWl0cy5kaXNjYXJkX21pc2FsaWduZWQg PSAwOwotCX0gZWxzZQotCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBx KTsKKwl9CiAKIAlpZiAoZG1fdGFibGVfc3VwcG9ydHNfc2VjdXJlX2VyYXNlKHQpKQogCQlibGtf cXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19TRUNFUkFTRSwgcSk7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kL2RtLXRoaW4uYyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCmluZGV4IDRkMjVkMGUyNzAz MTMuLmVkZWQ0YmNjNDU0NWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGhpbi5jCisrKyBi L2RyaXZlcnMvbWQvZG0tdGhpbi5jCkBAIC0yODAyLDEzICsyODAyLDYgQEAgc3RhdGljIHZvaWQg cmVxdWV1ZV9iaW9zKHN0cnVjdCBwb29sICpwb29sKQogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBCaW5kaW5nIG9m IGNvbnRyb2wgdGFyZ2V0cyB0byBhIHBvb2wgb2JqZWN0CiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLXN0YXRpYyBib29s IGRhdGFfZGV2X3N1cHBvcnRzX2Rpc2NhcmQoc3RydWN0IHBvb2xfYyAqcHQpCi17Ci0Jc3RydWN0 IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShwdC0+ZGF0YV9kZXYtPmJkZXYpOwot Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKHEpOwotfQotCiBzdGF0aWMgYm9vbCBpc19mYWN0 b3Ioc2VjdG9yX3QgYmxvY2tfc2l6ZSwgdWludDMyX3QgbikKIHsKIAlyZXR1cm4gIXNlY3Rvcl9k aXYoYmxvY2tfc2l6ZSwgbik7CkBAIC0yODI4LDcgKzI4MjEsNyBAQCBzdGF0aWMgdm9pZCBkaXNh YmxlX3Bhc3Nkb3duX2lmX25vdF9zdXBwb3J0ZWQoc3RydWN0IHBvb2xfYyAqcHQpCiAJaWYgKCFw dC0+YWRqdXN0ZWRfcGYuZGlzY2FyZF9wYXNzZG93bikKIAkJcmV0dXJuOwogCi0JaWYgKCFkYXRh X2Rldl9zdXBwb3J0c19kaXNjYXJkKHB0KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhwdC0+ZGF0YV9kZXYtPmJkZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAKIAllbHNlIGlmIChkYXRhX2xpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA8IHBvb2wtPnNl Y3RvcnNfcGVyX2Jsb2NrKQpAQCAtNDA1Nyw4ICs0MDUwLDYgQEAgc3RhdGljIHZvaWQgcG9vbF9p b19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgc3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRz KQogCQkvKgogCQkgKiBNdXN0IGV4cGxpY2l0bHkgZGlzYWxsb3cgc3RhY2tpbmcgZGlzY2FyZCBs aW1pdHMgb3RoZXJ3aXNlIHRoZQogCQkgKiBibG9jayBsYXllciB3aWxsIHN0YWNrIHRoZW0gaWYg cG9vbCdzIGRhdGEgZGV2aWNlIGhhcyBzdXBwb3J0LgotCQkgKiBRVUVVRV9GTEFHX0RJU0NBUkQg d291bGRuJ3QgYmUgc2V0IGJ1dCB0aGVyZSBpcyBubyB3YXkgZm9yIHRoZQotCQkgKiB1c2VyIHRv IHNlZSB0aGF0LCBzbyBtYWtlIHN1cmUgdG8gc2V0IGFsbCBkaXNjYXJkIGxpbWl0cyB0byAwLgog CQkgKi8KIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJcmV0dXJuOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9tZC9kbS5jIGIvZHJpdmVycy9tZC9kbS5jCmluZGV4IDNjNWZhZDdj NGVlNjguLmRiYmY2NGNlN2U5MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0uYworKysgYi9k cml2ZXJzL21kL2RtLmMKQEAgLTk1NSw3ICs5NTUsNiBAQCB2b2lkIGRpc2FibGVfZGlzY2FyZChz dHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCiAKIAkvKiBkZXZpY2UgZG9lc24ndCByZWFsbHkgc3Vw cG9ydCBESVNDQVJELCBkaXNhYmxlIGl0ICovCiAJbGltaXRzLT5tYXhfZGlzY2FyZF9zZWN0b3Jz ID0gMDsKLQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIG1kLT5xdWV1 ZSk7CiB9CiAKIHZvaWQgZGlzYWJsZV93cml0ZV96ZXJvZXMoc3RydWN0IG1hcHBlZF9kZXZpY2Ug Km1kKQpAQCAtOTgyLDcgKzk4MSw3IEBAIHN0YXRpYyB2b2lkIGNsb25lX2VuZGlvKHN0cnVjdCBi aW8gKmJpbykKIAogCWlmICh1bmxpa2VseShlcnJvciA9PSBCTEtfU1RTX1RBUkdFVCkpIHsKIAkJ aWYgKGJpb19vcChiaW8pID09IFJFUV9PUF9ESVNDQVJEICYmCi0JCSAgICAhcS0+bGltaXRzLm1h eF9kaXNjYXJkX3NlY3RvcnMpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+ YmlfYmRldikpCiAJCQlkaXNhYmxlX2Rpc2NhcmQobWQpOwogCQllbHNlIGlmIChiaW9fb3AoYmlv KSA9PSBSRVFfT1BfV1JJVEVfWkVST0VTICYmCiAJCQkgIXEtPmxpbWl0cy5tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLWxpbmVhci5jIGIvZHJpdmVy cy9tZC9tZC1saW5lYXIuYwppbmRleCAwZjU1YjA3OTM3MWIxLi4xMzhhM2IyNWM1YzgyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kL21kLWxpbmVhci5jCisrKyBiL2RyaXZlcnMvbWQvbWQtbGluZWFy LmMKQEAgLTY0LDcgKzY0LDYgQEAgc3RhdGljIHN0cnVjdCBsaW5lYXJfY29uZiAqbGluZWFyX2Nv bmYoc3RydWN0IG1kZGV2ICptZGRldiwgaW50IHJhaWRfZGlza3MpCiAJc3RydWN0IGxpbmVhcl9j b25mICpjb25mOwogCXN0cnVjdCBtZF9yZGV2ICpyZGV2OwogCWludCBpLCBjbnQ7Ci0JYm9vbCBk aXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJY29uZiA9IGt6YWxsb2Moc3RydWN0X3NpemUo Y29uZiwgZGlza3MsIHJhaWRfZGlza3MpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWNvbmYpCkBAIC05 Niw5ICs5NSw2IEBAIHN0YXRpYyBzdHJ1Y3QgbGluZWFyX2NvbmYgKmxpbmVhcl9jb25mKHN0cnVj dCBtZGRldiAqbWRkZXYsIGludCByYWlkX2Rpc2tzKQogCiAJCWNvbmYtPmFycmF5X3NlY3RvcnMg Kz0gcmRldi0+c2VjdG9yczsKIAkJY250Kys7Ci0KLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJk ZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsK IAl9CiAJaWYgKGNudCAhPSByYWlkX2Rpc2tzKSB7CiAJCXByX3dhcm4oIm1kL2xpbmVhcjolczog bm90IGVub3VnaCBkcml2ZXMgcHJlc2VudC4gQWJvcnRpbmchXG4iLApAQCAtMTA2LDExICsxMDIs NiBAQCBzdGF0aWMgc3RydWN0IGxpbmVhcl9jb25mICpsaW5lYXJfY29uZihzdHJ1Y3QgbWRkZXYg Km1kZGV2LCBpbnQgcmFpZF9kaXNrcykKIAkJZ290byBvdXQ7CiAJfQogCi0JaWYgKCFkaXNjYXJk X3N1cHBvcnRlZCkKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBt ZGRldi0+cXVldWUpOwotCWVsc2UKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElT Q0FSRCwgbWRkZXYtPnF1ZXVlKTsKLQogCS8qCiAJICogSGVyZSB3ZSBjYWxjdWxhdGUgdGhlIGRl dmljZSBvZmZzZXRzLgogCSAqLwpAQCAtMjUyLDcgKzI0Myw3IEBAIHN0YXRpYyBib29sIGxpbmVh cl9tYWtlX3JlcXVlc3Qoc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IGJpbyAqYmlvKQogCQlz dGFydF9zZWN0b3IgKyBkYXRhX29mZnNldDsKIAogCWlmICh1bmxpa2VseSgoYmlvX29wKGJpbykg PT0gUkVRX09QX0RJU0NBUkQpICYmCi0JCSAgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkgeworCQkgICAgICFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoYmlvLT5iaV9iZGV2KSkpIHsKIAkJLyogSnVzdCBpZ25vcmUgaXQgKi8KIAkJYmlvX2VuZGlv KGJpbyk7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDAuYyBiL2RyaXZl cnMvbWQvcmFpZDAuYwppbmRleCBiMjFlMTAxMTgzZjQ0Li43MjMxZjVlMWVhYTczIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQwLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMC5jCkBAIC0zOTks NyArMzk5LDYgQEAgc3RhdGljIGludCByYWlkMF9ydW4oc3RydWN0IG1kZGV2ICptZGRldikKIAlj b25mID0gbWRkZXYtPnByaXZhdGU7CiAJaWYgKG1kZGV2LT5xdWV1ZSkgewogCQlzdHJ1Y3QgbWRf cmRldiAqcmRldjsKLQkJYm9vbCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJCWJsa19x dWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2LT5jaHVua19zZWN0b3JzKTsK IAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2 LT5jaHVua19zZWN0b3JzKTsKQEAgLTQxMiwxMyArNDExLDcgQEAgc3RhdGljIGludCByYWlkMF9y dW4oc3RydWN0IG1kZGV2ICptZGRldikKIAkJcmRldl9mb3JfZWFjaChyZGV2LCBtZGRldikgewog CQkJZGlza19zdGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJCSAg cmRldi0+ZGF0YV9vZmZzZXQgPDwgOSk7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUocmRldi0+YmRldikpKQotCQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJ fQotCQlpZiAoIWRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVF VUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwotCQllbHNlCi0JCQlibGtfcXVldWVfZmxh Z19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCX0KIAogCS8qIGNhbGN1 bGF0ZSBhcnJheSBkZXZpY2Ugc2l6ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkMS5j IGIvZHJpdmVycy9tZC9yYWlkMS5jCmluZGV4IGQ4MWI4OTY4NTVmOWYuLjNkYTc0OWQxNTBhMTcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDEuYworKysgYi9kcml2ZXJzL21kL3JhaWQxLmMK QEAgLTgwMiw3ICs4MDIsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9iaW9fbGlzdChzdHJ1Y3QgcjFj b25mICpjb25mLCBzdHJ1Y3QgYmlvICpiaW8pCiAJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2 LT5mbGFncykpIHsKIAkJCWJpb19pb19lcnJvcihiaW8pOwogCQl9IGVsc2UgaWYgKHVubGlrZWx5 KChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9k aXNjYXJkKGJpby0+YmlfYmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICov CiAJCQliaW9fZW5kaW8oYmlvKTsKIAkJZWxzZQpAQCAtMTgyNiw4ICsxODI2LDYgQEAgc3RhdGlj IGludCByYWlkMV9hZGRfZGlzayhzdHJ1Y3QgbWRkZXYgKm1kZGV2LCBzdHJ1Y3QgbWRfcmRldiAq cmRldikKIAkJCWJyZWFrOwogCQl9CiAJfQotCWlmIChtZGRldi0+cXVldWUgJiYgYmxrX3F1ZXVl X2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQotCQlibGtfcXVldWVfZmxhZ19z ZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCXByaW50X2NvbmYoY29uZik7 CiAJcmV0dXJuIGVycjsKIH0KQEAgLTMxMDYsNyArMzEwNCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFf cnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJaW50IGk7CiAJc3RydWN0IG1kX3JkZXYgKnJkZXY7 CiAJaW50IHJldDsKLQlib29sIGRpc2NhcmRfc3VwcG9ydGVkID0gZmFsc2U7CiAKIAlpZiAobWRk ZXYtPmxldmVsICE9IDEpIHsKIAkJcHJfd2FybigibWQvcmFpZDE6JXM6IHJhaWQgbGV2ZWwgbm90 IHNldCB0byBtaXJyb3JpbmcgKCVkKVxuIiwKQEAgLTMxNDEsOCArMzEzOCw2IEBAIHN0YXRpYyBp bnQgcmFpZDFfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQljb250aW51ZTsKIAkJZGlza19z dGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJICByZGV2LT5kYXRh X29mZnNldCA8PCA5KTsKLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJk ZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAl9CiAKIAltZGRldi0+ ZGVncmFkZWQgPSAwOwpAQCAtMzE3OSwxNSArMzE3NCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFfcnVu KHN0cnVjdCBtZGRldiAqbWRkZXYpCiAKIAltZF9zZXRfYXJyYXlfc2VjdG9ycyhtZGRldiwgcmFp ZDFfc2l6ZShtZGRldiwgMCwgMCkpOwogCi0JaWYgKG1kZGV2LT5xdWV1ZSkgewotCQlpZiAoZGlz Y2FyZF9zdXBwb3J0ZWQpCi0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJE LAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIo UVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJICBtZGRldi0+cXVldWUpOwotCX0KLQogCXJldCA9 IG1kX2ludGVncml0eV9yZWdpc3RlcihtZGRldik7CiAJaWYgKHJldCkgewogCQltZF91bnJlZ2lz dGVyX3RocmVhZCgmbWRkZXYtPnRocmVhZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQx MC5jIGIvZHJpdmVycy9tZC9yYWlkMTAuYwppbmRleCA3ODE2YzhiMmU4MDg3Li4zNmE0NjAwMTVj ZjU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxMC5jCisrKyBiL2RyaXZlcnMvbWQvcmFp ZDEwLmMKQEAgLTg4OCw3ICs4ODgsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9wZW5kaW5nX3dyaXRl cyhzdHJ1Y3QgcjEwY29uZiAqY29uZikKIAkJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5m bGFncykpIHsKIAkJCQliaW9faW9fZXJyb3IoYmlvKTsKIAkJCX0gZWxzZSBpZiAodW5saWtlbHko KGJpb19vcChiaW8pID09ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkJICAgICFibGtfcXVldWVf ZGlzY2FyZChiaW8tPmJpX2JkZXYtPmJkX2Rpc2stPnF1ZXVlKSkpCisJCQkJCSAgICAhYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+YmlfYmRldikpKQogCQkJCS8qIEp1c3QgaWdub3JlIGl0 ICovCiAJCQkJYmlvX2VuZGlvKGJpbyk7CiAJCQllbHNlCkBAIC0xMDgzLDcgKzEwODMsNyBAQCBz dGF0aWMgdm9pZCByYWlkMTBfdW5wbHVnKHN0cnVjdCBibGtfcGx1Z19jYiAqY2IsIGJvb2wgZnJv bV9zY2hlZHVsZSkKIAkJaWYgKHRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkgewogCQkJ YmlvX2lvX2Vycm9yKGJpbyk7CiAJCX0gZWxzZSBpZiAodW5saWtlbHkoKGJpb19vcChiaW8pID09 ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICovCiAJCQliaW9fZW5kaW8o YmlvKTsKIAkJZWxzZQpAQCAtMjE0NCw4ICsyMTQ0LDYgQEAgc3RhdGljIGludCByYWlkMTBfYWRk X2Rpc2soc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IG1kX3JkZXYgKnJkZXYpCiAJCXJjdV9h c3NpZ25fcG9pbnRlcihwLT5yZGV2LCByZGV2KTsKIAkJYnJlYWs7CiAJfQotCWlmIChtZGRldi0+ cXVldWUgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQot CQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwog CiAJcHJpbnRfY29uZihjb25mKTsKIAlyZXR1cm4gZXJyOwpAQCAtNDA2OSw3ICs0MDY3LDYgQEAg c3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJc2VjdG9yX3Qgc2l6 ZTsKIAlzZWN0b3JfdCBtaW5fb2Zmc2V0X2RpZmYgPSAwOwogCWludCBmaXJzdCA9IDE7Ci0JYm9v bCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJaWYgKG1kZGV2X2luaXRfd3JpdGVzX3Bl bmRpbmcobWRkZXYpIDwgMCkKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC00MTQwLDIwICs0MTM3LDkg QEAgc3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQkJCSAgcmRl di0+ZGF0YV9vZmZzZXQgPDwgOSk7CiAKIAkJZGlzay0+aGVhZF9wb3NpdGlvbiA9IDA7Ci0KLQkJ aWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRp c2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJZmlyc3QgPSAwOwogCX0KIAotCWlmIChtZGRldi0+ cXVldWUpIHsKLQkJaWYgKGRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCW1kZGV2LT5xdWV1ZSk7Ci0JCWVsc2UKLQkJCWJs a19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCSAgbWRkZXYtPnF1 ZXVlKTsKLQl9CiAJLyogbmVlZCB0byBjaGVjayB0aGF0IGV2ZXJ5IGJsb2NrIGhhcyBhdCBsZWFz dCBvbmUgd29ya2luZyBtaXJyb3IgKi8KIAlpZiAoIWVub3VnaChjb25mLCAtMSkpIHsKIAkJcHJf ZXJyKCJtZC9yYWlkMTA6JXM6IG5vdCBlbm91Z2ggb3BlcmF0aW9uYWwgbWlycm9ycy5cbiIsCmRp ZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQ1LWNhY2hlLmMgYi9kcml2ZXJzL21kL3JhaWQ1LWNh Y2hlLmMKaW5kZXggYTdkNTBmZjkwMjBhOC4uYzNjYmY5YTU3NGEzOSAxMDA2NDQKLS0tIGEvZHJp dmVycy9tZC9yYWlkNS1jYWNoZS5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDUtY2FjaGUuYwpAQCAt MTMxOCw3ICsxMzE4LDcgQEAgc3RhdGljIHZvaWQgcjVsX3dyaXRlX3N1cGVyX2FuZF9kaXNjYXJk X3NwYWNlKHN0cnVjdCByNWxfbG9nICpsb2csCiAKIAlyNWxfd3JpdGVfc3VwZXIobG9nLCBlbmQp OwogCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShiZGV2KSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCXJldHVybjsKIAogCW1kZGV2ID0g bG9nLT5yZGV2LT5tZGRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDUuYyBiL2RyaXZl cnMvbWQvcmFpZDUuYwppbmRleCAwYmJhZTBlNjM4NjY2Li41OWY5MWUzOTJhMmFlIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQ1LmMKKysrIGIvZHJpdmVycy9tZC9yYWlkNS5jCkBAIC03Nzc2 LDE0ICs3Nzc2LDEwIEBAIHN0YXRpYyBpbnQgcmFpZDVfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYp CiAJCSAqIEEgYmV0dGVyIGlkZWEgbWlnaHQgYmUgdG8gdHVybiBESVNDQVJEIGludG8gV1JJVEVf WkVST0VTCiAJCSAqIHJlcXVlc3RzLCBhcyB0aGF0IGlzIHJlcXVpcmVkIHRvIGJlIHNhZmUuCiAJ CSAqLwotCQlpZiAoZGV2aWNlc19oYW5kbGVfZGlzY2FyZF9zYWZlbHkgJiYKLQkJICAgIG1kZGV2 LT5xdWV1ZS0+bGltaXRzLm1heF9kaXNjYXJkX3NlY3RvcnMgPj0gKHN0cmlwZSA+PiA5KSAmJgot CQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA+PSBzdHJpcGUp Ci0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJbWRkZXYt PnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVND QVJELAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKKwkJaWYgKCFkZXZpY2VzX2hhbmRsZV9kaXNjYXJk X3NhZmVseSB8fAorCQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9y cyA8IChzdHJpcGUgPj4gOSkgfHwKKwkJICAgIG1kZGV2LT5xdWV1ZS0+bGltaXRzLmRpc2NhcmRf Z3JhbnVsYXJpdHkgPCBzdHJpcGUpCisJCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyht ZGRldi0+cXVldWUsIDApOwogCiAJCWJsa19xdWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVl dWUsIFVJTlRfTUFYKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMg Yi9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMKaW5kZXggYzY5YjJkOWRmNmYxNi4uY2FjNjMxNTAx MGEzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9xdWV1ZS5jCisrKyBiL2RyaXZlcnMv bW1jL2NvcmUvcXVldWUuYwpAQCAtMTgzLDcgKzE4Myw2IEBAIHN0YXRpYyB2b2lkIG1tY19xdWV1 ZV9zZXR1cF9kaXNjYXJkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLAogCWlmICghbWF4X2Rpc2Nh cmQpCiAJCXJldHVybjsKIAotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFHX0RJU0NBUkQs IHEpOwogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIG1heF9kaXNjYXJkKTsKIAlx LT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IGNhcmQtPnByZWZfZXJhc2UgPDwgOTsKIAkv KiBncmFudWxhcml0eSBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gbWF4LiBkaXNjYXJkICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jIGIvZHJpdmVycy9tdGQvbXRkX2Js a2RldnMuYwppbmRleCA2NGQyYjA5M2YxMTRiLi5mNzMxNzIxMTE0NjU1IDEwMDY0NAotLS0gYS9k cml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jCisrKyBiL2RyaXZlcnMvbXRkL210ZF9ibGtkZXZzLmMK QEAgLTM3Nyw3ICszNzcsNiBAQCBpbnQgYWRkX210ZF9ibGt0cmFuc19kZXYoc3RydWN0IG10ZF9i bGt0cmFuc19kZXYgKm5ldykKIAlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0FERF9S QU5ET00sIG5ldy0+cnEpOwogCiAJaWYgKHRyLT5kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFn X3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIG5ldy0+cnEpOwogCQlibGtfcXVldWVfbWF4X2Rpc2Nh cmRfc2VjdG9ycyhuZXctPnJxLCBVSU5UX01BWCk7CiAJCW5ldy0+cnEtPmxpbWl0cy5kaXNjYXJk X2dyYW51bGFyaXR5ID0gdHItPmJsa3NpemU7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l L2hvc3QvY29yZS5jIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCmluZGV4IGVmYjg1YzZkOGUy ZDUuLjdlMDdkZDY5MjYyYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwor KysgYi9kcml2ZXJzL252bWUvaG9zdC9jb3JlLmMKQEAgLTE2MDcsMTAgKzE2MDcsOCBAQCBzdGF0 aWMgdm9pZCBudm1lX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBzdHJ1Y3Qg bnZtZV9ucyAqbnMpCiAJc3RydWN0IHJlcXVlc3RfcXVldWUgKnF1ZXVlID0gZGlzay0+cXVldWU7 CiAJdTMyIHNpemUgPSBxdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUocXVldWUpOwogCi0JaWYgKGN0 cmwtPm1heF9kaXNjYXJkX3NlY3RvcnMgPT0gMCkgewotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKTsKKwlpZiAoY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9y cyA9PSAwKQogCQlyZXR1cm47Ci0JfQogCiAJQlVJTERfQlVHX09OKFBBR0VfU0laRSAvIHNpemVv ZihzdHJ1Y3QgbnZtZV9kc21fcmFuZ2UpIDwKIAkJCU5WTUVfRFNNX01BWF9SQU5HRVMpOwpAQCAt MTYxOSw3ICsxNjE3LDcgQEAgc3RhdGljIHZvaWQgbnZtZV9jb25maWdfZGlzY2FyZChzdHJ1Y3Qg Z2VuZGlzayAqZGlzaywgc3RydWN0IG52bWVfbnMgKm5zKQogCXF1ZXVlLT5saW1pdHMuZGlzY2Fy ZF9ncmFudWxhcml0eSA9IHNpemU7CiAKIAkvKiBJZiBkaXNjYXJkIGlzIGFscmVhZHkgZW5hYmxl ZCwgZG9uJ3QgcmVzZXQgcXVldWUgbGltaXRzICovCi0JaWYgKGJsa19xdWV1ZV9mbGFnX3Rlc3Rf YW5kX3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKSkKKwlpZiAocXVldWUtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzKQogCQlyZXR1cm47CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRf c2VjdG9ycyhxdWV1ZSwgY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9ycyk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3MzOTAvYmxvY2svZGFzZF9mYmEuYyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCmluZGV4IGUwODRmNGRlZGRkZGQuLjhiZDU2NjVkYjkxOTggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvczM5MC9ibG9jay9kYXNkX2ZiYS5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCkBAIC03OTEsNyArNzkxLDYgQEAgc3RhdGljIHZvaWQgZGFzZF9mYmFfc2V0dXBfYmxrX3F1 ZXVlKHN0cnVjdCBkYXNkX2Jsb2NrICpibG9jaykKIAogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9z ZWN0b3JzKHEsIG1heF9kaXNjYXJkX3NlY3RvcnMpOwogCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMocSwgbWF4X2Rpc2NhcmRfc2VjdG9ycyk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBpbnQgZGFzZF9mYmFfcGVfaGFu ZGxlcihzdHJ1Y3QgZGFzZF9kZXZpY2UgKmRldmljZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2Nz aS9zZC5jIGIvZHJpdmVycy9zY3NpL3NkLmMKaW5kZXggYTM5MDY3OWNmNDU4NC4uNDQ0NDc5NjU3 YjdmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NkLmMKKysrIGIvZHJpdmVycy9zY3NpL3Nk LmMKQEAgLTc5Nyw3ICs3OTcsNiBAQCBzdGF0aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1 Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25lZCBpbnQgbW9kZSkKIAljYXNlIFNEX0xCUF9GVUxM OgogCWNhc2UgU0RfTEJQX0RJU0FCTEU6CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3Jz KHEsIDApOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwog CQlyZXR1cm47CiAKIAljYXNlIFNEX0xCUF9VTk1BUDoKQEAgLTgzMCw3ICs4MjksNiBAQCBzdGF0 aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25l ZCBpbnQgbW9kZSkKIAl9CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCBtYXhf YmxvY2tzICogKGxvZ2ljYWxfYmxvY2tfc2l6ZSA+PiA5KSk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBibGtfc3RhdHVzX3Qgc2Rfc2V0 dXBfdW5tYXBfY21uZChzdHJ1Y3Qgc2NzaV9jbW5kICpjbWQpCmRpZmYgLS1naXQgYS9kcml2ZXJz L3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3Jl X2RldmljZS5jCmluZGV4IGMzZTI1YmFjOTBkNTkuLjZjYjlmODc4NDMyNzggMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0 L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC04MzgsNyArODM4LDcgQEAgYm9vbCB0YXJnZXRfY29u ZmlndXJlX3VubWFwX2Zyb21fcXVldWUoc3RydWN0IHNlX2Rldl9hdHRyaWIgKmF0dHJpYiwKIAlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwogCWludCBibG9j a19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmRldik7CiAKLQlpZiAoIWJsa19xdWV1 ZV9kaXNjYXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQly ZXR1cm4gZmFsc2U7CiAKIAlhdHRyaWItPm1heF91bm1hcF9sYmFfY291bnQgPQpkaWZmIC0tZ2l0 IGEvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKaW5kZXgg ZjQ3NzAzNWEyYWMyMy4uZWZkOGRlYjNhYjdlOCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50 LXRyZWUuYworKysgYi9mcy9idHJmcy9leHRlbnQtdHJlZS5jCkBAIC0xMjkxLDcgKzEyOTEsNyBA QCBzdGF0aWMgaW50IGRvX2Rpc2NhcmRfZXh0ZW50KHN0cnVjdCBidHJmc19pb19zdHJpcGUgKnN0 cmlwZSwgdTY0ICpieXRlcykKIAkJcmV0ID0gYnRyZnNfcmVzZXRfZGV2aWNlX3pvbmUoZGV2X3Jl cGxhY2UtPnRndGRldiwgcGh5cywgbGVuLAogCQkJCQkgICAgICAmZGlzY2FyZGVkKTsKIAkJZGlz Y2FyZGVkICs9IHNyY19kaXNjOwotCX0gZWxzZSBpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUoc3RyaXBlLT5kZXYtPmJkZXYpKSkgeworCX0gZWxzZSBpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHN0cmlwZS0+ZGV2LT5iZGV2KSkgewogCQlyZXQgPSBidHJmc19pc3N1ZV9k aXNjYXJkKGRldi0+YmRldiwgcGh5cywgbGVuLCAmZGlzY2FyZGVkKTsKIAl9IGVsc2UgewogCQly ZXQgPSAwOwpAQCAtNTk4Nyw3ICs1OTg3LDcgQEAgc3RhdGljIGludCBidHJmc190cmltX2ZyZWVf ZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2UsIHU2NCAqdHJpbW1lZCkKIAkqdHJp bW1lZCA9IDA7CiAKIAkvKiBEaXNjYXJkIG5vdCBzdXBwb3J0ZWQgPSBub3RoaW5nIHRvIGRvLiAq LwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoZGV2aWNlLT5iZGV2KSkp CisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGV2aWNlLT5iZGV2KSkKIAkJcmV0dXJu IDA7CiAKIAkvKiBOb3Qgd3JpdGFibGUgPSBub3RoaW5nIHRvIGRvLiAqLwpkaWZmIC0tZ2l0IGEv ZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggZjQ2ZTcxMDYxOTQyZC4u MDk2YmIwZGEwM2YxYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJm cy9pb2N0bC5jCkBAIC01MDEsNyArNTAxLDcgQEAgc3RhdGljIG5vaW5saW5lIGludCBidHJmc19p b2N0bF9maXRyaW0oc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8sCiAJCWlmICghZGV2aWNl LT5iZGV2KQogCQkJY29udGludWU7CiAJCXEgPSBiZGV2X2dldF9xdWV1ZShkZXZpY2UtPmJkZXYp OwotCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwkJaWYgKGJkZXZfbWF4X2Rpc2NhcmRf c2VjdG9ycyhkZXZpY2UtPmJkZXYpKSB7CiAJCQludW1fZGV2aWNlcysrOwogCQkJbWlubGVuID0g bWluX3QodTY0LCBxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSwKIAkJCQkgICAgIG1pbmxl bik7CmRpZmYgLS1naXQgYS9mcy9leGZhdC9maWxlLmMgYi9mcy9leGZhdC9maWxlLmMKaW5kZXgg MmY1MTMwMDU5MjM2Ni4uNzY1ZTRmNjNkZDE4ZCAxMDA2NDQKLS0tIGEvZnMvZXhmYXQvZmlsZS5j CisrKyBiL2ZzL2V4ZmF0L2ZpbGUuYwpAQCAtMzU4LDcgKzM1OCw3IEBAIHN0YXRpYyBpbnQgZXhm YXRfaW9jdGxfZml0cmltKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHVuc2lnbmVkIGxvbmcgYXJnKQog CWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0dXJuIC1FUEVSTTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoaW5v ZGUtPmlfc2ItPnNfYmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zy b21fdXNlcigmcmFuZ2UsIChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZywgc2l6ZW9m KHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy9leGZhdC9zdXBlci5jIGIvZnMvZXhmYXQvc3VwZXIu YwppbmRleCA4Y2EyMWU3OTE3ZDE2Li5iZTA3ODhlY2FmMjBlIDEwMDY0NAotLS0gYS9mcy9leGZh dC9zdXBlci5jCisrKyBiL2ZzL2V4ZmF0L3N1cGVyLmMKQEAgLTYyNywxMyArNjI3LDkgQEAgc3Rh dGljIGludCBleGZhdF9maWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBm c19jb250ZXh0ICpmYykKIAlpZiAob3B0cy0+YWxsb3dfdXRpbWUgPT0gKHVuc2lnbmVkIHNob3J0 KS0xKQogCQlvcHRzLT5hbGxvd191dGltZSA9IH5vcHRzLT5mc19kbWFzayAmIDAwMjI7CiAKLQlp ZiAob3B0cy0+ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0 X3F1ZXVlKHNiLT5zX2JkZXYpOwotCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJ CWV4ZmF0X3dhcm4oc2IsICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRo ZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JCQlvcHRzLT5kaXNjYXJkID0g MDsKLQkJfQorCWlmIChvcHRzLT5kaXNjYXJkICYmICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMo c2ItPnNfYmRldikpIHsKKwkJZXhmYXRfd2FybihzYiwgIm1vdW50aW5nIHdpdGggXCJkaXNjYXJk XCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2NhcmQiKTsKKwkJ b3B0cy0+ZGlzY2FyZCA9IDA7CiAJfQogCiAJc2ItPnNfZmxhZ3MgfD0gU0JfTk9ESVJBVElNRTsK ZGlmZiAtLWdpdCBhL2ZzL2V4dDQvaW9jdGwuYyBiL2ZzL2V4dDQvaW9jdGwuYwppbmRleCA5OTIy MjljYTJkODMwLi42ZTNiOWVlYTEyNmY0IDEwMDY0NAotLS0gYS9mcy9leHQ0L2lvY3RsLmMKKysr IGIvZnMvZXh0NC9pb2N0bC5jCkBAIC0xMDQ0LDcgKzEwNDQsNiBAQCBzdGF0aWMgaW50IGV4dDRf aW9jdGxfY2hlY2twb2ludChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJ X191MzIgZmxhZ3MgPSAwOwogCXVuc2lnbmVkIGludCBmbHVzaF9mbGFncyA9IDA7CiAJc3RydWN0 IHN1cGVyX2Jsb2NrICpzYiA9IGZpbGVfaW5vZGUoZmlscCktPmlfc2I7Ci0Jc3RydWN0IHJlcXVl c3RfcXVldWUgKnE7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIoJmZsYWdzLCAoX191MzIgX191c2Vy ICopYXJnLAogCQkJCXNpemVvZihfX3UzMikpKQpAQCAtMTA2NSwxMCArMTA2NCw4IEBAIHN0YXRp YyBpbnQgZXh0NF9pb2N0bF9jaGVja3BvaW50KHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBs b25nIGFyZykKIAlpZiAoZmxhZ3MgJiB+RVhUNF9JT0NfQ0hFQ0tQT0lOVF9GTEFHX1ZBTElEKQog CQlyZXR1cm4gLUVJTlZBTDsKIAotCXEgPSBiZGV2X2dldF9xdWV1ZShFWFQ0X1NCKHNiKS0+c19q b3VybmFsLT5qX2Rldik7Ci0JaWYgKCFxKQotCQlyZXR1cm4gLUVOWElPOwotCWlmICgoZmxhZ3Mg JiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYgIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQor CWlmICgoZmxhZ3MgJiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYKKwkgICAgIWJkZXZf bWF4X2Rpc2NhcmRfc2VjdG9ycyhFWFQ0X1NCKHNiKS0+c19qb3VybmFsLT5qX2RldikpCiAJCXJl dHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChmbGFncyAmIEVYVDRfSU9DX0NIRUNLUE9JTlRfRkxB R19EUllfUlVOKQpAQCAtMTM5MywxNCArMTM5MCwxMyBAQCBzdGF0aWMgbG9uZyBfX2V4dDRfaW9j dGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJn KQogCiAJY2FzZSBGSVRSSU06CiAJewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZf Z2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQlzdHJ1Y3QgZnN0cmltX3JhbmdlIHJhbmdlOwogCQlp bnQgcmV0ID0gMDsKIAogCQlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCQlyZXR1cm4g LUVQRVJNOwogCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCWlmICghYmRldl9tYXhf ZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCiAJ CS8qCmRpZmYgLS1naXQgYS9mcy9leHQ0L3N1cGVyLmMgYi9mcy9leHQ0L3N1cGVyLmMKaW5kZXgg ODE3NDllYWRkZjRjMS4uOTNmNGU0ZTllMjYzMSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9zdXBlci5j CisrKyBiL2ZzL2V4dDQvc3VwZXIuYwpAQCAtNTQ1OCwxMyArNTQ1OCw5IEBAIHN0YXRpYyBpbnQg X19leHQ0X2ZpbGxfc3VwZXIoc3RydWN0IGZzX2NvbnRleHQgKmZjLCBzdHJ1Y3Qgc3VwZXJfYmxv Y2sgKnNiKQogCQkJZ290byBmYWlsZWRfbW91bnQ5OwogCX0KIAotCWlmICh0ZXN0X29wdChzYiwg RElTQ0FSRCkpIHsKLQkJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShz Yi0+c19iZGV2KTsKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJCWV4dDRfbXNnKHNi LCBLRVJOX1dBUk5JTkcsCi0JCQkJICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwg YnV0ICIKLQkJCQkgInRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JfQor CWlmICh0ZXN0X29wdChzYiwgRElTQ0FSRCkgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhz Yi0+c19iZGV2KSkKKwkJZXh0NF9tc2coc2IsIEtFUk5fV0FSTklORywKKwkJCSAibW91bnRpbmcg d2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCB0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQg ZGlzY2FyZCIpOwogCiAJaWYgKGVzLT5zX2Vycm9yX2NvdW50KQogCQltb2RfdGltZXIoJnNiaS0+ c19lcnJfcmVwb3J0LCBqaWZmaWVzICsgMzAwKkhaKTsgLyogNSBtaW51dGVzICovCmRpZmYgLS1n aXQgYS9mcy9mMmZzL2YyZnMuaCBiL2ZzL2YyZnMvZjJmcy5oCmluZGV4IGNkMWU2NWJjZjBiMDQu LjBlYTlhNWZhN2MxZGQgMTAwNjQ0Ci0tLSBhL2ZzL2YyZnMvZjJmcy5oCisrKyBiL2ZzL2YyZnMv ZjJmcy5oCkBAIC00MzgxLDggKzQzODEsNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgZjJmc19od19z aG91bGRfZGlzY2FyZChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkpCiAKIHN0YXRpYyBpbmxpbmUg Ym9vbCBmMmZzX2JkZXZfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYp CiB7Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSB8fAot CSAgICAgICBiZGV2X2lzX3pvbmVkKGJkZXYpOworCXJldHVybiBiZGV2X21heF9kaXNjYXJkX3Nl Y3RvcnMoYmRldikgfHwgYmRldl9pc196b25lZChiZGV2KTsKIH0KIAogc3RhdGljIGlubGluZSBi b29sIGYyZnNfaHdfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSkKZGlm ZiAtLWdpdCBhL2ZzL2ZhdC9maWxlLmMgYi9mcy9mYXQvZmlsZS5jCmluZGV4IGE1YTMwOWZjYzdm YWYuLmU0YzdkMTBlODAxMjkgMTAwNjQ0Ci0tLSBhL2ZzL2ZhdC9maWxlLmMKKysrIGIvZnMvZmF0 L2ZpbGUuYwpAQCAtMTMzLDcgKzEzMyw3IEBAIHN0YXRpYyBpbnQgZmF0X2lvY3RsX2ZpdHJpbShz dHJ1Y3QgaW5vZGUgKmlub2RlLCB1bnNpZ25lZCBsb25nIGFyZykKIAlpZiAoIWNhcGFibGUoQ0FQ X1NZU19BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJk KHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAl1c2VyX3JhbmdlID0gKHN0cnVjdCBmc3RyaW1fcmFuZ2UgX191 c2VyICopYXJnOwpkaWZmIC0tZ2l0IGEvZnMvZmF0L2lub2RlLmMgYi9mcy9mYXQvaW5vZGUuYwpp bmRleCBiZjYwNTFiZGYxZDFkLi4zZDFhZmI5NWE5MjVhIDEwMDY0NAotLS0gYS9mcy9mYXQvaW5v ZGUuYworKysgYi9mcy9mYXQvaW5vZGUuYwpAQCAtMTg3MiwxMyArMTg3Miw5IEBAIGludCBmYXRf ZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpkYXRhLCBpbnQgc2lsZW50 LCBpbnQgaXN2ZmF0LAogCQlnb3RvIG91dF9mYWlsOwogCX0KIAotCWlmIChzYmktPm9wdGlvbnMu ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNi LT5zX2JkZXYpOwotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQotCQkJZmF0X21zZyhzYiwg S0VSTl9XQVJOSU5HLAotCQkJCQkibW91bnRpbmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1 dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCX0KKwlp ZiAoc2JpLT5vcHRpb25zLmRpc2NhcmQgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhzYi0+ c19iZGV2KSkKKwkJZmF0X21zZyhzYiwgS0VSTl9XQVJOSU5HLAorCQkJIm1vdW50aW5nIHdpdGgg XCJkaXNjYXJkXCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2Nh cmQiKTsKIAogCWZhdF9zZXRfc3RhdGUoc2IsIDEsIDApOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0 IGEvZnMvZ2ZzMi9yZ3JwLmMgYi9mcy9nZnMyL3JncnAuYwppbmRleCA4MDFhZDlmNGYyYmVmLi43 ZjIwYWM5MTMzYmM2IDEwMDY0NAotLS0gYS9mcy9nZnMyL3JncnAuYworKysgYi9mcy9nZnMyL3Jn cnAuYwpAQCAtMTQwNSw3ICsxNDA1LDcgQEAgaW50IGdmczJfZml0cmltKHN0cnVjdCBmaWxlICpm aWxwLCB2b2lkIF9fdXNlciAqYXJncCkKIAlpZiAoIXRlc3RfYml0KFNERl9KT1VSTkFMX0xJVkUs ICZzZHAtPnNkX2ZsYWdzKSkKIAkJcmV0dXJuIC1FUk9GUzsKIAotCWlmICghYmxrX3F1ZXVlX2Rp c2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2RwLT5zZF92ZnMtPnNf YmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmciwg YXJncCwgc2l6ZW9mKHIpKSkKZGlmZiAtLWdpdCBhL2ZzL2piZDIvam91cm5hbC5jIGIvZnMvamJk Mi9qb3VybmFsLmMKaW5kZXggZmNhY2FmYTQ1MTBkMS4uMTlkMjI2Y2Q0ZmY0ZCAxMDA2NDQKLS0t IGEvZnMvamJkMi9qb3VybmFsLmMKKysrIGIvZnMvamJkMi9qb3VybmFsLmMKQEAgLTE3NjIsNyAr MTc2Miw2IEBAIHN0YXRpYyBpbnQgX19qYmQyX2pvdXJuYWxfZXJhc2Uoam91cm5hbF90ICpqb3Vy bmFsLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJdW5zaWduZWQgbG9uZyBibG9jaywgbG9nX29mZnNl dDsgLyogbG9naWNhbCAqLwogCXVuc2lnbmVkIGxvbmcgbG9uZyBwaHlzX2Jsb2NrLCBibG9ja19z dGFydCwgYmxvY2tfc3RvcDsgLyogcGh5c2ljYWwgKi8KIAlsb2ZmX3QgYnl0ZV9zdGFydCwgYnl0 ZV9zdG9wLCBieXRlX2NvdW50OwotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRf cXVldWUoam91cm5hbC0+al9kZXYpOwogCiAJLyogZmxhZ3MgbXVzdCBiZSBzZXQgdG8gZWl0aGVy IGRpc2NhcmQgb3IgemVyb291dCAqLwogCWlmICgoZmxhZ3MgJiB+SkJEMl9KT1VSTkFMX0ZMVVNI X1ZBTElEKSB8fCAhZmxhZ3MgfHwKQEAgLTE3NzAsMTAgKzE3NjksOCBAQCBzdGF0aWMgaW50IF9f amJkMl9qb3VybmFsX2VyYXNlKGpvdXJuYWxfdCAqam91cm5hbCwgdW5zaWduZWQgaW50IGZsYWdz KQogCQkJKGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX1pFUk9PVVQpKSkKIAkJcmV0dXJuIC1F SU5WQUw7CiAKLQlpZiAoIXEpCi0JCXJldHVybiAtRU5YSU87Ci0KLQlpZiAoKGZsYWdzICYgSkJE Ml9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwlpZiAo KGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmCisJICAgICFiZGV2X21heF9k aXNjYXJkX3NlY3RvcnMoam91cm5hbC0+al9kZXYpKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAK IAkvKgpkaWZmIC0tZ2l0IGEvZnMvamZzL2lvY3RsLmMgYi9mcy9qZnMvaW9jdGwuYwppbmRleCAw M2E4NDVhYjRmMDA5Li4zNTdhZTZlNWMzNmVjIDEwMDY0NAotLS0gYS9mcy9qZnMvaW9jdGwuYwor KysgYi9mcy9qZnMvaW9jdGwuYwpAQCAtMTE3LDcgKzExNyw3IEBAIGxvbmcgamZzX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIAkJ aWYgKCFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQogCQkJcmV0dXJuIC1FUEVSTTsKIAotCQlpZiAo IWJsa19xdWV1ZV9kaXNjYXJkKHEpKSB7CisJCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KHNiLT5zX2JkZXYpKSB7CiAJCQlqZnNfd2FybigiRklUUklNIG5vdCBzdXBwb3J0ZWQgb24gZGV2 aWNlIik7CiAJCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJCX0KZGlmZiAtLWdpdCBhL2ZzL2pmcy9z dXBlci5jIGIvZnMvamZzL3N1cGVyLmMKaW5kZXggZjFhMTNhNzRjZGRmMy4uODVkNGY0NGYyYWM0 ZCAxMDA2NDQKLS0tIGEvZnMvamZzL3N1cGVyLmMKKysrIGIvZnMvamZzL3N1cGVyLmMKQEAgLTM3 MiwxOSArMzcyLDE2IEBAIHN0YXRpYyBpbnQgcGFyc2Vfb3B0aW9ucyhjaGFyICpvcHRpb25zLCBz dHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzNjQgKm5ld0xWU2l6ZSwKIAkJfQogCiAJCWNhc2UgT3B0 X2Rpc2NhcmQ6Ci0JCXsKLQkJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVl dWUoc2ItPnNfYmRldik7CiAJCQkvKiBpZiBzZXQgdG8gMSwgZXZlbiBjb3B5aW5nIGZpbGVzIHdp bGwgY2F1c2UKIAkJCSAqIHRyaW1taW5nIDpPCiAJCQkgKiAtPiB1c2VyIGhhcyBtb3JlIGNvbnRy b2wgb3ZlciB0aGUgb25saW5lIHRyaW1taW5nCiAJCQkgKi8KIAkJCXNiaS0+bWluYmxrc190cmlt ID0gNjQ7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCQlpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJCSpmbGFnIHw9IEpGU19ESVNDQVJEOwogCQkJ ZWxzZQogCQkJCXByX2VycigiSkZTOiBkaXNjYXJkIG9wdGlvbiBub3Qgc3VwcG9ydGVkIG9uIGRl dmljZVxuIik7CiAJCQlicmVhazsKLQkJfQogCiAJCWNhc2UgT3B0X25vZGlzY2FyZDoKIAkJCSpm bGFnICY9IH5KRlNfRElTQ0FSRDsKQEAgLTM5MiwxMCArMzg5LDkgQEAgc3RhdGljIGludCBwYXJz ZV9vcHRpb25zKGNoYXIgKm9wdGlvbnMsIHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHM2NCAqbmV3 TFZTaXplLAogCiAJCWNhc2UgT3B0X2Rpc2NhcmRfbWluYmxrOgogCQl7Ci0JCQlzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQkJY2hhciAqbWlu Ymxrc190cmltID0gYXJnc1swXS5mcm9tOwogCQkJaW50IHJjOwotCQkJaWYgKGJsa19xdWV1ZV9k aXNjYXJkKHEpKSB7CisJCQlpZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYp KSB7CiAJCQkJKmZsYWcgfD0gSkZTX0RJU0NBUkQ7CiAJCQkJcmMgPSBrc3RydG91aW50KG1pbmJs a3NfdHJpbSwgMCwKIAkJCQkJCSZzYmktPm1pbmJsa3NfdHJpbSk7CmRpZmYgLS1naXQgYS9mcy9u aWxmczIvaW9jdGwuYyBiL2ZzL25pbGZzMi9pb2N0bC5jCmluZGV4IGZlYzE5NGE2NjZmNGIuLjUy YjczZjU1OGZjYjEgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9pb2N0bC5jCisrKyBiL2ZzL25pbGZz Mi9pb2N0bC5jCkBAIC0xMDU5LDcgKzEwNTksNyBAQCBzdGF0aWMgaW50IG5pbGZzX2lvY3RsX3Ry aW1fZnMoc3RydWN0IGlub2RlICppbm9kZSwgdm9pZCBfX3VzZXIgKmFyZ3ApCiAJaWYgKCFjYXBh YmxlKENBUF9TWVNfQURNSU4pKQogCQlyZXR1cm4gLUVQRVJNOwogCi0JaWYgKCFibGtfcXVldWVf ZGlzY2FyZChxKSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhuaWxmcy0+bnNfYmRl dikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmcmFuZ2Us IGFyZ3AsIHNpemVvZihyYW5nZSkpKQpkaWZmIC0tZ2l0IGEvZnMvbnRmczMvZmlsZS5jIGIvZnMv bnRmczMvZmlsZS5jCmluZGV4IDc4N2I1M2I5ODRlZTEuLmU3NjMyMzYxNjkzMzEgMTAwNjQ0Ci0t LSBhL2ZzL250ZnMzL2ZpbGUuYworKysgYi9mcy9udGZzMy9maWxlLmMKQEAgLTI4LDcgKzI4LDcg QEAgc3RhdGljIGludCBudGZzX2lvY3RsX2ZpdHJpbShzdHJ1Y3QgbnRmc19zYl9pbmZvICpzYmks IHVuc2lnbmVkIGxvbmcgYXJnKQogCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0 dXJuIC1FUEVSTTsKIAotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21h eF9kaXNjYXJkX3NlY3RvcnMoc2JpLT5zYi0+c19iZGV2KSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQ OwogCiAJdXNlcl9yYW5nZSA9IChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZzsKZGlm ZiAtLWdpdCBhL2ZzL250ZnMzL3N1cGVyLmMgYi9mcy9udGZzMy9zdXBlci5jCmluZGV4IGNkMzBl ODFhYmJjZTAuLmM3MzQwODViY2NlNGEgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMzL3N1cGVyLmMKKysr IGIvZnMvbnRmczMvc3VwZXIuYwpAQCAtOTEzLDcgKzkxMyw3IEBAIHN0YXRpYyBpbnQgbnRmc19m aWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBmc19jb250ZXh0ICpmYykK IAl9CiAKIAlycSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwotCWlmIChibGtfcXVldWVfZGlzY2Fy ZChycSkgJiYgcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5KSB7CisJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSAmJiBycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkp IHsKIAkJc2JpLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51 bGFyaXR5OwogCQlzYmktPmRpc2NhcmRfZ3JhbnVsYXJpdHlfbWFza19pbnYgPQogCQkJfih1NjQp KHNiaS0+ZGlzY2FyZF9ncmFudWxhcml0eSAtIDEpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvaW9j dGwuYyBiL2ZzL29jZnMyL2lvY3RsLmMKaW5kZXggZjU5NDYxZDg1ZGE0NS4uOWI3OGVmMTAzYWRh NiAxMDA2NDQKLS0tIGEvZnMvb2NmczIvaW9jdGwuYworKysgYi9mcy9vY2ZzMi9pb2N0bC5jCkBA IC05MTAsNyArOTEwLDcgQEAgbG9uZyBvY2ZzMl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5z aWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJCWlmICghY2FwYWJsZShDQVBfU1lT X0FETUlOKSkKIAkJCXJldHVybiAtRVBFUk07CiAKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChx KSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2ItPnNfYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZyYW5nZSwgYXJncCwgc2l6 ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Rpc2NhcmQuYyBiL2ZzL3hmcy94 ZnNfZGlzY2FyZC5jCmluZGV4IDAxOTFkZThjZTljZWQuLmE0ZTY2MDlkNjE2YjcgMTAwNjQ0Ci0t LSBhL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCisrKyBiL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCkBAIC0x NjIsNyArMTYyLDcgQEAgeGZzX2lvY190cmltKAogCiAJaWYgKCFjYXBhYmxlKENBUF9TWVNfQURN SU4pKQogCQlyZXR1cm4gLUVQRVJNOwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMobXAtPm1fZGRldl90YXJncC0+YnRfYmRldikpCiAJ CXJldHVybiAtRU9QTk9UU1VQUDsKIAogCS8qCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3N1cGVy LmMgYi9mcy94ZnMveGZzX3N1cGVyLmMKaW5kZXggNTRiZTlkNjQwOTNlZC4uYTI3NmI4MTExZjYz NiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19zdXBlci5jCisrKyBiL2ZzL3hmcy94ZnNfc3VwZXIu YwpAQCAtMTYwOCwxNCArMTYwOCwxMCBAQCB4ZnNfZnNfZmlsbF9zdXBlcigKIAkJCWdvdG8gb3V0 X2ZpbGVzdHJlYW1fdW5tb3VudDsKIAl9CiAKLQlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSkgewot CQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwot Ci0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJCXhmc193YXJuKG1wLCAibW91bnRp bmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMg bm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCQkJbXAtPm1fZmVhdHVyZXMgJj0gflhGU19GRUFUX0RJ U0NBUkQ7Ci0JCX0KKwlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSAmJiAhYmRldl9tYXhfZGlzY2Fy ZF9zZWN0b3JzKHNiLT5zX2JkZXYpKSB7CisJCXhmc193YXJuKG1wLAorCSJtb3VudGluZyB3aXRo IFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNj YXJkIik7CisJCW1wLT5tX2ZlYXR1cmVzICY9IH5YRlNfRkVBVF9ESVNDQVJEOwogCX0KIAogCWlm ICh4ZnNfaGFzX3JlZmxpbmsobXApKSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Jsa2Rl di5oIGIvaW5jbHVkZS9saW51eC9ibGtkZXYuaAppbmRleCBjZTE2MjQ3ZDNhZmFiLi43NjdhYjIy ZTEwNTJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1ZGUv bGludXgvYmxrZGV2LmgKQEAgLTU0MCw3ICs1NDAsNiBAQCBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSB7 CiAjZGVmaW5lIFFVRVVFX0ZMQUdfTk9OUk9UCTYJLyogbm9uLXJvdGF0aW9uYWwgZGV2aWNlIChT U0QpICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfVklSVAkJUVVFVUVfRkxBR19OT05ST1QgLyogcGFy YXZpcnQgZGV2aWNlICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfSU9fU1RBVAk3CS8qIGRvIGRpc2sv cGFydGl0aW9ucyBJTyBhY2NvdW50aW5nICovCi0jZGVmaW5lIFFVRVVFX0ZMQUdfRElTQ0FSRAk4 CS8qIHN1cHBvcnRzIERJU0NBUkQgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19OT1hNRVJHRVMJOQkv KiBObyBleHRlbmRlZCBtZXJnZXMgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19BRERfUkFORE9NCTEw CS8qIENvbnRyaWJ1dGVzIHRvIHJhbmRvbSBwb29sICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfU0VD RVJBU0UJMTEJLyogc3VwcG9ydHMgc2VjdXJlIGVyYXNlICovCkBAIC01ODIsNyArNTgxLDYgQEAg Ym9vbCBibGtfcXVldWVfZmxhZ190ZXN0X2FuZF9zZXQodW5zaWduZWQgaW50IGZsYWcsIHN0cnVj dCByZXF1ZXN0X3F1ZXVlICpxKTsKIAl0ZXN0X2JpdChRVUVVRV9GTEFHX1NUQUJMRV9XUklURVMs ICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfaW9fc3RhdChxKQl0ZXN0X2Jp dChRVUVVRV9GTEFHX0lPX1NUQVQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVl dWVfYWRkX3JhbmRvbShxKQl0ZXN0X2JpdChRVUVVRV9GTEFHX0FERF9SQU5ET00sICYocSktPnF1 ZXVlX2ZsYWdzKQotI2RlZmluZSBibGtfcXVldWVfZGlzY2FyZChxKQl0ZXN0X2JpdChRVUVVRV9G TEFHX0RJU0NBUkQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfem9uZV9y ZXNldGFsbChxKQlcCiAJdGVzdF9iaXQoUVVFVUVfRkxBR19aT05FX1JFU0VUQUxMLCAmKHEpLT5x dWV1ZV9mbGFncykKICNkZWZpbmUgYmxrX3F1ZXVlX3NlY3VyZV9lcmFzZShxKSBcCmRpZmYgLS1n aXQgYS9tbS9zd2FwZmlsZS5jIGIvbW0vc3dhcGZpbGUuYwppbmRleCA0MDY5ZjE3YTgyYzhlLi41 ZDljZWRmOWU3Yjg0IDEwMDY0NAotLS0gYS9tbS9zd2FwZmlsZS5jCisrKyBiL21tL3N3YXBmaWxl LmMKQEAgLTI5NTcsMjAgKzI5NTcsNiBAQCBzdGF0aWMgaW50IHNldHVwX3N3YXBfbWFwX2FuZF9l eHRlbnRzKHN0cnVjdCBzd2FwX2luZm9fc3RydWN0ICpwLAogCXJldHVybiBucl9leHRlbnRzOwog fQogCi0vKgotICogSGVscGVyIHRvIHN5c19zd2Fwb24gZGV0ZXJtaW5pbmcgaWYgYSBnaXZlbiBz d2FwCi0gKiBiYWNraW5nIGRldmljZSBxdWV1ZSBzdXBwb3J0cyBESVNDQVJEIG9wZXJhdGlvbnMu Ci0gKi8KLXN0YXRpYyBib29sIHN3YXBfZGlzY2FyZGFibGUoc3RydWN0IHN3YXBfaW5mb19zdHJ1 Y3QgKnNpKQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoc2kt PmJkZXYpOwotCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJcmV0dXJuIGZhbHNlOwot Ci0JcmV0dXJuIHRydWU7Ci19Ci0KIFNZU0NBTExfREVGSU5FMihzd2Fwb24sIGNvbnN0IGNoYXIg X191c2VyICosIHNwZWNpYWxmaWxlLCBpbnQsIHN3YXBfZmxhZ3MpCiB7CiAJc3RydWN0IHN3YXBf aW5mb19zdHJ1Y3QgKnA7CkBAIC0zMTMyLDcgKzMxMTgsOCBAQCBTWVNDQUxMX0RFRklORTIoc3dh cG9uLCBjb25zdCBjaGFyIF9fdXNlciAqLCBzcGVjaWFsZmlsZSwgaW50LCBzd2FwX2ZsYWdzKQog CQkJCQkgc2l6ZW9mKGxvbmcpLAogCQkJCQkgR0ZQX0tFUk5FTCk7CiAKLQlpZiAocC0+YmRldiAm JiAoc3dhcF9mbGFncyAmIFNXQVBfRkxBR19ESVNDQVJEKSAmJiBzd2FwX2Rpc2NhcmRhYmxlKHAp KSB7CisJaWYgKChzd2FwX2ZsYWdzICYgU1dBUF9GTEFHX0RJU0NBUkQpICYmCisJICAgIHAtPmJk ZXYgJiYgYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHAtPmJkZXYpKSB7CiAJCS8qCiAJCSAqIFdo ZW4gZGlzY2FyZCBpcyBlbmFibGVkIGZvciBzd2FwIHdpdGggbm8gcGFydGljdWxhcgogCQkgKiBw b2xpY3kgZmxhZ2dlZCwgd2Ugc2V0IGFsbCBzd2FwIGRpc2NhcmQgZmxhZ3MgaGVyZSBpbgotLSAK Mi4zMC4yCgotLQpkbS1kZXZlbCBtYWlsaW5nIGxpc3QKZG0tZGV2ZWxAcmVkaGF0LmNvbQpodHRw czovL2xpc3RtYW4ucmVkaGF0LmNvbS9tYWlsbWFuL2xpc3RpbmZvL2RtLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id AF32AC433EF for ; Sat, 9 Apr 2022 05:16:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=8ox6lNQD+T18fuj8e7g3ev9CUXlHxfhlWJ1dylaV46k=; b=cUDDnn6roeJzfR VHyQzHgL1JnvVLoYz61Y41wAim1N5IheTo3Bm/7TnLllidp1RvRck47jlhiPg7spNpA4oSSdx6ynR I2qgXRRDC+unwfhcys4sKYY93fUykQVAgIDOuC0HI/n8F1INUtw/xIvdFXEu52l0b1y24Iy6WtY5U Ml81sSMj01opUoUac2InTo18BzGN6Blh81f3wOB+yY1xqfrkIC1PLVl0lW4Hf+0o0PjAPfXwg1B7B LGJoId3ipn9su5Hvw2Uz+5UeqhKe8tQ1v2ZiS3jaDjw9tIYkFO2JrSwY4WSsK+8klOQLWZqVKClfl DtegINA5Kab5sZ1KJtKQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nd3SH-002DND-JH; Sat, 09 Apr 2022 05:16:13 +0000 Received: from 213-147-167-116.nat.highway.webapn.at ([213.147.167.116] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.94.2 #2 (Red Hat Linux)) id 1nd354-0021dK-Sw; Sat, 09 Apr 2022 04:52:15 +0000 From: Christoph Hellwig To: Jens Axboe Cc: dm-devel@redhat.com, linux-xfs@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-um@lists.infradead.org, linux-block@vger.kernel.org, drbd-dev@lists.linbit.com, nbd@other.debian.org, ceph-devel@vger.kernel.org, virtualization@lists.linux-foundation.org, xen-devel@lists.xenproject.org, linux-bcache@vger.kernel.org, linux-raid@vger.kernel.org, linux-mmc@vger.kernel.org, linux-mtd@lists.infradead.org, linux-nvme@lists.infradead.org, linux-s390@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux-btrfs@vger.kernel.org, linux-ext4@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, cluster-devel@redhat.com, jfs-discussion@lists.sourceforge.net, linux-nilfs@vger.kernel.org, ntfs3@lists.linux.dev, ocfs2-devel@oss.oracle.com, linux-mm@kvack.org, "Martin K . Petersen" , =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , Coly Li Subject: [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-Id: <20220409045043.23593-25-hch@lst.de> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> MIME-Version: 1.0 X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-mtd" Errors-To: linux-mtd-bounces+linux-mtd=archiver.kernel.org@lists.infradead.org SnVzdCB1c2UgYSBub24temVybyBtYXhfZGlzY2FyZF9zZWN0b3JzIGFzIGFuIGluZGljYXRvciBm b3IgZGlzY2FyZApzdXBwb3J0LCBzaW1pbGFyIHRvIHdoYXQgaXMgZG9uZSBmb3Igd3JpdGUgemVy b2VzLgoKVGhlIG9ubHkgcGxhY2VzIHdoZXJlIG5lZWRzIHNwZWNpYWwgYXR0ZW50aW9uIGlzIHRo ZSBSQUlENSBkcml2ZXIsCndoaWNoIG11c3QgY2xlYXIgZGlzY2FyZCBzdXBwb3J0IGZvciBzZWN1 cml0eSByZWFzb25zIGJ5IGRlZmF1bHQsCmV2ZW4gaWYgdGhlIGRlZmF1bHQgc3RhY2tpbmcgcnVs ZXMgd291bGQgYWxsb3cgZm9yIGl0LgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcg PGhjaEBsc3QuZGU+ClJldmlld2VkLWJ5OiBNYXJ0aW4gSy4gUGV0ZXJzZW4gPG1hcnRpbi5wZXRl cnNlbkBvcmFjbGUuY29tPgpBY2tlZC1ieTogQ2hyaXN0b3BoIELDtmhtd2FsZGVyIDxjaHJpc3Rv cGguYm9laG13YWxkZXJAbGluYml0LmNvbT4gW2J0cmZzXQpBY2tlZC1ieTogQ29seSBMaSA8Y29s eWxpQHN1c2UuZGU+IFtiY2FjaGVdCi0tLQogYXJjaC91bS9kcml2ZXJzL3ViZF9rZXJuLmMgICAg ICAgICAgfCAgMiAtLQogYmxvY2svYmxrLWNvcmUuYyAgICAgICAgICAgICAgICAgICAgfCAgMiAr LQogYmxvY2svYmxrLWxpYi5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogYmxvY2svYmxr LW1xLWRlYnVnZnMuYyAgICAgICAgICAgICAgfCAgMSAtCiBibG9jay9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgICB8ICAzICstLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbWFpbi5jICAg ICAgfCAgMiArLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYyAgICAgICAgfCAxOSArKy0t LS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jICB8ICAz ICstLQogZHJpdmVycy9ibG9jay9sb29wLmMgICAgICAgICAgICAgICAgfCAxMSArKystLS0tLS0t LQogZHJpdmVycy9ibG9jay9uYmQuYyAgICAgICAgICAgICAgICAgfCAgNSArLS0tLQogZHJpdmVy cy9ibG9jay9udWxsX2Jsay9tYWluLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL2Jsb2NrL3JiZC5j ICAgICAgICAgICAgICAgICB8ICAxIC0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jICAg ICAgIHwgIDIgLS0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaCAgIHwgIDMgLS0t CiBkcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYyAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Js b2NrL3hlbi1ibGtiYWNrL3hlbmJ1cy5jICB8ICAyICstCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtm cm9udC5jICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYyAgICAg ICB8ICAxIC0KIGRyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYyAgICAgICAgIHwgIDQgKystLQog ZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYyAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv YmNhY2hlL3N5c2ZzLmMgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvbWQvZG0tY2FjaGUtdGFy Z2V0LmMgICAgICAgIHwgIDkgKy0tLS0tLS0tCiBkcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5j ICAgICAgICB8ICA5ICstLS0tLS0tLQogZHJpdmVycy9tZC9kbS1sb2ctd3JpdGVzLmMgICAgICAg ICAgfCAgMyArLS0KIGRyaXZlcnMvbWQvZG0tcmFpZC5jICAgICAgICAgICAgICAgIHwgIDkgKyst LS0tLS0tCiBkcml2ZXJzL21kL2RtLXRhYmxlLmMgICAgICAgICAgICAgICB8ICA5ICsrLS0tLS0t LQogZHJpdmVycy9tZC9kbS10aGluLmMgICAgICAgICAgICAgICAgfCAxMSArLS0tLS0tLS0tLQog ZHJpdmVycy9tZC9kbS5jICAgICAgICAgICAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv bWQtbGluZWFyLmMgICAgICAgICAgICAgIHwgMTEgKy0tLS0tLS0tLS0KIGRyaXZlcnMvbWQvcmFp ZDAuYyAgICAgICAgICAgICAgICAgIHwgIDcgLS0tLS0tLQogZHJpdmVycy9tZC9yYWlkMS5jICAg ICAgICAgICAgICAgICAgfCAxNiArLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL21kL3JhaWQxMC5j ICAgICAgICAgICAgICAgICB8IDE4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tZC9yYWlk NS1jYWNoZS5jICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9tZC9yYWlkNS5jICAgICAgICAg ICAgICAgICAgfCAxMiArKysrLS0tLS0tLS0KIGRyaXZlcnMvbW1jL2NvcmUvcXVldWUuYyAgICAg ICAgICAgIHwgIDEgLQogZHJpdmVycy9tdGQvbXRkX2Jsa2RldnMuYyAgICAgICAgICAgfCAgMSAt CiBkcml2ZXJzL252bWUvaG9zdC9jb3JlLmMgICAgICAgICAgICB8ICA2ICsrLS0tLQogZHJpdmVy cy9zMzkwL2Jsb2NrL2Rhc2RfZmJhLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL3Njc2kvc2QuYyAg ICAgICAgICAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9kZXZp Y2UuYyB8ICAyICstCiBmcy9idHJmcy9leHRlbnQtdHJlZS5jICAgICAgICAgICAgICB8ICA0ICsr LS0KIGZzL2J0cmZzL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0 L2ZpbGUuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0L3N1cGVyLmMgICAg ICAgICAgICAgICAgICAgIHwgMTAgKysrLS0tLS0tLQogZnMvZXh0NC9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgfCAxMCArKystLS0tLS0tCiBmcy9leHQ0L3N1cGVyLmMgICAgICAgICAgICAg ICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZzL2YyZnMvZjJmcy5oICAgICAgICAgICAgICAgICAg ICAgIHwgIDMgKy0tCiBmcy9mYXQvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgICB8ICAyICst CiBmcy9mYXQvaW5vZGUuYyAgICAgICAgICAgICAgICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZz L2dmczIvcmdycC5jICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2piZDIvam91cm5h bC5jICAgICAgICAgICAgICAgICAgIHwgIDcgKystLS0tLQogZnMvamZzL2lvY3RsLmMgICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQogZnMvamZzL3N1cGVyLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgOCArKy0tLS0tLQogZnMvbmlsZnMyL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgfCAg MiArLQogZnMvbnRmczMvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvbnRm czMvc3VwZXIuYyAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvb2NmczIvaW9jdGwuYyAg ICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMveGZzL3hmc19kaXNjYXJkLmMgICAgICAgICAg ICAgICAgfCAgMiArLQogZnMveGZzL3hmc19zdXBlci5jICAgICAgICAgICAgICAgICAgfCAxMiAr KysrLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvYmxrZGV2LmggICAgICAgICAgICAgIHwgIDIgLS0K IG1tL3N3YXBmaWxlLmMgICAgICAgICAgICAgICAgICAgICAgIHwgMTcgKystLS0tLS0tLS0tLS0t LS0KIDYxIGZpbGVzIGNoYW5nZWQsIDcyIGluc2VydGlvbnMoKyksIDI0NiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvdWJkX2tlcm4uYyBiL2FyY2gvdW0vZHJpdmVy cy91YmRfa2Vybi5jCmluZGV4IGIwMzI2OWZhZWY3MTQuLjA4NWZmZGY5OGU1N2UgMTAwNjQ0Ci0t LSBhL2FyY2gvdW0vZHJpdmVycy91YmRfa2Vybi5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy91YmRf a2Vybi5jCkBAIC00ODMsNyArNDgzLDYgQEAgc3RhdGljIHZvaWQgdWJkX2hhbmRsZXIodm9pZCkK IAkJCWlmICgoaW9fcmVxLT5lcnJvciA9PSBCTEtfU1RTX05PVFNVUFApICYmIChyZXFfb3AoaW9f cmVxLT5yZXEpID09IFJFUV9PUF9ESVNDQVJEKSkgewogCQkJCWJsa19xdWV1ZV9tYXhfZGlzY2Fy ZF9zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKIAkJCQlibGtfcXVldWVfbWF4X3dyaXRlX3pl cm9lc19zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKLQkJCQlibGtfcXVldWVfZmxhZ19jbGVh cihRVUVVRV9GTEFHX0RJU0NBUkQsIGlvX3JlcS0+cmVxLT5xKTsKIAkJCX0KIAkJCWJsa19tcV9l bmRfcmVxdWVzdChpb19yZXEtPnJlcSwgaW9fcmVxLT5lcnJvcik7CiAJCQlrZnJlZShpb19yZXEp OwpAQCAtODAzLDcgKzgwMiw2IEBAIHN0YXRpYyBpbnQgdWJkX29wZW5fZGV2KHN0cnVjdCB1YmQg KnViZF9kZXYpCiAJCXViZF9kZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQgPSBT RUNUT1JfU0laRTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnModWJkX2Rldi0+cXVl dWUsIFVCRF9NQVhfUkVRVUVTVCk7CiAJCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3Rv cnModWJkX2Rldi0+cXVldWUsIFVCRF9NQVhfUkVRVUVTVCk7Ci0JCWJsa19xdWV1ZV9mbGFnX3Nl dChRVUVVRV9GTEFHX0RJU0NBUkQsIHViZF9kZXYtPnF1ZXVlKTsKIAl9CiAJYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfTk9OUk9ULCB1YmRfZGV2LT5xdWV1ZSk7CiAJcmV0dXJuIDA7CmRp ZmYgLS1naXQgYS9ibG9jay9ibGstY29yZS5jIGIvYmxvY2svYmxrLWNvcmUuYwppbmRleCA5Mzdi YjZiODYzMzE3Li5iNWMzYTgwNDkxMzRjIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY29yZS5jCisr KyBiL2Jsb2NrL2Jsay1jb3JlLmMKQEAgLTgyMCw3ICs4MjAsNyBAQCB2b2lkIHN1Ym1pdF9iaW9f bm9hY2N0KHN0cnVjdCBiaW8gKmJpbykKIAogCXN3aXRjaCAoYmlvX29wKGJpbykpIHsKIAljYXNl IFJFUV9PUF9ESVNDQVJEOgotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQorCQlpZiAoIWJk ZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSkKIAkJCWdvdG8gbm90X3N1cHBvcnRlZDsKIAkJ YnJlYWs7CiAJY2FzZSBSRVFfT1BfU0VDVVJFX0VSQVNFOgpkaWZmIC0tZ2l0IGEvYmxvY2svYmxr LWxpYi5jIGIvYmxvY2svYmxrLWxpYi5jCmluZGV4IDJhZTMyYTcyMjg1MWMuLjhiNGI2NmQzYTli ZmMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1saWIuYworKysgYi9ibG9jay9ibGstbGliLmMKQEAg LTUzLDcgKzUzLDcgQEAgaW50IF9fYmxrZGV2X2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2Rl dmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCQlv cCA9IFJFUV9PUF9TRUNVUkVfRVJBU0U7CiAJfSBlbHNlIHsKLQkJaWYgKCFibGtfcXVldWVfZGlz Y2FyZChxKSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAJCW9wID0gUkVRX09QX0RJU0NBUkQ7CiAJfQpkaWZmIC0tZ2l0IGEv YmxvY2svYmxrLW1xLWRlYnVnZnMuYyBiL2Jsb2NrL2Jsay1tcS1kZWJ1Z2ZzLmMKaW5kZXggYWEw MzQ5ZTlmMDgzYi4uZmQxMTFjNTAwMTI1NiAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLW1xLWRlYnVn ZnMuYworKysgYi9ibG9jay9ibGstbXEtZGVidWdmcy5jCkBAIC0xMTMsNyArMTEzLDYgQEAgc3Rh dGljIGNvbnN0IGNoYXIgKmNvbnN0IGJsa19xdWV1ZV9mbGFnX25hbWVbXSA9IHsKIAlRVUVVRV9G TEFHX05BTUUoRkFJTF9JTyksCiAJUVVFVUVfRkxBR19OQU1FKE5PTlJPVCksCiAJUVVFVUVfRkxB R19OQU1FKElPX1NUQVQpLAotCVFVRVVFX0ZMQUdfTkFNRShESVNDQVJEKSwKIAlRVUVVRV9GTEFH X05BTUUoTk9YTUVSR0VTKSwKIAlRVUVVRV9GTEFHX05BTUUoQUREX1JBTkRPTSksCiAJUVVFVUVf RkxBR19OQU1FKFNFQ0VSQVNFKSwKZGlmZiAtLWdpdCBhL2Jsb2NrL2lvY3RsLmMgYi9ibG9jay9p b2N0bC5jCmluZGV4IGFkMzc3MWIyNjhiODEuLmMyY2QzYmE1MjkwY2UgMTAwNjQ0Ci0tLSBhL2Js b2NrL2lvY3RsLmMKKysrIGIvYmxvY2svaW9jdGwuYwpAQCAtODcsMTQgKzg3LDEzIEBAIHN0YXRp YyBpbnQgYmxrX2lvY3RsX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlLAogewogCXVpbnQ2NF90IHJhbmdlWzJdOwogCXVpbnQ2NF90IHN0YXJ0LCBsZW47Ci0J c3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShiZGV2KTsKIAlzdHJ1Y3Qg aW5vZGUgKmlub2RlID0gYmRldi0+YmRfaW5vZGU7CiAJaW50IGVycjsKIAogCWlmICghKG1vZGUg JiBGTU9ERV9XUklURSkpCiAJCXJldHVybiAtRUJBREY7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQlyZXR1cm4g LUVPUE5PVFNVUFA7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIocmFuZ2UsICh2b2lkIF9fdXNlciAq KWFyZywgc2l6ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJi ZF9tYWluLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMKaW5kZXggZWFlNjI5YzRm NmVhZi4uYTY5NDc1ZTU5MjgyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf bWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX21haW4uYwpAQCAtOTQyLDcgKzk0 Miw3IEBAIGludCBkcmJkX3NlbmRfc2l6ZXMoc3RydWN0IGRyYmRfcGVlcl9kZXZpY2UgKnBlZXJf ZGV2aWNlLCBpbnQgdHJpZ2dlcl9yZXBseSwgZW51CiAJCQljcHVfdG9fYmUzMihiZGV2X2FsaWdu bWVudF9vZmZzZXQoYmRldikpOwogCQlwLT5xbGltLT5pb19taW4gPSBjcHVfdG9fYmUzMihiZGV2 X2lvX21pbihiZGV2KSk7CiAJCXAtPnFsaW0tPmlvX29wdCA9IGNwdV90b19iZTMyKGJkZXZfaW9f b3B0KGJkZXYpKTsKLQkJcC0+cWxpbS0+ZGlzY2FyZF9lbmFibGVkID0gYmxrX3F1ZXVlX2Rpc2Nh cmQocSk7CisJCXAtPnFsaW0tPmRpc2NhcmRfZW5hYmxlZCA9ICEhYmRldl9tYXhfZGlzY2FyZF9z ZWN0b3JzKGJkZXYpOwogCQlwdXRfbGRldihkZXZpY2UpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBy ZXF1ZXN0X3F1ZXVlICpxID0gZGV2aWNlLT5ycV9xdWV1ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv YmxvY2svZHJiZC9kcmJkX25sLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9ubC5jCmluZGV4 IGQ0ZGFjYzMyOWFjMmUuLmI1NWU1ZmNjMjFlMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv ZHJiZC9kcmJkX25sLmMKKysrIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYwpAQCAtMTIx MCw3ICsxMjEwLDcgQEAgc3RhdGljIHZvaWQgZGVjaWRlX29uX2Rpc2NhcmRfc3VwcG9ydChzdHJ1 Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwKIAkJZmlyc3RfcGVlcl9kZXZpY2UoZGV2aWNlKS0+Y29u bmVjdGlvbjsKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGRldmljZS0+cnFfcXVldWU7CiAK LQlpZiAoYmRldiAmJiAhYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldi0+YmFja2luZ19iZGV2LT5iZF9k aXNrLT5xdWV1ZSkpCisJaWYgKGJkZXYgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2 LT5iYWNraW5nX2JkZXYpKQogCQlnb3RvIG5vdF9zdXBwb3J0ZWQ7CiAKIAlpZiAoY29ubmVjdGlv bi0+Y3N0YXRlID49IENfQ09OTkVDVEVEICYmCkBAIC0xMjMwLDMwICsxMjMwLDE2IEBAIHN0YXRp YyB2b2lkIGRlY2lkZV9vbl9kaXNjYXJkX3N1cHBvcnQoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZp Y2UsCiAJICovCiAJYmxrX3F1ZXVlX2Rpc2NhcmRfZ3JhbnVsYXJpdHkocSwgNTEyKTsKIAlxLT5s aW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9ycyA9IGRyYmRfbWF4X2Rpc2NhcmRfc2VjdG9ycyhjb25u ZWN0aW9uKTsKLQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAlx LT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0KIAkJZHJiZF9tYXhfZGlzY2FyZF9z ZWN0b3JzKGNvbm5lY3Rpb24pOwogCXJldHVybjsKIAogbm90X3N1cHBvcnRlZDoKLQlibGtfcXVl dWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwogCWJsa19xdWV1ZV9kaXNjYXJk X2dyYW51bGFyaXR5KHEsIDApOwogCXEtPmxpbWl0cy5tYXhfZGlzY2FyZF9zZWN0b3JzID0gMDsK IAlxLT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0gMDsKIH0KIAotc3RhdGljIHZv aWQgZml4dXBfZGlzY2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpx KQotewotCS8qIFRvIGF2b2lkIGNvbmZ1c2lvbiwgaWYgdGhpcyBxdWV1ZSBkb2VzIG5vdCBzdXBw b3J0IGRpc2NhcmQsIGNsZWFyCi0JICogbWF4X2Rpc2NhcmRfc2VjdG9ycywgd2hpY2ggaXMgd2hh dCBsc2JsayAtRCByZXBvcnRzIHRvIHRoZSB1c2VyLgotCSAqIE9sZGVyIGtlcm5lbHMgZ290IHRo aXMgd3JvbmcgaW4gInN0YWNrIGxpbWl0cyIuCi0JICogKi8KLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKSB7Ci0JCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIDApOwotCQlibGtf cXVldWVfZGlzY2FyZF9ncmFudWxhcml0eShxLCAwKTsKLQl9Ci19Ci0KIHN0YXRpYyB2b2lkIGZp eHVwX3dyaXRlX3plcm9lcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwgc3RydWN0IHJlcXVl c3RfcXVldWUgKnEpCiB7CiAJLyogRml4dXAgbWF4X3dyaXRlX3plcm9lc19zZWN0b3JzIGFmdGVy IGJsa19zdGFja19saW1pdHMoKToKQEAgLTEzMDAsNyArMTI4Niw2IEBAIHN0YXRpYyB2b2lkIGRy YmRfc2V0dXBfcXVldWVfcGFyYW0oc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBk cmJkX2JhY2tpCiAJCWJsa19zdGFja19saW1pdHMoJnEtPmxpbWl0cywgJmItPmxpbWl0cywgMCk7 CiAJCWRpc2tfdXBkYXRlX3JlYWRhaGVhZChkZXZpY2UtPnZkaXNrKTsKIAl9Ci0JZml4dXBfZGlz Y2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHEpOwogCWZpeHVwX3dyaXRlX3plcm9lcyhkZXZpY2UsIHEp OwogfQogCkBAIC0xNDQ3LDcgKzE0MzIsNyBAQCBzdGF0aWMgdm9pZCBzYW5pdGl6ZV9kaXNrX2Nv bmYoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBkaXNrX2NvbmYgKmRpcwogCWlm IChkaXNrX2NvbmYtPmFsX2V4dGVudHMgPiBkcmJkX2FsX2V4dGVudHNfbWF4KG5iYykpCiAJCWRp c2tfY29uZi0+YWxfZXh0ZW50cyA9IGRyYmRfYWxfZXh0ZW50c19tYXgobmJjKTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhi ZGV2KSkgewogCQlpZiAoZGlza19jb25mLT5yc19kaXNjYXJkX2dyYW51bGFyaXR5KSB7CiAJCQlk aXNrX2NvbmYtPnJzX2Rpc2NhcmRfZ3JhbnVsYXJpdHkgPSAwOyAvKiBkaXNhYmxlIGZlYXR1cmUg Ki8KIAkJCWRyYmRfaW5mbyhkZXZpY2UsICJyc19kaXNjYXJkX2dyYW51bGFyaXR5IGZlYXR1cmUg ZGlzYWJsZWRcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2 ZXIuYyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX3JlY2VpdmVyLmMKaW5kZXggMGI0YzdkZTQ2 Mzk4OS4uOGE0YTQ3ZGE1NmZlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf cmVjZWl2ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC0x NTc1LDExICsxNTc1LDEwIEBAIGludCBkcmJkX2lzc3VlX2Rpc2NhcmRfb3JfemVyb19vdXQoc3Ry dWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHNlY3Rvcl90IHN0YXJ0LCB1CiAKIHN0YXRpYyBib29s IGNhbl9kb19yZWxpYWJsZV9kaXNjYXJkcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSkKIHsK LQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGRldmljZS0+bGRldi0+ YmFja2luZ19iZGV2KTsKIAlzdHJ1Y3QgZGlza19jb25mICpkYzsKIAlib29sIGNhbl9kbzsKIAot CWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoZGV2aWNlLT5sZGV2LT5iYWNraW5nX2JkZXYpKQogCQlyZXR1cm4gZmFsc2U7CiAKIAlyY3Vf cmVhZF9sb2NrKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYyBiL2RyaXZlcnMv YmxvY2svbG9vcC5jCmluZGV4IDhkODAwZDQ2ZTQ5ODUuLjBlMDYxYzk4OTZlZmYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCkBAIC0z MTQsMTUgKzMxNCwxMiBAQCBzdGF0aWMgaW50IGxvX2ZhbGxvY2F0ZShzdHJ1Y3QgbG9vcF9kZXZp Y2UgKmxvLCBzdHJ1Y3QgcmVxdWVzdCAqcnEsIGxvZmZfdCBwb3MsCiAKIAltb2RlIHw9IEZBTExP Q19GTF9LRUVQX1NJWkU7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKGxvLT5sb19xdWV1ZSkp IHsKLQkJcmV0ID0gLUVPUE5PVFNVUFA7Ci0JCWdvdG8gb3V0OwotCX0KKwlpZiAoIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhsby0+bG9fZGV2aWNlKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOwog CiAJcmV0ID0gZmlsZS0+Zl9vcC0+ZmFsbG9jYXRlKGZpbGUsIG1vZGUsIHBvcywgYmxrX3JxX2J5 dGVzKHJxKSk7CiAJaWYgKHVubGlrZWx5KHJldCAmJiByZXQgIT0gLUVJTlZBTCAmJiByZXQgIT0g LUVPUE5PVFNVUFApKQotCQlyZXQgPSAtRUlPOwotIG91dDoKKwkJcmV0dXJuIC1FSU87CiAJcmV0 dXJuIHJldDsKIH0KIApAQCAtNzg3LDEyICs3ODQsMTAgQEAgc3RhdGljIHZvaWQgbG9vcF9jb25m aWdfZGlzY2FyZChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvKQogCQlxLT5saW1pdHMuZGlzY2FyZF9n cmFudWxhcml0eSA9IGdyYW51bGFyaXR5OwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9y cyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKIAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNf c2VjdG9ycyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFV RVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJfSBlbHNlIHsKIAkJcS0+bGltaXRzLmRpc2NhcmRfZ3Jh bnVsYXJpdHkgPSAwOwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCAwKTsKIAkJ YmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhxLCAwKTsKLQkJYmxrX3F1ZXVlX2Zs YWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAl9CiAJcS0+bGltaXRzLmRpc2NhcmRf YWxpZ25tZW50ID0gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbmJkLmMgYi9kcml2 ZXJzL2Jsb2NrL25iZC5jCmluZGV4IDVhMWY5ODQ5NGRkZGYuLjQ3MjlhZWY4YzY0NjIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYmxvY2svbmJkLmMKKysrIGIvZHJpdmVycy9ibG9jay9uYmQuYwpAQCAt MTIzMSw4ICsxMjMxLDYgQEAgc3RhdGljIHZvaWQgbmJkX3BhcnNlX2ZsYWdzKHN0cnVjdCBuYmRf ZGV2aWNlICpuYmQpCiAJCXNldF9kaXNrX3JvKG5iZC0+ZGlzaywgdHJ1ZSk7CiAJZWxzZQogCQlz ZXRfZGlza19ybyhuYmQtPmRpc2ssIGZhbHNlKTsKLQlpZiAoY29uZmlnLT5mbGFncyAmIE5CRF9G TEFHX1NFTkRfVFJJTSkKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwg bmJkLT5kaXNrLT5xdWV1ZSk7CiAJaWYgKGNvbmZpZy0+ZmxhZ3MgJiBOQkRfRkxBR19TRU5EX0ZM VVNIKSB7CiAJCWlmIChjb25maWctPmZsYWdzICYgTkJEX0ZMQUdfU0VORF9GVUEpCiAJCQlibGtf cXVldWVfd3JpdGVfY2FjaGUobmJkLT5kaXNrLT5xdWV1ZSwgdHJ1ZSwgdHJ1ZSk7CkBAIC0xMzE5 LDggKzEzMTcsNyBAQCBzdGF0aWMgdm9pZCBuYmRfY29uZmlnX3B1dChzdHJ1Y3QgbmJkX2Rldmlj ZSAqbmJkKQogCQluYmQtPnRhZ19zZXQudGltZW91dCA9IDA7CiAJCW5iZC0+ZGlzay0+cXVldWUt PmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJbmJkLT5kaXNrLT5xdWV1ZS0+bGlt aXRzLmRpc2NhcmRfYWxpZ25tZW50ID0gMDsKLQkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3Rv cnMobmJkLT5kaXNrLT5xdWV1ZSwgVUlOVF9NQVgpOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIG5iZC0+ZGlzay0+cXVldWUpOworCQlibGtfcXVldWVfbWF4X2Rp c2NhcmRfc2VjdG9ycyhuYmQtPmRpc2stPnF1ZXVlLCAwKTsKIAogCQltdXRleF91bmxvY2soJm5i ZC0+Y29uZmlnX2xvY2spOwogCQluYmRfcHV0KG5iZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Js b2NrL251bGxfYmxrL21haW4uYyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCmluZGV4 IDA1YjExMjBlNjYyMzQuLmY2NDkzYTllODVlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv bnVsbF9ibGsvbWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCkBAIC0x NzY3LDcgKzE3NjcsNiBAQCBzdGF0aWMgdm9pZCBudWxsX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBu dWxsYiAqbnVsbGIpCiAJbnVsbGItPnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gbnVs bGItPmRldi0+YmxvY2tzaXplOwogCW51bGxiLT5xLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQg PSBudWxsYi0+ZGV2LT5ibG9ja3NpemU7CiAJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMo bnVsbGItPnEsIFVJTlRfTUFYID4+IDkpOwotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFH X0RJU0NBUkQsIG51bGxiLT5xKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZp Y2Vfb3BlcmF0aW9ucyBudWxsX2Jpb19vcHMgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2Nr L3JiZC5jIGIvZHJpdmVycy9ibG9jay9yYmQuYwppbmRleCBiODQ0NDMyYmFkMjBiLi4yYjIxZjcx N2NjZTFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3JiZC5jCisrKyBiL2RyaXZlcnMvYmxv Y2svcmJkLmMKQEAgLTQ5NDIsNyArNDk0Miw2IEBAIHN0YXRpYyBpbnQgcmJkX2luaXRfZGlzayhz dHJ1Y3QgcmJkX2RldmljZSAqcmJkX2RldikKIAlibGtfcXVldWVfaW9fb3B0KHEsIHJiZF9kZXYt Pm9wdHMtPmFsbG9jX3NpemUpOwogCiAJaWYgKHJiZF9kZXYtPm9wdHMtPnRyaW0pIHsKLQkJYmxr X3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJCXEtPmxpbWl0cy5kaXNj YXJkX2dyYW51bGFyaXR5ID0gcmJkX2Rldi0+b3B0cy0+YWxsb2Nfc2l6ZTsKIAkJYmxrX3F1ZXVl X21heF9kaXNjYXJkX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNFQ1RPUl9TSElGVCk7CiAJ CWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNF Q1RPUl9TSElGVCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1jbHQuYyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCmluZGV4IGI2NmU4ODQwYjk0YjguLmVmYTk5 YTM4ODQ1MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCisrKyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCkBAIC0xMzY0LDggKzEzNjQsNiBAQCBzdGF0 aWMgdm9pZCBzZXR1cF9yZXF1ZXN0X3F1ZXVlKHN0cnVjdCBybmJkX2NsdF9kZXYgKmRldikKIAli bGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPnF1ZXVlLCBkZXYtPm1heF9kaXNjYXJk X3NlY3RvcnMpOwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5CT0gZGV2 LT5kaXNjYXJkX2dyYW51bGFyaXR5OwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2FsaWdu bWVudAk9IGRldi0+ZGlzY2FyZF9hbGlnbm1lbnQ7Ci0JaWYgKGRldi0+bWF4X2Rpc2NhcmRfc2Vj dG9ycykKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgZGV2LT5xdWV1 ZSk7CiAJaWYgKGRldi0+c2VjdXJlX2Rpc2NhcmQpCiAJCWJsa19xdWV1ZV9mbGFnX3NldChRVUVV RV9GTEFHX1NFQ0VSQVNFLCBkZXYtPnF1ZXVlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay9ybmJkL3JuYmQtc3J2LWRldi5oIGIvZHJpdmVycy9ibG9jay9ybmJkL3JuYmQtc3J2LWRldi5o CmluZGV4IGY4MmZiYjRiYmRhOGUuLjFmN2UxYzhmZDRkOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv YmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaAorKysgYi9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1z cnYtZGV2LmgKQEAgLTQ5LDkgKzQ5LDYgQEAgc3RhdGljIGlubGluZSBpbnQgcm5iZF9kZXZfZ2V0 X3NlY3VyZV9kaXNjYXJkKGNvbnN0IHN0cnVjdCBybmJkX2RldiAqZGV2KQogCiBzdGF0aWMgaW5s aW5lIGludCBybmJkX2Rldl9nZXRfbWF4X2Rpc2NhcmRfc2VjdHMoY29uc3Qgc3RydWN0IHJuYmRf ZGV2ICpkZXYpCiB7Ci0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShkZXYt PmJkZXYpKSkKLQkJcmV0dXJuIDA7Ci0KIAlyZXR1cm4gYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KGRldi0+YmRldik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svdmlydGlvX2Jsay5j IGIvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKaW5kZXggYThiY2YzZjY2NGFmMS4uNmNjZjE1 MjUzZGVlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKKysrIGIvZHJp dmVycy9ibG9jay92aXJ0aW9fYmxrLmMKQEAgLTg4OCw4ICs4ODgsNiBAQCBzdGF0aWMgaW50IHZp cnRibGtfcHJvYmUoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCiAJCQl2ID0gc2dfZWxlbXM7 CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWdtZW50cyhxLAogCQkJCQkgICAgICAgbWluKHYs IE1BWF9ESVNDQVJEX1NFR01FTlRTKSk7Ci0KLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZM QUdfRElTQ0FSRCwgcSk7CiAJfQogCiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJU SU9fQkxLX0ZfV1JJVEVfWkVST0VTKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrYmFjay94ZW5idXMuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2sveGVuYnVzLmMKaW5k ZXggOGI2OTFmZTUwNDc1Zi4uODNjZDA4MDQxZTZiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay94ZW4tYmxrYmFjay94ZW5idXMuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hl bmJ1cy5jCkBAIC01ODMsNyArNTgzLDcgQEAgc3RhdGljIHZvaWQgeGVuX2Jsa2JrX2Rpc2NhcmQo c3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQsIHN0cnVjdCBiYWNrZW5kX2luZm8KIAlpZiAo IXhlbmJ1c19yZWFkX3Vuc2lnbmVkKGRldi0+bm9kZW5hbWUsICJkaXNjYXJkLWVuYWJsZSIsIDEp KQogCQlyZXR1cm47CiAKLQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKSB7CiAJCWVyciA9IHhlbmJ1c19wcmludGYoeGJ0LCBk ZXYtPm5vZGVuYW1lLAogCQkJImRpc2NhcmQtZ3JhbnVsYXJpdHkiLCAiJXUiLAogCQkJcS0+bGlt aXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrZnJvbnQuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2Zyb250LmMKaW5kZXggMDAzMDU2ZDRm N2Y1Zi4uMjUzYmY4MzVhY2ExZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay94ZW4tYmxrZnJv bnQuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jCkBAIC05NDQsNyArOTQ0LDYg QEAgc3RhdGljIHZvaWQgYmxraWZfc2V0X3F1ZXVlX2xpbWl0cyhzdHJ1Y3QgYmxrZnJvbnRfaW5m byAqaW5mbykKIAlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19WSVJULCBycSk7CiAKIAlp ZiAoaW5mby0+ZmVhdHVyZV9kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX0RJU0NBUkQsIHJxKTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMocnEsIGdl dF9jYXBhY2l0eShnZCkpOwogCQlycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkgPSBpbmZv LT5kaXNjYXJkX2dyYW51bGFyaXR5ID86CiAJCQkJCQkgaW5mby0+cGh5c2ljYWxfc2VjdG9yX3Np emU7CkBAIC0xNjA2LDcgKzE2MDUsNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgYmxraWZfaW50ZXJy dXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAkJCQlibGtpZl9yZXEocmVxKS0+ZXJyb3IgPSBC TEtfU1RTX05PVFNVUFA7CiAJCQkJaW5mby0+ZmVhdHVyZV9kaXNjYXJkID0gMDsKIAkJCQlpbmZv LT5mZWF0dXJlX3NlY2Rpc2NhcmQgPSAwOwotCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfRElTQ0FSRCwgcnEpOwogCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdf U0VDRVJBU0UsIHJxKTsKIAkJCX0KIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay96cmFtL3pyYW1fZHJ2LmMgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwppbmRleCBl OTQ3NGIwMjAxMmRlLi41OWZmNDQ0YmY2Yzc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3py YW0venJhbV9kcnYuYworKysgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwpAQCAtMTk1 Miw3ICsxOTUyLDYgQEAgc3RhdGljIGludCB6cmFtX2FkZCh2b2lkKQogCWJsa19xdWV1ZV9pb19v cHQoenJhbS0+ZGlzay0+cXVldWUsIFBBR0VfU0laRSk7CiAJenJhbS0+ZGlzay0+cXVldWUtPmxp bWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gUEFHRV9TSVpFOwogCWJsa19xdWV1ZV9tYXhfZGlz Y2FyZF9zZWN0b3JzKHpyYW0tPmRpc2stPnF1ZXVlLCBVSU5UX01BWCk7Ci0JYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgenJhbS0+ZGlzay0+cXVldWUpOwogCiAJLyoKIAkg KiB6cmFtX2Jpb19kaXNjYXJkKCkgd2lsbCBjbGVhciBhbGwgbG9naWNhbCBibG9ja3MgaWYgbG9n aWNhbCBibG9jawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jIGIvZHJp dmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jCmluZGV4IGZkZDAxOTRmODRkZDAuLmUyN2Y2N2YwNmE0 MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYworKysgYi9kcml2ZXJz L21kL2JjYWNoZS9yZXF1ZXN0LmMKQEAgLTEwMDUsNyArMTAwNSw3IEBAIHN0YXRpYyB2b2lkIGNh Y2hlZF9kZXZfd3JpdGUoc3RydWN0IGNhY2hlZF9kZXYgKmRjLCBzdHJ1Y3Qgc2VhcmNoICpzKQog CQliaW9fZ2V0KHMtPmlvcC5iaW8pOwogCiAJCWlmIChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElT Q0FSRCAmJgotCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2 KSkpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGRjLT5iZGV2KSkKIAkJCWdvdG8g aW5zZXJ0X2RhdGE7CiAKIAkJLyogSS9PIHJlcXVlc3Qgc2VudCB0byBiYWNraW5nIGRldmljZSAq LwpAQCAtMTExNSw3ICsxMTE1LDcgQEAgc3RhdGljIHZvaWQgZGV0YWNoZWRfZGV2X2RvX3JlcXVl c3Qoc3RydWN0IGJjYWNoZV9kZXZpY2UgKmQsIHN0cnVjdCBiaW8gKmJpbywKIAliaW8tPmJpX3By aXZhdGUgPSBkZGlwOwogCiAJaWYgKChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYK LQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2KSkpCisJICAg ICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGMtPmJkZXYpKQogCQliaW8tPmJpX2VuZF9pbyhi aW8pOwogCWVsc2UKIAkJc3VibWl0X2Jpb19ub2FjY3QoYmlvKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWQvYmNhY2hlL3N1cGVyLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zdXBlci5jCmluZGV4IGJm M2RlMTQ5ZDNjOWYuLjJmNDllMzExNDJmNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hl L3N1cGVyLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYwpAQCAtOTczLDcgKzk3Myw2 IEBAIHN0YXRpYyBpbnQgYmNhY2hlX2RldmljZV9pbml0KHN0cnVjdCBiY2FjaGVfZGV2aWNlICpk LCB1bnNpZ25lZCBpbnQgYmxvY2tfc2l6ZSwKIAogCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX05PTlJPVCwgZC0+ZGlzay0+cXVldWUpOwogCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfQUREX1JBTkRPTSwgZC0+ZGlzay0+cXVldWUpOwotCWJsa19xdWV1ZV9mbGFnX3NldChR VUVVRV9GTEFHX0RJU0NBUkQsIGQtPmRpc2stPnF1ZXVlKTsKIAogCWJsa19xdWV1ZV93cml0ZV9j YWNoZShxLCB0cnVlLCB0cnVlKTsKIApAQCAtMjM1MCw3ICsyMzQ5LDcgQEAgc3RhdGljIGludCBy ZWdpc3Rlcl9jYWNoZShzdHJ1Y3QgY2FjaGVfc2IgKnNiLCBzdHJ1Y3QgY2FjaGVfc2JfZGlzayAq c2JfZGlzaywKIAljYS0+YmRldi0+YmRfaG9sZGVyID0gY2E7CiAJY2EtPnNiX2Rpc2sgPSBzYl9k aXNrOwogCi0JaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSkKKwlp ZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKChiZGV2KSkpCiAJCWNhLT5kaXNjYXJkID0gQ0FD SEVfRElTQ0FSRCgmY2EtPnNiKTsKIAogCXJldCA9IGNhY2hlX2FsbG9jKGNhKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWQvYmNhY2hlL3N5c2ZzLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zeXNmcy5j CmluZGV4IGQxMDI5ZDcxZmYzYmMuLmM2ZjY3NzA1OTIxNGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWQvYmNhY2hlL3N5c2ZzLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3lzZnMuYwpAQCAtMTE1 MSw3ICsxMTUxLDcgQEAgU1RPUkUoX19iY2hfY2FjaGUpCiAJaWYgKGF0dHIgPT0gJnN5c2ZzX2Rp c2NhcmQpIHsKIAkJYm9vbCB2ID0gc3RydG91bF9vcl9yZXR1cm4oYnVmKTsKIAotCQlpZiAoYmxr X3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoY2EtPmJkZXYpKSkKKwkJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhjYS0+YmRldikpCiAJCQljYS0+ZGlzY2FyZCA9IHY7CiAKIAkJaWYg KHYgIT0gQ0FDSEVfRElTQ0FSRCgmY2EtPnNiKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9k bS1jYWNoZS10YXJnZXQuYyBiL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMKaW5kZXggNzgw YTYxYmM2Y2MwMy4uMjhjNWRlOGVjYTRhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1jYWNo ZS10YXJnZXQuYworKysgYi9kcml2ZXJzL21kL2RtLWNhY2hlLXRhcmdldC5jCkBAIC0zMzI5LDEz ICszMzI5LDYgQEAgc3RhdGljIGludCBjYWNoZV9pdGVyYXRlX2RldmljZXMoc3RydWN0IGRtX3Rh cmdldCAqdGksCiAJcmV0dXJuIHI7CiB9CiAKLXN0YXRpYyBib29sIG9yaWdpbl9kZXZfc3VwcG9y dHNfZGlzY2FyZChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpvcmlnaW5fYmRldikKLXsKLQlzdHJ1Y3Qg cmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKG9yaWdpbl9iZGV2KTsKLQotCXJldHVy biBibGtfcXVldWVfZGlzY2FyZChxKTsKLX0KLQogLyoKICAqIElmIGRpc2NhcmRfcGFzc2Rvd24g d2FzIGVuYWJsZWQgdmVyaWZ5IHRoYXQgdGhlIG9yaWdpbiBkZXZpY2UKICAqIHN1cHBvcnRzIGRp c2NhcmRzLiAgRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlmIG5vdC4KQEAgLTMzNDksNyArMzM0 Miw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25faWZfbm90X3N1cHBvcnRlZChzdHJ1 Y3QgY2FjaGUgKmNhY2hlKQogCWlmICghY2FjaGUtPmZlYXR1cmVzLmRpc2NhcmRfcGFzc2Rvd24p CiAJCXJldHVybjsKIAotCWlmICghb3JpZ2luX2Rldl9zdXBwb3J0c19kaXNjYXJkKG9yaWdpbl9i ZGV2KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhvcmlnaW5fYmRldikpCiAJCXJl YXNvbiA9ICJkaXNjYXJkIHVuc3VwcG9ydGVkIjsKIAogCWVsc2UgaWYgKG9yaWdpbl9saW1pdHMt Pm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjYWNoZS0+c2VjdG9yc19wZXJfYmxvY2spCmRpZmYgLS1n aXQgYS9kcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jIGIvZHJpdmVycy9tZC9kbS1jbG9uZS10 YXJnZXQuYwppbmRleCAxMjgzMTZhNzNkMDE2Li44MTFiMGE1Mzc5ZDAzIDEwMDY0NAotLS0gYS9k cml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tY2xvbmUtdGFy Z2V0LmMKQEAgLTIwMTYsMTMgKzIwMTYsNiBAQCBzdGF0aWMgdm9pZCBjbG9uZV9yZXN1bWUoc3Ry dWN0IGRtX3RhcmdldCAqdGkpCiAJZG9fd2FrZXIoJmNsb25lLT53YWtlci53b3JrKTsKIH0KIAot c3RhdGljIGJvb2wgYmRldl9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2KQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoYmRldik7 Ci0KLQlyZXR1cm4gKHEgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQocSkpOwotfQotCiAvKgogICogSWYg ZGlzY2FyZF9wYXNzZG93biB3YXMgZW5hYmxlZCB2ZXJpZnkgdGhhdCB0aGUgZGVzdGluYXRpb24g ZGV2aWNlIHN1cHBvcnRzCiAgKiBkaXNjYXJkcy4gRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlm IG5vdC4KQEAgLTIwMzYsNyArMjAyOSw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25f aWZfbm90X3N1cHBvcnRlZChzdHJ1Y3QgY2xvbmUgKmNsb25lKQogCWlmICghdGVzdF9iaXQoRE1f Q0xPTkVfRElTQ0FSRF9QQVNTRE9XTiwgJmNsb25lLT5mbGFncykpCiAJCXJldHVybjsKIAotCWlm ICghYmRldl9zdXBwb3J0c19kaXNjYXJkcyhkZXN0X2RldikpCisJaWYgKCFiZGV2X21heF9kaXNj YXJkX3NlY3RvcnMoZGVzdF9kZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAJZWxzZSBpZiAoZGVzdF9saW1pdHMtPm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjbG9uZS0+cmVn aW9uX3NpemUpCiAJCXJlYXNvbiA9ICJtYXggZGlzY2FyZCBzZWN0b3JzIHNtYWxsZXIgdGhhbiBh IHJlZ2lvbiI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy13cml0ZXMuYyBiL2RyaXZl cnMvbWQvZG0tbG9nLXdyaXRlcy5jCmluZGV4IGM5ZDAzNmQ2YmIyZWUuLmUxOTQyMjZjODllNTQg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tbG9nLXdyaXRlcy5jCisrKyBiL2RyaXZlcnMvbWQv ZG0tbG9nLXdyaXRlcy5jCkBAIC04NjYsOSArODY2LDggQEAgc3RhdGljIGludCBsb2dfd3JpdGVz X21lc3NhZ2Uoc3RydWN0IGRtX3RhcmdldCAqdGksIHVuc2lnbmVkIGFyZ2MsIGNoYXIgKiphcmd2 LAogc3RhdGljIHZvaWQgbG9nX3dyaXRlc19pb19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRzKQogewogCXN0cnVjdCBsb2dfd3JpdGVzX2MgKmxj ID0gdGktPnByaXZhdGU7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1 ZShsYy0+ZGV2LT5iZGV2KTsKIAotCWlmICghcSB8fCAhYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsK KwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhsYy0+ZGV2LT5iZGV2KSkgewogCQlsYy0+ ZGV2aWNlX3N1cHBvcnRzX2Rpc2NhcmQgPSBmYWxzZTsKIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51 bGFyaXR5ID0gbGMtPnNlY3RvcnNpemU7CiAJCWxpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA9 IChVSU5UX01BWCA+PiBTRUNUT1JfU0hJRlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1y YWlkLmMgYi9kcml2ZXJzL21kL2RtLXJhaWQuYwppbmRleCAyYjI2NDM1YTY5NDZlLi45NTI2Y2Ni ZWRhZmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXJhaWQuYworKysgYi9kcml2ZXJzL21k L2RtLXJhaWQuYwpAQCAtMjk2MywxMyArMjk2Myw4IEBAIHN0YXRpYyB2b2lkIGNvbmZpZ3VyZV9k aXNjYXJkX3N1cHBvcnQoc3RydWN0IHJhaWRfc2V0ICpycykKIAlyYWlkNDU2ID0gcnNfaXNfcmFp ZDQ1Nihycyk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcnMtPnJhaWRfZGlza3M7IGkrKykgewotCQlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcTsKLQotCQlpZiAoIXJzLT5kZXZbaV0ucmRldi5iZGV2KQot CQkJY29udGludWU7Ci0KLQkJcSA9IGJkZXZfZ2V0X3F1ZXVlKHJzLT5kZXZbaV0ucmRldi5iZGV2 KTsKLQkJaWYgKCFxIHx8ICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwkJaWYgKCFycy0+ZGV2W2ld LnJkZXYuYmRldiB8fAorCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhycy0+ZGV2W2ld LnJkZXYuYmRldikpCiAJCQlyZXR1cm47CiAKIAkJaWYgKHJhaWQ0NTYpIHsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWQvZG0tdGFibGUuYyBiL2RyaXZlcnMvbWQvZG0tdGFibGUuYwppbmRleCBkNDY4 MzlmYWEwY2E1Li4wZGZmNjkwN2ZkMDBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXRhYmxl LmMKKysrIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCkBAIC0xODg4LDkgKzE4ODgsNyBAQCBzdGF0 aWMgYm9vbCBkbV90YWJsZV9zdXBwb3J0c19ub3dhaXQoc3RydWN0IGRtX3RhYmxlICp0KQogc3Rh dGljIGludCBkZXZpY2Vfbm90X2Rpc2NhcmRfY2FwYWJsZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IGRtX2RldiAqZGV2LAogCQkJCSAgICAgIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBs ZW4sIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9x dWV1ZShkZXYtPmJkZXYpOwotCi0JcmV0dXJuICFibGtfcXVldWVfZGlzY2FyZChxKTsKKwlyZXR1 cm4gIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPmJkZXYpOwogfQogCiBzdGF0aWMgYm9v bCBkbV90YWJsZV9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgZG1fdGFibGUgKnQpCkBAIC0xOTcw LDE1ICsxOTY4LDEyIEBAIGludCBkbV90YWJsZV9zZXRfcmVzdHJpY3Rpb25zKHN0cnVjdCBkbV90 YWJsZSAqdCwgc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsCiAJCWJsa19xdWV1ZV9mbGFnX2NsZWFy KFFVRVVFX0ZMQUdfTk9XQUlULCBxKTsKIAogCWlmICghZG1fdGFibGVfc3VwcG9ydHNfZGlzY2Fy ZHModCkpIHsKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsK LQkJLyogTXVzdCBhbHNvIGNsZWFyIGRpc2NhcmQgbGltaXRzLi4uICovCiAJCXEtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzID0gMDsKIAkJcS0+bGltaXRzLm1heF9od19kaXNjYXJkX3NlY3Rv cnMgPSAwOwogCQlxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IDA7CiAJCXEtPmxpbWl0 cy5kaXNjYXJkX2FsaWdubWVudCA9IDA7CiAJCXEtPmxpbWl0cy5kaXNjYXJkX21pc2FsaWduZWQg PSAwOwotCX0gZWxzZQotCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBx KTsKKwl9CiAKIAlpZiAoZG1fdGFibGVfc3VwcG9ydHNfc2VjdXJlX2VyYXNlKHQpKQogCQlibGtf cXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19TRUNFUkFTRSwgcSk7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kL2RtLXRoaW4uYyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCmluZGV4IDRkMjVkMGUyNzAz MTMuLmVkZWQ0YmNjNDU0NWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGhpbi5jCisrKyBi L2RyaXZlcnMvbWQvZG0tdGhpbi5jCkBAIC0yODAyLDEzICsyODAyLDYgQEAgc3RhdGljIHZvaWQg cmVxdWV1ZV9iaW9zKHN0cnVjdCBwb29sICpwb29sKQogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBCaW5kaW5nIG9m IGNvbnRyb2wgdGFyZ2V0cyB0byBhIHBvb2wgb2JqZWN0CiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLXN0YXRpYyBib29s IGRhdGFfZGV2X3N1cHBvcnRzX2Rpc2NhcmQoc3RydWN0IHBvb2xfYyAqcHQpCi17Ci0Jc3RydWN0 IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShwdC0+ZGF0YV9kZXYtPmJkZXYpOwot Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKHEpOwotfQotCiBzdGF0aWMgYm9vbCBpc19mYWN0 b3Ioc2VjdG9yX3QgYmxvY2tfc2l6ZSwgdWludDMyX3QgbikKIHsKIAlyZXR1cm4gIXNlY3Rvcl9k aXYoYmxvY2tfc2l6ZSwgbik7CkBAIC0yODI4LDcgKzI4MjEsNyBAQCBzdGF0aWMgdm9pZCBkaXNh YmxlX3Bhc3Nkb3duX2lmX25vdF9zdXBwb3J0ZWQoc3RydWN0IHBvb2xfYyAqcHQpCiAJaWYgKCFw dC0+YWRqdXN0ZWRfcGYuZGlzY2FyZF9wYXNzZG93bikKIAkJcmV0dXJuOwogCi0JaWYgKCFkYXRh X2Rldl9zdXBwb3J0c19kaXNjYXJkKHB0KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhwdC0+ZGF0YV9kZXYtPmJkZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAKIAllbHNlIGlmIChkYXRhX2xpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA8IHBvb2wtPnNl Y3RvcnNfcGVyX2Jsb2NrKQpAQCAtNDA1Nyw4ICs0MDUwLDYgQEAgc3RhdGljIHZvaWQgcG9vbF9p b19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgc3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRz KQogCQkvKgogCQkgKiBNdXN0IGV4cGxpY2l0bHkgZGlzYWxsb3cgc3RhY2tpbmcgZGlzY2FyZCBs aW1pdHMgb3RoZXJ3aXNlIHRoZQogCQkgKiBibG9jayBsYXllciB3aWxsIHN0YWNrIHRoZW0gaWYg cG9vbCdzIGRhdGEgZGV2aWNlIGhhcyBzdXBwb3J0LgotCQkgKiBRVUVVRV9GTEFHX0RJU0NBUkQg d291bGRuJ3QgYmUgc2V0IGJ1dCB0aGVyZSBpcyBubyB3YXkgZm9yIHRoZQotCQkgKiB1c2VyIHRv IHNlZSB0aGF0LCBzbyBtYWtlIHN1cmUgdG8gc2V0IGFsbCBkaXNjYXJkIGxpbWl0cyB0byAwLgog CQkgKi8KIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJcmV0dXJuOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9tZC9kbS5jIGIvZHJpdmVycy9tZC9kbS5jCmluZGV4IDNjNWZhZDdj NGVlNjguLmRiYmY2NGNlN2U5MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0uYworKysgYi9k cml2ZXJzL21kL2RtLmMKQEAgLTk1NSw3ICs5NTUsNiBAQCB2b2lkIGRpc2FibGVfZGlzY2FyZChz dHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCiAKIAkvKiBkZXZpY2UgZG9lc24ndCByZWFsbHkgc3Vw cG9ydCBESVNDQVJELCBkaXNhYmxlIGl0ICovCiAJbGltaXRzLT5tYXhfZGlzY2FyZF9zZWN0b3Jz ID0gMDsKLQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIG1kLT5xdWV1 ZSk7CiB9CiAKIHZvaWQgZGlzYWJsZV93cml0ZV96ZXJvZXMoc3RydWN0IG1hcHBlZF9kZXZpY2Ug Km1kKQpAQCAtOTgyLDcgKzk4MSw3IEBAIHN0YXRpYyB2b2lkIGNsb25lX2VuZGlvKHN0cnVjdCBi aW8gKmJpbykKIAogCWlmICh1bmxpa2VseShlcnJvciA9PSBCTEtfU1RTX1RBUkdFVCkpIHsKIAkJ aWYgKGJpb19vcChiaW8pID09IFJFUV9PUF9ESVNDQVJEICYmCi0JCSAgICAhcS0+bGltaXRzLm1h eF9kaXNjYXJkX3NlY3RvcnMpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+ YmlfYmRldikpCiAJCQlkaXNhYmxlX2Rpc2NhcmQobWQpOwogCQllbHNlIGlmIChiaW9fb3AoYmlv KSA9PSBSRVFfT1BfV1JJVEVfWkVST0VTICYmCiAJCQkgIXEtPmxpbWl0cy5tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLWxpbmVhci5jIGIvZHJpdmVy cy9tZC9tZC1saW5lYXIuYwppbmRleCAwZjU1YjA3OTM3MWIxLi4xMzhhM2IyNWM1YzgyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kL21kLWxpbmVhci5jCisrKyBiL2RyaXZlcnMvbWQvbWQtbGluZWFy LmMKQEAgLTY0LDcgKzY0LDYgQEAgc3RhdGljIHN0cnVjdCBsaW5lYXJfY29uZiAqbGluZWFyX2Nv bmYoc3RydWN0IG1kZGV2ICptZGRldiwgaW50IHJhaWRfZGlza3MpCiAJc3RydWN0IGxpbmVhcl9j b25mICpjb25mOwogCXN0cnVjdCBtZF9yZGV2ICpyZGV2OwogCWludCBpLCBjbnQ7Ci0JYm9vbCBk aXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJY29uZiA9IGt6YWxsb2Moc3RydWN0X3NpemUo Y29uZiwgZGlza3MsIHJhaWRfZGlza3MpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWNvbmYpCkBAIC05 Niw5ICs5NSw2IEBAIHN0YXRpYyBzdHJ1Y3QgbGluZWFyX2NvbmYgKmxpbmVhcl9jb25mKHN0cnVj dCBtZGRldiAqbWRkZXYsIGludCByYWlkX2Rpc2tzKQogCiAJCWNvbmYtPmFycmF5X3NlY3RvcnMg Kz0gcmRldi0+c2VjdG9yczsKIAkJY250Kys7Ci0KLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJk ZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsK IAl9CiAJaWYgKGNudCAhPSByYWlkX2Rpc2tzKSB7CiAJCXByX3dhcm4oIm1kL2xpbmVhcjolczog bm90IGVub3VnaCBkcml2ZXMgcHJlc2VudC4gQWJvcnRpbmchXG4iLApAQCAtMTA2LDExICsxMDIs NiBAQCBzdGF0aWMgc3RydWN0IGxpbmVhcl9jb25mICpsaW5lYXJfY29uZihzdHJ1Y3QgbWRkZXYg Km1kZGV2LCBpbnQgcmFpZF9kaXNrcykKIAkJZ290byBvdXQ7CiAJfQogCi0JaWYgKCFkaXNjYXJk X3N1cHBvcnRlZCkKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBt ZGRldi0+cXVldWUpOwotCWVsc2UKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElT Q0FSRCwgbWRkZXYtPnF1ZXVlKTsKLQogCS8qCiAJICogSGVyZSB3ZSBjYWxjdWxhdGUgdGhlIGRl dmljZSBvZmZzZXRzLgogCSAqLwpAQCAtMjUyLDcgKzI0Myw3IEBAIHN0YXRpYyBib29sIGxpbmVh cl9tYWtlX3JlcXVlc3Qoc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IGJpbyAqYmlvKQogCQlz dGFydF9zZWN0b3IgKyBkYXRhX29mZnNldDsKIAogCWlmICh1bmxpa2VseSgoYmlvX29wKGJpbykg PT0gUkVRX09QX0RJU0NBUkQpICYmCi0JCSAgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkgeworCQkgICAgICFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoYmlvLT5iaV9iZGV2KSkpIHsKIAkJLyogSnVzdCBpZ25vcmUgaXQgKi8KIAkJYmlvX2VuZGlv KGJpbyk7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDAuYyBiL2RyaXZl cnMvbWQvcmFpZDAuYwppbmRleCBiMjFlMTAxMTgzZjQ0Li43MjMxZjVlMWVhYTczIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQwLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMC5jCkBAIC0zOTks NyArMzk5LDYgQEAgc3RhdGljIGludCByYWlkMF9ydW4oc3RydWN0IG1kZGV2ICptZGRldikKIAlj b25mID0gbWRkZXYtPnByaXZhdGU7CiAJaWYgKG1kZGV2LT5xdWV1ZSkgewogCQlzdHJ1Y3QgbWRf cmRldiAqcmRldjsKLQkJYm9vbCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJCWJsa19x dWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2LT5jaHVua19zZWN0b3JzKTsK IAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2 LT5jaHVua19zZWN0b3JzKTsKQEAgLTQxMiwxMyArNDExLDcgQEAgc3RhdGljIGludCByYWlkMF9y dW4oc3RydWN0IG1kZGV2ICptZGRldikKIAkJcmRldl9mb3JfZWFjaChyZGV2LCBtZGRldikgewog CQkJZGlza19zdGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJCSAg cmRldi0+ZGF0YV9vZmZzZXQgPDwgOSk7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUocmRldi0+YmRldikpKQotCQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJ fQotCQlpZiAoIWRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVF VUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwotCQllbHNlCi0JCQlibGtfcXVldWVfZmxh Z19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCX0KIAogCS8qIGNhbGN1 bGF0ZSBhcnJheSBkZXZpY2Ugc2l6ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkMS5j IGIvZHJpdmVycy9tZC9yYWlkMS5jCmluZGV4IGQ4MWI4OTY4NTVmOWYuLjNkYTc0OWQxNTBhMTcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDEuYworKysgYi9kcml2ZXJzL21kL3JhaWQxLmMK QEAgLTgwMiw3ICs4MDIsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9iaW9fbGlzdChzdHJ1Y3QgcjFj b25mICpjb25mLCBzdHJ1Y3QgYmlvICpiaW8pCiAJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2 LT5mbGFncykpIHsKIAkJCWJpb19pb19lcnJvcihiaW8pOwogCQl9IGVsc2UgaWYgKHVubGlrZWx5 KChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9k aXNjYXJkKGJpby0+YmlfYmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICov CiAJCQliaW9fZW5kaW8oYmlvKTsKIAkJZWxzZQpAQCAtMTgyNiw4ICsxODI2LDYgQEAgc3RhdGlj IGludCByYWlkMV9hZGRfZGlzayhzdHJ1Y3QgbWRkZXYgKm1kZGV2LCBzdHJ1Y3QgbWRfcmRldiAq cmRldikKIAkJCWJyZWFrOwogCQl9CiAJfQotCWlmIChtZGRldi0+cXVldWUgJiYgYmxrX3F1ZXVl X2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQotCQlibGtfcXVldWVfZmxhZ19z ZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCXByaW50X2NvbmYoY29uZik7 CiAJcmV0dXJuIGVycjsKIH0KQEAgLTMxMDYsNyArMzEwNCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFf cnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJaW50IGk7CiAJc3RydWN0IG1kX3JkZXYgKnJkZXY7 CiAJaW50IHJldDsKLQlib29sIGRpc2NhcmRfc3VwcG9ydGVkID0gZmFsc2U7CiAKIAlpZiAobWRk ZXYtPmxldmVsICE9IDEpIHsKIAkJcHJfd2FybigibWQvcmFpZDE6JXM6IHJhaWQgbGV2ZWwgbm90 IHNldCB0byBtaXJyb3JpbmcgKCVkKVxuIiwKQEAgLTMxNDEsOCArMzEzOCw2IEBAIHN0YXRpYyBp bnQgcmFpZDFfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQljb250aW51ZTsKIAkJZGlza19z dGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJICByZGV2LT5kYXRh X29mZnNldCA8PCA5KTsKLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJk ZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAl9CiAKIAltZGRldi0+ ZGVncmFkZWQgPSAwOwpAQCAtMzE3OSwxNSArMzE3NCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFfcnVu KHN0cnVjdCBtZGRldiAqbWRkZXYpCiAKIAltZF9zZXRfYXJyYXlfc2VjdG9ycyhtZGRldiwgcmFp ZDFfc2l6ZShtZGRldiwgMCwgMCkpOwogCi0JaWYgKG1kZGV2LT5xdWV1ZSkgewotCQlpZiAoZGlz Y2FyZF9zdXBwb3J0ZWQpCi0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJE LAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIo UVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJICBtZGRldi0+cXVldWUpOwotCX0KLQogCXJldCA9 IG1kX2ludGVncml0eV9yZWdpc3RlcihtZGRldik7CiAJaWYgKHJldCkgewogCQltZF91bnJlZ2lz dGVyX3RocmVhZCgmbWRkZXYtPnRocmVhZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQx MC5jIGIvZHJpdmVycy9tZC9yYWlkMTAuYwppbmRleCA3ODE2YzhiMmU4MDg3Li4zNmE0NjAwMTVj ZjU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxMC5jCisrKyBiL2RyaXZlcnMvbWQvcmFp ZDEwLmMKQEAgLTg4OCw3ICs4ODgsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9wZW5kaW5nX3dyaXRl cyhzdHJ1Y3QgcjEwY29uZiAqY29uZikKIAkJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5m bGFncykpIHsKIAkJCQliaW9faW9fZXJyb3IoYmlvKTsKIAkJCX0gZWxzZSBpZiAodW5saWtlbHko KGJpb19vcChiaW8pID09ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkJICAgICFibGtfcXVldWVf ZGlzY2FyZChiaW8tPmJpX2JkZXYtPmJkX2Rpc2stPnF1ZXVlKSkpCisJCQkJCSAgICAhYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+YmlfYmRldikpKQogCQkJCS8qIEp1c3QgaWdub3JlIGl0 ICovCiAJCQkJYmlvX2VuZGlvKGJpbyk7CiAJCQllbHNlCkBAIC0xMDgzLDcgKzEwODMsNyBAQCBz dGF0aWMgdm9pZCByYWlkMTBfdW5wbHVnKHN0cnVjdCBibGtfcGx1Z19jYiAqY2IsIGJvb2wgZnJv bV9zY2hlZHVsZSkKIAkJaWYgKHRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkgewogCQkJ YmlvX2lvX2Vycm9yKGJpbyk7CiAJCX0gZWxzZSBpZiAodW5saWtlbHkoKGJpb19vcChiaW8pID09 ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICovCiAJCQliaW9fZW5kaW8o YmlvKTsKIAkJZWxzZQpAQCAtMjE0NCw4ICsyMTQ0LDYgQEAgc3RhdGljIGludCByYWlkMTBfYWRk X2Rpc2soc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IG1kX3JkZXYgKnJkZXYpCiAJCXJjdV9h c3NpZ25fcG9pbnRlcihwLT5yZGV2LCByZGV2KTsKIAkJYnJlYWs7CiAJfQotCWlmIChtZGRldi0+ cXVldWUgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQot CQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwog CiAJcHJpbnRfY29uZihjb25mKTsKIAlyZXR1cm4gZXJyOwpAQCAtNDA2OSw3ICs0MDY3LDYgQEAg c3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJc2VjdG9yX3Qgc2l6 ZTsKIAlzZWN0b3JfdCBtaW5fb2Zmc2V0X2RpZmYgPSAwOwogCWludCBmaXJzdCA9IDE7Ci0JYm9v bCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJaWYgKG1kZGV2X2luaXRfd3JpdGVzX3Bl bmRpbmcobWRkZXYpIDwgMCkKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC00MTQwLDIwICs0MTM3LDkg QEAgc3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQkJCSAgcmRl di0+ZGF0YV9vZmZzZXQgPDwgOSk7CiAKIAkJZGlzay0+aGVhZF9wb3NpdGlvbiA9IDA7Ci0KLQkJ aWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRp c2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJZmlyc3QgPSAwOwogCX0KIAotCWlmIChtZGRldi0+ cXVldWUpIHsKLQkJaWYgKGRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCW1kZGV2LT5xdWV1ZSk7Ci0JCWVsc2UKLQkJCWJs a19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCSAgbWRkZXYtPnF1 ZXVlKTsKLQl9CiAJLyogbmVlZCB0byBjaGVjayB0aGF0IGV2ZXJ5IGJsb2NrIGhhcyBhdCBsZWFz dCBvbmUgd29ya2luZyBtaXJyb3IgKi8KIAlpZiAoIWVub3VnaChjb25mLCAtMSkpIHsKIAkJcHJf ZXJyKCJtZC9yYWlkMTA6JXM6IG5vdCBlbm91Z2ggb3BlcmF0aW9uYWwgbWlycm9ycy5cbiIsCmRp ZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQ1LWNhY2hlLmMgYi9kcml2ZXJzL21kL3JhaWQ1LWNh Y2hlLmMKaW5kZXggYTdkNTBmZjkwMjBhOC4uYzNjYmY5YTU3NGEzOSAxMDA2NDQKLS0tIGEvZHJp dmVycy9tZC9yYWlkNS1jYWNoZS5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDUtY2FjaGUuYwpAQCAt MTMxOCw3ICsxMzE4LDcgQEAgc3RhdGljIHZvaWQgcjVsX3dyaXRlX3N1cGVyX2FuZF9kaXNjYXJk X3NwYWNlKHN0cnVjdCByNWxfbG9nICpsb2csCiAKIAlyNWxfd3JpdGVfc3VwZXIobG9nLCBlbmQp OwogCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShiZGV2KSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCXJldHVybjsKIAogCW1kZGV2ID0g bG9nLT5yZGV2LT5tZGRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDUuYyBiL2RyaXZl cnMvbWQvcmFpZDUuYwppbmRleCAwYmJhZTBlNjM4NjY2Li41OWY5MWUzOTJhMmFlIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQ1LmMKKysrIGIvZHJpdmVycy9tZC9yYWlkNS5jCkBAIC03Nzc2 LDE0ICs3Nzc2LDEwIEBAIHN0YXRpYyBpbnQgcmFpZDVfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYp CiAJCSAqIEEgYmV0dGVyIGlkZWEgbWlnaHQgYmUgdG8gdHVybiBESVNDQVJEIGludG8gV1JJVEVf WkVST0VTCiAJCSAqIHJlcXVlc3RzLCBhcyB0aGF0IGlzIHJlcXVpcmVkIHRvIGJlIHNhZmUuCiAJ CSAqLwotCQlpZiAoZGV2aWNlc19oYW5kbGVfZGlzY2FyZF9zYWZlbHkgJiYKLQkJICAgIG1kZGV2 LT5xdWV1ZS0+bGltaXRzLm1heF9kaXNjYXJkX3NlY3RvcnMgPj0gKHN0cmlwZSA+PiA5KSAmJgot CQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA+PSBzdHJpcGUp Ci0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJbWRkZXYt PnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVND QVJELAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKKwkJaWYgKCFkZXZpY2VzX2hhbmRsZV9kaXNjYXJk X3NhZmVseSB8fAorCQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9y cyA8IChzdHJpcGUgPj4gOSkgfHwKKwkJICAgIG1kZGV2LT5xdWV1ZS0+bGltaXRzLmRpc2NhcmRf Z3JhbnVsYXJpdHkgPCBzdHJpcGUpCisJCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyht ZGRldi0+cXVldWUsIDApOwogCiAJCWJsa19xdWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVl dWUsIFVJTlRfTUFYKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMg Yi9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMKaW5kZXggYzY5YjJkOWRmNmYxNi4uY2FjNjMxNTAx MGEzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9xdWV1ZS5jCisrKyBiL2RyaXZlcnMv bW1jL2NvcmUvcXVldWUuYwpAQCAtMTgzLDcgKzE4Myw2IEBAIHN0YXRpYyB2b2lkIG1tY19xdWV1 ZV9zZXR1cF9kaXNjYXJkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLAogCWlmICghbWF4X2Rpc2Nh cmQpCiAJCXJldHVybjsKIAotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFHX0RJU0NBUkQs IHEpOwogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIG1heF9kaXNjYXJkKTsKIAlx LT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IGNhcmQtPnByZWZfZXJhc2UgPDwgOTsKIAkv KiBncmFudWxhcml0eSBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gbWF4LiBkaXNjYXJkICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jIGIvZHJpdmVycy9tdGQvbXRkX2Js a2RldnMuYwppbmRleCA2NGQyYjA5M2YxMTRiLi5mNzMxNzIxMTE0NjU1IDEwMDY0NAotLS0gYS9k cml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jCisrKyBiL2RyaXZlcnMvbXRkL210ZF9ibGtkZXZzLmMK QEAgLTM3Nyw3ICszNzcsNiBAQCBpbnQgYWRkX210ZF9ibGt0cmFuc19kZXYoc3RydWN0IG10ZF9i bGt0cmFuc19kZXYgKm5ldykKIAlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0FERF9S QU5ET00sIG5ldy0+cnEpOwogCiAJaWYgKHRyLT5kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFn X3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIG5ldy0+cnEpOwogCQlibGtfcXVldWVfbWF4X2Rpc2Nh cmRfc2VjdG9ycyhuZXctPnJxLCBVSU5UX01BWCk7CiAJCW5ldy0+cnEtPmxpbWl0cy5kaXNjYXJk X2dyYW51bGFyaXR5ID0gdHItPmJsa3NpemU7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l L2hvc3QvY29yZS5jIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCmluZGV4IGVmYjg1YzZkOGUy ZDUuLjdlMDdkZDY5MjYyYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwor KysgYi9kcml2ZXJzL252bWUvaG9zdC9jb3JlLmMKQEAgLTE2MDcsMTAgKzE2MDcsOCBAQCBzdGF0 aWMgdm9pZCBudm1lX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBzdHJ1Y3Qg bnZtZV9ucyAqbnMpCiAJc3RydWN0IHJlcXVlc3RfcXVldWUgKnF1ZXVlID0gZGlzay0+cXVldWU7 CiAJdTMyIHNpemUgPSBxdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUocXVldWUpOwogCi0JaWYgKGN0 cmwtPm1heF9kaXNjYXJkX3NlY3RvcnMgPT0gMCkgewotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKTsKKwlpZiAoY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9y cyA9PSAwKQogCQlyZXR1cm47Ci0JfQogCiAJQlVJTERfQlVHX09OKFBBR0VfU0laRSAvIHNpemVv ZihzdHJ1Y3QgbnZtZV9kc21fcmFuZ2UpIDwKIAkJCU5WTUVfRFNNX01BWF9SQU5HRVMpOwpAQCAt MTYxOSw3ICsxNjE3LDcgQEAgc3RhdGljIHZvaWQgbnZtZV9jb25maWdfZGlzY2FyZChzdHJ1Y3Qg Z2VuZGlzayAqZGlzaywgc3RydWN0IG52bWVfbnMgKm5zKQogCXF1ZXVlLT5saW1pdHMuZGlzY2Fy ZF9ncmFudWxhcml0eSA9IHNpemU7CiAKIAkvKiBJZiBkaXNjYXJkIGlzIGFscmVhZHkgZW5hYmxl ZCwgZG9uJ3QgcmVzZXQgcXVldWUgbGltaXRzICovCi0JaWYgKGJsa19xdWV1ZV9mbGFnX3Rlc3Rf YW5kX3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKSkKKwlpZiAocXVldWUtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzKQogCQlyZXR1cm47CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRf c2VjdG9ycyhxdWV1ZSwgY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9ycyk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3MzOTAvYmxvY2svZGFzZF9mYmEuYyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCmluZGV4IGUwODRmNGRlZGRkZGQuLjhiZDU2NjVkYjkxOTggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvczM5MC9ibG9jay9kYXNkX2ZiYS5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCkBAIC03OTEsNyArNzkxLDYgQEAgc3RhdGljIHZvaWQgZGFzZF9mYmFfc2V0dXBfYmxrX3F1 ZXVlKHN0cnVjdCBkYXNkX2Jsb2NrICpibG9jaykKIAogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9z ZWN0b3JzKHEsIG1heF9kaXNjYXJkX3NlY3RvcnMpOwogCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMocSwgbWF4X2Rpc2NhcmRfc2VjdG9ycyk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBpbnQgZGFzZF9mYmFfcGVfaGFu ZGxlcihzdHJ1Y3QgZGFzZF9kZXZpY2UgKmRldmljZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2Nz aS9zZC5jIGIvZHJpdmVycy9zY3NpL3NkLmMKaW5kZXggYTM5MDY3OWNmNDU4NC4uNDQ0NDc5NjU3 YjdmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NkLmMKKysrIGIvZHJpdmVycy9zY3NpL3Nk LmMKQEAgLTc5Nyw3ICs3OTcsNiBAQCBzdGF0aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1 Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25lZCBpbnQgbW9kZSkKIAljYXNlIFNEX0xCUF9GVUxM OgogCWNhc2UgU0RfTEJQX0RJU0FCTEU6CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3Jz KHEsIDApOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwog CQlyZXR1cm47CiAKIAljYXNlIFNEX0xCUF9VTk1BUDoKQEAgLTgzMCw3ICs4MjksNiBAQCBzdGF0 aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25l ZCBpbnQgbW9kZSkKIAl9CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCBtYXhf YmxvY2tzICogKGxvZ2ljYWxfYmxvY2tfc2l6ZSA+PiA5KSk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBibGtfc3RhdHVzX3Qgc2Rfc2V0 dXBfdW5tYXBfY21uZChzdHJ1Y3Qgc2NzaV9jbW5kICpjbWQpCmRpZmYgLS1naXQgYS9kcml2ZXJz L3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3Jl X2RldmljZS5jCmluZGV4IGMzZTI1YmFjOTBkNTkuLjZjYjlmODc4NDMyNzggMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0 L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC04MzgsNyArODM4LDcgQEAgYm9vbCB0YXJnZXRfY29u ZmlndXJlX3VubWFwX2Zyb21fcXVldWUoc3RydWN0IHNlX2Rldl9hdHRyaWIgKmF0dHJpYiwKIAlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwogCWludCBibG9j a19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmRldik7CiAKLQlpZiAoIWJsa19xdWV1 ZV9kaXNjYXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQly ZXR1cm4gZmFsc2U7CiAKIAlhdHRyaWItPm1heF91bm1hcF9sYmFfY291bnQgPQpkaWZmIC0tZ2l0 IGEvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKaW5kZXgg ZjQ3NzAzNWEyYWMyMy4uZWZkOGRlYjNhYjdlOCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50 LXRyZWUuYworKysgYi9mcy9idHJmcy9leHRlbnQtdHJlZS5jCkBAIC0xMjkxLDcgKzEyOTEsNyBA QCBzdGF0aWMgaW50IGRvX2Rpc2NhcmRfZXh0ZW50KHN0cnVjdCBidHJmc19pb19zdHJpcGUgKnN0 cmlwZSwgdTY0ICpieXRlcykKIAkJcmV0ID0gYnRyZnNfcmVzZXRfZGV2aWNlX3pvbmUoZGV2X3Jl cGxhY2UtPnRndGRldiwgcGh5cywgbGVuLAogCQkJCQkgICAgICAmZGlzY2FyZGVkKTsKIAkJZGlz Y2FyZGVkICs9IHNyY19kaXNjOwotCX0gZWxzZSBpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUoc3RyaXBlLT5kZXYtPmJkZXYpKSkgeworCX0gZWxzZSBpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHN0cmlwZS0+ZGV2LT5iZGV2KSkgewogCQlyZXQgPSBidHJmc19pc3N1ZV9k aXNjYXJkKGRldi0+YmRldiwgcGh5cywgbGVuLCAmZGlzY2FyZGVkKTsKIAl9IGVsc2UgewogCQly ZXQgPSAwOwpAQCAtNTk4Nyw3ICs1OTg3LDcgQEAgc3RhdGljIGludCBidHJmc190cmltX2ZyZWVf ZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2UsIHU2NCAqdHJpbW1lZCkKIAkqdHJp bW1lZCA9IDA7CiAKIAkvKiBEaXNjYXJkIG5vdCBzdXBwb3J0ZWQgPSBub3RoaW5nIHRvIGRvLiAq LwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoZGV2aWNlLT5iZGV2KSkp CisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGV2aWNlLT5iZGV2KSkKIAkJcmV0dXJu IDA7CiAKIAkvKiBOb3Qgd3JpdGFibGUgPSBub3RoaW5nIHRvIGRvLiAqLwpkaWZmIC0tZ2l0IGEv ZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggZjQ2ZTcxMDYxOTQyZC4u MDk2YmIwZGEwM2YxYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJm cy9pb2N0bC5jCkBAIC01MDEsNyArNTAxLDcgQEAgc3RhdGljIG5vaW5saW5lIGludCBidHJmc19p b2N0bF9maXRyaW0oc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8sCiAJCWlmICghZGV2aWNl LT5iZGV2KQogCQkJY29udGludWU7CiAJCXEgPSBiZGV2X2dldF9xdWV1ZShkZXZpY2UtPmJkZXYp OwotCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwkJaWYgKGJkZXZfbWF4X2Rpc2NhcmRf c2VjdG9ycyhkZXZpY2UtPmJkZXYpKSB7CiAJCQludW1fZGV2aWNlcysrOwogCQkJbWlubGVuID0g bWluX3QodTY0LCBxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSwKIAkJCQkgICAgIG1pbmxl bik7CmRpZmYgLS1naXQgYS9mcy9leGZhdC9maWxlLmMgYi9mcy9leGZhdC9maWxlLmMKaW5kZXgg MmY1MTMwMDU5MjM2Ni4uNzY1ZTRmNjNkZDE4ZCAxMDA2NDQKLS0tIGEvZnMvZXhmYXQvZmlsZS5j CisrKyBiL2ZzL2V4ZmF0L2ZpbGUuYwpAQCAtMzU4LDcgKzM1OCw3IEBAIHN0YXRpYyBpbnQgZXhm YXRfaW9jdGxfZml0cmltKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHVuc2lnbmVkIGxvbmcgYXJnKQog CWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0dXJuIC1FUEVSTTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoaW5v ZGUtPmlfc2ItPnNfYmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zy b21fdXNlcigmcmFuZ2UsIChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZywgc2l6ZW9m KHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy9leGZhdC9zdXBlci5jIGIvZnMvZXhmYXQvc3VwZXIu YwppbmRleCA4Y2EyMWU3OTE3ZDE2Li5iZTA3ODhlY2FmMjBlIDEwMDY0NAotLS0gYS9mcy9leGZh dC9zdXBlci5jCisrKyBiL2ZzL2V4ZmF0L3N1cGVyLmMKQEAgLTYyNywxMyArNjI3LDkgQEAgc3Rh dGljIGludCBleGZhdF9maWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBm c19jb250ZXh0ICpmYykKIAlpZiAob3B0cy0+YWxsb3dfdXRpbWUgPT0gKHVuc2lnbmVkIHNob3J0 KS0xKQogCQlvcHRzLT5hbGxvd191dGltZSA9IH5vcHRzLT5mc19kbWFzayAmIDAwMjI7CiAKLQlp ZiAob3B0cy0+ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0 X3F1ZXVlKHNiLT5zX2JkZXYpOwotCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJ CWV4ZmF0X3dhcm4oc2IsICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRo ZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JCQlvcHRzLT5kaXNjYXJkID0g MDsKLQkJfQorCWlmIChvcHRzLT5kaXNjYXJkICYmICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMo c2ItPnNfYmRldikpIHsKKwkJZXhmYXRfd2FybihzYiwgIm1vdW50aW5nIHdpdGggXCJkaXNjYXJk XCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2NhcmQiKTsKKwkJ b3B0cy0+ZGlzY2FyZCA9IDA7CiAJfQogCiAJc2ItPnNfZmxhZ3MgfD0gU0JfTk9ESVJBVElNRTsK ZGlmZiAtLWdpdCBhL2ZzL2V4dDQvaW9jdGwuYyBiL2ZzL2V4dDQvaW9jdGwuYwppbmRleCA5OTIy MjljYTJkODMwLi42ZTNiOWVlYTEyNmY0IDEwMDY0NAotLS0gYS9mcy9leHQ0L2lvY3RsLmMKKysr IGIvZnMvZXh0NC9pb2N0bC5jCkBAIC0xMDQ0LDcgKzEwNDQsNiBAQCBzdGF0aWMgaW50IGV4dDRf aW9jdGxfY2hlY2twb2ludChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJ X191MzIgZmxhZ3MgPSAwOwogCXVuc2lnbmVkIGludCBmbHVzaF9mbGFncyA9IDA7CiAJc3RydWN0 IHN1cGVyX2Jsb2NrICpzYiA9IGZpbGVfaW5vZGUoZmlscCktPmlfc2I7Ci0Jc3RydWN0IHJlcXVl c3RfcXVldWUgKnE7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIoJmZsYWdzLCAoX191MzIgX191c2Vy ICopYXJnLAogCQkJCXNpemVvZihfX3UzMikpKQpAQCAtMTA2NSwxMCArMTA2NCw4IEBAIHN0YXRp YyBpbnQgZXh0NF9pb2N0bF9jaGVja3BvaW50KHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBs b25nIGFyZykKIAlpZiAoZmxhZ3MgJiB+RVhUNF9JT0NfQ0hFQ0tQT0lOVF9GTEFHX1ZBTElEKQog CQlyZXR1cm4gLUVJTlZBTDsKIAotCXEgPSBiZGV2X2dldF9xdWV1ZShFWFQ0X1NCKHNiKS0+c19q b3VybmFsLT5qX2Rldik7Ci0JaWYgKCFxKQotCQlyZXR1cm4gLUVOWElPOwotCWlmICgoZmxhZ3Mg JiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYgIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQor CWlmICgoZmxhZ3MgJiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYKKwkgICAgIWJkZXZf bWF4X2Rpc2NhcmRfc2VjdG9ycyhFWFQ0X1NCKHNiKS0+c19qb3VybmFsLT5qX2RldikpCiAJCXJl dHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChmbGFncyAmIEVYVDRfSU9DX0NIRUNLUE9JTlRfRkxB R19EUllfUlVOKQpAQCAtMTM5MywxNCArMTM5MCwxMyBAQCBzdGF0aWMgbG9uZyBfX2V4dDRfaW9j dGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJn KQogCiAJY2FzZSBGSVRSSU06CiAJewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZf Z2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQlzdHJ1Y3QgZnN0cmltX3JhbmdlIHJhbmdlOwogCQlp bnQgcmV0ID0gMDsKIAogCQlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCQlyZXR1cm4g LUVQRVJNOwogCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCWlmICghYmRldl9tYXhf ZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCiAJ CS8qCmRpZmYgLS1naXQgYS9mcy9leHQ0L3N1cGVyLmMgYi9mcy9leHQ0L3N1cGVyLmMKaW5kZXgg ODE3NDllYWRkZjRjMS4uOTNmNGU0ZTllMjYzMSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9zdXBlci5j CisrKyBiL2ZzL2V4dDQvc3VwZXIuYwpAQCAtNTQ1OCwxMyArNTQ1OCw5IEBAIHN0YXRpYyBpbnQg X19leHQ0X2ZpbGxfc3VwZXIoc3RydWN0IGZzX2NvbnRleHQgKmZjLCBzdHJ1Y3Qgc3VwZXJfYmxv Y2sgKnNiKQogCQkJZ290byBmYWlsZWRfbW91bnQ5OwogCX0KIAotCWlmICh0ZXN0X29wdChzYiwg RElTQ0FSRCkpIHsKLQkJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShz Yi0+c19iZGV2KTsKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJCWV4dDRfbXNnKHNi LCBLRVJOX1dBUk5JTkcsCi0JCQkJICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwg YnV0ICIKLQkJCQkgInRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JfQor CWlmICh0ZXN0X29wdChzYiwgRElTQ0FSRCkgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhz Yi0+c19iZGV2KSkKKwkJZXh0NF9tc2coc2IsIEtFUk5fV0FSTklORywKKwkJCSAibW91bnRpbmcg d2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCB0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQg ZGlzY2FyZCIpOwogCiAJaWYgKGVzLT5zX2Vycm9yX2NvdW50KQogCQltb2RfdGltZXIoJnNiaS0+ c19lcnJfcmVwb3J0LCBqaWZmaWVzICsgMzAwKkhaKTsgLyogNSBtaW51dGVzICovCmRpZmYgLS1n aXQgYS9mcy9mMmZzL2YyZnMuaCBiL2ZzL2YyZnMvZjJmcy5oCmluZGV4IGNkMWU2NWJjZjBiMDQu LjBlYTlhNWZhN2MxZGQgMTAwNjQ0Ci0tLSBhL2ZzL2YyZnMvZjJmcy5oCisrKyBiL2ZzL2YyZnMv ZjJmcy5oCkBAIC00MzgxLDggKzQzODEsNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgZjJmc19od19z aG91bGRfZGlzY2FyZChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkpCiAKIHN0YXRpYyBpbmxpbmUg Ym9vbCBmMmZzX2JkZXZfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYp CiB7Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSB8fAot CSAgICAgICBiZGV2X2lzX3pvbmVkKGJkZXYpOworCXJldHVybiBiZGV2X21heF9kaXNjYXJkX3Nl Y3RvcnMoYmRldikgfHwgYmRldl9pc196b25lZChiZGV2KTsKIH0KIAogc3RhdGljIGlubGluZSBi b29sIGYyZnNfaHdfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSkKZGlm ZiAtLWdpdCBhL2ZzL2ZhdC9maWxlLmMgYi9mcy9mYXQvZmlsZS5jCmluZGV4IGE1YTMwOWZjYzdm YWYuLmU0YzdkMTBlODAxMjkgMTAwNjQ0Ci0tLSBhL2ZzL2ZhdC9maWxlLmMKKysrIGIvZnMvZmF0 L2ZpbGUuYwpAQCAtMTMzLDcgKzEzMyw3IEBAIHN0YXRpYyBpbnQgZmF0X2lvY3RsX2ZpdHJpbShz dHJ1Y3QgaW5vZGUgKmlub2RlLCB1bnNpZ25lZCBsb25nIGFyZykKIAlpZiAoIWNhcGFibGUoQ0FQ X1NZU19BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJk KHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAl1c2VyX3JhbmdlID0gKHN0cnVjdCBmc3RyaW1fcmFuZ2UgX191 c2VyICopYXJnOwpkaWZmIC0tZ2l0IGEvZnMvZmF0L2lub2RlLmMgYi9mcy9mYXQvaW5vZGUuYwpp bmRleCBiZjYwNTFiZGYxZDFkLi4zZDFhZmI5NWE5MjVhIDEwMDY0NAotLS0gYS9mcy9mYXQvaW5v ZGUuYworKysgYi9mcy9mYXQvaW5vZGUuYwpAQCAtMTg3MiwxMyArMTg3Miw5IEBAIGludCBmYXRf ZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpkYXRhLCBpbnQgc2lsZW50 LCBpbnQgaXN2ZmF0LAogCQlnb3RvIG91dF9mYWlsOwogCX0KIAotCWlmIChzYmktPm9wdGlvbnMu ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNi LT5zX2JkZXYpOwotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQotCQkJZmF0X21zZyhzYiwg S0VSTl9XQVJOSU5HLAotCQkJCQkibW91bnRpbmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1 dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCX0KKwlp ZiAoc2JpLT5vcHRpb25zLmRpc2NhcmQgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhzYi0+ c19iZGV2KSkKKwkJZmF0X21zZyhzYiwgS0VSTl9XQVJOSU5HLAorCQkJIm1vdW50aW5nIHdpdGgg XCJkaXNjYXJkXCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2Nh cmQiKTsKIAogCWZhdF9zZXRfc3RhdGUoc2IsIDEsIDApOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0 IGEvZnMvZ2ZzMi9yZ3JwLmMgYi9mcy9nZnMyL3JncnAuYwppbmRleCA4MDFhZDlmNGYyYmVmLi43 ZjIwYWM5MTMzYmM2IDEwMDY0NAotLS0gYS9mcy9nZnMyL3JncnAuYworKysgYi9mcy9nZnMyL3Jn cnAuYwpAQCAtMTQwNSw3ICsxNDA1LDcgQEAgaW50IGdmczJfZml0cmltKHN0cnVjdCBmaWxlICpm aWxwLCB2b2lkIF9fdXNlciAqYXJncCkKIAlpZiAoIXRlc3RfYml0KFNERl9KT1VSTkFMX0xJVkUs ICZzZHAtPnNkX2ZsYWdzKSkKIAkJcmV0dXJuIC1FUk9GUzsKIAotCWlmICghYmxrX3F1ZXVlX2Rp c2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2RwLT5zZF92ZnMtPnNf YmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmciwg YXJncCwgc2l6ZW9mKHIpKSkKZGlmZiAtLWdpdCBhL2ZzL2piZDIvam91cm5hbC5jIGIvZnMvamJk Mi9qb3VybmFsLmMKaW5kZXggZmNhY2FmYTQ1MTBkMS4uMTlkMjI2Y2Q0ZmY0ZCAxMDA2NDQKLS0t IGEvZnMvamJkMi9qb3VybmFsLmMKKysrIGIvZnMvamJkMi9qb3VybmFsLmMKQEAgLTE3NjIsNyAr MTc2Miw2IEBAIHN0YXRpYyBpbnQgX19qYmQyX2pvdXJuYWxfZXJhc2Uoam91cm5hbF90ICpqb3Vy bmFsLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJdW5zaWduZWQgbG9uZyBibG9jaywgbG9nX29mZnNl dDsgLyogbG9naWNhbCAqLwogCXVuc2lnbmVkIGxvbmcgbG9uZyBwaHlzX2Jsb2NrLCBibG9ja19z dGFydCwgYmxvY2tfc3RvcDsgLyogcGh5c2ljYWwgKi8KIAlsb2ZmX3QgYnl0ZV9zdGFydCwgYnl0 ZV9zdG9wLCBieXRlX2NvdW50OwotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRf cXVldWUoam91cm5hbC0+al9kZXYpOwogCiAJLyogZmxhZ3MgbXVzdCBiZSBzZXQgdG8gZWl0aGVy IGRpc2NhcmQgb3IgemVyb291dCAqLwogCWlmICgoZmxhZ3MgJiB+SkJEMl9KT1VSTkFMX0ZMVVNI X1ZBTElEKSB8fCAhZmxhZ3MgfHwKQEAgLTE3NzAsMTAgKzE3NjksOCBAQCBzdGF0aWMgaW50IF9f amJkMl9qb3VybmFsX2VyYXNlKGpvdXJuYWxfdCAqam91cm5hbCwgdW5zaWduZWQgaW50IGZsYWdz KQogCQkJKGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX1pFUk9PVVQpKSkKIAkJcmV0dXJuIC1F SU5WQUw7CiAKLQlpZiAoIXEpCi0JCXJldHVybiAtRU5YSU87Ci0KLQlpZiAoKGZsYWdzICYgSkJE Ml9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwlpZiAo KGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmCisJICAgICFiZGV2X21heF9k aXNjYXJkX3NlY3RvcnMoam91cm5hbC0+al9kZXYpKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAK IAkvKgpkaWZmIC0tZ2l0IGEvZnMvamZzL2lvY3RsLmMgYi9mcy9qZnMvaW9jdGwuYwppbmRleCAw M2E4NDVhYjRmMDA5Li4zNTdhZTZlNWMzNmVjIDEwMDY0NAotLS0gYS9mcy9qZnMvaW9jdGwuYwor KysgYi9mcy9qZnMvaW9jdGwuYwpAQCAtMTE3LDcgKzExNyw3IEBAIGxvbmcgamZzX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIAkJ aWYgKCFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQogCQkJcmV0dXJuIC1FUEVSTTsKIAotCQlpZiAo IWJsa19xdWV1ZV9kaXNjYXJkKHEpKSB7CisJCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KHNiLT5zX2JkZXYpKSB7CiAJCQlqZnNfd2FybigiRklUUklNIG5vdCBzdXBwb3J0ZWQgb24gZGV2 aWNlIik7CiAJCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJCX0KZGlmZiAtLWdpdCBhL2ZzL2pmcy9z dXBlci5jIGIvZnMvamZzL3N1cGVyLmMKaW5kZXggZjFhMTNhNzRjZGRmMy4uODVkNGY0NGYyYWM0 ZCAxMDA2NDQKLS0tIGEvZnMvamZzL3N1cGVyLmMKKysrIGIvZnMvamZzL3N1cGVyLmMKQEAgLTM3 MiwxOSArMzcyLDE2IEBAIHN0YXRpYyBpbnQgcGFyc2Vfb3B0aW9ucyhjaGFyICpvcHRpb25zLCBz dHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzNjQgKm5ld0xWU2l6ZSwKIAkJfQogCiAJCWNhc2UgT3B0 X2Rpc2NhcmQ6Ci0JCXsKLQkJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVl dWUoc2ItPnNfYmRldik7CiAJCQkvKiBpZiBzZXQgdG8gMSwgZXZlbiBjb3B5aW5nIGZpbGVzIHdp bGwgY2F1c2UKIAkJCSAqIHRyaW1taW5nIDpPCiAJCQkgKiAtPiB1c2VyIGhhcyBtb3JlIGNvbnRy b2wgb3ZlciB0aGUgb25saW5lIHRyaW1taW5nCiAJCQkgKi8KIAkJCXNiaS0+bWluYmxrc190cmlt ID0gNjQ7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCQlpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJCSpmbGFnIHw9IEpGU19ESVNDQVJEOwogCQkJ ZWxzZQogCQkJCXByX2VycigiSkZTOiBkaXNjYXJkIG9wdGlvbiBub3Qgc3VwcG9ydGVkIG9uIGRl dmljZVxuIik7CiAJCQlicmVhazsKLQkJfQogCiAJCWNhc2UgT3B0X25vZGlzY2FyZDoKIAkJCSpm bGFnICY9IH5KRlNfRElTQ0FSRDsKQEAgLTM5MiwxMCArMzg5LDkgQEAgc3RhdGljIGludCBwYXJz ZV9vcHRpb25zKGNoYXIgKm9wdGlvbnMsIHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHM2NCAqbmV3 TFZTaXplLAogCiAJCWNhc2UgT3B0X2Rpc2NhcmRfbWluYmxrOgogCQl7Ci0JCQlzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQkJY2hhciAqbWlu Ymxrc190cmltID0gYXJnc1swXS5mcm9tOwogCQkJaW50IHJjOwotCQkJaWYgKGJsa19xdWV1ZV9k aXNjYXJkKHEpKSB7CisJCQlpZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYp KSB7CiAJCQkJKmZsYWcgfD0gSkZTX0RJU0NBUkQ7CiAJCQkJcmMgPSBrc3RydG91aW50KG1pbmJs a3NfdHJpbSwgMCwKIAkJCQkJCSZzYmktPm1pbmJsa3NfdHJpbSk7CmRpZmYgLS1naXQgYS9mcy9u aWxmczIvaW9jdGwuYyBiL2ZzL25pbGZzMi9pb2N0bC5jCmluZGV4IGZlYzE5NGE2NjZmNGIuLjUy YjczZjU1OGZjYjEgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9pb2N0bC5jCisrKyBiL2ZzL25pbGZz Mi9pb2N0bC5jCkBAIC0xMDU5LDcgKzEwNTksNyBAQCBzdGF0aWMgaW50IG5pbGZzX2lvY3RsX3Ry aW1fZnMoc3RydWN0IGlub2RlICppbm9kZSwgdm9pZCBfX3VzZXIgKmFyZ3ApCiAJaWYgKCFjYXBh YmxlKENBUF9TWVNfQURNSU4pKQogCQlyZXR1cm4gLUVQRVJNOwogCi0JaWYgKCFibGtfcXVldWVf ZGlzY2FyZChxKSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhuaWxmcy0+bnNfYmRl dikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmcmFuZ2Us IGFyZ3AsIHNpemVvZihyYW5nZSkpKQpkaWZmIC0tZ2l0IGEvZnMvbnRmczMvZmlsZS5jIGIvZnMv bnRmczMvZmlsZS5jCmluZGV4IDc4N2I1M2I5ODRlZTEuLmU3NjMyMzYxNjkzMzEgMTAwNjQ0Ci0t LSBhL2ZzL250ZnMzL2ZpbGUuYworKysgYi9mcy9udGZzMy9maWxlLmMKQEAgLTI4LDcgKzI4LDcg QEAgc3RhdGljIGludCBudGZzX2lvY3RsX2ZpdHJpbShzdHJ1Y3QgbnRmc19zYl9pbmZvICpzYmks IHVuc2lnbmVkIGxvbmcgYXJnKQogCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0 dXJuIC1FUEVSTTsKIAotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21h eF9kaXNjYXJkX3NlY3RvcnMoc2JpLT5zYi0+c19iZGV2KSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQ OwogCiAJdXNlcl9yYW5nZSA9IChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZzsKZGlm ZiAtLWdpdCBhL2ZzL250ZnMzL3N1cGVyLmMgYi9mcy9udGZzMy9zdXBlci5jCmluZGV4IGNkMzBl ODFhYmJjZTAuLmM3MzQwODViY2NlNGEgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMzL3N1cGVyLmMKKysr IGIvZnMvbnRmczMvc3VwZXIuYwpAQCAtOTEzLDcgKzkxMyw3IEBAIHN0YXRpYyBpbnQgbnRmc19m aWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBmc19jb250ZXh0ICpmYykK IAl9CiAKIAlycSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwotCWlmIChibGtfcXVldWVfZGlzY2Fy ZChycSkgJiYgcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5KSB7CisJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSAmJiBycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkp IHsKIAkJc2JpLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51 bGFyaXR5OwogCQlzYmktPmRpc2NhcmRfZ3JhbnVsYXJpdHlfbWFza19pbnYgPQogCQkJfih1NjQp KHNiaS0+ZGlzY2FyZF9ncmFudWxhcml0eSAtIDEpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvaW9j dGwuYyBiL2ZzL29jZnMyL2lvY3RsLmMKaW5kZXggZjU5NDYxZDg1ZGE0NS4uOWI3OGVmMTAzYWRh NiAxMDA2NDQKLS0tIGEvZnMvb2NmczIvaW9jdGwuYworKysgYi9mcy9vY2ZzMi9pb2N0bC5jCkBA IC05MTAsNyArOTEwLDcgQEAgbG9uZyBvY2ZzMl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5z aWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJCWlmICghY2FwYWJsZShDQVBfU1lT X0FETUlOKSkKIAkJCXJldHVybiAtRVBFUk07CiAKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChx KSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2ItPnNfYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZyYW5nZSwgYXJncCwgc2l6 ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Rpc2NhcmQuYyBiL2ZzL3hmcy94 ZnNfZGlzY2FyZC5jCmluZGV4IDAxOTFkZThjZTljZWQuLmE0ZTY2MDlkNjE2YjcgMTAwNjQ0Ci0t LSBhL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCisrKyBiL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCkBAIC0x NjIsNyArMTYyLDcgQEAgeGZzX2lvY190cmltKAogCiAJaWYgKCFjYXBhYmxlKENBUF9TWVNfQURN SU4pKQogCQlyZXR1cm4gLUVQRVJNOwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMobXAtPm1fZGRldl90YXJncC0+YnRfYmRldikpCiAJ CXJldHVybiAtRU9QTk9UU1VQUDsKIAogCS8qCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3N1cGVy LmMgYi9mcy94ZnMveGZzX3N1cGVyLmMKaW5kZXggNTRiZTlkNjQwOTNlZC4uYTI3NmI4MTExZjYz NiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19zdXBlci5jCisrKyBiL2ZzL3hmcy94ZnNfc3VwZXIu YwpAQCAtMTYwOCwxNCArMTYwOCwxMCBAQCB4ZnNfZnNfZmlsbF9zdXBlcigKIAkJCWdvdG8gb3V0 X2ZpbGVzdHJlYW1fdW5tb3VudDsKIAl9CiAKLQlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSkgewot CQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwot Ci0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJCXhmc193YXJuKG1wLCAibW91bnRp bmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMg bm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCQkJbXAtPm1fZmVhdHVyZXMgJj0gflhGU19GRUFUX0RJ U0NBUkQ7Ci0JCX0KKwlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSAmJiAhYmRldl9tYXhfZGlzY2Fy ZF9zZWN0b3JzKHNiLT5zX2JkZXYpKSB7CisJCXhmc193YXJuKG1wLAorCSJtb3VudGluZyB3aXRo IFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNj YXJkIik7CisJCW1wLT5tX2ZlYXR1cmVzICY9IH5YRlNfRkVBVF9ESVNDQVJEOwogCX0KIAogCWlm ICh4ZnNfaGFzX3JlZmxpbmsobXApKSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Jsa2Rl di5oIGIvaW5jbHVkZS9saW51eC9ibGtkZXYuaAppbmRleCBjZTE2MjQ3ZDNhZmFiLi43NjdhYjIy ZTEwNTJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1ZGUv bGludXgvYmxrZGV2LmgKQEAgLTU0MCw3ICs1NDAsNiBAQCBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSB7 CiAjZGVmaW5lIFFVRVVFX0ZMQUdfTk9OUk9UCTYJLyogbm9uLXJvdGF0aW9uYWwgZGV2aWNlIChT U0QpICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfVklSVAkJUVVFVUVfRkxBR19OT05ST1QgLyogcGFy YXZpcnQgZGV2aWNlICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfSU9fU1RBVAk3CS8qIGRvIGRpc2sv cGFydGl0aW9ucyBJTyBhY2NvdW50aW5nICovCi0jZGVmaW5lIFFVRVVFX0ZMQUdfRElTQ0FSRAk4 CS8qIHN1cHBvcnRzIERJU0NBUkQgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19OT1hNRVJHRVMJOQkv KiBObyBleHRlbmRlZCBtZXJnZXMgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19BRERfUkFORE9NCTEw CS8qIENvbnRyaWJ1dGVzIHRvIHJhbmRvbSBwb29sICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfU0VD RVJBU0UJMTEJLyogc3VwcG9ydHMgc2VjdXJlIGVyYXNlICovCkBAIC01ODIsNyArNTgxLDYgQEAg Ym9vbCBibGtfcXVldWVfZmxhZ190ZXN0X2FuZF9zZXQodW5zaWduZWQgaW50IGZsYWcsIHN0cnVj dCByZXF1ZXN0X3F1ZXVlICpxKTsKIAl0ZXN0X2JpdChRVUVVRV9GTEFHX1NUQUJMRV9XUklURVMs ICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfaW9fc3RhdChxKQl0ZXN0X2Jp dChRVUVVRV9GTEFHX0lPX1NUQVQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVl dWVfYWRkX3JhbmRvbShxKQl0ZXN0X2JpdChRVUVVRV9GTEFHX0FERF9SQU5ET00sICYocSktPnF1 ZXVlX2ZsYWdzKQotI2RlZmluZSBibGtfcXVldWVfZGlzY2FyZChxKQl0ZXN0X2JpdChRVUVVRV9G TEFHX0RJU0NBUkQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfem9uZV9y ZXNldGFsbChxKQlcCiAJdGVzdF9iaXQoUVVFVUVfRkxBR19aT05FX1JFU0VUQUxMLCAmKHEpLT5x dWV1ZV9mbGFncykKICNkZWZpbmUgYmxrX3F1ZXVlX3NlY3VyZV9lcmFzZShxKSBcCmRpZmYgLS1n aXQgYS9tbS9zd2FwZmlsZS5jIGIvbW0vc3dhcGZpbGUuYwppbmRleCA0MDY5ZjE3YTgyYzhlLi41 ZDljZWRmOWU3Yjg0IDEwMDY0NAotLS0gYS9tbS9zd2FwZmlsZS5jCisrKyBiL21tL3N3YXBmaWxl LmMKQEAgLTI5NTcsMjAgKzI5NTcsNiBAQCBzdGF0aWMgaW50IHNldHVwX3N3YXBfbWFwX2FuZF9l eHRlbnRzKHN0cnVjdCBzd2FwX2luZm9fc3RydWN0ICpwLAogCXJldHVybiBucl9leHRlbnRzOwog fQogCi0vKgotICogSGVscGVyIHRvIHN5c19zd2Fwb24gZGV0ZXJtaW5pbmcgaWYgYSBnaXZlbiBz d2FwCi0gKiBiYWNraW5nIGRldmljZSBxdWV1ZSBzdXBwb3J0cyBESVNDQVJEIG9wZXJhdGlvbnMu Ci0gKi8KLXN0YXRpYyBib29sIHN3YXBfZGlzY2FyZGFibGUoc3RydWN0IHN3YXBfaW5mb19zdHJ1 Y3QgKnNpKQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoc2kt PmJkZXYpOwotCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJcmV0dXJuIGZhbHNlOwot Ci0JcmV0dXJuIHRydWU7Ci19Ci0KIFNZU0NBTExfREVGSU5FMihzd2Fwb24sIGNvbnN0IGNoYXIg X191c2VyICosIHNwZWNpYWxmaWxlLCBpbnQsIHN3YXBfZmxhZ3MpCiB7CiAJc3RydWN0IHN3YXBf aW5mb19zdHJ1Y3QgKnA7CkBAIC0zMTMyLDcgKzMxMTgsOCBAQCBTWVNDQUxMX0RFRklORTIoc3dh cG9uLCBjb25zdCBjaGFyIF9fdXNlciAqLCBzcGVjaWFsZmlsZSwgaW50LCBzd2FwX2ZsYWdzKQog CQkJCQkgc2l6ZW9mKGxvbmcpLAogCQkJCQkgR0ZQX0tFUk5FTCk7CiAKLQlpZiAocC0+YmRldiAm JiAoc3dhcF9mbGFncyAmIFNXQVBfRkxBR19ESVNDQVJEKSAmJiBzd2FwX2Rpc2NhcmRhYmxlKHAp KSB7CisJaWYgKChzd2FwX2ZsYWdzICYgU1dBUF9GTEFHX0RJU0NBUkQpICYmCisJICAgIHAtPmJk ZXYgJiYgYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHAtPmJkZXYpKSB7CiAJCS8qCiAJCSAqIFdo ZW4gZGlzY2FyZCBpcyBlbmFibGVkIGZvciBzd2FwIHdpdGggbm8gcGFydGljdWxhcgogCQkgKiBw b2xpY3kgZmxhZ2dlZCwgd2Ugc2V0IGFsbCBzd2FwIGRpc2NhcmQgZmxhZ3MgaGVyZSBpbgotLSAK Mi4zMC4yCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCkxpbnV4IE1URCBkaXNjdXNzaW9uIG1haWxpbmcgbGlzdApodHRwOi8vbGlzdHMuaW5m cmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LW10ZC8K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Christoph Hellwig Subject: [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-Id: <20220409045043.23593-25-hch@lst.de> In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> MIME-Version: 1.0 List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-um" Errors-To: linux-um-bounces+geert=linux-m68k.org@lists.infradead.org To: Jens Axboe Cc: dm-devel@redhat.com, linux-xfs@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-um@lists.infradead.org, linux-block@vger.kernel.org, drbd-dev@lists.linbit.com, nbd@other.debian.org, ceph-devel@vger.kernel.org, virtualization@lists.linux-foundation.org, xen-devel@lists.xenproject.org, linux-bcache@vger.kernel.org, linux-raid@vger.kernel.org, linux-mmc@vger.kernel.org, linux-mtd@lists.infradead.org, linux-nvme@lists.infradead.org, linux-s390@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux-btrfs@vger.kernel.org, linux-ext4@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, cluster-devel@redhat.com, jfs-discussion@lists.sourceforge.net, linux-nilfs@vger.kernel.org, ntfs3@lists.linux.dev, ocfs2-devel@oss.oracle.com, linux-mm@kvack.org, "Martin K . Petersen" , =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , Coly Li SnVzdCB1c2UgYSBub24temVybyBtYXhfZGlzY2FyZF9zZWN0b3JzIGFzIGFuIGluZGljYXRvciBm b3IgZGlzY2FyZApzdXBwb3J0LCBzaW1pbGFyIHRvIHdoYXQgaXMgZG9uZSBmb3Igd3JpdGUgemVy b2VzLgoKVGhlIG9ubHkgcGxhY2VzIHdoZXJlIG5lZWRzIHNwZWNpYWwgYXR0ZW50aW9uIGlzIHRo ZSBSQUlENSBkcml2ZXIsCndoaWNoIG11c3QgY2xlYXIgZGlzY2FyZCBzdXBwb3J0IGZvciBzZWN1 cml0eSByZWFzb25zIGJ5IGRlZmF1bHQsCmV2ZW4gaWYgdGhlIGRlZmF1bHQgc3RhY2tpbmcgcnVs ZXMgd291bGQgYWxsb3cgZm9yIGl0LgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcg PGhjaEBsc3QuZGU+ClJldmlld2VkLWJ5OiBNYXJ0aW4gSy4gUGV0ZXJzZW4gPG1hcnRpbi5wZXRl cnNlbkBvcmFjbGUuY29tPgpBY2tlZC1ieTogQ2hyaXN0b3BoIELDtmhtd2FsZGVyIDxjaHJpc3Rv cGguYm9laG13YWxkZXJAbGluYml0LmNvbT4gW2J0cmZzXQpBY2tlZC1ieTogQ29seSBMaSA8Y29s eWxpQHN1c2UuZGU+IFtiY2FjaGVdCi0tLQogYXJjaC91bS9kcml2ZXJzL3ViZF9rZXJuLmMgICAg ICAgICAgfCAgMiAtLQogYmxvY2svYmxrLWNvcmUuYyAgICAgICAgICAgICAgICAgICAgfCAgMiAr LQogYmxvY2svYmxrLWxpYi5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogYmxvY2svYmxr LW1xLWRlYnVnZnMuYyAgICAgICAgICAgICAgfCAgMSAtCiBibG9jay9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgICB8ICAzICstLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbWFpbi5jICAg ICAgfCAgMiArLQogZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYyAgICAgICAgfCAxOSArKy0t LS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jICB8ICAz ICstLQogZHJpdmVycy9ibG9jay9sb29wLmMgICAgICAgICAgICAgICAgfCAxMSArKystLS0tLS0t LQogZHJpdmVycy9ibG9jay9uYmQuYyAgICAgICAgICAgICAgICAgfCAgNSArLS0tLQogZHJpdmVy cy9ibG9jay9udWxsX2Jsay9tYWluLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL2Jsb2NrL3JiZC5j ICAgICAgICAgICAgICAgICB8ICAxIC0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jICAg ICAgIHwgIDIgLS0KIGRyaXZlcnMvYmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaCAgIHwgIDMgLS0t CiBkcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYyAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Js b2NrL3hlbi1ibGtiYWNrL3hlbmJ1cy5jICB8ICAyICstCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtm cm9udC5jICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYyAgICAg ICB8ICAxIC0KIGRyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYyAgICAgICAgIHwgIDQgKystLQog ZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYyAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv YmNhY2hlL3N5c2ZzLmMgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvbWQvZG0tY2FjaGUtdGFy Z2V0LmMgICAgICAgIHwgIDkgKy0tLS0tLS0tCiBkcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5j ICAgICAgICB8ICA5ICstLS0tLS0tLQogZHJpdmVycy9tZC9kbS1sb2ctd3JpdGVzLmMgICAgICAg ICAgfCAgMyArLS0KIGRyaXZlcnMvbWQvZG0tcmFpZC5jICAgICAgICAgICAgICAgIHwgIDkgKyst LS0tLS0tCiBkcml2ZXJzL21kL2RtLXRhYmxlLmMgICAgICAgICAgICAgICB8ICA5ICsrLS0tLS0t LQogZHJpdmVycy9tZC9kbS10aGluLmMgICAgICAgICAgICAgICAgfCAxMSArLS0tLS0tLS0tLQog ZHJpdmVycy9tZC9kbS5jICAgICAgICAgICAgICAgICAgICAgfCAgMyArLS0KIGRyaXZlcnMvbWQv bWQtbGluZWFyLmMgICAgICAgICAgICAgIHwgMTEgKy0tLS0tLS0tLS0KIGRyaXZlcnMvbWQvcmFp ZDAuYyAgICAgICAgICAgICAgICAgIHwgIDcgLS0tLS0tLQogZHJpdmVycy9tZC9yYWlkMS5jICAg ICAgICAgICAgICAgICAgfCAxNiArLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL21kL3JhaWQxMC5j ICAgICAgICAgICAgICAgICB8IDE4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tZC9yYWlk NS1jYWNoZS5jICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9tZC9yYWlkNS5jICAgICAgICAg ICAgICAgICAgfCAxMiArKysrLS0tLS0tLS0KIGRyaXZlcnMvbW1jL2NvcmUvcXVldWUuYyAgICAg ICAgICAgIHwgIDEgLQogZHJpdmVycy9tdGQvbXRkX2Jsa2RldnMuYyAgICAgICAgICAgfCAgMSAt CiBkcml2ZXJzL252bWUvaG9zdC9jb3JlLmMgICAgICAgICAgICB8ICA2ICsrLS0tLQogZHJpdmVy cy9zMzkwL2Jsb2NrL2Rhc2RfZmJhLmMgICAgICAgfCAgMSAtCiBkcml2ZXJzL3Njc2kvc2QuYyAg ICAgICAgICAgICAgICAgICB8ICAyIC0tCiBkcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV9kZXZp Y2UuYyB8ICAyICstCiBmcy9idHJmcy9leHRlbnQtdHJlZS5jICAgICAgICAgICAgICB8ICA0ICsr LS0KIGZzL2J0cmZzL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0 L2ZpbGUuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2V4ZmF0L3N1cGVyLmMgICAg ICAgICAgICAgICAgICAgIHwgMTAgKysrLS0tLS0tLQogZnMvZXh0NC9pb2N0bC5jICAgICAgICAg ICAgICAgICAgICAgfCAxMCArKystLS0tLS0tCiBmcy9leHQ0L3N1cGVyLmMgICAgICAgICAgICAg ICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZzL2YyZnMvZjJmcy5oICAgICAgICAgICAgICAgICAg ICAgIHwgIDMgKy0tCiBmcy9mYXQvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgICB8ICAyICst CiBmcy9mYXQvaW5vZGUuYyAgICAgICAgICAgICAgICAgICAgICB8IDEwICsrKy0tLS0tLS0KIGZz L2dmczIvcmdycC5jICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGZzL2piZDIvam91cm5h bC5jICAgICAgICAgICAgICAgICAgIHwgIDcgKystLS0tLQogZnMvamZzL2lvY3RsLmMgICAgICAg ICAgICAgICAgICAgICAgfCAgMiArLQogZnMvamZzL3N1cGVyLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgOCArKy0tLS0tLQogZnMvbmlsZnMyL2lvY3RsLmMgICAgICAgICAgICAgICAgICAgfCAg MiArLQogZnMvbnRmczMvZmlsZS5jICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvbnRm czMvc3VwZXIuYyAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMvb2NmczIvaW9jdGwuYyAg ICAgICAgICAgICAgICAgICAgfCAgMiArLQogZnMveGZzL3hmc19kaXNjYXJkLmMgICAgICAgICAg ICAgICAgfCAgMiArLQogZnMveGZzL3hmc19zdXBlci5jICAgICAgICAgICAgICAgICAgfCAxMiAr KysrLS0tLS0tLS0KIGluY2x1ZGUvbGludXgvYmxrZGV2LmggICAgICAgICAgICAgIHwgIDIgLS0K IG1tL3N3YXBmaWxlLmMgICAgICAgICAgICAgICAgICAgICAgIHwgMTcgKystLS0tLS0tLS0tLS0t LS0KIDYxIGZpbGVzIGNoYW5nZWQsIDcyIGluc2VydGlvbnMoKyksIDI0NiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvdWJkX2tlcm4uYyBiL2FyY2gvdW0vZHJpdmVy cy91YmRfa2Vybi5jCmluZGV4IGIwMzI2OWZhZWY3MTQuLjA4NWZmZGY5OGU1N2UgMTAwNjQ0Ci0t LSBhL2FyY2gvdW0vZHJpdmVycy91YmRfa2Vybi5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy91YmRf a2Vybi5jCkBAIC00ODMsNyArNDgzLDYgQEAgc3RhdGljIHZvaWQgdWJkX2hhbmRsZXIodm9pZCkK IAkJCWlmICgoaW9fcmVxLT5lcnJvciA9PSBCTEtfU1RTX05PVFNVUFApICYmIChyZXFfb3AoaW9f cmVxLT5yZXEpID09IFJFUV9PUF9ESVNDQVJEKSkgewogCQkJCWJsa19xdWV1ZV9tYXhfZGlzY2Fy ZF9zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKIAkJCQlibGtfcXVldWVfbWF4X3dyaXRlX3pl cm9lc19zZWN0b3JzKGlvX3JlcS0+cmVxLT5xLCAwKTsKLQkJCQlibGtfcXVldWVfZmxhZ19jbGVh cihRVUVVRV9GTEFHX0RJU0NBUkQsIGlvX3JlcS0+cmVxLT5xKTsKIAkJCX0KIAkJCWJsa19tcV9l bmRfcmVxdWVzdChpb19yZXEtPnJlcSwgaW9fcmVxLT5lcnJvcik7CiAJCQlrZnJlZShpb19yZXEp OwpAQCAtODAzLDcgKzgwMiw2IEBAIHN0YXRpYyBpbnQgdWJkX29wZW5fZGV2KHN0cnVjdCB1YmQg KnViZF9kZXYpCiAJCXViZF9kZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQgPSBT RUNUT1JfU0laRTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnModWJkX2Rldi0+cXVl dWUsIFVCRF9NQVhfUkVRVUVTVCk7CiAJCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3Rv cnModWJkX2Rldi0+cXVldWUsIFVCRF9NQVhfUkVRVUVTVCk7Ci0JCWJsa19xdWV1ZV9mbGFnX3Nl dChRVUVVRV9GTEFHX0RJU0NBUkQsIHViZF9kZXYtPnF1ZXVlKTsKIAl9CiAJYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfTk9OUk9ULCB1YmRfZGV2LT5xdWV1ZSk7CiAJcmV0dXJuIDA7CmRp ZmYgLS1naXQgYS9ibG9jay9ibGstY29yZS5jIGIvYmxvY2svYmxrLWNvcmUuYwppbmRleCA5Mzdi YjZiODYzMzE3Li5iNWMzYTgwNDkxMzRjIDEwMDY0NAotLS0gYS9ibG9jay9ibGstY29yZS5jCisr KyBiL2Jsb2NrL2Jsay1jb3JlLmMKQEAgLTgyMCw3ICs4MjAsNyBAQCB2b2lkIHN1Ym1pdF9iaW9f bm9hY2N0KHN0cnVjdCBiaW8gKmJpbykKIAogCXN3aXRjaCAoYmlvX29wKGJpbykpIHsKIAljYXNl IFJFUV9PUF9ESVNDQVJEOgotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQorCQlpZiAoIWJk ZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSkKIAkJCWdvdG8gbm90X3N1cHBvcnRlZDsKIAkJ YnJlYWs7CiAJY2FzZSBSRVFfT1BfU0VDVVJFX0VSQVNFOgpkaWZmIC0tZ2l0IGEvYmxvY2svYmxr LWxpYi5jIGIvYmxvY2svYmxrLWxpYi5jCmluZGV4IDJhZTMyYTcyMjg1MWMuLjhiNGI2NmQzYTli ZmMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1saWIuYworKysgYi9ibG9jay9ibGstbGliLmMKQEAg LTUzLDcgKzUzLDcgQEAgaW50IF9fYmxrZGV2X2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2Rl dmljZSAqYmRldiwgc2VjdG9yX3Qgc2VjdG9yLAogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCQlv cCA9IFJFUV9PUF9TRUNVUkVfRVJBU0U7CiAJfSBlbHNlIHsKLQkJaWYgKCFibGtfcXVldWVfZGlz Y2FyZChxKSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAJCW9wID0gUkVRX09QX0RJU0NBUkQ7CiAJfQpkaWZmIC0tZ2l0IGEv YmxvY2svYmxrLW1xLWRlYnVnZnMuYyBiL2Jsb2NrL2Jsay1tcS1kZWJ1Z2ZzLmMKaW5kZXggYWEw MzQ5ZTlmMDgzYi4uZmQxMTFjNTAwMTI1NiAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLW1xLWRlYnVn ZnMuYworKysgYi9ibG9jay9ibGstbXEtZGVidWdmcy5jCkBAIC0xMTMsNyArMTEzLDYgQEAgc3Rh dGljIGNvbnN0IGNoYXIgKmNvbnN0IGJsa19xdWV1ZV9mbGFnX25hbWVbXSA9IHsKIAlRVUVVRV9G TEFHX05BTUUoRkFJTF9JTyksCiAJUVVFVUVfRkxBR19OQU1FKE5PTlJPVCksCiAJUVVFVUVfRkxB R19OQU1FKElPX1NUQVQpLAotCVFVRVVFX0ZMQUdfTkFNRShESVNDQVJEKSwKIAlRVUVVRV9GTEFH X05BTUUoTk9YTUVSR0VTKSwKIAlRVUVVRV9GTEFHX05BTUUoQUREX1JBTkRPTSksCiAJUVVFVUVf RkxBR19OQU1FKFNFQ0VSQVNFKSwKZGlmZiAtLWdpdCBhL2Jsb2NrL2lvY3RsLmMgYi9ibG9jay9p b2N0bC5jCmluZGV4IGFkMzc3MWIyNjhiODEuLmMyY2QzYmE1MjkwY2UgMTAwNjQ0Ci0tLSBhL2Js b2NrL2lvY3RsLmMKKysrIGIvYmxvY2svaW9jdGwuYwpAQCAtODcsMTQgKzg3LDEzIEBAIHN0YXRp YyBpbnQgYmxrX2lvY3RsX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwgZm1vZGVf dCBtb2RlLAogewogCXVpbnQ2NF90IHJhbmdlWzJdOwogCXVpbnQ2NF90IHN0YXJ0LCBsZW47Ci0J c3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShiZGV2KTsKIAlzdHJ1Y3Qg aW5vZGUgKmlub2RlID0gYmRldi0+YmRfaW5vZGU7CiAJaW50IGVycjsKIAogCWlmICghKG1vZGUg JiBGTU9ERV9XUklURSkpCiAJCXJldHVybiAtRUJBREY7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQlyZXR1cm4g LUVPUE5PVFNVUFA7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIocmFuZ2UsICh2b2lkIF9fdXNlciAq KWFyZywgc2l6ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJi ZF9tYWluLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9tYWluLmMKaW5kZXggZWFlNjI5YzRm NmVhZi4uYTY5NDc1ZTU5MjgyMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf bWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX21haW4uYwpAQCAtOTQyLDcgKzk0 Miw3IEBAIGludCBkcmJkX3NlbmRfc2l6ZXMoc3RydWN0IGRyYmRfcGVlcl9kZXZpY2UgKnBlZXJf ZGV2aWNlLCBpbnQgdHJpZ2dlcl9yZXBseSwgZW51CiAJCQljcHVfdG9fYmUzMihiZGV2X2FsaWdu bWVudF9vZmZzZXQoYmRldikpOwogCQlwLT5xbGltLT5pb19taW4gPSBjcHVfdG9fYmUzMihiZGV2 X2lvX21pbihiZGV2KSk7CiAJCXAtPnFsaW0tPmlvX29wdCA9IGNwdV90b19iZTMyKGJkZXZfaW9f b3B0KGJkZXYpKTsKLQkJcC0+cWxpbS0+ZGlzY2FyZF9lbmFibGVkID0gYmxrX3F1ZXVlX2Rpc2Nh cmQocSk7CisJCXAtPnFsaW0tPmRpc2NhcmRfZW5hYmxlZCA9ICEhYmRldl9tYXhfZGlzY2FyZF9z ZWN0b3JzKGJkZXYpOwogCQlwdXRfbGRldihkZXZpY2UpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBy ZXF1ZXN0X3F1ZXVlICpxID0gZGV2aWNlLT5ycV9xdWV1ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv YmxvY2svZHJiZC9kcmJkX25sLmMgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9ubC5jCmluZGV4 IGQ0ZGFjYzMyOWFjMmUuLmI1NWU1ZmNjMjFlMWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv ZHJiZC9kcmJkX25sLmMKKysrIGIvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfbmwuYwpAQCAtMTIx MCw3ICsxMjEwLDcgQEAgc3RhdGljIHZvaWQgZGVjaWRlX29uX2Rpc2NhcmRfc3VwcG9ydChzdHJ1 Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwKIAkJZmlyc3RfcGVlcl9kZXZpY2UoZGV2aWNlKS0+Y29u bmVjdGlvbjsKIAlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGRldmljZS0+cnFfcXVldWU7CiAK LQlpZiAoYmRldiAmJiAhYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldi0+YmFja2luZ19iZGV2LT5iZF9k aXNrLT5xdWV1ZSkpCisJaWYgKGJkZXYgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhiZGV2 LT5iYWNraW5nX2JkZXYpKQogCQlnb3RvIG5vdF9zdXBwb3J0ZWQ7CiAKIAlpZiAoY29ubmVjdGlv bi0+Y3N0YXRlID49IENfQ09OTkVDVEVEICYmCkBAIC0xMjMwLDMwICsxMjMwLDE2IEBAIHN0YXRp YyB2b2lkIGRlY2lkZV9vbl9kaXNjYXJkX3N1cHBvcnQoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZp Y2UsCiAJICovCiAJYmxrX3F1ZXVlX2Rpc2NhcmRfZ3JhbnVsYXJpdHkocSwgNTEyKTsKIAlxLT5s aW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9ycyA9IGRyYmRfbWF4X2Rpc2NhcmRfc2VjdG9ycyhjb25u ZWN0aW9uKTsKLQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAlx LT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0KIAkJZHJiZF9tYXhfZGlzY2FyZF9z ZWN0b3JzKGNvbm5lY3Rpb24pOwogCXJldHVybjsKIAogbm90X3N1cHBvcnRlZDoKLQlibGtfcXVl dWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwogCWJsa19xdWV1ZV9kaXNjYXJk X2dyYW51bGFyaXR5KHEsIDApOwogCXEtPmxpbWl0cy5tYXhfZGlzY2FyZF9zZWN0b3JzID0gMDsK IAlxLT5saW1pdHMubWF4X3dyaXRlX3plcm9lc19zZWN0b3JzID0gMDsKIH0KIAotc3RhdGljIHZv aWQgZml4dXBfZGlzY2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpx KQotewotCS8qIFRvIGF2b2lkIGNvbmZ1c2lvbiwgaWYgdGhpcyBxdWV1ZSBkb2VzIG5vdCBzdXBw b3J0IGRpc2NhcmQsIGNsZWFyCi0JICogbWF4X2Rpc2NhcmRfc2VjdG9ycywgd2hpY2ggaXMgd2hh dCBsc2JsayAtRCByZXBvcnRzIHRvIHRoZSB1c2VyLgotCSAqIE9sZGVyIGtlcm5lbHMgZ290IHRo aXMgd3JvbmcgaW4gInN0YWNrIGxpbWl0cyIuCi0JICogKi8KLQlpZiAoIWJsa19xdWV1ZV9kaXNj YXJkKHEpKSB7Ci0JCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIDApOwotCQlibGtf cXVldWVfZGlzY2FyZF9ncmFudWxhcml0eShxLCAwKTsKLQl9Ci19Ci0KIHN0YXRpYyB2b2lkIGZp eHVwX3dyaXRlX3plcm9lcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSwgc3RydWN0IHJlcXVl c3RfcXVldWUgKnEpCiB7CiAJLyogRml4dXAgbWF4X3dyaXRlX3plcm9lc19zZWN0b3JzIGFmdGVy IGJsa19zdGFja19saW1pdHMoKToKQEAgLTEzMDAsNyArMTI4Niw2IEBAIHN0YXRpYyB2b2lkIGRy YmRfc2V0dXBfcXVldWVfcGFyYW0oc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBk cmJkX2JhY2tpCiAJCWJsa19zdGFja19saW1pdHMoJnEtPmxpbWl0cywgJmItPmxpbWl0cywgMCk7 CiAJCWRpc2tfdXBkYXRlX3JlYWRhaGVhZChkZXZpY2UtPnZkaXNrKTsKIAl9Ci0JZml4dXBfZGlz Y2FyZF9pZl9ub3Rfc3VwcG9ydGVkKHEpOwogCWZpeHVwX3dyaXRlX3plcm9lcyhkZXZpY2UsIHEp OwogfQogCkBAIC0xNDQ3LDcgKzE0MzIsNyBAQCBzdGF0aWMgdm9pZCBzYW5pdGl6ZV9kaXNrX2Nv bmYoc3RydWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHN0cnVjdCBkaXNrX2NvbmYgKmRpcwogCWlm IChkaXNrX2NvbmYtPmFsX2V4dGVudHMgPiBkcmJkX2FsX2V4dGVudHNfbWF4KG5iYykpCiAJCWRp c2tfY29uZi0+YWxfZXh0ZW50cyA9IGRyYmRfYWxfZXh0ZW50c19tYXgobmJjKTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhi ZGV2KSkgewogCQlpZiAoZGlza19jb25mLT5yc19kaXNjYXJkX2dyYW51bGFyaXR5KSB7CiAJCQlk aXNrX2NvbmYtPnJzX2Rpc2NhcmRfZ3JhbnVsYXJpdHkgPSAwOyAvKiBkaXNhYmxlIGZlYXR1cmUg Ki8KIAkJCWRyYmRfaW5mbyhkZXZpY2UsICJyc19kaXNjYXJkX2dyYW51bGFyaXR5IGZlYXR1cmUg ZGlzYWJsZWRcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRfcmVjZWl2 ZXIuYyBiL2RyaXZlcnMvYmxvY2svZHJiZC9kcmJkX3JlY2VpdmVyLmMKaW5kZXggMGI0YzdkZTQ2 Mzk4OS4uOGE0YTQ3ZGE1NmZlOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay9kcmJkL2RyYmRf cmVjZWl2ZXIuYworKysgYi9kcml2ZXJzL2Jsb2NrL2RyYmQvZHJiZF9yZWNlaXZlci5jCkBAIC0x NTc1LDExICsxNTc1LDEwIEBAIGludCBkcmJkX2lzc3VlX2Rpc2NhcmRfb3JfemVyb19vdXQoc3Ry dWN0IGRyYmRfZGV2aWNlICpkZXZpY2UsIHNlY3Rvcl90IHN0YXJ0LCB1CiAKIHN0YXRpYyBib29s IGNhbl9kb19yZWxpYWJsZV9kaXNjYXJkcyhzdHJ1Y3QgZHJiZF9kZXZpY2UgKmRldmljZSkKIHsK LQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGRldmljZS0+bGRldi0+ YmFja2luZ19iZGV2KTsKIAlzdHJ1Y3QgZGlza19jb25mICpkYzsKIAlib29sIGNhbl9kbzsKIAot CWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoZGV2aWNlLT5sZGV2LT5iYWNraW5nX2JkZXYpKQogCQlyZXR1cm4gZmFsc2U7CiAKIAlyY3Vf cmVhZF9sb2NrKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYyBiL2RyaXZlcnMv YmxvY2svbG9vcC5jCmluZGV4IDhkODAwZDQ2ZTQ5ODUuLjBlMDYxYzk4OTZlZmYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvYmxvY2svbG9vcC5jCisrKyBiL2RyaXZlcnMvYmxvY2svbG9vcC5jCkBAIC0z MTQsMTUgKzMxNCwxMiBAQCBzdGF0aWMgaW50IGxvX2ZhbGxvY2F0ZShzdHJ1Y3QgbG9vcF9kZXZp Y2UgKmxvLCBzdHJ1Y3QgcmVxdWVzdCAqcnEsIGxvZmZfdCBwb3MsCiAKIAltb2RlIHw9IEZBTExP Q19GTF9LRUVQX1NJWkU7CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKGxvLT5sb19xdWV1ZSkp IHsKLQkJcmV0ID0gLUVPUE5PVFNVUFA7Ci0JCWdvdG8gb3V0OwotCX0KKwlpZiAoIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhsby0+bG9fZGV2aWNlKSkKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOwog CiAJcmV0ID0gZmlsZS0+Zl9vcC0+ZmFsbG9jYXRlKGZpbGUsIG1vZGUsIHBvcywgYmxrX3JxX2J5 dGVzKHJxKSk7CiAJaWYgKHVubGlrZWx5KHJldCAmJiByZXQgIT0gLUVJTlZBTCAmJiByZXQgIT0g LUVPUE5PVFNVUFApKQotCQlyZXQgPSAtRUlPOwotIG91dDoKKwkJcmV0dXJuIC1FSU87CiAJcmV0 dXJuIHJldDsKIH0KIApAQCAtNzg3LDEyICs3ODQsMTAgQEAgc3RhdGljIHZvaWQgbG9vcF9jb25m aWdfZGlzY2FyZChzdHJ1Y3QgbG9vcF9kZXZpY2UgKmxvKQogCQlxLT5saW1pdHMuZGlzY2FyZF9n cmFudWxhcml0eSA9IGdyYW51bGFyaXR5OwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9y cyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKIAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNf c2VjdG9ycyhxLCBtYXhfZGlzY2FyZF9zZWN0b3JzKTsKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFV RVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJfSBlbHNlIHsKIAkJcS0+bGltaXRzLmRpc2NhcmRfZ3Jh bnVsYXJpdHkgPSAwOwogCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCAwKTsKIAkJ YmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhxLCAwKTsKLQkJYmxrX3F1ZXVlX2Zs YWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsKIAl9CiAJcS0+bGltaXRzLmRpc2NhcmRf YWxpZ25tZW50ID0gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svbmJkLmMgYi9kcml2 ZXJzL2Jsb2NrL25iZC5jCmluZGV4IDVhMWY5ODQ5NGRkZGYuLjQ3MjlhZWY4YzY0NjIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYmxvY2svbmJkLmMKKysrIGIvZHJpdmVycy9ibG9jay9uYmQuYwpAQCAt MTIzMSw4ICsxMjMxLDYgQEAgc3RhdGljIHZvaWQgbmJkX3BhcnNlX2ZsYWdzKHN0cnVjdCBuYmRf ZGV2aWNlICpuYmQpCiAJCXNldF9kaXNrX3JvKG5iZC0+ZGlzaywgdHJ1ZSk7CiAJZWxzZQogCQlz ZXRfZGlza19ybyhuYmQtPmRpc2ssIGZhbHNlKTsKLQlpZiAoY29uZmlnLT5mbGFncyAmIE5CRF9G TEFHX1NFTkRfVFJJTSkKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwg bmJkLT5kaXNrLT5xdWV1ZSk7CiAJaWYgKGNvbmZpZy0+ZmxhZ3MgJiBOQkRfRkxBR19TRU5EX0ZM VVNIKSB7CiAJCWlmIChjb25maWctPmZsYWdzICYgTkJEX0ZMQUdfU0VORF9GVUEpCiAJCQlibGtf cXVldWVfd3JpdGVfY2FjaGUobmJkLT5kaXNrLT5xdWV1ZSwgdHJ1ZSwgdHJ1ZSk7CkBAIC0xMzE5 LDggKzEzMTcsNyBAQCBzdGF0aWMgdm9pZCBuYmRfY29uZmlnX3B1dChzdHJ1Y3QgbmJkX2Rldmlj ZSAqbmJkKQogCQluYmQtPnRhZ19zZXQudGltZW91dCA9IDA7CiAJCW5iZC0+ZGlzay0+cXVldWUt PmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJbmJkLT5kaXNrLT5xdWV1ZS0+bGlt aXRzLmRpc2NhcmRfYWxpZ25tZW50ID0gMDsKLQkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3Rv cnMobmJkLT5kaXNrLT5xdWV1ZSwgVUlOVF9NQVgpOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIG5iZC0+ZGlzay0+cXVldWUpOworCQlibGtfcXVldWVfbWF4X2Rp c2NhcmRfc2VjdG9ycyhuYmQtPmRpc2stPnF1ZXVlLCAwKTsKIAogCQltdXRleF91bmxvY2soJm5i ZC0+Y29uZmlnX2xvY2spOwogCQluYmRfcHV0KG5iZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Js b2NrL251bGxfYmxrL21haW4uYyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCmluZGV4 IDA1YjExMjBlNjYyMzQuLmY2NDkzYTllODVlZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sv bnVsbF9ibGsvbWFpbi5jCisrKyBiL2RyaXZlcnMvYmxvY2svbnVsbF9ibGsvbWFpbi5jCkBAIC0x NzY3LDcgKzE3NjcsNiBAQCBzdGF0aWMgdm9pZCBudWxsX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBu dWxsYiAqbnVsbGIpCiAJbnVsbGItPnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gbnVs bGItPmRldi0+YmxvY2tzaXplOwogCW51bGxiLT5xLT5saW1pdHMuZGlzY2FyZF9hbGlnbm1lbnQg PSBudWxsYi0+ZGV2LT5ibG9ja3NpemU7CiAJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMo bnVsbGItPnEsIFVJTlRfTUFYID4+IDkpOwotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFH X0RJU0NBUkQsIG51bGxiLT5xKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCBibG9ja19kZXZp Y2Vfb3BlcmF0aW9ucyBudWxsX2Jpb19vcHMgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2Nr L3JiZC5jIGIvZHJpdmVycy9ibG9jay9yYmQuYwppbmRleCBiODQ0NDMyYmFkMjBiLi4yYjIxZjcx N2NjZTFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3JiZC5jCisrKyBiL2RyaXZlcnMvYmxv Y2svcmJkLmMKQEAgLTQ5NDIsNyArNDk0Miw2IEBAIHN0YXRpYyBpbnQgcmJkX2luaXRfZGlzayhz dHJ1Y3QgcmJkX2RldmljZSAqcmJkX2RldikKIAlibGtfcXVldWVfaW9fb3B0KHEsIHJiZF9kZXYt Pm9wdHMtPmFsbG9jX3NpemUpOwogCiAJaWYgKHJiZF9kZXYtPm9wdHMtPnRyaW0pIHsKLQkJYmxr X3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiAJCXEtPmxpbWl0cy5kaXNj YXJkX2dyYW51bGFyaXR5ID0gcmJkX2Rldi0+b3B0cy0+YWxsb2Nfc2l6ZTsKIAkJYmxrX3F1ZXVl X21heF9kaXNjYXJkX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNFQ1RPUl9TSElGVCk7CiAJ CWJsa19xdWV1ZV9tYXhfd3JpdGVfemVyb2VzX3NlY3RvcnMocSwgb2Jqc2V0X2J5dGVzID4+IFNF Q1RPUl9TSElGVCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1jbHQuYyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCmluZGV4IGI2NmU4ODQwYjk0YjguLmVmYTk5 YTM4ODQ1MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCisrKyBi L2RyaXZlcnMvYmxvY2svcm5iZC9ybmJkLWNsdC5jCkBAIC0xMzY0LDggKzEzNjQsNiBAQCBzdGF0 aWMgdm9pZCBzZXR1cF9yZXF1ZXN0X3F1ZXVlKHN0cnVjdCBybmJkX2NsdF9kZXYgKmRldikKIAli bGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPnF1ZXVlLCBkZXYtPm1heF9kaXNjYXJk X3NlY3RvcnMpOwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5CT0gZGV2 LT5kaXNjYXJkX2dyYW51bGFyaXR5OwogCWRldi0+cXVldWUtPmxpbWl0cy5kaXNjYXJkX2FsaWdu bWVudAk9IGRldi0+ZGlzY2FyZF9hbGlnbm1lbnQ7Ci0JaWYgKGRldi0+bWF4X2Rpc2NhcmRfc2Vj dG9ycykKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgZGV2LT5xdWV1 ZSk7CiAJaWYgKGRldi0+c2VjdXJlX2Rpc2NhcmQpCiAJCWJsa19xdWV1ZV9mbGFnX3NldChRVUVV RV9GTEFHX1NFQ0VSQVNFLCBkZXYtPnF1ZXVlKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay9ybmJkL3JuYmQtc3J2LWRldi5oIGIvZHJpdmVycy9ibG9jay9ybmJkL3JuYmQtc3J2LWRldi5o CmluZGV4IGY4MmZiYjRiYmRhOGUuLjFmN2UxYzhmZDRkOWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv YmxvY2svcm5iZC9ybmJkLXNydi1kZXYuaAorKysgYi9kcml2ZXJzL2Jsb2NrL3JuYmQvcm5iZC1z cnYtZGV2LmgKQEAgLTQ5LDkgKzQ5LDYgQEAgc3RhdGljIGlubGluZSBpbnQgcm5iZF9kZXZfZ2V0 X3NlY3VyZV9kaXNjYXJkKGNvbnN0IHN0cnVjdCBybmJkX2RldiAqZGV2KQogCiBzdGF0aWMgaW5s aW5lIGludCBybmJkX2Rldl9nZXRfbWF4X2Rpc2NhcmRfc2VjdHMoY29uc3Qgc3RydWN0IHJuYmRf ZGV2ICpkZXYpCiB7Ci0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShkZXYt PmJkZXYpKSkKLQkJcmV0dXJuIDA7Ci0KIAlyZXR1cm4gYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KGRldi0+YmRldik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svdmlydGlvX2Jsay5j IGIvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKaW5kZXggYThiY2YzZjY2NGFmMS4uNmNjZjE1 MjUzZGVlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMKKysrIGIvZHJp dmVycy9ibG9jay92aXJ0aW9fYmxrLmMKQEAgLTg4OCw4ICs4ODgsNiBAQCBzdGF0aWMgaW50IHZp cnRibGtfcHJvYmUoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCiAJCQl2ID0gc2dfZWxlbXM7 CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWdtZW50cyhxLAogCQkJCQkgICAgICAgbWluKHYs IE1BWF9ESVNDQVJEX1NFR01FTlRTKSk7Ci0KLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZM QUdfRElTQ0FSRCwgcSk7CiAJfQogCiAJaWYgKHZpcnRpb19oYXNfZmVhdHVyZSh2ZGV2LCBWSVJU SU9fQkxLX0ZfV1JJVEVfWkVST0VTKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrYmFjay94ZW5idXMuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2sveGVuYnVzLmMKaW5k ZXggOGI2OTFmZTUwNDc1Zi4uODNjZDA4MDQxZTZiMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay94ZW4tYmxrYmFjay94ZW5idXMuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hl bmJ1cy5jCkBAIC01ODMsNyArNTgzLDcgQEAgc3RhdGljIHZvaWQgeGVuX2Jsa2JrX2Rpc2NhcmQo c3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQsIHN0cnVjdCBiYWNrZW5kX2luZm8KIAlpZiAo IXhlbmJ1c19yZWFkX3Vuc2lnbmVkKGRldi0+bm9kZW5hbWUsICJkaXNjYXJkLWVuYWJsZSIsIDEp KQogCQlyZXR1cm47CiAKLQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwlpZiAoYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKSB7CiAJCWVyciA9IHhlbmJ1c19wcmludGYoeGJ0LCBk ZXYtPm5vZGVuYW1lLAogCQkJImRpc2NhcmQtZ3JhbnVsYXJpdHkiLCAiJXUiLAogCQkJcS0+bGlt aXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4t YmxrZnJvbnQuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2Zyb250LmMKaW5kZXggMDAzMDU2ZDRm N2Y1Zi4uMjUzYmY4MzVhY2ExZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9jay94ZW4tYmxrZnJv bnQuYworKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtmcm9udC5jCkBAIC05NDQsNyArOTQ0LDYg QEAgc3RhdGljIHZvaWQgYmxraWZfc2V0X3F1ZXVlX2xpbWl0cyhzdHJ1Y3QgYmxrZnJvbnRfaW5m byAqaW5mbykKIAlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19WSVJULCBycSk7CiAKIAlp ZiAoaW5mby0+ZmVhdHVyZV9kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX0RJU0NBUkQsIHJxKTsKIAkJYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMocnEsIGdl dF9jYXBhY2l0eShnZCkpOwogCQlycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkgPSBpbmZv LT5kaXNjYXJkX2dyYW51bGFyaXR5ID86CiAJCQkJCQkgaW5mby0+cGh5c2ljYWxfc2VjdG9yX3Np emU7CkBAIC0xNjA2LDcgKzE2MDUsNiBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgYmxraWZfaW50ZXJy dXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAkJCQlibGtpZl9yZXEocmVxKS0+ZXJyb3IgPSBC TEtfU1RTX05PVFNVUFA7CiAJCQkJaW5mby0+ZmVhdHVyZV9kaXNjYXJkID0gMDsKIAkJCQlpbmZv LT5mZWF0dXJlX3NlY2Rpc2NhcmQgPSAwOwotCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfRElTQ0FSRCwgcnEpOwogCQkJCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdf U0VDRVJBU0UsIHJxKTsKIAkJCX0KIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9j ay96cmFtL3pyYW1fZHJ2LmMgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwppbmRleCBl OTQ3NGIwMjAxMmRlLi41OWZmNDQ0YmY2Yzc2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3py YW0venJhbV9kcnYuYworKysgYi9kcml2ZXJzL2Jsb2NrL3pyYW0venJhbV9kcnYuYwpAQCAtMTk1 Miw3ICsxOTUyLDYgQEAgc3RhdGljIGludCB6cmFtX2FkZCh2b2lkKQogCWJsa19xdWV1ZV9pb19v cHQoenJhbS0+ZGlzay0+cXVldWUsIFBBR0VfU0laRSk7CiAJenJhbS0+ZGlzay0+cXVldWUtPmxp bWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5ID0gUEFHRV9TSVpFOwogCWJsa19xdWV1ZV9tYXhfZGlz Y2FyZF9zZWN0b3JzKHpyYW0tPmRpc2stPnF1ZXVlLCBVSU5UX01BWCk7Ci0JYmxrX3F1ZXVlX2Zs YWdfc2V0KFFVRVVFX0ZMQUdfRElTQ0FSRCwgenJhbS0+ZGlzay0+cXVldWUpOwogCiAJLyoKIAkg KiB6cmFtX2Jpb19kaXNjYXJkKCkgd2lsbCBjbGVhciBhbGwgbG9naWNhbCBibG9ja3MgaWYgbG9n aWNhbCBibG9jawpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jIGIvZHJp dmVycy9tZC9iY2FjaGUvcmVxdWVzdC5jCmluZGV4IGZkZDAxOTRmODRkZDAuLmUyN2Y2N2YwNmE0 MjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hlL3JlcXVlc3QuYworKysgYi9kcml2ZXJz L21kL2JjYWNoZS9yZXF1ZXN0LmMKQEAgLTEwMDUsNyArMTAwNSw3IEBAIHN0YXRpYyB2b2lkIGNh Y2hlZF9kZXZfd3JpdGUoc3RydWN0IGNhY2hlZF9kZXYgKmRjLCBzdHJ1Y3Qgc2VhcmNoICpzKQog CQliaW9fZ2V0KHMtPmlvcC5iaW8pOwogCiAJCWlmIChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElT Q0FSRCAmJgotCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2 KSkpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGRjLT5iZGV2KSkKIAkJCWdvdG8g aW5zZXJ0X2RhdGE7CiAKIAkJLyogSS9PIHJlcXVlc3Qgc2VudCB0byBiYWNraW5nIGRldmljZSAq LwpAQCAtMTExNSw3ICsxMTE1LDcgQEAgc3RhdGljIHZvaWQgZGV0YWNoZWRfZGV2X2RvX3JlcXVl c3Qoc3RydWN0IGJjYWNoZV9kZXZpY2UgKmQsIHN0cnVjdCBiaW8gKmJpbywKIAliaW8tPmJpX3By aXZhdGUgPSBkZGlwOwogCiAJaWYgKChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYK LQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGRjLT5iZGV2KSkpCisJICAg ICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGMtPmJkZXYpKQogCQliaW8tPmJpX2VuZF9pbyhi aW8pOwogCWVsc2UKIAkJc3VibWl0X2Jpb19ub2FjY3QoYmlvKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWQvYmNhY2hlL3N1cGVyLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zdXBlci5jCmluZGV4IGJm M2RlMTQ5ZDNjOWYuLjJmNDllMzExNDJmNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvYmNhY2hl L3N1cGVyLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3VwZXIuYwpAQCAtOTczLDcgKzk3Myw2 IEBAIHN0YXRpYyBpbnQgYmNhY2hlX2RldmljZV9pbml0KHN0cnVjdCBiY2FjaGVfZGV2aWNlICpk LCB1bnNpZ25lZCBpbnQgYmxvY2tfc2l6ZSwKIAogCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9G TEFHX05PTlJPVCwgZC0+ZGlzay0+cXVldWUpOwogCWJsa19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVF X0ZMQUdfQUREX1JBTkRPTSwgZC0+ZGlzay0+cXVldWUpOwotCWJsa19xdWV1ZV9mbGFnX3NldChR VUVVRV9GTEFHX0RJU0NBUkQsIGQtPmRpc2stPnF1ZXVlKTsKIAogCWJsa19xdWV1ZV93cml0ZV9j YWNoZShxLCB0cnVlLCB0cnVlKTsKIApAQCAtMjM1MCw3ICsyMzQ5LDcgQEAgc3RhdGljIGludCBy ZWdpc3Rlcl9jYWNoZShzdHJ1Y3QgY2FjaGVfc2IgKnNiLCBzdHJ1Y3QgY2FjaGVfc2JfZGlzayAq c2JfZGlzaywKIAljYS0+YmRldi0+YmRfaG9sZGVyID0gY2E7CiAJY2EtPnNiX2Rpc2sgPSBzYl9k aXNrOwogCi0JaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSkKKwlp ZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKChiZGV2KSkpCiAJCWNhLT5kaXNjYXJkID0gQ0FD SEVfRElTQ0FSRCgmY2EtPnNiKTsKIAogCXJldCA9IGNhY2hlX2FsbG9jKGNhKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWQvYmNhY2hlL3N5c2ZzLmMgYi9kcml2ZXJzL21kL2JjYWNoZS9zeXNmcy5j CmluZGV4IGQxMDI5ZDcxZmYzYmMuLmM2ZjY3NzA1OTIxNGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWQvYmNhY2hlL3N5c2ZzLmMKKysrIGIvZHJpdmVycy9tZC9iY2FjaGUvc3lzZnMuYwpAQCAtMTE1 MSw3ICsxMTUxLDcgQEAgU1RPUkUoX19iY2hfY2FjaGUpCiAJaWYgKGF0dHIgPT0gJnN5c2ZzX2Rp c2NhcmQpIHsKIAkJYm9vbCB2ID0gc3RydG91bF9vcl9yZXR1cm4oYnVmKTsKIAotCQlpZiAoYmxr X3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoY2EtPmJkZXYpKSkKKwkJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhjYS0+YmRldikpCiAJCQljYS0+ZGlzY2FyZCA9IHY7CiAKIAkJaWYg KHYgIT0gQ0FDSEVfRElTQ0FSRCgmY2EtPnNiKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9k bS1jYWNoZS10YXJnZXQuYyBiL2RyaXZlcnMvbWQvZG0tY2FjaGUtdGFyZ2V0LmMKaW5kZXggNzgw YTYxYmM2Y2MwMy4uMjhjNWRlOGVjYTRhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1jYWNo ZS10YXJnZXQuYworKysgYi9kcml2ZXJzL21kL2RtLWNhY2hlLXRhcmdldC5jCkBAIC0zMzI5LDEz ICszMzI5LDYgQEAgc3RhdGljIGludCBjYWNoZV9pdGVyYXRlX2RldmljZXMoc3RydWN0IGRtX3Rh cmdldCAqdGksCiAJcmV0dXJuIHI7CiB9CiAKLXN0YXRpYyBib29sIG9yaWdpbl9kZXZfc3VwcG9y dHNfZGlzY2FyZChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpvcmlnaW5fYmRldikKLXsKLQlzdHJ1Y3Qg cmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKG9yaWdpbl9iZGV2KTsKLQotCXJldHVy biBibGtfcXVldWVfZGlzY2FyZChxKTsKLX0KLQogLyoKICAqIElmIGRpc2NhcmRfcGFzc2Rvd24g d2FzIGVuYWJsZWQgdmVyaWZ5IHRoYXQgdGhlIG9yaWdpbiBkZXZpY2UKICAqIHN1cHBvcnRzIGRp c2NhcmRzLiAgRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlmIG5vdC4KQEAgLTMzNDksNyArMzM0 Miw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25faWZfbm90X3N1cHBvcnRlZChzdHJ1 Y3QgY2FjaGUgKmNhY2hlKQogCWlmICghY2FjaGUtPmZlYXR1cmVzLmRpc2NhcmRfcGFzc2Rvd24p CiAJCXJldHVybjsKIAotCWlmICghb3JpZ2luX2Rldl9zdXBwb3J0c19kaXNjYXJkKG9yaWdpbl9i ZGV2KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhvcmlnaW5fYmRldikpCiAJCXJl YXNvbiA9ICJkaXNjYXJkIHVuc3VwcG9ydGVkIjsKIAogCWVsc2UgaWYgKG9yaWdpbl9saW1pdHMt Pm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjYWNoZS0+c2VjdG9yc19wZXJfYmxvY2spCmRpZmYgLS1n aXQgYS9kcml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jIGIvZHJpdmVycy9tZC9kbS1jbG9uZS10 YXJnZXQuYwppbmRleCAxMjgzMTZhNzNkMDE2Li44MTFiMGE1Mzc5ZDAzIDEwMDY0NAotLS0gYS9k cml2ZXJzL21kL2RtLWNsb25lLXRhcmdldC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tY2xvbmUtdGFy Z2V0LmMKQEAgLTIwMTYsMTMgKzIwMTYsNiBAQCBzdGF0aWMgdm9pZCBjbG9uZV9yZXN1bWUoc3Ry dWN0IGRtX3RhcmdldCAqdGkpCiAJZG9fd2FrZXIoJmNsb25lLT53YWtlci53b3JrKTsKIH0KIAot c3RhdGljIGJvb2wgYmRldl9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpi ZGV2KQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoYmRldik7 Ci0KLQlyZXR1cm4gKHEgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQocSkpOwotfQotCiAvKgogICogSWYg ZGlzY2FyZF9wYXNzZG93biB3YXMgZW5hYmxlZCB2ZXJpZnkgdGhhdCB0aGUgZGVzdGluYXRpb24g ZGV2aWNlIHN1cHBvcnRzCiAgKiBkaXNjYXJkcy4gRGlzYWJsZSBkaXNjYXJkX3Bhc3Nkb3duIGlm IG5vdC4KQEAgLTIwMzYsNyArMjAyOSw3IEBAIHN0YXRpYyB2b2lkIGRpc2FibGVfcGFzc2Rvd25f aWZfbm90X3N1cHBvcnRlZChzdHJ1Y3QgY2xvbmUgKmNsb25lKQogCWlmICghdGVzdF9iaXQoRE1f Q0xPTkVfRElTQ0FSRF9QQVNTRE9XTiwgJmNsb25lLT5mbGFncykpCiAJCXJldHVybjsKIAotCWlm ICghYmRldl9zdXBwb3J0c19kaXNjYXJkcyhkZXN0X2RldikpCisJaWYgKCFiZGV2X21heF9kaXNj YXJkX3NlY3RvcnMoZGVzdF9kZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAJZWxzZSBpZiAoZGVzdF9saW1pdHMtPm1heF9kaXNjYXJkX3NlY3RvcnMgPCBjbG9uZS0+cmVn aW9uX3NpemUpCiAJCXJlYXNvbiA9ICJtYXggZGlzY2FyZCBzZWN0b3JzIHNtYWxsZXIgdGhhbiBh IHJlZ2lvbiI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy13cml0ZXMuYyBiL2RyaXZl cnMvbWQvZG0tbG9nLXdyaXRlcy5jCmluZGV4IGM5ZDAzNmQ2YmIyZWUuLmUxOTQyMjZjODllNTQg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tbG9nLXdyaXRlcy5jCisrKyBiL2RyaXZlcnMvbWQv ZG0tbG9nLXdyaXRlcy5jCkBAIC04NjYsOSArODY2LDggQEAgc3RhdGljIGludCBsb2dfd3JpdGVz X21lc3NhZ2Uoc3RydWN0IGRtX3RhcmdldCAqdGksIHVuc2lnbmVkIGFyZ2MsIGNoYXIgKiphcmd2 LAogc3RhdGljIHZvaWQgbG9nX3dyaXRlc19pb19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRzKQogewogCXN0cnVjdCBsb2dfd3JpdGVzX2MgKmxj ID0gdGktPnByaXZhdGU7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1 ZShsYy0+ZGV2LT5iZGV2KTsKIAotCWlmICghcSB8fCAhYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsK KwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhsYy0+ZGV2LT5iZGV2KSkgewogCQlsYy0+ ZGV2aWNlX3N1cHBvcnRzX2Rpc2NhcmQgPSBmYWxzZTsKIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51 bGFyaXR5ID0gbGMtPnNlY3RvcnNpemU7CiAJCWxpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA9 IChVSU5UX01BWCA+PiBTRUNUT1JfU0hJRlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1y YWlkLmMgYi9kcml2ZXJzL21kL2RtLXJhaWQuYwppbmRleCAyYjI2NDM1YTY5NDZlLi45NTI2Y2Ni ZWRhZmJhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXJhaWQuYworKysgYi9kcml2ZXJzL21k L2RtLXJhaWQuYwpAQCAtMjk2MywxMyArMjk2Myw4IEBAIHN0YXRpYyB2b2lkIGNvbmZpZ3VyZV9k aXNjYXJkX3N1cHBvcnQoc3RydWN0IHJhaWRfc2V0ICpycykKIAlyYWlkNDU2ID0gcnNfaXNfcmFp ZDQ1Nihycyk7CiAKIAlmb3IgKGkgPSAwOyBpIDwgcnMtPnJhaWRfZGlza3M7IGkrKykgewotCQlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcTsKLQotCQlpZiAoIXJzLT5kZXZbaV0ucmRldi5iZGV2KQot CQkJY29udGludWU7Ci0KLQkJcSA9IGJkZXZfZ2V0X3F1ZXVlKHJzLT5kZXZbaV0ucmRldi5iZGV2 KTsKLQkJaWYgKCFxIHx8ICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwkJaWYgKCFycy0+ZGV2W2ld LnJkZXYuYmRldiB8fAorCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhycy0+ZGV2W2ld LnJkZXYuYmRldikpCiAJCQlyZXR1cm47CiAKIAkJaWYgKHJhaWQ0NTYpIHsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWQvZG0tdGFibGUuYyBiL2RyaXZlcnMvbWQvZG0tdGFibGUuYwppbmRleCBkNDY4 MzlmYWEwY2E1Li4wZGZmNjkwN2ZkMDBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXRhYmxl LmMKKysrIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCkBAIC0xODg4LDkgKzE4ODgsNyBAQCBzdGF0 aWMgYm9vbCBkbV90YWJsZV9zdXBwb3J0c19ub3dhaXQoc3RydWN0IGRtX3RhYmxlICp0KQogc3Rh dGljIGludCBkZXZpY2Vfbm90X2Rpc2NhcmRfY2FwYWJsZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwg c3RydWN0IGRtX2RldiAqZGV2LAogCQkJCSAgICAgIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBs ZW4sIHZvaWQgKmRhdGEpCiB7Ci0Jc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9x dWV1ZShkZXYtPmJkZXYpOwotCi0JcmV0dXJuICFibGtfcXVldWVfZGlzY2FyZChxKTsKKwlyZXR1 cm4gIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhkZXYtPmJkZXYpOwogfQogCiBzdGF0aWMgYm9v bCBkbV90YWJsZV9zdXBwb3J0c19kaXNjYXJkcyhzdHJ1Y3QgZG1fdGFibGUgKnQpCkBAIC0xOTcw LDE1ICsxOTY4LDEyIEBAIGludCBkbV90YWJsZV9zZXRfcmVzdHJpY3Rpb25zKHN0cnVjdCBkbV90 YWJsZSAqdCwgc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsCiAJCWJsa19xdWV1ZV9mbGFnX2NsZWFy KFFVRVVFX0ZMQUdfTk9XQUlULCBxKTsKIAogCWlmICghZG1fdGFibGVfc3VwcG9ydHNfZGlzY2Fy ZHModCkpIHsKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBxKTsK LQkJLyogTXVzdCBhbHNvIGNsZWFyIGRpc2NhcmQgbGltaXRzLi4uICovCiAJCXEtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzID0gMDsKIAkJcS0+bGltaXRzLm1heF9od19kaXNjYXJkX3NlY3Rv cnMgPSAwOwogCQlxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IDA7CiAJCXEtPmxpbWl0 cy5kaXNjYXJkX2FsaWdubWVudCA9IDA7CiAJCXEtPmxpbWl0cy5kaXNjYXJkX21pc2FsaWduZWQg PSAwOwotCX0gZWxzZQotCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBx KTsKKwl9CiAKIAlpZiAoZG1fdGFibGVfc3VwcG9ydHNfc2VjdXJlX2VyYXNlKHQpKQogCQlibGtf cXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19TRUNFUkFTRSwgcSk7CmRpZmYgLS1naXQgYS9kcml2 ZXJzL21kL2RtLXRoaW4uYyBiL2RyaXZlcnMvbWQvZG0tdGhpbi5jCmluZGV4IDRkMjVkMGUyNzAz MTMuLmVkZWQ0YmNjNDU0NWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGhpbi5jCisrKyBi L2RyaXZlcnMvbWQvZG0tdGhpbi5jCkBAIC0yODAyLDEzICsyODAyLDYgQEAgc3RhdGljIHZvaWQg cmVxdWV1ZV9iaW9zKHN0cnVjdCBwb29sICpwb29sKQogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBCaW5kaW5nIG9m IGNvbnRyb2wgdGFyZ2V0cyB0byBhIHBvb2wgb2JqZWN0CiAgKi0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLXN0YXRpYyBib29s IGRhdGFfZGV2X3N1cHBvcnRzX2Rpc2NhcmQoc3RydWN0IHBvb2xfYyAqcHQpCi17Ci0Jc3RydWN0 IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShwdC0+ZGF0YV9kZXYtPmJkZXYpOwot Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKHEpOwotfQotCiBzdGF0aWMgYm9vbCBpc19mYWN0 b3Ioc2VjdG9yX3QgYmxvY2tfc2l6ZSwgdWludDMyX3QgbikKIHsKIAlyZXR1cm4gIXNlY3Rvcl9k aXYoYmxvY2tfc2l6ZSwgbik7CkBAIC0yODI4LDcgKzI4MjEsNyBAQCBzdGF0aWMgdm9pZCBkaXNh YmxlX3Bhc3Nkb3duX2lmX25vdF9zdXBwb3J0ZWQoc3RydWN0IHBvb2xfYyAqcHQpCiAJaWYgKCFw dC0+YWRqdXN0ZWRfcGYuZGlzY2FyZF9wYXNzZG93bikKIAkJcmV0dXJuOwogCi0JaWYgKCFkYXRh X2Rldl9zdXBwb3J0c19kaXNjYXJkKHB0KSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhwdC0+ZGF0YV9kZXYtPmJkZXYpKQogCQlyZWFzb24gPSAiZGlzY2FyZCB1bnN1cHBvcnRlZCI7 CiAKIAllbHNlIGlmIChkYXRhX2xpbWl0cy0+bWF4X2Rpc2NhcmRfc2VjdG9ycyA8IHBvb2wtPnNl Y3RvcnNfcGVyX2Jsb2NrKQpAQCAtNDA1Nyw4ICs0MDUwLDYgQEAgc3RhdGljIHZvaWQgcG9vbF9p b19oaW50cyhzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgc3RydWN0IHF1ZXVlX2xpbWl0cyAqbGltaXRz KQogCQkvKgogCQkgKiBNdXN0IGV4cGxpY2l0bHkgZGlzYWxsb3cgc3RhY2tpbmcgZGlzY2FyZCBs aW1pdHMgb3RoZXJ3aXNlIHRoZQogCQkgKiBibG9jayBsYXllciB3aWxsIHN0YWNrIHRoZW0gaWYg cG9vbCdzIGRhdGEgZGV2aWNlIGhhcyBzdXBwb3J0LgotCQkgKiBRVUVVRV9GTEFHX0RJU0NBUkQg d291bGRuJ3QgYmUgc2V0IGJ1dCB0aGVyZSBpcyBubyB3YXkgZm9yIHRoZQotCQkgKiB1c2VyIHRv IHNlZSB0aGF0LCBzbyBtYWtlIHN1cmUgdG8gc2V0IGFsbCBkaXNjYXJkIGxpbWl0cyB0byAwLgog CQkgKi8KIAkJbGltaXRzLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gMDsKIAkJcmV0dXJuOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9tZC9kbS5jIGIvZHJpdmVycy9tZC9kbS5jCmluZGV4IDNjNWZhZDdj NGVlNjguLmRiYmY2NGNlN2U5MjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0uYworKysgYi9k cml2ZXJzL21kL2RtLmMKQEAgLTk1NSw3ICs5NTUsNiBAQCB2b2lkIGRpc2FibGVfZGlzY2FyZChz dHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCiAKIAkvKiBkZXZpY2UgZG9lc24ndCByZWFsbHkgc3Vw cG9ydCBESVNDQVJELCBkaXNhYmxlIGl0ICovCiAJbGltaXRzLT5tYXhfZGlzY2FyZF9zZWN0b3Jz ID0gMDsKLQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIG1kLT5xdWV1 ZSk7CiB9CiAKIHZvaWQgZGlzYWJsZV93cml0ZV96ZXJvZXMoc3RydWN0IG1hcHBlZF9kZXZpY2Ug Km1kKQpAQCAtOTgyLDcgKzk4MSw3IEBAIHN0YXRpYyB2b2lkIGNsb25lX2VuZGlvKHN0cnVjdCBi aW8gKmJpbykKIAogCWlmICh1bmxpa2VseShlcnJvciA9PSBCTEtfU1RTX1RBUkdFVCkpIHsKIAkJ aWYgKGJpb19vcChiaW8pID09IFJFUV9PUF9ESVNDQVJEICYmCi0JCSAgICAhcS0+bGltaXRzLm1h eF9kaXNjYXJkX3NlY3RvcnMpCisJCSAgICAhYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+ YmlfYmRldikpCiAJCQlkaXNhYmxlX2Rpc2NhcmQobWQpOwogCQllbHNlIGlmIChiaW9fb3AoYmlv KSA9PSBSRVFfT1BfV1JJVEVfWkVST0VTICYmCiAJCQkgIXEtPmxpbWl0cy5tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLWxpbmVhci5jIGIvZHJpdmVy cy9tZC9tZC1saW5lYXIuYwppbmRleCAwZjU1YjA3OTM3MWIxLi4xMzhhM2IyNWM1YzgyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL21kL21kLWxpbmVhci5jCisrKyBiL2RyaXZlcnMvbWQvbWQtbGluZWFy LmMKQEAgLTY0LDcgKzY0LDYgQEAgc3RhdGljIHN0cnVjdCBsaW5lYXJfY29uZiAqbGluZWFyX2Nv bmYoc3RydWN0IG1kZGV2ICptZGRldiwgaW50IHJhaWRfZGlza3MpCiAJc3RydWN0IGxpbmVhcl9j b25mICpjb25mOwogCXN0cnVjdCBtZF9yZGV2ICpyZGV2OwogCWludCBpLCBjbnQ7Ci0JYm9vbCBk aXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJY29uZiA9IGt6YWxsb2Moc3RydWN0X3NpemUo Y29uZiwgZGlza3MsIHJhaWRfZGlza3MpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWNvbmYpCkBAIC05 Niw5ICs5NSw2IEBAIHN0YXRpYyBzdHJ1Y3QgbGluZWFyX2NvbmYgKmxpbmVhcl9jb25mKHN0cnVj dCBtZGRldiAqbWRkZXYsIGludCByYWlkX2Rpc2tzKQogCiAJCWNvbmYtPmFycmF5X3NlY3RvcnMg Kz0gcmRldi0+c2VjdG9yczsKIAkJY250Kys7Ci0KLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJk ZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsK IAl9CiAJaWYgKGNudCAhPSByYWlkX2Rpc2tzKSB7CiAJCXByX3dhcm4oIm1kL2xpbmVhcjolczog bm90IGVub3VnaCBkcml2ZXMgcHJlc2VudC4gQWJvcnRpbmchXG4iLApAQCAtMTA2LDExICsxMDIs NiBAQCBzdGF0aWMgc3RydWN0IGxpbmVhcl9jb25mICpsaW5lYXJfY29uZihzdHJ1Y3QgbWRkZXYg Km1kZGV2LCBpbnQgcmFpZF9kaXNrcykKIAkJZ290byBvdXQ7CiAJfQogCi0JaWYgKCFkaXNjYXJk X3N1cHBvcnRlZCkKLQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVNDQVJELCBt ZGRldi0+cXVldWUpOwotCWVsc2UKLQkJYmxrX3F1ZXVlX2ZsYWdfc2V0KFFVRVVFX0ZMQUdfRElT Q0FSRCwgbWRkZXYtPnF1ZXVlKTsKLQogCS8qCiAJICogSGVyZSB3ZSBjYWxjdWxhdGUgdGhlIGRl dmljZSBvZmZzZXRzLgogCSAqLwpAQCAtMjUyLDcgKzI0Myw3IEBAIHN0YXRpYyBib29sIGxpbmVh cl9tYWtlX3JlcXVlc3Qoc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IGJpbyAqYmlvKQogCQlz dGFydF9zZWN0b3IgKyBkYXRhX29mZnNldDsKIAogCWlmICh1bmxpa2VseSgoYmlvX29wKGJpbykg PT0gUkVRX09QX0RJU0NBUkQpICYmCi0JCSAgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkgeworCQkgICAgICFiZGV2X21heF9kaXNjYXJkX3NlY3Rv cnMoYmlvLT5iaV9iZGV2KSkpIHsKIAkJLyogSnVzdCBpZ25vcmUgaXQgKi8KIAkJYmlvX2VuZGlv KGJpbyk7CiAJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDAuYyBiL2RyaXZl cnMvbWQvcmFpZDAuYwppbmRleCBiMjFlMTAxMTgzZjQ0Li43MjMxZjVlMWVhYTczIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQwLmMKKysrIGIvZHJpdmVycy9tZC9yYWlkMC5jCkBAIC0zOTks NyArMzk5LDYgQEAgc3RhdGljIGludCByYWlkMF9ydW4oc3RydWN0IG1kZGV2ICptZGRldikKIAlj b25mID0gbWRkZXYtPnByaXZhdGU7CiAJaWYgKG1kZGV2LT5xdWV1ZSkgewogCQlzdHJ1Y3QgbWRf cmRldiAqcmRldjsKLQkJYm9vbCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJCWJsa19x dWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2LT5jaHVua19zZWN0b3JzKTsK IAkJYmxrX3F1ZXVlX21heF93cml0ZV96ZXJvZXNfc2VjdG9ycyhtZGRldi0+cXVldWUsIG1kZGV2 LT5jaHVua19zZWN0b3JzKTsKQEAgLTQxMiwxMyArNDExLDcgQEAgc3RhdGljIGludCByYWlkMF9y dW4oc3RydWN0IG1kZGV2ICptZGRldikKIAkJcmRldl9mb3JfZWFjaChyZGV2LCBtZGRldikgewog CQkJZGlza19zdGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJCSAg cmRldi0+ZGF0YV9vZmZzZXQgPDwgOSk7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUocmRldi0+YmRldikpKQotCQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJ fQotCQlpZiAoIWRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVF VUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwotCQllbHNlCi0JCQlibGtfcXVldWVfZmxh Z19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCX0KIAogCS8qIGNhbGN1 bGF0ZSBhcnJheSBkZXZpY2Ugc2l6ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9yYWlkMS5j IGIvZHJpdmVycy9tZC9yYWlkMS5jCmluZGV4IGQ4MWI4OTY4NTVmOWYuLjNkYTc0OWQxNTBhMTcg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvcmFpZDEuYworKysgYi9kcml2ZXJzL21kL3JhaWQxLmMK QEAgLTgwMiw3ICs4MDIsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9iaW9fbGlzdChzdHJ1Y3QgcjFj b25mICpjb25mLCBzdHJ1Y3QgYmlvICpiaW8pCiAJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2 LT5mbGFncykpIHsKIAkJCWJpb19pb19lcnJvcihiaW8pOwogCQl9IGVsc2UgaWYgKHVubGlrZWx5 KChiaW9fb3AoYmlvKSA9PSBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9k aXNjYXJkKGJpby0+YmlfYmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICov CiAJCQliaW9fZW5kaW8oYmlvKTsKIAkJZWxzZQpAQCAtMTgyNiw4ICsxODI2LDYgQEAgc3RhdGlj IGludCByYWlkMV9hZGRfZGlzayhzdHJ1Y3QgbWRkZXYgKm1kZGV2LCBzdHJ1Y3QgbWRfcmRldiAq cmRldikKIAkJCWJyZWFrOwogCQl9CiAJfQotCWlmIChtZGRldi0+cXVldWUgJiYgYmxrX3F1ZXVl X2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQotCQlibGtfcXVldWVfZmxhZ19z ZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwogCXByaW50X2NvbmYoY29uZik7 CiAJcmV0dXJuIGVycjsKIH0KQEAgLTMxMDYsNyArMzEwNCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFf cnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJaW50IGk7CiAJc3RydWN0IG1kX3JkZXYgKnJkZXY7 CiAJaW50IHJldDsKLQlib29sIGRpc2NhcmRfc3VwcG9ydGVkID0gZmFsc2U7CiAKIAlpZiAobWRk ZXYtPmxldmVsICE9IDEpIHsKIAkJcHJfd2FybigibWQvcmFpZDE6JXM6IHJhaWQgbGV2ZWwgbm90 IHNldCB0byBtaXJyb3JpbmcgKCVkKVxuIiwKQEAgLTMxNDEsOCArMzEzOCw2IEBAIHN0YXRpYyBp bnQgcmFpZDFfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQljb250aW51ZTsKIAkJZGlza19z dGFja19saW1pdHMobWRkZXYtPmdlbmRpc2ssIHJkZXYtPmJkZXYsCiAJCQkJICByZGV2LT5kYXRh X29mZnNldCA8PCA5KTsKLQkJaWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJk ZXYtPmJkZXYpKSkKLQkJCWRpc2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAl9CiAKIAltZGRldi0+ ZGVncmFkZWQgPSAwOwpAQCAtMzE3OSwxNSArMzE3NCw2IEBAIHN0YXRpYyBpbnQgcmFpZDFfcnVu KHN0cnVjdCBtZGRldiAqbWRkZXYpCiAKIAltZF9zZXRfYXJyYXlfc2VjdG9ycyhtZGRldiwgcmFp ZDFfc2l6ZShtZGRldiwgMCwgMCkpOwogCi0JaWYgKG1kZGV2LT5xdWV1ZSkgewotCQlpZiAoZGlz Y2FyZF9zdXBwb3J0ZWQpCi0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJE LAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIo UVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJICBtZGRldi0+cXVldWUpOwotCX0KLQogCXJldCA9 IG1kX2ludGVncml0eV9yZWdpc3RlcihtZGRldik7CiAJaWYgKHJldCkgewogCQltZF91bnJlZ2lz dGVyX3RocmVhZCgmbWRkZXYtPnRocmVhZCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQx MC5jIGIvZHJpdmVycy9tZC9yYWlkMTAuYwppbmRleCA3ODE2YzhiMmU4MDg3Li4zNmE0NjAwMTVj ZjU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL3JhaWQxMC5jCisrKyBiL2RyaXZlcnMvbWQvcmFp ZDEwLmMKQEAgLTg4OCw3ICs4ODgsNyBAQCBzdGF0aWMgdm9pZCBmbHVzaF9wZW5kaW5nX3dyaXRl cyhzdHJ1Y3QgcjEwY29uZiAqY29uZikKIAkJCWlmICh0ZXN0X2JpdChGYXVsdHksICZyZGV2LT5m bGFncykpIHsKIAkJCQliaW9faW9fZXJyb3IoYmlvKTsKIAkJCX0gZWxzZSBpZiAodW5saWtlbHko KGJpb19vcChiaW8pID09ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkJICAgICFibGtfcXVldWVf ZGlzY2FyZChiaW8tPmJpX2JkZXYtPmJkX2Rpc2stPnF1ZXVlKSkpCisJCQkJCSAgICAhYmRldl9t YXhfZGlzY2FyZF9zZWN0b3JzKGJpby0+YmlfYmRldikpKQogCQkJCS8qIEp1c3QgaWdub3JlIGl0 ICovCiAJCQkJYmlvX2VuZGlvKGJpbyk7CiAJCQllbHNlCkBAIC0xMDgzLDcgKzEwODMsNyBAQCBz dGF0aWMgdm9pZCByYWlkMTBfdW5wbHVnKHN0cnVjdCBibGtfcGx1Z19jYiAqY2IsIGJvb2wgZnJv bV9zY2hlZHVsZSkKIAkJaWYgKHRlc3RfYml0KEZhdWx0eSwgJnJkZXYtPmZsYWdzKSkgewogCQkJ YmlvX2lvX2Vycm9yKGJpbyk7CiAJCX0gZWxzZSBpZiAodW5saWtlbHkoKGJpb19vcChiaW8pID09 ICBSRVFfT1BfRElTQ0FSRCkgJiYKLQkJCQkgICAgIWJsa19xdWV1ZV9kaXNjYXJkKGJpby0+Ymlf YmRldi0+YmRfZGlzay0+cXVldWUpKSkKKwkJCQkgICAgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9y cyhiaW8tPmJpX2JkZXYpKSkKIAkJCS8qIEp1c3QgaWdub3JlIGl0ICovCiAJCQliaW9fZW5kaW8o YmlvKTsKIAkJZWxzZQpAQCAtMjE0NCw4ICsyMTQ0LDYgQEAgc3RhdGljIGludCByYWlkMTBfYWRk X2Rpc2soc3RydWN0IG1kZGV2ICptZGRldiwgc3RydWN0IG1kX3JkZXYgKnJkZXYpCiAJCXJjdV9h c3NpZ25fcG9pbnRlcihwLT5yZGV2LCByZGV2KTsKIAkJYnJlYWs7CiAJfQotCWlmIChtZGRldi0+ cXVldWUgJiYgYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUocmRldi0+YmRldikpKQot CQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELCBtZGRldi0+cXVldWUpOwog CiAJcHJpbnRfY29uZihjb25mKTsKIAlyZXR1cm4gZXJyOwpAQCAtNDA2OSw3ICs0MDY3LDYgQEAg c3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJc2VjdG9yX3Qgc2l6 ZTsKIAlzZWN0b3JfdCBtaW5fb2Zmc2V0X2RpZmYgPSAwOwogCWludCBmaXJzdCA9IDE7Ci0JYm9v bCBkaXNjYXJkX3N1cHBvcnRlZCA9IGZhbHNlOwogCiAJaWYgKG1kZGV2X2luaXRfd3JpdGVzX3Bl bmRpbmcobWRkZXYpIDwgMCkKIAkJcmV0dXJuIC1FTk9NRU07CkBAIC00MTQwLDIwICs0MTM3LDkg QEAgc3RhdGljIGludCByYWlkMTBfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYpCiAJCQkJCSAgcmRl di0+ZGF0YV9vZmZzZXQgPDwgOSk7CiAKIAkJZGlzay0+aGVhZF9wb3NpdGlvbiA9IDA7Ci0KLQkJ aWYgKGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKHJkZXYtPmJkZXYpKSkKLQkJCWRp c2NhcmRfc3VwcG9ydGVkID0gdHJ1ZTsKIAkJZmlyc3QgPSAwOwogCX0KIAotCWlmIChtZGRldi0+ cXVldWUpIHsKLQkJaWYgKGRpc2NhcmRfc3VwcG9ydGVkKQotCQkJYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCW1kZGV2LT5xdWV1ZSk7Ci0JCWVsc2UKLQkJCWJs a19xdWV1ZV9mbGFnX2NsZWFyKFFVRVVFX0ZMQUdfRElTQ0FSRCwKLQkJCQkJCSAgbWRkZXYtPnF1 ZXVlKTsKLQl9CiAJLyogbmVlZCB0byBjaGVjayB0aGF0IGV2ZXJ5IGJsb2NrIGhhcyBhdCBsZWFz dCBvbmUgd29ya2luZyBtaXJyb3IgKi8KIAlpZiAoIWVub3VnaChjb25mLCAtMSkpIHsKIAkJcHJf ZXJyKCJtZC9yYWlkMTA6JXM6IG5vdCBlbm91Z2ggb3BlcmF0aW9uYWwgbWlycm9ycy5cbiIsCmRp ZmYgLS1naXQgYS9kcml2ZXJzL21kL3JhaWQ1LWNhY2hlLmMgYi9kcml2ZXJzL21kL3JhaWQ1LWNh Y2hlLmMKaW5kZXggYTdkNTBmZjkwMjBhOC4uYzNjYmY5YTU3NGEzOSAxMDA2NDQKLS0tIGEvZHJp dmVycy9tZC9yYWlkNS1jYWNoZS5jCisrKyBiL2RyaXZlcnMvbWQvcmFpZDUtY2FjaGUuYwpAQCAt MTMxOCw3ICsxMzE4LDcgQEAgc3RhdGljIHZvaWQgcjVsX3dyaXRlX3N1cGVyX2FuZF9kaXNjYXJk X3NwYWNlKHN0cnVjdCByNWxfbG9nICpsb2csCiAKIAlyNWxfd3JpdGVfc3VwZXIobG9nLCBlbmQp OwogCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChiZGV2X2dldF9xdWV1ZShiZGV2KSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoYmRldikpCiAJCXJldHVybjsKIAogCW1kZGV2ID0g bG9nLT5yZGV2LT5tZGRldjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvcmFpZDUuYyBiL2RyaXZl cnMvbWQvcmFpZDUuYwppbmRleCAwYmJhZTBlNjM4NjY2Li41OWY5MWUzOTJhMmFlIDEwMDY0NAot LS0gYS9kcml2ZXJzL21kL3JhaWQ1LmMKKysrIGIvZHJpdmVycy9tZC9yYWlkNS5jCkBAIC03Nzc2 LDE0ICs3Nzc2LDEwIEBAIHN0YXRpYyBpbnQgcmFpZDVfcnVuKHN0cnVjdCBtZGRldiAqbWRkZXYp CiAJCSAqIEEgYmV0dGVyIGlkZWEgbWlnaHQgYmUgdG8gdHVybiBESVNDQVJEIGludG8gV1JJVEVf WkVST0VTCiAJCSAqIHJlcXVlc3RzLCBhcyB0aGF0IGlzIHJlcXVpcmVkIHRvIGJlIHNhZmUuCiAJ CSAqLwotCQlpZiAoZGV2aWNlc19oYW5kbGVfZGlzY2FyZF9zYWZlbHkgJiYKLQkJICAgIG1kZGV2 LT5xdWV1ZS0+bGltaXRzLm1heF9kaXNjYXJkX3NlY3RvcnMgPj0gKHN0cmlwZSA+PiA5KSAmJgot CQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA+PSBzdHJpcGUp Ci0JCQlibGtfcXVldWVfZmxhZ19zZXQoUVVFVUVfRkxBR19ESVNDQVJELAotCQkJCQkJbWRkZXYt PnF1ZXVlKTsKLQkJZWxzZQotCQkJYmxrX3F1ZXVlX2ZsYWdfY2xlYXIoUVVFVUVfRkxBR19ESVND QVJELAotCQkJCQkJbWRkZXYtPnF1ZXVlKTsKKwkJaWYgKCFkZXZpY2VzX2hhbmRsZV9kaXNjYXJk X3NhZmVseSB8fAorCQkgICAgbWRkZXYtPnF1ZXVlLT5saW1pdHMubWF4X2Rpc2NhcmRfc2VjdG9y cyA8IChzdHJpcGUgPj4gOSkgfHwKKwkJICAgIG1kZGV2LT5xdWV1ZS0+bGltaXRzLmRpc2NhcmRf Z3JhbnVsYXJpdHkgPCBzdHJpcGUpCisJCQlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyht ZGRldi0+cXVldWUsIDApOwogCiAJCWJsa19xdWV1ZV9tYXhfaHdfc2VjdG9ycyhtZGRldi0+cXVl dWUsIFVJTlRfTUFYKTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMg Yi9kcml2ZXJzL21tYy9jb3JlL3F1ZXVlLmMKaW5kZXggYzY5YjJkOWRmNmYxNi4uY2FjNjMxNTAx MGEzZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9xdWV1ZS5jCisrKyBiL2RyaXZlcnMv bW1jL2NvcmUvcXVldWUuYwpAQCAtMTgzLDcgKzE4Myw2IEBAIHN0YXRpYyB2b2lkIG1tY19xdWV1 ZV9zZXR1cF9kaXNjYXJkKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLAogCWlmICghbWF4X2Rpc2Nh cmQpCiAJCXJldHVybjsKIAotCWJsa19xdWV1ZV9mbGFnX3NldChRVUVVRV9GTEFHX0RJU0NBUkQs IHEpOwogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3JzKHEsIG1heF9kaXNjYXJkKTsKIAlx LT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSA9IGNhcmQtPnByZWZfZXJhc2UgPDwgOTsKIAkv KiBncmFudWxhcml0eSBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gbWF4LiBkaXNjYXJkICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jIGIvZHJpdmVycy9tdGQvbXRkX2Js a2RldnMuYwppbmRleCA2NGQyYjA5M2YxMTRiLi5mNzMxNzIxMTE0NjU1IDEwMDY0NAotLS0gYS9k cml2ZXJzL210ZC9tdGRfYmxrZGV2cy5jCisrKyBiL2RyaXZlcnMvbXRkL210ZF9ibGtkZXZzLmMK QEAgLTM3Nyw3ICszNzcsNiBAQCBpbnQgYWRkX210ZF9ibGt0cmFuc19kZXYoc3RydWN0IG10ZF9i bGt0cmFuc19kZXYgKm5ldykKIAlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0FERF9S QU5ET00sIG5ldy0+cnEpOwogCiAJaWYgKHRyLT5kaXNjYXJkKSB7Ci0JCWJsa19xdWV1ZV9mbGFn X3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIG5ldy0+cnEpOwogCQlibGtfcXVldWVfbWF4X2Rpc2Nh cmRfc2VjdG9ycyhuZXctPnJxLCBVSU5UX01BWCk7CiAJCW5ldy0+cnEtPmxpbWl0cy5kaXNjYXJk X2dyYW51bGFyaXR5ID0gdHItPmJsa3NpemU7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l L2hvc3QvY29yZS5jIGIvZHJpdmVycy9udm1lL2hvc3QvY29yZS5jCmluZGV4IGVmYjg1YzZkOGUy ZDUuLjdlMDdkZDY5MjYyYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwor KysgYi9kcml2ZXJzL252bWUvaG9zdC9jb3JlLmMKQEAgLTE2MDcsMTAgKzE2MDcsOCBAQCBzdGF0 aWMgdm9pZCBudm1lX2NvbmZpZ19kaXNjYXJkKHN0cnVjdCBnZW5kaXNrICpkaXNrLCBzdHJ1Y3Qg bnZtZV9ucyAqbnMpCiAJc3RydWN0IHJlcXVlc3RfcXVldWUgKnF1ZXVlID0gZGlzay0+cXVldWU7 CiAJdTMyIHNpemUgPSBxdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUocXVldWUpOwogCi0JaWYgKGN0 cmwtPm1heF9kaXNjYXJkX3NlY3RvcnMgPT0gMCkgewotCQlibGtfcXVldWVfZmxhZ19jbGVhcihR VUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKTsKKwlpZiAoY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9y cyA9PSAwKQogCQlyZXR1cm47Ci0JfQogCiAJQlVJTERfQlVHX09OKFBBR0VfU0laRSAvIHNpemVv ZihzdHJ1Y3QgbnZtZV9kc21fcmFuZ2UpIDwKIAkJCU5WTUVfRFNNX01BWF9SQU5HRVMpOwpAQCAt MTYxOSw3ICsxNjE3LDcgQEAgc3RhdGljIHZvaWQgbnZtZV9jb25maWdfZGlzY2FyZChzdHJ1Y3Qg Z2VuZGlzayAqZGlzaywgc3RydWN0IG52bWVfbnMgKm5zKQogCXF1ZXVlLT5saW1pdHMuZGlzY2Fy ZF9ncmFudWxhcml0eSA9IHNpemU7CiAKIAkvKiBJZiBkaXNjYXJkIGlzIGFscmVhZHkgZW5hYmxl ZCwgZG9uJ3QgcmVzZXQgcXVldWUgbGltaXRzICovCi0JaWYgKGJsa19xdWV1ZV9mbGFnX3Rlc3Rf YW5kX3NldChRVUVVRV9GTEFHX0RJU0NBUkQsIHF1ZXVlKSkKKwlpZiAocXVldWUtPmxpbWl0cy5t YXhfZGlzY2FyZF9zZWN0b3JzKQogCQlyZXR1cm47CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRf c2VjdG9ycyhxdWV1ZSwgY3RybC0+bWF4X2Rpc2NhcmRfc2VjdG9ycyk7CmRpZmYgLS1naXQgYS9k cml2ZXJzL3MzOTAvYmxvY2svZGFzZF9mYmEuYyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCmluZGV4IGUwODRmNGRlZGRkZGQuLjhiZDU2NjVkYjkxOTggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvczM5MC9ibG9jay9kYXNkX2ZiYS5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Zi YS5jCkBAIC03OTEsNyArNzkxLDYgQEAgc3RhdGljIHZvaWQgZGFzZF9mYmFfc2V0dXBfYmxrX3F1 ZXVlKHN0cnVjdCBkYXNkX2Jsb2NrICpibG9jaykKIAogCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9z ZWN0b3JzKHEsIG1heF9kaXNjYXJkX3NlY3RvcnMpOwogCWJsa19xdWV1ZV9tYXhfd3JpdGVfemVy b2VzX3NlY3RvcnMocSwgbWF4X2Rpc2NhcmRfc2VjdG9ycyk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBpbnQgZGFzZF9mYmFfcGVfaGFu ZGxlcihzdHJ1Y3QgZGFzZF9kZXZpY2UgKmRldmljZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2Nz aS9zZC5jIGIvZHJpdmVycy9zY3NpL3NkLmMKaW5kZXggYTM5MDY3OWNmNDU4NC4uNDQ0NDc5NjU3 YjdmZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NkLmMKKysrIGIvZHJpdmVycy9zY3NpL3Nk LmMKQEAgLTc5Nyw3ICs3OTcsNiBAQCBzdGF0aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1 Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25lZCBpbnQgbW9kZSkKIAljYXNlIFNEX0xCUF9GVUxM OgogCWNhc2UgU0RfTEJQX0RJU0FCTEU6CiAJCWJsa19xdWV1ZV9tYXhfZGlzY2FyZF9zZWN0b3Jz KHEsIDApOwotCQlibGtfcXVldWVfZmxhZ19jbGVhcihRVUVVRV9GTEFHX0RJU0NBUkQsIHEpOwog CQlyZXR1cm47CiAKIAljYXNlIFNEX0xCUF9VTk1BUDoKQEAgLTgzMCw3ICs4MjksNiBAQCBzdGF0 aWMgdm9pZCBzZF9jb25maWdfZGlzY2FyZChzdHJ1Y3Qgc2NzaV9kaXNrICpzZGtwLCB1bnNpZ25l ZCBpbnQgbW9kZSkKIAl9CiAKIAlibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyhxLCBtYXhf YmxvY2tzICogKGxvZ2ljYWxfYmxvY2tfc2l6ZSA+PiA5KSk7Ci0JYmxrX3F1ZXVlX2ZsYWdfc2V0 KFFVRVVFX0ZMQUdfRElTQ0FSRCwgcSk7CiB9CiAKIHN0YXRpYyBibGtfc3RhdHVzX3Qgc2Rfc2V0 dXBfdW5tYXBfY21uZChzdHJ1Y3Qgc2NzaV9jbW5kICpjbWQpCmRpZmYgLS1naXQgYS9kcml2ZXJz L3RhcmdldC90YXJnZXRfY29yZV9kZXZpY2UuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3Jl X2RldmljZS5jCmluZGV4IGMzZTI1YmFjOTBkNTkuLjZjYjlmODc4NDMyNzggMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX2RldmljZS5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0 L3RhcmdldF9jb3JlX2RldmljZS5jCkBAIC04MzgsNyArODM4LDcgQEAgYm9vbCB0YXJnZXRfY29u ZmlndXJlX3VubWFwX2Zyb21fcXVldWUoc3RydWN0IHNlX2Rldl9hdHRyaWIgKmF0dHJpYiwKIAlz dHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwogCWludCBibG9j a19zaXplID0gYmRldl9sb2dpY2FsX2Jsb2NrX3NpemUoYmRldik7CiAKLQlpZiAoIWJsa19xdWV1 ZV9kaXNjYXJkKHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKGJkZXYpKQogCQly ZXR1cm4gZmFsc2U7CiAKIAlhdHRyaWItPm1heF91bm1hcF9sYmFfY291bnQgPQpkaWZmIC0tZ2l0 IGEvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKaW5kZXgg ZjQ3NzAzNWEyYWMyMy4uZWZkOGRlYjNhYjdlOCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZXh0ZW50 LXRyZWUuYworKysgYi9mcy9idHJmcy9leHRlbnQtdHJlZS5jCkBAIC0xMjkxLDcgKzEyOTEsNyBA QCBzdGF0aWMgaW50IGRvX2Rpc2NhcmRfZXh0ZW50KHN0cnVjdCBidHJmc19pb19zdHJpcGUgKnN0 cmlwZSwgdTY0ICpieXRlcykKIAkJcmV0ID0gYnRyZnNfcmVzZXRfZGV2aWNlX3pvbmUoZGV2X3Jl cGxhY2UtPnRndGRldiwgcGh5cywgbGVuLAogCQkJCQkgICAgICAmZGlzY2FyZGVkKTsKIAkJZGlz Y2FyZGVkICs9IHNyY19kaXNjOwotCX0gZWxzZSBpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9n ZXRfcXVldWUoc3RyaXBlLT5kZXYtPmJkZXYpKSkgeworCX0gZWxzZSBpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHN0cmlwZS0+ZGV2LT5iZGV2KSkgewogCQlyZXQgPSBidHJmc19pc3N1ZV9k aXNjYXJkKGRldi0+YmRldiwgcGh5cywgbGVuLCAmZGlzY2FyZGVkKTsKIAl9IGVsc2UgewogCQly ZXQgPSAwOwpAQCAtNTk4Nyw3ICs1OTg3LDcgQEAgc3RhdGljIGludCBidHJmc190cmltX2ZyZWVf ZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfZGV2aWNlICpkZXZpY2UsIHU2NCAqdHJpbW1lZCkKIAkqdHJp bW1lZCA9IDA7CiAKIAkvKiBEaXNjYXJkIG5vdCBzdXBwb3J0ZWQgPSBub3RoaW5nIHRvIGRvLiAq LwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQoYmRldl9nZXRfcXVldWUoZGV2aWNlLT5iZGV2KSkp CisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoZGV2aWNlLT5iZGV2KSkKIAkJcmV0dXJu IDA7CiAKIAkvKiBOb3Qgd3JpdGFibGUgPSBub3RoaW5nIHRvIGRvLiAqLwpkaWZmIC0tZ2l0IGEv ZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggZjQ2ZTcxMDYxOTQyZC4u MDk2YmIwZGEwM2YxYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJm cy9pb2N0bC5jCkBAIC01MDEsNyArNTAxLDcgQEAgc3RhdGljIG5vaW5saW5lIGludCBidHJmc19p b2N0bF9maXRyaW0oc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmZzX2luZm8sCiAJCWlmICghZGV2aWNl LT5iZGV2KQogCQkJY29udGludWU7CiAJCXEgPSBiZGV2X2dldF9xdWV1ZShkZXZpY2UtPmJkZXYp OwotCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKKwkJaWYgKGJkZXZfbWF4X2Rpc2NhcmRf c2VjdG9ycyhkZXZpY2UtPmJkZXYpKSB7CiAJCQludW1fZGV2aWNlcysrOwogCQkJbWlubGVuID0g bWluX3QodTY0LCBxLT5saW1pdHMuZGlzY2FyZF9ncmFudWxhcml0eSwKIAkJCQkgICAgIG1pbmxl bik7CmRpZmYgLS1naXQgYS9mcy9leGZhdC9maWxlLmMgYi9mcy9leGZhdC9maWxlLmMKaW5kZXgg MmY1MTMwMDU5MjM2Ni4uNzY1ZTRmNjNkZDE4ZCAxMDA2NDQKLS0tIGEvZnMvZXhmYXQvZmlsZS5j CisrKyBiL2ZzL2V4ZmF0L2ZpbGUuYwpAQCAtMzU4LDcgKzM1OCw3IEBAIHN0YXRpYyBpbnQgZXhm YXRfaW9jdGxfZml0cmltKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHVuc2lnbmVkIGxvbmcgYXJnKQog CWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0dXJuIC1FUEVSTTsKIAotCWlmICgh YmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoaW5v ZGUtPmlfc2ItPnNfYmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zy b21fdXNlcigmcmFuZ2UsIChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZywgc2l6ZW9m KHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy9leGZhdC9zdXBlci5jIGIvZnMvZXhmYXQvc3VwZXIu YwppbmRleCA4Y2EyMWU3OTE3ZDE2Li5iZTA3ODhlY2FmMjBlIDEwMDY0NAotLS0gYS9mcy9leGZh dC9zdXBlci5jCisrKyBiL2ZzL2V4ZmF0L3N1cGVyLmMKQEAgLTYyNywxMyArNjI3LDkgQEAgc3Rh dGljIGludCBleGZhdF9maWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBm c19jb250ZXh0ICpmYykKIAlpZiAob3B0cy0+YWxsb3dfdXRpbWUgPT0gKHVuc2lnbmVkIHNob3J0 KS0xKQogCQlvcHRzLT5hbGxvd191dGltZSA9IH5vcHRzLT5mc19kbWFzayAmIDAwMjI7CiAKLQlp ZiAob3B0cy0+ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0 X3F1ZXVlKHNiLT5zX2JkZXYpOwotCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJ CWV4ZmF0X3dhcm4oc2IsICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRo ZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JCQlvcHRzLT5kaXNjYXJkID0g MDsKLQkJfQorCWlmIChvcHRzLT5kaXNjYXJkICYmICFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMo c2ItPnNfYmRldikpIHsKKwkJZXhmYXRfd2FybihzYiwgIm1vdW50aW5nIHdpdGggXCJkaXNjYXJk XCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2NhcmQiKTsKKwkJ b3B0cy0+ZGlzY2FyZCA9IDA7CiAJfQogCiAJc2ItPnNfZmxhZ3MgfD0gU0JfTk9ESVJBVElNRTsK ZGlmZiAtLWdpdCBhL2ZzL2V4dDQvaW9jdGwuYyBiL2ZzL2V4dDQvaW9jdGwuYwppbmRleCA5OTIy MjljYTJkODMwLi42ZTNiOWVlYTEyNmY0IDEwMDY0NAotLS0gYS9mcy9leHQ0L2lvY3RsLmMKKysr IGIvZnMvZXh0NC9pb2N0bC5jCkBAIC0xMDQ0LDcgKzEwNDQsNiBAQCBzdGF0aWMgaW50IGV4dDRf aW9jdGxfY2hlY2twb2ludChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJ X191MzIgZmxhZ3MgPSAwOwogCXVuc2lnbmVkIGludCBmbHVzaF9mbGFncyA9IDA7CiAJc3RydWN0 IHN1cGVyX2Jsb2NrICpzYiA9IGZpbGVfaW5vZGUoZmlscCktPmlfc2I7Ci0Jc3RydWN0IHJlcXVl c3RfcXVldWUgKnE7CiAKIAlpZiAoY29weV9mcm9tX3VzZXIoJmZsYWdzLCAoX191MzIgX191c2Vy ICopYXJnLAogCQkJCXNpemVvZihfX3UzMikpKQpAQCAtMTA2NSwxMCArMTA2NCw4IEBAIHN0YXRp YyBpbnQgZXh0NF9pb2N0bF9jaGVja3BvaW50KHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBs b25nIGFyZykKIAlpZiAoZmxhZ3MgJiB+RVhUNF9JT0NfQ0hFQ0tQT0lOVF9GTEFHX1ZBTElEKQog CQlyZXR1cm4gLUVJTlZBTDsKIAotCXEgPSBiZGV2X2dldF9xdWV1ZShFWFQ0X1NCKHNiKS0+c19q b3VybmFsLT5qX2Rldik7Ci0JaWYgKCFxKQotCQlyZXR1cm4gLUVOWElPOwotCWlmICgoZmxhZ3Mg JiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYgIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQor CWlmICgoZmxhZ3MgJiBKQkQyX0pPVVJOQUxfRkxVU0hfRElTQ0FSRCkgJiYKKwkgICAgIWJkZXZf bWF4X2Rpc2NhcmRfc2VjdG9ycyhFWFQ0X1NCKHNiKS0+c19qb3VybmFsLT5qX2RldikpCiAJCXJl dHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChmbGFncyAmIEVYVDRfSU9DX0NIRUNLUE9JTlRfRkxB R19EUllfUlVOKQpAQCAtMTM5MywxNCArMTM5MCwxMyBAQCBzdGF0aWMgbG9uZyBfX2V4dDRfaW9j dGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJn KQogCiAJY2FzZSBGSVRSSU06CiAJewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZf Z2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQlzdHJ1Y3QgZnN0cmltX3JhbmdlIHJhbmdlOwogCQlp bnQgcmV0ID0gMDsKIAogCQlpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCiAJCQlyZXR1cm4g LUVQRVJNOwogCi0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCWlmICghYmRldl9tYXhf ZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwogCiAJ CS8qCmRpZmYgLS1naXQgYS9mcy9leHQ0L3N1cGVyLmMgYi9mcy9leHQ0L3N1cGVyLmMKaW5kZXgg ODE3NDllYWRkZjRjMS4uOTNmNGU0ZTllMjYzMSAxMDA2NDQKLS0tIGEvZnMvZXh0NC9zdXBlci5j CisrKyBiL2ZzL2V4dDQvc3VwZXIuYwpAQCAtNTQ1OCwxMyArNTQ1OCw5IEBAIHN0YXRpYyBpbnQg X19leHQ0X2ZpbGxfc3VwZXIoc3RydWN0IGZzX2NvbnRleHQgKmZjLCBzdHJ1Y3Qgc3VwZXJfYmxv Y2sgKnNiKQogCQkJZ290byBmYWlsZWRfbW91bnQ5OwogCX0KIAotCWlmICh0ZXN0X29wdChzYiwg RElTQ0FSRCkpIHsKLQkJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBiZGV2X2dldF9xdWV1ZShz Yi0+c19iZGV2KTsKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJCWV4dDRfbXNnKHNi LCBLRVJOX1dBUk5JTkcsCi0JCQkJICJtb3VudGluZyB3aXRoIFwiZGlzY2FyZFwiIG9wdGlvbiwg YnV0ICIKLQkJCQkgInRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNjYXJkIik7Ci0JfQor CWlmICh0ZXN0X29wdChzYiwgRElTQ0FSRCkgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhz Yi0+c19iZGV2KSkKKwkJZXh0NF9tc2coc2IsIEtFUk5fV0FSTklORywKKwkJCSAibW91bnRpbmcg d2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCB0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQg ZGlzY2FyZCIpOwogCiAJaWYgKGVzLT5zX2Vycm9yX2NvdW50KQogCQltb2RfdGltZXIoJnNiaS0+ c19lcnJfcmVwb3J0LCBqaWZmaWVzICsgMzAwKkhaKTsgLyogNSBtaW51dGVzICovCmRpZmYgLS1n aXQgYS9mcy9mMmZzL2YyZnMuaCBiL2ZzL2YyZnMvZjJmcy5oCmluZGV4IGNkMWU2NWJjZjBiMDQu LjBlYTlhNWZhN2MxZGQgMTAwNjQ0Ci0tLSBhL2ZzL2YyZnMvZjJmcy5oCisrKyBiL2ZzL2YyZnMv ZjJmcy5oCkBAIC00MzgxLDggKzQzODEsNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgZjJmc19od19z aG91bGRfZGlzY2FyZChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmkpCiAKIHN0YXRpYyBpbmxpbmUg Ym9vbCBmMmZzX2JkZXZfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYp CiB7Ci0JcmV0dXJuIGJsa19xdWV1ZV9kaXNjYXJkKGJkZXZfZ2V0X3F1ZXVlKGJkZXYpKSB8fAot CSAgICAgICBiZGV2X2lzX3pvbmVkKGJkZXYpOworCXJldHVybiBiZGV2X21heF9kaXNjYXJkX3Nl Y3RvcnMoYmRldikgfHwgYmRldl9pc196b25lZChiZGV2KTsKIH0KIAogc3RhdGljIGlubGluZSBi b29sIGYyZnNfaHdfc3VwcG9ydF9kaXNjYXJkKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSkKZGlm ZiAtLWdpdCBhL2ZzL2ZhdC9maWxlLmMgYi9mcy9mYXQvZmlsZS5jCmluZGV4IGE1YTMwOWZjYzdm YWYuLmU0YzdkMTBlODAxMjkgMTAwNjQ0Ci0tLSBhL2ZzL2ZhdC9maWxlLmMKKysrIGIvZnMvZmF0 L2ZpbGUuYwpAQCAtMTMzLDcgKzEzMyw3IEBAIHN0YXRpYyBpbnQgZmF0X2lvY3RsX2ZpdHJpbShz dHJ1Y3QgaW5vZGUgKmlub2RlLCB1bnNpZ25lZCBsb25nIGFyZykKIAlpZiAoIWNhcGFibGUoQ0FQ X1NZU19BRE1JTikpCiAJCXJldHVybiAtRVBFUk07CiAKLQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJk KHEpKQorCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAl1c2VyX3JhbmdlID0gKHN0cnVjdCBmc3RyaW1fcmFuZ2UgX191 c2VyICopYXJnOwpkaWZmIC0tZ2l0IGEvZnMvZmF0L2lub2RlLmMgYi9mcy9mYXQvaW5vZGUuYwpp bmRleCBiZjYwNTFiZGYxZDFkLi4zZDFhZmI5NWE5MjVhIDEwMDY0NAotLS0gYS9mcy9mYXQvaW5v ZGUuYworKysgYi9mcy9mYXQvaW5vZGUuYwpAQCAtMTg3MiwxMyArMTg3Miw5IEBAIGludCBmYXRf ZmlsbF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCB2b2lkICpkYXRhLCBpbnQgc2lsZW50 LCBpbnQgaXN2ZmF0LAogCQlnb3RvIG91dF9mYWlsOwogCX0KIAotCWlmIChzYmktPm9wdGlvbnMu ZGlzY2FyZCkgewotCQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNi LT5zX2JkZXYpOwotCQlpZiAoIWJsa19xdWV1ZV9kaXNjYXJkKHEpKQotCQkJZmF0X21zZyhzYiwg S0VSTl9XQVJOSU5HLAotCQkJCQkibW91bnRpbmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1 dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMgbm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCX0KKwlp ZiAoc2JpLT5vcHRpb25zLmRpc2NhcmQgJiYgIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhzYi0+ c19iZGV2KSkKKwkJZmF0X21zZyhzYiwgS0VSTl9XQVJOSU5HLAorCQkJIm1vdW50aW5nIHdpdGgg XCJkaXNjYXJkXCIgb3B0aW9uLCBidXQgdGhlIGRldmljZSBkb2VzIG5vdCBzdXBwb3J0IGRpc2Nh cmQiKTsKIAogCWZhdF9zZXRfc3RhdGUoc2IsIDEsIDApOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0 IGEvZnMvZ2ZzMi9yZ3JwLmMgYi9mcy9nZnMyL3JncnAuYwppbmRleCA4MDFhZDlmNGYyYmVmLi43 ZjIwYWM5MTMzYmM2IDEwMDY0NAotLS0gYS9mcy9nZnMyL3JncnAuYworKysgYi9mcy9nZnMyL3Jn cnAuYwpAQCAtMTQwNSw3ICsxNDA1LDcgQEAgaW50IGdmczJfZml0cmltKHN0cnVjdCBmaWxlICpm aWxwLCB2b2lkIF9fdXNlciAqYXJncCkKIAlpZiAoIXRlc3RfYml0KFNERl9KT1VSTkFMX0xJVkUs ICZzZHAtPnNkX2ZsYWdzKSkKIAkJcmV0dXJuIC1FUk9GUzsKIAotCWlmICghYmxrX3F1ZXVlX2Rp c2NhcmQocSkpCisJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2RwLT5zZF92ZnMtPnNf YmRldikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmciwg YXJncCwgc2l6ZW9mKHIpKSkKZGlmZiAtLWdpdCBhL2ZzL2piZDIvam91cm5hbC5jIGIvZnMvamJk Mi9qb3VybmFsLmMKaW5kZXggZmNhY2FmYTQ1MTBkMS4uMTlkMjI2Y2Q0ZmY0ZCAxMDA2NDQKLS0t IGEvZnMvamJkMi9qb3VybmFsLmMKKysrIGIvZnMvamJkMi9qb3VybmFsLmMKQEAgLTE3NjIsNyAr MTc2Miw2IEBAIHN0YXRpYyBpbnQgX19qYmQyX2pvdXJuYWxfZXJhc2Uoam91cm5hbF90ICpqb3Vy bmFsLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJdW5zaWduZWQgbG9uZyBibG9jaywgbG9nX29mZnNl dDsgLyogbG9naWNhbCAqLwogCXVuc2lnbmVkIGxvbmcgbG9uZyBwaHlzX2Jsb2NrLCBibG9ja19z dGFydCwgYmxvY2tfc3RvcDsgLyogcGh5c2ljYWwgKi8KIAlsb2ZmX3QgYnl0ZV9zdGFydCwgYnl0 ZV9zdG9wLCBieXRlX2NvdW50OwotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRf cXVldWUoam91cm5hbC0+al9kZXYpOwogCiAJLyogZmxhZ3MgbXVzdCBiZSBzZXQgdG8gZWl0aGVy IGRpc2NhcmQgb3IgemVyb291dCAqLwogCWlmICgoZmxhZ3MgJiB+SkJEMl9KT1VSTkFMX0ZMVVNI X1ZBTElEKSB8fCAhZmxhZ3MgfHwKQEAgLTE3NzAsMTAgKzE3NjksOCBAQCBzdGF0aWMgaW50IF9f amJkMl9qb3VybmFsX2VyYXNlKGpvdXJuYWxfdCAqam91cm5hbCwgdW5zaWduZWQgaW50IGZsYWdz KQogCQkJKGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX1pFUk9PVVQpKSkKIAkJcmV0dXJuIC1F SU5WQUw7CiAKLQlpZiAoIXEpCi0JCXJldHVybiAtRU5YSU87Ci0KLQlpZiAoKGZsYWdzICYgSkJE Ml9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmICFibGtfcXVldWVfZGlzY2FyZChxKSkKKwlpZiAo KGZsYWdzICYgSkJEMl9KT1VSTkFMX0ZMVVNIX0RJU0NBUkQpICYmCisJICAgICFiZGV2X21heF9k aXNjYXJkX3NlY3RvcnMoam91cm5hbC0+al9kZXYpKQogCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAK IAkvKgpkaWZmIC0tZ2l0IGEvZnMvamZzL2lvY3RsLmMgYi9mcy9qZnMvaW9jdGwuYwppbmRleCAw M2E4NDVhYjRmMDA5Li4zNTdhZTZlNWMzNmVjIDEwMDY0NAotLS0gYS9mcy9qZnMvaW9jdGwuYwor KysgYi9mcy9qZnMvaW9jdGwuYwpAQCAtMTE3LDcgKzExNyw3IEBAIGxvbmcgamZzX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIAkJ aWYgKCFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQogCQkJcmV0dXJuIC1FUEVSTTsKIAotCQlpZiAo IWJsa19xdWV1ZV9kaXNjYXJkKHEpKSB7CisJCWlmICghYmRldl9tYXhfZGlzY2FyZF9zZWN0b3Jz KHNiLT5zX2JkZXYpKSB7CiAJCQlqZnNfd2FybigiRklUUklNIG5vdCBzdXBwb3J0ZWQgb24gZGV2 aWNlIik7CiAJCQlyZXR1cm4gLUVPUE5PVFNVUFA7CiAJCX0KZGlmZiAtLWdpdCBhL2ZzL2pmcy9z dXBlci5jIGIvZnMvamZzL3N1cGVyLmMKaW5kZXggZjFhMTNhNzRjZGRmMy4uODVkNGY0NGYyYWM0 ZCAxMDA2NDQKLS0tIGEvZnMvamZzL3N1cGVyLmMKKysrIGIvZnMvamZzL3N1cGVyLmMKQEAgLTM3 MiwxOSArMzcyLDE2IEBAIHN0YXRpYyBpbnQgcGFyc2Vfb3B0aW9ucyhjaGFyICpvcHRpb25zLCBz dHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBzNjQgKm5ld0xWU2l6ZSwKIAkJfQogCiAJCWNhc2UgT3B0 X2Rpc2NhcmQ6Ci0JCXsKLQkJCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVl dWUoc2ItPnNfYmRldik7CiAJCQkvKiBpZiBzZXQgdG8gMSwgZXZlbiBjb3B5aW5nIGZpbGVzIHdp bGwgY2F1c2UKIAkJCSAqIHRyaW1taW5nIDpPCiAJCQkgKiAtPiB1c2VyIGhhcyBtb3JlIGNvbnRy b2wgb3ZlciB0aGUgb25saW5lIHRyaW1taW5nCiAJCQkgKi8KIAkJCXNiaS0+bWluYmxrc190cmlt ID0gNjQ7Ci0JCQlpZiAoYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJCQlpZiAoYmRldl9tYXhfZGlz Y2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYpKQogCQkJCSpmbGFnIHw9IEpGU19ESVNDQVJEOwogCQkJ ZWxzZQogCQkJCXByX2VycigiSkZTOiBkaXNjYXJkIG9wdGlvbiBub3Qgc3VwcG9ydGVkIG9uIGRl dmljZVxuIik7CiAJCQlicmVhazsKLQkJfQogCiAJCWNhc2UgT3B0X25vZGlzY2FyZDoKIAkJCSpm bGFnICY9IH5KRlNfRElTQ0FSRDsKQEAgLTM5MiwxMCArMzg5LDkgQEAgc3RhdGljIGludCBwYXJz ZV9vcHRpb25zKGNoYXIgKm9wdGlvbnMsIHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHM2NCAqbmV3 TFZTaXplLAogCiAJCWNhc2UgT3B0X2Rpc2NhcmRfbWluYmxrOgogCQl7Ci0JCQlzdHJ1Y3QgcmVx dWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwogCQkJY2hhciAqbWlu Ymxrc190cmltID0gYXJnc1swXS5mcm9tOwogCQkJaW50IHJjOwotCQkJaWYgKGJsa19xdWV1ZV9k aXNjYXJkKHEpKSB7CisJCQlpZiAoYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHNiLT5zX2JkZXYp KSB7CiAJCQkJKmZsYWcgfD0gSkZTX0RJU0NBUkQ7CiAJCQkJcmMgPSBrc3RydG91aW50KG1pbmJs a3NfdHJpbSwgMCwKIAkJCQkJCSZzYmktPm1pbmJsa3NfdHJpbSk7CmRpZmYgLS1naXQgYS9mcy9u aWxmczIvaW9jdGwuYyBiL2ZzL25pbGZzMi9pb2N0bC5jCmluZGV4IGZlYzE5NGE2NjZmNGIuLjUy YjczZjU1OGZjYjEgMTAwNjQ0Ci0tLSBhL2ZzL25pbGZzMi9pb2N0bC5jCisrKyBiL2ZzL25pbGZz Mi9pb2N0bC5jCkBAIC0xMDU5LDcgKzEwNTksNyBAQCBzdGF0aWMgaW50IG5pbGZzX2lvY3RsX3Ry aW1fZnMoc3RydWN0IGlub2RlICppbm9kZSwgdm9pZCBfX3VzZXIgKmFyZ3ApCiAJaWYgKCFjYXBh YmxlKENBUF9TWVNfQURNSU4pKQogCQlyZXR1cm4gLUVQRVJNOwogCi0JaWYgKCFibGtfcXVldWVf ZGlzY2FyZChxKSkKKwlpZiAoIWJkZXZfbWF4X2Rpc2NhcmRfc2VjdG9ycyhuaWxmcy0+bnNfYmRl dikpCiAJCXJldHVybiAtRU9QTk9UU1VQUDsKIAogCWlmIChjb3B5X2Zyb21fdXNlcigmcmFuZ2Us IGFyZ3AsIHNpemVvZihyYW5nZSkpKQpkaWZmIC0tZ2l0IGEvZnMvbnRmczMvZmlsZS5jIGIvZnMv bnRmczMvZmlsZS5jCmluZGV4IDc4N2I1M2I5ODRlZTEuLmU3NjMyMzYxNjkzMzEgMTAwNjQ0Ci0t LSBhL2ZzL250ZnMzL2ZpbGUuYworKysgYi9mcy9udGZzMy9maWxlLmMKQEAgLTI4LDcgKzI4LDcg QEAgc3RhdGljIGludCBudGZzX2lvY3RsX2ZpdHJpbShzdHJ1Y3QgbnRmc19zYl9pbmZvICpzYmks IHVuc2lnbmVkIGxvbmcgYXJnKQogCWlmICghY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKIAkJcmV0 dXJuIC1FUEVSTTsKIAotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYgKCFiZGV2X21h eF9kaXNjYXJkX3NlY3RvcnMoc2JpLT5zYi0+c19iZGV2KSkKIAkJcmV0dXJuIC1FT1BOT1RTVVBQ OwogCiAJdXNlcl9yYW5nZSA9IChzdHJ1Y3QgZnN0cmltX3JhbmdlIF9fdXNlciAqKWFyZzsKZGlm ZiAtLWdpdCBhL2ZzL250ZnMzL3N1cGVyLmMgYi9mcy9udGZzMy9zdXBlci5jCmluZGV4IGNkMzBl ODFhYmJjZTAuLmM3MzQwODViY2NlNGEgMTAwNjQ0Ci0tLSBhL2ZzL250ZnMzL3N1cGVyLmMKKysr IGIvZnMvbnRmczMvc3VwZXIuYwpAQCAtOTEzLDcgKzkxMyw3IEBAIHN0YXRpYyBpbnQgbnRmc19m aWxsX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIHN0cnVjdCBmc19jb250ZXh0ICpmYykK IAl9CiAKIAlycSA9IGJkZXZfZ2V0X3F1ZXVlKGJkZXYpOwotCWlmIChibGtfcXVldWVfZGlzY2Fy ZChycSkgJiYgcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51bGFyaXR5KSB7CisJaWYgKGJkZXZfbWF4 X2Rpc2NhcmRfc2VjdG9ycyhiZGV2KSAmJiBycS0+bGltaXRzLmRpc2NhcmRfZ3JhbnVsYXJpdHkp IHsKIAkJc2JpLT5kaXNjYXJkX2dyYW51bGFyaXR5ID0gcnEtPmxpbWl0cy5kaXNjYXJkX2dyYW51 bGFyaXR5OwogCQlzYmktPmRpc2NhcmRfZ3JhbnVsYXJpdHlfbWFza19pbnYgPQogCQkJfih1NjQp KHNiaS0+ZGlzY2FyZF9ncmFudWxhcml0eSAtIDEpOwpkaWZmIC0tZ2l0IGEvZnMvb2NmczIvaW9j dGwuYyBiL2ZzL29jZnMyL2lvY3RsLmMKaW5kZXggZjU5NDYxZDg1ZGE0NS4uOWI3OGVmMTAzYWRh NiAxMDA2NDQKLS0tIGEvZnMvb2NmczIvaW9jdGwuYworKysgYi9mcy9vY2ZzMi9pb2N0bC5jCkBA IC05MTAsNyArOTEwLDcgQEAgbG9uZyBvY2ZzMl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdW5z aWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCiAJCWlmICghY2FwYWJsZShDQVBfU1lT X0FETUlOKSkKIAkJCXJldHVybiAtRVBFUk07CiAKLQkJaWYgKCFibGtfcXVldWVfZGlzY2FyZChx KSkKKwkJaWYgKCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMoc2ItPnNfYmRldikpCiAJCQlyZXR1 cm4gLUVPUE5PVFNVUFA7CiAKIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZyYW5nZSwgYXJncCwgc2l6 ZW9mKHJhbmdlKSkpCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX2Rpc2NhcmQuYyBiL2ZzL3hmcy94 ZnNfZGlzY2FyZC5jCmluZGV4IDAxOTFkZThjZTljZWQuLmE0ZTY2MDlkNjE2YjcgMTAwNjQ0Ci0t LSBhL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCisrKyBiL2ZzL3hmcy94ZnNfZGlzY2FyZC5jCkBAIC0x NjIsNyArMTYyLDcgQEAgeGZzX2lvY190cmltKAogCiAJaWYgKCFjYXBhYmxlKENBUF9TWVNfQURN SU4pKQogCQlyZXR1cm4gLUVQRVJNOwotCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpCisJaWYg KCFiZGV2X21heF9kaXNjYXJkX3NlY3RvcnMobXAtPm1fZGRldl90YXJncC0+YnRfYmRldikpCiAJ CXJldHVybiAtRU9QTk9UU1VQUDsKIAogCS8qCmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3N1cGVy LmMgYi9mcy94ZnMveGZzX3N1cGVyLmMKaW5kZXggNTRiZTlkNjQwOTNlZC4uYTI3NmI4MTExZjYz NiAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19zdXBlci5jCisrKyBiL2ZzL3hmcy94ZnNfc3VwZXIu YwpAQCAtMTYwOCwxNCArMTYwOCwxMCBAQCB4ZnNfZnNfZmlsbF9zdXBlcigKIAkJCWdvdG8gb3V0 X2ZpbGVzdHJlYW1fdW5tb3VudDsKIAl9CiAKLQlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSkgewot CQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSA9IGJkZXZfZ2V0X3F1ZXVlKHNiLT5zX2JkZXYpOwot Ci0JCWlmICghYmxrX3F1ZXVlX2Rpc2NhcmQocSkpIHsKLQkJCXhmc193YXJuKG1wLCAibW91bnRp bmcgd2l0aCBcImRpc2NhcmRcIiBvcHRpb24sIGJ1dCAiCi0JCQkJCSJ0aGUgZGV2aWNlIGRvZXMg bm90IHN1cHBvcnQgZGlzY2FyZCIpOwotCQkJbXAtPm1fZmVhdHVyZXMgJj0gflhGU19GRUFUX0RJ U0NBUkQ7Ci0JCX0KKwlpZiAoeGZzX2hhc19kaXNjYXJkKG1wKSAmJiAhYmRldl9tYXhfZGlzY2Fy ZF9zZWN0b3JzKHNiLT5zX2JkZXYpKSB7CisJCXhmc193YXJuKG1wLAorCSJtb3VudGluZyB3aXRo IFwiZGlzY2FyZFwiIG9wdGlvbiwgYnV0IHRoZSBkZXZpY2UgZG9lcyBub3Qgc3VwcG9ydCBkaXNj YXJkIik7CisJCW1wLT5tX2ZlYXR1cmVzICY9IH5YRlNfRkVBVF9ESVNDQVJEOwogCX0KIAogCWlm ICh4ZnNfaGFzX3JlZmxpbmsobXApKSB7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Jsa2Rl di5oIGIvaW5jbHVkZS9saW51eC9ibGtkZXYuaAppbmRleCBjZTE2MjQ3ZDNhZmFiLi43NjdhYjIy ZTEwNTJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1ZGUv bGludXgvYmxrZGV2LmgKQEAgLTU0MCw3ICs1NDAsNiBAQCBzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSB7 CiAjZGVmaW5lIFFVRVVFX0ZMQUdfTk9OUk9UCTYJLyogbm9uLXJvdGF0aW9uYWwgZGV2aWNlIChT U0QpICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfVklSVAkJUVVFVUVfRkxBR19OT05ST1QgLyogcGFy YXZpcnQgZGV2aWNlICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfSU9fU1RBVAk3CS8qIGRvIGRpc2sv cGFydGl0aW9ucyBJTyBhY2NvdW50aW5nICovCi0jZGVmaW5lIFFVRVVFX0ZMQUdfRElTQ0FSRAk4 CS8qIHN1cHBvcnRzIERJU0NBUkQgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19OT1hNRVJHRVMJOQkv KiBObyBleHRlbmRlZCBtZXJnZXMgKi8KICNkZWZpbmUgUVVFVUVfRkxBR19BRERfUkFORE9NCTEw CS8qIENvbnRyaWJ1dGVzIHRvIHJhbmRvbSBwb29sICovCiAjZGVmaW5lIFFVRVVFX0ZMQUdfU0VD RVJBU0UJMTEJLyogc3VwcG9ydHMgc2VjdXJlIGVyYXNlICovCkBAIC01ODIsNyArNTgxLDYgQEAg Ym9vbCBibGtfcXVldWVfZmxhZ190ZXN0X2FuZF9zZXQodW5zaWduZWQgaW50IGZsYWcsIHN0cnVj dCByZXF1ZXN0X3F1ZXVlICpxKTsKIAl0ZXN0X2JpdChRVUVVRV9GTEFHX1NUQUJMRV9XUklURVMs ICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfaW9fc3RhdChxKQl0ZXN0X2Jp dChRVUVVRV9GTEFHX0lPX1NUQVQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVl dWVfYWRkX3JhbmRvbShxKQl0ZXN0X2JpdChRVUVVRV9GTEFHX0FERF9SQU5ET00sICYocSktPnF1 ZXVlX2ZsYWdzKQotI2RlZmluZSBibGtfcXVldWVfZGlzY2FyZChxKQl0ZXN0X2JpdChRVUVVRV9G TEFHX0RJU0NBUkQsICYocSktPnF1ZXVlX2ZsYWdzKQogI2RlZmluZSBibGtfcXVldWVfem9uZV9y ZXNldGFsbChxKQlcCiAJdGVzdF9iaXQoUVVFVUVfRkxBR19aT05FX1JFU0VUQUxMLCAmKHEpLT5x dWV1ZV9mbGFncykKICNkZWZpbmUgYmxrX3F1ZXVlX3NlY3VyZV9lcmFzZShxKSBcCmRpZmYgLS1n aXQgYS9tbS9zd2FwZmlsZS5jIGIvbW0vc3dhcGZpbGUuYwppbmRleCA0MDY5ZjE3YTgyYzhlLi41 ZDljZWRmOWU3Yjg0IDEwMDY0NAotLS0gYS9tbS9zd2FwZmlsZS5jCisrKyBiL21tL3N3YXBmaWxl LmMKQEAgLTI5NTcsMjAgKzI5NTcsNiBAQCBzdGF0aWMgaW50IHNldHVwX3N3YXBfbWFwX2FuZF9l eHRlbnRzKHN0cnVjdCBzd2FwX2luZm9fc3RydWN0ICpwLAogCXJldHVybiBucl9leHRlbnRzOwog fQogCi0vKgotICogSGVscGVyIHRvIHN5c19zd2Fwb24gZGV0ZXJtaW5pbmcgaWYgYSBnaXZlbiBz d2FwCi0gKiBiYWNraW5nIGRldmljZSBxdWV1ZSBzdXBwb3J0cyBESVNDQVJEIG9wZXJhdGlvbnMu Ci0gKi8KLXN0YXRpYyBib29sIHN3YXBfZGlzY2FyZGFibGUoc3RydWN0IHN3YXBfaW5mb19zdHJ1 Y3QgKnNpKQotewotCXN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxID0gYmRldl9nZXRfcXVldWUoc2kt PmJkZXYpOwotCi0JaWYgKCFibGtfcXVldWVfZGlzY2FyZChxKSkKLQkJcmV0dXJuIGZhbHNlOwot Ci0JcmV0dXJuIHRydWU7Ci19Ci0KIFNZU0NBTExfREVGSU5FMihzd2Fwb24sIGNvbnN0IGNoYXIg X191c2VyICosIHNwZWNpYWxmaWxlLCBpbnQsIHN3YXBfZmxhZ3MpCiB7CiAJc3RydWN0IHN3YXBf aW5mb19zdHJ1Y3QgKnA7CkBAIC0zMTMyLDcgKzMxMTgsOCBAQCBTWVNDQUxMX0RFRklORTIoc3dh cG9uLCBjb25zdCBjaGFyIF9fdXNlciAqLCBzcGVjaWFsZmlsZSwgaW50LCBzd2FwX2ZsYWdzKQog CQkJCQkgc2l6ZW9mKGxvbmcpLAogCQkJCQkgR0ZQX0tFUk5FTCk7CiAKLQlpZiAocC0+YmRldiAm JiAoc3dhcF9mbGFncyAmIFNXQVBfRkxBR19ESVNDQVJEKSAmJiBzd2FwX2Rpc2NhcmRhYmxlKHAp KSB7CisJaWYgKChzd2FwX2ZsYWdzICYgU1dBUF9GTEFHX0RJU0NBUkQpICYmCisJICAgIHAtPmJk ZXYgJiYgYmRldl9tYXhfZGlzY2FyZF9zZWN0b3JzKHAtPmJkZXYpKSB7CiAJCS8qCiAJCSAqIFdo ZW4gZGlzY2FyZCBpcyBlbmFibGVkIGZvciBzd2FwIHdpdGggbm8gcGFydGljdWxhcgogCQkgKiBw b2xpY3kgZmxhZ2dlZCwgd2Ugc2V0IGFsbCBzd2FwIGRpc2NhcmQgZmxhZ3MgaGVyZSBpbgotLSAK Mi4zMC4yCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K bGludXgtdW0gbWFpbGluZyBsaXN0CmxpbnV4LXVtQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC11bQo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christoph Hellwig Date: Sat, 9 Apr 2022 06:50:40 +0200 Subject: [Cluster-devel] [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD In-Reply-To: <20220409045043.23593-1-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> Message-ID: <20220409045043.23593-25-hch@lst.de> List-Id: To: cluster-devel.redhat.com MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Just use a non-zero max_discard_sectors as an indicator for discard support, similar to what is done for write zeroes. The only places where needs special attention is the RAID5 driver, which must clear discard support for security reasons by default, even if the default stacking rules would allow for it. Signed-off-by: Christoph Hellwig Reviewed-by: Martin K. Petersen Acked-by: Christoph B?hmwalder [btrfs] Acked-by: Coly Li [bcache] --- arch/um/drivers/ubd_kern.c | 2 -- block/blk-core.c | 2 +- block/blk-lib.c | 2 +- block/blk-mq-debugfs.c | 1 - block/ioctl.c | 3 +-- drivers/block/drbd/drbd_main.c | 2 +- drivers/block/drbd/drbd_nl.c | 19 ++----------------- drivers/block/drbd/drbd_receiver.c | 3 +-- drivers/block/loop.c | 11 +++-------- drivers/block/nbd.c | 5 +---- drivers/block/null_blk/main.c | 1 - drivers/block/rbd.c | 1 - drivers/block/rnbd/rnbd-clt.c | 2 -- drivers/block/rnbd/rnbd-srv-dev.h | 3 --- drivers/block/virtio_blk.c | 2 -- drivers/block/xen-blkback/xenbus.c | 2 +- drivers/block/xen-blkfront.c | 2 -- drivers/block/zram/zram_drv.c | 1 - drivers/md/bcache/request.c | 4 ++-- drivers/md/bcache/super.c | 3 +-- drivers/md/bcache/sysfs.c | 2 +- drivers/md/dm-cache-target.c | 9 +-------- drivers/md/dm-clone-target.c | 9 +-------- drivers/md/dm-log-writes.c | 3 +-- drivers/md/dm-raid.c | 9 ++------- drivers/md/dm-table.c | 9 ++------- drivers/md/dm-thin.c | 11 +---------- drivers/md/dm.c | 3 +-- drivers/md/md-linear.c | 11 +---------- drivers/md/raid0.c | 7 ------- drivers/md/raid1.c | 16 +--------------- drivers/md/raid10.c | 18 ++---------------- drivers/md/raid5-cache.c | 2 +- drivers/md/raid5.c | 12 ++++-------- drivers/mmc/core/queue.c | 1 - drivers/mtd/mtd_blkdevs.c | 1 - drivers/nvme/host/core.c | 6 ++---- drivers/s390/block/dasd_fba.c | 1 - drivers/scsi/sd.c | 2 -- drivers/target/target_core_device.c | 2 +- fs/btrfs/extent-tree.c | 4 ++-- fs/btrfs/ioctl.c | 2 +- fs/exfat/file.c | 2 +- fs/exfat/super.c | 10 +++------- fs/ext4/ioctl.c | 10 +++------- fs/ext4/super.c | 10 +++------- fs/f2fs/f2fs.h | 3 +-- fs/fat/file.c | 2 +- fs/fat/inode.c | 10 +++------- fs/gfs2/rgrp.c | 2 +- fs/jbd2/journal.c | 7 ++----- fs/jfs/ioctl.c | 2 +- fs/jfs/super.c | 8 ++------ fs/nilfs2/ioctl.c | 2 +- fs/ntfs3/file.c | 2 +- fs/ntfs3/super.c | 2 +- fs/ocfs2/ioctl.c | 2 +- fs/xfs/xfs_discard.c | 2 +- fs/xfs/xfs_super.c | 12 ++++-------- include/linux/blkdev.h | 2 -- mm/swapfile.c | 17 ++--------------- 61 files changed, 72 insertions(+), 246 deletions(-) diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c index b03269faef714..085ffdf98e57e 100644 --- a/arch/um/drivers/ubd_kern.c +++ b/arch/um/drivers/ubd_kern.c @@ -483,7 +483,6 @@ static void ubd_handler(void) if ((io_req->error == BLK_STS_NOTSUPP) && (req_op(io_req->req) == REQ_OP_DISCARD)) { blk_queue_max_discard_sectors(io_req->req->q, 0); blk_queue_max_write_zeroes_sectors(io_req->req->q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, io_req->req->q); } blk_mq_end_request(io_req->req, io_req->error); kfree(io_req); @@ -803,7 +802,6 @@ static int ubd_open_dev(struct ubd *ubd_dev) ubd_dev->queue->limits.discard_alignment = SECTOR_SIZE; blk_queue_max_discard_sectors(ubd_dev->queue, UBD_MAX_REQUEST); blk_queue_max_write_zeroes_sectors(ubd_dev->queue, UBD_MAX_REQUEST); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, ubd_dev->queue); } blk_queue_flag_set(QUEUE_FLAG_NONROT, ubd_dev->queue); return 0; diff --git a/block/blk-core.c b/block/blk-core.c index 937bb6b863317..b5c3a8049134c 100644 --- a/block/blk-core.c +++ b/block/blk-core.c @@ -820,7 +820,7 @@ void submit_bio_noacct(struct bio *bio) switch (bio_op(bio)) { case REQ_OP_DISCARD: - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) goto not_supported; break; case REQ_OP_SECURE_ERASE: diff --git a/block/blk-lib.c b/block/blk-lib.c index 2ae32a722851c..8b4b66d3a9bfc 100644 --- a/block/blk-lib.c +++ b/block/blk-lib.c @@ -53,7 +53,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, return -EOPNOTSUPP; op = REQ_OP_SECURE_ERASE; } else { - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return -EOPNOTSUPP; op = REQ_OP_DISCARD; } diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index aa0349e9f083b..fd111c5001256 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -113,7 +113,6 @@ static const char *const blk_queue_flag_name[] = { QUEUE_FLAG_NAME(FAIL_IO), QUEUE_FLAG_NAME(NONROT), QUEUE_FLAG_NAME(IO_STAT), - QUEUE_FLAG_NAME(DISCARD), QUEUE_FLAG_NAME(NOXMERGES), QUEUE_FLAG_NAME(ADD_RANDOM), QUEUE_FLAG_NAME(SECERASE), diff --git a/block/ioctl.c b/block/ioctl.c index ad3771b268b81..c2cd3ba5290ce 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -87,14 +87,13 @@ static int blk_ioctl_discard(struct block_device *bdev, fmode_t mode, { uint64_t range[2]; uint64_t start, len; - struct request_queue *q = bdev_get_queue(bdev); struct inode *inode = bdev->bd_inode; int err; if (!(mode & FMODE_WRITE)) return -EBADF; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return -EOPNOTSUPP; if (copy_from_user(range, (void __user *)arg, sizeof(range))) diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c index eae629c4f6eaf..a69475e592822 100644 --- a/drivers/block/drbd/drbd_main.c +++ b/drivers/block/drbd/drbd_main.c @@ -942,7 +942,7 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enu cpu_to_be32(bdev_alignment_offset(bdev)); p->qlim->io_min = cpu_to_be32(bdev_io_min(bdev)); p->qlim->io_opt = cpu_to_be32(bdev_io_opt(bdev)); - p->qlim->discard_enabled = blk_queue_discard(q); + p->qlim->discard_enabled = !!bdev_max_discard_sectors(bdev); put_ldev(device); } else { struct request_queue *q = device->rq_queue; diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c index d4dacc329ac2e..b55e5fcc21e1f 100644 --- a/drivers/block/drbd/drbd_nl.c +++ b/drivers/block/drbd/drbd_nl.c @@ -1210,7 +1210,7 @@ static void decide_on_discard_support(struct drbd_device *device, first_peer_device(device)->connection; struct request_queue *q = device->rq_queue; - if (bdev && !blk_queue_discard(bdev->backing_bdev->bd_disk->queue)) + if (bdev && !bdev_max_discard_sectors(bdev->backing_bdev)) goto not_supported; if (connection->cstate >= C_CONNECTED && @@ -1230,30 +1230,16 @@ static void decide_on_discard_support(struct drbd_device *device, */ blk_queue_discard_granularity(q, 512); q->limits.max_discard_sectors = drbd_max_discard_sectors(connection); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); q->limits.max_write_zeroes_sectors = drbd_max_discard_sectors(connection); return; not_supported: - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); blk_queue_discard_granularity(q, 0); q->limits.max_discard_sectors = 0; q->limits.max_write_zeroes_sectors = 0; } -static void fixup_discard_if_not_supported(struct request_queue *q) -{ - /* To avoid confusion, if this queue does not support discard, clear - * max_discard_sectors, which is what lsblk -D reports to the user. - * Older kernels got this wrong in "stack limits". - * */ - if (!blk_queue_discard(q)) { - blk_queue_max_discard_sectors(q, 0); - blk_queue_discard_granularity(q, 0); - } -} - static void fixup_write_zeroes(struct drbd_device *device, struct request_queue *q) { /* Fixup max_write_zeroes_sectors after blk_stack_limits(): @@ -1300,7 +1286,6 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backi blk_stack_limits(&q->limits, &b->limits, 0); disk_update_readahead(device->vdisk); } - fixup_discard_if_not_supported(q); fixup_write_zeroes(device, q); } @@ -1447,7 +1432,7 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *dis if (disk_conf->al_extents > drbd_al_extents_max(nbc)) disk_conf->al_extents = drbd_al_extents_max(nbc); - if (!blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(bdev)) { if (disk_conf->rs_discard_granularity) { disk_conf->rs_discard_granularity = 0; /* disable feature */ drbd_info(device, "rs_discard_granularity feature disabled\n"); diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c index 0b4c7de463989..8a4a47da56fe9 100644 --- a/drivers/block/drbd/drbd_receiver.c +++ b/drivers/block/drbd/drbd_receiver.c @@ -1575,11 +1575,10 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u static bool can_do_reliable_discards(struct drbd_device *device) { - struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); struct disk_conf *dc; bool can_do; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(device->ldev->backing_bdev)) return false; rcu_read_lock(); diff --git a/drivers/block/loop.c b/drivers/block/loop.c index 8d800d46e4985..0e061c9896eff 100644 --- a/drivers/block/loop.c +++ b/drivers/block/loop.c @@ -314,15 +314,12 @@ static int lo_fallocate(struct loop_device *lo, struct request *rq, loff_t pos, mode |= FALLOC_FL_KEEP_SIZE; - if (!blk_queue_discard(lo->lo_queue)) { - ret = -EOPNOTSUPP; - goto out; - } + if (!bdev_max_discard_sectors(lo->lo_device)) + return -EOPNOTSUPP; ret = file->f_op->fallocate(file, mode, pos, blk_rq_bytes(rq)); if (unlikely(ret && ret != -EINVAL && ret != -EOPNOTSUPP)) - ret = -EIO; - out: + return -EIO; return ret; } @@ -787,12 +784,10 @@ static void loop_config_discard(struct loop_device *lo) q->limits.discard_granularity = granularity; blk_queue_max_discard_sectors(q, max_discard_sectors); blk_queue_max_write_zeroes_sectors(q, max_discard_sectors); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } else { q->limits.discard_granularity = 0; blk_queue_max_discard_sectors(q, 0); blk_queue_max_write_zeroes_sectors(q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); } q->limits.discard_alignment = 0; } diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c index 5a1f98494dddf..4729aef8c6462 100644 --- a/drivers/block/nbd.c +++ b/drivers/block/nbd.c @@ -1231,8 +1231,6 @@ static void nbd_parse_flags(struct nbd_device *nbd) set_disk_ro(nbd->disk, true); else set_disk_ro(nbd->disk, false); - if (config->flags & NBD_FLAG_SEND_TRIM) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, nbd->disk->queue); if (config->flags & NBD_FLAG_SEND_FLUSH) { if (config->flags & NBD_FLAG_SEND_FUA) blk_queue_write_cache(nbd->disk->queue, true, true); @@ -1319,8 +1317,7 @@ static void nbd_config_put(struct nbd_device *nbd) nbd->tag_set.timeout = 0; nbd->disk->queue->limits.discard_granularity = 0; nbd->disk->queue->limits.discard_alignment = 0; - blk_queue_max_discard_sectors(nbd->disk->queue, UINT_MAX); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, nbd->disk->queue); + blk_queue_max_discard_sectors(nbd->disk->queue, 0); mutex_unlock(&nbd->config_lock); nbd_put(nbd); diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c index 05b1120e66234..f6493a9e85ed3 100644 --- a/drivers/block/null_blk/main.c +++ b/drivers/block/null_blk/main.c @@ -1767,7 +1767,6 @@ static void null_config_discard(struct nullb *nullb) nullb->q->limits.discard_granularity = nullb->dev->blocksize; nullb->q->limits.discard_alignment = nullb->dev->blocksize; blk_queue_max_discard_sectors(nullb->q, UINT_MAX >> 9); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, nullb->q); } static const struct block_device_operations null_bio_ops = { diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c index b844432bad20b..2b21f717cce1a 100644 --- a/drivers/block/rbd.c +++ b/drivers/block/rbd.c @@ -4942,7 +4942,6 @@ static int rbd_init_disk(struct rbd_device *rbd_dev) blk_queue_io_opt(q, rbd_dev->opts->alloc_size); if (rbd_dev->opts->trim) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); q->limits.discard_granularity = rbd_dev->opts->alloc_size; blk_queue_max_discard_sectors(q, objset_bytes >> SECTOR_SHIFT); blk_queue_max_write_zeroes_sectors(q, objset_bytes >> SECTOR_SHIFT); diff --git a/drivers/block/rnbd/rnbd-clt.c b/drivers/block/rnbd/rnbd-clt.c index b66e8840b94b8..efa99a3884507 100644 --- a/drivers/block/rnbd/rnbd-clt.c +++ b/drivers/block/rnbd/rnbd-clt.c @@ -1364,8 +1364,6 @@ static void setup_request_queue(struct rnbd_clt_dev *dev) blk_queue_max_discard_sectors(dev->queue, dev->max_discard_sectors); dev->queue->limits.discard_granularity = dev->discard_granularity; dev->queue->limits.discard_alignment = dev->discard_alignment; - if (dev->max_discard_sectors) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, dev->queue); if (dev->secure_discard) blk_queue_flag_set(QUEUE_FLAG_SECERASE, dev->queue); diff --git a/drivers/block/rnbd/rnbd-srv-dev.h b/drivers/block/rnbd/rnbd-srv-dev.h index f82fbb4bbda8e..1f7e1c8fd4d9b 100644 --- a/drivers/block/rnbd/rnbd-srv-dev.h +++ b/drivers/block/rnbd/rnbd-srv-dev.h @@ -49,9 +49,6 @@ static inline int rnbd_dev_get_secure_discard(const struct rnbd_dev *dev) static inline int rnbd_dev_get_max_discard_sects(const struct rnbd_dev *dev) { - if (!blk_queue_discard(bdev_get_queue(dev->bdev))) - return 0; - return bdev_max_discard_sectors(dev->bdev); } diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c index a8bcf3f664af1..6ccf15253dee1 100644 --- a/drivers/block/virtio_blk.c +++ b/drivers/block/virtio_blk.c @@ -888,8 +888,6 @@ static int virtblk_probe(struct virtio_device *vdev) v = sg_elems; blk_queue_max_discard_segments(q, min(v, MAX_DISCARD_SEGMENTS)); - - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } if (virtio_has_feature(vdev, VIRTIO_BLK_F_WRITE_ZEROES)) { diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c index 8b691fe50475f..83cd08041e6b3 100644 --- a/drivers/block/xen-blkback/xenbus.c +++ b/drivers/block/xen-blkback/xenbus.c @@ -583,7 +583,7 @@ static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info if (!xenbus_read_unsigned(dev->nodename, "discard-enable", 1)) return; - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(bdev)) { err = xenbus_printf(xbt, dev->nodename, "discard-granularity", "%u", q->limits.discard_granularity); diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c index 003056d4f7f5f..253bf835aca1f 100644 --- a/drivers/block/xen-blkfront.c +++ b/drivers/block/xen-blkfront.c @@ -944,7 +944,6 @@ static void blkif_set_queue_limits(struct blkfront_info *info) blk_queue_flag_set(QUEUE_FLAG_VIRT, rq); if (info->feature_discard) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, rq); blk_queue_max_discard_sectors(rq, get_capacity(gd)); rq->limits.discard_granularity = info->discard_granularity ?: info->physical_sector_size; @@ -1606,7 +1605,6 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id) blkif_req(req)->error = BLK_STS_NOTSUPP; info->feature_discard = 0; info->feature_secdiscard = 0; - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, rq); blk_queue_flag_clear(QUEUE_FLAG_SECERASE, rq); } break; diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index e9474b02012de..59ff444bf6c76 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1952,7 +1952,6 @@ static int zram_add(void) blk_queue_io_opt(zram->disk->queue, PAGE_SIZE); zram->disk->queue->limits.discard_granularity = PAGE_SIZE; blk_queue_max_discard_sectors(zram->disk->queue, UINT_MAX); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, zram->disk->queue); /* * zram_bio_discard() will clear all logical blocks if logical block diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c index fdd0194f84dd0..e27f67f06a428 100644 --- a/drivers/md/bcache/request.c +++ b/drivers/md/bcache/request.c @@ -1005,7 +1005,7 @@ static void cached_dev_write(struct cached_dev *dc, struct search *s) bio_get(s->iop.bio); if (bio_op(bio) == REQ_OP_DISCARD && - !blk_queue_discard(bdev_get_queue(dc->bdev))) + !bdev_max_discard_sectors(dc->bdev)) goto insert_data; /* I/O request sent to backing device */ @@ -1115,7 +1115,7 @@ static void detached_dev_do_request(struct bcache_device *d, struct bio *bio, bio->bi_private = ddip; if ((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bdev_get_queue(dc->bdev))) + !bdev_max_discard_sectors(dc->bdev)) bio->bi_end_io(bio); else submit_bio_noacct(bio); diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c index bf3de149d3c9f..2f49e31142f62 100644 --- a/drivers/md/bcache/super.c +++ b/drivers/md/bcache/super.c @@ -973,7 +973,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size, blk_queue_flag_set(QUEUE_FLAG_NONROT, d->disk->queue); blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, d->disk->queue); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, d->disk->queue); blk_queue_write_cache(q, true, true); @@ -2350,7 +2349,7 @@ static int register_cache(struct cache_sb *sb, struct cache_sb_disk *sb_disk, ca->bdev->bd_holder = ca; ca->sb_disk = sb_disk; - if (blk_queue_discard(bdev_get_queue(bdev))) + if (bdev_max_discard_sectors((bdev))) ca->discard = CACHE_DISCARD(&ca->sb); ret = cache_alloc(ca); diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c index d1029d71ff3bc..c6f677059214d 100644 --- a/drivers/md/bcache/sysfs.c +++ b/drivers/md/bcache/sysfs.c @@ -1151,7 +1151,7 @@ STORE(__bch_cache) if (attr == &sysfs_discard) { bool v = strtoul_or_return(buf); - if (blk_queue_discard(bdev_get_queue(ca->bdev))) + if (bdev_max_discard_sectors(ca->bdev)) ca->discard = v; if (v != CACHE_DISCARD(&ca->sb)) { diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c index 780a61bc6cc03..28c5de8eca4a0 100644 --- a/drivers/md/dm-cache-target.c +++ b/drivers/md/dm-cache-target.c @@ -3329,13 +3329,6 @@ static int cache_iterate_devices(struct dm_target *ti, return r; } -static bool origin_dev_supports_discard(struct block_device *origin_bdev) -{ - struct request_queue *q = bdev_get_queue(origin_bdev); - - return blk_queue_discard(q); -} - /* * If discard_passdown was enabled verify that the origin device * supports discards. Disable discard_passdown if not. @@ -3349,7 +3342,7 @@ static void disable_passdown_if_not_supported(struct cache *cache) if (!cache->features.discard_passdown) return; - if (!origin_dev_supports_discard(origin_bdev)) + if (!bdev_max_discard_sectors(origin_bdev)) reason = "discard unsupported"; else if (origin_limits->max_discard_sectors < cache->sectors_per_block) diff --git a/drivers/md/dm-clone-target.c b/drivers/md/dm-clone-target.c index 128316a73d016..811b0a5379d03 100644 --- a/drivers/md/dm-clone-target.c +++ b/drivers/md/dm-clone-target.c @@ -2016,13 +2016,6 @@ static void clone_resume(struct dm_target *ti) do_waker(&clone->waker.work); } -static bool bdev_supports_discards(struct block_device *bdev) -{ - struct request_queue *q = bdev_get_queue(bdev); - - return (q && blk_queue_discard(q)); -} - /* * If discard_passdown was enabled verify that the destination device supports * discards. Disable discard_passdown if not. @@ -2036,7 +2029,7 @@ static void disable_passdown_if_not_supported(struct clone *clone) if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags)) return; - if (!bdev_supports_discards(dest_dev)) + if (!bdev_max_discard_sectors(dest_dev)) reason = "discard unsupported"; else if (dest_limits->max_discard_sectors < clone->region_size) reason = "max discard sectors smaller than a region"; diff --git a/drivers/md/dm-log-writes.c b/drivers/md/dm-log-writes.c index c9d036d6bb2ee..e194226c89e54 100644 --- a/drivers/md/dm-log-writes.c +++ b/drivers/md/dm-log-writes.c @@ -866,9 +866,8 @@ static int log_writes_message(struct dm_target *ti, unsigned argc, char **argv, static void log_writes_io_hints(struct dm_target *ti, struct queue_limits *limits) { struct log_writes_c *lc = ti->private; - struct request_queue *q = bdev_get_queue(lc->dev->bdev); - if (!q || !blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(lc->dev->bdev)) { lc->device_supports_discard = false; limits->discard_granularity = lc->sectorsize; limits->max_discard_sectors = (UINT_MAX >> SECTOR_SHIFT); diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c index 2b26435a6946e..9526ccbedafba 100644 --- a/drivers/md/dm-raid.c +++ b/drivers/md/dm-raid.c @@ -2963,13 +2963,8 @@ static void configure_discard_support(struct raid_set *rs) raid456 = rs_is_raid456(rs); for (i = 0; i < rs->raid_disks; i++) { - struct request_queue *q; - - if (!rs->dev[i].rdev.bdev) - continue; - - q = bdev_get_queue(rs->dev[i].rdev.bdev); - if (!q || !blk_queue_discard(q)) + if (!rs->dev[i].rdev.bdev || + !bdev_max_discard_sectors(rs->dev[i].rdev.bdev)) return; if (raid456) { diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c index d46839faa0ca5..0dff6907fd00d 100644 --- a/drivers/md/dm-table.c +++ b/drivers/md/dm-table.c @@ -1888,9 +1888,7 @@ static bool dm_table_supports_nowait(struct dm_table *t) static int device_not_discard_capable(struct dm_target *ti, struct dm_dev *dev, sector_t start, sector_t len, void *data) { - struct request_queue *q = bdev_get_queue(dev->bdev); - - return !blk_queue_discard(q); + return !bdev_max_discard_sectors(dev->bdev); } static bool dm_table_supports_discards(struct dm_table *t) @@ -1970,15 +1968,12 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, q); if (!dm_table_supports_discards(t)) { - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); - /* Must also clear discard limits... */ q->limits.max_discard_sectors = 0; q->limits.max_hw_discard_sectors = 0; q->limits.discard_granularity = 0; q->limits.discard_alignment = 0; q->limits.discard_misaligned = 0; - } else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); + } if (dm_table_supports_secure_erase(t)) blk_queue_flag_set(QUEUE_FLAG_SECERASE, q); diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c index 4d25d0e270313..eded4bcc4545f 100644 --- a/drivers/md/dm-thin.c +++ b/drivers/md/dm-thin.c @@ -2802,13 +2802,6 @@ static void requeue_bios(struct pool *pool) /*---------------------------------------------------------------- * Binding of control targets to a pool object *--------------------------------------------------------------*/ -static bool data_dev_supports_discard(struct pool_c *pt) -{ - struct request_queue *q = bdev_get_queue(pt->data_dev->bdev); - - return blk_queue_discard(q); -} - static bool is_factor(sector_t block_size, uint32_t n) { return !sector_div(block_size, n); @@ -2828,7 +2821,7 @@ static void disable_passdown_if_not_supported(struct pool_c *pt) if (!pt->adjusted_pf.discard_passdown) return; - if (!data_dev_supports_discard(pt)) + if (!bdev_max_discard_sectors(pt->data_dev->bdev)) reason = "discard unsupported"; else if (data_limits->max_discard_sectors < pool->sectors_per_block) @@ -4057,8 +4050,6 @@ static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits) /* * Must explicitly disallow stacking discard limits otherwise the * block layer will stack them if pool's data device has support. - * QUEUE_FLAG_DISCARD wouldn't be set but there is no way for the - * user to see that, so make sure to set all discard limits to 0. */ limits->discard_granularity = 0; return; diff --git a/drivers/md/dm.c b/drivers/md/dm.c index 3c5fad7c4ee68..dbbf64ce7e927 100644 --- a/drivers/md/dm.c +++ b/drivers/md/dm.c @@ -955,7 +955,6 @@ void disable_discard(struct mapped_device *md) /* device doesn't really support DISCARD, disable it */ limits->max_discard_sectors = 0; - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue); } void disable_write_zeroes(struct mapped_device *md) @@ -982,7 +981,7 @@ static void clone_endio(struct bio *bio) if (unlikely(error == BLK_STS_TARGET)) { if (bio_op(bio) == REQ_OP_DISCARD && - !q->limits.max_discard_sectors) + !bdev_max_discard_sectors(bio->bi_bdev)) disable_discard(md); else if (bio_op(bio) == REQ_OP_WRITE_ZEROES && !q->limits.max_write_zeroes_sectors) diff --git a/drivers/md/md-linear.c b/drivers/md/md-linear.c index 0f55b079371b1..138a3b25c5c82 100644 --- a/drivers/md/md-linear.c +++ b/drivers/md/md-linear.c @@ -64,7 +64,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) struct linear_conf *conf; struct md_rdev *rdev; int i, cnt; - bool discard_supported = false; conf = kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL); if (!conf) @@ -96,9 +95,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) conf->array_sectors += rdev->sectors; cnt++; - - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; } if (cnt != raid_disks) { pr_warn("md/linear:%s: not enough drives present. Aborting!\n", @@ -106,11 +102,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) goto out; } - if (!discard_supported) - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); - else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); - /* * Here we calculate the device offsets. */ @@ -252,7 +243,7 @@ static bool linear_make_request(struct mddev *mddev, struct bio *bio) start_sector + data_offset; if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) { + !bdev_max_discard_sectors(bio->bi_bdev))) { /* Just ignore it */ bio_endio(bio); } else { diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c index b21e101183f44..7231f5e1eaa73 100644 --- a/drivers/md/raid0.c +++ b/drivers/md/raid0.c @@ -399,7 +399,6 @@ static int raid0_run(struct mddev *mddev) conf = mddev->private; if (mddev->queue) { struct md_rdev *rdev; - bool discard_supported = false; blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors); blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors); @@ -412,13 +411,7 @@ static int raid0_run(struct mddev *mddev) rdev_for_each(rdev, mddev) { disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; } - if (!discard_supported) - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); - else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); } /* calculate array device size */ diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index d81b896855f9f..3da749d150a17 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -802,7 +802,7 @@ static void flush_bio_list(struct r1conf *conf, struct bio *bio) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -1826,8 +1826,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev) break; } } - if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); print_conf(conf); return err; } @@ -3106,7 +3104,6 @@ static int raid1_run(struct mddev *mddev) int i; struct md_rdev *rdev; int ret; - bool discard_supported = false; if (mddev->level != 1) { pr_warn("md/raid1:%s: raid level not set to mirroring (%d)\n", @@ -3141,8 +3138,6 @@ static int raid1_run(struct mddev *mddev) continue; disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; } mddev->degraded = 0; @@ -3179,15 +3174,6 @@ static int raid1_run(struct mddev *mddev) md_set_array_sectors(mddev, raid1_size(mddev, 0, 0)); - if (mddev->queue) { - if (discard_supported) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); - } - ret = md_integrity_register(mddev); if (ret) { md_unregister_thread(&mddev->thread); diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c index 7816c8b2e8087..36a460015cf58 100644 --- a/drivers/md/raid10.c +++ b/drivers/md/raid10.c @@ -888,7 +888,7 @@ static void flush_pending_writes(struct r10conf *conf) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -1083,7 +1083,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -2144,8 +2144,6 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev) rcu_assign_pointer(p->rdev, rdev); break; } - if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); print_conf(conf); return err; @@ -4069,7 +4067,6 @@ static int raid10_run(struct mddev *mddev) sector_t size; sector_t min_offset_diff = 0; int first = 1; - bool discard_supported = false; if (mddev_init_writes_pending(mddev) < 0) return -ENOMEM; @@ -4140,20 +4137,9 @@ static int raid10_run(struct mddev *mddev) rdev->data_offset << 9); disk->head_position = 0; - - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported = true; first = 0; } - if (mddev->queue) { - if (discard_supported) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); - } /* need to check that every block has at least one working mirror */ if (!enough(conf, -1)) { pr_err("md/raid10:%s: not enough operational mirrors.\n", diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c index a7d50ff9020a8..c3cbf9a574a39 100644 --- a/drivers/md/raid5-cache.c +++ b/drivers/md/raid5-cache.c @@ -1318,7 +1318,7 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log, r5l_write_super(log, end); - if (!blk_queue_discard(bdev_get_queue(bdev))) + if (!bdev_max_discard_sectors(bdev)) return; mddev = log->rdev->mddev; diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c index 0bbae0e638666..59f91e392a2ae 100644 --- a/drivers/md/raid5.c +++ b/drivers/md/raid5.c @@ -7776,14 +7776,10 @@ static int raid5_run(struct mddev *mddev) * A better idea might be to turn DISCARD into WRITE_ZEROES * requests, as that is required to be safe. */ - if (devices_handle_discard_safely && - mddev->queue->limits.max_discard_sectors >= (stripe >> 9) && - mddev->queue->limits.discard_granularity >= stripe) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); + if (!devices_handle_discard_safely || + mddev->queue->limits.max_discard_sectors < (stripe >> 9) || + mddev->queue->limits.discard_granularity < stripe) + blk_queue_max_discard_sectors(mddev->queue, 0); blk_queue_max_hw_sectors(mddev->queue, UINT_MAX); } diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c index c69b2d9df6f16..cac6315010a3d 100644 --- a/drivers/mmc/core/queue.c +++ b/drivers/mmc/core/queue.c @@ -183,7 +183,6 @@ static void mmc_queue_setup_discard(struct request_queue *q, if (!max_discard) return; - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); blk_queue_max_discard_sectors(q, max_discard); q->limits.discard_granularity = card->pref_erase << 9; /* granularity must not be greater than max. discard */ diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c index 64d2b093f114b..f731721114655 100644 --- a/drivers/mtd/mtd_blkdevs.c +++ b/drivers/mtd/mtd_blkdevs.c @@ -377,7 +377,6 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new) blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq); if (tr->discard) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, new->rq); blk_queue_max_discard_sectors(new->rq, UINT_MAX); new->rq->limits.discard_granularity = tr->blksize; } diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index efb85c6d8e2d5..7e07dd69262a7 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -1607,10 +1607,8 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns) struct request_queue *queue = disk->queue; u32 size = queue_logical_block_size(queue); - if (ctrl->max_discard_sectors == 0) { - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, queue); + if (ctrl->max_discard_sectors == 0) return; - } BUILD_BUG_ON(PAGE_SIZE / sizeof(struct nvme_dsm_range) < NVME_DSM_MAX_RANGES); @@ -1619,7 +1617,7 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns) queue->limits.discard_granularity = size; /* If discard is already enabled, don't reset queue limits */ - if (blk_queue_flag_test_and_set(QUEUE_FLAG_DISCARD, queue)) + if (queue->limits.max_discard_sectors) return; blk_queue_max_discard_sectors(queue, ctrl->max_discard_sectors); diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c index e084f4deddddd..8bd5665db9198 100644 --- a/drivers/s390/block/dasd_fba.c +++ b/drivers/s390/block/dasd_fba.c @@ -791,7 +791,6 @@ static void dasd_fba_setup_blk_queue(struct dasd_block *block) blk_queue_max_discard_sectors(q, max_discard_sectors); blk_queue_max_write_zeroes_sectors(q, max_discard_sectors); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } static int dasd_fba_pe_handler(struct dasd_device *device, diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index a390679cf4584..444479657b7fd 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -797,7 +797,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode) case SD_LBP_FULL: case SD_LBP_DISABLE: blk_queue_max_discard_sectors(q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); return; case SD_LBP_UNMAP: @@ -830,7 +829,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode) } blk_queue_max_discard_sectors(q, max_blocks * (logical_block_size >> 9)); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd) diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c index c3e25bac90d59..6cb9f87843278 100644 --- a/drivers/target/target_core_device.c +++ b/drivers/target/target_core_device.c @@ -838,7 +838,7 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib, struct request_queue *q = bdev_get_queue(bdev); int block_size = bdev_logical_block_size(bdev); - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return false; attrib->max_unmap_lba_count = diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index f477035a2ac23..efd8deb3ab7e8 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c @@ -1291,7 +1291,7 @@ static int do_discard_extent(struct btrfs_io_stripe *stripe, u64 *bytes) ret = btrfs_reset_device_zone(dev_replace->tgtdev, phys, len, &discarded); discarded += src_disc; - } else if (blk_queue_discard(bdev_get_queue(stripe->dev->bdev))) { + } else if (bdev_max_discard_sectors(stripe->dev->bdev)) { ret = btrfs_issue_discard(dev->bdev, phys, len, &discarded); } else { ret = 0; @@ -5987,7 +5987,7 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, u64 *trimmed) *trimmed = 0; /* Discard not supported = nothing to do. */ - if (!blk_queue_discard(bdev_get_queue(device->bdev))) + if (!bdev_max_discard_sectors(device->bdev)) return 0; /* Not writable = nothing to do. */ diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index f46e71061942d..096bb0da03f1c 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -501,7 +501,7 @@ static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info, if (!device->bdev) continue; q = bdev_get_queue(device->bdev); - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(device->bdev)) { num_devices++; minlen = min_t(u64, q->limits.discard_granularity, minlen); diff --git a/fs/exfat/file.c b/fs/exfat/file.c index 2f51300592366..765e4f63dd18d 100644 --- a/fs/exfat/file.c +++ b/fs/exfat/file.c @@ -358,7 +358,7 @@ static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(inode->i_sb->s_bdev)) return -EOPNOTSUPP; if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range))) diff --git a/fs/exfat/super.c b/fs/exfat/super.c index 8ca21e7917d16..be0788ecaf20e 100644 --- a/fs/exfat/super.c +++ b/fs/exfat/super.c @@ -627,13 +627,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc) if (opts->allow_utime == (unsigned short)-1) opts->allow_utime = ~opts->fs_dmask & 0022; - if (opts->discard) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - - if (!blk_queue_discard(q)) { - exfat_warn(sb, "mounting with \"discard\" option, but the device does not support discard"); - opts->discard = 0; - } + if (opts->discard && !bdev_max_discard_sectors(sb->s_bdev)) { + exfat_warn(sb, "mounting with \"discard\" option, but the device does not support discard"); + opts->discard = 0; } sb->s_flags |= SB_NODIRATIME; diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c index 992229ca2d830..6e3b9eea126f4 100644 --- a/fs/ext4/ioctl.c +++ b/fs/ext4/ioctl.c @@ -1044,7 +1044,6 @@ static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg) __u32 flags = 0; unsigned int flush_flags = 0; struct super_block *sb = file_inode(filp)->i_sb; - struct request_queue *q; if (copy_from_user(&flags, (__u32 __user *)arg, sizeof(__u32))) @@ -1065,10 +1064,8 @@ static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg) if (flags & ~EXT4_IOC_CHECKPOINT_FLAG_VALID) return -EINVAL; - q = bdev_get_queue(EXT4_SB(sb)->s_journal->j_dev); - if (!q) - return -ENXIO; - if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) + if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && + !bdev_max_discard_sectors(EXT4_SB(sb)->s_journal->j_dev)) return -EOPNOTSUPP; if (flags & EXT4_IOC_CHECKPOINT_FLAG_DRY_RUN) @@ -1393,14 +1390,13 @@ static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) case FITRIM: { - struct request_queue *q = bdev_get_queue(sb->s_bdev); struct fstrim_range range; int ret = 0; if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; /* diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 81749eaddf4c1..93f4e4e9e2631 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -5458,13 +5458,9 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) goto failed_mount9; } - if (test_opt(sb, DISCARD)) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - if (!blk_queue_discard(q)) - ext4_msg(sb, KERN_WARNING, - "mounting with \"discard\" option, but " - "the device does not support discard"); - } + if (test_opt(sb, DISCARD) && !bdev_max_discard_sectors(sb->s_bdev)) + ext4_msg(sb, KERN_WARNING, + "mounting with \"discard\" option, but the device does not support discard"); if (es->s_error_count) mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */ diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index cd1e65bcf0b04..0ea9a5fa7c1dd 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4381,8 +4381,7 @@ static inline bool f2fs_hw_should_discard(struct f2fs_sb_info *sbi) static inline bool f2fs_bdev_support_discard(struct block_device *bdev) { - return blk_queue_discard(bdev_get_queue(bdev)) || - bdev_is_zoned(bdev); + return bdev_max_discard_sectors(bdev) || bdev_is_zoned(bdev); } static inline bool f2fs_hw_support_discard(struct f2fs_sb_info *sbi) diff --git a/fs/fat/file.c b/fs/fat/file.c index a5a309fcc7faf..e4c7d10e80129 100644 --- a/fs/fat/file.c +++ b/fs/fat/file.c @@ -133,7 +133,7 @@ static int fat_ioctl_fitrim(struct inode *inode, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; user_range = (struct fstrim_range __user *)arg; diff --git a/fs/fat/inode.c b/fs/fat/inode.c index bf6051bdf1d1d..3d1afb95a925a 100644 --- a/fs/fat/inode.c +++ b/fs/fat/inode.c @@ -1872,13 +1872,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, goto out_fail; } - if (sbi->options.discard) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - if (!blk_queue_discard(q)) - fat_msg(sb, KERN_WARNING, - "mounting with \"discard\" option, but " - "the device does not support discard"); - } + if (sbi->options.discard && !bdev_max_discard_sectors(sb->s_bdev)) + fat_msg(sb, KERN_WARNING, + "mounting with \"discard\" option, but the device does not support discard"); fat_set_state(sb, 1, 0); return 0; diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c index 801ad9f4f2bef..7f20ac9133bc6 100644 --- a/fs/gfs2/rgrp.c +++ b/fs/gfs2/rgrp.c @@ -1405,7 +1405,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp) if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) return -EROFS; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sdp->sd_vfs->s_bdev)) return -EOPNOTSUPP; if (copy_from_user(&r, argp, sizeof(r))) diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c index fcacafa4510d1..19d226cd4ff4d 100644 --- a/fs/jbd2/journal.c +++ b/fs/jbd2/journal.c @@ -1762,7 +1762,6 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) unsigned long block, log_offset; /* logical */ unsigned long long phys_block, block_start, block_stop; /* physical */ loff_t byte_start, byte_stop, byte_count; - struct request_queue *q = bdev_get_queue(journal->j_dev); /* flags must be set to either discard or zeroout */ if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags || @@ -1770,10 +1769,8 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) (flags & JBD2_JOURNAL_FLUSH_ZEROOUT))) return -EINVAL; - if (!q) - return -ENXIO; - - if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) + if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && + !bdev_max_discard_sectors(journal->j_dev)) return -EOPNOTSUPP; /* diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c index 03a845ab4f009..357ae6e5c36ec 100644 --- a/fs/jfs/ioctl.c +++ b/fs/jfs/ioctl.c @@ -117,7 +117,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(sb->s_bdev)) { jfs_warn("FITRIM not supported on device"); return -EOPNOTSUPP; } diff --git a/fs/jfs/super.c b/fs/jfs/super.c index f1a13a74cddf3..85d4f44f2ac4d 100644 --- a/fs/jfs/super.c +++ b/fs/jfs/super.c @@ -372,19 +372,16 @@ static int parse_options(char *options, struct super_block *sb, s64 *newLVSize, } case Opt_discard: - { - struct request_queue *q = bdev_get_queue(sb->s_bdev); /* if set to 1, even copying files will cause * trimming :O * -> user has more control over the online trimming */ sbi->minblks_trim = 64; - if (blk_queue_discard(q)) + if (bdev_max_discard_sectors(sb->s_bdev)) *flag |= JFS_DISCARD; else pr_err("JFS: discard option not supported on device\n"); break; - } case Opt_nodiscard: *flag &= ~JFS_DISCARD; @@ -392,10 +389,9 @@ static int parse_options(char *options, struct super_block *sb, s64 *newLVSize, case Opt_discard_minblk: { - struct request_queue *q = bdev_get_queue(sb->s_bdev); char *minblks_trim = args[0].from; int rc; - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(sb->s_bdev)) { *flag |= JFS_DISCARD; rc = kstrtouint(minblks_trim, 0, &sbi->minblks_trim); diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c index fec194a666f4b..52b73f558fcb1 100644 --- a/fs/nilfs2/ioctl.c +++ b/fs/nilfs2/ioctl.c @@ -1059,7 +1059,7 @@ static int nilfs_ioctl_trim_fs(struct inode *inode, void __user *argp) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(nilfs->ns_bdev)) return -EOPNOTSUPP; if (copy_from_user(&range, argp, sizeof(range))) diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c index 787b53b984ee1..e763236169331 100644 --- a/fs/ntfs3/file.c +++ b/fs/ntfs3/file.c @@ -28,7 +28,7 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sbi->sb->s_bdev)) return -EOPNOTSUPP; user_range = (struct fstrim_range __user *)arg; diff --git a/fs/ntfs3/super.c b/fs/ntfs3/super.c index cd30e81abbce0..c734085bcce4a 100644 --- a/fs/ntfs3/super.c +++ b/fs/ntfs3/super.c @@ -913,7 +913,7 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) } rq = bdev_get_queue(bdev); - if (blk_queue_discard(rq) && rq->limits.discard_granularity) { + if (bdev_max_discard_sectors(bdev) && rq->limits.discard_granularity) { sbi->discard_granularity = rq->limits.discard_granularity; sbi->discard_granularity_mask_inv = ~(u64)(sbi->discard_granularity - 1); diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c index f59461d85da45..9b78ef103ada6 100644 --- a/fs/ocfs2/ioctl.c +++ b/fs/ocfs2/ioctl.c @@ -910,7 +910,7 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; if (copy_from_user(&range, argp, sizeof(range))) diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c index 0191de8ce9ced..a4e6609d616b7 100644 --- a/fs/xfs/xfs_discard.c +++ b/fs/xfs/xfs_discard.c @@ -162,7 +162,7 @@ xfs_ioc_trim( if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(mp->m_ddev_targp->bt_bdev)) return -EOPNOTSUPP; /* diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c index 54be9d64093ed..a276b8111f636 100644 --- a/fs/xfs/xfs_super.c +++ b/fs/xfs/xfs_super.c @@ -1608,14 +1608,10 @@ xfs_fs_fill_super( goto out_filestream_unmount; } - if (xfs_has_discard(mp)) { - struct request_queue *q = bdev_get_queue(sb->s_bdev); - - if (!blk_queue_discard(q)) { - xfs_warn(mp, "mounting with \"discard\" option, but " - "the device does not support discard"); - mp->m_features &= ~XFS_FEAT_DISCARD; - } + if (xfs_has_discard(mp) && !bdev_max_discard_sectors(sb->s_bdev)) { + xfs_warn(mp, + "mounting with \"discard\" option, but the device does not support discard"); + mp->m_features &= ~XFS_FEAT_DISCARD; } if (xfs_has_reflink(mp)) { diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index ce16247d3afab..767ab22e1052a 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -540,7 +540,6 @@ struct request_queue { #define QUEUE_FLAG_NONROT 6 /* non-rotational device (SSD) */ #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */ #define QUEUE_FLAG_IO_STAT 7 /* do disk/partitions IO accounting */ -#define QUEUE_FLAG_DISCARD 8 /* supports DISCARD */ #define QUEUE_FLAG_NOXMERGES 9 /* No extended merges */ #define QUEUE_FLAG_ADD_RANDOM 10 /* Contributes to random pool */ #define QUEUE_FLAG_SECERASE 11 /* supports secure erase */ @@ -582,7 +581,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); test_bit(QUEUE_FLAG_STABLE_WRITES, &(q)->queue_flags) #define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags) #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags) -#define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags) #define blk_queue_zone_resetall(q) \ test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags) #define blk_queue_secure_erase(q) \ diff --git a/mm/swapfile.c b/mm/swapfile.c index 4069f17a82c8e..5d9cedf9e7b84 100644 --- a/mm/swapfile.c +++ b/mm/swapfile.c @@ -2957,20 +2957,6 @@ static int setup_swap_map_and_extents(struct swap_info_struct *p, return nr_extents; } -/* - * Helper to sys_swapon determining if a given swap - * backing device queue supports DISCARD operations. - */ -static bool swap_discardable(struct swap_info_struct *si) -{ - struct request_queue *q = bdev_get_queue(si->bdev); - - if (!blk_queue_discard(q)) - return false; - - return true; -} - SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) { struct swap_info_struct *p; @@ -3132,7 +3118,8 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) sizeof(long), GFP_KERNEL); - if (p->bdev && (swap_flags & SWAP_FLAG_DISCARD) && swap_discardable(p)) { + if ((swap_flags & SWAP_FLAG_DISCARD) && + p->bdev && bdev_max_discard_sectors(p->bdev)) { /* * When discard is enabled for swap with no particular * policy flagged, we set all swap discard flags here in -- 2.30.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christoph Hellwig Subject: [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD Date: Sat, 9 Apr 2022 06:50:40 +0200 Message-ID: <20220409045043.23593-25-hch@lst.de> References: <20220409045043.23593-1-hch@lst.de> Mime-Version: 1.0 Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20220409045043.23593-1-hch@lst.de> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: cluster-devel-bounces@redhat.com Sender: "Cluster-devel" Content-Type: text/plain; charset="iso-8859-1" To: Jens Axboe Cc: jfs-discussion@lists.sourceforge.net, linux-nvme@lists.infradead.org, virtualization@lists.linux-foundation.org, linux-mm@kvack.org, dm-devel@redhat.com, target-devel@vger.kernel.org, linux-mtd@lists.infradead.org, drbd-dev@lists.linbit.com, linux-s390@vger.kernel.org, linux-nilfs@vger.kernel.org, linux-scsi@vger.kernel.org, cluster-devel@redhat.com, xen-devel@lists.xenproject.org, linux-ext4@vger.kernel.org, linux-um@lists.infradead.org, nbd@other.debian.org, linux-block@vger.kernel.org, linux-bcache@vger.kernel.org, ceph-devel@vger.kernel.org, Coly Li , linux-raid@vger.kernel.org, "Martin K . Petersen" , linux-mmc@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-xfs@vger.kernel.org, =?UTF-8?q?Christoph=20B=C3=B6hmwalder?= , ocfs2-devel@oss.oracle.com, linux-fsdevel@vger.kernel. Just use a non-zero max_discard_sectors as an indicator for discard support, similar to what is done for write zeroes. The only places where needs special attention is the RAID5 driver, which must clear discard support for security reasons by default, even if the default stacking rules would allow for it. Signed-off-by: Christoph Hellwig Reviewed-by: Martin K. Petersen Acked-by: Christoph B=C3=B6hmwalder [btr= fs] Acked-by: Coly Li [bcache] --- arch/um/drivers/ubd_kern.c | 2 -- block/blk-core.c | 2 +- block/blk-lib.c | 2 +- block/blk-mq-debugfs.c | 1 - block/ioctl.c | 3 +-- drivers/block/drbd/drbd_main.c | 2 +- drivers/block/drbd/drbd_nl.c | 19 ++----------------- drivers/block/drbd/drbd_receiver.c | 3 +-- drivers/block/loop.c | 11 +++-------- drivers/block/nbd.c | 5 +---- drivers/block/null_blk/main.c | 1 - drivers/block/rbd.c | 1 - drivers/block/rnbd/rnbd-clt.c | 2 -- drivers/block/rnbd/rnbd-srv-dev.h | 3 --- drivers/block/virtio_blk.c | 2 -- drivers/block/xen-blkback/xenbus.c | 2 +- drivers/block/xen-blkfront.c | 2 -- drivers/block/zram/zram_drv.c | 1 - drivers/md/bcache/request.c | 4 ++-- drivers/md/bcache/super.c | 3 +-- drivers/md/bcache/sysfs.c | 2 +- drivers/md/dm-cache-target.c | 9 +-------- drivers/md/dm-clone-target.c | 9 +-------- drivers/md/dm-log-writes.c | 3 +-- drivers/md/dm-raid.c | 9 ++------- drivers/md/dm-table.c | 9 ++------- drivers/md/dm-thin.c | 11 +---------- drivers/md/dm.c | 3 +-- drivers/md/md-linear.c | 11 +---------- drivers/md/raid0.c | 7 ------- drivers/md/raid1.c | 16 +--------------- drivers/md/raid10.c | 18 ++---------------- drivers/md/raid5-cache.c | 2 +- drivers/md/raid5.c | 12 ++++-------- drivers/mmc/core/queue.c | 1 - drivers/mtd/mtd_blkdevs.c | 1 - drivers/nvme/host/core.c | 6 ++---- drivers/s390/block/dasd_fba.c | 1 - drivers/scsi/sd.c | 2 -- drivers/target/target_core_device.c | 2 +- fs/btrfs/extent-tree.c | 4 ++-- fs/btrfs/ioctl.c | 2 +- fs/exfat/file.c | 2 +- fs/exfat/super.c | 10 +++------- fs/ext4/ioctl.c | 10 +++------- fs/ext4/super.c | 10 +++------- fs/f2fs/f2fs.h | 3 +-- fs/fat/file.c | 2 +- fs/fat/inode.c | 10 +++------- fs/gfs2/rgrp.c | 2 +- fs/jbd2/journal.c | 7 ++----- fs/jfs/ioctl.c | 2 +- fs/jfs/super.c | 8 ++------ fs/nilfs2/ioctl.c | 2 +- fs/ntfs3/file.c | 2 +- fs/ntfs3/super.c | 2 +- fs/ocfs2/ioctl.c | 2 +- fs/xfs/xfs_discard.c | 2 +- fs/xfs/xfs_super.c | 12 ++++-------- include/linux/blkdev.h | 2 -- mm/swapfile.c | 17 ++--------------- 61 files changed, 72 insertions(+), 246 deletions(-) diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c index b03269faef714..085ffdf98e57e 100644 --- a/arch/um/drivers/ubd_kern.c +++ b/arch/um/drivers/ubd_kern.c @@ -483,7 +483,6 @@ static void ubd_handler(void) if ((io_req->error =3D=3D BLK_STS_NOTSUPP) && (req_op(io_req->req) =3D= =3D REQ_OP_DISCARD)) { blk_queue_max_discard_sectors(io_req->req->q, 0); blk_queue_max_write_zeroes_sectors(io_req->req->q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, io_req->req->q); } blk_mq_end_request(io_req->req, io_req->error); kfree(io_req); @@ -803,7 +802,6 @@ static int ubd_open_dev(struct ubd *ubd_dev) ubd_dev->queue->limits.discard_alignment =3D SECTOR_SIZE; blk_queue_max_discard_sectors(ubd_dev->queue, UBD_MAX_REQUEST); blk_queue_max_write_zeroes_sectors(ubd_dev->queue, UBD_MAX_REQUEST); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, ubd_dev->queue); } blk_queue_flag_set(QUEUE_FLAG_NONROT, ubd_dev->queue); return 0; diff --git a/block/blk-core.c b/block/blk-core.c index 937bb6b863317..b5c3a8049134c 100644 --- a/block/blk-core.c +++ b/block/blk-core.c @@ -820,7 +820,7 @@ void submit_bio_noacct(struct bio *bio) =20 switch (bio_op(bio)) { case REQ_OP_DISCARD: - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) goto not_supported; break; case REQ_OP_SECURE_ERASE: diff --git a/block/blk-lib.c b/block/blk-lib.c index 2ae32a722851c..8b4b66d3a9bfc 100644 --- a/block/blk-lib.c +++ b/block/blk-lib.c @@ -53,7 +53,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sec= tor_t sector, return -EOPNOTSUPP; op =3D REQ_OP_SECURE_ERASE; } else { - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return -EOPNOTSUPP; op =3D REQ_OP_DISCARD; } diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index aa0349e9f083b..fd111c5001256 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -113,7 +113,6 @@ static const char *const blk_queue_flag_name[] =3D { QUEUE_FLAG_NAME(FAIL_IO), QUEUE_FLAG_NAME(NONROT), QUEUE_FLAG_NAME(IO_STAT), - QUEUE_FLAG_NAME(DISCARD), QUEUE_FLAG_NAME(NOXMERGES), QUEUE_FLAG_NAME(ADD_RANDOM), QUEUE_FLAG_NAME(SECERASE), diff --git a/block/ioctl.c b/block/ioctl.c index ad3771b268b81..c2cd3ba5290ce 100644 --- a/block/ioctl.c +++ b/block/ioctl.c @@ -87,14 +87,13 @@ static int blk_ioctl_discard(struct block_device *bdev,= fmode_t mode, { uint64_t range[2]; uint64_t start, len; - struct request_queue *q =3D bdev_get_queue(bdev); struct inode *inode =3D bdev->bd_inode; int err; =20 if (!(mode & FMODE_WRITE)) return -EBADF; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return -EOPNOTSUPP; =20 if (copy_from_user(range, (void __user *)arg, sizeof(range))) diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c index eae629c4f6eaf..a69475e592822 100644 --- a/drivers/block/drbd/drbd_main.c +++ b/drivers/block/drbd/drbd_main.c @@ -942,7 +942,7 @@ int drbd_send_sizes(struct drbd_peer_device *peer_devic= e, int trigger_reply, enu cpu_to_be32(bdev_alignment_offset(bdev)); p->qlim->io_min =3D cpu_to_be32(bdev_io_min(bdev)); p->qlim->io_opt =3D cpu_to_be32(bdev_io_opt(bdev)); - p->qlim->discard_enabled =3D blk_queue_discard(q); + p->qlim->discard_enabled =3D !!bdev_max_discard_sectors(bdev); put_ldev(device); } else { struct request_queue *q =3D device->rq_queue; diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c index d4dacc329ac2e..b55e5fcc21e1f 100644 --- a/drivers/block/drbd/drbd_nl.c +++ b/drivers/block/drbd/drbd_nl.c @@ -1210,7 +1210,7 @@ static void decide_on_discard_support(struct drbd_dev= ice *device, first_peer_device(device)->connection; struct request_queue *q =3D device->rq_queue; =20 - if (bdev && !blk_queue_discard(bdev->backing_bdev->bd_disk->queue)) + if (bdev && !bdev_max_discard_sectors(bdev->backing_bdev)) goto not_supported; =20 if (connection->cstate >=3D C_CONNECTED && @@ -1230,30 +1230,16 @@ static void decide_on_discard_support(struct drbd_d= evice *device, */ blk_queue_discard_granularity(q, 512); q->limits.max_discard_sectors =3D drbd_max_discard_sectors(connection); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); q->limits.max_write_zeroes_sectors =3D drbd_max_discard_sectors(connection); return; =20 not_supported: - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); blk_queue_discard_granularity(q, 0); q->limits.max_discard_sectors =3D 0; q->limits.max_write_zeroes_sectors =3D 0; } =20 -static void fixup_discard_if_not_supported(struct request_queue *q) -{ - /* To avoid confusion, if this queue does not support discard, clear - * max_discard_sectors, which is what lsblk -D reports to the user. - * Older kernels got this wrong in "stack limits". - * */ - if (!blk_queue_discard(q)) { - blk_queue_max_discard_sectors(q, 0); - blk_queue_discard_granularity(q, 0); - } -} - static void fixup_write_zeroes(struct drbd_device *device, struct request_= queue *q) { /* Fixup max_write_zeroes_sectors after blk_stack_limits(): @@ -1300,7 +1286,6 @@ static void drbd_setup_queue_param(struct drbd_device= *device, struct drbd_backi blk_stack_limits(&q->limits, &b->limits, 0); disk_update_readahead(device->vdisk); } - fixup_discard_if_not_supported(q); fixup_write_zeroes(device, q); } =20 @@ -1447,7 +1432,7 @@ static void sanitize_disk_conf(struct drbd_device *de= vice, struct disk_conf *dis if (disk_conf->al_extents > drbd_al_extents_max(nbc)) disk_conf->al_extents =3D drbd_al_extents_max(nbc); =20 - if (!blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(bdev)) { if (disk_conf->rs_discard_granularity) { disk_conf->rs_discard_granularity =3D 0; /* disable feature */ drbd_info(device, "rs_discard_granularity feature disabled\n"); diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_r= eceiver.c index 0b4c7de463989..8a4a47da56fe9 100644 --- a/drivers/block/drbd/drbd_receiver.c +++ b/drivers/block/drbd/drbd_receiver.c @@ -1575,11 +1575,10 @@ int drbd_issue_discard_or_zero_out(struct drbd_devi= ce *device, sector_t start, u =20 static bool can_do_reliable_discards(struct drbd_device *device) { - struct request_queue *q =3D bdev_get_queue(device->ldev->backing_bdev); struct disk_conf *dc; bool can_do; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(device->ldev->backing_bdev)) return false; =20 rcu_read_lock(); diff --git a/drivers/block/loop.c b/drivers/block/loop.c index 8d800d46e4985..0e061c9896eff 100644 --- a/drivers/block/loop.c +++ b/drivers/block/loop.c @@ -314,15 +314,12 @@ static int lo_fallocate(struct loop_device *lo, struc= t request *rq, loff_t pos, =20 mode |=3D FALLOC_FL_KEEP_SIZE; =20 - if (!blk_queue_discard(lo->lo_queue)) { - ret =3D -EOPNOTSUPP; - goto out; - } + if (!bdev_max_discard_sectors(lo->lo_device)) + return -EOPNOTSUPP; =20 ret =3D file->f_op->fallocate(file, mode, pos, blk_rq_bytes(rq)); if (unlikely(ret && ret !=3D -EINVAL && ret !=3D -EOPNOTSUPP)) - ret =3D -EIO; - out: + return -EIO; return ret; } =20 @@ -787,12 +784,10 @@ static void loop_config_discard(struct loop_device *l= o) q->limits.discard_granularity =3D granularity; blk_queue_max_discard_sectors(q, max_discard_sectors); blk_queue_max_write_zeroes_sectors(q, max_discard_sectors); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } else { q->limits.discard_granularity =3D 0; blk_queue_max_discard_sectors(q, 0); blk_queue_max_write_zeroes_sectors(q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); } q->limits.discard_alignment =3D 0; } diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c index 5a1f98494dddf..4729aef8c6462 100644 --- a/drivers/block/nbd.c +++ b/drivers/block/nbd.c @@ -1231,8 +1231,6 @@ static void nbd_parse_flags(struct nbd_device *nbd) set_disk_ro(nbd->disk, true); else set_disk_ro(nbd->disk, false); - if (config->flags & NBD_FLAG_SEND_TRIM) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, nbd->disk->queue); if (config->flags & NBD_FLAG_SEND_FLUSH) { if (config->flags & NBD_FLAG_SEND_FUA) blk_queue_write_cache(nbd->disk->queue, true, true); @@ -1319,8 +1317,7 @@ static void nbd_config_put(struct nbd_device *nbd) nbd->tag_set.timeout =3D 0; nbd->disk->queue->limits.discard_granularity =3D 0; nbd->disk->queue->limits.discard_alignment =3D 0; - blk_queue_max_discard_sectors(nbd->disk->queue, UINT_MAX); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, nbd->disk->queue); + blk_queue_max_discard_sectors(nbd->disk->queue, 0); =20 mutex_unlock(&nbd->config_lock); nbd_put(nbd); diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c index 05b1120e66234..f6493a9e85ed3 100644 --- a/drivers/block/null_blk/main.c +++ b/drivers/block/null_blk/main.c @@ -1767,7 +1767,6 @@ static void null_config_discard(struct nullb *nullb) nullb->q->limits.discard_granularity =3D nullb->dev->blocksize; nullb->q->limits.discard_alignment =3D nullb->dev->blocksize; blk_queue_max_discard_sectors(nullb->q, UINT_MAX >> 9); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, nullb->q); } =20 static const struct block_device_operations null_bio_ops =3D { diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c index b844432bad20b..2b21f717cce1a 100644 --- a/drivers/block/rbd.c +++ b/drivers/block/rbd.c @@ -4942,7 +4942,6 @@ static int rbd_init_disk(struct rbd_device *rbd_dev) blk_queue_io_opt(q, rbd_dev->opts->alloc_size); =20 if (rbd_dev->opts->trim) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); q->limits.discard_granularity =3D rbd_dev->opts->alloc_size; blk_queue_max_discard_sectors(q, objset_bytes >> SECTOR_SHIFT); blk_queue_max_write_zeroes_sectors(q, objset_bytes >> SECTOR_SHIFT); diff --git a/drivers/block/rnbd/rnbd-clt.c b/drivers/block/rnbd/rnbd-clt.c index b66e8840b94b8..efa99a3884507 100644 --- a/drivers/block/rnbd/rnbd-clt.c +++ b/drivers/block/rnbd/rnbd-clt.c @@ -1364,8 +1364,6 @@ static void setup_request_queue(struct rnbd_clt_dev *= dev) blk_queue_max_discard_sectors(dev->queue, dev->max_discard_sectors); dev->queue->limits.discard_granularity =3D dev->discard_granularity; dev->queue->limits.discard_alignment =3D dev->discard_alignment; - if (dev->max_discard_sectors) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, dev->queue); if (dev->secure_discard) blk_queue_flag_set(QUEUE_FLAG_SECERASE, dev->queue); =20 diff --git a/drivers/block/rnbd/rnbd-srv-dev.h b/drivers/block/rnbd/rnbd-sr= v-dev.h index f82fbb4bbda8e..1f7e1c8fd4d9b 100644 --- a/drivers/block/rnbd/rnbd-srv-dev.h +++ b/drivers/block/rnbd/rnbd-srv-dev.h @@ -49,9 +49,6 @@ static inline int rnbd_dev_get_secure_discard(const struc= t rnbd_dev *dev) =20 static inline int rnbd_dev_get_max_discard_sects(const struct rnbd_dev *de= v) { - if (!blk_queue_discard(bdev_get_queue(dev->bdev))) - return 0; - return bdev_max_discard_sectors(dev->bdev); } =20 diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c index a8bcf3f664af1..6ccf15253dee1 100644 --- a/drivers/block/virtio_blk.c +++ b/drivers/block/virtio_blk.c @@ -888,8 +888,6 @@ static int virtblk_probe(struct virtio_device *vdev) v =3D sg_elems; blk_queue_max_discard_segments(q, min(v, MAX_DISCARD_SEGMENTS)); - - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } =20 if (virtio_has_feature(vdev, VIRTIO_BLK_F_WRITE_ZEROES)) { diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback= /xenbus.c index 8b691fe50475f..83cd08041e6b3 100644 --- a/drivers/block/xen-blkback/xenbus.c +++ b/drivers/block/xen-blkback/xenbus.c @@ -583,7 +583,7 @@ static void xen_blkbk_discard(struct xenbus_transaction= xbt, struct backend_info if (!xenbus_read_unsigned(dev->nodename, "discard-enable", 1)) return; =20 - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(bdev)) { err =3D xenbus_printf(xbt, dev->nodename, "discard-granularity", "%u", q->limits.discard_granularity); diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c index 003056d4f7f5f..253bf835aca1f 100644 --- a/drivers/block/xen-blkfront.c +++ b/drivers/block/xen-blkfront.c @@ -944,7 +944,6 @@ static void blkif_set_queue_limits(struct blkfront_info= *info) blk_queue_flag_set(QUEUE_FLAG_VIRT, rq); =20 if (info->feature_discard) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, rq); blk_queue_max_discard_sectors(rq, get_capacity(gd)); rq->limits.discard_granularity =3D info->discard_granularity ?: info->physical_sector_size; @@ -1606,7 +1605,6 @@ static irqreturn_t blkif_interrupt(int irq, void *dev= _id) blkif_req(req)->error =3D BLK_STS_NOTSUPP; info->feature_discard =3D 0; info->feature_secdiscard =3D 0; - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, rq); blk_queue_flag_clear(QUEUE_FLAG_SECERASE, rq); } break; diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c index e9474b02012de..59ff444bf6c76 100644 --- a/drivers/block/zram/zram_drv.c +++ b/drivers/block/zram/zram_drv.c @@ -1952,7 +1952,6 @@ static int zram_add(void) blk_queue_io_opt(zram->disk->queue, PAGE_SIZE); zram->disk->queue->limits.discard_granularity =3D PAGE_SIZE; blk_queue_max_discard_sectors(zram->disk->queue, UINT_MAX); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, zram->disk->queue); =20 /* * zram_bio_discard() will clear all logical blocks if logical block diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c index fdd0194f84dd0..e27f67f06a428 100644 --- a/drivers/md/bcache/request.c +++ b/drivers/md/bcache/request.c @@ -1005,7 +1005,7 @@ static void cached_dev_write(struct cached_dev *dc, s= truct search *s) bio_get(s->iop.bio); =20 if (bio_op(bio) =3D=3D REQ_OP_DISCARD && - !blk_queue_discard(bdev_get_queue(dc->bdev))) + !bdev_max_discard_sectors(dc->bdev)) goto insert_data; =20 /* I/O request sent to backing device */ @@ -1115,7 +1115,7 @@ static void detached_dev_do_request(struct bcache_dev= ice *d, struct bio *bio, bio->bi_private =3D ddip; =20 if ((bio_op(bio) =3D=3D REQ_OP_DISCARD) && - !blk_queue_discard(bdev_get_queue(dc->bdev))) + !bdev_max_discard_sectors(dc->bdev)) bio->bi_end_io(bio); else submit_bio_noacct(bio); diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c index bf3de149d3c9f..2f49e31142f62 100644 --- a/drivers/md/bcache/super.c +++ b/drivers/md/bcache/super.c @@ -973,7 +973,6 @@ static int bcache_device_init(struct bcache_device *d, = unsigned int block_size, =20 blk_queue_flag_set(QUEUE_FLAG_NONROT, d->disk->queue); blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, d->disk->queue); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, d->disk->queue); =20 blk_queue_write_cache(q, true, true); =20 @@ -2350,7 +2349,7 @@ static int register_cache(struct cache_sb *sb, struct= cache_sb_disk *sb_disk, ca->bdev->bd_holder =3D ca; ca->sb_disk =3D sb_disk; =20 - if (blk_queue_discard(bdev_get_queue(bdev))) + if (bdev_max_discard_sectors((bdev))) ca->discard =3D CACHE_DISCARD(&ca->sb); =20 ret =3D cache_alloc(ca); diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c index d1029d71ff3bc..c6f677059214d 100644 --- a/drivers/md/bcache/sysfs.c +++ b/drivers/md/bcache/sysfs.c @@ -1151,7 +1151,7 @@ STORE(__bch_cache) if (attr =3D=3D &sysfs_discard) { bool v =3D strtoul_or_return(buf); =20 - if (blk_queue_discard(bdev_get_queue(ca->bdev))) + if (bdev_max_discard_sectors(ca->bdev)) ca->discard =3D v; =20 if (v !=3D CACHE_DISCARD(&ca->sb)) { diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c index 780a61bc6cc03..28c5de8eca4a0 100644 --- a/drivers/md/dm-cache-target.c +++ b/drivers/md/dm-cache-target.c @@ -3329,13 +3329,6 @@ static int cache_iterate_devices(struct dm_target *t= i, return r; } =20 -static bool origin_dev_supports_discard(struct block_device *origin_bdev) -{ - struct request_queue *q =3D bdev_get_queue(origin_bdev); - - return blk_queue_discard(q); -} - /* * If discard_passdown was enabled verify that the origin device * supports discards. Disable discard_passdown if not. @@ -3349,7 +3342,7 @@ static void disable_passdown_if_not_supported(struct = cache *cache) if (!cache->features.discard_passdown) return; =20 - if (!origin_dev_supports_discard(origin_bdev)) + if (!bdev_max_discard_sectors(origin_bdev)) reason =3D "discard unsupported"; =20 else if (origin_limits->max_discard_sectors < cache->sectors_per_block) diff --git a/drivers/md/dm-clone-target.c b/drivers/md/dm-clone-target.c index 128316a73d016..811b0a5379d03 100644 --- a/drivers/md/dm-clone-target.c +++ b/drivers/md/dm-clone-target.c @@ -2016,13 +2016,6 @@ static void clone_resume(struct dm_target *ti) do_waker(&clone->waker.work); } =20 -static bool bdev_supports_discards(struct block_device *bdev) -{ - struct request_queue *q =3D bdev_get_queue(bdev); - - return (q && blk_queue_discard(q)); -} - /* * If discard_passdown was enabled verify that the destination device supp= orts * discards. Disable discard_passdown if not. @@ -2036,7 +2029,7 @@ static void disable_passdown_if_not_supported(struct = clone *clone) if (!test_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags)) return; =20 - if (!bdev_supports_discards(dest_dev)) + if (!bdev_max_discard_sectors(dest_dev)) reason =3D "discard unsupported"; else if (dest_limits->max_discard_sectors < clone->region_size) reason =3D "max discard sectors smaller than a region"; diff --git a/drivers/md/dm-log-writes.c b/drivers/md/dm-log-writes.c index c9d036d6bb2ee..e194226c89e54 100644 --- a/drivers/md/dm-log-writes.c +++ b/drivers/md/dm-log-writes.c @@ -866,9 +866,8 @@ static int log_writes_message(struct dm_target *ti, uns= igned argc, char **argv, static void log_writes_io_hints(struct dm_target *ti, struct queue_limits = *limits) { struct log_writes_c *lc =3D ti->private; - struct request_queue *q =3D bdev_get_queue(lc->dev->bdev); =20 - if (!q || !blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(lc->dev->bdev)) { lc->device_supports_discard =3D false; limits->discard_granularity =3D lc->sectorsize; limits->max_discard_sectors =3D (UINT_MAX >> SECTOR_SHIFT); diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c index 2b26435a6946e..9526ccbedafba 100644 --- a/drivers/md/dm-raid.c +++ b/drivers/md/dm-raid.c @@ -2963,13 +2963,8 @@ static void configure_discard_support(struct raid_se= t *rs) raid456 =3D rs_is_raid456(rs); =20 for (i =3D 0; i < rs->raid_disks; i++) { - struct request_queue *q; - - if (!rs->dev[i].rdev.bdev) - continue; - - q =3D bdev_get_queue(rs->dev[i].rdev.bdev); - if (!q || !blk_queue_discard(q)) + if (!rs->dev[i].rdev.bdev || + !bdev_max_discard_sectors(rs->dev[i].rdev.bdev)) return; =20 if (raid456) { diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c index d46839faa0ca5..0dff6907fd00d 100644 --- a/drivers/md/dm-table.c +++ b/drivers/md/dm-table.c @@ -1888,9 +1888,7 @@ static bool dm_table_supports_nowait(struct dm_table = *t) static int device_not_discard_capable(struct dm_target *ti, struct dm_dev = *dev, sector_t start, sector_t len, void *data) { - struct request_queue *q =3D bdev_get_queue(dev->bdev); - - return !blk_queue_discard(q); + return !bdev_max_discard_sectors(dev->bdev); } =20 static bool dm_table_supports_discards(struct dm_table *t) @@ -1970,15 +1968,12 @@ int dm_table_set_restrictions(struct dm_table *t, s= truct request_queue *q, blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, q); =20 if (!dm_table_supports_discards(t)) { - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); - /* Must also clear discard limits... */ q->limits.max_discard_sectors =3D 0; q->limits.max_hw_discard_sectors =3D 0; q->limits.discard_granularity =3D 0; q->limits.discard_alignment =3D 0; q->limits.discard_misaligned =3D 0; - } else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); + } =20 if (dm_table_supports_secure_erase(t)) blk_queue_flag_set(QUEUE_FLAG_SECERASE, q); diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c index 4d25d0e270313..eded4bcc4545f 100644 --- a/drivers/md/dm-thin.c +++ b/drivers/md/dm-thin.c @@ -2802,13 +2802,6 @@ static void requeue_bios(struct pool *pool) /*---------------------------------------------------------------- * Binding of control targets to a pool object *--------------------------------------------------------------*/ -static bool data_dev_supports_discard(struct pool_c *pt) -{ - struct request_queue *q =3D bdev_get_queue(pt->data_dev->bdev); - - return blk_queue_discard(q); -} - static bool is_factor(sector_t block_size, uint32_t n) { return !sector_div(block_size, n); @@ -2828,7 +2821,7 @@ static void disable_passdown_if_not_supported(struct = pool_c *pt) if (!pt->adjusted_pf.discard_passdown) return; =20 - if (!data_dev_supports_discard(pt)) + if (!bdev_max_discard_sectors(pt->data_dev->bdev)) reason =3D "discard unsupported"; =20 else if (data_limits->max_discard_sectors < pool->sectors_per_block) @@ -4057,8 +4050,6 @@ static void pool_io_hints(struct dm_target *ti, struc= t queue_limits *limits) /* * Must explicitly disallow stacking discard limits otherwise the * block layer will stack them if pool's data device has support. - * QUEUE_FLAG_DISCARD wouldn't be set but there is no way for the - * user to see that, so make sure to set all discard limits to 0. */ limits->discard_granularity =3D 0; return; diff --git a/drivers/md/dm.c b/drivers/md/dm.c index 3c5fad7c4ee68..dbbf64ce7e927 100644 --- a/drivers/md/dm.c +++ b/drivers/md/dm.c @@ -955,7 +955,6 @@ void disable_discard(struct mapped_device *md) =20 /* device doesn't really support DISCARD, disable it */ limits->max_discard_sectors =3D 0; - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, md->queue); } =20 void disable_write_zeroes(struct mapped_device *md) @@ -982,7 +981,7 @@ static void clone_endio(struct bio *bio) =20 if (unlikely(error =3D=3D BLK_STS_TARGET)) { if (bio_op(bio) =3D=3D REQ_OP_DISCARD && - !q->limits.max_discard_sectors) + !bdev_max_discard_sectors(bio->bi_bdev)) disable_discard(md); else if (bio_op(bio) =3D=3D REQ_OP_WRITE_ZEROES && !q->limits.max_write_zeroes_sectors) diff --git a/drivers/md/md-linear.c b/drivers/md/md-linear.c index 0f55b079371b1..138a3b25c5c82 100644 --- a/drivers/md/md-linear.c +++ b/drivers/md/md-linear.c @@ -64,7 +64,6 @@ static struct linear_conf *linear_conf(struct mddev *mdde= v, int raid_disks) struct linear_conf *conf; struct md_rdev *rdev; int i, cnt; - bool discard_supported =3D false; =20 conf =3D kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL); if (!conf) @@ -96,9 +95,6 @@ static struct linear_conf *linear_conf(struct mddev *mdde= v, int raid_disks) =20 conf->array_sectors +=3D rdev->sectors; cnt++; - - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported =3D true; } if (cnt !=3D raid_disks) { pr_warn("md/linear:%s: not enough drives present. Aborting!\n", @@ -106,11 +102,6 @@ static struct linear_conf *linear_conf(struct mddev *m= ddev, int raid_disks) goto out; } =20 - if (!discard_supported) - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); - else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); - /* * Here we calculate the device offsets. */ @@ -252,7 +243,7 @@ static bool linear_make_request(struct mddev *mddev, st= ruct bio *bio) start_sector + data_offset; =20 if (unlikely((bio_op(bio) =3D=3D REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) { + !bdev_max_discard_sectors(bio->bi_bdev))) { /* Just ignore it */ bio_endio(bio); } else { diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c index b21e101183f44..7231f5e1eaa73 100644 --- a/drivers/md/raid0.c +++ b/drivers/md/raid0.c @@ -399,7 +399,6 @@ static int raid0_run(struct mddev *mddev) conf =3D mddev->private; if (mddev->queue) { struct md_rdev *rdev; - bool discard_supported =3D false; =20 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors); blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors); @@ -412,13 +411,7 @@ static int raid0_run(struct mddev *mddev) rdev_for_each(rdev, mddev) { disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported =3D true; } - if (!discard_supported) - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); - else - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); } =20 /* calculate array device size */ diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index d81b896855f9f..3da749d150a17 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c @@ -802,7 +802,7 @@ static void flush_bio_list(struct r1conf *conf, struct = bio *bio) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) =3D=3D REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -1826,8 +1826,6 @@ static int raid1_add_disk(struct mddev *mddev, struct= md_rdev *rdev) break; } } - if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); print_conf(conf); return err; } @@ -3106,7 +3104,6 @@ static int raid1_run(struct mddev *mddev) int i; struct md_rdev *rdev; int ret; - bool discard_supported =3D false; =20 if (mddev->level !=3D 1) { pr_warn("md/raid1:%s: raid level not set to mirroring (%d)\n", @@ -3141,8 +3138,6 @@ static int raid1_run(struct mddev *mddev) continue; disk_stack_limits(mddev->gendisk, rdev->bdev, rdev->data_offset << 9); - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported =3D true; } =20 mddev->degraded =3D 0; @@ -3179,15 +3174,6 @@ static int raid1_run(struct mddev *mddev) =20 md_set_array_sectors(mddev, raid1_size(mddev, 0, 0)); =20 - if (mddev->queue) { - if (discard_supported) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); - } - ret =3D md_integrity_register(mddev); if (ret) { md_unregister_thread(&mddev->thread); diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c index 7816c8b2e8087..36a460015cf58 100644 --- a/drivers/md/raid10.c +++ b/drivers/md/raid10.c @@ -888,7 +888,7 @@ static void flush_pending_writes(struct r10conf *conf) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) =3D=3D REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -1083,7 +1083,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, boo= l from_schedule) if (test_bit(Faulty, &rdev->flags)) { bio_io_error(bio); } else if (unlikely((bio_op(bio) =3D=3D REQ_OP_DISCARD) && - !blk_queue_discard(bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors(bio->bi_bdev))) /* Just ignore it */ bio_endio(bio); else @@ -2144,8 +2144,6 @@ static int raid10_add_disk(struct mddev *mddev, struc= t md_rdev *rdev) rcu_assign_pointer(p->rdev, rdev); break; } - if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev))) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); =20 print_conf(conf); return err; @@ -4069,7 +4067,6 @@ static int raid10_run(struct mddev *mddev) sector_t size; sector_t min_offset_diff =3D 0; int first =3D 1; - bool discard_supported =3D false; =20 if (mddev_init_writes_pending(mddev) < 0) return -ENOMEM; @@ -4140,20 +4137,9 @@ static int raid10_run(struct mddev *mddev) rdev->data_offset << 9); =20 disk->head_position =3D 0; - - if (blk_queue_discard(bdev_get_queue(rdev->bdev))) - discard_supported =3D true; first =3D 0; } =20 - if (mddev->queue) { - if (discard_supported) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); - } /* need to check that every block has at least one working mirror */ if (!enough(conf, -1)) { pr_err("md/raid10:%s: not enough operational mirrors.\n", diff --git a/drivers/md/raid5-cache.c b/drivers/md/raid5-cache.c index a7d50ff9020a8..c3cbf9a574a39 100644 --- a/drivers/md/raid5-cache.c +++ b/drivers/md/raid5-cache.c @@ -1318,7 +1318,7 @@ static void r5l_write_super_and_discard_space(struct = r5l_log *log, =20 r5l_write_super(log, end); =20 - if (!blk_queue_discard(bdev_get_queue(bdev))) + if (!bdev_max_discard_sectors(bdev)) return; =20 mddev =3D log->rdev->mddev; diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c index 0bbae0e638666..59f91e392a2ae 100644 --- a/drivers/md/raid5.c +++ b/drivers/md/raid5.c @@ -7776,14 +7776,10 @@ static int raid5_run(struct mddev *mddev) * A better idea might be to turn DISCARD into WRITE_ZEROES * requests, as that is required to be safe. */ - if (devices_handle_discard_safely && - mddev->queue->limits.max_discard_sectors >=3D (stripe >> 9) && - mddev->queue->limits.discard_granularity >=3D stripe) - blk_queue_flag_set(QUEUE_FLAG_DISCARD, - mddev->queue); - else - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, - mddev->queue); + if (!devices_handle_discard_safely || + mddev->queue->limits.max_discard_sectors < (stripe >> 9) || + mddev->queue->limits.discard_granularity < stripe) + blk_queue_max_discard_sectors(mddev->queue, 0); =20 blk_queue_max_hw_sectors(mddev->queue, UINT_MAX); } diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c index c69b2d9df6f16..cac6315010a3d 100644 --- a/drivers/mmc/core/queue.c +++ b/drivers/mmc/core/queue.c @@ -183,7 +183,6 @@ static void mmc_queue_setup_discard(struct request_queu= e *q, if (!max_discard) return; =20 - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); blk_queue_max_discard_sectors(q, max_discard); q->limits.discard_granularity =3D card->pref_erase << 9; /* granularity must not be greater than max. discard */ diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c index 64d2b093f114b..f731721114655 100644 --- a/drivers/mtd/mtd_blkdevs.c +++ b/drivers/mtd/mtd_blkdevs.c @@ -377,7 +377,6 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new) blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq); =20 if (tr->discard) { - blk_queue_flag_set(QUEUE_FLAG_DISCARD, new->rq); blk_queue_max_discard_sectors(new->rq, UINT_MAX); new->rq->limits.discard_granularity =3D tr->blksize; } diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index efb85c6d8e2d5..7e07dd69262a7 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -1607,10 +1607,8 @@ static void nvme_config_discard(struct gendisk *disk= , struct nvme_ns *ns) struct request_queue *queue =3D disk->queue; u32 size =3D queue_logical_block_size(queue); =20 - if (ctrl->max_discard_sectors =3D=3D 0) { - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, queue); + if (ctrl->max_discard_sectors =3D=3D 0) return; - } =20 BUILD_BUG_ON(PAGE_SIZE / sizeof(struct nvme_dsm_range) < NVME_DSM_MAX_RANGES); @@ -1619,7 +1617,7 @@ static void nvme_config_discard(struct gendisk *disk,= struct nvme_ns *ns) queue->limits.discard_granularity =3D size; =20 /* If discard is already enabled, don't reset queue limits */ - if (blk_queue_flag_test_and_set(QUEUE_FLAG_DISCARD, queue)) + if (queue->limits.max_discard_sectors) return; =20 blk_queue_max_discard_sectors(queue, ctrl->max_discard_sectors); diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c index e084f4deddddd..8bd5665db9198 100644 --- a/drivers/s390/block/dasd_fba.c +++ b/drivers/s390/block/dasd_fba.c @@ -791,7 +791,6 @@ static void dasd_fba_setup_blk_queue(struct dasd_block = *block) =20 blk_queue_max_discard_sectors(q, max_discard_sectors); blk_queue_max_write_zeroes_sectors(q, max_discard_sectors); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } =20 static int dasd_fba_pe_handler(struct dasd_device *device, diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index a390679cf4584..444479657b7fd 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -797,7 +797,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, u= nsigned int mode) case SD_LBP_FULL: case SD_LBP_DISABLE: blk_queue_max_discard_sectors(q, 0); - blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q); return; =20 case SD_LBP_UNMAP: @@ -830,7 +829,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, u= nsigned int mode) } =20 blk_queue_max_discard_sectors(q, max_blocks * (logical_block_size >> 9)); - blk_queue_flag_set(QUEUE_FLAG_DISCARD, q); } =20 static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd) diff --git a/drivers/target/target_core_device.c b/drivers/target/target_co= re_device.c index c3e25bac90d59..6cb9f87843278 100644 --- a/drivers/target/target_core_device.c +++ b/drivers/target/target_core_device.c @@ -838,7 +838,7 @@ bool target_configure_unmap_from_queue(struct se_dev_at= trib *attrib, struct request_queue *q =3D bdev_get_queue(bdev); int block_size =3D bdev_logical_block_size(bdev); =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(bdev)) return false; =20 attrib->max_unmap_lba_count =3D diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index f477035a2ac23..efd8deb3ab7e8 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c @@ -1291,7 +1291,7 @@ static int do_discard_extent(struct btrfs_io_stripe *= stripe, u64 *bytes) ret =3D btrfs_reset_device_zone(dev_replace->tgtdev, phys, len, &discarded); discarded +=3D src_disc; - } else if (blk_queue_discard(bdev_get_queue(stripe->dev->bdev))) { + } else if (bdev_max_discard_sectors(stripe->dev->bdev)) { ret =3D btrfs_issue_discard(dev->bdev, phys, len, &discarded); } else { ret =3D 0; @@ -5987,7 +5987,7 @@ static int btrfs_trim_free_extents(struct btrfs_devic= e *device, u64 *trimmed) *trimmed =3D 0; =20 /* Discard not supported =3D nothing to do. */ - if (!blk_queue_discard(bdev_get_queue(device->bdev))) + if (!bdev_max_discard_sectors(device->bdev)) return 0; =20 /* Not writable =3D nothing to do. */ diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index f46e71061942d..096bb0da03f1c 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c @@ -501,7 +501,7 @@ static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_= info *fs_info, if (!device->bdev) continue; q =3D bdev_get_queue(device->bdev); - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(device->bdev)) { num_devices++; minlen =3D min_t(u64, q->limits.discard_granularity, minlen); diff --git a/fs/exfat/file.c b/fs/exfat/file.c index 2f51300592366..765e4f63dd18d 100644 --- a/fs/exfat/file.c +++ b/fs/exfat/file.c @@ -358,7 +358,7 @@ static int exfat_ioctl_fitrim(struct inode *inode, unsi= gned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(inode->i_sb->s_bdev)) return -EOPNOTSUPP; =20 if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(rang= e))) diff --git a/fs/exfat/super.c b/fs/exfat/super.c index 8ca21e7917d16..be0788ecaf20e 100644 --- a/fs/exfat/super.c +++ b/fs/exfat/super.c @@ -627,13 +627,9 @@ static int exfat_fill_super(struct super_block *sb, st= ruct fs_context *fc) if (opts->allow_utime =3D=3D (unsigned short)-1) opts->allow_utime =3D ~opts->fs_dmask & 0022; =20 - if (opts->discard) { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); - - if (!blk_queue_discard(q)) { - exfat_warn(sb, "mounting with \"discard\" option, but the device does n= ot support discard"); - opts->discard =3D 0; - } + if (opts->discard && !bdev_max_discard_sectors(sb->s_bdev)) { + exfat_warn(sb, "mounting with \"discard\" option, but the device does no= t support discard"); + opts->discard =3D 0; } =20 sb->s_flags |=3D SB_NODIRATIME; diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c index 992229ca2d830..6e3b9eea126f4 100644 --- a/fs/ext4/ioctl.c +++ b/fs/ext4/ioctl.c @@ -1044,7 +1044,6 @@ static int ext4_ioctl_checkpoint(struct file *filp, u= nsigned long arg) __u32 flags =3D 0; unsigned int flush_flags =3D 0; struct super_block *sb =3D file_inode(filp)->i_sb; - struct request_queue *q; =20 if (copy_from_user(&flags, (__u32 __user *)arg, sizeof(__u32))) @@ -1065,10 +1064,8 @@ static int ext4_ioctl_checkpoint(struct file *filp, = unsigned long arg) if (flags & ~EXT4_IOC_CHECKPOINT_FLAG_VALID) return -EINVAL; =20 - q =3D bdev_get_queue(EXT4_SB(sb)->s_journal->j_dev); - if (!q) - return -ENXIO; - if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) + if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && + !bdev_max_discard_sectors(EXT4_SB(sb)->s_journal->j_dev)) return -EOPNOTSUPP; =20 if (flags & EXT4_IOC_CHECKPOINT_FLAG_DRY_RUN) @@ -1393,14 +1390,13 @@ static long __ext4_ioctl(struct file *filp, unsigne= d int cmd, unsigned long arg) =20 case FITRIM: { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); struct fstrim_range range; int ret =3D 0; =20 if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; =20 /* diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 81749eaddf4c1..93f4e4e9e2631 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -5458,13 +5458,9 @@ static int __ext4_fill_super(struct fs_context *fc, = struct super_block *sb) goto failed_mount9; } =20 - if (test_opt(sb, DISCARD)) { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); - if (!blk_queue_discard(q)) - ext4_msg(sb, KERN_WARNING, - "mounting with \"discard\" option, but " - "the device does not support discard"); - } + if (test_opt(sb, DISCARD) && !bdev_max_discard_sectors(sb->s_bdev)) + ext4_msg(sb, KERN_WARNING, + "mounting with \"discard\" option, but the device does not support dis= card"); =20 if (es->s_error_count) mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */ diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index cd1e65bcf0b04..0ea9a5fa7c1dd 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4381,8 +4381,7 @@ static inline bool f2fs_hw_should_discard(struct f2fs= _sb_info *sbi) =20 static inline bool f2fs_bdev_support_discard(struct block_device *bdev) { - return blk_queue_discard(bdev_get_queue(bdev)) || - bdev_is_zoned(bdev); + return bdev_max_discard_sectors(bdev) || bdev_is_zoned(bdev); } =20 static inline bool f2fs_hw_support_discard(struct f2fs_sb_info *sbi) diff --git a/fs/fat/file.c b/fs/fat/file.c index a5a309fcc7faf..e4c7d10e80129 100644 --- a/fs/fat/file.c +++ b/fs/fat/file.c @@ -133,7 +133,7 @@ static int fat_ioctl_fitrim(struct inode *inode, unsign= ed long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; =20 user_range =3D (struct fstrim_range __user *)arg; diff --git a/fs/fat/inode.c b/fs/fat/inode.c index bf6051bdf1d1d..3d1afb95a925a 100644 --- a/fs/fat/inode.c +++ b/fs/fat/inode.c @@ -1872,13 +1872,9 @@ int fat_fill_super(struct super_block *sb, void *dat= a, int silent, int isvfat, goto out_fail; } =20 - if (sbi->options.discard) { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); - if (!blk_queue_discard(q)) - fat_msg(sb, KERN_WARNING, - "mounting with \"discard\" option, but " - "the device does not support discard"); - } + if (sbi->options.discard && !bdev_max_discard_sectors(sb->s_bdev)) + fat_msg(sb, KERN_WARNING, + "mounting with \"discard\" option, but the device does not support disc= ard"); =20 fat_set_state(sb, 1, 0); return 0; diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c index 801ad9f4f2bef..7f20ac9133bc6 100644 --- a/fs/gfs2/rgrp.c +++ b/fs/gfs2/rgrp.c @@ -1405,7 +1405,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp) if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) return -EROFS; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sdp->sd_vfs->s_bdev)) return -EOPNOTSUPP; =20 if (copy_from_user(&r, argp, sizeof(r))) diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c index fcacafa4510d1..19d226cd4ff4d 100644 --- a/fs/jbd2/journal.c +++ b/fs/jbd2/journal.c @@ -1762,7 +1762,6 @@ static int __jbd2_journal_erase(journal_t *journal, u= nsigned int flags) unsigned long block, log_offset; /* logical */ unsigned long long phys_block, block_start, block_stop; /* physical */ loff_t byte_start, byte_stop, byte_count; - struct request_queue *q =3D bdev_get_queue(journal->j_dev); =20 /* flags must be set to either discard or zeroout */ if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags || @@ -1770,10 +1769,8 @@ static int __jbd2_journal_erase(journal_t *journal, = unsigned int flags) (flags & JBD2_JOURNAL_FLUSH_ZEROOUT))) return -EINVAL; =20 - if (!q) - return -ENXIO; - - if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && !blk_queue_discard(q)) + if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && + !bdev_max_discard_sectors(journal->j_dev)) return -EOPNOTSUPP; =20 /* diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c index 03a845ab4f009..357ae6e5c36ec 100644 --- a/fs/jfs/ioctl.c +++ b/fs/jfs/ioctl.c @@ -117,7 +117,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, uns= igned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) { + if (!bdev_max_discard_sectors(sb->s_bdev)) { jfs_warn("FITRIM not supported on device"); return -EOPNOTSUPP; } diff --git a/fs/jfs/super.c b/fs/jfs/super.c index f1a13a74cddf3..85d4f44f2ac4d 100644 --- a/fs/jfs/super.c +++ b/fs/jfs/super.c @@ -372,19 +372,16 @@ static int parse_options(char *options, struct super_= block *sb, s64 *newLVSize, } =20 case Opt_discard: - { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); /* if set to 1, even copying files will cause * trimming :O * -> user has more control over the online trimming */ sbi->minblks_trim =3D 64; - if (blk_queue_discard(q)) + if (bdev_max_discard_sectors(sb->s_bdev)) *flag |=3D JFS_DISCARD; else pr_err("JFS: discard option not supported on device\n"); break; - } =20 case Opt_nodiscard: *flag &=3D ~JFS_DISCARD; @@ -392,10 +389,9 @@ static int parse_options(char *options, struct super_b= lock *sb, s64 *newLVSize, =20 case Opt_discard_minblk: { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); char *minblks_trim =3D args[0].from; int rc; - if (blk_queue_discard(q)) { + if (bdev_max_discard_sectors(sb->s_bdev)) { *flag |=3D JFS_DISCARD; rc =3D kstrtouint(minblks_trim, 0, &sbi->minblks_trim); diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c index fec194a666f4b..52b73f558fcb1 100644 --- a/fs/nilfs2/ioctl.c +++ b/fs/nilfs2/ioctl.c @@ -1059,7 +1059,7 @@ static int nilfs_ioctl_trim_fs(struct inode *inode, v= oid __user *argp) if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(nilfs->ns_bdev)) return -EOPNOTSUPP; =20 if (copy_from_user(&range, argp, sizeof(range))) diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c index 787b53b984ee1..e763236169331 100644 --- a/fs/ntfs3/file.c +++ b/fs/ntfs3/file.c @@ -28,7 +28,7 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, un= signed long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sbi->sb->s_bdev)) return -EOPNOTSUPP; =20 user_range =3D (struct fstrim_range __user *)arg; diff --git a/fs/ntfs3/super.c b/fs/ntfs3/super.c index cd30e81abbce0..c734085bcce4a 100644 --- a/fs/ntfs3/super.c +++ b/fs/ntfs3/super.c @@ -913,7 +913,7 @@ static int ntfs_fill_super(struct super_block *sb, stru= ct fs_context *fc) } =20 rq =3D bdev_get_queue(bdev); - if (blk_queue_discard(rq) && rq->limits.discard_granularity) { + if (bdev_max_discard_sectors(bdev) && rq->limits.discard_granularity) { sbi->discard_granularity =3D rq->limits.discard_granularity; sbi->discard_granularity_mask_inv =3D ~(u64)(sbi->discard_granularity - 1); diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c index f59461d85da45..9b78ef103ada6 100644 --- a/fs/ocfs2/ioctl.c +++ b/fs/ocfs2/ioctl.c @@ -910,7 +910,7 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, u= nsigned long arg) if (!capable(CAP_SYS_ADMIN)) return -EPERM; =20 - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(sb->s_bdev)) return -EOPNOTSUPP; =20 if (copy_from_user(&range, argp, sizeof(range))) diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c index 0191de8ce9ced..a4e6609d616b7 100644 --- a/fs/xfs/xfs_discard.c +++ b/fs/xfs/xfs_discard.c @@ -162,7 +162,7 @@ xfs_ioc_trim( =20 if (!capable(CAP_SYS_ADMIN)) return -EPERM; - if (!blk_queue_discard(q)) + if (!bdev_max_discard_sectors(mp->m_ddev_targp->bt_bdev)) return -EOPNOTSUPP; =20 /* diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c index 54be9d64093ed..a276b8111f636 100644 --- a/fs/xfs/xfs_super.c +++ b/fs/xfs/xfs_super.c @@ -1608,14 +1608,10 @@ xfs_fs_fill_super( goto out_filestream_unmount; } =20 - if (xfs_has_discard(mp)) { - struct request_queue *q =3D bdev_get_queue(sb->s_bdev); - - if (!blk_queue_discard(q)) { - xfs_warn(mp, "mounting with \"discard\" option, but " - "the device does not support discard"); - mp->m_features &=3D ~XFS_FEAT_DISCARD; - } + if (xfs_has_discard(mp) && !bdev_max_discard_sectors(sb->s_bdev)) { + xfs_warn(mp, + "mounting with \"discard\" option, but the device does not support discar= d"); + mp->m_features &=3D ~XFS_FEAT_DISCARD; } =20 if (xfs_has_reflink(mp)) { diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index ce16247d3afab..767ab22e1052a 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -540,7 +540,6 @@ struct request_queue { #define QUEUE_FLAG_NONROT 6 /* non-rotational device (SSD) */ #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */ #define QUEUE_FLAG_IO_STAT 7 /* do disk/partitions IO accounting */ -#define QUEUE_FLAG_DISCARD 8 /* supports DISCARD */ #define QUEUE_FLAG_NOXMERGES 9 /* No extended merges */ #define QUEUE_FLAG_ADD_RANDOM 10 /* Contributes to random pool */ #define QUEUE_FLAG_SECERASE 11 /* supports secure erase */ @@ -582,7 +581,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, str= uct request_queue *q); test_bit(QUEUE_FLAG_STABLE_WRITES, &(q)->queue_flags) #define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flag= s) #define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queu= e_flags) -#define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flag= s) #define blk_queue_zone_resetall(q) \ test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags) #define blk_queue_secure_erase(q) \ diff --git a/mm/swapfile.c b/mm/swapfile.c index 4069f17a82c8e..5d9cedf9e7b84 100644 --- a/mm/swapfile.c +++ b/mm/swapfile.c @@ -2957,20 +2957,6 @@ static int setup_swap_map_and_extents(struct swap_in= fo_struct *p, return nr_extents; } =20 -/* - * Helper to sys_swapon determining if a given swap - * backing device queue supports DISCARD operations. - */ -static bool swap_discardable(struct swap_info_struct *si) -{ - struct request_queue *q =3D bdev_get_queue(si->bdev); - - if (!blk_queue_discard(q)) - return false; - - return true; -} - SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) { struct swap_info_struct *p; @@ -3132,7 +3118,8 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialf= ile, int, swap_flags) sizeof(long), GFP_KERNEL); =20 - if (p->bdev && (swap_flags & SWAP_FLAG_DISCARD) && swap_discardable(p)) { + if ((swap_flags & SWAP_FLAG_DISCARD) && + p->bdev && bdev_max_discard_sectors(p->bdev)) { /* * When discard is enabled for swap with no particular * policy flagged, we set all swap discard flags here in --=20 2.30.2