无忧启动论坛

标题: imdisk支持sector map扇区映射 [打印本页]
作者: 不点    时间: 2018-1-25 12:06
标题: imdisk支持sector map扇区映射
在 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:

  1. 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  /? 命令，可以获得如下的帮助信息：


  2. Control program for the ImDisk Virtual Disk Driver.
  3. For copyrights and credits, type imdisk --version

  5. Syntax:
  6. imdisk -a -t type -m mountpoint [-n] [-o opt1[,opt2 ...]] [-f|-F file]
  7.        [-s size] [-b offset] [-v partition] [-S sectorsize] [-u unit]
  8.        [-x sectors/track] [-y tracks/cylinder] [-p "format-parameters"]
  9. imdisk -d|-D [-u unit | -m mountpoint]
  10. imdisk -l [-u unit | -m mountpoint]
  11. imdisk -e [-s size] [-o opt1[,opt2 ...]] [-u unit | -m mountpoint]

  13. -a      Attach a virtual disk. This will configure and attach a virtual disk
  14.         with the parameters specified and attach it to the system.

  16. -d      Detach a virtual disk from the system and release all resources.
  17.         Use -D to force removal even if the device is in use.

  19. -e      Edit an existing virtual disk.

  21.         Along with the -s parameter extends the size of an existing virtual
  22.         disk. Note that even if the disk can be extended successfully, the
  23.         existing filesystem on it can only be extended to fill the new size
  24.         without re-formatting if you are running Windows 2000 or later and the
  25.         current filesystem is NTFS.

  27.         Along with the -o parameter changes media characteristics for an
  28.         existing virtual disk. Options that can be changed on existing virtual
  29.         disks are those specifying wether or not the media of the virtual disk
  30.         should be writable and/or removable.

  32. -t type
  33.         Select the backingstore for the virtual disk.

  35. vm      Storage for this type of virtual disk is allocated from virtual memory
  36.         in the system process. If a file is specified with -f that file is
  37.         is loaded into the memory allocated for the disk image.

  39. file    A file specified with -f file becomes the backingstore for this
  40.         virtual disk.

  42. proxy   The actual backingstore for this type of virtual disk is controlled by
  43.         an ImDisk storage server accessed by the driver on this machine by
  44.         sending storage I/O request through a named pipe specified with -f.

  46. -f file or -F file
  47.         Filename to use as backingstore for the file type virtual disk, to
  48.         initialize a vm type virtual disk or name of a named pipe for I/O
  49.         client/server communication for proxy type virtual disks. For proxy
  50.         type virtual disks "file" may be a COM port or a remote server
  51.         address if the -o options includes "ip" or "comm".

  53.         Instead of using -f to specify 'DOS-style' paths, such as
  54.         C:\dir\image.bin or \\server\share\image.bin, you can use -F to
  55.         specify 'NT-style' native paths, such as
  56.         \Device\Harddisk0\Partition1\image.bin. This makes it possible to
  57.         specify files on disks or communication devices that currently have no
  58.         drive letters assigned.

  60. -l      List configured devices. If given with -u or -m, display details about
  61.         that particular device.

  63. -n      When printing ImDisk device names, print only the unit number without
  64.         the \Device\ImDisk prefix.

  66. -s size
  67.         Size of the virtual disk. Size is number of bytes unless suffixed with
  68.         a b, k, m, g, t, K, M, G or T which denotes number of 512-byte blocks,
  69.         thousand bytes, million bytes, billion bytes, trillion bytes,
  70.         kilobytes, megabytes, gigabytes and terabytes respectively. The suffix
  71.         can also be % to indicate percentage of free physical memory which
  72.         could be useful when creating vm type virtual disks. It is optional to
  73.         specify a size unless the file to use for a file type virtual disk does
  74.         not already exist or when a vm type virtual disk is created without
  75.         specifying an initialization image file using the -f or -F. If size is
  76.         specified when creating a file type virtual disk, the size of the file
  77.         used as backingstore for the virtual disk is adjusted to the new size
  78.         specified with this size option.

  80.         The size can be a negative value to indicate the size of free physical
  81.         memory minus this size. If you e.g. type -400M the size of the virtual
  82.         disk will be the amount of free physical memory minus 400 MB.

  84. -b offset
  85.         Specifies an offset in an image file where the virtual disk begins. All
  86.         offsets of I/O operations on the virtual disk will be relative to this
  87.         offset. This parameter is particularily useful when mounting a specific
  88.         partition in an image file that contains an image of a complete hard
  89.         disk, not just one partition. This parameter has no effect when
  90.         creating a blank vm type virtual disk. When creating a vm type virtual
  91.         disk with a pre-load image file specified with -f or -F paramters, the
  92.         -b parameter specifies an offset in the image file where the image to
  93.         be loaded into the vm type virtual disk begins.

  95.         Specify auto as offset to automatically select offset for a few known
  96.         non-raw disk image file formats. Currently auto-selection is supported
  97.         for Nero .nrg and Microsoft .sdi image files.

  99. -v partition
  100.         Specifies which partition to mount when mounting a raw hard disk image
  101.         file containing a master boot record and partitions.

  103.         Specify number 1-4 to mount a partition from the primary partition
  104.         table and 5-8 to mount a partition from an extended partition table.

  106. -S sectorsize
  107.         Sectorsize to use for the virtual disk device. Default value is 512
  108.         bytes except for CD-ROM/DVD-ROM style devices where 2048 bytes is used
  109.         by default.

  111. -x sectors/track
  112.         See the description of the -y option below.

  114. -y tracks/cylinder
  115.         The -x and -y options can be used to specify a synthetic geometry.
  116.         This is useful for constructing bootable images for later download to
  117.         physical devices. Default values depends on the device-type specified
  118.         with the -o option. If the 'fd' option is specified the default values
  119.         are based on the virtual disk size, e.g. a 1440K image gets 2
  120.         tracks/cylinder and 18 sectors/track.

  122. -p "format-parameters"
  123.         If -p is specified the 'format' command is invoked to create a
  124.         filesystem when the new virtual disk has been created.
  125.         "format-parameters" must be a parameter string enclosed within
  126.         double-quotes. The string is added to the command line that starts
  127.         'format'. You usually specify something like "/fs:ntfs /q /y", that
  128.         is, create an NTFS filesystem with quick formatting and without user
  129.         interaction.

  131. -o option
  132.         Set or reset options.

  134. ro      Creates a read-only virtual disk. For vm type virtual disks, this
  135.         option can only be used if the -f option is also specified.

  137. rw      Specifies that the virtual disk should be read/writable. This is the
  138.         default setting. It can be used with the -e parameter to set an
  139.         existing read-only virtual disk writable.

  141. rem     Specifies that the device should be created with removable media
  142.         characteristics. This changes the device properties returned by the
  143.         driver to the system. For example, this changes how some filesystems
  144.         cache write operations.

  146. fix     Specifies that the media characteristics of the virtual disk should be
  147.         fixed media, as opposed to removable media specified with the rem
  148.         option. Fixed media is the default setting. The fix option can be used
  149.         with the -e parameter to set an existing removable virtual disk as
  150.         fixed.

  152. saved   Clears the 'image modified' flag from an existing virtual disk. This
  153.         flag is set by the driver when an image is modified and is displayed
  154.         in the -l output for a virtual disk. The 'saved' option is only valid
  155.         with the -e parameter.

  157.         Note that virtual floppy or CD/DVD-ROM drives are always read-only and
  158.         removable devices and that cannot be changed.

  160. cd      Creates a virtual CD-ROM/DVD-ROM. This is the default if the file
  161.         name specified with the -f option ends with either .iso, .nrg or .bin
  162.         extensions.

  164. fd      Creates a virtual floppy disk. This is the default if the size of the
  165.         virtual disk is any of 160K, 180K, 320K, 360K, 640K, 720K, 820K, 1200K,
  166.         1440K, 1680K, 1722K, 2880K, 123264K or 234752K.

  168. hd      Creates a virtual fixed disk partition. This is the default unless
  169.         file extension or size match the criterias for defaulting to the cd or
  170.         fd options.

  172. ip      Can only be used with proxy-type virtual disks. With this option, the
  173.         user-mode service component is initialized to connect to an ImDisk
  174.         storage server using TCP/IP. With this option, the -f switch specifies
  175.         the remote host optionally followed by a colon and a port number to
  176.         connect to.

  178. comm    Can only be used with proxy-type virtual disks. With this option, the
  179.         user-mode service component is initialized to connect to an ImDisk
  180.         storage server through a COM port. With this option, the -f switch
  181.         specifies the COM port to connect to, optionally followed by a colon,
  182.         a space, and then a device settings string with the same syntax as the
  183.         MODE command.

  185. -u unit
  186.         Along with -a, request a specific unit number for the ImDisk device
  187.         instead of automatic allocation. Along with -d or -l specifies the
  188.         unit number of the virtual disk to remove or query.

  190. -m mountpoint
  191.         Specifies a drive letter or mount point for the new virtual disk, the
  192.         virtual disk to query or the virtual disk to remove. When creating a
  193.         new virtual disk you can specify #: as mountpoint in which case the
  194.         first unused drive letter is automatically used.
复制代码
作者: 红毛樱木    时间: 2018-1-25 13:11
这个一直都支持。。。您才知道啊，用了几年了。
作者: 不点    时间: 2018-1-25 15:37
红毛樱木 发表于 2018-1-25 13:11
这个一直都支持。。。您才知道啊，用了几年了。

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

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

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

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

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

作者: 红毛樱木    时间: 2018-1-25 15:59
本帖最后由 红毛樱木 于 2018-1-25 16:03 编辑
不点 发表于 2018-1-25 15:37
哦，我跟不上形势了。能分享使用经验、心得体会吗？能给出优缺点的评价吗？

我想制作一个 U 盘，含两 ...


我一直用PECMD操作的。IMDISK命令行应该差不多。
  1. ENVI^ EnviMode=1
  2. ENVI^ ForceLocal=1
  3. //定义磁盘号
  4. ENVI &HD=6
  5. //定义分区号
  6. ENVI &ID=2
  7. //要挂载的盘符
  8. ENVI &Drv=Z:
  9. part -hextp -phy -fill list part %&hd%#%&ID%,&&DiskInfo
  10. MSTR &&a,&&b,&&c,&&d=<2><8><4><5>%&DiskInfo%
  11. RAMD ImDisk*ret*%&c%*%&d%*0*\\.\PhysicalDrive%&hd% -a -o hd -m %&Drv%
复制代码


好像还有个更简单的方式。MOUN-udm -udmid:pt1，具体格式忘记了。
------------------我这个好像需要通过分区表的信息获取分区长度。。。估计不适合你用。。。
作者: 不点    时间: 2018-1-25 17:24
红毛樱木 发表于 2018-1-25 15:59
我一直用PECMD操作的。IMDISK命令行应该差不多。

