leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xen-blkback-porting

Browse Source
This commit is contained in:
Jeremy Fitzhardinge 2009-02-09 12:05:51 -08:00 committed by Konrad Rzeszutek Wilk
parent 4d05a28db5
commit 8812293323
6 changed files with 42 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
drivers/xen/blkback/blkback.c
View File

@ -39,8 +39,12 @@
#include <linux/kthread.h>
#include <linux/list.h>
#include <linux/delay.h>
#include <linux/freezer.h>
#include <xen/balloon.h>
#include <asm/hypervisor.h>
#include <xen/events.h>
#include <xen/page.h>
#include <asm/xen/hypervisor.h>
#include <asm/xen/hypercall.h>
#include "common.h"
/*
@ -106,7 +110,7 @@ static inline unsigned long vaddr(pending_req_t *req, int seg)
static int do_block_io_op(blkif_t *blkif);
static void dispatch_rw_block_io(blkif_t *blkif,
blkif_request_t *req,
struct blkif_request *req,
pending_req_t *pending_req);
static void make_response(blkif_t *blkif, u64 id,
unsigned short op, int st);
@ -153,7 +157,7 @@ static void unplug_queue(blkif_t *blkif)
static void plug_queue(blkif_t *blkif, struct block_device *bdev)
{
request_queue_t *q = bdev_get_queue(bdev);
struct request_queue *q = bdev_get_queue(bdev);
if (q == blkif->plug)
return;
@ -268,13 +272,10 @@ static void __end_block_io_op(pending_req_t *pending_req, int error)
}
}
static int end_block_io_op(struct bio *bio, unsigned int done, int error)
static void end_block_io_op(struct bio *bio, int error)
{
if (bio->bi_size != 0)
return 1;
__end_block_io_op(bio->bi_private, error);
bio_put(bio);
return error;
}
@ -288,7 +289,7 @@ static void blkif_notify_work(blkif_t *blkif)
wake_up(&blkif->wq);
}
irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs)
irqreturn_t blkif_be_int(int irq, void *dev_id)
{
blkif_notify_work(dev_id);
return IRQ_HANDLED;
@ -302,8 +303,8 @@ irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs)
static int do_block_io_op(blkif_t *blkif)
{
blkif_back_rings_t *blk_rings = &blkif->blk_rings;
blkif_request_t req;
union blkif_back_rings *blk_rings = &blkif->blk_rings;
struct blkif_request req;
pending_req_t *pending_req;
RING_IDX rc, rp;
int more_to_do = 0;
@ -379,7 +380,7 @@ static int do_block_io_op(blkif_t *blkif)
}
static void dispatch_rw_block_io(blkif_t *blkif,
blkif_request_t *req,
struct blkif_request *req,
pending_req_t *pending_req)
{
extern void ll_rw_block(int rw, int nr, struct buffer_head * bhs[]);
@ -560,9 +561,9 @@ static void dispatch_rw_block_io(blkif_t *blkif,
static void make_response(blkif_t *blkif, u64 id,
unsigned short op, int st)
{
blkif_response_t resp;
struct blkif_response resp;
unsigned long flags;
blkif_back_rings_t *blk_rings = &blkif->blk_rings;
union blkif_back_rings *blk_rings = &blkif->blk_rings;
int more_to_do = 0;
int notify;
@ -614,7 +615,8 @@ static int __init blkif_init(void)
{
int i, mmap_pages;
if (!is_running_on_xen())
printk(KERN_CRIT "***blkif_init\n");
if (!xen_pv_domain())
return -ENODEV;
mmap_pages = blkif_reqs * BLKIF_MAX_SEGMENTS_PER_REQUEST;

9
drivers/xen/blkback/common.h
View File

@ -40,8 +40,7 @@
#include <xen/evtchn.h>
#include <asm/hypervisor.h>
#include <xen/blkif.h>
#include <xen/gnttab.h>
#include <xen/driver_util.h>
#include <xen/grant_table.h>
#include <xen/xenbus.h>
#define DPRINTK(_f, _a...) \
@ -66,7 +65,7 @@ typedef struct blkif_st {
unsigned int irq;
/* Comms information. */
enum blkif_protocol blk_protocol;
blkif_back_rings_t blk_rings;
union blkif_back_rings blk_rings;
struct vm_struct *blk_ring_area;
/* The VBD attached to this interface. */
struct vbd vbd;
@ -79,7 +78,7 @@ typedef struct blkif_st {
wait_queue_head_t wq;
struct task_struct *xenblkd;
unsigned int waiting_reqs;
request_queue_t *plug;
struct request_queue *plug;
/* statistics */
unsigned long st_print;
@ -130,7 +129,7 @@ void blkif_interface_init(void);
void blkif_xenbus_init(void);
irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs);
irqreturn_t blkif_be_int(int irq, void *dev_id);
int blkif_schedule(void *arg);
int blkback_barrier(struct xenbus_transaction xbt,

19
drivers/xen/blkback/interface.c
View File

@ -31,10 +31,11 @@
*/
#include "common.h"
#include <xen/evtchn.h>
#include <xen/events.h>
#include <xen/grant_table.h>
#include <linux/kthread.h>
static kmem_cache_t *blkif_cachep;
static struct kmem_cache *blkif_cachep;
blkif_t *blkif_alloc(domid_t domid)
{
@ -107,22 +108,22 @@ int blkif_map(blkif_t *blkif, unsigned long shared_page, unsigned int evtchn)
switch (blkif->blk_protocol) {
case BLKIF_PROTOCOL_NATIVE:
{
blkif_sring_t *sring;
sring = (blkif_sring_t *)blkif->blk_ring_area->addr;
struct blkif_sring *sring;
sring = (struct blkif_sring *)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;
struct blkif_x86_32_sring *sring_x86_32;
sring_x86_32 = (struct blkif_x86_32_sring *)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;
struct blkif_x86_64_sring *sring_x86_64;
sring_x86_64 = (struct blkif_x86_64_sring *)blkif->blk_ring_area->addr;
BACK_RING_INIT(&blkif->blk_rings.x86_64, sring_x86_64, PAGE_SIZE);
break;
}
@ -177,5 +178,5 @@ void blkif_free(blkif_t *blkif)
void __init blkif_interface_init(void)
{
blkif_cachep = kmem_cache_create("blkif_cache", sizeof(blkif_t),
0, 0, NULL, NULL);
0, 0, NULL);
}

4
drivers/xen/blkback/vbd.c
View File

@ -33,7 +33,7 @@
#include "common.h"
#define vbd_sz(_v) ((_v)->bdev->bd_part ? \
(_v)->bdev->bd_part->nr_sects : (_v)->bdev->bd_disk->capacity)
(_v)->bdev->bd_part->nr_sects : get_capacity((_v)->bdev->bd_disk))
unsigned long long vbd_size(struct vbd *vbd)
{
@ -94,7 +94,7 @@ int vbd_create(blkif_t *blkif, blkif_vdev_t handle, unsigned major,
void vbd_free(struct vbd *vbd)
{
if (vbd->bdev)
blkdev_put(vbd->bdev);
blkdev_put(vbd->bdev, vbd->readonly ? FMODE_READ : FMODE_WRITE);
vbd->bdev = NULL;
}

7
drivers/xen/blkback/xenbus.c
View File

@ -238,8 +238,8 @@ static int blkback_probe(struct xenbus_device *dev,
/* setup back pointer */
be->blkif->be = be;
err = xenbus_watch_path2(dev, dev->nodename, "physical-device",
&be->backend_watch, backend_changed);
err = xenbus_watch_pathfmt(dev, &be->backend_watch, backend_changed,
"%s/%s", dev->nodename, "physical-device");
if (err)
goto fail;
@ -537,5 +537,6 @@ static struct xenbus_driver blkback = {
void blkif_xenbus_init(void)
{
xenbus_register_backend(&blkback);
/* XXX must_check */
(void)xenbus_register_backend(&blkback);
}

13
include/xen/blkif.h
View File

@ -77,12 +77,11 @@ DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request, struct blkif_x86_32
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;
struct blkif_back_ring native;
struct blkif_common_back_ring common;
struct blkif_x86_32_back_ring x86_32;
struct blkif_x86_64_back_ring x86_64;
};
typedef union blkif_back_rings blkif_back_rings_t;
enum blkif_protocol {
BLKIF_PROTOCOL_NATIVE = 1,
@ -90,7 +89,7 @@ enum blkif_protocol {
BLKIF_PROTOCOL_X86_64 = 3,
};
static void inline blkif_get_x86_32_req(blkif_request_t *dst, blkif_x86_32_request_t *src)
static void inline blkif_get_x86_32_req(struct blkif_request *dst, struct blkif_x86_32_request *src)
{
int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
dst->operation = src->operation;
@ -105,7 +104,7 @@ static void inline blkif_get_x86_32_req(blkif_request_t *dst, blkif_x86_32_reque
dst->seg[i] = src->seg[i];
}
static void inline blkif_get_x86_64_req(blkif_request_t *dst, blkif_x86_64_request_t *src)
static void inline blkif_get_x86_64_req(struct blkif_request *dst, struct blkif_x86_64_request *src)
{
int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST;
dst->operation = src->operation;