From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paul Durrant Subject: [PATCH v3 03/18] xen: introduce 'xen-block', 'xen-disk' and 'xen-cdrom' Date: Tue, 11 Dec 2018 10:47:03 +0000 Message-ID: <1544525238-3527-4-git-send-email-paul.durrant@citrix.com> References: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1gWfZf-0004vk-W9 for xen-devel@lists.xenproject.org; Tue, 11 Dec 2018 10:47:36 +0000 In-Reply-To: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: qemu-devel@nongnu.org, qemu-block@nongnu.org, xen-devel@lists.xenproject.org Cc: Kevin Wolf , Anthony Perard , Paul Durrant , Stefano Stabellini , Max Reitz List-Id: xen-devel@lists.xenproject.org VGhpcyBwYXRjaCBhZGRzIG5ldyBYZW5EZXZpY2UtczogJ3hlbi1kaXNrJyBhbmQgJ3hlbi1jZHJv bScsIGJvdGggZGVyaXZlZApmcm9tIGEgY29tbW9uICd4ZW4tYmxvY2snIHBhcmVudCB0eXBlLiBU aGVzZSB3aWxsIGV2ZW50dWFsbHkgcmVwbGFjZSB0aGUKJ3hlbl9kaXNrJyAobm90ZSB0aGUgdW5k ZXJzY29yZSByYXRoZXIgdGhhbiBoeXBoZW4pIGxlZ2FjeSBQViBiYWNrZW5kIGJ1dAppdCBpcyBp bGx1c3RyYXRpdmUgdG8gYnVpbGQgdXAgdGhlIGltcGxlbWVudGF0aW9uIGluY3JlbWVudGFsbHks IGFsb25nIHdpdGgKdGhlIFhlbkJ1cy9YZW5EZXZpY2UgZnJhbWV3b3JrLiBTdWJzZXF1ZW50IHBh dGNoZXMgd2lsbCB0aGVyZWZvcmUgYWRkIHRvCnRoZXNlIGRldmljZXMnIGltcGxlbWVudGF0aW9u IGFzIG5ldyBmZWF0dXJlcyBhcmUgYWRkZWQgdG8gdGhlIGZyYW1ld29yay4KCkFmdGVyIHRoaXMg cGF0Y2ggaGFzIGJlZW4gYXBwbGllZCBpdCBpcyBwb3NzaWJsZSB0byBpbnN0YW50aWF0ZSBuZXcK J3hlbi1kaXNrJyBvciAneGVuLWNkcm9tJyBkZXZpY2VzIHdpdGggYSBzaW5nbGUgJ3ZkZXYnIHBh cmFtZXRlciwgd2hpY2gKYWNjZXB0cyB2YWx1ZXMgYWRoZXJpbmcgdG8gdGhlIFhlbiBWQkQgbmFt aW5nIHNjaGVtZSBbMV0uIEZvciBleGFtcGxlLCBhCmNvbW1hbmQtbGluZSBpbnN0YW50aWF0aW9u IG9mIGEgeGVuLWRpc2sgY2FuIGJlIGRvbmUgd2l0aCBhbiBhcmd1bWVudApzaW1pbGFyIHRvIHRo ZSBmb2xsb3dpbmc6CgotZGV2aWNlIHhlbi1kaXNrLHZkZXY9aGRhCgpUaGUgaW1wbGVtZW50YXRp b24gb2YgdGhlIHZkZXYgcGFyYW1ldGVyIGZvcm11bGF0ZXMgdGhlIGFwcHJvcHJpYXRlIFZCRApu dW1iZXIgZm9yIHVzZSBpbiB0aGUgUFYgcHJvdG9jb2wuCgpbMV0gaHR0cHM6Ly94ZW5iaXRzLnhl bi5vcmcvZG9jcy91bnN0YWJsZS9tYW4veGVuLXZiZC1pbnRlcmZhY2UuNy5odG1sCgpTaWduZWQt b2ZmLWJ5OiBQYXVsIER1cnJhbnQgPHBhdWwuZHVycmFudEBjaXRyaXguY29tPgotLS0KQ2M6IEtl dmluIFdvbGYgPGt3b2xmQHJlZGhhdC5jb20+CkNjOiBNYXggUmVpdHogPG1yZWl0ekByZWRoYXQu Y29tPgpDYzogU3RlZmFubyBTdGFiZWxsaW5pIDxzc3RhYmVsbGluaUBrZXJuZWwub3JnPgpDYzog QW50aG9ueSBQZXJhcmQgPGFudGhvbnkucGVyYXJkQGNpdHJpeC5jb20+Cgp2MzoKIC0gRml4IHZk ZXYgcGFyc2luZyBhZ2FpbiwgYW5kIHZkZXYgZm9ybWF0dGluZyB0aGlzIHRpbWUKIC0gUmVtb3Zl IGFuIHVubmVjZXNzYXJ5IGxvY2FsX2VycgoKdjI6CiAtIEZpeCBib2lsZXJwbGF0ZQogLSBGaXgg dmRldiBwYXJzaW5nCiAtIENoYW5nZSBuYW1lIGZyb20gJ3hlbi1xZGlzaycgdG8gJ3hlbi1ibG9j aycsIG1ha2UgYWJzdHJhY3QsIGFuZCBzcGxpdAogICBvZmYgJ3hlbi1kaXNrJyBhbmQgJ3hlbi1j ZHJvbScgYXMgY29uY3JldGUgc3ViLXR5cGVzCi0tLQogTUFJTlRBSU5FUlMgICAgICAgICAgICAg ICAgfCAgIDIgKy0KIGh3L2Jsb2NrL01ha2VmaWxlLm9ianMgICAgIHwgICAxICsKIGh3L2Jsb2Nr L3RyYWNlLWV2ZW50cyAgICAgIHwgICA4ICsrCiBody9ibG9jay94ZW4tYmxvY2suYyAgICAgICB8 IDM0MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGluY2x1 ZGUvaHcveGVuL3hlbi1ibG9jay5oIHwgIDY5ICsrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCA0 MjIgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGh3L2Js b2NrL3hlbi1ibG9jay5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9ody94ZW4veGVuLWJs b2NrLmgKCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDYzZWZm ZGMuLmRkNzI4YzMgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBA IC00MDMsNyArNDAzLDcgQEAgRjogaHcvOXBmcy94ZW4tOXAtYmFja2VuZC5jCiBGOiBody9jaGFy L3hlbl9jb25zb2xlLmMKIEY6IGh3L2Rpc3BsYXkveGVuZmIuYwogRjogaHcvbmV0L3hlbl9uaWMu YwotRjogaHcvYmxvY2sveGVuXyoKK0Y6IGh3L2Jsb2NrL3hlbioKIEY6IGh3L3hlbi8KIEY6IGh3 L3hlbnB2LwogRjogaHcvaTM4Ni94ZW4vCmRpZmYgLS1naXQgYS9ody9ibG9jay9NYWtlZmlsZS5v YmpzIGIvaHcvYmxvY2svTWFrZWZpbGUub2JqcwppbmRleCA1M2NlNTc1Li5mMzQ4MTNhIDEwMDY0 NAotLS0gYS9ody9ibG9jay9NYWtlZmlsZS5vYmpzCisrKyBiL2h3L2Jsb2NrL01ha2VmaWxlLm9i anMKQEAgLTQsNiArNCw3IEBAIGNvbW1vbi1vYmotJChDT05GSUdfU1NJX00yNVA4MCkgKz0gbTI1 cDgwLm8KIGNvbW1vbi1vYmotJChDT05GSUdfTkFORCkgKz0gbmFuZC5vCiBjb21tb24tb2JqLSQo Q09ORklHX1BGTEFTSF9DRkkwMSkgKz0gcGZsYXNoX2NmaTAxLm8KIGNvbW1vbi1vYmotJChDT05G SUdfUEZMQVNIX0NGSTAyKSArPSBwZmxhc2hfY2ZpMDIubworY29tbW9uLW9iai0kKENPTkZJR19Y RU4pICs9IHhlbi1ibG9jay5vCiBjb21tb24tb2JqLSQoQ09ORklHX1hFTikgKz0geGVuX2Rpc2su bwogY29tbW9uLW9iai0kKENPTkZJR19FQ0MpICs9IGVjYy5vCiBjb21tb24tb2JqLSQoQ09ORklH X09ORU5BTkQpICs9IG9uZW5hbmQubwpkaWZmIC0tZ2l0IGEvaHcvYmxvY2svdHJhY2UtZXZlbnRz IGIvaHcvYmxvY2svdHJhY2UtZXZlbnRzCmluZGV4IDMzNWMwOTIuLjRhZmJkNjIgMTAwNjQ0Ci0t LSBhL2h3L2Jsb2NrL3RyYWNlLWV2ZW50cworKysgYi9ody9ibG9jay90cmFjZS1ldmVudHMKQEAg LTEyNywzICsxMjcsMTEgQEAgeGVuX2Rpc2tfaW5pdChjaGFyICpuYW1lKSAiJXMiCiB4ZW5fZGlz a19jb25uZWN0KGNoYXIgKm5hbWUpICIlcyIKIHhlbl9kaXNrX2Rpc2Nvbm5lY3QoY2hhciAqbmFt ZSkgIiVzIgogeGVuX2Rpc2tfZnJlZShjaGFyICpuYW1lKSAiJXMiCisKKyMgaHcvYmxvY2sveGVu LWJsb2NrLmMKK3hlbl9ibG9ja19yZWFsaXplKGNvbnN0IGNoYXIgKnR5cGUsIHVpbnQzMl90IGRp c2ssIHVpbnQzMl90IHBhcnRpdGlvbikgIiVzIGQldXAldSIKK3hlbl9ibG9ja191bnJlYWxpemUo Y29uc3QgY2hhciAqdHlwZSwgdWludDMyX3QgZGlzaywgdWludDMyX3QgcGFydGl0aW9uKSAiJXMg ZCV1cCV1IgoreGVuX2Rpc2tfcmVhbGl6ZSh2b2lkKSAiIgoreGVuX2Rpc2tfdW5yZWFsaXplKHZv aWQpICIiCit4ZW5fY2Ryb21fcmVhbGl6ZSh2b2lkKSAiIgoreGVuX2Nkcm9tX3VucmVhbGl6ZSh2 b2lkKSAiIgpkaWZmIC0tZ2l0IGEvaHcvYmxvY2sveGVuLWJsb2NrLmMgYi9ody9ibG9jay94ZW4t YmxvY2suYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMjlhY2IwCi0tLSAv ZGV2L251bGwKKysrIGIvaHcvYmxvY2sveGVuLWJsb2NrLmMKQEAgLTAsMCArMSwzNDMgQEAKKy8q CisgKiBDb3B5cmlnaHQgKGMpIDIwMTggIENpdHJpeCBTeXN0ZW1zIEluYy4KKyAqCisgKiBUaGlz IHdvcmsgaXMgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR1BMLCB2ZXJzaW9u IDIgb3IgbGF0ZXIuCisgKiBTZWUgdGhlIENPUFlJTkcgZmlsZSBpbiB0aGUgdG9wLWxldmVsIGRp cmVjdG9yeS4KKyAqLworCisjaW5jbHVkZSAicWVtdS9vc2RlcC5oIgorI2luY2x1ZGUgInFlbXUv Y3V0aWxzLmgiCisjaW5jbHVkZSAicWFwaS9lcnJvci5oIgorI2luY2x1ZGUgInFhcGkvdmlzaXRv ci5oIgorI2luY2x1ZGUgImh3L2h3LmgiCisjaW5jbHVkZSAiaHcveGVuL3hlbi1ibG9jay5oIgor I2luY2x1ZGUgInRyYWNlLmgiCisKK3N0YXRpYyB2b2lkIHhlbl9ibG9ja191bnJlYWxpemUoWGVu RGV2aWNlICp4ZW5kZXYsIEVycm9yICoqZXJycCkKK3sKKyAgICBYZW5CbG9ja0RldmljZSAqYmxv Y2tkZXYgPSBYRU5fQkxPQ0tfREVWSUNFKHhlbmRldik7CisgICAgWGVuQmxvY2tEZXZpY2VDbGFz cyAqYmxvY2tkZXZfY2xhc3MgPQorICAgICAgICBYRU5fQkxPQ0tfREVWSUNFX0dFVF9DTEFTUyh4 ZW5kZXYpOworICAgIGNvbnN0IGNoYXIgKnR5cGUgPSBvYmplY3RfZ2V0X3R5cGVuYW1lKE9CSkVD VChibG9ja2RldikpOworICAgIFhlbkJsb2NrVmRldiAqdmRldiA9ICZibG9ja2Rldi0+dmRldjsK KworICAgIGlmICh2ZGV2LT50eXBlID09IFhFTl9CTE9DS19WREVWX1RZUEVfSU5WQUxJRCkgewor ICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgdHJhY2VfeGVuX2Jsb2NrX3VucmVhbGl6ZSh0 eXBlLCB2ZGV2LT5kaXNrLCB2ZGV2LT5wYXJ0aXRpb24pOworCisgICAgaWYgKGJsb2NrZGV2X2Ns YXNzLT51bnJlYWxpemUpIHsKKyAgICAgICAgYmxvY2tkZXZfY2xhc3MtPnVucmVhbGl6ZShibG9j a2RldiwgZXJycCk7CisgICAgfQorfQorCitzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfcmVhbGl6ZShY ZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQoreworICAgIFhlbkJsb2NrRGV2aWNlICpi bG9ja2RldiA9IFhFTl9CTE9DS19ERVZJQ0UoeGVuZGV2KTsKKyAgICBYZW5CbG9ja0RldmljZUNs YXNzICpibG9ja2Rldl9jbGFzcyA9CisgICAgICAgIFhFTl9CTE9DS19ERVZJQ0VfR0VUX0NMQVNT KHhlbmRldik7CisgICAgY29uc3QgY2hhciAqdHlwZSA9IG9iamVjdF9nZXRfdHlwZW5hbWUoT0JK RUNUKGJsb2NrZGV2KSk7CisgICAgWGVuQmxvY2tWZGV2ICp2ZGV2ID0gJmJsb2NrZGV2LT52ZGV2 OworICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOworCisgICAgaWYgKHZkZXYtPnR5cGUgPT0g WEVOX0JMT0NLX1ZERVZfVFlQRV9JTlZBTElEKSB7CisgICAgICAgIGVycm9yX3NldGcoZXJycCwg InZkZXYgcHJvcGVydHkgbm90IHNldCIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg dHJhY2VfeGVuX2Jsb2NrX3JlYWxpemUodHlwZSwgdmRldi0+ZGlzaywgdmRldi0+cGFydGl0aW9u KTsKKworICAgIGlmIChibG9ja2Rldl9jbGFzcy0+cmVhbGl6ZSkgeworICAgICAgICBibG9ja2Rl dl9jbGFzcy0+cmVhbGl6ZShibG9ja2RldiwgJmxvY2FsX2Vycik7CisgICAgICAgIGlmIChsb2Nh bF9lcnIpIHsKKyAgICAgICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOwor ICAgICAgICB9CisgICAgfQorfQorCitzdGF0aWMgY2hhciAqZGlza190b192YmRfbmFtZSh1bnNp Z25lZCBpbnQgZGlzaykKK3sKKyAgICBjaGFyICpuYW1lLCAqcHJlZml4ID0gKGRpc2sgPj0gMjYp ID8KKyAgICAgICAgZGlza190b192YmRfbmFtZSgoZGlzayAvIDI2KSAtIDEpIDogZ19zdHJkdXAo IiIpOworCisgICAgbmFtZSA9IGdfc3RyZHVwX3ByaW50ZigiJXMlYyIsIHByZWZpeCwgJ2EnICsg ZGlzayAlIDI2KTsKKyAgICBnX2ZyZWUocHJlZml4KTsKKworICAgIHJldHVybiBuYW1lOworfQor CitzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZ2V0X3ZkZXYoT2JqZWN0ICpvYmosIFZpc2l0b3IgKnYs IGNvbnN0IGNoYXIgKm5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdm9pZCAq b3BhcXVlLCBFcnJvciAqKmVycnApCit7CisgICAgRGV2aWNlU3RhdGUgKmRldiA9IERFVklDRShv YmopOworICAgIFByb3BlcnR5ICpwcm9wID0gb3BhcXVlOworICAgIFhlbkJsb2NrVmRldiAqdmRl diA9IHFkZXZfZ2V0X3Byb3BfcHRyKGRldiwgcHJvcCk7CisgICAgY2hhciAqc3RyOworCisgICAg c3dpdGNoICh2ZGV2LT50eXBlKSB7CisgICAgY2FzZSBYRU5fQkxPQ0tfVkRFVl9UWVBFX0RQOgor ICAgICAgICBzdHIgPSBnX3N0cmR1cF9wcmludGYoImQlbHVwJWx1IiwgdmRldi0+ZGlzaywgdmRl di0+cGFydGl0aW9uKTsKKyAgICAgICAgYnJlYWs7CisKKyAgICBjYXNlIFhFTl9CTE9DS19WREVW X1RZUEVfWFZEOgorICAgIGNhc2UgWEVOX0JMT0NLX1ZERVZfVFlQRV9IRDoKKyAgICBjYXNlIFhF Tl9CTE9DS19WREVWX1RZUEVfU0Q6IHsKKyAgICAgICAgY2hhciAqbmFtZSA9IGRpc2tfdG9fdmJk X25hbWUodmRldi0+ZGlzayk7CisKKyAgICAgICAgc3RyID0gZ19zdHJkdXBfcHJpbnRmKCIlcyVz JWx1IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICh2ZGV2LT50eXBlID09IFhFTl9C TE9DS19WREVWX1RZUEVfWFZEKSA/CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAieHZk IiA6CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAodmRldi0+dHlwZSA9PSBYRU5fQkxP Q0tfVkRFVl9UWVBFX0hEKSA/CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiaGQiIDoK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJzZCIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBuYW1lLCB2ZGV2LT5wYXJ0aXRpb24pOworICAgICAgICBnX2ZyZWUobmFtZSk7 CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICBkZWZhdWx0OgorICAgICAgICBlcnJvcl9zZXRn KGVycnAsICJpbnZhbGlkIHZkZXYgdHlwZSIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgdmlzaXRfdHlwZV9zdHIodiwgbmFtZSwgJnN0ciwgZXJycCk7CisgICAgZ19mcmVlKHN0cik7 Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBpbnQgdmJkX25hbWVfdG9fZGlzayhjb25zdCBjaGFyICpu YW1lLCBjb25zdCBjaGFyICoqZW5kcCkKK3sKKyAgICB1bnNpZ25lZCBpbnQgZGlzayA9IDA7CisK KyAgICB3aGlsZSAoKm5hbWUgIT0gJ1wwJykgeworICAgICAgICBpZiAoIWdfYXNjaWlfaXNhbHBo YSgqbmFtZSkgfHwgIWdfYXNjaWlfaXNsb3dlcigqbmFtZSkpIHsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICB9CisKKyAgICAgICAgZGlzayAqPSAyNjsKKyAgICAgICAgZGlzayArPSAqbmFt ZSsrIC0gJ2EnICsgMTsKKyAgICB9CisgICAgKmVuZHAgPSBuYW1lOworCisgICAgcmV0dXJuIGRp c2sgLSAxOworfQorCitzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfc2V0X3ZkZXYoT2JqZWN0ICpvYmos IFZpc2l0b3IgKnYsIGNvbnN0IGNoYXIgKm5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdm9pZCAqb3BhcXVlLCBFcnJvciAqKmVycnApCit7CisgICAgRGV2aWNlU3RhdGUgKmRl diA9IERFVklDRShvYmopOworICAgIFByb3BlcnR5ICpwcm9wID0gb3BhcXVlOworICAgIFhlbkJs b2NrVmRldiAqdmRldiA9IHFkZXZfZ2V0X3Byb3BfcHRyKGRldiwgcHJvcCk7CisgICAgRXJyb3Ig KmxvY2FsX2VyciA9IE5VTEw7CisgICAgY2hhciAqc3RyLCAqcDsKKyAgICBjb25zdCBjaGFyICpl bmQ7CisKKyAgICBpZiAoZGV2LT5yZWFsaXplZCkgeworICAgICAgICBxZGV2X3Byb3Bfc2V0X2Fm dGVyX3JlYWxpemUoZGV2LCBuYW1lLCBlcnJwKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwor ICAgIHZpc2l0X3R5cGVfc3RyKHYsIG5hbWUsICZzdHIsICZsb2NhbF9lcnIpOworICAgIGlmIChs b2NhbF9lcnIpIHsKKyAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBwID0gc3RyY2hyKHN0ciwgJ2QnKTsKKyAgICBp ZiAoIXApIHsKKyAgICAgICAgZ290byBpbnZhbGlkOworICAgIH0KKworICAgICpwKysgPSAnXDAn OworICAgIGlmICgqc3RyID09ICdcMCcpIHsKKyAgICAgICAgdmRldi0+dHlwZSA9IFhFTl9CTE9D S19WREVWX1RZUEVfRFA7CisgICAgfSBlbHNlIGlmIChzdHJjbXAoc3RyLCAieHYiKSA9PSAwKSB7 CisgICAgICAgIHZkZXYtPnR5cGUgPSBYRU5fQkxPQ0tfVkRFVl9UWVBFX1hWRDsKKyAgICB9IGVs c2UgaWYgKHN0cmNtcChzdHIsICJoIikgPT0gMCkgeworICAgICAgICB2ZGV2LT50eXBlID0gWEVO X0JMT0NLX1ZERVZfVFlQRV9IRDsKKyAgICB9IGVsc2UgaWYgKHN0cmNtcChzdHIsICJzIikgPT0g MCkgeworICAgICAgICB2ZGV2LT50eXBlID0gWEVOX0JMT0NLX1ZERVZfVFlQRV9TRDsKKyAgICB9 IGVsc2UgeworICAgICAgICBnb3RvIGludmFsaWQ7CisgICAgfQorCisgICAgaWYgKHZkZXYtPnR5 cGUgPT0gWEVOX0JMT0NLX1ZERVZfVFlQRV9EUCkgeworICAgICAgICBpZiAocWVtdV9zdHJ0b3Vs KHAsICZlbmQsIDEwLCAmdmRldi0+ZGlzaykpIHsKKyAgICAgICAgICAgIGdvdG8gaW52YWxpZDsK KyAgICAgICAgfQorCisgICAgICAgIGlmICgqZW5kID09ICdwJykgeworICAgICAgICAgICAgcCA9 IChjaGFyICopICsrZW5kOworICAgICAgICAgICAgaWYgKCplbmQgPT0gJ1wwJykgeworICAgICAg ICAgICAgICAgIGdvdG8gaW52YWxpZDsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0g ZWxzZSB7CisgICAgICAgIHZkZXYtPmRpc2sgPSB2YmRfbmFtZV90b19kaXNrKHAsICZlbmQpOwor ICAgIH0KKworICAgIGlmICgqZW5kICE9ICdcMCcpIHsKKyAgICAgICAgcCA9IChjaGFyICopZW5k OworCisgICAgICAgIGlmIChxZW11X3N0cnRvdWwocCwgJmVuZCwgMTAsICZ2ZGV2LT5wYXJ0aXRp b24pKSB7CisgICAgICAgICAgICBnb3RvIGludmFsaWQ7CisgICAgICAgIH0KKworICAgICAgICBp ZiAoKmVuZCAhPSAnXDAnKSB7CisgICAgICAgICAgICBnb3RvIGludmFsaWQ7CisgICAgICAgIH0K KyAgICB9IGVsc2UgeworICAgICAgICB2ZGV2LT5wYXJ0aXRpb24gPSAwOworICAgIH0KKworICAg IHN3aXRjaCAodmRldi0+dHlwZSkgeworICAgIGNhc2UgWEVOX0JMT0NLX1ZERVZfVFlQRV9EUDoK KyAgICBjYXNlIFhFTl9CTE9DS19WREVWX1RZUEVfWFZEOgorICAgICAgICBpZiAodmRldi0+ZGlz ayA8ICgxIDw8IDQpICYmIHZkZXYtPnBhcnRpdGlvbiA8ICgxIDw8IDQpKSB7CisgICAgICAgICAg ICB2ZGV2LT5udW1iZXIgPSAoMjAyIDw8IDgpIHwgKHZkZXYtPmRpc2sgPDwgNCkgfAorICAgICAg ICAgICAgICAgIHZkZXYtPnBhcnRpdGlvbjsKKyAgICAgICAgfSBlbHNlIGlmICh2ZGV2LT5kaXNr IDwgKDEgPDwgMjApICYmIHZkZXYtPnBhcnRpdGlvbiA8ICgxIDw8IDgpKSB7CisgICAgICAgICAg ICB2ZGV2LT5udW1iZXIgPSAoMSA8PCAyOCkgfCAodmRldi0+ZGlzayA8PCA4KSB8CisgICAgICAg ICAgICAgICAgdmRldi0+cGFydGl0aW9uOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAg Z290byBpbnZhbGlkOworICAgICAgICB9CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBYRU5f QkxPQ0tfVkRFVl9UWVBFX0hEOgorICAgICAgICBpZiAoKHZkZXYtPmRpc2sgPT0gMCB8fCB2ZGV2 LT5kaXNrID09IDEpICYmCisgICAgICAgICAgICB2ZGV2LT5wYXJ0aXRpb24gPCAoMSA8PCA2KSkg eworICAgICAgICAgICAgdmRldi0+bnVtYmVyID0gKDMgPDwgOCkgfCAodmRldi0+ZGlzayA8PCA2 KSB8IHZkZXYtPnBhcnRpdGlvbjsKKyAgICAgICAgfSBlbHNlIGlmICgodmRldi0+ZGlzayA9PSAy IHx8IHZkZXYtPmRpc2sgPT0gMykgJiYKKyAgICAgICAgICAgICAgICAgICB2ZGV2LT5wYXJ0aXRp b24gPCAoMSA8PCA2KSkgeworICAgICAgICAgICAgdmRldi0+bnVtYmVyID0gKDIyIDw8IDgpIHwg KCh2ZGV2LT5kaXNrIC0gMikgPDwgNikgfAorICAgICAgICAgICAgICAgIHZkZXYtPnBhcnRpdGlv bjsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGdvdG8gaW52YWxpZDsKKyAgICAgICAg fQorICAgICAgICBicmVhazsKKworICAgIGNhc2UgWEVOX0JMT0NLX1ZERVZfVFlQRV9TRDoKKyAg ICAgICAgaWYgKHZkZXYtPmRpc2sgPCAoMSA8PCA0KSAmJiB2ZGV2LT5wYXJ0aXRpb24gPCAoMSA8 PCA0KSkgeworICAgICAgICAgICAgdmRldi0+bnVtYmVyID0gKDggPDwgOCkgfCAodmRldi0+ZGlz ayA8PCA0KSB8IHZkZXYtPnBhcnRpdGlvbjsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAg IGdvdG8gaW52YWxpZDsKKyAgICAgICAgfQorICAgICAgICBicmVhazsKKworICAgIGRlZmF1bHQ6 CisgICAgICAgIGdvdG8gaW52YWxpZDsKKyAgICB9CisKKyAgICBnX2ZyZWUoc3RyKTsKKyAgICBy ZXR1cm47CisKK2ludmFsaWQ6CisgICAgZXJyb3Jfc2V0ZyhlcnJwLCAiaW52YWxpZCB2aXJ0dWFs IGRpc2sgc3BlY2lmaWVyIik7CisKKyAgICB2ZGV2LT50eXBlID0gWEVOX0JMT0NLX1ZERVZfVFlQ RV9JTlZBTElEOworICAgIGdfZnJlZShzdHIpOworfQorCisvKgorICogVGhpcyBwcm9wZXJ0eSBk ZWFscyB3aXRoICd2ZGV2JyBuYW1lcyBhZGhlcmluZyB0byB0aGUgWGVuIFZCRCBuYW1pbmcKKyAq IHNjaGVtZSBkZXNjcmliZWQgaW46CisgKgorICogaHR0cHM6Ly94ZW5iaXRzLnhlbi5vcmcvZG9j cy91bnN0YWJsZS9tYW4veGVuLXZiZC1pbnRlcmZhY2UuNy5odG1sCisgKi8KK2NvbnN0IFByb3Bl cnR5SW5mbyB4ZW5fYmxvY2tfcHJvcF92ZGV2ID0geworICAgIC5uYW1lICA9ICJzdHIiLAorICAg IC5kZXNjcmlwdGlvbiA9ICJWaXJ0dWFsIERpc2sgc3BlY2lmaWVyOiBkKnAqL3h2ZCovaGQqL3Nk KiIsCisgICAgLmdldCA9IHhlbl9ibG9ja19nZXRfdmRldiwKKyAgICAuc2V0ID0geGVuX2Jsb2Nr X3NldF92ZGV2LAorfTsKKworc3RhdGljIFByb3BlcnR5IHhlbl9ibG9ja19wcm9wc1tdID0gewor ICAgIERFRklORV9QUk9QKCJ2ZGV2IiwgWGVuQmxvY2tEZXZpY2UsIHZkZXYsCisgICAgICAgICAg ICAgICAgeGVuX2Jsb2NrX3Byb3BfdmRldiwgWGVuQmxvY2tWZGV2KSwKKyAgICBERUZJTkVfUFJP UF9FTkRfT0ZfTElTVCgpCit9OworCitzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfY2xhc3NfaW5pdChP YmplY3RDbGFzcyAqY2xhc3MsIHZvaWQgKmRhdGEpCit7CisgICAgRGV2aWNlQ2xhc3MgKmRldl9j bGFzcyA9IERFVklDRV9DTEFTUyhjbGFzcyk7CisgICAgWGVuRGV2aWNlQ2xhc3MgKnhlbmRldl9j bGFzcyA9IFhFTl9ERVZJQ0VfQ0xBU1MoY2xhc3MpOworCisgICAgeGVuZGV2X2NsYXNzLT5yZWFs aXplID0geGVuX2Jsb2NrX3JlYWxpemU7CisgICAgeGVuZGV2X2NsYXNzLT51bnJlYWxpemUgPSB4 ZW5fYmxvY2tfdW5yZWFsaXplOworCisgICAgZGV2X2NsYXNzLT5wcm9wcyA9IHhlbl9ibG9ja19w cm9wczsKK30KKworc3RhdGljIGNvbnN0IFR5cGVJbmZvIHhlbl9ibG9ja190eXBlX2luZm8gPSB7 CisgICAgLm5hbWUgPSBUWVBFX1hFTl9CTE9DS19ERVZJQ0UsCisgICAgLnBhcmVudCA9IFRZUEVf WEVOX0RFVklDRSwKKyAgICAuaW5zdGFuY2Vfc2l6ZSA9IHNpemVvZihYZW5CbG9ja0RldmljZSks CisgICAgLmFic3RyYWN0ID0gdHJ1ZSwKKyAgICAuY2xhc3Nfc2l6ZSA9IHNpemVvZihYZW5CbG9j a0RldmljZUNsYXNzKSwKKyAgICAuY2xhc3NfaW5pdCA9IHhlbl9ibG9ja19jbGFzc19pbml0LAor fTsKKworc3RhdGljIHZvaWQgeGVuX2Rpc2tfdW5yZWFsaXplKFhlbkJsb2NrRGV2aWNlICpibG9j a2RldiwgRXJyb3IgKiplcnJwKQoreworICAgIHRyYWNlX3hlbl9kaXNrX3VucmVhbGl6ZSgpOwor fQorCitzdGF0aWMgdm9pZCB4ZW5fZGlza19yZWFsaXplKFhlbkJsb2NrRGV2aWNlICpibG9ja2Rl diwgRXJyb3IgKiplcnJwKQoreworICAgIHRyYWNlX3hlbl9kaXNrX3JlYWxpemUoKTsKK30KKwor c3RhdGljIHZvaWQgeGVuX2Rpc2tfY2xhc3NfaW5pdChPYmplY3RDbGFzcyAqY2xhc3MsIHZvaWQg KmRhdGEpCit7CisgICAgRGV2aWNlQ2xhc3MgKmRldl9jbGFzcyA9IERFVklDRV9DTEFTUyhjbGFz cyk7CisgICAgWGVuQmxvY2tEZXZpY2VDbGFzcyAqYmxvY2tkZXZfY2xhc3MgPSBYRU5fQkxPQ0tf REVWSUNFX0NMQVNTKGNsYXNzKTsKKworICAgIGJsb2NrZGV2X2NsYXNzLT5yZWFsaXplID0geGVu X2Rpc2tfcmVhbGl6ZTsKKyAgICBibG9ja2Rldl9jbGFzcy0+dW5yZWFsaXplID0geGVuX2Rpc2tf dW5yZWFsaXplOworCisgICAgZGV2X2NsYXNzLT5kZXNjID0gIlhlbiBEaXNrIERldmljZSI7Cit9 CisKK3N0YXRpYyBjb25zdCBUeXBlSW5mbyB4ZW5fZGlza190eXBlX2luZm8gPSB7CisgICAgLm5h bWUgPSBUWVBFX1hFTl9ESVNLX0RFVklDRSwKKyAgICAucGFyZW50ID0gVFlQRV9YRU5fQkxPQ0tf REVWSUNFLAorICAgIC5pbnN0YW5jZV9zaXplID0gc2l6ZW9mKFhlbkRpc2tEZXZpY2UpLAorICAg IC5jbGFzc19pbml0ID0geGVuX2Rpc2tfY2xhc3NfaW5pdCwKK307CisKK3N0YXRpYyB2b2lkIHhl bl9jZHJvbV91bnJlYWxpemUoWGVuQmxvY2tEZXZpY2UgKmJsb2NrZGV2LCBFcnJvciAqKmVycnAp Cit7CisgICAgdHJhY2VfeGVuX2Nkcm9tX3VucmVhbGl6ZSgpOworfQorCitzdGF0aWMgdm9pZCB4 ZW5fY2Ryb21fcmVhbGl6ZShYZW5CbG9ja0RldmljZSAqYmxvY2tkZXYsIEVycm9yICoqZXJycCkK K3sKKyAgICB0cmFjZV94ZW5fY2Ryb21fcmVhbGl6ZSgpOworfQorCitzdGF0aWMgdm9pZCB4ZW5f Y2Ryb21fY2xhc3NfaW5pdChPYmplY3RDbGFzcyAqY2xhc3MsIHZvaWQgKmRhdGEpCit7CisgICAg RGV2aWNlQ2xhc3MgKmRldl9jbGFzcyA9IERFVklDRV9DTEFTUyhjbGFzcyk7CisgICAgWGVuQmxv Y2tEZXZpY2VDbGFzcyAqYmxvY2tkZXZfY2xhc3MgPSBYRU5fQkxPQ0tfREVWSUNFX0NMQVNTKGNs YXNzKTsKKworICAgIGJsb2NrZGV2X2NsYXNzLT5yZWFsaXplID0geGVuX2Nkcm9tX3JlYWxpemU7 CisgICAgYmxvY2tkZXZfY2xhc3MtPnVucmVhbGl6ZSA9IHhlbl9jZHJvbV91bnJlYWxpemU7CisK KyAgICBkZXZfY2xhc3MtPmRlc2MgPSAiWGVuIENELVJPTSBEZXZpY2UiOworfQorCitzdGF0aWMg Y29uc3QgVHlwZUluZm8geGVuX2Nkcm9tX3R5cGVfaW5mbyA9IHsKKyAgICAubmFtZSA9IFRZUEVf WEVOX0NEUk9NX0RFVklDRSwKKyAgICAucGFyZW50ID0gVFlQRV9YRU5fQkxPQ0tfREVWSUNFLAor ICAgIC5pbnN0YW5jZV9zaXplID0gc2l6ZW9mKFhlbkNEUm9tRGV2aWNlKSwKKyAgICAuY2xhc3Nf aW5pdCA9IHhlbl9jZHJvbV9jbGFzc19pbml0LAorfTsKKworc3RhdGljIHZvaWQgeGVuX2Jsb2Nr X3JlZ2lzdGVyX3R5cGVzKHZvaWQpCit7CisgICAgdHlwZV9yZWdpc3Rlcl9zdGF0aWMoJnhlbl9i bG9ja190eXBlX2luZm8pOworICAgIHR5cGVfcmVnaXN0ZXJfc3RhdGljKCZ4ZW5fZGlza190eXBl X2luZm8pOworICAgIHR5cGVfcmVnaXN0ZXJfc3RhdGljKCZ4ZW5fY2Ryb21fdHlwZV9pbmZvKTsK K30KKwordHlwZV9pbml0KHhlbl9ibG9ja19yZWdpc3Rlcl90eXBlcykKZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvaHcveGVuL3hlbi1ibG9jay5oIGIvaW5jbHVkZS9ody94ZW4veGVuLWJsb2NrLmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDY3OTMyYQotLS0gL2Rldi9udWxsCisr KyBiL2luY2x1ZGUvaHcveGVuL3hlbi1ibG9jay5oCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBD b3B5cmlnaHQgKGMpIDIwMTggIENpdHJpeCBTeXN0ZW1zIEluYy4KKyAqCisgKiBUaGlzIHdvcmsg aXMgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR1BMLCB2ZXJzaW9uIDIgb3Ig bGF0ZXIuCisgKiBTZWUgdGhlIENPUFlJTkcgZmlsZSBpbiB0aGUgdG9wLWxldmVsIGRpcmVjdG9y eS4KKyAqLworCisjaWZuZGVmIEhXX1hFTl9CTE9DS19ICisjZGVmaW5lIEhXX1hFTl9CTE9DS19I CisKKyNpbmNsdWRlICJody94ZW4veGVuLWJ1cy5oIgorCit0eXBlZGVmIGVudW0gWGVuQmxvY2tW ZGV2VHlwZSB7CisgICAgWEVOX0JMT0NLX1ZERVZfVFlQRV9JTlZBTElELAorICAgIFhFTl9CTE9D S19WREVWX1RZUEVfRFAsCisgICAgWEVOX0JMT0NLX1ZERVZfVFlQRV9YVkQsCisgICAgWEVOX0JM T0NLX1ZERVZfVFlQRV9IRCwKKyAgICBYRU5fQkxPQ0tfVkRFVl9UWVBFX1NELAorICAgIFhFTl9C TE9DS19WREVWX1RZUEVfX01BWAorfSBYZW5CbG9ja1ZkZXZUeXBlOworCit0eXBlZGVmIHN0cnVj dCBYZW5CbG9ja1ZkZXYgeworICAgIFhlbkJsb2NrVmRldlR5cGUgdHlwZTsKKyAgICB1bnNpZ25l ZCBsb25nIGRpc2s7CisgICAgdW5zaWduZWQgbG9uZyBwYXJ0aXRpb247CisgICAgdW5zaWduZWQg bG9uZyBudW1iZXI7Cit9IFhlbkJsb2NrVmRldjsKKwordHlwZWRlZiBzdHJ1Y3QgWGVuQmxvY2tE ZXZpY2UgeworICAgIFhlbkRldmljZSB4ZW5kZXY7CisgICAgWGVuQmxvY2tWZGV2IHZkZXY7Cit9 IFhlbkJsb2NrRGV2aWNlOworCit0eXBlZGVmIHZvaWQgKCpYZW5CbG9ja0RldmljZVJlYWxpemUp KFhlbkJsb2NrRGV2aWNlICpibG9ja2RldiwgRXJyb3IgKiplcnJwKTsKK3R5cGVkZWYgdm9pZCAo KlhlbkJsb2NrRGV2aWNlVW5yZWFsaXplKShYZW5CbG9ja0RldmljZSAqYmxvY2tkZXYsIEVycm9y ICoqZXJycCk7CisKK3R5cGVkZWYgc3RydWN0IFhlbkJsb2NrRGV2aWNlQ2xhc3MgeworICAgIC8q PCBwcml2YXRlID4qLworICAgIFhlbkRldmljZUNsYXNzIHBhcmVudF9jbGFzczsKKyAgICAvKjwg cHVibGljID4qLworICAgIFhlbkJsb2NrRGV2aWNlUmVhbGl6ZSByZWFsaXplOworICAgIFhlbkJs b2NrRGV2aWNlVW5yZWFsaXplIHVucmVhbGl6ZTsKK30gWGVuQmxvY2tEZXZpY2VDbGFzczsKKwor I2RlZmluZSBUWVBFX1hFTl9CTE9DS19ERVZJQ0UgICJ4ZW4tYmxvY2siCisjZGVmaW5lIFhFTl9C TE9DS19ERVZJQ0Uob2JqKSBcCisgICAgIE9CSkVDVF9DSEVDSyhYZW5CbG9ja0RldmljZSwgKG9i aiksIFRZUEVfWEVOX0JMT0NLX0RFVklDRSkKKyNkZWZpbmUgWEVOX0JMT0NLX0RFVklDRV9DTEFT UyhjbGFzcykgXAorICAgICBPQkpFQ1RfQ0xBU1NfQ0hFQ0soWGVuQmxvY2tEZXZpY2VDbGFzcywg KGNsYXNzKSwgVFlQRV9YRU5fQkxPQ0tfREVWSUNFKQorI2RlZmluZSBYRU5fQkxPQ0tfREVWSUNF X0dFVF9DTEFTUyhvYmopIFwKKyAgICAgT0JKRUNUX0dFVF9DTEFTUyhYZW5CbG9ja0RldmljZUNs YXNzLCAob2JqKSwgVFlQRV9YRU5fQkxPQ0tfREVWSUNFKQorCit0eXBlZGVmIHN0cnVjdCBYZW5E aXNrRGV2aWNlIHsKKyAgICBYZW5CbG9ja0RldmljZSBibG9ja2RldjsKK30gWGVuRGlza0Rldmlj ZTsKKworI2RlZmluZSBUWVBFX1hFTl9ESVNLX0RFVklDRSAgInhlbi1kaXNrIgorI2RlZmluZSBY RU5fRElTS19ERVZJQ0Uob2JqKSBcCisgICAgIE9CSkVDVF9DSEVDSyhYZW5EaXNrRGV2aWNlLCAo b2JqKSwgVFlQRV9YRU5fRElTS19ERVZJQ0UpCisKK3R5cGVkZWYgc3RydWN0IFhlbkNEUm9tRGV2 aWNlIHsKKyAgICBYZW5CbG9ja0RldmljZSBibG9ja2RldjsKK30gWGVuQ0RSb21EZXZpY2U7CisK KyNkZWZpbmUgVFlQRV9YRU5fQ0RST01fREVWSUNFICAieGVuLWNkcm9tIgorI2RlZmluZSBYRU5f Q0RST01fREVWSUNFKG9iaikgXAorICAgICBPQkpFQ1RfQ0hFQ0soWGVuQ0RSb21EZXZpY2UsIChv YmopLCBUWVBFX1hFTl9DRFJPTV9ERVZJQ0UpCisKKyNlbmRpZiAvKiBIV19YRU5fQkxPQ0tfSCAq LwotLSAKMi4xLjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9y ZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:55901) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gWfZj-0003jb-N5 for qemu-devel@nongnu.org; Tue, 11 Dec 2018 05:47:42 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gWfZf-0008WK-94 for qemu-devel@nongnu.org; Tue, 11 Dec 2018 05:47:39 -0500 From: Paul Durrant Date: Tue, 11 Dec 2018 10:47:03 +0000 Message-ID: <1544525238-3527-4-git-send-email-paul.durrant@citrix.com> In-Reply-To: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> References: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 Content-Type: text/plain Subject: [Qemu-devel] [PATCH v3 03/18] xen: introduce 'xen-block', 'xen-disk' and 'xen-cdrom' List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org, qemu-block@nongnu.org, xen-devel@lists.xenproject.org Cc: Paul Durrant , Kevin Wolf , Max Reitz , Stefano Stabellini , Anthony Perard This patch adds new XenDevice-s: 'xen-disk' and 'xen-cdrom', both derived from a common 'xen-block' parent type. These will eventually replace the 'xen_disk' (note the underscore rather than hyphen) legacy PV backend but it is illustrative to build up the implementation incrementally, along with the XenBus/XenDevice framework. Subsequent patches will therefore add to these devices' implementation as new features are added to the framework. After this patch has been applied it is possible to instantiate new 'xen-disk' or 'xen-cdrom' devices with a single 'vdev' parameter, which accepts values adhering to the Xen VBD naming scheme [1]. For example, a command-line instantiation of a xen-disk can be done with an argument similar to the following: -device xen-disk,vdev=hda The implementation of the vdev parameter formulates the appropriate VBD number for use in the PV protocol. [1] https://xenbits.xen.org/docs/unstable/man/xen-vbd-interface.7.html Signed-off-by: Paul Durrant --- Cc: Kevin Wolf Cc: Max Reitz Cc: Stefano Stabellini Cc: Anthony Perard v3: - Fix vdev parsing again, and vdev formatting this time - Remove an unnecessary local_err v2: - Fix boilerplate - Fix vdev parsing - Change name from 'xen-qdisk' to 'xen-block', make abstract, and split off 'xen-disk' and 'xen-cdrom' as concrete sub-types --- MAINTAINERS | 2 +- hw/block/Makefile.objs | 1 + hw/block/trace-events | 8 ++ hw/block/xen-block.c | 343 +++++++++++++++++++++++++++++++++++++++++++++ include/hw/xen/xen-block.h | 69 +++++++++ 5 files changed, 422 insertions(+), 1 deletion(-) create mode 100644 hw/block/xen-block.c create mode 100644 include/hw/xen/xen-block.h diff --git a/MAINTAINERS b/MAINTAINERS index 63effdc..dd728c3 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -403,7 +403,7 @@ F: hw/9pfs/xen-9p-backend.c F: hw/char/xen_console.c F: hw/display/xenfb.c F: hw/net/xen_nic.c -F: hw/block/xen_* +F: hw/block/xen* F: hw/xen/ F: hw/xenpv/ F: hw/i386/xen/ diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs index 53ce575..f34813a 100644 --- a/hw/block/Makefile.objs +++ b/hw/block/Makefile.objs @@ -4,6 +4,7 @@ common-obj-$(CONFIG_SSI_M25P80) += m25p80.o common-obj-$(CONFIG_NAND) += nand.o common-obj-$(CONFIG_PFLASH_CFI01) += pflash_cfi01.o common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o +common-obj-$(CONFIG_XEN) += xen-block.o common-obj-$(CONFIG_XEN) += xen_disk.o common-obj-$(CONFIG_ECC) += ecc.o common-obj-$(CONFIG_ONENAND) += onenand.o diff --git a/hw/block/trace-events b/hw/block/trace-events index 335c092..4afbd62 100644 --- a/hw/block/trace-events +++ b/hw/block/trace-events @@ -127,3 +127,11 @@ xen_disk_init(char *name) "%s" xen_disk_connect(char *name) "%s" xen_disk_disconnect(char *name) "%s" xen_disk_free(char *name) "%s" + +# hw/block/xen-block.c +xen_block_realize(const char *type, uint32_t disk, uint32_t partition) "%s d%up%u" +xen_block_unrealize(const char *type, uint32_t disk, uint32_t partition) "%s d%up%u" +xen_disk_realize(void) "" +xen_disk_unrealize(void) "" +xen_cdrom_realize(void) "" +xen_cdrom_unrealize(void) "" diff --git a/hw/block/xen-block.c b/hw/block/xen-block.c new file mode 100644 index 0000000..c29acb0 --- /dev/null +++ b/hw/block/xen-block.c @@ -0,0 +1,343 @@ +/* + * Copyright (c) 2018 Citrix Systems Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "qemu/cutils.h" +#include "qapi/error.h" +#include "qapi/visitor.h" +#include "hw/hw.h" +#include "hw/xen/xen-block.h" +#include "trace.h" + +static void xen_block_unrealize(XenDevice *xendev, Error **errp) +{ + XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev); + XenBlockDeviceClass *blockdev_class = + XEN_BLOCK_DEVICE_GET_CLASS(xendev); + const char *type = object_get_typename(OBJECT(blockdev)); + XenBlockVdev *vdev = &blockdev->vdev; + + if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) { + return; + } + + trace_xen_block_unrealize(type, vdev->disk, vdev->partition); + + if (blockdev_class->unrealize) { + blockdev_class->unrealize(blockdev, errp); + } +} + +static void xen_block_realize(XenDevice *xendev, Error **errp) +{ + XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev); + XenBlockDeviceClass *blockdev_class = + XEN_BLOCK_DEVICE_GET_CLASS(xendev); + const char *type = object_get_typename(OBJECT(blockdev)); + XenBlockVdev *vdev = &blockdev->vdev; + Error *local_err = NULL; + + if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) { + error_setg(errp, "vdev property not set"); + return; + } + + trace_xen_block_realize(type, vdev->disk, vdev->partition); + + if (blockdev_class->realize) { + blockdev_class->realize(blockdev, &local_err); + if (local_err) { + error_propagate(errp, local_err); + } + } +} + +static char *disk_to_vbd_name(unsigned int disk) +{ + char *name, *prefix = (disk >= 26) ? + disk_to_vbd_name((disk / 26) - 1) : g_strdup(""); + + name = g_strdup_printf("%s%c", prefix, 'a' + disk % 26); + g_free(prefix); + + return name; +} + +static void xen_block_get_vdev(Object *obj, Visitor *v, const char *name, + void *opaque, Error **errp) +{ + DeviceState *dev = DEVICE(obj); + Property *prop = opaque; + XenBlockVdev *vdev = qdev_get_prop_ptr(dev, prop); + char *str; + + switch (vdev->type) { + case XEN_BLOCK_VDEV_TYPE_DP: + str = g_strdup_printf("d%lup%lu", vdev->disk, vdev->partition); + break; + + case XEN_BLOCK_VDEV_TYPE_XVD: + case XEN_BLOCK_VDEV_TYPE_HD: + case XEN_BLOCK_VDEV_TYPE_SD: { + char *name = disk_to_vbd_name(vdev->disk); + + str = g_strdup_printf("%s%s%lu", + (vdev->type == XEN_BLOCK_VDEV_TYPE_XVD) ? + "xvd" : + (vdev->type == XEN_BLOCK_VDEV_TYPE_HD) ? + "hd" : + "sd", + name, vdev->partition); + g_free(name); + break; + } + default: + error_setg(errp, "invalid vdev type"); + return; + } + + visit_type_str(v, name, &str, errp); + g_free(str); +} + +static unsigned int vbd_name_to_disk(const char *name, const char **endp) +{ + unsigned int disk = 0; + + while (*name != '\0') { + if (!g_ascii_isalpha(*name) || !g_ascii_islower(*name)) { + break; + } + + disk *= 26; + disk += *name++ - 'a' + 1; + } + *endp = name; + + return disk - 1; +} + +static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name, + void *opaque, Error **errp) +{ + DeviceState *dev = DEVICE(obj); + Property *prop = opaque; + XenBlockVdev *vdev = qdev_get_prop_ptr(dev, prop); + Error *local_err = NULL; + char *str, *p; + const char *end; + + if (dev->realized) { + qdev_prop_set_after_realize(dev, name, errp); + return; + } + + visit_type_str(v, name, &str, &local_err); + if (local_err) { + error_propagate(errp, local_err); + return; + } + + p = strchr(str, 'd'); + if (!p) { + goto invalid; + } + + *p++ = '\0'; + if (*str == '\0') { + vdev->type = XEN_BLOCK_VDEV_TYPE_DP; + } else if (strcmp(str, "xv") == 0) { + vdev->type = XEN_BLOCK_VDEV_TYPE_XVD; + } else if (strcmp(str, "h") == 0) { + vdev->type = XEN_BLOCK_VDEV_TYPE_HD; + } else if (strcmp(str, "s") == 0) { + vdev->type = XEN_BLOCK_VDEV_TYPE_SD; + } else { + goto invalid; + } + + if (vdev->type == XEN_BLOCK_VDEV_TYPE_DP) { + if (qemu_strtoul(p, &end, 10, &vdev->disk)) { + goto invalid; + } + + if (*end == 'p') { + p = (char *) ++end; + if (*end == '\0') { + goto invalid; + } + } + } else { + vdev->disk = vbd_name_to_disk(p, &end); + } + + if (*end != '\0') { + p = (char *)end; + + if (qemu_strtoul(p, &end, 10, &vdev->partition)) { + goto invalid; + } + + if (*end != '\0') { + goto invalid; + } + } else { + vdev->partition = 0; + } + + switch (vdev->type) { + case XEN_BLOCK_VDEV_TYPE_DP: + case XEN_BLOCK_VDEV_TYPE_XVD: + if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) { + vdev->number = (202 << 8) | (vdev->disk << 4) | + vdev->partition; + } else if (vdev->disk < (1 << 20) && vdev->partition < (1 << 8)) { + vdev->number = (1 << 28) | (vdev->disk << 8) | + vdev->partition; + } else { + goto invalid; + } + break; + + case XEN_BLOCK_VDEV_TYPE_HD: + if ((vdev->disk == 0 || vdev->disk == 1) && + vdev->partition < (1 << 6)) { + vdev->number = (3 << 8) | (vdev->disk << 6) | vdev->partition; + } else if ((vdev->disk == 2 || vdev->disk == 3) && + vdev->partition < (1 << 6)) { + vdev->number = (22 << 8) | ((vdev->disk - 2) << 6) | + vdev->partition; + } else { + goto invalid; + } + break; + + case XEN_BLOCK_VDEV_TYPE_SD: + if (vdev->disk < (1 << 4) && vdev->partition < (1 << 4)) { + vdev->number = (8 << 8) | (vdev->disk << 4) | vdev->partition; + } else { + goto invalid; + } + break; + + default: + goto invalid; + } + + g_free(str); + return; + +invalid: + error_setg(errp, "invalid virtual disk specifier"); + + vdev->type = XEN_BLOCK_VDEV_TYPE_INVALID; + g_free(str); +} + +/* + * This property deals with 'vdev' names adhering to the Xen VBD naming + * scheme described in: + * + * https://xenbits.xen.org/docs/unstable/man/xen-vbd-interface.7.html + */ +const PropertyInfo xen_block_prop_vdev = { + .name = "str", + .description = "Virtual Disk specifier: d*p*/xvd*/hd*/sd*", + .get = xen_block_get_vdev, + .set = xen_block_set_vdev, +}; + +static Property xen_block_props[] = { + DEFINE_PROP("vdev", XenBlockDevice, vdev, + xen_block_prop_vdev, XenBlockVdev), + DEFINE_PROP_END_OF_LIST() +}; + +static void xen_block_class_init(ObjectClass *class, void *data) +{ + DeviceClass *dev_class = DEVICE_CLASS(class); + XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class); + + xendev_class->realize = xen_block_realize; + xendev_class->unrealize = xen_block_unrealize; + + dev_class->props = xen_block_props; +} + +static const TypeInfo xen_block_type_info = { + .name = TYPE_XEN_BLOCK_DEVICE, + .parent = TYPE_XEN_DEVICE, + .instance_size = sizeof(XenBlockDevice), + .abstract = true, + .class_size = sizeof(XenBlockDeviceClass), + .class_init = xen_block_class_init, +}; + +static void xen_disk_unrealize(XenBlockDevice *blockdev, Error **errp) +{ + trace_xen_disk_unrealize(); +} + +static void xen_disk_realize(XenBlockDevice *blockdev, Error **errp) +{ + trace_xen_disk_realize(); +} + +static void xen_disk_class_init(ObjectClass *class, void *data) +{ + DeviceClass *dev_class = DEVICE_CLASS(class); + XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class); + + blockdev_class->realize = xen_disk_realize; + blockdev_class->unrealize = xen_disk_unrealize; + + dev_class->desc = "Xen Disk Device"; +} + +static const TypeInfo xen_disk_type_info = { + .name = TYPE_XEN_DISK_DEVICE, + .parent = TYPE_XEN_BLOCK_DEVICE, + .instance_size = sizeof(XenDiskDevice), + .class_init = xen_disk_class_init, +}; + +static void xen_cdrom_unrealize(XenBlockDevice *blockdev, Error **errp) +{ + trace_xen_cdrom_unrealize(); +} + +static void xen_cdrom_realize(XenBlockDevice *blockdev, Error **errp) +{ + trace_xen_cdrom_realize(); +} + +static void xen_cdrom_class_init(ObjectClass *class, void *data) +{ + DeviceClass *dev_class = DEVICE_CLASS(class); + XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_CLASS(class); + + blockdev_class->realize = xen_cdrom_realize; + blockdev_class->unrealize = xen_cdrom_unrealize; + + dev_class->desc = "Xen CD-ROM Device"; +} + +static const TypeInfo xen_cdrom_type_info = { + .name = TYPE_XEN_CDROM_DEVICE, + .parent = TYPE_XEN_BLOCK_DEVICE, + .instance_size = sizeof(XenCDRomDevice), + .class_init = xen_cdrom_class_init, +}; + +static void xen_block_register_types(void) +{ + type_register_static(&xen_block_type_info); + type_register_static(&xen_disk_type_info); + type_register_static(&xen_cdrom_type_info); +} + +type_init(xen_block_register_types) diff --git a/include/hw/xen/xen-block.h b/include/hw/xen/xen-block.h new file mode 100644 index 0000000..067932a --- /dev/null +++ b/include/hw/xen/xen-block.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2018 Citrix Systems Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#ifndef HW_XEN_BLOCK_H +#define HW_XEN_BLOCK_H + +#include "hw/xen/xen-bus.h" + +typedef enum XenBlockVdevType { + XEN_BLOCK_VDEV_TYPE_INVALID, + XEN_BLOCK_VDEV_TYPE_DP, + XEN_BLOCK_VDEV_TYPE_XVD, + XEN_BLOCK_VDEV_TYPE_HD, + XEN_BLOCK_VDEV_TYPE_SD, + XEN_BLOCK_VDEV_TYPE__MAX +} XenBlockVdevType; + +typedef struct XenBlockVdev { + XenBlockVdevType type; + unsigned long disk; + unsigned long partition; + unsigned long number; +} XenBlockVdev; + +typedef struct XenBlockDevice { + XenDevice xendev; + XenBlockVdev vdev; +} XenBlockDevice; + +typedef void (*XenBlockDeviceRealize)(XenBlockDevice *blockdev, Error **errp); +typedef void (*XenBlockDeviceUnrealize)(XenBlockDevice *blockdev, Error **errp); + +typedef struct XenBlockDeviceClass { + /*< private >*/ + XenDeviceClass parent_class; + /*< public >*/ + XenBlockDeviceRealize realize; + XenBlockDeviceUnrealize unrealize; +} XenBlockDeviceClass; + +#define TYPE_XEN_BLOCK_DEVICE "xen-block" +#define XEN_BLOCK_DEVICE(obj) \ + OBJECT_CHECK(XenBlockDevice, (obj), TYPE_XEN_BLOCK_DEVICE) +#define XEN_BLOCK_DEVICE_CLASS(class) \ + OBJECT_CLASS_CHECK(XenBlockDeviceClass, (class), TYPE_XEN_BLOCK_DEVICE) +#define XEN_BLOCK_DEVICE_GET_CLASS(obj) \ + OBJECT_GET_CLASS(XenBlockDeviceClass, (obj), TYPE_XEN_BLOCK_DEVICE) + +typedef struct XenDiskDevice { + XenBlockDevice blockdev; +} XenDiskDevice; + +#define TYPE_XEN_DISK_DEVICE "xen-disk" +#define XEN_DISK_DEVICE(obj) \ + OBJECT_CHECK(XenDiskDevice, (obj), TYPE_XEN_DISK_DEVICE) + +typedef struct XenCDRomDevice { + XenBlockDevice blockdev; +} XenCDRomDevice; + +#define TYPE_XEN_CDROM_DEVICE "xen-cdrom" +#define XEN_CDROM_DEVICE(obj) \ + OBJECT_CHECK(XenCDRomDevice, (obj), TYPE_XEN_CDROM_DEVICE) + +#endif /* HW_XEN_BLOCK_H */ -- 2.1.4