1 # Copyright (c) 2017 - 2018, Intel Corporation. All rights reserved.<BR>
2 # This program and the accompanying materials
3 # are licensed and made available under the terms and conditions of the BSD License
4 # which accompanies this distribution. The full text of the license may be found at
5 # http://opensource.org/licenses/bsd-license.php
7 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
8 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11 # This file is used to collect the Variable checking information
17 from struct
import pack
, unpack
20 from Common
.VariableAttributes
import VariableAttributes
21 from Common
.Misc
import *
23 import Common
.DataType
as DataType
25 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")
26 NvStorageHeaderSize
= 28
27 VariableHeaderSize
= 32
29 class VariableMgr(object):
30 def __init__(self
, DefaultStoreMap
, SkuIdMap
):
32 self
.DefaultStoreMap
= DefaultStoreMap
33 self
.SkuIdMap
= SkuIdMap
34 self
.VpdRegionSize
= 0
35 self
.VpdRegionOffset
= 0
36 self
.NVHeaderBuff
= None
37 self
.VarDefaultBuff
= None
38 self
.VarDeltaBuff
= None
40 def append_variable(self
, uefi_var
):
41 self
.VarInfo
.append(uefi_var
)
43 def SetVpdRegionMaxSize(self
, maxsize
):
44 self
.VpdRegionSize
= maxsize
46 def SetVpdRegionOffset(self
, vpdoffset
):
47 self
.VpdRegionOffset
= vpdoffset
49 def PatchNVStoreDefaultMaxSize(self
, maxsize
):
50 if not self
.NVHeaderBuff
:
52 self
.NVHeaderBuff
= self
.NVHeaderBuff
[:8] + pack("=Q", maxsize
)
53 default_var_bin
= VariableMgr
.format_data(self
.NVHeaderBuff
+ self
.VarDefaultBuff
+ self
.VarDeltaBuff
)
55 default_var_bin_strip
= [ data
.strip("""'""") for data
in default_var_bin
]
56 value_str
+= ",".join(default_var_bin_strip
)
59 def Do_combine(self
,sku_var_info_offset_list
):
61 for item
in sku_var_info_offset_list
:
62 data_type
= item
.data_type
63 value_list
= item
.default_value
.strip("{").strip("}").split(",")
64 if data_type
in DataType
.TAB_PCD_NUMERIC_TYPES
:
65 data_flag
= DataType
.PACK_CODE_BY_SIZE
[MAX_SIZE_TYPE
[data_type
]]
68 for data_byte
in pack(data_flag
, int(data
, 16) if data
.upper().startswith('0X') else int(data
)):
69 value_list
.append(hex(unpack("B", data_byte
)[0]))
70 newvalue
[int(item
.var_offset
, 16) if item
.var_offset
.upper().startswith("0X") else int(item
.var_offset
)] = value_list
72 newvaluestr
= "{" + ",".join(VariableMgr
.assemble_variable(newvalue
)) +"}"
74 EdkLogger
.error("build", AUTOGEN_ERROR
, "Variable offset conflict in PCDs: %s \n" % (" and ".join(item
.pcdname
for item
in sku_var_info_offset_list
)))
76 def Do_Merge(self
,sku_var_info_offset_list
):
77 StructrurePcds
= sorted([item
for item
in sku_var_info_offset_list
if item
.StructurePcd
], key
= lambda x
: x
.PcdDscLine
, reverse
=True )
78 Base
= StructrurePcds
[0]
79 BaseValue
= Base
.default_value
.strip("{").strip("}").split(",")
80 Override
= [item
for item
in sku_var_info_offset_list
if not item
.StructurePcd
and item
.PcdDscLine
> Base
.PcdDscLine
]
83 data_type
= item
.data_type
84 value_list
= item
.default_value
.strip("{").strip("}").split(",")
85 if data_type
in DataType
.TAB_PCD_NUMERIC_TYPES
:
86 data_flag
= DataType
.PACK_CODE_BY_SIZE
[MAX_SIZE_TYPE
[data_type
]]
89 for data_byte
in pack(data_flag
, int(data
, 16) if data
.upper().startswith('0X') else int(data
)):
90 value_list
.append(hex(unpack("B", data_byte
)[0]))
91 newvalue
[int(item
.var_offset
, 16) if item
.var_offset
.upper().startswith("0X") else int(item
.var_offset
)] = (value_list
,item
.pcdname
,item
.PcdDscLine
)
92 for offset
in newvalue
:
93 value_list
,itemPcdname
,itemPcdDscLine
= newvalue
[offset
]
94 if offset
> len(BaseValue
) or (offset
+ len(value_list
) > len(BaseValue
)):
95 EdkLogger
.error("build", AUTOGEN_ERROR
, "The EFI Variable referred by PCD %s in line %s exceeds variable size: %s\n" % (itemPcdname
,itemPcdDscLine
,hex(len(BaseValue
))))
96 for i
in xrange(len(value_list
)):
97 BaseValue
[offset
+ i
] = value_list
[i
]
98 newvaluestr
= "{" + ",".join(BaseValue
) +"}"
100 def NeedMerge(self
,sku_var_info_offset_list
):
101 if [item
for item
in sku_var_info_offset_list
if item
.StructurePcd
]:
104 def combine_variable(self
):
105 indexedvarinfo
= collections
.OrderedDict()
106 for item
in self
.VarInfo
:
107 if (item
.skuname
, item
.defaultstoragename
, item
.var_name
, item
.var_guid
) not in indexedvarinfo
:
108 indexedvarinfo
[(item
.skuname
, item
.defaultstoragename
, item
.var_name
, item
.var_guid
) ] = []
109 indexedvarinfo
[(item
.skuname
, item
.defaultstoragename
, item
.var_name
, item
.var_guid
)].append(item
)
110 for key
in indexedvarinfo
:
111 sku_var_info_offset_list
= indexedvarinfo
[key
]
112 if len(sku_var_info_offset_list
) == 1:
115 n
= sku_var_info_offset_list
[0]
117 if self
.NeedMerge(sku_var_info_offset_list
):
118 newvaluestr
= self
.Do_Merge(sku_var_info_offset_list
)
120 newvaluestr
= self
.Do_combine(sku_var_info_offset_list
)
122 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
)]
123 self
.VarInfo
= [item
[0] for item
in indexedvarinfo
.values()]
126 def assemble_variable(valuedict
):
127 ordered_valuedict_keys
= sorted(valuedict
.keys())
129 for current_valuedict_key
in ordered_valuedict_keys
:
130 if current_valuedict_key
< len(var_value
):
132 for _
in xrange(current_valuedict_key
- len(var_value
)):
133 var_value
.append('0x00')
134 var_value
+= valuedict
[current_valuedict_key
]
137 def process_variable_data(self
):
139 var_data
= collections
.defaultdict(collections
.OrderedDict
)
141 indexedvarinfo
= collections
.OrderedDict()
142 for item
in self
.VarInfo
:
143 if item
.pcdindex
not in indexedvarinfo
:
144 indexedvarinfo
[item
.pcdindex
] = dict()
145 indexedvarinfo
[item
.pcdindex
][(item
.skuname
, item
.defaultstoragename
)] = item
147 for index
in indexedvarinfo
:
148 sku_var_info
= indexedvarinfo
[index
]
150 default_data_buffer
= ""
151 others_data_buffer
= ""
153 default_sku_default
= indexedvarinfo
[index
].get((DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
))
155 if default_sku_default
.data_type
not in DataType
.TAB_PCD_NUMERIC_TYPES
:
156 var_max_len
= max(len(var_item
.default_value
.split(",")) for var_item
in sku_var_info
.values())
157 if len(default_sku_default
.default_value
.split(",")) < var_max_len
:
158 tail
= ",".join("0x00" for i
in range(var_max_len
-len(default_sku_default
.default_value
.split(","))))
160 default_data_buffer
= VariableMgr
.PACK_VARIABLES_DATA(default_sku_default
.default_value
, default_sku_default
.data_type
, tail
)
162 default_data_array
= ()
163 for item
in default_data_buffer
:
164 default_data_array
+= unpack("B", item
)
166 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
)])
168 for (skuid
, defaultstoragename
) in indexedvarinfo
[index
]:
170 if (skuid
, defaultstoragename
) == (DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
):
172 other_sku_other
= indexedvarinfo
[index
][(skuid
, defaultstoragename
)]
174 if default_sku_default
.data_type
not in DataType
.TAB_PCD_NUMERIC_TYPES
:
175 if len(other_sku_other
.default_value
.split(",")) < var_max_len
:
176 tail
= ",".join("0x00" for i
in range(var_max_len
-len(other_sku_other
.default_value
.split(","))))
178 others_data_buffer
= VariableMgr
.PACK_VARIABLES_DATA(other_sku_other
.default_value
, other_sku_other
.data_type
, tail
)
180 others_data_array
= ()
181 for item
in others_data_buffer
:
182 others_data_array
+= unpack("B", item
)
184 data_delta
= VariableMgr
.calculate_delta(default_data_array
, others_data_array
)
186 var_data
[(skuid
, defaultstoragename
)][index
] = (data_delta
, sku_var_info
[(skuid
, defaultstoragename
)])
189 def new_process_varinfo(self
):
190 self
.combine_variable()
192 var_data
= self
.process_variable_data()
197 pcds_default_data
= var_data
.get((DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
), {})
198 NvStoreDataBuffer
= ""
199 var_data_offset
= collections
.OrderedDict()
200 offset
= NvStorageHeaderSize
201 for default_data
, default_info
in pcds_default_data
.values():
202 var_name_buffer
= VariableMgr
.PACK_VARIABLE_NAME(default_info
.var_name
)
204 vendorguid
= default_info
.var_guid
.split('-')
206 if default_info
.var_attribute
:
207 var_attr_value
, _
= VariableAttributes
.GetVarAttributes(default_info
.var_attribute
)
209 var_attr_value
= 0x07
211 DataBuffer
= VariableMgr
.AlignData(var_name_buffer
+ default_data
)
213 data_size
= len(DataBuffer
)
214 offset
+= VariableHeaderSize
+ len(default_info
.var_name
.split(","))
215 var_data_offset
[default_info
.pcdindex
] = offset
216 offset
+= data_size
- len(default_info
.var_name
.split(","))
218 var_header_buffer
= VariableMgr
.PACK_VARIABLE_HEADER(var_attr_value
, len(default_info
.var_name
.split(",")), len (default_data
), vendorguid
)
219 NvStoreDataBuffer
+= (var_header_buffer
+ DataBuffer
)
221 variable_storage_header_buffer
= VariableMgr
.PACK_VARIABLE_STORE_HEADER(len(NvStoreDataBuffer
) + 28)
223 nv_default_part
= VariableMgr
.AlignData(VariableMgr
.PACK_DEFAULT_DATA(0, 0, VariableMgr
.unpack_data(variable_storage_header_buffer
+NvStoreDataBuffer
)), 8)
225 data_delta_structure_buffer
= ""
226 for skuname
, defaultstore
in var_data
:
227 if (skuname
, defaultstore
) == (DataType
.TAB_DEFAULT
, DataType
.TAB_DEFAULT_STORES_DEFAULT
):
229 pcds_sku_data
= var_data
[(skuname
, defaultstore
)]
231 for pcdindex
in pcds_sku_data
:
232 offset
= var_data_offset
[pcdindex
]
233 delta_data
, _
= pcds_sku_data
[pcdindex
]
234 delta_data
= [(item
[0] + offset
, item
[1]) for item
in delta_data
]
235 delta_data_set
.extend(delta_data
)
237 data_delta_structure_buffer
+= VariableMgr
.AlignData(self
.PACK_DELTA_DATA(skuname
, defaultstore
, delta_data_set
), 8)
239 size
= len(nv_default_part
+ data_delta_structure_buffer
) + 16
240 maxsize
= self
.VpdRegionSize
if self
.VpdRegionSize
else size
241 NV_Store_Default_Header
= VariableMgr
.PACK_NV_STORE_DEFAULT_HEADER(size
, maxsize
)
243 self
.NVHeaderBuff
= NV_Store_Default_Header
244 self
.VarDefaultBuff
=nv_default_part
245 self
.VarDeltaBuff
= data_delta_structure_buffer
246 return VariableMgr
.format_data(NV_Store_Default_Header
+ nv_default_part
+ data_delta_structure_buffer
)
250 def format_data(data
):
251 return [hex(item
) for item
in VariableMgr
.unpack_data(data
)]
254 def unpack_data(data
):
257 final_data
+= unpack("B", item
)
261 def calculate_delta(default
, theother
):
262 if len(default
) - len(theother
) != 0:
263 EdkLogger
.error("build", FORMAT_INVALID
, 'The variable data length is not the same for the same PCD.')
265 for i
in range(len(default
)):
266 if default
[i
] != theother
[i
]:
267 data_delta
.append((i
, theother
[i
]))
272 default_var_bin
= self
.new_process_varinfo()
275 default_var_bin_strip
= [ data
.strip("""'""") for data
in default_var_bin
]
276 value_str
+= ",".join(default_var_bin_strip
)
282 def PACK_VARIABLE_STORE_HEADER(size
):
283 #Signature: gEfiVariableGuid
284 Guid
= "{ 0xddcf3616, 0x3275, 0x4164, { 0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d }}"
285 Guid
= GuidStructureStringToGuidString(Guid
)
286 GuidBuffer
= PackGUID(Guid
.split('-'))
288 SizeBuffer
= pack('=L', size
)
289 FormatBuffer
= pack('=B', 0x5A)
290 StateBuffer
= pack('=B', 0xFE)
291 reservedBuffer
= pack('=H', 0)
292 reservedBuffer
+= pack('=L', 0)
294 return GuidBuffer
+ SizeBuffer
+ FormatBuffer
+ StateBuffer
+ reservedBuffer
297 def PACK_NV_STORE_DEFAULT_HEADER(size
, maxsize
):
298 Signature
= pack('=B', ord('N'))
299 Signature
+= pack("=B", ord('S'))
300 Signature
+= pack("=B", ord('D'))
301 Signature
+= pack("=B", ord('B'))
303 SizeBuffer
= pack("=L", size
)
304 MaxSizeBuffer
= pack("=Q", maxsize
)
306 return Signature
+ SizeBuffer
+ MaxSizeBuffer
309 def PACK_VARIABLE_HEADER(attribute
, namesize
, datasize
, vendorguid
):
311 Buffer
= pack('=H', 0x55AA) # pack StartID
312 Buffer
+= pack('=B', 0x3F) # pack State
313 Buffer
+= pack('=B', 0) # pack reserved
315 Buffer
+= pack('=L', attribute
)
316 Buffer
+= pack('=L', namesize
)
317 Buffer
+= pack('=L', datasize
)
319 Buffer
+= PackGUID(vendorguid
)
324 def PACK_VARIABLES_DATA(var_value
,data_type
, tail
= None):
327 if data_type
== DataType
.TAB_VOID
:
328 for value_char
in var_value
.strip("{").strip("}").split(","):
329 Buffer
+= pack("=B", int(value_char
, 16))
330 data_len
+= len(var_value
.split(","))
332 for value_char
in tail
.split(","):
333 Buffer
+= pack("=B", int(value_char
, 16))
334 data_len
+= len(tail
.split(","))
335 elif data_type
== "BOOLEAN":
336 Buffer
+= pack("=B", True) if var_value
.upper() in ["TRUE","1"] else pack("=B", False)
338 elif data_type
== DataType
.TAB_UINT8
:
339 Buffer
+= pack("=B", GetIntegerValue(var_value
))
341 elif data_type
== DataType
.TAB_UINT16
:
342 Buffer
+= pack("=H", GetIntegerValue(var_value
))
344 elif data_type
== DataType
.TAB_UINT32
:
345 Buffer
+= pack("=L", GetIntegerValue(var_value
))
347 elif data_type
== DataType
.TAB_UINT64
:
348 Buffer
+= pack("=Q", GetIntegerValue(var_value
))
354 def PACK_DEFAULT_DATA(defaultstoragename
, skuid
, var_value
):
356 Buffer
+= pack("=L", 4+8+8)
357 Buffer
+= pack("=Q", int(skuid
))
358 Buffer
+= pack("=Q", int(defaultstoragename
))
360 for item
in var_value
:
361 Buffer
+= pack("=B", item
)
363 Buffer
= pack("=L", len(Buffer
)+4) + Buffer
367 def GetSkuId(self
, skuname
):
368 if skuname
not in self
.SkuIdMap
:
370 return self
.SkuIdMap
.get(skuname
)[0]
372 def GetDefaultStoreId(self
, dname
):
373 if dname
not in self
.DefaultStoreMap
:
375 return self
.DefaultStoreMap
.get(dname
)[0]
377 def PACK_DELTA_DATA(self
, skuname
, defaultstoragename
, delta_list
):
378 skuid
= self
.GetSkuId(skuname
)
379 defaultstorageid
= self
.GetDefaultStoreId(defaultstoragename
)
381 Buffer
+= pack("=L", 4+8+8)
382 Buffer
+= pack("=Q", int(skuid
))
383 Buffer
+= pack("=Q", int(defaultstorageid
))
384 for (delta_offset
, value
) in delta_list
:
385 Buffer
+= pack("=L", delta_offset
)
386 Buffer
= Buffer
[:-1] + pack("=B", value
)
388 Buffer
= pack("=L", len(Buffer
) + 4) + Buffer
393 def AlignData(data
, align
= 4):
395 if (len(data
) % align
) > 0:
396 for i
in range(align
- (len(data
) % align
)):
397 mybuffer
+= pack("=B", 0)
402 def PACK_VARIABLE_NAME(var_name
):
404 for name_char
in var_name
.strip("{").strip("}").split(","):
405 Buffer
+= pack("=B", int(name_char
, 16))