那我以后有机会就试试吧。看看这个 imdisk 会不会比 winvblock 更好用。
作者: 不点    时间: 2018-1-27 09:28
红毛樱木 发表于 2018-1-25 15:59
我一直用PECMD操作的。IMDISK命令行应该差不多。

我用笨办法搞定了。步骤如下：

在 U 盘开头建立 Fat32 分区，提高启动成功率（我实际上是使用我自己开发的 multimbr，本身就是 FAT32 格式）。剩余空间创建 NTFS 分区，用来存放大文件。

然后，用 bootice 查看分区表上 NTFS 分区的起始扇区号和分区长度，用计算器转换成 10 进制。这个必须准确无误。以下假定起始扇区号是 12345678，分区长度是 87654321。在 U 盘的 FAT32 分区创建批处理文件，名字是 imdisk0.bat，内容只有一行：

imdisk  -a  -f  \\.\PhysicalDrive0  -b  12345678b  -s  87654321b  -m  #:

类似地，创建 imdisk1.bat，imdisk2.bat，......，直到 imdisk9.bat，分别相应于 PhysicalDrive1，2，......，直到 9。

为什么要创建这么多批处理文件呢？因为事先不知道哪个 PhysicalDrive 是 U 盘。

好的，现在可以用 bootice 修改 U 盘分区表，抹掉 NTFS 表项，这就彻底隐藏了 NTFS 分区。

任何时候需要访问 NTFS 分区时，只需执行上述某个批处理即可把隐藏的 NTFS 分区挂到一个新盘符上。这些批处理里面，只有一个是成功的，其它都会失败。没关系，我们要的就是成功的这个，而那些失败的，直接在资源管理器中卸载无效盘符即可。


这个办法很笨，不求大家打赏。但它管用，也简单易懂，我就满意了。

经过测试，无论在 pe 下还是在正常 Windows下都能工作。

作者: 红毛樱木    时间: 2018-1-27 09:43
不点 发表于 2018-1-27 09:28
我用笨办法搞定了。步骤如下：

在 U 盘开头建立 Fat32 分区，提高启动成功率（我实际上是使用我自己开 ...

原理是一样的。
作者: 不点    时间: 2018-1-28 08:58
本帖最后由 不点 于 2018-1-28 08:59 编辑

太棒了！！！！google 了 “batch nt-style native path”，找到如下网页：

DOS to NT: A Path’s Journey
https://blogs.msdn.microsoft.com/jeremykuhne/2016/05/02/dos-to-nt-a-paths-journey/

重要部分摘录：

  1. all of the following (and many other variants) are equivalent:

  3.     C:\bar\foo.txt
  4.     \\.\C:\bar\foo.txt
  5.     \\?\C:\bar\foo.txt
  6.     \??\C:\bar\foo.txt
  7.     \\?\Harddisk0Partition2\bar\foo.txt
  8.     \\?\HarddiskVolume4\bar\foo.txt
  9.     \\?\Volume{0FAF43C1-2AED-4824-B2D4-2339C14E93A}\bar\foo.txt
  10.     \\?\Volume{d1655348-000-000-000-f0150000000}\bar\foo.txt
  11.     \\?\GLOBALROOT\Device\Harddisk0\Partition2\bar\foo.txt
  12.     \\.\GLOBALROOT\Device\HarddiskVolume4\bar\foo.txt
  13.     \\LOCALHOST\C$\bar\foo.txt
  14.     \\?\UNC\C$\bar\foo.txt
  15.     \\?\GLOBALROOT\Device\Mup\C$\bar\foo.txt

复制代码


我在 cmd 命令提示符下试验，有些不支持，但有些是支持的，特别是正好支持了我想要的这个：

  1. type \\?\GLOBALROOT\Device\Harddisk1\Partition1\imdisk0.bat
复制代码


此命令成功显示出我的 U 盘上的 imdisk0.bat 的内容！

这样，我通过 for 循环 和 if 语句来枚举测试 Harddisk? 就能确定究竟 imdisk0.bat 是在哪个 PhysicalDrive 上了。知道了这一点，也就可以写挂载虚拟 ntfs 分区的命令了。棒极了！前几天费了好大牛劲，也没找到想要的简单办法。


作者: dos时代菜鸟    时间: 2018-1-28 09:38
vbs脚本
  1. '获取 磁盘以及其分区列表,包括接口信息。
  2. Set wmi=GetObject("winmgmts:\\.\root\cimv2")
  3. Set disk_s=wmi.instancesof("win32_LogicalDiskToPartition")
  4. Set d_s=wmi.instancesof("win32_diskdrive")
  5. sn=""
  6. d0=Split("x,y",",",-1,1)
  7. For Each s In disk_s
  8.         dx=d0(1)
  9. '记录 分区对应的 硬盘index
  10.         d0=split(Split(Split(s.antecedent,"=",-1,1)(1),",",-1,1)(0),"#",-1,1)

  12.         d1=Split(s.Dependent,"=",-1,1)
  13.         If (dx = d0(1) ) then
  14.                 sn=sn&(d1(1))
  15.         Else
  16.                 For Each d In d_s
  17.                    If (""&d.index = ""&d0(1)) Then id=chr(10)&d.name&"  "&d.interfacetype
  18.                 Next
  19.                 sn=sn+id&" "&(d1(1))
  20.         End If

  22. Next
  23. wscript.echo sn
复制代码


无标题.png (6.99 KB, 下载次数: 153)

无标题.png

无标题2.png (8.6 KB, 下载次数: 132)

无标题2.png

parts.7z

516 Bytes, 下载次数: 12, 下载积分: 无忧币 -2

利用 vbs 调用 wmic 获取硬盘 、接口、分区盘符
作者: 不点    时间: 2018-1-28 10:43
dos时代菜鸟 发表于 2018-1-28 09:38
vbs脚本

在 win PE 下能运行吗？我需要在多种环境都能起作用的方法。
作者: 不点    时间: 2018-1-28 10:56
本帖最后由 不点 于 2018-1-28 10:58 编辑

找到了一个 c++ 的程序，能够得到逻辑盘号所对应物理驱动器号。C 代码比较折腾，不如脚本方便，聊胜于无吧。

https://www.codeproject.com/Messages/3155060/Re-Translate-Logical-Drive-to-Physical-Drive.aspx

You could use the IOCTL_STORAGE_GET_DEVICE_NUMBER[^] control code to obtain the physical drive and volume number.

For example:

  1. #include <Winioctl.h>
  2. VOID LogicalToPhysical(TCHAR *szDrive)
  3. {
  4.         CString szPhysical;
  5.         HANDLE h = CreateFile(szDrive, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL);
  6.         if(INVALID_HANDLE_VALUE != h)
  7.         {
  8.                 STORAGE_DEVICE_NUMBER sd;
  9.                 DWORD dwRet;
  10.                 if(DeviceIoControl(h, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL, 0, &sd, sizeof(STORAGE_DEVICE_NUMBER), &dwRet, NULL))
  11.                 {
  12.                         szPhysical.Format(_T("\\\\.\\PhysicalDrive%d"), sd.DeviceNumber);
  13.                 }
  14.                 CloseHandle(h);
  15.         }
  16. }

  18. //Usage:
  19. LogicalToPhysical(_T("\\\\.\\\\C:"));
复制代码



Note that this control code will fail to return correct information for mirrored and striped volumes. A more complete solution for these types of drives would be the IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS[^] control code which will return an array of partitions for the drive.

Best Wishes,
-David Delaune



作者: dos时代菜鸟    时间: 2018-1-28 11:10
不点 发表于 2018-1-28 10:56
找到了一个 c++ 的程序，能够得到逻辑盘号所对应物理驱动器号。C 代码比较折腾，不如脚本方便，聊胜于无吧 ...

嗯，如果winpe 没有 vbs 和 wmic  
vbs 就不好用了。
作者: 不点    时间: 2018-1-28 11:34
又找到一个 VB 脚本

http://www.vbforums.com/showthread.php?466828-RESOLVED-Get-physical-drive-number-given-a-drive-letter

  1.     Option Explicit
  2.     Private Enum IOCOMMANDS
  3.         IOCTL_STORAGE_GET_DEVICE_NUMBER = &H2D1080
  4.     End Enum

  6.     Private Declare Function DeviceIoControl Lib "kernel32" _
  7.       (ByVal hDevice As Long, _
  8.        ByVal dwIoControlCode As Long, _
  9.        lpInBuffer As Any, _
  10.        ByVal nInBufferSize As Long, _
  11.        lpOutBuffer As Any, _
  12.        ByVal nOutBufferSize As Long, _
  13.        lpBytesReturned As Long, _
  14.        lpOverlapped As Any) As Long

  16.     Private Declare Function CreateFile Lib "kernel32" _
  17.        Alias "CreateFileA" _
  18.       (ByVal lpFileName As String, _
  19.        ByVal dwDesiredAccess As Long, _
  20.        ByVal dwShareMode As Long, _
  21.        lpSecurityAttributes As Any, _
  22.        ByVal dwCreationDisposition As Long, _
  23.        ByVal dwFlagsAndAttributes As Long, _
  24.        ByVal hTemplateFile As Long) As Long

  26.     Private Declare Function CloseHandle Lib "kernel32" _
  27.        (ByVal hObject As Long) As Long

  29.     Private Const INVALID_HANDLE_VALUE As Long = -1&
  30.     Private Const GENERIC_READ As Long = &H80000000
  31.     Private Const FILE_SHARE_READ As Long = &H1
  32.     Private Const FILE_SHARE_WRITE As Long = &H2
  33.     Private Const OPEN_EXISTING As Long = 3

  35.     Type ddevicetype
  36.         DEVICE_TYPE As Long
  37.         deviceno As Long
  38.         partionno As Long
  39.     End Type

  41.     Public Function DeviceCheckMedia(sDrive As String) As ddevicetype

  43.         Dim hDevice As Long
  44.         Dim bytesReturned As Long
  45.         Dim success As Long
  46.         Dim sdn As ddevicetype

  48.     'Open a handle to drive
  49.         hDevice = CreateFile("\\." & sDrive, _
  50.                             GENERIC_READ, _
  51.                             FILE_SHARE_READ Or FILE_SHARE_WRITE, _
  52.                             ByVal 0&, _
  53.                             OPEN_EXISTING, _
  54.                             0&, 0&)
  55.     'Issue GET_DEVICE_NUMBER command to DeviceIoControl
  56.         If hDevice <> INVALID_HANDLE_VALUE Then
  57.             success = DeviceIoControl(hDevice, _
  58.                                     IOCTL_STORAGE_GET_DEVICE_NUMBER, _
  59.                                     0&, _
  60.                                     0&, _
  61.                                     sdn, _
  62.                                     Len(sdn), _
  63.                                     bytesReturned, _
  64.                                     ByVal 0&)
  65.         End If
  66.     'Close Handle to drive
  67.         Call CloseHandle(hDevice)
  68.     'Return sdn contianing drive type, drive #,  and partition #
  69.         DeviceCheckMedia = sdn
  70.     End Function
