/[dynamips]/trunk/hv_vm.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /trunk/hv_vm.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 9 - (hide annotations)
Sat Oct 6 16:26:06 2007 UTC (16 years, 5 months ago) by dpavlin
Original Path: upstream/dynamips-0.2.7-RC3/hv_vm.c
File MIME type: text/plain
File size: 19126 byte(s)
dynamips-0.2.7-RC3

1 dpavlin 1 /*
2 dpavlin 7 * Cisco router simulation platform.
3 dpavlin 1 * Copyright (c) 2006 Christophe Fillot (cf@utc.fr)
4     *
5     * Hypervisor generic VM routines.
6     */
7    
8     #include <stdio.h>
9     #include <stdlib.h>
10     #include <unistd.h>
11     #include <string.h>
12     #include <sys/types.h>
13     #include <sys/stat.h>
14     #include <sys/mman.h>
15     #include <signal.h>
16     #include <fcntl.h>
17     #include <errno.h>
18     #include <assert.h>
19     #include <stdarg.h>
20     #include <sys/ioctl.h>
21     #include <sys/types.h>
22     #include <sys/socket.h>
23     #include <arpa/inet.h>
24     #include <pthread.h>
25    
26 dpavlin 7 #include "cpu.h"
27     #include "vm.h"
28 dpavlin 1 #include "dynamips.h"
29     #include "device.h"
30     #include "dev_c7200.h"
31     #include "dev_vtty.h"
32     #include "utils.h"
33     #include "base64.h"
34     #include "net.h"
35     #include "atm.h"
36     #include "frame_relay.h"
37     #include "crc.h"
38     #include "net_io.h"
39     #include "net_io_bridge.h"
40     #ifdef GEN_ETH
41     #include "gen_eth.h"
42     #endif
43     #include "registry.h"
44     #include "hypervisor.h"
45    
46 dpavlin 3 /* Find the specified CPU */
47 dpavlin 7 static cpu_gen_t *find_cpu(hypervisor_conn_t *conn,vm_instance_t *vm,
48     u_int cpu_id)
49 dpavlin 3 {
50 dpavlin 7 cpu_gen_t *cpu;
51 dpavlin 3
52     cpu = cpu_group_find_id(vm->cpu_group,cpu_id);
53    
54     if (!cpu) {
55     vm_release(vm);
56     hypervisor_send_reply(conn,HSC_ERR_BAD_OBJ,1,"Bad CPU specified");
57     return NULL;
58     }
59    
60     return cpu;
61     }
62    
63 dpavlin 1 /* Set debugging level */
64     static int cmd_set_debug_level(hypervisor_conn_t *conn,int argc,char *argv[])
65     {
66     vm_instance_t *vm;
67    
68     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
69     return(-1);
70    
71     vm->debug_level = atoi(argv[1]);
72    
73     vm_release(vm);
74     hypervisor_send_reply(conn,HSC_INFO_OK,1,"O",argv[0]);
75     return(0);
76     }
77    
78     /* Set IOS image filename */
79     static int cmd_set_ios(hypervisor_conn_t *conn,int argc,char *argv[])
80     {
81     vm_instance_t *vm;
82    
83     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
84     return(-1);
85    
86     if (vm_ios_set_image(vm,argv[1]) == -1) {
87     vm_release(vm);
88     hypervisor_send_reply(conn,HSC_ERR_CREATE,1,
89     "unable to store IOS image name for router '%s'",
90     argv[0]);
91     return(-1);
92     }
93    
94     vm_release(vm);
95     hypervisor_send_reply(conn,HSC_INFO_OK,1,"IOS image set for '%s'",argv[0]);
96     return(0);
97     }
98    
99     /* Set IOS configuration filename to load at startup */
100     static int cmd_set_config(hypervisor_conn_t *conn,int argc,char *argv[])
101     {
102     vm_instance_t *vm;
103    
104     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
105     return(-1);
106    
107     if (vm_ios_set_config(vm,argv[1]) == -1) {
108     vm_release(vm);
109     hypervisor_send_reply(conn,HSC_ERR_CREATE,1,
110     "unable to store IOS config for router '%s'",
111     argv[0]);
112     return(-1);
113     }
114    
115     vm_release(vm);
116     hypervisor_send_reply(conn,HSC_INFO_OK,1,"IOS config file set for '%s'",
117     argv[0]);
118     return(0);
119     }
120    
121     /* Set RAM size */
122     static int cmd_set_ram(hypervisor_conn_t *conn,int argc,char *argv[])
123     {
124     vm_instance_t *vm;
125    
126     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
127     return(-1);
128    
129     vm->ram_size = atoi(argv[1]);
130    
131     vm_release(vm);
132     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
133     return(0);
134     }
135    
136     /* Set NVRAM size */
137     static int cmd_set_nvram(hypervisor_conn_t *conn,int argc,char *argv[])
138     {
139     vm_instance_t *vm;
140    
141     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
142     return(-1);
143    
144     vm->nvram_size = atoi(argv[1]);
145    
146     vm_release(vm);
147     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
148     return(0);
149     }
150    
151     /* Enable/disable use of a memory-mapped file to simulate RAM */
152     static int cmd_set_ram_mmap(hypervisor_conn_t *conn,int argc,char *argv[])
153     {
154     vm_instance_t *vm;
155    
156     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
157     return(-1);
158    
159     vm->ram_mmap = atoi(argv[1]);
160    
161     vm_release(vm);
162     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
163     return(0);
164     }
165    
166 dpavlin 7 /* Enable/disable use of sparse memory */
167     static int cmd_set_sparse_mem(hypervisor_conn_t *conn,int argc,char *argv[])
168     {
169     vm_instance_t *vm;
170    
171     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
172     return(-1);
173    
174     vm->sparse_mem = atoi(argv[1]);
175    
176     vm_release(vm);
177     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
178     return(0);
179     }
180    
181 dpavlin 1 /* Set the clock divisor */
182     static int cmd_set_clock_divisor(hypervisor_conn_t *conn,int argc,char *argv[])
183     {
184     vm_instance_t *vm;
185     u_int clock_div;
186    
187     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
188     return(-1);
189    
190     if ((clock_div = atoi(argv[1])) != 0)
191     vm->clock_divisor = clock_div;
192    
193     vm_release(vm);
194     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
195     return(0);
196     }
197    
198 dpavlin 8 /* Enable/disable use of block direct jump (compatibility option) */
199     static int cmd_set_blk_direct_jump(hypervisor_conn_t *conn,
200     int argc,char *argv[])
201     {
202     vm_instance_t *vm;
203    
204     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
205     return(-1);
206    
207     vm->exec_blk_direct_jump = atoi(argv[1]);
208    
209     vm_release(vm);
210     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
211     return(0);
212     }
213    
214 dpavlin 1 /* Set the idle PC */
215     static int cmd_set_idle_pc(hypervisor_conn_t *conn,int argc,char *argv[])
216     {
217     vm_instance_t *vm;
218    
219     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
220     return(-1);
221    
222     vm->idle_pc = strtoull(argv[1],NULL,0);
223    
224     vm_release(vm);
225     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
226     return(0);
227     }
228    
229 dpavlin 3 /* Set the idle PC value when the CPU is online */
230     static int cmd_set_idle_pc_online(hypervisor_conn_t *conn,
231     int argc,char *argv[])
232     {
233     vm_instance_t *vm;
234 dpavlin 7 cpu_gen_t *cpu;
235 dpavlin 3
236     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
237     return(-1);
238    
239     if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
240     return(-1);
241    
242 dpavlin 7 cpu->set_idle_pc(cpu,strtoull(argv[2],NULL,0));
243 dpavlin 3
244     vm_release(vm);
245     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
246     return(0);
247     }
248    
249     /* Get the idle PC proposals */
250     static int cmd_get_idle_pc_prop(hypervisor_conn_t *conn,int argc,char *argv[])
251     {
252     vm_instance_t *vm;
253 dpavlin 7 cpu_gen_t *cpu;
254 dpavlin 3 int i;
255    
256     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
257     return(-1);
258    
259     if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
260     return(-1);
261    
262 dpavlin 7 cpu->get_idling_pc(cpu);
263 dpavlin 3
264     for(i=0;i<cpu->idle_pc_prop_count;i++) {
265     hypervisor_send_reply(conn,HSC_INFO_MSG,0,"0x%llx [%d]",
266     cpu->idle_pc_prop[i].pc,
267     cpu->idle_pc_prop[i].count);
268     }
269    
270     vm_release(vm);
271     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
272     return(0);
273     }
274    
275     /* Dump the idle PC proposals */
276     static int cmd_show_idle_pc_prop(hypervisor_conn_t *conn,int argc,char *argv[])
277     {
278     vm_instance_t *vm;
279 dpavlin 7 cpu_gen_t *cpu;
280 dpavlin 3 int i;
281    
282     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
283     return(-1);
284    
285     if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
286     return(-1);
287    
288     for(i=0;i<cpu->idle_pc_prop_count;i++) {
289     hypervisor_send_reply(conn,HSC_INFO_MSG,0,"0x%llx [%d]",
290     cpu->idle_pc_prop[i].pc,
291     cpu->idle_pc_prop[i].count);
292     }
293    
294     vm_release(vm);
295     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
296     return(0);
297     }
298    
299     /* Set CPU idle max value */
300     static int cmd_set_idle_max(hypervisor_conn_t *conn,int argc,char *argv[])
301     {
302     vm_instance_t *vm;
303 dpavlin 7 cpu_gen_t *cpu;
304 dpavlin 3
305     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
306     return(-1);
307    
308     if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
309     return(-1);
310    
311     cpu->idle_max = atoi(argv[2]);
312    
313     vm_release(vm);
314     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
315     return(0);
316     }
317    
318     /* Set CPU idle sleep time value */
319     static int cmd_set_idle_sleep_time(hypervisor_conn_t *conn,
320     int argc,char *argv[])
321     {
322     vm_instance_t *vm;
323 dpavlin 7 cpu_gen_t *cpu;
324 dpavlin 3
325     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
326     return(-1);
327    
328     if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
329     return(-1);
330    
331     cpu->idle_sleep_time = atoi(argv[2]);
332    
333     vm_release(vm);
334     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
335     return(0);
336     }
337    
338 dpavlin 4 /* Show info about potential timer drift */
339     static int cmd_show_timer_drift(hypervisor_conn_t *conn,
340     int argc,char *argv[])
341     {
342     vm_instance_t *vm;
343 dpavlin 7 cpu_gen_t *cpu;
344 dpavlin 4
345     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
346     return(-1);
347    
348     if (!(cpu = find_cpu(conn,vm,atoi(argv[1]))))
349     return(-1);
350    
351 dpavlin 7 if (cpu->type == CPU_TYPE_MIPS64) {
352     hypervisor_send_reply(conn,HSC_INFO_MSG,0,"Timer Drift: %u",
353     CPU_MIPS64(cpu)->timer_drift);
354 dpavlin 4
355 dpavlin 7 hypervisor_send_reply(conn,HSC_INFO_MSG,0,"Pending Timer IRQ: %u",
356     CPU_MIPS64(cpu)->timer_irq_pending);
357     }
358    
359 dpavlin 4 vm_release(vm);
360     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
361     return(0);
362     }
363    
364 dpavlin 1 /* Set the exec area size */
365     static int cmd_set_exec_area(hypervisor_conn_t *conn,int argc,char *argv[])
366     {
367     vm_instance_t *vm;
368    
369     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
370     return(-1);
371    
372     vm->exec_area_size = atoi(argv[1]);
373    
374     vm_release(vm);
375     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
376     return(0);
377     }
378    
379 dpavlin 4 /* Set ghost RAM file */
380     static int cmd_set_ghost_file(hypervisor_conn_t *conn,int argc,char *argv[])
381     {
382     vm_instance_t *vm;
383    
384     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
385     return(-1);
386    
387     vm->ghost_ram_filename = strdup(argv[1]);
388    
389     vm_release(vm);
390     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
391     return(0);
392     }
393    
394     /* Set ghost RAM status */
395     static int cmd_set_ghost_status(hypervisor_conn_t *conn,int argc,char *argv[])
396     {
397     vm_instance_t *vm;
398    
399     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
400     return(-1);
401    
402     vm->ghost_status = atoi(argv[1]);
403    
404     vm_release(vm);
405     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
406     return(0);
407     }
408    
409    
410 dpavlin 1 /* Set PCMCIA ATA disk0 size */
411     static int cmd_set_disk0(hypervisor_conn_t *conn,int argc,char *argv[])
412     {
413     vm_instance_t *vm;
414    
415     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
416     return(-1);
417    
418     vm->pcmcia_disk_size[0] = atoi(argv[1]);
419     vm_release(vm);
420     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
421     return(0);
422     }
423    
424     /* Set PCMCIA ATA disk1 size */
425     static int cmd_set_disk1(hypervisor_conn_t *conn,int argc,char *argv[])
426     {
427     vm_instance_t *vm;
428    
429     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
430     return(-1);
431    
432     vm->pcmcia_disk_size[1] = atoi(argv[1]);
433     vm_release(vm);
434     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
435     return(0);
436     }
437    
438     /* Set the config register used at startup */
439     static int cmd_set_conf_reg(hypervisor_conn_t *conn,int argc,char *argv[])
440     {
441     vm_instance_t *vm;
442    
443     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
444     return(-1);
445    
446     vm->conf_reg_setup = strtol(argv[1],NULL,0);
447     vm_release(vm);
448     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
449     return(0);
450     }
451    
452     /* Set TCP port for console */
453     static int cmd_set_con_tcp_port(hypervisor_conn_t *conn,int argc,char *argv[])
454     {
455     vm_instance_t *vm;
456    
457     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
458     return(-1);
459    
460     vm->vtty_con_type = VTTY_TYPE_TCP;
461     vm->vtty_con_tcp_port = atoi(argv[1]);
462    
463     vm_release(vm);
464     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
465     return(0);
466     }
467    
468     /* Set TCP port for AUX port */
469     static int cmd_set_aux_tcp_port(hypervisor_conn_t *conn,int argc,char *argv[])
470     {
471     vm_instance_t *vm;
472    
473     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
474     return(-1);
475    
476     vm->vtty_aux_type = VTTY_TYPE_TCP;
477     vm->vtty_aux_tcp_port = atoi(argv[1]);
478    
479     vm_release(vm);
480     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
481     return(0);
482     }
483    
484     /* Read an IOS configuration file from a given router */
485     static int cmd_extract_config(hypervisor_conn_t *conn,int argc,char *argv[])
486     {
487     vm_instance_t *vm;
488     char *cfg_buffer,*cfg_base64;
489     ssize_t cfg_len;
490    
491     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
492     return(-1);
493    
494     if (!vm->nvram_extract_config)
495     goto err_no_extract_method;
496    
497     /* Extract the IOS configuration */
498     if (((cfg_len = vm->nvram_extract_config(vm,&cfg_buffer)) < 0) ||
499     (cfg_buffer == NULL))
500     goto err_nvram_extract;
501    
502     /*
503     * Convert config to base64. base64 is about 1/3 larger than input,
504     * let's be on the safe side with twice longer.
505     */
506     if (!(cfg_base64 = malloc(cfg_len * 2)))
507     goto err_alloc_base64;
508    
509     base64_encode(cfg_base64,cfg_buffer,cfg_len);
510    
511     vm_release(vm);
512     hypervisor_send_reply(conn,HSC_INFO_OK,1,"conf '%s' %s",argv[0],cfg_base64);
513    
514     free(cfg_buffer);
515     free(cfg_base64);
516     return(0);
517    
518     err_alloc_base64:
519     free(cfg_buffer);
520     err_nvram_extract:
521     err_no_extract_method:
522     vm_release(vm);
523     hypervisor_send_reply(conn,HSC_ERR_CREATE,1,
524     "unable to extract config of VM '%s'",argv[0]);
525     return(-1);
526     }
527    
528     /* Push an IOS configuration file */
529     static int cmd_push_config(hypervisor_conn_t *conn,int argc,char *argv[])
530     {
531     vm_instance_t *vm;
532     char *cfg_buffer;
533     ssize_t len;
534    
535     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
536     return(-1);
537    
538     if (!vm->nvram_push_config)
539     goto err_no_push_method;
540    
541     /* Convert base64 input to standard text */
542     if (!(cfg_buffer = malloc(3 * strlen(argv[1]))))
543     goto err_alloc_base64;
544    
545     if ((len = base64_decode(cfg_buffer,argv[1],0)) < 0)
546     goto err_decode_base64;
547    
548     /* Push configuration */
549     if (vm->nvram_push_config(vm,cfg_buffer,len) < 0)
550     goto err_nvram_push;
551    
552     free(cfg_buffer);
553     vm_release(vm);
554     hypervisor_send_reply(conn,HSC_INFO_OK,1,
555     "IOS config file pushed tm VM '%s'",
556     argv[0]);
557     return(0);
558    
559     err_nvram_push:
560     err_decode_base64:
561     free(cfg_buffer);
562     err_alloc_base64:
563     err_no_push_method:
564     vm_release(vm);
565     hypervisor_send_reply(conn,HSC_ERR_CREATE,1,
566     "unable to push IOS config for VM '%s'",
567     argv[0]);
568     return(-1);
569     }
570    
571     /* Show info about the specified CPU */
572     static int cmd_show_cpu_info(hypervisor_conn_t *conn,int argc,char *argv[])
573     {
574     vm_instance_t *vm;
575 dpavlin 7 cpu_gen_t *cpu;
576 dpavlin 1
577     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
578     return(-1);
579    
580     cpu = cpu_group_find_id(vm->cpu_group,atoi(argv[1]));
581    
582     if (cpu) {
583 dpavlin 7 cpu->reg_dump(cpu);
584     cpu->mmu_dump(cpu);
585 dpavlin 1 }
586    
587     vm_release(vm);
588     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
589     return(0);
590     }
591    
592     /* Suspend a VM instance */
593     static int cmd_suspend(hypervisor_conn_t *conn,int argc,char *argv[])
594     {
595     vm_instance_t *vm;
596    
597     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
598     return(-1);
599    
600     vm_suspend(vm);
601    
602     vm_release(vm);
603     hypervisor_send_reply(conn,HSC_INFO_OK,1,"VM '%s' suspended",argv[0]);
604     return(0);
605     }
606    
607     /* Resume a VM instance */
608     static int cmd_resume(hypervisor_conn_t *conn,int argc,char *argv[])
609     {
610     vm_instance_t *vm;
611    
612     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
613     return(-1);
614    
615     vm_resume(vm);
616    
617     vm_release(vm);
618     hypervisor_send_reply(conn,HSC_INFO_OK,1,"VM '%s' resumed",argv[0]);
619     return(0);
620     }
621    
622 dpavlin 4 /* Send a message on the console */
623     static int cmd_send_con_msg(hypervisor_conn_t *conn,int argc,char *argv[])
624     {
625     vm_instance_t *vm;
626    
627     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
628     return(-1);
629    
630     vtty_store_str(vm->vtty_con,argv[1]);
631    
632     vm_release(vm);
633     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
634     return(0);
635     }
636    
637     /* Send a message on the AUX port */
638     static int cmd_send_aux_msg(hypervisor_conn_t *conn,int argc,char *argv[])
639     {
640     vm_instance_t *vm;
641    
642     if (!(vm = hypervisor_find_object(conn,argv[0],OBJ_TYPE_VM)))
643     return(-1);
644    
645     vtty_store_str(vm->vtty_aux,argv[1]);
646    
647     vm_release(vm);
648     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
649     return(0);
650     }
651    
652 dpavlin 1 /* Show info about VM object */
653     static void cmd_show_vm_list(registry_entry_t *entry,void *opt,int *err)
654     {
655     hypervisor_conn_t *conn = opt;
656     vm_instance_t *vm = entry->data;
657    
658     hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s (%s)",
659     entry->name,vm_get_type(vm));
660     }
661    
662     /* VM List */
663     static int cmd_vm_list(hypervisor_conn_t *conn,int argc,char *argv[])
664     {
665     int err = 0;
666     registry_foreach_type(OBJ_TYPE_VM,cmd_show_vm_list,conn,&err);
667     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
668     return(0);
669     }
670    
671 dpavlin 6 /* Show console TCP port info about VM object */
672     static void cmd_show_vm_list_con_ports(registry_entry_t *entry,void *opt,
673     int *err)
674     {
675     hypervisor_conn_t *conn = opt;
676     vm_instance_t *vm = entry->data;
677    
678     if (vm->vtty_con_type == VTTY_TYPE_TCP)
679     hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s (%d)",
680     vm->name,vm->vtty_con_tcp_port);
681     }
682    
683     /* VM console TCP port list */
684     static int cmd_vm_list_con_ports(hypervisor_conn_t *conn,int argc,char *argv[])
685     {
686     int err = 0;
687     registry_foreach_type(OBJ_TYPE_VM,cmd_show_vm_list_con_ports,conn,&err);
688     hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
689     return(0);
690     }
691    
692 dpavlin 1 /* VM commands */
693     static hypervisor_cmd_t vm_cmd_array[] = {
694     { "set_debug_level", 2, 2, cmd_set_debug_level, NULL },
695     { "set_ios", 2, 2, cmd_set_ios, NULL },
696     { "set_config", 2, 2, cmd_set_config, NULL },
697     { "set_ram", 2, 2, cmd_set_ram, NULL },
698     { "set_nvram", 2, 2, cmd_set_nvram, NULL },
699     { "set_ram_mmap", 2, 2, cmd_set_ram_mmap, NULL },
700 dpavlin 7 { "set_sparse_mem", 2, 2, cmd_set_sparse_mem, NULL },
701 dpavlin 1 { "set_clock_divisor", 2, 2, cmd_set_clock_divisor, NULL },
702 dpavlin 8 { "set_blk_direct_jump", 2, 2, cmd_set_blk_direct_jump, NULL },
703 dpavlin 1 { "set_exec_area", 2, 2, cmd_set_exec_area, NULL },
704     { "set_disk0", 2, 2, cmd_set_disk0, NULL },
705     { "set_disk1", 2, 2, cmd_set_disk1, NULL },
706     { "set_conf_reg", 2, 2, cmd_set_conf_reg, NULL },
707     { "set_idle_pc", 2, 2, cmd_set_idle_pc, NULL },
708 dpavlin 3 { "set_idle_pc_online", 3, 3, cmd_set_idle_pc_online, NULL },
709     { "get_idle_pc_prop", 2, 2, cmd_get_idle_pc_prop, NULL },
710     { "show_idle_pc_prop", 2, 2, cmd_show_idle_pc_prop, NULL },
711     { "set_idle_max", 3, 3, cmd_set_idle_max, NULL },
712     { "set_idle_sleep_time", 3, 3, cmd_set_idle_sleep_time, NULL },
713 dpavlin 4 { "show_timer_drift", 2, 2, cmd_show_timer_drift, NULL },
714 dpavlin 5 { "set_ghost_file", 2, 2, cmd_set_ghost_file, NULL },
715     { "set_ghost_status", 2, 2, cmd_set_ghost_status, NULL },
716 dpavlin 1 { "set_con_tcp_port", 2, 2, cmd_set_con_tcp_port, NULL },
717     { "set_aux_tcp_port", 2, 2, cmd_set_aux_tcp_port, NULL },
718     { "extract_config", 1, 1, cmd_extract_config, NULL },
719     { "push_config", 2, 2, cmd_push_config, NULL },
720     { "cpu_info", 2, 2, cmd_show_cpu_info, NULL },
721     { "suspend", 1, 1, cmd_suspend, NULL },
722     { "resume", 1, 1, cmd_resume, NULL },
723 dpavlin 4 { "send_con_msg", 2, 2, cmd_send_con_msg, NULL },
724     { "send_aux_msg", 2, 2, cmd_send_aux_msg, NULL },
725 dpavlin 1 { "list", 0, 0, cmd_vm_list, NULL },
726 dpavlin 6 { "list_con_ports", 0, 0, cmd_vm_list_con_ports, NULL },
727 dpavlin 1 { NULL, -1, -1, NULL, NULL },
728     };
729    
730     /* Hypervisor VM initialization */
731     int hypervisor_vm_init(void)
732     {
733     hypervisor_module_t *module;
734    
735     module = hypervisor_register_module("vm");
736     assert(module != NULL);
737    
738     hypervisor_register_cmd_array(module,vm_cmd_array);
739     return(0);
740     }

  ViewVC Help
Powered by ViewVC 1.1.26