Merge branch 'master' into for-next

Sync with Linus' tree to be able to apply fixes on top of newer things
in tree (efi-stub).

Signed-off-by: Jiri Kosina <jkosina@suse.cz>

11 files changed, 210 insertions, 63 deletions

diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index e8dc72c4bf11..12ba6db65142 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -140,7 +140,6 @@ config XEN_GRANT_DEV_ALLOC
 
 config SWIOTLB_XEN
         def_bool y
-        depends on PCI && X86
         select SWIOTLB
 
 config XEN_TMEM
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 3101cf6daf56..55ea73f7c70b 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -349,8 +349,6 @@ static enum bp_state increase_reservation(unsigned long nr_pages)
                 BUG_ON(page == NULL);
 
                 pfn = page_to_pfn(page);
-                BUG_ON(!xen_feature(XENFEAT_auto_translated_physmap) &&
-                       phys_to_machine_mapping_valid(pfn));
 
                 set_phys_to_machine(pfn, frame_list[i]);
 
@@ -380,6 +378,7 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
         enum bp_state state = BP_DONE;
         unsigned long  pfn, i;
         struct page   *page;
+        struct page   *scratch_page;
         int ret;
         struct xen_memory_reservation reservation = {
                 .address_bits = 0,
@@ -412,34 +411,35 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
 
                 scrub_page(page);
 
+                /*
+                 * Ballooned out frames are effectively replaced with
+                 * a scratch frame.  Ensure direct mappings and the
+                 * p2m are consistent.
+                 */
+                scratch_page = get_balloon_scratch_page();
 #ifdef CONFIG_XEN_HAVE_PVMMU
                 if (xen_pv_domain() && !PageHighMem(page)) {
                         ret = HYPERVISOR_update_va_mapping(
                                 (unsigned long)__va(pfn << PAGE_SHIFT),
-                                pfn_pte(page_to_pfn(__get_cpu_var(balloon_scratch_page)),
+                                pfn_pte(page_to_pfn(scratch_page),
                                         PAGE_KERNEL_RO), 0);
                         BUG_ON(ret);
                 }
 #endif
-        }
-
-        /* Ensure that ballooned highmem pages don't have kmaps. */
-        kmap_flush_unused();
-        flush_tlb_all();
-
-        /* No more mappings: invalidate P2M and add to balloon. */
-        for (i = 0; i < nr_pages; i++) {
-                pfn = mfn_to_pfn(frame_list[i]);
                 if (!xen_feature(XENFEAT_auto_translated_physmap)) {
                         unsigned long p;
-                        struct page *pg;
-                        pg = __get_cpu_var(balloon_scratch_page);
-                        p = page_to_pfn(pg);
+                        p = page_to_pfn(scratch_page);
                         __set_phys_to_machine(pfn, pfn_to_mfn(p));
                 }
+                put_balloon_scratch_page();
+
                 balloon_append(pfn_to_page(pfn));
         }
 
+        /* Ensure that ballooned highmem pages don't have kmaps. */
+        kmap_flush_unused();
+        flush_tlb_all();
+
         set_xen_guest_handle(reservation.extent_start, frame_list);
         reservation.nr_extents   = nr_pages;
         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
@@ -596,7 +596,7 @@ static void __init balloon_add_region(unsigned long start_pfn,
         }
 }
 