复制代码




    Sorry, I mis-spoke there. I did mean physical drive.
    I'm not sure if this will help you generating the input you listed, this will give you the physical drive numbers as they are listed in the drive managment console. I'm not sure how you would find out which controller it is connected to becasue windows will assign a drive number the same whether you add a second drive to an IDE controller or plug in a USB drive. There may be a way to get the serial number directly with DeviceIoControl instead?

    Just to clarify. The function returns 3 things

    sdn.DEVICE_TYPE - type of drive, 7 for fixed disk, there is a list of the other return codes somewhere if you need them. I was only concerned with fixed disks.

    sdn.deviceno - the device number or phycial disk number of the drive, 0 for first physical drive, 1 for 2nd, etc...

    sdn.partitionno - the number of the partition, 1st partion on a physical disk is 1, second is 2 etc...

    So, using your 100GB dirve with 2 partitons as an example

  1.     devicecheckmedia (C:)
复制代码


    returns
    sdn.DEVICE_TYPE = 7
    sdn.deviceno = 0
    sdn.partitionno = 1


  1.     devicecheckmedia (D:)
复制代码


    returns
    sdn.DEVICE_TYPE = 7
    sdn.deviceno = 0
    sdn.partitionno = 2

    if we have a second physical drive with one partition E:


  1.     devicecheckmedia (E:)
复制代码


    returns
    sdn.DEVICE_TYPE = 7
    sdn.deviceno = 1
    sdn.partitionno = 1

作者: 不点    时间: 2018-1-28 13:57
从这里 https://msfn.org/board/topic/174825-get-disk-number-from-drive-letter-in-cmd/
找到这里 http://reboot.pro/topic/20240-how-to-get-partitions-path-in-command-prompt/
又找到这里：http://www.ltr-data.se/opencode.html/ 这里有 imdisk 作者自己写的很多工具软件。
太棒了！！！！devioctl.exe 就够用了：

  1. D:\>devioctl.exe extents c:
  2. Disk number    : 0
  3. Starting offset: 160039276544
  4. Extent length  : 34359742464 (32 GB)


  7. c:: 操作成功完成。

  9. D:\>devioctl.exe extents f:
  10. Disk number    : 1
  11. Starting offset: 32256
  12. Extent length  : 67786129920 (63.13 GB)


  15. f:: 操作成功完成。

  17. D:\>
复制代码


给出 F: 盘符（它是我的 U 盘），就能得到 disk number = 1，这就是 PhysicalDrive 的号码。要的就是它呀！

作者: dos时代菜鸟    时间: 2018-1-28 14:55
不点 发表于 2018-1-28 13:57
从这里 https://msfn.org/board/topic/174825-get-disk-number-from-drive-letter-in-cmd/
找到这里 http: ...



大师威武
作者: 不点    时间: 2018-1-28 18:41
本帖最后由 不点 于 2018-2-9 16:52 编辑

mount_NTFS.bat 批处理做好了，以下是示例代码：

请自己下载 devioctl 放在 U 盘上，与 mount_NTFS.bat 放在一起。

可不要把 mount_NTFS.bat 放在硬盘上啊！如果是在硬盘上，就把硬盘的扇区序列虚拟成盘符了，这很危险！

批处理在哪个盘上，就会把哪个盘上的扇区序列虚拟成一个新盘！一定要明白！

【说明】下面这个版本不要用了，请下载 19 楼的修正增强版。


  1. :: Use VER to Reset ERRORLEVEL to 0
  2. ver > NUL
  3. pushd "%CD%"
  4. cd /d "%~dp0"
  5. if not exist imdisk.exe for %%I in (imdisk.exe) do if "%%~$PATH:I"=="" if exist imdiskinst.exe imdiskinst.exe
  6. if not exist imdisk.exe for %%I in (imdisk.exe) do if "%%~$PATH:I"=="" goto :NO_IMDISK
  7. if not exist devioctl.exe for %%I in (devioctl.exe) do if "%%~$PATH:I"=="" goto :NO_DEVIOCTL
  8. for /F "tokens=1,2,3,4,*" %%A in ('devioctl.exe extents %~d0') do (
  9. if not [%%A]==[Disk] goto :NO_DISK
  10. if not [%%B]==[number] goto :NO_NUMBER
  11. if not [%%C]==[:] goto :NO_COLON
  12. if not [%%E]==[] goto :E_NOT_EMPTY
  13. if %%D GTR 9 goto :TOO_MANY_DRIVES

  15. :: 下面这句是关键，请修改好以后，去掉前面的 echo，就真正起作用了！危险！
  16. echo imdisk.exe -a -f \\.\PhysicalDrive%%D -b 132395008b -s 110219264b -m #:

  18. if %ERRORLEVEL% NEQ 0 goto :IMDISK_FAILED
  19. goto :END
  20. )

  22. :NO_DEVIOCTL
  23. echo Error: No devioctl.exe!
  24. pause
  25. goto :END

  27. :NO_DISK
  28. echo Error: No disk!
  29. pause
  30. goto :END

  32. :NO_NUMBER
  33. echo Error: No number!
  34. pause
  35. goto :END

  37. :NO_COLON
  38. echo Error: No colon!
  39. pause
  40. goto :END

  42. :E_NOT_EMPTY
  43. echo Error: E not empty!
  44. pause
  45. goto :END

  47. :TOO_MANY_DRIVES
  48. echo Error: Too many drives!
  49. pause
  50. goto :END

  52. :NO_IMDISK
  53. echo Error: No imdisk.exe!
  54. pause
  55. goto :END

  57. :IMDISK_FAILED
  58. echo Error: imdisk failed!
  59. pause
  60. goto :END

  62. :END
  63. popd
复制代码

作者: 不点    时间: 2018-2-2 09:48
从 chenall 的 Blog 上又找到一个好东西——

批处理检测外部命令是否存在的模块
http://chenall.net/post/cmd_if_exist/

作者 chenall 发表于 2009-09-29

编写批处理时经常需要用到外部命令，一些常用的命令一般的系统都会有，但是一些精简的系统上可能就没有了。如果没有作判断就可能导致程序出现未知的错误。

一般检测文件是否存在可以使用

    IF EXIST filename 执行某个命令…

但是这样只能检测当前目录下或指定目录的，而批处理的外部命令是通过 PATH 变量来确定位置的。正常情况下可以通过以下命令来确定这个外部命令是否存在：

    for %I in (find.exe) do if “%~$PATH:I”==”” echo find 命令不存在

为了以后方便就写了一个模块，用于判断命令是否存在。

  1. @echo off
  2. cls&echo.IF_EXIST.cmd by chenall 2009-09-29 http://www.chenall.net
  3. echo.
  4. echo.功能:
  5. echo.   从环境变量PATH,当前目录,程序所在目录中查找指定的文件,如果找到就显示并返回值0,否则就返回1
  6. echo.
  7. echo.使用方法:
  8. echo.   直接复制下面::模块开始::到::模块结束::之间的代码到你的批处理程序中.然后使用以下命令调用.
  9. echo.   CALL :IF_EXIST xxxx.xxx
  10. echo.
  11. echo.使用例子:
  12. echo.   CALL :IF_EXIST find.exe || echo.find.exe 不存在
  13. echo.
  14. echo.注:只是简单查找,并且不支持查找子目录.主要用于批处理中判断某个外部命是否存在.
  15. echo.   实际应用中可以删除echo %~$PATH:1语句删除输出显示,或者在调用时加一个>nul
  16. echo.
  17. echo.
  18. ECHO.以下是测试命令.
  19. ECHO.查找FIND.EXE
  20. CALL :IF_EXIST FIND.EXE || ECHO.FIND.EXE 不存在
  21. CALL :IF_EXIST FIND.EXE >nul ||echo.出错了,find.exe不存在.
  22. ECHO.查找noEXIST.FILE
  23. CALL :IF_EXIST noEXIST.FILE || ECHO.noEXIST.FILE 不存在
  24. PAUSE
  25. GOTO :EOF

  27. ::::::::::::::::::::::::模块开始::::::::::::::::::::::::
  28. :IF_EXIST       BY chenall QQ:366840202     2009-09-29
  29. SETLOCAL&PATH %PATH%;%~dp0;%cd%
  30. if "%~$PATH:1"=="" exit /b 1
  31. echo %~$PATH:1
  32. exit /b 0       http://www.chenall.net
  33. :::::::::::::::::::::::模块结束:::::::::::::::::::::::::
复制代码


作者: 不点    时间: 2018-2-3 01:29
本帖最后由 不点 于 2020-4-28 20:28 编辑


下面的代码是 2020-04-28 更新的。


注意！设计的目标，就是只在 U 盘上使用。请不要在硬盘上使用。为避免硬盘受到伤害，请不要把这个脚本放在硬盘上！脚本在哪个盘上，就会对哪个盘进行操作。

主要用于 U 盘单分区的情况。U 盘多分区的情况，能否使用，请您自行判断。Ventoy 的 exFAT + FAT 双分区，在 Win7 下只有 exFAT 是可见的。我已经证明可以用这个脚本来把不可见的 FAT 分区虚拟出来，变成可见的 FAT 卷。

注意，U 盘扇区总数应该低于 2T，也即低于 2000G。这是因为，脚本采用 4 字节的整数来表示扇区号，因此，最大只能处理 2T 的容量。而且，U 盘应该是 MBR 格式。我没有测试 GPT 格式是否支持，所以，不要在 GPT 格式的 U 盘上使用。

程序会查找 U 盘的第一个分区之后的空间，看看它是不是一个合法的文件系统卷。如果是的，就挂载为虚拟盘。

程序使用了两个工具：imdisk.exe 以及 devioctl.exe。

你的系统中必须已经安装了 imdisk。你必须把 devioctl.exe 与该脚本放在一起，或者放在 C 盘的 Windows 系统中 PATH 可以查找的位置。


