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=-15.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_SANE_1 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 CC69CC433DB for ; Tue, 16 Mar 2021 03:21:51 +0000 (UTC) Received: from ml01.01.org (ml01.01.org [198.145.21.10]) (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 393F965093 for ; Tue, 16 Mar 2021 03:21:51 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 393F965093 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.alibaba.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-nvdimm-bounces@lists.01.org Received: from ml01.vlan13.01.org (localhost [IPv6:::1]) by ml01.01.org (Postfix) with ESMTP id C41F2100EBB96; Mon, 15 Mar 2021 20:21:50 -0700 (PDT) Received-SPF: Pass (mailfrom) identity=mailfrom; client-ip=115.124.30.132; helo=out30-132.freemail.mail.aliyun.com; envelope-from=zhongjiang-ali@linux.alibaba.com; receiver= Received: from out30-132.freemail.mail.aliyun.com (out30-132.freemail.mail.aliyun.com [115.124.30.132]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id EDCF8100EBB90 for ; Mon, 15 Mar 2021 20:21:47 -0700 (PDT) X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R801e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=e01e04426;MF=zhongjiang-ali@linux.alibaba.com;NM=1;PH=DS;RN=16;SR=0;TI=SMTPD_---0US4IWG9_1615864901; Received: from L-X1DSLVDL-1420.local(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0US4IWG9_1615864901) by smtp.aliyun-inc.com(127.0.0.1); Tue, 16 Mar 2021 11:21:42 +0800 Message-ID: Date: Tue, 16 Mar 2021 11:21:41 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:87.0) Gecko/20100101 Thunderbird/87.0 Subject: Re: [PATCH v3 05/11] mm, fsdax: Refactor memory-failure handler for dax mapping Content-Language: en-US To: Shiyang Ruan , linux-kernel@vger.kernel.org, linux-xfs@vger.kernel.org, linux-nvdimm@lists.01.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, dm-devel@redhat.com References: <20210208105530.3072869-1-ruansy.fnst@cn.fujitsu.com> <20210208105530.3072869-6-ruansy.fnst@cn.fujitsu.com> From: zhong jiang In-Reply-To: <20210208105530.3072869-6-ruansy.fnst@cn.fujitsu.com> Message-ID-Hash: IPPGPXQINCMILVPMH6FFII7EPCAMG6AF X-Message-ID-Hash: IPPGPXQINCMILVPMH6FFII7EPCAMG6AF X-MailFrom: zhongjiang-ali@linux.alibaba.com X-Mailman-Rule-Hits: nonmember-moderation X-Mailman-Rule-Misses: dmarc-mitigation; no-senders; approved; emergency; loop; banned-address; member-moderation CC: darrick.wong@oracle.com, david@fromorbit.com, hch@lst.de, agk@redhat.com, snitzer@redhat.com, rgoldwyn@suse.de, qi.fuli@fujitsu.com, y-goto@fujitsu.com X-Mailman-Version: 3.1.1 Precedence: list List-Id: "Linux-nvdimm developer list." Archived-At: List-Archive: List-Help: List-Post: List-Subscribe: List-Unsubscribe: Content-Type: text/plain; charset="utf-8"; format="flowed" Content-Transfer-Encoding: base64 DQpPbiAyMDIxLzIvOCA2OjU1IOS4i+WNiCwgU2hpeWFuZyBSdWFuIHdyb3RlOg0KPiBUaGUgY3Vy cmVudCBtZW1vcnlfZmFpbHVyZV9kZXZfcGFnZW1hcCgpIGNhbiBvbmx5IGhhbmRsZSBzaW5nbGUt bWFwcGVkDQo+IGRheCBwYWdlIGZvciBmc2RheCBtb2RlLiAgVGhlIGRheCBwYWdlIGNvdWxkIGJl IG1hcHBlZCBieSBtdWx0aXBsZSBmaWxlcw0KPiBhbmQgb2Zmc2V0cyBpZiB3ZSBsZXQgcmVmbGlu ayBmZWF0dXJlICYgZnNkYXggbW9kZSB3b3JrIHRvZ2V0aGVyLiAgU28sDQo+IHdlIHJlZmFjdG9y IGN1cnJlbnQgaW1wbGVtZW50YXRpb24gdG8gc3VwcG9ydCBoYW5kbGUgbWVtb3J5IGZhaWx1cmUg b24NCj4gZWFjaCBmaWxlIGFuZCBvZmZzZXQuDQo+DQo+IFNpZ25lZC1vZmYtYnk6IFNoaXlhbmcg UnVhbiA8cnVhbnN5LmZuc3RAY24uZnVqaXRzdS5jb20+DQo+IC0tLQ0KPiAgIGZzL2RheC5jICAg ICAgICAgICAgfCAyMSArKysrKysrKysrDQo+ICAgaW5jbHVkZS9saW51eC9kYXguaCB8ICAxICsN Cj4gICBpbmNsdWRlL2xpbnV4L21tLmggIHwgIDkgKysrKysNCj4gICBtbS9tZW1vcnktZmFpbHVy ZS5jIHwgOTggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tDQo+ ICAgNCBmaWxlcyBjaGFuZ2VkLCAxMDUgaW5zZXJ0aW9ucygrKSwgMjQgZGVsZXRpb25zKC0pDQo+ DQo+IGRpZmYgLS1naXQgYS9mcy9kYXguYyBiL2ZzL2RheC5jDQo+IGluZGV4IDI2ZDVkY2QyZDY5 ZS4uYzY0YzNhMGU3NmE2IDEwMDY0NA0KPiAtLS0gYS9mcy9kYXguYw0KPiArKysgYi9mcy9kYXgu Yw0KPiBAQCAtMzc4LDYgKzM3OCwyNyBAQCBzdGF0aWMgc3RydWN0IHBhZ2UgKmRheF9idXN5X3Bh Z2Uodm9pZCAqZW50cnkpDQo+ICAgCXJldHVybiBOVUxMOw0KPiAgIH0NCj4gICANCj4gKy8qDQo+ ICsgKiBkYXhfbG9hZF9wZm4gLSBMb2FkIHBmbiBvZiB0aGUgREFYIGVudHJ5IGNvcnJlc3BvbmRp bmcgdG8gYSBwYWdlDQo+ICsgKiBAbWFwcGluZzogVGhlIGZpbGUgd2hvc2UgZW50cnkgd2Ugd2Fu dCB0byBsb2FkDQo+ICsgKiBAaW5kZXg6ICAgVGhlIG9mZnNldCB3aGVyZSB0aGUgREFYIGVudHJ5 IGxvY2F0ZWQgaW4NCj4gKyAqDQo+ICsgKiBSZXR1cm46ICAgcGZuIG9mIHRoZSBEQVggZW50cnkN Cj4gKyAqLw0KPiArdW5zaWduZWQgbG9uZyBkYXhfbG9hZF9wZm4oc3RydWN0IGFkZHJlc3Nfc3Bh Y2UgKm1hcHBpbmcsIHVuc2lnbmVkIGxvbmcgaW5kZXgpDQo+ICt7DQo+ICsJWEFfU1RBVEUoeGFz LCAmbWFwcGluZy0+aV9wYWdlcywgaW5kZXgpOw0KPiArCXZvaWQgKmVudHJ5Ow0KPiArCXVuc2ln bmVkIGxvbmcgcGZuOw0KPiArDQo+ICsJeGFzX2xvY2tfaXJxKCZ4YXMpOw0KPiArCWVudHJ5ID0g eGFzX2xvYWQoJnhhcyk7DQo+ICsJcGZuID0gZGF4X3RvX3BmbihlbnRyeSk7DQo+ICsJeGFzX3Vu bG9ja19pcnEoJnhhcyk7DQo+ICsNCj4gKwlyZXR1cm4gcGZuOw0KPiArfQ0KPiArDQo+ICAgLyoN Cj4gICAgKiBkYXhfbG9ja19tYXBwaW5nX2VudHJ5IC0gTG9jayB0aGUgREFYIGVudHJ5IGNvcnJl c3BvbmRpbmcgdG8gYSBwYWdlDQo+ICAgICogQHBhZ2U6IFRoZSBwYWdlIHdob3NlIGVudHJ5IHdl IHdhbnQgdG8gbG9jaw0KPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kYXguaCBiL2luY2x1 ZGUvbGludXgvZGF4LmgNCj4gaW5kZXggYjUyZjA4NGFhNjQzLi44OWU1NmNlZWZmYzcgMTAwNjQ0 DQo+IC0tLSBhL2luY2x1ZGUvbGludXgvZGF4LmgNCj4gKysrIGIvaW5jbHVkZS9saW51eC9kYXgu aA0KPiBAQCAtMTUwLDYgKzE1MCw3IEBAIGludCBkYXhfd3JpdGViYWNrX21hcHBpbmdfcmFuZ2Uo c3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsDQo+ICAgDQo+ICAgc3RydWN0IHBhZ2UgKmRh eF9sYXlvdXRfYnVzeV9wYWdlKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKTsNCj4gICBz dHJ1Y3QgcGFnZSAqZGF4X2xheW91dF9idXN5X3BhZ2VfcmFuZ2Uoc3RydWN0IGFkZHJlc3Nfc3Bh Y2UgKm1hcHBpbmcsIGxvZmZfdCBzdGFydCwgbG9mZl90IGVuZCk7DQo+ICt1bnNpZ25lZCBsb25n IGRheF9sb2FkX3BmbihzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZywgdW5zaWduZWQgbG9u ZyBpbmRleCk7DQo+ICAgZGF4X2VudHJ5X3QgZGF4X2xvY2tfcGFnZShzdHJ1Y3QgcGFnZSAqcGFn ZSk7DQo+ICAgdm9pZCBkYXhfdW5sb2NrX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsIGRheF9lbnRy eV90IGNvb2tpZSk7DQo+ICAgI2Vsc2UNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW0u aCBiL2luY2x1ZGUvbGludXgvbW0uaA0KPiBpbmRleCBlY2RmOGE4Y2Q2YWUuLmFiNTJiYzYzM2Q4 NCAxMDA2NDQNCj4gLS0tIGEvaW5jbHVkZS9saW51eC9tbS5oDQo+ICsrKyBiL2luY2x1ZGUvbGlu dXgvbW0uaA0KPiBAQCAtMTE1Nyw2ICsxMTU3LDE0IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBpc19k ZXZpY2VfcHJpdmF0ZV9wYWdlKGNvbnN0IHN0cnVjdCBwYWdlICpwYWdlKQ0KPiAgIAkJcGFnZS0+ cGdtYXAtPnR5cGUgPT0gTUVNT1JZX0RFVklDRV9QUklWQVRFOw0KPiAgIH0NCj4gICANCj4gK3N0 YXRpYyBpbmxpbmUgYm9vbCBpc19kZXZpY2VfZnNkYXhfcGFnZShjb25zdCBzdHJ1Y3QgcGFnZSAq cGFnZSkNCj4gK3sNCj4gKwlyZXR1cm4gSVNfRU5BQkxFRChDT05GSUdfREVWX1BBR0VNQVBfT1BT KSAmJg0KPiArCQlJU19FTkFCTEVEKENPTkZJR19GU19EQVgpICYmDQo+ICsJCWlzX3pvbmVfZGV2 aWNlX3BhZ2UocGFnZSkgJiYNCj4gKwkJcGFnZS0+cGdtYXAtPnR5cGUgPT0gTUVNT1JZX0RFVklD RV9GU19EQVg7DQo+ICt9DQo+ICsNCj4gICBzdGF0aWMgaW5saW5lIGJvb2wgaXNfcGNpX3AycGRt YV9wYWdlKGNvbnN0IHN0cnVjdCBwYWdlICpwYWdlKQ0KPiAgIHsNCj4gICAJcmV0dXJuIElTX0VO QUJMRUQoQ09ORklHX0RFVl9QQUdFTUFQX09QUykgJiYNCj4gQEAgLTMwNDUsNiArMzA1Myw3IEBA IGVudW0gbWZfZmxhZ3Mgew0KPiAgIAlNRl9NVVNUX0tJTEwgPSAxIDw8IDIsDQo+ICAgCU1GX1NP RlRfT0ZGTElORSA9IDEgPDwgMywNCj4gICB9Ow0KPiArZXh0ZXJuIGludCBtZl9kYXhfbWFwcGlu Z19raWxsX3Byb2NzKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLCBwZ29mZl90IGluZGV4 LCBpbnQgZmxhZ3MpOw0KPiAgIGV4dGVybiBpbnQgbWVtb3J5X2ZhaWx1cmUodW5zaWduZWQgbG9u ZyBwZm4sIGludCBmbGFncyk7DQo+ICAgZXh0ZXJuIHZvaWQgbWVtb3J5X2ZhaWx1cmVfcXVldWUo dW5zaWduZWQgbG9uZyBwZm4sIGludCBmbGFncyk7DQo+ICAgZXh0ZXJuIHZvaWQgbWVtb3J5X2Zh aWx1cmVfcXVldWVfa2ljayhpbnQgY3B1KTsNCj4gZGlmZiAtLWdpdCBhL21tL21lbW9yeS1mYWls dXJlLmMgYi9tbS9tZW1vcnktZmFpbHVyZS5jDQo+IGluZGV4IGU5NDgxNjMyZmNkMS4uMTU4ZmUw YzhlNjAyIDEwMDY0NA0KPiAtLS0gYS9tbS9tZW1vcnktZmFpbHVyZS5jDQo+ICsrKyBiL21tL21l bW9yeS1mYWlsdXJlLmMNCj4gQEAgLTU2LDYgKzU2LDcgQEANCj4gICAjaW5jbHVkZSA8bGludXgv a2ZpZm8uaD4NCj4gICAjaW5jbHVkZSA8bGludXgvcmF0ZWxpbWl0Lmg+DQo+ICAgI2luY2x1ZGUg PGxpbnV4L3BhZ2UtaXNvbGF0aW9uLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvZGF4Lmg+DQo+ICAg I2luY2x1ZGUgImludGVybmFsLmgiDQo+ICAgI2luY2x1ZGUgInJhcy9yYXNfZXZlbnQuaCINCj4g ICANCj4gQEAgLTEyMCw2ICsxMjEsMTMgQEAgc3RhdGljIGludCBod3BvaXNvbl9maWx0ZXJfZGV2 KHN0cnVjdCBwYWdlICpwKQ0KPiAgIAlpZiAoUGFnZVNsYWIocCkpDQo+ICAgCQlyZXR1cm4gLUVJ TlZBTDsNCj4gICANCj4gKwlpZiAocGZuX3ZhbGlkKHBhZ2VfdG9fcGZuKHApKSkgew0KPiArCQlp ZiAoaXNfZGV2aWNlX2ZzZGF4X3BhZ2UocCkpDQo+ICsJCQlyZXR1cm4gMDsNCj4gKwkJZWxzZQ0K PiArCQkJcmV0dXJuIC1FSU5WQUw7DQo+ICsJfQ0KPiArDQo+ICAgCW1hcHBpbmcgPSBwYWdlX21h cHBpbmcocCk7DQo+ICAgCWlmIChtYXBwaW5nID09IE5VTEwgfHwgbWFwcGluZy0+aG9zdCA9PSBO VUxMKQ0KPiAgIAkJcmV0dXJuIC1FSU5WQUw7DQo+IEBAIC0yODYsMTAgKzI5NCw5IEBAIHZvaWQg c2hha2VfcGFnZShzdHJ1Y3QgcGFnZSAqcCwgaW50IGFjY2VzcykNCj4gICB9DQo+ICAgRVhQT1JU X1NZTUJPTF9HUEwoc2hha2VfcGFnZSk7DQo+ICAgDQo+IC1zdGF0aWMgdW5zaWduZWQgbG9uZyBk ZXZfcGFnZW1hcF9tYXBwaW5nX3NoaWZ0KHN0cnVjdCBwYWdlICpwYWdlLA0KPiAtCQlzdHJ1Y3Qg dm1fYXJlYV9zdHJ1Y3QgKnZtYSkNCj4gK3N0YXRpYyB1bnNpZ25lZCBsb25nIGRldl9wYWdlbWFw X21hcHBpbmdfc2hpZnQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsDQo+ICsJCQkJCSAgICAg ICB1bnNpZ25lZCBsb25nIGFkZHJlc3MpDQo+ICAgew0KPiAtCXVuc2lnbmVkIGxvbmcgYWRkcmVz cyA9IHZtYV9hZGRyZXNzKHBhZ2UsIHZtYSk7DQo+ICAgCXBnZF90ICpwZ2Q7DQo+ICAgCXA0ZF90 ICpwNGQ7DQo+ICAgCXB1ZF90ICpwdWQ7DQo+IEBAIC0zMjksOSArMzM2LDggQEAgc3RhdGljIHVu c2lnbmVkIGxvbmcgZGV2X3BhZ2VtYXBfbWFwcGluZ19zaGlmdChzdHJ1Y3QgcGFnZSAqcGFnZSwN Cj4gICAgKiBTY2hlZHVsZSBhIHByb2Nlc3MgZm9yIGxhdGVyIGtpbGwuDQo+ICAgICogVXNlcyBH RlBfQVRPTUlDIGFsbG9jYXRpb25zIHRvIGF2b2lkIHBvdGVudGlhbCByZWN1cnNpb25zIGluIHRo ZSBWTS4NCj4gICAgKi8NCj4gLXN0YXRpYyB2b2lkIGFkZF90b19raWxsKHN0cnVjdCB0YXNrX3N0 cnVjdCAqdHNrLCBzdHJ1Y3QgcGFnZSAqcCwNCj4gLQkJICAgICAgIHN0cnVjdCB2bV9hcmVhX3N0 cnVjdCAqdm1hLA0KPiAtCQkgICAgICAgc3RydWN0IGxpc3RfaGVhZCAqdG9fa2lsbCkNCj4gK3N0 YXRpYyB2b2lkIGFkZF90b19raWxsKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBzdHJ1Y3QgcGFn ZSAqcCwgcGdvZmZfdCBwZ29mZiwNCj4gKwkJCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBz dHJ1Y3QgbGlzdF9oZWFkICp0b19raWxsKQ0KPiAgIHsNCj4gICAJc3RydWN0IHRvX2tpbGwgKnRr Ow0KPiAgIA0KPiBAQCAtMzQyLDkgKzM0OCwxMiBAQCBzdGF0aWMgdm9pZCBhZGRfdG9fa2lsbChz dHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywgc3RydWN0IHBhZ2UgKnAsDQo+ICAgCX0NCj4gICANCj4g ICAJdGstPmFkZHIgPSBwYWdlX2FkZHJlc3NfaW5fdm1hKHAsIHZtYSk7DQo+IC0JaWYgKGlzX3pv bmVfZGV2aWNlX3BhZ2UocCkpDQo+IC0JCXRrLT5zaXplX3NoaWZ0ID0gZGV2X3BhZ2VtYXBfbWFw cGluZ19zaGlmdChwLCB2bWEpOw0KPiAtCWVsc2UNCj4gKwlpZiAoaXNfem9uZV9kZXZpY2VfcGFn ZShwKSkgew0KPiArCQlpZiAoaXNfZGV2aWNlX2ZzZGF4X3BhZ2UocCkpDQo+ICsJCQl0ay0+YWRk ciA9IHZtYS0+dm1fc3RhcnQgKw0KPiArCQkJCQkoKHBnb2ZmIC0gdm1hLT52bV9wZ29mZikgPDwg UEFHRV9TSElGVCk7DQo+ICsJCXRrLT5zaXplX3NoaWZ0ID0gZGV2X3BhZ2VtYXBfbWFwcGluZ19z aGlmdCh2bWEsIHRrLT5hZGRyKTsNCj4gKwl9IGVsc2UNCj4gICAJCXRrLT5zaXplX3NoaWZ0ID0g cGFnZV9zaGlmdChjb21wb3VuZF9oZWFkKHApKTsNCj4gICANCj4gICAJLyoNCj4gQEAgLTQ5Miw3 ICs1MDEsNyBAQCBzdGF0aWMgdm9pZCBjb2xsZWN0X3Byb2NzX2Fub24oc3RydWN0IHBhZ2UgKnBh Z2UsIHN0cnVjdCBsaXN0X2hlYWQgKnRvX2tpbGwsDQo+ICAgCQkJaWYgKCFwYWdlX21hcHBlZF9p bl92bWEocGFnZSwgdm1hKSkNCj4gICAJCQkJY29udGludWU7DQo+ICAgCQkJaWYgKHZtYS0+dm1f bW0gPT0gdC0+bW0pDQo+IC0JCQkJYWRkX3RvX2tpbGwodCwgcGFnZSwgdm1hLCB0b19raWxsKTsN Cj4gKwkJCQlhZGRfdG9fa2lsbCh0LCBwYWdlLCAwLCB2bWEsIHRvX2tpbGwpOw0KPiAgIAkJfQ0K PiAgIAl9DQo+ICAgCXJlYWRfdW5sb2NrKCZ0YXNrbGlzdF9sb2NrKTsNCj4gQEAgLTUwMiwyNCAr NTExLDE5IEBAIHN0YXRpYyB2b2lkIGNvbGxlY3RfcHJvY3NfYW5vbihzdHJ1Y3QgcGFnZSAqcGFn ZSwgc3RydWN0IGxpc3RfaGVhZCAqdG9fa2lsbCwNCj4gICAvKg0KPiAgICAqIENvbGxlY3QgcHJv Y2Vzc2VzIHdoZW4gdGhlIGVycm9yIGhpdCBhIGZpbGUgbWFwcGVkIHBhZ2UuDQo+ICAgICovDQo+ IC1zdGF0aWMgdm9pZCBjb2xsZWN0X3Byb2NzX2ZpbGUoc3RydWN0IHBhZ2UgKnBhZ2UsIHN0cnVj dCBsaXN0X2hlYWQgKnRvX2tpbGwsDQo+IC0JCQkJaW50IGZvcmNlX2Vhcmx5KQ0KPiArc3RhdGlj IHZvaWQgY29sbGVjdF9wcm9jc19maWxlKHN0cnVjdCBwYWdlICpwYWdlLCBzdHJ1Y3QgYWRkcmVz c19zcGFjZSAqbWFwcGluZywNCj4gKwkJcGdvZmZfdCBwZ29mZiwgc3RydWN0IGxpc3RfaGVhZCAq dG9fa2lsbCwgaW50IGZvcmNlX2Vhcmx5KQ0KPiAgIHsNCj4gICAJc3RydWN0IHZtX2FyZWFfc3Ry dWN0ICp2bWE7DQo+ICAgCXN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrOw0KPiAtCXN0cnVjdCBhZGRy ZXNzX3NwYWNlICptYXBwaW5nID0gcGFnZS0+bWFwcGluZzsNCj4gLQlwZ29mZl90IHBnb2ZmOw0K PiAgIA0KPiAgIAlpX21tYXBfbG9ja19yZWFkKG1hcHBpbmcpOw0KPiAgIAlyZWFkX2xvY2soJnRh c2tsaXN0X2xvY2spOw0KPiAtCXBnb2ZmID0gcGFnZV90b19wZ29mZihwYWdlKTsNCj4gICAJZm9y X2VhY2hfcHJvY2Vzcyh0c2spIHsNCj4gICAJCXN0cnVjdCB0YXNrX3N0cnVjdCAqdCA9IHRhc2tf ZWFybHlfa2lsbCh0c2ssIGZvcmNlX2Vhcmx5KTsNCj4gLQ0KPiAgIAkJaWYgKCF0KQ0KPiAgIAkJ CWNvbnRpbnVlOw0KPiAtCQl2bWFfaW50ZXJ2YWxfdHJlZV9mb3JlYWNoKHZtYSwgJm1hcHBpbmct PmlfbW1hcCwgcGdvZmYsDQo+IC0JCQkJICAgICAgcGdvZmYpIHsNCj4gKwkJdm1hX2ludGVydmFs X3RyZWVfZm9yZWFjaCh2bWEsICZtYXBwaW5nLT5pX21tYXAsIHBnb2ZmLCBwZ29mZikgew0KPiAg IAkJCS8qDQo+ICAgCQkJICogU2VuZCBlYXJseSBraWxsIHNpZ25hbCB0byB0YXNrcyB3aGVyZSBh IHZtYSBjb3ZlcnMNCj4gICAJCQkgKiB0aGUgcGFnZSBidXQgdGhlIGNvcnJ1cHRlZCBwYWdlIGlz IG5vdCBuZWNlc3NhcmlseQ0KPiBAQCAtNTI4LDcgKzUzMiw3IEBAIHN0YXRpYyB2b2lkIGNvbGxl Y3RfcHJvY3NfZmlsZShzdHJ1Y3QgcGFnZSAqcGFnZSwgc3RydWN0IGxpc3RfaGVhZCAqdG9fa2ls bCwNCj4gICAJCQkgKiB0byBiZSBpbmZvcm1lZCBvZiBhbGwgc3VjaCBkYXRhIGNvcnJ1cHRpb25z Lg0KPiAgIAkJCSAqLw0KPiAgIAkJCWlmICh2bWEtPnZtX21tID09IHQtPm1tKQ0KPiAtCQkJCWFk ZF90b19raWxsKHQsIHBhZ2UsIHZtYSwgdG9fa2lsbCk7DQo+ICsJCQkJYWRkX3RvX2tpbGwodCwg cGFnZSwgcGdvZmYsIHZtYSwgdG9fa2lsbCk7DQo+ICAgCQl9DQo+ICAgCX0NCj4gICAJcmVhZF91 bmxvY2soJnRhc2tsaXN0X2xvY2spOw0KPiBAQCAtNTQ3LDcgKzU1MSw4IEBAIHN0YXRpYyB2b2lk IGNvbGxlY3RfcHJvY3Moc3RydWN0IHBhZ2UgKnBhZ2UsIHN0cnVjdCBsaXN0X2hlYWQgKnRva2ls bCwNCj4gICAJaWYgKFBhZ2VBbm9uKHBhZ2UpKQ0KPiAgIAkJY29sbGVjdF9wcm9jc19hbm9uKHBh Z2UsIHRva2lsbCwgZm9yY2VfZWFybHkpOw0KPiAgIAllbHNlDQo+IC0JCWNvbGxlY3RfcHJvY3Nf ZmlsZShwYWdlLCB0b2tpbGwsIGZvcmNlX2Vhcmx5KTsNCj4gKwkJY29sbGVjdF9wcm9jc19maWxl KHBhZ2UsIHBhZ2VfbWFwcGluZyhwYWdlKSwgcGFnZV90b19wZ29mZihwYWdlKSwNCj4gKwkJCQkg ICB0b2tpbGwsIGZvcmNlX2Vhcmx5KTsNCj4gICB9DQo+ICAgDQo+ICAgc3RhdGljIGNvbnN0IGNo YXIgKmFjdGlvbl9uYW1lW10gPSB7DQo+IEBAIC0xMjE0LDYgKzEyMTksNTAgQEAgc3RhdGljIGlu dCB0cnlfdG9fc3BsaXRfdGhwX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsIGNvbnN0IGNoYXIgKm1z ZykNCj4gICAJcmV0dXJuIDA7DQo+ICAgfQ0KPiAgIA0KPiAraW50IG1mX2RheF9tYXBwaW5nX2tp bGxfcHJvY3Moc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsIHBnb2ZmX3QgaW5kZXgsIGlu dCBmbGFncykNCj4gK3sNCj4gKwljb25zdCBib29sIHVubWFwX3N1Y2Nlc3MgPSB0cnVlOw0KPiAr CXVuc2lnbmVkIGxvbmcgcGZuLCBzaXplID0gMDsNCj4gKwlzdHJ1Y3QgdG9fa2lsbCAqdGs7DQo+ ICsJTElTVF9IRUFEKHRvX2tpbGwpOw0KPiArCWludCByYyA9IC1FQlVTWTsNCj4gKwlsb2ZmX3Qg c3RhcnQ7DQo+ICsNCj4gKwkvKiBsb2FkIHRoZSBwZm4gb2YgdGhlIGRheCBtYXBwaW5nIGZpbGUg Ki8NCj4gKwlwZm4gPSBkYXhfbG9hZF9wZm4obWFwcGluZywgaW5kZXgpOw0KPiArCWlmICghcGZu KQ0KPiArCQlyZXR1cm4gcmM7DQo+ICsJLyoNCj4gKwkgKiBVbmxpa2UgU3lzdGVtLVJBTSB0aGVy ZSBpcyBubyBwb3NzaWJpbGl0eSB0byBzd2FwIGluIGENCj4gKwkgKiBkaWZmZXJlbnQgcGh5c2lj YWwgcGFnZSBhdCBhIGdpdmVuIHZpcnR1YWwgYWRkcmVzcywgc28gYWxsDQo+ICsJICogdXNlcnNw YWNlIGNvbnN1bXB0aW9uIG9mIFpPTkVfREVWSUNFIG1lbW9yeSBuZWNlc3NpdGF0ZXMNCj4gKwkg KiBTSUdCVVMgKGkuZS4gTUZfTVVTVF9LSUxMKQ0KPiArCSAqLw0KPiArCWZsYWdzIHw9IE1GX0FD VElPTl9SRVFVSVJFRCB8IE1GX01VU1RfS0lMTDsNCg0KTUZfQUNUSU9OX1JFUVVJUkVEIG9ubHkg a2lsbCB0aGUgY3VycmVudCBleGVjdXRpb24gY29udGV4dC4gQSBwYWdlIGNhbiBiZSBzaGFyZWQN CndoZW4gcmVmbGluayBmaWxlIGJlIG1hcHBlZCBieSBkaWZmZXJlbnQgcHJvY2Vzcy4gV2UgY2Fu IG5vdCBraWxsIGFsbCBwcm9jZXNzDQpzaGFyZWQgdGhlIHBhZ2UuICBPdGhlciBwcm9jZXNzIHN0 aWxsIGNhbiBhY2Nlc3MgdGhlIHBvc2lvbmVkIHBhZ2UgPw0KDQpUaGFua3MsDQp6aG9uZyBqaWFu Zw0KDQo+ICsJY29sbGVjdF9wcm9jc19maWxlKHBmbl90b19wYWdlKHBmbiksIG1hcHBpbmcsIGlu ZGV4LCAmdG9fa2lsbCwNCj4gKwkJCSAgIGZsYWdzICYgTUZfQUNUSU9OX1JFUVVJUkVEKTsNCj4g Kw0KPiArCWxpc3RfZm9yX2VhY2hfZW50cnkodGssICZ0b19raWxsLCBuZCkNCj4gKwkJaWYgKHRr LT5zaXplX3NoaWZ0KQ0KPiArCQkJc2l6ZSA9IG1heChzaXplLCAxVUwgPDwgdGstPnNpemVfc2hp ZnQpOw0KPiArCWlmIChzaXplKSB7DQo+ICsJCS8qDQo+ICsJCSAqIFVubWFwIHRoZSBsYXJnZXN0 IG1hcHBpbmcgdG8gYXZvaWQgYnJlYWtpbmcgdXANCj4gKwkJICogZGV2aWNlLWRheCBtYXBwaW5n cyB3aGljaCBhcmUgY29uc3RhbnQgc2l6ZS4gVGhlDQo+ICsJCSAqIGFjdHVhbCBzaXplIG9mIHRo ZSBtYXBwaW5nIGJlaW5nIHRvcm4gZG93biBpcw0KPiArCQkgKiBjb21tdW5pY2F0ZWQgaW4gc2ln aW5mbywgc2VlIGtpbGxfcHJvYygpDQo+ICsJCSAqLw0KPiArCQlzdGFydCA9IChpbmRleCA8PCBQ QUdFX1NISUZUKSAmIH4oc2l6ZSAtIDEpOw0KPiArCQl1bm1hcF9tYXBwaW5nX3JhbmdlKG1hcHBp bmcsIHN0YXJ0LCBzdGFydCArIHNpemUsIDApOw0KPiArCX0NCj4gKw0KPiArCWtpbGxfcHJvY3Mo JnRvX2tpbGwsIGZsYWdzICYgTUZfTVVTVF9LSUxMLCAhdW5tYXBfc3VjY2VzcywNCj4gKwkJICAg cGZuLCBmbGFncyk7DQo+ICsJcmMgPSAwOw0KPiArCXJldHVybiByYzsNCj4gK30NCj4gK0VYUE9S VF9TWU1CT0xfR1BMKG1mX2RheF9tYXBwaW5nX2tpbGxfcHJvY3MpOw0KPiArDQo+ICAgc3RhdGlj IGludCBtZW1vcnlfZmFpbHVyZV9odWdldGxiKHVuc2lnbmVkIGxvbmcgcGZuLCBpbnQgZmxhZ3Mp DQo+ICAgew0KPiAgIAlzdHJ1Y3QgcGFnZSAqcCA9IHBmbl90b19wYWdlKHBmbik7DQo+IEBAIC0x Mjk3LDcgKzEzNDYsNyBAQCBzdGF0aWMgaW50IG1lbW9yeV9mYWlsdXJlX2Rldl9wYWdlbWFwKHVu c2lnbmVkIGxvbmcgcGZuLCBpbnQgZmxhZ3MsDQo+ICAgCWNvbnN0IGJvb2wgdW5tYXBfc3VjY2Vz cyA9IHRydWU7DQo+ICAgCXVuc2lnbmVkIGxvbmcgc2l6ZSA9IDA7DQo+ICAgCXN0cnVjdCB0b19r aWxsICp0azsNCj4gLQlMSVNUX0hFQUQodG9raWxsKTsNCj4gKwlMSVNUX0hFQUQodG9fa2lsbCk7 DQo+ICAgCWludCByYyA9IC1FQlVTWTsNCj4gICAJbG9mZl90IHN0YXJ0Ow0KPiAgIAlkYXhfZW50 cnlfdCBjb29raWU7DQo+IEBAIC0xMzQ1LDkgKzEzOTQsMTAgQEAgc3RhdGljIGludCBtZW1vcnlf ZmFpbHVyZV9kZXZfcGFnZW1hcCh1bnNpZ25lZCBsb25nIHBmbiwgaW50IGZsYWdzLA0KPiAgIAkg KiBTSUdCVVMgKGkuZS4gTUZfTVVTVF9LSUxMKQ0KPiAgIAkgKi8NCj4gICAJZmxhZ3MgfD0gTUZf QUNUSU9OX1JFUVVJUkVEIHwgTUZfTVVTVF9LSUxMOw0KPiAtCWNvbGxlY3RfcHJvY3MocGFnZSwg JnRva2lsbCwgZmxhZ3MgJiBNRl9BQ1RJT05fUkVRVUlSRUQpOw0KPiArCWNvbGxlY3RfcHJvY3Nf ZmlsZShwYWdlLCBwYWdlLT5tYXBwaW5nLCBwYWdlLT5pbmRleCwgJnRvX2tpbGwsDQo+ICsJCQkg ICBmbGFncyAmIE1GX0FDVElPTl9SRVFVSVJFRCk7DQo+ICAgDQo+IC0JbGlzdF9mb3JfZWFjaF9l bnRyeSh0aywgJnRva2lsbCwgbmQpDQo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeSh0aywgJnRvX2tp bGwsIG5kKQ0KPiAgIAkJaWYgKHRrLT5zaXplX3NoaWZ0KQ0KPiAgIAkJCXNpemUgPSBtYXgoc2l6 ZSwgMVVMIDw8IHRrLT5zaXplX3NoaWZ0KTsNCj4gICAJaWYgKHNpemUpIHsNCj4gQEAgLTEzNjAs NyArMTQxMCw3IEBAIHN0YXRpYyBpbnQgbWVtb3J5X2ZhaWx1cmVfZGV2X3BhZ2VtYXAodW5zaWdu ZWQgbG9uZyBwZm4sIGludCBmbGFncywNCj4gICAJCXN0YXJ0ID0gKHBhZ2UtPmluZGV4IDw8IFBB R0VfU0hJRlQpICYgfihzaXplIC0gMSk7DQo+ICAgCQl1bm1hcF9tYXBwaW5nX3JhbmdlKHBhZ2Ut Pm1hcHBpbmcsIHN0YXJ0LCBzdGFydCArIHNpemUsIDApOw0KPiAgIAl9DQo+IC0Ja2lsbF9wcm9j cygmdG9raWxsLCBmbGFncyAmIE1GX01VU1RfS0lMTCwgIXVubWFwX3N1Y2Nlc3MsIHBmbiwgZmxh Z3MpOw0KPiArCWtpbGxfcHJvY3MoJnRvX2tpbGwsIGZsYWdzICYgTUZfTVVTVF9LSUxMLCAhdW5t YXBfc3VjY2VzcywgcGZuLCBmbGFncyk7DQo+ICAgCXJjID0gMDsNCj4gICB1bmxvY2s6DQo+ICAg CWRheF91bmxvY2tfcGFnZShwYWdlLCBjb29raWUpOwpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1udmRpbW0gbWFpbGluZyBsaXN0IC0tIGxpbnV4 LW52ZGltbUBsaXN0cy4wMS5vcmcKVG8gdW5zdWJzY3JpYmUgc2VuZCBhbiBlbWFpbCB0byBsaW51 eC1udmRpbW0tbGVhdmVAbGlzdHMuMDEub3JnCg== 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=-15.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_SANE_1 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 57EA7C433E9 for ; Tue, 16 Mar 2021 03:22:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1E21D6509E for ; Tue, 16 Mar 2021 03:22:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234843AbhCPDWL (ORCPT ); Mon, 15 Mar 2021 23:22:11 -0400 Received: from out30-56.freemail.mail.aliyun.com ([115.124.30.56]:59263 "EHLO out30-56.freemail.mail.aliyun.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230177AbhCPDVr (ORCPT ); Mon, 15 Mar 2021 23:21:47 -0400 X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R801e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=e01e04426;MF=zhongjiang-ali@linux.alibaba.com;NM=1;PH=DS;RN=16;SR=0;TI=SMTPD_---0US4IWG9_1615864901; Received: from L-X1DSLVDL-1420.local(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0US4IWG9_1615864901) by smtp.aliyun-inc.com(127.0.0.1); Tue, 16 Mar 2021 11:21:42 +0800 Message-ID: Date: Tue, 16 Mar 2021 11:21:41 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:87.0) Gecko/20100101 Thunderbird/87.0 Subject: Re: [PATCH v3 05/11] mm, fsdax: Refactor memory-failure handler for dax mapping Content-Language: en-US To: Shiyang Ruan , linux-kernel@vger.kernel.org, linux-xfs@vger.kernel.org, linux-nvdimm@lists.01.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, dm-devel@redhat.com Cc: darrick.wong@oracle.com, dan.j.williams@intel.com, david@fromorbit.com, hch@lst.de, agk@redhat.com, snitzer@redhat.com, rgoldwyn@suse.de, qi.fuli@fujitsu.com, y-goto@fujitsu.com References: <20210208105530.3072869-1-ruansy.fnst@cn.fujitsu.com> <20210208105530.3072869-6-ruansy.fnst@cn.fujitsu.com> From: zhong jiang In-Reply-To: <20210208105530.3072869-6-ruansy.fnst@cn.fujitsu.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 2021/2/8 6:55 下午, Shiyang Ruan wrote: > The current memory_failure_dev_pagemap() can only handle single-mapped > dax page for fsdax mode. The dax page could be mapped by multiple files > and offsets if we let reflink feature & fsdax mode work together. So, > we refactor current implementation to support handle memory failure on > each file and offset. > > Signed-off-by: Shiyang Ruan > --- > fs/dax.c | 21 ++++++++++ > include/linux/dax.h | 1 + > include/linux/mm.h | 9 +++++ > mm/memory-failure.c | 98 ++++++++++++++++++++++++++++++++++----------- > 4 files changed, 105 insertions(+), 24 deletions(-) > > diff --git a/fs/dax.c b/fs/dax.c > index 26d5dcd2d69e..c64c3a0e76a6 100644 > --- a/fs/dax.c > +++ b/fs/dax.c > @@ -378,6 +378,27 @@ static struct page *dax_busy_page(void *entry) > return NULL; > } > > +/* > + * dax_load_pfn - Load pfn of the DAX entry corresponding to a page > + * @mapping: The file whose entry we want to load > + * @index: The offset where the DAX entry located in > + * > + * Return: pfn of the DAX entry > + */ > +unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index) > +{ > + XA_STATE(xas, &mapping->i_pages, index); > + void *entry; > + unsigned long pfn; > + > + xas_lock_irq(&xas); > + entry = xas_load(&xas); > + pfn = dax_to_pfn(entry); > + xas_unlock_irq(&xas); > + > + return pfn; > +} > + > /* > * dax_lock_mapping_entry - Lock the DAX entry corresponding to a page > * @page: The page whose entry we want to lock > diff --git a/include/linux/dax.h b/include/linux/dax.h > index b52f084aa643..89e56ceeffc7 100644 > --- a/include/linux/dax.h > +++ b/include/linux/dax.h > @@ -150,6 +150,7 @@ int dax_writeback_mapping_range(struct address_space *mapping, > > struct page *dax_layout_busy_page(struct address_space *mapping); > struct page *dax_layout_busy_page_range(struct address_space *mapping, loff_t start, loff_t end); > +unsigned long dax_load_pfn(struct address_space *mapping, unsigned long index); > dax_entry_t dax_lock_page(struct page *page); > void dax_unlock_page(struct page *page, dax_entry_t cookie); > #else > diff --git a/include/linux/mm.h b/include/linux/mm.h > index ecdf8a8cd6ae..ab52bc633d84 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -1157,6 +1157,14 @@ static inline bool is_device_private_page(const struct page *page) > page->pgmap->type == MEMORY_DEVICE_PRIVATE; > } > > +static inline bool is_device_fsdax_page(const struct page *page) > +{ > + return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) && > + IS_ENABLED(CONFIG_FS_DAX) && > + is_zone_device_page(page) && > + page->pgmap->type == MEMORY_DEVICE_FS_DAX; > +} > + > static inline bool is_pci_p2pdma_page(const struct page *page) > { > return IS_ENABLED(CONFIG_DEV_PAGEMAP_OPS) && > @@ -3045,6 +3053,7 @@ enum mf_flags { > MF_MUST_KILL = 1 << 2, > MF_SOFT_OFFLINE = 1 << 3, > }; > +extern int mf_dax_mapping_kill_procs(struct address_space *mapping, pgoff_t index, int flags); > extern int memory_failure(unsigned long pfn, int flags); > extern void memory_failure_queue(unsigned long pfn, int flags); > extern void memory_failure_queue_kick(int cpu); > diff --git a/mm/memory-failure.c b/mm/memory-failure.c > index e9481632fcd1..158fe0c8e602 100644 > --- a/mm/memory-failure.c > +++ b/mm/memory-failure.c > @@ -56,6 +56,7 @@ > #include > #include > #include > +#include > #include "internal.h" > #include "ras/ras_event.h" > > @@ -120,6 +121,13 @@ static int hwpoison_filter_dev(struct page *p) > if (PageSlab(p)) > return -EINVAL; > > + if (pfn_valid(page_to_pfn(p))) { > + if (is_device_fsdax_page(p)) > + return 0; > + else > + return -EINVAL; > + } > + > mapping = page_mapping(p); > if (mapping == NULL || mapping->host == NULL) > return -EINVAL; > @@ -286,10 +294,9 @@ void shake_page(struct page *p, int access) > } > EXPORT_SYMBOL_GPL(shake_page); > > -static unsigned long dev_pagemap_mapping_shift(struct page *page, > - struct vm_area_struct *vma) > +static unsigned long dev_pagemap_mapping_shift(struct vm_area_struct *vma, > + unsigned long address) > { > - unsigned long address = vma_address(page, vma); > pgd_t *pgd; > p4d_t *p4d; > pud_t *pud; > @@ -329,9 +336,8 @@ static unsigned long dev_pagemap_mapping_shift(struct page *page, > * Schedule a process for later kill. > * Uses GFP_ATOMIC allocations to avoid potential recursions in the VM. > */ > -static void add_to_kill(struct task_struct *tsk, struct page *p, > - struct vm_area_struct *vma, > - struct list_head *to_kill) > +static void add_to_kill(struct task_struct *tsk, struct page *p, pgoff_t pgoff, > + struct vm_area_struct *vma, struct list_head *to_kill) > { > struct to_kill *tk; > > @@ -342,9 +348,12 @@ static void add_to_kill(struct task_struct *tsk, struct page *p, > } > > tk->addr = page_address_in_vma(p, vma); > - if (is_zone_device_page(p)) > - tk->size_shift = dev_pagemap_mapping_shift(p, vma); > - else > + if (is_zone_device_page(p)) { > + if (is_device_fsdax_page(p)) > + tk->addr = vma->vm_start + > + ((pgoff - vma->vm_pgoff) << PAGE_SHIFT); > + tk->size_shift = dev_pagemap_mapping_shift(vma, tk->addr); > + } else > tk->size_shift = page_shift(compound_head(p)); > > /* > @@ -492,7 +501,7 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill, > if (!page_mapped_in_vma(page, vma)) > continue; > if (vma->vm_mm == t->mm) > - add_to_kill(t, page, vma, to_kill); > + add_to_kill(t, page, 0, vma, to_kill); > } > } > read_unlock(&tasklist_lock); > @@ -502,24 +511,19 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill, > /* > * Collect processes when the error hit a file mapped page. > */ > -static void collect_procs_file(struct page *page, struct list_head *to_kill, > - int force_early) > +static void collect_procs_file(struct page *page, struct address_space *mapping, > + pgoff_t pgoff, struct list_head *to_kill, int force_early) > { > struct vm_area_struct *vma; > struct task_struct *tsk; > - struct address_space *mapping = page->mapping; > - pgoff_t pgoff; > > i_mmap_lock_read(mapping); > read_lock(&tasklist_lock); > - pgoff = page_to_pgoff(page); > for_each_process(tsk) { > struct task_struct *t = task_early_kill(tsk, force_early); > - > if (!t) > continue; > - vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, > - pgoff) { > + vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) { > /* > * Send early kill signal to tasks where a vma covers > * the page but the corrupted page is not necessarily > @@ -528,7 +532,7 @@ static void collect_procs_file(struct page *page, struct list_head *to_kill, > * to be informed of all such data corruptions. > */ > if (vma->vm_mm == t->mm) > - add_to_kill(t, page, vma, to_kill); > + add_to_kill(t, page, pgoff, vma, to_kill); > } > } > read_unlock(&tasklist_lock); > @@ -547,7 +551,8 @@ static void collect_procs(struct page *page, struct list_head *tokill, > if (PageAnon(page)) > collect_procs_anon(page, tokill, force_early); > else > - collect_procs_file(page, tokill, force_early); > + collect_procs_file(page, page_mapping(page), page_to_pgoff(page), > + tokill, force_early); > } > > static const char *action_name[] = { > @@ -1214,6 +1219,50 @@ static int try_to_split_thp_page(struct page *page, const char *msg) > return 0; > } > > +int mf_dax_mapping_kill_procs(struct address_space *mapping, pgoff_t index, int flags) > +{ > + const bool unmap_success = true; > + unsigned long pfn, size = 0; > + struct to_kill *tk; > + LIST_HEAD(to_kill); > + int rc = -EBUSY; > + loff_t start; > + > + /* load the pfn of the dax mapping file */ > + pfn = dax_load_pfn(mapping, index); > + if (!pfn) > + return rc; > + /* > + * Unlike System-RAM there is no possibility to swap in a > + * different physical page at a given virtual address, so all > + * userspace consumption of ZONE_DEVICE memory necessitates > + * SIGBUS (i.e. MF_MUST_KILL) > + */ > + flags |= MF_ACTION_REQUIRED | MF_MUST_KILL; MF_ACTION_REQUIRED only kill the current execution context. A page can be shared when reflink file be mapped by different process. We can not kill all process shared the page. Other process still can access the posioned page ? Thanks, zhong jiang > + collect_procs_file(pfn_to_page(pfn), mapping, index, &to_kill, > + flags & MF_ACTION_REQUIRED); > + > + list_for_each_entry(tk, &to_kill, nd) > + if (tk->size_shift) > + size = max(size, 1UL << tk->size_shift); > + if (size) { > + /* > + * Unmap the largest mapping to avoid breaking up > + * device-dax mappings which are constant size. The > + * actual size of the mapping being torn down is > + * communicated in siginfo, see kill_proc() > + */ > + start = (index << PAGE_SHIFT) & ~(size - 1); > + unmap_mapping_range(mapping, start, start + size, 0); > + } > + > + kill_procs(&to_kill, flags & MF_MUST_KILL, !unmap_success, > + pfn, flags); > + rc = 0; > + return rc; > +} > +EXPORT_SYMBOL_GPL(mf_dax_mapping_kill_procs); > + > static int memory_failure_hugetlb(unsigned long pfn, int flags) > { > struct page *p = pfn_to_page(pfn); > @@ -1297,7 +1346,7 @@ static int memory_failure_dev_pagemap(unsigned long pfn, int flags, > const bool unmap_success = true; > unsigned long size = 0; > struct to_kill *tk; > - LIST_HEAD(tokill); > + LIST_HEAD(to_kill); > int rc = -EBUSY; > loff_t start; > dax_entry_t cookie; > @@ -1345,9 +1394,10 @@ static int memory_failure_dev_pagemap(unsigned long pfn, int flags, > * SIGBUS (i.e. MF_MUST_KILL) > */ > flags |= MF_ACTION_REQUIRED | MF_MUST_KILL; > - collect_procs(page, &tokill, flags & MF_ACTION_REQUIRED); > + collect_procs_file(page, page->mapping, page->index, &to_kill, > + flags & MF_ACTION_REQUIRED); > > - list_for_each_entry(tk, &tokill, nd) > + list_for_each_entry(tk, &to_kill, nd) > if (tk->size_shift) > size = max(size, 1UL << tk->size_shift); > if (size) { > @@ -1360,7 +1410,7 @@ static int memory_failure_dev_pagemap(unsigned long pfn, int flags, > start = (page->index << PAGE_SHIFT) & ~(size - 1); > unmap_mapping_range(page->mapping, start, start + size, 0); > } > - kill_procs(&tokill, flags & MF_MUST_KILL, !unmap_success, pfn, flags); > + kill_procs(&to_kill, flags & MF_MUST_KILL, !unmap_success, pfn, flags); > rc = 0; > unlock: > dax_unlock_page(page, cookie); 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=-15.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_SANE_1 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 8D5B2C433E0 for ; Tue, 16 Mar 2021 06:54:47 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A8D816511D for ; Tue, 16 Mar 2021 06:54:46 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A8D816511D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.alibaba.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-602-aw03sqq4Pi6A7-2DBD1o6w-1; Tue, 16 Mar 2021 02:54:42 -0400 X-MC-Unique: aw03sqq4Pi6A7-2DBD1o6w-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id C825719057A1; Tue, 16 Mar 2021 06:54:37 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 8562D6BC2D; Tue, 16 Mar 2021 06:54:37 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 9194B4A717; Tue, 16 Mar 2021 06:54:36 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.rdu2.redhat.com [10.11.54.5]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 12G3RFoj004109 for ; Mon, 15 Mar 2021 23:27:16 -0400 Received: by smtp.corp.redhat.com (Postfix) id 9B531568F1; Tue, 16 Mar 2021 03:27:15 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast05.extmail.prod.ext.rdu2.redhat.com [10.11.55.21]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 95D5D6CA80 for ; Tue, 16 Mar 2021 03:27:13 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 257B180B91F for ; Tue, 16 Mar 2021 03:27:13 +0000 (UTC) Received: from out30-132.freemail.mail.aliyun.com (out30-132.freemail.mail.aliyun.com [115.124.30.132]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-571-HtiW6SLnNeizXTMjM2tGtQ-1; Mon, 15 Mar 2021 23:27:07 -0400 X-MC-Unique: HtiW6SLnNeizXTMjM2tGtQ-1 X-Alimail-AntiSpam: AC=PASS; BC=-1|-1; BR=01201311R801e4; CH=green; DM=||false|; DS=||; FP=0|-1|-1|-1|0|-1|-1|-1; HT=e01e04426; MF=zhongjiang-ali@linux.alibaba.com; NM=1; PH=DS; RN=16; SR=0; TI=SMTPD_---0US4IWG9_1615864901 Received: from L-X1DSLVDL-1420.local(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0US4IWG9_1615864901) by smtp.aliyun-inc.com(127.0.0.1); Tue, 16 Mar 2021 11:21:42 +0800 Message-ID: Date: Tue, 16 Mar 2021 11:21:41 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:87.0) Gecko/20100101 Thunderbird/87.0 To: Shiyang Ruan , linux-kernel@vger.kernel.org, linux-xfs@vger.kernel.org, linux-nvdimm@lists.01.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, dm-devel@redhat.com References: <20210208105530.3072869-1-ruansy.fnst@cn.fujitsu.com> <20210208105530.3072869-6-ruansy.fnst@cn.fujitsu.com> From: zhong jiang In-Reply-To: <20210208105530.3072869-6-ruansy.fnst@cn.fujitsu.com> X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.79 on 10.11.54.5 X-loop: dm-devel@redhat.com X-Mailman-Approved-At: Tue, 16 Mar 2021 02:54:36 -0400 Cc: qi.fuli@fujitsu.com, snitzer@redhat.com, darrick.wong@oracle.com, rgoldwyn@suse.de, david@fromorbit.com, y-goto@fujitsu.com, dan.j.williams@intel.com, hch@lst.de, agk@redhat.com Subject: Re: [dm-devel] [PATCH v3 05/11] mm, fsdax: Refactor memory-failure handler for dax mapping X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Ck9uIDIwMjEvMi84IDY6NTUg5LiL5Y2ILCBTaGl5YW5nIFJ1YW4gd3JvdGU6Cj4gVGhlIGN1cnJl bnQgbWVtb3J5X2ZhaWx1cmVfZGV2X3BhZ2VtYXAoKSBjYW4gb25seSBoYW5kbGUgc2luZ2xlLW1h cHBlZAo+IGRheCBwYWdlIGZvciBmc2RheCBtb2RlLiAgVGhlIGRheCBwYWdlIGNvdWxkIGJlIG1h cHBlZCBieSBtdWx0aXBsZSBmaWxlcwo+IGFuZCBvZmZzZXRzIGlmIHdlIGxldCByZWZsaW5rIGZl YXR1cmUgJiBmc2RheCBtb2RlIHdvcmsgdG9nZXRoZXIuICBTbywKPiB3ZSByZWZhY3RvciBjdXJy ZW50IGltcGxlbWVudGF0aW9uIHRvIHN1cHBvcnQgaGFuZGxlIG1lbW9yeSBmYWlsdXJlIG9uCj4g ZWFjaCBmaWxlIGFuZCBvZmZzZXQuCj4KPiBTaWduZWQtb2ZmLWJ5OiBTaGl5YW5nIFJ1YW4gPHJ1 YW5zeS5mbnN0QGNuLmZ1aml0c3UuY29tPgo+IC0tLQo+ICAgZnMvZGF4LmMgICAgICAgICAgICB8 IDIxICsrKysrKysrKysKPiAgIGluY2x1ZGUvbGludXgvZGF4LmggfCAgMSArCj4gICBpbmNsdWRl L2xpbnV4L21tLmggIHwgIDkgKysrKysKPiAgIG1tL21lbW9yeS1mYWlsdXJlLmMgfCA5OCArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0KPiAgIDQgZmlsZXMgY2hh bmdlZCwgMTA1IGluc2VydGlvbnMoKyksIDI0IGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdpdCBh L2ZzL2RheC5jIGIvZnMvZGF4LmMKPiBpbmRleCAyNmQ1ZGNkMmQ2OWUuLmM2NGMzYTBlNzZhNiAx MDA2NDQKPiAtLS0gYS9mcy9kYXguYwo+ICsrKyBiL2ZzL2RheC5jCj4gQEAgLTM3OCw2ICszNzgs MjcgQEAgc3RhdGljIHN0cnVjdCBwYWdlICpkYXhfYnVzeV9wYWdlKHZvaWQgKmVudHJ5KQo+ICAg CXJldHVybiBOVUxMOwo+ICAgfQo+ICAgCj4gKy8qCj4gKyAqIGRheF9sb2FkX3BmbiAtIExvYWQg cGZuIG9mIHRoZSBEQVggZW50cnkgY29ycmVzcG9uZGluZyB0byBhIHBhZ2UKPiArICogQG1hcHBp bmc6IFRoZSBmaWxlIHdob3NlIGVudHJ5IHdlIHdhbnQgdG8gbG9hZAo+ICsgKiBAaW5kZXg6ICAg VGhlIG9mZnNldCB3aGVyZSB0aGUgREFYIGVudHJ5IGxvY2F0ZWQgaW4KPiArICoKPiArICogUmV0 dXJuOiAgIHBmbiBvZiB0aGUgREFYIGVudHJ5Cj4gKyAqLwo+ICt1bnNpZ25lZCBsb25nIGRheF9s b2FkX3BmbihzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZywgdW5zaWduZWQgbG9uZyBpbmRl eCkKPiArewo+ICsJWEFfU1RBVEUoeGFzLCAmbWFwcGluZy0+aV9wYWdlcywgaW5kZXgpOwo+ICsJ dm9pZCAqZW50cnk7Cj4gKwl1bnNpZ25lZCBsb25nIHBmbjsKPiArCj4gKwl4YXNfbG9ja19pcnEo Jnhhcyk7Cj4gKwllbnRyeSA9IHhhc19sb2FkKCZ4YXMpOwo+ICsJcGZuID0gZGF4X3RvX3Bmbihl bnRyeSk7Cj4gKwl4YXNfdW5sb2NrX2lycSgmeGFzKTsKPiArCj4gKwlyZXR1cm4gcGZuOwo+ICt9 Cj4gKwo+ICAgLyoKPiAgICAqIGRheF9sb2NrX21hcHBpbmdfZW50cnkgLSBMb2NrIHRoZSBEQVgg ZW50cnkgY29ycmVzcG9uZGluZyB0byBhIHBhZ2UKPiAgICAqIEBwYWdlOiBUaGUgcGFnZSB3aG9z ZSBlbnRyeSB3ZSB3YW50IHRvIGxvY2sKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kYXgu aCBiL2luY2x1ZGUvbGludXgvZGF4LmgKPiBpbmRleCBiNTJmMDg0YWE2NDMuLjg5ZTU2Y2VlZmZj NyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L2RheC5oCj4gKysrIGIvaW5jbHVkZS9saW51 eC9kYXguaAo+IEBAIC0xNTAsNiArMTUwLDcgQEAgaW50IGRheF93cml0ZWJhY2tfbWFwcGluZ19y YW5nZShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZywKPiAgIAo+ICAgc3RydWN0IHBhZ2Ug KmRheF9sYXlvdXRfYnVzeV9wYWdlKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKTsKPiAg IHN0cnVjdCBwYWdlICpkYXhfbGF5b3V0X2J1c3lfcGFnZV9yYW5nZShzdHJ1Y3QgYWRkcmVzc19z cGFjZSAqbWFwcGluZywgbG9mZl90IHN0YXJ0LCBsb2ZmX3QgZW5kKTsKPiArdW5zaWduZWQgbG9u ZyBkYXhfbG9hZF9wZm4oc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcsIHVuc2lnbmVkIGxv bmcgaW5kZXgpOwo+ICAgZGF4X2VudHJ5X3QgZGF4X2xvY2tfcGFnZShzdHJ1Y3QgcGFnZSAqcGFn ZSk7Cj4gICB2b2lkIGRheF91bmxvY2tfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSwgZGF4X2VudHJ5 X3QgY29va2llKTsKPiAgICNlbHNlCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW0uaCBi L2luY2x1ZGUvbGludXgvbW0uaAo+IGluZGV4IGVjZGY4YThjZDZhZS4uYWI1MmJjNjMzZDg0IDEw MDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbW0uaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvbW0u aAo+IEBAIC0xMTU3LDYgKzExNTcsMTQgQEAgc3RhdGljIGlubGluZSBib29sIGlzX2RldmljZV9w cml2YXRlX3BhZ2UoY29uc3Qgc3RydWN0IHBhZ2UgKnBhZ2UpCj4gICAJCXBhZ2UtPnBnbWFwLT50 eXBlID09IE1FTU9SWV9ERVZJQ0VfUFJJVkFURTsKPiAgIH0KPiAgIAo+ICtzdGF0aWMgaW5saW5l IGJvb2wgaXNfZGV2aWNlX2ZzZGF4X3BhZ2UoY29uc3Qgc3RydWN0IHBhZ2UgKnBhZ2UpCj4gK3sK PiArCXJldHVybiBJU19FTkFCTEVEKENPTkZJR19ERVZfUEFHRU1BUF9PUFMpICYmCj4gKwkJSVNf RU5BQkxFRChDT05GSUdfRlNfREFYKSAmJgo+ICsJCWlzX3pvbmVfZGV2aWNlX3BhZ2UocGFnZSkg JiYKPiArCQlwYWdlLT5wZ21hcC0+dHlwZSA9PSBNRU1PUllfREVWSUNFX0ZTX0RBWDsKPiArfQo+ ICsKPiAgIHN0YXRpYyBpbmxpbmUgYm9vbCBpc19wY2lfcDJwZG1hX3BhZ2UoY29uc3Qgc3RydWN0 IHBhZ2UgKnBhZ2UpCj4gICB7Cj4gICAJcmV0dXJuIElTX0VOQUJMRUQoQ09ORklHX0RFVl9QQUdF TUFQX09QUykgJiYKPiBAQCAtMzA0NSw2ICszMDUzLDcgQEAgZW51bSBtZl9mbGFncyB7Cj4gICAJ TUZfTVVTVF9LSUxMID0gMSA8PCAyLAo+ICAgCU1GX1NPRlRfT0ZGTElORSA9IDEgPDwgMywKPiAg IH07Cj4gK2V4dGVybiBpbnQgbWZfZGF4X21hcHBpbmdfa2lsbF9wcm9jcyhzdHJ1Y3QgYWRkcmVz c19zcGFjZSAqbWFwcGluZywgcGdvZmZfdCBpbmRleCwgaW50IGZsYWdzKTsKPiAgIGV4dGVybiBp bnQgbWVtb3J5X2ZhaWx1cmUodW5zaWduZWQgbG9uZyBwZm4sIGludCBmbGFncyk7Cj4gICBleHRl cm4gdm9pZCBtZW1vcnlfZmFpbHVyZV9xdWV1ZSh1bnNpZ25lZCBsb25nIHBmbiwgaW50IGZsYWdz KTsKPiAgIGV4dGVybiB2b2lkIG1lbW9yeV9mYWlsdXJlX3F1ZXVlX2tpY2soaW50IGNwdSk7Cj4g ZGlmZiAtLWdpdCBhL21tL21lbW9yeS1mYWlsdXJlLmMgYi9tbS9tZW1vcnktZmFpbHVyZS5jCj4g aW5kZXggZTk0ODE2MzJmY2QxLi4xNThmZTBjOGU2MDIgMTAwNjQ0Cj4gLS0tIGEvbW0vbWVtb3J5 LWZhaWx1cmUuYwo+ICsrKyBiL21tL21lbW9yeS1mYWlsdXJlLmMKPiBAQCAtNTYsNiArNTYsNyBA QAo+ICAgI2luY2x1ZGUgPGxpbnV4L2tmaWZvLmg+Cj4gICAjaW5jbHVkZSA8bGludXgvcmF0ZWxp bWl0Lmg+Cj4gICAjaW5jbHVkZSA8bGludXgvcGFnZS1pc29sYXRpb24uaD4KPiArI2luY2x1ZGUg PGxpbnV4L2RheC5oPgo+ICAgI2luY2x1ZGUgImludGVybmFsLmgiCj4gICAjaW5jbHVkZSAicmFz L3Jhc19ldmVudC5oIgo+ICAgCj4gQEAgLTEyMCw2ICsxMjEsMTMgQEAgc3RhdGljIGludCBod3Bv aXNvbl9maWx0ZXJfZGV2KHN0cnVjdCBwYWdlICpwKQo+ICAgCWlmIChQYWdlU2xhYihwKSkKPiAg IAkJcmV0dXJuIC1FSU5WQUw7Cj4gICAKPiArCWlmIChwZm5fdmFsaWQocGFnZV90b19wZm4ocCkp KSB7Cj4gKwkJaWYgKGlzX2RldmljZV9mc2RheF9wYWdlKHApKQo+ICsJCQlyZXR1cm4gMDsKPiAr CQllbHNlCj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiAgIAltYXBwaW5nID0gcGFn ZV9tYXBwaW5nKHApOwo+ICAgCWlmIChtYXBwaW5nID09IE5VTEwgfHwgbWFwcGluZy0+aG9zdCA9 PSBOVUxMKQo+ICAgCQlyZXR1cm4gLUVJTlZBTDsKPiBAQCAtMjg2LDEwICsyOTQsOSBAQCB2b2lk IHNoYWtlX3BhZ2Uoc3RydWN0IHBhZ2UgKnAsIGludCBhY2Nlc3MpCj4gICB9Cj4gICBFWFBPUlRf U1lNQk9MX0dQTChzaGFrZV9wYWdlKTsKPiAgIAo+IC1zdGF0aWMgdW5zaWduZWQgbG9uZyBkZXZf cGFnZW1hcF9tYXBwaW5nX3NoaWZ0KHN0cnVjdCBwYWdlICpwYWdlLAo+IC0JCXN0cnVjdCB2bV9h cmVhX3N0cnVjdCAqdm1hKQo+ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBkZXZfcGFnZW1hcF9tYXBw aW5nX3NoaWZ0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+ICsJCQkJCSAgICAgICB1bnNp Z25lZCBsb25nIGFkZHJlc3MpCj4gICB7Cj4gLQl1bnNpZ25lZCBsb25nIGFkZHJlc3MgPSB2bWFf YWRkcmVzcyhwYWdlLCB2bWEpOwo+ICAgCXBnZF90ICpwZ2Q7Cj4gICAJcDRkX3QgKnA0ZDsKPiAg IAlwdWRfdCAqcHVkOwo+IEBAIC0zMjksOSArMzM2LDggQEAgc3RhdGljIHVuc2lnbmVkIGxvbmcg ZGV2X3BhZ2VtYXBfbWFwcGluZ19zaGlmdChzdHJ1Y3QgcGFnZSAqcGFnZSwKPiAgICAqIFNjaGVk dWxlIGEgcHJvY2VzcyBmb3IgbGF0ZXIga2lsbC4KPiAgICAqIFVzZXMgR0ZQX0FUT01JQyBhbGxv Y2F0aW9ucyB0byBhdm9pZCBwb3RlbnRpYWwgcmVjdXJzaW9ucyBpbiB0aGUgVk0uCj4gICAgKi8K PiAtc3RhdGljIHZvaWQgYWRkX3RvX2tpbGwoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssIHN0cnVj dCBwYWdlICpwLAo+IC0JCSAgICAgICBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKPiAtCQkg ICAgICAgc3RydWN0IGxpc3RfaGVhZCAqdG9fa2lsbCkKPiArc3RhdGljIHZvaWQgYWRkX3RvX2tp bGwoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssIHN0cnVjdCBwYWdlICpwLCBwZ29mZl90IHBnb2Zm LAo+ICsJCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgc3RydWN0IGxpc3RfaGVhZCAqdG9f a2lsbCkKPiAgIHsKPiAgIAlzdHJ1Y3QgdG9fa2lsbCAqdGs7Cj4gICAKPiBAQCAtMzQyLDkgKzM0 OCwxMiBAQCBzdGF0aWMgdm9pZCBhZGRfdG9fa2lsbChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywg c3RydWN0IHBhZ2UgKnAsCj4gICAJfQo+ICAgCj4gICAJdGstPmFkZHIgPSBwYWdlX2FkZHJlc3Nf aW5fdm1hKHAsIHZtYSk7Cj4gLQlpZiAoaXNfem9uZV9kZXZpY2VfcGFnZShwKSkKPiAtCQl0ay0+ c2l6ZV9zaGlmdCA9IGRldl9wYWdlbWFwX21hcHBpbmdfc2hpZnQocCwgdm1hKTsKPiAtCWVsc2UK PiArCWlmIChpc196b25lX2RldmljZV9wYWdlKHApKSB7Cj4gKwkJaWYgKGlzX2RldmljZV9mc2Rh eF9wYWdlKHApKQo+ICsJCQl0ay0+YWRkciA9IHZtYS0+dm1fc3RhcnQgKwo+ICsJCQkJCSgocGdv ZmYgLSB2bWEtPnZtX3Bnb2ZmKSA8PCBQQUdFX1NISUZUKTsKPiArCQl0ay0+c2l6ZV9zaGlmdCA9 IGRldl9wYWdlbWFwX21hcHBpbmdfc2hpZnQodm1hLCB0ay0+YWRkcik7Cj4gKwl9IGVsc2UKPiAg IAkJdGstPnNpemVfc2hpZnQgPSBwYWdlX3NoaWZ0KGNvbXBvdW5kX2hlYWQocCkpOwo+ICAgCj4g ICAJLyoKPiBAQCAtNDkyLDcgKzUwMSw3IEBAIHN0YXRpYyB2b2lkIGNvbGxlY3RfcHJvY3NfYW5v bihzdHJ1Y3QgcGFnZSAqcGFnZSwgc3RydWN0IGxpc3RfaGVhZCAqdG9fa2lsbCwKPiAgIAkJCWlm ICghcGFnZV9tYXBwZWRfaW5fdm1hKHBhZ2UsIHZtYSkpCj4gICAJCQkJY29udGludWU7Cj4gICAJ CQlpZiAodm1hLT52bV9tbSA9PSB0LT5tbSkKPiAtCQkJCWFkZF90b19raWxsKHQsIHBhZ2UsIHZt YSwgdG9fa2lsbCk7Cj4gKwkJCQlhZGRfdG9fa2lsbCh0LCBwYWdlLCAwLCB2bWEsIHRvX2tpbGwp Owo+ICAgCQl9Cj4gICAJfQo+ICAgCXJlYWRfdW5sb2NrKCZ0YXNrbGlzdF9sb2NrKTsKPiBAQCAt NTAyLDI0ICs1MTEsMTkgQEAgc3RhdGljIHZvaWQgY29sbGVjdF9wcm9jc19hbm9uKHN0cnVjdCBw YWdlICpwYWdlLCBzdHJ1Y3QgbGlzdF9oZWFkICp0b19raWxsLAo+ICAgLyoKPiAgICAqIENvbGxl Y3QgcHJvY2Vzc2VzIHdoZW4gdGhlIGVycm9yIGhpdCBhIGZpbGUgbWFwcGVkIHBhZ2UuCj4gICAg Ki8KPiAtc3RhdGljIHZvaWQgY29sbGVjdF9wcm9jc19maWxlKHN0cnVjdCBwYWdlICpwYWdlLCBz dHJ1Y3QgbGlzdF9oZWFkICp0b19raWxsLAo+IC0JCQkJaW50IGZvcmNlX2Vhcmx5KQo+ICtzdGF0 aWMgdm9pZCBjb2xsZWN0X3Byb2NzX2ZpbGUoc3RydWN0IHBhZ2UgKnBhZ2UsIHN0cnVjdCBhZGRy ZXNzX3NwYWNlICptYXBwaW5nLAo+ICsJCXBnb2ZmX3QgcGdvZmYsIHN0cnVjdCBsaXN0X2hlYWQg KnRvX2tpbGwsIGludCBmb3JjZV9lYXJseSkKPiAgIHsKPiAgIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1 Y3QgKnZtYTsKPiAgIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzazsKPiAtCXN0cnVjdCBhZGRyZXNz X3NwYWNlICptYXBwaW5nID0gcGFnZS0+bWFwcGluZzsKPiAtCXBnb2ZmX3QgcGdvZmY7Cj4gICAK PiAgIAlpX21tYXBfbG9ja19yZWFkKG1hcHBpbmcpOwo+ICAgCXJlYWRfbG9jaygmdGFza2xpc3Rf bG9jayk7Cj4gLQlwZ29mZiA9IHBhZ2VfdG9fcGdvZmYocGFnZSk7Cj4gICAJZm9yX2VhY2hfcHJv Y2Vzcyh0c2spIHsKPiAgIAkJc3RydWN0IHRhc2tfc3RydWN0ICp0ID0gdGFza19lYXJseV9raWxs KHRzaywgZm9yY2VfZWFybHkpOwo+IC0KPiAgIAkJaWYgKCF0KQo+ICAgCQkJY29udGludWU7Cj4g LQkJdm1hX2ludGVydmFsX3RyZWVfZm9yZWFjaCh2bWEsICZtYXBwaW5nLT5pX21tYXAsIHBnb2Zm LAo+IC0JCQkJICAgICAgcGdvZmYpIHsKPiArCQl2bWFfaW50ZXJ2YWxfdHJlZV9mb3JlYWNoKHZt YSwgJm1hcHBpbmctPmlfbW1hcCwgcGdvZmYsIHBnb2ZmKSB7Cj4gICAJCQkvKgo+ICAgCQkJICog U2VuZCBlYXJseSBraWxsIHNpZ25hbCB0byB0YXNrcyB3aGVyZSBhIHZtYSBjb3ZlcnMKPiAgIAkJ CSAqIHRoZSBwYWdlIGJ1dCB0aGUgY29ycnVwdGVkIHBhZ2UgaXMgbm90IG5lY2Vzc2FyaWx5Cj4g QEAgLTUyOCw3ICs1MzIsNyBAQCBzdGF0aWMgdm9pZCBjb2xsZWN0X3Byb2NzX2ZpbGUoc3RydWN0 IHBhZ2UgKnBhZ2UsIHN0cnVjdCBsaXN0X2hlYWQgKnRvX2tpbGwsCj4gICAJCQkgKiB0byBiZSBp bmZvcm1lZCBvZiBhbGwgc3VjaCBkYXRhIGNvcnJ1cHRpb25zLgo+ICAgCQkJICovCj4gICAJCQlp ZiAodm1hLT52bV9tbSA9PSB0LT5tbSkKPiAtCQkJCWFkZF90b19raWxsKHQsIHBhZ2UsIHZtYSwg dG9fa2lsbCk7Cj4gKwkJCQlhZGRfdG9fa2lsbCh0LCBwYWdlLCBwZ29mZiwgdm1hLCB0b19raWxs KTsKPiAgIAkJfQo+ICAgCX0KPiAgIAlyZWFkX3VubG9jaygmdGFza2xpc3RfbG9jayk7Cj4gQEAg LTU0Nyw3ICs1NTEsOCBAQCBzdGF0aWMgdm9pZCBjb2xsZWN0X3Byb2NzKHN0cnVjdCBwYWdlICpw YWdlLCBzdHJ1Y3QgbGlzdF9oZWFkICp0b2tpbGwsCj4gICAJaWYgKFBhZ2VBbm9uKHBhZ2UpKQo+ ICAgCQljb2xsZWN0X3Byb2NzX2Fub24ocGFnZSwgdG9raWxsLCBmb3JjZV9lYXJseSk7Cj4gICAJ ZWxzZQo+IC0JCWNvbGxlY3RfcHJvY3NfZmlsZShwYWdlLCB0b2tpbGwsIGZvcmNlX2Vhcmx5KTsK PiArCQljb2xsZWN0X3Byb2NzX2ZpbGUocGFnZSwgcGFnZV9tYXBwaW5nKHBhZ2UpLCBwYWdlX3Rv X3Bnb2ZmKHBhZ2UpLAo+ICsJCQkJICAgdG9raWxsLCBmb3JjZV9lYXJseSk7Cj4gICB9Cj4gICAK PiAgIHN0YXRpYyBjb25zdCBjaGFyICphY3Rpb25fbmFtZVtdID0gewo+IEBAIC0xMjE0LDYgKzEy MTksNTAgQEAgc3RhdGljIGludCB0cnlfdG9fc3BsaXRfdGhwX3BhZ2Uoc3RydWN0IHBhZ2UgKnBh Z2UsIGNvbnN0IGNoYXIgKm1zZykKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+ICtpbnQgbWZf ZGF4X21hcHBpbmdfa2lsbF9wcm9jcyhzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZywgcGdv ZmZfdCBpbmRleCwgaW50IGZsYWdzKQo+ICt7Cj4gKwljb25zdCBib29sIHVubWFwX3N1Y2Nlc3Mg PSB0cnVlOwo+ICsJdW5zaWduZWQgbG9uZyBwZm4sIHNpemUgPSAwOwo+ICsJc3RydWN0IHRvX2tp bGwgKnRrOwo+ICsJTElTVF9IRUFEKHRvX2tpbGwpOwo+ICsJaW50IHJjID0gLUVCVVNZOwo+ICsJ bG9mZl90IHN0YXJ0Owo+ICsKPiArCS8qIGxvYWQgdGhlIHBmbiBvZiB0aGUgZGF4IG1hcHBpbmcg ZmlsZSAqLwo+ICsJcGZuID0gZGF4X2xvYWRfcGZuKG1hcHBpbmcsIGluZGV4KTsKPiArCWlmICgh cGZuKQo+ICsJCXJldHVybiByYzsKPiArCS8qCj4gKwkgKiBVbmxpa2UgU3lzdGVtLVJBTSB0aGVy ZSBpcyBubyBwb3NzaWJpbGl0eSB0byBzd2FwIGluIGEKPiArCSAqIGRpZmZlcmVudCBwaHlzaWNh bCBwYWdlIGF0IGEgZ2l2ZW4gdmlydHVhbCBhZGRyZXNzLCBzbyBhbGwKPiArCSAqIHVzZXJzcGFj ZSBjb25zdW1wdGlvbiBvZiBaT05FX0RFVklDRSBtZW1vcnkgbmVjZXNzaXRhdGVzCj4gKwkgKiBT SUdCVVMgKGkuZS4gTUZfTVVTVF9LSUxMKQo+ICsJICovCj4gKwlmbGFncyB8PSBNRl9BQ1RJT05f UkVRVUlSRUQgfCBNRl9NVVNUX0tJTEw7CgpNRl9BQ1RJT05fUkVRVUlSRUQgb25seSBraWxsIHRo ZSBjdXJyZW50IGV4ZWN1dGlvbiBjb250ZXh0LiBBIHBhZ2UgY2FuIGJlIHNoYXJlZAp3aGVuIHJl ZmxpbmsgZmlsZSBiZSBtYXBwZWQgYnkgZGlmZmVyZW50IHByb2Nlc3MuIFdlIGNhbiBub3Qga2ls bCBhbGwgcHJvY2VzcwpzaGFyZWQgdGhlIHBhZ2UuICBPdGhlciBwcm9jZXNzIHN0aWxsIGNhbiBh Y2Nlc3MgdGhlIHBvc2lvbmVkIHBhZ2UgPwoKVGhhbmtzLAp6aG9uZyBqaWFuZwoKPiArCWNvbGxl Y3RfcHJvY3NfZmlsZShwZm5fdG9fcGFnZShwZm4pLCBtYXBwaW5nLCBpbmRleCwgJnRvX2tpbGws Cj4gKwkJCSAgIGZsYWdzICYgTUZfQUNUSU9OX1JFUVVJUkVEKTsKPiArCj4gKwlsaXN0X2Zvcl9l YWNoX2VudHJ5KHRrLCAmdG9fa2lsbCwgbmQpCj4gKwkJaWYgKHRrLT5zaXplX3NoaWZ0KQo+ICsJ CQlzaXplID0gbWF4KHNpemUsIDFVTCA8PCB0ay0+c2l6ZV9zaGlmdCk7Cj4gKwlpZiAoc2l6ZSkg ewo+ICsJCS8qCj4gKwkJICogVW5tYXAgdGhlIGxhcmdlc3QgbWFwcGluZyB0byBhdm9pZCBicmVh a2luZyB1cAo+ICsJCSAqIGRldmljZS1kYXggbWFwcGluZ3Mgd2hpY2ggYXJlIGNvbnN0YW50IHNp emUuIFRoZQo+ICsJCSAqIGFjdHVhbCBzaXplIG9mIHRoZSBtYXBwaW5nIGJlaW5nIHRvcm4gZG93 biBpcwo+ICsJCSAqIGNvbW11bmljYXRlZCBpbiBzaWdpbmZvLCBzZWUga2lsbF9wcm9jKCkKPiAr CQkgKi8KPiArCQlzdGFydCA9IChpbmRleCA8PCBQQUdFX1NISUZUKSAmIH4oc2l6ZSAtIDEpOwo+ ICsJCXVubWFwX21hcHBpbmdfcmFuZ2UobWFwcGluZywgc3RhcnQsIHN0YXJ0ICsgc2l6ZSwgMCk7 Cj4gKwl9Cj4gKwo+ICsJa2lsbF9wcm9jcygmdG9fa2lsbCwgZmxhZ3MgJiBNRl9NVVNUX0tJTEws ICF1bm1hcF9zdWNjZXNzLAo+ICsJCSAgIHBmbiwgZmxhZ3MpOwo+ICsJcmMgPSAwOwo+ICsJcmV0 dXJuIHJjOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKG1mX2RheF9tYXBwaW5nX2tpbGxfcHJv Y3MpOwo+ICsKPiAgIHN0YXRpYyBpbnQgbWVtb3J5X2ZhaWx1cmVfaHVnZXRsYih1bnNpZ25lZCBs b25nIHBmbiwgaW50IGZsYWdzKQo+ICAgewo+ICAgCXN0cnVjdCBwYWdlICpwID0gcGZuX3RvX3Bh Z2UocGZuKTsKPiBAQCAtMTI5Nyw3ICsxMzQ2LDcgQEAgc3RhdGljIGludCBtZW1vcnlfZmFpbHVy ZV9kZXZfcGFnZW1hcCh1bnNpZ25lZCBsb25nIHBmbiwgaW50IGZsYWdzLAo+ICAgCWNvbnN0IGJv b2wgdW5tYXBfc3VjY2VzcyA9IHRydWU7Cj4gICAJdW5zaWduZWQgbG9uZyBzaXplID0gMDsKPiAg IAlzdHJ1Y3QgdG9fa2lsbCAqdGs7Cj4gLQlMSVNUX0hFQUQodG9raWxsKTsKPiArCUxJU1RfSEVB RCh0b19raWxsKTsKPiAgIAlpbnQgcmMgPSAtRUJVU1k7Cj4gICAJbG9mZl90IHN0YXJ0Owo+ICAg CWRheF9lbnRyeV90IGNvb2tpZTsKPiBAQCAtMTM0NSw5ICsxMzk0LDEwIEBAIHN0YXRpYyBpbnQg bWVtb3J5X2ZhaWx1cmVfZGV2X3BhZ2VtYXAodW5zaWduZWQgbG9uZyBwZm4sIGludCBmbGFncywK PiAgIAkgKiBTSUdCVVMgKGkuZS4gTUZfTVVTVF9LSUxMKQo+ICAgCSAqLwo+ICAgCWZsYWdzIHw9 IE1GX0FDVElPTl9SRVFVSVJFRCB8IE1GX01VU1RfS0lMTDsKPiAtCWNvbGxlY3RfcHJvY3MocGFn ZSwgJnRva2lsbCwgZmxhZ3MgJiBNRl9BQ1RJT05fUkVRVUlSRUQpOwo+ICsJY29sbGVjdF9wcm9j c19maWxlKHBhZ2UsIHBhZ2UtPm1hcHBpbmcsIHBhZ2UtPmluZGV4LCAmdG9fa2lsbCwKPiArCQkJ ICAgZmxhZ3MgJiBNRl9BQ1RJT05fUkVRVUlSRUQpOwo+ICAgCj4gLQlsaXN0X2Zvcl9lYWNoX2Vu dHJ5KHRrLCAmdG9raWxsLCBuZCkKPiArCWxpc3RfZm9yX2VhY2hfZW50cnkodGssICZ0b19raWxs LCBuZCkKPiAgIAkJaWYgKHRrLT5zaXplX3NoaWZ0KQo+ICAgCQkJc2l6ZSA9IG1heChzaXplLCAx VUwgPDwgdGstPnNpemVfc2hpZnQpOwo+ICAgCWlmIChzaXplKSB7Cj4gQEAgLTEzNjAsNyArMTQx MCw3IEBAIHN0YXRpYyBpbnQgbWVtb3J5X2ZhaWx1cmVfZGV2X3BhZ2VtYXAodW5zaWduZWQgbG9u ZyBwZm4sIGludCBmbGFncywKPiAgIAkJc3RhcnQgPSAocGFnZS0+aW5kZXggPDwgUEFHRV9TSElG VCkgJiB+KHNpemUgLSAxKTsKPiAgIAkJdW5tYXBfbWFwcGluZ19yYW5nZShwYWdlLT5tYXBwaW5n LCBzdGFydCwgc3RhcnQgKyBzaXplLCAwKTsKPiAgIAl9Cj4gLQlraWxsX3Byb2NzKCZ0b2tpbGws IGZsYWdzICYgTUZfTVVTVF9LSUxMLCAhdW5tYXBfc3VjY2VzcywgcGZuLCBmbGFncyk7Cj4gKwlr aWxsX3Byb2NzKCZ0b19raWxsLCBmbGFncyAmIE1GX01VU1RfS0lMTCwgIXVubWFwX3N1Y2Nlc3Ms IHBmbiwgZmxhZ3MpOwo+ICAgCXJjID0gMDsKPiAgIHVubG9jazoKPiAgIAlkYXhfdW5sb2NrX3Bh Z2UocGFnZSwgY29va2llKTsKCi0tCmRtLWRldmVsIG1haWxpbmcgbGlzdApkbS1kZXZlbEByZWRo YXQuY29tCmh0dHBzOi8vbGlzdG1hbi5yZWRoYXQuY29tL21haWxtYW4vbGlzdGluZm8vZG0tZGV2 ZWw=