ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/pbcdedit/pbcdedit
(Generate patch)

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

Diff Legend

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