1
2
/*
* QEMU monitor
ths
authored
18 years ago
3
*
4
* Copyright ( c ) 2003 - 2004 Fabrice Bellard
ths
authored
18 years ago
5
*
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
* Permission is hereby granted , free of charge , to any person obtaining a copy
* of this software and associated documentation files ( the "Software" ), to deal
* in the Software without restriction , including without limitation the rights
* to use , copy , modify , merge , publish , distribute , sublicense , and / or sell
* copies of the Software , and to permit persons to whom the Software is
* furnished to do so , subject to the following conditions :
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software .
*
* THE SOFTWARE IS PROVIDED "AS IS" , WITHOUT WARRANTY OF ANY KIND , EXPRESS OR
* IMPLIED , INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY ,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT . IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM , DAMAGES OR OTHER
* LIABILITY , WHETHER IN AN ACTION OF CONTRACT , TORT OR OTHERWISE , ARISING FROM ,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE .
*/
24
# include < dirent . h >
25
# include "hw/hw.h"
26
# include "hw/qdev.h"
27
28
29
30
# include "hw/usb.h"
# include "hw/pcmcia.h"
# include "hw/pc.h"
# include "hw/pci.h"
31
# include "hw/watchdog.h"
32
33
34
35
# include "gdbstub.h"
# include "net.h"
# include "qemu-char.h"
# include "sysemu.h"
36
37
# include "monitor.h"
# include "readline.h"
38
39
40
# include "console.h"
# include "block.h"
# include "audio/audio.h"
41
# include "disas.h"
42
# include "balloon.h"
43
# include "qemu-timer.h"
44
# include "migration.h"
45
# include "kvm.h"
46
# include "acl.h"
ths
authored
17 years ago
47
48
// # define DEBUG
49
// # define DEBUG_COMPLETION
50
51
52
/*
* Supported types :
ths
authored
18 years ago
53
*
54
* 'F' filename
55
* 'B' block device name
56
* 's' string ( accept optional quote )
57
58
* 'i' 32 bit integer
* 'l' target long ( 32 or 64 bit )
59
60
61
62
63
64
* '/' optional gdb - like print format ( like "/10x" )
*
* '?' optional type ( for 'F' , 's' and 'i' )
*
*/
65
typedef struct mon_cmd_t {
66
const char * name ;
67
const char * args_type ;
68
void * handler ;
69
70
const char * params ;
const char * help ;
71
} mon_cmd_t ;
72
73
74
struct Monitor {
CharDriverState * chr ;
75
76
77
78
79
80
81
82
int flags ;
int suspend_cnt ;
uint8_t outbuf [ 1024 ];
int outbuf_index ;
ReadLineState * rs ;
CPUState * mon_cpu ;
BlockDriverCompletionFunc * password_completion_cb ;
void * password_opaque ;
83
84
85
86
LIST_ENTRY ( Monitor ) entry ;
};
static LIST_HEAD ( mon_list , Monitor ) mon_list ;
87
88
89
static const mon_cmd_t mon_cmds [];
static const mon_cmd_t info_cmds [];
90
91
Monitor * cur_mon = NULL ;
92
93
94
static void monitor_command_cb ( Monitor * mon , const char * cmdline ,
void * opaque );
95
96
97
98
99
100
101
static void monitor_read_command ( Monitor * mon , int show_prompt )
{
readline_start ( mon -> rs , "(qemu) " , 0 , monitor_command_cb , NULL );
if ( show_prompt )
readline_show_prompt ( mon -> rs );
}
102
103
104
static int monitor_read_password ( Monitor * mon , ReadLineFunc * readline_func ,
void * opaque )
105
{
106
107
108
109
110
111
112
113
if ( mon -> rs ) {
readline_start ( mon -> rs , "Password: " , 1 , readline_func , opaque );
/* prompt is printed on return from the command handler */
return 0 ;
} else {
monitor_printf ( mon , "terminal does not support password prompting \n " );
return - ENOTTY ;
}
114
115
}
116
void monitor_flush ( Monitor * mon )
117
{
118
119
120
if ( mon && mon -> outbuf_index != 0 && mon -> chr -> focus == 0 ) {
qemu_chr_write ( mon -> chr , mon -> outbuf , mon -> outbuf_index );
mon -> outbuf_index = 0 ;
121
122
123
124
}
}
/* flush at every end of line or if the buffer is full */
125
static void monitor_puts ( Monitor * mon , const char * str )
126
{
ths
authored
17 years ago
127
char c ;
128
129
130
131
if ( ! mon )
return ;
132
133
134
135
for (;;) {
c = * str ++ ;
if ( c == '\0' )
break ;
136
if ( c == '\n' )
137
138
139
140
mon -> outbuf [ mon -> outbuf_index ++ ] = '\r' ;
mon -> outbuf [ mon -> outbuf_index ++ ] = c ;
if ( mon -> outbuf_index >= ( sizeof ( mon -> outbuf ) - 1 )
|| c == '\n' )
141
monitor_flush ( mon );
142
143
144
}
}
145
void monitor_vprintf ( Monitor * mon , const char * fmt , va_list ap )
146
{
147
148
char buf [ 4096 ];
vsnprintf ( buf , sizeof ( buf ), fmt , ap );
149
monitor_puts ( mon , buf );
150
151
}
152
void monitor_printf ( Monitor * mon , const char * fmt , ...)
153
{
154
155
va_list ap ;
va_start ( ap , fmt );
156
monitor_vprintf ( mon , fmt , ap );
157
va_end ( ap );
158
159
}
160
void monitor_print_filename ( Monitor * mon , const char * filename )
ths
authored
18 years ago
161
162
163
164
{
int i ;
for ( i = 0 ; filename [ i ]; i ++ ) {
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
switch ( filename [ i ]) {
case ' ' :
case '"' :
case '\\' :
monitor_printf ( mon , " \\ %c" , filename [ i ]);
break ;
case '\t' :
monitor_printf ( mon , " \\ t" );
break ;
case '\r' :
monitor_printf ( mon , " \\ r" );
break ;
case '\n' :
monitor_printf ( mon , " \\ n" );
break ;
default :
monitor_printf ( mon , "%c" , filename [ i ]);
break ;
}
ths
authored
18 years ago
184
185
186
}
}
187
188
189
190
static int monitor_fprintf ( FILE * stream , const char * fmt , ...)
{
va_list ap ;
va_start ( ap , fmt );
191
monitor_vprintf (( Monitor * ) stream , fmt , ap );
192
193
194
195
va_end ( ap );
return 0 ;
}
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
static int compare_cmd ( const char * name , const char * list )
{
const char * p , * pstart ;
int len ;
len = strlen ( name );
p = list ;
for (;;) {
pstart = p ;
p = strchr ( p , '|' );
if ( ! p )
p = pstart + strlen ( pstart );
if (( p - pstart ) == len && ! memcmp ( pstart , name , len ))
return 1 ;
if ( * p == '\0' )
break ;
p ++ ;
}
return 0 ;
}
216
217
static void help_cmd_dump ( Monitor * mon , const mon_cmd_t * cmds ,
const char * prefix , const char * name )
218
{
219
const mon_cmd_t * cmd ;
220
221
222
for ( cmd = cmds ; cmd -> name != NULL ; cmd ++ ) {
if ( ! name || ! strcmp ( name , cmd -> name ))
223
224
monitor_printf ( mon , "%s%s %s -- %s \n " , prefix , cmd -> name ,
cmd -> params , cmd -> help );
225
226
227
}
}
228
static void help_cmd ( Monitor * mon , const char * name )
229
230
{
if ( name && ! strcmp ( name , "info" )) {
231
help_cmd_dump ( mon , info_cmds , "info " , NULL );
232
} else {
233
help_cmd_dump ( mon , mon_cmds , "" , name );
234
if ( name && ! strcmp ( name , "log" )) {
235
const CPULogItem * item ;
236
237
monitor_printf ( mon , "Log items (comma separated): \n " );
monitor_printf ( mon , "%-10s %s \n " , "none" , "remove all logs" );
238
for ( item = cpu_log_items ; item -> mask != 0 ; item ++ ) {
239
monitor_printf ( mon , "%-10s %s \n " , item -> name , item -> help );
240
241
}
}
242
243
244
}
}
245
static void do_commit ( Monitor * mon , const char * device )
246
{
247
int i , all_devices ;
248
249
all_devices = ! strcmp ( device , "all" );
ths
authored
17 years ago
250
for ( i = 0 ; i < nb_drives ; i ++ ) {
ths
authored
18 years ago
251
if ( all_devices ||
ths
authored
17 years ago
252
253
! strcmp ( bdrv_get_device_name ( drives_table [ i ]. bdrv ), device ))
bdrv_commit ( drives_table [ i ]. bdrv );
254
255
256
}
}
257
static void do_info ( Monitor * mon , const char * item )
258
{
259
260
const mon_cmd_t * cmd ;
void ( * handler )( Monitor * );
261
262
if ( ! item )
263
264
goto help ;
for ( cmd = info_cmds ; cmd -> name != NULL ; cmd ++ ) {
ths
authored
18 years ago
265
if ( compare_cmd ( item , cmd -> name ))
266
267
268
goto found ;
}
help :
269
help_cmd ( mon , "info" );
270
271
return ;
found :
272
handler = cmd -> handler ;
273
handler ( mon );
274
275
}
276
static void do_info_version ( Monitor * mon )
277
{
278
monitor_printf ( mon , "%s \n " , QEMU_VERSION QEMU_PKGVERSION );
279
280
}
281
static void do_info_name ( Monitor * mon )
ths
authored
18 years ago
282
283
{
if ( qemu_name )
284
monitor_printf ( mon , "%s \n " , qemu_name );
ths
authored
18 years ago
285
286
}
287
# if defined ( TARGET_I386 )
288
static void do_info_hpet ( Monitor * mon )
289
{
290
291
monitor_printf ( mon , "HPET is %s by QEMU \n " ,
( no_hpet ) ? "disabled" : "enabled" );
292
}
293
# endif
294
295
static void do_info_uuid ( Monitor * mon )
ths
authored
17 years ago
296
{
297
298
299
300
301
monitor_printf ( mon , UUID_FMT " \n " , qemu_uuid [ 0 ], qemu_uuid [ 1 ],
qemu_uuid [ 2 ], qemu_uuid [ 3 ], qemu_uuid [ 4 ], qemu_uuid [ 5 ],
qemu_uuid [ 6 ], qemu_uuid [ 7 ], qemu_uuid [ 8 ], qemu_uuid [ 9 ],
qemu_uuid [ 10 ], qemu_uuid [ 11 ], qemu_uuid [ 12 ], qemu_uuid [ 13 ],
qemu_uuid [ 14 ], qemu_uuid [ 15 ]);
ths
authored
17 years ago
302
303
}
304
/* get the current CPU defined by the user */
305
static int mon_set_cpu ( int cpu_index )
306
307
308
309
310
{
CPUState * env ;
for ( env = first_cpu ; env != NULL ; env = env -> next_cpu ) {
if ( env -> cpu_index == cpu_index ) {
311
cur_mon -> mon_cpu = env ;
312
313
314
315
316
317
return 0 ;
}
}
return - 1 ;
}
318
static CPUState * mon_get_cpu ( void )
319
{
320
if ( ! cur_mon -> mon_cpu ) {
321
322
mon_set_cpu ( 0 );
}
323
cpu_synchronize_state ( cur_mon -> mon_cpu , 0 );
324
return cur_mon -> mon_cpu ;
325
326
}
327
static void do_info_registers ( Monitor * mon )
328
{
329
330
331
332
CPUState * env ;
env = mon_get_cpu ();
if ( ! env )
return ;
333
# ifdef TARGET_I386
334
cpu_dump_state ( env , ( FILE * ) mon , monitor_fprintf ,
335
X86_DUMP_FPU );
336
# else
337
cpu_dump_state ( env , ( FILE * ) mon , monitor_fprintf ,
338
0 );
339
340
341
# endif
}
342
static void do_info_cpus ( Monitor * mon )
343
344
345
346
347
348
349
{
CPUState * env ;
/* just to set the default cpu if not already done */
mon_get_cpu ();
for ( env = first_cpu ; env != NULL ; env = env -> next_cpu ) {
350
cpu_synchronize_state ( env , 0 );
351
monitor_printf ( mon , "%c CPU #%d:" ,
352
( env == mon -> mon_cpu ) ? '*' : ' ' ,
353
env -> cpu_index );
354
# if defined ( TARGET_I386 )
355
356
monitor_printf ( mon , " pc=0x" TARGET_FMT_lx ,
env -> eip + env -> segs [ R_CS ]. base );
357
# elif defined ( TARGET_PPC )
358
monitor_printf ( mon , " nip=0x" TARGET_FMT_lx , env -> nip );
359
# elif defined ( TARGET_SPARC )
360
361
monitor_printf ( mon , " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx ,
env -> pc , env -> npc );
ths
authored
18 years ago
362
# elif defined ( TARGET_MIPS )
363
monitor_printf ( mon , " PC=0x" TARGET_FMT_lx , env -> active_tc . PC );
364
# endif
ths
authored
18 years ago
365
if ( env -> halted )
366
367
monitor_printf ( mon , " (halted)" );
monitor_printf ( mon , " \n " );
368
369
370
}
}
371
static void do_cpu_set ( Monitor * mon , int index )
372
373
{
if ( mon_set_cpu ( index ) < 0 )
374
monitor_printf ( mon , "Invalid CPU index \n " );
375
376
}
377
static void do_info_jit ( Monitor * mon )
378
{
379
dump_exec_info (( FILE * ) mon , monitor_fprintf );
380
381
}
382
static void do_info_history ( Monitor * mon )
383
384
{
int i ;
385
const char * str ;
ths
authored
18 years ago
386
387
388
if ( ! mon -> rs )
return ;
389
390
i = 0 ;
for (;;) {
391
str = readline_get_history ( mon -> rs , i );
392
393
if ( ! str )
break ;
394
monitor_printf ( mon , "%d: '%s' \n " , i , str );
395
i ++ ;
396
397
398
}
}
399
400
# if defined ( TARGET_PPC )
/* XXX: not implemented in other targets */
401
static void do_info_cpu_stats ( Monitor * mon )
402
403
404
405
{
CPUState * env ;
env = mon_get_cpu ();
406
cpu_dump_statistics ( env , ( FILE * ) mon , & monitor_fprintf , 0 );
407
408
409
}
# endif
410
static void do_quit ( Monitor * mon )
411
412
413
414
{
exit ( 0 );
}
415
static int eject_device ( Monitor * mon , BlockDriverState * bs , int force )
416
417
418
419
{
if ( bdrv_is_inserted ( bs )) {
if ( ! force ) {
if ( ! bdrv_is_removable ( bs )) {
420
monitor_printf ( mon , "device is not removable \n " );
421
422
423
return - 1 ;
}
if ( bdrv_is_locked ( bs )) {
424
monitor_printf ( mon , "device is locked \n " );
425
426
427
428
429
430
431
432
return - 1 ;
}
}
bdrv_close ( bs );
}
return 0 ;
}
433
static void do_eject ( Monitor * mon , int force , const char * filename )
434
435
436
{
BlockDriverState * bs ;
437
bs = bdrv_find ( filename );
438
if ( ! bs ) {
439
monitor_printf ( mon , "device not found \n " );
440
441
return ;
}
442
eject_device ( mon , bs , force );
443
444
}
445
446
static void do_change_block ( Monitor * mon , const char * device ,
const char * filename , const char * fmt )
447
448
{
BlockDriverState * bs ;
449
BlockDriver * drv = NULL ;
450
451
bs = bdrv_find ( device );
452
if ( ! bs ) {
453
monitor_printf ( mon , "device not found \n " );
454
455
return ;
}
456
457
458
if ( fmt ) {
drv = bdrv_find_format ( fmt );
if ( ! drv ) {
459
monitor_printf ( mon , "invalid format %s \n " , fmt );
460
461
462
return ;
}
}
463
if ( eject_device ( mon , bs , 0 ) < 0 )
464
return ;
465
bdrv_open2 ( bs , filename , 0 , drv );
466
monitor_read_bdrv_key_start ( mon , bs , NULL , NULL );
467
468
}
469
470
static void change_vnc_password_cb ( Monitor * mon , const char * password ,
void * opaque )
471
472
{
if ( vnc_display_password ( NULL , password ) < 0 )
473
monitor_printf ( mon , "could not set VNC server password \n " );
474
475
monitor_read_command ( mon , 1 );
476
477
}
478
static void do_change_vnc ( Monitor * mon , const char * target , const char * arg )
ths
authored
18 years ago
479
{
ths
authored
18 years ago
480
if ( strcmp ( target , "passwd" ) == 0 ||
481
482
strcmp ( target , "password" ) == 0 ) {
if ( arg ) {
483
char password [ 9 ];
484
485
strncpy ( password , arg , sizeof ( password ));
password [ sizeof ( password ) - 1 ] = '\0' ;
486
change_vnc_password_cb ( mon , password , NULL );
487
} else {
488
monitor_read_password ( mon , change_vnc_password_cb , NULL );
489
}
ths
authored
18 years ago
490
} else {
491
if ( vnc_display_open ( NULL , target ) < 0 )
492
monitor_printf ( mon , "could not start VNC server on %s \n " , target );
ths
authored
18 years ago
493
}
ths
authored
18 years ago
494
495
}
496
497
static void do_change ( Monitor * mon , const char * device , const char * target ,
const char * arg )
ths
authored
18 years ago
498
499
{
if ( strcmp ( device , "vnc" ) == 0 ) {
500
do_change_vnc ( mon , target , arg );
ths
authored
18 years ago
501
} else {
502
do_change_block ( mon , device , target , arg );
ths
authored
18 years ago
503
504
505
}
}
506
static void do_screen_dump ( Monitor * mon , const char * filename )
507
{
508
vga_hw_screen_dump ( filename );
509
510
}
511
static void do_logfile ( Monitor * mon , const char * filename )
512
513
514
515
{
cpu_set_log_filename ( filename );
}
516
static void do_log ( Monitor * mon , const char * items )
517
518
{
int mask ;
ths
authored
18 years ago
519
520
if ( ! strcmp ( items , "none" )) {
521
522
mask = 0 ;
} else {
523
mask = cpu_str_to_log_mask ( items );
524
if ( ! mask ) {
525
help_cmd ( mon , "log" );
526
527
528
529
530
531
return ;
}
}
cpu_set_log ( mask );
}
532
533
534
535
536
537
538
539
540
541
542
static void do_singlestep ( Monitor * mon , const char * option )
{
if ( ! option || ! strcmp ( option , "on" )) {
singlestep = 1 ;
} else if ( ! strcmp ( option , "off" )) {
singlestep = 0 ;
} else {
monitor_printf ( mon , "unexpected option %s \n " , option );
}
}
543
static void do_stop ( Monitor * mon )
544
545
546
547
{
vm_stop ( EXCP_INTERRUPT );
}
548
static void encrypted_bdrv_it ( void * opaque , BlockDriverState * bs );
549
550
551
552
553
554
555
struct bdrv_iterate_context {
Monitor * mon ;
int err ;
};
static void do_cont ( Monitor * mon )
556
{
557
struct bdrv_iterate_context context = { mon , 0 };
558
559
bdrv_iterate ( encrypted_bdrv_it , & context );
560
/* only resume the vm if all keys are set and valid */
561
if ( ! context . err )
562
vm_start ();
563
564
}
565
566
static void bdrv_key_cb ( void * opaque , int err )
{
567
568
Monitor * mon = opaque ;
569
570
/* another key was set successfully, retry to continue */
if ( ! err )
571
do_cont ( mon );
572
573
574
575
}
static void encrypted_bdrv_it ( void * opaque , BlockDriverState * bs )
{
576
struct bdrv_iterate_context * context = opaque ;
577
578
579
580
581
if ( ! context -> err && bdrv_key_required ( bs )) {
context -> err = - EBUSY ;
monitor_read_bdrv_key_start ( context -> mon , bs , bdrv_key_cb ,
context -> mon );
582
583
584
}
}
585
586
587
588
589
590
591
592
static void do_gdbserver ( Monitor * mon , const char * device )
{
if ( ! device )
device = "tcp::" DEFAULT_GDBSTUB_PORT ;
if ( gdbserver_start ( device ) < 0 ) {
monitor_printf ( mon , "Could not open gdbserver on device '%s' \n " ,
device );
} else if ( strcmp ( device , "none" ) == 0 ) {
593
monitor_printf ( mon , "Disabled gdbserver \n " );
594
} else {
595
596
monitor_printf ( mon , "Waiting for gdb connection on device '%s' \n " ,
device );
597
598
599
}
}
600
601
602
603
604
605
606
static void do_watchdog_action ( Monitor * mon , const char * action )
{
if ( select_watchdog_action ( action ) == - 1 ) {
monitor_printf ( mon , "Unknown watchdog action '%s' \n " , action );
}
}
607
static void monitor_printc ( Monitor * mon , int c )
608
{
609
monitor_printf ( mon , "'" );
610
611
switch ( c ) {
case '\'' :
612
monitor_printf ( mon , " \\ '" );
613
614
break ;
case '\\' :
615
monitor_printf ( mon , " \\\\ " );
616
617
break ;
case '\n' :
618
monitor_printf ( mon , " \\ n" );
619
620
break ;
case '\r' :
621
monitor_printf ( mon , " \\ r" );
622
623
624
break ;
default :
if ( c >= 32 && c <= 126 ) {
625
monitor_printf ( mon , "%c" , c );
626
} else {
627
monitor_printf ( mon , " \\ x%02x" , c );
628
629
630
}
break ;
}
631
monitor_printf ( mon , "'" );
632
633
}
634
static void memory_dump ( Monitor * mon , int count , int format , int wsize ,
635
target_phys_addr_t addr , int is_physical )
636
{
637
CPUState * env ;
638
639
640
641
642
643
644
int nb_per_line , l , line_size , i , max_digits , len ;
uint8_t buf [ 16 ];
uint64_t v ;
if ( format == 'i' ) {
int flags ;
flags = 0 ;
645
646
647
env = mon_get_cpu ();
if ( ! env && ! is_physical )
return ;
648
# ifdef TARGET_I386
649
if ( wsize == 2 ) {
650
flags = 1 ;
651
652
653
} else if ( wsize == 4 ) {
flags = 0 ;
} else {
654
/* as default we use the current CS size */
655
flags = 0 ;
656
657
if ( env ) {
# ifdef TARGET_X86_64
ths
authored
18 years ago
658
if (( env -> efer & MSR_EFER_LMA ) &&
659
660
661
662
663
664
665
( env -> segs [ R_CS ]. flags & DESC_L_MASK ))
flags = 2 ;
else
# endif
if ( ! ( env -> segs [ R_CS ]. flags & DESC_B_MASK ))
flags = 1 ;
}
666
667
}
# endif
668
monitor_disas ( mon , env , addr , count , is_physical , flags );
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
return ;
}
len = wsize * count ;
if ( wsize == 1 )
line_size = 8 ;
else
line_size = 16 ;
nb_per_line = line_size / wsize ;
max_digits = 0 ;
switch ( format ) {
case 'o' :
max_digits = ( wsize * 8 + 2 ) / 3 ;
break ;
default :
case 'x' :
max_digits = ( wsize * 8 ) / 4 ;
break ;
case 'u' :
case 'd' :
max_digits = ( wsize * 8 * 10 + 32 ) / 33 ;
break ;
case 'c' :
wsize = 1 ;
break ;
}
while ( len > 0 ) {
698
if ( is_physical )
699
monitor_printf ( mon , TARGET_FMT_plx ":" , addr );
700
else
701
monitor_printf ( mon , TARGET_FMT_lx ":" , ( target_ulong ) addr );
702
703
704
705
706
707
l = len ;
if ( l > line_size )
l = line_size ;
if ( is_physical ) {
cpu_physical_memory_rw ( addr , buf , l , 0 );
} else {
708
709
710
env = mon_get_cpu ();
if ( ! env )
break ;
711
if ( cpu_memory_rw_debug ( env , addr , buf , l , 0 ) < 0 ) {
712
monitor_printf ( mon , " Cannot access memory \n " );
713
714
break ;
}
715
}
ths
authored
18 years ago
716
i = 0 ;
717
718
719
720
721
722
723
724
725
726
while ( i < l ) {
switch ( wsize ) {
default :
case 1 :
v = ldub_raw ( buf + i );
break ;
case 2 :
v = lduw_raw ( buf + i );
break ;
case 4 :
727
v = ( uint32_t ) ldl_raw ( buf + i );
728
729
730
731
732
break ;
case 8 :
v = ldq_raw ( buf + i );
break ;
}
733
monitor_printf ( mon , " " );
734
735
switch ( format ) {
case 'o' :
736
monitor_printf ( mon , "%#*" PRIo64 , max_digits , v );
737
738
break ;
case 'x' :
739
monitor_printf ( mon , "0x%0*" PRIx64 , max_digits , v );
740
741
break ;
case 'u' :
742
monitor_printf ( mon , "%*" PRIu64 , max_digits , v );
743
744
break ;
case 'd' :
745
monitor_printf ( mon , "%*" PRId64 , max_digits , v );
746
747
break ;
case 'c' :
748
monitor_printc ( mon , v );
749
750
751
752
break ;
}
i += wsize ;
}
753
monitor_printf ( mon , " \n " );
754
755
756
757
758
addr += l ;
len -= l ;
}
}
759
760
761
762
763
764
# if TARGET_LONG_BITS == 64
# define GET_TLONG ( h , l ) ((( uint64_t )( h ) << 32 ) | ( l ))
# else
# define GET_TLONG ( h , l ) ( l )
# endif
765
static void do_memory_dump ( Monitor * mon , int count , int format , int size ,
766
uint32_t addrh , uint32_t addrl )
767
{
768
target_long addr = GET_TLONG ( addrh , addrl );
769
memory_dump ( mon , count , format , size , addr , 0 );
770
771
}
772
773
774
775
776
777
# if TARGET_PHYS_ADDR_BITS > 32
# define GET_TPHYSADDR ( h , l ) ((( uint64_t )( h ) << 32 ) | ( l ))
# else
# define GET_TPHYSADDR ( h , l ) ( l )
# endif
778
779
static void do_physical_memory_dump ( Monitor * mon , int count , int format ,
int size , uint32_t addrh , uint32_t addrl )
780
781
{
782
target_phys_addr_t addr = GET_TPHYSADDR ( addrh , addrl );
783
memory_dump ( mon , count , format , size , addr , 1 );
784
785
}
786
787
static void do_print ( Monitor * mon , int count , int format , int size ,
unsigned int valh , unsigned int vall )
788
{
789
790
target_phys_addr_t val = GET_TPHYSADDR ( valh , vall );
# if TARGET_PHYS_ADDR_BITS == 32
791
792
switch ( format ) {
case 'o' :
793
monitor_printf ( mon , "%#o" , val );
794
795
break ;
case 'x' :
796
monitor_printf ( mon , "%#x" , val );
797
798
break ;
case 'u' :
799
monitor_printf ( mon , "%u" , val );
800
801
802
break ;
default :
case 'd' :
803
monitor_printf ( mon , "%d" , val );
804
805
break ;
case 'c' :
806
monitor_printc ( mon , val );
807
808
break ;
}
809
810
811
# else
switch ( format ) {
case 'o' :
812
monitor_printf ( mon , "%#" PRIo64 , val );
813
814
break ;
case 'x' :
815
monitor_printf ( mon , "%#" PRIx64 , val );
816
817
break ;
case 'u' :
818
monitor_printf ( mon , "%" PRIu64 , val );
819
820
821
break ;
default :
case 'd' :
822
monitor_printf ( mon , "%" PRId64 , val );
823
824
break ;
case 'c' :
825
monitor_printc ( mon , val );
826
827
828
break ;
}
# endif
829
monitor_printf ( mon , " \n " );
830
831
}
832
static void do_memory_save ( Monitor * mon , unsigned int valh , unsigned int vall ,
833
834
835
836
837
838
839
840
841
842
843
844
845
846
uint32_t size , const char * filename )
{
FILE * f ;
target_long addr = GET_TLONG ( valh , vall );
uint32_t l ;
CPUState * env ;
uint8_t buf [ 1024 ];
env = mon_get_cpu ();
if ( ! env )
return ;
f = fopen ( filename , "wb" );
if ( ! f ) {
847
monitor_printf ( mon , "could not open '%s' \n " , filename );
848
849
850
851
852
853
854
855
856
857
858
859
860
861
return ;
}
while ( size != 0 ) {
l = sizeof ( buf );
if ( l > size )
l = size ;
cpu_memory_rw_debug ( env , addr , buf , l , 0 );
fwrite ( buf , 1 , l , f );
addr += l ;
size -= l ;
}
fclose ( f );
}
862
863
864
static void do_physical_memory_save ( Monitor * mon , unsigned int valh ,
unsigned int vall , uint32_t size ,
const char * filename )
865
866
867
868
{
FILE * f ;
uint32_t l ;
uint8_t buf [ 1024 ];
869
target_phys_addr_t addr = GET_TPHYSADDR ( valh , vall );
870
871
872
f = fopen ( filename , "wb" );
if ( ! f ) {
873
monitor_printf ( mon , "could not open '%s' \n " , filename );
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
return ;
}
while ( size != 0 ) {
l = sizeof ( buf );
if ( l > size )
l = size ;
cpu_physical_memory_rw ( addr , buf , l , 0 );
fwrite ( buf , 1 , l , f );
fflush ( f );
addr += l ;
size -= l ;
}
fclose ( f );
}
889
static void do_sum ( Monitor * mon , uint32_t start , uint32_t size )
890
891
892
893
894
895
896
897
898
899
900
901
{
uint32_t addr ;
uint8_t buf [ 1 ];
uint16_t sum ;
sum = 0 ;
for ( addr = start ; addr < ( start + size ); addr ++ ) {
cpu_physical_memory_rw ( addr , buf , 1 , 0 );
/* BSD sum algorithm ('sum' Unix command) */
sum = ( sum >> 1 ) | ( sum << 15 );
sum += buf [ 0 ];
}
902
monitor_printf ( mon , "%05d \n " , sum );
903
904
}
905
906
907
908
909
910
911
912
typedef struct {
int keycode ;
const char * name ;
} KeyDef ;
static const KeyDef key_defs [] = {
{ 0x2a , "shift" },
{ 0x36 , "shift_r" },
ths
authored
18 years ago
913
914
915
{ 0x38 , "alt" },
{ 0xb8 , "alt_r" },
ths
authored
17 years ago
916
917
{ 0x64 , "altgr" },
{ 0xe4 , "altgr_r" },
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
{ 0x1d , "ctrl" },
{ 0x9d , "ctrl_r" },
{ 0xdd , "menu" },
{ 0x01 , "esc" },
{ 0x02 , "1" },
{ 0x03 , "2" },
{ 0x04 , "3" },
{ 0x05 , "4" },
{ 0x06 , "5" },
{ 0x07 , "6" },
{ 0x08 , "7" },
{ 0x09 , "8" },
{ 0x0a , "9" },
{ 0x0b , "0" },
935
936
{ 0x0c , "minus" },
{ 0x0d , "equal" },
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
{ 0x0e , "backspace" },
{ 0x0f , "tab" },
{ 0x10 , "q" },
{ 0x11 , "w" },
{ 0x12 , "e" },
{ 0x13 , "r" },
{ 0x14 , "t" },
{ 0x15 , "y" },
{ 0x16 , "u" },
{ 0x17 , "i" },
{ 0x18 , "o" },
{ 0x19 , "p" },
{ 0x1c , "ret" },
{ 0x1e , "a" },
{ 0x1f , "s" },
{ 0x20 , "d" },
{ 0x21 , "f" },
{ 0x22 , "g" },
{ 0x23 , "h" },
{ 0x24 , "j" },
{ 0x25 , "k" },
{ 0x26 , "l" },
{ 0x2c , "z" },
{ 0x2d , "x" },
{ 0x2e , "c" },
{ 0x2f , "v" },
{ 0x30 , "b" },
{ 0x31 , "n" },
{ 0x32 , "m" },
970
971
972
{ 0x33 , "comma" },
{ 0x34 , "dot" },
{ 0x35 , "slash" },
ths
authored
18 years ago
973
974
975
{ 0x37 , "asterisk" },
976
{ 0x39 , "spc" },
977
{ 0x3a , "caps_lock" },
978
979
980
981
982
983
984
985
986
987
{ 0x3b , "f1" },
{ 0x3c , "f2" },
{ 0x3d , "f3" },
{ 0x3e , "f4" },
{ 0x3f , "f5" },
{ 0x40 , "f6" },
{ 0x41 , "f7" },
{ 0x42 , "f8" },
{ 0x43 , "f9" },
{ 0x44 , "f10" },
988
{ 0x45 , "num_lock" },
989
990
{ 0x46 , "scroll_lock" },
991
992
{ 0xb5 , "kp_divide" },
{ 0x37 , "kp_multiply" },
ths
authored
18 years ago
993
{ 0x4a , "kp_subtract" },
994
995
996
{ 0x4e , "kp_add" },
{ 0x9c , "kp_enter" },
{ 0x53 , "kp_decimal" },
997
{ 0x54 , "sysrq" },
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
{ 0x52 , "kp_0" },
{ 0x4f , "kp_1" },
{ 0x50 , "kp_2" },
{ 0x51 , "kp_3" },
{ 0x4b , "kp_4" },
{ 0x4c , "kp_5" },
{ 0x4d , "kp_6" },
{ 0x47 , "kp_7" },
{ 0x48 , "kp_8" },
{ 0x49 , "kp_9" },
ths
authored
18 years ago
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
{ 0x56 , "<" },
{ 0x57 , "f11" },
{ 0x58 , "f12" },
{ 0xb7 , "print" },
{ 0xc7 , "home" },
{ 0xc9 , "pgup" },
{ 0xd1 , "pgdn" },
{ 0xcf , "end" },
{ 0xcb , "left" },
{ 0xc8 , "up" },
{ 0xd0 , "down" },
{ 0xcd , "right" },
{ 0xd2 , "insert" },
{ 0xd3 , "delete" },
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
# if defined ( TARGET_SPARC ) && ! defined ( TARGET_SPARC64 )
{ 0xf0 , "stop" },
{ 0xf1 , "again" },
{ 0xf2 , "props" },
{ 0xf3 , "undo" },
{ 0xf4 , "front" },
{ 0xf5 , "copy" },
{ 0xf6 , "open" },
{ 0xf7 , "paste" },
{ 0xf8 , "find" },
{ 0xf9 , "cut" },
{ 0xfa , "lf" },
{ 0xfb , "help" },
{ 0xfc , "meta_l" },
{ 0xfd , "meta_r" },
{ 0xfe , "compose" },
# endif
1046
1047
1048
1049
1050
1051
{ 0 , NULL },
};
static int get_keycode ( const char * key )
{
const KeyDef * p ;
1052
1053
char * endp ;
int ret ;
1054
1055
1056
1057
1058
for ( p = key_defs ; p -> name != NULL ; p ++ ) {
if ( ! strcmp ( key , p -> name ))
return p -> keycode ;
}
1059
1060
1061
1062
1063
if ( strstart ( key , "0x" , NULL )) {
ret = strtoul ( key , & endp , 0 );
if ( * endp == '\0' && ret >= 0x01 && ret <= 0xff )
return ret ;
}
1064
1065
1066
return - 1 ;
}
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
# define MAX_KEYCODES 16
static uint8_t keycodes [ MAX_KEYCODES ];
static int nb_pending_keycodes ;
static QEMUTimer * key_timer ;
static void release_keys ( void * opaque )
{
int keycode ;
while ( nb_pending_keycodes > 0 ) {
nb_pending_keycodes -- ;
keycode = keycodes [ nb_pending_keycodes ];
if ( keycode & 0x80 )
kbd_put_keycode ( 0xe0 );
kbd_put_keycode ( keycode | 0x80 );
}
}
1085
1086
static void do_sendkey ( Monitor * mon , const char * string , int has_hold_time ,
int hold_time )
1087
{
1088
1089
1090
1091
char keyname_buf [ 16 ];
char * separator ;
int keyname_len , keycode , i ;
1092
1093
1094
1095
1096
1097
1098
if ( nb_pending_keycodes > 0 ) {
qemu_del_timer ( key_timer );
release_keys ( NULL );
}
if ( ! has_hold_time )
hold_time = 100 ;
i = 0 ;
1099
1100
1101
1102
1103
1104
while ( 1 ) {
separator = strchr ( string , '-' );
keyname_len = separator ? separator - string : strlen ( string );
if ( keyname_len > 0 ) {
pstrcpy ( keyname_buf , sizeof ( keyname_buf ), string );
if ( keyname_len > sizeof ( keyname_buf ) - 1 ) {
1105
monitor_printf ( mon , "invalid key: '%s...' \n " , keyname_buf );
1106
return ;
1107
}
1108
if ( i == MAX_KEYCODES ) {
1109
monitor_printf ( mon , "too many keys \n " );
1110
1111
1112
1113
1114
return ;
}
keyname_buf [ keyname_len ] = 0 ;
keycode = get_keycode ( keyname_buf );
if ( keycode < 0 ) {
1115
monitor_printf ( mon , "unknown key: '%s' \n " , keyname_buf );
1116
1117
return ;
}
1118
keycodes [ i ++ ] = keycode ;
1119
}
1120
if ( ! separator )
1121
break ;
1122
string = separator + 1 ;
1123
}
1124
nb_pending_keycodes = i ;
1125
/* key down events */
1126
for ( i = 0 ; i < nb_pending_keycodes ; i ++ ) {
1127
1128
1129
1130
1131
keycode = keycodes [ i ];
if ( keycode & 0x80 )
kbd_put_keycode ( 0xe0 );
kbd_put_keycode ( keycode & 0x7f );
}
1132
/* delayed key up events */
1133
1134
qemu_mod_timer ( key_timer , qemu_get_clock ( vm_clock ) +
muldiv64 ( ticks_per_sec , hold_time , 1000 ));
1135
1136
}
1137
1138
static int mouse_button_state ;
1139
static void do_mouse_move ( Monitor * mon , const char * dx_str , const char * dy_str ,
1140
1141
1142
1143
1144
1145
const char * dz_str )
{
int dx , dy , dz ;
dx = strtol ( dx_str , NULL , 0 );
dy = strtol ( dy_str , NULL , 0 );
dz = 0 ;
ths
authored
18 years ago
1146
if ( dz_str )
1147
1148
1149
1150
dz = strtol ( dz_str , NULL , 0 );
kbd_mouse_event ( dx , dy , dz , mouse_button_state );
}
1151
static void do_mouse_button ( Monitor * mon , int button_state )
1152
1153
1154
1155
1156
{
mouse_button_state = button_state ;
kbd_mouse_event ( 0 , 0 , 0 , mouse_button_state );
}
1157
1158
static void do_ioport_read ( Monitor * mon , int count , int format , int size ,
int addr , int has_index , int index )
1159
1160
1161
1162
1163
{
uint32_t val ;
int suffix ;
if ( has_index ) {
1164
cpu_outb ( NULL , addr & IOPORTS_MASK , index & 0xff );
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
addr ++ ;
}
addr &= 0xffff ;
switch ( size ) {
default :
case 1 :
val = cpu_inb ( NULL , addr );
suffix = 'b' ;
break ;
case 2 :
val = cpu_inw ( NULL , addr );
suffix = 'w' ;
break ;
case 4 :
val = cpu_inl ( NULL , addr );
suffix = 'l' ;
break ;
}
1184
1185
monitor_printf ( mon , "port%c[0x%04x] = %#0*x \n " ,
suffix , addr , size * 2 , val );
1186
}
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
static void do_ioport_write ( Monitor * mon , int count , int format , int size ,
int addr , int val )
{
addr &= IOPORTS_MASK ;
switch ( size ) {
default :
case 1 :
cpu_outb ( NULL , addr , val );
break ;
case 2 :
cpu_outw ( NULL , addr , val );
break ;
case 4 :
cpu_outl ( NULL , addr , val );
break ;
}
}
1207
static void do_boot_set ( Monitor * mon , const char * bootdevice )
1208
1209
1210
{
int res ;
1211
1212
1213
1214
1215
res = qemu_boot_set ( bootdevice );
if ( res == 0 ) {
monitor_printf ( mon , "boot device list now set to %s \n " , bootdevice );
} else if ( res > 0 ) {
monitor_printf ( mon , "setting boot device list failed \n " );
1216
} else {
1217
1218
monitor_printf ( mon , "no function defined to set boot device list for "
"this architecture \n " );
1219
1220
1221
}
}
1222
static void do_system_reset ( Monitor * mon )
1223
1224
1225
1226
{
qemu_system_reset_request ();
}
1227
static void do_system_powerdown ( Monitor * mon )
1228
1229
1230
1231
{
qemu_system_powerdown_request ();
}
1232
# if defined ( TARGET_I386 )
1233
static void print_pte ( Monitor * mon , uint32_t addr , uint32_t pte , uint32_t mask )
1234
{
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
monitor_printf ( mon , "%08x: %08x %c%c%c%c%c%c%c%c \n " ,
addr ,
pte & mask ,
pte & PG_GLOBAL_MASK ? 'G' : '-' ,
pte & PG_PSE_MASK ? 'P' : '-' ,
pte & PG_DIRTY_MASK ? 'D' : '-' ,
pte & PG_ACCESSED_MASK ? 'A' : '-' ,
pte & PG_PCD_MASK ? 'C' : '-' ,
pte & PG_PWT_MASK ? 'T' : '-' ,
pte & PG_USER_MASK ? 'U' : '-' ,
pte & PG_RW_MASK ? 'W' : '-' );
1246
1247
}
1248
static void tlb_info ( Monitor * mon )
1249
{
1250
CPUState * env ;
1251
1252
1253
int l1 , l2 ;
uint32_t pgd , pde , pte ;
1254
1255
1256
1257
env = mon_get_cpu ();
if ( ! env )
return ;
1258
if ( ! ( env -> cr [ 0 ] & CR0_PG_MASK )) {
1259
monitor_printf ( mon , "PG disabled \n " );
1260
1261
1262
1263
1264
1265
1266
1267
return ;
}
pgd = env -> cr [ 3 ] & ~ 0xfff ;
for ( l1 = 0 ; l1 < 1024 ; l1 ++ ) {
cpu_physical_memory_read ( pgd + l1 * 4 , ( uint8_t * ) & pde , 4 );
pde = le32_to_cpu ( pde );
if ( pde & PG_PRESENT_MASK ) {
if (( pde & PG_PSE_MASK ) && ( env -> cr [ 4 ] & CR4_PSE_MASK )) {
1268
print_pte ( mon , ( l1 << 22 ), pde , ~ (( 1 << 20 ) - 1 ));
1269
1270
} else {
for ( l2 = 0 ; l2 < 1024 ; l2 ++ ) {
ths
authored
18 years ago
1271
cpu_physical_memory_read (( pde & ~ 0xfff ) + l2 * 4 ,
1272
1273
1274
( uint8_t * ) & pte , 4 );
pte = le32_to_cpu ( pte );
if ( pte & PG_PRESENT_MASK ) {
1275
print_pte ( mon , ( l1 << 22 ) + ( l2 << 12 ),
ths
authored
18 years ago
1276
pte & ~ PG_PSE_MASK ,
1277
1278
1279
1280
1281
1282
1283
1284
~ 0xfff );
}
}
}
}
}
}
1285
static void mem_print ( Monitor * mon , uint32_t * pstart , int * plast_prot ,
1286
1287
uint32_t end , int prot )
{
1288
1289
1290
int prot1 ;
prot1 = * plast_prot ;
if ( prot != prot1 ) {
1291
if ( * pstart != - 1 ) {
1292
1293
1294
1295
1296
monitor_printf ( mon , "%08x-%08x %08x %c%c%c \n " ,
* pstart , end , end - * pstart ,
prot1 & PG_USER_MASK ? 'u' : '-' ,
'r' ,
prot1 & PG_RW_MASK ? 'w' : '-' );
1297
1298
1299
1300
1301
1302
1303
1304
1305
}
if ( prot != 0 )
* pstart = end ;
else
* pstart = - 1 ;
* plast_prot = prot ;
}
}
1306
static void mem_info ( Monitor * mon )
1307
{
1308
CPUState * env ;
1309
1310
1311
int l1 , l2 , prot , last_prot ;
uint32_t pgd , pde , pte , start , end ;
1312
1313
1314
1315
env = mon_get_cpu ();
if ( ! env )
return ;
1316
if ( ! ( env -> cr [ 0 ] & CR0_PG_MASK )) {
1317
monitor_printf ( mon , "PG disabled \n " );
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
return ;
}
pgd = env -> cr [ 3 ] & ~ 0xfff ;
last_prot = 0 ;
start = - 1 ;
for ( l1 = 0 ; l1 < 1024 ; l1 ++ ) {
cpu_physical_memory_read ( pgd + l1 * 4 , ( uint8_t * ) & pde , 4 );
pde = le32_to_cpu ( pde );
end = l1 << 22 ;
if ( pde & PG_PRESENT_MASK ) {
if (( pde & PG_PSE_MASK ) && ( env -> cr [ 4 ] & CR4_PSE_MASK )) {
prot = pde & ( PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK );
1330
mem_print ( mon , & start , & last_prot , end , prot );
1331
1332
} else {
for ( l2 = 0 ; l2 < 1024 ; l2 ++ ) {
ths
authored
18 years ago
1333
cpu_physical_memory_read (( pde & ~ 0xfff ) + l2 * 4 ,
1334
1335
1336
1337
1338
1339
1340
1341
( uint8_t * ) & pte , 4 );
pte = le32_to_cpu ( pte );
end = ( l1 << 22 ) + ( l2 << 12 );
if ( pte & PG_PRESENT_MASK ) {
prot = pte & ( PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK );
} else {
prot = 0 ;
}
1342
mem_print ( mon , & start , & last_prot , end , prot );
1343
1344
1345
1346
}
}
} else {
prot = 0 ;
1347
mem_print ( mon , & start , & last_prot , end , prot );
1348
1349
1350
1351
1352
}
}
}
# endif
1353
1354
# if defined ( TARGET_SH4 )
1355
static void print_tlb ( Monitor * mon , int idx , tlb_t * tlb )
1356
{
1357
1358
1359
1360
1361
1362
1363
1364
monitor_printf ( mon , " tlb%i: \t "
"asid=%hhu vpn=%x \t ppn=%x \t sz=%hhu size=%u \t "
"v=%hhu shared=%hhu cached=%hhu prot=%hhu "
"dirty=%hhu writethrough=%hhu \n " ,
idx ,
tlb -> asid , tlb -> vpn , tlb -> ppn , tlb -> sz , tlb -> size ,
tlb -> v , tlb -> sh , tlb -> c , tlb -> pr ,
tlb -> d , tlb -> wt );
1365
1366
}
1367
static void tlb_info ( Monitor * mon )
1368
1369
1370
1371
{
CPUState * env = mon_get_cpu ();
int i ;
1372
monitor_printf ( mon , "ITLB: \n " );
1373
for ( i = 0 ; i < ITLB_SIZE ; i ++ )
1374
1375
print_tlb ( mon , i , & env -> itlb [ i ]);
monitor_printf ( mon , "UTLB: \n " );
1376
for ( i = 0 ; i < UTLB_SIZE ; i ++ )
1377
print_tlb ( mon , i , & env -> utlb [ i ]);
1378
1379
1380
1381
}
# endif
1382
static void do_info_kqemu ( Monitor * mon )
1383
{
1384
# ifdef CONFIG_KQEMU
1385
CPUState * env ;
1386
1387
int val ;
val = 0 ;
1388
1389
env = mon_get_cpu ();
if ( ! env ) {
1390
monitor_printf ( mon , "No cpu initialized yet" );
1391
1392
1393
return ;
}
val = env -> kqemu_enabled ;
1394
monitor_printf ( mon , "kqemu support: " );
1395
1396
1397
switch ( val ) {
default :
case 0 :
1398
monitor_printf ( mon , "disabled \n " );
1399
1400
break ;
case 1 :
1401
monitor_printf ( mon , "enabled for user code \n " );
1402
1403
break ;
case 2 :
1404
monitor_printf ( mon , "enabled for user and kernel code \n " );
1405
1406
break ;
}
1407
# else
1408
monitor_printf ( mon , "kqemu support: not compiled \n " );
1409
# endif
ths
authored
18 years ago
1410
}
1411
1412
static void do_info_kvm ( Monitor * mon )
1413
1414
{
# ifdef CONFIG_KVM
1415
monitor_printf ( mon , "kvm support: " );
1416
if ( kvm_enabled ())
1417
monitor_printf ( mon , "enabled \n " );
1418
else
1419
monitor_printf ( mon , "disabled \n " );
1420
# else
1421
monitor_printf ( mon , "kvm support: not compiled \n " );
1422
1423
1424
# endif
}
1425
1426
static void do_info_numa ( Monitor * mon )
{
1427
int i ;
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
CPUState * env ;
monitor_printf ( mon , "%d nodes \n " , nb_numa_nodes );
for ( i = 0 ; i < nb_numa_nodes ; i ++ ) {
monitor_printf ( mon , "node %d cpus:" , i );
for ( env = first_cpu ; env != NULL ; env = env -> next_cpu ) {
if ( env -> numa_node == i ) {
monitor_printf ( mon , " %d" , env -> cpu_index );
}
}
monitor_printf ( mon , " \n " );
monitor_printf ( mon , "node %d size: %" PRId64 " MB \n " , i ,
node_mem [ i ] >> 20 );
}
}
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
# ifdef CONFIG_PROFILER
int64_t kqemu_time ;
int64_t qemu_time ;
int64_t kqemu_exec_count ;
int64_t dev_time ;
int64_t kqemu_ret_int_count ;
int64_t kqemu_ret_excp_count ;
int64_t kqemu_ret_intr_count ;
1454
static void do_info_profile ( Monitor * mon )
1455
1456
1457
1458
1459
{
int64_t total ;
total = qemu_time ;
if ( total == 0 )
total = 1 ;
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
monitor_printf ( mon , "async time %" PRId64 " (%0.3f) \n " ,
dev_time , dev_time / ( double ) ticks_per_sec );
monitor_printf ( mon , "qemu time %" PRId64 " (%0.3f) \n " ,
qemu_time , qemu_time / ( double ) ticks_per_sec );
monitor_printf ( mon , "kqemu time %" PRId64 " (%0.3f %0.1f%%) count=%"
PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%"
PRId64 " \n " ,
kqemu_time , kqemu_time / ( double ) ticks_per_sec ,
kqemu_time / ( double ) total * 100 . 0 ,
kqemu_exec_count ,
kqemu_ret_int_count ,
kqemu_ret_excp_count ,
kqemu_ret_intr_count );
1473
1474
1475
1476
1477
1478
1479
qemu_time = 0 ;
kqemu_time = 0 ;
kqemu_exec_count = 0 ;
dev_time = 0 ;
kqemu_ret_int_count = 0 ;
kqemu_ret_excp_count = 0 ;
kqemu_ret_intr_count = 0 ;
1480
# ifdef CONFIG_KQEMU
1481
1482
1483
1484
kqemu_record_dump ();
# endif
}
# else
1485
static void do_info_profile ( Monitor * mon )
1486
{
1487
monitor_printf ( mon , "Internal profiler not compiled \n " );
1488
1489
1490
}
# endif
1491
1492
1493
/* Capture support */
static LIST_HEAD ( capture_list_head , CaptureState ) capture_head ;
1494
static void do_info_capture ( Monitor * mon )
1495
1496
1497
1498
1499
{
int i ;
CaptureState * s ;
for ( s = capture_head . lh_first , i = 0 ; s ; s = s -> entries . le_next , ++ i ) {
1500
monitor_printf ( mon , "[%d]: " , i );
1501
1502
1503
1504
s -> ops . info ( s -> opaque );
}
}
1505
# ifdef HAS_AUDIO
1506
static void do_stop_capture ( Monitor * mon , int n )
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
{
int i ;
CaptureState * s ;
for ( s = capture_head . lh_first , i = 0 ; s ; s = s -> entries . le_next , ++ i ) {
if ( i == n ) {
s -> ops . destroy ( s -> opaque );
LIST_REMOVE ( s , entries );
qemu_free ( s );
return ;
}
}
}
1521
1522
1523
1524
static void do_wav_capture ( Monitor * mon , const char * path ,
int has_freq , int freq ,
int has_bits , int bits ,
int has_channels , int nchannels )
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
{
CaptureState * s ;
s = qemu_mallocz ( sizeof ( * s ));
freq = has_freq ? freq : 44100 ;
bits = has_bits ? bits : 16 ;
nchannels = has_channels ? nchannels : 2 ;
if ( wav_start_capture ( s , path , freq , bits , nchannels )) {
1535
monitor_printf ( mon , "Faied to add wave capture \n " );
1536
1537
1538
1539
1540
1541
qemu_free ( s );
}
LIST_INSERT_HEAD ( & capture_head , s , entries );
}
# endif
1542
# if defined ( TARGET_I386 )
1543
static void do_inject_nmi ( Monitor * mon , int cpu_index )
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
{
CPUState * env ;
for ( env = first_cpu ; env != NULL ; env = env -> next_cpu )
if ( env -> cpu_index == cpu_index ) {
cpu_interrupt ( env , CPU_INTERRUPT_NMI );
break ;
}
}
# endif
1555
static void do_info_status ( Monitor * mon )
1556
{
1557
1558
1559
1560
1561
1562
1563
if ( vm_running ) {
if ( singlestep ) {
monitor_printf ( mon , "VM status: running (single step mode) \n " );
} else {
monitor_printf ( mon , "VM status: running \n " );
}
} else
1564
monitor_printf ( mon , "VM status: paused \n " );
1565
1566
1567
}
1568
static void do_balloon ( Monitor * mon , int value )
1569
1570
1571
1572
1573
{
ram_addr_t target = value ;
qemu_balloon ( target << 20 );
}
1574
static void do_info_balloon ( Monitor * mon )
1575
1576
1577
1578
{
ram_addr_t actual ;
actual = qemu_balloon_status ();
1579
if ( kvm_enabled () && ! kvm_has_sync_mmu ())
1580
1581
monitor_printf ( mon , "Using KVM without synchronous MMU, "
"ballooning disabled \n " );
1582
else if ( actual == 0 )
1583
monitor_printf ( mon , "Ballooning not activated in VM \n " );
1584
else
1585
monitor_printf ( mon , "balloon: actual=%d \n " , ( int )( actual >> 20 ));
1586
1587
}
1588
static qemu_acl * find_acl ( Monitor * mon , const char * name )
1589
{
1590
qemu_acl * acl = qemu_acl_find ( name );
1591
1592
if ( ! acl ) {
1593
monitor_printf ( mon , "acl: unknown list '%s' \n " , name );
1594
}
1595
1596
1597
1598
1599
1600
1601
1602
return acl ;
}
static void do_acl_show ( Monitor * mon , const char * aclname )
{
qemu_acl * acl = find_acl ( mon , aclname );
qemu_acl_entry * entry ;
int i = 0 ;
1603
1604
if ( acl ) {
1605
monitor_printf ( mon , "policy: %s \n " ,
1606
acl -> defaultDeny ? "deny" : "allow" );
1607
1608
1609
TAILQ_FOREACH ( entry , & acl -> entries , next ) {
i ++ ;
monitor_printf ( mon , "%d: %s %s \n " , i ,
1610
entry -> deny ? "deny" : "allow" , entry -> match );
1611
}
1612
1613
1614
1615
1616
1617
1618
1619
}
}
static void do_acl_reset ( Monitor * mon , const char * aclname )
{
qemu_acl * acl = find_acl ( mon , aclname );
if ( acl ) {
1620
1621
qemu_acl_reset ( acl );
monitor_printf ( mon , "acl: removed all rules \n " );
1622
1623
1624
1625
1626
1627
1628
}
}
static void do_acl_policy ( Monitor * mon , const char * aclname ,
const char * policy )
{
qemu_acl * acl = find_acl ( mon , aclname );
1629
1630
1631
if ( acl ) {
if ( strcmp ( policy , "allow" ) == 0 ) {
1632
1633
acl -> defaultDeny = 0 ;
monitor_printf ( mon , "acl: policy set to 'allow' \n " );
1634
} else if ( strcmp ( policy , "deny" ) == 0 ) {
1635
1636
1637
acl -> defaultDeny = 1 ;
monitor_printf ( mon , "acl: policy set to 'deny' \n " );
} else {
1638
1639
monitor_printf ( mon , "acl: unknown policy '%s', "
"expected 'deny' or 'allow' \n " , policy );
1640
}
1641
1642
}
}
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
static void do_acl_add ( Monitor * mon , const char * aclname ,
const char * match , const char * policy ,
int has_index , int index )
{
qemu_acl * acl = find_acl ( mon , aclname );
int deny , ret ;
if ( acl ) {
if ( strcmp ( policy , "allow" ) == 0 ) {
deny = 0 ;
} else if ( strcmp ( policy , "deny" ) == 0 ) {
deny = 1 ;
} else {
monitor_printf ( mon , "acl: unknown policy '%s', "
"expected 'deny' or 'allow' \n " , policy );
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
return ;
}
if ( has_index )
ret = qemu_acl_insert ( acl , deny , match , index );
else
ret = qemu_acl_append ( acl , deny , match );
if ( ret < 0 )
monitor_printf ( mon , "acl: unable to add acl entry \n " );
else
monitor_printf ( mon , "acl: added rule at position %d \n " , ret );
1669
1670
}
}
1671
1672
1673
1674
1675
static void do_acl_remove ( Monitor * mon , const char * aclname , const char * match )
{
qemu_acl * acl = find_acl ( mon , aclname );
int ret ;
1676
1677
if ( acl ) {
1678
1679
1680
1681
1682
ret = qemu_acl_remove ( acl , match );
if ( ret < 0 )
monitor_printf ( mon , "acl: no matching acl entry \n " );
else
monitor_printf ( mon , "acl: removed rule at position %d \n " , ret );
1683
1684
1685
}
}
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
# if defined ( TARGET_I386 )
static void do_inject_mce ( Monitor * mon ,
int cpu_index , int bank ,
unsigned status_hi , unsigned status_lo ,
unsigned mcg_status_hi , unsigned mcg_status_lo ,
unsigned addr_hi , unsigned addr_lo ,
unsigned misc_hi , unsigned misc_lo )
{
CPUState * cenv ;
uint64_t status = (( uint64_t ) status_hi << 32 ) | status_lo ;
uint64_t mcg_status = (( uint64_t ) mcg_status_hi << 32 ) | mcg_status_lo ;
uint64_t addr = (( uint64_t ) addr_hi << 32 ) | addr_lo ;
uint64_t misc = (( uint64_t ) misc_hi << 32 ) | misc_lo ;
for ( cenv = first_cpu ; cenv != NULL ; cenv = cenv -> next_cpu )
if ( cenv -> cpu_index == cpu_index && cenv -> mcg_cap ) {
cpu_inject_x86_mce ( cenv , bank , status , mcg_status , addr , misc );
break ;
}
}
# endif
1708
static const mon_cmd_t mon_cmds [] = {
1709
# include "qemu-monitor.h"
ths
authored
18 years ago
1710
{ NULL , NULL , },
1711
1712
};
1713
/* Please update qemu-monitor.hx when adding or changing commands */
1714
static const mon_cmd_t info_cmds [] = {
1715
{ "version" , "" , do_info_version ,
1716
"" , "show the version of QEMU" },
1717
{ "network" , "" , do_info_network ,
1718
"" , "show the network state" },
1719
1720
{ "chardev" , "" , qemu_chr_info ,
"" , "show the character devices" },
1721
{ "block" , "" , bdrv_info ,
1722
"" , "show the block devices" },
1723
{ "blockstats" , "" , bdrv_info_stats ,
ths
authored
17 years ago
1724
"" , "show block device statistics" },
1725
1726
{ "registers" , "" , do_info_registers ,
"" , "show the cpu registers" },
1727
1728
{ "cpus" , "" , do_info_cpus ,
"" , "show infos for each CPU" },
1729
1730
{ "history" , "" , do_info_history ,
"" , "show the command line history" , },
1731
1732
{ "irq" , "" , irq_info ,
"" , "show the interrupts statistics (if available)" , },
1733
1734
{ "pic" , "" , pic_info ,
"" , "show i8259 (PIC) state" , },
1735
1736
{ "pci" , "" , pci_info ,
"" , "show PCI info" , },
1737
# if defined ( TARGET_I386 ) || defined ( TARGET_SH4 )
1738
1739
{ "tlb" , "" , tlb_info ,
"" , "show virtual to physical memory mappings" , },
1740
1741
# endif
# if defined ( TARGET_I386 )
1742
1743
{ "mem" , "" , mem_info ,
"" , "show the active virtual memory mappings" , },
1744
1745
{ "hpet" , "" , do_info_hpet ,
"" , "show state of HPET" , },
1746
# endif
1747
1748
{ "jit" , "" , do_info_jit ,
"" , "show dynamic compiler info" , },
1749
{ "kqemu" , "" , do_info_kqemu ,
1750
"" , "show KQEMU information" , },
1751
{ "kvm" , "" , do_info_kvm ,
1752
"" , "show KVM information" , },
1753
1754
{ "numa" , "" , do_info_numa ,
"" , "show NUMA information" , },
1755
1756
1757
1758
{ "usb" , "" , usb_info ,
"" , "show guest USB devices" , },
{ "usbhost" , "" , usb_host_info ,
"" , "show host USB devices" , },
1759
1760
{ "profile" , "" , do_info_profile ,
"" , "show profiling information" , },
1761
{ "capture" , "" , do_info_capture ,
1762
"" , "show capture information" },
1763
{ "snapshots" , "" , do_info_snapshots ,
1764
"" , "show the currently saved VM snapshots" },
1765
1766
{ "status" , "" , do_info_status ,
"" , "show the current VM status (running|paused)" },
1767
1768
{ "pcmcia" , "" , pcmcia_info ,
"" , "show guest PCMCIA status" },
ths
authored
18 years ago
1769
1770
{ "mice" , "" , do_info_mice ,
"" , "show which guest mouse is receiving events" },
1771
1772
{ "vnc" , "" , do_info_vnc ,
"" , "show the vnc server status" },
ths
authored
18 years ago
1773
1774
{ "name" , "" , do_info_name ,
"" , "show the current VM name" },
1775
1776
{ "uuid" , "" , do_info_uuid ,
"" , "show the current VM UUID" },
1777
1778
1779
1780
# if defined ( TARGET_PPC )
{ "cpustats" , "" , do_info_cpu_stats ,
"" , "show CPU statistics" , },
# endif
1781
# if defined ( CONFIG_SLIRP )
1782
1783
{ "usernet" , "" , do_info_usernet ,
"" , "show user network stack connection states" , },
1784
# endif
1785
{ "migrate" , "" , do_info_migrate , "" , "show migration status" },
1786
1787
{ "balloon" , "" , do_info_balloon ,
"" , "show balloon information" },
1788
1789
{ "qtree" , "" , do_info_qtree ,
"" , "show device tree" },
1790
1791
1792
{ NULL , NULL , },
};
1793
1794
1795
1796
1797
/*******************************************************************/
static const char * pch ;
static jmp_buf expr_env ;
1798
1799
1800
# define MD_TLONG 0
# define MD_I32 1
1801
1802
1803
typedef struct MonitorDef {
const char * name ;
int offset ;
1804
target_long ( * get_value )( const struct MonitorDef * md , int val );
1805
int type ;
1806
1807
} MonitorDef ;
1808
# if defined ( TARGET_I386 )
1809
static target_long monitor_get_pc ( const struct MonitorDef * md , int val )
1810
{
1811
1812
1813
1814
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
return env -> eip + env -> segs [ R_CS ]. base ;
1815
1816
1817
}
# endif
1818
# if defined ( TARGET_PPC )
1819
static target_long monitor_get_ccr ( const struct MonitorDef * md , int val )
1820
{
1821
CPUState * env = mon_get_cpu ();
1822
1823
1824
unsigned int u ;
int i ;
1825
1826
1827
if ( ! env )
return 0 ;
1828
1829
u = 0 ;
for ( i = 0 ; i < 8 ; i ++ )
1830
u |= env -> crf [ i ] << ( 32 - ( 4 * i ));
1831
1832
1833
1834
return u ;
}
1835
static target_long monitor_get_msr ( const struct MonitorDef * md , int val )
1836
{
1837
1838
1839
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
1840
return env -> msr ;
1841
1842
}
1843
static target_long monitor_get_xer ( const struct MonitorDef * md , int val )
1844
{
1845
1846
1847
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
1848
return env -> xer ;
1849
}
1850
1851
static target_long monitor_get_decr ( const struct MonitorDef * md , int val )
1852
{
1853
1854
1855
1856
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
return cpu_ppc_load_decr ( env );
1857
1858
}
1859
static target_long monitor_get_tbu ( const struct MonitorDef * md , int val )
1860
{
1861
1862
1863
1864
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
return cpu_ppc_load_tbu ( env );
1865
1866
}
1867
static target_long monitor_get_tbl ( const struct MonitorDef * md , int val )
1868
{
1869
1870
1871
1872
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
return cpu_ppc_load_tbl ( env );
1873
}
1874
1875
# endif
1876
# if defined ( TARGET_SPARC )
1877
# ifndef TARGET_SPARC64
1878
static target_long monitor_get_psr ( const struct MonitorDef * md , int val )
1879
{
1880
1881
1882
1883
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
return GET_PSR ( env );
1884
}
1885
# endif
1886
1887
static target_long monitor_get_reg ( const struct MonitorDef * md , int val )
1888
{
1889
1890
1891
1892
CPUState * env = mon_get_cpu ();
if ( ! env )
return 0 ;
return env -> regwptr [ val ];
1893
1894
1895
}
# endif
1896
static const MonitorDef monitor_defs [] = {
1897
# ifdef TARGET_I386
1898
1899
# define SEG ( name , seg ) \
1900
{ name , offsetof ( CPUState , segs [ seg ]. selector ), NULL , MD_I32 }, \
1901
{ name ".base" , offsetof ( CPUState , segs [ seg ]. base ) }, \
1902
{ name ".limit" , offsetof ( CPUState , segs [ seg ]. limit ), NULL , MD_I32 },
1903
1904
1905
1906
1907
1908
1909
1910
{ "eax" , offsetof ( CPUState , regs [ 0 ]) },
{ "ecx" , offsetof ( CPUState , regs [ 1 ]) },
{ "edx" , offsetof ( CPUState , regs [ 2 ]) },
{ "ebx" , offsetof ( CPUState , regs [ 3 ]) },
{ "esp|sp" , offsetof ( CPUState , regs [ 4 ]) },
{ "ebp|fp" , offsetof ( CPUState , regs [ 5 ]) },
{ "esi" , offsetof ( CPUState , regs [ 6 ]) },
1911
{ "edi" , offsetof ( CPUState , regs [ 7 ]) },
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
# ifdef TARGET_X86_64
{ "r8" , offsetof ( CPUState , regs [ 8 ]) },
{ "r9" , offsetof ( CPUState , regs [ 9 ]) },
{ "r10" , offsetof ( CPUState , regs [ 10 ]) },
{ "r11" , offsetof ( CPUState , regs [ 11 ]) },
{ "r12" , offsetof ( CPUState , regs [ 12 ]) },
{ "r13" , offsetof ( CPUState , regs [ 13 ]) },
{ "r14" , offsetof ( CPUState , regs [ 14 ]) },
{ "r15" , offsetof ( CPUState , regs [ 15 ]) },
# endif
1922
{ "eflags" , offsetof ( CPUState , eflags ) },
1923
1924
1925
1926
{ "eip" , offsetof ( CPUState , eip ) },
SEG ( "cs" , R_CS )
SEG ( "ds" , R_DS )
SEG ( "es" , R_ES )
1927
SEG ( "ss" , R_SS )
1928
1929
1930
SEG ( "fs" , R_FS )
SEG ( "gs" , R_GS )
{ "pc" , 0 , monitor_get_pc , },
1931
# elif defined ( TARGET_PPC )
1932
/* General purpose registers */
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
{ "r0" , offsetof ( CPUState , gpr [ 0 ]) },
{ "r1" , offsetof ( CPUState , gpr [ 1 ]) },
{ "r2" , offsetof ( CPUState , gpr [ 2 ]) },
{ "r3" , offsetof ( CPUState , gpr [ 3 ]) },
{ "r4" , offsetof ( CPUState , gpr [ 4 ]) },
{ "r5" , offsetof ( CPUState , gpr [ 5 ]) },
{ "r6" , offsetof ( CPUState , gpr [ 6 ]) },
{ "r7" , offsetof ( CPUState , gpr [ 7 ]) },
{ "r8" , offsetof ( CPUState , gpr [ 8 ]) },
{ "r9" , offsetof ( CPUState , gpr [ 9 ]) },
{ "r10" , offsetof ( CPUState , gpr [ 10 ]) },
{ "r11" , offsetof ( CPUState , gpr [ 11 ]) },
{ "r12" , offsetof ( CPUState , gpr [ 12 ]) },
{ "r13" , offsetof ( CPUState , gpr [ 13 ]) },
{ "r14" , offsetof ( CPUState , gpr [ 14 ]) },
{ "r15" , offsetof ( CPUState , gpr [ 15 ]) },
{ "r16" , offsetof ( CPUState , gpr [ 16 ]) },
{ "r17" , offsetof ( CPUState , gpr [ 17 ]) },
{ "r18" , offsetof ( CPUState , gpr [ 18 ]) },
{ "r19" , offsetof ( CPUState , gpr [ 19 ]) },
{ "r20" , offsetof ( CPUState , gpr [ 20 ]) },
{ "r21" , offsetof ( CPUState , gpr [ 21 ]) },
{ "r22" , offsetof ( CPUState , gpr [ 22 ]) },
{ "r23" , offsetof ( CPUState , gpr [ 23 ]) },
{ "r24" , offsetof ( CPUState , gpr [ 24 ]) },
{ "r25" , offsetof ( CPUState , gpr [ 25 ]) },
{ "r26" , offsetof ( CPUState , gpr [ 26 ]) },
{ "r27" , offsetof ( CPUState , gpr [ 27 ]) },
{ "r28" , offsetof ( CPUState , gpr [ 28 ]) },
{ "r29" , offsetof ( CPUState , gpr [ 29 ]) },
{ "r30" , offsetof ( CPUState , gpr [ 30 ]) },
{ "r31" , offsetof ( CPUState , gpr [ 31 ]) },
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
/* Floating point registers */
{ "f0" , offsetof ( CPUState , fpr [ 0 ]) },
{ "f1" , offsetof ( CPUState , fpr [ 1 ]) },
{ "f2" , offsetof ( CPUState , fpr [ 2 ]) },
{ "f3" , offsetof ( CPUState , fpr [ 3 ]) },
{ "f4" , offsetof ( CPUState , fpr [ 4 ]) },
{ "f5" , offsetof ( CPUState , fpr [ 5 ]) },
{ "f6" , offsetof ( CPUState , fpr [ 6 ]) },
{ "f7" , offsetof ( CPUState , fpr [ 7 ]) },
{ "f8" , offsetof ( CPUState , fpr [ 8 ]) },
{ "f9" , offsetof ( CPUState , fpr [ 9 ]) },
{ "f10" , offsetof ( CPUState , fpr [ 10 ]) },
{ "f11" , offsetof ( CPUState , fpr [ 11 ]) },
{ "f12" , offsetof ( CPUState , fpr [ 12 ]) },
{ "f13" , offsetof ( CPUState , fpr [ 13 ]) },
{ "f14" , offsetof ( CPUState , fpr [ 14 ]) },
{ "f15" , offsetof ( CPUState , fpr [ 15 ]) },
{ "f16" , offsetof ( CPUState , fpr [ 16 ]) },
{ "f17" , offsetof ( CPUState , fpr [ 17 ]) },
{ "f18" , offsetof ( CPUState , fpr [ 18 ]) },
{ "f19" , offsetof ( CPUState , fpr [ 19 ]) },
{ "f20" , offsetof ( CPUState , fpr [ 20 ]) },
{ "f21" , offsetof ( CPUState , fpr [ 21 ]) },
{ "f22" , offsetof ( CPUState , fpr [ 22 ]) },
{ "f23" , offsetof ( CPUState , fpr [ 23 ]) },
{ "f24" , offsetof ( CPUState , fpr [ 24 ]) },
{ "f25" , offsetof ( CPUState , fpr [ 25 ]) },
{ "f26" , offsetof ( CPUState , fpr [ 26 ]) },
{ "f27" , offsetof ( CPUState , fpr [ 27 ]) },
{ "f28" , offsetof ( CPUState , fpr [ 28 ]) },
{ "f29" , offsetof ( CPUState , fpr [ 29 ]) },
{ "f30" , offsetof ( CPUState , fpr [ 30 ]) },
{ "f31" , offsetof ( CPUState , fpr [ 31 ]) },
{ "fpscr" , offsetof ( CPUState , fpscr ) },
/* Next instruction pointer */
2000
{ "nip|pc" , offsetof ( CPUState , nip ) },
2001
2002
{ "lr" , offsetof ( CPUState , lr ) },
{ "ctr" , offsetof ( CPUState , ctr ) },
2003
{ "decr" , 0 , & monitor_get_decr , },
2004
{ "ccr" , 0 , & monitor_get_ccr , },
2005
/* Machine state register */
2006
2007
{ "msr" , 0 , & monitor_get_msr , },
{ "xer" , 0 , & monitor_get_xer , },
2008
2009
{ "tbu" , 0 , & monitor_get_tbu , },
{ "tbl" , 0 , & monitor_get_tbl , },
2010
2011
2012
2013
2014
# if defined ( TARGET_PPC64 )
/* Address space register */
{ "asr" , offsetof ( CPUState , asr ) },
# endif
/* Segment registers */
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
{ "sdr1" , offsetof ( CPUState , sdr1 ) },
{ "sr0" , offsetof ( CPUState , sr [ 0 ]) },
{ "sr1" , offsetof ( CPUState , sr [ 1 ]) },
{ "sr2" , offsetof ( CPUState , sr [ 2 ]) },
{ "sr3" , offsetof ( CPUState , sr [ 3 ]) },
{ "sr4" , offsetof ( CPUState , sr [ 4 ]) },
{ "sr5" , offsetof ( CPUState , sr [ 5 ]) },
{ "sr6" , offsetof ( CPUState , sr [ 6 ]) },
{ "sr7" , offsetof ( CPUState , sr [ 7 ]) },
{ "sr8" , offsetof ( CPUState , sr [ 8 ]) },
{ "sr9" , offsetof ( CPUState , sr [ 9 ]) },
{ "sr10" , offsetof ( CPUState , sr [ 10 ]) },
{ "sr11" , offsetof ( CPUState , sr [ 11 ]) },
{ "sr12" , offsetof ( CPUState , sr [ 12 ]) },
{ "sr13" , offsetof ( CPUState , sr [ 13 ]) },
{ "sr14" , offsetof ( CPUState , sr [ 14 ]) },
{ "sr15" , offsetof ( CPUState , sr [ 15 ]) },
/* Too lazy to put BATs and SPRs ... */
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
# elif defined ( TARGET_SPARC )
{ "g0" , offsetof ( CPUState , gregs [ 0 ]) },
{ "g1" , offsetof ( CPUState , gregs [ 1 ]) },
{ "g2" , offsetof ( CPUState , gregs [ 2 ]) },
{ "g3" , offsetof ( CPUState , gregs [ 3 ]) },
{ "g4" , offsetof ( CPUState , gregs [ 4 ]) },
{ "g5" , offsetof ( CPUState , gregs [ 5 ]) },
{ "g6" , offsetof ( CPUState , gregs [ 6 ]) },
{ "g7" , offsetof ( CPUState , gregs [ 7 ]) },
{ "o0" , 0 , monitor_get_reg },
{ "o1" , 1 , monitor_get_reg },
{ "o2" , 2 , monitor_get_reg },
{ "o3" , 3 , monitor_get_reg },
{ "o4" , 4 , monitor_get_reg },
{ "o5" , 5 , monitor_get_reg },
{ "o6" , 6 , monitor_get_reg },
{ "o7" , 7 , monitor_get_reg },
{ "l0" , 8 , monitor_get_reg },
{ "l1" , 9 , monitor_get_reg },
{ "l2" , 10 , monitor_get_reg },
{ "l3" , 11 , monitor_get_reg },
{ "l4" , 12 , monitor_get_reg },
{ "l5" , 13 , monitor_get_reg },
{ "l6" , 14 , monitor_get_reg },
{ "l7" , 15 , monitor_get_reg },
{ "i0" , 16 , monitor_get_reg },
{ "i1" , 17 , monitor_get_reg },
{ "i2" , 18 , monitor_get_reg },
{ "i3" , 19 , monitor_get_reg },
{ "i4" , 20 , monitor_get_reg },
{ "i5" , 21 , monitor_get_reg },
{ "i6" , 22 , monitor_get_reg },
{ "i7" , 23 , monitor_get_reg },
{ "pc" , offsetof ( CPUState , pc ) },
{ "npc" , offsetof ( CPUState , npc ) },
{ "y" , offsetof ( CPUState , y ) },
2069
# ifndef TARGET_SPARC64
2070
2071
{ "psr" , 0 , & monitor_get_psr , },
{ "wim" , offsetof ( CPUState , wim ) },
2072
# endif
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
{ "tbr" , offsetof ( CPUState , tbr ) },
{ "fsr" , offsetof ( CPUState , fsr ) },
{ "f0" , offsetof ( CPUState , fpr [ 0 ]) },
{ "f1" , offsetof ( CPUState , fpr [ 1 ]) },
{ "f2" , offsetof ( CPUState , fpr [ 2 ]) },
{ "f3" , offsetof ( CPUState , fpr [ 3 ]) },
{ "f4" , offsetof ( CPUState , fpr [ 4 ]) },
{ "f5" , offsetof ( CPUState , fpr [ 5 ]) },
{ "f6" , offsetof ( CPUState , fpr [ 6 ]) },
{ "f7" , offsetof ( CPUState , fpr [ 7 ]) },
{ "f8" , offsetof ( CPUState , fpr [ 8 ]) },
{ "f9" , offsetof ( CPUState , fpr [ 9 ]) },
{ "f10" , offsetof ( CPUState , fpr [ 10 ]) },
{ "f11" , offsetof ( CPUState , fpr [ 11 ]) },
{ "f12" , offsetof ( CPUState , fpr [ 12 ]) },
{ "f13" , offsetof ( CPUState , fpr [ 13 ]) },
{ "f14" , offsetof ( CPUState , fpr [ 14 ]) },
{ "f15" , offsetof ( CPUState , fpr [ 15 ]) },
{ "f16" , offsetof ( CPUState , fpr [ 16 ]) },
{ "f17" , offsetof ( CPUState , fpr [ 17 ]) },
{ "f18" , offsetof ( CPUState , fpr [ 18 ]) },
{ "f19" , offsetof ( CPUState , fpr [ 19 ]) },
{ "f20" , offsetof ( CPUState , fpr [ 20 ]) },
{ "f21" , offsetof ( CPUState , fpr [ 21 ]) },
{ "f22" , offsetof ( CPUState , fpr [ 22 ]) },
{ "f23" , offsetof ( CPUState , fpr [ 23 ]) },
{ "f24" , offsetof ( CPUState , fpr [ 24 ]) },
{ "f25" , offsetof ( CPUState , fpr [ 25 ]) },
{ "f26" , offsetof ( CPUState , fpr [ 26 ]) },
{ "f27" , offsetof ( CPUState , fpr [ 27 ]) },
{ "f28" , offsetof ( CPUState , fpr [ 28 ]) },
{ "f29" , offsetof ( CPUState , fpr [ 29 ]) },
{ "f30" , offsetof ( CPUState , fpr [ 30 ]) },
{ "f31" , offsetof ( CPUState , fpr [ 31 ]) },
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
# ifdef TARGET_SPARC64
{ "f32" , offsetof ( CPUState , fpr [ 32 ]) },
{ "f34" , offsetof ( CPUState , fpr [ 34 ]) },
{ "f36" , offsetof ( CPUState , fpr [ 36 ]) },
{ "f38" , offsetof ( CPUState , fpr [ 38 ]) },
{ "f40" , offsetof ( CPUState , fpr [ 40 ]) },
{ "f42" , offsetof ( CPUState , fpr [ 42 ]) },
{ "f44" , offsetof ( CPUState , fpr [ 44 ]) },
{ "f46" , offsetof ( CPUState , fpr [ 46 ]) },
{ "f48" , offsetof ( CPUState , fpr [ 48 ]) },
{ "f50" , offsetof ( CPUState , fpr [ 50 ]) },
{ "f52" , offsetof ( CPUState , fpr [ 52 ]) },
{ "f54" , offsetof ( CPUState , fpr [ 54 ]) },
{ "f56" , offsetof ( CPUState , fpr [ 56 ]) },
{ "f58" , offsetof ( CPUState , fpr [ 58 ]) },
{ "f60" , offsetof ( CPUState , fpr [ 60 ]) },
{ "f62" , offsetof ( CPUState , fpr [ 62 ]) },
{ "asi" , offsetof ( CPUState , asi ) },
{ "pstate" , offsetof ( CPUState , pstate ) },
{ "cansave" , offsetof ( CPUState , cansave ) },
{ "canrestore" , offsetof ( CPUState , canrestore ) },
{ "otherwin" , offsetof ( CPUState , otherwin ) },
{ "wstate" , offsetof ( CPUState , wstate ) },
{ "cleanwin" , offsetof ( CPUState , cleanwin ) },
{ "fprs" , offsetof ( CPUState , fprs ) },
# endif
2133
2134
2135
2136
# endif
{ NULL },
};
2137
static void expr_error ( Monitor * mon , const char * msg )
2138
{
2139
monitor_printf ( mon , "%s \n " , msg );
2140
2141
2142
longjmp ( expr_env , 1 );
}
2143
/* return 0 if OK, -1 if not found, -2 if no CPU defined */
2144
static int get_monitor_def ( target_long * pval , const char * name )
2145
{
2146
const MonitorDef * md ;
2147
2148
void * ptr ;
2149
2150
2151
for ( md = monitor_defs ; md -> name != NULL ; md ++ ) {
if ( compare_cmd ( name , md -> name )) {
if ( md -> get_value ) {
2152
* pval = md -> get_value ( md , md -> offset );
2153
} else {
2154
2155
2156
2157
CPUState * env = mon_get_cpu ();
if ( ! env )
return - 2 ;
ptr = ( uint8_t * ) env + md -> offset ;
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
switch ( md -> type ) {
case MD_I32 :
* pval = * ( int32_t * ) ptr ;
break ;
case MD_TLONG :
* pval = * ( target_long * ) ptr ;
break ;
default :
* pval = 0 ;
break ;
}
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
}
return 0 ;
}
}
return - 1 ;
}
static void next ( void )
{
if ( pch != '\0' ) {
pch ++ ;
2180
while ( qemu_isspace ( * pch ))
2181
2182
2183
2184
pch ++ ;
}
}
2185
static int64_t expr_sum ( Monitor * mon );
2186
2187
static int64_t expr_unary ( Monitor * mon )
2188
{
2189
int64_t n ;
2190
char * p ;
2191
int ret ;
2192
2193
2194
2195
switch ( * pch ) {
case '+' :
next ();
2196
n = expr_unary ( mon );
2197
2198
2199
break ;
case '-' :
next ();
2200
n = - expr_unary ( mon );
2201
2202
2203
break ;
case '~' :
next ();
2204
n = ~ expr_unary ( mon );
2205
2206
2207
break ;
case '(' :
next ();
2208
n = expr_sum ( mon );
2209
if ( * pch != ')' ) {
2210
expr_error ( mon , "')' expected" );
2211
2212
2213
}
next ();
break ;
2214
2215
2216
case '\'' :
pch ++ ;
if ( * pch == '\0' )
2217
expr_error ( mon , "character constant expected" );
2218
2219
2220
n = * pch ;
pch ++ ;
if ( * pch != '\'' )
2221
expr_error ( mon , "missing terminating \' character" );
2222
2223
next ();
break ;
2224
2225
2226
case '$' :
{
char buf [ 128 ], * q ;
ths
authored
17 years ago
2227
target_long reg = 0 ;
ths
authored
18 years ago
2228
2229
2230
2231
2232
2233
pch ++ ;
q = buf ;
while (( * pch >= 'a' && * pch <= 'z' ) ||
( * pch >= 'A' && * pch <= 'Z' ) ||
( * pch >= '0' && * pch <= '9' ) ||
2234
* pch == '_' || * pch == '.' ) {
2235
2236
2237
2238
if (( q - buf ) < sizeof ( buf ) - 1 )
* q ++ = * pch ;
pch ++ ;
}
2239
while ( qemu_isspace ( * pch ))
2240
2241
pch ++ ;
* q = 0 ;
2242
ret = get_monitor_def ( & reg , buf );
2243
if ( ret == - 1 )
2244
expr_error ( mon , "unknown register" );
ths
authored
18 years ago
2245
else if ( ret == - 2 )
2246
expr_error ( mon , "no cpu defined" );
2247
n = reg ;
2248
2249
2250
}
break ;
case '\0' :
2251
expr_error ( mon , "unexpected end of expression" );
2252
2253
2254
n = 0 ;
break ;
default :
2255
# if TARGET_PHYS_ADDR_BITS > 32
2256
2257
n = strtoull ( pch , & p , 0 );
# else
2258
n = strtoul ( pch , & p , 0 );
2259
# endif
2260
if ( pch == p ) {
2261
expr_error ( mon , "invalid char in expression" );
2262
2263
}
pch = p ;
2264
while ( qemu_isspace ( * pch ))
2265
2266
2267
2268
2269
2270
2271
pch ++ ;
break ;
}
return n ;
}
2272
static int64_t expr_prod ( Monitor * mon )
2273
{
2274
int64_t val , val2 ;
2275
int op ;
ths
authored
18 years ago
2276
2277
val = expr_unary ( mon );
2278
2279
2280
2281
2282
for (;;) {
op = * pch ;
if ( op != '*' && op != '/' && op != '%' )
break ;
next ();
2283
val2 = expr_unary ( mon );
2284
2285
2286
2287
2288
2289
2290
switch ( op ) {
default :
case '*' :
val *= val2 ;
break ;
case '/' :
case '%' :
ths
authored
18 years ago
2291
if ( val2 == 0 )
2292
expr_error ( mon , "division by zero" );
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
if ( op == '/' )
val /= val2 ;
else
val %= val2 ;
break ;
}
}
return val ;
}
2303
static int64_t expr_logic ( Monitor * mon )
2304
{
2305
int64_t val , val2 ;
2306
int op ;
2307
2308
val = expr_prod ( mon );
2309
2310
2311
2312
2313
for (;;) {
op = * pch ;
if ( op != '&' && op != '|' && op != '^' )
break ;
next ();
2314
val2 = expr_prod ( mon );
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
switch ( op ) {
default :
case '&' :
val &= val2 ;
break ;
case '|' :
val |= val2 ;
break ;
case '^' :
val ^= val2 ;
break ;
}
}
return val ;
}
2331
static int64_t expr_sum ( Monitor * mon )
2332
{
2333
int64_t val , val2 ;
2334
int op ;
2335
2336
val = expr_logic ( mon );
2337
2338
2339
2340
2341
for (;;) {
op = * pch ;
if ( op != '+' && op != '-' )
break ;
next ();
2342
val2 = expr_logic ( mon );
2343
2344
2345
2346
2347
2348
2349
2350
if ( op == '+' )
val += val2 ;
else
val -= val2 ;
}
return val ;
}
2351
static int get_expr ( Monitor * mon , int64_t * pval , const char ** pp )
2352
2353
2354
2355
2356
2357
{
pch = * pp ;
if ( setjmp ( expr_env )) {
* pp = pch ;
return - 1 ;
}
2358
while ( qemu_isspace ( * pch ))
2359
pch ++ ;
2360
* pval = expr_sum ( mon );
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
* pp = pch ;
return 0 ;
}
static int get_str ( char * buf , int buf_size , const char ** pp )
{
const char * p ;
char * q ;
int c ;
2371
q = buf ;
2372
p = * pp ;
2373
while ( qemu_isspace ( * p ))
2374
2375
2376
p ++ ;
if ( * p == '\0' ) {
fail :
2377
* q = '\0' ;
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
* pp = p ;
return - 1 ;
}
if ( * p == '\"' ) {
p ++ ;
while ( * p != '\0' && * p != '\"' ) {
if ( * p == '\\' ) {
p ++ ;
c = * p ++ ;
switch ( c ) {
case 'n' :
c = '\n' ;
break ;
case 'r' :
c = '\r' ;
break ;
case '\\' :
case '\'' :
case '\"' :
break ;
default :
qemu_printf ( "unsupported escape code: ' \\ %c' \n " , c );
goto fail ;
}
if (( q - buf ) < buf_size - 1 ) {
* q ++ = c ;
}
} else {
if (( q - buf ) < buf_size - 1 ) {
* q ++ = * p ;
}
p ++ ;
}
}
if ( * p != '\"' ) {
2413
qemu_printf ( "unterminated string \n " );
2414
2415
2416
2417
goto fail ;
}
p ++ ;
} else {
2418
while ( * p != '\0' && ! qemu_isspace ( * p )) {
2419
2420
2421
2422
2423
2424
if (( q - buf ) < buf_size - 1 ) {
* q ++ = * p ;
}
p ++ ;
}
}
2425
* q = '\0' ;
2426
2427
2428
2429
* pp = p ;
return 0 ;
}
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
/*
* Store the command - name in cmdname , and return a pointer to
* the remaining of the command string .
*/
static const char * get_command_name ( const char * cmdline ,
char * cmdname , size_t nlen )
{
size_t len ;
const char * p , * pstart ;
p = cmdline ;
while ( qemu_isspace ( * p ))
p ++ ;
if ( * p == '\0' )
return NULL ;
pstart = p ;
while ( * p != '\0' && * p != '/' && ! qemu_isspace ( * p ))
p ++ ;
len = p - pstart ;
if ( len > nlen - 1 )
len = nlen - 1 ;
memcpy ( cmdname , pstart , len );
cmdname [ len ] = '\0' ;
return p ;
}
2456
2457
2458
2459
2460
static int default_fmt_format = 'x' ;
static int default_fmt_size = 4 ;
# define MAX_ARGS 16
2461
static void monitor_handle_command ( Monitor * mon , const char * cmdline )
2462
{
2463
2464
const char * p , * typestr ;
int c , nb_args , i , has_arg ;
2465
const mon_cmd_t * cmd ;
2466
2467
2468
2469
char cmdname [ 256 ];
char buf [ 1024 ];
void * str_allocated [ MAX_ARGS ];
void * args [ MAX_ARGS ];
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
void ( * handler_0 )( Monitor * mon );
void ( * handler_1 )( Monitor * mon , void * arg0 );
void ( * handler_2 )( Monitor * mon , void * arg0 , void * arg1 );
void ( * handler_3 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 );
void ( * handler_4 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 );
void ( * handler_5 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 , void * arg4 );
void ( * handler_6 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 , void * arg4 , void * arg5 );
void ( * handler_7 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 , void * arg4 , void * arg5 , void * arg6 );
2482
2483
2484
2485
2486
2487
2488
2489
2490
void ( * handler_8 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 , void * arg4 , void * arg5 , void * arg6 ,
void * arg7 );
void ( * handler_9 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 , void * arg4 , void * arg5 , void * arg6 ,
void * arg7 , void * arg8 );
void ( * handler_10 )( Monitor * mon , void * arg0 , void * arg1 , void * arg2 ,
void * arg3 , void * arg4 , void * arg5 , void * arg6 ,
void * arg7 , void * arg8 , void * arg9 );
2491
2492
# ifdef DEBUG
2493
monitor_printf ( mon , "command='%s' \n " , cmdline );
2494
# endif
ths
authored
18 years ago
2495
2496
/* extract the command name */
2497
2498
p = get_command_name ( cmdline , cmdname , sizeof ( cmdname ));
if ( ! p )
2499
return ;
ths
authored
18 years ago
2500
2501
/* find the command */
2502
for ( cmd = mon_cmds ; cmd -> name != NULL ; cmd ++ ) {
ths
authored
18 years ago
2503
if ( compare_cmd ( cmdname , cmd -> name ))
2504
2505
2506
2507
2508
2509
break ;
}
if ( cmd -> name == NULL ) {
monitor_printf ( mon , "unknown command: '%s' \n " , cmdname );
return ;
2510
2511
2512
2513
}
for ( i = 0 ; i < MAX_ARGS ; i ++ )
str_allocated [ i ] = NULL ;
ths
authored
18 years ago
2514
2515
2516
2517
/* parse the parameters */
typestr = cmd -> args_type ;
nb_args = 0 ;
2518
for (;;) {
2519
2520
c = * typestr ;
if ( c == '\0' )
2521
break ;
2522
2523
2524
typestr ++ ;
switch ( c ) {
case 'F' :
2525
case 'B' :
2526
2527
2528
2529
case 's' :
{
int ret ;
char * str ;
ths
authored
18 years ago
2530
2531
while ( qemu_isspace ( * p ))
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
p ++ ;
if ( * typestr == '?' ) {
typestr ++ ;
if ( * p == '\0' ) {
/* no optional string: NULL argument */
str = NULL ;
goto add_str ;
}
}
ret = get_str ( buf , sizeof ( buf ), & p );
if ( ret < 0 ) {
2543
2544
switch ( c ) {
case 'F' :
2545
2546
monitor_printf ( mon , "%s: filename expected \n " ,
cmdname );
2547
2548
break ;
case 'B' :
2549
2550
monitor_printf ( mon , "%s: block device name expected \n " ,
cmdname );
2551
2552
break ;
default :
2553
monitor_printf ( mon , "%s: string expected \n " , cmdname );
2554
2555
break ;
}
2556
2557
2558
goto fail ;
}
str = qemu_malloc ( strlen ( buf ) + 1 );
2559
pstrcpy ( str , sizeof ( buf ), buf );
2560
2561
2562
2563
str_allocated [ nb_args ] = str ;
add_str :
if ( nb_args >= MAX_ARGS ) {
error_args :
2564
monitor_printf ( mon , "%s: too many arguments \n " , cmdname );
2565
2566
2567
2568
goto fail ;
}
args [ nb_args ++ ] = str ;
}
2569
break ;
2570
2571
2572
case '/' :
{
int count , format , size ;
ths
authored
18 years ago
2573
2574
while ( qemu_isspace ( * p ))
2575
2576
2577
2578
2579
p ++ ;
if ( * p == '/' ) {
/* format found */
p ++ ;
count = 1 ;
2580
if ( qemu_isdigit ( * p )) {
2581
count = 0 ;
2582
while ( qemu_isdigit ( * p )) {
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
count = count * 10 + ( * p - '0' );
p ++ ;
}
}
size = - 1 ;
format = - 1 ;
for (;;) {
switch ( * p ) {
case 'o' :
case 'd' :
case 'u' :
case 'x' :
case 'i' :
case 'c' :
format = * p ++ ;
break ;
case 'b' :
size = 1 ;
p ++ ;
break ;
case 'h' :
size = 2 ;
p ++ ;
break ;
case 'w' :
size = 4 ;
p ++ ;
break ;
case 'g' :
case 'L' :
size = 8 ;
p ++ ;
break ;
default :
goto next ;
}
}
next :
2621
if ( * p != '\0' && ! qemu_isspace ( * p )) {
2622
2623
monitor_printf ( mon , "invalid char in format: '%c' \n " ,
* p );
2624
2625
2626
2627
goto fail ;
}
if ( format < 0 )
format = default_fmt_format ;
2628
2629
2630
2631
if ( format != 'i' ) {
/* for 'i', not specifying a size gives -1 as size */
if ( size < 0 )
size = default_fmt_size ;
2632
default_fmt_size = size ;
2633
}
2634
2635
2636
2637
default_fmt_format = format ;
} else {
count = 1 ;
format = default_fmt_format ;
2638
2639
2640
2641
2642
if ( format != 'i' ) {
size = default_fmt_size ;
} else {
size = - 1 ;
}
2643
2644
2645
}
if ( nb_args + 3 > MAX_ARGS )
goto error_args ;
2646
2647
2648
args [ nb_args ++ ] = ( void * )( long ) count ;
args [ nb_args ++ ] = ( void * )( long ) format ;
args [ nb_args ++ ] = ( void * )( long ) size ;
2649
}
2650
break ;
2651
case 'i' :
2652
case 'l' :
2653
{
2654
int64_t val ;
2655
2656
while ( qemu_isspace ( * p ))
2657
p ++ ;
2658
2659
2660
2661
2662
2663
2664
2665
2666
if ( * typestr == '?' || * typestr == '.' ) {
if ( * typestr == '?' ) {
if ( * p == '\0' )
has_arg = 0 ;
else
has_arg = 1 ;
} else {
if ( * p == '.' ) {
p ++ ;
2667
while ( qemu_isspace ( * p ))
2668
2669
2670
2671
2672
2673
p ++ ;
has_arg = 1 ;
} else {
has_arg = 0 ;
}
}
2674
typestr ++ ;
2675
2676
if ( nb_args >= MAX_ARGS )
goto error_args ;
2677
args [ nb_args ++ ] = ( void * )( long ) has_arg ;
2678
2679
2680
2681
2682
2683
2684
if ( ! has_arg ) {
if ( nb_args >= MAX_ARGS )
goto error_args ;
val = - 1 ;
goto add_num ;
}
}
2685
if ( get_expr ( mon , & val , & p ))
2686
2687
goto fail ;
add_num :
2688
2689
2690
if ( c == 'i' ) {
if ( nb_args >= MAX_ARGS )
goto error_args ;
2691
args [ nb_args ++ ] = ( void * )( long ) val ;
2692
2693
2694
} else {
if (( nb_args + 1 ) >= MAX_ARGS )
goto error_args ;
2695
# if TARGET_PHYS_ADDR_BITS > 32
2696
args [ nb_args ++ ] = ( void * )( long )(( val >> 32 ) & 0xffffffff );
2697
2698
2699
# else
args [ nb_args ++ ] = ( void * ) 0 ;
# endif
2700
args [ nb_args ++ ] = ( void * )( long )( val & 0xffffffff );
2701
}
2702
2703
2704
2705
2706
2707
}
break ;
case '-' :
{
int has_option ;
/* option */
ths
authored
18 years ago
2708
2709
2710
2711
c = * typestr ++ ;
if ( c == '\0' )
goto bad_type ;
2712
while ( qemu_isspace ( * p ))
2713
2714
2715
2716
2717
p ++ ;
has_option = 0 ;
if ( * p == '-' ) {
p ++ ;
if ( * p != c ) {
2718
2719
monitor_printf ( mon , "%s: unsupported option -%c \n " ,
cmdname , * p );
2720
2721
2722
2723
2724
2725
2726
goto fail ;
}
p ++ ;
has_option = 1 ;
}
if ( nb_args >= MAX_ARGS )
goto error_args ;
2727
args [ nb_args ++ ] = ( void * )( long ) has_option ;
2728
2729
2730
2731
}
break ;
default :
bad_type :
2732
monitor_printf ( mon , "%s: unknown type '%c' \n " , cmdname , c );
2733
2734
goto fail ;
}
2735
}
2736
/* check that all arguments were parsed */
2737
while ( qemu_isspace ( * p ))
2738
2739
p ++ ;
if ( * p != '\0' ) {
2740
2741
monitor_printf ( mon , "%s: extraneous characters at the end of line \n " ,
cmdname );
2742
goto fail ;
2743
}
2744
2745
2746
switch ( nb_args ) {
case 0 :
2747
handler_0 = cmd -> handler ;
2748
handler_0 ( mon );
2749
2750
break ;
case 1 :
2751
handler_1 = cmd -> handler ;
2752
handler_1 ( mon , args [ 0 ]);
2753
2754
break ;
case 2 :
2755
handler_2 = cmd -> handler ;
2756
handler_2 ( mon , args [ 0 ], args [ 1 ]);
2757
2758
break ;
case 3 :
2759
handler_3 = cmd -> handler ;
2760
handler_3 ( mon , args [ 0 ], args [ 1 ], args [ 2 ]);
2761
2762
break ;
case 4 :
2763
handler_4 = cmd -> handler ;
2764
handler_4 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ]);
2765
2766
break ;
case 5 :
2767
handler_5 = cmd -> handler ;
2768
handler_5 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ], args [ 4 ]);
2769
break ;
2770
case 6 :
2771
handler_6 = cmd -> handler ;
2772
handler_6 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ], args [ 4 ], args [ 5 ]);
2773
break ;
2774
case 7 :
2775
handler_7 = cmd -> handler ;
2776
2777
handler_7 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ], args [ 4 ], args [ 5 ],
args [ 6 ]);
2778
break ;
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
case 8 :
handler_8 = cmd -> handler ;
handler_8 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ], args [ 4 ], args [ 5 ],
args [ 6 ], args [ 7 ]);
break ;
case 9 :
handler_9 = cmd -> handler ;
handler_9 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ], args [ 4 ], args [ 5 ],
args [ 6 ], args [ 7 ], args [ 8 ]);
break ;
case 10 :
handler_10 = cmd -> handler ;
handler_10 ( mon , args [ 0 ], args [ 1 ], args [ 2 ], args [ 3 ], args [ 4 ], args [ 5 ],
args [ 6 ], args [ 7 ], args [ 8 ], args [ 9 ]);
break ;
2794
default :
2795
monitor_printf ( mon , "unsupported number of arguments: %d \n " , nb_args );
2796
goto fail ;
2797
}
2798
2799
2800
fail :
for ( i = 0 ; i < MAX_ARGS ; i ++ )
qemu_free ( str_allocated [ i ]);
2801
2802
}
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
static void cmd_completion ( const char * name , const char * list )
{
const char * p , * pstart ;
char cmd [ 128 ];
int len ;
p = list ;
for (;;) {
pstart = p ;
p = strchr ( p , '|' );
if ( ! p )
p = pstart + strlen ( pstart );
len = p - pstart ;
if ( len > sizeof ( cmd ) - 2 )
len = sizeof ( cmd ) - 2 ;
memcpy ( cmd , pstart , len );
cmd [ len ] = '\0' ;
if ( name [ 0 ] == '\0' || ! strncmp ( name , cmd , strlen ( name ))) {
2821
readline_add_completion ( cur_mon -> rs , cmd );
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
}
if ( * p == '\0' )
break ;
p ++ ;
}
}
static void file_completion ( const char * input )
{
DIR * ffs ;
struct dirent * d ;
char path [ 1024 ];
char file [ 1024 ], file_prefix [ 1024 ];
int input_path_len ;
const char * p ;
ths
authored
18 years ago
2838
p = strrchr ( input , '/' );
2839
2840
2841
if ( ! p ) {
input_path_len = 0 ;
pstrcpy ( file_prefix , sizeof ( file_prefix ), input );
2842
pstrcpy ( path , sizeof ( path ), "." );
2843
2844
2845
2846
2847
2848
2849
2850
2851
} else {
input_path_len = p - input + 1 ;
memcpy ( path , input , input_path_len );
if ( input_path_len > sizeof ( path ) - 1 )
input_path_len = sizeof ( path ) - 1 ;
path [ input_path_len ] = '\0' ;
pstrcpy ( file_prefix , sizeof ( file_prefix ), p + 1 );
}
# ifdef DEBUG_COMPLETION
2852
2853
monitor_printf ( cur_mon , "input='%s' path='%s' prefix='%s' \n " ,
input , path , file_prefix );
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
# endif
ffs = opendir ( path );
if ( ! ffs )
return ;
for (;;) {
struct stat sb ;
d = readdir ( ffs );
if ( ! d )
break ;
if ( strstart ( d -> d_name , file_prefix , NULL )) {
memcpy ( file , input , input_path_len );
2865
2866
2867
if ( input_path_len < sizeof ( file ))
pstrcpy ( file + input_path_len , sizeof ( file ) - input_path_len ,
d -> d_name );
2868
2869
2870
2871
2872
/* stat the file to find out if it ' s a directory .
* In that case add a slash to speed up typing long paths
*/
stat ( file , & sb ) ;
if ( S_ISDIR ( sb . st_mode ))
2873
pstrcat ( file , sizeof ( file ), "/" ) ;
2874
readline_add_completion ( cur_mon -> rs , file ) ;
2875
2876
2877
2878
2879
}
}
closedir ( ffs ) ;
}
2880
static void block_completion_it ( void * opaque , BlockDriverState * bs )
2881
{
2882
const char * name = bdrv_get_device_name ( bs ) ;
2883
2884
2885
2886
const char * input = opaque ;
if ( input [ 0 ] == '\0' ||
! strncmp ( name , ( char * ) input , strlen ( input ))) {
2887
readline_add_completion ( cur_mon -> rs , name ) ;
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
}
}
/* NOTE: this parser is an approximate form of the real command parser */
static void parse_cmdline ( const char * cmdline ,
int * pnb_args , char ** args )
{
const char * p ;
int nb_args , ret ;
char buf [ 1024 ] ;
p = cmdline ;
nb_args = 0 ;
for ( ;; ) {
2902
while ( qemu_isspace ( * p ))
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
p ++ ;
if ( * p == '\0' )
break ;
if ( nb_args >= MAX_ARGS )
break ;
ret = get_str ( buf , sizeof ( buf ), & p ) ;
args [ nb_args ] = qemu_strdup ( buf ) ;
nb_args ++ ;
if ( ret < 0 )
break ;
}
* pnb_args = nb_args ;
}
2917
static void monitor_find_completion ( const char * cmdline )
2918
2919
2920
2921
2922
{
const char * cmdname ;
char * args [ MAX_ARGS ] ;
int nb_args , i , len ;
const char * ptype , * str ;
2923
const mon_cmd_t * cmd ;
2924
const KeyDef * key ;
2925
2926
2927
2928
parse_cmdline ( cmdline , & nb_args , args ) ;
# ifdef DEBUG_COMPLETION
for ( i = 0 ; i < nb_args ; i ++ ) {
2929
monitor_printf ( cur_mon , "arg%d = '%s' \n " , i , ( char * ) args [ i ]) ;
2930
2931
2932
2933
2934
2935
}
# endif
/* if the line ends with a space , it means we want to complete the
next arg */
len = strlen ( cmdline ) ;
2936
if ( len > 0 && qemu_isspace ( cmdline [ len - 1 ])) {
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
if ( nb_args >= MAX_ARGS )
return ;
args [ nb_args ++ ] = qemu_strdup ( "" ) ;
}
if ( nb_args <= 1 ) {
/* command completion */
if ( nb_args == 0 )
cmdname = "" ;
else
cmdname = args [ 0 ] ;
2947
readline_set_completion_index ( cur_mon -> rs , strlen ( cmdname )) ;
2948
for ( cmd = mon_cmds ; cmd -> name != NULL ; cmd ++ ) {
2949
2950
2951
2952
cmd_completion ( cmdname , cmd -> name ) ;
}
} else {
/* find the command */
2953
for ( cmd = mon_cmds ; cmd -> name != NULL ; cmd ++ ) {
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
if ( compare_cmd ( args [ 0 ], cmd -> name ))
goto found ;
}
return ;
found :
ptype = cmd -> args_type ;
for ( i = 0 ; i < nb_args - 2 ; i ++ ) {
if ( * ptype != '\0' ) {
ptype ++ ;
while ( * ptype == '?' )
ptype ++ ;
}
}
str = args [ nb_args - 1 ];
switch ( * ptype ) {
case 'F' :
/* file completion */
2971
readline_set_completion_index ( cur_mon -> rs , strlen ( str ));
2972
2973
2974
2975
file_completion ( str );
break ;
case 'B' :
/* block device name completion */
2976
readline_set_completion_index ( cur_mon -> rs , strlen ( str ));
2977
2978
bdrv_iterate ( block_completion_it , ( void * ) str );
break ;
2979
2980
2981
case 's' :
/* XXX: more generic ? */
if ( ! strcmp ( cmd -> name , "info" )) {
2982
readline_set_completion_index ( cur_mon -> rs , strlen ( str ));
2983
2984
2985
for ( cmd = info_cmds ; cmd -> name != NULL ; cmd ++ ) {
cmd_completion ( str , cmd -> name );
}
2986
} else if ( ! strcmp ( cmd -> name , "sendkey" )) {
2987
2988
2989
char * sep = strrchr ( str , '-' );
if ( sep )
str = sep + 1 ;
2990
readline_set_completion_index ( cur_mon -> rs , strlen ( str ));
2991
2992
2993
for ( key = key_defs ; key -> name != NULL ; key ++ ) {
cmd_completion ( str , key -> name );
}
2994
2995
2996
2997
2998
} else if ( ! strcmp ( cmd -> name , "help|?" )) {
readline_set_completion_index ( cur_mon -> rs , strlen ( str ));
for ( cmd = mon_cmds ; cmd -> name != NULL ; cmd ++ ) {
cmd_completion ( str , cmd -> name );
}
2999
3000
}
break ;
3001
3002
3003
3004
3005
3006
3007
3008
default :
break ;
}
}
for ( i = 0 ; i < nb_args ; i ++ )
qemu_free ( args [ i ]);
}
3009
static int monitor_can_read ( void * opaque )
3010
{
3011
3012
3013
Monitor * mon = opaque ;
return ( mon -> suspend_cnt == 0 ) ? 128 : 0 ;
3014
3015
}
3016
static void monitor_read ( void * opaque , const uint8_t * buf , int size )
3017
{
3018
Monitor * old_mon = cur_mon ;
3019
int i ;
3020
3021
3022
cur_mon = opaque ;
3023
3024
3025
3026
3027
3028
3029
3030
3031
if ( cur_mon -> rs ) {
for ( i = 0 ; i < size ; i ++ )
readline_handle_byte ( cur_mon -> rs , buf [ i ]);
} else {
if ( size == 0 || buf [ size - 1 ] != 0 )
monitor_printf ( cur_mon , "corrupted command \n " );
else
monitor_handle_command ( cur_mon , ( char * ) buf );
}
3032
3033
3034
cur_mon = old_mon ;
}
3035
3036
static void monitor_command_cb ( Monitor * mon , const char * cmdline , void * opaque )
3037
{
3038
monitor_suspend ( mon );
3039
monitor_handle_command ( mon , cmdline );
3040
monitor_resume ( mon );
3041
3042
}
3043
int monitor_suspend ( Monitor * mon )
3044
{
3045
3046
if ( ! mon -> rs )
return - ENOTTY ;
3047
mon -> suspend_cnt ++ ;
3048
return 0 ;
3049
3050
}
3051
void monitor_resume ( Monitor * mon )
3052
{
3053
3054
if ( ! mon -> rs )
return ;
3055
3056
if ( -- mon -> suspend_cnt == 0 )
readline_show_prompt ( mon -> rs );
3057
3058
}
3059
static void monitor_event ( void * opaque , int event )
ths
authored
18 years ago
3060
{
3061
3062
Monitor * mon = opaque ;
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
switch ( event ) {
case CHR_EVENT_MUX_IN :
readline_restart ( mon -> rs );
monitor_resume ( mon );
monitor_flush ( mon );
break ;
case CHR_EVENT_MUX_OUT :
if ( mon -> suspend_cnt == 0 )
monitor_printf ( mon , " \n " );
monitor_flush ( mon );
monitor_suspend ( mon );
break ;
ths
authored
18 years ago
3076
3077
3078
3079
3080
3081
3082
3083
case CHR_EVENT_RESET :
monitor_printf ( mon , "QEMU %s monitor - type 'help' for more "
"information \n " , QEMU_VERSION );
if ( mon -> chr -> focus == 0 )
readline_show_prompt ( mon -> rs );
break ;
}
ths
authored
18 years ago
3084
3085
}
3086
3087
3088
3089
3090
3091
3092
3093
3094
/*
* Local variables :
* c - indent - level : 4
* c - basic - offset : 4
* tab - width : 8
* End :
*/
3095
void monitor_init ( CharDriverState * chr , int flags )
3096
{
3097
static int is_first_init = 1 ;
3098
Monitor * mon ;
ths
authored
18 years ago
3099
3100
if ( is_first_init ) {
3101
key_timer = qemu_new_timer ( vm_clock , release_keys , NULL );
ths
authored
18 years ago
3102
3103
is_first_init = 0 ;
}
3104
3105
mon = qemu_mallocz ( sizeof ( * mon ));
ths
authored
18 years ago
3106
3107
mon -> chr = chr ;
3108
mon -> flags = flags ;
3109
3110
if ( mon -> chr -> focus != 0 )
mon -> suspend_cnt = 1 ; /* mux'ed monitors start suspended */
3111
3112
3113
3114
if ( flags & MONITOR_USE_READLINE ) {
mon -> rs = readline_init ( mon , monitor_find_completion );
monitor_read_command ( mon , 0 );
}
3115
3116
3117
qemu_chr_add_handlers ( chr , monitor_can_read , monitor_read , monitor_event ,
mon );
3118
3119
LIST_INSERT_HEAD ( & mon_list , mon , entry );
3120
if ( ! cur_mon || ( flags & MONITOR_IS_DEFAULT ))
3121
cur_mon = mon ;
3122
3123
}
3124
static void bdrv_password_cb ( Monitor * mon , const char * password , void * opaque )
3125
{
3126
3127
BlockDriverState * bs = opaque ;
int ret = 0 ;
3128
3129
if ( bdrv_set_key ( bs , password ) != 0 ) {
3130
monitor_printf ( mon , "invalid password \n " );
3131
ret = - EPERM ;
3132
}
3133
3134
if ( mon -> password_completion_cb )
mon -> password_completion_cb ( mon -> password_opaque , ret );
3135
3136
monitor_read_command ( mon , 1 );
3137
}
3138
3139
void monitor_read_bdrv_key_start ( Monitor * mon , BlockDriverState * bs ,
3140
3141
BlockDriverCompletionFunc * completion_cb ,
void * opaque )
3142
{
3143
3144
int err ;
3145
3146
3147
3148
3149
if ( ! bdrv_key_required ( bs )) {
if ( completion_cb )
completion_cb ( opaque , 0 );
return ;
}
3150
3151
3152
monitor_printf ( mon , "%s (%s) is encrypted. \n " , bdrv_get_device_name ( bs ),
bdrv_get_encrypted_filename ( bs ));
3153
3154
3155
mon -> password_completion_cb = completion_cb ;
mon -> password_opaque = opaque ;
3156
3157
3158
3159
3160
err = monitor_read_password ( mon , bdrv_password_cb , bs );
if ( err && completion_cb )
completion_cb ( opaque , err );
3161
}