From mboxrd@z Thu Jan 1 00:00:00 1970 From: Pallai Roland Subject: [PATCH] proactive raid5 disk replacement, 2.6.14 Date: Thu, 10 Nov 2005 04:21:28 +0100 Message-ID: <1131592888.16325.98.camel@localhost.localdomain> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=-cvrENmlRXkwLAfO+s1cW" Return-path: Sender: linux-raid-owner@vger.kernel.org To: linux-raid@vger.kernel.org List-Id: linux-raid.ids --=-cvrENmlRXkwLAfO+s1cW Content-Type: text/plain Content-Transfer-Encoding: 7bit *biiiiig* thanks for all developers of bitmap-based raid5 resyncing and bad block rewriting, both of them is really great feature! :) I ported my "proactive thing" to the new kernel, it can live nicely with the new features now.. some bugs hunted in the last month, it's quite stable for me if you wanna give a try you must apply Neil's badblock rewriting patch first, attached also - *readme* - This is a feature patch that implements 'proactive raid5 disk replacement' (http://www.arctic.org/~dean/raid-wishlist.html), that could help a lot on large raid5 arrays built from cheap sata drivers when the IO traffic such large that daily media scan on the disks isn't possible. An atypical breakdown situation is when a drive gets kicked from the array due to a bad block, I replace it but the resync fails cause another 2-3 disks has hidden badblocks too. In this situation I've to save the disks with dd and rebuild bad blocks with a userspace tool (by hand), meanwhile the site is down for hours. This patch tries to give a solution for this problem, the two main feature is: 1. Don't kick a drive on read error cause it is possible that 99.99% is useable and will help (to serve and to save data) if another drive shows bad sectors in same array - Neil's new (experimental) sector rewrite feature included, the first thing is always a try to rewrite the bad sector 2. Let to mirror a partially failed drive to a spare _online_ and replace the source of the mirror with the spare when it's done. Bad blocks isn't a problem unless same stripe is damaged on two disks what's a rare case. In this way is possible to fix an array with partially failed drives without data loss and without downtime. In other words, you never have to degrade the array due to a disk change, you can do that in optimal state. Per-device bad block cache is implemented to speed up arrays with partially failed drives (replies are often slow from those), also helps to determine badly damaged drives based on number of bad blocks, and can take an action if steps over an user defined threshold (see /proc/sys/dev/raid/badblock_tolerance). Rewrite of a bad block will delete the entry from the cache. performance is affected just a little bit if there's no or some registered bad blocks, but over a million that could be a problem currently.. Some words about error handling: first big change is now you can use an external error handler, what means that a user-space script will be called by the kernel to handle the situation. The common method in this script is to call 'mdadm' and choosing return values (see below). This is good -for example- if you have 1 spare drive for 2 arrays, a script can handle it nicely.. If the script has failed to run (or does not exists), there's a default algorithm, the main guidelines of that: - a "disk fail" means that it's oversteps the 'badblock threshold' or failed on write - if a drive fails in an optimal array and there's no spare the disk will be kicked from the array - if the drive fails in degraded array the drive _won't_ be kicked. processes gets read/write error if data is needed from the damaged sectors. if you want the old behavior use an external error handler - if drive fails and there's a spare then the proactive mirroring begins to the spare. the failing drive won't be kicked until the mirror has not been done Well, better if you know, It's an ugly hack, I'm not a kernel guru, but I love the idea and now I can't live without it on my own servers (so this is works for me). I hope somebody will implement this feature once in a much nicer adaptation, I'm trying to maintain this patch till then.. You should put your external error handler script at location "/sbin/mdevent"; it gets the following arguments: 1st: name of the md array (eg.: "md0") 2nd: kind of the fail event as string, currently always "drivefail" 3rd: name of the drive (maybe major/minor nr would be better, currently you can translate to that by /proc/partitions) Let's see how can you handle some situations from the script: array is optimal, a disk fails: you want to.. fail that drive and add a spare for normal rebuilding mdadm -f /dev/$2 /dev/$3 mdadm -a /dev/$2 /dev/my_spare1 exit 0 ..start proactive mirroring of that disk mdadm -a /dev/$2 /dev/my_spare1 exit 0 ..keep it on and reset the badblock cache exit 1 ..just keep it in sync exit 0 ..let the default action exit 2 Notice that if the proactive mirroring is done the spare won't replace the source drive automatically, you should do it by hand or by a scheluded task. You've got a last chance to re-think it. (raid6 could be another solution for this problem, but that's the big far evil in my eyes ;) use: 1. patch the kernel, this one is against 2.6.14 2. type: # make the drives mdadm -B -n1 -l faulty -c4 /dev/md/1 /dev/rd/0 mdadm -B -n1 -l faulty -c4 /dev/md/2 /dev/rd/1 mdadm -B -n1 -l faulty -c4 /dev/md/3 /dev/rd/2 # make the array mdadm -C -n3 -l5 /dev/md/0 /dev/md/1 /dev/md/2 /dev/md/3 # .. wait for sync .. # grow bad blocks as ma*tor does :) mdadm --grow -l faulty -p rp454 /dev/md/1 mdadm --grow -l faulty -p rp738 /dev/md/2 # add a spare mdadm -a /dev/md/0 /dev/rd/4 # -> fail a drive, sync begins <- # the md/1 will not be marked as failed, this is the point, but # if you want to, you can issue this command again mdadm -f /dev/md/0 /dev/md/1 # kernel: # resync from md1 to spare ram4 # added spare for active resync # .. wonder the read errors from md[12] and the sync goes on! # feel free to stress the md at this time, mkfs, dd, badblocks, etc # kernel: # raid5_spare_active: 3 in_sync 3->0 # /proc/mdstat: # md0 : active raid5 ram4[0] md3[2] md2[1] md1[0] # -> ram4 and md1 has same id, this means the spare is a complete mirror, # if you stop the array you can assembly it with ram4 instead of md1, # the superblock is same on them # check the mirror (stop write stress if any) mdadm --grow -l faulty -p none /dev/md/1 cmp /dev/md/1 /dev/rd/4 # hot-replace the mirrored -partially failed- device with the active spare # (yes, mark it as failed again, but if there's a syncing- or synced 'active spare' # the -f really fails the device or replace it with the synced spare) mdadm -f /dev/md/0 /dev/md/1 # kernel: # replace md1 with in_sync active spare ram4 # and voila! # /proc/mdstat: # md0 : active raid5 ram4[0] md3[2] md2[1] -- dap --=-cvrENmlRXkwLAfO+s1cW Content-Disposition: attachment; filename=05_raid5-rewr1.diff Content-Type: text/x-patch; name=05_raid5-rewr1.diff; charset=us-ascii Content-Transfer-Encoding: base64 ZGlmZiAuL2RyaXZlcnMvbWQvcmFpZDUuY35jdXJyZW50fiAuL2RyaXZlcnMvbWQvcmFpZDUuYw0K LS0tIC4vZHJpdmVycy9tZC9yYWlkNS5jfmN1cnJlbnR+CTIwMDUtMDktMTYgMTI6MjE6MjQuMDAw MDAwMDAwICsxMDAwDQorKysgLi9kcml2ZXJzL21kL3JhaWQ1LmMJMjAwNS0wOS0xNiAxMjo1Nzox Mi4wMDAwMDAwMDAgKzEwMDANCkBAIC0zNDksNyArMzQ5LDcgQEAgc3RhdGljIHZvaWQgc2hyaW5r X3N0cmlwZXMocmFpZDVfY29uZl90IA0KIAljb25mLT5zbGFiX2NhY2hlID0gTlVMTDsNCiB9DQog DQotc3RhdGljIGludCByYWlkNV9lbmRfcmVhZF9yZXF1ZXN0IChzdHJ1Y3QgYmlvICogYmksIHVu c2lnbmVkIGludCBieXRlc19kb25lLA0KK3N0YXRpYyBpbnQgcmFpZDVfZW5kX3JlYWRfcmVxdWVz dChzdHJ1Y3QgYmlvICogYmksIHVuc2lnbmVkIGludCBieXRlc19kb25lLA0KIAkJCQkgICBpbnQg ZXJyb3IpDQogew0KICAJc3RydWN0IHN0cmlwZV9oZWFkICpzaCA9IGJpLT5iaV9wcml2YXRlOw0K QEAgLTQwMSwxMCArNDAxLDI3IEBAIHN0YXRpYyBpbnQgcmFpZDVfZW5kX3JlYWRfcmVxdWVzdCAo c3RydWMNCiAJCX0NCiAjZWxzZQ0KIAkJc2V0X2JpdChSNV9VUFRPREFURSwgJnNoLT5kZXZbaV0u ZmxhZ3MpOw0KLSNlbmRpZgkJDQorI2VuZGlmDQorCQlpZiAodGVzdF9iaXQoUjVfUmVhZEVycm9y LCAmc2gtPmRldltpXS5mbGFncykpIHsNCisJCQlwcmludGsoIlI1OiByZWFkIGVycm9yIGNvcnJl Y3RlZCEhXG4iKTsNCisJCQljbGVhcl9iaXQoUjVfUmVhZEVycm9yLCAmc2gtPmRldltpXS5mbGFn cyk7DQorCQkJY2xlYXJfYml0KFI1X1JlV3JpdGUsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCisJCX0N CiAJfSBlbHNlIHsNCi0JCW1kX2Vycm9yKGNvbmYtPm1kZGV2LCBjb25mLT5kaXNrc1tpXS5yZGV2 KTsNCiAJCWNsZWFyX2JpdChSNV9VUFRPREFURSwgJnNoLT5kZXZbaV0uZmxhZ3MpOw0KKwkJaWYg KGNvbmYtPm1kZGV2LT5kZWdyYWRlZCkgew0KKwkJCXByaW50aygiUjU6IHJlYWQgZXJyb3Igbm90 IGNvcnJlY3RhYmxlLlxuIik7DQorCQkJY2xlYXJfYml0KFI1X1JlYWRFcnJvciwgJnNoLT5kZXZb aV0uZmxhZ3MpOw0KKwkJCWNsZWFyX2JpdChSNV9SZVdyaXRlLCAmc2gtPmRldltpXS5mbGFncyk7 DQorCQkJbWRfZXJyb3IoY29uZi0+bWRkZXYsIGNvbmYtPmRpc2tzW2ldLnJkZXYpOw0KKwkJfSBl bHNlIGlmICh0ZXN0X2JpdChSNV9SZVdyaXRlLCAmc2gtPmRldltpXS5mbGFncykpIHsNCisJCQkv KiBPaCwgbm8hISEgKi8NCisJCQlwcmludGsoIlI1OiByZWFkIGVycm9yIE5PVCBjb3JyZWN0ZWQh IVxuIik7DQorCQkJY2xlYXJfYml0KFI1X1JlYWRFcnJvciwgJnNoLT5kZXZbaV0uZmxhZ3MpOw0K KwkJCWNsZWFyX2JpdChSNV9SZVdyaXRlLCAmc2gtPmRldltpXS5mbGFncyk7DQorCQkJbWRfZXJy b3IoY29uZi0+bWRkZXYsIGNvbmYtPmRpc2tzW2ldLnJkZXYpOw0KKwkJfSBlbHNlDQorCQkJc2V0 X2JpdChSNV9SZWFkRXJyb3IsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCiAJfQ0KIAlyZGV2X2RlY19w ZW5kaW5nKGNvbmYtPmRpc2tzW2ldLnJkZXYsIGNvbmYtPm1kZGV2KTsNCiAjaWYgMA0KQEAgLTk2 Niw2ICs5ODMsMTIgQEAgc3RhdGljIHZvaWQgaGFuZGxlX3N0cmlwZShzdHJ1Y3Qgc3RyaXBlXw0K IAkJaWYgKGRldi0+d3JpdHRlbikgd3JpdHRlbisrOw0KIAkJcmRldiA9IGNvbmYtPmRpc2tzW2ld LnJkZXY7IC8qIEZJWE1FLCBzaG91bGQgSSBiZSBsb29raW5nIHJkZXYgKi8NCiAJCWlmICghcmRl diB8fCAhcmRldi0+aW5fc3luYykgew0KKwkJCS8qIFRoZSBSZWFkRXJyb3IgZmxhZyB3aWwganVz dCBiZSBjb25mdXNpbmcgbm93ICovDQorCQkJY2xlYXJfYml0KFI1X1JlYWRFcnJvciwgJmRldi0+ ZmxhZ3MpOw0KKwkJCWNsZWFyX2JpdChSNV9SZVdyaXRlLCAmZGV2LT5mbGFncyk7DQorCQl9DQor CQlpZiAoIXJkZXYgfHwgIXJkZXYtPmluX3N5bmMNCisJCSAgICB8fCB0ZXN0X2JpdChSNV9SZWFk RXJyb3IsICZkZXYtPmZsYWdzKSkgew0KIAkJCWZhaWxlZCsrOw0KIAkJCWZhaWxlZF9udW0gPSBp Ow0KIAkJfSBlbHNlDQpAQCAtOTgwLDYgKzEwMDMsMTQgQEAgc3RhdGljIHZvaWQgaGFuZGxlX3N0 cmlwZShzdHJ1Y3Qgc3RyaXBlXw0KIAlpZiAoZmFpbGVkID4gMSAmJiB0b19yZWFkK3RvX3dyaXRl K3dyaXR0ZW4pIHsNCiAJCWZvciAoaT1kaXNrczsgaS0tOyApIHsNCiAJCQlpbnQgYml0bWFwX2Vu ZCA9IDA7DQorDQorCQkJaWYgKHRlc3RfYml0KFI1X1JlYWRFcnJvciwgJnNoLT5kZXZbaV0uZmxh Z3MpKSB7DQorCQkJCW1ka19yZGV2X3QgKnJkZXYgPSBjb25mLT5kaXNrc1tpXS5yZGV2Ow0KKwkJ CQlpZiAocmRldiAmJiByZGV2LT5pbl9zeW5jKQ0KKwkJCQkJLyogbXVsdGlwbGUgcmVhZCBmYWls dXJlcyBpbiBvbmUgc3RyaXBlICovDQorCQkJCQltZF9lcnJvcihjb25mLT5tZGRldiwgcmRldik7 DQorCQkJfQ0KKw0KIAkJCXNwaW5fbG9ja19pcnEoJmNvbmYtPmRldmljZV9sb2NrKTsNCiAJCQkv KiBmYWlsIGFsbCB3cml0ZXMgZmlyc3QgKi8NCiAJCQliaSA9IHNoLT5kZXZbaV0udG93cml0ZTsN CkBAIC0xMDE1LDcgKzEwNDYsOCBAQCBzdGF0aWMgdm9pZCBoYW5kbGVfc3RyaXBlKHN0cnVjdCBz dHJpcGVfDQogCQkJfQ0KIA0KIAkJCS8qIGZhaWwgYW55IHJlYWRzIGlmIHRoaXMgZGV2aWNlIGlz IG5vbi1vcGVyYXRpb25hbCAqLw0KLQkJCWlmICghdGVzdF9iaXQoUjVfSW5zeW5jLCAmc2gtPmRl dltpXS5mbGFncykpIHsNCisJCQlpZiAoIXRlc3RfYml0KFI1X0luc3luYywgJnNoLT5kZXZbaV0u ZmxhZ3MpIHx8DQorCQkJICAgIHRlc3RfYml0KFI1X1JlYWRFcnJvciwgJnNoLT5kZXZbaV0uZmxh Z3MpKSB7DQogCQkJCWJpID0gc2gtPmRldltpXS50b3JlYWQ7DQogCQkJCXNoLT5kZXZbaV0udG9y ZWFkID0gTlVMTDsNCiAJCQkJaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChSNV9PdmVybGFwLCAmc2gt PmRldltpXS5mbGFncykpDQpAQCAtMTI3NCw3ICsxMzA2LDI2IEBAIHN0YXRpYyB2b2lkIGhhbmRs ZV9zdHJpcGUoc3RydWN0IHN0cmlwZV8NCiAJCW1kX2RvbmVfc3luYyhjb25mLT5tZGRldiwgU1RS SVBFX1NFQ1RPUlMsMSk7DQogCQljbGVhcl9iaXQoU1RSSVBFX1NZTkNJTkcsICZzaC0+c3RhdGUp Ow0KIAl9DQotCQ0KKw0KKwkvKiBJZiB0aGUgZmFpbGVkIGRyaXZlIGlzIGp1c3QgYSBSZWFkRXJy b3IsIHRoZW4gd2UgbWlnaHQgbmVlZCB0byBwcm9ncmVzcw0KKwkgKiB0aGUgcmVwYWlyL2NoZWNr IHByb2Nlc3MNCisJICovDQorCWlmIChmYWlsZWQgPT0gMSAmJiB0ZXN0X2JpdChSNV9SZWFkRXJy b3IsICZzaC0+ZGV2W2ZhaWxlZF9udW1dLmZsYWdzKQ0KKwkgICAgJiYgIXRlc3RfYml0KFI1X0xP Q0tFRCwgJnNoLT5kZXZbZmFpbGVkX251bV0uZmxhZ3MpDQorCSAgICAmJiB0ZXN0X2JpdChSNV9V UFRPREFURSwgJnNoLT5kZXZbZmFpbGVkX251bV0uZmxhZ3MpDQorCQkpIHsNCisJCWRldiA9ICZz aC0+ZGV2W2ZhaWxlZF9udW1dOw0KKwkJaWYgKCF0ZXN0X2JpdChSNV9SZVdyaXRlLCAmZGV2LT5m bGFncykpIHsNCisJCQlzZXRfYml0KFI1X1dhbnR3cml0ZSwgJmRldi0+ZmxhZ3MpOw0KKwkJCXNl dF9iaXQoUjVfUmVXcml0ZSwgJmRldi0+ZmxhZ3MpOw0KKwkJCXNldF9iaXQoUjVfTE9DS0VELCAm ZGV2LT5mbGFncyk7DQorCQl9IGVsc2Ugew0KKwkJCS8qIGxldCdzIHJlYWQgaXQgYmFjayAqLw0K KwkJCXNldF9iaXQoUjVfV2FudHJlYWQsICZkZXYtPmZsYWdzKTsNCisJCQlzZXRfYml0KFI1X0xP Q0tFRCwgJmRldi0+ZmxhZ3MpOw0KKwkJfQ0KKwl9DQorDQogCXNwaW5fdW5sb2NrKCZzaC0+bG9j ayk7DQogDQogCXdoaWxlICgoYmk9cmV0dXJuX2JpKSkgew0KDQpkaWZmIC4vaW5jbHVkZS9saW51 eC9yYWlkL3JhaWQ1Lmh+Y3VycmVudH4gLi9pbmNsdWRlL2xpbnV4L3JhaWQvcmFpZDUuaA0KLS0t IC4vaW5jbHVkZS9saW51eC9yYWlkL3JhaWQ1Lmh+Y3VycmVudH4JMjAwNS0wOS0xNiAxMjoyMToy NC4wMDAwMDAwMDAgKzEwMDANCisrKyAuL2luY2x1ZGUvbGludXgvcmFpZC9yYWlkNS5oCTIwMDUt MDktMTYgMTI6NTU6NTEuMDAwMDAwMDAwICsxMDAwDQpAQCAtMTU0LDYgKzE1NCw4IEBAIHN0cnVj dCBzdHJpcGVfaGVhZCB7DQogI2RlZmluZQlSNV9XYW50d3JpdGUJNQ0KICNkZWZpbmUJUjVfU3lu Y2lvCTYJLyogdGhpcyBpbyBuZWVkIHRvIGJlIGFjY291bnRlZCBhcyByZXN5bmMgaW8gKi8NCiAj ZGVmaW5lCVI1X092ZXJsYXAJNwkvKiBUaGVyZSBpcyBhIHBlbmRpbmcgb3ZlcmxhcHBpbmcgcmVx dWVzdCBvbiB0aGlzIGJsb2NrICovDQorI2RlZmluZQlSNV9SZWFkRXJyb3IJOAkvKiBzZWVuIGEg cmVhZCBlcnJvciBoZXJlIHJlY2VudGx5ICovDQorI2RlZmluZQlSNV9SZVdyaXRlCTkJLyogaGF2 ZSB0cmllZCB0byBvdmVyLXdyaXRlIHRoZSByZWFkZXJyb3IgKi8NCiANCiAvKg0KICAqIFdyaXRl IG1ldGhvZA0K --=-cvrENmlRXkwLAfO+s1cW Content-Disposition: attachment; filename=04_raid5-asp-dap7.diff Content-Type: text/x-patch; name=04_raid5-asp-dap7.diff; charset=us-ascii Content-Transfer-Encoding: base64 LS0tIGxpbnV4L2luY2x1ZGUvbGludXgvc3lzY3RsLmgub3JpZwkyMDA1LTExLTA4IDE0OjQxOjA2 LjAwMDAwMDAwMCArMDEwMA0KKysrIGxpbnV4L2luY2x1ZGUvbGludXgvc3lzY3RsLmgJMjAwNS0x MS0wOSAyMDowODo1MS4wMDAwMDAwMDAgKzAxMDANCkBAIC03NTgsNyArNzU4LDggQEANCiAvKiAv cHJvYy9zeXMvZGV2L3JhaWQgKi8NCiBlbnVtIHsNCiAJREVWX1JBSURfU1BFRURfTElNSVRfTUlO PTEsDQotCURFVl9SQUlEX1NQRUVEX0xJTUlUX01BWD0yDQorCURFVl9SQUlEX1NQRUVEX0xJTUlU X01BWD0yLA0KKwlERVZfUkFJRF9CQURCTE9DS19UT0xFUkFOQ0U9Mw0KIH07DQogDQogLyogL3By b2Mvc3lzL2Rldi9wYXJwb3J0L2RlZmF1bHQgKi8NCi0tLSBsaW51eC9pbmNsdWRlL2xpbnV4L3Jh aWQvbWRfay5oLm9yaWcJMjAwNS0xMC0yOCAwMjowMjowOC4wMDAwMDAwMDAgKzAyMDANCisrKyBs aW51eC9pbmNsdWRlL2xpbnV4L3JhaWQvbWRfay5oCTIwMDUtMTEtMDkgMjA6MDY6MDIuMDAwMDAw MDAwICswMTAwDQpAQCAtMTY1LDYgKzE2NSwxMSBAQA0KIAljaGFyCQkJCXV1aWRbMTZdOw0KIA0K IAlzdHJ1Y3QgbWRrX3RocmVhZF9zCQkqdGhyZWFkOwkvKiBtYW5hZ2VtZW50IHRocmVhZCAqLw0K KwlzdHJ1Y3QgbWRrX3RocmVhZF9zCQkqZWVoX3RocmVhZDsJLyogZXh0ZXJuYWwgZXJyb3IgaGFu ZGxlciAqLw0KKwlzdHJ1Y3QgZWVoX2RhdGEgew0KKwkJaW50CQkJZmFpbGVkX251bTsJLyogZHJp dmUgIyAqLw0KKwl9IGVlaF9kYXRhOw0KKw0KIAlzdHJ1Y3QgbWRrX3RocmVhZF9zCQkqc3luY190 aHJlYWQ7CS8qIGRvaW5nIHJlc3luYyBvciByZWNvbnN0cnVjdCAqLw0KIAlzZWN0b3JfdAkJCWN1 cnJfcmVzeW5jOwkvKiBibG9ja3Mgc2NoZWR1bGVkICovDQogCXVuc2lnbmVkIGxvbmcJCQlyZXN5 bmNfbWFyazsJLyogYSByZWNlbnQgdGltZXN0YW1wICovDQotLS0gbGludXgvaW5jbHVkZS9saW51 eC9yYWlkL3JhaWQ1Lmgub3JpZwkyMDA1LTExLTA4IDE4OjI2OjQ4LjAwMDAwMDAwMCArMDEwMA0K KysrIGxpbnV4L2luY2x1ZGUvbGludXgvcmFpZC9yYWlkNS5oCTIwMDUtMTEtMDkgMjI6Mjc6NTgu MDAwMDAwMDAwICswMTAwDQpAQCAtMTU2LDYgKzE1Niw3IEBADQogI2RlZmluZQlSNV9PdmVybGFw CTcJLyogVGhlcmUgaXMgYSBwZW5kaW5nIG92ZXJsYXBwaW5nIHJlcXVlc3Qgb24gdGhpcyBibG9j ayAqLw0KICNkZWZpbmUJUjVfUmVhZEVycm9yCTgJLyogc2VlbiBhIHJlYWQgZXJyb3IgaGVyZSBy ZWNlbnRseSAqLw0KICNkZWZpbmUJUjVfUmVXcml0ZQk5CS8qIGhhdmUgdHJpZWQgdG8gb3Zlci13 cml0ZSB0aGUgcmVhZGVycm9yICovDQorI2RlZmluZQlSNV9IYXJkUmVhZEVycgkxMAkvKiByZXdy aXRlIGZhaWxlZCwgcHV0IGludG8gYmFkYmxvY2tzIGxpc3QgKi8NCiANCiAvKg0KICAqIFdyaXRl IG1ldGhvZA0KQEAgLTIwMCw4ICsyMDEsMTYgQEANCiAgKi8NCiAgDQogDQorc3RydWN0IGJhZGJs b2NrIHsNCisJc3RydWN0IGJhZGJsb2NrCQkqaGFzaF9uZXh0LCAqKmhhc2hfcHByZXY7IC8qIGhh c2ggcG9pbnRlcnMgKi8NCisJc2VjdG9yX3QJCXNlY3RvcjsgLyogc3RyaXBlICMgKi8NCit9Ow0K Kw0KIHN0cnVjdCBkaXNrX2luZm8gew0KIAltZGtfcmRldl90CSpyZGV2Ow0KKwlzdHJ1Y3QgYmFk YmxvY2sgKipiYWRibG9ja19oYXNodGJsOyAvKiBsaXN0IG9mIGtub3duIGJhZGJsb2NrcyAqLw0K KwljaGFyCQljYWNoZV9uYW1lWzIwXTsNCisJa21lbV9jYWNoZV90CSpzbGFiX2NhY2hlOyAvKiBi YWRibG9jayBkYiAqLw0KIH07DQogDQogc3RydWN0IHJhaWQ1X3ByaXZhdGVfZGF0YSB7DQpAQCAt MjM4LDYgKzI0Nyw4IEBADQogCWludAkJCWluYWN0aXZlX2Jsb2NrZWQ7CS8qIHJlbGVhc2Ugb2Yg aW5hY3RpdmUgc3RyaXBlcyBibG9ja2VkLA0KIAkJCQkJCQkgKiB3YWl0aW5nIGZvciAyNSUgdG8g YmUgZnJlZQ0KIAkJCQkJCQkgKi8gICAgICAgIA0KKwlpbnQJCQltaXJyb3JpdDsgLyogc291cmNl IGZvciBhY3RpdmUgc3BhcmUgcmVzeW5jICovDQorDQogCXNwaW5sb2NrX3QJCWRldmljZV9sb2Nr Ow0KIAlzdHJ1Y3QgZGlza19pbmZvCWRpc2tzWzBdOw0KIH07DQotLS0gbGludXgvZHJpdmVycy9t ZC9tZC5jLm9yaWcJMjAwNS0xMC0yOCAwMjowMjowOC4wMDAwMDAwMDAgKzAyMDANCisrKyBsaW51 eC9kcml2ZXJzL21kL21kLmMJMjAwNS0xMS0wOSAyMDoxODozOS4wMDAwMDAwMDAgKzAxMDANCkBA IC04NSw2ICs4NSwxMCBAQA0KIHN0YXRpYyBpbnQgc3lzY3RsX3NwZWVkX2xpbWl0X21pbiA9IDEw MDA7DQogc3RhdGljIGludCBzeXNjdGxfc3BlZWRfbGltaXRfbWF4ID0gMjAwMDAwOw0KIA0KKy8q IHRoZSBkcml2ZSdsbCBiZSBtYXJrZWQgZmFpbGVkIG92ZXIgdGhpcyB0aHJlc2hvbGQuIG1lYXN1 cmUgaXMgYmxvY2suICovDQoraW50IHN5c2N0bF9iYWRibG9ja190b2xlcmFuY2UgPSAxMDAwMDsN CisNCisNCiBzdGF0aWMgc3RydWN0IGN0bF90YWJsZV9oZWFkZXIgKnJhaWRfdGFibGVfaGVhZGVy Ow0KIA0KIHN0YXRpYyBjdGxfdGFibGUgcmFpZF90YWJsZVtdID0gew0KQEAgLTEwNCw2ICsxMDgs MTQgQEANCiAJCS5tb2RlCQk9IDA2NDQsDQogCQkucHJvY19oYW5kbGVyCT0gJnByb2NfZG9pbnR2 ZWMsDQogCX0sDQorCXsNCisJCS5jdGxfbmFtZQk9IERFVl9SQUlEX0JBREJMT0NLX1RPTEVSQU5D RSwNCisJCS5wcm9jbmFtZQk9ICJiYWRibG9ja190b2xlcmFuY2UiLA0KKwkJLmRhdGEJCT0gJnN5 c2N0bF9iYWRibG9ja190b2xlcmFuY2UsDQorCQkubWF4bGVuCQk9IHNpemVvZihpbnQpLA0KKwkJ Lm1vZGUJCT0gMDY0NCwNCisJCS5wcm9jX2hhbmRsZXIJPSAmcHJvY19kb2ludHZlYywNCisJfSwN CiAJeyAuY3RsX25hbWUgPSAwIH0NCiB9Ow0KIA0KQEAgLTQwOTcsNiArNDEwOSw4IEBADQogRVhQ T1JUX1NZTUJPTChtZF93YWtldXBfdGhyZWFkKTsNCiBFWFBPUlRfU1lNQk9MKG1kX3ByaW50X2Rl dmljZXMpOw0KIEVYUE9SVF9TWU1CT0wobWRfY2hlY2tfcmVjb3ZlcnkpOw0KK0VYUE9SVF9TWU1C T0woa2lja19yZGV2X2Zyb21fYXJyYXkpOwkvLyBmaXhtZQ0KK0VYUE9SVF9TWU1CT0woc3lzY3Rs X2JhZGJsb2NrX3RvbGVyYW5jZSk7DQogTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOw0KIE1PRFVMRV9B TElBUygibWQiKTsNCiBNT0RVTEVfQUxJQVNfQkxPQ0tERVZfTUFKT1IoTURfTUFKT1IpOw0KLS0t IGxpbnV4L2RyaXZlcnMvbWQvcmFpZDUuYy5vcmlnCTIwMDUtMTEtMDggMTg6MjY6NDguMDAwMDAw MDAwICswMTAwDQorKysgbGludXgvZHJpdmVycy9tZC9yYWlkNS5jCTIwMDUtMTEtMTAgMDI6MzI6 NTIuMDAwMDAwMDAwICswMTAwDQpAQCAtNDIsNiArNDIsMTggQEANCiANCiAjZGVmaW5lIHN0cmlw ZV9oYXNoKGNvbmYsIHNlY3QpCSgoY29uZiktPnN0cmlwZV9oYXNodGJsWygoc2VjdCkgPj4gU1RS SVBFX1NISUZUKSAmIEhBU0hfTUFTS10pDQogDQorIC8qDQorICogcGVyLWRldmljZSBiYWRibG9j ayBjYWNoZQ0KKyAqLw0KKw0KKyNkZWZpbmUJQkJfU0hJRlQJCShQQUdFX1NISUZULyoxMiovIC0g OSkNCisjZGVmaW5lCUJCX0hBU0hfUEFHRVMJCTENCisjZGVmaW5lCUJCX05SX0hBU0gJCShIQVNI X1BBR0VTICogUEFHRV9TSVpFIC8gc2l6ZW9mKHN0cnVjdCBiYWRibG9jayAqKSkNCisjZGVmaW5l CUJCX0hBU0hfTUFTSwkJKEJCX05SX0hBU0ggLSAxKQ0KKw0KKyNkZWZpbmUJYmJfaGFzaChkaXNr LCBzZWN0KQkoKGRpc2spLT5iYWRibG9ja19oYXNodGJsWygoc2VjdCkgPj4gQkJfU0hJRlQpICYg QkJfSEFTSF9NQVNLXSkNCisjZGVmaW5lCWJiX2hhc2hucihzZWN0KQkJKCgoc2VjdCkgPj4gQkJf U0hJRlQpICYgQkJfSEFTSF9NQVNLKQ0KKw0KIC8qIGJpbydzIGF0dGFjaGVkIHRvIGEgc3RyaXBl K2RldmljZSBmb3IgSS9PIGFyZSBsaW5rZWQgdG9nZXRoZXIgaW4gYmlfc2VjdG9yDQogICogb3Jk ZXIgd2l0aG91dCBvdmVybGFwLiAgVGhlcmUgbWF5IGJlIHNldmVyYWwgYmlvJ3MgcGVyIHN0cmlw ZStkZXZpY2UsIGFuZA0KICAqIGEgYmlvIGNvdWxkIHNwYW4gc2V2ZXJhbCBkZXZpY2VzLg0KQEAg LTU1LDcgKzY3LDcgQEANCiAvKg0KICAqIFRoZSBmb2xsb3dpbmcgY2FuIGJlIHVzZWQgdG8gZGVi dWcgdGhlIGRyaXZlcg0KICAqLw0KLSNkZWZpbmUgUkFJRDVfREVCVUcJMA0KKyNkZWZpbmUgUkFJ RDVfREVCVUcJMQ0KICNkZWZpbmUgUkFJRDVfUEFSQU5PSUEJMQ0KICNpZiBSQUlENV9QQVJBTk9J QSAmJiBkZWZpbmVkKENPTkZJR19TTVApDQogIyBkZWZpbmUgQ0hFQ0tfREVWTE9DSygpIGFzc2Vy dF9zcGluX2xvY2tlZCgmY29uZi0+ZGV2aWNlX2xvY2spDQpAQCAtNjMsMTMgKzc1LDE2MiBAQA0K ICMgZGVmaW5lIENIRUNLX0RFVkxPQ0soKQ0KICNlbmRpZg0KIA0KLSNkZWZpbmUgUFJJTlRLKHgu Li4pICgodm9pZCkoUkFJRDVfREVCVUcgJiYgcHJpbnRrKHgpKSkNCisvKiB1c2UgRXh0ZXJuYWwg RXJyb3IgSGFuZGxlcj8gKi8NCisjZGVmaW5lCVVTRVJFSAkJMQ0KKw0KKyNkZWZpbmUgUFJJTlRL KHguLi4pICgodm9pZCkoUkFJRDVfREVCVUcgJiYgcHJpbnRrKEtFUk5fREVCVUcgeCkpKQ0KICNp ZiBSQUlENV9ERUJVRw0KICNkZWZpbmUgaW5saW5lDQogI2RlZmluZSBfX2lubGluZV9fDQogI2Vu ZGlmDQogDQogc3RhdGljIHZvaWQgcHJpbnRfcmFpZDVfY29uZiAocmFpZDVfY29uZl90ICpjb25m KTsNCitleHRlcm4gaW50IHN5c2N0bF9iYWRibG9ja190b2xlcmFuY2U7DQorDQorDQorc3RhdGlj IHZvaWQgYmJfaW5zZXJ0X2hhc2goc3RydWN0IGRpc2tfaW5mbyAqZGlzaywgc3RydWN0IGJhZGJs b2NrICpiYikNCit7DQorCXN0cnVjdCBiYWRibG9jayAqKmJicCA9ICZiYl9oYXNoKGRpc2ssIGJi LT5zZWN0b3IpOw0KKw0KKwkvKnByaW50aygiYmJfaW5zZXJ0X2hhc2goKSwgc2VjdG9yICVsbHUg aGFzaG5yICVsdVxuIiwgKHVuc2lnbmVkIGxvbmcgbG9uZyliYi0+c2VjdG9yLA0KKwkJYmJfaGFz aG5yKGJiLT5zZWN0b3IpKTsqLw0KKw0KKwlpZiAoKGJiLT5oYXNoX25leHQgPSAqYmJwKSAhPSBO VUxMKQ0KKwkJKCpiYnApLT5oYXNoX3BwcmV2ID0gJmJiLT5oYXNoX25leHQ7DQorCSpiYnAgPSBi YjsJDQorCWJiLT5oYXNoX3BwcmV2ID0gYmJwOw0KK30NCisNCitzdGF0aWMgdm9pZCBiYl9yZW1v dmVfaGFzaChzdHJ1Y3QgYmFkYmxvY2sgKmJiKQ0KK3sNCisJLypwcmludGsoInJlbW92ZV9oYXNo KCksIHNlY3RvciAlbGx1IGhhc2huciAlbHVcbiIsICh1bnNpZ25lZCBsb25nIGxvbmcpYmItPnNl Y3RvciwNCisJCWJiX2hhc2hucihiYi0+c2VjdG9yKSk7Ki8NCisNCisJaWYgKGJiLT5oYXNoX3Bw cmV2KSB7DQorCQlpZiAoYmItPmhhc2hfbmV4dCkNCisJCQliYi0+aGFzaF9uZXh0LT5oYXNoX3Bw cmV2ID0gYmItPmhhc2hfcHByZXY7DQorCQkqYmItPmhhc2hfcHByZXYgPSBiYi0+aGFzaF9uZXh0 Ow0KKwkJYmItPmhhc2hfcHByZXYgPSBOVUxMOw0KKwl9DQorfQ0KKw0KK3N0YXRpYyBzdHJ1Y3Qg YmFkYmxvY2sgKl9fZmluZF9iYWRibG9jayhzdHJ1Y3QgZGlza19pbmZvICpkaXNrLCBzZWN0b3Jf dCBzZWN0b3IpDQorew0KKwlzdHJ1Y3QgYmFkYmxvY2sgKmJiOw0KKw0KKwlmb3IgKGJiID0gYmJf aGFzaChkaXNrLCBzZWN0b3IpOyBiYjsgYmIgPSBiYi0+aGFzaF9uZXh0KQ0KKwkJaWYgKGJiLT5z ZWN0b3IgPT0gc2VjdG9yKQ0KKwkJCXJldHVybiBiYjsNCisJcmV0dXJuIE5VTEw7DQorfQ0KKw0K K3N0YXRpYyBzdHJ1Y3QgYmFkYmxvY2sgKmZpbmRfYmFkYmxvY2soc3RydWN0IGRpc2tfaW5mbyAq ZGlzaywgc2VjdG9yX3Qgc2VjdG9yKQ0KK3sNCisJcmFpZDVfY29uZl90ICpjb25mID0gKHJhaWQ1 X2NvbmZfdCAqKSBkaXNrLT5yZGV2LT5tZGRldi0+cHJpdmF0ZTsNCisJc3RydWN0IGJhZGJsb2Nr ICpiYjsNCisNCisJc3Bpbl9sb2NrX2lycSgmY29uZi0+ZGV2aWNlX2xvY2spOw0KKwliYiA9IF9f ZmluZF9iYWRibG9jayhkaXNrLCBzZWN0b3IpOw0KKwlzcGluX3VubG9ja19pcnEoJmNvbmYtPmRl dmljZV9sb2NrKTsNCisJcmV0dXJuIGJiOw0KK30NCisNCitzdGF0aWMgdW5zaWduZWQgbG9uZyBj b3VudF9iYWRibG9ja3MgKHN0cnVjdCBkaXNrX2luZm8gKmRpc2spDQorew0KKwlyYWlkNV9jb25m X3QgKmNvbmYgPSAocmFpZDVfY29uZl90ICopIGRpc2stPnJkZXYtPm1kZGV2LT5wcml2YXRlOw0K KwlzdHJ1Y3QgYmFkYmxvY2sgKmJiOw0KKwlpbnQgajsNCisJaW50IG4gPSAwOw0KKw0KKwlzcGlu X2xvY2tfaXJxKCZjb25mLT5kZXZpY2VfbG9jayk7DQorCWZvciAoaiA9IDA7IGogPCBCQl9OUl9I QVNIOyBqKyspIHsNCisJCWJiID0gZGlzay0+YmFkYmxvY2tfaGFzaHRibFtqXTsNCisJCWZvciAo OyBiYjsgYmIgPSBiYi0+aGFzaF9uZXh0KQ0KKwkJCW4rKzsNCisJfQ0KKwlzcGluX3VubG9ja19p cnEoJmNvbmYtPmRldmljZV9sb2NrKTsNCisNCisJcmV0dXJuIG47DQorfQ0KKw0KK3N0YXRpYyBp bnQgZ3Jvd19iYWRibG9ja3Moc3RydWN0IGRpc2tfaW5mbyAqZGlzaykNCit7DQorCWNoYXIgYltC REVWTkFNRV9TSVpFXTsNCisJa21lbV9jYWNoZV90ICpzYzsNCisNCisJLyogaGFzaCB0YWJsZSAq Lw0KKwlpZiAoKGRpc2stPmJhZGJsb2NrX2hhc2h0YmwgPSAoc3RydWN0IGJhZGJsb2NrICoqKSBf X2dldF9mcmVlX3BhZ2VzKEdGUF9BVE9NSUMsIEhBU0hfUEFHRVNfT1JERVIpKSA9PSBOVUxMKSB7 DQorCSAgICBwcmludGsoImdyb3dfYmFkYmxvY2tzOiBfX2dldF9mcmVlX3BhZ2VzIGZhaWxlZFxu Iik7DQorCSAgICByZXR1cm4gMDsNCisJfQ0KKwltZW1zZXQoZGlzay0+YmFkYmxvY2tfaGFzaHRi bCwgMCwgQkJfSEFTSF9QQUdFUyAqIFBBR0VfU0laRSk7DQorDQorCS8qIGJhZGJsb2NrcyBkYiAq Lw0KKwlzcHJpbnRmKGRpc2stPmNhY2hlX25hbWUsICJyYWlkNS8lc18lc19iYmMiLCBtZG5hbWUo ZGlzay0+cmRldi0+bWRkZXYpLA0KKwkJCWJkZXZuYW1lKGRpc2stPnJkZXYtPmJkZXYsIGIpKTsN CisJc2MgPSBrbWVtX2NhY2hlX2NyZWF0ZShkaXNrLT5jYWNoZV9uYW1lLA0KKwkJCSAgICAgICBz aXplb2Yoc3RydWN0IGJhZGJsb2NrKSwNCisJCQkgICAgICAgMCwgMCwgTlVMTCwgTlVMTCk7DQor CWlmICghc2MpIHsNCisJCXByaW50aygiZ3Jvd19iYWRibG9ja3M6IGttZW1fY2FjaGVfY3JlYXRl IGZhaWxlZFxuIik7DQorCQlyZXR1cm4gMTsNCisJfQ0KKwlkaXNrLT5zbGFiX2NhY2hlID0gc2M7 DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgdm9pZCBzaHJpbmtfYmFkYmxvY2tzKHN0 cnVjdCBkaXNrX2luZm8gKmRpc2spDQorew0KKwlzdHJ1Y3QgYmFkYmxvY2sgKmJiOw0KKwlpbnQg ajsNCisNCisJLyogYmFkYmxvY2tzIGRiICovDQorCWZvciAoaiA9IDA7IGogPCBCQl9OUl9IQVNI OyBqKyspIHsNCisJCWJiID0gZGlzay0+YmFkYmxvY2tfaGFzaHRibFtqXTsNCisJCWZvciAoOyBi YjsgYmIgPSBiYi0+aGFzaF9uZXh0KQ0KKwkJICAgICAgICBrbWVtX2NhY2hlX2ZyZWUoZGlzay0+ c2xhYl9jYWNoZSwgYmIpOw0KKwl9DQorCWttZW1fY2FjaGVfZGVzdHJveShkaXNrLT5zbGFiX2Nh Y2hlKTsNCisJZGlzay0+c2xhYl9jYWNoZSA9IE5VTEw7DQorDQorCS8qIGhhc2ggdGFibGUgKi8N CisJZnJlZV9wYWdlcygodW5zaWduZWQgbG9uZykgZGlzay0+YmFkYmxvY2tfaGFzaHRibCwgSEFT SF9QQUdFU19PUkRFUik7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIHN0b3JlX2JhZGJsb2NrKHN0cnVj dCBkaXNrX2luZm8gKmRpc2ssIHNlY3Rvcl90IHNlY3RvcikNCit7DQorCXN0cnVjdCBiYWRibG9j ayAqYmI7DQorCXJhaWQ1X2NvbmZfdCAqY29uZiA9IChyYWlkNV9jb25mX3QgKikgZGlzay0+cmRl di0+bWRkZXYtPnByaXZhdGU7DQorDQorCWJiID0ga21lbV9jYWNoZV9hbGxvYyhkaXNrLT5zbGFi X2NhY2hlLCBHRlBfS0VSTkVMKTsNCisJaWYgKCFiYikgew0KKwkJcHJpbnRrKCJzdG9yZV9iYWRi bG9jazoga21lbV9jYWNoZV9hbGxvYyBmYWlsZWRcbiIpOw0KKwkJcmV0dXJuOw0KKwl9DQorCW1l bXNldChiYiwgMCwgc2l6ZW9mKCpiYikpOw0KKwliYi0+c2VjdG9yID0gc2VjdG9yOw0KKw0KKwlz cGluX2xvY2tfaXJxKCZjb25mLT5kZXZpY2VfbG9jayk7DQorCWJiX2luc2VydF9oYXNoKGRpc2ss IGJiKTsNCisJc3Bpbl91bmxvY2tfaXJxKCZjb25mLT5kZXZpY2VfbG9jayk7DQorfQ0KKw0KK3N0 YXRpYyB2b2lkIGRlbGV0ZV9iYWRibG9jayhzdHJ1Y3QgZGlza19pbmZvICpkaXNrLCBzZWN0b3Jf dCBzZWN0b3IpDQorew0KKwlzdHJ1Y3QgYmFkYmxvY2sgKmJiOw0KKwlyYWlkNV9jb25mX3QgKmNv bmYgPSAocmFpZDVfY29uZl90ICopIGRpc2stPnJkZXYtPm1kZGV2LT5wcml2YXRlOw0KKw0KKwli YiA9IGZpbmRfYmFkYmxvY2soZGlzaywgc2VjdG9yKTsNCisJaWYgKCFiYikNCisJCS8qIHJlc2V0 IG9uIHdyaXRlJ2xsIGNhbGwgdXMgbGlrZSBhbiBpZGlvdCA6fSAqLw0KKwkJcmV0dXJuOw0KKwlz cGluX2xvY2tfaXJxKCZjb25mLT5kZXZpY2VfbG9jayk7DQorCWJiX3JlbW92ZV9oYXNoKGJiKTsN CisJa21lbV9jYWNoZV9mcmVlKGRpc2stPnNsYWJfY2FjaGUsIGJiKTsNCisJc3Bpbl91bmxvY2tf aXJxKCZjb25mLT5kZXZpY2VfbG9jayk7DQorfQ0KKw0KIA0KIHN0YXRpYyBpbmxpbmUgdm9pZCBf X3JlbGVhc2Vfc3RyaXBlKHJhaWQ1X2NvbmZfdCAqY29uZiwgc3RydWN0IHN0cmlwZV9oZWFkICpz aCkNCiB7DQpAQCAtMjA4LDcgKzM2OSw3IEBADQogCXNoLT5wZF9pZHggPSBwZF9pZHg7DQogCXNo LT5zdGF0ZSA9IDA7DQogDQotCWZvciAoaT1kaXNrczsgaS0tOyApIHsNCisJZm9yIChpPWRpc2tz KzE7IGktLTsgKSB7DQogCQlzdHJ1Y3QgcjVkZXYgKmRldiA9ICZzaC0+ZGV2W2ldOw0KIA0KIAkJ aWYgKGRldi0+dG9yZWFkIHx8IGRldi0+dG93cml0ZSB8fCBkZXYtPndyaXR0ZW4gfHwNCkBAIC0z MDEsOCArNDYyLDEwIEBADQogDQogCXNwcmludGYoY29uZi0+Y2FjaGVfbmFtZSwgInJhaWQ1LyVz IiwgbWRuYW1lKGNvbmYtPm1kZGV2KSk7DQogDQorCS8qICsxOiB3ZSBuZWVkIGV4dHJhIHNwYWNl IGluIHRoZSAqc2gtPmRldnMgZm9yIHRoZSAnYWN0aXZlIHNwYXJlJyB0byBrZWVwDQorCSAgICBo YW5kbGVfc3RyaXBlKCkgc2ltcGxlICovDQogCXNjID0ga21lbV9jYWNoZV9jcmVhdGUoY29uZi0+ Y2FjaGVfbmFtZSwgDQotCQkJICAgICAgIHNpemVvZihzdHJ1Y3Qgc3RyaXBlX2hlYWQpKyhkZXZz LTEpKnNpemVvZihzdHJ1Y3QgcjVkZXYpLA0KKwkJCSAgICAgICBzaXplb2Yoc3RydWN0IHN0cmlw ZV9oZWFkKSsoZGV2cy0xKzEpKnNpemVvZihzdHJ1Y3QgcjVkZXYpLA0KIAkJCSAgICAgICAwLCAw LCBOVUxMLCBOVUxMKTsNCiAJaWYgKCFzYykNCiAJCXJldHVybiAxOw0KQEAgLTMxMSwxMiArNDc0 LDEyIEBADQogCQlzaCA9IGttZW1fY2FjaGVfYWxsb2Moc2MsIEdGUF9LRVJORUwpOw0KIAkJaWYg KCFzaCkNCiAJCQlyZXR1cm4gMTsNCi0JCW1lbXNldChzaCwgMCwgc2l6ZW9mKCpzaCkgKyAoZGV2 cy0xKSpzaXplb2Yoc3RydWN0IHI1ZGV2KSk7DQorCQltZW1zZXQoc2gsIDAsIHNpemVvZigqc2gp ICsgKGRldnMtMSsxKSpzaXplb2Yoc3RydWN0IHI1ZGV2KSk7DQogCQlzaC0+cmFpZF9jb25mID0g Y29uZjsNCiAJCXNwaW5fbG9ja19pbml0KCZzaC0+bG9jayk7DQogDQotCQlpZiAoZ3Jvd19idWZm ZXJzKHNoLCBjb25mLT5yYWlkX2Rpc2tzKSkgew0KLQkJCXNocmlua19idWZmZXJzKHNoLCBjb25m LT5yYWlkX2Rpc2tzKTsNCisJCWlmIChncm93X2J1ZmZlcnMoc2gsIGNvbmYtPnJhaWRfZGlza3Mr MSkpIHsNCisJCQlzaHJpbmtfYnVmZmVycyhzaCwgY29uZi0+cmFpZF9kaXNrcysxKTsNCiAJCQlr bWVtX2NhY2hlX2ZyZWUoc2MsIHNoKTsNCiAJCQlyZXR1cm4gMTsNCiAJCX0NCkBAIC00MDgsMTgg KzU3MSw0MCBAQA0KIAkJCWNsZWFyX2JpdChSNV9SZVdyaXRlLCAmc2gtPmRldltpXS5mbGFncyk7 DQogCQl9DQogCX0gZWxzZSB7DQorCQlpbnQga2VlcG9uID0gMDsNCisNCiAJCWNsZWFyX2JpdChS NV9VUFRPREFURSwgJnNoLT5kZXZbaV0uZmxhZ3MpOw0KKwkgICAgICAgIC8qDQorCQkgICAgcnVs ZSAxLiw6IHRyeSB0byBrZWVwIGFsbCBkaXNrIGluX3N5bmMgZXZlbiBpZiB3ZSd2ZSBnb3QNCisJ CSAgICB1bmZpeGFibGUgcmVhZCBlcnJvcnMsIGNhdXNlIHRoZSAnYWN0aXZlIHNwYXJlJyBtYXkg Y2FuDQorCQkgICAgcmVidWlsZCBhIGNvbXBsZXRlIGNvbHVtbiBmcm9tIHBhcnRpYWxseSBmYWls ZWQgZHJpdmVzDQorCSAgICAgICAgKi8NCisJCWlmIChjb25mLT5kaXNrc1tpXS5yZGV2LT5pbl9z eW5jKSB7DQorCQkgICAgY2hhciBiW0JERVZOQU1FX1NJWkVdOw0KKwkJICAgIHByaW50ayhLRVJO X0FMRVJUDQorCQkJICAgICJyYWlkNV9lbmRfcmVhZF9yZXF1ZXN0OiBSZWFkIGZhaWx1cmUgJXMg b24gc2VjdG9yICVsbHUgKCVkKSBpbiAlcyBtb2RlXG4iLA0KKwkJCSAgICBiZGV2bmFtZShjb25m LT5kaXNrc1tpXS5yZGV2LT5iZGV2LCBiKSwNCisJCQkgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylz aC0+c2VjdG9yLCBhdG9taWNfcmVhZCgmc2gtPmNvdW50KSwNCisJCQkgICAgY29uZi0+d29ya2lu Z19kaXNrcyA+PSBjb25mLT5yYWlkX2Rpc2tzID8gIm9wdGltYWwiIDogImRlZ3JhZGVkIik7DQor CQkgICAga2VlcG9uKys7DQorCQl9DQogCQlpZiAoY29uZi0+bWRkZXYtPmRlZ3JhZGVkKSB7DQog CQkJcHJpbnRrKCJSNTogcmVhZCBlcnJvciBub3QgY29ycmVjdGFibGUuXG4iKTsNCiAJCQljbGVh cl9iaXQoUjVfUmVhZEVycm9yLCAmc2gtPmRldltpXS5mbGFncyk7DQogCQkJY2xlYXJfYml0KFI1 X1JlV3JpdGUsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCi0JCQltZF9lcnJvcihjb25mLT5tZGRldiwg Y29uZi0+ZGlza3NbaV0ucmRldik7DQorCQkJaWYgKCFrZWVwb24pDQorCQkJICAgIG1kX2Vycm9y KGNvbmYtPm1kZGV2LCBjb25mLT5kaXNrc1tpXS5yZGV2KTsNCisJCQllbHNlDQorCQkJICAgIHNl dF9iaXQoUjVfSGFyZFJlYWRFcnIsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCiAJCX0gZWxzZSBpZiAo dGVzdF9iaXQoUjVfUmVXcml0ZSwgJnNoLT5kZXZbaV0uZmxhZ3MpKSB7DQogCQkJLyogT2gsIG5v ISEhICovDQogCQkJcHJpbnRrKCJSNTogcmVhZCBlcnJvciBOT1QgY29ycmVjdGVkISFcbiIpOw0K IAkJCWNsZWFyX2JpdChSNV9SZWFkRXJyb3IsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCiAJCQljbGVh cl9iaXQoUjVfUmVXcml0ZSwgJnNoLT5kZXZbaV0uZmxhZ3MpOw0KLQkJCW1kX2Vycm9yKGNvbmYt Pm1kZGV2LCBjb25mLT5kaXNrc1tpXS5yZGV2KTsNCisJCQlpZiAoIWtlZXBvbikNCisJCQkgICAg bWRfZXJyb3IoY29uZi0+bWRkZXYsIGNvbmYtPmRpc2tzW2ldLnJkZXYpOw0KKwkJCWVsc2UNCisJ CQkgICAgc2V0X2JpdChSNV9IYXJkUmVhZEVyciwgJnNoLT5kZXZbaV0uZmxhZ3MpOw0KIAkJfSBl bHNlDQogCQkJc2V0X2JpdChSNV9SZWFkRXJyb3IsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCiAJfQ0K QEAgLTQ1NywxMyArNjQyLDE4IEBADQogCVBSSU5USygiZW5kX3dyaXRlX3JlcXVlc3QgJWxsdS8l ZCwgY291bnQgJWQsIHVwdG9kYXRlOiAlZC5cbiIsIA0KIAkJKHVuc2lnbmVkIGxvbmcgbG9uZylz aC0+c2VjdG9yLCBpLCBhdG9taWNfcmVhZCgmc2gtPmNvdW50KSwNCiAJCXVwdG9kYXRlKTsNCisJ Lyogc29ycnkNCiAJaWYgKGkgPT0gZGlza3MpIHsNCiAJCUJVRygpOw0KIAkJcmV0dXJuIDA7DQot CX0NCisJfSovDQogDQogCXNwaW5fbG9ja19pcnFzYXZlKCZjb25mLT5kZXZpY2VfbG9jaywgZmxh Z3MpOw0KIAlpZiAoIXVwdG9kYXRlKQ0KKwkJLyogIHdlIG11c3QgZmFpbCB0aGlzIGRyaXZlLCBj YXVzZSByaXNrcyB0aGUgaW50ZWdyaXR5IG9mIGRhdGENCisJCSAgICBpZiB0aGlzIHNlY3RvciBp cyByZWFkYWJsZS4gbGF0ZXIsIHdlIGNvdWxkIGNoZWNrDQorCQkgICAgaXMgaXQgdGhpcyByZWFk YWJsZSwgaWYgbm90LCB0aGVuIHdlIGNhbiBoYW5kbGUgaXQgYXMgYQ0KKwkJICAgIGNvbW1vbiBi YWRibG9jay4gKi8NCiAJCW1kX2Vycm9yKGNvbmYtPm1kZGV2LCBjb25mLT5kaXNrc1tpXS5yZGV2 KTsNCiANCiAJcmRldl9kZWNfcGVuZGluZyhjb25mLT5kaXNrc1tpXS5yZGV2LCBjb25mLT5tZGRl dik7DQpAQCAtNDk0LDMzICs2ODQsMTU0IEBADQogCWRldi0+cmVxLmJpX3ByaXZhdGUgPSBzaDsN CiANCiAJZGV2LT5mbGFncyA9IDA7DQotCWlmIChpICE9IHNoLT5wZF9pZHgpDQorCWlmIChpICE9 IHNoLT5wZF9pZHggJiYgaSA8IHNoLT5yYWlkX2NvbmYtPnJhaWRfZGlza3MpCS8qIGFjdGl2ZSBz cGFyZT8gKi8NCiAJCWRldi0+c2VjdG9yID0gY29tcHV0ZV9ibG9ja25yKHNoLCBpKTsNCiB9DQog DQorc3RhdGljIGludCByYWlkNV9yZW1vdmVfZGlzayhtZGRldl90ICptZGRldiwgaW50IG51bWJl cik7DQorc3RhdGljIGludCByYWlkNV9hZGRfZGlzayhtZGRldl90ICptZGRldiwgbWRrX3JkZXZf dCAqcmRldik7DQorLypzdGF0aWMqLyB2b2lkIGtpY2tfcmRldl9mcm9tX2FycmF5KG1ka19yZGV2 X3QgKiByZGV2KTsNCiBzdGF0aWMgdm9pZCBlcnJvcihtZGRldl90ICptZGRldiwgbWRrX3JkZXZf dCAqcmRldikNCiB7DQogCWNoYXIgYltCREVWTkFNRV9TSVpFXTsNCisJY2hhciBiMltCREVWTkFN RV9TSVpFXTsNCiAJcmFpZDVfY29uZl90ICpjb25mID0gKHJhaWQ1X2NvbmZfdCAqKSBtZGRldi0+ cHJpdmF0ZTsNCiAJUFJJTlRLKCJyYWlkNTogZXJyb3IgY2FsbGVkXG4iKTsNCiANCiAJaWYgKCFy ZGV2LT5mYXVsdHkpIHsNCi0JCW1kZGV2LT5zYl9kaXJ0eSA9IDE7DQotCQlpZiAocmRldi0+aW5f c3luYykgew0KLQkJCWNvbmYtPndvcmtpbmdfZGlza3MtLTsNCi0JCQltZGRldi0+ZGVncmFkZWQr KzsNCi0JCQljb25mLT5mYWlsZWRfZGlza3MrKzsNCi0JCQlyZGV2LT5pbl9zeW5jID0gMDsNCi0J CQkvKg0KLQkJCSAqIGlmIHJlY292ZXJ5IHdhcyBydW5uaW5nLCBtYWtlIHN1cmUgaXQgYWJvcnRz Lg0KLQkJCSAqLw0KLQkJCXNldF9iaXQoTURfUkVDT1ZFUllfRVJSLCAmbWRkZXYtPnJlY292ZXJ5 KTsNCi0JCX0NCi0JCXJkZXYtPmZhdWx0eSA9IDE7DQotCQlwcmludGsgKEtFUk5fQUxFUlQNCi0J CQkicmFpZDU6IERpc2sgZmFpbHVyZSBvbiAlcywgZGlzYWJsaW5nIGRldmljZS4iDQotCQkJIiBP cGVyYXRpb24gY29udGludWluZyBvbiAlZCBkZXZpY2VzXG4iLA0KLQkJCWJkZXZuYW1lKHJkZXYt PmJkZXYsYiksIGNvbmYtPndvcmtpbmdfZGlza3MpOw0KKwkJaW50IG1kZGlza3MgPSAwOw0KKwkJ bWRrX3JkZXZfdCAqcmQ7DQorCQltZGtfcmRldl90ICpyZGV2cyA9IE5VTEw7DQorCQlzdHJ1Y3Qg bGlzdF9oZWFkICpydG1wOw0KKwkJaW50IGk7DQorDQorCQlJVEVSQVRFX1JERVYobWRkZXYscmQs cnRtcCkNCisJCSAgICB7DQorCQkJcHJpbnRrKCJtZGRldiVkOiAlc1xuIiwgbWRkaXNrcywgYmRl dm5hbWUocmQtPmJkZXYsYikpOw0KKwkJCW1kZGlza3MrKzsNCisJCSAgICB9DQorCQlmb3IgKGkg PSAwOyBpIDwgbWRkaXNrcyAmJiAocmQgPSBjb25mLT5kaXNrc1tpXS5yZGV2KTsgaSsrKSB7DQor CQkJcHJpbnRrKCJyNWRldiVkOiAlc1xuIiwgaSwgYmRldm5hbWUocmQtPmJkZXYsYikpOw0KKwkJ fQ0KKwkJSVRFUkFURV9SREVWKG1kZGV2LHJkLHJ0bXApDQorCQkgICAgew0KKwkJCXJkZXZzID0g cmQ7DQorCQkJYnJlYWs7DQorCQkgICAgfQ0KK3ByaW50aygiSUkgJWQgJWQgPiAlZCAlZCBpbnM6 JWQgJXBcbiIsDQorCW1kZGV2LT5yYWlkX2Rpc2tzLCBtZGRpc2tzLCBjb25mLT5yYWlkX2Rpc2tz LCBtZGRldi0+ZGVncmFkZWQsIHJkZXYtPmluX3N5bmMsIHJkZXZzKTsNCisJCWlmIChjb25mLT5k aXNrc1tjb25mLT5yYWlkX2Rpc2tzXS5yZGV2ID09IHJkZXYNCisJCSAgICAmJiBjb25mLT5taXJy b3JpdCAhPSAtMSkgew0KKwkJCS8qIGluX3N5bmMsIGJ1dCBtdXN0IGJlIGhhbmRsZWQgc3BlY2lh bGx5LCBkb24ndCBsZXQgJ2RlZ3JhZGVkKysnICovDQorCQkgICAgICAgIHByaW50ayAoS0VSTl9B TEVSVCAiYWN0aXZlIHNwYXJlIGhhcyBmYWlsZWQgJXMgKGluX3N5bmMgJWQpXG4iLA0KKwkJCQkg ICAgYmRldm5hbWUocmRldi0+YmRldixiKSwgcmRldi0+aW5fc3luYyk7DQorCQkJbWRkZXYtPnNi X2RpcnR5ID0gMTsNCisJCQlpZiAocmRldi0+aW5fc3luYykNCisJCQkJcmRldi0+cmFpZF9kaXNr ID0gY29uZi0+cmFpZF9kaXNrczsgLyogbWUgYXMgbXlzZWxmLCBhZ2FpbiA7KSAqLw0KKwkJICAg ICAgICByZGV2LT5pbl9zeW5jID0gMDsNCisJCQlyZGV2LT5mYXVsdHkgPSAxOw0KKwkJICAgICAg ICBjb25mLT5taXJyb3JpdCA9IC0xOw0KKwkJfSBlbHNlIGlmIChtZGRpc2tzID4gY29uZi0+cmFp ZF9kaXNrcyAmJiAhbWRkZXYtPmRlZ3JhZGVkICYmIHJkZXYtPmluX3N5bmMpIHsNCisJCSAgICAv KiBoYXZlIGFjdGl2ZSBzcGFyZSwgYXJyYXkgaXMgb3B0aW1hbCwgcmVtb3ZlZCBkaXNrIG1lbWJl cg0KKwkJCSAgICBvZiBpdCAoYnV0IG5vdCB0aGUgYWN0aXZlIHNwYXJlKSAqLw0KKwkJICAgIGlm IChyZGV2LT5yYWlkX2Rpc2sgPT0gY29uZi0+bWlycm9yaXQgJiYgY29uZi0+ZGlza3NbY29uZi0+ cmFpZF9kaXNrc10ucmRldikgew0KKwkJCWlmICghY29uZi0+ZGlza3NbY29uZi0+cmFpZF9kaXNr c10ucmRldi0+aW5fc3luYykgew0KKwkJCSAgICBwcmludGsoS0VSTl9BTEVSVCAiZGlzayAlcyBm YWlsZWQgYW5kIGFjdGl2ZSBzcGFyZSBpc24ndCBpbl9zeW5jIHlldCwgcmVhZGQgYXMgbm9ybWFs IHNwYXJlXG4iLA0KKwkJCQkJYmRldm5hbWUocmRldi0+YmRldixiKSk7DQorCQkJICAgIGNvbmYt Pm1pcnJvcml0ID0gLTE7DQorCQkJICAgIGdvdG8gbGV0aXRnbzsNCisJCQl9IGVsc2Ugew0KKwkJ CSAgICBpbnQgcmV0Ow0KKw0KKwkJCSAgICAvKiBob3QgcmVwbGFjZSB0aGUgbWlycm9yZWQgZHJp dmUgd2l0aCB0aGUgJ2FjdGl2ZSBzcGFyZScNCisJCQkJdGhpcyBpcyByZWFsbHkgImhvdCIsIEkg Y2FuJ3Qgc2VlIGNsZWFybHkgdGhlIHRoaW5ncw0KKwkJCQl3aGF0IEkgaGF2ZSB0byBkbyBoZXJl LiA6fQ0KKwkJCQlwcmF5LiAqLw0KKw0KKwkJCSAgICBwcmludGsoS0VSTl9BTEVSVCAicmVwbGFj ZSAlcyB3aXRoIGluX3N5bmMgYWN0aXZlIHNwYXJlICVzXG4iLA0KKwkJCQkgICAgYmRldm5hbWUo cmRldi0+YmRldixiKSwNCisJCQkJICAgIGJkZXZuYW1lKHJkZXZzLT5iZGV2LGIyKSk7DQorCQkJ ICAgIHJkZXYtPmluX3N5bmMgPSAwOw0KKwkJCSAgICByZGV2LT5mYXVsdHkgPSAxOw0KKw0KKwkJ CSAgICBjb25mLT5taXJyb3JpdCA9IC0xOw0KKw0KKwkJCSAgICAvKiBteSBHb2QsIGFtIEkgc2Fu ZT8gKi8NCisJCQkgICAgd2hpbGUgKChpID0gYXRvbWljX3JlYWQoJnJkZXYtPm5yX3BlbmRpbmcp KSkgew0KKwkJCQlwcmludGsoIndhaXRpbmcgZm9yIGRpc2sgJWQgLi4gJWRcbiIsDQorCQkJCQly ZGV2LT5yYWlkX2Rpc2ssIGkpOw0KKwkJCSAgICB9DQorCQkJICAgIHJldCA9IHJhaWQ1X3JlbW92 ZV9kaXNrKG1kZGV2LCByZGV2LT5yYWlkX2Rpc2spOw0KKwkJCSAgICBpZiAocmV0KSB7DQorCQkJ CXByaW50ayhLRVJOX0VSUiAicmFpZDVfcmVtb3ZlX2Rpc2sxOiBidXN5PyFcbiIpOw0KKwkJCQly ZXR1cm47CS8vIHNob3VsZCBub3RoaW5nIHRvIGRvDQorCQkJICAgIH0NCisNCisJCQkgICAgcmQg PSBjb25mLT5kaXNrc1tjb25mLT5yYWlkX2Rpc2tzXS5yZGV2Ow0KKwkJCSAgICB3aGlsZSAoKGkg PSBhdG9taWNfcmVhZCgmcmQtPm5yX3BlbmRpbmcpKSkgew0KKwkJCQlwcmludGsoIndhaXRpbmcg Zm9yIGRpc2sgJWQgLi4gJWRcbiIsDQorCQkJCQljb25mLT5yYWlkX2Rpc2tzLCBpKTsNCisJCQkg ICAgfQ0KKwkJCSAgICByZC0+aW5fc3luYyA9IDA7DQorCQkJICAgIHJldCA9IHJhaWQ1X3JlbW92 ZV9kaXNrKG1kZGV2LCBjb25mLT5yYWlkX2Rpc2tzKTsNCisJCQkgICAgaWYgKHJldCkgew0KKwkJ CQlwcmludGsoS0VSTl9FUlIgInJhaWQ1X3JlbW92ZV9kaXNrMjogYnVzeT8hXG4iKTsNCisJCQkJ cmV0dXJuOwkvLyAuLg0KKwkJCSAgICB9DQorDQorCQkJICAgIHJldCA9IHJhaWQ1X2FkZF9kaXNr KG1kZGV2LCByZCk7DQorCQkJICAgIGlmICghcmV0KSB7DQorCQkJCXByaW50ayhLRVJOX0VSUiAi cmFpZDVfYWRkX2Rpc2s6IG5vIGZyZWUgc2xvdD8hXG4iKTsNCisJCQkJcmV0dXJuOwkvLyAuLg0K KwkJCSAgICB9DQorCQkJICAgIHJkLT5pbl9zeW5jID0gMTsNCisNCisJCQkgICAgLyogYm9ycm93 ZWQgZnJvbSBob3RfcmVtb3ZlX2Rpc2soKSAqLw0KKwkJCSAgICBraWNrX3JkZXZfZnJvbV9hcnJh eShyZGV2KTsNCisJCQkgICAgbWRkZXYtPnNiX2RpcnR5ID0gMTsNCisJCQl9DQorCQkgICAgfSBl bHNlIHsNCisJCQkvKiBpbl9zeW5jIGRpc2sgZmFpbGVkICghZGVncmFkZWQpLCBoYXZlIGEgc3Bh cmUsIHN0YXJ0aW5nDQorCQkJICAgIHByb2FjdGl2ZSBtaXJyb3JpbmcgKi8NCisJCQlpZiAoY29u Zi0+bWlycm9yaXQgPT0gLTEpIHsNCisJCQkJcHJpbnRrKEtFUk5fQUxFUlQgInJlc3luYyBmcm9t ICVzIHRvIHNwYXJlICVzICglZClcbiIsDQorCQkJCQliZGV2bmFtZShyZGV2LT5iZGV2LGIpLA0K KwkJCSAgICAJCWJkZXZuYW1lKHJkZXZzLT5iZGV2LGIyKSwNCisJCQkJCWNvbmYtPnJhaWRfZGlz a3MpOw0KKw0KKwkJCQljb25mLT5taXJyb3JpdCA9IHJkZXYtPnJhaWRfZGlzazsNCisNCisJCQkJ bWRkZXYtPmRlZ3JhZGVkKys7CS8qIHRvIGNhbGwgcmFpZDVfaG90X2FkZF9kaXNrKCksIHJlc2V0 IHRoZXJlICovDQorCQkJfSBlbHNlIHsNCisJCQkJcHJpbnRrKEtFUk5fQUxFUlQgInByb2FjdGl2 ZSBtaXJyb3JpbmcgaXMgYWN0aXZlLCBsZXQgdGhpcyBkZXZpY2UgZ29cbiIpOw0KKwkJCQlnb3Rv IGxldGl0Z287DQorCQkJfQ0KKwkJICAgIH0NCisJCX0gZWxzZSB7DQorbGV0aXRnbzoNCisJCSAg ICBtZGRldi0+c2JfZGlydHkgPSAxOw0KKwkJICAgIGlmIChyZGV2LT5pbl9zeW5jKSB7DQorCQkJ ICAgIGNvbmYtPndvcmtpbmdfZGlza3MtLTsNCisJCQkgICAgbWRkZXYtPmRlZ3JhZGVkKys7DQor CQkJICAgIGNvbmYtPmZhaWxlZF9kaXNrcysrOw0KKwkJCSAgICByZGV2LT5pbl9zeW5jID0gMDsN CisJCQkgICAgLyogZXJyb3IoKSB3YXMgbm90IGNhbGxlZCBpZiB0aGUgc3luY2luZyB3YXMgc3Rv cHBlZCBieSBJTyBlcnJvciAqLw0KKwkJCSAgICBpZiAoY29uZi0+bWlycm9yaXQgIT0gLTEgJiYN CisJCQkJIWNvbmYtPmRpc2tzW2NvbmYtPnJhaWRfZGlza3NdLnJkZXYtPmluX3N5bmMpIHsNCisJ CQkJICAgIHByaW50ayhLRVJOX05PVElDRSAic3RvcCBwcm9hY3RpdmUgbWlycm9yaW5nXG4iKTsN CisJCQkJICAgIGNvbmYtPm1pcnJvcml0ID0gLTE7DQorCQkJICAgIH0NCisJCQkgICAgLyoNCisJ CQkgICAgICogaWYgcmVjb3Zlcnkgd2FzIHJ1bm5pbmcsIG1ha2Ugc3VyZSBpdCBhYm9ydHMuDQor CQkJICAgICAqLw0KKwkJCSAgICBzZXRfYml0KE1EX1JFQ09WRVJZX0VSUiwgJm1kZGV2LT5yZWNv dmVyeSk7DQorCQkgICAgfQ0KKwkJICAgIHJkZXYtPmZhdWx0eSA9IDE7DQorCQkgICAgcHJpbnRr IChLRVJOX0FMRVJUDQorCQkJICAgICJyYWlkNTogRGlzayBmYWlsdXJlIG9uICVzLCBkaXNhYmxp bmcgZGV2aWNlLiINCisJCQkgICAgIiBPcGVyYXRpb24gY29udGludWluZyBvbiAlZCBkZXZpY2Vz XG4iLA0KKwkJCSAgICBiZGV2bmFtZShyZGV2LT5iZGV2LGIpLCBjb25mLT53b3JraW5nX2Rpc2tz KTsNCisJCX0NCiAJfQ0KIH0JDQogDQpAQCAtODk2LDYgKzEyMDcsNzQgQEANCiB9DQogDQogDQor c3RhdGljIGludCByYWlkNV9zcGFyZV9hY3RpdmUobWRkZXZfdCAqbWRkZXYpOw0KKw0KK3N0YXRp YyB2b2lkIHJhaWQ1X2VlaCAobWRkZXZfdCAqbWRkZXYpDQorew0KKwlyYWlkNV9jb25mX3QgKmNv bmYgPSBtZGRldl90b19jb25mKG1kZGV2KTsNCisJaW50IGkgPSBjb25mLT5tZGRldi0+ZWVoX2Rh dGEuZmFpbGVkX251bTsNCisJc3RydWN0IGRpc2tfaW5mbyAqZGlzayA9ICZjb25mLT5kaXNrc1tp XTsNCisJY2hhciBiW0JERVZOQU1FX1NJWkVdOw0KKwlzdGF0aWMgY2hhciAqZW52cFtdID0geyAi SE9NRT0vIiwNCisJCQkgICAgIlRFUk09bGludXgiLA0KKwkJCSAgICAiUEFUSD0vc2JpbjovdXNy L3NiaW46L2JpbjovdXNyL2JpbiIsDQorCQkJICAgIE5VTEwgfTsNCisJaW50IHJldDsNCisJaW50 IGo7DQorDQorCS8qIHN1c3BlbmQgSU87IHRvZG86IHdlbGwsIHdlIHNob3VsZCB3YWxrIG92ZXIg b24gZGlza3MgYW5kIHdhaXRpbmcgdGlsbA0KKwkgICAgKG5yX3BlbmRpbmcgPiAwKSAqLw0KKwlw cmludGsoInJhaWQ1X3VzZXJlaCBhY3RpdmUgWyVkLCAleF1cbiIsIGksIGRpc2stPnJkZXYpOw0K Kw0KKwlpZiAoaSA8IDAgfHwgIWRpc2stPnJkZXYpIHsNCisJCS8vIGZpeG1lOiB3aHkgY2FsbGVk IG9uIG1kX3VucmVnaXN0ZXI/DQorCSAgICAgICAgcHJpbnRrKEtFUk5fQUxFUlQgIkVSUk9SOiAh ZGlzay0+cmRldiBbJWRdXG4iLCBpKTsNCisJCWdvdG8gZWVoX291dDsNCisJfQ0KKw0KKyAgICAg ICAgaWYgKG1kZGV2LT5kZWdyYWRlZCkgew0KKwkgICAgICAgIHByaW50ayhLRVJOX0FMRVJUICJh cnJheSBpcyBhbHJlYWR5IGRlZ3JhZGVkLCBkb24ndCBraWNrIHRoaXMgZGV2aWNlXG4iKTsNCisJ CWdvdG8gZWVoX291dDsNCisJfQ0KKw0KKwl7DQorCSAgICBjaGFyICphcmd2W10gPSB7ICIvc2Jp bi9tZGV2ZW50IiwgbWRuYW1lKG1kZGV2KSwgImRyaXZlZmFpbCIsDQorCQkJCWJkZXZuYW1lKGRp c2stPnJkZXYtPmJkZXYsIGIpLCBOVUxMIH07DQorCSAgICByZXQgPSBjYWxsX3VzZXJtb2RlaGVs cGVyKCIvc2Jpbi9tZGV2ZW50IiwgYXJndiwgZW52cCwgMS8qd2FpdCovKTsNCisJICAgIHJldCA9 IHJldCA+PiA4Ow0KKwkgICAgaWYgKHJldCA8IDAgfHwgcmV0ID4gMSkgew0KKwkgICAgCXByaW50 ayhLRVJOX0FMRVJUICIvc2Jpbi9tZGV2ZW50IGZhaWxlZDogJWRcbiIsIHJldCk7DQorCSAgICAJ bWRfZXJyb3IobWRkZXYsIGRpc2stPnJkZXYpOw0KKwkgICAgICAgIC8qICh0aGUgcmFpZDVfcmVt b3ZlX2Rpc2sgYW5kIHJhaWQ1X2FkZF9kaXNrIHdhc24ndCBjYWxsZWQgeWV0KSAqLw0KKwkgICAg fQ0KKwl9DQorDQorCXN3aXRjaCAocmV0KSB7DQorCSAgICBjYXNlIDE6CQkvKiByZXNldCBiYWRi bG9jayBjYWNoZSAobGF0ZXI6IHJld3JpdGUgYmFkIGJsb2Nrcz8pICovDQorCSAgICAgICAgcHJp bnRrKEtFUk5fSU5GTyAicmVzZXR0aW5nIGJhZGJsb2NrcyBjYWNoZVxuIik7DQorCSAgICAgICAg Zm9yIChqID0gMDsgaiA8IEJCX05SX0hBU0g7IGorKykgew0KKwkJCXN0cnVjdCBiYWRibG9jayAq YmIsICpiYnByZXYgPSBOVUxMOw0KKwkJCWJiID0gZGlzay0+YmFkYmxvY2tfaGFzaHRibFtqXTsN CisJCQlmb3IgKDsgYmI7IGJiID0gYmItPmhhc2hfbmV4dCkgew0KKwkJCQlpZiAoYmJwcmV2KQ0K KwkJCQkJa21lbV9jYWNoZV9mcmVlKGRpc2stPnNsYWJfY2FjaGUsIGJicHJldik7DQorCQkJCWJi X3JlbW92ZV9oYXNoKGJiKTsNCisJCQkJYmJwcmV2ID0gYmI7DQorCQkJfQ0KKwkJCWlmIChiYnBy ZXYpDQorCQkJCWttZW1fY2FjaGVfZnJlZShkaXNrLT5zbGFiX2NhY2hlLCBiYnByZXYpOw0KKwkJ fQ0KKwkJYnJlYWs7DQorCSAgICBkZWZhdWx0Og0KKwkJYnJlYWs7DQorCX0NCisNCitlZWhfb3V0 Og0KKwltZGRldi0+ZWVoX2RhdGEuZmFpbGVkX251bSA9IC0xOwkvKiB1bnJlZ2lzdGVyIG1lICov DQorCW1kX3dha2V1cF90aHJlYWQobWRkZXYtPnRocmVhZCk7DQorCXByaW50aygicmFpZDVfdXNl cmVoIGV4aXRlZFxuIik7DQorfQ0KKw0KIC8qDQogICogaGFuZGxlX3N0cmlwZSAtIGRvIHRoaW5n cyB0byBhIHN0cmlwZS4NCiAgKg0KQEAgLTkyNSwyMSArMTMwNCwzNyBAQA0KIAlpbnQgbG9ja2Vk PTAsIHVwdG9kYXRlPTAsIHRvX3JlYWQ9MCwgdG9fd3JpdGU9MCwgZmFpbGVkPTAsIHdyaXR0ZW49 MDsNCiAJaW50IG5vbl9vdmVyd3JpdGUgPSAwOw0KIAlpbnQgZmFpbGVkX251bT0wOw0KKwlpbnQg YXNwYXJlPTAsIGFzcGFyZW51bT0tMTsNCisJc3RydWN0IGRpc2tfaW5mbyAqYXNwYXJlZGV2Ow0K IAlzdHJ1Y3QgcjVkZXYgKmRldjsNCiANCiAJUFJJTlRLKCJoYW5kbGluZyBzdHJpcGUgJWxsdSwg Y250PSVkLCBwZF9pZHg9JWRcbiIsDQogCQkodW5zaWduZWQgbG9uZyBsb25nKXNoLT5zZWN0b3Is IGF0b21pY19yZWFkKCZzaC0+Y291bnQpLA0KIAkJc2gtPnBkX2lkeCk7DQogDQorCWlmIChjb25m LT5tZGRldi0+ZWVoX3RocmVhZCkgew0KKwkJUFJJTlRLKCJwYXNzIHRoZSBzdHJpcGUsIGVlaCBp cyBhY3RpdmVcbiIpOw0KKwkJc2V0X2JpdChTVFJJUEVfSEFORExFLCAmc2gtPnN0YXRlKTsNCisJ ICAgICAgICByZXR1cm47DQorCX0NCisNCiAJc3Bpbl9sb2NrKCZzaC0+bG9jayk7DQogCWNsZWFy X2JpdChTVFJJUEVfSEFORExFLCAmc2gtPnN0YXRlKTsNCiAJY2xlYXJfYml0KFNUUklQRV9ERUxB WUVELCAmc2gtPnN0YXRlKTsNCiANCiAJc3luY2luZyA9IHRlc3RfYml0KFNUUklQRV9TWU5DSU5H LCAmc2gtPnN0YXRlKTsNCisJYXNwYXJlZGV2ID0gJmNvbmYtPmRpc2tzW2NvbmYtPnJhaWRfZGlz a3NdOw0KKwlpZiAoIWNvbmYtPm1kZGV2LT5kZWdyYWRlZCAmJiBhc3BhcmVkZXYtPnJkZXYgJiYg IWFzcGFyZWRldi0+cmRldi0+ZmF1bHR5ICYmDQorCQljb25mLT5taXJyb3JpdCAhPSAtMSkgew0K KwkgICAgYXNwYXJlKys7DQorCSAgICBhc3BhcmVudW0gPSBzaC0+cmFpZF9jb25mLT5taXJyb3Jp dDsNCisJICAgIFBSSU5USygiaGFzIGFzcGFyZSAoJWQpXG4iLCBhc3BhcmVudW0pOw0KKwl9DQog CS8qIE5vdyB0byBsb29rIGFyb3VuZCBhbmQgc2VlIHdoYXQgY2FuIGJlIGRvbmUgKi8NCiANCi0J Zm9yIChpPWRpc2tzOyBpLS07ICkgew0KKwlmb3IgKGk9ZGlza3MrYXNwYXJlOyBpLS07ICkgew0K IAkJbWRrX3JkZXZfdCAqcmRldjsNCisJCXN0cnVjdCBiYWRibG9jayAqYmIgPSBOVUxMOw0KIAkJ ZGV2ID0gJnNoLT5kZXZbaV07DQogCQljbGVhcl9iaXQoUjVfSW5zeW5jLCAmZGV2LT5mbGFncyk7 DQogCQljbGVhcl9iaXQoUjVfU3luY2lvLCAmZGV2LT5mbGFncyk7DQpAQCAtOTgyLDE4ICsxMzc3 LDc5IEBADQogCQl9DQogCQlpZiAoZGV2LT53cml0dGVuKSB3cml0dGVuKys7DQogCQlyZGV2ID0g Y29uZi0+ZGlza3NbaV0ucmRldjsgLyogRklYTUUsIHNob3VsZCBJIGJlIGxvb2tpbmcgcmRldiAq Lw0KKwkJaWYgKHJkZXYgJiYgcmRldi0+aW5fc3luYyAmJg0KKwkJICAgICF0ZXN0X2JpdChSNV9V UFRPREFURSwgJmRldi0+ZmxhZ3MpICYmDQorCQkgICAgIXRlc3RfYml0KFI1X0xPQ0tFRCwgJmRl di0+ZmxhZ3MpKSB7DQorCQkJLyogLi5wb3RlbnRpYWxseSBkZXNlcnZlZCB0byByZWFkLCB3ZSBt dXN0IGNoZWNrIGl0DQorCQkJICAgIGNoZWNrbWUsIGl0IGNvdWxkIGJlIGEgYmlnIHBlcmZvcm1h bmNlIHBlbmFsdHkgaWYgY2FsbGVkDQorCQkJCXdpdGhvdXQgYSBnb29kIHJlYXNvbiEgaXQncyBz ZWVtcyBvayBmb3Igbm93DQorCQkJKi8NCisJCQlQUklOVEsoImZpbmRfYmFkYmxvY2sgJWQ6ICVs bHVcbiIsIGksIHNoLT5zZWN0b3IpOw0KKwkJCWJiID0gZmluZF9iYWRibG9jaygmY29uZi0+ZGlz a3NbaV0sIHNoLT5zZWN0b3IpOw0KKwkJfQ0KIAkJaWYgKCFyZGV2IHx8ICFyZGV2LT5pbl9zeW5j KSB7DQogCQkJLyogVGhlIFJlYWRFcnJvciBmbGFnIHdpbCBqdXN0IGJlIGNvbmZ1c2luZyBub3cg Ki8NCiAJCQljbGVhcl9iaXQoUjVfUmVhZEVycm9yLCAmZGV2LT5mbGFncyk7DQogCQkJY2xlYXJf Yml0KFI1X1JlV3JpdGUsICZkZXYtPmZsYWdzKTsNCiAJCX0NCiAJCWlmICghcmRldiB8fCAhcmRl di0+aW5fc3luYw0KLQkJICAgIHx8IHRlc3RfYml0KFI1X1JlYWRFcnJvciwgJmRldi0+ZmxhZ3Mp KSB7DQorCQkgICAgfHwgdGVzdF9iaXQoUjVfUmVhZEVycm9yLCAmZGV2LT5mbGFncykgLyomJiAh dGVzdF9iaXQoUjVfVVBUT0RBVEUsICZkZXYtPmZsYWdzKSkqLw0KKwkJICAgIHx8IHRlc3RfYml0 KFI1X0hhcmRSZWFkRXJyLCAmZGV2LT5mbGFncykNCisJCSAgICB8fCBiYikgew0KKwkJCWlmIChy ZGV2ICYmIHJkZXYtPmluX3N5bmMNCisJCQkgICAgJiYgIWJiICYmIHRlc3RfYml0KFI1X0hhcmRS ZWFkRXJyLCAmZGV2LT5mbGFncykpIHsNCisJCQkJLyogdGFrZSBhbiBhY3Rpb24gb25seSBpZiBp dCdzIGEgX25ld18gYmFkIGJsb2NrDQorCQkJCSAgICBhbmQgbm90IHdoaWxlIHByb2FjdGl2ZSBt aXJyb3JpbmcgaXMgcnVubmluZyAqLw0KKw0KKwkJCQlpZiAoIWFzcGFyZSB8fCAoYXNwYXJlICYm IGFzcGFyZWRldi0+cmRldi0+aW5fc3luYy8qYXNwYXJlbnVtICE9IGkqLykpIHsNCisJCQkJICAg IC8qIGlmIGFzcGFyZSBpcyBzeW5jaW5nIHdlIHNob3VsZG4ndCByZWdpc3RlciBuZXcNCisJCQkJ CWJhZCBibG9ja3MsIGFmdGVyIHRoZSBzeW5jIHRoaXMgZGlzayB3aWxsDQorCQkJCQliZSBraWNr ZWQgYW55d2F5ICovDQorDQorCQkJCSAgICBpZiAodGVzdF9iaXQoUjVfSGFyZFJlYWRFcnIsICZk ZXYtPmZsYWdzKSkgew0KKwkJCQkJUFJJTlRLKCJzdG9yZV9iYWRibG9jayAlZDogJWxsdVxuIiwg aSwgc2gtPnNlY3Rvcik7DQorCQkJCQlzdG9yZV9iYWRibG9jaygmY29uZi0+ZGlza3NbaV0sIHNo LT5zZWN0b3IpOw0KKwkJCQkgICAgfQ0KKw0KKwkJCQkgICAgaWYgKGNvdW50X2JhZGJsb2Nrcygm Y29uZi0+ZGlza3NbaV0pID49IHN5c2N0bF9iYWRibG9ja190b2xlcmFuY2UpIHsNCisJCQkJCWNo YXIgYltCREVWTkFNRV9TSVpFXTsNCisNCisJCQkJCXByaW50ayhLRVJOX0FMRVJUICJ0b28gbWFu eSBiYWRibG9ja3MgKCVsdSkgb24gZGV2aWNlICVzIFslZF1cbiIsDQorCQkJCQkJICAgIGNvdW50 X2JhZGJsb2NrcygmY29uZi0+ZGlza3NbaV0pICsgMSwgYmRldm5hbWUoY29uZi0+ZGlza3NbaV0u cmRldi0+YmRldiwgYiksDQorCQkJCQkJICAgIGF0b21pY19yZWFkKCZyZGV2LT5ucl9wZW5kaW5n KSk7DQorI2lmbmRlZiBVU0VSRUgNCisJCQkJCW1kX2Vycm9yKGNvbmYtPm1kZGV2LCBjb25mLT5k aXNrc1tpXS5yZGV2KTsNCisjZWxzZQ0KKwkJCQkJaWYgKCFjb25mLT5tZGRldi0+ZWVoX3RocmVh ZCkgew0KKwkJCQkJICAgIGNvbmYtPm1kZGV2LT5lZWhfdGhyZWFkID0gbWRfcmVnaXN0ZXJfdGhy ZWFkKHJhaWQ1X2VlaCwgY29uZi0+bWRkZXYsICIlc19lZWgiKTsNCisJCQkJCSAgICBpZiAoIWNv bmYtPm1kZGV2LT5lZWhfdGhyZWFkKSB7DQorCQkJCQkJcHJpbnRrKEtFUk5fRVJSIA0KKwkJCQkJ CSAgICAicmFpZDU6IGNvdWxkbid0IGFsbG9jYXRlIGV4dGVybmFsIGVycm9yIGhhbmRsZXIgdGhy ZWFkIGZvciAlc1xuIiwNCisJCQkJCQkgICAgbWRuYW1lKGNvbmYtPm1kZGV2KSk7DQorCQkJCQkJ bWRfZXJyb3IoY29uZi0+bWRkZXYsIGNvbmYtPmRpc2tzW2ldLnJkZXYpOw0KKwkJCQkJICAgIH0g ZWxzZSAgew0KKwkJCQkJCWNvbmYtPm1kZGV2LT5lZWhfZGF0YS5mYWlsZWRfbnVtID0gaTsNCisJ CQkJCQltZF93YWtldXBfdGhyZWFkKGNvbmYtPm1kZGV2LT5lZWhfdGhyZWFkKTsNCisJCQkJCSAg ICB9DQorCQkJCQl9DQorI2VuZGlmDQorCQkJCSAgICB9DQorCQkJCX0NCisNCisJCQkJLy8gaGEg a296YmVuIHZvbHQgbWFzaWsgSU8gZXMgYXp0IGthcGp1ayBlbG9iYiBpZGU/Pw0KKwkJCQkvLyBo YXNvbmxvIGRvbG9nIHZhbiBhIHJld3JpdGUtbmFsIGlzLCBlZ3kgY2lwbw0KKwkJCQljbGVhcl9i aXQoUjVfSGFyZFJlYWRFcnIsICZkZXYtPmZsYWdzKTsNCisJCQl9DQogCQkJZmFpbGVkKys7DQog CQkJZmFpbGVkX251bSA9IGk7DQotCQl9IGVsc2UNCisJCQlQUklOVEsoImRldmljZSAlZCBmYWls ZWQgZm9yIHRoaXMgc3RyaXBlIHIlcCB3JXBcbiIsIGksIGRldi0+dG9yZWFkLCBkZXYtPnRvd3Jp dGUpOw0KKwkJfSBlbHNlIHsNCiAJCQlzZXRfYml0KFI1X0luc3luYywgJmRldi0+ZmxhZ3MpOw0K KwkJfQ0KIAl9DQorCWlmIChhc3BhcmUgJiYgZmFpbGVkID4gMSkNCisJICAgIGZhaWxlZC0tOwkv KiBmYWlsZWQgPSAxIG1lYW5zICJhbGwgb2siIGlmIHdlJ3ZlIGFzcGFyZSwgdGhpcyBpcyBzaW1w bGVzdA0KKwkJCSAgICBtZXRob2QgdG8gZG8gb3VyIHdvcmsgKi8NCiAJUFJJTlRLKCJsb2NrZWQ9 JWQgdXB0b2RhdGU9JWQgdG9fcmVhZD0lZCINCiAJCSIgdG9fd3JpdGU9JWQgZmFpbGVkPSVkIGZh aWxlZF9udW09JWRcbiIsDQogCQlsb2NrZWQsIHVwdG9kYXRlLCB0b19yZWFkLCB0b193cml0ZSwg ZmFpbGVkLCBmYWlsZWRfbnVtKTsNCkBAIC0xMDQ3LDcgKzE1MDMsNyBAQA0KIA0KIAkJCS8qIGZh aWwgYW55IHJlYWRzIGlmIHRoaXMgZGV2aWNlIGlzIG5vbi1vcGVyYXRpb25hbCAqLw0KIAkJCWlm ICghdGVzdF9iaXQoUjVfSW5zeW5jLCAmc2gtPmRldltpXS5mbGFncykgfHwNCi0JCQkgICAgdGVz dF9iaXQoUjVfUmVhZEVycm9yLCAmc2gtPmRldltpXS5mbGFncykpIHsNCisJCQkgICAgdGVzdF9i aXQoUjVfUmVhZEVycm9yLCAmc2gtPmRldltpXS5mbGFncykpIHsgLy8gaGF2ZSBtZWFuaW5nIG9m IHRoaXM/Pw0KIAkJCQliaSA9IHNoLT5kZXZbaV0udG9yZWFkOw0KIAkJCQlzaC0+ZGV2W2ldLnRv cmVhZCA9IE5VTEw7DQogCQkJCWlmICh0ZXN0X2FuZF9jbGVhcl9iaXQoUjVfT3ZlcmxhcCwgJnNo LT5kZXZbaV0uZmxhZ3MpKQ0KQEAgLTEwNzAsNiArMTUyNiw4IEBADQogCQl9DQogCX0NCiAJaWYg KGZhaWxlZCA+IDEgJiYgc3luY2luZykgew0KKwkJcHJpbnRrKEtFUk5fQUxFUlQgInN5bmMgc3Rv cHBlZCBieSBJTyBlcnJvciwgbWFya2luZyB0aGUgc3BhcmUgZmFpbGVkXG4iKTsNCisJCWNvbmYt PmRpc2tzW2ZhaWxlZF9udW1dLnJkZXYtPmZhdWx0eSA9IDE7DQogCQltZF9kb25lX3N5bmMoY29u Zi0+bWRkZXYsIFNUUklQRV9TRUNUT1JTLDApOw0KIAkJY2xlYXJfYml0KFNUUklQRV9TWU5DSU5H LCAmc2gtPnN0YXRlKTsNCiAJCXN5bmNpbmcgPSAwOw0KQEAgLTEyNDksNiArMTcwNywyNiBAQA0K IAkJCQkJUFJJTlRLKCJXcml0aW5nIGJsb2NrICVkXG4iLCBpKTsNCiAJCQkJCWxvY2tlZCsrOw0K IAkJCQkJc2V0X2JpdChSNV9XYW50d3JpdGUsICZzaC0+ZGV2W2ldLmZsYWdzKTsNCisJCQkJCWlm IChhc3BhcmUgJiYgaSA9PSBhc3BhcmVudW0pIHsNCisJCQkJCSAgICBjaGFyICpwcywgKnBkOw0K Kw0KKwkJCQkJICAgIC8qIG1pcnJvcmluZyB0aGlzIG5ldyBibG9jayAqLw0KKwkJCQkJICAgIFBS SU5USygiV3JpdGluZyB0byBhc3BhcmUgdG9vICVkLT4lZFxuIiwNCisJCQkJCQkJaSwgY29uZi0+ cmFpZF9kaXNrcyk7DQorCQkJCQkgICAgLyppZiAodGVzdF9iaXQoUjVfTE9DS0VELCAmc2gtPmRl dltjb25mLT5yYWlkX2Rpc2tzXS5mbGFncykpIHsNCisJCQkJCQlwcmludGsoImJhem1lZywgZXog bG9ra29sdDEhISFcbiIpOw0KKwkJCQkJICAgIH0qLw0KKwkJCQkJICAgIHBzID0gcGFnZV9hZGRy ZXNzKHNoLT5kZXZbaV0ucGFnZSk7DQorCQkJCQkgICAgcGQgPSBwYWdlX2FkZHJlc3Moc2gtPmRl dltjb25mLT5yYWlkX2Rpc2tzXS5wYWdlKTsNCisJCQkJCSAgICAvKiBiZXR0ZXIgaWRlYT8gKi8N CisJCQkJCSAgICBtZW1jcHkocGQsIHBzLCBTVFJJUEVfU0laRSk7DQorCQkJCQkgICAgc2V0X2Jp dChSNV9MT0NLRUQsICZzaC0+ZGV2W2NvbmYtPnJhaWRfZGlza3NdLmZsYWdzKTsNCisJCQkJCSAg ICBzZXRfYml0KFI1X1dhbnR3cml0ZSwgJnNoLT5kZXZbY29uZi0+cmFpZF9kaXNrc10uZmxhZ3Mp Ow0KKwkJCQkJfQ0KKwkJCQkJaWYgKGNvbmYtPmRpc2tzW2ldLnJkZXYgJiYgY29uZi0+ZGlza3Nb aV0ucmRldi0+aW5fc3luYykgew0KKwkJCQkJICAgIFBSSU5USygicmVzZXQgYmFkYmxvY2sgb24g JWQ6ICVsbHVcbiIsIGksIHNoLT5zZWN0b3IpOw0KKwkJCQkJICAgIGRlbGV0ZV9iYWRibG9jaygm Y29uZi0+ZGlza3NbaV0sIHNoLT5zZWN0b3IpOw0KKwkJCQkJfQ0KIAkJCQkJaWYgKCF0ZXN0X2Jp dChSNV9JbnN5bmMsICZzaC0+ZGV2W2ldLmZsYWdzKQ0KIAkJCQkJICAgIHx8IChpPT1zaC0+cGRf aWR4ICYmIGZhaWxlZCA9PSAwKSkNCiAJCQkJCQlzZXRfYml0KFNUUklQRV9JTlNZTkMsICZzaC0+ c3RhdGUpOw0KQEAgLTEyODUsMTQgKzE3NjMsMzAgQEANCiAJCQlpZiAoZmFpbGVkPT0wKQ0KIAkJ CQlmYWlsZWRfbnVtID0gc2gtPnBkX2lkeDsNCiAJCQkvKiBzaG91bGQgYmUgYWJsZSB0byBjb21w dXRlIHRoZSBtaXNzaW5nIGJsb2NrIGFuZCB3cml0ZSBpdCB0byBzcGFyZSAqLw0KKwkJCWlmIChh c3BhcmUpDQorCQkJICAgIGZhaWxlZF9udW0gPSBhc3BhcmVudW07DQogCQkJaWYgKCF0ZXN0X2Jp dChSNV9VUFRPREFURSwgJnNoLT5kZXZbZmFpbGVkX251bV0uZmxhZ3MpKSB7DQogCQkJCWlmICh1 cHRvZGF0ZSsxICE9IGRpc2tzKQ0KIAkJCQkJQlVHKCk7DQogCQkJCWNvbXB1dGVfYmxvY2soc2gs IGZhaWxlZF9udW0pOw0KIAkJCQl1cHRvZGF0ZSsrOw0KIAkJCX0NCisJCQlpZiAoYXNwYXJlKSB7 DQorCQkJICAgIGNoYXIgKnBzLCAqcGQ7DQorDQorCQkJICAgIHBzID0gcGFnZV9hZGRyZXNzKHNo LT5kZXZbZmFpbGVkX251bV0ucGFnZSk7DQorCQkJICAgIHBkID0gcGFnZV9hZGRyZXNzKHNoLT5k ZXZbY29uZi0+cmFpZF9kaXNrc10ucGFnZSk7DQorCQkJICAgIG1lbWNweShwZCwgcHMsIFNUUklQ RV9TSVpFKTsNCisJCQkgICAgUFJJTlRLKCJSNV9XYW50d3JpdGUgdG8gYXNwYXJlLCB1cHRvZGF0 ZTogJWQgJXAtPiVwXG4iLA0KKwkJCQkJdXB0b2RhdGUsIHBzLCBwZCk7DQorCQkJICAgIC8qaWYg KHRlc3RfYml0KFI1X0xPQ0tFRCwgJnNoLT5kZXZbY29uZi0+cmFpZF9kaXNrc10uZmxhZ3MpKSB7 DQorCQkJCXByaW50aygiYmF6bWVnLCBleiBsb2trb2x0MiEhIVxuIik7DQorCQkJICAgIH0qLw0K KwkJCX0NCiAJCQlpZiAodXB0b2RhdGUgIT0gZGlza3MpDQogCQkJCUJVRygpOw0KKwkJCWlmIChh c3BhcmUpDQorCQkJICAgIGZhaWxlZF9udW0gPSBjb25mLT5yYWlkX2Rpc2tzOw0KIAkJCWRldiA9 ICZzaC0+ZGV2W2ZhaWxlZF9udW1dOw0KIAkJCXNldF9iaXQoUjVfTE9DS0VELCAmZGV2LT5mbGFn cyk7DQogCQkJc2V0X2JpdChSNV9XYW50d3JpdGUsICZkZXYtPmZsYWdzKTsNCkBAIC0xMzAwLDYg KzE3OTQsOSBAQA0KIAkJCWxvY2tlZCsrOw0KIAkJCXNldF9iaXQoU1RSSVBFX0lOU1lOQywgJnNo LT5zdGF0ZSk7DQogCQkJc2V0X2JpdChSNV9TeW5jaW8sICZkZXYtPmZsYWdzKTsNCisJCQkvKiAh aW5fc3luYy4uDQorCQkJcHJpbnRrKCJyZXNldCBiYWRibG9jayBvbiAlZDogJWxsdVxuIiwgZmFp bGVkX251bSwgc2gtPnNlY3Rvcik7DQorCQkJZGVsZXRlX2JhZGJsb2NrKCZjb25mLT5kaXNrc1tm YWlsZWRfbnVtXSwgc2gtPnNlY3Rvcik7Ki8NCiAJCX0NCiAJfQ0KIAlpZiAoc3luY2luZyAmJiBs b2NrZWQgPT0gMCAmJiB0ZXN0X2JpdChTVFJJUEVfSU5TWU5DLCAmc2gtPnN0YXRlKSkgew0KQEAg LTEzMzYsNyArMTgzMyw3IEBADQogCQliaS0+Ymlfc2l6ZSA9IDA7DQogCQliaS0+YmlfZW5kX2lv KGJpLCBieXRlcywgMCk7DQogCX0NCi0JZm9yIChpPWRpc2tzOyBpLS0gOykgew0KKwlmb3IgKGk9 ZGlza3MrYXNwYXJlOyBpLS0gOykgew0KIAkJaW50IHJ3Ow0KIAkJc3RydWN0IGJpbyAqYmk7DQog CQltZGtfcmRldl90ICpyZGV2Ow0KQEAgLTE2NzQsMTEgKzIxNzEsMjAgQEANCiANCiAJbWRfY2hl Y2tfcmVjb3ZlcnkobWRkZXYpOw0KIA0KKwlpZiAobWRkZXYtPmVlaF90aHJlYWQgJiYgbWRkZXYt PmVlaF9kYXRhLmZhaWxlZF9udW0gPT0gLTEpIHsNCisJCXByaW50ayhLRVJOX0lORk8gImVlaF90 aHJlYWQgaXMgZG9uZSwgdW5yZWdpc3RlcmluZ1xuIik7DQorCQltZF91bnJlZ2lzdGVyX3RocmVh ZChtZGRldi0+ZWVoX3RocmVhZCk7DQorCQltZGRldi0+ZWVoX3RocmVhZCA9IE5VTEw7DQorCX0N CisNCiAJaGFuZGxlZCA9IDA7DQogCXNwaW5fbG9ja19pcnEoJmNvbmYtPmRldmljZV9sb2NrKTsN CiAJd2hpbGUgKDEpIHsNCiAJCXN0cnVjdCBsaXN0X2hlYWQgKmZpcnN0Ow0KIA0KKwkJaWYgKG1k ZGV2LT5lZWhfdGhyZWFkKQ0KKwkJICAgIGJyZWFrOw0KKw0KIAkJaWYgKGNvbmYtPnNlcV9mbHVz aCAtIGNvbmYtPnNlcV93cml0ZSA+IDApIHsNCiAJCQlpbnQgc2VxID0gY29uZi0+c2VxX2ZsdXNo Ow0KIAkJCWJpdG1hcF91bnBsdWcobWRkZXYtPmJpdG1hcCk7DQpAQCAtMTczMywxMSArMjIzOSwx MSBAQA0KIAl9DQogDQogCW1kZGV2LT5wcml2YXRlID0ga21hbGxvYyAoc2l6ZW9mIChyYWlkNV9j b25mX3QpDQotCQkJCSAgKyBtZGRldi0+cmFpZF9kaXNrcyAqIHNpemVvZihzdHJ1Y3QgZGlza19p bmZvKSwNCisJCQkJICArIChtZGRldi0+cmFpZF9kaXNrcyArIDEpICogc2l6ZW9mKHN0cnVjdCBk aXNrX2luZm8pLA0KIAkJCQkgIEdGUF9LRVJORUwpOw0KIAlpZiAoKGNvbmYgPSBtZGRldi0+cHJp dmF0ZSkgPT0gTlVMTCkNCiAJCWdvdG8gYWJvcnQ7DQotCW1lbXNldCAoY29uZiwgMCwgc2l6ZW9m ICgqY29uZikgKyBtZGRldi0+cmFpZF9kaXNrcyAqIHNpemVvZihzdHJ1Y3QgZGlza19pbmZvKSAp Ow0KKwltZW1zZXQgKGNvbmYsIDAsIHNpemVvZiAoKmNvbmYpICsgKG1kZGV2LT5yYWlkX2Rpc2tz ICsgMSkgKiBzaXplb2Yoc3RydWN0IGRpc2tfaW5mbykgKTsNCiAJY29uZi0+bWRkZXYgPSBtZGRl djsNCiANCiAJaWYgKChjb25mLT5zdHJpcGVfaGFzaHRibCA9IChzdHJ1Y3Qgc3RyaXBlX2hlYWQg KiopIF9fZ2V0X2ZyZWVfcGFnZXMoR0ZQX0FUT01JQywgSEFTSF9QQUdFU19PUkRFUikpID09IE5V TEwpDQpAQCAtMTc2NSw2ICsyMjcxLDggQEANCiANCiAJCWRpc2stPnJkZXYgPSByZGV2Ow0KIA0K KwkJZ3Jvd19iYWRibG9ja3MoZGlzayk7DQorDQogCQlpZiAocmRldi0+aW5fc3luYykgew0KIAkJ CWNoYXIgYltCREVWTkFNRV9TSVpFXTsNCiAJCQlwcmludGsoS0VSTl9JTkZPICJyYWlkNTogZGV2 aWNlICVzIG9wZXJhdGlvbmFsIGFzIHJhaWQiDQpAQCAtMTc3NSw2ICsyMjgzLDggQEANCiAJfQ0K IA0KIAljb25mLT5yYWlkX2Rpc2tzID0gbWRkZXYtPnJhaWRfZGlza3M7DQorCWNvbmYtPm1pcnJv cml0ID0gLTE7DQorCW1kZGV2LT5lZWhfdGhyZWFkID0gTlVMTDsJLyoganVzdCB0byBiZSBzdXJl ICovDQogCS8qDQogCSAqIDAgZm9yIGEgZnVsbHkgZnVuY3Rpb25hbCBhcnJheSwgMSBmb3IgYSBk ZWdyYWRlZCBhcnJheS4NCiAJICovDQpAQCAtMTgyNSw3ICsyMzM1LDcgQEANCiAJCX0NCiAJfQ0K IG1lbW9yeSA9IGNvbmYtPm1heF9ucl9zdHJpcGVzICogKHNpemVvZihzdHJ1Y3Qgc3RyaXBlX2hl YWQpICsNCi0JCSBjb25mLT5yYWlkX2Rpc2tzICogKChzaXplb2Yoc3RydWN0IGJpbykgKyBQQUdF X1NJWkUpKSkgLyAxMDI0Ow0KKwkJIChjb25mLT5yYWlkX2Rpc2tzKzEpICogKChzaXplb2Yoc3Ry dWN0IGJpbykgKyBQQUdFX1NJWkUpKSkgLyAxMDI0Ow0KIAlpZiAoZ3Jvd19zdHJpcGVzKGNvbmYs IGNvbmYtPm1heF9ucl9zdHJpcGVzKSkgew0KIAkJcHJpbnRrKEtFUk5fRVJSIA0KIAkJCSJyYWlk NTogY291bGRuJ3QgYWxsb2NhdGUgJWRrQiBmb3IgYnVmZmVyc1xuIiwgbWVtb3J5KTsNCkBAIC0x ODg3LDEwICsyMzk3LDE5IEBADQogc3RhdGljIGludCBzdG9wIChtZGRldl90ICptZGRldikNCiB7 DQogCXJhaWQ1X2NvbmZfdCAqY29uZiA9IChyYWlkNV9jb25mX3QgKikgbWRkZXYtPnByaXZhdGU7 DQorCWludCBpOw0KIA0KKwkvKiBtYXkgYmxvY2tlZCBpbiB1c2VyLXNwYWNlLCBraWxsIGl0ICov DQorCWlmIChtZGRldi0+ZWVoX3RocmVhZCkgew0KKwkJbWRfdW5yZWdpc3Rlcl90aHJlYWQobWRk ZXYtPmVlaF90aHJlYWQpOw0KKwkJbWRkZXYtPmVlaF90aHJlYWQgPSBOVUxMOw0KKwl9DQogCW1k X3VucmVnaXN0ZXJfdGhyZWFkKG1kZGV2LT50aHJlYWQpOw0KIAltZGRldi0+dGhyZWFkID0gTlVM TDsNCiAJc2hyaW5rX3N0cmlwZXMoY29uZik7DQorCWZvciAoaSA9IGNvbmYtPnJhaWRfZGlza3M7 IGktLTsgKQ0KKwkJaWYgKGNvbmYtPmRpc2tzW2ldLnJkZXYgJiYgY29uZi0+ZGlza3NbaV0ucmRl di0+aW5fc3luYykNCisJCQlzaHJpbmtfYmFkYmxvY2tzKCZjb25mLT5kaXNrc1tpXSk7DQogCWZy ZWVfcGFnZXMoKHVuc2lnbmVkIGxvbmcpIGNvbmYtPnN0cmlwZV9oYXNodGJsLCBIQVNIX1BBR0VT X09SREVSKTsNCiAJYmxrX3N5bmNfcXVldWUobWRkZXYtPnF1ZXVlKTsgLyogdGhlIHVucGx1ZyBm biByZWZlcmVuY2VzICdjb25mJyovDQogCWtmcmVlKGNvbmYpOw0KQEAgLTE5MzYsNyArMjQ1NSw5 IEBADQogc3RhdGljIHZvaWQgc3RhdHVzIChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgbWRkZXZfdCAq bWRkZXYpDQogew0KIAlyYWlkNV9jb25mX3QgKmNvbmYgPSAocmFpZDVfY29uZl90ICopIG1kZGV2 LT5wcml2YXRlOw0KLQlpbnQgaTsNCisJaW50IGksIGo7DQorCWNoYXIgYltCREVWTkFNRV9TSVpF XTsNCisJc3RydWN0IGJhZGJsb2NrICpiYjsNCiANCiAJc2VxX3ByaW50ZiAoc2VxLCAiIGxldmVs ICVkLCAlZGsgY2h1bmssIGFsZ29yaXRobSAlZCIsIG1kZGV2LT5sZXZlbCwgbWRkZXYtPmNodW5r X3NpemUgPj4gMTAsIG1kZGV2LT5sYXlvdXQpOw0KIAlzZXFfcHJpbnRmIChzZXEsICIgWyVkLyVk XSBbIiwgY29uZi0+cmFpZF9kaXNrcywgY29uZi0+d29ya2luZ19kaXNrcyk7DQpAQCAtMTk0OSw2 ICsyNDcwLDIwIEBADQogI2RlZmluZSBEKHgpIFwNCiAJc2VxX3ByaW50ZiAoc2VxLCAiPCIjeCI6 JWQ+IiwgYXRvbWljX3JlYWQoJmNvbmYtPngpKQ0KIAlwcmludGFsbChjb25mKTsNCisNCisJc3Bp bl9sb2NrX2lycSgmY29uZi0+ZGV2aWNlX2xvY2spOwkvKiBpdCdzIG9rIG5vdyBmb3IgZGVidWcg Ki8NCisJc2VxX3ByaW50ZiAoc2VxLCAiXG4gICAgICBrbm93biBiYWQgc2VjdG9ycyBvbiBhY3Rp dmUgZGV2aWNlczoiKTsNCisJZm9yIChpID0gY29uZi0+cmFpZF9kaXNrczsgaS0tOyApIHsNCisJ ICAgIGlmIChjb25mLT5kaXNrc1tpXS5yZGV2KSB7DQorCQlzZXFfcHJpbnRmIChzZXEsICJcbiAg ICAgICVzIiwgYmRldm5hbWUoY29uZi0+ZGlza3NbaV0ucmRldi0+YmRldiwgYikpOw0KKwkJZm9y IChqID0gMDsgaiA8IEJCX05SX0hBU0g7IGorKykgew0KKwkJICAgIGJiID0gY29uZi0+ZGlza3Nb aV0uYmFkYmxvY2tfaGFzaHRibFtqXTsNCisJCSAgICBmb3IgKDsgYmI7IGJiID0gYmItPmhhc2hf bmV4dCkNCisJCQlzZXFfcHJpbnRmIChzZXEsICIgJWxsdS0lbGx1IiwgYmItPnNlY3RvciwgYmIt PnNlY3RvciArICh1bnNpZ25lZCBsb25nIGxvbmcpKFNUUklQRV9TSVpFIC8gNTEyKSAtIDEpOw0K KwkJfQ0KKwkgICAgfQ0KKwl9DQorCXNwaW5fdW5sb2NrX2lycSgmY29uZi0+ZGV2aWNlX2xvY2sp Ow0KICNlbmRpZg0KIH0NCiANCkBAIC0xOTkyLDYgKzI1MjcsMTYgQEANCiAJCQl0bXAtPnJkZXYt PmluX3N5bmMgPSAxOw0KIAkJfQ0KIAl9DQorCXRtcCA9IGNvbmYtPmRpc2tzICsgaTsNCisJaWYg KHRtcC0+cmRldiAmJiAhdG1wLT5yZGV2LT5mYXVsdHkgJiYgIXRtcC0+cmRldi0+aW5fc3luYykg ew0KKwkgICAgdG1wLT5yZGV2LT5pbl9zeW5jID0gMTsNCisNCisJICAgIHByaW50ayhLRVJOX05P VElDRSAicmFpZDVfc3BhcmVfYWN0aXZlOiAlZCBpbl9zeW5jICVkLT4lZFxuIiwNCisJCQlpLCB0 bXAtPnJkZXYtPnJhaWRfZGlzaywgY29uZi0+bWlycm9yaXQpOw0KKw0KKwkgICAgLyogc2Nhcnku Lj8gOn0gKi8NCisJICAgIHRtcC0+cmRldi0+cmFpZF9kaXNrID0gY29uZi0+bWlycm9yaXQ7DQor CX0NCiAJcHJpbnRfcmFpZDVfY29uZihjb25mKTsNCiAJcmV0dXJuIDA7DQogfQ0KQEAgLTIwMDUs NiArMjU1MCw3IEBADQogDQogCXByaW50X3JhaWQ1X2NvbmYoY29uZik7DQogCXJkZXYgPSBwLT5y ZGV2Ow0KK3ByaW50aygicmFpZDVfcmVtb3ZlX2Rpc2sgJWRcbiIsIG51bWJlcik7DQogCWlmIChy ZGV2KSB7DQogCQlpZiAocmRldi0+aW5fc3luYyB8fA0KIAkJICAgIGF0b21pY19yZWFkKCZyZGV2 LT5ucl9wZW5kaW5nKSkgew0KQEAgLTIwMTgsNiArMjU2NCwxNyBAQA0KIAkJCWVyciA9IC1FQlVT WTsNCiAJCQlwLT5yZGV2ID0gcmRldjsNCiAJCX0NCisJCWlmICghZXJyKSB7DQorCQkJc2hyaW5r X2JhZGJsb2NrcyhwKTsNCisNCisJCQkvKiBzdG9wcGVkIGJ5IElPIGVycm9yLi4gKi8NCisJCQlp ZiAoY29uZi0+bWlycm9yaXQgIT0gLTENCisJCQkgICAgJiYgY29uZi0+ZGlza3NbY29uZi0+cmFp ZF9kaXNrc10ucmRldiA9PSBOVUxMKSB7DQorCQkJCXByaW50ayhLRVJOX0lORk8gInJhaWQ1X3Jl bW92ZV9kaXNrOiBJTyBlcnJvciBvbiBwcm9hY3RpdmUgbWlycm9yaW5nIG9mICVkIVxuIiwNCisJ CQkJCSAgICBjb25mLT5taXJyb3JpdCk7DQorCQkJCWNvbmYtPm1pcnJvcml0ID0gLTE7DQorCQkJ fQ0KKwkJfQ0KIAl9DQogYWJvcnQ6DQogDQpAQCAtMjA0OSw2ICsyNjA2LDI5IEBADQogCQkJcC0+ cmRldiA9IHJkZXY7DQogCQkJYnJlYWs7DQogCQl9DQorDQorCWlmICghZm91bmQgJiYgY29uZi0+ ZGlza3NbZGlza10ucmRldiA9PSBOVUxMKSB7DQorCSAgICBjaGFyIGJbQkRFVk5BTUVfU0laRV07 DQorDQorCSAgICAvKiBhcnJheSBvcHRpbWFsLCB0aGlzIHNob3VsZCBiZSB0aGUgJ2FjdGl2ZSBz cGFyZScgYWRkZWQgYnkgZWVoX3RocmVhZC9lcnJvcigpICovDQorCSAgICBjb25mLT5kaXNrc1tk aXNrXS5yZGV2ID0gcmRldjsNCisJICAgIHJkZXYtPmluX3N5bmMgPSAwOw0KKwkgICAgcmRldi0+ cmFpZF9kaXNrID0gY29uZi0+cmFpZF9kaXNrczsNCisJICAgIGNvbmYtPmZ1bGxzeW5jID0gMTsN CisNCisJICAgIGlmIChtZGRldi0+ZGVncmFkZWQpIC8qIGlmIHdlJ3JlIGhlcmUgYW5kIGl0J3Mg dHJ1ZSwgd2UncmUgY2FsbGVkIGFmdGVyIGVycm9yKCkgKi8NCisJCSAgICBtZGRldi0+ZGVncmFk ZWQtLTsNCisJICAgIGVsc2UNCisJCSAgICBjb25mLT5taXJyb3JpdCA9IG1kZGV2LT5lZWhfZGF0 YS5mYWlsZWRfbnVtOw0KKwkgICAgZm91bmQgPSAxOw0KKw0KKwkgICAgcHJpbnRrKEtFUk5fTk9U SUNFICJhZGRlZCBzcGFyZSBmb3IgcHJvYWN0aXZlIHJlcGxhY2VtZW50IG9mICVzXG4iLA0KKwkJ ICAgIGJkZXZuYW1lKGNvbmYtPmRpc2tzW2NvbmYtPm1pcnJvcml0XS5yZGV2LT5iZGV2LCBiKSk7 DQorCX0NCisJaWYgKGZvdW5kKQ0KKwkJZ3Jvd19iYWRibG9ja3MoJmNvbmYtPmRpc2tzW2Rpc2td KTsNCisJcHJpbnRrKEtFUk5fSU5GTyAicmFpZDVfYWRkX2Rpc2s6ICVkICglZCkgaW5fc3luYzog JWRcbiIsIGRpc2ssIGZvdW5kLCBmb3VuZCA/IHJkZXYtPmluX3N5bmMgOiAtMSk7DQorDQogCXBy aW50X3JhaWQ1X2NvbmYoY29uZik7DQogCXJldHVybiBmb3VuZDsNCiB9DQo= --=-cvrENmlRXkwLAfO+s1cW--