source: trunk/packages/xen-3.1/xen-3.1/linux-2.6-xen-sparse/arch/ia64/xen/xcom_hcall.c @ 34

Last change on this file since 34 was 34, checked in by hartmans, 18 years ago

Add xen and xen-common

File size: 9.3 KB
Line 
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
15 *
16 *          Tristan Gingold <tristan.gingold@bull.net>
17 */
18#include <linux/types.h>
19#include <linux/errno.h>
20#include <linux/kernel.h>
21#include <linux/gfp.h>
22#include <linux/module.h>
23#include <xen/interface/xen.h>
24#include <xen/interface/platform.h>
25#include <xen/interface/memory.h>
26#include <xen/interface/xencomm.h>
27#include <xen/interface/version.h>
28#include <xen/interface/sched.h>
29#include <xen/interface/event_channel.h>
30#include <xen/interface/physdev.h>
31#include <xen/interface/grant_table.h>
32#include <xen/interface/callback.h>
33#include <xen/interface/acm_ops.h>
34#include <xen/interface/hvm/params.h>
35#include <xen/interface/xenoprof.h>
36#include <xen/interface/vcpu.h>
37#include <asm/hypercall.h>
38#include <asm/page.h>
39#include <asm/uaccess.h>
40#include <asm/xen/xencomm.h>
41#include <asm/perfmon.h>
42
43/* Xencomm notes:
44 * This file defines hypercalls to be used by xencomm.  The hypercalls simply
45 * create inlines descriptors for pointers and then call the raw arch hypercall
46 * xencomm_arch_hypercall_XXX
47 *
48 * If the arch wants to directly use these hypercalls, simply define macros
49 * in asm/hypercall.h, eg:
50 *  #define HYPERVISOR_sched_op xencomm_hypercall_sched_op
51 *
52 * The arch may also define HYPERVISOR_xxx as a function and do more operations
53 * before/after doing the hypercall.
54 *
55 * Note: because only inline descriptors are created these functions must only
56 * be called with in kernel memory parameters.
57 */
58
59int
60xencomm_hypercall_console_io(int cmd, int count, char *str)
61{
62        return xencomm_arch_hypercall_console_io
63                (cmd, count, xencomm_create_inline(str));
64}
65
66int
67xencomm_hypercall_event_channel_op(int cmd, void *op)
68{
69        return xencomm_arch_hypercall_event_channel_op
70                (cmd, xencomm_create_inline(op));
71}
72
73int
74xencomm_hypercall_xen_version(int cmd, void *arg)
75{
76        switch (cmd) {
77        case XENVER_version:
78        case XENVER_extraversion:
79        case XENVER_compile_info:
80        case XENVER_capabilities:
81        case XENVER_changeset:
82        case XENVER_platform_parameters:
83        case XENVER_pagesize:
84        case XENVER_get_features:
85                break;
86        default:
87                printk("%s: unknown version cmd %d\n", __func__, cmd);
88                return -ENOSYS;
89        }
90
91        return xencomm_arch_hypercall_xen_version
92                (cmd, xencomm_create_inline(arg));
93}
94
95int
96xencomm_hypercall_physdev_op(int cmd, void *op)
97{
98        return xencomm_arch_hypercall_physdev_op
99                (cmd, xencomm_create_inline(op));
100}
101
102static void *
103xencommize_grant_table_op(unsigned int cmd, void *op, unsigned int count)
104{
105        switch (cmd) {
106        case GNTTABOP_map_grant_ref:
107        case GNTTABOP_unmap_grant_ref:
108                break;
109        case GNTTABOP_setup_table:
110        {
111                struct gnttab_setup_table *setup = op;
112                struct xencomm_handle *frame_list;
113
114                frame_list = xencomm_create_inline
115                        (xen_guest_handle(setup->frame_list));
116
117                set_xen_guest_handle(setup->frame_list, (void *)frame_list);
118                break;
119        }
120        case GNTTABOP_dump_table:
121        case GNTTABOP_transfer:
122        case GNTTABOP_copy:
123                break;
124        default:
125                printk("%s: unknown grant table op %d\n", __func__, cmd);
126                BUG();
127        }
128
129        return  xencomm_create_inline(op);
130}
131
132int
133xencomm_hypercall_grant_table_op(unsigned int cmd, void *op, unsigned int count)
134{
135        void *desc = xencommize_grant_table_op (cmd, op, count);
136
137        return xencomm_arch_hypercall_grant_table_op(cmd, desc, count);
138}
139
140int
141xencomm_hypercall_sched_op(int cmd, void *arg)
142{
143        switch (cmd) {
144        case SCHEDOP_yield:
145        case SCHEDOP_block:
146        case SCHEDOP_shutdown:
147        case SCHEDOP_remote_shutdown:
148                break;
149        case SCHEDOP_poll:
150        {
151                sched_poll_t *poll = arg;
152                struct xencomm_handle *ports;
153
154                ports = xencomm_create_inline(xen_guest_handle(poll->ports));
155
156                set_xen_guest_handle(poll->ports, (void *)ports);
157                break;
158        }
159        default:
160                printk("%s: unknown sched op %d\n", __func__, cmd);
161                return -ENOSYS;
162        }
163       
164        return xencomm_arch_hypercall_sched_op(cmd, xencomm_create_inline(arg));
165}
166
167int
168xencomm_hypercall_multicall(void *call_list, int nr_calls)
169{
170        int i;
171        multicall_entry_t *mce;
172
173        for (i = 0; i < nr_calls; i++) {
174                mce = (multicall_entry_t *)call_list + i;
175
176                switch (mce->op) {
177                case __HYPERVISOR_update_va_mapping:
178                case __HYPERVISOR_mmu_update:
179                        /* No-op on ia64.  */
180                        break;
181                case __HYPERVISOR_grant_table_op:
182                        mce->args[1] = (unsigned long)xencommize_grant_table_op
183                                (mce->args[0], (void *)mce->args[1],
184                                 mce->args[2]);
185                        break;
186                case __HYPERVISOR_memory_op:
187                default:
188                        printk("%s: unhandled multicall op entry op %lu\n",
189                               __func__, mce->op);
190                        return -ENOSYS;
191                }
192        }
193
194        return xencomm_arch_hypercall_multicall
195                (xencomm_create_inline(call_list), nr_calls);
196}
197
198int
199xencomm_hypercall_callback_op(int cmd, void *arg)
200{
201        switch (cmd)
202        {
203        case CALLBACKOP_register:
204        case CALLBACKOP_unregister:
205                break;
206        default:
207                printk("%s: unknown callback op %d\n", __func__, cmd);
208                return -ENOSYS;
209        }
210
211        return xencomm_arch_hypercall_callback_op
212                (cmd, xencomm_create_inline(arg));
213}
214
215static void
216xencommize_memory_reservation (xen_memory_reservation_t *mop)
217{
218        struct xencomm_handle *desc;
219
220        desc = xencomm_create_inline(xen_guest_handle(mop->extent_start));
221        set_xen_guest_handle(mop->extent_start, (void *)desc);
222}
223
224int
225xencomm_hypercall_memory_op(unsigned int cmd, void *arg)
226{
227        XEN_GUEST_HANDLE(xen_pfn_t) extent_start_va[2];
228        xen_memory_reservation_t *xmr = NULL, *xme_in = NULL, *xme_out = NULL;
229        int rc;
230
231        switch (cmd) {
232        case XENMEM_increase_reservation:
233        case XENMEM_decrease_reservation:
234        case XENMEM_populate_physmap:
235                xmr = (xen_memory_reservation_t *)arg;
236                xen_guest_handle(extent_start_va[0]) =
237                        xen_guest_handle(xmr->extent_start);
238                xencommize_memory_reservation((xen_memory_reservation_t *)arg);
239                break;
240               
241        case XENMEM_maximum_ram_page:
242                break;
243
244        case XENMEM_exchange:
245                xme_in  = &((xen_memory_exchange_t *)arg)->in;
246                xme_out = &((xen_memory_exchange_t *)arg)->out;
247                xen_guest_handle(extent_start_va[0]) =
248                        xen_guest_handle(xme_in->extent_start);
249                xen_guest_handle(extent_start_va[1]) =
250                        xen_guest_handle(xme_out->extent_start);
251                xencommize_memory_reservation
252                        (&((xen_memory_exchange_t *)arg)->in);
253                xencommize_memory_reservation
254                        (&((xen_memory_exchange_t *)arg)->out);
255                break;
256
257        default:
258                printk("%s: unknown memory op %d\n", __func__, cmd);
259                return -ENOSYS;
260        }
261
262        rc =  xencomm_arch_hypercall_memory_op(cmd, xencomm_create_inline(arg));
263
264        switch (cmd) {
265        case XENMEM_increase_reservation:
266        case XENMEM_decrease_reservation:
267        case XENMEM_populate_physmap:
268                xen_guest_handle(xmr->extent_start) =
269                        xen_guest_handle(extent_start_va[0]);
270                break;
271
272        case XENMEM_exchange:
273                xen_guest_handle(xme_in->extent_start) =
274                        xen_guest_handle(extent_start_va[0]);
275                xen_guest_handle(xme_out->extent_start) =
276                        xen_guest_handle(extent_start_va[1]);
277                break;
278        }
279
280        return rc;
281}
282
283unsigned long
284xencomm_hypercall_hvm_op(int cmd, void *arg)
285{
286        switch (cmd) {
287        case HVMOP_set_param:
288        case HVMOP_get_param:
289                break;
290        default:
291                printk("%s: unknown hvm op %d\n", __func__, cmd);
292                return -ENOSYS;
293        }
294
295        return xencomm_arch_hypercall_hvm_op(cmd, xencomm_create_inline(arg));
296}
297
298int
299xencomm_hypercall_suspend(unsigned long srec)
300{
301        struct sched_shutdown arg;
302
303        arg.reason = SHUTDOWN_suspend;
304
305        return xencomm_arch_hypercall_suspend(xencomm_create_inline(&arg));
306}
307
308int
309xencomm_hypercall_xenoprof_op(int op, void *arg)
310{
311        switch (op) {
312        case XENOPROF_init:
313        case XENOPROF_set_active:
314        case XENOPROF_set_passive:
315        case XENOPROF_counter:
316        case XENOPROF_get_buffer:
317                break;
318
319        case XENOPROF_reset_active_list:
320        case XENOPROF_reset_passive_list:
321        case XENOPROF_reserve_counters:
322        case XENOPROF_setup_events:
323        case XENOPROF_enable_virq:
324        case XENOPROF_start:
325        case XENOPROF_stop:
326        case XENOPROF_disable_virq:
327        case XENOPROF_release_counters:
328        case XENOPROF_shutdown:
329                return xencomm_arch_hypercall_xenoprof_op(op, arg);
330                break;
331
332        default:
333                printk("%s: op %d isn't supported\n", __func__, op);
334                return -ENOSYS;
335        }
336        return xencomm_arch_hypercall_xenoprof_op(op,
337                                                  xencomm_create_inline(arg));
338}
339
340int
341xencomm_hypercall_perfmon_op(unsigned long cmd, void* arg, unsigned long count)
342{
343        switch (cmd) {
344        case PFM_GET_FEATURES:
345        case PFM_CREATE_CONTEXT:
346        case PFM_WRITE_PMCS:
347        case PFM_WRITE_PMDS:
348        case PFM_LOAD_CONTEXT:
349                break;
350
351        case PFM_DESTROY_CONTEXT:
352        case PFM_UNLOAD_CONTEXT:
353        case PFM_START:
354        case PFM_STOP:
355                return xencomm_arch_hypercall_perfmon_op(cmd, arg, count);
356
357        default:
358                printk("%s:%d cmd %ld isn't supported\n",
359                       __func__,__LINE__, cmd);
360                BUG();
361        }
362
363        return xencomm_arch_hypercall_perfmon_op(cmd,
364                                                 xencomm_create_inline(arg),
365                                                 count);
366}
367
368long
369xencomm_hypercall_vcpu_op(int cmd, int cpu, void *arg)
370{
371        switch (cmd) {
372        case VCPUOP_register_runstate_memory_area:
373                xencommize_memory_reservation((xen_memory_reservation_t *)arg);
374                break;
375
376        default:
377                printk("%s: unknown vcpu op %d\n", __func__, cmd);
378                return -ENOSYS;
379        }
380
381        return xencomm_arch_hypercall_vcpu_op(cmd, cpu,
382                                              xencomm_create_inline(arg));
383}
Note: See TracBrowser for help on using the repository browser.