ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/pbcdedit/pbcdedit

Comparing pbcdedit/pbcdedit (file contents):
Revision 1.9 by root, Wed Aug 14 22:54:28 2019 UTC vs.
Revision 1.72 by root, Sun Sep 15 01:40:09 2019 UTC

…		…
17	#	17	#
18	# You should have received a copy of the GNU General Public License	18	# You should have received a copy of the GNU General Public License
19	# along with this program. If not, see <https://www.gnu.org/licenses/>.	19	# along with this program. If not, see <https://www.gnu.org/licenses/>.
20	#	20	#
21		21
22	use 5.014; # numerous features needed	22	use 5.016; # numerous features need 5.14, __SUB__ needs 5.16
23		23
24	our $VERSION = '1.0';	24	our $VERSION = '1.4';
25	our $JSON_VERSION = 1; # the versiobn of the json objects generated by this program	25	our $JSON_VERSION = 3; # the version of the json objects generated by this program
		26
		27	our $CHANGELOG = <<EOF;
		28
		29	- add "del" edit instruction.
		30	- work around lsblk bug sometimes giving "dos" pttype for gpt partitions.
		31	- bootmenupolicy in synopsis must be set to 0 for text menu.
		32	- minor doc fxes.
		33
		34	1.4 Thu Aug 22 10:48:22 CEST 2019
		35	- new "create" subcommand.
		36	- "create" and "edit" try to save and restore ownership/permissions
		37	of bcd hives when writing the new file.
		38	- editorial fixes to the documentation.
		39	- add mininmal hive creation example.
		40
		41	1.3 Sat Aug 17 07:04:15 CEST 2019
		42	- output of pbcdedit elements --json has changed, as it didn't
		43	take the reorganisation by classes fully into account.
		44	- json schema bumped to 3.
		45	- new "bcd-device" and "bcd-legacy-device" subcommands.
		46	- implement --json option for lsblk.
		47
		48	1.2 Fri Aug 16 00:20:41 CEST 2019
		49	- bcd element names now depend on the bcd object type they are in,
		50	also affects "elements" output.
		51	- json schema bumped to 2.
		52	- new version command.
		53	- numerous minor bugfixes.
		54
		55	EOF
26		56
27	=head1 NAME	57	=head1 NAME
28		58
29	pbcdedit - portable boot configuration data (BCD) store editor	59	pbcdedit - portable boot configuration data (BCD) store editor
30		60
31	=head1 SYNOPSIS	61	=head1 SYNOPSIS
32		62
33	pbcdedit help # output manual page	63	pbcdedit help # output manual page
		64	pbcdedit version # output version and changelog
		65
34	pbcdedit export path/to/BCD # output BCD hive as JSON	66	pbcdedit export path/to/BCD # output BCD hive as JSON
35	pbcdedit import path/to/bcd # convert standard input to BCD hive	67	pbcdedit import path/to/BCD # convert standard input to BCD hive
36	pbcdedit edit path/to/BCD edit-instructions...	68	pbcdedit edit path/to/BCD edit-instructions...
37		69
38	pbcdedit objects # list all supported object aliases and types	70	pbcdedit objects # list all supported object aliases and types
39	pbcdedit elements # list all supported bcd element aliases	71	pbcdedit elements # list all supported bcd element aliases
40		72
		73	# Example: enable text-based boot menu.
		74	pbcdedit edit /my/BCD set '{default}' bootmenupolicy 0
		75
		76	# Example change system device to first partition containing winload.
		77	pbcdedit edit /my/BCD \
		78	set '{default}' device 'locate=<null>,element,path' \
		79	set '{default}' osdevice 'locate=<null>,element,path'
		80
		81
41	=head1 DESCRIPTION	82	=head1 DESCRIPTION
42		83
43	This program allows you to create, read and modify Boot Configuration Data	84	This program allows you to create, read and modify Boot Configuration Data
44	(BCD) stores used by Windows Vista and newer versions of Windows.	85	(BCD) stores used by Windows Vista and newer versions of Windows.
45		86
…		…
58		99
59	=item Does not rely on Windows	100	=item Does not rely on Windows
60		101
61	As the "portable" in the name implies, this program does not rely on	102	As the "portable" in the name implies, this program does not rely on
62	C<bcdedit> or other windows programs or libraries, it works on any system	103	C<bcdedit> or other windows programs or libraries, it works on any system
63	that supports at least perl version 5.14.	104	that supports at least perl version 5.16.
64		105
65	=item Decodes and encodes BCD device elements	106	=item Decodes and encodes BCD device elements
66		107
67	PBCDEDIT can concisely decode and encode BCD device element contents. This	108	PBCDEDIT can concisely decode and encode BCD device element contents. This
68	is pretty unique, and offers a lot of potential that can't be realised	109	is pretty unique, and offers a lot of potential that can't be realised
…		…
75	sensitive data.	116	sensitive data.
76		117
77	=back	118	=back
78		119
79	The target audience for this program is professionals and tinkerers who	120	The target audience for this program is professionals and tinkerers who
80	are rewady to invest time into learning how it works. It is not an easy	121	are ready to invest time into learning how it works. It is not an easy
81	program to use and requires patience and a good understanding of BCD data	122	program to use and requires patience and a good understanding of BCD
82	stores.	123	stores.
83		124
84		125
85	=head1 SUBCOMMANDS	126	=head1 SUBCOMMANDS
86		127
87	PCBEDIT expects a subcommand as first argument that tells it what to	128	PBCDEDIT expects a subcommand as first argument that tells it what to
88	do. The following subcommands exist:	129	do. The following subcommands exist:
89		130
90	=over	131	=over
91		132
92	=item help	133	=item C<help>
93		134
94	Displays the whole manuale page (this document).	135	Displays the whole manual page (this document).
95		136
		137	=item C<version>
		138
		139	This outputs the PBCDEDIT version, the JSON schema version it uses and the
		140	full log of changes.
		141
96	=item export F<path>	142	=item C<export> F<path>
97		143
98	Reads a BCD data store and writes a JSON representation of it to standard	144	Reads a BCD data store and writes a JSON representation of it to standard
99	output.	145	output.
100		146
101	The format of the data is explained later in this document.	147	The format of the data is explained later in this document.
102		148
103	Example: read a BCD store, modify it wiht an extenral program, write it again.	149	Example: read a BCD store, modify it with an external program, write it
		150	again.
104		151
105	pbcdedit export BCD | modify-json-somehow | pbcdedit import BCD	152	pbcdedit export BCD | modify-json-somehow | pbcdedit import BCD
106		153
107	=item import F<path>	154	=item C<import> F<path>
108		155
109	The reverse of C<export>: Reads a JSON representation of a BCD data store	156	The reverse of C<export>: Reads a JSON representation of a BCD data store
110	from standard input, and creates or replaces the given BCD data store.	157	from standard input, and creates or replaces the given BCD data store.
111		158
112	=item edit F<path> instructions...	159	=item C<edit> F<path> I<instructions...>
113		160
114	Load a BCD data store, apply some instructions to it, and save it again.	161	Load a BCD data store, apply some instructions to it, and save it again.
115		162
116	See the section L<EDITING BCD DATA STORES>, below, for more info.	163	See the section L<EDITING BCD STORES>, below, for more info.
117		164
118	=item parse F<path> instructions...	165	=item C<parse> F<path> I<instructions...>
119		166
120	Same as C<edit>, above, except it doesn't save the data store again. Can	167	Same as C<edit>, above, except it doesn't save the data store again. Can
121	be useful to extract some data from it.	168	be useful to extract some data from it.
122		169
123	=item lsblk	170	=item C<create> F<path> I<instructions...>
		171
		172	Same as C<edit>, above, except it creates a new data store from scratch if
		173	needed. An existing store will be emptied completely.
		174
		175	=item C<lsblk> [C<--json>]
124		176
125	On a GNU/Linux system, you can get a list of partition device descriptors	177	On a GNU/Linux system, you can get a list of partition device descriptors
126	using this command - the external C<lsblk> command is required, as well as	178	using this command - the external C<lsblk> command is required, as well as
127	a mounted C</sys> file system.	179	a mounted C</sys> file system.
128		180
129	The output will be a list of all partitions in the system and C<partition>	181	The output will be a list of all partitions in the system and C<partition>
130	descriptors for GPT and both C<legacypartition> and C<partition>	182	descriptors for GPT and both C<legacypartition> and C<partition>
131	descritpors for MBR partitions.	183	descriptors for MBR partitions.
132		184
		185	With C<--json> it will print similar information as C<lsblk --json>, but
		186	with extra C<bcd_device> and C<bcd_legacy_device> attributes.
		187
		188	=item C<bcd-device> F<path>
		189
		190	Tries to find the BCD device element for the given device, which currently
		191	must be a a partition of some kind. Prints the C<partition=> descriptor as
		192	a result, or nothing. Exit status will be true on success, and false on
		193	failure.
		194
		195	Like C<lsblk>, above, this likely only works on GNU/Linux systems.
		196
		197	Example: print the partition descriptor of tghe partition with label DATA.
		198
		199	$ pbcdedit bcd-device /dev/disk/by-label/DATA
		200	partition=<null>,harddisk,mbr,47cbc08a,213579202560
		201
		202	=item C<bcd-legacy-device> F<path>
		203
		204	Like above, but uses a C<legacypartition> descriptor instead.
		205
133	=item objects [--json]	206	=item C<objects> [C<--json>]
134		207
135	Outputs two tables: a table listing all type aliases with their hex bcd	208	Outputs two tables: a table listing all type aliases with their hex BCD
136	element ID, and all object name aliases with their GUID and default type	209	element ID, and all object name aliases with their GUID and default type
137	(if any).	210	(if any).
138		211
139	With C<--json> it prints similar information as a JSON object, for easier parsing.	212	With C<--json> it prints similar information as a JSON object, for easier parsing.
140		213
141	=item elements [--json]	214	=item C<elements> [C<--json>]
142		215
143	Outputs a table of known element aliases with their hex ID and the format	216	Outputs a table of known element aliases with their hex ID and the format
144	type.	217	type.
145		218
146	With C<--json> it prints similar information as a JSON object, for easier parsing.	219	With C<--json> it prints similar information as a JSON object, for easier parsing.
147		220
148	=item export-regf F<path>	221	=item C<export-regf> F<path>
149		222
150	This has nothing to do with BCD data stores - it takes a registry hive	223	This has nothing to do with BCD stores, but simply exposes PCBEDIT's
		224	internal registry hive reader - it takes a registry hive file as argument
151	file as argument and outputs a JSON representation of it to standard	225	and outputs a JSON representation of it to standard output.
152	output.
153		226
154	Hive versions 1.2 till 1.6 are supported.	227	Hive versions 1.2 till 1.6 are supported.
155		228
156	=item import-regf F<path>	229	=item C<import-regf> F<path>
157		230
158	The reverse of C<export-regf>: reads a JSON representation of a registry	231	The reverse of C<export-regf>: reads a JSON representation of a registry
159	hive from standard input and creates or replaces the registry hive file given as	232	hive from standard input and creates or replaces the registry hive file
160	argument.	233	given as argument.
161		234
162	The written hive will always be in a slightly modified version 1.3	235	The written hive will always be in a slightly modified version 1.3
163	format. It's not the format windows would generate, but it should be	236	format. It's not the format windows would generate, but it should be
164	understood by any conformant hive reader.	237	understood by any conformant hive reader.
165		238
166	Note that the representation chosen by PBCDEDIT currently throws away	239	Note that the representation chosen by PBCDEDIT currently throws away
167	clasname data (often used for feeble attemtps at hiding stuff by	240	classname data (often used for feeble attempts at hiding stuff by
168	Microsoft) and security descriptors, so if you write anything other than	241	Microsoft) and security descriptors, so if you write anything other than
169	a BCD hive you will most likely destroy it.	242	a BCD hive you will most likely destroy it.
170		243
171	=back	244	=back
172		245
173		246
174	=head1 BCD DATA STORE REPRESENTATION FORMAT	247	=head1 BCD STORE REPRESENTATION FORMAT
175		248
176	A BCD data store is represented as a JSON object with one special key,	249	A BCD data store is represented as a JSON object with one special key,
177	C<meta>, and one key per BCD object. That is, each BCD object becomes	250	C<meta>, and one key per BCD object. That is, each BCD object becomes
178	one key-value pair in the object, and an additional key called C<meta>	251	one key-value pair in the object, and an additional key called C<meta>
179	contains meta information.	252	contains meta information.
…		…
215	}	288	}
216		289
217	=head2 Minimal BCD to boot windows	290	=head2 Minimal BCD to boot windows
218		291
219	Experimentally I found the following BCD is the minimum required to	292	Experimentally I found the following BCD is the minimum required to
220	successfully boot any post-XP version of Windows (suitable C<device> and	293	successfully boot any post-XP version of Windows (assuming suitable
221	C<osdevice> values, of course):	294	C<device> and C<osdevice> values, of course, and assuming a BIOS boot -
		295	for UEFI, you should use F<winload.efi> instead of F<winload.exe>):
