博客园_老李的地下室

Cosmos动手练习（基于里程碑2的代码）--.net/C#开源操作系统学习系列十

2012-03-05T04:33:00Z

直接开始吧，在KenelTest文件夹下面添加一个自己的项目，这里我的项目是PCIDeviceEnumerator，列出当前自己机子上的PCI设备的VendorID和DeviceID以及设备类型

敲入如下代码：

using System;
using System.Collections.Generic;
using System.Text;
using Cosmos.Build;
using Cosmos.Hardware.PC;

namespace PCIDeviceEnumerator
{
class Program
{

        //这个是项目的启动函数
        [STAThread]
        static void Main(string[] args)
        {

            //在里程碑2中，COSMOS项目还需要自己调用编译器对自己进行编译，生成最后的ISO，并调用模拟器启动我们自己的操作系统
            var xbuilder = new Cosmos.Build.Windows.Builder();
            xbuilder.Build();
        }

//这个是操作系统的入口函数，操作系统就从这里开始进入我们的代码的

        public static void Init()
        {
            Cosmos.Kernel.Boot.Default();//操作系统初始化，详细解释可以参看下小弟之前的拙文
            var DeviceCollect = Cosmos.Hardware.PC.Bus.PCIBus.Devices;//获取机子上所有的PCI设备

            //遍历设备，并列出VendorID和DeviceID以及设备类型
            foreach (var device in DeviceCollect)
            {
                Console.WriteLine(device.VendorID + " | " + device.DeviceID + " | "+ device.GetClassInfo());
            }
        }
    }
}

以下是这次动手练习中遇到的一些问题下面一个个解释：

上图：可以看到代码中红色的部分，对于项目的启动函数需要加上STAThread属性，由错误提示可知，一些UI组件需要STA，这里摘录一段网上对STAThread的解释

——————————————————————————————————————————————————

[STAThread]
是一种线程模型，用在程序的入口方法上（在C#和VB.NET里是Main()方法），来指定当前线程的ApartmentState 是STA。用在其他方法上不产生影响。在aspx页面上可以使用AspCompat = "true" 来达到同样的效果。这个属性只在 Com Interop 有用，如果全部是 managed code 则无用。简单的说法:[STAThread]指示应用程序的默认线程模型是单线程单元 (STA)。启动线程模型可设置为单线程单元或多线程单元。如果未对其进行设置，则该线程不被初始化。也就是说如果你用的.NET Framework，并且没有使用COM Interop，一般不需要这个Attribute。其它的还有MTA（多线程套间）、Free Thread（自由线程）。

——————————————————————————————————————————————————

对于这个的解释，我们先看一下下面的这个UI界面，有项目类型可知这是一个WPF的项目，个人理解，由于项目的界面调用到了一些COM的组件来进行绘制或者需要和某些COM组件来进行交互，所以我们自己创建的项目的启动函数里面需要加上STAThread属性。

现在看下图的这个错误，提示在XXXXXX目录下找不到XXXXX.dll文件，我们在结合上图，留意到“Current build path is:“这个属性，这里指定了在编译过程中需要用到的程序集的路径，现在的这个是在编译器启动时的默认值，我们需要把它修改成我们需要的值（注：目前这个路径只支持英文名）

我们在启动编译器的界面项目中可以找到如下代码，位于Cosmos.Build.Windows项目的BuildRegister.cs文件中。

public static class BuildRegistry
    {
        public static void Write(string key, string value)
        {
            RegistryKey xKey = Registry.CurrentUser.CreateSubKey(@"Software\Cosmos");
            xKey.SetValue(key, value);
        }

        public static string Read(string key)
        {
            try
            {
                RegistryKey xKey = Registry.CurrentUser.OpenSubKey(@"Software\Cosmos");
                return (string)xKey.GetValue(key);
            }
            catch
            {
                return null;
            }
        }
    }

这里在注册表中写入了一条记录，其实这就是Current build path is:属性的默认值，找到该记录把它的值改成我们项目生成的地址，通常我们的项目生成之后所在的目录一般为：XXXXXX\bin\debug\

这下我们就可以通过编译了，操作系统启动之后会列出本机上的所有PCI设备的VendorID和DeviceID以及设备类型，由下图我们可以知道，小弟的机子上有：

一个PCI桥（用来在CPU和PCI之间进行通信）

还有一个PCI桥（用来在PCI和ISA之间进行通信--不知道ISA的朋友百度一下吧，一种比较古老的总线）

一个IDE硬盘

还是一个PCI桥（但是小弟做的这个操作系统无法识别，个人觉得应该是用来在PCI和USB之间进行通信的）

一个VGA显示卡（就是显卡）

一个以太网卡

好了，练习完毕，

最后还是广告时间，大家懂的：

欢迎大家经常光顾小弟的淘宝充值店：http://hundre.taobao.com/

好了，多谢大家捧场

本文链接

Cosmos的里程碑2（Mile Stone 2）之浅尝PCI总线、设备编程--.net/C#开源操作系统学习系列九

2012-01-16T00:22:00Z

书接上文（这两篇文章之间隔得有点久，唉，最近工作比较忙，加上基础不够，学习PCI知识花了不少时间），话说在上一篇中，我们直接使用系统提供的类来获取了RTL8139网卡的类，这一篇我们就来一起学习COSMOS是如何找到网卡芯片并实例化相应的类的。

直接来到RTL8139Test这个类下，定位到语句List<Cosmos.Driver.RTL8139.RTL8139> nics = Cosmos.Driver.RTL8139.RTL8139.FindRTL8139Devices();上一篇中我们直接跳过了这个语句，这次就进入到FindRTL8139Devices()方法里面，看看这个方法是如何找到PCI上的RTL8139网卡的。进入到方法的代码里面

public static List<RTL8139> FindRTL8139Devices()
        {
            List<RTL8139> found = new List<RTL8139>();

            foreach (PCIDevice device in Cosmos.Hardware.PC.Bus.PCIBus.Devices)
            {
                if (device.VendorID == 0x10EC && device.DeviceID == 0x8139)
                    found.Add(new RTL8139(device));
            }

            return found;
        }

可以看到该方法是通过遍历PCI总线上的所有设备然后比较设备的VendorID和DeviceID来确认遍历到的设备是不是我们要找的RTL8139网卡。这里的VendorID和DeviceID都是PCI规范中规定厂家必须要实现的参数（除非哪家厂子不想让自己的产品卖不出去），其中VendorID是由PCI SIG（貌似是叫做PCI标准组织）规定的，可以在http://www.pcisig.com/ 这个网站查找到所有获得该组织授权的生产产商的ID，而DeviceID是由生产厂商自己规定的一个编号，用来识别自己生产的不同产品。这里的10EC就是realtek公司的编号，8139就是这家公司生产的网卡芯片的编号。在这里再附上PCI 3.0标准的文档中文版英文原版（个人觉得中文版翻译得实在不咋地，英文过得去的强烈图推荐直接看英文版），文档其中对我们编程有用的只有第六章的内容，其他的都可以忽略。

好接下来我们再来学习PCI总线类（PCIBus）是如何获得所有PCI设备的，首先我们准备点预备知识，通过资料我们可以找到下面一幅图（左边的为中文文档的翻译，右边的是英文原版，SubsystemID和Subsystem Vendor ID居然都被忽略掉了，所谓的“信达雅”……唉，不吐槽了）：

这里加上点个人见解，Status应译为状态寄存器，Command应译为命令寄存器，DeviceID是设备识别代码（就少两个字，少引两个字会死人吗）

这是Header Type为00H的PCI设备的，配置空间中的头部区域中各个寄存器在内存中的排列规范（这里的寄存器已不是传统意义上的CPU中的寄存器了，而是内容中从特定位置右特定长度的一段内存），关于这些寄存器字段的详细说明文档中都有，在此就不献丑了。要说的是“配置空间”这个说法个人感觉应该是针对硬件产商来说的，应该是硬件厂商在生产他们自己的PCI设备，在设备出厂前就应该完成对这部分空间的配置，而我们程序员只需从内容中读取出这些信息来辅助我们编程实现功能即可。预备知识到此结束，下面来看下PCIBus类中的代码（代码比较长，就把分析写在代买的注释里面吧，为节省篇幅，也删除了部分不必要的代码和注释）：

public class PCIBus : Cosmos.Hardware.Bus.PCIBus
    {
        //先是Devices该属性，可以看到在上一层的代码中，RTL81139的驱动程序类就是通过遍历这个集合来确定它要找的设备的
        //该集合直接势力化了一个PCIDevice设备的数组，我们看到这里初始化的时候这个数组只有0个元素，这样的话怎么可能能找得出设备呢？
        /*现在我们倒回去一下，还记得我们选择的启动项目的program.cs文件里面的第一条语句吗：Cosmos.Kernel.Boot.Default();在Default()方法里面调用了Cosmos.Hardware.PC.Global.Init();方法，而该方法有调用了方法HW.PC.Bus.PCIBus.Init();啊哈，这个就是我们这个类的初始化方法。这样，在我们获取Devcies数据之前，已经对数组完成了新的初始化，把所有的PCI设备都添加进去了。好，接下来我们直接到Init()方法里面看个究竟*/
        public static PCIDevice[] Devices = new PCIDevice[0];
        private static bool haveEnumerated = false;
        public static PCIDevice GetPCIDevice(byte bus, byte slot, byte function)
        {
            if (!haveEnumerated)
                Init();

            foreach (PCIDevice dev in PCIBus.Devices)
            {
                if (dev.Bus == bus &&
                    dev.Slot == slot &&
                    dev.Function == function)
                    return dev;
            }
            return null;
        }
        //该方法直接调用EnumerateBus(byte Bus, ref List<PCIDevice> Devices)方法来查找系统中的PCI设备，此处ref Bus参数不知是什么东西，求解?
        public static void Init()
        {
            //Console.WriteLine("Cosmos.Hardware.PC.Bus.Init()");
            List<PCIDevice> devices = new List<PCIDevice>();
            //Console.WriteLine("- created generic");
            EnumerateBus(0, ref devices);
            Devices = devices.ToArray();

            haveEnumerated = true;
        }
        //遍历本机上的所有PCI设备，遍历到的设备存储到参数Devices中
        private static void EnumerateBus(byte Bus, ref List<PCIDevice> Devices)
        {
            for (byte xSlot = 0; xSlot < 32; xSlot++)
            {
                byte xMaxFunctions = 1;
                for (byte xFunction = 0; xFunction < xMaxFunctions; xFunction++)
                {
                    //这里先初始化一个普通的PCI设备，然后再通过读取设备中的参数来确定是不是我们想要的设备
                    /*求高人指点此处Bus,xSlot,xFunction的意思，xSlot个人认为应该是插槽的数量，由于是32位的系统，所以是可以有32个插槽，然后逐个遍历，但是其他两个参数的话……*/
                    //以下部分请参考下面的关于PCIDevice类的学习
                    PCIDevice xPCIDevice = new PCIDeviceNormal(Bus, xSlot, xFunction);
                    if (xPCIDevice.DeviceExists)
                    {
                        if (xPCIDevice.HeaderType == 2 /* PCIHeaderType.Cardbus */)
                            xPCIDevice = new PCIDeviceCardBus(Bus, xSlot, xFunction);

                        if (xPCIDevice.HeaderType == 1 /* PCIHeaderType.Bridge */)
                            xPCIDevice = new PCIDeviceBridge(Bus, xSlot, xFunction);

                        Devices.Add(xPCIDevice);

                        if (xPCIDevice is PCIDeviceBridge)
                            EnumerateBus(((PCIDeviceBridge)xPCIDevice).SecondaryBus, ref Devices);

                        if (xPCIDevice.IsMultiFunction)
                            xMaxFunctions = 8;
                    }
                }
            }
        }
        //貌似是调试用的一段代码，此次分析中没用到，也忽略之
        public static void DebugLSPCI()
        {……}
        }
    }

呼，终于能从代买里面出来一会了，从上面的代码中我们新发现了三个类PCIDevice, PCIDeviceNormal, PCIDeviceBridge。后面两个其实都是从PCIDevice中继承而来，基本没有自己的代码，主要看一下PCIDevice这个类（好长，看得我头晕晕眼花花，同样删除了不分不必要的代码和注释）：

/*由构造函数得到，在这里PCI设备的创建就是配置了几个参数，仔细阅读代码之后可以发现，这里基本上都是从PCI设备中读取设备的参数，这可能是因为这个为PCI设备通用的抽象类，所实现的还只是些PCI设备通用的功能，例如读取所有PCI设备都必须实现的一些参数。*/

