From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id EF1CEC43381 for ; Thu, 28 Mar 2019 13:37:24 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 94BC6206BA for ; Thu, 28 Mar 2019 13:37:24 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=garyguo.net header.i=@garyguo.net header.b="I71HNaXK" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727213AbfC1NhX (ORCPT ); Thu, 28 Mar 2019 09:37:23 -0400 Received: from mail-eopbgr110133.outbound.protection.outlook.com ([40.107.11.133]:51954 "EHLO GBR01-CWL-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726357AbfC1NhX (ORCPT ); Thu, 28 Mar 2019 09:37:23 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=garyguo.net; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=C7qlUqRiywDE6RVGWOfx0UfR91vGOeIr4hwZctX2G3g=; b=I71HNaXKkZcG6ss84jeLxhrb4yMVEx81PFXd0f+1QUEYYJlSJrnPy+8yyTu4itNGJOhvS20Tz0WdJrklT6eNbTt4WnrxFFhazT+04hVPU8idKXXeX1my363t6VKv1dBdtvnkq1QESlS2p2bCrB/3aglqGpww38pK9I1Cv2AMz/0= Received: from LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM (20.176.139.20) by LO2P265MB0990.GBRP265.PROD.OUTLOOK.COM (20.176.140.18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1730.18; Thu, 28 Mar 2019 13:37:15 +0000 Received: from LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM ([fe80::ed34:1290:4306:3157]) by LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM ([fe80::ed34:1290:4306:3157%3]) with mapi id 15.20.1750.017; Thu, 28 Mar 2019 13:37:15 +0000 From: Gary Guo To: Anup Patel CC: Palmer Dabbelt , Albert Ou , Atish Patra , Paul Walmsley , Christoph Hellwig , Mike Rapoport , "linux-riscv@lists.infradead.org" , "linux-kernel@vger.kernel.org" Subject: Re: [PATCH v2] RISC-V: Implement ASID allocator Thread-Topic: [PATCH v2] RISC-V: Implement ASID allocator Thread-Index: AQHU5TAIKaRDCttA7UazIjpcDaomMKYhDFQA Date: Thu, 28 Mar 2019 13:37:15 +0000 Message-ID: References: <20190328063211.13052-1-anup.patel@wdc.com> In-Reply-To: <20190328063211.13052-1-anup.patel@wdc.com> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: LO2P123CA0013.GBRP123.PROD.OUTLOOK.COM (2603:10a6:600:a6::25) To LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:8c::20) authentication-results: spf=none (sender IP is ) smtp.mailfrom=gary@garyguo.net; x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [2001:630:212:238:3697:f6ff:fe55:55b1] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: d25f576f-fd08-49cc-ec98-08d6b3827d76 x-microsoft-antispam: BCL:0;PCL:0;RULEID:(2390118)(7020095)(4652040)(7021145)(8989299)(4534185)(7022145)(4603075)(4627221)(201702281549075)(8990200)(7048125)(7024125)(7027125)(7023125)(5600127)(711020)(4605104)(2017052603328)(7153060)(7193020);SRVR:LO2P265MB0990; x-ms-traffictypediagnostic: LO2P265MB0990: x-ms-exchange-purlcount: 1 x-microsoft-antispam-prvs: x-forefront-prvs: 0990C54589 x-forefront-antispam-report: SFV:NSPM;SFS:(10019020)(346002)(396003)(366004)(136003)(39830400003)(376002)(55674003)(199004)(189003)(30864003)(476003)(71190400001)(2616005)(6512007)(316002)(71200400001)(76176011)(31686004)(6116002)(31696002)(53946003)(386003)(6916009)(46003)(54906003)(86362001)(53546011)(6506007)(14444005)(8936002)(6246003)(446003)(53936002)(256004)(486006)(11346002)(68736007)(102836004)(229853002)(6436002)(5660300002)(99286004)(2906002)(6486002)(97736004)(52116002)(966005)(508600001)(106356001)(81156014)(7736002)(8676002)(81166006)(186003)(25786009)(105586002)(36756003)(6306002)(305945005)(4326008)(14454004);DIR:OUT;SFP:1102;SCL:1;SRVR:LO2P265MB0990;H:LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; received-spf: None (protection.outlook.com: garyguo.net does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: ADdFbD/bSOLZJz5GOxvFIk9atBvjzs6uh2PZR3niAi1u3yLazovHUUV6zfTVSqlvphhEjdBNQntqeeWV1Cbu92yxeWOgWEHgdwp+Im/E9C6FehXQGz+ATfCUOKcTFrXAC49FXAZSWBsKU0YRobLR8++PrbrF3WRtS19bI+QGSxhgcMkOPu6aZ5csuLova6MZIFSRsh8xLuGG0u0bDH8X9lEw1t5bPrhQfFxGHkxygUtZZEn8/whz91CfKnosfYDvbCO7Kw6VOcT4/JW//SvOXrTGfpPPEGXTdTWNwJ9Vs7rmjTmSxQF7xIUFmcQ72RdxWKPRg+rmy5IqJ9IRS72tZhfBwKZ9GlAyTYrIVFiTHqVIQPTrwyvrUFp9PaGDRXCTeB4DauuuV0l+RRw/lHYfI+zBUXOkgVIrCUXOe2yAOtU= Content-Type: text/plain; charset="utf-8" Content-ID: Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-OriginatorOrg: garyguo.net X-MS-Exchange-CrossTenant-Network-Message-Id: d25f576f-fd08-49cc-ec98-08d6b3827d76 X-MS-Exchange-CrossTenant-originalarrivaltime: 28 Mar 2019 13:37:15.3381 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: bbc898ad-b10f-4e10-8552-d9377b823d45 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-Transport-CrossTenantHeadersStamped: LO2P265MB0990 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org SGkgQW51cCwNCg0KVGhlIGNvZGUgc3RpbGwgZG9lcyBub3QgdXNlIEFTSUQgaW4gVExCIGZsdXNo IHJvdXRpbmVzLiBXaXRob3V0IHRoaXMgDQphZGRlZCB0aGUgY29kZSBkb2VzIG5vdCBib290IG9u IHN5c3RlbXMgd2l0aCB0cnVlIEFTSUQgc3VwcG9ydC4NCg0KV2UgYWxzbyBuZWVkIHRvIGNvbnNp ZGVyIHRoZSBjYXNlIG9mIENPTlRFWFRJRCBvdmVyZmxvdyBvbiAzMi1iaXQgDQpzeXN0ZW1zLiAz Mi1iaXQgQ09OVEVYVElEIG1heSBvdmVyZmxvdyBpbiBhIG1vbnRoIHRpbWUuDQoNClBsZWFzZSBh bGwgc2VlIG15IGlubGluZSBjb21tZW50cy4NCg0KQmVzdCwNCkdhcnkNCg0KT24gMjgvMDMvMjAx OSAwNjozMiwgQW51cCBQYXRlbCB3cm90ZToNCj4gQ3VycmVudGx5LCB3ZSBkbyBsb2NhbCBUTEIg Zmx1c2ggb24gZXZlcnkgTU0gc3dpdGNoLiBUaGlzIGlzIHZlcnkgaGFyc2gNCj4gb24gcGVyZm9y bWFuY2UgYmVjYXVzZSB3ZSBhcmUgZm9yY2luZyBwYWdlIHRhYmxlIHdhbGtzIGFmdGVyIGV2ZXJ5 IE1NDQo+IHN3aXRjaC4NCj4gDQo+IFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBBU0lEIGFsbG9jYXRv ciBmb3IgYXNzaWduaW5nIGFuIEFTSUQgdG8gZXZlcnkgTU0NCj4gY29udGV4dC4gVGhlIG51bWJl ciBvZiBBU0lEcyBhcmUgbGltaXRlZCBpbiBIVyBzbyB3ZSBjcmVhdGUgYSBsb2dpY2FsDQo+IGVu dGl0eSBuYW1lZCBDT05URVhUSUQgZm9yIGFzc2lnbmluZyB0byBNTSBjb250ZXh0LiBUaGUgbG93 ZXIgYml0cyBvZg0KPiBDT05URVhUSUQgYXJlIEFTSUQgYW5kIHVwcGVyIGJpdHMgYXJlIFZFUlNJ T04gbnVtYmVyLiBUaGUgbnVtYmVyIG9mDQo+IHVzYWJsZSBBU0lEIGJpdHMgc3VwcG9ydGVkIGJ5 IEhXIGFyZSBkZXRlY3RlZCBhdCBib290LXRpbWUgYnkgd3JpdGluZw0KPiAxcyB0byBBU0lEIGJp dHMgaW4gU0FUUCBDU1IuIFRoaXMgbWVhbnMgbGFzdCBBU0lEIGlzIGFsd2F5cyByZXNlcnZlZA0K PiBiZWNhdXNlIGl0IGlzIHVzZWQgZm9yIGluaXRpYWwgTU0gY29udGV4dC4NCj4gDQo+IFdlIGFs bG9jYXRlIG5ldyBDT05URVhUSUQgb24gZmlyc3QgTU0gc3dpdGNoIGZvciBhIE1NIGNvbnRleHQg d2hlcmUNCj4gdGhlIEFTSUQgaXMgYWxsb2NhdGVkIGZyb20gYW4gQVNJRCBiaXRtYXAgYW5kIFZF UlNJT04gaXMgcHJvdmlkZSBieQ0KPiBhbiBhdG9taWMgY291bnRlci4gQXQgdGltZSBvZiBhbGxv Y2F0aW5nIG5ldyBDT05URVhUSUQsIGlmIHdlIHJ1biBvdXQNCj4gb2YgYXZhaWxhYmxlIEFTSURz IHRoZW46DQo+IDEuIFdlIGZsdXNoIHRoZSBBU0lEIGJpdG1hcA0KPiAyLiBJbmNyZW1lbnQgY3Vy cmVudCBWRVJTSU9OIGF0b21pYyBjb3VudGVyDQo+IDMuIFJlLWFsbG9jYXRlIEFTSUQgZnJvbSBB U0lEIGJpdG1hcA0KPiA0LiBGbHVzaCBUTEIgb24gYWxsIENQVXMNCj4gNS4gVHJ5IENPTlRFWFRJ RCByZS1hc3NpZ25tZW50IG9uIGFsbCBDUFVzDQo+IA0KPiBVc2luZyBhYm92ZSBhcHByb2FjaCwg d2UgaGF2ZSB2aXJ0dWFsbHkgaW5maW5pdGUgQ09OVEVYVElEcyBvbi10b3Atb2YNCj4gbGltaXRl ZCBudW1iZXIgb2YgSFcgQVNJRHMuIFRoaXMgYXBwcm9hY2ggaXMgaW5zcGlyZWQgZnJvbSBBU0lE IGFsbG9jYXRvcg0KPiB1c2VkIGZvciBMaW51eCBBUk0vQVJNNjQgYnV0IHdlIGhhdmUgYWRhcHRl ZCBpdCBmb3IgUklTQy1WLiBPdmVyYWxsLA0KPiB0aGlzIEFTSUQgYWxsb2NhdG9yIGhlbHBzIHVz IHJlZHVjZSByYXRlIG9mIGxvY2FsIFRMQiBmbHVzaGVzIG9uIGV2ZXJ5DQo+IENQVSB0aGVyZWJ5 IGluY3JlYXNpbmcgcGVyZm9ybWFuY2UuDQo+IA0KPiBUaGlzIHBhdGNoIGlzIHRlc3RlZCBvbiBR RU1VL3ZpcnQgbWFjaGluZSBhbmQgU2lGaXZlIFVubGVhc2hlZCBib2FyZC4NCj4gT24gUUVNVS92 aXJ0IG1hY2hpbmUsIHdlIHNlZSAxMCUgKGFwcHJveCkgcGVyZm9ybWFuY2UgaW1wcm92ZW1lbnQg d2l0aA0KPiBTVyBlbXVsYXRlZCBUTEJzIHByb3ZpZGVkIGJ5IFFFTVUuIFVuZm9ydHVuYXRlbHks IEFTSUQgYml0cyBvZiBTQVRQIENTUg0KPiBhcmUgbm90IGltcGxlbWVudGVkIG9uIFNpRml2ZSBV bmxlYXNoZWQgYm9hcmQgc28gd2UgZG9uJ3Qgc2VlIGFueSBjaGFuZ2UNCj4gaW4gcGVyZm9ybWFu Y2UuDQo+IA0KPiBTaWduZWQtb2ZmLWJ5OiBHYXJ5IEd1byA8Z2FyeUBnYXJ5Z3VvLm5ldD4NCkNv dWxkIHlvdSBhZGQgYSBDby1kZXZlbG9wZWQtYnkgbGluZSBpbiBhZGRpdGlvbiB0byBTaWduZWQt b2ZmLWJ5IGFzIA0Kd2VsbD8gVGhhbmtzLg0KPiBTaWduZWQtb2ZmLWJ5OiBBbnVwIFBhdGVsIDxh bnVwLnBhdGVsQHdkYy5jb20+DQo+IC0tLQ0KPiBDaGFuZ2VzIHNpbmNlIHYxOg0KPiAtIFdlIGFk YXB0IGdvb2QgYXNwZWN0cyBmcm9tIEdhcnkgR3VvJ3MgQVNJRCBhbGxvY2F0b3IgaW1wbGVtZW50 YXRpb24NCj4gICAgYW5kIHByb3ZpZGUgZHVlIGNyZWRpdCB0byBoaW0gYnkgYWRkaW5nIGhpcyBT b0IuDQo+IC0gVHJhY2sgQVNJRHMgYWN0aXZlIGR1cmluZyBjb250ZXh0IGZsdXNoIGFuZCBtYXJr IHRoZW0gYXMgcmVzZXJ2ZWQNCj4gLSBTZXQgQVNJRCBiaXRzIHRvIGFsbCAxcyB0byBzaW1wbGlm eSBudW1iZXIgb2YgQVNJRCBiaXQgZGV0ZWN0aW9uDQo+IC0gVXNlIGF0b21pY19sb25nX3QgaW5z dGVhZCBvZiBhdG9taWM2NF90IGZvciBiZWluZyAzMmJpdCBmcmllbmRseQ0KPiAtIFVzZSB1bnNp Z25lZCBsb25nIGluc3RlYWQgb2YgdTY0IGZvciBiZWluZyAzMmJpdCBmcmllbmRseQ0KPiAtIFVz ZSBmbHVzaF90bGJfYWxsKCkgaW5zdGVhZCBvZiBsYXp5IGxvY2FsX3RsYl9mbHVzaF9hbGwoKSBh dCB0aW1lDQo+ICAgIG9mIGNvbnRleHQgZmx1c2gNCj4gDQo+IFRoaXMgcGF0Y2ggaXMgYmFzZWQg b24gTGludXgtNS4xLXJjMiBhbmQgVExCIGZsdXNoIGNsZWFudXAgcGF0Y2hlcyB2NA0KPiBmcm9t IEdhcnkgR3VvLiBJdCBjYW4gYmUgYWxzbyBmb3VuZCBpbiByaXNjdl9hc2lkX2FsbG9jYXRvcl92 MiBicmFuY2gNCj4gb2YgaHR0cHM6Ly9naXRodWIuY29tL2F2cGF0ZWwvbGludXguZ2l0DQo+IC0t LQ0KPiAgIGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vY3NyLmggICAgICAgICB8ICAgNiArDQo+ICAg YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9tbXUuaCAgICAgICAgIHwgICAxICsNCj4gICBhcmNoL3Jp c2N2L2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmggfCAgIDEgKw0KPiAgIGFyY2gvcmlzY3Yva2Vy bmVsL2hlYWQuUyAgICAgICAgICAgICB8ICAgMiArDQo+ICAgYXJjaC9yaXNjdi9tbS9jb250ZXh0 LmMgICAgICAgICAgICAgIHwgMjQ5ICsrKysrKysrKysrKysrKysrKysrKysrKystLQ0KPiAgIDUg ZmlsZXMgY2hhbmdlZCwgMjQ3IGluc2VydGlvbnMoKyksIDEyIGRlbGV0aW9ucygtKQ0KPiANCj4g ZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vY3NyLmggYi9hcmNoL3Jpc2N2L2lu Y2x1ZGUvYXNtL2Nzci5oDQo+IGluZGV4IDI4YTBkMWNiMzc0Yy4uY2UxOGFiOGY1M2VkIDEwMDY0 NA0KPiAtLS0gYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2Nzci5oDQo+ICsrKyBiL2FyY2gvcmlz Y3YvaW5jbHVkZS9hc20vY3NyLmgNCj4gQEAgLTQ1LDEwICs0NSwxNiBAQA0KPiAgICNkZWZpbmUg U0FUUF9QUE4gICAgIF9BQygweDAwM0ZGRkZGLCBVTCkNCj4gICAjZGVmaW5lIFNBVFBfTU9ERV8z MiBfQUMoMHg4MDAwMDAwMCwgVUwpDQo+ICAgI2RlZmluZSBTQVRQX01PREUgICAgU0FUUF9NT0RF XzMyDQo+ICsjZGVmaW5lIFNBVFBfQVNJRF9CSVRTCTkNCj4gKyNkZWZpbmUgU0FUUF9BU0lEX1NI SUZUCTIyDQo+ICsjZGVmaW5lIFNBVFBfQVNJRF9NQVNLCV9BQygweDFGRiwgVUwpDQo+ICAgI2Vs c2UNCj4gICAjZGVmaW5lIFNBVFBfUFBOICAgICBfQUMoMHgwMDAwMEZGRkZGRkZGRkZGLCBVTCkN Cj4gICAjZGVmaW5lIFNBVFBfTU9ERV8zOSBfQUMoMHg4MDAwMDAwMDAwMDAwMDAwLCBVTCkNCj4g ICAjZGVmaW5lIFNBVFBfTU9ERSAgICBTQVRQX01PREVfMzkNCj4gKyNkZWZpbmUgU0FUUF9BU0lE X0JJVFMJMTYNCj4gKyNkZWZpbmUgU0FUUF9BU0lEX1NISUZUCTQ0DQo+ICsjZGVmaW5lIFNBVFBf QVNJRF9NQVNLCV9BQygweEZGRkYsIFVMKQ0KPiAgICNlbmRpZg0KPiAgIA0KPiAgIC8qIEludGVy cnVwdCBFbmFibGUgYW5kIEludGVycnVwdCBQZW5kaW5nIGZsYWdzICovDQo+IGRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL21tdS5oIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9t bXUuaA0KPiBpbmRleCA1ZGYyZGNjZGJhMTIuLjQyYTljYTBmZTFmYiAxMDA2NDQNCj4gLS0tIGEv YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9tbXUuaA0KPiArKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUv YXNtL21tdS5oDQo+IEBAIC0xOCw2ICsxOCw3IEBADQo+ICAgI2lmbmRlZiBfX0FTU0VNQkxZX18N Cj4gICANCj4gICB0eXBlZGVmIHN0cnVjdCB7DQo+ICsJYXRvbWljX2xvbmdfdCBpZDsNCj4gICAJ dm9pZCAqdmRzbzsNCj4gICAjaWZkZWYgQ09ORklHX1NNUA0KPiAgIAkvKiBBIGxvY2FsIGljYWNo ZSBmbHVzaCBpcyBuZWVkZWQgYmVmb3JlIHVzZXIgZXhlY3V0aW9uIGNhbiByZXN1bWUuICovDQo+ IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmggYi9hcmNo L3Jpc2N2L2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmgNCj4gaW5kZXggYmY0ZjA5N2E5MDUxLi5i YTZhYjM1YzE4ZGMgMTAwNjQ0DQo+IC0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vbW11X2Nv bnRleHQuaA0KPiArKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmgNCj4g QEAgLTMwLDYgKzMwLDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGVudGVyX2xhenlfdGxiKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLA0KPiAgIHN0YXRpYyBpbmxpbmUgaW50IGluaXRfbmV3X2NvbnRleHQo c3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLA0KPiAgIAlzdHJ1Y3QgbW1fc3RydWN0ICptbSkNCj4g ICB7DQo+ICsJYXRvbWljX2xvbmdfc2V0KCYobW0pLT5jb250ZXh0LmlkLCAwKTsNClBhcmVudGhl c2lzIGFyb3VuZCBtbSBpc24ndCBuZWNlc3NhcnkNCj4gICAJcmV0dXJuIDA7DQo+ICAgfQ0KPiAg IA0KPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5TIGIvYXJjaC9yaXNjdi9r ZXJuZWwvaGVhZC5TDQo+IGluZGV4IGZlODg0Y2Q2OWFiZC4uYzNmOWFkYzBkMDU0IDEwMDY0NA0K PiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlMNCj4gKysrIGIvYXJjaC9yaXNjdi9rZXJu ZWwvaGVhZC5TDQo+IEBAIC05NSw2ICs5NSw4IEBAIHJlbG9jYXRlOg0KPiAgIAlsYSBhMiwgc3dh cHBlcl9wZ19kaXINCj4gICAJc3JsIGEyLCBhMiwgUEFHRV9TSElGVA0KPiAgIAlsaSBhMSwgU0FU UF9NT0RFDQo+ICsJbGkgYTAsIChTQVRQX0FTSURfTUFTSyA8PCBTQVRQX0FTSURfU0hJRlQpDQo+ ICsJb3IgYTEsIGExLCBhMA0KPiAgIAlvciBhMiwgYTIsIGExDQo+ICAgDQo+ICAgCS8qDQo+IGRp ZmYgLS1naXQgYS9hcmNoL3Jpc2N2L21tL2NvbnRleHQuYyBiL2FyY2gvcmlzY3YvbW0vY29udGV4 dC5jDQo+IGluZGV4IDBmNzg3YmNkM2E3YS4uMTIwNWQzM2QxYjFiIDEwMDY0NA0KPiAtLS0gYS9h cmNoL3Jpc2N2L21tL2NvbnRleHQuYw0KPiArKysgYi9hcmNoL3Jpc2N2L21tL2NvbnRleHQuYw0K PiBAQCAtMiwxMyArMiwyMDkgQEANCj4gICAvKg0KPiAgICAqIENvcHlyaWdodCAoQykgMjAxMiBS ZWdlbnRzIG9mIHRoZSBVbml2ZXJzaXR5IG9mIENhbGlmb3JuaWENCj4gICAgKiBDb3B5cmlnaHQg KEMpIDIwMTcgU2lGaXZlDQo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTkgV2VzdGVybiBEaWdpdGFs IENvcnBvcmF0aW9uIG9yIGl0cyBhZmZpbGlhdGVzLg0KPiAgICAqLw0KPiAgIA0KPiArI2luY2x1 ZGUgPGxpbnV4L2JpdG9wcy5oPg0KPiAgICNpbmNsdWRlIDxsaW51eC9tbS5oPg0KPiArI2luY2x1 ZGUgPGxpbnV4L3NsYWIuaD4NCj4gICANCj4gICAjaW5jbHVkZSA8YXNtL3RsYmZsdXNoLmg+DQo+ ICAgI2luY2x1ZGUgPGFzbS9jYWNoZWZsdXNoLmg+DQo+ICAgDQo+ICtzdGF0aWMgYm9vbCB1c2Vf YXNpZF9hbGxvY2F0b3I7DQo+ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBhc2lkX2JpdHM7DQo+ICtz dGF0aWMgdW5zaWduZWQgbG9uZyBudW1fYXNpZHM7DQo+ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBh c2lkX21hc2s7DQo+ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBmaXJzdF92ZXJzaW9uOw0KPiArDQo+ ICtzdGF0aWMgYXRvbWljX2xvbmdfdCBjdXJyZW50X3ZlcnNpb247DQo+ICsNCj4gK3N0YXRpYyBE RUZJTkVfUkFXX1NQSU5MT0NLKGNvbnRleHRfbG9jayk7DQo+ICtzdGF0aWMgdW5zaWduZWQgbG9u ZyAqY29udGV4dF9hc2lkX21hcDsNCj4gKw0KPiArc3RhdGljIERFRklORV9QRVJfQ1BVKGF0b21p Y19sb25nX3QsIGFjdGl2ZV9jb250ZXh0KTsNCj4gK3N0YXRpYyBERUZJTkVfUEVSX0NQVSh1bnNp Z25lZCBsb25nLCByZXNlcnZlZF9jb250ZXh0KTsNCj4gKw0KPiArc3RhdGljIGJvb2wgY2hlY2tf dXBkYXRlX3Jlc2VydmVkX2NvbnRleHQodW5zaWduZWQgbG9uZyBjbnR4LA0KPiArCQkJCQkgIHVu c2lnbmVkIGxvbmcgbmV3Y250eCkNCj4gK3sNCj4gKwlpbnQgY3B1Ow0KPiArCWJvb2wgaGl0ID0g ZmFsc2U7DQo+ICsNCj4gKwkvKg0KPiArCSAqIEl0ZXJhdGUgb3ZlciB0aGUgc2V0IG9mIHJlc2Vy dmVkIENPTlRFWFQgbG9va2luZyBmb3IgYSBtYXRjaC4NCj4gKwkgKiBJZiB3ZSBmaW5kIG9uZSwg dGhlbiB3ZSBjYW4gdXBkYXRlIG91ciBtbSB0byB1c2UgbmV3IENPTlRFWFQNCj4gKwkgKiAoaS5l LiB0aGUgc2FtZSBDT05URVhUIGluIHRoZSBjdXJyZW50X3ZlcnNpb24pIGJ1dCB3ZSBjYW4ndA0K PiArCSAqIGV4aXQgdGhlIGxvb3AgZWFybHksIHNpbmNlIHdlIG5lZWQgdG8gZW5zdXJlIHRoYXQg YWxsIGNvcGllcw0KPiArCSAqIG9mIHRoZSBvbGQgQ09OVEVYVCBhcmUgdXBkYXRlZCB0byByZWZs ZWN0IHRoZSBtbS4gRmFpbHVyZSB0byBkbw0KPiArCSAqIHNvIGNvdWxkIHJlc3VsdCBpbiB1cyBt aXNzaW5nIHRoZSByZXNlcnZlZCBDT05URVhUIGluIGEgZnV0dXJlDQo+ICsJICogdmVyc2lvbi4N Cj4gKwkgKi8NCj4gKwlmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1KSB7DQo+ICsJCWlmIChwZXJf Y3B1KHJlc2VydmVkX2NvbnRleHQsIGNwdSkgPT0gY250eCkgew0KPiArCQkJaGl0ID0gdHJ1ZTsN Cj4gKwkJCXBlcl9jcHUocmVzZXJ2ZWRfY29udGV4dCwgY3B1KSA9IG5ld2NudHg7DQo+ICsJCX0N Cj4gKwl9DQo+ICsNCj4gKwlyZXR1cm4gaGl0Ow0KPiArfQ0KPiArDQo+ICsvKiBOb3RlOiBtdXN0 IGJlIGNhbGxlZCB3aXRoIGNvbnRleHRfbG9jayBoZWxkICovDQo+ICtzdGF0aWMgdm9pZCBfX2Zs dXNoX2NvbnRleHQodm9pZCkNCj4gK3sNCj4gKwlpbnQgaTsNCj4gKwl1bnNpZ25lZCBsb25nIGNu dHg7DQo+ICsNCj4gKwkvKiBVcGRhdGUgdGhlIGxpc3Qgb2YgcmVzZXJ2ZWQgQVNJRHMgYW5kIHRo ZSBBU0lEIGJpdG1hcC4gKi8NCj4gKwliaXRtYXBfY2xlYXIoY29udGV4dF9hc2lkX21hcCwgMCwg bnVtX2FzaWRzKTsNCj4gKw0KPiArCS8qIE1hcmsgYWxyZWFkeSBhY2l0dmUgQVNJRHMgYXMgdXNl ZCAqLw0KPiArCWZvcl9lYWNoX3Bvc3NpYmxlX2NwdShpKSB7DQo+ICsJCWNudHggPSBhdG9taWNf bG9uZ194Y2hnX3JlbGF4ZWQoJnBlcl9jcHUoYWN0aXZlX2NvbnRleHQsIGkpLCAwKTsNCj4gKwkJ LyoNCj4gKwkJICogSWYgdGhpcyBDUFUgaGFzIGFscmVhZHkgYmVlbiB0aHJvdWdoIGEgcm9sbG92 ZXIsIGJ1dA0KPiArCQkgKiBoYXNuJ3QgcnVuIGFub3RoZXIgdGFzayBpbiB0aGUgbWVhbnRpbWUs IHdlIG11c3QgcHJlc2VydmUNCj4gKwkJICogaXRzIHJlc2VydmVkIENPTlRFWFQsIGFzIHRoaXMg aXMgdGhlIG9ubHkgdHJhY2Ugd2UgaGF2ZSBvZg0KPiArCQkgKiB0aGUgcHJvY2VzcyBpdCBpcyBz dGlsbCBydW5uaW5nLg0KPiArCQkgKi8NCj4gKwkJaWYgKGNudHggPT0gMCkNCj4gKwkJCWNudHgg PSBwZXJfY3B1KHJlc2VydmVkX2NvbnRleHQsIGkpOw0KPiArDQo+ICsJCV9fc2V0X2JpdChjbnR4 ICYgYXNpZF9tYXNrLCBjb250ZXh0X2FzaWRfbWFwKTsNCj4gKwkJcGVyX2NwdShyZXNlcnZlZF9j b250ZXh0LCBpKSA9IGNudHg7DQo+ICsJfQ0KPiArDQo+ICsJLyogTWFyayBsYXN0IEFTSUQgYXMg dXNlZCBiZWNhdXNlIGl0IGlzIHVzZWQgYXQgYm9vdC10aW1lICovDQo+ICsJX19zZXRfYml0KGFz aWRfbWFzaywgY29udGV4dF9hc2lkX21hcCk7DQpMb29rcyB1bm5lY2Vzc2FyeSBhcyB3ZSBhbHdh eXMgc3RhcnQgZmluZF9uZXh0X3plcm9fYml0IGZyb20gaWR4IDEuDQo+ICt9DQo+ICsNCj4gKy8q IE5vdGU6IG11c3QgYmUgY2FsbGVkIHdpdGggY29udGV4dF9sb2NrIGhlbGQgKi8NCj4gK3N0YXRp YyB1bnNpZ25lZCBsb25nIF9fbmV3X2NvbnRleHQoc3RydWN0IG1tX3N0cnVjdCAqbW0sDQo+ICsJ CQkJICAgYm9vbCAqbmVlZF90bGJfZmx1c2gpDQo+ICt7DQo+ICsJc3RhdGljIHUzMiBjdXJfaWR4 ID0gMTsNCj4gKwl1bnNpZ25lZCBsb25nIGNudHggPSBhdG9taWNfbG9uZ19yZWFkKCZtbS0+Y29u dGV4dC5pZCk7DQo+ICsJdW5zaWduZWQgbG9uZyBhc2lkLCB2ZXIgPSBhdG9taWNfbG9uZ19yZWFk KCZjdXJyZW50X3ZlcnNpb24pOw0KPiArDQo+ICsJaWYgKGNudHggIT0gMCkgew0KPiArCQl1bnNp Z25lZCBsb25nIG5ld2NudHggPSB2ZXIgfCAoY250eCAmIH5hc2lkX21hc2spOw0KU2hvdWxkbid0 IHRoaXMgYmUgY250eCAmIGFzaWRfbWFzayA/DQo+ICsNCj4gKwkJLyoNCj4gKwkJICogSWYgb3Vy IGN1cnJlbnQgQ09OVEVYVCB3YXMgYWN0aXZlIGR1cmluZyBhIHJvbGxvdmVyLCB3ZQ0KPiArCQkg KiBjYW4gY29udGludWUgdG8gdXNlIGl0IGFuZCB0aGlzIHdhcyBqdXN0IGEgZmFsc2UgYWxhcm0u DQo+ICsJCSAqLw0KPiArCQlpZiAoY2hlY2tfdXBkYXRlX3Jlc2VydmVkX2NvbnRleHQoY250eCwg bmV3Y250eCkpDQo+ICsJCQlyZXR1cm4gbmV3Y250eDsNCj4gKw0KPiArCQkvKg0KPiArCQkgKiBX ZSBoYWQgYSB2YWxpZCBDT05URVhUIGluIGEgcHJldmlvdXMgbGlmZSwgc28gdHJ5IHRvDQo+ICsJ CSAqIHJlLXVzZSBpdCBpZiBwb3NzaWJsZS4NCj4gKwkJICovDQo+ICsJCWlmICghX190ZXN0X2Fu ZF9zZXRfYml0KGNudHggJiBhc2lkX21hc2ssIGNvbnRleHRfYXNpZF9tYXApKQ0KPiArCQkJcmV0 dXJuIG5ld2NudHg7DQo+ICsJfQ0KPiArDQo+ICsJLyoNCj4gKwkgKiBBbGxvY2F0ZSBhIGZyZWUg QVNJRC4gSWYgd2UgY2FuJ3QgZmluZCBvbmUgdGhlbiBpbmNyZW1lbnQNCj4gKwkgKiBjdXJyZW50 X3ZlcnNpb24gYW5kIGZsdXNoIGFsbCBBU0lEcy4NCj4gKwkgKi8NCj4gKwlhc2lkID0gZmluZF9u ZXh0X3plcm9fYml0KGNvbnRleHRfYXNpZF9tYXAsIG51bV9hc2lkcywgY3VyX2lkeCk7DQo+ICsJ aWYgKGFzaWQgIT0gbnVtX2FzaWRzKQ0KPiArCQlnb3RvIHNldF9hc2lkOw0KPiArDQo+ICsJLyog V2UncmUgb3V0IG9mIEFTSURzLCBzbyBpbmNyZW1lbnQgY3VycmVudF92ZXJzaW9uICovDQo+ICsJ dmVyID0gYXRvbWljX2xvbmdfYWRkX3JldHVybl9yZWxheGVkKGZpcnN0X3ZlcnNpb24sICZjdXJy ZW50X3ZlcnNpb24pOw0KPiArDQo+ICsJLyogRmx1c2ggZXZlcnl0aGluZyAgKi8NCj4gKwlfX2Zs dXNoX2NvbnRleHQoKTsNCj4gKwkqbmVlZF90bGJfZmx1c2ggPSB0cnVlOw0KPiArDQo+ICsJLyog V2UgaGF2ZSBtb3JlIEFTSURzIHRoYW4gQ1BVcywgc28gdGhpcyB3aWxsIGFsd2F5cyBzdWNjZWVk ICovDQo+ICsJYXNpZCA9IGZpbmRfbmV4dF96ZXJvX2JpdChjb250ZXh0X2FzaWRfbWFwLCBudW1f YXNpZHMsIDEpOw0KPiArDQo+ICtzZXRfYXNpZDoNCj4gKwlfX3NldF9iaXQoYXNpZCwgY29udGV4 dF9hc2lkX21hcCk7DQo+ICsJY3VyX2lkeCA9IGFzaWQ7DQo+ICsJcmV0dXJuIGFzaWQgfCB2ZXI7 DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIHNldF9tbV9hc2lkKHN0cnVjdCBtbV9zdHJ1Y3Qg Km1tLCB1bnNpZ25lZCBpbnQgY3B1KQ0KPiArew0KPiArCXVuc2lnbmVkIGxvbmcgZmxhZ3M7DQo+ ICsJYm9vbCBuZWVkX3RsYl9mbHVzaCA9IGZhbHNlOw0KPiArCXVuc2lnbmVkIGxvbmcgY250eCwg b2xkX2FjdGl2ZV9jbnR4Ow0KPiArDQo+ICsJY250eCA9IGF0b21pY19sb25nX3JlYWQoJm1tLT5j b250ZXh0LmlkKTsNCj4gKw0KPiArCS8qDQo+ICsJICogSWYgb3VyIGFjdGl2ZV9jb250ZXh0IGlz IG5vbi16ZXJvIGFuZCB0aGUgY29udGV4dCBtYXRjaGVzIHRoZQ0KPiArCSAqIGN1cnJlbnRfdmVy c2lvbiwgdGhlbiB3ZSB1cGRhdGUgdGhlIGFjdGl2ZV9jb250ZXh0IGVudHJ5IHdpdGggYQ0KPiAr CSAqIHJlbGF4ZWQgY21weGNoZy4NCj4gKwkgKg0KPiArCSAqIEZvbGxvd2luZyBpcyBob3cgd2Ug aGFuZGxlIHJhY2luZyB3aXRoIGEgY29uY3VycmVudCByb2xsb3ZlcjoNCj4gKwkgKg0KPiArCSAq IC0gV2UgZ2V0IGEgemVybyBiYWNrIGZyb20gdGhlIGNtcHhjaGcgYW5kIGVuZCB1cCB3YWl0aW5n IG9uIHRoZQ0KPiArCSAqICAgbG9jay4gVGFraW5nIHRoZSBsb2NrIHN5bmNocm9uaXNlcyB3aXRo IHRoZSByb2xsb3ZlciBhbmQgc28NCj4gKwkgKiAgIHdlIGFyZSBmb3JjZWQgdG8gc2VlIHRoZSB1 cGRhdGVkIHZlcmlvbi4NCj4gKwkgKg0KPiArCSAqIC0gV2UgZ2V0IGEgdmFsaWQgY29udGV4dCBi YWNrIGZyb20gdGhlIGNtcHhjaGcgdGhlbiB3ZSBjb250aW51ZQ0KPiArCSAqICAgdXNpbmcgb2xk IEFTSUQgYmVjYXVzZSBfX2ZsdXNoX2NvbnRleHQoKSB3b3VsZCBoYXZlIG1hcmtlZCBBU0lEDQo+ ICsJICogICBvZiBhY3RpdmVfY29udGV4dCBhcyB1c2VkIGFuZCBuZXh0IGNvbnRleHQgc3dpdGNo IHdlIHdpbGwgYWxsb2NhdGUNCj4gKwkgKiAgIG5ldyBjb250ZXh0Lg0KPiArCSAqLw0KPiArCW9s ZF9hY3RpdmVfY250eCA9IGF0b21pY19sb25nX3JlYWQoJnBlcl9jcHUoYWN0aXZlX2NvbnRleHQs IGNwdSkpOw0KPiArCWlmIChvbGRfYWN0aXZlX2NudHggJiYNCj4gKwkgICAgISgoY250eCBeIGF0 b21pY19sb25nX3JlYWQoJmN1cnJlbnRfdmVyc2lvbikpID4+IGFzaWRfYml0cykgJiYNClRoaXMg bG9va3MgaGFyZCB0byByZWFkLiBQcm9iYWJseQ0KKGNudHggJn4gYXNpZF9tYXNrKSA9PSBhdG9t aWNfbG9uZ19yZWFkKCZjdXJyZW50X3ZlcnNpb24pDQppcyBjbGVhcmVyLg0KPiArCSAgICBhdG9t aWNfbG9uZ19jbXB4Y2hnX3JlbGF4ZWQoJnBlcl9jcHUoYWN0aXZlX2NvbnRleHQsIGNwdSksDQo+ ICsJCQkJCW9sZF9hY3RpdmVfY250eCwgY250eCkpDQo+ICsJCWdvdG8gc3dpdGNoX21tX2Zhc3Q7 DQo+ICsNCj4gKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmNvbnRleHRfbG9jaywgZmxhZ3MpOw0K QW55IHJlYXNvbiB0aGF0IHdlIHByZWZlciByYXdfIGhlcmU/DQo+ICsNCj4gKwkvKiBDaGVjayB0 aGF0IG91ciBBU0lEIGJlbG9uZ3MgdG8gdGhlIGN1cnJlbnRfdmVyc2lvbi4gKi8NCj4gKwljbnR4 ID0gYXRvbWljX2xvbmdfcmVhZCgmbW0tPmNvbnRleHQuaWQpOw0KPiArCWlmICgoY250eCBeIGF0 b21pY19sb25nX3JlYWQoJmN1cnJlbnRfdmVyc2lvbikpID4+IGFzaWRfYml0cykgew0KU2FtZSBh cyBhYm92ZSwgcHJvYmFibHkNCihjbnR4ICZ+IGFzaWRfbWFzaykgIT0gYXRvbWljX2xvbmdfcmVh ZCgmY3VycmVudF92ZXJzaW9uKQ0KbWFrZXMgbW9yZSBzZW5zZS4NCj4gKwkJY250eCA9IF9fbmV3 X2NvbnRleHQobW0sICZuZWVkX3RsYl9mbHVzaCk7DQo+ICsJCWF0b21pY19sb25nX3NldCgmbW0t PmNvbnRleHQuaWQsIGNudHgpOw0KPiArCX0NCj4gKw0KPiArCWF0b21pY19sb25nX3NldCgmcGVy X2NwdShhY3RpdmVfY29udGV4dCwgY3B1KSwgY250eCk7DQo+ICsNCj4gKwlyYXdfc3Bpbl91bmxv Y2tfaXJxcmVzdG9yZSgmY29udGV4dF9sb2NrLCBmbGFncyk7DQo+ICsNCj4gK3N3aXRjaF9tbV9m YXN0Og0KPiArCS8qDQo+ICsJICogVXNlIHRoZSBvbGQgc3BidHIgbmFtZSBpbnN0ZWFkIG9mIHVz aW5nIHRoZSBjdXJyZW50IHNhdHANCj4gKwkgKiBuYW1lIHRvIHN1cHBvcnQgYmludXRpbHMgMi4y OSB3aGljaCBkb2Vzbid0IGtub3cgYWJvdXQgdGhlDQo+ICsJICogcHJpdmlsZWdlZCBJU0EgMS4x MCB5ZXQuDQo+ICsJICovDQo+ICsJY3NyX3dyaXRlKHNwdGJyLCB2aXJ0X3RvX3BmbihtbS0+cGdk KSB8DQo+ICsJCSAgKChjbnR4ICYgYXNpZF9tYXNrKSA8PCBTQVRQX0FTSURfU0hJRlQpIHwNCj4g KwkJICBTQVRQX01PREUpOw0KPiArDQo+ICsJaWYgKG5lZWRfdGxiX2ZsdXNoKQ0KPiArCQlmbHVz aF90bGJfYWxsKCk7DQpJIHRoaW5rIHlvdXIgaW50ZW50aW9uIGhlcmUgaXMgdG8gYXZvaWQgY2Fs bGluZyBmbHVzaF90bGJfYWxsIHdoZW4gSVJRcyANCmFyZSBvZmYgaW4gdGhlIGNyaXRpY2FsIHJl Z2lvbi4gSG93ZXZlciwgc3dpdGNoX21tIHdpbGwgYmUgY2FsbGVkIGZyb20gDQpzY2hlZHVsZXIg YXMgd2VsbCB3aGljaCBhbHNvIHR1cm4gaXJxcyBvZmYsIHNvIHRoaXMgc3RpbGwgY2F1c2UgaXNz dWUuIEkgDQp0aGluayBhIGJldHRlciB3YXkgaXMgdG8gZm9yY2UgZmx1c2hfdGxiX2FsbCB0byB1 c2UgU0JJIHdoZW4gSVJRcyBhcmUgDQpvZmYuIFdoYXQgZG8geW91IHRoaW5rPw0KPiArfQ0KPiAr DQo+ICtzdGF0aWMgdm9pZCBzZXRfbW1fbm9hc2lkKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQ0KPiAr ew0KPiArCS8qDQo+ICsJICogVXNlIHRoZSBvbGQgc3BidHIgbmFtZSBpbnN0ZWFkIG9mIHVzaW5n IHRoZSBjdXJyZW50IHNhdHANCj4gKwkgKiBuYW1lIHRvIHN1cHBvcnQgYmludXRpbHMgMi4yOSB3 aGljaCBkb2Vzbid0IGtub3cgYWJvdXQgdGhlDQo+ICsJICogcHJpdmlsZWdlZCBJU0EgMS4xMCB5 ZXQuDQo+ICsJICovDQo+ICsJY3NyX3dyaXRlKHNwdGJyLCB2aXJ0X3RvX3BmbihtbS0+cGdkKSB8 IFNBVFBfTU9ERSk7DQo+ICsNCj4gKwkvKg0KPiArCSAqIHNmZW5jZS52bWEgYWZ0ZXIgU0FUUCB3 cml0ZS4gV2UgY2FsbCBpdCBvbiBNTSBjb250ZXh0IGluc3RlYWQgb2YNCj4gKwkgKiBjYWxsaW5n IGxvY2FsX2ZsdXNoX3RsYl9hbGwgdG8gcHJldmVudCBnbG9iYWwgbWFwcGluZ3MgZnJvbSBiZWlu Zw0KPiArCSAqIGFmZmVjdGVkLg0KPiArCSAqLw0KPiArCWxvY2FsX2ZsdXNoX3RsYl9tbShtbSk7 DQo+ICt9DQo+ICsNCj4gICAvKg0KPiAgICAqIFdoZW4gbmVjZXNzYXJ5LCBwZXJmb3JtcyBhIGRl ZmVycmVkIGljYWNoZSBmbHVzaCBmb3IgdGhlIGdpdmVuIE1NIGNvbnRleHQsDQo+ICAgICogb24g dGhlIGxvY2FsIENQVS4gIFJJU0MtViBoYXMgbm8gZGlyZWN0IG1lY2hhbmlzbSBmb3IgaW5zdHJ1 Y3Rpb24gY2FjaGUNCj4gQEAgLTU4LDIwICsyNTQsNDkgQEAgdm9pZCBzd2l0Y2hfbW0oc3RydWN0 IG1tX3N0cnVjdCAqcHJldiwgc3RydWN0IG1tX3N0cnVjdCAqbmV4dCwNCj4gICAJY3B1bWFza19j bGVhcl9jcHUoY3B1LCBtbV9jcHVtYXNrKHByZXYpKTsNCj4gICAJY3B1bWFza19zZXRfY3B1KGNw dSwgbW1fY3B1bWFzayhuZXh0KSk7DQo+ICAgDQo+IC0JLyoNCj4gLQkgKiBVc2UgdGhlIG9sZCBz cGJ0ciBuYW1lIGluc3RlYWQgb2YgdXNpbmcgdGhlIGN1cnJlbnQgc2F0cA0KPiAtCSAqIG5hbWUg dG8gc3VwcG9ydCBiaW51dGlscyAyLjI5IHdoaWNoIGRvZXNuJ3Qga25vdyBhYm91dCB0aGUNCj4g LQkgKiBwcml2aWxlZ2VkIElTQSAxLjEwIHlldC4NCj4gLQkgKi8NCj4gLQljc3Jfd3JpdGUoc3B0 YnIsIHZpcnRfdG9fcGZuKG5leHQtPnBnZCkgfCBTQVRQX01PREUpOw0KPiArCWlmICh1c2VfYXNp ZF9hbGxvY2F0b3IpDQo+ICsJCXNldF9tbV9hc2lkKG5leHQsIGNwdSk7DQo+ICsJZWxzZQ0KPiAr CQlzZXRfbW1fbm9hc2lkKG5leHQpOw0KPiArDQo+ICsJZmx1c2hfaWNhY2hlX2RlZmVycmVkKG5l eHQpOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgaW50IGFzaWRzX2luaXQodm9pZCkNCj4gK3sNCj4g KwkvKiBGaWd1cmUtb3V0IG51bWJlciBvZiBBU0lEIGJpdHMgaW4gSFcgKi8NCj4gKwlhc2lkX2Jp dHMgPSAoY3NyX3JlYWQoc3B0YnIpID4+IFNBVFBfQVNJRF9TSElGVCkgJiBTQVRQX0FTSURfTUFT SzsNCj4gKwlhc2lkX2JpdHMgPSBmbHNfbG9uZyhhc2lkX2JpdHMpOw0KPiArDQo+ICsJLyogUHJl LWNvbXB1dGUgQVNJRCBkZXRhaWxzICovDQo+ICsJbnVtX2FzaWRzID0gMSA8PCBhc2lkX2JpdHM7 DQo+ICsJYXNpZF9tYXNrID0gbnVtX2FzaWRzIC0gMTsNCj4gKwlmaXJzdF92ZXJzaW9uID0gbnVt X2FzaWRzOw0KSXMgdGhlcmUgYW55IHJlYXNvbiB3ZSB3YW50IHRvIGhhdmUgdHdvIHNldC1vbmNl IHZhcmlhYmxlcyB3aXRoIHNhbWUgdmFsdWU/DQo+ICAgDQo+ICAgCS8qDQo+IC0JICogc2ZlbmNl LnZtYSBhZnRlciBTQVRQIHdyaXRlLiBXZSBjYWxsIGl0IG9uIE1NIGNvbnRleHQgaW5zdGVhZCBv Zg0KPiAtCSAqIGNhbGxpbmcgbG9jYWxfZmx1c2hfdGxiX2FsbCB0byBwcmV2ZW50IGdsb2JhbCBt YXBwaW5ncyBmcm9tIGJlaW5nDQo+IC0JICogYWZmZWN0ZWQuDQo+ICsJICogVXNlIEFTSUQgYWxs b2NhdG9yIG9ubHkgaWYgbnVtYmVyIG9mIEhXIEFTSURzIGFyZQ0KPiArCSAqIGF0LWxlYXN0IHR3 aWNlIG1vcmUgdGhhbiBDUFVzDQo+ICAgCSAqLw0KPiAtCWxvY2FsX2ZsdXNoX3RsYl9tbShuZXh0 KTsNCj4gKwl1c2VfYXNpZF9hbGxvY2F0b3IgPQ0KPiArCQkobnVtX2FzaWRzIDw9ICgyICogbnVt X3Bvc3NpYmxlX2NwdXMoKSkpID8gZmFsc2UgOiB0cnVlOw0KPiAgIA0KPiAtCWZsdXNoX2ljYWNo ZV9kZWZlcnJlZChuZXh0KTsNCj4gLX0NCj4gKwkvKiBTZXR1cCBBU0lEIGFsbG9jYXRvciBpZiBh dmFpbGFibGUgKi8NCj4gKwlpZiAodXNlX2FzaWRfYWxsb2NhdG9yKSB7DQo+ICsJCWF0b21pY19s b25nX3NldCgmY3VycmVudF92ZXJzaW9uLCBmaXJzdF92ZXJzaW9uKTsNCj4gICANCj4gKwkJY29u dGV4dF9hc2lkX21hcCA9IGtjYWxsb2MoQklUU19UT19MT05HUyhudW1fYXNpZHMpLA0KPiArCQkJ CSAgIHNpemVvZigqY29udGV4dF9hc2lkX21hcCksIEdGUF9LRVJORUwpOw0KPiArCQlpZiAoIWNv bnRleHRfYXNpZF9tYXApDQo+ICsJCQlwYW5pYygiRmFpbGVkIHRvIGFsbG9jYXRlIGJpdG1hcCBm b3IgJWx1IEFTSURzXG4iLA0KPiArCQkJICAgICAgbnVtX2FzaWRzKTsNCj4gKw0KPiArCQlfX3Nl dF9iaXQoYXNpZF9tYXNrLCBjb250ZXh0X2FzaWRfbWFwKTsNCj4gKw0KPiArCQlwcl9pbmZvKCJB U0lEIGFsbG9jYXRvciB1c2luZyAlbHUgZW50cmllc1xuIiwgbnVtX2FzaWRzKTsNCj4gKwl9IGVs c2Ugew0KSWYgd2UgZGVjaWRlIG5vdCB0byB1c2UgQVNJRCBhbGxvY2F0b3IsIHdlIHdpbGwgbmVl ZCB0byBzZXQgQVNJRCBmaWVsZCANCnRvIHplcm8gb24gKmFsbCBoYXJ0cyogYmVmb3JlIHdlIGRv IG91ciBmaXJzdCBzd2l0Y2hfbW0uIE90aGVyd2lzZSB3ZSANCndpbGwgZW5kIHVwIGEgaGFydCBy dW5uaW5nIG5vbi16ZXJvIEFTSUQgYW5kIGFub3RoZXIgcnVubmluZyB6ZXJvIEFTSUQgDQp3aXRo IGRpZmZlcmVudCBwYWdlIHRhYmxlLg0KPiArCQlwcl9pbmZvKCJBU0lEIGFsbG9jYXRvciBkaXNh YmxlZFxuIik7DQo+ICsJfQ0KPiArDQo+ICsJcmV0dXJuIDA7DQo+ICt9DQo+ICtlYXJseV9pbml0 Y2FsbChhc2lkc19pbml0KTsNCj4gDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-12.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 115F9C43381 for ; Thu, 28 Mar 2019 13:38:34 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id CEA3F206BA for ; Thu, 28 Mar 2019 13:38:33 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Mlpa+qL8"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=garyguo.net header.i=@garyguo.net header.b="I71HNaXK" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CEA3F206BA Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=garyguo.net Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-riscv-bounces+infradead-linux-riscv=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:Content-ID:In-Reply-To: References:Message-ID:Date:Subject:To:From:Reply-To:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=rsFDwp9QPKIpNYcCYe/gleP1nJ36nCHjuGA5d4Jz2DE=; b=Mlpa+qL8pzEP/u YrC1zqsDLsoA808C1PTqUKj1lQaN88vv76kB1jdxnfVLi220S+14WP3M7AFdHv+uGmoP9/Lw1xDd7 f5gWH2VlYXaXG9WlsvPuPnzvDilp5oQE6E2cbtBuqB04E0uT/yT5O53MOsU5hQcCc8AlIKF3II+3M ZML3yn6yRZAaaVZ3Cr4D2fmX3WShPfDtFT4IoNqms+u5tWWd55WFy+8f/9hjNtHufIbfZME23gozp /cPWubvLYOXk4o5EDh56jR1ClKJENf5LHmNw4Q3GgEy4XIHqslo0D74dXgjFUxV+BFT9vzzm0Up/x r3/23f6nN1x4hA1dEVVw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1h9VEk-0003N0-5B; Thu, 28 Mar 2019 13:38:30 +0000 Received: from mail-eopbgr110117.outbound.protection.outlook.com ([40.107.11.117] helo=GBR01-CWL-obe.outbound.protection.outlook.com) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1h9VDd-0001uc-7T for linux-riscv@lists.infradead.org; Thu, 28 Mar 2019 13:37:26 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=garyguo.net; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=C7qlUqRiywDE6RVGWOfx0UfR91vGOeIr4hwZctX2G3g=; b=I71HNaXKkZcG6ss84jeLxhrb4yMVEx81PFXd0f+1QUEYYJlSJrnPy+8yyTu4itNGJOhvS20Tz0WdJrklT6eNbTt4WnrxFFhazT+04hVPU8idKXXeX1my363t6VKv1dBdtvnkq1QESlS2p2bCrB/3aglqGpww38pK9I1Cv2AMz/0= Received: from LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM (20.176.139.20) by LO2P265MB0990.GBRP265.PROD.OUTLOOK.COM (20.176.140.18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1730.18; Thu, 28 Mar 2019 13:37:15 +0000 Received: from LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM ([fe80::ed34:1290:4306:3157]) by LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM ([fe80::ed34:1290:4306:3157%3]) with mapi id 15.20.1750.017; Thu, 28 Mar 2019 13:37:15 +0000 From: Gary Guo To: Anup Patel Subject: Re: [PATCH v2] RISC-V: Implement ASID allocator Thread-Topic: [PATCH v2] RISC-V: Implement ASID allocator Thread-Index: AQHU5TAIKaRDCttA7UazIjpcDaomMKYhDFQA Date: Thu, 28 Mar 2019 13:37:15 +0000 Message-ID: References: <20190328063211.13052-1-anup.patel@wdc.com> In-Reply-To: <20190328063211.13052-1-anup.patel@wdc.com> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: LO2P123CA0013.GBRP123.PROD.OUTLOOK.COM (2603:10a6:600:a6::25) To LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:8c::20) authentication-results: spf=none (sender IP is ) smtp.mailfrom=gary@garyguo.net; x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [2001:630:212:238:3697:f6ff:fe55:55b1] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: d25f576f-fd08-49cc-ec98-08d6b3827d76 x-microsoft-antispam: BCL:0; PCL:0; RULEID:(2390118)(7020095)(4652040)(7021145)(8989299)(4534185)(7022145)(4603075)(4627221)(201702281549075)(8990200)(7048125)(7024125)(7027125)(7023125)(5600127)(711020)(4605104)(2017052603328)(7153060)(7193020); SRVR:LO2P265MB0990; x-ms-traffictypediagnostic: LO2P265MB0990: x-ms-exchange-purlcount: 1 x-microsoft-antispam-prvs: x-forefront-prvs: 0990C54589 x-forefront-antispam-report: SFV:NSPM; SFS:(10019020)(346002)(396003)(366004)(136003)(39830400003)(376002)(55674003)(199004)(189003)(30864003)(476003)(71190400001)(2616005)(6512007)(316002)(71200400001)(76176011)(31686004)(6116002)(31696002)(53946003)(386003)(6916009)(46003)(54906003)(86362001)(53546011)(6506007)(14444005)(8936002)(6246003)(446003)(53936002)(256004)(486006)(11346002)(68736007)(102836004)(229853002)(6436002)(5660300002)(99286004)(2906002)(6486002)(97736004)(52116002)(966005)(508600001)(106356001)(81156014)(7736002)(8676002)(81166006)(186003)(25786009)(105586002)(36756003)(6306002)(305945005)(4326008)(14454004); DIR:OUT; SFP:1102; SCL:1; SRVR:LO2P265MB0990; H:LO2P265MB0847.GBRP265.PROD.OUTLOOK.COM; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; received-spf: None (protection.outlook.com: garyguo.net does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: ADdFbD/bSOLZJz5GOxvFIk9atBvjzs6uh2PZR3niAi1u3yLazovHUUV6zfTVSqlvphhEjdBNQntqeeWV1Cbu92yxeWOgWEHgdwp+Im/E9C6FehXQGz+ATfCUOKcTFrXAC49FXAZSWBsKU0YRobLR8++PrbrF3WRtS19bI+QGSxhgcMkOPu6aZ5csuLova6MZIFSRsh8xLuGG0u0bDH8X9lEw1t5bPrhQfFxGHkxygUtZZEn8/whz91CfKnosfYDvbCO7Kw6VOcT4/JW//SvOXrTGfpPPEGXTdTWNwJ9Vs7rmjTmSxQF7xIUFmcQ72RdxWKPRg+rmy5IqJ9IRS72tZhfBwKZ9GlAyTYrIVFiTHqVIQPTrwyvrUFp9PaGDRXCTeB4DauuuV0l+RRw/lHYfI+zBUXOkgVIrCUXOe2yAOtU= Content-ID: MIME-Version: 1.0 X-OriginatorOrg: garyguo.net X-MS-Exchange-CrossTenant-Network-Message-Id: d25f576f-fd08-49cc-ec98-08d6b3827d76 X-MS-Exchange-CrossTenant-originalarrivaltime: 28 Mar 2019 13:37:15.3381 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: bbc898ad-b10f-4e10-8552-d9377b823d45 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-Transport-CrossTenantHeadersStamped: LO2P265MB0990 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190328_063721_609500_09F64CB4 X-CRM114-Status: GOOD ( 31.43 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Albert Ou , Palmer Dabbelt , "linux-kernel@vger.kernel.org" , Mike Rapoport , Christoph Hellwig , Atish Patra , Paul Walmsley , "linux-riscv@lists.infradead.org" Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-riscv" Errors-To: linux-riscv-bounces+infradead-linux-riscv=archiver.kernel.org@lists.infradead.org Hi Anup, The code still does not use ASID in TLB flush routines. Without this added the code does not boot on systems with true ASID support. We also need to consider the case of CONTEXTID overflow on 32-bit systems. 32-bit CONTEXTID may overflow in a month time. Please all see my inline comments. Best, Gary On 28/03/2019 06:32, Anup Patel wrote: > Currently, we do local TLB flush on every MM switch. This is very harsh > on performance because we are forcing page table walks after every MM > switch. > > This patch implements ASID allocator for assigning an ASID to every MM > context. The number of ASIDs are limited in HW so we create a logical > entity named CONTEXTID for assigning to MM context. The lower bits of > CONTEXTID are ASID and upper bits are VERSION number. The number of > usable ASID bits supported by HW are detected at boot-time by writing > 1s to ASID bits in SATP CSR. This means last ASID is always reserved > because it is used for initial MM context. > > We allocate new CONTEXTID on first MM switch for a MM context where > the ASID is allocated from an ASID bitmap and VERSION is provide by > an atomic counter. At time of allocating new CONTEXTID, if we run out > of available ASIDs then: > 1. We flush the ASID bitmap > 2. Increment current VERSION atomic counter > 3. Re-allocate ASID from ASID bitmap > 4. Flush TLB on all CPUs > 5. Try CONTEXTID re-assignment on all CPUs > > Using above approach, we have virtually infinite CONTEXTIDs on-top-of > limited number of HW ASIDs. This approach is inspired from ASID allocator > used for Linux ARM/ARM64 but we have adapted it for RISC-V. Overall, > this ASID allocator helps us reduce rate of local TLB flushes on every > CPU thereby increasing performance. > > This patch is tested on QEMU/virt machine and SiFive Unleashed board. > On QEMU/virt machine, we see 10% (approx) performance improvement with > SW emulated TLBs provided by QEMU. Unfortunately, ASID bits of SATP CSR > are not implemented on SiFive Unleashed board so we don't see any change > in performance. > > Signed-off-by: Gary Guo Could you add a Co-developed-by line in addition to Signed-off-by as well? Thanks. > Signed-off-by: Anup Patel > --- > Changes since v1: > - We adapt good aspects from Gary Guo's ASID allocator implementation > and provide due credit to him by adding his SoB. > - Track ASIDs active during context flush and mark them as reserved > - Set ASID bits to all 1s to simplify number of ASID bit detection > - Use atomic_long_t instead of atomic64_t for being 32bit friendly > - Use unsigned long instead of u64 for being 32bit friendly > - Use flush_tlb_all() instead of lazy local_tlb_flush_all() at time > of context flush > > This patch is based on Linux-5.1-rc2 and TLB flush cleanup patches v4 > from Gary Guo. It can be also found in riscv_asid_allocator_v2 branch > of https://github.com/avpatel/linux.git > --- > arch/riscv/include/asm/csr.h | 6 + > arch/riscv/include/asm/mmu.h | 1 + > arch/riscv/include/asm/mmu_context.h | 1 + > arch/riscv/kernel/head.S | 2 + > arch/riscv/mm/context.c | 249 +++++++++++++++++++++++++-- > 5 files changed, 247 insertions(+), 12 deletions(-) > > diff --git a/arch/riscv/include/asm/csr.h b/arch/riscv/include/asm/csr.h > index 28a0d1cb374c..ce18ab8f53ed 100644 > --- a/arch/riscv/include/asm/csr.h > +++ b/arch/riscv/include/asm/csr.h > @@ -45,10 +45,16 @@ > #define SATP_PPN _AC(0x003FFFFF, UL) > #define SATP_MODE_32 _AC(0x80000000, UL) > #define SATP_MODE SATP_MODE_32 > +#define SATP_ASID_BITS 9 > +#define SATP_ASID_SHIFT 22 > +#define SATP_ASID_MASK _AC(0x1FF, UL) > #else > #define SATP_PPN _AC(0x00000FFFFFFFFFFF, UL) > #define SATP_MODE_39 _AC(0x8000000000000000, UL) > #define SATP_MODE SATP_MODE_39 > +#define SATP_ASID_BITS 16 > +#define SATP_ASID_SHIFT 44 > +#define SATP_ASID_MASK _AC(0xFFFF, UL) > #endif > > /* Interrupt Enable and Interrupt Pending flags */ > diff --git a/arch/riscv/include/asm/mmu.h b/arch/riscv/include/asm/mmu.h > index 5df2dccdba12..42a9ca0fe1fb 100644 > --- a/arch/riscv/include/asm/mmu.h > +++ b/arch/riscv/include/asm/mmu.h > @@ -18,6 +18,7 @@ > #ifndef __ASSEMBLY__ > > typedef struct { > + atomic_long_t id; > void *vdso; > #ifdef CONFIG_SMP > /* A local icache flush is needed before user execution can resume. */ > diff --git a/arch/riscv/include/asm/mmu_context.h b/arch/riscv/include/asm/mmu_context.h > index bf4f097a9051..ba6ab35c18dc 100644 > --- a/arch/riscv/include/asm/mmu_context.h > +++ b/arch/riscv/include/asm/mmu_context.h > @@ -30,6 +30,7 @@ static inline void enter_lazy_tlb(struct mm_struct *mm, > static inline int init_new_context(struct task_struct *task, > struct mm_struct *mm) > { > + atomic_long_set(&(mm)->context.id, 0); Parenthesis around mm isn't necessary > return 0; > } > > diff --git a/arch/riscv/kernel/head.S b/arch/riscv/kernel/head.S > index fe884cd69abd..c3f9adc0d054 100644 > --- a/arch/riscv/kernel/head.S > +++ b/arch/riscv/kernel/head.S > @@ -95,6 +95,8 @@ relocate: > la a2, swapper_pg_dir > srl a2, a2, PAGE_SHIFT > li a1, SATP_MODE > + li a0, (SATP_ASID_MASK << SATP_ASID_SHIFT) > + or a1, a1, a0 > or a2, a2, a1 > > /* > diff --git a/arch/riscv/mm/context.c b/arch/riscv/mm/context.c > index 0f787bcd3a7a..1205d33d1b1b 100644 > --- a/arch/riscv/mm/context.c > +++ b/arch/riscv/mm/context.c > @@ -2,13 +2,209 @@ > /* > * Copyright (C) 2012 Regents of the University of California > * Copyright (C) 2017 SiFive > + * Copyright (C) 2019 Western Digital Corporation or its affiliates. > */ > > +#include > #include > +#include > > #include > #include > > +static bool use_asid_allocator; > +static unsigned long asid_bits; > +static unsigned long num_asids; > +static unsigned long asid_mask; > +static unsigned long first_version; > + > +static atomic_long_t current_version; > + > +static DEFINE_RAW_SPINLOCK(context_lock); > +static unsigned long *context_asid_map; > + > +static DEFINE_PER_CPU(atomic_long_t, active_context); > +static DEFINE_PER_CPU(unsigned long, reserved_context); > + > +static bool check_update_reserved_context(unsigned long cntx, > + unsigned long newcntx) > +{ > + int cpu; > + bool hit = false; > + > + /* > + * Iterate over the set of reserved CONTEXT looking for a match. > + * If we find one, then we can update our mm to use new CONTEXT > + * (i.e. the same CONTEXT in the current_version) but we can't > + * exit the loop early, since we need to ensure that all copies > + * of the old CONTEXT are updated to reflect the mm. Failure to do > + * so could result in us missing the reserved CONTEXT in a future > + * version. > + */ > + for_each_possible_cpu(cpu) { > + if (per_cpu(reserved_context, cpu) == cntx) { > + hit = true; > + per_cpu(reserved_context, cpu) = newcntx; > + } > + } > + > + return hit; > +} > + > +/* Note: must be called with context_lock held */ > +static void __flush_context(void) > +{ > + int i; > + unsigned long cntx; > + > + /* Update the list of reserved ASIDs and the ASID bitmap. */ > + bitmap_clear(context_asid_map, 0, num_asids); > + > + /* Mark already acitve ASIDs as used */ > + for_each_possible_cpu(i) { > + cntx = atomic_long_xchg_relaxed(&per_cpu(active_context, i), 0); > + /* > + * If this CPU has already been through a rollover, but > + * hasn't run another task in the meantime, we must preserve > + * its reserved CONTEXT, as this is the only trace we have of > + * the process it is still running. > + */ > + if (cntx == 0) > + cntx = per_cpu(reserved_context, i); > + > + __set_bit(cntx & asid_mask, context_asid_map); > + per_cpu(reserved_context, i) = cntx; > + } > + > + /* Mark last ASID as used because it is used at boot-time */ > + __set_bit(asid_mask, context_asid_map); Looks unnecessary as we always start find_next_zero_bit from idx 1. > +} > + > +/* Note: must be called with context_lock held */ > +static unsigned long __new_context(struct mm_struct *mm, > + bool *need_tlb_flush) > +{ > + static u32 cur_idx = 1; > + unsigned long cntx = atomic_long_read(&mm->context.id); > + unsigned long asid, ver = atomic_long_read(¤t_version); > + > + if (cntx != 0) { > + unsigned long newcntx = ver | (cntx & ~asid_mask); Shouldn't this be cntx & asid_mask ? > + > + /* > + * If our current CONTEXT was active during a rollover, we > + * can continue to use it and this was just a false alarm. > + */ > + if (check_update_reserved_context(cntx, newcntx)) > + return newcntx; > + > + /* > + * We had a valid CONTEXT in a previous life, so try to > + * re-use it if possible. > + */ > + if (!__test_and_set_bit(cntx & asid_mask, context_asid_map)) > + return newcntx; > + } > + > + /* > + * Allocate a free ASID. If we can't find one then increment > + * current_version and flush all ASIDs. > + */ > + asid = find_next_zero_bit(context_asid_map, num_asids, cur_idx); > + if (asid != num_asids) > + goto set_asid; > + > + /* We're out of ASIDs, so increment current_version */ > + ver = atomic_long_add_return_relaxed(first_version, ¤t_version); > + > + /* Flush everything */ > + __flush_context(); > + *need_tlb_flush = true; > + > + /* We have more ASIDs than CPUs, so this will always succeed */ > + asid = find_next_zero_bit(context_asid_map, num_asids, 1); > + > +set_asid: > + __set_bit(asid, context_asid_map); > + cur_idx = asid; > + return asid | ver; > +} > + > +static void set_mm_asid(struct mm_struct *mm, unsigned int cpu) > +{ > + unsigned long flags; > + bool need_tlb_flush = false; > + unsigned long cntx, old_active_cntx; > + > + cntx = atomic_long_read(&mm->context.id); > + > + /* > + * If our active_context is non-zero and the context matches the > + * current_version, then we update the active_context entry with a > + * relaxed cmpxchg. > + * > + * Following is how we handle racing with a concurrent rollover: > + * > + * - We get a zero back from the cmpxchg and end up waiting on the > + * lock. Taking the lock synchronises with the rollover and so > + * we are forced to see the updated verion. > + * > + * - We get a valid context back from the cmpxchg then we continue > + * using old ASID because __flush_context() would have marked ASID > + * of active_context as used and next context switch we will allocate > + * new context. > + */ > + old_active_cntx = atomic_long_read(&per_cpu(active_context, cpu)); > + if (old_active_cntx && > + !((cntx ^ atomic_long_read(¤t_version)) >> asid_bits) && This looks hard to read. Probably (cntx &~ asid_mask) == atomic_long_read(¤t_version) is clearer. > + atomic_long_cmpxchg_relaxed(&per_cpu(active_context, cpu), > + old_active_cntx, cntx)) > + goto switch_mm_fast; > + > + raw_spin_lock_irqsave(&context_lock, flags); Any reason that we prefer raw_ here? > + > + /* Check that our ASID belongs to the current_version. */ > + cntx = atomic_long_read(&mm->context.id); > + if ((cntx ^ atomic_long_read(¤t_version)) >> asid_bits) { Same as above, probably (cntx &~ asid_mask) != atomic_long_read(¤t_version) makes more sense. > + cntx = __new_context(mm, &need_tlb_flush); > + atomic_long_set(&mm->context.id, cntx); > + } > + > + atomic_long_set(&per_cpu(active_context, cpu), cntx); > + > + raw_spin_unlock_irqrestore(&context_lock, flags); > + > +switch_mm_fast: > + /* > + * Use the old spbtr name instead of using the current satp > + * name to support binutils 2.29 which doesn't know about the > + * privileged ISA 1.10 yet. > + */ > + csr_write(sptbr, virt_to_pfn(mm->pgd) | > + ((cntx & asid_mask) << SATP_ASID_SHIFT) | > + SATP_MODE); > + > + if (need_tlb_flush) > + flush_tlb_all(); I think your intention here is to avoid calling flush_tlb_all when IRQs are off in the critical region. However, switch_mm will be called from scheduler as well which also turn irqs off, so this still cause issue. I think a better way is to force flush_tlb_all to use SBI when IRQs are off. What do you think? > +} > + > +static void set_mm_noasid(struct mm_struct *mm) > +{ > + /* > + * Use the old spbtr name instead of using the current satp > + * name to support binutils 2.29 which doesn't know about the > + * privileged ISA 1.10 yet. > + */ > + csr_write(sptbr, virt_to_pfn(mm->pgd) | SATP_MODE); > + > + /* > + * sfence.vma after SATP write. We call it on MM context instead of > + * calling local_flush_tlb_all to prevent global mappings from being > + * affected. > + */ > + local_flush_tlb_mm(mm); > +} > + > /* > * When necessary, performs a deferred icache flush for the given MM context, > * on the local CPU. RISC-V has no direct mechanism for instruction cache > @@ -58,20 +254,49 @@ void switch_mm(struct mm_struct *prev, struct mm_struct *next, > cpumask_clear_cpu(cpu, mm_cpumask(prev)); > cpumask_set_cpu(cpu, mm_cpumask(next)); > > - /* > - * Use the old spbtr name instead of using the current satp > - * name to support binutils 2.29 which doesn't know about the > - * privileged ISA 1.10 yet. > - */ > - csr_write(sptbr, virt_to_pfn(next->pgd) | SATP_MODE); > + if (use_asid_allocator) > + set_mm_asid(next, cpu); > + else > + set_mm_noasid(next); > + > + flush_icache_deferred(next); > +} > + > +static int asids_init(void) > +{ > + /* Figure-out number of ASID bits in HW */ > + asid_bits = (csr_read(sptbr) >> SATP_ASID_SHIFT) & SATP_ASID_MASK; > + asid_bits = fls_long(asid_bits); > + > + /* Pre-compute ASID details */ > + num_asids = 1 << asid_bits; > + asid_mask = num_asids - 1; > + first_version = num_asids; Is there any reason we want to have two set-once variables with same value? > > /* > - * sfence.vma after SATP write. We call it on MM context instead of > - * calling local_flush_tlb_all to prevent global mappings from being > - * affected. > + * Use ASID allocator only if number of HW ASIDs are > + * at-least twice more than CPUs > */ > - local_flush_tlb_mm(next); > + use_asid_allocator = > + (num_asids <= (2 * num_possible_cpus())) ? false : true; > > - flush_icache_deferred(next); > -} > + /* Setup ASID allocator if available */ > + if (use_asid_allocator) { > + atomic_long_set(¤t_version, first_version); > > + context_asid_map = kcalloc(BITS_TO_LONGS(num_asids), > + sizeof(*context_asid_map), GFP_KERNEL); > + if (!context_asid_map) > + panic("Failed to allocate bitmap for %lu ASIDs\n", > + num_asids); > + > + __set_bit(asid_mask, context_asid_map); > + > + pr_info("ASID allocator using %lu entries\n", num_asids); > + } else { If we decide not to use ASID allocator, we will need to set ASID field to zero on *all harts* before we do our first switch_mm. Otherwise we will end up a hart running non-zero ASID and another running zero ASID with different page table. > + pr_info("ASID allocator disabled\n"); > + } > + > + return 0; > +} > +early_initcall(asids_init); > _______________________________________________ linux-riscv mailing list linux-riscv@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-riscv