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: Tue, 27 Apr 2010 21:31:57 -0700 Message-ID: <1272429119-12103-7-git-send-email-arve@android.com> References: <1272429119-12103-1-git-send-email-arve@android.com> <1272429119-12103-2-git-send-email-arve@android.com> <1272429119-12103-3-git-send-email-arve@android.com> <1272429119-12103-4-git-send-email-arve@android.com> <1272429119-12103-5-git-send-email-arve@android.com> <1272429119-12103-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: <1272429119-12103-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 KysrKysrKwoga2VybmVsL3Bvd2VyL3N1c3BlbmRfYmxvY2tlci5jICB8ICAxMDcgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDE3NCBpbnNl 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 ZXIuYwppbmRleCAyZDQzZjM3Li5mOWM2MjA2IDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvc3Vz cGVuZF9ibG9ja2VyLmMKKysrIGIva2VybmVsL3Bvd2VyL3N1c3BlbmRfYmxvY2tlci5jCkBAIC00 ODQsMyArNDg0LDExMCBAQCBzdGF0aWMgaW50IF9faW5pdCBzdXNwZW5kX2Jsb2NrX3Bvc3Rjb3Jl X2luaXQodm9pZCkKIAogY29yZV9pbml0Y2FsbChzdXNwZW5kX2Jsb2NrX2luaXQpOwogcG9zdGNv cmVfaW5pdGNhbGwoc3VzcGVuZF9ibG9ja19wb3N0Y29yZV9pbml0KTsKKworc3RhdGljIHZvaWQg c3VzcGVuZF9ibG9ja2luZ193b3JrX2NvbXBsZXRlKHN0cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dv cmsgKndvcmspCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCVdBUk5fT04oIXdvcmstPmFj dGl2ZSk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJndvcmstPmxvY2ssIGZsYWdzKTsKKwlpZiAoIS0t d29yay0+YWN0aXZlKQorCQlzdXNwZW5kX3VuYmxvY2soJndvcmstPnN1c3BlbmRfYmxvY2tlcik7 CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmd29yay0+bG9jaywgZmxhZ3MpOworfQorCitzdGF0 aWMgdm9pZCBzdXNwZW5kX2Jsb2NraW5nX3dvcmtfZnVuYyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndv cmspCit7CisJc3RydWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqc2J3b3JrID0gdG9fc3VzcGVu ZF9ibG9ja2luZ193b3JrKHdvcmspOworCisJc2J3b3JrLT5mdW5jKHdvcmspOworCXN1c3BlbmRf YmxvY2tpbmdfd29ya19jb21wbGV0ZShzYndvcmspOworfQorCisvKioKKyAqIHN1c3BlbmRfYmxv Y2tpbmdfd29ya19pbml0IC0gSW5pdGlhbGl6ZSBzdXNwZW5kX2Jsb2NraW5nX3dvcmsKKyAqIEB3 b3JrOiBUaGUgd29yayBpdGVtIGluIHF1ZXN0aW9uLgorICogQGZ1bmM6IENhbGxiYWNrLgorICog QG5hbWU6IE5hbWUgZm9yIHN1c3BlbmQgYmxvY2tlci4KKyAqCisgKi8KK3ZvaWQgc3VzcGVuZF9i bG9ja2luZ193b3JrX2luaXQoc3RydWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqd29yaywKKwkJ CQl3b3JrX2Z1bmNfdCBmdW5jLCBjb25zdCBjaGFyICpuYW1lKQoreworCUlOSVRfV09SSygmd29y ay0+d29yaywgc3VzcGVuZF9ibG9ja2luZ193b3JrX2Z1bmMpOworCXN1c3BlbmRfYmxvY2tlcl9p bml0KCZ3b3JrLT5zdXNwZW5kX2Jsb2NrZXIsIG5hbWUpOworCXdvcmstPmZ1bmMgPSBmdW5jOwor CXNwaW5fbG9ja19pbml0KCZ3b3JrLT5sb2NrKTsKKwl3b3JrLT5hY3RpdmUgPSAwOworfQorRVhQ T1JUX1NZTUJPTChzdXNwZW5kX2Jsb2NraW5nX3dvcmtfaW5pdCk7CisKKy8qKgorICogY2FuY2Vs X3N1c3BlbmRfYmxvY2tpbmdfd29ya19zeW5jIC0gQ2FuY2VsIHN1c3BlbmRfYmxvY2tpbmdfd29y aworICogQHdvcms6IFRoZSB3b3JrIGl0ZW0gaW4gcXVlc3Rpb24KKyAqLworaW50IGNhbmNlbF9z dXNwZW5kX2Jsb2NraW5nX3dvcmtfc3luYyhzdHJ1Y3Qgc3VzcGVuZF9ibG9ja2luZ193b3JrICp3 b3JrKQoreworCWludCByZXQ7CisKKwlyZXQgPSBjYW5jZWxfd29ya19zeW5jKCZ3b3JrLT53b3Jr KTsKKwlpZiAocmV0KQorCQlzdXNwZW5kX2Jsb2NraW5nX3dvcmtfY29tcGxldGUod29yayk7CisJ cmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0woY2FuY2VsX3N1c3BlbmRfYmxvY2tpbmdfd29y a19zeW5jKTsKKworLyoqCisgKiBzdXNwZW5kX2Jsb2NraW5nX3dvcmtfZGVzdHJveSAtIERlc3Ry b3kgc3VzcGVuZF9ibG9ja2luZ193b3JrCisgKiBAd29yazogVGhlIHdvcmsgaXRlbSBpbiBxdWVz dGlvbgorICoKKyAqIElmIHRoZSB3b3JrIHdhcyBldmVyIHF1ZXVlZCBvbiBtb3JlIHRoZW4gb25l IHdvcmtxdWV1ZSBhbGwgYnV0IHRoZSBsYXN0CisgKiB3b3JrcXVldWUgbXVzdCBiZSBmbHVzaGVk IGJlZm9yZSBjYWxsaW5nIHN1c3BlbmRfYmxvY2tpbmdfd29ya19kZXN0cm95LgorICovCit2b2lk IHN1c3BlbmRfYmxvY2tpbmdfd29ya19kZXN0cm95KHN0cnVjdCBzdXNwZW5kX2Jsb2NraW5nX3dv cmsgKndvcmspCit7CisJY2FuY2VsX3N1c3BlbmRfYmxvY2tpbmdfd29ya19zeW5jKHdvcmspOwor CVdBUk5fT04od29yay0+YWN0aXZlKTsKKwlzdXNwZW5kX2Jsb2NrZXJfZGVzdHJveSgmd29yay0+ c3VzcGVuZF9ibG9ja2VyKTsKK30KK0VYUE9SVF9TWU1CT0woc3VzcGVuZF9ibG9ja2luZ193b3Jr X2Rlc3Ryb3kpOworCisvKioKKyAqIHF1ZXVlX3N1c3BlbmRfYmxvY2tpbmdfd29yayAtIFF1ZXVl IHN1c3BlbmQgYmxvY2tpbmcgd29yaworICogQHdxOgkJV29ya3F1ZXVlIHRvIHF1ZXVlIHdvcmsg b24uCisgKiBAd29yazoJVGhlIHdvcmsgaXRlbSBpbiBxdWVzdGlvbi4KKyAqLworaW50IHF1ZXVl X3N1c3BlbmRfYmxvY2tpbmdfd29yayhzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqd3EsCisJCQkJ c3RydWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAqd29yaykKK3sKKwlpbnQgcmV0OworCXVuc2ln bmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmd29yay0+bG9jaywgZmxhZ3Mp OworCXN1c3BlbmRfYmxvY2soJndvcmstPnN1c3BlbmRfYmxvY2tlcik7CisJcmV0ID0gcXVldWVf d29yayh3cSwgJndvcmstPndvcmspOworCWlmIChyZXQpCisJCXdvcmstPmFjdGl2ZSsrOworCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJndvcmstPmxvY2ssIGZsYWdzKTsKKwlyZXR1cm4gcmV0Owor fQorRVhQT1JUX1NZTUJPTChxdWV1ZV9zdXNwZW5kX2Jsb2NraW5nX3dvcmspOworCisvKioKKyAq IHNjaGVkdWxlX3N1c3BlbmRfYmxvY2tpbmdfd29yayAtIFF1ZXVlIHN1c3BlbmQgYmxvY2tpbmcg d29yaworICogQHdvcms6CVRoZSB3b3JrIGl0ZW0gaW4gcXVlc3Rpb24uCisgKi8KK2ludCBzY2hl ZHVsZV9zdXNwZW5kX2Jsb2NraW5nX3dvcmsoc3RydWN0IHN1c3BlbmRfYmxvY2tpbmdfd29yayAq d29yaykKK3sKKwlpbnQgcmV0OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tf aXJxc2F2ZSgmd29yay0+bG9jaywgZmxhZ3MpOworCXN1c3BlbmRfYmxvY2soJndvcmstPnN1c3Bl bmRfYmxvY2tlcik7CisJcmV0ID0gc2NoZWR1bGVfd29yaygmd29yay0+d29yayk7CisJaWYgKHJl dCkKKwkJd29yay0+YWN0aXZlKys7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmd29yay0+bG9j aywgZmxhZ3MpOworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MKHNjaGVkdWxlX3N1c3Bl bmRfYmxvY2tpbmdfd29yayk7Ci0tIAoxLjYuNS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1wbSBtYWlsaW5nIGxpc3QKbGludXgtcG1AbGlz dHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eC1mb3VuZGF0aW9uLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXBt From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751816Ab0D1Ecv (ORCPT ); Wed, 28 Apr 2010 00:32:51 -0400 Received: from mail-pz0-f204.google.com ([209.85.222.204]:57985 "EHLO mail-pz0-f204.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751141Ab0D1Ecc (ORCPT ); Wed, 28 Apr 2010 00:32:32 -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: Tue, 27 Apr 2010 21:31:57 -0700 Message-Id: <1272429119-12103-7-git-send-email-arve@android.com> X-Mailer: git-send-email 1.6.5.1 In-Reply-To: <1272429119-12103-6-git-send-email-arve@android.com> References: <1272429119-12103-1-git-send-email-arve@android.com> <1272429119-12103-2-git-send-email-arve@android.com> <1272429119-12103-3-git-send-email-arve@android.com> <1272429119-12103-4-git-send-email-arve@android.com> <1272429119-12103-5-git-send-email-arve@android.com> <1272429119-12103-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 | 107 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 174 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 2d43f37..f9c6206 100644 --- a/kernel/power/suspend_blocker.c +++ b/kernel/power/suspend_blocker.c @@ -484,3 +484,110 @@ static int __init suspend_block_postcore_init(void) core_initcall(suspend_block_init); 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(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(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(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); + suspend_block(&work->suspend_blocker); + ret = queue_work(wq, &work->work); + if (ret) + work->active++; + spin_unlock_irqrestore(&work->lock, flags); + return ret; +} +EXPORT_SYMBOL(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); + suspend_block(&work->suspend_blocker); + ret = schedule_work(&work->work); + if (ret) + work->active++; + spin_unlock_irqrestore(&work->lock, flags); + return ret; +} +EXPORT_SYMBOL(schedule_suspend_blocking_work); -- 1.6.5.1