kvm解释器-004

最新推荐文章于 2024-06-06 09:39:59 发布
最新推荐文章于 2024-06-06 09:39:59 发布
阅读量4.7k 收藏
点赞数
分类专栏： kvm kvm源码解析 文章标签： kvm jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26000415/article/details/95352975
版权

本文介绍主类main方法执行的过程.其字节码如下:

另外,此处主类反编译后的结果如下:

# 参数 hejiarui$ javap -v -l -p -c -s -constants KVMTest.class 
Classfile KVMTest.class
  Last modified Jul 8, 2019; size 415 bytes
  MD5 checksum be7ceda6878f53d188a60205926bab6f
  Compiled from "KVMTest.java"
public class KVMTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // success
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // KVMTest
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               KVMTest.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               success
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               KVMTest
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public KVMTest();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String success
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
}
SourceFile: "KVMTest.java"

getstatic

此处我们来看getstatic所对应的字节码.此处在kvm中的处理如下:

#if INFREQUENTSTANDARDBYTECODES
SELECT(GETSTATIC)                        /* Get static field from class */
        /* Get the CONSTANT_Fieldref index */
        unsigned int cpIndex;
        FIELD field;
        int currentToken = TOKEN; // (*ip)

        /* Get the constant pool index */
        cpIndex = getUShort(ip + 1); // 获得index

        /* Resolve constant pool reference */
        VMSAVE
	    // 1. 获得字段
        field = resolveFieldReference(cp_global, cpIndex, TRUE, currentToken,
                                      fp_global->thisMethod->ofClass);
        VMRESTORE

     
		// 2. 如果该字段所对应的类的状态为CLASS_ERROR则抛出异常
        if (field && field->ofClass->status == CLASS_ERROR) {
            VMSAVE
                raiseExceptionWithMessage(NoClassDefFoundError,
                    KVM_MSG_EXPECTED_INITIALIZED_CLASS);
            VMRESTORE
        }

        // 3. 如果该字段所对应的类没有初始化,则进行初始化
        if (field && !CLASS_INITIALIZED(field->ofClass)) {
            VMSAVE
            /* Push class initialization frame */
            initializeClass(field->ofClass);
            VMRESTORE
            goto reschedulePoint;
        }

        if (field) {
            void *location = field->u.staticAddress;

#if ENABLEFASTBYTECODES
                REPLACE_BYTECODE(ip, ((field->accessFlags & ACC_DOUBLE)
                         ? GETSTATIC2_FAST
                         : (field->accessFlags & ACC_POINTER)
                         ? GETSTATICP_FAST : GETSTATIC_FAST))
#endif

            /* Load either one or two cells depending on field type
             * 如果存在,则进行压栈,压栈时区分是否是ACC_DOUBLE */
            if (field->accessFlags & ACC_DOUBLE) {
                oneMore;
                COPY_LONG(sp, location);
                oneMore;
            } else {
                pushStack(*(cell *)location);
            }
        } else {
        	// 如果字段不存在,则抛出异常
            VMSAVE
            fatalSlotError(cp, cpIndex);
            VMRESTORE
        }
DONE(3) 
#endif

此处有几点说一下:

  1. 静态字段压栈时是将指向PrintStream的指针压入栈中.对应的代码为:

    pushStack(*(cell *)location);

  2. DONE(3) 是个宏,宏展开后,为

    } goto next3;

    则此时执行的代码为:

    #if !RESCHEDULEATBRANCH
 	next3:  ip++;
 	next2:  ip++;
 	next1:  ip++;
 	next0:
 	reschedulePoint:
 	    RESCHEDULE
 	#endif
 	
 	   /*
 	    * If RESCHEDULEATBRANCH is defined then we only test for thread
 	    * scheduling when reschedulePoint is called.
 	    */
 	
 	#if RESCHEDULEATBRANCH
 	reschedulePoint:
 	    RESCHEDULE
 	#if ENABLE_JAVA_DEBUGGER
 	    goto next0a;
 	#else
 	    goto next0;
 	#endif

    其最终的效果是ip增加了3,因为getstatic的长度为3.

