[Xen-ia64-devel] Re: [Xen-devel] [patch] CFQ for xen domains

["Magenheimer, Dan (HP Labs Fort Collins)" <dan.magenheimer@xxxxxx>]

Thought I should point out this proposed blkback patch
as it is fairly extensive and may cause problems for
Xen/ia64 multiple domains.  Perhaps Kevin or Matt can
look it over before it gets applied?  On quick glance I see that
the removal of xen_init() is probably a mistake.

http://lists.xensource.com/archives/html/xen-devel/2005-11/msg00371.html

====

> Does 'xm save / xm restore' work with this patch (at least as well as
it 
> currently does ;-)? 

xm save/restore still doesn't work for me, neither with the sparse tree 
nor with the linux-2.6 repository, so I can't try.  I can't see any 
reason why it should become worse with that patch though. 

I've resynced the blkback threading patch with the latest sparse tree, 
here we are.  Changes: 

   * One thread per blkif.  The I/O scheduler can do a better job that 
     way, also you can use ionice on the blkback threads to adjust the 
     block I/O priorities for the domain. 
   * Various stuff has been moved from global variables into blkif_t. 
   * The scary allocation ring for pending_req's is gone and has been 
     replaced by a free list. 
   * made dispatch_rw_block_io() reentrant. 
   * general linux coding style cleanup, at least for the code I've 
     touched anyway. 
   * number of outstanding requests is runtime-configurable now. 
   * made the ia64 #ifdefs smaller and dropped one.  It should still 
     work on ia64 in theory, but would be great if the ia64 folks 
     can have a look ... 

cheers, 

   Gerd 

diff -r abbe3df33774 linux-2.6-xen-sparse/drivers/xen/blkback/blkback.c 
--- a/linux-2.6-xen-sparse/drivers/xen/blkback/blkback.c Tue Nov  8
17:39:58 2005 
+++ b/linux-2.6-xen-sparse/drivers/xen/blkback/blkback.c Wed Nov  9
13:45:37 2005 
@@ -12,6 +12,8 @@ 
  */ 
  
 #include <linux/spinlock.h> 
+#include <linux/kthread.h> 
+#include <linux/list.h> 
 #include <asm-xen/balloon.h> 
 #include <asm/hypervisor.h> 
 #include "common.h" 
@@ -21,26 +23,21 @@ 
  * pulled from a communication ring are quite likely to end up being
part of 
  * the same scatter/gather request at the disc. 
  * 
- * ** TRY INCREASING 'MAX_PENDING_REQS' IF WRITE SPEEDS SEEM TOO LOW **

+ * ** 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. 
  */ 