222		296
223	{	297	{
224	"{bootmgr}" : {	298	"{bootmgr}" : {
225	"resumeobject" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"	299	"default" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"
226	},	300	},
227		301
228	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {	302	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {
229	"type" : "application::osloader",	303	"type" : "application::osloader",
230	"description" : "Windows Boot",	304	"description" : "Windows Boot",
…		…
237		311
238	Note that minimal doesn't mean recommended - Windows itself will add stuff	312	Note that minimal doesn't mean recommended - Windows itself will add stuff
239	to this during or after boot, and you might or might not run into issues	313	to this during or after boot, and you might or might not run into issues
240	when installing updates as it might not be able to find the F<bootmgr>.	314	when installing updates as it might not be able to find the F<bootmgr>.
241		315
		316	This is how you would create a minimal hive with PBCDEDIT from within
		317	GNU/Linux, assuming F</dev/sdc3> is the windows partition, using
		318	a random GUID for the osloader and using C<partition> instead of
		319	C<legacypartition>:
		320
		321	osldr="{$(uuidgen)}"
		322	part=$(pbcdedit bcd-device /dev/sdc3)
		323	pbcdedit create minimal.bcd \
		324	set '{bootmgr}' default "$osldr" \
		325	set "$osldr" type application::osloader \
		326	set "$osldr" description 'Windows Boot' \
		327	set "$osldr" device "$part" \
		328	set "$osldr" osdevice "$part" \
		329	set "$osldr" path '\Windows\system32\winload.exe' \
		330	set "$osldr" systemroot '\Windows'
		331
242	=head2 The C<meta> key	332	=head2 The C<meta> key
243		333
244	The C<meta> key is not stored in the BCD data store but is used only	334	The C<meta> key is not stored in the BCD data store but is used only
245	by PBCDEDIT. It is always generated when exporting, and importing will	335	by PBCDEDIT. It is always generated when exporting, and importing will
246	be refused when it exists and the version stored inside doesn't store	336	be refused when it exists and the version stored inside doesn't store
247	the JSON schema version of PBCDEDIT. This ensures that differemt and	337	the JSON schema version of PBCDEDIT. This ensures that different and
248	incompatible versions of PBCDEDIT will not read and misinterüret each	338	incompatible versions of PBCDEDIT will not read and misinterpret each
249	others data.	339	others data.
250		340
251	=head2 The object keys	341	=head2 The object keys
252		342
253	Every other key is a BCD object. There is usually a BCD object for the	343	Every other key is a BCD object. There is usually a BCD object for the
254	boot manager, one for every boot option and a few others that store common	344	boot manager, one for every boot option and a few others that store common
255	settings inherited by these.	345	settings inherited by these.
256		346
257	Each BCD object is represented by a GUID wrapped in curly braces. These	347	Each BCD object is represented by a GUID wrapped in curly braces. These
258	are usually random GUIDs used only to distinguish bCD objects from each	348	are usually random GUIDs used only to distinguish BCD objects from each
259	other. When adding a new boot option, you can simply generate a new GUID.	349	other. When adding a new boot option, you can simply generate a new GUID.
260		350
261	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode	351	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode
262	into human-readable strings such as C<{globalsettings}>, which is the same	352	into human-readable strings such as C<{globalsettings}>, which is the same
263	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.	353	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.
…		…
297	get a list of all BCD elements known to PBCDEDIT by running F<pbcdedit	387	get a list of all BCD elements known to PBCDEDIT by running F<pbcdedit
298	elements>.	388	elements>.
299		389
300	What was said about duplicate keys mapping to the same object is true for	390	What was said about duplicate keys mapping to the same object is true for
301	elements as well, so, again, you should always use the canonical name,	391	elements as well, so, again, you should always use the canonical name,
302	whcih is the human radable alias, if known.	392	which is the human readable alias, if known.
303		393
304	=head3 BCD element types	394	=head3 BCD element types
305		395
306	Each BCD element has a type such as I<string> or I<boolean>. This type	396	Each BCD element has a type such as I<string> or I<boolean>. This type
307	determines how the value is interpreted, and most of them are pretty easy	397	determines how the value is interpreted, and most of them are pretty easy
…		…
319	"description" : "Windows 10",	409	"description" : "Windows 10",
320	"systemroot" : "\\Windows",	410	"systemroot" : "\\Windows",
321		411
322	=item boolean	412	=item boolean
323		413
324	Almost as simnple are booleans, which represent I<true>/I<false>,	414	Almost as simple are booleans, which represent I<true>/I<false>,
325	I<on>/I<off> and similar values. In the JSON form, true is represented	415	I<on>/I<off> and similar values. In the JSON form, true is represented
326	by the number C<1>, and false is represented by the number C<0>. Other	416	by the number C<1>, and false is represented by the number C<0>. Other
327	values will be accepted, but PBCDEDIT doesn't guarantee how these are	417	values will be accepted, but PBCDEDIT doesn't guarantee how these are
328	interpreted.	418	interpreted.
329		419
…		…
333		423
334	"displaybootmenu" : 0,	424	"displaybootmenu" : 0,
335		425
336	=item integer	426	=item integer
337		427
338	Again, very simple, this is a 64 bit integer. IT can be either specified	428	Again, very simple, this is a 64 bit integer. It can be either specified
339	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a	429	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a
340	binatry number (prefix C<0b>).	430	binary number (prefix C<0b>).
341		431
342	For example, the boot C<timeout> is an integer, specifying the automatic	432	For example, the boot C<timeout> is an integer, specifying the automatic
343	boot delay in seconds:	433	boot delay in seconds:
344		434
345	"timeout" : 30,	435	"timeout" : 30,
346		436
347	=item integer list	437	=item integer list
348		438
349	This is a list of 64 bit integers separated by whitespace. It is not used	439	This is a list of 64 bit integers separated by whitespace. It is not used
350	much, so here is a somewhat artificial an untested exanmple of using	440	much, so here is a somewhat artificial and untested example of using
351	C<customactions> to specify a certain custom, eh, action to be executed	441	C<customactions> to specify a certain custom, eh, action to be executed
352	when pressing C<F10> at boot:	442	when pressing C<F10> at boot:
353		443
354	"customactions" : "0x1000044000001 0x54000001",	444	"customactions" : "0x1000044000001 0x54000001",
355		445
356	=item guid	446	=item guid
357		447
358	This represents a single GUID value wrqapped in curly braces. It is used a	448	This represents a single GUID value wrapped in curly braces. It is used a
359	lot to refer from one BCD object to other one.	449	lot to refer from one BCD object to other one.
360		450
361	For example, The C<{bootmgr}> object might refer to a resume boot option	451	For example, The C<{bootmgr}> object might refer to a resume boot option
362	using C<resumeobject>:	452	using C<default>:
363		453
364	"resumeobject" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",	454	"default" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",
365		455
366	Human readable aliases are used and allowed.	456	Human readable aliases are used and allowed.
367		457
368	=item guid list	458	=item guid list
369		459
370	Similar to te guid type, this represents a list of such GUIDs, separated	460	Similar to the GUID type, this represents a list of such GUIDs, separated
371	by whitespace from each other.	461	by whitespace from each other.
372		462
373	For example, many BCD objects can I<inherit> elements from other BCD	463	For example, many BCD objects can I<inherit> elements from other BCD
374	objects by specifying the GUIDs of those other objects ina GUID list	464	objects by specifying the GUIDs of those other objects in a GUID list
375	called surprisingly called C<inherit>:	465	called surprisingly called C<inherit>:
376		466
377	"inherit" : "{dbgsettings} {emssettings} {badmemory}",	467	"inherit" : "{dbgsettings} {emssettings} {badmemory}",
378		468
379	This example also shows how human readable aliases can be used.	469	This example also shows how human readable aliases can be used.
…		…
383	This type is why I write I<most> are easy to explain earlier: This type	473	This type is why I write I<most> are easy to explain earlier: This type
384	is the pinnacle of Microsoft-typical hacks layered on top of other	474	is the pinnacle of Microsoft-typical hacks layered on top of other
385	hacks. Understanding this type took more time than writing all the rest of	475	hacks. Understanding this type took more time than writing all the rest of
386	PBCDEDIT, and because it is so complex, this type has its own subsection	476	PBCDEDIT, and because it is so complex, this type has its own subsection
387	below.	477	below.
		478
388	=back	479	=back
389		480
390	=head4 The BCD "device" element type	481	=head3 The BCD "device" element type
391		482
392	Device elements specify, well, devices. They are used for such diverse	483	Device elements specify, well, devices. They are used for such diverse
393	purposes such as finding a TFTP network boot imagem serial ports or VMBUS	484	purposes such as finding a TFTP network boot image, serial ports or VMBUS
394	devices, but most commonly they are used to specify the disk (harddisk,	485	devices, but most commonly they are used to specify the disk (harddisk,
395	cdrom ramdisk, vhd...) to boot from.	486	cdrom, ramdisk, vhd...) to boot from.
396		487
397	The device element is kind of a mini-language in its own which is much	488	The device element is kind of a mini-language in its own which is much
398	more versatile then the limited windows interface to it - BCDEDIT -	489	more versatile then the limited windows interface to it - BCDEDIT -
399	reveals.	490	reveals.
400		491
…		…
403	element, so almost everything known about it had to be researched first	494	element, so almost everything known about it had to be researched first
404	in the process of writing this script, and consequently, support for BCD	495	in the process of writing this script, and consequently, support for BCD
405	device elements is partial only.	496	device elements is partial only.
406		497
407	On the other hand, the expressive power of PBCDEDIT in specifying devices	498	On the other hand, the expressive power of PBCDEDIT in specifying devices
408	is much bigger than BCDEDIT and therefore more cna be don with it. The	499	is much greater than BCDEDIT and therefore more can be done with it. The
409	downside is that BCD device elements are much more complicated than what	500	downside is that BCD device elements are much more complicated than what
410	you might think from reading the BCDEDIT documentation.	501	you might think from reading the BCDEDIT documentation.
411		502
412	In other words, simple things are complicated, and complicated things are	503	In other words, simple things are complicated, and complicated things are
413	possible.	504	possible.
414		505
415	Anyway, the general syntax of device elements is an optional GUID,	506	Anyway, the general syntax of device elements is an optional GUID,
416	followed by a device type, optionally followed by hexdecimal flags in	507	followed by a device type, optionally followed by hexadecimal flags in
417	angle brackets, optionally followed by C<=> and a comma-separated list of	508	angle brackets, optionally followed by C<=> and a comma-separated list of
418	arguments, some of which can be (and often are) in turn devices again.	509	arguments, some of which can be (and often are) in turn devices again.
419		510
420	[{GUID}]type[<flags>][=arg,arg...]	511	[{GUID}]type[<flags>][=arg,arg...]
421		512
422	Here are some examples:	513	Here are some examples:
423		514
424	boot	515	boot
425	{b097d29f-bc00-11e9-8a9a-525400123456}block=file,<boot>,\\EFI"	516	{b097d29f-bc00-11e9-8a9a-525400123456}block=file,<boot>,\EFI
426	locate=<null>,element,systemroot	517	locate=<null>,element,systemroot
427	partition=<null>,harddisk,mbr,47cbc08a,1048576	518	partition=<null>,harddisk,mbr,47cbc08a,1048576
428	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd	519	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd
429	block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,68720525312>,0,0,0,\Recovery\b097d29e-bc00-11e9-8a9a-525400123456\Winre.wim	520	block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,68720525312>,0,0,0,\Recovery\b097d29e-bc00-11e9-8a9a-525400123456\Winre.wim
430	block=file,<partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,ee3a393a-f0de-4057-9946-88584245ed48>,\	521	block=file,<partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,ee3a393a-f0de-4057-9946-88584245ed48>,\
…		…
447	The types understood and used by PBCDEDIT are as follows (keep in mind	538	The types understood and used by PBCDEDIT are as follows (keep in mind
448	that not of all the following is necessarily supported in PBCDEDIT):	539	that not of all the following is necessarily supported in PBCDEDIT):
449		540
450	=over	541	=over
451		542
452	=item binary=hex...	543	=item C<binary=>I<hex...>
453		544
454	This type isn't actually a real BCD element type, but a fallback for those	545	This type isn't actually a real BCD element type, but a fallback for those
455	cases where PBCDEDIT can't perfectly decode a device element (except for	546	cases where PBCDEDIT can't perfectly decode a device element (except for
456	the leading GUID, which it can always decode). In such cases, it will	547	the leading GUID, which it can always decode). In such cases, it will
457	convert the device into this type with a hexdump of the element data.	548	convert the device into this type with a hexdump of the element data.
458		549
459	=item null	550	=item C<null>
460		551
461	This is another special type - sometimes, a device all zero-filled, which	552	This is another special type - sometimes, a device is all zero-filled,
462	is not valid. This can mark the absence of a device or something PBCDEDIT	553	which is not valid. This can mark the absence of a device or something
463	does not understand, so it decodes it into this special "all zero" type	554	PBCDEDIT does not understand, so it decodes it into this special "all
464	called C<null>.	555	zero" type called C<null>.
465		556
466	It's most commonly found in devices that can use an optional parent	557	It's most commonly found in devices that can use an optional parent
467	device, when no parent device is used.	558	device, when no parent device is used.
468		559
469	=item boot	560	=item C<boot>
470		561
471	Another type without parameters, this refers to the device that was booted	562	Another type without parameters, this refers to the device that was booted
472	from (nowadays typically the EFI system partition).	563	from (nowadays typically the EFI system partition).
473		564
474	=item vmbus=interfacetype,interfaceinstance	565	=item C<vmbus=>I<interfacetype>,I<interfaceinstance>
475		566
476	This specifies a VMBUS device with the given interface type and interface	567	This specifies a VMBUS device with the given interface type and interface
477	instance, both of which are "naked" (no curly braces) GUIDs.	568	instance, both of which are "naked" (no curly braces) GUIDs.
478		569
479	Made-up example (couldn't find a single example on the web):	570	Made-up example (couldn't find a single example on the web):
480		571
481	vmbus=c376c1c3-d276-48d2-90a9-c04748072c60,12345678-a234-b234-c234-d2345678abcd	572	vmbus=c376c1c3-d276-48d2-90a9-c04748072c60,12345678-a234-b234-c234-d2345678abcd
482		573
483	=item partition=<parent>,devicetype,partitiontype,diskid,partitionid	574	=item C<partition=><I<parent>>,I<devicetype>,I<partitiontype>,I<diskid>,I<partitionid>
484		575
485	This designates a specific partition on a block device. C<< <parent>	576	This designates a specific partition on a block device. I<parent> is an
486	>> is an optional parent device on which to search on, and is often	577	optional parent device on which to search on, and is often C<null>. Note
487	C<null>. Note that the anfgle brackets are part of the syntax.	578	that the angle brackets around I<parent> are part of the syntax.
488		579
489	C<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	580	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
490	C<file> or C<vhd>, where the first three should be self-explaining,	581	C<file> or C<vhd>, where the first three should be self-explaining,
491	C<file> is usually used to locate a device by finding a magic file, and	582	C<file> is usually used to locate a file to be used as a disk image,
492	C<vhd> is used for virtual harddisks - F<.vhd> and F<-vhdx> files.	583	and C<vhd> is used to treat files as virtual harddisks, i.e. F<vhd> and
		584	F<vhdx> files.
493		585
494	The C<partitiontype> is either C<mbr>, C<gpt> or C<raw>, the latter being	586	The I<partitiontype> is either C<mbr>, C<gpt> or C<raw>, the latter being
495	used for devices without partitions, such as cdroms, where the "partition"	587	used for devices without partitions, such as cdroms, where the "partition"
496	is usually the whole device.	588	is usually the whole device.
497		589
498	The C<diskid> identifies the disk or device using a unique signature, and	590	The I<diskid> identifies the disk or device using a unique signature, and
499	the same is true for the C<partitionid>. How these are interpreted depends	591	the same is true for the I<partitionid>. How these are interpreted depends
500	on the C<partitiontype>:	592	on the I<partitiontype>:
501		593
502	=over	594	=over
503		595
504	=item mbr	596	=item C<mbr>
505		597
506	The C<diskid> is the 32 bit disk signature stored at offset 0x1b8 in the	598	The C<diskid> is the 32 bit disk signature stored at offset 0x1b8 in the
507	MBR, interpreted as a 32 bit unsigned little endian integer and written as	599	MBR, interpreted as a 32 bit unsigned little endian integer and written as
508	hex number. That is, the bytes C<01 02 03 04> would become C<04030201>.	600	hex number. That is, the bytes C<01 02 03 04> would become C<04030201>.
509		601
510	Diskpart (using the C<DETAIL> command) and the C<lsblk> comamnd typically	602	Diskpart (using the C<DETAIL> command) and the C<lsblk> command typically
511	found on GNU/Linux systems (using e.g. C<lsblk -o NAME,PARTUUID>) can	603	found on GNU/Linux systems (using e.g. C<lsblk -o NAME,PARTUUID>) can
512	display the disk id.	604	display the I<diskid>.
513		605
514	The C<partitionid> is the byte offset(!) of the partition counting from	606	The I<partitionid> is the byte offset(!) of the partition counting from
515	the beginning of the MBR.	607	the beginning of the MBR.
516		608
517	Example, use the partition on the harddisk with C<diskid> C<47cbc08a>	609	Example, use the partition on the harddisk with I<diskid> C<47cbc08a>
518	starting at sector C<2048> (= 1048576 / 512).	610	starting at sector C<2048> (= 1048576 / 512).
519		611
520	partition=<null>,harddisk,mbr,47cbc08a,1048576	612	partition=<null>,harddisk,mbr,47cbc08a,1048576
521		613
522	=item gpt	614	=item C<gpt>
523		615
524	The C<diskid> is the disk UUID/disk identifier GUID from the partition	616	The I<diskid> is the disk GUID/disk identifier GUID from the partition
525	table (as displayed e.g. by C<gdisk>), and the C<partitionid> is the	617	table (as displayed e.g. by F<gdisk>), and the I<partitionid> is the
526	partition unique GUID (displayed using e.g. the C<gdisk> C<i> command).	618	partition unique GUID (displayed using e.g. the F<gdisk> F<i> command).
527		619
528	Example: use the partition C<76d39e5f-ad1b-407e-9c05-c81eb83b57dd> on GPT	620	Example: use the partition C<76d39e5f-ad1b-407e-9c05-c81eb83b57dd> on GPT
529	disk C<9742e468-9206-48a0-b4e4-c4e9745a356a>.	621	disk C<9742e468-9206-48a0-b4e4-c4e9745a356a>.
530		622
531	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd	623	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd
532		624
533	=item raw	625	=item C<raw>
534		626
535	Instead of diskid and partitionid, this type only accepts a decimal disk	627	Instead of I<diskid> and I<partitionid>, this type only accepts a decimal
536	number and signifies the whole disk. BCDEDIT cannot display the resulting	628	disk number and signifies the whole disk. BCDEDIT cannot display the
537	device, and I am doubtful whether it has a useful effect.	629	resulting device, and I am doubtful whether it has a useful effect.
538		630
539	=back	631	=back
540		632
541	=item legacypartition=<parent>,devicetype,partitiontype,diskid,partitionid	633	=item C<legacypartition=><I<parent>>,I<devicetype>,I<partitiontype>,I<diskid>,I<partitionid>
542		634
543	This is exactly the same as the C<partition> type, except for a tiny	635	This is exactly the same as the C<partition> type, except for a tiny
544	detail: instead of using the partition start offset, this type uses the	636	detail: instead of using the partition start offset, this type uses the
545	partition number for MBR disks. Behaviour other partition types should be	637	partition number for MBR disks. Behaviour other partition types should be
546	the same.	638	the same.
547		639
548	The partition number starts at C<1> and skips unused partition, so if	640	The partition number starts at C<1> and skips unused partition, so if
549	there are two primary partitions and another partition inside the extended	641	there are two primary partitions and another partition inside the extended
550	partition, the primary partitions are number C<1> and C<2> and the	642	partition, the primary partitions are number C<1> and C<2> and the
551	partition inside the extended partition is number C<3>, rwegardless of any	643	partition inside the extended partition is number C<3>, regardless of any
552	gaps.	644	gaps.
553		645
554	=item locate=<parent>,locatetype,locatearg	646	=item C<locate=><I<parent>>,I<locatetype>,I<locatearg>
555		647
556	This device description will make the bootloader search for a partition	648	This device description will make the bootloader search for a partition
557	with a given path.	649	with a given path.
558		650
559	The C<< <parent> >> device is the device to search on (angle brackets are	651	The I<parent> device is the device to search on (angle brackets are
560	still part of the syntax!) If it is C<< <null> >>, then C<locate> will	652	still part of the syntax!) If it is C<null>, then C<locate> will
561	search all disks it can find.	653	search all disks it can find.
562		654
563	C<locatetype> is either C<element> or C<path>, and merely distinguishes	655	I<locatetype> is either C<element> or C<path>, and merely distinguishes
564	between two different ways to specify the path to search for: C<element>	656	between two different ways to specify the path to search for: C<element>
565	uses an element ID (either as hex or as name) as C<locatearg> and C<path>	657	uses an element ID (either as hex or as name) as I<locatearg> and C<path>
566	uses a relative path as C<locatearg>.	658	uses a relative path as I<locatearg>.
567		659
568	Example: find any partition which has the C<magicfile.xxx> path in the	660	Example: find any partition which has the F<magicfile.xxx> path in the
569	root.	661	root.
570		662
571	locate=<null>,path,\magicfile.xxx	663	locate=<null>,path,\magicfile.xxx
572		664
573	Example: find any partition which has the path specified in the	665	Example: find any partition which has the path specified in the
574	C<systemroot> element (typically C<\Windows>).	666	C<systemroot> element (typically F<\Windows>).
575		667
576	locate=<null>,element,systemroot	668	locate=<null>,element,systemroot
577		669
578	=item block=devicetype,args...	670	=item C<block=>I<devicetype>,I<args...>
579		671
580	Last not least, the most complex type, C<block>, which... specifies block	672	Last not least, the most complex type, C<block>, which... specifies block
581	devices (which could be inside a F<vhdx> file for example).	673	devices (which could be inside a F<vhdx> file for example).
582		674
583	C<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	675	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
584	C<file> or C<vhd> - the same as for C<partiion=>.	676	C<file> or C<vhd> - the same as for C<partition=>.
585		677
586	The remaining arguments change depending on the C<devicetype>:	678	The remaining arguments change depending on the I<devicetype>:
587		679
588	=over	680	=over
589		681
590	=item block=file,<parent>,path	682	=item C<block=file>,<I<parent>>,I<path>
591		683
592	Interprets the C<< <parent> >> device (typically a partition) as a	684	Interprets the I<parent> device (typically a partition) as a
593	filesystem and specifies a file path inside.	685	filesystem and specifies a file path inside.
594		686
595	=item block=vhd,<parent>	687	=item C<block=vhd>,<I<parent>>
596		688
597	Pretty much just changes the interpretation of C<< <parent> >>, which is	689	Pretty much just changes the interpretation of I<parent>, which is
598	usually a disk image (C<block=file,...)>) to be a F<vhd> or F<vhdx> file.	690	usually a disk image (C<block=file,...)>) to be a F<vhd> or F<vhdx> file.
599		691
600	=item block=ramdisk,<parent>,base,size,offset,path	692	=item C<block=ramdisk>,<I<parent>>,I<base>,I<size>,I<offset>,I<path>
601		693
602	Interprets the C<< <parent> >> device as RAM disk, using the (decimal)	694	Interprets the I<parent> device as RAM disk, using the (decimal)
603	base address, byte size and byte offset inside a file specified by	695	base address, byte size and byte offset inside a file specified by
604	C<path>. The numbers are usually all C<0> because they cna be extracted	696	I<path>. The numbers are usually all C<0> because they can be extracted
605	from the RAM disk image or other parameters.	697	from the RAM disk image or other parameters.
606		698
607	This is most commonly used to boot C<wim> images.	699	This is most commonly used to boot C<wim> images.
608		700
609	=item block=floppy,drivenum	701	=item C<block=floppy>,I<drivenum>
610		702
611	Refers to a removable drive identified by a number. BCDEDIT cannot display	703	Refers to a removable drive identified by a number. BCDEDIT cannot display
612	the resultinfg device, and it is not clear what effect it will have.	704	the resulting device, and it is not clear what effect it will have.
613		705
614	=item block=cdrom,drivenum	706	=item C<block=cdrom>,I<drivenum>
615		707
616	Pretty much the same as C<floppy> but for CD-ROMs.	708	Pretty much the same as C<floppy> but for CD-ROMs.
617		709
618	=item anything else	710	=item anything else
619		711
620	Probably not yet implemented. Tell me of your needs...	712	Probably not yet implemented. Tell me of your needs...
621		713
622	=back	714	=back
623		715
624	=back5 Examples	716	=head4 Examples
625		717
626	This concludes the syntax overview for device elements, but probably	718	This concludes the syntax overview for device elements, but probably
627	leaves many questions open. I can't help with most of them, as I also ave	719	leaves many questions open. I can't help with most of them, as I also have
628	many questions, but I can walk you through some actual examples using mroe	720	many questions, but I can walk you through some actual examples using more
629	complex aspects.	721	complex aspects.
630		722
631	=item locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path	723	=item C<< locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path >>
632		724
633	Just like with C declarations, you best treat device descriptors as	725	Just like with C declarations, you best treat device descriptors as
634	instructions to find your device and work your way from the inside out:	726	instructions to find your device and work your way from the inside out:
635		727
636	locate=<null>,path,\disk.vhdx	728	locate=<null>,path,\disk.vhdx
…		…
643	Next, this takes the device locate has found and finds a file called	735	Next, this takes the device locate has found and finds a file called
644	F<\disk.vhdx> on it. This is the same file locate was using, but that is	736	F<\disk.vhdx> on it. This is the same file locate was using, but that is
645	only because we find the device using the same path as finding the disk	737	only because we find the device using the same path as finding the disk
646	image, so this is purely incidental, although quite common.	738	image, so this is purely incidental, although quite common.
647		739
648	Bext, this file will be opened as a virtual disk:	740	Next, this file will be opened as a virtual disk:
649		741
650	block=vhd,<see above>	742	block=vhd,<see above>
651		743
652	And finally, inside this disk, another C<locate> will look for a partition	744	And finally, inside this disk, another C<locate> will look for a partition
653	with a path as specified in the C<path> element, which most likely will be	745	with a path as specified in the C<path> element, which most likely will be
…		…
656	locate=<see above>,element,path	748	locate=<see above>,element,path
657		749
658	As a result, this will boot the first Windows it finds on the first	750	As a result, this will boot the first Windows it finds on the first
659	F<disk.vhdx> disk image it can find anywhere.	751	F<disk.vhdx> disk image it can find anywhere.
660		752
661	=item locate=<block=vhd,<block=file,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,\win10.vhdx>>,element,path	753	=item C<< locate=<block=vhd,<block=file,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,\win10.vhdx>>,element,path >>
662		754
663	Pretty much the same as the previous case, but witzh a bit of variance. First, look for a specific partition on	755	Pretty much the same as the previous case, but with a bit of
664	an MBR-partitioned disk:	756	variance. First, look for a specific partition on an MBR-partitioned disk:
665		757
666	partition=<null>,harddisk,mbr,47cbc08a,242643632128	758	partition=<null>,harddisk,mbr,47cbc08a,242643632128
667		759
668	Then open the file F<\win10.vhdx> on that partition:	760	Then open the file F<\win10.vhdx> on that partition:
669		761
…		…
675		767
676	And again the windows loader (or whatever is in C<path>) will be searched:	768	And again the windows loader (or whatever is in C<path>) will be searched:
677		769
678	locate=<see above>,element,path	770	locate=<see above>,element,path
679		771
680	=item {b097d2b2-bc00-11e9-8a9a-525400123456}block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,0,0,0,\boot.wim	772	=item C<< {b097d2b2-bc00-11e9-8a9a-525400123456}block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,0,0,0,\boot.wim >>
681		773
682	This is quite different. First, it starts with a GUID. This GUID belongs	774	This is quite different. First, it starts with a GUID. This GUID belongs
683	to a BCD object of type C<device>, which has additional parameters:	775	to a BCD object of type C<device>, which has additional parameters:
684		776
685	"{b097d2b2-bc00-11e9-8a9a-525400123456}" : {	777	"{b097d2b2-bc00-11e9-8a9a-525400123456}" : {
…		…
688	"ramdisksdidevice" : "partition=<null>,harddisk,mbr,47cbc08a,1048576",	780	"ramdisksdidevice" : "partition=<null>,harddisk,mbr,47cbc08a,1048576",
689	"ramdisksdipath" : "\boot.sdi"	781	"ramdisksdipath" : "\boot.sdi"
690	},	782	},
691		783
692	I will not go into many details, but this specifies a (presumably empty)	784	I will not go into many details, but this specifies a (presumably empty)
693	template ramdisk image (F<\boot.sdi>) that is used to initiaolize the	785	template ramdisk image (F<\boot.sdi>) that is used to initialize the
694	ramdisk. The F<\boot.wim> file is then extracted into it. As you cna also	786	ramdisk. The F<\boot.wim> file is then extracted into it. As you can also
695	see, this F<.sdi> file resides on a different C<partition>.	787	see, this F<.sdi> file resides on a different C<partition>.
696		788
697	Continuitn, as always, form the inside out, first this device descriptor	789	Continuing, as always, from the inside out, first this device descriptor
698	finds a specific partition:	790	finds a specific partition:
699		791
700	partition=<null>,harddisk,mbr,47cbc08a,242643632128	792	partition=<null>,harddisk,mbr,47cbc08a,242643632128
701		793
702	And then specifies a C<ramdisk> image on this partition:	794	And then specifies a C<ramdisk> image on this partition:
…		…
707	seems to be always there on this kind of entry.	799	seems to be always there on this kind of entry.
708		800
709	If you have some good examples to add here, feel free to mail me.	801	If you have some good examples to add here, feel free to mail me.
710		802
711		803
712	=head1 EDITING BCD DATA STORES	804	=head1 EDITING BCD STORES
713		805
714	The C<edit> and C<parse> subcommands allow you to read a BCD data store	806	The C<edit> and C<parse> subcommands allow you to read a BCD data store
715	and modify it or extract data from it. This is done by exyecuting a series	807	and modify it or extract data from it. This is done by executing a series
716	of "editing instructions" which are explained here.	808	of "editing instructions" which are explained here.
717		809
718	=over	810	=over
719		811
720	=item get I<object> I<element>	812	=item C<get> I<object> I<element>
721		813
722	Reads the BCD element I<element> from the BCD object I<object> and writes	814	Reads the BCD element I<element> from the BCD object I<object> and writes
723	it to standard output, followed by a newline. The I<object> can be a GUID	815	it to standard output, followed by a newline. The I<object> can be a GUID
724	or a human-readable alias, or the special string C<{default}>, which will	816	or a human-readable alias, or the special string C<{default}>, which will
725	refer to the default BCD object.	817	refer to the default BCD object.
726		818
727	Example: find description of the default BCD object.	819	Example: find description of the default BCD object.
728		820
729	pbcdedit parse BCD get "{default}" description	821	pbcdedit parse BCD get "{default}" description
730		822
731	=item set I<object> I<element> I<value>	823	=item C<set> I<object> I<element> I<value>
732		824
733	Similar to C<get>, but sets the element to the given I<value> instead.	825	Similar to C<get>, but sets the element to the given I<value> instead.
734		826
735	Example: change bootmgr default too	827	Example: change the bootmgr default too
736	C<{b097d2ad-bc00-11e9-8a9a-525400123456}>:	828	C<{b097d2ad-bc00-11e9-8a9a-525400123456}>:
737		829
738	pbcdedit edit BCD set "{bootmgr}" resumeobject "{b097d2ad-bc00-11e9-8a9a-525400123456}"	830	pbcdedit edit BCD set "{bootmgr}" default "{b097d2ad-bc00-11e9-8a9a-525400123456}"
739		831
		832	=item C<del> I<object> I<element>
		833
		834	Similar to C<get>, but removed the BCD element from the specified BCD object.
		835
740	=item eval I<perlcode>	836	=item C<eval> I<perlcode>
741		837
742	This takes the next argument, interprets it as Perl code and	838	This takes the next argument, interprets it as Perl code and
743	evaluates it. This allows you to do more complicated modifications or	839	evaluates it. This allows you to do more complicated modifications or
744	extractions.	840	extractions.
745		841
…		…
764	The example given for C<get>, above, could be expressed like this with	860	The example given for C<get>, above, could be expressed like this with
765	C<eval>:	861	C<eval>:
766		862
767	pbcdedit edit BCD eval 'say $BCD->{$DEFAULT}{description}'	863	pbcdedit edit BCD eval 'say $BCD->{$DEFAULT}{description}'
768		864
769	The example given for C<set> could be expresed like this:	865	The example given for C<set> could be expressed like this:
770		866
771	pbcdedit edit BCD eval '$BCD->{$DEFAULT}{resumeobject} = "{b097d2ad-bc00-11e9-8a9a-525400123456}"'	867	pbcdedit edit BCD eval '$BCD->{"{bootmgr}"{default} = "{b097d2ad-bc00-11e9-8a9a-525400123456}"'
772		868
773	=item do I<path>	869	=item C<do> I<path>
774		870
775	Similar to C<eval>, above, but instead of using the argument as perl code,	871	Similar to C<eval>, above, but instead of using the argument as perl code,
776	it loads the perl code from the given file and executes it. This makes it	872	it loads the perl code from the given file and executes it. This makes it
777	easier to write more complicated or larger programs.	873	easier to write more complicated or larger programs.
778		874
779	=back	875	=back
780		876
		877
781	=head1 SEE ALSO	878	=head1 SEE ALSO
782		879
783	For ideas on what you can do, and some introductory material, try	880	For ideas on what you can do with BCD stores in
		881	general, and some introductory material, try
784	L<http://www.mistyprojects.co.uk/documents/BCDEdit/index.html>.	882	L<http://www.mistyprojects.co.uk/documents/BCDEdit/index.html>.
785		883
786	For good reference on BCD objects and elements, see Geoff Chappels pages	884	For good reference on which BCD objects and
		885	elements exist, see Geoff Chappell's pages at
787	at L<http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm>.	886	L<http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm>.
788		887
789	=head1 AUTHOR	888	=head1 AUTHOR
790		889
791	Written by Marc A. Lehmann <pbcdedit@schmorp.de>.	890	Written by Marc A. Lehmann L<pbcdedit@schmorp.de>.
792		891
793	=head1 REPORTING BUGS	892	=head1 REPORTING BUGS
794		893
795	Bugs can be reported dorectly tt he author at L<pcbedit@schmorp.de>.	894	Bugs can be reported directly the author at L<pcbedit@schmorp.de>.
796		895
797	=head1 BUGS AND SHORTCOMINGS	896	=head1 BUGS AND SHORTCOMINGS
798		897
799	This should be a module. Of a series of modules, even.	898	This should be a module. Of a series of modules, even.
800		899
801	Registry code should preserve classname and security descriptor data, and	900	Registry code should preserve classname and security descriptor data, and
802	whatever else is necessary to read and write any registry hive file.	901	whatever else is necessary to read and write any registry hive file.
803		902
804	I am also not happy with device descriptors being strings rather than a	903	I am also not happy with device descriptors being strings rather than a
805	data structure, but strings are probably better for command line usage. In	904	data structure, but strings are probably better for command line usage. In
806	any case,. device descriptors could be converted by simply "splitting" at	905	any case, device descriptors could be converted by simply "splitting" at
807	"=" and "," into an array reference, recursively.	906	"=" and "," into an array reference, recursively.
808		907
809	=head1 HOMEPAGE	908	=head1 HOMEPAGE
810		909
811	Original versions of this program can be found at	910	Original versions of this program can be found at
…		…
818	free to change and redistribute it. There is NO WARRANTY, to the extent	917	free to change and redistribute it. There is NO WARRANTY, to the extent
819	permitted by law.	918	permitted by law.
820		919
821	=cut	920	=cut
822		921
823	BEGIN { require "common/sense.pm"; common::sense->import } # common sense is optional, but recommended	922	# common sense is optional, but recommended
		923	BEGIN { eval { require "common/sense.pm"; } && common::sense->import }
824		924
825	use Data::Dump;	925	no warnings 'portable'; # avoid 32 bit integer warnings
		926
826	use Encode ();	927	use Encode ();
827	use List::Util ();	928	use List::Util ();
828	use IO::Handle ();	929	use IO::Handle ();
829	use Time::HiRes ();	930	use Time::HiRes ();
830		931
…		…
839		940
840	# hack used for debugging	941	# hack used for debugging
841	sub xxd($$) {	942	sub xxd($$) {
842	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";	943	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";
843	syswrite $xxd, $_[1];	944	syswrite $xxd, $_[1];
		945	}
		946
		947	# get some meta info on a file (uid, gid, perms)
		948	sub stat_get($) {
		949	[(stat shift)[4, 5, 2]]
		950	}
		951
		952	# set stat info on a file
		953	sub stat_set($$) {
		954	my ($fh_or_path, $stat) = @_;
		955
		956	return unless $stat;
		957	chown $stat->[0], $stat->[1], $fh_or_path;
		958	chmod +($stat->[2] & 07777), $fh_or_path;
844	}	959	}
845		960
846	sub file_load($) {	961	sub file_load($) {
847	my ($path) = @_;	962	my ($path) = @_;
848		963
…		…
853	or die "$path: short read\n";	968	or die "$path: short read\n";
854		969
855	$buf	970	$buf
856	}	971	}
857		972
		973	sub file_save($$;$) {
		974	my ($path, $data, $stat) = @_;
		975
		976	open my $fh, ">:raw", "$path~"
		977	or die "$path~: $!\n";
		978	print $fh $data
		979	or die "$path~: short write\n";
		980	stat_set $fh, $stat;
		981	$fh->sync;
		982	close $fh;
		983
		984	rename "$path~", $path;
		985	}
		986
858	# sources and resources used for this:	987	# sources and resources used for writing pbcdedit
		988	#
859	# registry:	989	# registry:
860	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md	990	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md
861	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/	991	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/
862	# bcd:	992	# bcd:
863	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm	993	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm
…		…
1045	my ($rname, $root) = $decode_key->($rootcell);	1175	my ($rname, $root) = $decode_key->($rootcell);
1046		1176
1047	[$rname, $root]	1177	[$rname, $root]
1048	}	1178	}
1049		1179
1050	# return a binary windows fILETIME struct	1180	# return a binary windows FILETIME struct
1051	sub filetime_now {	1181	sub filetime_now {
1052	my ($s, $ms) = Time::HiRes::gettimeofday;	1182	my ($s, $ms) = Time::HiRes::gettimeofday;
1053		1183
1054	pack "Q<", $s = ($s * 1_000_000 + $ms) * 10 + 116_444_736_000_000_000	1184	pack "Q<", ($s * 1_000_000 + $ms) * 10
		1185	+ 116_444_736_000_000_000 # 1970-01-01 00:00:00
1055	}	1186	}
1056		1187
1057	# encode a registry hive	1188	# encode a registry hive
1058	sub regf_encode($) {	1189	sub regf_encode($) {
1059	my ($hive) = @_;	1190	my ($hive) = @_;
…		…
1062		1193
1063	# the filetime is apparently used to verify log file validity,	1194	# the filetime is apparently used to verify log file validity,
1064	# so by generating a new timestamp the log files *should* automatically	1195	# so by generating a new timestamp the log files *should* automatically
1065	# become invalidated and windows would "self-heal" them.	1196	# become invalidated and windows would "self-heal" them.
1066	# (update: has been verified by reverse engineering)	1197	# (update: has been verified by reverse engineering)
1067	# possibly the fact that the two sequence numbes match might also	1198	# possibly the fact that the two sequence numbers match might also
1068	# make windows think that the hive is not dirty and ignore logs.	1199	# make windows think that the hive is not dirty and ignore logs.
1069	# (update: has been verified by reverse engineering)	1200	# (update: has been verified by reverse engineering)
1070		1201
1071	my $now = filetime_now;	1202	my $now = filetime_now;
1072		1203
…		…
1216		1347
1217	regf_decode file_load $path	1348	regf_decode file_load $path
1218	}	1349	}
1219		1350
1220	# encode and save registry to file	1351	# encode and save registry to file
1221	sub regf_save {	1352	sub regf_save($$;$) {
1222	my ($path, $hive) = @_;	1353	my ($path, $hive, $stat) = @_;
1223		1354
1224	$hive = regf_encode $hive;	1355	$hive = regf_encode $hive;
1225		1356
1226	open my $regf, ">:raw", "$path~"	1357	file_save $path, $hive, $stat;
1227	or die "$path~: $!\n";
1228	print $regf $hive
1229	or die "$path~: short write\n";
1230	$regf->sync;
1231	close $regf;
1232
1233	rename "$path~", $path;
1234	}	1358	}
1235		1359
1236	#############################################################################	1360	#############################################################################
1237	# bcd stuff	1361	# bcd stuff
1238		1362
1239	# human-readable alises for GUID object identifiers	1363	# human-readable aliases for GUID object identifiers
1240	our %bcd_objects = (	1364	our %bcd_objects = (
1241	'{0ce4991b-e6b3-4b16-b23c-5e0d9250e5d9}' => '{emssettings}',	1365	'{0ce4991b-e6b3-4b16-b23c-5e0d9250e5d9}' => '{emssettings}',
1242	'{1afa9c49-16ab-4a5c-4a90-212802da9460}' => '{resumeloadersettings}',	1366	'{1afa9c49-16ab-4a5c-4a90-212802da9460}' => '{resumeloadersettings}',
1243	'{1cae1eb7-a0df-4d4d-9851-4860e34ef535}' => '{default}',	1367	'{1cae1eb7-a0df-4d4d-9851-4860e34ef535}' => '{default}',
1244	'{313e8eed-7098-4586-a9bf-309c61f8d449}' => '{kerneldbgsettings}',	1368	'{313e8eed-7098-4586-a9bf-309c61f8d449}' => '{kerneldbgsettings}',
…		…
1351	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }	1475	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }
1352	sub BCDE_FORMAT_INTEGER () { 0x05000000 }	1476	sub BCDE_FORMAT_INTEGER () { 0x05000000 }
1353	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }	1477	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }
1354	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }	1478	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }
1355		1479
1356	sub dec_device;
1357	sub enc_device;
1358
1359	sub enc_integer($) {	1480	sub enc_integer($) {
1360	no warnings 'portable'; # ugh
1361	my $value = shift;	1481	my $value = shift;
1362	$value = oct $value if $value =~ /^0[bBxX]/;	1482	$value = oct $value if $value =~ /^0[bBxX]/;
1363	unpack "H*", pack "Q<", $value	1483	unpack "H*", pack "Q<", $value
1364	}	1484	}
		1485
		1486	sub enc_device($$);
		1487	sub dec_device($$);
