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: Thu, 13 May 2010 21:11:07 -0700 Message-ID: <1273810273-3039-3-git-send-email-arve@android.com> References: <1273810273-3039-1-git-send-email-arve@android.com> <1273810273-3039-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: <1273810273-3039-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 , Avi Kivity , Ryusuke Konishi , Magnus Damm , Andrew Morton List-Id: linux-pm@vger.kernel.org QWRkIGEgbWlzYyBkZXZpY2UsICJzdXNwZW5kX2Jsb2NrZXIiLCB0aGF0IGFsbG93cyB1c2VyLXNw YWNlIHByb2Nlc3Nlcwp0byBibG9jayBhdXRvIHN1c3BlbmQuIFRoZSBkZXZpY2UgaGFzIGlvY3Rs cyB0byBjcmVhdGUgYSBzdXNwZW5kX2Jsb2NrZXIsCmFuZCB0byBibG9jayBhbmQgdW5ibG9jayBz dXNwZW5kLiBUbyBkZWxldGUgdGhlIHN1c3BlbmRfYmxvY2tlciwgY2xvc2UKdGhlIGRldmljZS4K ClNpZ25lZC1vZmYtYnk6IEFydmUgSGrDuG5uZXbDpWcgPGFydmVAYW5kcm9pZC5jb20+Ci0tLQog RG9jdW1lbnRhdGlvbi9pb2N0bC9pb2N0bC1udW1iZXIudHh0ICAgICAgICAgIHwgICAgMyArLQog RG9jdW1lbnRhdGlvbi9wb3dlci9vcHBvcnR1bmlzdGljLXN1c3BlbmQudHh0IHwgICAyNyArKysr KwogaW5jbHVkZS9saW51eC9zdXNwZW5kX2lvY3Rscy5oICAgICAgICAgICAgICAgIHwgICAgNCAr CiBrZXJuZWwvcG93ZXIvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA3ICsr CiBrZXJuZWwvcG93ZXIvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsK IGtlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxvY2tlci5jICAgICAgICAgICB8ICAxNDMgKysr KysrKysrKysrKysrKysrKysrKysrKwogNiBmaWxlcyBjaGFuZ2VkLCAxODQgaW5zZXJ0aW9ucygr KSwgMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBrZXJuZWwvcG93ZXIvdXNlcl9z dXNwZW5kX2Jsb2NrZXIuYwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaW9jdGwvaW9jdGwt bnVtYmVyLnR4dCBiL0RvY3VtZW50YXRpb24vaW9jdGwvaW9jdGwtbnVtYmVyLnR4dAppbmRleCBk ZDU4MDZmLi5lMjQ1OGY3IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2lvY3RsL2lvY3RsLW51 bWJlci50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9pb2N0bC9pb2N0bC1udW1iZXIudHh0CkBAIC0y NTQsNyArMjU0LDggQEAgQ29kZSAgU2VxIyhoZXgpCUluY2x1ZGUgRmlsZQkJQ29tbWVudHMKICdx Jwk4MC1GRglsaW51eC90ZWxlcGhvbnkuaAlJbnRlcm5ldCBQaG9uZUpBQ0ssIEludGVybmV0IExp bmVKQUNLCiAJCWxpbnV4L2l4anVzZXIuaAkJPGh0dHA6Ly93d3cucXVpY2tuZXQubmV0PgogJ3In CTAwLTFGCWxpbnV4L21zZG9zX2ZzLmggYW5kIGZzL2ZhdC9kaXIuYwotJ3MnCWFsbAlsaW51eC9j ZGsuaAorJ3MnCWFsbAlsaW51eC9jZGsuaAljb25mbGljdCEKKydzJwlhbGwJbGludXgvc3VzcGVu ZF9ibG9ja19kZXYuaAljb25mbGljdCEKICd0JwkwMC03RglsaW51eC9pZl9wcHAuaAogJ3QnCTgw LThGCWxpbnV4L2lzZG5fcHBwLmgKICd0Jwk5MAlsaW51eC90b3NoaWJhLmgKZGlmZiAtLWdpdCBh L0RvY3VtZW50YXRpb24vcG93ZXIvb3Bwb3J0dW5pc3RpYy1zdXNwZW5kLnR4dCBiL0RvY3VtZW50 YXRpb24vcG93ZXIvb3Bwb3J0dW5pc3RpYy1zdXNwZW5kLnR4dAppbmRleCA0YmVlN2JjLi45M2Y0 YzI0IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3Bvd2VyL29wcG9ydHVuaXN0aWMtc3VzcGVu ZC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9wb3dlci9vcHBvcnR1bmlzdGljLXN1c3BlbmQudHh0 CkBAIC0xMjcsMyArMTI3LDMwIEBAIGlmIChsaXN0X2VtcHR5KCZzdGF0ZS0+cGVuZGluZ193b3Jr KSkKIAlzdXNwZW5kX3VuYmxvY2soJnN0YXRlLT5zdXNwZW5kX2Jsb2NrZXIpOwogZWxzZQogCXN1 c3BlbmRfYmxvY2soJnN0YXRlLT5zdXNwZW5kX2Jsb2NrZXIpOworCitVc2VyIHNwYWNlIEFQSQor PT09PT09PT09PT09PT0KKworVG8gY3JlYXRlIGEgc3VzcGVuZCBibG9ja2VyIGZyb20gdXNlciBz cGFjZSwgb3BlbiB0aGUgc3VzcGVuZF9ibG9ja2VyIHNwZWNpYWwKK2RldmljZSBmaWxlOgorCisg ICAgZmQgPSBvcGVuKCIvZGV2L3N1c3BlbmRfYmxvY2tlciIsIE9fUkRXUiB8IE9fQ0xPRVhFQyk7 CisKK3RoZW4gb3B0aW9uYWxseSBjYWxsOgorCisgICAgaW9jdGwoZmQsIFNVU1BFTkRfQkxPQ0tF Ul9JT0NUTF9TRVRfTkFNRShzdHJsZW4obmFtZSkpLCBuYW1lKTsKKworVG8gYWN0aXZhdGUgdGhl IHN1c3BlbmQgYmxvY2tlciBjYWxsOgorCisgICAgaW9jdGwoZmQsIFNVU1BFTkRfQkxPQ0tFUl9J T0NUTF9CTE9DSyk7CisKK1RvIGRlYWN0aXZhdGUgaXQgY2FsbDoKKworICAgIGlvY3RsKGZkLCBT VVNQRU5EX0JMT0NLRVJfSU9DVExfVU5CTE9DSyk7CisKK1RvIGRlc3Ryb3kgdGhlIHN1c3BlbmQg YmxvY2tlciwgY2xvc2UgdGhlIGRldmljZToKKworICAgIGNsb3NlKGZkKTsKKworSWYgdGhlIGZp cnN0IGlvY3RsIGNhbGxlZCBpcyBub3QgU1VTUEVORF9CTE9DS0VSX0lPQ1RMX1NFVF9OQU1FIHRo ZSBzdXNwZW5kCitibG9ja2VyIHdpbGwgZ2V0IHRoZSBkZWZhdWx0IG5hbWUgIih1c2Vyc3BhY2Up Ii4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3VzcGVuZF9pb2N0bHMuaCBiL2luY2x1ZGUv bGludXgvc3VzcGVuZF9pb2N0bHMuaAppbmRleCAwYjMwMzgyLi5iOTVhNmIyIDEwMDY0NAotLS0g YS9pbmNsdWRlL2xpbnV4L3N1c3BlbmRfaW9jdGxzLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdXNw ZW5kX2lvY3Rscy5oCkBAIC0zMCw0ICszMCw4IEBAIHN0cnVjdCByZXN1bWVfc3dhcF9hcmVhIHsK ICNkZWZpbmUgU05BUFNIT1RfQUxMT0NfU1dBUF9QQUdFCV9JT1IoU05BUFNIT1RfSU9DX01BR0lD LCAyMCwgX19rZXJuZWxfbG9mZl90KQogI2RlZmluZSBTTkFQU0hPVF9JT0NfTUFYTlIJMjAKIAor I2RlZmluZSBTVVNQRU5EX0JMT0NLRVJfSU9DVExfU0VUX05BTUUobGVuKQlfSU9DKF9JT0NfV1JJ VEUsICdzJywgMCwgbGVuKQorI2RlZmluZSBTVVNQRU5EX0JMT0NLRVJfSU9DVExfQkxPQ0sJCV9J TygncycsIDEpCisjZGVmaW5lIFNVU1BFTkRfQkxPQ0tFUl9JT0NUTF9VTkJMT0NLCQlfSU8oJ3Mn LCAyKQorCiAjZW5kaWYgLyogX0xJTlVYX1NVU1BFTkRfSU9DVExTX0ggKi8KZGlmZiAtLWdpdCBh L2tlcm5lbC9wb3dlci9LY29uZmlnIGIva2VybmVsL3Bvd2VyL0tjb25maWcKaW5kZXggNmQxMWE0 NS4uMmU2NjVjZCAxMDA2NDQKLS0tIGEva2VybmVsL3Bvd2VyL0tjb25maWcKKysrIGIva2VybmVs L3Bvd2VyL0tjb25maWcKQEAgLTE0Niw2ICsxNDYsMTMgQEAgY29uZmlnIE9QUE9SVFVOSVNUSUNf U1VTUEVORAogCSAgZGV0ZXJtaW5lcyB0aGUgc2xlZXAgc3RhdGUgdGhlIHN5c3RlbSB3aWxsIGJl IHB1dCBpbnRvIHdoZW4gdGhlcmUgYXJlCiAJICBubyBhY3RpdmUgc3VzcGVuZCBibG9ja2Vycy4K IAorY29uZmlnIFVTRVJfU1VTUEVORF9CTE9DS0VSUworCWJvb2wgIlVzZXIgc3BhY2Ugc3VzcGVu ZCBibG9ja2VycyIKKwlkZXBlbmRzIG9uIE9QUE9SVFVOSVNUSUNfU1VTUEVORAorCS0tLWhlbHAt LS0KKwkgIFVzZXIgc3BhY2Ugc3VzcGVuZCBibG9ja2VycyBBUEkuICBDcmVhdGVzIGEgbWlzYyBk ZXZpY2UgYWxsb3dpbmcgdXNlcgorCSAgc3BhY2UgdG8gY3JlYXRlLCB1c2UgYW5kIGRlc3Ryb3kg c3VzcGVuZCBibG9ja2Vycy4KKwogY29uZmlnIEhJQkVSTkFUSU9OX05WUwogCWJvb2wKIApkaWZm IC0tZ2l0IGEva2VybmVsL3Bvd2VyL01ha2VmaWxlIGIva2VybmVsL3Bvd2VyL01ha2VmaWxlCmlu ZGV4IDk1ZDhlNmQuLjIwMTU1OTQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9wb3dlci9NYWtlZmlsZQor KysgYi9rZXJuZWwvcG93ZXIvTWFrZWZpbGUKQEAgLTgsNiArOCw3IEBAIG9iai0kKENPTkZJR19Q TV9TTEVFUCkJCSs9IGNvbnNvbGUubwogb2JqLSQoQ09ORklHX0ZSRUVaRVIpCQkrPSBwcm9jZXNz Lm8KIG9iai0kKENPTkZJR19TVVNQRU5EKQkJKz0gc3VzcGVuZC5vCiBvYmotJChDT05GSUdfT1BQ T1JUVU5JU1RJQ19TVVNQRU5EKQkrPSBvcHBvcnR1bmlzdGljX3N1c3BlbmQubworb2JqLSQoQ09O RklHX1VTRVJfU1VTUEVORF9CTE9DS0VSUykJKz0gdXNlcl9zdXNwZW5kX2Jsb2NrZXIubwogb2Jq LSQoQ09ORklHX1BNX1RFU1RfU1VTUEVORCkJKz0gc3VzcGVuZF90ZXN0Lm8KIG9iai0kKENPTkZJ R19ISUJFUk5BVElPTikJKz0gaGliZXJuYXRlLm8gc25hcHNob3QubyBzd2FwLm8gdXNlci5vCiBv YmotJChDT05GSUdfSElCRVJOQVRJT05fTlZTKQkrPSBoaWJlcm5hdGVfbnZzLm8KZGlmZiAtLWdp dCBhL2tlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxvY2tlci5jIGIva2VybmVsL3Bvd2VyL3Vz ZXJfc3VzcGVuZF9ibG9ja2VyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u ZDUzZjkzOQotLS0gL2Rldi9udWxsCisrKyBiL2tlcm5lbC9wb3dlci91c2VyX3N1c3BlbmRfYmxv Y2tlci5jCkBAIC0wLDAgKzEsMTQzIEBACisvKgorICoga2VybmVsL3Bvd2VyL3VzZXJfc3VzcGVu ZF9ibG9ja2VyLmMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDktMjAxMCBHb29nbGUsIEluYy4K KyAqCisgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGFuZAorICogbWF5IGJlIGNvcGllZCwgZGlz dHJpYnV0ZWQsIGFuZCBtb2RpZmllZCB1bmRlciB0aG9zZSB0ZXJtcy4KKyAqCisgKiBUaGlzIHBy b2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorICoKKyAqLworCisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxs aW51eC9taXNjZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8 bGludXgvdWFjY2Vzcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51 eC9zdXNwZW5kLmg+CisjaW5jbHVkZSA8bGludXgvc3VzcGVuZF9pb2N0bHMuaD4KKworZW51bSB7 CisJREVCVUdfRkFJTFVSRQk9IEJJVCgwKSwKK307CitzdGF0aWMgaW50IGRlYnVnX21hc2sgPSBE RUJVR19GQUlMVVJFOworbW9kdWxlX3BhcmFtX25hbWVkKGRlYnVnX21hc2ssIGRlYnVnX21hc2ss IGludCwgU19JUlVHTyB8IFNfSVdVU1IgfCBTX0lXR1JQKTsKKworc3RhdGljIERFRklORV9NVVRF WChpb2N0bF9sb2NrKTsKKworI2RlZmluZSBVU0VSX1NVU1BFTkRfQkxPQ0tFUl9OQU1FX0xFTiAz MQorCitzdHJ1Y3QgdXNlcl9zdXNwZW5kX2Jsb2NrZXIgeworCXN0cnVjdCBzdXNwZW5kX2Jsb2Nr ZXIJYmxvY2tlcjsKKwljaGFyCQkJbmFtZVtVU0VSX1NVU1BFTkRfQkxPQ0tFUl9OQU1FX0xFTiAr IDFdOworCWJvb2wJCQlyZWdpc3RlcmVkOworfTsKKworc3RhdGljIGludCB1c2VyX3N1c3BlbmRf YmxvY2tlcl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQorewor CXN0cnVjdCB1c2VyX3N1c3BlbmRfYmxvY2tlciAqYmxvY2tlcjsKKworCWJsb2NrZXIgPSBremFs bG9jKHNpemVvZigqYmxvY2tlciksIEdGUF9LRVJORUwpOworCWlmICghYmxvY2tlcikKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwlub25zZWVrYWJsZV9vcGVuKGlub2RlLCBmaWxwKTsKKwlzdHJjcHko YmxvY2tlci0+bmFtZSwgIih1c2Vyc3BhY2UpIik7CisJYmxvY2tlci0+YmxvY2tlci5uYW1lID0g YmxvY2tlci0+bmFtZTsKKwlmaWxwLT5wcml2YXRlX2RhdGEgPSBibG9ja2VyOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgc3VzcGVuZF9ibG9ja2VyX3NldF9uYW1lKHN0cnVjdCB1c2Vy X3N1c3BlbmRfYmxvY2tlciAqYmxvY2tlciwKKwkJCQkgICAgdm9pZCBfX3VzZXIgKm5hbWUsIHNp emVfdCBuYW1lX2xlbikKK3sKKwlpZiAoYmxvY2tlci0+cmVnaXN0ZXJlZCkKKwkJcmV0dXJuIC1F QlVTWTsKKworCWlmIChuYW1lX2xlbiA+IFVTRVJfU1VTUEVORF9CTE9DS0VSX05BTUVfTEVOKQor CQluYW1lX2xlbiA9IFVTRVJfU1VTUEVORF9CTE9DS0VSX05BTUVfTEVOOworCisJaWYgKGNvcHlf ZnJvbV91c2VyKGJsb2NrZXItPm5hbWUsIG5hbWUsIG5hbWVfbGVuKSkKKwkJcmV0dXJuIC1FRkFV TFQ7CisJYmxvY2tlci0+bmFtZVtuYW1lX2xlbl0gPSAnXDAnOworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBsb25nIHVzZXJfc3VzcGVuZF9ibG9ja2VyX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxw LCB1bnNpZ25lZCBpbnQgY21kLAorCQkJCQl1bnNpZ25lZCBsb25nIF9hcmcpCit7CisJdm9pZCBf X3VzZXIgKmFyZyA9ICh2b2lkIF9fdXNlciAqKV9hcmc7CisJc3RydWN0IHVzZXJfc3VzcGVuZF9i bG9ja2VyICpibG9ja2VyID0gZmlscC0+cHJpdmF0ZV9kYXRhOworCWxvbmcgcmV0ID0gMDsKKwor CW11dGV4X2xvY2soJmlvY3RsX2xvY2spOworCWlmICgoY21kICYgfklPQ1NJWkVfTUFTSykgPT0g U1VTUEVORF9CTE9DS0VSX0lPQ1RMX1NFVF9OQU1FKDApKSB7CisJCXJldCA9IHN1c3BlbmRfYmxv Y2tlcl9zZXRfbmFtZShibG9ja2VyLCBhcmcsIF9JT0NfU0laRShjbWQpKTsKKwkJZ290byBkb25l OworCX0KKwlpZiAoIWJsb2NrZXItPnJlZ2lzdGVyZWQpIHsKKwkJc3VzcGVuZF9ibG9ja2VyX3Jl Z2lzdGVyKCZibG9ja2VyLT5ibG9ja2VyKTsKKwkJYmxvY2tlci0+cmVnaXN0ZXJlZCA9IHRydWU7 CisJfQorCXN3aXRjaCAoY21kKSB7CisJY2FzZSBTVVNQRU5EX0JMT0NLRVJfSU9DVExfQkxPQ0s6 CisJCXN1c3BlbmRfYmxvY2soJmJsb2NrZXItPmJsb2NrZXIpOworCQlicmVhazsKKworCWNhc2Ug U1VTUEVORF9CTE9DS0VSX0lPQ1RMX1VOQkxPQ0s6CisJCXN1c3BlbmRfdW5ibG9jaygmYmxvY2tl ci0+YmxvY2tlcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJcmV0ID0gLUVOT1RUWTsKKwl9 Citkb25lOgorCWlmIChyZXQgJiYgKGRlYnVnX21hc2sgJiBERUJVR19GQUlMVVJFKSkKKwkJcHJf ZXJyKCJ1c2VyX3N1c3BlbmRfYmxvY2tlcl9pb2N0bDogY21kICV4IGZhaWxlZCwgJWxkXG4iLAor CQkJY21kLCByZXQpOworCW11dGV4X3VubG9jaygmaW9jdGxfbG9jayk7CisJcmV0dXJuIHJldDsK K30KKworc3RhdGljIGludCB1c2VyX3N1c3BlbmRfYmxvY2tlcl9yZWxlYXNlKHN0cnVjdCBpbm9k ZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxwKQoreworCXN0cnVjdCB1c2VyX3N1c3BlbmRfYmxv Y2tlciAqYmxvY2tlciA9IGZpbHAtPnByaXZhdGVfZGF0YTsKKworCWlmIChibG9ja2VyLT5yZWdp c3RlcmVkKQorCQlzdXNwZW5kX2Jsb2NrZXJfdW5yZWdpc3RlcigmYmxvY2tlci0+YmxvY2tlcik7 CisJa2ZyZWUoYmxvY2tlcik7CisKKwlyZXR1cm4gMDsKK30KKworY29uc3Qgc3RydWN0IGZpbGVf b3BlcmF0aW9ucyB1c2VyX3N1c3BlbmRfYmxvY2tlcl9mb3BzID0geworCS5vcGVuID0gdXNlcl9z dXNwZW5kX2Jsb2NrZXJfb3BlbiwKKwkucmVsZWFzZSA9IHVzZXJfc3VzcGVuZF9ibG9ja2VyX3Jl bGVhc2UsCisJLnVubG9ja2VkX2lvY3RsID0gdXNlcl9zdXNwZW5kX2Jsb2NrZXJfaW9jdGwsCit9 OworCitzdHJ1Y3QgbWlzY2RldmljZSB1c2VyX3N1c3BlbmRfYmxvY2tlcl9kZXZpY2UgPSB7CisJ Lm1pbm9yID0gTUlTQ19EWU5BTUlDX01JTk9SLAorCS5uYW1lID0gInN1c3BlbmRfYmxvY2tlciIs CisJLmZvcHMgPSAmdXNlcl9zdXNwZW5kX2Jsb2NrZXJfZm9wcywKK307CisKK3N0YXRpYyBpbnQg X19pbml0IHVzZXJfc3VzcGVuZF9ibG9ja2VyX2luaXQodm9pZCkKK3sKKwlyZXR1cm4gbWlzY19y ZWdpc3RlcigmdXNlcl9zdXNwZW5kX2Jsb2NrZXJfZGV2aWNlKTsKK30KKworc3RhdGljIHZvaWQg X19leGl0IHVzZXJfc3VzcGVuZF9ibG9ja2VyX2V4aXQodm9pZCkKK3sKKwltaXNjX2RlcmVnaXN0 ZXIoJnVzZXJfc3VzcGVuZF9ibG9ja2VyX2RldmljZSk7Cit9CisKK21vZHVsZV9pbml0KHVzZXJf c3VzcGVuZF9ibG9ja2VyX2luaXQpOworbW9kdWxlX2V4aXQodXNlcl9zdXNwZW5kX2Jsb2NrZXJf ZXhpdCk7Ci0tIAoxLjYuNS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpsaW51eC1wbSBtYWlsaW5nIGxpc3QKbGludXgtcG1AbGlzdHMubGludXgtZm91 bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LXBt From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751890Ab0ENELj (ORCPT ); Fri, 14 May 2010 00:11:39 -0400 Received: from mail-pw0-f46.google.com ([209.85.160.46]:35277 "EHLO mail-pw0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751599Ab0ENELc (ORCPT ); Fri, 14 May 2010 00:11: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" , =?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: Thu, 13 May 2010 21:11:07 -0700 Message-Id: <1273810273-3039-3-git-send-email-arve@android.com> X-Mailer: git-send-email 1.6.5.1 In-Reply-To: <1273810273-3039-2-git-send-email-arve@android.com> References: <1273810273-3039-1-git-send-email-arve@android.com> <1273810273-3039-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 | 27 +++++ include/linux/suspend_ioctls.h | 4 + kernel/power/Kconfig | 7 ++ kernel/power/Makefile | 1 + kernel/power/user_suspend_blocker.c | 143 +++++++++++++++++++++++++ 6 files changed, 184 insertions(+), 1 deletions(-) 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 4bee7bc..93f4c24 100644 --- a/Documentation/power/opportunistic-suspend.txt +++ b/Documentation/power/opportunistic-suspend.txt @@ -127,3 +127,30 @@ if (list_empty(&state->pending_work)) suspend_unblock(&state->suspend_blocker); else suspend_block(&state->suspend_blocker); + +User space API +============== + +To create a suspend blocker from user space, open the suspend_blocker special +device file: + + fd = open("/dev/suspend_blocker", O_RDWR | O_CLOEXEC); + +then optionally call: + + ioctl(fd, SUSPEND_BLOCKER_IOCTL_SET_NAME(strlen(name)), name); + +To activate the suspend blocker call: + + ioctl(fd, SUSPEND_BLOCKER_IOCTL_BLOCK); + +To deactivate it call: + + ioctl(fd, SUSPEND_BLOCKER_IOCTL_UNBLOCK); + +To destroy the suspend blocker, close the device: + + close(fd); + +If the first ioctl called is not SUSPEND_BLOCKER_IOCTL_SET_NAME the suspend +blocker will get the default name "(userspace)". diff --git a/include/linux/suspend_ioctls.h b/include/linux/suspend_ioctls.h index 0b30382..b95a6b2 100644 --- a/include/linux/suspend_ioctls.h +++ b/include/linux/suspend_ioctls.h @@ -30,4 +30,8 @@ struct resume_swap_area { #define SNAPSHOT_ALLOC_SWAP_PAGE _IOR(SNAPSHOT_IOC_MAGIC, 20, __kernel_loff_t) #define SNAPSHOT_IOC_MAXNR 20 +#define SUSPEND_BLOCKER_IOCTL_SET_NAME(len) _IOC(_IOC_WRITE, 's', 0, len) +#define SUSPEND_BLOCKER_IOCTL_BLOCK _IO('s', 1) +#define SUSPEND_BLOCKER_IOCTL_UNBLOCK _IO('s', 2) + #endif /* _LINUX_SUSPEND_IOCTLS_H */ diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 6d11a45..2e665cd 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -146,6 +146,13 @@ 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 "User space suspend blockers" + depends on OPPORTUNISTIC_SUSPEND + ---help--- + User space suspend blockers API. Creates a misc device allowing user + space to create, use and destroy suspend blockers. + config HIBERNATION_NVS bool diff --git a/kernel/power/Makefile b/kernel/power/Makefile index 95d8e6d..2015594 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) += opportunistic_suspend.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..d53f939 --- /dev/null +++ b/kernel/power/user_suspend_blocker.c @@ -0,0 +1,143 @@ +/* + * kernel/power/user_suspend_blocker.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); + +#define USER_SUSPEND_BLOCKER_NAME_LEN 31 + +struct user_suspend_blocker { + struct suspend_blocker blocker; + char name[USER_SUSPEND_BLOCKER_NAME_LEN + 1]; + bool registered; +}; + +static int user_suspend_blocker_open(struct inode *inode, struct file *filp) +{ + struct user_suspend_blocker *blocker; + + blocker = kzalloc(sizeof(*blocker), GFP_KERNEL); + if (!blocker) + return -ENOMEM; + + nonseekable_open(inode, filp); + strcpy(blocker->name, "(userspace)"); + blocker->blocker.name = blocker->name; + filp->private_data = blocker; + + return 0; +} + +static int suspend_blocker_set_name(struct user_suspend_blocker *blocker, + void __user *name, size_t name_len) +{ + if (blocker->registered) + return -EBUSY; + + if (name_len > USER_SUSPEND_BLOCKER_NAME_LEN) + name_len = USER_SUSPEND_BLOCKER_NAME_LEN; + + if (copy_from_user(blocker->name, name, name_len)) + return -EFAULT; + blocker->name[name_len] = '\0'; + + return 0; +} + +static long user_suspend_blocker_ioctl(struct file *filp, unsigned int cmd, + unsigned long _arg) +{ + void __user *arg = (void __user *)_arg; + struct user_suspend_blocker *blocker = filp->private_data; + long ret = 0; + + mutex_lock(&ioctl_lock); + if ((cmd & ~IOCSIZE_MASK) == SUSPEND_BLOCKER_IOCTL_SET_NAME(0)) { + ret = suspend_blocker_set_name(blocker, arg, _IOC_SIZE(cmd)); + goto done; + } + if (!blocker->registered) { + suspend_blocker_register(&blocker->blocker); + blocker->registered = true; + } + switch (cmd) { + case SUSPEND_BLOCKER_IOCTL_BLOCK: + suspend_block(&blocker->blocker); + break; + + case SUSPEND_BLOCKER_IOCTL_UNBLOCK: + suspend_unblock(&blocker->blocker); + break; + + default: + ret = -ENOTTY; + } +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 *filp) +{ + struct user_suspend_blocker *blocker = filp->private_data; + + if (blocker->registered) + suspend_blocker_unregister(&blocker->blocker); + kfree(blocker); + + return 0; +} + +const struct file_operations user_suspend_blocker_fops = { + .open = user_suspend_blocker_open, + .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