-#define MAX_PENDING_REQS 64 
-#define BATCH_PER_DOMAIN 16 
- 
-static unsigned long mmap_vstart; 
-#define MMAP_PAGES \ 
- (MAX_PENDING_REQS * BLKIF_MAX_SEGMENTS_PER_REQUEST) 
-#ifdef __ia64__ 
-static void *pending_vaddrs[MMAP_PAGES]; 
-#define MMAP_VADDR(_idx, _i) \ 
- (unsigned long)(pending_vaddrs[((_idx) *
BLKIF_MAX_SEGMENTS_PER_REQUEST) + (_i)]) 
-#else 
-#define MMAP_VADDR(_req,_seg) \ 
- (mmap_vstart + \ 
- ((_req) * BLKIF_MAX_SEGMENTS_PER_REQUEST * PAGE_SIZE) + \ 
- ((_seg) * PAGE_SIZE)) 
-#endif 
+static int blkif_reqs = 64; 
+static int mmap_pages; 
+ 
+static int __init set_blkif_reqs(char *str) 
+{ 
+ get_option(&str, &blkif_reqs); 
+ return 1; 
+} 
+__setup("blkif_reqs=", set_blkif_reqs); 
+ 
  
 /* 
  * Each outstanding request that we've passed to the lower device
layers has a 
@@ -55,43 +52,38 @@ 
         atomic_t       pendcnt; 
         unsigned short operation; 
         int            status; 
+ struct list_head free_list; 
 } pending_req_t; 
  
-/* 
- * We can't allocate pending_req's in order, since they may complete
out of 
- * order. We therefore maintain an allocation ring. This ring also
indicates 
- * when enough work has been passed down -- at that point the
allocation ring 
- * will be empty. 
- */ 
-static pending_req_t pending_reqs[MAX_PENDING_REQS]; 
-static unsigned char pending_ring[MAX_PENDING_REQS]; 
-static spinlock_t pend_prod_lock = SPIN_LOCK_UNLOCKED; 
-/* NB. We use a different index type to differentiate from shared blk
rings. */ 
-typedef unsigned int PEND_RING_IDX; 
-#define MASK_PEND_IDX(_i) ((_i)&(MAX_PENDING_REQS-1)) 
-static PEND_RING_IDX pending_prod, pending_cons; 
-#define NR_PENDING_REQS (MAX_PENDING_REQS - pending_prod +
pending_cons) 
- 
-static request_queue_t *plugged_queue; 
-static inline void flush_plugged_queue(void) 
-{ 
- request_queue_t *q = plugged_queue; 
- if (q != NULL) { 
- if ( q->unplug_fn != NULL ) 
- q->unplug_fn(q); 
- blk_put_queue(q); 
- plugged_queue = NULL; 
- } 
-} 
+static pending_req_t *pending_reqs; 
+static struct list_head pending_free; 
+static spinlock_t pending_free_lock = SPIN_LOCK_UNLOCKED; 
+static DECLARE_WAIT_QUEUE_HEAD(pending_free_wq); 
+ 
+#define BLKBACK_INVALID_HANDLE (0xFFFF) 
+ 
+static unsigned long mmap_vstart; 
+static unsigned long *pending_vaddrs; 
+static u16 *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) 
+{ 
+ return pending_vaddrs[vaddr_pagenr(req, seg)]; 
+} 
+ 
+#define pending_handle(_req, _seg) \ 
+ (pending_grant_handles[vaddr_pagenr(_req, _seg)]) 
+ 
  
 /* When using grant tables to map a frame for device access then the 
  * handle returned must be used to unmap the frame. This is needed to 
  * drop the ref count on the frame. 
  */ 
-static u16 pending_grant_handles[MMAP_PAGES]; 
-#define pending_handle(_idx, _i) \ 
-    (pending_grant_handles[((_idx) * BLKIF_MAX_SEGMENTS_PER_REQUEST) +
(_i)]) 
-#define BLKBACK_INVALID_HANDLE (0xFFFF) 
  
 #ifdef CONFIG_XEN_BLKDEV_TAP_BE 
 /* 
@@ -105,26 +97,79 @@ 
 static inline domid_t ID_TO_DOM(unsigned long id) { return (id >> 16);
} 
 #endif 
  
-static int do_block_io_op(blkif_t *blkif, int max_to_do); 
-static void dispatch_rw_block_io(blkif_t *blkif, blkif_request_t *req);

+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, unsigned long id, 
                           unsigned short op, int st); 
  
-static void fast_flush_area(int idx, int nr_pages) 
+/****************************************************************** 
+ * 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 (NULL == blkif->plug) 
+ 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 bio *bio) 
+{ 
+ request_queue_t *q = bdev_get_queue(bio->bi_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; 
         u16 handle; 
         int ret; 
  
- for (i = 0; i < nr_pages; i++) { 
- handle = pending_handle(idx, i); 
+ for (i = 0; i < req->nr_pages; i++) { 
+ handle = pending_handle(req, i); 
                 if (handle == BLKBACK_INVALID_HANDLE) 
                         continue; 
- unmap[invcount].host_addr    = MMAP_VADDR(idx, i); 
+ unmap[invcount].host_addr    = vaddr(req, i); 
                 unmap[invcount].dev_bus_addr = 0; 
                 unmap[invcount].handle       = handle; 
- pending_handle(idx, i) = BLKBACK_INVALID_HANDLE; 
+ pending_handle(req, i) = BLKBACK_INVALID_HANDLE; 
                 invcount++; 
         } 
  
@@ -133,109 +178,56 @@ 
         BUG_ON(ret); 
 } 
  
- 
-/****************************************************************** 
- * BLOCK-DEVICE SCHEDULER LIST MAINTENANCE 
- */ 
- 
-static struct list_head blkio_schedule_list; 
-static spinlock_t blkio_schedule_list_lock; 
- 
-static int __on_blkdev_list(blkif_t *blkif) 
-{ 
- return blkif->blkdev_list.next != NULL; 
-} 
- 
-static void remove_from_blkdev_list(blkif_t *blkif) 
-{ 
- unsigned long flags; 
- 
- if (!__on_blkdev_list(blkif)) 
- return; 
- 
- spin_lock_irqsave(&blkio_schedule_list_lock, flags); 
- if (__on_blkdev_list(blkif)) { 
- list_del(&blkif->blkdev_list); 
- blkif->blkdev_list.next = NULL; 
- blkif_put(blkif); 
- } 
- spin_unlock_irqrestore(&blkio_schedule_list_lock, flags); 
-} 
- 
-static void add_to_blkdev_list_tail(blkif_t *blkif) 
-{ 
- unsigned long flags; 
- 
- if (__on_blkdev_list(blkif)) 
- return; 
- 
- spin_lock_irqsave(&blkio_schedule_list_lock, flags); 
- if (!__on_blkdev_list(blkif) && (blkif->status == CONNECTED)) { 
- list_add_tail(&blkif->blkdev_list, &blkio_schedule_list); 
- blkif_get(blkif); 
- } 
- spin_unlock_irqrestore(&blkio_schedule_list_lock, flags); 
-} 
- 
- 
 /****************************************************************** 
  * SCHEDULER FUNCTIONS 
  */ 
  
