From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751986AbdIOXDQ (ORCPT ); Fri, 15 Sep 2017 19:03:16 -0400 Received: from mail.kernel.org ([198.145.29.99]:37042 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751516AbdIOXAo (ORCPT ); Fri, 15 Sep 2017 19:00:44 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9172422A76 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=sstabellini@kernel.org From: Stefano Stabellini To: xen-devel@lists.xen.org Cc: linux-kernel@vger.kernel.org, sstabellini@kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, Stefano Stabellini Subject: [PATCH v4 03/13] xen/pvcalls: connect to the backend Date: Fri, 15 Sep 2017 16:00:30 -0700 Message-Id: <1505516440-11111-3-git-send-email-sstabellini@kernel.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> References: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Implement the probe function for the pvcalls frontend. Read the supported versions, max-page-order and function-calls nodes from xenstore. Only one frontend<->backend connection is supported at any given time for a guest. Store the active frontend device to a static pointer. Introduce a stub functions for the event handler. Signed-off-by: Stefano Stabellini CC: boris.ostrovsky@oracle.com CC: jgross@suse.com --- drivers/xen/pvcalls-front.c | 133 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c index 67c8337..ffbbcd1 100644 --- a/drivers/xen/pvcalls-front.c +++ b/drivers/xen/pvcalls-front.c @@ -96,12 +96,145 @@ static int pvcalls_front_remove(struct xenbus_device *dev) static int pvcalls_front_probe(struct xenbus_device *dev, const struct xenbus_device_id *id) { + int ret = -ENOMEM, evtchn, i; + unsigned int max_page_order, function_calls, len; + char *versions; + grant_ref_t gref_head = 0; + struct xenbus_transaction xbt; + struct pvcalls_bedata *bedata = NULL; + struct xen_pvcalls_sring *sring; + + if (pvcalls_front_dev != NULL) { + dev_err(&dev->dev, "only one PV Calls connection supported\n"); + return -EINVAL; + } + + versions = xenbus_read(XBT_NIL, dev->otherend, "versions", &len); + if (!len) + return -EINVAL; + if (strcmp(versions, "1")) { + kfree(versions); + return -EINVAL; + } + kfree(versions); + max_page_order = xenbus_read_unsigned(dev->otherend, + "max-page-order", 0); + if (max_page_order < PVCALLS_RING_ORDER) + return -ENODEV; + function_calls = xenbus_read_unsigned(dev->otherend, + "function-calls", 0); + /* See XENBUS_FUNCTIONS_CALLS in pvcalls.h */ + if (function_calls != 1) + return -ENODEV; + pr_info("%s max-page-order is %u\n", __func__, max_page_order); + + bedata = kzalloc(sizeof(struct pvcalls_bedata), GFP_KERNEL); + if (!bedata) + return -ENOMEM; + + dev_set_drvdata(&dev->dev, bedata); + pvcalls_front_dev = dev; + init_waitqueue_head(&bedata->inflight_req); + INIT_LIST_HEAD(&bedata->socket_mappings); + INIT_LIST_HEAD(&bedata->socketpass_mappings); + spin_lock_init(&bedata->socket_lock); + bedata->irq = -1; + bedata->ref = -1; + + for (i = 0; i < PVCALLS_NR_REQ_PER_RING; i++) + bedata->rsp[i].req_id = PVCALLS_INVALID_ID; + + sring = (struct xen_pvcalls_sring *) __get_free_page(GFP_KERNEL | + __GFP_ZERO); + if (!sring) + goto error; + SHARED_RING_INIT(sring); + FRONT_RING_INIT(&bedata->ring, sring, XEN_PAGE_SIZE); + + ret = xenbus_alloc_evtchn(dev, &evtchn); + if (ret) + goto error; + + bedata->irq = bind_evtchn_to_irqhandler(evtchn, + pvcalls_front_event_handler, + 0, "pvcalls-frontend", dev); + if (bedata->irq < 0) { + ret = bedata->irq; + goto error; + } + + ret = gnttab_alloc_grant_references(1, &gref_head); + if (ret < 0) + goto error; + bedata->ref = gnttab_claim_grant_reference(&gref_head); + if (bedata->ref < 0) { + ret = bedata->ref; + goto error; + } + gnttab_grant_foreign_access_ref(bedata->ref, dev->otherend_id, + virt_to_gfn((void *)sring), 0); + + again: + ret = xenbus_transaction_start(&xbt); + if (ret) { + xenbus_dev_fatal(dev, ret, "starting transaction"); + goto error; + } + ret = xenbus_printf(xbt, dev->nodename, "version", "%u", 1); + if (ret) + goto error_xenbus; + ret = xenbus_printf(xbt, dev->nodename, "ring-ref", "%d", bedata->ref); + if (ret) + goto error_xenbus; + ret = xenbus_printf(xbt, dev->nodename, "port", "%u", + evtchn); + if (ret) + goto error_xenbus; + ret = xenbus_transaction_end(xbt, 0); + if (ret) { + if (ret == -EAGAIN) + goto again; + xenbus_dev_fatal(dev, ret, "completing transaction"); + goto error; + } + xenbus_switch_state(dev, XenbusStateInitialised); + return 0; + + error_xenbus: + xenbus_transaction_end(xbt, 1); + xenbus_dev_fatal(dev, ret, "writing xenstore"); + error: + pvcalls_front_remove(dev); + return ret; } static void pvcalls_front_changed(struct xenbus_device *dev, enum xenbus_state backend_state) { + switch (backend_state) { + case XenbusStateReconfiguring: + case XenbusStateReconfigured: + case XenbusStateInitialising: + case XenbusStateInitialised: + case XenbusStateUnknown: + break; + + case XenbusStateInitWait: + break; + + case XenbusStateConnected: + xenbus_switch_state(dev, XenbusStateConnected); + break; + + case XenbusStateClosed: + if (dev->state == XenbusStateClosed) + break; + /* Missed the backend's CLOSING state -- fallthrough */ + case XenbusStateClosing: + xenbus_frontend_closed(dev); + break; + } } static struct xenbus_driver pvcalls_front_driver = { -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: [PATCH v4 03/13] xen/pvcalls: connect to the backend Date: Fri, 15 Sep 2017 16:00:30 -0700 Message-ID: <1505516440-11111-3-git-send-email-sstabellini@kernel.org> References: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: xen-devel@lists.xen.org Cc: jgross@suse.com, Stefano Stabellini , boris.ostrovsky@oracle.com, sstabellini@kernel.org, linux-kernel@vger.kernel.org List-Id: xen-devel@lists.xenproject.org SW1wbGVtZW50IHRoZSBwcm9iZSBmdW5jdGlvbiBmb3IgdGhlIHB2Y2FsbHMgZnJvbnRlbmQuIFJl YWQgdGhlCnN1cHBvcnRlZCB2ZXJzaW9ucywgbWF4LXBhZ2Utb3JkZXIgYW5kIGZ1bmN0aW9uLWNh bGxzIG5vZGVzIGZyb20KeGVuc3RvcmUuCgpPbmx5IG9uZSBmcm9udGVuZDwtPmJhY2tlbmQgY29u bmVjdGlvbiBpcyBzdXBwb3J0ZWQgYXQgYW55IGdpdmVuIHRpbWUKZm9yIGEgZ3Vlc3QuIFN0b3Jl IHRoZSBhY3RpdmUgZnJvbnRlbmQgZGV2aWNlIHRvIGEgc3RhdGljIHBvaW50ZXIuCgpJbnRyb2R1 Y2UgYSBzdHViIGZ1bmN0aW9ucyBmb3IgdGhlIGV2ZW50IGhhbmRsZXIuCgpTaWduZWQtb2ZmLWJ5 OiBTdGVmYW5vIFN0YWJlbGxpbmkgPHN0ZWZhbm9AYXBvcmV0by5jb20+CkNDOiBib3Jpcy5vc3Ry b3Zza3lAb3JhY2xlLmNvbQpDQzogamdyb3NzQHN1c2UuY29tCi0tLQogZHJpdmVycy94ZW4vcHZj YWxscy1mcm9udC5jIHwgMTMzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCiAxIGZpbGUgY2hhbmdlZCwgMTMzIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9k cml2ZXJzL3hlbi9wdmNhbGxzLWZyb250LmMgYi9kcml2ZXJzL3hlbi9wdmNhbGxzLWZyb250LmMK aW5kZXggNjdjODMzNy4uZmZiYmNkMSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vcHZjYWxscy1m cm9udC5jCisrKyBiL2RyaXZlcnMveGVuL3B2Y2FsbHMtZnJvbnQuYwpAQCAtOTYsMTIgKzk2LDE0 NSBAQCBzdGF0aWMgaW50IHB2Y2FsbHNfZnJvbnRfcmVtb3ZlKHN0cnVjdCB4ZW5idXNfZGV2aWNl ICpkZXYpCiBzdGF0aWMgaW50IHB2Y2FsbHNfZnJvbnRfcHJvYmUoc3RydWN0IHhlbmJ1c19kZXZp Y2UgKmRldiwKIAkJCSAgY29uc3Qgc3RydWN0IHhlbmJ1c19kZXZpY2VfaWQgKmlkKQogeworCWlu dCByZXQgPSAtRU5PTUVNLCBldnRjaG4sIGk7CisJdW5zaWduZWQgaW50IG1heF9wYWdlX29yZGVy LCBmdW5jdGlvbl9jYWxscywgbGVuOworCWNoYXIgKnZlcnNpb25zOworCWdyYW50X3JlZl90IGdy ZWZfaGVhZCA9IDA7CisJc3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQ7CisJc3RydWN0IHB2 Y2FsbHNfYmVkYXRhICpiZWRhdGEgPSBOVUxMOworCXN0cnVjdCB4ZW5fcHZjYWxsc19zcmluZyAq c3Jpbmc7CisKKwlpZiAocHZjYWxsc19mcm9udF9kZXYgIT0gTlVMTCkgeworCQlkZXZfZXJyKCZk ZXYtPmRldiwgIm9ubHkgb25lIFBWIENhbGxzIGNvbm5lY3Rpb24gc3VwcG9ydGVkXG4iKTsKKwkJ cmV0dXJuIC1FSU5WQUw7CisJfQorCisJdmVyc2lvbnMgPSB4ZW5idXNfcmVhZChYQlRfTklMLCBk ZXYtPm90aGVyZW5kLCAidmVyc2lvbnMiLCAmbGVuKTsKKwlpZiAoIWxlbikKKwkJcmV0dXJuIC1F SU5WQUw7CisJaWYgKHN0cmNtcCh2ZXJzaW9ucywgIjEiKSkgeworCQlrZnJlZSh2ZXJzaW9ucyk7 CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlrZnJlZSh2ZXJzaW9ucyk7CisJbWF4X3BhZ2Vfb3Jk ZXIgPSB4ZW5idXNfcmVhZF91bnNpZ25lZChkZXYtPm90aGVyZW5kLAorCQkJCQkgICAgICAibWF4 LXBhZ2Utb3JkZXIiLCAwKTsKKwlpZiAobWF4X3BhZ2Vfb3JkZXIgPCBQVkNBTExTX1JJTkdfT1JE RVIpCisJCXJldHVybiAtRU5PREVWOworCWZ1bmN0aW9uX2NhbGxzID0geGVuYnVzX3JlYWRfdW5z aWduZWQoZGV2LT5vdGhlcmVuZCwKKwkJCQkJICAgICAgImZ1bmN0aW9uLWNhbGxzIiwgMCk7CisJ LyogU2VlIFhFTkJVU19GVU5DVElPTlNfQ0FMTFMgaW4gcHZjYWxscy5oICovCisJaWYgKGZ1bmN0 aW9uX2NhbGxzICE9IDEpCisJCXJldHVybiAtRU5PREVWOworCXByX2luZm8oIiVzIG1heC1wYWdl LW9yZGVyIGlzICV1XG4iLCBfX2Z1bmNfXywgbWF4X3BhZ2Vfb3JkZXIpOworCisJYmVkYXRhID0g a3phbGxvYyhzaXplb2Yoc3RydWN0IHB2Y2FsbHNfYmVkYXRhKSwgR0ZQX0tFUk5FTCk7CisJaWYg KCFiZWRhdGEpCisJCXJldHVybiAtRU5PTUVNOworCisJZGV2X3NldF9kcnZkYXRhKCZkZXYtPmRl diwgYmVkYXRhKTsKKwlwdmNhbGxzX2Zyb250X2RldiA9IGRldjsKKwlpbml0X3dhaXRxdWV1ZV9o ZWFkKCZiZWRhdGEtPmluZmxpZ2h0X3JlcSk7CisJSU5JVF9MSVNUX0hFQUQoJmJlZGF0YS0+c29j a2V0X21hcHBpbmdzKTsKKwlJTklUX0xJU1RfSEVBRCgmYmVkYXRhLT5zb2NrZXRwYXNzX21hcHBp bmdzKTsKKwlzcGluX2xvY2tfaW5pdCgmYmVkYXRhLT5zb2NrZXRfbG9jayk7CisJYmVkYXRhLT5p cnEgPSAtMTsKKwliZWRhdGEtPnJlZiA9IC0xOworCisJZm9yIChpID0gMDsgaSA8IFBWQ0FMTFNf TlJfUkVRX1BFUl9SSU5HOyBpKyspCisJCWJlZGF0YS0+cnNwW2ldLnJlcV9pZCA9IFBWQ0FMTFNf SU5WQUxJRF9JRDsKKworCXNyaW5nID0gKHN0cnVjdCB4ZW5fcHZjYWxsc19zcmluZyAqKSBfX2dl dF9mcmVlX3BhZ2UoR0ZQX0tFUk5FTCB8CisJCQkJCQkJICAgICBfX0dGUF9aRVJPKTsKKwlpZiAo IXNyaW5nKQorCQlnb3RvIGVycm9yOworCVNIQVJFRF9SSU5HX0lOSVQoc3JpbmcpOworCUZST05U X1JJTkdfSU5JVCgmYmVkYXRhLT5yaW5nLCBzcmluZywgWEVOX1BBR0VfU0laRSk7CisKKwlyZXQg PSB4ZW5idXNfYWxsb2NfZXZ0Y2huKGRldiwgJmV2dGNobik7CisJaWYgKHJldCkKKwkJZ290byBl cnJvcjsKKworCWJlZGF0YS0+aXJxID0gYmluZF9ldnRjaG5fdG9faXJxaGFuZGxlcihldnRjaG4s CisJCQkJCQlwdmNhbGxzX2Zyb250X2V2ZW50X2hhbmRsZXIsCisJCQkJCQkwLCAicHZjYWxscy1m cm9udGVuZCIsIGRldik7CisJaWYgKGJlZGF0YS0+aXJxIDwgMCkgeworCQlyZXQgPSBiZWRhdGEt PmlycTsKKwkJZ290byBlcnJvcjsKKwl9CisKKwlyZXQgPSBnbnR0YWJfYWxsb2NfZ3JhbnRfcmVm ZXJlbmNlcygxLCAmZ3JlZl9oZWFkKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBlcnJvcjsKKwli ZWRhdGEtPnJlZiA9IGdudHRhYl9jbGFpbV9ncmFudF9yZWZlcmVuY2UoJmdyZWZfaGVhZCk7CisJ aWYgKGJlZGF0YS0+cmVmIDwgMCkgeworCQlyZXQgPSBiZWRhdGEtPnJlZjsKKwkJZ290byBlcnJv cjsKKwl9CisJZ250dGFiX2dyYW50X2ZvcmVpZ25fYWNjZXNzX3JlZihiZWRhdGEtPnJlZiwgZGV2 LT5vdGhlcmVuZF9pZCwKKwkJCQkJdmlydF90b19nZm4oKHZvaWQgKilzcmluZyksIDApOworCisg YWdhaW46CisJcmV0ID0geGVuYnVzX3RyYW5zYWN0aW9uX3N0YXJ0KCZ4YnQpOworCWlmIChyZXQp IHsKKwkJeGVuYnVzX2Rldl9mYXRhbChkZXYsIHJldCwgInN0YXJ0aW5nIHRyYW5zYWN0aW9uIik7 CisJCWdvdG8gZXJyb3I7CisJfQorCXJldCA9IHhlbmJ1c19wcmludGYoeGJ0LCBkZXYtPm5vZGVu YW1lLCAidmVyc2lvbiIsICIldSIsIDEpOworCWlmIChyZXQpCisJCWdvdG8gZXJyb3JfeGVuYnVz OworCXJldCA9IHhlbmJ1c19wcmludGYoeGJ0LCBkZXYtPm5vZGVuYW1lLCAicmluZy1yZWYiLCAi JWQiLCBiZWRhdGEtPnJlZik7CisJaWYgKHJldCkKKwkJZ290byBlcnJvcl94ZW5idXM7CisJcmV0 ID0geGVuYnVzX3ByaW50Zih4YnQsIGRldi0+bm9kZW5hbWUsICJwb3J0IiwgIiV1IiwKKwkJCSAg ICBldnRjaG4pOworCWlmIChyZXQpCisJCWdvdG8gZXJyb3JfeGVuYnVzOworCXJldCA9IHhlbmJ1 c190cmFuc2FjdGlvbl9lbmQoeGJ0LCAwKTsKKwlpZiAocmV0KSB7CisJCWlmIChyZXQgPT0gLUVB R0FJTikKKwkJCWdvdG8gYWdhaW47CisJCXhlbmJ1c19kZXZfZmF0YWwoZGV2LCByZXQsICJjb21w bGV0aW5nIHRyYW5zYWN0aW9uIik7CisJCWdvdG8gZXJyb3I7CisJfQorCXhlbmJ1c19zd2l0Y2hf c3RhdGUoZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2VkKTsKKwogCXJldHVybiAwOworCisgZXJy b3JfeGVuYnVzOgorCXhlbmJ1c190cmFuc2FjdGlvbl9lbmQoeGJ0LCAxKTsKKwl4ZW5idXNfZGV2 X2ZhdGFsKGRldiwgcmV0LCAid3JpdGluZyB4ZW5zdG9yZSIpOworIGVycm9yOgorCXB2Y2FsbHNf ZnJvbnRfcmVtb3ZlKGRldik7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIHZvaWQgcHZjYWxs c19mcm9udF9jaGFuZ2VkKHN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYsCiAJCQkgICAgZW51bSB4 ZW5idXNfc3RhdGUgYmFja2VuZF9zdGF0ZSkKIHsKKwlzd2l0Y2ggKGJhY2tlbmRfc3RhdGUpIHsK KwljYXNlIFhlbmJ1c1N0YXRlUmVjb25maWd1cmluZzoKKwljYXNlIFhlbmJ1c1N0YXRlUmVjb25m aWd1cmVkOgorCWNhc2UgWGVuYnVzU3RhdGVJbml0aWFsaXNpbmc6CisJY2FzZSBYZW5idXNTdGF0 ZUluaXRpYWxpc2VkOgorCWNhc2UgWGVuYnVzU3RhdGVVbmtub3duOgorCQlicmVhazsKKworCWNh c2UgWGVuYnVzU3RhdGVJbml0V2FpdDoKKwkJYnJlYWs7CisKKwljYXNlIFhlbmJ1c1N0YXRlQ29u bmVjdGVkOgorCQl4ZW5idXNfc3dpdGNoX3N0YXRlKGRldiwgWGVuYnVzU3RhdGVDb25uZWN0ZWQp OworCQlicmVhazsKKworCWNhc2UgWGVuYnVzU3RhdGVDbG9zZWQ6CisJCWlmIChkZXYtPnN0YXRl ID09IFhlbmJ1c1N0YXRlQ2xvc2VkKQorCQkJYnJlYWs7CisJCS8qIE1pc3NlZCB0aGUgYmFja2Vu ZCdzIENMT1NJTkcgc3RhdGUgLS0gZmFsbHRocm91Z2ggKi8KKwljYXNlIFhlbmJ1c1N0YXRlQ2xv c2luZzoKKwkJeGVuYnVzX2Zyb250ZW5kX2Nsb3NlZChkZXYpOworCQlicmVhazsKKwl9CiB9CiAK IHN0YXRpYyBzdHJ1Y3QgeGVuYnVzX2RyaXZlciBwdmNhbGxzX2Zyb250X2RyaXZlciA9IHsKLS0g CjEuOS4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K WGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwczovL2xp c3RzLnhlbi5vcmcveGVuLWRldmVsCg==