此时栈中的情况如下:

在这里插入图片描述

关于这点做如下说明:

  1. 首先执行如下代码:

    switch (signature[0]) {
                case 'D': case 'J':   accessFlags |= ACC_DOUBLE;   break;
                  case 'L': case '[':   accessFlags |= ACC_POINTER;  break;
 }
 
 if (isStatic) {
             	// 如果是static的话,则读取其属性,设置其值的下标
                 loadStaticFieldAttributes(ClassFileH, CurrentClass,
                                           thisField, StringPoolH);
                 if (accessFlags & ACC_POINTER) {
                     staticPtrCount++;
                 } else {
                     staticNonPtrCount += (accessFlags & ACC_DOUBLE) ? 2 : 1;
                 }
             } else {
                 ignoreAttributes(ClassFileH, StringPoolH);
}

    由于是对象,因此该字段的accessFlags就添加了ACC_POINTER标记.同样,也就增加了staticPtrCount

  2. 接着,将该字段分配在持久代中,代码如下:

    void **nextPtrField = (void **)statics->data;
....

cpIndex = (unsigned short)(thisField->u.offset);
             if (thisField->accessFlags & ACC_POINTER) {
                 /* The only possible initialization is for a string 这种情况只能是string,这里是对string的特殊处理,对于其他对象,数组,都是在<cinit>方法中初始化的*/
                 thisField->u.staticAddress = nextPtrField;
                 if (cpIndex != 0) {
                     verifyConstantPoolEntry(CurrentClass, cpIndex,
                                             CONSTANT_String);
                     *(INTERNED_STRING_INSTANCE *)nextPtrField =
                         CP_ENTRY(cpIndex).String;
                 }
                 nextPtrField++;
}

  3. 而在对getstatic处理的过程中,其最终使用如下代码压栈:

    void *location = field->u.staticAddress;
pushStack(*(cell *)location); // 此处是指向PrintStream的指针.

    因此,在栈中压入的是指向PrintStream的指针.

ldc

此处执行的字节码是

3: ldc           #3                  // String success

而在kvm中对应的代码为:

#if STANDARDBYTECODES
SELECT(LDC)       /* Push item from constant pool onto the operand stack */
        unsigned int cpIndex = ip[1];
        CONSTANTPOOL_ENTRY thisEntry = &cp->entries[cpIndex];
        pushStack(thisEntry->integer);
DONE(2)
#endif

此处存放的是指向success的字符串的指针.因此此处的情况如图所示:

在这里插入图片描述

关于以上为何是指针.这点解释一下.

对于success字符串而言.是在loadConstantPool方法中进行处理的.

  1. 由于其声明如下:

    #3 = String             #18            // success
