drivers/xen/blktap/interface.c

   1 /******************************************************************************
   2  * drivers/xen/blktap/interface.c
   3  *
   4  * Block-device interface management.
   5  *
   6  * Copyright (c) 2004, Keir Fraser
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version 2
  10  * as published by the Free Software Foundation; or, when distributed
  11  * separately from the Linux kernel or incorporated into other
  12  * software packages, subject to the following license:
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a copy
  15  * of this source file (the "Software"), to deal in the Software without
  16  * restriction, including without limitation the rights to use, copy, modify,
  17  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  18  * and to permit persons to whom the Software is furnished to do so, subject to
  19  * the following conditions:
  20  *
  21  * The above copyright notice and this permission notice shall be included in
  22  * all copies or substantial portions of the Software.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  27  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  29  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  30  * IN THE SOFTWARE.
  31
  32  */
  33
  34 #include "common.h"
  35 #include <xen/evtchn.h>
  36
  37 static kmem_cache_t *blkif_cachep;
  38
  39 blkif_t *tap_alloc_blkif(domid_t domid)
  40 {
  41         blkif_t *blkif;
  42
  43         blkif = kmem_cache_alloc(blkif_cachep, GFP_KERNEL);
  44         if (!blkif)
  45                 return ERR_PTR(-ENOMEM);
  46
  47         memset(blkif, 0, sizeof(*blkif));
  48         blkif->domid = domid;
  49         spin_lock_init(&blkif->blk_ring_lock);
  50         atomic_set(&blkif->refcnt, 1);
  51         init_waitqueue_head(&blkif->wq);
  52         blkif->st_print = jiffies;
  53         init_waitqueue_head(&blkif->waiting_to_free);
  54
  55         return blkif;
  56 }
  57
  58 static int map_frontend_page(blkif_t *blkif, unsigned long shared_page)
  59 {
  60         struct gnttab_map_grant_ref op;
  61         int ret;
  62
  63         gnttab_set_map_op(&op, (unsigned long)blkif->blk_ring_area->addr,
  64                           GNTMAP_host_map, shared_page, blkif->domid);
  65
  66         lock_vm_area(blkif->blk_ring_area);
  67         ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1);
  68         unlock_vm_area(blkif->blk_ring_area);
  69         BUG_ON(ret);
  70
  71         if (op.status) {
  72                 DPRINTK(" Grant table operation failure !\n");
  73                 return op.status;
  74         }
  75
  76         blkif->shmem_ref = shared_page;
  77         blkif->shmem_handle = op.handle;
  78
  79         return 0;
  80 }
  81
  82 static void unmap_frontend_page(blkif_t *blkif)
  83 {
  84         struct gnttab_unmap_grant_ref op;
  85         int ret;
  86
  87         gnttab_set_unmap_op(&op, (unsigned long)blkif->blk_ring_area->addr,
  88                             GNTMAP_host_map, blkif->shmem_handle);
  89
  90         lock_vm_area(blkif->blk_ring_area);
  91         ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1);
  92         unlock_vm_area(blkif->blk_ring_area);
  93         BUG_ON(ret);
  94 }
  95
  96 int tap_blkif_map(blkif_t *blkif, unsigned long shared_page,
  97                   unsigned int evtchn)
  98 {
  99         blkif_sring_t *sring;
 100         int err;
 101         struct evtchn_bind_interdomain bind_interdomain;
 102
 103         /* Already connected through? */
 104         if (blkif->irq)
 105                 return 0;
 106
 107         if ( (blkif->blk_ring_area = alloc_vm_area(PAGE_SIZE)) == NULL )
 108                 return -ENOMEM;
 109
 110         err = map_frontend_page(blkif, shared_page);
 111         if (err) {
 112                 free_vm_area(blkif->blk_ring_area);
 113                 return err;
 114         }
 115
 116         bind_interdomain.remote_dom  = blkif->domid;
 117         bind_interdomain.remote_port = evtchn;
 118
 119         err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
 120                                           &bind_interdomain);
 121         if (err) {
 122                 unmap_frontend_page(blkif);
 123                 free_vm_area(blkif->blk_ring_area);
 124                 return err;
 125         }
 126
 127         blkif->evtchn = bind_interdomain.local_port;
 128
 129         sring = (blkif_sring_t *)blkif->blk_ring_area->addr;
 130         BACK_RING_INIT(&blkif->blk_ring, sring, PAGE_SIZE);
 131
 132         blkif->irq = bind_evtchn_to_irqhandler(
 133                 blkif->evtchn, tap_blkif_be_int, 0, "blkif-backend", blkif);
 134
 135         return 0;
 136 }
 137
 138 void tap_blkif_free(blkif_t *blkif)
 139 {
 140         atomic_dec(&blkif->refcnt);
 141         wait_event(blkif->waiting_to_free, atomic_read(&blkif->refcnt) == 0);
 142
 143         /* Already disconnected? */
 144         if (blkif->irq)
 145                 unbind_from_irqhandler(blkif->irq, blkif);
 146
 147         if (blkif->blk_ring.sring) {
 148                 unmap_frontend_page(blkif);
 149                 free_vm_area(blkif->blk_ring_area);
 150         }
 151
 152         kmem_cache_free(blkif_cachep, blkif);
 153 }
 154
 155 void __init tap_blkif_interface_init(void)
 156 {
 157         blkif_cachep = kmem_cache_create("blktapif_cache", sizeof(blkif_t),
 158                                          0, 0, NULL, NULL);
 159 }