WWW.LAB-Z.COM

在Shell下面可以使用 memmap 命令查看到当前的内存状况：

UEFI下面没有了E820 Table。取而代之的是GetMemoryMap()。UEFI spec Version 2.4 中 P143有如下的描述，实际上是一个长得和E820很像的东西。

在网上可以搜索到一个示例[参考1]，原文是用Toolkit 写成的，经过一些改造成为可以直接在EDK2下面的编译的代码。

GetMap.c:

#include <Uefi.h>
#include <Library/PcdLib.h>
#include <Library/UefiLib.h>
#include <Library/UefiApplicationEntryPoint.h>

#define PAGE_SIZE 4096 

const CHAR16 *memory_types[] = { 
    L"EfiReservedMemoryType", 
    L"EfiLoaderCode", 
    L"EfiLoaderData", 
    L"EfiBootServicesCode", 
    L"EfiBootServicesData", 
    L"EfiRuntimeServicesCode", 
    L"EfiRuntimeServicesData", 
    L"EfiConventionalMemory", 
    L"EfiUnusableMemory", 
    L"EfiACPIReclaimMemory", 
    L"EfiACPIMemoryNVS", 
    L"EfiMemoryMappedIO", 
    L"EfiMemoryMappedIOPortSpace", 
    L"EfiPalCode", 
    L"EfiMaxMemoryType"
}; 

EFI_BOOT_SERVICES *gBS;  
const CHAR16 * 
memory_type_to_str(UINT32 type) 
{ 
    if (type > sizeof(memory_types)/sizeof(CHAR16 *)) 
        return L"Unknown"; 

    return memory_types[type]; 
} 

EFI_STATUS 
memory_map(EFI_MEMORY_DESCRIPTOR **map_buf, UINTN *map_size, 
           UINTN *map_key, UINTN *desc_size, UINT32 *desc_version) 
{ 
    EFI_STATUS err = EFI_SUCCESS; 

    *map_size = sizeof(**map_buf) * 31; 

get_map: 
    *map_size += sizeof(**map_buf); 

    err = gBS->AllocatePool(EfiLoaderData, *map_size, (void **)map_buf); 
    if (err != EFI_SUCCESS) { 
        Print(L"ERROR: Failed to allocate pool for memory map"); 
        return err; 
    } 

    err = gBS->GetMemoryMap(map_size, *map_buf, map_key, desc_size, desc_version); 
    if (err != EFI_SUCCESS) { 
        if (err == EFI_BUFFER_TOO_SMALL) { 
            gBS->FreePool((void *)*map_buf); 
            goto get_map; 
        } 
        Print(L"ERROR: Failed to get memory map"); 
    } 
    return err; 
} 

GetMap.inf

[Defines]
  INF_VERSION                    = 0x00010005
  BASE_NAME                      = GetMap
  FILE_GUID                      = 6987936E-ED34-44db-AE97-1FA5E4ED2318
  MODULE_TYPE                    = UEFI_APPLICATION
  VERSION_STRING                 = 1.0
  ENTRY_POINT                    = UefiMain

#
# The following information is for reference only and not required by the build tools.
#
#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
#

[Sources]
  GetMap.c

[Packages]
  MdePkg/MdePkg.dec
  ShellPkg/ShellPkg.dec
  MdeModulePkg/MdeModulePkg.dec

[LibraryClasses]
  UefiApplicationEntryPoint
  UefiLib
  PcdLib
  ShellCEntryLib
  ShellLib

[FeaturePcd]
  gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintEnable

[Pcd]
  gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintString || gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintEnable  ## Valid when gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintEnable
  gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintTimes  || gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintEnable  ## Valid when gEfiMdeModulePkgTokenSpaceGuid.PcdHelloWorldPrintEnable

EFI_STATUS  
print_memory_map(void) 
{ 
    EFI_MEMORY_DESCRIPTOR *buf; 
    UINTN desc_size; 
    UINT32 desc_version; 
    UINTN size, map_key, mapping_size; 
    EFI_MEMORY_DESCRIPTOR *desc; 
    EFI_STATUS err = EFI_SUCCESS; 
    int i = 0; 

    err = memory_map(&buf, &size, &map_key, &desc_size, &desc_version); 
    if (err != EFI_SUCCESS) 
        return err; 

    Print(L"Memory Map Size: %d\n", size); 
    Print(L"Map Key: %d\n", map_key); 
    Print(L"Descriptor Version: %d\n", desc_version); 
    Print(L"Descriptor Size: %d\n\n", desc_size); 
    Print(L"Descriptor Size: %d\n\n", sizeof(EFI_MEMORY_DESCRIPTOR)); 

    desc = buf; 
    while ((UINT8 *)desc <  (UINT8 *)buf + size) { 
        mapping_size =(UINTN) desc->NumberOfPages * PAGE_SIZE; 

        Print(L"[#%02d] Type: %s  Attr: 0x%x\n", i, memory_type_to_str(desc->Type), desc->Attribute); 
        Print(L"      Phys: %016llx-%016llx\n", desc->PhysicalStart, desc->PhysicalStart + mapping_size -1 ); 

        desc = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)desc + desc_size); 
        i++; 
    } 

    gBS->FreePool (buf); 
    return err; 
} 