#18 = Utf8               success

    因此,在loadConstantPool中首先是对String处理,代码如下:

    switch (tag) {
         case CONSTANT_String:
         case CONSTANT_Class: {
             /* A single 16-bit entry that points to a UTF string */
             unsigned short nameIndex = loadShort(ClassFileH); // 此处获得的是18
             RAW_POOL(cpIndex).integer = nameIndex;
             break;
}

    因此,此处在主类所对应的运行时常量池中下标为3处,存放的是18.

    然后接着处理UTF8,代码如下:

     case CONSTANT_Utf8: {
             unsigned short length = loadShort(ClassFileH);
             /* This allocation may invalidate ClassFile */
             char *string = mallocBytes(length + 1);
             STRING_POOL(cpIndex) =  string;
             loadBytes(ClassFileH, string, length);
             string[length] = '\0';

             verifyUTF8String(string, length);
}

    将success该字符串放入string_pool中。注意,这个string_pool是临时的

  2. 接着,执行如下代码:

     case CONSTANT_String: {
             unsigned short nameIndex =
                 (unsigned short)RAW_POOL(cpIndex).integer;// 此处获得的是18
             char *name = getUTF8String(&StringPool, nameIndex);// 此处获得success的指针
             INTERNED_STRING_INSTANCE string =
                 internString(name, strlen(name));// 在持久代中分配
             CP_ENTRY(cpIndex).String = string;// 保存指针
             break;
}

    因此,最终主类所对应的运行时常量池中下标为3处,存放的是指向success字符串的指针.

  3. 由于constantPoolEntryStruct是一个union,其定义如下:

    union constantPoolEntryStruct {
 struct { 
     unsigned short classIndex;
     unsigned short nameTypeIndex;
 }               method;  /* Also used by Fields */
 CLASS           clazz;
 INTERNED_STRING_INSTANCE String;
 cell           *cache;   /* Either clazz or String */
 cell            integer;
 long            length;
 NameTypeKey     nameTypeKey;
 NameKey         nameKey;
 UString         ustring;
 };

    因此,在ldc的处理中,使用thisEntry->integer和thisEntry–> String是一样的,都是4字节.

invokevirtual

此处执行的字节码为:

5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V

而在kvm中对应的代码为:

#if INFREQUENTSTANDARDBYTECODES
SELECT(INVOKEVIRTUAL)
        /* Invoke instance method; dispatch based on dynamic class */

        /* Get the CONSTANT_Methodref index */
        unsigned int cpIndex;
        METHOD cpMethod;

        /* Get the constant pool index */
        cpIndex = getUShort(ip + 1);

        /* Resolve constant pool reference */
        VMSAVE
		// 1. 获得对应的方法
        cpMethod = resolveMethodReference(cp_global, cpIndex, FALSE,
                                          fp_global->thisMethod->ofClass);
        VMRESTORE
        if (cpMethod) {
            CLASS dynamicClass;

            /* Calculate the number of parameters  from signature */
            int argCount = cpMethod->argCount; // 获得参数数量

            /* Get this */
            thisObject = *(OBJECT*)(sp-argCount+1);// 获得this
            CHECK_NOT_NULL(thisObject);

            /* Get the dynamic class of the object */
            dynamicClass = thisObject->ofClass;// 获得当前对象所对应的class

            /* Find the actual method */
            VMSAVE
			// 找到对应的方法
            thisMethod = lookupDynamicMethod(dynamicClass, cpMethod);
            VMRESTORE

            /*
             * In order for INVOKEVIRTUAL to be called, an instance
             * of the object must exist. Thus, the class initialization
             * is not needed since the class in question will already be 
             * initialized.
             */
            if (thisMethod) {
               // 缓存处理
#if ENABLEFASTBYTECODES
                if (   (cpMethod->accessFlags & (ACC_PRIVATE | ACC_FINAL))
                    || (cpMethod->ofClass->clazz.accessFlags & ACC_FINAL)
                   ) {
                    REPLACE_BYTECODE(ip, INVOKESPECIAL_FAST)
                } else {
                    int iCacheIndex;
                    /* Replace the current bytecode sequence */
                    CREATE_CACHE_ENTRY((cell*)thisMethod, ip)
                    REPLACE_BYTECODE(ip, INVOKEVIRTUAL_FAST)
                    putShort(ip + 1, iCacheIndex);
                }
#endif /* ENABLEFASTBYTECODES */

                TRACE_METHOD_ENTRY(thisMethod, "virtual");

                // 调用方法
                CALL_VIRTUAL_METHOD
            } else {
                VMSAVE
                fatalSlotError(cp, cpIndex);
                VMRESTORE
            }
        } else {
            VMSAVE
            fatalSlotError(cp, cpIndex);
            VMRESTORE
        }
DONE(0)
#endif

而CALL_VIRTUAL_METHOD是一个宏,展开后为:

#define CALL_VIRTUAL_METHOD   {                 \
    goto callMethod_virtual;                    \
}