1365		1488
1366	our %bcde_dec = (	1489	our %bcde_dec = (
1367	BCDE_FORMAT_DEVICE , \&dec_device,	1490	BCDE_FORMAT_DEVICE , \&dec_device,
1368	# # for round-trip verification	1491	# # for round-trip verification
1369	# BCDE_FORMAT_DEVICE , sub {	1492	# BCDE_FORMAT_DEVICE , sub {
…		…
1375	BCDE_FORMAT_STRING , sub { shift },	1498	BCDE_FORMAT_STRING , sub { shift },
1376	BCDE_FORMAT_GUID , sub { dec_wguid enc_wguid shift },	1499	BCDE_FORMAT_GUID , sub { dec_wguid enc_wguid shift },
1377	BCDE_FORMAT_GUID_LIST , sub { join " ", map dec_wguid enc_wguid $_, @{+shift} },	1500	BCDE_FORMAT_GUID_LIST , sub { join " ", map dec_wguid enc_wguid $_, @{+shift} },
1378	BCDE_FORMAT_INTEGER , sub { unpack "Q", pack "a8", pack "H*", shift }, # integer might be 4 or 8 bytes - caused by ms coding bugs	1501	BCDE_FORMAT_INTEGER , sub { unpack "Q", pack "a8", pack "H*", shift }, # integer might be 4 or 8 bytes - caused by ms coding bugs
1379	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },	1502	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },
1380	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this cna be 4 bytes	1503	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this can be 4 bytes
1381	);	1504	);
1382		1505
1383	our %bcde_enc = (	1506	our %bcde_enc = (
1384	BCDE_FORMAT_DEVICE , sub { binary => enc_device shift },	1507	BCDE_FORMAT_DEVICE , sub { binary => enc_device $_[0], $_[1] },
1385	BCDE_FORMAT_STRING , sub { sz => shift },	1508	BCDE_FORMAT_STRING , sub { sz => shift },
1386	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },	1509	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },
1387	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },	1510	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },
1388	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },	1511	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },
1389	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },	1512	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },
1390	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },	1513	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },
1391	);	1514	);
1392		1515
1393	# BCD Elements	1516	# BCD Elements
1394	our %bcde = (	1517	our %bcde_byclass = (
		1518	any => {
1395	0x11000001 => 'device',	1519	0x11000001 => 'device',
1396	0x12000002 => 'path',	1520	0x12000002 => 'path',
1397	0x12000004 => 'description',	1521	0x12000004 => 'description',
1398	0x12000005 => 'locale',	1522	0x12000005 => 'locale',
1399	0x14000006 => 'inherit',	1523	0x14000006 => 'inherit',
1400	0x15000007 => 'truncatememory',	1524	0x15000007 => 'truncatememory',
1401	0x14000008 => 'recoverysequence',	1525	0x14000008 => 'recoverysequence',
1402	0x16000009 => 'recoveryenabled',	1526	0x16000009 => 'recoveryenabled',
1403	0x1700000a => 'badmemorylist',	1527	0x1700000a => 'badmemorylist',
1404	0x1600000b => 'badmemoryaccess',	1528	0x1600000b => 'badmemoryaccess',
1405	0x1500000c => 'firstmegabytepolicy',	1529	0x1500000c => 'firstmegabytepolicy',
1406	0x1500000d => 'relocatephysical',	1530	0x1500000d => 'relocatephysical',
1407	0x1500000e => 'avoidlowmemory',	1531	0x1500000e => 'avoidlowmemory',
1408	0x1600000f => 'traditionalkseg',	1532	0x1600000f => 'traditionalkseg',
1409	0x16000010 => 'bootdebug',	1533	0x16000010 => 'bootdebug',
1410	0x15000011 => 'debugtype',	1534	0x15000011 => 'debugtype',
1411	0x15000012 => 'debugaddress',	1535	0x15000012 => 'debugaddress',
1412	0x15000013 => 'debugport',	1536	0x15000013 => 'debugport',
1413	0x15000014 => 'baudrate',	1537	0x15000014 => 'baudrate',
1414	0x15000015 => 'channel',	1538	0x15000015 => 'channel',
1415	0x12000016 => 'targetname',	1539	0x12000016 => 'targetname',
1416	0x16000017 => 'noumex',	1540	0x16000017 => 'noumex',
1417	0x15000018 => 'debugstart',	1541	0x15000018 => 'debugstart',
1418	0x12000019 => 'busparams',	1542	0x12000019 => 'busparams',
1419	0x1500001a => 'hostip',	1543	0x1500001a => 'hostip',
1420	0x1500001b => 'port',	1544	0x1500001b => 'port',
1421	0x1600001c => 'dhcp',	1545	0x1600001c => 'dhcp',
1422	0x1200001d => 'key',	1546	0x1200001d => 'key',
1423	0x1600001e => 'vm',	1547	0x1600001e => 'vm',
1424	0x16000020 => 'bootems',	1548	0x16000020 => 'bootems',
1425	0x15000022 => 'emsport',	1549	0x15000022 => 'emsport',
1426	0x15000023 => 'emsbaudrate',	1550	0x15000023 => 'emsbaudrate',
1427	0x12000030 => 'loadoptions',	1551	0x12000030 => 'loadoptions',
1428	0x16000040 => 'advancedoptions',	1552	0x16000040 => 'advancedoptions',
1429	0x16000041 => 'optionsedit',	1553	0x16000041 => 'optionsedit',
1430	0x15000042 => 'keyringaddress',	1554	0x15000042 => 'keyringaddress',
1431	0x11000043 => 'bootstatdevice',	1555	0x11000043 => 'bootstatdevice',
1432	0x12000044 => 'bootstatfilepath',	1556	0x12000044 => 'bootstatfilepath',
1433	0x16000045 => 'preservebootstat',	1557	0x16000045 => 'preservebootstat',
1434	0x16000046 => 'graphicsmodedisabled',	1558	0x16000046 => 'graphicsmodedisabled',
1435	0x15000047 => 'configaccesspolicy',	1559	0x15000047 => 'configaccesspolicy',
1436	0x16000048 => 'nointegritychecks',	1560	0x16000048 => 'nointegritychecks',
1437	0x16000049 => 'testsigning',	1561	0x16000049 => 'testsigning',
1438	0x1200004a => 'fontpath',	1562	0x1200004a => 'fontpath',
1439	0x1500004b => 'integrityservices',	1563	0x1500004b => 'integrityservices',
1440	0x1500004c => 'volumebandid',	1564	0x1500004c => 'volumebandid',
1441	0x16000050 => 'extendedinput',	1565	0x16000050 => 'extendedinput',
1442	0x15000051 => 'initialconsoleinput',	1566	0x15000051 => 'initialconsoleinput',
1443	0x15000052 => 'graphicsresolution',	1567	0x15000052 => 'graphicsresolution',
1444	0x16000053 => 'restartonfailure',	1568	0x16000053 => 'restartonfailure',
1445	0x16000054 => 'highestmode',	1569	0x16000054 => 'highestmode',
1446	0x16000060 => 'isolatedcontext',	1570	0x16000060 => 'isolatedcontext',
1447	0x15000065 => 'displaymessage',	1571	0x15000065 => 'displaymessage',
1448	0x15000066 => 'displaymessageoverride',	1572	0x15000066 => 'displaymessageoverride',
1449	0x16000068 => 'nobootuxtext',	1573	0x16000068 => 'nobootuxtext',
1450	0x16000069 => 'nobootuxprogress',	1574	0x16000069 => 'nobootuxprogress',
1451	0x1600006a => 'nobootuxfade',	1575	0x1600006a => 'nobootuxfade',
1452	0x1600006b => 'bootuxreservepooldebug',	1576	0x1600006b => 'bootuxreservepooldebug',
1453	0x1600006c => 'bootuxdisabled',	1577	0x1600006c => 'bootuxdisabled',
1454	0x1500006d => 'bootuxfadeframes',	1578	0x1500006d => 'bootuxfadeframes',
1455	0x1600006e => 'bootuxdumpstats',	1579	0x1600006e => 'bootuxdumpstats',
1456	0x1600006f => 'bootuxshowstats',	1580	0x1600006f => 'bootuxshowstats',
1457	0x16000071 => 'multibootsystem',	1581	0x16000071 => 'multibootsystem',
1458	0x16000072 => 'nokeyboard',	1582	0x16000072 => 'nokeyboard',
1459	0x15000073 => 'aliaswindowskey',	1583	0x15000073 => 'aliaswindowskey',
1460	0x16000074 => 'bootshutdowndisabled',	1584	0x16000074 => 'bootshutdowndisabled',
1461	0x15000075 => 'performancefrequency',	1585	0x15000075 => 'performancefrequency',
1462	0x15000076 => 'securebootrawpolicy',	1586	0x15000076 => 'securebootrawpolicy',
1463	0x17000077 => 'allowedinmemorysettings',	1587	0x17000077 => 'allowedinmemorysettings',
1464	0x15000079 => 'bootuxtransitiontime',	1588	0x15000079 => 'bootuxtransitiontime',
1465	0x1600007a => 'mobilegraphics',	1589	0x1600007a => 'mobilegraphics',
1466	0x1600007b => 'forcefipscrypto',	1590	0x1600007b => 'forcefipscrypto',
1467	0x1500007d => 'booterrorux',	1591	0x1500007d => 'booterrorux',
1468	0x1600007e => 'flightsigning',	1592	0x1600007e => 'flightsigning',
1469	0x1500007f => 'measuredbootlogformat',	1593	0x1500007f => 'measuredbootlogformat',
1470	0x15000080 => 'displayrotation',	1594	0x15000080 => 'displayrotation',
1471	0x15000081 => 'logcontrol',	1595	0x15000081 => 'logcontrol',
1472	0x16000082 => 'nofirmwaresync',	1596	0x16000082 => 'nofirmwaresync',
1473	0x11000084 => 'windowssyspart',	1597	0x11000084 => 'windowssyspart',
1474	0x16000087 => 'numlock',	1598	0x16000087 => 'numlock',
1475	0x22000001 => 'bpbstring',	1599	0x26000202 => 'skipffumode',
		1600	0x26000203 => 'forceffumode',
		1601	0x25000510 => 'chargethreshold',
		1602	0x26000512 => 'offmodecharging',
		1603	0x25000aaa => 'bootflow',
		1604	0x45000001 => 'devicetype',
		1605	0x42000002 => 'applicationrelativepath',
		1606	0x42000003 => 'ramdiskdevicerelativepath',
		1607	0x46000004 => 'omitosloaderelements',
		1608	0x47000006 => 'elementstomigrate',
		1609	0x46000010 => 'recoveryos',
		1610	},
		1611	bootapp => {
		1612	0x26000145 => 'enablebootdebugpolicy',
		1613	0x26000146 => 'enablebootorderclean',
		1614	0x26000147 => 'enabledeviceid',
		1615	0x26000148 => 'enableffuloader',
		1616	0x26000149 => 'enableiuloader',
		1617	0x2600014a => 'enablemassstorage',
		1618	0x2600014b => 'enablerpmbprovisioning',
		1619	0x2600014c => 'enablesecurebootpolicy',
		1620	0x2600014d => 'enablestartcharge',
		1621	0x2600014e => 'enableresettpm',
		1622	},
		1623	bootmgr => {
1476	0x24000001 => 'displayorder',	1624	0x24000001 => 'displayorder',
1477	0x21000001 => 'filedevice',
1478	0x21000001 => 'osdevice',
1479	0x25000001 => 'passcount',
1480	0x26000001 => 'pxesoftreboot',
1481	0x22000002 => 'applicationname',
1482	0x24000002 => 'bootsequence',	1625	0x24000002 => 'bootsequence',
1483	0x22000002 => 'filepath',
1484	0x22000002 => 'systemroot',
1485	0x25000002 => 'testmix',
1486	0x26000003 => 'cacheenable',
1487	0x26000003 => 'customsettings',
1488	0x23000003 => 'default',	1626	0x23000003 => 'default',
1489	0x25000003 => 'failurecount',
1490	0x23000003 => 'resumeobject',
1491	0x26000004 => 'failuresenabled',
1492	0x26000004 => 'pae',
1493	0x26000004 => 'stampdisks',
1494	0x25000004 => 'testtofail',
1495	0x25000004 => 'timeout',	1627	0x25000004 => 'timeout',
1496	0x21000005 => 'associatedosdevice',
1497	0x26000005 => 'cacheenable',
1498	0x26000005 => 'resume',	1628	0x26000005 => 'resume',
1499	0x25000005 => 'stridefailcount',
1500	0x26000006 => 'debugoptionenabled',
1501	0x25000006 => 'invcfailcount',
1502	0x23000006 => 'resumeobject',	1629	0x23000006 => 'resumeobject',
1503	0x25000007 => 'bootux',
1504	0x25000007 => 'matsfailcount',
1505	0x24000007 => 'startupsequence',	1630	0x24000007 => 'startupsequence',
1506	0x25000008 => 'bootmenupolicy',
1507	0x25000008 => 'randfailcount',
1508	0x25000009 => 'chckrfailcount',
1509	0x26000010 => 'detecthal',
1510	0x24000010 => 'toolsdisplayorder',	1631	0x24000010 => 'toolsdisplayorder',
1511	0x22000011 => 'kernel',
1512	0x22000012 => 'hal',
1513	0x22000013 => 'dbgtransport',
1514	0x26000020 => 'displaybootmenu',	1632	0x26000020 => 'displaybootmenu',
1515	0x25000020 => 'nx',
1516	0x26000021 => 'noerrordisplay',	1633	0x26000021 => 'noerrordisplay',
1517	0x25000021 => 'pae',
1518	0x21000022 => 'bcddevice',	1634	0x21000022 => 'bcddevice',
1519	0x26000022 => 'winpe',
1520	0x22000023 => 'bcdfilepath',	1635	0x22000023 => 'bcdfilepath',
1521	0x26000024 => 'hormenabled',	1636	0x26000024 => 'hormenabled',
1522	0x26000024 => 'hormenabled',
1523	0x26000024 => 'nocrashautoreboot',
1524	0x26000025 => 'hiberboot',	1637	0x26000025 => 'hiberboot',
1525	0x26000025 => 'lastknowngood',
1526	0x26000026 => 'oslnointegritychecks',
1527	0x22000026 => 'passwordoverride',	1638	0x22000026 => 'passwordoverride',
1528	0x26000027 => 'osltestsigning',
1529	0x22000027 => 'pinpassphraseoverride',	1639	0x22000027 => 'pinpassphraseoverride',
1530	0x26000028 => 'processcustomactionsfirst',	1640	0x26000028 => 'processcustomactionsfirst',
1531	0x27000030 => 'customactions',	1641	0x27000030 => 'customactions',
1532	0x26000030 => 'nolowmem',
1533	0x26000031 => 'persistbootsequence',	1642	0x26000031 => 'persistbootsequence',
1534	0x25000031 => 'removememory',
1535	0x25000032 => 'increaseuserva',
1536	0x26000032 => 'skipstartupsequence',	1643	0x26000032 => 'skipstartupsequence',
1537	0x25000033 => 'perfmem',
1538	0x22000040 => 'fverecoveryurl',	1644	0x22000040 => 'fverecoveryurl',
1539	0x26000040 => 'vga',
1540	0x22000041 => 'fverecoverymessage',	1645	0x22000041 => 'fverecoverymessage',
		1646	},
		1647	device => {
		1648	0x35000001 => 'ramdiskimageoffset',
		1649	0x35000002 => 'ramdisktftpclientport',
		1650	0x31000003 => 'ramdisksdidevice',
		1651	0x32000004 => 'ramdisksdipath',
		1652	0x35000005 => 'ramdiskimagelength',
		1653	0x36000006 => 'exportascd',
		1654	0x35000007 => 'ramdisktftpblocksize',
		1655	0x35000008 => 'ramdisktftpwindowsize',
		1656	0x36000009 => 'ramdiskmcenabled',
		1657	0x3600000a => 'ramdiskmctftpfallback',
		1658	0x3600000b => 'ramdisktftpvarwindow',
		1659	},
		1660	memdiag => {
		1661	0x25000001 => 'passcount',
		1662	0x25000002 => 'testmix',
		1663	0x25000003 => 'failurecount',
		1664	0x26000003 => 'cacheenable',
		1665	0x25000004 => 'testtofail',
		1666	0x26000004 => 'failuresenabled',
		1667	0x25000005 => 'stridefailcount',
		1668	0x26000005 => 'cacheenable',
		1669	0x25000006 => 'invcfailcount',
		1670	0x25000007 => 'matsfailcount',
		1671	0x25000008 => 'randfailcount',
		1672	0x25000009 => 'chckrfailcount',
		1673	},
		1674	ntldr => {
		1675	0x22000001 => 'bpbstring',
		1676	},
		1677	osloader => {
		1678	0x21000001 => 'osdevice',
		1679	0x22000002 => 'systemroot',
		1680	0x23000003 => 'resumeobject',
		1681	0x26000004 => 'stampdisks',
		1682	0x26000010 => 'detecthal',
		1683	0x22000011 => 'kernel',
		1684	0x22000012 => 'hal',
		1685	0x22000013 => 'dbgtransport',
		1686	0x25000020 => 'nx',
		1687	0x25000021 => 'pae',
		1688	0x26000022 => 'winpe',
		1689	0x26000024 => 'nocrashautoreboot',
		1690	0x26000025 => 'lastknowngood',
		1691	0x26000026 => 'oslnointegritychecks',
		1692	0x26000027 => 'osltestsigning',
		1693	0x26000030 => 'nolowmem',
		1694	0x25000031 => 'removememory',
		1695	0x25000032 => 'increaseuserva',
		1696	0x25000033 => 'perfmem',
		1697	0x26000040 => 'vga',
1541	0x26000041 => 'quietboot',	1698	0x26000041 => 'quietboot',
1542	0x26000042 => 'novesa',	1699	0x26000042 => 'novesa',
1543	0x26000043 => 'novga',	1700	0x26000043 => 'novga',
1544	0x25000050 => 'clustermodeaddressing',	1701	0x25000050 => 'clustermodeaddressing',
1545	0x26000051 => 'usephysicaldestination',	1702	0x26000051 => 'usephysicaldestination',
1546	0x25000052 => 'restrictapiccluster',	1703	0x25000052 => 'restrictapiccluster',
1547	0x22000053 => 'evstore',	1704	0x22000053 => 'evstore',
1548	0x26000054 => 'uselegacyapicmode',	1705	0x26000054 => 'uselegacyapicmode',
1549	0x26000060 => 'onecpu',	1706	0x26000060 => 'onecpu',
1550	0x25000061 => 'numproc',	1707	0x25000061 => 'numproc',
1551	0x26000062 => 'maxproc',	1708	0x26000062 => 'maxproc',
1552	0x25000063 => 'configflags',	1709	0x25000063 => 'configflags',
1553	0x26000064 => 'maxgroup',	1710	0x26000064 => 'maxgroup',
1554	0x26000065 => 'groupaware',	1711	0x26000065 => 'groupaware',
1555	0x25000066 => 'groupsize',	1712	0x25000066 => 'groupsize',
1556	0x26000070 => 'usefirmwarepcisettings',	1713	0x26000070 => 'usefirmwarepcisettings',
1557	0x25000071 => 'msi',	1714	0x25000071 => 'msi',
1558	0x25000072 => 'pciexpress',	1715	0x25000072 => 'pciexpress',
1559	0x25000080 => 'safeboot',	1716	0x25000080 => 'safeboot',
1560	0x26000081 => 'safebootalternateshell',	1717	0x26000081 => 'safebootalternateshell',
1561	0x26000090 => 'bootlog',	1718	0x26000090 => 'bootlog',
1562	0x26000091 => 'sos',	1719	0x26000091 => 'sos',
1563	0x260000a0 => 'debug',	1720	0x260000a0 => 'debug',
1564	0x260000a1 => 'halbreakpoint',	1721	0x260000a1 => 'halbreakpoint',
1565	0x260000a2 => 'useplatformclock',	1722	0x260000a2 => 'useplatformclock',
1566	0x260000a3 => 'forcelegacyplatform',	1723	0x260000a3 => 'forcelegacyplatform',
1567	0x260000a4 => 'useplatformtick',	1724	0x260000a4 => 'useplatformtick',
1568	0x260000a5 => 'disabledynamictick',	1725	0x260000a5 => 'disabledynamictick',
1569	0x250000a6 => 'tscsyncpolicy',	1726	0x250000a6 => 'tscsyncpolicy',
1570	0x260000b0 => 'ems',	1727	0x260000b0 => 'ems',
1571	0x250000c0 => 'forcefailure',	1728	0x250000c0 => 'forcefailure',
1572	0x250000c1 => 'driverloadfailurepolicy',	1729	0x250000c1 => 'driverloadfailurepolicy',
1573	0x250000c2 => 'bootmenupolicy',	1730	0x250000c2 => 'bootmenupolicy',
1574	0x260000c3 => 'onetimeadvancedoptions',	1731	0x260000c3 => 'onetimeadvancedoptions',
1575	0x260000c4 => 'onetimeoptionsedit',	1732	0x260000c4 => 'onetimeoptionsedit',
1576	0x250000e0 => 'bootstatuspolicy',	1733	0x250000e0 => 'bootstatuspolicy',
1577	0x260000e1 => 'disableelamdrivers',	1734	0x260000e1 => 'disableelamdrivers',
1578	0x250000f0 => 'hypervisorlaunchtype',	1735	0x250000f0 => 'hypervisorlaunchtype',
1579	0x220000f1 => 'hypervisorpath',	1736	0x220000f1 => 'hypervisorpath',
1580	0x260000f2 => 'hypervisordebug',	1737	0x260000f2 => 'hypervisordebug',
1581	0x250000f3 => 'hypervisordebugtype',	1738	0x250000f3 => 'hypervisordebugtype',
1582	0x250000f4 => 'hypervisordebugport',	1739	0x250000f4 => 'hypervisordebugport',
1583	0x250000f5 => 'hypervisorbaudrate',	1740	0x250000f5 => 'hypervisorbaudrate',
1584	0x250000f6 => 'hypervisorchannel',	1741	0x250000f6 => 'hypervisorchannel',
1585	0x250000f7 => 'bootux',	1742	0x250000f7 => 'bootux',
1586	0x260000f8 => 'hypervisordisableslat',	1743	0x260000f8 => 'hypervisordisableslat',
1587	0x220000f9 => 'hypervisorbusparams',	1744	0x220000f9 => 'hypervisorbusparams',
1588	0x250000fa => 'hypervisornumproc',	1745	0x250000fa => 'hypervisornumproc',
1589	0x250000fb => 'hypervisorrootprocpernode',	1746	0x250000fb => 'hypervisorrootprocpernode',
1590	0x260000fc => 'hypervisoruselargevtlb',	1747	0x260000fc => 'hypervisoruselargevtlb',
1591	0x250000fd => 'hypervisorhostip',	1748	0x250000fd => 'hypervisorhostip',
1592	0x250000fe => 'hypervisorhostport',	1749	0x250000fe => 'hypervisorhostport',
1593	0x250000ff => 'hypervisordebugpages',	1750	0x250000ff => 'hypervisordebugpages',
1594	0x25000100 => 'tpmbootentropy',	1751	0x25000100 => 'tpmbootentropy',
1595	0x22000110 => 'hypervisorusekey',	1752	0x22000110 => 'hypervisorusekey',
1596	0x22000112 => 'hypervisorproductskutype',	1753	0x22000112 => 'hypervisorproductskutype',
1597	0x25000113 => 'hypervisorrootproc',	1754	0x25000113 => 'hypervisorrootproc',
1598	0x26000114 => 'hypervisordhcp',	1755	0x26000114 => 'hypervisordhcp',
1599	0x25000115 => 'hypervisoriommupolicy',	1756	0x25000115 => 'hypervisoriommupolicy',
1600	0x26000116 => 'hypervisorusevapic',	1757	0x26000116 => 'hypervisorusevapic',
1601	0x22000117 => 'hypervisorloadoptions',	1758	0x22000117 => 'hypervisorloadoptions',
1602	0x25000118 => 'hypervisormsrfilterpolicy',	1759	0x25000118 => 'hypervisormsrfilterpolicy',
1603	0x25000119 => 'hypervisormmionxpolicy',	1760	0x25000119 => 'hypervisormmionxpolicy',
1604	0x2500011a => 'hypervisorschedulertype',	1761	0x2500011a => 'hypervisorschedulertype',
1605	0x25000120 => 'xsavepolicy',	1762	0x25000120 => 'xsavepolicy',
1606	0x25000121 => 'xsaveaddfeature0',	1763	0x25000121 => 'xsaveaddfeature0',
1607	0x25000122 => 'xsaveaddfeature1',	1764	0x25000122 => 'xsaveaddfeature1',
1608	0x25000123 => 'xsaveaddfeature2',	1765	0x25000123 => 'xsaveaddfeature2',
1609	0x25000124 => 'xsaveaddfeature3',	1766	0x25000124 => 'xsaveaddfeature3',
1610	0x25000125 => 'xsaveaddfeature4',	1767	0x25000125 => 'xsaveaddfeature4',
1611	0x25000126 => 'xsaveaddfeature5',	1768	0x25000126 => 'xsaveaddfeature5',
1612	0x25000127 => 'xsaveaddfeature6',	1769	0x25000127 => 'xsaveaddfeature6',
1613	0x25000128 => 'xsaveaddfeature7',	1770	0x25000128 => 'xsaveaddfeature7',
1614	0x25000129 => 'xsaveremovefeature',	1771	0x25000129 => 'xsaveremovefeature',
1615	0x2500012a => 'xsaveprocessorsmask',	1772	0x2500012a => 'xsaveprocessorsmask',
1616	0x2500012b => 'xsavedisable',	1773	0x2500012b => 'xsavedisable',
1617	0x2500012c => 'kerneldebugtype',	1774	0x2500012c => 'kerneldebugtype',
1618	0x2200012d => 'kernelbusparams',	1775	0x2200012d => 'kernelbusparams',
1619	0x2500012e => 'kerneldebugaddress',	1776	0x2500012e => 'kerneldebugaddress',
1620	0x2500012f => 'kerneldebugport',	1777	0x2500012f => 'kerneldebugport',
1621	0x25000130 => 'claimedtpmcounter',	1778	0x25000130 => 'claimedtpmcounter',
1622	0x25000131 => 'kernelchannel',	1779	0x25000131 => 'kernelchannel',
1623	0x22000132 => 'kerneltargetname',	1780	0x22000132 => 'kerneltargetname',
1624	0x25000133 => 'kernelhostip',	1781	0x25000133 => 'kernelhostip',
1625	0x25000134 => 'kernelport',	1782	0x25000134 => 'kernelport',
1626	0x26000135 => 'kerneldhcp',	1783	0x26000135 => 'kerneldhcp',
1627	0x22000136 => 'kernelkey',	1784	0x22000136 => 'kernelkey',
1628	0x22000137 => 'imchivename',	1785	0x22000137 => 'imchivename',
1629	0x21000138 => 'imcdevice',	1786	0x21000138 => 'imcdevice',
1630	0x25000139 => 'kernelbaudrate',	1787	0x25000139 => 'kernelbaudrate',
1631	0x22000140 => 'mfgmode',	1788	0x22000140 => 'mfgmode',
1632	0x26000141 => 'event',	1789	0x26000141 => 'event',
1633	0x25000142 => 'vsmlaunchtype',	1790	0x25000142 => 'vsmlaunchtype',
1634	0x25000144 => 'hypervisorenforcedcodeintegrity',	1791	0x25000144 => 'hypervisorenforcedcodeintegrity',
1635	0x26000145 => 'enablebootdebugpolicy',
1636	0x26000146 => 'enablebootorderclean',
1637	0x26000147 => 'enabledeviceid',
1638	0x26000148 => 'enableffuloader',
1639	0x26000149 => 'enableiuloader',
1640	0x2600014a => 'enablemassstorage',
1641	0x2600014b => 'enablerpmbprovisioning',
1642	0x2600014c => 'enablesecurebootpolicy',
1643	0x2600014d => 'enablestartcharge',
1644	0x2600014e => 'enableresettpm',
1645	0x21000150 => 'systemdatadevice',	1792	0x21000150 => 'systemdatadevice',
1646	0x21000151 => 'osarcdevice',	1793	0x21000151 => 'osarcdevice',
1647	0x21000153 => 'osdatadevice',	1794	0x21000153 => 'osdatadevice',
1648	0x21000154 => 'bspdevice',	1795	0x21000154 => 'bspdevice',
1649	0x21000155 => 'bspfilepath',	1796	0x21000155 => 'bspfilepath',
1650	0x26000202 => 'skipffumode',	1797	},
1651	0x26000203 => 'forceffumode',	1798	resume => {
1652	0x25000510 => 'chargethreshold',
1653	0x26000512 => 'offmodecharging',
1654	0x25000aaa => 'bootflow',
1655	0x35000001 => 'ramdiskimageoffset',
1656	0x35000002 => 'ramdisktftpclientport',
1657	0x31000003 => 'ramdisksdidevice',
1658	0x32000004 => 'ramdisksdipath',
1659	0x35000005 => 'ramdiskimagelength',
1660	0x36000006 => 'exportascd',
1661	0x35000007 => 'ramdisktftpblocksize',
1662	0x35000008 => 'ramdisktftpwindowsize',
1663	0x36000009 => 'ramdiskmcenabled',
1664	0x3600000a => 'ramdiskmctftpfallback',
1665	0x3600000b => 'ramdisktftpvarwindow',
1666	0x45000001 => 'devicetype',	1799	0x21000001 => 'filedevice',
		1800	0x22000002 => 'filepath',
		1801	0x26000003 => 'customsettings',
		1802	0x26000004 => 'pae',
		1803	0x21000005 => 'associatedosdevice',
		1804	0x26000006 => 'debugoptionenabled',
		1805	0x25000007 => 'bootux',
		1806	0x25000008 => 'bootmenupolicy',
		1807	0x26000024 => 'hormenabled',
		1808	},
		1809	startup => {
		1810	0x26000001 => 'pxesoftreboot',
1667	0x42000002 => 'applicationrelativepath',	1811	0x22000002 => 'applicationname',
1668	0x42000003 => 'ramdiskdevicerelativepath',	1812	},
1669	0x46000004 => 'omitosloaderelements',
1670	0x47000006 => 'elementstomigrate',
1671	0x46000010 => 'recoveryos',
1672	);	1813	);
1673		1814
1674	our %rbcde = reverse %bcde;	1815	# mask, value => class
		1816	our @bcde_typeclass = (
		1817	[0x00000000, 0x00000000, 'any'],
		1818	[0xf00fffff, 0x1000000a, 'bootapp'],
		1819	[0xf0ffffff, 0x2020000a, 'bootapp'],
		1820	[0xf00fffff, 0x10000001, 'bootmgr'],
		1821	[0xf00fffff, 0x10000002, 'bootmgr'],
		1822	[0xf0ffffff, 0x20200001, 'bootmgr'],
		1823	[0xf0ffffff, 0x20200002, 'bootmgr'],
		1824	[0xf0f00000, 0x20300000, 'device'],
		1825	[0xf0000000, 0x30000000, 'device'],
		1826	[0xf00fffff, 0x10000005, 'memdiag'],
		1827	[0xf0ffffff, 0x20200005, 'memdiag'],
		1828	[0xf00fffff, 0x10000006, 'ntldr'],
		1829	[0xf00fffff, 0x10000007, 'ntldr'],
		1830	[0xf0ffffff, 0x20200006, 'ntldr'],
		1831	[0xf0ffffff, 0x20200007, 'ntldr'],
		1832	[0xf00fffff, 0x10000003, 'osloader'],
		1833	[0xf0ffffff, 0x20200003, 'osloader'],
		1834	[0xf00fffff, 0x10000004, 'resume'],
		1835	[0xf0ffffff, 0x20200004, 'resume'],
		1836	[0xf00fffff, 0x10000009, 'startup'],
		1837	[0xf0ffffff, 0x20200009, 'startup'],
		1838	);
