Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e8e28871 authored by Konrad Rzeszutek Wilk's avatar Konrad Rzeszutek Wilk
Browse files

xen/blkback: Move global/static variables into struct xen_blkbk.



Bundle the lot of discrete variables into a single structure.
This is based on what was done in the xen-netback driver:
xen: netback: Move global/static variables into struct xen_netbk.
(094944631cc5a9d6e623302c987f78117c0bf7ac)

Signed-off-by: default avatarKonrad Rzeszutek Wilk <konrad.wilk@oracle.com>
parent efe08a3e
Loading
Loading
Loading
Loading
+48 −34
Original line number Diff line number Diff line
@@ -84,31 +84,34 @@ typedef struct {
	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;
struct xen_blkbk {
	pending_req_t	*pending_reqs;
	struct list_head	pending_free;
	spinlock_t		pending_free_lock;
	wait_queue_head_t	pending_free_wq;
	struct page		**pending_pages;
	grant_handle_t		*pending_grant_handles;
};

static struct xen_blkbk *blkbk;

static inline int vaddr_pagenr(pending_req_t *req, int seg)
{
	return (req - pending_reqs) * BLKIF_MAX_SEGMENTS_PER_REQUEST + seg;
	return (req - blkbk->pending_reqs) * BLKIF_MAX_SEGMENTS_PER_REQUEST + seg;
}

#define pending_page(req, seg) pending_pages[vaddr_pagenr(req, seg)]

static inline unsigned long vaddr(pending_req_t *req, int seg)
{
	unsigned long pfn = page_to_pfn(pending_page(req, seg));
	unsigned long pfn = page_to_pfn(blkbk->pending_page(req, seg));
	return (unsigned long)pfn_to_kaddr(pfn);
}

#define pending_handle(_req, _seg) \
	(pending_grant_handles[vaddr_pagenr(_req, _seg)])
	(blkbk->pending_grant_handles[vaddr_pagenr(_req, _seg)])


static int do_block_io_op(blkif_t *blkif);
@@ -126,12 +129,12 @@ 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);
	spin_lock_irqsave(&blkbk->pending_free_lock, flags);
	if (!list_empty(&blkbk->pending_free)) {
		req = list_entry(blkbk->pending_free.next, pending_req_t, free_list);
		list_del(&req->free_list);
	}
	spin_unlock_irqrestore(&pending_free_lock, flags);
	spin_unlock_irqrestore(&blkbk->pending_free_lock, flags);
	return req;
}

@@ -140,12 +143,12 @@ 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);
	spin_lock_irqsave(&blkbk->pending_free_lock, flags);
	was_empty = list_empty(&blkbk->pending_free);
	list_add(&req->free_list, &blkbk->pending_free);
	spin_unlock_irqrestore(&blkbk->pending_free_lock, flags);
	if (was_empty)
		wake_up(&pending_free_wq);
		wake_up(&blkbk->pending_free_wq);
}

static void unplug_queue(blkif_t *blkif)
@@ -226,8 +229,8 @@ int blkif_schedule(void *arg)
			blkif->wq,
			blkif->waiting_reqs || kthread_should_stop());
		wait_event_interruptible(
			pending_free_wq,
			!list_empty(&pending_free) || kthread_should_stop());
			blkbk->pending_free_wq,
			!list_empty(&blkbk->pending_free) || kthread_should_stop());

		blkif->waiting_reqs = 0;
		smp_mb(); /* clear flag *before* checking for work */
@@ -466,7 +469,7 @@ static void dispatch_rw_block_io(blkif_t *blkif,
			continue;

		set_phys_to_machine(
			page_to_pfn(pending_page(pending_req, i)),
			page_to_pfn(blkbk->pending_page(pending_req, i)),
			FOREIGN_FRAME(map[i].dev_bus_addr >> PAGE_SHIFT));
		seg[i].buf  = map[i].dev_bus_addr |
			(req->seg[i].first_sect << 9);
@@ -497,7 +500,7 @@ static void dispatch_rw_block_io(blkif_t *blkif,

		while ((bio == NULL) ||
		       (bio_add_page(bio,
				     pending_page(pending_req, i),
				     blkbk->pending_page(pending_req, i),
				     seg[i].nsec << 9,
				     seg[i].buf & ~PAGE_MASK) == 0)) {
			if (bio) {
@@ -624,31 +627,40 @@ static int __init blkif_init(void)
	if (!xen_pv_domain())
		return -ENODEV;

	blkbk = (struct xen_blkbk *)vmalloc(sizeof(struct xen_blkbk));
	if (!blkbk) {
		printk(KERN_ALERT "%s: out of memory!\n", __func__);
		return -ENOMEM;
	}

	mmap_pages = blkif_reqs * BLKIF_MAX_SEGMENTS_PER_REQUEST;

	pending_reqs          = kmalloc(sizeof(pending_reqs[0]) *
	blkbk->pending_reqs          = kmalloc(sizeof(blkbk->pending_reqs[0]) *
					blkif_reqs, GFP_KERNEL);
	pending_grant_handles = kmalloc(sizeof(pending_grant_handles[0]) *
	blkbk->pending_grant_handles = kmalloc(sizeof(blkbk->pending_grant_handles[0]) *
					mmap_pages, GFP_KERNEL);
	pending_pages         = alloc_empty_pages_and_pagevec(mmap_pages);
	blkbk->pending_pages         = alloc_empty_pages_and_pagevec(mmap_pages);

	if (!pending_reqs || !pending_grant_handles || !pending_pages) {
	if (!blkbk->pending_reqs || !blkbk->pending_grant_handles || !blkbk->pending_pages) {
		rc = -ENOMEM;
		goto out_of_memory;
	}

	for (i = 0; i < mmap_pages; i++)
		pending_grant_handles[i] = BLKBACK_INVALID_HANDLE;
		blkbk->pending_grant_handles[i] = BLKBACK_INVALID_HANDLE;

	rc = blkif_interface_init();
	if (rc)
		goto failed_init;

	memset(pending_reqs, 0, sizeof(pending_reqs));
	INIT_LIST_HEAD(&pending_free);
	memset(blkbk->pending_reqs, 0, sizeof(blkbk->pending_reqs));

	INIT_LIST_HEAD(&blkbk->pending_free);
	spin_lock_init(&blkbk->pending_free_lock);
	init_waitqueue_head(&blkbk->pending_free_wq);

	for (i = 0; i < blkif_reqs; i++)
		list_add_tail(&pending_reqs[i].free_list, &pending_free);
		list_add_tail(&blkbk->pending_reqs[i].free_list, &blkbk->pending_free);

	rc = blkif_xenbus_init();
	if (rc)
@@ -659,9 +671,11 @@ static int __init blkif_init(void)
 out_of_memory:
	printk(KERN_ERR "%s: out of memory\n", __func__);
 failed_init:
	kfree(pending_reqs);
	kfree(pending_grant_handles);
	free_empty_pages_and_pagevec(pending_pages, mmap_pages);
	kfree(blkbk->pending_reqs);
	kfree(blkbk->pending_grant_handles);
	free_empty_pages_and_pagevec(blkbk->pending_pages, mmap_pages);
	vfree(blkbk);
	blkbk = NULL;
	return rc;
}