imdisk支持sector map扇区映射

不点 · 发表于 2018-1-25 12:06:46

在 http://reboot.pro/topic/20450-mounting-split-image/ 的 7 楼，imdisk 的开发者本人透露：

This is rather easy nowadays with ImDisk.
Simply specify a physical drive object as "image file"
and specify offset and size as -b and -s switches.
Example:

imdisk -a -f \\?\physicaldrive1 -b 200000 -s 300000 -m #:

复制代码

-f \\?\physicaldrive1 - path to physical drive object

-b 200000 = offset in bytes

-s 300000 = size in bytes (length to use after offset)

For first experiments add -o ro for read-only operation, so that ImDisk does not overwrite anything until you know that it works and you have got the right offsets and lengths.

And yes, I use this method now and then to mount secondary partitions on USB thumb drives that are not directly visible in Windows. :)

在 http://diddy.boot-land.net/firadisk/files/imdisk.htm 有个 imdisk 的教程。

在命令窗口执行 imdisk /? 命令，可以获得如下的帮助信息：

Control program for the ImDisk Virtual Disk Driver.
For copyrights and credits, type imdisk --version
Syntax:
imdisk -a -t type -m mountpoint [-n] [-o opt1[,opt2 ...]] [-f|-F file]
[-s size] [-b offset] [-v partition] [-S sectorsize] [-u unit]
[-x sectors/track] [-y tracks/cylinder] [-p "format-parameters"]
imdisk -d|-D [-u unit | -m mountpoint]
imdisk -l [-u unit | -m mountpoint]
imdisk -e [-s size] [-o opt1[,opt2 ...]] [-u unit | -m mountpoint]
-a Attach a virtual disk. This will configure and attach a virtual disk
with the parameters specified and attach it to the system.
-d Detach a virtual disk from the system and release all resources.
Use -D to force removal even if the device is in use.
-e Edit an existing virtual disk.
Along with the -s parameter extends the size of an existing virtual
disk. Note that even if the disk can be extended successfully, the
existing filesystem on it can only be extended to fill the new size
without re-formatting if you are running Windows 2000 or later and the
current filesystem is NTFS.
Along with the -o parameter changes media characteristics for an
existing virtual disk. Options that can be changed on existing virtual
disks are those specifying wether or not the media of the virtual disk
should be writable and/or removable.
-t type
Select the backingstore for the virtual disk.
vm Storage for this type of virtual disk is allocated from virtual memory
in the system process. If a file is specified with -f that file is
is loaded into the memory allocated for the disk image.
file A file specified with -f file becomes the backingstore for this
virtual disk.
proxy The actual backingstore for this type of virtual disk is controlled by
an ImDisk storage server accessed by the driver on this machine by
sending storage I/O request through a named pipe specified with -f.
-f file or -F file
Filename to use as backingstore for the file type virtual disk, to
initialize a vm type virtual disk or name of a named pipe for I/O
client/server communication for proxy type virtual disks. For proxy
type virtual disks "file" may be a COM port or a remote server
address if the -o options includes "ip" or "comm".
Instead of using -f to specify 'DOS-style' paths, such as
C:\dir\image.bin or \\server\share\image.bin, you can use -F to
specify 'NT-style' native paths, such as
\Device\Harddisk0\Partition1\image.bin. This makes it possible to
specify files on disks or communication devices that currently have no
drive letters assigned.
-l List configured devices. If given with -u or -m, display details about
that particular device.
-n When printing ImDisk device names, print only the unit number without
the \Device\ImDisk prefix.
-s size
Size of the virtual disk. Size is number of bytes unless suffixed with
a b, k, m, g, t, K, M, G or T which denotes number of 512-byte blocks,
thousand bytes, million bytes, billion bytes, trillion bytes,
kilobytes, megabytes, gigabytes and terabytes respectively. The suffix
can also be % to indicate percentage of free physical memory which
could be useful when creating vm type virtual disks. It is optional to
specify a size unless the file to use for a file type virtual disk does
not already exist or when a vm type virtual disk is created without
specifying an initialization image file using the -f or -F. If size is
specified when creating a file type virtual disk, the size of the file
used as backingstore for the virtual disk is adjusted to the new size
specified with this size option.
The size can be a negative value to indicate the size of free physical
memory minus this size. If you e.g. type -400M the size of the virtual
disk will be the amount of free physical memory minus 400 MB.
-b offset
Specifies an offset in an image file where the virtual disk begins. All
offsets of I/O operations on the virtual disk will be relative to this
offset. This parameter is particularily useful when mounting a specific
partition in an image file that contains an image of a complete hard
disk, not just one partition. This parameter has no effect when
creating a blank vm type virtual disk. When creating a vm type virtual
disk with a pre-load image file specified with -f or -F paramters, the
-b parameter specifies an offset in the image file where the image to
be loaded into the vm type virtual disk begins.
Specify auto as offset to automatically select offset for a few known
non-raw disk image file formats. Currently auto-selection is supported
for Nero .nrg and Microsoft .sdi image files.
-v partition
Specifies which partition to mount when mounting a raw hard disk image
file containing a master boot record and partitions.
Specify number 1-4 to mount a partition from the primary partition
table and 5-8 to mount a partition from an extended partition table.
-S sectorsize
Sectorsize to use for the virtual disk device. Default value is 512
bytes except for CD-ROM/DVD-ROM style devices where 2048 bytes is used
by default.
-x sectors/track
See the description of the -y option below.
-y tracks/cylinder
The -x and -y options can be used to specify a synthetic geometry.
This is useful for constructing bootable images for later download to
physical devices. Default values depends on the device-type specified
with the -o option. If the 'fd' option is specified the default values
are based on the virtual disk size, e.g. a 1440K image gets 2
tracks/cylinder and 18 sectors/track.
-p "format-parameters"
If -p is specified the 'format' command is invoked to create a
filesystem when the new virtual disk has been created.
"format-parameters" must be a parameter string enclosed within
double-quotes. The string is added to the command line that starts
'format'. You usually specify something like "/fs:ntfs /q /y", that
is, create an NTFS filesystem with quick formatting and without user
interaction.
-o option
Set or reset options.
ro Creates a read-only virtual disk. For vm type virtual disks, this
option can only be used if the -f option is also specified.
rw Specifies that the virtual disk should be read/writable. This is the
default setting. It can be used with the -e parameter to set an
existing read-only virtual disk writable.
rem Specifies that the device should be created with removable media
characteristics. This changes the device properties returned by the
driver to the system. For example, this changes how some filesystems
cache write operations.
fix Specifies that the media characteristics of the virtual disk should be
fixed media, as opposed to removable media specified with the rem
option. Fixed media is the default setting. The fix option can be used
with the -e parameter to set an existing removable virtual disk as
fixed.
saved Clears the 'image modified' flag from an existing virtual disk. This
flag is set by the driver when an image is modified and is displayed
in the -l output for a virtual disk. The 'saved' option is only valid
with the -e parameter.
Note that virtual floppy or CD/DVD-ROM drives are always read-only and
removable devices and that cannot be changed.
cd Creates a virtual CD-ROM/DVD-ROM. This is the default if the file
name specified with the -f option ends with either .iso, .nrg or .bin
extensions.
fd Creates a virtual floppy disk. This is the default if the size of the
virtual disk is any of 160K, 180K, 320K, 360K, 640K, 720K, 820K, 1200K,
1440K, 1680K, 1722K, 2880K, 123264K or 234752K.
hd Creates a virtual fixed disk partition. This is the default unless
file extension or size match the criterias for defaulting to the cd or
fd options.
ip Can only be used with proxy-type virtual disks. With this option, the
user-mode service component is initialized to connect to an ImDisk
storage server using TCP/IP. With this option, the -f switch specifies
the remote host optionally followed by a colon and a port number to
connect to.
comm Can only be used with proxy-type virtual disks. With this option, the
user-mode service component is initialized to connect to an ImDisk
storage server through a COM port. With this option, the -f switch
specifies the COM port to connect to, optionally followed by a colon,
a space, and then a device settings string with the same syntax as the
MODE command.
-u unit
Along with -a, request a specific unit number for the ImDisk device
instead of automatic allocation. Along with -d or -l specifies the
unit number of the virtual disk to remove or query.
-m mountpoint
Specifies a drive letter or mount point for the new virtual disk, the
virtual disk to query or the virtual disk to remove. When creating a
new virtual disk you can specify #: as mountpoint in which case the
first unused drive letter is automatically used.

