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")
26 NvStorageHeaderSize
= 28
27 VariableHeaderSize
= 32
29 def StringArrayToList(StringArray
):
30 StringArray
= StringArray
[1:-1]
31 StringArray
= '[' + StringArray
+ ']'
32 return eval(StringArray
)
35 GuidBuffer
= pack('=LHHBBBBBBBB',
39 int(Guid
[3][-4:-2], 16),
40 int(Guid
[3][-2:], 16),
41 int(Guid
[4][-12:-10], 16),
42 int(Guid
[4][-10:-8], 16),
43 int(Guid
[4][-8:-6], 16),
44 int(Guid
[4][-6:-4], 16),
45 int(Guid
[4][-4:-2], 16),
50 class VariableMgr(object):
51 def __init__(self
, DefaultStoreMap
,SkuIdMap
):
53 self
.DefaultStoreMap
= DefaultStoreMap
54 self
.SkuIdMap
= SkuIdMap
55 self
.VpdRegionSize
= 0
56 self
.VpdRegionOffset
= 0
57 self
.NVHeaderBuff
= None
58 self
.VarDefaultBuff
= None
59 self
.VarDeltaBuff
= None
61 def append_variable(self
,uefi_var
):
62 self
.VarInfo
.append(uefi_var
)
64 def SetVpdRegionMaxSize(self
,maxsize
):
65 self
.VpdRegionSize
= maxsize
67 def SetVpdRegionOffset(self
,vpdoffset
):
68 self
.VpdRegionOffset
= vpdoffset
70 def PatchNVStoreDefaultMaxSize(self
,maxsize
):
71 if not self
.NVHeaderBuff
:
73 self
.NVHeaderBuff
= self
.NVHeaderBuff
[:8] + pack("=Q",maxsize
)
74 default_var_bin
= self
.format_data(self
.NVHeaderBuff
+ self
.VarDefaultBuff
+ self
.VarDeltaBuff
)
76 default_var_bin_strip
= [ data
.strip("""'""") for data
in default_var_bin
]
77 value_str
+= ",".join(default_var_bin_strip
)
80 def combine_variable(self
):
81 indexedvarinfo
= collections
.OrderedDict()
82 for item
in self
.VarInfo
:
83 if (item
.skuname
,item
.defaultstoragename
, item
.var_name
,item
.var_guid
) not in indexedvarinfo
:
84 indexedvarinfo
[(item
.skuname
,item
.defaultstoragename
, item
.var_name
,item
.var_guid
) ] = []
85 indexedvarinfo
[(item
.skuname
,item
.defaultstoragename
, item
.var_name
,item
.var_guid
)].append(item
)
86 for key
in indexedvarinfo
:
87 sku_var_info_offset_list
= indexedvarinfo
[key
]
88 if len(sku_var_info_offset_list
) == 1:
91 for item
in sku_var_info_offset_list
:
92 data_type
= item
.data_type
93 value_list
= item
.default_value
.strip("{").strip("}").split(",")
94 if data_type
in DataType
.TAB_PCD_NUMERIC_TYPES
:
95 if data_type
== ["BOOLEAN", DataType
.TAB_UINT8
]:
97 elif data_type
== DataType
.TAB_UINT16
:
99 elif data_type
== DataType
.TAB_UINT32
:
101 elif data_type
== DataType
.TAB_UINT64
:
105 for data_byte
in pack(data_flag
,int(data
,16) if data
.upper().startswith('0X') else int(data
)):
106 value_list
+= [hex(unpack("B",data_byte
)[0])]
107 newvalue
[int(item
.var_offset
,16) if item
.var_offset
.upper().startswith("0X") else int(item
.var_offset
)] = value_list
109 newvaluestr
= "{" + ",".join(self
.assemble_variable(newvalue
)) +"}"
111 EdkLogger
.error("build", AUTOGEN_ERROR
, "Variable offset conflict in PCDs: %s \n" % (" and ".join([item
.pcdname
for item
in sku_var_info_offset_list
])))
112 n
= sku_var_info_offset_list
[0]
113 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
)]
114 self
.VarInfo
= [item
[0] for item
in indexedvarinfo
.values()]
116 def assemble_variable(self
, valuelist
):
117 ordered_offset
= sorted(valuelist
.keys())
118 ordered_value
= [valuelist
[k
] for k
in ordered_offset
]
121 for offset
in ordered_offset
:
122 if offset
< len(var_value
):
124 for _
in xrange(offset
- len(var_value
)):
125 var_value
.append('0x00')
126 var_value
+= ordered_value
[num
]
129 def process_variable_data(self
):
131 var_data
= collections
.defaultdict(collections
.OrderedDict
)
133 indexedvarinfo
= collections
.OrderedDict()
134 for item
in self
.VarInfo
:
135 if item
.pcdindex
not in indexedvarinfo
:
136 indexedvarinfo
[item
.pcdindex
] = dict()
137 indexedvarinfo
[item
.pcdindex
][(item
.skuname
,item
.defaultstoragename
)] = item
139 for index
in indexedvarinfo
:
140 sku_var_info
= indexedvarinfo
[index
]
142 default_data_buffer
= ""
143 others_data_buffer
= ""
145 default_sku_default
= indexedvarinfo
.get(index
).get((DataType
.TAB_DEFAULT
,DataType
.TAB_DEFAULT_STORES_DEFAULT
))
147 if default_sku_default
.data_type
not in DataType
.TAB_PCD_NUMERIC_TYPES
:
148 var_max_len
= max([len(var_item
.default_value
.split(",")) for var_item
in sku_var_info
.values()])
149 if len(default_sku_default
.default_value
.split(",")) < var_max_len
:
150 tail
= ",".join([ "0x00" for i
in range(var_max_len
-len(default_sku_default
.default_value
.split(",")))])
152 default_data_buffer
= self
.PACK_VARIABLES_DATA(default_sku_default
.default_value
,default_sku_default
.data_type
,tail
)
154 default_data_array
= ()
155 for item
in default_data_buffer
:
156 default_data_array
+= unpack("B",item
)
158 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
)])
160 for (skuid
,defaultstoragename
) in indexedvarinfo
.get(index
):
162 if (skuid
,defaultstoragename
) == (DataType
.TAB_DEFAULT
,DataType
.TAB_DEFAULT_STORES_DEFAULT
):
164 other_sku_other
= indexedvarinfo
.get(index
).get((skuid
,defaultstoragename
))
166 if default_sku_default
.data_type
not in DataType
.TAB_PCD_NUMERIC_TYPES
:
167 if len(other_sku_other
.default_value
.split(",")) < var_max_len
:
168 tail
= ",".join([ "0x00" for i
in range(var_max_len
-len(other_sku_other
.default_value
.split(",")))])
170 others_data_buffer
= self
.PACK_VARIABLES_DATA(other_sku_other
.default_value
,other_sku_other
.data_type
,tail
)
172 others_data_array
= ()
173 for item
in others_data_buffer
:
174 others_data_array
+= unpack("B",item
)
176 data_delta
= self
.calculate_delta(default_data_array
, others_data_array
)
178 var_data
[(skuid
,defaultstoragename
)][index
] = (data_delta
,sku_var_info
[(skuid
,defaultstoragename
)])
181 def new_process_varinfo(self
):
182 self
.combine_variable()
184 var_data
= self
.process_variable_data()
189 pcds_default_data
= var_data
.get((DataType
.TAB_DEFAULT
,DataType
.TAB_DEFAULT_STORES_DEFAULT
),{})
190 NvStoreDataBuffer
= ""
191 var_data_offset
= collections
.OrderedDict()
192 offset
= NvStorageHeaderSize
193 for default_data
,default_info
in pcds_default_data
.values():
194 var_name_buffer
= self
.PACK_VARIABLE_NAME(default_info
.var_name
)
196 vendorguid
= default_info
.var_guid
.split('-')
198 if default_info
.var_attribute
:
199 var_attr_value
,_
= VariableAttributes
.GetVarAttributes(default_info
.var_attribute
)
201 var_attr_value
= 0x07
203 DataBuffer
= self
.AlignData(var_name_buffer
+ default_data
)
205 data_size
= len(DataBuffer
)
206 offset
+= VariableHeaderSize
+ len(default_info
.var_name
.split(","))
207 var_data_offset
[default_info
.pcdindex
] = offset
208 offset
+= data_size
- len(default_info
.var_name
.split(","))
210 var_header_buffer
= self
.PACK_VARIABLE_HEADER(var_attr_value
, len(default_info
.var_name
.split(",")), len (default_data
), vendorguid
)
211 NvStoreDataBuffer
+= (var_header_buffer
+ DataBuffer
)
213 variable_storage_header_buffer
= self
.PACK_VARIABLE_STORE_HEADER(len(NvStoreDataBuffer
) + 28)
215 nv_default_part
= self
.AlignData(self
.PACK_DEFAULT_DATA(0, 0, self
.unpack_data(variable_storage_header_buffer
+NvStoreDataBuffer
)), 8)
217 data_delta_structure_buffer
= ""
218 for skuname
,defaultstore
in var_data
:
219 if (skuname
,defaultstore
) == (DataType
.TAB_DEFAULT
,DataType
.TAB_DEFAULT_STORES_DEFAULT
):
221 pcds_sku_data
= var_data
.get((skuname
,defaultstore
))
223 for pcdindex
in pcds_sku_data
:
224 offset
= var_data_offset
[pcdindex
]
225 delta_data
,_
= pcds_sku_data
[pcdindex
]
226 delta_data
= [(item
[0] + offset
, item
[1]) for item
in delta_data
]
227 delta_data_set
.extend(delta_data
)
229 data_delta_structure_buffer
+= self
.AlignData(self
.PACK_DELTA_DATA(skuname
,defaultstore
,delta_data_set
), 8)
231 size
= len(nv_default_part
+ data_delta_structure_buffer
) + 16
232 maxsize
= self
.VpdRegionSize
if self
.VpdRegionSize
else size
233 NV_Store_Default_Header
= self
.PACK_NV_STORE_DEFAULT_HEADER(size
,maxsize
)
235 self
.NVHeaderBuff
= NV_Store_Default_Header
236 self
.VarDefaultBuff
=nv_default_part
237 self
.VarDeltaBuff
= data_delta_structure_buffer
238 return self
.format_data(NV_Store_Default_Header
+ nv_default_part
+ data_delta_structure_buffer
)
241 def format_data(self
,data
):
243 return [hex(item
) for item
in self
.unpack_data(data
)]
245 def unpack_data(self
,data
):
248 final_data
+= unpack("B",item
)
251 def calculate_delta(self
, default
, theother
):
252 if len(default
) - len(theother
) != 0:
253 EdkLogger
.error("build", FORMAT_INVALID
, 'The variable data length is not the same for the same PCD.')
255 for i
in range(len(default
)):
256 if default
[i
] != theother
[i
]:
257 data_delta
.append((i
,theother
[i
]))
262 default_var_bin
= self
.new_process_varinfo()
265 default_var_bin_strip
= [ data
.strip("""'""") for data
in default_var_bin
]
266 value_str
+= ",".join(default_var_bin_strip
)
271 def PACK_VARIABLE_STORE_HEADER(self
,size
):
272 #Signature: gEfiVariableGuid
273 Guid
= "{ 0xddcf3616, 0x3275, 0x4164, { 0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d }}"
274 Guid
= GuidStructureStringToGuidString(Guid
)
275 GuidBuffer
= PackGUID(Guid
.split('-'))
277 SizeBuffer
= pack('=L',size
)
278 FormatBuffer
= pack('=B',0x5A)
279 StateBuffer
= pack('=B',0xFE)
280 reservedBuffer
= pack('=H',0)
281 reservedBuffer
+= pack('=L',0)
283 return GuidBuffer
+ SizeBuffer
+ FormatBuffer
+ StateBuffer
+ reservedBuffer
285 def PACK_NV_STORE_DEFAULT_HEADER(self
,size
,maxsize
):
286 Signature
= pack('=B',ord('N'))
287 Signature
+= pack("=B",ord('S'))
288 Signature
+= pack("=B",ord('D'))
289 Signature
+= pack("=B",ord('B'))
291 SizeBuffer
= pack("=L",size
)
292 MaxSizeBuffer
= pack("=Q",maxsize
)
294 return Signature
+ SizeBuffer
+ MaxSizeBuffer
296 def PACK_VARIABLE_HEADER(self
,attribute
,namesize
,datasize
,vendorguid
):
298 Buffer
= pack('=H',0x55AA) # pack StartID
299 Buffer
+= pack('=B',0x3F) # pack State
300 Buffer
+= pack('=B',0) # pack reserved
302 Buffer
+= pack('=L',attribute
)
303 Buffer
+= pack('=L',namesize
)
304 Buffer
+= pack('=L',datasize
)
306 Buffer
+= PackGUID(vendorguid
)
310 def PACK_VARIABLES_DATA(self
, var_value
,data_type
, tail
= None):
313 if data_type
== DataType
.TAB_VOID
:
314 for value_char
in var_value
.strip("{").strip("}").split(","):
315 Buffer
+= pack("=B",int(value_char
,16))
316 data_len
+= len(var_value
.split(","))
318 for value_char
in tail
.split(","):
319 Buffer
+= pack("=B",int(value_char
,16))
320 data_len
+= len(tail
.split(","))
321 elif data_type
== "BOOLEAN":
322 Buffer
+= pack("=B",True) if var_value
.upper() == "TRUE" else pack("=B",False)
324 elif data_type
== DataType
.TAB_UINT8
:
325 Buffer
+= pack("=B",GetIntegerValue(var_value
))
327 elif data_type
== DataType
.TAB_UINT16
:
328 Buffer
+= pack("=H",GetIntegerValue(var_value
))
330 elif data_type
== DataType
.TAB_UINT32
:
331 Buffer
+= pack("=L",GetIntegerValue(var_value
))
333 elif data_type
== DataType
.TAB_UINT64
:
334 Buffer
+= pack("=Q",GetIntegerValue(var_value
))
339 def PACK_DEFAULT_DATA(self
, defaultstoragename
,skuid
,var_value
):
341 Buffer
+= pack("=L",4+8+8)
342 Buffer
+= pack("=Q",int(skuid
))
343 Buffer
+= pack("=Q",int(defaultstoragename
))
345 for item
in var_value
:
346 Buffer
+= pack("=B",item
)
348 Buffer
= pack("=L",len(Buffer
)+4) + Buffer
352 def GetSkuId(self
,skuname
):
353 if skuname
not in self
.SkuIdMap
:
355 return self
.SkuIdMap
.get(skuname
)[0]
356 def GetDefaultStoreId(self
,dname
):
357 if dname
not in self
.DefaultStoreMap
:
359 return self
.DefaultStoreMap
.get(dname
)[0]
360 def PACK_DELTA_DATA(self
,skuname
,defaultstoragename
,delta_list
):
361 skuid
= self
.GetSkuId(skuname
)
362 defaultstorageid
= self
.GetDefaultStoreId(defaultstoragename
)
364 Buffer
+= pack("=L",4+8+8)
365 Buffer
+= pack("=Q",int(skuid
))
366 Buffer
+= pack("=Q",int(defaultstorageid
))
367 for (delta_offset
,value
) in delta_list
:
368 Buffer
+= pack("=L",delta_offset
)
369 Buffer
= Buffer
[:-1] + pack("=B",value
)
371 Buffer
= pack("=L",len(Buffer
) + 4) + Buffer
375 def AlignData(self
,data
, align
= 4):
377 if (len(data
) % align
) > 0:
378 for i
in range(align
- (len(data
) % align
)):
379 mybuffer
+= pack("=B",0)
383 def PACK_VARIABLE_NAME(self
, var_name
):
385 for name_char
in var_name
.strip("{").strip("}").split(","):
386 Buffer
+= pack("=B",int(name_char
,16))