Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > linux.kernel > #1179724 > unrolled thread
| Started by | "Wu, Feng" <feng.wu@intel.com> |
|---|---|
| First post | 2015-07-08 14:30 +0200 |
| Last post | 2015-07-08 15:00 +0200 |
| Articles | 2 — 2 participants |
Back to article view | Back to linux.kernel
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
RE: [RFC PATCH] irq: IRQ bypass manager "Wu, Feng" <feng.wu@intel.com> - 2015-07-08 14:30 +0200
Re: [RFC PATCH] irq: IRQ bypass manager Alex Williamson <alex.williamson@redhat.com> - 2015-07-08 15:00 +0200
| From | "Wu, Feng" <feng.wu@intel.com> |
|---|---|
| Date | 2015-07-08 14:30 +0200 |
| Subject | RE: [RFC PATCH] irq: IRQ bypass manager |
| Message-ID | <pJWEa-2Dy-15@gated-at.bofh.it> |
DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogQWxleCBXaWxsaWFtc29u IFttYWlsdG86YWxleC53aWxsaWFtc29uQHJlZGhhdC5jb21dDQo+IFNlbnQ6IFdlZG5lc2RheSwg SnVseSAwOCwgMjAxNSA1OjQwIEFNDQo+IFRvOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3Jn OyBrdm1Admdlci5rZXJuZWwub3JnDQo+IENjOiBlcmljLmF1Z2VyQHN0LmNvbTsgZXJpYy5hdWdl ckBsaW5hcm8ub3JnOyBqb3JvQDhieXRlcy5vcmc7DQo+IGF2aS5raXZpdHlAZ21haWwuY29tOyBw Ym9uemluaUByZWRoYXQuY29tOyBXdSwgRmVuZw0KPiBTdWJqZWN0OiBbUkZDIFBBVENIXSBpcnE6 IElSUSBieXBhc3MgbWFuYWdlcg0KPiANCj4gV2hlbiBhIHBoeXNpY2FsIEkvTyBkZXZpY2UgaXMg YXNzaWduZWQgdG8gYSB2aXJ0dWFsIG1hY2hpbmUgdGhyb3VnaA0KPiBmYWNpbGl0aWVzIGxpa2Ug VkZJTyBhbmQgS1ZNLCB0aGUgaW50ZXJydXB0IGZvciB0aGUgZGV2aWNlIGdlbmVyYWxseQ0KPiBi b3VuY2VzIHRocm91Z2ggdGhlIGhvc3Qgc3lzdGVtIGJlZm9yZSBiZWluZyBpbmplY3RlZCBpbnRv IHRoZSBWTS4NCj4gSG93ZXZlciwgaGFyZHdhcmUgdGVjaG5vbG9naWVzIGV4aXN0IHRoYXQgb2Z0 ZW4gYWxsb3cgdGhlIGhvc3QgdG8gYmUNCj4gYnlwYXNzZWQgZm9yIHNvbWUgb2YgdGhlc2Ugc2Nl bmFyaW9zLiAgSW50ZWwgUG9zdGVkIEludGVycnVwdHMgYWxsb3cNCj4gdGhlIHNwZWNpZmllZCBw aHlzaWNhbCBlZGdlIGludGVycnVwdHMgdG8gYmUgZGlyZWN0bHkgaW5qZWN0ZWQgaW50byBhDQo+ IGd1ZXN0IHdoZW4gZGVsaXZlcmVkIHRvIGEgcGh5c2ljYWwgcHJvY2Vzc29yIHdoaWxlIHRoZSB2 Q1BVIGlzDQo+IHJ1bm5pbmcuICBBUk0gSVJRIEZvcndhcmRpbmcgYWxsb3dzIHRoZSBoeXBlcnZp c29yIHRvIGhhbmRsZSBsZXZlbA0KPiB0cmlnZ2VyZWQgZGV2aWNlIGludGVycnVwdHMgYXMgZWRn ZSBpbnRlcnJ1cHRzLCBieSBnaXZpbmcgdGhlIGd1ZXN0DQo+IGNvbnRyb2wgb2YgZGUtYXNzZXJ0 aW5nIGFuZCB1bm1hc2tpbmcgdGhlIGludGVycnVwdCBsaW5lLg0KPiANCj4gVGhlIElSUSBieXBh c3MgbWFuYWdlciBoZXJlIGlzIG1lYW50IHRvIHByb3ZpZGUgdGhlIHNoaW0gdG8gY29ubmVjdA0K PiBpbnRlcnJ1cHQgcHJvZHVjZXJzLCBnZW5lcmFsbHkgdGhlIGhvc3QgcGh5c2ljYWwgZGV2aWNl IGRyaXZlciwgd2l0aA0KPiBpbnRlcnJ1cHQgY29uc3VtZXJzLCBnZW5lcmFsbHkgdGhlIGh5cGVy dmlzb3IsIGluIG9yZGVyIHRvIGNvbmZpZ3VyZQ0KPiB0aGVzZSBieXBhc3MgbWVjaGFuaXNtLiAg VG8gZG8gdGhpcywgd2UgYmFzZSB0aGUgY29ubmVjdGlvbiBvbiBhDQo+IHNoYXJlZCwgb3BhcXVl IHRva2VuLiAgRm9yIEtWTS1WRklPIHRoaXMgaXMgZXhwZWN0ZWQgdG8gYmUgYW4NCj4gZXZlbnRm ZF9jdHggc2luY2UgdGhpcyBpcyB0aGUgY29ubmVjdGlvbiB3ZSBhbHJlYWR5IHVzZSB0byBjb25u ZWN0IGFuDQo+IGV2ZW50ZmQgdG8gYW4gaXJxZmQgb24gdGhlIGluLWtlcm5lbCBwYXRoLiAgV2hl biBhIHByb2R1Y2VyIGFuZA0KPiBjb25zdW1lciB3aXRoIG1hdGNoaW5nIHRva2VucyBpcyBmb3Vu ZCwgY2FsbGJhY2tzIHZpYSBib3RoIHJlZ2lzdGVyZWQNCj4gcGFydGljaXBhbnRzIGFsbG93IHRo ZSBieXBhc3MgZmFjaWxpdGllcyB0byBiZSBhdXRvbWF0aWNhbGx5IGVuYWJsZWQuDQoNCk15IFBp IHBhdGNoZXMgY2FuIHdvcmsgd2VsbCBiYXNlZCBvbiB0aGlzIG9uZSBhbmQgdGhlIG9uZSBFcmlj IHNlbnQNCm91dCBlYXJsaWVyLiBBbGV4LCB3aGF0IHNob3VsZCB3ZSBkbyBpbiB0aGUgbmV4dCBz dGVwIHRvIHNwZWVkIHVwIHRoZQ0KdXBzdHJlYW1pbmcgcHJvY2Vzcz8NCg0KVGhhbmtzLA0KRmVu Zw0KDQo+IA0KPiBTaWduZWQtb2ZmLWJ5OiBBbGV4IFdpbGxpYW1zb24gPGFsZXgud2lsbGlhbXNv bkByZWRoYXQuY29tPg0KPiBDYzogRXJpYyBBdWdlciA8ZXJpYy5hdWdlckBsaW5hcm8ub3JnPg0K PiAtLS0NCj4gDQo+IFRoaXMgaXMgdGhlIGN1cnJlbnQgZHJhZnQgb2YgdGhlIElSUSBieXBhc3Mg bWFuYWdlciwgSSd2ZSBtYWRlIHRoZQ0KPiBmb2xsb3dpbmcgY2hhbmdlczoNCj4gDQo+ICAtIElu Y29ycG9yYXRlZCBFcmljJ3MgZXh0ZW5zaW9ucyAoSSB3b3VsZCB3ZWxjb21lIFNpZ24tb2ZmcyBm cm9tIGFsbA0KPiAgICBpbnZvbHZlZCBpbiB0aGUgZGV2ZWxvcG1lbnQsIGVzcGVjaWFsbHkgRXJp YyAtIEkndmUgZ29uZSBhaGVhZCBhbmQNCj4gICAgYWRkZWQgTGluYXJvIGNvcHlyaWdodCBmb3Ig dGhlIGNvbnRyaWJ1dGlvbnMgc28gZmFyKQ0KPiAgLSBNb2R1bGUgc3VwcG9ydCB3aXRoIG1vZHVs ZSByZWZlcmVuY2UgdHJhY2tpbmcNCj4gIC0gbWlnaHRfc2xlZXAoKSBhcyBzdWdnZXN0ZWQgYnkg UGFvbG8NCj4gIC0ga2VybmVsZG9jIGFzIHN1Z2dlc3RlZCBieSBQYW9sbw0KPiAgLSBSZW5hbWVk IGZpbGUgcy9ieXBhc3MvaXJxYnlwYXNzLyBiZWNhdXNlIGEgbW9kdWxlIG5hbWVkICJieXBhc3Mi DQo+ICAgIGlzIHN0cmFuZ2UNCj4gDQo+IElzc3VlczoNCj4gIC0gVGhlIHVwZGF0ZSgpIGNhbGxi YWNrIGlzIGRlZmluZWQgYnV0IG5vdCB1c2VkDQo+ICAtIFdlIGNhbid0IGhhdmUgKmFsbCogdGhl IGNhbGxiYWNrcyBiZSBvcHRpb25hbC4gIEkgYXNzdW1lIGFkZC9kZWwNCj4gICAgYXJlIHJlcXVp cmVkDQo+ICAtIE5hbWluZyBjb25zaXN0ZW5jeSwgc3RvcCBpcyB0byBzdGFydCBhcyBzdXNwZW5k IGlzIHRvIHJlc3VtZSwgbm90DQo+ICAgIHN0b3AvcmVzdW1lDQo+ICAtIENhbGxiYWNrIGRlc2Ny aXB0aW9ucyBpbmNsdWRpbmcgd2h5IHdlIG5lZWQgc2VwYXJhdGUgc3RvcC9zdGFydA0KPiAgICBo b29rcyB3aGVuIGl0IHNlZW1zIGxpa2UgdGhlIGNhbGxlZSBjb3VsZCByZWFzb25hYmx5IGFzc3Vt ZSBzdWNoDQo+ICAgIGFyb3VuZCB0aGUgYWRkL2RlbCBjYWxsYmFja3MNCj4gIC0gTmVlZCBmdW5j dGlvbmFsIHByb3RvdHlwZXMgZm9yIGJvdGggUEkgYW5kIGZvcndhcmRpbmcNCj4gDQo+ICBpbmNs dWRlL2xpbnV4L2lycWJ5cGFzcy5oIHwgICA3NSArKysrKysrKysrKysrKysrDQo+ICBrZXJuZWwv aXJxL0tjb25maWcgICAgICAgIHwgICAgMyArDQo+ICBrZXJuZWwvaXJxL01ha2VmaWxlICAgICAg IHwgICAgMQ0KPiAga2VybmVsL2lycS9pcnFieXBhc3MuYyAgICB8ICAyMDYNCj4gKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ICA0IGZpbGVzIGNoYW5nZWQs IDI4NSBpbnNlcnRpb25zKCspDQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9p cnFieXBhc3MuaA0KPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGtlcm5lbC9pcnEvaXJxYnlwYXNzLmMN Cj4gDQo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2lycWJ5cGFzcy5oIGIvaW5jbHVkZS9s aW51eC9pcnFieXBhc3MuaA0KPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAw Li5jYzdjZTQ1DQo+IC0tLSAvZGV2L251bGwNCj4gKysrIGIvaW5jbHVkZS9saW51eC9pcnFieXBh c3MuaA0KPiBAQCAtMCwwICsxLDc1IEBADQo+ICsvKg0KPiArICogSVJRIG9mZmxvYWQvYnlwYXNz IG1hbmFnZXINCj4gKyAqDQo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTUgUmVkIEhhdCwgSW5jLg0K PiArICogQ29weXJpZ2h0IChjKSAyMDE1IExpbmFybyBMdGQuDQo+ICsgKg0KPiArICogVGhpcyBw cm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBt b2RpZnkNCj4gKyAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgdmVyc2lvbiAyIGFzDQo+ICsgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbi4NCj4gKyAqLw0KPiArI2lmbmRlZiBJUlFCWVBBU1NfSA0KPiArI2RlZmlu ZSBJUlFCWVBBU1NfSA0KPiArDQo+ICsjaW5jbHVkZSA8bGludXgvbGlzdC5oPg0KPiArDQo+ICtz dHJ1Y3QgaXJxX2J5cGFzc19jb25zdW1lcjsNCj4gKw0KPiArLyoqDQo+ICsgKiBzdHJ1Y3QgaXJx X2J5cGFzc19wcm9kdWNlciAtIElSUSBieXBhc3MgcHJvZHVjZXIgZGVmaW5pdGlvbg0KPiArICog QG5vZGU6IElSUSBieXBhc3MgbWFuYWdlciBwcml2YXRlIGxpc3QgbWFuYWdlbWVudA0KPiArICog QHRva2VuOiBvcGFxdWUgdG9rZW4gdG8gbWF0Y2ggYmV0d2VlbiBwcm9kdWNlciBhbmQgY29uc3Vt ZXINCj4gKyAqIEBpcnE6IExpbnV4IElSUSBudW1iZXIgZm9yIHRoZSBwcm9kdWNlciBkZXZpY2UN Cj4gKyAqIEBzdG9wOg0KPiArICogQHJlc3VtZToNCj4gKyAqIEBhZGRfY29uc3VtZXI6DQo+ICsg KiBAZGVsX2NvbnN1bWVyOg0KPiArICoNCj4gKyAqIFRoZSBJUlEgYnlwYXNzIHByb2R1Y2VyIHN0 cnVjdHVyZSByZXByZXNlbnRzIGFuIGludGVycnVwdCBzb3VyY2UgZm9yDQo+ICsgKiBwYXJ0aWNp cGF0aW9uIGluIHBvc3NpYmxlIGhvc3QgYnlwYXNzLCBmb3IgaW5zdGFuY2UgYW4gaW50ZXJydXB0 IHZlY3Rvcg0KPiArICogZm9yIGEgcGh5c2ljYWwgZGV2aWNlIGFzc2lnbmVkIHRvIGEgVk0uDQo+ ICsgKi8NCj4gK3N0cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyIHsNCj4gKwlzdHJ1Y3QgbGlzdF9o ZWFkIG5vZGU7DQo+ICsJdm9pZCAqdG9rZW47DQo+ICsJaW50IGlycTsgLyogbGludXggaXJxICov DQo+ICsJdm9pZCAoKnN0b3ApKHN0cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyICopOw0KPiArCXZv aWQgKCpyZXN1bWUpKHN0cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyICopOw0KPiArCXZvaWQgKCph ZGRfY29uc3VtZXIpKHN0cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyICosDQo+ICsJCQkgICAgIHN0 cnVjdCBpcnFfYnlwYXNzX2NvbnN1bWVyICopOw0KPiArCXZvaWQgKCpkZWxfY29uc3VtZXIpKHN0 cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyICosDQo+ICsJCQkgICAgIHN0cnVjdCBpcnFfYnlwYXNz X2NvbnN1bWVyICopOw0KPiArfTsNCj4gKw0KPiArLyoqDQo+ICsgKiBzdHJ1Y3QgaXJxX2J5cGFz c19jb25zdW1lciAtIElSUSBieXBhc3MgY29uc3VtZXIgZGVmaW5pdGlvbg0KPiArICogQG5vZGU6 IElSUSBieXBhc3MgbWFuYWdlciBwcml2YXRlIGxpc3QgbWFuYWdlbWVudA0KPiArICogQHRva2Vu OiBvcGFxdWUgdG9rZW4gdG8gbWF0Y2ggYmV0d2VlbiBwcm9kdWNlciBhbmQgY29uc3VtZXINCj4g KyAqIEBzdG9wOg0KPiArICogQHJlc3VtZToNCj4gKyAqIEBhZGRfY29uc3VtZXI6DQo+ICsgKiBA ZGVsX2NvbnN1bWVyOg0KPiArICogQHVwZGF0ZToNCj4gKyAqDQo+ICsgKiBUaGUgSVJRIGJ5cGFz cyBjb25zdW1lciBzdHJ1Y3R1cmUgcmVwcmVzZW50cyBhbiBpbnRlcnJ1cHQgc2luayBmb3INCj4g KyAqIHBhcnRpY2lwYXRpb24gaW4gcG9zc2libGUgaG9zdCBieXBhc3MsIGZvciBpbnN0YW5jZSBh IGh5cGVydmlzb3IgbWF5DQo+ICsgKiBzdXBwb3J0IG9mZmxvYWRzIHRvIGFsbG93IGJ5cGFzc2lu ZyB0aGUgaG9zdCBlbnRpcmVseSBvciBvZmZsb2FkDQo+ICsgKiBwb3J0aW9ucyBvZiB0aGUgaW50 ZXJydXB0IGhhbmRsaW5nIHRvIHRoZSBWTS4NCj4gKyAqLw0KPiArc3RydWN0IGlycV9ieXBhc3Nf Y29uc3VtZXIgew0KPiArCXN0cnVjdCBsaXN0X2hlYWQgbm9kZTsNCj4gKwl2b2lkICp0b2tlbjsN Cj4gKwl2b2lkICgqc3RvcCkoc3RydWN0IGlycV9ieXBhc3NfY29uc3VtZXIgKik7DQo+ICsJdm9p ZCAoKnJlc3VtZSkoc3RydWN0IGlycV9ieXBhc3NfY29uc3VtZXIgKik7DQo+ICsJdm9pZCAoKmFk ZF9wcm9kdWNlcikoc3RydWN0IGlycV9ieXBhc3NfY29uc3VtZXIgKiwNCj4gKwkJCSAgICAgc3Ry dWN0IGlycV9ieXBhc3NfcHJvZHVjZXIgKik7DQo+ICsJdm9pZCAoKmRlbF9wcm9kdWNlcikoc3Ry dWN0IGlycV9ieXBhc3NfY29uc3VtZXIgKiwNCj4gKwkJCSAgICAgc3RydWN0IGlycV9ieXBhc3Nf cHJvZHVjZXIgKik7DQo+ICsJdm9pZCAoKnVwZGF0ZSkoc3RydWN0IGlycV9ieXBhc3NfY29uc3Vt ZXIgKik7DQo+ICt9Ow0KPiArDQo+ICtpbnQgaXJxX2J5cGFzc19yZWdpc3Rlcl9wcm9kdWNlcihz dHJ1Y3QgaXJxX2J5cGFzc19wcm9kdWNlciAqKTsNCj4gK3ZvaWQgaXJxX2J5cGFzc191bnJlZ2lz dGVyX3Byb2R1Y2VyKHN0cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyICopOw0KPiAraW50IGlycV9i eXBhc3NfcmVnaXN0ZXJfY29uc3VtZXIoc3RydWN0IGlycV9ieXBhc3NfY29uc3VtZXIgKik7DQo+ ICt2b2lkIGlycV9ieXBhc3NfdW5yZWdpc3Rlcl9jb25zdW1lcihzdHJ1Y3QgaXJxX2J5cGFzc19j b25zdW1lciAqKTsNCj4gKyNlbmRpZiAvKiBJUlFCWVBBU1NfSCAqLw0KPiBkaWZmIC0tZ2l0IGEv a2VybmVsL2lycS9LY29uZmlnIGIva2VybmVsL2lycS9LY29uZmlnDQo+IGluZGV4IDlhNzZlM2Iu LmRlNWFmZTMgMTAwNjQ0DQo+IC0tLSBhL2tlcm5lbC9pcnEvS2NvbmZpZw0KPiArKysgYi9rZXJu ZWwvaXJxL0tjb25maWcNCj4gQEAgLTEwMCw0ICsxMDAsNyBAQCBjb25maWcgU1BBUlNFX0lSUQ0K PiANCj4gIAkgIElmIHlvdSBkb24ndCBrbm93IHdoYXQgdG8gZG8gaGVyZSwgc2F5IE4uDQo+IA0K PiArY29uZmlnIElSUV9CWVBBU1NfTUFOQUdFUg0KPiArCXRyaXN0YXRlDQo+ICsNCj4gIGVuZG1l bnUNCj4gZGlmZiAtLWdpdCBhL2tlcm5lbC9pcnEvTWFrZWZpbGUgYi9rZXJuZWwvaXJxL01ha2Vm aWxlDQo+IGluZGV4IGQxMjEyMzUuLmE2Y2ZlYzcgMTAwNjQ0DQo+IC0tLSBhL2tlcm5lbC9pcnEv TWFrZWZpbGUNCj4gKysrIGIva2VybmVsL2lycS9NYWtlZmlsZQ0KPiBAQCAtNywzICs3LDQgQEAg b2JqLSQoQ09ORklHX1BST0NfRlMpICs9IHByb2Mubw0KPiAgb2JqLSQoQ09ORklHX0dFTkVSSUNf UEVORElOR19JUlEpICs9IG1pZ3JhdGlvbi5vDQo+ICBvYmotJChDT05GSUdfUE1fU0xFRVApICs9 IHBtLm8NCj4gIG9iai0kKENPTkZJR19HRU5FUklDX01TSV9JUlEpICs9IG1zaS5vDQo+ICtvYmot JChDT05GSUdfSVJRX0JZUEFTU19NQU5BR0VSKSArPSBpcnFieXBhc3Mubw0KPiBkaWZmIC0tZ2l0 IGEva2VybmVsL2lycS9pcnFieXBhc3MuYyBiL2tlcm5lbC9pcnEvaXJxYnlwYXNzLmMNCj4gbmV3 IGZpbGUgbW9kZSAxMDA2NDQNCj4gaW5kZXggMDAwMDAwMC4uM2ZkODI4ZA0KPiAtLS0gL2Rldi9u dWxsDQo+ICsrKyBiL2tlcm5lbC9pcnEvaXJxYnlwYXNzLmMNCj4gQEAgLTAsMCArMSwyMDYgQEAN Cj4gKy8qDQo+ICsgKiBJUlEgb2ZmbG9hZC9ieXBhc3MgbWFuYWdlcg0KPiArICoNCj4gKyAqIENv cHlyaWdodCAoQykgMjAxNSBSZWQgSGF0LCBJbmMuDQo+ICsgKiBDb3B5cmlnaHQgKGMpIDIwMTUg TGluYXJvIEx0ZC4NCj4gKyAqDQo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQ0KPiArICogaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMNCj4g KyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLg0KPiArICoNCj4g KyAqIFZhcmlvdXMgdmlydHVhbGl6YXRpb24gaGFyZHdhcmUgYWNjZWxlcmF0aW9uIHRlY2huaXF1 ZXMgYWxsb3cgYnlwYXNzaW5nDQo+ICsgKiBvciBvZmZsb2FkaW5nIGludGVycnVwdHMgcmVjZWl2 ZWQgZnJvbSBkZXZpY2VzIGFyb3VuZCB0aGUgaG9zdCBrZXJuZWwuDQo+ICsgKiBQb3N0ZWQgSW50 ZXJydXB0cyBvbiBJbnRlbCBWVC1kIHN5c3RlbXMgY2FuIGFsbG93IGludGVycnVwdHMgdG8gYmUN Cj4gKyAqIHJlY2VpdmVkIGRpcmVjdGx5IGJ5IGEgdmlydHVhbCBtYWNoaW5lLiAgQVJNIElSUSBG b3J3YXJkaW5nIGNhbiBhbGxvdw0KPiArICogbGV2ZWwgdHJpZ2dlcmVkIGRldmljZSBpbnRlcnJ1 cHRzIHRvIGJlIGRlLWFzc2VydGVkIGRpcmVjdGx5IGJ5IHRoZSBWTS4NCj4gKyAqIFRoaXMgbWFu YWdlciBhbGxvd3MgaW50ZXJydXB0IHByb2R1Y2VycyBhbmQgY29uc3VtZXJzIHRvIGZpbmQgZWFj aCBvdGhlcg0KPiArICogdG8gZW5hYmxlIHRoaXMgc29ydCBvZiBieXBhc3MuDQo+ICsgKi8NCj4g Kw0KPiArI2luY2x1ZGUgPGxpbnV4L2lycWJ5cGFzcy5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2xp c3QuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9t dXRleC5oPg0KPiArDQo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7DQo+ICtNT0RVTEVfREVT Q1JJUFRJT04oIklSUSBieXBhc3MgbWFuYWdlciB1dGlsaXR5IG1vZHVsZSIpOw0KPiArDQo+ICtz dGF0aWMgTElTVF9IRUFEKHByb2R1Y2Vycyk7DQo+ICtzdGF0aWMgTElTVF9IRUFEKGNvbnN1bWVy cyk7DQo+ICtzdGF0aWMgREVGSU5FX01VVEVYKGxvY2spOw0KPiArDQo+ICsvKiBAbG9jayBtdXN0 IGJlIGhlbGQgd2hlbiBjYWxsaW5nIGNvbm5lY3QgKi8NCj4gK3N0YXRpYyB2b2lkIF9fY29ubmVj dChzdHJ1Y3QgaXJxX2J5cGFzc19wcm9kdWNlciAqcHJvZCwNCj4gKwkJICAgICAgc3RydWN0IGly cV9ieXBhc3NfY29uc3VtZXIgKmNvbnMpDQo+ICt7DQo+ICsJaWYgKHByb2QtPnN0b3ApDQo+ICsJ CXByb2QtPnN0b3AocHJvZCk7DQo+ICsJaWYgKGNvbnMtPnN0b3ApDQo+ICsJCWNvbnMtPnN0b3Ao Y29ucyk7DQo+ICsJaWYgKHByb2QtPmFkZF9jb25zdW1lcikNCj4gKwkJcHJvZC0+YWRkX2NvbnN1 bWVyKHByb2QsIGNvbnMpOw0KPiArCWlmIChjb25zLT5hZGRfcHJvZHVjZXIpDQo+ICsJCWNvbnMt PmFkZF9wcm9kdWNlcihjb25zLCBwcm9kKTsNCj4gKwlpZiAoY29ucy0+cmVzdW1lKQ0KPiArCQlj b25zLT5yZXN1bWUoY29ucyk7DQo+ICsJaWYgKHByb2QtPnJlc3VtZSkNCj4gKwkJcHJvZC0+cmVz dW1lKHByb2QpOw0KPiArfQ0KPiArDQo+ICsvKiBAbG9jayBtdXN0IGJlIGhlbGQgd2hlbiBjYWxs aW5nIGRpc2Nvbm5lY3QgKi8NCj4gK3N0YXRpYyB2b2lkIF9fZGlzY29ubmVjdChzdHJ1Y3QgaXJx X2J5cGFzc19wcm9kdWNlciAqcHJvZCwNCj4gKwkJCSBzdHJ1Y3QgaXJxX2J5cGFzc19jb25zdW1l ciAqY29ucykNCj4gK3sNCj4gKwlpZiAocHJvZC0+c3RvcCkNCj4gKwkJcHJvZC0+c3RvcChwcm9k KTsNCj4gKwlpZiAoY29ucy0+c3RvcCkNCj4gKwkJY29ucy0+c3RvcChjb25zKTsNCj4gKwlpZiAo Y29ucy0+ZGVsX3Byb2R1Y2VyKQ0KPiArCQljb25zLT5kZWxfcHJvZHVjZXIoY29ucywgcHJvZCk7 DQo+ICsJaWYgKHByb2QtPmRlbF9jb25zdW1lcikNCj4gKwkJcHJvZC0+ZGVsX2NvbnN1bWVyKHBy b2QsIGNvbnMpOw0KPiArCWlmIChjb25zLT5yZXN1bWUpDQo+ICsJCWNvbnMtPnJlc3VtZShjb25z KTsNCj4gKwlpZiAocHJvZC0+cmVzdW1lKQ0KPiArCQlwcm9kLT5yZXN1bWUocHJvZCk7DQo+ICt9 DQo+ICsNCj4gKy8qKg0KPiArICogaXJxX2J5cGFzc19yZWdpc3Rlcl9wcm9kdWNlciAtIHJlZ2lz dGVyIElSUSBieXBhc3MgcHJvZHVjZXINCj4gKyAqIEBwcm9kdWNlcjogcG9pbnRlciB0byBwcm9k dWNlciBzdHJ1Y3R1cmUNCj4gKyAqDQo+ICsgKiBBZGQgdGhlIHByb3ZpZGVkIElSUSBwcm9kdWNl ciB0byB0aGUgbGlzdCBvZiBwcm9kdWNlcnMgYW5kIGNvbm5lY3QNCj4gKyAqIHdpdGggYW55IG1h dGNoaW5nIHRva2VucyBmb3VuZCBvbiB0aGUgSVJRIGNvbnN1bWVycyBsaXN0Lg0KPiArICovDQo+ ICtpbnQgaXJxX2J5cGFzc19yZWdpc3Rlcl9wcm9kdWNlcihzdHJ1Y3QgaXJxX2J5cGFzc19wcm9k dWNlciAqcHJvZHVjZXIpDQo+ICt7DQo+ICsJc3RydWN0IGlycV9ieXBhc3NfcHJvZHVjZXIgKnRt cDsNCj4gKwlzdHJ1Y3QgaXJxX2J5cGFzc19jb25zdW1lciAqY29uc3VtZXI7DQo+ICsNCj4gKwlt aWdodF9zbGVlcCgpOw0KPiArDQo+ICsJaWYgKCF0cnlfbW9kdWxlX2dldChUSElTX01PRFVMRSkp DQo+ICsJCXJldHVybiAtRU5PREVWOw0KPiArDQo+ICsJbXV0ZXhfbG9jaygmbG9jayk7DQo+ICsN Cj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRtcCwgJnByb2R1Y2Vycywgbm9kZSkgew0KPiArCQlp ZiAodG1wLT50b2tlbiA9PSBwcm9kdWNlci0+dG9rZW4pIHsNCj4gKwkJCW11dGV4X3VubG9jaygm bG9jayk7DQo+ICsJCQltb2R1bGVfcHV0KFRISVNfTU9EVUxFKTsNCj4gKwkJCXJldHVybiAtRUlO VkFMOw0KPiArCQl9DQo+ICsJfQ0KPiArDQo+ICsJbGlzdF9hZGQoJnByb2R1Y2VyLT5ub2RlLCAm cHJvZHVjZXJzKTsNCj4gKw0KPiArCWxpc3RfZm9yX2VhY2hfZW50cnkoY29uc3VtZXIsICZjb25z dW1lcnMsIG5vZGUpIHsNCj4gKwkJaWYgKGNvbnN1bWVyLT50b2tlbiA9PSBwcm9kdWNlci0+dG9r ZW4pIHsNCj4gKwkJCV9fY29ubmVjdChwcm9kdWNlciwgY29uc3VtZXIpOw0KPiArCQkJYnJlYWs7 DQo+ICsJCX0NCj4gKwl9DQo+ICsNCj4gKwltdXRleF91bmxvY2soJmxvY2spOw0KPiArCXJldHVy biAwOw0KPiArfQ0KPiArRVhQT1JUX1NZTUJPTF9HUEwoaXJxX2J5cGFzc19yZWdpc3Rlcl9wcm9k dWNlcik7DQo+ICsNCj4gKy8qKg0KPiArICogaXJxX2J5cGFzc191bnJlZ2lzdGVyX3Byb2R1Y2Vy IC0gdW5yZWdpc3RlciBJUlEgYnlwYXNzIHByb2R1Y2VyDQo+ICsgKiBAcHJvZHVjZXI6IHBvaW50 ZXIgdG8gcHJvZHVjZXIgc3RydWN0dXJlDQo+ICsgKg0KPiArICogUmVtb3ZlIGEgcHJldmlvdXNs eSByZWdpc3RlcmVkIElSUSBwcm9kdWNlciBmcm9tIHRoZSBsaXN0IG9mIHByb2R1Y2Vycw0KPiAr ICogYW5kIGRpc2Nvbm5lY3RlZCBmcm9tIGFueSBjb25uZWN0ZWQgSVJRIGNvbnN1bWVycy4NCj4g KyAqLw0KPiArdm9pZCBpcnFfYnlwYXNzX3VucmVnaXN0ZXJfcHJvZHVjZXIoc3RydWN0IGlycV9i eXBhc3NfcHJvZHVjZXIgKnByb2R1Y2VyKQ0KPiArew0KPiArCXN0cnVjdCBpcnFfYnlwYXNzX2Nv bnN1bWVyICpjb25zdW1lcjsNCj4gKw0KPiArCW1pZ2h0X3NsZWVwKCk7DQo+ICsNCj4gKwltdXRl eF9sb2NrKCZsb2NrKTsNCj4gKw0KPiArCWxpc3RfZm9yX2VhY2hfZW50cnkoY29uc3VtZXIsICZj b25zdW1lcnMsIG5vZGUpIHsNCj4gKwkJaWYgKGNvbnN1bWVyLT50b2tlbiA9PSBwcm9kdWNlci0+ dG9rZW4pIHsNCj4gKwkJCV9fZGlzY29ubmVjdChwcm9kdWNlciwgY29uc3VtZXIpOw0KPiArCQkJ YnJlYWs7DQo+ICsJCX0NCj4gKwl9DQo+ICsNCj4gKwlsaXN0X2RlbCgmcHJvZHVjZXItPm5vZGUp Ow0KPiArDQo+ICsJbXV0ZXhfdW5sb2NrKCZsb2NrKTsNCj4gKwltb2R1bGVfcHV0KFRISVNfTU9E VUxFKTsNCj4gK30NCj4gK0VYUE9SVF9TWU1CT0xfR1BMKGlycV9ieXBhc3NfdW5yZWdpc3Rlcl9w cm9kdWNlcik7DQo+ICsNCj4gKy8qKg0KPiArICogaXJxX2J5cGFzc19yZWdpc3Rlcl9jb25zdW1l ciAtIHJlZ2lzdGVyIElSUSBieXBhc3MgY29uc3VtZXINCj4gKyAqIEBjb25zdW1lcjogcG9pbnRl ciB0byBjb25zdW1lciBzdHJ1Y3R1cmUNCj4gKyAqDQo+ICsgKiBBZGQgdGhlIHByb3ZpZGVkIElS USBjb25zdW1lciB0byB0aGUgbGlzdCBvZiBjb25zdW1lcnMgYW5kIGNvbm5lY3QNCj4gKyAqIHdp dGggYW55IG1hdGNoaW5nIHRva2VucyBmb3VuZCBvbiB0aGUgSVJRIHByb2R1Y2VyIGxpc3QuDQo+ ICsgKi8NCj4gK2ludCBpcnFfYnlwYXNzX3JlZ2lzdGVyX2NvbnN1bWVyKHN0cnVjdCBpcnFfYnlw YXNzX2NvbnN1bWVyICpjb25zdW1lcikNCj4gK3sNCj4gKwlzdHJ1Y3QgaXJxX2J5cGFzc19jb25z dW1lciAqdG1wOw0KPiArCXN0cnVjdCBpcnFfYnlwYXNzX3Byb2R1Y2VyICpwcm9kdWNlcjsNCj4g Kw0KPiArCW1pZ2h0X3NsZWVwKCk7DQo+ICsNCj4gKwlpZiAoIXRyeV9tb2R1bGVfZ2V0KFRISVNf TU9EVUxFKSkNCj4gKwkJcmV0dXJuIC1FTk9ERVY7DQo+ICsNCj4gKwltdXRleF9sb2NrKCZsb2Nr KTsNCj4gKw0KPiArCWxpc3RfZm9yX2VhY2hfZW50cnkodG1wLCAmY29uc3VtZXJzLCBub2RlKSB7 DQo+ICsJCWlmICh0bXAtPnRva2VuID09IGNvbnN1bWVyLT50b2tlbikgew0KPiArCQkJbXV0ZXhf dW5sb2NrKCZsb2NrKTsNCj4gKwkJCW1vZHVsZV9wdXQoVEhJU19NT0RVTEUpOw0KPiArCQkJcmV0 dXJuIC1FSU5WQUw7DQo+ICsJCX0NCj4gKwl9DQo+ICsNCj4gKwlsaXN0X2FkZCgmY29uc3VtZXIt Pm5vZGUsICZjb25zdW1lcnMpOw0KPiArDQo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeShwcm9kdWNl ciwgJnByb2R1Y2Vycywgbm9kZSkgew0KPiArCQlpZiAocHJvZHVjZXItPnRva2VuID09IGNvbnN1 bWVyLT50b2tlbikgew0KPiArCQkJX19jb25uZWN0KHByb2R1Y2VyLCBjb25zdW1lcik7DQo+ICsJ CQlicmVhazsNCj4gKwkJfQ0KPiArCX0NCj4gKw0KPiArCW11dGV4X3VubG9jaygmbG9jayk7DQo+ ICsJcmV0dXJuIDA7DQo+ICt9DQo+ICtFWFBPUlRfU1lNQk9MX0dQTChpcnFfYnlwYXNzX3JlZ2lz dGVyX2NvbnN1bWVyKTsNCj4gKw0KPiArLyoqDQo+ICsgKiBpcnFfYnlwYXNzX3VucmVnaXN0ZXJf Y29uc3VtZXIgLSB1bnJlZ2lzdGVyIElSUSBieXBhc3MgY29uc3VtZXINCj4gKyAqIEBjb25zdW1l cjogcG9pbnRlciB0byBjb25zdW1lciBzdHJ1Y3R1cmUNCj4gKyAqDQo+ICsgKiBSZW1vdmUgYSBw cmV2aW91c2x5IHJlZ2lzdGVyZWQgSVJRIGNvbnN1bWVyIGZyb20gdGhlIGxpc3Qgb2YgY29uc3Vt ZXJzDQo+ICsgKiBhbmQgZGlzY29ubmVjdGVkIGZyb20gYW55IGNvbm5lY3RlZCBJUlEgcHJvZHVj ZXJzLg0KPiArICovDQo+ICt2b2lkIGlycV9ieXBhc3NfdW5yZWdpc3Rlcl9jb25zdW1lcihzdHJ1 Y3QgaXJxX2J5cGFzc19jb25zdW1lcg0KPiAqY29uc3VtZXIpDQo+ICt7DQo+ICsJc3RydWN0IGly cV9ieXBhc3NfcHJvZHVjZXIgKnByb2R1Y2VyOw0KPiArDQo+ICsJbWlnaHRfc2xlZXAoKTsNCj4g Kw0KPiArCW11dGV4X2xvY2soJmxvY2spOw0KPiArDQo+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeShw cm9kdWNlciwgJnByb2R1Y2Vycywgbm9kZSkgew0KPiArCQlpZiAocHJvZHVjZXItPnRva2VuID09 IGNvbnN1bWVyLT50b2tlbikgew0KPiArCQkJX19kaXNjb25uZWN0KHByb2R1Y2VyLCBjb25zdW1l cik7DQo+ICsJCQlicmVhazsNCj4gKwkJfQ0KPiArCX0NCj4gKw0KPiArCWxpc3RfZGVsKCZjb25z dW1lci0+bm9kZSk7DQo+ICsNCj4gKwltdXRleF91bmxvY2soJmxvY2spOw0KPiArCW1vZHVsZV9w dXQoVEhJU19NT0RVTEUpOw0KPiArfQ0KPiArRVhQT1JUX1NZTUJPTF9HUEwoaXJxX2J5cGFzc191 bnJlZ2lzdGVyX2NvbnN1bWVyKTsNCg0K -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
[toc] | [next] | [standalone]
| From | Alex Williamson <alex.williamson@redhat.com> |
|---|---|
| Date | 2015-07-08 15:00 +0200 |
| Message-ID | <pJX7d-2OK-37@gated-at.bofh.it> |
| In reply to | #1179724 |
On Wed, 2015-07-08 at 12:22 +0000, Wu, Feng wrote:
>
>
> > -----Original Message-----
> > From: Alex Williamson [mailto:alex.williamson@redhat.com]
> > Sent: Wednesday, July 08, 2015 5:40 AM
> > To: linux-kernel@vger.kernel.org; kvm@vger.kernel.org
> > Cc: eric.auger@st.com; eric.auger@linaro.org; joro@8bytes.org;
> > avi.kivity@gmail.com; pbonzini@redhat.com; Wu, Feng
> > Subject: [RFC PATCH] irq: IRQ bypass manager
> >
> > When a physical I/O device is assigned to a virtual machine through
> > facilities like VFIO and KVM, the interrupt for the device generally
> > bounces through the host system before being injected into the VM.
> > However, hardware technologies exist that often allow the host to be
> > bypassed for some of these scenarios. Intel Posted Interrupts allow
> > the specified physical edge interrupts to be directly injected into a
> > guest when delivered to a physical processor while the vCPU is
> > running. ARM IRQ Forwarding allows the hypervisor to handle level
> > triggered device interrupts as edge interrupts, by giving the guest
> > control of de-asserting and unmasking the interrupt line.
> >
> > The IRQ bypass manager here is meant to provide the shim to connect
> > interrupt producers, generally the host physical device driver, with
> > interrupt consumers, generally the hypervisor, in order to configure
> > these bypass mechanism. To do this, we base the connection on a
> > shared, opaque token. For KVM-VFIO this is expected to be an
> > eventfd_ctx since this is the connection we already use to connect an
> > eventfd to an irqfd on the in-kernel path. When a producer and
> > consumer with matching tokens is found, callbacks via both registered
> > participants allow the bypass facilities to be automatically enabled.
>
> My Pi patches can work well based on this one and the one Eric sent
> out earlier. Alex, what should we do in the next step to speed up the
> upstreaming process?
Hi Feng,
Post the patches. Define how the update() callback is used. Help to
address the issues I've outlined below. Thanks,
Alex
> >
> > Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
> > Cc: Eric Auger <eric.auger@linaro.org>
> > ---
> >
> > This is the current draft of the IRQ bypass manager, I've made the
> > following changes:
> >
> > - Incorporated Eric's extensions (I would welcome Sign-offs from all
> > involved in the development, especially Eric - I've gone ahead and
> > added Linaro copyright for the contributions so far)
> > - Module support with module reference tracking
> > - might_sleep() as suggested by Paolo
> > - kerneldoc as suggested by Paolo
> > - Renamed file s/bypass/irqbypass/ because a module named "bypass"
> > is strange
> >
> > Issues:
> > - The update() callback is defined but not used
> > - We can't have *all* the callbacks be optional. I assume add/del
> > are required
> > - Naming consistency, stop is to start as suspend is to resume, not
> > stop/resume
> > - Callback descriptions including why we need separate stop/start
> > hooks when it seems like the callee could reasonably assume such
> > around the add/del callbacks
> > - Need functional prototypes for both PI and forwarding
> >
> > include/linux/irqbypass.h | 75 ++++++++++++++++
> > kernel/irq/Kconfig | 3 +
> > kernel/irq/Makefile | 1
> > kernel/irq/irqbypass.c | 206
> > +++++++++++++++++++++++++++++++++++++++++++++
> > 4 files changed, 285 insertions(+)
> > create mode 100644 include/linux/irqbypass.h
> > create mode 100644 kernel/irq/irqbypass.c
> >
> > diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h
> > new file mode 100644
> > index 0000000..cc7ce45
> > --- /dev/null
> > +++ b/include/linux/irqbypass.h
> > @@ -0,0 +1,75 @@
> > +/*
> > + * IRQ offload/bypass manager
> > + *
> > + * Copyright (C) 2015 Red Hat, Inc.
> > + * Copyright (c) 2015 Linaro Ltd.
> > + *
> > + * This program is free software; you can redistribute it and/or modify
> > + * it under the terms of the GNU General Public License version 2 as
> > + * published by the Free Software Foundation.
> > + */
> > +#ifndef IRQBYPASS_H
> > +#define IRQBYPASS_H
> > +
> > +#include <linux/list.h>
> > +
> > +struct irq_bypass_consumer;
> > +
> > +/**
> > + * struct irq_bypass_producer - IRQ bypass producer definition
> > + * @node: IRQ bypass manager private list management
> > + * @token: opaque token to match between producer and consumer
> > + * @irq: Linux IRQ number for the producer device
> > + * @stop:
> > + * @resume:
> > + * @add_consumer:
> > + * @del_consumer:
> > + *
> > + * The IRQ bypass producer structure represents an interrupt source for
> > + * participation in possible host bypass, for instance an interrupt vector
> > + * for a physical device assigned to a VM.
> > + */
> > +struct irq_bypass_producer {
> > + struct list_head node;
> > + void *token;
> > + int irq; /* linux irq */
> > + void (*stop)(struct irq_bypass_producer *);
> > + void (*resume)(struct irq_bypass_producer *);
> > + void (*add_consumer)(struct irq_bypass_producer *,
> > + struct irq_bypass_consumer *);
> > + void (*del_consumer)(struct irq_bypass_producer *,
> > + struct irq_bypass_consumer *);
> > +};
> > +
> > +/**
> > + * struct irq_bypass_consumer - IRQ bypass consumer definition
> > + * @node: IRQ bypass manager private list management
> > + * @token: opaque token to match between producer and consumer
> > + * @stop:
> > + * @resume:
> > + * @add_consumer:
> > + * @del_consumer:
> > + * @update:
> > + *
> > + * The IRQ bypass consumer structure represents an interrupt sink for
> > + * participation in possible host bypass, for instance a hypervisor may
> > + * support offloads to allow bypassing the host entirely or offload
> > + * portions of the interrupt handling to the VM.
> > + */
> > +struct irq_bypass_consumer {
> > + struct list_head node;
> > + void *token;
> > + void (*stop)(struct irq_bypass_consumer *);
> > + void (*resume)(struct irq_bypass_consumer *);
> > + void (*add_producer)(struct irq_bypass_consumer *,
> > + struct irq_bypass_producer *);
> > + void (*del_producer)(struct irq_bypass_consumer *,
> > + struct irq_bypass_producer *);
> > + void (*update)(struct irq_bypass_consumer *);
> > +};
> > +
> > +int irq_bypass_register_producer(struct irq_bypass_producer *);
> > +void irq_bypass_unregister_producer(struct irq_bypass_producer *);
> > +int irq_bypass_register_consumer(struct irq_bypass_consumer *);
> > +void irq_bypass_unregister_consumer(struct irq_bypass_consumer *);
> > +#endif /* IRQBYPASS_H */
> > diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
> > index 9a76e3b..de5afe3 100644
> > --- a/kernel/irq/Kconfig
> > +++ b/kernel/irq/Kconfig
> > @@ -100,4 +100,7 @@ config SPARSE_IRQ
> >
> > If you don't know what to do here, say N.
> >
> > +config IRQ_BYPASS_MANAGER
> > + tristate
> > +
> > endmenu
> > diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
> > index d121235..a6cfec7 100644
> > --- a/kernel/irq/Makefile
> > +++ b/kernel/irq/Makefile
> > @@ -7,3 +7,4 @@ obj-$(CONFIG_PROC_FS) += proc.o
> > obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
> > obj-$(CONFIG_PM_SLEEP) += pm.o
> > obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
> > +obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o
> > diff --git a/kernel/irq/irqbypass.c b/kernel/irq/irqbypass.c
> > new file mode 100644
> > index 0000000..3fd828d
> > --- /dev/null
> > +++ b/kernel/irq/irqbypass.c
> > @@ -0,0 +1,206 @@
> > +/*
> > + * IRQ offload/bypass manager
> > + *
> > + * Copyright (C) 2015 Red Hat, Inc.
> > + * Copyright (c) 2015 Linaro Ltd.
> > + *
> > + * This program is free software; you can redistribute it and/or modify
> > + * it under the terms of the GNU General Public License version 2 as
> > + * published by the Free Software Foundation.
> > + *
> > + * Various virtualization hardware acceleration techniques allow bypassing
> > + * or offloading interrupts received from devices around the host kernel.
> > + * Posted Interrupts on Intel VT-d systems can allow interrupts to be
> > + * received directly by a virtual machine. ARM IRQ Forwarding can allow
> > + * level triggered device interrupts to be de-asserted directly by the VM.
> > + * This manager allows interrupt producers and consumers to find each other
> > + * to enable this sort of bypass.
> > + */
> > +
> > +#include <linux/irqbypass.h>
> > +#include <linux/list.h>
> > +#include <linux/module.h>
> > +#include <linux/mutex.h>
> > +
> > +MODULE_LICENSE("GPL v2");
> > +MODULE_DESCRIPTION("IRQ bypass manager utility module");
> > +
> > +static LIST_HEAD(producers);
> > +static LIST_HEAD(consumers);
> > +static DEFINE_MUTEX(lock);
> > +
> > +/* @lock must be held when calling connect */
> > +static void __connect(struct irq_bypass_producer *prod,
> > + struct irq_bypass_consumer *cons)
> > +{
> > + if (prod->stop)
> > + prod->stop(prod);
> > + if (cons->stop)
> > + cons->stop(cons);
> > + if (prod->add_consumer)
> > + prod->add_consumer(prod, cons);
> > + if (cons->add_producer)
> > + cons->add_producer(cons, prod);
> > + if (cons->resume)
> > + cons->resume(cons);
> > + if (prod->resume)
> > + prod->resume(prod);
> > +}
> > +
> > +/* @lock must be held when calling disconnect */
> > +static void __disconnect(struct irq_bypass_producer *prod,
> > + struct irq_bypass_consumer *cons)
> > +{
> > + if (prod->stop)
> > + prod->stop(prod);
> > + if (cons->stop)
> > + cons->stop(cons);
> > + if (cons->del_producer)
> > + cons->del_producer(cons, prod);
> > + if (prod->del_consumer)
> > + prod->del_consumer(prod, cons);
> > + if (cons->resume)
> > + cons->resume(cons);
> > + if (prod->resume)
> > + prod->resume(prod);
> > +}
> > +
> > +/**
> > + * irq_bypass_register_producer - register IRQ bypass producer
> > + * @producer: pointer to producer structure
> > + *
> > + * Add the provided IRQ producer to the list of producers and connect
> > + * with any matching tokens found on the IRQ consumers list.
> > + */
> > +int irq_bypass_register_producer(struct irq_bypass_producer *producer)
> > +{
> > + struct irq_bypass_producer *tmp;
> > + struct irq_bypass_consumer *consumer;
> > +
> > + might_sleep();
> > +
> > + if (!try_module_get(THIS_MODULE))
> > + return -ENODEV;
> > +
> > + mutex_lock(&lock);
> > +
> > + list_for_each_entry(tmp, &producers, node) {
> > + if (tmp->token == producer->token) {
> > + mutex_unlock(&lock);
> > + module_put(THIS_MODULE);
> > + return -EINVAL;
> > + }
> > + }
> > +
> > + list_add(&producer->node, &producers);
> > +
> > + list_for_each_entry(consumer, &consumers, node) {
> > + if (consumer->token == producer->token) {
> > + __connect(producer, consumer);
> > + break;
> > + }
> > + }
> > +
> > + mutex_unlock(&lock);
> > + return 0;
> > +}
> > +EXPORT_SYMBOL_GPL(irq_bypass_register_producer);
> > +
> > +/**
> > + * irq_bypass_unregister_producer - unregister IRQ bypass producer
> > + * @producer: pointer to producer structure
> > + *
> > + * Remove a previously registered IRQ producer from the list of producers
> > + * and disconnected from any connected IRQ consumers.
> > + */
> > +void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
> > +{
> > + struct irq_bypass_consumer *consumer;
> > +
> > + might_sleep();
> > +
> > + mutex_lock(&lock);
> > +
> > + list_for_each_entry(consumer, &consumers, node) {
> > + if (consumer->token == producer->token) {
> > + __disconnect(producer, consumer);
> > + break;
> > + }
> > + }
> > +
> > + list_del(&producer->node);
> > +
> > + mutex_unlock(&lock);
> > + module_put(THIS_MODULE);
> > +}
> > +EXPORT_SYMBOL_GPL(irq_bypass_unregister_producer);
> > +
> > +/**
> > + * irq_bypass_register_consumer - register IRQ bypass consumer
> > + * @consumer: pointer to consumer structure
> > + *
> > + * Add the provided IRQ consumer to the list of consumers and connect
> > + * with any matching tokens found on the IRQ producer list.
> > + */
> > +int irq_bypass_register_consumer(struct irq_bypass_consumer *consumer)
> > +{
> > + struct irq_bypass_consumer *tmp;
> > + struct irq_bypass_producer *producer;
> > +
> > + might_sleep();
> > +
> > + if (!try_module_get(THIS_MODULE))
> > + return -ENODEV;
> > +
> > + mutex_lock(&lock);
> > +
> > + list_for_each_entry(tmp, &consumers, node) {
> > + if (tmp->token == consumer->token) {
> > + mutex_unlock(&lock);
> > + module_put(THIS_MODULE);
> > + return -EINVAL;
> > + }
> > + }
> > +
> > + list_add(&consumer->node, &consumers);
> > +
> > + list_for_each_entry(producer, &producers, node) {
> > + if (producer->token == consumer->token) {
> > + __connect(producer, consumer);
> > + break;
> > + }
> > + }
> > +
> > + mutex_unlock(&lock);
> > + return 0;
> > +}
> > +EXPORT_SYMBOL_GPL(irq_bypass_register_consumer);
> > +
> > +/**
> > + * irq_bypass_unregister_consumer - unregister IRQ bypass consumer
> > + * @consumer: pointer to consumer structure
> > + *
> > + * Remove a previously registered IRQ consumer from the list of consumers
> > + * and disconnected from any connected IRQ producers.
> > + */
> > +void irq_bypass_unregister_consumer(struct irq_bypass_consumer
> > *consumer)
> > +{
> > + struct irq_bypass_producer *producer;
> > +
> > + might_sleep();
> > +
> > + mutex_lock(&lock);
> > +
> > + list_for_each_entry(producer, &producers, node) {
> > + if (producer->token == consumer->token) {
> > + __disconnect(producer, consumer);
> > + break;
> > + }
> > + }
> > +
> > + list_del(&consumer->node);
> > +
> > + mutex_unlock(&lock);
> > + module_put(THIS_MODULE);
> > +}
> > +EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);
>
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[toc] | [prev] | [standalone]
Back to top | Article view | linux.kernel
csiph-web