复制代码

不点 · 发表于 2018-1-25 15:37:21

红毛樱木发表于 2018-1-25 13:11
这个一直都支持。。。您才知道啊，用了几年了。

哦，我跟不上形势了。能分享使用经验、心得体会吗？能给出优缺点的评价吗？

我想制作一个 U 盘，含两个分区：开头是 FAT32 分区，紧接着是 NTFS 分区。

NTFS 分区需要从分区表中去除掉，只留下 FAT32 分区，这样的单一分区结构，才能满足某些变态 BIOS 的要求（其实我认为那是垄断者用 BIOS 来封杀多分区启动盘，不然的话，U 盘到处能启动 Windows，尤其是低版本的 Windows，这可能不符合垄断者的利益）。

这个 NTFS 分区的数据还在，只是分区表上找不到它了。

请问，这种情况，进入 Win7 （或 Win10 PE）以后，怎么用 imdisk 来挂上这个 NTFS 分区？最好给出详细步骤。

不点 · 发表于 2018-2-25 15:34:22

sp_star 发表于 2018-2-25 14:47
64位应该是签名的原因。
由于编译环境，可能不支持xp，我在win10 x86下试过。你可以试试在xp下自己再编 ...

在 Windows 下我没有编译环境，就不试了。

sp_star · 发表于 2018-2-25 14:47:04

不点发表于 2018-2-25 13:39
Win7x64 下运行失败。出错信息：InitializeWinIo failed!
是必须签名的原因吗？
我没有 32 位 Win7 ...

64位应该是签名的原因。
由于编译环境，可能不支持xp，我在win10 x86下试过。你可以试试在xp下自己再编译一下。

不点 · 发表于 2018-2-25 13:39:35

本帖最后由不点于 2018-2-25 14:28 编辑

sp_star 发表于 2018-2-25 11:03
一个小工具，在windows下读GRUB4DOS map的磁盘信息。

Win7x64 下运行失败。出错信息：InitializeWinIo failed!
是必须签名的原因吗？
我没有 32 位 Win7 环境，现在无法测试。但稍后可以试试 XP。

【更新】
XP 下报错：对话框 “g4d.exe 不是有效的 Win32 应用程序。”

有个“确定”按钮。

点击 “确定” 按钮后，DOS 框里显示 “拒绝访问。”

回到命令提示符。

D:\G4D>dir
驱动器 D 中的卷没有标签。
卷的序列号是 0000-4823
D:\G4D 的目录
2018/02/25 13:31 <DIR> .
2018/02/25 13:31 <DIR> ..
2018/02/25 10:10 161,280 g4d.exe
2010/05/15 23:56 45,568 WinIo32.dll
2010/05/08 23:16 6,656 WinIo32.sys
2010/05/15 23:56 44,544 WinIo64.dll
2010/05/08 23:46 10,920 WinIo64.sys
5 个文件 268,968 字节
2 个目录 263,994,019,840 可用字节
D:\G4D>g4d
InitializeWinIo failed!
D:\G4D>

复制代码

不点 · 发表于 2018-2-25 13:20:09

sp_star 发表于 2018-2-25 12:04
还是使用的Winio驱动，64位时有签名问题。既然有兴趣，自己改改就可以了。

我的 Windows 编译环境建立不起来，没有缘分，已经放弃。目前我的兴趣已经彻底转到 Linux 下了。在 Linux 下可做的事多着呢，根本忙不过来，恐怕以后再也没有机会回到 Windows 下编程了。

我把你提供的代码贴出来，方便有兴趣者查看。

