Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * linux/fs/9p/trans_xen
0004  *
0005  * Xen transport layer.
0006  *
0007  * Copyright (C) 2017 by Stefano Stabellini <stefano@aporeto.com>
0008  */
0009 
0010 #include <xen/events.h>
0011 #include <xen/grant_table.h>
0012 #include <xen/xen.h>
0013 #include <xen/xenbus.h>
0014 #include <xen/interface/io/9pfs.h>
0015 
0016 #include <linux/module.h>
0017 #include <linux/spinlock.h>
0018 #include <net/9p/9p.h>
0019 #include <net/9p/client.h>
0020 #include <net/9p/transport.h>
0021 
0022 #define XEN_9PFS_NUM_RINGS 2
0023 #define XEN_9PFS_RING_ORDER 9
0024 #define XEN_9PFS_RING_SIZE(ring)  XEN_FLEX_RING_SIZE(ring->intf->ring_order)
0025 
0026 struct xen_9pfs_header {
0027     uint32_t size;
0028     uint8_t id;
0029     uint16_t tag;
0030 
0031     /* uint8_t sdata[]; */
0032 } __attribute__((packed));
0033 
0034 /* One per ring, more than one per 9pfs share */
0035 struct xen_9pfs_dataring {
0036     struct xen_9pfs_front_priv *priv;
0037 
0038     struct xen_9pfs_data_intf *intf;
0039     grant_ref_t ref;
0040     int evtchn;
0041     int irq;
0042     /* protect a ring from concurrent accesses */
0043     spinlock_t lock;
0044 
0045     struct xen_9pfs_data data;
0046     wait_queue_head_t wq;
0047     struct work_struct work;
0048 };
0049 
0050 /* One per 9pfs share */
0051 struct xen_9pfs_front_priv {
0052     struct list_head list;
0053     struct xenbus_device *dev;
0054     char *tag;
0055     struct p9_client *client;
0056 
0057     int num_rings;
0058     struct xen_9pfs_dataring *rings;
0059 };
0060 
0061 static LIST_HEAD(xen_9pfs_devs);
0062 static DEFINE_RWLOCK(xen_9pfs_lock);
0063 
0064 /* We don't currently allow canceling of requests */
0065 static int p9_xen_cancel(struct p9_client *client, struct p9_req_t *req)
0066 {
0067     return 1;
0068 }
0069 
0070 static int p9_xen_create(struct p9_client *client, const char *addr, char *args)
0071 {
0072     struct xen_9pfs_front_priv *priv;
0073 
0074     if (addr == NULL)
0075         return -EINVAL;
0076 
0077     read_lock(&xen_9pfs_lock);
0078     list_for_each_entry(priv, &xen_9pfs_devs, list) {
0079         if (!strcmp(priv->tag, addr)) {
0080             priv->client = client;
0081             read_unlock(&xen_9pfs_lock);
0082             return 0;
0083         }
0084     }
0085     read_unlock(&xen_9pfs_lock);
0086     return -EINVAL;
0087 }
0088 
0089 static void p9_xen_close(struct p9_client *client)
0090 {
0091     struct xen_9pfs_front_priv *priv;
0092 
0093     read_lock(&xen_9pfs_lock);
0094     list_for_each_entry(priv, &xen_9pfs_devs, list) {
0095         if (priv->client == client) {
0096             priv->client = NULL;
0097             read_unlock(&xen_9pfs_lock);
0098             return;
0099         }
0100     }
0101     read_unlock(&xen_9pfs_lock);
0102 }
0103 
0104 static bool p9_xen_write_todo(struct xen_9pfs_dataring *ring, RING_IDX size)
0105 {
0106     RING_IDX cons, prod;
0107 
0108     cons = ring->intf->out_cons;
0109     prod = ring->intf->out_prod;
0110     virt_mb();
0111 
0112     return XEN_9PFS_RING_SIZE(ring) -
0113         xen_9pfs_queued(prod, cons, XEN_9PFS_RING_SIZE(ring)) >= size;
0114 }
0115 
0116 static int p9_xen_request(struct p9_client *client, struct p9_req_t *p9_req)
0117 {
0118     struct xen_9pfs_front_priv *priv;
0119     RING_IDX cons, prod, masked_cons, masked_prod;
0120     unsigned long flags;
0121     u32 size = p9_req->tc.size;
0122     struct xen_9pfs_dataring *ring;
0123     int num;
0124 
0125     read_lock(&xen_9pfs_lock);
0126     list_for_each_entry(priv, &xen_9pfs_devs, list) {
0127         if (priv->client == client)
0128             break;
0129     }
0130     read_unlock(&xen_9pfs_lock);
0131     if (list_entry_is_head(priv, &xen_9pfs_devs, list))
0132         return -EINVAL;
0133 
0134     num = p9_req->tc.tag % priv->num_rings;
0135     ring = &priv->rings[num];
0136 
0137 again:
0138     while (wait_event_killable(ring->wq,
0139                    p9_xen_write_todo(ring, size)) != 0)
0140         ;
0141 
0142     spin_lock_irqsave(&ring->lock, flags);
0143     cons = ring->intf->out_cons;
0144     prod = ring->intf->out_prod;
0145     virt_mb();
0146 
0147     if (XEN_9PFS_RING_SIZE(ring) -
0148         xen_9pfs_queued(prod, cons, XEN_9PFS_RING_SIZE(ring)) < size) {
0149         spin_unlock_irqrestore(&ring->lock, flags);
0150         goto again;
0151     }
0152 
0153     masked_prod = xen_9pfs_mask(prod, XEN_9PFS_RING_SIZE(ring));
0154     masked_cons = xen_9pfs_mask(cons, XEN_9PFS_RING_SIZE(ring));
0155 
0156     xen_9pfs_write_packet(ring->data.out, p9_req->tc.sdata, size,
0157                   &masked_prod, masked_cons,
0158                   XEN_9PFS_RING_SIZE(ring));
0159 
0160     p9_req->status = REQ_STATUS_SENT;
0161     virt_wmb();         /* write ring before updating pointer */
0162     prod += size;
0163     ring->intf->out_prod = prod;
0164     spin_unlock_irqrestore(&ring->lock, flags);
0165     notify_remote_via_irq(ring->irq);
0166     p9_req_put(client, p9_req);
0167 
0168     return 0;
0169 }
0170 
0171 static void p9_xen_response(struct work_struct *work)
0172 {
0173     struct xen_9pfs_front_priv *priv;
0174     struct xen_9pfs_dataring *ring;
0175     RING_IDX cons, prod, masked_cons, masked_prod;
0176     struct xen_9pfs_header h;
0177     struct p9_req_t *req;
0178     int status;
0179 
0180     ring = container_of(work, struct xen_9pfs_dataring, work);
0181     priv = ring->priv;
0182 
0183     while (1) {
0184         cons = ring->intf->in_cons;
0185         prod = ring->intf->in_prod;
0186         virt_rmb();
0187 
0188         if (xen_9pfs_queued(prod, cons, XEN_9PFS_RING_SIZE(ring)) <
0189             sizeof(h)) {
0190             notify_remote_via_irq(ring->irq);
0191             return;
0192         }
0193 
0194         masked_prod = xen_9pfs_mask(prod, XEN_9PFS_RING_SIZE(ring));
0195         masked_cons = xen_9pfs_mask(cons, XEN_9PFS_RING_SIZE(ring));
0196 
0197         /* First, read just the header */
0198         xen_9pfs_read_packet(&h, ring->data.in, sizeof(h),
0199                      masked_prod, &masked_cons,
0200                      XEN_9PFS_RING_SIZE(ring));
0201 
0202         req = p9_tag_lookup(priv->client, h.tag);
0203         if (!req || req->status != REQ_STATUS_SENT) {
0204             dev_warn(&priv->dev->dev, "Wrong req tag=%x\n", h.tag);
0205             cons += h.size;
0206             virt_mb();
0207             ring->intf->in_cons = cons;
0208             continue;
0209         }
0210 
0211         memcpy(&req->rc, &h, sizeof(h));
0212         req->rc.offset = 0;
0213 
0214         masked_cons = xen_9pfs_mask(cons, XEN_9PFS_RING_SIZE(ring));
0215         /* Then, read the whole packet (including the header) */
0216         xen_9pfs_read_packet(req->rc.sdata, ring->data.in, h.size,
0217                      masked_prod, &masked_cons,
0218                      XEN_9PFS_RING_SIZE(ring));
0219 
0220         virt_mb();
0221         cons += h.size;
0222         ring->intf->in_cons = cons;
0223 
0224         status = (req->status != REQ_STATUS_ERROR) ?
0225             REQ_STATUS_RCVD : REQ_STATUS_ERROR;
0226 
0227         p9_client_cb(priv->client, req, status);
0228     }
0229 }
0230 
0231 static irqreturn_t xen_9pfs_front_event_handler(int irq, void *r)
0232 {
0233     struct xen_9pfs_dataring *ring = r;
0234 
0235     if (!ring || !ring->priv->client) {
0236         /* ignore spurious interrupt */
0237         return IRQ_HANDLED;
0238     }
0239 
0240     wake_up_interruptible(&ring->wq);
0241     schedule_work(&ring->work);
0242 
0243     return IRQ_HANDLED;
0244 }
0245 
0246 static struct p9_trans_module p9_xen_trans = {
0247     .name = "xen",
0248     .maxsize = 1 << (XEN_9PFS_RING_ORDER + XEN_PAGE_SHIFT - 2),
0249     .def = 1,
0250     .create = p9_xen_create,
0251     .close = p9_xen_close,
0252     .request = p9_xen_request,
0253     .cancel = p9_xen_cancel,
0254     .owner = THIS_MODULE,
0255 };
0256 
0257 static const struct xenbus_device_id xen_9pfs_front_ids[] = {
0258     { "9pfs" },
0259     { "" }
0260 };
0261 
0262 static void xen_9pfs_front_free(struct xen_9pfs_front_priv *priv)
0263 {
0264     int i, j;
0265 
0266     write_lock(&xen_9pfs_lock);
0267     list_del(&priv->list);
0268     write_unlock(&xen_9pfs_lock);
0269 
0270     for (i = 0; i < priv->num_rings; i++) {
0271         if (!priv->rings[i].intf)
0272             break;
0273         if (priv->rings[i].irq > 0)
0274             unbind_from_irqhandler(priv->rings[i].irq, priv->dev);
0275         if (priv->rings[i].data.in) {
0276             for (j = 0;
0277                  j < (1 << priv->rings[i].intf->ring_order);
0278                  j++) {
0279                 grant_ref_t ref;
0280 
0281                 ref = priv->rings[i].intf->ref[j];
0282                 gnttab_end_foreign_access(ref, NULL);
0283             }
0284             free_pages_exact(priv->rings[i].data.in,
0285                    1UL << (priv->rings[i].intf->ring_order +
0286                        XEN_PAGE_SHIFT));
0287         }
0288         gnttab_end_foreign_access(priv->rings[i].ref, NULL);
0289         free_page((unsigned long)priv->rings[i].intf);
0290     }
0291     kfree(priv->rings);
0292     kfree(priv->tag);
0293     kfree(priv);
0294 }
0295 
0296 static int xen_9pfs_front_remove(struct xenbus_device *dev)
0297 {
0298     struct xen_9pfs_front_priv *priv = dev_get_drvdata(&dev->dev);
0299 
0300     dev_set_drvdata(&dev->dev, NULL);
0301     xen_9pfs_front_free(priv);
0302     return 0;
0303 }
0304 
0305 static int xen_9pfs_front_alloc_dataring(struct xenbus_device *dev,
0306                      struct xen_9pfs_dataring *ring,
0307                      unsigned int order)
0308 {
0309     int i = 0;
0310     int ret = -ENOMEM;
0311     void *bytes = NULL;
0312 
0313     init_waitqueue_head(&ring->wq);
0314     spin_lock_init(&ring->lock);
0315     INIT_WORK(&ring->work, p9_xen_response);
0316 
0317     ring->intf = (struct xen_9pfs_data_intf *)get_zeroed_page(GFP_KERNEL);
0318     if (!ring->intf)
0319         return ret;
0320     ret = gnttab_grant_foreign_access(dev->otherend_id,
0321                       virt_to_gfn(ring->intf), 0);
0322     if (ret < 0)
0323         goto out;
0324     ring->ref = ret;
0325     bytes = alloc_pages_exact(1UL << (order + XEN_PAGE_SHIFT),
0326                   GFP_KERNEL | __GFP_ZERO);
0327     if (!bytes) {
0328         ret = -ENOMEM;
0329         goto out;
0330     }
0331     for (; i < (1 << order); i++) {
0332         ret = gnttab_grant_foreign_access(
0333                 dev->otherend_id, virt_to_gfn(bytes) + i, 0);
0334         if (ret < 0)
0335             goto out;
0336         ring->intf->ref[i] = ret;
0337     }
0338     ring->intf->ring_order = order;
0339     ring->data.in = bytes;
0340     ring->data.out = bytes + XEN_FLEX_RING_SIZE(order);
0341 
0342     ret = xenbus_alloc_evtchn(dev, &ring->evtchn);
0343     if (ret)
0344         goto out;
0345     ring->irq = bind_evtchn_to_irqhandler(ring->evtchn,
0346                           xen_9pfs_front_event_handler,
0347                           0, "xen_9pfs-frontend", ring);
0348     if (ring->irq >= 0)
0349         return 0;
0350 
0351     xenbus_free_evtchn(dev, ring->evtchn);
0352     ret = ring->irq;
0353 out:
0354     if (bytes) {
0355         for (i--; i >= 0; i--)
0356             gnttab_end_foreign_access(ring->intf->ref[i], NULL);
0357         free_pages_exact(bytes, 1UL << (order + XEN_PAGE_SHIFT));
0358     }
0359     gnttab_end_foreign_access(ring->ref, NULL);
0360     free_page((unsigned long)ring->intf);
0361     return ret;
0362 }
0363 
0364 static int xen_9pfs_front_probe(struct xenbus_device *dev,
0365                 const struct xenbus_device_id *id)
0366 {
0367     int ret, i;
0368     struct xenbus_transaction xbt;
0369     struct xen_9pfs_front_priv *priv = NULL;
0370     char *versions;
0371     unsigned int max_rings, max_ring_order, len = 0;
0372 
0373     versions = xenbus_read(XBT_NIL, dev->otherend, "versions", &len);
0374     if (IS_ERR(versions))
0375         return PTR_ERR(versions);
0376     if (strcmp(versions, "1")) {
0377         kfree(versions);
0378         return -EINVAL;
0379     }
0380     kfree(versions);
0381     max_rings = xenbus_read_unsigned(dev->otherend, "max-rings", 0);
0382     if (max_rings < XEN_9PFS_NUM_RINGS)
0383         return -EINVAL;
0384     max_ring_order = xenbus_read_unsigned(dev->otherend,
0385                           "max-ring-page-order", 0);
0386     if (max_ring_order > XEN_9PFS_RING_ORDER)
0387         max_ring_order = XEN_9PFS_RING_ORDER;
0388     if (p9_xen_trans.maxsize > XEN_FLEX_RING_SIZE(max_ring_order))
0389         p9_xen_trans.maxsize = XEN_FLEX_RING_SIZE(max_ring_order) / 2;
0390 
0391     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0392     if (!priv)
0393         return -ENOMEM;
0394 
0395     priv->dev = dev;
0396     priv->num_rings = XEN_9PFS_NUM_RINGS;
0397     priv->rings = kcalloc(priv->num_rings, sizeof(*priv->rings),
0398                   GFP_KERNEL);
0399     if (!priv->rings) {
0400         kfree(priv);
0401         return -ENOMEM;
0402     }
0403 
0404     for (i = 0; i < priv->num_rings; i++) {
0405         priv->rings[i].priv = priv;
0406         ret = xen_9pfs_front_alloc_dataring(dev, &priv->rings[i],
0407                             max_ring_order);
0408         if (ret < 0)
0409             goto error;
0410     }
0411 
0412  again:
0413     ret = xenbus_transaction_start(&xbt);
0414     if (ret) {
0415         xenbus_dev_fatal(dev, ret, "starting transaction");
0416         goto error;
0417     }
0418     ret = xenbus_printf(xbt, dev->nodename, "version", "%u", 1);
0419     if (ret)
0420         goto error_xenbus;
0421     ret = xenbus_printf(xbt, dev->nodename, "num-rings", "%u",
0422                 priv->num_rings);
0423     if (ret)
0424         goto error_xenbus;
0425     for (i = 0; i < priv->num_rings; i++) {
0426         char str[16];
0427 
0428         BUILD_BUG_ON(XEN_9PFS_NUM_RINGS > 9);
0429         sprintf(str, "ring-ref%d", i);
0430         ret = xenbus_printf(xbt, dev->nodename, str, "%d",
0431                     priv->rings[i].ref);
0432         if (ret)
0433             goto error_xenbus;
0434 
0435         sprintf(str, "event-channel-%d", i);
0436         ret = xenbus_printf(xbt, dev->nodename, str, "%u",
0437                     priv->rings[i].evtchn);
0438         if (ret)
0439             goto error_xenbus;
0440     }
0441     priv->tag = xenbus_read(xbt, dev->nodename, "tag", NULL);
0442     if (IS_ERR(priv->tag)) {
0443         ret = PTR_ERR(priv->tag);
0444         goto error_xenbus;
0445     }
0446     ret = xenbus_transaction_end(xbt, 0);
0447     if (ret) {
0448         if (ret == -EAGAIN)
0449             goto again;
0450         xenbus_dev_fatal(dev, ret, "completing transaction");
0451         goto error;
0452     }
0453 
0454     write_lock(&xen_9pfs_lock);
0455     list_add_tail(&priv->list, &xen_9pfs_devs);
0456     write_unlock(&xen_9pfs_lock);
0457     dev_set_drvdata(&dev->dev, priv);
0458     xenbus_switch_state(dev, XenbusStateInitialised);
0459 
0460     return 0;
0461 
0462  error_xenbus:
0463     xenbus_transaction_end(xbt, 1);
0464     xenbus_dev_fatal(dev, ret, "writing xenstore");
0465  error:
0466     dev_set_drvdata(&dev->dev, NULL);
0467     xen_9pfs_front_free(priv);
0468     return ret;
0469 }
0470 
0471 static int xen_9pfs_front_resume(struct xenbus_device *dev)
0472 {
0473     dev_warn(&dev->dev, "suspend/resume unsupported\n");
0474     return 0;
0475 }
0476 
0477 static void xen_9pfs_front_changed(struct xenbus_device *dev,
0478                    enum xenbus_state backend_state)
0479 {
0480     switch (backend_state) {
0481     case XenbusStateReconfiguring:
0482     case XenbusStateReconfigured:
0483     case XenbusStateInitialising:
0484     case XenbusStateInitialised:
0485     case XenbusStateUnknown:
0486         break;
0487 
0488     case XenbusStateInitWait:
0489         break;
0490 
0491     case XenbusStateConnected:
0492         xenbus_switch_state(dev, XenbusStateConnected);
0493         break;
0494 
0495     case XenbusStateClosed:
0496         if (dev->state == XenbusStateClosed)
0497             break;
0498         fallthrough;    /* Missed the backend's CLOSING state */
0499     case XenbusStateClosing:
0500         xenbus_frontend_closed(dev);
0501         break;
0502     }
0503 }
0504 
0505 static struct xenbus_driver xen_9pfs_front_driver = {
0506     .ids = xen_9pfs_front_ids,
0507     .probe = xen_9pfs_front_probe,
0508     .remove = xen_9pfs_front_remove,
0509     .resume = xen_9pfs_front_resume,
0510     .otherend_changed = xen_9pfs_front_changed,
0511 };
0512 
0513 static int p9_trans_xen_init(void)
0514 {
0515     int rc;
0516 
0517     if (!xen_domain())
0518         return -ENODEV;
0519 
0520     pr_info("Initialising Xen transport for 9pfs\n");
0521 
0522     v9fs_register_trans(&p9_xen_trans);
0523     rc = xenbus_register_frontend(&xen_9pfs_front_driver);
0524     if (rc)
0525         v9fs_unregister_trans(&p9_xen_trans);
0526 
0527     return rc;
0528 }
0529 module_init(p9_trans_xen_init);
0530 MODULE_ALIAS_9P("xen");
0531 
0532 static void p9_trans_xen_exit(void)
0533 {
0534     v9fs_unregister_trans(&p9_xen_trans);
0535     return xenbus_unregister_driver(&xen_9pfs_front_driver);
0536 }
0537 module_exit(p9_trans_xen_exit);
0538 
0539 MODULE_ALIAS("xen:9pfs");
0540 MODULE_AUTHOR("Stefano Stabellini <stefano@aporeto.com>");
0541 MODULE_DESCRIPTION("Xen Transport for 9P");
0542 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!