From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from [222.73.24.84] (helo=song.cn.fujitsu.com) by merlin.infradead.org with esmtp (Exim 4.76 #1 (Red Hat Linux)) id 1Sjo44-0006Hc-0g for kexec@lists.infradead.org; Wed, 27 Jun 2012 08:57:33 +0000 Message-ID: <4FEACA37.5060905@cn.fujitsu.com> Date: Wed, 27 Jun 2012 16:54:15 +0800 From: Yanfei Zhang MIME-Version: 1.0 Subject: [PATCH v3 3/5] KVM-INTEL: Add new module vmcsinfo-intel to fill VMCSINFO References: <4FEAC945.50700@cn.fujitsu.com> In-Reply-To: <4FEAC945.50700@cn.fujitsu.com> 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-bounces@lists.infradead.org Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org To: Avi Kivity , mtosatti@redhat.com Cc: dzickus@redhat.com, luto@mit.edu, kvm@vger.kernel.org, Joerg Roedel , kexec@lists.infradead.org, linux-kernel@vger.kernel.org, paul.gortmaker@windriver.com, ludwig.nussel@suse.de, ebiederm@xmission.com, Greg KH VGhpcyBwYXRjaCBpbXBsZW1lbnRzIGEgbmV3IG1vZHVsZSBuYW1lZCB2bWNzaW5mby1pbnRlbC4g VGhlCm1vZHVsZSBmaWxscyBWTUNTSU5GTyB3aXRoIHRoZSBWTUNTIHJldmlzaW9uIGlkZW50aWZp ZXIsCmFuZCBvZmZzZXRzIG9mIFZNQ1MgZmllbGRzLgoKTm90ZSwgb2Zmc2V0cyBvZiBmaWVsZHMg YmVsb3cgd2lsbCBub3QgYmUgZmlsbGVkIGludG8gVk1DU0lORk86CjEuIGZpZWxkcyBkZWZpbmVk IGluIEludGVsIHNwZWNpZmljYXRpb24gKEludGVswq4gNjQgYW5kCiAgIElBLTMyIEFyY2hpdGVj dHVyZXMgU29mdHdhcmUgRGV2ZWxvcGVy4oCZcyBNYW51YWwsIFZvbHVtZQogICAzQykgYnV0IG5v dCBkZWZpbmVkIGluICp2bWNzX2ZpZWxkKi4KMi4gZmllbGRzIHVuc3VwcG9ydGVkLgoKU2lnbmVk LW9mZi1ieTogemhhbmd5YW5mZWkgPHpoYW5neWFuZmVpQGNuLmZ1aml0c3UuY29tPgotLS0KIGFy Y2gveDg2L2t2bS9LY29uZmlnICAgIHwgICAxMSArKysKIGFyY2gveDg2L2t2bS9NYWtlZmlsZSAg IHwgICAgMyArCiBhcmNoL3g4Ni9rdm0vdm1jc2luZm8uYyB8ICAxOTggKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgMjEyIGlu c2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC94ODYv a3ZtL3ZtY3NpbmZvLmMKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rdm0vS2NvbmZpZyBiL2FyY2gv eDg2L2t2bS9LY29uZmlnCmluZGV4IGEyOGYzMzguLjFkZDY0YjEgMTAwNjQ0Ci0tLSBhL2FyY2gv eDg2L2t2bS9LY29uZmlnCisrKyBiL2FyY2gveDg2L2t2bS9LY29uZmlnCkBAIC02Myw2ICs2Mywx NyBAQCBjb25maWcgS1ZNX0lOVEVMCiAJICBUbyBjb21waWxlIHRoaXMgYXMgYSBtb2R1bGUsIGNo b29zZSBNIGhlcmU6IHRoZSBtb2R1bGUKIAkgIHdpbGwgYmUgY2FsbGVkIGt2bS1pbnRlbC4KIAor Y29uZmlnIFZNQ1NJTkZPX0lOVEVMCisJdHJpc3RhdGUgIkV4cG9ydCBWTUNTSU5GTyBmb3IgSW50 ZWwgcHJvY2Vzc29ycyIKKwlkZXBlbmRzIG9uIEtWTV9JTlRFTAorCS0tLWhlbHAtLS0KKwkgIFBy b3ZpZGVzIHN1cHBvcnQgZm9yIGV4cG9ydGluZyBWTUNTSU5GTyBvbiBJbnRlbCBwcm9jZXNzb3Jz IGVxdWlwcGVkCisJICB3aXRoIHRoZSBWVCBleHRlbnNpb25zLiBUaGUgVk1DU0lORk8gY29udGFp bnMgYSBWTUNTIHJldmlzaW9uCisJICBpZGVudGlmaWVyIGFuZCBvZmZzZXRzIG9mIFZNQ1MgZmll bGRzLgorCisJICBUbyBjb21waWxlIHRoaXMgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRo ZSBtb2R1bGUKKwkgIHdpbGwgYmUgY2FsbGVkIHZtY3NpbmZvLWludGVsLgorCiBjb25maWcgS1ZN X0FNRAogCXRyaXN0YXRlICJLVk0gZm9yIEFNRCBwcm9jZXNzb3JzIHN1cHBvcnQiCiAJZGVwZW5k cyBvbiBLVk0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2t2bS9NYWtlZmlsZSBiL2FyY2gveDg2L2t2 bS9NYWtlZmlsZQppbmRleCA0ZjU3OWU4Li4xMmExZWY2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9r dm0vTWFrZWZpbGUKKysrIGIvYXJjaC94ODYva3ZtL01ha2VmaWxlCkBAIC00LDYgKzQsNyBAQCBj Y2ZsYWdzLXkgKz0gLUl2aXJ0L2t2bSAtSWFyY2gveDg2L2t2bQogQ0ZMQUdTX3g4Ni5vIDo9IC1J LgogQ0ZMQUdTX3N2bS5vIDo9IC1JLgogQ0ZMQUdTX3ZteC5vIDo9IC1JLgorQ0ZMQUdTX3ZtY3Np bmZvLm8gOj0gLUkuCiAKIGt2bS15CQkJKz0gJChhZGRwcmVmaXggLi4vLi4vLi4vdmlydC9rdm0v LCBrdm1fbWFpbi5vIGlvYXBpYy5vIFwKIAkJCQljb2FsZXNjZWRfbW1pby5vIGlycV9jb21tLm8g ZXZlbnRmZC5vIFwKQEAgLTE1LDcgKzE2LDkgQEAga3ZtLXkJCQkrPSB4ODYubyBtbXUubyBlbXVs YXRlLm8gaTgyNTkubyBpcnEubyBsYXBpYy5vIFwKIAkJCSAgIGk4MjU0Lm8gdGltZXIubyBjcHVp ZC5vIHBtdS5vCiBrdm0taW50ZWwteQkJKz0gdm14Lm8KIGt2bS1hbWQteQkJKz0gc3ZtLm8KK3Zt Y3NpbmZvLWludGVsLXkJKz0gdm1jc2luZm8ubwogCiBvYmotJChDT05GSUdfS1ZNKQkrPSBrdm0u bwogb2JqLSQoQ09ORklHX0tWTV9JTlRFTCkJKz0ga3ZtLWludGVsLm8KIG9iai0kKENPTkZJR19L Vk1fQU1EKQkrPSBrdm0tYW1kLm8KK29iai0kKENPTkZJR19WTUNTSU5GT19JTlRFTCkJKz0gdm1j c2luZm8taW50ZWwubwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva3ZtL3ZtY3NpbmZvLmMgYi9hcmNo L3g4Ni9rdm0vdm1jc2luZm8uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43 YjE4NzNjCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC94ODYva3ZtL3ZtY3NpbmZvLmMKQEAgLTAs MCArMSwxOTggQEAKKy8qCisgKiBLZXJuZWwtYmFzZWQgVmlydHVhbCBNYWNoaW5lIGRyaXZlciBm b3IgTGludXgKKyAqCisgKiBUaGlzIG1vZHVsZSBlbmFibGVzIG1hY2hpbmVzIHdpdGggSW50ZWwg VlQteCBleHRlbnNpb25zIHRvIGV4cG9ydAorICogb2Zmc2V0cyBvZiBWTUNTIGZpZWxkcyBmb3Ig Z3Vlc3QgZGVidWdnaW5nLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBGdWppdHN1LCBJbmMu CisgKgorICogQXV0aG9yczoKKyAqICAgWmhhbmcgWWFuZmVpIDx6aGFuZ3lhbmZlaUBjbi5mdWpp dHN1LmNvbT4KKyAqCisgKiBUaGlzIHdvcmsgaXMgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR1BMLCB2ZXJzaW9uIDIuICBTZWUKKyAqIHRoZSBDT1BZSU5HIGZpbGUgaW4gdGhl IHRvcC1sZXZlbCBkaXJlY3RvcnkuCisgKgorICovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUu aD4KKyNpbmNsdWRlIDxsaW51eC9tb2RfZGV2aWNldGFibGUuaD4KKyNpbmNsdWRlIDxsaW51eC9z d2FiLmg+CisKKyNpbmNsdWRlIDxhc20vdm14Lmg+CisjaW5jbHVkZSA8YXNtL3ZtY3NpbmZvLmg+ CisKK01PRFVMRV9BVVRIT1IoIkZ1aml0c3UiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKKwor c3RhdGljIGNvbnN0IHN0cnVjdCB4ODZfY3B1X2lkIHZtY3NpbmZvX2NwdV9pZFtdID0geworCVg4 Nl9GRUFUVVJFX01BVENIKFg4Nl9GRUFUVVJFX1ZNWCksCisJe30KK307CitNT0RVTEVfREVWSUNF X1RBQkxFKHg4NmNwdSwgdm1jc2luZm9fY3B1X2lkKTsKKworLyoKKyAqIEZvciBjYWN1bGF0aW5n IG9mZnNldHMgb2YgZmllbGRzIGluIFZNQ1MgZGF0YSwgd2UgaW5kZXggZXZlcnkgMTYtYml0Cisg KiBmaWVsZCBieSB0aGlzIGtpbmQgb2YgZm9ybWF0OgorICogICAgICAgICB8IC0tLS0tLS0tLSAx NiBiaXRzIC0tLS0tLS0tLS0gfAorICogICAgICAgICArLS0tLS0tLS0tLS0tLSstKy0tLS0tLS0t LS0tLSstKworICogICAgICAgICB8IGhpZ2ggNyBiaXRzIHwxfCBsb3cgNyBiaXRzIHwwfAorICog ICAgICAgICArLS0tLS0tLS0tLS0tLSstKy0tLS0tLS0tLS0tLSstKworICogSW4gaGlnaCBieXRl LCB0aGUgbG93ZXN0IGJpdCBtdXN0IGJlIDE7IEluIGxvdyBieXRlLCB0aGUgbG93ZXN0IGJpdAor ICogbXVzdCBiZSAwLiBUaGUgdHdvIGJpdHMgYXJlIHNldCBsaWtlIHRoaXMgaW4gY2FzZSBpbmRl eGVzIGluIFZNQ1MKKyAqIGRhdGEgYXJlIHJlYWQgYXMgYmlnIGVuZGlhbiBtb2RlLgorICogVGhl IHJlbWFpbmluZyAxNCBiaXRzIG9mIHRoZSBpbmRleCBpbmRpY2F0ZSB0aGUgcmVhbCBvZmZzZXQg b2YgdGhlCisgKiBmaWVsZC4gQmVjYXVzZSB0aGUgc2l6ZSBvZiBhIFZNQ1MgcmVnaW9uIGlzIGF0 IG1vc3QgNCBLQnl0ZXMsIHNvCisgKiAxNCBiaXRzIGFyZSBlbm91Z2ggdG8gaW5kZXggdGhlIHdo b2xlIFZNQ1MgcmVnaW9uLgorICoKKyAqIEVOQ09ESU5HX09GRlNFVDogZW5jb2RlIHRoZSBvZmZz ZXQgaW50byB0aGUgaW5kZXggb2YgdGhpcyBraW5kLgorICogREVDT0RJTkdfT0ZGU0VUOiBkZWNv ZGUgdGhlIGluZGV4IG9mIHRoaXMga2luZCBpbnRvIHJlYWwgb2Zmc2V0LgorICovCisjZGVmaW5l IE9GRlNFVF9ISUdIX1NISUZUICg3KQorI2RlZmluZSBPRkZTRVRfTE9XX01BU0sgICAoKDEgPDwg T0ZGU0VUX0hJR0hfU0hJRlQpIC0gMSkgLyogMHg3ZiAqLworI2RlZmluZSBPRkZTRVRfSElHSF9N QVNLICAoT0ZGU0VUX0xPV19NQVNLIDw8IE9GRlNFVF9ISUdIX1NISUZUKSAvKiAweDNmODAgKi8K KyNkZWZpbmUgRU5DT0RJTkdfT0ZGU0VUKG9mZnNldCkgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgXAorCSgoKChvZmZzZXQpICYgT0ZGU0VUX0xPV19NQVNLKSA8PCAxKSArICAg ICAgICAgICAgICAgICAgICAgIFwKKwkoKCgob2Zmc2V0KSAmIE9GRlNFVF9ISUdIX01BU0spIDw8 IDIpIHwgMHgxMDApKQorLyoKKyAqIGluZGV4IGhlcmUgc2hvdWxkIGJlIGFsd2F5cyByZWFkIGlu IGxpdHRsZSBlbmRpYW4gbW9kZS4KKyAqLworI2RlZmluZSBERUNPRElOR19PRkZTRVRfTEUoaW5k ZXgpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJKCgoKGluZGV4KSA+PiAx KSAmIE9GRlNFVF9MT1dfTUFTSykgKyAgICAgICAgICAgICAgICAgICAgICAgXAorCSgoKGluZGV4 KSA+PiAyKSAmIE9GRlNFVF9ISUdIX01BU0spKQorLyoKKyAqIG4gaW5kaWNhdGVzIHRoZSBiaXRz IG9mIGluZGV4LiBXZSBmaXJzdCBjaGVjayBpZiBpbmRleAorICogaXMgcmVhZCBpbiBiaWcgZW5k aWFuIG1vZGUuCisgKi8KKyNkZWZpbmUgREVDT0RJTkdfT0ZGU0VUKGluZGV4LCBuKSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorCSgoaW5kZXggJiAxKSA/IChERUNPRElOR19P RkZTRVRfTEUoX19zd2FiIyNuKGluZGV4KSkpIDogICAgIFwKKwkoREVDT0RJTkdfT0ZGU0VUX0xF KGluZGV4KSkpCisKKyNkZWZpbmUgRklFTERfT0ZGU0VUMTYoZmllbGQsIG9mZnNldCkgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXAorCXZtY3NpbmZvX2ZpZWxkKGZpZWxkLCBERUNPRElO R19PRkZTRVQob2Zmc2V0LCAxNikpCisjZGVmaW5lIEZJRUxEX09GRlNFVDY0KGZpZWxkLCBvZmZz ZXQpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKwl2bWNzaW5mb19maWVsZChmaWVs ZCwgREVDT0RJTkdfT0ZGU0VUKG9mZnNldCwgNjQpKQorI2RlZmluZSBGSUVMRF9PRkZTRVQzMihm aWVsZCwgb2Zmc2V0KSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJdm1jc2luZm9f ZmllbGQoZmllbGQsIERFQ09ESU5HX09GRlNFVChvZmZzZXQsIDMyKSkKKyNkZWZpbmUgRklFTERf T0ZGU0VUTlcoZmllbGQsIG9mZnNldCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAor ZG8geyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisJaWYgKHNpemVvZihvZmZzZXQpID09IDgpICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAorCQl2bWNzaW5mb19maWVsZChmaWVsZCwgREVDT0RJTkdfT0ZG U0VUKG9mZnNldCwgNjQpKTsgXAorCWVsc2UgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFwKKwkJdm1jc2luZm9fZmllbGQoZmllbGQsIERFQ09E SU5HX09GRlNFVChvZmZzZXQsIDMyKSk7IFwKK30gd2hpbGUgKDApCisKKyNkZWZpbmUgVk1DU19G SUVMRF9DSEVDSyhmaWVsZCwgb2Zmc2V0LCB0eXBlKSAgICAgICAgICAgICAgICAgICAgICAgXAor ZG8geyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCisJaWYgKHZtY3NfcmVhZDMyKFZNX0lOU1RSVUNUSU9OX0VSUk9SKSAhPSAg ICAgICAgICAgICAgICAgICAgXAorCQlWTVhFUlJfVU5TVVBQT1JURURfVk1DU19DT01QT05FTlQp ICAgICAgICAgICAgICAgICAgXAorCQlGSUVMRF9PRkZTRVQjI3R5cGUoZmllbGQsIG9mZnNldCk7 ICAgICAgICAgICAgICAgICAgXAorfSB3aGlsZSAoMCkKKworc3RhdGljIGlubGluZSB2b2lkIHZt Y3NfcmVhZF9jaGVja2luZyh1bnNpZ25lZCBsb25nIGZpZWxkKQoreworCXUxNiBvZmZzZXQxNjsK Kwl1NjQgb2Zmc2V0NjQ7CisJdTMyIG9mZnNldDMyOworCXVuc2lnbmVkIGxvbmcgb2Zmc2V0bnc7 CisKKwlzd2l0Y2ggKHZtY3NfZmllbGRfdHlwZShmaWVsZCkpIHsKKwljYXNlIFZNQ1NfRklFTERf VFlQRV9VMTY6CisJCW9mZnNldDE2ID0gdm1jc19yZWFkMTYoZmllbGQpOworCQlWTUNTX0ZJRUxE X0NIRUNLKGZpZWxkLCBvZmZzZXQxNiwgMTYpOworCQlicmVhazsKKwljYXNlIFZNQ1NfRklFTERf VFlQRV9VNjQ6CisJCW9mZnNldDY0ID0gdm1jc19yZWFkNjQoZmllbGQpOworCQlWTUNTX0ZJRUxE X0NIRUNLKGZpZWxkLCBvZmZzZXQ2NCwgNjQpOworCQlicmVhazsKKwljYXNlIFZNQ1NfRklFTERf VFlQRV9VMzI6CisJCW9mZnNldDMyID0gdm1jc19yZWFkMzIoZmllbGQpOworCQlWTUNTX0ZJRUxE X0NIRUNLKGZpZWxkLCBvZmZzZXQzMiwgMzIpOworCQlicmVhazsKKwljYXNlIFZNQ1NfRklFTERf VFlQRV9OQVRVUkFMX1dJRFRIOgorCQlvZmZzZXRudyA9IHZtY3NfcmVhZGwoZmllbGQpOworCQlW TUNTX0ZJRUxEX0NIRUNLKGZpZWxkLCBvZmZzZXRudywgTlcpOworCQlicmVhazsKKwl9Cit9CisK Ky8qCisgKiBOb3RlLCBvZmZzZXRzIG9mIGZpZWxkcyBiZWxvdyB3aWxsIG5vdCBiZSBmaWxsZWQg aW50bworICogVk1DU0lORk86CisgKiAxLiBmaWVsZHMgZGVmaW5lZCBpbiBJbnRlbCBzcGVjaWZp Y2F0aW9uIChJbnRlbMKuIDY0IGFuZAorICogICAgSUEtMzIgQXJjaGl0ZWN0dXJlcyBTb2Z0d2Fy ZSBEZXZlbG9wZXLigJlzIE1hbnVhbCwgVm9sdW1lCisgKiAgICAzQykgYnV0IG5vdCBkZWZpbmVk IGluICp2bWNzX2ZpZWxkKi4KKyAqIDIuIGZpZWxkcyB1bnN1cHBvcnRlZC4KKyAqLworc3RhdGlj IGludCBfX2luaXQgYWxsb2Nfdm1jc2luZm9faW5pdCh2b2lkKQoreworLyoKKyAqIFRoZSBmaXJz dCA4IGJ5dGVzIGluIHZtY3MgcmVnaW9uIGFyZSBmb3IKKyAqICAgVk1DUyByZXZpc2lvbiBpZGVu dGlmaWVyCisgKiAgIFZNWC1hYm9ydCBpbmRpY2F0b3IKKyAqLworI2RlZmluZSBGSUVMRF9TVEFS VCAoOCkKKworCWludCByLCBvZmZzZXQ7CisJc3RydWN0IHZtY3MgKnZtY3M7CisJaW50IGNwdTsK Kwl1bnNpZ25lZCBsb25nIGZpZWxkOworCisJaWYgKHZtY3NpbmZvX2lzX2ZpbGxlZCgpKQorCQly ZXR1cm4gMDsKKworCXZtY3MgPSBhbGxvY192bWNzKCk7CisJaWYgKCF2bWNzKSB7CisJCXJldHVy biAtRU5PTUVNOworCX0KKworCXIgPSBoYXJkd2FyZV9lbmFibGVfYWxsKCk7CisJaWYgKHIpCisJ CWdvdG8gb3V0X2VycjsKKworCS8qCisJICogV3JpdGUgZW5jb2RlZCBvZmZzZXRzIGludG8gVk1D UyBkYXRhIGZvciBsYXRlciB2bWNzX3JlYWQuCisJICovCisJZm9yIChvZmZzZXQgPSBGSUVMRF9T VEFSVDsgb2Zmc2V0IDwgdm1jc19jb25maWcuc2l6ZTsKKwkgICAgIG9mZnNldCArPSBzaXplb2Yo dTE2KSkKKwkJKih1MTYgKikoKGNoYXIgKil2bWNzICsgb2Zmc2V0KSA9IEVOQ09ESU5HX09GRlNF VChvZmZzZXQpOworCisJY3B1ID0gZ2V0X2NwdSgpOworCXZtY3NfY2xlYXIodm1jcyk7CisJcGVy X2NwdShjdXJyZW50X3ZtY3MsIGNwdSkgPSB2bWNzOworCXZtY3NfbG9hZCh2bWNzKTsKKworCXZt Y3NpbmZvX3JldmlzaW9uX2lkKHZtY3MtPnJldmlzaW9uX2lkKTsKKwl2bWNzX3JlYWRfY2hlY2tp bmcoVk1fSU5TVFJVQ1RJT05fRVJST1IpOworCW9mZnNldCA9IGdldF92bWNzX2ZpZWxkX29mZnNl dChWTV9JTlNUUlVDVElPTl9FUlJPUik7CisJaWYgKG9mZnNldCA9PSAtMSkKKwkJZ290byBvdXRf Y2xlYXI7CisKKwlmb3IgKGZpZWxkID0gMDsgZmllbGQgPCBWTUNTSU5GT19NQVhfRklFTEQ7ICsr ZmllbGQpIHsKKwkJaWYgKGZpZWxkID09IFZNX0lOU1RSVUNUSU9OX0VSUk9SKQorCQkJY29udGlu dWU7CisJCS8qCisJCSAqIEJlZm9yZSBlYWNoIHJlYWRpbmcsIHplcm9lZCBmaWVsZCBWTV9JTlNU UlVDVElPTl9FUlJPUgorCQkgKi8KKwkJKih1MzIgKikoKGNoYXIgKil2bWNzICsgb2Zmc2V0KSA9 IDA7CisJCXZtY3NfcmVhZF9jaGVja2luZyhmaWVsZCk7CisJfQorCXZtY3NpbmZvX2ZpbGxlZCgp OworCisJdXBkYXRlX3ZtY3NpbmZvX25vdGUoKTsKKworb3V0X2NsZWFyOgorCXZtY3NfY2xlYXIo dm1jcyk7CisJcHV0X2NwdSgpOworCitvdXRfZXJyOgorCWZyZWVfdm1jcyh2bWNzKTsKKwlyZXR1 cm4gcjsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGFsbG9jX3ZtY3NpbmZvX2V4aXQodm9pZCkK K3sKKwloYXJkd2FyZV9kaXNhYmxlX2FsbCgpOworfQorCittb2R1bGVfaW5pdChhbGxvY192bWNz aW5mb19pbml0KTsKK21vZHVsZV9leGl0KGFsbG9jX3ZtY3NpbmZvX2V4aXQpOwotLSAKMS43LjEK CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwprZXhlYyBt YWlsaW5nIGxpc3QKa2V4ZWNAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2tleGVjCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: Yanfei Zhang Subject: [PATCH v3 3/5] KVM-INTEL: Add new module vmcsinfo-intel to fill VMCSINFO Date: Wed, 27 Jun 2012 16:54:15 +0800 Message-ID: <4FEACA37.5060905@cn.fujitsu.com> References: <4FEAC945.50700@cn.fujitsu.com> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: QUOTED-PRINTABLE Cc: ebiederm@xmission.com, luto@mit.edu, Joerg Roedel , dzickus@redhat.com, paul.gortmaker@windriver.com, ludwig.nussel@suse.de, linux-kernel@vger.kernel.org, kvm@vger.kernel.org, kexec@lists.infradead.org, Greg KH To: Avi Kivity , mtosatti@redhat.com Return-path: In-Reply-To: <4FEAC945.50700@cn.fujitsu.com> Sender: linux-kernel-owner@vger.kernel.org List-Id: kvm.vger.kernel.org This patch implements a new module named vmcsinfo-intel. The module fills VMCSINFO with the VMCS revision identifier, and offsets of VMCS fields. Note, offsets of fields below will not be filled into VMCSINFO: 1. fields defined in Intel specification (Intel=C2=AE 64 and IA-32 Architectures Software Developer=E2=80=99s Manual, Volume 3C) but not defined in *vmcs_field*. 2. fields unsupported. Signed-off-by: zhangyanfei --- arch/x86/kvm/Kconfig | 11 +++ arch/x86/kvm/Makefile | 3 + arch/x86/kvm/vmcsinfo.c | 198 +++++++++++++++++++++++++++++++++++++++= ++++++++ 3 files changed, 212 insertions(+), 0 deletions(-) create mode 100644 arch/x86/kvm/vmcsinfo.c diff --git a/arch/x86/kvm/Kconfig b/arch/x86/kvm/Kconfig index a28f338..1dd64b1 100644 --- a/arch/x86/kvm/Kconfig +++ b/arch/x86/kvm/Kconfig @@ -63,6 +63,17 @@ config KVM_INTEL To compile this as a module, choose M here: the module will be called kvm-intel. =20 +config VMCSINFO_INTEL + tristate "Export VMCSINFO for Intel processors" + depends on KVM_INTEL + ---help--- + Provides support for exporting VMCSINFO on Intel processors equippe= d + with the VT extensions. The VMCSINFO contains a VMCS revision + identifier and offsets of VMCS fields. + + To compile this as a module, choose M here: the module + will be called vmcsinfo-intel. + config KVM_AMD tristate "KVM for AMD processors support" depends on KVM diff --git a/arch/x86/kvm/Makefile b/arch/x86/kvm/Makefile index 4f579e8..12a1ef6 100644 --- a/arch/x86/kvm/Makefile +++ b/arch/x86/kvm/Makefile @@ -4,6 +4,7 @@ ccflags-y +=3D -Ivirt/kvm -Iarch/x86/kvm CFLAGS_x86.o :=3D -I. CFLAGS_svm.o :=3D -I. CFLAGS_vmx.o :=3D -I. +CFLAGS_vmcsinfo.o :=3D -I. =20 kvm-y +=3D $(addprefix ../../../virt/kvm/, kvm_main.o ioapic.o \ coalesced_mmio.o irq_comm.o eventfd.o \ @@ -15,7 +16,9 @@ kvm-y +=3D x86.o mmu.o emulate.o i8259.o irq.o lapi= c.o \ i8254.o timer.o cpuid.o pmu.o kvm-intel-y +=3D vmx.o kvm-amd-y +=3D svm.o +vmcsinfo-intel-y +=3D vmcsinfo.o =20 obj-$(CONFIG_KVM) +=3D kvm.o obj-$(CONFIG_KVM_INTEL) +=3D kvm-intel.o obj-$(CONFIG_KVM_AMD) +=3D kvm-amd.o +obj-$(CONFIG_VMCSINFO_INTEL) +=3D vmcsinfo-intel.o diff --git a/arch/x86/kvm/vmcsinfo.c b/arch/x86/kvm/vmcsinfo.c new file mode 100644 index 0000000..7b1873c --- /dev/null +++ b/arch/x86/kvm/vmcsinfo.c @@ -0,0 +1,198 @@ +/* + * Kernel-based Virtual Machine driver for Linux + * + * This module enables machines with Intel VT-x extensions to export + * offsets of VMCS fields for guest debugging. + * + * Copyright (C) 2012 Fujitsu, Inc. + * + * Authors: + * Zhang Yanfei + * + * This work is licensed under the terms of the GNU GPL, version 2. S= ee + * the COPYING file in the top-level directory. + * + */ + +#include +#include +#include + +#include +#include + +MODULE_AUTHOR("Fujitsu"); +MODULE_LICENSE("GPL"); + +static const struct x86_cpu_id vmcsinfo_cpu_id[] =3D { + X86_FEATURE_MATCH(X86_FEATURE_VMX), + {} +}; +MODULE_DEVICE_TABLE(x86cpu, vmcsinfo_cpu_id); + +/* + * For caculating offsets of fields in VMCS data, we index every 16-bi= t + * field by this kind of format: + * | --------- 16 bits ---------- | + * +-------------+-+------------+-+ + * | high 7 bits |1| low 7 bits |0| + * +-------------+-+------------+-+ + * In high byte, the lowest bit must be 1; In low byte, the lowest bit + * must be 0. The two bits are set like this in case indexes in VMCS + * data are read as big endian mode. + * The remaining 14 bits of the index indicate the real offset of the + * field. Because the size of a VMCS region is at most 4 KBytes, so + * 14 bits are enough to index the whole VMCS region. + * + * ENCODING_OFFSET: encode the offset into the index of this kind. + * DECODING_OFFSET: decode the index of this kind into real offset. + */ +#define OFFSET_HIGH_SHIFT (7) +#define OFFSET_LOW_MASK ((1 << OFFSET_HIGH_SHIFT) - 1) /* 0x7f */ +#define OFFSET_HIGH_MASK (OFFSET_LOW_MASK << OFFSET_HIGH_SHIFT) /* 0x= 3f80 */ +#define ENCODING_OFFSET(offset) \ + ((((offset) & OFFSET_LOW_MASK) << 1) + \ + ((((offset) & OFFSET_HIGH_MASK) << 2) | 0x100)) +/* + * index here should be always read in little endian mode. + */ +#define DECODING_OFFSET_LE(index) \ + ((((index) >> 1) & OFFSET_LOW_MASK) + \ + (((index) >> 2) & OFFSET_HIGH_MASK)) +/* + * n indicates the bits of index. We first check if index + * is read in big endian mode. + */ +#define DECODING_OFFSET(index, n) \ + ((index & 1) ? (DECODING_OFFSET_LE(__swab##n(index))) : \ + (DECODING_OFFSET_LE(index))) + +#define FIELD_OFFSET16(field, offset) \ + vmcsinfo_field(field, DECODING_OFFSET(offset, 16)) +#define FIELD_OFFSET64(field, offset) \ + vmcsinfo_field(field, DECODING_OFFSET(offset, 64)) +#define FIELD_OFFSET32(field, offset) \ + vmcsinfo_field(field, DECODING_OFFSET(offset, 32)) +#define FIELD_OFFSETNW(field, offset) \ +do { \ + if (sizeof(offset) =3D=3D 8) \ + vmcsinfo_field(field, DECODING_OFFSET(offset, 64)); \ + else \ + vmcsinfo_field(field, DECODING_OFFSET(offset, 32)); \ +} while (0) + +#define VMCS_FIELD_CHECK(field, offset, type) \ +do { \ + if (vmcs_read32(VM_INSTRUCTION_ERROR) !=3D \ + VMXERR_UNSUPPORTED_VMCS_COMPONENT) \ + FIELD_OFFSET##type(field, offset); \ +} while (0) + +static inline void vmcs_read_checking(unsigned long field) +{ + u16 offset16; + u64 offset64; + u32 offset32; + unsigned long offsetnw; + + switch (vmcs_field_type(field)) { + case VMCS_FIELD_TYPE_U16: + offset16 =3D vmcs_read16(field); + VMCS_FIELD_CHECK(field, offset16, 16); + break; + case VMCS_FIELD_TYPE_U64: + offset64 =3D vmcs_read64(field); + VMCS_FIELD_CHECK(field, offset64, 64); + break; + case VMCS_FIELD_TYPE_U32: + offset32 =3D vmcs_read32(field); + VMCS_FIELD_CHECK(field, offset32, 32); + break; + case VMCS_FIELD_TYPE_NATURAL_WIDTH: + offsetnw =3D vmcs_readl(field); + VMCS_FIELD_CHECK(field, offsetnw, NW); + break; + } +} + +/* + * Note, offsets of fields below will not be filled into + * VMCSINFO: + * 1. fields defined in Intel specification (Intel=C2=AE 64 and + * IA-32 Architectures Software Developer=E2=80=99s Manual, Volume + * 3C) but not defined in *vmcs_field*. + * 2. fields unsupported. + */ +static int __init alloc_vmcsinfo_init(void) +{ +/* + * The first 8 bytes in vmcs region are for + * VMCS revision identifier + * VMX-abort indicator + */ +#define FIELD_START (8) + + int r, offset; + struct vmcs *vmcs; + int cpu; + unsigned long field; + + if (vmcsinfo_is_filled()) + return 0; + + vmcs =3D alloc_vmcs(); + if (!vmcs) { + return -ENOMEM; + } + + r =3D hardware_enable_all(); + if (r) + goto out_err; + + /* + * Write encoded offsets into VMCS data for later vmcs_read. + */ + for (offset =3D FIELD_START; offset < vmcs_config.size; + offset +=3D sizeof(u16)) + *(u16 *)((char *)vmcs + offset) =3D ENCODING_OFFSET(offset); + + cpu =3D get_cpu(); + vmcs_clear(vmcs); + per_cpu(current_vmcs, cpu) =3D vmcs; + vmcs_load(vmcs); + + vmcsinfo_revision_id(vmcs->revision_id); + vmcs_read_checking(VM_INSTRUCTION_ERROR); + offset =3D get_vmcs_field_offset(VM_INSTRUCTION_ERROR); + if (offset =3D=3D -1) + goto out_clear; + + for (field =3D 0; field < VMCSINFO_MAX_FIELD; ++field) { + if (field =3D=3D VM_INSTRUCTION_ERROR) + continue; + /* + * Before each reading, zeroed field VM_INSTRUCTION_ERROR + */ + *(u32 *)((char *)vmcs + offset) =3D 0; + vmcs_read_checking(field); + } + vmcsinfo_filled(); + + update_vmcsinfo_note(); + +out_clear: + vmcs_clear(vmcs); + put_cpu(); + +out_err: + free_vmcs(vmcs); + return r; +} + +static void __exit alloc_vmcsinfo_exit(void) +{ + hardware_disable_all(); +} + +module_init(alloc_vmcsinfo_init); +module_exit(alloc_vmcsinfo_exit); --=20 1.7.1