public abstract class PCIDevice
    {
        public abstract int NumberOfBaseAddresses();
       private static string[] classtext = new string[]
       {
        "pre pci 2.0",        // 00
        "disk",        // 01
        "network",        // 02
        "display",        // 03
        "multimedia",    // 04
        "memory",        // 05
        "bridge",        // 06
        "communication",    // 07
        "system peripheral",// 08
        "input",        // 09
        "docking station",    // 0A
        "CPU",        // 0B
        "serial bus",    // 0C
       };

        private static string[][] subclasstext = new string[][]
        {
            new string[] { "VGA Device", "non VGA device"},
            new string[] { "SCSI" ,"IDE" , "floppy","IPI","RAID", "other" },
            new string[] { "Ethernet", "TokenRing", "FDDI" , "ATM" , "other" },
            new string[] { "VGA", "SuperVGA","XGA", "other"},
            new string[] { "video" ,"audio", "other"},
            new string[] { "RAM", "Flash memory" , "other"},
            new string[] { "CPU/PCI" ,"PCI/ISA" , "PCI/EISA" , "PCI/MCA","PCI/PCI" , "PCI/PCMCIA", "PCI/NuBus", "PCI/CardBus", "other"},
            new string[] { "serial", "parallel", "other"},
            new string[] { "PIC", "DMAC" , "timer" ,"RTC", "other"},
            new string[] { "keyboard","digitizer","mouse", "other" },
            new string[] { "generic" , "other" },
            new string[] { "386", "486","Pentium" , "P6" ,"Alpha","coproc","other" },
            new string[] { "Firewire", "ACCESS.bus" , "SSA", "USB" ,"Fiber Channel" , "other"},
        };

        /*获取设备的分类信息，从代码中可以看到使用了ClassCode, SubClass这两个字段，参考这两个字段的代码可以发现都是使用ReadX方法把数据从配置空间中读取出来，这里的ReadX方法放到下面再说*/
        public string GetClassInfo()
        {
            int cc = ClassCode;
            int sc = SubClass;

            if (cc >= classtext.Length)
                return "unknown class (" + cc.ToString() + ") / subclass (" + sc.ToString() + ")";

            if (sc >= subclasstext[cc].Length)
                return String.Concat(classtext[cc], " / unknown subclass (", sc.ToString(), ")");

            return String.Concat( classtext[cc] , " / " , subclasstext[cc][sc]);
        }
        //PCI 3.0规范中定义的一些PCI设备使用的参数
        private const UInt32 PCI_BASE_ADDRESS_SPACE = 0x01;    /* 0 = memory, 1 = I/O */
        private const UInt32 PCI_BASE_ADDRESS_SPACE_IO = 0x01;
        private const UInt32 PCI_BASE_ADDRESS_SPACE_MEMORY = 0x00;
        private const UInt32 PCI_BASE_ADDRESS_MEM_TYPE_MASK = 0x06;
        private const UInt32 PCI_BASE_ADDRESS_MEM_TYPE_32 = 0x00;   /* 32 bit address */
        private const UInt32 PCI_BASE_ADDRESS_MEM_TYPE_1M = 0x02;   /* Below 1M [obsolete] */
        private const UInt32 PCI_BASE_ADDRESS_MEM_TYPE_64 = 0x04;   /* 64 bit address */
        private const UInt32 PCI_BASE_ADDRESS_MEM_PREFETCH = 0x08;  /* prefetchable? */
        private const UInt32 PCI_BASE_ADDRESS_MEM_MASK = 0xfffffff0;
        private const UInt32 PCI_BASE_ADDRESS_IO_MASK = 0xfffffffc;
        //构造函数，给一些参数赋值
        protected PCIDevice(byte bus, byte slot, byte function)
        {
            this.Bus = bus;
            this.Slot = slot;
            this.Function = function;
        }

        private bool NeedsIO = false;
        private bool NeedsMemory = false;
        private bool _NeedsLayingout = true;
        //IO布局，惭愧，真不知道这段是用来干什么的，还好分析的代码里面好像没有对该函数进行的调用
        private void LayoutIO()
        {
            //Console.WriteLine("Checking AdressSpaces of PCI(" + Bus + ", " + Slot + ", " + Function + ")");
            IOMaps = new AddressSpace[NumberOfBaseAddresses()];
            for (byte i = 0; i < NumberOfBaseAddresses(); i++)
            {
                UInt32 address = GetBaseAddress(i);
                SetBaseAddress(i, 0xffffffff);
                UInt32 flags = GetBaseAddress(i);
                SetBaseAddress(i, address);
                if (address == 0)
                {
                    //Console.WriteLine("register " + i + " - none " + PCIBus.ToHex(flags,8));
                    IOMaps[i] = null;
                }
                else if ((address & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_MEMORY)
                {
                    UInt32 size = ~(PCI_BASE_ADDRESS_MEM_MASK & flags)+1;
                    IOMaps[i] = new MemoryAddressSpace(address, size);
                    //Console.WriteLine("register " + i + " - " + size + "b mem");
                    NeedsIO = true;
                }
                else if ((address & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
                {
                    UInt32 size = ~(PCI_BASE_ADDRESS_IO_MASK & flags) +1;
                    IOMaps[i] = new IOAddressSpace(address, size);
                    //Console.WriteLine("register " + i + " - " + size + "b io");
                    NeedsMemory = true;
                }
            }
            _NeedsLayingout = false;
        }

        private AddressSpace[] IOMaps;
        public AddressSpace GetAddressSpace(byte index)
        {
            if (index < 0 || index >= NumberOfBaseAddresses())
                throw new ArgumentOutOfRangeException("index");

            if (_NeedsLayingout)
                LayoutIO();
            return IOMaps[index];
        }

        public byte Bus { get; private set; }
        public byte Slot { get; private set; }
        public byte Function { get; private set; }
        public bool DeviceExists { get { return VendorID != 0xFFFF && VendorID != 0x0; } }
        public bool IsMultiFunction { get { return (Read8(0x0e) & 0xf0) != 0; } }

        //以下为各种字段的定义，可以看到读取的地址参数都和上面两张布局截图中的地址编号相对应
        public UInt32 VendorID { get { return Read16(0x0); } }
        public UInt16 DeviceID { get { return Read16(0x2); } }
        public PCICommand Command { get { return (PCICommand)Read16(0x4); } set { Write16(0x4, (ushort)value); } }
        public PCIStatus Status { get { return (PCIStatus)Read16(0x6); } set { Write16(0x6, (ushort)value); } }
        public byte RevisionID { get { return Read8(0x8); } }
        public byte ProgIF { get { return Read8(0x9); } }
        public byte SubClass { get { return Read8(0xa); } }
        public byte ClassCode { get { return Read8(0xb); } }
        public byte CacheLineSize { get { return Read8(0x0c); } set { Write8(0x0c, value); } }
        public byte LatencyTimer { get { return Read8(0x0d); } set { Write8(0x0d, value); } }
        public byte HeaderType { get { return (byte)(Read8(0x0e) & 0xf); } }
        public PCIBist Bist { get { return (PCIBist)Read8(0x0f); } set { Write8(0x0f, (byte)value); } }
        public UInt32 GetBaseAddress(byte index)
        {
            return Read32((byte)(0x10 + index * 4));
        }
        public void SetBaseAddress(byte index, UInt32 value)
        {
            Write32((byte)(0x10 + index *4), value);
        }
        public UInt32 BaseAddress0 { get { return Read32(0x10); } set { Write32(0x10, value); } }
        public UInt32 BaseAddress1 { get { return Read32(0x14); } set { Write32(0x14, value); } }
        public byte InterruptLine { get { return Read8(0x3c); } set { Write8(0x3c, value); } }
        public byte InterruptPin { get { return Read8(0x3d); } set { Write8(0x3d, value); } }
        public byte MinGNT { get { return Read8(0x3e); } set { Write8(0x3e, value); } }
        public byte MaxLAT { get { return Read8(0x3f); } set { Write8(0x3f, value); } }
        //访问PCI配置空间可通过两个访问寄存器，CONFIG_ADDRESS寄存器和CONFIG_DATA寄存器。这两个寄存器在PC中分别对应着CF8h和CFCh端口
        protected const ushort ConfigAddr = 0xCF8;
        protected const ushort ConfigData = 0xCFC;

        public void DisableDevice()
        {
            Command = Command & (~PCICommand.IO & ~PCICommand.Master & PCICommand.Memort);
        }
        public void EnableDevice()
        {
            Command = Command & ((NeedsIO ? PCICommand.IO : 0) & PCICommand.Master & (NeedsMemory ? PCICommand.Memort : 0));
        }
        private UInt32 GetAddress(byte aRegister)
        {
            return (UInt32)(
                // Bits 23-16
                ((UInt32)Bus << 16)
                // Bits 15-11
                | (((UInt32)Slot & 0x1F) << 11)
                // Bits 10-8
                | (((UInt32)Function & 0x07) << 8)
                // Bits 7-0
                | ((UInt32)aRegister & 0xFF)
                // Enable bit - must be set
                | 0x80000000);
        }

        public UInt32 Read32(byte aRegister)
        {
            CPUBus.Write32(ConfigAddr, GetAddress(aRegister));
            return CPUBus.Read32(ConfigData);
        }

        //........
        /*此处为节省篇幅，省略源码中的一些各种ReadX和WriteX方法,其实这些函数都和这两个类似，只是读取和写入的位数不一样而已
        public void Write8(byte aRegister, byte value)
        {
            CPUBus.Write32(ConfigAddr, GetAddress(aRegister));
            CPUBus.Write8(ConfigData, value);
        }
    }

终于从PCIDevice中出来了，下面重点说一下Read8, Read32, Write8, Write32这几个函数，这里先来说说如何对PCI的配置空间进行访问，因为这几个函数都是用来读写配置空间的。访问PCI配置空间可通过两个访问寄存器，CONFIG_ADDRESS寄存器和CONFIG_DATA寄存器。这两个寄存器在PC中分别对应着CF8h和CFCh端口，并且是32位端口，即读写要用的32为IN和OUT汇编指令。当然Cosmos已经对汇编指令进行了封装，我们就不需要直接对汇编指令进行操作了，直接调用即可。

从源代码中也可以看到对PCI设备中各种寄存器的访问都是通过ReadX和WriteX方法配合完成的，跟进这两个方法之后，我们可以看到代码：

public class CPUBus : Cosmos.Hardware.Bus.CPUBus {
        // all plugs
        public static void Write8(UInt16 aPort, byte aData) { }
        public static void Write16(UInt16 aPort, UInt16 aData) { }
        public static void Write32(UInt16 aPort, UInt32 aData) { }

        public static byte Read8(UInt16 aPort) { return 0; }
        public static UInt16 Read16(UInt16 aPort) { return 0; }
        public static UInt32 Read32(UInt16 aPort) { return 0; }
    }

可以看到没有任何实现代码，不过请注意注释中的//all plugs，这里所有的操作都被plug了（关于plug，请参考本系列六，嘿嘿），由编译器完成实际的代码的生成操作。这样我们就明白了PCIBus这个类是怎么读出PCI设备中的VendorID和DeviceID的了。

好了，到这里这次对PCI粗浅的学习就算完了，下一篇文章中将会使用这次学习到的内容实际动手做个小程序，来遍历并显示小弟自己机子上的PCI设备的VendorID和DeviceID，欢迎大家继续期待。哇哈哈哈，当然这次有什么说得不对的地方也欢迎大家指出来

最后是广告时间，大家懂得……

欢迎大家经常光顾小弟的淘宝充值店：http://hundre.taobao.com/

最后是多谢大家捧场

本文链接

Cosmos的里程碑2（Mile Stone 2）之RTL8139网卡芯片编程---- .net/C#开源操作系统学习系列八

2011-09-28T09:50:00Z

下载的源代码包为cosomos-16025.zip

从发布的时间上看，MS2和MS1的时间只差了2个月，比较明显的变化有在编译操作系统是出来了一个图形化的选择界面同时内核文件夹里面多了两个项目RL8139驱动和文件系统，其他的基本没啥大变化。

接下来我们启动MS2看看，把启动项目设为FrodeTest，只有这个项目里面使用到了RL8139驱动，其他的项目和MS1中的基本一样。

先看一下Prgrom.cs里面的源代码（去掉了原文中的一些无用的注释）：

using System;
using Cosmos.Build.Windows;

namespace FrodeTest
{
    class Program
    {
        #region Cosmos Builder logic
        // Most users wont touch this. This will call the Cosmos Build tool
        [STAThread]
        static void Main(string[] args)
        {
            var xBuilder = new Builder();
            xBuilder.Build();
        }
        #endregion

        // Main entry point of the kernel
        //This is the playground for Frode "Scalpel" Lillerud.
        public static void Init()
        {
            Cosmos.Kernel.Boot.Default();

            Cosmos.Kernel.Staging.DefaultStageQueue stages = new Cosmos.Kernel.Staging.DefaultStageQueue();
            stages.Enqueue(new Cosmos.Kernel.Staging.Stages.KernelStage());
            stages.Run();

            //以上代码和MS1中的基本一样，就不说了
            //下面这三行应该是为了给多用户登陆做准备用的吧，可惜MS2目前还是个单进程单线程的程序，无法让多用户进行操作
            //总之这里实例化了一个用户，然后在加载一次会话，最后是run运行，跳到下一段代码块来分析run里面的代码
            Security.User currentUser = Security.User.Authenticate("frode", "secret");
            Shell.Session currentSession =  Shell.Session.CreateSession(currentUser);
            currentSession.Run();

            Test.RTL8139Test.RunTest();

            Console.WriteLine("Shutting down computer");
            while (true)
                ;
        }
    }
}

以下是run部分的代码：

这段代码用来响应用户输入的命令，可以看到这里里面包括了使用RTL8139网卡芯片来发送数据包的代码，其实就是调用RTL8139驱动程序提供的类和方法。其实MS2个人感觉主要是实现了对PCI设备的控制

internal void Run()
        {
            Console.Write(Prompt.LoadPrompt(xUser).PromptText());
            string command = Console.ReadLine();
            Cosmos.Driver.RTL8139.RTL8139 nic = null;

            if (command.Equals("exit"))
                return;
            else if (command.Equals("nic"))
            {
                //获取PCI设备，下一篇文章再共同学习一下对PCI的编程控制
                Cosmos.Hardware.PC.Bus.PCIDevice pciNic = Cosmos.Hardware.PC.Bus.PCIBus.GetPCIDevice(0, 3, 0);
                nic = new Cosmos.Driver.RTL8139.RTL8139(pciNic);
                nic.Enable();
                Console.WriteLine("Enabled Network card");
            }
            else if (command.Equals("send"))
            {

                //这里调用网卡发送数据包其实也只是简单的使用了几个网卡驱动程序中提供出来的几个函数而已
                //数据包的格式是自己构造的，并没有遵循任何协议（比如TCP/IP）的标准
                Cosmos.Driver.RTL8139.PacketHeader head = new Cosmos.Driver.RTL8139.PacketHeader(0xFF);
                byte[] data = FrodeTest.Test.Mock.FakeBroadcastPacket.GetFakePacketAllHigh();
                Cosmos.Driver.RTL8139.Packet packet = new Cosmos.Driver.RTL8139.Packet(head, data);
                if (nic == null)
                {
                    Console.WriteLine("Enable NIC with command nic first");
                    return;
                }
                nic.Enable();
                nic.EnableRecieve();
                nic.EnableTransmit();
                nic.Transmit(packet);
            }
            else if (command.Equals("reset"))
            {
                nic.SoftReset();
                nic.EnableTransmit();
                nic.EnableRecieve();
                Console.WriteLine("NIC reset");
            }
            else
                Console.WriteLine("No such systemcommand or application: " + command);

            Run();

}

好接下来就是分析RTL8139这个类了

可以看到，这个项目里面除了RTL8139这个类外还有其他一些文件，这些合起来构成了一个cosmos中RTL8139网卡的驱动程序。从代码中可以看到RTL8139继承自NetwordDevice，NetworkDevice继承自Device，Device继承自Hardware，虽然继承层次比较多，但并不复杂，各基类只是定义了一些接口用来规范和统一操作，其他的代码也并不多，基本一看就能明白。

在接下来继续讲解RTL8139这个驱动之前，得对RTL8139这个网卡有点了解（小弟百度了N也没找到多少关于RTL8139的编程资料，可能是百度技术还不够高，泪奔。最后找到了一篇英文的，这里自己翻译一下，希望大家能看懂）

****************************************************

原文地址（需要 fan qiang 访问）：http://wiki.osdev.org/RTL8139

前言

RTL8139通过寄存器（这里的寄存器应该指的是网卡上的寄存器）来进行配置。它的IO基址和IRQ号可以通过PCI配置信息获取。

寄存器

以下是RTL8139使用的寄存器

Offset (from IO base) 相对于IO基址的偏移值	Size 大小	Name 名称
0x00	6	MAC0-5
0x08	8	MAR0-7
0x30	4	RBSTART
0x37	1	CMD
0x3C	2	IMR
0x3E	2	ISR

（原文的表格不太简单了，更多寄存器信息请参考：http://www.soiseek.cn/ETC/RTL8139/10.htm ）

再附上RTL8139的datasheet（做硬件的应该很熟悉了，在此多谢下小弟做硬件的同事，不然还真不知道从datasheet中找资料）/Files/li0803/RTL8139-datasheet.pdf

编程手册

启动RTL8139

发送0x00到config1（0x52）寄存器来设置LWAKE+LWPTN（这两个应该是针脚的名字）为高电平（to active high.）这一步是启动该设备的关键操作。

软复位

接下来我们应该做一次软复位来清理RX和TX缓冲区并设置所有东西回默认值。这一操作用来清除在通电启动时候仍然留在缓冲区或者寄存器中的垃圾。

发送0x01到Command寄存器（0x37）将会使RTL8139进入软复位。只要这个字节被发送过去，可以检查RST位来确认芯片是否完成复位。如果RST位为high(1)，那么复位仍在进行中。

另：在Qemu模拟器中有个小小的bug，如果在执行软复位前检查command寄存器，你可能会发现RST是high(1)。这时，尽管忽略它继续进行初始化操作。

初始化接收缓冲区

这一部分，我们将设置一段芯片地址位置为接收缓存的开始地址。一种方法是，定义个缓存变量并把这个变量地址发送到PBSTART寄存器（0x30），如：

char rx_buffer[8192+16]; // declare the local buffer space (8k + header)

outportd(0x30, (unsigned long)rx_buffer); // send dword memory location to RBSTART (0x30)

设置IMR+ISR

Interrupt Mask 寄存器(IMR)和Interrupt Service寄存器(ISR)用来负责激活不同的IRQ。IMR的各个位和ISR的各个位排成一排来同步工作（The IMR bits line up with ISR bits to work in sync.）如果IMR的一个位为低电平 (low) ，则对应的ISR位将不会触发一个IRQ当这个IRQ的发生周期来到的时候（翻译得真拗口，自己都受不了。上原文吧：. If an IMR bit is low, then the corresponding ISR bit with never fire an IRQ when the time comes for it to happen）。IMR的位置为0x3C，ISR的位置为 0x3E。

要设置RTL8139为只接收Transmit OK(TOK) 和 Receive OK (ROK)中断的话，我们需要让IMR中的TOK位和ROK位为高电平而其他位为低电平。这样设置后，当TOK或者ROK中断请求发生时，就会触发一个IRQ（中断请求）。如：

outportw(0x3C, 0x0005); // Sets the TOK and ROK bits high

另：当你处理一个中断时，你必须写入这个中断对应的位来重置它。文档（不知道什么文档，RTL8139的datasheet？）上说重置缓冲区为0的话读这个寄存器就够了而写入是没有任何效果的。这在QEMU中无效，估计在一些或者大部分硬件中也是如此。而且如果无效的话写入一个位也无妨。

01000101：确认。实际上，清理一个中断的唯一办法是写入这个中断。Datasheet上说读（reading）是你必须做的，但是这完全是错的。

配置接收缓冲区

在期望见到一个数据包到来之前，你应该告诉RTL8139根据各种规则来接收数据包。这里的配置寄存器为RCR。

你可以开启不同的匹配规则：

AB – Accept Broadcast: 允许广播数据包发送到MAC地址 FF：FF：FF：FF：FF：FF

AM – Accept Multicast: 允许多播数据包

APM – Accept Physical Match: 允许数据包被发送到NIC（网络接口卡？Network Interface Card）的MAC地址

AAP – Accept All Packets: 允许所有数据包（运行在 promiscuous模式下）

另外一个位----WRAP位，控制着接收缓冲区wrap around（环绕？不知如何翻译）的处理。

如果WRAP是0，RX缓冲区则被当作传统的环缓冲（ring buffer）处理；如果一个数据包被写入缓冲区结尾附近并且RTL8139知道你已经在它之前处理了（根据CAPR来判断是否被处理）这个被写入的数据，这个数据包将会在缓冲的开始继续（怎么觉得这句话有问题呢，求高手：if a packet is being written near the end of the buffer and the RTL8139 knows you've already handled data before this (thanks to CAPR), the packet will continue at the beginning of the buffer.）

如果WRAP是1，数据包的remainder将会被连续地写入（使实际的接收缓冲区溢出）这样它能被更有效地处理。这将意味着为了接收可能使缓冲区溢出的最大的数据包，接收缓冲需要额外的1500个字节。

你也可以在这里设置你的RX缓冲区的大小，尽管如此，如果你使用一个像之前描述的8K+16的缓冲，填0已经足够了。要是用WRAP=1的位的话，一个8K的缓冲实际上必须是8K+16+1500字节。例如：

outportl(0x44, 0xf | (1 << 7)); // (1 << 7) is the WRAP bit, 0xf is AB+AM+APM+AAP

开启接收和传送功能

现在是时候设置RX和TX的功能了。这真的是小意思，在我看来，这个只应该在RTL8139的寄存器按照我们想要的配置完成后才来完成这部分内容。RE（Receiver Enabled）和TE（Transmitter Enabled）位都在Command寄存器（0x37）中。设置RE和TE真的很简单，但还是让我们来看一下。

为了允许RTL8139接收和传送数据包，RE和TE位必须设置成高电平。一旦这个设置完成，网卡就将同意数据包进出。如

outportb(0x37, 0x0C); // Sets the RE and TE bits high

****************************************************

好了，有了上面RTL8139的编程知识后，我们在来理解Cosmos中RTL8139的驱动代码就容易很多了。来一起学习下几个比较重要的public函数。

//构造函数，由于RTL8139通过PCI总线进行通信，所以这里传入一个PCI设备类，然后是获取设备能进行读写的内存范围，最后用这段内存来实例化网卡的寄存器。
//这里的寄存器应该和我们CPU汇编中使用的寄存器有点不太一样，这里虽然也是使用寄存器名字，但是读写寄存器还是读写内存，不同的寄存器对应的是不同的内存范围。
public RTL8139(PCIDevice device)
        {
            pciCard = device;
            mem = device.GetAddressSpace(1) as MemoryAddressSpace;
            regs = new MainRegister(mem);
        }

//启动网卡，有前面翻译的文章中知道，启动网卡就是往config1寄存器中写入0x00
public override bool Enable()
        {
            regs.Config1 = 0x00;
            return true;
        }

//软复位，根据翻译的文章基本可以了解代码的内容了，不多解释
public void SoftReset()
        {
            Console.WriteLine("Performing software reset of RTL8139");

            regs.ChipCmd = MainRegister.ChipCommandFlags.RST;
            while (regs.ChipCmdTest(MainRegister.ChipCommandFlags.RST))
            {
                Console.WriteLine("Reset in progress...");
            }

            Console.WriteLine("Reset Complete!");
        }

//开启接收功能
public void EnableRecieve()
        {
            regs.ChipCmd = MainRegister.ChipCommandFlags.TE;
        }

//开启传送功能
public void EnableTransmit()
        {
            regs.ChipCmd = MainRegister.ChipCommandFlags.TE;
        }

//Early TX Threshold特指在传送开始前TX先进先出寄存器中的的临界值
//bytecount不能超过2048（2K 字节）
//bytecount是一个能被32整除的数
//bytecount是0则NIC（网卡适配器，其实就是网卡）将使用8字节作为临界值
public void SetEarlyTxThreshold(uint bytecount)
        {
            if (bytecount != 0 & (bytecount % 32 > 0))
                throw new ArgumentException("Early TX Threshold must be 0 or dividable by 32");

            //Each of the four Transmit Status Descriptors (TSD) has its own EarlyTxThreshold.
            UInt32 address = pciCard.BaseAddress1 + (byte)MainRegister.Bit.RxEarlyCnt;
            IOSpace.Write8(address, (byte)bytecount);
        }

//初始化接收缓冲区。RBSTART寄存器由4字节组成(0x30h 到 0x33h)，这4个字节应该包括将要保存数据的缓冲区地址
public void InitReceiveBuffer()
        {
            byte[] rxbuffer = new byte[2048];
            UInt32 address = pciCard.BaseAddress1 + (byte)MainRegister.Bit.RxBuf;

            //把缓冲区的地址空间（就是一段地址）写入RBSTART
            WriteAddressToPCI(ref rxbuffer, address);

            Console.WriteLine("RxBuffer contains address: " + IOSpace.Read32(address));

        }

//传送指定的数据包
public unsafe void Transmit(Packet packet)
        {
            //告诉PCI卡数据包中内容部分的地址.
            UInt32 address =
                pciCard.BaseAddress1 +
                (byte)MainRegister.Bit.TSD0 + //I think this should be TSAD0, but then no packet is sent...
                TransmitStatusDescriptor.GetCurrentTSDescriptor();
            Console.WriteLine("Address of TSAD0: " + address);

            byte[] body = packet.PacketBody;

            WriteAddressToPCI(ref body, address);

            Console.Write("Data in Transmit Status Descriptor " + TransmitStatusDescriptor.GetCurrentTSDescriptor() + ":");
            Console.WriteLine(IOSpace.Read32(address));
            //就目前来看，TSDA0应该包含有数据的地址.
            Console.WriteLine("The Data pointed to: " + IOSpace.Read32(IOSpace.Read32(address)));

            //把传送状态设置为允许传送.
            TransmitStatusDescriptor tsd = TransmitStatusDescriptor.Load(pciCard);
            tsd.Size = body.Length;
            Console.WriteLine("Told NIC to send " + tsd.Size + " bytes.");
            SetEarlyTxThreshold(1024);
            Console.WriteLine("Sending...");
            tsd.ClearOWNBit();
            TransmitStatusDescriptor.IncrementTSDescriptor();
        }

这里解释一下，RTL8139中所谓的寄存器其实就是其自身对其自己已划分好的各个内存块的名称，操作不同的寄存器，其实就是操作不同的内存块。Cosmos中RTL8139的驱动还另外写了一些类来专门负责读写对应的寄存器，其实就是专门修改对应的内存地址段。里面的代码都比较简单，基本上都是对内存段的读写，就不说了

最后，我们来运行这个项目看看

运行了两个命令：nic和send,可以看到输出了一些和网卡相关的信息。不过在此寻求高人帮助：怎么检测本机的网卡是否是真的有数据发送出去。还有这里显示出来的MAC地址虽然是从硬件的配置信息用读取出来的，但和用ipconfig列出的本机的网卡的MAC不太一样，不确定这里的代码是否真的运行成功了。

好了，此次就写到这里吧，以上列出的代码中还有些PCIdevice，IOSpace之类的类没有涉及到，这些将留在下一篇对PCI总线的编程学习中和大家共享学习心得。

这次的好像有点长，希望写的东西大家能看得懂，也非常欢迎大家点评。

接下来是广告时间，大家懂得……

欢迎大家经常光顾小弟的淘宝充值店：http://hundre.taobao.com/

最后是多谢大家捧场

本文链接

Cosmos的汇编级调试器（翻译）---- .net/C#开源操作系统学习系列七

2011-09-21T09:52:00Z

英文原文地址：http://www.codeproject.com/KB/cs/CosmosAsmDebuggerPreview.aspx

前言

一些用户写信给我，问我要一些关于新Cosmsos X86 汇编级调试的信息。因为在这方面比较有兴趣，我写了这篇简短的文章。Cosmos已经有了一个集成在Visual
Studio中用于调试C#和VB.NET代码的调试器。尽管如此，为了调试X86汇编，用户需要依靠GDB。Cosmos也包括了部分GDB前端，但是在IL和C#之间的链接阶段这些会丢失并且需要大量的mental parsing(不知道啥意思).
最后，我们希望扩展我们新的汇编调试器，这样以后将很少用到或者GDB只有在一些很深入的调试如debug
stub才会使用。这个X86调试器允许你在C#中设置断点，然后查看IL代码和X86汇编以及寄存器。

Cosmos是什么？

（…………………此处省略文字若干，这部分内容已在其他系列文章中列出，这里就不写了）

使用汇编调试器

1. 打开一个Cosmos工具窗口

目前（翻译这篇文章的时候最新更新包为83843），只有汇编和寄存器窗口能工作。栈和帧（frame）窗口将在接下来几天完成。我们也将添加其他的直接内存注入窗口，最后将实现汇编级的单步调试。

现在，在C#代码里面设置一个断点，然后运行你的“操作系统”。如果你是使用默认的设置，VMWare将和你的系统一起出来，同时Visual
Studio将会停在你的断点处。

你将会注意到“local watch window”(本地窗口？)是可以工作的。这是 Cosmos Visual Studio调试器的一部分。在右边出现的两个汇编调试窗口也是新的调试窗口。汇编窗口显示出这一行对应的IL和X86的汇编代码。如果有更多的断点，将会使用单步调试（stepping）并且汇编调试器窗口每次都会更新。注意：在截图中有个小BUG,在汇编窗口中只显示出一个IL操作符。它应该是这样子的

System_Void__BreakpointsKernel_BreakpointsOS_Run____DOT__00000001:
call DebugStub_TracerEntry
; [Cosmos.IL2CPU.X86.IL.Ldc_I4]
push dword 0x0
; Stack contains 1 items: (4)

System_Void__BreakpointsKernel_BreakpointsOS_Run____DOT__00000002:
; [Cosmos.IL2CPU.X86.IL.Stloc]
; EBPOffset = 4
pop dword EAX
mov dword [EBP + -4], EAX
; Stack contains 0 items: ()

在刚开始的寄存器窗口显示了X86
寄存器。最近更新的值将会用红色标识出来。在监控改变上这很有用。

为什么需要一个汇编级的调试器。

既然COSMOS使用C#来写的，为什么我们需要一个如此底层的调试？我们觉得很多用户可能只需要用到C#调试器。尽管如此，汇编级调试器对工作在编译器上的用户或者在直接和硬件交互的调试中的用户来说是一个很大的帮助。

本文链接

Plugs介绍（翻译）---- .net/C#开源操作系统学习系列六

2011-08-10T19:18:00Z

原文地址：http://www.codeproject.com/KB/cs/CosmosPlugs.aspx

介绍

这篇文章将展示在COSMOS中如何实现基于WINDOWS API调用和内部调用的.net代码。另外，也包含了如何使用COSMOS，汇编或者X#语言与硬件直接进行交互。

Cosmos是什么

Cosmos一个使用Visual Studio作为开发环境的操作系统开发工具（development kit）。尽管如此，任何基于.net的语言，包括VB.NET,Fortran,Delphi Prism,IronPython,F#等等都可以用来进行开发。Cosmos本省和内核运行都是使用C# 来写的，所以命名为Cosmos。而且，NOSMOS（.NET Open Source Managed Operating System）听起来太蠢了。

Cosmos不是传统意义上的操作系统，它更应该叫做操作系统工具（Operating System Kit），或者正如我所说的叫做“Operating System Legos”(不知如何翻译，嘿嘿)。Cosmos让您能像使用Visual Studio和C#创建应用程序一样创建操作系统。大部分用户可以在几分钟之内自己写和引导一个他们自己的操作系统，所有这些都可以在Visual Studio中完成。Cosmos提供了与Visual Studio集成的项目类型、调试器、断点工具和观察其（watchers）等。你可以向调试你的C#或者VB.NET应用程序一样调试你的操作系统。

什么情况下需要Plugs

在以下三种场景中需要用到Plugs:

1. 内部调用（Internal Calls）

2. P/Invoke

3. 直接汇编

内部调用和P/Invoke的情况

在.net框架提供的各种类中，有一部分不是使用.net代码来实现的，而是使用的本地代码。这样做的原因有两：

1. 被实现的方法依赖于Windows API(P/Invoke的情况)

2.被实现的方法依赖于高度优化过的C++或者在.net运行时中的汇编代码（内部调用的情况）

P/Invoke被用来往屏幕上画图，访问已存在的Window encrypition API,访问网络和其他一些类似的功能。

内部调用被需要直接访问.net运行时的类来使用。比如直接访问内存管理的类，或者对速度有要求的情况。如Math.Pow方法就是使用的内部调用。

Plugs可以使用C# ，汇编或者任何.net语言来实现。

直接汇编的情况

对于直接与硬件进行会话，Cosmos必须能够和PIC总线，CPU IO总线，内存等进行交互。访问内存经常使用的是非类型安全的指针（unsafe pointers），尽管如此，在某些情况下还是得自己手写汇编代码。Plugs相当于接口，提供给C#直接访问汇编代码，使得对汇编调用的访问就像C#代码的方法调用一样。

在Cosmos中写X86汇编

可以在Cosmos中使用类来实现X86汇编

new Move(Registers.DX, (xComAddr + 1).ToString());

new Move(Registers.AL, 0.ToString());

new Out("dx", "al");// disable all interrupts

new Move(Registers.DX, (xComAddr + 3).ToString());

new Move(Registers.AL, 0x80.ToString());

new Out("dx", "al");//  Enable DLAB (set baud rate divisor)

new Move(Registers.DX, (xComAddr + 0).ToString());

new Move(Registers.AL, 0x1.ToString());

new Out("dx", "al");//      Set diviso (low byte)

new Move(Registers.DX, (xComAddr + 1).ToString());

new Move(Registers.AL, 0x00.ToString());

new Out("dx", "al");// // set divisor (high byte)

但是 Cosmos也支持一个更高层次的调用X#。X#是一种类型安全的直接与X86汇编对应的汇编语言。X#如下：

UInt16 xComStatusAddr = (UInt16)(aComAddr + 5);

Label = "WriteByteToComPort";

Label = "WriteByteToComPort_Wait";

DX = xComStatusAddr;

AL = Port[DX];

AL.Test(0x20);

JumpIfEqual("WriteByteToComPort_Wait");

DX = aComAddr;

AL = Memory[ESP + 4];

Port[DX] = AL;

Return(4);

Label = "DebugWriteEIP";

AL = Memory[EBP + 3];

EAX.Push();

Call<WriteByteToComPort>();

AL = Memory[EBP + 2];

EAX.Push();

Call<WriteByteToComPort>();

AL = Memory[EBP + 1];

EAX.Push();

Call<WriteByteToComPort>();

AL = Memory[EBP];

EAX.Push();

Call<WriteByteToComPort>();

Return();

开始实现Plugs

首先我们必须先决定我们的plug要干什么。举例来说，Math.Abs(double)被用来实现一个内部调用

.method public hidebysig static float64 Abs(float64 'value') cil managed internalcall

{

.custom instance void System.Security.SecuritySafeCriticalAttribute::.ctor()

}

如果你直接使用这个方法而Cosmos没有相应的plug，编译器便会产生一个“plug needed”错误。因为在IL2CPU没有IL代码把它编译为X86代码。所以“plug needed”错误的意思是你需要一些依赖内部调用或者P/Invoke的方法，否则Cosmos将无法编译。

在Math.Pow这个例子中，是可以通过编译的因为Cosmos的内核已经包含了一个在编译的时候会自动被调用的plug.

编译器在运行时中使用plug来替换实际的代码。Plug中提供的代码被用来替换对内部调用和WINDOWS API的调用，这些调用无法在Cosmos中直接使用因为Cosmos不是运行在Windows或者CLR下面的。Plug就是这么一个强制嵌入和替换的格式（It’s a form of forced inlining and replacement）

为了创建一个Plug，我们需要创建一个新的类。在内核中的Plug被创建为各个单独的程序集(assemblies)并且被内核单独引用。这样允许IL2CPU包含和使用plug。

[Plug(Target = typeof(global::System.Math))]

public class MathImpl  {

        public static double Abs(double value)  {

            if (value < 0) {

                return -value;

            } else {

                return value;

            }

        }

虽然这里是显示了一个方法，但其实Plug类能包括多个方法。在这个例子中Plug的属性（attribute）是关键因素。它告诉IL2CPU这个plug用来替换System.Math类中的方法。然后IL2CPU便会去找与System.Math中方法对应的方法，并把他们给换掉。

直接汇编的plug

直接汇编的plug是被用来运行C#直接和X86汇编进行交互的代码。比如IOPort类允许设备驱动程序在需要和硬件设备通信的时候直接访问CPU总线。

首先创建一个空的C# 类，创建将要被替换的空方法。如果这个被替换的方法的返回类型不是VOID，则plug中的方法需要随便返回一个值以使C# 编译器能编译它。尽管如此这个方法的返回值是不会被用到的，因为plug将使被替换的目标方法被忽略，而以plug中实现的方法替换掉原方法。

public abstract class IOPortBase  {

        public readonly UInt16 Port;

        // all ctors are internal - Only Core ring can create it.. but hardware ring can use it.

        internal IOPortBase(UInt16 aPort)

        {

            Port = aPort;

        }

        internal IOPortBase(UInt16 aBase, UInt16 aOffset)

        {

            // C# math promotes things to integers, so we have this constructor

            // to relieve the use from having to do so many casts

            Port = (UInt16)(aBase + aOffset);

        }

        //TODO: Reads and writes can use this to get port instead of argument

        static protected void Write8(UInt16 aPort, byte aData) { } // Plugged

        static protected void Write16(UInt16 aPort, UInt16 aData) { } // Plugged

        static protected void Write32(UInt16 aPort, UInt32 aData) { } // Plugged

        static protected byte Read8(UInt16 aPort) { return 0; } // Plugged

        static protected UInt16 Read16(UInt16 aPort) { return 0; } // Plugged

        static protected UInt32 Read32(UInt16 aPort) { return 0; } // Plugged

正如你看到的“Write”方法是空的，而“Read”方法需要一个名义上的返回值。

这个类将被一下代码给替换掉：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Cosmos.IL2CPU.Plugs;

using Assembler = Cosmos.Compiler.Assembler.Assembler;

using CPUx86 = Cosmos.Compiler.Assembler.X86;

namespace Cosmos.Core.Plugs

{

    [Plug(Target = typeof(Cosmos.Core.IOPortBase))]

    public class IOPortImpl

    {

        [Inline]

        public static void Write8(UInt16 aPort, byte aData)

        {

            //TODO: This is a lot of work to write to a single port.

            // We need to have some kind of inline ASM option that can

            // emit a single out instruction

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EDX, SourceReg = CPUx86.Registers.EBP, SourceDisplacement = 0x0C, SourceIsIndirect = true };

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EAX, SourceReg = CPUx86.Registers.EBP, SourceDisplacement = 0x08, SourceIsIndirect = true };

            new CPUx86.Out { DestinationReg = CPUx86.Registers.AL };

        }

        [Inline]

        public static void Write16(UInt16 aPort, UInt16 aData)

        {

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EDX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x0C };

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EAX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x08 };

            new CPUx86.Out { DestinationReg = CPUx86.Registers.AX };

        }

        [Inline]

        public static void Write32(UInt16 aPort, UInt32 aData)

        {

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EDX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x0C };

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EAX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x08 };

            new CPUx86.Out { DestinationReg = CPUx86.Registers.EAX };

        }

        [Inline]

        public static byte Read8(UInt16 aPort)

        {

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EDX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x08 };

            //TODO: Do we need to clear rest of EAX first?

            //    MTW: technically not, as in other places, it _should_ be working with AL too..

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EAX, SourceValue = 0 };

            new CPUx86.In { DestinationReg = CPUx86.Registers.AL };

            new CPUx86.Push { DestinationReg = CPUx86.Registers.EAX };

            return 0;

        }

        [Inline]

        public static UInt16 Read16(UInt16 aPort)

        {

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EDX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x08 };

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EAX, SourceValue = 0 };

            new CPUx86.In { DestinationReg = CPUx86.Registers.AX };

            new CPUx86.Push { DestinationReg = CPUx86.Registers.EAX };

            return 0;

        }

        [Inline]

        public static UInt32 Read32(UInt16 aPort)

        {

            new CPUx86.Move { DestinationReg = CPUx86.Registers.EDX, SourceReg = CPUx86.Registers.EBP, SourceIsIndirect = true, SourceDisplacement = 0x08 };

            new CPUx86.In { DestinationReg = CPUx86.Registers.EAX };

            new CPUx86.Push { DestinationReg = CPUx86.Registers.EAX };

            return 0;

        }

    }

}

注：在这个例子中的代码（指那些看起来像汇编的代码—译者注）不是X#代码。我们一些比较老的plug任然是使用比较老的语法来写的。

现在我们有了一个plug，我们可以使用C#直接访问IOPort这个类。下面这个例子摘自ATA类

public override void ReadBlock(UInt64 aBlockNo, UInt32 aBlockCount, byte[] aData) {

      CheckDataSize(aData, aBlockCount);

      SelectSector(aBlockNo, aBlockCount);

      SendCmd(Cmd.ReadPio);

      IO.Data.Read8(aData);

    }

其他plug的例子

在BCL（Binary Classes Library?。.net中框架提供的类），Console类中使用的一些内部调用通常最后都使用到了WINDOWS API，我们不需要逐个替换每一个调用层次上直接映射到WINDOWS API调用，而只需在一个更高的调用层次树上调用我们的TextScreen类完全替换这些方法。（We don't need to plug only the methods that directly map to Windows API calls, but instead we plug methods much higher up the tree and completely replace the implementation to call our TextScreen class instead.）

namespace Cosmos.System.Plugs.System.System {

    [Plug(Target = typeof(global::System.Console))]

    public static class ConsoleImpl {

        private static ConsoleColor mForeground = ConsoleColor.White;

        private static ConsoleColor mBackground = ConsoleColor.Black;

        public static ConsoleColor get_BackgroundColor() {

            return mBackground;

        }

        public static void set_BackgroundColor(ConsoleColor value) {

            mBackground = value;

            Cosmos.Hardware.Global.TextScreen.SetColors(mForeground, mBackground);

        }

（翻译就到此结束了，水平有限，欢迎大家指点）

本文链接

Cosmos的库--.net/C#开源操作系统学习系类五

2011-04-18T09:15:00Z

接上文，争取这一次打通操作系统开发的任督二脉~~~嘿嘿

库对于大家来说都不陌生，我们做C开发时会引入标准输入输出头文件stdio.h，做MFC开发时又会引入afx.h头文件，使用DirectX做游戏开发时又会引入DirectX的头文件等等，在头文件中有给我们定义好的函数、结构、类等等可供使用，我们写代码时直接调用即可。
在各种库中，有一部分的库是封装了对底层硬件的操作的，例如在屏幕上输入字符，使用网卡发送数据包等。因为是直接对硬件进行操作，所以这一种类型的库的代码是和硬件相关的，这就是为什么我们会有x86的标准C程序库和arm的标准C程序库，两套不同的硬件体系，需要不同的库来完成对硬件的实际操作，每一套库中，都根据不同的硬件情况，按照硬件的规格定义好数据的排列方式（这就是为什么会有int,int16,int32,int64这么多蛋疼的数据类型的原因之一，因为编译器编译后有些数据必须占有足够长的位数以符合硬件产品的规格要求），以及根据硬件的功能提供出相应的函数，然后编译器编译时就能编译出符合硬件要求的格式的数据排列方式和操作这些数据的机器码。

在库中，根据不同的硬件特点定义了只适用于特定硬件的数据结构和函数，这就是为什么我们用C++开发普通的软件的时候使用标准输入输出库(stdio.h)，而用C++开发游戏软件的时候需要使用DirectX库的原因。因为DirectX的库中定义有调用显卡的特殊功能的数据结构、类或者方法，从而能充分利用显卡这个硬件来展示游戏内容。

该说点沾边的了，其实Cosmos中也定义了一些这样的库，用来提供开启CPU的分页存储、读写端口的数据等功能，在编写操作系统的过程中，我们只需要自己实现这些库中的类和函数来完成对硬件的操作。同时因为这些功能都是直接操作硬件的，所以一般的操作系统开发包里面都不会提供给用户使用，咱们现在是操作系统的开发者，所以才会使用到这些底层的东西（也就开源的操作系统能看到源代码，才会从开发者的角度看到有这么一些函数或者类……），另外从某种程度上看，做驱动程序的开发的人员也需要编写一些底层的对硬件的操作库来供应用软件的开发人员使用。

在C#的项目中把程序集添加进来，就相当于C/C++里面的include头文件操作。这些对硬件操作的代码虽然都是使用C# 来编写的，但在编译的时候IL2CPU编译器会把这些操作全都转换成特定的CPU操作指令这样就可以达到使用C#来控制硬件的目的，由此可见，一套好的代码库能极大地提高我们的工作效率。但是，目前C#的对硬件进行操作的库真是少之又少啊（要不就是我太孤陋寡闻了，还没能见着这方面的东西），只能是自己来写了L

由以上看来库的历史比操作系统的历史还长哦~~~呵呵。

好了，理论到此结束，看图说话

在COSMOS中，库有个特别的叫法，叫做Plugs（插件？）。

前面关于COSMOS编译的文章中说到，在COSMOS编译的时候会加载所有的Plugs并进行编译，而COSMOS所有的Plugs都放在了Cosmos.Kernel.Plugs项目中

我们看到了上文提过的CreateGDT操作，还有Console这个我们比较熟悉的类型。先看下CreateGDT中的代码

public class CreateGDT : AssemblerMethod {

                    public override void Assemble(Assembler aAssembler) {

                               string xFieldName = "_NATIVE_GDT_Contents";

                               string xFieldData

                // Null Segment

                = "0,0,0,0,0,0,0,0"

                                   // Code Segment

                                   + ", 0xFF, 0xFF, 0, 0, 0, 0x99, 0xCF, 0"

                                   // Data Segment

                                   + ", 0xFF,0xFF,0,0,0,0x93,0xCF,0";

                    aAssembler.DataMembers.Add(new KeyValuePair<string, DataMember> (aAssembler.CurrentGroup,new DataMember(xFieldName, "db", xFieldData)));

                               xFieldName = "_NATIVE_GDT_Pointer";

                               //xFieldData = "0x17, (_NATIVE_GDT_Contents and 0xFFFF), (_NATIVE_GDT_Contents shr 16)";

                    aAssembler.DataMembers.Add(new KeyValuePair<string, DataMember> (aAssembler.CurrentGroup,new DataMember(xFieldName, "dw", "0x17,0,0")));

                               new CPUx86.Move(Registers.EAX, "_NATIVE_GDT_Pointer");

                               new CPUx86.Move("dword [_NATIVE_GDT_Pointer + 2]", "_NATIVE_GDT_Contents");

                               new Label(".RegisterGDT");

                               new CPUNative.Lgdt(Registers.AtEAX);

                               new CPUx86.Move(Registers.AX, "0x10");

                               new CPUx86.Move("ds", Registers.AX);

            new CPUx86.Move("es", Registers.AX);

            new CPUx86.Move("fs", Registers.AX);

            new CPUx86.Move("gs", Registers.AX);

            new CPUx86.Move("ss", Registers.AX);

            // Force reload of code segement

new CPUx86.JumpAlways("0x8:flush__GDT__table");

new Label("flush__GDT__table");

                    }

          }

可以看到有一些x86的指令在里面，因为这是创建x86特有的GDT这个数据结构，这里直接调用了IL2CPU提供的功能（例如CPUx86.Move）来生成x86的指令。

总的来说，在Cosmos.Kernel.Plugs里面，实现和封装了对硬件操作的大部分功能，然后再由我们的启动项目（这里为Cosmos.Shell.Guess）来在不同的时间调用，以此来搭建出供程序员使用的一个硬件环境。这个环境对外都是通过开放一些特定的类来给程序员使用，目前来看这些类还只是很底层的操作硬件的类，也许以后会在这一层上再封装出一层API来。

（感觉这一次自己的截图不太给力啊……）

IL2CPU在编译时会根据启动项目的程序集加载被引入的程序集和Plugs及Plugs项目中引入的程序集。对于里程碑1，最后需要处理的程序集如下：

总共34个，需要编译器处理的函数如下：

共318个，编译完成后在/Build/Tools/asm目录下生成以下文件：

由生成的目录我们就能很直观的看出都编译了那些程序集，这里最后生成的文件为13个，但前面我们看到总共加载了34个程序集来进行处理，这34个程序集在编译的过程中会被IL2CPU有选择地进行合并，最后输出到上面相应的13个文件里面。剩下的就是编译这些汇编程序文件为二进制文件即可，之后的内容欢迎参看该系列的第二篇文章J

最后，小小地揭秘一下（如果这也算是秘密的话~嘿嘿）：我们可以看到，在Cosmos.Shell.Guess这个项目中，我们使用的Console这个类是.net framework中定义的类，同时我们自己定义的Console类中的方法和属性的名称和.net framework中定义的一模一样，这个只要在编译的时候制定是使用.net framework中的类还是使用我们自己定义的类就可以实现跨平台的目的，这就是跨平台的秘密，这里跨的是.net平台和x86平台，我们也可以自己实现arm下的Console类来实现跨arm的平台（啊呀，谁拿砖拍的我~~）。

再小小地总结一下开发一个操作系统需要的一些前期工作

到这里我觉得操作系统开发的大致思路应该都理清楚了，剩下的就是学习硬件如何工作以及如何运行，完了之后再编写出相应的代码库对相应的硬件进行操作，同时，根据教科书上所说，再实现进程的调度管理、硬件IO管理、文件系统等功能，一个基本的操作系统就算是出来了。整个开发流程就是：写对硬件操作的代码（这些代码有时就被称为库，在COSMOS中成为Plug）->调用对硬件操作的代码（库）来实现对硬件的管理，不知道这算不算是打通了操作系统开发的任督二脉（还是个人意见，欢迎拍砖）

常规广告时间：欢迎光临小弟的淘宝话费充值小店捧场，呵呵

参考资料：

《程序员的自我修养—连接、装载与库》

《操作系统的设计与实现》--上册

本文链接

Cosmos里程碑1--.net/C#开源操作系统学习系列四

2011-03-28T04:06:00Z

使用的代码包为cosmos14395.zip，以下把COSMOS里程碑1简称为COSMOS MS1或 MS1 COSMOS

申请：由于本篇内容涉及的技术的东西太多，小弟水平有限，如有思想认识上的错误，欢迎大家指正。

对于IBM-PC兼容机的硬件启动流程我目前理解是这样的：通电->BIOS初始化与自检->CPU初始化->加载硬盘的0磁道0柱面1扇区的内容进内存并开始执行这一部分的内容。到此，硬件的过程—注意是硬件--就走完了，剩下的就都交给0磁道0柱面1扇区的程序来执行，这里面的东西就是我们程序员要做的东西了。

这里如果没有操作系统的话，那么从0磁道0柱面1扇区开始执行的程序就是我们自己写的程序，但这样一次只能执行一个，很浪费硬件资源，如果要换别的程序的话还得重新启动一次硬件，所以我们希望这个首先执行的程序可以一直运行，然后再向这个程序发出命令，让这个程序来执行我们想要执行的程序，这样就可以不用重启硬件就能运行多个程序了，慢慢地这个我们对其发出命令让其运行别的程序的程序就变成了我们所谓的操作系统了。

随着操作系统的发展，现代操作系统的一般都需要做以下工作：

1．进程管理
2．内存管理
3． IO管理
4．文件系统管理
(以上为参考《操作系统的设计与实现》一书)

对于我们这次要分析的COSMOS MS1，那么他实现了以上哪些功能呢，严格来说都没实现（第一个里程碑版本嘛，能运行就可以了），要说的话可以说实现了一些IO管理上的功能，如向显示器上输出字符和相应键盘输入。下面通过一副图来说一下COSMOS
MS1操作系统（即PC机软件部分）的启动过程：

由图中可以看到，0磁道0柱面1扇区是一个叫做BOOT（也有叫做BOOTLOADER的）的程序，由它把操作系统的内核加载到内存中，这里再注意是操作系统内核，不是整个操作系统。那么为什么不一开始就加载操作系统而是要通过BOOT来完成加载呢？

因为对于硬盘来说，1个扇区只有512字节，早期操作系统的活比较少的时候可以这么加载，可现代的操作系统已经远远大于512字节，所以只能先运行一个加载程序，然后由加载程序来完成操作系统的加载。

那么操作系统加载进来之后干什么呢，这个就得了解下CPU了。对于x86系列的CPU，操作系统会要开启CPU的段式寻址、分页存储、对CPU进行设置然后进入保护模式等（x86的CPU默认情况是只在保护模式下运行的，并且不使用段式寻址和分页的功能），对于别的系列的CPU，如ARM等，也需要根据CPU产品的说明文档对CPU进行相应的设置来开启CPU所具有的特定功能。在这之后，会在内存上开辟出操作系统自己的栈空间和堆空间，初始化机器的IO。这些做完了之后，对于图形界面的操作系统，就会运行图形界面程序，对于命令行界面的操作系统就会去运行命令行程序（就是常听到的Shell）。然后就是我们平时看到的操作系统的界面了，这就算是启动完成了。

理论到这里就结束了，开始我们的实践吧。开始之前先把启动项目换成Cosmos.Shell.Guess

再说明一下，本版本使用VS2010编译之后似乎无法正常运行，这里是我个人的理解：里程碑1的程序还是VS2008的项目，如果使用VS2010的朋友在打开项目之后会提示升级，升级完后编译会出现部分无法编译通过的情况，是因为升级之后部分项目升级成使用.net 4.0的框架，而部分项目还是用的.net 2.0或3.5的framework，当使用.net 2.0或.net 3.5的项目引用了.net 4.0项目的程序集时，是无法通过编译的，这时尽管把这些项目该为使用.net 4.0的framework后可以正常启动进到编译界面，但是编译操作系统的过程中会出现“未将引用设置到对象”错误，原因不明………..

好了，了解了流程就直接上代码，跟着代码逐行进行说明，找到Program文件，定位到以下代码

/// <summary>
/// 为什么这个是程序的开始函数，请看小弟的上一篇拙文 :)
/// </summary>
publicstaticvoidInit()
{
  //初始化硬件
Kernel.Boot.Default();
//加载一些在硬件设置完毕之后，程序启动之前需要运行的一些东西，COSMOS中每一个需要在这里运行的东西叫做一个Stage（不知道操作系统理论中是不是有这么一个概念？），比如说一些欢迎词和版权声明之类的。这加载进来的是一个欢迎语的Stage
Kernel.Staging.DefaultStageQueue stages = newCosmos.Kernel.Staging.DefaultStageQueue();
//运行上一步加载的Stage
stages.Run();
//剩下的大家应该都能看得懂了
Randommt = newRandom();
intnum = mt.Next();

System.Console.WriteLine("I am thinking of a number between 0 and 100. What is it?");
System.Console.ForegroundColor = ConsoleColor.Blue;
System.Console.Write("Take a guess: ");
System.Console.ForegroundColor = ConsoleColor.White;
short guess = short.Parse(System.Console.ReadLine());

while (guess != num)
            {
System.Console.ForegroundColor = ConsoleColor.Red;
if (guess >num)
System.Console.WriteLine("Too high.");
else
System.Console.WriteLine("Too low.");

System.Console.ForegroundColor = ConsoleColor.Blue;
System.Console.Write("Take another guess: ");
System.Console.ForegroundColor = ConsoleColor.White;
guess = short.Parse(System.Console.ReadLine());
            }

System.Console.WriteLine("You got it!!!!");

stages.Teardown();
}

主要分析一下Kernel.Boot.Default()这个函数干了什么事，前面一大堆理论中关于CPU，内存，IO初始化这些的操作都是在这里面完成的

public static void Default() {
//Init Heap first - Hardware loads devices and they need heap
//居然是先在内存中初始化堆(就是开辟堆空间)   还以为是先对CPU进行设置呢……
//初始化堆的过程其实就是一个在系统中建立各种不同的对象的过程，用这些对象来对内存进行管理
    Heap.CheckInit();

    //现在该是设置CPU和初始化IO了，稍后对该函数进行分析
    Cosmos.Hardware.PC.Global.Init();

// Now init kernel devices and rest of kernel
//对设备进行初始化，看名字这应该是个键盘 
    Keyboard.Initialize();
}

再看一下Cosmos.Hardware.PC.Global.Init()里面做了什么

public static void Init() {
    //终于到CPU了 
    //这里先是new 了一个处理器，但是从函数的带来看这个处理器什么都没做，那玄机就是在Processor这个类的构造函数里面了。跟进去可以看到，可以看到构造函数里面创建了GDT（简单的说就是对于x86的CPU，如果要使用保护模式的话就需要创建一个GDT，并对它进行设置来开启CPU的保护模式功能），但是，由于是MS1(里程碑1)，实现程度还很小，创建GDT只是一个空操作，实际什么也没做，估计会在后续版本中添加进来。
mProcessor = new Processor();
//对中断控制器
    Bus.CPU.PIC.Init();

//All old.. need to port ----------------
//对串口进行初始化
HW.Serial.InitSerial(0);
//对调试工具进行初始化(这个应该是在初期才使用的吧，商业操作系统上在这里应该没有调试相关的代码)
    HW.DebugUtil.Initialize();
HW.DebugUtil.SendMessage("Logging", "Initialized!");
    //初始化时钟？不知道有啥用
    HW.PIT.Initialize(Tick);

    // Partially new
    //初始化中断处理程序，此处是挂在不同的处理程序到对应的中断向量号上
    Interrupts.Init();
    // end partially new

    //初始化ATA存储设备，通常指的是硬盘，此处传入的参数是一个委托，委托内容为一个死循环，也就是没有做任何实现，估计以后会补上
HW.Storage.ATA.Initialize(Sleep);

//创建IDT，如果要使用CPU的分页功能就必须创建一个IDT，并对其进行设置。这里这个函数也是没有做任何实现，因为还是MS1，COSMOS能做的事情还很少，没必要使用到CPU的分页功能。
    HW.CPU.CreateIDT();
    // end old -----------------

    //把键盘添加到系统设备中
    HW.Device.Add(new Bus.CPU.Keyboard());
}

这样就算是基本完成了，当然，对于不同的操作系统，初始化的流程可能会不一样，这得根据实际的硬件情况来决定。

以上的初始化函数中大量调用了这个操作：void Write8(UInt16 aPort, byte aData)

这个是直接往端口中写入数据，根据IBM-PC兼容机的端口说明，对不同的端口进行初始化其实就是往相应的端口中写入不同的数据（但通常都是写入数据0）

这里完了之后我们再跳回到上一层函数，看看Keyboard.Initialize()里面做了什么

//这是一个键盘设备的初始化函数，对于一个设备，COSMOS中使用相应的类和对象来实现设备的功能，以后支持的设备多了的话，这些初始化函数也可能会增多。
public static void Initialize() {
            mBuffer = new Queue<uint>(BufferSize);

            // Old
            Hardware.Keyboard.Initialize(HandleScancode);
            // New

            mKeys = new List<KeyMapping>(128);
//以下都是添加字符的映射关系进映射关系表
            #region Letters
            AddKey(0x10, 'q');
            AddKey(0x100000, 'Q');
            AddKey(0x11, 'w');
            AddKey(0x110000, 'W');
            AddKey(0x12, 'e');
            AddKey(0x120000, 'E');
            AddKey(0x13, 'r');
            AddKey(0x130000, 'r');
            AddKey(0x14, 't');
            AddKey(0x140000, 'T');
            AddKey(0x15, 'y');
            AddKey(0x150000, 'Y');
            AddKey(0x16, 'u');
            AddKey(0x160000, 'U');
            AddKey(0x17, 'i');
            AddKey(0x170000, 'I');
            AddKey(0x18, 'o');
            AddKey(0x180000, 'O');
            AddKey(0x19, 'p');
            AddKey(0x190000, 'P');

            AddKey(0x1E, 'a');
            AddKey(0x1E0000, 'A');
            AddKey(0x1F, 's');
            AddKey(0x1F0000, 'S');
            AddKey(0x20, 'd');
            AddKey(0x200000, 'D');
            AddKey(0x21, 'f');
            AddKey(0x210000, 'F');
            AddKey(0x22, 'g');
            AddKey(0x220000, 'G');
            AddKey(0x23, 'h');
            AddKey(0x230000, 'H');
            AddKey(0x24, 'j');
            AddKey(0x240000, 'J');
            AddKey(0x25, 'k');
            AddKey(0x250000, 'K');
            AddKey(0x26, 'l');
            AddKey(0x260000, 'L');

            AddKey(0x2C, 'z');
            AddKey(0x2C0000, 'Z');
            AddKey(0x2D, 'x');
            AddKey(0x2D0000, 'X');
            AddKey(0x2E, 'c');
            AddKey(0x2E0000, 'C');
            AddKey(0x2F, 'v');
            AddKey(0x2F0000, 'V');
            AddKey(0x30, 'b');
            AddKey(0x300000, 'B');
            AddKey(0x31, 'n');
            AddKey(0x310000, 'N');
            AddKey(0x32, 'm');
            AddKey(0x320000, 'M');
            #endregion

            #region digits
            AddKey(0x1, '`');
            AddKey(0x10000, '~');
            AddKey(0x2, '1');
            AddKey(0x20000, '!');
            AddKey(0x3, '2');
            AddKey(0x30000, '@');
            AddKey(0x4, '3');
            AddKey(0x40000, '#');
            AddKey(0x5, '4');
            AddKey(0x50000, '$');
            AddKey(0x6, '5');
            AddKey(0x60000, '%');
            AddKey(0x7, '6');
            AddKey(0x70000, '^');
            AddKey(0x8, '7');
            AddKey(0x80000, '&');
            AddKey(0x9, '8');
            AddKey(0x90000, '*');
            AddKey(0xA, '9');
            AddKey(0xA0000, '(');
            AddKey(0xB, '0');
            AddKey(0xB0000, ')');

            #endregion

            #region Special
            AddKey(0x1C, '\n');
            AddKey(0x1C0000, '\n');
            AddKey(0x39, ' ');
            AddKey(0x390000, ' ');
            AddKey(0x0E, '\u0968');
            AddKey(0x0E0000, '\u0968');
            #endregion

            #region Punctuation
            AddKey(0x34, '.');
            AddKey(0x340000, '>');
            #endregion
        }

好了，硬件的设置（初始化）总算完了，让我们回到最上层的函数看看接下来的是什么。

在这之后操作系统的任务就算是基本完成了，剩下的就应该是程序的调度运行的工作了，从源代码中可以看到COSMOS是直接运行了一个猜数的程序，我们看一下运行截图：

好了，COSMOS MS1的启动流程和运行到这里就算是结束了。但是还有几个问题没有解开，比如：System.Console.WriteLine（string）这个函数。对于在.net framework环境下编程的朋友可能还没有意识到，问题在什么地方。

首先System.Console.WriteLine是向显示器上显示字符，但是在我们刚才的代码中没有看到与显示器设备初始化相关的代码，在.net 环境下之所以能够向显示器上输出字符是因为.net framework在程序启动之前已经进行了这部份相关代码的加载，当程序中遇到System.Console.WriteLine类似的函数调用时，其实是调用的.net framework中的代码来实现的，这就是为什么我们在编写.net 程序的时候需要引入相应的dll，这些加载代码就在这些dll里面。

但是COSMOS是独立于.net framework来运行的，也就是说COSMOS在运行时是没加载过任何.net framework中的dll，这部分功能的实现COSMOS是通过编写自己的程序库（Plugs）来完成的，这个部分上一篇文章介绍IL2CPU编译器时小小地涉及了一下，更多的内容将在下一遍文章中说明，呵呵（诶呀！谁扔过来的鸡蛋！）

欢迎大家实践学习交流，任何意见和错误都欢迎指出，一起学习，共同进步 J

广告时间：欢迎光临小弟的淘宝话费充值小店捧场，呵呵

参考资料：

Intel Vol 3A System Programming Guide Part 1

《编译原理》—“龙书”第二版

本文链接

Cosmos的基石：IL2CPU编译器--.net/C#开源操作系统学习系列三

2011-02-23T03:31:00Z

本文的代码包以cosmos-12304.zip为例（从这个包开始，COSMOS的内核算是有了个基本的雏形，就像是一颗大树在出芽前会先长出庞大的根系，现在就要破土长出第一颗芽了）

IL2CPU之于COSMOS就相当与GCC之于LINUX，查看COSMOS的源代码，可以发现没有一行汇编代码，就连BOOTLOADER也是使用C#语言来完成的，在COSMOS中很对与硬件相对应的类，如屏幕、键盘等，然后在编译的时候再由IL2CPU识别出这些特定的类并转换成机器指令代码代码。

由于是纯C#的开发环境，因此IL2CPU责任重大，需要实现C#语言的各种特性，包括对象的初始化、多态、事件、委托等等，当然到cosmos-12304为止，这些特性还没有全部实现（后面的应该会一步一步的都实现，不过还没有看过后面的源代码，只是猜测而已）。除此之外，IL2CPU还负责处理对.net的运行库（这个运行库并不是.net framework，这个库是COSMOS自己实现的与.net framework类似但要小很多很多的一个库，以后再讲这一部分）

cosmos-12304这个版本的代码和现在最新的代码在文件结构上有很大的差别，之所以文章从这个代码包开始，是因为小弟从第一个源代码包开始，一点一点的挪到这里，个人感觉从这里开始终于可以大致的抓住了COSMOS的开发思路，目前的COSMOS应该可以分成两部，一部分是IL2CPU，一部分是操作系统内核。整个COSMOS项目是从IL2CPU开始的（从早期的代码可以看出，全都是在实现的编译器的任务），先是让IL2CPU能把简单的C#程序编译成本地程序之后，就开始实现操作系统内核，随着项目的深入，一遍扩展内核的功能，一遍完善IL2CPU编译器，小弟估计到后期IL2CPU将会支持全部C#语言乃至整个MSIL语言的所有特性。

好了，废话到这该来点实质性的东西了，cosmos-12304中先修改启动项目为这个

该项目调用了一段脚本用来编译并启动COSMOS的内核，脚本内容如下：

..\..\..\source\il2cpu\bin\debug\il2cpu.exe
-metal
-in:..\..\..\source\Cosmos\Cosmos.Shell.Console\bin\debug\Cosmos.Shell.Console.exe

-plug:..\..\..\source\Cosmos\Cosmos.Kernel.Plugs\bin\debug\Cosmos.Kernel.Plugs.dll

-out:Files\output.obj -platform:nativex86 -asm:output.asm

脚本位于cosmos-12304\Build\Cosmos\ISO目录下，文件名为Build.bat（其实就是一段批处理程序.........）。设置完后F5启动，整个项目就开始运行了

成功运行的截图如下：

运行方式为把内核编译生成ISO文件，然后使用QEMU虚拟机加载（关于运行如何启动可以参考小弟的上一篇文章，使用的工具不太一样，但是流程是相同的）

好了，到这里整个项目算是运行完成了（对！就只有两行输出，雏形......雏形，大家见谅，就相当于可以输出一个“hello world”了）

接下来看看IL2CPU是如何把C#代码转换成可以独立运行的操作系统内核的，痛苦的历程开始了（小弟编译原理和操作系统原理没学好，分析这里的代码是在是太痛苦了）

从Build.bat文件中的脚本可以看出，启动的时候运行的是IL2CPU项目，直接来到该项目下，点开，查看，是一个CONSOLE类型的项目，直接来到Main函数里面，分析源代码可以发现，IL2CPU项目根据-in输入参数来确定要编译的程序集--此处输入的项目为Cosmos.Shell.Console项目--在Main函数中找到如下代码：

using (FileStream fs = new FileStream(AsmFile, FileMode.Create))
{
    using (StreamWriter br = new StreamWriter(fs))
        {
        e.Execute(InputFile, TargetPlatform, br, MetalMode, DebugMode, BCLDir, Plugs);
    }
}

主要关注这一句：

e.Execute(InputFile, TargetPlatform, br, MetalMode, DebugMode, BCLDir, Plugs);

此处e为一个ENGINE类型的对象，在上边有实例化的代码，跳到Execute方法的定义处，函数内容如下........额，太长了就不列出来，有兴趣的朋友可以自己查看下源代码J

可以看到IL2CPU先获取了Cosmos.Shell.Console程序集的信息，然后存到一个本地变量中，

mCrawledAssembly = AssemblyFactory.GetAssembly(aAssembly);

然后就可以从这个变量中获取程序集都另外引用了哪些程序集，再把引用到的程序集都添加到mCrawledAssembly变量内，在mCrawledAssembly内部使用一个List<AssemblyDefinition>类型的变量来存储这些程序集，留到后面生成汇编代码的时候使用（注：此处使用了MONO项目中的一些类，如AssemblyFactory、AssemblyDefinition等，求一份MONO的类库文档，英文的也行），除此之外还加载了Plugs（插件？），目前看来，Plugs就相当于COSMOS库，COSMOS中对外部硬件的操作都通过Plugs（库）来实现，目前只实现了CONSOLE这个类，也就是说，COSMOS内核中使用的CONSOLE类不是.net framework中的CONSOLE类，而是由CONSOLE内核重新实现了的，在CONSOLE内部调用特定的对象（以后分析）来实现输出功能，当然CONSOLE实现的方法和属性都与.net framework中的一样，这样在编程的时候只需直接使用.net framework来完成操作即可，等到了编译阶段IL2CPU会自动把相应的代码转换成COSMOS的内部实现从而脱离对.net framework库的依赖。

个人猜测以后Plugs会扩展成一个像.net framework一样的类库，不过.net framework的类库这么庞大……恐怕……………

完成以上这些操作后，IL2CPU还会加入一些初始化运行时的函数：

mMethods.Add(RuntimeEngineRefs.InitializeApplicationRef, new QueuedMethodInformation() {
                            Processed = false,
                            Index = mMethods.Count
                        });
                        mMethods.Add(RuntimeEngineRefs.FinalizeApplicationRef, new QueuedMethodInformation() {
                            Processed = false,
                            Index = mMethods.Count
                        });

和虚表（用来实现多态）的实现（对多态的底层实现不是很了解，这里只知其然并不知其所以然，惭愧）：

if (!aInMetalMode) {
                            mMethods.Add(VTablesImplRefs.LoadTypeTableRef, new QueuedMethodInformation() {
                                Processed = false,
                                Index = mMethods.Count
                            });
                            mMethods.Add(VTablesImplRefs.SetMethodInfoRef, new QueuedMethodInformation() {
                                Processed = false,
                                Index = mMethods.Count
                            });
                            mMethods.Add(VTablesImplRefs.SetTypeInfoRef, new QueuedMethodInformation() {
                                Processed = false,
                                Index = mMethods.Count
                            });
                            mMethods.Add(VTablesImplRefs.GetMethodAddressForTypeRef, new QueuedMethodInformation() {
                                Processed = false,
                                Index = mMethods.Count
                            });
                        }

完了之后会传入内核程序的入口点，这就是为什么很多语言的程序都是以Main函数作为程序入口点的原因，因为编译器内部定义的就是把程序跳到Main函数开始执行，如果想让别的函数作为开始函数，则在编译器中就得做相应的修改，有时候这部分内容也交由连接器来处理（有关连接器和编译器的作用在此推荐本书《程序员的自我修养—连接、装载与库》）

mMethods.Add(mCrawledAssembly.EntryPoint, new QueuedMethodInformation() {
                            Processed = false,
                            Index = mMethods.Count
                        });

之后就会调用ProcessAllMethods()方法把以上传入的所有程序集里面的方法转换成汇编代码，然后还会有些清理作用的函数，最后是调用ProcessAllStaticFields()处理一些全局的静态变量

有兴趣的朋友可以跟进代码里面研究一下转换的过程，小弟实在是顶不住了，看得眼花花、头晕晕，大家知道是这么一个流程就好，以后的编译过程基本上就是走的这么一个流程，下面是小弟总结出来的IL2CPU的编译流程图，欢迎大家拍砖：

从上图中没有看到传统编译器中还需要进行的语法、词法、文法分析这几步，嘿嘿，其实这些步骤在加载之前就都已经完成了，这是因为IL2CPU中加载的需要编译的文件都是程序集文件，而.net中，可以通过反射来查看程序集中的所有定义的函数、变量之类的内容，相当于.net已经帮我们做完了语法、词法、文法分析，并把分析的结果分门别类的存放在程序集里了，我们只需要通过反射功能来查看程序集中已经分类好的信息即可。其实，上图中除了分析和汇编的操作，其他的都是把各个需要用到的程序集中的函数、变量这些东西取出来，再补充上一些额外的初始化操作。而分析和汇编的任务就是把从各个程序集中取出函数、变量翻译成本地CPU代码。在IL2CPU内部，是通过逐条翻译MSIL指令来完成的。

可以点开看一下Indy.IL2CPU.IL.X86项目（最新的代码包中好像已经被更名为Cosmos.Complier.IL2CPU.IL.X86）

里面对每一调MSIL指令都写了一个与其对应的类，每一个类就是专门负责把其自己翻译成X86的指令。

上面的这些函数小弟跟进去看了一下，在此以目前的水平就展开分析，展开了也说不清，但里面的东西确实都是精华，虽然复杂了点，但是对于学习面向对象程序的结构和编译器实现的朋友来说是一个很好的例子，在此推荐

最后，IL2CPU再使用第三方工具，把汇编出来的汇编指令文件转换成本地CPU识别的二进制文件，代码如下：

ProcessStartInfo xFasmStartInfo = new ProcessStartInfo();
                    xFasmStartInfo.FileName = FasmFileName;
                    xFasmStartInfo.Arguments = String.Format("\"{0}\" \"{1}\"", AsmFile, OutputFile);
                    xFasmStartInfo.UseShellExecute = false;
                    xFasmStartInfo.RedirectStandardError = true;
                    xFasmStartInfo.RedirectStandardOutput = true;
                    Console.WriteLine("fasm = '{0}'", FasmFileName);
                    Process xFasm = Process.Start(xFasmStartInfo);
                    xFasm.Start();
                    if (!xFasm.WaitForExit(60 * 1000) || xFasm.ExitCode != 0) {
                        Console.WriteLine("Error while running FASM!");
                        Console.Write(xFasm.StandardOutput.ReadToEnd());
                        Console.Write(xFasm.StandardError.ReadToEnd());
                        return 3;
                    }

最后，在通过脚本，讲二进制文件转换成ISO文件供虚拟机加载运行：

@REM ----------- Build ISO

del cosmos.iso

attrib files\boot\grub\stage2_eltorito -r

..\..\..\Tools\mkisofs\mkisofs -R -b boot/grub/stage2_eltorito -no-emul-boot -boot-load-size 4 -boot-info-table -o Cosmos.iso files

pause

@REM ----------- Start QEMU

cd ..\..\..\tools\qemu\

qemu.exe -L . -cdrom ..\..\build\Cosmos\ISO\Cosmos.iso -boot d

pause

最后附上一个comos-12304.zip中IL2CPU相关项目的说明（当然也是个人学习的总结，可能有错，仅当参考，欢迎拍砖）

IL2CPU：IL2CPU的启动项目

IL2CPU.Tests：用来测试对MSIL的指令的翻译是否正确的测试项目

IL2CPUGUI:暂时无用

Indy.IL2CPU：IL2CPU的编译引擎，主要的活动都发生在这里面，同时封装了用来实现MSIL特性的类，如垃圾收集器、多态等

Indy.IL2CPU.Assembler：实现汇编器的一些基类和一些通用的指令操作

Indy.IL2CPU.Assembler.X86：X86汇编器，封装X86指令的实现

Indy.IL2CPU.Assembler.X86.Native：对X86汇编器的一些扩展，应该是用来封装一些平台特有的指令

Indy.IL2CPU.Assembler.X86.Win32：对X86汇编器的扩展，用来翻译支持WIN32环境下的汇编程序

Indy.IL2CPU.IL：封装MSIL指令的一些基类和一些通用的操作

Indy.IL2CPU.IL.X86：与Indy.IL2CPU.Assembler.X86项目配合，把MSIL指令翻译成X86指令

Indy.IL2CPU.IL.X86.Native：与Indy.IL2CPU.Assembler.X86.Native项目配合，把MSIL指令翻译成一些平台支持的特有一些特性的指令

Indy.IL2CPU.IL.X86.Win32：与上面两个类似，翻译成Win32环境下的汇编指令

Indy.IL2CPU.Plugs：封装一些用来在编译的时候处理Plugs的类和操作

最新的代码包中，以上项目的名字已经被该动，不过也只是前缀进行了改变，面的部分基本上都一样。同时个人觉得IL2CPU也还是很不错的编译器，学习编译原理的朋友门，小弟在次推荐一下可以研究一下IL2CPU的源代码，也可以写些文章出来帮小弟解惑一下，呵呵J

好了，先写到这里吧，水平有限，写得不是很好，留下的一些问题特别是关于Plugs的内容小弟也会在以后对源码的学习中慢慢解开

如果觉得本文有点帮助的朋友楼主是很乐意接收鼓励的J，可以到楼主的淘宝充值店光顾下（欢迎收藏小店……广告….广告，大家懂的~~~~）或者点击下博客里面的广告，呵呵

有大虾路过的话楼主也愿意接受鸡蛋和板砖。

本文链接

Cosmos编译--.net/C#开源操作系统学习系列二

2011-02-03T00:40:00Z

惶恐中放上小弟的第一篇分析作品，水平有限，文笔不济，希望各位见谅并提出意见和建议

一、启动之前

VS的便捷同时也掩盖了一个操作系统从源代码转换到二进制文件的中间流程，所以首先先从源代码编译下手，先弄清楚VS是怎么把C#源代码编译成可引导启动的二进制代码。

本人使用的源代码包为cosmos-72205.zip

对于VS需要额外安装：VS2010 SDK

二、MSBuild

编译过LINUX的朋友应该都熟悉Make文件吧，在这里面可以清楚的看到使用编译器把C源代码编译成二进制源代码的流程，中间干了什么都可以看得清清楚楚。但使用VS的朋友一般都是程序写好之后直接F5就运行了，后面做了什么我们根本不知道。对于COSMOS的源代码，VS只是帮我们编译成了IL的代码，这种代码无法在没有CLR环境中运行，所以VS还需要把IL代码编译为针对CPU的本地代码。这中间的流程都由MSBuild这个东西控制。对于MSBuild的介绍可以直接查看MSDN文档。总的来说这个东西的地位就相当于Make文件的地位吧，指导VS如何生成可以引导的二进制文件。

三、编译Cosmos

首先先运行解压出来的文件夹里的Build/VSIP/install.bat文件，这个好像是用安装Cosmos的编译环境的。安装完成，直接双击Source/cosmos.sln文件(在这之前需要先安装VS2010 SDK)即可浏览全部源代码文件（激动~~~~选择COSMOS的主要原因）。打开之后得先改一下启动项目，在次修改成Breakpoints这个项目。然后就可以直接F5启动了。COSMOS编译完成后会直接使用自带的Bulid目录下的虚拟机来加载编译生成的ISO文件，并运行，运行界面如下：

四、Cosmos的编译过程

我们可以看到，工程里面设为启动项的不是常规的C#项目，而已Cosmos项目，该项目在运行Build/VSIP/install.bat时安装到VS2010中，编译的时候会调用该项目自己的MSBuild文件来控制其编译过程，可以在C:\Program Files\MSBuild\Cosmos该目录下找到一个Cosmos.target文件，用写字板打开，找到如下内容：

个人理解，Cosmos项目编译时应该会加载这些dll进内存，在Cosmos项目源代码中到对应的项目，可以发现它们都直接或者间接继承自AppDomainIsolatedTask类，查看MSDN，这个继承该类的类都重写了execute方法，MSBuild在加载这些程序集时应该是会自动运行这些程序集中继承自AppDomainIsolatedTask的类重写的execute方法（运行的顺序似乎并不是按照上面的书写顺序），那么接下来我们只要再分析每一个execute方法，就可以明白这个C#源代码程序是如何编译成为本地CPU二进制格式的文件了（以上各个类运行时需要的参数可以在该文件的接下来的部分找到，如下：<IL2CPU  DebugMode="$(DebugMode)"

                 TraceAssemblies="$(TraceAssemblies)"

                 DebugCom="1"

                 UseNAsm="true"

                 References="@(ReferencePath)"

                 OutputFilename="$(TargetDir)$(MSBuildProjectName).asm"

                 EnableLogging="true"

                 EmitDebugSymbols="$(DebugSymbols)"/>

         <NAsm    InputFile="$(TargetDir)$(MSBuildProjectName).asm"

                 OutputFile="$(TargetDir)$(MSBuildProjectName).obj"

                 IsELF="$(IsELF)"

                 ExePath="$(NasmFile)" />

          

        <Ld      CosmosBuildDir="$(CosmosDir)\Build"

                 WorkingDir="$(TargetDir)"

                 Arguments="-Ttext 0x500000 -Tdata 0x200000 -e Kernel_Start -o '$(TargetDir)$(MSBuildProjectName).bin' '$(TargetDir)$(MSBuildProjectName).obj'"

                 Condition="$(IsELF) == 'true'"/>

        <Delete Files="$(TargetDir)$(MSBuildProjectName).obj" Condition="$(IsELF) == 'true'"/>

        <ExtractMapFromElfFile  InputFile="$(TargetDir)$(MSBuildProjectName).bin"

                                DebugInfoFile="$(TargetDir)$(MSBuildProjectName).cpdb"

                                WorkingDir="$(TargetDir)"

                                CosmosBuildDir="$(CosmosDir)\Build"

                                Condition="$(IsELF) == 'true'"/>

        <CreateItem Include="$(TargetDir)$(MSBuildProjectName).bin" Condition="$(IsELF) == 'true'">

            <Output TaskParameter="Include"

                    ItemName="TempFilesToCopy"/>

        </CreateItem>

        <Copy SourceFiles="@(TempFilesToCopy)"

              DestinationFiles="@(TempFilesToCopy->'$(TargetDir)\%(Filename).obj')"

              Condition="$(IsELF) == 'true'"/>

        <Delete Files="$(TargetDir)$(MSBuildProjectName).bin" Condition="$(IsELF) == 'true'"/>

         

          

        <ReadNAsmMapToCosmosMap InputBaseDir="$(TargetDir)"

                                DebugInfoFile="$(TargetDir)$(MSBuildProjectName).cpdb"

                                Condition="$(IsELF) == 'false'"/>

         

         

        <MakeISO InputFile="$(TargetDir)$(MSBuildProjectName).obj"

                 OutputFile="$(TargetDir)$(MSBuildProjectName).iso"

                 CosmosBuildDir="$(CosmosDir)\Build" />）。     4．1先从Cosmos.Build.MSBuild.IL2CPU开始。Cosmos.Build.MSBuild.IL2CPU继承自AppDomainIsolatedTask类，并重写了execute方法，在execute方法中调用实例化的IL2CPUTask的类的execute方法。而IL2CPUTask类的execute方法则负责获取程序的入口点，读取所有的程序集文件。对于小弟的这个水平来说，由于IL2CPU编译器过于复杂，以下分析请大家以批判的角度来阅读：读取程序集文件后，应该是调用IL2CPU编译器来把IL代码转换成本地CPU的汇编代码文件.asm和支持调试用的符号文件.cpdb。到此Cosmos.Build.MSBuild.IL2CPU的任务就算完成了。接下来的事情交由Cosmos.Build.MSBuild.Nasm处理。

4.2 Cosmos.Build.MSBuild.Nasm

Cosmos.Build.MSBuild.Nasm直接继承自Cosmos.Build.MSBuild.BaseToolTask,而BaseToolTask又直接继承自AppDomainIsolatedTask,查看他们的execute方法内的代码，可以知道Nasm这个类应该是使用Nasm.exe（一个跨平台的汇编开发工具）这个工具把上一步转换出来的.asm文件编译成elf格式的（关于elf格式可以参看小弟空间里的另一篇文章http://www.cnblogs.com/li0803/archive/2010/11/15/1877961.html）目标文件.obj,到此Cosmos.Build.MSBuild.Nasm这个类的工作也结束了，接下来由Cosmos.Build.MSBuild.MakeISO这个类来处理

4.3 Cosmos.Build.MSBuild.MakeISO

Cosmos.Build.MSBuild.MakeISO与Nasm类似，直接继承自BaseToolTask,间接继承自AppDomainIsolatedTask，并重写了自己的execute方法，作用是使用mkisofs.exe这个工具把上一步生成的.obj文件链接成一个ISO文件，以便虚拟机可以加载运行。其实到这一步已经得到了一个可以运行的COSMOS操作系统文件了，但得到的只是一个ISO文件，只能再虚拟机种运行，无法安装到实际的机子上，也不方便进行调试，所以COSMOS还要MSBuild做了一下的事情来生成一个.bin的二进制文件和一些支持在VS下对操作系统的源代码进行调试的.cpdb符号表文件。不知道这么说对不对，大家就仅当参考吧，不对的话也希望大家可以帮忙指正一下，呵呵：）

4.4 Cosmos.Build.MSBuild.Ld

Cosmos.Build.MSBuild.Ld也与Nasm类似，直接继承自BaseToolTask,间接继承自AppDomainIsolatedTask，并重写了自己的execute方法，作用是把Nasm类中编译出来的.obj目标文件使用ld.exe工具链接成一个独立的ELF格式的本地CPU可运行的二进制文件（有关编译和链接的只是可以参考《程序员的自我修养》），然后再交由Cosmos.Build.MSBuild.ExtractMapFromElfFile继续处理

4.5 Cosmos.Build.MSBuild.ExtractMapFromElfFile

Cosmos.Build.MSBuild.ExtractMapFromElfFile同样是直接继承自BaseToolTask,间接继承自AppDomainIsolatedTask，并重写了自己的execute方法，在execute方法中调用objdump.exe来处理上一步生成的文件。小弟也是第一次接触objdump.exe这个东西，从源代码上看应该是分析上一步编译出来的.bin文件，然后生成支持调试用的.cpdb符号表文件吧，接着再交由Cosmos.Build.MSBuild.ReadNAsmMapToCosmosMap做最后的处理。

4.6 Cosmos.Build.MSBuild.ReadNAsmMapToCosmosMap

Cosmos.Build.MSBuild.ReadNAsmMapToCosmosMap类直接继承自AppDomainIsolatedTask类，并重写自己的execute方法，作用是从Nasm任务中生成的.obj文件中读取出地址符号映射表（什么东西？不太懂），写入自带的firebird数据库中，便于源代码跟踪调试用。

到此，COSMOS的编译工作就算是全部完成了

本文链接

Cosmos开篇、本系列目录--.net/C#开源操作系统学习系列一

2011-01-31T03:48:00Z

cosmos简介

cosmos全称C# open source manage operation system，是一个使用C#语言基于.net framwark框架编写的开源操作系统，主页www.gocosmos.org。可从cosmos.codeplex.com获取最新的源代码。

Cosmos的源代码使用C#来编写，先把源代码编译成IL中间语言，然后再由专门针对该项目编写的编译器IL2CPU来把编译好的IL源代码转换成本地机器码，目前处于里程碑5的阶段，只支持x86体系的CPU。官方网站上计划以后将会提供对ARM、MIPS等其他CPU的支持。

目前在学习操作系统的知识，想找份开源的代码来学习学习，刚开始想的使用使用LINUX的，不过LINUX实在是在大了，而且最可气的地方是没有一个好的集成开发环境，也许也是我的能力有限，没有找到一个好的集成开发环境，查看源文件得需要一个一个文件的打开来查看，中间找到过一个SharpOS的开源系统，也是基于C#的，不过已经停止开发了(残念…..)。当然LINUX任然是目前使用范围最广的开源操作系统，最后决定Cosmos的主要原因还是因为可以通过使用VS直接打开.sln文件，就可以浏览全部的源代码，这个便捷性对我这种菜鸟来说实在是太方便了

在此将开始记录我学习Cosmos操作系统的过程，也做个笔记，水平有限，文笔较差，希望大家可以多多指点，嘿嘿：）

本Cosmos系列目录：

本文链接