另外，你可能需要用管理员的身份，才能正常运行脚本。运行失败时，你可以试试用鼠标右键单击脚本，然后选择 “以管理员的身份运行”。





  2. @echo off
  3. setlocal EnableDelayedExpansion
  4. pushd "%CD%"
  5. cd /d "%~dp0"
  6. if not exist imdisk.exe for %%I in (imdisk.exe) do if "%%~$PATH:I"=="" if exist imdisk\imdiskinst.exe imdisk\imdiskinst.exe
  7. if not exist imdisk.exe for %%I in (imdisk.exe) do if "%%~$PATH:I"=="" goto :NO_IMDISK
  8. if not exist devioctl.exe for %%I in (devioctl.exe) do if "%%~$PATH:I"=="" goto :NO_DEVIOCTL
  9. REM 准备获取物理驱动器号、FAT32 分区位置、长度等信息
  10. set L=6
  11. echo devioctl.exe geometry %~d0
  12. for /F "skip=6 tokens=1,2,3,4,*" %%A in ('devioctl.exe geometry %~d0') do (
  13. set /a L+=1
  14. if !L! GTR 21 goto :END
  15. REM 下面这句显示一个“.”，模拟动画进度条。echo 命令无法做到不换行。
  16. set /p =. < NUL
  17. call :do_lines  %%A %%B %%C %%D
  18. )
  19. echo devioctl.exe needs to run as Administrator!
  20. echo Right click the batch file and select "Run as administrator".
  21. pause
  22. goto :END

  24. :do_lines
  25. if "%1"=="" exit /b
  26. if %L%==7 (
  27. if not "%1 %2 %3"=="Total CHS size:" goto :NO_Total_CHS_size

  29. exit /b
  30. )
  31. if %L%==8 (
  32. if not "%1 %2 %3"=="LBA length :" goto :NO_LBA_length

  34. REM 成功获取分区长度 %4。
  35. set LENGTH=%4

  37. exit /b
  38. )
  39. if %L%==9 exit /b
  40. if %L%==10 (
  41. if not "%1 %2 %3"=="Start offset :" goto :NO_Start_offset

  43. REM 成功获取分区起始偏移 %4。
  44. set OFFSET=%4

  46. exit /b
  47. )
  48. if %L% GTR 10 if %L% LSS 20 exit /b
  49. if %L%==20 (
  50. if not "%1 %2 %3"=="Device number :" goto :NO_Device_number
  51. if %4 GTR 9 goto :TOO_MANY_DRIVES

  53. REM 成功获取物理驱动器号 %4。
  54. set PHYDRV=%4
  55. exit /b
  56. )

  58. if not %L%==21 exit /b

  60. REM 把 64 位的 offset 除以 512 转化为 32 位值（扇区数）。
  61. set HI=%OFFSET:~0,-3%
  62. set LO=%OFFSET:~-3%
  63. set /a "Q=%HI%/512"
  64. set /a "R=%HI% %% 512"
  65. REM %Q%000 就是 %Q% * 1000，同理，%R%000 也是 %R% * 1000
  66. set /a "OFFSET=%Q%000 + (%R%000 + %LO%)/512"
  67. echo %OFFSET%

  69. REM 把 64 位的 length 除以 512 转化为 32 位值（扇区数）。
  70. set HI=%LENGTH:~0,-3%
  71. set LO=%LENGTH:~-3%
  72. set /a "Q=%HI%/512"
  73. set /a "R=%HI% %% 512"
  74. REM %Q%000 就是 %Q% * 1000，同理，%R%000 也是 %R% * 1000
  75. set /a "LENGTH=%Q%000 + (%R%000 + %LO%)/512"
  76. echo %LENGTH%

  78. set /a B=%OFFSET%+%LENGTH%
  79. set BB=%B%
  80. REM 虚拟盘的起始扇区 B，对齐到下一个 MB 的边界，就是 BB 了。
  81. REM 后面的代码会先尝试从 B 处挂载；若失败，再尝试从 BB 处挂载。
  82. set /a BB+=2047
  83. set /a "BB&=-2048"
  84. echo %B%, %BB%

  86. REM 准备获取物理驱动器 PHYDRV 的总扇区数。
  87. set L=0
  88. echo devioctl.exe extents PhysicalDrive%PHYDRV%
  89. for /F "tokens=1,2,3,4,*" %%A in ('devioctl.exe extents PhysicalDrive%PHYDRV%') do (
  90. set /a L+=1
  91. if !L! GTR 3 goto :done_phy
  92. set /p =. < NUL
  93. call :do_lines_phy  %%A %%B %%C %%D
  94. if !L! GTR 3 goto :done_phy
  95. )
  96. echo devioctl.exe needs to run as Administrator!
  97. echo Right click the batch file and select "Run as administrator".
  98. pause
  99. goto :END

  101. :done_phy

  103. REM 把 64 位的 total 除以 512 转化为 32 位值（扇区数）。
  104. set HI=%TOTAL:~0,-3%
  105. set LO=%TOTAL:~-3%
  106. set /a "Q=%HI%/512"
  107. set /a "R=%HI% %% 512"
  108. REM %Q%000 就是 %Q% * 1000，同理，%R%000 也是 %R% * 1000
  109. set /a "TOTAL=%Q%000 + (%R%000 + %LO%)/512"
  110. echo %TOTAL%

  112. if %BB% GEQ %TOTAL% goto :mount_fail

  114. set /a S=%TOTAL%-%B%
  115. set /a SS=%TOTAL%-%BB%
  116. echo %S%

  118. :try_mount

  120. REM 选项 -o rem 是挂载为“可移动磁盘”，虚拟盘可以“弹出”。
  121. REM 若用默认的 -o fix 挂为“本地磁盘”，则虚拟盘无法弹出，也无法安全卸载。
  122. echo.
  123. echo imdisk.exe -a -f \\.\PhysicalDrive%PHYDRV% -b %B%b -s %S%b -m #: -o rem

  125. REM Use VER to Reset ERRORLEVEL to 0
  126. ver > NUL

  128. set CREATED=NODRIVE:

  130. for /F "tokens=1,2,3,4,*" %%A in ('imdisk.exe -a -f \\.\PhysicalDrive%PHYDRV% -b %B%b -s %S%b -m #: -o rem') do (
  131. rem set /a L+=1
  132. rem if !L! GTR 3 goto :done_phy
  133. set /p =. < NUL
  134. echo %%A %%B %%C %%D %%E
  135. if "%%A %%B"=="Created device" set CREATED=%%D
  136. rem call :do_lines_phy  %%A %%B %%C %%D
  137. rem if !L! GTR 3 goto :done_phy
  138. )

  140. REM if !ERRORLEVEL! NEQ 0 goto :IMDISK_FAILED

  142. REM 如果想要挂载一个未格式化的卷，可以去掉下面这句开头的注释符
  143. rem if "%BB%"=="%B%" goto :finish

  145. REM 检查是否成功挂载了一个带有文件系统的卷
  146. if exist %CREATED% goto :finish

  148. REM 失败，没有发现文件系统，现在卸掉已经挂上的无效虚拟盘
  149. REM devioctl.exe dismount %CREATED% <--- 这个卸载方法不起作用
  150. imdisk -D -m %CREATED%

  152. if "%B%"=="%BB%" goto :mount_fail
  153. REM 让虚拟盘的起始位置按 MB 对齐，再试一次
  154. set B=%BB%
  155. set S=%SS%
  156. goto :try_mount

  158. :mount_fail
  159. echo 挂载失败！可能不存在隐藏分区，或隐藏分区的位置很特殊。60 秒后自动退出。
  160. ping -n 60 localhost > nul

  162. REM 设置退出条件，让第一个 for 循环体正常退出
  163. set L=22

  165. exit /b

  167. :finish
  168. echo 操作成功！请检查上述信息是否正常，60 秒后自动退出。
  169. ping -n 60 localhost > nul

  171. REM 设置退出条件，让第一个 for 循环体正常退出
  172. set L=22

  174. exit /b


  177. :do_lines_phy
  178. if "%1"=="" exit /b
  179. if %L%==1 (
  180. if not "%1 %2 %3"=="Disk number :" goto :NO_Disk_number
  181. if not "%4"=="%PHYDRV%" goto :Wrong_Disk_number
  182. exit /b
  183. )
  184. if %L%==2 (
  185. if not "%1 %2 %3"=="Starting offset: 0" goto :Wrong_Starting_offset
  186. exit /b
  187. )

  189. if not %L%==3 exit /b

  191. REM 设置退出条件，让 for 循环体正常退出
  192. set L=22

  194. if not "%1 %2 %3"=="Extent length :" goto :NO_Extent_length
  195. REM 成功获取物理驱动器总长度 %4。
  196. set TOTAL=%4

  198. exit /b


  201. :Wrong_Disk_number
  202. echo Fatal: Wrong Disk number( %4 != %PHYDRV% )! Exit!
  203. pause
  204. exit /b

  206. :Wrong_Starting_offset
  207. echo Fatal: Wrong Starting offset (should be 0)! Exit!
  208. pause
  209. exit /b

  211. :NO_Start_offset
  212. echo Error: No Start offset!
  213. pause
  214. exit /b

  216. :NO_LBA_length
  217. echo Error: No LBA length!
  218. pause
  219. exit /b

  221. :NO_Total_CHS_size
  222. echo Error: No Total CHS size!
  223. pause
  224. exit /b

  226. :NO_Device_number
  227. echo Error: No Device number!
  228. pause
  229. exit /b

  231. :NO_Disk_number
  232. echo Fatal: No Disk number!
  233. pause
  234. exit /b

  236. :NO_Extent_length
  237. echo Fatal: No Extent length!
  238. pause
  239. exit /b

  241. :TOO_MANY_DRIVES
  242. echo Error: Too many drives!
  243. pause
  244. exit /b

  246. :IMDISK_FAILED
  247. echo Error: imdisk failed!
  248. pause
  249. exit /b

  251. :NO_IMDISK
  252. echo Error: No imdisk.exe!
  253. pause
  254. goto :END

  256. :NO_DEVIOCTL
  257. echo Error: No devioctl.exe!
  258. pause
  259. goto :END

  261. :END
  262. popd
  263. goto :eof
复制代码


上面的是新版，请使用。






下面是以前的旧版，请不要用了。

mount_NTFS.bat 批处理修正增强版，检查更严格了，运行速度会慢一些，但更安全一些。

