加多一個debug protocol去qemu是可能的

最新推荐文章于 2024-08-01 18:59:30 发布
最新推荐文章于 2024-08-01 18:59:30 发布
阅读量1k 收藏
点赞数
分类专栏： 操作系统开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cmk128/article/details/8183852
版权

加多一個debug protocol去qemu是可能的, 只要重寫gdbstub.c裏的gdb_handle_packet(), socket方面很容易搞， 照抄gdbserver就行


static int gdb_handle_packet(GDBState *s, const char *line_buf)
{
	printf("gdb_handle_packet=%s\n", line_buf);
    CPUArchState *env;
    const char *p;
    uint32_t thread;
    int ch, reg_size, type, res;
    char buf[MAX_PACKET_LENGTH];
    uint8_t mem_buf[MAX_PACKET_LENGTH];
    uint8_t *registers;
    target_ulong addr, len;

#ifdef DEBUG_GDB
    printf("command='%s'\n", line_buf);
#endif
    p = line_buf;
    ch = *p++;
    switch(ch) {
    case '?':
        /* TODO: Make this return the correct value for user-mode.  */
        snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
                 cpu_index(s->c_cpu));
        put_packet(s, buf);
        /* Remove all the breakpoints when this query is issued,
         * because gdb is doing and initial connect and the state
         * should be cleaned up.
         */
        gdb_breakpoint_remove_all();
        break;
    case 'c':
        if (*p != '\0') {
            addr = strtoull(p, (char **)&p, 16);
            gdb_set_cpu_pc(s, addr);
        }
        s->signal = 0;
        gdb_continue(s);
	return RS_IDLE;
    case 'C':
        s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
        if (s->signal == -1)
            s->signal = 0;
        gdb_continue(s);
        return RS_IDLE;
    case 'v':
        if (strncmp(p, "Cont", 4) == 0) {
            int res_signal, res_thread;

            p += 4;
            if (*p == '?') {
                put_packet(s, "vCont;c;C;s;S");
                break;
            }
            res = 0;
            res_signal = 0;
            res_thread = 0;
            while (*p) {
                int action, signal;

                if (*p++ != ';') {
                    res = 0;
                    break;
                }
                action = *p++;
                signal = 0;
                if (action == 'C' || action == 'S') {
                    signal = strtoul(p, (char **)&p, 16);
                } else if (action != 'c' && action != 's') {
                    res = 0;
                    break;
                }
                thread = 0;
                if (*p == ':') {
                    thread = strtoull(p+1, (char **)&p, 16);
                }
                action = tolower(action);
                if (res == 0 || (res == 'c' && action == 's')) {
                    res = action;
                    res_signal = signal;
                    res_thread = thread;
                }
            }
            if (res) {
                if (res_thread != -1 && res_thread != 0) {
                    env = find_cpu(res_thread);
                    if (env == NULL) {
                        put_packet(s, "E22");
                        break;
                    }
                    s->c_cpu = env;
                }
                if (res == 's') {
                    cpu_single_step(s->c_cpu, sstep_flags);
                }
                s->signal = res_signal;
                gdb_continue(s);
                return RS_IDLE;
            }
            break;
        } else {
            goto unknown_command;
        }
    case 'k':
#ifdef CONFIG_USER_ONLY
        /* Kill the target */
        fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
        exit(0);
#endif
    case 'D':
        /* Detach packet */
        gdb_breakpoint_remove_all();
        gdb_syscall_mode = GDB_SYS_DISABLED;
        gdb_continue(s);
        put_packet(s, "OK");
        break;
    case 's':
        if (*p != '\0') {
            addr = strtoull(p, (char **)&p, 16);
            gdb_set_cpu_pc(s, addr);
        }
        cpu_single_step(s->c_cpu, sstep_flags);
        gdb_continue(s);
	return RS_IDLE;
    case 'F':
        {
            target_ulong ret;
            target_ulong err;

            ret = strtoull(p, (char **)&p, 16);
            if (*p == ',') {
                p++;
                err = strtoull(p, (char **)&p, 16);
            } else {
                err = 0;
            }
            if (*p == ',')
                p++;
            type = *p;
            if (s->current_syscall_cb) {
                s->current_syscall_cb(s->c_cpu, ret, err);
                s->current_syscall_cb = NULL;
            }
            if (type == 'C') {
                put_packet(s, "T02");
            } else {
                gdb_continue(s);
            }
        }
        break;
    case 'g':
        cpu_synchronize_state(s->g_cpu);
        env = s->g_cpu;
        len = 0;
        for (addr = 0; addr < num_g_regs; addr++) {
            reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
            len += reg_size;
        }
        memtohex(buf, mem_buf, len);
        put_packet(s, buf);
        break;
    case 'G':
        cpu_synchronize_state(s->g_cpu);
        env = s->g_cpu;
        registers = mem_buf;
        len = strlen(p) / 2;
        hextomem((uint8_t *)registers, p, len);
        for (addr = 0; addr < num_g_regs && len > 0; addr++) {
            reg_size = gdb_write_register(s->g_cpu, registers, addr);
            len -= reg_size;
            registers += reg_size;
        }
        put_packet(s, "OK");
        break;
    case 'm':
        addr = strtoull(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoull(p, NULL, 16);
        if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 0) != 0) {
            put_packet (s, "E14");
        } else {
            memtohex(buf, mem_buf, len);
            put_packet(s, buf);
        }
        break;
    case 'M':
        addr = strtoull(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoull(p, (char **)&p, 16);
        if (*p == ':')
            p++;
        hextomem(mem_buf, p, len);
        if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 1) != 0) {
            put_packet(s, "E14");
        } else {
            put_packet(s, "OK");
        }
        break;
    case 'p':
        /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
           This works, but can be very slow.  Anything new enough to
           understand XML also knows how to use this properly.  */
        if (!gdb_has_xml)
            goto unknown_command;
        addr = strtoull(p, (char **)&p, 16);
        reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
        if (reg_size) {
            memtohex(buf, mem_buf, reg_size);
            put_packet(s, buf);
        } else {
            put_packet(s, "E14");
        }
        break;
    case 'P':
        if (!gdb_has_xml)
            goto unknown_command;
        addr = strtoull(p, (char **)&p, 16);
        if (*p == '=')
            p++;
        reg_size = strlen(p) / 2;
        hextomem(mem_buf, p, reg_size);
        gdb_write_register(s->g_cpu, mem_buf, addr);
        put_packet(s, "OK");
        break;
    case 'Z':
    case 'z':
        type = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        addr = strtoull(p, (char **)&p, 16);
        if (*p == ',')
            p++;
        len = strtoull(p, (char **)&p, 16);
        if (ch == 'Z')
            res = gdb_breakpoint_insert(addr, len, type);
        else
            res = gdb_breakpoint_remove(addr, len, type);
        if (res >= 0)
             put_packet(s, "OK");
        else if (res == -ENOSYS)
            put_packet(s, "");
        else
            put_packet(s, "E22");
        break;
    case 'H':
        type = *p++;
        thread = strtoull(p, (char **)&p, 16);
        if (thread == -1 || thread == 0) {
            put_packet(s, "OK");
            break;
        }
        env = find_cpu(thread);
        if (env == NULL) {
            put_packet(s, "E22");
            break;
        }
        switch (type) {
        case 'c':
            s->c_cpu = env;
            put_packet(s, "OK");
            break;
        case 'g':
            s->g_cpu = env;
            put_packet(s, "OK");
            break;
        default:
             put_packet(s, "E22");
             break;
        }
        break;
    case 'T':
        thread = strtoull(p, (char **)&p, 16);
        env = find_cpu(thread);

        if (env != NULL) {
            put_packet(s, "OK");
        } else {
            put_packet(s, "E22");
        }
        break;
    case 'q':
    case 'Q':
        /* parse any 'q' packets here */
        if (!strcmp(p,"qemu.sstepbits")) {
            /* Query Breakpoint bit definitions */
            snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
                     SSTEP_ENABLE,
                     SSTEP_NOIRQ,
                     SSTEP_NOTIMER);
            put_packet(s, buf);
            break;
        } else if (strncmp(p,"qemu.sstep",10) == 0) {
            /* Display or change the sstep_flags */
            p += 10;
            if (*p != '=') {
                /* Display current setting */
                snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
                put_packet(s, buf);
                break;
            }
            p++;
            type = strtoul(p, (char **)&p, 16);
            sstep_flags = type;
            put_packet(s, "OK");
            break;
        } else if (strcmp(p,"C") == 0) {
            /* "Current thread" remains vague in the spec, so always return
             *  the first CPU (gdb returns the first thread). */
            put_packet(s, "QC1");
            break;
        } else if (strcmp(p,"fThreadInfo") == 0) {
            s->query_cpu = first_cpu;
            goto report_cpuinfo;
        } else if (strcmp(p,"sThreadInfo") == 0) {
        report_cpuinfo:
            if (s->query_cpu) {
                snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
                put_packet(s, buf);
                s->query_cpu = s->query_cpu->next_cpu;
            } else
                put_packet(s, "l");
            break;
        } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
            thread = strtoull(p+16, (char **)&p, 16);
            env = find_cpu(thread);
            if (env != NULL) {
                cpu_synchronize_state(env);
                len = snprintf((char *)mem_buf, sizeof(mem_buf),
                               "CPU#%d [%s]", env->cpu_index,
                               env->halted ? "halted " : "running");
                memtohex(buf, mem_buf, len);
                put_packet(s, buf);
            }
            break;
        }