// mdisk.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <shellapi.h>
//#include <winable.h>
typedef BOOL(WINAPI *INITIALIZEWINTO)(void);
typedef BOOL(WINAPI *SHUTDOWNWINIO)(void);
typedef BOOL(WINAPI *GETPORTVAL)(WORD wPortAddr, PDWORD pdwPortVal, BYTE bSize);
typedef BOOL(WINAPI *SETPORTVAL)(WORD wPortAddr, DWORD dwPortVal, BYTE bSize);
typedef PBYTE(_stdcall *MAPPHYSTOLIN)(PBYTE pbPhysAddr, DWORD dwPhysSize, HANDLE *pPhysicalMemoryHandle);
typedef BOOL(_stdcall *UNMAPPHYSICALMEMORY)(HANDLE PhysicalMemoryHandle, PBYTE pbLinAddr);
typedef BOOL(WINAPI *GETPHYSLONG)(PBYTE pbPhysAddr, PDWORD pdwPhysVal);
typedef BOOL(WINAPI *SETPHYSLONG)(PBYTE pbPhysAddr, DWORD dwPhysVal);
//typedef BOOL(WINAPI *INSTALLWINIODRIVER)(PWSTR pszWinIoDriverPath, bool IsDemandLoaded = false); 　
//typedef BOOL(WINAPI *REMOVEWINIODRIVER)();
INITIALIZEWINTO InitializeWinIo = NULL;
SHUTDOWNWINIO ShutdownWinIo = NULL;
GETPORTVAL GetPortVal = NULL;
SETPORTVAL SetPortVal = NULL;
MAPPHYSTOLIN MapPhysToLin = NULL;
UNMAPPHYSICALMEMORY UnmapPhysicalMemory = NULL;
GETPHYSLONG GetPhysLong = NULL;
SETPHYSLONG SetPhysLong = NULL;
//INSTALLWINIODRIVER InstallWinIoDriver = NULL;
//REMOVEWINIODRIVER RemoveWinIoDriver = NULL;
BOOL InitFuncs(void)
{
HMODULE hMod = LoadLibrary(_T("WinIo32.dll"));
InitializeWinIo= (INITIALIZEWINTO)GetProcAddress(hMod,"InitializeWinIo");
ShutdownWinIo= (SHUTDOWNWINIO)GetProcAddress(hMod,"ShutdownWinIo");
GetPortVal= (GETPORTVAL)GetProcAddress(hMod,"GetPortVal");
SetPortVal= (SETPORTVAL)GetProcAddress(hMod,"SetPortVal");
MapPhysToLin=(MAPPHYSTOLIN)GetProcAddress(hMod,"MapPhysToLin");
UnmapPhysicalMemory=(UNMAPPHYSICALMEMORY)GetProcAddress(hMod,"UnmapPhysicalMemory");
GetPhysLong=(GETPHYSLONG)GetProcAddress(hMod,"GetPhysLong");
SetPhysLong=(SETPHYSLONG)GetProcAddress(hMod,"SetPhysLong");
//InstallWinIoDriver=(INSTALLWINIODRIVER)GetProcAddress(hMod,"InstallWinIoDriver");
//RemoveWinIoDriver=(REMOVEWINIODRIVER)GetProcAddress(hMod,"RemoveWinIoDriver");
if(InitializeWinIo==NULL) return FALSE;
if(ShutdownWinIo==NULL) return FALSE;
if(GetPortVal==NULL) return FALSE;
if(SetPortVal==NULL) return FALSE;
if(MapPhysToLin==NULL) return FALSE;
if(UnmapPhysicalMemory==NULL) return FALSE;
if(GetPhysLong==NULL) return FALSE;
if(SetPhysLong==NULL) return FALSE;
//if(InstallWinIoDriver==NULL) return FALSE;
//if(RemoveWinIoDriver==NULL) return FALSE;
return TRUE;
}
BOOL ReadPhysicalMemory(unsigned int phyAddr, DWORD phySize, unsigned char *buf)
{
unsigned int addr;
unsigned long data;
unsigned long *p=(unsigned long *)buf;
for(unsigned int i=0;i<phySize;i+=4)
{
addr=phyAddr+i;
GetPhysLong((PBYTE)addr,&data);
*p=data;
p++;
}
return TRUE;
}
void print_buf(unsigned char *p)
{
for(int k=0;k<200;k++)
{
printf("%c",*(p+k));
}
printf("\n");
}
void find_g4d_drive(unsigned char* buf, int bufLen);
int _tmain(int argc, _TCHAR* argv[])
{
if(InitFuncs()!=TRUE)
{
printf("Load WinIo.dll failed!\n");
return 0;
}
if(InitializeWinIo()!=TRUE)
{
printf("InitializeWinIo failed!\n");
return 0;
}
printf("InitializeWinIo OK!\n");
printf("\n");
//printf("DWORD length=%d\n",sizeof(DWORD));
#if 0
HANDLE hPhyMem;
PBYTE pbLinAddr;
//下面的语句让 0xf0000 地址的 65536 个字节可直接读写
pbLinAddr = MapPhysToLin((unsigned char *)0xf0000,65536,&hPhyMem);
printf("pbLinAddr=%x\n",pbLinAddr);
DWORD ttmp;
BOOL rtv;
rtv=GetPhysLong((PBYTE)0xf0000,&ttmp);
printf("rtv=%d, ttmp=%x\n",rtv, ttmp);
#endif
// real-mode RAM range 0-640KB
const int nBytes=0xA0000;
unsigned char buf[nBytes];
memset(buf,0,nBytes);
ReadPhysicalMemory(0,nBytes,buf);
//print_buf(buf);
find_g4d_drive(buf,nBytes);
ShutdownWinIo();
printf("Done!\n");
return 0;
}
typedef struct _INTRVECT {
UINT16 offset;
UINT16 segment;
} INTRVECT, *PINTRVECT;
typedef struct _GRUB4DOS_DRIVE_MAP_SLOT {
unsigned char from_drive;
unsigned char to_drive; // 0xFF indicates a memdrive
unsigned char max_head;
unsigned char max_sector:6,
disable_lba:1, // bit 6: disable lba
read_only:1; // bit 7: read only
unsigned short to_cylinder:13, // max cylinder of the TO drive
from_cdrom:1, // bit 13: FROM drive is CDROM(with big 2048-byte sector)
to_cdrom:1, // bit 14: TO drive is CDROM(with big 2048-byte sector)
to_support_lba:1; // bit 15: TO drive support LBA
unsigned char to_head; // max head of the TO drive
unsigned char to_sector:6, // max sector of the TO drive
fake_write:1, // bit 6: fake-write or safe-boot
in_situ:1; // bit 7: in-situ
UINT64 start_sector;
UINT64 sector_count;
} GRUB4DOS_DRIVE_MAP_SLOT, *PGRUB4DOS_DRIVE_MAP_SLOT;
void print_drv_map(PGRUB4DOS_DRIVE_MAP_SLOT slot)
{
int dataLen=sizeof(GRUB4DOS_DRIVE_MAP_SLOT);
printf("DATA: ");
for(int k=0;k<dataLen;k++)
{
printf("%.2X ", *((unsigned char *)slot+k) );
}
printf("\n");
UINT64 drvlen=slot->sector_count<<9;
UINT64 address=slot->start_sector<<9;
printf("Detected GRUB4DOS disk offset=0x%I64x bytes, len=%I64d KB\n",address, drvlen>>10);
printf(" GRUB4DOS SourceDrive: 0x%02x\n", slot->from_drive);
printf(" GRUB4DOS DestDrive: 0x%02x\n", slot->to_drive);
printf(" GRUB4DOS MaxHead: %d\n", slot->max_head);
printf(" GRUB4DOS MaxSector: %d\n", slot->max_sector);
printf(" GRUB4DOS DestMaxCylinder: %d\n", slot->to_cylinder);
printf(" GRUB4DOS DestMaxHead: %d\n", slot->to_head);
printf(" GRUB4DOS DestMaxSector: %d\n", slot->to_sector);
printf(" GRUB4DOS SectorStart: 0x%08x\n", slot->start_sector);
printf(" GRUB4DOS SectorCount: %d\n", slot->sector_count);
printf("\n");
printf(" GRUB4DOS disable_lba=%d\n", slot->disable_lba);
printf(" GRUB4DOS read_only=%d\n", slot->read_only);
printf(" GRUB4DOS from_cdrom=%d\n", slot->from_cdrom);
printf(" GRUB4DOS to_cdrom=%d\n", slot->to_cdrom);
printf(" GRUB4DOS to_support_lba=%d\n", slot->to_support_lba);
printf(" GRUB4DOS fake_write=%d\n", slot->fake_write);
printf(" GRUB4DOS in_situ=%d\n", slot->in_situ);
}
void print_vector(INTRVECT * pvec)
{
printf("offset=0x%.4x ", pvec->offset);
printf("segment=0x%.4x", pvec->segment);
printf("\n");
}
void print_string(unsigned char *buf,UINT32 int13entry)
{
unsigned char tmp_str[9];
memset(tmp_str,0,9);
memcpy(tmp_str,buf+int13entry+3,8);
printf("%s ",tmp_str);
memset(tmp_str,0,9);
memcpy(tmp_str,buf+int13entry+3+8,8);
printf("%s\n",tmp_str);
}
int check_string(unsigned char *buf,UINT32 int13entry)
{
int cmp=-1;
unsigned char tmp_str[9];
memset(tmp_str,0,9);
memcpy(tmp_str,buf+int13entry+3,8);
cmp = strcmp((char *)tmp_str,"$INT13SF");
if(cmp!=0) return 0;
memset(tmp_str,0,9);
memcpy(tmp_str,buf+int13entry+3+8,8);
cmp = strcmp((char *)tmp_str,"GRUB4DOS");
if(cmp==0)
{
//printf("Found GRUB4DOS\n");
return 1;
}
return 0;
}
void find_g4d_drive(unsigned char* buf, int bufLen)
{
//bufLen=0xA0000; //640K
INTRVECT int13vector;
UINT32 int13entry;
int found=0;
/*for(int kk=0;kk<0x40;kk++)
{
int13vector = ((PINTRVECT)buf)[kk];
int13entry = (((UINT32)int13vector.segment << 4) + int13vector.offset);
printf("int13entry=0x%lX [%.4X:%.4X]\n",int13entry,int13vector.segment,int13vector.offset);
}
printf("\n");
return;
*/
int13vector = ((PINTRVECT)buf)[0x13];
int13entry = (((UINT32)int13vector.segment << 4) + int13vector.offset);
while(int13entry<0xA0000-27)
{
//if(int13entry==0) continue;
printf("int13entry=0x%lX [%.4X:%.4X]\n",int13entry,int13vector.segment,int13vector.offset);
found=check_string(buf,int13entry);
if(found==1)
{
PGRUB4DOS_DRIVE_MAP_SLOT pdrvmap;
//drive map slot starts at offset 0x20 of the same segment as int13 entry
pdrvmap = (PGRUB4DOS_DRIVE_MAP_SLOT)(buf+(((UINT32)int13vector.segment << 4) + 0x20));
printf("Found GRUBDOS drive at offset 0x%lX [%.4X:%.4X], data length=%d bytes\n",
(unsigned char *)pdrvmap-buf,int13vector.segment,0x20,
sizeof(GRUB4DOS_DRIVE_MAP_SLOT) );
printf("\n");
print_drv_map(pdrvmap);
printf("\n");
}
int13vector = *((UNALIGNED INTRVECT *)(buf+int13entry+3+8+8));
int13entry = (((UINT32)int13vector.segment << 4) + int13vector.offset);
//printf("==>int13entry=0x%lX [%.4X:%.4X]\n",int13entry,int13vector.segment,int13vector.offset);
}
}