-static DECLARE_WAIT_QUEUE_HEAD(blkio_schedule_wait); 
- 
-static int blkio_schedule(void *arg) 
-{ 
- DECLARE_WAITQUEUE(wq, current); 
- 
- blkif_t          *blkif; 
- struct list_head *ent; 
- 
- daemonize("xenblkd"); 
- 
+int blkif_schedule(void *arg) 
+{ 
+ blkif_t          *blkif = arg; 
+ 
+ blkif_get(blkif); 
+ printk(KERN_DEBUG "%s: started\n", current->comm); 
         for (;;) { 
- /* Wait for work to do. */ 
- add_wait_queue(&blkio_schedule_wait, &wq); 
- set_current_state(TASK_INTERRUPTIBLE); 
- if ( (NR_PENDING_REQS == MAX_PENDING_REQS) || 
-     list_empty(&blkio_schedule_list) ) 
- schedule(); 
- __set_current_state(TASK_RUNNING); 
- remove_wait_queue(&blkio_schedule_wait, &wq); 
- 
- /* Queue up a batch of requests. */ 
- while ((NR_PENDING_REQS < MAX_PENDING_REQS) && 
-       !list_empty(&blkio_schedule_list)) { 
- ent = blkio_schedule_list.next; 
- blkif = list_entry(ent, blkif_t, blkdev_list); 
- blkif_get(blkif); 
- remove_from_blkdev_list(blkif); 
- if (do_block_io_op(blkif, BATCH_PER_DOMAIN)) 
- add_to_blkdev_list_tail(blkif); 
- blkif_put(blkif); 
- } 
- 
- /* Push the batch through to disc. */ 
- flush_plugged_queue(); 
- } 
-} 
- 
-static void maybe_trigger_blkio_schedule(void) 
-{ 
- /* 
- * Needed so that two processes, which together make the following 
- * predicate true, don't both read stale values and evaluate the 
- * predicate incorrectly. Incredibly unlikely to stall the scheduler 
- * on x86, but... 
- */ 
- smp_mb(); 
- 
- if ((NR_PENDING_REQS < (MAX_PENDING_REQS/2)) && 
-    !list_empty(&blkio_schedule_list)) 
- wake_up(&blkio_schedule_wait); 
-} 
- 
- 
+ if (!atomic_read(&blkif->io_pending)) { 
+ /* Wait for work to do or requests to exit. */ 
+ if (kthread_should_stop()) 
+ break; 
+ wait_event_interruptible(blkif->wq, 
+ atomic_read(&blkif->io_pending) || 
+ kthread_should_stop()); 
+ } else if (list_empty(&pending_free)) { 
+ /* Wait for pending_req becoming available. */ 
+ wait_event_interruptible(pending_free_wq, 
+ !list_empty(&pending_free)); 
+ } 
+ 
+ /* Schedule I/O */ 
+ atomic_set(&blkif->io_pending, 0); 
+ if (do_block_io_op(blkif)) 
+ atomic_inc(&blkif->io_pending); 
+ unplug_queue(blkif); 
+ 
+#if 0 
+ /* Print stats for performance debugging. */ 
+ if (time_after(jiffies, blkif->st_print)) { 
+ printk(KERN_DEBUG "%s: oo %3d  |  rd %4d  |  wr %4d\n", 
+       current->comm, blkif->st_oo_req, 
+       blkif->st_rd_req, blkif->st_wr_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; 
+ } 
+#endif 
+ } 
+ 
+ /* bye folks, and thanks for all the fish ;) */ 
+ printk(KERN_DEBUG "%s: exiting\n", current->comm); 
+ blkif->xenblkd = NULL; 
+ blkif_put(blkif); 
+ return 0; 
+} 
  
 /****************************************************************** 
  * COMPLETION CALLBACK -- Called as bh->b_end_io() 
@@ -243,8 +235,6 @@ 
  
 static void __end_block_io_op(pending_req_t *pending_req, int uptodate)

 { 
- unsigned long flags; 
- 
         /* An error fails the entire request. */ 
         if (!uptodate) { 
                 DPRINTK("Buffer not up-to-date at end of operation\n");

@@ -252,15 +242,11 @@ 
         } 
  
         if (atomic_dec_and_test(&pending_req->pendcnt)) { 
- int pending_idx = pending_req - pending_reqs; 
- fast_flush_area(pending_idx, pending_req->nr_pages); 
+ fast_flush_area(pending_req); 
                 make_response(pending_req->blkif, pending_req->id, 
                               pending_req->operation,
pending_req->status); 
                 blkif_put(pending_req->blkif); 
- spin_lock_irqsave(&pend_prod_lock, flags); 
- pending_ring[MASK_PEND_IDX(pending_prod++)] = pending_idx; 
- spin_unlock_irqrestore(&pend_prod_lock, flags); 
- maybe_trigger_blkio_schedule(); 
+ free_req(pending_req); 
         } 
 } 
  