1675		1839
		1840	our %rbcde_byclass;
		1841
		1842	while (my ($k, $v) = each %bcde_byclass) {
		1843	$rbcde_byclass{$k} = { reverse %$v };
		1844	}
		1845
		1846	# decodes (numerical elem, type) to name
1676	sub dec_bcde_id($) {	1847	sub dec_bcde_id($$) {
		1848	for my $class (@bcde_typeclass) {
		1849	if (($_[1] & $class->[0]) == $class->[1]) {
		1850	if (my $id = $bcde_byclass{$class->[2]}{$_[0]}) {
		1851	return $id;
		1852	}
		1853	}
		1854	}
		1855
1677	$bcde{$_[0]} // sprintf "custom:%08x", $_[0]	1856	sprintf "custom:%08x", $_[0]
1678	}	1857	}
1679		1858
		1859	# encodes (elem as name, type)
1680	sub enc_bcde_id($) {	1860	sub enc_bcde_id($$) {
1681	$_[0] =~ /^custom:([0-9a-fA-F]{8}$)/	1861	$_[0] =~ /^custom:(?:0x)?([0-9a-fA-F]{8}$)/
1682	? hex $1	1862	and return hex $1;
1683	: $rbcde{$_[0]}	1863
		1864	for my $class (@bcde_typeclass) {
		1865	if (($_[1] & $class->[0]) == $class->[1]) {
		1866	if (my $value = $rbcde_byclass{$class->[2]}{$_[0]}) {
		1867	return $value;
		1868	}
		1869	}
		1870	}
		1871
		1872	undef
1684	}	1873	}
1685		1874
1686	# decode/encode bcd device element - the horror, no documentaion	1875	# decode/encode bcd device element - the horror, no documentaion
1687	# whatsoever, supercomplex, superinconsistent.	1876	# whatsoever, supercomplex, superinconsistent.
1688		1877
…		…
1691	our @part_type = qw(gpt mbr raw);	1880	our @part_type = qw(gpt mbr raw);
1692		1881
1693	our $NULL_DEVICE = "\x00" x 16;	1882	our $NULL_DEVICE = "\x00" x 16;
1694		1883
1695	# biggest bitch to decode, ever	1884	# biggest bitch to decode, ever
1696	# this decoded a device portion after the GUID	1885	# this decodes a device portion after the GUID
1697	sub dec_device_($);	1886	sub dec_device_($$);
1698	sub dec_device_($) {	1887	sub dec_device_($$) {
1699	my ($device) = @_;	1888	my ($device, $type) = @_;
1700		1889
1701	my $res;	1890	my $res;
1702		1891
1703	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";	1892	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";
1704		1893
…		…
1749		1938
1750	my $partid = $parttype eq "gpt" ? dec_guid $partdata	1939	my $partid = $parttype eq "gpt" ? dec_guid $partdata
1751	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start	1940	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start
1752	: unpack "L<", $partdata; # partition number, one-based	1941	: unpack "L<", $partdata; # partition number, one-based
1753		1942
1754	(my $parent, $device) = dec_device_ $device;	1943	(my $parent, $device) = dec_device_ $device, $type;
1755		1944
1756	$res .= "=";	1945	$res .= "=";
1757	$res .= "<$parent>";	1946	$res .= "<$parent>";
1758	$res .= ",$blocktype,$parttype,$diskid,$partid";	1947	$res .= ",$blocktype,$parttype,$diskid,$partid";
1759		1948
…		…
1779	or die "unsupported file descriptor version '$fver'\n";	1968	or die "unsupported file descriptor version '$fver'\n";
1780		1969
1781	$ftype == 5	1970	$ftype == 5
1782	or die "unsupported file descriptor path type '$type'\n";	1971	or die "unsupported file descriptor path type '$type'\n";
1783		1972
1784	(my $parent, $path) = dec_device_ $path;	1973	(my $parent, $path) = dec_device_ $path, $type;
1785		1974
1786	$path = $dec_path->($path, "file device without path");	1975	$path = $dec_path->($path, "file device without path");
1787		1976
1788	($parent, $path)	1977	($parent, $path)
1789	};	1978	};
…		…
1795		1984
1796	} elsif ($blocktype eq "vhd") {	1985	} elsif ($blocktype eq "vhd") {
1797	$device =~ s/^\x00{20}//s	1986	$device =~ s/^\x00{20}//s
1798	or die "virtualdisk has non-zero fields I don't understand\n";	1987	or die "virtualdisk has non-zero fields I don't understand\n";
1799		1988
1800	(my $parent, $device) = dec_device_ $device;	1989	(my $parent, $device) = dec_device_ $device, $type;
1801		1990
1802	$res .= "=vhd,<$parent>";	1991	$res .= "=vhd,<$parent>";
1803		1992
1804	} elsif ($blocktype eq "ramdisk") {	1993	} elsif ($blocktype eq "ramdisk") {
1805	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";	1994	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";
…		…
1818	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";	2007	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";
1819		2008
1820	if ($parent) {	2009	if ($parent) {
1821	# not sure why this is an offset - it must come after the path	2010	# not sure why this is an offset - it must come after the path
1822	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";	2011	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";
1823	($parent, my $tail) = dec_device_ $parent;	2012	($parent, my $tail) = dec_device_ $parent, $type;
1824	0 == length $tail	2013	0 == length $tail
1825	or die "trailing data after locate device parent\n";	2014	or die "trailing data after locate device parent\n";
1826	} else {	2015	} else {
1827	$parent = "null";	2016	$parent = "null";
1828	}	2017	}
…		…
1834		2023
1835	if ($mode == 0) { # "Element"	2024	if ($mode == 0) { # "Element"
1836	!length $path	2025	!length $path
1837	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";	2026	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";
1838		2027
1839	$elem = dec_bcde_id $elem;	2028	$elem = dec_bcde_id $elem, $type;
1840	$res .= "element,$elem";	2029	$res .= "element,$elem";
1841		2030
1842	} elsif ($mode == 1) { # "String"	2031	} elsif ($mode == 1) { # "String"
1843	!$elem	2032	!$elem
1844	or die "device locate mode 1 having non-zero element\n";	2033	or die "device locate mode 1 having non-zero element\n";
…		…
1869		2058
1870	($res, $tail)	2059	($res, $tail)
1871	}	2060	}
1872		2061
1873	# decode a full binary BCD device descriptor	2062	# decode a full binary BCD device descriptor
1874	sub dec_device($) {	2063	sub dec_device($$) {
1875	my ($device) = @_;	2064	my ($device, $type) = @_;
1876		2065
1877	$device = pack "H*", $device;	2066	$device = pack "H*", $device;
1878		2067
1879	my $guid = dec_guid substr $device, 0, 16, "";	2068	my $guid = dec_guid substr $device, 0, 16, "";
1880	$guid = $guid eq "00000000-0000-0000-0000-000000000000"	2069	$guid = $guid eq "00000000-0000-0000-0000-000000000000"
1881	? "" : "{$guid}";	2070	? "" : "{$guid}";
1882		2071
1883	eval {	2072	eval {
1884	my ($dev, $tail) = dec_device_ $device;	2073	my ($dev, $tail) = dec_device_ $device, $type;
1885		2074
1886	$tail eq ""	2075	$tail eq ""
1887	or die "unsupported trailing data after device descriptor\n";	2076	or die "unsupported trailing data after device descriptor\n";
1888		2077
1889	"$guid$dev"	2078	"$guid$dev"
…		…
1901		2090
1902	undef	2091	undef
1903	}	2092	}
1904		2093
1905	# encode the device portion after the GUID	2094	# encode the device portion after the GUID
1906	sub enc_device_;	2095	sub enc_device_($$);
1907	sub enc_device_ {	2096	sub enc_device_($$) {
1908	my ($device) = @_;	2097	my ($device, $type) = @_;
1909		2098
1910	my $enc_path = sub {	2099	my $enc_path = sub {
1911	my $path = shift;	2100	my $path = shift;
1912	$path =~ s/\//\\/g;	2101	$path =~ s/\//\\/g;
1913	(Encode::encode "UTF-16LE", $path) . "\x00\x00"	2102	(Encode::encode "UTF-16LE", $path) . "\x00\x00"
…		…
1931		2120
1932	my $parse_parent = sub {	2121	my $parse_parent = sub {
1933	my $parent;	2122	my $parent;
1934		2123
1935	if (s/^<//) {	2124	if (s/^<//) {
1936	($parent, $_) = enc_device_ $_;	2125	($parent, $_) = enc_device_ $_, $type;
1937	s/^>//	2126	s/^>//
1938	or die "$device: syntax error: parent device not followed by '>'\n";	2127	or die "$device: syntax error: parent device not followed by '>'\n";
1939	} else {	2128	} else {
1940	$parent = $NULL_DEVICE;	2129	$parent = $NULL_DEVICE;
1941	}	2130	}
…		…
2029		2218
2030	s/^,//	2219	s/^,//
2031	or die "$_: missing comma after locate parent device\n";	2220	or die "$_: missing comma after locate parent device\n";
2032		2221
2033	if (s/^element,//) {	2222	if (s/^element,//) {
2034	s/^([0-9a-z]+)//i	2223	s/^([0-9a-z:]+)//i
2035	or die "$_ locate element must be either name or 8-digit hex id\n";	2224	or die "$_ locate element must be either name or 8-digit hex id\n";
2036	$elem = enc_bcde_id $1;	2225	$elem = enc_bcde_id $1, $type;
2037	$mode = 0;	2226	$mode = 0;
2038	$path = $enc_path->("");	2227	$path = $enc_path->("");
2039		2228
2040	} elsif (s/^path,//) {	2229	} elsif (s/^path,//) {
2041	$mode = 1;	2230	$mode = 1;
…		…
2108	or die "$_: malformed or missing vmbus interface instance guid\n";	2297	or die "$_: malformed or missing vmbus interface instance guid\n";
2109	my $instance = enc_guid $1;	2298	my $instance = enc_guid $1;
2110		2299
2111	$payload = pack "a16a16x24", $type, $instance;	2300	$payload = pack "a16a16x24", $type, $instance;
2112		2301
		2302	# } elsif ($type eq "udp") {
		2303	# $payload = pack "Va16", 1, "12345678";
		2304
2113	} else {	2305	} else {
2114	die "$type: not a supported device type (binary, null, boot, legacypartition, partition, block, locate)\n";	2306	die "$type: not a supported device type (binary, null, boot, legacypartition, partition, block, locate)\n";
2115	}	2307	}
2116		2308
2117	return (	2309	return (
…		…
2120	);	2312	);
2121	}	2313	}
2122	}	2314	}
2123		2315
2124	# encode a full binary BCD device descriptor	2316	# encode a full binary BCD device descriptor
2125	sub enc_device {	2317	sub enc_device($$) {
2126	my ($device) = @_;	2318	my ($device, $type) = @_;
2127		2319
2128	my $guid = "\x00" x 16;	2320	my $guid = "\x00" x 16;
2129		2321
2130	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {	2322	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {
2131	$guid = enc_guid $1	2323	$guid = enc_guid $1
2132	or die "$device: does not start with valid guid\n";	2324	or die "$device: does not start with valid guid\n";
2133	}	2325	}
2134		2326
2135	my ($descriptor, $tail) = enc_device_ $device;	2327	my ($descriptor, $tail) = enc_device_ $device, $type;
2136		2328
2137	length $tail	2329	length $tail
2138	and die "$device: garbage after device descriptor\n";	2330	and die "$device: garbage after device descriptor\n";
2139		2331
2140	unpack "H*", $guid . $descriptor	2332	unpack "H*", $guid . $descriptor
…		…
2155	$k = $bcd_objects{$k} // $k;	2347	$k = $bcd_objects{$k} // $k;
2156		2348
2157	my $type = $v->{Description}[0]{Type}[1];	2349	my $type = $v->{Description}[0]{Type}[1];
2158		2350
2159	if ($type != $bcd_object_types{$k}) {	2351	if ($type != $bcd_object_types{$k}) {
2160	$type = $bcd_types{$type} // sprintf "0x%08x", $type;	2352	$kv{type} = $bcd_types{$type} // sprintf "0x%08x", $type;
2161	$kv{type} = $type;
2162	}	2353	}
2163		2354
2164	my $elems = $v->{Elements}[1];	2355	my $elems = $v->{Elements}[1];
2165		2356
2166	while (my ($k, $v) = each %$elems) {	2357	while (my ($k, $v) = each %$elems) {
2167	my $k = hex $k;	2358	my $k = hex $k;
2168		2359
2169	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1]);	2360	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1], $type);
2170	my $k = dec_bcde_id $k;	2361	my $k = dec_bcde_id $k, $type;
2171		2362
2172	$kv{$k} = $v;	2363	$kv{$k} = $v;
2173	}	2364	}
2174		2365
2175	$bcd{$k} = \%kv;	2366	$bcd{$k} = \%kv;
…		…
2216	my %elem;	2407	my %elem;
2217		2408
2218	while (my ($k, $v) = each %$v) {	2409	while (my ($k, $v) = each %$v) {
2219	next if $k eq "type";	2410	next if $k eq "type";
2220		2411
2221	$k = (enc_bcde_id $k) // die "$k: invalid bcde element name or id\n";	2412	$k = (enc_bcde_id $k, $type) // die "$k: invalid bcde element name or id\n";
2222	$elem{sprintf "%08x", $k} = [{	2413	$elem{sprintf "%08x", $k} = [{
2223	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]	2414	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]
2224	}];	2415	}];
2225	}	2416	}
2226		2417
…		…
2242	Objects => [undef, \%objects],	2433	Objects => [undef, \%objects],
2243	}]]	2434	}]]
2244	}	2435	}
2245		2436
2246	#############################################################################	2437	#############################################################################
		2438	# edit instructions