复制代码

sp_star · 发表于 2018-2-25 12:04:04

不点发表于 2018-2-25 11:42
前面有个闭源的工具可以显示出物理内存。

既然你能读 map 信息，想必你一定也能 cat 出物理内存。你能 ...

还是使用的Winio驱动，64位时有签名问题。既然有兴趣，自己改改就可以了。

不点 · 发表于 2018-2-25 11:42:43

sp_star 发表于 2018-2-25 11:03
一个小工具，在windows下读GRUB4DOS map的磁盘信息。

前面有个闭源的工具可以显示出物理内存。

既然你能读 map 信息，想必你一定也能 cat 出物理内存。你能否写个工具，显示物理内存的内容呢？命令行工具即可，不需要图形界面。最好能 open source。

sp_star · 发表于 2018-2-25 11:03:13

一个小工具，在windows下读GRUB4DOS map的磁盘信息。

527104427 · 发表于 2018-2-13 00:04:17

chenall 发表于 2018-2-12 20:46
我也是用windows 7的安装了vs 2017可以正常使用呀，编译驱动还需要安装winddk.我之前有测试编译imdisk，编 ...

我以前编译成功过，记得是用WDK 7.1.0，貌似不用改什么东西啊。

苏州本是 · 发表于 2018-2-12 23:44:17

dos时代菜鸟发表于 2018-1-28 09:38
vbs脚本

谢谢分享好东西！

不点 · 发表于 2018-2-12 22:56:54

本帖最后由不点于 2018-2-12 22:58 编辑

谁能编译这一句，就算成功：

MmMapIoSpace(0, 0, 0);

firadisk 和 winvblock 都使用了这个 API。如果编译成功，修改一下，就能把物理内存 dump 出来。

只要能 dump 出物理内存，事情就简单了。我们现在就卡在不能访问物理内存上了。