因此最终会执行如下代码:

 callMethod_virtual:
        callMethod_static:
        callMethod_special:
            invokerSize = 3;       /* Size of the bytecode */

        callMethod_general: {

            INC_CALLS

            /* 如果是本地方法,则调用本地方法*/
            if (thisMethod->accessFlags & ACC_NATIVE) {
                ip += invokerSize;
                VMSAVE
                invokeNativeFunction(thisMethod);
                VMRESTORE
                TRACE_METHOD_EXIT(thisMethod);
                goto reschedulePoint;
            }

            /* 如果该方法是抽象的,则抛出异常 */
            if (thisMethod->accessFlags & ACC_ABSTRACT) {
                VMSAVE
                raiseExceptionWithMessage(AbstractMethodError, methodName(thisMethod));
                VMRESTORE
            }


            // 压栈处理
            thisObjectGCSafe = thisObject;
            VMSAVE
            pushFrame(thisMethod);
            VMRESTORE

            /* Advance to the next instruction on return */
            fp->previousIp += invokerSize;

            /*  同步处理 */
            if (thisMethod->accessFlags & ACC_SYNCHRONIZED) {
                VMSAVE
                monitorEnter(thisObjectGCSafe);
                VMRESTORE
                fp->syncObject = thisObjectGCSafe;
            }

            thisObjectGCSafe = NULL;
            goto reschedulePoint;

因此,此处也就是建立println方法的栈帧,进行方法调用.此处就不展开了.

RETURN

此处我们看主类main方法中的最后一个字节码,return.在kvm中,处理如下:

#if STANDARDBYTECODES
SELECT6(IRETURN, LRETURN, FRETURN, DRETURN, ARETURN, RETURN)
        /* Return from method */
        BYTE*  previousIp    = fp->previousIp;
        OBJECT synchronized  = fp->syncObject;

        TRACE_METHOD_EXIT(fp->thisMethod);

        if (synchronized != NULL) {
            char*  exitError;
            if (monitorExit(synchronized, &exitError) == MonitorStatusError) {
                exception = exitError;
                goto handleException;
            }
        }

        /* Special case where we are killing a thread */
        if (previousIp == KILLTHREAD) { // 此处执行这里
            VMSAVE
            stopThread(); // 停止线程
            VMRESTORE
            if (areAliveThreads()) {
                goto reschedulePoint;
            } else {
                return;                   /* Must be the end of the program */
            }
        }

        /* Regular case where we pop the stack frame and return data */
        if ((TOKEN & 1) == 0) {
            /* The even ones are all the return of a single value */
            cell data = topStack;
            POP_FRAME
            pushStack(data);
        } else if (TOKEN == RETURN) {
            POP_FRAME
        } else {
            /* We don't care whether it's little or big endian. . . */
            long t2 = sp[0];
            long t1 = sp[-1];
            POP_FRAME
            pushStack(t1);
            pushStack(t2);

        }
        goto reschedulePoint;
DONEX
#endif

由于此处的previousIp = KILLTHREAD,因此会调用stopThread.而关于该方法,我们下文介绍。(写不动了…)

一个努力的码农
关注
专栏目录
call 存储过程时必须声明表示符_【课程笔记】南大软件分析课程5——过程间分析（课时7）
weixin_39830917的博客
11-02 138
有些符号、表格显示不出来，还是看原文吧 https://www.jianshu.com/p/d314b316b332【课程笔记】南大软件分析课程5——过程间分析​www.jianshu.com目录：Motivation调用图构建过程间控制流分析过程间数据流分析重点：学习如何利用类层级分析来构建调用图；过程间控制流/数据流分析；过程间的常量传播。1.Motivation问题：过程内的分析未考虑函数调...
java kvm_KVM的web管理界面
weixin_42526353的博客
02-15 705
安装好KVM之后，就可以安装kimchi和wok了。一、KVM的web管理界面什么是Wok？Wok基于cherrypy的web框架，可以通过一些插件来进行扩展，例如：虚拟化管理、主机管理、系统管理。它可以在任何支持HTML5的网页浏览器中运行。什么是Kimchi？Kimchi是一个基于HTML5的KVM管理工具，是Wok的一个插件(使用Kimchi前一定要先安装了wok)，通过Kimchi可以更方...
KVM在嵌入式Linux上的移植
if.q的博客（请转iwood.co.nr）
10-17 2059
以前就想做这个玩玩 不过发现似乎难度不大 都比较现成的东西了 就没有做.不过对于具体问题还是不清楚.昨天找到这篇文章 记下来,说不定以后会用到..KVM在嵌入式Linux上的移植 [转载请注明出处,作者：张洪耿，patrick_zhg@hotmail.com] 目前嵌入式Linux被广泛应用于嵌入式设备，Java语言由于其”Write Once，Run Anywher e”的特性，开始被应
java原理实现: 从虚拟机到源码
secret_breathe的博客
07-07 3330
java原理实现: 从虚拟机到源码 ​ Sun公司与其他组织发布了许多可以运行在各种不同平台上的虚拟机, 这些虚拟机都可以编译和执行同一种平台无关的字节码, 从而实现了"一次编写, 到处运行". 了解Java内存 ​ Java内存是由虚拟机自动管理的, 当时也会发生内存溢出异常. 为了在发生内存溢出时不至于束手无策, 还是需要了解 Java 怎么管理内存的. a. Java内存划分 ​ ...
kvm解释器-003
qq_26000415的博客
07-10 4820
本文继续介绍kvm中解释执行的步骤.接上文,目前栈中的情况如图所示: 初始化Thread 此处初始化的步骤和上文中介绍的一样,也是调用runClinit方法.首先设置初始化线程为CurrentThread,然后由于其父类Object此时的状态为CLASS_READY,因此就不需要初始化父类了.此处的代码如下: if ((thisClass->clazz.accessFlags & ...
kvm解释器-001
qq_26000415的博客
07-09 5016
从本文开始接受kvm中解释器是如何执行的流程.以一个例子来进行说明,如下: public class KVMTest{ public static void main(String[] args){ System.out.println("success"); } } javap后,其结果如下: # 命令行为: javap -v -l -p -c ...
kvm解释器-002
qq_26000415的博客
07-09 4847
在JAVA虚拟机规范(JAVA SE 7 )中,针对初始化的过程有如下的定义: 每个类或接口C，都有一个唯一的初始化锁LC。如何实现从C到LC的映射可由Java虚拟机实现自行决定。例如，LC可以是C的Class对象，或者是与Class对象相关的管程（Monitor）。初始化C的过程如下： 同步C的初始化锁LC。这个操作会导致当前线程一直等待直到可以获得LC锁 如果C的Class对象显示当前C的初...
kvm启动流程-005
qq_26000415的博客
07-05 5109
写在前面 这是本人的第100篇博文,随着不断的看源码,不知不觉已有这么多… 前言 kvm在启动时的步骤如下: 创建ROM镜像,此处为宏,定义在j2me_cldc/kvm/VmCommon/h/garbage.h 初始化FPU 初始化异步I/0系统 初始化本地代码 初始化vm,此处为宏,定义在j2me_cldc/kvm/VmUnix/h/machine_md.h 初始化全局变量 初始化性能统计的变...
kvm启动流程-003
qq_26000415的博客
07-05 5133
kvm在启动时的步骤如下: 创建ROM镜像,此处为宏,定义在j2me_cldc/kvm/VmCommon/h/garbage.h 初始化FPU 初始化异步I/0系统 初始化本地代码 初始化vm,此处为宏,定义在j2me_cldc/kvm/VmUnix/h/machine_md.h 初始化全局变量 初始化性能统计的变量,定义在 j2me_cldc/kvm/VmCommon/h/profiling....
J2ME的KVM-KNI-资料
01-08
KVM（K Virtual Machine）是Java虚拟机的精简版本，负责解释和执行字节码。它包括类加载器、字节码验证器、垃圾收集器以及一个基本的运行时环境。KVM在J2ME中的角色至关重要，因为它使得开发者能够利用Java的跨平台...
virt-scripts：用于Linux KVM实验室的Bash脚本。 仅用于教育目的
01-31
Bash是Unix及类Unix系统中最常用的命令行解释器，也是Linux shell脚本的主要编写语言。Bash脚本允许用户通过编程方式执行一系列命令，非常适合进行系统自动化管理任务，如创建虚拟机、安装操作系统、配置网络等。 ...
OpenStack所支持的虚拟化技术和KVM、Xen、Hyer-V、QEMU、Libvirt说明
最新发布
没刮胡子的程序员专栏
06-06 1441
OpenStack所支持的虚拟化技术和KVM、Xen、Hyer-V、QEMU、Libvirt说明
StackMap属性解析
qq_26000415的博客
07-01 7351
由于我们会在后续的文章介绍class验证环节,其中在校验方法时需要使用到StackMap.那么什么是StackMap呢? 从Java 6开始，JVM规范有一个更新文档，JSR 202，里面提到一种新的字节码校验算法，“类型检查”；在此之前是用“类型推导”的算法。为了支持新算法，Class文件从版本50开始添加了一个新的属性表，叫做StackMapTable，里面记录的是一个方法中操作数栈与局部变...
kvm启动流程
qq_26000415的博客
07-02 5865
从本文开始介绍,kvn的启动流程. 启动入口位于j2me_cldc/kvm/VmExtra/src/main.c的main方法.代码如下: int main (int argc, char* argv[]) { int result; #if USE_JAM char *jamInstalledAppsDir = "./instapps"; #endif JamEnab...
kvm目录结构
qq_26000415的博客
07-01 5653
kvm介绍 此KVM不是目前特别火的Kernel-based Virtual Machine(一个开源的系统虚拟化模块).而是一个JAVA 的虚拟机.是J2ME cldc 的一个实现.其源码的难度比hotspot简单多了.因此,想通过研读KVM,以加深对hotspot的理解 下载 可以到: 下载地址 在同意许可证后就可以下载到CLDC 1.1的参考实现源码了。 文件名是：j2me_cldc-1_1...
kvm垃圾收集-001
qq_26000415的博客
07-12 5584
kvm中的垃圾收集算法是基于Cheney的elegant copying collector而来.尽管该收集器有很多好处(特别是，它使用迭代而不是递归算法来收集对象).但它有复制收集器的一般问题，因为它需要比程序实际使用的内存空间多一倍的内存空间。当将KVM移植到内存非常有限的设备（如PalmPilot）上运行时，这一要求是有问题的。 为了使kvm更适合小型设备，针对kvm 1.0实现了一种新的垃...
kvm垃圾收集-002
qq_26000415的博客
07-18 5521
本文我们来介绍kvm中的垃圾收集器的实现.其算法为mark-and-sweep(含有压缩功能).其方法为garbageCollect.代码如下: void garbageCollect(int moreMemory) { #if INCLUDEDEBUGCODE int beforeCollection = 0; int afterCollection = 0; #endif ...
kvm线程-007-线程状态-THREAD_SUSPENDED,THREAD_DEAD
qq_26000415的博客
07-25 5506
本文介绍线程状态THREAD_SUSPENDED,THREAD_DEAD的使用。 THREAD_SUSPENDE 该状态设置的地方为: startThread,该方法在kvm线程-006-线程状态-THREAD_ACTIVE 中有介绍 suspendThread,该方法的代码如下: void suspendThread(void) { // 1. 如果CurrentThread 为null...
ARM Cortex-A15 KVM 深入指南
- 启动加载器：讨论了如U-Boot这样的启动加载器的配置，以便正确引导KVM虚拟机。 - 主机文件系统：描述了创建和配置主机文件系统以包含必要的工具和库的流程。 - 测试主机系统：给出了验证主机系统是否准备好运行KVM...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值