Windows image file boot — Ваш верный помощник с OS Windows

2 out of 2 rated this helpful — Rate this topic

Updated: April 2, 2014

Windows image file boot (WIMBoot) lets you set up a PC so that it runs directly from a compressed Windows image file (WIM file).

WIMBoot can significantly reduce the amount of space used by Windows files. This helps you provide more free space to users, and helps you manufacture Windows on PCs with smaller drives.

WIMBoot can also help reduce manufacturing time:

You can deploy Windows with fewer compression/decompression steps.
You can make updates to the image on the factory floor faster by using a separate customized image file.
You can refresh a PC or restore it to its factory state faster. This reduces the need to create a separate partition for testing a PC on the factory floor, and can also help reduce PC support calls.

WIMBoot is available for client editions of Windows 8.1 with Windows 8.1 Update only (not server versions). All architectures are supported, including amd64, x86, and ARM. Some enterprise deployment tools do not support WIMBoot.
WIMBoot is available only for UEFI-based PCs running in UEFI mode (legacy BIOS-compatibility mode isn’t supported).
WIMBoot is supported for solid-state drives and eMMC (Windows HCK compliant) drives. WIMBoot isn’t supported on traditional drives that contain rotational components, or on hybrid drives that contain both solid-state and rotational drive components. WIMBoot works by taking advantage of the capability of solid-state drives to access different areas of the hard drive quickly.

It’s OK to have a secondary drive attached to the PC, and the secondary drive can contain rotational components. But the WIMBoot image and pointer files must all be located on the primary solid-state or eMMC drive.
Some backup, antivirus, and encryption tools aren’t compatible with WIMBoot images.

In a standard Windows installation (without WIMBoot), every file is written to disk at least twice: once in the compressed form for recovery, and once in the uncompressed form in the applied image. When the push-button reset feature is included, the compressed image remains on the PC. Having both the Windows installation and recovery image on the device can take up a lot of disk space.

When installing Windows with WIMBoot, you write the files to the disk only once, in compressed format. Next, you apply a set of pointer files onto the Windows partition that point back to the compressed files in the Images partition. When the user adds files, apps, or updates, they’re added onto the Windows partition.

In WIMBoot, your WIMBoot image is also used as the recovery image, saving disk space.

WIMBoot uses a new partition layout.

Standard partition layout (without WIMBoot):

The Windows 8.1 partition layout includes two system partitions (ESP and MSR), a Windows partition, and two separate recovery partitions:

Partitions: System, MSR, WinRE, Windows, Recovery

With WIMBoot:

The Images partition contains the compressed images of the Windows files (install.wim), the Windows RE recovery tools (winre.wim), and other factory floor customizations (custom.wim).
The Windows partition contains the pointer files to the compressed image, plus free space for any new files created by the end user, including registry files, page files, hibernation files, user data, and user-installed apps and updates.

For more info, see Deploy WIMBoot Images: If you know the size of the images upfront.

Partitions map: System, MSR, Windows, Images

The WIMBoot process supports creating a separate custom.wim file for final customizations, such as Windows updates, build-to-order apps and drivers, or other changes that typically happen on the factory floor. This means you don’t have to recapture these updates into the fully-loaded install.wim. This change can potentially save time during the manufacturing process.

If the user refreshes the image, the push-button reset tools refresh the pointers to both the install.wim and the custom.wim file.

For more info, see Create WIMBoot Images and Deploy WIMBoot Images: If you know the size of the images upfront.

WIMBoot is compatible with Secure Boot.

We don’t recommend that you use encryption tools, such as BitLocker, on the Images partition because this might reduce system performance. If you have sensitive apps or data to preinstall, install them to the Windows partition.

To deploy Windows using the WIMBoot, you’ll need the Windows 8.1 Update version of the Windows Assessment and Deployment Kit (Windows ADK), with the following tools.

You’ll need the updated version of DISM to capture and apply the installation files. For more info, see What’s New in DISM.

The updated version of Windows PE includes the updated version of DISM, which you’ll use to capture and apply the installation files.

For WIMBoot PCs:

The push-button reset feature is enabled automatically for client editions of Windows and cannot be disabled or opted out of. You don’t need to register your push-button reset WIM file (install.wim).
You’ll still need to register the Windows RE file (winre.wim). For more info, see Deploy WIMBoot Images: If you know the size of the images upfront.
The built-in recovery drive creator (bare metal reset) is enabled automatically for client editions of Windows, using the WIMBoot hard drive partition layout. If you’re using a non-standard partition configuration, you’ll need to update your ResetConfig.xml file and add the new WIMBoot parameter. For more info, see ResetConfig XML Reference.

Overview

Windows Image Boot (WIMBoot) is a new feature in Windows 8.1 that enables you to install and run the operating system from a compressed WIM file on your device. This saves space on your device and can speed up startup times. In this article, we will explain what WIMBoot is, how it works, its advantages and disadvantages, and show you how to create a Wimboot Installation on your device.

1. What is Windows Image Boot (WIMBoot)?

WIMBoot is a technology that allows computers with limited storage space to operate system-level functions. It accomplishes this by reading the Windows imaging file (WIM) from an existing hard drive instead of installing it onto newly available blank media, thus saving time and money in distribution costs for OEM manufacturers. Additionally, it speeds up upgrades/installations compared to traditional methods since less data needs inscription into boot settings. The idea behind WIMBoot is that it enables Windows devices with less storage space to get the full version of the system while still having more than enough room for data or applications.

2. How does Wimboot Works?

During a traditional Windows installation, all system files will be written to the local disk twice: the first time, a compressed archive of the system backup file is written to the disk. The second time, an uncompressed archive of the system files is written. Our local system disk will store a compressed version of the system backup file when the system installation is finished. Many system installation files and backup files occupy our local disk space, so the minimum disk space requirement for Windows 8.1 is 16GB, and the actual installation occupies about 10GB of hard disk space.

When using WIMBoot technology to install a new Windows system, the entire process is written to the local disk only once, and the entire process is done in a compressed archive. Then, the Windows partition will set a set of pointers to the corresponding compressed files in the image partition. As the user continues to write new files, Modern applications, and update patches for the system, these new files will be written to the Windows partition.

In addition, the WIMBoot image generated by the WIMBoot can be applied as a system to restore an image to continue saving local disk space.

3. Advantages of WIMBoot

With WIMBoot, Windows can be installed on a smaller number of partitions, which reduces the amount of disk space required and helps to improve system performance.

The system file after WIMBOOT is actually an image boot, and the disk performance under WIMBOOT is slightly improved compared to the normal mode.

You can get going faster by simplifying the process and removing extra steps from downloading an operating system like Windows onto your device.

It can use http rather than TFTP while having more compatibility between boot loading environments such as bios & UEFI.

In brief, the advantage of WIMBOOT are mainly as follows:

Save disk space.

Reduce system file addressing time.

Reinstalling your system is even easier.

BIOS/UEFI compatibility.

4. Disadvantages of WIMBoot

One of the disadvantages to using WIMBoot is that it only works on UEFI-based computers, which means any computer with a legacy BIOS will not be able to get these benefits. Another issue could arise if you have certain security software installed, some versions don’t play well together, so there may be an error or something similar. Also, loading WIM image at the boot is slightly slower than normal mode.

Disadvantages are simply:

Slightly slow to load on boot.

Only for UEFI-based computers.

Software compatibility is not so good.

5. How Much Space Does WIMBoot Need?

With WIMBoot, Windows will use much less disk space on your PC, which means you’ll have more free space for your personal files. So, how much space does WIMBoot need?

To compress Windows system files, WIMBoot needs around 4GB of free disk space. Which is a significant reduction from the more than 20 GB Windows typically needs.

In addition, WIMBoot will also compress Windows files to take up even less space. However, the actual amount of space you’ll need will depend on the size of your Windows system files. For example, if you have a lot of personal files, you may need more than 2GB of free disk space to use WIMBoot.

Overall, though, WIMBoot is a great way to reduce the storage space Windows uses without sacrificing too much in terms of performance.

6. How To Get WIMBoot

When you buy one of these new «Windows 8.1 Update» computers, you get a Windows system with WIMBoot installed, including a small amount of storage space. You can also download it from here: https://github.com/ipxe/wimboot/releases/latest/download/wimboot.

Before you can install it, you need to make sure that the hardware and software of the device meet the installation requirements.

Operating System: Windows 8.1 Update

Hardware Requirement: SSD, eMMC

7. How to Create a Wimboot Installation

If you have fully understood WIMBoot and would like to test it yourself, then please read the following steps:

First, create a WIM file of your Windows installation.

Then, apply the WIM file to your WIMBoot-optimized image.

Finally, configure your computer to boot from the WIMBoot-optimized image.

For more information on creating a Wimboot installation of Windows, see the documentation for your version of Windows.

Conclusion

WIMBoot as a new Windows 8.1 system installation method, and its advantages are still very obvious, especially for those Windows 8.1 devices with small storage capacity. It can save a lot of space. So it is very practical for manufacturers and users. Are you interested in WIMBoot after reading the introduction? If you want to know more about WIMBoot, you can check the official Microsoft website.

Источник

This method allows you to directly boot from a number of different unmodified Windows Install 7/8/10 ISOs on a bootable USB drive AND then run Setup to install Windows to a system.

No files need to be extracted from the ISO – just copy the ISO file and boot!

Legacy, UEFI or PXE boot is supported.
The ISO is automatically mounted as a virtual drive so Setup can find and use the Install.wim\esd file.
2GB or more RAM is required to be in the system (it may fail to work if not enough RAM is available).
The Windows Install ISO file does not need to be modified in any way.

I will describe here only the outline process so that you can see how it is done. Easy2Boot uses a similar (but not identical) process when MBR-booting.

Example grub2 menus are also provided (grub4dos only MBR boots, grub2 will MBR and UEFI32 and UEFI64 boot).

PROCESS IN OUTLINE:

Add Windows Install ISO to a grub4dos or grub2 bootable USB drive
Add a menu for grub4dos\grub2
The menu uses wimboot to boot to files inside the ISO
Add in a null.cfg file which contains the full path of the ISO (except for the drive letter)
The menu also injects a startnet.bat file and winpeshl.ini file
For MBR booting we swap BIOS device hd0 with hd1 so that Windows does not think the boot drive is the USB drive (it may refuse to install Windows to a Removable USB drive or Setup may install the Windows boot code to a USB hard disk if we don’t do this).
When the grub2\grub4dos menu is picked, here is what happens…
1. The ISO is mounted (by grub4dos as a CD device using map or by grub2 as a loop device)
2. wimboot will load the boot.wim, boot.SDI and BCD from the mounted ISO into RAM
3. wimboot injects into the boot.wim\X: RAM drive a null.cfg file which contains the file path of the ISO
4. wimboot injects into the boot.wim\X: RAM drive a winpeshl.ini and startup.bat file
5. The boot.wim file is booted to by wimboot via bootmgr+BCD and startup.bat runs
6. startup.bat finds the USB drive and installs ImDisk (which is also located in a folder on the USB drive somewhere)
7. startup.bat finds the null.cfg file in X:\Windows\System32 and from this we can determine the name of the ISO that we need to load
8. startup.bat uses ImDisk to load the ISO as drive Y: from the USB drive
9. startup.bat runs X:\Setup.exe which will now be able to find the \sources\install.wim file on the Y: virtual DVD drive mounted by ImDisk

If required, we can also inject an XML file into the X:\Windows\System32 folder and specify this as the unattend file when we run setup.exe. This will cause Setup to be automated.

