mirror of
https://github.com/torvalds/linux
synced 2024-10-04 02:10:58 +00:00
xen: add blkback support
Signed-off-by: Ian Campbell <ian.campbell@citrix.com> Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com> Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com> Conflicts: drivers/xen/Makefile
This commit is contained in:
parent
a6360dd37e
commit
4d05a28db5
|
@ -37,6 +37,14 @@ config XEN_BACKEND
|
||||||
Support for backend device drivers that provide I/O services
|
Support for backend device drivers that provide I/O services
|
||||||
to other virtual machines.
|
to other virtual machines.
|
||||||
|
|
||||||
|
config XEN_BLKDEV_BACKEND
|
||||||
|
tristate "Block-device backend driver"
|
||||||
|
depends on XEN_BACKEND && BLOCK
|
||||||
|
help
|
||||||
|
The block-device backend driver allows the kernel to export its
|
||||||
|
block devices to other guests via a high-performance shared-memory
|
||||||
|
interface.
|
||||||
|
|
||||||
config XENFS
|
config XENFS
|
||||||
tristate "Xen filesystem"
|
tristate "Xen filesystem"
|
||||||
default y
|
default y
|
||||||
|
|
|
@ -11,6 +11,7 @@ obj-$(CONFIG_XEN_BALLOON) += xen-balloon.o
|
||||||
obj-$(CONFIG_XEN_DEV_EVTCHN) += xen-evtchn.o
|
obj-$(CONFIG_XEN_DEV_EVTCHN) += xen-evtchn.o
|
||||||
obj-$(CONFIG_XEN_GNTDEV) += xen-gntdev.o
|
obj-$(CONFIG_XEN_GNTDEV) += xen-gntdev.o
|
||||||
obj-$(CONFIG_XEN_GRANT_DEV_ALLOC) += xen-gntalloc.o
|
obj-$(CONFIG_XEN_GRANT_DEV_ALLOC) += xen-gntalloc.o
|
||||||
|
obj-$(CONFIG_XEN_BLKDEV_BACKEND) += blkback/
|
||||||
obj-$(CONFIG_XENFS) += xenfs/
|
obj-$(CONFIG_XENFS) += xenfs/
|
||||||
obj-$(CONFIG_XEN_SYS_HYPERVISOR) += sys-hypervisor.o
|
obj-$(CONFIG_XEN_SYS_HYPERVISOR) += sys-hypervisor.o
|
||||||
obj-$(CONFIG_XEN_PLATFORM_PCI) += xen-platform-pci.o
|
obj-$(CONFIG_XEN_PLATFORM_PCI) += xen-platform-pci.o
|
||||||
|
|
3
drivers/xen/blkback/Makefile
Normal file
3
drivers/xen/blkback/Makefile
Normal file
|
@ -0,0 +1,3 @@
|
||||||
|
obj-$(CONFIG_XEN_BLKDEV_BACKEND) := blkbk.o
|
||||||
|
|
||||||
|
blkbk-y := blkback.o xenbus.o interface.o vbd.o
|
656
drivers/xen/blkback/blkback.c
Normal file
656
drivers/xen/blkback/blkback.c
Normal file
|
@ -0,0 +1,656 @@
|
||||||
|
/******************************************************************************
|
||||||
|
* arch/xen/drivers/blkif/backend/main.c
|
||||||
|
*
|
||||||
|
* Back-end of the driver for virtual block devices. This portion of the
|
||||||
|
* driver exports a 'unified' block-device interface that can be accessed
|
||||||
|
* by any operating system that implements a compatible front end. A
|
||||||
|
* reference front-end implementation can be found in:
|
||||||
|
* arch/xen/drivers/blkif/frontend
|
||||||
|
*
|
||||||
|
* Copyright (c) 2003-2004, Keir Fraser & Steve Hand
|
||||||
|
* Copyright (c) 2005, Christopher Clark
|
||||||
|
*
|
||||||
|
* This program is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License version 2
|
||||||
|
* as published by the Free Software Foundation; or, when distributed
|
||||||
|
* separately from the Linux kernel or incorporated into other
|
||||||
|
* software packages, subject to the following license:
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
* of this source file (the "Software"), to deal in the Software without
|
||||||
|
* restriction, including without limitation the rights to use, copy, modify,
|
||||||
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
||||||
|
* the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be included in
|
||||||
|
* all copies or substantial portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||||
|
* IN THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <linux/spinlock.h>
|
||||||
|
#include <linux/kthread.h>
|
||||||
|
#include <linux/list.h>
|
||||||
|
#include <linux/delay.h>
|
||||||
|
#include <xen/balloon.h>
|
||||||
|
#include <asm/hypervisor.h>
|
||||||
|
#include "common.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* These are rather arbitrary. They are fairly large because adjacent requests
|
||||||
|
* pulled from a communication ring are quite likely to end up being part of
|
||||||
|
* the same scatter/gather request at the disc.
|
||||||
|
*
|
||||||
|
* ** TRY INCREASING 'blkif_reqs' IF WRITE SPEEDS SEEM TOO LOW **
|
||||||
|
*
|
||||||
|
* This will increase the chances of being able to write whole tracks.
|
||||||
|
* 64 should be enough to keep us competitive with Linux.
|
||||||
|
*/
|
||||||
|
static int blkif_reqs = 64;
|
||||||
|
module_param_named(reqs, blkif_reqs, int, 0);
|
||||||
|
MODULE_PARM_DESC(reqs, "Number of blkback requests to allocate");
|
||||||
|
|
||||||
|
/* Run-time switchable: /sys/module/blkback/parameters/ */
|
||||||
|
static unsigned int log_stats = 0;
|
||||||
|
static unsigned int debug_lvl = 0;
|
||||||
|
module_param(log_stats, int, 0644);
|
||||||
|
module_param(debug_lvl, int, 0644);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Each outstanding request that we've passed to the lower device layers has a
|
||||||
|
* 'pending_req' allocated to it. Each buffer_head that completes decrements
|
||||||
|
* the pendcnt towards zero. When it hits zero, the specified domain has a
|
||||||
|
* response queued for it, with the saved 'id' passed back.
|
||||||
|
*/
|
||||||
|
typedef struct {
|
||||||
|
blkif_t *blkif;
|
||||||
|
u64 id;
|
||||||
|
int nr_pages;
|
||||||
|
atomic_t pendcnt;
|
||||||
|
unsigned short operation;
|
||||||
|
int status;
|
||||||
|
struct list_head free_list;
|
||||||
|
} pending_req_t;
|
||||||
|
|
||||||
|
static pending_req_t *pending_reqs;
|
||||||
|
static struct list_head pending_free;
|
||||||
|
static DEFINE_SPINLOCK(pending_free_lock);
|
||||||
|
static DECLARE_WAIT_QUEUE_HEAD(pending_free_wq);
|
||||||
|
|
||||||
|
#define BLKBACK_INVALID_HANDLE (~0)
|
||||||
|
|
||||||
|
static struct page **pending_pages;
|
||||||
|
static grant_handle_t *pending_grant_handles;
|
||||||
|
|
||||||
|
static inline int vaddr_pagenr(pending_req_t *req, int seg)
|
||||||
|
{
|
||||||
|
return (req - pending_reqs) * BLKIF_MAX_SEGMENTS_PER_REQUEST + seg;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline unsigned long vaddr(pending_req_t *req, int seg)
|
||||||
|
{
|
||||||
|
unsigned long pfn = page_to_pfn(pending_pages[vaddr_pagenr(req, seg)]);
|
||||||
|
return (unsigned long)pfn_to_kaddr(pfn);
|
||||||
|
}
|
||||||
|
|
||||||
|
#define pending_handle(_req, _seg) \
|
||||||
|
(pending_grant_handles[vaddr_pagenr(_req, _seg)])
|
||||||
|
|
||||||
|
|
||||||
|
static int do_block_io_op(blkif_t *blkif);
|
||||||
|
static void dispatch_rw_block_io(blkif_t *blkif,
|
||||||
|
blkif_request_t *req,
|
||||||
|
pending_req_t *pending_req);
|
||||||
|
static void make_response(blkif_t *blkif, u64 id,
|
||||||
|
unsigned short op, int st);
|
||||||
|
|
||||||
|
/******************************************************************
|
||||||
|
* misc small helpers
|
||||||
|
*/
|
||||||
|
static pending_req_t* alloc_req(void)
|
||||||
|
{
|
||||||
|
pending_req_t *req = NULL;
|
||||||
|
unsigned long flags;
|
||||||
|
|
||||||
|
spin_lock_irqsave(&pending_free_lock, flags);
|
||||||
|
if (!list_empty(&pending_free)) {
|
||||||
|
req = list_entry(pending_free.next, pending_req_t, free_list);
|
||||||
|
list_del(&req->free_list);
|
||||||
|
}
|
||||||
|
spin_unlock_irqrestore(&pending_free_lock, flags);
|
||||||
|
return req;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void free_req(pending_req_t *req)
|
||||||
|
{
|
||||||
|
unsigned long flags;
|
||||||
|
int was_empty;
|
||||||
|
|
||||||
|
spin_lock_irqsave(&pending_free_lock, flags);
|
||||||
|
was_empty = list_empty(&pending_free);
|
||||||
|
list_add(&req->free_list, &pending_free);
|
||||||
|
spin_unlock_irqrestore(&pending_free_lock, flags);
|
||||||
|
if (was_empty)
|
||||||
|
wake_up(&pending_free_wq);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void unplug_queue(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
if (blkif->plug == NULL)
|
||||||
|
return;
|
||||||
|
if (blkif->plug->unplug_fn)
|
||||||
|
blkif->plug->unplug_fn(blkif->plug);
|
||||||
|
blk_put_queue(blkif->plug);
|
||||||
|
blkif->plug = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void plug_queue(blkif_t *blkif, struct block_device *bdev)
|
||||||
|
{
|
||||||
|
request_queue_t *q = bdev_get_queue(bdev);
|
||||||
|
|
||||||
|
if (q == blkif->plug)
|
||||||
|
return;
|
||||||
|
unplug_queue(blkif);
|
||||||
|
blk_get_queue(q);
|
||||||
|
blkif->plug = q;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void fast_flush_area(pending_req_t *req)
|
||||||
|
{
|
||||||
|
struct gnttab_unmap_grant_ref unmap[BLKIF_MAX_SEGMENTS_PER_REQUEST];
|
||||||
|
unsigned int i, invcount = 0;
|
||||||
|
grant_handle_t handle;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
for (i = 0; i < req->nr_pages; i++) {
|
||||||
|
handle = pending_handle(req, i);
|
||||||
|
if (handle == BLKBACK_INVALID_HANDLE)
|
||||||
|
continue;
|
||||||
|
gnttab_set_unmap_op(&unmap[invcount], vaddr(req, i),
|
||||||
|
GNTMAP_host_map, handle);
|
||||||
|
pending_handle(req, i) = BLKBACK_INVALID_HANDLE;
|
||||||
|
invcount++;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = HYPERVISOR_grant_table_op(
|
||||||
|
GNTTABOP_unmap_grant_ref, unmap, invcount);
|
||||||
|
BUG_ON(ret);
|
||||||
|
}
|
||||||
|
|
||||||
|
/******************************************************************
|
||||||
|
* SCHEDULER FUNCTIONS
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void print_stats(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
printk(KERN_DEBUG "%s: oo %3d | rd %4d | wr %4d | br %4d\n",
|
||||||
|
current->comm, blkif->st_oo_req,
|
||||||
|
blkif->st_rd_req, blkif->st_wr_req, blkif->st_br_req);
|
||||||
|
blkif->st_print = jiffies + msecs_to_jiffies(10 * 1000);
|
||||||
|
blkif->st_rd_req = 0;
|
||||||
|
blkif->st_wr_req = 0;
|
||||||
|
blkif->st_oo_req = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int blkif_schedule(void *arg)
|
||||||
|
{
|
||||||
|
blkif_t *blkif = arg;
|
||||||
|
|
||||||
|
blkif_get(blkif);
|
||||||
|
|
||||||
|
if (debug_lvl)
|
||||||
|
printk(KERN_DEBUG "%s: started\n", current->comm);
|
||||||
|
|
||||||
|
while (!kthread_should_stop()) {
|
||||||
|
if (try_to_freeze())
|
||||||
|
continue;
|
||||||
|
|
||||||
|
wait_event_interruptible(
|
||||||
|
blkif->wq,
|
||||||
|
blkif->waiting_reqs || kthread_should_stop());
|
||||||
|
wait_event_interruptible(
|
||||||
|
pending_free_wq,
|
||||||
|
!list_empty(&pending_free) || kthread_should_stop());
|
||||||
|
|
||||||
|
blkif->waiting_reqs = 0;
|
||||||
|
smp_mb(); /* clear flag *before* checking for work */
|
||||||
|
|
||||||
|
if (do_block_io_op(blkif))
|
||||||
|
blkif->waiting_reqs = 1;
|
||||||
|
unplug_queue(blkif);
|
||||||
|
|
||||||
|
if (log_stats && time_after(jiffies, blkif->st_print))
|
||||||
|
print_stats(blkif);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (log_stats)
|
||||||
|
print_stats(blkif);
|
||||||
|
if (debug_lvl)
|
||||||
|
printk(KERN_DEBUG "%s: exiting\n", current->comm);
|
||||||
|
|
||||||
|
blkif->xenblkd = NULL;
|
||||||
|
blkif_put(blkif);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/******************************************************************
|
||||||
|
* COMPLETION CALLBACK -- Called as bh->b_end_io()
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void __end_block_io_op(pending_req_t *pending_req, int error)
|
||||||
|
{
|
||||||
|
/* An error fails the entire request. */
|
||||||
|
if ((pending_req->operation == BLKIF_OP_WRITE_BARRIER) &&
|
||||||
|
(error == -EOPNOTSUPP)) {
|
||||||
|
DPRINTK("blkback: write barrier op failed, not supported\n");
|
||||||
|
blkback_barrier(XBT_NIL, pending_req->blkif->be, 0);
|
||||||
|
pending_req->status = BLKIF_RSP_EOPNOTSUPP;
|
||||||
|
} else if (error) {
|
||||||
|
DPRINTK("Buffer not up-to-date at end of operation, "
|
||||||
|
"error=%d\n", error);
|
||||||
|
pending_req->status = BLKIF_RSP_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (atomic_dec_and_test(&pending_req->pendcnt)) {
|
||||||
|
fast_flush_area(pending_req);
|
||||||
|
make_response(pending_req->blkif, pending_req->id,
|
||||||
|
pending_req->operation, pending_req->status);
|
||||||
|
blkif_put(pending_req->blkif);
|
||||||
|
free_req(pending_req);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int end_block_io_op(struct bio *bio, unsigned int done, int error)
|
||||||
|
{
|
||||||
|
if (bio->bi_size != 0)
|
||||||
|
return 1;
|
||||||
|
__end_block_io_op(bio->bi_private, error);
|
||||||
|
bio_put(bio);
|
||||||
|
return error;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/******************************************************************************
|
||||||
|
* NOTIFICATION FROM GUEST OS.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static void blkif_notify_work(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
blkif->waiting_reqs = 1;
|
||||||
|
wake_up(&blkif->wq);
|
||||||
|
}
|
||||||
|
|
||||||
|
irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs)
|
||||||
|
{
|
||||||
|
blkif_notify_work(dev_id);
|
||||||
|
return IRQ_HANDLED;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/******************************************************************
|
||||||
|
* DOWNWARD CALLS -- These interface with the block-device layer proper.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static int do_block_io_op(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
blkif_back_rings_t *blk_rings = &blkif->blk_rings;
|
||||||
|
blkif_request_t req;
|
||||||
|
pending_req_t *pending_req;
|
||||||
|
RING_IDX rc, rp;
|
||||||
|
int more_to_do = 0;
|
||||||
|
|
||||||
|
rc = blk_rings->common.req_cons;
|
||||||
|
rp = blk_rings->common.sring->req_prod;
|
||||||
|
rmb(); /* Ensure we see queued requests up to 'rp'. */
|
||||||
|
|
||||||
|
while (rc != rp) {
|
||||||
|
|
||||||
|
if (RING_REQUEST_CONS_OVERFLOW(&blk_rings->common, rc))
|
||||||
|
break;
|
||||||
|
|
||||||
|
pending_req = alloc_req();
|
||||||
|
if (NULL == pending_req) {
|
||||||
|
blkif->st_oo_req++;
|
||||||
|
more_to_do = 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (kthread_should_stop()) {
|
||||||
|
more_to_do = 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (blkif->blk_protocol) {
|
||||||
|
case BLKIF_PROTOCOL_NATIVE:
|
||||||
|
memcpy(&req, RING_GET_REQUEST(&blk_rings->native, rc), sizeof(req));
|
||||||
|
break;
|
||||||
|
case BLKIF_PROTOCOL_X86_32:
|
||||||
|
blkif_get_x86_32_req(&req, RING_GET_REQUEST(&blk_rings->x86_32, rc));
|
||||||
|
break;
|
||||||
|
case BLKIF_PROTOCOL_X86_64:
|
||||||
|
blkif_get_x86_64_req(&req, RING_GET_REQUEST(&blk_rings->x86_64, rc));
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
BUG();
|
||||||
|
}
|
||||||
|
blk_rings->common.req_cons = ++rc; /* before make_response() */
|
||||||
|
|
||||||
|
/* Apply all sanity checks to /private copy/ of request. */
|
||||||
|
barrier();
|
||||||
|
|
||||||
|
switch (req.operation) {
|
||||||
|
case BLKIF_OP_READ:
|
||||||
|
blkif->st_rd_req++;
|
||||||
|
dispatch_rw_block_io(blkif, &req, pending_req);
|
||||||
|
break;
|
||||||
|
case BLKIF_OP_WRITE_BARRIER:
|
||||||
|
blkif->st_br_req++;
|
||||||
|
/* fall through */
|
||||||
|
case BLKIF_OP_WRITE:
|
||||||
|
blkif->st_wr_req++;
|
||||||
|
dispatch_rw_block_io(blkif, &req, pending_req);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
/* A good sign something is wrong: sleep for a while to
|
||||||
|
* avoid excessive CPU consumption by a bad guest. */
|
||||||
|
msleep(1);
|
||||||
|
DPRINTK("error: unknown block io operation [%d]\n",
|
||||||
|
req.operation);
|
||||||
|
make_response(blkif, req.id, req.operation,
|
||||||
|
BLKIF_RSP_ERROR);
|
||||||
|
free_req(pending_req);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Yield point for this unbounded loop. */
|
||||||
|
cond_resched();
|
||||||
|
}
|
||||||
|
|
||||||
|
return more_to_do;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void dispatch_rw_block_io(blkif_t *blkif,
|
||||||
|
blkif_request_t *req,
|
||||||
|
pending_req_t *pending_req)
|
||||||
|
{
|
||||||
|
extern void ll_rw_block(int rw, int nr, struct buffer_head * bhs[]);
|
||||||
|
struct gnttab_map_grant_ref map[BLKIF_MAX_SEGMENTS_PER_REQUEST];
|
||||||
|
struct phys_req preq;
|
||||||
|
struct {
|
||||||
|
unsigned long buf; unsigned int nsec;
|
||||||
|
} seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
|
||||||
|
unsigned int nseg;
|
||||||
|
struct bio *bio = NULL;
|
||||||
|
int ret, i;
|
||||||
|
int operation;
|
||||||
|
|
||||||
|
switch (req->operation) {
|
||||||
|
case BLKIF_OP_READ:
|
||||||
|
operation = READ;
|
||||||
|
break;
|
||||||
|
case BLKIF_OP_WRITE:
|
||||||
|
operation = WRITE;
|
||||||
|
break;
|
||||||
|
case BLKIF_OP_WRITE_BARRIER:
|
||||||
|
operation = WRITE_BARRIER;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
operation = 0; /* make gcc happy */
|
||||||
|
BUG();
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Check that number of segments is sane. */
|
||||||
|
nseg = req->nr_segments;
|
||||||
|
if (unlikely(nseg == 0 && operation != WRITE_BARRIER) ||
|
||||||
|
unlikely(nseg > BLKIF_MAX_SEGMENTS_PER_REQUEST)) {
|
||||||
|
DPRINTK("Bad number of segments in request (%d)\n", nseg);
|
||||||
|
goto fail_response;
|
||||||
|
}
|
||||||
|
|
||||||
|
preq.dev = req->handle;
|
||||||
|
preq.sector_number = req->sector_number;
|
||||||
|
preq.nr_sects = 0;
|
||||||
|
|
||||||
|
pending_req->blkif = blkif;
|
||||||
|
pending_req->id = req->id;
|
||||||
|
pending_req->operation = req->operation;
|
||||||
|
pending_req->status = BLKIF_RSP_OKAY;
|
||||||
|
pending_req->nr_pages = nseg;
|
||||||
|
|
||||||
|
for (i = 0; i < nseg; i++) {
|
||||||
|
uint32_t flags;
|
||||||
|
|
||||||
|
seg[i].nsec = req->seg[i].last_sect -
|
||||||
|
req->seg[i].first_sect + 1;
|
||||||
|
|
||||||
|
if ((req->seg[i].last_sect >= (PAGE_SIZE >> 9)) ||
|
||||||
|
(req->seg[i].last_sect < req->seg[i].first_sect))
|
||||||
|
goto fail_response;
|
||||||
|
preq.nr_sects += seg[i].nsec;
|
||||||
|
|
||||||
|
flags = GNTMAP_host_map;
|
||||||
|
if (operation != READ)
|
||||||
|
flags |= GNTMAP_readonly;
|
||||||
|
gnttab_set_map_op(&map[i], vaddr(pending_req, i), flags,
|
||||||
|
req->seg[i].gref, blkif->domid);
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, map, nseg);
|
||||||
|
BUG_ON(ret);
|
||||||
|
|
||||||
|
for (i = 0; i < nseg; i++) {
|
||||||
|
if (unlikely(map[i].status != 0)) {
|
||||||
|
DPRINTK("invalid buffer -- could not remap it\n");
|
||||||
|
map[i].handle = BLKBACK_INVALID_HANDLE;
|
||||||
|
ret |= 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
pending_handle(pending_req, i) = map[i].handle;
|
||||||
|
|
||||||
|
if (ret)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
set_phys_to_machine(__pa(vaddr(
|
||||||
|
pending_req, i)) >> PAGE_SHIFT,
|
||||||
|
FOREIGN_FRAME(map[i].dev_bus_addr >> PAGE_SHIFT));
|
||||||
|
seg[i].buf = map[i].dev_bus_addr |
|
||||||
|
(req->seg[i].first_sect << 9);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ret)
|
||||||
|
goto fail_flush;
|
||||||
|
|
||||||
|
if (vbd_translate(&preq, blkif, operation) != 0) {
|
||||||
|
DPRINTK("access denied: %s of [%llu,%llu] on dev=%04x\n",
|
||||||
|
operation == READ ? "read" : "write",
|
||||||
|
preq.sector_number,
|
||||||
|
preq.sector_number + preq.nr_sects, preq.dev);
|
||||||
|
goto fail_flush;
|
||||||
|
}
|
||||||
|
|
||||||
|
plug_queue(blkif, preq.bdev);
|
||||||
|
atomic_set(&pending_req->pendcnt, 1);
|
||||||
|
blkif_get(blkif);
|
||||||
|
|
||||||
|
for (i = 0; i < nseg; i++) {
|
||||||
|
if (((int)preq.sector_number|(int)seg[i].nsec) &
|
||||||
|
((bdev_hardsect_size(preq.bdev) >> 9) - 1)) {
|
||||||
|
DPRINTK("Misaligned I/O request from domain %d",
|
||||||
|
blkif->domid);
|
||||||
|
goto fail_put_bio;
|
||||||
|
}
|
||||||
|
|
||||||
|
while ((bio == NULL) ||
|
||||||
|
(bio_add_page(bio,
|
||||||
|
virt_to_page(vaddr(pending_req, i)),
|
||||||
|
seg[i].nsec << 9,
|
||||||
|
seg[i].buf & ~PAGE_MASK) == 0)) {
|
||||||
|
if (bio) {
|
||||||
|
atomic_inc(&pending_req->pendcnt);
|
||||||
|
submit_bio(operation, bio);
|
||||||
|
}
|
||||||
|
|
||||||
|
bio = bio_alloc(GFP_KERNEL, nseg-i);
|
||||||
|
if (unlikely(bio == NULL))
|
||||||
|
goto fail_put_bio;
|
||||||
|
|
||||||
|
bio->bi_bdev = preq.bdev;
|
||||||
|
bio->bi_private = pending_req;
|
||||||
|
bio->bi_end_io = end_block_io_op;
|
||||||
|
bio->bi_sector = preq.sector_number;
|
||||||
|
}
|
||||||
|
|
||||||
|
preq.sector_number += seg[i].nsec;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!bio) {
|
||||||
|
BUG_ON(operation != WRITE_BARRIER);
|
||||||
|
bio = bio_alloc(GFP_KERNEL, 0);
|
||||||
|
if (unlikely(bio == NULL))
|
||||||
|
goto fail_put_bio;
|
||||||
|
|
||||||
|
bio->bi_bdev = preq.bdev;
|
||||||
|
bio->bi_private = pending_req;
|
||||||
|
bio->bi_end_io = end_block_io_op;
|
||||||
|
bio->bi_sector = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
submit_bio(operation, bio);
|
||||||
|
|
||||||
|
if (operation == READ)
|
||||||
|
blkif->st_rd_sect += preq.nr_sects;
|
||||||
|
else if (operation == WRITE || operation == WRITE_BARRIER)
|
||||||
|
blkif->st_wr_sect += preq.nr_sects;
|
||||||
|
|
||||||
|
return;
|
||||||
|
|
||||||
|
fail_flush:
|
||||||
|
fast_flush_area(pending_req);
|
||||||
|
fail_response:
|
||||||
|
make_response(blkif, req->id, req->operation, BLKIF_RSP_ERROR);
|
||||||
|
free_req(pending_req);
|
||||||
|
msleep(1); /* back off a bit */
|
||||||
|
return;
|
||||||
|
|
||||||
|
fail_put_bio:
|
||||||
|
__end_block_io_op(pending_req, -EINVAL);
|
||||||
|
if (bio)
|
||||||
|
bio_put(bio);
|
||||||
|
unplug_queue(blkif);
|
||||||
|
msleep(1); /* back off a bit */
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/******************************************************************
|
||||||
|
* MISCELLANEOUS SETUP / TEARDOWN / DEBUGGING
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
static void make_response(blkif_t *blkif, u64 id,
|
||||||
|
unsigned short op, int st)
|
||||||
|
{
|
||||||
|
blkif_response_t resp;
|
||||||
|
unsigned long flags;
|
||||||
|
blkif_back_rings_t *blk_rings = &blkif->blk_rings;
|
||||||
|
int more_to_do = 0;
|
||||||
|
int notify;
|
||||||
|
|
||||||
|
resp.id = id;
|
||||||
|
resp.operation = op;
|
||||||
|
resp.status = st;
|
||||||
|
|
||||||
|
spin_lock_irqsave(&blkif->blk_ring_lock, flags);
|
||||||
|
/* Place on the response ring for the relevant domain. */
|
||||||
|
switch (blkif->blk_protocol) {
|
||||||
|
case BLKIF_PROTOCOL_NATIVE:
|
||||||
|
memcpy(RING_GET_RESPONSE(&blk_rings->native, blk_rings->native.rsp_prod_pvt),
|
||||||
|
&resp, sizeof(resp));
|
||||||
|
break;
|
||||||
|
case BLKIF_PROTOCOL_X86_32:
|
||||||
|
memcpy(RING_GET_RESPONSE(&blk_rings->x86_32, blk_rings->x86_32.rsp_prod_pvt),
|
||||||
|
&resp, sizeof(resp));
|
||||||
|
break;
|
||||||
|
case BLKIF_PROTOCOL_X86_64:
|
||||||
|
memcpy(RING_GET_RESPONSE(&blk_rings->x86_64, blk_rings->x86_64.rsp_prod_pvt),
|
||||||
|
&resp, sizeof(resp));
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
BUG();
|
||||||
|
}
|
||||||
|
blk_rings->common.rsp_prod_pvt++;
|
||||||
|
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&blk_rings->common, notify);
|
||||||
|
if (blk_rings->common.rsp_prod_pvt == blk_rings->common.req_cons) {
|
||||||
|
/*
|
||||||
|
* Tail check for pending requests. Allows frontend to avoid
|
||||||
|
* notifications if requests are already in flight (lower
|
||||||
|
* overheads and promotes batching).
|
||||||
|
*/
|
||||||
|
RING_FINAL_CHECK_FOR_REQUESTS(&blk_rings->common, more_to_do);
|
||||||
|
|
||||||
|
} else if (RING_HAS_UNCONSUMED_REQUESTS(&blk_rings->common)) {
|
||||||
|
more_to_do = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
spin_unlock_irqrestore(&blkif->blk_ring_lock, flags);
|
||||||
|
|
||||||
|
if (more_to_do)
|
||||||
|
blkif_notify_work(blkif);
|
||||||
|
if (notify)
|
||||||
|
notify_remote_via_irq(blkif->irq);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int __init blkif_init(void)
|
||||||
|
{
|
||||||
|
int i, mmap_pages;
|
||||||
|
|
||||||
|
if (!is_running_on_xen())
|
||||||
|
return -ENODEV;
|
||||||
|
|
||||||
|
mmap_pages = blkif_reqs * BLKIF_MAX_SEGMENTS_PER_REQUEST;
|
||||||
|
|
||||||
|
pending_reqs = kmalloc(sizeof(pending_reqs[0]) *
|
||||||
|
blkif_reqs, GFP_KERNEL);
|
||||||
|
pending_grant_handles = kmalloc(sizeof(pending_grant_handles[0]) *
|
||||||
|
mmap_pages, GFP_KERNEL);
|
||||||
|
pending_pages = alloc_empty_pages_and_pagevec(mmap_pages);
|
||||||
|
|
||||||
|
if (!pending_reqs || !pending_grant_handles || !pending_pages)
|
||||||
|
goto out_of_memory;
|
||||||
|
|
||||||
|
for (i = 0; i < mmap_pages; i++)
|
||||||
|
pending_grant_handles[i] = BLKBACK_INVALID_HANDLE;
|
||||||
|
|
||||||
|
blkif_interface_init();
|
||||||
|
|
||||||
|
memset(pending_reqs, 0, sizeof(pending_reqs));
|
||||||
|
INIT_LIST_HEAD(&pending_free);
|
||||||
|
|
||||||
|
for (i = 0; i < blkif_reqs; i++)
|
||||||
|
list_add_tail(&pending_reqs[i].free_list, &pending_free);
|
||||||
|
|
||||||
|
blkif_xenbus_init();
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
out_of_memory:
|
||||||
|
kfree(pending_reqs);
|
||||||
|
kfree(pending_grant_handles);
|
||||||
|
free_empty_pages_and_pagevec(pending_pages, mmap_pages);
|
||||||
|
printk("%s: out of memory\n", __FUNCTION__);
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
|
||||||
|
module_init(blkif_init);
|
||||||
|
|
||||||
|
MODULE_LICENSE("Dual BSD/GPL");
|
139
drivers/xen/blkback/common.h
Normal file
139
drivers/xen/blkback/common.h
Normal file
|
@ -0,0 +1,139 @@
|
||||||
|
/*
|
||||||
|
* This program is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License version 2
|
||||||
|
* as published by the Free Software Foundation; or, when distributed
|
||||||
|
* separately from the Linux kernel or incorporated into other
|
||||||
|
* software packages, subject to the following license:
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
* of this source file (the "Software"), to deal in the Software without
|
||||||
|
* restriction, including without limitation the rights to use, copy, modify,
|
||||||
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
||||||
|
* the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be included in
|
||||||
|
* all copies or substantial portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||||
|
* IN THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __BLKIF__BACKEND__COMMON_H__
|
||||||
|
#define __BLKIF__BACKEND__COMMON_H__
|
||||||
|
|
||||||
|
#include <linux/version.h>
|
||||||
|
#include <linux/module.h>
|
||||||
|
#include <linux/interrupt.h>
|
||||||
|
#include <linux/slab.h>
|
||||||
|
#include <linux/blkdev.h>
|
||||||
|
#include <linux/vmalloc.h>
|
||||||
|
#include <linux/wait.h>
|
||||||
|
#include <asm/io.h>
|
||||||
|
#include <asm/setup.h>
|
||||||
|
#include <asm/pgalloc.h>
|
||||||
|
#include <xen/evtchn.h>
|
||||||
|
#include <asm/hypervisor.h>
|
||||||
|
#include <xen/blkif.h>
|
||||||
|
#include <xen/gnttab.h>
|
||||||
|
#include <xen/driver_util.h>
|
||||||
|
#include <xen/xenbus.h>
|
||||||
|
|
||||||
|
#define DPRINTK(_f, _a...) \
|
||||||
|
pr_debug("(file=%s, line=%d) " _f, \
|
||||||
|
__FILE__ , __LINE__ , ## _a )
|
||||||
|
|
||||||
|
struct vbd {
|
||||||
|
blkif_vdev_t handle; /* what the domain refers to this vbd as */
|
||||||
|
unsigned char readonly; /* Non-zero -> read-only */
|
||||||
|
unsigned char type; /* VDISK_xxx */
|
||||||
|
u32 pdevice; /* phys device that this vbd maps to */
|
||||||
|
struct block_device *bdev;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct backend_info;
|
||||||
|
|
||||||
|
typedef struct blkif_st {
|
||||||
|
/* Unique identifier for this interface. */
|
||||||
|
domid_t domid;
|
||||||
|
unsigned int handle;
|
||||||
|
/* Physical parameters of the comms window. */
|
||||||
|
unsigned int irq;
|
||||||
|
/* Comms information. */
|
||||||
|
enum blkif_protocol blk_protocol;
|
||||||
|
blkif_back_rings_t blk_rings;
|
||||||
|
struct vm_struct *blk_ring_area;
|
||||||
|
/* The VBD attached to this interface. */
|
||||||
|
struct vbd vbd;
|
||||||
|
/* Back pointer to the backend_info. */
|
||||||
|
struct backend_info *be;
|
||||||
|
/* Private fields. */
|
||||||
|
spinlock_t blk_ring_lock;
|
||||||
|
atomic_t refcnt;
|
||||||
|
|
||||||
|
wait_queue_head_t wq;
|
||||||
|
struct task_struct *xenblkd;
|
||||||
|
unsigned int waiting_reqs;
|
||||||
|
request_queue_t *plug;
|
||||||
|
|
||||||
|
/* statistics */
|
||||||
|
unsigned long st_print;
|
||||||
|
int st_rd_req;
|
||||||
|
int st_wr_req;
|
||||||
|
int st_oo_req;
|
||||||
|
int st_br_req;
|
||||||
|
int st_rd_sect;
|
||||||
|
int st_wr_sect;
|
||||||
|
|
||||||
|
wait_queue_head_t waiting_to_free;
|
||||||
|
|
||||||
|
grant_handle_t shmem_handle;
|
||||||
|
grant_ref_t shmem_ref;
|
||||||
|
} blkif_t;
|
||||||
|
|
||||||
|
blkif_t *blkif_alloc(domid_t domid);
|
||||||
|
void blkif_disconnect(blkif_t *blkif);
|
||||||
|
void blkif_free(blkif_t *blkif);
|
||||||
|
int blkif_map(blkif_t *blkif, unsigned long shared_page, unsigned int evtchn);
|
||||||
|
|
||||||
|
#define blkif_get(_b) (atomic_inc(&(_b)->refcnt))
|
||||||
|
#define blkif_put(_b) \
|
||||||
|
do { \
|
||||||
|
if (atomic_dec_and_test(&(_b)->refcnt)) \
|
||||||
|
wake_up(&(_b)->waiting_to_free);\
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Create a vbd. */
|
||||||
|
int vbd_create(blkif_t *blkif, blkif_vdev_t vdevice, unsigned major,
|
||||||
|
unsigned minor, int readonly, int cdrom);
|
||||||
|
void vbd_free(struct vbd *vbd);
|
||||||
|
|
||||||
|
unsigned long long vbd_size(struct vbd *vbd);
|
||||||
|
unsigned int vbd_info(struct vbd *vbd);
|
||||||
|
unsigned long vbd_secsize(struct vbd *vbd);
|
||||||
|
|
||||||
|
struct phys_req {
|
||||||
|
unsigned short dev;
|
||||||
|
unsigned short nr_sects;
|
||||||
|
struct block_device *bdev;
|
||||||
|
blkif_sector_t sector_number;
|
||||||
|
};
|
||||||
|
|
||||||
|
int vbd_translate(struct phys_req *req, blkif_t *blkif, int operation);
|
||||||
|
|
||||||
|
void blkif_interface_init(void);
|
||||||
|
|
||||||
|
void blkif_xenbus_init(void);
|
||||||
|
|
||||||
|
irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs);
|
||||||
|
int blkif_schedule(void *arg);
|
||||||
|
|
||||||
|
int blkback_barrier(struct xenbus_transaction xbt,
|
||||||
|
struct backend_info *be, int state);
|
||||||
|
|
||||||
|
#endif /* __BLKIF__BACKEND__COMMON_H__ */
|
181
drivers/xen/blkback/interface.c
Normal file
181
drivers/xen/blkback/interface.c
Normal file
|
@ -0,0 +1,181 @@
|
||||||
|
/******************************************************************************
|
||||||
|
* arch/xen/drivers/blkif/backend/interface.c
|
||||||
|
*
|
||||||
|
* Block-device interface management.
|
||||||
|
*
|
||||||
|
* Copyright (c) 2004, Keir Fraser
|
||||||
|
*
|
||||||
|
* This program is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License version 2
|
||||||
|
* as published by the Free Software Foundation; or, when distributed
|
||||||
|
* separately from the Linux kernel or incorporated into other
|
||||||
|
* software packages, subject to the following license:
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
* of this source file (the "Software"), to deal in the Software without
|
||||||
|
* restriction, including without limitation the rights to use, copy, modify,
|
||||||
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
||||||
|
* the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be included in
|
||||||
|
* all copies or substantial portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||||
|
* IN THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "common.h"
|
||||||
|
#include <xen/evtchn.h>
|
||||||
|
#include <linux/kthread.h>
|
||||||
|
|
||||||
|
static kmem_cache_t *blkif_cachep;
|
||||||
|
|
||||||
|
blkif_t *blkif_alloc(domid_t domid)
|
||||||
|
{
|
||||||
|
blkif_t *blkif;
|
||||||
|
|
||||||
|
blkif = kmem_cache_alloc(blkif_cachep, GFP_KERNEL);
|
||||||
|
if (!blkif)
|
||||||
|
return ERR_PTR(-ENOMEM);
|
||||||
|
|
||||||
|
memset(blkif, 0, sizeof(*blkif));
|
||||||
|
blkif->domid = domid;
|
||||||
|
spin_lock_init(&blkif->blk_ring_lock);
|
||||||
|
atomic_set(&blkif->refcnt, 1);
|
||||||
|
init_waitqueue_head(&blkif->wq);
|
||||||
|
blkif->st_print = jiffies;
|
||||||
|
init_waitqueue_head(&blkif->waiting_to_free);
|
||||||
|
|
||||||
|
return blkif;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int map_frontend_page(blkif_t *blkif, unsigned long shared_page)
|
||||||
|
{
|
||||||
|
struct gnttab_map_grant_ref op;
|
||||||
|
|
||||||
|
gnttab_set_map_op(&op, (unsigned long)blkif->blk_ring_area->addr,
|
||||||
|
GNTMAP_host_map, shared_page, blkif->domid);
|
||||||
|
|
||||||
|
if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
|
||||||
|
BUG();
|
||||||
|
|
||||||
|
if (op.status) {
|
||||||
|
DPRINTK(" Grant table operation failure !\n");
|
||||||
|
return op.status;
|
||||||
|
}
|
||||||
|
|
||||||
|
blkif->shmem_ref = shared_page;
|
||||||
|
blkif->shmem_handle = op.handle;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void unmap_frontend_page(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
struct gnttab_unmap_grant_ref op;
|
||||||
|
|
||||||
|
gnttab_set_unmap_op(&op, (unsigned long)blkif->blk_ring_area->addr,
|
||||||
|
GNTMAP_host_map, blkif->shmem_handle);
|
||||||
|
|
||||||
|
if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
|
||||||
|
BUG();
|
||||||
|
}
|
||||||
|
|
||||||
|
int blkif_map(blkif_t *blkif, unsigned long shared_page, unsigned int evtchn)
|
||||||
|
{
|
||||||
|
int err;
|
||||||
|
|
||||||
|
/* Already connected through? */
|
||||||
|
if (blkif->irq)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
if ( (blkif->blk_ring_area = alloc_vm_area(PAGE_SIZE)) == NULL )
|
||||||
|
return -ENOMEM;
|
||||||
|
|
||||||
|
err = map_frontend_page(blkif, shared_page);
|
||||||
|
if (err) {
|
||||||
|
free_vm_area(blkif->blk_ring_area);
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (blkif->blk_protocol) {
|
||||||
|
case BLKIF_PROTOCOL_NATIVE:
|
||||||
|
{
|
||||||
|
blkif_sring_t *sring;
|
||||||
|
sring = (blkif_sring_t *)blkif->blk_ring_area->addr;
|
||||||
|
BACK_RING_INIT(&blkif->blk_rings.native, sring, PAGE_SIZE);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case BLKIF_PROTOCOL_X86_32:
|
||||||
|
{
|
||||||
|
blkif_x86_32_sring_t *sring_x86_32;
|
||||||
|
sring_x86_32 = (blkif_x86_32_sring_t *)blkif->blk_ring_area->addr;
|
||||||
|
BACK_RING_INIT(&blkif->blk_rings.x86_32, sring_x86_32, PAGE_SIZE);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case BLKIF_PROTOCOL_X86_64:
|
||||||
|
{
|
||||||
|
blkif_x86_64_sring_t *sring_x86_64;
|
||||||
|
sring_x86_64 = (blkif_x86_64_sring_t *)blkif->blk_ring_area->addr;
|
||||||
|
BACK_RING_INIT(&blkif->blk_rings.x86_64, sring_x86_64, PAGE_SIZE);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
BUG();
|
||||||
|
}
|
||||||
|
|
||||||
|
err = bind_interdomain_evtchn_to_irqhandler(
|
||||||
|
blkif->domid, evtchn, blkif_be_int, 0, "blkif-backend", blkif);
|
||||||
|
if (err < 0)
|
||||||
|
{
|
||||||
|
unmap_frontend_page(blkif);
|
||||||
|
free_vm_area(blkif->blk_ring_area);
|
||||||
|
blkif->blk_rings.common.sring = NULL;
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
blkif->irq = err;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void blkif_disconnect(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
if (blkif->xenblkd) {
|
||||||
|
kthread_stop(blkif->xenblkd);
|
||||||
|
blkif->xenblkd = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
atomic_dec(&blkif->refcnt);
|
||||||
|
wait_event(blkif->waiting_to_free, atomic_read(&blkif->refcnt) == 0);
|
||||||
|
atomic_inc(&blkif->refcnt);
|
||||||
|
|
||||||
|
if (blkif->irq) {
|
||||||
|
unbind_from_irqhandler(blkif->irq, blkif);
|
||||||
|
blkif->irq = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (blkif->blk_rings.common.sring) {
|
||||||
|
unmap_frontend_page(blkif);
|
||||||
|
free_vm_area(blkif->blk_ring_area);
|
||||||
|
blkif->blk_rings.common.sring = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void blkif_free(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
if (!atomic_dec_and_test(&blkif->refcnt))
|
||||||
|
BUG();
|
||||||
|
kmem_cache_free(blkif_cachep, blkif);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __init blkif_interface_init(void)
|
||||||
|
{
|
||||||
|
blkif_cachep = kmem_cache_create("blkif_cache", sizeof(blkif_t),
|
||||||
|
0, 0, NULL, NULL);
|
||||||
|
}
|
118
drivers/xen/blkback/vbd.c
Normal file
118
drivers/xen/blkback/vbd.c
Normal file
|
@ -0,0 +1,118 @@
|
||||||
|
/******************************************************************************
|
||||||
|
* blkback/vbd.c
|
||||||
|
*
|
||||||
|
* Routines for managing virtual block devices (VBDs).
|
||||||
|
*
|
||||||
|
* Copyright (c) 2003-2005, Keir Fraser & Steve Hand
|
||||||
|
*
|
||||||
|
* This program is free software; you can redistribute it and/or
|
||||||
|
* modify it under the terms of the GNU General Public License version 2
|
||||||
|
* as published by the Free Software Foundation; or, when distributed
|
||||||
|
* separately from the Linux kernel or incorporated into other
|
||||||
|
* software packages, subject to the following license:
|
||||||
|
*
|
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
* of this source file (the "Software"), to deal in the Software without
|
||||||
|
* restriction, including without limitation the rights to use, copy, modify,
|
||||||
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
||||||
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
||||||
|
* the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be included in
|
||||||
|
* all copies or substantial portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||||
|
* IN THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "common.h"
|
||||||
|
|
||||||
|
#define vbd_sz(_v) ((_v)->bdev->bd_part ? \
|
||||||
|
(_v)->bdev->bd_part->nr_sects : (_v)->bdev->bd_disk->capacity)
|
||||||
|
|
||||||
|
unsigned long long vbd_size(struct vbd *vbd)
|
||||||
|
{
|
||||||
|
return vbd_sz(vbd);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned int vbd_info(struct vbd *vbd)
|
||||||
|
{
|
||||||
|
return vbd->type | (vbd->readonly?VDISK_READONLY:0);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned long vbd_secsize(struct vbd *vbd)
|
||||||
|
{
|
||||||
|
return bdev_hardsect_size(vbd->bdev);
|
||||||
|
}
|
||||||
|
|
||||||
|
int vbd_create(blkif_t *blkif, blkif_vdev_t handle, unsigned major,
|
||||||
|
unsigned minor, int readonly, int cdrom)
|
||||||
|
{
|
||||||
|
struct vbd *vbd;
|
||||||
|
struct block_device *bdev;
|
||||||
|
|
||||||
|
vbd = &blkif->vbd;
|
||||||
|
vbd->handle = handle;
|
||||||
|
vbd->readonly = readonly;
|
||||||
|
vbd->type = 0;
|
||||||
|
|
||||||
|
vbd->pdevice = MKDEV(major, minor);
|
||||||
|
|
||||||
|
bdev = open_by_devnum(vbd->pdevice,
|
||||||
|
vbd->readonly ? FMODE_READ : FMODE_WRITE);
|
||||||
|
|
||||||
|
if (IS_ERR(bdev)) {
|
||||||
|
DPRINTK("vbd_creat: device %08x could not be opened.\n",
|
||||||
|
vbd->pdevice);
|
||||||
|
return -ENOENT;
|
||||||
|
}
|
||||||
|
|
||||||
|
vbd->bdev = bdev;
|
||||||
|
|
||||||
|
if (vbd->bdev->bd_disk == NULL) {
|
||||||
|
DPRINTK("vbd_creat: device %08x doesn't exist.\n",
|
||||||
|
vbd->pdevice);
|
||||||
|
vbd_free(vbd);
|
||||||
|
return -ENOENT;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (vbd->bdev->bd_disk->flags & GENHD_FL_CD || cdrom)
|
||||||
|
vbd->type |= VDISK_CDROM;
|
||||||
|
if (vbd->bdev->bd_disk->flags & GENHD_FL_REMOVABLE)
|
||||||
|
vbd->type |= VDISK_REMOVABLE;
|
||||||
|
|
||||||
|
DPRINTK("Successful creation of handle=%04x (dom=%u)\n",
|
||||||
|
handle, blkif->domid);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void vbd_free(struct vbd *vbd)
|
||||||
|
{
|
||||||
|
if (vbd->bdev)
|
||||||
|
blkdev_put(vbd->bdev);
|
||||||
|
vbd->bdev = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
int vbd_translate(struct phys_req *req, blkif_t *blkif, int operation)
|
||||||
|
{
|
||||||
|
struct vbd *vbd = &blkif->vbd;
|
||||||
|
int rc = -EACCES;
|
||||||
|
|
||||||
|
if ((operation != READ) && vbd->readonly)
|
||||||
|
goto out;
|
||||||
|
|
||||||
|
if (unlikely((req->sector_number + req->nr_sects) > vbd_sz(vbd)))
|
||||||
|
goto out;
|
||||||
|
|
||||||
|
req->dev = vbd->pdevice;
|
||||||
|
req->bdev = vbd->bdev;
|
||||||
|
rc = 0;
|
||||||
|
|
||||||
|
out:
|
||||||
|
return rc;
|
||||||
|
}
|
541
drivers/xen/blkback/xenbus.c
Normal file
541
drivers/xen/blkback/xenbus.c
Normal file
|
@ -0,0 +1,541 @@
|
||||||
|
/* Xenbus code for blkif backend
|
||||||
|
Copyright (C) 2005 Rusty Russell <rusty@rustcorp.com.au>
|
||||||
|
Copyright (C) 2005 XenSource Ltd
|
||||||
|
|
||||||
|
This program is free software; you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published by
|
||||||
|
the Free Software Foundation; either version 2 of the License, or
|
||||||
|
(at your option) any later version.
|
||||||
|
|
||||||
|
This program is distributed in the hope that it will be useful,
|
||||||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
GNU General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with this program; if not, write to the Free Software
|
||||||
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdarg.h>
|
||||||
|
#include <linux/module.h>
|
||||||
|
#include <linux/kthread.h>
|
||||||
|
#include "common.h"
|
||||||
|
|
||||||
|
#undef DPRINTK
|
||||||
|
#define DPRINTK(fmt, args...) \
|
||||||
|
pr_debug("blkback/xenbus (%s:%d) " fmt ".\n", \
|
||||||
|
__FUNCTION__, __LINE__, ##args)
|
||||||
|
|
||||||
|
struct backend_info
|
||||||
|
{
|
||||||
|
struct xenbus_device *dev;
|
||||||
|
blkif_t *blkif;
|
||||||
|
struct xenbus_watch backend_watch;
|
||||||
|
unsigned major;
|
||||||
|
unsigned minor;
|
||||||
|
char *mode;
|
||||||
|
};
|
||||||
|
|
||||||
|
static void connect(struct backend_info *);
|
||||||
|
static int connect_ring(struct backend_info *);
|
||||||
|
static void backend_changed(struct xenbus_watch *, const char **,
|
||||||
|
unsigned int);
|
||||||
|
|
||||||
|
static int blkback_name(blkif_t *blkif, char *buf)
|
||||||
|
{
|
||||||
|
char *devpath, *devname;
|
||||||
|
struct xenbus_device *dev = blkif->be->dev;
|
||||||
|
|
||||||
|
devpath = xenbus_read(XBT_NIL, dev->nodename, "dev", NULL);
|
||||||
|
if (IS_ERR(devpath))
|
||||||
|
return PTR_ERR(devpath);
|
||||||
|
|
||||||
|
if ((devname = strstr(devpath, "/dev/")) != NULL)
|
||||||
|
devname += strlen("/dev/");
|
||||||
|
else
|
||||||
|
devname = devpath;
|
||||||
|
|
||||||
|
snprintf(buf, TASK_COMM_LEN, "blkback.%d.%s", blkif->domid, devname);
|
||||||
|
kfree(devpath);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void update_blkif_status(blkif_t *blkif)
|
||||||
|
{
|
||||||
|
int err;
|
||||||
|
char name[TASK_COMM_LEN];
|
||||||
|
|
||||||
|
/* Not ready to connect? */
|
||||||
|
if (!blkif->irq || !blkif->vbd.bdev)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* Already connected? */
|
||||||
|
if (blkif->be->dev->state == XenbusStateConnected)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* Attempt to connect: exit if we fail to. */
|
||||||
|
connect(blkif->be);
|
||||||
|
if (blkif->be->dev->state != XenbusStateConnected)
|
||||||
|
return;
|
||||||
|
|
||||||
|
err = blkback_name(blkif, name);
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_error(blkif->be->dev, err, "get blkback dev name");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
blkif->xenblkd = kthread_run(blkif_schedule, blkif, name);
|
||||||
|
if (IS_ERR(blkif->xenblkd)) {
|
||||||
|
err = PTR_ERR(blkif->xenblkd);
|
||||||
|
blkif->xenblkd = NULL;
|
||||||
|
xenbus_dev_error(blkif->be->dev, err, "start xenblkd");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/****************************************************************
|
||||||
|
* sysfs interface for VBD I/O requests
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define VBD_SHOW(name, format, args...) \
|
||||||
|
static ssize_t show_##name(struct device *_dev, \
|
||||||
|
struct device_attribute *attr, \
|
||||||
|
char *buf) \
|
||||||
|
{ \
|
||||||
|
struct xenbus_device *dev = to_xenbus_device(_dev); \
|
||||||
|
struct backend_info *be = dev->dev.driver_data; \
|
||||||
|
\
|
||||||
|
return sprintf(buf, format, ##args); \
|
||||||
|
} \
|
||||||
|
static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
|
||||||
|
|
||||||
|
VBD_SHOW(oo_req, "%d\n", be->blkif->st_oo_req);
|
||||||
|
VBD_SHOW(rd_req, "%d\n", be->blkif->st_rd_req);
|
||||||
|
VBD_SHOW(wr_req, "%d\n", be->blkif->st_wr_req);
|
||||||
|
VBD_SHOW(br_req, "%d\n", be->blkif->st_br_req);
|
||||||
|
VBD_SHOW(rd_sect, "%d\n", be->blkif->st_rd_sect);
|
||||||
|
VBD_SHOW(wr_sect, "%d\n", be->blkif->st_wr_sect);
|
||||||
|
|
||||||
|
static struct attribute *vbdstat_attrs[] = {
|
||||||
|
&dev_attr_oo_req.attr,
|
||||||
|
&dev_attr_rd_req.attr,
|
||||||
|
&dev_attr_wr_req.attr,
|
||||||
|
&dev_attr_br_req.attr,
|
||||||
|
&dev_attr_rd_sect.attr,
|
||||||
|
&dev_attr_wr_sect.attr,
|
||||||
|
NULL
|
||||||
|
};
|
||||||
|
|
||||||
|
static struct attribute_group vbdstat_group = {
|
||||||
|
.name = "statistics",
|
||||||
|
.attrs = vbdstat_attrs,
|
||||||
|
};
|
||||||
|
|
||||||
|
VBD_SHOW(physical_device, "%x:%x\n", be->major, be->minor);
|
||||||
|
VBD_SHOW(mode, "%s\n", be->mode);
|
||||||
|
|
||||||
|
int xenvbd_sysfs_addif(struct xenbus_device *dev)
|
||||||
|
{
|
||||||
|
int error;
|
||||||
|
|
||||||
|
error = device_create_file(&dev->dev, &dev_attr_physical_device);
|
||||||
|
if (error)
|
||||||
|
goto fail1;
|
||||||
|
|
||||||
|
error = device_create_file(&dev->dev, &dev_attr_mode);
|
||||||
|
if (error)
|
||||||
|
goto fail2;
|
||||||
|
|
||||||
|
error = sysfs_create_group(&dev->dev.kobj, &vbdstat_group);
|
||||||
|
if (error)
|
||||||
|
goto fail3;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
fail3: sysfs_remove_group(&dev->dev.kobj, &vbdstat_group);
|
||||||
|
fail2: device_remove_file(&dev->dev, &dev_attr_mode);
|
||||||
|
fail1: device_remove_file(&dev->dev, &dev_attr_physical_device);
|
||||||
|
return error;
|
||||||
|
}
|
||||||
|
|
||||||
|
void xenvbd_sysfs_delif(struct xenbus_device *dev)
|
||||||
|
{
|
||||||
|
sysfs_remove_group(&dev->dev.kobj, &vbdstat_group);
|
||||||
|
device_remove_file(&dev->dev, &dev_attr_mode);
|
||||||
|
device_remove_file(&dev->dev, &dev_attr_physical_device);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int blkback_remove(struct xenbus_device *dev)
|
||||||
|
{
|
||||||
|
struct backend_info *be = dev->dev.driver_data;
|
||||||
|
|
||||||
|
DPRINTK("");
|
||||||
|
|
||||||
|
if (be->major || be->minor)
|
||||||
|
xenvbd_sysfs_delif(dev);
|
||||||
|
|
||||||
|
if (be->backend_watch.node) {
|
||||||
|
unregister_xenbus_watch(&be->backend_watch);
|
||||||
|
kfree(be->backend_watch.node);
|
||||||
|
be->backend_watch.node = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (be->blkif) {
|
||||||
|
blkif_disconnect(be->blkif);
|
||||||
|
vbd_free(&be->blkif->vbd);
|
||||||
|
blkif_free(be->blkif);
|
||||||
|
be->blkif = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
kfree(be);
|
||||||
|
dev->dev.driver_data = NULL;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
int blkback_barrier(struct xenbus_transaction xbt,
|
||||||
|
struct backend_info *be, int state)
|
||||||
|
{
|
||||||
|
struct xenbus_device *dev = be->dev;
|
||||||
|
int err;
|
||||||
|
|
||||||
|
err = xenbus_printf(xbt, dev->nodename, "feature-barrier",
|
||||||
|
"%d", state);
|
||||||
|
if (err)
|
||||||
|
xenbus_dev_fatal(dev, err, "writing feature-barrier");
|
||||||
|
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Entry point to this code when a new device is created. Allocate the basic
|
||||||
|
* structures, and watch the store waiting for the hotplug scripts to tell us
|
||||||
|
* the device's physical major and minor numbers. Switch to InitWait.
|
||||||
|
*/
|
||||||
|
static int blkback_probe(struct xenbus_device *dev,
|
||||||
|
const struct xenbus_device_id *id)
|
||||||
|
{
|
||||||
|
int err;
|
||||||
|
struct backend_info *be = kzalloc(sizeof(struct backend_info),
|
||||||
|
GFP_KERNEL);
|
||||||
|
if (!be) {
|
||||||
|
xenbus_dev_fatal(dev, -ENOMEM,
|
||||||
|
"allocating backend structure");
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
be->dev = dev;
|
||||||
|
dev->dev.driver_data = be;
|
||||||
|
|
||||||
|
be->blkif = blkif_alloc(dev->otherend_id);
|
||||||
|
if (IS_ERR(be->blkif)) {
|
||||||
|
err = PTR_ERR(be->blkif);
|
||||||
|
be->blkif = NULL;
|
||||||
|
xenbus_dev_fatal(dev, err, "creating block interface");
|
||||||
|
goto fail;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* setup back pointer */
|
||||||
|
be->blkif->be = be;
|
||||||
|
|
||||||
|
err = xenbus_watch_path2(dev, dev->nodename, "physical-device",
|
||||||
|
&be->backend_watch, backend_changed);
|
||||||
|
if (err)
|
||||||
|
goto fail;
|
||||||
|
|
||||||
|
err = xenbus_switch_state(dev, XenbusStateInitWait);
|
||||||
|
if (err)
|
||||||
|
goto fail;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
fail:
|
||||||
|
DPRINTK("failed");
|
||||||
|
blkback_remove(dev);
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Callback received when the hotplug scripts have placed the physical-device
|
||||||
|
* node. Read it and the mode node, and create a vbd. If the frontend is
|
||||||
|
* ready, connect.
|
||||||
|
*/
|
||||||
|
static void backend_changed(struct xenbus_watch *watch,
|
||||||
|
const char **vec, unsigned int len)
|
||||||
|
{
|
||||||
|
int err;
|
||||||
|
unsigned major;
|
||||||
|
unsigned minor;
|
||||||
|
struct backend_info *be
|
||||||
|
= container_of(watch, struct backend_info, backend_watch);
|
||||||
|
struct xenbus_device *dev = be->dev;
|
||||||
|
int cdrom = 0;
|
||||||
|
char *device_type;
|
||||||
|
|
||||||
|
DPRINTK("");
|
||||||
|
|
||||||
|
err = xenbus_scanf(XBT_NIL, dev->nodename, "physical-device", "%x:%x",
|
||||||
|
&major, &minor);
|
||||||
|
if (XENBUS_EXIST_ERR(err)) {
|
||||||
|
/* Since this watch will fire once immediately after it is
|
||||||
|
registered, we expect this. Ignore it, and wait for the
|
||||||
|
hotplug scripts. */
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (err != 2) {
|
||||||
|
xenbus_dev_fatal(dev, err, "reading physical-device");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((be->major || be->minor) &&
|
||||||
|
((be->major != major) || (be->minor != minor))) {
|
||||||
|
printk(KERN_WARNING
|
||||||
|
"blkback: changing physical device (from %x:%x to "
|
||||||
|
"%x:%x) not supported.\n", be->major, be->minor,
|
||||||
|
major, minor);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
be->mode = xenbus_read(XBT_NIL, dev->nodename, "mode", NULL);
|
||||||
|
if (IS_ERR(be->mode)) {
|
||||||
|
err = PTR_ERR(be->mode);
|
||||||
|
be->mode = NULL;
|
||||||
|
xenbus_dev_fatal(dev, err, "reading mode");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
device_type = xenbus_read(XBT_NIL, dev->otherend, "device-type", NULL);
|
||||||
|
if (!IS_ERR(device_type)) {
|
||||||
|
cdrom = strcmp(device_type, "cdrom") == 0;
|
||||||
|
kfree(device_type);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (be->major == 0 && be->minor == 0) {
|
||||||
|
/* Front end dir is a number, which is used as the handle. */
|
||||||
|
|
||||||
|
char *p = strrchr(dev->otherend, '/') + 1;
|
||||||
|
long handle = simple_strtoul(p, NULL, 0);
|
||||||
|
|
||||||
|
be->major = major;
|
||||||
|
be->minor = minor;
|
||||||
|
|
||||||
|
err = vbd_create(be->blkif, handle, major, minor,
|
||||||
|
(NULL == strchr(be->mode, 'w')), cdrom);
|
||||||
|
if (err) {
|
||||||
|
be->major = be->minor = 0;
|
||||||
|
xenbus_dev_fatal(dev, err, "creating vbd structure");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
err = xenvbd_sysfs_addif(dev);
|
||||||
|
if (err) {
|
||||||
|
vbd_free(&be->blkif->vbd);
|
||||||
|
be->major = be->minor = 0;
|
||||||
|
xenbus_dev_fatal(dev, err, "creating sysfs entries");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* We're potentially connected now */
|
||||||
|
update_blkif_status(be->blkif);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Callback received when the frontend's state changes.
|
||||||
|
*/
|
||||||
|
static void frontend_changed(struct xenbus_device *dev,
|
||||||
|
enum xenbus_state frontend_state)
|
||||||
|
{
|
||||||
|
struct backend_info *be = dev->dev.driver_data;
|
||||||
|
int err;
|
||||||
|
|
||||||
|
DPRINTK("%s", xenbus_strstate(frontend_state));
|
||||||
|
|
||||||
|
switch (frontend_state) {
|
||||||
|
case XenbusStateInitialising:
|
||||||
|
if (dev->state == XenbusStateClosed) {
|
||||||
|
printk(KERN_INFO "%s: %s: prepare for reconnect\n",
|
||||||
|
__FUNCTION__, dev->nodename);
|
||||||
|
xenbus_switch_state(dev, XenbusStateInitWait);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case XenbusStateInitialised:
|
||||||
|
case XenbusStateConnected:
|
||||||
|
/* Ensure we connect even when two watches fire in
|
||||||
|
close successsion and we miss the intermediate value
|
||||||
|
of frontend_state. */
|
||||||
|
if (dev->state == XenbusStateConnected)
|
||||||
|
break;
|
||||||
|
|
||||||
|
err = connect_ring(be);
|
||||||
|
if (err)
|
||||||
|
break;
|
||||||
|
update_blkif_status(be->blkif);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case XenbusStateClosing:
|
||||||
|
blkif_disconnect(be->blkif);
|
||||||
|
xenbus_switch_state(dev, XenbusStateClosing);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case XenbusStateClosed:
|
||||||
|
xenbus_switch_state(dev, XenbusStateClosed);
|
||||||
|
if (xenbus_dev_is_online(dev))
|
||||||
|
break;
|
||||||
|
/* fall through if not online */
|
||||||
|
case XenbusStateUnknown:
|
||||||
|
device_unregister(&dev->dev);
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend",
|
||||||
|
frontend_state);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* ** Connection ** */
|
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write the physical details regarding the block device to the store, and
|
||||||
|
* switch to Connected state.
|
||||||
|
*/
|
||||||
|
static void connect(struct backend_info *be)
|
||||||
|
{
|
||||||
|
struct xenbus_transaction xbt;
|
||||||
|
int err;
|
||||||
|
struct xenbus_device *dev = be->dev;
|
||||||
|
|
||||||
|
DPRINTK("%s", dev->otherend);
|
||||||
|
|
||||||
|
/* Supply the information about the device the frontend needs */
|
||||||
|
again:
|
||||||
|
err = xenbus_transaction_start(&xbt);
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_fatal(dev, err, "starting transaction");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
err = blkback_barrier(xbt, be, 1);
|
||||||
|
if (err)
|
||||||
|
goto abort;
|
||||||
|
|
||||||
|
err = xenbus_printf(xbt, dev->nodename, "sectors", "%llu",
|
||||||
|
vbd_size(&be->blkif->vbd));
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_fatal(dev, err, "writing %s/sectors",
|
||||||
|
dev->nodename);
|
||||||
|
goto abort;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* FIXME: use a typename instead */
|
||||||
|
err = xenbus_printf(xbt, dev->nodename, "info", "%u",
|
||||||
|
vbd_info(&be->blkif->vbd));
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_fatal(dev, err, "writing %s/info",
|
||||||
|
dev->nodename);
|
||||||
|
goto abort;
|
||||||
|
}
|
||||||
|
err = xenbus_printf(xbt, dev->nodename, "sector-size", "%lu",
|
||||||
|
vbd_secsize(&be->blkif->vbd));
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_fatal(dev, err, "writing %s/sector-size",
|
||||||
|
dev->nodename);
|
||||||
|
goto abort;
|
||||||
|
}
|
||||||
|
|
||||||
|
err = xenbus_transaction_end(xbt, 0);
|
||||||
|
if (err == -EAGAIN)
|
||||||
|
goto again;
|
||||||
|
if (err)
|
||||||
|
xenbus_dev_fatal(dev, err, "ending transaction");
|
||||||
|
|
||||||
|
err = xenbus_switch_state(dev, XenbusStateConnected);
|
||||||
|
if (err)
|
||||||
|
xenbus_dev_fatal(dev, err, "switching to Connected state",
|
||||||
|
dev->nodename);
|
||||||
|
|
||||||
|
return;
|
||||||
|
abort:
|
||||||
|
xenbus_transaction_end(xbt, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static int connect_ring(struct backend_info *be)
|
||||||
|
{
|
||||||
|
struct xenbus_device *dev = be->dev;
|
||||||
|
unsigned long ring_ref;
|
||||||
|
unsigned int evtchn;
|
||||||
|
char protocol[64] = "";
|
||||||
|
int err;
|
||||||
|
|
||||||
|
DPRINTK("%s", dev->otherend);
|
||||||
|
|
||||||
|
err = xenbus_gather(XBT_NIL, dev->otherend, "ring-ref", "%lu", &ring_ref,
|
||||||
|
"event-channel", "%u", &evtchn, NULL);
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_fatal(dev, err,
|
||||||
|
"reading %s/ring-ref and event-channel",
|
||||||
|
dev->otherend);
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
be->blkif->blk_protocol = BLKIF_PROTOCOL_NATIVE;
|
||||||
|
err = xenbus_gather(XBT_NIL, dev->otherend, "protocol",
|
||||||
|
"%63s", protocol, NULL);
|
||||||
|
if (err)
|
||||||
|
strcpy(protocol, "unspecified, assuming native");
|
||||||
|
else if (0 == strcmp(protocol, XEN_IO_PROTO_ABI_NATIVE))
|
||||||
|
be->blkif->blk_protocol = BLKIF_PROTOCOL_NATIVE;
|
||||||
|
else if (0 == strcmp(protocol, XEN_IO_PROTO_ABI_X86_32))
|
||||||
|
be->blkif->blk_protocol = BLKIF_PROTOCOL_X86_32;
|
||||||
|
else if (0 == strcmp(protocol, XEN_IO_PROTO_ABI_X86_64))
|
||||||
|
be->blkif->blk_protocol = BLKIF_PROTOCOL_X86_64;
|
||||||
|
else {
|
||||||
|
xenbus_dev_fatal(dev, err, "unknown fe protocol %s", protocol);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
printk(KERN_INFO
|
||||||
|
"blkback: ring-ref %ld, event-channel %d, protocol %d (%s)\n",
|
||||||
|
ring_ref, evtchn, be->blkif->blk_protocol, protocol);
|
||||||
|
|
||||||
|
/* Map the shared frame, irq etc. */
|
||||||
|
err = blkif_map(be->blkif, ring_ref, evtchn);
|
||||||
|
if (err) {
|
||||||
|
xenbus_dev_fatal(dev, err, "mapping ring-ref %lu port %u",
|
||||||
|
ring_ref, evtchn);
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* ** Driver Registration ** */
|
||||||
|
|
||||||
|
|
||||||
|
static const struct xenbus_device_id blkback_ids[] = {
|
||||||
|
{ "vbd" },
|
||||||
|
{ "" }
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
static struct xenbus_driver blkback = {
|
||||||
|
.name = "vbd",
|
||||||
|
.owner = THIS_MODULE,
|
||||||
|
.ids = blkback_ids,
|
||||||
|
.probe = blkback_probe,
|
||||||
|
.remove = blkback_remove,
|
||||||
|
.otherend_changed = frontend_changed
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
void blkif_xenbus_init(void)
|
||||||
|
{
|
||||||
|
xenbus_register_backend(&blkback);
|
||||||
|
}
|
123
include/xen/blkif.h
Normal file
123
include/xen/blkif.h
Normal file
|
@ -0,0 +1,123 @@
|
||||||
|
/*
|
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
* of this software and associated documentation files (the "Software"), to
|
||||||
|
* deal in the Software without restriction, including without limitation the
|
||||||
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||||
|
* sell copies of the Software, and to permit persons to whom the Software is
|
||||||
|
* furnished to do so, subject to the following conditions:
|
||||||
|
*
|
||||||
|
* The above copyright notice and this permission notice shall be included in
|
||||||
|
* all copies or substantial portions of the Software.
|
||||||
|
*
|
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
* DEALINGS IN THE SOFTWARE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __XEN_BLKIF_H__
|
||||||
|
#define __XEN_BLKIF_H__
|
||||||
|
|
||||||
|
#include <xen/interface/io/ring.h>
|
||||||
|
#include <xen/interface/io/blkif.h>
|
||||||
|
#include <xen/interface/io/protocols.h>
|
||||||
|
|
||||||
|
/* Not a real protocol. Used to generate ring structs which contain
|
||||||
|
* the elements common to all protocols only. This way we get a
|
||||||
|
* compiler-checkable way to use common struct elements, so we can
|
||||||
|
* avoid using switch(protocol) in a number of places. */
|
||||||
|
struct blkif_common_request {
|
||||||
|
char dummy;
|
||||||
|
};
|
||||||
|
struct blkif_common_response {
|
||||||
|
char dummy;
|
||||||
|
};
|
||||||
|
|
||||||
|
/* i386 protocol version */
|
||||||
|
#pragma pack(push, 4)
|
||||||
|
struct blkif_x86_32_request {
|
||||||
|
uint8_t operation; /* BLKIF_OP_??? */
|
||||||
|
uint8_t nr_segments; /* number of segments */
|
||||||
|
blkif_vdev_t handle; /* only for read/write requests */
|
||||||
|
uint64_t id; /* private guest value, echoed in resp */
|
||||||
|
blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */
|
||||||
|
struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
|
||||||
|
};
|
||||||
|
struct blkif_x86_32_response {
|
||||||
|
uint64_t id; /* copied from request */
|
||||||
|
uint8_t operation; /* copied from request */
|
||||||
|
int16_t status; /* BLKIF_RSP_??? */
|
||||||
|
};
|
||||||
|
typedef struct blkif_x86_32_request blkif_x86_32_request_t;
|
||||||
|
typedef struct blkif_x86_32_response blkif_x86_32_response_t;
|
||||||
|
#pragma pack(pop)
|
||||||
|
|
||||||
|
/* x86_64 protocol version */
|
||||||
|
struct blkif_x86_64_request {
|
||||||
|
uint8_t operation; /* BLKIF_OP_??? */
|
||||||
|
uint8_t nr_segments; /* number of segments */
|
||||||
|
blkif_vdev_t handle; /* only for read/write requests */
|
||||||
|
uint64_t __attribute__((__aligned__(8))) id;
|
||||||
|
blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */
|
||||||
|
struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
|
||||||
|
};
|
||||||
|
struct blkif_x86_64_response {
|
||||||
|
uint64_t __attribute__((__aligned__(8))) id;
|
||||||
|
uint8_t operation; /* copied from request */
|
||||||
|
int16_t status; /* BLKIF_RSP_??? */
|
||||||
|
};
|
||||||
|
typedef struct blkif_x86_64_request blkif_x86_64_request_t;
|
||||||
|
typedef struct blkif_x86_64_response blkif_x86_64_response_t;
|
||||||
|
|
||||||
|
DEFINE_RING_TYPES(blkif_common, struct blkif_common_request, struct blkif_common_response);
|
||||||
|
DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request, struct blkif_x86_32_response);
|
||||||
|
DEFINE_RING_TYPES(blkif_x86_64, struct blkif_x86_64_request, struct blkif_x86_64_response);
|
||||||
|
|
||||||
|
union blkif_back_rings {
|
||||||
|
blkif_back_ring_t native;
|
||||||
|
blkif_common_back_ring_t common;
|
||||||
|
blkif_x86_32_back_ring_t x86_32;
|
||||||
|
blkif_x86_64_back_ring_t x86_64;
|
||||||
|
};
|
||||||
|
typedef union blkif_back_rings blkif_back_rings_t;
|
||||||
|
|
||||||
|
enum blkif_protocol {
|
||||||
|
BLKIF_PROTOCOL_NATIVE = 1,
|
||||||
|
BLKIF_PROTOCOL_X86_32 = 2,
|
||||||
|
BLKIF_PROTOCOL_X86_64 = 3,
|
||||||
|
};
|
||||||
|
|
||||||
|
static void inline blkif_get_x86_32_req(blkif_request_t *dst, blkif_x86_32_request_t *src)
|
||||||
|
{
|
||||||
|
int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
|
||||||
|
dst->operation = src->operation;
|
||||||
|
dst->nr_segments = src->nr_segments;
|
||||||
|
dst->handle = src->handle;
|
||||||
|
dst->id = src->id;
|
||||||
|
dst->sector_number = src->sector_number;
|
||||||
|
barrier();
|
||||||
|
if (n > dst->nr_segments)
|
||||||
|
n = dst->nr_segments;
|
||||||
|
for (i = 0; i < n; i++)
|
||||||
|
dst->seg[i] = src->seg[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
static void inline blkif_get_x86_64_req(blkif_request_t *dst, blkif_x86_64_request_t *src)
|
||||||
|
{
|
||||||
|
int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
|
||||||
|
dst->operation = src->operation;
|
||||||
|
dst->nr_segments = src->nr_segments;
|
||||||
|
dst->handle = src->handle;
|
||||||
|
dst->id = src->id;
|
||||||
|
dst->sector_number = src->sector_number;
|
||||||
|
barrier();
|
||||||
|
if (n > dst->nr_segments)
|
||||||
|
n = dst->nr_segments;
|
||||||
|
for (i = 0; i < n; i++)
|
||||||
|
dst->seg[i] = src->seg[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* __XEN_BLKIF_H__ */
|
Loading…
Reference in a new issue