@@ -281,8 +267,10 @@ 
 irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs) 
 { 
         blkif_t *blkif = dev_id; 
- add_to_blkdev_list_tail(blkif); 
- maybe_trigger_blkio_schedule(); 
+ 
+ atomic_inc(&blkif->io_pending); 
+ if (blkif->status == CONNECTED) 
+ wake_up(&blkif->wq); 
         return IRQ_HANDLED; 
 } 
  
@@ -292,10 +280,11 @@ 
  * DOWNWARD CALLS -- These interface with the block-device layer
proper. 
  */ 
  
-static int do_block_io_op(blkif_t *blkif, int max_to_do) 
+static int do_block_io_op(blkif_t *blkif) 
 { 
         blkif_back_ring_t *blk_ring = &blkif->blk_ring; 
         blkif_request_t *req; 
+ pending_req_t *pending_req; 
         RING_IDX i, rp; 
         int more_to_do = 0; 
  
@@ -305,24 +294,30 @@ 
         for (i = blk_ring->req_cons; 
              (i != rp) && !RING_REQUEST_CONS_OVERFLOW(blk_ring, i); 
              i++) { 
- if ((max_to_do-- == 0) || 
-    (NR_PENDING_REQS == MAX_PENDING_REQS)) { 
+ 
+ pending_req = alloc_req(); 
+ if (NULL == pending_req) { 
+ blkif->st_oo_req++; 
                         more_to_do = 1; 
                         break; 
                 } 
-         
+ 
                 req = RING_GET_REQUEST(blk_ring, i); 
                 switch (req->operation) { 
                 case BLKIF_OP_READ: 
+ blkif->st_rd_req++; 
+ dispatch_rw_block_io(blkif, req, pending_req); 
+ break; 
                 case BLKIF_OP_WRITE: 
- dispatch_rw_block_io(blkif, req); 
+ blkif->st_wr_req++; 
+ dispatch_rw_block_io(blkif, req, pending_req); 
                         break; 
- 
                 default: 
                         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; 
                 } 
         } 
@@ -331,13 +326,13 @@ 
         return more_to_do; 
 } 
  
-static void dispatch_rw_block_io(blkif_t *blkif, blkif_request_t *req) 
+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[]); 
         int operation = (req->operation == BLKIF_OP_WRITE) ? WRITE :
READ; 
         unsigned long fas = 0; 
- int i, pending_idx = pending_ring[MASK_PEND_IDX(pending_cons)]; 
- pending_req_t *pending_req; 
         struct gnttab_map_grant_ref