如果不是以 Administrator 的身份运行，则 devioctl.exe 会显示 “拒绝操作” 信息。出现这个失败信息时，用鼠标右键点击 mount_NTFS.bat，选择 “以管理员身份运行” 即可。


  1. @echo off
  2. setlocal EnableDelayedExpansion
  3. pushd "%CD%"
  4. cd /d "%~dp0"
  5. if not exist imdisk.exe for %%I in (imdisk.exe) do if "%%~$PATH:I"=="" if exist imdiskinst.exe imdiskinst.exe
  6. if not exist imdisk.exe for %%I in (imdisk.exe) do if "%%~$PATH:I"=="" goto :NO_IMDISK
  7. if not exist devioctl.exe for %%I in (devioctl.exe) do if "%%~$PATH:I"=="" goto :NO_DEVIOCTL
  8. REM 检查分区位置、长度等几何参数信息，避免挂载错误的物理驱动器
  9. set L=6
  10. echo devioctl.exe geometry %~d0
  11. for /F "skip=6 tokens=1,2,3,4,*" %%A in ('devioctl.exe geometry %~d0') do (
  12. set /a L+=1
  13. if !L! GTR 20 goto :END
  14. set /p =. < NUL
  15. call :do_lines  %%A %%B %%C %%D
  16. )
  17. echo devioctl.exe needs to run as Administrator!
  18. echo Right click the batch file and select "Run as administrator".
  19. pause
  20. goto :END

  22. :do_lines
  23. if "%1"=="" exit /b
  24. if %L%==7 (
  25. if not "%1 %2 %3"=="Total CHS size:" goto :NO_Total_CHS_size

  27. REM 下面这句中的数值是 devioctl 探测的 U 盘总扇区数 * 512，请修改好。
  28. if not "%4"=="124218178560" goto :Wrong_Total_CHS_size

  30. exit /b
  31. )
  32. if %L%==8 (
  33. if not "%1 %2 %3"=="LBA length :" goto :NO_LBA_length

  35. REM 下面这句中的数值等于 FAT32 分区的总扇区数 * 512，请修改好。
  36. if not "%4"=="67786129920" goto :Wrong_LBA_length

  38. exit /b
  39. )
  40. if %L%==9 exit /b
  41. if %L%==10 (
  42. if not "%1 %2 %3"=="Start offset :" goto :NO_Start_offset

  44. REM 下面这句中的数值等于 FAT32 分区的起始扇区号 * 512，请修改好。
  45. if not "%4"=="32256" goto :Wrong_Start_offset

  47. exit /b
  48. )
  49. if %L% GTR 10 if %L% LSS 20 exit /b
  50. if %L%==20 (
  51. if not "%1 %2 %3"=="Device number :" goto :NO_Device_number
  52. if %4 GTR 9 goto :TOO_MANY_DRIVES

  54. REM Use VER to Reset ERRORLEVEL to 0
  55. ver > NUL

  57. echo.
  58. echo imdisk.exe -a -f \\.\PhysicalDrive%4 -b 132395008b -s 110219264b -m #:

  60. REM 下面这句是关键，请修改好以后，去掉前面的 REM，就真正起作用了！危险！
  61. REM imdisk.exe -a -f \\.\PhysicalDrive%4 -b 132395008b -s 110219264b -m #:

  63. if !ERRORLEVEL! NEQ 0 goto :IMDISK_FAILED

  65. ping -n 5 localhost > nul

  67. exit /b
  68. )
  69. exit /b

  71. :Wrong_Total_CHS_size
  72. echo Error: Wrong Total CHS size! Cannot run on drive %~d0!
  73. pause
  74. exit /b

  76. :Wrong_Start_offset
  77. echo Error: Wrong Start offset! Cannot run on drive %~d0!
  78. pause
  79. exit /b

  81. :Wrong_LBA_length
  82. echo Error: Wrong LBA length! Cannot run on drive %~d0!
  83. pause
  84. exit /b

  86. :NO_Start_offset
  87. echo Error: No Start offset!
  88. pause
  89. exit /b

  91. :NO_LBA_length
  92. echo Error: No LBA length!
  93. pause
  94. exit /b

  96. :NO_Total_CHS_size
  97. echo Error: No Total CHS size!
  98. pause
  99. exit /b

  101. :NO_Device_number
  102. echo Error: No Device number!
  103. pause
  104. exit /b

  106. :TOO_MANY_DRIVES
  107. echo Error: Too many drives!
  108. pause
  109. exit /b

  111. :IMDISK_FAILED
  112. echo Error: imdisk failed!
  113. pause
  114. exit /b

  116. :NO_IMDISK
  117. echo Error: No imdisk.exe!
  118. pause
  119. goto :END

  121. :NO_DEVIOCTL
  122. echo Error: No devioctl.exe!
  123. pause
  124. goto :END

  126. :END
  127. popd
  128. goto :eof
复制代码

上面是以前的旧版，只用于备忘，请不要使用了。请使用本帖开头的新版。
作者: 512154224    时间: 2018-2-4 14:41
看不懂，支持下！
作者: 不点    时间: 2018-2-9 07:16
本帖最后由 不点 于 2018-2-9 16:45 编辑

batch 文件需要以 administrator 账户运行。因此，普通管理员账户需提升权限至 administrator 账户。搜到以下解决方案：

https://stackoverflow.com/questions/41481655/cant-run-as-admin
https://stackoverflow.com/questions/7044985/how-can-i-auto-elevate-my-batch-file-so-that-it-requests-from-uac-administrator/12264592#

上述方案虽然可行，但不能在精简的 PE 下运行。PE 缺少很多命令，比如，mshta，runas，以及运行 vbs 脚本的命令。

最后只有一招是通用的（兼容 PE 环境）：鼠标右键单击 .bat 文件，在弹出菜单上选择 “以管理员身份运行” 即可。
作者: 510819776    时间: 2018-2-9 22:20
做一份备忘录
采用imdisk的注册表方式开机自动加载所需的镜像文件
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\ImDisk\Parameters]
"LoadDevices"=dword:00000002
"Size0"=hex(b):00,00,00,08,00,00,00,00
"ImageOffset0"=hex(b):00,10,00,00,00,00,00,00
"FileName0"="\\DosDevices\\D:\\1.vhd"
"DriveLetter0"="O"
"DriveLetter1"="R"
"FileName1"="\\??\\physicaldrive0"
"Flags0"=dword:00000000
"ImageOffset1"=hex(b):00,00,00,c0,07,00,00,00
"Size1"=hex(b):00,00,00,c0,00,00,00,00

一个是用1.vhd开机挂载,另一个是把扇区序列拿来开机挂载了
其中flagsx参数如果修改为0x200 会把镜像加载到内存
已经win7 64位测试成功了
作者: 不点    时间: 2018-2-10 09:54
我们遇到的困难之一，是不知道 Windows 物理驱动器与 BIOS 驱动器号码的对应关系。
前面我们已经通过 devioctl 知道了某个已知盘符所在的物理驱动器号码。
但我们真正想知道的，却是 Windows 物理驱动器号码与 BIOS 驱动器号码的对应关系。
一旦知道了这个对应关系，我们就可以用 imdisk 来驱动 grub4dos 扇区映射的虚拟盘了。
这是因为，imdisk 是 Windows 程序，只能识别 Windows 驱动器号码，不能识别 BIOS 驱动器号码。
如果找到对应关系，就等于打通了 imdisk 和 grub4dos 的脉络，不再有障碍。

以下这篇文章似乎正是需要的。

Editing the MountedDevices Registry Key
http://diddy.boot-land.net/firadisk/files/mounteddevices.htm

通过磁盘签名，就能够唯一地找到磁盘。

驱动程序在进入保护模式之前，在实模式阶段，首先保存各个 BIOS 磁盘的签名。
在进入 Windows 的保护模式之后，就检查 Windows 的各个物理磁盘的签名。
这样就建立了 BIOS 磁盘和 Windows 磁盘的对应关系。

我猜 winvblock 可能就是这么做的。

要是有人能够整合 firadisk、winvblock、imdisk，那就太好了。

作者: gnuxwy    时间: 2018-2-10 17:31
嗯，大师辛苦了。。。很有趣的解决问题办法。。。可以拓展启动思路。
作者: 不点    时间: 2018-2-11 07:55
本帖最后由 不点 于 2018-2-11 08:29 编辑

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

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

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

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

  1. /**
  2. * Check if a disk might be the matching backing disk for
  3. * a GRUB4DOS sector-mapped disk.
  4. *
  5. * @v file              HANDLE to an open disk.
  6. * @v filedisk          Points to the filedisk to match against.
  7. */
  8. static BOOLEAN STDCALL WvFilediskG4dCheckDiskMatch_(
  9.     IN HANDLE file,
  10.     IN WV_SP_FILEDISK_T filedisk
  11.   ) {
  12.     BOOLEAN ok = FALSE;

  14.     switch (filedisk->disk->Media) {
  15.         case WvlDiskMediaTypeFloppy:
  16.           break;

  18.         case WvlDiskMediaTypeHard:
  19.           ok = WvFilediskG4dCheckDiskMatchMbrSig_(file, filedisk);
  20.           if (ok)
  21.             break;
  22.           ok = WvFilediskG4dCheckDiskMatchVHD_(file, filedisk);
  23.           break;
  24.         case WvlDiskMediaTypeOptical:
  25.           ok = WvFilediskG4dCheckDiskMatchIsoSig_(file, filedisk);
  26.           break;
  27.       }
  28.     return ok;
  29.   }
复制代码


作者: chenall    时间: 2018-2-11 09:19
我觉得把firadisk、winvblock的一些特性整合进imdisk是最理想的,因为imdisk已经实现了所有需要的功能, 整合其实主要是作一些映射处理.

不懂驱动开发,帮不上忙.
作者: 不点    时间: 2018-2-11 09:26
chenall 发表于 2018-2-11 09:19
我觉得把firadisk、winvblock的一些特性整合进imdisk是最理想的,因为imdisk已经实现了所有需要的功能, 整合 ...

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

作者: 不点    时间: 2018-2-11 11:31
本帖最后由 不点 于 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 18:09
又想到一个方面的问题，提出来，供大家讨论、研究。

我们先前的开源虚拟盘驱动大致有三个（仅就我们感兴趣的而言）。其中 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) 中增加一些扇区信息” 罢了 。


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

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

可以考虑把想法和imdisk作者说说，看他是否可以把需要的功能添加上去。
作者: sp_star    时间: 2018-2-11 22:09
不点 发表于 2018-2-11 18:09
又想到一个方面的问题，提出来，供大家讨论、研究。

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

瞎猜的......
================================
看firadisk的实现，好像就是在0~64K这一段内存中直接查找grub4dos映射的磁盘，主要就是需要访问物理内存的权限，这要在驱动中完成，驱动又需要签名。
如果imdisk愿意实现，应该很简单，只要找到grub4dos的ramdisk的位置信息就可以映射了。
如果imdisk没有实现，需要一个第三方程序找到grub4dos的ramdisk的位置信息，调用imdisk来映射。这个第三方程序可能要能访问物理内存。
作者: 不点    时间: 2018-2-11 22:30
搜到一篇好文，备忘（使用了未公开的功能，不具有通用性，但确实是一篇好文，从技术上来说）：

Calling BIOS from Driver in Windows XP x64

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