前面的那个闭源软件能够访问物理内存，可惜是闭源的。

在网上搜了许多天，也见不到一个能够在（新近的） Windows 下 dump 物理内存的开源工具。前面介绍的那个开源的工具只能在 xp 上运行。

不点 · 发表于 2018-2-12 22:33:50

chenall 发表于 2018-2-12 20:46
我也是用windows 7的安装了vs 2017可以正常使用呀，编译驱动还需要安装winddk.我之前有测试编译imdisk，编 ...

能力有限，精力、时间、身体都不允许。放弃。也不会再去英文论坛给别人解释什么了，我的英文太 poor，费劲。

有难度的事情，我一下子都失去信心了。

顺其自然，谁愿意干啥就干啥。不勉强自己，也不勉强别人。

一切皆缘分，没办法。有缘和没缘。最后还是得老老实实在 Linux 下捣鼓。

chenall · 发表于 2018-2-12 20:46:18

本帖最后由 chenall 于 2018-2-12 20:47 编辑

我也是用windows 7的安装了vs 2017可以正常使用呀，编译驱动还需要安装winddk.我之前有测试编译imdisk，编译没有通过，应该还需要做一些设置．

没有编译过驱动，搞不懂如何编译，我看了imdisk的源码介绍，应该是可以直接用nmake编译的，不过还是失败了．有一些报错．

也许你可以把这些需求到reboot回复给作者看看他能不能直接加上．毕竟我们如果自己要编译的话那个签名就是一个大麻烦．

不点 · 发表于 2018-2-12 18:45:44

我在 win7 下安装了 Visual Studio 2017，结果不能编译任何程序。它要求操作系统是 Win10。

难度太大，这个帖子的讨论，我就不再来了，抱歉。有兴趣者，你们可以继续。

不点 · 发表于 2018-2-12 17:27:36

sp_star 发表于 2018-2-12 17:08
关键是改了驱动就没有签名了啊。
不然，直接修改firadisk 或 winvblock就可以了。当然这2个本来也没签名 ...

确实是个问题。可以提交给原作者进行签名。

再有就是，干脆就增强 firadisk 或 winvblock 也行。

哪个途径容易编译，就采用那个途径。具体编译的人，看情况决定。

我估计，firadisk 的功能最完善。

firadisk 支持高位内存，winvblock 不支持。
firadisk 和 winvblock 支持物理内存，而 imdisk （有可能）不支持。
winvblock 和 imdisk 支持纯扇区序列，而 firadisk 不支持。

总体感觉，firadisk 毛病不严重，其毛病容易解决。

sp_star · 发表于 2018-2-12 17:08:52

不点发表于 2018-2-12 17:02
映射物理内存，我觉得不难，imdisk 应该可以做到。

已知 firadisk 和 winvblock 都能访问物理内存。

关键是改了驱动就没有签名了啊。
不然，直接修改firadisk 或 winvblock就可以了。当然这2个本来也没签名。

不点 · 发表于 2018-2-12 17:02:51

sp_star 发表于 2018-2-12 16:31
grub4dos的信息应该是在低位内存吧? 即使实际磁盘在高位内存，也要靠imdisk去处理。如果知道ramdisk在内 ...

映射物理内存，我觉得不难，imdisk 应该可以做到。

已知 firadisk 和 winvblock 都能访问物理内存。

imdisk 至少能够访问线性地址。

不过，即使 imdisk 不能访问物理地址，也能够给它添加这个功能（从 firadisk 或 winvblock 复制代码即可）。

sp_star · 发表于 2018-2-12 16:31:18

不点发表于 2018-2-12 15:32
试验过了，完全能读出物理内存啊。

只需验证 XP 下能否读高位内存即可。Win7x64 已经验证成功。

grub4dos的信息应该是在低位内存吧? 即使实际磁盘在高位内存，也要靠imdisk去处理。如果知道ramdisk在内存中的地址和大小，imdisk能直接映射吗?

不点 · 发表于 2018-2-12 15:32:34

sp_star 发表于 2018-2-12 14:03
这个工具是.net的，没运行起来。可以试试读取0~1M的内存，看看grub4dos的信息能不能找到。
里面还有个phys ...

试验过了，完全能读出物理内存啊。

只需验证 XP 下能否读高位内存即可。Win7x64 已经验证成功。

sp_star · 发表于 2018-2-12 14:03:28

这个工具是.net的，没运行起来。可以试试读取0~1M的内存，看看grub4dos的信息能不能找到。
里面还有个physmem.sys驱动，好像签名齐全啊，只是不知道怎么用。

不点 · 发表于 2018-2-12 07:35:33

本帖最后由不点于 2018-2-12 12:08 编辑

找到了一个闭源的查看物理内存的工具，德语的界面，可能不太方便：

https://kb.hilscher.com/display/CIFXDRV/Physical+Memory+Viewer+for+Windows

在 XP 和 Win7x64 试验了，能够查看物理内存的内容。

Win7x64 下还可以查看超过 4G 的高位内存。

谁能试试，看看在 XP （32 位）之下能否查看高于 4G 的物理内存地址的内容？

（点击上面的网址，下载原网站上的文件，不需要币值）

不点 · 发表于 2018-2-12 06:54:26

访问物理内存，找到如下代码，但不知这个代码能否在新版 Windows 下工作：

http://nah6.com/~itsme/cvs-xdadevtools/itsutils/src/sysint-physmem.cpp