map[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 
         struct phys_req preq; 
         struct { 
@@ -345,31 +340,35 @@ 
         } seg[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 
         unsigned int nseg; 
         struct bio *bio = NULL,
*biolist[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 
- int nbio = 0; 
- request_queue_t *q; 
- int ret, errors = 0; 
+ int ret, i, nbio = 0; 
  
         /* Check that number of segments is sane. */ 
         nseg = req->nr_segments; 
         if (unlikely(nseg == 0) || 
             unlikely(nseg > BLKIF_MAX_SEGMENTS_PER_REQUEST)) { 
                 DPRINTK("Bad number of segments in request (%d)\n",
nseg); 
- goto bad_descriptor; 
+ 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 = operation; 
+ pending_req->status    = BLKIF_RSP_OKAY; 
+ pending_req->nr_pages  = nseg; 
+ 
         for (i = 0; i < nseg; i++) { 
                 fas         = req->frame_and_sects[i]; 
                 seg[i].nsec = blkif_last_sect(fas) -
blkif_first_sect(fas) + 1; 
  
                 if (seg[i].nsec <= 0) 
- goto bad_descriptor; 
+ goto fail_response; 
                 preq.nr_sects += seg[i].nsec; 
  
- map[i].host_addr = MMAP_VADDR(pending_idx, i); 
+ map[i].host_addr = vaddr(pending_req, i); 
                 map[i].dom = blkif->domid; 
                 map[i].ref = blkif_gref_from_fas(fas); 
                 map[i].flags = GNTMAP_host_map; 
@@ -381,27 +380,23 @@ 
         BUG_ON(ret); 
  
         for (i = 0; i < nseg; i++) { 
- if (likely(map[i].handle >= 0)) { 
- pending_handle(pending_idx, i) = map[i].handle; 
+ if (unlikely(map[i].handle < 0)) { 
+ DPRINTK("invalid buffer -- could not remap it\n"); 
+ goto fail_flush; 
+ } 
+ 
+ pending_handle(pending_req, i) = map[i].handle; 
 #ifdef __ia64__ 
- MMAP_VADDR(pending_idx,i) = gnttab_map_vaddr(map[i]); 
+ pending_vaddrs[vaddr_pagenr(req, seg)] = 
+ = gnttab_map_vaddr(map[i]); 
 #else 
- phys_to_machine_mapping[__pa(MMAP_VADDR( 
- pending_idx, i)) >> PAGE_SHIFT] = 
- FOREIGN_FRAME(map[i].dev_bus_addr>>PAGE_SHIFT); 
+ phys_to_machine_mapping[__pa(vaddr( 
+ pending_req, i)) >> PAGE_SHIFT] = 
+ FOREIGN_FRAME(map[i].dev_bus_addr >> PAGE_SHIFT); 
 #endif 
- fas        = req->frame_and_sects[i]; 
- seg[i].buf = map[i].dev_bus_addr | 
- (blkif_first_sect(fas) << 9); 
- } else { 
- errors++; 
- } 
- } 
- 
- if (errors) { 
- DPRINTK("invalid buffer -- could not remap it\n"); 
- fast_flush_area(pending_idx, nseg); 
- goto bad_descriptor; 
+ fas         = req->frame_and_sects[i]; 
+ seg[i].buf  = map[i].dev_bus_addr | 
+ (blkif_first_sect(fas) << 9); 
         } 
  
         if (vbd_translate(&preq, blkif, operation) != 0) { 
@@ -409,37 +404,25 @@ 
                         operation == READ ? "read" : "write", 
                         preq.sector_number, 
                         preq.sector_number + preq.nr_sects, preq.dev); 
- goto bad_descriptor; 
- } 
- 
- pending_req = &pending_reqs[pending_idx]; 
- pending_req->blkif     = blkif; 
- pending_req->id        = req->id; 
- pending_req->operation = operation; 
- pending_req->status    = BLKIF_RSP_OKAY; 
- pending_req->nr_pages  = nseg; 
+ goto fail_flush; 
+ } 
  
         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 cleanup_and_fail; 
+ goto fail_put_bio; 
                 } 
  
                 while ((bio == NULL) || 
                        (bio_add_page(bio, 
-     virt_to_page(MMAP_VADDR(pending_idx, i)), 
+     virt_to_page(vaddr(pending_req, i)), 
                                      seg[i].nsec << 9, 
                                      seg[i].buf & ~PAGE_MASK) == 0)) { 
                         bio = biolist[nbio++] = bio_alloc(GFP_KERNEL,
nseg-i); 
- if (unlikely(bio == NULL)) { 
- cleanup_and_fail: 
- for (i = 0; i < (nbio-1); i++) 
- bio_put(biolist[i]); 
- fast_flush_area(pending_idx, nseg); 
- goto bad_descriptor; 
- } 
+ if (unlikely(bio == NULL)) 
+ goto fail_put_bio; 
                  
                         bio->bi_bdev    = preq.bdev; 
                         bio->bi_private = pending_req; 
@@ -450,14 +433,8 @@ 
                 preq.sector_number += seg[i].nsec; 
         } 
  
- if ((q = bdev_get_queue(bio->bi_bdev)) != plugged_queue) { 
- flush_plugged_queue(); 
- blk_get_queue(q); 
- plugged_queue = q; 
- } 
- 
+ plug_queue(blkif, bio); 
         atomic_set(&pending_req->pendcnt, nbio); 
- pending_cons++; 
         blkif_get(blkif); 
  
         for (i = 0; i < nbio; i++) 
@@ -465,8 +442,14 @@ 
  
         return; 
  
- bad_descriptor: 
+ fail_put_bio: 
+ for (i = 0; i < (nbio-1); i++) 
+ bio_put(biolist[i]); 
+ fail_flush: 
+ fast_flush_area(pending_req); 
+ fail_response: 
         make_response(blkif, req->id, req->operation, BLKIF_RSP_ERROR);

+ free_req(pending_req); 
 } 
  
  
@@ -498,56 +481,47 @@ 
         notify_remote_via_irq(blkif->irq); 
 } 
  