作者: 不点    时间: 2018-2-12 06:54
访问物理内存，找到如下代码，但不知这个代码能否在新版 Windows 下工作：

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

  1. //========================================================
  2. //
  3. // Physmem
  4. //
  5. // Mark Russinovich
  6. // Systems Internals
  7. // http://www.sysinternals.com
  8. //
  9. // This program demonstrates how you can open and
  10. // map physical memory. This is essentially the NT
  11. // equivalent of the \dev\kmem device in UNIX.
  12. //
  13. //========================================================
  14. #include <util/wintypes.h>
  15. #include "debug.h"
  16. //#include <stdio.h>
  17. //#include "native.h"

  19. //========================================================
  20. //
  21. // Native.h
  22. //
  23. // Mark Russinovich
  24. // Systems Internals
  25. // http://www.sysinternals.com
  26. //
  27. // This file contains tyepdefs and defines from NTDDK.H.
  28. // They are included here so that we don't have to
  29. // include NTDDK.H and get all the other stuff that
  30. // we don't really need or want.
  31. //
  32. //========================================================

  34. #define PAGE_NOACCESS          0x01     // winnt
  35. #define PAGE_READONLY          0x02     // winnt
  36. #define PAGE_READWRITE         0x04     // winnt
  37. #define PAGE_WRITECOPY         0x08     // winnt
  38. #define PAGE_EXECUTE           0x10     // winnt
  39. #define PAGE_EXECUTE_READ      0x20     // winnt
  40. #define PAGE_EXECUTE_READWRITE 0x40     // winnt
  41. #define PAGE_EXECUTE_WRITECOPY 0x80     // winnt
  42. #define PAGE_GUARD            0x100     // winnt
  43. #define PAGE_NOCACHE          0x200     // winnt

  45. typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS; // windbgkd


  48. typedef LONG NTSTATUS;
  49. #define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)

  51. typedef struct _UNICODE_STRING {
  52.     USHORT Length;
  53.     USHORT MaximumLength;
  54. #ifdef MIDL_PASS
  55.     [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT * Buffer;
  56. #else // MIDL_PASS
  57.     PWSTR  Buffer;
  58. #endif // MIDL_PASS
  59. } UNICODE_STRING;
  60. typedef UNICODE_STRING *PUNICODE_STRING;

  62. typedef enum _SECTION_INHERIT {
  63.     ViewShare = 1,
  64.     ViewUnmap = 2
  65. } SECTION_INHERIT;

  67. #define OBJ_INHERIT             0x00000002L
  68. #define OBJ_PERMANENT           0x00000010L
  69. #define OBJ_EXCLUSIVE           0x00000020L
  70. #define OBJ_CASE_INSENSITIVE    0x00000040L
  71. #define OBJ_OPENIF              0x00000080L
  72. #define OBJ_OPENLINK            0x00000100L
  73. #define OBJ_VALID_ATTRIBUTES    0x000001F2L


  76. typedef struct _OBJECT_ATTRIBUTES {
  77.     ULONG Length;
  78.     HANDLE RootDirectory;
  79.     PUNICODE_STRING ObjectName;
  80.     ULONG Attributes;
  81.     PVOID SecurityDescriptor;        // Points to type SECURITY_DESCRIPTOR
  82.     PVOID SecurityQualityOfService;  // Points to type SECURITY_QUALITY_OF_SERVICE
  83. } OBJECT_ATTRIBUTES;
  84. typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES;


  87. #define InitializeObjectAttributes( p, n, a, r, s ) { \
  88.     (p)->Length = sizeof( OBJECT_ATTRIBUTES );          \
  89.     (p)->RootDirectory = r;                             \
  90.     (p)->Attributes = a;                                \
  91.     (p)->ObjectName = n;                                \
  92.     (p)->SecurityDescriptor = s;                        \
  93.     (p)->SecurityQualityOfService = NULL;               \
  94.     }


  97. //
  98. // Functions in NTDLL that we dynamically locate
  99. //

  101. typedef NTSTATUS (__stdcall *PFN_NtUnmapViewOfSection)(
  102.                 IN HANDLE  ProcessHandle,
  103.                 IN PVOID  BaseAddress
  104.                 );

  106. typedef NTSTATUS (__stdcall *PFN_NtOpenSection)(
  107.                 OUT PHANDLE  SectionHandle,
  108.                 IN ACCESS_MASK  DesiredAccess,
  109.                 IN POBJECT_ATTRIBUTES  ObjectAttributes
  110.                 );

  112. typedef NTSTATUS (__stdcall *PFN_NtMapViewOfSection)(
  113.                 IN HANDLE  SectionHandle,
  114.                 IN HANDLE  ProcessHandle,
  115.                 IN OUT PVOID  *BaseAddress,
  116.                 IN ULONG  ZeroBits,
  117.                 IN ULONG  CommitSize,
  118.                 IN OUT PLARGE_INTEGER  SectionOffset,        /* optional */
  119.                 IN OUT PULONG  ViewSize,
  120.                 IN SECTION_INHERIT  InheritDisposition,
  121.                 IN ULONG  AllocationType,
  122.                 IN ULONG  Protect
  123.                 );

  125. typedef VOID (__stdcall *PFN_RtlInitUnicodeString)(
  126.                 IN OUT PUNICODE_STRING  DestinationString,
  127.                 IN PCWSTR  SourceString
  128.                 );

  130. typedef ULONG (__stdcall *PFN_RtlNtStatusToDosError) (
  131.                 IN NTSTATUS Status
  132.                 );

  134. PFN_NtUnmapViewOfSection NtUnmapViewOfSection;
  135. PFN_NtOpenSection NtOpenSection;
  136. PFN_NtMapViewOfSection NtMapViewOfSection;
  137. PFN_RtlInitUnicodeString RtlInitUnicodeString;
  138. PFN_RtlNtStatusToDosError RtlNtStatusToDosError;

  140. //--------------------------------------------------------
  141. //
  142. // UnmapPhysicalMemory
  143. //
  144. // Maps a view of a section.
  145. //
  146. //--------------------------------------------------------
  147. VOID UnmapPhysicalMemory( DWORD Address )
  148. {
  149.         NTSTATUS                status;

  151.         status = NtUnmapViewOfSection( (HANDLE) -1, (PVOID) Address );
  152.         if( !NT_SUCCESS(status)) {
  153.                 error(status, "Unable to unmap view");
  154.         }
  155. }


  158. //--------------------------------------------------------
  159. //
  160. // MapPhysicalMemory
  161. //
  162. // Maps a view of a section.
  163. //
  164. //--------------------------------------------------------
  165. BOOLEAN MapPhysicalMemory( HANDLE PhysicalMemory,
  166.                                                         PDWORD Address, PDWORD Length,
  167.                                                         PDWORD VirtualAddress )
  168. {
  169.         NTSTATUS                        ntStatus;
  170.         PHYSICAL_ADDRESS        viewBase;

  172.         *VirtualAddress = 0;
  173.         viewBase.QuadPart = (ULONGLONG) (*Address);
  174.         ntStatus = NtMapViewOfSection (PhysicalMemory,
  175.                                (HANDLE) -1,
  176.                                (PVOID*) VirtualAddress,
  177.                                0L,
  178.                                *Length,
  179.                                &viewBase,
  180.                                Length,
  181.                                ViewShare,
  182.                                0,
  183.                                PAGE_READONLY );

  185.         if( !NT_SUCCESS( ntStatus )) {
  186.                 //error( ntStatus, "Could not map view of %X length %X", *Address, *Length );
  187.                 return FALSE;                                       
  188.         }

  190.         *Address = viewBase.LowPart;
  191.         return TRUE;
  192. }


  195. //--------------------------------------------------------
  196. //
  197. // OpensPhysicalMemory
  198. //
  199. // This function opens the physical memory device. It
  200. // uses the native API since
  201. //
  202. //--------------------------------------------------------
  203. HANDLE OpenPhysicalMemory()
  204. {
  205.         NTSTATUS                status;
  206.         HANDLE                        physmem;
  207.         UNICODE_STRING        physmemString;
  208.         OBJECT_ATTRIBUTES attributes;
  209.         WCHAR                        physmemName[] = L"\\device\\physicalmemory";

  211.         RtlInitUnicodeString( &physmemString, physmemName );        

  213.         InitializeObjectAttributes( &attributes, &physmemString,
  214.                                                                 OBJ_CASE_INSENSITIVE, NULL, NULL );                        
  215.         status = NtOpenSection( &physmem, SECTION_MAP_READ, &attributes );

  217.         if( !NT_SUCCESS( status )) {
  218.                 error(status, "Could not open \\device\\physicalmemory");
  219.                 return NULL;
  220.         }

  222.         return physmem;
  223. }



  227. //--------------------------------------------------------
  228. //
  229. // LocateNtdllEntryPoints
  230. //
  231. // Finds the entry points for all the functions we
  232. // need within NTDLL.DLL.
  233. //
  234. //--------------------------------------------------------
  235. BOOLEAN LocateNtdllEntryPoints()
  236. {
  237.         if( !(RtlInitUnicodeString = (PFN_RtlInitUnicodeString) GetProcAddress( GetModuleHandle("ntdll.dll"),
  238.                         "RtlInitUnicodeString" )) ) {

  240.                 return FALSE;
  241.         }
  242.         if( !(NtUnmapViewOfSection = (PFN_NtUnmapViewOfSection) GetProcAddress( GetModuleHandle("ntdll.dll"),
  243.                         "NtUnmapViewOfSection" )) ) {

  245.                 return FALSE;
  246.         }
  247.         if( !(NtOpenSection = (PFN_NtOpenSection) GetProcAddress( GetModuleHandle("ntdll.dll"),
  248.                         "NtOpenSection" )) ) {

  250.                 return FALSE;
  251.         }
  252.         if( !(NtMapViewOfSection = (PFN_NtMapViewOfSection) GetProcAddress( GetModuleHandle("ntdll.dll"),
  253.                         "NtMapViewOfSection" )) ) {

  255.                 return FALSE;
  256.         }
  257.         if( !(RtlNtStatusToDosError = (PFN_RtlNtStatusToDosError) GetProcAddress( GetModuleHandle("ntdll.dll"),
  258.                         "RtlNtStatusToDosError" )) ) {

  260.                 return FALSE;
  261.         }
  262.         return TRUE;
  263. }

  265. #if 0
  266. //--------------------------------------------------------
  267. //
  268. // Main
  269. //
  270. // This program drives the command loop
  271. //
  272. //--------------------------------------------------------
  273. int main( int argc, char *argv[] )
  274. {
  275.         HANDLE                physmem;
  276.         DWORD                vaddress, paddress, length;
  277.         char                input[256];
  278.         DWORD                lines;
  279.         char                ch;
  280.         DWORD                i, j;

  282.         printf("\nPhysmem v1.0: physical memory viewer\n"
  283.                    "By Mark Russinovich\n"
  284.                    "Systems Internals - http://www.sysinternals.com\n\n");

  286.         //
  287.         // Load NTDLL entry points
  288.         //
  289.         if( !LocateNtdllEntryPoints() ) {

  291.                 printf("Unable to locate NTDLL entry points.\n\n");
  292.                 return -1;
  293.         }

  295.         //
  296.         // Open physical memory
  297.         //
  298.         if( !(physmem = OpenPhysicalMemory())) {

  300.                 return -1;
  301.         }

  303.         //
  304.         // Enter the command loop
  305.         //
  306.         printf("Enter values in hexadecimal. Enter 'q' to quit.\n");
  307.         while( 1 ) {

  309.                 printf("\nAddress: " ); fflush( stdout );
  310.                 gets( input );
  311.                 if( input[0] == 'q' || input[0] == 'Q' ) break;
  312.                 sscanf( input, "%x", &paddress );

  314.                 printf("Bytes: "); fflush( stdout );
  315.                 gets( input );
  316.                 if( input[0] == 'q' || input[0] == 'Q' ) break;
  317.                 sscanf( input, "%x", &length );

  319.                 //
  320.                 // Map it
  321.                 //
  322.                 if( !MapPhysicalMemory( physmem, &paddress, &length,
  323.                                                                 &vaddress ))
  324.                         continue;

  326.                 //
  327.                 // Dump it
  328.                 //
  329.                 lines = 0;
  330.                 for( i = 0; i < length; i += BYTESPERLINE ) {

  332.                         printf("%08X: ", paddress + i );

  334.                         for( j = 0; j < BYTESPERLINE; j++ ) {

  336.                                 if( i+j == length ) break;
  337.                                 if( j == BYTESPERLINE/2 ) printf("-" );
  338.                                 printf("%02X ", *(PUCHAR) (vaddress + i +j ));
  339.                         }

  341.                         for( j = 0; j < BYTESPERLINE; j++ ) {

  343.                                 if( i+j == length ) break;
  344.                                 ch = *(PUCHAR) (vaddress + i +j );

  346.                                 if( __iscsym( ch ) ||
  347.                                         isalnum( ch ) ||
  348.                                         ch == ' ') {

  350.                                         printf("%c", ch);

  352.                                 } else {

  354.                                         printf("." );
  355.                                 }
  356.                         }

  358.                         printf("\n");

  360.                         if( lines++ == LINESPERSCREEN ) {

  362.                                 printf("-- more -- ('q' to abort)" ); fflush(stdout);
  363.                                 ch = getchar();
  364.                                 if( ch == 'q' || ch == 'Q' ) {
  365.                                         fflush( stdin );
  366.                                         break;
  367.                                 }
  368.                                 lines = 0;
  369.                         }
  370.                 }

  372.                 //
  373.                 // Unmap the view
  374.                 //
  375.                 UnmapPhysicalMemory( vaddress );
  376.         }

  378.         //
  379.         // Close physical memory section
  380.         //
  381.         CloseHandle( physmem );

  383.         return 0;
  384. }
  385. #endif
