From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Shi, Alex" Subject: RE: [patch 012/100] acpi: fix of pmtimer overflow that make Cx states time incorrect Date: Thu, 23 Apr 2009 17:24:48 +0800 Message-ID: References: <20090423072020.428683652@sous-sol.org> <20090423072212.535803819@sous-sol.org> Mime-Version: 1.0 Content-Type: text/plain; charset="gb2312" Content-Transfer-Encoding: base64 Return-path: Received: from mga09.intel.com ([134.134.136.24]:20398 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751812AbZDWJZJ (ORCPT ); Thu, 23 Apr 2009 05:25:09 -0400 In-Reply-To: <20090423072212.535803819@sous-sol.org> Content-Language: en-US Sender: linux-acpi-owner@vger.kernel.org List-Id: linux-acpi@vger.kernel.org To: Chris Wright , "linux-kernel@vger.kernel.org" , "stable@kernel.org" Cc: Justin Forbes , Zwane Mwaikambo , Theodore Ts'o , Randy Dunlap , Dave Jones , Chuck Wolber , Chris Wedgwood , Michael Krufky , Chuck Ebbert , Domenico Andreoli , Willy Tarreau , Rodrigo Rubira Branco , Jake Edge , Eugene Teo , "torvalds@linux-foundation.org" , "akpm@linux-foundation.org" , "alan@lxorguk.ukuu.org.uk" , Len Brown , "linux-acpi@vger.kernel.org" , "Pallipadi, Venkatesh" , "Zhao, Yakui" SXQgd2FzIHJlcG9ydGVkIG1ha2Ugc29tZSBsYXRvcCBib290aW5nIGhhbmcuIGFuZCBpcyBub3Qg cm9vdCBjYXVzZWQgbm93LiA6KA0KaHR0cDovL2J1Z3ppbGxhLmtlcm5lbC5vcmcvc2hvd19idWcu Y2dpP2lkPTEzMDg3IA0KDQpBbGV4IA0KPi0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+RnJv bTogQ2hyaXMgV3JpZ2h0IFttYWlsdG86Y2hyaXN3QHNvdXMtc29sLm9yZ10NCj5TZW50OiAyMDA5 xOo01MIyM8jVIDE1OjIxDQo+VG86IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmc7IHN0YWJs ZUBrZXJuZWwub3JnDQo+Q2M6IEp1c3RpbiBGb3JiZXM7IFp3YW5lIE13YWlrYW1ibzsgVGhlb2Rv cmUgVHMnbzsgUmFuZHkgRHVubGFwOyBEYXZlIEpvbmVzOw0KPkNodWNrIFdvbGJlcjsgQ2hyaXMg V2VkZ3dvb2Q7IE1pY2hhZWwgS3J1Zmt5OyBDaHVjayBFYmJlcnQ7IERvbWVuaWNvIEFuZHJlb2xp Ow0KPldpbGx5IFRhcnJlYXU7IFJvZHJpZ28gUnViaXJhIEJyYW5jbzsgSmFrZSBFZGdlOyBFdWdl bmUgVGVvOw0KPnRvcnZhbGRzQGxpbnV4LWZvdW5kYXRpb24ub3JnOyBha3BtQGxpbnV4LWZvdW5k YXRpb24ub3JnOw0KPmFsYW5AbHhvcmd1ay51a3V1Lm9yZy51azsgTGVuIEJyb3duOyBsaW51eC1h Y3BpQHZnZXIua2VybmVsLm9yZzsgU2hpLCBBbGV4Ow0KPlBhbGxpcGFkaSwgVmVua2F0ZXNoOyBa aGFvLCBZYWt1aTsgQnJvd24sIExlbg0KPlN1YmplY3Q6IFtwYXRjaCAwMTIvMTAwXSBhY3BpOiBm aXggb2YgcG10aW1lciBvdmVyZmxvdyB0aGF0IG1ha2UgQ3ggc3RhdGVzIHRpbWUNCj5pbmNvcnJl Y3QNCj4NCj4tc3RhYmxlIHJldmlldyBwYXRjaC4gIElmIGFueW9uZSBoYXMgYW55IG9iamVjdGlv bnMsIHBsZWFzZSBsZXQgdXMga25vdy4NCj4tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCj4NCj5Gcm9t OiBhbGV4LnNoaSA8YWxleC5zaGlAaW50ZWwuY29tPg0KPg0KPnVwc3RyZWFtIGNvbW1pdDogZmY2 OWYyYmJhNjdiZDQ1NTE0OTIzYWFlZGJmNDBmZTM1MTc4N2M1OQ0KPg0KPldlIGZvdW5kIEN4IHN0 YXRlcyB0aW1lIGFibm9ybWFsIGluIG91ciBzb21lIG9mIG1hY2hpbmVzIHdoaWNoIGhhdmUgMTYN Cj5MQ1BVcywgdGhlIEMwIHRha2UgdG9vIG1hbnkgdGltZSB3aGlsZSBzeXN0ZW0gaXMgcmVhbGx5 IGlkbGUgd2hlbiBrZXJuZWwNCj5lbmFibGVkIHRpY2tsZXNzIGFuZCBoaWdocmVzLiAgcG93ZXJ0 b3Agb3V0cHV0IGlzIGJlbG93Og0KPg0KPiAgICAgUG93ZXJUT1AgdmVyc2lvbiAxLjkgICAgICAg KEMpIDIwMDcgSW50ZWwgQ29ycG9yYXRpb24NCj4NCj5DbiAgICAgICAgICAgICAgICBBdmcgcmVz aWRlbmN5ICAgICAgIFAtc3RhdGVzIChmcmVxdWVuY2llcykNCj5DMCAoY3B1IHJ1bm5pbmcpICAg ICAgICAoNDAuNSUpICAgICAgICAgMi41MyBHaHogICAgIDAuMCUNCj5DMSAgICAgICAgICAgICAg ICAwLjBtcyAoIDAuMCUpICAgICAgICAgMi41MyBHaHogICAgIDAuMCUNCj5DMiAgICAgICAgICAg ICAgMTI4LjhtcyAoNTkuNSUpICAgICAgICAgMi40MCBHaHogICAgIDAuMCUNCj4gICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMS42MCBHaHogICAxMDAuMCUNCj4NCj5XYWtl dXBzLWZyb20taWRsZSBwZXIgc2Vjb25kIDogIDQuNyAgICAgaW50ZXJ2YWw6IDIwLjBzDQo+bm8g QUNQSSBwb3dlciB1c2FnZSBlc3RpbWF0ZSBhdmFpbGFibGUNCj4NCj5Ub3AgY2F1c2VzIGZvciB3 YWtldXBzOg0KPiAgNDEuNCUgKCAyNC45KSAgICAgICA8aW50ZXJydXB0PiA6IGV4dHJhIHRpbWVy IGludGVycnVwdA0KPiAgMjAuMiUgKCAxMi4yKSAgICAgPGtlcm5lbCBjb3JlPiA6IHVzYl9oY2Rf cG9sbF9yaF9zdGF0dXMNCj4ocmhfdGltZXJfZnVuYykNCj4NCj5BZnRlciB0YWNraW5nIGRldGFp bGVkIGZvciB0aGlzIGlzc3VlLCBZYWt1aSBhbmQgSSBmaW5kIGl0IGlzIGR1ZSB0byAyNA0KPmJp dCBQTSB0aW1lciBvdmVyZmxvd3Mgd2hlbiBzb21lIG9mIGNwdSBzbGVlcCBtb3JlIHRoYW4gNCBz ZWNvbmRzLiAgV2l0aA0KPnRpY2tsZXNzIGtlcm5lbCwgdGhlIENQVSB3YW50IHRvIHNsZWVwIGFz IG11Y2ggYXMgcG9zc2libGUgd2hlbiBzeXN0ZW0NCj5pZGxlLiAgQnV0IHRoZSBDeCBzbGVlcCB0 aW1lIGFyZSByZWNvcmRlZCBieSBwbXRpbWVyIHdoaWNoIGxlbmd0aCBpcw0KPmRldGVybWluZWQg YnkgQklPUy4gIFRoZSBjdXJyZW50IEN4IHRpbWUgd2FzIGdvdHRlbiBpbiB0aGUgZm9sbG93aW5n DQo+ZnVuY3Rpb24gZnJvbSBkcml2ZXIvYWNwaS9wcm9jZXNzb3JfaWRsZS5jOg0KPg0KPnN0YXRp YyBpbmxpbmUgdTMyIHRpY2tzX2VsYXBzZWQodTMyIHQxLCB1MzIgdDIpDQo+ew0KPiAgICAgICBp ZiAodDIgPj0gdDEpDQo+ICAgICAgICAgICAgICAgcmV0dXJuICh0MiAtIHQxKTsNCj4gICAgICAg ZWxzZSBpZiAoIShhY3BpX2dibF9GQURULmZsYWdzICYgQUNQSV9GQURUXzMyQklUX1RJTUVSKSkN Cj4gICAgICAgICAgICAgICByZXR1cm4gKCgoMHgwMEZGRkZGRiAtIHQxKSArIHQyKSAmIDB4MDBG RkZGRkYpOw0KPiAgICAgICBlbHNlDQo+ICAgICAgICAgICAgICAgcmV0dXJuICgoMHhGRkZGRkZG RiAtIHQxKSArIHQyKTsNCj59DQo+DQo+SWYgcG10aW1lciBpcyAyNCBiaXRzIGFuZCBpdCB0YWtl IDUgc2Vjb25kcyBmcm9tIHQxIHRvIHQyLCBpbiBhYm92ZQ0KPmZ1bmN0aW9uLCBqdXN0IGFib3V0 IDEgc2Vjb25kcyB0aWNrcyB3YXMgcmVjb3JkZWQuICBTbyB0aGUgQ3ggdGltZSB3aWxsIGJlDQo+ cmVkdWNlZCBhYm91dCA0IHNlY29uZHMuICBhbmQgdGhpcyBpcyB3aHkgd2Ugc2VlIGFib3ZlIHBv d2VydG9wIG91dHB1dC4NCj4NCj5UbyByZXNvbHZlIHRoaXMgcHJvYmxlbSwgWWFrdWkgYW5kIEkg dXNlIGt0aW1lX2dldCgpIHRvIHJlY29yZCB0aGUgQ3gNCj5zdGF0ZXMgdGltZSBpbnN0ZWFkIG9m IFBNIHRpbWVyIGFzIHRoZSBmb2xsb3dpbmcgcGF0Y2guICB0aGUgcGF0Y2ggd2FzDQo+dGVzdGVk IHdpdGggaTM4Ni94ODZfNjQgbW9kZXMgb24gc2V2ZXJhbCBwbGF0Zm9ybXMuDQo+DQo+QWNrZWQt Ynk6IFZlbmthdGVzaCBQYWxsaXBhZGkgPHZlbmthdGVzaC5wYWxsaXBhZGlAaW50ZWwuY29tPg0K PlRlc3RlZC1ieTogQWxleCBTaGkgPGFsZXguc2hpQGludGVsLmNvbT4NCj5TaWduZWQtb2ZmLWJ5 OiBBbGV4IFNoaSA8YWxleC5zaGlAaW50ZWwuY29tPg0KPlNpZ25lZC1vZmYtYnk6IFlha3VpLnpo YW8gPHlha3VpLnpoYW9AaW50ZWwuY29tPg0KPlNpZ25lZC1vZmYtYnk6IEFuZHJldyBNb3J0b24g PGFrcG1AbGludXgtZm91bmRhdGlvbi5vcmc+DQo+U2lnbmVkLW9mZi1ieTogTGVuIEJyb3duIDxs ZW4uYnJvd25AaW50ZWwuY29tPg0KPlNpZ25lZC1vZmYtYnk6IENocmlzIFdyaWdodCA8Y2hyaXN3 QHNvdXMtc29sLm9yZz4NCj4tLS0NCj4gZHJpdmVycy9hY3BpL3Byb2Nlc3Nvcl9pZGxlLmMgfCAg IDYzDQo+KysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQo+IDEgZmls ZSBjaGFuZ2VkLCAyNyBpbnNlcnRpb25zKCspLCAzNiBkZWxldGlvbnMoLSkNCj4NCj4tLS0gYS9k cml2ZXJzL2FjcGkvcHJvY2Vzc29yX2lkbGUuYw0KPisrKyBiL2RyaXZlcnMvYWNwaS9wcm9jZXNz b3JfaWRsZS5jDQo+QEAgLTY0LDcgKzY0LDYgQEANCj4gI2RlZmluZSBfQ09NUE9ORU5UICAgICAg ICAgICAgICBBQ1BJX1BST0NFU1NPUl9DT01QT05FTlQNCj4gQUNQSV9NT0RVTEVfTkFNRSgicHJv Y2Vzc29yX2lkbGUiKTsNCj4gI2RlZmluZSBBQ1BJX1BST0NFU1NPUl9GSUxFX1BPV0VSCSJwb3dl ciINCj4tI2RlZmluZSBVU19UT19QTV9USU1FUl9USUNLUyh0KQkJKCh0ICogKFBNX1RJTUVSX0ZS RVFVRU5DWS8xMDAwKSkgLw0KPjEwMDApDQo+ICNkZWZpbmUgUE1fVElNRVJfVElDS19OUwkJKDEw MDAwMDAwMDBVTEwvUE1fVElNRVJfRlJFUVVFTkNZKQ0KPiAjZGVmaW5lIEMyX09WRVJIRUFECQkJ MQkvKiAxdXMgKi8NCj4gI2RlZmluZSBDM19PVkVSSEVBRAkJCTEJLyogMXVzICovDQo+QEAgLTc4 LDYgKzc3LDEwIEBAIG1vZHVsZV9wYXJhbShub2NzdCwgdWludCwgMDAwMCk7DQo+IHN0YXRpYyB1 bnNpZ25lZCBpbnQgbGF0ZW5jeV9mYWN0b3IgX19yZWFkX21vc3RseSA9IDI7DQo+IG1vZHVsZV9w YXJhbShsYXRlbmN5X2ZhY3RvciwgdWludCwgMDY0NCk7DQo+DQo+K3N0YXRpYyBzNjQgdXNfdG9f cG1fdGltZXJfdGlja3MoczY0IHQpDQo+K3sNCj4rCXJldHVybiBkaXY2NF91NjQodCAqIFBNX1RJ TUVSX0ZSRVFVRU5DWSwgMTAwMDAwMCk7DQo+K30NCj4gLyoNCj4gICogSUJNIFRoaW5rUGFkIFI0 MGUgY3Jhc2hlcyBteXN0ZXJpb3VzbHkgd2hlbiBnb2luZyBpbnRvIEMyIG9yIEMzLg0KPiAgKiBG b3Igbm93IGRpc2FibGUgdGhpcy4gUHJvYmFibHkgYSBidWcgc29tZXdoZXJlIGVsc2UuDQo+QEAg LTE1OSwyNSArMTYyLDYgQEAgc3RhdGljIHN0cnVjdCBkbWlfc3lzdGVtX2lkIF9fY3B1aW5pdGRh dA0KPiAJe30sDQo+IH07DQo+DQo+LXN0YXRpYyBpbmxpbmUgdTMyIHRpY2tzX2VsYXBzZWQodTMy IHQxLCB1MzIgdDIpDQo+LXsNCj4tCWlmICh0MiA+PSB0MSkNCj4tCQlyZXR1cm4gKHQyIC0gdDEp Ow0KPi0JZWxzZSBpZiAoIShhY3BpX2dibF9GQURULmZsYWdzICYgQUNQSV9GQURUXzMyQklUX1RJ TUVSKSkNCj4tCQlyZXR1cm4gKCgoMHgwMEZGRkZGRiAtIHQxKSArIHQyKSAmIDB4MDBGRkZGRkYp Ow0KPi0JZWxzZQ0KPi0JCXJldHVybiAoKDB4RkZGRkZGRkYgLSB0MSkgKyB0Mik7DQo+LX0NCj4t DQo+LXN0YXRpYyBpbmxpbmUgdTMyIHRpY2tzX2VsYXBzZWRfaW5fdXModTMyIHQxLCB1MzIgdDIp DQo+LXsNCj4tCWlmICh0MiA+PSB0MSkNCj4tCQlyZXR1cm4gUE1fVElNRVJfVElDS1NfVE9fVVMo dDIgLSB0MSk7DQo+LQllbHNlIGlmICghKGFjcGlfZ2JsX0ZBRFQuZmxhZ3MgJiBBQ1BJX0ZBRFRf MzJCSVRfVElNRVIpKQ0KPi0JCXJldHVybiBQTV9USU1FUl9USUNLU19UT19VUygoKDB4MDBGRkZG RkYgLSB0MSkgKyB0MikgJiAweDAwRkZGRkZGKTsNCj4tCWVsc2UNCj4tCQlyZXR1cm4gUE1fVElN RVJfVElDS1NfVE9fVVMoKDB4RkZGRkZGRkYgLSB0MSkgKyB0Mik7DQo+LX0NCj4NCj4gLyoNCj4g ICogQ2FsbGVycyBzaG91bGQgZGlzYWJsZSBpbnRlcnJ1cHRzIGJlZm9yZSB0aGUgY2FsbCBhbmQg ZW5hYmxlDQo+QEAgLTg1Myw3ICs4MzcsOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgYWNwaV9pZGxl X2RvX2VudHJ5KHN0DQo+IHN0YXRpYyBpbnQgYWNwaV9pZGxlX2VudGVyX2MxKHN0cnVjdCBjcHVp ZGxlX2RldmljZSAqZGV2LA0KPiAJCQkgICAgICBzdHJ1Y3QgY3B1aWRsZV9zdGF0ZSAqc3RhdGUp DQo+IHsNCj4tCXUzMiB0MSwgdDI7DQo+KwlrdGltZV90ICBrdDEsIGt0MjsNCj4rCXM2NCBpZGxl X3RpbWU7DQo+IAlzdHJ1Y3QgYWNwaV9wcm9jZXNzb3IgKnByOw0KPiAJc3RydWN0IGFjcGlfcHJv Y2Vzc29yX2N4ICpjeCA9IGNwdWlkbGVfZ2V0X3N0YXRlZGF0YShzdGF0ZSk7DQo+DQo+QEAgLTg3 MSwxNCArODU2LDE1IEBAIHN0YXRpYyBpbnQgYWNwaV9pZGxlX2VudGVyX2MxKHN0cnVjdCBjcHUN Cj4gCQlyZXR1cm4gMDsNCj4gCX0NCj4NCj4tCXQxID0gaW5sKGFjcGlfZ2JsX0ZBRFQueHBtX3Rp bWVyX2Jsb2NrLmFkZHJlc3MpOw0KPisJa3QxID0ga3RpbWVfZ2V0X3JlYWwoKTsNCj4gCWFjcGlf aWRsZV9kb19lbnRyeShjeCk7DQo+LQl0MiA9IGlubChhY3BpX2dibF9GQURULnhwbV90aW1lcl9i bG9jay5hZGRyZXNzKTsNCj4rCWt0MiA9IGt0aW1lX2dldF9yZWFsKCk7DQo+KwlpZGxlX3RpbWUg PSAga3RpbWVfdG9fdXMoa3RpbWVfc3ViKGt0Miwga3QxKSk7DQo+DQo+IAlsb2NhbF9pcnFfZW5h YmxlKCk7DQo+IAljeC0+dXNhZ2UrKzsNCj4NCj4tCXJldHVybiB0aWNrc19lbGFwc2VkX2luX3Vz KHQxLCB0Mik7DQo+KwlyZXR1cm4gaWRsZV90aW1lOw0KPiB9DQo+DQo+IC8qKg0KPkBAIC04OTEs OCArODc3LDkgQEAgc3RhdGljIGludCBhY3BpX2lkbGVfZW50ZXJfc2ltcGxlKHN0cnVjdA0KPiB7 DQo+IAlzdHJ1Y3QgYWNwaV9wcm9jZXNzb3IgKnByOw0KPiAJc3RydWN0IGFjcGlfcHJvY2Vzc29y X2N4ICpjeCA9IGNwdWlkbGVfZ2V0X3N0YXRlZGF0YShzdGF0ZSk7DQo+LQl1MzIgdDEsIHQyOw0K Pi0JaW50IHNsZWVwX3RpY2tzID0gMDsNCj4rCWt0aW1lX3QgIGt0MSwga3QyOw0KPisJczY0IGlk bGVfdGltZTsNCj4rCXM2NCBzbGVlcF90aWNrcyA9IDA7DQo+DQo+IAlwciA9IF9fZ2V0X2NwdV92 YXIocHJvY2Vzc29ycyk7DQo+DQo+QEAgLTkyNSwxOCArOTEyLDE5IEBAIHN0YXRpYyBpbnQgYWNw aV9pZGxlX2VudGVyX3NpbXBsZShzdHJ1Y3QNCj4gCWlmIChjeC0+dHlwZSA9PSBBQ1BJX1NUQVRF X0MzKQ0KPiAJCUFDUElfRkxVU0hfQ1BVX0NBQ0hFKCk7DQo+DQo+LQl0MSA9IGlubChhY3BpX2di bF9GQURULnhwbV90aW1lcl9ibG9jay5hZGRyZXNzKTsNCj4rCWt0MSA9IGt0aW1lX2dldF9yZWFs KCk7DQo+IAkvKiBUZWxsIHRoZSBzY2hlZHVsZXIgdGhhdCB3ZSBhcmUgZ29pbmcgZGVlcC1pZGxl OiAqLw0KPiAJc2NoZWRfY2xvY2tfaWRsZV9zbGVlcF9ldmVudCgpOw0KPiAJYWNwaV9pZGxlX2Rv X2VudHJ5KGN4KTsNCj4tCXQyID0gaW5sKGFjcGlfZ2JsX0ZBRFQueHBtX3RpbWVyX2Jsb2NrLmFk ZHJlc3MpOw0KPisJa3QyID0ga3RpbWVfZ2V0X3JlYWwoKTsNCj4rCWlkbGVfdGltZSA9ICBrdGlt ZV90b191cyhrdGltZV9zdWIoa3QyLCBrdDEpKTsNCj4NCj4gI2lmIGRlZmluZWQgKENPTkZJR19H RU5FUklDX1RJTUUpICYmIGRlZmluZWQgKENPTkZJR19YODYpDQo+IAkvKiBUU0MgY291bGQgaGFs dCBpbiBpZGxlLCBzbyBub3RpZnkgdXNlcnMgKi8NCj4gCWlmICh0c2NfaGFsdHNfaW5fYyhjeC0+ dHlwZSkpDQo+IAkJbWFya190c2NfdW5zdGFibGUoIlRTQyBoYWx0cyBpbiBpZGxlIik7Ow0KPiAj ZW5kaWYNCj4tCXNsZWVwX3RpY2tzID0gdGlja3NfZWxhcHNlZCh0MSwgdDIpOw0KPisJc2xlZXBf dGlja3MgPSB1c190b19wbV90aW1lcl90aWNrcyhpZGxlX3RpbWUpOw0KPg0KPiAJLyogVGVsbCB0 aGUgc2NoZWR1bGVyIGhvdyBtdWNoIHdlIGlkbGVkOiAqLw0KPiAJc2NoZWRfY2xvY2tfaWRsZV93 YWtldXBfZXZlbnQoc2xlZXBfdGlja3MqUE1fVElNRVJfVElDS19OUyk7DQo+QEAgLTk0OCw3ICs5 MzYsNyBAQCBzdGF0aWMgaW50IGFjcGlfaWRsZV9lbnRlcl9zaW1wbGUoc3RydWN0DQo+DQo+IAlh Y3BpX3N0YXRlX3RpbWVyX2Jyb2FkY2FzdChwciwgY3gsIDApOw0KPiAJY3gtPnRpbWUgKz0gc2xl ZXBfdGlja3M7DQo+LQlyZXR1cm4gdGlja3NfZWxhcHNlZF9pbl91cyh0MSwgdDIpOw0KPisJcmV0 dXJuIGlkbGVfdGltZTsNCj4gfQ0KPg0KPiBzdGF0aWMgaW50IGMzX2NwdV9jb3VudDsNCj5AQCAt OTY2LDggKzk1NCwxMCBAQCBzdGF0aWMgaW50IGFjcGlfaWRsZV9lbnRlcl9ibShzdHJ1Y3QgY3B1 DQo+IHsNCj4gCXN0cnVjdCBhY3BpX3Byb2Nlc3NvciAqcHI7DQo+IAlzdHJ1Y3QgYWNwaV9wcm9j ZXNzb3JfY3ggKmN4ID0gY3B1aWRsZV9nZXRfc3RhdGVkYXRhKHN0YXRlKTsNCj4tCXUzMiB0MSwg dDI7DQo+LQlpbnQgc2xlZXBfdGlja3MgPSAwOw0KPisJa3RpbWVfdCAga3QxLCBrdDI7DQo+Kwlz NjQgaWRsZV90aW1lOw0KPisJczY0IHNsZWVwX3RpY2tzID0gMDsNCj4rDQo+DQo+IAlwciA9IF9f Z2V0X2NwdV92YXIocHJvY2Vzc29ycyk7DQo+DQo+QEAgLTEwMzQsOSArMTAyNCwxMCBAQCBzdGF0 aWMgaW50IGFjcGlfaWRsZV9lbnRlcl9ibShzdHJ1Y3QgY3B1DQo+IAkJQUNQSV9GTFVTSF9DUFVf Q0FDSEUoKTsNCj4gCX0NCj4NCj4tCXQxID0gaW5sKGFjcGlfZ2JsX0ZBRFQueHBtX3RpbWVyX2Js b2NrLmFkZHJlc3MpOw0KPisJa3QxID0ga3RpbWVfZ2V0X3JlYWwoKTsNCj4gCWFjcGlfaWRsZV9k b19lbnRyeShjeCk7DQo+LQl0MiA9IGlubChhY3BpX2dibF9GQURULnhwbV90aW1lcl9ibG9jay5h ZGRyZXNzKTsNCj4rCWt0MiA9IGt0aW1lX2dldF9yZWFsKCk7DQo+KwlpZGxlX3RpbWUgPSAga3Rp bWVfdG9fdXMoa3RpbWVfc3ViKGt0Miwga3QxKSk7DQo+DQo+IAkvKiBSZS1lbmFibGUgYnVzIG1h c3RlciBhcmJpdHJhdGlvbiAqLw0KPiAJaWYgKHByLT5mbGFncy5ibV9jaGVjayAmJiBwci0+Zmxh Z3MuYm1fY29udHJvbCkgew0KPkBAIC0xMDUxLDcgKzEwNDIsNyBAQCBzdGF0aWMgaW50IGFjcGlf aWRsZV9lbnRlcl9ibShzdHJ1Y3QgY3B1DQo+IAlpZiAodHNjX2hhbHRzX2luX2MoQUNQSV9TVEFU RV9DMykpDQo+IAkJbWFya190c2NfdW5zdGFibGUoIlRTQyBoYWx0cyBpbiBpZGxlIik7DQo+ICNl bmRpZg0KPi0Jc2xlZXBfdGlja3MgPSB0aWNrc19lbGFwc2VkKHQxLCB0Mik7DQo+KwlzbGVlcF90 aWNrcyA9IHVzX3RvX3BtX3RpbWVyX3RpY2tzKGlkbGVfdGltZSk7DQo+IAkvKiBUZWxsIHRoZSBz Y2hlZHVsZXIgaG93IG11Y2ggd2UgaWRsZWQ6ICovDQo+IAlzY2hlZF9jbG9ja19pZGxlX3dha2V1 cF9ldmVudChzbGVlcF90aWNrcypQTV9USU1FUl9USUNLX05TKTsNCj4NCj5AQCAtMTA2Miw3ICsx MDUzLDcgQEAgc3RhdGljIGludCBhY3BpX2lkbGVfZW50ZXJfYm0oc3RydWN0IGNwdQ0KPg0KPiAJ YWNwaV9zdGF0ZV90aW1lcl9icm9hZGNhc3QocHIsIGN4LCAwKTsNCj4gCWN4LT50aW1lICs9IHNs ZWVwX3RpY2tzOw0KPi0JcmV0dXJuIHRpY2tzX2VsYXBzZWRfaW5fdXModDEsIHQyKTsNCj4rCXJl dHVybiBpZGxlX3RpbWU7DQo+IH0NCj4NCj4gc3RydWN0IGNwdWlkbGVfZHJpdmVyIGFjcGlfaWRs ZV9kcml2ZXIgPSB7DQoNCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755309AbZDWJZ1 (ORCPT ); Thu, 23 Apr 2009 05:25:27 -0400 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1753501AbZDWJZM (ORCPT ); Thu, 23 Apr 2009 05:25:12 -0400 Received: from mga09.intel.com ([134.134.136.24]:20398 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751812AbZDWJZJ (ORCPT ); Thu, 23 Apr 2009 05:25:09 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.40,235,1239001200"; d="scan'208";a="406069799" From: "Shi, Alex" To: Chris Wright , "linux-kernel@vger.kernel.org" , "stable@kernel.org" CC: Justin Forbes , Zwane Mwaikambo , "Theodore Ts'o" , Randy Dunlap , Dave Jones , Chuck Wolber , Chris Wedgwood , Michael Krufky , Chuck Ebbert , Domenico Andreoli , Willy Tarreau , Rodrigo Rubira Branco , Jake Edge , Eugene Teo , "torvalds@linux-foundation.org" , "akpm@linux-foundation.org" , "alan@lxorguk.ukuu.org.uk" , Len Brown , "linux-acpi@vger.kernel.org" , "Pallipadi, Venkatesh" , "Zhao, Yakui" , "Brown, Len" Date: Thu, 23 Apr 2009 17:24:48 +0800 Subject: RE: [patch 012/100] acpi: fix of pmtimer overflow that make Cx states time incorrect Thread-Topic: [patch 012/100] acpi: fix of pmtimer overflow that make Cx states time incorrect Thread-Index: AcnD5FbKB7gAH/4zQmKRfSxbbBMdKQAELJZg Message-ID: References: <20090423072020.428683652@sous-sol.org> <20090423072212.535803819@sous-sol.org> In-Reply-To: <20090423072212.535803819@sous-sol.org> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: acceptlanguage: en-US Content-Type: text/plain; charset="gb2312" MIME-Version: 1.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by alpha.home.local id n3N9PYqu020536 It was reported make some latop booting hang. and is not root caused now. :( http://bugzilla.kernel.org/show_bug.cgi?id=13087 Alex >-----Original Message----- >From: Chris Wright [mailto:chrisw@sous-sol.org] >Sent: 2009423 15:21 >To: linux-kernel@vger.kernel.org; stable@kernel.org >Cc: Justin Forbes; Zwane Mwaikambo; Theodore Ts'o; Randy Dunlap; Dave Jones; >Chuck Wolber; Chris Wedgwood; Michael Krufky; Chuck Ebbert; Domenico Andreoli; >Willy Tarreau; Rodrigo Rubira Branco; Jake Edge; Eugene Teo; >torvalds@linux-foundation.org; akpm@linux-foundation.org; >alan@lxorguk.ukuu.org.uk; Len Brown; linux-acpi@vger.kernel.org; Shi, Alex; >Pallipadi, Venkatesh; Zhao, Yakui; Brown, Len >Subject: [patch 012/100] acpi: fix of pmtimer overflow that make Cx states time >incorrect > >-stable review patch. If anyone has any objections, please let us know. >--------------------- > >From: alex.shi > >upstream commit: ff69f2bba67bd45514923aaedbf40fe351787c59 > >We found Cx states time abnormal in our some of machines which have 16 >LCPUs, the C0 take too many time while system is really idle when kernel >enabled tickless and highres. powertop output is below: > > PowerTOP version 1.9 (C) 2007 Intel Corporation > >Cn Avg residency P-states (frequencies) >C0 (cpu running) (40.5%) 2.53 Ghz 0.0% >C1 0.0ms ( 0.0%) 2.53 Ghz 0.0% >C2 128.8ms (59.5%) 2.40 Ghz 0.0% > 1.60 Ghz 100.0% > >Wakeups-from-idle per second : 4.7 interval: 20.0s >no ACPI power usage estimate available > >Top causes for wakeups: > 41.4% ( 24.9) : extra timer interrupt > 20.2% ( 12.2) : usb_hcd_poll_rh_status >(rh_timer_func) > >After tacking detailed for this issue, Yakui and I find it is due to 24 >bit PM timer overflows when some of cpu sleep more than 4 seconds. With >tickless kernel, the CPU want to sleep as much as possible when system >idle. But the Cx sleep time are recorded by pmtimer which length is >determined by BIOS. The current Cx time was gotten in the following >function from driver/acpi/processor_idle.c: > >static inline u32 ticks_elapsed(u32 t1, u32 t2) >{ > if (t2 >= t1) > return (t2 - t1); > else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER)) > return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF); > else > return ((0xFFFFFFFF - t1) + t2); >} > >If pmtimer is 24 bits and it take 5 seconds from t1 to t2, in above >function, just about 1 seconds ticks was recorded. So the Cx time will be >reduced about 4 seconds. and this is why we see above powertop output. > >To resolve this problem, Yakui and I use ktime_get() to record the Cx >states time instead of PM timer as the following patch. the patch was >tested with i386/x86_64 modes on several platforms. > >Acked-by: Venkatesh Pallipadi >Tested-by: Alex Shi >Signed-off-by: Alex Shi >Signed-off-by: Yakui.zhao >Signed-off-by: Andrew Morton >Signed-off-by: Len Brown >Signed-off-by: Chris Wright >--- > drivers/acpi/processor_idle.c | 63 >++++++++++++++++++------------------------ > 1 file changed, 27 insertions(+), 36 deletions(-) > >--- a/drivers/acpi/processor_idle.c >+++ b/drivers/acpi/processor_idle.c >@@ -64,7 +64,6 @@ > #define _COMPONENT ACPI_PROCESSOR_COMPONENT > ACPI_MODULE_NAME("processor_idle"); > #define ACPI_PROCESSOR_FILE_POWER "power" >-#define US_TO_PM_TIMER_TICKS(t) ((t * (PM_TIMER_FREQUENCY/1000)) / >1000) > #define PM_TIMER_TICK_NS (1000000000ULL/PM_TIMER_FREQUENCY) > #define C2_OVERHEAD 1 /* 1us */ > #define C3_OVERHEAD 1 /* 1us */ >@@ -78,6 +77,10 @@ module_param(nocst, uint, 0000); > static unsigned int latency_factor __read_mostly = 2; > module_param(latency_factor, uint, 0644); > >+static s64 us_to_pm_timer_ticks(s64 t) >+{ >+ return div64_u64(t * PM_TIMER_FREQUENCY, 1000000); >+} > /* > * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. > * For now disable this. Probably a bug somewhere else. >@@ -159,25 +162,6 @@ static struct dmi_system_id __cpuinitdat > {}, > }; > >-static inline u32 ticks_elapsed(u32 t1, u32 t2) >-{ >- if (t2 >= t1) >- return (t2 - t1); >- else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER)) >- return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF); >- else >- return ((0xFFFFFFFF - t1) + t2); >-} >- >-static inline u32 ticks_elapsed_in_us(u32 t1, u32 t2) >-{ >- if (t2 >= t1) >- return PM_TIMER_TICKS_TO_US(t2 - t1); >- else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER)) >- return PM_TIMER_TICKS_TO_US(((0x00FFFFFF - t1) + t2) & 0x00FFFFFF); >- else >- return PM_TIMER_TICKS_TO_US((0xFFFFFFFF - t1) + t2); >-} > > /* > * Callers should disable interrupts before the call and enable >@@ -853,7 +837,8 @@ static inline void acpi_idle_do_entry(st > static int acpi_idle_enter_c1(struct cpuidle_device *dev, > struct cpuidle_state *state) > { >- u32 t1, t2; >+ ktime_t kt1, kt2; >+ s64 idle_time; > struct acpi_processor *pr; > struct acpi_processor_cx *cx = cpuidle_get_statedata(state); > >@@ -871,14 +856,15 @@ static int acpi_idle_enter_c1(struct cpu > return 0; > } > >- t1 = inl(acpi_gbl_FADT.xpm_timer_block.address); >+ kt1 = ktime_get_real(); > acpi_idle_do_entry(cx); >- t2 = inl(acpi_gbl_FADT.xpm_timer_block.address); >+ kt2 = ktime_get_real(); >+ idle_time = ktime_to_us(ktime_sub(kt2, kt1)); > > local_irq_enable(); > cx->usage++; > >- return ticks_elapsed_in_us(t1, t2); >+ return idle_time; > } > > /** >@@ -891,8 +877,9 @@ static int acpi_idle_enter_simple(struct > { > struct acpi_processor *pr; > struct acpi_processor_cx *cx = cpuidle_get_statedata(state); >- u32 t1, t2; >- int sleep_ticks = 0; >+ ktime_t kt1, kt2; >+ s64 idle_time; >+ s64 sleep_ticks = 0; > > pr = __get_cpu_var(processors); > >@@ -925,18 +912,19 @@ static int acpi_idle_enter_simple(struct > if (cx->type == ACPI_STATE_C3) > ACPI_FLUSH_CPU_CACHE(); > >- t1 = inl(acpi_gbl_FADT.xpm_timer_block.address); >+ kt1 = ktime_get_real(); > /* Tell the scheduler that we are going deep-idle: */ > sched_clock_idle_sleep_event(); > acpi_idle_do_entry(cx); >- t2 = inl(acpi_gbl_FADT.xpm_timer_block.address); >+ kt2 = ktime_get_real(); >+ idle_time = ktime_to_us(ktime_sub(kt2, kt1)); > > #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86) > /* TSC could halt in idle, so notify users */ > if (tsc_halts_in_c(cx->type)) > mark_tsc_unstable("TSC halts in idle");; > #endif >- sleep_ticks = ticks_elapsed(t1, t2); >+ sleep_ticks = us_to_pm_timer_ticks(idle_time); > > /* Tell the scheduler how much we idled: */ > sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS); >@@ -948,7 +936,7 @@ static int acpi_idle_enter_simple(struct > > acpi_state_timer_broadcast(pr, cx, 0); > cx->time += sleep_ticks; >- return ticks_elapsed_in_us(t1, t2); >+ return idle_time; > } > > static int c3_cpu_count; >@@ -966,8 +954,10 @@ static int acpi_idle_enter_bm(struct cpu > { > struct acpi_processor *pr; > struct acpi_processor_cx *cx = cpuidle_get_statedata(state); >- u32 t1, t2; >- int sleep_ticks = 0; >+ ktime_t kt1, kt2; >+ s64 idle_time; >+ s64 sleep_ticks = 0; >+ > > pr = __get_cpu_var(processors); > >@@ -1034,9 +1024,10 @@ static int acpi_idle_enter_bm(struct cpu > ACPI_FLUSH_CPU_CACHE(); > } > >- t1 = inl(acpi_gbl_FADT.xpm_timer_block.address); >+ kt1 = ktime_get_real(); > acpi_idle_do_entry(cx); >- t2 = inl(acpi_gbl_FADT.xpm_timer_block.address); >+ kt2 = ktime_get_real(); >+ idle_time = ktime_to_us(ktime_sub(kt2, kt1)); > > /* Re-enable bus master arbitration */ > if (pr->flags.bm_check && pr->flags.bm_control) { >@@ -1051,7 +1042,7 @@ static int acpi_idle_enter_bm(struct cpu > if (tsc_halts_in_c(ACPI_STATE_C3)) > mark_tsc_unstable("TSC halts in idle"); > #endif >- sleep_ticks = ticks_elapsed(t1, t2); >+ sleep_ticks = us_to_pm_timer_ticks(idle_time); > /* Tell the scheduler how much we idled: */ > sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS); > >@@ -1062,7 +1053,7 @@ static int acpi_idle_enter_bm(struct cpu > > acpi_state_timer_broadcast(pr, cx, 0); > cx->time += sleep_ticks; >- return ticks_elapsed_in_us(t1, t2); >+ return idle_time; > } > > struct cpuidle_driver acpi_idle_driver = { {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I