For MBR-bootong, it is necessary to swap the BIOS drives 0 (USB drive) and 1 around so that Windows will think the ‘boot’ drive is the internal hard disk and not the USB drive – otherwise Windows will refuse to install the boot code (and the Windows OS) to the first internal hard disk.

Download files – see link at the bottom of this article.

You can use VBox+VMUB to test (see Tutorial 4) but the grub2 drivemap command can cause WinPE to hang and not boot in a VM.

Example grub2 MBR menu:

menuentry "WIN10 Install" --unrestricted --class Windows {
set isoname=win10.iso
loopback loop /$isoname
linux16 /wimboot/wimboot
initrd16 \
newc:bcd:(loop)/boot/bcd \
newc:null.cfg:/wimboot/null.cfg \
newc:winpeshl.ini:/wimboot/winpeshl.ini \
newc:startup.bat.sdi:/wimboot/startup.bat \
newc:boot.sdi:(loop)/boot/boot.sdi \
newc:boot.wim:(loop)/sources/boot.wim
drivemap -s hd0 hd1
boot
)

Note: filenames defined after newc: must not be bigger than 31 characters or wimboot will fail.

Also grub is case sensitive so beware! – e.g. /Boot/boot.sdi instead of /boot/boot.sdi.

wimboot will try to locate a suitable bootmgr or bootxxx.efi boot file, so you don’t usually need to specify one.