复制代码
作者: 不点    时间: 2018-2-12 07:35
本帖最后由 不点 于 2018-2-12 12:08 编辑

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

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

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

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

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

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

PhysicalMemoryViewer_V1.0.0.0.zip

1.05 MB, 下载次数: 15, 下载积分: 无忧币 -2

Windows 下查看物理内存，德语操作界面
作者: sp_star    时间: 2018-2-12 14:03
这个工具是.net的，没运行起来。可以试试读取0~1M的内存，看看grub4dos的信息能不能找到。
里面还有个physmem.sys驱动，好像签名齐全啊，只是不知道怎么用。
作者: 不点    时间: 2018-2-12 15:32
sp_star 发表于 2018-2-12 14:03
这个工具是.net的，没运行起来。可以试试读取0~1M的内存，看看grub4dos的信息能不能找到。
里面还有个phys ...

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

只需验证 XP 下能否读高位内存即可。Win7x64 已经验证成功。
作者: sp_star    时间: 2018-2-12 16:31
不点 发表于 2018-2-12 15:32
试验过了，完全能读出物理内存啊。

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

grub4dos的信息应该是在低位内存吧? 即使实际磁盘在高位内存，也要靠imdisk去处理。如果知道ramdisk在内存中的地址和大小，imdisk能直接映射吗?
作者: 不点    时间: 2018-2-12 17:02
sp_star 发表于 2018-2-12 16:31
grub4dos的信息应该是在低位内存吧? 即使实际磁盘在高位内存，也要靠imdisk去处理。如果知道ramdisk在内 ...

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

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

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

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



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

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

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

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

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

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

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

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

总体感觉，firadisk 毛病不严重，其毛病容易解决。
作者: 不点    时间: 2018-2-12 18:45
我在 win7 下安装了 Visual Studio 2017，结果不能编译任何程序。它要求操作系统是 Win10。

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


作者: chenall    时间: 2018-2-12 20:46
本帖最后由 chenall 于 2018-2-12 20:47 编辑

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

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


也许你可以把这些需求到reboot回复给作者看看他能不能直接加上．毕竟我们如果自己要编译的话那个签名就是一个大麻烦．
作者: 不点    时间: 2018-2-12 22:33
chenall 发表于 2018-2-12 20:46
我也是用windows 7的安装了vs 2017可以正常使用呀，编译驱动还需要安装winddk.我之前有测试编译imdisk，编 ...

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

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

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

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


作者: 不点    时间: 2018-2-12 22:56
本帖最后由 不点 于 2018-2-12 22:58 编辑

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

MmMapIoSpace(0, 0, 0);

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

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

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

在网上搜了许多天，也见不到一个能够在（新近的） Windows 下 dump 物理内存的开源工具。前面介绍的那个开源的工具只能在 xp 上运行。
作者: 苏州本是    时间: 2018-2-12 23:44
dos时代菜鸟 发表于 2018-1-28 09:38
vbs脚本

谢谢分享好东西！
作者: 527104427    时间: 2018-2-13 00:04
chenall 发表于 2018-2-12 20:46
我也是用windows 7的安装了vs 2017可以正常使用呀，编译驱动还需要安装winddk.我之前有测试编译imdisk，编 ...





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






作者: sp_star    时间: 2018-2-25 11:03
一个小工具，在windows下读GRUB4DOS map的磁盘信息。

G4D.zip

112.73 KB, 下载次数: 19, 下载积分: 无忧币 -2

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

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

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

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

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

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

g4d.zip

2.74 KB, 下载次数: 11, 下载积分: 无忧币 -2

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

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

