170461 2017-04-04 11:38:13 -0700 webkitpy: Add apple_additions to webkitpy to insert Internal tools 2017-04-28 18:06:32 -0700 1 1 1 Unclassified WebKit Tools / Tests WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 jbedard jbedard ap buildbot commit-queue dbates glenn lforschler webkit-bug-importer oldest_to_newest 1294085 0 jbedard 2017-04-04 11:38:13 -0700 Add the AppleAdditions class to webkitpy to allow Internal tools to be used from webkitpy. Provide needed hooks for on-device testing. 1294089 1 306183 jbedard 2017-04-04 11:41:57 -0700 Created attachment 306183 Patch 1294090 2 webkit-bug-importer 2017-04-04 11:42:19 -0700 <rdar://problem/31433077> 1294157 3 dbates 2017-04-04 14:07:27 -0700 The proposed patch exposes safaripy and a dependency on its organization. This approach is not consistent with the approach I discussed with you most recently two weeks ago. In that discussion I suggested that we assume that the AppleInternalAdditions module be in the Python module search path (PYTHONPATH) and using a try/catch to try to load the module. The benefit of this approach is that we avoid making webkitpy dpeendent on safaripy or the hierarchy of safaripy. What issue(s) did you run into that led you to your proposed patch? 1294163 4 dbates 2017-04-04 14:12:57 -0700 My proposal also did not need to introduce DefaultAppleAdditions. I suggested using the existence of the module as a means to trigger a different code path. 1294492 5 jbedard 2017-04-05 08:21:54 -0700 (In reply to Daniel Bates from comment #3) > ... This would require changing how import paths work in safaripy, as all files assume the import path starts in the folder containing safaripy. There is a work-around for this, but it would require modifying the system path in the internal code in a way I would consider undesirable. The stub methods provided in this patch encapsulate the specifics of importing this optional module. I used this technique to ensure that the insertion of the Apple Additions only needs occur in a single place. These stub methods also allow WebKit developers to clearly see which functionality the Apple Additions module will be providing. 1294944 6 dbates 2017-04-06 10:32:10 -0700 (In reply to Jonathan Bedard from comment #5) > (In reply to Daniel Bates from comment #3) > > ... > > This would require changing how import paths work in safaripy, as all files > assume the import path starts in the folder containing safaripy. There is a > work-around for this, but it would require modifying the system path in the > internal code in a way I would consider undesirable. Can we solve this issue by adding safaripy to PYTHONPATH? > > The stub methods provided in this patch encapsulate the specifics of > importing this optional module. I do not see the need for such stubs. I elaborate further below. > I used this technique to ensure that the insertion of the Apple Additions only needs occur in a single place. We can accomplish the same goal by defining a free function in webkitpy/config/config.py, say have_apple_internal_additions(), that checks if the module AppleInternalAdditions was loaded or tries to load it. Something like: @memoized def have_apple_internal_additions(): if 'AppleInternalAdditions' in sys.modules: return True try: module = __import__('AppleInternalAdditions', globals(), locals(), [ ], 0) # Absolute import globals()[module.__name__] = module except ImportError: return False return True (*) Then code that needs to make use of the AppleInternalModule will look like: if config.have_apple_internal_additions(): AppleInternalAdditions.some_internal_function() If we are worried about polluting the global namespace with AppleInternalAdditions (I am not worried; should I be worried?) then we could rename and modify have_apple_internal_additions() return a module object instead of a boolean result. > These stub methods also allow WebKit developers to clearly see which functionality > the Apple Additions module will be providing. This is unnecessary using the approach I described to you in person two weeks ago and by (*). Looking at call sites like (*) it will be obvious to a reader what function/constant that needs to be implemented and the syntax used in (*) means that a reader can find all the functions/constants that need to be implemented by searching the code for "AppleInternalAdditions". Moreover having stub functions/constants and using the AppleInternalAdditions loading approach in the proposed patch (attachment 306183) is error prone for Apple engineers that work on the Python code because they will need to remember to always add a stub function/constant corresponding to a function/constant added to AppleInternalAdditions or the Open Source implementation will break (if one ever manifests itself). Should an Open Source replacement of AppleInternalAdditions be attempted I expect it will manifest as just that, a replacement. That is, code that calls AppleInternalAdditions will be replaced with code that lives in webkitpy. Such replacement can be done (as in coded and enabled by default immediately) iteratively when the code is structured as in (*) as opposed to the all-or-nothing approach in the proposed patch (since switching Apple engineers to the Open Source code requires removing the logic to load the AppleInternalAdditions module and this would not be attempted until all functionality is replaced - a difficult task for an Open Source contributor). Therefore, the stubs methods do not provide any benefit and hamper a future Open Source replacement. 1295030 7 jbedard 2017-04-06 13:57:16 -0700 (In reply to Daniel Bates from comment #6) > (In reply to Jonathan Bedard from comment #5) > > (In reply to Daniel Bates from comment #3) > > > ... > > > > This would require changing how import paths work in safaripy, as all files > > assume the import path starts in the folder containing safaripy. There is a > > work-around for this, but it would require modifying the system path in the > > internal code in a way I would consider undesirable. > > Can we solve this issue by adding safaripy to PYTHONPATH? > In short, no. Adding safaripy to PYTHONPATH would mean that import paths for modules from safaripy would start in safaripy as opposed to the directory containing safaripy, which is where they should start. Instead, the provided approach adds the directory containing safaripy to PYTHONPATH, that way all imports from webkitpy or safaripy will be of the form: import <toplevel>.<file> import <toplevel>.<directory>.<file> where <toplevel> is either webkitpy or safaripy. Adding safaripy to PYTHONPATH would break this structure. The breakage does not occur in this file, but rather, the files which this file imports. > > ... > > > We can accomplish the same goal by defining a free function in > webkitpy/config/config.py, say have_apple_internal_additions(), that checks > if the module AppleInternalAdditions was loaded or tries to load it. > Something like: > > @memoized > def have_apple_internal_additions(): > if 'AppleInternalAdditions' in sys.modules: > return True > try: > module = __import__('AppleInternalAdditions', globals(), locals(), [ > ], 0) # Absolute import > globals()[module.__name__] = module > except ImportError: > return False > return True > > (*) Then code that needs to make use of the AppleInternalModule will look > like: > > if config.have_apple_internal_additions(): > AppleInternalAdditions.some_internal_function() I don't think the verbose version of import is needed. If the correct directory is in the system path, a try/except should be sufficient. My understanding is that __import__ is used when the module which needs to be imported is defined by a variable. > If we are worried about polluting the global namespace with > AppleInternalAdditions (I am not worried; should I be worried?) then we > could rename and modify have_apple_internal_additions() return a module > object instead of a boolean result. > > > These stub methods also allow WebKit developers to clearly see which functionality > > the Apple Additions module will be providing. > > This is unnecessary using the approach I described to you in person two > weeks ago and by (*). Looking at call sites like (*) it will be obvious to a > reader what function/constant that needs to be implemented and the syntax > used in (*) means that a reader can find all the functions/constants that > need to be implemented by searching the code for "AppleInternalAdditions". > Moreover having stub functions/constants and using the > AppleInternalAdditions loading approach in the proposed patch (attachment > 306183 [details]) is error prone for Apple engineers that work on the Python > code because they will need to remember to always add a stub > function/constant corresponding to a function/constant added to > AppleInternalAdditions or the Open Source implementation will break (if one > ever manifests itself). Should an Open Source replacement of > AppleInternalAdditions be attempted I expect it will manifest as just that, > a replacement. That is, code that calls AppleInternalAdditions will be > replaced with code that lives in webkitpy. Such replacement can be done (as > in coded and enabled by default immediately) iteratively when the code is > structured as in (*) as opposed to the all-or-nothing approach in the > proposed patch (since switching Apple engineers to the Open Source code > requires removing the logic to load the AppleInternalAdditions module and > this would not be attempted until all functionality is replaced - a > difficult task for an Open Source contributor). Therefore, the stubs methods > do not provide any benefit and hamper a future Open Source replacement. I think you bring up a good point here about fragility. I will upload a cleaner version of this change which removes stub functions and defines AppleAdditions as a module instead of a static class contained in a module. My version will be less verbose then some of the code you've suggested, as I think Python allows for this to be done more succinctly. 1295037 8 306425 jbedard 2017-04-06 14:12:05 -0700 Created attachment 306425 Patch 1295045 9 dbates 2017-04-06 14:26:15 -0700 (In reply to Jonathan Bedard from comment #7) > (In reply to Daniel Bates from comment #6) > > (In reply to Jonathan Bedard from comment #5) > > > (In reply to Daniel Bates from comment #3) > > > > ... > > > > > > This would require changing how import paths work in safaripy, as all files > > > assume the import path starts in the folder containing safaripy. There is a > > > work-around for this, but it would require modifying the system path in the > > > internal code in a way I would consider undesirable. > > > > Can we solve this issue by adding safaripy to PYTHONPATH? > > > > In short, no. Adding safaripy to PYTHONPATH would mean that import paths > for modules from safaripy would start in safaripy as opposed to the > directory containing safaripy, which is where they should start. I meant to ask: Can we solve this issue by adding the directory containing safaripy to PYTHONPATH? And to be clear I mean that the caller of run-webkit-tests sets up such a PYTHONPATH. > Instead, the provided approach adds the directory containing safaripy to PYTHONPATH, > that way all imports from webkitpy or safaripy will be of the form: > Where? > import <toplevel>.<file> > import <toplevel>.<directory>.<file> > > where <toplevel> is either webkitpy or safaripy. Adding safaripy to > PYTHONPATH would break this structure. The breakage does not occur in this > file, but rather, the files which this file imports. > > > > > ... > > > > > > We can accomplish the same goal by defining a free function in > > webkitpy/config/config.py, say have_apple_internal_additions(), that checks > > if the module AppleInternalAdditions was loaded or tries to load it. > > Something like: > > > > @memoized > > def have_apple_internal_additions(): > > if 'AppleInternalAdditions' in sys.modules: > > return True > > try: > > module = __import__('AppleInternalAdditions', globals(), locals(), [ > > ], 0) # Absolute import > > globals()[module.__name__] = module > > except ImportError: > > return False > > return True > > > > (*) Then code that needs to make use of the AppleInternalModule will look > > like: > > > > if config.have_apple_internal_additions(): > > AppleInternalAdditions.some_internal_function() > > I don't think the verbose version of import is needed. If the correct > directory is in the system path, a try/except should be sufficient. My > understanding is that __import__ is used when the module which needs to be > imported is defined by a variable. Notice that I am importing AppleInternalAdditions from a function into the global namespace. The scope of a function defines a local namespace and the import statement imports into the namespace it is invoked in. So, calling import from inside the function will import the namespace defined by the function. But I want to import AppleInternalAdditions into the global namespace. From reading the documentation, this can be done using __import__() or importlib.import_module(). I chose the former because it does not require importing another module, importlib, and it allows me to force absolute path importing instead of relative path importing to make the code less error prone in the unlikely event that 'AppleInternalAdditions' be changed to a relative path, which it should never be changed to because we are assuming it can be found in PYTHONPATH. 1295047 10 dbates 2017-04-06 14:27:16 -0700 (In reply to Daniel Bates from comment #9) > (In reply to Jonathan Bedard from comment #7) > > (In reply to Daniel Bates from comment #6) > > > (In reply to Jonathan Bedard from comment #5) > > > > (In reply to Daniel Bates from comment #3) > > > > > ... > > > > > > > > This would require changing how import paths work in safaripy, as all files > > > > assume the import path starts in the folder containing safaripy. There is a > > > > work-around for this, but it would require modifying the system path in the > > > > internal code in a way I would consider undesirable. > > > > > > Can we solve this issue by adding safaripy to PYTHONPATH? > > > > > > > In short, no. Adding safaripy to PYTHONPATH would mean that import paths > > for modules from safaripy would start in safaripy as opposed to the > > directory containing safaripy, which is where they should start. > > I meant to ask: > > Can we solve this issue by adding the directory containing safaripy to > PYTHONPATH? You already answered this question. It would work. 1295062 11 306425 dbates 2017-04-06 14:47:28 -0700 Comment on attachment 306425 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=306425&action=review > Tools/Scripts/webkitpy/common/apple_additions.py:26 > +try: > + import safaripy.apple_additions as AppleAdditions > +except ImportError: > + AppleAdditions = None This still exposes unnecessary details about safaripy and it is weird semantically that even if a file imports this module (as seen on line 39 of factory.py) that accessing the module, AppleAdditions, may return None. 1295084 12 jbedard 2017-04-06 15:47:06 -0700 (In reply to Daniel Bates from comment #10) > (In reply to Daniel Bates from comment #9) > > (In reply to Jonathan Bedard from comment #7) > > > (In reply to Daniel Bates from comment #6) > > > > (In reply to Jonathan Bedard from comment #5) > > > > > (In reply to Daniel Bates from comment #3) > > > > > > ... > > > > > > > > > > This would require changing how import paths work in safaripy, as all files > > > > > assume the import path starts in the folder containing safaripy. There is a > > > > > work-around for this, but it would require modifying the system path in the > > > > > internal code in a way I would consider undesirable. > > > > > > > > Can we solve this issue by adding safaripy to PYTHONPATH? > > > > > > > > > > In short, no. Adding safaripy to PYTHONPATH would mean that import paths > > > for modules from safaripy would start in safaripy as opposed to the > > > directory containing safaripy, which is where they should start. > > > > I meant to ask: > > > > Can we solve this issue by adding the directory containing safaripy to > > PYTHONPATH? > > > You already answered this question. It would work. So yes, adding both paths to the PYTHONPATH would allow everything to work. But having both of these techniques seems very wrong. When we add safaripy to the PYTHONPATH, we're essentially throwing out the established scoping pattern already used in webkitpy. I don't see a good reason to break the organizational assumptions of the project just to leave out 'safaripy.' 1295087 13 jbedard 2017-04-06 15:48:50 -0700 (In reply to Daniel Bates from comment #9) > (In reply to Jonathan Bedard from comment #7) > > Instead, the provided approach adds the directory containing safaripy to PYTHONPATH, > > that way all imports from webkitpy or safaripy will be of the form: > > > > Where? > This should read: Instead, the provided approach assumes the directory containing safaripy is in the PYTHONPATH Sorry for the confusion. 1295099 14 jbedard 2017-04-06 16:11:43 -0700 (In reply to Daniel Bates from comment #11) > Comment on attachment 306425 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=306425&action=review > > > Tools/Scripts/webkitpy/common/apple_additions.py:26 > > +try: > > + import safaripy.apple_additions as AppleAdditions > > +except ImportError: > > + AppleAdditions = None > > This still exposes unnecessary details about safaripy and it is weird > semantically that even if a file imports this module (as seen on line 39 of > factory.py) that accessing the module, AppleAdditions, may return None. Your right that this isn't an idiom we currently use since we don't have optional imports. But this seems like the most Pythonic way to do this. We could (as you suggest) export the module to the global namespace. But I don't think that is an intuitive way to achieve an optional module, it would break break IDEs and decrease code readability in the places the global module is used. It seems better to explicitly pass an optional module as 'None.' It will be very obvious when it is used that it is undefined and it will also be obvious why it is undefined. 1295106 15 dbates 2017-04-06 16:40:18 -0700 (In reply to Jonathan Bedard from comment #12) > (In reply to Daniel Bates from comment #10) > > (In reply to Daniel Bates from comment #9) > > > (In reply to Jonathan Bedard from comment #7) > > > > (In reply to Daniel Bates from comment #6) > > > > > (In reply to Jonathan Bedard from comment #5) > > > > > > (In reply to Daniel Bates from comment #3) > > > > > > > ... > > > > > > > > > > > > This would require changing how import paths work in safaripy, as all files > > > > > > assume the import path starts in the folder containing safaripy. There is a > > > > > > work-around for this, but it would require modifying the system path in the > > > > > > internal code in a way I would consider undesirable. > > > > > > > > > > Can we solve this issue by adding safaripy to PYTHONPATH? > > > > > > > > > > > > > In short, no. Adding safaripy to PYTHONPATH would mean that import paths > > > > for modules from safaripy would start in safaripy as opposed to the > > > > directory containing safaripy, which is where they should start. > > > > > > I meant to ask: > > > > > > Can we solve this issue by adding the directory containing safaripy to > > > PYTHONPATH? > > > > > > You already answered this question. It would work. > > So yes, adding both paths to the PYTHONPATH would allow everything to work. > > But having both of these techniques seems very wrong. When we add safaripy > to the PYTHONPATH, we're essentially throwing out the established scoping > pattern already used in webkitpy. The "established scoping pattern" is an artifact of how module importation in Python works, effectively forcing what we have today: a directory, webkitpy, that contains all-the-code. (E.g. There is no logical reason for webkitpy to contain multiple main() entry points for tools, including run-webkit-tests and webkit-patch, other than because the way Python supports importing makes it simpler to share Python code if it is all under a single rooted hierarchy than if it were not). The safaripy code is explicitly not in the Open Source tree (maybe one day it could be, but likely there will always be a reasons that is cannot be) and it should be treated analogous to a system module, disjoint. We should not put up a facade to make safaripy fit into the webkitpy scoping pattern. > I don't see a good reason to break the organizational assumptions of the project just to leave out 'safaripy.' The organization assumptions are not logical and are largely forced upon us as an artifact of how importing works in Python. I give an example of how our current organization is illogical (above) with respect to run-webkit-tests and webkit-patch. 1295389 16 jbedard 2017-04-07 10:59:13 -0700 (In reply to Daniel Bates from comment #15) > (In reply to Jonathan Bedard from comment #12) > > (In reply to Daniel Bates from comment #10) > > > (In reply to Daniel Bates from comment #9) > > > > (In reply to Jonathan Bedard from comment #7) > > > > > (In reply to Daniel Bates from comment #6) > > > > > > (In reply to Jonathan Bedard from comment #5) > > > > > > > (In reply to Daniel Bates from comment #3) > ... > > The "established scoping pattern" is an artifact of how module importation > in Python works, effectively forcing what we have today: a directory, > webkitpy, that contains all-the-code. (E.g. There is no logical reason for > webkitpy to contain multiple main() entry points for tools, including > run-webkit-tests and webkit-patch, other than because the way Python > supports importing makes it simpler to share Python code if it is all under > a single rooted hierarchy than if it were not). The safaripy code is > explicitly not in the Open Source tree (maybe one day it could be, but > likely there will always be a reasons that is cannot be) and it should be > treated analogous to a system module, disjoint. We should not put up a > facade to make safaripy fit into the webkitpy scoping pattern. > > > I don't see a good reason to break the organizational assumptions of the project just to leave out 'safaripy.' > > The organization assumptions are not logical and are largely forced upon us > as an artifact of how importing works in Python. I give an example of how > our current organization is illogical (above) with respect to > run-webkit-tests and webkit-patch. Except that abandoning the scoping pattern means that we now have to be careful about how things are named. In fact, this change assumes that the module being imported form safaripy is apple_additions. It is currently being imported from apple_additions. If the line reads like this: import apple_additions as AppleAdditions as you are suggesting, Python will import the Open Source module as AppleAdditions, even if the PYTHONPATH is set correctly. We could rename things to avoid this conflict, or preform this import from a function. But the fact that this conflict could exist demonstrates that we should be using some sort of scoping to disambiguate the import. 1296763 17 306918 jbedard 2017-04-12 10:22:30 -0700 Created attachment 306918 Patch 1298326 18 307389 jbedard 2017-04-18 09:50:59 -0700 Created attachment 307389 Patch 1298327 19 jbedard 2017-04-18 09:51:49 -0700 After discussing with Dan in person yesterday, I've made some changes to how this import works. 1298483 20 dbates 2017-04-18 16:00:36 -0700 (In reply to Jonathan Bedard from comment #19) > After discussing with Dan in person yesterday, I've made some changes to how > this import works. This patch (attachment #307389) does not represent changes we discussed yesterday (04/17), which were in part a reiteration of my comments in this bug. In particular, this patch does not make use of the suggestions I gave in comment #6. And no explanation for such divergence has been given. 1298526 21 307442 jbedard 2017-04-18 17:26:24 -0700 Created attachment 307442 Patch 1298527 22 jbedard 2017-04-18 17:40:14 -0700 This patch (attachment 307442) has brought this import more along the lines of what Dan suggested, although, there are some differences (namely, this patch still isn't using the global namespace) and some possible scoping issues. This patch doesn't use the global namespace because I think that approach is confusing. Instead, places which use this function access the package returned by the function directly, I think this is more clear. Using the __import__() call instead of the import call means that we are targeting absolute paths only, an apple_additions module or package sitting in webkitpy/port will not be loaded. However, if an apple_additions module or package is sitting next to the entry point, this will always be loaded over one in another directory on the system path. This indicates a larger issue with the architecture of webkitpy. Lastly, this change implements the device polling and access on the apple_additions level instead of the IOSDeviceDelegate level. I'm not sure this is the best place for this. While these functions operate on global objects, they will only be used in the context of the iOSDevicePort. 1302312 23 308451 jbedard 2017-04-27 14:51:55 -0700 Created attachment 308451 Patch 1302315 24 jbedard 2017-04-27 14:53:29 -0700 Some changes to apple_additions have changed the interface required in webkitpy. I don't think the IOSDeviceDelegate is the correct way to implement this anymore. Apple additions should provide all of the needed functions. 1302883 25 308451 dbates 2017-04-28 17:13:01 -0700 Comment on attachment 308451 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=308451&action=review > Tools/Scripts/webkitpy/port/config.py:61 > + return __import__('apple_additions', globals(), None, [], 0) I suggest that we use named parameters for all arguments except the first. We should explain the purpose of the last argument, 0, in a comment even if we use a named parameter calling style as the name of the last parameter, level, is not very meaningful. > Tools/Scripts/webkitpy/port/ios_device.py:55 > + return apple_additions().ios_device_driver() if apple_additions() else super(IOSDevicePort, self)._driver_class() Does it make sense to call the base class implementation if we do not have Apple Additions? I mean, would using the base class driver class ever work? If we need to call the base class implementation then I would write this as: if apple_additions(): return apple_additions().ios_device_driver() return super(IOSDevicePort, self)._driver_class() > Tools/Scripts/webkitpy/port/ios_device.py:60 > + iphoneos_sdk_version = host.platform.xcode_sdk_version(IOSDevicePort.SDK) I suggest that we access the SDK class variable using the argument cls instead of hardcoding the class name. The benefit of doing this is the same as the benefit of using super() to call the base class implementation. > Tools/Scripts/webkitpy/port/ios_device.py:67 > + # FIXME: These need device implementations <rdar://problem/30497991> Minor: Missing period at the end of this sentence. > Tools/Scripts/webkitpy/port/ios_device.py:82 > + return ['--sdk', IOSDevicePort.SDK] + (['ARCHS=%s' % self.architecture()] if self.architecture() else []) Ditto. > Tools/Scripts/webkitpy/port/ios_device.py:89 > + raise RuntimeError('On-device testing is not supported on this machine') We could move the runtime error string literal into a class variable and avoid the need to duplicate it here and in _device_for_worker_number_map(). > Tools/Scripts/webkitpy/port/ios_device_unittest.py:40 > + # FIXME: Update tests when <rdar://problem/30497991> is completed Minor: Missing a period at the end of this sentence. 1302894 26 308627 jbedard 2017-04-28 17:25:32 -0700 Created attachment 308627 Patch for landing 1302920 27 308627 commit-queue 2017-04-28 18:06:30 -0700 Comment on attachment 308627 Patch for landing Clearing flags on attachment: 308627 Committed r215965: <http://trac.webkit.org/changeset/215965> 1302921 28 commit-queue 2017-04-28 18:06:32 -0700 All reviewed patches have been landed. Closing bug. 306183 2017-04-04 11:41:57 -0700 2017-04-06 14:12:04 -0700 Patch bug-170461-20170404114156.patch text/plain 10531 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNDg4NSkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDQ0IEBACisyMDE3LTA0LTA0ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIEFwcGxlQWRkaXRpb25zIHRvIHdlYmtpdHB5IHRv IGluc2VydCBJbnRlcm5hbCB0b29scworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTcwNDYxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgUHJvdmlkZSBob29rcyB0byBBcHBsZSBpbnRlcm5hbCBzY3JpcHRzIGFu ZCBwcm92aWRlIElPU0RldmljZVBvcnQgd2l0aCB0aGUKKyAgICAgICAgbmVlZGVkIGZ1bmN0aW9u YWxpdHkgZm9yIG9uLWRldmljZSB0ZXN0aW5nLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS9jb21tb24vYXBwbGVfYWRkaXRpb25zLnB5OiBBZGRlZC4KKyAgICAgICAgKERlZmF1bHRBcHBs ZUFkZGl0aW9ucyk6IFN0dWIgaW1wbGVtZW50YXRpb24gb2YgaG9va3MgZGVmaW5lZCBpbiBBcHBs ZSBpbnRlcm5hbC4KKyAgICAgICAgKERlZmF1bHRBcHBsZUFkZGl0aW9ucy5oYXNfYWRkaXRpb25z KToKKyAgICAgICAgKERlZmF1bHRBcHBsZUFkZGl0aW9ucy5wbGF0Zm9ybV9vcHRpb25zKTogQWRk aXRpb25hbCBwbGF0Zm9ybSBvcHRpb25zIHRvIGJlIGluc2VydGVkLgorICAgICAgICAoRGVmYXVs dEFwcGxlQWRkaXRpb25zLklPU0RldmljZURlbGVnYXRlKTogUHJvdmlkZXMgbmVlZGVkIEFwcGxl IGludGVybmFsCisgICAgICAgIGZ1bmN0aW9uYWxpdHkgdG8gSU9TRGV2aWNlUG9ydC4KKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvZGV2aWNlLnB5OgorICAgICAgICAoRGV2aWNlLnBy ZXBhcmVfZm9yX3Rlc3RpbmcpOiBQYXNzIGxpc3RlbmluZyBwb3J0IHRvIHNldHVwLgorICAgICAg ICAoRGV2aWNlLmZpbmlzaGVkX3Rlc3RpbmcpOiBDYWxsIGNvcnJlY3QgdGVhci1kb3duIGZ1bmN0 aW9uLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5OgorICAgICAg ICAocGxhdGZvcm1fb3B0aW9ucyk6IEluc2VydCBhZGRpdGlvbmFsIHBsYXRmb3JtIG9wdGlvbnMu CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2UucHk6CisgICAgICAg IChJT1NEZXZpY2VQb3J0KToKKyAgICAgICAgKElPU0RldmljZVBvcnQuX19pbml0X18pOgorICAg ICAgICAoSU9TRGV2aWNlUG9ydC5fZGV2aWNlX2Zvcl93b3JrZXJfbnVtYmVyX21hcCk6CisgICAg ICAgIChJT1NEZXZpY2VQb3J0Ll9kcml2ZXJfY2xhc3MpOgorICAgICAgICAoSU9TRGV2aWNlUG9y dC5kZXRlcm1pbmVfZnVsbF9wb3J0X25hbWUpOiBVc2UgU0RLIHZhcmlhYmxlLgorICAgICAgICAo SU9TRGV2aWNlUG9ydC5jaGVja19mb3JfbGVha3MpOiBObyBpbXBsZW1lbnRhdGlvbi4KKyAgICAg ICAgKElPU0RldmljZVBvcnQubG9va19mb3JfbmV3X2NyYXNoX2xvZ3MpOiBEaXR0by4KKyAgICAg ICAgKElPU0RldmljZVBvcnQubG9va19mb3JfbmV3X3NhbXBsZXMpOiBEaXR0by4KKyAgICAgICAg KElPU0RldmljZVBvcnQuc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElPU0Rldmlj ZVBvcnQuX2J1aWxkX2RyaXZlcl9mbGFncyk6IFVzZSBTREsgdmFyaWFibGUuCisgICAgICAgIChJ T1NEZXZpY2VQb3J0Ll9jcmVhdGVfZGV2aWNlcyk6CisgICAgICAgIChJT1NEZXZpY2VQb3J0LmNs ZWFuX3VwX3Rlc3RfcnVuKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2Rl dmljZV91bml0dGVzdC5weToKKyAgICAgICAgKElPU0RldmljZVRlc3QudGVzdF9vcGVyYXRpbmdf c3lzdGVtKToKKyAgICAgICAgKElPU0RldmljZVRlc3QpOgorICAgICAgICAoSU9TRGV2aWNlVGVz dC50ZXN0X3NwaW5kdW1wKTogTm8gaW1wbGVtZW50YXRpb24uCisgICAgICAgIChJT1NEZXZpY2VU ZXN0LnRlc3Rfc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElPU0RldmljZVRlc3Qu dGVzdF9zYW1wbGVfcHJvY2Vzc19leGNlcHRpb24pOiBEaXR0by4KKwogMjAxNy0wNC0wMyAgSm9z ZXBoIFBlY29yYXJvICA8cGVjb3Jhcm9AYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBzb21lIG5l dyBwYXR0ZXJucyB0byBmaWx0ZXItYnVpbGQtd2Via2l0CkluZGV4OiBUb29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi9hcHBsZV9hZGRpdGlvbnMucHkKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vYXBwbGVfYWRkaXRpb25zLnB5CShub25leGlzdGVudCkKKysr IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2FwcGxlX2FkZGl0aW9ucy5weQkod29ya2lu ZyBjb3B5KQpAQCAtMCwwICsxLDYxIEBACisjIENvcHlyaWdodCAoQykgMjAxNyBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyMgYXJl IG1ldDoKKyMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQorIyAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQKKyMgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUgor IyBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UiBDT05TRVFVRU5USUFMCisjIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SCisjIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS CisjIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksCisjIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisKK2Zyb20gd2Via2l0cHkucG9ydC5kcml2ZXIgaW1wb3J0IERyaXZlcgorCisKKyMg QWxsb3dzIEFwcGxlIHNwZWNpZmljIHRvb2xzIHRvIGJlIHRyYW5zcGFyZW50bHkgdXNlZCBpbiBP cGVuU291cmNlLgorY2xhc3MgRGVmYXVsdEFwcGxlQWRkaXRpb25zKG9iamVjdCk6CisKKyAgICBA c3RhdGljbWV0aG9kCisgICAgZGVmIGhhc19hZGRpdGlvbnMoKToKKyAgICAgICAgcmV0dXJuIEZh bHNlCisKKyAgICBAc3RhdGljbWV0aG9kCisgICAgZGVmIHBsYXRmb3JtX29wdGlvbnMoKToKKyAg ICAgICAgcmV0dXJuIFtdCisKKyAgICBjbGFzcyBJT1NEZXZpY2VEZWxlZ2F0ZShvYmplY3QpOgor CisgICAgICAgIFNESyA9ICdpcGhvbmVvcycKKyAgICAgICAgREVWSUNFX0RSSVZFUiA9IERyaXZl cgorCisgICAgICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0KToKKyAgICAgICAgICAgIHNlbGYu X3BvcnQgPSBwb3J0CisKKyAgICAgICAgQHN0YXRpY21ldGhvZAorICAgICAgICBkZWYgZGV2aWNl X21hcCgpOgorICAgICAgICAgICAgcmV0dXJuIHt9CisKKyAgICAgICAgZGVmIHBvbGxfZGV2aWNl cyhzZWxmKToKKyAgICAgICAgICAgIHBhc3MKKworICAgICAgICBkZWYgc2V0dXBfZGV2aWNlc19m b3JfYXV0b21hdGlvbihzZWxmKToKKyAgICAgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJy b3IKKworICAgICAgICBkZWYgdGVhcmRvd25fZGV2aWNlc19hZnRlcl9hdXRvbWF0aW9uKHNlbGYp OgorICAgICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcgorCit0cnk6CisgICAgZnJv bSBzYWZhcmlweS5hcHBsZV9hZGRpdGlvbnMgaW1wb3J0IEFwcGxlSW50ZXJuYWxBZGRpdGlvbnMg YXMgQXBwbGVBZGRpdGlvbnMKK2V4Y2VwdCBJbXBvcnRFcnJvcjoKKyAgICBBcHBsZUFkZGl0aW9u cyA9IERlZmF1bHRBcHBsZUFkZGl0aW9ucwpJbmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L2RldmljZS5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQv ZGV2aWNlLnB5CShyZXZpc2lvbiAyMTQ4ODEpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Bv cnQvZGV2aWNlLnB5CSh3b3JraW5nIGNvcHkpCkBAIC00NSwxMCArNDUsMTAgQEAgY2xhc3MgRGV2 aWNlKG9iamVjdCk6CiAgICAgICAgICAgICBzZWxmLmxpc3RlbmluZ19zb2NrZXQuYmluZCgoJzEy Ny4wLjAuMScsIDApKQogCiAgICAgICAgIGlmIGhhc2F0dHIoc2VsZi5wbGF0Zm9ybV9kZXZpY2Us ICdwcmVwYXJlX2Zvcl90ZXN0aW5nJyk6Ci0gICAgICAgICAgICBzZWxmLnBsYXRmb3JtX2Rldmlj ZS5wcmVwYXJlX2Zvcl90ZXN0aW5nKCkKKyAgICAgICAgICAgIHNlbGYucGxhdGZvcm1fZGV2aWNl LnByZXBhcmVfZm9yX3Rlc3RpbmcobGlzdGVuaW5nX3BvcnQ9c2VsZi5saXN0ZW5pbmdfcG9ydCgp KQogCiAgICAgZGVmIGZpbmlzaGVkX3Rlc3Rpbmcoc2VsZik6Ci0gICAgICAgIGlmIGhhc2F0dHIo c2VsZi5wbGF0Zm9ybV9kZXZpY2UsICd0ZWFyZG93bicpOgorICAgICAgICBpZiBoYXNhdHRyKHNl bGYucGxhdGZvcm1fZGV2aWNlLCAnZmluaXNoZWRfdGVzdGluZycpOgogICAgICAgICAgICAgc2Vs Zi5wbGF0Zm9ybV9kZXZpY2UuZmluaXNoZWRfdGVzdGluZygpCiAKICAgICAgICAgc2VsZi5saXN0 ZW5pbmdfc29ja2V0ID0gTm9uZQpJbmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2Zh Y3RvcnkucHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2ZhY3Rv cnkucHkJKHJldmlzaW9uIDIxNDg4MSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9m YWN0b3J5LnB5CSh3b3JraW5nIGNvcHkpCkBAIC0zNiw2ICszNiw3IEBAIGltcG9ydCByZQogCiBm cm9tIHdlYmtpdHB5LnBvcnQgaW1wb3J0IGJ1aWxkZXJzCiBmcm9tIHdlYmtpdHB5LnBvcnQgaW1w b3J0IGNvbmZpZworZnJvbSB3ZWJraXRweS5jb21tb24uYXBwbGVfYWRkaXRpb25zIGltcG9ydCBB cHBsZUFkZGl0aW9ucwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtIGltcG9ydCBleGVjdXRp dmUKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgZmlsZXN5c3RlbQogCkBAIC01 OSw3ICs2MCw3IEBAIGRlZiBwbGF0Zm9ybV9vcHRpb25zKHVzZV9nbG9icz1GYWxzZSk6CiAgICAg ICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKCctLW5vLWluc3RhbGwnLCBhY3Rpb249J3N0b3JlX2Nv bnN0JywKICAgICAgICAgICAgIGNvbnN0PUZhbHNlLCBkZWZhdWx0PVRydWUsIGRlc3Q9J2luc3Rh bGwnLAogICAgICAgICAgICAgaGVscD0nU2tpcCBpbnN0YWxsIHN0ZXAgZm9yIGRldmljZSBhbmQg c2ltdWxhdG9yIHRlc3RpbmcnKSwKLSAgICAgICAgXQorICAgICAgICBdICsgQXBwbGVBZGRpdGlv bnMucGxhdGZvcm1fb3B0aW9ucygpCiAKIAogZGVmIGNvbmZpZ3VyYXRpb25fb3B0aW9ucygpOgpJ bmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2UucHkKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2UucHkJKHJldmlzaW9u IDIxNDg4MSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5CSh3 b3JraW5nIGNvcHkpCkBAIC0yMiw2ICsyMiw3IEBACiAKIGltcG9ydCBsb2dnaW5nCiAKK2Zyb20g d2Via2l0cHkuY29tbW9uLmFwcGxlX2FkZGl0aW9ucyBpbXBvcnQgQXBwbGVBZGRpdGlvbnMKIGZy b20gd2Via2l0cHkucG9ydC5pb3MgaW1wb3J0IElPU1BvcnQKIAogX2xvZyA9IGxvZ2dpbmcuZ2V0 TG9nZ2VyKF9fbmFtZV9fKQpAQCAtMzMsMjAgKzM0LDYzIEBAIGNsYXNzIElPU0RldmljZVBvcnQo SU9TUG9ydCk6CiAgICAgQVJDSElURUNUVVJFUyA9IFsnYXJtdjcnLCAnYXJtdjdzJywgJ2FybTY0 J10KICAgICBERUZBVUxUX0FSQ0hJVEVDVFVSRSA9ICdhcm02NCcKICAgICBWRVJTSU9OX0ZBTExC QUNLX09SREVSID0gWydpb3MtNycsICdpb3MtOCcsICdpb3MtOScsICdpb3MtMTAnXQorICAgIFNE SyA9IEFwcGxlQWRkaXRpb25zLklPU0RldmljZURlbGVnYXRlLlNESworCisgICAgZGVmIF9faW5p dF9fKHNlbGYsIGhvc3QsIHBvcnRfbmFtZSwgKiprd2FyZ3MpOgorICAgICAgICBzdXBlcihJT1NE ZXZpY2VQb3J0LCBzZWxmKS5fX2luaXRfXyhob3N0LCBwb3J0X25hbWUsICoqa3dhcmdzKQorICAg ICAgICBzZWxmLl9kZXZpY2VfZGVsZWdhdGUgPSBBcHBsZUFkZGl0aW9ucy5JT1NEZXZpY2VEZWxl Z2F0ZShzZWxmKQorICAgICAgICBzZWxmLl9kZXZpY2VfZGVsZWdhdGUucG9sbF9kZXZpY2VzKCkK KyAgICAgICAgbnVtX2RldmljZXMgPSBsZW4oc2VsZi5fZGV2aWNlX2RlbGVnYXRlLmRldmljZV9t YXAoKSkKKyAgICAgICAgaWYgbnVtX2RldmljZXMgPT0gMToKKyAgICAgICAgICAgIHNlbGYuX2N1 cnJlbnRfZGV2aWNlID0gc2VsZi5fZGV2aWNlX2RlbGVnYXRlLmRldmljZV9tYXAoKVswXQorICAg ICAgICBlbGlmIG51bV9kZXZpY2VzIDw9IDA6CisgICAgICAgICAgICBudW1fZGV2aWNlcyA9IDEK KyAgICAgICAgc2VsZi5zZXRfb3B0aW9uKCdjaGlsZF9wcm9jZXNzZXMnLCBudW1fZGV2aWNlcykK KworICAgIGRlZiBfZGV2aWNlX2Zvcl93b3JrZXJfbnVtYmVyX21hcChzZWxmKToKKyAgICAgICAg cmV0dXJuIEFwcGxlQWRkaXRpb25zLklPU0RldmljZURlbGVnYXRlLmRldmljZV9tYXAoKQorCisg ICAgZGVmIF9kcml2ZXJfY2xhc3Moc2VsZik6CisgICAgICAgIHJldHVybiBBcHBsZUFkZGl0aW9u cy5JT1NEZXZpY2VEZWxlZ2F0ZS5ERVZJQ0VfRFJJVkVSCiAKICAgICBAY2xhc3NtZXRob2QKICAg ICBkZWYgZGV0ZXJtaW5lX2Z1bGxfcG9ydF9uYW1lKGNscywgaG9zdCwgb3B0aW9ucywgcG9ydF9u YW1lKToKICAgICAgICAgaWYgcG9ydF9uYW1lID09IGNscy5wb3J0X25hbWU6Ci0gICAgICAgICAg ICBpcGhvbmVvc19zZGtfdmVyc2lvbiA9IGhvc3QucGxhdGZvcm0ueGNvZGVfc2RrX3ZlcnNpb24o J2lwaG9uZW9zJykKKyAgICAgICAgICAgIGlwaG9uZW9zX3Nka192ZXJzaW9uID0gaG9zdC5wbGF0 Zm9ybS54Y29kZV9zZGtfdmVyc2lvbihJT1NEZXZpY2VQb3J0LlNESykKICAgICAgICAgICAgIGlm IG5vdCBpcGhvbmVvc19zZGtfdmVyc2lvbjoKICAgICAgICAgICAgICAgICByYWlzZSBFeGNlcHRp b24oIlBsZWFzZSBpbnN0YWxsIHRoZSBpT1MgU0RLLiIpCiAgICAgICAgICAgICBtYWpvcl92ZXJz aW9uX251bWJlciA9IGlwaG9uZW9zX3Nka192ZXJzaW9uLnNwbGl0KCcuJylbMF0KICAgICAgICAg ICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZSArICctJyArIG1ham9yX3ZlcnNpb25fbnVtYmVyCiAg ICAgICAgIHJldHVybiBwb3J0X25hbWUKIAorICAgICMgRklYTUU6IFRoZXNlIG5lZWQgZGV2aWNl IGltcGxlbWVudGF0aW9ucyA8cmRhcjovL3Byb2JsZW0vMzA0OTc5OTE+CisgICAgZGVmIGNoZWNr X2Zvcl9sZWFrcyhzZWxmLCBwcm9jZXNzX25hbWUsIHByb2Nlc3NfcGlkKToKKyAgICAgICAgcGFz cworCisgICAgZGVmIGxvb2tfZm9yX25ld19jcmFzaF9sb2dzKHNlbGYsIGNyYXNoZWRfcHJvY2Vz c2VzLCBzdGFydF90aW1lKToKKyAgICAgICAgcmV0dXJuIHt9CisKKyAgICBkZWYgbG9va19mb3Jf bmV3X3NhbXBsZXMoc2VsZiwgdW5yZXNwb25zaXZlX3Byb2Nlc3Nlcywgc3RhcnRfdGltZSk6Cisg ICAgICAgIHJldHVybiB7fQorCisgICAgZGVmIHNhbXBsZV9wcm9jZXNzKHNlbGYsIG5hbWUsIHBp ZCk6CisgICAgICAgIHBhc3MKKwogICAgICMgRGVzcGl0ZSB0aGVpciBuYW1lcywgdGhlc2UgZmxh Z3MgZG8gbm90IGFjdHVhbGx5IGdldCBwYXNzZWQgYWxsIHRoZSB3YXkgZG93biB0byB3ZWJraXQt YnVpbGQuCiAgICAgZGVmIF9idWlsZF9kcml2ZXJfZmxhZ3Moc2VsZik6Ci0gICAgICAgIHJldHVy biBbJy0tc2RrJywgJ2lwaG9uZW9zJ10gKyAoWydBUkNIUz0lcycgJSBzZWxmLmFyY2hpdGVjdHVy ZSgpXSBpZiBzZWxmLmFyY2hpdGVjdHVyZSgpIGVsc2UgW10pCisgICAgICAgIHJldHVybiBbJy0t c2RrJywgSU9TRGV2aWNlUG9ydC5TREtdICsgKFsnQVJDSFM9JXMnICUgc2VsZi5hcmNoaXRlY3R1 cmUoKV0gaWYgc2VsZi5hcmNoaXRlY3R1cmUoKSBlbHNlIFtdKQogCiAgICAgZGVmIG9wZXJhdGlu Z19zeXN0ZW0oc2VsZik6CiAgICAgICAgIHJldHVybiAnaW9zLWRldmljZScKKworICAgIGRlZiBf Y3JlYXRlX2RldmljZXMoc2VsZiwgZGV2aWNlX2NsYXNzKToKKyAgICAgICAgc2VsZi5fZGV2aWNl X2RlbGVnYXRlLnBvbGxfZGV2aWNlcygpCisgICAgICAgIGlmIG5vdCBBcHBsZUFkZGl0aW9ucy5o YXNfYWRkaXRpb25zKCk6CisgICAgICAgICAgICByYWlzZSBSdW50aW1lRXJyb3IoJ09uLWRldmlj ZSB0ZXN0aW5nIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBtYWNoaW5lJykKKyAgICAgICAgZWxp ZiBub3Qgc2VsZi5fZGV2aWNlX2RlbGVnYXRlLmRldmljZV9tYXAoKToKKyAgICAgICAgICAgIHJh aXNlIFJ1bnRpbWVFcnJvcignTm8gZGV2aWNlcyBhcmUgYXZhaWxhYmxlIGZvciB0ZXN0aW5nJykK KyAgICAgICAgc2VsZi5fZGV2aWNlX2RlbGVnYXRlLnNldHVwX2RldmljZXNfZm9yX2F1dG9tYXRp b24oKQorCisgICAgZGVmIGNsZWFuX3VwX3Rlc3RfcnVuKHNlbGYpOgorICAgICAgICBzdXBlcihJ T1NEZXZpY2VQb3J0LCBzZWxmKS5jbGVhbl91cF90ZXN0X3J1bigpCisgICAgICAgIHNlbGYuX2Rl dmljZV9kZWxlZ2F0ZS50ZWFyZG93bl9kZXZpY2VzX2FmdGVyX2F1dG9tYXRpb24oKQpJbmRleDog VG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2VfdW5pdHRlc3QucHkKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2VfdW5pdHRlc3Qu cHkJKHJldmlzaW9uIDIxNDg4MSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3Nf ZGV2aWNlX3VuaXR0ZXN0LnB5CSh3b3JraW5nIGNvcHkpCkBAIC0zNiwzICszNiwxMyBAQCBjbGFz cyBJT1NEZXZpY2VUZXN0KGlvc190ZXN0Y2FzZS5JT1NUZXN0CiAKICAgICBkZWYgdGVzdF9vcGVy YXRpbmdfc3lzdGVtKHNlbGYpOgogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdpb3MtZGV2aWNl Jywgc2VsZi5tYWtlX3BvcnQoKS5vcGVyYXRpbmdfc3lzdGVtKCkpCisKKyAgICAjIEZJWE1FOiBV cGRhdGUgdGVzdHMgd2hlbiA8cmRhcjovL3Byb2JsZW0vMzA0OTc5OTE+IGlzIGNvbXBsZXRlZAor ICAgIGRlZiB0ZXN0X3NwaW5kdW1wKHNlbGYpOgorICAgICAgICBwYXNzCisKKyAgICBkZWYgdGVz dF9zYW1wbGVfcHJvY2VzcyhzZWxmKToKKyAgICAgICAgcGFzcworCisgICAgZGVmIHRlc3Rfc2Ft cGxlX3Byb2Nlc3NfZXhjZXB0aW9uKHNlbGYpOgorICAgICAgICBwYXNzCg== 306425 2017-04-06 14:12:05 -0700 2017-04-12 10:22:29 -0700 Patch bug-170461-20170406141204.patch text/plain 9910 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNTA1NykKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDM4IEBACisyMDE3LTA0LTA2ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIEFwcGxlQWRkaXRpb25zIHRvIHdlYmtpdHB5IHRv IGluc2VydCBJbnRlcm5hbCB0b29scworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTcwNDYxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8zMTQzMzA3Nz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvY29tbW9uL2FwcGxlX2FkZGl0aW9ucy5weTogSW1wb3J0IG9wdGlvbmFsIEFw cGxlQWRkaXRpb25zIG1vZHVsZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvZGV2 aWNlLnB5OgorICAgICAgICAoRGV2aWNlLnByZXBhcmVfZm9yX3Rlc3RpbmcpOiBQYXNzIGxpc3Rl bmluZyBwb3J0IHRvIHNldHVwLgorICAgICAgICAoRGV2aWNlLmZpbmlzaGVkX3Rlc3RpbmcpOiBD YWxsIGNvcnJlY3QgdGVhci1kb3duIGZ1bmN0aW9uLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvcG9ydC9mYWN0b3J5LnB5OgorICAgICAgICAocGxhdGZvcm1fb3B0aW9ucyk6IEluc2VydCBh ZGRpdGlvbmFsIHBsYXRmb3JtIG9wdGlvbnMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9w b3J0L2lvc19kZXZpY2UucHk6CisgICAgICAgIChJT1NEZXZpY2VEZWxlZ2F0ZSk6IFByb3ZpZGVz IGZ1bmN0aW9uYWxpdHkgdG8gSU9TRGV2aWNlUG9ydCBmb3Igb24tZGV2aWNlIHRlc3RpbmcuCisg ICAgICAgIChJT1NEZXZpY2VQb3J0KToKKyAgICAgICAgKElPU0RldmljZVBvcnQuX19pbml0X18p OgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5fZGV2aWNlX2Zvcl93b3JrZXJfbnVtYmVyX21hcCk6 CisgICAgICAgIChJT1NEZXZpY2VQb3J0Ll9kcml2ZXJfY2xhc3MpOgorICAgICAgICAoSU9TRGV2 aWNlUG9ydC5kZXRlcm1pbmVfZnVsbF9wb3J0X25hbWUpOiBVc2UgU0RLIHZhcmlhYmxlLgorICAg ICAgICAoSU9TRGV2aWNlUG9ydC5jaGVja19mb3JfbGVha3MpOiBObyBpbXBsZW1lbnRhdGlvbi4K KyAgICAgICAgKElPU0RldmljZVBvcnQubG9va19mb3JfbmV3X2NyYXNoX2xvZ3MpOiBEaXR0by4K KyAgICAgICAgKElPU0RldmljZVBvcnQubG9va19mb3JfbmV3X3NhbXBsZXMpOiBEaXR0by4KKyAg ICAgICAgKElPU0RldmljZVBvcnQuc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElP U0RldmljZVBvcnQuX2J1aWxkX2RyaXZlcl9mbGFncyk6IFVzZSBTREsgdmFyaWFibGUuCisgICAg ICAgIChJT1NEZXZpY2VQb3J0Ll9jcmVhdGVfZGV2aWNlcyk6CisgICAgICAgIChJT1NEZXZpY2VQ b3J0LmNsZWFuX3VwX3Rlc3RfcnVuKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQv aW9zX2RldmljZV91bml0dGVzdC5weToKKyAgICAgICAgKElPU0RldmljZVRlc3QudGVzdF9vcGVy YXRpbmdfc3lzdGVtKToKKyAgICAgICAgKElPU0RldmljZVRlc3QpOgorICAgICAgICAoSU9TRGV2 aWNlVGVzdC50ZXN0X3NwaW5kdW1wKTogTm8gaW1wbGVtZW50YXRpb24uCisgICAgICAgIChJT1NE ZXZpY2VUZXN0LnRlc3Rfc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElPU0Rldmlj ZVRlc3QudGVzdF9zYW1wbGVfcHJvY2Vzc19leGNlcHRpb24pOiBEaXR0by4KKwogMjAxNy0wNC0w NiAgWW91ZW5uIEZhYmxldCAgPHlvdWVubkBhcHBsZS5jb20+CiAKICAgICAgICAgV2ViUlRDIHRl c3RzIGdhcmRlbmluZwpJbmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vYXBwbGVf YWRkaXRpb25zLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2FwcGxlX2FkZGl0aW9ucy5weQkobm9uZXhpc3RlbnQpCisrKyBUb29scy9TY3JpcHRzL3dlYmtp dHB5L2NvbW1vbi9hcHBsZV9hZGRpdGlvbnMucHkJKHdvcmtpbmcgY29weSkKQEAgLTAsMCArMSwy NiBAQAorIyBDb3B5cmlnaHQgKEMpIDIwMTcgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorIworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisjIGFyZSBtZXQ6CisjIDEuICBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor IyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorIyAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyMgICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQg SVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5ECisjIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisj IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUKKyMgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5D LiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IKKyMgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTAorIyBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUgorIyBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUgorIyBDQVVTRUQgQU5EIE9OIEFO WSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklM SVRZLAorIyBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCit0cnk6CisgICAg aW1wb3J0IHNhZmFyaXB5LmFwcGxlX2FkZGl0aW9ucyBhcyBBcHBsZUFkZGl0aW9ucworZXhjZXB0 IEltcG9ydEVycm9yOgorICAgIEFwcGxlQWRkaXRpb25zID0gTm9uZQpJbmRleDogVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9wb3J0L2RldmljZS5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRz L3dlYmtpdHB5L3BvcnQvZGV2aWNlLnB5CShyZXZpc2lvbiAyMTQ4ODEpCisrKyBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3BvcnQvZGV2aWNlLnB5CSh3b3JraW5nIGNvcHkpCkBAIC00NSwxMCArNDUs MTAgQEAgY2xhc3MgRGV2aWNlKG9iamVjdCk6CiAgICAgICAgICAgICBzZWxmLmxpc3RlbmluZ19z b2NrZXQuYmluZCgoJzEyNy4wLjAuMScsIDApKQogCiAgICAgICAgIGlmIGhhc2F0dHIoc2VsZi5w bGF0Zm9ybV9kZXZpY2UsICdwcmVwYXJlX2Zvcl90ZXN0aW5nJyk6Ci0gICAgICAgICAgICBzZWxm LnBsYXRmb3JtX2RldmljZS5wcmVwYXJlX2Zvcl90ZXN0aW5nKCkKKyAgICAgICAgICAgIHNlbGYu cGxhdGZvcm1fZGV2aWNlLnByZXBhcmVfZm9yX3Rlc3RpbmcobGlzdGVuaW5nX3BvcnQ9c2VsZi5s aXN0ZW5pbmdfcG9ydCgpKQogCiAgICAgZGVmIGZpbmlzaGVkX3Rlc3Rpbmcoc2VsZik6Ci0gICAg ICAgIGlmIGhhc2F0dHIoc2VsZi5wbGF0Zm9ybV9kZXZpY2UsICd0ZWFyZG93bicpOgorICAgICAg ICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2aWNlLCAnZmluaXNoZWRfdGVzdGluZycpOgog ICAgICAgICAgICAgc2VsZi5wbGF0Zm9ybV9kZXZpY2UuZmluaXNoZWRfdGVzdGluZygpCiAKICAg ICAgICAgc2VsZi5saXN0ZW5pbmdfc29ja2V0ID0gTm9uZQpJbmRleDogVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9wb3J0L2ZhY3RvcnkucHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9wb3J0L2ZhY3RvcnkucHkJKHJldmlzaW9uIDIxNDg4MSkKKysrIFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5CSh3b3JraW5nIGNvcHkpCkBAIC0zNiw2ICszNiw3IEBA IGltcG9ydCByZQogCiBmcm9tIHdlYmtpdHB5LnBvcnQgaW1wb3J0IGJ1aWxkZXJzCiBmcm9tIHdl YmtpdHB5LnBvcnQgaW1wb3J0IGNvbmZpZworZnJvbSB3ZWJraXRweS5jb21tb24uYXBwbGVfYWRk aXRpb25zIGltcG9ydCBBcHBsZUFkZGl0aW9ucwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVt IGltcG9ydCBleGVjdXRpdmUKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgZmls ZXN5c3RlbQogCkBAIC01OSw3ICs2MCw3IEBAIGRlZiBwbGF0Zm9ybV9vcHRpb25zKHVzZV9nbG9i cz1GYWxzZSk6CiAgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKCctLW5vLWluc3RhbGwnLCBh Y3Rpb249J3N0b3JlX2NvbnN0JywKICAgICAgICAgICAgIGNvbnN0PUZhbHNlLCBkZWZhdWx0PVRy dWUsIGRlc3Q9J2luc3RhbGwnLAogICAgICAgICAgICAgaGVscD0nU2tpcCBpbnN0YWxsIHN0ZXAg Zm9yIGRldmljZSBhbmQgc2ltdWxhdG9yIHRlc3RpbmcnKSwKLSAgICAgICAgXQorICAgICAgICBd ICsgKEFwcGxlQWRkaXRpb25zLnBsYXRmb3JtX29wdGlvbnMoKSBpZiBBcHBsZUFkZGl0aW9ucyBl bHNlIFtdKQogCiAKIGRlZiBjb25maWd1cmF0aW9uX29wdGlvbnMoKToKSW5kZXg6IFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5Cj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5CShyZXZpc2lvbiAyMTQ4ODEpCisrKyBU b29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5weQkod29ya2luZyBjb3B5KQpA QCAtMjIsMzEgKzIyLDk3IEBACiAKIGltcG9ydCBsb2dnaW5nCiAKK2Zyb20gd2Via2l0cHkuY29t bW9uLmFwcGxlX2FkZGl0aW9ucyBpbXBvcnQgQXBwbGVBZGRpdGlvbnMKK2Zyb20gd2Via2l0cHku cG9ydC5kcml2ZXIgaW1wb3J0IERyaXZlcgogZnJvbSB3ZWJraXRweS5wb3J0LmlvcyBpbXBvcnQg SU9TUG9ydAogCiBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCiAKIAorY2xhc3Mg SU9TRGV2aWNlRGVsZWdhdGUob2JqZWN0KToKKyAgICBTREsgPSAnaXBob25lb3MnCisgICAgREVW SUNFX0RSSVZFUiA9IERyaXZlcgorCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQpOgorICAg ICAgICBzZWxmLl9wb3J0ID0gcG9ydAorCisgICAgQHN0YXRpY21ldGhvZAorICAgIGRlZiBkZXZp Y2VfbWFwKCk6CisgICAgICAgIHJldHVybiB7fQorCisgICAgZGVmIHBvbGxfZGV2aWNlcyhzZWxm KToKKyAgICAgICAgcGFzcworCisgICAgZGVmIHNldHVwX2RldmljZXNfZm9yX2F1dG9tYXRpb24o c2VsZik6CisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IKKworICAgIGRlZiB0ZWFy ZG93bl9kZXZpY2VzX2FmdGVyX2F1dG9tYXRpb24oc2VsZik6CisgICAgICAgIHJhaXNlIE5vdElt cGxlbWVudGVkRXJyb3IKKwogY2xhc3MgSU9TRGV2aWNlUG9ydChJT1NQb3J0KToKICAgICBwb3J0 X25hbWUgPSAnaW9zLWRldmljZScKIAogICAgIEFSQ0hJVEVDVFVSRVMgPSBbJ2FybXY3JywgJ2Fy bXY3cycsICdhcm02NCddCiAgICAgREVGQVVMVF9BUkNISVRFQ1RVUkUgPSAnYXJtNjQnCiAgICAg VkVSU0lPTl9GQUxMQkFDS19PUkRFUiA9IFsnaW9zLTcnLCAnaW9zLTgnLCAnaW9zLTknLCAnaW9z LTEwJ10KKyAgICBEZXZpY2VEZWxlZ2F0ZSA9IEFwcGxlQWRkaXRpb25zLklPU0RldmljZURlbGVn YXRlIGlmIEFwcGxlQWRkaXRpb25zIGVsc2UgSU9TRGV2aWNlRGVsZWdhdGUKKyAgICBTREsgPSBE ZXZpY2VEZWxlZ2F0ZS5TREsKKworICAgIGRlZiBfX2luaXRfXyhzZWxmLCBob3N0LCBwb3J0X25h bWUsICoqa3dhcmdzKToKKyAgICAgICAgc3VwZXIoSU9TRGV2aWNlUG9ydCwgc2VsZikuX19pbml0 X18oaG9zdCwgcG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAgICAgc2VsZi5fZGV2aWNlX2RlbGVn YXRlID0gSU9TRGV2aWNlUG9ydC5EZXZpY2VEZWxlZ2F0ZShzZWxmKQorICAgICAgICBzZWxmLl9k ZXZpY2VfZGVsZWdhdGUucG9sbF9kZXZpY2VzKCkKKyAgICAgICAgbnVtX2RldmljZXMgPSBsZW4o c2VsZi5fZGV2aWNlX2RlbGVnYXRlLmRldmljZV9tYXAoKSkKKyAgICAgICAgaWYgbnVtX2Rldmlj ZXMgPT0gMToKKyAgICAgICAgICAgIHNlbGYuX2N1cnJlbnRfZGV2aWNlID0gc2VsZi5fZGV2aWNl X2RlbGVnYXRlLmRldmljZV9tYXAoKVswXQorICAgICAgICBlbGlmIG51bV9kZXZpY2VzIDw9IDA6 CisgICAgICAgICAgICBudW1fZGV2aWNlcyA9IDEKKyAgICAgICAgc2VsZi5zZXRfb3B0aW9uKCdj aGlsZF9wcm9jZXNzZXMnLCBudW1fZGV2aWNlcykKKworICAgIGRlZiBfZGV2aWNlX2Zvcl93b3Jr ZXJfbnVtYmVyX21hcChzZWxmKToKKyAgICAgICAgcmV0dXJuIElPU0RldmljZVBvcnQuRGV2aWNl RGVsZWdhdGUuZGV2aWNlX21hcCgpCisKKyAgICBkZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToKKyAg ICAgICAgcmV0dXJuIElPU0RldmljZVBvcnQuRGV2aWNlRGVsZWdhdGUuREVWSUNFX0RSSVZFUgog CiAgICAgQGNsYXNzbWV0aG9kCiAgICAgZGVmIGRldGVybWluZV9mdWxsX3BvcnRfbmFtZShjbHMs IGhvc3QsIG9wdGlvbnMsIHBvcnRfbmFtZSk6CiAgICAgICAgIGlmIHBvcnRfbmFtZSA9PSBjbHMu cG9ydF9uYW1lOgotICAgICAgICAgICAgaXBob25lb3Nfc2RrX3ZlcnNpb24gPSBob3N0LnBsYXRm b3JtLnhjb2RlX3Nka192ZXJzaW9uKCdpcGhvbmVvcycpCisgICAgICAgICAgICBpcGhvbmVvc19z ZGtfdmVyc2lvbiA9IGhvc3QucGxhdGZvcm0ueGNvZGVfc2RrX3ZlcnNpb24oSU9TRGV2aWNlUG9y dC5TREspCiAgICAgICAgICAgICBpZiBub3QgaXBob25lb3Nfc2RrX3ZlcnNpb246CiAgICAgICAg ICAgICAgICAgcmFpc2UgRXhjZXB0aW9uKCJQbGVhc2UgaW5zdGFsbCB0aGUgaU9TIFNESy4iKQog ICAgICAgICAgICAgbWFqb3JfdmVyc2lvbl9udW1iZXIgPSBpcGhvbmVvc19zZGtfdmVyc2lvbi5z cGxpdCgnLicpWzBdCiAgICAgICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBt YWpvcl92ZXJzaW9uX251bWJlcgogICAgICAgICByZXR1cm4gcG9ydF9uYW1lCiAKKyAgICAjIEZJ WE1FOiBUaGVzZSBuZWVkIGRldmljZSBpbXBsZW1lbnRhdGlvbnMgPHJkYXI6Ly9wcm9ibGVtLzMw NDk3OTkxPgorICAgIGRlZiBjaGVja19mb3JfbGVha3Moc2VsZiwgcHJvY2Vzc19uYW1lLCBwcm9j ZXNzX3BpZCk6CisgICAgICAgIHBhc3MKKworICAgIGRlZiBsb29rX2Zvcl9uZXdfY3Jhc2hfbG9n cyhzZWxmLCBjcmFzaGVkX3Byb2Nlc3Nlcywgc3RhcnRfdGltZSk6CisgICAgICAgIHJldHVybiB7 fQorCisgICAgZGVmIGxvb2tfZm9yX25ld19zYW1wbGVzKHNlbGYsIHVucmVzcG9uc2l2ZV9wcm9j ZXNzZXMsIHN0YXJ0X3RpbWUpOgorICAgICAgICByZXR1cm4ge30KKworICAgIGRlZiBzYW1wbGVf cHJvY2VzcyhzZWxmLCBuYW1lLCBwaWQpOgorICAgICAgICBwYXNzCisKICAgICAjIERlc3BpdGUg dGhlaXIgbmFtZXMsIHRoZXNlIGZsYWdzIGRvIG5vdCBhY3R1YWxseSBnZXQgcGFzc2VkIGFsbCB0 aGUgd2F5IGRvd24gdG8gd2Via2l0LWJ1aWxkLgogICAgIGRlZiBfYnVpbGRfZHJpdmVyX2ZsYWdz KHNlbGYpOgotICAgICAgICByZXR1cm4gWyctLXNkaycsICdpcGhvbmVvcyddICsgKFsnQVJDSFM9 JXMnICUgc2VsZi5hcmNoaXRlY3R1cmUoKV0gaWYgc2VsZi5hcmNoaXRlY3R1cmUoKSBlbHNlIFtd KQorICAgICAgICByZXR1cm4gWyctLXNkaycsIElPU0RldmljZVBvcnQuU0RLXSArIChbJ0FSQ0hT PSVzJyAlIHNlbGYuYXJjaGl0ZWN0dXJlKCldIGlmIHNlbGYuYXJjaGl0ZWN0dXJlKCkgZWxzZSBb XSkKIAogICAgIGRlZiBvcGVyYXRpbmdfc3lzdGVtKHNlbGYpOgogICAgICAgICByZXR1cm4gJ2lv cy1kZXZpY2UnCisKKyAgICBkZWYgX2NyZWF0ZV9kZXZpY2VzKHNlbGYsIGRldmljZV9jbGFzcyk6 CisgICAgICAgIHNlbGYuX2RldmljZV9kZWxlZ2F0ZS5wb2xsX2RldmljZXMoKQorICAgICAgICBp ZiBub3QgQXBwbGVBZGRpdGlvbnM6CisgICAgICAgICAgICByYWlzZSBSdW50aW1lRXJyb3IoJ09u LWRldmljZSB0ZXN0aW5nIGlzIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBtYWNoaW5lJykKKyAgICAg ICAgZWxpZiBub3Qgc2VsZi5fZGV2aWNlX2RlbGVnYXRlLmRldmljZV9tYXAoKToKKyAgICAgICAg ICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignTm8gZGV2aWNlcyBhcmUgYXZhaWxhYmxlIGZvciB0ZXN0 aW5nJykKKyAgICAgICAgc2VsZi5fZGV2aWNlX2RlbGVnYXRlLnNldHVwX2RldmljZXNfZm9yX2F1 dG9tYXRpb24oKQorCisgICAgZGVmIGNsZWFuX3VwX3Rlc3RfcnVuKHNlbGYpOgorICAgICAgICBz dXBlcihJT1NEZXZpY2VQb3J0LCBzZWxmKS5jbGVhbl91cF90ZXN0X3J1bigpCisgICAgICAgIHNl bGYuX2RldmljZV9kZWxlZ2F0ZS50ZWFyZG93bl9kZXZpY2VzX2FmdGVyX2F1dG9tYXRpb24oKQpJ bmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2VfdW5pdHRlc3QucHkK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2VfdW5p dHRlc3QucHkJKHJldmlzaW9uIDIxNDg4MSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9y dC9pb3NfZGV2aWNlX3VuaXR0ZXN0LnB5CSh3b3JraW5nIGNvcHkpCkBAIC0zNiwzICszNiwxMyBA QCBjbGFzcyBJT1NEZXZpY2VUZXN0KGlvc190ZXN0Y2FzZS5JT1NUZXN0CiAKICAgICBkZWYgdGVz dF9vcGVyYXRpbmdfc3lzdGVtKHNlbGYpOgogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdpb3Mt ZGV2aWNlJywgc2VsZi5tYWtlX3BvcnQoKS5vcGVyYXRpbmdfc3lzdGVtKCkpCisKKyAgICAjIEZJ WE1FOiBVcGRhdGUgdGVzdHMgd2hlbiA8cmRhcjovL3Byb2JsZW0vMzA0OTc5OTE+IGlzIGNvbXBs ZXRlZAorICAgIGRlZiB0ZXN0X3NwaW5kdW1wKHNlbGYpOgorICAgICAgICBwYXNzCisKKyAgICBk ZWYgdGVzdF9zYW1wbGVfcHJvY2VzcyhzZWxmKToKKyAgICAgICAgcGFzcworCisgICAgZGVmIHRl c3Rfc2FtcGxlX3Byb2Nlc3NfZXhjZXB0aW9uKHNlbGYpOgorICAgICAgICBwYXNzCg== 306918 2017-04-12 10:22:30 -0700 2017-04-18 09:50:57 -0700 Patch bug-170461-20170412102229.patch text/plain 9953 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNTE5NSkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDM4IEBACisyMDE3LTA0LTEyICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIEFwcGxlQWRkaXRpb25zIHRvIHdlYmtpdHB5IHRv IGluc2VydCBJbnRlcm5hbCB0b29scworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MTcwNDYxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8zMTQzMzA3Nz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvY29tbW9uL2FwcGxlX2FkZGl0aW9ucy5weTogSW1wb3J0IG9wdGlvbmFsIEFw cGxlQWRkaXRpb25zIG1vZHVsZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvZGV2 aWNlLnB5OgorICAgICAgICAoRGV2aWNlLnByZXBhcmVfZm9yX3Rlc3RpbmcpOiBQYXNzIGxpc3Rl bmluZyBwb3J0IHRvIHNldHVwLgorICAgICAgICAoRGV2aWNlLmZpbmlzaGVkX3Rlc3RpbmcpOiBD YWxsIGNvcnJlY3QgdGVhci1kb3duIGZ1bmN0aW9uLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0 cHkvcG9ydC9mYWN0b3J5LnB5OgorICAgICAgICAocGxhdGZvcm1fb3B0aW9ucyk6IEluc2VydCBh ZGRpdGlvbmFsIHBsYXRmb3JtIG9wdGlvbnMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9w b3J0L2lvc19kZXZpY2UucHk6CisgICAgICAgIChJT1NEZXZpY2VEZWxlZ2F0ZSk6IFByb3ZpZGVz IGZ1bmN0aW9uYWxpdHkgdG8gSU9TRGV2aWNlUG9ydCBmb3Igb24tZGV2aWNlIHRlc3RpbmcuCisg ICAgICAgIChJT1NEZXZpY2VQb3J0KToKKyAgICAgICAgKElPU0RldmljZVBvcnQuX19pbml0X18p OgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5fZGV2aWNlX2Zvcl93b3JrZXJfbnVtYmVyX21hcCk6 CisgICAgICAgIChJT1NEZXZpY2VQb3J0Ll9kcml2ZXJfY2xhc3MpOgorICAgICAgICAoSU9TRGV2 aWNlUG9ydC5kZXRlcm1pbmVfZnVsbF9wb3J0X25hbWUpOiBVc2UgU0RLIHZhcmlhYmxlLgorICAg ICAgICAoSU9TRGV2aWNlUG9ydC5jaGVja19mb3JfbGVha3MpOiBObyBpbXBsZW1lbnRhdGlvbi4K KyAgICAgICAgKElPU0RldmljZVBvcnQubG9va19mb3JfbmV3X2NyYXNoX2xvZ3MpOiBEaXR0by4K KyAgICAgICAgKElPU0RldmljZVBvcnQubG9va19mb3JfbmV3X3NhbXBsZXMpOiBEaXR0by4KKyAg ICAgICAgKElPU0RldmljZVBvcnQuc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElP U0RldmljZVBvcnQuX2J1aWxkX2RyaXZlcl9mbGFncyk6IFVzZSBTREsgdmFyaWFibGUuCisgICAg ICAgIChJT1NEZXZpY2VQb3J0Ll9jcmVhdGVfZGV2aWNlcyk6CisgICAgICAgIChJT1NEZXZpY2VQ b3J0LmNsZWFuX3VwX3Rlc3RfcnVuKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQv aW9zX2RldmljZV91bml0dGVzdC5weToKKyAgICAgICAgKElPU0RldmljZVRlc3QudGVzdF9vcGVy YXRpbmdfc3lzdGVtKToKKyAgICAgICAgKElPU0RldmljZVRlc3QpOgorICAgICAgICAoSU9TRGV2 aWNlVGVzdC50ZXN0X3NwaW5kdW1wKTogTm8gaW1wbGVtZW50YXRpb24uCisgICAgICAgIChJT1NE ZXZpY2VUZXN0LnRlc3Rfc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElPU0Rldmlj ZVRlc3QudGVzdF9zYW1wbGVfcHJvY2Vzc19leGNlcHRpb24pOiBEaXR0by4KKwogMjAxNy0wNC0x MCAgR3VpbGxhdW1lIEVtb250ICA8Z3VpamVtb250QGlnYWxpYS5jb20+CiAKICAgICAgICAgW0pT Q10gRG8gbm90IHJ1biBGVEwgc3RyZXNzIHRlc3RzIG9uIE1JUFMKSW5kZXg6IFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvY29tbW9uL2FwcGxlX2FkZGl0aW9ucy5weQo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9hcHBsZV9hZGRpdGlvbnMucHkJKG5vbmV4aXN0ZW50 KQorKysgVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vYXBwbGVfYWRkaXRpb25zLnB5CSh3 b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsMjYgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE3IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor IyBhcmUgbWV0OgorIyAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIgaW4gdGhlCisjICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORAor IyBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SCisjIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExB UlksIE9SIENPTlNFUVVFTlRJQUwKKyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7IExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIKKyMgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMg T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKwordHJ5OgorICAgIGltcG9ydCBzYWZhcmlweS5hcHBsZV9hZGRpdGlvbnMg YXMgQXBwbGVBZGRpdGlvbnMKK2V4Y2VwdCBJbXBvcnRFcnJvcjoKKyAgICBBcHBsZUFkZGl0aW9u cyA9IE5vbmUKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9kZXZpY2UucHkKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2RldmljZS5weQkocmV2aXNp b24gMjE1MTk1KQorKysgVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2RldmljZS5weQkod29y a2luZyBjb3B5KQpAQCAtNDUsMTAgKzQ1LDEwIEBAIGNsYXNzIERldmljZShvYmplY3QpOgogICAg ICAgICAgICAgc2VsZi5saXN0ZW5pbmdfc29ja2V0LmJpbmQoKCcxMjcuMC4wLjEnLCAwKSkKIAog ICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2aWNlLCAncHJlcGFyZV9mb3JfdGVz dGluZycpOgotICAgICAgICAgICAgc2VsZi5wbGF0Zm9ybV9kZXZpY2UucHJlcGFyZV9mb3JfdGVz dGluZygpCisgICAgICAgICAgICBzZWxmLnBsYXRmb3JtX2RldmljZS5wcmVwYXJlX2Zvcl90ZXN0 aW5nKGxpc3RlbmluZ19wb3J0PXNlbGYubGlzdGVuaW5nX3BvcnQoKSkKIAogICAgIGRlZiBmaW5p c2hlZF90ZXN0aW5nKHNlbGYpOgotICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2 aWNlLCAndGVhcmRvd24nKToKKyAgICAgICAgaWYgaGFzYXR0cihzZWxmLnBsYXRmb3JtX2Rldmlj ZSwgJ2ZpbmlzaGVkX3Rlc3RpbmcnKToKICAgICAgICAgICAgIHNlbGYucGxhdGZvcm1fZGV2aWNl LmZpbmlzaGVkX3Rlc3RpbmcoKQogCiAgICAgICAgIHNlbGYubGlzdGVuaW5nX3NvY2tldCA9IE5v bmUKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5Cj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5CShyZXZpc2lvbiAy MTUxOTUpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQkod29ya2lu ZyBjb3B5KQpAQCAtMzYsNiArMzYsNyBAQCBpbXBvcnQgcmUKIAogZnJvbSB3ZWJraXRweS5wb3J0 IGltcG9ydCBidWlsZGVycwogZnJvbSB3ZWJraXRweS5wb3J0IGltcG9ydCBjb25maWcKK2Zyb20g d2Via2l0cHkuY29tbW9uLmFwcGxlX2FkZGl0aW9ucyBpbXBvcnQgQXBwbGVBZGRpdGlvbnMKIGZy b20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgZXhlY3V0aXZlCiBmcm9tIHdlYmtpdHB5 LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IGZpbGVzeXN0ZW0KIApAQCAtNTksNyArNjAsNyBAQCBkZWYg cGxhdGZvcm1fb3B0aW9ucyh1c2VfZ2xvYnM9RmFsc2UpOgogICAgICAgICBvcHRwYXJzZS5tYWtl X29wdGlvbignLS1uby1pbnN0YWxsJywgYWN0aW9uPSdzdG9yZV9jb25zdCcsCiAgICAgICAgICAg ICBjb25zdD1GYWxzZSwgZGVmYXVsdD1UcnVlLCBkZXN0PSdpbnN0YWxsJywKICAgICAgICAgICAg IGhlbHA9J1NraXAgaW5zdGFsbCBzdGVwIGZvciBkZXZpY2UgYW5kIHNpbXVsYXRvciB0ZXN0aW5n JyksCi0gICAgICAgIF0KKyAgICAgICAgXSArIChBcHBsZUFkZGl0aW9ucy5wbGF0Zm9ybV9vcHRp b25zKCkgaWYgQXBwbGVBZGRpdGlvbnMgZWxzZSBbXSkKIAogCiBkZWYgY29uZmlndXJhdGlvbl9v cHRpb25zKCk6CkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5w eQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5w eQkocmV2aXNpb24gMjE1MTk1KQorKysgVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19k ZXZpY2UucHkJKHdvcmtpbmcgY29weSkKQEAgLTIyLDMxICsyMiw5NyBAQAogCiBpbXBvcnQgbG9n Z2luZwogCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5hcHBsZV9hZGRpdGlvbnMgaW1wb3J0IEFwcGxl QWRkaXRpb25zCitmcm9tIHdlYmtpdHB5LnBvcnQuZHJpdmVyIGltcG9ydCBEcml2ZXIKIGZyb20g d2Via2l0cHkucG9ydC5pb3MgaW1wb3J0IElPU1BvcnQKIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9n Z2VyKF9fbmFtZV9fKQogCiAKK2NsYXNzIElPU0RldmljZURlbGVnYXRlKG9iamVjdCk6CisgICAg U0RLID0gJ2lwaG9uZW9zJworICAgIERFVklDRV9EUklWRVIgPSBEcml2ZXIKKworICAgIGRlZiBf X2luaXRfXyhzZWxmLCBwb3J0KToKKyAgICAgICAgc2VsZi5fcG9ydCA9IHBvcnQKKworICAgIEBz dGF0aWNtZXRob2QKKyAgICBkZWYgZGV2aWNlX21hcCgpOgorICAgICAgICByZXR1cm4ge30KKwor ICAgIGRlZiBwb2xsX2RldmljZXMoc2VsZik6CisgICAgICAgIHBhc3MKKworICAgIGRlZiBzZXR1 cF9kZXZpY2VzX2Zvcl9hdXRvbWF0aW9uKHNlbGYpOgorICAgICAgICByYWlzZSBOb3RJbXBsZW1l bnRlZEVycm9yCisKKyAgICBkZWYgdGVhcmRvd25fZGV2aWNlc19hZnRlcl9hdXRvbWF0aW9uKHNl bGYpOgorICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yCisKIGNsYXNzIElPU0Rldmlj ZVBvcnQoSU9TUG9ydCk6CiAgICAgcG9ydF9uYW1lID0gJ2lvcy1kZXZpY2UnCiAKICAgICBBUkNI SVRFQ1RVUkVTID0gWydhcm12NycsICdhcm12N3MnLCAnYXJtNjQnXQogICAgIERFRkFVTFRfQVJD SElURUNUVVJFID0gJ2FybTY0JwogICAgIFZFUlNJT05fRkFMTEJBQ0tfT1JERVIgPSBbJ2lvcy03 JywgJ2lvcy04JywgJ2lvcy05JywgJ2lvcy0xMCddCisgICAgRGV2aWNlRGVsZWdhdGUgPSBBcHBs ZUFkZGl0aW9ucy5JT1NEZXZpY2VEZWxlZ2F0ZSBpZiBBcHBsZUFkZGl0aW9ucyBlbHNlIElPU0Rl dmljZURlbGVnYXRlCisgICAgU0RLID0gRGV2aWNlRGVsZWdhdGUuU0RLCisKKyAgICBkZWYgX19p bml0X18oc2VsZiwgaG9zdCwgcG9ydF9uYW1lLCAqKmt3YXJncyk6CisgICAgICAgIHN1cGVyKElP U0RldmljZVBvcnQsIHNlbGYpLl9faW5pdF9fKGhvc3QsIHBvcnRfbmFtZSwgKiprd2FyZ3MpCisg ICAgICAgIHNlbGYuX2RldmljZV9kZWxlZ2F0ZSA9IElPU0RldmljZVBvcnQuRGV2aWNlRGVsZWdh dGUoc2VsZikKKyAgICAgICAgc2VsZi5fZGV2aWNlX2RlbGVnYXRlLnBvbGxfZGV2aWNlcygpCisg ICAgICAgIG51bV9kZXZpY2VzID0gbGVuKHNlbGYuX2RldmljZV9kZWxlZ2F0ZS5kZXZpY2VfbWFw KCkpCisgICAgICAgIGlmIG51bV9kZXZpY2VzID09IDE6CisgICAgICAgICAgICBzZWxmLl9jdXJy ZW50X2RldmljZSA9IHNlbGYuX2RldmljZV9kZWxlZ2F0ZS5kZXZpY2VfbWFwKClbMF0KKyAgICAg ICAgZWxpZiBudW1fZGV2aWNlcyA8PSAwOgorICAgICAgICAgICAgbnVtX2RldmljZXMgPSAxCisg ICAgICAgIHNlbGYuc2V0X29wdGlvbignY2hpbGRfcHJvY2Vzc2VzJywgbnVtX2RldmljZXMpCisK KyAgICBkZWYgX2RldmljZV9mb3Jfd29ya2VyX251bWJlcl9tYXAoc2VsZik6CisgICAgICAgIHJl dHVybiBJT1NEZXZpY2VQb3J0LkRldmljZURlbGVnYXRlLmRldmljZV9tYXAoKQorCisgICAgZGVm IF9kcml2ZXJfY2xhc3Moc2VsZik6CisgICAgICAgIHJldHVybiBJT1NEZXZpY2VQb3J0LkRldmlj ZURlbGVnYXRlLkRFVklDRV9EUklWRVIKIAogICAgIEBjbGFzc21ldGhvZAogICAgIGRlZiBkZXRl cm1pbmVfZnVsbF9wb3J0X25hbWUoY2xzLCBob3N0LCBvcHRpb25zLCBwb3J0X25hbWUpOgogICAg ICAgICBpZiBwb3J0X25hbWUgPT0gY2xzLnBvcnRfbmFtZToKLSAgICAgICAgICAgIGlwaG9uZW9z X3Nka192ZXJzaW9uID0gaG9zdC5wbGF0Zm9ybS54Y29kZV9zZGtfdmVyc2lvbignaXBob25lb3Mn KQorICAgICAgICAgICAgaXBob25lb3Nfc2RrX3ZlcnNpb24gPSBob3N0LnBsYXRmb3JtLnhjb2Rl X3Nka192ZXJzaW9uKElPU0RldmljZVBvcnQuU0RLKQogICAgICAgICAgICAgaWYgbm90IGlwaG9u ZW9zX3Nka192ZXJzaW9uOgogICAgICAgICAgICAgICAgIHJhaXNlIEV4Y2VwdGlvbigiUGxlYXNl IGluc3RhbGwgdGhlIGlPUyBTREsuIikKICAgICAgICAgICAgIG1ham9yX3ZlcnNpb25fbnVtYmVy ID0gaXBob25lb3Nfc2RrX3ZlcnNpb24uc3BsaXQoJy4nKVswXQogICAgICAgICAgICAgcG9ydF9u YW1lID0gcG9ydF9uYW1lICsgJy0nICsgbWFqb3JfdmVyc2lvbl9udW1iZXIKICAgICAgICAgcmV0 dXJuIHBvcnRfbmFtZQogCisgICAgIyBGSVhNRTogVGhlc2UgbmVlZCBkZXZpY2UgaW1wbGVtZW50 YXRpb25zIDxyZGFyOi8vcHJvYmxlbS8zMDQ5Nzk5MT4KKyAgICBkZWYgY2hlY2tfZm9yX2xlYWtz KHNlbGYsIHByb2Nlc3NfbmFtZSwgcHJvY2Vzc19waWQpOgorICAgICAgICBwYXNzCisKKyAgICBk ZWYgbG9va19mb3JfbmV3X2NyYXNoX2xvZ3Moc2VsZiwgY3Jhc2hlZF9wcm9jZXNzZXMsIHN0YXJ0 X3RpbWUpOgorICAgICAgICByZXR1cm4ge30KKworICAgIGRlZiBsb29rX2Zvcl9uZXdfc2FtcGxl cyhzZWxmLCB1bnJlc3BvbnNpdmVfcHJvY2Vzc2VzLCBzdGFydF90aW1lKToKKyAgICAgICAgcmV0 dXJuIHt9CisKKyAgICBkZWYgc2FtcGxlX3Byb2Nlc3Moc2VsZiwgbmFtZSwgcGlkLCB0YXJnZXRf aG9zdD1Ob25lKToKKyAgICAgICAgcGFzcworCiAgICAgIyBEZXNwaXRlIHRoZWlyIG5hbWVzLCB0 aGVzZSBmbGFncyBkbyBub3QgYWN0dWFsbHkgZ2V0IHBhc3NlZCBhbGwgdGhlIHdheSBkb3duIHRv IHdlYmtpdC1idWlsZC4KICAgICBkZWYgX2J1aWxkX2RyaXZlcl9mbGFncyhzZWxmKToKLSAgICAg ICAgcmV0dXJuIFsnLS1zZGsnLCAnaXBob25lb3MnXSArIChbJ0FSQ0hTPSVzJyAlIHNlbGYuYXJj aGl0ZWN0dXJlKCldIGlmIHNlbGYuYXJjaGl0ZWN0dXJlKCkgZWxzZSBbXSkKKyAgICAgICAgcmV0 dXJuIFsnLS1zZGsnLCBJT1NEZXZpY2VQb3J0LlNES10gKyAoWydBUkNIUz0lcycgJSBzZWxmLmFy Y2hpdGVjdHVyZSgpXSBpZiBzZWxmLmFyY2hpdGVjdHVyZSgpIGVsc2UgW10pCiAKICAgICBkZWYg b3BlcmF0aW5nX3N5c3RlbShzZWxmKToKICAgICAgICAgcmV0dXJuICdpb3MtZGV2aWNlJworCisg ICAgZGVmIF9jcmVhdGVfZGV2aWNlcyhzZWxmLCBkZXZpY2VfY2xhc3MpOgorICAgICAgICBzZWxm Ll9kZXZpY2VfZGVsZWdhdGUucG9sbF9kZXZpY2VzKCkKKyAgICAgICAgaWYgbm90IEFwcGxlQWRk aXRpb25zOgorICAgICAgICAgICAgcmFpc2UgUnVudGltZUVycm9yKCdPbi1kZXZpY2UgdGVzdGlu ZyBpcyBub3Qgc3VwcG9ydGVkIG9uIHRoaXMgbWFjaGluZScpCisgICAgICAgIGVsaWYgbm90IHNl bGYuX2RldmljZV9kZWxlZ2F0ZS5kZXZpY2VfbWFwKCk6CisgICAgICAgICAgICByYWlzZSBSdW50 aW1lRXJyb3IoJ05vIGRldmljZXMgYXJlIGF2YWlsYWJsZSBmb3IgdGVzdGluZycpCisgICAgICAg IHNlbGYuX2RldmljZV9kZWxlZ2F0ZS5zZXR1cF9kZXZpY2VzX2Zvcl9hdXRvbWF0aW9uKCkKKwor ICAgIGRlZiBjbGVhbl91cF90ZXN0X3J1bihzZWxmKToKKyAgICAgICAgc3VwZXIoSU9TRGV2aWNl UG9ydCwgc2VsZikuY2xlYW5fdXBfdGVzdF9ydW4oKQorICAgICAgICBzZWxmLl9kZXZpY2VfZGVs ZWdhdGUudGVhcmRvd25fZGV2aWNlc19hZnRlcl9hdXRvbWF0aW9uKCkKSW5kZXg6IFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlX3VuaXR0ZXN0LnB5Cj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlX3VuaXR0ZXN0LnB5CShyZXZp c2lvbiAyMTUxOTUpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZV91 bml0dGVzdC5weQkod29ya2luZyBjb3B5KQpAQCAtMzYsMyArMzYsMTMgQEAgY2xhc3MgSU9TRGV2 aWNlVGVzdChpb3NfdGVzdGNhc2UuSU9TVGVzdAogCiAgICAgZGVmIHRlc3Rfb3BlcmF0aW5nX3N5 c3RlbShzZWxmKToKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnaW9zLWRldmljZScsIHNlbGYu bWFrZV9wb3J0KCkub3BlcmF0aW5nX3N5c3RlbSgpKQorCisgICAgIyBGSVhNRTogVXBkYXRlIHRl c3RzIHdoZW4gPHJkYXI6Ly9wcm9ibGVtLzMwNDk3OTkxPiBpcyBjb21wbGV0ZWQKKyAgICBkZWYg dGVzdF9zcGluZHVtcChzZWxmKToKKyAgICAgICAgcGFzcworCisgICAgZGVmIHRlc3Rfc2FtcGxl X3Byb2Nlc3Moc2VsZik6CisgICAgICAgIHBhc3MKKworICAgIGRlZiB0ZXN0X3NhbXBsZV9wcm9j ZXNzX2V4Y2VwdGlvbihzZWxmKToKKyAgICAgICAgcGFzcwo= 307389 2017-04-18 09:50:59 -0700 2017-04-18 17:26:23 -0700 Patch bug-170461-20170418095102.patch text/plain 10637 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNTQ2MykKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDQyIEBACisyMDE3LTA0LTE4ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIGFwcGxlX2FkZGl0aW9ucyB0byB3ZWJraXRweSB0 byBpbnNlcnQgSW50ZXJuYWwgdG9vbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3MDQ2MQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzE0MzMwNzc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWxsb3cg YSBwYWNrYWdlIHRvIGJlIHB1bGxlZCBpbiBieSBydW4td2Via2l0LXRlc3RzIHdoaWNoIHByb3Zp ZGVzIGFuIGludGVyZmFjZSB0bworICAgICAgICBydW4gbGF5b3V0IHRlc3RzIG9uIGFuIGlPUyBk ZXZpY2UuICBJZiB0aGlzIHBhY2thZ2UgaXMgbm90IGF2YWlsYWJsZSwgdGhyb3cgYW4KKyAgICAg ICAgZXhjZXB0aW9uIHdoZW4gYXR0ZW1wdGluZyB0byBydW4gbGF5b3V0IHRlc3RzIG9uIGFuIGlP UyBkZXZpY2UuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9hZGRpdGlvbnMu cHk6IEFkZGVkLgorICAgICAgICAoYXBwbGVfYWRkaXRpb25zKTogSW1wb3J0IGFuZCByZXR1cm4g YXBwbGVfYWRkaXRpb25zIGV4cG9ydHMsIGlmIHRoZXkgZXhpc3QuCisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9wb3J0L2RldmljZS5weToKKyAgICAgICAgKERldmljZS5wcmVwYXJlX2Zvcl90 ZXN0aW5nKTogUGFzcyBsaXN0ZW5pbmcgcG9ydCB0byBzZXR1cC4KKyAgICAgICAgKERldmljZS5m aW5pc2hlZF90ZXN0aW5nKTogQ2FsbCBjb3JyZWN0IHRlYXItZG93biBmdW5jdGlvbi4KKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weToKKyAgICAgICAgKHBsYXRmb3Jt X29wdGlvbnMpOiBJbnNlcnQgYWRkaXRpb25hbCBwbGF0Zm9ybSBvcHRpb25zLgorICAgICAgICAq IFNjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5OgorICAgICAgICAoSU9TRGV2aWNl RGVsZWdhdGUpOiBQcm92aWRlcyBmdW5jdGlvbmFsaXR5IHRvIElPU0RldmljZVBvcnQgZm9yIG9u LWRldmljZSB0ZXN0aW5nLgorICAgICAgICAoSU9TRGV2aWNlUG9ydCk6CisgICAgICAgIChJT1NE ZXZpY2VQb3J0Ll9faW5pdF9fKToKKyAgICAgICAgKElPU0RldmljZVBvcnQuX2RldmljZV9mb3Jf d29ya2VyX251bWJlcl9tYXApOiAKKyAgICAgICAgKElPU0RldmljZVBvcnQuX2RyaXZlcl9jbGFz cyk6CisgICAgICAgIChJT1NEZXZpY2VQb3J0LmRldGVybWluZV9mdWxsX3BvcnRfbmFtZSk6IFVz ZSBTREsgdmFyaWFibGUuCisgICAgICAgIChJT1NEZXZpY2VQb3J0LmNoZWNrX2Zvcl9sZWFrcyk6 IE5vIGltcGxlbWVudGF0aW9uLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5sb29rX2Zvcl9uZXdf Y3Jhc2hfbG9ncyk6IERpdHRvLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5sb29rX2Zvcl9uZXdf c2FtcGxlcyk6IERpdHRvLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5zYW1wbGVfcHJvY2Vzcyk6 IERpdHRvLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5fYnVpbGRfZHJpdmVyX2ZsYWdzKTogVXNl IFNESyB2YXJpYWJsZS4KKyAgICAgICAgKElPU0RldmljZVBvcnQuX2NyZWF0ZV9kZXZpY2VzKTog UG9sbCBkZXZpY2VzIGFuZCBzZXQgYWxsIG9mIHRoZW0gdXAgZm9yIGF1dG9tYXRpb24uCisgICAg ICAgIChJT1NEZXZpY2VQb3J0LmNsZWFuX3VwX3Rlc3RfcnVuKTogVGVhciBhbGwgZGV2aWNlcyBk b3duLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlX3VuaXR0ZXN0 LnB5OgorICAgICAgICAoSU9TRGV2aWNlVGVzdCk6CisgICAgICAgIChJT1NEZXZpY2VUZXN0LnRl c3Rfc3BpbmR1bXApOiBJZ25vcmUgdGVzdCBmb3IgdGhlIElPU0RldmljZVBvcnQuCisgICAgICAg IChJT1NEZXZpY2VUZXN0LnRlc3Rfc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElP U0RldmljZVRlc3QudGVzdF9zYW1wbGVfcHJvY2Vzc19leGNlcHRpb24pOiBEaXR0by4KKwogMjAx Ny0wNC0xNyAgQWxleCBDaHJpc3RlbnNlbiAgPGFjaHJpc3RlbnNlbkB3ZWJraXQub3JnPgogCiAg ICAgICAgIEFsbG93IFZhcmlhbnRzIG9mIFJldGFpblB0cnMKSW5kZXg6IFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL2FkZGl0aW9ucy5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9hZGRpdGlvbnMucHkJKG5vbmV4aXN0ZW50KQorKysgVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vYWRkaXRpb25zLnB5CSh3b3JraW5nIGNvcHkpCkBAIC0wLDAg KzEsMjkgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE3IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworIyBhcmUgbWV0OgorIyAxLiAgUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyMgICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyMgMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisjICAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisjICAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g QU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORAorIyBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElF RAorIyBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFCisjIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExF IElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SCisjIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwK KyMgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IKKyMgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIKKyMgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJ QUJJTElUWSwKKyMgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworCitkZWYg YXBwbGVfYWRkaXRpb25zKCk6CisgICAgdHJ5OgorICAgICAgICBpbXBvcnQgYXBwbGVfYWRkaXRp b25zIGFzIHJlc3VsdAorICAgICAgICByZXR1cm4gcmVzdWx0CisgICAgZXhjZXB0IEltcG9ydEVy cm9yOgorICAgICAgICByZXR1cm4gTm9uZQpJbmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L2RldmljZS5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQv ZGV2aWNlLnB5CShyZXZpc2lvbiAyMTU0MDkpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3Bv cnQvZGV2aWNlLnB5CSh3b3JraW5nIGNvcHkpCkBAIC00NSwxMCArNDUsMTAgQEAgY2xhc3MgRGV2 aWNlKG9iamVjdCk6CiAgICAgICAgICAgICBzZWxmLmxpc3RlbmluZ19zb2NrZXQuYmluZCgoJzEy Ny4wLjAuMScsIDApKQogCiAgICAgICAgIGlmIGhhc2F0dHIoc2VsZi5wbGF0Zm9ybV9kZXZpY2Us ICdwcmVwYXJlX2Zvcl90ZXN0aW5nJyk6Ci0gICAgICAgICAgICBzZWxmLnBsYXRmb3JtX2Rldmlj ZS5wcmVwYXJlX2Zvcl90ZXN0aW5nKCkKKyAgICAgICAgICAgIHNlbGYucGxhdGZvcm1fZGV2aWNl LnByZXBhcmVfZm9yX3Rlc3RpbmcobGlzdGVuaW5nX3BvcnQ9c2VsZi5saXN0ZW5pbmdfcG9ydCgp KQogCiAgICAgZGVmIGZpbmlzaGVkX3Rlc3Rpbmcoc2VsZik6Ci0gICAgICAgIGlmIGhhc2F0dHIo c2VsZi5wbGF0Zm9ybV9kZXZpY2UsICd0ZWFyZG93bicpOgorICAgICAgICBpZiBoYXNhdHRyKHNl bGYucGxhdGZvcm1fZGV2aWNlLCAnZmluaXNoZWRfdGVzdGluZycpOgogICAgICAgICAgICAgc2Vs Zi5wbGF0Zm9ybV9kZXZpY2UuZmluaXNoZWRfdGVzdGluZygpCiAKICAgICAgICAgc2VsZi5saXN0 ZW5pbmdfc29ja2V0ID0gTm9uZQpJbmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2Zh Y3RvcnkucHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2ZhY3Rv cnkucHkJKHJldmlzaW9uIDIxNTQwOSkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9m YWN0b3J5LnB5CSh3b3JraW5nIGNvcHkpCkBAIC0zNiw2ICszNiw3IEBAIGltcG9ydCByZQogCiBm cm9tIHdlYmtpdHB5LnBvcnQgaW1wb3J0IGJ1aWxkZXJzCiBmcm9tIHdlYmtpdHB5LnBvcnQgaW1w b3J0IGNvbmZpZworZnJvbSB3ZWJraXRweS5jb21tb24uYWRkaXRpb25zIGltcG9ydCBhcHBsZV9h ZGRpdGlvbnMKIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgZXhlY3V0aXZlCiBm cm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IGZpbGVzeXN0ZW0KIApAQCAtNTksNyAr NjAsNyBAQCBkZWYgcGxhdGZvcm1fb3B0aW9ucyh1c2VfZ2xvYnM9RmFsc2UpOgogICAgICAgICBv cHRwYXJzZS5tYWtlX29wdGlvbignLS1uby1pbnN0YWxsJywgYWN0aW9uPSdzdG9yZV9jb25zdCcs CiAgICAgICAgICAgICBjb25zdD1GYWxzZSwgZGVmYXVsdD1UcnVlLCBkZXN0PSdpbnN0YWxsJywK ICAgICAgICAgICAgIGhlbHA9J1NraXAgaW5zdGFsbCBzdGVwIGZvciBkZXZpY2UgYW5kIHNpbXVs YXRvciB0ZXN0aW5nJyksCi0gICAgICAgIF0KKyAgICAgICAgXSArIChhcHBsZV9hZGRpdGlvbnMo KS5wbGF0Zm9ybV9vcHRpb25zKCkgaWYgYXBwbGVfYWRkaXRpb25zKCkgZWxzZSBbXSkKIAogCiBk ZWYgY29uZmlndXJhdGlvbl9vcHRpb25zKCk6CkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvaW9zX2RldmljZS5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvaW9zX2RldmljZS5weQkocmV2aXNpb24gMjE1NDA5KQorKysgVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9wb3J0L2lvc19kZXZpY2UucHkJKHdvcmtpbmcgY29weSkKQEAgLTIxLDEwICsyMSwy NyBAQAogIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgogCiBpbXBvcnQgbG9nZ2luZworaW1wb3J0IHdlYmtpdHB5LmNv bW1vbi5hZGRpdGlvbnMgYXMgYWRkaXRpb25zCiAKK2Zyb20gd2Via2l0cHkucG9ydC5kcml2ZXIg aW1wb3J0IERyaXZlcgogZnJvbSB3ZWJraXRweS5wb3J0LmlvcyBpbXBvcnQgSU9TUG9ydAogCiBf bG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCithcHBsZV9hZGRpdGlvbnNfbW9kdWxl ID0gYWRkaXRpb25zLmFwcGxlX2FkZGl0aW9ucygpCisKKworY2xhc3MgSU9TRGV2aWNlRGVsZWdh dGUob2JqZWN0KToKKyAgICBTREsgPSAnaXBob25lb3MnCisgICAgREVWSUNFX0RSSVZFUiA9IERy aXZlcgorCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQpOgorICAgICAgICBzZWxmLl9wb3J0 ID0gcG9ydAorCisgICAgZGVmIHNldHVwX2RldmljZXNfZm9yX2F1dG9tYXRpb24oc2VsZik6Cisg ICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IKKworICAgIGRlZiB0ZWFyZG93bl9kZXZp Y2VzX2FmdGVyX2F1dG9tYXRpb24oc2VsZik6CisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVk RXJyb3IKIAogCiBjbGFzcyBJT1NEZXZpY2VQb3J0KElPU1BvcnQpOgpAQCAtMzMsMjAgKzUwLDcw IEBAIGNsYXNzIElPU0RldmljZVBvcnQoSU9TUG9ydCk6CiAgICAgQVJDSElURUNUVVJFUyA9IFsn YXJtdjcnLCAnYXJtdjdzJywgJ2FybTY0J10KICAgICBERUZBVUxUX0FSQ0hJVEVDVFVSRSA9ICdh cm02NCcKICAgICBWRVJTSU9OX0ZBTExCQUNLX09SREVSID0gWydpb3MtNycsICdpb3MtOCcsICdp b3MtOScsICdpb3MtMTAnXQorICAgIERldmljZURlbGVnYXRlID0gYXBwbGVfYWRkaXRpb25zX21v ZHVsZS5pb3NfZGV2aWNlX2RlbGVnYXRlKCkgaWYgYXBwbGVfYWRkaXRpb25zX21vZHVsZSBlbHNl IElPU0RldmljZURlbGVnYXRlCisgICAgU0RLID0gRGV2aWNlRGVsZWdhdGUuU0RLCisKKyAgICBk ZWYgX19pbml0X18oc2VsZiwgaG9zdCwgcG9ydF9uYW1lLCAqKmt3YXJncyk6CisgICAgICAgIHN1 cGVyKElPU0RldmljZVBvcnQsIHNlbGYpLl9faW5pdF9fKGhvc3QsIHBvcnRfbmFtZSwgKiprd2Fy Z3MpCisgICAgICAgIHNlbGYuX2RldmljZV9kZWxlZ2F0ZSA9IElPU0RldmljZVBvcnQuRGV2aWNl RGVsZWdhdGUoc2VsZikKKyAgICAgICAgaWYgYXBwbGVfYWRkaXRpb25zX21vZHVsZToKKyAgICAg ICAgICAgIGFwcGxlX2FkZGl0aW9uc19tb2R1bGUucG9sbF9pb3NfZGV2aWNlcyhzZWxmKQorICAg ICAgICAgICAgbnVtX2RldmljZXMgPSBsZW4oYXBwbGVfYWRkaXRpb25zX21vZHVsZS5jb25uZWN0 ZWRfaW9zX2RldmljZXMoKSkKKyAgICAgICAgICAgIGlmIG51bV9kZXZpY2VzID09IDE6CisgICAg ICAgICAgICAgICAgc2VsZi5fY3VycmVudF9kZXZpY2UgPSBhcHBsZV9hZGRpdGlvbnNfbW9kdWxl LmNvbm5lY3RlZF9pb3NfZGV2aWNlcygpWzBdCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBz ZWxmLl9jdXJyZW50X2RldmljZSA9IE5vbmUKKyAgICAgICAgICAgIG51bV9kZXZpY2VzID0gMQor ICAgICAgICBpZiBudW1fZGV2aWNlcyA8PSAwOgorICAgICAgICAgICAgbnVtX2RldmljZXMgPSAx CisgICAgICAgIHNlbGYuc2V0X29wdGlvbignY2hpbGRfcHJvY2Vzc2VzJywgbnVtX2RldmljZXMp CisKKyAgICBkZWYgX2RldmljZV9mb3Jfd29ya2VyX251bWJlcl9tYXAoc2VsZik6CisgICAgICAg IGlmIG5vdCBhcHBsZV9hZGRpdGlvbnNfbW9kdWxlOgorICAgICAgICAgICAgcmFpc2UgUnVudGlt ZUVycm9yKCdObyAnKQorICAgICAgICByZXR1cm4gYXBwbGVfYWRkaXRpb25zX21vZHVsZS5jb25u ZWN0ZWRfaW9zX2RldmljZXMoKQorCisgICAgZGVmIF9kcml2ZXJfY2xhc3Moc2VsZik6CisgICAg ICAgIHJldHVybiBJT1NEZXZpY2VQb3J0LkRldmljZURlbGVnYXRlLkRFVklDRV9EUklWRVIKIAog ICAgIEBjbGFzc21ldGhvZAogICAgIGRlZiBkZXRlcm1pbmVfZnVsbF9wb3J0X25hbWUoY2xzLCBo b3N0LCBvcHRpb25zLCBwb3J0X25hbWUpOgogICAgICAgICBpZiBwb3J0X25hbWUgPT0gY2xzLnBv cnRfbmFtZToKLSAgICAgICAgICAgIGlwaG9uZW9zX3Nka192ZXJzaW9uID0gaG9zdC5wbGF0Zm9y bS54Y29kZV9zZGtfdmVyc2lvbignaXBob25lb3MnKQorICAgICAgICAgICAgaXBob25lb3Nfc2Rr X3ZlcnNpb24gPSBob3N0LnBsYXRmb3JtLnhjb2RlX3Nka192ZXJzaW9uKElPU0RldmljZVBvcnQu U0RLKQogICAgICAgICAgICAgaWYgbm90IGlwaG9uZW9zX3Nka192ZXJzaW9uOgogICAgICAgICAg ICAgICAgIHJhaXNlIEV4Y2VwdGlvbigiUGxlYXNlIGluc3RhbGwgdGhlIGlPUyBTREsuIikKICAg ICAgICAgICAgIG1ham9yX3ZlcnNpb25fbnVtYmVyID0gaXBob25lb3Nfc2RrX3ZlcnNpb24uc3Bs aXQoJy4nKVswXQogICAgICAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lICsgJy0nICsgbWFq b3JfdmVyc2lvbl9udW1iZXIKICAgICAgICAgcmV0dXJuIHBvcnRfbmFtZQogCisgICAgIyBGSVhN RTogVGhlc2UgbmVlZCBkZXZpY2UgaW1wbGVtZW50YXRpb25zIDxyZGFyOi8vcHJvYmxlbS8zMDQ5 Nzk5MT4KKyAgICBkZWYgY2hlY2tfZm9yX2xlYWtzKHNlbGYsIHByb2Nlc3NfbmFtZSwgcHJvY2Vz c19waWQpOgorICAgICAgICBwYXNzCisKKyAgICBkZWYgbG9va19mb3JfbmV3X2NyYXNoX2xvZ3Mo c2VsZiwgY3Jhc2hlZF9wcm9jZXNzZXMsIHN0YXJ0X3RpbWUpOgorICAgICAgICByZXR1cm4ge30K KworICAgIGRlZiBsb29rX2Zvcl9uZXdfc2FtcGxlcyhzZWxmLCB1bnJlc3BvbnNpdmVfcHJvY2Vz c2VzLCBzdGFydF90aW1lKToKKyAgICAgICAgcmV0dXJuIHt9CisKKyAgICBkZWYgc2FtcGxlX3By b2Nlc3Moc2VsZiwgbmFtZSwgcGlkLCB0YXJnZXRfaG9zdD1Ob25lKToKKyAgICAgICAgcGFzcwor CiAgICAgIyBEZXNwaXRlIHRoZWlyIG5hbWVzLCB0aGVzZSBmbGFncyBkbyBub3QgYWN0dWFsbHkg Z2V0IHBhc3NlZCBhbGwgdGhlIHdheSBkb3duIHRvIHdlYmtpdC1idWlsZC4KICAgICBkZWYgX2J1 aWxkX2RyaXZlcl9mbGFncyhzZWxmKToKLSAgICAgICAgcmV0dXJuIFsnLS1zZGsnLCAnaXBob25l b3MnXSArIChbJ0FSQ0hTPSVzJyAlIHNlbGYuYXJjaGl0ZWN0dXJlKCldIGlmIHNlbGYuYXJjaGl0 ZWN0dXJlKCkgZWxzZSBbXSkKKyAgICAgICAgcmV0dXJuIFsnLS1zZGsnLCBJT1NEZXZpY2VQb3J0 LlNES10gKyAoWydBUkNIUz0lcycgJSBzZWxmLmFyY2hpdGVjdHVyZSgpXSBpZiBzZWxmLmFyY2hp dGVjdHVyZSgpIGVsc2UgW10pCiAKICAgICBkZWYgb3BlcmF0aW5nX3N5c3RlbShzZWxmKToKICAg ICAgICAgcmV0dXJuICdpb3MtZGV2aWNlJworCisgICAgZGVmIF9jcmVhdGVfZGV2aWNlcyhzZWxm LCBkZXZpY2VfY2xhc3MpOgorICAgICAgICBpZiBub3QgYXBwbGVfYWRkaXRpb25zX21vZHVsZToK KyAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignT24tZGV2aWNlIHRlc3RpbmcgaXMgbm90 IHN1cHBvcnRlZCBvbiB0aGlzIG1hY2hpbmUnKQorICAgICAgICBhcHBsZV9hZGRpdGlvbnNfbW9k dWxlLnBvbGxfaW9zX2RldmljZXMoc2VsZikKKyAgICAgICAgaWYgbm90IGFwcGxlX2FkZGl0aW9u c19tb2R1bGUuY29ubmVjdGVkX2lvc19kZXZpY2VzKCk6CisgICAgICAgICAgICByYWlzZSBSdW50 aW1lRXJyb3IoJ05vIGRldmljZXMgYXJlIGF2YWlsYWJsZSBmb3IgdGVzdGluZycpCisgICAgICAg IHNlbGYuX2RldmljZV9kZWxlZ2F0ZS5zZXR1cF9kZXZpY2VzX2Zvcl9hdXRvbWF0aW9uKCkKKwor ICAgIGRlZiBjbGVhbl91cF90ZXN0X3J1bihzZWxmKToKKyAgICAgICAgc3VwZXIoSU9TRGV2aWNl UG9ydCwgc2VsZikuY2xlYW5fdXBfdGVzdF9ydW4oKQorICAgICAgICBzZWxmLl9kZXZpY2VfZGVs ZWdhdGUudGVhcmRvd25fZGV2aWNlc19hZnRlcl9hdXRvbWF0aW9uKCkKSW5kZXg6IFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlX3VuaXR0ZXN0LnB5Cj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlX3VuaXR0ZXN0LnB5CShyZXZp c2lvbiAyMTU0MDkpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZV91 bml0dGVzdC5weQkod29ya2luZyBjb3B5KQpAQCAtMzYsMyArMzYsMTMgQEAgY2xhc3MgSU9TRGV2 aWNlVGVzdChpb3NfdGVzdGNhc2UuSU9TVGVzdAogCiAgICAgZGVmIHRlc3Rfb3BlcmF0aW5nX3N5 c3RlbShzZWxmKToKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnaW9zLWRldmljZScsIHNlbGYu bWFrZV9wb3J0KCkub3BlcmF0aW5nX3N5c3RlbSgpKQorCisgICAgIyBGSVhNRTogVXBkYXRlIHRl c3RzIHdoZW4gPHJkYXI6Ly9wcm9ibGVtLzMwNDk3OTkxPiBpcyBjb21wbGV0ZWQKKyAgICBkZWYg dGVzdF9zcGluZHVtcChzZWxmKToKKyAgICAgICAgcGFzcworCisgICAgZGVmIHRlc3Rfc2FtcGxl X3Byb2Nlc3Moc2VsZik6CisgICAgICAgIHBhc3MKKworICAgIGRlZiB0ZXN0X3NhbXBsZV9wcm9j ZXNzX2V4Y2VwdGlvbihzZWxmKToKKyAgICAgICAgcGFzcwo= 307442 2017-04-18 17:26:24 -0700 2017-04-27 14:51:53 -0700 Patch bug-170461-20170418172623.patch text/plain 9189 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNTQ4OSkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDQyIEBACisyMDE3LTA0LTE4ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIGFwcGxlX2FkZGl0aW9ucyB0byB3ZWJraXRweSB0 byBpbnNlcnQgSW50ZXJuYWwgdG9vbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3MDQ2MQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzE0MzMwNzc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWxsb3cg YSBwYWNrYWdlIHRvIGJlIHB1bGxlZCBpbiBieSBydW4td2Via2l0LXRlc3RzIHdoaWNoIHByb3Zp ZGVzIGFuIGludGVyZmFjZSB0bworICAgICAgICBydW4gbGF5b3V0IHRlc3RzIG9uIGFuIGlPUyBk ZXZpY2UuICBJZiB0aGlzIHBhY2thZ2UgaXMgbm90IGF2YWlsYWJsZSwgdGhyb3cgYW4KKyAgICAg ICAgZXhjZXB0aW9uIHdoZW4gYXR0ZW1wdGluZyB0byBydW4gbGF5b3V0IHRlc3RzIG9uIGFuIGlP UyBkZXZpY2UuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvY29uZmlnLnB5Ogor ICAgICAgICAoYXBwbGVfYWRkaXRpb25zKTogSW1wb3J0IGFwcGxlX2FkZGl0aW9ucyBwYWNrYWdl LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9kZXZpY2UucHk6CisgICAgICAgIChE ZXZpY2UucHJlcGFyZV9mb3JfdGVzdGluZyk6IFBhc3MgbGlzdGVuaW5nIHBvcnQgdG8gc2V0dXAu CisgICAgICAgIChEZXZpY2UuZmluaXNoZWRfdGVzdGluZyk6IENhbGwgY29ycmVjdCB0ZWFyLWRv d24gZnVuY3Rpb24uCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0L2ZhY3RvcnkucHk6 CisgICAgICAgIChwbGF0Zm9ybV9vcHRpb25zKTogSW5zZXJ0IGFkZGl0aW9uYWwgcGxhdGZvcm0g b3B0aW9ucy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5weToK KyAgICAgICAgKElPU0RldmljZURlbGVnYXRlKTogUHJvdmlkZXMgZnVuY3Rpb25hbGl0eSB0byBJ T1NEZXZpY2VQb3J0IGZvciBvbi1kZXZpY2UgdGVzdGluZy4KKyAgICAgICAgKElPU0RldmljZVBv cnQpOgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5fX2luaXRfXyk6CisgICAgICAgIChJT1NEZXZp Y2VQb3J0Ll9kZXZpY2VfZm9yX3dvcmtlcl9udW1iZXJfbWFwKTogCisgICAgICAgIChJT1NEZXZp Y2VQb3J0Ll9kcml2ZXJfY2xhc3MpOgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5kZXRlcm1pbmVf ZnVsbF9wb3J0X25hbWUpOiBVc2UgU0RLIHZhcmlhYmxlLgorICAgICAgICAoSU9TRGV2aWNlUG9y dC5jaGVja19mb3JfbGVha3MpOiBObyBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgKElPU0Rldmlj ZVBvcnQubG9va19mb3JfbmV3X2NyYXNoX2xvZ3MpOiBEaXR0by4KKyAgICAgICAgKElPU0Rldmlj ZVBvcnQubG9va19mb3JfbmV3X3NhbXBsZXMpOiBEaXR0by4KKyAgICAgICAgKElPU0RldmljZVBv cnQuc2FtcGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElPU0RldmljZVBvcnQuX2J1aWxk X2RyaXZlcl9mbGFncyk6IFVzZSBTREsgdmFyaWFibGUuCisgICAgICAgIChJT1NEZXZpY2VQb3J0 Ll9jcmVhdGVfZGV2aWNlcyk6IFBvbGwgZGV2aWNlcyBhbmQgc2V0IGFsbCBvZiB0aGVtIHVwIGZv ciBhdXRvbWF0aW9uLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5jbGVhbl91cF90ZXN0X3J1bik6 IFRlYXIgYWxsIGRldmljZXMgZG93bi4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQv aW9zX2RldmljZV91bml0dGVzdC5weToKKyAgICAgICAgKElPU0RldmljZVRlc3QpOgorICAgICAg ICAoSU9TRGV2aWNlVGVzdC50ZXN0X3NwaW5kdW1wKTogSWdub3JlIHRlc3QgZm9yIHRoZSBJT1NE ZXZpY2VQb3J0LgorICAgICAgICAoSU9TRGV2aWNlVGVzdC50ZXN0X3NhbXBsZV9wcm9jZXNzKTog RGl0dG8uCisgICAgICAgIChJT1NEZXZpY2VUZXN0LnRlc3Rfc2FtcGxlX3Byb2Nlc3NfZXhjZXB0 aW9uKTogRGl0dG8uCisKIDIwMTctMDQtMTggIEpvaG4gV2lsYW5kZXIgIDx3aWxhbmRlckBhcHBs ZS5jb20+CiAKICAgICAgICAgTWFrZSBXZWJDb3JlOjp0b3BQcml2YXRlbHlDb250cm9sbGVkRG9t YWluKCkgcmV0dXJuICJsb2NhbGhvc3QiIGZvciBsb2NhbGhvc3QKSW5kZXg6IFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9jb25maWcucHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9wb3J0L2NvbmZpZy5weQkocmV2aXNpb24gMjE1NDcyKQorKysgVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9wb3J0L2NvbmZpZy5weQkod29ya2luZyBjb3B5KQpAQCAtMzMsNiArMzMsNyBA QAogaW1wb3J0IGxvZ2dpbmcKIAogZnJvbSB3ZWJraXRweS5jb21tb24gaW1wb3J0IHdlYmtpdF9m aW5kZXIKK2Zyb20gd2Via2l0cHkuY29tbW9uLm1lbW9pemVkIGltcG9ydCBtZW1vaXplZAogCiAK IF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKQEAgLTU0LDYgKzU1LDE0IEBAIGRl ZiBjbGVhcl9jYWNoZWRfY29uZmlndXJhdGlvbigpOgogICAgIF9jb25maWd1cmF0aW9uID0gIlJl bGVhc2UiCiAKIAorQG1lbW9pemVkCitkZWYgYXBwbGVfYWRkaXRpb25zKCk6CisgICAgdHJ5Ogor ICAgICAgICByZXR1cm4gX19pbXBvcnRfXygnYXBwbGVfYWRkaXRpb25zJywgZ2xvYmFscygpLCBO b25lLCBbXSwgMCkKKyAgICBleGNlcHQgSW1wb3J0RXJyb3I6CisgICAgICAgIHJldHVybiBOb25l CisKKwogY2xhc3MgQ29uZmlnKG9iamVjdCk6CiAgICAgX0ZMQUdTX0ZST01fQ09ORklHVVJBVElP TlMgPSB7CiAgICAgICAgICJEZWJ1ZyI6ICItLWRlYnVnIiwKSW5kZXg6IFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9kZXZpY2UucHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9wb3J0L2RldmljZS5weQkocmV2aXNpb24gMjE1NDcyKQorKysgVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9wb3J0L2RldmljZS5weQkod29ya2luZyBjb3B5KQpAQCAtNDUsMTAgKzQ1LDEwIEBA IGNsYXNzIERldmljZShvYmplY3QpOgogICAgICAgICAgICAgc2VsZi5saXN0ZW5pbmdfc29ja2V0 LmJpbmQoKCcxMjcuMC4wLjEnLCAwKSkKIAogICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZv cm1fZGV2aWNlLCAncHJlcGFyZV9mb3JfdGVzdGluZycpOgotICAgICAgICAgICAgc2VsZi5wbGF0 Zm9ybV9kZXZpY2UucHJlcGFyZV9mb3JfdGVzdGluZygpCisgICAgICAgICAgICBzZWxmLnBsYXRm b3JtX2RldmljZS5wcmVwYXJlX2Zvcl90ZXN0aW5nKGxpc3RlbmluZ19wb3J0PXNlbGYubGlzdGVu aW5nX3BvcnQoKSkKIAogICAgIGRlZiBmaW5pc2hlZF90ZXN0aW5nKHNlbGYpOgotICAgICAgICBp ZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2aWNlLCAndGVhcmRvd24nKToKKyAgICAgICAgaWYg aGFzYXR0cihzZWxmLnBsYXRmb3JtX2RldmljZSwgJ2ZpbmlzaGVkX3Rlc3RpbmcnKToKICAgICAg ICAgICAgIHNlbGYucGxhdGZvcm1fZGV2aWNlLmZpbmlzaGVkX3Rlc3RpbmcoKQogCiAgICAgICAg IHNlbGYubGlzdGVuaW5nX3NvY2tldCA9IE5vbmUKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9mYWN0b3J5LnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv cG9ydC9mYWN0b3J5LnB5CShyZXZpc2lvbiAyMTU0NzIpCisrKyBUb29scy9TY3JpcHRzL3dlYmtp dHB5L3BvcnQvZmFjdG9yeS5weQkod29ya2luZyBjb3B5KQpAQCAtNTksNyArNTksNyBAQCBkZWYg cGxhdGZvcm1fb3B0aW9ucyh1c2VfZ2xvYnM9RmFsc2UpOgogICAgICAgICBvcHRwYXJzZS5tYWtl X29wdGlvbignLS1uby1pbnN0YWxsJywgYWN0aW9uPSdzdG9yZV9jb25zdCcsCiAgICAgICAgICAg ICBjb25zdD1GYWxzZSwgZGVmYXVsdD1UcnVlLCBkZXN0PSdpbnN0YWxsJywKICAgICAgICAgICAg IGhlbHA9J1NraXAgaW5zdGFsbCBzdGVwIGZvciBkZXZpY2UgYW5kIHNpbXVsYXRvciB0ZXN0aW5n JyksCi0gICAgICAgIF0KKyAgICAgICAgXSArIChjb25maWcuYXBwbGVfYWRkaXRpb25zKCkucGxh dGZvcm1fb3B0aW9ucygpIGlmIGNvbmZpZy5hcHBsZV9hZGRpdGlvbnMoKSBlbHNlIFtdKQogCiAK IGRlZiBjb25maWd1cmF0aW9uX29wdGlvbnMoKToKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9pb3NfZGV2aWNlLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9pb3NfZGV2aWNlLnB5CShyZXZpc2lvbiAyMTU0NzIpCisrKyBUb29scy9TY3JpcHRz L3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5weQkod29ya2luZyBjb3B5KQpAQCAtMjIsMzEgKzIy LDk3IEBACiAKIGltcG9ydCBsb2dnaW5nCiAKK2Zyb20gd2Via2l0cHkucG9ydC5jb25maWcgaW1w b3J0IGFwcGxlX2FkZGl0aW9ucworZnJvbSB3ZWJraXRweS5wb3J0LmRyaXZlciBpbXBvcnQgRHJp dmVyCiBmcm9tIHdlYmtpdHB5LnBvcnQuaW9zIGltcG9ydCBJT1NQb3J0CiAKIF9sb2cgPSBsb2dn aW5nLmdldExvZ2dlcihfX25hbWVfXykKIAogCitjbGFzcyBJT1NEZXZpY2VEZWxlZ2F0ZShvYmpl Y3QpOgorICAgIFNESyA9ICdpcGhvbmVvcycKKyAgICBERVZJQ0VfRFJJVkVSID0gRHJpdmVyCisK KyAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCk6CisgICAgICAgIHNlbGYuX3BvcnQgPSBwb3J0 CisKKyAgICBkZWYgc2V0dXBfZGV2aWNlc19mb3JfYXV0b21hdGlvbihzZWxmKToKKyAgICAgICAg cmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcgorCisgICAgZGVmIHRlYXJkb3duX2RldmljZXNfYWZ0 ZXJfYXV0b21hdGlvbihzZWxmKToKKyAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcgor CisKIGNsYXNzIElPU0RldmljZVBvcnQoSU9TUG9ydCk6CiAgICAgcG9ydF9uYW1lID0gJ2lvcy1k ZXZpY2UnCiAKICAgICBBUkNISVRFQ1RVUkVTID0gWydhcm12NycsICdhcm12N3MnLCAnYXJtNjQn XQogICAgIERFRkFVTFRfQVJDSElURUNUVVJFID0gJ2FybTY0JwogICAgIFZFUlNJT05fRkFMTEJB Q0tfT1JERVIgPSBbJ2lvcy03JywgJ2lvcy04JywgJ2lvcy05JywgJ2lvcy0xMCddCisgICAgRGV2 aWNlRGVsZWdhdGUgPSBhcHBsZV9hZGRpdGlvbnMoKS5pb3NfZGV2aWNlX2RlbGVnYXRlKCkgaWYg YXBwbGVfYWRkaXRpb25zKCkgZWxzZSBJT1NEZXZpY2VEZWxlZ2F0ZQorICAgIFNESyA9IERldmlj ZURlbGVnYXRlLlNESworCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGhvc3QsIHBvcnRfbmFtZSwg Kiprd2FyZ3MpOgorICAgICAgICBzdXBlcihJT1NEZXZpY2VQb3J0LCBzZWxmKS5fX2luaXRfXyho b3N0LCBwb3J0X25hbWUsICoqa3dhcmdzKQorICAgICAgICBzZWxmLl9kZXZpY2VfZGVsZWdhdGUg PSBJT1NEZXZpY2VQb3J0LkRldmljZURlbGVnYXRlKHNlbGYpCisgICAgICAgIGlmIGFwcGxlX2Fk ZGl0aW9ucygpOgorICAgICAgICAgICAgYXBwbGVfYWRkaXRpb25zKCkucG9sbF9pb3NfZGV2aWNl cyhzZWxmKQorICAgICAgICAgICAgbnVtX2RldmljZXMgPSBsZW4oYXBwbGVfYWRkaXRpb25zKCku Y29ubmVjdGVkX2lvc19kZXZpY2VzKCkpCisgICAgICAgICAgICBpZiBudW1fZGV2aWNlcyA9PSAx OgorICAgICAgICAgICAgICAgIHNlbGYuX2N1cnJlbnRfZGV2aWNlID0gYXBwbGVfYWRkaXRpb25z KCkuY29ubmVjdGVkX2lvc19kZXZpY2VzKClbMF0KKyAgICAgICAgZWxzZToKKyAgICAgICAgICAg IHNlbGYuX2N1cnJlbnRfZGV2aWNlID0gTm9uZQorICAgICAgICAgICAgbnVtX2RldmljZXMgPSAx CisgICAgICAgIGlmIG51bV9kZXZpY2VzIDw9IDA6CisgICAgICAgICAgICBudW1fZGV2aWNlcyA9 IDEKKyAgICAgICAgc2VsZi5zZXRfb3B0aW9uKCdjaGlsZF9wcm9jZXNzZXMnLCBudW1fZGV2aWNl cykKKworICAgIGRlZiBfZGV2aWNlX2Zvcl93b3JrZXJfbnVtYmVyX21hcChzZWxmKToKKyAgICAg ICAgaWYgbm90IGFwcGxlX2FkZGl0aW9ucygpOgorICAgICAgICAgICAgcmFpc2UgUnVudGltZUVy cm9yKCdObyAnKQorICAgICAgICByZXR1cm4gYXBwbGVfYWRkaXRpb25zKCkuY29ubmVjdGVkX2lv c19kZXZpY2VzKCkKKworICAgIGRlZiBfZHJpdmVyX2NsYXNzKHNlbGYpOgorICAgICAgICByZXR1 cm4gSU9TRGV2aWNlUG9ydC5EZXZpY2VEZWxlZ2F0ZS5ERVZJQ0VfRFJJVkVSCiAKICAgICBAY2xh c3NtZXRob2QKICAgICBkZWYgZGV0ZXJtaW5lX2Z1bGxfcG9ydF9uYW1lKGNscywgaG9zdCwgb3B0 aW9ucywgcG9ydF9uYW1lKToKICAgICAgICAgaWYgcG9ydF9uYW1lID09IGNscy5wb3J0X25hbWU6 Ci0gICAgICAgICAgICBpcGhvbmVvc19zZGtfdmVyc2lvbiA9IGhvc3QucGxhdGZvcm0ueGNvZGVf c2RrX3ZlcnNpb24oJ2lwaG9uZW9zJykKKyAgICAgICAgICAgIGlwaG9uZW9zX3Nka192ZXJzaW9u ID0gaG9zdC5wbGF0Zm9ybS54Y29kZV9zZGtfdmVyc2lvbihJT1NEZXZpY2VQb3J0LlNESykKICAg ICAgICAgICAgIGlmIG5vdCBpcGhvbmVvc19zZGtfdmVyc2lvbjoKICAgICAgICAgICAgICAgICBy YWlzZSBFeGNlcHRpb24oIlBsZWFzZSBpbnN0YWxsIHRoZSBpT1MgU0RLLiIpCiAgICAgICAgICAg ICBtYWpvcl92ZXJzaW9uX251bWJlciA9IGlwaG9uZW9zX3Nka192ZXJzaW9uLnNwbGl0KCcuJylb MF0KICAgICAgICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZSArICctJyArIG1ham9yX3ZlcnNp b25fbnVtYmVyCiAgICAgICAgIHJldHVybiBwb3J0X25hbWUKIAorICAgICMgRklYTUU6IFRoZXNl IG5lZWQgZGV2aWNlIGltcGxlbWVudGF0aW9ucyA8cmRhcjovL3Byb2JsZW0vMzA0OTc5OTE+Cisg ICAgZGVmIGNoZWNrX2Zvcl9sZWFrcyhzZWxmLCBwcm9jZXNzX25hbWUsIHByb2Nlc3NfcGlkKToK KyAgICAgICAgcGFzcworCisgICAgZGVmIGxvb2tfZm9yX25ld19jcmFzaF9sb2dzKHNlbGYsIGNy YXNoZWRfcHJvY2Vzc2VzLCBzdGFydF90aW1lKToKKyAgICAgICAgcmV0dXJuIHt9CisKKyAgICBk ZWYgbG9va19mb3JfbmV3X3NhbXBsZXMoc2VsZiwgdW5yZXNwb25zaXZlX3Byb2Nlc3Nlcywgc3Rh cnRfdGltZSk6CisgICAgICAgIHJldHVybiB7fQorCisgICAgZGVmIHNhbXBsZV9wcm9jZXNzKHNl bGYsIG5hbWUsIHBpZCwgdGFyZ2V0X2hvc3Q9Tm9uZSk6CisgICAgICAgIHBhc3MKKwogICAgICMg RGVzcGl0ZSB0aGVpciBuYW1lcywgdGhlc2UgZmxhZ3MgZG8gbm90IGFjdHVhbGx5IGdldCBwYXNz ZWQgYWxsIHRoZSB3YXkgZG93biB0byB3ZWJraXQtYnVpbGQuCiAgICAgZGVmIF9idWlsZF9kcml2 ZXJfZmxhZ3Moc2VsZik6Ci0gICAgICAgIHJldHVybiBbJy0tc2RrJywgJ2lwaG9uZW9zJ10gKyAo WydBUkNIUz0lcycgJSBzZWxmLmFyY2hpdGVjdHVyZSgpXSBpZiBzZWxmLmFyY2hpdGVjdHVyZSgp IGVsc2UgW10pCisgICAgICAgIHJldHVybiBbJy0tc2RrJywgSU9TRGV2aWNlUG9ydC5TREtdICsg KFsnQVJDSFM9JXMnICUgc2VsZi5hcmNoaXRlY3R1cmUoKV0gaWYgc2VsZi5hcmNoaXRlY3R1cmUo KSBlbHNlIFtdKQogCiAgICAgZGVmIG9wZXJhdGluZ19zeXN0ZW0oc2VsZik6CiAgICAgICAgIHJl dHVybiAnaW9zLWRldmljZScKKworICAgIGRlZiBfY3JlYXRlX2RldmljZXMoc2VsZiwgZGV2aWNl X2NsYXNzKToKKyAgICAgICAgaWYgbm90IGFwcGxlX2FkZGl0aW9ucygpOgorICAgICAgICAgICAg cmFpc2UgUnVudGltZUVycm9yKCdPbi1kZXZpY2UgdGVzdGluZyBpcyBub3Qgc3VwcG9ydGVkIG9u IHRoaXMgbWFjaGluZScpCisgICAgICAgIGFwcGxlX2FkZGl0aW9ucygpLnBvbGxfaW9zX2Rldmlj ZXMoc2VsZikKKyAgICAgICAgaWYgbm90IGFwcGxlX2FkZGl0aW9ucygpLmNvbm5lY3RlZF9pb3Nf ZGV2aWNlcygpOgorICAgICAgICAgICAgcmFpc2UgUnVudGltZUVycm9yKCdObyBkZXZpY2VzIGFy ZSBhdmFpbGFibGUgZm9yIHRlc3RpbmcnKQorICAgICAgICBzZWxmLl9kZXZpY2VfZGVsZWdhdGUu c2V0dXBfZGV2aWNlc19mb3JfYXV0b21hdGlvbigpCisKKyAgICBkZWYgY2xlYW5fdXBfdGVzdF9y dW4oc2VsZik6CisgICAgICAgIHN1cGVyKElPU0RldmljZVBvcnQsIHNlbGYpLmNsZWFuX3VwX3Rl c3RfcnVuKCkKKyAgICAgICAgc2VsZi5fZGV2aWNlX2RlbGVnYXRlLnRlYXJkb3duX2RldmljZXNf YWZ0ZXJfYXV0b21hdGlvbigpCkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9z X2RldmljZV91bml0dGVzdC5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvaW9zX2RldmljZV91bml0dGVzdC5weQkocmV2aXNpb24gMjE1NDcyKQorKysgVG9vbHMv U2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2VfdW5pdHRlc3QucHkJKHdvcmtpbmcgY29w eSkKQEAgLTM2LDMgKzM2LDEzIEBAIGNsYXNzIElPU0RldmljZVRlc3QoaW9zX3Rlc3RjYXNlLklP U1Rlc3QKIAogICAgIGRlZiB0ZXN0X29wZXJhdGluZ19zeXN0ZW0oc2VsZik6CiAgICAgICAgIHNl bGYuYXNzZXJ0RXF1YWwoJ2lvcy1kZXZpY2UnLCBzZWxmLm1ha2VfcG9ydCgpLm9wZXJhdGluZ19z eXN0ZW0oKSkKKworICAgICMgRklYTUU6IFVwZGF0ZSB0ZXN0cyB3aGVuIDxyZGFyOi8vcHJvYmxl bS8zMDQ5Nzk5MT4gaXMgY29tcGxldGVkCisgICAgZGVmIHRlc3Rfc3BpbmR1bXAoc2VsZik6Cisg ICAgICAgIHBhc3MKKworICAgIGRlZiB0ZXN0X3NhbXBsZV9wcm9jZXNzKHNlbGYpOgorICAgICAg ICBwYXNzCisKKyAgICBkZWYgdGVzdF9zYW1wbGVfcHJvY2Vzc19leGNlcHRpb24oc2VsZik6Cisg ICAgICAgIHBhc3MK 308451 2017-04-27 14:51:55 -0700 2017-04-28 17:25:30 -0700 Patch bug-170461-20170427145154.patch text/plain 11921 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNTg4NikKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDU0IEBACisyMDE3LTA0LTI3ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIGFwcGxlX2FkZGl0aW9ucyB0byB3ZWJraXRweSB0 byBpbnNlcnQgSW50ZXJuYWwgdG9vbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3MDQ2MQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzE0MzMwNzc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWxsb3cg YSBwYWNrYWdlIHRvIGJlIHB1bGxlZCBpbiBieSBydW4td2Via2l0LXRlc3RzIHdoaWNoIHByb3Zp ZGVzIGFuIGludGVyZmFjZSB0bworICAgICAgICBydW4gbGF5b3V0IHRlc3RzIG9uIGFuIGlPUyBk ZXZpY2UuICBJZiB0aGlzIHBhY2thZ2UgaXMgbm90IGF2YWlsYWJsZSwgdGhyb3cgYW4KKyAgICAg ICAgZXhjZXB0aW9uIHdoZW4gYXR0ZW1wdGluZyB0byBydW4gbGF5b3V0IHRlc3RzIG9uIGFuIGlP UyBkZXZpY2UuCisKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvY29uZmlnLnB5Ogor ICAgICAgICAoYXBwbGVfYWRkaXRpb25zKTogSW1wb3J0IGFwcGxlX2FkZGl0aW9ucyBwYWNrYWdl LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9kZXZpY2UucHk6CisgICAgICAgIChE ZXZpY2UuaW5zdGFsbF9keWxpYnMpOiBQYXNzIGEgZGlyZWN0b3J5IHdpdGggYWxsIHRoZSBmcmFt ZXdvcmtzIGFuZCBkeWxpYnMgdG8gYmUKKyAgICAgICAgaW5zdGFsbGVkIG9uIGEgZGV2aWNlLgor ICAgICAgICAoRGV2aWNlLnByZXBhcmVfZm9yX3Rlc3RpbmcpOiBQYXNzIGEgbGlzdCBvZiBwb3J0 cyB0byBmb3J3YXJkIGZyb20gdGhlIGRldmljZSB0byB0aGUKKyAgICAgICAgaG9zdCwgdGhlIGJ1 bmRsZSBpZCBvZiB0aGUgYXBwIHRvIGJlIHVzZWQgZm9yIHRlc3RpbmcgYW5kIGEgcGF0aCB0byB0 aGUgbGF5b3V0IHRlc3QKKyAgICAgICAgZGlyZWN0b3J5IHRvIGJlIG1vdW50ZWQgb24gdGhlIGRl dmljZS4KKyAgICAgICAgKERldmljZS5maW5pc2hlZF90ZXN0aW5nKToKKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weToKKyAgICAgICAgKHBsYXRmb3JtX29wdGlvbnMp OiBBZGQgYXBwbGVfYWRkaXRpb25zIHBsYXRmb3JtIG9wdGlvbnMgaWYgYXBwbGVfYWRkaXRpb25z IGV4aXN0cy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zLnB5OgorICAgICAg ICAoSU9TUG9ydC5zZXR1cF90ZXN0X3J1bik6IEluc3RhbGwgZHlsaWJzIGFuZCBmcmFtZXdvcmtz IG9uIHRoZSBkZXZpY2UsIHBhc3MgcG9ydHMKKyAgICAgICAgdG8gZm9yd2FyZCwgdGhlIGJ1bmRs ZSBJRCBvZiB0aGUgdGVzdGluZyBhcHAgYW5kIHRoZSBsYXlvdXQgdGVzdHMgZGlyZWN0b3J5IHRv CisgICAgICAgIGVhY2ggZGV2aWNlLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9p b3NfZGV2aWNlLnB5OgorICAgICAgICAoSU9TRGV2aWNlUG9ydCk6CisgICAgICAgIChJT1NEZXZp Y2VQb3J0LmRlZmF1bHRfY2hpbGRfcHJvY2Vzc2VzKTogUXVlcnkgYXBwbGVfYWRkaXRpb25zIGZv ciB0aGUgbnVtYmVyIG9mIGNoaWxkCisgICAgICAgIHByb2Nlc3NlcyB0byBiZSBydW4uCisgICAg ICAgIChJT1NEZXZpY2VQb3J0LnVzaW5nX211bHRpcGxlX2RldmljZXMpOiBBbHdheXMgYXNzdW1l IG11bHRpcGxlIGRldmljZXMgYXJlIHVzZWQuIFdoZW4KKyAgICAgICAgYSBzaW5nbGUgZGV2aWNl IGlzIHVzZWQsIGl0IGlzIHN0aWxsIGFjY2Vzc2VkIHRocm91Z2ggYW4gYXJyYXkuCisgICAgICAg IChJT1NEZXZpY2VQb3J0Ll9kZXZpY2VfZm9yX3dvcmtlcl9udW1iZXJfbWFwKTogUXVlcnkgYXBw bGVfYWRkaXRpb25zIGZvciB0aGUgZGV2aWNlCisgICAgICAgIGZvciB3b3JrZXIgbnVtYmVyIG1h cC4KKyAgICAgICAgKElPU0RldmljZVBvcnQuX2RyaXZlcl9jbGFzcyk6IFF1ZXJ5IGFwcGxlX2Fk ZGl0aW9ucyBmb3IgdGhlIHRlc3QgZHJpdmVyLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5kZXRl cm1pbmVfZnVsbF9wb3J0X25hbWUpOiBVc2UgY2xhc3MgdmFyaWFibGUgb3ZlciBoYXJkLWNvZGVk IHN0cmluZy4KKyAgICAgICAgKElPU0RldmljZVBvcnQuY2hlY2tfZm9yX2xlYWtzKTogTm8gaW1w bGVtZW50YXRpb24gZm9yIGlPU0RldmljZVBvcnQuCisgICAgICAgIChJT1NEZXZpY2VQb3J0Lmxv b2tfZm9yX25ld19jcmFzaF9sb2dzKTogRGl0dG8uCisgICAgICAgIChJT1NEZXZpY2VQb3J0Lmxv b2tfZm9yX25ld19zYW1wbGVzKTogRGl0dG8uCisgICAgICAgIChJT1NEZXZpY2VQb3J0LnNhbXBs ZV9wcm9jZXNzKTogRGl0dG8uCisgICAgICAgIChJT1NEZXZpY2VQb3J0Ll9idWlsZF9kcml2ZXJf ZmxhZ3MpOiBVc2UgY2xhc3MgdmFyaWFibGUgb3ZlciBoYXJkLWNvZGVkIHN0cmluZy4KKyAgICAg ICAgKElPU0RldmljZVBvcnQuX2NyZWF0ZV9kZXZpY2VzKTogQ2hlY2sgdGhhdCBkZXZpY2VzIGFy ZSBhdmFpbGFibGUgZm9yIHRlc3RpbmcgYW5kIGNoZWNrCisgICAgICAgIHRoYXQgd2UgaGF2ZSBl bm91Z2ggZGV2aWNlcyBmb3IgZWFjaCBjaGlsZCBwcm9jZXNzLgorICAgICAgICAoSU9TRGV2aWNl UG9ydC5jbGVhbl91cF90ZXN0X3J1bik6IEhhdmUgYXBwbGVfYWRkaXRpb25zIHByZWZvcm0gYW55 IG5lZWRlZCBjbGVhbiB1cC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2Rl dmljZV91bml0dGVzdC5weToKKyAgICAgICAgKElPU0RldmljZVRlc3QudGVzdF9vcGVyYXRpbmdf c3lzdGVtKToKKyAgICAgICAgKElPU0RldmljZVRlc3QudGVzdF9zcGluZHVtcCk6IE92ZXJyaWRl IG1ldGhvZCBmcm9tIERhcndpblRlc3QuCisgICAgICAgIChJT1NEZXZpY2VUZXN0LnRlc3Rfc2Ft cGxlX3Byb2Nlc3MpOiBEaXR0by4KKyAgICAgICAgKElPU0RldmljZVRlc3QudGVzdF9zYW1wbGVf cHJvY2Vzc19leGNlcHRpb24pOiBEaXR0by4KKwogMjAxNy0wNC0yNiAgU2FhbSBCYXJhdGkgIDxz YmFyYXRpQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQgc29tZSBtb3JlIHRlc3RpbmcgbW9kZXMg Zm9yIFdhc20gdGVzdHMgbm93IHRoYXQgd2UgaGF2ZSB0aWVyIHVwCkluZGV4OiBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3BvcnQvY29uZmlnLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9jb25maWcucHkJKHJldmlzaW9uIDIxNTg4NikKKysrIFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9jb25maWcucHkJKHdvcmtpbmcgY29weSkKQEAgLTMzLDYgKzMzLDcg QEAKIGltcG9ydCBsb2dnaW5nCiAKIGZyb20gd2Via2l0cHkuY29tbW9uIGltcG9ydCB3ZWJraXRf ZmluZGVyCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5tZW1vaXplZCBpbXBvcnQgbWVtb2l6ZWQKIAog CiBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCkBAIC01NCw2ICs1NSwxNCBAQCBk ZWYgY2xlYXJfY2FjaGVkX2NvbmZpZ3VyYXRpb24oKToKICAgICBfY29uZmlndXJhdGlvbiA9ICJS ZWxlYXNlIgogCiAKK0BtZW1vaXplZAorZGVmIGFwcGxlX2FkZGl0aW9ucygpOgorICAgIHRyeToK KyAgICAgICAgcmV0dXJuIF9faW1wb3J0X18oJ2FwcGxlX2FkZGl0aW9ucycsIGdsb2JhbHMoKSwg Tm9uZSwgW10sIDApCisgICAgZXhjZXB0IEltcG9ydEVycm9yOgorICAgICAgICByZXR1cm4gTm9u ZQorCisKIGNsYXNzIENvbmZpZyhvYmplY3QpOgogICAgIF9GTEFHU19GUk9NX0NPTkZJR1VSQVRJ T05TID0gewogICAgICAgICAiRGVidWciOiAiLS1kZWJ1ZyIsCkluZGV4OiBUb29scy9TY3JpcHRz L3dlYmtpdHB5L3BvcnQvZGV2aWNlLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvcG9ydC9kZXZpY2UucHkJKHJldmlzaW9uIDIxNTg4NikKKysrIFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9kZXZpY2UucHkJKHdvcmtpbmcgY29weSkKQEAgLTM1LDIwICszNSwyOSBA QCBjbGFzcyBEZXZpY2Uob2JqZWN0KToKICAgICBkZWYgaW5zdGFsbF9hcHAoc2VsZiwgYXBwX3Bh dGgsIGVudj1Ob25lKToKICAgICAgICAgcmV0dXJuIHNlbGYucGxhdGZvcm1fZGV2aWNlLmluc3Rh bGxfYXBwKGFwcF9wYXRoLCBlbnYpCiAKKyAgICBkZWYgaW5zdGFsbF9keWxpYnMoc2VsZiwgcGF0 aF90b19keWxpYnMpOgorICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2aWNlLCAn aW5zdGFsbF9keWxpYnMnKToKKyAgICAgICAgICAgIHJldHVybiBzZWxmLnBsYXRmb3JtX2Rldmlj ZS5pbnN0YWxsX2R5bGlicyhwYXRoX3RvX2R5bGlicz1wYXRoX3RvX2R5bGlicykKKyAgICAgICAg cmV0dXJuIFRydWUKKwogICAgIGRlZiBsYXVuY2hfYXBwKHNlbGYsIGJ1bmRsZV9pZCwgYXJncywg ZW52PU5vbmUpOgogICAgICAgICByZXR1cm4gc2VsZi5wbGF0Zm9ybV9kZXZpY2UubGF1bmNoX2Fw cChidW5kbGVfaWQsIGFyZ3MsIGVudikKIAotICAgIGRlZiBwcmVwYXJlX2Zvcl90ZXN0aW5nKHNl bGYpOgorICAgIGRlZiBwcmVwYXJlX2Zvcl90ZXN0aW5nKHNlbGYsIHBvcnRzX3RvX2ZvcndhcmQs IHRlc3RfYXBwX2J1bmRsZV9pZCwgbGF5b3V0X3Rlc3RfZGlyZWN0b3J5KToKICAgICAgICAgaWYg bm90IHNlbGYubGlzdGVuaW5nX3NvY2tldDoKICAgICAgICAgICAgIHNlbGYubGlzdGVuaW5nX3Nv Y2tldCA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkK ICAgICAgICAgICAgIHNlbGYubGlzdGVuaW5nX3NvY2tldC5zZXRzb2Nrb3B0KHNvY2tldC5TT0xf U09DS0VULCBzb2NrZXQuU09fUkVVU0VBRERSLCAxKQogICAgICAgICAgICAgc2VsZi5saXN0ZW5p bmdfc29ja2V0LmJpbmQoKCcxMjcuMC4wLjEnLCAwKSkKIAogICAgICAgICBpZiBoYXNhdHRyKHNl bGYucGxhdGZvcm1fZGV2aWNlLCAncHJlcGFyZV9mb3JfdGVzdGluZycpOgotICAgICAgICAgICAg c2VsZi5wbGF0Zm9ybV9kZXZpY2UucHJlcGFyZV9mb3JfdGVzdGluZygpCisgICAgICAgICAgICBz ZWxmLnBsYXRmb3JtX2RldmljZS5wcmVwYXJlX2Zvcl90ZXN0aW5nKAorICAgICAgICAgICAgICAg IHBvcnRzX3RvX2ZvcndhcmQ9cG9ydHNfdG9fZm9yd2FyZCArIFtzZWxmLmxpc3RlbmluZ19wb3J0 KCldLAorICAgICAgICAgICAgICAgIHRlc3RfYXBwX2J1bmRsZV9pZD10ZXN0X2FwcF9idW5kbGVf aWQsCisgICAgICAgICAgICAgICAgbGF5b3V0X3Rlc3RfZGlyZWN0b3J5PWxheW91dF90ZXN0X2Rp cmVjdG9yeSwKKyAgICAgICAgICAgICkKIAogICAgIGRlZiBmaW5pc2hlZF90ZXN0aW5nKHNlbGYp OgotICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2aWNlLCAndGVhcmRvd24nKToK KyAgICAgICAgaWYgaGFzYXR0cihzZWxmLnBsYXRmb3JtX2RldmljZSwgJ2ZpbmlzaGVkX3Rlc3Rp bmcnKToKICAgICAgICAgICAgIHNlbGYucGxhdGZvcm1fZGV2aWNlLmZpbmlzaGVkX3Rlc3Rpbmco KQogCiAgICAgICAgIHNlbGYubGlzdGVuaW5nX3NvY2tldCA9IE5vbmUKSW5kZXg6IFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5CShyZXZpc2lvbiAyMTU4ODYpCisrKyBUb29scy9T Y3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQkod29ya2luZyBjb3B5KQpAQCAtNTYsNyAr NTYsNyBAQCBkZWYgcGxhdGZvcm1fb3B0aW9ucyh1c2VfZ2xvYnM9RmFsc2UpOgogICAgICAgICBv cHRwYXJzZS5tYWtlX29wdGlvbignLS1uby1pbnN0YWxsJywgYWN0aW9uPSdzdG9yZV9jb25zdCcs CiAgICAgICAgICAgICBjb25zdD1GYWxzZSwgZGVmYXVsdD1UcnVlLCBkZXN0PSdpbnN0YWxsJywK ICAgICAgICAgICAgIGhlbHA9J1NraXAgaW5zdGFsbCBzdGVwIGZvciBkZXZpY2UgYW5kIHNpbXVs YXRvciB0ZXN0aW5nJyksCi0gICAgICAgIF0KKyAgICAgICAgXSArIChjb25maWcuYXBwbGVfYWRk aXRpb25zKCkucGxhdGZvcm1fb3B0aW9ucygpIGlmIGNvbmZpZy5hcHBsZV9hZGRpdGlvbnMoKSBl bHNlIFtdKQogCiAKIGRlZiBjb25maWd1cmF0aW9uX29wdGlvbnMoKToKSW5kZXg6IFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9pb3MucHkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9wb3J0L2lvcy5weQkocmV2aXNpb24gMjE1ODg2KQorKysgVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9wb3J0L2lvcy5weQkod29ya2luZyBjb3B5KQpAQCAtMTE4LDExICsxMTgsMTcgQEAg Y2xhc3MgSU9TUG9ydChEYXJ3aW5Qb3J0KToKICAgICAgICAgICAgICAgICAjIGxlYXZpbmcgYSBj cmFzaCBsb2cgd2hpY2ggd2lsbCBiZSBwaWNrZWQgdXAgaW4gcmVzdWx0cy4gRFlMRF9GUkFNRVdP UktfUEFUSCBpcyBuZWVkZWQgdG8gcHJldmVudCBhbiBlYXJseSBjcmFzaC4KICAgICAgICAgICAg ICAgICBpZiBub3QgZGV2aWNlLmluc3RhbGxfYXBwKHNlbGYuX3BhdGhfdG9fZHJpdmVyKCksIHsn RFlMRF9MSUJSQVJZX1BBVEgnOiBzZWxmLl9idWlsZF9wYXRoKCksICdEWUxEX0ZSQU1FV09SS19Q QVRIJzogc2VsZi5fYnVpbGRfcGF0aCgpfSk6CiAgICAgICAgICAgICAgICAgICAgIHJhaXNlIFJ1 bnRpbWVFcnJvcignRmFpbGVkIHRvIGluc3RhbGwgYXBwIHt9IG9uIGRldmljZSB7fScuZm9ybWF0 KHNlbGYuX3BhdGhfdG9fZHJpdmVyKCksIGRldmljZS51ZGlkKSkKKyAgICAgICAgICAgICAgICBp ZiBub3QgZGV2aWNlLmluc3RhbGxfZHlsaWJzKHNlbGYuX2J1aWxkX3BhdGgoKSk6CisgICAgICAg ICAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignRmFpbGVkIHRvIGluc3RhbGwgZHlsaWJz IGF0IHt9IG9uIGRldmljZSB7fScuZm9ybWF0KHNlbGYuX2J1aWxkX3BhdGgoKSwgZGV2aWNlLnVk aWQpKQogICAgICAgICBlbHNlOgogICAgICAgICAgICAgX2xvZy5kZWJ1ZygnU2tpcHBpbmcgaW5z dGFsbGF0aW9uJykKIAogICAgICAgICBmb3IgaSBpbiB4cmFuZ2Uoc2VsZi5jaGlsZF9wcm9jZXNz ZXMoKSk6Ci0gICAgICAgICAgICBzZWxmLnRhcmdldF9ob3N0KGkpLnByZXBhcmVfZm9yX3Rlc3Rp bmcoKQorICAgICAgICAgICAgc2VsZi50YXJnZXRfaG9zdChpKS5wcmVwYXJlX2Zvcl90ZXN0aW5n KAorICAgICAgICAgICAgICAgIHNlbGYucG9ydHNfdG9fZm9yd2FyZCgpLAorICAgICAgICAgICAg ICAgIHNlbGYuYXBwX2lkZW50aWZpZXJfZnJvbV9idW5kbGUoc2VsZi5fcGF0aF90b19kcml2ZXIo KSksCisgICAgICAgICAgICAgICAgc2VsZi5sYXlvdXRfdGVzdHNfZGlyKCksCisgICAgICAgICAg ICApCiAKICAgICBkZWYgY2xlYW5fdXBfdGVzdF9ydW4oc2VsZik6CiAgICAgICAgIHN1cGVyKElP U1BvcnQsIHNlbGYpLmNsZWFuX3VwX3Rlc3RfcnVuKCkKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5CShyZXZpc2lvbiAyMTU4ODYpCisrKyBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5weQkod29ya2luZyBjb3B5KQpAQCAtMjIsNiAr MjIsOCBAQAogCiBpbXBvcnQgbG9nZ2luZwogCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5tZW1vaXpl ZCBpbXBvcnQgbWVtb2l6ZWQKK2Zyb20gd2Via2l0cHkucG9ydC5jb25maWcgaW1wb3J0IGFwcGxl X2FkZGl0aW9ucwogZnJvbSB3ZWJraXRweS5wb3J0LmlvcyBpbXBvcnQgSU9TUG9ydAogCiBfbG9n ID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCkBAIC0zMywyMCArMzUsNjQgQEAgY2xhc3Mg SU9TRGV2aWNlUG9ydChJT1NQb3J0KToKICAgICBBUkNISVRFQ1RVUkVTID0gWydhcm12NycsICdh cm12N3MnLCAnYXJtNjQnXQogICAgIERFRkFVTFRfQVJDSElURUNUVVJFID0gJ2FybTY0JwogICAg IFZFUlNJT05fRkFMTEJBQ0tfT1JERVIgPSBbJ2lvcy03JywgJ2lvcy04JywgJ2lvcy05JywgJ2lv cy0xMCddCisgICAgU0RLID0gYXBwbGVfYWRkaXRpb25zKCkuaW9zX2RldmljZV9TREsoKSBpZiBh cHBsZV9hZGRpdGlvbnMoKSBlbHNlICdpcGhvbmVvcycKKworICAgIEBtZW1vaXplZAorICAgIGRl ZiBkZWZhdWx0X2NoaWxkX3Byb2Nlc3NlcyhzZWxmKToKKyAgICAgICAgaWYgYXBwbGVfYWRkaXRp b25zKCk6CisgICAgICAgICAgICByZXR1cm4gYXBwbGVfYWRkaXRpb25zKCkuaW9zX2RldmljZV9k ZWZhdWx0X2NoaWxkX3Byb2Nlc3NlcyhzZWxmKQorICAgICAgICByZXR1cm4gMQorCisgICAgZGVm IHVzaW5nX211bHRpcGxlX2RldmljZXMoc2VsZik6CisgICAgICAgIHJldHVybiBUcnVlCisKKyAg ICBkZWYgX2RldmljZV9mb3Jfd29ya2VyX251bWJlcl9tYXAoc2VsZik6CisgICAgICAgIGlmIG5v dCBhcHBsZV9hZGRpdGlvbnMoKToKKyAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignT24t ZGV2aWNlIHRlc3RpbmcgaXMgbm90IHN1cHBvcnRlZCBvbiB0aGlzIG1hY2hpbmUnKQorICAgICAg ICByZXR1cm4gYXBwbGVfYWRkaXRpb25zKCkuaW9zX2RldmljZV9mb3Jfd29ya2VyX251bWJlcl9t YXAoc2VsZikKKworICAgIGRlZiBfZHJpdmVyX2NsYXNzKHNlbGYpOgorICAgICAgICByZXR1cm4g YXBwbGVfYWRkaXRpb25zKCkuaW9zX2RldmljZV9kcml2ZXIoKSBpZiBhcHBsZV9hZGRpdGlvbnMo KSBlbHNlIHN1cGVyKElPU0RldmljZVBvcnQsIHNlbGYpLl9kcml2ZXJfY2xhc3MoKQogCiAgICAg QGNsYXNzbWV0aG9kCiAgICAgZGVmIGRldGVybWluZV9mdWxsX3BvcnRfbmFtZShjbHMsIGhvc3Qs IG9wdGlvbnMsIHBvcnRfbmFtZSk6CiAgICAgICAgIGlmIHBvcnRfbmFtZSA9PSBjbHMucG9ydF9u YW1lOgotICAgICAgICAgICAgaXBob25lb3Nfc2RrX3ZlcnNpb24gPSBob3N0LnBsYXRmb3JtLnhj b2RlX3Nka192ZXJzaW9uKCdpcGhvbmVvcycpCisgICAgICAgICAgICBpcGhvbmVvc19zZGtfdmVy c2lvbiA9IGhvc3QucGxhdGZvcm0ueGNvZGVfc2RrX3ZlcnNpb24oSU9TRGV2aWNlUG9ydC5TREsp CiAgICAgICAgICAgICBpZiBub3QgaXBob25lb3Nfc2RrX3ZlcnNpb246CiAgICAgICAgICAgICAg ICAgcmFpc2UgRXhjZXB0aW9uKCJQbGVhc2UgaW5zdGFsbCB0aGUgaU9TIFNESy4iKQogICAgICAg ICAgICAgbWFqb3JfdmVyc2lvbl9udW1iZXIgPSBpcGhvbmVvc19zZGtfdmVyc2lvbi5zcGxpdCgn LicpWzBdCiAgICAgICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBtYWpvcl92 ZXJzaW9uX251bWJlcgogICAgICAgICByZXR1cm4gcG9ydF9uYW1lCiAKKyAgICAjIEZJWE1FOiBU aGVzZSBuZWVkIGRldmljZSBpbXBsZW1lbnRhdGlvbnMgPHJkYXI6Ly9wcm9ibGVtLzMwNDk3OTkx PgorICAgIGRlZiBjaGVja19mb3JfbGVha3Moc2VsZiwgcHJvY2Vzc19uYW1lLCBwcm9jZXNzX3Bp ZCk6CisgICAgICAgIHBhc3MKKworICAgIGRlZiBsb29rX2Zvcl9uZXdfY3Jhc2hfbG9ncyhzZWxm LCBjcmFzaGVkX3Byb2Nlc3Nlcywgc3RhcnRfdGltZSk6CisgICAgICAgIHJldHVybiB7fQorCisg ICAgZGVmIGxvb2tfZm9yX25ld19zYW1wbGVzKHNlbGYsIHVucmVzcG9uc2l2ZV9wcm9jZXNzZXMs IHN0YXJ0X3RpbWUpOgorICAgICAgICByZXR1cm4ge30KKworICAgIGRlZiBzYW1wbGVfcHJvY2Vz cyhzZWxmLCBuYW1lLCBwaWQsIHRhcmdldF9ob3N0PU5vbmUpOgorICAgICAgICBwYXNzCisKICAg ICAjIERlc3BpdGUgdGhlaXIgbmFtZXMsIHRoZXNlIGZsYWdzIGRvIG5vdCBhY3R1YWxseSBnZXQg cGFzc2VkIGFsbCB0aGUgd2F5IGRvd24gdG8gd2Via2l0LWJ1aWxkLgogICAgIGRlZiBfYnVpbGRf ZHJpdmVyX2ZsYWdzKHNlbGYpOgotICAgICAgICByZXR1cm4gWyctLXNkaycsICdpcGhvbmVvcydd ICsgKFsnQVJDSFM9JXMnICUgc2VsZi5hcmNoaXRlY3R1cmUoKV0gaWYgc2VsZi5hcmNoaXRlY3R1 cmUoKSBlbHNlIFtdKQorICAgICAgICByZXR1cm4gWyctLXNkaycsIElPU0RldmljZVBvcnQuU0RL XSArIChbJ0FSQ0hTPSVzJyAlIHNlbGYuYXJjaGl0ZWN0dXJlKCldIGlmIHNlbGYuYXJjaGl0ZWN0 dXJlKCkgZWxzZSBbXSkKIAogICAgIGRlZiBvcGVyYXRpbmdfc3lzdGVtKHNlbGYpOgogICAgICAg ICByZXR1cm4gJ2lvcy1kZXZpY2UnCisKKyAgICBkZWYgX2NyZWF0ZV9kZXZpY2VzKHNlbGYsIGRl dmljZV9jbGFzcyk6CisgICAgICAgIGlmIG5vdCBhcHBsZV9hZGRpdGlvbnMoKToKKyAgICAgICAg ICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignT24tZGV2aWNlIHRlc3RpbmcgaXMgbm90IHN1cHBvcnRl ZCBvbiB0aGlzIG1hY2hpbmUnKQorICAgICAgICBpZiBub3Qgc2VsZi5fZGV2aWNlX2Zvcl93b3Jr ZXJfbnVtYmVyX21hcCgpOgorICAgICAgICAgICAgcmFpc2UgUnVudGltZUVycm9yKCdObyBkZXZp Y2VzIGFyZSBhdmFpbGFibGUgZm9yIHRlc3RpbmcnKQorCisgICAgICAgIGlmIHNlbGYuZGVmYXVs dF9jaGlsZF9wcm9jZXNzZXMoKSA8IHNlbGYuY2hpbGRfcHJvY2Vzc2VzKCk6CisgICAgICAgICAg ICByYWlzZSBSdW50aW1lRXJyb3IoJ05vdCBlbm91Z2h0IGNvbm5lY3RlZCBkZXZpY2VzIGZvciB7 fSBwcm9jZXNzZXMnLmZvcm1hdChzZWxmLmNoaWxkX3Byb2Nlc3NlcygpKSkKKworICAgIGRlZiBj bGVhbl91cF90ZXN0X3J1bihzZWxmKToKKyAgICAgICAgc3VwZXIoSU9TRGV2aWNlUG9ydCwgc2Vs ZikuY2xlYW5fdXBfdGVzdF9ydW4oKQorICAgICAgICBhcHBsZV9hZGRpdGlvbnMoKS5pb3NfZGV2 aWNlX2NsZWFuX3VwX3Rlc3RfcnVuKHNlbGYsIHNlbGYuX3BhdGhfdG9fZHJpdmVyKCksIHNlbGYu X2J1aWxkX3BhdGgoKSkKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2 aWNlX3VuaXR0ZXN0LnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9y dC9pb3NfZGV2aWNlX3VuaXR0ZXN0LnB5CShyZXZpc2lvbiAyMTU4ODYpCisrKyBUb29scy9TY3Jp cHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZV91bml0dGVzdC5weQkod29ya2luZyBjb3B5KQpA QCAtMzYsMyArMzYsMTMgQEAgY2xhc3MgSU9TRGV2aWNlVGVzdChpb3NfdGVzdGNhc2UuSU9TVGVz dAogCiAgICAgZGVmIHRlc3Rfb3BlcmF0aW5nX3N5c3RlbShzZWxmKToKICAgICAgICAgc2VsZi5h c3NlcnRFcXVhbCgnaW9zLWRldmljZScsIHNlbGYubWFrZV9wb3J0KCkub3BlcmF0aW5nX3N5c3Rl bSgpKQorCisgICAgIyBGSVhNRTogVXBkYXRlIHRlc3RzIHdoZW4gPHJkYXI6Ly9wcm9ibGVtLzMw NDk3OTkxPiBpcyBjb21wbGV0ZWQKKyAgICBkZWYgdGVzdF9zcGluZHVtcChzZWxmKToKKyAgICAg ICAgcGFzcworCisgICAgZGVmIHRlc3Rfc2FtcGxlX3Byb2Nlc3Moc2VsZik6CisgICAgICAgIHBh c3MKKworICAgIGRlZiB0ZXN0X3NhbXBsZV9wcm9jZXNzX2V4Y2VwdGlvbihzZWxmKToKKyAgICAg ICAgcGFzcwo= 308627 2017-04-28 17:25:32 -0700 2017-04-28 18:06:30 -0700 Patch for landing bug-170461-20170428172531.patch text/plain 12034 jbedard SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDIxNTkyNCkKKysrIFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDU0IEBACisyMDE3LTA0LTI3ICBKb25hdGhhbiBCZWRhcmQgIDxqYmVkYXJkQGFwcGxlLmNv bT4KKworICAgICAgICB3ZWJraXRweTogQWRkIGFwcGxlX2FkZGl0aW9ucyB0byB3ZWJraXRweSB0 byBpbnNlcnQgSW50ZXJuYWwgdG9vbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3MDQ2MQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vMzE0MzMwNzc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFuaWVsIEJhdGVzLgorCisgICAgICAgIEFsbG93IGEg cGFja2FnZSB0byBiZSBwdWxsZWQgaW4gYnkgcnVuLXdlYmtpdC10ZXN0cyB3aGljaCBwcm92aWRl cyBhbiBpbnRlcmZhY2UgdG8KKyAgICAgICAgcnVuIGxheW91dCB0ZXN0cyBvbiBhbiBpT1MgZGV2 aWNlLiAgSWYgdGhpcyBwYWNrYWdlIGlzIG5vdCBhdmFpbGFibGUsIHRocm93IGFuCisgICAgICAg IGV4Y2VwdGlvbiB3aGVuIGF0dGVtcHRpbmcgdG8gcnVuIGxheW91dCB0ZXN0cyBvbiBhbiBpT1Mg ZGV2aWNlLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0L2NvbmZpZy5weToKKyAg ICAgICAgKGFwcGxlX2FkZGl0aW9ucyk6IEltcG9ydCBhcHBsZV9hZGRpdGlvbnMgcGFja2FnZS4K KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvZGV2aWNlLnB5OgorICAgICAgICAoRGV2 aWNlLmluc3RhbGxfZHlsaWJzKTogUGFzcyBhIGRpcmVjdG9yeSB3aXRoIGFsbCB0aGUgZnJhbWV3 b3JrcyBhbmQgZHlsaWJzIHRvIGJlCisgICAgICAgIGluc3RhbGxlZCBvbiBhIGRldmljZS4KKyAg ICAgICAgKERldmljZS5wcmVwYXJlX2Zvcl90ZXN0aW5nKTogUGFzcyBhIGxpc3Qgb2YgcG9ydHMg dG8gZm9yd2FyZCBmcm9tIHRoZSBkZXZpY2UgdG8gdGhlCisgICAgICAgIGhvc3QsIHRoZSBidW5k bGUgaWQgb2YgdGhlIGFwcCB0byBiZSB1c2VkIGZvciB0ZXN0aW5nIGFuZCBhIHBhdGggdG8gdGhl IGxheW91dCB0ZXN0CisgICAgICAgIGRpcmVjdG9yeSB0byBiZSBtb3VudGVkIG9uIHRoZSBkZXZp Y2UuCisgICAgICAgIChEZXZpY2UuZmluaXNoZWRfdGVzdGluZyk6CisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9wb3J0L2ZhY3RvcnkucHk6CisgICAgICAgIChwbGF0Zm9ybV9vcHRpb25zKTog QWRkIGFwcGxlX2FkZGl0aW9ucyBwbGF0Zm9ybSBvcHRpb25zIGlmIGFwcGxlX2FkZGl0aW9ucyBl eGlzdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvcy5weToKKyAgICAgICAg KElPU1BvcnQuc2V0dXBfdGVzdF9ydW4pOiBJbnN0YWxsIGR5bGlicyBhbmQgZnJhbWV3b3JrcyBv biB0aGUgZGV2aWNlLCBwYXNzIHBvcnRzCisgICAgICAgIHRvIGZvcndhcmQsIHRoZSBidW5kbGUg SUQgb2YgdGhlIHRlc3RpbmcgYXBwIGFuZCB0aGUgbGF5b3V0IHRlc3RzIGRpcmVjdG9yeSB0bwor ICAgICAgICBlYWNoIGRldmljZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9z X2RldmljZS5weToKKyAgICAgICAgKElPU0RldmljZVBvcnQpOgorICAgICAgICAoSU9TRGV2aWNl UG9ydC5kZWZhdWx0X2NoaWxkX3Byb2Nlc3Nlcyk6IFF1ZXJ5IGFwcGxlX2FkZGl0aW9ucyBmb3Ig dGhlIG51bWJlciBvZiBjaGlsZAorICAgICAgICBwcm9jZXNzZXMgdG8gYmUgcnVuLgorICAgICAg ICAoSU9TRGV2aWNlUG9ydC51c2luZ19tdWx0aXBsZV9kZXZpY2VzKTogQWx3YXlzIGFzc3VtZSBt dWx0aXBsZSBkZXZpY2VzIGFyZSB1c2VkLiBXaGVuCisgICAgICAgIGEgc2luZ2xlIGRldmljZSBp cyB1c2VkLCBpdCBpcyBzdGlsbCBhY2Nlc3NlZCB0aHJvdWdoIGFuIGFycmF5LgorICAgICAgICAo SU9TRGV2aWNlUG9ydC5fZGV2aWNlX2Zvcl93b3JrZXJfbnVtYmVyX21hcCk6IFF1ZXJ5IGFwcGxl X2FkZGl0aW9ucyBmb3IgdGhlIGRldmljZQorICAgICAgICBmb3Igd29ya2VyIG51bWJlciBtYXAu CisgICAgICAgIChJT1NEZXZpY2VQb3J0Ll9kcml2ZXJfY2xhc3MpOiBRdWVyeSBhcHBsZV9hZGRp dGlvbnMgZm9yIHRoZSB0ZXN0IGRyaXZlci4KKyAgICAgICAgKElPU0RldmljZVBvcnQuZGV0ZXJt aW5lX2Z1bGxfcG9ydF9uYW1lKTogVXNlIGNsYXNzIHZhcmlhYmxlIG92ZXIgaGFyZC1jb2RlZCBz dHJpbmcuCisgICAgICAgIChJT1NEZXZpY2VQb3J0LmNoZWNrX2Zvcl9sZWFrcyk6IE5vIGltcGxl bWVudGF0aW9uIGZvciBpT1NEZXZpY2VQb3J0LgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5sb29r X2Zvcl9uZXdfY3Jhc2hfbG9ncyk6IERpdHRvLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5sb29r X2Zvcl9uZXdfc2FtcGxlcyk6IERpdHRvLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5zYW1wbGVf cHJvY2Vzcyk6IERpdHRvLgorICAgICAgICAoSU9TRGV2aWNlUG9ydC5fYnVpbGRfZHJpdmVyX2Zs YWdzKTogVXNlIGNsYXNzIHZhcmlhYmxlIG92ZXIgaGFyZC1jb2RlZCBzdHJpbmcuCisgICAgICAg IChJT1NEZXZpY2VQb3J0Ll9jcmVhdGVfZGV2aWNlcyk6IENoZWNrIHRoYXQgZGV2aWNlcyBhcmUg YXZhaWxhYmxlIGZvciB0ZXN0aW5nIGFuZCBjaGVjaworICAgICAgICB0aGF0IHdlIGhhdmUgZW5v dWdoIGRldmljZXMgZm9yIGVhY2ggY2hpbGQgcHJvY2Vzcy4KKyAgICAgICAgKElPU0RldmljZVBv cnQuY2xlYW5fdXBfdGVzdF9ydW4pOiBIYXZlIGFwcGxlX2FkZGl0aW9ucyBwcmVmb3JtIGFueSBu ZWVkZWQgY2xlYW4gdXAuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvc19kZXZp Y2VfdW5pdHRlc3QucHk6CisgICAgICAgIChJT1NEZXZpY2VUZXN0LnRlc3Rfb3BlcmF0aW5nX3N5 c3RlbSk6CisgICAgICAgIChJT1NEZXZpY2VUZXN0LnRlc3Rfc3BpbmR1bXApOiBPdmVycmlkZSBt ZXRob2QgZnJvbSBEYXJ3aW5UZXN0LgorICAgICAgICAoSU9TRGV2aWNlVGVzdC50ZXN0X3NhbXBs ZV9wcm9jZXNzKTogRGl0dG8uCisgICAgICAgIChJT1NEZXZpY2VUZXN0LnRlc3Rfc2FtcGxlX3By b2Nlc3NfZXhjZXB0aW9uKTogRGl0dG8uCisKIDIwMTctMDQtMjcgIENhcmxvcyBHYXJjaWEgQ2Ft cG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIE1vdmUgVVVJRCBmcm9tIFdlYkNv cmUvcGxhdGZvcm0gdG8gV1RGCkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvY29u ZmlnLnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9jb25maWcu cHkJKHJldmlzaW9uIDIxNTkyNCkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9jb25m aWcucHkJKHdvcmtpbmcgY29weSkKQEAgLTMzLDYgKzMzLDcgQEAKIGltcG9ydCBsb2dnaW5nCiAK IGZyb20gd2Via2l0cHkuY29tbW9uIGltcG9ydCB3ZWJraXRfZmluZGVyCitmcm9tIHdlYmtpdHB5 LmNvbW1vbi5tZW1vaXplZCBpbXBvcnQgbWVtb2l6ZWQKIAogCiBfbG9nID0gbG9nZ2luZy5nZXRM b2dnZXIoX19uYW1lX18pCkBAIC01NCw2ICs1NSwxNSBAQCBkZWYgY2xlYXJfY2FjaGVkX2NvbmZp Z3VyYXRpb24oKToKICAgICBfY29uZmlndXJhdGlvbiA9ICJSZWxlYXNlIgogCiAKK0BtZW1vaXpl ZAorZGVmIGFwcGxlX2FkZGl0aW9ucygpOgorICAgIHRyeToKKyAgICAgICAgIyBBIGxldmVsIG9m IDAgbWVhbnMgdGhhdCBvbmx5IGFic29sdXRlIHBhdGhzIHdpbGwgYmUgdXNlZC4KKyAgICAgICAg cmV0dXJuIF9faW1wb3J0X18oJ2FwcGxlX2FkZGl0aW9ucycsIGdsb2JhbHM9Z2xvYmFscygpLCBs b2NhbHM9Tm9uZSwgZnJvbWxpc3Q9W10sIGxldmVsPTApCisgICAgZXhjZXB0IEltcG9ydEVycm9y OgorICAgICAgICByZXR1cm4gTm9uZQorCisKIGNsYXNzIENvbmZpZyhvYmplY3QpOgogICAgIF9G TEFHU19GUk9NX0NPTkZJR1VSQVRJT05TID0gewogICAgICAgICAiRGVidWciOiAiLS1kZWJ1ZyIs CkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZGV2aWNlLnB5Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9kZXZpY2UucHkJKHJldmlzaW9uIDIxNTky NCkKKysrIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9kZXZpY2UucHkJKHdvcmtpbmcgY29w eSkKQEAgLTM1LDIwICszNSwyOSBAQCBjbGFzcyBEZXZpY2Uob2JqZWN0KToKICAgICBkZWYgaW5z dGFsbF9hcHAoc2VsZiwgYXBwX3BhdGgsIGVudj1Ob25lKToKICAgICAgICAgcmV0dXJuIHNlbGYu cGxhdGZvcm1fZGV2aWNlLmluc3RhbGxfYXBwKGFwcF9wYXRoLCBlbnYpCiAKKyAgICBkZWYgaW5z dGFsbF9keWxpYnMoc2VsZiwgcGF0aF90b19keWxpYnMpOgorICAgICAgICBpZiBoYXNhdHRyKHNl bGYucGxhdGZvcm1fZGV2aWNlLCAnaW5zdGFsbF9keWxpYnMnKToKKyAgICAgICAgICAgIHJldHVy biBzZWxmLnBsYXRmb3JtX2RldmljZS5pbnN0YWxsX2R5bGlicyhwYXRoX3RvX2R5bGlicz1wYXRo X3RvX2R5bGlicykKKyAgICAgICAgcmV0dXJuIFRydWUKKwogICAgIGRlZiBsYXVuY2hfYXBwKHNl bGYsIGJ1bmRsZV9pZCwgYXJncywgZW52PU5vbmUpOgogICAgICAgICByZXR1cm4gc2VsZi5wbGF0 Zm9ybV9kZXZpY2UubGF1bmNoX2FwcChidW5kbGVfaWQsIGFyZ3MsIGVudikKIAotICAgIGRlZiBw cmVwYXJlX2Zvcl90ZXN0aW5nKHNlbGYpOgorICAgIGRlZiBwcmVwYXJlX2Zvcl90ZXN0aW5nKHNl bGYsIHBvcnRzX3RvX2ZvcndhcmQsIHRlc3RfYXBwX2J1bmRsZV9pZCwgbGF5b3V0X3Rlc3RfZGly ZWN0b3J5KToKICAgICAgICAgaWYgbm90IHNlbGYubGlzdGVuaW5nX3NvY2tldDoKICAgICAgICAg ICAgIHNlbGYubGlzdGVuaW5nX3NvY2tldCA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQs IHNvY2tldC5TT0NLX1NUUkVBTSkKICAgICAgICAgICAgIHNlbGYubGlzdGVuaW5nX3NvY2tldC5z ZXRzb2Nrb3B0KHNvY2tldC5TT0xfU09DS0VULCBzb2NrZXQuU09fUkVVU0VBRERSLCAxKQogICAg ICAgICAgICAgc2VsZi5saXN0ZW5pbmdfc29ja2V0LmJpbmQoKCcxMjcuMC4wLjEnLCAwKSkKIAog ICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1fZGV2aWNlLCAncHJlcGFyZV9mb3JfdGVz dGluZycpOgotICAgICAgICAgICAgc2VsZi5wbGF0Zm9ybV9kZXZpY2UucHJlcGFyZV9mb3JfdGVz dGluZygpCisgICAgICAgICAgICBzZWxmLnBsYXRmb3JtX2RldmljZS5wcmVwYXJlX2Zvcl90ZXN0 aW5nKAorICAgICAgICAgICAgICAgIHBvcnRzX3RvX2ZvcndhcmQ9cG9ydHNfdG9fZm9yd2FyZCAr IFtzZWxmLmxpc3RlbmluZ19wb3J0KCldLAorICAgICAgICAgICAgICAgIHRlc3RfYXBwX2J1bmRs ZV9pZD10ZXN0X2FwcF9idW5kbGVfaWQsCisgICAgICAgICAgICAgICAgbGF5b3V0X3Rlc3RfZGly ZWN0b3J5PWxheW91dF90ZXN0X2RpcmVjdG9yeSwKKyAgICAgICAgICAgICkKIAogICAgIGRlZiBm aW5pc2hlZF90ZXN0aW5nKHNlbGYpOgotICAgICAgICBpZiBoYXNhdHRyKHNlbGYucGxhdGZvcm1f ZGV2aWNlLCAndGVhcmRvd24nKToKKyAgICAgICAgaWYgaGFzYXR0cihzZWxmLnBsYXRmb3JtX2Rl dmljZSwgJ2ZpbmlzaGVkX3Rlc3RpbmcnKToKICAgICAgICAgICAgIHNlbGYucGxhdGZvcm1fZGV2 aWNlLmZpbmlzaGVkX3Rlc3RpbmcoKQogCiAgICAgICAgIHNlbGYubGlzdGVuaW5nX3NvY2tldCA9 IE5vbmUKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5Cj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5CShyZXZpc2lv biAyMTU5MjQpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQkod29y a2luZyBjb3B5KQpAQCAtNTYsNyArNTYsNyBAQCBkZWYgcGxhdGZvcm1fb3B0aW9ucyh1c2VfZ2xv YnM9RmFsc2UpOgogICAgICAgICBvcHRwYXJzZS5tYWtlX29wdGlvbignLS1uby1pbnN0YWxsJywg YWN0aW9uPSdzdG9yZV9jb25zdCcsCiAgICAgICAgICAgICBjb25zdD1GYWxzZSwgZGVmYXVsdD1U cnVlLCBkZXN0PSdpbnN0YWxsJywKICAgICAgICAgICAgIGhlbHA9J1NraXAgaW5zdGFsbCBzdGVw IGZvciBkZXZpY2UgYW5kIHNpbXVsYXRvciB0ZXN0aW5nJyksCi0gICAgICAgIF0KKyAgICAgICAg XSArIChjb25maWcuYXBwbGVfYWRkaXRpb25zKCkucGxhdGZvcm1fb3B0aW9ucygpIGlmIGNvbmZp Zy5hcHBsZV9hZGRpdGlvbnMoKSBlbHNlIFtdKQogCiAKIGRlZiBjb25maWd1cmF0aW9uX29wdGlv bnMoKToKSW5kZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3MucHkKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvcy5weQkocmV2aXNpb24gMjE1OTI0 KQorKysgVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvcy5weQkod29ya2luZyBjb3B5KQpA QCAtMTE4LDExICsxMTgsMTcgQEAgY2xhc3MgSU9TUG9ydChEYXJ3aW5Qb3J0KToKICAgICAgICAg ICAgICAgICAjIGxlYXZpbmcgYSBjcmFzaCBsb2cgd2hpY2ggd2lsbCBiZSBwaWNrZWQgdXAgaW4g cmVzdWx0cy4gRFlMRF9GUkFNRVdPUktfUEFUSCBpcyBuZWVkZWQgdG8gcHJldmVudCBhbiBlYXJs eSBjcmFzaC4KICAgICAgICAgICAgICAgICBpZiBub3QgZGV2aWNlLmluc3RhbGxfYXBwKHNlbGYu X3BhdGhfdG9fZHJpdmVyKCksIHsnRFlMRF9MSUJSQVJZX1BBVEgnOiBzZWxmLl9idWlsZF9wYXRo KCksICdEWUxEX0ZSQU1FV09SS19QQVRIJzogc2VsZi5fYnVpbGRfcGF0aCgpfSk6CiAgICAgICAg ICAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignRmFpbGVkIHRvIGluc3RhbGwgYXBwIHt9 IG9uIGRldmljZSB7fScuZm9ybWF0KHNlbGYuX3BhdGhfdG9fZHJpdmVyKCksIGRldmljZS51ZGlk KSkKKyAgICAgICAgICAgICAgICBpZiBub3QgZGV2aWNlLmluc3RhbGxfZHlsaWJzKHNlbGYuX2J1 aWxkX3BhdGgoKSk6CisgICAgICAgICAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignRmFp bGVkIHRvIGluc3RhbGwgZHlsaWJzIGF0IHt9IG9uIGRldmljZSB7fScuZm9ybWF0KHNlbGYuX2J1 aWxkX3BhdGgoKSwgZGV2aWNlLnVkaWQpKQogICAgICAgICBlbHNlOgogICAgICAgICAgICAgX2xv Zy5kZWJ1ZygnU2tpcHBpbmcgaW5zdGFsbGF0aW9uJykKIAogICAgICAgICBmb3IgaSBpbiB4cmFu Z2Uoc2VsZi5jaGlsZF9wcm9jZXNzZXMoKSk6Ci0gICAgICAgICAgICBzZWxmLnRhcmdldF9ob3N0 KGkpLnByZXBhcmVfZm9yX3Rlc3RpbmcoKQorICAgICAgICAgICAgc2VsZi50YXJnZXRfaG9zdChp KS5wcmVwYXJlX2Zvcl90ZXN0aW5nKAorICAgICAgICAgICAgICAgIHNlbGYucG9ydHNfdG9fZm9y d2FyZCgpLAorICAgICAgICAgICAgICAgIHNlbGYuYXBwX2lkZW50aWZpZXJfZnJvbV9idW5kbGUo c2VsZi5fcGF0aF90b19kcml2ZXIoKSksCisgICAgICAgICAgICAgICAgc2VsZi5sYXlvdXRfdGVz dHNfZGlyKCksCisgICAgICAgICAgICApCiAKICAgICBkZWYgY2xlYW5fdXBfdGVzdF9ydW4oc2Vs Zik6CiAgICAgICAgIHN1cGVyKElPU1BvcnQsIHNlbGYpLmNsZWFuX3VwX3Rlc3RfcnVuKCkKSW5k ZXg6IFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9pb3NfZGV2aWNlLnB5CShyZXZpc2lvbiAy MTU5MjQpCisrKyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2RldmljZS5weQkod29y a2luZyBjb3B5KQpAQCAtMjIsNiArMjIsOCBAQAogCiBpbXBvcnQgbG9nZ2luZwogCitmcm9tIHdl YmtpdHB5LmNvbW1vbi5tZW1vaXplZCBpbXBvcnQgbWVtb2l6ZWQKK2Zyb20gd2Via2l0cHkucG9y dC5jb25maWcgaW1wb3J0IGFwcGxlX2FkZGl0aW9ucwogZnJvbSB3ZWJraXRweS5wb3J0LmlvcyBp bXBvcnQgSU9TUG9ydAogCiBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCkBAIC0z MywyMCArMzUsNjcgQEAgY2xhc3MgSU9TRGV2aWNlUG9ydChJT1NQb3J0KToKICAgICBBUkNISVRF Q1RVUkVTID0gWydhcm12NycsICdhcm12N3MnLCAnYXJtNjQnXQogICAgIERFRkFVTFRfQVJDSElU RUNUVVJFID0gJ2FybTY0JwogICAgIFZFUlNJT05fRkFMTEJBQ0tfT1JERVIgPSBbJ2lvcy03Jywg J2lvcy04JywgJ2lvcy05JywgJ2lvcy0xMCddCisgICAgU0RLID0gYXBwbGVfYWRkaXRpb25zKCku aW9zX2RldmljZV9TREsoKSBpZiBhcHBsZV9hZGRpdGlvbnMoKSBlbHNlICdpcGhvbmVvcycKKyAg ICBOT19PTl9ERVZJQ0VfVEVTVElORyA9ICdPbi1kZXZpY2UgdGVzdGluZyBpcyBub3Qgc3VwcG9y dGVkIG9uIHRoaXMgbWFjaGluZScKKworICAgIEBtZW1vaXplZAorICAgIGRlZiBkZWZhdWx0X2No aWxkX3Byb2Nlc3NlcyhzZWxmKToKKyAgICAgICAgaWYgYXBwbGVfYWRkaXRpb25zKCk6CisgICAg ICAgICAgICByZXR1cm4gYXBwbGVfYWRkaXRpb25zKCkuaW9zX2RldmljZV9kZWZhdWx0X2NoaWxk X3Byb2Nlc3NlcyhzZWxmKQorICAgICAgICByZXR1cm4gMQorCisgICAgZGVmIHVzaW5nX211bHRp cGxlX2RldmljZXMoc2VsZik6CisgICAgICAgIHJldHVybiBUcnVlCisKKyAgICBkZWYgX2Rldmlj ZV9mb3Jfd29ya2VyX251bWJlcl9tYXAoc2VsZik6CisgICAgICAgIGlmIG5vdCBhcHBsZV9hZGRp dGlvbnMoKToKKyAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcihzZWxmLk5PX09OX0RFVklD RV9URVNUSU5HKQorICAgICAgICByZXR1cm4gYXBwbGVfYWRkaXRpb25zKCkuaW9zX2RldmljZV9m b3Jfd29ya2VyX251bWJlcl9tYXAoc2VsZikKKworICAgIGRlZiBfZHJpdmVyX2NsYXNzKHNlbGYp OgorICAgICAgICBpZiBhcHBsZV9hZGRpdGlvbnMoKToKKyAgICAgICAgICAgIHJldHVybiBhcHBs ZV9hZGRpdGlvbnMoKS5pb3NfZGV2aWNlX2RyaXZlcigpCisgICAgICAgIHJldHVybiBzdXBlcihJ T1NEZXZpY2VQb3J0LCBzZWxmKS5fZHJpdmVyX2NsYXNzKCkKIAogICAgIEBjbGFzc21ldGhvZAog ICAgIGRlZiBkZXRlcm1pbmVfZnVsbF9wb3J0X25hbWUoY2xzLCBob3N0LCBvcHRpb25zLCBwb3J0 X25hbWUpOgogICAgICAgICBpZiBwb3J0X25hbWUgPT0gY2xzLnBvcnRfbmFtZToKLSAgICAgICAg ICAgIGlwaG9uZW9zX3Nka192ZXJzaW9uID0gaG9zdC5wbGF0Zm9ybS54Y29kZV9zZGtfdmVyc2lv bignaXBob25lb3MnKQorICAgICAgICAgICAgaXBob25lb3Nfc2RrX3ZlcnNpb24gPSBob3N0LnBs YXRmb3JtLnhjb2RlX3Nka192ZXJzaW9uKGNscy5TREspCiAgICAgICAgICAgICBpZiBub3QgaXBo b25lb3Nfc2RrX3ZlcnNpb246CiAgICAgICAgICAgICAgICAgcmFpc2UgRXhjZXB0aW9uKCJQbGVh c2UgaW5zdGFsbCB0aGUgaU9TIFNESy4iKQogICAgICAgICAgICAgbWFqb3JfdmVyc2lvbl9udW1i ZXIgPSBpcGhvbmVvc19zZGtfdmVyc2lvbi5zcGxpdCgnLicpWzBdCiAgICAgICAgICAgICBwb3J0 X25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBtYWpvcl92ZXJzaW9uX251bWJlcgogICAgICAgICBy ZXR1cm4gcG9ydF9uYW1lCiAKKyAgICAjIEZJWE1FOiBUaGVzZSBuZWVkIGRldmljZSBpbXBsZW1l bnRhdGlvbnMgPHJkYXI6Ly9wcm9ibGVtLzMwNDk3OTkxPi4KKyAgICBkZWYgY2hlY2tfZm9yX2xl YWtzKHNlbGYsIHByb2Nlc3NfbmFtZSwgcHJvY2Vzc19waWQpOgorICAgICAgICBwYXNzCisKKyAg ICBkZWYgbG9va19mb3JfbmV3X2NyYXNoX2xvZ3Moc2VsZiwgY3Jhc2hlZF9wcm9jZXNzZXMsIHN0 YXJ0X3RpbWUpOgorICAgICAgICByZXR1cm4ge30KKworICAgIGRlZiBsb29rX2Zvcl9uZXdfc2Ft cGxlcyhzZWxmLCB1bnJlc3BvbnNpdmVfcHJvY2Vzc2VzLCBzdGFydF90aW1lKToKKyAgICAgICAg cmV0dXJuIHt9CisKKyAgICBkZWYgc2FtcGxlX3Byb2Nlc3Moc2VsZiwgbmFtZSwgcGlkLCB0YXJn ZXRfaG9zdD1Ob25lKToKKyAgICAgICAgcGFzcworCiAgICAgIyBEZXNwaXRlIHRoZWlyIG5hbWVz LCB0aGVzZSBmbGFncyBkbyBub3QgYWN0dWFsbHkgZ2V0IHBhc3NlZCBhbGwgdGhlIHdheSBkb3du IHRvIHdlYmtpdC1idWlsZC4KICAgICBkZWYgX2J1aWxkX2RyaXZlcl9mbGFncyhzZWxmKToKLSAg ICAgICAgcmV0dXJuIFsnLS1zZGsnLCAnaXBob25lb3MnXSArIChbJ0FSQ0hTPSVzJyAlIHNlbGYu YXJjaGl0ZWN0dXJlKCldIGlmIHNlbGYuYXJjaGl0ZWN0dXJlKCkgZWxzZSBbXSkKKyAgICAgICAg cmV0dXJuIFsnLS1zZGsnLCBzZWxmLlNES10gKyAoWydBUkNIUz0lcycgJSBzZWxmLmFyY2hpdGVj dHVyZSgpXSBpZiBzZWxmLmFyY2hpdGVjdHVyZSgpIGVsc2UgW10pCiAKICAgICBkZWYgb3BlcmF0 aW5nX3N5c3RlbShzZWxmKToKICAgICAgICAgcmV0dXJuICdpb3MtZGV2aWNlJworCisgICAgZGVm IF9jcmVhdGVfZGV2aWNlcyhzZWxmLCBkZXZpY2VfY2xhc3MpOgorICAgICAgICBpZiBub3QgYXBw bGVfYWRkaXRpb25zKCk6CisgICAgICAgICAgICByYWlzZSBSdW50aW1lRXJyb3Ioc2VsZi5OT19P Tl9ERVZJQ0VfVEVTVElORykKKyAgICAgICAgaWYgbm90IHNlbGYuX2RldmljZV9mb3Jfd29ya2Vy X251bWJlcl9tYXAoKToKKyAgICAgICAgICAgIHJhaXNlIFJ1bnRpbWVFcnJvcignTm8gZGV2aWNl cyBhcmUgYXZhaWxhYmxlIGZvciB0ZXN0aW5nJykKKworICAgICAgICBpZiBzZWxmLmRlZmF1bHRf Y2hpbGRfcHJvY2Vzc2VzKCkgPCBzZWxmLmNoaWxkX3Byb2Nlc3NlcygpOgorICAgICAgICAgICAg cmFpc2UgUnVudGltZUVycm9yKCdOb3QgZW5vdWdodCBjb25uZWN0ZWQgZGV2aWNlcyBmb3Ige30g cHJvY2Vzc2VzJy5mb3JtYXQoc2VsZi5jaGlsZF9wcm9jZXNzZXMoKSkpCisKKyAgICBkZWYgY2xl YW5fdXBfdGVzdF9ydW4oc2VsZik6CisgICAgICAgIHN1cGVyKElPU0RldmljZVBvcnQsIHNlbGYp LmNsZWFuX3VwX3Rlc3RfcnVuKCkKKyAgICAgICAgYXBwbGVfYWRkaXRpb25zKCkuaW9zX2Rldmlj ZV9jbGVhbl91cF90ZXN0X3J1bihzZWxmLCBzZWxmLl9wYXRoX3RvX2RyaXZlcigpLCBzZWxmLl9i dWlsZF9wYXRoKCkpCkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zX2Rldmlj ZV91bml0dGVzdC5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQv aW9zX2RldmljZV91bml0dGVzdC5weQkocmV2aXNpb24gMjE1OTI0KQorKysgVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9wb3J0L2lvc19kZXZpY2VfdW5pdHRlc3QucHkJKHdvcmtpbmcgY29weSkKQEAg LTM2LDMgKzM2LDEzIEBAIGNsYXNzIElPU0RldmljZVRlc3QoaW9zX3Rlc3RjYXNlLklPU1Rlc3QK IAogICAgIGRlZiB0ZXN0X29wZXJhdGluZ19zeXN0ZW0oc2VsZik6CiAgICAgICAgIHNlbGYuYXNz ZXJ0RXF1YWwoJ2lvcy1kZXZpY2UnLCBzZWxmLm1ha2VfcG9ydCgpLm9wZXJhdGluZ19zeXN0ZW0o KSkKKworICAgICMgRklYTUU6IFVwZGF0ZSB0ZXN0cyB3aGVuIDxyZGFyOi8vcHJvYmxlbS8zMDQ5 Nzk5MT4gaXMgY29tcGxldGVkLgorICAgIGRlZiB0ZXN0X3NwaW5kdW1wKHNlbGYpOgorICAgICAg ICBwYXNzCisKKyAgICBkZWYgdGVzdF9zYW1wbGVfcHJvY2VzcyhzZWxmKToKKyAgICAgICAgcGFz cworCisgICAgZGVmIHRlc3Rfc2FtcGxlX3Byb2Nlc3NfZXhjZXB0aW9uKHNlbGYpOgorICAgICAg ICBwYXNzCg==