1 # Copyright (c) 2017 - 2018, Intel Corporation. All rights reserved.<BR>
2 # SPDX-License-Identifier: BSD-2-Clause-Patent
5 # This file is used to collect the Variable checking information
11 from struct
import pack
, unpack
14 from Common
.VariableAttributes
import VariableAttributes
15 from Common
.Misc
import *
17 import Common
.DataType
as DataType
18 import Common
.GlobalData
as GlobalData
20 var_info
= collections
.namedtuple("uefi_var", "pcdindex,pcdname,defaultstoragename,skuname,var_name, var_guid, var_offset,var_attribute,pcd_default_value, default_value, data_type,PcdDscLine,StructurePcd")
21 NvStorageHeaderSize
= 28
22 VariableHeaderSize
= 32
23 AuthenticatedVariableHeaderSize
= 60
25 class VariableMgr(object):
26 def __init__(self
, DefaultStoreMap
, SkuIdMap
):
28 self
.DefaultStoreMap
= DefaultStoreMap
29 self
.SkuIdMap
= SkuIdMap
30 self
.VpdRegionSize
= 0
31 self
.VpdRegionOffset
= 0
32 self
.NVHeaderBuff
= None
33 self
.VarDefaultBuff
= None
34 self
.VarDeltaBuff
= None
36 def append_variable(self
, uefi_var
):
37 self
.VarInfo
.append(uefi_var
)
39 def SetVpdRegionMaxSize(self
, maxsize
):
40 self
.VpdRegionSize
= maxsize
42 def SetVpdRegionOffset(self
, vpdoffset
):
43 self
.VpdRegionOffset
= vpdoffset
45 def PatchNVStoreDefaultMaxSize(self
, maxsize
):
46 if not self
.NVHeaderBuff
:
48 self
.NVHeaderBuff
= self
.NVHeaderBuff
[:8] + pack("=Q", maxsize
)
49 default_var_bin
= VariableMgr
.format_data(self
.NVHeaderBuff
+ self
.VarDefaultBuff
+ self
.VarDeltaBuff
)
51 default_var_bin_strip
= [ data
.strip("""'""") for data
in default_var_bin
]
52 value_str
+= ",".join(default_var_bin_strip
)
56 def combine_variable(self
):
57 indexedvarinfo
= collections
.OrderedDict()
58 for item
in self
.VarInfo
:
59 if (item
.skuname
, item
.defaultstoragename
, item
.var_name
, item
.var_guid
) not in indexedvarinfo
:
60 indexedvarinfo
[(item
.skuname
, item
.defaultstoragename
, item
.var_name
, item
.var_guid
) ] = []
61 indexedvarinfo
[(item
.skuname
, item
.defaultstoragename
, item
.var_name
, item
.var_guid
)].append(item
)
62 for key
in indexedvarinfo
:
63 sku_var_info_offset_list
= indexedvarinfo
[key
]
64 sku_var_info_offset_list
.sort(key
=lambda x
:x
.PcdDscLine
)
65 FirstOffset
= int(sku_var_info_offset_list
[0].var_offset
, 16) if sku_var_info_offset_list
[0].var_offset
.upper().startswith("0X") else int(sku_var_info_offset_list
[0].var_offset
)
66 fisrtvalue_list
= sku_var_info_offset_list
[0].default_value
.strip("{").strip("}").split(",")
67 firstdata_type
= sku_var_info_offset_list
[0].data_type
68 if firstdata_type
in DataType
.TAB_PCD_NUMERIC_TYPES
:
69 fisrtdata_flag
= DataType
.PACK_CODE_BY_SIZE
[MAX_SIZE_TYPE
[firstdata_type
]]
70 fisrtdata
= fisrtvalue_list
[0]
72 pack_data
= pack(fisrtdata_flag
, int(fisrtdata
, 0))
73 for data_byte
in range(len(pack_data
)):
74 fisrtvalue_list
.append(hex(unpack("B", pack_data
[data_byte
:data_byte
+ 1])[0]))
75 newvalue_list
= ["0x00"] * FirstOffset
+ fisrtvalue_list
77 for var_item
in sku_var_info_offset_list
[1:]:
78 CurOffset
= int(var_item
.var_offset
, 16) if var_item
.var_offset
.upper().startswith("0X") else int(var_item
.var_offset
)
79 CurvalueList
= var_item
.default_value
.strip("{").strip("}").split(",")
80 Curdata_type
= var_item
.data_type
81 if Curdata_type
in DataType
.TAB_PCD_NUMERIC_TYPES
:
82 data_flag
= DataType
.PACK_CODE_BY_SIZE
[MAX_SIZE_TYPE
[Curdata_type
]]
83 data
= CurvalueList
[0]
85 pack_data
= pack(data_flag
, int(data
, 0))
86 for data_byte
in range(len(pack_data
)):
87 CurvalueList
.append(hex(unpack("B", pack_data
[data_byte
:data_byte
+ 1])[0]))
88 if CurOffset
> len(newvalue_list
):
89 newvalue_list
= newvalue_list
+ ["0x00"] * (CurOffset
- len(newvalue_list
)) + CurvalueList
91 newvalue_list
[CurOffset
: CurOffset
+ len(CurvalueList
)] = CurvalueList
93 newvaluestr
= "{" + ",".join(newvalue_list
) +"}"
94 n
= sku_var_info_offset_list
[0]
95 indexedvarinfo
[key
] = [var_info(n
.pcdindex
, n
.pcdname
, n
.defaultstoragename
, n
.skuname
, n
.var_name
, n
.var_guid
, "0x00", n
.var_attribute
, newvaluestr
, newvaluestr
, DataType
.TAB_VOID
,n
.PcdDscLine
,n
.StructurePcd
)]
96 self
.VarInfo
= [item
[0] for item
in list(indexedvarinfo
.values())]
98 def process_variable_data(self
):
100 var_data
= collections
.defaultdict(collections
.OrderedDict
)
102 indexedvarinfo
= collections
.OrderedDict()
103 for item
in self
.VarInfo
:
104 if item
.pcdindex
not in indexedvarinfo
:
105 indexedvarinfo
[item
.pcdindex
] = dict()
106 indexedvarinfo
[item
.pcdindex
][(item
.skuname
, item
.defaultstoragename
)] = item
108 for index
in indexedvarinfo
:
109 sku_var_info
= indexedvarinfo
[index
]
111 default_data_buffer
= ""
112 others_data_buffer
= ""
114 default_sku_default
= indexedvarinfo
[index
].get((DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
))
116 if default_sku_default
.data_type
not in DataType
.TAB_PCD_NUMERIC_TYPES
:
117 var_max_len
= max(len(var_item
.default_value
.split(",")) for var_item
in sku_var_info
.values())
118 if len(default_sku_default
.default_value
.split(",")) < var_max_len
:
119 tail
= ",".join("0x00" for i
in range(var_max_len
-len(default_sku_default
.default_value
.split(","))))
121 default_data_buffer
= VariableMgr
.PACK_VARIABLES_DATA(default_sku_default
.default_value
, default_sku_default
.data_type
, tail
)
123 default_data_array
= ()
124 for item
in range(len(default_data_buffer
)):
125 default_data_array
+= unpack("B", default_data_buffer
[item
:item
+ 1])
127 var_data
[(DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
)][index
] = (default_data_buffer
, sku_var_info
[(DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
)])
129 for (skuid
, defaultstoragename
) in indexedvarinfo
[index
]:
131 if (skuid
, defaultstoragename
) == (DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
):
133 other_sku_other
= indexedvarinfo
[index
][(skuid
, defaultstoragename
)]
135 if default_sku_default
.data_type
not in DataType
.TAB_PCD_NUMERIC_TYPES
:
136 if len(other_sku_other
.default_value
.split(",")) < var_max_len
:
137 tail
= ",".join("0x00" for i
in range(var_max_len
-len(other_sku_other
.default_value
.split(","))))
139 others_data_buffer
= VariableMgr
.PACK_VARIABLES_DATA(other_sku_other
.default_value
, other_sku_other
.data_type
, tail
)
141 others_data_array
= ()
142 for item
in range(len(others_data_buffer
)):
143 others_data_array
+= unpack("B", others_data_buffer
[item
:item
+ 1])
145 data_delta
= VariableMgr
.calculate_delta(default_data_array
, others_data_array
)
147 var_data
[(skuid
, defaultstoragename
)][index
] = (data_delta
, sku_var_info
[(skuid
, defaultstoragename
)])
150 def new_process_varinfo(self
):
151 self
.combine_variable()
153 var_data
= self
.process_variable_data()
158 pcds_default_data
= var_data
.get((DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
), {})
159 NvStoreDataBuffer
= bytearray()
160 var_data_offset
= collections
.OrderedDict()
161 offset
= NvStorageHeaderSize
162 for default_data
, default_info
in pcds_default_data
.values():
163 var_name_buffer
= VariableMgr
.PACK_VARIABLE_NAME(default_info
.var_name
)
165 vendorguid
= default_info
.var_guid
.split('-')
167 if default_info
.var_attribute
:
168 var_attr_value
, _
= VariableAttributes
.GetVarAttributes(default_info
.var_attribute
)
170 var_attr_value
= 0x07
172 DataBuffer
= VariableMgr
.AlignData(var_name_buffer
+ default_data
)
174 data_size
= len(DataBuffer
)
175 if GlobalData
.gCommandLineDefines
.get(TAB_DSC_DEFINES_VPD_AUTHENTICATED_VARIABLE_STORE
,"FALSE").upper() == "TRUE":
176 offset
+= AuthenticatedVariableHeaderSize
+ len(default_info
.var_name
.split(","))
178 offset
+= VariableHeaderSize
+ len(default_info
.var_name
.split(","))
179 var_data_offset
[default_info
.pcdindex
] = offset
180 offset
+= data_size
- len(default_info
.var_name
.split(","))
181 if GlobalData
.gCommandLineDefines
.get(TAB_DSC_DEFINES_VPD_AUTHENTICATED_VARIABLE_STORE
,"FALSE").upper() == "TRUE":
182 var_header_buffer
= VariableMgr
.PACK_AUTHENTICATED_VARIABLE_HEADER(var_attr_value
, len(default_info
.var_name
.split(",")), len (default_data
), vendorguid
)
184 var_header_buffer
= VariableMgr
.PACK_VARIABLE_HEADER(var_attr_value
, len(default_info
.var_name
.split(",")), len (default_data
), vendorguid
)
185 NvStoreDataBuffer
+= (var_header_buffer
+ DataBuffer
)
187 if GlobalData
.gCommandLineDefines
.get(TAB_DSC_DEFINES_VPD_AUTHENTICATED_VARIABLE_STORE
,"FALSE").upper() == "TRUE":
188 variable_storage_header_buffer
= VariableMgr
.PACK_AUTHENTICATED_VARIABLE_STORE_HEADER(len(NvStoreDataBuffer
) + 28)
190 variable_storage_header_buffer
= VariableMgr
.PACK_VARIABLE_STORE_HEADER(len(NvStoreDataBuffer
) + 28)
192 nv_default_part
= VariableMgr
.AlignData(VariableMgr
.PACK_DEFAULT_DATA(0, 0, VariableMgr
.unpack_data(variable_storage_header_buffer
+NvStoreDataBuffer
)), 8)
194 data_delta_structure_buffer
= bytearray()
195 for skuname
, defaultstore
in var_data
:
196 if (skuname
, defaultstore
) == (DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
):
198 pcds_sku_data
= var_data
[(skuname
, defaultstore
)]
200 for pcdindex
in pcds_sku_data
:
201 offset
= var_data_offset
[pcdindex
]
202 delta_data
, _
= pcds_sku_data
[pcdindex
]
203 delta_data
= [(item
[0] + offset
, item
[1]) for item
in delta_data
]
204 delta_data_set
.extend(delta_data
)
206 data_delta_structure_buffer
+= VariableMgr
.AlignData(self
.PACK_DELTA_DATA(skuname
, defaultstore
, delta_data_set
), 8)
208 size
= len(nv_default_part
+ data_delta_structure_buffer
) + 16
209 maxsize
= self
.VpdRegionSize
if self
.VpdRegionSize
else size
210 NV_Store_Default_Header
= VariableMgr
.PACK_NV_STORE_DEFAULT_HEADER(size
, maxsize
)
212 self
.NVHeaderBuff
= NV_Store_Default_Header
213 self
.VarDefaultBuff
=nv_default_part
214 self
.VarDeltaBuff
= data_delta_structure_buffer
215 return VariableMgr
.format_data(NV_Store_Default_Header
+ nv_default_part
+ data_delta_structure_buffer
)
219 def format_data(data
):
220 return [hex(item
) for item
in VariableMgr
.unpack_data(data
)]
223 def unpack_data(data
):
225 for item
in range(len(data
)):
226 final_data
+= unpack("B", data
[item
:item
+ 1])
230 def calculate_delta(default
, theother
):
231 if len(default
) - len(theother
) != 0:
232 EdkLogger
.error("build", FORMAT_INVALID
, 'The variable data length is not the same for the same PCD.')
234 for i
in range(len(default
)):
235 if default
[i
] != theother
[i
]:
236 data_delta
.append((i
, theother
[i
]))
241 default_var_bin
= self
.new_process_varinfo()
244 default_var_bin_strip
= [ data
.strip("""'""") for data
in default_var_bin
]
245 value_str
+= ",".join(default_var_bin_strip
)
251 def PACK_VARIABLE_STORE_HEADER(size
):
252 #Signature: gEfiVariableGuid
253 Guid
= "{ 0xddcf3616, 0x3275, 0x4164, { 0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d }}"
254 Guid
= GuidStructureStringToGuidString(Guid
)
255 GuidBuffer
= PackGUID(Guid
.split('-'))
257 SizeBuffer
= pack('=L', size
)
258 FormatBuffer
= pack('=B', 0x5A)
259 StateBuffer
= pack('=B', 0xFE)
260 reservedBuffer
= pack('=H', 0)
261 reservedBuffer
+= pack('=L', 0)
263 return GuidBuffer
+ SizeBuffer
+ FormatBuffer
+ StateBuffer
+ reservedBuffer
265 def PACK_AUTHENTICATED_VARIABLE_STORE_HEADER(size
):
266 #Signature: gEfiAuthenticatedVariableGuid
267 Guid
= "{ 0xaaf32c78, 0x947b, 0x439a, { 0xa1, 0x80, 0x2e, 0x14, 0x4e, 0xc3, 0x77, 0x92 }}"
268 Guid
= GuidStructureStringToGuidString(Guid
)
269 GuidBuffer
= PackGUID(Guid
.split('-'))
271 SizeBuffer
= pack('=L', size
)
272 FormatBuffer
= pack('=B', 0x5A)
273 StateBuffer
= pack('=B', 0xFE)
274 reservedBuffer
= pack('=H', 0)
275 reservedBuffer
+= pack('=L', 0)
277 return GuidBuffer
+ SizeBuffer
+ FormatBuffer
+ StateBuffer
+ reservedBuffer
280 def PACK_NV_STORE_DEFAULT_HEADER(size
, maxsize
):
281 Signature
= pack('=B', ord('N'))
282 Signature
+= pack("=B", ord('S'))
283 Signature
+= pack("=B", ord('D'))
284 Signature
+= pack("=B", ord('B'))
286 SizeBuffer
= pack("=L", size
)
287 MaxSizeBuffer
= pack("=Q", maxsize
)
289 return Signature
+ SizeBuffer
+ MaxSizeBuffer
292 def PACK_VARIABLE_HEADER(attribute
, namesize
, datasize
, vendorguid
):
294 Buffer
= pack('=H', 0x55AA) # pack StartID
295 Buffer
+= pack('=B', 0x3F) # pack State
296 Buffer
+= pack('=B', 0) # pack reserved
298 Buffer
+= pack('=L', attribute
)
299 Buffer
+= pack('=L', namesize
)
300 Buffer
+= pack('=L', datasize
)
302 Buffer
+= PackGUID(vendorguid
)
307 def PACK_AUTHENTICATED_VARIABLE_HEADER(attribute
, namesize
, datasize
, vendorguid
):
309 Buffer
= pack('=H', 0x55AA) # pack StartID
310 Buffer
+= pack('=B', 0x3F) # pack State
311 Buffer
+= pack('=B', 0) # pack reserved
313 Buffer
+= pack('=L', attribute
)
315 Buffer
+= pack('=Q', 0) # pack MonotonicCount
316 Buffer
+= pack('=HBBBBBBLhBB', # pack TimeStamp
324 0, # UINT32 Nanosecond
328 Buffer
+= pack('=L', 0) # pack PubKeyIndex
330 Buffer
+= pack('=L', namesize
)
331 Buffer
+= pack('=L', datasize
)
333 Buffer
+= PackGUID(vendorguid
)
338 def PACK_VARIABLES_DATA(var_value
,data_type
, tail
= None):
341 if data_type
== DataType
.TAB_VOID
:
342 for value_char
in var_value
.strip("{").strip("}").split(","):
343 Buffer
+= pack("=B", int(value_char
, 16))
344 data_len
+= len(var_value
.split(","))
346 for value_char
in tail
.split(","):
347 Buffer
+= pack("=B", int(value_char
, 16))
348 data_len
+= len(tail
.split(","))
349 elif data_type
== "BOOLEAN":
350 Buffer
+= pack("=B", True) if var_value
.upper() in ["TRUE","1"] else pack("=B", False)
352 elif data_type
== DataType
.TAB_UINT8
:
353 Buffer
+= pack("=B", GetIntegerValue(var_value
))
355 elif data_type
== DataType
.TAB_UINT16
:
356 Buffer
+= pack("=H", GetIntegerValue(var_value
))
358 elif data_type
== DataType
.TAB_UINT32
:
359 Buffer
+= pack("=L", GetIntegerValue(var_value
))
361 elif data_type
== DataType
.TAB_UINT64
:
362 Buffer
+= pack("=Q", GetIntegerValue(var_value
))
368 def PACK_DEFAULT_DATA(defaultstoragename
, skuid
, var_value
):
370 Buffer
+= pack("=L", 4+8+8)
371 Buffer
+= pack("=Q", int(skuid
))
372 Buffer
+= pack("=Q", int(defaultstoragename
))
374 for item
in var_value
:
375 Buffer
+= pack("=B", item
)
377 Buffer
= pack("=L", len(Buffer
)+4) + Buffer
381 def GetSkuId(self
, skuname
):
382 if skuname
not in self
.SkuIdMap
:
384 return self
.SkuIdMap
.get(skuname
)[0]
386 def GetDefaultStoreId(self
, dname
):
387 if dname
not in self
.DefaultStoreMap
:
389 return self
.DefaultStoreMap
.get(dname
)[0]
391 def PACK_DELTA_DATA(self
, skuname
, defaultstoragename
, delta_list
):
392 skuid
= self
.GetSkuId(skuname
)
393 defaultstorageid
= self
.GetDefaultStoreId(defaultstoragename
)
395 Buffer
+= pack("=L", 4+8+8)
396 Buffer
+= pack("=Q", int(skuid
))
397 Buffer
+= pack("=Q", int(defaultstorageid
))
398 for (delta_offset
, value
) in delta_list
:
399 Buffer
+= pack("=L", delta_offset
)
400 Buffer
= Buffer
[:-1] + pack("=B", value
)
402 Buffer
= pack("=L", len(Buffer
) + 4) + Buffer
407 def AlignData(data
, align
= 4):
409 if (len(data
) % align
) > 0:
410 for i
in range(align
- (len(data
) % align
)):
411 mybuffer
+= pack("=B", 0)
416 def PACK_VARIABLE_NAME(var_name
):
418 for name_char
in var_name
.strip("{").strip("}").split(","):
419 Buffer
+= pack("=B", int(name_char
, 16))