-static int __cpuinit balloon_cpu_notify(struct notifier_block *self,
+static int balloon_cpu_notify(struct notifier_block *self,
                                     unsigned long action, void *hcpu)
 {
         int cpu = (long)hcpu;
@@ -616,7 +616,7 @@ static int __cpuinit balloon_cpu_notify(struct notifier_block *self,
         return NOTIFY_OK;
 }
 
-static struct notifier_block balloon_cpu_notifier __cpuinitdata = {
+static struct notifier_block balloon_cpu_notifier = {
         .notifier_call  = balloon_cpu_notify,
 };
 
@@ -641,7 +641,7 @@ static int __init balloon_init(void)
 
         balloon_stats.current_pages = xen_pv_domain()
                 ? min(xen_start_info->nr_pages - xen_released_pages, max_pfn)
-                : max_pfn;
+                : get_num_physpages();
         balloon_stats.target_pages  = balloon_stats.current_pages;
         balloon_stats.balloon_low   = 0;
         balloon_stats.balloon_high  = 0;
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index 8b3a69a06c39..5de2063e16d3 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -305,7 +305,7 @@ static int evtchn_bind_to_user(struct per_user_data *u, int port)
         if (rc < 0)
                 goto err;
 
-        rc = bind_evtchn_to_irqhandler(port, evtchn_interrupt, IRQF_DISABLED,
+        rc = bind_evtchn_to_irqhandler(port, evtchn_interrupt, 0,
                                        u->name, evtchn);
         if (rc < 0)
                 goto err;
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index c4d2298893b1..028387192b60 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -49,6 +49,7 @@
 #include <xen/grant_table.h>
 #include <xen/interface/memory.h>
 #include <xen/hvc-console.h>
+#include <xen/swiotlb-xen.h>
 #include <asm/xen/hypercall.h>
 #include <asm/xen/interface.h>
 
@@ -898,8 +899,16 @@ int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
                         gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, map_ops + i,
                                                 &map_ops[i].status, __func__);
 
-        if (xen_feature(XENFEAT_auto_translated_physmap))
+        /* this is basically a nop on x86 */
+        if (xen_feature(XENFEAT_auto_translated_physmap)) {
+                for (i = 0; i < count; i++) {
+                        if (map_ops[i].status)
+                                continue;
+                        set_phys_to_machine(map_ops[i].host_addr >> PAGE_SHIFT,
+                                        map_ops[i].dev_bus_addr >> PAGE_SHIFT);
+                }
                 return ret;
+        }
 
         if (!in_interrupt() && paravirt_get_lazy_mode() == PARAVIRT_LAZY_NONE) {
                 arch_enter_lazy_mmu_mode();
@@ -921,9 +930,10 @@ int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
                 ret = m2p_add_override(mfn, pages[i], kmap_ops ?
                                        &kmap_ops[i] : NULL);
                 if (ret)
-                        return ret;
+                        goto out;
         }
 
+ out:
         if (lazy)
                 arch_leave_lazy_mmu_mode();
 
@@ -942,8 +952,14 @@ int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,
         if (ret)
                 return ret;
 
-        if (xen_feature(XENFEAT_auto_translated_physmap))
+        /* this is basically a nop on x86 */
+        if (xen_feature(XENFEAT_auto_translated_physmap)) {
+                for (i = 0; i < count; i++) {
+                        set_phys_to_machine(unmap_ops[i].host_addr >> PAGE_SHIFT,
+                                        INVALID_P2M_ENTRY);
+                }
                 return ret;
+        }
 
         if (!in_interrupt() && paravirt_get_lazy_mode() == PARAVIRT_LAZY_NONE) {
                 arch_enter_lazy_mmu_mode();
@@ -954,9 +970,10 @@ int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,
                 ret = m2p_remove_override(pages[i], kmap_ops ?
                                        &kmap_ops[i] : NULL);
                 if (ret)
-                        return ret;
+                        goto out;
         }
 
+ out:
         if (lazy)
                 arch_leave_lazy_mmu_mode();
 
diff --git a/drivers/xen/pci.c b/drivers/xen/pci.c
index 18fff88254eb..188825122aae 100644
--- a/drivers/xen/pci.c
+++ b/drivers/xen/pci.c
@@ -26,6 +26,7 @@
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
 #include "../pci/pci.h"
+#include <asm/pci_x86.h>
 
 static bool __read_mostly pci_seg_supported = true;
 
@@ -58,12 +59,12 @@ static int xen_add_device(struct device *dev)
                         add.flags = XEN_PCI_DEV_EXTFN;
 
 #ifdef CONFIG_ACPI
-                handle = DEVICE_ACPI_HANDLE(&pci_dev->dev);
+                handle = ACPI_HANDLE(&pci_dev->dev);
                 if (!handle && pci_dev->bus->bridge)
-                        handle = DEVICE_ACPI_HANDLE(pci_dev->bus->bridge);
+                        handle = ACPI_HANDLE(pci_dev->bus->bridge);
 #ifdef CONFIG_PCI_IOV
                 if (!handle && pci_dev->is_virtfn)
-                        handle = DEVICE_ACPI_HANDLE(physfn->bus->bridge);
+                        handle = ACPI_HANDLE(physfn->bus->bridge);
 #endif
                 if (handle) {
                         acpi_status status;
@@ -192,3 +193,49 @@ static int __init register_xen_pci_notifier(void)
 }
 
 arch_initcall(register_xen_pci_notifier);
+
+#ifdef CONFIG_PCI_MMCONFIG
+static int __init xen_mcfg_late(void)
+{
+        struct pci_mmcfg_region *cfg;
+        int rc;
+
+        if (!xen_initial_domain())
+                return 0;
+
+        if ((pci_probe & PCI_PROBE_MMCONF) == 0)
+                return 0;
+
+        if (list_empty(&pci_mmcfg_list))
+                return 0;
+
+        /* Check whether they are in the right area. */
+        list_for_each_entry(cfg, &pci_mmcfg_list, list) {
+                struct physdev_pci_mmcfg_reserved r;
+
+                r.address = cfg->address;
+                r.segment = cfg->segment;
+                r.start_bus = cfg->start_bus;
+                r.end_bus = cfg->end_bus;
+                r.flags = XEN_PCI_MMCFG_RESERVED;
+
+                rc = HYPERVISOR_physdev_op(PHYSDEVOP_pci_mmcfg_reserved, &r);
+                switch (rc) {
+                case 0:
+                case -ENOSYS:
+                        continue;
+
+                default:
+                        pr_warn("Failed to report MMCONFIG reservation"
+                                " state for %s to hypervisor"
+                                " (%d)\n",
+                                cfg->name, rc);
+                }
+        }
+        return 0;
+}
+/*
+ * Needs to be done after acpi_init which are subsys_initcall.
+ */
+subsys_initcall_sync(xen_mcfg_late);
+#endif
diff --git a/drivers/xen/platform-pci.c b/drivers/xen/platform-pci.c
index 99db9e1eb8ba..2f3528e93cb9 100644
--- a/drivers/xen/platform-pci.c
+++ b/drivers/xen/platform-pci.c
@@ -84,7 +84,7 @@ static irqreturn_t do_hvm_evtchn_intr(int irq, void *dev_id)
 static int xen_allocate_irq(struct pci_dev *pdev)
 {
         return request_irq(pdev->irq, do_hvm_evtchn_intr,
-                        IRQF_DISABLED | IRQF_NOBALANCING | IRQF_TRIGGER_RISING,
+                        IRQF_NOBALANCING | IRQF_TRIGGER_RISING,
                         "xen-platform-pci", pdev);
 }
 
diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
index 1b2277c311d2..1eac0731c349 100644
--- a/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@ -42,12 +42,31 @@
 #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
  * API.
  */
 
+#ifndef CONFIG_X86
+static unsigned long dma_alloc_coherent_mask(struct device *dev,
+                                            gfp_t gfp)
+{
+        unsigned long dma_mask = 0;
+
+        dma_mask = dev->coherent_dma_mask;
+        if (!dma_mask)
+                dma_mask = (gfp & GFP_DMA) ? DMA_BIT_MASK(24) : DMA_BIT_MASK(32);
+
+        return dma_mask;
+}
+#endif
+
 static char *xen_io_tlb_start, *xen_io_tlb_end;
 static unsigned long xen_io_tlb_nslabs;
 /*
@@ -56,17 +75,17 @@ static unsigned long xen_io_tlb_nslabs;
 
 static u64 start_dma_addr;
 
-static dma_addr_t xen_phys_to_bus(phys_addr_t paddr)
+static inline dma_addr_t xen_phys_to_bus(phys_addr_t paddr)
 {
         return phys_to_machine(XPADDR(paddr)).maddr;
 }
 
-static phys_addr_t xen_bus_to_phys(dma_addr_t baddr)
+static inline phys_addr_t xen_bus_to_phys(dma_addr_t baddr)
 {
         return machine_to_phys(XMADDR(baddr)).paddr;
 }
 
-static dma_addr_t xen_virt_to_bus(void *address)
+static inline dma_addr_t xen_virt_to_bus(void *address)
 {
         return xen_phys_to_bus(virt_to_phys(address));
 }
@@ -89,7 +108,7 @@ static int check_pages_physically_contiguous(unsigned long pfn,
         return 1;
 }
 
-static int range_straddles_page_boundary(phys_addr_t p, size_t size)
+static inline int range_straddles_page_boundary(phys_addr_t p, size_t size)
 {
         unsigned long pfn = PFN_DOWN(p);
         unsigned int offset = p & ~PAGE_MASK;
@@ -126,6 +145,8 @@ xen_swiotlb_fixup(void *buf, size_t size, unsigned long nslabs)
 {
         int i, rc;
         int dma_bits;
+        dma_addr_t dma_handle;
+        phys_addr_t p = virt_to_phys(buf);
 
         dma_bits = get_order(IO_TLB_SEGSIZE << IO_TLB_SHIFT) + PAGE_SHIFT;
 
@@ -135,9 +156,9 @@ xen_swiotlb_fixup(void *buf, size_t size, unsigned long nslabs)
 
                 do {
                         rc = xen_create_contiguous_region(
-                                (unsigned long)buf + (i << IO_TLB_SHIFT),
+                                p + (i << IO_TLB_SHIFT),
                                 get_order(slabs << IO_TLB_SHIFT),
-                                dma_bits);
+                                dma_bits, &dma_handle);
                 } while (rc && dma_bits++ < max_dma_bits);
                 if (rc)
                         return rc;
@@ -263,7 +284,6 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
         void *ret;
         int order = get_order(size);
         u64 dma_mask = DMA_BIT_MASK(32);
-        unsigned long vstart;
         phys_addr_t phys;
         dma_addr_t dev_addr;
 
@@ -278,8 +298,12 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
         if (dma_alloc_from_coherent(hwdev, size, dma_handle, &ret))
                 return ret;
 
-        vstart = __get_free_pages(flags, order);
-        ret = (void *)vstart;
+        /* On ARM this function returns an ioremap'ped virtual address for
+         * which virt_to_phys doesn't return the corresponding physical
+         * address. In fact on ARM virt_to_phys only works for kernel direct
+         * mapped RAM memory. Also see comment below.
+         */
+        ret = xen_alloc_coherent_pages(hwdev, size, dma_handle, flags, attrs);
 
         if (!ret)
                 return ret;
@@ -287,18 +311,21 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
         if (hwdev && hwdev->coherent_dma_mask)
                 dma_mask = dma_alloc_coherent_mask(hwdev, flags);
 
-        phys = virt_to_phys(ret);
+        /* At this point dma_handle is the physical address, next we are
+         * going to set it to the machine address.
+         * Do not use virt_to_phys(ret) because on ARM it doesn't correspond
+         * to *dma_handle. */
+        phys = *dma_handle;
         dev_addr = xen_phys_to_bus(phys);
         if (((dev_addr + size - 1 <= dma_mask)) &&
             !range_straddles_page_boundary(phys, size))
                 *dma_handle = dev_addr;
         else {
-                if (xen_create_contiguous_region(vstart, order,
-                                                 fls64(dma_mask)) != 0) {
-                        free_pages(vstart, order);
+                if (xen_create_contiguous_region(phys, order,
+                                                 fls64(dma_mask), dma_handle) != 0) {
+                        xen_free_coherent_pages(hwdev, size, ret, (dma_addr_t)phys, attrs);
                         return NULL;
                 }
-                *dma_handle = virt_to_machine(ret).maddr;
         }
         memset(ret, 0, size);
         return ret;
@@ -319,13 +346,15 @@ xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
         if (hwdev && hwdev->coherent_dma_mask)
                 dma_mask = hwdev->coherent_dma_mask;
 
-        phys = virt_to_phys(vaddr);
+        /* do not use virt_to_phys because on ARM it doesn't return you the
+         * physical address */
+        phys = xen_bus_to_phys(dev_addr);
 
         if (((dev_addr + size - 1 > dma_mask)) ||
             range_straddles_page_boundary(phys, size))
-                xen_destroy_contiguous_region((unsigned long)vaddr, order);
+                xen_destroy_contiguous_region(phys, order);
 
-        free_pages((unsigned long)vaddr, order);
+        xen_free_coherent_pages(hwdev, size, vaddr, (dma_addr_t)phys, attrs);
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent);
 
@@ -352,16 +381,25 @@ dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
          * buffering it.
          */
         if (dma_capable(dev, dev_addr, size) &&
-            !range_straddles_page_boundary(phys, size) && !swiotlb_force)
+            !range_straddles_page_boundary(phys, size) && !swiotlb_force) {
+                /* we are not interested in the dma_addr returned by
+                 * xen_dma_map_page, only in the potential cache flushes executed
+                 * by the function. */
+                xen_dma_map_page(dev, page, offset, size, dir, attrs);
                 return dev_addr;
+        }
 
         /*
          * Oh well, have to allocate and map a bounce buffer.
          */
+        trace_swiotlb_bounced(dev, dev_addr, size, swiotlb_force);
+
         map = swiotlb_tbl_map_single(dev, start_dma_addr, phys, size, dir);
         if (map == SWIOTLB_MAP_ERROR)
                 return DMA_ERROR_CODE;
 
+        xen_dma_map_page(dev, pfn_to_page(map >> PAGE_SHIFT),
+                                        map & ~PAGE_MASK, size, dir, attrs);
         dev_addr = xen_phys_to_bus(map);
 
         /*
@@ -384,12 +422,15 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_page);
  * whatever the device wrote there.
  */
 static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
-                             size_t size, enum dma_data_direction dir)
+                             size_t size, enum dma_data_direction dir,
+                                 struct dma_attrs *attrs)
 {
         phys_addr_t paddr = xen_bus_to_phys(dev_addr);
 
         BUG_ON(dir == DMA_NONE);
 
+        xen_dma_unmap_page(hwdev, paddr, size, dir, attrs);
+
         /* NOTE: We use dev_addr here, not paddr! */
         if (is_xen_swiotlb_buffer(dev_addr)) {
                 swiotlb_tbl_unmap_single(hwdev, paddr, size, dir);
@@ -412,7 +453,7 @@ void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                             size_t size, enum dma_data_direction dir,
                             struct dma_attrs *attrs)
 {
-        xen_unmap_single(hwdev, dev_addr, size, dir);
+        xen_unmap_single(hwdev, dev_addr, size, dir, attrs);
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_page);
 
@@ -435,11 +476,15 @@ xen_swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
 
         BUG_ON(dir == DMA_NONE);
 
+        if (target == SYNC_FOR_CPU)
+                xen_dma_sync_single_for_cpu(hwdev, paddr, size, dir);
+
         /* NOTE: We use dev_addr here, not paddr! */
-        if (is_xen_swiotlb_buffer(dev_addr)) {
+        if (is_xen_swiotlb_buffer(dev_addr))
                 swiotlb_tbl_sync_single(hwdev, paddr, size, dir, target);
-                return;
-        }
+
+        if (target == SYNC_FOR_DEVICE)
+                xen_dma_sync_single_for_cpu(hwdev, paddr, size, dir);
 
         if (dir != DMA_FROM_DEVICE)
                 return;
@@ -502,16 +547,31 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                                                                  sg->length,
                                                                  dir);
                         if (map == SWIOTLB_MAP_ERROR) {
+                                dev_warn(hwdev, "swiotlb buffer is full\n");
                                 /* Don't panic here, we expect map_sg users
                                    to do proper error handling. */
                                 xen_swiotlb_unmap_sg_attrs(hwdev, sgl, i, dir,
                                                            attrs);
                                 sg_dma_len(sgl) = 0;
-                                return DMA_ERROR_CODE;
+                                return 0;
                         }
