From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= Subject: [PATCH 2/8] PM: suspend_block: Add driver to access suspend blockers from user-space Date: Tue, 27 Apr 2010 21:31:53 -0700 Message-ID: <1272429119-12103-3-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> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1272429119-12103-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 , Jim Collar , linux-doc@vger.kernel.org, Greg Kroah-Hartman , Oleg Nesterov , Avi Kivity , Ryusuke Konishi , Tejun Heo , Magnus Damm , Andrew Morton List-Id: linux-pm@vger.kernel.org QWRkIGEgbWlzYyBkZXZpY2UsICJzdXNwZW5kX2Jsb2NrZXIiLCB0aGF0IGFsbG93cyB1c2VyLXNw YWNlIHByb2Nlc3Nlcwp0byBibG9jayBhdXRvIHN1c3BlbmQuIFRoZSBkZXZpY2UgaGFzIGlvY3Rs cyB0byBjcmVhdGUgYSBzdXNwZW5kX2Jsb2NrZXIsCmFuZCB0byBibG9jayBhbmQgdW5ibG9jayBz dXNwZW5kLiBUbyBkZWxldGUgdGhlIHN1c3BlbmRfYmxvY2tlciwgY2xvc2UKdGhlIGRldmljZS4K ClNpZ25lZC1vZmYtYnk6IEFydmUgSGrDuG5uZXbDpWcgPGFydmVAYW5kcm9pZC5jb20+Ci0tLQog RG9jdW1lbnRhdGlvbi9pb2N0bC9pb2N0bC1udW1iZXIudHh0ICAgICAgICAgIHwgICAgMyArLQog RG9jdW1lbnRhdGlvbi9wb3dlci9vcHBvcnR1bmlzdGljLXN1c3BlbmQudHh0IHwgICAxNyArKysr CiBpbmNsdWRlL2xpbnV4L3N1c3BlbmRfYmxvY2tfZGV2LmggICAgICAgICAgICAgfCAgIDI1ICsr KysrCiBrZXJuZWwvcG93ZXIvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA5 ICsrCiBrZXJuZWwvcG93ZXIvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAx ICsKIGtlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxvY2tlci5jICAgICAgICAgICB8ICAxMjgg KysrKysrKysrKysrKysrKysrKysrKysrKwogNiBmaWxlcyBjaGFuZ2VkLCAxODIgaW5zZXJ0aW9u cygrKSwgMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L3N1 c3BlbmRfYmxvY2tfZGV2LmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBrZXJuZWwvcG93ZXIvdXNlcl9z dXNwZW5kX2Jsb2NrZXIuYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaW9jdGwvaW9jdGwt bnVtYmVyLnR4dCBiL0RvY3VtZW50YXRpb24vaW9jdGwvaW9jdGwtbnVtYmVyLnR4dAppbmRleCBk ZDU4MDZmLi5lMjQ1OGY3IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2lvY3RsL2lvY3RsLW51 bWJlci50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9pb2N0bC9pb2N0bC1udW1iZXIudHh0CkBAIC0y NTQsNyArMjU0LDggQEAgQ29kZSAgU2VxIyhoZXgpCUluY2x1ZGUgRmlsZQkJQ29tbWVudHMKICdx Jwk4MC1GRglsaW51eC90ZWxlcGhvbnkuaAlJbnRlcm5ldCBQaG9uZUpBQ0ssIEludGVybmV0IExp bmVKQUNLCiAJCWxpbnV4L2l4anVzZXIuaAkJPGh0dHA6Ly93d3cucXVpY2tuZXQubmV0PgogJ3In CTAwLTFGCWxpbnV4L21zZG9zX2ZzLmggYW5kIGZzL2ZhdC9kaXIuYwotJ3MnCWFsbAlsaW51eC9j ZGsuaAorJ3MnCWFsbAlsaW51eC9jZGsuaAljb25mbGljdCEKKydzJwlhbGwJbGludXgvc3VzcGVu ZF9ibG9ja19kZXYuaAljb25mbGljdCEKICd0JwkwMC03RglsaW51eC9pZl9wcHAuaAogJ3QnCTgw LThGCWxpbnV4L2lzZG5fcHBwLmgKICd0Jwk5MAlsaW51eC90b3NoaWJhLmgKZGlmZiAtLWdpdCBh L0RvY3VtZW50YXRpb24vcG93ZXIvb3Bwb3J0dW5pc3RpYy1zdXNwZW5kLnR4dCBiL0RvY3VtZW50 YXRpb24vcG93ZXIvb3Bwb3J0dW5pc3RpYy1zdXNwZW5kLnR4dAppbmRleCAxYTI5ZDEwLi42Mzlk YTczIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3Bvd2VyL29wcG9ydHVuaXN0aWMtc3VzcGVu ZC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9wb3dlci9vcHBvcnR1bmlzdGljLXN1c3BlbmQudHh0 CkBAIC0xMTIsMyArMTEyLDIwIEBAIGlmIChsaXN0X2VtcHR5KCZzdGF0ZS0+cGVuZGluZ193b3Jr KSkKIGVsc2UKIAlzdXNwZW5kX2Jsb2NrKCZzdGF0ZS0+c3VzcGVuZF9ibG9ja2VyKTsKIAorVXNl ci1zcGFjZSBBUEkKKz09PT09PT09PT09PT09CisKK1RvIGNyZWF0ZSBhIHN1c3BlbmRfYmxvY2tl ciBmcm9tIHVzZXItc3BhY2UsIG9wZW4gdGhlIHN1c3BlbmRfYmxvY2tlciBkZXZpY2U6CisgICAg ZmQgPSBvcGVuKCIvZGV2L3N1c3BlbmRfYmxvY2tlciIsIE9fUkRXUiB8IE9fQ0xPRVhFQyk7Cit0 aGVuIGNhbGw6CisgICAgaW9jdGwoZmQsIFNVU1BFTkRfQkxPQ0tFUl9JT0NUTF9JTklUKHN0cmxl bihuYW1lKSksIG5hbWUpOworCitUbyBhY3RpdmF0ZSBhIHN1c3BlbmRfYmxvY2tlciBjYWxsOgor ICAgIGlvY3RsKGZkLCBTVVNQRU5EX0JMT0NLRVJfSU9DVExfQkxPQ0spOworCitUbyB1bmJsb2Nr IGNhbGw6CisgICAgaW9jdGwoZmQsIFNVU1BFTkRfQkxPQ0tFUl9JT0NUTF9VTkJMT0NLKTsKKwor VG8gZGVzdHJveSB0aGUgc3VzcGVuZF9ibG9ja2VyLCBjbG9zZSB0aGUgZGV2aWNlOgorICAgIGNs b3NlKGZkKTsKKwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zdXNwZW5kX2Jsb2NrX2Rldi5o IGIvaW5jbHVkZS9saW51eC9zdXNwZW5kX2Jsb2NrX2Rldi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjI0YmM1YzcKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4 L3N1c3BlbmRfYmxvY2tfZGV2LmgKQEAgLTAsMCArMSwyNSBAQAorLyogaW5jbHVkZS9saW51eC9z dXNwZW5kX2Jsb2NrX2Rldi5oCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEdvb2dsZSwgSW5j LgorICoKKyAqIFRoaXMgc29mdHdhcmUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgYW5kCisgKiBtYXkgYmUgY29waWVkLCBk aXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVuZGVyIHRob3NlIHRlcm1zLgorICoKKyAqIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICovCisKKyNpZm5kZWYgX0xJTlVYX1NVU1BFTkRfQkxPQ0tfREVW X0gKKyNkZWZpbmUgX0xJTlVYX1NVU1BFTkRfQkxPQ0tfREVWX0gKKworI2luY2x1ZGUgPGxpbnV4 L2lvY3RsLmg+CisKKyNkZWZpbmUgU1VTUEVORF9CTE9DS0VSX0lPQ1RMX0lOSVQobGVuKQkJX0lP QyhfSU9DX1dSSVRFLCAncycsIDAsIGxlbikKKyNkZWZpbmUgU1VTUEVORF9CTE9DS0VSX0lPQ1RM X0JMT0NLCQlfSU8oJ3MnLCAxKQorI2RlZmluZSBTVVNQRU5EX0JMT0NLRVJfSU9DVExfVU5CTE9D SwkJX0lPKCdzJywgMikKKworI2VuZGlmCmRpZmYgLS1naXQgYS9rZXJuZWwvcG93ZXIvS2NvbmZp ZyBiL2tlcm5lbC9wb3dlci9LY29uZmlnCmluZGV4IDU1YTA2YTEuLmZlNWEyZjIgMTAwNjQ0Ci0t LSBhL2tlcm5lbC9wb3dlci9LY29uZmlnCisrKyBiL2tlcm5lbC9wb3dlci9LY29uZmlnCkBAIC0x NDYsNiArMTQ2LDE1IEBAIGNvbmZpZyBPUFBPUlRVTklTVElDX1NVU1BFTkQKIAkgIGRldGVybWlu ZXMgdGhlIHNsZWVwIHN0YXRlIHRoZSBzeXN0ZW0gd2lsbCBiZSBwdXQgaW50byB3aGVuIHRoZXJl IGFyZQogCSAgbm8gYWN0aXZlIHN1c3BlbmQgYmxvY2tlcnMuCiAKK2NvbmZpZyBVU0VSX1NVU1BF TkRfQkxPQ0tFUlMKKwlib29sICJVc2Vyc3BhY2Ugc3VzcGVuZCBibG9ja2VycyIKKwlkZXBlbmRz IG9uIE9QUE9SVFVOSVNUSUNfU1VTUEVORAorCWRlZmF1bHQgeQorCS0tLWhlbHAtLS0KKwkgIFVz ZXItc3BhY2Ugc3VzcGVuZCBibG9jayBhcGkuIENyZWF0ZXMgYSBtaXNjIGRldmljZSB3aXRoIGlv Y3RscworCSAgdG8gY3JlYXRlLCBibG9jayBhbmQgdW5ibG9jayBhIHN1c3BlbmRfYmxvY2tlci4g VGhlIHN1c3BlbmRfYmxvY2tlcgorCSAgd2lsbCBiZSBkZWxldGVkIHdoZW4gdGhlIGRldmljZSBp cyBjbG9zZWQuCisKIGNvbmZpZyBISUJFUk5BVElPTl9OVlMKIAlib29sCiAKZGlmZiAtLWdpdCBh L2tlcm5lbC9wb3dlci9NYWtlZmlsZSBiL2tlcm5lbC9wb3dlci9NYWtlZmlsZQppbmRleCBlZTUy NzZkLi43OGY3MDNiIDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvTWFrZWZpbGUKKysrIGIva2Vy bmVsL3Bvd2VyL01ha2VmaWxlCkBAIC04LDYgKzgsNyBAQCBvYmotJChDT05GSUdfUE1fU0xFRVAp CQkrPSBjb25zb2xlLm8KIG9iai0kKENPTkZJR19GUkVFWkVSKQkJKz0gcHJvY2Vzcy5vCiBvYmot JChDT05GSUdfU1VTUEVORCkJCSs9IHN1c3BlbmQubwogb2JqLSQoQ09ORklHX09QUE9SVFVOSVNU SUNfU1VTUEVORCkJKz0gc3VzcGVuZF9ibG9ja2VyLm8KK29iai0kKENPTkZJR19VU0VSX1NVU1BF TkRfQkxPQ0tFUlMpCSs9IHVzZXJfc3VzcGVuZF9ibG9ja2VyLm8KIG9iai0kKENPTkZJR19QTV9U RVNUX1NVU1BFTkQpCSs9IHN1c3BlbmRfdGVzdC5vCiBvYmotJChDT05GSUdfSElCRVJOQVRJT04p CSs9IGhpYmVybmF0ZS5vIHNuYXBzaG90Lm8gc3dhcC5vIHVzZXIubwogb2JqLSQoQ09ORklHX0hJ QkVSTkFUSU9OX05WUykJKz0gaGliZXJuYXRlX252cy5vCmRpZmYgLS1naXQgYS9rZXJuZWwvcG93 ZXIvdXNlcl9zdXNwZW5kX2Jsb2NrZXIuYyBiL2tlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxv Y2tlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE5YmU2ZjQKLS0tIC9k ZXYvbnVsbAorKysgYi9rZXJuZWwvcG93ZXIvdXNlcl9zdXNwZW5kX2Jsb2NrZXIuYwpAQCAtMCww ICsxLDEyOCBAQAorLyoga2VybmVsL3Bvd2VyL3VzZXJfc3VzcGVuZF9ibG9jay5jCisgKgorICog Q29weXJpZ2h0IChDKSAyMDA5LTIwMTAgR29vZ2xlLCBJbmMuCisgKgorICogVGhpcyBzb2Z0d2Fy ZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYwor ICogTGljZW5zZSB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uLCBhbmQKKyAqIG1heSBiZSBjb3BpZWQsIGRpc3RyaWJ1dGVkLCBhbmQgbW9kaWZp ZWQgdW5kZXIgdGhvc2UgdGVybXMuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVk IGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQor ICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKi8K KworI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvbWlzY2RldmljZS5oPgor I2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KKyNp bmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc3VzcGVuZF9ibG9ja2VyLmg+ CisjaW5jbHVkZSA8bGludXgvc3VzcGVuZF9ibG9ja19kZXYuaD4KKworZW51bSB7CisJREVCVUdf RkFJTFVSRQk9IEJJVCgwKSwKK307CitzdGF0aWMgaW50IGRlYnVnX21hc2sgPSBERUJVR19GQUlM VVJFOworbW9kdWxlX3BhcmFtX25hbWVkKGRlYnVnX21hc2ssIGRlYnVnX21hc2ssIGludCwgU19J UlVHTyB8IFNfSVdVU1IgfCBTX0lXR1JQKTsKKworc3RhdGljIERFRklORV9NVVRFWChpb2N0bF9s b2NrKTsKKworc3RydWN0IHVzZXJfc3VzcGVuZF9ibG9ja2VyIHsKKwlzdHJ1Y3Qgc3VzcGVuZF9i bG9ja2VyCWJsb2NrZXI7CisJY2hhcgkJCW5hbWVbMF07Cit9OworCitzdGF0aWMgaW50IGNyZWF0 ZV91c2VyX3N1c3BlbmRfYmxvY2tlcihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCBfX3VzZXIgKm5h bWUsCisJCQkJIHNpemVfdCBuYW1lX2xlbikKK3sKKwlzdHJ1Y3QgdXNlcl9zdXNwZW5kX2Jsb2Nr ZXIgKmJsOworCWlmIChmaWxlLT5wcml2YXRlX2RhdGEpCisJCXJldHVybiAtRUJVU1k7CisJaWYg KG5hbWVfbGVuID4gTkFNRV9NQVgpCisJCXJldHVybiAtRU5BTUVUT09MT05HOworCWJsID0ga3ph bGxvYyhzaXplb2YoKmJsKSArIG5hbWVfbGVuICsgMSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFibCkK KwkJcmV0dXJuIC1FTk9NRU07CisJaWYgKGNvcHlfZnJvbV91c2VyKGJsLT5uYW1lLCBuYW1lLCBu YW1lX2xlbikpCisJCWdvdG8gZXJyX2ZhdWx0OworCXN1c3BlbmRfYmxvY2tlcl9pbml0KCZibC0+ YmxvY2tlciwgYmwtPm5hbWUpOworCWZpbGUtPnByaXZhdGVfZGF0YSA9IGJsOworCXJldHVybiAw OworCitlcnJfZmF1bHQ6CisJa2ZyZWUoYmwpOworCXJldHVybiAtRUZBVUxUOworfQorCitzdGF0 aWMgbG9uZyB1c2VyX3N1c3BlbmRfYmxvY2tlcl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5z aWduZWQgaW50IGNtZCwKKwkJCQl1bnNpZ25lZCBsb25nIF9hcmcpCit7CisJdm9pZCBfX3VzZXIg KmFyZyA9ICh2b2lkIF9fdXNlciAqKV9hcmc7CisJc3RydWN0IHVzZXJfc3VzcGVuZF9ibG9ja2Vy ICpibDsKKwlsb25nIHJldDsKKworCW11dGV4X2xvY2soJmlvY3RsX2xvY2spOworCWlmICgoY21k ICYgfklPQ1NJWkVfTUFTSykgPT0gU1VTUEVORF9CTE9DS0VSX0lPQ1RMX0lOSVQoMCkpIHsKKwkJ cmV0ID0gY3JlYXRlX3VzZXJfc3VzcGVuZF9ibG9ja2VyKGZpbGUsIGFyZywgX0lPQ19TSVpFKGNt ZCkpOworCQlnb3RvIGRvbmU7CisJfQorCWJsID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCWlmICgh YmwpIHsKKwkJcmV0ID0gLUVOT0VOVDsKKwkJZ290byBkb25lOworCX0KKwlzd2l0Y2ggKGNtZCkg eworCWNhc2UgU1VTUEVORF9CTE9DS0VSX0lPQ1RMX0JMT0NLOgorCQlzdXNwZW5kX2Jsb2NrKCZi bC0+YmxvY2tlcik7CisJCXJldCA9IDA7CisJCWJyZWFrOworCWNhc2UgU1VTUEVORF9CTE9DS0VS X0lPQ1RMX1VOQkxPQ0s6CisJCXN1c3BlbmRfdW5ibG9jaygmYmwtPmJsb2NrZXIpOworCQlyZXQg PSAwOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXQgPSAtRU5PVFNVUFA7CisJfQorZG9uZToK KwlpZiAocmV0ICYmIGRlYnVnX21hc2sgJiBERUJVR19GQUlMVVJFKQorCQlwcl9lcnIoInVzZXJf c3VzcGVuZF9ibG9ja2VyX2lvY3RsOiBjbWQgJXggZmFpbGVkLCAlbGRcbiIsCisJCQljbWQsIHJl dCk7CisJbXV0ZXhfdW5sb2NrKCZpb2N0bF9sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0 aWMgaW50IHVzZXJfc3VzcGVuZF9ibG9ja2VyX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9kZSwg c3RydWN0IGZpbGUgKmZpbGUpCit7CisJc3RydWN0IHVzZXJfc3VzcGVuZF9ibG9ja2VyICpibCA9 IGZpbGUtPnByaXZhdGVfZGF0YTsKKwlpZiAoIWJsKQorCQlyZXR1cm4gMDsKKwlzdXNwZW5kX2Js b2NrZXJfZGVzdHJveSgmYmwtPmJsb2NrZXIpOworCWtmcmVlKGJsKTsKKwlyZXR1cm4gMDsKK30K KworY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyB1c2VyX3N1c3BlbmRfYmxvY2tlcl9mb3Bz ID0geworCS5yZWxlYXNlID0gdXNlcl9zdXNwZW5kX2Jsb2NrZXJfcmVsZWFzZSwKKwkudW5sb2Nr ZWRfaW9jdGwgPSB1c2VyX3N1c3BlbmRfYmxvY2tlcl9pb2N0bCwKK307CisKK3N0cnVjdCBtaXNj ZGV2aWNlIHVzZXJfc3VzcGVuZF9ibG9ja2VyX2RldmljZSA9IHsKKwkubWlub3IgPSBNSVNDX0RZ TkFNSUNfTUlOT1IsCisJLm5hbWUgPSAic3VzcGVuZF9ibG9ja2VyIiwKKwkuZm9wcyA9ICZ1c2Vy X3N1c3BlbmRfYmxvY2tlcl9mb3BzLAorfTsKKworc3RhdGljIGludCBfX2luaXQgdXNlcl9zdXNw ZW5kX2Jsb2NrZXJfaW5pdCh2b2lkKQoreworCXJldHVybiBtaXNjX3JlZ2lzdGVyKCZ1c2VyX3N1 c3BlbmRfYmxvY2tlcl9kZXZpY2UpOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgdXNlcl9zdXNw ZW5kX2Jsb2NrZXJfZXhpdCh2b2lkKQoreworCW1pc2NfZGVyZWdpc3RlcigmdXNlcl9zdXNwZW5k X2Jsb2NrZXJfZGV2aWNlKTsKK30KKworbW9kdWxlX2luaXQodXNlcl9zdXNwZW5kX2Jsb2NrZXJf aW5pdCk7Cittb2R1bGVfZXhpdCh1c2VyX3N1c3BlbmRfYmxvY2tlcl9leGl0KTsKLS0gCjEuNi41 LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LXBtIG1haWxpbmcgbGlzdApsaW51eC1wbUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRw czovL2xpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcG0= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751252Ab0D1Ech (ORCPT ); Wed, 28 Apr 2010 00:32:37 -0400 Received: from mail-pw0-f46.google.com ([209.85.160.46]:37211 "EHLO mail-pw0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751089Ab0D1EcW (ORCPT ); Wed, 28 Apr 2010 00:32:22 -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?= , Randy Dunlap , Andrew Morton , Ryusuke Konishi , Jim Collar , Greg Kroah-Hartman , Avi Kivity , Len Brown , Pavel Machek , Magnus Damm , Cornelia Huck , Nigel Cunningham , linux-doc@vger.kernel.org Subject: [PATCH 2/8] PM: suspend_block: Add driver to access suspend blockers from user-space Date: Tue, 27 Apr 2010 21:31:53 -0700 Message-Id: <1272429119-12103-3-git-send-email-arve@android.com> X-Mailer: git-send-email 1.6.5.1 In-Reply-To: <1272429119-12103-2-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> 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/ioctl/ioctl-number.txt | 3 +- Documentation/power/opportunistic-suspend.txt | 17 ++++ include/linux/suspend_block_dev.h | 25 +++++ kernel/power/Kconfig | 9 ++ kernel/power/Makefile | 1 + kernel/power/user_suspend_blocker.c | 128 +++++++++++++++++++++++++ 6 files changed, 182 insertions(+), 1 deletions(-) create mode 100644 include/linux/suspend_block_dev.h create mode 100644 kernel/power/user_suspend_blocker.c diff --git a/Documentation/ioctl/ioctl-number.txt b/Documentation/ioctl/ioctl-number.txt index dd5806f..e2458f7 100644 --- a/Documentation/ioctl/ioctl-number.txt +++ b/Documentation/ioctl/ioctl-number.txt @@ -254,7 +254,8 @@ Code Seq#(hex) Include File Comments 'q' 80-FF linux/telephony.h Internet PhoneJACK, Internet LineJACK linux/ixjuser.h 'r' 00-1F linux/msdos_fs.h and fs/fat/dir.c -'s' all linux/cdk.h +'s' all linux/cdk.h conflict! +'s' all linux/suspend_block_dev.h conflict! 't' 00-7F linux/if_ppp.h 't' 80-8F linux/isdn_ppp.h 't' 90 linux/toshiba.h diff --git a/Documentation/power/opportunistic-suspend.txt b/Documentation/power/opportunistic-suspend.txt index 1a29d10..639da73 100644 --- a/Documentation/power/opportunistic-suspend.txt +++ b/Documentation/power/opportunistic-suspend.txt @@ -112,3 +112,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 55a06a1..fe5a2f2 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -146,6 +146,15 @@ config OPPORTUNISTIC_SUSPEND determines the sleep state the system will be put into when there are no active suspend blockers. +config USER_SUSPEND_BLOCKERS + bool "Userspace suspend blockers" + depends on OPPORTUNISTIC_SUSPEND + 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 ee5276d..78f703b 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_OPPORTUNISTIC_SUSPEND) += 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