-void blkif_deschedule(blkif_t *blkif) 
-{ 
- remove_from_blkdev_list(blkif); 
-} 
- 
 static int __init blkif_init(void) 
 { 
+ struct page *page; 
         int i; 
- struct page *page; 
- int ret; 
- 
- for (i = 0; i < MMAP_PAGES; i++) 
- pending_grant_handles[i] = BLKBACK_INVALID_HANDLE; 
- 
- if (xen_init() < 0) 
- 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_vaddrs        = kmalloc(sizeof(pending_vaddrs[0]) * 
+ mmap_pages, GFP_KERNEL); 
+ if (!pending_reqs || !pending_grant_handles || !pending_vaddrs) { 
+ printk("%s: out of memory\n", __FUNCTION__); 
+ return -1; 
+ } 
  
         blkif_interface_init(); 
- 
+ 
 #ifdef __ia64__ 
-    { 
         extern unsigned long
alloc_empty_foreign_map_page_range(unsigned long pages); 
- int i; 
- 
- mmap_vstart =  alloc_empty_foreign_map_page_range(MMAP_PAGES); 
- printk("Allocated mmap_vstart: 0x%lx\n", mmap_vstart); 
- for(i = 0; i < MMAP_PAGES; i++) 
-    pending_vaddrs[i] = mmap_vstart + (i << PAGE_SHIFT); 
- BUG_ON(mmap_vstart == NULL); 
-    } 
-#else 
- page = balloon_alloc_empty_page_range(MMAP_PAGES); 
+ mmap_vstart = (unsigned
long)alloc_empty_foreign_map_page_range(mmap_pages); 
+#else /* ! ia64 */ 
+ page = balloon_alloc_empty_page_range(mmap_pages); 
         BUG_ON(page == NULL); 
         mmap_vstart = (unsigned long)pfn_to_kaddr(page_to_pfn(page)); 
 #endif 
- 
- pending_cons = 0; 
- pending_prod = MAX_PENDING_REQS; 
+ printk("%s: reqs=%d, pages=%d, mmap_vstart=0x%lx\n", 
+       __FUNCTION__, blkif_reqs, mmap_pages, mmap_vstart); 
+ BUG_ON(mmap_vstart == 0); 
+ for (i = 0; i < mmap_pages; i++) 
+ pending_vaddrs[i] = mmap_vstart + (i << PAGE_SHIFT); 
+ 
+ memset(pending_grant_handles,  BLKBACK_INVALID_HANDLE, mmap_pages); 
         memset(pending_reqs, 0, sizeof(pending_reqs)); 
- for (i = 0; i < MAX_PENDING_REQS; i++) 
- pending_ring[i] = i; 
+ INIT_LIST_HEAD(&pending_free); 
+ 
+ for (i = 0; i < blkif_reqs; i++) 
+ list_add_tail(&pending_reqs[i].free_list, &pending_free); 
      
- spin_lock_init(&blkio_schedule_list_lock); 
- INIT_LIST_HEAD(&blkio_schedule_list); 
- 
- ret = kernel_thread(blkio_schedule, 0, CLONE_FS | CLONE_FILES); 
- BUG_ON(ret < 0); 
- 
         blkif_xenbus_init(); 
- 
         return 0; 
 } 
  
