精华内容
下载资源
问答
  • 如果使用远程桌面复制粘贴过程中异常中断,接下来很可能无法再使用复制粘贴,重新连接远程桌面也不管用,试试以下办法: 首先检查远程电脑上rdpclip.exe进程是否在运行,如果运行可以结束进程再重新运行。运行方法...

    如果使用远程桌面复制粘贴过程中异常中断,接下来很可能无法再使用复制粘贴,重新连接远程桌面也不管用,试试以下办法:

    首先检查远程电脑上rdpclip.exe进程是否在运行,如果运行可以结束进程再重新运行。运行方法:使用win+r调出运行框,输入rdpclip回车即可运行rdpclip.exe。

    如果不行,在本地电脑执行相同的操作

    展开全文
  • 这么看来感觉跟IO的实现一致啊,为什么速度差别那么大呢,继续跟代码,问题在图片1newInputStream(source)方法 这里提供的InputSteam实际上是sun.nio.ch.ChannelInputStream,而我们测试的IO的...

     

    第一种,传统的IO模式

    	private static void copyByIO(String srcPath, String dstPath) {
            byte[] buffer = new byte[bufferSize];
            FileInputStream fis = null;
            FileOutputStream fos = null;
            try {
                fis = new FileInputStream(srcPath);
                fos = new FileOutputStream(dstPath);
                int len;
                while ((len = fis.read(buffer)) != -1) {
                    fos.write(buffer, 0, len);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    第二种,NIO的 directbuffer模式

    private static void copyByNIO(String srcPath, String dstPath) {
            FileInputStream fis = null;
            FileOutputStream fos = null;
            FileChannel fisChannel = null;
            FileChannel fosChannel = null;
            ByteBuffer buffer = ByteBuffer.allocateDirect(bufferSize);
            try {
                fis = new FileInputStream(srcPath);
                fos = new FileOutputStream(dstPath);
                fisChannel = fis.getChannel();
                fosChannel = fos.getChannel();
                while (fisChannel.read(buffer) != -1) {
                    buffer.flip();
                    fosChannel.write(buffer);
                    buffer.clear();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fisChannel != null) {
                    try {
                        fisChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fosChannel != null) {
                    try {
                        fosChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    第3种,NIO transferto的模式

    private static void copyByNIOTransfer(String srcPath, String dstPath) {
            FileInputStream fis = null;
            FileOutputStream fos = null;
            FileChannel fisChannel = null;
            FileChannel fosChannel = null;
            try {
                fis = new FileInputStream(srcPath);
                fos = new FileOutputStream(dstPath);
                fisChannel = fis.getChannel();
                fosChannel = fos.getChannel();
                long len = fisChannel.transferTo(0, fisChannel.size(), fosChannel);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fisChannel != null) {
                    try {
                        fisChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fis != null) {
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fosChannel != null) {
                    try {
                        fosChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    第4种,通过Files copy方式实现

    private static void copyByFiles(String srcPath, String dstPath) {
            Path path = Paths.get(srcPath);
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(dstPath);
                /*
                 * private static final int BUFFER_SIZE = 8192;
                 * private static long copy(InputStream source, OutputStream sink) throws IOException
                 * {
                 * long nread = 0L;
                 * byte[] buf = new byte[BUFFER_SIZE];
                 * int n;
                 * while ((n = source.read(buf)) > 0) {
                 * sink.write(buf, 0, n);
                 * nread += n;
                 * }
                 * return nread;
                 * }
                 */
                long len = Files.copy(path, fos);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    通过单个方法运行得出结果,IO最慢,Files.copy的速度接近transferto,但是查看源码疑惑出现了,下面列出源码Files.copy
    createFile		000102400	cost	04342033631us
    copyByIO		000102400	cost	254391101034132us
    copyByNIO		000102400	cost	00241791703us
    copyByNIOTransfer	000102400	cost	00178104807us
    copyByFiles		000102400	cost	00202207341us

    这是在另一台机械硬盘上的表现,第一台测试机带SSD,担心有影响,机械硬盘的结果比较明显了

    5. FILE_SIZE = 102400 KB
    createFile		000102400	cost	12997817696us
    copyByIO		000102400	cost	00395415564us
    copyByNIO		000102400	cost	00348269525us
    copyByNIOTransfer	000102400	cost	00127312664us
    copyByFiles		000102400	cost	00407214806us

     

     

    这么看来感觉跟IO的实现一致啊,为什么速度差别那么大呢,继续跟代码,问题在图片1中newInputStream(source)方法中

    这里提供的InputSteam实际上是sun.nio.ch.ChannelInputStream,而我们测试的IO中的InputSteam是用的FileInputSteam,而ch 实际是SeekableByteChannel ,由FileSystemProvider的实现类创建,而不同操作系统会提供不同的Prodvider,比如windows的差别就在这里了。

        public SeekableByteChannel newByteChannel(Path obj,
                                                  Set<? extends OpenOption> options,
                                                  FileAttribute<?>... attrs)
             throws IOException
        {
            WindowsPath file = WindowsPath.toWindowsPath(obj);
            WindowsSecurityDescriptor sd =
                WindowsSecurityDescriptor.fromAttribute(attrs);
            try {
                return WindowsChannelFactory
                    .newFileChannel(file.getPathForWin32Calls(),
                                    file.getPathForPermissionCheck(),
                                    options,
                                    sd.address());
            } catch (WindowsException x) {
                x.rethrowAsIOException(file);
                return null;  // keep compiler happy
            } finally {
                sd.release();
            }
        }

    实际上Files.copy还有两种方式,一:

    public static long copy(InputStream in, Path target, CopyOption... options)

    关键在于

                ostream = newOutputStream(target, StandardOpenOption.CREATE_NEW,
                                                  StandardOpenOption.WRITE);

    从这里可用看出跟上面的方式基本一致,只不过一个是InputSteam,一个是OutStream。还有另外一种,二:方法如下

    public static Path copy(Path source, Path target, CopyOption... options)

    直接利用的是windows的复制功能

        @Override
        public void copy(Path source, Path target, CopyOption... options)
            throws IOException
        {
            WindowsFileCopy.copy(WindowsPath.toWindowsPath(source),
                                 WindowsPath.toWindowsPath(target),
                                 options);
        }

    另外有一种方式与第二种方式类似,使用MappedByteBuffer来进行文件读写,底层是利用的mmap的机制

     

    DMA(Direct Memory Access,直接内存存取) 是所有现代电脑的重要特色,它允许不同速度的硬件装置来沟通,而不需要依赖于 CPU 的大量中断负载。否则,CPU 需要从来源把每一片段的资料复制到暂存器,然后把它们再次写回到新的地方。在这个时间中,CPU 对于其他的工作来说就无法使用。

    DMA 传输将数据从一个地址空间复制到另外一个地址空间。当CPU 初始化这个传输动作,传输动作本身是由 DMA 控制器来实行和完成。典型的例子就是移动一个外部内存的区块到芯片内部更快的内存区。像是这样的操作并没有让处理器工作拖延,反而可以被重新排程去处理其他的工作。DMA 传输对于高效能 嵌入式系统算法和网络是很重要的。

    DMADMA

    在实现DMA传输时,是由DMA控制器直接掌管总线,因此,存在着一个总线控制权转移问题。即DMA传输前,CPU要把总线控制权交给DMA控制器,而在结束DMA传输后,DMA控制器应立即把总线控制权再交回给CPU。一个完整的DMA传输过程必须经过DMA请求、DMA响应、DMA传输、DMA结束4个步骤。

    DMA控制器与CPU怎样分时使用内存呢?通常采用以下三种方法:

    (1)停止CPU访内存;

    (2)周期挪用;

    (3)DMA与CPU交替访问内存。

    Linux高速缓冲区

    高速缓冲区在整个物理内存中的位置处于内核区和主内存区之间,不在硬盘上,之前的理解有误跟swap区搞混了。

    https://www.cnblogs.com/alantu2018/p/8447411.html

    关于零拷贝的资料

    https://www.jianshu.com/p/fad3339e3448 中文版

    https://blog.csdn.net/hzrandd/article/details/51025341

    https://blog.csdn.net/linsongbin1/article/details/77650105

    https://blog.csdn.net/a417930422/article/details/52585862

    https://www.linuxjournal.com/article/6345?page=0,2  e文版

    https://www.ibm.com/developerworks/cn/java/j-zerocopy/#fig1

    关于mmap的资料

    https://blog.csdn.net/zqixiao_09/article/details/51088478

    VM_IO将VMA设置成一个内存映射IO区域。

    shm与mmap的区别联系

    https://blog.csdn.net/bluenet13/article/details/40039497

    Linux虚拟缓存

    https://www.oschina.net/translate/understanding-virtual-memory

    Linux IPC,FIFO和shm

    https://blog.csdn.net/pouloghost/article/details/19997961

    Linux IPC

    https://blog.csdn.net/a987073381/article/details/52006729

     

    https://www.cnblogs.com/wang_yb/p/3351599.html

    http://blog.jqian.net/post/linux-shm.html

    Linux文件Cache

    https://www.ibm.com/developerworks/cn/linux/l-cache/

    Linux文件系统预读

    https://blog.csdn.net/AXW2013/article/details/55188316

    Java中的IOStatus

    static final int EOF = -1;              // End of file
    static final int UNAVAILABLE = -2;      // Nothing available (non-blocking)
    static final int INTERRUPTED = -3;      // System call interrupted
    static final int UNSUPPORTED = -4;      // Operation not supported
    static final int THROWN = -5;           // Exception thrown in JNI code
    static final int UNSUPPORTED_CASE = -6; // This case not supported

     

    Java io的读写情况,以

    磁盘—>内核缓存—>native堆——>jvm heap——>native堆——>socket缓冲——>网卡

    java多了native堆和jvm heap之间拷贝就是为了防止gc发生时jvm heap内部数据地址改变,导致读取错误数据。

    directbuffer和c语言中的io速度一样的,是heapbuffer拖慢了性能,不是directbuffer提高了性能。

     

    展开全文
  • 一、中断处理的过程根据Intel 64 and IA-32 Architectures Software Developer’s Manual 的介绍,在中断或异常产生是,CPU会将当前执行的指令(或下一条指令)在内存的地址,也就是EIP的值,放入栈,同时还会放...

    一、中断处理的过程

     

    根据Intel 64 and IA-32 Architectures Software Developer’s Manual 的介绍,在中断或异常产生是,CPU会将当前执行的指令(或下一条指令)在内存中的地址,也就是EIP的值,放入栈中,同时还会放入CS段寄存器和eflags标志寄存器的值等。

    根据当前的优先级不同(ring0或ring3,也就是执行与用户态还是内核态)会有较大的不同。如果异常或中断发生时,系统正执行在内核态,那么CPU不会切换栈,直接将EFLAGS、CS、EIP和Error Code压入栈中,如果正执行在非内核态,那么先切换到内核,切换到内核栈,然后依次压入SS、ESP(用户态线程的)、EFLAGS、CS、EIP和Error Code。(上述过程CPU自行完成,操作系统只需要把ISR放到正确的位置等待调用。)然后通过IDT找到对应的ISR 开始执行。

    ISR完成处理后通过IRET(IRETD)指令返回到被中断的程序中继续执行即可。

     

     

    二、安装配置Bochs和XP Guest系统

     

    在上一篇文章中,说了为什么不能使用WinDbg调试ISR。

     

    好在我们还有bochs这个带调试功能的软件虚拟机。bochs的调试功能比起WinDbg这个专业调试器来,功能弱了十万八千里。但是,由于bochs是一个软件实现的CPU(对Guest系统来说相当于硬件),比WinDbg要低一个层次,在一些特殊的情况下bochs就能出奇制胜了。bochs是CPU,是一切的主宰,不需要你guest系统给我提供任何支持。

     

    安装好bochs以后,可以在bochs中安装windows xp。bochs运行所依赖的一切硬件的配置都是依赖于bxrc配置文件。把安装目录下的bochsrc.bxrc复制一份,双击打开。在下图的对话框里可以编辑配置文件。

    如果安装xp需要将CPU的主频调高一些(我用的50000000)memory调得合适一些,比如512Mb。在这之前还需要使用安装目录下的bximage.exe创建一个growing的硬盘文件,比如c.img。growing的方式可以避免以后guest系统硬盘不够用。

     

     

    然后配置“Disk & Boot”选项,挂载上c.img

     

     然后配置光盘。需要一个windows xp安装光盘的iso文件,也可以映射到物理光驱。

     

     然后配置有cdrom启动。

     

    调试过程最好log下来,便于后面分析。在“logfile”选项中配置调试的日志文件。

     

     

    然后save,start就可以开始运行bochs了。

    安装过程需要比较漫长的时间,毕竟软件CPU的性能和物理CPU不在一个数量级上。打个球,洗个澡,再吃个饭的时间应该差不多了。
    安装好以后注意备份一下,在bochs里安装xp可是一个宏大的系统工程了。然后再把boot选项设置为从disk启动。

    安装好以后,就可以使用bochs调试器bochsdbg.exe加载配置文件运行了。在“Bochs Start Menu”里面load然后start。

    bochsdbg会停在f000:fff0处(这个时候CPU还没有切换到保护模式)是bios的起始处。
    运行命令c(continue)可以继续系统运行。不久windows系统启动。在console里Ctrl-C可以中断运行输入各种调试命令。

     

    操作虚拟机的鼠标需要点击按钮,释放时Ctrl+鼠标第三键(滚轮)

     

     

    三、使用bochs调试观察中断过程

     

    先介绍几个调试指令(不是全部,只是在本文中用的的,其他的可以参考help或Bochs的文档)

    r 查看通用寄存器

    sreg 参看段寄存器(idtr被归到这里了)

    creg 参看系统寄存器(cr0等)

    x 参看内存(线性地址)

    xp 参看内存(物理地址)

    pb 通过物理地址下执行断点

    lb 通过线性地址下执行断点

    setpmem 修改物理内存(Bochs只支持通过物理地址修改内存,不过可以通过info tab参看整个分页表,手工转换一下,而且单步跟踪时Bochs也会同时打印指令对应的物理地址和线性地址)

    help 帮助

    info idt 参看idt信息

     

    Crtl-C中断下XP系统的执行,就可以在Console中输入调试命令。

     

    1、静态参看IDT信息


    <bochs:5> sreg
    es:0x0023, dh=0x00cff300, dl=0x0000ffff, valid=7
     Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
    cs:0x0008, dh=0x00cf9b00, dl=0x0000ffff, valid=1
     Code segment, base=0x00000000, limit=0xffffffff, Execute/Read, Accessed, 32-bit
    ss:0x0010, dh=0x00cf9300, dl=0x0000ffff, valid=7
     Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
    ds:0x0023, dh=0x00cff300, dl=0x0000ffff, valid=7
     Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
    fs:0x0030, dh=0xffc093df, dl=0xf0000001, valid=7
     Data segment, base=0xffdff000, limit=0x00001fff, Read/Write, Accessed
    gs:0x0000, dh=0x00001000, dl=0x00000000, valid=0
    ldtr:0x0000, dh=0x00008200, dl=0x0000ffff, valid=0
    tr:0x0028, dh=0x80008b04, dl=0x200020ab, valid=1
    gdtr:base=0x000000008003f000, limit=0x3ff
    idtr:base=0x000000008003f400, limit=0x7ff

    <bochs:6> x /100w 0x8003f400
    [bochs]:
    0x000000008003f400 <bogus+       0>: 0x0008f19c 0x80538e00 0x0008f314 0x80538e00
    0x000000008003f410 <bogus+      16>: 0x0058113e 0x00008500 0x0008f6e4 0x8053ee00
    0x000000008003f420 <bogus+      32>: 0x0008f864 0x8053ee00 0x0008f9c0 0x80538e00
    0x000000008003f430 <bogus+      48>: 0x0008fb34 0x80538e00 0x0008019c 0x80548e00
    0x000000008003f440 <bogus+      64>: 0x00501198 0x00008500 0x000805c0 0x80548e00
    0x000000008003f450 <bogus+      80>: 0x000806e0 0x80548e00 0x00080820 0x80548e00
    0x000000008003f460 <bogus+      96>: 0x00080a7c 0x80548e00 0x00080d60 0x80548e00
    0x000000008003f470 <bogus+     112>: 0x00081450 0x80548e00 0x00081780 0x80548e00
    0x000000008003f480 <bogus+     128>: 0x000818a0 0x80548e00 0x000819d8 0x80548e00
    0x000000008003f490 <bogus+     144>: 0x00a01780 0x80548500 0x00081b40 0x80548e00
    0x000000008003f4a0 <bogus+     160>: 0x00081780 0x80548e00 0x00081780 0x80548e00

    ... ...

    <bochs:3> info idt
    Interrupt Descriptor Table (base=0x000000008003f400, limit=2047):
    IDT[0x00]=32-Bit Interrupt Gate target=0x0008:0x8053f19c, DPL=0
    IDT[0x01]=32-Bit Interrupt Gate target=0x0008:0x8053f314, DPL=0
    IDT[0x02]=Task Gate target=0x0058:0x0000113e, DPL=0
    IDT[0x03]=32-Bit Interrupt Gate target=0x0008:0x8053f6e4, DPL=3
    IDT[0x04]=32-Bit Interrupt Gate target=0x0008:0x8053f864, DPL=3
    IDT[0x05]=32-Bit Interrupt Gate target=0x0008:0x8053f9c0, DPL=0
    IDT[0x06]=32-Bit Interrupt Gate target=0x0008:0x8053fb34, DPL=0

    ... ...

    <bochs:4> info idt 3
    Interrupt Descriptor Table (base=0x000000008003f400, limit=2047):
    IDT[0x03]=32-Bit Interrupt Gate target=0x0008:0x8053f6e4, DPL=3

    <bochs:8> u 0x8053f6e4 0x8053f6ff
    8053f6e4: (                    ): push 0x00000000           ; 6a00
    8053f6e6: (                    ): mov word ptr ss:[esp+2], 0x0000 ; 66c74424020000
    8053f6ed: (                    ): push ebp                  ; 55
    8053f6ee: (                    ): push ebx                  ; 53
    8053f6ef: (                    ): push esi                  ; 56
    8053f6f0: (                    ): push edi                  ; 57
    8053f6f1: (                    ): push fs                   ; 0fa0
    8053f6f3: (                    ): mov ebx, 0x00000030       ; bb30000000
    8053f6f8: (                    ): mov fs, bx                ; 668ee3
    8053f6fb: (                    ): mov ebx, dword ptr fs:0x0 ; 648b1d00000000

     

    2、ring0 内核态的INT 3中断

    进入Console后单步一次,看一下目前运行在什么地方。


    <bochs:3> s
    Next at t=5931168643
    (0) [0x04f0833f] 0008:00000000bf80533f (unk. ctxt): pop edi                   ; 5f

     

    线性地址bf80533f大于80000000应是在内核。

     

    反汇编看一下指令

     

    <bochs:5> u 0xbf80533f 0xbf805350
    bf80533f: (                    ): pop edi                   ; 5f
    bf805340: (                    ): pop esi                   ; 5e
    bf805341: (                    ): leave                     ; c9
    bf805342: (                    ): ret 0x0004                ; c20400
    bf805345: (                    ): nop                       ; 90
    ... ...

     

    看一下bf805342对应物理内存中的数据。(s指令时知道 (0) [0x04f0833f] 0008:00000000bf80533f 的内存映射关系)。

     

    <bochs:8> xp /20b 0x04f08342
    [bochs]:
    0x0000000004f08342 <bogus+       0>: 0xc2 0x04 0x00 0x90 0x90 0x90 0x90 0x90
    0x0000000004f0834a <bogus+       8>: 0x8b 0xff 0x55 0x8b 0xec 0x83 0xec 0x10
    0x0000000004f08352 <bogus+      16>: 0x56 0x8b 0xf1 0x8b

     

    将 bf805342: ret 0x0004 修改为int 3

     

    <bochs:9> setpmem 0x04f08342 1 0xcc

     

    看一下修改的结果

     

    <bochs:11> u 0xbf80533f 0xbf805350
    bf80533f: (                    ): pop edi                   ; 5f
    bf805340: (                    ): pop esi                   ; 5e
    bf805341: (                    ): leave                     ; c9
    bf805342: (                    ): int3                      ; cc
    bf805343: (                    ): add al, 0x00              ; 0400
    ... ...

     

    中断之前的栈
    <bochs:15> x /100w rsp
    [bochs]:
    0x00000000f78807b8 <bogus+       0>: 0xf7880808 0xe13b1008 0x00000000 0x00000000
    0x00000000f78807c8 <bogus+      16>: 0x00000001 0x00000001 0xf7880818 0xbf808ae6
    0x00000000f78807d8 <bogus+      32>: 0xf78807f8 0xe13b1008 0x81f187d8 0x00000001
    0x00000000f78807e8 <bogus+      48>: 0x00000000 0x00000000 0x00000001 0x00000001
    0x00000000f78807f8 <bogus+      64>: 0x00000000 0x00000000 0x00000001 0x00000001
    0x00000000f7880808 <bogus+      80>: 0x820c92a8 0xe13b1008 0x00000001 0xe183c918
    0x00000000f7880818 <bogus+      96>: 0xf788084c 0xbf80d31c 0x81f187d8 0xe13b1008
    0x00000000f7880828 <bogus+     112>: 0x8052890c 0x820c92a8 0xe13b1008 0x00000001
    0x00000000f7880838 <bogus+     128>: 0xf7880894 0xf7880864 0xe18c5008 0x00000000

    ... ...
    单步到执行到int 3

    <bochs:20> s
    Next at t=5931168646
    (0) [0x04f08342] 0008:00000000bf805342 (unk. ctxt): int3                      ; cc

     

    int 3 之前寄存器和栈的情况。

     

    <bochs:21> r
    rax: 0x00000000:f78807c0 rcx: 0x00000000:00000001
    rdx: 0x00000000:00000001 rbx: 0x00000000:e18c5008
    rsp: 0x00000000:f78807d4 rbp: 0x00000000:f7880818
    rsi: 0x00000000:e13b1008 rdi: 0x00000000:f7880808
    r8 : 0x00000000:00000000 r9 : 0x00000000:00000000
    r10: 0x00000000:00000000 r11: 0x00000000:00000000
    r12: 0x00000000:00000000 r13: 0x00000000:00000000
    r14: 0x00000000:00000000 r15: 0x00000000:00000000
    rip: 0x00000000:bf805342
    eflags 0x00000286: id vip vif ac vm rf nt IOPL=0 of df IF tf SF zf af PF cf
    <bochs:22> x /100w rsp
    [bochs]:
    0x00000000f78807d4 <bogus+       0>: 0xbf808ae6 0xf78807f8 0xe13b1008 0x81f187d8
    0x00000000f78807e4 <bogus+      16>: 0x00000001 0x00000000 0x00000000 0x00000001
    0x00000000f78807f4 <bogus+      32>: 0x00000001 0x00000000 0x00000000 0x00000001
    0x00000000f7880804 <bogus+      48>: 0x00000001 0x820c92a8 0xe13b1008 0x00000001
    0x00000000f7880814 <bogus+      64>: 0xe183c918 0xf788084c 0xbf80d31c 0x81f187d8
    0x00000000f7880824 <bogus+      80>: 0xe13b1008 0x8052890c 0x820c92a8 0xe13b1008
    0x00000000f7880834 <bogus+      96>: 0x00000001 0xf7880894 0xf7880864 0xe18c5008
    0x00000000f7880844 <bogus+     112>: 0x00000000 0x00000000 0xf788086c 0xbf81f825
    0x00000000f7880854 <bogus+     128>: 0xe13b1008 0x00000001 0x00000000 0x00000000
    0x00000000f7880864 <bogus+     144>: 0x0006f2e4 0xbf80cf90 0xf7880888 0xbf80d003


    执行int 3,程序跳转到了 ISR 3 8053f6e4
    <bochs:23> s
    Next at t=5931168647
    (0) [0x0053f6e4] 0008:000000008053f6e4 (unk. ctxt): push 0x00000000           ; 6a00

     

    寄存器和栈变化了:


    <bochs:24> r
    rax: 0x00000000:f78807c0 rcx: 0x00000000:00000001
    rdx: 0x00000000:00000001 rbx: 0x00000000:e18c5008
    rsp: 0x00000000:f78807c8 rbp: 0x00000000:f7880818
    rsi: 0x00000000:e13b1008 rdi: 0x00000000:f7880808
    r8 : 0x00000000:00000000 r9 : 0x00000000:00000000
    r10: 0x00000000:00000000 r11: 0x00000000:00000000
    r12: 0x00000000:00000000 r13: 0x00000000:00000000
    r14: 0x00000000:00000000 r15: 0x00000000:00000000
    rip: 0x00000000:8053f6e4
    eflags 0x00000086: id vip vif ac vm rf nt IOPL=0 of df if tf SF zf af PF cf
    <bochs:25> x /100w rsp
    [bochs]:
    0x00000000f78807c8 <bogus+       0>: 0xbf805343 0x00000008 0x00000286 0xbf808ae6
    0x00000000f78807d8 <bogus+      16>: 0xf78807f8 0xe13b1008 0x81f187d8 0x00000001
    0x00000000f78807e8 <bogus+      32>: 0x00000000 0x00000000 0x00000001 0x00000001
    0x00000000f78807f8 <bogus+      48>: 0x00000000 0x00000000 0x00000001 0x00000001
    0x00000000f7880808 <bogus+      64>: 0x820c92a8 0xe13b1008 0x00000001 0xe183c918
    0x00000000f7880818 <bogus+      80>: 0xf788084c 0xbf80d31c 0x81f187d8 0xe13b1008
    ... ...

     

     

    CPU 在执行int 3时入栈的内容为 0xbf805343 0x00000008 0x00000286 共三个dword 其中 0xbf805343是产生异常的指令的下一条指令(3号中断是Trap类型),0x00000008是CS寄存器的值,0x00000286是eflags寄存器的值。
    由于int 3指令也是在ring0执行的,在这个异常过程中没有优先级的切换,所以没有切换栈,入栈的内容只有三个。

    继续执行可以调试观察ISR过程


    <bochs:26> trace on
    Tracing enabled for CPU0
    <bochs:27> s 100
    (0).[5931168647] [0x0053f6e4] 0008:000000008053f6e4 (unk. ctxt): push 0x00000000           ; 6a00
    (0).[5931168648] [0x0053f6e6] 0008:000000008053f6e6 (unk. ctxt): mov word ptr ss:[esp+2], 0x0000 ; 66c74424020000
    (0).[5931168649] [0x0053f6ed] 0008:000000008053f6ed (unk. ctxt): push ebp                  ; 55
    (0).[5931168650] [0x0053f6ee] 0008:000000008053f6ee (unk. ctxt): push ebx                  ; 53
    (0).[5931168651] [0x0053f6ef] 0008:000000008053f6ef (unk. ctxt): push esi                  ; 56
    (0).[5931168652] [0x0053f6f0] 0008:000000008053f6f0 (unk. ctxt): push edi                  ; 57
    (0).[5931168653] [0x0053f6f1] 0008:000000008053f6f1 (unk. ctxt): push fs                   ; 0fa0
    (0).[5931168654] [0x0053f6f3] 0008:000000008053f6f3 (unk. ctxt): mov ebx, 0x00000030       ; bb30000000
    (0).[5931168655] [0x0053f6f8] 0008:000000008053f6f8 (unk. ctxt): mov fs, bx                ; 668ee3
    (0).[5931168656] [0x0053f6fb] 0008:000000008053f6fb (unk. ctxt): mov ebx, dword ptr fs:0x0 ; 648b1d00000000
    (0).[5931168657] [0x0053f702] 0008:000000008053f702 (unk. ctxt): push ebx                  ; 53
    (0).[5931168658] [0x0053f703] 0008:000000008053f703 (unk. ctxt): sub esp, 0x00000004       ; 83ec04
    ... ...

    略。

     

    3、ring3 用户态下的INT 3中断。

     

    下面我们可以在ring 3 状态下产生中断,看看优先级变化时的异常处理。

    重启bochs,启动XP Ctrl-C尝试停在ring 3(如果不是Ring 3 多尝试几次,CPU还是有很大比例的时间运行在ring 3态的)
    如果暂停时eip线性地址小于0x80000000就是在ring 3态下

    在ring 3态下的程序重复上述过程,观察int 3前后的变化。

     

    <bochs:9> r
    rax: 0x00000000:1e7a18d1 rcx: 0x00000000:4d532745
    rdx: 0x00000000:13f91976 rbx: 0x00000000:25dc3f3b
    rsp: 0x00000000:0063efc8 rbp: 0x00000000:ffffffe0
    rsi: 0x00000000:0009f7e0 rdi: 0x00000000:0009f870
    r8 : 0x00000000:00000000 r9 : 0x00000000:00000000
    r10: 0x00000000:00000000 r11: 0x00000000:00000000
    r12: 0x00000000:00000000 r13: 0x00000000:00000000
    r14: 0x00000000:00000000 r15: 0x00000000:00000000
    rip: 0x00000000:68021d3b
    eflags 0x00000202: id vip vif ac vm rf nt IOPL=0 of df IF tf sf zf af pf cf

    <bochs:10> x /100w rsp
    [bochs]:
    0x000000000063efc8 <bogus+       0>: 0x0063efd8 0x00000020 0x0009f7e0 0x0009f7f0
    0x000000000063efd8 <bogus+      16>: 0x0063f004 0x6802145f 0x0009f7f0 0x25dc3f3b
    0x000000000063efe8 <bogus+      32>: 0x0009f760 0x00000020 0x0000003b 0x0009f7e0
    0x000000000063eff8 <bogus+      48>: 0x000a5ef8 0x0009f760 0x0009f6e0 0x0063f05c
    0x000000000063f008 <bogus+      64>: 0x6802192d 0x0009f660 0x0009f7e0 0x000a5ef8
    0x000000000063f018 <bogus+      80>: 0x000a4f04 0x000a500c 0x00000021 0x00000020
    0x000000000063f028 <bogus+      96>: 0x0009f660 0x0009f6e0 0x0009f760 0x0009f7e0
    0x000000000063f038 <bogus+     112>: 0x00000010 0x00000006 0x00000000 0x000001c5
    0x000000000063f048 <bogus+     128>: 0x000001c5 0x00000020 0x000a5ff8 0x00000080
    ... ...

    <bochs:12> sreg
    es:0x0023, dh=0x00cff300, dl=0x0000ffff, valid=1
     Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
    cs:0x001b, dh=0x00cffb00, dl=0x0000ffff, valid=1
     Code segment, base=0x00000000, limit=0xffffffff, Execute/Read, Accessed, 32-bit
    ss:0x0023, dh=0x00cff300, dl=0x0000ffff, valid=7
     Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
    ds:0x0023, dh=0x00cff300, dl=0x0000ffff, valid=7
     Data segment, base=0x00000000, limit=0xffffffff, Read/Write, Accessed
    fs:0x003b, dh=0x7f40f3fd, dl=0xe0000fff, valid=1
     Data segment, base=0x7ffde000, limit=0x00000fff, Read/Write, Accessed
    gs:0x0000, dh=0x00001000, dl=0x00000000, valid=0
    ldtr:0x0000, dh=0x00008200, dl=0x0000ffff, valid=0
    tr:0x0028, dh=0x80008b04, dl=0x200020ab, valid=1
    gdtr:base=0x000000008003f000, limit=0x3ff
    idtr:base=0x000000008003f400, limit=0x7ff

    <bochs:26> s
    Next at t=2257012356
    (0) [0x05488d4a] 001b:0000000068021d4a (unk. ctxt): int3                      ; cc

    <bochs:27> s
    Next at t=2257012357
    (0) [0x0053f6e4] 0008:000000008053f6e4 (unk. ctxt): push 0x00000000           ; 6a00

    <bochs:28> r
    rax: 0x00000000:3edb3b9d rcx: 0x00000000:13f91977
    rdx: 0x00000000:13f91977 rbx: 0x00000000:25dc3f3b
    rsp: 0x00000000:f8149dcc rbp: 0x00000000:ffffffe0
    rsi: 0x00000000:0009f7e0 rdi: 0x00000000:0009f870
    r8 : 0x00000000:00000000 r9 : 0x00000000:00000000
    r10: 0x00000000:00000000 r11: 0x00000000:00000000
    r12: 0x00000000:00000000 r13: 0x00000000:00000000
    r14: 0x00000000:00000000 r15: 0x00000000:00000000
    rip: 0x00000000:8053f6e4
    eflags 0x00000006: id vip vif ac vm rf nt IOPL=0 of df if tf sf zf af PF cf

    <bochs:30> x /100w rsp
    [bochs]:
    0x00000000f8149dcc <bogus+       0>: 0x68021d4b 0x0000001b 0x00000206 0x0063efc8
    0x00000000f8149ddc <bogus+      16>: 0x00000023 0x00000000 0x00000000 0x00000000
    0x00000000f8149dec <bogus+      32>: 0x00000000 0x0000027f 0x00000000 0x00000000
    0x00000000f8149dfc <bogus+      48>: 0x00000000 0x00000000 0x00000000 0x00001f80
    0x00000000f8149e0c <bogus+      64>: 0x0000ffff 0x00000000 0x00000000 0x00000000
    0x00000000f8149e1c <bogus+      80>: 0x00000000 0x00000000 0x8a885d04 0x00000048
    0x00000000f8149e2c <bogus+      96>: 0x00000000 0x77db612a 0x00000002 0x00006148
    0x00000000f8149e3c <bogus+     112>: 0x00000000 0x00000000 0x00000000 0x00006134
    ... ...

     

    在int 3前后的寄存器和栈都存在变化,首先不是同一栈,int 3之前是用户栈,int 3之后,切换到了系统栈。esp的值由0063efc8变为了f8149dcc,由于CONTEXT的切换,寄存器的值都发生了变化。
    在int 3的内核栈中 0x68021d4b 0x0000001b 0x00000206 0x0063efc8 0x00000023 五个值是新压入的,分别是:
    (1)0x68021d4b 产生异常的EIP的后一条指令
    (2)0x0000001b CS
    (3)0x00000206 EFLAGS
    (4)0x0063efc8 ESP
    (5)0x00000023 SS
    与文档中描述相同。

     

    4、TF标志和中断处理

     

    调试器的单步跟踪(比如WinDbg的t命令)一般是通过CPU的TF标志实现的。如果TF标志被置位,那么在每执行一条指令后即产生一个int 1中断。

     

    <bochs:3> r
    rax: 0x00000000:00a18f6a rcx: 0x00000000:ffdffc70
    rdx: 0x00000000:00000000 rbx: 0x00000000:ffdffc70
    rsp: 0x00000000:8054ac34 rbp: 0x00000000:8054ac50
    rsi: 0x00000000:ffdffc50 rdi: 0x00000000:821e7b68
    r8 : 0x00000000:00000000 r9 : 0x00000000:00000000
    r10: 0x00000000:00000000 r11: 0x00000000:00000000
    r12: 0x00000000:00000000 r13: 0x00000000:00000000
    r14: 0x00000000:00000000 r15: 0x00000000:00000000
    rip: 0x00000000:f871d162
    eflags 0x00000246: id vip vif ac vm rf nt IOPL=0 of df IF tf sf ZF af PF cf

     

    eflags的第八位是TF标志位,也就是将eflag and 0x100即可将TF置位

     

    <bochs:38> setpmem 0x006d1d35 4 0x00034668
    <bochs:39> setpmem 0x006d1d39 2 0x6600
    <bochs:40> setpmem 0x006d1d3b 1 0x9d
    <bochs:41> u rip rip+20
    806d1d35: (                    ): push 0x00000346           ; 6846030000
    806d1d3a: (                    ): popf                      ; 669d
    806d1d3c: (                    ): mov ebp, esp              ; 8bec
    806d1d3e: (                    ): mov dword ptr ss:[esp+68], eax ; 89442444
    806d1d42: (                    ): mov dword ptr ss:[esp+64], ecx ; 894c2440
    806d1d46: (                    ): mov dword ptr ss:[esp+60], edx ; 8954243c

     

    由于bochsdbg不支持设置eflag基础器的值,只能设置通用寄存器的值,这就通过修改代码将eflags置位。

    单步运行:


    <bochs:43> s
    Next at t=36941382598
    (0) [0x006d1d3a] 0008:00000000806d1d3a (unk. ctxt): popf                      ; 669d
    <bochs:44> s
    Next at t=36941382599
    (0) [0x006d1d3c] 0008:00000000806d1d3c (unk. ctxt): mov ebp, esp              ; 8bec
    <bochs:46> s
    Next at t=36941382600
    (0) [0x006d1d3e] 0008:00000000806d1d3e (unk. ctxt): mov dword ptr ss:[esp+68], eax ; 89442444


    TF置位是成功了的:
    <bochs:47> r
    rax: 0x00000000:00a18f6a rcx: 0x00000000:ffdffc70
    rdx: 0x00000000:00000000 rbx: 0x00000000:ffdffc70
    rsp: 0x00000000:8054ac22 rbp: 0x00000000:8054ac22
    rsi: 0x00000000:ffdffc50 rdi: 0x00000000:821e7b68
    r8 : 0x00000000:00000000 r9 : 0x00000000:00000000
    r10: 0x00000000:00000000 r11: 0x00000000:00000000
    r12: 0x00000000:00000000 r13: 0x00000000:00000000
    r14: 0x00000000:00000000 r15: 0x00000000:00000000
    rip: 0x00000000:806d1d3e
    eflags 0x00000346: id vip vif ac vm rf nt IOPL=0 of df IF TF sf ZF af PF cf
    <bochs:48> s
    Next at t=36941382601
    (0) [0x0053f314] 0008:000000008053f314 (unk. ctxt): push 0x00000000           ; 6a00

     

    已经进入ISR 1
    (这里不知为是么置位了TF后单步了两条指令才跳入ISR 1,是bochs的实现原理问题?存疑在此。)

     

    <bochs:49> info idt
    Interrupt Descriptor Table (base=0x000000008003f400, limit=2047):
    IDT[0x00]=32-Bit Interrupt Gate target=0x0008:0x8053f19c, DPL=0
    IDT[0x01]=32-Bit Interrupt Gate target=0x0008:0x8053f314, DPL=0
    ... ...

    展开全文
  • 剪切时中断文件不见了是很常见的数据恢复故障。剪切时中断文件不见了如何寻回?接下来我们还需要了解下具体如何恢复剪切时中断文件不见了的数据,具体请看正文了解。 剪切时中断文件不见了怎样恢复? ...

        剪切时中断,文件不见了是很常见的数据恢复故障。剪切时中断,文件不见了如何寻回?接下来我们还需要了解下具体如何恢复剪切时中断,文件不见了的数据,具体请看正文了解。

    剪切时中断,文件不见了怎样恢复?

    工具/软件:光明数据恢复软件

    步骤1:先下载并解压程序打开后,在软件中选中需要恢复的盘,然后点《开始恢复》按钮。

    剪切时中断,文件不见了怎样恢复?

    步骤2:等程序扫描完成,平均需要几分钟时间。

    剪切时中断,文件不见了怎样恢复?

    步骤3:软件扫描到数据后,都在《原来的文件夹》和《找不到路径的文件》里面。

    剪切时中断,文件不见了怎样恢复?

    步骤4:勾选所有需要恢复的数据,右击选择《复制选中的文件》,程序会将勾选的文件COPY出来。

    剪切时中断,文件不见了怎样恢复?

    步骤5:最后一步只需坐等程序将数据COPY完成就可以了 。

    剪切时中断,文件不见了怎样恢复?

    注意事项1:想要恢复剪切时中断,文件不见了需要注意,一定注意不要往被剪切文件所在的盘存入新的文件。

    注意事项2:剪切时中断,文件不见了恢复出来的数据需要暂时保存到其它盘里。

    展开全文
  • 版权声明:本文为博主原创文章,未经博主允许,欢迎随意转载,标好作者+原文地址...1、使用标准I/O实现文件复制; 2、使用目录检索寻找文件夹,并递归复制文件夹。 代码: #include&lt;stdio.h&gt; #in...
  • 今天本来不想写这种小问题,可是...1. VM虚拟机不能和主机互相复制文件 2. 剪切板共享也失效了对于第一个问题我还可以忍受,但是本人有强迫症啊,有需要上网百度或者CSDN的必须复制到win8 里搞定啊,hold不住啊,曾经
  • 移动硬盘上存有一个VM虚拟机,运行之,往VM虚拟机里复制一个大约500MB的文件夹,复制过程中,移动硬盘掉电自动重启了,运行的VM虚拟机貌似未受到掉电重启的影响,复制继续进行。   但是,复制完成后,在VM虚拟...
  • linux中断响应和处理过程分析

    千次阅读 2012-06-01 17:28:30
    linux中断响应和处理过程: 首先中断属于异常的一种。异常,就是可以打断CPU正常运行流程的一些事情,比如说外部中断,未定义的指定,试图修改只读数据,执行SWI指定(software interrupt instructin,软件中断指令...
  • Linux scp 设置nohup后台运行 Linux scp 设置nohup后台运行 ...5.测试会话中断,任务继续运行不受影响 1.正常执行scp命令 从机器一拷贝一个文件夹到另一台机器: scp -r /u01/media/Disk1/ 192.168.1.31:/...
  • Github下载慢和下载过程中断等情况的解决方案

    万次阅读 多人点赞 2019-05-15 16:08:32
    尝试了修改hosts文件的方式,更换了延迟最低的域名也没啥用(难道我姿势不对?) 正确姿势: 1.复制你需要下载的git链接,如https://github.com/cayden/facesample.git 2.打开码云(当然不是福报)...
  • ARM Linux外部中断处理过程

    千次阅读 2008-08-04 10:39:00
    ARM Linux外部中断处理过程http://www.linuxforum.net/forum/showflat.php?Cat=&Board=linuxK&Number=652682&page=12&view=collapsed&sb=7&o=all&fpart=1&vc=1作者:muxiaowei 整理:Nathan.Yu 最近在学习arm linux...
  •  //从设备复制文件到D:盘 ,true 默示重写,false 不重写, } 下面介绍应用案例,便利大师一路进修: //pc->pda public static bool DataToTermial(string LocalFile, string RemoteFile) ...
  • 最后使用NSIS对已经编译完的可执行程序打成的安装包在安装过程中会报libgcc_s_dw2-1.dll缺失和libstdc++-6.dll调用错误问题,请到mingw目录下找到这两个同名文件复制/替换过来。   2) java部分 (省略) ...
  • 1. VM虚拟机不能和主机互相复制文件  2. 剪切板共享也失效了 分析问题:  1. 其实以上问题是同一个问题,当不能复制文件的时候,剪切板也就失效了 2. 是不是因为某个设置,让vmware tools失效 3. 是不是...
  • 原语 操作系统或计算机网络用语范畴。...primitive or atomic action 是由若干个机器指令构成的完成某种特定功能的一段程序,具有不可分割性·即原语的执行必须是连续的,在执行过程中不允许被中断。 ...
  • ——USB口拷贝文件中断/电池在低温时无输出 本文主要叙述如何发现计算机故障,以及如何呈现。同时,也给网友传达如何正确与厂家交涉。 本电脑在2018年3月14日左右购买,在2018年9日前,给亲人使用,他使用期间只...
  • VC 移动,复制,删除文件(SHFileOperation)

    千次阅读 2011-08-10 14:52:44
    (转载于:http://hi.baidu.com/%B4%E7%B2%DD%D0%C4_/blog/item/e3a8200a28f6ea3ab1351d38.html)总结一下SHFileOperation的用法,希望对大家有用//删除文件或者文件夹bool DeleteFil
  • 复制分发过程存在异常不在叙述,参考上述说明,在此着重说明如何处理服务器上数据库日志爆增。   现象描述:  首先要对现有游戏数据库大小要有基本了解;另外一个判断依据是一般情况下数据库主文件大小...
  • 一、移动硬盘在mac和windows兼容使用 Windows下打开我的电脑 找到移动硬盘 右键格式化 选择exFAT 执行就可以了...二、复制文件时突然断开导致不能操作复制失败的文件或者导致文件无法使用 试试修复操作 1、单击“开始
  • 【UCOSIII】UCOSIII的中断和时间管理

    万次阅读 2018-06-28 19:36:03
    在STM32是支持中断的,中断是一个硬件机制,主要用来向CPU通知一个异步事件发生了,这时CPU就会将当前CPU寄存器值入栈,然后转而执行中断服务程序,在CPU执行中断服务程序的时候有可能有更高优先级的任务就绪,...
  • windows 8 中断处理界面改进

    千次阅读 2012-10-31 11:12:29
    在 Win 8 复制过程中如果遇到文件无法找到、文件正在使用等中断问题后,系统会在完成所能完成的全部工作后按顺序显示这些中断问题。另外如果还在复制过程中系统就进行了睡眠或休眠状态后复制过程自动暂停,当...
  • linux可执行文件的加载过程

    千次阅读 2013-07-16 18:40:49
    本篇文章简要介绍linux可执行文件的进程创建与加载的过程。linux在创建进程时,采用写时复制(copy on write)技术,在加载进程时,采用按需加载机制。 写时复制技术 父进程通过fork()系统调用创建子进程,子进程...
  • 中断处理

    千次阅读 2012-05-07 20:29:02
    对于中断和异常的定义在ULK的第4章中给予了非常明确的定义。中断通常分为同步中断和异步中断: 同步中断是党指令执行时由CPU控制单元产生的,之所以称为同步,是因为只有在一条指令中止执行后CPU才会发出中断...
  • UCOSIII 中断

    千次阅读 2016-12-28 23:26:20
    1.UCOSIII 中断处理过程 UCOSIII 是支持中断嵌套的, 既高优先级的中断可以打断低优先级的中断,在 UCOSIII 使用 OSIntNestingCtr 来记录中断嵌套次数,最大支持 250 级的中断嵌套,每进入一次中断服务...
  • BIOS中断调用

    千次阅读 2010-04-21 21:38:00
    BIOS和DOS中断大全DOS中断:1、字符功能调用类(Character-Oriented Function)01H、07H和08H —从标准输入设备输入字符02H —字符输出03H —辅助设备的输入04H —辅助设备的输出05H —打印输出06H —控制台输入/输出...
  • 数据库在运行期间,由于检查点发生等原因会不断的更新控制文件,同时数据库在关闭和重启过程中都会更新控制文件的内容,但是数据库服务器突 然的掉电,会导致当前的db信息无法适时更新到控制文件中,再次启动数据库...
  • 个 linux 主机间复制文件;    命令基本格式:   scp [可选参数] file_source file_target    ==================  从 本地 复制到 远程  ==================  * 复制...
  • 定时器中断

    千次阅读 2010-03-07 17:54:00
    走到这里,大家肯定对Linux的中断处理有概念了,下面我们通过一个具体的实例,来了解Linux内核处理中断的全过程,那就是定时器中断。在详细分析这个过程之前,我们把Linux时间管理的概念先缕一缕。 在当前的80x86...
  • Linux硬件中断处理

    千次阅读 2014-02-19 15:43:02
    今天看了0.11核的关于硬件中断... I386体系结构CPU有两种中断,硬中断和软中断,硬中断是外部硬件产生的,软中断是程序的某条指令或者程序对标志寄存器某个标志的设置而产生的,与硬件电路无关。无论是硬件
  • ARM中断

    千次阅读 2011-10-04 21:37:46
    S3C2440系统中断 分类: ARM体系结构 2011-06-20 14:17 196人阅读评论(0) 收藏举报 ...CPU和外设构成了计算机系统,CPU和外设之间通过总线进行连接,用于数据通信和控制,CPU管理监视计算机系统所有硬件

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,967
精华内容 37,986
关键字:

复制文件过程中中断