Merge remote-tracking branch 'stefano/swiotlb-xen-9.1' into stable/for-linus-3.13

* stefano/swiotlb-xen-9.1:
  swiotlb-xen: fix error code returned by xen_swiotlb_map_sg_attrs
  swiotlb-xen: static inline xen_phys_to_bus, xen_bus_to_phys, xen_virt_to_bus and range_straddles_page_boundary
  grant-table: call set_phys_to_machine after mapping grant refs
  arm,arm64: do not always merge biovec if we are running on Xen
  swiotlb: print a warning when the swiotlb is full
  swiotlb-xen: use xen_dma_map/unmap_page, xen_dma_sync_single_for_cpu/device
  xen: introduce xen_dma_map/unmap_page and xen_dma_sync_single_for_cpu/device
  swiotlb-xen: use xen_alloc/free_coherent_pages
  xen: introduce xen_alloc/free_coherent_pages
  arm64/xen: get_dma_ops: return xen_dma_ops if we are running as xen_initial_domain
  arm/xen: get_dma_ops: return xen_dma_ops if we are running as xen_initial_domain
  swiotlb-xen: introduce xen_swiotlb_set_dma_mask
  xen/arm,arm64: enable SWIOTLB_XEN
  xen: make xen_create_contiguous_region return the dma address
  xen/x86: allow __set_phys_to_machine for autotranslate guests
  arm/xen,arm64/xen: introduce p2m
  arm64: define DMA_ERROR_CODE
  arm: make SWIOTLB available

Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Conflicts:
	arch/arm/include/asm/dma-mapping.h
	drivers/xen/swiotlb-xen.c

[Conflicts arose b/c "arm: make SWIOTLB available" v8 was in Stefano's
branch, while I had v9 + Ack from Russel. I also fixed up white-space
issues]

diff --cc arch/arm/include/asm/dma-mapping.h
index 1ad2c17,f5945d4..8acfef4
--- 1/arch/arm/include/asm/dma-mapping.h
--- 2/arch/arm/include/asm/dma-mapping.h
+++ b/arch/arm/include/asm/dma-mapping.h
@@@ -10,7 -10,11 +10,10 @@@
  
  #include <asm-generic/dma-coherent.h>
  #include <asm/memory.h>
 -#include <asm/cacheflush.h>
  
+ #include <xen/xen.h>
+ #include <asm/xen/hypervisor.h>
+ 
  #define DMA_ERROR_CODE        (~0)
  extern struct dma_map_ops arm_dma_ops;
  extern struct dma_map_ops arm_coherent_dma_ops;

diff --cc arch/arm/include/asm/xen/page.h
index 359a7b5,5d0e4c5..71bb779
--- 1/arch/arm/include/asm/xen/page.h
--- 2/arch/arm/include/asm/xen/page.h
+++ b/arch/arm/include/asm/xen/page.h
@@@ -32,6 -32,44 +32,44 @@@ typedef struct xpaddr 
  
  #define INVALID_P2M_ENTRY      (~0UL)
  
 -      