#ifdef CONFIG_USER_ONLY
        else if (strncmp(p, "Offsets", 7) == 0) {
            TaskState *ts = s->c_cpu->opaque;

            snprintf(buf, sizeof(buf),
                     "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
                     ";Bss=" TARGET_ABI_FMT_lx,
                     ts->info->code_offset,
                     ts->info->data_offset,
                     ts->info->data_offset);
            put_packet(s, buf);
            break;
        }
#else /* !CONFIG_USER_ONLY */
        else if (strncmp(p, "Rcmd,", 5) == 0) {
            int len = strlen(p + 5);

            if ((len % 2) != 0) {
                put_packet(s, "E01");
                break;
            }
            hextomem(mem_buf, p + 5, len);
            len = len / 2;
            mem_buf[len++] = 0;
            qemu_chr_be_write(s->mon_chr, mem_buf, len);
            put_packet(s, "OK");
            break;
        }
#endif /* !CONFIG_USER_ONLY */
        if (strncmp(p, "Supported", 9) == 0) {
            snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
#ifdef GDB_CORE_XML
            pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
#endif
            put_packet(s, buf);
            break;
        }
#ifdef GDB_CORE_XML
        if (strncmp(p, "Xfer:features:read:", 19) == 0) {
            const char *xml;
            target_ulong total_len;

            gdb_has_xml = 1;
            p += 19;
            xml = get_feature_xml(p, &p);
            if (!xml) {
                snprintf(buf, sizeof(buf), "E00");
                put_packet(s, buf);
                break;
            }

            if (*p == ':')
                p++;
            addr = strtoul(p, (char **)&p, 16);
            if (*p == ',')
                p++;
            len = strtoul(p, (char **)&p, 16);

            total_len = strlen(xml);
            if (addr > total_len) {
                snprintf(buf, sizeof(buf), "E00");
                put_packet(s, buf);
                break;
            }
            if (len > (MAX_PACKET_LENGTH - 5) / 2)
                len = (MAX_PACKET_LENGTH - 5) / 2;
            if (len < total_len - addr) {
                buf[0] = 'm';
                len = memtox(buf + 1, xml + addr, len);
            } else {
                buf[0] = 'l';
                len = memtox(buf + 1, xml + addr, total_len - addr);
            }
            put_packet_binary(s, buf, len + 1);
            break;
        }
