From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tvrtko Ursulin Subject: Re: [PATCH] [v2] drm/i915/pmu: avoid -Wmaybe-uninitialized warning Date: Wed, 14 Mar 2018 07:43:11 +0000 Message-ID: <7821b457-0194-dcf5-aa3c-e6adbfc931fa@linux.intel.com> References: <20180313161952.552083-1-arnd@arndb.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: Content-Language: en-GB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Arnd Bergmann Cc: David Airlie , Intel Graphics , Linux Kernel Mailing List , dri-devel , Rodrigo Vivi List-Id: dri-devel@lists.freedesktop.org Ck9uIDEzLzAzLzIwMTggMjA6MTAsIEFybmQgQmVyZ21hbm4gd3JvdGU6Cj4gT24gVHVlLCBNYXIg MTMsIDIwMTggYXQgNjo0NiBQTSwgVHZydGtvIFVyc3VsaW4KPiA8dHZydGtvLnVyc3VsaW5AbGlu dXguaW50ZWwuY29tPiB3cm90ZToKPj4KPj4gT24gMTMvMDMvMjAxOCAxNjoxOSwgQXJuZCBCZXJn bWFubiB3cm90ZToKPj4+Cj4+PiBUaGUgY29uZGl0aW9uYWwgc3BpbmxvY2sgY29uZnVzZXMgZ2Nj IGludG8gdGhpbmtpbmcgdGhlICdmbGFncycgdmFsdWUKPj4+IG1pZ2h0IGNvbnRhaW4gdW5pbml0 aWFsaXplZCBkYXRhOgo+Pj4KPj4+IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcG11LmM6IElu IGZ1bmN0aW9uICdfX2k5MTVfcG11X2V2ZW50X3JlYWQnOgo+Pj4gYXJjaC94ODYvaW5jbHVkZS9h c20vcGFyYXZpcnRfdHlwZXMuaDo1NzM6MzogZXJyb3I6ICdmbGFncycgbWF5IGJlIHVzZWQKPj4+ IHVuaW5pdGlhbGl6ZWQgaW4gdGhpcyBmdW5jdGlvbiBbLVdlcnJvcj1tYXliZS11bmluaXRpYWxp emVkXQo+Pgo+Pgo+PiBIbSwgaG93IGRvZXMgcGFyYXZpcnRfdHlwZXMuaCBjb21lcyBpbnRvIHRo ZSBwaWN0dXJlPwo+IAo+IHNwaW5fdW5sb2NrX2lycXJlc3RvcmUoKSBjYWxscyBhcmNoX2xvY2Fs X2lycV9yZXN0b3JlKCkKPiAKPj4+IFRoZSBjb2RlIGlzIGNvcnJlY3QsIGJ1dCBpdCdzIGVhc3kg dG8gc2VlIGhvdyB0aGUgY29tcGlsZXIgZ2V0cyBjb25mdXNlZAo+Pj4gaGVyZS4gVGhpcyBhdm9p ZHMgdGhlIHByb2JsZW0gYnkgcHVsbGluZyB0aGUgbG9jayBvdXRzaWRlIG9mIHRoZSBmdW5jdGlv bgo+Pj4gaW50byBpdHMgb25seSBjYWxsZXIuCj4+Cj4+Cj4+IElzIGl0IHNwZWNpZmljIGdjYyB2 ZXJzaW9uLCBzcGVjaWZpYyBvcHRpb25zLCBvciBzcGVjaWZpYyBrZXJuZWwgY29uZmlnIHRoYXQK Pj4gdGhpcyBoYXBwZW5zPwo+IAo+IE5vdCBnY2MgdmVyc2lvbiBzcGVjaWZpYyAoc2FtZSByZXN1 bHQgd2l0aCBnY2MtNC45IHRocm91Z2ggOCwgZGlkbid0IHRlc3QKPiBlYXJsaWVyIHZlcnNpb25z IHRoYXQgYXJlIGN1cnJlbnRseSBicm9rZW4pLgo+IAo+PiBTdHJhbmdlIHRoYXQgaXQgaGFzbid0 IGJlZW4gc2VlbiBzbyBmYXIuCj4gCj4gSXQgc2VlbXMgdG8gYmUgYSByZWxhdGl2ZWx5IHJhcmUg J3JhbmRjb25maWcnIGNvbWJpbmF0aW9uLiBMb29raW5nIGF0Cj4gdGhlIHByZXByb2Nlc3NlZCBz b3VyY2VzLCBJIGZpbmQ6Cj4gCj4gc3RhdGljIHU2NCBnZXRfcmM2KHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICppOTE1LCBib29sIGxvY2tlZCkKPiB7Cj4gCj4gICB1bnNpZ25lZCBsb25nIGZsYWdz Owo+ICAgdTY0IHZhbDsKPiAKPiAgIGlmIChpbnRlbF9ydW50aW1lX3BtX2dldF9pZl9pbl91c2Uo aTkxNSkpIHsKPiAgICB2YWwgPSBfX2dldF9yYzYoaTkxNSk7Cj4gICAgaW50ZWxfcnVudGltZV9w bV9wdXQoaTkxNSk7Cj4gICAgaWYgKCFsb2NrZWQpCj4gICAgIGRvIHsgZG8geyAoeyB1bnNpZ25l ZCBsb25nIF9fZHVtbXk7IHR5cGVvZihmbGFncykgX19kdW1teTI7Cj4gKHZvaWQpKCZfX2R1bW15 ID09ICZfX2R1bW15Mik7IDE7IH0pOyBkbyB7IGRvIHsgZG8geyAoeyB1bnNpZ25lZCBsb25nCj4g X19kdW1teTsgdHlwZW9mKGZsYWdzKSBfX2R1bW15MjsgKHZvaWQpKCZfX2R1bW15ID09ICZfX2R1 bW15Mik7IDE7IH0pOwo+IGZsYWdzID0gYXJjaF9sb2NhbF9pcnFfc2F2ZSgpOyB9IHdoaWxlICgw KTsgdHJhY2VfaGFyZGlycXNfb2ZmKCk7IH0KPiB3aGlsZSAoMCk7IGRvIHsgX19hc21fXyBfX3Zv bGF0aWxlX18oIiI6IDogOiJtZW1vcnkiKTsgZG8geyAodm9pZCkwOwo+ICh2b2lkKShzcGlubG9j a19jaGVjaygmaTkxNS0+cG11LmxvY2spKTsgfSB3aGlsZSAoMCk7IH0gd2hpbGUgKDApOyB9Cj4g d2hpbGUgKDApOyB9IHdoaWxlICgwKTsgfSB3aGlsZSAoMCk7Cj4gCj4gICAgaWYgKHZhbCA+PSBp OTE1LT5wbXUuc2FtcGxlW19fSTkxNV9TQU1QTEVfUkM2X0VTVElNQVRFRF0uY3VyKSB7Cj4gICAg IGk5MTUtPnBtdS5zYW1wbGVbX19JOTE1X1NBTVBMRV9SQzZfRVNUSU1BVEVEXS5jdXIgPSAwOwo+ ICAgICBpOTE1LT5wbXUuc2FtcGxlW19fSTkxNV9TQU1QTEVfUkM2XS5jdXIgPSB2YWw7Cj4gICAg fSBlbHNlIHsKPiAgICAgdmFsID0gaTkxNS0+cG11LnNhbXBsZVtfX0k5MTVfU0FNUExFX1JDNl9F U1RJTUFURURdLmN1cjsKPiAgICB9Cj4gICAgaWYgKCFsb2NrZWQpCj4gICAgIHNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJmk5MTUtPnBtdS5sb2NrLCBmbGFncyk7Cj4gICB9IGVsc2Ugewo+ICAgIHN0 cnVjdCBwY2lfZGV2ICpwZGV2ID0gaTkxNS0+ZHJtLnBkZXY7Cj4gICAgc3RydWN0IGRldmljZSAq a2RldiA9ICZwZGV2LT5kZXY7Cj4gICAgdW5zaWduZWQgbG9uZyBmbGFnczI7Cj4gIyA0NTUgIi9n aXQvYXJtLXNvYy9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3BtdS5jIgo+ICAgIGlmICghbG9j a2VkKQo+ICAgICBkbyB7IGRvIHsgKHsgdW5zaWduZWQgbG9uZyBfX2R1bW15OyB0eXBlb2YoZmxh Z3MpIF9fZHVtbXkyOwo+ICh2b2lkKSgmX19kdW1teSA9PSAmX19kdW1teTIpOyAxOyB9KTsgZG8g eyBkbyB7IGRvIHsgKHsgdW5zaWduZWQgbG9uZwo+IF9fZHVtbXk7IHR5cGVvZihmbGFncykgX19k dW1teTI7ICh2b2lkKSgmX19kdW1teSA9PSAmX19kdW1teTIpOyAxOyB9KTsKPiBmbGFncyA9IGFy Y2hfbG9jYWxfaXJxX3NhdmUoKTsgfSB3aGlsZSAoMCk7IHRyYWNlX2hhcmRpcnFzX29mZigpOyB9 Cj4gd2hpbGUgKDApOyBkbyB7IF9fYXNtX18gX192b2xhdGlsZV9fKCIiOiA6IDoibWVtb3J5Iik7 IGRvIHsgKHZvaWQpMDsKPiAodm9pZCkoc3BpbmxvY2tfY2hlY2soJmk5MTUtPnBtdS5sb2NrKSk7 IH0gd2hpbGUgKDApOyB9IHdoaWxlICgwKTsgfQo+IHdoaWxlICgwKTsgfSB3aGlsZSAoMCk7IH0g d2hpbGUgKDApOwo+IAo+ICAgIGRvIHsgZG8geyAoeyB1bnNpZ25lZCBsb25nIF9fZHVtbXk7IHR5 cGVvZihmbGFnczIpIF9fZHVtbXkyOwo+ICh2b2lkKSgmX19kdW1teSA9PSAmX19kdW1teTIpOyAx OyB9KTsgZG8geyBkbyB7IGRvIHsgKHsgdW5zaWduZWQgbG9uZwo+IF9fZHVtbXk7IHR5cGVvZihm bGFnczIpIF9fZHVtbXkyOyAodm9pZCkoJl9fZHVtbXkgPT0gJl9fZHVtbXkyKTsgMTsKPiB9KTsg ZmxhZ3MyID0gYXJjaF9sb2NhbF9pcnFfc2F2ZSgpOyB9IHdoaWxlICgwKTsgdHJhY2VfaGFyZGly cXNfb2ZmKCk7Cj4gfSB3aGlsZSAoMCk7IGRvIHsgX19hc21fXyBfX3ZvbGF0aWxlX18oIiI6IDog OiJtZW1vcnkiKTsgZG8geyAodm9pZCkwOwo+ICh2b2lkKShzcGlubG9ja19jaGVjaygma2Rldi0+ cG93ZXIubG9jaykpOyB9IHdoaWxlICgwKTsgfSB3aGlsZSAoMCk7IH0KPiB3aGlsZSAoMCk7IH0g d2hpbGUgKDApOyB9IHdoaWxlICgwKTsKPiAKPiAgICBpZiAoIWk5MTUtPnBtdS5zYW1wbGVbX19J OTE1X1NBTVBMRV9SQzZfRVNUSU1BVEVEXS5jdXIpCj4gICAgIGk5MTUtPnBtdS5zdXNwZW5kZWRf amlmZmllc19sYXN0ID0KPiAgICAgICAga2Rldi0+cG93ZXIuc3VzcGVuZGVkX2ppZmZpZXM7Cj4g Cj4gICAgdmFsID0ga2Rldi0+cG93ZXIuc3VzcGVuZGVkX2ppZmZpZXMgLQo+ICAgICAgICAgIGk5 MTUtPnBtdS5zdXNwZW5kZWRfamlmZmllc19sYXN0Owo+ICAgIHZhbCArPSBqaWZmaWVzIC0ga2Rl di0+cG93ZXIuYWNjb3VudGluZ190aW1lc3RhbXA7Cj4gCj4gICAgc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgma2Rldi0+cG93ZXIubG9jaywgZmxhZ3MyKTsKPiAKPiAgICB2YWwgPSBqaWZmaWVzX3Rv X25zZWNzKHZhbCk7Cj4gICAgdmFsICs9IGk5MTUtPnBtdS5zYW1wbGVbX19JOTE1X1NBTVBMRV9S QzZdLmN1cjsKPiAgICBpOTE1LT5wbXUuc2FtcGxlW19fSTkxNV9TQU1QTEVfUkM2X0VTVElNQVRF RF0uY3VyID0gdmFsOwo+IAo+ICAgIGlmICghbG9ja2VkKQo+ICAgICBzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZpOTE1LT5wbXUubG9jaywgZmxhZ3MpOwo+ICAgfQo+ICAgIHJldHVybiB2YWw7Cj4g fQo+IAo+IHNvIGl0IHNlZW1zIHRoYXQgdGhlIHNwaW5fbG9ja19pcnFzYXZlKCkgaXMgY29tcGxl dGVseSBpbmxpbmVkIHRocm91Z2gKPiBhIG1hY3JvIHdoaWxlIHRoZSB1bmxvY2sgaXMgbm90LCBh bmQgdGhlIGxvY2sgY29udGFpbnMgYSBtZW1vcnkgYmFycmllcgo+IChhbW9uZyBvdGhlciB0aGlu Z3MpIHRoYXQgbWlnaHQgdGVsbCB0aGUgY29tcGlsZXIgdGhhdCB0aGUgc3RhdGUgb2YgdGhlCj4g J2xvY2tlZCcgZmxhZyBjb3VsZCBjaGFuZ2VkIHVuZGVybmVhdGggaXQuCgpIYSwgaW50ZXJlc3Rp bmcuIFNvIGl0IHNvdW5kcyBtb3JlIGxpa2UgdXMgaGF2aW5nIHRvIHdvcmthcm91bmQgYSBidWcg aW4gCnRoZSBwYXJhdmlydCBzcGlubG9jayBtYWNyb3MuCgpJIHRoaW5rIEkgd291bGQgcHJlZmVy IGEgZGlmZmVyZW50IHNvbHV0aW9uLCB3aGVyZSB3ZSBkb24ndCBlbmQgdXAgZG9pbmcgCk1NSU8g dW5kZXIgaXJxc2F2ZSBzcGlubG9jay4gSSdsbCBzZW5kIGEgcGF0Y2guCgpSZWdhcmRzLAoKVHZy dGtvCgo+IAo+IEl0IGNvdWxkIGFsc28gYmUgdGhlIHByb2JsZW0gdGhhdCBhcmNoX2xvY2FsX2ly cV9yZXN0b3JlKCkgdXNlcwo+IF9fYnVpbHRpbl9leHBlY3QoKSBpbiAgUFZPUF9URVNUX05VTEwo b3ApIHdoZW4KPiBDT05GSUdfUEFSQVZJUlRfREVCVUcgaXMgZW5hYmxlZCwgc2VlCj4gCj4gc3Rh dGljIGlubGluZSBfX2F0dHJpYnV0ZV9fKCh1bnVzZWQpKQo+IF9fYXR0cmlidXRlX18oKG5vX2lu c3RydW1lbnRfZnVuY3Rpb24pKQo+IF9fYXR0cmlidXRlX18oKG5vX2luc3RydW1lbnRfZnVuY3Rp b24pKSB2b2lkCj4gYXJjaF9sb2NhbF9pcnFfcmVzdG9yZSh1bnNpZ25lZCBsb25nIGYpCj4gewo+ ICAgKHsgdW5zaWduZWQgbG9uZyBfX2VheCA9IF9fZWF4LCBfX2VkeCA9IF9fZWR4LCBfX2VjeCA9 IF9fZWN4OzsgZG8gewo+IGlmIChfX2J1aWx0aW5fZXhwZWN0KCEhKHB2X2lycV9vcHMucmVzdG9y ZV9mbC5mdW5jID09ICgodm9pZCAqKTApKSwKPiAwKSkgZG8geyBkbyB7IGFzbSB2b2xhdGlsZSgi MTpcdCIgIi5ieXRlIDB4MGYsIDB4MGIiICJcbiIKPiAiLnB1c2hzZWN0aW9uIF9fYnVnX3RhYmxl LFwiYXdcIlxuIiAiMjpcdCIgIi5sb25nICIgIjFiIiAiXHQjCj4gYnVnX2VudHJ5OjpidWdfYWRk clxuIiAiXHQiICIubG9uZyAiICIlYzAiICJcdCMgYnVnX2VudHJ5OjpmaWxlXG4iCj4gIlx0Lndv cmQgJWMxIiAiXHQjIGJ1Z19lbnRyeTo6bGluZVxuIiAiXHQud29yZCAlYzIiICJcdCMKPiBidWdf ZW50cnk6OmZsYWdzXG4iICJcdC5vcmcgMmIrJWMzXG4iICIucG9wc2VjdGlvbiIgOiA6ICJpIgo+ ICgiL2dpdC9hcm0tc29jL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0LmgiKSwgImkiICg3 ODMpLCAiaSIgKDApLAo+ICJpIiAoc2l6ZW9mKHN0cnVjdCBidWdfZW50cnkpKSk7IH0gd2hpbGUg KDApOyBkbyB7IDsgYXNtIHZvbGF0aWxlKCIiKTsKPiBfX2J1aWx0aW5fdW5yZWFjaGFibGUoKTsg fSB3aGlsZSAoMCk7IH0gd2hpbGUgKDApOyB9IHdoaWxlICgwKTsgYXNtCj4gdm9sYXRpbGUoIiIg Ijc3MTpcblx0IiAiOTk5OlxuXHQiICIucHVzaHNlY3Rpb24KPiAuZGlzY2FyZC5yZXRwb2xpbmVf c2FmZVxuXHQiICIgIiAiLmxvbmciICIgIiAiIDk5OWJcblx0Igo+ICIucG9wc2VjdGlvblxuXHQi ICJjYWxsIColY1twYXJhdmlydF9vcHB0cl07IiAiXG4iICI3NzI6XG4iCj4gIi5wdXNoc2VjdGlv biAucGFyYWluc3RydWN0aW9ucyxcImFcIlxuIiAiICIgIi5iYWxpZ24gNCIgIiAiICJcbiIgIiIK PiAiLmxvbmciICIgIiAiIDc3MWJcbiIgIiAgLmJ5dGUgIiAiJWNbcGFyYXZpcnRfdHlwZW51bV0i ICJcbiIgIiAgLmJ5dGUKPiA3NzJiLTc3MWJcbiIgIiAgLnNob3J0ICIgIiVjW3BhcmF2aXJ0X2Ns b2JiZXJdIiAiXG4iICIucG9wc2VjdGlvblxuIgo+ICIiIDogIj1hIiAoX19lYXgpLCAiPWQiIChf X2VkeCksICIrciIgKGN1cnJlbnRfc3RhY2tfcG9pbnRlcikgOgo+IFtwYXJhdmlydF90eXBlbnVt XSAiaSIgKChfX2J1aWx0aW5fb2Zmc2V0b2Yoc3RydWN0Cj4gcGFyYXZpcnRfcGF0Y2hfdGVtcGxh dGUsIHB2X2lycV9vcHMucmVzdG9yZV9mbC5mdW5jKSAvIHNpemVvZih2b2lkCj4gKikpKSwgW3Bh cmF2aXJ0X29wcHRyXSAiaSIgKCYocHZfaXJxX29wcy5yZXN0b3JlX2ZsLmZ1bmMpKSwKPiBbcGFy YXZpcnRfY2xvYmJlcl0gImkiICgoKDEgPDwgMCkgfCAoMSA8PCAyKSkpLCAiYSIgKCh1bnNpZ25l ZAo+IGxvbmcpKGYpKSA6ICJtZW1vcnkiLCAiY2MiICk7IH0pOwo+IH0KPiAKPiB0aGlzIHNlZW1z IHRvIGZyZXF1ZW50bHkgY29uZnVzZSBnY2MsIGFuZCB0dXJuaW5nIG9mZiB0aGF0IE5VTEwgY2hl Y2sKPiBhdm9pZHMgdGhlIHdhcm5pbmcgYXMgd2VsbC4KPiAKPiBJZiB5b3Ugd2FudCB0byBhbmFs eXplIGl0IGZ1cnRoZXIsIHNlZSBodHRwczovL3Bhc3RlYmluLmNvbS9UMnlMUnFVNQo+IGZvciB0 aGUgLmNvbmZpZyBmaWxlLCBidXQgSSdtIHByZXR0eSBzdXJlIHRoaXMgaXMgYSBrbm93biBwcm9i bGVtIHdpdGggZ2NjCj4gdGhhdCBoYXBwZW5zIHRvIGJlIHZlcnkgaGFyZCB0byBmaXguCj4gCj4g ICAgICAgICBBcm5kCj4gCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVs LWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753449AbeCNHnQ (ORCPT ); Wed, 14 Mar 2018 03:43:16 -0400 Received: from mga04.intel.com ([192.55.52.120]:60460 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750934AbeCNHnP (ORCPT ); Wed, 14 Mar 2018 03:43:15 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.47,469,1515484800"; d="scan'208";a="41869073" Subject: Re: [Intel-gfx] [PATCH] [v2] drm/i915/pmu: avoid -Wmaybe-uninitialized warning To: Arnd Bergmann Cc: Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , David Airlie , Intel Graphics , Linux Kernel Mailing List , dri-devel References: <20180313161952.552083-1-arnd@arndb.de> From: Tvrtko Ursulin Message-ID: <7821b457-0194-dcf5-aa3c-e6adbfc931fa@linux.intel.com> Date: Wed, 14 Mar 2018 07:43:11 +0000 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Thunderbird/52.6.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-GB Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 13/03/2018 20:10, Arnd Bergmann wrote: > On Tue, Mar 13, 2018 at 6:46 PM, Tvrtko Ursulin > wrote: >> >> On 13/03/2018 16:19, Arnd Bergmann wrote: >>> >>> The conditional spinlock confuses gcc into thinking the 'flags' value >>> might contain uninitialized data: >>> >>> drivers/gpu/drm/i915/i915_pmu.c: In function '__i915_pmu_event_read': >>> arch/x86/include/asm/paravirt_types.h:573:3: error: 'flags' may be used >>> uninitialized in this function [-Werror=maybe-uninitialized] >> >> >> Hm, how does paravirt_types.h comes into the picture? > > spin_unlock_irqrestore() calls arch_local_irq_restore() > >>> The code is correct, but it's easy to see how the compiler gets confused >>> here. This avoids the problem by pulling the lock outside of the function >>> into its only caller. >> >> >> Is it specific gcc version, specific options, or specific kernel config that >> this happens? > > Not gcc version specific (same result with gcc-4.9 through 8, didn't test > earlier versions that are currently broken). > >> Strange that it hasn't been seen so far. > > It seems to be a relatively rare 'randconfig' combination. Looking at > the preprocessed sources, I find: > > static u64 get_rc6(struct drm_i915_private *i915, bool locked) > { > > unsigned long flags; > u64 val; > > if (intel_runtime_pm_get_if_in_use(i915)) { > val = __get_rc6(i915); > intel_runtime_pm_put(i915); > if (!locked) > do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; > (void)(&__dummy == &__dummy2); 1; }); do { do { do { ({ unsigned long > __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); > flags = arch_local_irq_save(); } while (0); trace_hardirqs_off(); } > while (0); do { __asm__ __volatile__("": : :"memory"); do { (void)0; > (void)(spinlock_check(&i915->pmu.lock)); } while (0); } while (0); } > while (0); } while (0); } while (0); > > if (val >= i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur) { > i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur = 0; > i915->pmu.sample[__I915_SAMPLE_RC6].cur = val; > } else { > val = i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur; > } > if (!locked) > spin_unlock_irqrestore(&i915->pmu.lock, flags); > } else { > struct pci_dev *pdev = i915->drm.pdev; > struct device *kdev = &pdev->dev; > unsigned long flags2; > # 455 "/git/arm-soc/drivers/gpu/drm/i915/i915_pmu.c" > if (!locked) > do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; > (void)(&__dummy == &__dummy2); 1; }); do { do { do { ({ unsigned long > __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); > flags = arch_local_irq_save(); } while (0); trace_hardirqs_off(); } > while (0); do { __asm__ __volatile__("": : :"memory"); do { (void)0; > (void)(spinlock_check(&i915->pmu.lock)); } while (0); } while (0); } > while (0); } while (0); } while (0); > > do { do { ({ unsigned long __dummy; typeof(flags2) __dummy2; > (void)(&__dummy == &__dummy2); 1; }); do { do { do { ({ unsigned long > __dummy; typeof(flags2) __dummy2; (void)(&__dummy == &__dummy2); 1; > }); flags2 = arch_local_irq_save(); } while (0); trace_hardirqs_off(); > } while (0); do { __asm__ __volatile__("": : :"memory"); do { (void)0; > (void)(spinlock_check(&kdev->power.lock)); } while (0); } while (0); } > while (0); } while (0); } while (0); > > if (!i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur) > i915->pmu.suspended_jiffies_last = > kdev->power.suspended_jiffies; > > val = kdev->power.suspended_jiffies - > i915->pmu.suspended_jiffies_last; > val += jiffies - kdev->power.accounting_timestamp; > > spin_unlock_irqrestore(&kdev->power.lock, flags2); > > val = jiffies_to_nsecs(val); > val += i915->pmu.sample[__I915_SAMPLE_RC6].cur; > i915->pmu.sample[__I915_SAMPLE_RC6_ESTIMATED].cur = val; > > if (!locked) > spin_unlock_irqrestore(&i915->pmu.lock, flags); > } > return val; > } > > so it seems that the spin_lock_irqsave() is completely inlined through > a macro while the unlock is not, and the lock contains a memory barrier > (among other things) that might tell the compiler that the state of the > 'locked' flag could changed underneath it. Ha, interesting. So it sounds more like us having to workaround a bug in the paravirt spinlock macros. I think I would prefer a different solution, where we don't end up doing MMIO under irqsave spinlock. I'll send a patch. Regards, Tvrtko > > It could also be the problem that arch_local_irq_restore() uses > __builtin_expect() in PVOP_TEST_NULL(op) when > CONFIG_PARAVIRT_DEBUG is enabled, see > > static inline __attribute__((unused)) > __attribute__((no_instrument_function)) > __attribute__((no_instrument_function)) void > arch_local_irq_restore(unsigned long f) > { > ({ unsigned long __eax = __eax, __edx = __edx, __ecx = __ecx;; do { > if (__builtin_expect(!!(pv_irq_ops.restore_fl.func == ((void *)0)), > 0)) do { do { asm volatile("1:\t" ".byte 0x0f, 0x0b" "\n" > ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" "\t# > bug_entry::bug_addr\n" "\t" ".long " "%c0" "\t# bug_entry::file\n" > "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# > bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" > ("/git/arm-soc/arch/x86/include/asm/paravirt.h"), "i" (783), "i" (0), > "i" (sizeof(struct bug_entry))); } while (0); do { ; asm volatile(""); > __builtin_unreachable(); } while (0); } while (0); } while (0); asm > volatile("" "771:\n\t" "999:\n\t" ".pushsection > .discard.retpoline_safe\n\t" " " ".long" " " " 999b\n\t" > ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" > ".pushsection .parainstructions,\"a\"\n" " " ".balign 4" " " "\n" "" > ".long" " " " 771b\n" " .byte " "%c[paravirt_typenum]" "\n" " .byte > 772b-771b\n" " .short " "%c[paravirt_clobber]" "\n" ".popsection\n" > "" : "=a" (__eax), "=d" (__edx), "+r" (current_stack_pointer) : > [paravirt_typenum] "i" ((__builtin_offsetof(struct > paravirt_patch_template, pv_irq_ops.restore_fl.func) / sizeof(void > *))), [paravirt_opptr] "i" (&(pv_irq_ops.restore_fl.func)), > [paravirt_clobber] "i" (((1 << 0) | (1 << 2))), "a" ((unsigned > long)(f)) : "memory", "cc" ); }); > } > > this seems to frequently confuse gcc, and turning off that NULL check > avoids the warning as well. > > If you want to analyze it further, see https://pastebin.com/T2yLRqU5 > for the .config file, but I'm pretty sure this is a known problem with gcc > that happens to be very hard to fix. > > Arnd >