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=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,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 4F43CC433DF for ; Fri, 26 Jun 2020 12:02:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 18EDA2078D for ; Fri, 26 Jun 2020 12:02:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728048AbgFZMB7 (ORCPT ); Fri, 26 Jun 2020 08:01:59 -0400 Received: from szxga03-in.huawei.com ([45.249.212.189]:2531 "EHLO huawei.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726256AbgFZMB6 (ORCPT ); Fri, 26 Jun 2020 08:01:58 -0400 Received: from dggemi406-hub.china.huawei.com (unknown [172.30.72.56]) by Forcepoint Email with ESMTP id 9667551DE239E30D0C96; Fri, 26 Jun 2020 20:01:56 +0800 (CST) Received: from DGGEMI525-MBS.china.huawei.com ([169.254.6.126]) by dggemi406-hub.china.huawei.com ([10.3.17.144]) with mapi id 14.03.0487.000; Fri, 26 Jun 2020 20:01:45 +0800 From: "Song Bao Hua (Barry Song)" To: Robin Murphy , "hch@lst.de" , "m.szyprowski@samsung.com" , "will@kernel.org" , "ganapatrao.kulkarni@cavium.com" , "catalin.marinas@arm.com" CC: "iommu@lists.linux-foundation.org" , Linuxarm , "linux-arm-kernel@lists.infradead.org" , "linux-kernel@vger.kernel.org" , Jonathan Cameron , Nicolas Saenz Julienne , Steve Capper , Andrew Morton , Mike Rapoport Subject: RE: [PATCH v2 1/2] dma-direct: provide the ability to reserve per-numa CMA Thread-Topic: [PATCH v2 1/2] dma-direct: provide the ability to reserve per-numa CMA Thread-Index: AQHWSsSY8LnVWNMYkEmWpaJ1pqQoDKjoptmAgAIP9AA= Date: Fri, 26 Jun 2020 12:01:45 +0000 Message-ID: References: <20200625074330.13668-1-song.bao.hua@hisilicon.com> <20200625074330.13668-2-song.bao.hua@hisilicon.com> <11672f20-6011-1a70-8def-fc662f52d50f@arm.com> In-Reply-To: <11672f20-6011-1a70-8def-fc662f52d50f@arm.com> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.126.201.204] Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-CFilter-Loop: Reflected Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogbGludXgta2VybmVsLW93 bmVyQHZnZXIua2VybmVsLm9yZw0KPiBbbWFpbHRvOmxpbnV4LWtlcm5lbC1vd25lckB2Z2VyLmtl cm5lbC5vcmddIE9uIEJlaGFsZiBPZiBSb2JpbiBNdXJwaHkNCj4gU2VudDogVGh1cnNkYXksIEp1 bmUgMjUsIDIwMjAgMTE6MTEgUE0NCj4gVG86IFNvbmcgQmFvIEh1YSAoQmFycnkgU29uZykgPHNv bmcuYmFvLmh1YUBoaXNpbGljb24uY29tPjsgaGNoQGxzdC5kZTsNCj4gbS5zenlwcm93c2tpQHNh bXN1bmcuY29tOyB3aWxsQGtlcm5lbC5vcmc7DQo+IGdhbmFwYXRyYW8ua3Vsa2FybmlAY2F2aXVt LmNvbTsgY2F0YWxpbi5tYXJpbmFzQGFybS5jb20NCj4gQ2M6IGlvbW11QGxpc3RzLmxpbnV4LWZv dW5kYXRpb24ub3JnOyBMaW51eGFybSA8bGludXhhcm1AaHVhd2VpLmNvbT47DQo+IGxpbnV4LWFy bS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZzsgbGludXgta2VybmVsQHZnZXIua2VybmVsLm9y ZzsgSm9uYXRoYW4NCj4gQ2FtZXJvbiA8am9uYXRoYW4uY2FtZXJvbkBodWF3ZWkuY29tPjsgTmlj b2xhcyBTYWVueiBKdWxpZW5uZQ0KPiA8bnNhZW56anVsaWVubmVAc3VzZS5kZT47IFN0ZXZlIENh cHBlciA8c3RldmUuY2FwcGVyQGFybS5jb20+OyBBbmRyZXcNCj4gTW9ydG9uIDxha3BtQGxpbnV4 LWZvdW5kYXRpb24ub3JnPjsgTWlrZSBSYXBvcG9ydCA8cnBwdEBsaW51eC5pYm0uY29tPg0KPiBT dWJqZWN0OiBSZTogW1BBVENIIHYyIDEvMl0gZG1hLWRpcmVjdDogcHJvdmlkZSB0aGUgYWJpbGl0 eSB0byByZXNlcnZlDQo+IHBlci1udW1hIENNQQ0KPiANCj4gT24gMjAyMC0wNi0yNSAwODo0Mywg QmFycnkgU29uZyB3cm90ZToNCj4gPiBUaGlzIGlzIHVzZWZ1bCBmb3IgYXQgbGVhc3QgdHdvIHNj ZW5hcmlvczoNCj4gPiAxLiBBUk02NCBzbW11IHdpbGwgZ2V0IG1lbW9yeSBmcm9tIGxvY2FsIG51 bWEgbm9kZSwgaXQgY2FuIHNhdmUgaXRzDQo+ID4gY29tbWFuZCBxdWV1ZXMgYW5kIHBhZ2UgdGFi bGVzIGxvY2FsbHkuIFRlc3RzIHNob3cgaXQgY2FuIGRlY3JlYXNlDQo+ID4gZG1hX3VubWFwIGxh dGVuY3kgYXQgbG90LiBGb3IgZXhhbXBsZSwgd2l0aG91dCB0aGlzIHBhdGNoLCBzbW11IG9uDQo+ ID4gbm9kZTIgd2lsbCBnZXQgbWVtb3J5IGZyb20gbm9kZTAgYnkgY2FsbGluZyBkbWFfYWxsb2Nf Y29oZXJlbnQoKSwNCj4gPiB0eXBpY2FsbHksIGl0IGhhcyB0byB3YWl0IGZvciBtb3JlIHRoYW4g NTYwbnMgZm9yIHRoZSBjb21wbGV0aW9uIG9mDQo+ID4gQ01EX1NZTkMgaW4gYW4gZW1wdHkgY29t bWFuZCBxdWV1ZTsgd2l0aCB0aGlzIHBhdGNoLCBpdCBuZWVkcyAyNDBucw0KPiA+IG9ubHkuDQo+ ID4gMi4gd2hlbiB3ZSBzZXQgaW9tbXUgcGFzc3Rocm91Z2gsIGRyaXZlcnMgd2lsbCBnZXQgbWVt b3J5IGZyb20gQ01BLA0KPiA+IGxvY2FsIG1lbW9yeSBtZWFucyBtdWNoIGxlc3MgbGF0ZW5jeS4N Cj4gPg0KPiA+IENjOiBKb25hdGhhbiBDYW1lcm9uIDxKb25hdGhhbi5DYW1lcm9uQGh1YXdlaS5j b20+DQo+ID4gQ2M6IENocmlzdG9waCBIZWxsd2lnIDxoY2hAbHN0LmRlPg0KPiA+IENjOiBNYXJl ayBTenlwcm93c2tpIDxtLnN6eXByb3dza2lAc2Ftc3VuZy5jb20+DQo+ID4gQ2M6IFdpbGwgRGVh Y29uIDx3aWxsQGtlcm5lbC5vcmc+DQo+ID4gQ2M6IFJvYmluIE11cnBoeSA8cm9iaW4ubXVycGh5 QGFybS5jb20+DQo+ID4gQ2M6IEdhbmFwYXRyYW8gS3Vsa2FybmkgPGdhbmFwYXRyYW8ua3Vsa2Fy bmlAY2F2aXVtLmNvbT4NCj4gPiBDYzogQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNA YXJtLmNvbT4NCj4gPiBDYzogTmljb2xhcyBTYWVueiBKdWxpZW5uZSA8bnNhZW56anVsaWVubmVA c3VzZS5kZT4NCj4gPiBDYzogU3RldmUgQ2FwcGVyIDxzdGV2ZS5jYXBwZXJAYXJtLmNvbT4NCj4g PiBDYzogQW5kcmV3IE1vcnRvbiA8YWtwbUBsaW51eC1mb3VuZGF0aW9uLm9yZz4NCj4gPiBDYzog TWlrZSBSYXBvcG9ydCA8cnBwdEBsaW51eC5pYm0uY29tPg0KPiA+IFNpZ25lZC1vZmYtYnk6IEJh cnJ5IFNvbmcgPHNvbmcuYmFvLmh1YUBoaXNpbGljb24uY29tPg0KPiA+IC0tLQ0KPiA+ICAgaW5j bHVkZS9saW51eC9kbWEtY29udGlndW91cy5oIHwgIDQgKysNCj4gPiAgIGtlcm5lbC9kbWEvS2Nv bmZpZyAgICAgICAgICAgICB8IDEwICsrKysNCj4gPiAgIGtlcm5lbC9kbWEvY29udGlndW91cy5j ICAgICAgICB8IDk5DQo+ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0NCj4gPiAg IDMgZmlsZXMgY2hhbmdlZCwgMTA0IGluc2VydGlvbnMoKyksIDkgZGVsZXRpb25zKC0pDQo+ID4N Cj4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWEtY29udGlndW91cy5oDQo+IGIvaW5j bHVkZS9saW51eC9kbWEtY29udGlndW91cy5oDQo+ID4gaW5kZXggMDNmOGU5OGUzYmNjLi4yNzhh ODBhNDA0NTYgMTAwNjQ0DQo+ID4gLS0tIGEvaW5jbHVkZS9saW51eC9kbWEtY29udGlndW91cy5o DQo+ID4gKysrIGIvaW5jbHVkZS9saW51eC9kbWEtY29udGlndW91cy5oDQo+ID4gQEAgLTc5LDYg Kzc5LDggQEAgc3RhdGljIGlubGluZSB2b2lkIGRtYV9jb250aWd1b3VzX3NldF9kZWZhdWx0KHN0 cnVjdA0KPiBjbWEgKmNtYSkNCj4gPg0KPiA+ICAgdm9pZCBkbWFfY29udGlndW91c19yZXNlcnZl KHBoeXNfYWRkcl90IGFkZHJfbGltaXQpOw0KPiA+DQo+ID4gK3ZvaWQgZG1hX3Blcm51bWFfY21h X3Jlc2VydmUodm9pZCk7DQo+ID4gKw0KPiA+ICAgaW50IF9faW5pdCBkbWFfY29udGlndW91c19y ZXNlcnZlX2FyZWEocGh5c19hZGRyX3Qgc2l6ZSwgcGh5c19hZGRyX3QNCj4gYmFzZSwNCj4gPiAg IAkJCQkgICAgICAgcGh5c19hZGRyX3QgbGltaXQsIHN0cnVjdCBjbWEgKipyZXNfY21hLA0KPiA+ ICAgCQkJCSAgICAgICBib29sIGZpeGVkKTsNCj4gPiBAQCAtMTI4LDYgKzEzMCw4IEBAIHN0YXRp YyBpbmxpbmUgdm9pZCBkbWFfY29udGlndW91c19zZXRfZGVmYXVsdChzdHJ1Y3QNCj4gY21hICpj bWEpIHsgfQ0KPiA+DQo+ID4gICBzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2NvbnRpZ3VvdXNfcmVz ZXJ2ZShwaHlzX2FkZHJfdCBsaW1pdCkgeyB9DQo+ID4NCj4gPiArc3RhdGljIGlubGluZSB2b2lk IGRtYV9wZXJudW1hX2NtYV9yZXNlcnZlKHZvaWQpIHsgfQ0KPiA+ICsNCj4gPiAgIHN0YXRpYyBp bmxpbmUgaW50IGRtYV9jb250aWd1b3VzX3Jlc2VydmVfYXJlYShwaHlzX2FkZHJfdCBzaXplLA0K PiBwaHlzX2FkZHJfdCBiYXNlLA0KPiA+ICAgCQkJCSAgICAgICBwaHlzX2FkZHJfdCBsaW1pdCwg c3RydWN0IGNtYSAqKnJlc19jbWEsDQo+ID4gICAJCQkJICAgICAgIGJvb2wgZml4ZWQpDQo+ID4g ZGlmZiAtLWdpdCBhL2tlcm5lbC9kbWEvS2NvbmZpZyBiL2tlcm5lbC9kbWEvS2NvbmZpZw0KPiA+ IGluZGV4IGQwMDY2NjhjMDAyNy4uYWViOTc2YjFkMjFjIDEwMDY0NA0KPiA+IC0tLSBhL2tlcm5l bC9kbWEvS2NvbmZpZw0KPiA+ICsrKyBiL2tlcm5lbC9kbWEvS2NvbmZpZw0KPiA+IEBAIC0xMDQs NiArMTA0LDE2IEBAIGNvbmZpZyBETUFfQ01BDQo+ID4gICBpZiAgRE1BX0NNQQ0KPiA+ICAgY29t bWVudCAiRGVmYXVsdCBjb250aWd1b3VzIG1lbW9yeSBhcmVhIHNpemU6Ig0KPiA+DQo+ID4gK2Nv bmZpZyBDTUFfUEVSTlVNQV9TSVpFX01CWVRFUw0KPiA+ICsJaW50ICJTaXplIGluIE1lZ2EgQnl0 ZXMgZm9yIHBlci1udW1hIENNQSBhcmVhcyINCj4gPiArCWRlcGVuZHMgb24gTlVNQQ0KPiA+ICsJ ZGVmYXVsdCAxNiBpZiBBUk02NA0KPiA+ICsJZGVmYXVsdCAwDQo+ID4gKwloZWxwDQo+ID4gKwkg IERlZmluZXMgdGhlIHNpemUgKGluIE1pQikgb2YgdGhlIHBlci1udW1hIG1lbW9yeSBhcmVhIGZv ciBDb250aWd1b3VzDQo+ID4gKwkgIE1lbW9yeSBBbGxvY2F0b3IuIEV2ZXJ5IG51bWEgbm9kZSB3 aWxsIGdldCBhIHNlcGFyYXRlIENNQSB3aXRoIHRoaXMNCj4gPiArCSAgc2l6ZS4gSWYgdGhlIHNp emUgb2YgMCBpcyBzZWxlY3RlZCwgcGVyLW51bWEgQ01BIGlzIGRpc2FibGVkLg0KPiA+ICsNCj4g DQo+IEkgdGhpbmsgdGhpcyBuZWVkcyB0byBiZSBjbGV2ZXJlciB0aGFuIGp1c3QgYSBzdGF0aWMg Y29uZmlnIG9wdGlvbi4NCj4gUHJldHR5IG11Y2ggZXZlcnl0aGluZyBlbHNlIENNQS1yZWxhdGVk IGlzIHJ1bnRpbWUtY29uZmlndXJhYmxlIHRvIHNvbWUNCj4gZGVncmVlLCBhbmQgZG9pbmcgYW55 IHBlci1ub2RlIHNldHVwIHdoZW4gYm9vdGluZyBvbiBhIHNpbmdsZS1ub2RlDQo+IHN5c3RlbSB3 b3VsZCBiZSB3YXN0ZWQgZWZmb3J0Lg0KDQpJIGFncmVlIHNvbWUgZHluYW1pYyBjb25maWd1cmF0 aW9uIHNob3VsZCBiZSBzdXBwb3J0ZWQgdG8gc2V0IHRoZSBzaXplIG9mIGNtYS4NCkl0IGNvdWxk IGJlIGEga2VybmVsIHBhcmFtZXRlciBib290YXJncywgb3IgbGV2ZXJhZ2UgYW4gZXhpc3Rpbmcg cGFyYW1ldGVyLg0KDQpGb3IgYSBzeXN0ZW0gd2l0aCBOVU1BIGVuYWJsZWQsIGJ1dCB3aXRoIG9u bHkgb25lIG5vZGUgb3IgYWN0dWFsbHkgbm9uLW51bWEsIA0KdGhlIGN1cnJlbnQgZG1hX3Blcm51 bWFfY21hX3Jlc2VydmUoKSB3b24ndCBkbyBhbnl0aGluZzoNCg0Kdm9pZCBfX2luaXQgZG1hX3Bl cm51bWFfY21hX3Jlc2VydmUodm9pZCkNCnsNCglpbnQgbmlkOw0KDQoJaWYgKCFwZXJudW1hX3Np emVfYnl0ZXMgfHwgbnJfb25saW5lX25vZGVzIDw9IDEpDQoJCXJldHVybjsNCn0NCg0KPiANCj4g U2luY2UgdGhpcyBpcyBjb25jZXB0dWFsbHkgdmVyeSBzaW1pbGFyIHRvIHRoZSBleGlzdGluZyBo dWdldGxiX2NtYQ0KPiBpbXBsZW1lbnRhdGlvbiBJJ20gYWxzbyB3b25kZXJpbmcgYWJvdXQgaW5j b25zaXN0ZW5jeSB3aXRoIHJlc3BlY3QgdG8NCj4gc3BlY2lmeWluZyBwZXItbm9kZSB2cy4gdG90 YWwgc2l6ZXMuDQoNCkZvciBodWdldGxiY21hLCBwZXJudW1hIGNtYSBzaXplIGlzOiB0b3RhbF9z aXplL3RoZSBudW1iZXIgb2Ygbm9kZXMNCkl0IGlzIHF1aXRlIHNpbXBsZS4NCg0KQnV0IGZvciBE TUEsIG5vZGUwJ3MgQ01BIG1pZ2h0IHN1cHBvcnQgYWRkcmVzcyBsaW1pdGF0aW9uIGZvciBvbGQN CmRldmljZXMgd2hpY2ggYWxsb2NhdGUgbWVtb3J5IGJ5IEdGUF9ETUEoMzIpLg0KDQo+IA0KPiBB bm90aGVyIHRob3VnaHQsIHRob3VnaCwgaXMgdGhhdCBzeXN0ZW1zIGxhcmdlIGVub3VnaCB0byBo YXZlIG11bHRpcGxlDQo+IE5VTUEgbm9kZXMgdGVuZCBub3QgdG8gYmUgc2hvcnQgb24gbWVtb3J5 LCBzbyBpdCBtaWdodCBub3QgYmUNCj4gdW5yZWFzb25hYmxlIHRvIGJhc2UgdGhpcyBhbGwgb24g d2hhdGV2ZXIgc2l6ZSB0aGUgZGVmYXVsdCBhcmVhIGlzDQo+IGdpdmVuLCBhbmQgc2ltcGx5IGhh dmUgYSBiaW5hcnkgb24vb2ZmIHN3aXRjaCB0byBjb250cm9sIHRoZSBwZXItbm9kZQ0KPiBhc3Bl Y3QuDQoNCkkgZG9uJ3QgbWluZCBhcHBseWluZyB0aGUgZGVmYXVsdCBzaXplIHRvIGFsbCBOVU1B IG5vZGVzIGFzIGdlbmVyYWxseSBhIHNlcnZlcg0KaGFzIGxhcmdlciBtZW1vcnkgdGhhbiBlbWJl ZGRlZCBzeXN0ZW0uDQpPbmUgaXNzdWUgaXMgdGhhdCB0aGUgZGVmYXVsdCBnbG9iYWwgQ01BIGlz IG9uIG5vZGUwLCBhbmQgaWYgdGhlIGNvZGUgYXBwbGllcyB0aGUgZGVmYXVsdCBzaXplIHRvDQpl dmVyeSBub2RlLCB0aGUgZGVmYXVsdCBjbWEgaXMgYmV0dGVyIHRvIGFsc28gYXMgbm9kZTAncyBw ZXJudW1hIGNtYSB0b28uIE90aGVyd2lzZSwgdGhlcmUNCndvdWxkIGJlIHR3byBDTUEgd2l0aCBz YW1lIHNpemUgb24gbm9kZTAuIA0KDQpTbyB0aGUgY29kZSBjYW4gYnlwYXNzIG5vZGUwIHdoaWxl IGNyZWF0aW5nIHBlci1udW1hIENNQS4NCg0KT24gdGhlIG90aGVyIGhhbmQsIG9ubHkgQ01BIG9u IG5vZGUwIHN1cHBvcnQgYWRkcmVzcyBsaW1pdGF0aW9uIGZvciBvbGQgZGV2aWNlcw0KYXMgaXRz IG1lbW9yeSBpcyBpbiBsb3cgcGh5c2ljYWwgYWRkcmVzcy4NClRoYXQgaXMgcHJvYmFibHkgd2h5 IHRoZSBjbWEgb2Ygbm9kZTAgc3RpbGwgbmVlZCB0byBiZSBoYW5kbGVkIHNlcGFyYXRlbHkuDQoN ClNvIG5vZGUwJ3MgQ01BIHdpbGwgYmUgYm90aCBkZWZhdWx0IGdsb2JhbCBDTUEgYW5kIHBlci1O VU1BIENNQSBvZiBub2RlMC4NCg0KPiANCj4gPiAgIGNvbmZpZyBDTUFfU0laRV9NQllURVMNCj4g PiAgIAlpbnQgIlNpemUgaW4gTWVnYSBCeXRlcyINCj4gPiAgIAlkZXBlbmRzIG9uICFDTUFfU0la RV9TRUxfUEVSQ0VOVEFHRQ0KPiA+IGRpZmYgLS1naXQgYS9rZXJuZWwvZG1hL2NvbnRpZ3VvdXMu YyBiL2tlcm5lbC9kbWEvY29udGlndW91cy5jDQo+ID4gaW5kZXggMTViYzUwMjZjNDg1Li5iY2Jk NTNhZWFkOTMgMTAwNjQ0DQo+ID4gLS0tIGEva2VybmVsL2RtYS9jb250aWd1b3VzLmMNCj4gPiAr KysgYi9rZXJuZWwvZG1hL2NvbnRpZ3VvdXMuYw0KPiA+IEBAIC0zMCw3ICszMCwxNCBAQA0KPiA+ ICAgI2RlZmluZSBDTUFfU0laRV9NQllURVMgMA0KPiA+ICAgI2VuZGlmDQo+ID4NCj4gPiArI2lm ZGVmIENPTkZJR19DTUFfUEVSTlVNQV9TSVpFX01CWVRFUw0KPiA+ICsjZGVmaW5lIENNQV9TSVpF X1BFUk5VTUFfTUJZVEVTDQo+IENPTkZJR19DTUFfUEVSTlVNQV9TSVpFX01CWVRFUw0KPiA+ICsj ZWxzZQ0KPiA+ICsjZGVmaW5lIENNQV9TSVpFX1BFUk5VTUFfTUJZVEVTIDANCj4gPiArI2VuZGlm DQo+ID4gKw0KPiA+ICAgc3RydWN0IGNtYSAqZG1hX2NvbnRpZ3VvdXNfZGVmYXVsdF9hcmVhOw0K PiA+ICtzdGF0aWMgc3RydWN0IGNtYSAqZG1hX2NvbnRpZ3VvdXNfcGVybnVtYV9hcmVhW01BWF9O VU1OT0RFU107DQo+ID4NCj4gPiAgIC8qDQo+ID4gICAgKiBEZWZhdWx0IGdsb2JhbCBDTUEgYXJl YSBzaXplIGNhbiBiZSBkZWZpbmVkIGluIGtlcm5lbCdzIC5jb25maWcuDQo+ID4gQEAgLTQ0LDYg KzUxLDggQEAgc3RydWN0IGNtYSAqZG1hX2NvbnRpZ3VvdXNfZGVmYXVsdF9hcmVhOw0KPiA+ICAg ICovDQo+ID4gICBzdGF0aWMgY29uc3QgcGh5c19hZGRyX3Qgc2l6ZV9ieXRlcyBfX2luaXRjb25z dCA9DQo+ID4gICAJKHBoeXNfYWRkcl90KUNNQV9TSVpFX01CWVRFUyAqIFNaXzFNOw0KPiA+ICtz dGF0aWMgY29uc3QgcGh5c19hZGRyX3QgcGVybnVtYV9zaXplX2J5dGVzIF9faW5pdGNvbnN0ID0N Cj4gPiArCShwaHlzX2FkZHJfdClDTUFfU0laRV9QRVJOVU1BX01CWVRFUyAqIFNaXzFNOw0KPiA+ ICAgc3RhdGljIHBoeXNfYWRkcl90ICBzaXplX2NtZGxpbmUgX19pbml0ZGF0YSA9IC0xOw0KPiA+ ICAgc3RhdGljIHBoeXNfYWRkcl90IGJhc2VfY21kbGluZSBfX2luaXRkYXRhOw0KPiA+ICAgc3Rh dGljIHBoeXNfYWRkcl90IGxpbWl0X2NtZGxpbmUgX19pbml0ZGF0YTsNCj4gPiBAQCAtOTYsNiAr MTA1LDMzIEBAIHN0YXRpYyBpbmxpbmUgX19tYXliZV91bnVzZWQgcGh5c19hZGRyX3QNCj4gY21h X2Vhcmx5X3BlcmNlbnRfbWVtb3J5KHZvaWQpDQo+ID4NCj4gPiAgICNlbmRpZg0KPiA+DQo+ID4g K3ZvaWQgX19pbml0IGRtYV9wZXJudW1hX2NtYV9yZXNlcnZlKHZvaWQpDQo+ID4gK3sNCj4gPiAr CWludCBuaWQ7DQo+ID4gKw0KPiA+ICsJaWYgKCFwZXJudW1hX3NpemVfYnl0ZXMgfHwgbnJfb25s aW5lX25vZGVzIDw9IDEpDQo+ID4gKwkJcmV0dXJuOw0KPiA+ICsNCj4gPiArCWZvcl9lYWNoX25v ZGVfc3RhdGUobmlkLCBOX09OTElORSkgew0KPiANCj4gRG8gd2UgbmVlZC93YW50IG5vdGlmaWVy cyB0byBoYW5kbGUgY3VycmVudGx5LW9mZmxpbmUgbm9kZXMgY29taW5nDQo+IG9ubGluZSBsYXRl ciAoSSdtIG5vdCBzdXJlIG9mZi1oYW5kIGhvdyBOVU1BIGludGVyYWN0cyB3aXRoIHN0dWZmIGxp a2UNCj4gIm1heGNwdXM9biIpPw0KDQpJIGhhZCBhIHRyeS4NCg0KRm9yIGV4YW1wbGUsIGlmIHRo ZSBoYXJkd2FyZSBoYXMgNCBudW1hIG5vZGVzIGFuZCBlYWNoIG9uZSBoYXMgMjQgQ1BVcy4NCg0K U2V0dGluZyBtYXhjcHVzPTIwIHdpbGwgcmVzdWx0IGluOg0KDQo0IG51bWEgbm9kZXMgYXJlIGFs bCBvbmxpbmUgYWZ0ZXIgYXJtNjRfbnVtYV9pbml0KCkgOw0KQ1BVMC0xOSBpcyBvbmxpbmU7DQpD UFUyMC05NSBpcyBvZmZsaW5lOw0KDQokY2F0IC9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdTAv b25saW5lIA0KMQ0KDQokY2F0IC9zeXMvZGV2aWNlcy9zeXN0ZW0vY3B1L2NwdTI0L29ubGluZSAN CjANCg0KJGNhdCAvc3lzL2RldmljZXMvc3lzdGVtL2NwdS9jcHU1MC9vbmxpbmUgDQowDQoNCkJ1 dCB0aGUgcHJpbnRrIHN0aWxsIHByaW50IDQgaGVyZToNCg0KLS0tIGEvYXJjaC9hcm02NC9tbS9p bml0LmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICANCisrKyBiL2FyY2gvYXJtNjQvbW0vaW5pdC5jICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgDQpAQCAtNDIwLDYgKzQyMCw4IEBAIHZvaWQgX19pbml0IGJvb3RtZW1faW5pdCh2b2lk KQ0KDQogICAgICAgIGFybTY0X251bWFfaW5pdCgpOyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA0KDQorICAgICAg IHByaW50aygiJXMgbnJfb25saW5lX25vZGUgOiVkXG4iLCBfX2Z1bmNfXywgbnJfb25saW5lX25v ZGVzKTsNCisNCiAgICAgICAgLyogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQogICAg ICAgICAqIG11c3QgYmUgZG9uZSBhZnRlciBhcm02NF9udW1hX2luaXQoKSB3aGljaCBjYWxscyBu dW1hX2luaXQoKSB0byAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA0KICAgICAgICAgKiBpbml0aWFs aXplIG5vZGVfb25saW5lX21hcCB0aGF0IGdldHMgdXNlZCBpbiBodWdldGxiX2NtYV9yZXNlcnZl KCkgICAgDQoNCj4gDQo+ID4gKwkJaW50IHJldDsNCj4gPiArCQljaGFyIG5hbWVbMjBdOw0KPiA+ ICsNCj4gPiArCQlzbnByaW50ZihuYW1lLCBzaXplb2YobmFtZSksICJwZXJudW1hJWQiLCBuaWQp Ow0KPiA+ICsJCXJldCA9IGNtYV9kZWNsYXJlX2NvbnRpZ3VvdXNfbmlkKDAsIHBlcm51bWFfc2l6 ZV9ieXRlcywgMCwgMCwNCj4gPiArCQkJCQkJIDAsIGZhbHNlLCBuYW1lLA0KPiA+ICsJCQkJCQkg JmRtYV9jb250aWd1b3VzX3Blcm51bWFfYXJlYVtuaWRdLA0KPiA+ICsJCQkJCQkgbmlkKTsNCj4g PiArCQlpZiAocmV0KSB7DQo+ID4gKwkJCXByX3dhcm4oIiVzOiByZXNlcnZhdGlvbiBmYWlsZWQ6 IGVyciAlZCwgbm9kZSAlZCIsIF9fZnVuY19fLA0KPiA+ICsJCQkJcmV0LCBuaWQpOw0KPiA+ICsJ CQljb250aW51ZTsNCj4gPiArCQl9DQo+ID4gKw0KPiA+ICsJCXByX2RlYnVnKCIlczogcmVzZXJ2 ZWQgJWxsdSBNaUIgb24gbm9kZSAlZFxuIiwgX19mdW5jX18sDQo+ID4gKwkJCSh1bnNpZ25lZCBs b25nIGxvbmcpcGVybnVtYV9zaXplX2J5dGVzIC8gU1pfMU0sIG5pZCk7DQo+ID4gKwl9DQo+ID4g K30NCj4gPiArDQo+ID4gICAvKioNCj4gPiAgICAqIGRtYV9jb250aWd1b3VzX3Jlc2VydmUoKSAt IHJlc2VydmUgYXJlYShzKSBmb3IgY29udGlndW91cyBtZW1vcnkNCj4gaGFuZGxpbmcNCj4gPiAg ICAqIEBsaW1pdDogRW5kIGFkZHJlc3Mgb2YgdGhlIHJlc2VydmVkIG1lbW9yeSAob3B0aW9uYWws IDAgZm9yIGFueSkuDQo+ID4gQEAgLTIyMiwyMiArMjU4LDMxIEBAIGJvb2wgZG1hX3JlbGVhc2Vf ZnJvbV9jb250aWd1b3VzKHN0cnVjdCBkZXZpY2UNCj4gKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2Vz LA0KPiA+ICAgICogQGdmcDogICBBbGxvY2F0aW9uIGZsYWdzLg0KPiA+ICAgICoNCj4gPiAgICAq IFRoaXMgZnVuY3Rpb24gYWxsb2NhdGVzIGNvbnRpZ3VvdXMgbWVtb3J5IGJ1ZmZlciBmb3Igc3Bl Y2lmaWVkIGRldmljZS4NCj4gSXQNCj4gPiAtICogdHJpZXMgdG8gdXNlIGRldmljZSBzcGVjaWZp YyBjb250aWd1b3VzIG1lbW9yeSBhcmVhIGlmIGF2YWlsYWJsZSwgb3IgdGhlDQo+ID4gLSAqIGRl ZmF1bHQgZ2xvYmFsIG9uZS4NCj4gPiArICogdHJpZXMgdG8gdXNlIGRldmljZSBzcGVjaWZpYyBj b250aWd1b3VzIG1lbW9yeSBhcmVhIGlmIGF2YWlsYWJsZSwgb3IgaXQNCj4gPiArICogdHJpZXMg dG8gdXNlIHBlci1udW1hIGNtYSwgaWYgdGhlIGFsbG9jYXRpb24gZmFpbHMsIGl0IHdpbGwgZmFs bGJhY2sgdG8NCj4gPiArICogdHJ5IGRlZmF1bHQgZ2xvYmFsIG9uZS4NCj4gPiAgICAqDQo+ID4g LSAqIE5vdGUgdGhhdCBpdCBieWFwc3Mgb25lLXBhZ2Ugc2l6ZSBvZiBhbGxvY2F0aW9ucyBmcm9t IHRoZSBnbG9iYWwgYXJlYSBhcw0KPiA+IC0gKiB0aGUgYWRkcmVzc2VzIHdpdGhpbiBvbmUgcGFn ZSBhcmUgYWx3YXlzIGNvbnRpZ3VvdXMsIHNvIHRoZXJlIGlzIG5vIG5lZWQNCj4gPiAtICogdG8g d2FzdGUgQ01BIHBhZ2VzIGZvciB0aGF0IGtpbmQ7IGl0IGFsc28gaGVscHMgcmVkdWNlIGZyYWdt ZW50YXRpb25zLg0KPiA+ICsgKiBOb3RlIHRoYXQgaXQgYnlwYXNzIG9uZS1wYWdlIHNpemUgb2Yg YWxsb2NhdGlvbnMgZnJvbSB0aGUgcGVyLW51bWEgYW5kDQo+ID4gKyAqIGdsb2JhbCBhcmVhIGFz IHRoZSBhZGRyZXNzZXMgd2l0aGluIG9uZSBwYWdlIGFyZSBhbHdheXMgY29udGlndW91cywgc28N Cj4gPiArICogdGhlcmUgaXMgbm8gbmVlZCB0byB3YXN0ZSBDTUEgcGFnZXMgZm9yIHRoYXQga2lu ZDsgaXQgYWxzbyBoZWxwcyByZWR1Y2UNCj4gPiArICogZnJhZ21lbnRhdGlvbnMuDQo+ID4gICAg Ki8NCj4gPiAgIHN0cnVjdCBwYWdlICpkbWFfYWxsb2NfY29udGlndW91cyhzdHJ1Y3QgZGV2aWNl ICpkZXYsIHNpemVfdCBzaXplLCBnZnBfdA0KPiBnZnApDQo+ID4gICB7DQo+ID4gICAJc2l6ZV90 IGNvdW50ID0gc2l6ZSA+PiBQQUdFX1NISUZUOw0KPiA+ICAgCXN0cnVjdCBwYWdlICpwYWdlID0g TlVMTDsNCj4gPiAgIAlzdHJ1Y3QgY21hICpjbWEgPSBOVUxMOw0KPiA+ICsJaW50IG5pZCA9IGRl diA/IGRldl90b19ub2RlKGRldikgOiBOVU1BX05PX05PREU7DQo+IA0KPiBkZXYgc2hvdWxkIG5l dmVyIGJlIE5VTEwgaGVyZSAodGhlIGV4aXN0aW5nIGNoZWNrIGJlbG93IGNvdWxkIGJlIGNsZWFu ZWQNCj4gdXAgaWYgd2UncmUgcmVmYWN0b3JpbmcgYW55d2F5KS4NCg0KSXQgd2FzIG5vdCBkb25l IGluIHYxLiBCdXQga2VybmVsIHRlc3Qgcm9ib3QgcmVwb3J0ZWQgaXNzdWUgbGlrZSANCg0KInNt YXRjaCB3YXJuaW5nczoNCmtlcm5lbC9kbWEvY29udGlndW91cy5jOjI3NCBkbWFfYWxsb2NfY29u dGlndW91cygpIHdhcm46IHZhcmlhYmxlIGRlcmVmZXJlbmNlZCBiZWZvcmUgXA0KY2hlY2sgJ2Rl dicgKHNlZSBsaW5lIDI3MikiDQoNCmh0dHBzOi8vbWFyYy5pbmZvLz9sPWxpbnV4LWFybS1rZXJu ZWwmbT0xNTkxMjcwNzYyMDg3ODAmdz0yDQoNCj4gDQo+ID4gKwlib29sIGFsbG9jX2Zyb21fcGVy bnVtYSA9IGZhbHNlOw0KPiA+DQo+ID4gICAJaWYgKGRldiAmJiBkZXYtPmNtYV9hcmVhKQ0KPiA+ ICAgCQljbWEgPSBkZXYtPmNtYV9hcmVhOw0KPiA+IC0JZWxzZSBpZiAoY291bnQgPiAxKQ0KPiA+ ICsJZWxzZSBpZiAoKG5pZCAhPSBOVU1BX05PX05PREUpICYmDQo+IGRtYV9jb250aWd1b3VzX3Bl cm51bWFfYXJlYVtuaWRdDQo+ID4gKwkJJiYgIShnZnAgJiAoR0ZQX0RNQSB8IEdGUF9ETUEzMikp DQo+ID4gKwkJJiYgKGNvdW50ID4gMSkpIHsNCj4gPiArCQljbWEgPSBkbWFfY29udGlndW91c19w ZXJudW1hX2FyZWFbbmlkXTsNCj4gPiArCQlhbGxvY19mcm9tX3Blcm51bWEgPSB0cnVlOw0KPiA+ ICsJfSBlbHNlIGlmIChjb3VudCA+IDEpDQo+IA0KPiBXZWxsIHRoaXMgaXMgYSBiaWcgdWdseSBt ZXNzLi4uIEknZCBzdWdnZXN0IHJlc3RydWN0dXJpbmcgdGhlIHdob2xlDQo+IGZ1bmN0aW9uIHRv IGJhaWwgb3V0IGltbWVkaWF0ZWx5IGlmIChjb3VudCA9PSAxICYmICFkZXYtPmNtYV9hcmVhKSwg dGhlbg0KPiB0cnkgdGhlIHBlci1kZXZpY2UsIHBlci1ub2RlIGFuZCBkZWZhdWx0IGFyZWFzIGlu IHR1cm4gdW50aWwgc29tZXRoaW5nDQo+IHdvcmtzLg0KDQpBZ3JlZWQNCg0KPiANCj4gPiAgIAkJ Y21hID0gZG1hX2NvbnRpZ3VvdXNfZGVmYXVsdF9hcmVhOw0KPiA+DQo+ID4gICAJLyogQ01BIGNh biBiZSB1c2VkIG9ubHkgaW4gdGhlIGNvbnRleHQgd2hpY2ggcGVybWl0cyBzbGVlcGluZyAqLw0K PiA+IEBAIC0yNDYsNiArMjkxLDExIEBAIHN0cnVjdCBwYWdlICpkbWFfYWxsb2NfY29udGlndW91 cyhzdHJ1Y3QgZGV2aWNlDQo+ICpkZXYsIHNpemVfdCBzaXplLCBnZnBfdCBnZnApDQo+ID4gICAJ CXNpemVfdCBjbWFfYWxpZ24gPSBtaW5fdChzaXplX3QsIGFsaWduLCBDT05GSUdfQ01BX0FMSUdO TUVOVCk7DQo+ID4NCj4gPiAgIAkJcGFnZSA9IGNtYV9hbGxvYyhjbWEsIGNvdW50LCBjbWFfYWxp Z24sIGdmcCAmIF9fR0ZQX05PV0FSTik7DQo+ID4gKw0KPiA+ICsJCS8qIGZhbGwgYmFjayB0byBk ZWZhdWx0IGNtYSBpZiBmYWlsZWQgaW4gcGVyLW51bWEgY21hICovDQo+ID4gKwkJaWYgKCFwYWdl ICYmIGFsbG9jX2Zyb21fcGVybnVtYSkNCj4gPiArCQkJcGFnZSA9IGNtYV9hbGxvYyhkbWFfY29u dGlndW91c19kZWZhdWx0X2FyZWEsIGNvdW50LA0KPiA+ICsJCQkJY21hX2FsaWduLCBnZnAgJiBf X0dGUF9OT1dBUk4pOw0KPiA+ICAgCX0NCj4gPg0KPiA+ICAgCXJldHVybiBwYWdlOw0KPiA+IEBA IC0yNjQsOSArMzE0LDQwIEBAIHN0cnVjdCBwYWdlICpkbWFfYWxsb2NfY29udGlndW91cyhzdHJ1 Y3QgZGV2aWNlDQo+ICpkZXYsIHNpemVfdCBzaXplLCBnZnBfdCBnZnApDQo+ID4gICAgKi8NCj4g PiAgIHZvaWQgZG1hX2ZyZWVfY29udGlndW91cyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBw YWdlICpwYWdlLCBzaXplX3QNCj4gc2l6ZSkNCj4gPiAgIHsNCj4gPiAtCWlmICghY21hX3JlbGVh c2UoZGV2X2dldF9jbWFfYXJlYShkZXYpLCBwYWdlLA0KPiA+IC0JCQkgUEFHRV9BTElHTihzaXpl KSA+PiBQQUdFX1NISUZUKSkNCj4gPiAtCQlfX2ZyZWVfcGFnZXMocGFnZSwgZ2V0X29yZGVyKHNp emUpKTsNCj4gPiArCS8qIGlmIGRldiBoYXMgaXRzIG93biBjbWEsIGZyZWUgcGFnZSBmcm9tIHRo ZXJlICovDQo+ID4gKwlpZiAoZGV2ICYmIGRldi0+Y21hX2FyZWEpIHsNCj4gDQo+IEFnYWluLCBu byBuZXcgcmVkdW5kYW50IE5VTEwgY2hlY2tzIHBsZWFzZS4NCg0KS2VybmVsIHRlc3Qgcm9ib3Qg bWlnaHQgcmVwb3J0IGlzc3VlLg0KDQo+IA0KPiA+ICsJCWlmIChjbWFfcmVsZWFzZShkZXYtPmNt YV9hcmVhLCBwYWdlLCBQQUdFX0FMSUdOKHNpemUpID4+DQo+IFBBR0VfU0hJRlQpKQ0KPiA+ICsJ CQlyZXR1cm47DQo+ID4gKwl9IGVsc2Ugew0KPiA+ICsJCS8qDQo+ID4gKwkJICogb3RoZXJ3aXNl LCBwYWdlIGlzIGZyb20gZWl0aGVyIHBlci1udW1hIGNtYSBvciBkZWZhdWx0IGNtYQ0KPiA+ICsJ CSAqLw0KPiA+ICsJCWludCBuaWQgPSBkZXYgPyBkZXZfdG9fbm9kZShkZXYpIDogTlVNQV9OT19O T0RFOw0KPiA+ICsNCj4gPiArCQlpZiAobmlkICE9IE5VTUFfTk9fTk9ERSkgew0KPiA+ICsJCQlp bnQgaTsNCj4gPiArDQo+ID4gKwkJCS8qDQo+ID4gKwkJCSAqIExpdGVyYWxseSB3ZSBvbmx5IG5l ZWQgdG8gY2FsbCBjbWFfcmVsZWFzZSgpIG9uIHBlcm51bWEgY21hDQo+IG9mDQo+ID4gKwkJCSAq IG5vZGUgbmlkLCBob3dlcnZlciwgYSBjb3JuZXIgY2FzZSBpcyB0aGF0IHVzZXJzIG1pZ2h0IHdy aXRlDQo+ID4gKwkJCSAqIC9zeXMvZGV2aWNlcy9wY2kteC9udW1hX25vZGUgdG8gY2hhbmdlIG5v ZGUgdG8NCj4gd29ya2Fyb3VuZCBmaXJtd2FyZQ0KPiA+ICsJCQkgKiBidWcsIHNvIGl0IG1pZ2h0 IGFsbG9jYXRlIG1lbW9yeSBmcm9tIG5vZGVBIENNQSwgYnV0IGZyZWUNCj4gZnJvbSBub2RlQg0K PiA+ICsJCQkgKiBDTUEuDQo+ID4gKwkJCSAqLw0KPiANCj4gV2h5IGJvdGhlciB3aXRoIHRoaXMg ZGFuY2UgYXQgYWxsPyBZb3UgaGF2ZSB0aGUgcGFnZSwgc28geW91IGNhbid0IG5vdA0KPiBrbm93 IHdoZXJlIGl0IGlzLiBKdXN0IHVzZSBwYWdlX3RvX25pZCgpIGxpa2UgaHVnZXRsYl9jbWEgZG9l cy4NCg0KQ29vbC4NCg0KPiANCj4gUm9iaW4uDQo+IA0KPiA+ICsJCQlmb3IgKGkgPSAwOyBpIDwg TUFYX05VTU5PREVTOyBpKyspIHsNCj4gPiArCQkJCWlmIChjbWFfcmVsZWFzZShkbWFfY29udGln dW91c19wZXJudW1hX2FyZWFbaV0sIHBhZ2UsDQo+ID4gKwkJCQkJCQlQQUdFX0FMSUdOKHNpemUp ID4+IFBBR0VfU0hJRlQpKQ0KPiA+ICsJCQkJCXJldHVybjsNCj4gPiArCQkJfQ0KPiA+ICsJCX0N Cj4gPiArDQo+ID4gKwkJaWYgKGNtYV9yZWxlYXNlKGRtYV9jb250aWd1b3VzX2RlZmF1bHRfYXJl YSwgcGFnZSwNCj4gPiArCQkJCQlQQUdFX0FMSUdOKHNpemUpID4+IFBBR0VfU0hJRlQpKQ0KPiA+ ICsJCQlyZXR1cm47DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJLyogbm90IGluIGFueSBjbWEsIGZy ZWUgZnJvbSBidWRkeSAqLw0KPiA+ICsJX19mcmVlX3BhZ2VzKHBhZ2UsIGdldF9vcmRlcihzaXpl KSk7DQo+ID4gICB9DQoNClRoYW5rcw0KQmFycnkNCg0K 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=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,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 4069DC433E0 for ; Fri, 26 Jun 2020 12:02:14 +0000 (UTC) Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (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 0CB9A2078D for ; Fri, 26 Jun 2020 12:02:13 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0CB9A2078D Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=hisilicon.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=iommu-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id DCB5E8655C; Fri, 26 Jun 2020 12:02:13 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 3aMt4ql9gZQF; Fri, 26 Jun 2020 12:02:12 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id 8470B861A1; Fri, 26 Jun 2020 12:02:12 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 53E4AC088C; Fri, 26 Jun 2020 12:02:12 +0000 (UTC) Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 4CA51C016F for ; Fri, 26 Jun 2020 12:02:11 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 4667586311 for ; Fri, 26 Jun 2020 12:02:11 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id YtMB8RUGi512 for ; Fri, 26 Jun 2020 12:02:09 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from huawei.com (szxga03-in.huawei.com [45.249.212.189]) by fraxinus.osuosl.org (Postfix) with ESMTPS id B1E2B861A1 for ; Fri, 26 Jun 2020 12:02:08 +0000 (UTC) Received: from dggemi406-hub.china.huawei.com (unknown [172.30.72.56]) by Forcepoint Email with ESMTP id 9667551DE239E30D0C96; Fri, 26 Jun 2020 20:01:56 +0800 (CST) Received: from DGGEMI525-MBS.china.huawei.com ([169.254.6.126]) by dggemi406-hub.china.huawei.com ([10.3.17.144]) with mapi id 14.03.0487.000; Fri, 26 Jun 2020 20:01:45 +0800 From: "Song Bao Hua (Barry Song)" To: Robin Murphy , "hch@lst.de" , "m.szyprowski@samsung.com" , "will@kernel.org" , "ganapatrao.kulkarni@cavium.com" , "catalin.marinas@arm.com" Subject: RE: [PATCH v2 1/2] dma-direct: provide the ability to reserve per-numa CMA Thread-Topic: [PATCH v2 1/2] dma-direct: provide the ability to reserve per-numa CMA Thread-Index: AQHWSsSY8LnVWNMYkEmWpaJ1pqQoDKjoptmAgAIP9AA= Date: Fri, 26 Jun 2020 12:01:45 +0000 Message-ID: References: <20200625074330.13668-1-song.bao.hua@hisilicon.com> <20200625074330.13668-2-song.bao.hua@hisilicon.com> <11672f20-6011-1a70-8def-fc662f52d50f@arm.com> In-Reply-To: <11672f20-6011-1a70-8def-fc662f52d50f@arm.com> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.126.201.204] MIME-Version: 1.0 X-CFilter-Loop: Reflected Cc: Steve Capper , Linuxarm , "linux-kernel@vger.kernel.org" , "iommu@lists.linux-foundation.org" , "linux-arm-kernel@lists.infradead.org" , Andrew Morton , Mike Rapoport , Nicolas Saenz Julienne X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" > -----Original Message----- > From: linux-kernel-owner@vger.kernel.org > [mailto:linux-kernel-owner@vger.kernel.org] On Behalf Of Robin Murphy > Sent: Thursday, June 25, 2020 11:11 PM > To: Song Bao Hua (Barry Song) ; hch@lst.de; > m.szyprowski@samsung.com; will@kernel.org; > ganapatrao.kulkarni@cavium.com; catalin.marinas@arm.com > Cc: iommu@lists.linux-foundation.org; Linuxarm ; > linux-arm-kernel@lists.infradead.org; linux-kernel@vger.kernel.org; Jonathan > Cameron ; Nicolas Saenz Julienne > ; Steve Capper ; Andrew > Morton ; Mike Rapoport > Subject: Re: [PATCH v2 1/2] dma-direct: provide the ability to reserve > per-numa CMA > > On 2020-06-25 08:43, Barry Song wrote: > > This is useful for at least two scenarios: > > 1. ARM64 smmu will get memory from local numa node, it can save its > > command queues and page tables locally. Tests show it can decrease > > dma_unmap latency at lot. For example, without this patch, smmu on > > node2 will get memory from node0 by calling dma_alloc_coherent(), > > typically, it has to wait for more than 560ns for the completion of > > CMD_SYNC in an empty command queue; with this patch, it needs 240ns > > only. > > 2. when we set iommu passthrough, drivers will get memory from CMA, > > local memory means much less latency. > > > > Cc: Jonathan Cameron > > Cc: Christoph Hellwig > > Cc: Marek Szyprowski > > Cc: Will Deacon > > Cc: Robin Murphy > > Cc: Ganapatrao Kulkarni > > Cc: Catalin Marinas > > Cc: Nicolas Saenz Julienne > > Cc: Steve Capper > > Cc: Andrew Morton > > Cc: Mike Rapoport > > Signed-off-by: Barry Song > > --- > > include/linux/dma-contiguous.h | 4 ++ > > kernel/dma/Kconfig | 10 ++++ > > kernel/dma/contiguous.c | 99 > ++++++++++++++++++++++++++++++---- > > 3 files changed, 104 insertions(+), 9 deletions(-) > > > > diff --git a/include/linux/dma-contiguous.h > b/include/linux/dma-contiguous.h > > index 03f8e98e3bcc..278a80a40456 100644 > > --- a/include/linux/dma-contiguous.h > > +++ b/include/linux/dma-contiguous.h > > @@ -79,6 +79,8 @@ static inline void dma_contiguous_set_default(struct > cma *cma) > > > > void dma_contiguous_reserve(phys_addr_t addr_limit); > > > > +void dma_pernuma_cma_reserve(void); > > + > > int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t > base, > > phys_addr_t limit, struct cma **res_cma, > > bool fixed); > > @@ -128,6 +130,8 @@ static inline void dma_contiguous_set_default(struct > cma *cma) { } > > > > static inline void dma_contiguous_reserve(phys_addr_t limit) { } > > > > +static inline void dma_pernuma_cma_reserve(void) { } > > + > > static inline int dma_contiguous_reserve_area(phys_addr_t size, > phys_addr_t base, > > phys_addr_t limit, struct cma **res_cma, > > bool fixed) > > diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig > > index d006668c0027..aeb976b1d21c 100644 > > --- a/kernel/dma/Kconfig > > +++ b/kernel/dma/Kconfig > > @@ -104,6 +104,16 @@ config DMA_CMA > > if DMA_CMA > > comment "Default contiguous memory area size:" > > > > +config CMA_PERNUMA_SIZE_MBYTES > > + int "Size in Mega Bytes for per-numa CMA areas" > > + depends on NUMA > > + default 16 if ARM64 > > + default 0 > > + help > > + Defines the size (in MiB) of the per-numa memory area for Contiguous > > + Memory Allocator. Every numa node will get a separate CMA with this > > + size. If the size of 0 is selected, per-numa CMA is disabled. > > + > > I think this needs to be cleverer than just a static config option. > Pretty much everything else CMA-related is runtime-configurable to some > degree, and doing any per-node setup when booting on a single-node > system would be wasted effort. I agree some dynamic configuration should be supported to set the size of cma. It could be a kernel parameter bootargs, or leverage an existing parameter. For a system with NUMA enabled, but with only one node or actually non-numa, the current dma_pernuma_cma_reserve() won't do anything: void __init dma_pernuma_cma_reserve(void) { int nid; if (!pernuma_size_bytes || nr_online_nodes <= 1) return; } > > Since this is conceptually very similar to the existing hugetlb_cma > implementation I'm also wondering about inconsistency with respect to > specifying per-node vs. total sizes. For hugetlbcma, pernuma cma size is: total_size/the number of nodes It is quite simple. But for DMA, node0's CMA might support address limitation for old devices which allocate memory by GFP_DMA(32). > > Another thought, though, is that systems large enough to have multiple > NUMA nodes tend not to be short on memory, so it might not be > unreasonable to base this all on whatever size the default area is > given, and simply have a binary on/off switch to control the per-node > aspect. I don't mind applying the default size to all NUMA nodes as generally a server has larger memory than embedded system. One issue is that the default global CMA is on node0, and if the code applies the default size to every node, the default cma is better to also as node0's pernuma cma too. Otherwise, there would be two CMA with same size on node0. So the code can bypass node0 while creating per-numa CMA. On the other hand, only CMA on node0 support address limitation for old devices as its memory is in low physical address. That is probably why the cma of node0 still need to be handled separately. So node0's CMA will be both default global CMA and per-NUMA CMA of node0. > > > config CMA_SIZE_MBYTES > > int "Size in Mega Bytes" > > depends on !CMA_SIZE_SEL_PERCENTAGE > > diff --git a/kernel/dma/contiguous.c b/kernel/dma/contiguous.c > > index 15bc5026c485..bcbd53aead93 100644 > > --- a/kernel/dma/contiguous.c > > +++ b/kernel/dma/contiguous.c > > @@ -30,7 +30,14 @@ > > #define CMA_SIZE_MBYTES 0 > > #endif > > > > +#ifdef CONFIG_CMA_PERNUMA_SIZE_MBYTES > > +#define CMA_SIZE_PERNUMA_MBYTES > CONFIG_CMA_PERNUMA_SIZE_MBYTES > > +#else > > +#define CMA_SIZE_PERNUMA_MBYTES 0 > > +#endif > > + > > struct cma *dma_contiguous_default_area; > > +static struct cma *dma_contiguous_pernuma_area[MAX_NUMNODES]; > > > > /* > > * Default global CMA area size can be defined in kernel's .config. > > @@ -44,6 +51,8 @@ struct cma *dma_contiguous_default_area; > > */ > > static const phys_addr_t size_bytes __initconst = > > (phys_addr_t)CMA_SIZE_MBYTES * SZ_1M; > > +static const phys_addr_t pernuma_size_bytes __initconst = > > + (phys_addr_t)CMA_SIZE_PERNUMA_MBYTES * SZ_1M; > > static phys_addr_t size_cmdline __initdata = -1; > > static phys_addr_t base_cmdline __initdata; > > static phys_addr_t limit_cmdline __initdata; > > @@ -96,6 +105,33 @@ static inline __maybe_unused phys_addr_t > cma_early_percent_memory(void) > > > > #endif > > > > +void __init dma_pernuma_cma_reserve(void) > > +{ > > + int nid; > > + > > + if (!pernuma_size_bytes || nr_online_nodes <= 1) > > + return; > > + > > + for_each_node_state(nid, N_ONLINE) { > > Do we need/want notifiers to handle currently-offline nodes coming > online later (I'm not sure off-hand how NUMA interacts with stuff like > "maxcpus=n")? I had a try. For example, if the hardware has 4 numa nodes and each one has 24 CPUs. Setting maxcpus=20 will result in: 4 numa nodes are all online after arm64_numa_init() ; CPU0-19 is online; CPU20-95 is offline; $cat /sys/devices/system/cpu/cpu0/online 1 $cat /sys/devices/system/cpu/cpu24/online 0 $cat /sys/devices/system/cpu/cpu50/online 0 But the printk still print 4 here: --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -420,6 +420,8 @@ void __init bootmem_init(void) arm64_numa_init(); + printk("%s nr_online_node :%d\n", __func__, nr_online_nodes); + /* * must be done after arm64_numa_init() which calls numa_init() to * initialize node_online_map that gets used in hugetlb_cma_reserve() > > > + int ret; > > + char name[20]; > > + > > + snprintf(name, sizeof(name), "pernuma%d", nid); > > + ret = cma_declare_contiguous_nid(0, pernuma_size_bytes, 0, 0, > > + 0, false, name, > > + &dma_contiguous_pernuma_area[nid], > > + nid); > > + if (ret) { > > + pr_warn("%s: reservation failed: err %d, node %d", __func__, > > + ret, nid); > > + continue; > > + } > > + > > + pr_debug("%s: reserved %llu MiB on node %d\n", __func__, > > + (unsigned long long)pernuma_size_bytes / SZ_1M, nid); > > + } > > +} > > + > > /** > > * dma_contiguous_reserve() - reserve area(s) for contiguous memory > handling > > * @limit: End address of the reserved memory (optional, 0 for any). > > @@ -222,22 +258,31 @@ bool dma_release_from_contiguous(struct device > *dev, struct page *pages, > > * @gfp: Allocation flags. > > * > > * This function allocates contiguous memory buffer for specified device. > It > > - * tries to use device specific contiguous memory area if available, or the > > - * default global one. > > + * tries to use device specific contiguous memory area if available, or it > > + * tries to use per-numa cma, if the allocation fails, it will fallback to > > + * try default global one. > > * > > - * Note that it byapss one-page size of allocations from the global area as > > - * the addresses within one page are always contiguous, so there is no need > > - * to waste CMA pages for that kind; it also helps reduce fragmentations. > > + * Note that it bypass one-page size of allocations from the per-numa and > > + * global area as the addresses within one page are always contiguous, so > > + * there is no need to waste CMA pages for that kind; it also helps reduce > > + * fragmentations. > > */ > > struct page *dma_alloc_contiguous(struct device *dev, size_t size, gfp_t > gfp) > > { > > size_t count = size >> PAGE_SHIFT; > > struct page *page = NULL; > > struct cma *cma = NULL; > > + int nid = dev ? dev_to_node(dev) : NUMA_NO_NODE; > > dev should never be NULL here (the existing check below could be cleaned > up if we're refactoring anyway). It was not done in v1. But kernel test robot reported issue like "smatch warnings: kernel/dma/contiguous.c:274 dma_alloc_contiguous() warn: variable dereferenced before \ check 'dev' (see line 272)" https://marc.info/?l=linux-arm-kernel&m=159127076208780&w=2 > > > + bool alloc_from_pernuma = false; > > > > if (dev && dev->cma_area) > > cma = dev->cma_area; > > - else if (count > 1) > > + else if ((nid != NUMA_NO_NODE) && > dma_contiguous_pernuma_area[nid] > > + && !(gfp & (GFP_DMA | GFP_DMA32)) > > + && (count > 1)) { > > + cma = dma_contiguous_pernuma_area[nid]; > > + alloc_from_pernuma = true; > > + } else if (count > 1) > > Well this is a big ugly mess... I'd suggest restructuring the whole > function to bail out immediately if (count == 1 && !dev->cma_area), then > try the per-device, per-node and default areas in turn until something > works. Agreed > > > cma = dma_contiguous_default_area; > > > > /* CMA can be used only in the context which permits sleeping */ > > @@ -246,6 +291,11 @@ struct page *dma_alloc_contiguous(struct device > *dev, size_t size, gfp_t gfp) > > size_t cma_align = min_t(size_t, align, CONFIG_CMA_ALIGNMENT); > > > > page = cma_alloc(cma, count, cma_align, gfp & __GFP_NOWARN); > > + > > + /* fall back to default cma if failed in per-numa cma */ > > + if (!page && alloc_from_pernuma) > > + page = cma_alloc(dma_contiguous_default_area, count, > > + cma_align, gfp & __GFP_NOWARN); > > } > > > > return page; > > @@ -264,9 +314,40 @@ struct page *dma_alloc_contiguous(struct device > *dev, size_t size, gfp_t gfp) > > */ > > void dma_free_contiguous(struct device *dev, struct page *page, size_t > size) > > { > > - if (!cma_release(dev_get_cma_area(dev), page, > > - PAGE_ALIGN(size) >> PAGE_SHIFT)) > > - __free_pages(page, get_order(size)); > > + /* if dev has its own cma, free page from there */ > > + if (dev && dev->cma_area) { > > Again, no new redundant NULL checks please. Kernel test robot might report issue. > > > + if (cma_release(dev->cma_area, page, PAGE_ALIGN(size) >> > PAGE_SHIFT)) > > + return; > > + } else { > > + /* > > + * otherwise, page is from either per-numa cma or default cma > > + */ > > + int nid = dev ? dev_to_node(dev) : NUMA_NO_NODE; > > + > > + if (nid != NUMA_NO_NODE) { > > + int i; > > + > > + /* > > + * Literally we only need to call cma_release() on pernuma cma > of > > + * node nid, howerver, a corner case is that users might write > > + * /sys/devices/pci-x/numa_node to change node to > workaround firmware > > + * bug, so it might allocate memory from nodeA CMA, but free > from nodeB > > + * CMA. > > + */ > > Why bother with this dance at all? You have the page, so you can't not > know where it is. Just use page_to_nid() like hugetlb_cma does. Cool. > > Robin. > > > + for (i = 0; i < MAX_NUMNODES; i++) { > > + if (cma_release(dma_contiguous_pernuma_area[i], page, > > + PAGE_ALIGN(size) >> PAGE_SHIFT)) > > + return; > > + } > > + } > > + > > + if (cma_release(dma_contiguous_default_area, page, > > + PAGE_ALIGN(size) >> PAGE_SHIFT)) > > + return; > > + } > > + > > + /* not in any cma, free from buddy */ > > + __free_pages(page, get_order(size)); > > } Thanks Barry _______________________________________________ iommu mailing list iommu@lists.linux-foundation.org https://lists.linuxfoundation.org/mailman/listinfo/iommu 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=-7.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=unavailable 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 3A0F1C433E0 for ; Fri, 26 Jun 2020 12:25:46 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (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 BF82A207E8 for ; Fri, 26 Jun 2020 12:25:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="PEmWQUUU" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BF82A207E8 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=hisilicon.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:In-Reply-To:References:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=rtJYIlH21zag7EuLYlUb5FPk86KSB7C3MFBVSFSu3FY=; b=PEmWQUUUK+HGGfKv9P1rLwzes lnuhynOIRXSoqtpqI3lLncWmzG+EBgx9+i5SveJ+DwMMuiRErIiDiJ9mYGmxdKK3rRsY2VD3hX21I 6MbdPX6gGA5jZwFG67jl4Js6MwNXMe/WXReDeVqzCjK7qzzg/DPLasy1vieTYV5q8kALap5GE7KZa p0adiSZLYmY6il1isjB7+ygLn/HKiUDTvFDitqCfLmRcKgsSzlSpQL3MvEyeqZxOWGLyMB1xwDlIg uQnhV93j5YAS20XfkY8cVraYMisyz5beiVU0nuM9iadwMw5mDuz+gsC7AMgU3KaK6rLfnXzYy6f3u jf1Q7oIAA==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jonNn-0003wN-6r; Fri, 26 Jun 2020 12:23:03 +0000 Received: from szxga03-in.huawei.com ([45.249.212.189] helo=huawei.com) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jon3a-0002Ed-I5 for linux-arm-kernel@lists.infradead.org; Fri, 26 Jun 2020 12:02:12 +0000 Received: from dggemi406-hub.china.huawei.com (unknown [172.30.72.56]) by Forcepoint Email with ESMTP id 9667551DE239E30D0C96; Fri, 26 Jun 2020 20:01:56 +0800 (CST) Received: from DGGEMI525-MBS.china.huawei.com ([169.254.6.126]) by dggemi406-hub.china.huawei.com ([10.3.17.144]) with mapi id 14.03.0487.000; Fri, 26 Jun 2020 20:01:45 +0800 From: "Song Bao Hua (Barry Song)" To: Robin Murphy , "hch@lst.de" , "m.szyprowski@samsung.com" , "will@kernel.org" , "ganapatrao.kulkarni@cavium.com" , "catalin.marinas@arm.com" Subject: RE: [PATCH v2 1/2] dma-direct: provide the ability to reserve per-numa CMA Thread-Topic: [PATCH v2 1/2] dma-direct: provide the ability to reserve per-numa CMA Thread-Index: AQHWSsSY8LnVWNMYkEmWpaJ1pqQoDKjoptmAgAIP9AA= Date: Fri, 26 Jun 2020 12:01:45 +0000 Message-ID: References: <20200625074330.13668-1-song.bao.hua@hisilicon.com> <20200625074330.13668-2-song.bao.hua@hisilicon.com> <11672f20-6011-1a70-8def-fc662f52d50f@arm.com> In-Reply-To: <11672f20-6011-1a70-8def-fc662f52d50f@arm.com> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.126.201.204] MIME-Version: 1.0 X-CFilter-Loop: Reflected X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Steve Capper , Linuxarm , "linux-kernel@vger.kernel.org" , "iommu@lists.linux-foundation.org" , "linux-arm-kernel@lists.infradead.org" , Jonathan Cameron , Andrew Morton , Mike Rapoport , Nicolas Saenz Julienne Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org > -----Original Message----- > From: linux-kernel-owner@vger.kernel.org > [mailto:linux-kernel-owner@vger.kernel.org] On Behalf Of Robin Murphy > Sent: Thursday, June 25, 2020 11:11 PM > To: Song Bao Hua (Barry Song) ; hch@lst.de; > m.szyprowski@samsung.com; will@kernel.org; > ganapatrao.kulkarni@cavium.com; catalin.marinas@arm.com > Cc: iommu@lists.linux-foundation.org; Linuxarm ; > linux-arm-kernel@lists.infradead.org; linux-kernel@vger.kernel.org; Jonathan > Cameron ; Nicolas Saenz Julienne > ; Steve Capper ; Andrew > Morton ; Mike Rapoport > Subject: Re: [PATCH v2 1/2] dma-direct: provide the ability to reserve > per-numa CMA > > On 2020-06-25 08:43, Barry Song wrote: > > This is useful for at least two scenarios: > > 1. ARM64 smmu will get memory from local numa node, it can save its > > command queues and page tables locally. Tests show it can decrease > > dma_unmap latency at lot. For example, without this patch, smmu on > > node2 will get memory from node0 by calling dma_alloc_coherent(), > > typically, it has to wait for more than 560ns for the completion of > > CMD_SYNC in an empty command queue; with this patch, it needs 240ns > > only. > > 2. when we set iommu passthrough, drivers will get memory from CMA, > > local memory means much less latency. > > > > Cc: Jonathan Cameron > > Cc: Christoph Hellwig > > Cc: Marek Szyprowski > > Cc: Will Deacon > > Cc: Robin Murphy > > Cc: Ganapatrao Kulkarni > > Cc: Catalin Marinas > > Cc: Nicolas Saenz Julienne > > Cc: Steve Capper > > Cc: Andrew Morton > > Cc: Mike Rapoport > > Signed-off-by: Barry Song > > --- > > include/linux/dma-contiguous.h | 4 ++ > > kernel/dma/Kconfig | 10 ++++ > > kernel/dma/contiguous.c | 99 > ++++++++++++++++++++++++++++++---- > > 3 files changed, 104 insertions(+), 9 deletions(-) > > > > diff --git a/include/linux/dma-contiguous.h > b/include/linux/dma-contiguous.h > > index 03f8e98e3bcc..278a80a40456 100644 > > --- a/include/linux/dma-contiguous.h > > +++ b/include/linux/dma-contiguous.h > > @@ -79,6 +79,8 @@ static inline void dma_contiguous_set_default(struct > cma *cma) > > > > void dma_contiguous_reserve(phys_addr_t addr_limit); > > > > +void dma_pernuma_cma_reserve(void); > > + > > int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t > base, > > phys_addr_t limit, struct cma **res_cma, > > bool fixed); > > @@ -128,6 +130,8 @@ static inline void dma_contiguous_set_default(struct > cma *cma) { } > > > > static inline void dma_contiguous_reserve(phys_addr_t limit) { } > > > > +static inline void dma_pernuma_cma_reserve(void) { } > > + > > static inline int dma_contiguous_reserve_area(phys_addr_t size, > phys_addr_t base, > > phys_addr_t limit, struct cma **res_cma, > > bool fixed) > > diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig > > index d006668c0027..aeb976b1d21c 100644 > > --- a/kernel/dma/Kconfig > > +++ b/kernel/dma/Kconfig > > @@ -104,6 +104,16 @@ config DMA_CMA > > if DMA_CMA > > comment "Default contiguous memory area size:" > > > > +config CMA_PERNUMA_SIZE_MBYTES > > + int "Size in Mega Bytes for per-numa CMA areas" > > + depends on NUMA > > + default 16 if ARM64 > > + default 0 > > + help > > + Defines the size (in MiB) of the per-numa memory area for Contiguous > > + Memory Allocator. Every numa node will get a separate CMA with this > > + size. If the size of 0 is selected, per-numa CMA is disabled. > > + > > I think this needs to be cleverer than just a static config option. > Pretty much everything else CMA-related is runtime-configurable to some > degree, and doing any per-node setup when booting on a single-node > system would be wasted effort. I agree some dynamic configuration should be supported to set the size of cma. It could be a kernel parameter bootargs, or leverage an existing parameter. For a system with NUMA enabled, but with only one node or actually non-numa, the current dma_pernuma_cma_reserve() won't do anything: void __init dma_pernuma_cma_reserve(void) { int nid; if (!pernuma_size_bytes || nr_online_nodes <= 1) return; } > > Since this is conceptually very similar to the existing hugetlb_cma > implementation I'm also wondering about inconsistency with respect to > specifying per-node vs. total sizes. For hugetlbcma, pernuma cma size is: total_size/the number of nodes It is quite simple. But for DMA, node0's CMA might support address limitation for old devices which allocate memory by GFP_DMA(32). > > Another thought, though, is that systems large enough to have multiple > NUMA nodes tend not to be short on memory, so it might not be > unreasonable to base this all on whatever size the default area is > given, and simply have a binary on/off switch to control the per-node > aspect. I don't mind applying the default size to all NUMA nodes as generally a server has larger memory than embedded system. One issue is that the default global CMA is on node0, and if the code applies the default size to every node, the default cma is better to also as node0's pernuma cma too. Otherwise, there would be two CMA with same size on node0. So the code can bypass node0 while creating per-numa CMA. On the other hand, only CMA on node0 support address limitation for old devices as its memory is in low physical address. That is probably why the cma of node0 still need to be handled separately. So node0's CMA will be both default global CMA and per-NUMA CMA of node0. > > > config CMA_SIZE_MBYTES > > int "Size in Mega Bytes" > > depends on !CMA_SIZE_SEL_PERCENTAGE > > diff --git a/kernel/dma/contiguous.c b/kernel/dma/contiguous.c > > index 15bc5026c485..bcbd53aead93 100644 > > --- a/kernel/dma/contiguous.c > > +++ b/kernel/dma/contiguous.c > > @@ -30,7 +30,14 @@ > > #define CMA_SIZE_MBYTES 0 > > #endif > > > > +#ifdef CONFIG_CMA_PERNUMA_SIZE_MBYTES > > +#define CMA_SIZE_PERNUMA_MBYTES > CONFIG_CMA_PERNUMA_SIZE_MBYTES > > +#else > > +#define CMA_SIZE_PERNUMA_MBYTES 0 > > +#endif > > + > > struct cma *dma_contiguous_default_area; > > +static struct cma *dma_contiguous_pernuma_area[MAX_NUMNODES]; > > > > /* > > * Default global CMA area size can be defined in kernel's .config. > > @@ -44,6 +51,8 @@ struct cma *dma_contiguous_default_area; > > */ > > static const phys_addr_t size_bytes __initconst = > > (phys_addr_t)CMA_SIZE_MBYTES * SZ_1M; > > +static const phys_addr_t pernuma_size_bytes __initconst = > > + (phys_addr_t)CMA_SIZE_PERNUMA_MBYTES * SZ_1M; > > static phys_addr_t size_cmdline __initdata = -1; > > static phys_addr_t base_cmdline __initdata; > > static phys_addr_t limit_cmdline __initdata; > > @@ -96,6 +105,33 @@ static inline __maybe_unused phys_addr_t > cma_early_percent_memory(void) > > > > #endif > > > > +void __init dma_pernuma_cma_reserve(void) > > +{ > > + int nid; > > + > > + if (!pernuma_size_bytes || nr_online_nodes <= 1) > > + return; > > + > > + for_each_node_state(nid, N_ONLINE) { > > Do we need/want notifiers to handle currently-offline nodes coming > online later (I'm not sure off-hand how NUMA interacts with stuff like > "maxcpus=n")? I had a try. For example, if the hardware has 4 numa nodes and each one has 24 CPUs. Setting maxcpus=20 will result in: 4 numa nodes are all online after arm64_numa_init() ; CPU0-19 is online; CPU20-95 is offline; $cat /sys/devices/system/cpu/cpu0/online 1 $cat /sys/devices/system/cpu/cpu24/online 0 $cat /sys/devices/system/cpu/cpu50/online 0 But the printk still print 4 here: --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -420,6 +420,8 @@ void __init bootmem_init(void) arm64_numa_init(); + printk("%s nr_online_node :%d\n", __func__, nr_online_nodes); + /* * must be done after arm64_numa_init() which calls numa_init() to * initialize node_online_map that gets used in hugetlb_cma_reserve() > > > + int ret; > > + char name[20]; > > + > > + snprintf(name, sizeof(name), "pernuma%d", nid); > > + ret = cma_declare_contiguous_nid(0, pernuma_size_bytes, 0, 0, > > + 0, false, name, > > + &dma_contiguous_pernuma_area[nid], > > + nid); > > + if (ret) { > > + pr_warn("%s: reservation failed: err %d, node %d", __func__, > > + ret, nid); > > + continue; > > + } > > + > > + pr_debug("%s: reserved %llu MiB on node %d\n", __func__, > > + (unsigned long long)pernuma_size_bytes / SZ_1M, nid); > > + } > > +} > > + > > /** > > * dma_contiguous_reserve() - reserve area(s) for contiguous memory > handling > > * @limit: End address of the reserved memory (optional, 0 for any). > > @@ -222,22 +258,31 @@ bool dma_release_from_contiguous(struct device > *dev, struct page *pages, > > * @gfp: Allocation flags. > > * > > * This function allocates contiguous memory buffer for specified device. > It > > - * tries to use device specific contiguous memory area if available, or the > > - * default global one. > > + * tries to use device specific contiguous memory area if available, or it > > + * tries to use per-numa cma, if the allocation fails, it will fallback to > > + * try default global one. > > * > > - * Note that it byapss one-page size of allocations from the global area as > > - * the addresses within one page are always contiguous, so there is no need > > - * to waste CMA pages for that kind; it also helps reduce fragmentations. > > + * Note that it bypass one-page size of allocations from the per-numa and > > + * global area as the addresses within one page are always contiguous, so > > + * there is no need to waste CMA pages for that kind; it also helps reduce > > + * fragmentations. > > */ > > struct page *dma_alloc_contiguous(struct device *dev, size_t size, gfp_t > gfp) > > { > > size_t count = size >> PAGE_SHIFT; > > struct page *page = NULL; > > struct cma *cma = NULL; > > + int nid = dev ? dev_to_node(dev) : NUMA_NO_NODE; > > dev should never be NULL here (the existing check below could be cleaned > up if we're refactoring anyway). It was not done in v1. But kernel test robot reported issue like "smatch warnings: kernel/dma/contiguous.c:274 dma_alloc_contiguous() warn: variable dereferenced before \ check 'dev' (see line 272)" https://marc.info/?l=linux-arm-kernel&m=159127076208780&w=2 > > > + bool alloc_from_pernuma = false; > > > > if (dev && dev->cma_area) > > cma = dev->cma_area; > > - else if (count > 1) > > + else if ((nid != NUMA_NO_NODE) && > dma_contiguous_pernuma_area[nid] > > + && !(gfp & (GFP_DMA | GFP_DMA32)) > > + && (count > 1)) { > > + cma = dma_contiguous_pernuma_area[nid]; > > + alloc_from_pernuma = true; > > + } else if (count > 1) > > Well this is a big ugly mess... I'd suggest restructuring the whole > function to bail out immediately if (count == 1 && !dev->cma_area), then > try the per-device, per-node and default areas in turn until something > works. Agreed > > > cma = dma_contiguous_default_area; > > > > /* CMA can be used only in the context which permits sleeping */ > > @@ -246,6 +291,11 @@ struct page *dma_alloc_contiguous(struct device > *dev, size_t size, gfp_t gfp) > > size_t cma_align = min_t(size_t, align, CONFIG_CMA_ALIGNMENT); > > > > page = cma_alloc(cma, count, cma_align, gfp & __GFP_NOWARN); > > + > > + /* fall back to default cma if failed in per-numa cma */ > > + if (!page && alloc_from_pernuma) > > + page = cma_alloc(dma_contiguous_default_area, count, > > + cma_align, gfp & __GFP_NOWARN); > > } > > > > return page; > > @@ -264,9 +314,40 @@ struct page *dma_alloc_contiguous(struct device > *dev, size_t size, gfp_t gfp) > > */ > > void dma_free_contiguous(struct device *dev, struct page *page, size_t > size) > > { > > - if (!cma_release(dev_get_cma_area(dev), page, > > - PAGE_ALIGN(size) >> PAGE_SHIFT)) > > - __free_pages(page, get_order(size)); > > + /* if dev has its own cma, free page from there */ > > + if (dev && dev->cma_area) { > > Again, no new redundant NULL checks please. Kernel test robot might report issue. > > > + if (cma_release(dev->cma_area, page, PAGE_ALIGN(size) >> > PAGE_SHIFT)) > > + return; > > + } else { > > + /* > > + * otherwise, page is from either per-numa cma or default cma > > + */ > > + int nid = dev ? dev_to_node(dev) : NUMA_NO_NODE; > > + > > + if (nid != NUMA_NO_NODE) { > > + int i; > > + > > + /* > > + * Literally we only need to call cma_release() on pernuma cma > of > > + * node nid, howerver, a corner case is that users might write > > + * /sys/devices/pci-x/numa_node to change node to > workaround firmware > > + * bug, so it might allocate memory from nodeA CMA, but free > from nodeB > > + * CMA. > > + */ > > Why bother with this dance at all? You have the page, so you can't not > know where it is. Just use page_to_nid() like hugetlb_cma does. Cool. > > Robin. > > > + for (i = 0; i < MAX_NUMNODES; i++) { > > + if (cma_release(dma_contiguous_pernuma_area[i], page, > > + PAGE_ALIGN(size) >> PAGE_SHIFT)) > > + return; > > + } > > + } > > + > > + if (cma_release(dma_contiguous_default_area, page, > > + PAGE_ALIGN(size) >> PAGE_SHIFT)) > > + return; > > + } > > + > > + /* not in any cma, free from buddy */ > > + __free_pages(page, get_order(size)); > > } Thanks Barry _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel