From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= Subject: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space Date: Thu, 22 Apr 2010 18:08:51 -0700 Message-ID: <1271984938-13920-3-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> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1271984938-13920-2-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 , linux-doc@vger.kernel.org, Jesse Barnes , Magnus Damm List-Id: linux-pm@vger.kernel.org QWRkIGEgbWlzYyBkZXZpY2UsICJzdXNwZW5kX2Jsb2NrZXIiLCB0aGF0IGFsbG93cyB1c2VyLXNw YWNlIHByb2Nlc3Nlcwp0byBibG9jayBhdXRvIHN1c3BlbmQuIFRoZSBkZXZpY2UgaGFzIGlvY3Rs cyB0byBjcmVhdGUgYSBzdXNwZW5kX2Jsb2NrZXIsCmFuZCB0byBibG9jayBhbmQgdW5ibG9jayBz dXNwZW5kLiBUbyBkZWxldGUgdGhlIHN1c3BlbmRfYmxvY2tlciwgY2xvc2UKdGhlIGRldmljZS4K ClNpZ25lZC1vZmYtYnk6IEFydmUgSGrDuG5uZXbDpWcgPGFydmVAYW5kcm9pZC5jb20+Ci0tLQog RG9jdW1lbnRhdGlvbi9wb3dlci9zdXNwZW5kLWJsb2NrZXJzLnR4dCB8ICAgMTcgKysrKwogaW5j bHVkZS9saW51eC9zdXNwZW5kX2Jsb2NrX2Rldi5oICAgICAgICB8ICAgMjUgKysrKysrCiBrZXJu ZWwvcG93ZXIvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgIHwgICAgOSArKwoga2VybmVsL3Bv d2VyL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwoga2VybmVsL3Bvd2VyL3Vz ZXJfc3VzcGVuZF9ibG9ja2VyLmMgICAgICB8ICAxMjggKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCiA1IGZpbGVzIGNoYW5nZWQsIDE4MCBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygt KQogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvc3VzcGVuZF9ibG9ja19kZXYuaAog Y3JlYXRlIG1vZGUgMTAwNjQ0IGtlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxvY2tlci5jCgpk aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9wb3dlci9zdXNwZW5kLWJsb2NrZXJzLnR4dCBiL0Rv Y3VtZW50YXRpb24vcG93ZXIvc3VzcGVuZC1ibG9ja2Vycy50eHQKaW5kZXggMWM0ODUxNC4uODc3 YmQ4YyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9wb3dlci9zdXNwZW5kLWJsb2NrZXJzLnR4 dAorKysgYi9Eb2N1bWVudGF0aW9uL3Bvd2VyL3N1c3BlbmQtYmxvY2tlcnMudHh0CkBAIC05NSwz ICs5NSwyMCBAQCBpZiAobGlzdF9lbXB0eSgmc3RhdGUtPnBlbmRpbmdfd29yaykpCiBlbHNlCiAJ c3VzcGVuZF9ibG9jaygmc3RhdGUtPnN1c3BlbmRfYmxvY2tlcik7CiAKK1VzZXItc3BhY2UgQVBJ Cis9PT09PT09PT09PT09PQorCitUbyBjcmVhdGUgYSBzdXNwZW5kX2Jsb2NrZXIgZnJvbSB1c2Vy LXNwYWNlLCBvcGVuIHRoZSBzdXNwZW5kX2Jsb2NrZXIgZGV2aWNlOgorICAgIGZkID0gb3Blbigi L2Rldi9zdXNwZW5kX2Jsb2NrZXIiLCBPX1JEV1IgfCBPX0NMT0VYRUMpOwordGhlbiBjYWxsOgor ICAgIGlvY3RsKGZkLCBTVVNQRU5EX0JMT0NLRVJfSU9DVExfSU5JVChzdHJsZW4obmFtZSkpLCBu YW1lKTsKKworVG8gYWN0aXZhdGUgYSBzdXNwZW5kX2Jsb2NrZXIgY2FsbDoKKyAgICBpb2N0bChm ZCwgU1VTUEVORF9CTE9DS0VSX0lPQ1RMX0JMT0NLKTsKKworVG8gdW5ibG9jayBjYWxsOgorICAg IGlvY3RsKGZkLCBTVVNQRU5EX0JMT0NLRVJfSU9DVExfVU5CTE9DSyk7CisKK1RvIGRlc3Ryb3kg dGhlIHN1c3BlbmRfYmxvY2tlciwgY2xvc2UgdGhlIGRldmljZToKKyAgICBjbG9zZShmZCk7CisK ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3VzcGVuZF9ibG9ja19kZXYuaCBiL2luY2x1ZGUv bGludXgvc3VzcGVuZF9ibG9ja19kZXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi4yNGJjNWM3Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9zdXNwZW5kX2Js b2NrX2Rldi5oCkBAIC0wLDAgKzEsMjUgQEAKKy8qIGluY2x1ZGUvbGludXgvc3VzcGVuZF9ibG9j a19kZXYuaAorICoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHb29nbGUsIEluYy4KKyAqCisgKiBU aGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVy YWwgUHVibGljCisgKiBMaWNlbnNlIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24sIGFuZAorICogbWF5IGJlIGNvcGllZCwgZGlzdHJpYnV0ZWQs IGFuZCBtb2RpZmllZCB1bmRlciB0aG9zZSB0ZXJtcy4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqLworCisjaWZuZGVmIF9MSU5VWF9TVVNQRU5EX0JMT0NLX0RFVl9ICisjZGVmaW5l IF9MSU5VWF9TVVNQRU5EX0JMT0NLX0RFVl9ICisKKyNpbmNsdWRlIDxsaW51eC9pb2N0bC5oPgor CisjZGVmaW5lIFNVU1BFTkRfQkxPQ0tFUl9JT0NUTF9JTklUKGxlbikJCV9JT0MoX0lPQ19XUklU RSwgJ3MnLCAwLCBsZW4pCisjZGVmaW5lIFNVU1BFTkRfQkxPQ0tFUl9JT0NUTF9CTE9DSwkJX0lP KCdzJywgMSkKKyNkZWZpbmUgU1VTUEVORF9CTE9DS0VSX0lPQ1RMX1VOQkxPQ0sJCV9JTygncycs IDIpCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEva2VybmVsL3Bvd2VyL0tjb25maWcgYi9rZXJuZWwv cG93ZXIvS2NvbmZpZwppbmRleCBmOGZhMjQ2Li4xYWM1MGVlIDEwMDY0NAotLS0gYS9rZXJuZWwv cG93ZXIvS2NvbmZpZworKysgYi9rZXJuZWwvcG93ZXIvS2NvbmZpZwpAQCAtMTQxLDYgKzE0MSwx NSBAQCBjb25maWcgU1VTUEVORF9CTE9DS0VSUwogCSAgc3RhdGUgdGhyb3VnaCAvc3lzL3Bvd2Vy L3N0YXRlLCB0aGUgcmVxdWVzdGVkIHNsZWVwIHN0YXRlIHdpbGwgYmUKIAkgIGVudGVyZWQgd2hl biBubyBzdXNwZW5kIGJsb2NrZXJzIGFyZSBhY3RpdmUuCiAKK2NvbmZpZyBVU0VSX1NVU1BFTkRf QkxPQ0tFUlMKKwlib29sICJVc2Vyc3BhY2Ugc3VzcGVuZCBibG9ja2VycyIKKwlkZXBlbmRzIG9u IFNVU1BFTkRfQkxPQ0tFUlMKKwlkZWZhdWx0IHkKKwktLS1oZWxwLS0tCisJICBVc2VyLXNwYWNl IHN1c3BlbmQgYmxvY2sgYXBpLiBDcmVhdGVzIGEgbWlzYyBkZXZpY2Ugd2l0aCBpb2N0bHMKKwkg IHRvIGNyZWF0ZSwgYmxvY2sgYW5kIHVuYmxvY2sgYSBzdXNwZW5kX2Jsb2NrZXIuIFRoZSBzdXNw ZW5kX2Jsb2NrZXIKKwkgIHdpbGwgYmUgZGVsZXRlZCB3aGVuIHRoZSBkZXZpY2UgaXMgY2xvc2Vk LgorCiBjb25maWcgSElCRVJOQVRJT05fTlZTCiAJYm9vbAogCmRpZmYgLS1naXQgYS9rZXJuZWwv cG93ZXIvTWFrZWZpbGUgYi9rZXJuZWwvcG93ZXIvTWFrZWZpbGUKaW5kZXggZjU3MDgwMS4uODAw ODZjNiAxMDA2NDQKLS0tIGEva2VybmVsL3Bvd2VyL01ha2VmaWxlCisrKyBiL2tlcm5lbC9wb3dl ci9NYWtlZmlsZQpAQCAtOCw2ICs4LDcgQEAgb2JqLSQoQ09ORklHX1BNX1NMRUVQKQkJKz0gY29u c29sZS5vCiBvYmotJChDT05GSUdfRlJFRVpFUikJCSs9IHByb2Nlc3Mubwogb2JqLSQoQ09ORklH X1NVU1BFTkQpCQkrPSBzdXNwZW5kLm8KIG9iai0kKENPTkZJR19TVVNQRU5EX0JMT0NLRVJTKQkr PSBzdXNwZW5kX2Jsb2NrZXIubworb2JqLSQoQ09ORklHX1VTRVJfU1VTUEVORF9CTE9DS0VSUykJ Kz0gdXNlcl9zdXNwZW5kX2Jsb2NrZXIubwogb2JqLSQoQ09ORklHX1BNX1RFU1RfU1VTUEVORCkJ Kz0gc3VzcGVuZF90ZXN0Lm8KIG9iai0kKENPTkZJR19ISUJFUk5BVElPTikJKz0gaGliZXJuYXRl Lm8gc25hcHNob3QubyBzd2FwLm8gdXNlci5vCiBvYmotJChDT05GSUdfSElCRVJOQVRJT05fTlZT KQkrPSBoaWJlcm5hdGVfbnZzLm8KZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3dlci91c2VyX3N1c3Bl bmRfYmxvY2tlci5jIGIva2VybmVsL3Bvd2VyL3VzZXJfc3VzcGVuZF9ibG9ja2VyLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTliZTZmNAotLS0gL2Rldi9udWxsCisrKyBi L2tlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxvY2tlci5jCkBAIC0wLDAgKzEsMTI4IEBACisv KiBrZXJuZWwvcG93ZXIvdXNlcl9zdXNwZW5kX2Jsb2NrLmMKKyAqCisgKiBDb3B5cmlnaHQgKEMp IDIwMDktMjAxMCBHb29nbGUsIEluYy4KKyAqCisgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2Vk IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIHZl cnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGFu ZAorICogbWF5IGJlIGNvcGllZCwgZGlzdHJpYnV0ZWQsIGFuZCBtb2RpZmllZCB1bmRlciB0aG9z ZSB0ZXJtcy4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUg dGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqLworCisjaW5jbHVkZSA8 bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9taXNjZGV2aWNlLmg+CisjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgorI2luY2x1ZGUgPGxpbnV4 L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zdXNwZW5kX2Jsb2NrZXIuaD4KKyNpbmNsdWRlIDxs aW51eC9zdXNwZW5kX2Jsb2NrX2Rldi5oPgorCitlbnVtIHsKKwlERUJVR19GQUlMVVJFCT0gQklU KDApLAorfTsKK3N0YXRpYyBpbnQgZGVidWdfbWFzayA9IERFQlVHX0ZBSUxVUkU7Cittb2R1bGVf cGFyYW1fbmFtZWQoZGVidWdfbWFzaywgZGVidWdfbWFzaywgaW50LCBTX0lSVUdPIHwgU19JV1VT UiB8IFNfSVdHUlApOworCitzdGF0aWMgREVGSU5FX01VVEVYKGlvY3RsX2xvY2spOworCitzdHJ1 Y3QgdXNlcl9zdXNwZW5kX2Jsb2NrZXIgeworCXN0cnVjdCBzdXNwZW5kX2Jsb2NrZXIJYmxvY2tl cjsKKwljaGFyCQkJbmFtZVswXTsKK307CisKK3N0YXRpYyBpbnQgY3JlYXRlX3VzZXJfc3VzcGVu ZF9ibG9ja2VyKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkIF9fdXNlciAqbmFtZSwKKwkJCQkgc2l6 ZV90IG5hbWVfbGVuKQoreworCXN0cnVjdCB1c2VyX3N1c3BlbmRfYmxvY2tlciAqYmw7CisJaWYg KGZpbGUtPnByaXZhdGVfZGF0YSkKKwkJcmV0dXJuIC1FQlVTWTsKKwlpZiAobmFtZV9sZW4gPiBO QU1FX01BWCkKKwkJcmV0dXJuIC1FTkFNRVRPT0xPTkc7CisJYmwgPSBremFsbG9jKHNpemVvZigq YmwpICsgbmFtZV9sZW4gKyAxLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJsKQorCQlyZXR1cm4gLUVO T01FTTsKKwlpZiAoY29weV9mcm9tX3VzZXIoYmwtPm5hbWUsIG5hbWUsIG5hbWVfbGVuKSkKKwkJ Z290byBlcnJfZmF1bHQ7CisJc3VzcGVuZF9ibG9ja2VyX2luaXQoJmJsLT5ibG9ja2VyLCBibC0+ bmFtZSk7CisJZmlsZS0+cHJpdmF0ZV9kYXRhID0gYmw7CisJcmV0dXJuIDA7CisKK2Vycl9mYXVs dDoKKwlrZnJlZShibCk7CisJcmV0dXJuIC1FRkFVTFQ7Cit9CisKK3N0YXRpYyBsb25nIHVzZXJf c3VzcGVuZF9ibG9ja2VyX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21k LAorCQkJCXVuc2lnbmVkIGxvbmcgX2FyZykKK3sKKwl2b2lkIF9fdXNlciAqYXJnID0gKHZvaWQg X191c2VyICopX2FyZzsKKwlzdHJ1Y3QgdXNlcl9zdXNwZW5kX2Jsb2NrZXIgKmJsOworCWxvbmcg cmV0OworCisJbXV0ZXhfbG9jaygmaW9jdGxfbG9jayk7CisJaWYgKChjbWQgJiB+SU9DU0laRV9N QVNLKSA9PSBTVVNQRU5EX0JMT0NLRVJfSU9DVExfSU5JVCgwKSkgeworCQlyZXQgPSBjcmVhdGVf dXNlcl9zdXNwZW5kX2Jsb2NrZXIoZmlsZSwgYXJnLCBfSU9DX1NJWkUoY21kKSk7CisJCWdvdG8g ZG9uZTsKKwl9CisJYmwgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJaWYgKCFibCkgeworCQlyZXQg PSAtRU5PRU5UOworCQlnb3RvIGRvbmU7CisJfQorCXN3aXRjaCAoY21kKSB7CisJY2FzZSBTVVNQ RU5EX0JMT0NLRVJfSU9DVExfQkxPQ0s6CisJCXN1c3BlbmRfYmxvY2soJmJsLT5ibG9ja2VyKTsK KwkJcmV0ID0gMDsKKwkJYnJlYWs7CisJY2FzZSBTVVNQRU5EX0JMT0NLRVJfSU9DVExfVU5CTE9D SzoKKwkJc3VzcGVuZF91bmJsb2NrKCZibC0+YmxvY2tlcik7CisJCXJldCA9IDA7CisJCWJyZWFr OworCWRlZmF1bHQ6CisJCXJldCA9IC1FTk9UU1VQUDsKKwl9Citkb25lOgorCWlmIChyZXQgJiYg ZGVidWdfbWFzayAmIERFQlVHX0ZBSUxVUkUpCisJCXByX2VycigidXNlcl9zdXNwZW5kX2Jsb2Nr ZXJfaW9jdGw6IGNtZCAleCBmYWlsZWQsICVsZFxuIiwKKwkJCWNtZCwgcmV0KTsKKwltdXRleF91 bmxvY2soJmlvY3RsX2xvY2spOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgdXNlcl9z dXNwZW5kX2Jsb2NrZXJfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAq ZmlsZSkKK3sKKwlzdHJ1Y3QgdXNlcl9zdXNwZW5kX2Jsb2NrZXIgKmJsID0gZmlsZS0+cHJpdmF0 ZV9kYXRhOworCWlmICghYmwpCisJCXJldHVybiAwOworCXN1c3BlbmRfYmxvY2tlcl9kZXN0cm95 KCZibC0+YmxvY2tlcik7CisJa2ZyZWUoYmwpOworCXJldHVybiAwOworfQorCitjb25zdCBzdHJ1 Y3QgZmlsZV9vcGVyYXRpb25zIHVzZXJfc3VzcGVuZF9ibG9ja2VyX2ZvcHMgPSB7CisJLnJlbGVh c2UgPSB1c2VyX3N1c3BlbmRfYmxvY2tlcl9yZWxlYXNlLAorCS51bmxvY2tlZF9pb2N0bCA9IHVz ZXJfc3VzcGVuZF9ibG9ja2VyX2lvY3RsLAorfTsKKworc3RydWN0IG1pc2NkZXZpY2UgdXNlcl9z dXNwZW5kX2Jsb2NrZXJfZGV2aWNlID0geworCS5taW5vciA9IE1JU0NfRFlOQU1JQ19NSU5PUiwK KwkubmFtZSA9ICJzdXNwZW5kX2Jsb2NrZXIiLAorCS5mb3BzID0gJnVzZXJfc3VzcGVuZF9ibG9j a2VyX2ZvcHMsCit9OworCitzdGF0aWMgaW50IF9faW5pdCB1c2VyX3N1c3BlbmRfYmxvY2tlcl9p bml0KHZvaWQpCit7CisJcmV0dXJuIG1pc2NfcmVnaXN0ZXIoJnVzZXJfc3VzcGVuZF9ibG9ja2Vy X2RldmljZSk7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCB1c2VyX3N1c3BlbmRfYmxvY2tlcl9l eGl0KHZvaWQpCit7CisJbWlzY19kZXJlZ2lzdGVyKCZ1c2VyX3N1c3BlbmRfYmxvY2tlcl9kZXZp Y2UpOworfQorCittb2R1bGVfaW5pdCh1c2VyX3N1c3BlbmRfYmxvY2tlcl9pbml0KTsKK21vZHVs ZV9leGl0KHVzZXJfc3VzcGVuZF9ibG9ja2VyX2V4aXQpOwotLSAKMS42LjUuMQoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtcG0gbWFpbGluZyBs aXN0CmxpbnV4LXBtQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGlu dXgtZm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1wbQ== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754835Ab0DWBLt (ORCPT ); Thu, 22 Apr 2010 21:11:49 -0400 Received: from mail-yw0-f194.google.com ([209.85.211.194]:50164 "EHLO mail-yw0-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754668Ab0DWBKD (ORCPT ); Thu, 22 Apr 2010 21:10:03 -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?= , Len Brown , Pavel Machek , "Rafael J. Wysocki" , Randy Dunlap , Jesse Barnes , Magnus Damm , Nigel Cunningham , Cornelia Huck , linux-doc@vger.kernel.org Subject: [PATCH 2/9] PM: suspend_block: Add driver to access suspend blockers from user-space Date: Thu, 22 Apr 2010 18:08:51 -0700 Message-Id: <1271984938-13920-3-git-send-email-arve@android.com> X-Mailer: git-send-email 1.6.5.1 In-Reply-To: <1271984938-13920-2-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> 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 Add a misc device, "suspend_blocker", that allows user-space processes to block auto suspend. The device has ioctls to create a suspend_blocker, and to block and unblock suspend. To delete the suspend_blocker, close the device. Signed-off-by: Arve Hjønnevåg --- Documentation/power/suspend-blockers.txt | 17 ++++ include/linux/suspend_block_dev.h | 25 ++++++ kernel/power/Kconfig | 9 ++ kernel/power/Makefile | 1 + kernel/power/user_suspend_blocker.c | 128 ++++++++++++++++++++++++++++++ 5 files changed, 180 insertions(+), 0 deletions(-) create mode 100644 include/linux/suspend_block_dev.h create mode 100644 kernel/power/user_suspend_blocker.c diff --git a/Documentation/power/suspend-blockers.txt b/Documentation/power/suspend-blockers.txt index 1c48514..877bd8c 100644 --- a/Documentation/power/suspend-blockers.txt +++ b/Documentation/power/suspend-blockers.txt @@ -95,3 +95,20 @@ if (list_empty(&state->pending_work)) else suspend_block(&state->suspend_blocker); +User-space API +============== + +To create a suspend_blocker from user-space, open the suspend_blocker device: + fd = open("/dev/suspend_blocker", O_RDWR | O_CLOEXEC); +then call: + ioctl(fd, SUSPEND_BLOCKER_IOCTL_INIT(strlen(name)), name); + +To activate a suspend_blocker call: + ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK); + +To unblock call: + ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK); + +To destroy the suspend_blocker, close the device: + close(fd); + diff --git a/include/linux/suspend_block_dev.h b/include/linux/suspend_block_dev.h new file mode 100644 index 0000000..24bc5c7 --- /dev/null +++ b/include/linux/suspend_block_dev.h @@ -0,0 +1,25 @@ +/* include/linux/suspend_block_dev.h + * + * Copyright (C) 2009 Google, Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#ifndef _LINUX_SUSPEND_BLOCK_DEV_H +#define _LINUX_SUSPEND_BLOCK_DEV_H + +#include + +#define SUSPEND_BLOCKER_IOCTL_INIT(len) _IOC(_IOC_WRITE, 's', 0, len) +#define SUSPEND_BLOCKER_IOCTL_BLOCK _IO('s', 1) +#define SUSPEND_BLOCKER_IOCTL_UNBLOCK _IO('s', 2) + +#endif diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index f8fa246..1ac50ee 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -141,6 +141,15 @@ config SUSPEND_BLOCKERS state through /sys/power/state, the requested sleep state will be entered when no suspend blockers are active. +config USER_SUSPEND_BLOCKERS + bool "Userspace suspend blockers" + depends on SUSPEND_BLOCKERS + default y + ---help--- + User-space suspend block api. Creates a misc device with ioctls + to create, block and unblock a suspend_blocker. The suspend_blocker + will be deleted when the device is closed. + config HIBERNATION_NVS bool diff --git a/kernel/power/Makefile b/kernel/power/Makefile index f570801..80086c6 100644 --- a/kernel/power/Makefile +++ b/kernel/power/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_PM_SLEEP) += console.o obj-$(CONFIG_FREEZER) += process.o obj-$(CONFIG_SUSPEND) += suspend.o obj-$(CONFIG_SUSPEND_BLOCKERS) += suspend_blocker.o +obj-$(CONFIG_USER_SUSPEND_BLOCKERS) += user_suspend_blocker.o obj-$(CONFIG_PM_TEST_SUSPEND) += suspend_test.o obj-$(CONFIG_HIBERNATION) += hibernate.o snapshot.o swap.o user.o obj-$(CONFIG_HIBERNATION_NVS) += hibernate_nvs.o diff --git a/kernel/power/user_suspend_blocker.c b/kernel/power/user_suspend_blocker.c new file mode 100644 index 0000000..a9be6f4 --- /dev/null +++ b/kernel/power/user_suspend_blocker.c @@ -0,0 +1,128 @@ +/* kernel/power/user_suspend_block.c + * + * Copyright (C) 2009-2010 Google, Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +enum { + DEBUG_FAILURE = BIT(0), +}; +static int debug_mask = DEBUG_FAILURE; +module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP); + +static DEFINE_MUTEX(ioctl_lock); + +struct user_suspend_blocker { + struct suspend_blocker blocker; + char name[0]; +}; + +static int create_user_suspend_blocker(struct file *file, void __user *name, + size_t name_len) +{ + struct user_suspend_blocker *bl; + if (file->private_data) + return -EBUSY; + if (name_len > NAME_MAX) + return -ENAMETOOLONG; + bl = kzalloc(sizeof(*bl) + name_len + 1, GFP_KERNEL); + if (!bl) + return -ENOMEM; + if (copy_from_user(bl->name, name, name_len)) + goto err_fault; + suspend_blocker_init(&bl->blocker, bl->name); + file->private_data = bl; + return 0; + +err_fault: + kfree(bl); + return -EFAULT; +} + +static long user_suspend_blocker_ioctl(struct file *file, unsigned int cmd, + unsigned long _arg) +{ + void __user *arg = (void __user *)_arg; + struct user_suspend_blocker *bl; + long ret; + + mutex_lock(&ioctl_lock); + if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_INIT(0)) { + ret = create_user_suspend_blocker(file, arg, _IOC_SIZE(cmd)); + goto done; + } + bl = file->private_data; + if (!bl) { + ret = -ENOENT; + goto done; + } + switch (cmd) { + case SUSPEND_BLOCKER_IOCTL_BLOCK: + suspend_block(&bl->blocker); + ret = 0; + break; + case SUSPEND_BLOCKER_IOCTL_UNBLOCK: + suspend_unblock(&bl->blocker); + ret = 0; + break; + default: + ret = -ENOTSUPP; + } +done: + if (ret && debug_mask & DEBUG_FAILURE) + pr_err("user_suspend_blocker_ioctl: cmd %x failed, %ld\n", + cmd, ret); + mutex_unlock(&ioctl_lock); + return ret; +} + +static int user_suspend_blocker_release(struct inode *inode, struct file *file) +{ + struct user_suspend_blocker *bl = file->private_data; + if (!bl) + return 0; + suspend_blocker_destroy(&bl->blocker); + kfree(bl); + return 0; +} + +const struct file_operations user_suspend_blocker_fops = { + .release = user_suspend_blocker_release, + .unlocked_ioctl = user_suspend_blocker_ioctl, +}; + +struct miscdevice user_suspend_blocker_device = { + .minor = MISC_DYNAMIC_MINOR, + .name = "suspend_blocker", + .fops = &user_suspend_blocker_fops, +}; + +static int __init user_suspend_blocker_init(void) +{ + return misc_register(&user_suspend_blocker_device); +} + +static void __exit user_suspend_blocker_exit(void) +{ + misc_deregister(&user_suspend_blocker_device); +} + +module_init(user_suspend_blocker_init); +module_exit(user_suspend_blocker_exit); -- 1.6.5.1