我把你提供的代码贴出来，方便有兴趣者查看。
  1. // mdisk.cpp : 定义控制台应用程序的入口点。
  2. //

  4. #include "stdafx.h"
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <conio.h>
  8. #include <windows.h>
  9. #include <shellapi.h>
  10. //#include <winable.h>

  12. typedef BOOL(WINAPI *INITIALIZEWINTO)(void);
  13. typedef BOOL(WINAPI *SHUTDOWNWINIO)(void);
  14. typedef BOOL(WINAPI *GETPORTVAL)(WORD wPortAddr, PDWORD pdwPortVal, BYTE bSize);
  15. typedef BOOL(WINAPI *SETPORTVAL)(WORD wPortAddr, DWORD dwPortVal, BYTE bSize);
  16. typedef PBYTE(_stdcall *MAPPHYSTOLIN)(PBYTE pbPhysAddr, DWORD dwPhysSize, HANDLE *pPhysicalMemoryHandle);  
  17. typedef BOOL(_stdcall *UNMAPPHYSICALMEMORY)(HANDLE PhysicalMemoryHandle, PBYTE pbLinAddr);  
  18. typedef BOOL(WINAPI *GETPHYSLONG)(PBYTE pbPhysAddr, PDWORD pdwPhysVal);  
  19. typedef BOOL(WINAPI *SETPHYSLONG)(PBYTE pbPhysAddr, DWORD dwPhysVal);
  20. //typedef BOOL(WINAPI *INSTALLWINIODRIVER)(PWSTR pszWinIoDriverPath, bool IsDemandLoaded = false);  　
  21. //typedef BOOL(WINAPI *REMOVEWINIODRIVER)();  

  23. INITIALIZEWINTO   InitializeWinIo = NULL;
  24. SHUTDOWNWINIO        ShutdownWinIo = NULL;
  25. GETPORTVAL  GetPortVal = NULL;
  26. SETPORTVAL  SetPortVal = NULL;
  27. MAPPHYSTOLIN MapPhysToLin = NULL;   
  28. UNMAPPHYSICALMEMORY UnmapPhysicalMemory = NULL;  
  29. GETPHYSLONG GetPhysLong = NULL;
  30. SETPHYSLONG SetPhysLong = NULL;
  31. //INSTALLWINIODRIVER InstallWinIoDriver = NULL;
  32. //REMOVEWINIODRIVER RemoveWinIoDriver = NULL;

  34. BOOL InitFuncs(void)
  35. {
  36.         HMODULE hMod = LoadLibrary(_T("WinIo32.dll"));
  37.     InitializeWinIo= (INITIALIZEWINTO)GetProcAddress(hMod,"InitializeWinIo");
  38.         ShutdownWinIo= (SHUTDOWNWINIO)GetProcAddress(hMod,"ShutdownWinIo");
  39.     GetPortVal= (GETPORTVAL)GetProcAddress(hMod,"GetPortVal");
  40.         SetPortVal= (SETPORTVAL)GetProcAddress(hMod,"SetPortVal");
  41.         MapPhysToLin=(MAPPHYSTOLIN)GetProcAddress(hMod,"MapPhysToLin");  
  42.         UnmapPhysicalMemory=(UNMAPPHYSICALMEMORY)GetProcAddress(hMod,"UnmapPhysicalMemory");  
  43.         GetPhysLong=(GETPHYSLONG)GetProcAddress(hMod,"GetPhysLong");  
  44.         SetPhysLong=(SETPHYSLONG)GetProcAddress(hMod,"SetPhysLong");  
  45.         //InstallWinIoDriver=(INSTALLWINIODRIVER)GetProcAddress(hMod,"InstallWinIoDriver");        
  46.         //RemoveWinIoDriver=(REMOVEWINIODRIVER)GetProcAddress(hMod,"RemoveWinIoDriver");  

  48.         if(InitializeWinIo==NULL) return FALSE;
  49.         if(ShutdownWinIo==NULL) return FALSE;
  50.         if(GetPortVal==NULL) return FALSE;
  51.         if(SetPortVal==NULL) return FALSE;
  52.         if(MapPhysToLin==NULL) return FALSE;
  53.         if(UnmapPhysicalMemory==NULL) return FALSE;
  54.         if(GetPhysLong==NULL) return FALSE;
  55.         if(SetPhysLong==NULL) return FALSE;
  56.         //if(InstallWinIoDriver==NULL) return FALSE;
  57.         //if(RemoveWinIoDriver==NULL) return FALSE;
  58.         
  59.         return TRUE;
  60. }


  63. BOOL ReadPhysicalMemory(unsigned int phyAddr, DWORD phySize, unsigned char *buf)
  64. {
  65.         unsigned int addr;
  66.         unsigned long data;
  67.         unsigned long *p=(unsigned long *)buf;
  68.         for(unsigned int i=0;i<phySize;i+=4)
  69.         {
  70.                 addr=phyAddr+i;
  71.                 GetPhysLong((PBYTE)addr,&data);
  72.                 *p=data;
  73.                 p++;
  74.         }
  75.         return TRUE;
  76. }

  78. void print_buf(unsigned char *p)
  79. {
  80.         for(int k=0;k<200;k++)
  81.         {
  82.                 printf("%c",*(p+k));
  83.         }
  84.         printf("\n");
  85. }

  87. void find_g4d_drive(unsigned char* buf, int bufLen);


  90. int _tmain(int argc, _TCHAR* argv[])
  91. {

  93.     if(InitFuncs()!=TRUE)
  94.         {
  95.                 printf("Load WinIo.dll failed!\n");
  96.                 return 0;
  97.         }
  98.     if(InitializeWinIo()!=TRUE)
  99.         {
  100.                 printf("InitializeWinIo failed!\n");
  101.                 return 0;
  102.         }
  103.         printf("InitializeWinIo OK!\n");

  105.         printf("\n");
  106.         //printf("DWORD length=%d\n",sizeof(DWORD));
  107. #if 0        
  108.         HANDLE hPhyMem;
  109.         PBYTE pbLinAddr;
  110.         //下面的语句让 0xf0000 地址的 65536 个字节可直接读写
  111.     pbLinAddr = MapPhysToLin((unsigned char *)0xf0000,65536,&hPhyMem);
  112.         printf("pbLinAddr=%x\n",pbLinAddr);

  114.         DWORD ttmp;
  115.         BOOL rtv;
  116.         rtv=GetPhysLong((PBYTE)0xf0000,&ttmp);
  117.         printf("rtv=%d, ttmp=%x\n",rtv, ttmp);
  118.         
  119. #endif        
  120.         // real-mode RAM range 0-640KB
  121.     const int nBytes=0xA0000;
  122.         unsigned char buf[nBytes];
  123.         memset(buf,0,nBytes);
  124.         ReadPhysicalMemory(0,nBytes,buf);
  125.     //print_buf(buf);

  127.     find_g4d_drive(buf,nBytes);

  129.         ShutdownWinIo();
  130.         printf("Done!\n");
  131.         return 0;
  132. }

  134. typedef struct _INTRVECT {
  135.         UINT16 offset;
  136.         UINT16 segment;
  137. } INTRVECT, *PINTRVECT;

  139. typedef struct _GRUB4DOS_DRIVE_MAP_SLOT {
  140.         unsigned char from_drive;
  141.         unsigned char to_drive;                        // 0xFF indicates a memdrive
  142.         unsigned char max_head;
  143.         unsigned char max_sector:6,
  144.                 disable_lba:1,                // bit 6: disable lba
  145.                 read_only:1;                // bit 7: read only
  146.         unsigned short to_cylinder:13,        // max cylinder of the TO drive
  147.                 from_cdrom:1,                // bit 13: FROM drive is CDROM(with big 2048-byte sector)
  148.                 to_cdrom:1,                        // bit 14:  TO  drive is CDROM(with big 2048-byte sector)
  149.                 to_support_lba:1;        // bit 15:  TO  drive support LBA
  150.         unsigned char to_head;                        // max head of the TO drive
  151.         unsigned char to_sector:6,                // max sector of the TO drive
  152.                 fake_write:1,                // bit 6: fake-write or safe-boot
  153.                 in_situ:1;                        // bit 7: in-situ
  154.         UINT64 start_sector;
  155.         UINT64 sector_count;
  156. } GRUB4DOS_DRIVE_MAP_SLOT, *PGRUB4DOS_DRIVE_MAP_SLOT;

  158. void print_drv_map(PGRUB4DOS_DRIVE_MAP_SLOT slot)
  159. {
  160.         int dataLen=sizeof(GRUB4DOS_DRIVE_MAP_SLOT);
  161.         printf("DATA: ");
  162.         for(int k=0;k<dataLen;k++)
  163.         {
  164.                 printf("%.2X ", *((unsigned char *)slot+k) );
  165.         }
  166.         printf("\n");

  168.         UINT64 drvlen=slot->sector_count<<9;
  169.         UINT64 address=slot->start_sector<<9;
  170.         printf("Detected GRUB4DOS disk offset=0x%I64x bytes, len=%I64d KB\n",address, drvlen>>10);
  171.         

  173.     printf("   GRUB4DOS SourceDrive: 0x%02x\n", slot->from_drive);
  174.     printf("   GRUB4DOS DestDrive: 0x%02x\n", slot->to_drive);
  175.     printf("   GRUB4DOS MaxHead: %d\n", slot->max_head);
  176.     printf("   GRUB4DOS MaxSector: %d\n", slot->max_sector);
  177.     printf("   GRUB4DOS DestMaxCylinder: %d\n", slot->to_cylinder);
  178.     printf("   GRUB4DOS DestMaxHead: %d\n", slot->to_head);
  179.     printf("   GRUB4DOS DestMaxSector: %d\n", slot->to_sector);
  180.     printf("   GRUB4DOS SectorStart: 0x%08x\n", slot->start_sector);
  181.     printf("   GRUB4DOS SectorCount: %d\n", slot->sector_count);
  182.     printf("\n");
  183.         printf("   GRUB4DOS disable_lba=%d\n", slot->disable_lba);
  184.         printf("   GRUB4DOS read_only=%d\n", slot->read_only);
  185.         printf("   GRUB4DOS from_cdrom=%d\n", slot->from_cdrom);
  186.         printf("   GRUB4DOS to_cdrom=%d\n", slot->to_cdrom);
  187.         printf("   GRUB4DOS to_support_lba=%d\n", slot->to_support_lba);
  188.         printf("   GRUB4DOS fake_write=%d\n", slot->fake_write);
  189.         printf("   GRUB4DOS in_situ=%d\n", slot->in_situ);

  191. }

  193. void print_vector(INTRVECT * pvec)
  194. {
  195.         printf("offset=0x%.4x  ", pvec->offset);
  196.         printf("segment=0x%.4x", pvec->segment);
  197.         printf("\n");
  198. }

  200. void print_string(unsigned char *buf,UINT32 int13entry)
  201. {
  202.         unsigned char tmp_str[9];
  203.     memset(tmp_str,0,9);
  204.         memcpy(tmp_str,buf+int13entry+3,8);
  205.         printf("%s  ",tmp_str);
  206.     memset(tmp_str,0,9);
  207.         memcpy(tmp_str,buf+int13entry+3+8,8);
  208.         printf("%s\n",tmp_str);
  209. }

  211. int check_string(unsigned char *buf,UINT32 int13entry)
  212. {
  213.         int cmp=-1;
  214.         
  215.         unsigned char tmp_str[9];
  216.     memset(tmp_str,0,9);
  217.         memcpy(tmp_str,buf+int13entry+3,8);
  218.         cmp = strcmp((char *)tmp_str,"$INT13SF");
  219.         if(cmp!=0) return 0;

  221.         memset(tmp_str,0,9);
  222.         memcpy(tmp_str,buf+int13entry+3+8,8);
  223.         cmp = strcmp((char *)tmp_str,"GRUB4DOS");
  224.         if(cmp==0)
  225.         {
  226.                 //printf("Found GRUB4DOS\n");
  227.                 return 1;
  228.         }

  230.         return 0;
  231. }

  233. void find_g4d_drive(unsigned char* buf, int bufLen)
  234. {
  235.         //bufLen=0xA0000;  //640K

  237.         INTRVECT int13vector;
  238.         UINT32 int13entry;
  239.         int found=0;

  241.         /*for(int kk=0;kk<0x40;kk++)
  242.         {
  243.         int13vector = ((PINTRVECT)buf)[kk];        
  244.         int13entry = (((UINT32)int13vector.segment << 4) + int13vector.offset);        
  245.         printf("int13entry=0x%lX [%.4X:%.4X]\n",int13entry,int13vector.segment,int13vector.offset);
  246.         }
  247.         printf("\n");
  248.         return;
  249.         */
  250.         
  251.         int13vector = ((PINTRVECT)buf)[0x13];        
  252.         int13entry = (((UINT32)int13vector.segment << 4) + int13vector.offset);
  253.         while(int13entry<0xA0000-27)
  254.         {
  255.                 //if(int13entry==0) continue;
  256.                 printf("int13entry=0x%lX [%.4X:%.4X]\n",int13entry,int13vector.segment,int13vector.offset);
  257.                 found=check_string(buf,int13entry);
  258.                 if(found==1)
  259.                 {
  260.                         PGRUB4DOS_DRIVE_MAP_SLOT pdrvmap;
  261.                         //drive map slot starts at offset 0x20 of the same segment as int13 entry
  262.                         pdrvmap = (PGRUB4DOS_DRIVE_MAP_SLOT)(buf+(((UINT32)int13vector.segment << 4) + 0x20));                        
  263.                         printf("Found GRUBDOS drive at offset 0x%lX [%.4X:%.4X], data length=%d bytes\n",
  264.                                 (unsigned char *)pdrvmap-buf,int13vector.segment,0x20,
  265.                                 sizeof(GRUB4DOS_DRIVE_MAP_SLOT) );
  266.                         printf("\n");
  267.                     print_drv_map(pdrvmap);
  268.                         printf("\n");
  269.                         
  270.                 }
  271.                 int13vector = *((UNALIGNED INTRVECT *)(buf+int13entry+3+8+8));
  272.                 int13entry = (((UINT32)int13vector.segment << 4) + int13vector.offset);
  273.                 //printf("==>int13entry=0x%lX [%.4X:%.4X]\n",int13entry,int13vector.segment,int13vector.offset);
  274.         
  275.         }
  276. }
复制代码
作者: 不点    时间: 2018-2-25 13:39
本帖最后由 不点 于 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 框里显示 “拒绝访问。”

回到命令提示符。


  1. D:\G4D>dir
  2. 驱动器 D 中的卷没有标签。
  3. 卷的序列号是 0000-4823

  5. D:\G4D 的目录

  7. 2018/02/25  13:31    <DIR>          .
  8. 2018/02/25  13:31    <DIR>          ..
  9. 2018/02/25  10:10           161,280 g4d.exe
  10. 2010/05/15  23:56            45,568 WinIo32.dll
  11. 2010/05/08  23:16             6,656 WinIo32.sys
  12. 2010/05/15  23:56            44,544 WinIo64.dll
  13. 2010/05/08  23:46            10,920 WinIo64.sys
  14.                5 个文件        268,968 字节
  15.                2 个目录 263,994,019,840 可用字节

  17. D:\G4D>g4d
  18. InitializeWinIo failed!

  20. D:\G4D>
复制代码

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

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

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



欢迎光临 无忧启动论坛 (http://bbs.c3.wuyou.net/) Powered by Discuz! X3.3