blob: 7a92a5e1d40c6f17227936ee2b6925286deab511 [file] [log] [blame]
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -08001/******************************************************************************
2 * privcmd.c
3 *
4 * Interface to privileged domain-0 commands.
5 *
6 * Copyright (c) 2002-2004, K A Fraser, B Dragovic
7 */
8
Joe Perches283c0972013-06-28 03:21:41 -07009#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
10
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080011#include <linux/kernel.h>
Bastian Blankd8414d32011-12-16 11:34:33 -050012#include <linux/module.h>
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080013#include <linux/sched.h>
14#include <linux/slab.h>
15#include <linux/string.h>
16#include <linux/errno.h>
17#include <linux/mm.h>
18#include <linux/mman.h>
19#include <linux/uaccess.h>
20#include <linux/swap.h>
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080021#include <linux/highmem.h>
22#include <linux/pagemap.h>
23#include <linux/seq_file.h>
Bastian Blankd8414d32011-12-16 11:34:33 -050024#include <linux/miscdevice.h>
Paul Durrantab520be2017-02-13 17:03:23 +000025#include <linux/moduleparam.h>
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080026
27#include <asm/pgalloc.h>
28#include <asm/pgtable.h>
29#include <asm/tlb.h>
30#include <asm/xen/hypervisor.h>
31#include <asm/xen/hypercall.h>
32
33#include <xen/xen.h>
34#include <xen/privcmd.h>
35#include <xen/interface/xen.h>
Paul Durrantab520be2017-02-13 17:03:23 +000036#include <xen/interface/hvm/dm_op.h>
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080037#include <xen/features.h>
38#include <xen/page.h>
Ian Campbellde1ef202009-05-21 10:09:46 +010039#include <xen/xen-ops.h>
Mukesh Rathord71f5132012-10-17 17:11:21 -070040#include <xen/balloon.h>
Ian Campbellf020e292009-05-20 15:42:14 +010041
Bastian Blankd8414d32011-12-16 11:34:33 -050042#include "privcmd.h"
43
44MODULE_LICENSE("GPL");
45
Mukesh Rathord71f5132012-10-17 17:11:21 -070046#define PRIV_VMA_LOCKED ((void *)1)
47
Paul Durrantab520be2017-02-13 17:03:23 +000048static unsigned int privcmd_dm_op_max_num = 16;
49module_param_named(dm_op_max_nr_bufs, privcmd_dm_op_max_num, uint, 0644);
50MODULE_PARM_DESC(dm_op_max_nr_bufs,
51 "Maximum number of buffers per dm_op hypercall");
52
53static unsigned int privcmd_dm_op_buf_max_size = 4096;
54module_param_named(dm_op_buf_max_size, privcmd_dm_op_buf_max_size, uint,
55 0644);
56MODULE_PARM_DESC(dm_op_buf_max_size,
57 "Maximum size of a dm_op hypercall buffer");
58
Paul Durrant4610d242017-02-13 17:03:24 +000059struct privcmd_data {
60 domid_t domid;
61};
62
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +010063static int privcmd_vma_range_is_mapped(
64 struct vm_area_struct *vma,
65 unsigned long addr,
66 unsigned long nr_pages);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080067
Paul Durrant4610d242017-02-13 17:03:24 +000068static long privcmd_ioctl_hypercall(struct file *file, void __user *udata)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080069{
Paul Durrant4610d242017-02-13 17:03:24 +000070 struct privcmd_data *data = file->private_data;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080071 struct privcmd_hypercall hypercall;
72 long ret;
73
Paul Durrant4610d242017-02-13 17:03:24 +000074 /* Disallow arbitrary hypercalls if restricted */
75 if (data->domid != DOMID_INVALID)
76 return -EPERM;
77
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080078 if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
79 return -EFAULT;
80
David Vrabelfdfd8112015-02-19 15:23:17 +000081 xen_preemptible_hcall_begin();
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080082 ret = privcmd_call(hypercall.op,
83 hypercall.arg[0], hypercall.arg[1],
84 hypercall.arg[2], hypercall.arg[3],
85 hypercall.arg[4]);
David Vrabelfdfd8112015-02-19 15:23:17 +000086 xen_preemptible_hcall_end();
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -080087
88 return ret;
89}
90
91static void free_page_list(struct list_head *pages)
92{
93 struct page *p, *n;
94
95 list_for_each_entry_safe(p, n, pages, lru)
96 __free_page(p);
97
98 INIT_LIST_HEAD(pages);
99}
100
101/*
102 * Given an array of items in userspace, return a list of pages
103 * containing the data. If copying fails, either because of memory
104 * allocation failure or a problem reading user memory, return an
105 * error code; its up to the caller to dispose of any partial list.
106 */
107static int gather_array(struct list_head *pagelist,
108 unsigned nelem, size_t size,
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400109 const void __user *data)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800110{
111 unsigned pageidx;
112 void *pagedata;
113 int ret;
114
115 if (size > PAGE_SIZE)
116 return 0;
117
118 pageidx = PAGE_SIZE;
119 pagedata = NULL; /* quiet, gcc */
120 while (nelem--) {
121 if (pageidx > PAGE_SIZE-size) {
122 struct page *page = alloc_page(GFP_KERNEL);
123
124 ret = -ENOMEM;
125 if (page == NULL)
126 goto fail;
127
128 pagedata = page_address(page);
129
130 list_add_tail(&page->lru, pagelist);
131 pageidx = 0;
132 }
133
134 ret = -EFAULT;
135 if (copy_from_user(pagedata + pageidx, data, size))
136 goto fail;
137
138 data += size;
139 pageidx += size;
140 }
141
142 ret = 0;
143
144fail:
145 return ret;
146}
147
148/*
149 * Call function "fn" on each element of the array fragmented
150 * over a list of pages.
151 */
152static int traverse_pages(unsigned nelem, size_t size,
153 struct list_head *pos,
154 int (*fn)(void *data, void *state),
155 void *state)
156{
157 void *pagedata;
158 unsigned pageidx;
Ian Campbellf020e292009-05-20 15:42:14 +0100159 int ret = 0;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800160
161 BUG_ON(size > PAGE_SIZE);
162
163 pageidx = PAGE_SIZE;
164 pagedata = NULL; /* hush, gcc */
165
166 while (nelem--) {
167 if (pageidx > PAGE_SIZE-size) {
168 struct page *page;
169 pos = pos->next;
170 page = list_entry(pos, struct page, lru);
171 pagedata = page_address(page);
172 pageidx = 0;
173 }
174
175 ret = (*fn)(pagedata + pageidx, state);
176 if (ret)
177 break;
178 pageidx += size;
179 }
180
181 return ret;
182}
183
David Vrabel4e8c0c82015-03-11 14:49:57 +0000184/*
185 * Similar to traverse_pages, but use each page as a "block" of
186 * data to be processed as one unit.
187 */
188static int traverse_pages_block(unsigned nelem, size_t size,
189 struct list_head *pos,
190 int (*fn)(void *data, int nr, void *state),
191 void *state)
192{
193 void *pagedata;
194 unsigned pageidx;
195 int ret = 0;
196
197 BUG_ON(size > PAGE_SIZE);
198
199 pageidx = PAGE_SIZE;
200
201 while (nelem) {
202 int nr = (PAGE_SIZE/size);
203 struct page *page;
204 if (nr > nelem)
205 nr = nelem;
206 pos = pos->next;
207 page = list_entry(pos, struct page, lru);
208 pagedata = page_address(page);
209 ret = (*fn)(pagedata, nr, state);
210 if (ret)
211 break;
212 nelem -= nr;
213 }
214
215 return ret;
216}
217
Julien Gralla13d7202015-08-07 17:34:41 +0100218struct mmap_gfn_state {
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800219 unsigned long va;
220 struct vm_area_struct *vma;
221 domid_t domain;
222};
223
Julien Gralla13d7202015-08-07 17:34:41 +0100224static int mmap_gfn_range(void *data, void *state)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800225{
226 struct privcmd_mmap_entry *msg = data;
Julien Gralla13d7202015-08-07 17:34:41 +0100227 struct mmap_gfn_state *st = state;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800228 struct vm_area_struct *vma = st->vma;
229 int rc;
230
231 /* Do not allow range to wrap the address space. */
232 if ((msg->npages > (LONG_MAX >> PAGE_SHIFT)) ||
233 ((unsigned long)(msg->npages << PAGE_SHIFT) >= -st->va))
234 return -EINVAL;
235
236 /* Range chunks must be contiguous in va space. */
237 if ((msg->va != st->va) ||
238 ((msg->va+(msg->npages<<PAGE_SHIFT)) > vma->vm_end))
239 return -EINVAL;
240
Julien Gralla13d7202015-08-07 17:34:41 +0100241 rc = xen_remap_domain_gfn_range(vma,
Ian Campbellde1ef202009-05-21 10:09:46 +0100242 msg->va & PAGE_MASK,
243 msg->mfn, msg->npages,
244 vma->vm_page_prot,
Ian Campbell9a032e32012-10-17 13:37:49 -0700245 st->domain, NULL);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800246 if (rc < 0)
247 return rc;
248
249 st->va += msg->npages << PAGE_SHIFT;
250
251 return 0;
252}
253
Paul Durrant4610d242017-02-13 17:03:24 +0000254static long privcmd_ioctl_mmap(struct file *file, void __user *udata)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800255{
Paul Durrant4610d242017-02-13 17:03:24 +0000256 struct privcmd_data *data = file->private_data;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800257 struct privcmd_mmap mmapcmd;
258 struct mm_struct *mm = current->mm;
259 struct vm_area_struct *vma;
260 int rc;
261 LIST_HEAD(pagelist);
Julien Gralla13d7202015-08-07 17:34:41 +0100262 struct mmap_gfn_state state;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800263
Mukesh Rathord71f5132012-10-17 17:11:21 -0700264 /* We only support privcmd_ioctl_mmap_batch for auto translated. */
265 if (xen_feature(XENFEAT_auto_translated_physmap))
266 return -ENOSYS;
267
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800268 if (copy_from_user(&mmapcmd, udata, sizeof(mmapcmd)))
269 return -EFAULT;
270
Paul Durrant4610d242017-02-13 17:03:24 +0000271 /* If restriction is in place, check the domid matches */
272 if (data->domid != DOMID_INVALID && data->domid != mmapcmd.dom)
273 return -EPERM;
274
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800275 rc = gather_array(&pagelist,
276 mmapcmd.num, sizeof(struct privcmd_mmap_entry),
277 mmapcmd.entry);
278
279 if (rc || list_empty(&pagelist))
280 goto out;
281
282 down_write(&mm->mmap_sem);
283
284 {
285 struct page *page = list_first_entry(&pagelist,
286 struct page, lru);
287 struct privcmd_mmap_entry *msg = page_address(page);
288
289 vma = find_vma(mm, msg->va);
290 rc = -EINVAL;
291
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100292 if (!vma || (msg->va != vma->vm_start) || vma->vm_private_data)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800293 goto out_up;
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100294 vma->vm_private_data = PRIV_VMA_LOCKED;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800295 }
296
297 state.va = vma->vm_start;
298 state.vma = vma;
299 state.domain = mmapcmd.dom;
300
301 rc = traverse_pages(mmapcmd.num, sizeof(struct privcmd_mmap_entry),
302 &pagelist,
Julien Gralla13d7202015-08-07 17:34:41 +0100303 mmap_gfn_range, &state);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800304
305
306out_up:
307 up_write(&mm->mmap_sem);
308
309out:
310 free_page_list(&pagelist);
311
312 return rc;
313}
314
315struct mmap_batch_state {
316 domid_t domain;
317 unsigned long va;
318 struct vm_area_struct *vma;
Mukesh Rathord71f5132012-10-17 17:11:21 -0700319 int index;
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400320 /* A tristate:
321 * 0 for no errors
322 * 1 if at least one error has happened (and no
323 * -ENOENT errors have happened)
324 * -ENOENT if at least 1 -ENOENT has happened.
325 */
326 int global_error;
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500327 int version;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800328
Julien Gralla13d7202015-08-07 17:34:41 +0100329 /* User-space gfn array to store errors in the second pass for V1. */
330 xen_pfn_t __user *user_gfn;
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500331 /* User-space int array to store errors in the second pass for V2. */
332 int __user *user_err;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800333};
334
Julien Gralla13d7202015-08-07 17:34:41 +0100335/* auto translated dom0 note: if domU being created is PV, then gfn is
336 * mfn(addr on bus). If it's auto xlated, then gfn is pfn (input to HAP).
Mukesh Rathord71f5132012-10-17 17:11:21 -0700337 */
David Vrabel4e8c0c82015-03-11 14:49:57 +0000338static int mmap_batch_fn(void *data, int nr, void *state)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800339{
Julien Gralla13d7202015-08-07 17:34:41 +0100340 xen_pfn_t *gfnp = data;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800341 struct mmap_batch_state *st = state;
Mukesh Rathord71f5132012-10-17 17:11:21 -0700342 struct vm_area_struct *vma = st->vma;
343 struct page **pages = vma->vm_private_data;
David Vrabel4e8c0c82015-03-11 14:49:57 +0000344 struct page **cur_pages = NULL;
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400345 int ret;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800346
Mukesh Rathord71f5132012-10-17 17:11:21 -0700347 if (xen_feature(XENFEAT_auto_translated_physmap))
David Vrabel4e8c0c82015-03-11 14:49:57 +0000348 cur_pages = &pages[st->index];
Mukesh Rathord71f5132012-10-17 17:11:21 -0700349
David Vrabel4e8c0c82015-03-11 14:49:57 +0000350 BUG_ON(nr < 0);
Julien Gralla13d7202015-08-07 17:34:41 +0100351 ret = xen_remap_domain_gfn_array(st->vma, st->va & PAGE_MASK, gfnp, nr,
352 (int *)gfnp, st->vma->vm_page_prot,
David Vrabel4e8c0c82015-03-11 14:49:57 +0000353 st->domain, cur_pages);
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400354
David Vrabel4e8c0c82015-03-11 14:49:57 +0000355 /* Adjust the global_error? */
356 if (ret != nr) {
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400357 if (ret == -ENOENT)
358 st->global_error = -ENOENT;
359 else {
360 /* Record that at least one error has happened. */
361 if (st->global_error == 0)
362 st->global_error = 1;
363 }
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800364 }
David Vrabel4e8c0c82015-03-11 14:49:57 +0000365 st->va += PAGE_SIZE * nr;
366 st->index += nr;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800367
368 return 0;
369}
370
David Vrabel4e8c0c82015-03-11 14:49:57 +0000371static int mmap_return_error(int err, struct mmap_batch_state *st)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800372{
David Vrabel4e8c0c82015-03-11 14:49:57 +0000373 int ret;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800374
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500375 if (st->version == 1) {
David Vrabel4e8c0c82015-03-11 14:49:57 +0000376 if (err) {
Julien Gralla13d7202015-08-07 17:34:41 +0100377 xen_pfn_t gfn;
David Vrabel4e8c0c82015-03-11 14:49:57 +0000378
Julien Gralla13d7202015-08-07 17:34:41 +0100379 ret = get_user(gfn, st->user_gfn);
David Vrabel4e8c0c82015-03-11 14:49:57 +0000380 if (ret < 0)
381 return ret;
382 /*
383 * V1 encodes the error codes in the 32bit top
Julien Gralla13d7202015-08-07 17:34:41 +0100384 * nibble of the gfn (with its known
David Vrabel4e8c0c82015-03-11 14:49:57 +0000385 * limitations vis-a-vis 64 bit callers).
386 */
Julien Gralla13d7202015-08-07 17:34:41 +0100387 gfn |= (err == -ENOENT) ?
David Vrabel4e8c0c82015-03-11 14:49:57 +0000388 PRIVCMD_MMAPBATCH_PAGED_ERROR :
389 PRIVCMD_MMAPBATCH_MFN_ERROR;
Julien Gralla13d7202015-08-07 17:34:41 +0100390 return __put_user(gfn, st->user_gfn++);
David Vrabel4e8c0c82015-03-11 14:49:57 +0000391 } else
Julien Gralla13d7202015-08-07 17:34:41 +0100392 st->user_gfn++;
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500393 } else { /* st->version == 2 */
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500394 if (err)
395 return __put_user(err, st->user_err++);
396 else
397 st->user_err++;
398 }
399
400 return 0;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800401}
402
David Vrabel4e8c0c82015-03-11 14:49:57 +0000403static int mmap_return_errors(void *data, int nr, void *state)
404{
405 struct mmap_batch_state *st = state;
406 int *errs = data;
407 int i;
408 int ret;
409
410 for (i = 0; i < nr; i++) {
411 ret = mmap_return_error(errs[i], st);
412 if (ret < 0)
413 return ret;
414 }
415 return 0;
416}
417
Julien Gralla13d7202015-08-07 17:34:41 +0100418/* Allocate pfns that are then mapped with gfns from foreign domid. Update
Mukesh Rathord71f5132012-10-17 17:11:21 -0700419 * the vma with the page info to use later.
420 * Returns: 0 if success, otherwise -errno
421 */
422static int alloc_empty_pages(struct vm_area_struct *vma, int numpgs)
423{
424 int rc;
425 struct page **pages;
426
427 pages = kcalloc(numpgs, sizeof(pages[0]), GFP_KERNEL);
428 if (pages == NULL)
429 return -ENOMEM;
430
David Vrabel81b286e2015-06-25 13:12:46 +0100431 rc = alloc_xenballooned_pages(numpgs, pages);
Mukesh Rathord71f5132012-10-17 17:11:21 -0700432 if (rc != 0) {
433 pr_warn("%s Could not alloc %d pfns rc:%d\n", __func__,
434 numpgs, rc);
435 kfree(pages);
436 return -ENOMEM;
437 }
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100438 BUG_ON(vma->vm_private_data != NULL);
Mukesh Rathord71f5132012-10-17 17:11:21 -0700439 vma->vm_private_data = pages;
440
441 return 0;
442}
443
Kirill A. Shutemov7cbea8d2015-09-09 15:39:26 -0700444static const struct vm_operations_struct privcmd_vm_ops;
Jeremy Fitzhardingef31fdf52009-03-08 04:10:00 -0700445
Paul Durrant4610d242017-02-13 17:03:24 +0000446static long privcmd_ioctl_mmap_batch(
447 struct file *file, void __user *udata, int version)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800448{
Paul Durrant4610d242017-02-13 17:03:24 +0000449 struct privcmd_data *data = file->private_data;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800450 int ret;
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400451 struct privcmd_mmapbatch_v2 m;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800452 struct mm_struct *mm = current->mm;
453 struct vm_area_struct *vma;
454 unsigned long nr_pages;
455 LIST_HEAD(pagelist);
456 struct mmap_batch_state state;
457
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400458 switch (version) {
459 case 1:
460 if (copy_from_user(&m, udata, sizeof(struct privcmd_mmapbatch)))
461 return -EFAULT;
462 /* Returns per-frame error in m.arr. */
463 m.err = NULL;
464 if (!access_ok(VERIFY_WRITE, m.arr, m.num * sizeof(*m.arr)))
465 return -EFAULT;
466 break;
467 case 2:
468 if (copy_from_user(&m, udata, sizeof(struct privcmd_mmapbatch_v2)))
469 return -EFAULT;
470 /* Returns per-frame error code in m.err. */
471 if (!access_ok(VERIFY_WRITE, m.err, m.num * (sizeof(*m.err))))
472 return -EFAULT;
473 break;
474 default:
475 return -EINVAL;
476 }
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800477
Paul Durrant4610d242017-02-13 17:03:24 +0000478 /* If restriction is in place, check the domid matches */
479 if (data->domid != DOMID_INVALID && data->domid != m.dom)
480 return -EPERM;
481
Julien Grall5995a682015-05-05 16:54:12 +0100482 nr_pages = DIV_ROUND_UP(m.num, XEN_PFN_PER_PAGE);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800483 if ((m.num <= 0) || (nr_pages > (LONG_MAX >> PAGE_SHIFT)))
484 return -EINVAL;
485
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400486 ret = gather_array(&pagelist, m.num, sizeof(xen_pfn_t), m.arr);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800487
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400488 if (ret)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800489 goto out;
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400490 if (list_empty(&pagelist)) {
491 ret = -EINVAL;
492 goto out;
493 }
494
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500495 if (version == 2) {
496 /* Zero error array now to only copy back actual errors. */
497 if (clear_user(m.err, sizeof(int) * m.num)) {
498 ret = -EFAULT;
499 goto out;
500 }
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400501 }
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800502
503 down_write(&mm->mmap_sem);
504
505 vma = find_vma(mm, m.addr);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800506 if (!vma ||
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100507 vma->vm_ops != &privcmd_vm_ops) {
Mats Petersson68fa9652012-11-16 18:36:49 +0000508 ret = -EINVAL;
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100509 goto out_unlock;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800510 }
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100511
512 /*
513 * Caller must either:
514 *
515 * Map the whole VMA range, which will also allocate all the
516 * pages required for the auto_translated_physmap case.
517 *
518 * Or
519 *
520 * Map unmapped holes left from a previous map attempt (e.g.,
521 * because those foreign frames were previously paged out).
522 */
523 if (vma->vm_private_data == NULL) {
524 if (m.addr != vma->vm_start ||
525 m.addr + (nr_pages << PAGE_SHIFT) != vma->vm_end) {
526 ret = -EINVAL;
527 goto out_unlock;
528 }
529 if (xen_feature(XENFEAT_auto_translated_physmap)) {
Julien Grall5995a682015-05-05 16:54:12 +0100530 ret = alloc_empty_pages(vma, nr_pages);
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100531 if (ret < 0)
532 goto out_unlock;
533 } else
534 vma->vm_private_data = PRIV_VMA_LOCKED;
535 } else {
536 if (m.addr < vma->vm_start ||
537 m.addr + (nr_pages << PAGE_SHIFT) > vma->vm_end) {
538 ret = -EINVAL;
539 goto out_unlock;
540 }
541 if (privcmd_vma_range_is_mapped(vma, m.addr, nr_pages)) {
542 ret = -EINVAL;
543 goto out_unlock;
Mukesh Rathord71f5132012-10-17 17:11:21 -0700544 }
545 }
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800546
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400547 state.domain = m.dom;
548 state.vma = vma;
549 state.va = m.addr;
Mukesh Rathord71f5132012-10-17 17:11:21 -0700550 state.index = 0;
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400551 state.global_error = 0;
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500552 state.version = version;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800553
Julien Grall5995a682015-05-05 16:54:12 +0100554 BUILD_BUG_ON(((PAGE_SIZE / sizeof(xen_pfn_t)) % XEN_PFN_PER_PAGE) != 0);
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400555 /* mmap_batch_fn guarantees ret == 0 */
David Vrabel4e8c0c82015-03-11 14:49:57 +0000556 BUG_ON(traverse_pages_block(m.num, sizeof(xen_pfn_t),
557 &pagelist, mmap_batch_fn, &state));
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800558
559 up_write(&mm->mmap_sem);
560
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500561 if (state.global_error) {
562 /* Write back errors in second pass. */
Julien Gralla13d7202015-08-07 17:34:41 +0100563 state.user_gfn = (xen_pfn_t *)m.arr;
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500564 state.user_err = m.err;
David Vrabel4e8c0c82015-03-11 14:49:57 +0000565 ret = traverse_pages_block(m.num, sizeof(xen_pfn_t),
566 &pagelist, mmap_return_errors, &state);
Andres Lagar-Cavilla99beae62013-01-14 22:35:40 -0500567 } else
568 ret = 0;
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400569
570 /* If we have not had any EFAULT-like global errors then set the global
571 * error to -ENOENT if necessary. */
572 if ((ret == 0) && (state.global_error == -ENOENT))
573 ret = -ENOENT;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800574
575out:
576 free_page_list(&pagelist);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800577 return ret;
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100578
579out_unlock:
580 up_write(&mm->mmap_sem);
581 goto out;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800582}
583
Paul Durrantab520be2017-02-13 17:03:23 +0000584static int lock_pages(
585 struct privcmd_dm_op_buf kbufs[], unsigned int num,
586 struct page *pages[], unsigned int nr_pages)
587{
588 unsigned int i;
589
590 for (i = 0; i < num; i++) {
591 unsigned int requested;
592 int pinned;
593
594 requested = DIV_ROUND_UP(
595 offset_in_page(kbufs[i].uptr) + kbufs[i].size,
596 PAGE_SIZE);
597 if (requested > nr_pages)
598 return -ENOSPC;
599
600 pinned = get_user_pages_fast(
601 (unsigned long) kbufs[i].uptr,
602 requested, FOLL_WRITE, pages);
603 if (pinned < 0)
604 return pinned;
605
606 nr_pages -= pinned;
607 pages += pinned;
608 }
609
610 return 0;
611}
612
613static void unlock_pages(struct page *pages[], unsigned int nr_pages)
614{
615 unsigned int i;
616
617 if (!pages)
618 return;
619
620 for (i = 0; i < nr_pages; i++) {
621 if (pages[i])
622 put_page(pages[i]);
623 }
624}
625
Paul Durrant4610d242017-02-13 17:03:24 +0000626static long privcmd_ioctl_dm_op(struct file *file, void __user *udata)
Paul Durrantab520be2017-02-13 17:03:23 +0000627{
Paul Durrant4610d242017-02-13 17:03:24 +0000628 struct privcmd_data *data = file->private_data;
Paul Durrantab520be2017-02-13 17:03:23 +0000629 struct privcmd_dm_op kdata;
630 struct privcmd_dm_op_buf *kbufs;
631 unsigned int nr_pages = 0;
632 struct page **pages = NULL;
633 struct xen_dm_op_buf *xbufs = NULL;
634 unsigned int i;
635 long rc;
636
637 if (copy_from_user(&kdata, udata, sizeof(kdata)))
638 return -EFAULT;
639
Paul Durrant4610d242017-02-13 17:03:24 +0000640 /* If restriction is in place, check the domid matches */
641 if (data->domid != DOMID_INVALID && data->domid != kdata.dom)
642 return -EPERM;
643
Paul Durrantab520be2017-02-13 17:03:23 +0000644 if (kdata.num == 0)
645 return 0;
646
647 if (kdata.num > privcmd_dm_op_max_num)
648 return -E2BIG;
649
650 kbufs = kcalloc(kdata.num, sizeof(*kbufs), GFP_KERNEL);
651 if (!kbufs)
652 return -ENOMEM;
653
654 if (copy_from_user(kbufs, kdata.ubufs,
655 sizeof(*kbufs) * kdata.num)) {
656 rc = -EFAULT;
657 goto out;
658 }
659
660 for (i = 0; i < kdata.num; i++) {
661 if (kbufs[i].size > privcmd_dm_op_buf_max_size) {
662 rc = -E2BIG;
663 goto out;
664 }
665
666 if (!access_ok(VERIFY_WRITE, kbufs[i].uptr,
667 kbufs[i].size)) {
668 rc = -EFAULT;
669 goto out;
670 }
671
672 nr_pages += DIV_ROUND_UP(
673 offset_in_page(kbufs[i].uptr) + kbufs[i].size,
674 PAGE_SIZE);
675 }
676
677 pages = kcalloc(nr_pages, sizeof(*pages), GFP_KERNEL);
678 if (!pages) {
679 rc = -ENOMEM;
680 goto out;
681 }
682
683 xbufs = kcalloc(kdata.num, sizeof(*xbufs), GFP_KERNEL);
684 if (!xbufs) {
685 rc = -ENOMEM;
686 goto out;
687 }
688
689 rc = lock_pages(kbufs, kdata.num, pages, nr_pages);
690 if (rc)
691 goto out;
692
693 for (i = 0; i < kdata.num; i++) {
694 set_xen_guest_handle(xbufs[i].h, kbufs[i].uptr);
695 xbufs[i].size = kbufs[i].size;
696 }
697
698 xen_preemptible_hcall_begin();
699 rc = HYPERVISOR_dm_op(kdata.dom, kdata.num, xbufs);
700 xen_preemptible_hcall_end();
701
702out:
703 unlock_pages(pages, nr_pages);
704 kfree(xbufs);
705 kfree(pages);
706 kfree(kbufs);
707
708 return rc;
709}
710
Paul Durrant4610d242017-02-13 17:03:24 +0000711static long privcmd_ioctl_restrict(struct file *file, void __user *udata)
712{
713 struct privcmd_data *data = file->private_data;
714 domid_t dom;
715
716 if (copy_from_user(&dom, udata, sizeof(dom)))
717 return -EFAULT;
718
719 /* Set restriction to the specified domain, or check it matches */
720 if (data->domid == DOMID_INVALID)
721 data->domid = dom;
722 else if (data->domid != dom)
723 return -EINVAL;
724
725 return 0;
726}
727
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800728static long privcmd_ioctl(struct file *file,
729 unsigned int cmd, unsigned long data)
730{
Paul Durrantdc9eab62017-02-13 17:03:22 +0000731 int ret = -ENOTTY;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800732 void __user *udata = (void __user *) data;
733
734 switch (cmd) {
735 case IOCTL_PRIVCMD_HYPERCALL:
Paul Durrant4610d242017-02-13 17:03:24 +0000736 ret = privcmd_ioctl_hypercall(file, udata);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800737 break;
738
739 case IOCTL_PRIVCMD_MMAP:
Paul Durrant4610d242017-02-13 17:03:24 +0000740 ret = privcmd_ioctl_mmap(file, udata);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800741 break;
742
743 case IOCTL_PRIVCMD_MMAPBATCH:
Paul Durrant4610d242017-02-13 17:03:24 +0000744 ret = privcmd_ioctl_mmap_batch(file, udata, 1);
Andres Lagar-Cavillaceb90fa2012-08-31 09:59:30 -0400745 break;
746
747 case IOCTL_PRIVCMD_MMAPBATCH_V2:
Paul Durrant4610d242017-02-13 17:03:24 +0000748 ret = privcmd_ioctl_mmap_batch(file, udata, 2);
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800749 break;
750
Paul Durrantab520be2017-02-13 17:03:23 +0000751 case IOCTL_PRIVCMD_DM_OP:
Paul Durrant4610d242017-02-13 17:03:24 +0000752 ret = privcmd_ioctl_dm_op(file, udata);
753 break;
754
755 case IOCTL_PRIVCMD_RESTRICT:
756 ret = privcmd_ioctl_restrict(file, udata);
Paul Durrantab520be2017-02-13 17:03:23 +0000757 break;
758
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800759 default:
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800760 break;
761 }
762
763 return ret;
764}
765
Paul Durrant4610d242017-02-13 17:03:24 +0000766static int privcmd_open(struct inode *ino, struct file *file)
767{
768 struct privcmd_data *data = kzalloc(sizeof(*data), GFP_KERNEL);
769
770 if (!data)
771 return -ENOMEM;
772
773 /* DOMID_INVALID implies no restriction */
774 data->domid = DOMID_INVALID;
775
776 file->private_data = data;
777 return 0;
778}
779
780static int privcmd_release(struct inode *ino, struct file *file)
781{
782 struct privcmd_data *data = file->private_data;
783
784 kfree(data);
785 return 0;
786}
787
Mukesh Rathord71f5132012-10-17 17:11:21 -0700788static void privcmd_close(struct vm_area_struct *vma)
789{
790 struct page **pages = vma->vm_private_data;
Muhammad Falak R Wanic7ebf9d2016-05-24 05:34:32 +0530791 int numpgs = vma_pages(vma);
Julien Grall5995a682015-05-05 16:54:12 +0100792 int numgfns = (vma->vm_end - vma->vm_start) >> XEN_PAGE_SHIFT;
Ian Campbellb6497b32013-12-06 17:55:56 +0000793 int rc;
Mukesh Rathord71f5132012-10-17 17:11:21 -0700794
Dan Carpenter9eff37a2012-11-05 09:42:17 +0300795 if (!xen_feature(XENFEAT_auto_translated_physmap) || !numpgs || !pages)
Mukesh Rathord71f5132012-10-17 17:11:21 -0700796 return;
797
Julien Grall5995a682015-05-05 16:54:12 +0100798 rc = xen_unmap_domain_gfn_range(vma, numgfns, pages);
Ian Campbellb6497b32013-12-06 17:55:56 +0000799 if (rc == 0)
800 free_xenballooned_pages(numpgs, pages);
801 else
802 pr_crit("unable to unmap MFN range: leaking %d pages. rc=%d\n",
803 numpgs, rc);
Mukesh Rathord71f5132012-10-17 17:11:21 -0700804 kfree(pages);
805}
806
Dave Jiang11bac802017-02-24 14:56:41 -0800807static int privcmd_fault(struct vm_fault *vmf)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800808{
Jeremy Fitzhardinge441c7412009-03-06 09:56:59 -0800809 printk(KERN_DEBUG "privcmd_fault: vma=%p %lx-%lx, pgoff=%lx, uv=%p\n",
Dave Jiang11bac802017-02-24 14:56:41 -0800810 vmf->vma, vmf->vma->vm_start, vmf->vma->vm_end,
Jan Kara1a29d852016-12-14 15:07:01 -0800811 vmf->pgoff, (void *)vmf->address);
Jeremy Fitzhardinge441c7412009-03-06 09:56:59 -0800812
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800813 return VM_FAULT_SIGBUS;
814}
815
Kirill A. Shutemov7cbea8d2015-09-09 15:39:26 -0700816static const struct vm_operations_struct privcmd_vm_ops = {
Mukesh Rathord71f5132012-10-17 17:11:21 -0700817 .close = privcmd_close,
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800818 .fault = privcmd_fault
819};
820
821static int privcmd_mmap(struct file *file, struct vm_area_struct *vma)
822{
Stefano Stabellinie060e7af2010-11-11 12:37:43 -0800823 /* DONTCOPY is essential for Xen because copy_page_range doesn't know
824 * how to recreate these mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -0700825 vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTCOPY |
826 VM_DONTEXPAND | VM_DONTDUMP;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800827 vma->vm_ops = &privcmd_vm_ops;
828 vma->vm_private_data = NULL;
829
830 return 0;
831}
832
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100833/*
834 * For MMAPBATCH*. This allows asserting the singleshot mapping
835 * on a per pfn/pte basis. Mapping calls that fail with ENOENT
836 * can be then retried until success.
837 */
838static int is_mapped_fn(pte_t *pte, struct page *pmd_page,
839 unsigned long addr, void *data)
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800840{
Andres Lagar-Cavillaa5deabe2013-08-23 18:10:06 +0100841 return pte_none(*pte) ? 0 : -EBUSY;
842}
843
844static int privcmd_vma_range_is_mapped(
845 struct vm_area_struct *vma,
846 unsigned long addr,
847 unsigned long nr_pages)
848{
849 return apply_to_page_range(vma->vm_mm, addr, nr_pages << PAGE_SHIFT,
850 is_mapped_fn, NULL) != 0;
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800851}
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800852
Bastian Blankd8414d32011-12-16 11:34:33 -0500853const struct file_operations xen_privcmd_fops = {
854 .owner = THIS_MODULE,
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800855 .unlocked_ioctl = privcmd_ioctl,
Paul Durrant4610d242017-02-13 17:03:24 +0000856 .open = privcmd_open,
857 .release = privcmd_release,
Jeremy Fitzhardinge1c5de192009-02-09 12:05:49 -0800858 .mmap = privcmd_mmap,
859};
Bastian Blankd8414d32011-12-16 11:34:33 -0500860EXPORT_SYMBOL_GPL(xen_privcmd_fops);
861
862static struct miscdevice privcmd_dev = {
863 .minor = MISC_DYNAMIC_MINOR,
864 .name = "xen/privcmd",
865 .fops = &xen_privcmd_fops,
866};
867
868static int __init privcmd_init(void)
869{
870 int err;
871
872 if (!xen_domain())
873 return -ENODEV;
874
875 err = misc_register(&privcmd_dev);
876 if (err != 0) {
Joe Perches283c0972013-06-28 03:21:41 -0700877 pr_err("Could not register Xen privcmd device\n");
Bastian Blankd8414d32011-12-16 11:34:33 -0500878 return err;
879 }
880 return 0;
881}
882
883static void __exit privcmd_exit(void)
884{
885 misc_deregister(&privcmd_dev);
886}
887
888module_init(privcmd_init);
889module_exit(privcmd_exit);