#endif
        /* Unrecognised 'q' command.  */
        goto unknown_command;

    default:
    unknown_command:
        /* put empty packet */
        buf[0] = '\0';
        put_packet(s, buf);
        break;
    }
    return RS_IDLE;
}

void gdb_set_stop_cpu(CPUArchState *env)
{
    gdbserver_state->c_cpu = env;
    gdbserver_state->g_cpu = env;
}

#ifndef CONFIG_USER_ONLY
static void gdb_vm_state_change(void *opaque, int running, RunState state)
{
    GDBState *s = gdbserver_state;
    CPUArchState *env = s->c_cpu;
    char buf[256];
    const char *type;
    int ret;

    if (running || s->state == RS_INACTIVE) {
        return;
    }
    /* Is there a GDB syscall waiting to be sent?  */
    if (s->current_syscall_cb) {
        put_packet(s, s->syscall_buf);
        return;
    }
    switch (state) {
    case RUN_STATE_DEBUG:
        if (env->watchpoint_hit) {
            switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
            case BP_MEM_READ:
                type = "r";
                break;
            case BP_MEM_ACCESS:
                type = "a";
                break;
            default:
                type = "";
                break;
            }
            snprintf(buf, sizeof(buf),
                     "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
                     GDB_SIGNAL_TRAP, cpu_index(env), type,
                     env->watchpoint_hit->vaddr);
            env->watchpoint_hit = NULL;
            goto send_packet;
        }
        tb_flush(env);
        ret = GDB_SIGNAL_TRAP;
        break;
    case RUN_STATE_PAUSED:
        ret = GDB_SIGNAL_INT;
        break;
    case RUN_STATE_SHUTDOWN:
        ret = GDB_SIGNAL_QUIT;
        break;
    case RUN_STATE_IO_ERROR:
        ret = GDB_SIGNAL_IO;
        break;
    case RUN_STATE_WATCHDOG:
        ret = GDB_SIGNAL_ALRM;
        break;
    case RUN_STATE_INTERNAL_ERROR:
        ret = GDB_SIGNAL_ABRT;
        break;
    case RUN_STATE_SAVE_VM:
    case RUN_STATE_RESTORE_VM:
        return;
    case RUN_STATE_FINISH_MIGRATE:
        ret = GDB_SIGNAL_XCPU;
        break;
    default:
        ret = GDB_SIGNAL_UNKNOWN;
        break;
    }
    snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(env));

