drivers/xen/unpopulated-alloc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/errno.h>
   3 #include <linux/gfp.h>
   4 #include <linux/kernel.h>
   5 #include <linux/mm.h>
   6 #include <linux/memremap.h>
   7 #include <linux/slab.h>
   8
   9 #include <asm/page.h>
  10
  11 #include <xen/balloon.h>
  12 #include <xen/page.h>
  13 #include <xen/xen.h>
  14
  15 static DEFINE_MUTEX(list_lock);
  16 static struct page *page_list;
  17 static unsigned int list_count;
  18
  19 static struct resource *target_resource;
  20
  21 /*
  22  * If arch is not happy with system "iomem_resource" being used for
  23  * the region allocation it can provide it's own view by creating specific
  24  * Xen resource with unused regions of guest physical address space provided
  25  * by the hypervisor.
  26  */
  27 int __weak __init arch_xen_unpopulated_init(struct resource **res)
  28 {
  29         *res = &iomem_resource;
  30
  31         return 0;
  32 }
  33
  34 static int fill_list(unsigned int nr_pages)
  35 {
  36         struct dev_pagemap *pgmap;
  37         struct resource *res, *tmp_res = NULL;
  38         void *vaddr;
  39         unsigned int i, alloc_pages = round_up(nr_pages, PAGES_PER_SECTION);
  40         struct range mhp_range;
  41         int ret;
  42
  43         res = kzalloc(sizeof(*res), GFP_KERNEL);
  44         if (!res)
  45                 return -ENOMEM;
  46
  47         res->name = "Xen scratch";
  48         res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  49
  50         mhp_range = mhp_get_pluggable_range(true);
  51
  52         ret = allocate_resource(target_resource, res,
  53                                 alloc_pages * PAGE_SIZE, mhp_range.start, mhp_range.end,
  54                                 PAGES_PER_SECTION * PAGE_SIZE, NULL, NULL);
  55         if (ret < 0) {
  56                 pr_err("Cannot allocate new IOMEM resource\n");
  57                 goto err_resource;
  58         }
  59
  60         /*
  61          * Reserve the region previously allocated from Xen resource to avoid
  62          * re-using it by someone else.
  63          */
  64         if (target_resource != &iomem_resource) {
  65                 tmp_res = kzalloc(sizeof(*tmp_res), GFP_KERNEL);
  66                 if (!tmp_res) {
  67                         ret = -ENOMEM;
  68                         goto err_insert;
  69                 }
  70
  71                 tmp_res->name = res->name;
  72                 tmp_res->start = res->start;
  73                 tmp_res->end = res->end;
  74                 tmp_res->flags = res->flags;
  75
  76                 ret = request_resource(&iomem_resource, tmp_res);
  77                 if (ret < 0) {
  78                         pr_err("Cannot request resource %pR (%d)\n", tmp_res, ret);
  79                         kfree(tmp_res);
  80                         goto err_insert;
  81                 }
  82         }
  83
  84         pgmap = kzalloc(sizeof(*pgmap), GFP_KERNEL);
  85         if (!pgmap) {
  86                 ret = -ENOMEM;
  87                 goto err_pgmap;
  88         }
  89
  90         pgmap->type = MEMORY_DEVICE_GENERIC;
  91         pgmap->range = (struct range) {
  92                 .start = res->start,
  93                 .end = res->end,
  94         };
  95         pgmap->nr_range = 1;
  96         pgmap->owner = res;
  97
  98 #ifdef CONFIG_XEN_HAVE_PVMMU
  99         /*
 100          * memremap will build page tables for the new memory so
 101          * the p2m must contain invalid entries so the correct
 102          * non-present PTEs will be written.
 103          *
 104          * If a failure occurs, the original (identity) p2m entries
 105          * are not restored since this region is now known not to
 106          * conflict with any devices.
 107          */
 108         if (!xen_feature(XENFEAT_auto_translated_physmap)) {
 109                 xen_pfn_t pfn = PFN_DOWN(res->start);
 110
 111                 for (i = 0; i < alloc_pages; i++) {
 112                         if (!set_phys_to_machine(pfn + i, INVALID_P2M_ENTRY)) {
 113                                 pr_warn("set_phys_to_machine() failed, no memory added\n");
 114                                 ret = -ENOMEM;
 115                                 goto err_memremap;
 116                         }
 117                 }
 118         }
 119 #endif
 120
 121         vaddr = memremap_pages(pgmap, NUMA_NO_NODE);
 122         if (IS_ERR(vaddr)) {
 123                 pr_err("Cannot remap memory range\n");
 124                 ret = PTR_ERR(vaddr);
 125                 goto err_memremap;
 126         }
 127
 128         for (i = 0; i < alloc_pages; i++) {
 129                 struct page *pg = virt_to_page(vaddr + PAGE_SIZE * i);
 130
 131                 pg->zone_device_data = page_list;
 132                 page_list = pg;
 133                 list_count++;
 134         }
 135
 136         return 0;
 137
 138 err_memremap:
 139         kfree(pgmap);
 140 err_pgmap:
 141         if (tmp_res) {
 142                 release_resource(tmp_res);
 143                 kfree(tmp_res);
 144         }
 145 err_insert:
 146         release_resource(res);
 147 err_resource:
 148         kfree(res);
 149         return ret;
 150 }
 151
 152 /**
 153  * xen_alloc_unpopulated_pages - alloc unpopulated pages
 154  * @nr_pages: Number of pages
 155  * @pages: pages returned
 156  * @return 0 on success, error otherwise
 157  */
 158 int xen_alloc_unpopulated_pages(unsigned int nr_pages, struct page **pages)
 159 {
 160         unsigned int i;
 161         int ret = 0;
 162
 163         /*
 164          * Fallback to default behavior if we do not have any suitable resource
 165          * to allocate required region from and as the result we won't be able to
 166          * construct pages.
 167          */
 168         if (!target_resource)
 169                 return xen_alloc_ballooned_pages(nr_pages, pages);
 170
 171         mutex_lock(&list_lock);
 172         if (list_count < nr_pages) {
 173                 ret = fill_list(nr_pages - list_count);
 174                 if (ret)
 175                         goto out;
 176         }
 177
 178         for (i = 0; i < nr_pages; i++) {
 179                 struct page *pg = page_list;
 180
 181                 BUG_ON(!pg);
 182                 page_list = pg->zone_device_data;
 183                 list_count--;
 184                 pages[i] = pg;
 185
 186 #ifdef CONFIG_XEN_HAVE_PVMMU
 187                 if (!xen_feature(XENFEAT_auto_translated_physmap)) {
 188                         ret = xen_alloc_p2m_entry(page_to_pfn(pg));
 189                         if (ret < 0) {
 190                                 unsigned int j;
 191
 192                                 for (j = 0; j <= i; j++) {
 193                                         pages[j]->zone_device_data = page_list;
 194                                         page_list = pages[j];
 195                                         list_count++;
 196                                 }
 197                                 goto out;
 198                         }
 199                 }
 200 #endif
 201         }
 202
 203 out:
 204         mutex_unlock(&list_lock);
 205         return ret;
 206 }
 207 EXPORT_SYMBOL(xen_alloc_unpopulated_pages);
 208
 209 /**
 210  * xen_free_unpopulated_pages - return unpopulated pages
 211  * @nr_pages: Number of pages
 212  * @pages: pages to return
 213  */
 214 void xen_free_unpopulated_pages(unsigned int nr_pages, struct page **pages)
 215 {
 216         unsigned int i;
 217
 218         if (!target_resource) {
 219                 xen_free_ballooned_pages(nr_pages, pages);
 220                 return;
 221         }
 222
 223         mutex_lock(&list_lock);
 224         for (i = 0; i < nr_pages; i++) {
 225                 pages[i]->zone_device_data = page_list;
 226                 page_list = pages[i];
 227                 list_count++;
 228         }
 229         mutex_unlock(&list_lock);
 230 }
 231 EXPORT_SYMBOL(xen_free_unpopulated_pages);
 232
 233 static int __init unpopulated_init(void)
 234 {
 235         int ret;
 236
 237         if (!xen_domain())
 238                 return -ENODEV;
 239
 240         ret = arch_xen_unpopulated_init(&target_resource);
 241         if (ret) {
 242                 pr_err("xen:unpopulated: Cannot initialize target resource\n");
 243                 target_resource = NULL;
 244         }
 245
 246         return ret;
 247 }
 248 early_initcall(unpopulated_init);