2247		2439
2248	sub bcd_edit_eval {	2440	sub bcd_edit_eval {
2249	package pbcdedit;	2441	package pbcdedit;
2250		2442
2251	our ($PATH, $BCD, $DEFAULT);	2443	our ($PATH, $BCD, $DEFAULT);
…		…
2255	}	2447	}
2256		2448
2257	sub bcd_edit {	2449	sub bcd_edit {
2258	my ($path, $bcd, @insns) = @_;	2450	my ($path, $bcd, @insns) = @_;
2259		2451
2260	my $default = $bcd->{"{bootmgr}"}{resumeobject};	2452	my $default = $bcd->{"{bootmgr}"}{default};
2261		2453
2262	# prepare "officially visible" variables	2454	# prepare "officially visible" variables
2263	local $pbcdedit::PATH = $path;	2455	local $pbcdedit::PATH = $path;
2264	local $pbcdedit::BCD = $bcd;	2456	local $pbcdedit::BCD = $bcd;
2265	local $pbcdedit::DEFAULT = $default;	2457	local $pbcdedit::DEFAULT = $default;
…		…
2269		2461
2270	if ($insn eq "get") {	2462	if ($insn eq "get") {
2271	my $object = shift @insns;	2463	my $object = shift @insns;
2272	my $elem = shift @insns;	2464	my $elem = shift @insns;
2273		2465
2274	$object = $default if $object eq "{default}";	2466	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
2275		2467
2276	print $bcd->{$object}{$elem}, "\n";	2468	print $bcd->{$object}{$elem}, "\n";
2277		2469
2278	} elsif ($insn eq "set") {	2470	} elsif ($insn eq "set") {
2279	my $object = shift @insns;	2471	my $object = shift @insns;
2280	my $elem = shift @insns;	2472	my $elem = shift @insns;
2281	my $value = shift @insns;	2473	my $value = shift @insns;
2282		2474
2283	$object = $default if $object eq "{default}";	2475	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
2284		2476
2285	$bcd->{$object}{$elem} = $value;	2477	$bcd->{$object}{$elem} = $value;
2286		2478
		2479	} elsif ($insn eq "del") {
		2480	my $object = shift @insns;
		2481	my $elem = shift @insns;
		2482
		2483	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2484
		2485	delete $bcd->{$object}{$elem};
		2486
2287	} elsif ($insn eq "eval") {	2487	} elsif ($insn eq "eval") {
2288	bcd_edit_eval shift @insns;	2488	my $perl = shift @insns;
		2489	bcd_edit_eval "#line 1 'eval'\n$perl";
2289		2490
2290	} elsif ($insn eq "do") {	2491	} elsif ($insn eq "do") {
2291	my $path = shift @insns;	2492	my $path = shift @insns;
2292	my $file = file_load $path;	2493	my $file = file_load $path;
2293	bcd_edit_eval "#line 1 '$path'\n$file";	2494	bcd_edit_eval "#line 1 '$path'\n$file";
2294		2495
2295	} else {	2496	} else {
2296	die "$insn: not a recognized instruction for edit/parse\n";	2497	die "$insn: not a recognized instruction for create/edit/parse\n";
2297	}	2498	}
2298	}	2499	}
2299		2500
2300	}	2501	}
2301		2502
2302	#############################################################################	2503	#############################################################################
		2504	# other utilities