+                        xen_dma_map_page(hwdev, pfn_to_page(map >> PAGE_SHIFT),
+                                                map & ~PAGE_MASK,
+                                                sg->length,
+                                                dir,
+                                                attrs);
                         sg->dma_address = xen_phys_to_bus(map);
-                } else
+                } else {
+                        /* we are not interested in the dma_addr returned by
+                         * xen_dma_map_page, only in the potential cache flushes executed
+                         * by the function. */
+                        xen_dma_map_page(hwdev, pfn_to_page(paddr >> PAGE_SHIFT),
+                                                paddr & ~PAGE_MASK,
+                                                sg->length,
+                                                dir,
+                                                attrs);
                         sg->dma_address = dev_addr;
+                }
                 sg_dma_len(sg) = sg->length;
         }
         return nelems;
@@ -533,7 +593,7 @@ xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
         BUG_ON(dir == DMA_NONE);
 
         for_each_sg(sgl, sg, nelems, i)
-                xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir);
+                xen_unmap_single(hwdev, sg->dma_address, sg_dma_len(sg), dir, attrs);
 
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg_attrs);
@@ -593,3 +653,15 @@ xen_swiotlb_dma_supported(struct device *hwdev, u64 mask)
         return xen_virt_to_bus(xen_io_tlb_end - 1) <= mask;
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_dma_supported);
+
+int
+xen_swiotlb_set_dma_mask(struct device *dev, u64 dma_mask)
+{
+        if (!dev->dma_mask || !xen_swiotlb_dma_supported(dev, dma_mask))
+                return -EIO;
+
+        *dev->dma_mask = dma_mask;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_set_dma_mask);
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 38e92b770e91..3c0a74b3e9b1 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -384,12 +384,14 @@ static ssize_t nodename_show(struct device *dev,
 {
         return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
 }
+static DEVICE_ATTR_RO(nodename);
 
 static ssize_t devtype_show(struct device *dev,
                             struct device_attribute *attr, char *buf)
 {
         return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
 }
+static DEVICE_ATTR_RO(devtype);
 
 static ssize_t modalias_show(struct device *dev,
                              struct device_attribute *attr, char *buf)
@@ -397,14 +399,24 @@ static ssize_t modalias_show(struct device *dev,
         return sprintf(buf, "%s:%s\n", dev->bus->name,
                        to_xenbus_device(dev)->devicetype);
 }
+static DEVICE_ATTR_RO(modalias);
 
-struct device_attribute xenbus_dev_attrs[] = {
-        __ATTR_RO(nodename),
-        __ATTR_RO(devtype),
-        __ATTR_RO(modalias),
-        __ATTR_NULL
+static struct attribute *xenbus_dev_attrs[] = {
+        &dev_attr_nodename.attr,
+        &dev_attr_devtype.attr,
+        &dev_attr_modalias.attr,
+        NULL,
 };
-EXPORT_SYMBOL_GPL(xenbus_dev_attrs);
+
+static const struct attribute_group xenbus_dev_group = {
+        .attrs = xenbus_dev_attrs,
+};
+
+const struct attribute_group *xenbus_dev_groups[] = {
+        &xenbus_dev_group,
+        NULL,
+};
+EXPORT_SYMBOL_GPL(xenbus_dev_groups);
 
 int xenbus_probe_node(struct xen_bus_type *bus,
                       const char *type,
diff --git a/drivers/xen/xenbus/xenbus_probe.h b/drivers/xen/xenbus/xenbus_probe.h
index 146f857a36f8..1085ec294a19 100644
--- a/drivers/xen/xenbus/xenbus_probe.h
+++ b/drivers/xen/xenbus/xenbus_probe.h
@@ -54,7 +54,7 @@ enum xenstore_init {
         XS_LOCAL,
 };
 
-extern struct device_attribute xenbus_dev_attrs[];
+extern const struct attribute_group *xenbus_dev_groups[];
 
 extern int xenbus_match(struct device *_dev, struct device_driver *_drv);
 extern int xenbus_dev_probe(struct device *_dev);
diff --git a/drivers/xen/xenbus/xenbus_probe_backend.c b/drivers/xen/xenbus/xenbus_probe_backend.c
index 998bbbab816b..5125dce11a60 100644
--- a/drivers/xen/xenbus/xenbus_probe_backend.c
+++ b/drivers/xen/xenbus/xenbus_probe_backend.c
@@ -200,7 +200,7 @@ static struct xen_bus_type xenbus_backend = {
                 .probe          = xenbus_dev_probe,
                 .remove         = xenbus_dev_remove,
                 .shutdown       = xenbus_dev_shutdown,
-                .dev_attrs      = xenbus_dev_attrs,
+                .dev_groups     = xenbus_dev_groups,
         },
 };
 
diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c
index 34b20bfa4e8c..129bf84c19ec 100644
--- a/drivers/xen/xenbus/xenbus_probe_frontend.c
+++ b/drivers/xen/xenbus/xenbus_probe_frontend.c
@@ -154,7 +154,7 @@ static struct xen_bus_type xenbus_frontend = {
                 .probe          = xenbus_frontend_dev_probe,
                 .remove         = xenbus_dev_remove,
                 .shutdown       = xenbus_dev_shutdown,
-                .dev_attrs      = xenbus_dev_attrs,
+                .dev_groups     = xenbus_dev_groups,
 
                 .pm             = &xenbus_pm_ops,
         },