From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [4.13,35/36] x86/mcelog: Get rid of RCU remnants From: Greg Kroah-Hartman Message-Id: <20171106085048.608290620@linuxfoundation.org> Date: Mon, 6 Nov 2017 10:12:48 +0100 To: linux-kernel@vger.kernel.org Cc: Greg Kroah-Hartman , stable@vger.kernel.org, Jeremy Cline , Borislav Petkov , Thomas Gleixner , Andi Kleen , linux-edac@vger.kernel.org, Laura Abbott List-ID: NC4xMy1zdGFibGUgcmV2aWV3IHBhdGNoLiAgSWYgYW55b25lIGhhcyBhbnkgb2JqZWN0aW9ucywg cGxlYXNlIGxldCBtZSBrbm93LgoKLS0tLS0tLS0tLS0tLS0tLS0tCgpGcm9tOiBCb3Jpc2xhdiBQ ZXRrb3YgPGJwQHN1c2UuZGU+Cgpjb21taXQgNzI5OGYwOGVhODg3MGQ0NGQzNmM3ZDZjZDA3ZGQw MzAzZmFlZjZjMiB1cHN0cmVhbS4KCkplcmVteSByZXBvcnRlZCBhIHN1c3BpY2lvdXMgUkNVIHVz YWdlIHdhcm5pbmcgaW4gbWNlbG9nLgoKL2Rldi9tY2Vsb2cgaXMgY2FsbGVkIGluIHByb2Nlc3Mg Y29udGV4dCBub3cgYXMgcGFydCBvZiB0aGUgbm90aWZpZXIKY2hhaW4gYW5kIGRvZXNuJ3QgbmVl ZCBhbnkgb2YgdGhlIGZhbmN5IFJDVSBhbmQgbG9ja2xlc3MgYWNjZXNzZXMgd2hpY2gKaXQgZGlk IGluIGF0b21pYyBjb250ZXh0LgoKQXhlIGl0IGFsbCBpbiBmYXZvciBvZiBhIHNpbXBsZSBtdXRl eCBzeW5jaHJvbml6YXRpb24gd2hpY2ggY3VyZXMgdGhlCnByb2JsZW0gcmVwb3J0ZWQuCgpGaXhl czogNWRlOTdjOWY2ZDg1ICgieDg2L21jZTogRmFjdG9yIG91dCBhbmQgZGVwcmVjYXRlIHRoZSAv ZGV2L21jZWxvZyBkcml2ZXIiKQpSZXBvcnRlZC1ieTogSmVyZW15IENsaW5lIDxqY2xpbmVAcmVk aGF0LmNvbT4KU2lnbmVkLW9mZi1ieTogQm9yaXNsYXYgUGV0a292IDxicEBzdXNlLmRlPgpTaWdu ZWQtb2ZmLWJ5OiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KUmV2aWV3ZWQt YW5kLXRlc3RlZC1ieTogVG9ueSBMdWNrIDx0b255Lmx1Y2tAaW50ZWwuY29tPgpDYzogQW5kaSBL bGVlbiA8YWtAbGludXguaW50ZWwuY29tPgpDYzogbGludXgtZWRhY0B2Z2VyLmtlcm5lbC5vcmcK Q2M6IExhdXJhIEFiYm90dCA8bGFiYm90dEByZWRoYXQuY29tPgpMaW5rOiBodHRwczovL2xrbWwu a2VybmVsLm9yZy9yLzIwMTcxMTAxMTY0NzU0Lnh6em1za2w0bmdycWM1YnJAcGQudG5pYwpMaW5r OiBodHRwczovL2J1Z3ppbGxhLnJlZGhhdC5jb20vc2hvd19idWcuY2dpP2lkPTE0OTg5NjkKU2ln bmVkLW9mZi1ieTogR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9y Zz4KLS0tCiBhcmNoL3g4Ni9rZXJuZWwvY3B1L21jaGVjay9kZXYtbWNlbG9nLmMgfCAgMTE5ICsr KysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgMjYgaW5zZXJ0 aW9ucygrKSwgOTMgZGVsZXRpb25zKC0pCgoKCi0tClRvIHVuc3Vic2NyaWJlIGZyb20gdGhpcyBs aXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC1lZGFjIiBpbgp0aGUgYm9keSBv ZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZwpNb3JlIG1ham9yZG9tbyBp bmZvIGF0ICBodHRwOi8vdmdlci5rZXJuZWwub3JnL21ham9yZG9tby1pbmZvLmh0bWwKCi0tLSBh L2FyY2gveDg2L2tlcm5lbC9jcHUvbWNoZWNrL2Rldi1tY2Vsb2cuYworKysgYi9hcmNoL3g4Ni9r ZXJuZWwvY3B1L21jaGVjay9kZXYtbWNlbG9nLmMKQEAgLTI0LDE0ICsyNCw2IEBAIHN0YXRpYyBE RUZJTkVfTVVURVgobWNlX2NocmRldl9yZWFkX211dGUKIHN0YXRpYyBjaGFyIG1jZV9oZWxwZXJb MTI4XTsKIHN0YXRpYyBjaGFyICptY2VfaGVscGVyX2FyZ3ZbMl0gPSB7IG1jZV9oZWxwZXIsIE5V TEwgfTsKIAotI2RlZmluZSBtY2VfbG9nX2dldF9pZHhfY2hlY2socCkgXAotKHsgXAotCVJDVV9M T0NLREVQX1dBUk4oIXJjdV9yZWFkX2xvY2tfc2NoZWRfaGVsZCgpICYmIFwKLQkJCSAhbG9ja2Rl cF9pc19oZWxkKCZtY2VfY2hyZGV2X3JlYWRfbXV0ZXgpLCBcCi0JCQkgInN1c3BpY2lvdXMgbWNl X2xvZ19nZXRfaWR4X2NoZWNrKCkgdXNhZ2UiKTsgXAotCXNtcF9sb2FkX2FjcXVpcmUoJihwKSk7 IFwKLX0pCi0KIC8qCiAgKiBMb2NrbGVzcyBNQ0UgbG9nZ2luZyBpbmZyYXN0cnVjdHVyZS4KICAq IFRoaXMgYXZvaWRzIGRlYWRsb2NrcyBvbiBwcmludGsgbG9ja3Mgd2l0aG91dCBoYXZpbmcgdG8g YnJlYWsgbG9ja3MuIEFsc28KQEAgLTUzLDQzICs0NSwzMiBAQCBzdGF0aWMgaW50IGRldl9tY2Vf bG9nKHN0cnVjdCBub3RpZmllcl9iCiAJCQkJdm9pZCAqZGF0YSkKIHsKIAlzdHJ1Y3QgbWNlICpt Y2UgPSAoc3RydWN0IG1jZSAqKWRhdGE7Ci0JdW5zaWduZWQgaW50IG5leHQsIGVudHJ5OworCXVu c2lnbmVkIGludCBlbnRyeTsKKworCW11dGV4X2xvY2soJm1jZV9jaHJkZXZfcmVhZF9tdXRleCk7 CiAKLQl3bWIoKTsKLQlmb3IgKDs7KSB7Ci0JCWVudHJ5ID0gbWNlX2xvZ19nZXRfaWR4X2NoZWNr KG1jZWxvZy5uZXh0KTsKLQkJZm9yICg7OykgewotCi0JCQkvKgotCQkJICogV2hlbiB0aGUgYnVm ZmVyIGZpbGxzIHVwIGRpc2NhcmQgbmV3IGVudHJpZXMuCi0JCQkgKiBBc3N1bWUgdGhhdCB0aGUg ZWFybGllciBlcnJvcnMgYXJlIHRoZSBtb3JlCi0JCQkgKiBpbnRlcmVzdGluZyBvbmVzOgotCQkJ ICovCi0JCQlpZiAoZW50cnkgPj0gTUNFX0xPR19MRU4pIHsKLQkJCQlzZXRfYml0KE1DRV9PVkVS RkxPVywKLQkJCQkJKHVuc2lnbmVkIGxvbmcgKikmbWNlbG9nLmZsYWdzKTsKLQkJCQlyZXR1cm4g Tk9USUZZX09LOwotCQkJfQotCQkJLyogT2xkIGxlZnQgb3ZlciBlbnRyeS4gU2tpcDogKi8KLQkJ CWlmIChtY2Vsb2cuZW50cnlbZW50cnldLmZpbmlzaGVkKSB7Ci0JCQkJZW50cnkrKzsKLQkJCQlj b250aW51ZTsKLQkJCX0KLQkJCWJyZWFrOwotCQl9Ci0JCXNtcF9ybWIoKTsKLQkJbmV4dCA9IGVu dHJ5ICsgMTsKLQkJaWYgKGNtcHhjaGcoJm1jZWxvZy5uZXh0LCBlbnRyeSwgbmV4dCkgPT0gZW50 cnkpCi0JCQlicmVhazsKKwllbnRyeSA9IG1jZWxvZy5uZXh0OworCisJLyoKKwkgKiBXaGVuIHRo ZSBidWZmZXIgZmlsbHMgdXAgZGlzY2FyZCBuZXcgZW50cmllcy4gQXNzdW1lIHRoYXQgdGhlCisJ ICogZWFybGllciBlcnJvcnMgYXJlIHRoZSBtb3JlIGludGVyZXN0aW5nIG9uZXM6CisJICovCisJ aWYgKGVudHJ5ID49IE1DRV9MT0dfTEVOKSB7CisJCXNldF9iaXQoTUNFX09WRVJGTE9XLCAodW5z aWduZWQgbG9uZyAqKSZtY2Vsb2cuZmxhZ3MpOworCQlnb3RvIHVubG9jazsKIAl9CisKKwltY2Vs b2cubmV4dCA9IGVudHJ5ICsgMTsKKwogCW1lbWNweShtY2Vsb2cuZW50cnkgKyBlbnRyeSwgbWNl LCBzaXplb2Yoc3RydWN0IG1jZSkpOwotCXdtYigpOwogCW1jZWxvZy5lbnRyeVtlbnRyeV0uZmlu aXNoZWQgPSAxOwotCXdtYigpOwogCiAJLyogd2FrZSBwcm9jZXNzZXMgcG9sbGluZyAvZGV2L21j ZWxvZyAqLwogCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmbWNlX2NocmRldl93YWl0KTsKIAordW5s b2NrOgorCW11dGV4X3VubG9jaygmbWNlX2NocmRldl9yZWFkX211dGV4KTsKKwogCXJldHVybiBO T1RJRllfT0s7CiB9CiAKQEAgLTE3NywxMyArMTU4LDYgQEAgc3RhdGljIGludCBtY2VfY2hyZGV2 X3JlbGVhc2Uoc3RydWN0IGlubwogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCBjb2xsZWN0 X3RzY3Modm9pZCAqZGF0YSkKLXsKLQl1bnNpZ25lZCBsb25nICpjcHVfdHNjID0gKHVuc2lnbmVk IGxvbmcgKilkYXRhOwotCi0JY3B1X3RzY1tzbXBfcHJvY2Vzc29yX2lkKCldID0gcmR0c2MoKTsK LX0KLQogc3RhdGljIGludCBtY2VfYXBlaV9yZWFkX2RvbmU7CiAKIC8qIENvbGxlY3QgTUNFIHJl Y29yZCBvZiBwcmV2aW91cyBib290IGluIHBlcnNpc3RlbnQgc3RvcmFnZSB2aWEgQVBFSSBFUlNU LiAqLwpAQCAtMjMxLDE0ICsyMDUsOSBAQCBzdGF0aWMgc3NpemVfdCBtY2VfY2hyZGV2X3JlYWQo c3RydWN0IGZpCiAJCQkJc2l6ZV90IHVzaXplLCBsb2ZmX3QgKm9mZikKIHsKIAljaGFyIF9fdXNl ciAqYnVmID0gdWJ1ZjsKLQl1bnNpZ25lZCBsb25nICpjcHVfdHNjOwotCXVuc2lnbmVkIHByZXYs IG5leHQ7CisJdW5zaWduZWQgbmV4dDsKIAlpbnQgaSwgZXJyOwogCi0JY3B1X3RzYyA9IGttYWxs b2MobnJfY3B1X2lkcyAqIHNpemVvZihsb25nKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFjcHVfdHNj KQotCQlyZXR1cm4gLUVOT01FTTsKLQogCW11dGV4X2xvY2soJm1jZV9jaHJkZXZfcmVhZF9tdXRl eCk7CiAKIAlpZiAoIW1jZV9hcGVpX3JlYWRfZG9uZSkgewpAQCAtMjQ3LDY1ICsyMTYsMjkgQEAg c3RhdGljIHNzaXplX3QgbWNlX2NocmRldl9yZWFkKHN0cnVjdCBmaQogCQkJZ290byBvdXQ7CiAJ fQogCi0JbmV4dCA9IG1jZV9sb2dfZ2V0X2lkeF9jaGVjayhtY2Vsb2cubmV4dCk7Ci0KIAkvKiBP bmx5IHN1cHBvcnRzIGZ1bGwgcmVhZHMgcmlnaHQgbm93ICovCiAJZXJyID0gLUVJTlZBTDsKIAlp ZiAoKm9mZiAhPSAwIHx8IHVzaXplIDwgTUNFX0xPR19MRU4qc2l6ZW9mKHN0cnVjdCBtY2UpKQog CQlnb3RvIG91dDsKIAorCW5leHQgPSBtY2Vsb2cubmV4dDsKIAllcnIgPSAwOwotCXByZXYgPSAw OwotCWRvIHsKLQkJZm9yIChpID0gcHJldjsgaSA8IG5leHQ7IGkrKykgewotCQkJdW5zaWduZWQg bG9uZyBzdGFydCA9IGppZmZpZXM7Ci0JCQlzdHJ1Y3QgbWNlICptID0gJm1jZWxvZy5lbnRyeVtp XTsKLQotCQkJd2hpbGUgKCFtLT5maW5pc2hlZCkgewotCQkJCWlmICh0aW1lX2FmdGVyX2VxKGpp ZmZpZXMsIHN0YXJ0ICsgMikpIHsKLQkJCQkJbWVtc2V0KG0sIDAsIHNpemVvZigqbSkpOwotCQkJ CQlnb3RvIHRpbWVvdXQ7Ci0JCQkJfQotCQkJCWNwdV9yZWxheCgpOwotCQkJfQotCQkJc21wX3Jt YigpOwotCQkJZXJyIHw9IGNvcHlfdG9fdXNlcihidWYsIG0sIHNpemVvZigqbSkpOwotCQkJYnVm ICs9IHNpemVvZigqbSk7Ci10aW1lb3V0OgotCQkJOwotCQl9Ci0KLQkJbWVtc2V0KG1jZWxvZy5l bnRyeSArIHByZXYsIDAsCi0JCSAgICAgICAobmV4dCAtIHByZXYpICogc2l6ZW9mKHN0cnVjdCBt Y2UpKTsKLQkJcHJldiA9IG5leHQ7Ci0JCW5leHQgPSBjbXB4Y2hnKCZtY2Vsb2cubmV4dCwgcHJl diwgMCk7Ci0JfSB3aGlsZSAobmV4dCAhPSBwcmV2KTsKIAotCXN5bmNocm9uaXplX3NjaGVkKCk7 Ci0KLQkvKgotCSAqIENvbGxlY3QgZW50cmllcyB0aGF0IHdlcmUgc3RpbGwgZ2V0dGluZyB3cml0 dGVuIGJlZm9yZSB0aGUKLQkgKiBzeW5jaHJvbml6ZS4KLQkgKi8KLQlvbl9lYWNoX2NwdShjb2xs ZWN0X3RzY3MsIGNwdV90c2MsIDEpOwotCi0JZm9yIChpID0gbmV4dDsgaSA8IE1DRV9MT0dfTEVO OyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgbmV4dDsgaSsrKSB7CiAJCXN0cnVjdCBtY2UgKm0g PSAmbWNlbG9nLmVudHJ5W2ldOwogCi0JCWlmIChtLT5maW5pc2hlZCAmJiBtLT50c2MgPCBjcHVf dHNjW20tPmNwdV0pIHsKLQkJCWVyciB8PSBjb3B5X3RvX3VzZXIoYnVmLCBtLCBzaXplb2YoKm0p KTsKLQkJCXNtcF9ybWIoKTsKLQkJCWJ1ZiArPSBzaXplb2YoKm0pOwotCQkJbWVtc2V0KG0sIDAs IHNpemVvZigqbSkpOwotCQl9CisJCWVyciB8PSBjb3B5X3RvX3VzZXIoYnVmLCBtLCBzaXplb2Yo Km0pKTsKKwkJYnVmICs9IHNpemVvZigqbSk7CiAJfQogCisJbWVtc2V0KG1jZWxvZy5lbnRyeSwg MCwgbmV4dCAqIHNpemVvZihzdHJ1Y3QgbWNlKSk7CisJbWNlbG9nLm5leHQgPSAwOworCiAJaWYg KGVycikKIAkJZXJyID0gLUVGQVVMVDsKIAogb3V0OgogCW11dGV4X3VubG9jaygmbWNlX2NocmRl dl9yZWFkX211dGV4KTsKLQlrZnJlZShjcHVfdHNjKTsKIAogCXJldHVybiBlcnIgPyBlcnIgOiBi dWYgLSB1YnVmOwogfQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752862AbdKFJP1 (ORCPT ); Mon, 6 Nov 2017 04:15:27 -0500 Received: from mail.linuxfoundation.org ([140.211.169.12]:56650 "EHLO mail.linuxfoundation.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751300AbdKFJPY (ORCPT ); Mon, 6 Nov 2017 04:15:24 -0500 From: Greg Kroah-Hartman To: linux-kernel@vger.kernel.org Cc: Greg Kroah-Hartman , stable@vger.kernel.org, Jeremy Cline , Borislav Petkov , Thomas Gleixner , Andi Kleen , linux-edac@vger.kernel.org, Laura Abbott Subject: [PATCH 4.13 35/36] x86/mcelog: Get rid of RCU remnants Date: Mon, 6 Nov 2017 10:12:48 +0100 Message-Id: <20171106085048.608290620@linuxfoundation.org> X-Mailer: git-send-email 2.15.0 In-Reply-To: <20171106085047.005824077@linuxfoundation.org> References: <20171106085047.005824077@linuxfoundation.org> User-Agent: quilt/0.65 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 4.13-stable review patch. If anyone has any objections, please let me know. ------------------ From: Borislav Petkov commit 7298f08ea8870d44d36c7d6cd07dd0303faef6c2 upstream. Jeremy reported a suspicious RCU usage warning in mcelog. /dev/mcelog is called in process context now as part of the notifier chain and doesn't need any of the fancy RCU and lockless accesses which it did in atomic context. Axe it all in favor of a simple mutex synchronization which cures the problem reported. Fixes: 5de97c9f6d85 ("x86/mce: Factor out and deprecate the /dev/mcelog driver") Reported-by: Jeremy Cline Signed-off-by: Borislav Petkov Signed-off-by: Thomas Gleixner Reviewed-and-tested-by: Tony Luck Cc: Andi Kleen Cc: linux-edac@vger.kernel.org Cc: Laura Abbott Link: https://lkml.kernel.org/r/20171101164754.xzzmskl4ngrqc5br@pd.tnic Link: https://bugzilla.redhat.com/show_bug.cgi?id=1498969 Signed-off-by: Greg Kroah-Hartman --- arch/x86/kernel/cpu/mcheck/dev-mcelog.c | 119 ++++++-------------------------- 1 file changed, 26 insertions(+), 93 deletions(-) --- a/arch/x86/kernel/cpu/mcheck/dev-mcelog.c +++ b/arch/x86/kernel/cpu/mcheck/dev-mcelog.c @@ -24,14 +24,6 @@ static DEFINE_MUTEX(mce_chrdev_read_mute static char mce_helper[128]; static char *mce_helper_argv[2] = { mce_helper, NULL }; -#define mce_log_get_idx_check(p) \ -({ \ - RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held() && \ - !lockdep_is_held(&mce_chrdev_read_mutex), \ - "suspicious mce_log_get_idx_check() usage"); \ - smp_load_acquire(&(p)); \ -}) - /* * Lockless MCE logging infrastructure. * This avoids deadlocks on printk locks without having to break locks. Also @@ -53,43 +45,32 @@ static int dev_mce_log(struct notifier_b void *data) { struct mce *mce = (struct mce *)data; - unsigned int next, entry; + unsigned int entry; + + mutex_lock(&mce_chrdev_read_mutex); - wmb(); - for (;;) { - entry = mce_log_get_idx_check(mcelog.next); - for (;;) { - - /* - * When the buffer fills up discard new entries. - * Assume that the earlier errors are the more - * interesting ones: - */ - if (entry >= MCE_LOG_LEN) { - set_bit(MCE_OVERFLOW, - (unsigned long *)&mcelog.flags); - return NOTIFY_OK; - } - /* Old left over entry. Skip: */ - if (mcelog.entry[entry].finished) { - entry++; - continue; - } - break; - } - smp_rmb(); - next = entry + 1; - if (cmpxchg(&mcelog.next, entry, next) == entry) - break; + entry = mcelog.next; + + /* + * When the buffer fills up discard new entries. Assume that the + * earlier errors are the more interesting ones: + */ + if (entry >= MCE_LOG_LEN) { + set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog.flags); + goto unlock; } + + mcelog.next = entry + 1; + memcpy(mcelog.entry + entry, mce, sizeof(struct mce)); - wmb(); mcelog.entry[entry].finished = 1; - wmb(); /* wake processes polling /dev/mcelog */ wake_up_interruptible(&mce_chrdev_wait); +unlock: + mutex_unlock(&mce_chrdev_read_mutex); + return NOTIFY_OK; } @@ -177,13 +158,6 @@ static int mce_chrdev_release(struct ino return 0; } -static void collect_tscs(void *data) -{ - unsigned long *cpu_tsc = (unsigned long *)data; - - cpu_tsc[smp_processor_id()] = rdtsc(); -} - static int mce_apei_read_done; /* Collect MCE record of previous boot in persistent storage via APEI ERST. */ @@ -231,14 +205,9 @@ static ssize_t mce_chrdev_read(struct fi size_t usize, loff_t *off) { char __user *buf = ubuf; - unsigned long *cpu_tsc; - unsigned prev, next; + unsigned next; int i, err; - cpu_tsc = kmalloc(nr_cpu_ids * sizeof(long), GFP_KERNEL); - if (!cpu_tsc) - return -ENOMEM; - mutex_lock(&mce_chrdev_read_mutex); if (!mce_apei_read_done) { @@ -247,65 +216,29 @@ static ssize_t mce_chrdev_read(struct fi goto out; } - next = mce_log_get_idx_check(mcelog.next); - /* Only supports full reads right now */ err = -EINVAL; if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) goto out; + next = mcelog.next; err = 0; - prev = 0; - do { - for (i = prev; i < next; i++) { - unsigned long start = jiffies; - struct mce *m = &mcelog.entry[i]; - - while (!m->finished) { - if (time_after_eq(jiffies, start + 2)) { - memset(m, 0, sizeof(*m)); - goto timeout; - } - cpu_relax(); - } - smp_rmb(); - err |= copy_to_user(buf, m, sizeof(*m)); - buf += sizeof(*m); -timeout: - ; - } - - memset(mcelog.entry + prev, 0, - (next - prev) * sizeof(struct mce)); - prev = next; - next = cmpxchg(&mcelog.next, prev, 0); - } while (next != prev); - synchronize_sched(); - - /* - * Collect entries that were still getting written before the - * synchronize. - */ - on_each_cpu(collect_tscs, cpu_tsc, 1); - - for (i = next; i < MCE_LOG_LEN; i++) { + for (i = 0; i < next; i++) { struct mce *m = &mcelog.entry[i]; - if (m->finished && m->tsc < cpu_tsc[m->cpu]) { - err |= copy_to_user(buf, m, sizeof(*m)); - smp_rmb(); - buf += sizeof(*m); - memset(m, 0, sizeof(*m)); - } + err |= copy_to_user(buf, m, sizeof(*m)); + buf += sizeof(*m); } + memset(mcelog.entry, 0, next * sizeof(struct mce)); + mcelog.next = 0; + if (err) err = -EFAULT; out: mutex_unlock(&mce_chrdev_read_mutex); - kfree(cpu_tsc); return err ? err : buf - ubuf; }