From mboxrd@z Thu Jan 1 00:00:00 1970 From: Joonas Lahtinen Subject: Re: [PATCH] [RFC] kernel/cpu: Use lockref for online CPU reference counting Date: Thu, 18 Feb 2016 12:54:11 +0200 Message-ID: <1455792851.9851.36.camel@linux.intel.com> References: <1455539803-13913-1-git-send-email-joonas.lahtinen@linux.intel.com> <20160215141755.GG6357@twins.programming.kicks-ass.net> <20160215170618.GL6375@twins.programming.kicks-ass.net> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by gabe.freedesktop.org (Postfix) with ESMTP id B85E46E1F0 for ; Thu, 18 Feb 2016 10:54:11 +0000 (UTC) In-Reply-To: <20160215170618.GL6375@twins.programming.kicks-ass.net> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Peter Zijlstra , Oleg Nesterov Cc: "Gautham R. Shenoy" , Intel graphics driver community testing & development , Linux kernel development , David Hildenbrand , "Paul E. McKenney" , Ingo Molnar List-Id: intel-gfx@lists.freedesktop.org SGksCgpPbiBtYSwgMjAxNi0wMi0xNSBhdCAxODowNiArMDEwMCwgUGV0ZXIgWmlqbHN0cmEgd3Jv dGU6Cj4gT24gTW9uLCBGZWIgMTUsIDIwMTYgYXQgMDM6MTc6NTVQTSArMDEwMCwgUGV0ZXIgWmlq bHN0cmEgd3JvdGU6Cj4gPiBPbiBNb24sIEZlYiAxNSwgMjAxNiBhdCAwMjozNjo0M1BNICswMjAw LCBKb29uYXMgTGFodGluZW4gd3JvdGU6Cj4gPiA+IEluc3RlYWQgb2YgaW1wbGVtZW50aW5nIGEg Y3VzdG9tIGxvY2tlZCByZWZlcmVuY2UgY291bnRpbmcsIHVzZSBsb2NrcmVmLgo+ID4gPiAKPiA+ ID4gQ3VycmVudCBpbXBsZW1lbnRhdGlvbiBsZWFkcyB0byBhIGRlYWRsb2NrIHNwbGF0IG9uIElu dGVsIFNLTCBwbGF0Zm9ybXMKPiA+ID4gd2hlbiBsb2NrZGVwIGRlYnVnZ2luZyBpcyBlbmFibGVk Lgo+ID4gPiAKPiA+ID4gVGhpcyBpcyBkdWUgdG8gZmV3IG9mIENQVWZyZXEgZHJpdmVycyAoaW5j bHVkaW5nIEludGVsIFAtc3RhdGUpIGhhdmluZyB0aGlzOwo+ID4gPiBwb2xpY3ktPnJ3c2VtIGlz IGxvY2tlZCBkdXJpbmcgZHJpdmVyIGluaXRpYWxpemF0aW9uIGFuZCB0aGUgZnVuY3Rpb25zIGNh bGxlZAo+ID4gPiBkdXJpbmcgaW5pdCB0aGF0IGFjdHVhbGx5IGFwcGx5IENQVSBsaW1pdHMgdXNl IGdldF9vbmxpbmVfY3B1cyAoYmVjYXVzZSB0aGV5Cj4gPiA+IGhhdmUgb3RoZXIgY2FsbGluZyBw YXRocyB0b28pLCB3aGljaCB3aWxsIGJyaWVmbHkgbG9jayBjcHVfaG90cGx1Zy5sb2NrIHRvCj4g PiA+IGluY3JlYXNlIGNwdV9ob3RwbHVnLnJlZmNvdW50Lgo+ID4gPiAKPiA+ID4gT24gbGF0ZXIg Y2FsbGluZyBwYXRoLCB3aGVuIGRvaW5nIGEgc3VzcGVuZCwgd2hlbiBjcHVfaG90cGx1Z19iZWdp bigpIGlzIGNhbGxlZAo+ID4gPiBpbiBkaXNhYmxlX25vbmJvb3RfY3B1cygpLCBjYWxsYmFja3Mg dG8gQ1BVZnJlcSBmdW5jdGlvbnMgZ2V0IGNhbGxlZCBhZnRlciwKPiA+ID4gd2hpY2ggd2lsbCBs b2NrIHBvbGljeS0+cndzZW0gYW5kIGNwdV9ob3RwbHVnLmxvY2sgaXMgYWxyZWFkeSBoZWxkIGJ5 Cj4gPiA+IGNwdV9ob3RwbHVnX2JlZ2luKCkgYW5kIHdlIGRvIGhhdmUgYSBwb3RlbnRpYWwgZGVh ZGxvY2sgc2NlbmFyaW8gcmVwb3J0ZWQgYnkKPiA+ID4gb3VyIENJIHN5c3RlbSAodGhvdWdoIGl0 IGlzIGEgdmVyeSB1bmxpa2VseSBvbmUpLiBTZWUgdGhlIEJ1Z3ppbGxhIGxpbmsgZm9yIG1vcmUK PiA+ID4gZGV0YWlscy4KPiA+IAo+ID4gSSd2ZSBiZWVuIG1lYW5pbmcgdG8gY2hhbmdlIHRoZSB0 aGluZyBpbnRvIGEgcGVyY3B1LXJ3c2VtLCBJIGp1c3QKPiA+IGhhdmVuJ3QgaGFkIHRpbWUgdG8g bG9vayBpbnRvIHRoZSBsb2NrZGVwIHNwbGF0IHRoYXQgZ2VuZXJhdGVkLgo+IAo+IAo+IFRoZSBi ZWxvdyBoYXMgcGxlbnR5IGxvY2tkZXAgaXNzdWVzIGJlY2F1c2UgcGVyY3B1LXJ3c2VtIGlzCj4g cmVhZGVyLXdyaXRlciBmYWlyIChsaWtlIHRoZSByZWd1bGFyIHJ3c2VtKSwgc28gaXQgZG9lcyB0 aHJvdyB1cCBhIGZhaXIKPiBudW1iZXIgb2YgdmVyeSBpY2t5IGlzc3Vlcy4KPiAKPiBJZiBhdCBh bGwgcG9zc2libGUsIEknZCByZWFsbHkgcmF0aGVyIGZpeCB0aG9zZSBhbmQgaGF2ZSBhICdzYW5l cicKPiBob3RwbHVnIGxvY2ssIHJhdGhlciB0aGFuIG11ZGRsZSBvbiB3aXRoIG9wZW4tY29kZWQg aG9ycm9yIGxvY2sgd2UgaGF2ZQo+IG5vdy4KPiAKCkkgZG8gc3RpbGwgYWdyZWUgdGhlIGJlbG93 IHdvdWxkIGJlIGEgd29ydGh5IGNoYW5nZSB0byBwcm9jZWVkIHdpdGguCgpDQydkIE9sZWcgaGVy ZSB0b28gdG8gZ2l2ZSBhIGNvbW1lbnQuCgpSZWdhcmRzLCBKb29uYXMKCj4gCj4gLS0tIGEvaW5j bHVkZS9saW51eC9jcHUuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvY3B1LmgKPiBAQCAtMjI1LDYg KzIyNSw4IEBAIGV4dGVybiBzdHJ1Y3QgYnVzX3R5cGUgY3B1X3N1YnN5czsKPiDCoCNpZmRlZiBD T05GSUdfSE9UUExVR19DUFUKPiDCoC8qIFN0b3AgQ1BVcyBnb2luZyB1cCBhbmQgZG93bi4gKi8K PiDCoAo+ICtleHRlcm4gdm9pZCBjcHVfaG90cGx1Z19pbml0X3Rhc2soc3RydWN0IHRhc2tfc3Ry dWN0ICpwKTsKPiArCj4gwqBleHRlcm4gdm9pZCBjcHVfaG90cGx1Z19iZWdpbih2b2lkKTsKPiDC oGV4dGVybiB2b2lkIGNwdV9ob3RwbHVnX2RvbmUodm9pZCk7Cj4gwqBleHRlcm4gdm9pZCBnZXRf b25saW5lX2NwdXModm9pZCk7Cj4gQEAgLTI0Miw2ICsyNDQsOCBAQCBpbnQgY3B1X2Rvd24odW5z aWduZWQgaW50IGNwdSk7Cj4gwqAKPiDCoCNlbHNlCQkvKiBDT05GSUdfSE9UUExVR19DUFUgKi8K PiDCoAo+ICtzdGF0aWMgaW5saW5lIHZvaWQgY3B1X2hvdHBsdWdfaW5pdF90YXNrKHN0cnVjdCB0 YXNrX3N0cnVjdCAqcCkge30KPiArCj4gwqBzdGF0aWMgaW5saW5lIHZvaWQgY3B1X2hvdHBsdWdf YmVnaW4odm9pZCkge30KPiDCoHN0YXRpYyBpbmxpbmUgdm9pZCBjcHVfaG90cGx1Z19kb25lKHZv aWQpIHt9Cj4gwqAjZGVmaW5lIGdldF9vbmxpbmVfY3B1cygpCWRvIHsgfSB3aGlsZSAoMCkKPiAt LS0gYS9pbmNsdWRlL2xpbnV4L3BlcmNwdS1yd3NlbS5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9w ZXJjcHUtcndzZW0uaAo+IEBAIC0xNiw2ICsxNiwxNSBAQCBzdHJ1Y3QgcGVyY3B1X3J3X3NlbWFw aG9yZSB7Cj4gwqAJd2FpdF9xdWV1ZV9oZWFkX3QJd3JpdGVfd2FpdHE7Cj4gwqB9Owo+IMKgCj4g KyNkZWZpbmUgREVGSU5FX1NUQVRJQ19QRVJDUFVfUldTRU0obmFtZSkJCQkJXAo+ICtzdGF0aWMg REVGSU5FX1BFUl9DUFUodW5zaWduZWQgaW50LCBfX3BlcmNwdV9yd3NlbV9mcmNfIyNuYW1lKTsJ XAo+ICtzdGF0aWMgc3RydWN0IHBlcmNwdV9yd19zZW1hcGhvcmUgbmFtZSA9IHsJCQkJXAo+ICsJ LnJzcyA9IF9fUkNVX1NZTkNfSU5JVElBTElaRVIobmFtZS5yc3MsIFJDVV9TQ0hFRF9TWU5DKSwJ XAo+ICsJLmZhc3RfcmVhZF9jdHIgPSAmX19wZXJjcHVfcndzZW1fZnJjXyMjbmFtZSwJCQlcCj4g Kwkucndfc2VtID0gX19SV1NFTV9JTklUSUFMSVpFUihuYW1lLnJ3X3NlbSksCQkJXAo+ICsJLndy aXRlX3dhaXRxID0gX19XQUlUX1FVRVVFX0hFQURfSU5JVElBTElaRVIobmFtZS53cml0ZV93YWl0 cSksCVwKPiArfQo+ICsKPiDCoGV4dGVybiB2b2lkIHBlcmNwdV9kb3duX3JlYWQoc3RydWN0IHBl cmNwdV9yd19zZW1hcGhvcmUgKik7Cj4gwqBleHRlcm4gaW50wqDCoHBlcmNwdV9kb3duX3JlYWRf dHJ5bG9jayhzdHJ1Y3QgcGVyY3B1X3J3X3NlbWFwaG9yZSAqKTsKPiDCoGV4dGVybiB2b2lkIHBl cmNwdV91cF9yZWFkKHN0cnVjdCBwZXJjcHVfcndfc2VtYXBob3JlICopOwo+IEBAIC0zMyw5ICs0 MiwxMSBAQCBleHRlcm4gdm9pZCBwZXJjcHVfZnJlZV9yd3NlbShzdHJ1Y3QgcGVyCj4gwqAJX19w ZXJjcHVfaW5pdF9yd3NlbShicncsICNicncsICZyd3NlbV9rZXkpOwkJXAo+IMKgfSkKPiDCoAo+ IC0KPiDCoCNkZWZpbmUgcGVyY3B1X3J3c2VtX2lzX2hlbGQoc2VtKSBsb2NrZGVwX2lzX2hlbGQo JihzZW0pLT5yd19zZW0pCj4gwqAKPiArI2RlZmluZSBwZXJjcHVfcndzZW1fYXNzZXJ0X2hlbGQo c2VtKcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBc Cj4gKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCYoc2VtKS0+cndfc2VtKQo+ICsKPiDCoHN0YXRpYyBp bmxpbmUgdm9pZCBwZXJjcHVfcndzZW1fcmVsZWFzZShzdHJ1Y3QgcGVyY3B1X3J3X3NlbWFwaG9y ZSAqc2VtLAo+IMKgCQkJCQlib29sIHJlYWQsIHVuc2lnbmVkIGxvbmcgaXApCj4gwqB7Cj4gLS0t IGEvaW5jbHVkZS9saW51eC9zY2hlZC5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9zY2hlZC5oCj4g QEAgLTE0MDMsNiArMTQwMyw5IEBAIHN0cnVjdCB0YXNrX3N0cnVjdCB7Cj4gwqAJc3RydWN0IHRh c2tfc3RydWN0ICpsYXN0X3dha2VlOwo+IMKgCj4gwqAJaW50IHdha2VfY3B1Owo+ICsjaWZkZWYg Q09ORklHX0hPVFBMVUdfQ1BVCj4gKwlpbnQgY3B1aHBfcmVmOwo+ICsjZW5kaWYKPiDCoCNlbmRp Zgo+IMKgCWludCBvbl9ycTsKPiDCoAo+IC0tLSBhL2tlcm5lbC9jcHUuYwo+ICsrKyBiL2tlcm5l bC9jcHUuYwo+IEBAIC0yMyw2ICsyMyw3IEBACj4gwqAjaW5jbHVkZSAKPiDCoCNpbmNsdWRlIAo+ IMKgI2luY2x1ZGUgCj4gKyNpbmNsdWRlIAo+IMKgCj4gwqAjaW5jbHVkZSAic21wYm9vdC5oIgo+ IMKgCj4gQEAgLTUxLDEyMSArNTIsNTIgQEAgRVhQT1JUX1NZTUJPTChjcHVfbm90aWZpZXJfcmVn aXN0ZXJfZG9uZQo+IMKgCj4gwqBzdGF0aWMgUkFXX05PVElGSUVSX0hFQUQoY3B1X2NoYWluKTsK PiDCoAo+IC0vKiBJZiBzZXQsIGNwdV91cCBhbmQgY3B1X2Rvd24gd2lsbCByZXR1cm4gLUVCVVNZ IGFuZCBkbyBub3RoaW5nLgo+ICsvKgo+ICsgKiBJZiBzZXQsIGNwdV91cCBhbmQgY3B1X2Rvd24g d2lsbCByZXR1cm4gLUVCVVNZIGFuZCBkbyBub3RoaW5nLgo+IMKgICogU2hvdWxkIGFsd2F5cyBi ZSBtYW5pcHVsYXRlZCB1bmRlciBjcHVfYWRkX3JlbW92ZV9sb2NrCj4gwqAgKi8KPiDCoHN0YXRp YyBpbnQgY3B1X2hvdHBsdWdfZGlzYWJsZWQ7Cj4gwqAKPiDCoCNpZmRlZiBDT05GSUdfSE9UUExV R19DUFUKPiDCoAo+IC1zdGF0aWMgc3RydWN0IHsKPiAtCXN0cnVjdCB0YXNrX3N0cnVjdCAqYWN0 aXZlX3dyaXRlcjsKPiAtCS8qIHdhaXQgcXVldWUgdG8gd2FrZSB1cCB0aGUgYWN0aXZlX3dyaXRl ciAqLwo+IC0Jd2FpdF9xdWV1ZV9oZWFkX3Qgd3E7Cj4gLQkvKiB2ZXJpZmllcyB0aGF0IG5vIHdy aXRlciB3aWxsIGdldCBhY3RpdmUgd2hpbGUgcmVhZGVycyBhcmUgYWN0aXZlICovCj4gLQlzdHJ1 Y3QgbXV0ZXggbG9jazsKPiAtCS8qCj4gLQnCoCogQWxzbyBibG9ja3MgdGhlIG5ldyByZWFkZXJz IGR1cmluZwo+IC0JwqAqIGFuIG9uZ29pbmcgY3B1IGhvdHBsdWcgb3BlcmF0aW9uLgo+IC0JwqAq Lwo+IC0JYXRvbWljX3QgcmVmY291bnQ7Cj4gLQo+IC0jaWZkZWYgQ09ORklHX0RFQlVHX0xPQ0tf QUxMT0MKPiAtCXN0cnVjdCBsb2NrZGVwX21hcCBkZXBfbWFwOwo+IC0jZW5kaWYKPiAtfSBjcHVf aG90cGx1ZyA9IHsKPiAtCS5hY3RpdmVfd3JpdGVyID0gTlVMTCwKPiAtCS53cSA9IF9fV0FJVF9R VUVVRV9IRUFEX0lOSVRJQUxJWkVSKGNwdV9ob3RwbHVnLndxKSwKPiAtCS5sb2NrID0gX19NVVRF WF9JTklUSUFMSVpFUihjcHVfaG90cGx1Zy5sb2NrKSwKPiAtI2lmZGVmIENPTkZJR19ERUJVR19M T0NLX0FMTE9DCj4gLQkuZGVwX21hcCA9IHsubmFtZSA9ICJjcHVfaG90cGx1Zy5sb2NrIiB9LAo+ IC0jZW5kaWYKPiAtfTsKPiAtCj4gLS8qIExvY2tkZXAgYW5ub3RhdGlvbnMgZm9yIGdldC9wdXRf b25saW5lX2NwdXMoKSBhbmQgY3B1X2hvdHBsdWdfYmVnaW4vZW5kKCkgKi8KPiAtI2RlZmluZSBj cHVocF9sb2NrX2FjcXVpcmVfcmVhZCgpIGxvY2tfbWFwX2FjcXVpcmVfcmVhZCgmY3B1X2hvdHBs dWcuZGVwX21hcCkKPiAtI2RlZmluZSBjcHVocF9sb2NrX2FjcXVpcmVfdHJ5cmVhZCgpIFwKPiAt CQkJCcKgwqBsb2NrX21hcF9hY3F1aXJlX3RyeXJlYWQoJmNwdV9ob3RwbHVnLmRlcF9tYXApCj4g LSNkZWZpbmUgY3B1aHBfbG9ja19hY3F1aXJlKCnCoMKgwqDCoMKgwqBsb2NrX21hcF9hY3F1aXJl KCZjcHVfaG90cGx1Zy5kZXBfbWFwKQo+IC0jZGVmaW5lIGNwdWhwX2xvY2tfcmVsZWFzZSgpwqDC oMKgwqDCoMKgbG9ja19tYXBfcmVsZWFzZSgmY3B1X2hvdHBsdWcuZGVwX21hcCkKPiArREVGSU5F X1NUQVRJQ19QRVJDUFVfUldTRU0oaG90cGx1Zyk7Cj4gwqAKPiArdm9pZCBjcHVfaG90cGx1Z19p bml0X3Rhc2soc3RydWN0IHRhc2tfc3RydWN0ICpwKQo+ICt7Cj4gKwlpZiAoV0FSTl9PTl9PTkNF KHAtPmNwdWhwX3JlZikpCj4gKwkJcC0+Y3B1aHBfcmVmID0gMDsKPiArfQo+IMKgCj4gwqB2b2lk IGdldF9vbmxpbmVfY3B1cyh2b2lkKQo+IMKgewo+IMKgCW1pZ2h0X3NsZWVwKCk7Cj4gLQlpZiAo Y3B1X2hvdHBsdWcuYWN0aXZlX3dyaXRlciA9PSBjdXJyZW50KQo+ICsKPiArCWlmIChjdXJyZW50 LT5jcHVocF9yZWYrKykgLyogcmVhZCByZWN1cnNpb24gKi8KPiDCoAkJcmV0dXJuOwo+IC0JY3B1 aHBfbG9ja19hY3F1aXJlX3JlYWQoKTsKPiAtCW11dGV4X2xvY2soJmNwdV9ob3RwbHVnLmxvY2sp Owo+IC0JYXRvbWljX2luYygmY3B1X2hvdHBsdWcucmVmY291bnQpOwo+IC0JbXV0ZXhfdW5sb2Nr KCZjcHVfaG90cGx1Zy5sb2NrKTsKPiArCj4gKwlwZXJjcHVfZG93bl9yZWFkKCZob3RwbHVnKTsK PiDCoH0KPiDCoEVYUE9SVF9TWU1CT0xfR1BMKGdldF9vbmxpbmVfY3B1cyk7Cj4gwqAKPiDCoHZv aWQgcHV0X29ubGluZV9jcHVzKHZvaWQpCj4gwqB7Cj4gLQlpbnQgcmVmY291bnQ7Cj4gLQo+IC0J aWYgKGNwdV9ob3RwbHVnLmFjdGl2ZV93cml0ZXIgPT0gY3VycmVudCkKPiArCWlmICgtLWN1cnJl bnQtPmNwdWhwX3JlZikKPiDCoAkJcmV0dXJuOwo+IMKgCj4gLQlyZWZjb3VudCA9IGF0b21pY19k ZWNfcmV0dXJuKCZjcHVfaG90cGx1Zy5yZWZjb3VudCk7Cj4gLQlpZiAoV0FSTl9PTihyZWZjb3Vu dCA8IDApKSAvKiB0cnkgdG8gZml4IHRoaW5ncyB1cCAqLwo+IC0JCWF0b21pY19pbmMoJmNwdV9o b3RwbHVnLnJlZmNvdW50KTsKPiAtCj4gLQlpZiAocmVmY291bnQgPD0gMCAmJiB3YWl0cXVldWVf YWN0aXZlKCZjcHVfaG90cGx1Zy53cSkpCj4gLQkJd2FrZV91cCgmY3B1X2hvdHBsdWcud3EpOwo+ IC0KPiAtCWNwdWhwX2xvY2tfcmVsZWFzZSgpOwo+IC0KPiArCXBlcmNwdV91cF9yZWFkKCZob3Rw bHVnKTsKPiDCoH0KPiDCoEVYUE9SVF9TWU1CT0xfR1BMKHB1dF9vbmxpbmVfY3B1cyk7Cj4gwqAK PiAtLyoKPiAtICogVGhpcyBlbnN1cmVzIHRoYXQgdGhlIGhvdHBsdWcgb3BlcmF0aW9uIGNhbiBi ZWdpbiBvbmx5IHdoZW4gdGhlCj4gLSAqIHJlZmNvdW50IGdvZXMgdG8gemVyby4KPiAtICoKPiAt ICogTm90ZSB0aGF0IGR1cmluZyBhIGNwdS1ob3RwbHVnIG9wZXJhdGlvbiwgdGhlIG5ldyByZWFk ZXJzLCBpZiBhbnksCj4gLSAqIHdpbGwgYmUgYmxvY2tlZCBieSB0aGUgY3B1X2hvdHBsdWcubG9j awo+IC0gKgo+IC0gKiBTaW5jZSBjcHVfaG90cGx1Z19iZWdpbigpIGlzIGFsd2F5cyBjYWxsZWQg YWZ0ZXIgaW52b2tpbmcKPiAtICogY3B1X21hcHNfdXBkYXRlX2JlZ2luKCksIHdlIGNhbiBiZSBz dXJlIHRoYXQgb25seSBvbmUgd3JpdGVyIGlzIGFjdGl2ZS4KPiAtICoKPiAtICogTm90ZSB0aGF0 IHRoZW9yZXRpY2FsbHksIHRoZXJlIGlzIGEgcG9zc2liaWxpdHkgb2YgYSBsaXZlbG9jazoKPiAt ICogLSBSZWZjb3VudCBnb2VzIHRvIHplcm8sIGxhc3QgcmVhZGVyIHdha2VzIHVwIHRoZSBzbGVl cGluZwo+IC0gKsKgwqDCoHdyaXRlci4KPiAtICogLSBMYXN0IHJlYWRlciB1bmxvY2tzIHRoZSBj cHVfaG90cGx1Zy5sb2NrLgo+IC0gKiAtIEEgbmV3IHJlYWRlciBhcnJpdmVzIGF0IHRoaXMgbW9t ZW50LCBidW1wcyB1cCB0aGUgcmVmY291bnQuCj4gLSAqIC0gVGhlIHdyaXRlciBhY3F1aXJlcyB0 aGUgY3B1X2hvdHBsdWcubG9jayBmaW5kcyB0aGUgcmVmY291bnQKPiAtICrCoMKgwqBub24gemVy byBhbmQgZ29lcyB0byBzbGVlcCBhZ2Fpbi4KPiAtICoKPiAtICogSG93ZXZlciwgdGhpcyBpcyB2 ZXJ5IGRpZmZpY3VsdCB0byBhY2hpZXZlIGluIHByYWN0aWNlIHNpbmNlCj4gLSAqIGdldF9vbmxp bmVfY3B1cygpIG5vdCBhbiBhcGkgd2hpY2ggaXMgY2FsbGVkIGFsbCB0aGF0IG9mdGVuLgo+IC0g Kgo+IC0gKi8KPiDCoHZvaWQgY3B1X2hvdHBsdWdfYmVnaW4odm9pZCkKPiDCoHsKPiAtCURFRklO RV9XQUlUKHdhaXQpOwo+IC0KPiAtCWNwdV9ob3RwbHVnLmFjdGl2ZV93cml0ZXIgPSBjdXJyZW50 Owo+IC0JY3B1aHBfbG9ja19hY3F1aXJlKCk7Cj4gLQo+IC0JZm9yICg7Oykgewo+IC0JCW11dGV4 X2xvY2soJmNwdV9ob3RwbHVnLmxvY2spOwo+IC0JCXByZXBhcmVfdG9fd2FpdCgmY3B1X2hvdHBs dWcud3EsICZ3YWl0LCBUQVNLX1VOSU5URVJSVVBUSUJMRSk7Cj4gLQkJaWYgKGxpa2VseSghYXRv bWljX3JlYWQoJmNwdV9ob3RwbHVnLnJlZmNvdW50KSkpCj4gLQkJCQlicmVhazsKPiAtCQltdXRl eF91bmxvY2soJmNwdV9ob3RwbHVnLmxvY2spOwo+IC0JCXNjaGVkdWxlKCk7Cj4gLQl9Cj4gLQlm aW5pc2hfd2FpdCgmY3B1X2hvdHBsdWcud3EsICZ3YWl0KTsKPiArCXBlcmNwdV9kb3duX3dyaXRl KCZob3RwbHVnKTsKPiArCWN1cnJlbnQtPmNwdWhwX3JlZisrOyAvKiBhbGxvdyByZWFkLWluLXdy aXRlIHJlY3Vyc2lvbiAqLwo+IMKgfQo+IMKgCj4gwqB2b2lkIGNwdV9ob3RwbHVnX2RvbmUodm9p ZCkKPiDCoHsKPiAtCWNwdV9ob3RwbHVnLmFjdGl2ZV93cml0ZXIgPSBOVUxMOwo+IC0JbXV0ZXhf dW5sb2NrKCZjcHVfaG90cGx1Zy5sb2NrKTsKPiAtCWNwdWhwX2xvY2tfcmVsZWFzZSgpOwo+ICsJ Y3VycmVudC0+Y3B1aHBfcmVmLS07Cj4gKwlwZXJjcHVfdXBfd3JpdGUoJmhvdHBsdWcpOwo+IMKg fQo+IMKgCj4gwqAvKgo+IC0tLSBhL2tlcm5lbC9mb3JrLmMKPiArKysgYi9rZXJuZWwvZm9yay5j Cj4gQEAgLTE0MTQsNiArMTQxNCw4IEBAIHN0YXRpYyBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNvcHlf cHJvY2VzcygKPiDCoAlwLT5zZXF1ZW50aWFsX2lvX2F2Zwk9IDA7Cj4gwqAjZW5kaWYKPiDCoAo+ ICsJY3B1X2hvdHBsdWdfaW5pdF90YXNrKHApOwo+ICsKPiDCoAkvKiBQZXJmb3JtIHNjaGVkdWxl ciByZWxhdGVkIHNldHVwLiBBc3NpZ24gdGhpcyB0YXNrIHRvIGEgQ1BVLiAqLwo+IMKgCXJldHZh bCA9IHNjaGVkX2ZvcmsoY2xvbmVfZmxhZ3MsIHApOwo+IMKgCWlmIChyZXR2YWwpCj4gLS0tIGEv bGliL0tjb25maWcKPiArKysgYi9saWIvS2NvbmZpZwo+IEBAIC01Myw2ICs1MywxMSBAQCBjb25m aWcgR0VORVJJQ19JTwo+IMKgY29uZmlnIFNUTVBfREVWSUNFCj4gwqAJYm9vbAo+IMKgCj4gK2Nv bmZpZyBQRVJDUFVfUldTRU1fSE9UUExVRwo+ICsJZGVmX2Jvb2wgeQo+ICsJZGVwZW5kcyBvbiBI T1RQTFVHX0NQVQo+ICsJc2VsZWN0IFBFUkNQVV9SV1NFTQo+ICsKPiDCoGNvbmZpZyBBUkNIX1VT RV9DTVBYQ0hHX0xPQ0tSRUYKPiDCoAlib29sCj4gwqAKLS0gCkpvb25hcyBMYWh0aW5lbgpPcGVu IFNvdXJjZSBUZWNobm9sb2d5IENlbnRlcgpJbnRlbCBDb3Jwb3JhdGlvbgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0 CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3Rv cC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1426300AbcBRKyQ (ORCPT ); Thu, 18 Feb 2016 05:54:16 -0500 Received: from mga09.intel.com ([134.134.136.24]:55997 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1425160AbcBRKyM (ORCPT ); Thu, 18 Feb 2016 05:54:12 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.22,464,1449561600"; d="scan'208";a="654935255" Message-ID: <1455792851.9851.36.camel@linux.intel.com> Subject: Re: [PATCH] [RFC] kernel/cpu: Use lockref for online CPU reference counting From: Joonas Lahtinen To: Peter Zijlstra , Oleg Nesterov Cc: Intel graphics driver community testing & development , Linux kernel development , Ingo Molnar , David Hildenbrand , "Paul E. McKenney" , "Gautham R. Shenoy" , Chris Wilson Date: Thu, 18 Feb 2016 12:54:11 +0200 In-Reply-To: <20160215170618.GL6375@twins.programming.kicks-ass.net> References: <1455539803-13913-1-git-send-email-joonas.lahtinen@linux.intel.com> <20160215141755.GG6357@twins.programming.kicks-ass.net> <20160215170618.GL6375@twins.programming.kicks-ass.net> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo Content-Type: text/plain; charset="UTF-8" X-Mailer: Evolution 3.18.4 (3.18.4-1.fc23) Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, On ma, 2016-02-15 at 18:06 +0100, Peter Zijlstra wrote: > On Mon, Feb 15, 2016 at 03:17:55PM +0100, Peter Zijlstra wrote: > > On Mon, Feb 15, 2016 at 02:36:43PM +0200, Joonas Lahtinen wrote: > > > Instead of implementing a custom locked reference counting, use lockref. > > > > > > Current implementation leads to a deadlock splat on Intel SKL platforms > > > when lockdep debugging is enabled. > > > > > > This is due to few of CPUfreq drivers (including Intel P-state) having this; > > > policy->rwsem is locked during driver initialization and the functions called > > > during init that actually apply CPU limits use get_online_cpus (because they > > > have other calling paths too), which will briefly lock cpu_hotplug.lock to > > > increase cpu_hotplug.refcount. > > > > > > On later calling path, when doing a suspend, when cpu_hotplug_begin() is called > > > in disable_nonboot_cpus(), callbacks to CPUfreq functions get called after, > > > which will lock policy->rwsem and cpu_hotplug.lock is already held by > > > cpu_hotplug_begin() and we do have a potential deadlock scenario reported by > > > our CI system (though it is a very unlikely one). See the Bugzilla link for more > > > details. > > > > I've been meaning to change the thing into a percpu-rwsem, I just > > haven't had time to look into the lockdep splat that generated. > > > The below has plenty lockdep issues because percpu-rwsem is > reader-writer fair (like the regular rwsem), so it does throw up a fair > number of very icky issues. > > If at all possible, I'd really rather fix those and have a 'saner' > hotplug lock, rather than muddle on with open-coded horror lock we have > now. > I do still agree the below would be a worthy change to proceed with. CC'd Oleg here too to give a comment. Regards, Joonas > > --- a/include/linux/cpu.h > +++ b/include/linux/cpu.h > @@ -225,6 +225,8 @@ extern struct bus_type cpu_subsys; >  #ifdef CONFIG_HOTPLUG_CPU >  /* Stop CPUs going up and down. */ >   > +extern void cpu_hotplug_init_task(struct task_struct *p); > + >  extern void cpu_hotplug_begin(void); >  extern void cpu_hotplug_done(void); >  extern void get_online_cpus(void); > @@ -242,6 +244,8 @@ int cpu_down(unsigned int cpu); >   >  #else /* CONFIG_HOTPLUG_CPU */ >   > +static inline void cpu_hotplug_init_task(struct task_struct *p) {} > + >  static inline void cpu_hotplug_begin(void) {} >  static inline void cpu_hotplug_done(void) {} >  #define get_online_cpus() do { } while (0) > --- a/include/linux/percpu-rwsem.h > +++ b/include/linux/percpu-rwsem.h > @@ -16,6 +16,15 @@ struct percpu_rw_semaphore { >   wait_queue_head_t write_waitq; >  }; >   > +#define DEFINE_STATIC_PERCPU_RWSEM(name) \ > +static DEFINE_PER_CPU(unsigned int, __percpu_rwsem_frc_##name); \ > +static struct percpu_rw_semaphore name = { \ > + .rss = __RCU_SYNC_INITIALIZER(name.rss, RCU_SCHED_SYNC), \ > + .fast_read_ctr = &__percpu_rwsem_frc_##name, \ > + .rw_sem = __RWSEM_INITIALIZER(name.rw_sem), \ > + .write_waitq = __WAIT_QUEUE_HEAD_INITIALIZER(name.write_waitq), \ > +} > + >  extern void percpu_down_read(struct percpu_rw_semaphore *); >  extern int  percpu_down_read_trylock(struct percpu_rw_semaphore *); >  extern void percpu_up_read(struct percpu_rw_semaphore *); > @@ -33,9 +42,11 @@ extern void percpu_free_rwsem(struct per >   __percpu_init_rwsem(brw, #brw, &rwsem_key); \ >  }) >   > - >  #define percpu_rwsem_is_held(sem) lockdep_is_held(&(sem)->rw_sem) >   > +#define percpu_rwsem_assert_held(sem)                          \ > + lockdep_assert_held(&(sem)->rw_sem) > + >  static inline void percpu_rwsem_release(struct percpu_rw_semaphore *sem, >   bool read, unsigned long ip) >  { > --- a/include/linux/sched.h > +++ b/include/linux/sched.h > @@ -1403,6 +1403,9 @@ struct task_struct { >   struct task_struct *last_wakee; >   >   int wake_cpu; > +#ifdef CONFIG_HOTPLUG_CPU > + int cpuhp_ref; > +#endif >  #endif >   int on_rq; >   > --- a/kernel/cpu.c > +++ b/kernel/cpu.c > @@ -23,6 +23,7 @@ >  #include >  #include >  #include > +#include >   >  #include "smpboot.h" >   > @@ -51,121 +52,52 @@ EXPORT_SYMBOL(cpu_notifier_register_done >   >  static RAW_NOTIFIER_HEAD(cpu_chain); >   > -/* If set, cpu_up and cpu_down will return -EBUSY and do nothing. > +/* > + * If set, cpu_up and cpu_down will return -EBUSY and do nothing. >   * Should always be manipulated under cpu_add_remove_lock >   */ >  static int cpu_hotplug_disabled; >   >  #ifdef CONFIG_HOTPLUG_CPU >   > -static struct { > - struct task_struct *active_writer; > - /* wait queue to wake up the active_writer */ > - wait_queue_head_t wq; > - /* verifies that no writer will get active while readers are active */ > - struct mutex lock; > - /* > -  * Also blocks the new readers during > -  * an ongoing cpu hotplug operation. > -  */ > - atomic_t refcount; > - > -#ifdef CONFIG_DEBUG_LOCK_ALLOC > - struct lockdep_map dep_map; > -#endif > -} cpu_hotplug = { > - .active_writer = NULL, > - .wq = __WAIT_QUEUE_HEAD_INITIALIZER(cpu_hotplug.wq), > - .lock = __MUTEX_INITIALIZER(cpu_hotplug.lock), > -#ifdef CONFIG_DEBUG_LOCK_ALLOC > - .dep_map = {.name = "cpu_hotplug.lock" }, > -#endif > -}; > - > -/* Lockdep annotations for get/put_online_cpus() and cpu_hotplug_begin/end() */ > -#define cpuhp_lock_acquire_read() lock_map_acquire_read(&cpu_hotplug.dep_map) > -#define cpuhp_lock_acquire_tryread() \ > -   lock_map_acquire_tryread(&cpu_hotplug.dep_map) > -#define cpuhp_lock_acquire()      lock_map_acquire(&cpu_hotplug.dep_map) > -#define cpuhp_lock_release()      lock_map_release(&cpu_hotplug.dep_map) > +DEFINE_STATIC_PERCPU_RWSEM(hotplug); >   > +void cpu_hotplug_init_task(struct task_struct *p) > +{ > + if (WARN_ON_ONCE(p->cpuhp_ref)) > + p->cpuhp_ref = 0; > +} >   >  void get_online_cpus(void) >  { >   might_sleep(); > - if (cpu_hotplug.active_writer == current) > + > + if (current->cpuhp_ref++) /* read recursion */ >   return; > - cpuhp_lock_acquire_read(); > - mutex_lock(&cpu_hotplug.lock); > - atomic_inc(&cpu_hotplug.refcount); > - mutex_unlock(&cpu_hotplug.lock); > + > + percpu_down_read(&hotplug); >  } >  EXPORT_SYMBOL_GPL(get_online_cpus); >   >  void put_online_cpus(void) >  { > - int refcount; > - > - if (cpu_hotplug.active_writer == current) > + if (--current->cpuhp_ref) >   return; >   > - refcount = atomic_dec_return(&cpu_hotplug.refcount); > - if (WARN_ON(refcount < 0)) /* try to fix things up */ > - atomic_inc(&cpu_hotplug.refcount); > - > - if (refcount <= 0 && waitqueue_active(&cpu_hotplug.wq)) > - wake_up(&cpu_hotplug.wq); > - > - cpuhp_lock_release(); > - > + percpu_up_read(&hotplug); >  } >  EXPORT_SYMBOL_GPL(put_online_cpus); >   > -/* > - * This ensures that the hotplug operation can begin only when the > - * refcount goes to zero. > - * > - * Note that during a cpu-hotplug operation, the new readers, if any, > - * will be blocked by the cpu_hotplug.lock > - * > - * Since cpu_hotplug_begin() is always called after invoking > - * cpu_maps_update_begin(), we can be sure that only one writer is active. > - * > - * Note that theoretically, there is a possibility of a livelock: > - * - Refcount goes to zero, last reader wakes up the sleeping > - *   writer. > - * - Last reader unlocks the cpu_hotplug.lock. > - * - A new reader arrives at this moment, bumps up the refcount. > - * - The writer acquires the cpu_hotplug.lock finds the refcount > - *   non zero and goes to sleep again. > - * > - * However, this is very difficult to achieve in practice since > - * get_online_cpus() not an api which is called all that often. > - * > - */ >  void cpu_hotplug_begin(void) >  { > - DEFINE_WAIT(wait); > - > - cpu_hotplug.active_writer = current; > - cpuhp_lock_acquire(); > - > - for (;;) { > - mutex_lock(&cpu_hotplug.lock); > - prepare_to_wait(&cpu_hotplug.wq, &wait, TASK_UNINTERRUPTIBLE); > - if (likely(!atomic_read(&cpu_hotplug.refcount))) > - break; > - mutex_unlock(&cpu_hotplug.lock); > - schedule(); > - } > - finish_wait(&cpu_hotplug.wq, &wait); > + percpu_down_write(&hotplug); > + current->cpuhp_ref++; /* allow read-in-write recursion */ >  } >   >  void cpu_hotplug_done(void) >  { > - cpu_hotplug.active_writer = NULL; > - mutex_unlock(&cpu_hotplug.lock); > - cpuhp_lock_release(); > + current->cpuhp_ref--; > + percpu_up_write(&hotplug); >  } >   >  /* > --- a/kernel/fork.c > +++ b/kernel/fork.c > @@ -1414,6 +1414,8 @@ static struct task_struct *copy_process( >   p->sequential_io_avg = 0; >  #endif >   > + cpu_hotplug_init_task(p); > + >   /* Perform scheduler related setup. Assign this task to a CPU. */ >   retval = sched_fork(clone_flags, p); >   if (retval) > --- a/lib/Kconfig > +++ b/lib/Kconfig > @@ -53,6 +53,11 @@ config GENERIC_IO >  config STMP_DEVICE >   bool >   > +config PERCPU_RWSEM_HOTPLUG > + def_bool y > + depends on HOTPLUG_CPU > + select PERCPU_RWSEM > + >  config ARCH_USE_CMPXCHG_LOCKREF >   bool >   -- Joonas Lahtinen Open Source Technology Center Intel Corporation