From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bartlomiej Zolnierkiewicz Subject: Re: [PATCH 3/3] ide: use per-device request queue locks Date: Sun, 14 Dec 2008 00:15:23 +0100 Message-ID: <200812140015.23853.bzolnier@gmail.com> References: <200811182119.21286.bzolnier@gmail.com> <87vdudjgfm.fsf@denkblock.local> Mime-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <87vdudjgfm.fsf@denkblock.local> Content-Disposition: inline Sender: linux-kernel-owner@vger.kernel.org To: Elias Oltmanns Cc: linux-ide@vger.kernel.org, linux-kernel@vger.kernel.org List-Id: linux-ide@vger.kernel.org ClsgT25jZSBhZ2Fpbiwgc29ycnkgZm9yIHRoZSBsb25nIGRlbGF5LiBdCgpPbiBNb25kYXkgMjQg Tm92ZW1iZXIgMjAwOCwgRWxpYXMgT2x0bWFubnMgd3JvdGU6Cj4gQmFydGxvbWllaiBab2xuaWVy a2lld2ljeiA8YnpvbG5pZXJAZ21haWwuY29tPiB3cm90ZToKPiA+ICogTW92ZSBoYWNrIGZvciBm bHVzaCByZXF1ZXN0cyBmcm9tIGNob29zZV9kcml2ZSgpIHRvIGRvX2lkZV9yZXF1ZXN0KCkuCj4g Pgo+ID4gKiBBZGQgaWRlX3BsdWdfZGV2aWNlKCkgaGVscGVyIGFuZCBjb252ZXJ0IGNvcmUgSURF IGNvZGUgZnJvbSB1c2luZwo+ID4gICBwZXItaHdncm91cCBsb2NrIGFzIGEgcmVxdWVzdCBsb2Nr IHRvIHVzZSB0aGUgLT5xdWV1ZV9sb2NrIGluc3RlYWQuCj4gPgo+ID4gKiBSZW1vdmUgbm8gbG9u Z2VyIG5lZWRlZDoKPiA+ICAgLSBjaG9vc2VfZHJpdmUoKSBmdW5jdGlvbgo+ID4gICAtIFdBS0VV UCgpIG1hY3JvCj4gPiAgIC0gJ3NsZWVwaW5nJyBmbGFnIGZyb20gaWRlX2h3aWZfdAo+ID4gICAt ICdzZXJ2aWNlX3tzdGFydCx0aW1lfScgZmllbGRzIGZyb20gaWRlX2RyaXZlX3QKPiA+Cj4gPiBU aGlzIHBhdGNoIHJlc3VsdHMgaW4gbXVjaCBzaW1wbGVyIGFuZCBtb3JlIG1haW50YWluYWJsZSBj b2RlCj4gPiAoYmVzaWRlcyBiZWluZyBhIHNjYWxhYmlsaXR5IGltcHJvdmVtZW50KS4KPiA+Cj4g PiBDYzogRWxpYXMgT2x0bWFubnMgPGVvQG5lYmVuc2FjaGVuLmRlPgo+ID4gU2lnbmVkLW9mZi1i eTogQmFydGxvbWllaiBab2xuaWVya2lld2ljeiA8YnpvbG5pZXJAZ21haWwuY29tPgo+ID4gLS0t Cj4gPiBuZXdlciB2ZXJzaW9uCj4gCj4gRXZlbnR1YWxseSwgSSBnb3Qgcm91bmQgdG8gaGF2aW5n IGEgbG9vayBhdCB0aGlzIG9uZSAoSSByZXZpZXdlZCB0aGUgdHdvCj4gc21hbGwgb25lcyBhdCB0 aGUgdGltZSkuIEFwb2xvZ2llcyBmb3IgdGhlIGRlbGF5Lgo+IAo+ID4KPiA+ICBkcml2ZXJzL2lk ZS9pZGUtaW8uYyAgICB8IDIxMyArKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KPiA+ICBkcml2ZXJzL2lkZS9pZGUtcGFyay5jICB8ICAgMTMgKy0KPiA+ICBk cml2ZXJzL2lkZS9pZGUtcHJvYmUuYyB8ICAgIDMgCj4gPiAgaW5jbHVkZS9saW51eC9pZGUuaCAg ICAgfCAgICA0IAo+ID4gIDQgZmlsZXMgY2hhbmdlZCwgNzkgaW5zZXJ0aW9ucygrKSwgMTU0IGRl bGV0aW9ucygtKQo+ID4KPiA+IEluZGV4OiBiL2RyaXZlcnMvaWRlL2lkZS1pby5jCj4gPiA9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Cj4gPiAtLS0gYS9kcml2ZXJzL2lkZS9pZGUtaW8uYwo+ID4gKysrIGIvZHJpdmVycy9p ZGUvaWRlLWlvLmMKPiBbLi4uXQo+ID4gQEAgLTc4MCw2MSArNzA0LDQwIEBAIHJlcGVhdDoJCj4g PiAgICovCj4gPiAgdm9pZCBkb19pZGVfcmVxdWVzdChzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSkK PiA+ICB7Cj4gPiAtCWlkZV9kcml2ZV90CSpvcmlnX2RyaXZlID0gcS0+cXVldWVkYXRhOwo+ID4g LQlpZGVfaHdncm91cF90CSpod2dyb3VwID0gb3JpZ19kcml2ZS0+aHdpZi0+aHdncm91cDsKPiA+ IC0JaWRlX2RyaXZlX3QJKmRyaXZlOwo+ID4gLQlpZGVfaHdpZl90CSpod2lmOwo+ID4gKwlpZGVf ZHJpdmVfdAkqZHJpdmUgPSBxLT5xdWV1ZWRhdGE7Cj4gPiArCWlkZV9od2lmX3QJKmh3aWYgPSBk cml2ZS0+aHdpZjsKPiA+ICsJaWRlX2h3Z3JvdXBfdAkqaHdncm91cCA9IGh3aWYtPmh3Z3JvdXA7 Cj4gPiAgCXN0cnVjdCByZXF1ZXN0CSpycTsKPiA+ICAJaWRlX3N0YXJ0c3RvcF90CXN0YXJ0c3Rv cDsKPiA+ICAKPiA+IC0JLyogY2FsbGVyIG11c3Qgb3duIGh3Z3JvdXAtPmxvY2sgKi8KPiA+IC0J QlVHX09OKCFpcnFzX2Rpc2FibGVkKCkpOwo+ID4gLQo+ID4gLQl3aGlsZSAoIWlkZV9sb2NrX2h3 Z3JvdXAoaHdncm91cCkpIHsKPiA+IC0JCWRyaXZlID0gY2hvb3NlX2RyaXZlKGh3Z3JvdXApOwo+ ID4gLQkJaWYgKGRyaXZlID09IE5VTEwpIHsKPiA+IC0JCQlpbnQgc2xlZXBpbmcgPSAwOwo+ID4g LQkJCXVuc2lnbmVkIGxvbmcgc2xlZXAgPSAwOyAvKiBzaHV0IHVwLCBnY2MgKi8KPiA+IC0JCQlo d2dyb3VwLT5ycSA9IE5VTEw7Cj4gPiAtCQkJZHJpdmUgPSBod2dyb3VwLT5kcml2ZTsKPiA+IC0J CQlkbyB7Cj4gPiAtCQkJCWlmICgoZHJpdmUtPmRldl9mbGFncyAmIElERV9ERkxBR19TTEVFUElO RykgJiYKPiA+IC0JCQkJICAgIChzbGVlcGluZyA9PSAwIHx8Cj4gPiAtCQkJCSAgICAgdGltZV9i ZWZvcmUoZHJpdmUtPnNsZWVwLCBzbGVlcCkpKSB7Cj4gPiAtCQkJCQlzbGVlcGluZyA9IDE7Cj4g PiAtCQkJCQlzbGVlcCA9IGRyaXZlLT5zbGVlcDsKPiA+IC0JCQkJfQo+ID4gLQkJCX0gd2hpbGUg KChkcml2ZSA9IGRyaXZlLT5uZXh0KSAhPSBod2dyb3VwLT5kcml2ZSk7Cj4gPiAtCQkJaWYgKHNs ZWVwaW5nKSB7Cj4gPiArCS8qCj4gPiArCSAqIGRyaXZlIGlzIGRvaW5nIHByZS1mbHVzaCwgb3Jk ZXJlZCB3cml0ZSwgcG9zdC1mbHVzaCBzZXF1ZW5jZS4gZXZlbgo+ID4gKwkgKiB0aG91Z2ggdGhh dCBpcyAzIHJlcXVlc3RzLCBpdCBtdXN0IGJlIHNlZW4gYXMgYSBzaW5nbGUgdHJhbnNhY3Rpb24u Cj4gPiArCSAqIHdlIG11c3Qgbm90IHByZWVtcHQgdGhpcyBkcml2ZSB1bnRpbCB0aGF0IGlzIGNv bXBsZXRlCj4gPiArCSAqLwo+ID4gKwlpZiAoYmxrX3F1ZXVlX2ZsdXNoaW5nKHEpKQo+ID4gIAkJ LyoKPiA+IC0JCSAqIFRha2UgYSBzaG9ydCBzbm9vemUsIGFuZCB0aGVuIHdha2UgdXAgdGhpcyBo d2dyb3VwIGFnYWluLgo+ID4gLQkJICogVGhpcyBnaXZlcyBvdGhlciBod2dyb3VwcyBvbiB0aGUg c2FtZSBhIGNoYW5jZSB0bwo+ID4gLQkJICogcGxheSBmYWlybHkgd2l0aCB1cywganVzdCBpbiBj YXNlIHRoZXJlIGFyZSBiaWcgZGlmZmVyZW5jZXMKPiA+IC0JCSAqIGluIHJlbGF0aXZlIHRocm91 Z2hwdXRzLi4gZG9uJ3Qgd2FudCB0byBob2cgdGhlIGNwdSB0b28gbXVjaC4KPiA+ICsJCSAqIHNt YWxsIHJhY2Ugd2hlcmUgcXVldWUgY291bGQgZ2V0IHJlcGx1Z2dlZCBkdXJpbmcKPiA+ICsJCSAq IHRoZSAzLXJlcXVlc3QgZmx1c2ggY3ljbGUsIGp1c3QgeWFuayB0aGUgcGx1ZyBzaW5jZQo+ID4g KwkJICogd2Ugd2FudCBpdCB0byBmaW5pc2ggYXNhcAo+ID4gIAkJICovCj4gPiAtCQkJCWlmICh0 aW1lX2JlZm9yZShzbGVlcCwgamlmZmllcyArIFdBSVRfTUlOX1NMRUVQKSkKPiA+IC0JCQkJCXNs ZWVwID0gamlmZmllcyArIFdBSVRfTUlOX1NMRUVQOwo+ID4gLSNpZiAxCj4gPiAtCQkJCWlmICh0 aW1lcl9wZW5kaW5nKCZod2dyb3VwLT50aW1lcikpCj4gPiAtCQkJCQlwcmludGsoS0VSTl9DUklU ICJpZGVfc2V0X2hhbmRsZXI6IHRpbWVyIGFscmVhZHkgYWN0aXZlXG4iKTsKPiA+IC0jZW5kaWYK PiA+IC0JCQkJLyogc28gdGhhdCBpZGVfdGltZXJfZXhwaXJ5IGtub3dzIHdoYXQgdG8gZG8gKi8K PiA+IC0JCQkJaHdncm91cC0+c2xlZXBpbmcgPSAxOwo+ID4gLQkJCQlod2dyb3VwLT5yZXFfZ2Vu X3RpbWVyID0gaHdncm91cC0+cmVxX2dlbjsKPiA+IC0JCQkJbW9kX3RpbWVyKCZod2dyb3VwLT50 aW1lciwgc2xlZXApOwo+ID4gLQkJCQkvKiB3ZSBwdXJwb3NlbHkgbGVhdmUgaHdncm91cCBsb2Nr ZWQKPiA+IC0JCQkJICogd2hpbGUgc2xlZXBpbmcgKi8KPiA+IC0JCQl9IGVsc2UKPiA+IC0JCQkJ aWRlX3VubG9ja19od2dyb3VwKGh3Z3JvdXApOwo+ID4gKwkJYmxrX3JlbW92ZV9wbHVnKHEpOwo+ IAo+IEknbSBub3QgYXQgYWxsIGNvbnZpbmNlZCB0aGF0IHRoaXMgd29ya3MgYXMgZXhwZWN0ZWQu IEZpcnN0IG9mIGFsbCwgSQo+IHRoaW5rIHdlIGNhbiBzYWZlbHkgYXNzdW1lIHRoYXQgdGhlIHBs dWcgaXMgcmVtb3ZlZCB3aGVuIGJsb2NrIGxheWVyCj4gY2FsbHMgaW50byB0aGUgLT5yZXF1ZXN0 X2ZuKCkuIFNlY29uZGx5LCBzaW5jZSB0aGUgaWRlIGxheWVyIGRvZXNuJ3QKPiBjYWxsIHRoZSAt PnJlcXVlc3RfZm4oKSBvbiBpdCdzIG93biBhY2NvcmQsIEkgcmF0aGVyIHN1c3BlY3QgdGhhdCB0 aGlzCj4gY2hlY2sgY2FuIGJlIGRyb3BwZWQgYWx0b2dldGhlci4gT24gdGhlIG90aGVyIGhhbmQs IEknbSBub3Qgc3VyZSBJIGFncmVlCgpJIHN1c3BlY3QgdGhhdCB0aGlzIGlzIGxlZnRvdmVyIGZy b20gdGhlIG9sZCBjb2RlIGFuZCBJIGFsc28gdGhpbmsgdGhhdAppdCBjYW4gYmUgcmVtb3ZlZCBj b21wbGV0ZWx5LiAgSG93ZXZlciBtaXhpbmcgdG9vIG1hbnkgcmVhbCBjb2RlIGNoYW5nZXMKaW4g YSBzaW5nbGUgcGF0Y2ggaXMgbm90IGEgZ29vZCBwcmFjdGljZSBhbmQgdGhlIHJlbW92YWwgY2Fu IGJlIGhhbmRsZWQKaW5kZXBlbmRlbnRseSBvZiB0aGUgZGlzY3Vzc2VkIHBhdGNoLgoKSWYgeW91 IHdvdWxkIHNlbmQgbWUgYSBwYXRjaCB3aXRoIHRoZSBhYm92ZSBjaGFuZ2UgSSB3aWxsIGJlIGhh cHB5IHRvCmludGVncmF0ZSBpdCBpbnRvIHBhdGEgdHJlZSAocGF0Y2ggY2FuIGJlIGFnYWluc3Qg Y3VycmVudCBMaW51cycgdHJlZSBvcgpsaW51eC1uZXh0LCBlaXRoZXIgb25lIGlzIGNvbXBsZXRl bHkgZmluZSB3aXRoIG1lKS4KCj4gd2l0aCB0aGUgcmVzdCBvZiB0aGUgcGF0Y2ggYW55d2F5LCBz ZWUgYmVsb3cuCj4gCj4gPiAgCj4gPiAtCQkJLyogbm8gbW9yZSB3b3JrIGZvciB0aGlzIGh3Z3Jv dXAgKGZvciBub3cpICovCj4gPiAtCQkJZ290byBwbHVnX2RldmljZTsKPiA+IC0JCX0KPiA+ICsJ c3Bpbl91bmxvY2tfaXJxKHEtPnF1ZXVlX2xvY2spOwo+ID4gKwlzcGluX2xvY2tfaXJxKCZod2dy b3VwLT5sb2NrKTsKPiA+ICAKPiA+IC0JCWlmIChkcml2ZSAhPSBvcmlnX2RyaXZlKQo+ID4gLQkJ CWdvdG8gcGx1Z19kZXZpY2U7Cj4gPiArCS8qIGNhbGxlciBtdXN0IG93biBod2dyb3VwLT5sb2Nr ICovCj4gPiArCUJVR19PTighaXJxc19kaXNhYmxlZCgpKTsKPiAKPiBEb2VzIHRoaXMgY2hlY2sg cmVhbGx5IG1ha2UgYW55IHNlbnNlPyBUaGUgbG9jayBpcyBiZWluZyB0YWtlbiBqdXN0IHR3bwo+ IGxpbmVzIGJlZm9yZSwgYWZ0ZXIgYWxsLgoKSW5kZWVkLCByZW1vdmVkLgoKPiA+IC0JCWh3aWYg PSBkcml2ZS0+aHdpZjsKPiA+ICsJaWYgKCFpZGVfbG9ja19od2dyb3VwKGh3Z3JvdXApKSB7Cj4g PiArCQlod2dyb3VwLT5ycSA9IE5VTEw7Cj4gPiArCj4gPiArCQlpZiAoZHJpdmUtPmRldl9mbGFn cyAmIElERV9ERkxBR19TTEVFUElORykgewo+ID4gKwkJCWlmICh0aW1lX2JlZm9yZShkcml2ZS0+ c2xlZXAsIGppZmZpZXMpKSB7Cj4gPiArCQkJCWlkZV91bmxvY2tfaHdncm91cChod2dyb3VwKTsK PiA+ICsJCQkJZ290byBwbHVnX2RldmljZTsKPiA+ICsJCQl9Cj4gPiArCQl9Cj4gPiAgCj4gPiAg CQlpZiAoaHdpZiAhPSBod2dyb3VwLT5od2lmKSB7Cj4gPiAgCQkJLyoKPiA+IEBAIC04NDcsMTYg Kzc1MCwyMCBAQCB2b2lkIGRvX2lkZV9yZXF1ZXN0KHN0cnVjdCByZXF1ZXN0X3F1ZXVlCj4gPiAg CQlod2dyb3VwLT5od2lmID0gaHdpZjsKPiA+ICAJCWh3Z3JvdXAtPmRyaXZlID0gZHJpdmU7Cj4g PiAgCQlkcml2ZS0+ZGV2X2ZsYWdzICY9IH4oSURFX0RGTEFHX1NMRUVQSU5HIHwgSURFX0RGTEFH X1BBUktFRCk7Cj4gPiAtCQlkcml2ZS0+c2VydmljZV9zdGFydCA9IGppZmZpZXM7Cj4gPiAgCj4g PiArCQlzcGluX3VubG9ja19pcnEoJmh3Z3JvdXAtPmxvY2spOwo+ID4gKwkJc3Bpbl9sb2NrX2ly cShxLT5xdWV1ZV9sb2NrKTsKPiA+ICAJCS8qCj4gPiAgCQkgKiB3ZSBrbm93IHRoYXQgdGhlIHF1 ZXVlIGlzbid0IGVtcHR5LCBidXQgdGhpcyBjYW4gaGFwcGVuCj4gPiAgCQkgKiBpZiB0aGUgcS0+ cHJlcF9ycV9mbigpIGRlY2lkZXMgdG8ga2lsbCBhIHJlcXVlc3QKPiA+ICAJCSAqLwo+ID4gIAkJ cnEgPSBlbHZfbmV4dF9yZXF1ZXN0KGRyaXZlLT5xdWV1ZSk7Cj4gPiArCQlzcGluX3VubG9ja19p cnEocS0+cXVldWVfbG9jayk7Cj4gPiArCQlzcGluX2xvY2tfaXJxKCZod2dyb3VwLT5sb2NrKTsK PiA+ICsKPiA+ICAJCWlmICghcnEpIHsKPiA+ICAJCQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91 cCk7Cj4gPiAtCQkJYnJlYWs7Cj4gPiArCQkJZ290byBvdXQ7Cj4gPiAgCQl9Cj4gPiAgCj4gPiAg CQkvKgo+ID4gQEAgLTg4OCwxNSArNzk1LDIyIEBAIHZvaWQgZG9faWRlX3JlcXVlc3Qoc3RydWN0 IHJlcXVlc3RfcXVldWUKPiA+ICAKPiA+ICAJCWlmIChzdGFydHN0b3AgPT0gaWRlX3N0b3BwZWQp IHsKPiA+ICAJCQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91cCk7Cj4gPiAtCQkJaWYgKCFlbHZf cXVldWVfZW1wdHkob3JpZ19kcml2ZS0+cXVldWUpKQo+ID4gLQkJCQlibGtfcGx1Z19kZXZpY2Uo b3JpZ19kcml2ZS0+cXVldWUpOwo+ID4gKwkJCS8qIGdpdmUgb3RoZXIgZGV2aWNlcyBhIGNoYW5j ZSAqLwo+ID4gKwkJCWdvdG8gcGx1Z19kZXZpY2U7Cj4gCj4gVGhpcywgSSB0aGluaywgaXMgdmVy eSB3cm9uZy4gVGhlIHJ1bGUgb2YgdGh1bWIgZm9yIGEgLT5yZXF1c3RfZm4oKQo+IHNob3VsZCBi ZSB0byB0YWtlIGFzIG1hbnkgcmVxdWVzdHMgb2ZmIHRoZSBxdWV1ZSBhcyBwb3NzaWJsZS4gQmVz aWRlcywKPiB0aGlzIG1heSBlYXNpbHkgcHJlZW1wdCBhbiBvcmRlcmVkIHNlcXVlbmNlIGFzIG1l bnRpb25lZCBlYXJsaWVyLiBJbiBteQo+IG9waW5pb24sIHdlIHJlYWxseSBuZWVkIGEgbG9vcCBv ZiBzb3J0cyAod2hpbGUgb3IgZ290bykuCgpUaGFua3MgZm9yIG5vdGljaW5nIHRoaXMuICBGaXhl ZC4KClsgVGhlIG9yaWdpbmFsIGlkZWEgYmVoaW5kICJnb3RvIHBsdWdfZGV2aWNlIiBpcyBpbiB0 aGUgY29tbWVudCBidXQgYXMKICBJIHJlYWQgdGhlIGNvZGUgYWdhaW4gaXQgZG9lc24ndCBtYWtl IGFueSBzZW5zZSBub3cuLi4gXQoKPiA+ICAJCX0KPiA+IC0JfQo+ID4gKwl9IGVsc2UKPiA+ICsJ CWdvdG8gcGx1Z19kZXZpY2U7Cj4gPiArb3V0Ogo+ID4gKwlzcGluX3VubG9ja19pcnEoJmh3Z3Jv dXAtPmxvY2spOwo+ID4gKwlzcGluX2xvY2tfaXJxKHEtPnF1ZXVlX2xvY2spOwo+ID4gIAlyZXR1 cm47Cj4gPiAgCj4gPiAgcGx1Z19kZXZpY2U6Cj4gPiAtCWlmICghZWx2X3F1ZXVlX2VtcHR5KG9y aWdfZHJpdmUtPnF1ZXVlKSkKPiA+IC0JCWJsa19wbHVnX2RldmljZShvcmlnX2RyaXZlLT5xdWV1 ZSk7Cj4gPiArCXNwaW5fdW5sb2NrX2lycSgmaHdncm91cC0+bG9jayk7Cj4gPiArCXNwaW5fbG9j a19pcnEocS0+cXVldWVfbG9jayk7Cj4gPiArCj4gPiArCWlmICghZWx2X3F1ZXVlX2VtcHR5KHEp KQo+ID4gKwkJYmxrX3BsdWdfZGV2aWNlKHEpOwo+ID4gIH0KPiA+ICAKPiA+ICAvKgo+IFsuLi5d Cj4gPiBAQCAtOTc0LDEwICs4OTksMTIgQEAgb3V0Ogo+ID4gIHZvaWQgaWRlX3RpbWVyX2V4cGly eSAodW5zaWduZWQgbG9uZyBkYXRhKQo+ID4gIHsKPiA+ICAJaWRlX2h3Z3JvdXBfdAkqaHdncm91 cCA9IChpZGVfaHdncm91cF90ICopIGRhdGE7Cj4gPiArCWlkZV9kcml2ZV90CSp1bmluaXRpYWxp emVkX3Zhcihkcml2ZSk7Cj4gPiAgCWlkZV9oYW5kbGVyX3QJKmhhbmRsZXI7Cj4gPiAgCWlkZV9l eHBpcnlfdAkqZXhwaXJ5Owo+ID4gIAl1bnNpZ25lZCBsb25nCWZsYWdzOwo+ID4gIAl1bnNpZ25l ZCBsb25nCXdhaXQgPSAtMTsKPiA+ICsJaW50CQlwbHVnX2RldmljZSA9IDA7Cj4gPiAgCj4gPiAg CXNwaW5fbG9ja19pcnFzYXZlKCZod2dyb3VwLT5sb2NrLCBmbGFncyk7Cj4gPiAgCj4gPiBAQCAt OTg5LDEyICs5MTYsOCBAQCB2b2lkIGlkZV90aW1lcl9leHBpcnkgKHVuc2lnbmVkIGxvbmcgZGF0 Cj4gPiAgCQkgKiBvciB3ZSB3ZXJlICJzbGVlcGluZyIgdG8gZ2l2ZSBvdGhlciBkZXZpY2VzIGEg Y2hhbmNlLgo+ID4gIAkJICogRWl0aGVyIHdheSwgd2UgZG9uJ3QgcmVhbGx5IHdhbnQgdG8gY29t cGxhaW4gYWJvdXQgYW55dGhpbmcuCj4gPiAgCQkgKi8KPiAKPiBOb3QgdGhhdCBpbXBvcnRhbnQs IEkgc3VwcG9zZSwgYnV0IHlvdSBtaWdodCB3YW50IHRvIHVwZGF0ZSB0aGF0IGNvbW1lbnQKPiB3 aGlsZSB5b3UncmUgYXQgaXQuCgpJIHRoaW5rIHRoYXQgZGVzcGl0ZSBjb2RlIGNoYW5nZXMgaXQg c3RheXMgdmFsaWQgc28gdGhlcmUgaXMgbm8gdXJnZW50IG5lZWQKdG8gdG91Y2ggaXQuLgoKPiA+ IC0JCWlmIChod2dyb3VwLT5zbGVlcGluZykgewo+ID4gLQkJCWh3Z3JvdXAtPnNsZWVwaW5nID0g MDsKPiA+IC0JCQlpZGVfdW5sb2NrX2h3Z3JvdXAoaHdncm91cCk7Cj4gPiAtCQl9Cj4gPiAgCX0g ZWxzZSB7Cj4gPiAtCQlpZGVfZHJpdmVfdCAqZHJpdmUgPSBod2dyb3VwLT5kcml2ZTsKPiA+ICsJ CWRyaXZlID0gaHdncm91cC0+ZHJpdmU7Cj4gPiAgCQlpZiAoIWRyaXZlKSB7Cj4gPiAgCQkJcHJp bnRrKEtFUk5fRVJSICJpZGVfdGltZXJfZXhwaXJ5OiBod2dyb3VwLT5kcml2ZSB3YXMgTlVMTFxu Iik7Cj4gPiAgCQkJaHdncm91cC0+aGFuZGxlciA9IE5VTEw7Cj4gCj4gRmluYWxseSwgc29tZSBt b3JlIGdlbmVyYWwgYmxhdGhlcmluZyBvbiB0aGUgdG9waWMgYXQgaGFuZDogQSB3aGlsZSBhZ28s Cj4gSSBzcGVudCBzb21lIHRob3VnaHQgb24gdGhlIHBvc3NpYmlsaXRpZXMgb2YgZ2l2aW5nIHRo ZSBibG9jayBsYXllciBhCj4gbm90aW9uIG9mIGxpbmtlZCBkZXZpY2UgcXVldWVzIGFzIGFuIGVx dWl2YWxlbnQgaHdncm91cHMgaW4gaWRlLAo+IHNjc2lfaG9zdHMgb3IgYXRhX3BvcnRzIGFuZCBs ZXQgaXQgdGFrZSBjYXJlIG9mIHRpbWUgLyBiYW5kd2lkdGgKPiBkaXN0cmlidXRpb24gYW1vbmcg dGhlIHF1ZXVlcyBiZWxvbmdpbmcgdG8gb25lIGdyb3VwLiBUaGlzIGlzLCBhcyBJCj4gdW5kZXJz dGFuZCwgcHJldHR5IG11Y2ggd2hhdCB5b3VyIGNvZGUgaXMgcmVseWluZyBvbiBzaW5jZSB5b3Ug aGF2ZQo+IGNodWNrZWQgb3V0IGNob29zZV9kcml2ZSgpLiBIb3dldmVyLCB0aGlzIHR1cm5lZCBv dXQgbm90IHRvIGJlIHRvbyBlYXN5CgpUaGlzIGlzIHRoZSByaWdodCB3YXkgdG8gZ28gYW5kIEkg aGFzIGFsd2F5cyBhZHZvY2F0ZWQgZm9yIGl0LiAgSG93ZXZlcgphZnRlciBzZWVpbmcgaG93IGxp YmF0YSBnb3QgYXdheSB3aXRoIGlnbm9yaW5nIHRoZSBpc3N1ZSBhbHRvZ2V0aGVyCkknbSBubyBs b25nZXIgc3VyZSBvZiB0aGlzLiAgSSBoYXZlbid0IHNlZW4gYW55IGJ1ZyByZXBvcnRzIHdoaWNo IHdvdWxkCmluZGljYXRlIHRoYXQgc2ltcGxpZmllZCBhcHByb2FjaCBoYXMgYW55IHJlYWxseSBu ZWdhdGl2ZSBjb25zZXF1ZW5jZXMuCgpbIFN0aWxsIHdvdWxkIGJlIGdyZWF0IHRvIGhhdmUgdGhl IGNvbnRyb2wgb3ZlciBiYW5kd2l0Y2ggb2YgInF1ZXVlLWdyb3VwIgogIGF0IHRoZSBibG9jayBs YXllciBsZXZlbCBzaW5jZSB3ZSBjb3VsZCBhbHNvIHVzZSBpdCBmb3IgZGlzdHJpYnV0aW5nIHRo ZQogIGF2YWlsYWJsZSBQQ0lbLUVdIGJ1cyBiYW5kd2l0Y2guIF0KCj4gYW5kIEknbSBub3QgcXVp dGUgc3VyZSB3aGV0aGVyIHdlIHJlYWxseSB3YW50IHRvIGdvIGRvd24gdGhhdCByb2FkLiBPbmUK PiBtYWpvciBwcm9ibGVtIGlzIHRoYXQgdGhlcmUgaXMgbm8gc3RyYWlnaHQgZm9yd2FyZCB3YXkg Zm9yIHRoZSBibG9jawo+IGxheWVyIHRvIGtub3csIHdoZXRoZXIgYSAtPnJlcXVlc3RfZm4oKSBo YXMgYWN0dWFsbHkgdGFrZW4gYSByZXF1ZXN0IG9mZgo+IHRoZSBxdWV1ZSBhbmQgaWYgbm90IChv ciBsZXNzIHRoYW4gcXVldWVfZGVwdGggYW55d2F5KSwgd2hldGhlciBpdCdzCj4ganVzdCB0aGUg ZGV2aWNlIHRoYXQgY291bGRuJ3QgdGFrZSBhbnkgbW9yZSBvciB0aGUgY29udHJvbGxlciBpbnN0 ZWFkLgo+IE9uIHRoZSB3aG9sZSwgaXQgc2VlbXMgbm90IGV4YWN0bHkgdHJpdmlhbCB0byBnZXQg aXQgcmlnaHQgYW5kIGl0IHdvdWxkCj4gcHJvYmFibHkgYmUgYSBnb29kIGlkZWEgdG8gY29uc3Vs dCBKZW5zIGFuZCBwZXJoYXBzIEphbWVzIGJlZm9yZQoKSSB0aGluayB0aGF0IGhhdmluZyBtb3Jl IGluZm9ybWF0aW9uIHJldHVybmVkIGJ5IC0+cmVxdWVzdF9mbigpIGNvdWxkIGJlCmJlbmVmaWNp YWwgdG8gdGhlIGJsb2NrIGxheWVyIChpbmRlcGVuZGVudGx5IHdoZXRoZXIgd2UgZW5kIHVwIGFk ZGluZwpzdXBwb3J0IGZvciAicXVldWUtZ3JvdXBzIiB0byB0aGUgYmxvY2sgbGF5ZXIgb3Igbm90 KSBidXQgdGhpcyBkZWZpbml0ZWx5Cm5lZWRzIHRvIGJlIHZlcmlmaWVkIHdpdGggSmVucyAmIEph bWVzLgoKPiBlbWJhcmtpbmcgb24gc3VjaCBhIHZlbnR1cmUuIFNob3J0IG9mIHRoYXQsIEkgdGhp bmsgdGhhdCBpZGUgbGF5ZXIgaGFzCj4gdG8ga2VlcCBhbiBhcHByb3ByaWF0ZSBlcXVpdmFsZW50 IG9mIGNob29zZV9kcml2ZSgpIGFuZCBhbHNvIHRoZSB3aGlsZQo+IGxvb3AgaW4gdGhlIGRvX2lk ZV9yZXF1ZXN0KCkgZnVuY3Rpb24uCgpUaGFuayB5b3UgZm9yIHlvdXIgcmV2aWV3LiAgdjEtPnYy IGludGVyZGlmZiBiZWxvdy4KCnYyOgoqIEZpeGVzL2ltcHJvdmVtZW50cyBiYXNlZCBvbiByZXZp ZXcgZnJvbSBFbGlhczoKIC0gdGFrZSBhcyBtYW55IHJlcXVlc3RzIG9mZiB0aGUgcXVldWUgYXMg cG9zc2libGUKIC0gcmVtb3ZlIG5vdyByZWR1bmRhbnQgQlVHX09OKCkKCmRpZmYgLXUgYi9kcml2 ZXJzL2lkZS9pZGUtaW8uYyBiL2RyaXZlcnMvaWRlL2lkZS1pby5jCi0tLSBiL2RyaXZlcnMvaWRl L2lkZS1pby5jCisrKyBiL2RyaXZlcnMvaWRlL2lkZS1pby5jCkBAIC03MjYsMTAgKzcyNiw4IEBA CiAJc3Bpbl91bmxvY2tfaXJxKHEtPnF1ZXVlX2xvY2spOwogCXNwaW5fbG9ja19pcnEoJmh3Z3Jv dXAtPmxvY2spOwogCi0JLyogY2FsbGVyIG11c3Qgb3duIGh3Z3JvdXAtPmxvY2sgKi8KLQlCVUdf T04oIWlycXNfZGlzYWJsZWQoKSk7Ci0KIAlpZiAoIWlkZV9sb2NrX2h3Z3JvdXAoaHdncm91cCkp IHsKK3JlcGVhdDoKIAkJaHdncm91cC0+cnEgPSBOVUxMOwogCiAJCWlmIChkcml2ZS0+ZGV2X2Zs YWdzICYgSURFX0RGTEFHX1NMRUVQSU5HKSB7CkBAIC03OTMsMTEgKzc5MSw4IEBACiAJCXN0YXJ0 c3RvcCA9IHN0YXJ0X3JlcXVlc3QoZHJpdmUsIHJxKTsKIAkJc3Bpbl9sb2NrX2lycSgmaHdncm91 cC0+bG9jayk7CiAKLQkJaWYgKHN0YXJ0c3RvcCA9PSBpZGVfc3RvcHBlZCkgewotCQkJaWRlX3Vu bG9ja19od2dyb3VwKGh3Z3JvdXApOwotCQkJLyogZ2l2ZSBvdGhlciBkZXZpY2VzIGEgY2hhbmNl ICovCi0JCQlnb3RvIHBsdWdfZGV2aWNlOwotCQl9CisJCWlmIChzdGFydHN0b3AgPT0gaWRlX3N0 b3BwZWQpCisJCQlnb3RvIHJlcGVhdDsKIAl9IGVsc2UKIAkJZ290byBwbHVnX2RldmljZTsKIG91 dDoKAAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753324AbYLMXSw (ORCPT ); Sat, 13 Dec 2008 18:18:52 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1752201AbYLMXSn (ORCPT ); Sat, 13 Dec 2008 18:18:43 -0500 Received: from mail-bw0-f21.google.com ([209.85.218.21]:58605 "EHLO mail-bw0-f21.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752057AbYLMXSl (ORCPT ); Sat, 13 Dec 2008 18:18:41 -0500 DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=from:to:subject:date:user-agent:cc:references:in-reply-to :mime-version:content-disposition:message-id:content-type :content-transfer-encoding; b=yBG1D8hfVRBA+Fe7oRlFRZUwBzjdy/tuE4SjfkuGI6lwKXtmJng7w5B7rrWEhce+aD JjEb0kWfZG09DmotqkJqG9WAEvhF+Ssu/Wi+i0xvQ/V5GN6HrfN7v2YGp8fbGCJHTMcu pYxijFqMg3EwjJzn5DVprOgOJNXzj/mEmLxXc= From: Bartlomiej Zolnierkiewicz To: Elias Oltmanns Subject: Re: [PATCH 3/3] ide: use per-device request queue locks Date: Sun, 14 Dec 2008 00:15:23 +0100 User-Agent: KMail/1.10.3 (Linux/2.6.28-rc6-next-20081128; KDE/4.1.3; i686; ; ) Cc: linux-ide@vger.kernel.org, linux-kernel@vger.kernel.org References: <200811182119.21286.bzolnier@gmail.com> <87vdudjgfm.fsf@denkblock.local> In-Reply-To: <87vdudjgfm.fsf@denkblock.local> MIME-Version: 1.0 Content-Disposition: inline Message-Id: <200812140015.23853.bzolnier@gmail.com> Content-Type: text/plain; charset="iso-8859-1" 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 mBDNIvdq028856 [ Once again, sorry for the long delay. ] On Monday 24 November 2008, Elias Oltmanns wrote:> Bartlomiej Zolnierkiewicz wrote:> > * Move hack for flush requests from choose_drive() to do_ide_request().> >> > * Add ide_plug_device() helper and convert core IDE code from using> > per-hwgroup lock as a request lock to use the ->queue_lock instead.> >> > * Remove no longer needed:> > - choose_drive() function> > - WAKEUP() macro> > - 'sleeping' flag from ide_hwif_t> > - 'service_{start,time}' fields from ide_drive_t> >> > This patch results in much simpler and more maintainable code> > (besides being a scalability improvement).> >> > Cc: Elias Oltmanns > > Signed-off-by: Bartlomiej Zolnierkiewicz > > ---> > newer version> > Eventually, I got round to having a look at this one (I reviewed the two> small ones at the time). Apologies for the delay.> > >> > drivers/ide/ide-io.c | 213 +++++++++++++++---------------------------------> > drivers/ide/ide-park.c | 13 +-> > drivers/ide/ide-probe.c | 3 > > include/linux/ide.h | 4 > > 4 files changed, 79 insertions(+), 154 deletions(-)> >> > Index: b/drivers/ide/ide-io.c> > ===================================================================> > --- a/drivers/ide/ide-io.c> > +++ b/drivers/ide/ide-io.c> [...]> > @@ -780,61 +704,40 @@ repeat: > > */> > void do_ide_request(struct request_queue *q)> > {> > - ide_drive_t *orig_drive = q->queuedata;> > - ide_hwgroup_t *hwgroup = orig_drive->hwif->hwgroup;> > - ide_drive_t *drive;> > - ide_hwif_t *hwif;> > + ide_drive_t *drive = q->queuedata;> > + ide_hwif_t *hwif = drive->hwif;> > + ide_hwgroup_t *hwgroup = hwif->hwgroup;> > struct request *rq;> > ide_startstop_t startstop;> > > > - /* caller must own hwgroup->lock */> > - BUG_ON(!irqs_disabled());> > -> > - while (!ide_lock_hwgroup(hwgroup)) {> > - drive = choose_drive(hwgroup);> > - if (drive == NULL) {> > - int sleeping = 0;> > - unsigned long sleep = 0; /* shut up, gcc */> > - hwgroup->rq = NULL;> > - drive = hwgroup->drive;> > - do {> > - if ((drive->dev_flags & IDE_DFLAG_SLEEPING) &&> > - (sleeping == 0 ||> > - time_before(drive->sleep, sleep))) {> > - sleeping = 1;> > - sleep = drive->sleep;> > - }> > - } while ((drive = drive->next) != hwgroup->drive);> > - if (sleeping) {> > + /*> > + * drive is doing pre-flush, ordered write, post-flush sequence. even> > + * though that is 3 requests, it must be seen as a single transaction.> > + * we must not preempt this drive until that is complete> > + */> > + if (blk_queue_flushing(q))> > /*> > - * Take a short snooze, and then wake up this hwgroup again.> > - * This gives other hwgroups on the same a chance to> > - * play fairly with us, just in case there are big differences> > - * in relative throughputs.. don't want to hog the cpu too much.> > + * small race where queue could get replugged during> > + * the 3-request flush cycle, just yank the plug since> > + * we want it to finish asap> > */> > - if (time_before(sleep, jiffies + WAIT_MIN_SLEEP))> > - sleep = jiffies + WAIT_MIN_SLEEP;> > -#if 1> > - if (timer_pending(&hwgroup->timer))> > - printk(KERN_CRIT "ide_set_handler: timer already active\n");> > -#endif> > - /* so that ide_timer_expiry knows what to do */> > - hwgroup->sleeping = 1;> > - hwgroup->req_gen_timer = hwgroup->req_gen;> > - mod_timer(&hwgroup->timer, sleep);> > - /* we purposely leave hwgroup locked> > - * while sleeping */> > - } else> > - ide_unlock_hwgroup(hwgroup);> > + blk_remove_plug(q);> > I'm not at all convinced that this works as expected. First of all, I> think we can safely assume that the plug is removed when block layer> calls into the ->request_fn(). Secondly, since the ide layer doesn't> call the ->request_fn() on it's own accord, I rather suspect that this> check can be dropped altogether. On the other hand, I'm not sure I agree I suspect that this is leftover from the old code and I also think thatit can be removed completely. However mixing too many real code changesin a single patch is not a good practice and the removal can be handledindependently of the discussed patch. If you would send me a patch with the above change I will be happy tointegrate it into pata tree (patch can be against current Linus' tree orlinux-next, either one is completely fine with me). > with the rest of the patch anyway, see below.> > > > > - /* no more work for this hwgroup (for now) */> > - goto plug_device;> > - }> > + spin_unlock_irq(q->queue_lock);> > + spin_lock_irq(&hwgroup->lock);> > > > - if (drive != orig_drive)> > - goto plug_device;> > + /* caller must own hwgroup->lock */> > + BUG_ON(!irqs_disabled());> > Does this check really make any sense? The lock is being taken just two> lines before, after all. Indeed, removed. > > - hwif = drive->hwif;> > + if (!ide_lock_hwgroup(hwgroup)) {> > + hwgroup->rq = NULL;> > +> > + if (drive->dev_flags & IDE_DFLAG_SLEEPING) {> > + if (time_before(drive->sleep, jiffies)) {> > + ide_unlock_hwgroup(hwgroup);> > + goto plug_device;> > + }> > + }> > > > if (hwif != hwgroup->hwif) {> > /*> > @@ -847,16 +750,20 @@ void do_ide_request(struct request_queue> > hwgroup->hwif = hwif;> > hwgroup->drive = drive;> > drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);> > - drive->service_start = jiffies;> > > > + spin_unlock_irq(&hwgroup->lock);> > + spin_lock_irq(q->queue_lock);> > /*> > * we know that the queue isn't empty, but this can happen> > * if the q->prep_rq_fn() decides to kill a request> > */> > rq = elv_next_request(drive->queue);> > + spin_unlock_irq(q->queue_lock);> > + spin_lock_irq(&hwgroup->lock);> > +> > if (!rq) {> > ide_unlock_hwgroup(hwgroup);> > - break;> > + goto out;> > }> > > > /*> > @@ -888,15 +795,22 @@ void do_ide_request(struct request_queue> > > > if (startstop == ide_stopped) {> > ide_unlock_hwgroup(hwgroup);> > - if (!elv_queue_empty(orig_drive->queue))> > - blk_plug_device(orig_drive->queue);> > + /* give other devices a chance */> > + goto plug_device;> > This, I think, is very wrong. The rule of thumb for a ->requst_fn()> should be to take as many requests off the queue as possible. Besides,> this may easily preempt an ordered sequence as mentioned earlier. In my> opinion, we really need a loop of sorts (while or goto). Thanks for noticing this. Fixed. [ The original idea behind "goto plug_device" is in the comment but as I read the code again it doesn't make any sense now... ] > > }> > - }> > + } else> > + goto plug_device;> > +out:> > + spin_unlock_irq(&hwgroup->lock);> > + spin_lock_irq(q->queue_lock);> > return;> > > > plug_device:> > - if (!elv_queue_empty(orig_drive->queue))> > - blk_plug_device(orig_drive->queue);> > + spin_unlock_irq(&hwgroup->lock);> > + spin_lock_irq(q->queue_lock);> > +> > + if (!elv_queue_empty(q))> > + blk_plug_device(q);> > }> > > > /*> [...]> > @@ -974,10 +899,12 @@ out:> > void ide_timer_expiry (unsigned long data)> > {> > ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;> > + ide_drive_t *uninitialized_var(drive);> > ide_handler_t *handler;> > ide_expiry_t *expiry;> > unsigned long flags;> > unsigned long wait = -1;> > + int plug_device = 0;> > > > spin_lock_irqsave(&hwgroup->lock, flags);> > > > @@ -989,12 +916,8 @@ void ide_timer_expiry (unsigned long dat> > * or we were "sleeping" to give other devices a chance.> > * Either way, we don't really want to complain about anything.> > */> > Not that important, I suppose, but you might want to update that comment> while you're at it. I think that despite code changes it stays valid so there is no urgent needto touch it.. > > - if (hwgroup->sleeping) {> > - hwgroup->sleeping = 0;> > - ide_unlock_hwgroup(hwgroup);> > - }> > } else {> > - ide_drive_t *drive = hwgroup->drive;> > + drive = hwgroup->drive;> > if (!drive) {> > printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n");> > hwgroup->handler = NULL;> > Finally, some more general blathering on the topic at hand: A while ago,> I spent some thought on the possibilities of giving the block layer a> notion of linked device queues as an equivalent hwgroups in ide,> scsi_hosts or ata_ports and let it take care of time / bandwidth> distribution among the queues belonging to one group. This is, as I> understand, pretty much what your code is relying on since you have> chucked out choose_drive(). However, this turned out not to be too easy This is the right way to go and I has always advocated for it. Howeverafter seeing how libata got away with ignoring the issue altogetherI'm no longer sure of this. I haven't seen any bug reports which wouldindicate that simplified approach has any really negative consequences. [ Still would be great to have the control over bandwitch of "queue-group" at the block layer level since we could also use it for distributing the available PCI[-E] bus bandwitch. ] > and I'm not quite sure whether we really want to go down that road. One> major problem is that there is no straight forward way for the block> layer to know, whether a ->request_fn() has actually taken a request off> the queue and if not (or less than queue_depth anyway), whether it's> just the device that couldn't take any more or the controller instead.> On the whole, it seems not exactly trivial to get it right and it would> probably be a good idea to consult Jens and perhaps James before I think that having more information returned by ->request_fn() could bebeneficial to the block layer (independently whether we end up addingsupport for "queue-groups" to the block layer or not) but this definitelyneeds to be verified with Jens & James. > embarking on such a venture. Short of that, I think that ide layer has> to keep an appropriate equivalent of choose_drive() and also the while> loop in the do_ide_request() function. Thank you for your review. v1->v2 interdiff below. v2:* Fixes/improvements based on review from Elias: - take as many requests off the queue as possible - remove now redundant BUG_ON() diff -u b/drivers/ide/ide-io.c b/drivers/ide/ide-io.c--- b/drivers/ide/ide-io.c+++ b/drivers/ide/ide-io.c@@ -726,10 +726,8 @@ spin_unlock_irq(q->queue_lock); spin_lock_irq(&hwgroup->lock); - /* caller must own hwgroup->lock */- BUG_ON(!irqs_disabled());- if (!ide_lock_hwgroup(hwgroup)) {+repeat: hwgroup->rq = NULL; if (drive->dev_flags & IDE_DFLAG_SLEEPING) {@@ -793,11 +791,8 @@ startstop = start_request(drive, rq); spin_lock_irq(&hwgroup->lock); - if (startstop == ide_stopped) {- ide_unlock_hwgroup(hwgroup);- /* give other devices a chance */- goto plug_device;- }+ if (startstop == ide_stopped)+ goto repeat; } else goto plug_device; out:{.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I