diff -r abbe3df33774 linux-2.6-xen-sparse/drivers/xen/blkback/common.h 
--- a/linux-2.6-xen-sparse/drivers/xen/blkback/common.h Tue Nov  8
17:39:58 2005 
+++ b/linux-2.6-xen-sparse/drivers/xen/blkback/common.h Wed Nov  9
13:45:37 2005 
@@ -56,9 +56,19 @@ 
         /* Is this a blktap frontend */ 
         unsigned int     is_blktap; 
 #endif 
- struct list_head blkdev_list; 
         spinlock_t       blk_ring_lock; 
         atomic_t         refcnt; 
+ 
+ wait_queue_head_t   wq; 
+ struct task_struct  *xenblkd; 
+ atomic_t            io_pending; 
+ request_queue_t     *plug; 
+ 
+ /* statistics */ 
+ unsigned long       st_print; 
+ int                 st_rd_req; 
+ int                 st_wr_req; 
+ int                 st_oo_req; 
  
         struct work_struct free_work; 
  
@@ -97,11 +107,10 @@ 
  
 void blkif_interface_init(void); 
  
-void blkif_deschedule(blkif_t *blkif); 
- 
 void blkif_xenbus_init(void); 
  
 irqreturn_t blkif_be_int(int irq, void *dev_id, struct pt_regs *regs); 
+int blkif_schedule(void *arg); 
  
 #endif /* __BLKIF__BACKEND__COMMON_H__ */ 
  
diff -r abbe3df33774
linux-2.6-xen-sparse/drivers/xen/blkback/interface.c 
--- a/linux-2.6-xen-sparse/drivers/xen/blkback/interface.c Tue Nov  8
17:39:58 2005 
+++ b/linux-2.6-xen-sparse/drivers/xen/blkback/interface.c Wed Nov  9
13:45:37 2005 
@@ -24,6 +24,8 @@ 
         blkif->status = DISCONNECTED; 
         spin_lock_init(&blkif->blk_ring_lock); 
         atomic_set(&blkif->refcnt, 1); 
+ init_waitqueue_head(&blkif->wq); 
+ blkif->st_print = jiffies; 
  
         return blkif; 
 } 
diff -r abbe3df33774 linux-2.6-xen-sparse/drivers/xen/blkback/xenbus.c 
--- a/linux-2.6-xen-sparse/drivers/xen/blkback/xenbus.c Tue Nov  8
17:39:58 2005 
+++ b/linux-2.6-xen-sparse/drivers/xen/blkback/xenbus.c Wed Nov  9
13:45:37 2005 
@@ -17,6 +17,7 @@ 
 */ 
 #include <stdarg.h> 
 #include <linux/module.h> 
+#include <linux/kthread.h> 
 #include <asm-xen/xenbus.h> 
 #include "common.h" 
  
@@ -46,8 +47,11 @@ 
         if (be->watch.node) 
                 unregister_xenbus_watch(&be->watch); 
         unregister_xenbus_watch(&be->backend_watch); 
- if (be->blkif) 
+ if (be->blkif) { 
+ if (be->blkif->xenblkd) 
+ kthread_stop(be->blkif->xenblkd); 
                 blkif_put(be->blkif); 
+ } 
         if (be->frontpath) 
                 kfree(be->frontpath); 
         kfree(be); 
@@ -198,6 +202,16 @@ 
                         be->blkif = NULL; 
                         xenbus_dev_error(dev, err, 
                                          "creating vbd structure"); 
+ return; 
+ } 
+ 
+ be->blkif->xenblkd = kthread_run(blkif_schedule, be->blkif, 
+ "xenblkd %d/%04lx", 
+ be->blkif->domid, be->pdev); 
+ if (IS_ERR(be->blkif->xenblkd)) { 
+ err = PTR_ERR(be->blkif->xenblkd); 
+ be->blkif->xenblkd = NULL; 
+ xenbus_dev_error(dev, err, "start xenblkd"); 
                         return; 
                 } 
  
_______________________________________________ 
Xen-devel mailing list 
Xen-devel@... 
http://lists.xensource.com/xen-devel 

_______________________________________________
Xen-ia64-devel mailing list
Xen-ia64-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-ia64-devel