EFI_STATUS 
EFIAPI
UefiMain(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) 
{ 

    print_memory_map(); 

    return EFI_SUCCESS; 
}

 

运行结果如下：

我们使用 GetMap >> result.txt 得到完整的输出结果如下：

Memory Map Size: 960
Map Key: 2841
Descriptor Version: 1
Descriptor Size: 48

Descriptor Size: 40

[#00] Type: EfiBootServicesData Attr: 0xF
Phys: 0000000000CB0000-0000000000CCFFFF
[#01] Type: EfiConventionalMemory Attr: 0xF
Phys: 0000000000CD0000-000000000383FFFF
[#02] Type: EfiLoaderData Attr: 0xF
Phys: 0000000003840000-0000000003841FFF
[#03] Type: EfiLoaderCode Attr: 0xF
Phys: 0000000003842000-0000000003848FFF
[#04] Type: EfiLoaderData Attr: 0xF
Phys: 0000000003849000-000000000385EFFF
[#05] Type: EfiLoaderCode Attr: 0xF
Phys: 000000000385F000-00000000038ABFFF
[#06] Type: EfiConventionalMemory Attr: 0xF
Phys: 00000000038AC000-0000000003B09FFF
[#07] Type: EfiBootServicesData Attr: 0xF
Phys: 0000000003B0A000-0000000003B56FFF
[#08] Type: EfiConventionalMemory Attr: 0xF
Phys: 0000000003B57000-0000000003B74FFF
[#09] Type: EfiBootServicesData Attr: 0xF
Phys: 0000000003B75000-0000000003B75FFF
[#10] Type: EfiConventionalMemory Attr: 0xF
Phys: 0000000003B76000-0000000003B76FFF
[#11] Type: EfiBootServicesData Attr: 0xF
Phys: 0000000003B77000-00000000048ABFFF
[#12] Type: EfiConventionalMemory Attr: 0xF
Phys: 00000000048AC000-0000000004990FFF
[#13] Type: EfiBootServicesCode Attr: 0xF
Phys: 0000000004991000-0000000004BABFFF
[#14] Type: EfiRuntimeServicesData Attr: 0xF
Phys: 0000000004BAC000-0000000004BEBFFF
[#15] Type: EfiRuntimeServicesCode Attr: 0xF
Phys: 0000000004BEC000-0000000004C2BFFF
[#16] Type: EfiReservedMemoryType Attr: 0xF
Phys: 0000000004C2C000-0000000004C2FFFF
[#17] Type: EfiBootServicesData Attr: 0xF
Phys: 0000000004C30000-0000000004CAFFFF
[#18] Type: EfiConventionalMemory Attr: 0xF
Phys: 0000000004CB0000-0000000008CAFFFF
[#19] Type: EfiMemoryMappedIO Attr: 0x0
Phys: 0000000000BE0000-0000000000BEBFFF

和直接使用memmap取得的结果相同。需要注意的是：

1. 返回的Descriptor Size 并不是 sizeof(EFI_MEMORY_DESCRIPTOR)
2. 不知道EFI_VIRTUAL_ADDRESS VirtualStart; 是干什么用的

GetMap

参考：
1. http://blog.fpmurphy.com/2012/08/uefi-memory-v-e820-memory.html
可以在附件中找到该网页。它使用的是EFI_Toolkit 我没有编译过

下面的代码展示了在Shell下如何编写一个清屏功能

EFI_SYSTEM_TABLE	*gST;

//
// Entry point function - HelloMain
//
EFI_STATUS
EFIAPI
UefiMain (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{

  gST = SystemTable;

  gST->ConOut->ClearScreen(gST->ConOut);
  gST->ConOut->EnableCursor(gST->ConOut,TRUE);

  return EFI_SUCCESS;
}

 

运行之后，会清屏并将光标至于屏幕左上角。

完整的代码 HelloWorld3

这里介绍如何获得Shell下的命令行参数。关键代码很简单，如下：

EFI_STATUS
EFIAPI
ShellAppMain (
	IN	UINTN 	Argc,
	IN 	CHAR16	**Argv
)
{
UINTN 	i;

	Print (L"Total %d args\n",Argc);
	for (i=0;i<Argc;i++)
 	{
	  Print (L"Arg[%d]= %s \n",i,*(Argv+i));
	}
	return EFI_SUCCESS;
}

 

完整的代码 HelloWorld2

这一系列文章是根据cutebunny 的BLOG “windows的磁盘操作” 写成的，主要是部分修改原作中的代码，使之兼容Unicode和Windows 7 64bit. 原文可以在下面的网址找到

http://cutebunny.blog.51cto.com 。 本文是参考 “windows的磁盘操作之五——获取物理磁盘上的所有逻辑分区号”写成。

程序实现了获得当前硬盘上全部盘符的功能（分区可能没有分配盘符，比如：win7一般都会隐藏起来最前面的分区）。

// emuPart.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "windows.h"

/******************************************************************************
* Function: get disk's physical number from its drive letter
*           e.g. C-->0 (C: is on disk0)
* input: letter, drive letter
* output: N/A
* return: Succeed, disk number
*         Fail, -1
******************************************************************************/
DWORD GetPhysicalDriveFromPartitionLetter(TCHAR letter)
{
    HANDLE hDevice;               // handle to the drive to be examined
    BOOL result;                 // results flag
    DWORD readed;                   // discard results
    STORAGE_DEVICE_NUMBER number;   //use this to get disk numbers
 
    TCHAR path[MAX_PATH];
    wsprintf(path, L"\\\\.\\%c:", letter);
    hDevice = CreateFile(path, // drive to open
                         GENERIC_READ | GENERIC_WRITE,    // access to the drive
                         FILE_SHARE_READ | FILE_SHARE_WRITE,    //share mode
                         NULL,             // default security attributes
                         OPEN_EXISTING,    // disposition
                         0,                // file attributes
                         NULL);            // do not copy file attribute
    if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
    {
        fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
        return DWORD(-1);
    }
 
    result = DeviceIoControl(
                hDevice,                // handle to device
                IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode
                NULL,                            // lpInBuffer
                0,                               // nInBufferSize
                &number,           // output buffer
                sizeof(number),         // size of output buffer
                &readed,       // number of bytes returned
                NULL      // OVERLAPPED structure
            );
    if (!result) // fail
    {
        fprintf(stderr, "IOCTL_STORAGE_GET_DEVICE_NUMBER Error: %ld\n", GetLastError());
        (void)CloseHandle(hDevice);
        return (DWORD)-1;
    }
    printf("%d %d %d\n\n", number.DeviceType, number.DeviceNumber, number.PartitionNumber);
 
    (void)CloseHandle(hDevice);
    return number.DeviceNumber;
}

/******************************************************************************
* Function: get disk's drive letters from physical number
*           e.g. 0-->{C, D, E} (disk0 has 3 drives, C:, D: and E:)
* input: phyDriveNumber, disk's physical number
* output: letters, letters array
* return: Succeed, the amount of letters
*         Fail, -1
******************************************************************************/
DWORD GetPartitionLetterFromPhysicalDrive(DWORD phyDriveNumber, TCHAR **letters)
{
    DWORD mask;
    DWORD driveType;
    DWORD bmLetters;
    DWORD diskNumber;
    TCHAR path[MAX_PATH]; 
    TCHAR letter;
    DWORD letterNum;
    WORD i;
    TCHAR *p;
 
    bmLetters = GetLogicalDrives();
    if (0 == bmLetters)
    {
        return (DWORD)-1;
    }
 
    letterNum = 0;
    for (i = 0; i < sizeof(DWORD) * 8; i++)
    {
        mask = 0x1u << i;
        if ((mask & bmLetters) == 0)        //get one letter
        {
            continue;
        }
        letter = (TCHAR)(0x41 + i);    //ASCII change
        wsprintf(path, L"%c:\\", letter);
        driveType = GetDriveType(path);
        if (driveType != DRIVE_FIXED)
        {
            bmLetters &= ~mask;     //clear this bit
            continue;
        }
        diskNumber = GetPhysicalDriveFromPartitionLetter(letter);
        if (diskNumber != phyDriveNumber)
        {
            bmLetters &= ~mask;     //clear this bit
            continue;
        }
        letterNum++;
    }
 
    //build the result
    *letters = (TCHAR *)malloc(letterNum);
    if (NULL == *letters)
    {
        return (DWORD)-1;
    }
    p = *letters;
    for (i = 0; i < sizeof(DWORD) * 8; i++)
    {
        mask = 0x1u << i;
        if ((mask & bmLetters) == 0)
        {
            continue;
        }
        letter = (TCHAR)(0x41 + i);    //ASCII change
        *p = letter;
		printf("%c",letter);
        p++;
    }
   
    return letterNum;
}

int _tmain(int argc, _TCHAR* argv[])
{
	TCHAR	*List;

	GetPartitionLetterFromPhysicalDrive(0,&List);

	getchar();
	return 0;
}

 

运行结果如下 （注意，运行时需要管理员的权限）

最后一行给出了PhysicalDrive0 上的三个盘符

参考：
1.cutebunny 的BLOG “windows的磁盘操作” 可以在这里下载 WindowsDisk

我的台式机使用梅捷 SY-D2700-U3M 的主板，固化了Intel D2700 Atom CPU。具有零噪音（无风扇），节能环保，扩展丰富等等特点。唯一的问题是：经常硬盘丢失。具体是在使用中忽然BSOD，然后自动重启之后在Setup中无法找到硬盘，重启无效，必须关机一次再开机。从我的经验来看这绝非BIOS问题，并且实验确定不是硬盘问题。有人看守的情况下遇到这样的最多只是郁闷一些，但是作为下载机的时候，上述的问题就变得令人难以忍受。于是，考虑做一个硬件的 WatchDog，当出现问题的时候自动完成关闭开关，再次重启的动作。

BOM 如下：

1. Arduino UNO
2. WCH341 USB转串口
3. 面包板
4. 杜邦线+大头针
5. 继电器

说说上面这些东西，最重要的是继电器，就是下面这个东西。

这是两路的继电器，可以控制2组电路。性能指标是“交流电压最大250V，交流电流最大10A，直流电压最大30V,直流电流最大10A”。有4个输入针脚，分别是VCC GND，1IN 和2IN可以直连Arduino IO口。上电之后，1IN和2IN可以直接接入到VCC和GND上，应该能听到继电器“啪”的吸合的声音，此时测量受控端的电阻可以得知当前是断开还是链接。

再说一下喂狗的WCH341。 一般来说，Arduino的USB口可以用来取电和串口通讯。实际使用中我关闭台式机后，USB口供电也会随之切断，因此Arduino必须使用外部供电。既然使用了外部供电，串口也只能使用外部输入。刚开始选择的是FDTI 的USB转串口，一直无法正常通讯，最后测量发现它转出来的电压在 6.2v左右（TX/RX）远超过了.预期的5V。WCH341是之前玩单片机的剩下的，测量之后发现它的输出电压能够满足要求，于是就选用之。还有需要注意的是，完整的串口通讯实际上需要3跟线：TX RX和GND.

引出PowerButton的2个Pin.

继电器直接控制PowerButton Pin。

绿线接到继电器上进行控制

Arduino代码：

#include //引用库
/*
Simple LED sketch
*/

int led = 13; // Pin 13 当连接（相当于按下PowerButton）时点亮，断开时关闭
int cnt = 10; // Pin 10 控制继电器，高时断开，低时连接

unsigned long int elsp=0; //计算时间

void setup()
{
pinMode(led, OUTPUT); // Set pin 13 as digital out
pinMode(cnt, OUTPUT); // Set pin 10 as digital out
digitalWrite(led, LOW); // off
digitalWrite(cnt,HIGH); //Cut OFF

// Start up serial connection
Serial.begin(9600); //baud rate
Serial.flush();
elsp=millis();

wdt_enable(WDTO_8S); //这是Arduino的看门狗可以更换其他时间值
//注意，这里是8s，后面的延时不可以直接超过8s
}

void loop()
{

// Read any serial input
while (Serial.available() > 0)
{
if ((char) Serial.read() == ‘P’) {elsp=millis(); }
//当收到”P”时，重置计时器。换句话，我们用字符 “P” 来喂狗
}

if (abs(millis()-elsp)>300*1000UL) //300s = minutes
{
digitalWrite(led, HIGH); // on
//关机动作
digitalWrite(cnt,LOW); //继电器短路，相当于按下PowerButton
wdt_reset(); //重置Arduino内部看门狗
delay(6000); //这里相当于长按PowerButton 6s
wdt_reset(); //重置Arduino内部看门狗
digitalWrite(cnt,HIGH); //继电器断路，相当于松开PowerButton
//松开PowerButton 5s
delay(5000);
wdt_reset(); //重置Arduino内部看门狗
//开机上电
digitalWrite(cnt,LOW); //继电器短路，相当于按下PowerButton
delay(500); //按下500ms
digitalWrite(cnt,HIGH); //继电器断路，相当于松开PowerButton
elsp=millis();

digitalWrite(led, LOW); // off
wdt_reset(); //重置Arduino内部看门狗
}
delay(1000);
Serial.println(millis()-elsp);
wdt_reset(); //重置Arduino内部看门狗如果loop时间超过时限，系统会重启
}

除了Arduino的Firmware，PC端喂狗也需要一个程序。选择Delphi编写程序，实现两个功能：1.扫描COM Port找到进行通讯的端口 2.每隔一段时间就进行一次喂狗

(此处Delphi代码，Console模式)
HWDog

参考：

1. http://biosren.com/thread-6794-1-1.html 《改动代码提取器》