//========================================================
//
// Physmem
//
// Mark Russinovich
// Systems Internals
// http://www.sysinternals.com
//
// This program demonstrates how you can open and
// map physical memory. This is essentially the NT
// equivalent of the \dev\kmem device in UNIX.
//
//========================================================
#include <util/wintypes.h>
#include "debug.h"
//#include <stdio.h>
//#include "native.h"
//========================================================
//
// Native.h
//
// Mark Russinovich
// Systems Internals
// http://www.sysinternals.com
//
// This file contains tyepdefs and defines from NTDDK.H.
// They are included here so that we don't have to
// include NTDDK.H and get all the other stuff that
// we don't really need or want.
//
//========================================================
#define PAGE_NOACCESS 0x01 // winnt
#define PAGE_READONLY 0x02 // winnt
#define PAGE_READWRITE 0x04 // winnt
#define PAGE_WRITECOPY 0x08 // winnt
#define PAGE_EXECUTE 0x10 // winnt
#define PAGE_EXECUTE_READ 0x20 // winnt
#define PAGE_EXECUTE_READWRITE 0x40 // winnt
#define PAGE_EXECUTE_WRITECOPY 0x80 // winnt
#define PAGE_GUARD 0x100 // winnt
#define PAGE_NOCACHE 0x200 // winnt
typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS; // windbgkd
typedef LONG NTSTATUS;
#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
#ifdef MIDL_PASS
[size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT * Buffer;
#else // MIDL_PASS
PWSTR Buffer;
#endif // MIDL_PASS
} UNICODE_STRING;
typedef UNICODE_STRING *PUNICODE_STRING;
typedef enum _SECTION_INHERIT {
ViewShare = 1,
ViewUnmap = 2
} SECTION_INHERIT;
#define OBJ_INHERIT 0x00000002L
#define OBJ_PERMANENT 0x00000010L
#define OBJ_EXCLUSIVE 0x00000020L
#define OBJ_CASE_INSENSITIVE 0x00000040L
#define OBJ_OPENIF 0x00000080L
#define OBJ_OPENLINK 0x00000100L
#define OBJ_VALID_ATTRIBUTES 0x000001F2L
typedef struct _OBJECT_ATTRIBUTES {
ULONG Length;
HANDLE RootDirectory;
PUNICODE_STRING ObjectName;
ULONG Attributes;
PVOID SecurityDescriptor; // Points to type SECURITY_DESCRIPTOR
PVOID SecurityQualityOfService; // Points to type SECURITY_QUALITY_OF_SERVICE
} OBJECT_ATTRIBUTES;
typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES;
#define InitializeObjectAttributes( p, n, a, r, s ) { \
(p)->Length = sizeof( OBJECT_ATTRIBUTES ); \
(p)->RootDirectory = r; \
(p)->Attributes = a; \
(p)->ObjectName = n; \
(p)->SecurityDescriptor = s; \
(p)->SecurityQualityOfService = NULL; \
}
//
// Functions in NTDLL that we dynamically locate
//
typedef NTSTATUS (__stdcall *PFN_NtUnmapViewOfSection)(
IN HANDLE ProcessHandle,
IN PVOID BaseAddress
);
typedef NTSTATUS (__stdcall *PFN_NtOpenSection)(
OUT PHANDLE SectionHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes
);
typedef NTSTATUS (__stdcall *PFN_NtMapViewOfSection)(
IN HANDLE SectionHandle,
IN HANDLE ProcessHandle,
IN OUT PVOID *BaseAddress,
IN ULONG ZeroBits,
IN ULONG CommitSize,
IN OUT PLARGE_INTEGER SectionOffset, /* optional */
IN OUT PULONG ViewSize,
IN SECTION_INHERIT InheritDisposition,
IN ULONG AllocationType,
IN ULONG Protect
);
typedef VOID (__stdcall *PFN_RtlInitUnicodeString)(
IN OUT PUNICODE_STRING DestinationString,
IN PCWSTR SourceString
);
typedef ULONG (__stdcall *PFN_RtlNtStatusToDosError) (
IN NTSTATUS Status
);
PFN_NtUnmapViewOfSection NtUnmapViewOfSection;
PFN_NtOpenSection NtOpenSection;
PFN_NtMapViewOfSection NtMapViewOfSection;
PFN_RtlInitUnicodeString RtlInitUnicodeString;
PFN_RtlNtStatusToDosError RtlNtStatusToDosError;
//--------------------------------------------------------
//
// UnmapPhysicalMemory
//
// Maps a view of a section.
//
//--------------------------------------------------------
VOID UnmapPhysicalMemory( DWORD Address )
{
NTSTATUS status;
status = NtUnmapViewOfSection( (HANDLE) -1, (PVOID) Address );
if( !NT_SUCCESS(status)) {
error(status, "Unable to unmap view");
}
}
//--------------------------------------------------------
//
// MapPhysicalMemory
//
// Maps a view of a section.
//
//--------------------------------------------------------
BOOLEAN MapPhysicalMemory( HANDLE PhysicalMemory,
PDWORD Address, PDWORD Length,
PDWORD VirtualAddress )
{
NTSTATUS ntStatus;
PHYSICAL_ADDRESS viewBase;
*VirtualAddress = 0;
viewBase.QuadPart = (ULONGLONG) (*Address);
ntStatus = NtMapViewOfSection (PhysicalMemory,
(HANDLE) -1,
(PVOID*) VirtualAddress,
0L,
*Length,
&viewBase,
Length,
ViewShare,
0,
PAGE_READONLY );
if( !NT_SUCCESS( ntStatus )) {
//error( ntStatus, "Could not map view of %X length %X", *Address, *Length );
return FALSE;
}
*Address = viewBase.LowPart;
return TRUE;
}
//--------------------------------------------------------
//
// OpensPhysicalMemory
//
// This function opens the physical memory device. It
// uses the native API since
//
//--------------------------------------------------------
HANDLE OpenPhysicalMemory()
{
NTSTATUS status;
HANDLE physmem;
UNICODE_STRING physmemString;
OBJECT_ATTRIBUTES attributes;
WCHAR physmemName[] = L"\\device\\physicalmemory";
RtlInitUnicodeString( &physmemString, physmemName );
InitializeObjectAttributes( &attributes, &physmemString,
OBJ_CASE_INSENSITIVE, NULL, NULL );
status = NtOpenSection( &physmem, SECTION_MAP_READ, &attributes );
if( !NT_SUCCESS( status )) {
error(status, "Could not open \\device\\physicalmemory");
return NULL;
}
return physmem;
}
//--------------------------------------------------------
//
// LocateNtdllEntryPoints
//
// Finds the entry points for all the functions we
// need within NTDLL.DLL.
//
//--------------------------------------------------------
BOOLEAN LocateNtdllEntryPoints()
{
if( !(RtlInitUnicodeString = (PFN_RtlInitUnicodeString) GetProcAddress( GetModuleHandle("ntdll.dll"),
"RtlInitUnicodeString" )) ) {
return FALSE;
}
if( !(NtUnmapViewOfSection = (PFN_NtUnmapViewOfSection) GetProcAddress( GetModuleHandle("ntdll.dll"),
"NtUnmapViewOfSection" )) ) {
return FALSE;
}
if( !(NtOpenSection = (PFN_NtOpenSection) GetProcAddress( GetModuleHandle("ntdll.dll"),
"NtOpenSection" )) ) {
return FALSE;
}
if( !(NtMapViewOfSection = (PFN_NtMapViewOfSection) GetProcAddress( GetModuleHandle("ntdll.dll"),
"NtMapViewOfSection" )) ) {
return FALSE;
}
if( !(RtlNtStatusToDosError = (PFN_RtlNtStatusToDosError) GetProcAddress( GetModuleHandle("ntdll.dll"),
"RtlNtStatusToDosError" )) ) {
return FALSE;
}
return TRUE;
}
#if 0
//--------------------------------------------------------
//
// Main
//
// This program drives the command loop
//
//--------------------------------------------------------
int main( int argc, char *argv[] )
{
HANDLE physmem;
DWORD vaddress, paddress, length;
char input[256];
DWORD lines;
char ch;
DWORD i, j;
printf("\nPhysmem v1.0: physical memory viewer\n"
"By Mark Russinovich\n"
"Systems Internals - http://www.sysinternals.com\n\n");
//
// Load NTDLL entry points
//
if( !LocateNtdllEntryPoints() ) {
printf("Unable to locate NTDLL entry points.\n\n");
return -1;
}
//
// Open physical memory
//
if( !(physmem = OpenPhysicalMemory())) {
return -1;
}
//
// Enter the command loop
//
printf("Enter values in hexadecimal. Enter 'q' to quit.\n");
while( 1 ) {
printf("\nAddress: " ); fflush( stdout );
gets( input );
if( input[0] == 'q' || input[0] == 'Q' ) break;
sscanf( input, "%x", &paddress );
printf("Bytes: "); fflush( stdout );
gets( input );
if( input[0] == 'q' || input[0] == 'Q' ) break;
sscanf( input, "%x", &length );
//
// Map it
//
if( !MapPhysicalMemory( physmem, &paddress, &length,
&vaddress ))
continue;
//
// Dump it
//
lines = 0;
for( i = 0; i < length; i += BYTESPERLINE ) {
printf("%08X: ", paddress + i );
for( j = 0; j < BYTESPERLINE; j++ ) {
if( i+j == length ) break;
if( j == BYTESPERLINE/2 ) printf("-" );
printf("%02X ", *(PUCHAR) (vaddress + i +j ));
}
for( j = 0; j < BYTESPERLINE; j++ ) {
if( i+j == length ) break;
ch = *(PUCHAR) (vaddress + i +j );
if( __iscsym( ch ) ||
isalnum( ch ) ||
ch == ' ') {
printf("%c", ch);
} else {
printf("." );
}
}
printf("\n");
if( lines++ == LINESPERSCREEN ) {
printf("-- more -- ('q' to abort)" ); fflush(stdout);
ch = getchar();
if( ch == 'q' || ch == 'Q' ) {
fflush( stdin );
break;
}
lines = 0;
}
}
//
// Unmap the view
//
UnmapPhysicalMemory( vaddress );
}
//
// Close physical memory section
//
CloseHandle( physmem );
return 0;
}
#endif

