From mboxrd@z Thu Jan 1 00:00:00 1970 From: Namhyung Kim Subject: [PATCH 1/3] virtio: Basic implementation of virtio pstore driver Date: Sat, 20 Aug 2016 17:07:42 +0900 Message-ID: <20160820080744.10344-2-namhyung@kernel.org> References: <20160820080744.10344-1-namhyung@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20160820080744.10344-1-namhyung@kernel.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: virtualization-bounces@lists.linux-foundation.org Errors-To: virtualization-bounces@lists.linux-foundation.org To: virtio-dev@lists.oasis-open.org, kvm@vger.kernel.org, qemu-devel@nongnu.org, virtualization@lists.linux-foundation.org Cc: Tony Luck , =?UTF-8?q?Radim=20Kr=C4=8Dm=C3=A1=C5=99?= , Kees Cook , "Michael S. Tsirkin" , Anton Vorontsov , LKML , Steven Rostedt , Minchan Kim , Anthony Liguori , Colin Cross , Paolo Bonzini , Ingo Molnar List-Id: virtualization@lists.linuxfoundation.org VGhlIHZpcnRpbyBwc3RvcmUgZHJpdmVyIHByb3ZpZGVzIGludGVyZmFjZSB0byB0aGUgcHN0b3Jl IHN1YnN5c3RlbSBzbwp0aGF0IHRoZSBndWVzdCBrZXJuZWwncyBsb2cvZHVtcCBtZXNzYWdlIGNh biBiZSBzYXZlZCBvbiB0aGUgaG9zdAptYWNoaW5lLiAgVXNlcnMgY2FuIGFjY2VzcyB0aGUgbG9n IGZpbGUgZGlyZWN0bHkgb24gdGhlIGhvc3QsIG9yIG9uIHRoZQpndWVzdCBhdCB0aGUgbmV4dCBi b290IHVzaW5nIHBzdG9yZSBmaWxlc3lzdGVtLiAgSXQgY3VycmVudGx5IGRlYWxzIHdpdGgKa2Vy bmVsIGxvZyAocHJpbnRrKSBidWZmZXIgb25seSwgYnV0IHdlIGNhbiBleHRlbmQgaXQgdG8gaGF2 ZSBvdGhlcgppbmZvcm1hdGlvbiAobGlrZSBmdHJhY2UgZHVtcCkgbGF0ZXIuCgpJdCBzdXBwb3J0 cyBsZWdhY3kgUENJIGRldmljZSB1c2luZyBzaW5nbGUgb3JkZXItMiBwYWdlIGJ1ZmZlci4gIEl0 IHVzZXMKdHdvIHZpcnRxdWV1ZXMgLSBvbmUgZm9yIChzeW5jKSByZWFkIGFuZCBhbm90aGVyIGZv ciAoYXN5bmMpIHdyaXRlLgpTaW5jZSBpdCBjYW5ub3Qgd2FpdCBmb3Igd3JpdGUgZmluaXNoZWQs IGl0IHN1cHBvcnRzIHVwIHRvIDEyOApjb25jdXJyZW50IElPLiAgVGhlIGJ1ZmZlciBzaXplIGlz IGNvbmZpZ3VyYWJsZSBub3cuCgpDYzogUGFvbG8gQm9uemluaSA8cGJvbnppbmlAcmVkaGF0LmNv bT4KQ2M6IFJhZGltIEtyxI1tw6HFmSA8cmtyY21hckByZWRoYXQuY29tPgpDYzogIk1pY2hhZWwg Uy4gVHNpcmtpbiIgPG1zdEByZWRoYXQuY29tPgpDYzogQW50aG9ueSBMaWd1b3JpIDxhbGlndW9y aUBhbWF6b24uY29tPgpDYzogQW50b24gVm9yb250c292IDxhbnRvbkBlbm9tc2cub3JnPgpDYzog Q29saW4gQ3Jvc3MgPGNjcm9zc0BhbmRyb2lkLmNvbT4KQ2M6IEtlZXMgQ29vayA8a2Vlc2Nvb2tA Y2hyb21pdW0ub3JnPgpDYzogVG9ueSBMdWNrIDx0b255Lmx1Y2tAaW50ZWwuY29tPgpDYzogU3Rl dmVuIFJvc3RlZHQgPHJvc3RlZHRAZ29vZG1pcy5vcmc+CkNjOiBJbmdvIE1vbG5hciA8bWluZ29A a2VybmVsLm9yZz4KQ2M6IE1pbmNoYW4gS2ltIDxtaW5jaGFuQGtlcm5lbC5vcmc+CkNjOiBrdm1A dmdlci5rZXJuZWwub3JnCkNjOiBxZW11LWRldmVsQG5vbmdudS5vcmcKQ2M6IHZpcnR1YWxpemF0 aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnClNpZ25lZC1vZmYtYnk6IE5hbWh5dW5nIEtp bSA8bmFtaHl1bmdAa2VybmVsLm9yZz4KLS0tCiBkcml2ZXJzL3ZpcnRpby9LY29uZmlnICAgICAg ICAgICAgIHwgIDEwICsKIGRyaXZlcnMvdmlydGlvL01ha2VmaWxlICAgICAgICAgICAgfCAgIDEg KwogZHJpdmVycy92aXJ0aW8vdmlydGlvX3BzdG9yZS5jICAgICB8IDQxNyArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL3VhcGkvbGludXgvS2J1aWxkICAgICAg ICAgIHwgICAxICsKIGluY2x1ZGUvdWFwaS9saW51eC92aXJ0aW9faWRzLmggICAgfCAgIDEgKwog aW5jbHVkZS91YXBpL2xpbnV4L3ZpcnRpb19wc3RvcmUuaCB8ICA3NCArKysrKysrCiA2IGZpbGVz IGNoYW5nZWQsIDUwNCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy92 aXJ0aW8vdmlydGlvX3BzdG9yZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS91YXBpL2xp bnV4L3ZpcnRpb19wc3RvcmUuaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlvL0tjb25maWcg Yi9kcml2ZXJzL3ZpcnRpby9LY29uZmlnCmluZGV4IDc3NTkwMzIwZDQ0Yy4uOGYwZTZjNzk2YzEy IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpcnRpby9LY29uZmlnCisrKyBiL2RyaXZlcnMvdmlydGlv L0tjb25maWcKQEAgLTU4LDYgKzU4LDE2IEBAIGNvbmZpZyBWSVJUSU9fSU5QVVQKIAogCSBJZiB1 bnN1cmUsIHNheSBNLgogCitjb25maWcgVklSVElPX1BTVE9SRQorCXRyaXN0YXRlICJWaXJ0aW8g cHN0b3JlIGRyaXZlciIKKwlkZXBlbmRzIG9uIFZJUlRJTworCWRlcGVuZHMgb24gUFNUT1JFCisJ LS0taGVscC0tLQorCSBUaGlzIGRyaXZlciBzdXBwb3J0cyB2aXJ0aW8gcHN0b3JlIGRldmljZXMg dG8gc2F2ZS9yZXN0b3JlCisJIHBhbmljIGFuZCBvb3BzIG1lc3NhZ2VzIG9uIHRoZSBob3N0Lgor CisJIElmIHVuc3VyZSwgc2F5IE0uCisKICBjb25maWcgVklSVElPX01NSU8KIAl0cmlzdGF0ZSAi UGxhdGZvcm0gYnVzIGRyaXZlciBmb3IgbWVtb3J5IG1hcHBlZCB2aXJ0aW8gZGV2aWNlcyIKIAlk ZXBlbmRzIG9uIEhBU19JT01FTSAmJiBIQVNfRE1BCmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpcnRp by9NYWtlZmlsZSBiL2RyaXZlcnMvdmlydGlvL01ha2VmaWxlCmluZGV4IDQxZTMwZTNkYzg0Mi4u YmVlNjhjYjI2ZDQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3ZpcnRpby9NYWtlZmlsZQorKysgYi9k cml2ZXJzL3ZpcnRpby9NYWtlZmlsZQpAQCAtNSwzICs1LDQgQEAgdmlydGlvX3BjaS15IDo9IHZp cnRpb19wY2lfbW9kZXJuLm8gdmlydGlvX3BjaV9jb21tb24ubwogdmlydGlvX3BjaS0kKENPTkZJ R19WSVJUSU9fUENJX0xFR0FDWSkgKz0gdmlydGlvX3BjaV9sZWdhY3kubwogb2JqLSQoQ09ORklH X1ZJUlRJT19CQUxMT09OKSArPSB2aXJ0aW9fYmFsbG9vbi5vCiBvYmotJChDT05GSUdfVklSVElP X0lOUFVUKSArPSB2aXJ0aW9faW5wdXQubworb2JqLSQoQ09ORklHX1ZJUlRJT19QU1RPUkUpICs9 IHZpcnRpb19wc3RvcmUubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BzdG9y ZS5jIGIvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BzdG9yZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uMGE2M2M3ZGI0Mjc4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJp dmVycy92aXJ0aW8vdmlydGlvX3BzdG9yZS5jCkBAIC0wLDAgKzEsNDE3IEBACisjZGVmaW5lIHBy X2ZtdChmbXQpIEtCVUlMRF9NT0ROQU1FICI6ICIgZm10CisKKyNpbmNsdWRlIDxsaW51eC9rZXJu ZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9wc3RvcmUu aD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW8uaD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29u ZmlnLmg+CisjaW5jbHVkZSA8dWFwaS9saW51eC92aXJ0aW9faWRzLmg+CisjaW5jbHVkZSA8dWFw aS9saW51eC92aXJ0aW9fcHN0b3JlLmg+CisKKyNkZWZpbmUgVklSVF9QU1RPUkVfT1JERVIgICAg MgorI2RlZmluZSBWSVJUX1BTVE9SRV9CVUZTSVpFICAoNDA5NiA8PCBWSVJUX1BTVE9SRV9PUkRF UikKKyNkZWZpbmUgVklSVF9QU1RPUkVfTlJfUkVRICAgMTI4CisKK3N0cnVjdCB2aXJ0aW9fcHN0 b3JlIHsKKwlzdHJ1Y3QgdmlydGlvX2RldmljZQkqdmRldjsKKwlzdHJ1Y3QgdmlydHF1ZXVlCSp2 cVsyXTsKKwlzdHJ1Y3QgcHN0b3JlX2luZm8JIHBzdG9yZTsKKwlzdHJ1Y3QgdmlydGlvX3BzdG9y ZV9yZXEgcmVxW1ZJUlRfUFNUT1JFX05SX1JFUV07CisJc3RydWN0IHZpcnRpb19wc3RvcmVfcmVz IHJlc1tWSVJUX1BTVE9SRV9OUl9SRVFdOworCXVuc2lnbmVkIGludAkJIHJlcV9pZDsKKworCS8q IFdhaXRpbmcgZm9yIGhvc3QgdG8gYWNrICovCisJd2FpdF9xdWV1ZV9oZWFkX3QJYWNrZWQ7CisJ aW50CQkJZmFpbGVkOworfTsKKworI2RlZmluZSBUWVBFX1RBQkxFX0VOVFJZKF9lbnRyeSkJCQkJ XAorCXsgUFNUT1JFX1RZUEVfIyNfZW50cnksIFZJUlRJT19QU1RPUkVfVFlQRV8jI19lbnRyeSB9 CisKK3N0cnVjdCB0eXBlX3RhYmxlIHsKKwlpbnQgcHN0b3JlOworCXUxNiB2aXJ0aW87Cit9IHR5 cGVfdGFibGVbXSA9IHsKKwlUWVBFX1RBQkxFX0VOVFJZKERNRVNHKSwKK307CisKKyN1bmRlZiBU WVBFX1RBQkxFX0VOVFJZCisKKworc3RhdGljIHUxNiB0b192aXJ0aW9fdHlwZShzdHJ1Y3Qgdmly dGlvX3BzdG9yZSAqdnBzLCBlbnVtIHBzdG9yZV90eXBlX2lkIHR5cGUpCit7CisJdW5zaWduZWQg aW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh0eXBlX3RhYmxlKTsgaSsrKSB7 CisJCWlmICh0eXBlID09IHR5cGVfdGFibGVbaV0ucHN0b3JlKQorCQkJcmV0dXJuIGNwdV90b192 aXJ0aW8xNih2cHMtPnZkZXYsIHR5cGVfdGFibGVbaV0udmlydGlvKTsKKwl9CisKKwlyZXR1cm4g Y3B1X3RvX3ZpcnRpbzE2KHZwcy0+dmRldiwgVklSVElPX1BTVE9SRV9UWVBFX1VOS05PV04pOwor fQorCitzdGF0aWMgZW51bSBwc3RvcmVfdHlwZV9pZCBmcm9tX3ZpcnRpb190eXBlKHN0cnVjdCB2 aXJ0aW9fcHN0b3JlICp2cHMsIHUxNiB0eXBlKQoreworCXVuc2lnbmVkIGludCBpOworCisJZm9y IChpID0gMDsgaSA8IEFSUkFZX1NJWkUodHlwZV90YWJsZSk7IGkrKykgeworCQlpZiAodmlydGlv MTZfdG9fY3B1KHZwcy0+dmRldiwgdHlwZSkgPT0gdHlwZV90YWJsZVtpXS52aXJ0aW8pCisJCQly ZXR1cm4gdHlwZV90YWJsZVtpXS5wc3RvcmU7CisJfQorCisJcmV0dXJuIFBTVE9SRV9UWVBFX1VO S05PV047Cit9CisKK3N0YXRpYyB2b2lkIHZpcnRwc3RvcmVfYWNrKHN0cnVjdCB2aXJ0cXVldWUg KnZxKQoreworCXN0cnVjdCB2aXJ0aW9fcHN0b3JlICp2cHMgPSB2cS0+dmRldi0+cHJpdjsKKwor CXdha2VfdXAoJnZwcy0+YWNrZWQpOworfQorCitzdGF0aWMgdm9pZCB2aXJ0cHN0b3JlX2NoZWNr KHN0cnVjdCB2aXJ0cXVldWUgKnZxKQoreworCXN0cnVjdCB2aXJ0aW9fcHN0b3JlICp2cHMgPSB2 cS0+dmRldi0+cHJpdjsKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZV9yZXMgKnJlczsKKwl1bnNpZ25l ZCBpbnQgbGVuOworCisJcmVzID0gdmlydHF1ZXVlX2dldF9idWYodnEsICZsZW4pOworCWlmIChy ZXMgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKHZpcnRpbzMyX3RvX2NwdSh2cS0+dmRldiwg cmVzLT5yZXQpIDwgMCkKKwkJdnBzLT5mYWlsZWQgPSAxOworfQorCitzdGF0aWMgdm9pZCB2aXJ0 X3BzdG9yZV9nZXRfcmVxcyhzdHJ1Y3QgdmlydGlvX3BzdG9yZSAqdnBzLAorCQkJCSBzdHJ1Y3Qg dmlydGlvX3BzdG9yZV9yZXEgKipwcmVxLAorCQkJCSBzdHJ1Y3QgdmlydGlvX3BzdG9yZV9yZXMg KipwcmVzKQoreworCXVuc2lnbmVkIGludCBpZHggPSB2cHMtPnJlcV9pZCsrICUgVklSVF9QU1RP UkVfTlJfUkVROworCisJKnByZXEgPSAmdnBzLT5yZXFbaWR4XTsKKwkqcHJlcyA9ICZ2cHMtPnJl c1tpZHhdOworCisJbWVtc2V0KCpwcmVxLCAwLCBzaXplb2YoKipwcmVxKSk7CisJbWVtc2V0KCpw cmVzLCAwLCBzaXplb2YoKipwcmVzKSk7Cit9CisKK3N0YXRpYyBpbnQgdmlydF9wc3RvcmVfb3Bl bihzdHJ1Y3QgcHN0b3JlX2luZm8gKnBzaSkKK3sKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZSAqdnBz ID0gcHNpLT5kYXRhOworCXN0cnVjdCB2aXJ0aW9fcHN0b3JlX3JlcSAqcmVxOworCXN0cnVjdCB2 aXJ0aW9fcHN0b3JlX3JlcyAqcmVzOworCXN0cnVjdCBzY2F0dGVybGlzdCBzZ29bMV0sIHNnaVsx XTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnc1syXSA9IHsgc2dvLCBzZ2kgfTsKKwl1bnNpZ25l ZCBpbnQgbGVuOworCisJdmlydF9wc3RvcmVfZ2V0X3JlcXModnBzLCAmcmVxLCAmcmVzKTsKKwor CXJlcS0+Y21kID0gY3B1X3RvX3ZpcnRpbzE2KHZwcy0+dmRldiwgVklSVElPX1BTVE9SRV9DTURf T1BFTik7CisKKwlzZ19pbml0X29uZShzZ28sIHJlcSwgc2l6ZW9mKCpyZXEpKTsKKwlzZ19pbml0 X29uZShzZ2ksIHJlcywgc2l6ZW9mKCpyZXMpKTsKKwl2aXJ0cXVldWVfYWRkX3Nncyh2cHMtPnZx WzBdLCBzZ3MsIDEsIDEsIHZwcywgR0ZQX0tFUk5FTCk7CisJdmlydHF1ZXVlX2tpY2sodnBzLT52 cVswXSk7CisKKwl3YWl0X2V2ZW50KHZwcy0+YWNrZWQsIHZpcnRxdWV1ZV9nZXRfYnVmKHZwcy0+ dnFbMF0sICZsZW4pKTsKKwlyZXR1cm4gdmlydGlvMzJfdG9fY3B1KHZwcy0+dmRldiwgcmVzLT5y ZXQpOworfQorCitzdGF0aWMgaW50IHZpcnRfcHN0b3JlX2Nsb3NlKHN0cnVjdCBwc3RvcmVfaW5m byAqcHNpKQoreworCXN0cnVjdCB2aXJ0aW9fcHN0b3JlICp2cHMgPSBwc2ktPmRhdGE7CisJc3Ry dWN0IHZpcnRpb19wc3RvcmVfcmVxICpyZXEgPSAmdnBzLT5yZXFbdnBzLT5yZXFfaWRdOworCXN0 cnVjdCB2aXJ0aW9fcHN0b3JlX3JlcyAqcmVzID0gJnZwcy0+cmVzW3Zwcy0+cmVxX2lkXTsKKwlz dHJ1Y3Qgc2NhdHRlcmxpc3Qgc2dvWzFdLCBzZ2lbMV07CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpz Z3NbMl0gPSB7IHNnbywgc2dpIH07CisJdW5zaWduZWQgaW50IGxlbjsKKworCXZpcnRfcHN0b3Jl X2dldF9yZXFzKHZwcywgJnJlcSwgJnJlcyk7CisKKwlyZXEtPmNtZCA9IGNwdV90b192aXJ0aW8x Nih2cHMtPnZkZXYsIFZJUlRJT19QU1RPUkVfQ01EX0NMT1NFKTsKKworCXNnX2luaXRfb25lKHNn bywgcmVxLCBzaXplb2YoKnJlcSkpOworCXNnX2luaXRfb25lKHNnaSwgcmVzLCBzaXplb2YoKnJl cykpOworCXZpcnRxdWV1ZV9hZGRfc2dzKHZwcy0+dnFbMF0sIHNncywgMSwgMSwgdnBzLCBHRlBf S0VSTkVMKTsKKwl2aXJ0cXVldWVfa2ljayh2cHMtPnZxWzBdKTsKKworCXdhaXRfZXZlbnQodnBz LT5hY2tlZCwgdmlydHF1ZXVlX2dldF9idWYodnBzLT52cVswXSwgJmxlbikpOworCXJldHVybiB2 aXJ0aW8zMl90b19jcHUodnBzLT52ZGV2LCByZXMtPnJldCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90 IHZpcnRfcHN0b3JlX3JlYWQodTY0ICppZCwgZW51bSBwc3RvcmVfdHlwZV9pZCAqdHlwZSwKKwkJ CQlpbnQgKmNvdW50LCBzdHJ1Y3QgdGltZXNwZWMgKnRpbWUsCisJCQkJY2hhciAqKmJ1ZiwgYm9v bCAqY29tcHJlc3NlZCwKKwkJCQlzc2l6ZV90ICplY2Nfbm90aWNlX3NpemUsCisJCQkJc3RydWN0 IHBzdG9yZV9pbmZvICpwc2kpCit7CisJc3RydWN0IHZpcnRpb19wc3RvcmUgKnZwcyA9IHBzaS0+ ZGF0YTsKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZV9yZXEgKnJlcTsKKwlzdHJ1Y3QgdmlydGlvX3Bz dG9yZV9yZXMgKnJlczsKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZV9maWxlaW5mbyBpbmZvOworCXN0 cnVjdCBzY2F0dGVybGlzdCBzZ29bMV0sIHNnaVszXTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNn c1syXSA9IHsgc2dvLCBzZ2kgfTsKKwl1bnNpZ25lZCBpbnQgbGVuOworCXVuc2lnbmVkIGludCBm bGFnczsKKwlpbnQgcmV0OworCXZvaWQgKmJmOworCisJdmlydF9wc3RvcmVfZ2V0X3JlcXModnBz LCAmcmVxLCAmcmVzKTsKKworCXJlcS0+Y21kID0gY3B1X3RvX3ZpcnRpbzE2KHZwcy0+dmRldiwg VklSVElPX1BTVE9SRV9DTURfUkVBRCk7CisKKwlzZ19pbml0X29uZShzZ28sIHJlcSwgc2l6ZW9m KCpyZXEpKTsKKwlzZ19pbml0X3RhYmxlKHNnaSwgMyk7CisJc2dfc2V0X2J1Zigmc2dpWzBdLCBy ZXMsIHNpemVvZigqcmVzKSk7CisJc2dfc2V0X2J1Zigmc2dpWzFdLCAmaW5mbywgc2l6ZW9mKGlu Zm8pKTsKKwlzZ19zZXRfYnVmKCZzZ2lbMl0sIHBzaS0+YnVmLCBwc2ktPmJ1ZnNpemUpOworCXZp cnRxdWV1ZV9hZGRfc2dzKHZwcy0+dnFbMF0sIHNncywgMSwgMSwgdnBzLCBHRlBfS0VSTkVMKTsK Kwl2aXJ0cXVldWVfa2ljayh2cHMtPnZxWzBdKTsKKworCXdhaXRfZXZlbnQodnBzLT5hY2tlZCwg dmlydHF1ZXVlX2dldF9idWYodnBzLT52cVswXSwgJmxlbikpOworCWlmIChsZW4gPCBzaXplb2Yo KnJlcykgKyBzaXplb2YoaW5mbykpCisJCXJldHVybiAtMTsKKworCXJldCA9IHZpcnRpbzMyX3Rv X2NwdSh2cHMtPnZkZXYsIHJlcy0+cmV0KTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsK KworCWxlbiA9IHZpcnRpbzMyX3RvX2NwdSh2cHMtPnZkZXYsIGluZm8ubGVuKTsKKworCWJmID0g a21hbGxvYyhsZW4sIEdGUF9LRVJORUwpOworCWlmIChiZiA9PSBOVUxMKQorCQlyZXR1cm4gLUVO T01FTTsKKworCSppZCAgICA9IHZpcnRpbzY0X3RvX2NwdSh2cHMtPnZkZXYsIGluZm8uaWQpOwor CSp0eXBlICA9IGZyb21fdmlydGlvX3R5cGUodnBzLCBpbmZvLnR5cGUpOworCSpjb3VudCA9IHZp cnRpbzMyX3RvX2NwdSh2cHMtPnZkZXYsIGluZm8uY291bnQpOworCisJZmxhZ3MgPSB2aXJ0aW8z Ml90b19jcHUodnBzLT52ZGV2LCBpbmZvLmZsYWdzKTsKKwkqY29tcHJlc3NlZCA9IGZsYWdzICYg VklSVElPX1BTVE9SRV9GTF9DT01QUkVTU0VEOworCisJdGltZS0+dHZfc2VjICA9IHZpcnRpbzY0 X3RvX2NwdSh2cHMtPnZkZXYsIGluZm8udGltZV9zZWMpOworCXRpbWUtPnR2X25zZWMgPSB2aXJ0 aW8zMl90b19jcHUodnBzLT52ZGV2LCBpbmZvLnRpbWVfbnNlYyk7CisKKwltZW1jcHkoYmYsIHBz aS0+YnVmLCBsZW4pOworCSpidWYgPSBiZjsKKworCXJldHVybiBsZW47Cit9CisKK3N0YXRpYyBp bnQgbm90cmFjZSB2aXJ0X3BzdG9yZV93cml0ZShlbnVtIHBzdG9yZV90eXBlX2lkIHR5cGUsCisJ CQkJICAgICBlbnVtIGttc2dfZHVtcF9yZWFzb24gcmVhc29uLAorCQkJCSAgICAgdTY0ICppZCwg dW5zaWduZWQgaW50IHBhcnQsIGludCBjb3VudCwKKwkJCQkgICAgIGJvb2wgY29tcHJlc3NlZCwg c2l6ZV90IHNpemUsCisJCQkJICAgICBzdHJ1Y3QgcHN0b3JlX2luZm8gKnBzaSkKK3sKKwlzdHJ1 Y3QgdmlydGlvX3BzdG9yZSAqdnBzID0gcHNpLT5kYXRhOworCXN0cnVjdCB2aXJ0aW9fcHN0b3Jl X3JlcSAqcmVxOworCXN0cnVjdCB2aXJ0aW9fcHN0b3JlX3JlcyAqcmVzOworCXN0cnVjdCBzY2F0 dGVybGlzdCBzZ29bMl0sIHNnaVsxXTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnc1syXSA9IHsg c2dvLCBzZ2kgfTsKKwl1bnNpZ25lZCBpbnQgZmxhZ3MgPSBjb21wcmVzc2VkID8gVklSVElPX1BT VE9SRV9GTF9DT01QUkVTU0VEIDogMDsKKworCWlmICh2cHMtPmZhaWxlZCkKKwkJcmV0dXJuIC0x OworCisJKmlkID0gdnBzLT5yZXFfaWQ7CisJdmlydF9wc3RvcmVfZ2V0X3JlcXModnBzLCAmcmVx LCAmcmVzKTsKKworCXJlcS0+Y21kICAgPSBjcHVfdG9fdmlydGlvMTYodnBzLT52ZGV2LCBWSVJU SU9fUFNUT1JFX0NNRF9XUklURSk7CisJcmVxLT50eXBlICA9IHRvX3ZpcnRpb190eXBlKHZwcywg dHlwZSk7CisJcmVxLT5mbGFncyA9IGNwdV90b192aXJ0aW8zMih2cHMtPnZkZXYsIGZsYWdzKTsK KworCXNnX2luaXRfdGFibGUoc2dvLCAyKTsKKwlzZ19zZXRfYnVmKCZzZ29bMF0sIHJlcSwgc2l6 ZW9mKCpyZXEpKTsKKwlzZ19zZXRfYnVmKCZzZ29bMV0sIHBzdG9yZV9nZXRfYnVmKHBzaSksIHNp emUpOworCXNnX2luaXRfb25lKHNnaSwgcmVzLCBzaXplb2YoKnJlcykpOworCXZpcnRxdWV1ZV9h ZGRfc2dzKHZwcy0+dnFbMV0sIHNncywgMSwgMSwgdnBzLCBHRlBfQVRPTUlDKTsKKwl2aXJ0cXVl dWVfa2ljayh2cHMtPnZxWzFdKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHZpcnRf cHN0b3JlX2VyYXNlKGVudW0gcHN0b3JlX3R5cGVfaWQgdHlwZSwgdTY0IGlkLCBpbnQgY291bnQs CisJCQkgICAgIHN0cnVjdCB0aW1lc3BlYyB0aW1lLCBzdHJ1Y3QgcHN0b3JlX2luZm8gKnBzaSkK K3sKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZSAqdnBzID0gcHNpLT5kYXRhOworCXN0cnVjdCB2aXJ0 aW9fcHN0b3JlX3JlcSAqcmVxOworCXN0cnVjdCB2aXJ0aW9fcHN0b3JlX3JlcyAqcmVzOworCXN0 cnVjdCBzY2F0dGVybGlzdCBzZ29bMV0sIHNnaVsxXTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNn c1syXSA9IHsgc2dvLCBzZ2kgfTsKKwl1bnNpZ25lZCBpbnQgbGVuOworCisJdmlydF9wc3RvcmVf Z2V0X3JlcXModnBzLCAmcmVxLCAmcmVzKTsKKworCXJlcS0+Y21kICAgPSBjcHVfdG9fdmlydGlv MTYodnBzLT52ZGV2LCBWSVJUSU9fUFNUT1JFX0NNRF9FUkFTRSk7CisJcmVxLT50eXBlICA9IHRv X3ZpcnRpb190eXBlKHZwcywgdHlwZSk7CisJcmVxLT5pZAkgICA9IGNwdV90b192aXJ0aW82NCh2 cHMtPnZkZXYsIGlkKTsKKwlyZXEtPmNvdW50ID0gY3B1X3RvX3ZpcnRpbzMyKHZwcy0+dmRldiwg Y291bnQpOworCisJc2dfaW5pdF9vbmUoc2dvLCByZXEsIHNpemVvZigqcmVxKSk7CisJc2dfaW5p dF9vbmUoc2dpLCByZXMsIHNpemVvZigqcmVzKSk7CisJdmlydHF1ZXVlX2FkZF9zZ3ModnBzLT52 cVswXSwgc2dzLCAxLCAxLCB2cHMsIEdGUF9LRVJORUwpOworCXZpcnRxdWV1ZV9raWNrKHZwcy0+ dnFbMF0pOworCisJd2FpdF9ldmVudCh2cHMtPmFja2VkLCB2aXJ0cXVldWVfZ2V0X2J1Zih2cHMt PnZxWzBdLCAmbGVuKSk7CisJcmV0dXJuIHZpcnRpbzMyX3RvX2NwdSh2cHMtPnZkZXYsIHJlcy0+ cmV0KTsKK30KKworc3RhdGljIGludCB2aXJ0X3BzdG9yZV9pbml0KHN0cnVjdCB2aXJ0aW9fcHN0 b3JlICp2cHMpCit7CisJc3RydWN0IHBzdG9yZV9pbmZvICpwc2luZm8gPSAmdnBzLT5wc3RvcmU7 CisJaW50IGVycjsKKworCWlmICghcHNpbmZvLT5idWZzaXplKQorCQlwc2luZm8tPmJ1ZnNpemUg PSBWSVJUX1BTVE9SRV9CVUZTSVpFOworCisJcHNpbmZvLT5idWYgPSBhbGxvY19wYWdlc19leGFj dChwc2luZm8tPmJ1ZnNpemUsIEdGUF9LRVJORUwpOworCWlmICghcHNpbmZvLT5idWYpIHsKKwkJ cHJfZXJyKCJjYW5ub3QgYWxsb2NhdGUgcHN0b3JlIGJ1ZmZlclxuIik7CisJCXJldHVybiAtRU5P TUVNOworCX0KKworCXBzaW5mby0+b3duZXIgPSBUSElTX01PRFVMRTsKKwlwc2luZm8tPm5hbWUg ID0gInZpcnRpbyI7CisJcHNpbmZvLT5vcGVuICA9IHZpcnRfcHN0b3JlX29wZW47CisJcHNpbmZv LT5jbG9zZSA9IHZpcnRfcHN0b3JlX2Nsb3NlOworCXBzaW5mby0+cmVhZCAgPSB2aXJ0X3BzdG9y ZV9yZWFkOworCXBzaW5mby0+ZXJhc2UgPSB2aXJ0X3BzdG9yZV9lcmFzZTsKKwlwc2luZm8tPndy aXRlID0gdmlydF9wc3RvcmVfd3JpdGU7CisJcHNpbmZvLT5mbGFncyA9IFBTVE9SRV9GTEFHU19E TUVTRzsKKworCXBzaW5mby0+ZGF0YSAgPSB2cHM7CisJc3Bpbl9sb2NrX2luaXQoJnBzaW5mby0+ YnVmX2xvY2spOworCisJZXJyID0gcHN0b3JlX3JlZ2lzdGVyKHBzaW5mbyk7CisJaWYgKGVycikK KwkJa2ZyZWUocHNpbmZvLT5idWYpOworCisJcmV0dXJuIGVycjsKK30KKworc3RhdGljIGludCB2 aXJ0X3BzdG9yZV9leGl0KHN0cnVjdCB2aXJ0aW9fcHN0b3JlICp2cHMpCit7CisJc3RydWN0IHBz dG9yZV9pbmZvICpwc2luZm8gPSAmdnBzLT5wc3RvcmU7CisKKwlwc3RvcmVfdW5yZWdpc3Rlcihw c2luZm8pOworCisJZnJlZV9wYWdlc19leGFjdChwc2luZm8tPmJ1ZiwgcHNpbmZvLT5idWZzaXpl KTsKKwlwc2luZm8tPmJ1ZiA9IE5VTEw7CisJcHNpbmZvLT5idWZzaXplID0gMDsKKworCXJldHVy biAwOworfQorCitzdGF0aWMgaW50IHZpcnRwc3RvcmVfaW5pdF92cXMoc3RydWN0IHZpcnRpb19w c3RvcmUgKnZwcykKK3sKKwl2cV9jYWxsYmFja190ICpjYWxsYmFja3NbXSA9IHsgdmlydHBzdG9y ZV9hY2ssIHZpcnRwc3RvcmVfY2hlY2sgfTsKKwljb25zdCBjaGFyICpuYW1lc1tdID0geyAicHN0 b3JlX3JlYWQiLCAicHN0b3JlX3dyaXRlIiB9OworCisJcmV0dXJuIHZwcy0+dmRldi0+Y29uZmln LT5maW5kX3Zxcyh2cHMtPnZkZXYsIDIsIHZwcy0+dnEsCisJCQkJCSAgIGNhbGxiYWNrcywgbmFt ZXMpOworfQorCitzdGF0aWMgdm9pZCB2aXJ0cHN0b3JlX2luaXRfY29uZmlnKHN0cnVjdCB2aXJ0 aW9fcHN0b3JlICp2cHMpCit7CisJdTMyIGJ1ZnNpemU7CisKKwl2aXJ0aW9fY3JlYWQodnBzLT52 ZGV2LCBzdHJ1Y3QgdmlydGlvX3BzdG9yZV9jb25maWcsIGJ1ZnNpemUsICZidWZzaXplKTsKKwor CXZwcy0+cHN0b3JlLmJ1ZnNpemUgPSBQQUdFX0FMSUdOKGJ1ZnNpemUpOworfQorCitzdGF0aWMg dm9pZCB2aXJ0cHN0b3JlX2NvbmZpcm1fY29uZmlnKHN0cnVjdCB2aXJ0aW9fcHN0b3JlICp2cHMp Cit7CisJdTMyIGJ1ZnNpemUgPSB2cHMtPnBzdG9yZS5idWZzaXplOworCisJdmlydGlvX2N3cml0 ZSh2cHMtPnZkZXYsIHN0cnVjdCB2aXJ0aW9fcHN0b3JlX2NvbmZpZywgYnVmc2l6ZSwKKwkJICAg ICAmYnVmc2l6ZSk7Cit9CisKK3N0YXRpYyBpbnQgdmlydHBzdG9yZV9wcm9iZShzdHJ1Y3Qgdmly dGlvX2RldmljZSAqdmRldikKK3sKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZSAqdnBzOworCWludCBl cnI7CisKKwlpZiAoIXZkZXYtPmNvbmZpZy0+Z2V0KSB7CisJCWRldl9lcnIoJnZkZXYtPmRldiwg ImRyaXZlciBpbml0OiBjb25maWcgYWNjZXNzIGRpc2FibGVkXG4iKTsKKwkJcmV0dXJuIC1FSU5W QUw7CisJfQorCisJdmRldi0+cHJpdiA9IHZwcyA9IGt6YWxsb2Moc2l6ZW9mKCp2cHMpLCBHRlBf S0VSTkVMKTsKKwlpZiAoIXZwcykgeworCQllcnIgPSAtRU5PTUVNOworCQlnb3RvIG91dDsKKwl9 CisJdnBzLT52ZGV2ID0gdmRldjsKKworCWVyciA9IHZpcnRwc3RvcmVfaW5pdF92cXModnBzKTsK KwlpZiAoZXJyIDwgMCkKKwkJZ290byBvdXRfZnJlZTsKKworCXZpcnRwc3RvcmVfaW5pdF9jb25m aWcodnBzKTsKKworCWVyciA9IHZpcnRfcHN0b3JlX2luaXQodnBzKTsKKwlpZiAoZXJyKQorCQln b3RvIG91dF9kZWxfdnE7CisKKwl2aXJ0cHN0b3JlX2NvbmZpcm1fY29uZmlnKHZwcyk7CisKKwlp bml0X3dhaXRxdWV1ZV9oZWFkKCZ2cHMtPmFja2VkKTsKKworCXZpcnRpb19kZXZpY2VfcmVhZHko dmRldik7CisKKwlkZXZfaW5mbygmdmRldi0+ZGV2LCAiZHJpdmVyIGluaXQ6IG9rIChidWZzaXpl ID0gJWx1SywgZmxhZ3MgPSAleClcbiIsCisJCSB2cHMtPnBzdG9yZS5idWZzaXplID4+IDEwLCB2 cHMtPnBzdG9yZS5mbGFncyk7CisKKwlyZXR1cm4gMDsKKworb3V0X2RlbF92cToKKwl2ZGV2LT5j b25maWctPmRlbF92cXModmRldik7CitvdXRfZnJlZToKKwlrZnJlZSh2cHMpOworb3V0OgorCWRl dl9lcnIoJnZkZXYtPmRldiwgImRyaXZlciBpbml0OiBmYWlsZWQgd2l0aCAlZFxuIiwgZXJyKTsK KwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgdm9pZCB2aXJ0cHN0b3JlX3JlbW92ZShzdHJ1Y3Qg dmlydGlvX2RldmljZSAqdmRldikKK3sKKwlzdHJ1Y3QgdmlydGlvX3BzdG9yZSAqdnBzID0gdmRl di0+cHJpdjsKKworCXZpcnRfcHN0b3JlX2V4aXQodnBzKTsKKworCS8qIE5vdyB3ZSByZXNldCB0 aGUgZGV2aWNlIHNvIHdlIGNhbiBjbGVhbiB1cCB0aGUgcXVldWVzLiAqLworCXZkZXYtPmNvbmZp Zy0+cmVzZXQodmRldik7CisKKwl2ZGV2LT5jb25maWctPmRlbF92cXModmRldik7CisKKwlrZnJl ZSh2cHMpOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IGZlYXR1cmVzW10gPSB7Cit9OworCitz dGF0aWMgc3RydWN0IHZpcnRpb19kZXZpY2VfaWQgaWRfdGFibGVbXSA9IHsKKwl7IFZJUlRJT19J RF9QU1RPUkUsIFZJUlRJT19ERVZfQU5ZX0lEIH0sCisJeyAwIH0sCit9OworCitzdGF0aWMgc3Ry dWN0IHZpcnRpb19kcml2ZXIgdmlydGlvX3BzdG9yZV9kcml2ZXIgPSB7CisJLmRyaXZlci5uYW1l ICAgICAgICAgPSBLQlVJTERfTU9ETkFNRSwKKwkuZHJpdmVyLm93bmVyICAgICAgICA9IFRISVNf TU9EVUxFLAorCS5mZWF0dXJlX3RhYmxlICAgICAgID0gZmVhdHVyZXMsCisJLmZlYXR1cmVfdGFi bGVfc2l6ZSAgPSBBUlJBWV9TSVpFKGZlYXR1cmVzKSwKKwkuaWRfdGFibGUgICAgICAgICAgICA9 IGlkX3RhYmxlLAorCS5wcm9iZSAgICAgICAgICAgICAgID0gdmlydHBzdG9yZV9wcm9iZSwKKwku cmVtb3ZlICAgICAgICAgICAgICA9IHZpcnRwc3RvcmVfcmVtb3ZlLAorfTsKKworbW9kdWxlX3Zp cnRpb19kcml2ZXIodmlydGlvX3BzdG9yZV9kcml2ZXIpOworTU9EVUxFX0RFVklDRV9UQUJMRSh2 aXJ0aW8sIGlkX3RhYmxlKTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FVVEhP UigiTmFtaHl1bmcgS2ltIDxuYW1oeXVuZ0BrZXJuZWwub3JnPiIpOworTU9EVUxFX0RFU0NSSVBU SU9OKCJWaXJ0aW8gcHN0b3JlIGRyaXZlciIpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xp bnV4L0tidWlsZCBiL2luY2x1ZGUvdWFwaS9saW51eC9LYnVpbGQKaW5kZXggNmQ0ZTkyY2NkYzkx Li45YmJiMTU1NGQ4YjIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9LYnVpbGQKKysr IGIvaW5jbHVkZS91YXBpL2xpbnV4L0tidWlsZApAQCAtNDQ5LDYgKzQ0OSw3IEBAIGhlYWRlci15 ICs9IHZpcnRpb19pZHMuaAogaGVhZGVyLXkgKz0gdmlydGlvX2lucHV0LmgKIGhlYWRlci15ICs9 IHZpcnRpb19uZXQuaAogaGVhZGVyLXkgKz0gdmlydGlvX3BjaS5oCitoZWFkZXIteSArPSB2aXJ0 aW9fcHN0b3JlLmgKIGhlYWRlci15ICs9IHZpcnRpb19yaW5nLmgKIGhlYWRlci15ICs9IHZpcnRp b19ybmcuaAogaGVhZGVyLXkgKz0gdmlydGlvX3Njc2kuaApkaWZmIC0tZ2l0IGEvaW5jbHVkZS91 YXBpL2xpbnV4L3ZpcnRpb19pZHMuaCBiL2luY2x1ZGUvdWFwaS9saW51eC92aXJ0aW9faWRzLmgK aW5kZXggNzc5MjVmNTg3YjE1Li5jNzJhOWFiNTg4YzAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFw aS9saW51eC92aXJ0aW9faWRzLmgKKysrIGIvaW5jbHVkZS91YXBpL2xpbnV4L3ZpcnRpb19pZHMu aApAQCAtNDEsNSArNDEsNiBAQAogI2RlZmluZSBWSVJUSU9fSURfQ0FJRgkgICAgICAgMTIgLyog VmlydGlvIGNhaWYgKi8KICNkZWZpbmUgVklSVElPX0lEX0dQVSAgICAgICAgICAxNiAvKiB2aXJ0 aW8gR1BVICovCiAjZGVmaW5lIFZJUlRJT19JRF9JTlBVVCAgICAgICAgMTggLyogdmlydGlvIGlu cHV0ICovCisjZGVmaW5lIFZJUlRJT19JRF9QU1RPUkUgICAgICAgMjIgLyogdmlydGlvIHBzdG9y ZSAqLwogCiAjZW5kaWYgLyogX0xJTlVYX1ZJUlRJT19JRFNfSCAqLwpkaWZmIC0tZ2l0IGEvaW5j bHVkZS91YXBpL2xpbnV4L3ZpcnRpb19wc3RvcmUuaCBiL2luY2x1ZGUvdWFwaS9saW51eC92aXJ0 aW9fcHN0b3JlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mNGIw ZDIwNGQ4YWUKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3VhcGkvbGludXgvdmlydGlvX3Bz dG9yZS5oCkBAIC0wLDAgKzEsNzQgQEAKKyNpZm5kZWYgX0xJTlVYX1ZJUlRJT19QU1RPUkVfSAor I2RlZmluZSBfTElOVVhfVklSVElPX1BTVE9SRV9ICisvKiBUaGlzIGhlYWRlciBpcyBCU0QgbGlj ZW5zZWQgc28gYW55b25lIGNhbiB1c2UgdGhlIGRlZmluaXRpb25zIHRvIGltcGxlbWVudAorICog Y29tcGF0aWJsZSBkcml2ZXJzL3NlcnZlcnMuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKiAzLiBOZWl0aGVyIHRoZSBu YW1lIG9mIElCTSBub3IgdGhlIG5hbWVzIG9mIGl0cyBjb250cmlidXRvcnMKKyAqICAgIG1heSBi ZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20gdGhpcyBz b2Z0d2FyZQorICogICAgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24u CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQKKyAqIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UKKyAqIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgSUJNIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUKKyAqIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMCisgKiBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUworICogT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pCisgKiBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVAorICogTElBQklM SVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWQorICogT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRgorICogU1VDSCBEQU1BR0UuICovCisjaW5jbHVk ZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW9fdHlwZXMuaD4KKworI2Rl ZmluZSBWSVJUSU9fUFNUT1JFX0NNRF9OVUxMICAgMAorI2RlZmluZSBWSVJUSU9fUFNUT1JFX0NN RF9PUEVOICAgMQorI2RlZmluZSBWSVJUSU9fUFNUT1JFX0NNRF9SRUFEICAgMgorI2RlZmluZSBW SVJUSU9fUFNUT1JFX0NNRF9XUklURSAgMworI2RlZmluZSBWSVJUSU9fUFNUT1JFX0NNRF9FUkFT RSAgNAorI2RlZmluZSBWSVJUSU9fUFNUT1JFX0NNRF9DTE9TRSAgNQorCisjZGVmaW5lIFZJUlRJ T19QU1RPUkVfVFlQRV9VTktOT1dOICAwCisjZGVmaW5lIFZJUlRJT19QU1RPUkVfVFlQRV9ETUVT RyAgICAxCisKKyNkZWZpbmUgVklSVElPX1BTVE9SRV9GTF9DT01QUkVTU0VEICAxCisKK3N0cnVj dCB2aXJ0aW9fcHN0b3JlX3JlcSB7CisJX192aXJ0aW8xNgkJY21kOworCV9fdmlydGlvMTYJCXR5 cGU7CisJX192aXJ0aW8zMgkJZmxhZ3M7CisJX192aXJ0aW82NAkJaWQ7CisJX192aXJ0aW8zMgkJ Y291bnQ7CisJX192aXJ0aW8zMgkJcmVzZXJ2ZWQ7Cit9OworCitzdHJ1Y3QgdmlydGlvX3BzdG9y ZV9yZXMgeworCV9fdmlydGlvMTYJCWNtZDsKKwlfX3ZpcnRpbzE2CQl0eXBlOworCV9fdmlydGlv MzIJCXJldDsKK307CisKK3N0cnVjdCB2aXJ0aW9fcHN0b3JlX2ZpbGVpbmZvIHsKKwlfX3ZpcnRp bzY0CQlpZDsKKwlfX3ZpcnRpbzMyCQljb3VudDsKKwlfX3ZpcnRpbzE2CQl0eXBlOworCV9fdmly dGlvMTYJCXVudXNlZDsKKwlfX3ZpcnRpbzMyCQlmbGFnczsKKwlfX3ZpcnRpbzMyCQlsZW47CisJ X192aXJ0aW82NAkJdGltZV9zZWM7CisJX192aXJ0aW8zMgkJdGltZV9uc2VjOworCV9fdmlydGlv MzIJCXJlc2VydmVkOworfTsKKworc3RydWN0IHZpcnRpb19wc3RvcmVfY29uZmlnIHsKKwlfX3Zp cnRpbzMyCQlidWZzaXplOworfTsKKworI2VuZGlmIC8qIF9MSU5VWF9WSVJUSU9fUFNUT1JFX0gg Ki8KLS0gCjIuOS4zCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpWaXJ0dWFsaXphdGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6YXRpb25AbGlzdHMubGlu dXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxt YW4vbGlzdGluZm8vdmlydHVhbGl6YXRpb24= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754041AbcHTIKU (ORCPT ); Sat, 20 Aug 2016 04:10:20 -0400 Received: from mail-pa0-f66.google.com ([209.85.220.66]:32922 "EHLO mail-pa0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751350AbcHTIJS (ORCPT ); Sat, 20 Aug 2016 04:09:18 -0400 From: Namhyung Kim To: virtio-dev@lists.oasis-open.org, kvm@vger.kernel.org, qemu-devel@nongnu.org, virtualization@lists.linux-foundation.org Cc: LKML , Paolo Bonzini , =?UTF-8?q?Radim=20Kr=C4=8Dm=C3=A1=C5=99?= , "Michael S. Tsirkin" , Anthony Liguori , Anton Vorontsov , Colin Cross , Kees Cook , Tony Luck , Steven Rostedt , Ingo Molnar , Minchan Kim Subject: [PATCH 1/3] virtio: Basic implementation of virtio pstore driver Date: Sat, 20 Aug 2016 17:07:42 +0900 Message-Id: <20160820080744.10344-2-namhyung@kernel.org> X-Mailer: git-send-email 2.9.3 In-Reply-To: <20160820080744.10344-1-namhyung@kernel.org> References: <20160820080744.10344-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The virtio pstore driver provides interface to the pstore subsystem so that the guest kernel's log/dump message can be saved on the host machine. Users can access the log file directly on the host, or on the guest at the next boot using pstore filesystem. It currently deals with kernel log (printk) buffer only, but we can extend it to have other information (like ftrace dump) later. It supports legacy PCI device using single order-2 page buffer. It uses two virtqueues - one for (sync) read and another for (async) write. Since it cannot wait for write finished, it supports up to 128 concurrent IO. The buffer size is configurable now. Cc: Paolo Bonzini Cc: Radim Krčmář Cc: "Michael S. Tsirkin" Cc: Anthony Liguori Cc: Anton Vorontsov Cc: Colin Cross Cc: Kees Cook Cc: Tony Luck Cc: Steven Rostedt Cc: Ingo Molnar Cc: Minchan Kim Cc: kvm@vger.kernel.org Cc: qemu-devel@nongnu.org Cc: virtualization@lists.linux-foundation.org Signed-off-by: Namhyung Kim --- drivers/virtio/Kconfig | 10 + drivers/virtio/Makefile | 1 + drivers/virtio/virtio_pstore.c | 417 +++++++++++++++++++++++++++++++++++++ include/uapi/linux/Kbuild | 1 + include/uapi/linux/virtio_ids.h | 1 + include/uapi/linux/virtio_pstore.h | 74 +++++++ 6 files changed, 504 insertions(+) create mode 100644 drivers/virtio/virtio_pstore.c create mode 100644 include/uapi/linux/virtio_pstore.h diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig index 77590320d44c..8f0e6c796c12 100644 --- a/drivers/virtio/Kconfig +++ b/drivers/virtio/Kconfig @@ -58,6 +58,16 @@ config VIRTIO_INPUT If unsure, say M. +config VIRTIO_PSTORE + tristate "Virtio pstore driver" + depends on VIRTIO + depends on PSTORE + ---help--- + This driver supports virtio pstore devices to save/restore + panic and oops messages on the host. + + If unsure, say M. + config VIRTIO_MMIO tristate "Platform bus driver for memory mapped virtio devices" depends on HAS_IOMEM && HAS_DMA diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile index 41e30e3dc842..bee68cb26d48 100644 --- a/drivers/virtio/Makefile +++ b/drivers/virtio/Makefile @@ -5,3 +5,4 @@ virtio_pci-y := virtio_pci_modern.o virtio_pci_common.o virtio_pci-$(CONFIG_VIRTIO_PCI_LEGACY) += virtio_pci_legacy.o obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o obj-$(CONFIG_VIRTIO_INPUT) += virtio_input.o +obj-$(CONFIG_VIRTIO_PSTORE) += virtio_pstore.o diff --git a/drivers/virtio/virtio_pstore.c b/drivers/virtio/virtio_pstore.c new file mode 100644 index 000000000000..0a63c7db4278 --- /dev/null +++ b/drivers/virtio/virtio_pstore.c @@ -0,0 +1,417 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include + +#define VIRT_PSTORE_ORDER 2 +#define VIRT_PSTORE_BUFSIZE (4096 << VIRT_PSTORE_ORDER) +#define VIRT_PSTORE_NR_REQ 128 + +struct virtio_pstore { + struct virtio_device *vdev; + struct virtqueue *vq[2]; + struct pstore_info pstore; + struct virtio_pstore_req req[VIRT_PSTORE_NR_REQ]; + struct virtio_pstore_res res[VIRT_PSTORE_NR_REQ]; + unsigned int req_id; + + /* Waiting for host to ack */ + wait_queue_head_t acked; + int failed; +}; + +#define TYPE_TABLE_ENTRY(_entry) \ + { PSTORE_TYPE_##_entry, VIRTIO_PSTORE_TYPE_##_entry } + +struct type_table { + int pstore; + u16 virtio; +} type_table[] = { + TYPE_TABLE_ENTRY(DMESG), +}; + +#undef TYPE_TABLE_ENTRY + + +static u16 to_virtio_type(struct virtio_pstore *vps, enum pstore_type_id type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(type_table); i++) { + if (type == type_table[i].pstore) + return cpu_to_virtio16(vps->vdev, type_table[i].virtio); + } + + return cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_TYPE_UNKNOWN); +} + +static enum pstore_type_id from_virtio_type(struct virtio_pstore *vps, u16 type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(type_table); i++) { + if (virtio16_to_cpu(vps->vdev, type) == type_table[i].virtio) + return type_table[i].pstore; + } + + return PSTORE_TYPE_UNKNOWN; +} + +static void virtpstore_ack(struct virtqueue *vq) +{ + struct virtio_pstore *vps = vq->vdev->priv; + + wake_up(&vps->acked); +} + +static void virtpstore_check(struct virtqueue *vq) +{ + struct virtio_pstore *vps = vq->vdev->priv; + struct virtio_pstore_res *res; + unsigned int len; + + res = virtqueue_get_buf(vq, &len); + if (res == NULL) + return; + + if (virtio32_to_cpu(vq->vdev, res->ret) < 0) + vps->failed = 1; +} + +static void virt_pstore_get_reqs(struct virtio_pstore *vps, + struct virtio_pstore_req **preq, + struct virtio_pstore_res **pres) +{ + unsigned int idx = vps->req_id++ % VIRT_PSTORE_NR_REQ; + + *preq = &vps->req[idx]; + *pres = &vps->res[idx]; + + memset(*preq, 0, sizeof(**preq)); + memset(*pres, 0, sizeof(**pres)); +} + +static int virt_pstore_open(struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct scatterlist sgo[1], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_OPEN); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + return virtio32_to_cpu(vps->vdev, res->ret); +} + +static int virt_pstore_close(struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req = &vps->req[vps->req_id]; + struct virtio_pstore_res *res = &vps->res[vps->req_id]; + struct scatterlist sgo[1], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_CLOSE); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + return virtio32_to_cpu(vps->vdev, res->ret); +} + +static ssize_t virt_pstore_read(u64 *id, enum pstore_type_id *type, + int *count, struct timespec *time, + char **buf, bool *compressed, + ssize_t *ecc_notice_size, + struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct virtio_pstore_fileinfo info; + struct scatterlist sgo[1], sgi[3]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + unsigned int flags; + int ret; + void *bf; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_READ); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_table(sgi, 3); + sg_set_buf(&sgi[0], res, sizeof(*res)); + sg_set_buf(&sgi[1], &info, sizeof(info)); + sg_set_buf(&sgi[2], psi->buf, psi->bufsize); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + if (len < sizeof(*res) + sizeof(info)) + return -1; + + ret = virtio32_to_cpu(vps->vdev, res->ret); + if (ret < 0) + return ret; + + len = virtio32_to_cpu(vps->vdev, info.len); + + bf = kmalloc(len, GFP_KERNEL); + if (bf == NULL) + return -ENOMEM; + + *id = virtio64_to_cpu(vps->vdev, info.id); + *type = from_virtio_type(vps, info.type); + *count = virtio32_to_cpu(vps->vdev, info.count); + + flags = virtio32_to_cpu(vps->vdev, info.flags); + *compressed = flags & VIRTIO_PSTORE_FL_COMPRESSED; + + time->tv_sec = virtio64_to_cpu(vps->vdev, info.time_sec); + time->tv_nsec = virtio32_to_cpu(vps->vdev, info.time_nsec); + + memcpy(bf, psi->buf, len); + *buf = bf; + + return len; +} + +static int notrace virt_pstore_write(enum pstore_type_id type, + enum kmsg_dump_reason reason, + u64 *id, unsigned int part, int count, + bool compressed, size_t size, + struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct scatterlist sgo[2], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int flags = compressed ? VIRTIO_PSTORE_FL_COMPRESSED : 0; + + if (vps->failed) + return -1; + + *id = vps->req_id; + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_WRITE); + req->type = to_virtio_type(vps, type); + req->flags = cpu_to_virtio32(vps->vdev, flags); + + sg_init_table(sgo, 2); + sg_set_buf(&sgo[0], req, sizeof(*req)); + sg_set_buf(&sgo[1], pstore_get_buf(psi), size); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[1], sgs, 1, 1, vps, GFP_ATOMIC); + virtqueue_kick(vps->vq[1]); + + return 0; +} + +static int virt_pstore_erase(enum pstore_type_id type, u64 id, int count, + struct timespec time, struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct scatterlist sgo[1], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_ERASE); + req->type = to_virtio_type(vps, type); + req->id = cpu_to_virtio64(vps->vdev, id); + req->count = cpu_to_virtio32(vps->vdev, count); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + return virtio32_to_cpu(vps->vdev, res->ret); +} + +static int virt_pstore_init(struct virtio_pstore *vps) +{ + struct pstore_info *psinfo = &vps->pstore; + int err; + + if (!psinfo->bufsize) + psinfo->bufsize = VIRT_PSTORE_BUFSIZE; + + psinfo->buf = alloc_pages_exact(psinfo->bufsize, GFP_KERNEL); + if (!psinfo->buf) { + pr_err("cannot allocate pstore buffer\n"); + return -ENOMEM; + } + + psinfo->owner = THIS_MODULE; + psinfo->name = "virtio"; + psinfo->open = virt_pstore_open; + psinfo->close = virt_pstore_close; + psinfo->read = virt_pstore_read; + psinfo->erase = virt_pstore_erase; + psinfo->write = virt_pstore_write; + psinfo->flags = PSTORE_FLAGS_DMESG; + + psinfo->data = vps; + spin_lock_init(&psinfo->buf_lock); + + err = pstore_register(psinfo); + if (err) + kfree(psinfo->buf); + + return err; +} + +static int virt_pstore_exit(struct virtio_pstore *vps) +{ + struct pstore_info *psinfo = &vps->pstore; + + pstore_unregister(psinfo); + + free_pages_exact(psinfo->buf, psinfo->bufsize); + psinfo->buf = NULL; + psinfo->bufsize = 0; + + return 0; +} + +static int virtpstore_init_vqs(struct virtio_pstore *vps) +{ + vq_callback_t *callbacks[] = { virtpstore_ack, virtpstore_check }; + const char *names[] = { "pstore_read", "pstore_write" }; + + return vps->vdev->config->find_vqs(vps->vdev, 2, vps->vq, + callbacks, names); +} + +static void virtpstore_init_config(struct virtio_pstore *vps) +{ + u32 bufsize; + + virtio_cread(vps->vdev, struct virtio_pstore_config, bufsize, &bufsize); + + vps->pstore.bufsize = PAGE_ALIGN(bufsize); +} + +static void virtpstore_confirm_config(struct virtio_pstore *vps) +{ + u32 bufsize = vps->pstore.bufsize; + + virtio_cwrite(vps->vdev, struct virtio_pstore_config, bufsize, + &bufsize); +} + +static int virtpstore_probe(struct virtio_device *vdev) +{ + struct virtio_pstore *vps; + int err; + + if (!vdev->config->get) { + dev_err(&vdev->dev, "driver init: config access disabled\n"); + return -EINVAL; + } + + vdev->priv = vps = kzalloc(sizeof(*vps), GFP_KERNEL); + if (!vps) { + err = -ENOMEM; + goto out; + } + vps->vdev = vdev; + + err = virtpstore_init_vqs(vps); + if (err < 0) + goto out_free; + + virtpstore_init_config(vps); + + err = virt_pstore_init(vps); + if (err) + goto out_del_vq; + + virtpstore_confirm_config(vps); + + init_waitqueue_head(&vps->acked); + + virtio_device_ready(vdev); + + dev_info(&vdev->dev, "driver init: ok (bufsize = %luK, flags = %x)\n", + vps->pstore.bufsize >> 10, vps->pstore.flags); + + return 0; + +out_del_vq: + vdev->config->del_vqs(vdev); +out_free: + kfree(vps); +out: + dev_err(&vdev->dev, "driver init: failed with %d\n", err); + return err; +} + +static void virtpstore_remove(struct virtio_device *vdev) +{ + struct virtio_pstore *vps = vdev->priv; + + virt_pstore_exit(vps); + + /* Now we reset the device so we can clean up the queues. */ + vdev->config->reset(vdev); + + vdev->config->del_vqs(vdev); + + kfree(vps); +} + +static unsigned int features[] = { +}; + +static struct virtio_device_id id_table[] = { + { VIRTIO_ID_PSTORE, VIRTIO_DEV_ANY_ID }, + { 0 }, +}; + +static struct virtio_driver virtio_pstore_driver = { + .driver.name = KBUILD_MODNAME, + .driver.owner = THIS_MODULE, + .feature_table = features, + .feature_table_size = ARRAY_SIZE(features), + .id_table = id_table, + .probe = virtpstore_probe, + .remove = virtpstore_remove, +}; + +module_virtio_driver(virtio_pstore_driver); +MODULE_DEVICE_TABLE(virtio, id_table); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Namhyung Kim "); +MODULE_DESCRIPTION("Virtio pstore driver"); diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild index 6d4e92ccdc91..9bbb1554d8b2 100644 --- a/include/uapi/linux/Kbuild +++ b/include/uapi/linux/Kbuild @@ -449,6 +449,7 @@ header-y += virtio_ids.h header-y += virtio_input.h header-y += virtio_net.h header-y += virtio_pci.h +header-y += virtio_pstore.h header-y += virtio_ring.h header-y += virtio_rng.h header-y += virtio_scsi.h diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h index 77925f587b15..c72a9ab588c0 100644 --- a/include/uapi/linux/virtio_ids.h +++ b/include/uapi/linux/virtio_ids.h @@ -41,5 +41,6 @@ #define VIRTIO_ID_CAIF 12 /* Virtio caif */ #define VIRTIO_ID_GPU 16 /* virtio GPU */ #define VIRTIO_ID_INPUT 18 /* virtio input */ +#define VIRTIO_ID_PSTORE 22 /* virtio pstore */ #endif /* _LINUX_VIRTIO_IDS_H */ diff --git a/include/uapi/linux/virtio_pstore.h b/include/uapi/linux/virtio_pstore.h new file mode 100644 index 000000000000..f4b0d204d8ae --- /dev/null +++ b/include/uapi/linux/virtio_pstore.h @@ -0,0 +1,74 @@ +#ifndef _LINUX_VIRTIO_PSTORE_H +#define _LINUX_VIRTIO_PSTORE_H +/* This header is BSD licensed so anyone can use the definitions to implement + * compatible drivers/servers. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of IBM nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. */ +#include +#include + +#define VIRTIO_PSTORE_CMD_NULL 0 +#define VIRTIO_PSTORE_CMD_OPEN 1 +#define VIRTIO_PSTORE_CMD_READ 2 +#define VIRTIO_PSTORE_CMD_WRITE 3 +#define VIRTIO_PSTORE_CMD_ERASE 4 +#define VIRTIO_PSTORE_CMD_CLOSE 5 + +#define VIRTIO_PSTORE_TYPE_UNKNOWN 0 +#define VIRTIO_PSTORE_TYPE_DMESG 1 + +#define VIRTIO_PSTORE_FL_COMPRESSED 1 + +struct virtio_pstore_req { + __virtio16 cmd; + __virtio16 type; + __virtio32 flags; + __virtio64 id; + __virtio32 count; + __virtio32 reserved; +}; + +struct virtio_pstore_res { + __virtio16 cmd; + __virtio16 type; + __virtio32 ret; +}; + +struct virtio_pstore_fileinfo { + __virtio64 id; + __virtio32 count; + __virtio16 type; + __virtio16 unused; + __virtio32 flags; + __virtio32 len; + __virtio64 time_sec; + __virtio32 time_nsec; + __virtio32 reserved; +}; + +struct virtio_pstore_config { + __virtio32 bufsize; +}; + +#endif /* _LINUX_VIRTIO_PSTORE_H */ -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:37786) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bb1LH-00088M-GV for qemu-devel@nongnu.org; Sat, 20 Aug 2016 04:09:25 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1bb1LC-0000YX-F2 for qemu-devel@nongnu.org; Sat, 20 Aug 2016 04:09:22 -0400 Received: from mail-pa0-x243.google.com ([2607:f8b0:400e:c03::243]:33823) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bb1LB-0000YQ-WF for qemu-devel@nongnu.org; Sat, 20 Aug 2016 04:09:18 -0400 Received: by mail-pa0-x243.google.com with SMTP id hh10so4624828pac.1 for ; Sat, 20 Aug 2016 01:09:17 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim Date: Sat, 20 Aug 2016 17:07:42 +0900 Message-Id: <20160820080744.10344-2-namhyung@kernel.org> In-Reply-To: <20160820080744.10344-1-namhyung@kernel.org> References: <20160820080744.10344-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Subject: [Qemu-devel] [PATCH 1/3] virtio: Basic implementation of virtio pstore driver List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: virtio-dev@lists.oasis-open.org, kvm@vger.kernel.org, qemu-devel@nongnu.org, virtualization@lists.linux-foundation.org Cc: LKML , Paolo Bonzini , =?UTF-8?q?Radim=20Kr=C4=8Dm=C3=A1=C5=99?= , "Michael S. Tsirkin" , Anthony Liguori , Anton Vorontsov , Colin Cross , Kees Cook , Tony Luck , Steven Rostedt , Ingo Molnar , Minchan Kim The virtio pstore driver provides interface to the pstore subsystem so that the guest kernel's log/dump message can be saved on the host machine. Users can access the log file directly on the host, or on the guest at the next boot using pstore filesystem. It currently deals with kernel log (printk) buffer only, but we can extend it to have other information (like ftrace dump) later. It supports legacy PCI device using single order-2 page buffer. It uses two virtqueues - one for (sync) read and another for (async) write. Since it cannot wait for write finished, it supports up to 128 concurrent IO. The buffer size is configurable now. Cc: Paolo Bonzini Cc: Radim Krčmář Cc: "Michael S. Tsirkin" Cc: Anthony Liguori Cc: Anton Vorontsov Cc: Colin Cross Cc: Kees Cook Cc: Tony Luck Cc: Steven Rostedt Cc: Ingo Molnar Cc: Minchan Kim Cc: kvm@vger.kernel.org Cc: qemu-devel@nongnu.org Cc: virtualization@lists.linux-foundation.org Signed-off-by: Namhyung Kim --- drivers/virtio/Kconfig | 10 + drivers/virtio/Makefile | 1 + drivers/virtio/virtio_pstore.c | 417 +++++++++++++++++++++++++++++++++++++ include/uapi/linux/Kbuild | 1 + include/uapi/linux/virtio_ids.h | 1 + include/uapi/linux/virtio_pstore.h | 74 +++++++ 6 files changed, 504 insertions(+) create mode 100644 drivers/virtio/virtio_pstore.c create mode 100644 include/uapi/linux/virtio_pstore.h diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig index 77590320d44c..8f0e6c796c12 100644 --- a/drivers/virtio/Kconfig +++ b/drivers/virtio/Kconfig @@ -58,6 +58,16 @@ config VIRTIO_INPUT If unsure, say M. +config VIRTIO_PSTORE + tristate "Virtio pstore driver" + depends on VIRTIO + depends on PSTORE + ---help--- + This driver supports virtio pstore devices to save/restore + panic and oops messages on the host. + + If unsure, say M. + config VIRTIO_MMIO tristate "Platform bus driver for memory mapped virtio devices" depends on HAS_IOMEM && HAS_DMA diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile index 41e30e3dc842..bee68cb26d48 100644 --- a/drivers/virtio/Makefile +++ b/drivers/virtio/Makefile @@ -5,3 +5,4 @@ virtio_pci-y := virtio_pci_modern.o virtio_pci_common.o virtio_pci-$(CONFIG_VIRTIO_PCI_LEGACY) += virtio_pci_legacy.o obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o obj-$(CONFIG_VIRTIO_INPUT) += virtio_input.o +obj-$(CONFIG_VIRTIO_PSTORE) += virtio_pstore.o diff --git a/drivers/virtio/virtio_pstore.c b/drivers/virtio/virtio_pstore.c new file mode 100644 index 000000000000..0a63c7db4278 --- /dev/null +++ b/drivers/virtio/virtio_pstore.c @@ -0,0 +1,417 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include + +#define VIRT_PSTORE_ORDER 2 +#define VIRT_PSTORE_BUFSIZE (4096 << VIRT_PSTORE_ORDER) +#define VIRT_PSTORE_NR_REQ 128 + +struct virtio_pstore { + struct virtio_device *vdev; + struct virtqueue *vq[2]; + struct pstore_info pstore; + struct virtio_pstore_req req[VIRT_PSTORE_NR_REQ]; + struct virtio_pstore_res res[VIRT_PSTORE_NR_REQ]; + unsigned int req_id; + + /* Waiting for host to ack */ + wait_queue_head_t acked; + int failed; +}; + +#define TYPE_TABLE_ENTRY(_entry) \ + { PSTORE_TYPE_##_entry, VIRTIO_PSTORE_TYPE_##_entry } + +struct type_table { + int pstore; + u16 virtio; +} type_table[] = { + TYPE_TABLE_ENTRY(DMESG), +}; + +#undef TYPE_TABLE_ENTRY + + +static u16 to_virtio_type(struct virtio_pstore *vps, enum pstore_type_id type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(type_table); i++) { + if (type == type_table[i].pstore) + return cpu_to_virtio16(vps->vdev, type_table[i].virtio); + } + + return cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_TYPE_UNKNOWN); +} + +static enum pstore_type_id from_virtio_type(struct virtio_pstore *vps, u16 type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(type_table); i++) { + if (virtio16_to_cpu(vps->vdev, type) == type_table[i].virtio) + return type_table[i].pstore; + } + + return PSTORE_TYPE_UNKNOWN; +} + +static void virtpstore_ack(struct virtqueue *vq) +{ + struct virtio_pstore *vps = vq->vdev->priv; + + wake_up(&vps->acked); +} + +static void virtpstore_check(struct virtqueue *vq) +{ + struct virtio_pstore *vps = vq->vdev->priv; + struct virtio_pstore_res *res; + unsigned int len; + + res = virtqueue_get_buf(vq, &len); + if (res == NULL) + return; + + if (virtio32_to_cpu(vq->vdev, res->ret) < 0) + vps->failed = 1; +} + +static void virt_pstore_get_reqs(struct virtio_pstore *vps, + struct virtio_pstore_req **preq, + struct virtio_pstore_res **pres) +{ + unsigned int idx = vps->req_id++ % VIRT_PSTORE_NR_REQ; + + *preq = &vps->req[idx]; + *pres = &vps->res[idx]; + + memset(*preq, 0, sizeof(**preq)); + memset(*pres, 0, sizeof(**pres)); +} + +static int virt_pstore_open(struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct scatterlist sgo[1], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_OPEN); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + return virtio32_to_cpu(vps->vdev, res->ret); +} + +static int virt_pstore_close(struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req = &vps->req[vps->req_id]; + struct virtio_pstore_res *res = &vps->res[vps->req_id]; + struct scatterlist sgo[1], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_CLOSE); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + return virtio32_to_cpu(vps->vdev, res->ret); +} + +static ssize_t virt_pstore_read(u64 *id, enum pstore_type_id *type, + int *count, struct timespec *time, + char **buf, bool *compressed, + ssize_t *ecc_notice_size, + struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct virtio_pstore_fileinfo info; + struct scatterlist sgo[1], sgi[3]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + unsigned int flags; + int ret; + void *bf; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_READ); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_table(sgi, 3); + sg_set_buf(&sgi[0], res, sizeof(*res)); + sg_set_buf(&sgi[1], &info, sizeof(info)); + sg_set_buf(&sgi[2], psi->buf, psi->bufsize); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + if (len < sizeof(*res) + sizeof(info)) + return -1; + + ret = virtio32_to_cpu(vps->vdev, res->ret); + if (ret < 0) + return ret; + + len = virtio32_to_cpu(vps->vdev, info.len); + + bf = kmalloc(len, GFP_KERNEL); + if (bf == NULL) + return -ENOMEM; + + *id = virtio64_to_cpu(vps->vdev, info.id); + *type = from_virtio_type(vps, info.type); + *count = virtio32_to_cpu(vps->vdev, info.count); + + flags = virtio32_to_cpu(vps->vdev, info.flags); + *compressed = flags & VIRTIO_PSTORE_FL_COMPRESSED; + + time->tv_sec = virtio64_to_cpu(vps->vdev, info.time_sec); + time->tv_nsec = virtio32_to_cpu(vps->vdev, info.time_nsec); + + memcpy(bf, psi->buf, len); + *buf = bf; + + return len; +} + +static int notrace virt_pstore_write(enum pstore_type_id type, + enum kmsg_dump_reason reason, + u64 *id, unsigned int part, int count, + bool compressed, size_t size, + struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct scatterlist sgo[2], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int flags = compressed ? VIRTIO_PSTORE_FL_COMPRESSED : 0; + + if (vps->failed) + return -1; + + *id = vps->req_id; + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_WRITE); + req->type = to_virtio_type(vps, type); + req->flags = cpu_to_virtio32(vps->vdev, flags); + + sg_init_table(sgo, 2); + sg_set_buf(&sgo[0], req, sizeof(*req)); + sg_set_buf(&sgo[1], pstore_get_buf(psi), size); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[1], sgs, 1, 1, vps, GFP_ATOMIC); + virtqueue_kick(vps->vq[1]); + + return 0; +} + +static int virt_pstore_erase(enum pstore_type_id type, u64 id, int count, + struct timespec time, struct pstore_info *psi) +{ + struct virtio_pstore *vps = psi->data; + struct virtio_pstore_req *req; + struct virtio_pstore_res *res; + struct scatterlist sgo[1], sgi[1]; + struct scatterlist *sgs[2] = { sgo, sgi }; + unsigned int len; + + virt_pstore_get_reqs(vps, &req, &res); + + req->cmd = cpu_to_virtio16(vps->vdev, VIRTIO_PSTORE_CMD_ERASE); + req->type = to_virtio_type(vps, type); + req->id = cpu_to_virtio64(vps->vdev, id); + req->count = cpu_to_virtio32(vps->vdev, count); + + sg_init_one(sgo, req, sizeof(*req)); + sg_init_one(sgi, res, sizeof(*res)); + virtqueue_add_sgs(vps->vq[0], sgs, 1, 1, vps, GFP_KERNEL); + virtqueue_kick(vps->vq[0]); + + wait_event(vps->acked, virtqueue_get_buf(vps->vq[0], &len)); + return virtio32_to_cpu(vps->vdev, res->ret); +} + +static int virt_pstore_init(struct virtio_pstore *vps) +{ + struct pstore_info *psinfo = &vps->pstore; + int err; + + if (!psinfo->bufsize) + psinfo->bufsize = VIRT_PSTORE_BUFSIZE; + + psinfo->buf = alloc_pages_exact(psinfo->bufsize, GFP_KERNEL); + if (!psinfo->buf) { + pr_err("cannot allocate pstore buffer\n"); + return -ENOMEM; + } + + psinfo->owner = THIS_MODULE; + psinfo->name = "virtio"; + psinfo->open = virt_pstore_open; + psinfo->close = virt_pstore_close; + psinfo->read = virt_pstore_read; + psinfo->erase = virt_pstore_erase; + psinfo->write = virt_pstore_write; + psinfo->flags = PSTORE_FLAGS_DMESG; + + psinfo->data = vps; + spin_lock_init(&psinfo->buf_lock); + + err = pstore_register(psinfo); + if (err) + kfree(psinfo->buf); + + return err; +} + +static int virt_pstore_exit(struct virtio_pstore *vps) +{ + struct pstore_info *psinfo = &vps->pstore; + + pstore_unregister(psinfo); + + free_pages_exact(psinfo->buf, psinfo->bufsize); + psinfo->buf = NULL; + psinfo->bufsize = 0; + + return 0; +} + +static int virtpstore_init_vqs(struct virtio_pstore *vps) +{ + vq_callback_t *callbacks[] = { virtpstore_ack, virtpstore_check }; + const char *names[] = { "pstore_read", "pstore_write" }; + + return vps->vdev->config->find_vqs(vps->vdev, 2, vps->vq, + callbacks, names); +} + +static void virtpstore_init_config(struct virtio_pstore *vps) +{ + u32 bufsize; + + virtio_cread(vps->vdev, struct virtio_pstore_config, bufsize, &bufsize); + + vps->pstore.bufsize = PAGE_ALIGN(bufsize); +} + +static void virtpstore_confirm_config(struct virtio_pstore *vps) +{ + u32 bufsize = vps->pstore.bufsize; + + virtio_cwrite(vps->vdev, struct virtio_pstore_config, bufsize, + &bufsize); +} + +static int virtpstore_probe(struct virtio_device *vdev) +{ + struct virtio_pstore *vps; + int err; + + if (!vdev->config->get) { + dev_err(&vdev->dev, "driver init: config access disabled\n"); + return -EINVAL; + } + + vdev->priv = vps = kzalloc(sizeof(*vps), GFP_KERNEL); + if (!vps) { + err = -ENOMEM; + goto out; + } + vps->vdev = vdev; + + err = virtpstore_init_vqs(vps); + if (err < 0) + goto out_free; + + virtpstore_init_config(vps); + + err = virt_pstore_init(vps); + if (err) + goto out_del_vq; + + virtpstore_confirm_config(vps); + + init_waitqueue_head(&vps->acked); + + virtio_device_ready(vdev); + + dev_info(&vdev->dev, "driver init: ok (bufsize = %luK, flags = %x)\n", + vps->pstore.bufsize >> 10, vps->pstore.flags); + + return 0; + +out_del_vq: + vdev->config->del_vqs(vdev); +out_free: + kfree(vps); +out: + dev_err(&vdev->dev, "driver init: failed with %d\n", err); + return err; +} + +static void virtpstore_remove(struct virtio_device *vdev) +{ + struct virtio_pstore *vps = vdev->priv; + + virt_pstore_exit(vps); + + /* Now we reset the device so we can clean up the queues. */ + vdev->config->reset(vdev); + + vdev->config->del_vqs(vdev); + + kfree(vps); +} + +static unsigned int features[] = { +}; + +static struct virtio_device_id id_table[] = { + { VIRTIO_ID_PSTORE, VIRTIO_DEV_ANY_ID }, + { 0 }, +}; + +static struct virtio_driver virtio_pstore_driver = { + .driver.name = KBUILD_MODNAME, + .driver.owner = THIS_MODULE, + .feature_table = features, + .feature_table_size = ARRAY_SIZE(features), + .id_table = id_table, + .probe = virtpstore_probe, + .remove = virtpstore_remove, +}; + +module_virtio_driver(virtio_pstore_driver); +MODULE_DEVICE_TABLE(virtio, id_table); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Namhyung Kim "); +MODULE_DESCRIPTION("Virtio pstore driver"); diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild index 6d4e92ccdc91..9bbb1554d8b2 100644 --- a/include/uapi/linux/Kbuild +++ b/include/uapi/linux/Kbuild @@ -449,6 +449,7 @@ header-y += virtio_ids.h header-y += virtio_input.h header-y += virtio_net.h header-y += virtio_pci.h +header-y += virtio_pstore.h header-y += virtio_ring.h header-y += virtio_rng.h header-y += virtio_scsi.h diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h index 77925f587b15..c72a9ab588c0 100644 --- a/include/uapi/linux/virtio_ids.h +++ b/include/uapi/linux/virtio_ids.h @@ -41,5 +41,6 @@ #define VIRTIO_ID_CAIF 12 /* Virtio caif */ #define VIRTIO_ID_GPU 16 /* virtio GPU */ #define VIRTIO_ID_INPUT 18 /* virtio input */ +#define VIRTIO_ID_PSTORE 22 /* virtio pstore */ #endif /* _LINUX_VIRTIO_IDS_H */ diff --git a/include/uapi/linux/virtio_pstore.h b/include/uapi/linux/virtio_pstore.h new file mode 100644 index 000000000000..f4b0d204d8ae --- /dev/null +++ b/include/uapi/linux/virtio_pstore.h @@ -0,0 +1,74 @@ +#ifndef _LINUX_VIRTIO_PSTORE_H +#define _LINUX_VIRTIO_PSTORE_H +/* This header is BSD licensed so anyone can use the definitions to implement + * compatible drivers/servers. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of IBM nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. */ +#include +#include + +#define VIRTIO_PSTORE_CMD_NULL 0 +#define VIRTIO_PSTORE_CMD_OPEN 1 +#define VIRTIO_PSTORE_CMD_READ 2 +#define VIRTIO_PSTORE_CMD_WRITE 3 +#define VIRTIO_PSTORE_CMD_ERASE 4 +#define VIRTIO_PSTORE_CMD_CLOSE 5 + +#define VIRTIO_PSTORE_TYPE_UNKNOWN 0 +#define VIRTIO_PSTORE_TYPE_DMESG 1 + +#define VIRTIO_PSTORE_FL_COMPRESSED 1 + +struct virtio_pstore_req { + __virtio16 cmd; + __virtio16 type; + __virtio32 flags; + __virtio64 id; + __virtio32 count; + __virtio32 reserved; +}; + +struct virtio_pstore_res { + __virtio16 cmd; + __virtio16 type; + __virtio32 ret; +}; + +struct virtio_pstore_fileinfo { + __virtio64 id; + __virtio32 count; + __virtio16 type; + __virtio16 unused; + __virtio32 flags; + __virtio32 len; + __virtio64 time_sec; + __virtio32 time_nsec; + __virtio32 reserved; +}; + +struct virtio_pstore_config { + __virtio32 bufsize; +}; + +#endif /* _LINUX_VIRTIO_PSTORE_H */ -- 2.9.3