2011-04-15 06:25:47 +08:00
|
|
|
/* 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.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kthread.h>
|
2011-04-20 22:57:29 +08:00
|
|
|
#include <xen/events.h>
|
|
|
|
#include <xen/grant_table.h>
|
2011-04-15 06:25:47 +08:00
|
|
|
#include "common.h"
|
|
|
|
|
2011-04-15 05:33:30 +08:00
|
|
|
struct backend_info {
|
2011-05-12 03:57:09 +08:00
|
|
|
struct xenbus_device *dev;
|
2011-05-13 06:02:28 +08:00
|
|
|
struct xen_blkif *blkif;
|
2011-05-12 03:57:09 +08:00
|
|
|
struct xenbus_watch backend_watch;
|
|
|
|
unsigned major;
|
|
|
|
unsigned minor;
|
|
|
|
char *mode;
|
2011-04-15 06:25:47 +08:00
|
|
|
};
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
static struct kmem_cache *xen_blkif_cachep;
|
2011-04-15 06:25:47 +08:00
|
|
|
static void connect(struct backend_info *);
|
|
|
|
static int connect_ring(struct backend_info *);
|
|
|
|
static void backend_changed(struct xenbus_watch *, const char **,
|
|
|
|
unsigned int);
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
struct xenbus_device *xen_blkbk_xenbus(struct backend_info *be)
|
2010-03-19 06:35:05 +08:00
|
|
|
{
|
|
|
|
return be->dev;
|
|
|
|
}
|
|
|
|
|
2011-05-13 04:47:48 +08:00
|
|
|
static int blkback_name(struct xen_blkif *blkif, char *buf)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
2011-04-15 05:33:30 +08:00
|
|
|
devname = strstr(devpath, "/dev/");
|
|
|
|
if (devname != NULL)
|
2011-04-15 06:25:47 +08:00
|
|
|
devname += strlen("/dev/");
|
|
|
|
else
|
|
|
|
devname = devpath;
|
|
|
|
|
|
|
|
snprintf(buf, TASK_COMM_LEN, "blkback.%d.%s", blkif->domid, devname);
|
|
|
|
kfree(devpath);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-13 04:47:48 +08:00
|
|
|
static void xen_update_blkif_status(struct xen_blkif *blkif)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-07-22 03:41:45 +08:00
|
|
|
err = filemap_write_and_wait(blkif->vbd.bdev->bd_inode->i_mapping);
|
|
|
|
if (err) {
|
|
|
|
xenbus_dev_error(blkif->be->dev, err, "block flush");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
invalidate_inode_pages2(blkif->vbd.bdev->bd_inode->i_mapping);
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
blkif->xenblkd = kthread_run(xen_blkif_schedule, blkif, name);
|
2011-04-15 06:25:47 +08:00
|
|
|
if (IS_ERR(blkif->xenblkd)) {
|
|
|
|
err = PTR_ERR(blkif->xenblkd);
|
|
|
|
blkif->xenblkd = NULL;
|
|
|
|
xenbus_dev_error(blkif->be->dev, err, "start xenblkd");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-13 04:47:48 +08:00
|
|
|
static struct xen_blkif *xen_blkif_alloc(domid_t domid)
|
2011-04-20 22:57:29 +08:00
|
|
|
{
|
2011-05-13 04:47:48 +08:00
|
|
|
struct xen_blkif *blkif;
|
2011-04-20 22:57:29 +08:00
|
|
|
|
2012-08-27 12:28:57 +08:00
|
|
|
blkif = kmem_cache_zalloc(xen_blkif_cachep, GFP_KERNEL);
|
2011-04-20 22:57:29 +08:00
|
|
|
if (!blkif)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
blkif->domid = domid;
|
|
|
|
spin_lock_init(&blkif->blk_ring_lock);
|
|
|
|
atomic_set(&blkif->refcnt, 1);
|
|
|
|
init_waitqueue_head(&blkif->wq);
|
2011-10-10 12:42:22 +08:00
|
|
|
init_completion(&blkif->drain_complete);
|
|
|
|
atomic_set(&blkif->drain, 0);
|
2011-04-20 22:57:29 +08:00
|
|
|
blkif->st_print = jiffies;
|
|
|
|
init_waitqueue_head(&blkif->waiting_to_free);
|
|
|
|
|
|
|
|
return blkif;
|
|
|
|
}
|
|
|
|
|
2011-05-13 04:47:48 +08:00
|
|
|
static int xen_blkif_map(struct xen_blkif *blkif, unsigned long shared_page,
|
2011-04-20 23:50:43 +08:00
|
|
|
unsigned int evtchn)
|
2011-04-20 22:57:29 +08:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* Already connected through? */
|
|
|
|
if (blkif->irq)
|
|
|
|
return 0;
|
|
|
|
|
2011-09-29 23:53:30 +08:00
|
|
|
err = xenbus_map_ring_valloc(blkif->be->dev, shared_page, &blkif->blk_ring);
|
|
|
|
if (err < 0)
|
2011-04-20 22:57:29 +08:00
|
|
|
return err;
|
|
|
|
|
|
|
|
switch (blkif->blk_protocol) {
|
|
|
|
case BLKIF_PROTOCOL_NATIVE:
|
|
|
|
{
|
|
|
|
struct blkif_sring *sring;
|
2011-09-29 23:53:30 +08:00
|
|
|
sring = (struct blkif_sring *)blkif->blk_ring;
|
2011-04-20 22:57:29 +08:00
|
|
|
BACK_RING_INIT(&blkif->blk_rings.native, sring, PAGE_SIZE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BLKIF_PROTOCOL_X86_32:
|
|
|
|
{
|
|
|
|
struct blkif_x86_32_sring *sring_x86_32;
|
2011-09-29 23:53:30 +08:00
|
|
|
sring_x86_32 = (struct blkif_x86_32_sring *)blkif->blk_ring;
|
2011-04-20 22:57:29 +08:00
|
|
|
BACK_RING_INIT(&blkif->blk_rings.x86_32, sring_x86_32, PAGE_SIZE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BLKIF_PROTOCOL_X86_64:
|
|
|
|
{
|
|
|
|
struct blkif_x86_64_sring *sring_x86_64;
|
2011-09-29 23:53:30 +08:00
|
|
|
sring_x86_64 = (struct blkif_x86_64_sring *)blkif->blk_ring;
|
2011-04-20 22:57:29 +08:00
|
|
|
BACK_RING_INIT(&blkif->blk_rings.x86_64, sring_x86_64, PAGE_SIZE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
err = bind_interdomain_evtchn_to_irqhandler(blkif->domid, evtchn,
|
|
|
|
xen_blkif_be_int, 0,
|
|
|
|
"blkif-backend", blkif);
|
2011-04-20 22:57:29 +08:00
|
|
|
if (err < 0) {
|
2011-09-29 23:53:30 +08:00
|
|
|
xenbus_unmap_ring_vfree(blkif->be->dev, blkif->blk_ring);
|
2011-04-20 22:57:29 +08:00
|
|
|
blkif->blk_rings.common.sring = NULL;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
blkif->irq = err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-13 04:47:48 +08:00
|
|
|
static void xen_blkif_disconnect(struct xen_blkif *blkif)
|
2011-04-20 22:57:29 +08:00
|
|
|
{
|
|
|
|
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) {
|
2011-09-29 23:53:30 +08:00
|
|
|
xenbus_unmap_ring_vfree(blkif->be->dev, blkif->blk_ring);
|
2011-04-20 22:57:29 +08:00
|
|
|
blkif->blk_rings.common.sring = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-13 22:53:17 +08:00
|
|
|
static void xen_blkif_free(struct xen_blkif *blkif)
|
2011-04-20 22:57:29 +08:00
|
|
|
{
|
|
|
|
if (!atomic_dec_and_test(&blkif->refcnt))
|
|
|
|
BUG();
|
2011-04-20 23:50:43 +08:00
|
|
|
kmem_cache_free(xen_blkif_cachep, blkif);
|
2011-04-20 22:57:29 +08:00
|
|
|
}
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
int __init xen_blkif_interface_init(void)
|
2011-04-20 22:57:29 +08:00
|
|
|
{
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_blkif_cachep = kmem_cache_create("blkif_cache",
|
2011-05-13 04:47:48 +08:00
|
|
|
sizeof(struct xen_blkif),
|
2011-04-20 23:50:43 +08:00
|
|
|
0, 0, NULL);
|
|
|
|
if (!xen_blkif_cachep)
|
2011-04-20 22:57:29 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-04-15 06:25:47 +08:00
|
|
|
|
2011-04-15 05:05:23 +08:00
|
|
|
/*
|
2011-04-15 06:25:47 +08:00
|
|
|
* 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); \
|
2010-02-12 08:07:31 +08:00
|
|
|
struct backend_info *be = dev_get_drvdata(&dev->dev); \
|
2011-04-15 06:25:47 +08:00
|
|
|
\
|
|
|
|
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);
|
2011-05-05 05:07:27 +08:00
|
|
|
VBD_SHOW(f_req, "%d\n", be->blkif->st_f_req);
|
2011-09-01 18:39:10 +08:00
|
|
|
VBD_SHOW(ds_req, "%d\n", be->blkif->st_ds_req);
|
2011-04-15 06:25:47 +08:00
|
|
|
VBD_SHOW(rd_sect, "%d\n", be->blkif->st_rd_sect);
|
|
|
|
VBD_SHOW(wr_sect, "%d\n", be->blkif->st_wr_sect);
|
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
static struct attribute *xen_vbdstat_attrs[] = {
|
2011-04-15 06:25:47 +08:00
|
|
|
&dev_attr_oo_req.attr,
|
|
|
|
&dev_attr_rd_req.attr,
|
|
|
|
&dev_attr_wr_req.attr,
|
2011-05-05 05:07:27 +08:00
|
|
|
&dev_attr_f_req.attr,
|
2011-09-01 18:39:10 +08:00
|
|
|
&dev_attr_ds_req.attr,
|
2011-04-15 06:25:47 +08:00
|
|
|
&dev_attr_rd_sect.attr,
|
|
|
|
&dev_attr_wr_sect.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
static struct attribute_group xen_vbdstat_group = {
|
2011-04-15 06:25:47 +08:00
|
|
|
.name = "statistics",
|
2011-05-13 04:53:56 +08:00
|
|
|
.attrs = xen_vbdstat_attrs,
|
2011-04-15 06:25:47 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
VBD_SHOW(physical_device, "%x:%x\n", be->major, be->minor);
|
|
|
|
VBD_SHOW(mode, "%s\n", be->mode);
|
|
|
|
|
2012-08-13 22:53:17 +08:00
|
|
|
static int xenvbd_sysfs_addif(struct xenbus_device *dev)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = device_create_file(&dev->dev, &dev_attr_physical_device);
|
2011-04-15 05:33:30 +08:00
|
|
|
if (error)
|
2011-04-15 06:25:47 +08:00
|
|
|
goto fail1;
|
|
|
|
|
|
|
|
error = device_create_file(&dev->dev, &dev_attr_mode);
|
|
|
|
if (error)
|
|
|
|
goto fail2;
|
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
error = sysfs_create_group(&dev->dev.kobj, &xen_vbdstat_group);
|
2011-04-15 06:25:47 +08:00
|
|
|
if (error)
|
|
|
|
goto fail3;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
fail3: sysfs_remove_group(&dev->dev.kobj, &xen_vbdstat_group);
|
2011-04-15 06:25:47 +08:00
|
|
|
fail2: device_remove_file(&dev->dev, &dev_attr_mode);
|
|
|
|
fail1: device_remove_file(&dev->dev, &dev_attr_physical_device);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2012-08-13 22:53:17 +08:00
|
|
|
static void xenvbd_sysfs_delif(struct xenbus_device *dev)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
2011-05-13 04:53:56 +08:00
|
|
|
sysfs_remove_group(&dev->dev.kobj, &xen_vbdstat_group);
|
2011-04-15 06:25:47 +08:00
|
|
|
device_remove_file(&dev->dev, &dev_attr_mode);
|
|
|
|
device_remove_file(&dev->dev, &dev_attr_physical_device);
|
|
|
|
}
|
|
|
|
|
2011-04-20 23:21:43 +08:00
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
static void xen_vbd_free(struct xen_vbd *vbd)
|
2011-04-20 23:21:43 +08:00
|
|
|
{
|
|
|
|
if (vbd->bdev)
|
|
|
|
blkdev_put(vbd->bdev, vbd->readonly ? FMODE_READ : FMODE_WRITE);
|
|
|
|
vbd->bdev = NULL;
|
|
|
|
}
|
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle,
|
|
|
|
unsigned major, unsigned minor, int readonly,
|
|
|
|
int cdrom)
|
2011-04-20 23:21:43 +08:00
|
|
|
{
|
2011-05-13 04:53:56 +08:00
|
|
|
struct xen_vbd *vbd;
|
2011-04-20 23:21:43 +08:00
|
|
|
struct block_device *bdev;
|
2011-05-05 05:07:27 +08:00
|
|
|
struct request_queue *q;
|
2011-04-20 23:21:43 +08:00
|
|
|
|
|
|
|
vbd = &blkif->vbd;
|
|
|
|
vbd->handle = handle;
|
|
|
|
vbd->readonly = readonly;
|
|
|
|
vbd->type = 0;
|
|
|
|
|
|
|
|
vbd->pdevice = MKDEV(major, minor);
|
|
|
|
|
|
|
|
bdev = blkdev_get_by_dev(vbd->pdevice, vbd->readonly ?
|
|
|
|
FMODE_READ : FMODE_WRITE, NULL);
|
|
|
|
|
|
|
|
if (IS_ERR(bdev)) {
|
2011-05-13 04:53:56 +08:00
|
|
|
DPRINTK("xen_vbd_create: device %08x could not be opened.\n",
|
2011-04-20 23:21:43 +08:00
|
|
|
vbd->pdevice);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
vbd->bdev = bdev;
|
|
|
|
if (vbd->bdev->bd_disk == NULL) {
|
2011-05-13 04:53:56 +08:00
|
|
|
DPRINTK("xen_vbd_create: device %08x doesn't exist.\n",
|
2011-04-20 23:21:43 +08:00
|
|
|
vbd->pdevice);
|
2011-05-13 04:53:56 +08:00
|
|
|
xen_vbd_free(vbd);
|
2011-04-20 23:21:43 +08:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
2011-05-25 18:24:25 +08:00
|
|
|
vbd->size = vbd_sz(vbd);
|
2011-04-20 23:21:43 +08:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2011-05-05 05:07:27 +08:00
|
|
|
q = bdev_get_queue(bdev);
|
|
|
|
if (q && q->flush_flags)
|
|
|
|
vbd->flush_support = true;
|
|
|
|
|
2011-10-13 04:23:30 +08:00
|
|
|
if (q && blk_queue_secdiscard(q))
|
|
|
|
vbd->discard_secure = true;
|
|
|
|
|
2011-04-20 23:21:43 +08:00
|
|
|
DPRINTK("Successful creation of handle=%04x (dom=%u)\n",
|
|
|
|
handle, blkif->domid);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-04-20 23:50:43 +08:00
|
|
|
static int xen_blkbk_remove(struct xenbus_device *dev)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
2010-02-12 08:07:31 +08:00
|
|
|
struct backend_info *be = dev_get_drvdata(&dev->dev);
|
2011-04-15 06:25:47 +08:00
|
|
|
|
|
|
|
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) {
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_blkif_disconnect(be->blkif);
|
2011-05-13 04:53:56 +08:00
|
|
|
xen_vbd_free(&be->blkif->vbd);
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_blkif_free(be->blkif);
|
2011-04-15 06:25:47 +08:00
|
|
|
be->blkif = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(be);
|
2010-02-12 08:07:31 +08:00
|
|
|
dev_set_drvdata(&dev->dev, NULL);
|
2011-04-15 06:25:47 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-05 05:07:27 +08:00
|
|
|
int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt,
|
|
|
|
struct backend_info *be, int state)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
|
|
|
struct xenbus_device *dev = be->dev;
|
|
|
|
int err;
|
|
|
|
|
2011-05-05 05:07:27 +08:00
|
|
|
err = xenbus_printf(xbt, dev->nodename, "feature-flush-cache",
|
2011-04-15 06:25:47 +08:00
|
|
|
"%d", state);
|
|
|
|
if (err)
|
2012-03-15 01:04:00 +08:00
|
|
|
dev_warn(&dev->dev, "writing feature-flush-cache (%d)", err);
|
2011-04-15 06:25:47 +08:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-03-15 01:04:00 +08:00
|
|
|
static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_info *be)
|
2011-09-01 18:39:10 +08:00
|
|
|
{
|
|
|
|
struct xenbus_device *dev = be->dev;
|
|
|
|
struct xen_blkif *blkif = be->blkif;
|
|
|
|
int err;
|
|
|
|
int state = 0;
|
2012-03-14 06:43:23 +08:00
|
|
|
struct block_device *bdev = be->blkif->vbd.bdev;
|
|
|
|
struct request_queue *q = bdev_get_queue(bdev);
|
|
|
|
|
|
|
|
if (blk_queue_discard(q)) {
|
|
|
|
err = xenbus_printf(xbt, dev->nodename,
|
|
|
|
"discard-granularity", "%u",
|
|
|
|
q->limits.discard_granularity);
|
|
|
|
if (err) {
|
2012-03-15 01:04:00 +08:00
|
|
|
dev_warn(&dev->dev, "writing discard-granularity (%d)", err);
|
|
|
|
return;
|
2012-03-14 06:43:23 +08:00
|
|
|
}
|
|
|
|
err = xenbus_printf(xbt, dev->nodename,
|
|
|
|
"discard-alignment", "%u",
|
|
|
|
q->limits.discard_alignment);
|
|
|
|
if (err) {
|
2012-03-15 01:04:00 +08:00
|
|
|
dev_warn(&dev->dev, "writing discard-alignment (%d)", err);
|
|
|
|
return;
|
2011-09-01 18:39:10 +08:00
|
|
|
}
|
2012-03-14 06:43:23 +08:00
|
|
|
state = 1;
|
|
|
|
/* Optional. */
|
|
|
|
err = xenbus_printf(xbt, dev->nodename,
|
|
|
|
"discard-secure", "%d",
|
|
|
|
blkif->vbd.discard_secure);
|
|
|
|
if (err) {
|
2012-04-17 09:55:04 +08:00
|
|
|
dev_warn(&dev->dev, "writing discard-secure (%d)", err);
|
2012-03-15 01:04:00 +08:00
|
|
|
return;
|
2011-09-01 18:39:10 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
err = xenbus_printf(xbt, dev->nodename, "feature-discard",
|
|
|
|
"%d", state);
|
|
|
|
if (err)
|
2012-03-15 01:04:00 +08:00
|
|
|
dev_warn(&dev->dev, "writing feature-discard (%d)", err);
|
2011-09-01 18:39:10 +08:00
|
|
|
}
|
2011-10-10 12:42:22 +08:00
|
|
|
int xen_blkbk_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)
|
2012-03-15 01:04:00 +08:00
|
|
|
dev_warn(&dev->dev, "writing feature-barrier (%d)", err);
|
2011-10-10 12:42:22 +08:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2011-09-01 18:39:10 +08:00
|
|
|
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
2011-04-15 06:25:47 +08:00
|
|
|
* 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.
|
|
|
|
*/
|
2011-04-20 23:50:43 +08:00
|
|
|
static int xen_blkbk_probe(struct xenbus_device *dev,
|
|
|
|
const struct xenbus_device_id *id)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
|
|
|
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;
|
2010-02-12 08:07:31 +08:00
|
|
|
dev_set_drvdata(&dev->dev, be);
|
2011-04-15 06:25:47 +08:00
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
be->blkif = xen_blkif_alloc(dev->otherend_id);
|
2011-04-15 06:25:47 +08:00
|
|
|
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;
|
|
|
|
|
2009-02-10 04:05:51 +08:00
|
|
|
err = xenbus_watch_pathfmt(dev, &be->backend_watch, backend_changed,
|
|
|
|
"%s/%s", dev->nodename, "physical-device");
|
2011-04-15 06:25:47 +08:00
|
|
|
if (err)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
err = xenbus_switch_state(dev, XenbusStateInitWait);
|
|
|
|
if (err)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
DPRINTK("failed");
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_blkbk_remove(dev);
|
2011-04-15 06:25:47 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
2011-04-15 06:25:47 +08:00
|
|
|
* 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)) {
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
|
|
|
* Since this watch will fire once immediately after it is
|
|
|
|
* registered, we expect this. Ignore it, and wait for the
|
|
|
|
* hotplug scripts.
|
|
|
|
*/
|
2011-04-15 06:25:47 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (err != 2) {
|
|
|
|
xenbus_dev_fatal(dev, err, "reading physical-device");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((be->major || be->minor) &&
|
|
|
|
((be->major != major) || (be->minor != minor))) {
|
2011-05-13 04:43:12 +08:00
|
|
|
pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n",
|
2011-05-13 04:42:31 +08:00
|
|
|
be->major, be->minor, major, minor);
|
2011-04-15 06:25:47 +08:00
|
|
|
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;
|
2011-04-15 05:33:30 +08:00
|
|
|
long handle;
|
|
|
|
err = strict_strtoul(p, 0, &handle);
|
|
|
|
if (err)
|
|
|
|
return;
|
2011-04-15 06:25:47 +08:00
|
|
|
|
|
|
|
be->major = major;
|
|
|
|
be->minor = minor;
|
|
|
|
|
2011-05-13 04:53:56 +08:00
|
|
|
err = xen_vbd_create(be->blkif, handle, major, minor,
|
2011-04-15 06:25:47 +08:00
|
|
|
(NULL == strchr(be->mode, 'w')), cdrom);
|
|
|
|
if (err) {
|
2011-05-13 04:19:23 +08:00
|
|
|
be->major = 0;
|
|
|
|
be->minor = 0;
|
2011-04-15 06:25:47 +08:00
|
|
|
xenbus_dev_fatal(dev, err, "creating vbd structure");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = xenvbd_sysfs_addif(dev);
|
|
|
|
if (err) {
|
2011-05-13 04:53:56 +08:00
|
|
|
xen_vbd_free(&be->blkif->vbd);
|
2011-05-13 04:19:23 +08:00
|
|
|
be->major = 0;
|
|
|
|
be->minor = 0;
|
2011-04-15 06:25:47 +08:00
|
|
|
xenbus_dev_fatal(dev, err, "creating sysfs entries");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We're potentially connected now */
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_update_blkif_status(be->blkif);
|
2011-04-15 06:25:47 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
2011-04-15 06:25:47 +08:00
|
|
|
* Callback received when the frontend's state changes.
|
|
|
|
*/
|
|
|
|
static void frontend_changed(struct xenbus_device *dev,
|
|
|
|
enum xenbus_state frontend_state)
|
|
|
|
{
|
2010-02-12 08:07:31 +08:00
|
|
|
struct backend_info *be = dev_get_drvdata(&dev->dev);
|
2011-04-15 06:25:47 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
DPRINTK("%s", xenbus_strstate(frontend_state));
|
|
|
|
|
|
|
|
switch (frontend_state) {
|
|
|
|
case XenbusStateInitialising:
|
|
|
|
if (dev->state == XenbusStateClosed) {
|
2011-05-13 04:43:12 +08:00
|
|
|
pr_info(DRV_PFX "%s: prepare for reconnect\n",
|
2011-05-13 04:42:31 +08:00
|
|
|
dev->nodename);
|
2011-04-15 06:25:47 +08:00
|
|
|
xenbus_switch_state(dev, XenbusStateInitWait);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XenbusStateInitialised:
|
|
|
|
case XenbusStateConnected:
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
|
|
|
* Ensure we connect even when two watches fire in
|
2011-11-29 12:31:00 +08:00
|
|
|
* close succession and we miss the intermediate value
|
2011-05-12 03:57:09 +08:00
|
|
|
* of frontend_state.
|
|
|
|
*/
|
2011-04-15 06:25:47 +08:00
|
|
|
if (dev->state == XenbusStateConnected)
|
|
|
|
break;
|
|
|
|
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
|
|
|
* Enforce precondition before potential leak point.
|
2011-08-15 12:57:07 +08:00
|
|
|
* xen_blkif_disconnect() is idempotent.
|
2010-11-25 14:08:20 +08:00
|
|
|
*/
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_blkif_disconnect(be->blkif);
|
2010-11-25 14:08:20 +08:00
|
|
|
|
2011-04-15 06:25:47 +08:00
|
|
|
err = connect_ring(be);
|
|
|
|
if (err)
|
|
|
|
break;
|
2011-04-20 23:50:43 +08:00
|
|
|
xen_update_blkif_status(be->blkif);
|
2011-04-15 06:25:47 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case XenbusStateClosing:
|
|
|
|
xenbus_switch_state(dev, XenbusStateClosing);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XenbusStateClosed:
|
xen-blkback: Don't disconnect backend until state switched to XenbusStateClosed.
When do block-attach/block-detach test with below steps, umount hangs
in the guest. Furthermore shutdown ends up being stuck when umounting file-systems.
1. start guest.
2. attach new block device by xm block-attach in Dom0.
3. mount new disk in guest.
4. execute xm block-detach to detach the block device in dom0 until timeout
5. Any request to the disk will hung.
Root cause:
This issue is caused when setting backend device's state to
'XenbusStateClosing', which sends to the frontend the XenbusStateClosing
notification. When frontend receives the notification it tries to release
the disk in blkfront_closing(), but at that moment the disk is still in use
by guest, so frontend refuses to close. Specifically it sets the disk state to
XenbusStateClosing and sends the notification to backend - when backend receives the
event, it disconnects the vbd from real device, and sets the vbd device state to
XenbusStateClosing. The backend disconnects the real device/file, and any IO
requests to the disk in guest will end up in ether, leaving disk DEAD and set to
XenbusStateClosing. When the guest wants to disconnect the disk, umount will
hang on blkif_release()->xlvbd_release_gendisk() as it is unable to send any IO
to the disk, which prevents clean system shutdown.
Solution:
Don't disconnect backend until frontend state switched to XenbusStateClosed.
Signed-off-by: Joe Jin <joe.jin@oracle.com>
Cc: Daniel Stodden <daniel.stodden@citrix.com>
Cc: Jens Axboe <jaxboe@fusionio.com>
Cc: Annie Li <annie.li@oracle.com>
Cc: Ian Campbell <Ian.Campbell@eu.citrix.com>
[v1: Modified description a bit]
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
2011-08-15 12:51:31 +08:00
|
|
|
xen_blkif_disconnect(be->blkif);
|
2011-04-15 06:25:47 +08:00
|
|
|
xenbus_switch_state(dev, XenbusStateClosed);
|
|
|
|
if (xenbus_dev_is_online(dev))
|
|
|
|
break;
|
|
|
|
/* fall through if not online */
|
|
|
|
case XenbusStateUnknown:
|
2011-08-15 12:57:07 +08:00
|
|
|
/* implies xen_blkif_disconnect() via xen_blkbk_remove() */
|
2011-04-15 06:25:47 +08:00
|
|
|
device_unregister(&dev->dev);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend",
|
|
|
|
frontend_state);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ** Connection ** */
|
|
|
|
|
|
|
|
|
2011-05-12 03:57:09 +08:00
|
|
|
/*
|
2011-04-15 06:25:47 +08:00
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2012-03-15 01:04:00 +08:00
|
|
|
/* If we can't advertise it is OK. */
|
|
|
|
xen_blkbk_flush_diskcache(xbt, be, be->blkif->vbd.flush_support);
|
2011-04-15 06:25:47 +08:00
|
|
|
|
2012-03-15 01:04:00 +08:00
|
|
|
xen_blkbk_discard(xbt, be);
|
2011-09-01 18:39:10 +08:00
|
|
|
|
2012-03-15 01:04:00 +08:00
|
|
|
xen_blkbk_barrier(xbt, be, be->blkif->vbd.flush_support);
|
2011-10-10 12:42:22 +08:00
|
|
|
|
2011-04-15 06:25:47 +08:00
|
|
|
err = xenbus_printf(xbt, dev->nodename, "sectors", "%llu",
|
2011-04-20 23:21:43 +08:00
|
|
|
(unsigned long long)vbd_sz(&be->blkif->vbd));
|
2011-04-15 06:25:47 +08:00
|
|
|
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",
|
2011-04-20 23:21:43 +08:00
|
|
|
be->blkif->vbd.type |
|
|
|
|
(be->blkif->vbd.readonly ? VDISK_READONLY : 0));
|
2011-04-15 06:25:47 +08:00
|
|
|
if (err) {
|
|
|
|
xenbus_dev_fatal(dev, err, "writing %s/info",
|
|
|
|
dev->nodename);
|
|
|
|
goto abort;
|
|
|
|
}
|
|
|
|
err = xenbus_printf(xbt, dev->nodename, "sector-size", "%lu",
|
2011-04-20 23:21:43 +08:00
|
|
|
(unsigned long)
|
|
|
|
bdev_logical_block_size(be->blkif->vbd.bdev));
|
2011-04-15 06:25:47 +08:00
|
|
|
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)
|
2011-06-13 00:21:13 +08:00
|
|
|
xenbus_dev_fatal(dev, err, "%s: switching to Connected state",
|
2011-04-15 06:25:47 +08:00
|
|
|
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);
|
|
|
|
|
2011-04-15 05:33:30 +08:00
|
|
|
err = xenbus_gather(XBT_NIL, dev->otherend, "ring-ref", "%lu",
|
|
|
|
&ring_ref, "event-channel", "%u", &evtchn, NULL);
|
2011-04-15 06:25:47 +08:00
|
|
|
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;
|
|
|
|
}
|
2011-05-13 04:43:12 +08:00
|
|
|
pr_info(DRV_PFX "ring-ref %ld, event-channel %d, protocol %d (%s)\n",
|
2011-05-13 04:42:31 +08:00
|
|
|
ring_ref, evtchn, be->blkif->blk_protocol, protocol);
|
2011-04-15 06:25:47 +08:00
|
|
|
|
|
|
|
/* Map the shared frame, irq etc. */
|
2011-04-20 23:50:43 +08:00
|
|
|
err = xen_blkif_map(be->blkif, ring_ref, evtchn);
|
2011-04-15 06:25:47 +08:00
|
|
|
if (err) {
|
|
|
|
xenbus_dev_fatal(dev, err, "mapping ring-ref %lu port %u",
|
|
|
|
ring_ref, evtchn);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ** Driver Registration ** */
|
|
|
|
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
static const struct xenbus_device_id xen_blkbk_ids[] = {
|
2011-04-15 06:25:47 +08:00
|
|
|
{ "vbd" },
|
|
|
|
{ "" }
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-12-22 17:08:13 +08:00
|
|
|
static DEFINE_XENBUS_DRIVER(xen_blkbk, ,
|
2011-04-20 23:50:43 +08:00
|
|
|
.probe = xen_blkbk_probe,
|
|
|
|
.remove = xen_blkbk_remove,
|
2011-04-15 06:25:47 +08:00
|
|
|
.otherend_changed = frontend_changed
|
2011-12-22 17:08:13 +08:00
|
|
|
);
|
2011-04-15 06:25:47 +08:00
|
|
|
|
|
|
|
|
2011-04-20 23:50:43 +08:00
|
|
|
int xen_blkif_xenbus_init(void)
|
2011-04-15 06:25:47 +08:00
|
|
|
{
|
2011-12-22 17:08:13 +08:00
|
|
|
return xenbus_register_backend(&xen_blkbk_driver);
|
2011-04-15 06:25:47 +08:00
|
|
|
}
|