You can also add in bootmgr.exe or bootmgr or bootx64.efi/bootmgfw.efi files if the wim file does not contain a suitable file (copy the files to the \wimboot folder) add an extra @bootmgr=/bootmgr.exe entry (or /bootmgr (or /bootmgfw.efi if UEFI).

iPXE wimboot is used for MBR booting but a special grub2 (unsigned, non-secure) version of grub2 with wimboot.mod is required for UEFI-booting.

Example MBR grub4dos menu:

Use Grub4dos 2020-02-29.7z (note: shows as 2020-03-04 in command prompt) (other versions may have bugs – so try this version first!)

Most files are in grub2_wimboot.zip (see end of page).

title Install Windows10x64UK_Oct_2018 using wimboot method
map /Windows10x64UK_Oct_2018.iso (0xff)
map --hook
root (0xff)
# the root path now points to the files inside the ISO file
# hd0,0 is the USB drive that we booted from
kernel (hd0,0)/wimboot/wimboot
initrd @null.cfg=(hd0,0)/wimboot/null.cfg @startup.bat=(hd0,0)/wimboot/startup.bat @winpeshl.ini=(hd0,0)/wimboot/winpeshl.ini @bcd=/boot/bcd @boot.sdi=/boot/boot.sdi @boot.wim=/sources/boot.wim
map (hd0) (hd1)
map (hd1) (hd0)
map --hook
boot

IMPORTANT: order of the files in the initrd line seems to be important, the bcd and .wim file should be the last files loaded for the MBR version of wimboot.

On our USB drive we have a \wimboot folder:

\wimboot\wimboot
\wimboot\winpeshl.ini
\wimboot\startup.bat
\wimboot\null.cfg (contains the line installiso=xxxxxxxxx where xxxxxxxxx is the path and filename of the ISO using forward slashes)
\wimboot\imdisk\(files from grub2_wimboot.zip)
\Windows10x64UK_Oct_2018.iso

Example winpeshl.ini

[LaunchApps] startup.bat

See Easy2Boot’s \_ISO\e2b\docs\QRUN.g4b file (search for ‘wimboot’ to see how you can use grub4dos to change null.cfg contents, etc.

ADDING A ‘WINDOWS INSTALL FROM ISO’ MENU TO THE E2B GRUB2 MENU SYSTEM

Set up your E2B drive with a second partition and the E2B grub2 menu files FIRST, then switch to the .imgPTN23 file so that the first partition contains the standard grub2 boot menu system files and the second partition contains your grub2 menu folders (e.g. \_ISO\MAINMENU, etc.) and then…

The following windows_install.grub2 menu text file can be added to the \_ISO\MAINMENU folder on the 2nd partition.

Download the grub2_wimboot files – extract it onto the root of the 2nd partition so you have a new \wimboot folder
Download the windows_install.grub2 file and copy it to \_ISO\MAINMENU\grub2 folder on the 2nd E2B partition. Rename it as custom_menu.grub2 if using grub2 Beta 10 or later.
Create a new \_ISO\MAINMENU\WINDOWS folder (must be in capital letters) on the 2nd partition and place all your Windows Install ISOs in that folder.

This is for MBR booting

2nd partition (additions)

\wimboot folder
\_ISO\MAINMENU\grub2\custom_menu.grub2
\_ISO\MAINMENU\WINDOWS\ (your windows isos here)

Note: E2B grub2 v10W.imgPTN already includes wimboot and a new Windows Install W menu (you just copy your ISOs to the 2nd partition!) – see next section below…

Add grub2 UEFI + wimboot (using a1ive grub2)

I suggest you use the latest E2B grub2 v10W .imgPTN file – see bottom of this page for instructions.

The following instructions are for the v10A E2B grub2 menu system and is more difficult to set up…

A1ive has added a wimboot grub2 module into his special version of grub2 (unsigned).

1. Download the grub2 UEFI zip file

2. Extract the files to the \EFI\BOOT folder on the first FAT32 partition (after switching in the E2B grub2 .imgPTN file)

3. Use the windows_install.grub2 menu file (copy to \_ISO\MAINMENU\grub2 folder)

4. Place all your Windows Install ISO files in the \_ISO\MAINMENU\WINDOWS folder – must end in .ISO or .iso.

5. Add this line into one of the customX_menu.grub2 files at the very bottom to add in the windows menu

source $isofpath/grub2/windows_install.grub2

The E2B grub2 menu system will automatically add-in any customX_menu.grub2 files but the source line is required so that it adds in the windows_install.grub2 menu (or rename it as custom3_menu.grub2 instead if you wish),

The Windows ISOs will be automatically added into the main grub2 menu when you boot. If you have placed Windows Install ISOs in the \_ISO\MAINMENU\WINDOWS folder, they should be listed in the grub2 menu when you boot.

The ISO filename can contain spaces. It must end in .ISO or .iso (case sensitive – so not .ISo for instance).

Standard Microsoft dual-architecture Install ISOs are supported, x64 will be used if the CPU is a 64-bit processor.

For MBR-booting, the menu may run bootmgr and then hang on a Virtual Machine due to the drivemap command – so test on a REAL SYSTEM if you have boot problems on a VM.

\_ISO\MAINMENU\grub2\windows_install.grub2

#WINDOWS INSTALL MENU
#$isofpath e.g. (hd0,msdos2)/_ISO/LINUX - use only in if [ -e tests
#$root2 e.g. (hd0,msdos2) partition containing payload files
#$root e.g. hd0,msdos1 boot partition with grub2 on it
#$root2uuid e.g. 1234-2123-33 (uuid of $root2)
#Special variables: MBR EFI MBR32 MBR64 EFI32 EFI64 BIT32 BIT64 FAT (true if filesystem on ptn2 is FAT)
#Examples:
#if $BIT32 ; then echo 32-bit ; fi
#if ! $BIT64 ; then echo not 64-bit ; fi
#if [ $BIT64 = true and $FAT = true ] ; then echo 64-bit MBR on FAT partititon ; fi
#if [ $BIT64 = true and $EFI = true ] ; then echo 64-bit EFI (same as \$EFI64) ; fi
#CHECK_MNU_FOLDER sets these variables on return - do not use filename and filenamex inside menuentry
#$ip e.g. /_ISO/LINUX
#$ipf e.g. (hd0,msdos2)/_ISO/LINUX
#$isofile e.g. /_ISO/LINUX/xxxx.iso
#supports filenames with spaces
function ListWimBoot {
echo Adding WINDOWS ISO files from $ifp/WINDOWS
for file in $ifp/WINDOWS/*.iso $ifp/WINDOWS/*.ISO; do
if ! test -f "$file"; then continue; fi
regexp -s filename "$ip/WINDOWS/(.*)" "$file"
regexp -s filenamex "$ip/WINDOWS/(.*)(.[iI][Ss][oO])" "$file"
# echo $file
menuentry "${filenamex}" "${filename}" {
#do not use $filename inside menuentry - use $isoname instead!
set isoname="$2" ; CHECK_MNU_FOLDER
#ip, ipf and isofile are now set correctly after CHECK_MNU_FOLDER
loopback loop "${ipf}/WINDOWS/${isoname}"
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
if $MBR32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
fi
echo Using ${pp}/sources/boot.wim...
set root=$root2
set installiso="${ip}/WINDOWS/${isoname}"
save_env -f /wimboot/null.cfg installiso
# cat /wimboot/null.cfg
# read
linux16 /wimboot/wimboot
initrd16 \
# newc:bootmgr:(loop)${pp}/bootmgr \
newc:winpeshl.ini:/wimboot/winpeshl.ini \
newc:null.cfg:/wimboot/null.cfg \
newc:startup.bat:/wimboot/startup.bat \
newc:boot.wim:(loop)${pp}/sources/boot.wim \
newc:bcd:(loop)${pp}/boot/bcd \
newc:boot.sdi:(loop)${pp}/boot/boot.sdi
#swap hd0 (USB) with hd1 (internal hdd) so 'boot disk' is internal hdd
#this means may only work on real system
drivemap -s hd0 hd1
boot
}
done
}
function ListWimBootEFI {
echo Adding WINDOWS ISO files from $ifp/WINDOWS/
for file in $ifp/WINDOWS/*.iso $ifp/WINDOWS/*.ISO; do
if ! test -f "$file"; then continue; fi
regexp -s filename "$ip/WINDOWS/(.*)" "$file"
regexp -s filenamex "$ip/WINDOWS/(.*)(.[iI][Ss][oO])" "$file"
# echo $file
menuentry "${filenamex} EFI" "${filename}" {
set isoname="$2" ; CHECK_MNU_FOLDER
#ip ipf and isofile are now set correctly after CHECK_MNU_FOLDER
loopback loop "${ipf}/WINDOWS/${isoname}"
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
set bootmg=bootia32.efi
if $EFI32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
set bootmg=bootx64.efi
fi
echo Using ${pp}/sources/boot.wim...
set root=$root2
set installiso="${ip}/WINDOWS/${isoname}"
save_env -f /wimboot/null.cfg installiso
# cat /wimboot/null.cfg
# read
#NOTE: ORDER IS IMPORTANT! May get 0xC000000f error if order is wrong! boot.wim should be first.
#use wimboot --pause to see any error ( also --rawbcd --rawwim --index=1 --gui )
wimboot \
@:startup.bat:/wimboot/startup.bat \
@:winpeshl.ini:/wimboot/winpeshl.ini \
@:null.cfg:/wimboot/null.cfg \
@:boot.wim:(loop)${pp}/sources/boot.wim \
# @:bootmgfw.efi:(loop)${pp}/efi/boot/$bootmg \
@:bcd:(loop)${pp}/efi/microsoft/boot/bcd \
@:boot.sdi:(loop)${pp}/boot/boot.sdi
boot
}
done
}
if ! $EFI ; then ListWimBoot; fi
if $EFI ; then ListWimBootEFI; fi

If wimboot uses an incorrect bootmgr/bootgmfw.efi file you may get a 0xc000000f unknown error BSOD – it is often better to not specify this file and let wimboot find it.

Note that the full path of the ISO is placed in null.cfg which is later picked up by startup.bat.

Example startup.bat file:

@echo off
TITLE %~dpnx0 (WIMBOOT startup.bat)
wpeinit.exe
REM prevent wpeinit from running again
ren X:\windows\system32\wpeinit.exe wpeinit.exe.old
for %%I in (C D E F G H I J K L M N O P Q R S T U V W X Y Z) do if exist %%I:\wimboot\startup.bat set USBDRIVE=%%I:
IF "%USBDRIVE%"=="" (
echo ERROR - could not find \wimboot\startup.bat on any drive!
@echo on
for %%I in (C D E F G H I J K L M N O P Q R S T U V W X Y Z) do if exist %%I:\wimboot\startup.bat set USBDRIVE=%%I:
pause
goto :EOF
)
color 1f
cls
@echo FOUND USB DRIVE AT DRIVE %USBDRIVE%
SET BIT=32
if "%PROCESSOR_ARCHITECTURE%"=="AMD64" SET BIT=64
FOR /L %%A IN (0,1,5000) DO ECHO NOTHING > nul
:: get path of the ISO into MYISO e.g. /_ISO/WINDOWS/WIN10/Windows10ProBoth.iso
cd /d %USBDRIVE%\
set MYISO=INVALID_ISO_NAME.ISO
echo Looking for X:\Windows\System32\null.cfg contents...
for /f "tokens=1,2 delims==" %%a in ('find "installiso=" X:\Windows\System32\null.cfg') do set isopath=%%b
REM change linux forward slash to Windows backslash
set string1=%isopath:/=\%
if exist "%USBDRIVE%%string1%" set MYISO=%string1%
if not exist "%USBDRIVE%%MYISO%" if exist X:\Windows\System32\null.cfg type X:\Windows\System32\null.cfg
if not exist "%USBDRIVE%%MYISO%" echo ERROR: Can't find %USBDRIVE%%MYISO% && pause && goto :EOF
if exist "%USBDRIVE%%MYISO%" echo Loading %USBDRIVE%%MYISO%...
REM Load ISO using ImDisk
TITLE LOAD WINDOWS ISO USING IMDISK
call \wimboot\imdisk\IMDISK_install.cmd
call \wimboot\imdisk\IMDISK_instiso.cmd
REM Find mounted DVD drive
set DVDDRIVE=
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\SOURCES\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\SOURCES\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\SOURCES\x86\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\SOURCES\x86\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\SOURCES\x64\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\SOURCES\x64\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\x86\SOURCES\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\x86\SOURCES\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\x64\SOURCES\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\x64\SOURCES\install.*
)
:ENDSEARCH
IF "%DVDDRIVE%"=="" echo WARNING: VIRTUAL DRIVE DRIVE NOT FOUND!
IF "%DVDDRIVE%"=="" echo WARNING: install.* not found on any mounted volume.
IF "%DVDDRIVE%"=="" pause
echo.
IF NOT "%DVDDRIVE%"=="" echo ISO FILE MOUNTED AS %DVDDRIVE%
REM startnet.cmd normally only contains wpeinit.exe, custom ISOs may contain other commands, so try to run them
if exist X:\WINDOWS\SYSTEM32\startnet.cmd call cmd /c X:\WINDOWS\SYSTEM32\startnet.cmd
if not exist X:\WINDOWS\SYSTEM32\startup.bat exit
IF "%DVDDRIVE%"=="" cmd
MODE CON COLS=30 LINES=2
echo DO NOT CLOSE THIS WINDOW
REM X:\Sources\setup.exe /Unattend:%E2BDRIVE%\AutoUnattend.xml
REM X:\Setup.exe will allow the repair option, X:\Sources\Setup.exe will directly run Setup
X:\setup.exe

THE BCD

You must use a standard Microsoft WinPE BCD which is usually already present in a standard Microsoft Windows Install ISO.

Special WinPE ISOs tend to contain non-standard BCDs which will give a BSOD.

If in doubt, make a new BCD file using BootIce and copy it to the \wimboot folder so you can use it with wimboot.

The files will be placed by wimboot into their standard locations inside the RAMDisk that it makes so you must use standard names and paths in the BCD.

For UEFI – BCD must be set to boot from \sources\boot.wim and use \boot\boot.sdi and boot file=\Windows\system32\boot\winload.efi

For MBR – BCD must be set to boot from \sources\boot.wim and use \boot\boot.sdi
and boot file=\Windows\system32\boot\winload.exe

If you get an error check that the winload file exists in the correct path inside the boot.wim by using 7Zip to open the ISO and \sources\boot.wim file.

Note: A solid black checkbox indicates ‘not defined in BCD’.

wimboot command line

wimboot will parse the following extra commands on the same line (e.g. linux16 /wimboot pause):

rawbcd Use raw (unpatched) BCD files

rawwim Use raw (unpatched) WIM files

gui Allow graphical output from bootmgr/bootmgfw

pause Pause before booting OS

pause=quiet Pause without displaying any prompt

index=n WIM boot index

initrdfile Ignored to allow to be used with syslinux

after processing the command line, the files in the initrd ramdrive will be loaded.

For UEFI:

wimboot [--gui] [--rawbcd] [--rawwim] [--pause] [--index=n] @:boot.wim:/path/to/test.wim @:bootmgfw.efi:/path/to/test.efi @:bcd:/path/to/bcd @:boot.sdi:/path/to/boot.sdi * params: * --gui or -g Display graphical boot messages. * --rawbcd or -b Disable rewriting .exe to .efi in the BCD file. * --rawwim or -w Disable patching the wim file. * --pause or -p * --index=n or -i n Use WIM image index n.

File Injection into \Windows\System32

Files named ‘BCD’, or ending in ‘.wim’ or ‘.sdi’ are ignored and are not injected into the X:\Windows\System32 folder.

All other files added using wimboot will be added to the X:\windows\system32 folder with the new name that you specify.

Make your own grub2 boot files

The bootx64.efi and bootia32.efi files are stub files which load grubx64.efi and grubia32.efi.

To build you own grub2 files, download a build from here.

C:\TEMP\builds-master\

.gitignore
build_grub.bat <<< run this
grub-install.exe
grub-mkimage.exe
README.md
+—arch
| +—arm64
| +—ia32
| +—legacy
| | \—ntboot
| | \—NTBOOT.MOD
| \—x64
+—i386-efi
+—i386-pc
+—locale
\—x86_64-efi

Double-click on build_grub.bat to make new core.img, grubx64.efi and grubia32.efi boot files.

The builtin.lst files under the arch folder contain a list of modules which will be added into grub2.

The EFI files will be unsigned and so will not Secure Boot.

EXAMPLE WINPE E2B .GRUB2 MENUS

Download custom2_menu.grub2 for WinPE files.

Create a .grub2 menu – e.g. \_ISO\MAINMENU\grub2\custom2_menu.grub2 in the 2nd E2B partition.

#WINDOWS PE EXAMPLES
# uses iPXE wimboot (2017-05-1) 30242 bytes http://ipxe.org/wimboot#download
# \wimboot folder on Partition 2 should contain wimboot, bootmgr, bootmgr.exe
# bootmgr.exe can be found in \Windows\Boot\PXE folder - copy it to the USB:\wimboot folder
#$isofpath e.g. (hd0,msdos2)/_ISO/LINUX - use only in if [ -e tests
#$root2 e.g. (hd0,msdos2) partition containing payload files
#$root e.g. hd0,msdos1 boot partition with grub2 on it
#$root2uuid e.g. 1234-2123-33 (uuid of $root2)
#Special variables: MBR EFI MBR32 MBR64 EFI32 EFI64 BIT32 BIT64 FAT (true if filesystem on ptn2 is FAT)
#Examples:
#if $BIT32 ; then echo 32-bit ; fi
#if ! $BIT64 ; then echo not 64-bit ; fi
#if [ $BIT64 = true and $FAT = true ] ; then echo 64-bit MBR on FAT partititon ; fi
#if [ $BIT64 = true and $EFI = true ] ; then echo 64-bit EFI (same as \$EFI64) ; fi
#CHECK_MNU_FOLDER sets these variables on return
#$ip e.g. /_ISO/LINUX
#$ifp e.g. (hd0,msdos2)/_ISO/LINUX
#$isofile e.g. /_ISO/LINUX/xxxx.iso
# ---------------------
function GetWimbootFiles {
#This function looks for files needed for iPXE WIMBOOT
#The filenames are case-sensitive, so we try to look for most likely ones!
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/boot.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/Boot.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/BOOT.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/BOOT.WIM; then set pp=/x64; fi
if $BIT32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/boot.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/Boot.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/BOOT.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/BOOT.WIM; then set pp=/x86; fi
fi
unset bme
if [ -e "/wimboot/bootmgr.exe" ]; then set bme=/wimboot/bootmgr.exe ; fi
if [ -e "(loop)/bootmgr.exe" ]; then set bme=(loop)/bootmgr.exe ; fi
if [ -e "(loop)/BOOTMGR.EXE" ]; then set bme=(loop)/BOOTMGR.EXE ; fi
if [ -e "(loop)/BOOTMGR.exe" ]; then set bme=(loop)/BOOTMGR.exe ; fi
if [ -e "(loop)/Bootmgr.exe" ]; then set bme=(loop)/Bootmgr.exe ; fi
unset bm1
if [ -e "/wimboot/bootmgr" ]; then set bm1=/wimboot/bootmgr ; fi
if [ -e "(loop)/bootmgr" ]; then set bm1=(loop)/bootmgr ; fi
if [ -e "(loop)/Bootmgr" ]; then set bm1=(loop)/Bootmgr ; fi
if [ -e "(loop)/BOOTMGR" ]; then set bm1=(loop)/BOOTMGR ; fi
unset bcd
if [ -e "(loop)${pp}/BOOT/BCD" ]; then set bcd=(loop)${pp}/BOOT/BCD ; fi
if [ -e "(loop)${pp}/BOOT/bcd" ]; then set bcd=(loop)${pp}/BOOT/bcd ; fi
if [ -e "(loop)${pp}/BOOT/Bcd" ]; then set bcd=(loop)${pp}/BOOT/bcd ; fi
if [ -e "(loop)${pp}/Boot/BCD" ]; then set bcd=(loop)${pp}/Boot/BCD ; fi
if [ -e "(loop)${pp}/Boot/bcd" ]; then set bcd=(loop)${pp}/Boot/bcd ; fi
if [ -e "(loop)${pp}/Boot/Bcd" ]; then set bcd=(loop)${pp}/Boot/bcd ; fi
if [ -e "(loop)${pp}/boot/BCD" ]; then set bcd=(loop)${pp}/boot/BCD ; fi
if [ -e "(loop)${pp}/boot/bcd" ]; then set bcd=(loop)${pp}/boot/bcd ; fi
if [ -e "(loop)${pp}/boot/Bcd" ]; then set bcd=(loop)${pp}/boot/bcd ; fi
unset sdi
if [ -e "(loop)${pp}/BOOT/BOOT.SDI" ]; then set sdi=(loop)${pp}/BOOT/BOOT.SDI ; fi
if [ -e "(loop)${pp}/BOOT/boot.sdi" ]; then set sdi=(loop)${pp}/BOOT/BOOT.SDI ; fi
if [ -e "(loop)${pp}/BOOT/Boot.sdi" ]; then set sdi=(loop)${pp}/BOOT/BOOT.SDI ; fi
if [ -e "(loop)${pp}/Boot/BOOT.SDI" ]; then set sdi=(loop)${pp}/Boot/BOOT.SDI ; fi
if [ -e "(loop)${pp}/Boot/boot.sdi" ]; then set sdi=(loop)${pp}/Boot/boot.sdi ; fi
if [ -e "(loop)${pp}/Boot/Boot.sdi" ]; then set sdi=(loop)${pp}/Boot/BOOT.SDI ; fi
if [ -e "(loop)${pp}/boot/BOOT.SDI" ]; then set sdi=(loop)${pp}/boot/BOOT.SDI ; fi
if [ -e "(loop)${pp}/boot/boot.sdi" ]; then set sdi=(loop)${pp}/boot/boot.sdi ; fi
if [ -e "(loop)${pp}/boot/Boot.sdi" ]; then set sdi=(loop)${pp}/boot/BOOT.sdi ; fi
unset wim
if [ -e "(loop)${pp}/sources/boot.wim" ]; then set wim=(loop)${pp}/sources/boot.wim ; fi
if [ -e "(loop)${pp}/Sources/boot.wim" ]; then set wim=(loop)${pp}/Sources/boot.wim ; fi
if [ -e "(loop)${pp}/Sources/Boot.wim" ]; then set wim=(loop)${pp}/Sources/Boot.wim ; fi
if [ -e "(loop)${pp}/SOURCES/boot.wim" ]; then set wim=(loop)${pp}/SOURCES/boot.wim ; fi
if [ -e "(loop)${pp}/SOURCES/Boot.wim" ]; then set wim=(loop)${pp}/SOURCES/Boot.wim ; fi
if [ -e "(loop)${pp}/SOURCES/BOOT.wim" ]; then set wim=(loop)${pp}/SOURCES/BOOT.wim ; fi
if [ -e "(loop)${pp}/SOURCES/BOOT.WIM" ]; then set wim=(loop)${pp}/SOURCES/BOOT.WIM ; fi
unset bmefi64
set t="(loop)${pp}/bootmgr.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/efi/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/efi/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/efi/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
unset bmefi32
set t="(loop)${pp}/bootmgr.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/efi/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/efi/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/efi/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
#either bootmgr.exe or bootmgr is required. It can be inside the boot.wim file
if ! [ -e /wimboot/wimboot ]; then echo ERROR: /wimboot/wimboot does not exist! Please add /wimboot folder to Partition 2 ; read ; fi
echo
if [ "$bme" = "" ]; then echo WARNING: bootmgr.exe not found ; fi
if [ "$bm1" = "" ]; then echo WARNING: bootmgr not found ; fi
if [ "$bme" = "" -a "$bm1" = "" ]; then set werr=1 ; fi
if [ "$bcd" = "" ]; then echo ERROR: BCD not found in ISO file ; set werr=1 ; fi
if [ "$sdi" = "" ]; then echo ERROR: boot.sdi not found in ISO file ; set werr=1 ; fi
if [ "$wim" = "" ]; then echo ERROR: boot.wim not found in ISO file ; set werr=1 ; fi
echo Using:
echo bm1=$bm1
echo bme=$bme
echo bcd=$bcd
echo sdi=$sdi
echo wim=$wim
echo bmefi64=$bmefi64
echo bmefi32=$bmefi32
echo --------
if [ "$werr" = "1" ]; then echo Possible error: Press a key to continue anyway... ; read ; fi
}
# ---------- Win10PESE_x64.ISO ------
if $MBR64; then
if [ -e "$isofpath/Win10PESE_x64.ISO" ]; then
menuentry "Win10PESE_x64.ISO (BIOS WIMBOOT)" --unrestricted --class windows {
set isoname=Win10PESE_x64.ISO ; CHECK_MNU_FOLDER
set root=$root2
loopback loop $isofile
GetWimbootFiles
linux16 /wimboot/wimboot pause
initrd16 \
# newc:bootmgr:$bm1 \
newc:boot.sdi:$sdi \
newc:boot.wim:$wim \
newc:bcd:$bcd
boot
}
fi
fi
#This menu will be shown for 32-bit and 64-bit CPUs
if $EFI; then
if [ -e "$isofpath/Win10PESE_x64.ISO" ]; then
menuentry "Win10PESE_x64.ISO (UEFI WIMBOOT)" --unrestricted --class windows {
set isoname=Win10PESE_x64.ISO ; CHECK_MNU_FOLDER
set root=$root2
loopback loop "$isofile"
# GetWimbootFiles
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
if $EFI32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
fi
echo Using ${pp}/sources/boot.wim...
wimboot --pause \
@:boot.sdi:(loop)${pp}/Boot/boot.sdi \
# @:bootmgfw.efi:(loop)${pp}/efi/boot/bootx64.efi \
@:boot.wim:(loop)${pp}/sources/boot.wim \
@:bcd:(loop)${pp}/efi/microsoft/boot/bcd
boot
}
fi
fi
# ------------- Win10XPE_X64.iso ----------------------
#WORKS (wimboot doesn't work)
if $MBR64; then
if [ -e "$isofpath/Win10XPE_x64.ISO" ]; then
menuentry "Win10XPE_x64 (BIOS MEMDISK)" --unrestricted --class windows {
set isoname=Win10XPE_x64.ISO ; CHECK_MNU_FOLDER
linux16 ($root)/boot/grub/memdisk iso raw
set root=$root2
initrd16 $isofile
# drivemap -s (hd0) (hd1)
boot
}
fi
fi
# ----------- ampe64.iso ------------------
if $MBR64; then
if [ -e "$isofpath/ampe64.iso" ]; then
menuentry "ampe64.iso WORKS (BIOS WIMBOOT)" --unrestricted --class windows {
set isoname=ampe64.iso ; CHECK_MNU_FOLDER
set root=$root2
loopback loop $isofile
GetWimbootFiles
linux16 /wimboot/wimboot pause
initrd16 \
# newc:bootmgr:$bm1 \
newc:boot.sdi:$sdi \
newc:boot.wim:$wim \
newc:bcd:$bcd
boot
}
fi
fi
#This menu will be shown for 32-bit and 64-bit CPUs
if $EFI; then
if [ -e "$isofpath/ampe64.iso" ]; then
menuentry "ampe64.iso (UEFI WIMBOOT)" --unrestricted --class windows {
set isoname=ampe64.iso ; CHECK_MNU_FOLDER
set root=$root2
loopback loop "$isofile"
GetWimbootFiles
if [ "$bmefi64" = "" ]; then echo ERROR: bootmgr EFI file not found ; fi
if [ "$sdi" = "" ]; then echo ERROR: boot.sdi file not found ; fi
if [ "$wim" = "" ]; then echo ERROR: boot.wim file not found ; fi
if [ "$bcd" = "" ]; then echo ERROR: BCD file not found ; fi
echo Using $wim...
wimboot --pause \
# @:bootmgfw.efi:$bmefi64 \
@:boot.sdi:$sdi \
@:boot.wim:$wim \
@:bcd:$bcd
echo boot...
read
boot
}
fi
fi
# Strelec WinPE TEST
# This menu will be shown for 32-bit and 64-bit CPUs
# Make strelec_BCD using BootIce - BCD must be set to boot from \sources\boot.wim and use \boot\boot.sdi and boot file=\Windows\system32\boot\winload.efi
# Need to obtain missing bootx64.efi from a standard Win10 ISO and add to \wimboot folder
# Once at Desktop, right-click on Strelec ISO in Explorer and MOUNT as Y: - then run MistAll from start menu
if $EFI64; then
if [ -e "$isofpath/WinPE10_8_Sergei_Strelec_x86_x64_2019.02.04_English.iso" ]; then
menuentry "TEST WinPE10_8_Sergei_Strelec_x86_x64_2019.02.04_English.iso (UEFI WINPE WIMBOOT)" --unrestricted --class windows {
set isoname=WinPE10_8_Sergei_Strelec_x86_x64_2019.02.04_English.iso ; CHECK_MNU_FOLDER
set root=$root2
loopback loop "$isofile"
wimboot --pause \
@:boot.sdi:(loop)/SSTR/boot.sdi \
@:bootmgfw.efi:/wimboot/bootx64.efi \
@:boot.wim:(loop)/SSTR/strelec10x64Eng.wim \
@:bcd:/wimboot/strelec64_BCD
boot
}
fi
fi

————————————————-

GRUB2 UEFI + WIMBOOT (IPXE)

You can use the iPXE environment instead of a grub2 environment

\boot.ipxe – config file run by iPXE
\ipxe64.efi – contains iPXE boot code (x64)
\ipxe32.efi – contains iPXE boot code (32-bit)
\wimboot – the wimboot code
\win\boot64.wim – \win folder contains your bootable wim file (any name)
\win\BCD2 – and name for BCD
\win\boot.sdi – generic boot.sdi

1. Go to the ROMMatic site and create a 64-bit and 32-bit .EFI file using – Advanced – EFI PXE bootstrap xx-bit (.efi)

and paste in the following script in the Embedded script box at the bottom:

#!ipxe
chain file:/boot.ipxe

then click on Proceed and wait (if you get a timeout – try again)

2. Now you should have a ipxe64.efi file and a ipxe32.efi file which you can load from grub2:

menuentry “iPXE wimboot” {
chainloader /ipxe64.efi
boot
}

3. Create the iPXE config file \boot.ipxe

#!ipxe
#use --name for UEFI when file has different name from default
#add second virtual name for MBR booting
#ensure BCD has standard \sources\boot.wim and \sources\boot.sdi paths
ifopen
kernel file:/wimboot
initrd --name bcd file:/win/bcd2 bcd
initrd --name boot.sdi file:/win/boot.sdi boot.sdi
initrd --name boot.wim file:/win/boot64.wim boot.wim
echo
echo Platform=${platform} BuildArch=${buildarch}
echo
imgstat
prompt --timeout 5000 Press a key... ||
boot

The same boot.sdi file can be used by all Windows 7/8/10 etc. AFAIK.

4. Use BootIce to ensure that the BCD2 file has standard file paths for the boot.wim and boot.sdi

If these paths are not ‘standard’, then you will get a BSOD 0xc000000f error!

See iPXE wimboot description for more details.

The big problem with this method is that the boot.ipxe configuration file cannot be passed the path of the boot.wim file by grub. Once grub chainloads the .efi boot file, all connections with grub are lost.

This means that you can only boot to one boot.wim OR you must prompt the user to enter path of the boot.wim file by adding scripting into the boot.ipxe file,

e.g.

echo Please enter the full path of the boot.wim file...
read wimboot
and then use
initrd --name boot.wim file:$wimboot boot.wim

in the boot.iPXE menuentry…

#!ipxe
#use --name for UEFI when file has different name from default
#add second virtual name for MBR booting
#ensure BCD has standard \sources\boot.wim and \sources\boot.sdi paths
ifopen
:getwim
imgfree
echo
echo
echo Please enter the full path of the boot.wim file...
echo Press ENTER for /win/boot64.wim
clear wimboot
echo
read wimboot
isset ${wimboot} || set wimboot /win/boot64.wim
echo wimboot=${wimboot}
#check file exists
imgfetch file:${wimboot} || goto getwim
read ask
kernel file:/wimboot
initrd --name bcd file:/win/bcd2 bcd
initrd --name boot.sdi file:/win/boot.sdi boot.sdi
initrd --name boot.wim file:${wimboot} boot.wim
echo
echo Platform=${platform} BuildArch=${buildarch}
echo
imgstat
prompt --timeout 5000 Press a key... || boot

Download files

Click here (OneDrive folder) if you cannot find any file mentioned in the articles on this site or Contact Me.

Источник

Пройдемся еще немножко по теме установки ОС Windows. На этот раз, речь пойдет о использовании стандартного установщика для организации мультиустановки. И напоследок рассмотрим ручную установку из *.wim или *.esd архива.

Содержание

Как Происходит Установка ОС Windows
Стандартный Установщик Windows
Мультиустановка с Помощью Установщика Windows
Уменьшение Размера WIM-архива
Ручная Установка
- Создание Разделов
  - Diskpart
    - MBR
    - GPT
- Извлечение Файлов
  - Dism
- Установка Загрузчика
  - BIOS
  - UEFI
- Тестовый Запуск
Итог

Как Происходит Установка ОС Windows

Разберем процесс установки детально. Сначала происходит подготовка установочного диска. Под диском я подразумеваю любой накопитель, с которого возможна установка Windows, будь то флешка, CD-диск и т.д. Выглядит данный процесс следующим образом.

Скачивается ISO-образ, с необходимой редакцией ОС. С помощью данного образа подготавливается установочная флешка, или установочный CD-диск. Либо скачивается официальная программа от Microsoft, для создания установочного диска. И уже с ее помощью происходит подготовка установочного диска.

Следующий этап, загрузка с подготовленного установочного диска. На этом этапе происходит запуск среды предустановки (WinPE), и выполнение установочной программы Windows.

Установочная программа, в свою очередь, выполняет следующие действия. Выбор диска, на который будет происходить установка. Создание разделов. Копирование файлов ОС Windows на созданный или указанный раздел. Установка загрузчика.

Работа с установочным диском на этом завершается. Поэтому, формально сам процесс установки на этом завершается. Все последующее, это просто инициализация скопированной копии ОС Windows.

Стандартный Установщик Windows

Представлен исполняемым файлом \sources\setup.exe установочного диска Windows.

И ссылающийся на него файл \setup.exe в корне диска.

Стандартный установщик, так же присутствует в образе среды предустановки boot.wim. Пути расположения идентичны.

\sources\setup.exe

\setup.exe

Как говорилось ранее, задача у данной программы выполнить установку ОС Windows. Теперь немного фактов о стандартном установщике Windows.

Windows-установщик является обычной программой. То есть при желании, его можно сохранить как отдельную программу вне установочного диска, например на флешке, и запускать по мере необходимости. Все файлы стандартного установщика расположены в папке \sources.

Файл \setup.exe в корне установочного диска, или среды предустановки, на самом деле не является самостоятельным установщиком. Все что он делает, это запускает файл \sources\setup.exe.

Для Windows-установщика не важна разрядность устанавливаемой ОС. К примеру, 32-битный установщик, без проблем выполнит установку 64-битной версии ОС Windows из указанного *.wim/*.esd архива.

Установочный *.wim/*.esd архив, не обязательно должен находиться в папке \sources для выполнения установки. Установщику можно указывать путь до архива, который он в последствии будет извлекать.

Установщик Windows расположенный в boot.wim образе содержит в себе функционал восстановления системы. Исполняемый файл, запускающий утилиту восстановления системы, расположен по пути \sources\recovery\RecEnv.exe.

Мультиустановка с Помощью Установщика Windows

Теперь, когда нам известно о возможностях стандартного установщика, попробуем организовать с его помощью установку различных версий ОС Windows. Для теста, я взял четыре установочных *.wim/*.esd (располагаются в папке \sources установочного ISO-образа, и обычно имеют имя install.wim или install.esd) архива операционных систем

Windows 7 64-bit

Windows 8.1 64-bit

Windows 10 64-bit

Windows 10 32-bit

Установочные файлы были размещены в директории WinSetup\WinImage. Пути не обязательно должны быть такими же, меняйте их по своему усмотрению, просто учитывайте ваши изменения с дальнейшим описанием.

Скопируем стандартный установщик Windows с boot.wim образа, 32-x битной версии установочного диска, в папку WinSetup. Весь установщик, с необходимыми ему файлами, расположен в папке \sources, в корне самого объемного по размеру индекса, файла boot.wim.

Почему копировать папку sources лучше из файла boot.wim, а не из корня установочного ISO-образа? Ответ банален — из-за размера. Папка sources из файла образа boot.wim имеет вдвое меньший объем, чем аналогичная в корне установочного диска. Учитывая, что обе версии одинаково справляются со своей задачей, выбор пал на меньшую по размерам.

Перейдем в скопированную папку sources, и запустим установщик setup.exe.

В результате, получаем ошибку о том, что системе Windows не удалось найти файл boot.wim, очень необходимый, по мнению установщика.

«Windows не может найти требуемый файл установки [boot.wim]. Убедитесь, что источник установки действителен и запустите установку заново. Код ошибки: 0x80070002»

Дело в том, что установщик понимает, что он выполняется в полноценной версии Windows, а не в среде предустановки. И ожидает увидеть файлы boot.wim и install.wim (esd), в папке sources. Если он их не находит, то считает, что установка не может быть выполнена, так как установочный диск является не полноценным. К сведению, аналогичные действия в загруженной WinPE, не вызвали бы таких ошибок.

Придется дать установщику то, что он просит. Сама мысль о том, что папка sources будет увеличена в размере на на 350 МБ, приводит в ужас. Ведь немного ранее мы уже экономили на папке sources.

Попробуем обмануть установщик. Самое первое, что может прийти в голову, это создать пустой файл с именем boot.wim, и подложить в папку sources.

Но, установщик не так прост как кажется. Получаем ошибку — «Системе Windows не удается создать требуемую папку установки. Код ошибки: 0x8007000B«.

То есть, он не просто проверяет наличие файла boot.wim, но проверяет его содержимое на валидность. Тогда остается последний вариант. Скопировать корректный файл boot.wim с установочного диска, и опустошить его, то есть максимально уменьшить его размер.

Если нет желания возиться с командной строкой, то можете скачать уже максимально опустошенный мною файл boot.wim (2.44 KB). Информацию о том, как уменьшить размер файла boot.wim, и в принципе любого другого *.wim архива, можно прочесть в этом разделе.

После того, как у нас на руках есть уменьшенный в размере файл boot.wim, копируем его в папку sources.

Запускаем setup.exe и получаем сообщение — «Windows не удалось собрать данные для [OSImage], так как указанный файл образа [install.wim] не существует.».

Из текста сообщения понятно, что теперь все хорошо, не хватает лишь файла install.wim для осуществления установки.

На этом этапе никаких хитростей не понадобится. Ранее уже говорилось, что установщику можно указать с какого файла производить установку. Делается это с помощью запуска файла sources\setup.exe с параметром /installfrom:«путь_до_wim_или_esd_архива». Остальные параметры установщика можно посмотреть по адресу https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/windows-setup-command-line-options.

Так как у нас четыре установочных архива, создадим рядом с папкой sources четыре *.cmd скрипта, для запуска установки каждого из них. Перечислим их с описанием их содержимого, и примером запуска:

Win7x64.cmd — Запуск установки Windows 7 64-bit.

@echo off
@pushd %~dp0
cd sources
setup.exe /installfrom:..\WinImage\Win7Ult64.esd

Win8x64.cmd — Запуск установки Windows 8 64-bit.

@echo off
@pushd %~dp0
cd sources
setup.exe /installfrom:..\WinImage\Win81Pro64.wim

Win10x64.cmd — Запуск установки Windows 10 64-bit.

@echo off
@pushd %~dp0
cd sources
setup.exe /installfrom:..\WinImage\Win10Pro64.esd

Win10x86.cmd — Запуск установки Windows 10 32-bit.

@echo off
@pushd %~dp0
cd sources
setup.exe /installfrom:..\WinImage\Win10Pro86.esd

Все работает! Последнее, что можно сделать, это создать либо единый *.cmd скрипт, либо приложение с графическим интерфейсом, с возможностью выбора устанавливаемой версии Windows.

Пример графического меню созданного с помощью AutoIt.

Исходный код следующий:

#NoTrayIcon
#RequireAdmin

#include <buttonconstants.au3>
#include <guiconstantsex.au3>
#include <staticconstants.au3>
#include <windowsconstants.au3>

$MainWin = GUICreate("Install Menu", 297, 322,- 1, -1, BitOR($WS_CAPTION, $WS_POPUP, $WS_SYSMENU))

$b1 = GUICtrlCreateButton("Windows 7 64-bit", 8, 8, 281, 65)
$b2 = GUICtrlCreateButton("Windows 8.1 64-bit", 8, 80, 281, 65)
$b3 = GUICtrlCreateButton("Windows 10 64-bit", 8, 152, 281, 65)
$b4 = GUICtrlCreateButton("Windows 10 32-bit", 8, 224, 281, 65)

$link = GUICtrlCreateLabel("http://www.BootDev.ru/", 88, 296, 121, 17)
GUICtrlSetFont(-1, 8, 400, 4, "MS Sans Serif")

GUICtrlSetBkColor(-1, 0xFFFFFF)

GUISetIcon("icon.ico")

GUISetState(@SW_SHOW)

FileChangeDir(@ScriptDir)

Global $setup = "sources\setup.exe /installfrom:"

While 1
 $nMsg = GUIGetMsg()
 Switch $nMsg
  Case $GUI_EVENT_CLOSE
   Exit

  Case $b1 ; Windows 7 64-bit
   Run($setup & "WinImage\Win7Ult64.esd")

  Case $b2 ; Windows 8.1 64-bit
   Run($setup & "WinImage\Win81Pro64.wim")

  Case $b3 ; Windows 10 64-bit
   Run($setup & "WinImage\Win10Pro64.esd")

  Case $b4 ; Windows 10 32-bit
   Run($setup & "WinImage\Win10Pro86.esd")

  Case $link
   ShellExecute("http://www.bootdev.ru")
 EndSwitch
WEnd

Скрипт скомпилирован в исполняемый файл WinSetup.exe. Располагаться он должен рядом с папкой sources.

Созданное меню более удобно для использования, и заменяет по функционалу все написанные ранее *.cmd скрипты. Особенно, данное удобство будет заметно при интеграцию его в среду предустановки, немного доработав поиск установочных архивов на поиск их на внешнем носителе. В общем, какой вариант запуска использовать, это дело конкретной потребности.

Уменьшение Размера WIM-архива

Единственный способ уменьшить размер wim-архива, это избавиться от ненужного содержимого в нем. Но здесь есть один подвох. При удалении данных, они физически не удаляются, а как бы перемещаются в раздел удаленных. Размер wim-файла при этом даже немного увеличивается. Разберем все более подробно на примере файла boot.wim. Текущая цель создать пустой wim-файл.

Создадим папку (это скорее для удобства), в моем случае это папка E:\WIM, и поместим в нее оригинальный файл boot.wim.

Размер его на данный момент составляет 336 MB. Запустим командную, строку от имени администратора, и перейдем в ней в каталог с нашим файлом boot.wim.

Посмотрим информацию о файле boot.wim, выполнив команду dism /get-wiminfo /wimfile:boot.wim.

Видим, что архив содержит две версии Windows — первая Microsoft Windows PE размером ~1395 MB (среда предустановки), вторая Microsoft Windows Setup размером ~1580 MB (среда предуставновки + установщик).

Через 7-Zip, boot.wim на данный момент выглядит так:

Удалим второй индекс, вместе со всем его содержимым. Выполним для этого команду dism /delete-image /imagefile:boot.wim /index:2.

Снова выведем информацию о boot.wim, и проверим содержимое через 7-Zip.

Командная строка показывает то что индекса 2 больше нет. Размер boot.wim при этом вырос на 1 MB. И только 7-Zip показывает, что удаленные данные, размером в ~100 MB, находятся в секции [DELETED].

Индекс 1 удалить невозможно (наша цель, напомню, уменьшить максимально файл boot.wim), потому что он обязательно должен присутствовать в wim-архиве. Поэтому остается только смонтировать 1-й индекс, и удалить файлы вручную с сохранением проделанных изменений.

Для монтирования нам потребуется какая-нибудь папка. Содержимое смонтированного архива, будет отображено в ней. Создадим папку с именем mnt рядом с файлом boot.wim.

Смонтируем первый индекс в папку mnt, выполнив команду dism /mount-image /imagefile:boot.wim /index:1 /mountdir:mnt.

В папке mnt появится содержимое архива boot.wim.

Открываем Far Manager от имени администратор, переходим в папку mnt и удаляем ее содержимое. Именно он позволяет полностью, без проблем, удалить все файлы.

Закрываем Far Manager. Закрываем все окна, в которых открыта папка mnt. Возвращаемся в командную строку, выполняем размонтирование файла boot.wim с сохранением проделанных изменений. Вводим для этого команду dism /unmount-image /mountdir:mnt /commit.

Снова проверим информацию о boot.wim.

Размер первого индекса 0. Сам архив увеличился еще на 1 MB.

Последнее что нужно сделать, это экспортировать первый индекс в новый архив. Данное действие позволит избавится от так называемого раздела [DELETED], который хранит в себе удаленные данные.

Выполняем команду dism /export-image /sourceimagefile:boot.wim /sourceindex:1 /destinationimagefile:new_boot.wim.

Появится новый архив new_boot.wim размером 2.44 KB. Операция уменьшения boot.wim архива на этом, успешно выполнена.

Ручная Установка

Все рассказанное до этого момента, предполагало наличие установщика. То есть программы, которая за вас выполнит разметку диска, копирование файлов и установку загрузчика. В этой главе, и ее подглавах, мы рассмотрим как выполнить установку с *.wim или *.esd архива вручную.

Сразу напрашивается вопрос — А зачем нужна установка вручную, ведь много программ которые могут автоматизировать данный процесс, WinNTSetup или тот же стандартный установщик? Данный вариант можно рассматривать как «аварийный». Например, у вас нет под рукой необходимого ПО, или используемый вами WinPE не содержит его. Или вы находитесь в ситуации когда нет времени, а установку уже надо делать. Я это все к тому, что знать о ручной установке все же будет полезно.

Все дальнейшие действия будут проводиться на виртуальном жестком диске VHD. Так же, будет производиться загрузка данного VHD в виртуальной машине VirtualBox, для проверки корректности работы, после проделанных действий.

Разметка Диска

Возможные таблицы разделов на данный для дисков, это MBR или GPT. С MBR-диска можно загружаться как в BIOS, так и в UEFI системах (legacy mode). С GPT-диска, только в UEFI. Рассмотрим создание обоих типов таблиц разделов.

Diskpart

Рассмотрим создание таблицы разделов с помощью консольной утилиты diskpart. Предназначена она для выполнения различных манипуляций с дисками и разделами. Присутствует в Windows с 2000-й версии.

Все дальнейшие действия в данной программе, будут проводиться для диска под номером 2 (виртуальный жесткий диск, о котором говорилось выше).

Узнать номер целевого диска можно командой list disk, а командой select disk X, где X номер диска, можно выбрать указанный диск для выполнения дальнейших манипуляций над ним.

MBR

Для диска в формате MBR потребуется 2 раздела. Первый системный, размером в 100 MB, на котором будут располагаться файлы загрузчика. И второй основной, для операционной системы. Хотя можно обойтись и одним разделом для всего.

Запускаем diskpart (Win+R, вводим diskpart и нажимаем ENTER) и выполняем следующую последовательность команд:

rem Выбираем целевой диск
select disk 2

rem Очищаем выбранный диск от таблицы разделов
clean

rem Создаем первый раздел размером в 100 MB
create partition primary size=100

rem Помечаем раздел как активный
active

rem Форматируем раздел в файловую систему NTFS и выставляем метку System
format quick fs=ntfs label="System"

rem Присваиваем разделу букву S
assign letter="S"

rem Создаем второй раздел занимающий все оставшееся пространство диска
create partition primary

rem Форматируем раздел в файловую систему NTFS и выставляем метку Windows
format quick fs=ntfs label="Windows"

rem Присваиваем разделу букву W
assign letter="W"

GPT

Для диска в GPT формате потребуется 3 раздела. Первый EFI раздел, с файловой системой FAT32, размером 100 MB. В нем будет располагаться загрузчик. Второй MSR раздел, размером в 128 MB. Служебный раздел для ОС Windows, не предназначен для хранения данных. И последний основной раздел, для операционной системы.

Запускаем diskpart (Win+R, вводим diskpart и нажимаем ENTER) и выполняем следующую последовательность команд:

rem Выбираем целевой диск
select disk 2

rem Очищаем выбранный диск от таблицы разделов
clean

rem Конвертируем таблицу разделов в GPT формат
convert gpt

rem Создаем EFI раздел размером в 100 MB
create partition efi size=100

rem Форматируем раздел в файловую систему FAT32 и выставляем метку System
format quick fs=fat32 label="System"

rem Присваиваем разделу букву S
assign letter="S"

rem Создаем служебный раздел MSR размером в 128 MB
create partition msr size=128

rem Создаем третий раздел занимающий все оставшееся пространство диска
create partition primary

rem Форматируем раздел в файловую систему NTFS и выставляем метку Windows
format quick fs=ntfs label="Windows"

rem Присваиваем разделу букву W
assign letter="W"

Пару слов по поводу MSR раздела, команда create partition msr size=128. При выполнении команды convert gpt, MSR раздел создается автоматически.

Как можно заметить, до выполнения команды convert gpt, разделы на жестком диске отсутствовали. А после выполнения, появился раздел размером в 128 MB.

Вывод детальной информации о созданном разделе, только подтверждает, что это MSR раздел.
Возможно, я не уверен, старые версии diskpart не обладали таким поведением. Хотя в Windows 7 поведение полностью аналогичное, но ОС при этом была обновленная. Поэтому команду в списке я все же оставил.

Извлечение Файлов

Данный шаг, является следующим после разметки диска. Выполнять извлечение установочного архива будем выполнять с помощью консольной утилиты DISM.

Можно попробовать использовать для этих целей 7-Zip. Собственно я планировал добавить далее описание данного процесса. Но при тестировании выявил, что операционная система Windows 10, распакованная таким образом, выдавала ошибку при первом старте. Поэтому от вариантов распаковки установочного образа с помощью архиваторов и файл менеджеров, было решено отказаться.

Сам процесс извлечения состоит из двух этапов. Определение извлекаемой версии архива. Как известно *.wim/*.esd архивы могут содержать несколько версий содержимого, разбитого по индексам. И последний этап, извлечение выбранного индекса в указанный раздел.

DISM

Для работы dism нужны права администратора, поэтому все дальнейшие действия необходимо выполнять в командной строке запущенной с соответствующими правами.

В командной строке, переходим в директорию, в которой расположен установочный архив. В моем случае это директория WinSetup\WinImage.

Выполнив команду dir, выводим список файлов, чтобы посмотреть имя архива с которым будем работать далее.

Выводим информацию о выбранном архиве введя команду dism /get-wiminfo /wimfile:Win10Pro64.esd, чтобы определить индекс извлекаемого содержимого.

Выполняем извлечение выбранного индекса командой dism /apply-image /imagefile:Win10Pro64.esd /index:4 /applydir:W:\. W:\ в данном случае, это раздел, который создавался в предыдущей главе, и предназначался для размещения ОС Windows.

Извлечение файлов на этом завершено. Содержимое диска W:\ представлено на скриншоте ниже.

Установка Загрузчика

Перед установкой загрузчика, в системе должны быть подключены, оба созданных ранее раздела S:\ и W:\. Подключить разделы можно с помощью программы diskpart, либо в оснастке Управление дисками.

Для diskpart, делается с помощью следующих команд:

rem Узнаем номер необходимого диска
list disk

rem Выбираем необходимый диск
select disk 2

rem Выводим список разделов выбранного диска
list partition

rem Выбираем первый раздел диска
select partition 1

rem Монтируем первый раздел под буквой S
assign letter=S

rem Выыбираем второй раздел диска
select partition 2

rem Монтируем второй раздел под буквой W
assign letter=W

rem Выходим из diskpart
exit

В оснастке Управление дисками, все делается через контекстное меню нужного раздела.

Процесс довольно простой и понятный, поэтому не нуждается в подробном описании.

Теперь, когда подключены оба раздела, можно приступать к установке загрузчика. Возможны два варианта, в зависимости от используемой таблицы разделов — установка BIOS версии (MBR), или установка EFI версии (GPT).

BIOS

Для дисков размеченных в стиле MBR, потребуется установить MBR-запись, и выполнить копирование файлов загрузчика на раздел S:\. Делается это довольно просто, с помощью консольных программ bootsect и bcdboot. Сами команды будут иметь следующий вид, выполнять их нужно в командной строке, запущенной от имени администратора:

:: Устанавливаем загрузочный код Windows Boot Manager в MBR область диска
bootsect /nt60 S: /mbr

:: Переходим в раздел W:\ с распакованными файлами Windows
W:

:: Переходим в директорию System32 распакованной системы
cd W:\Windows\System32

:: Устанавливаем BIOS версию загрузчка Windows Boot Manager в раздел S:\
bcdboot W:\Windows /s S: /f BIOS

Загрузчик установлен. На диске S:\ появятся файлы загрузчика.

UEFI

Для дисков с таблице разделов GPT, для установки загрузчика достаточно выполнить только копирование файлов загрузчика на раздел S:\. Выполняется эта операция с помощью консольной утилиты bcdboot. Выполнять ее запуск нужно в командной строке запущенной от имени администратора. Полный пример команд будет выглядеть так:

:: Переходим в раздел W:\ с распакованными файлами Windows
W:

:: Переходим в директорию System32 распакованной системы
cd W:\Windows\System32

:: Устанавливаем BIOS версию загрузчка Windows Boot Manager в раздел S:
bcdboot W:\Windows /s S: /f UEFI

Загрузчик установлен. На диске S:\ появится папка с UEFI загрузчиком.

Тестовый Запуск

Проверим ручную установку, подключив подготовленный VHD-образ в виртуальную машину VirtualBox.

Результат загрузки.

Операционная система успешно установилась и загрузилась.

Итог

Процесс установки Windows, достаточно многогранен. Реализовать данную процедуру можно различными способами. Сегодня мы рассмотрели, несколько нестандартное, применение стандартных средств установки, а так же целиком ручную установку. Оба метода по своему интересны, и в зависимости от ситуации, обязательно найдут применение в реальных задачах.

Источник

Сегодня стационарные компьютеры начинают медленно уходить на задний план. Их место прочно занимают ноутбуки, а затем идут и планшетные компьютеры. Сочетание мобильности, высокой производительности и высокой скорости получения информации – все это является несомненным плюсом планшетов. Однако, и своя ложка дегтя у планшетов есть: это малый размер жестких дисков. Если диск 16, 32 и даже 64 ГБ, вовсе не хочется разбрасываться ценным пространством на установочные файлы. С выходом Windows 8.1 Update появилось решение этой проблемы – WIMBoot – новый способ установки ОС, обеспечивающий большее свободное пространство для пользователя.

Обзор технологии

Итак, что же такое WIMBoot (Windows Image Boot)? Это технология, предназначенная для устройств с малым объемом жестких дисков, с помощью которой обеспечивается большее пространство под пользовательские данные и приложения после установки операционной системы. Сразу перечислю ограничения при использовании WIMBoot:

WIMBoot может быть использован только на компьютерах с UEFI, запущенных в режиме UEFI. Режим совместимости с BIOS не поддерживается.
WIMBoot предназначен для устройств с малым объемом жестких дисков SSD или eMMC.
WIMBoot доступен только Windows 8.1 Update и не поддерживается для серверных ОС. WIMBoot доступен для всех архитектур процессоров (amd64, x86, и ARM).

Чем отличается WIMBoot от обычной установки Windows? При обычной установке Windows каждый установочный файл записывается на диск дважды: в сжатой форме на случай восстановления и в разархивированном виде для использования. Таким образом, размер пространства доступного пользователю, уменьшается.

Стандартная схема разделов (без WIMBoot)

При установке Windows с использование WIMBoot, файлы записываются на жесткий диск только однажды и в сжатом формате. Далее к разделу Windows применяются файлы-указатели (Pointer files), которые ссылаются на сжатые файлы в разделе образов.

Схема разделов при использовании WIMBoot

В чем преимущества WIMBoot? C технической точки зрения, пользователь не заметит разницы в работе системы. Все файлы пользователя будут видны и доступны без каких-либо преобразований. При этом, место на устройства будет значительно больше. Для примера, при обычной установке Windows 8.1 на 16 ГБ жесткого диска, пользователю будут доступны примерно 7 ГБ. В случае установки системы из образа WIMBoot, свободное пространство увеличится, и пользователю будет доступно уже порядка 12 ГБ.
Теперь попробуем самостоятельно создать образ WIMBoot и развернуть его. Для этого понадобится образ Windows 8.1 Update, Windows Assessment and Deployment Kit для Windows 8.1 и загрузочный диск Windows PE 5.1. Для проверки версии Windows PE в среде wpeinit необходимо запустить редактор реестра (regedit) и проверить следующий регистрационный ключ:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\WinPE

Если версия WinPE будет 5.1, Windows PE можно не обновлять.
Начинаем с установки Windows ADK Для начала установите следующие компоненты из Windows ADK для Windows 8.1: это Deployment Image and Management и PE Environment (скачать). Создавать образ WIMBoot можно как на компьютере под управлением Windows 8 и Windows 8.1, так и на Windows Server 2012.
После того, как Windows ADK установлен, необходимо запустить программу Deployment Image and Management с правами администратора. Именно с ней нам и предстоит работать. Так же, для удобства, будем использовать следующую систему каталогов:

C:\Images – каталог, в котором хранятся образы
C:\mount – каталог, в который будем монтировать образы
C:\MSU – каталог, в котором сохраним архивы с обновлениями

В каталог C:\Images скопируем файл install.wim из установочного образа Windows 8.1.
Прежде чем детально описывать процесс создания образа WIMBoot, я перечислю основные шаги, которые нужно проделать.

Создание образа WIMBoot
1. Создание временной копии образа для установки Windows
2. Отделение образа для восстановления от главного образа Windows
3. Оптимизация образа для WIMBoot
Создание загрузочного диска WinPE 5.1
Добавление WIMBoot на загрузочный диск
Развертывание WIMBoot
1. Форматирование жесткого диска по схеме разделов WIMBoot
2. Добавление Windows и файлов восстановления
3. Защита папки WIMBoot

Далее подробно рассмотрим каждый из этих шагов. В конце статьи в качестве дополнительных материалов приведены подробные описания процессов обновления образа Windows, образа WinPE, а также инструкция по проверке финального образа WIMBoot.

1. Создание образа WIMBoot

С помощью обновленных файлов Windows, создадим образ WIMBoot.

1.1 Создание временной копии образа для установки Windows

Скопируем обновленный файл install.wim в новый временный файл. Именно этот файл будет использоваться для установки WIMBoot.

Copy C:\Images\install.wim C:\Images\install_temp.wim

Создадим каталог и смонтируем туда образ.

md C:\mount\Windows
Dism /Mount-Image /ImageFile:"C:\Images\install_temp.wim" /Index:1 /MountDir:C:\mount\Windows

1.2 Отделение образа для восстановления от главного образа Windows

Переместим образ Windows RE (winre.wim) из смонтированного каталога. Добавлю пару слов о Windows RE. Windows Recovery Environment это расширяемая платформа для восстановления основанная на Windows PE. В процессе создания образа WIMBoot образ Windows RE рекомендуется отделить от основного образ Windows. Иначе образ потребует еще примерно 200 МБ свободного пространства на жестком диске, которое не будет использовано. Также хочу отметить, что файл winre.wim обычно скрыт, поэтому его необходимо сделать видимым.

attrib –s -h C:\mount\Windows\Windows\System32\Recovery\winre.wim
move C:\mount\Windows\Windows\System32\Recovery\winre.wim C:\images\winre.wim

1.3 Оптимизация образа для WIMBoot

Оптимизируем образ WIMBoot.

Dism /Optimize-Image /Image:C:\mount\Windows /WIMBoot

Размонтируем образ

Dism /Unmount-Image /MountDir:C:\mount\Windows /Commit

2. Создание загрузочного диска WinPE 5.1

Создаем рабочую копию файлов Windows PE. Доступны на выбор две версии x86 или amd64.

copype amd64 C:\WinPE_amd64

Если это необходимо, обновляем WinPE 5.0 до WinPE 5.1. Подробное описание процесса обновления смотрите в приложении.
Следующим этапом создадим загрузочный диск WinPE 5.1. Тут возможно несколько вариантов. В самом простом варианте можно записать файлы на обычную флешку. Размер флеш-карты лучше выбрать 16 ГБ и больше, т.к. понадобится в дальнейшем делать некоторые манипуляции с образом, для которых понадобится дополнительное место. Создать загрузочную флешку можно с помощью команды:

MakeWinPEMedia /UFD C:\WinPE_amd64 F:

В моем случае, WIMBoot тестировался на виртуальной машине Hyper-V. Чтобы сымитировать стандартный процесс установки WIMBoot на планшет с флешки, я буду использовать виртуальный жесткий диск и опишу процесс его создания. Для того, чтобы записать образ Windows PE на VHD, воспользуемся инструментом diskpart и введем следующие команды:

Diskpart 
  create vdisk file=”C:\WinPE.vhdx” maximum=16000
  attach vdisk
  create partition primary
  assign letter=V
  format fs=ntfs quick
exit

Далее запишем файлы WinPE на созданный нами виртуальный диск

MakeWinPEMedia /UFD C:\WinPE_amd64 V:

Снова запустим diskpart и завершим создание диска.

Diskpart
  select vdisk file=”C:\WinPE.vhdx”
  detach vdisk
exit

3. Добавление WIMBoot на загрузочный диск

После того, как создан образ WinPE 5.1 и подготовлен образ WIMBoot, программу Deployment Image and Management можно закрыть. Продолжим работать мы уже без нее. Теперь на диск с WinPE 5.1 необходимо добавить файлы образа WIMBoot (копируем папку Images целиком). Также, я рекомендую добавить на загрузочный диск несколько скриптов для diskpart, которые сэкономят нам время при создании и развертывание образа WIMBoot. Эти скрипты необязательны, их можно добавить позже или не добавлять к образу совсем.
Добавлять WIMBoot на загрузочный диск можно на абсолютно любом компьютере или же виртуальной машине, главное, чтобы они соответствовали ограничениям, которые накладывает технология WIMBoot. Я продолжу работать с виртуальной машиной и создам в Hyper-V виртуальную машину второго поколения (Generation 2), которая поддерживает технологию UEFI. В качестве образа для установки операционной системы я укажу созданный ранее виртуальный диск WinPE.vhdx. Образ WinPE с WIMBoot я создавала на виртуальной машине с размером жесткого диска в 32 ГБ. А устанавливала систему с помощью WIMBoot уже на виртуалку с размером жесткого диска для создаваемой виртуальной машины будет составлять 16 ГБ, чтобы симулировать установку на планшет с маленьким размером жесткого диска. Загружаем виртуальную машину с диска WinPE.vhdx и ждем пока запустится утили wpeinit (может занять несколько минут).
С помощью утилиты diskpart создадим разделы жесткого диска. Можно запустить скрипт, приведенный ниже с помощью команды

diskpart /s C:\Createpartition.txt

Проверить нахождения файла скрипта можно запустив утилиту diskpart и команду list volume. Надо указать путь к диску WinPE.

rem == CreatePartitions.txt ==
select disk 0
clean
convert gpt
rem == Создание раздела под средства восстановления ==
create partition primary size=300
format quick fs=ntfs label=”Windows RE tools”
assign letter=”T”
set id=”de94bba4-06d1-4d40-a16a-bfd50179d6ac”
gpt attributes=0x8000000000000001
rem == Создание системного раздела ==
create partition efi size=100
format quick fs=fat32 label=”System”
assign letter=”S”
rem == Создание раздела MSR ==
create partition msr size=128
rem == Создание раздела Windows ==
create partition primary
shrink minimum=10000
format quick fs=ntfs label=”Windows”
assign letter=”W”
rem == Создание образа для восстановления ==
create partition primary
format quiсk fs=ntfs label=”Recovery image”
assign letter=”R”
set id=”de94bba4-06d1-4d40-a16a-bfd50179d6ac”
gpt attributes=0x8000000000000001
list volume
exit

Небольшой комментарий по поводу команды

set id=”de94bba4-06d1-4d40-a16a-bfd50179d6ac”
gpt attributes=0x8000000000000001

Использование приведенного выше скрипта не позволяет пользователю увидеть разделы восстановления через проводник, однако через Disk Management Tools пользователь может эти разделы удалить. Чтобы предотвратить удаление разделов восстановления и нужно использовать вышеприведенную команду.
После выполнения данного скрипта, вы должны увидеть примерно следующее.

В итоге получились вот такие разделы (MSR – резервный раздел Microsoft и в выводе данной команды не отображается):

Далее выполним установку образа. Сначала создадим директорию на диске R и скопируем туда установочный образ.

md R:\RI
copy C:\Images\install.wim R:\RI\install.wim

Применим образ install.wim на раздел Windows.

dism /Apply-Image /ImageFile:R:\RI\install.wim /Index:1 /ApplyDir:W:\

Скопируем инструменты для восстановления на раздел Windows RE.

md T:\Recovery\WindowsRE
attrib –s –h W:\windows\system32\recovery\winre.wim
copy W:\windows\system32\recovery\winre.wim T:\Recovery\WindowsRE\winre.wim

Скопируем загрузочные файлы с раздела Windows на раздел System. Данный шаг нужен для того, чтобы загружать развернутый образ.

bcdboot W:\Windows

Зарегистрируем раздел Windows и раздел восстановления

W:\Windows\System32\reagentc /setosimage /path R:\RI /target W:\Windows /index 1
W:\Windows\System32\reagentc /setreimage /path T:\Recovery\WindowsRE /target W:\Windows

Перезагрузим компьютер. При новой загрузке дождемся экрана с началом настройки.

При его появлении необходимо нажать комбинацию CTRL+SHIFT+F3, чтобы перезагрузить компьютер в режиме аудита. После этого компьютер запустит систему под учетной записью локального администратора. В среде Windows 8.1 нужно будет запустить командную строку с правами Администратора и очистить образ. Очистка образа позволит освободить дополнительное место на диске.

dism /Cleanup-Image /Online /StartComponentCleanup

После этого с помощью команды Sysprep подготовим компьютер к использованию и завершим работу.

C:\Windows\System32\Sysprep\sysprep /generalize /shutdown /oobe

Запустим компьютер снова в режиме WinPE. Рекомендую запустить утилиту diskpart и команду list volume. У вас должны быть назначены буквы на диск с Windows и на диск WinPE. Все остальные разделы скрыты.

Создадим каталог для временных файлов C:\Recycler\Scratch и перезахватим образ, но уже с опцией WIMBoot.

DISM /Capture-Image /WIMBoot /ImageFile:"D:\Images\install_wimboot.wim" /CaptureDir:C: /Name:"WIMBoot Enterprise_x64 with 8.1 Updates" /ScratchDir:C:\Recycler\Scratch

После того, как выполнение команды завершится, мы можем выключить компьютер. Теперь на нашем виртуальном диске или на флешке есть установочный образ WIMBoot.

4. Развертывание WIMBoot

Теперь осталось только протестировать образ WIMBoot и убедиться в том, что размер файлов, занимаемых Windows уменьшится. Как уже и говорилось ранее, для установки будет использована виртуальная машина второго поколения, поддерживающая технологию UEFI с объемом жесткого диска в 16 ГБ. В качестве установочного диска используем виртуальный диск WinPE.vhdx и запустим виртуальную машину.

4.1 Форматирование жесткого диска по схеме разделов WIMBoot

Дождемся запуска среды wpeinit, запустим утилиту diskpart и команду list volume. Если на раздел WinPE назначена буква С, рекомендую переназначить ее с помощью следующих команд.

select volume=0
assign letter=”D”
exit

Теперь с помощью утилиты diskpart и приведенного ниже скрипта создадим разделы для установки. Скрипт запустим командой

diskpart /s D:\WimCreatePartition.txt

rem == WimCreatePartition.txt ==
select disk 0
clean
convert gpt
rem == Создание системного раздела ==
create partition efi size=100
format quick fs=fat32 label=”System”
rem == Создание раздела MSR ==
create partition msr size=128
rem == Создание раздела Windows ==
create partition primary
shrink minimum=5000
format quick fs=ntfs label=”Windows”
assign letter=”С”
rem == Создание раздела для образов ==
create partition primary
format quick fs=ntfs label=”Images”
assign letter=”M”
set id=”de94bba4-06d1-4d40-a16a-bfd50179d6ac”
gpt attributes=0x8000000000000001
list volume
exit

В итоге должны получить вот такой результат:

4.2 Добавление Windows и файлов восстановления

Создадим папку “Windows Images” в разделе Images. Название папки обязательно должно быть “Windows Images”.

md "M:\ Windows Images \"

Скопируем образ Windows с диска WinPE в папку Windows Images и переименуем его в install.wim, если это необходимо.

copy D:\Images\install_update1.wim "M:\Windows Images\install.wim"

Применим образ Windows к разделу Windows с помощью команды /WIMBoot. Перед этим создадим каталог для временных файлов, чтобы избежать проблем, связанных с короткими именами файлов.

md C:\Recycler\Scratch
DISM /Apply-Image /ImageFile:"M:\Windows Images\install.wim" /ApplyDir:C: /Index:1 /WIMBoot /ScratchDir:C:\Recycler\Scratch

Создадим файлы загрузки и настроим их работу в раздел Windows.

C:\Windows\System32\bcdboot C:\Windows

Скопируем образ среды восстановления Windows в папку Images

md M:\Recovery\WindowsRE
echo f | xcopy D:\Images\winre.wim M:\Recovery\WindowsRE\winre.wim /h

Зарегистрируем раздел среды восстановления Windows.

C:\Windows\System32\Reagentc /SetREImage /Path M:\Recovery\WindowsRE /Target C:\Windows

4.3 Защита папки WIMBoot

Осталось защитить разделы образов Windows и проверить полученные результаты. Для установки атрибута «Только для чтения» в среде wpeinit выполним следующие команды

icacls "M:\Windows Images" /inheritance:r /T
icacls "M:\Windows Images" /grant:r SYSTEM:(R) /T
icacls "M:\Windows Images" /grant:r *S-1-5-32-544:(R) /T

Теперь осталось только запустить компьютер и увидеть приятную картинку:

Что же произошло? Теперь свободного диска на разделе Windows стало больше. Это произошло за счет того, что в разделе Windows теперь находятся файлы-указатели, которые ссылаются на образы Windows. При этом пользователь не ощущает разницы в работе: все его файлы работают нормально.

В завершение, хочу дополнительно отметить, что если есть необходимость добавить к образу WIMBoot какие-либо дополнительные настройки, это можно сделать до того, как папки WIMBoot были защищены. Дополнительную информацию по WIMBoot можно почитать на TechNet.

Надеюсь, информация будет полезна!

Приложение

Установка обновления: WinPE 5.0 —> WinPE 5.1

Перейдем к созданию WinPE и его обновления. В принципе, можете сначала просто создать WinPE, попробовать загрузить с его помощью целевой компьютер и проверить его версию. Однако здесь я приведу весь процесс создания образа.
Предварительно должна быть создана рабочая копия файлов Windows PE.
Смонтируем образ Windows PE

Dism /Mount-Image /ImageFile:"C:\WinPE_amd64\media\sources\boot.wim" /index:1 /MountDir:"C:\WinPE_amd64\mount"

Добавляем пакеты обновлений к образу Windows PE. Набор пакетов обновлений тот же, что и был использован для обновления образа Windows 8.1 можно скачать здесь. Важно при загрузке пакета KB2919355 скачать также пакеты KB2919355, KB2932046, KB2934018, KB2937592, KB2938439, и KB2959977. Пакеты нужно устанавливать по порядку и по отдельности.

Dism /Add-Package /PackagePath:C:\MSU\Windows8.1-<Package>-<arch>.msu /Image:C:\mount\Windows /LogPath:AddPackage.log

Оптимизируем образ

Dism /Image:С:\WinPE_amd64\mount /Cleanup-Image /StartComponentCleanup /ResetBase

Размонтируем образ Windows PE

Dism /Unmount-Image /MountDir:"C:\WinPE_amd64\mount" /commit

Экспортируем и конвертируем образ Windows PE в новый wim-файл

Dism /Export-Image /SourceImageFile:C:\WinPE_amd64\media\sources\boot.wim /SourceIndex:1 /DestinationImageFile:C:\WinPE_amd64\media\sources\boot2.wim

Заменяем файл boot.wim новым файлом boot2.wim

del C:\WinPE_amd64\media\sources\boot.wim
rename C:\WinPE_amd64\media\sources\boot2.wim boot.wim

Проверка образа WIMBoot

А теперь я приведу команды для проверки образа WIMBoot, которые необходимо выполнить в среде wpeinit.

Проверяем наличие разделов System, MSR, Windows и Images

diskpart
  select disk 0
  select partition 3
  assign letter C
  select partition 4
  assign letter M
  list partition
exit

Ожидаемый результат:

Проверка атрибутов раздела Images

diskpart
  select disk 0
  select partition 4
  detail partition
exit

Ожидаемый результат:

Проверка файлов в разделе Images и файлов восстановления

dir "M:\Windows Images"
dir M:\Recovery\WindowsRE

Ожидаемый результат:

В среде восстановления Windows должно быть правильно указано расположение допустимого образа восстановления.

C:\Windows\System32\Reagentc /Info /Target C:\Windows

Ожидаемый результат:

Установка обновлений на образ Windows 8.1

Смонтируем образ Windows

md C:\mount\Windows
Dism /Mount-Image /ImageFile:"C:\Images\install.wim" /Index:1 /MountDir:C:\mount\Windows

Устанавливаем обновления KB2919442 и KB2919355. Данные пакеты доступны для различных архитектур процессора: x86, x64 и arm. Скачать пакеты можно здесь. Пакеты обновлений должны быть установлены по порядку и по отдельности.

Dism /Add-Package /PackagePath:C:\MSU\Windows8.1-<Package>-<arch>.msu /Image:C:\mount\Windows /LogPath:AddPackage.log

Здесь и далее — имя пакета, а — архитектура процессора.
Монтируем образ Windows RE

md C:\mount\WinRE
Dism /Mount-Image /ImageFile:"C:\mount\Windows\Windows\System32\Recovery\winre.wim" /Index:1 /MountDir:C:\mount\WinRE

Обновляем образ WinRE с помощью тех же пакетов, которые были использованы при обновлении образа Windows

Dism /Add-Package /PackagePath:C:\MSU\Windows8.1-<Package>-<arch>.msu /Image:C:\mount\WinRE /LogPath:AddPackage.log

Дополнительно выполним очистку образа, для того, чтобы удалить некоторые элементы и уменьшить конечный размер образа. Этот шаг необязателен, но его можно выполнить только на этом этапе: после запуска очистить образ будет невозможно.

Dism /Cleanup-Image /Image:C:\mount\WinRE /StartComponentCleanup /ResetBase

Теперь можно размонтировать образ Windows RE

Dism /Unmount-Image /MountDir:C:\mount\WinRE /Commit

Для того, чтобы увидеть изменения в размере файла, образ нужно экспортировать.

Dism /Export-Image /SourceImageFile:C:\mount\Windows\Windows\System32\Recovery\winre.wim /SourceIndex:1 /DestinationImageFile:C:\Images\winre_updated.wim

После экспорта, необходимо заменить winre.wim новой версией.

attrib –s -h C:\mount\Windows\Windows\System32\Recovery\winre.wim Del C:\mount\Windows\Windows\System32\Recovery\winre.wim copy C:\Images\winre_updated.wim C:\mount\Windows\Windows\System32\Recovery\winre.wim

После того, как обновления установлены, можно размонтировать образ Windows

Dism /Unmount-Image /MountDir:C:\mount\Windows /Commit

Источник

See Also

Overview

1. What is Windows Image Boot (WIMBoot)?

2. How does Wimboot Works?

3. Advantages of WIMBoot

4. Disadvantages of WIMBoot

5. How Much Space Does WIMBoot Need?

6. How To Get WIMBoot

7. How to Create a Wimboot Installation

Conclusion

PROCESS IN OUTLINE:

ADDING A ‘WINDOWS INSTALL FROM ISO’ MENU TO THE E2B GRUB2 MENU SYSTEM

Add grub2 UEFI + wimboot (using a1ive grub2)

THE BCD

wimboot command line

File Injection into \Windows\System32

Make your own grub2 boot files

EXAMPLE WINPE E2B .GRUB2 MENUS

GRUB2 UEFI + WIMBOOT (IPXE)

Download files

Содержание

Как Происходит Установка ОС Windows

Стандартный Установщик Windows

Мультиустановка с Помощью Установщика Windows

Уменьшение Размера WIM-архива

Ручная Установка

Разметка Диска

Diskpart

MBR

GPT

Извлечение Файлов

DISM

Установка Загрузчика

BIOS

UEFI

Тестовый Запуск

Итог

Обзор технологии

Стандартная схема разделов (без WIMBoot)

Схема разделов при использовании WIMBoot

1. Создание образа WIMBoot

1.1 Создание временной копии образа для установки Windows

1.2 Отделение образа для восстановления от главного образа Windows

1.3 Оптимизация образа для WIMBoot

2. Создание загрузочного диска WinPE 5.1

3. Добавление WIMBoot на загрузочный диск

4. Развертывание WIMBoot

4.1 Форматирование жесткого диска по схеме разделов WIMBoot

4.2 Добавление Windows и файлов восстановления

4.3 Защита папки WIMBoot

Приложение