复制代码

不点 · 发表于 2018-2-11 22:30:36

搜到一篇好文，备忘（使用了未公开的功能，不具有通用性，但确实是一篇好文，从技术上来说）：

Calling BIOS from Driver in Windows XP x64

http://x86asm.net/articles/calling-bios-from-driver-in-windows-xp-x64/

sp_star · 发表于 2018-2-11 22:09:24

不点发表于 2018-2-11 18:09
又想到一个方面的问题，提出来，供大家讨论、研究。

我们先前的开源虚拟盘驱动大致有三个（仅就我们感兴 ...

瞎猜的......
================================
看firadisk的实现，好像就是在0~64K这一段内存中直接查找grub4dos映射的磁盘，主要就是需要访问物理内存的权限，这要在驱动中完成，驱动又需要签名。
如果imdisk愿意实现，应该很简单，只要找到grub4dos的ramdisk的位置信息就可以映射了。
如果imdisk没有实现，需要一个第三方程序找到grub4dos的ramdisk的位置信息，调用imdisk来映射。这个第三方程序可能要能访问物理内存。

freesoft00 · 发表于 2018-2-11 21:50:16

不点发表于 2018-2-11 18:09
又想到一个方面的问题，提出来，供大家讨论、研究。

我们先前的开源虚拟盘驱动大致有三个（仅就我们感兴 ...

可以考虑把想法和imdisk作者说说，看他是否可以把需要的功能添加上去。

不点 · 发表于 2018-2-11 18:09:37

又想到一个方面的问题，提出来，供大家讨论、研究。

我们先前的开源虚拟盘驱动大致有三个（仅就我们感兴趣的而言）。其中 firadisk 和 winvblock 都是为 bios 启动程序在实模式阶段所建立的虚拟盘提供驱动的。

而 imdisk 则不为这样的目的服务。imdisk 能够接受命令行参数，直接提供磁盘虚拟功能。

imdisk 不依赖于 grub4dos 或 memdisk 在内存中建立的虚拟盘数据结构，而直接进行 “一般化” 的操作，具有 “一般性” （或 “通用”）的那种方便（也可以说是一种 “美感”）。

因此我想，也许我们可以换个思路，利用 imdisk 的这种美感，或者向 imdisk 的这种美感 “靠拢”。

好了，就不 “云里雾里”、“海阔天空” 了，直接来 “干货”：

我们有时候需要在没有 grub4dos 的情况下使用虚拟盘功能。比如，可见 FAT + 隐藏 NTFS 的 U 盘，插在电脑上（可能是别人的电脑），而且电脑不是从 U 盘启动的。此时，我们仅仅希望 imdisk 能够自动挂上隐藏了的 NTFS 卷。注意此时没有 grub4dos，内存中也就不可能存在 grub4dos 的虚拟盘数据结构。此时，firadisk 和 winvblock 都无法起作用。

这一情况就暴露出 firadisk 和 winvblock 的弱点了——它们专用于 grub4dos（或 memdisk），不能脱离 grub4dos（或 memdisk）而成为应用更加广泛的一般化的虚拟磁盘工具。

假如一个磁盘虚拟工具（比如 imdisk）能够识别出任意一个卷（例如 U 盘）上的特定文件（比如叫做 drivemap.tab，含义是 “驱动器映射记录”），该文件含有 “虚拟盘和扇区序列相关信息”。imdisk 一旦检测到这一信息，就按照信息的指示，自动挂上相应的虚拟盘。除了让 imdisk 能够识别卷（即某分区）上的控制文件以外，还可以让 imdisk 在内存中寻找虚拟盘的指示信息，一旦找到，就自动挂上相应的虚拟盘。