+ unsigned long __pfn_to_mfn(unsigned long pfn);
+ unsigned long __mfn_to_pfn(unsigned long mfn);
+ extern struct rb_root phys_to_mach;
+ 
+ static inline unsigned long pfn_to_mfn(unsigned long pfn)
+ {
+       unsigned long mfn;
++
+       if (phys_to_mach.rb_node != NULL) {
+               mfn = __pfn_to_mfn(pfn);
+               if (mfn != INVALID_P2M_ENTRY)
+                       return mfn;
+       }
+ 
+       if (xen_initial_domain())
+               return pfn;
+       else
+               return INVALID_P2M_ENTRY;
+ }
+ 
+ static inline unsigned long mfn_to_pfn(unsigned long mfn)
+ {
+       unsigned long pfn;
+ 
+       if (phys_to_mach.rb_node != NULL) {
+               pfn = __mfn_to_pfn(mfn);
+               if (pfn != INVALID_P2M_ENTRY)
+                       return pfn;
+       }
+ 
+       if (xen_initial_domain())
+               return mfn;
+       else
+               return INVALID_P2M_ENTRY;
+ }
+ 
+ #define mfn_to_local_pfn(mfn) mfn_to_pfn(mfn)
+ 
  static inline xmaddr_t phys_to_machine(xpaddr_t phys)
  {
        unsigned offset = phys.paddr & ~PAGE_MASK;

diff --cc arch/arm/xen/p2m.c
index 0000000,5df4a9a..23732cd
mode 000000,100644..100644
--- /dev/null
--- 2/arch/arm/xen/p2m.c
+++ b/arch/arm/xen/p2m.c
@@@ -1,0 -1,208 +1,208 @@@
 -                              kfree(p2m_entry);       
+ #include <linux/bootmem.h>
+ #include <linux/gfp.h>
+ #include <linux/export.h>
+ #include <linux/rwlock.h>
+ #include <linux/slab.h>
+ #include <linux/types.h>
+ #include <linux/dma-mapping.h>
+ #include <linux/vmalloc.h>
+ #include <linux/swiotlb.h>
+ 
+ #include <xen/xen.h>
+ #include <xen/interface/memory.h>
+ #include <xen/swiotlb-xen.h>
+ 
+ #include <asm/cacheflush.h>
+ #include <asm/xen/page.h>
+ #include <asm/xen/hypercall.h>
+ #include <asm/xen/interface.h>
+ 
+ struct xen_p2m_entry {
+       unsigned long pfn;
+       unsigned long mfn;
+       unsigned long nr_pages;
+       struct rb_node rbnode_mach;
+       struct rb_node rbnode_phys;
+ };
+ 
+ rwlock_t p2m_lock;
+ struct rb_root phys_to_mach = RB_ROOT;
+ static struct rb_root mach_to_phys = RB_ROOT;
+ 
+ static int xen_add_phys_to_mach_entry(struct xen_p2m_entry *new)
+ {
+       struct rb_node **link = &phys_to_mach.rb_node;
+       struct rb_node *parent = NULL;
+       struct xen_p2m_entry *entry;
+       int rc = 0;
+ 
+       while (*link) {
+               parent = *link;
+               entry = rb_entry(parent, struct xen_p2m_entry, rbnode_phys);
+ 
+               if (new->mfn == entry->mfn)
+                       goto err_out;
+               if (new->pfn == entry->pfn)
+                       goto err_out;
+ 
+               if (new->pfn < entry->pfn)
+                       link = &(*link)->rb_left;
+               else
+                       link = &(*link)->rb_right;
+       }
+       rb_link_node(&new->rbnode_phys, parent, link);
+       rb_insert_color(&new->rbnode_phys, &phys_to_mach);
+       goto out;
+ 
+ err_out:
+       rc = -EINVAL;
+       pr_warn("%s: cannot add pfn=%pa -> mfn=%pa: pfn=%pa -> mfn=%pa already exists\n",
+                       __func__, &new->pfn, &new->mfn, &entry->pfn, &entry->mfn);
+ out:
+       return rc;
+ }
+ 
+ unsigned long __pfn_to_mfn(unsigned long pfn)
+ {
+       struct rb_node *n = phys_to_mach.rb_node;
+       struct xen_p2m_entry *entry;
+       unsigned long irqflags;
+ 
+       read_lock_irqsave(&p2m_lock, irqflags);
+       while (n) {
+               entry = rb_entry(n, struct xen_p2m_entry, rbnode_phys);
+               if (entry->pfn <= pfn &&
+                               entry->pfn + entry->nr_pages > pfn) {
+                       read_unlock_irqrestore(&p2m_lock, irqflags);
+                       return entry->mfn + (pfn - entry->pfn);
+               }
+               if (pfn < entry->pfn)
+                       n = n->rb_left;
+               else
+                       n = n->rb_right;
+       }
+       read_unlock_irqrestore(&p2m_lock, irqflags);
+ 
+       return INVALID_P2M_ENTRY;
+ }
+ EXPORT_SYMBOL_GPL(__pfn_to_mfn);
+ 
+ static int xen_add_mach_to_phys_entry(struct xen_p2m_entry *new)
+ {
+       struct rb_node **link = &mach_to_phys.rb_node;
+       struct rb_node *parent = NULL;
+       struct xen_p2m_entry *entry;
+       int rc = 0;
+ 
+       while (*link) {
+               parent = *link;
+               entry = rb_entry(parent, struct xen_p2m_entry, rbnode_mach);
+ 
+               if (new->mfn == entry->mfn)
+                       goto err_out;
+               if (new->pfn == entry->pfn)
+                       goto err_out;
+ 
+               if (new->mfn < entry->mfn)
+                       link = &(*link)->rb_left;
+               else
+                       link = &(*link)->rb_right;
+       }
+       rb_link_node(&new->rbnode_mach, parent, link);
+       rb_insert_color(&new->rbnode_mach, &mach_to_phys);
+       goto out;
+ 
+ err_out:
+       rc = -EINVAL;
+       pr_warn("%s: cannot add pfn=%pa -> mfn=%pa: pfn=%pa -> mfn=%pa already exists\n",
+                       __func__, &new->pfn, &new->mfn, &entry->pfn, &entry->mfn);
+ out:
+       return rc;
+ }
+ 
+ unsigned long __mfn_to_pfn(unsigned long mfn)
+ {
+       struct rb_node *n = mach_to_phys.rb_node;
+       struct xen_p2m_entry *entry;
+       unsigned long irqflags;
+ 
+       read_lock_irqsave(&p2m_lock, irqflags);
+       while (n) {
+               entry = rb_entry(n, struct xen_p2m_entry, rbnode_mach);
+               if (entry->mfn <= mfn &&
+                               entry->mfn + entry->nr_pages > mfn) {
+                       read_unlock_irqrestore(&p2m_lock, irqflags);
+                       return entry->pfn + (mfn - entry->mfn);
+               }
+               if (mfn < entry->mfn)
+                       n = n->rb_left;
+               else
+                       n = n->rb_right;
+       }
+       read_unlock_irqrestore(&p2m_lock, irqflags);
+ 
+       return INVALID_P2M_ENTRY;
+ }
+ EXPORT_SYMBOL_GPL(__mfn_to_pfn);
+ 
+ bool __set_phys_to_machine_multi(unsigned long pfn,
+               unsigned long mfn, unsigned long nr_pages)
+ {
+       int rc;
+       unsigned long irqflags;
+       struct xen_p2m_entry *p2m_entry;
+       struct rb_node *n = phys_to_mach.rb_node;
+ 
+       if (mfn == INVALID_P2M_ENTRY) {
+               write_lock_irqsave(&p2m_lock, irqflags);
+               while (n) {
+                       p2m_entry = rb_entry(n, struct xen_p2m_entry, rbnode_phys);
+                       if (p2m_entry->pfn <= pfn &&
+                                       p2m_entry->pfn + p2m_entry->nr_pages > pfn) {
+                               rb_erase(&p2m_entry->rbnode_mach, &mach_to_phys);
+                               rb_erase(&p2m_entry->rbnode_phys, &phys_to_mach);
+                               write_unlock_irqrestore(&p2m_lock, irqflags);
++                              kfree(p2m_entry);
+                               return true;
+                       }
+                       if (pfn < p2m_entry->pfn)
+                               n = n->rb_left;
+                       else
+                               n = n->rb_right;
+               }
+               write_unlock_irqrestore(&p2m_lock, irqflags);
+               return true;
+       }
+ 
+       p2m_entry = kzalloc(sizeof(struct xen_p2m_entry), GFP_NOWAIT);
+       if (!p2m_entry) {
+               pr_warn("cannot allocate xen_p2m_entry\n");
+               return false;
+       }
+       p2m_entry->pfn = pfn;
+       p2m_entry->nr_pages = nr_pages;
+       p2m_entry->mfn = mfn;
+ 
+       write_lock_irqsave(&p2m_lock, irqflags);
+       if ((rc = xen_add_phys_to_mach_entry(p2m_entry) < 0) ||
+               (rc = xen_add_mach_to_phys_entry(p2m_entry) < 0)) {
+               write_unlock_irqrestore(&p2m_lock, irqflags);
+               return false;
+       }
+       write_unlock_irqrestore(&p2m_lock, irqflags);
+       return true;
+ }
+ EXPORT_SYMBOL_GPL(__set_phys_to_machine_multi);
+ 
+ bool __set_phys_to_machine(unsigned long pfn, unsigned long mfn)
+ {
+       return __set_phys_to_machine_multi(pfn, mfn, 1);
+ }
+ EXPORT_SYMBOL_GPL(__set_phys_to_machine);
+ 
+ int p2m_init(void)
+ {
+       rwlock_init(&p2m_lock);
+       return 0;
+ }
+ arch_initcall(p2m_init);

diff --cc arch/x86/xen/mmu.c
Simple merge

diff --cc drivers/xen/swiotlb-xen.c
index 44af9d8,8af6862..a224bc7
--- 1/drivers/xen/swiotlb-xen.c
--- 2/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@@ -42,8 -42,8 +42,11 @@@
  #include <xen/page.h>
  #include <xen/xen-ops.h>
  #include <xen/hvc-console.h>
 +
+ #include <asm/dma-mapping.h>
+ #include <asm/xen/page-coherent.h>
++
 +#include <trace/events/swiotlb.h>
  /*
   * Used to do a quick range check in swiotlb_tbl_unmap_single and
   * swiotlb_tbl_sync_single_*, to see if the memory was in fact allocated by this

diff --cc include/xen/swiotlb-xen.h
Simple merge

diff --cc lib/swiotlb.c
Simple merge