File:  [Qemu by Fabrice Bellard] / qemu / hmp.c
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:17:22 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1001, HEAD
qemu 1.0.1

    1: /*
    2:  * Human Monitor Interface
    3:  *
    4:  * Copyright IBM, Corp. 2011
    5:  *
    6:  * Authors:
    7:  *  Anthony Liguori   <aliguori@us.ibm.com>
    8:  *
    9:  * This work is licensed under the terms of the GNU GPL, version 2.  See
   10:  * the COPYING file in the top-level directory.
   11:  *
   12:  */
   13: 
   14: #include "hmp.h"
   15: #include "qmp-commands.h"
   16: 
   17: void hmp_info_name(Monitor *mon)
   18: {
   19:     NameInfo *info;
   20: 
   21:     info = qmp_query_name(NULL);
   22:     if (info->has_name) {
   23:         monitor_printf(mon, "%s\n", info->name);
   24:     }
   25:     qapi_free_NameInfo(info);
   26: }
   27: 
   28: void hmp_info_version(Monitor *mon)
   29: {
   30:     VersionInfo *info;
   31: 
   32:     info = qmp_query_version(NULL);
   33: 
   34:     monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
   35:                    info->qemu.major, info->qemu.minor, info->qemu.micro,
   36:                    info->package);
   37: 
   38:     qapi_free_VersionInfo(info);
   39: }
   40: 
   41: void hmp_info_kvm(Monitor *mon)
   42: {
   43:     KvmInfo *info;
   44: 
   45:     info = qmp_query_kvm(NULL);
   46:     monitor_printf(mon, "kvm support: ");
   47:     if (info->present) {
   48:         monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
   49:     } else {
   50:         monitor_printf(mon, "not compiled\n");
   51:     }
   52: 
   53:     qapi_free_KvmInfo(info);
   54: }
   55: 
   56: void hmp_info_status(Monitor *mon)
   57: {
   58:     StatusInfo *info;
   59: 
   60:     info = qmp_query_status(NULL);
   61: 
   62:     monitor_printf(mon, "VM status: %s%s",
   63:                    info->running ? "running" : "paused",
   64:                    info->singlestep ? " (single step mode)" : "");
   65: 
   66:     if (!info->running && info->status != RUN_STATE_PAUSED) {
   67:         monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
   68:     }
   69: 
   70:     monitor_printf(mon, "\n");
   71: 
   72:     qapi_free_StatusInfo(info);
   73: }
   74: 
   75: void hmp_info_uuid(Monitor *mon)
   76: {
   77:     UuidInfo *info;
   78: 
   79:     info = qmp_query_uuid(NULL);
   80:     monitor_printf(mon, "%s\n", info->UUID);
   81:     qapi_free_UuidInfo(info);
   82: }
   83: 
   84: void hmp_info_chardev(Monitor *mon)
   85: {
   86:     ChardevInfoList *char_info, *info;
   87: 
   88:     char_info = qmp_query_chardev(NULL);
   89:     for (info = char_info; info; info = info->next) {
   90:         monitor_printf(mon, "%s: filename=%s\n", info->value->label,
   91:                                                  info->value->filename);
   92:     }
   93: 
   94:     qapi_free_ChardevInfoList(char_info);
   95: }
   96: 
   97: void hmp_info_mice(Monitor *mon)
   98: {
   99:     MouseInfoList *mice_list, *mouse;
  100: 
  101:     mice_list = qmp_query_mice(NULL);
  102:     if (!mice_list) {
  103:         monitor_printf(mon, "No mouse devices connected\n");
  104:         return;
  105:     }
  106: 
  107:     for (mouse = mice_list; mouse; mouse = mouse->next) {
  108:         monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
  109:                        mouse->value->current ? '*' : ' ',
  110:                        mouse->value->index, mouse->value->name,
  111:                        mouse->value->absolute ? " (absolute)" : "");
  112:     }
  113: 
  114:     qapi_free_MouseInfoList(mice_list);
  115: }
  116: 
  117: void hmp_info_migrate(Monitor *mon)
  118: {
  119:     MigrationInfo *info;
  120: 
  121:     info = qmp_query_migrate(NULL);
  122: 
  123:     if (info->has_status) {
  124:         monitor_printf(mon, "Migration status: %s\n", info->status);
  125:     }
  126: 
  127:     if (info->has_ram) {
  128:         monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
  129:                        info->ram->transferred >> 10);
  130:         monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
  131:                        info->ram->remaining >> 10);
  132:         monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
  133:                        info->ram->total >> 10);
  134:     }
  135: 
  136:     if (info->has_disk) {
  137:         monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
  138:                        info->disk->transferred >> 10);
  139:         monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
  140:                        info->disk->remaining >> 10);
  141:         monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
  142:                        info->disk->total >> 10);
  143:     }
  144: 
  145:     qapi_free_MigrationInfo(info);
  146: }
  147: 
  148: void hmp_info_cpus(Monitor *mon)
  149: {
  150:     CpuInfoList *cpu_list, *cpu;
  151: 
  152:     cpu_list = qmp_query_cpus(NULL);
  153: 
  154:     for (cpu = cpu_list; cpu; cpu = cpu->next) {
  155:         int active = ' ';
  156: 
  157:         if (cpu->value->CPU == monitor_get_cpu_index()) {
  158:             active = '*';
  159:         }
  160: 
  161:         monitor_printf(mon, "%c CPU #%" PRId64 ": ", active, cpu->value->CPU);
  162: 
  163:         if (cpu->value->has_pc) {
  164:             monitor_printf(mon, "pc=0x%016" PRIx64, cpu->value->pc);
  165:         }
  166:         if (cpu->value->has_nip) {
  167:             monitor_printf(mon, "nip=0x%016" PRIx64, cpu->value->nip);
  168:         }
  169:         if (cpu->value->has_npc) {
  170:             monitor_printf(mon, "pc=0x%016" PRIx64, cpu->value->pc);
  171:             monitor_printf(mon, "npc=0x%016" PRIx64, cpu->value->npc);
  172:         }
  173:         if (cpu->value->has_PC) {
  174:             monitor_printf(mon, "PC=0x%016" PRIx64, cpu->value->PC);
  175:         }
  176: 
  177:         if (cpu->value->halted) {
  178:             monitor_printf(mon, " (halted)");
  179:         }
  180: 
  181:         monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
  182:     }
  183: 
  184:     qapi_free_CpuInfoList(cpu_list);
  185: }
  186: 
  187: void hmp_info_block(Monitor *mon)
  188: {
  189:     BlockInfoList *block_list, *info;
  190: 
  191:     block_list = qmp_query_block(NULL);
  192: 
  193:     for (info = block_list; info; info = info->next) {
  194:         monitor_printf(mon, "%s: removable=%d",
  195:                        info->value->device, info->value->removable);
  196: 
  197:         if (info->value->removable) {
  198:             monitor_printf(mon, " locked=%d", info->value->locked);
  199:             monitor_printf(mon, " tray-open=%d", info->value->tray_open);
  200:         }
  201: 
  202:         if (info->value->has_io_status) {
  203:             monitor_printf(mon, " io-status=%s",
  204:                            BlockDeviceIoStatus_lookup[info->value->io_status]);
  205:         }
  206: 
  207:         if (info->value->has_inserted) {
  208:             monitor_printf(mon, " file=");
  209:             monitor_print_filename(mon, info->value->inserted->file);
  210: 
  211:             if (info->value->inserted->has_backing_file) {
  212:                 monitor_printf(mon, " backing_file=");
  213:                 monitor_print_filename(mon, info->value->inserted->backing_file);
  214:             }
  215:             monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
  216:                            info->value->inserted->ro,
  217:                            info->value->inserted->drv,
  218:                            info->value->inserted->encrypted);
  219:         } else {
  220:             monitor_printf(mon, " [not inserted]");
  221:         }
  222: 
  223:         monitor_printf(mon, "\n");
  224:     }
  225: 
  226:     qapi_free_BlockInfoList(block_list);
  227: }
  228: 
  229: void hmp_info_blockstats(Monitor *mon)
  230: {
  231:     BlockStatsList *stats_list, *stats;
  232: 
  233:     stats_list = qmp_query_blockstats(NULL);
  234: 
  235:     for (stats = stats_list; stats; stats = stats->next) {
  236:         if (!stats->value->has_device) {
  237:             continue;
  238:         }
  239: 
  240:         monitor_printf(mon, "%s:", stats->value->device);
  241:         monitor_printf(mon, " rd_bytes=%" PRId64
  242:                        " wr_bytes=%" PRId64
  243:                        " rd_operations=%" PRId64
  244:                        " wr_operations=%" PRId64
  245:                        " flush_operations=%" PRId64
  246:                        " wr_total_time_ns=%" PRId64
  247:                        " rd_total_time_ns=%" PRId64
  248:                        " flush_total_time_ns=%" PRId64
  249:                        "\n",
  250:                        stats->value->stats->rd_bytes,
  251:                        stats->value->stats->wr_bytes,
  252:                        stats->value->stats->rd_operations,
  253:                        stats->value->stats->wr_operations,
  254:                        stats->value->stats->flush_operations,
  255:                        stats->value->stats->wr_total_time_ns,
  256:                        stats->value->stats->rd_total_time_ns,
  257:                        stats->value->stats->flush_total_time_ns);
  258:     }
  259: 
  260:     qapi_free_BlockStatsList(stats_list);
  261: }
  262: 
  263: void hmp_info_vnc(Monitor *mon)
  264: {
  265:     VncInfo *info;
  266:     Error *err = NULL;
  267:     VncClientInfoList *client;
  268: 
  269:     info = qmp_query_vnc(&err);
  270:     if (err) {
  271:         monitor_printf(mon, "%s\n", error_get_pretty(err));
  272:         error_free(err);
  273:         return;
  274:     }
  275: 
  276:     if (!info->enabled) {
  277:         monitor_printf(mon, "Server: disabled\n");
  278:         goto out;
  279:     }
  280: 
  281:     monitor_printf(mon, "Server:\n");
  282:     if (info->has_host && info->has_service) {
  283:         monitor_printf(mon, "     address: %s:%s\n", info->host, info->service);
  284:     }
  285:     if (info->has_auth) {
  286:         monitor_printf(mon, "        auth: %s\n", info->auth);
  287:     }
  288: 
  289:     if (!info->has_clients || info->clients == NULL) {
  290:         monitor_printf(mon, "Client: none\n");
  291:     } else {
  292:         for (client = info->clients; client; client = client->next) {
  293:             monitor_printf(mon, "Client:\n");
  294:             monitor_printf(mon, "     address: %s:%s\n",
  295:                            client->value->host, client->value->service);
  296:             monitor_printf(mon, "  x509_dname: %s\n",
  297:                            client->value->x509_dname ?
  298:                            client->value->x509_dname : "none");
  299:             monitor_printf(mon, "    username: %s\n",
  300:                            client->value->has_sasl_username ?
  301:                            client->value->sasl_username : "none");
  302:         }
  303:     }
  304: 
  305: out:
  306:     qapi_free_VncInfo(info);
  307: }
  308: 
  309: void hmp_info_spice(Monitor *mon)
  310: {
  311:     SpiceChannelList *chan;
  312:     SpiceInfo *info;
  313: 
  314:     info = qmp_query_spice(NULL);
  315: 
  316:     if (!info->enabled) {
  317:         monitor_printf(mon, "Server: disabled\n");
  318:         goto out;
  319:     }
  320: 
  321:     monitor_printf(mon, "Server:\n");
  322:     if (info->has_port) {
  323:         monitor_printf(mon, "     address: %s:%" PRId64 "\n",
  324:                        info->host, info->port);
  325:     }
  326:     if (info->has_tls_port) {
  327:         monitor_printf(mon, "     address: %s:%" PRId64 " [tls]\n",
  328:                        info->host, info->tls_port);
  329:     }
  330:     monitor_printf(mon, "        auth: %s\n", info->auth);
  331:     monitor_printf(mon, "    compiled: %s\n", info->compiled_version);
  332: 
  333:     if (!info->has_channels || info->channels == NULL) {
  334:         monitor_printf(mon, "Channels: none\n");
  335:     } else {
  336:         for (chan = info->channels; chan; chan = chan->next) {
  337:             monitor_printf(mon, "Channel:\n");
  338:             monitor_printf(mon, "     address: %s:%s%s\n",
  339:                            chan->value->host, chan->value->port,
  340:                            chan->value->tls ? " [tls]" : "");
  341:             monitor_printf(mon, "     session: %" PRId64 "\n",
  342:                            chan->value->connection_id);
  343:             monitor_printf(mon, "     channel: %" PRId64 ":%" PRId64 "\n",
  344:                            chan->value->channel_type, chan->value->channel_id);
  345:         }
  346:     }
  347: 
  348: out:
  349:     qapi_free_SpiceInfo(info);
  350: }
  351: 
  352: void hmp_info_balloon(Monitor *mon)
  353: {
  354:     BalloonInfo *info;
  355:     Error *err = NULL;
  356: 
  357:     info = qmp_query_balloon(&err);
  358:     if (err) {
  359:         monitor_printf(mon, "%s\n", error_get_pretty(err));
  360:         error_free(err);
  361:         return;
  362:     }
  363: 
  364:     monitor_printf(mon, "balloon: actual=%" PRId64, info->actual >> 20);
  365:     if (info->has_mem_swapped_in) {
  366:         monitor_printf(mon, " mem_swapped_in=%" PRId64, info->mem_swapped_in);
  367:     }
  368:     if (info->has_mem_swapped_out) {
  369:         monitor_printf(mon, " mem_swapped_out=%" PRId64, info->mem_swapped_out);
  370:     }
  371:     if (info->has_major_page_faults) {
  372:         monitor_printf(mon, " major_page_faults=%" PRId64,
  373:                        info->major_page_faults);
  374:     }
  375:     if (info->has_minor_page_faults) {
  376:         monitor_printf(mon, " minor_page_faults=%" PRId64,
  377:                        info->minor_page_faults);
  378:     }
  379:     if (info->has_free_mem) {
  380:         monitor_printf(mon, " free_mem=%" PRId64, info->free_mem);
  381:     }
  382:     if (info->has_total_mem) {
  383:         monitor_printf(mon, " total_mem=%" PRId64, info->total_mem);
  384:     }
  385: 
  386:     monitor_printf(mon, "\n");
  387: 
  388:     qapi_free_BalloonInfo(info);
  389: }
  390: 
  391: static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
  392: {
  393:     PciMemoryRegionList *region;
  394: 
  395:     monitor_printf(mon, "  Bus %2" PRId64 ", ", dev->bus);
  396:     monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",
  397:                    dev->slot, dev->function);
  398:     monitor_printf(mon, "    ");
  399: 
  400:     if (dev->class_info.has_desc) {
  401:         monitor_printf(mon, "%s", dev->class_info.desc);
  402:     } else {
  403:         monitor_printf(mon, "Class %04" PRId64, dev->class_info.class);
  404:     }
  405: 
  406:     monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",
  407:                    dev->id.vendor, dev->id.device);
  408: 
  409:     if (dev->has_irq) {
  410:         monitor_printf(mon, "      IRQ %" PRId64 ".\n", dev->irq);
  411:     }
  412: 
  413:     if (dev->has_pci_bridge) {
  414:         monitor_printf(mon, "      BUS %" PRId64 ".\n",
  415:                        dev->pci_bridge->bus.number);
  416:         monitor_printf(mon, "      secondary bus %" PRId64 ".\n",
  417:                        dev->pci_bridge->bus.secondary);
  418:         monitor_printf(mon, "      subordinate bus %" PRId64 ".\n",
  419:                        dev->pci_bridge->bus.subordinate);
  420: 
  421:         monitor_printf(mon, "      IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",
  422:                        dev->pci_bridge->bus.io_range->base,
  423:                        dev->pci_bridge->bus.io_range->limit);
  424: 
  425:         monitor_printf(mon,
  426:                        "      memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",
  427:                        dev->pci_bridge->bus.memory_range->base,
  428:                        dev->pci_bridge->bus.memory_range->limit);
  429: 
  430:         monitor_printf(mon, "      prefetchable memory range "
  431:                        "[0x%08"PRIx64", 0x%08"PRIx64"]\n",
  432:                        dev->pci_bridge->bus.prefetchable_range->base,
  433:                        dev->pci_bridge->bus.prefetchable_range->limit);
  434:     }
  435: 
  436:     for (region = dev->regions; region; region = region->next) {
  437:         uint64_t addr, size;
  438: 
  439:         addr = region->value->address;
  440:         size = region->value->size;
  441: 
  442:         monitor_printf(mon, "      BAR%" PRId64 ": ", region->value->bar);
  443: 
  444:         if (!strcmp(region->value->type, "io")) {
  445:             monitor_printf(mon, "I/O at 0x%04" PRIx64
  446:                                 " [0x%04" PRIx64 "].\n",
  447:                            addr, addr + size - 1);
  448:         } else {
  449:             monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64
  450:                                " [0x%08" PRIx64 "].\n",
  451:                            region->value->mem_type_64 ? 64 : 32,
  452:                            region->value->prefetch ? " prefetchable" : "",
  453:                            addr, addr + size - 1);
  454:         }
  455:     }
  456: 
  457:     monitor_printf(mon, "      id \"%s\"\n", dev->qdev_id);
  458: 
  459:     if (dev->has_pci_bridge) {
  460:         if (dev->pci_bridge->has_devices) {
  461:             PciDeviceInfoList *cdev;
  462:             for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
  463:                 hmp_info_pci_device(mon, cdev->value);
  464:             }
  465:         }
  466:     }
  467: }
  468: 
  469: void hmp_info_pci(Monitor *mon)
  470: {
  471:     PciInfoList *info;
  472:     Error *err = NULL;
  473: 
  474:     info = qmp_query_pci(&err);
  475:     if (err) {
  476:         monitor_printf(mon, "PCI devices not supported\n");
  477:         error_free(err);
  478:         return;
  479:     }
  480: 
  481:     for (; info; info = info->next) {
  482:         PciDeviceInfoList *dev;
  483: 
  484:         for (dev = info->value->devices; dev; dev = dev->next) {
  485:             hmp_info_pci_device(mon, dev->value);
  486:         }
  487:     }
  488: 
  489:     qapi_free_PciInfoList(info);
  490: }
  491: 
  492: void hmp_quit(Monitor *mon, const QDict *qdict)
  493: {
  494:     monitor_suspend(mon);
  495:     qmp_quit(NULL);
  496: }
  497: 
  498: void hmp_stop(Monitor *mon, const QDict *qdict)
  499: {
  500:     qmp_stop(NULL);
  501: }
  502: 
  503: void hmp_system_reset(Monitor *mon, const QDict *qdict)
  504: {
  505:     qmp_system_reset(NULL);
  506: }
  507: 
  508: void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
  509: {
  510:     qmp_system_powerdown(NULL);
  511: }
  512: 
  513: void hmp_cpu(Monitor *mon, const QDict *qdict)
  514: {
  515:     int64_t cpu_index;
  516: 
  517:     /* XXX: drop the monitor_set_cpu() usage when all HMP commands that
  518:             use it are converted to the QAPI */
  519:     cpu_index = qdict_get_int(qdict, "index");
  520:     if (monitor_set_cpu(cpu_index) < 0) {
  521:         monitor_printf(mon, "invalid CPU index\n");
  522:     }
  523: }

unix.superglobalmegacorp.com