就是说，imdisk 不仅可以识别内存中的虚拟盘指示信息，也可以识别卷上含有虚拟盘指示信息的特定文件。如此一来，imdisk 的用法就自由了，应用范围也就扩大了。就是说，无论有没有 grub4dos 的存在，imdisk 都可以自动挂上虚拟盘。另一方面，grub4dos 也可以把内存中的虚拟盘信息拷贝到磁盘文件（drivemap.tab）里面，这样，imdisk 就能够从磁盘上发现 grub4dos 所提供的虚拟盘信息了。

总的来说，需要着力改造的是 imdisk，而不是 grub4dos。改造 imdisk 需要做大量工作，而 grub4dos 可能只需少量改造，就是前述 “在内存盘 (99) 中增加一些扇区信息” 罢了。

不点 · 发表于 2018-2-11 11:31:33

本帖最后由不点于 2018-2-11 11:42 编辑

有个问题，不知在 Windows 保护模式下，能否暂时回到实模式，执行 int13 读盘，然后再返回保护模式。

如果可行的话，那就好办了。

Win98 是可以的，估计 NT 以后都不行了。

如果不行的话，还真得从 grub4dos 身上“打主意” 了。用一个内存盘，类似于 firadisk 的 (99) 或 winvblock 的 (55)，用来存放各种信息。内存盘可以弄大一点，比如 32K，这样可以存放很多信息。

imdisk 只需读取这个内存盘信息，即可知道该怎么建立虚拟盘了。

赶紧行动！最好由 chenall 和 yaya 设计这个内存盘的格式，尽量兼容 firadisk 和 winvblock（我从未接触过，对它们都不了解）。还有谁能帮忙在 Windows 下编译软件的，请主动出手（由于 imdisk 需要进行相应的调整，因此需要编译）。我目前只能提供思路，尽自己所能吧。

【补充】不可能同时兼容 (99) 和 (55)。只需兼容 firadisk 的 (99) 即可。就是说，我们也采用 (99) 这个盘号，格式尽量与 firadisk 完全兼容，只不过我们的内存盘要大得多，能放下几十个扇区数据。

为什么要兼容 firadisk 而不是兼容 winvblock 呢？因为 winvblock 不需要兼容。winvblock 功能强，能支持纯扇区映射，大家通常都不需要 (55) 里面的信息。而 firadisk 在这方面就做得不太好了，它需要 (99) 里面的信息，否则，它根本就无法成功。

不点 · 发表于 2018-2-11 09:26:16

chenall 发表于 2018-2-11 09:19
我觉得把firadisk、winvblock的一些特性整合进imdisk是最理想的,因为imdisk已经实现了所有需要的功能, 整合 ...

chenall 你必须帮忙。你只要有编译环境即可，不需要懂得很多驱动开发知识。主要的代码，在这三个软件当中可能都有了，所需要的仅仅是局部改进而已。

chenall · 发表于 2018-2-11 09:19:43

我觉得把firadisk、winvblock的一些特性整合进imdisk是最理想的,因为imdisk已经实现了所有需要的功能, 整合其实主要是作一些映射处理.

不懂驱动开发,帮不上忙.

不点 · 发表于 2018-2-11 07:55:18

本帖最后由不点于 2018-2-11 08:29 编辑

找到 WinVblock 的处理方法了（见下面代码）。果然有磁盘签名的处理！【更正】遗憾，不是检查磁盘签名，而只是检查 mbr 尾部的 55 AA 标志。

如果扇区数据所在介质是软盘，则拒绝处理（这是没问题的，因为现在没有软盘了，而 U 盘在 Windows 下会被识别为硬盘）。
如果扇区数据所在介质是硬盘，则先检查硬盘上的磁盘签名，如果匹配（通常都能匹配），则成功；如果不匹配，继续检查扇区序列尾部是否 VHD 格式，如果是的，也成功。（我认为 VHD 格式就不用检查了，但可以增加检查虚拟盘第一扇区的内容，见接下来的详述）
如果扇区数据所在介质是光盘，则检查光盘上的 "CD001" 标识符，如果匹配，则成功。

我觉得可以改进一下，无论数据介质是在硬盘还是光盘上，再增加一个检查，即，检查该盘相应于扇区序列的第一扇区内容是否正好是虚拟盘的第一扇区内容，如果不是，则失败。这要求驱动程序在实模式已经保存好虚拟盘的第一扇区。如果虚拟盘是虚拟光盘，则保存含有 "CD001" 的那个扇区（只保存512字节就行）。如果觉得 512 字节太多，可以考虑只保存扇区的 “校验和”（4字节）。

【补充】好的，既然知道了 winvblock 并未使用磁盘签名技术，我们就可以改进了，即，使用磁盘签名，或者干脆使用整个 mbr 扇区，即可唯一确定数据介质所在的物理盘。在实模式阶段，保存所有物理盘的第一扇区数据，同时也保存所有虚拟盘的第一扇区数据。这样，在保护模式就可以对比确认了。

/**
* Check if a disk might be the matching backing disk for
* a GRUB4DOS sector-mapped disk.
*
* @v file HANDLE to an open disk.
* @v filedisk Points to the filedisk to match against.
*/
static BOOLEAN STDCALL WvFilediskG4dCheckDiskMatch_(
IN HANDLE file,
IN WV_SP_FILEDISK_T filedisk
) {
BOOLEAN ok = FALSE;
switch (filedisk->disk->Media) {
case WvlDiskMediaTypeFloppy:
break;
case WvlDiskMediaTypeHard:
ok = WvFilediskG4dCheckDiskMatchMbrSig_(file, filedisk);
if (ok)
break;
ok = WvFilediskG4dCheckDiskMatchVHD_(file, filedisk);
break;
case WvlDiskMediaTypeOptical:
ok = WvFilediskG4dCheckDiskMatchIsoSig_(file, filedisk);
break;
}
return ok;
}

复制代码

gnuxwy · 发表于 2018-2-10 17:31:51

嗯，大师辛苦了。。。很有趣的解决问题办法。。。可以拓展启动思路。

		自动登录	找回密码
密码			注册

imdisk支持sector map扇区映射

点评

评分

点评

点评

点评

评分

点评

点评

评分

点评

点评

点评

点评

点评

点评

点评

点评