Revert to Fedora kernel-2.6.17-1.2187_FC5 patched with vs2.0.2.1; there are too many...

[linux-2.6.git] / drivers / xen / blkback / blkback.c

diff --git a/drivers/xen/blkback/blkback.c b/drivers/xen/blkback/blkback.c
index 6c80baf..c5b3eee 100644 (file)
--- a/drivers/xen/blkback/blkback.c
+++ b/drivers/xen/blkback/blkback.c
@@ -40,7 +40,6 @@
 #include <linux/list.h>
 #include <xen/balloon.h>
 #include <asm/hypervisor.h>
-#include <asm/hypercall.h>
 #include "common.h"
 
 /*
@@ -57,6 +56,8 @@ static int blkif_reqs = 64;
 module_param_named(reqs, blkif_reqs, int, 0);
 MODULE_PARM_DESC(reqs, "Number of blkback requests to allocate");
 
+static int mmap_pages;
+
 /* Run-time switchable: /sys/module/blkback/parameters/ */
 static unsigned int log_stats = 0;
 static unsigned int debug_lvl = 0;
@@ -86,7 +87,8 @@ static DECLARE_WAIT_QUEUE_HEAD(pending_free_wq);
 
 #define BLKBACK_INVALID_HANDLE (~0)
 
-static struct page **pending_pages;
+static unsigned long mmap_vstart;
+static unsigned long *pending_vaddrs;
 static grant_handle_t *pending_grant_handles;
 
 static inline int vaddr_pagenr(pending_req_t *req, int seg)
@@ -96,8 +98,7 @@ static inline int vaddr_pagenr(pending_req_t *req, int 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);
+       return pending_vaddrs[vaddr_pagenr(req, seg)];
 }
 
 #define pending_handle(_req, _seg) \
@@ -340,7 +341,7 @@ 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[]);
+       extern void ll_rw_block(int rw, int nr, struct buffer_head * bhs[]); 
        int operation = (req->operation == BLKIF_OP_WRITE) ? WRITE : READ;
        struct gnttab_map_grant_ref map[BLKIF_MAX_SEGMENTS_PER_REQUEST];
        struct phys_req preq;
@@ -408,7 +409,7 @@ static void dispatch_rw_block_io(blkif_t *blkif,
                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);
+                       preq.sector_number + preq.nr_sects, preq.dev); 
                goto fail_flush;
        }
 
@@ -505,43 +506,59 @@ static void make_response(blkif_t *blkif, unsigned long id,
 
 static int __init blkif_init(void)
 {
-       int i, mmap_pages;
+       struct page *page;
+       int i;
 
        if (!is_running_on_xen())
                return -ENODEV;
 
-       mmap_pages = blkif_reqs * BLKIF_MAX_SEGMENTS_PER_REQUEST;
+       mmap_pages            = blkif_reqs * BLKIF_MAX_SEGMENTS_PER_REQUEST;
+
+#ifdef CONFIG_XEN_IA64_DOM0_NON_VP
+       extern unsigned long alloc_empty_foreign_map_page_range(
+               unsigned long pages);
+       mmap_vstart = (unsigned long)
+               alloc_empty_foreign_map_page_range(mmap_pages);
+#else /* ! ia64 */
+       page = balloon_alloc_empty_page_range(mmap_pages);
+       if (page == NULL)
+               return -ENOMEM;
+       mmap_vstart = (unsigned long)pfn_to_kaddr(page_to_pfn(page));
+#endif
 
        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;
+       pending_vaddrs        = kmalloc(sizeof(pending_vaddrs[0]) *
+                                       mmap_pages, GFP_KERNEL);
+       if (!pending_reqs || !pending_grant_handles || !pending_vaddrs) {
+               kfree(pending_reqs);
+               kfree(pending_grant_handles);
+               kfree(pending_vaddrs);
+               printk("%s: out of memory\n", __FUNCTION__);
+               return -ENOMEM;
+       }
 
        blkif_interface_init();
+       
+       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);
+               pending_grant_handles[i] = BLKBACK_INVALID_HANDLE;
+       }
 
        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);