From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= Subject: [PATCH 6/9] PM: suspend_block: Add suspend_blocker stats Date: Thu, 22 Apr 2010 18:08:55 -0700 Message-ID: <1271984938-13920-7-git-send-email-arve@android.com> References: <1271984938-13920-1-git-send-email-arve@android.com> <1271984938-13920-2-git-send-email-arve@android.com> <1271984938-13920-3-git-send-email-arve@android.com> <1271984938-13920-4-git-send-email-arve@android.com> <1271984938-13920-5-git-send-email-arve@android.com> <1271984938-13920-6-git-send-email-arve@android.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1271984938-13920-6-git-send-email-arve@android.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-pm-bounces@lists.linux-foundation.org Errors-To: linux-pm-bounces@lists.linux-foundation.org To: linux-pm@lists.linux-foundation.org, linux-kernel@vger.kernel.org Cc: Len Brown , Jesse Barnes , Magnus Damm , Andrew Morton , Wu Fengguang List-Id: linux-pm@vger.kernel.org UmVwb3J0IHN1c3BlbmQgYmxvY2sgc3RhdHMgaW4gL3N5cy9rZXJuZWwvZGVidWcvc3VzcGVuZF9i bG9ja2Vycy4KClNpZ25lZC1vZmYtYnk6IEFydmUgSGrDuG5uZXbDpWcgPGFydmVAYW5kcm9pZC5j b20+Ci0tLQogaW5jbHVkZS9saW51eC9zdXNwZW5kX2Jsb2NrZXIuaCB8ICAgMjEgKysrKy0KIGtl cm5lbC9wb3dlci9LY29uZmlnICAgICAgICAgICAgfCAgICA3ICsrCiBrZXJuZWwvcG93ZXIvcG93 ZXIuaCAgICAgICAgICAgIHwgICAgNiArLQoga2VybmVsL3Bvd2VyL3N1c3BlbmQuYyAgICAgICAg ICB8ICAgIDQgKy0KIGtlcm5lbC9wb3dlci9zdXNwZW5kX2Jsb2NrZXIuYyAgfCAgMTkwICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLQogNSBmaWxlcyBjaGFuZ2VkLCAyMTgg aW5zZXJ0aW9ucygrKSwgMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9zdXNwZW5kX2Jsb2NrZXIuaCBiL2luY2x1ZGUvbGludXgvc3VzcGVuZF9ibG9ja2VyLmgKaW5k ZXggMWZhYTQzMy4uM2JiOGE2YSAxMDA3NTUKLS0tIGEvaW5jbHVkZS9saW51eC9zdXNwZW5kX2Js b2NrZXIuaAorKysgYi9pbmNsdWRlL2xpbnV4L3N1c3BlbmRfYmxvY2tlci5oCkBAIC0xNywxMiAr MTcsMjEgQEAKICNkZWZpbmUgX0xJTlVYX1NVU1BFTkRfQkxPQ0tFUl9ICiAKICNpbmNsdWRlIDxs aW51eC9saXN0Lmg+CisjaW5jbHVkZSA8bGludXgva3RpbWUuaD4KIAogLyoqCiAgKiBzdHJ1Y3Qg c3VzcGVuZF9ibG9ja2VyIC0gdGhlIGJhc2ljIHN1c3BlbmRfYmxvY2tlciBzdHJ1Y3R1cmUKICAq IEBsaW5rOglMaXN0IGVudHJ5IGZvciBhY3RpdmUgb3IgaW5hY3RpdmUgbGlzdC4KLSAqIEBmbGFn czoJVHJhY2tzIGluaXRpYWxpemVkIGFuZCBhY3RpdmUgc3RhdGUuCisgKiBAZmxhZ3M6CVRyYWNr cyBpbml0aWFsaXplZCwgYWN0aXZlIGFuZCBzdGF0cyBzdGF0ZS4KICAqIEBuYW1lOglOYW1lIHVz ZWQgZm9yIGRlYnVnZ2luZy4KKyAqIEBjb3VudDoJTnVtYmVyIG9mIHRpbWVzIHRoaXMgYmxvY2tl ciBoYXMgYmVlbiBkZWFjaXZhdGVkCisgKiBAd2FrZXVwX2NvdW50OiBOdW1iZXIgb2YgdGltZXMg dGhpcyBibG9ja2VyIHdhcyB0aGUgZmlyc3QgdG8gYmxvY2sgc3VzcGVuZAorICoJCWFmdGVyIHJl c3VtZS4KKyAqIEB0b3RhbF90aW1lOglUb3RhbCB0aW1lIHRoaXMgc3VzcGVuZCBibG9ja2VyIGhh cyBwcmV2ZW50ZWQgc3VzcGVuZC4KKyAqIEBwcmV2ZW50X3N1c3BlbmRfdGltZTogVGltZSB0aGlz IHN1c3BlbmQgYmxvY2tlciBoYXMgcHJldmVudGVkIHN1c3BlbmQgd2hpbGUKKyAqCQl1c2VyLXNw YWNlIHJlcXVlc3RlZCBzdXNwZW5kLgorICogQG1heF90aW1lOglNYXggdGltZSB0aGlzIHN1c3Bl bmQgYmxvY2tlciBoYXMgYmVlbiBjb250aW51b3VzbHkgYWN0aXZlCisgKiBAbGFzdF90aW1lOglN b25vdG9uaWMgY2xvY2sgd2hlbiB0aGUgYWN0aXZlIHN0YXRlIGxhc3QgY2hhbmdlZC4KICAqCiAg KiBXaGVuIGEgc3VzcGVuZF9ibG9ja2VyIGlzIGFjdGl2ZSBpdCBwcmV2ZW50cyB0aGUgc3lzdGVt IGZyb20gZW50ZXJpbmcKICAqIHN1c3BlbmQuCkBAIC0zNSw2ICs0NCwxNiBAQCBzdHJ1Y3Qgc3Vz cGVuZF9ibG9ja2VyIHsKIAlzdHJ1Y3QgbGlzdF9oZWFkICAgIGxpbms7CiAJaW50ICAgICAgICAg ICAgICAgICBmbGFnczsKIAljb25zdCBjaGFyICAgICAgICAgKm5hbWU7CisjaWZkZWYgQ09ORklH X1NVU1BFTkRfQkxPQ0tFUl9TVEFUUworCXN0cnVjdCB7CisJCWludCAgICAgICAgICAgICBjb3Vu dDsKKwkJaW50ICAgICAgICAgICAgIHdha2V1cF9jb3VudDsKKwkJa3RpbWVfdCAgICAgICAgIHRv dGFsX3RpbWU7CisJCWt0aW1lX3QgICAgICAgICBwcmV2ZW50X3N1c3BlbmRfdGltZTsKKwkJa3Rp bWVfdCAgICAgICAgIG1heF90aW1lOworCQlrdGltZV90ICAgICAgICAgbGFzdF90aW1lOworCX0g c3RhdDsKKyNlbmRpZgogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9rZXJuZWwvcG93ZXIvS2Nv bmZpZyBiL2tlcm5lbC9wb3dlci9LY29uZmlnCmluZGV4IDFhYzUwZWUuLjNmYTJkMzMgMTAwNjQ0 Ci0tLSBhL2tlcm5lbC9wb3dlci9LY29uZmlnCisrKyBiL2tlcm5lbC9wb3dlci9LY29uZmlnCkBA IC0xNDEsNiArMTQxLDEzIEBAIGNvbmZpZyBTVVNQRU5EX0JMT0NLRVJTCiAJICBzdGF0ZSB0aHJv dWdoIC9zeXMvcG93ZXIvc3RhdGUsIHRoZSByZXF1ZXN0ZWQgc2xlZXAgc3RhdGUgd2lsbCBiZQog CSAgZW50ZXJlZCB3aGVuIG5vIHN1c3BlbmQgYmxvY2tlcnMgYXJlIGFjdGl2ZS4KIAorY29uZmln IFNVU1BFTkRfQkxPQ0tFUl9TVEFUUworCWJvb2wgIlN1c3BlbmQgYmxvY2sgc3RhdHMiCisJZGVw ZW5kcyBvbiBTVVNQRU5EX0JMT0NLRVJTCisJZGVmYXVsdCB5CisJLS0taGVscC0tLQorCSAgUmVw b3J0IHN1c3BlbmQgYmxvY2sgc3RhdHMgaW4gL3N5cy9rZXJuZWwvZGVidWcvc3VzcGVuZF9ibG9j a2VycworCiBjb25maWcgVVNFUl9TVVNQRU5EX0JMT0NLRVJTCiAJYm9vbCAiVXNlcnNwYWNlIHN1 c3BlbmQgYmxvY2tlcnMiCiAJZGVwZW5kcyBvbiBTVVNQRU5EX0JMT0NLRVJTCmRpZmYgLS1naXQg YS9rZXJuZWwvcG93ZXIvcG93ZXIuaCBiL2tlcm5lbC9wb3dlci9wb3dlci5oCmluZGV4IDliNDY4 ZDcuLjc1Yjg4NDkgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9wb3dlci9wb3dlci5oCisrKyBiL2tlcm5l bC9wb3dlci9wb3dlci5oCkBAIC0yNDAsNCArMjQwLDggQEAgc3RhdGljIGlubGluZSB2b2lkIHN1 c3BlbmRfdGhhd19wcm9jZXNzZXModm9pZCkKIC8qIGtlcm5lbC9wb3dlci9zdXNwZW5kX2Jsb2Nr LmMgKi8KIGV4dGVybiBpbnQgcmVxdWVzdF9zdXNwZW5kX3N0YXRlKHN1c3BlbmRfc3RhdGVfdCBz dGF0ZSk7CiBleHRlcm4gYm9vbCByZXF1ZXN0X3N1c3BlbmRfdmFsaWRfc3RhdGUoc3VzcGVuZF9z dGF0ZV90IHN0YXRlKTsKLQorI2lmZGVmIENPTkZJR19TVVNQRU5EX0JMT0NLRVJfU1RBVFMKK3Zv aWQgYWJvdXRfdG9fZW50ZXJfc3VzcGVuZCh2b2lkKTsKKyNlbHNlCitzdGF0aWMgaW5saW5lIHZv aWQgYWJvdXRfdG9fZW50ZXJfc3VzcGVuZCh2b2lkKSB7fQorI2VuZGlmCmRpZmYgLS1naXQgYS9r ZXJuZWwvcG93ZXIvc3VzcGVuZC5jIGIva2VybmVsL3Bvd2VyL3N1c3BlbmQuYwppbmRleCBkYzQy MDA2Li42ZDMyN2VhIDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvc3VzcGVuZC5jCisrKyBiL2tl cm5lbC9wb3dlci9zdXNwZW5kLmMKQEAgLTE1OSw4ICsxNTksMTAgQEAgc3RhdGljIGludCBzdXNw ZW5kX2VudGVyKHN1c3BlbmRfc3RhdGVfdCBzdGF0ZSkKIAogCWVycm9yID0gc3lzZGV2X3N1c3Bl bmQoUE1TR19TVVNQRU5EKTsKIAlpZiAoIWVycm9yKSB7Ci0JCWlmICghc3VzcGVuZF9pc19ibG9j a2VkKCkgJiYgIXN1c3BlbmRfdGVzdChURVNUX0NPUkUpKQorCQlpZiAoIXN1c3BlbmRfaXNfYmxv Y2tlZCgpICYmICFzdXNwZW5kX3Rlc3QoVEVTVF9DT1JFKSkgeworCQkJYWJvdXRfdG9fZW50ZXJf c3VzcGVuZCgpOwogCQkJZXJyb3IgPSBzdXNwZW5kX29wcy0+ZW50ZXIoc3RhdGUpOworCQl9CiAJ CXN5c2Rldl9yZXN1bWUoKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3dlci9zdXNwZW5k X2Jsb2NrZXIuYyBiL2tlcm5lbC9wb3dlci9zdXNwZW5kX2Jsb2NrZXIuYwppbmRleCAwNDdlOTEw Li4wOGQxOGMyIDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvc3VzcGVuZF9ibG9ja2VyLmMKKysr IGIva2VybmVsL3Bvd2VyL3N1c3BlbmRfYmxvY2tlci5jCkBAIC0zMiw2ICszMiw3IEBAIG1vZHVs ZV9wYXJhbV9uYW1lZChkZWJ1Z19tYXNrLCBkZWJ1Z19tYXNrLCBpbnQsIFNfSVJVR08gfCBTX0lX VVNSIHwgU19JV0dSUCk7CiAKICNkZWZpbmUgU0JfSU5JVElBTElaRUQgICAgICAgICAgICAoMVUg PDwgOCkKICNkZWZpbmUgU0JfQUNUSVZFICAgICAgICAgICAgICAgICAoMVUgPDwgOSkKKyNkZWZp bmUgU0JfUFJFVkVOVElOR19TVVNQRU5EICAgICAoMVUgPDwgMTApCiAKIHN0YXRpYyBERUZJTkVf U1BJTkxPQ0sobGlzdF9sb2NrKTsKIHN0YXRpYyBERUZJTkVfU1BJTkxPQ0soc3RhdGVfbG9jayk7 CkBAIC00Miw2ICs0Myw3IEBAIHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICpzdXNwZW5kX3dvcmtf cXVldWU7CiBzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2VyIG1haW5fc3VzcGVuZF9ibG9ja2VyOwogc3Rh dGljIHN1c3BlbmRfc3RhdGVfdCByZXF1ZXN0ZWRfc3VzcGVuZF9zdGF0ZSA9IFBNX1NVU1BFTkRf TUVNOwogc3RhdGljIGJvb2wgZW5hYmxlX3N1c3BlbmRfYmxvY2tlcnM7CitzdGF0aWMgc3RydWN0 IHN1c3BlbmRfYmxvY2tlciB1bmtub3duX3dha2V1cDsKIHN0YXRpYyBzdHJ1Y3QgZGVudHJ5ICpz dXNwZW5kX2Jsb2NrZXJfc3RhdHNfZGVudHJ5OwogCiAjZGVmaW5lIHByX2luZm9fdGltZShmbXQs IGFyZ3MuLi4pIFwKQEAgLTU2LDYgKzU4LDE1MyBAQCBzdGF0aWMgc3RydWN0IGRlbnRyeSAqc3Vz cGVuZF9ibG9ja2VyX3N0YXRzX2RlbnRyeTsKIAkJCXRtLnRtX2hvdXIsIHRtLnRtX21pbiwgdG0u dG1fc2VjLCB0cy50dl9uc2VjKTsgXAogCX0gd2hpbGUgKDApOwogCisjaWZkZWYgQ09ORklHX1NV U1BFTkRfQkxPQ0tFUl9TVEFUUworc3RhdGljIHN0cnVjdCBzdXNwZW5kX2Jsb2NrZXIgZGVsZXRl ZF9zdXNwZW5kX2Jsb2NrZXJzOworc3RhdGljIGt0aW1lX3QgbGFzdF9zbGVlcF90aW1lX3VwZGF0 ZTsKK3N0YXRpYyBib29sIHdhaXRfZm9yX3dha2V1cDsKKworc3RhdGljIGludCBwcmludF9ibG9j a2VyX3N0YXQoc3RydWN0IHNlcV9maWxlICptLAorCQkJICAgICAgc3RydWN0IHN1c3BlbmRfYmxv Y2tlciAqYmxvY2tlcikKK3sKKwlpbnQgbG9ja19jb3VudCA9IGJsb2NrZXItPnN0YXQuY291bnQ7 CisJa3RpbWVfdCBhY3RpdmVfdGltZSA9IGt0aW1lX3NldCgwLCAwKTsKKwlrdGltZV90IHRvdGFs X3RpbWUgPSBibG9ja2VyLT5zdGF0LnRvdGFsX3RpbWU7CisJa3RpbWVfdCBtYXhfdGltZSA9IGJs b2NrZXItPnN0YXQubWF4X3RpbWU7CisJa3RpbWVfdCBwcmV2ZW50X3N1c3BlbmRfdGltZSA9IGJs b2NrZXItPnN0YXQucHJldmVudF9zdXNwZW5kX3RpbWU7CisJaWYgKGJsb2NrZXItPmZsYWdzICYg U0JfQUNUSVZFKSB7CisJCWt0aW1lX3Qgbm93LCBhZGRfdGltZTsKKwkJbm93ID0ga3RpbWVfZ2V0 KCk7CisJCWFkZF90aW1lID0ga3RpbWVfc3ViKG5vdywgYmxvY2tlci0+c3RhdC5sYXN0X3RpbWUp OworCQlsb2NrX2NvdW50Kys7CisJCWFjdGl2ZV90aW1lID0gYWRkX3RpbWU7CisJCXRvdGFsX3Rp bWUgPSBrdGltZV9hZGQodG90YWxfdGltZSwgYWRkX3RpbWUpOworCQlpZiAoYmxvY2tlci0+Zmxh Z3MgJiBTQl9QUkVWRU5USU5HX1NVU1BFTkQpCisJCQlwcmV2ZW50X3N1c3BlbmRfdGltZSA9IGt0 aW1lX2FkZChwcmV2ZW50X3N1c3BlbmRfdGltZSwKKwkJCQkJa3RpbWVfc3ViKG5vdywgbGFzdF9z bGVlcF90aW1lX3VwZGF0ZSkpOworCQlpZiAoYWRkX3RpbWUudHY2NCA+IG1heF90aW1lLnR2NjQp CisJCQltYXhfdGltZSA9IGFkZF90aW1lOworCX0KKworCXJldHVybiBzZXFfcHJpbnRmKG0sICJc IiVzXCJcdCVkXHQlZFx0JWxsZFx0JWxsZFx0JWxsZFx0JWxsZFx0JWxsZFxuIiwKKwkJICAgICAg IGJsb2NrZXItPm5hbWUsIGxvY2tfY291bnQsIGJsb2NrZXItPnN0YXQud2FrZXVwX2NvdW50LAor CQkgICAgICAga3RpbWVfdG9fbnMoYWN0aXZlX3RpbWUpLCBrdGltZV90b19ucyh0b3RhbF90aW1l KSwKKwkJICAgICAgIGt0aW1lX3RvX25zKHByZXZlbnRfc3VzcGVuZF90aW1lKSwga3RpbWVfdG9f bnMobWF4X3RpbWUpLAorCQkgICAgICAga3RpbWVfdG9fbnMoYmxvY2tlci0+c3RhdC5sYXN0X3Rp bWUpKTsKK30KKworCitzdGF0aWMgaW50IHN1c3BlbmRfYmxvY2tlcl9zdGF0c19zaG93KHN0cnVj dCBzZXFfZmlsZSAqbSwgdm9pZCAqdW51c2VkKQoreworCXVuc2lnbmVkIGxvbmcgaXJxZmxhZ3M7 CisJc3RydWN0IHN1c3BlbmRfYmxvY2tlciAqYmxvY2tlcjsKKworCXNlcV9wdXRzKG0sICJuYW1l XHRjb3VudFx0d2FrZV9jb3VudFx0YWN0aXZlX3NpbmNlIgorCQkgIlx0dG90YWxfdGltZVx0c2xl ZXBfdGltZVx0bWF4X3RpbWVcdGxhc3RfY2hhbmdlXG4iKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgm bGlzdF9sb2NrLCBpcnFmbGFncyk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShibG9ja2VyLCAmaW5h Y3RpdmVfYmxvY2tlcnMsIGxpbmspCisJCXByaW50X2Jsb2NrZXJfc3RhdChtLCBibG9ja2VyKTsK KwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGJsb2NrZXIsICZhY3RpdmVfYmxvY2tlcnMsIGxpbmspCisJ CXByaW50X2Jsb2NrZXJfc3RhdChtLCBibG9ja2VyKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZsaXN0X2xvY2ssIGlycWZsYWdzKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgc3Vz cGVuZF9ibG9ja2VyX3N0YXRfaW5pdF9sb2NrZWQoc3RydWN0IHN1c3BlbmRfYmxvY2tlciAqYmxv Y2tlcikKK3sKKwlibG9ja2VyLT5zdGF0LmNvdW50ID0gMDsKKwlibG9ja2VyLT5zdGF0Lndha2V1 cF9jb3VudCA9IDA7CisJYmxvY2tlci0+c3RhdC50b3RhbF90aW1lID0ga3RpbWVfc2V0KDAsIDAp OworCWJsb2NrZXItPnN0YXQucHJldmVudF9zdXNwZW5kX3RpbWUgPSBrdGltZV9zZXQoMCwgMCk7 CisJYmxvY2tlci0+c3RhdC5tYXhfdGltZSA9IGt0aW1lX3NldCgwLCAwKTsKKwlibG9ja2VyLT5z dGF0Lmxhc3RfdGltZSA9IGt0aW1lX3NldCgwLCAwKTsKK30KKworc3RhdGljIHZvaWQgc3VzcGVu ZF9ibG9ja2VyX3N0YXRfZGVzdHJveV9sb2NrZWQoc3RydWN0IHN1c3BlbmRfYmxvY2tlciAqYmwp Cit7CisJaWYgKCFibC0+c3RhdC5jb3VudCkKKwkJcmV0dXJuOworCWRlbGV0ZWRfc3VzcGVuZF9i bG9ja2Vycy5zdGF0LmNvdW50ICs9IGJsLT5zdGF0LmNvdW50OworCWRlbGV0ZWRfc3VzcGVuZF9i bG9ja2Vycy5zdGF0LnRvdGFsX3RpbWUgPSBrdGltZV9hZGQoCisJCWRlbGV0ZWRfc3VzcGVuZF9i bG9ja2Vycy5zdGF0LnRvdGFsX3RpbWUsIGJsLT5zdGF0LnRvdGFsX3RpbWUpOworCWRlbGV0ZWRf c3VzcGVuZF9ibG9ja2Vycy5zdGF0LnByZXZlbnRfc3VzcGVuZF90aW1lID0ga3RpbWVfYWRkKAor CQlkZWxldGVkX3N1c3BlbmRfYmxvY2tlcnMuc3RhdC5wcmV2ZW50X3N1c3BlbmRfdGltZSwKKwkJ YmwtPnN0YXQucHJldmVudF9zdXNwZW5kX3RpbWUpOworCWRlbGV0ZWRfc3VzcGVuZF9ibG9ja2Vy cy5zdGF0Lm1heF90aW1lID0ga3RpbWVfYWRkKAorCQlkZWxldGVkX3N1c3BlbmRfYmxvY2tlcnMu c3RhdC5tYXhfdGltZSwgYmwtPnN0YXQubWF4X3RpbWUpOworfQorCitzdGF0aWMgdm9pZCBzdXNw ZW5kX3VuYmxvY2tfc3RhdF9sb2NrZWQoc3RydWN0IHN1c3BlbmRfYmxvY2tlciAqYmxvY2tlcikK K3sKKwlrdGltZV90IGR1cmF0aW9uOworCWt0aW1lX3Qgbm93OworCWlmICghKGJsb2NrZXItPmZs YWdzICYgU0JfQUNUSVZFKSkKKwkJcmV0dXJuOworCW5vdyA9IGt0aW1lX2dldCgpOworCWJsb2Nr ZXItPnN0YXQuY291bnQrKzsKKwlkdXJhdGlvbiA9IGt0aW1lX3N1Yihub3csIGJsb2NrZXItPnN0 YXQubGFzdF90aW1lKTsKKwlibG9ja2VyLT5zdGF0LnRvdGFsX3RpbWUgPQorCQlrdGltZV9hZGQo YmxvY2tlci0+c3RhdC50b3RhbF90aW1lLCBkdXJhdGlvbik7CisJaWYgKGt0aW1lX3RvX25zKGR1 cmF0aW9uKSA+IGt0aW1lX3RvX25zKGJsb2NrZXItPnN0YXQubWF4X3RpbWUpKQorCQlibG9ja2Vy LT5zdGF0Lm1heF90aW1lID0gZHVyYXRpb247CisJYmxvY2tlci0+c3RhdC5sYXN0X3RpbWUgPSBr dGltZV9nZXQoKTsKKwlpZiAoYmxvY2tlci0+ZmxhZ3MgJiBTQl9QUkVWRU5USU5HX1NVU1BFTkQp IHsKKwkJZHVyYXRpb24gPSBrdGltZV9zdWIobm93LCBsYXN0X3NsZWVwX3RpbWVfdXBkYXRlKTsK KwkJYmxvY2tlci0+c3RhdC5wcmV2ZW50X3N1c3BlbmRfdGltZSA9IGt0aW1lX2FkZCgKKwkJCWJs b2NrZXItPnN0YXQucHJldmVudF9zdXNwZW5kX3RpbWUsIGR1cmF0aW9uKTsKKwkJYmxvY2tlci0+ ZmxhZ3MgJj0gflNCX1BSRVZFTlRJTkdfU1VTUEVORDsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHN1 c3BlbmRfYmxvY2tfc3RhdF9sb2NrZWQoc3RydWN0IHN1c3BlbmRfYmxvY2tlciAqYmxvY2tlcikK K3sKKwlpZiAod2FpdF9mb3Jfd2FrZXVwKSB7CisJCWlmIChkZWJ1Z19tYXNrICYgREVCVUdfV0FL RVVQKQorCQkJcHJfaW5mbygid2FrZXVwIHN1c3BlbmQgYmxvY2tlcjogJXNcbiIsIGJsb2NrZXIt Pm5hbWUpOworCQl3YWl0X2Zvcl93YWtldXAgPSBmYWxzZTsKKwkJYmxvY2tlci0+c3RhdC53YWtl dXBfY291bnQrKzsKKwl9CisJaWYgKCEoYmxvY2tlci0+ZmxhZ3MgJiBTQl9BQ1RJVkUpKQorCQli bG9ja2VyLT5zdGF0Lmxhc3RfdGltZSA9IGt0aW1lX2dldCgpOworfQorCitzdGF0aWMgdm9pZCB1 cGRhdGVfc2xlZXBfd2FpdF9zdGF0c19sb2NrZWQoYm9vbCBkb25lKQoreworCXN0cnVjdCBzdXNw ZW5kX2Jsb2NrZXIgKmJsb2NrZXI7CisJa3RpbWVfdCBub3csIGVsYXBzZWQsIGFkZDsKKworCW5v dyA9IGt0aW1lX2dldCgpOworCWVsYXBzZWQgPSBrdGltZV9zdWIobm93LCBsYXN0X3NsZWVwX3Rp bWVfdXBkYXRlKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGJsb2NrZXIsICZhY3RpdmVfYmxvY2tl cnMsIGxpbmspIHsKKwkJaWYgKGJsb2NrZXItPmZsYWdzICYgU0JfUFJFVkVOVElOR19TVVNQRU5E KSB7CisJCQlhZGQgPSBlbGFwc2VkOworCQkJYmxvY2tlci0+c3RhdC5wcmV2ZW50X3N1c3BlbmRf dGltZSA9IGt0aW1lX2FkZCgKKwkJCQlibG9ja2VyLT5zdGF0LnByZXZlbnRfc3VzcGVuZF90aW1l LCBhZGQpOworCQl9CisJCWlmIChkb25lKQorCQkJYmxvY2tlci0+ZmxhZ3MgJj0gflNCX1BSRVZF TlRJTkdfU1VTUEVORDsKKwkJZWxzZQorCQkJYmxvY2tlci0+ZmxhZ3MgfD0gU0JfUFJFVkVOVElO R19TVVNQRU5EOworCX0KKwlsYXN0X3NsZWVwX3RpbWVfdXBkYXRlID0gbm93OworfQorCit2b2lk IGFib3V0X3RvX2VudGVyX3N1c3BlbmQodm9pZCkKK3sKKwl3YWl0X2Zvcl93YWtldXAgPSB0cnVl OworfQorCisjZWxzZQorCitzdGF0aWMgaW5saW5lIHZvaWQgc3VzcGVuZF9ibG9ja2VyX3N0YXRf aW5pdF9sb2NrZWQoCisJCQkJCXN0cnVjdCBzdXNwZW5kX2Jsb2NrZXIgKmJsb2NrZXIpIHt9Citz dGF0aWMgaW5saW5lIHZvaWQgc3VzcGVuZF9ibG9ja2VyX3N0YXRfZGVzdHJveV9sb2NrZWQoCisJ CQkJCXN0cnVjdCBzdXNwZW5kX2Jsb2NrZXIgKmJsb2NrZXIpIHt9CitzdGF0aWMgaW5saW5lIHZv aWQgc3VzcGVuZF9ibG9ja19zdGF0X2xvY2tlZCgKKwkJCQkJc3RydWN0IHN1c3BlbmRfYmxvY2tl ciAqYmxvY2tlcikge30KK3N0YXRpYyBpbmxpbmUgdm9pZCBzdXNwZW5kX3VuYmxvY2tfc3RhdF9s b2NrZWQoCisJCQkJCXN0cnVjdCBzdXNwZW5kX2Jsb2NrZXIgKmJsb2NrZXIpIHt9CitzdGF0aWMg aW5saW5lIHZvaWQgdXBkYXRlX3NsZWVwX3dhaXRfc3RhdHNfbG9ja2VkKGJvb2wgZG9uZSkge30K Kwogc3RhdGljIGludCBzdXNwZW5kX2Jsb2NrZXJfc3RhdHNfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUg Km0sIHZvaWQgKnVudXNlZCkKIHsKIAl1bnNpZ25lZCBsb25nIGlycWZsYWdzOwpAQCAtNzEsNiAr MjIwLDggQEAgc3RhdGljIGludCBzdXNwZW5kX2Jsb2NrZXJfc3RhdHNfc2hvdyhzdHJ1Y3Qgc2Vx X2ZpbGUgKm0sIHZvaWQgKnVudXNlZCkKIAlyZXR1cm4gMDsKIH0KIAorI2VuZGlmCisKIHN0YXRp YyB2b2lkIHByaW50X2FjdGl2ZV9ibG9ja2Vyc19sb2NrZWQodm9pZCkKIHsKIAlzdHJ1Y3Qgc3Vz cGVuZF9ibG9ja2VyICpibG9ja2VyOwpAQCAtMTAxLDE2ICsyNTIsMjYgQEAgc3RhdGljIHZvaWQg c3VzcGVuZF93b3JrZXIoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogCWludCBlbnRyeV9ldmVu dF9udW07CiAKIAllbmFibGVfc3VzcGVuZF9ibG9ja2VycyA9IHRydWU7Ci0Jd2hpbGUgKCFzdXNw ZW5kX2lzX2Jsb2NrZWQoKSkgewotCQllbnRyeV9ldmVudF9udW0gPSBjdXJyZW50X2V2ZW50X251 bTsKKworCWlmIChzdXNwZW5kX2lzX2Jsb2NrZWQoKSkgeworCQlpZiAoZGVidWdfbWFzayAmIERF QlVHX1NVU1BFTkQpCisJCQlwcl9pbmZvKCJzdXNwZW5kOiBhYm9ydCBzdXNwZW5kXG4iKTsKKwkJ Z290byBhYm9ydDsKKwl9CisKKwllbnRyeV9ldmVudF9udW0gPSBjdXJyZW50X2V2ZW50X251bTsK KwlpZiAoZGVidWdfbWFzayAmIERFQlVHX1NVU1BFTkQpCisJCXByX2luZm8oInN1c3BlbmQ6IGVu dGVyIHN1c3BlbmRcbiIpOworCXJldCA9IHBtX3N1c3BlbmQocmVxdWVzdGVkX3N1c3BlbmRfc3Rh dGUpOworCWlmIChkZWJ1Z19tYXNrICYgREVCVUdfRVhJVF9TVVNQRU5EKQorCQlwcl9pbmZvX3Rp bWUoInN1c3BlbmQ6IGV4aXQgc3VzcGVuZCwgcmV0ID0gJWQgIiwgcmV0KTsKKwlpZiAoY3VycmVu dF9ldmVudF9udW0gPT0gZW50cnlfZXZlbnRfbnVtKSB7CiAJCWlmIChkZWJ1Z19tYXNrICYgREVC VUdfU1VTUEVORCkKLQkJCXByX2luZm8oInN1c3BlbmQ6IGVudGVyIHN1c3BlbmRcbiIpOwotCQly ZXQgPSBwbV9zdXNwZW5kKHJlcXVlc3RlZF9zdXNwZW5kX3N0YXRlKTsKLQkJaWYgKGRlYnVnX21h c2sgJiBERUJVR19FWElUX1NVU1BFTkQpCi0JCQlwcl9pbmZvX3RpbWUoInN1c3BlbmQ6IGV4aXQg c3VzcGVuZCwgcmV0ID0gJWQgIiwgcmV0KTsKLQkJaWYgKGN1cnJlbnRfZXZlbnRfbnVtID09IGVu dHJ5X2V2ZW50X251bSkKIAkJCXByX2luZm8oInN1c3BlbmQ6IHBtX3N1c3BlbmQgcmV0dXJuZWQg d2l0aCBubyBldmVudFxuIik7CisJCXN1c3BlbmRfYmxvY2soJnVua25vd25fd2FrZXVwKTsKKwkJ c3VzcGVuZF91bmJsb2NrKCZ1bmtub3duX3dha2V1cCk7CiAJfQorYWJvcnQ6CiAJZW5hYmxlX3N1 c3BlbmRfYmxvY2tlcnMgPSBmYWxzZTsKIH0KIHN0YXRpYyBERUNMQVJFX1dPUksoc3VzcGVuZF93 b3JrLCBzdXNwZW5kX3dvcmtlcik7CkBAIC0xMzcsNiArMjk4LDcgQEAgdm9pZCBzdXNwZW5kX2Js b2NrZXJfaW5pdChzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2VyICpibG9ja2VyLCBjb25zdCBjaGFyICpu YW1lKQogCUlOSVRfTElTVF9IRUFEKCZibG9ja2VyLT5saW5rKTsKIAogCXNwaW5fbG9ja19pcnFz YXZlKCZsaXN0X2xvY2ssIGlycWZsYWdzKTsKKwlzdXNwZW5kX2Jsb2NrZXJfc3RhdF9pbml0X2xv Y2tlZChibG9ja2VyKTsKIAlsaXN0X2FkZCgmYmxvY2tlci0+bGluaywgJmluYWN0aXZlX2Jsb2Nr ZXJzKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsaXN0X2xvY2ssIGlycWZsYWdzKTsKIH0K QEAgLTE1NCw2ICszMTYsNyBAQCB2b2lkIHN1c3BlbmRfYmxvY2tlcl9kZXN0cm95KHN0cnVjdCBz dXNwZW5kX2Jsb2NrZXIgKmJsb2NrZXIpCiAJaWYgKGRlYnVnX21hc2sgJiBERUJVR19TVVNQRU5E X0JMT0NLRVIpCiAJCXByX2luZm8oInN1c3BlbmRfYmxvY2tlcl9kZXN0cm95IG5hbWU9JXNcbiIs IGJsb2NrZXItPm5hbWUpOwogCXNwaW5fbG9ja19pcnFzYXZlKCZsaXN0X2xvY2ssIGlycWZsYWdz KTsKKwlzdXNwZW5kX2Jsb2NrZXJfc3RhdF9kZXN0cm95X2xvY2tlZChibG9ja2VyKTsKIAlibG9j a2VyLT5mbGFncyAmPSB+U0JfSU5JVElBTElaRUQ7CiAJbGlzdF9kZWwoJmJsb2NrZXItPmxpbmsp OwogCWlmICgoYmxvY2tlci0+ZmxhZ3MgJiBTQl9BQ1RJVkUpICYmIGxpc3RfZW1wdHkoJmFjdGl2 ZV9ibG9ja2VycykpCkBAIC0xNzQsNiArMzM3LDcgQEAgdm9pZCBzdXNwZW5kX2Jsb2NrKHN0cnVj dCBzdXNwZW5kX2Jsb2NrZXIgKmJsb2NrZXIpCiAJCXJldHVybjsKIAogCXNwaW5fbG9ja19pcnFz YXZlKCZsaXN0X2xvY2ssIGlycWZsYWdzKTsKKwlzdXNwZW5kX2Jsb2NrX3N0YXRfbG9ja2VkKGJs b2NrZXIpOwogCWJsb2NrZXItPmZsYWdzIHw9IFNCX0FDVElWRTsKIAlsaXN0X2RlbCgmYmxvY2tl ci0+bGluayk7CiAJaWYgKGRlYnVnX21hc2sgJiBERUJVR19TVVNQRU5EX0JMT0NLRVIpCkBAIC0x ODEsNiArMzQ1LDEwIEBAIHZvaWQgc3VzcGVuZF9ibG9jayhzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2Vy ICpibG9ja2VyKQogCWxpc3RfYWRkKCZibG9ja2VyLT5saW5rLCAmYWN0aXZlX2Jsb2NrZXJzKTsK IAogCWN1cnJlbnRfZXZlbnRfbnVtKys7CisJaWYgKGJsb2NrZXIgPT0gJm1haW5fc3VzcGVuZF9i bG9ja2VyKQorCQl1cGRhdGVfc2xlZXBfd2FpdF9zdGF0c19sb2NrZWQodHJ1ZSk7CisJZWxzZSBp ZiAoIXN1c3BlbmRfYmxvY2tlcl9pc19hY3RpdmUoJm1haW5fc3VzcGVuZF9ibG9ja2VyKSkKKwkJ dXBkYXRlX3NsZWVwX3dhaXRfc3RhdHNfbG9ja2VkKGZhbHNlKTsKIAlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZsaXN0X2xvY2ssIGlycWZsYWdzKTsKIH0KIEVYUE9SVF9TWU1CT0woc3VzcGVuZF9i bG9jayk7CkBAIC0yMDAsNiArMzY4LDggQEAgdm9pZCBzdXNwZW5kX3VuYmxvY2soc3RydWN0IHN1 c3BlbmRfYmxvY2tlciAqYmxvY2tlcikKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZsaXN0X2xvY2ss IGlycWZsYWdzKTsKIAorCXN1c3BlbmRfdW5ibG9ja19zdGF0X2xvY2tlZChibG9ja2VyKTsKKwog CWlmIChkZWJ1Z19tYXNrICYgREVCVUdfU1VTUEVORF9CTE9DS0VSKQogCQlwcl9pbmZvKCJzdXNw ZW5kX3VuYmxvY2s6ICVzXG4iLCBibG9ja2VyLT5uYW1lKTsKIAlsaXN0X2RlbCgmYmxvY2tlci0+ bGluayk7CkBAIC0yMTEsNiArMzgxLDcgQEAgdm9pZCBzdXNwZW5kX3VuYmxvY2soc3RydWN0IHN1 c3BlbmRfYmxvY2tlciAqYmxvY2tlcikKIAlpZiAoYmxvY2tlciA9PSAmbWFpbl9zdXNwZW5kX2Js b2NrZXIpIHsKIAkJaWYgKGRlYnVnX21hc2sgJiBERUJVR19TVVNQRU5EKQogCQkJcHJpbnRfYWN0 aXZlX2Jsb2NrZXJzX2xvY2tlZCgpOworCQl1cGRhdGVfc2xlZXBfd2FpdF9zdGF0c19sb2NrZWQo ZmFsc2UpOwogCX0KIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZsaXN0X2xvY2ssIGlycWZsYWdz KTsKIH0KQEAgLTI3OCw2ICs0NDksMTEgQEAgc3RhdGljIGludCBfX2luaXQgc3VzcGVuZF9ibG9j a19pbml0KHZvaWQpCiAKIAlzdXNwZW5kX2Jsb2NrZXJfaW5pdCgmbWFpbl9zdXNwZW5kX2Jsb2Nr ZXIsICJtYWluIik7CiAJc3VzcGVuZF9ibG9jaygmbWFpbl9zdXNwZW5kX2Jsb2NrZXIpOworCXN1 c3BlbmRfYmxvY2tlcl9pbml0KCZ1bmtub3duX3dha2V1cCwgInVua25vd25fd2FrZXVwcyIpOwor I2lmZGVmIENPTkZJR19TVVNQRU5EX0JMT0NLRVJfU1RBVFMKKwlzdXNwZW5kX2Jsb2NrZXJfaW5p dCgmZGVsZXRlZF9zdXNwZW5kX2Jsb2NrZXJzLAorCQkJCSJkZWxldGVkX3N1c3BlbmRfYmxvY2tl cnMiKTsKKyNlbmRpZgogCXJldHVybiAwOwogfQogCi0tIAoxLjYuNS4xCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1wbSBtYWlsaW5nIGxpc3QK bGludXgtcG1AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eC1m b3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXBt From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754796Ab0DWBLb (ORCPT ); Thu, 22 Apr 2010 21:11:31 -0400 Received: from mail-gy0-f174.google.com ([209.85.160.174]:48107 "EHLO mail-gy0-f174.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754712Ab0DWBKO (ORCPT ); Thu, 22 Apr 2010 21:10:14 -0400 From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= To: linux-pm@lists.linux-foundation.org, linux-kernel@vger.kernel.org Cc: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Pavel Machek , "Rafael J. Wysocki" , Len Brown , Jesse Barnes , Magnus Damm , Wu Fengguang , Andrew Morton , Maxim Levitsky Subject: [PATCH 6/9] PM: suspend_block: Add suspend_blocker stats Date: Thu, 22 Apr 2010 18:08:55 -0700 Message-Id: <1271984938-13920-7-git-send-email-arve@android.com> X-Mailer: git-send-email 1.6.5.1 In-Reply-To: <1271984938-13920-6-git-send-email-arve@android.com> References: <1271984938-13920-1-git-send-email-arve@android.com> <1271984938-13920-2-git-send-email-arve@android.com> <1271984938-13920-3-git-send-email-arve@android.com> <1271984938-13920-4-git-send-email-arve@android.com> <1271984938-13920-5-git-send-email-arve@android.com> <1271984938-13920-6-git-send-email-arve@android.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Report suspend block stats in /sys/kernel/debug/suspend_blockers. Signed-off-by: Arve Hjønnevåg --- include/linux/suspend_blocker.h | 21 ++++- kernel/power/Kconfig | 7 ++ kernel/power/power.h | 6 +- kernel/power/suspend.c | 4 +- kernel/power/suspend_blocker.c | 190 +++++++++++++++++++++++++++++++++++++-- 5 files changed, 218 insertions(+), 10 deletions(-) diff --git a/include/linux/suspend_blocker.h b/include/linux/suspend_blocker.h index 1faa433..3bb8a6a 100755 --- a/include/linux/suspend_blocker.h +++ b/include/linux/suspend_blocker.h @@ -17,12 +17,21 @@ #define _LINUX_SUSPEND_BLOCKER_H #include +#include /** * struct suspend_blocker - the basic suspend_blocker structure * @link: List entry for active or inactive list. - * @flags: Tracks initialized and active state. + * @flags: Tracks initialized, active and stats state. * @name: Name used for debugging. + * @count: Number of times this blocker has been deacivated + * @wakeup_count: Number of times this blocker was the first to block suspend + * after resume. + * @total_time: Total time this suspend blocker has prevented suspend. + * @prevent_suspend_time: Time this suspend blocker has prevented suspend while + * user-space requested suspend. + * @max_time: Max time this suspend blocker has been continuously active + * @last_time: Monotonic clock when the active state last changed. * * When a suspend_blocker is active it prevents the system from entering * suspend. @@ -35,6 +44,16 @@ struct suspend_blocker { struct list_head link; int flags; const char *name; +#ifdef CONFIG_SUSPEND_BLOCKER_STATS + struct { + int count; + int wakeup_count; + ktime_t total_time; + ktime_t prevent_suspend_time; + ktime_t max_time; + ktime_t last_time; + } stat; +#endif #endif }; diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 1ac50ee..3fa2d33 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -141,6 +141,13 @@ config SUSPEND_BLOCKERS state through /sys/power/state, the requested sleep state will be entered when no suspend blockers are active. +config SUSPEND_BLOCKER_STATS + bool "Suspend block stats" + depends on SUSPEND_BLOCKERS + default y + ---help--- + Report suspend block stats in /sys/kernel/debug/suspend_blockers + config USER_SUSPEND_BLOCKERS bool "Userspace suspend blockers" depends on SUSPEND_BLOCKERS diff --git a/kernel/power/power.h b/kernel/power/power.h index 9b468d7..75b8849 100644 --- a/kernel/power/power.h +++ b/kernel/power/power.h @@ -240,4 +240,8 @@ static inline void suspend_thaw_processes(void) /* kernel/power/suspend_block.c */ extern int request_suspend_state(suspend_state_t state); extern bool request_suspend_valid_state(suspend_state_t state); - +#ifdef CONFIG_SUSPEND_BLOCKER_STATS +void about_to_enter_suspend(void); +#else +static inline void about_to_enter_suspend(void) {} +#endif diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c index dc42006..6d327ea 100644 --- a/kernel/power/suspend.c +++ b/kernel/power/suspend.c @@ -159,8 +159,10 @@ static int suspend_enter(suspend_state_t state) error = sysdev_suspend(PMSG_SUSPEND); if (!error) { - if (!suspend_is_blocked() && !suspend_test(TEST_CORE)) + if (!suspend_is_blocked() && !suspend_test(TEST_CORE)) { + about_to_enter_suspend(); error = suspend_ops->enter(state); + } sysdev_resume(); } diff --git a/kernel/power/suspend_blocker.c b/kernel/power/suspend_blocker.c index 047e910..08d18c2 100644 --- a/kernel/power/suspend_blocker.c +++ b/kernel/power/suspend_blocker.c @@ -32,6 +32,7 @@ module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP); #define SB_INITIALIZED (1U << 8) #define SB_ACTIVE (1U << 9) +#define SB_PREVENTING_SUSPEND (1U << 10) static DEFINE_SPINLOCK(list_lock); static DEFINE_SPINLOCK(state_lock); @@ -42,6 +43,7 @@ struct workqueue_struct *suspend_work_queue; struct suspend_blocker main_suspend_blocker; static suspend_state_t requested_suspend_state = PM_SUSPEND_MEM; static bool enable_suspend_blockers; +static struct suspend_blocker unknown_wakeup; static struct dentry *suspend_blocker_stats_dentry; #define pr_info_time(fmt, args...) \ @@ -56,6 +58,153 @@ static struct dentry *suspend_blocker_stats_dentry; tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec); \ } while (0); +#ifdef CONFIG_SUSPEND_BLOCKER_STATS +static struct suspend_blocker deleted_suspend_blockers; +static ktime_t last_sleep_time_update; +static bool wait_for_wakeup; + +static int print_blocker_stat(struct seq_file *m, + struct suspend_blocker *blocker) +{ + int lock_count = blocker->stat.count; + ktime_t active_time = ktime_set(0, 0); + ktime_t total_time = blocker->stat.total_time; + ktime_t max_time = blocker->stat.max_time; + ktime_t prevent_suspend_time = blocker->stat.prevent_suspend_time; + if (blocker->flags & SB_ACTIVE) { + ktime_t now, add_time; + now = ktime_get(); + add_time = ktime_sub(now, blocker->stat.last_time); + lock_count++; + active_time = add_time; + total_time = ktime_add(total_time, add_time); + if (blocker->flags & SB_PREVENTING_SUSPEND) + prevent_suspend_time = ktime_add(prevent_suspend_time, + ktime_sub(now, last_sleep_time_update)); + if (add_time.tv64 > max_time.tv64) + max_time = add_time; + } + + return seq_printf(m, "\"%s\"\t%d\t%d\t%lld\t%lld\t%lld\t%lld\t%lld\n", + blocker->name, lock_count, blocker->stat.wakeup_count, + ktime_to_ns(active_time), ktime_to_ns(total_time), + ktime_to_ns(prevent_suspend_time), ktime_to_ns(max_time), + ktime_to_ns(blocker->stat.last_time)); +} + + +static int suspend_blocker_stats_show(struct seq_file *m, void *unused) +{ + unsigned long irqflags; + struct suspend_blocker *blocker; + + seq_puts(m, "name\tcount\twake_count\tactive_since" + "\ttotal_time\tsleep_time\tmax_time\tlast_change\n"); + spin_lock_irqsave(&list_lock, irqflags); + list_for_each_entry(blocker, &inactive_blockers, link) + print_blocker_stat(m, blocker); + list_for_each_entry(blocker, &active_blockers, link) + print_blocker_stat(m, blocker); + spin_unlock_irqrestore(&list_lock, irqflags); + return 0; +} + +static void suspend_blocker_stat_init_locked(struct suspend_blocker *blocker) +{ + blocker->stat.count = 0; + blocker->stat.wakeup_count = 0; + blocker->stat.total_time = ktime_set(0, 0); + blocker->stat.prevent_suspend_time = ktime_set(0, 0); + blocker->stat.max_time = ktime_set(0, 0); + blocker->stat.last_time = ktime_set(0, 0); +} + +static void suspend_blocker_stat_destroy_locked(struct suspend_blocker *bl) +{ + if (!bl->stat.count) + return; + deleted_suspend_blockers.stat.count += bl->stat.count; + deleted_suspend_blockers.stat.total_time = ktime_add( + deleted_suspend_blockers.stat.total_time, bl->stat.total_time); + deleted_suspend_blockers.stat.prevent_suspend_time = ktime_add( + deleted_suspend_blockers.stat.prevent_suspend_time, + bl->stat.prevent_suspend_time); + deleted_suspend_blockers.stat.max_time = ktime_add( + deleted_suspend_blockers.stat.max_time, bl->stat.max_time); +} + +static void suspend_unblock_stat_locked(struct suspend_blocker *blocker) +{ + ktime_t duration; + ktime_t now; + if (!(blocker->flags & SB_ACTIVE)) + return; + now = ktime_get(); + blocker->stat.count++; + duration = ktime_sub(now, blocker->stat.last_time); + blocker->stat.total_time = + ktime_add(blocker->stat.total_time, duration); + if (ktime_to_ns(duration) > ktime_to_ns(blocker->stat.max_time)) + blocker->stat.max_time = duration; + blocker->stat.last_time = ktime_get(); + if (blocker->flags & SB_PREVENTING_SUSPEND) { + duration = ktime_sub(now, last_sleep_time_update); + blocker->stat.prevent_suspend_time = ktime_add( + blocker->stat.prevent_suspend_time, duration); + blocker->flags &= ~SB_PREVENTING_SUSPEND; + } +} + +static void suspend_block_stat_locked(struct suspend_blocker *blocker) +{ + if (wait_for_wakeup) { + if (debug_mask & DEBUG_WAKEUP) + pr_info("wakeup suspend blocker: %s\n", blocker->name); + wait_for_wakeup = false; + blocker->stat.wakeup_count++; + } + if (!(blocker->flags & SB_ACTIVE)) + blocker->stat.last_time = ktime_get(); +} + +static void update_sleep_wait_stats_locked(bool done) +{ + struct suspend_blocker *blocker; + ktime_t now, elapsed, add; + + now = ktime_get(); + elapsed = ktime_sub(now, last_sleep_time_update); + list_for_each_entry(blocker, &active_blockers, link) { + if (blocker->flags & SB_PREVENTING_SUSPEND) { + add = elapsed; + blocker->stat.prevent_suspend_time = ktime_add( + blocker->stat.prevent_suspend_time, add); + } + if (done) + blocker->flags &= ~SB_PREVENTING_SUSPEND; + else + blocker->flags |= SB_PREVENTING_SUSPEND; + } + last_sleep_time_update = now; +} + +void about_to_enter_suspend(void) +{ + wait_for_wakeup = true; +} + +#else + +static inline void suspend_blocker_stat_init_locked( + struct suspend_blocker *blocker) {} +static inline void suspend_blocker_stat_destroy_locked( + struct suspend_blocker *blocker) {} +static inline void suspend_block_stat_locked( + struct suspend_blocker *blocker) {} +static inline void suspend_unblock_stat_locked( + struct suspend_blocker *blocker) {} +static inline void update_sleep_wait_stats_locked(bool done) {} + static int suspend_blocker_stats_show(struct seq_file *m, void *unused) { unsigned long irqflags; @@ -71,6 +220,8 @@ static int suspend_blocker_stats_show(struct seq_file *m, void *unused) return 0; } +#endif + static void print_active_blockers_locked(void) { struct suspend_blocker *blocker; @@ -101,16 +252,26 @@ static void suspend_worker(struct work_struct *work) int entry_event_num; enable_suspend_blockers = true; - while (!suspend_is_blocked()) { - entry_event_num = current_event_num; + + if (suspend_is_blocked()) { + if (debug_mask & DEBUG_SUSPEND) + pr_info("suspend: abort suspend\n"); + goto abort; + } + + entry_event_num = current_event_num; + if (debug_mask & DEBUG_SUSPEND) + pr_info("suspend: enter suspend\n"); + ret = pm_suspend(requested_suspend_state); + if (debug_mask & DEBUG_EXIT_SUSPEND) + pr_info_time("suspend: exit suspend, ret = %d ", ret); + if (current_event_num == entry_event_num) { if (debug_mask & DEBUG_SUSPEND) - pr_info("suspend: enter suspend\n"); - ret = pm_suspend(requested_suspend_state); - if (debug_mask & DEBUG_EXIT_SUSPEND) - pr_info_time("suspend: exit suspend, ret = %d ", ret); - if (current_event_num == entry_event_num) pr_info("suspend: pm_suspend returned with no event\n"); + suspend_block(&unknown_wakeup); + suspend_unblock(&unknown_wakeup); } +abort: enable_suspend_blockers = false; } static DECLARE_WORK(suspend_work, suspend_worker); @@ -137,6 +298,7 @@ void suspend_blocker_init(struct suspend_blocker *blocker, const char *name) INIT_LIST_HEAD(&blocker->link); spin_lock_irqsave(&list_lock, irqflags); + suspend_blocker_stat_init_locked(blocker); list_add(&blocker->link, &inactive_blockers); spin_unlock_irqrestore(&list_lock, irqflags); } @@ -154,6 +316,7 @@ void suspend_blocker_destroy(struct suspend_blocker *blocker) if (debug_mask & DEBUG_SUSPEND_BLOCKER) pr_info("suspend_blocker_destroy name=%s\n", blocker->name); spin_lock_irqsave(&list_lock, irqflags); + suspend_blocker_stat_destroy_locked(blocker); blocker->flags &= ~SB_INITIALIZED; list_del(&blocker->link); if ((blocker->flags & SB_ACTIVE) && list_empty(&active_blockers)) @@ -174,6 +337,7 @@ void suspend_block(struct suspend_blocker *blocker) return; spin_lock_irqsave(&list_lock, irqflags); + suspend_block_stat_locked(blocker); blocker->flags |= SB_ACTIVE; list_del(&blocker->link); if (debug_mask & DEBUG_SUSPEND_BLOCKER) @@ -181,6 +345,10 @@ void suspend_block(struct suspend_blocker *blocker) list_add(&blocker->link, &active_blockers); current_event_num++; + if (blocker == &main_suspend_blocker) + update_sleep_wait_stats_locked(true); + else if (!suspend_blocker_is_active(&main_suspend_blocker)) + update_sleep_wait_stats_locked(false); spin_unlock_irqrestore(&list_lock, irqflags); } EXPORT_SYMBOL(suspend_block); @@ -200,6 +368,8 @@ void suspend_unblock(struct suspend_blocker *blocker) spin_lock_irqsave(&list_lock, irqflags); + suspend_unblock_stat_locked(blocker); + if (debug_mask & DEBUG_SUSPEND_BLOCKER) pr_info("suspend_unblock: %s\n", blocker->name); list_del(&blocker->link); @@ -211,6 +381,7 @@ void suspend_unblock(struct suspend_blocker *blocker) if (blocker == &main_suspend_blocker) { if (debug_mask & DEBUG_SUSPEND) print_active_blockers_locked(); + update_sleep_wait_stats_locked(false); } spin_unlock_irqrestore(&list_lock, irqflags); } @@ -278,6 +449,11 @@ static int __init suspend_block_init(void) suspend_blocker_init(&main_suspend_blocker, "main"); suspend_block(&main_suspend_blocker); + suspend_blocker_init(&unknown_wakeup, "unknown_wakeups"); +#ifdef CONFIG_SUSPEND_BLOCKER_STATS + suspend_blocker_init(&deleted_suspend_blockers, + "deleted_suspend_blockers"); +#endif return 0; } -- 1.6.5.1