From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH v2 12/11] mm/hmm: Fix error flows in hmm_invalidate_range_start Date: Fri, 7 Jun 2019 13:05:57 -0300 Message-ID: <20190607160557.GA335@ziepe.ca> References: <20190606184438.31646-1-jgg@ziepe.ca> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20190606184438.31646-1-jgg-uk2M96/98Pc@public.gmane.org> List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling-5C7GfCeVMHo@public.gmane.org Cc: linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, Andrea Arcangeli , amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org SWYgdGhlIHRyeWxvY2sgb24gdGhlIGhtbS0+bWlycm9yc19zZW0gZmFpbHMgdGhlIGZ1bmN0aW9u IHdpbGwgcmV0dXJuCndpdGhvdXQgZGVjcmVtZW50aW5nIHRoZSBub3RpZmllcnMgdGhhdCB3ZXJl IHByZXZpb3VzbHkgaW5jcmVtZW50ZWQuIFNpbmNlCnRoZSBjYWxsZXIgd2lsbCBub3QgY2FsbCBp bnZhbGlkYXRlX3JhbmdlX2VuZCgpIG9uIEVBR0FJTiB0aGlzIHdpbGwgcmVzdWx0CmluIG5vdGlm aWVycyBiZWNvbWluZyBwZXJtYW5lbnRseSBpbmNyZW1lbnRlZCBhbmQgZGVhZGxvY2suCgpJZiB0 aGUgc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMoKSByZXF1aXJlZCBibG9ja2luZyB0aGUgZnVu Y3Rpb24gd2lsbApub3QgcmV0dXJuIEVBR0FJTiBldmVuIHRob3VnaCB0aGUgZGV2aWNlIGNvbnRp bnVlcyB0byB0b3VjaCB0aGUKcGFnZXMuIFRoaXMgaXMgYSB2aW9sYXRpb24gb2YgdGhlIG1tdSBu b3RpZmllciBjb250cmFjdC4KClN3aXRjaCwgYW5kIHJlbmFtZSwgdGhlIHJhbmdlc19sb2NrIHRv IGEgc3BpbiBsb2NrIHNvIHdlIGNhbiByZWxpYWJseQpvYnRhaW4gaXQgd2l0aG91dCBibG9ja2lu ZyBkdXJpbmcgZXJyb3IgdW53aW5kLgoKVGhlIGVycm9yIHVud2luZCBpcyBuZWNlc3Nhcnkgc2lu Y2UgdGhlIG5vdGlmaWVycyBjb3VudCBtdXN0IGJlIGhlbGQKaW5jcmVtZW50ZWQgYWNyb3NzIHRo ZSBjYWxsIHRvIHN5bmNfY3B1X2RldmljZV9wYWdldGFibGVzKCkgYXMgd2UgY2Fubm90CmFsbG93 IHRoZSByYW5nZSB0byBiZWNvbWUgbWFya2VkIHZhbGlkIGJ5IGEgcGFyYWxsZWwKaW52YWxpZGF0 ZV9zdGFydC9lbmQoKSBwYWlyIHdoaWxlIGRvaW5nIHN5bmNfY3B1X2RldmljZV9wYWdldGFibGVz KCkuCgpTaWduZWQtb2ZmLWJ5OiBKYXNvbiBHdW50aG9ycGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0t LQogaW5jbHVkZS9saW51eC9obW0uaCB8ICAyICstCiBtbS9obW0uYyAgICAgICAgICAgIHwgNzcg KysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tCiAyIGZpbGVzIGNo YW5nZWQsIDQ4IGluc2VydGlvbnMoKyksIDMxIGRlbGV0aW9ucygtKQoKSSBhbG1vc3QgbG9zdCB0 aGlzIHBhdGNoIC0gaXQgaXMgcGFydCBvZiB0aGUgc2VyaWVzLCBoYXNuJ3QgYmVlbgpwb3N0ZWQg YmVmb3JlLCBhbmQgd2Fzbid0IHNlbnQgd2l0aCB0aGUgcmVzdCwgc29ycnkuCgpkaWZmIC0tZ2l0 IGEvaW5jbHVkZS9saW51eC9obW0uaCBiL2luY2x1ZGUvbGludXgvaG1tLmgKaW5kZXggYmYwMTNl OTY1MjU3NzEuLjBmYThlYTM0Y2NlZjZkIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2htbS5o CisrKyBiL2luY2x1ZGUvbGludXgvaG1tLmgKQEAgLTg2LDcgKzg2LDcgQEAKIHN0cnVjdCBobW0g ewogCXN0cnVjdCBtbV9zdHJ1Y3QJKm1tOwogCXN0cnVjdCBrcmVmCQlrcmVmOwotCXN0cnVjdCBt dXRleAkJbG9jazsKKwlzcGlubG9ja190CQlyYW5nZXNfbG9jazsKIAlzdHJ1Y3QgbGlzdF9oZWFk CXJhbmdlczsKIAlzdHJ1Y3QgbGlzdF9oZWFkCW1pcnJvcnM7CiAJc3RydWN0IG1tdV9ub3RpZmll cgltbXVfbm90aWZpZXI7CmRpZmYgLS1naXQgYS9tbS9obW0uYyBiL21tL2htbS5jCmluZGV4IDQy MTVlZGY3MzdlZjViLi4xMDEwM2EyNGU5YjdiMyAxMDA2NDQKLS0tIGEvbW0vaG1tLmMKKysrIGIv bW0vaG1tLmMKQEAgLTY4LDcgKzY4LDcgQEAgc3RhdGljIHN0cnVjdCBobW0gKmhtbV9nZXRfb3Jf Y3JlYXRlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogCWluaXRfcndzZW0oJmhtbS0+bWlycm9yc19z ZW0pOwogCWhtbS0+bW11X25vdGlmaWVyLm9wcyA9IE5VTEw7CiAJSU5JVF9MSVNUX0hFQUQoJmht bS0+cmFuZ2VzKTsKLQltdXRleF9pbml0KCZobW0tPmxvY2spOworCXNwaW5fbG9ja19pbml0KCZo bW0tPnJhbmdlc19sb2NrKTsKIAlrcmVmX2luaXQoJmhtbS0+a3JlZik7CiAJaG1tLT5ub3RpZmll cnMgPSAwOwogCWhtbS0+bW0gPSBtbTsKQEAgLTExNCwxOCArMTE0LDE5IEBAIHN0YXRpYyB2b2lk IGhtbV9yZWxlYXNlKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLCBzdHJ1Y3QgbW1fc3RydWN0ICpt bSkKIHsKIAlzdHJ1Y3QgaG1tICpobW0gPSBjb250YWluZXJfb2YobW4sIHN0cnVjdCBobW0sIG1t dV9ub3RpZmllcik7CiAJc3RydWN0IGhtbV9taXJyb3IgKm1pcnJvcjsKKwl1bnNpZ25lZCBsb25n IGZsYWdzOwogCiAJLyogQmFpbCBvdXQgaWYgaG1tIGlzIGluIHRoZSBwcm9jZXNzIG9mIGJlaW5n IGZyZWVkICovCiAJaWYgKCFrcmVmX2dldF91bmxlc3NfemVybygmaG1tLT5rcmVmKSkKIAkJcmV0 dXJuOwogCi0JbXV0ZXhfbG9jaygmaG1tLT5sb2NrKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmaG1t LT5yYW5nZXNfbG9jaywgZmxhZ3MpOwogCS8qCiAJICogU2luY2UgaG1tX3JhbmdlX3JlZ2lzdGVy KCkgaG9sZHMgdGhlIG1tZ2V0KCkgbG9jayBobW1fcmVsZWFzZSgpIGlzCiAJICogcHJldmVudGVk IGFzIGxvbmcgYXMgYSByYW5nZSBleGlzdHMuCiAJICovCiAJV0FSTl9PTighbGlzdF9lbXB0eSgm aG1tLT5yYW5nZXMpKTsKLQltdXRleF91bmxvY2soJmhtbS0+bG9jayk7CisJc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwogCiAJZG93bl9yZWFkKCZobW0t Pm1pcnJvcnNfc2VtKTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1pcnJvciwgJmhtbS0+bWlycm9y cywgbGlzdCkgewpAQCAtMTQxLDYgKzE0MiwyMyBAQCBzdGF0aWMgdm9pZCBobW1fcmVsZWFzZShz dHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCiAJaG1tX3B1dCho bW0pOwogfQogCitzdGF0aWMgdm9pZCBub3RpZmllcnNfZGVjcmVtZW50KHN0cnVjdCBobW0gKmht bSkKK3sKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZobW0tPnJhbmdlc19sb2NrKTsKKworCWhtbS0+ bm90aWZpZXJzLS07CisJaWYgKCFobW0tPm5vdGlmaWVycykgeworCQlzdHJ1Y3QgaG1tX3Jhbmdl ICpyYW5nZTsKKworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJhbmdlLCAmaG1tLT5yYW5nZXMsIGxp c3QpIHsKKwkJCWlmIChyYW5nZS0+dmFsaWQpCisJCQkJY29udGludWU7CisJCQlyYW5nZS0+dmFs aWQgPSB0cnVlOworCQl9CisJCXdha2VfdXBfYWxsKCZobW0tPndxKTsKKwl9Cit9CisKIHN0YXRp YyBpbnQgaG1tX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4s CiAJCQljb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpucmFuZ2UpCiB7CkBAIC0xNDgs NiArMTY2LDcgQEAgc3RhdGljIGludCBobW1faW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3Qg bW11X25vdGlmaWVyICptbiwKIAlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yOwogCXN0cnVjdCBo bW1fdXBkYXRlIHVwZGF0ZTsKIAlzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZTsKKwl1bnNpZ25lZCBs b25nIGZsYWdzOwogCWludCByZXQgPSAwOwogCiAJaWYgKCFrcmVmX2dldF91bmxlc3NfemVybygm aG1tLT5rcmVmKSkKQEAgLTE1OCwxMiArMTc3LDcgQEAgc3RhdGljIGludCBobW1faW52YWxpZGF0 ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAl1cGRhdGUuZXZlbnQgPSBI TU1fVVBEQVRFX0lOVkFMSURBVEU7CiAJdXBkYXRlLmJsb2NrYWJsZSA9IG1tdV9ub3RpZmllcl9y YW5nZV9ibG9ja2FibGUobnJhbmdlKTsKIAotCWlmIChtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2th YmxlKG5yYW5nZSkpCi0JCW11dGV4X2xvY2soJmhtbS0+bG9jayk7Ci0JZWxzZSBpZiAoIW11dGV4 X3RyeWxvY2soJmhtbS0+bG9jaykpIHsKLQkJcmV0ID0gLUVBR0FJTjsKLQkJZ290byBvdXQ7Ci0J fQorCXNwaW5fbG9ja19pcnFzYXZlKCZobW0tPnJhbmdlc19sb2NrLCBmbGFncyk7CiAJaG1tLT5u b3RpZmllcnMrKzsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJhbmdlLCAmaG1tLT5yYW5nZXMsIGxp c3QpIHsKIAkJaWYgKHVwZGF0ZS5lbmQgPCByYW5nZS0+c3RhcnQgfHwgdXBkYXRlLnN0YXJ0ID49 IHJhbmdlLT5lbmQpCkBAIC0xNzEsNyArMTg1LDcgQEAgc3RhdGljIGludCBobW1faW52YWxpZGF0 ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAogCQlyYW5nZS0+dmFsaWQg PSBmYWxzZTsKIAl9Ci0JbXV0ZXhfdW5sb2NrKCZobW0tPmxvY2spOworCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsKIAogCWlmIChtbXVfbm90aWZpZXJf cmFuZ2VfYmxvY2thYmxlKG5yYW5nZSkpCiAJCWRvd25fcmVhZCgmaG1tLT5taXJyb3JzX3NlbSk7 CkBAIC0xNzksMTYgKzE5MywyNiBAQCBzdGF0aWMgaW50IGhtbV9pbnZhbGlkYXRlX3JhbmdlX3N0 YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAogCQlyZXQgPSAtRUFHQUlOOwogCQlnb3RvIG91 dDsKIAl9CisKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KG1pcnJvciwgJmhtbS0+bWlycm9ycywgbGlz dCkgewotCQlpbnQgcmV0OworCQlpbnQgcmM7CiAKLQkJcmV0ID0gbWlycm9yLT5vcHMtPnN5bmNf Y3B1X2RldmljZV9wYWdldGFibGVzKG1pcnJvciwgJnVwZGF0ZSk7Ci0JCWlmICghdXBkYXRlLmJs b2NrYWJsZSAmJiByZXQgPT0gLUVBR0FJTikKKwkJcmMgPSBtaXJyb3ItPm9wcy0+c3luY19jcHVf ZGV2aWNlX3BhZ2V0YWJsZXMobWlycm9yLCAmdXBkYXRlKTsKKwkJaWYgKHJjKSB7CisJCQlpZiAo V0FSTl9PTih1cGRhdGUuYmxvY2thYmxlIHx8IHJjICE9IC1FQUdBSU4pKQorCQkJCWNvbnRpbnVl OworCQkJcmV0ID0gLUVBR0FJTjsKIAkJCWJyZWFrOworCQl9CiAJfQogCXVwX3JlYWQoJmhtbS0+ bWlycm9yc19zZW0pOwogCiBvdXQ6CisJaWYgKHJldCkgeworCQlzcGluX2xvY2tfaXJxc2F2ZSgm aG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOworCQlub3RpZmllcnNfZGVjcmVtZW50KGhtbSk7CisJ CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsKKwl9CiAJ aG1tX3B1dChobW0pOwogCXJldHVybiByZXQ7CiB9CkBAIC0xOTcsMjMgKzIyMSwxNCBAQCBzdGF0 aWMgdm9pZCBobW1faW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4s CiAJCQljb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpucmFuZ2UpCiB7CiAJc3RydWN0 IGhtbSAqaG1tID0gY29udGFpbmVyX29mKG1uLCBzdHJ1Y3QgaG1tLCBtbXVfbm90aWZpZXIpOwor CXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlpZiAoIWtyZWZfZ2V0X3VubGVzc196ZXJvKCZobW0t PmtyZWYpKQogCQlyZXR1cm47CiAKLQltdXRleF9sb2NrKCZobW0tPmxvY2spOwotCWhtbS0+bm90 aWZpZXJzLS07Ci0JaWYgKCFobW0tPm5vdGlmaWVycykgewotCQlzdHJ1Y3QgaG1tX3JhbmdlICpy YW5nZTsKLQotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJhbmdlLCAmaG1tLT5yYW5nZXMsIGxpc3Qp IHsKLQkJCWlmIChyYW5nZS0+dmFsaWQpCi0JCQkJY29udGludWU7Ci0JCQlyYW5nZS0+dmFsaWQg PSB0cnVlOwotCQl9Ci0JCXdha2VfdXBfYWxsKCZobW0tPndxKTsKLQl9Ci0JbXV0ZXhfdW5sb2Nr KCZobW0tPmxvY2spOworCXNwaW5fbG9ja19pcnFzYXZlKCZobW0tPnJhbmdlc19sb2NrLCBmbGFn cyk7CisJbm90aWZpZXJzX2RlY3JlbWVudChobW0pOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUo JmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsKIAogCWhtbV9wdXQoaG1tKTsKIH0KQEAgLTg2Niw2 ICs4ODEsNyBAQCBpbnQgaG1tX3JhbmdlX3JlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdl LAogewogCXVuc2lnbmVkIGxvbmcgbWFzayA9ICgoMVVMIDw8IHBhZ2Vfc2hpZnQpIC0gMVVMKTsK IAlzdHJ1Y3QgaG1tICpobW0gPSBtaXJyb3ItPmhtbTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwog CiAJcmFuZ2UtPnZhbGlkID0gZmFsc2U7CiAJcmFuZ2UtPmhtbSA9IE5VTEw7CkBAIC04ODcsNyAr OTAzLDcgQEAgaW50IGhtbV9yYW5nZV9yZWdpc3RlcihzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwK IAlrcmVmX2dldCgmaG1tLT5rcmVmKTsKIAogCS8qIEluaXRpYWxpemUgcmFuZ2UgdG8gdHJhY2sg Q1BVIHBhZ2UgdGFibGUgdXBkYXRlcy4gKi8KLQltdXRleF9sb2NrKCZobW0tPmxvY2spOworCXNw aW5fbG9ja19pcnFzYXZlKCZobW0tPnJhbmdlc19sb2NrLCBmbGFncyk7CiAKIAlyYW5nZS0+aG1t ID0gaG1tOwogCWxpc3RfYWRkKCZyYW5nZS0+bGlzdCwgJmhtbS0+cmFuZ2VzKTsKQEAgLTg5OCw3 ICs5MTQsNyBAQCBpbnQgaG1tX3JhbmdlX3JlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdl LAogCSAqLwogCWlmICghaG1tLT5ub3RpZmllcnMpCiAJCXJhbmdlLT52YWxpZCA9IHRydWU7Ci0J bXV0ZXhfdW5sb2NrKCZobW0tPmxvY2spOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhtbS0+ cmFuZ2VzX2xvY2ssIGZsYWdzKTsKIAogCXJldHVybiAwOwogfQpAQCAtOTE0LDEzICs5MzAsMTQg QEAgRVhQT1JUX1NZTUJPTChobW1fcmFuZ2VfcmVnaXN0ZXIpOwogdm9pZCBobW1fcmFuZ2VfdW5y ZWdpc3RlcihzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKIHsKIAlzdHJ1Y3QgaG1tICpobW0gPSBy YW5nZS0+aG1tOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlpZiAoV0FSTl9PTihyYW5nZS0+ ZW5kIDw9IHJhbmdlLT5zdGFydCkpCiAJCXJldHVybjsKIAotCW11dGV4X2xvY2soJmhtbS0+bG9j ayk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsKIAlsaXN0 X2RlbCgmcmFuZ2UtPmxpc3QpOwotCW11dGV4X3VubG9jaygmaG1tLT5sb2NrKTsKKwlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZobW0tPnJhbmdlc19sb2NrLCBmbGFncyk7CiAKIAkvKiBEcm9wIHJl ZmVyZW5jZSB0YWtlbiBieSBobW1fcmFuZ2VfcmVnaXN0ZXIoKSAqLwogCXJhbmdlLT52YWxpZCA9 IGZhbHNlOwotLSAKMi4yMS4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2FtZC1n Zng= 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=-8.6 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_MUTT 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 A3C2CC2BCA1 for ; Fri, 7 Jun 2019 16:06:01 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 2548C20657 for ; Fri, 7 Jun 2019 16:06:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="h6KpvG8k" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2548C20657 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ziepe.ca Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 802B76B0007; Fri, 7 Jun 2019 12:06:00 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 7B24B6B000C; Fri, 7 Jun 2019 12:06:00 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 6A10B6B000E; Fri, 7 Jun 2019 12:06:00 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from mail-qt1-f198.google.com (mail-qt1-f198.google.com [209.85.160.198]) by kanga.kvack.org (Postfix) with ESMTP id 4C5566B0007 for ; Fri, 7 Jun 2019 12:06:00 -0400 (EDT) Received: by mail-qt1-f198.google.com with SMTP id q26so2247014qtr.3 for ; Fri, 07 Jun 2019 09:06:00 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:dkim-signature:date:from:to:cc:subject :message-id:references:mime-version:content-disposition:in-reply-to :user-agent; bh=mDQI7vDRgVEqfEUUaCyaBBK+4bOYH5UfB7o3hA1mJXA=; b=R8XbfYvbiL/I3Y58CoC0Tjy0wnuQ3drbs3jZZ9s+VzMn3f5vJUIkU+EE0KsDaMe1Gx kscYIdLF3vXNzTT4Dawxz11xR0sa8GkYOzqPSNyV6MbgWJ6+sy9yIZ710Z5apWpBUu+r U/2iqh9jRdENRSa1qmAEH0Gu5TP9l/+5xUVUTL0PwbCJyqY4MSCVG+le8BfFTUiQHIb9 tWE114H2/yn77dUXTUpB0YQZ4O9N/Su/6yOlDgoht4Xw2HbKENYt1mAVXwkaGNss68uu ke51MeHRExx6FM4ifZ2Z4gkXA5EHkzX5EeuSHOJjBD/fF0365aB6ODRNZ7kqd/PgvOto eo9g== X-Gm-Message-State: APjAAAU7+QnVZ84RiQb6Y/YHpNyTlw79ZKI2l7Qi9T7DPn703S4rUM8Q Tf+SEPCwiVh4jsIu2RK9WESteKNxdykkIsAMXPsIcvQhR+DXwdqgU88tIUFhAsv4uU3ZyEd1bdP Z/rb35CSMNW5V9ddWB83daTZnUigQ/jfxl26cr4vP3tS6seMnbXaFJijrWp6UzcX5Bw== X-Received: by 2002:ac8:28c2:: with SMTP id j2mr45987407qtj.103.1559923560021; Fri, 07 Jun 2019 09:06:00 -0700 (PDT) X-Received: by 2002:ac8:28c2:: with SMTP id j2mr45987316qtj.103.1559923558871; Fri, 07 Jun 2019 09:05:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1559923558; cv=none; d=google.com; s=arc-20160816; b=LWNNSKq2fzP0Pz6ykMLc3oXQo+MAz/4mu53RpQS81Nx1E6b9ETz9z+z1snorSj62ZX NYRf0pTAsMlUtNadpF/YLRUVYzizrbXStrP7nP5KQ5Wa6wWwtwyZlrM3UuP3AgEjPJft tDmGNlfmGbozGS/PO0CSPrOzkSova1ThbuLiJghryieTNlIkoyY28XiKS077EQuJ/8oR /zhk1v24BX78/r8YjCbpOvFI1ss4evY4D23UV6o9ZuA9ov5zjVTzTcuOrT1TgAuqcqdR hT6BDenCRuhzXX0VgXI5eSfsf9DKeCZk16mxSPFT0eq8lfal41QI0Qb2dawpH5G3/ZHB EIQg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=user-agent:in-reply-to:content-disposition:mime-version:references :message-id:subject:cc:to:from:date:dkim-signature; bh=mDQI7vDRgVEqfEUUaCyaBBK+4bOYH5UfB7o3hA1mJXA=; b=UGYGkM6VZMfCc8KAsHsr5HAEgThs9JwrHzezJuMPnajxEeFn29z9lZSph6N6rLdYcl IZ7OUeWfy3vJHu2Q1nSFjZrDE5eDgP9qwhQ95THeox71rMvCYgLe992In937FnyGu22A blMaCMIny3IouEMK/d42e1Wu/5MxjM88pT8c1WbJxK1gGriFMXCohcVn+oxx2F24RCRR EQf3k7IrCPQ90tk7RHV175CBm1XCqkVPsTbcFJSu6p8uEmcr4Axgjdyx/dAMIgDuuAWa T6Dvgvb15ATaTL9lyFXbdegs734bcu0N1/4ddAjhj/O4Rx4Qu0aYM7DqO7P/TUCMl99Z zZrA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@ziepe.ca header.s=google header.b=h6KpvG8k; spf=pass (google.com: domain of jgg@ziepe.ca designates 209.85.220.65 as permitted sender) smtp.mailfrom=jgg@ziepe.ca Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id j34sor2937948qte.42.2019.06.07.09.05.58 for (Google Transport Security); Fri, 07 Jun 2019 09:05:58 -0700 (PDT) Received-SPF: pass (google.com: domain of jgg@ziepe.ca designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@ziepe.ca header.s=google header.b=h6KpvG8k; spf=pass (google.com: domain of jgg@ziepe.ca designates 209.85.220.65 as permitted sender) smtp.mailfrom=jgg@ziepe.ca DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to:user-agent; bh=mDQI7vDRgVEqfEUUaCyaBBK+4bOYH5UfB7o3hA1mJXA=; b=h6KpvG8kEPwZ4LEZggj55gXJyseLol+sT11VPWvdlbvHuRB/SDV9CdXfnBVmjGGNUR rOaB3khRLP9k43hFFlM7JgJrB+xap09v5WEvcNpCcDm+R7q6tjjOEBwesAVq48cJ/83g So0nJITGzjxRk4D0uPQp5n7PvmlL4uFKrl/48pOQIl6ZN2eKDvmwWgXQZlPWvyAnWlIw yU5ZwpruBe/84KRjpLYqcD9PBjC1jDUG3G9Ohbk+ythU2LvunFU4UkOUnBzmx4hF6Ao0 Lnzva0XY+uFw0Y+ynwlkcWlHyp6MBQc24OEdhN/d2qSSoB3U9Jw6KgBVG8SRZERqZzkb 2hlw== X-Google-Smtp-Source: APXvYqwIT1CmduZzPGFrLNflexTC0zIShRnLBlA8OsJP0/v7GZFL6ZhIHAbjBC1Kw7kXZZYVQlIuiQ== X-Received: by 2002:ac8:1af4:: with SMTP id h49mr38593897qtk.183.1559923558110; Fri, 07 Jun 2019 09:05:58 -0700 (PDT) Received: from ziepe.ca (hlfxns017vw-156-34-55-100.dhcp-dynamic.fibreop.ns.bellaliant.net. [156.34.55.100]) by smtp.gmail.com with ESMTPSA id n124sm1260323qkf.31.2019.06.07.09.05.57 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Fri, 07 Jun 2019 09:05:57 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1hZHNN-00008j-5Z; Fri, 07 Jun 2019 13:05:57 -0300 Date: Fri, 7 Jun 2019 13:05:57 -0300 From: Jason Gunthorpe To: Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Cc: linux-rdma@vger.kernel.org, linux-mm@kvack.org, Andrea Arcangeli , dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org Subject: [PATCH v2 12/11] mm/hmm: Fix error flows in hmm_invalidate_range_start Message-ID: <20190607160557.GA335@ziepe.ca> References: <20190606184438.31646-1-jgg@ziepe.ca> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20190606184438.31646-1-jgg@ziepe.ca> User-Agent: Mutt/1.9.4 (2018-02-28) X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: If the trylock on the hmm->mirrors_sem fails the function will return without decrementing the notifiers that were previously incremented. Since the caller will not call invalidate_range_end() on EAGAIN this will result in notifiers becoming permanently incremented and deadlock. If the sync_cpu_device_pagetables() required blocking the function will not return EAGAIN even though the device continues to touch the pages. This is a violation of the mmu notifier contract. Switch, and rename, the ranges_lock to a spin lock so we can reliably obtain it without blocking during error unwind. The error unwind is necessary since the notifiers count must be held incremented across the call to sync_cpu_device_pagetables() as we cannot allow the range to become marked valid by a parallel invalidate_start/end() pair while doing sync_cpu_device_pagetables(). Signed-off-by: Jason Gunthorpe --- include/linux/hmm.h | 2 +- mm/hmm.c | 77 +++++++++++++++++++++++++++------------------ 2 files changed, 48 insertions(+), 31 deletions(-) I almost lost this patch - it is part of the series, hasn't been posted before, and wasn't sent with the rest, sorry. diff --git a/include/linux/hmm.h b/include/linux/hmm.h index bf013e96525771..0fa8ea34ccef6d 100644 --- a/include/linux/hmm.h +++ b/include/linux/hmm.h @@ -86,7 +86,7 @@ struct hmm { struct mm_struct *mm; struct kref kref; - struct mutex lock; + spinlock_t ranges_lock; struct list_head ranges; struct list_head mirrors; struct mmu_notifier mmu_notifier; diff --git a/mm/hmm.c b/mm/hmm.c index 4215edf737ef5b..10103a24e9b7b3 100644 --- a/mm/hmm.c +++ b/mm/hmm.c @@ -68,7 +68,7 @@ static struct hmm *hmm_get_or_create(struct mm_struct *mm) init_rwsem(&hmm->mirrors_sem); hmm->mmu_notifier.ops = NULL; INIT_LIST_HEAD(&hmm->ranges); - mutex_init(&hmm->lock); + spin_lock_init(&hmm->ranges_lock); kref_init(&hmm->kref); hmm->notifiers = 0; hmm->mm = mm; @@ -114,18 +114,19 @@ static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) { struct hmm *hmm = container_of(mn, struct hmm, mmu_notifier); struct hmm_mirror *mirror; + unsigned long flags; /* Bail out if hmm is in the process of being freed */ if (!kref_get_unless_zero(&hmm->kref)) return; - mutex_lock(&hmm->lock); + spin_lock_irqsave(&hmm->ranges_lock, flags); /* * Since hmm_range_register() holds the mmget() lock hmm_release() is * prevented as long as a range exists. */ WARN_ON(!list_empty(&hmm->ranges)); - mutex_unlock(&hmm->lock); + spin_unlock_irqrestore(&hmm->ranges_lock, flags); down_read(&hmm->mirrors_sem); list_for_each_entry(mirror, &hmm->mirrors, list) { @@ -141,6 +142,23 @@ static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) hmm_put(hmm); } +static void notifiers_decrement(struct hmm *hmm) +{ + lockdep_assert_held(&hmm->ranges_lock); + + hmm->notifiers--; + if (!hmm->notifiers) { + struct hmm_range *range; + + list_for_each_entry(range, &hmm->ranges, list) { + if (range->valid) + continue; + range->valid = true; + } + wake_up_all(&hmm->wq); + } +} + static int hmm_invalidate_range_start(struct mmu_notifier *mn, const struct mmu_notifier_range *nrange) { @@ -148,6 +166,7 @@ static int hmm_invalidate_range_start(struct mmu_notifier *mn, struct hmm_mirror *mirror; struct hmm_update update; struct hmm_range *range; + unsigned long flags; int ret = 0; if (!kref_get_unless_zero(&hmm->kref)) @@ -158,12 +177,7 @@ static int hmm_invalidate_range_start(struct mmu_notifier *mn, update.event = HMM_UPDATE_INVALIDATE; update.blockable = mmu_notifier_range_blockable(nrange); - if (mmu_notifier_range_blockable(nrange)) - mutex_lock(&hmm->lock); - else if (!mutex_trylock(&hmm->lock)) { - ret = -EAGAIN; - goto out; - } + spin_lock_irqsave(&hmm->ranges_lock, flags); hmm->notifiers++; list_for_each_entry(range, &hmm->ranges, list) { if (update.end < range->start || update.start >= range->end) @@ -171,7 +185,7 @@ static int hmm_invalidate_range_start(struct mmu_notifier *mn, range->valid = false; } - mutex_unlock(&hmm->lock); + spin_unlock_irqrestore(&hmm->ranges_lock, flags); if (mmu_notifier_range_blockable(nrange)) down_read(&hmm->mirrors_sem); @@ -179,16 +193,26 @@ static int hmm_invalidate_range_start(struct mmu_notifier *mn, ret = -EAGAIN; goto out; } + list_for_each_entry(mirror, &hmm->mirrors, list) { - int ret; + int rc; - ret = mirror->ops->sync_cpu_device_pagetables(mirror, &update); - if (!update.blockable && ret == -EAGAIN) + rc = mirror->ops->sync_cpu_device_pagetables(mirror, &update); + if (rc) { + if (WARN_ON(update.blockable || rc != -EAGAIN)) + continue; + ret = -EAGAIN; break; + } } up_read(&hmm->mirrors_sem); out: + if (ret) { + spin_lock_irqsave(&hmm->ranges_lock, flags); + notifiers_decrement(hmm); + spin_unlock_irqrestore(&hmm->ranges_lock, flags); + } hmm_put(hmm); return ret; } @@ -197,23 +221,14 @@ static void hmm_invalidate_range_end(struct mmu_notifier *mn, const struct mmu_notifier_range *nrange) { struct hmm *hmm = container_of(mn, struct hmm, mmu_notifier); + unsigned long flags; if (!kref_get_unless_zero(&hmm->kref)) return; - mutex_lock(&hmm->lock); - hmm->notifiers--; - if (!hmm->notifiers) { - struct hmm_range *range; - - list_for_each_entry(range, &hmm->ranges, list) { - if (range->valid) - continue; - range->valid = true; - } - wake_up_all(&hmm->wq); - } - mutex_unlock(&hmm->lock); + spin_lock_irqsave(&hmm->ranges_lock, flags); + notifiers_decrement(hmm); + spin_unlock_irqrestore(&hmm->ranges_lock, flags); hmm_put(hmm); } @@ -866,6 +881,7 @@ int hmm_range_register(struct hmm_range *range, { unsigned long mask = ((1UL << page_shift) - 1UL); struct hmm *hmm = mirror->hmm; + unsigned long flags; range->valid = false; range->hmm = NULL; @@ -887,7 +903,7 @@ int hmm_range_register(struct hmm_range *range, kref_get(&hmm->kref); /* Initialize range to track CPU page table updates. */ - mutex_lock(&hmm->lock); + spin_lock_irqsave(&hmm->ranges_lock, flags); range->hmm = hmm; list_add(&range->list, &hmm->ranges); @@ -898,7 +914,7 @@ int hmm_range_register(struct hmm_range *range, */ if (!hmm->notifiers) range->valid = true; - mutex_unlock(&hmm->lock); + spin_unlock_irqrestore(&hmm->ranges_lock, flags); return 0; } @@ -914,13 +930,14 @@ EXPORT_SYMBOL(hmm_range_register); void hmm_range_unregister(struct hmm_range *range) { struct hmm *hmm = range->hmm; + unsigned long flags; if (WARN_ON(range->end <= range->start)) return; - mutex_lock(&hmm->lock); + spin_lock_irqsave(&hmm->ranges_lock, flags); list_del(&range->list); - mutex_unlock(&hmm->lock); + spin_unlock_irqrestore(&hmm->ranges_lock, flags); /* Drop reference taken by hmm_range_register() */ range->valid = false; -- 2.21.0