From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from [59.151.112.132] (helo=heian.cn.fujitsu.com) by bombadil.infradead.org with esmtp (Exim 4.85_2 #1 (Red Hat Linux)) id 1bRxN8-0004Zk-Nw for kexec@lists.infradead.org; Tue, 26 Jul 2016 08:05:54 +0000 From: "Wei, Jiangang" Subject: Re: [PATCH v2 3/3] x86/apic: Improved the setting of interrupt mode for bsp Date: Tue, 26 Jul 2016 08:05:20 +0000 Message-ID: <1469520148.7811.54.camel@localhost> References: <1469501995-2991-1-git-send-email-weijg.fnst@cn.fujitsu.com> <1469501995-2991-4-git-send-email-weijg.fnst@cn.fujitsu.com> <87k2g92gxb.fsf@x220.int.ebiederm.org> In-Reply-To: <87k2g92gxb.fsf@x220.int.ebiederm.org> Content-Language: en-US Content-ID: MIME-Version: 1.0 List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kexec" Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org To: "ebiederm@xmission.com" Cc: "bhe@redhat.com" , "xpang@redhat.com" , "joro@8bytes.org" , "x86@kernel.org" , "kexec@lists.infradead.org" , "linux-kernel@vger.kernel.org" , "Cao, Jin" , "mingo@redhat.com" , "kernel@kyup.com" , "hpa@zytor.com" , "tglx@linutronix.de" SGkgRXJpYywNCg0KVGhhbmtzIGZvciB5b3VyIHJlc3BvbnNlLg0KQnV0IEkgaGF2ZSBzb21lIGRp ZmZlcmVudCBpZGVhcy4uLg0KDQpPbiBNb24sIDIwMTYtMDctMjUgYXQgMjI6NTMgLTA1MDAsIEVy aWMgVy4gQmllZGVybWFuIHdyb3RlOg0KPiBXZWkgSmlhbmdhbmcgPHdlaWpnLmZuc3RAY24uZnVq aXRzdS5jb20+IHdyaXRlczoNCj4gDQo+ID4gSWYgd2Ugc3BlY2lmeSB0aGUgJ25vdHNjJyBwYXJh bWV0ZXIgZm9yIHRoZSBkdW1wLWNhcHR1cmUga2VybmVsLA0KPiA+IGFuZCB0aGVuIHRyaWdnZXIg YSBjcmFzaChwYW5pYykgYnkgdXNpbmcgIkFMVC1TeXNScS1jIiBvcg0KPiA+ICJlY2hvIGMgPiAv cHJvYy9zeXNycS10cmlnZ2VyIiwgdGhlIGR1bXAtY2FwdHVyZSBrZXJuZWwgd2lsbA0KPiA+IGhh bmcgaW4gY2FsaWJyYXRlX2RlbGF5X2NvbnZlcmdlKCkgYW5kIHdhaXQgZm9yIGppZmZpZXMgY2hh bmdlcy4NCj4gPiBzZXJpYWwgbG9nIGFzIGZvbGxvd3M6DQo+ID4NCj4gPiAgICAgdHNjOiBGYXN0 IFRTQyBjYWxpYnJhdGlvbiB1c2luZyBQSVQNCj4gPiAgICAgdHNjOiBEZXRlY3RlZCAyMDk5Ljk0 NyBNSHogcHJvY2Vzc29yDQo+ID4gICAgIENhbGlicmF0aW5nIGRlbGF5IGxvb3AuLi4NCj4gPg0K PiA+IFRoZSByZWFzb24gZm9yIGppZmZpZXMgbm90IGNoYW5nZXMgaXMgdGhlcmUncyBubyB0aW1l ciBpbnRlcnJ1cHQNCj4gPiBwYXNzZWQgdG8gZHVtcC1jYXB0dXJlIGtlcm5lbC4NCj4gPg0KPiA+ IEluIGZhY3QsIG9uY2Uga2VybmVsIHBhbmljIG9jY3VycywgdGhlIGxvY2FsIEFQSUMgaXMgZGlz YWJsZWQNCj4gPiBieSBsYXBpY19zaHV0ZG93bigpIGluIHJlYm9vdCBwYXRoLg0KPiA+IGdlbmVy bHkgc3BlYWtpbmcsIGxvY2FsIEFQSUMgc3RhdGUgY2FuIGJlIGluaXRpYWxpemVkIGJ5IEJJT1MN Cj4gPiBhZnRlciBQb3dlci1VcCBvciBSZXNldCwgd2hpY2ggZG9lc24ndCBhcHBseSB0byBrZHVt cCBjYXNlLg0KPiA+IHNvIHRoZSBrZXJuZWwgaGFzIHRvIGJlIHJlc3BvbnNpYmxlIGZvciBpbml0 aWFsaXplIHRoZSBpbnRlcnJ1cHQNCj4gPiBtb2RlIHByb3Blcmx5IGFjY29yZGluZyB0aGUgbGF0 ZXN0IHN0YXR1cyBvZiBBUElDIGluIGJvb3R1cCBwYXRoLg0KPiA+DQo+ID4gQW4gTVAgb3BlcmF0 aW5nIHN5c3RlbSBpcyBib290ZWQgdW5kZXIgZWl0aGVyIFBJQyBtb2RlIG9yDQo+ID4gdmlydHVh bCB3aXJlIG1vZGUuIExhdGVyLCB0aGUgb3BlcmF0aW5nIHN5c3RlbSBzd2l0Y2hlcyB0bw0KPiA+ IHN5bW1ldHJpYyBJL08gbW9kZSBhcyBpdCBlbnRlcnMgbXVsdGlwcm9jZXNzb3IgbW9kZS4NCj4g PiBUd28ga2luZHMgb2YgdmlydHVhbCB3aXJlIG1vZGUgYXJlIGRlZmluZWQgaW4gSW50ZWwgTVAg c3BlYzoNCj4gPiB2aXJ0dWFsIHdpcmUgbW9kZSB2aWEgbG9jYWwgQVBJQyBvciB2aWEgSS9PIEFQ SUMuDQo+ID4NCj4gPiBOb3cgd2UgZGV0ZXJtaW5lIHRoZSBtb2RlIG9mIEFQSUMgb25seSB0aHJv dWdoIGEgU01QIEJJT1MoTVAgdGFibGUpLg0KPiA+IFRoYXQncyBub3QgZW5vdWdoLiBJdCdzIGJl dHRlciB0byBkbyBmdXJ0aGVyIGNoZWNrIGlmIEFQSUMgd29ya3MNCj4gPiB3aXRoIGVmZmVjdGl2 ZSBpbnRlcnJ1cHQgbW9kZSwgYW5kIHRoZW4sIGRvIHNvbWUgcHJvcGVyIHNldHRpbmcuDQo+IA0K PiBSZWFkaW5nIHRocm91Z2ggdGhlIGNvZGUgbGV0IG1lIHBhdXNlIGEgbW9tZW50IGFuZCBzYXk6 DQo+ICJZb3d6ZXJzIHRoZSBpbnRlcnJ1cHQgaW5pdGlhbGl6YXRpb24gY29kZSBoYXMgZ290dGVu IGhhcmQgdG8gZm9sbG93LiAgSXQNCj4gaXMgbm93IGZ1bGwgb2YgaW5kaXJlY3Rpb24gd2l0aCBp bGwgZGVmaW5lZCBzZW1hbnRpY3MuIiAgcHJlX3ZlY3Rvcl9pbml0DQo+IGluZGVlZC4NCj4gDQo+ IEkgd2lsbCBhcmd1ZSB0aGlzIGlzIHRoZSB3cm9uZyBmaXguDQo+IA0KPiBXZSByZWFsbHkgc2hv dWxkIG5vdCBoYXZlIHRvIHdvcnJ5IGFib3V0IGdldHRpbmcgdGhlIHN5c3RlbSBmdW5jdGlvbmFs DQo+IGluIHZpcnR1YWwgd2lyZSBtb2RlIG9uIGEgbW9kZXJuIHN5c3RlbS4gIEFuZCBsb29raW5n IGF0IHRoZSBjb2RlDQo+IHNvbWVvbmUgaGFzIGRvbmUgaGFsZiB0aGUgd29yayBhbmQgbWFkZSBp dCBjb25kaXRpb25hbCB1bmRlcg0KPiBhY3BpX2dibF9yZWR1Y2VkX2hhcmR3YXJlLg0KPiANCj4g Tm93IHJlZHVjZWQgaGFyZHdhcmUgaW1wbGllcyBhIGJpdCBtb3JlIHRoYW4gd2Ugd2FyZSB0YWxr aW5nIGFib3V0IGJ1dA0KPiBpZiB0aGVyZSBpcyBBQ1BJIGFwaWMgaW5mb3JtYXRpb24gd2Ugc2hv dWxkIG5vdCBuZWVkIHRvIHdvcnJ5IGFib3V0DQo+IGV4dGVybmFsIGludGVycnVwdHMgYW5kIGNh biBqdXN0IGVuYWJsZSB0aGUgYXBpY3MuDQo+IA0KPiBJbiBmYWN0IEkgdGhpbmsgaGF2aW5nIE1Q dGFibGUgaW5mb3JtYXRpb24gaXMgZW5vdWdoIGZvciB0aGF0Lg0KDQpJbiBteSBvcGluaW9uLCBU aGUgTVAgdGFibGUgaXMgbm90IHRvIGJlIHRydXN0ZWQgaWYgc3lzdGVtIHN0YXJ0cw0Kd2l0aG91 dCBCSU9TIHBocmFzZS4gDQoNClRoZSBjaGFwdGVyIDMuOCBTeXN0ZW0gSW5pdGlhbCBTdGF0ZSAo TVAgdjEuNCBzcGVjKSBzYWlkIGJlbG93Og0KIjEuIEFsbCBsb2NhbCBBUElDcyBhcmUgZGlzYWJs ZWQsIGV4Y2VwdCBmb3IgdGhlIGxvY2FsIEFQSUMgb2YgdGhlIEJTUA0KaWYgdGhlIHN5c3RlbSBz dGFydHMgaW4gVmlydHVhbCBXaXJlIE1vZGUuIg0KDQpBbmQNCi4uLi4uDQoiVGhlIEJJT1MgbXVz dCBkaXNhYmxlIGludGVycnVwdHMgdG8gYWxsIHByb2Nlc3NvcnMgYW5kIHNldCB0aGUgQVBJQ3Mg dG8NCnRoZSBzeXN0ZW0gaW5pdGlhbCBzdGF0ZSBiZWZvcmUgZ2l2aW5nIGNvbnRyb2wgdG8gdGhl IG9wZXJhdGluZyBzeXN0ZW0uDQpUaGUgb3BlcmF0aW5nIHN5c3RlbSBpcyByZXNwb25zaWJsZSBm b3IgaW5pdGlhbGl6aW5nIGFsbCBvZiB0aGUgQVBJQ3MiDQoNClRoZSBkdW1wLWNhcHR1cmUga2Vy bmVsIHdvbid0IHRocm91Z2ggdGhlIEJJT1MgcGhyYXNlLA0Kc28gdGhlcmUgaXMgbm8gZ3VhcmFu dGVlIG9mIHRoZSBpbnRlcnJ1cHQgbW9kZSBvZiBBUElDIGFuZCB0aGUgc3RhdHVzIG9mDQpsb2Nh bCBBUElDLg0KDQpBbHRob3VnaCB0aGUgTVAgdGFibGUgaXMgcmVhZC1vbmx5LA0KdGhlIGR1bXAt Y2FwdHVyZSBrZXJuZWwgdXNlcyB0aGUgTVAgdGFibGUgd2hpY2ggYmUgZ2VuZXJhdGVkIGJlZm9y ZSB0aGUNCmZpcnN0IGtlcm5lbCBib290cyB1cCBpcyB1bnJlYXNvbmFibGUuIA0KQXQgbGVhc3Qs IG9ubHkgY2hlY2tpbmcgTVAgdGFibGUgaXMgbm90IGVub3VnaC4NClRoYXQncyB0aGUgc3RhcnRp bmcgcG9pbnQgb2YgbXkgcGF0Y2guDQoNCllvdSBzYWlkIOKAnHRoaXMgaXMgdGhlIHdyb25nIGZp eOKAnSwgDQpJcyB0aGVyZSBhbnkgd3Jvbmcgd2l0aCB0aGUgY29kZXMgb3IgbXkgc29sdXRpb24g dG8gY2hlY2sgdGhlIHN0YXR1cyBvZg0KQVBJQyBpbiBib290dXAgcGF0aD8NCg0KDQo+IFNvIEkg dGhpbmsgd2hhdCBuZWVkcyB0byBoYXBwZW5zIGlzIGZvciB0aGUgYXBpYyBpbml0aWFsaXphdGlv biB0byBnZXQNCj4gYW4gb3ZlcmhhdWwgdGhhdCBtYWtlcyBhcGljIGluaXRpYWxpemF0aW9uIHRo ZSBoYXBweSBwYXRoIGFuZCB0aGUgb3RoZXINCj4gaXJxIGNvbnRyb2xsZXJzIHRoZSBvZGQgYmFj a3dhcmRzIGNvbXBhdGliaWxpdHkgcGF0aC4gIEFuZCB3aGVuIHdlDQo+IGFyZSBkb25lIHdlIG5l dmVyIHJ1biBpbiBhbnl0aGluZyBleGNlcHQgZnVsbCBhcGljIG1vZGUgdW5sZXNzIHRoZQ0KPiBo YXJkd2FyZSBkb2Vzbid0IHN1cHBvcnQgaXQuDQpUaGUgc3BlYyByZXF1ZXN0cyAiQW4gTVAgb3Bl cmF0aW5nIHN5c3RlbSBpcyBib290ZWQgdW5kZXIgZWl0aGVyIG9uZSBvZg0KdGhlIHR3byBQQy9B VC1jb21wYXRpYmxlIG1vZGVzLiBMYXRlciB0aGUgb3BlcmF0aW5nIHN5c3RlbSBzd2l0Y2hlcyB0 bw0KU3ltbWV0cmljIEkvTyBNb2RlIGFzIGl0IGVudGVycyBtdWx0aXByb2Nlc3NvciBtb2RlLiIN CkFuZCBpdCBzZWVtcyB0aGF0IHRoZSBsYXRlc3Qga2VybmVsIGZvbGxvd3MgdGhlIHJ1bGUuDQpE b2VzIHRoZSBhcGljIGluaXRpYWxpemF0aW9uIHJlYWxseSBuZWVkIHRvIGJlIGNoYW5nZWQ/DQoN ClRoYW5rcywNCndlaQ0KPiANCj4gSSB0aGluayB0aGF0IHdpbGwgbGVhdmUgdGhpbmdzIG1vcmUg cm9idXN0IGFzIHdlIGRvbid0IG5lZWQgdG8gc2V0dXANCj4gYW5kIHRoZW4gcmVzZXQgdXAgdGhl IGludGVycnVwdHMgZHVyaW5nIGJvb3QuDQo+IA0KPiBFcmljDQo+IA0KPiANCj4gPiBTaWduZWQt b2ZmLWJ5OiBDYW8gamluIDxjYW9qLmZuc3RAY24uZnVqaXRzdS5jb20+DQo+ID4gU2lnbmVkLW9m Zi1ieTogV2VpIEppYW5nYW5nIDx3ZWlqZy5mbnN0QGNuLmZ1aml0c3UuY29tPg0KPiA+IC0tLQ0K PiA+ICBhcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmggfCAgNSArKysrDQo+ID4gIGFyY2gv eDg2L2tlcm5lbC9hcGljL2FwaWMuYyAgICB8IDYwICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrLQ0KPiA+ICBhcmNoL3g4Ni9rZXJuZWwvYXBpYy9pb19hcGljLmMgfCAy OCArKysrKysrKysrKysrKysrKysrKw0KPiA+ICAzIGZpbGVzIGNoYW5nZWQsIDkyIGluc2VydGlv bnMoKyksIDEgZGVsZXRpb24oLSkNCj4gPg0KPiA+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNs dWRlL2FzbS9pb19hcGljLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgNCj4gPiBp bmRleCA2Y2JmMmNmYjNmOGEuLmEzMjU3MzY2YmY3ZiAxMDA2NDQNCj4gPiAtLS0gYS9hcmNoL3g4 Ni9pbmNsdWRlL2FzbS9pb19hcGljLmgNCj4gPiArKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9p b19hcGljLmgNCj4gPiBAQCAtMTkwLDYgKzE5MCw3IEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQg aW50IGlvX2FwaWNfcmVhZCh1bnNpZ25lZCBpbnQgYXBpYywgdW5zaWduZWQgaW50IHJlZykNCj4g PiAgfQ0KPiA+ICANCj4gPiAgZXh0ZXJuIHZvaWQgc2V0dXBfSU9fQVBJQyh2b2lkKTsNCj4gPiAr ZXh0ZXJuIGJvb2wgdmlydF93aXJlX3Rocm91Z2hfaW9hcGljKHZvaWQpOw0KPiA+ICBleHRlcm4g dm9pZCBlbmFibGVfSU9fQVBJQyh2b2lkKTsNCj4gPiAgZXh0ZXJuIHZvaWQgZGlzYWJsZV9JT19B UElDKHZvaWQpOw0KPiA+ICBleHRlcm4gdm9pZCBzZXR1cF9pb2FwaWNfZGVzdCh2b2lkKTsNCj4g PiBAQCAtMjMxLDYgKzIzMiwxMCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgaW9fYXBpY19pbml0X21h cHBpbmdzKHZvaWQpIHsgfQ0KPiA+ICAjZGVmaW5lIG5hdGl2ZV9kaXNhYmxlX2lvX2FwaWMJCU5V TEwNCj4gPiAgDQo+ID4gIHN0YXRpYyBpbmxpbmUgdm9pZCBzZXR1cF9JT19BUElDKHZvaWQpIHsg fQ0KPiA+ICtzdGF0aWMgaW5saW5lIGJvb2wgdmlydF93aXJlX3Rocm91Z2hfaW9hcGljKHZvaWQp DQo+ID4gK3sNCj4gPiArCXJldHVybiBmYWxzZTsNCj4gPiArfQ0KPiA+ICBzdGF0aWMgaW5saW5l IHZvaWQgZW5hYmxlX0lPX0FQSUModm9pZCkgeyB9DQo+ID4gIHN0YXRpYyBpbmxpbmUgdm9pZCBz ZXR1cF9pb2FwaWNfZGVzdCh2b2lkKSB7IH0NCj4gPiAgDQo+ID4gZGlmZiAtLWdpdCBhL2FyY2gv eDg2L2tlcm5lbC9hcGljL2FwaWMuYyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2FwaWMuYw0KPiA+ IGluZGV4IDhlMjViOWIyZDM1MS4uYTM5MzlmYjEzMGNjIDEwMDY0NA0KPiA+IC0tLSBhL2FyY2gv eDg2L2tlcm5lbC9hcGljL2FwaWMuYw0KPiA+ICsrKyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2Fw aWMuYw0KPiA+IEBAIC0xMTI0LDYgKzExMjQsNTggQEAgdm9pZCBfX2luaXQgc3luY19BcmJfSURz KHZvaWQpDQo+ID4gIH0NCj4gPiAgDQo+ID4gIC8qDQo+ID4gKyAqIENoZWNrIEFQSUMgZW5hYmxl L2Rpc2FibGUgZmxhZw0KPiA+ICsgKi8NCj4gPiArc3RhdGljIGJvb2wgY2hlY2tfYXBpY19lbmFi bGVkKHZvaWQpDQo+ID4gK3sNCj4gPiArCXVuc2lnbmVkIGludCB2YWx1ZTsNCj4gPiArDQo+ID4g KwkvKg0KPiA+ICsJICogSWYgQVBJQyBpcyBkaXNhYmxlZCBnbG9iYWxseSAoSUEzMl9BUElDX0JB U0VbMTFdID09IDApDQo+ID4gKwkgKiB0aGUgYm9vdCBjcHUgaGFzbid0IFg4Nl9GRUFUVVJFX0FQ SUMsDQo+ID4gKwkgKiBhbmQgaW5pdF9ic3BfQVBJQygpIGhhcyBhbHJlYWR5IGNoZWNrZWQgaXQg YmVmb3JlLg0KPiA+ICsJICogc28gbm8gbmVlZCB0byBjaGVjayBnbG9iYWwgZW5hYmxlL2Rpc2Fi bGUgZmxhZyBoZXJlDQo+ID4gKwkgKi8NCj4gPiArDQo+ID4gKwkvKiBDaGVjayB0aGUgc29mdHdh cmUgZW5hYmxlL2Rpc2FibGUgZmxhZyAqLw0KPiA+ICsJdmFsdWUgPSBhcGljX3JlYWQoQVBJQ19T UElWKTsNCj4gPiArCWlmICghKHZhbHVlICYgQVBJQ19TUElWX0FQSUNfRU5BQkxFRCkpDQo+ID4g KwkJcmV0dXJuIGZhbHNlOw0KPiA+ICsNCj4gPiArCXJldHVybiB0cnVlOw0KPiA+ICt9DQo+ID4g Kw0KPiA+ICsvKg0KPiA+ICsgKiBSZXR1cm4gZmFsc2UgbWVhbnMgdGhlIHRocm91Z2gtbG9jYWwt QVBJQyB2aXJ0dWFsIHdpcmUgbW9kZSBpcyBpbmFjdGl2ZQ0KPiA+ICsgKi8NCj4gPiArc3RhdGlj IGJvb2wgdmlydF93aXJlX3Rocm91Z2hfbGFwaWModm9pZCkNCj4gPiArew0KPiA+ICsJdW5zaWdu ZWQgaW50IHZhbHVlOw0KPiA+ICsNCj4gPiArCS8qDQo+ID4gKwkgKiBUaGUgdGhyb3VnaC1sb2Nh bC1BUElDIHZpcnR1YWwgd2lyZSBtb2RlIHJlcXVlc3RzDQo+ID4gKwkgKiBsb2NhbCBBUElDIHRv IGVuYWJsZSBMSU5UMCBmb3IgRXh0SU5UIGRlbGl2ZXJ5IG1vZGUNCj4gPiArCSAqIGFuZCBMSU5U MSBmb3IgTk1JIGRlbGl2ZXJ5IG1vZGUNCj4gPiArCSAqLw0KPiA+ICsJdmFsdWUgPSBhcGljX3Jl YWQoQVBJQ19MVlQwKTsNCj4gPiArCWlmIChHRVRfQVBJQ19ERUxJVkVSWV9NT0RFKHZhbHVlKSAh PSBBUElDX01PREVfRVhUSU5UKQ0KPiA+ICsJCXJldHVybiBmYWxzZTsNCj4gPiArDQo+ID4gKwl2 YWx1ZSA9IGFwaWNfcmVhZChBUElDX0xWVDEpOw0KPiA+ICsJaWYgKEdFVF9BUElDX0RFTElWRVJZ X01PREUodmFsdWUpICE9IEFQSUNfTU9ERV9OTUkpDQo+ID4gKwkJcmV0dXJuIGZhbHNlOw0KPiA+ ICsNCj4gPiArCXJldHVybiB0cnVlOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgYm9vbCBj aGVja192aXJ0X3dpcmVfbW9kZSh2b2lkKQ0KPiA+ICt7DQo+ID4gKwkvKiBJZiBuZWl0aGVyIG9m IHZpcnR1YWwgd2lyZSBtb2RlIGlzIGFjdGl2ZSwgcmV0dXJuIGZhbHNlICovDQo+ID4gKwlyZXR1 cm4gKGNoZWNrX2FwaWNfZW5hYmxlZCgpICYmICh2aXJ0X3dpcmVfdGhyb3VnaF9sYXBpYygpIHx8 DQo+ID4gKwkJdmlydF93aXJlX3Rocm91Z2hfaW9hcGljKCkpKTsNCj4gPiArfQ0KPiA+ICsNCj4g PiArLyoNCj4gPiAgICogQW4gaW5pdGlhbCBzZXR1cCBvZiB0aGUgdmlydHVhbCB3aXJlIG1vZGUu DQo+ID4gICAqLw0KPiA+ICB2b2lkIF9faW5pdCBpbml0X2JzcF9BUElDKHZvaWQpDQo+ID4gQEAg LTExMzMsOCArMTE4NSwxNCBAQCB2b2lkIF9faW5pdCBpbml0X2JzcF9BUElDKHZvaWQpDQo+ID4g IAkvKg0KPiA+ICAJICogRG9uJ3QgZG8gdGhlIHNldHVwIG5vdyBpZiB3ZSBoYXZlIGEgU01QIEJJ T1MgYXMgdGhlDQo+ID4gIAkgKiB0aHJvdWdoLUkvTy1BUElDIHZpcnR1YWwgd2lyZSBtb2RlIG1p Z2h0IGJlIGFjdGl2ZS4NCj4gPiArCSAqDQo+ID4gKwkgKiBJdCdzIGJldHRlciB0byBkbyBmdXJ0 aGVyIGNoZWNrIGlmIGVpdGhlciB0aHJvdWdoLUkvTy1BUElDDQo+ID4gKwkgKiBvciB0aHJvdWdo LWxvY2FsLUFQSUMgaXMgYWN0aXZlLg0KPiA+ICsJICogdGhlIHdvcnN0IGNhc2UgaXMgdGhhdCBi b3RoIG9mIHRoZW0gYXJlIGluYWN0aXZlLCBJZiBzbywNCj4gPiArCSAqIHdlIG5lZWQgdG8gZW5h YmxlIHRoZSB0aHJvdWdoLWxvY2FsLUFQSUMgdmlydHVhbCB3aXJlIG1vZGUNCj4gPiAgCSAqLw0K PiA+IC0JaWYgKHNtcF9mb3VuZF9jb25maWcgfHwgIWJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9B UElDKSkNCj4gPiArCWlmIChwaWNfbW9kZSB8fCAhYm9vdF9jcHVfaGFzKFg4Nl9GRUFUVVJFX0FQ SUMpIHx8DQo+ID4gKwkgICAgKHNtcF9mb3VuZF9jb25maWcgJiYgY2hlY2tfdmlydF93aXJlX21v ZGUoKSkpDQo+ID4gIAkJcmV0dXJuOw0KPiA+ICANCj4gPiAgCS8qDQo+ID4gZGlmZiAtLWdpdCBh L2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMuYyBiL2FyY2gveDg2L2tlcm5lbC9hcGljL2lv X2FwaWMuYw0KPiA+IGluZGV4IDQ0NjcwMmVkOTlkYy4uZjc5NGQzODliYTg1IDEwMDY0NA0KPiA+ IC0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGljL2lvX2FwaWMuYw0KPiA+ICsrKyBiL2FyY2gveDg2 L2tlcm5lbC9hcGljL2lvX2FwaWMuYw0KPiA+IEBAIC0xMzc5LDYgKzEzNzksMzQgQEAgdm9pZCBf X2luaXQgcHJpbnRfSU9fQVBJQ3Modm9pZCkNCj4gPiAgLyogV2hlcmUgaWYgYW55d2hlcmUgaXMg dGhlIGk4MjU5IGNvbm5lY3QgaW4gZXh0ZXJuYWwgaW50IG1vZGUgKi8NCj4gPiAgc3RhdGljIHN0 cnVjdCB7IGludCBwaW4sIGFwaWM7IH0gaW9hcGljX2k4MjU5ID0geyAtMSwgLTEgfTsNCj4gPiAg DQo+ID4gKy8qDQo+ID4gKyAqIFJldHVybiBmYWxzZSBtZWFucyB0aGUgdGhyb3VnaC1JL08tQVBJ QyB2aXJ0dWFsIHdpcmUgbW9kZSBpcyBpbmFjdGl2ZQ0KPiA+ICsgKi8NCj4gPiArYm9vbCB2aXJ0 X3dpcmVfdGhyb3VnaF9pb2FwaWModm9pZCkNCj4gPiArew0KPiA+ICsJaW50IGFwaWMsIHBpbjsN Cj4gPiArDQo+ID4gKwlmb3JfZWFjaF9pb2FwaWNfcGluKGFwaWMsIHBpbikgew0KPiA+ICsJCS8q IFNlZSBpZiBhbnkgb2YgdGhlIHBpbnMgaXMgaW4gRXh0SU5UIG1vZGUgKi8NCj4gPiArCQlzdHJ1 Y3QgSU9fQVBJQ19yb3V0ZV9lbnRyeSBlbnRyeSA9IGlvYXBpY19yZWFkX2VudHJ5KGFwaWMsIHBp bik7DQo+ID4gKw0KPiA+ICsJCS8qDQo+ID4gKwkJICogSWYgdGhlIGludGVycnVwdCBsaW5lIGlz IGVuYWJsZWQgYW5kIGluIEV4dEludCBtb2RlDQo+ID4gKwkJICogSSBoYXZlIGZvdW5kIHRoZSBw aW4gd2hlcmUgdGhlIGk4MjU5IGlzIGNvbm5lY3RlZC4NCj4gPiArCQkgKi8NCj4gPiArCQlpZiAo KGVudHJ5Lm1hc2sgPT0gMCkgJiYgKGVudHJ5LmRlbGl2ZXJ5X21vZGUgPT0gZGVzdF9FeHRJTlQp KQ0KPiA+ICsJCQlyZXR1cm4gdHJ1ZTsNCj4gPiArCX0NCj4gPiArDQo+ID4gKwkvKg0KPiA+ICsJ ICogVGhlIHRocm91Z2gtSS9PLUFQSUMgdmlydHVhbCB3aXJlIG1vZGUgcmVxdWVzdHMNCj4gPiAr CSAqIEkvTyBBUElDIHRvIGJlIGNvbm5lY3RlZCBpODI1OSBpbiBjaGFwdGVyIDMuNi4yLjIgb2Yg dGhlIE1QIHYxLjQgc3BlYw0KPiA+ICsJICogSWYgbm8gcGluIGluIEV4dEludCBtb2RlLCB0aGUg dGhyb3VnaC1JL08tQVBJQyB2aXJ0dWFsIHdpcmUgbW9kZSBjYW4NCj4gPiArCSAqIGJlIHJlZ2Fy ZGVkIGFzIGluYWN0aXZlDQo+ID4gKwkgKi8NCj4gPiArCXJldHVybiBmYWxzZTsNCj4gPiArfQ0K PiA+ICsNCj4gPiAgdm9pZCBfX2luaXQgZW5hYmxlX0lPX0FQSUModm9pZCkNCj4gPiAgew0KPiA+ ICAJaW50IGk4MjU5X2FwaWMsIGk4MjU5X3BpbjsNCj4gDQo+IA0KDQoKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmtleGVjIG1haWxpbmcgbGlzdAprZXhl Y0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4v bGlzdGluZm8va2V4ZWMK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754650AbcGZIFn (ORCPT ); Tue, 26 Jul 2016 04:05:43 -0400 Received: from cn.fujitsu.com ([59.151.112.132]:50484 "EHLO heian.cn.fujitsu.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1751333AbcGZIFc (ORCPT ); Tue, 26 Jul 2016 04:05:32 -0400 X-IronPort-AV: E=Sophos;i="5.22,518,1449504000"; d="scan'208";a="9098314" From: "Wei, Jiangang" To: "ebiederm@xmission.com" CC: "kexec@lists.infradead.org" , "linux-kernel@vger.kernel.org" , "Cao, Jin" , "tglx@linutronix.de" , "bhe@redhat.com" , "xpang@redhat.com" , "kernel@kyup.com" , "x86@kernel.org" , "hpa@zytor.com" , "mingo@redhat.com" , "joro@8bytes.org" Subject: Re: [PATCH v2 3/3] x86/apic: Improved the setting of interrupt mode for bsp Thread-Topic: [PATCH v2 3/3] x86/apic: Improved the setting of interrupt mode for bsp Thread-Index: AQHR5vFSd7PO51qC6E22kCcSEUyNI6Ap1BsA Date: Tue, 26 Jul 2016 08:05:20 +0000 Message-ID: <1469520148.7811.54.camel@localhost> References: <1469501995-2991-1-git-send-email-weijg.fnst@cn.fujitsu.com> <1469501995-2991-4-git-send-email-weijg.fnst@cn.fujitsu.com> <87k2g92gxb.fsf@x220.int.ebiederm.org> In-Reply-To: <87k2g92gxb.fsf@x220.int.ebiederm.org> Accept-Language: zh-CN, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.167.226.50] Content-Type: text/plain; charset="utf-8" Content-ID: MIME-Version: 1.0 X-yoursite-MailScanner-ID: 7C52642984CB.AB6EC X-yoursite-MailScanner: Found to be clean X-yoursite-MailScanner-From: weijg.fnst@cn.fujitsu.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 mail.home.local id u6Q85m11021056 Hi Eric, Thanks for your response. But I have some different ideas... On Mon, 2016-07-25 at 22:53 -0500, Eric W. Biederman wrote: > Wei Jiangang writes: > > > If we specify the 'notsc' parameter for the dump-capture kernel, > > and then trigger a crash(panic) by using "ALT-SysRq-c" or > > "echo c > /proc/sysrq-trigger", the dump-capture kernel will > > hang in calibrate_delay_converge() and wait for jiffies changes. > > serial log as follows: > > > > tsc: Fast TSC calibration using PIT > > tsc: Detected 2099.947 MHz processor > > Calibrating delay loop... > > > > The reason for jiffies not changes is there's no timer interrupt > > passed to dump-capture kernel. > > > > In fact, once kernel panic occurs, the local APIC is disabled > > by lapic_shutdown() in reboot path. > > generly speaking, local APIC state can be initialized by BIOS > > after Power-Up or Reset, which doesn't apply to kdump case. > > so the kernel has to be responsible for initialize the interrupt > > mode properly according the latest status of APIC in bootup path. > > > > An MP operating system is booted under either PIC mode or > > virtual wire mode. Later, the operating system switches to > > symmetric I/O mode as it enters multiprocessor mode. > > Two kinds of virtual wire mode are defined in Intel MP spec: > > virtual wire mode via local APIC or via I/O APIC. > > > > Now we determine the mode of APIC only through a SMP BIOS(MP table). > > That's not enough. It's better to do further check if APIC works > > with effective interrupt mode, and then, do some proper setting. > > Reading through the code let me pause a moment and say: > "Yowzers the interrupt initialization code has gotten hard to follow. It > is now full of indirection with ill defined semantics." pre_vector_init > indeed. > > I will argue this is the wrong fix. > > We really should not have to worry about getting the system functional > in virtual wire mode on a modern system. And looking at the code > someone has done half the work and made it conditional under > acpi_gbl_reduced_hardware. > > Now reduced hardware implies a bit more than we ware talking about but > if there is ACPI apic information we should not need to worry about > external interrupts and can just enable the apics. > > In fact I think having MPtable information is enough for that. In my opinion, The MP table is not to be trusted if system starts without BIOS phrase. The chapter 3.8 System Initial State (MP v1.4 spec) said below: "1. All local APICs are disabled, except for the local APIC of the BSP if the system starts in Virtual Wire Mode." And ..... "The BIOS must disable interrupts to all processors and set the APICs to the system initial state before giving control to the operating system. The operating system is responsible for initializing all of the APICs" The dump-capture kernel won't through the BIOS phrase, so there is no guarantee of the interrupt mode of APIC and the status of local APIC. Although the MP table is read-only, the dump-capture kernel uses the MP table which be generated before the first kernel boots up is unreasonable. At least, only checking MP table is not enough. That's the starting point of my patch. You said “this is the wrong fix”, Is there any wrong with the codes or my solution to check the status of APIC in bootup path? > So I think what needs to happens is for the apic initialization to get > an overhaul that makes apic initialization the happy path and the other > irq controllers the odd backwards compatibility path. And when we > are done we never run in anything except full apic mode unless the > hardware doesn't support it. The spec requests "An MP operating system is booted under either one of the two PC/AT-compatible modes. Later the operating system switches to Symmetric I/O Mode as it enters multiprocessor mode." And it seems that the latest kernel follows the rule. Does the apic initialization really need to be changed? Thanks, wei > > I think that will leave things more robust as we don't need to setup > and then reset up the interrupts during boot. > > Eric > > > > Signed-off-by: Cao jin > > Signed-off-by: Wei Jiangang > > --- > > arch/x86/include/asm/io_apic.h | 5 ++++ > > arch/x86/kernel/apic/apic.c | 60 +++++++++++++++++++++++++++++++++++++++++- > > arch/x86/kernel/apic/io_apic.c | 28 ++++++++++++++++++++ > > 3 files changed, 92 insertions(+), 1 deletion(-) > > > > diff --git a/arch/x86/include/asm/io_apic.h b/arch/x86/include/asm/io_apic.h > > index 6cbf2cfb3f8a..a3257366bf7f 100644 > > --- a/arch/x86/include/asm/io_apic.h > > +++ b/arch/x86/include/asm/io_apic.h > > @@ -190,6 +190,7 @@ static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg) > > } > > > > extern void setup_IO_APIC(void); > > +extern bool virt_wire_through_ioapic(void); > > extern void enable_IO_APIC(void); > > extern void disable_IO_APIC(void); > > extern void setup_ioapic_dest(void); > > @@ -231,6 +232,10 @@ static inline void io_apic_init_mappings(void) { } > > #define native_disable_io_apic NULL > > > > static inline void setup_IO_APIC(void) { } > > +static inline bool virt_wire_through_ioapic(void) > > +{ > > + return false; > > +} > > static inline void enable_IO_APIC(void) { } > > static inline void setup_ioapic_dest(void) { } > > > > diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c > > index 8e25b9b2d351..a3939fb130cc 100644 > > --- a/arch/x86/kernel/apic/apic.c > > +++ b/arch/x86/kernel/apic/apic.c > > @@ -1124,6 +1124,58 @@ void __init sync_Arb_IDs(void) > > } > > > > /* > > + * Check APIC enable/disable flag > > + */ > > +static bool check_apic_enabled(void) > > +{ > > + unsigned int value; > > + > > + /* > > + * If APIC is disabled globally (IA32_APIC_BASE[11] == 0) > > + * the boot cpu hasn't X86_FEATURE_APIC, > > + * and init_bsp_APIC() has already checked it before. > > + * so no need to check global enable/disable flag here > > + */ > > + > > + /* Check the software enable/disable flag */ > > + value = apic_read(APIC_SPIV); > > + if (!(value & APIC_SPIV_APIC_ENABLED)) > > + return false; > > + > > + return true; > > +} > > + > > +/* > > + * Return false means the through-local-APIC virtual wire mode is inactive > > + */ > > +static bool virt_wire_through_lapic(void) > > +{ > > + unsigned int value; > > + > > + /* > > + * The through-local-APIC virtual wire mode requests > > + * local APIC to enable LINT0 for ExtINT delivery mode > > + * and LINT1 for NMI delivery mode > > + */ > > + value = apic_read(APIC_LVT0); > > + if (GET_APIC_DELIVERY_MODE(value) != APIC_MODE_EXTINT) > > + return false; > > + > > + value = apic_read(APIC_LVT1); > > + if (GET_APIC_DELIVERY_MODE(value) != APIC_MODE_NMI) > > + return false; > > + > > + return true; > > +} > > + > > +static bool check_virt_wire_mode(void) > > +{ > > + /* If neither of virtual wire mode is active, return false */ > > + return (check_apic_enabled() && (virt_wire_through_lapic() || > > + virt_wire_through_ioapic())); > > +} > > + > > +/* > > * An initial setup of the virtual wire mode. > > */ > > void __init init_bsp_APIC(void) > > @@ -1133,8 +1185,14 @@ void __init init_bsp_APIC(void) > > /* > > * Don't do the setup now if we have a SMP BIOS as the > > * through-I/O-APIC virtual wire mode might be active. > > + * > > + * It's better to do further check if either through-I/O-APIC > > + * or through-local-APIC is active. > > + * the worst case is that both of them are inactive, If so, > > + * we need to enable the through-local-APIC virtual wire mode > > */ > > - if (smp_found_config || !boot_cpu_has(X86_FEATURE_APIC)) > > + if (pic_mode || !boot_cpu_has(X86_FEATURE_APIC) || > > + (smp_found_config && check_virt_wire_mode())) > > return; > > > > /* > > diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c > > index 446702ed99dc..f794d389ba85 100644 > > --- a/arch/x86/kernel/apic/io_apic.c > > +++ b/arch/x86/kernel/apic/io_apic.c > > @@ -1379,6 +1379,34 @@ void __init print_IO_APICs(void) > > /* Where if anywhere is the i8259 connect in external int mode */ > > static struct { int pin, apic; } ioapic_i8259 = { -1, -1 }; > > > > +/* > > + * Return false means the through-I/O-APIC virtual wire mode is inactive > > + */ > > +bool virt_wire_through_ioapic(void) > > +{ > > + int apic, pin; > > + > > + for_each_ioapic_pin(apic, pin) { > > + /* See if any of the pins is in ExtINT mode */ > > + struct IO_APIC_route_entry entry = ioapic_read_entry(apic, pin); > > + > > + /* > > + * If the interrupt line is enabled and in ExtInt mode > > + * I have found the pin where the i8259 is connected. > > + */ > > + if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) > > + return true; > > + } > > + > > + /* > > + * The through-I/O-APIC virtual wire mode requests > > + * I/O APIC to be connected i8259 in chapter 3.6.2.2 of the MP v1.4 spec > > + * If no pin in ExtInt mode, the through-I/O-APIC virtual wire mode can > > + * be regarded as inactive > > + */ > > + return false; > > +} > > + > > void __init enable_IO_APIC(void) > > { > > int i8259_apic, i8259_pin; > >