send_packet:
    put_packet(s, buf);

    /* disable single step if it was enabled */
    cpu_single_step(env, 0);
}


Qemu 调试内核 出错 Remote 'g' packet reply is too long:
SunnyBeiKe的专栏
10-31 4719
Remote 'g' packet reply is too long: 28636081ffffffff6cca69010000000000fc090000000000685f5481fffffffff9774a81ffffffff36636081ffffffffb85f5481ffffffffa05f5481ffffffff00800001000000000000000000000000985
gdb 调试kvm虚拟机_使用gdb debug Qemu (一)
weixin_39827036的博客
01-14 595
如果调试qemu，gdb是一个不错的工具，跟踪研究qemu的工作机制，以及查看问题，都是很不错的。下面介绍几个调试的问题，了解一下日常工作中如何使用gdb.1. 在qemu中，使用command line的选项来定义和选择硬件。例如可以是用-usb来定义usb的选项。目前qemu中有几种定义command line的选项。例如，-device pci-ohci. 这种low level的方式来定义...
debug-adapter-protocol:为调试适配器定义通用协议
05-14
调试适配器协议 现在可以通过其自己的使用调试适配器协议。 该网站包含有关协议如何，更易读的以及列出协议 文档。 贡献 如果您有兴趣解决错别字等问题，则可以或提出包含对所做更改的请求。 提议添加协议时，请参阅“文档。 该项目采用了。 有关更多信息，请参见或与联系，并提出其他任何问题或意见。 调试适配器协议 见 执照
Vscode学习——VS Code Debug Protocol（极客教程学习拓展）
qq_42224211的博客
02-03 1105
vscode Debug Protocol英文学习文档 DAP参考
捍卫您的应用
weixin_26727575的博客
08-13 288
It all started from a crash reported in Firebase Crashlytics console. Its been happening over and over again and giving very different logs on each occurrence. As an android developer on that project,...
使用qemu的gdbstub调试
Quard_D的博客
07-13 825
在之前我的一篇博客——《kgdb调试linux内核以及驱动模块》中简要描述如何配置kgdb进行内核以及驱动模块调试，这种方法既适用于qemu仿真环境也适用于真实的物理开发板，但对于做早期cpu core bridge up时未必能在物理设备上搭建好稳定可靠的kgdb环境。一般来讲使用qemu仿真来发现一些早期软件问题是有一定的帮助的，因此本文将描述，借助qemu的gdbsever模式，在仿真环境上更早的介入gdb工具进行非常底层的debug。本文实验环境依然为qemu搭建的riscv64模拟器环境，笔者之前
qemu_kernel_debug.zip
07-06
“qemu_kernel_debug”这个文件很可能是QEMU的配置脚本或相关的调试示例。它可能包含了启动QEMU的命令行参数，或者是一些特定的调试场景设置。通过研究这个文件，开发者可以学习如何根据实际需求定制QEMU的启动配置...
Java_这是一个基于QEMU的Android虚拟机应用程序.zip
05-23
总的来说，基于 QEMU 的 Android 虚拟机为开发者提供了一个强大的开发和测试环境，它能够帮助提高工作效率，减少物理设备的使用，同时保持与实际设备的兼容性。通过深入了解 QEMU 的工作原理和配置方法，开发者可以...
qemu:QEMU项目的一个分支，用于构建xPack QEMU ARM
05-24
xPack QEMU ARM分支 基本原理 该存储库是官方存储库的分支，并且创建该存储库是为了存储在中执行的更改。 网址 https://github.com/xpack-dev-tools/qemu.git该fork的URL git://git.qemu.org/qemu.git上游Git的URL...
qemu参数选项说明-调试选项（Debug/Expert options）
m0_51139704的博客
08-01 1399
选项用于指定监视器（monitor）的设备，监视器是 QEMU 提供的一个交互式控制台，允许用户在虚拟机运行时与其进行交互。这些固件配置项可以被虚拟机内的操作系统或固件在启动时读取，以执行特定的配置任务，例如网络配置、启动参数传递等。选项用于配置虚拟机的固件配置（firmware configuration），这通常用于向虚拟机的 BIOS 或 UEFI 固件传递特定的配置数据。并行端口通常用于打印机和其他并行设备，但在虚拟化环境中，它也可以用于重定向输出，类似于串行端口。选项用于配置虚拟机的串行端口。
Gdb远程调试Linux内核遇到的Bug
weixin_30550081的博客
01-19 320
本作品采用知识共享署名 4.0 国际许可协议进行许可。转载联系作者并保留声明头部与原文链接https://luzeshu.com/blog/gdb-bug 本博客同步在http://www.cnblogs.com/papertree/p/6298774.html 在用qemu + gdb 调试linux内核时，遇到一个gdb的bug：“Remote 'g' packet reply is too...
QEMU+GDB调试内核
热门推荐
weijitao的博客
03-07 1万+
    用GDB来调试用户态程序是一个方便快捷的定位问题的方法，极大的缩短了调试程序和定位问题的时间。而对于内核或者驱动ko的调试或者我们想了解内核运行的某些过程，我们也可以借助于gdb工具。    GDB+QEMU的方式是一种比较常见的调试内核和驱动的方法，这里写的是我在安装和使用GDB+QEMU时碰到的一些问题的笔记总结。环境准备QEMU安装Qemu的安装比较简单，可以选择下载源码进行编译；也...
