From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bartlomiej Zolnierkiewicz Subject: [PATCH] ide: use lock bitops for ports serialization (v2) Date: Sun, 21 Dec 2008 21:56:07 +0100 Message-ID: <200812212156.08723.bzolnier@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: base64 Return-path: Received: from mail-bw0-f21.google.com ([209.85.218.21]:34662 "EHLO mail-bw0-f21.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751380AbYLUU55 (ORCPT ); Sun, 21 Dec 2008 15:57:57 -0500 Content-Disposition: inline Sender: linux-ide-owner@vger.kernel.org List-Id: linux-ide@vger.kernel.org To: linux-ide@vger.kernel.org Cc: linux-kernel@vger.kernel.org CmR1cmluZyBtb3JlIHRlc3RpbmcgaXQgdHVybmVkIG91dCB0aGF0IHYxIHdhcyB0b28gb3B0aW1p c3RpYyB3LnIudC4KZGV2aWNlcyBzZXJpYWxpemF0aW9uLCB2MiBmaXhlcyBpdCAoc28gdGhlIHBh dGNoIGNhbiBiZSBmaW5hbGx5IG1lcmdlZAppbnRvIHBhdGEtMi42IHRyZWUpCgpGcm9tOiBCYXJ0 bG9taWVqIFpvbG5pZXJraWV3aWN6IDxiem9sbmllckBnbWFpbC5jb20+ClN1YmplY3Q6IFtQQVRD SF0gaWRlOiB1c2UgbG9jayBiaXRvcHMgZm9yIHBvcnRzIHNlcmlhbGl6YXRpb24gKHYyKQoKKiBB ZGQgLT5ob3N0X2J1c3kgZmllbGQgdG8gc3RydWN0IGlkZV9ob3N0IGFuZCB1c2UgaXQncyBmaXJz dCBiaXQKICB0b2dldGhlciB3aXRoIGxvY2sgYml0b3BzIHRvIHByb3ZpZGUgbmV3IHBvcnRzIHNl cmlhbGl6YXRpb24gbWV0aG9kLgoKKiBDb252ZXJ0IGNvcmUgSURFIGNvZGUgdG8gdXNlIG5ldyBp ZGVfW3VuXWxvY2tfaG9zdCgpIGhlbHBlcnMuCgogIFRoaXMgcmVtb3ZlcyB0aGUgbmVlZCBmb3Ig dGFraW5nIGh3Z3JvdXAtPmxvY2sgaWYgaG9zdCBpcyBhbHJlYWR5CiAgYnVzeSBvbiBzZXJpYWxp emVkIGhvc3RzIGFuZCBtYWtlcyBpdCBwb3NzaWJsZSB0byBtZXJnZSBpZGVfaHdncm91cF90CiAg aW50byBpZGVfaHdpZl90IChkb25lIGluIHRoZSBsYXRlciBwYXRjaCkuCgoqIFJlbW92ZSBubyBs b25nZXIgbmVlZGVkIGlkZV9od2dyb3VwX3QuYnVzeSBhbmQgaWRlX1t1bl1sb2NrX2h3Z3JvdXAo KS4KCiogVXBkYXRlIGRvX2lkZV9yZXF1ZXN0KCkgZG9jdW1lbnRhdGlvbi4KCnYyOgoqIGlkZV9y ZWxlYXNlX2xvY2soKSBzaG91bGQgYmUgY2FsbGVkIGluc2lkZSBJREVfSEZMQUdfU0VSSUFMSVpF IGNoZWNrLgoKKiBBZGQgaWRlX2h3aWZfdC5idXN5IGZsYWcgYW5kIGlkZV9bdW5dbG9ja19wb3J0 KCkgZm9yIHNlcmlhbGl6aW5nCiAgZGV2aWNlcyBvbiBhIHBvcnQuCgpTaWduZWQtb2ZmLWJ5OiBC YXJ0bG9taWVqIFpvbG5pZXJraWV3aWN6IDxiem9sbmllckBnbWFpbC5jb20+Ci0tLQogZHJpdmVy cy9pZGUvaWRlLWlvLmMgfCAgMTA1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0t LS0tLS0tLS0tLS0tLS0tLQogaW5jbHVkZS9saW51eC9pZGUuaCAgfCAgIDM1ICsrLS0tLS0tLS0t LS0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDY5IGluc2VydGlvbnMoKyksIDcxIGRlbGV0aW9ucygt KQoKSW5kZXg6IGIvZHJpdmVycy9pZGUvaWRlLWlvLmMKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gYS9kcml2ZXJz L2lkZS9pZGUtaW8uYworKysgYi9kcml2ZXJzL2lkZS9pZGUtaW8uYwpAQCAtNjY2LDQ1ICs2NjYs NTQgQEAgdm9pZCBpZGVfc3RhbGxfcXVldWUgKGlkZV9kcml2ZV90ICpkcml2ZQogfQogRVhQT1JU X1NZTUJPTChpZGVfc3RhbGxfcXVldWUpOwogCitzdGF0aWMgaW5saW5lIGludCBpZGVfbG9ja19w b3J0KGlkZV9od2lmX3QgKmh3aWYpCit7CisJaWYgKGh3aWYtPmJ1c3kpCisJCXJldHVybiAxOwor CisJaHdpZi0+YnVzeSA9IDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB2b2lk IGlkZV91bmxvY2tfcG9ydChpZGVfaHdpZl90ICpod2lmKQoreworCWh3aWYtPmJ1c3kgPSAwOwor fQorCitzdGF0aWMgaW5saW5lIGludCBpZGVfbG9ja19ob3N0KHN0cnVjdCBpZGVfaG9zdCAqaG9z dCwgaWRlX2h3aWZfdCAqaHdpZikKK3sKKwlpbnQgcmMgPSAwOworCisJaWYgKGhvc3QtPmhvc3Rf ZmxhZ3MgJiBJREVfSEZMQUdfU0VSSUFMSVpFKSB7CisJCXJjID0gdGVzdF9hbmRfc2V0X2JpdF9s b2NrKElERV9IT1NUX0JVU1ksICZob3N0LT5ob3N0X2J1c3kpOworCQlpZiAocmMgPT0gMCkgewor CQkJLyogZm9yIGF0YXJpIG9ubHkgKi8KKwkJCWlkZV9nZXRfbG9jayhpZGVfaW50ciwgaHdpZik7 CisJCX0KKwl9CisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgaWRlX3VubG9j a19ob3N0KHN0cnVjdCBpZGVfaG9zdCAqaG9zdCkKK3sKKwlpZiAoaG9zdC0+aG9zdF9mbGFncyAm IElERV9IRkxBR19TRVJJQUxJWkUpIHsKKwkJLyogZm9yIGF0YXJpIG9ubHkgKi8KKwkJaWRlX3Jl bGVhc2VfbG9jaygpOworCQljbGVhcl9iaXRfdW5sb2NrKElERV9IT1NUX0JVU1ksICZob3N0LT5o b3N0X2J1c3kpOworCX0KK30KKwogLyoKICAqIElzc3VlIGEgbmV3IHJlcXVlc3QgdG8gYSBkcml2 ZSBmcm9tIGh3Z3JvdXAKLSAqCi0gKiBBIGh3Z3JvdXAgaXMgYSBzZXJpYWxpemVkIGdyb3VwIG9m IElERSBpbnRlcmZhY2VzLiAgVXN1YWxseSB0aGVyZSBpcwotICogZXhhY3RseSBvbmUgaHdpZiAo aW50ZXJmYWNlKSBwZXIgaHdncm91cCwgYnV0IGJ1Z2d5IGNvbnRyb2xsZXJzIChlZy4gQ01ENjQw KQotICogbWF5IGhhdmUgYm90aCBpbnRlcmZhY2VzIGluIGEgc2luZ2xlIGh3Z3JvdXAgdG8gInNl cmlhbGl6ZSIgYWNjZXNzLgotICogT3IgcG9zc2libHkgbXVsdGlwbGUgSVNBIGludGVyZmFjZXMg Y2FuIHNoYXJlIGEgY29tbW9uIElSUSBieSBiZWluZyBncm91cGVkCi0gKiB0b2dldGhlciBpbnRv IG9uZSBod2dyb3VwIGZvciBzZXJpYWxpemVkIGFjY2Vzcy4KLSAqCi0gKiBOb3RlIGFsc28gdGhh dCBzZXZlcmFsIGh3Z3JvdXBzIGNhbiBlbmQgdXAgc2hhcmluZyBhIHNpbmdsZSBJUlEsCi0gKiBw b3NzaWJseSBhbG9uZyB3aXRoIG1hbnkgb3RoZXIgZGV2aWNlcy4gIFRoaXMgaXMgZXNwZWNpYWxs eSBjb21tb24gaW4KLSAqIFBDSS1iYXNlZCBzeXN0ZW1zIHdpdGggb2ZmLWJvYXJkIElERSBjb250 cm9sbGVyIGNhcmRzLgotICoKLSAqIFRoZSBJREUgZHJpdmVyIHVzZXMgYSBwZXItaHdncm91cCBs b2NrIHRvIHByb3RlY3QgdGhlIGh3Z3JvdXAtPmJ1c3kgZmxhZy4KLSAqCi0gKiBUaGUgZmlyc3Qg dGhyZWFkIGludG8gdGhlIGRyaXZlciBmb3IgYSBwYXJ0aWN1bGFyIGh3Z3JvdXAgc2V0cyB0aGUK LSAqIGh3Z3JvdXAtPmJ1c3kgZmxhZyB0byBpbmRpY2F0ZSB0aGF0IHRoaXMgaHdncm91cCBpcyBu b3cgYWN0aXZlLAotICogYW5kIHRoZW4gaW5pdGlhdGVzIHByb2Nlc3Npbmcgb2YgdGhlIHRvcCBy ZXF1ZXN0IGZyb20gdGhlIHJlcXVlc3QgcXVldWUuCi0gKgotICogT3RoZXIgdGhyZWFkcyBhdHRl bXB0aW5nIGVudHJ5IG5vdGljZSB0aGUgYnVzeSBzZXR0aW5nLCBhbmQgd2lsbCBzaW1wbHkKLSAq IHF1ZXVlIHRoZWlyIG5ldyByZXF1ZXN0cyBhbmQgZXhpdCBpbW1lZGlhdGVseS4gIE5vdGUgdGhh dCBod2dyb3VwLT5idXN5Ci0gKiByZW1haW5zIHNldCBldmVuIHdoZW4gdGhlIGRyaXZlciBpcyBt ZXJlbHkgYXdhaXRpbmcgdGhlIG5leHQgaW50ZXJydXB0LgotICogVGh1cywgdGhlIG1lYW5pbmcg aXMgInRoaXMgaHdncm91cCBpcyBidXN5IHByb2Nlc3NpbmcgYSByZXF1ZXN0Ii4KLSAqCi0gKiBX aGVuIHByb2Nlc3Npbmcgb2YgYSByZXF1ZXN0IGNvbXBsZXRlcywgdGhlIGNvbXBsZXRpbmcgdGhy ZWFkIG9yIElSUS1oYW5kbGVyCi0gKiB3aWxsIHN0YXJ0IHRoZSBuZXh0IHJlcXVlc3QgZnJvbSB0 aGUgcXVldWUuICBJZiBubyBtb3JlIHdvcmsgcmVtYWlucywKLSAqIHRoZSBkcml2ZXIgd2lsbCBj bGVhciB0aGUgaHdncm91cC0+YnVzeSBmbGFnIGFuZCBleGl0LgotICoKLSAqIFRoZSBwZXItaHdn cm91cCBzcGlubG9jayBpcyB1c2VkIHRvIHByb3RlY3QgYWxsIGFjY2VzcyB0byB0aGUKLSAqIGh3 Z3JvdXAtPmJ1c3kgZmxhZywgYnV0IGlzIG90aGVyd2lzZSBub3QgbmVlZGVkIGZvciBtb3N0IHBy b2Nlc3NpbmcgaW4KLSAqIHRoZSBkcml2ZXIuICBUaGlzIG1ha2VzIHRoZSBkcml2ZXIgbXVjaCBt b3JlIGZyaWVuZGxpZXIgdG8gc2hhcmVkIElSUXMKLSAqIHRoYW4gcHJldmlvdXMgZGVzaWducywg d2hpbGUgcmVtYWluaW5nIDEwMCUgKD8pIFNNUCBzYWZlIGFuZCBjYXBhYmxlLgogICovCiB2b2lk IGRvX2lkZV9yZXF1ZXN0KHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxKQogewogCWlkZV9kcml2ZV90 CSpkcml2ZSA9IHEtPnF1ZXVlZGF0YTsKIAlpZGVfaHdpZl90CSpod2lmID0gZHJpdmUtPmh3aWY7 CisJc3RydWN0IGlkZV9ob3N0ICpob3N0ID0gaHdpZi0+aG9zdDsKIAlpZGVfaHdncm91cF90CSpo d2dyb3VwID0gaHdpZi0+aHdncm91cDsKLQlzdHJ1Y3QgcmVxdWVzdAkqcnE7CisJc3RydWN0IHJl cXVlc3QJKnJxID0gTlVMTDsKIAlpZGVfc3RhcnRzdG9wX3QJc3RhcnRzdG9wOwogCiAJLyoKQEAg LTcyMSw5ICs3MzAsMTMgQEAgdm9pZCBkb19pZGVfcmVxdWVzdChzdHJ1Y3QgcmVxdWVzdF9xdWV1 ZQogCQlibGtfcmVtb3ZlX3BsdWcocSk7CiAKIAlzcGluX3VubG9ja19pcnEocS0+cXVldWVfbG9j ayk7CisKKwlpZiAoaWRlX2xvY2tfaG9zdChob3N0LCBod2lmKSkKKwkJZ290byBwbHVnX2Rldmlj ZV8yOworCiAJc3Bpbl9sb2NrX2lycSgmaHdncm91cC0+bG9jayk7CiAKLQlpZiAoIWlkZV9sb2Nr X2h3Z3JvdXAoaHdncm91cCwgaHdpZikpIHsKKwlpZiAoIWlkZV9sb2NrX3BvcnQoaHdpZikpIHsK IAkJaWRlX2h3aWZfdCAqcHJldl9wb3J0OwogcmVwZWF0OgogCQlwcmV2X3BvcnQgPSBod2lmLT5o b3N0LT5jdXJfcG9ydDsKQEAgLTczMSw3ICs3NDQsNyBAQCByZXBlYXQ6CiAKIAkJaWYgKGRyaXZl LT5kZXZfZmxhZ3MgJiBJREVfREZMQUdfU0xFRVBJTkcpIHsKIAkJCWlmICh0aW1lX2JlZm9yZShk cml2ZS0+c2xlZXAsIGppZmZpZXMpKSB7Ci0JCQkJaWRlX3VubG9ja19od2dyb3VwKGh3Z3JvdXAp OworCQkJCWlkZV91bmxvY2tfcG9ydChod2lmKTsKIAkJCQlnb3RvIHBsdWdfZGV2aWNlOwogCQkJ fQogCQl9CkBAIC03NjEsNyArNzc0LDcgQEAgcmVwZWF0OgogCQlzcGluX2xvY2tfaXJxKCZod2dy b3VwLT5sb2NrKTsKIAogCQlpZiAoIXJxKSB7Ci0JCQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91 cCk7CisJCQlpZGVfdW5sb2NrX3BvcnQoaHdpZik7CiAJCQlnb3RvIG91dDsKIAkJfQogCkBAIC03 ODIsNyArNzk1LDcgQEAgcmVwZWF0OgogCQkgICAgYmxrX3BtX3JlcXVlc3QocnEpID09IDAgJiYK IAkJICAgIChycS0+Y21kX2ZsYWdzICYgUkVRX1BSRUVNUFQpID09IDApIHsKIAkJCS8qIHRoZXJl IHNob3VsZCBiZSBubyBwZW5kaW5nIGNvbW1hbmQgYXQgdGhpcyBwb2ludCAqLwotCQkJaWRlX3Vu bG9ja19od2dyb3VwKGh3Z3JvdXApOworCQkJaWRlX3VubG9ja19wb3J0KGh3aWYpOwogCQkJZ290 byBwbHVnX2RldmljZTsKIAkJfQogCkBAIC03OTgsMTEgKzgxMSwxNSBAQCByZXBlYXQ6CiAJCWdv dG8gcGx1Z19kZXZpY2U7CiBvdXQ6CiAJc3Bpbl91bmxvY2tfaXJxKCZod2dyb3VwLT5sb2NrKTsK KwlpZiAocnEgPT0gTlVMTCkKKwkJaWRlX3VubG9ja19ob3N0KGhvc3QpOwogCXNwaW5fbG9ja19p cnEocS0+cXVldWVfbG9jayk7CiAJcmV0dXJuOwogCiBwbHVnX2RldmljZToKIAlzcGluX3VubG9j a19pcnEoJmh3Z3JvdXAtPmxvY2spOworCWlkZV91bmxvY2tfaG9zdChob3N0KTsKK3BsdWdfZGV2 aWNlXzI6CiAJc3Bpbl9sb2NrX2lycShxLT5xdWV1ZV9sb2NrKTsKIAogCWlmICghZWx2X3F1ZXVl X2VtcHR5KHEpKQpAQCAtODQ0LDkgKzg2MSw5IEBAIHN0YXRpYyBpZGVfc3RhcnRzdG9wX3QgaWRl X2RtYV90aW1lb3V0X3IKIAlpZGVfZG1hX29mZl9xdWlldGx5KGRyaXZlKTsKIAogCS8qCi0JICog dW4tYnVzeSBkcml2ZSBldGMgKGh3Z3JvdXAtPmJ1c3kgaXMgY2xlYXJlZCBvbiByZXR1cm4pIGFu ZAotCSAqIG1ha2Ugc3VyZSByZXF1ZXN0IGlzIHNhbmUKKwkgKiB1bi1idXN5IGRyaXZlIGV0YyBh bmQgbWFrZSBzdXJlIHJlcXVlc3QgaXMgc2FuZQogCSAqLworCiAJcnEgPSBIV0dST1VQKGRyaXZl KS0+cnE7CiAKIAlpZiAoIXJxKQpAQCAtODk1LDYgKzkxMiw3IEBAIHN0YXRpYyB2b2lkIGlkZV9w bHVnX2RldmljZShpZGVfZHJpdmVfdCAKIHZvaWQgaWRlX3RpbWVyX2V4cGlyeSAodW5zaWduZWQg bG9uZyBkYXRhKQogewogCWlkZV9od2dyb3VwX3QJKmh3Z3JvdXAgPSAoaWRlX2h3Z3JvdXBfdCAq KSBkYXRhOworCWlkZV9od2lmX3QJKnVuaW5pdGlhbGl6ZWRfdmFyKGh3aWYpOwogCWlkZV9kcml2 ZV90CSp1bmluaXRpYWxpemVkX3Zhcihkcml2ZSk7CiAJaWRlX2hhbmRsZXJfdAkqaGFuZGxlcjsK IAlpZGVfZXhwaXJ5X3QJKmV4cGlyeTsKQEAgLTkxOCw3ICs5MzYsNiBAQCB2b2lkIGlkZV90aW1l cl9leHBpcnkgKHVuc2lnbmVkIGxvbmcgZGF0CiAJCQlwcmludGsoS0VSTl9FUlIgIiVzOiAtPmN1 cl9kZXYgd2FzIE5VTExcbiIsIF9fZnVuY19fKTsKIAkJCWh3Z3JvdXAtPmhhbmRsZXIgPSBOVUxM OwogCQl9IGVsc2UgewotCQkJaWRlX2h3aWZfdCAqaHdpZjsKIAkJCWlkZV9zdGFydHN0b3BfdCBz dGFydHN0b3AgPSBpZGVfc3RvcHBlZDsKIAogCQkJaWYgKChleHBpcnkgPSBod2dyb3VwLT5leHBp cnkpICE9IE5VTEwpIHsKQEAgLTk2NCwxNSArOTgxLDE3IEBAIHZvaWQgaWRlX3RpbWVyX2V4cGly eSAodW5zaWduZWQgbG9uZyBkYXQKIAkJCXNwaW5fbG9ja19pcnEoJmh3Z3JvdXAtPmxvY2spOwog CQkJZW5hYmxlX2lycShod2lmLT5pcnEpOwogCQkJaWYgKHN0YXJ0c3RvcCA9PSBpZGVfc3RvcHBl ZCkgewotCQkJCWlkZV91bmxvY2tfaHdncm91cChod2dyb3VwKTsKKwkJCQlpZGVfdW5sb2NrX3Bv cnQoaHdpZik7CiAJCQkJcGx1Z19kZXZpY2UgPSAxOwogCQkJfQogCQl9CiAJfQogCXNwaW5fdW5s b2NrX2lycXJlc3RvcmUoJmh3Z3JvdXAtPmxvY2ssIGZsYWdzKTsKIAotCWlmIChwbHVnX2Rldmlj ZSkKKwlpZiAocGx1Z19kZXZpY2UpIHsKKwkJaWRlX3VubG9ja19ob3N0KGh3aWYtPmhvc3QpOwog CQlpZGVfcGx1Z19kZXZpY2UoZHJpdmUpOworCX0KIH0KIAogLyoqCkBAIC0xMTUwLDcgKzExNjks NyBAQCBpcnFyZXR1cm5fdCBpZGVfaW50ciAoaW50IGlycSwgdm9pZCAqZGV2CiAJICovCiAJaWYg KHN0YXJ0c3RvcCA9PSBpZGVfc3RvcHBlZCkgewogCQlpZiAoaHdncm91cC0+aGFuZGxlciA9PSBO VUxMKSB7CS8qIHBhcmFub2lhICovCi0JCQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91cCk7CisJ CQlpZGVfdW5sb2NrX3BvcnQoaHdpZik7CiAJCQlwbHVnX2RldmljZSA9IDE7CiAJCX0gZWxzZQog CQkJcHJpbnRrKEtFUk5fRVJSICIlczogJXM6IGh1aD8gZXhwZWN0ZWQgTlVMTCBoYW5kbGVyICIK QEAgLTExNjEsOCArMTE4MCwxMCBAQCBvdXRfaGFuZGxlZDoKIG91dDoKIAlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZod2dyb3VwLT5sb2NrLCBmbGFncyk7CiBvdXRfZWFybHk6Ci0JaWYgKHBsdWdf ZGV2aWNlKQorCWlmIChwbHVnX2RldmljZSkgeworCQlpZGVfdW5sb2NrX2hvc3QoaHdpZi0+aG9z dCk7CiAJCWlkZV9wbHVnX2RldmljZShkcml2ZSk7CisJfQogCiAJcmV0dXJuIGlycV9yZXQ7CiB9 CkluZGV4OiBiL2luY2x1ZGUvbGludXgvaWRlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gYS9pbmNsdWRlL2xp bnV4L2lkZS5oCisrKyBiL2luY2x1ZGUvbGludXgvaWRlLmgKQEAgLTgyOCw2ICs4MjgsNyBAQCB0 eXBlZGVmIHN0cnVjdCBod2lmX3MgewogCiAJdW5zaWduZWQJcHJlc2VudCAgICA6IDE7CS8qIHRo aXMgaW50ZXJmYWNlIGV4aXN0cyAqLwogCXVuc2lnbmVkCXNnX21hcHBlZCAgOiAxOwkvKiBzZ190 YWJsZSBhbmQgc2dfbmVudHMgYXJlIHJlYWR5ICovCisJdW5zaWduZWQJYnVzeQkgICA6IDE7IC8q IHNlcmlhbGl6ZXMgZGV2aWNlcyBvbiBhIHBvcnQgKi8KIAogCXN0cnVjdCBkZXZpY2UJCWdlbmRl djsKIAlzdHJ1Y3QgZGV2aWNlCQkqcG9ydGRldjsKQEAgLTg1MSw4ICs4NTIsMTMgQEAgc3RydWN0 IGlkZV9ob3N0IHsKIAl1bnNpZ25lZCBsb25nCWhvc3RfZmxhZ3M7CiAJdm9pZAkJKmhvc3RfcHJp djsKIAlpZGVfaHdpZl90CSpjdXJfcG9ydDsJLyogZm9yIGhvc3RzIHJlcXVpcmluZyBzZXJpYWxp emF0aW9uICovCisKKwkvKiB1c2VkIGZvciBob3N0cyByZXF1aXJpbmcgc2VyaWFsaXphdGlvbiAq LworCXZvbGF0aWxlIGxvbmcJaG9zdF9idXN5OwogfTsKIAorI2RlZmluZSBJREVfSE9TVF9CVVNZ IDAKKwogLyoKICAqICBpbnRlcm5hbCBpZGUgaW50ZXJydXB0IGhhbmRsZXIgdHlwZQogICovCkBA IC04NjYsOCArODcyLDYgQEAgdHlwZWRlZiBzdHJ1Y3QgaHdncm91cF9zIHsKIAkJLyogaXJxIGhh bmRsZXIsIGlmIGFjdGl2ZSAqLwogCWlkZV9zdGFydHN0b3BfdAkoKmhhbmRsZXIpKGlkZV9kcml2 ZV90ICopOwogCi0JCS8qIEJPT0w6IHByb3RlY3RzIGFsbCBmaWVsZHMgYmVsb3cgKi8KLQl2b2xh dGlsZSBpbnQgYnVzeTsKIAkJLyogQk9PTDogcG9sbGluZyBhY3RpdmUgJiBwb2xsX3RpbWVvdXQg ZmllbGQgdmFsaWQgKi8KIAl1bnNpZ25lZCBpbnQgcG9sbGluZwk6IDE7CiAKQEAgLTEyNzEsMjYg KzEyNzUsNiBAQCBleHRlcm4gdm9pZCBpZGVfc3RhbGxfcXVldWUoaWRlX2RyaXZlX3QgCiAKIGV4 dGVybiB2b2lkIGlkZV90aW1lcl9leHBpcnkodW5zaWduZWQgbG9uZyk7CiBleHRlcm4gaXJxcmV0 dXJuX3QgaWRlX2ludHIoaW50IGlycSwgdm9pZCAqZGV2X2lkKTsKLQotc3RhdGljIGlubGluZSBp bnQgaWRlX2xvY2tfaHdncm91cChpZGVfaHdncm91cF90ICpod2dyb3VwLCBpZGVfaHdpZl90ICpo d2lmKQotewotCWlmIChod2dyb3VwLT5idXN5KQotCQlyZXR1cm4gMTsKLQotCWh3Z3JvdXAtPmJ1 c3kgPSAxOwotCS8qIGZvciBhdGFyaSBvbmx5ICovCi0JaWRlX2dldF9sb2NrKGlkZV9pbnRyLCBo d2lmKTsKLQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgaWRlX3VubG9ja19o d2dyb3VwKGlkZV9od2dyb3VwX3QgKmh3Z3JvdXApCi17Ci0JLyogZm9yIGF0YXJpIG9ubHkgKi8K LQlpZGVfcmVsZWFzZV9sb2NrKCk7Ci0JaHdncm91cC0+YnVzeSA9IDA7Ci19Ci0KIGV4dGVybiB2 b2lkIGRvX2lkZV9yZXF1ZXN0KHN0cnVjdCByZXF1ZXN0X3F1ZXVlICopOwogCiB2b2lkIGlkZV9p bml0X2Rpc2soc3RydWN0IGdlbmRpc2sgKiwgaWRlX2RyaXZlX3QgKik7CkBAIC0xNjE3LDEzICsx NjAxLDYgQEAgc3RhdGljIGlubGluZSB2b2lkIGlkZV9zZXRfbWF4X3BpbyhpZGVfZAogCiBleHRl cm4gc3BpbmxvY2tfdCBpZGVfbG9jazsKIGV4dGVybiBzdHJ1Y3QgbXV0ZXggaWRlX2NmZ19tdHg7 Ci0vKgotICogU3RydWN0dXJlIGxvY2tpbmc6Ci0gKgotICogaWRlX2h3Z3JvdXBfdC0+YnVzeTog aHdncm91cC0+bG9jawotICogaWRlX2h3aWZfdC0+e2h3Z3JvdXAsbWF0ZX06IGNvbnN0YW50LCBu byBsb2NraW5nCi0gKiBpZGVfZHJpdmVfdC0+aHdpZjogY29uc3RhbnQsIG5vIGxvY2tpbmcKLSAq LwogCiAjZGVmaW5lIGxvY2FsX2lycV9zZXQoZmxhZ3MpCWRvIHsgbG9jYWxfc2F2ZV9mbGFncygo ZmxhZ3MpKTsgbG9jYWxfaXJxX2VuYWJsZV9pbl9oYXJkaXJxKCk7IH0gd2hpbGUgKDApCiAKAAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753960AbYLUU65 (ORCPT ); Sun, 21 Dec 2008 15:58:57 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1751611AbYLUU6A (ORCPT ); Sun, 21 Dec 2008 15:58:00 -0500 Received: from mail-bw0-f21.google.com ([209.85.218.21]:34662 "EHLO mail-bw0-f21.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751380AbYLUU55 (ORCPT ); Sun, 21 Dec 2008 15:57:57 -0500 DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=from:to:subject:date:user-agent:cc:mime-version:content-type :content-transfer-encoding:content-disposition:message-id; b=pis7dSv1STDO95Kq+60y49mzhRFXSJjOKGlCdD/J65uAKayb1459nPPYx0YCSRA6vQ Gi9RiKbs7KjLEBlmEwk9DUMJXBRHTdSPYVjUdFKfBxl+wK47/eHAfln67CKmc7WmqG3j ciaY8ktfXNB+jUpvVKIDoqGhVEXXvPVqpYNzo= From: Bartlomiej Zolnierkiewicz To: linux-ide@vger.kernel.org Subject: [PATCH] ide: use lock bitops for ports serialization (v2) Date: Sun, 21 Dec 2008 21:56:07 +0100 User-Agent: KMail/1.10.3 (Linux/2.6.28-rc8-next-20081219; KDE/4.1.3; i686; ; ) Cc: linux-kernel@vger.kernel.org MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Disposition: inline Message-Id: <200812212156.08723.bzolnier@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by alpha id mBLKxfki010493 during more testing it turned out that v1 was too optimistic w.r.t.devices serialization, v2 fixes it (so the patch can be finally mergedinto pata-2.6 tree) From: Bartlomiej Zolnierkiewicz Subject: [PATCH] ide: use lock bitops for ports serialization (v2) * Add ->host_busy field to struct ide_host and use it's first bit together with lock bitops to provide new ports serialization method. * Convert core IDE code to use new ide_[un]lock_host() helpers. This removes the need for taking hwgroup->lock if host is already busy on serialized hosts and makes it possible to merge ide_hwgroup_t into ide_hwif_t (done in the later patch). * Remove no longer needed ide_hwgroup_t.busy and ide_[un]lock_hwgroup(). * Update do_ide_request() documentation. v2:* ide_release_lock() should be called inside IDE_HFLAG_SERIALIZE check. * Add ide_hwif_t.busy flag and ide_[un]lock_port() for serializing devices on a port. Signed-off-by: Bartlomiej Zolnierkiewicz --- drivers/ide/ide-io.c | 105 ++++++++++++++++++++++++++++++--------------------- include/linux/ide.h | 35 ++--------------- 2 files changed, 69 insertions(+), 71 deletions(-) Index: b/drivers/ide/ide-io.c===================================================================--- a/drivers/ide/ide-io.c+++ b/drivers/ide/ide-io.c@@ -666,45 +666,54 @@ void ide_stall_queue (ide_drive_t *drive } EXPORT_SYMBOL(ide_stall_queue); +static inline int ide_lock_port(ide_hwif_t *hwif)+{+ if (hwif->busy)+ return 1;++ hwif->busy = 1;++ return 0;+}++static inline void ide_unlock_port(ide_hwif_t *hwif)+{+ hwif->busy = 0;+}++static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif)+{+ int rc = 0;++ if (host->host_flags & IDE_HFLAG_SERIALIZE) {+ rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy);+ if (rc == 0) {+ /* for atari only */+ ide_get_lock(ide_intr, hwif);+ }+ }+ return rc;+}++static inline void ide_unlock_host(struct ide_host *host)+{+ if (host->host_flags & IDE_HFLAG_SERIALIZE) {+ /* for atari only */+ ide_release_lock();+ clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy);+ }+}+ /* * Issue a new request to a drive from hwgroup- *- * A hwgroup is a serialized group of IDE interfaces. Usually there is- * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640)- * may have both interfaces in a single hwgroup to "serialize" access.- * Or possibly multiple ISA interfaces can share a common IRQ by being grouped- * together into one hwgroup for serialized access.- *- * Note also that several hwgroups can end up sharing a single IRQ,- * possibly along with many other devices. This is especially common in- * PCI-based systems with off-board IDE controller cards.- *- * The IDE driver uses a per-hwgroup lock to protect the hwgroup->busy flag.- *- * The first thread into the driver for a particular hwgroup sets the- * hwgroup->busy flag to indicate that this hwgroup is now active,- * and then initiates processing of the top request from the request queue.- *- * Other threads attempting entry notice the busy setting, and will simply- * queue their new requests and exit immediately. Note that hwgroup->busy- * remains set even when the driver is merely awaiting the next interrupt.- * Thus, the meaning is "this hwgroup is busy processing a request".- *- * When processing of a request completes, the completing thread or IRQ-handler- * will start the next request from the queue. If no more work remains,- * the driver will clear the hwgroup->busy flag and exit.- *- * The per-hwgroup spinlock is used to protect all access to the- * hwgroup->busy flag, but is otherwise not needed for most processing in- * the driver. This makes the driver much more friendlier to shared IRQs- * than previous designs, while remaining 100% (?) SMP safe and capable. */ void do_ide_request(struct request_queue *q) { ide_drive_t *drive = q->queuedata; ide_hwif_t *hwif = drive->hwif;+ struct ide_host *host = hwif->host; ide_hwgroup_t *hwgroup = hwif->hwgroup;- struct request *rq;+ struct request *rq = NULL; ide_startstop_t startstop; /*@@ -721,9 +730,13 @@ void do_ide_request(struct request_queue blk_remove_plug(q); spin_unlock_irq(q->queue_lock);++ if (ide_lock_host(host, hwif))+ goto plug_device_2;+ spin_lock_irq(&hwgroup->lock); - if (!ide_lock_hwgroup(hwgroup, hwif)) {+ if (!ide_lock_port(hwif)) { ide_hwif_t *prev_port; repeat: prev_port = hwif->host->cur_port;@@ -731,7 +744,7 @@ repeat: if (drive->dev_flags & IDE_DFLAG_SLEEPING) { if (time_before(drive->sleep, jiffies)) {- ide_unlock_hwgroup(hwgroup);+ ide_unlock_port(hwif); goto plug_device; } }@@ -761,7 +774,7 @@ repeat: spin_lock_irq(&hwgroup->lock); if (!rq) {- ide_unlock_hwgroup(hwgroup);+ ide_unlock_port(hwif); goto out; } @@ -782,7 +795,7 @@ repeat: blk_pm_request(rq) == 0 && (rq->cmd_flags & REQ_PREEMPT) == 0) { /* there should be no pending command at this point */- ide_unlock_hwgroup(hwgroup);+ ide_unlock_port(hwif); goto plug_device; } @@ -798,11 +811,15 @@ repeat: goto plug_device; out: spin_unlock_irq(&hwgroup->lock);+ if (rq == NULL)+ ide_unlock_host(host); spin_lock_irq(q->queue_lock); return; plug_device: spin_unlock_irq(&hwgroup->lock);+ ide_unlock_host(host);+plug_device_2: spin_lock_irq(q->queue_lock); if (!elv_queue_empty(q))@@ -844,9 +861,9 @@ static ide_startstop_t ide_dma_timeout_r ide_dma_off_quietly(drive); /*- * un-busy drive etc (hwgroup->busy is cleared on return) and- * make sure request is sane+ * un-busy drive etc and make sure request is sane */+ rq = HWGROUP(drive)->rq; if (!rq)@@ -895,6 +912,7 @@ static void ide_plug_device(ide_drive_t void ide_timer_expiry (unsigned long data) { ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;+ ide_hwif_t *uninitialized_var(hwif); ide_drive_t *uninitialized_var(drive); ide_handler_t *handler; ide_expiry_t *expiry;@@ -918,7 +936,6 @@ void ide_timer_expiry (unsigned long dat printk(KERN_ERR "%s: ->cur_dev was NULL\n", __func__); hwgroup->handler = NULL; } else {- ide_hwif_t *hwif; ide_startstop_t startstop = ide_stopped; if ((expiry = hwgroup->expiry) != NULL) {@@ -964,15 +981,17 @@ void ide_timer_expiry (unsigned long dat spin_lock_irq(&hwgroup->lock); enable_irq(hwif->irq); if (startstop == ide_stopped) {- ide_unlock_hwgroup(hwgroup);+ ide_unlock_port(hwif); plug_device = 1; } } } spin_unlock_irqrestore(&hwgroup->lock, flags); - if (plug_device)+ if (plug_device) {+ ide_unlock_host(hwif->host); ide_plug_device(drive);+ } } /**@@ -1150,7 +1169,7 @@ irqreturn_t ide_intr (int irq, void *dev */ if (startstop == ide_stopped) { if (hwgroup->handler == NULL) { /* paranoia */- ide_unlock_hwgroup(hwgroup);+ ide_unlock_port(hwif); plug_device = 1; } else printk(KERN_ERR "%s: %s: huh? expected NULL handler "@@ -1161,8 +1180,10 @@ out_handled: out: spin_unlock_irqrestore(&hwgroup->lock, flags); out_early:- if (plug_device)+ if (plug_device) {+ ide_unlock_host(hwif->host); ide_plug_device(drive);+ } return irq_ret; }Index: b/include/linux/ide.h===================================================================--- a/include/linux/ide.h+++ b/include/linux/ide.h@@ -828,6 +828,7 @@ typedef struct hwif_s { unsigned present : 1; /* this interface exists */ unsigned sg_mapped : 1; /* sg_table and sg_nents are ready */+ unsigned busy : 1; /* serializes devices on a port */ struct device gendev; struct device *portdev;@@ -851,8 +852,13 @@ struct ide_host { unsigned long host_flags; void *host_priv; ide_hwif_t *cur_port; /* for hosts requiring serialization */++ /* used for hosts requiring serialization */+ volatile long host_busy; }; +#define IDE_HOST_BUSY 0+ /* * internal ide interrupt handler type */@@ -866,8 +872,6 @@ typedef struct hwgroup_s { /* irq handler, if active */ ide_startstop_t (*handler)(ide_drive_t *); - /* BOOL: protects all fields below */- volatile int busy; /* BOOL: polling active & poll_timeout field valid */ unsigned int polling : 1; @@ -1271,26 +1275,6 @@ extern void ide_stall_queue(ide_drive_t extern void ide_timer_expiry(unsigned long); extern irqreturn_t ide_intr(int irq, void *dev_id);--static inline int ide_lock_hwgroup(ide_hwgroup_t *hwgroup, ide_hwif_t *hwif)-{- if (hwgroup->busy)- return 1;-- hwgroup->busy = 1;- /* for atari only */- ide_get_lock(ide_intr, hwif);-- return 0;-}--static inline void ide_unlock_hwgroup(ide_hwgroup_t *hwgroup)-{- /* for atari only */- ide_release_lock();- hwgroup->busy = 0;-}- extern void do_ide_request(struct request_queue *); void ide_init_disk(struct gendisk *, ide_drive_t *);@@ -1617,13 +1601,6 @@ static inline void ide_set_max_pio(ide_d extern spinlock_t ide_lock; extern struct mutex ide_cfg_mtx;-/*- * Structure locking:- *- * ide_hwgroup_t->busy: hwgroup->lock- * ide_hwif_t->{hwgroup,mate}: constant, no locking- * ide_drive_t->hwif: constant, no locking- */ #define local_irq_set(flags) do { local_save_flags((flags)); local_irq_enable_in_hardirq(); } while (0) {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I