sys/dev/xen/privcmd/privcmd.c

   1 /*
   2  * Copyright (c) 2014 Roger Pau Monné <roger.pau@citrix.com>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/uio.h>
  33 #include <sys/bus.h>
  34 #include <sys/malloc.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/mutex.h>
  38 #include <sys/rwlock.h>
  39 #include <sys/selinfo.h>
  40 #include <sys/poll.h>
  41 #include <sys/conf.h>
  42 #include <sys/fcntl.h>
  43 #include <sys/ioccom.h>
  44 #include <sys/rman.h>
  45 #include <sys/tree.h>
  46 #include <sys/module.h>
  47 #include <sys/proc.h>
  48 #include <sys/bitset.h>
  49
  50 #include <vm/vm.h>
  51 #include <vm/vm_param.h>
  52 #include <vm/vm_extern.h>
  53 #include <vm/vm_kern.h>
  54 #include <vm/vm_page.h>
  55 #include <vm/vm_map.h>
  56 #include <vm/vm_object.h>
  57 #include <vm/vm_pager.h>
  58
  59 #include <machine/md_var.h>
  60
  61 #include <xen/xen-os.h>
  62 #include <xen/hypervisor.h>
  63 #include <xen/privcmd.h>
  64 #include <xen/error.h>
  65
  66 MALLOC_DEFINE(M_PRIVCMD, "privcmd_dev", "Xen privcmd user-space device");
  67
  68 struct privcmd_map {
  69         vm_object_t mem;
  70         vm_size_t size;
  71         struct resource *pseudo_phys_res;
  72         int pseudo_phys_res_id;
  73         vm_paddr_t phys_base_addr;
  74         boolean_t mapped;
  75         BITSET_DEFINE_VAR() *err;
  76 };
  77
  78 static d_ioctl_t     privcmd_ioctl;
  79 static d_mmap_single_t  privcmd_mmap_single;
  80
  81 static struct cdevsw privcmd_devsw = {
  82         .d_version = D_VERSION,
  83         .d_ioctl = privcmd_ioctl,
  84         .d_mmap_single = privcmd_mmap_single,
  85         .d_name = "privcmd",
  86 };
  87
  88 static int privcmd_pg_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot,
  89     vm_ooffset_t foff, struct ucred *cred, u_short *color);
  90 static void privcmd_pg_dtor(void *handle);
  91 static int privcmd_pg_fault(vm_object_t object, vm_ooffset_t offset,
  92     int prot, vm_page_t *mres);
  93
  94 static struct cdev_pager_ops privcmd_pg_ops = {
  95         .cdev_pg_fault = privcmd_pg_fault,
  96         .cdev_pg_ctor = privcmd_pg_ctor,
  97         .cdev_pg_dtor = privcmd_pg_dtor,
  98 };
  99
 100 static device_t privcmd_dev = NULL;
 101
 102 /*------------------------- Privcmd Pager functions --------------------------*/
 103 static int
 104 privcmd_pg_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot,
 105     vm_ooffset_t foff, struct ucred *cred, u_short *color)
 106 {
 107
 108         return (0);
 109 }
 110
 111 static void
 112 privcmd_pg_dtor(void *handle)
 113 {
 114         struct xen_remove_from_physmap rm = { .domid = DOMID_SELF };
 115         struct privcmd_map *map = handle;
 116         int error;
 117         vm_size_t i;
 118         vm_page_t m;
 119
 120         /*
 121          * Remove the mappings from the used pages. This will remove the
 122          * underlying p2m bindings in Xen second stage translation.
 123          */
 124         if (map->mapped == true) {
 125                 VM_OBJECT_WLOCK(map->mem);
 126 retry:
 127                 for (i = 0; i < map->size; i++) {
 128                         m = vm_page_lookup(map->mem, i);
 129                         if (m == NULL)
 130                                 continue;
 131                         if (vm_page_sleep_if_busy(m, "pcmdum"))
 132                                 goto retry;
 133                         cdev_pager_free_page(map->mem, m);
 134                 }
 135                 VM_OBJECT_WUNLOCK(map->mem);
 136
 137                 for (i = 0; i < map->size; i++) {
 138                         rm.gpfn = atop(map->phys_base_addr) + i;
 139                         HYPERVISOR_memory_op(XENMEM_remove_from_physmap, &rm);
 140                 }
 141                 free(map->err, M_PRIVCMD);
 142         }
 143
 144         error = xenmem_free(privcmd_dev, map->pseudo_phys_res_id,
 145             map->pseudo_phys_res);
 146         KASSERT(error == 0, ("Unable to release memory resource: %d", error));
 147
 148         free(map, M_PRIVCMD);
 149 }
 150
 151 static int
 152 privcmd_pg_fault(vm_object_t object, vm_ooffset_t offset,
 153     int prot, vm_page_t *mres)
 154 {
 155         struct privcmd_map *map = object->handle;
 156         vm_pindex_t pidx;
 157         vm_page_t page, oldm;
 158
 159         if (map->mapped != true)
 160                 return (VM_PAGER_FAIL);
 161
 162         pidx = OFF_TO_IDX(offset);
 163         if (pidx >= map->size || BIT_ISSET(map->size, pidx, map->err))
 164                 return (VM_PAGER_FAIL);
 165
 166         page = PHYS_TO_VM_PAGE(map->phys_base_addr + offset);
 167         if (page == NULL)
 168                 return (VM_PAGER_FAIL);
 169
 170         KASSERT((page->flags & PG_FICTITIOUS) != 0,
 171             ("not fictitious %p", page));
 172         KASSERT(page->wire_count == 1, ("wire_count not 1 %p", page));
 173         KASSERT(vm_page_busied(page) == 0, ("page %p is busy", page));
 174
 175         if (*mres != NULL) {
 176                 oldm = *mres;
 177                 vm_page_lock(oldm);
 178                 vm_page_free(oldm);
 179                 vm_page_unlock(oldm);
 180                 *mres = NULL;
 181         }
 182
 183         vm_page_insert(page, object, pidx);
 184         page->valid = VM_PAGE_BITS_ALL;
 185         vm_page_xbusy(page);
 186         *mres = page;
 187         return (VM_PAGER_OK);
 188 }
 189
 190 /*----------------------- Privcmd char device methods ------------------------*/
 191 static int
 192 privcmd_mmap_single(struct cdev *cdev, vm_ooffset_t *offset, vm_size_t size,
 193     vm_object_t *object, int nprot)
 194 {
 195         struct privcmd_map *map;
 196
 197         map = malloc(sizeof(*map), M_PRIVCMD, M_WAITOK | M_ZERO);
 198
 199         map->size = OFF_TO_IDX(size);
 200         map->pseudo_phys_res_id = 0;
 201
 202         map->pseudo_phys_res = xenmem_alloc(privcmd_dev,
 203             &map->pseudo_phys_res_id, size);
 204         if (map->pseudo_phys_res == NULL) {
 205                 free(map, M_PRIVCMD);
 206                 return (ENOMEM);
 207         }
 208
 209         map->phys_base_addr = rman_get_start(map->pseudo_phys_res);
 210         map->mem = cdev_pager_allocate(map, OBJT_MGTDEVICE, &privcmd_pg_ops,
 211             size, nprot, *offset, NULL);
 212         if (map->mem == NULL) {
 213                 xenmem_free(privcmd_dev, map->pseudo_phys_res_id,
 214                     map->pseudo_phys_res);
 215                 free(map, M_PRIVCMD);
 216                 return (ENOMEM);
 217         }
 218
 219         *object = map->mem;
 220
 221         return (0);
 222 }
 223
 224 static int
 225 privcmd_ioctl(struct cdev *dev, unsigned long cmd, caddr_t arg,
 226               int mode, struct thread *td)
 227 {
 228         int error, i;
 229
 230         switch (cmd) {
 231         case IOCTL_PRIVCMD_HYPERCALL: {
 232                 struct ioctl_privcmd_hypercall *hcall;
 233
 234                 hcall = (struct ioctl_privcmd_hypercall *)arg;
 235
 236                 error = privcmd_hypercall(hcall->op, hcall->arg[0],
 237                     hcall->arg[1], hcall->arg[2], hcall->arg[3], hcall->arg[4]);
 238                 if (error >= 0) {
 239                         hcall->retval = error;
 240                         error = 0;
 241                 } else {
 242                         error = xen_translate_error(error);
 243                         hcall->retval = 0;
 244                 }
 245                 break;
 246         }
 247         case IOCTL_PRIVCMD_MMAPBATCH: {
 248                 struct ioctl_privcmd_mmapbatch *mmap;
 249                 vm_map_t map;
 250                 vm_map_entry_t entry;
 251                 vm_object_t mem;
 252                 vm_pindex_t pindex;
 253                 vm_prot_t prot;
 254                 boolean_t wired;
 255                 struct xen_add_to_physmap_range add;
 256                 xen_ulong_t *idxs;
 257                 xen_pfn_t *gpfns;
 258                 int *errs, index;
 259                 struct privcmd_map *umap;
 260                 uint16_t num;
 261
 262                 mmap = (struct ioctl_privcmd_mmapbatch *)arg;
 263
 264                 if ((mmap->num == 0) ||
 265                     ((mmap->addr & PAGE_MASK) != 0)) {
 266                         error = EINVAL;
 267                         break;
 268                 }
 269
 270                 map = &td->td_proc->p_vmspace->vm_map;
 271                 error = vm_map_lookup(&map, mmap->addr, VM_PROT_NONE, &entry,
 272                     &mem, &pindex, &prot, &wired);
 273                 if (error != KERN_SUCCESS) {
 274                         error = EINVAL;
 275                         break;
 276                 }
 277                 if ((entry->start != mmap->addr) ||
 278                     (entry->end != mmap->addr + (mmap->num * PAGE_SIZE))) {
 279                         vm_map_lookup_done(map, entry);
 280                         error = EINVAL;
 281                         break;
 282                 }
 283                 vm_map_lookup_done(map, entry);
 284                 if ((mem->type != OBJT_MGTDEVICE) ||
 285                     (mem->un_pager.devp.ops != &privcmd_pg_ops)) {
 286                         error = EINVAL;
 287                         break;
 288                 }
 289                 umap = mem->handle;
 290
 291                 add.domid = DOMID_SELF;
 292                 add.space = XENMAPSPACE_gmfn_foreign;
 293                 add.foreign_domid = mmap->dom;
 294
 295                 /*
 296                  * The 'size' field in the xen_add_to_physmap_range only
 297                  * allows for UINT16_MAX mappings in a single hypercall.
 298                  */
 299                 num = MIN(mmap->num, UINT16_MAX);
 300
 301                 idxs = malloc(sizeof(*idxs) * num, M_PRIVCMD, M_WAITOK);
 302                 gpfns = malloc(sizeof(*gpfns) * num, M_PRIVCMD, M_WAITOK);
 303                 errs = malloc(sizeof(*errs) * num, M_PRIVCMD, M_WAITOK);
 304
 305                 set_xen_guest_handle(add.idxs, idxs);
 306                 set_xen_guest_handle(add.gpfns, gpfns);
 307                 set_xen_guest_handle(add.errs, errs);
 308
 309                 /* Allocate a bitset to store broken page mappings. */
 310                 umap->err = BITSET_ALLOC(mmap->num, M_PRIVCMD,
 311                     M_WAITOK | M_ZERO);
 312
 313                 for (index = 0; index < mmap->num; index += num) {
 314                         num = MIN(mmap->num - index, UINT16_MAX);
 315                         add.size = num;
 316
 317                         error = copyin(&mmap->arr[index], idxs,
 318                             sizeof(idxs[0]) * num);
 319                         if (error != 0)
 320                                 goto mmap_out;
 321
 322                         for (i = 0; i < num; i++)
 323                                 gpfns[i] = atop(umap->phys_base_addr +
 324                                     (i + index) * PAGE_SIZE);
 325
 326                         bzero(errs, sizeof(*errs) * num);
 327
 328                         error = HYPERVISOR_memory_op(
 329                             XENMEM_add_to_physmap_range, &add);
 330                         if (error != 0) {
 331                                 error = xen_translate_error(error);
 332                                 goto mmap_out;
 333                         }
 334
 335                         for (i = 0; i < num; i++) {
 336                                 if (errs[i] != 0) {
 337                                         errs[i] = xen_translate_error(errs[i]);
 338
 339                                         /* Mark the page as invalid. */
 340                                         BIT_SET(mmap->num, index + i,
 341                                             umap->err);
 342                                 }
 343                         }
 344
 345                         error = copyout(errs, &mmap->err[index],
 346                             sizeof(errs[0]) * num);
 347                         if (error != 0)
 348                                 goto mmap_out;
 349                 }
 350
 351                 umap->mapped = true;
 352
 353 mmap_out:
 354                 free(idxs, M_PRIVCMD);
 355                 free(gpfns, M_PRIVCMD);
 356                 free(errs, M_PRIVCMD);
 357                 if (!umap->mapped)
 358                         free(umap->err, M_PRIVCMD);
 359
 360                 break;
 361         }
 362
 363         default:
 364                 error = ENOSYS;
 365                 break;
 366         }
 367
 368         return (error);
 369 }
 370
 371 /*------------------ Private Device Attachment Functions  --------------------*/
 372 static void
 373 privcmd_identify(driver_t *driver, device_t parent)
 374 {
 375
 376         KASSERT(xen_domain(),
 377             ("Trying to attach privcmd device on non Xen domain"));
 378
 379         if (BUS_ADD_CHILD(parent, 0, "privcmd", 0) == NULL)
 380                 panic("unable to attach privcmd user-space device");
 381 }
 382
 383 static int
 384 privcmd_probe(device_t dev)
 385 {
 386
 387         privcmd_dev = dev;
 388         device_set_desc(dev, "Xen privileged interface user-space device");
 389         return (BUS_PROBE_NOWILDCARD);
 390 }
 391
 392 static int
 393 privcmd_attach(device_t dev)
 394 {
 395
 396         make_dev_credf(MAKEDEV_ETERNAL, &privcmd_devsw, 0, NULL, UID_ROOT,
 397             GID_WHEEL, 0600, "xen/privcmd");
 398         return (0);
 399 }
 400
 401 /*-------------------- Private Device Attachment Data  -----------------------*/
 402 static device_method_t privcmd_methods[] = {
 403         DEVMETHOD(device_identify,      privcmd_identify),
 404         DEVMETHOD(device_probe,         privcmd_probe),
 405         DEVMETHOD(device_attach,        privcmd_attach),
 406
 407         DEVMETHOD_END
 408 };
 409
 410 static driver_t privcmd_driver = {
 411         "privcmd",
 412         privcmd_methods,
 413         0,
 414 };
 415
 416 devclass_t privcmd_devclass;
 417
 418 DRIVER_MODULE(privcmd, xenpv, privcmd_driver, privcmd_devclass, 0, 0);
 419 MODULE_DEPEND(privcmd, xenpv, 1, 1, 1);