2303		2505
2304	# json to stdout	2506	# json to stdout
2305	sub prjson($) {	2507	sub prjson($) {
2306	print $json_coder->encode ($_[0]);	2508	print $json_coder->encode ($_[0]);
2307	}	2509	}
…		…
2311	my $json;	2513	my $json;
2312	1 while read STDIN, $json, 65536, length $json;	2514	1 while read STDIN, $json, 65536, length $json;
2313	$json_coder->decode ($json)	2515	$json_coder->decode ($json)
2314	}	2516	}
2315		2517
2316	# all subcommands	2518	sub lsblk() {
		2519	my $lsblk = $json_coder->decode (scalar qx<lsblk --json -o PATH,KNAME,MAJ:MIN,TYPE,PTTYPE,PTUUID,PARTUUID,LABEL,FSTYPE>);
		2520
		2521	for my $dev (@{ $lsblk->{blockdevices} }) {
		2522	if ($dev->{type} eq "part") {
		2523
		2524	# lsblk sometimes gives a bogus pttype, so we recreate it here
		2525	$dev->{pttype} = $dev->{ptuuid} =~ /^$RE_GUID\z/
		2526	? "gpt" : "dos";
		2527
		2528	if ($dev->{pttype} eq "gpt") {
		2529	$dev->{bcd_device} = "partition=<null>,harddisk,gpt,$dev->{ptuuid},$dev->{partuuid}";
		2530	} elsif ($dev->{pttype} eq "dos") { # why not "mbr" :(
		2531	if ($dev->{partuuid} =~ /^([0-9a-f]{8})-([0-9a-f]{2})\z/i) {
		2532	my ($diskid, $partno) = ($1, hex $2);
		2533	$dev->{bcd_legacy_device} = "legacypartition=<null>,harddisk,mbr,$diskid,$partno";
		2534	if (open my $fh, "/sys/class/block/$dev->{kname}/start") {
		2535	my $start = 512 * readline $fh;
		2536	$dev->{bcd_device} = "partition=<null>,harddisk,mbr,$diskid,$start";
		2537	}
		2538	}
		2539	}
		2540	}
		2541	}
		2542
		2543	$lsblk->{blockdevices}
		2544	}
		2545
		2546	sub prdev($$) {
		2547	my ($path, $attribute) = @_;
		2548
		2549	# rather than stat'ing and guessing how devices are encoded, we use lsblk for this
		2550	my $mm = $json_coder->decode (scalar qx<lsblk -d -o MAJ:MIN -J \Q$path\E>)->{blockdevices}[0]{"maj:min"};
		2551
		2552	my $lsblk = lsblk;
		2553
		2554	for my $dev (@$lsblk) {
		2555	if ($dev->{"maj:min"} eq $mm && $dev->{$attribute}) {
		2556	say $dev->{$attribute};
		2557	exit 0;
		2558	}
		2559	}
		2560
		2561	exit 1;
		2562	}
		2563
		2564	#############################################################################
		2565	# command line parser
		2566