用GDB远程调试运行于QEMU的程序
JiMoKuangXiangQu的专栏
02-19 2677
GDB, QEMU
gdbstub中的基本命令_GDBstub的剖析与改进.pdf
weixin_39752788的博客
12-21 467
GDBstub的剖析与改进刮睛譬黼希·应用系统GDBstub昀剖析与改进黄红燕，史烈(浙江大学计算机系统工程研究所，浙江杭州310027)改操作系统内核前提下调试应用程序的方法。这种方法可移植性强，而且消除了修改系统内核可能带来的隐患，减少了因修改内核而带来的工作量，在调试微内核操作系统服务的应用中非常有效。GDBseⅣer关键词：远程调试stub KGDB嵌入式系统调...
modelsim仿真不出波形_将GDB接入仿真的蜂鸟E203系统需要几步？
weixin_39761422的博客
11-27 844
之前在“简评几款开源RISC-V处理器”提到开源RISC-V处理器蜂鸟E203没有Verilator的仿真环境，自己何不去动手建一个呢？建起来之后，还可以把GDB接进去进行调试。我曾经总结过RISC-V的基于仿真的调试系统：“浅谈RISC-V的DEBUG系统及其仿真”，相信把GDB接入Verilator编译仿真的蜂鸟E203也不是不可能的事。说干就干，看看完成这项任务需要几步。1. Iv...
字符串16进制显示
yuanhubilie的专栏
07-24 1622
最近在项目中调试串口,,总结封装了字符串转化为16进制显示的算法,串口数据发送一般为ASCII和16进制两种,当收到数据时数据也有ASCII和16进制显示两种方式,下面给出一种转化算法,该算法基于字符类型参数化的模板实现，字符串的转化只是调用其内存版本，算法原理是对字符串内存进行操作转化,以一个字节(unsigned char类型)为单位,分别取其高4位和低4位(范围为0x0--0xF), 转化为
字符串转16进制串
luyumiao1990的专栏
07-25 448
std::string CSession::MemToHex(const void* src, size_t size, bool upper/* = true*/,char tag/* = 0*/) { std::string strDest; strDest.reserve(2*size); unsigned char* pSrc = (unsigned ch...
debug运行程序的原理
xihuanyuye的博客
05-21 3303
0 代码运行的原理是什么? 代码的运行方式可以分为直接执行和解释执行两类。 不知道平时你有没有注意，可执行文件直接 ./xxx 就可以执行，而执行 js 文件需要node ./xxx，执行python文件需要python ./xxx，这就是编译执行(直接执行)和解释执行的区别。 0.1 直接执行 cpu提供了一套指令集，基于这套指令集就可以控制整个计算机的运转，机器语言的代码就是由这些指令和对应的操作数构成的，这些机器码可以直接跑在计算机上，也就是可直接执行。由它们构成的文件叫做可执行文件。 不同操作系统可
搭建一个qemu虚拟机
最新发布
03-09
### QEMU 虚拟机搭建与配置 #### 安装依赖包 为了安装并运行 QEMU，需先确保操作系统已更新至最新状态，并安装必要的软件包。对于基于 Debian 的系统而言： ```bash sudo apt-get update && sudo apt-get upgrade -y sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virtinst cpu-checker -y ``` 以上命令不仅会下载所需的工具集还会设置好基础环境[^1]。 #### 创建桥接网络适配器 创建名为 `virbr0` 或其他名称的桥接设备用于连接物理网卡和虚拟机内部网卡。编辑 `/etc/network/interfaces.d/bridge-br0.cfg` 文件加入如下内容： ```plaintext auto br0 iface br0 inet dhcp bridge_ports eth0 bridge_stp off bridge_fd 0 bridge_maxwait 0 ``` 此操作使得宿主机上的特定网口能够共享给 VM 使用从而达到内外联通的效果[^2]。 #### 启动服务并验证功能正常 完成上述更改之后重启计算机或者手动激活新建立起来的服务单元文件： ```bash sudo systemctl restart networking.service sudo service libvirtd start ``` 此时应该可以查看到新的桥梁接口已经处于工作当中了。 #### 下载镜像准备启动实例 前往官方站点或者其他可信资源处选取适合版本的操作系统 ISO 映像作为初始加载项；接着利用图形界面管理程序如 Virt-manager 来简化整个过程或是编写 XML 描述文档定义硬件参数进而调用命令行实用程序来进行部署活动。 ```xml <domain type='kvm'> <name>TestVM</name> ... <!-- 更多配置 --> ... </domain> ``` 最后一步就是执行实际开机指令让新建好的 Guest OS 开始运作啦！ ```bash virt-install --import \ --name test-vm \ --ram=2048 \ --disk path=/var/lib/libvirt/images/test.img,size=10 \ --vcpus=2 \ --os-type linux \ --network bridge=virbr0,model=virtio \ --graphics none \ --console pty,target_type=serial \ --location 'http://archive.ubuntu.com/ubuntu/dists/focal/main/installer-amd64/' \ --extra-args 'console=ttyS0,115200n8 serial' ``` 该段脚本指定了内存大小、磁盘容量以及 CPU 数量等重要属性的同时还特别强调采用 virto 方式的 NIC 绑定方式以便获得更好的性能表现。 #### 自动化网络配置保存 为了避免每次重新引导时都要重复相同的设定动作可以在目标系统的 rc.local 中追加对应条目实现自动生效的目的。例如针对 CentOS/RHEL 类型发行版来说就是在 /etc/rc.d/rc.local 加入下面这几句语句即可达成目的: ```bash echo "ifconfig eth0 up" >> /etc/rc.d/rc.local chmod +x /etc/rc.d/rc.local ``` 而对于 Ubuntu 用户则建议修改 netplan 配置文件来持久化 IP 地址分配策略。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值