drivers/xen/gnttab.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * (C) 2006 - Cambridge University
   4  * (C) 2020 - EPAM Systems Inc.
   5  *
   6  * File: gnttab.c [1]
   7  * Author: Steven Smith (sos22@cam.ac.uk)
   8  * Changes: Grzegorz Milos (gm281@cam.ac.uk)
   9  *
  10  * Date: July 2006
  11  *
  12  * Description: Simple grant tables implementation. About as stupid as it's
  13  * possible to be and still work.
  14  *
  15  * [1] - http://xenbits.xen.org/gitweb/?p=mini-os.git;a=summary
  16  */
  17 #include <common.h>
  18 #include <asm/global_data.h>
  19 #include <linux/compiler.h>
  20 #include <log.h>
  21 #include <malloc.h>
  22
  23 #include <asm/armv8/mmu.h>
  24 #include <asm/io.h>
  25 #include <asm/xen/system.h>
  26
  27 #include <linux/bug.h>
  28
  29 #include <xen/gnttab.h>
  30 #include <xen/hvm.h>
  31
  32 #include <xen/interface/memory.h>
  33
  34 DECLARE_GLOBAL_DATA_PTR;
  35
  36 #define NR_RESERVED_ENTRIES 8
  37
  38 /* NR_GRANT_FRAMES must be less than or equal to that configured in Xen */
  39 #define NR_GRANT_FRAMES 1
  40 #define NR_GRANT_ENTRIES (NR_GRANT_FRAMES * PAGE_SIZE / sizeof(struct grant_entry_v1))
  41
  42 static struct grant_entry_v1 *gnttab_table;
  43 static grant_ref_t gnttab_list[NR_GRANT_ENTRIES];
  44
  45 static void put_free_entry(grant_ref_t ref)
  46 {
  47         unsigned long flags;
  48
  49         local_irq_save(flags);
  50         gnttab_list[ref] = gnttab_list[0];
  51         gnttab_list[0]  = ref;
  52         local_irq_restore(flags);
  53 }
  54
  55 static grant_ref_t get_free_entry(void)
  56 {
  57         unsigned int ref;
  58         unsigned long flags;
  59
  60         local_irq_save(flags);
  61         ref = gnttab_list[0];
  62         BUG_ON(ref < NR_RESERVED_ENTRIES || ref >= NR_GRANT_ENTRIES);
  63         gnttab_list[0] = gnttab_list[ref];
  64         local_irq_restore(flags);
  65         return ref;
  66 }
  67
  68 /**
  69  * gnttab_grant_access() - Allow access to the given frame.
  70  * The function creates an entry in the grant table according
  71  * to the specified parameters.
  72  * @domid: the id of the domain for which access is allowed
  73  * @frame: the number of the shared frame
  74  * @readonly: determines whether the frame is shared read-only or read-write
  75  *
  76  * Return: relevant grant reference
  77  */
  78 grant_ref_t gnttab_grant_access(domid_t domid, unsigned long frame, int readonly)
  79 {
  80         grant_ref_t ref;
  81
  82         ref = get_free_entry();
  83         gnttab_table[ref].frame = frame;
  84         gnttab_table[ref].domid = domid;
  85         wmb();
  86         readonly *= GTF_readonly;
  87         gnttab_table[ref].flags = GTF_permit_access | readonly;
  88
  89         return ref;
  90 }
  91
  92 /**
  93  * gnttab_end_access() - End of memory sharing. The function invalidates
  94  * the entry in the grant table.
  95  */
  96 int gnttab_end_access(grant_ref_t ref)
  97 {
  98         u16 flags, nflags;
  99
 100         BUG_ON(ref >= NR_GRANT_ENTRIES || ref < NR_RESERVED_ENTRIES);
 101
 102         nflags = gnttab_table[ref].flags;
 103         do {
 104                 flags = nflags;
 105                 if ((flags) & (GTF_reading | GTF_writing)) {
 106                         printf("WARNING: g.e. still in use! (%x)\n", flags);
 107                         return 0;
 108                 }
 109         } while ((nflags = synch_cmpxchg(&gnttab_table[ref].flags, flags, 0)) !=
 110                  flags);
 111
 112         put_free_entry(ref);
 113         return 1;
 114 }
 115
 116 grant_ref_t gnttab_alloc_and_grant(void **map)
 117 {
 118         unsigned long mfn;
 119         grant_ref_t gref;
 120
 121         *map = (void *)memalign(PAGE_SIZE, PAGE_SIZE);
 122         mfn = virt_to_mfn(*map);
 123         gref = gnttab_grant_access(0, mfn, 0);
 124         return gref;
 125 }
 126
 127 static const char * const gnttabop_error_msgs[] = GNTTABOP_error_msgs;
 128
 129 const char *gnttabop_error(int16_t status)
 130 {
 131         status = -status;
 132         if (status < 0 || status >= ARRAY_SIZE(gnttabop_error_msgs))
 133                 return "bad status";
 134         else
 135                 return gnttabop_error_msgs[status];
 136 }
 137
 138 /* Get Xen's suggested physical page assignments for the grant table. */
 139 void get_gnttab_base(phys_addr_t *gnttab_base, phys_size_t *gnttab_sz)
 140 {
 141         const void *blob = gd->fdt_blob;
 142         struct fdt_resource res;
 143         int mem;
 144
 145         mem = fdt_node_offset_by_compatible(blob, -1, "xen,xen");
 146         if (mem < 0) {
 147                 printf("No xen,xen compatible found\n");
 148                 BUG();
 149         }
 150
 151         mem = fdt_get_resource(blob, mem, "reg", 0, &res);
 152         if (mem == -FDT_ERR_NOTFOUND) {
 153                 printf("No grant table base in the device tree\n");
 154                 BUG();
 155         }
 156
 157         *gnttab_base = (phys_addr_t)res.start;
 158         if (gnttab_sz)
 159                 *gnttab_sz = (phys_size_t)(res.end - res.start + 1);
 160
 161         debug("FDT suggests grant table base at %llx\n",
 162               *gnttab_base);
 163 }
 164
 165 void init_gnttab(void)
 166 {
 167         struct xen_add_to_physmap xatp;
 168         struct gnttab_setup_table setup;
 169         xen_pfn_t frames[NR_GRANT_FRAMES];
 170         int i, rc;
 171
 172         debug("%s\n", __func__);
 173
 174         for (i = NR_RESERVED_ENTRIES; i < NR_GRANT_ENTRIES; i++)
 175                 put_free_entry(i);
 176
 177         get_gnttab_base((phys_addr_t *)&gnttab_table, NULL);
 178
 179         for (i = 0; i < NR_GRANT_FRAMES; i++) {
 180                 xatp.domid = DOMID_SELF;
 181                 xatp.size = 0;
 182                 xatp.space = XENMAPSPACE_grant_table;
 183                 xatp.idx = i;
 184                 xatp.gpfn = PFN_DOWN((unsigned long)gnttab_table) + i;
 185                 rc = HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp);
 186                 if (rc)
 187                         printf("XENMEM_add_to_physmap failed; status = %d\n",
 188                                rc);
 189                 BUG_ON(rc != 0);
 190         }
 191
 192         setup.dom = DOMID_SELF;
 193         setup.nr_frames = NR_GRANT_FRAMES;
 194         set_xen_guest_handle(setup.frame_list, frames);
 195 }
 196
 197 void fini_gnttab(void)
 198 {
 199         struct xen_remove_from_physmap xrtp;
 200         struct gnttab_setup_table setup;
 201         int i, rc;
 202
 203         debug("%s\n", __func__);
 204
 205         for (i = 0; i < NR_GRANT_FRAMES; i++) {
 206                 xrtp.domid = DOMID_SELF;
 207                 xrtp.gpfn = PFN_DOWN((unsigned long)gnttab_table) + i;
 208                 rc = HYPERVISOR_memory_op(XENMEM_remove_from_physmap, &xrtp);
 209                 if (rc)
 210                         printf("XENMEM_remove_from_physmap failed; status = %d\n",
 211                                rc);
 212                 BUG_ON(rc != 0);
 213         }
 214
 215         setup.dom = DOMID_SELF;
 216         setup.nr_frames = 0;
 217 }
 218