2317	our %CMD = (	2567	our %CMD = (
2318	help => sub {	2568	help => sub {
2319	require Pod::Usage;	2569	require Pod::Usage;
2320	Pod::Usage::pod2usage (-verbose => 2);	2570	Pod::Usage::pod2usage (-verbose => 2);
2321	},	2571	},
…		…
2346		2596
2347	print "\n";	2597	print "\n";
2348		2598
2349	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";	2599	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";
2350	for my $name (sort keys %rbcd_objects) {	2600	for my $name (sort keys %rbcd_objects) {
2351	my $guid = $rbcd_objects{$name};	2601	my $guid = $rbcd_objects{$name};
2352	my $type = $bcd_object_types{$name};	2602	my $type = $bcd_object_types{$name};
2353	my $tname = $bcd_types{$type};	2603	my $tname = $bcd_types{$type};
2354		2604
2355	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";	2605	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";
2356		2606
2357	printf "%-39s %-23s %s\n", $guid, $name, $type;	2607	printf "%-39s %-23s %s\n", $guid, $name, $type;
…		…
2371	BCDE_FORMAT_GUID_LIST , "guid list",	2621	BCDE_FORMAT_GUID_LIST , "guid list",
2372	BCDE_FORMAT_INTEGER , "integer",	2622	BCDE_FORMAT_INTEGER , "integer",
2373	BCDE_FORMAT_BOOLEAN , "boolean",	2623	BCDE_FORMAT_BOOLEAN , "boolean",
2374	BCDE_FORMAT_INTEGER_LIST, "integer list",	2624	BCDE_FORMAT_INTEGER_LIST, "integer list",
2375	);	2625	);
2376	my %rbcde = reverse %bcde;
2377	$_ = sprintf "%08x", $_ for values %rbcde;
2378		2626
2379	my %element;	2627	my @element;
2380		2628
		2629	for my $class (sort keys %rbcde_byclass) {
		2630	my $rbcde = $rbcde_byclass{$class};
		2631
2381	unless ($json) {	2632	unless ($json) {
2382	print "\n";	2633	print "\n";
		2634	printf "Elements applicable to class(es): $class\n";
2383	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";	2635	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";
2384	}	2636	}
2385	for my $name (sort keys %rbcde) {	2637	for my $name (sort keys %$rbcde) {
2386	my $id = $rbcde{$name};	2638	my $id = $rbcde->{$name};
2387	my $format = $format_name{(hex $id) & BCDE_FORMAT};	2639	my $format = $format_name{$id & BCDE_FORMAT};
2388		2640
2389	if ($json) {	2641	if ($json) {
2390	$element{$id} = [$format, $name];	2642	push @element, [$class, $id * 1, $format, $name];
2391	} else {	2643	} else {
		2644	$id = sprintf "%08x", $id;
2392	printf "%-9s %-12s %s\n", $id, $format, $name;	2645	printf "%-9s %-12s %s\n", $id, $format, $name;
		2646	}
2393	}	2647	}
2394	}	2648	}
2395	print "\n" unless $json;	2649	print "\n" unless $json;
2396		2650
2397	prjson {	2651	prjson {
2398	version => $JSON_VERSION,	2652	version => $JSON_VERSION,
2399	element => \%element,	2653	element => \@element,
		2654	class => \@bcde_typeclass,
2400	} if $json;	2655	} if $json;
2401		2656
2402	},	2657	},
2403		2658
2404	export => sub {	2659	export => sub {
…		…
2407		2662
2408	import => sub {	2663	import => sub {
2409	regf_save shift, bcd_encode rdjson;	2664	regf_save shift, bcd_encode rdjson;
2410	},	2665	},
2411		2666
		2667	create => sub {
		2668	my $path = shift;
		2669	my $stat = stat_get $path; # should actually be done at file load time
		2670	my $bcd = { };
		2671	bcd_edit $path, $bcd, @_;
		2672	regf_save $path, bcd_encode $bcd;
		2673	stat_set $path, $stat;
		2674	},
		2675
2412	edit => sub {	2676	edit => sub {
2413	my $path = shift;	2677	my $path = shift;
		2678	my $stat = stat_get $path; # should actually be done at file load time
2414	my $bcd = bcd_decode regf_load $path;	2679	my $bcd = bcd_decode regf_load $path;
2415	bcd_edit $path, $bcd, @_;	2680	bcd_edit $path, $bcd, @_;
2416	regf_save $path, bcd_encode $bcd;	2681	regf_save $path, bcd_encode $bcd;
		2682	stat_set $path, $stat;
2417	},	2683	},
2418		2684
2419	parse => sub {	2685	parse => sub {
2420	my $path = shift;	2686	my $path = shift;
2421	my $bcd = bcd_decode regf_load $path;	2687	my $bcd = bcd_decode regf_load $path;
…		…
2430	"import-regf" => sub {	2696	"import-regf" => sub {
2431	regf_save shift, rdjson;	2697	regf_save shift, rdjson;
2432	},	2698	},
2433		2699
2434	lsblk => sub {	2700	lsblk => sub {
		2701	my $json = $_[0] eq "--json";
		2702
		2703	my $lsblk = lsblk;
		2704
		2705	if ($json) {
		2706	prjson $lsblk;
		2707	} else {
2435	printf "%-10s %-8.8s %-6.6s %-3s %s\n", "DEVICE", "LABEL", "FSTYPE", "PT", "DEVICE DESCRIPTOR";	2708	printf "%-10s %-8.8s %-6.6s %-3s %s\n", "DEVICE", "LABEL", "FSTYPE", "PT", "DEVICE DESCRIPTOR";
2436		2709	for my $dev (@$lsblk) {
2437	my $lsblk = $json_coder->decode (scalar qx<lsblk --json -o PATH,KNAME,TYPE,PTTYPE,PTUUID,PARTUUID,LABEL,FSTYPE>);	2710	for my $bcd ($dev->{bcd_device}, $dev->{bcd_legacy_device}) {
2438
2439	for my $dev (@{ $lsblk->{blockdevices} }) {
2440	my $pr = sub {
2441	printf "%-10s %-8.8s %-6.6s %-3s %s\n",	2711	printf "%-10s %-8.8s %-6.6s %-3s %s\n",
2442	$dev->{path}, $dev->{label}, $dev->{fstype}, $dev->{pttype}, $_[0];	2712	$dev->{path}, $dev->{label}, $dev->{fstype}, $dev->{pttype}, $bcd
2443	};
2444
2445	if ($dev->{type} eq "part") {
2446	if ($dev->{pttype} eq "gpt") {
2447	$pr->("partition=<null>,harddisk,gpt,$dev->{ptuuid},$dev->{partuuid}");
2448	} elsif ($dev->{pttype} eq "dos") { # why not "mbr" :(
2449	if ($dev->{partuuid} =~ /^([0-9a-f]{8})-([0-9a-f]{2})\z/i) {
2450	my ($diskid, $partno) = ($1, hex $2);
2451	$pr->("legacypartition=<null>,harddisk,mbr,$diskid,$partno");
2452	if (open my $fh, "/sys/class/block/$dev->{kname}/start") {
2453	my $start = 512 * readline $fh;
2454	$pr->("partition=<null>,harddisk,mbr,$diskid,$start");
2455	}	2713	if $bcd;
2456	}
2457	}	2714	}
2458	}	2715	}
2459	}	2716	}
2460	},	2717	},
		2718
		2719	"bcd-device" => sub {
		2720	prdev shift, "bcd_device";
		2721	},
		2722
		2723	"bcd-legacy-device" => sub {
		2724	prdev shift, "bcd_legacy_device";
		2725	},
		2726
		2727	version => sub {
		2728	print "\n",
		2729	"PBCDEDIT version $VERSION, copyright 2019 Marc A. Lehmann <pbcdedit\@schmorp.de>.\n",
		2730	"JSON schema version: $JSON_VERSION\n",
		2731	"Licensed under the GNU General Public License Version 3.0, or any later version.\n",
		2732	"\n",
		2733	$CHANGELOG,
		2734	"\n";
		2735	},
2461	);	2736	);
2462		2737
2463	my $cmd = shift;	2738	my $cmd = shift;
2464		2739
2465	unless (exists $CMD{$cmd}) {	2740	unless (exists $CMD{$cmd}) {

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines