From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= Subject: [PATCH 6/8] PM: Add suspend blocking work. Date: Fri, 30 Apr 2010 15:36:59 -0700 Message-ID: <1272667021-21312-7-git-send-email-arve@android.com> References: <1272667021-21312-1-git-send-email-arve@android.com> <1272667021-21312-2-git-send-email-arve@android.com> <1272667021-21312-3-git-send-email-arve@android.com> <1272667021-21312-4-git-send-email-arve@android.com> <1272667021-21312-5-git-send-email-arve@android.com> <1272667021-21312-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: <1272667021-21312-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 , Oleg Nesterov , Tejun Heo List-Id: linux-pm@vger.kernel.org QWxsb3cgd29yayB0byBiZSBxdWV1ZWQgdGhhdCB3aWxsIGJsb2NrIHN1c3BlbmQgd2hpbGUgaXQg aXMgcGVuZGluZwpvciBleGVjdXRpbmcuIFRvIGdldCB0aGUgc2FtZSBmdW5jdGlvbmFsaXR5IGlu IHRoZSBjYWxsaW5nIGNvZGUgb2Z0ZW4KcmVxdWlyZXMgYSBzZXBhcmF0ZSBzdXNwZW5kX2Jsb2Nr ZXIgZm9yIHBlbmRpbmcgYW5kIGV4ZWN1dGluZyB3b3JrLCBvcgphZGRpdGlvbmFsIHN0YXRlIGFu ZCBsb2NraW5nLiBUaGlzIGltcGxlbWVudGF0aW9uIGRvZXMgYWRkIGFkZGl0aW9uYWwKc3RhdGUg YW5kIGxvY2tpbmcsIGJ1dCB0aGlzIGNhbiBiZSByZW1vdmVkIGxhdGVyIGlmIHdlIGFkZCBzdXBw b3J0IGZvcgpzdXNwZW5kIGJsb2NraW5nIHdvcmsgdG8gdGhlIGNvcmUgd29ya3F1ZXVlIGNvZGUu CgpTaWduZWQtb2ZmLWJ5OiBBcnZlIEhqw7hubmV2w6VnIDxhcnZlQGFuZHJvaWQuY29tPgotLS0K IGluY2x1ZGUvbGludXgvc3VzcGVuZF9ibG9ja2VyLmggfCAgIDY3ICsrKysrKysrKysrKysrKysr KysrKysrKwoga2VybmVsL3Bvd2VyL3N1c3BlbmRfYmxvY2tlci5jICB8ICAxMDkgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDE3NiBpbnNl cnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3Vz cGVuZF9ibG9ja2VyLmggYi9pbmNsdWRlL2xpbnV4L3N1c3BlbmRfYmxvY2tlci5oCmluZGV4IGM4 MDc2NGMuLmJmNDFhNTcgMTAwNzU1Ci0tLSBhL2luY2x1ZGUvbGludXgvc3VzcGVuZF9ibG9ja2Vy LmgKKysrIGIvaW5jbHVkZS9saW51eC9zdXNwZW5kX2Jsb2NrZXIuaApAQCAtMTgsNiArMTgsNyBA QAogCiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L2t0aW1lLmg+Cisj aW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAKIC8qKgogICogc3RydWN0IHN1c3BlbmRfYmxv Y2tlciAtIHRoZSBiYXNpYyBzdXNwZW5kX2Jsb2NrZXIgc3RydWN0dXJlCkBAIC01Nyw2ICs1OCwz OCBAQCBzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2VyIHsKICNlbmRpZgogfTsKIAorLyoqCisgKiBzdHJ1 Y3Qgc3VzcGVuZF9ibG9ja2luZ193b3JrIC0gdGhlIGJhc2ljIHN1c3BlbmRfYmxvY2tpbmdfd29y ayBzdHJ1Y3R1cmUKKyAqIEB3b3JrOgkJU3RhbmRhcmQgd29yayBzdHJ1Y3QuCisgKiBAc3VzcGVu ZF9ibG9ja2VyOglTdXNwZW5kIGJsb2NrZXIuCisgKiBAZnVuYzoJCUNhbGxiYWNrLgorICogQGxv Y2s6CQlTcGlubG9jayBwcm90ZWN0aW5nIHBlbmRpbmcgYW5kIHJ1bm5pbmcgc3RhdGUuCisgKiBA YWN0aXZlOgkJTnVtYmVyIG9mIGNwdSB3b3JrcXVldWVzIHdoZXJlIHdvcmsgaXMgcGVuZGluZyBv cgorICoJCQljYWxsYmFjayBpcyBydW5uaW5nLgorICoKKyAqIFdoZW4gc3VzcGVuZCBibG9ja2lu ZyB3b3JrIGlzIHBlbmRpbmcgb3IgaXRzIGNhbGxiYWNrIGlzIHJ1bm5pbmcgaXQgcHJldmVudHMK KyAqIHRoZSBzeXN0ZW0gZnJvbSBlbnRlcmluZyBvcHBvcnR1bmlzdGljIHN1c3BlbmQuCisgKgor ICogVGhlIHN1c3BlbmRfYmxvY2tpbmdfd29yayBzdHJ1Y3R1cmUgbXVzdCBiZSBpbml0aWFsaXpl ZCBieQorICogc3VzcGVuZF9ibG9ja2luZ193b3JrX2luaXQoKS4KKyAqLworCitzdHJ1Y3Qgc3Vz cGVuZF9ibG9ja2luZ193b3JrIHsKKwlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgd29yazsKKyNpZmRlZiBD T05GSUdfT1BQT1JUVU5JU1RJQ19TVVNQRU5ECisJc3RydWN0IHN1c3BlbmRfYmxvY2tlciBzdXNw ZW5kX2Jsb2NrZXI7CisJd29ya19mdW5jX3QgZnVuYzsKKwlzcGlubG9ja190IGxvY2s7CisJaW50 IGFjdGl2ZTsKKyNlbmRpZgorfTsKKworc3RhdGljIGlubGluZSBzdHJ1Y3Qgc3VzcGVuZF9ibG9j a2luZ193b3JrICp0b19zdXNwZW5kX2Jsb2NraW5nX3dvcmsoCisJc3RydWN0IHdvcmtfc3RydWN0 ICp3b3JrKQoreworCXJldHVybiBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHN1c3BlbmRfYmxv Y2tpbmdfd29yaywgd29yayk7Cit9CisKICNpZmRlZiBDT05GSUdfT1BQT1JUVU5JU1RJQ19TVVNQ RU5ECiAKIHZvaWQgc3VzcGVuZF9ibG9ja2VyX2luaXQoc3RydWN0IHN1c3BlbmRfYmxvY2tlciAq YmxvY2tlciwgY29uc3QgY2hhciAqbmFtZSk7CkBAIC02Niw2ICs5OSwxNCBAQCB2b2lkIHN1c3Bl bmRfdW5ibG9jayhzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2VyICpibG9ja2VyKTsKIGJvb2wgc3VzcGVu ZF9ibG9ja2VyX2lzX2FjdGl2ZShzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2VyICpibG9ja2VyKTsKIGJv b2wgc3VzcGVuZF9pc19ibG9ja2VkKHZvaWQpOwogCit2b2lkIHN1c3BlbmRfYmxvY2tpbmdfd29y a19pbml0KHN0cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dvcmsgKndvcmssCisJCQkJd29ya19mdW5j X3QgZnVuYywgY29uc3QgY2hhciAqbmFtZSk7Cit2b2lkIHN1c3BlbmRfYmxvY2tpbmdfd29ya19k ZXN0cm95KHN0cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dvcmsgKndvcmspOworaW50IHF1ZXVlX3N1 c3BlbmRfYmxvY2tpbmdfd29yayhzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqd3EsCisJCQkJc3Ry dWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqd29yayk7CitpbnQgc2NoZWR1bGVfc3VzcGVuZF9i bG9ja2luZ193b3JrKHN0cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dvcmsgKndvcmspOworaW50IGNh bmNlbF9zdXNwZW5kX2Jsb2NraW5nX3dvcmtfc3luYyhzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2luZ193 b3JrICp3b3JrKTsKKwogI2Vsc2UKIAogc3RhdGljIGlubGluZSB2b2lkIHN1c3BlbmRfYmxvY2tl cl9pbml0KHN0cnVjdCBzdXNwZW5kX2Jsb2NrZXIgKmJsb2NrZXIsCkBAIC03Nyw2ICsxMTgsMzIg QEAgc3RhdGljIGlubGluZSBib29sIHN1c3BlbmRfYmxvY2tlcl9pc19hY3RpdmUoc3RydWN0IHN1 c3BlbmRfYmxvY2tlciAqYmwpCiAJCQkJCQkJCXsgcmV0dXJuIDA7IH0KIHN0YXRpYyBpbmxpbmUg Ym9vbCBzdXNwZW5kX2lzX2Jsb2NrZWQodm9pZCkgeyByZXR1cm4gMDsgfQogCitzdGF0aWMgaW5s aW5lIHZvaWQgc3VzcGVuZF9ibG9ja2luZ193b3JrX2luaXQoCisJc3RydWN0IHN1c3BlbmRfYmxv Y2tpbmdfd29yayAqd29yaywgd29ya19mdW5jX3QgZnVuYywgY29uc3QgY2hhciAqbmFtZSkKK3sK KwlJTklUX1dPUksoJndvcmstPndvcmssIGZ1bmMpOworfQorc3RhdGljIGlubGluZSB2b2lkIHN1 c3BlbmRfYmxvY2tpbmdfd29ya19kZXN0cm95KAorCXN0cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dv cmsgKndvcmspCit7CisJY2FuY2VsX3dvcmtfc3luYygmd29yay0+d29yayk7Cit9CitzdGF0aWMg aW5saW5lIGludCBxdWV1ZV9zdXNwZW5kX2Jsb2NraW5nX3dvcmsoCisJc3RydWN0IHdvcmtxdWV1 ZV9zdHJ1Y3QgKndxLCBzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2luZ193b3JrICp3b3JrKQoreworCXJl dHVybiBxdWV1ZV93b3JrKHdxLCAmd29yay0+d29yayk7Cit9CitzdGF0aWMgaW5saW5lIGludCBz Y2hlZHVsZV9zdXNwZW5kX2Jsb2NraW5nX3dvcmsoCisJc3RydWN0IHN1c3BlbmRfYmxvY2tpbmdf d29yayAqd29yaykKK3sKKwlyZXR1cm4gc2NoZWR1bGVfd29yaygmd29yay0+d29yayk7Cit9Citz dGF0aWMgaW5saW5lIGludCBjYW5jZWxfc3VzcGVuZF9ibG9ja2luZ193b3JrX3N5bmMoCisJc3Ry dWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqd29yaykKK3sKKwlyZXR1cm4gY2FuY2VsX3dvcmtf c3luYygmd29yay0+d29yayk7Cit9CisKICNlbmRpZgogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2tl cm5lbC9wb3dlci9zdXNwZW5kX2Jsb2NrZXIuYyBiL2tlcm5lbC9wb3dlci9zdXNwZW5kX2Jsb2Nr ZXIuYwppbmRleCA3NzkyMGU2Li44NTJkOTQxIDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvc3Vz cGVuZF9ibG9ja2VyLmMKKysrIGIva2VybmVsL3Bvd2VyL3N1c3BlbmRfYmxvY2tlci5jCkBAIC00 NzQsMyArNDc0LDExMiBAQCBzdGF0aWMgaW50IF9faW5pdCBzdXNwZW5kX2Jsb2NrX3Bvc3Rjb3Jl X2luaXQodm9pZCkKIH0KIAogcG9zdGNvcmVfaW5pdGNhbGwoc3VzcGVuZF9ibG9ja19wb3N0Y29y ZV9pbml0KTsKKworc3RhdGljIHZvaWQgc3VzcGVuZF9ibG9ja2luZ193b3JrX2NvbXBsZXRlKHN0 cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dvcmsgKndvcmspCit7CisJdW5zaWduZWQgbG9uZyBmbGFn czsKKworCVdBUk5fT04oIXdvcmstPmFjdGl2ZSk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJndvcmst PmxvY2ssIGZsYWdzKTsKKwlpZiAoIS0td29yay0+YWN0aXZlKQorCQlzdXNwZW5kX3VuYmxvY2so JndvcmstPnN1c3BlbmRfYmxvY2tlcik7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmd29yay0+ bG9jaywgZmxhZ3MpOworfQorCitzdGF0aWMgdm9pZCBzdXNwZW5kX2Jsb2NraW5nX3dvcmtfZnVu YyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJc3RydWN0IHN1c3BlbmRfYmxvY2tpbmdf d29yayAqc2J3b3JrID0gdG9fc3VzcGVuZF9ibG9ja2luZ193b3JrKHdvcmspOworCisJc2J3b3Jr LT5mdW5jKHdvcmspOworCXN1c3BlbmRfYmxvY2tpbmdfd29ya19jb21wbGV0ZShzYndvcmspOwor fQorCisvKioKKyAqIHN1c3BlbmRfYmxvY2tpbmdfd29ya19pbml0IC0gSW5pdGlhbGl6ZSBzdXNw ZW5kX2Jsb2NraW5nX3dvcmsKKyAqIEB3b3JrOiBUaGUgd29yayBpdGVtIGluIHF1ZXN0aW9uLgor ICogQGZ1bmM6IENhbGxiYWNrLgorICogQG5hbWU6IE5hbWUgZm9yIHN1c3BlbmQgYmxvY2tlci4K KyAqCisgKi8KK3ZvaWQgc3VzcGVuZF9ibG9ja2luZ193b3JrX2luaXQoc3RydWN0IHN1c3BlbmRf YmxvY2tpbmdfd29yayAqd29yaywKKwkJCQl3b3JrX2Z1bmNfdCBmdW5jLCBjb25zdCBjaGFyICpu YW1lKQoreworCUlOSVRfV09SSygmd29yay0+d29yaywgc3VzcGVuZF9ibG9ja2luZ193b3JrX2Z1 bmMpOworCXN1c3BlbmRfYmxvY2tlcl9pbml0KCZ3b3JrLT5zdXNwZW5kX2Jsb2NrZXIsIG5hbWUp OworCXdvcmstPmZ1bmMgPSBmdW5jOworCXNwaW5fbG9ja19pbml0KCZ3b3JrLT5sb2NrKTsKKwl3 b3JrLT5hY3RpdmUgPSAwOworfQorRVhQT1JUX1NZTUJPTF9HUEwoc3VzcGVuZF9ibG9ja2luZ193 b3JrX2luaXQpOworCisvKioKKyAqIGNhbmNlbF9zdXNwZW5kX2Jsb2NraW5nX3dvcmtfc3luYyAt IENhbmNlbCBzdXNwZW5kX2Jsb2NraW5nX3dvcmsKKyAqIEB3b3JrOiBUaGUgd29yayBpdGVtIGlu IHF1ZXN0aW9uCisgKi8KK2ludCBjYW5jZWxfc3VzcGVuZF9ibG9ja2luZ193b3JrX3N5bmMoc3Ry dWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqd29yaykKK3sKKwlpbnQgcmV0OworCisJcmV0ID0g Y2FuY2VsX3dvcmtfc3luYygmd29yay0+d29yayk7CisJaWYgKHJldCkKKwkJc3VzcGVuZF9ibG9j a2luZ193b3JrX2NvbXBsZXRlKHdvcmspOworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9M X0dQTChjYW5jZWxfc3VzcGVuZF9ibG9ja2luZ193b3JrX3N5bmMpOworCisvKioKKyAqIHN1c3Bl bmRfYmxvY2tpbmdfd29ya19kZXN0cm95IC0gRGVzdHJveSBzdXNwZW5kX2Jsb2NraW5nX3dvcmsK KyAqIEB3b3JrOiBUaGUgd29yayBpdGVtIGluIHF1ZXN0aW9uCisgKgorICogSWYgdGhlIHdvcmsg d2FzIGV2ZXIgcXVldWVkIG9uIG1vcmUgdGhlbiBvbmUgd29ya3F1ZXVlIGFsbCBidXQgdGhlIGxh c3QKKyAqIHdvcmtxdWV1ZSBtdXN0IGJlIGZsdXNoZWQgYmVmb3JlIGNhbGxpbmcgc3VzcGVuZF9i bG9ja2luZ193b3JrX2Rlc3Ryb3kuCisgKi8KK3ZvaWQgc3VzcGVuZF9ibG9ja2luZ193b3JrX2Rl c3Ryb3koc3RydWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqd29yaykKK3sKKwljYW5jZWxfc3Vz cGVuZF9ibG9ja2luZ193b3JrX3N5bmMod29yayk7CisJV0FSTl9PTih3b3JrLT5hY3RpdmUpOwor CXN1c3BlbmRfYmxvY2tlcl9kZXN0cm95KCZ3b3JrLT5zdXNwZW5kX2Jsb2NrZXIpOworfQorRVhQ T1JUX1NZTUJPTF9HUEwoc3VzcGVuZF9ibG9ja2luZ193b3JrX2Rlc3Ryb3kpOworCisvKioKKyAq IHF1ZXVlX3N1c3BlbmRfYmxvY2tpbmdfd29yayAtIFF1ZXVlIHN1c3BlbmQgYmxvY2tpbmcgd29y aworICogQHdxOgkJV29ya3F1ZXVlIHRvIHF1ZXVlIHdvcmsgb24uCisgKiBAd29yazoJVGhlIHdv cmsgaXRlbSBpbiBxdWVzdGlvbi4KKyAqLworaW50IHF1ZXVlX3N1c3BlbmRfYmxvY2tpbmdfd29y ayhzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqd3EsCisJCQkJc3RydWN0IHN1c3BlbmRfYmxvY2tp bmdfd29yayAqd29yaykKK3sKKwlpbnQgcmV0OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlz cGluX2xvY2tfaXJxc2F2ZSgmd29yay0+bG9jaywgZmxhZ3MpOworCXJldCA9IHF1ZXVlX3dvcmso d3EsICZ3b3JrLT53b3JrKTsKKwlpZiAocmV0KSB7CisJCXN1c3BlbmRfYmxvY2soJndvcmstPnN1 c3BlbmRfYmxvY2tlcik7CisJCXdvcmstPmFjdGl2ZSsrOworCX0KKwlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZ3b3JrLT5sb2NrLCBmbGFncyk7CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1C T0xfR1BMKHF1ZXVlX3N1c3BlbmRfYmxvY2tpbmdfd29yayk7CisKKy8qKgorICogc2NoZWR1bGVf c3VzcGVuZF9ibG9ja2luZ193b3JrIC0gUXVldWUgc3VzcGVuZCBibG9ja2luZyB3b3JrCisgKiBA d29yazoJVGhlIHdvcmsgaXRlbSBpbiBxdWVzdGlvbi4KKyAqLworaW50IHNjaGVkdWxlX3N1c3Bl bmRfYmxvY2tpbmdfd29yayhzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2luZ193b3JrICp3b3JrKQorewor CWludCByZXQ7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZ3 b3JrLT5sb2NrLCBmbGFncyk7CisJcmV0ID0gc2NoZWR1bGVfd29yaygmd29yay0+d29yayk7CisJ aWYgKHJldCkgeworCQlzdXNwZW5kX2Jsb2NrKCZ3b3JrLT5zdXNwZW5kX2Jsb2NrZXIpOworCQl3 b3JrLT5hY3RpdmUrKzsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmd29yay0+bG9jaywg ZmxhZ3MpOworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChzY2hlZHVsZV9zdXNw ZW5kX2Jsb2NraW5nX3dvcmspOwotLSAKMS42LjUuMQoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcG0gbWFpbGluZyBsaXN0CmxpbnV4LXBtQGxp c3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXgtZm91bmRhdGlvbi5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1wbQ== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932356Ab0D3Wio (ORCPT ); Fri, 30 Apr 2010 18:38:44 -0400 Received: from mail-iw0-f182.google.com ([209.85.223.182]:36141 "EHLO mail-iw0-f182.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759853Ab0D3Whm (ORCPT ); Fri, 30 Apr 2010 18:37:42 -0400 From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= To: linux-pm@lists.linux-foundation.org, linux-kernel@vger.kernel.org Cc: "Rafael J. Wysocki" , Alan Stern , Tejun Heo , Oleg Nesterov , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Pavel Machek , Len Brown Subject: [PATCH 6/8] PM: Add suspend blocking work. Date: Fri, 30 Apr 2010 15:36:59 -0700 Message-Id: <1272667021-21312-7-git-send-email-arve@android.com> X-Mailer: git-send-email 1.6.5.1 In-Reply-To: <1272667021-21312-6-git-send-email-arve@android.com> References: <1272667021-21312-1-git-send-email-arve@android.com> <1272667021-21312-2-git-send-email-arve@android.com> <1272667021-21312-3-git-send-email-arve@android.com> <1272667021-21312-4-git-send-email-arve@android.com> <1272667021-21312-5-git-send-email-arve@android.com> <1272667021-21312-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 Allow work to be queued that will block suspend while it is pending or executing. To get the same functionality in the calling code often requires a separate suspend_blocker for pending and executing work, or additional state and locking. This implementation does add additional state and locking, but this can be removed later if we add support for suspend blocking work to the core workqueue code. Signed-off-by: Arve Hjønnevåg --- include/linux/suspend_blocker.h | 67 ++++++++++++++++++++++++ kernel/power/suspend_blocker.c | 109 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 176 insertions(+), 0 deletions(-) diff --git a/include/linux/suspend_blocker.h b/include/linux/suspend_blocker.h index c80764c..bf41a57 100755 --- a/include/linux/suspend_blocker.h +++ b/include/linux/suspend_blocker.h @@ -18,6 +18,7 @@ #include #include +#include /** * struct suspend_blocker - the basic suspend_blocker structure @@ -57,6 +58,38 @@ struct suspend_blocker { #endif }; +/** + * struct suspend_blocking_work - the basic suspend_blocking_work structure + * @work: Standard work struct. + * @suspend_blocker: Suspend blocker. + * @func: Callback. + * @lock: Spinlock protecting pending and running state. + * @active: Number of cpu workqueues where work is pending or + * callback is running. + * + * When suspend blocking work is pending or its callback is running it prevents + * the system from entering opportunistic suspend. + * + * The suspend_blocking_work structure must be initialized by + * suspend_blocking_work_init(). + */ + +struct suspend_blocking_work { + struct work_struct work; +#ifdef CONFIG_OPPORTUNISTIC_SUSPEND + struct suspend_blocker suspend_blocker; + work_func_t func; + spinlock_t lock; + int active; +#endif +}; + +static inline struct suspend_blocking_work *to_suspend_blocking_work( + struct work_struct *work) +{ + return container_of(work, struct suspend_blocking_work, work); +} + #ifdef CONFIG_OPPORTUNISTIC_SUSPEND void suspend_blocker_init(struct suspend_blocker *blocker, const char *name); @@ -66,6 +99,14 @@ void suspend_unblock(struct suspend_blocker *blocker); bool suspend_blocker_is_active(struct suspend_blocker *blocker); bool suspend_is_blocked(void); +void suspend_blocking_work_init(struct suspend_blocking_work *work, + work_func_t func, const char *name); +void suspend_blocking_work_destroy(struct suspend_blocking_work *work); +int queue_suspend_blocking_work(struct workqueue_struct *wq, + struct suspend_blocking_work *work); +int schedule_suspend_blocking_work(struct suspend_blocking_work *work); +int cancel_suspend_blocking_work_sync(struct suspend_blocking_work *work); + #else static inline void suspend_blocker_init(struct suspend_blocker *blocker, @@ -77,6 +118,32 @@ static inline bool suspend_blocker_is_active(struct suspend_blocker *bl) { return 0; } static inline bool suspend_is_blocked(void) { return 0; } +static inline void suspend_blocking_work_init( + struct suspend_blocking_work *work, work_func_t func, const char *name) +{ + INIT_WORK(&work->work, func); +} +static inline void suspend_blocking_work_destroy( + struct suspend_blocking_work *work) +{ + cancel_work_sync(&work->work); +} +static inline int queue_suspend_blocking_work( + struct workqueue_struct *wq, struct suspend_blocking_work *work) +{ + return queue_work(wq, &work->work); +} +static inline int schedule_suspend_blocking_work( + struct suspend_blocking_work *work) +{ + return schedule_work(&work->work); +} +static inline int cancel_suspend_blocking_work_sync( + struct suspend_blocking_work *work) +{ + return cancel_work_sync(&work->work); +} + #endif #endif diff --git a/kernel/power/suspend_blocker.c b/kernel/power/suspend_blocker.c index 77920e6..852d941 100644 --- a/kernel/power/suspend_blocker.c +++ b/kernel/power/suspend_blocker.c @@ -474,3 +474,112 @@ static int __init suspend_block_postcore_init(void) } postcore_initcall(suspend_block_postcore_init); + +static void suspend_blocking_work_complete(struct suspend_blocking_work *work) +{ + unsigned long flags; + + WARN_ON(!work->active); + spin_lock_irqsave(&work->lock, flags); + if (!--work->active) + suspend_unblock(&work->suspend_blocker); + spin_unlock_irqrestore(&work->lock, flags); +} + +static void suspend_blocking_work_func(struct work_struct *work) +{ + struct suspend_blocking_work *sbwork = to_suspend_blocking_work(work); + + sbwork->func(work); + suspend_blocking_work_complete(sbwork); +} + +/** + * suspend_blocking_work_init - Initialize suspend_blocking_work + * @work: The work item in question. + * @func: Callback. + * @name: Name for suspend blocker. + * + */ +void suspend_blocking_work_init(struct suspend_blocking_work *work, + work_func_t func, const char *name) +{ + INIT_WORK(&work->work, suspend_blocking_work_func); + suspend_blocker_init(&work->suspend_blocker, name); + work->func = func; + spin_lock_init(&work->lock); + work->active = 0; +} +EXPORT_SYMBOL_GPL(suspend_blocking_work_init); + +/** + * cancel_suspend_blocking_work_sync - Cancel suspend_blocking_work + * @work: The work item in question + */ +int cancel_suspend_blocking_work_sync(struct suspend_blocking_work *work) +{ + int ret; + + ret = cancel_work_sync(&work->work); + if (ret) + suspend_blocking_work_complete(work); + return ret; +} +EXPORT_SYMBOL_GPL(cancel_suspend_blocking_work_sync); + +/** + * suspend_blocking_work_destroy - Destroy suspend_blocking_work + * @work: The work item in question + * + * If the work was ever queued on more then one workqueue all but the last + * workqueue must be flushed before calling suspend_blocking_work_destroy. + */ +void suspend_blocking_work_destroy(struct suspend_blocking_work *work) +{ + cancel_suspend_blocking_work_sync(work); + WARN_ON(work->active); + suspend_blocker_destroy(&work->suspend_blocker); +} +EXPORT_SYMBOL_GPL(suspend_blocking_work_destroy); + +/** + * queue_suspend_blocking_work - Queue suspend blocking work + * @wq: Workqueue to queue work on. + * @work: The work item in question. + */ +int queue_suspend_blocking_work(struct workqueue_struct *wq, + struct suspend_blocking_work *work) +{ + int ret; + unsigned long flags; + + spin_lock_irqsave(&work->lock, flags); + ret = queue_work(wq, &work->work); + if (ret) { + suspend_block(&work->suspend_blocker); + work->active++; + } + spin_unlock_irqrestore(&work->lock, flags); + return ret; +} +EXPORT_SYMBOL_GPL(queue_suspend_blocking_work); + +/** + * schedule_suspend_blocking_work - Queue suspend blocking work + * @work: The work item in question. + */ +int schedule_suspend_blocking_work(struct suspend_blocking_work *work) +{ + int ret; + unsigned long flags; + + spin_lock_irqsave(&work->lock, flags); + ret = schedule_work(&work->work); + if (ret) { + suspend_block(&work->suspend_blocker); + work->active++; + } + spin_unlock_irqrestore(&work->lock, flags); + return ret; +} +EXPORT_SYMBOL_GPL(schedule_suspend_blocking_work); -- 1.6.5.1