ZGlmZiAtLWdpdCBhL2tlcm5lbC9NYWtlZmlsZSBiL2tlcm5lbC9NYWtlZmlsZQppbmRleCAzZDljN2UyLi5lMjZhNTQ2IDEwMDY0NAotLS0gYS9rZXJuZWwvTWFrZWZpbGUKKysrIGIva2VybmVsL01ha2VmaWxlCkBAIC05Niw3ICs5Niw3IEBACiBvYmotJChDT05GSUdfUklOR19CVUZGRVIpICs9IHRyYWNlLwogb2JqLSQoQ09ORklHX1NNUCkgKz0gc2NoZWRfY3B1cHJpLm8KIG9iai0kKENPTkZJR19TTE9XX1dPUkspICs9IHNsb3ctd29yay5vCi1vYmotJChDT05GSUdfUEVSRl9DT1VOVEVSUykgKz0gcGVyZl9jb3VudGVyLm8KK29iai0kKENPTkZJR19QRVJGX0VWRU5UUykgKz0gcGVyZl9ldmVudC5vCiAKIGlmbmVxICgkKENPTkZJR19TQ0hFRF9PTUlUX0ZSQU1FX1BPSU5URVIpLHkpCiAjIEFjY29yZGluZyB0byBBbGFuIE1vZHJhIDxhbGFuQGxpbnV4Y2FyZS5jb20uYXU+LCB0aGUgLWZuby1vbWl0LWZyYW1lLXBvaW50ZXIgaXMKZGlmZiAtLWdpdCBhL2tlcm5lbC9leGl0LmMgYi9rZXJuZWwvZXhpdC5jCmluZGV4IGFlNWQ4NjYuLmU0N2VlOGEgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9leGl0LmMKKysrIGIva2VybmVsL2V4aXQuYwpAQCAtNDcsNyArNDcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3RyYWNlaG9vay5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzX3N0cnVjdC5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXRfdGFzay5oPgotI2luY2x1ZGUgPGxpbnV4L3BlcmZfY291bnRlci5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmZfZXZlbnQuaD4KICNpbmNsdWRlIDx0cmFjZS9ldmVudHMvc2NoZWQuaD4KIAogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CkBAIC0xNTQsOCArMTU0LDggQEAKIHsKIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzayA9IGNvbnRhaW5lcl9vZihyaHAsIHN0cnVjdCB0YXNrX3N0cnVjdCwgcmN1KTsKIAotI2lmZGVmIENPTkZJR19QRVJGX0NPVU5URVJTCi0JV0FSTl9PTl9PTkNFKHRzay0+cGVyZl9jb3VudGVyX2N0eHApOworI2lmZGVmIENPTkZJR19QRVJGX0VWRU5UUworCVdBUk5fT05fT05DRSh0c2stPnBlcmZfZXZlbnRfY3R4cCk7CiAjZW5kaWYKIAl0cmFjZV9zY2hlZF9wcm9jZXNzX2ZyZWUodHNrKTsKIAlwdXRfdGFza19zdHJ1Y3QodHNrKTsKQEAgLTk4MSw3ICs5ODEsNyBAQAogCSAqIEZsdXNoIGluaGVyaXRlZCBjb3VudGVycyB0byB0aGUgcGFyZW50IC0gYmVmb3JlIHRoZSBwYXJlbnQKIAkgKiBnZXRzIHdva2VuIHVwIGJ5IGNoaWxkLWV4aXQgbm90aWZpY2F0aW9ucy4KIAkgKi8KLQlwZXJmX2NvdW50ZXJfZXhpdF90YXNrKHRzayk7CisJcGVyZl9ldmVudF9leGl0X3Rhc2sodHNrKTsKIAogCWV4aXRfbm90aWZ5KHRzaywgZ3JvdXBfZGVhZCk7CiAjaWZkZWYgQ09ORklHX05VTUEKZGlmZiAtLWdpdCBhL2tlcm5lbC9mb3JrLmMgYi9rZXJuZWwvZm9yay5jCmluZGV4IGJmZWU5MzEuLjJjZWJmYjIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9mb3JrLmMKKysrIGIva2VybmVsL2ZvcmsuYwpAQCAtNjEsNyArNjEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzX3N0cnVjdC5oPgogI2luY2x1ZGUgPGxpbnV4L21hZ2ljLmg+Ci0jaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+CisjaW5jbHVkZSA8bGludXgvcGVyZl9ldmVudC5oPgogCiAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KICNpbmNsdWRlIDxhc20vcGdhbGxvYy5oPgpAQCAtMTA3OCw3ICsxMDc4LDcgQEAKIAkvKiBQZXJmb3JtIHNjaGVkdWxlciByZWxhdGVkIHNldHVwLiBBc3NpZ24gdGhpcyB0YXNrIHRvIGEgQ1BVLiAqLwogCXNjaGVkX2ZvcmsocCwgY2xvbmVfZmxhZ3MpOwogCi0JcmV0dmFsID0gcGVyZl9jb3VudGVyX2luaXRfdGFzayhwKTsKKwlyZXR2YWwgPSBwZXJmX2V2ZW50X2luaXRfdGFzayhwKTsKIAlpZiAocmV0dmFsKQogCQlnb3RvIGJhZF9mb3JrX2NsZWFudXBfcG9saWN5OwogCkBAIC0xMjUzLDcgKzEyNTMsNyBAQAogCXdyaXRlX3VubG9ja19pcnEoJnRhc2tsaXN0X2xvY2spOwogCXByb2NfZm9ya19jb25uZWN0b3IocCk7CiAJY2dyb3VwX3Bvc3RfZm9yayhwKTsKLQlwZXJmX2NvdW50ZXJfZm9yayhwKTsKKwlwZXJmX2V2ZW50X2ZvcmsocCk7CiAJcmV0dXJuIHA7CiAKIGJhZF9mb3JrX2ZyZWVfcGlkOgpAQCAtMTI4MCw3ICsxMjgwLDcgQEAKIGJhZF9mb3JrX2NsZWFudXBfYXVkaXQ6CiAJYXVkaXRfZnJlZShwKTsKIGJhZF9mb3JrX2NsZWFudXBfcG9saWN5OgotCXBlcmZfY291bnRlcl9mcmVlX3Rhc2socCk7CisJcGVyZl9ldmVudF9mcmVlX3Rhc2socCk7CiAjaWZkZWYgQ09ORklHX05VTUEKIAltcG9sX3B1dChwLT5tZW1wb2xpY3kpOwogYmFkX2ZvcmtfY2xlYW51cF9jZ3JvdXA6CmRpZmYgLS1naXQgYS9rZXJuZWwvcGVyZl9jb3VudGVyLmMgYi9rZXJuZWwvcGVyZl9jb3VudGVyLmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDYyZGUwZGIuLjAwMDAwMDAKLS0tIGEva2VybmVsL3BlcmZfY291bnRlci5jCisrKyAvZGV2L251bGwKQEAgLTEsNTAwMCArMCwwIEBACi0vKgotICogUGVyZm9ybWFuY2UgY291bnRlciBjb3JlIGNvZGUKLSAqCi0gKiAgQ29weXJpZ2h0IChDKSAyMDA4IFRob21hcyBHbGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgotICogIENvcHlyaWdodCAoQykgMjAwOC0yMDA5IFJlZCBIYXQsIEluYy4sIEluZ28gTW9sbmFyCi0gKiAgQ29weXJpZ2h0IChDKSAyMDA4LTIwMDkgUmVkIEhhdCwgSW5jLiwgUGV0ZXIgWmlqbHN0cmEgPHB6aWpsc3RyQHJlZGhhdC5jb20+Ci0gKiAgQ29weXJpZ2h0ICCpICAyMDA5IFBhdWwgTWFja2VycmFzLCBJQk0gQ29ycC4gPHBhdWx1c0BhdTEuaWJtLmNvbT4KLSAqCi0gKiAgRm9yIGxpY2Vuc2luZyBkZXRhaWxzIHNlZSBrZXJuZWwtYmFzZS9DT1BZSU5HCi0gKi8KLQotI2luY2x1ZGUgPGxpbnV4L2ZzLmg+Ci0jaW5jbHVkZSA8bGludXgvbW0uaD4KLSNpbmNsdWRlIDxsaW51eC9jcHUuaD4KLSNpbmNsdWRlIDxsaW51eC9zbXAuaD4KLSNpbmNsdWRlIDxsaW51eC9maWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvcG9sbC5oPgotI2luY2x1ZGUgPGxpbnV4L3N5c2ZzLmg+Ci0jaW5jbHVkZSA8bGludXgvZGNhY2hlLmg+Ci0jaW5jbHVkZSA8bGludXgvcGVyY3B1Lmg+Ci0jaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+Ci0jaW5jbHVkZSA8bGludXgvdm1zdGF0Lmg+Ci0jaW5jbHVkZSA8bGludXgvaGFyZGlycS5oPgotI2luY2x1ZGUgPGxpbnV4L3JjdWxpc3QuaD4KLSNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+Ci0jaW5jbHVkZSA8bGludXgvc3lzY2FsbHMuaD4KLSNpbmNsdWRlIDxsaW51eC9hbm9uX2lub2Rlcy5oPgotI2luY2x1ZGUgPGxpbnV4L2tlcm5lbF9zdGF0Lmg+Ci0jaW5jbHVkZSA8bGludXgvcGVyZl9jb3VudGVyLmg+Ci0KLSNpbmNsdWRlIDxhc20vaXJxX3JlZ3MuaD4KLQotLyoKLSAqIEVhY2ggQ1BVIGhhcyBhIGxpc3Qgb2YgcGVyIENQVSBjb3VudGVyczoKLSAqLwotREVGSU5FX1BFUl9DUFUoc3RydWN0IHBlcmZfY3B1X2NvbnRleHQsIHBlcmZfY3B1X2NvbnRleHQpOwotCi1pbnQgcGVyZl9tYXhfY291bnRlcnMgX19yZWFkX21vc3RseSA9IDE7Ci1zdGF0aWMgaW50IHBlcmZfcmVzZXJ2ZWRfcGVyY3B1IF9fcmVhZF9tb3N0bHk7Ci1zdGF0aWMgaW50IHBlcmZfb3ZlcmNvbW1pdCBfX3JlYWRfbW9zdGx5ID0gMTsKLQotc3RhdGljIGF0b21pY190IG5yX2NvdW50ZXJzIF9fcmVhZF9tb3N0bHk7Ci1zdGF0aWMgYXRvbWljX3QgbnJfbW1hcF9jb3VudGVycyBfX3JlYWRfbW9zdGx5Owotc3RhdGljIGF0b21pY190IG5yX2NvbW1fY291bnRlcnMgX19yZWFkX21vc3RseTsKLXN0YXRpYyBhdG9taWNfdCBucl90YXNrX2NvdW50ZXJzIF9fcmVhZF9tb3N0bHk7Ci0KLS8qCi0gKiBwZXJmIGNvdW50ZXIgcGFyYW5vaWEgbGV2ZWw6Ci0gKiAgLTEgLSBub3QgcGFyYW5vaWQgYXQgYWxsCi0gKiAgIDAgLSBkaXNhbGxvdyByYXcgdHJhY2Vwb2ludCBhY2Nlc3MgZm9yIHVucHJpdgotICogICAxIC0gZGlzYWxsb3cgY3B1IGNvdW50ZXJzIGZvciB1bnByaXYKLSAqICAgMiAtIGRpc2FsbG93IGtlcm5lbCBwcm9maWxpbmcgZm9yIHVucHJpdgotICovCi1pbnQgc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCBfX3JlYWRfbW9zdGx5ID0gMTsKLQotc3RhdGljIGlubGluZSBib29sIHBlcmZfcGFyYW5vaWRfdHJhY2Vwb2ludF9yYXcodm9pZCkKLXsKLQlyZXR1cm4gc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCA+IC0xOwotfQotCi1zdGF0aWMgaW5saW5lIGJvb2wgcGVyZl9wYXJhbm9pZF9jcHUodm9pZCkKLXsKLQlyZXR1cm4gc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCA+IDA7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgYm9vbCBwZXJmX3BhcmFub2lkX2tlcm5lbCh2b2lkKQotewotCXJldHVybiBzeXNjdGxfcGVyZl9jb3VudGVyX3BhcmFub2lkID4gMTsKLX0KLQotaW50IHN5c2N0bF9wZXJmX2NvdW50ZXJfbWxvY2sgX19yZWFkX21vc3RseSA9IDUxMjsgLyogJ2ZyZWUnIGtiIHBlciB1c2VyICovCi0KLS8qCi0gKiBtYXggcGVyZiBjb3VudGVyIHNhbXBsZSByYXRlCi0gKi8KLWludCBzeXNjdGxfcGVyZl9jb3VudGVyX3NhbXBsZV9yYXRlIF9fcmVhZF9tb3N0bHkgPSAxMDAwMDA7Ci0KLXN0YXRpYyBhdG9taWM2NF90IHBlcmZfY291bnRlcl9pZDsKLQotLyoKLSAqIExvY2sgZm9yIChzeXNhZG1pbi1jb25maWd1cmFibGUpIGNvdW50ZXIgcmVzZXJ2YXRpb25zOgotICovCi1zdGF0aWMgREVGSU5FX1NQSU5MT0NLKHBlcmZfcmVzb3VyY2VfbG9jayk7Ci0KLS8qCi0gKiBBcmNoaXRlY3R1cmUgcHJvdmlkZWQgQVBJcyAtIHdlYWsgYWxpYXNlczoKLSAqLwotZXh0ZXJuIF9fd2VhayBjb25zdCBzdHJ1Y3QgcG11ICpod19wZXJmX2NvdW50ZXJfaW5pdChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXJldHVybiBOVUxMOwotfQotCi12b2lkIF9fd2VhayBod19wZXJmX2Rpc2FibGUodm9pZCkJCXsgYmFycmllcigpOyB9Ci12b2lkIF9fd2VhayBod19wZXJmX2VuYWJsZSh2b2lkKQkJeyBiYXJyaWVyKCk7IH0KLQotdm9pZCBfX3dlYWsgaHdfcGVyZl9jb3VudGVyX3NldHVwKGludCBjcHUpCXsgYmFycmllcigpOyB9Ci12b2lkIF9fd2VhayBod19wZXJmX2NvdW50ZXJfc2V0dXBfb25saW5lKGludCBjcHUpCXsgYmFycmllcigpOyB9Ci0KLWludCBfX3dlYWsKLWh3X3BlcmZfZ3JvdXBfc2NoZWRfaW4oc3RydWN0IHBlcmZfY291bnRlciAqZ3JvdXBfbGVhZGVyLAotCSAgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAotCSAgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwgaW50IGNwdSkKLXsKLQlyZXR1cm4gMDsKLX0KLQotdm9pZCBfX3dlYWsgcGVyZl9jb3VudGVyX3ByaW50X2RlYnVnKHZvaWQpCXsgfQotCi1zdGF0aWMgREVGSU5FX1BFUl9DUFUoaW50LCBwZXJmX2Rpc2FibGVfY291bnQpOwotCi12b2lkIF9fcGVyZl9kaXNhYmxlKHZvaWQpCi17Ci0JX19nZXRfY3B1X3ZhcihwZXJmX2Rpc2FibGVfY291bnQpKys7Ci19Ci0KLWJvb2wgX19wZXJmX2VuYWJsZSh2b2lkKQotewotCXJldHVybiAhLS1fX2dldF9jcHVfdmFyKHBlcmZfZGlzYWJsZV9jb3VudCk7Ci19Ci0KLXZvaWQgcGVyZl9kaXNhYmxlKHZvaWQpCi17Ci0JX19wZXJmX2Rpc2FibGUoKTsKLQlod19wZXJmX2Rpc2FibGUoKTsKLX0KLQotdm9pZCBwZXJmX2VuYWJsZSh2b2lkKQotewotCWlmIChfX3BlcmZfZW5hYmxlKCkpCi0JCWh3X3BlcmZfZW5hYmxlKCk7Ci19Ci0KLXN0YXRpYyB2b2lkIGdldF9jdHgoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCi17Ci0JV0FSTl9PTighYXRvbWljX2luY19ub3RfemVybygmY3R4LT5yZWZjb3VudCkpOwotfQotCi1zdGF0aWMgdm9pZCBmcmVlX2N0eChzdHJ1Y3QgcmN1X2hlYWQgKmhlYWQpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHg7Ci0KLQljdHggPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0LCByY3VfaGVhZCk7Ci0Ja2ZyZWUoY3R4KTsKLX0KLQotc3RhdGljIHZvaWQgcHV0X2N0eChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKLXsKLQlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmY3R4LT5yZWZjb3VudCkpIHsKLQkJaWYgKGN0eC0+cGFyZW50X2N0eCkKLQkJCXB1dF9jdHgoY3R4LT5wYXJlbnRfY3R4KTsKLQkJaWYgKGN0eC0+dGFzaykKLQkJCXB1dF90YXNrX3N0cnVjdChjdHgtPnRhc2spOwotCQljYWxsX3JjdSgmY3R4LT5yY3VfaGVhZCwgZnJlZV9jdHgpOwotCX0KLX0KLQotc3RhdGljIHZvaWQgdW5jbG9uZV9jdHgoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCi17Ci0JaWYgKGN0eC0+cGFyZW50X2N0eCkgewotCQlwdXRfY3R4KGN0eC0+cGFyZW50X2N0eCk7Ci0JCWN0eC0+cGFyZW50X2N0eCA9IE5VTEw7Ci0JfQotfQotCi0vKgotICogSWYgd2UgaW5oZXJpdCBjb3VudGVycyB3ZSB3YW50IHRvIHJldHVybiB0aGUgcGFyZW50IGNvdW50ZXIgaWQKLSAqIHRvIHVzZXJzcGFjZS4KLSAqLwotc3RhdGljIHU2NCBwcmltYXJ5X2NvdW50ZXJfaWQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQl1NjQgaWQgPSBjb3VudGVyLT5pZDsKLQotCWlmIChjb3VudGVyLT5wYXJlbnQpCi0JCWlkID0gY291bnRlci0+cGFyZW50LT5pZDsKLQotCXJldHVybiBpZDsKLX0KLQotLyoKLSAqIEdldCB0aGUgcGVyZl9jb3VudGVyX2NvbnRleHQgZm9yIGEgdGFzayBhbmQgbG9jayBpdC4KLSAqIFRoaXMgaGFzIHRvIGNvcGUgd2l0aCB3aXRoIHRoZSBmYWN0IHRoYXQgdW50aWwgaXQgaXMgbG9ja2VkLAotICogdGhlIGNvbnRleHQgY291bGQgZ2V0IG1vdmVkIHRvIGFub3RoZXIgdGFzay4KLSAqLwotc3RhdGljIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqCi1wZXJmX2xvY2tfdGFza19jb250ZXh0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywgdW5zaWduZWQgbG9uZyAqZmxhZ3MpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHg7Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0gcmV0cnk6Ci0JY3R4ID0gcmN1X2RlcmVmZXJlbmNlKHRhc2stPnBlcmZfY291bnRlcl9jdHhwKTsKLQlpZiAoY3R4KSB7Ci0JCS8qCi0JCSAqIElmIHRoaXMgY29udGV4dCBpcyBhIGNsb25lIG9mIGFub3RoZXIsIGl0IG1pZ2h0Ci0JCSAqIGdldCBzd2FwcGVkIGZvciBhbm90aGVyIHVuZGVybmVhdGggdXMgYnkKLQkJICogcGVyZl9jb3VudGVyX3Rhc2tfc2NoZWRfb3V0LCB0aG91Z2ggdGhlCi0JCSAqIHJjdV9yZWFkX2xvY2soKSBwcm90ZWN0cyB1cyBmcm9tIGFueSBjb250ZXh0Ci0JCSAqIGdldHRpbmcgZnJlZWQuICBMb2NrIHRoZSBjb250ZXh0IGFuZCBjaGVjayBpZiBpdAotCQkgKiBnb3Qgc3dhcHBlZCBiZWZvcmUgd2UgY291bGQgZ2V0IHRoZSBsb2NrLCBhbmQgcmV0cnkKLQkJICogaWYgc28uICBJZiB3ZSBsb2NrZWQgdGhlIHJpZ2h0IGNvbnRleHQsIHRoZW4gaXQKLQkJICogY2FuJ3QgZ2V0IHN3YXBwZWQgb24gdXMgYW55IG1vcmUuCi0JCSAqLwotCQlzcGluX2xvY2tfaXJxc2F2ZSgmY3R4LT5sb2NrLCAqZmxhZ3MpOwotCQlpZiAoY3R4ICE9IHJjdV9kZXJlZmVyZW5jZSh0YXNrLT5wZXJmX2NvdW50ZXJfY3R4cCkpIHsKLQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0eC0+bG9jaywgKmZsYWdzKTsKLQkJCWdvdG8gcmV0cnk7Ci0JCX0KLQotCQlpZiAoIWF0b21pY19pbmNfbm90X3plcm8oJmN0eC0+cmVmY291bnQpKSB7Ci0JCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssICpmbGFncyk7Ci0JCQljdHggPSBOVUxMOwotCQl9Ci0JfQotCXJjdV9yZWFkX3VubG9jaygpOwotCXJldHVybiBjdHg7Ci19Ci0KLS8qCi0gKiBHZXQgdGhlIGNvbnRleHQgZm9yIGEgdGFzayBhbmQgaW5jcmVtZW50IGl0cyBwaW5fY291bnQgc28gaXQKLSAqIGNhbid0IGdldCBzd2FwcGVkIHRvIGFub3RoZXIgdGFzay4gIFRoaXMgYWxzbyBpbmNyZW1lbnRzIGl0cwotICogcmVmZXJlbmNlIGNvdW50IHNvIHRoYXQgdGhlIGNvbnRleHQgY2FuJ3QgZ2V0IGZyZWVkLgotICovCi1zdGF0aWMgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpwZXJmX3Bpbl90YXNrX2NvbnRleHQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQljdHggPSBwZXJmX2xvY2tfdGFza19jb250ZXh0KHRhc2ssICZmbGFncyk7Ci0JaWYgKGN0eCkgewotCQkrK2N0eC0+cGluX2NvdW50OwotCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssIGZsYWdzKTsKLQl9Ci0JcmV0dXJuIGN0eDsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl91bnBpbl9jb250ZXh0KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQotewotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQlzcGluX2xvY2tfaXJxc2F2ZSgmY3R4LT5sb2NrLCBmbGFncyk7Ci0JLS1jdHgtPnBpbl9jb3VudDsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssIGZsYWdzKTsKLQlwdXRfY3R4KGN0eCk7Ci19Ci0KLS8qCi0gKiBBZGQgYSBjb3VudGVyIGZyb20gdGhlIGxpc3RzIGZvciBpdHMgY29udGV4dC4KLSAqIE11c3QgYmUgY2FsbGVkIHdpdGggY3R4LT5tdXRleCBhbmQgY3R4LT5sb2NrIGhlbGQuCi0gKi8KLXN0YXRpYyB2b2lkCi1saXN0X2FkZF9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4KQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmdyb3VwX2xlYWRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlcjsKLQotCS8qCi0JICogRGVwZW5kaW5nIG9uIHdoZXRoZXIgaXQgaXMgYSBzdGFuZGFsb25lIG9yIHNpYmxpbmcgY291bnRlciwKLQkgKiBhZGQgaXQgc3RyYWlnaHQgdG8gdGhlIGNvbnRleHQncyBjb3VudGVyIGxpc3QsIG9yIHRvIHRoZSBncm91cAotCSAqIGxlYWRlcidzIHNpYmxpbmcgbGlzdDoKLQkgKi8KLQlpZiAoZ3JvdXBfbGVhZGVyID09IGNvdW50ZXIpCi0JCWxpc3RfYWRkX3RhaWwoJmNvdW50ZXItPmdyb3VwX2VudHJ5LCAmY3R4LT5ncm91cF9saXN0KTsKLQllbHNlIHsKLQkJbGlzdF9hZGRfdGFpbCgmY291bnRlci0+Z3JvdXBfZW50cnksICZncm91cF9sZWFkZXItPnNpYmxpbmdfbGlzdCk7Ci0JCWdyb3VwX2xlYWRlci0+bnJfc2libGluZ3MrKzsKLQl9Ci0KLQlsaXN0X2FkZF9yY3UoJmNvdW50ZXItPmV2ZW50X2VudHJ5LCAmY3R4LT5ldmVudF9saXN0KTsKLQljdHgtPm5yX2NvdW50ZXJzKys7Ci0JaWYgKGNvdW50ZXItPmF0dHIuaW5oZXJpdF9zdGF0KQotCQljdHgtPm5yX3N0YXQrKzsKLX0KLQotLyoKLSAqIFJlbW92ZSBhIGNvdW50ZXIgZnJvbSB0aGUgbGlzdHMgZm9yIGl0cyBjb250ZXh0LgotICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGFuZCBjdHgtPmxvY2sgaGVsZC4KLSAqLwotc3RhdGljIHZvaWQKLWxpc3RfZGVsX2NvdW50ZXIoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqc2libGluZywgKnRtcDsKLQotCWlmIChsaXN0X2VtcHR5KCZjb3VudGVyLT5ncm91cF9lbnRyeSkpCi0JCXJldHVybjsKLQljdHgtPm5yX2NvdW50ZXJzLS07Ci0JaWYgKGNvdW50ZXItPmF0dHIuaW5oZXJpdF9zdGF0KQotCQljdHgtPm5yX3N0YXQtLTsKLQotCWxpc3RfZGVsX2luaXQoJmNvdW50ZXItPmdyb3VwX2VudHJ5KTsKLQlsaXN0X2RlbF9yY3UoJmNvdW50ZXItPmV2ZW50X2VudHJ5KTsKLQotCWlmIChjb3VudGVyLT5ncm91cF9sZWFkZXIgIT0gY291bnRlcikKLQkJY291bnRlci0+Z3JvdXBfbGVhZGVyLT5ucl9zaWJsaW5ncy0tOwotCi0JLyoKLQkgKiBJZiB0aGlzIHdhcyBhIGdyb3VwIGNvdW50ZXIgd2l0aCBzaWJsaW5nIGNvdW50ZXJzIHRoZW4KLQkgKiB1cGdyYWRlIHRoZSBzaWJsaW5ncyB0byBzaW5nbGV0b24gY291bnRlcnMgYnkgYWRkaW5nIHRoZW0KLQkgKiB0byB0aGUgY29udGV4dCBsaXN0IGRpcmVjdGx5OgotCSAqLwotCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShzaWJsaW5nLCB0bXAsICZjb3VudGVyLT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7Ci0KLQkJbGlzdF9tb3ZlX3RhaWwoJnNpYmxpbmctPmdyb3VwX2VudHJ5LCAmY3R4LT5ncm91cF9saXN0KTsKLQkJc2libGluZy0+Z3JvdXBfbGVhZGVyID0gc2libGluZzsKLQl9Ci19Ci0KLXN0YXRpYyB2b2lkCi1jb3VudGVyX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkgIHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsCi0JCSAgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCi17Ci0JaWYgKGNvdW50ZXItPnN0YXRlICE9IFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkUpCi0JCXJldHVybjsKLQotCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFOwotCWlmIChjb3VudGVyLT5wZW5kaW5nX2Rpc2FibGUpIHsKLQkJY291bnRlci0+cGVuZGluZ19kaXNhYmxlID0gMDsKLQkJY291bnRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGOwotCX0KLQljb3VudGVyLT50c3RhbXBfc3RvcHBlZCA9IGN0eC0+dGltZTsKLQljb3VudGVyLT5wbXUtPmRpc2FibGUoY291bnRlcik7Ci0JY291bnRlci0+b25jcHUgPSAtMTsKLQotCWlmICghaXNfc29mdHdhcmVfY291bnRlcihjb3VudGVyKSkKLQkJY3B1Y3R4LT5hY3RpdmVfb25jcHUtLTsKLQljdHgtPm5yX2FjdGl2ZS0tOwotCWlmIChjb3VudGVyLT5hdHRyLmV4Y2x1c2l2ZSB8fCAhY3B1Y3R4LT5hY3RpdmVfb25jcHUpCi0JCWNwdWN0eC0+ZXhjbHVzaXZlID0gMDsKLX0KLQotc3RhdGljIHZvaWQKLWdyb3VwX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpncm91cF9jb3VudGVyLAotCQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAotCQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCi0JaWYgKGdyb3VwX2NvdW50ZXItPnN0YXRlICE9IFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkUpCi0JCXJldHVybjsKLQotCWNvdW50ZXJfc2NoZWRfb3V0KGdyb3VwX2NvdW50ZXIsIGNwdWN0eCwgY3R4KTsKLQotCS8qCi0JICogU2NoZWR1bGUgb3V0IHNpYmxpbmdzIChpZiBhbnkpOgotCSAqLwotCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmdyb3VwX2NvdW50ZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpCi0JCWNvdW50ZXJfc2NoZWRfb3V0KGNvdW50ZXIsIGNwdWN0eCwgY3R4KTsKLQotCWlmIChncm91cF9jb3VudGVyLT5hdHRyLmV4Y2x1c2l2ZSkKLQkJY3B1Y3R4LT5leGNsdXNpdmUgPSAwOwotfQotCi0vKgotICogQ3Jvc3MgQ1BVIGNhbGwgdG8gcmVtb3ZlIGEgcGVyZm9ybWFuY2UgY291bnRlcgotICoKLSAqIFdlIGRpc2FibGUgdGhlIGNvdW50ZXIgb24gdGhlIGhhcmR3YXJlIGxldmVsIGZpcnN0LiBBZnRlciB0aGF0IHdlCi0gKiByZW1vdmUgaXQgZnJvbSB0aGUgY29udGV4dCBsaXN0LgotICovCi1zdGF0aWMgdm9pZCBfX3BlcmZfY291bnRlcl9yZW1vdmVfZnJvbV9jb250ZXh0KHZvaWQgKmluZm8pCi17Ci0Jc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBpbmZvOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OwotCi0JLyoKLQkgKiBJZiB0aGlzIGlzIGEgdGFzayBjb250ZXh0LCB3ZSBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgaXQgaXMKLQkgKiB0aGUgY3VycmVudCB0YXNrIGNvbnRleHQgb2YgdGhpcyBjcHUuIElmIG5vdCBpdCBoYXMgYmVlbgotCSAqIHNjaGVkdWxlZCBvdXQgYmVmb3JlIHRoZSBzbXAgY2FsbCBhcnJpdmVkLgotCSAqLwotCWlmIChjdHgtPnRhc2sgJiYgY3B1Y3R4LT50YXNrX2N0eCAhPSBjdHgpCi0JCXJldHVybjsKLQotCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKLQkvKgotCSAqIFByb3RlY3QgdGhlIGxpc3Qgb3BlcmF0aW9uIGFnYWluc3QgTk1JIGJ5IGRpc2FibGluZyB0aGUKLQkgKiBjb3VudGVycyBvbiBhIGdsb2JhbCBsZXZlbC4KLQkgKi8KLQlwZXJmX2Rpc2FibGUoKTsKLQotCWNvdW50ZXJfc2NoZWRfb3V0KGNvdW50ZXIsIGNwdWN0eCwgY3R4KTsKLQotCWxpc3RfZGVsX2NvdW50ZXIoY291bnRlciwgY3R4KTsKLQotCWlmICghY3R4LT50YXNrKSB7Ci0JCS8qCi0JCSAqIEFsbG93IG1vcmUgcGVyIHRhc2sgY291bnRlcnMgd2l0aCByZXNwZWN0IHRvIHRoZQotCQkgKiByZXNlcnZhdGlvbjoKLQkJICovCi0JCWNwdWN0eC0+bWF4X3BlcnRhc2sgPQotCQkJbWluKHBlcmZfbWF4X2NvdW50ZXJzIC0gY3R4LT5ucl9jb3VudGVycywKLQkJCSAgICBwZXJmX21heF9jb3VudGVycyAtIHBlcmZfcmVzZXJ2ZWRfcGVyY3B1KTsKLQl9Ci0KLQlwZXJmX2VuYWJsZSgpOwotCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwotfQotCi0KLS8qCi0gKiBSZW1vdmUgdGhlIGNvdW50ZXIgZnJvbSBhIHRhc2sncyAob3IgYSBDUFUncykgbGlzdCBvZiBjb3VudGVycy4KLSAqCi0gKiBNdXN0IGJlIGNhbGxlZCB3aXRoIGN0eC0+bXV0ZXggaGVsZC4KLSAqCi0gKiBDUFUgY291bnRlcnMgYXJlIHJlbW92ZWQgd2l0aCBhIHNtcCBjYWxsLiBGb3IgdGFzayBjb3VudGVycyB3ZSBvbmx5Ci0gKiBjYWxsIHdoZW4gdGhlIHRhc2sgaXMgb24gYSBDUFUuCi0gKgotICogSWYgY291bnRlci0+Y3R4IGlzIGEgY2xvbmVkIGNvbnRleHQsIGNhbGxlcnMgbXVzdCBtYWtlIHN1cmUgdGhhdAotICogZXZlcnkgdGFzayBzdHJ1Y3QgdGhhdCBjb3VudGVyLT5jdHgtPnRhc2sgY291bGQgcG9zc2libHkgcG9pbnQgdG8KLSAqIHJlbWFpbnMgdmFsaWQuICBUaGlzIGlzIE9LIHdoZW4gY2FsbGVkIGZyb20gcGVyZl9yZWxlYXNlIHNpbmNlCi0gKiB0aGF0IG9ubHkgY2FsbHMgdXMgb24gdGhlIHRvcC1sZXZlbCBjb250ZXh0LCB3aGljaCBjYW4ndCBiZSBhIGNsb25lLgotICogV2hlbiBjYWxsZWQgZnJvbSBwZXJmX2NvdW50ZXJfZXhpdF90YXNrLCBpdCdzIE9LIGJlY2F1c2UgdGhlCi0gKiBjb250ZXh0IGhhcyBiZWVuIGRldGFjaGVkIGZyb20gaXRzIHRhc2suCi0gKi8KLXN0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9yZW1vdmVfZnJvbV9jb250ZXh0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSBjb3VudGVyLT5jdHg7Ci0Jc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gY3R4LT50YXNrOwotCi0JaWYgKCF0YXNrKSB7Ci0JCS8qCi0JCSAqIFBlciBjcHUgY291bnRlcnMgYXJlIHJlbW92ZWQgdmlhIGFuIHNtcCBjYWxsIGFuZAotCQkgKiB0aGUgcmVtb3ZhbCBpcyBhbHdheXMgc3VjZXNzZnVsLgotCQkgKi8KLQkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGNvdW50ZXItPmNwdSwKLQkJCQkJIF9fcGVyZl9jb3VudGVyX3JlbW92ZV9mcm9tX2NvbnRleHQsCi0JCQkJCSBjb3VudGVyLCAxKTsKLQkJcmV0dXJuOwotCX0KLQotcmV0cnk6Ci0JdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9jb3VudGVyX3JlbW92ZV9mcm9tX2NvbnRleHQsCi0JCQkJIGNvdW50ZXIpOwotCi0Jc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKLQkvKgotCSAqIElmIHRoZSBjb250ZXh0IGlzIGFjdGl2ZSB3ZSBuZWVkIHRvIHJldHJ5IHRoZSBzbXAgY2FsbC4KLQkgKi8KLQlpZiAoY3R4LT5ucl9hY3RpdmUgJiYgIWxpc3RfZW1wdHkoJmNvdW50ZXItPmdyb3VwX2VudHJ5KSkgewotCQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Ci0JCWdvdG8gcmV0cnk7Ci0JfQotCi0JLyoKLQkgKiBUaGUgbG9jayBwcmV2ZW50cyB0aGF0IHRoaXMgY29udGV4dCBpcyBzY2hlZHVsZWQgaW4gc28gd2UKLQkgKiBjYW4gcmVtb3ZlIHRoZSBjb3VudGVyIHNhZmVseSwgaWYgdGhlIGNhbGwgYWJvdmUgZGlkIG5vdAotCSAqIHN1Y2NlZWQuCi0JICovCi0JaWYgKCFsaXN0X2VtcHR5KCZjb3VudGVyLT5ncm91cF9lbnRyeSkpIHsKLQkJbGlzdF9kZWxfY291bnRlcihjb3VudGVyLCBjdHgpOwotCX0KLQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdTY0IHBlcmZfY2xvY2sodm9pZCkKLXsKLQlyZXR1cm4gY3B1X2Nsb2NrKHNtcF9wcm9jZXNzb3JfaWQoKSk7Ci19Ci0KLS8qCi0gKiBVcGRhdGUgdGhlIHJlY29yZCBvZiB0aGUgY3VycmVudCB0aW1lIGluIGEgY29udGV4dC4KLSAqLwotc3RhdGljIHZvaWQgdXBkYXRlX2NvbnRleHRfdGltZShzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKLXsKLQl1NjQgbm93ID0gcGVyZl9jbG9jaygpOwotCi0JY3R4LT50aW1lICs9IG5vdyAtIGN0eC0+dGltZXN0YW1wOwotCWN0eC0+dGltZXN0YW1wID0gbm93OwotfQotCi0vKgotICogVXBkYXRlIHRoZSB0b3RhbF90aW1lX2VuYWJsZWQgYW5kIHRvdGFsX3RpbWVfcnVubmluZyBmaWVsZHMgZm9yIGEgY291bnRlci4KLSAqLwotc3RhdGljIHZvaWQgdXBkYXRlX2NvdW50ZXJfdGltZXMoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKLQl1NjQgcnVuX2VuZDsKLQotCWlmIChjb3VudGVyLT5zdGF0ZSA8IFBFUkZfQ09VTlRFUl9TVEFURV9JTkFDVElWRSB8fAotCSAgICBjb3VudGVyLT5ncm91cF9sZWFkZXItPnN0YXRlIDwgUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQotCQlyZXR1cm47Ci0KLQljb3VudGVyLT50b3RhbF90aW1lX2VuYWJsZWQgPSBjdHgtPnRpbWUgLSBjb3VudGVyLT50c3RhbXBfZW5hYmxlZDsKLQotCWlmIChjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpCi0JCXJ1bl9lbmQgPSBjb3VudGVyLT50c3RhbXBfc3RvcHBlZDsKLQllbHNlCi0JCXJ1bl9lbmQgPSBjdHgtPnRpbWU7Ci0KLQljb3VudGVyLT50b3RhbF90aW1lX3J1bm5pbmcgPSBydW5fZW5kIC0gY291bnRlci0+dHN0YW1wX3J1bm5pbmc7Ci19Ci0KLS8qCi0gKiBVcGRhdGUgdG90YWxfdGltZV9lbmFibGVkIGFuZCB0b3RhbF90aW1lX3J1bm5pbmcgZm9yIGFsbCBjb3VudGVycyBpbiBhIGdyb3VwLgotICovCi1zdGF0aWMgdm9pZCB1cGRhdGVfZ3JvdXBfdGltZXMoc3RydWN0IHBlcmZfY291bnRlciAqbGVhZGVyKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0KLQl1cGRhdGVfY291bnRlcl90aW1lcyhsZWFkZXIpOwotCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmxlYWRlci0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkKLQkJdXBkYXRlX2NvdW50ZXJfdGltZXMoY291bnRlcik7Ci19Ci0KLS8qCi0gKiBDcm9zcyBDUFUgY2FsbCB0byBkaXNhYmxlIGEgcGVyZm9ybWFuY2UgY291bnRlcgotICovCi1zdGF0aWMgdm9pZCBfX3BlcmZfY291bnRlcl9kaXNhYmxlKHZvaWQgKmluZm8pCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IGluZm87Ci0Jc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OwotCi0JLyoKLQkgKiBJZiB0aGlzIGlzIGEgcGVyLXRhc2sgY291bnRlciwgbmVlZCB0byBjaGVjayB3aGV0aGVyIHRoaXMKLQkgKiBjb3VudGVyJ3MgdGFzayBpcyB0aGUgY3VycmVudCB0YXNrIG9uIHRoaXMgY3B1LgotCSAqLwotCWlmIChjdHgtPnRhc2sgJiYgY3B1Y3R4LT50YXNrX2N0eCAhPSBjdHgpCi0JCXJldHVybjsKLQotCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKLQotCS8qCi0JICogSWYgdGhlIGNvdW50ZXIgaXMgb24sIHR1cm4gaXQgb2ZmLgotCSAqIElmIGl0IGlzIGluIGVycm9yIHN0YXRlLCBsZWF2ZSBpdCBpbiBlcnJvciBzdGF0ZS4KLQkgKi8KLQlpZiAoY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKSB7Ci0JCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKLQkJdXBkYXRlX2dyb3VwX3RpbWVzKGNvdW50ZXIpOwotCQlpZiAoY291bnRlciA9PSBjb3VudGVyLT5ncm91cF9sZWFkZXIpCi0JCQlncm91cF9zY2hlZF9vdXQoY291bnRlciwgY3B1Y3R4LCBjdHgpOwotCQllbHNlCi0JCQljb3VudGVyX3NjaGVkX291dChjb3VudGVyLCBjcHVjdHgsIGN0eCk7Ci0JCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX09GRjsKLQl9Ci0KLQlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKLX0KLQotLyoKLSAqIERpc2FibGUgYSBjb3VudGVyLgotICoKLSAqIElmIGNvdW50ZXItPmN0eCBpcyBhIGNsb25lZCBjb250ZXh0LCBjYWxsZXJzIG11c3QgbWFrZSBzdXJlIHRoYXQKLSAqIGV2ZXJ5IHRhc2sgc3RydWN0IHRoYXQgY291bnRlci0+Y3R4LT50YXNrIGNvdWxkIHBvc3NpYmx5IHBvaW50IHRvCi0gKiByZW1haW5zIHZhbGlkLiAgVGhpcyBjb25kaXRpb24gaXMgc2F0aXNpZmVkIHdoZW4gY2FsbGVkIHRocm91Z2gKLSAqIHBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZCBvciBwZXJmX2NvdW50ZXJfZm9yX2VhY2ggYmVjYXVzZSB0aGV5Ci0gKiBob2xkIHRoZSB0b3AtbGV2ZWwgY291bnRlcidzIGNoaWxkX211dGV4LCBzbyBhbnkgZGVzY2VuZGFudCB0aGF0Ci0gKiBnb2VzIHRvIGV4aXQgd2lsbCBibG9jayBpbiBzeW5jX2NoaWxkX2NvdW50ZXIuCi0gKiBXaGVuIGNhbGxlZCBmcm9tIHBlcmZfcGVuZGluZ19jb3VudGVyIGl0J3MgT0sgYmVjYXVzZSBjb3VudGVyLT5jdHgKLSAqIGlzIHRoZSBjdXJyZW50IGNvbnRleHQgb24gdGhpcyBDUFUgYW5kIHByZWVtcHRpb24gaXMgZGlzYWJsZWQsCi0gKiBoZW5jZSB3ZSBjYW4ndCBnZXQgaW50byBwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQgZm9yIHRoaXMgY29udGV4dC4KLSAqLwotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2Rpc2FibGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKLQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2sgPSBjdHgtPnRhc2s7Ci0KLQlpZiAoIXRhc2spIHsKLQkJLyoKLQkJICogRGlzYWJsZSB0aGUgY291bnRlciBvbiB0aGUgY3B1IHRoYXQgaXQncyBvbgotCQkgKi8KLQkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGNvdW50ZXItPmNwdSwgX19wZXJmX2NvdW50ZXJfZGlzYWJsZSwKLQkJCQkJIGNvdW50ZXIsIDEpOwotCQlyZXR1cm47Ci0JfQotCi0gcmV0cnk6Ci0JdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9jb3VudGVyX2Rpc2FibGUsIGNvdW50ZXIpOwotCi0Jc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKLQkvKgotCSAqIElmIHRoZSBjb3VudGVyIGlzIHN0aWxsIGFjdGl2ZSwgd2UgbmVlZCB0byByZXRyeSB0aGUgY3Jvc3MtY2FsbC4KLQkgKi8KLQlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkgewotCQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Ci0JCWdvdG8gcmV0cnk7Ci0JfQotCi0JLyoKLQkgKiBTaW5jZSB3ZSBoYXZlIHRoZSBsb2NrIHRoaXMgY29udGV4dCBjYW4ndCBiZSBzY2hlZHVsZWQKLQkgKiBpbiwgc28gd2UgY2FuIGNoYW5nZSB0aGUgc3RhdGUgc2FmZWx5LgotCSAqLwotCWlmIChjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpIHsKLQkJdXBkYXRlX2dyb3VwX3RpbWVzKGNvdW50ZXIpOwotCQljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkY7Ci0JfQotCi0Jc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOwotfQotCi1zdGF0aWMgaW50Ci1jb3VudGVyX3NjaGVkX2luKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCSBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAotCQkgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCi0JCSBpbnQgY3B1KQotewotCWlmIChjb3VudGVyLT5zdGF0ZSA8PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKQotCQlyZXR1cm4gMDsKLQotCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRTsKLQljb3VudGVyLT5vbmNwdSA9IGNwdTsJLyogVE9ETzogcHV0ICdjcHUnIGludG8gY3B1Y3R4LT5jcHUgKi8KLQkvKgotCSAqIFRoZSBuZXcgc3RhdGUgbXVzdCBiZSB2aXNpYmxlIGJlZm9yZSB3ZSB0dXJuIGl0IG9uIGluIHRoZSBoYXJkd2FyZToKLQkgKi8KLQlzbXBfd21iKCk7Ci0KLQlpZiAoY291bnRlci0+cG11LT5lbmFibGUoY291bnRlcikpIHsKLQkJY291bnRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkU7Ci0JCWNvdW50ZXItPm9uY3B1ID0gLTE7Ci0JCXJldHVybiAtRUFHQUlOOwotCX0KLQotCWNvdW50ZXItPnRzdGFtcF9ydW5uaW5nICs9IGN0eC0+dGltZSAtIGNvdW50ZXItPnRzdGFtcF9zdG9wcGVkOwotCi0JaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpKQotCQljcHVjdHgtPmFjdGl2ZV9vbmNwdSsrOwotCWN0eC0+bnJfYWN0aXZlKys7Ci0KLQlpZiAoY291bnRlci0+YXR0ci5leGNsdXNpdmUpCi0JCWNwdWN0eC0+ZXhjbHVzaXZlID0gMTsKLQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgaW50Ci1ncm91cF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jb3VudGVyICpncm91cF9jb3VudGVyLAotCSAgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAotCSAgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkgICAgICAgaW50IGNwdSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCAqcGFydGlhbF9ncm91cDsKLQlpbnQgcmV0OwotCi0JaWYgKGdyb3VwX2NvdW50ZXItPnN0YXRlID09IFBFUkZfQ09VTlRFUl9TVEFURV9PRkYpCi0JCXJldHVybiAwOwotCi0JcmV0ID0gaHdfcGVyZl9ncm91cF9zY2hlZF9pbihncm91cF9jb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0IDwgMCA/IHJldCA6IDA7Ci0KLQlpZiAoY291bnRlcl9zY2hlZF9pbihncm91cF9jb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQkvKgotCSAqIFNjaGVkdWxlIGluIHNpYmxpbmdzIGFzIG9uZSBncm91cCAoaWYgYW55KToKLQkgKi8KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZncm91cF9jb3VudGVyLT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7Ci0JCWlmIChjb3VudGVyX3NjaGVkX2luKGNvdW50ZXIsIGNwdWN0eCwgY3R4LCBjcHUpKSB7Ci0JCQlwYXJ0aWFsX2dyb3VwID0gY291bnRlcjsKLQkJCWdvdG8gZ3JvdXBfZXJyb3I7Ci0JCX0KLQl9Ci0KLQlyZXR1cm4gMDsKLQotZ3JvdXBfZXJyb3I6Ci0JLyoKLQkgKiBHcm91cHMgY2FuIGJlIHNjaGVkdWxlZCBpbiBhcyBvbmUgdW5pdCBvbmx5LCBzbyB1bmRvIGFueQotCSAqIHBhcnRpYWwgZ3JvdXAgYmVmb3JlIHJldHVybmluZzoKLQkgKi8KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZncm91cF9jb3VudGVyLT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7Ci0JCWlmIChjb3VudGVyID09IHBhcnRpYWxfZ3JvdXApCi0JCQlicmVhazsKLQkJY291bnRlcl9zY2hlZF9vdXQoY291bnRlciwgY3B1Y3R4LCBjdHgpOwotCX0KLQljb3VudGVyX3NjaGVkX291dChncm91cF9jb3VudGVyLCBjcHVjdHgsIGN0eCk7Ci0KLQlyZXR1cm4gLUVBR0FJTjsKLX0KLQotLyoKLSAqIFJldHVybiAxIGZvciBhIGdyb3VwIGNvbnNpc3RpbmcgZW50aXJlbHkgb2Ygc29mdHdhcmUgY291bnRlcnMsCi0gKiAwIGlmIHRoZSBncm91cCBjb250YWlucyBhbnkgaGFyZHdhcmUgY291bnRlcnMuCi0gKi8KLXN0YXRpYyBpbnQgaXNfc29mdHdhcmVfb25seV9ncm91cChzdHJ1Y3QgcGVyZl9jb3VudGVyICpsZWFkZXIpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKLQotCWlmICghaXNfc29mdHdhcmVfY291bnRlcihsZWFkZXIpKQotCQlyZXR1cm4gMDsKLQotCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmxlYWRlci0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkKLQkJaWYgKCFpc19zb2Z0d2FyZV9jb3VudGVyKGNvdW50ZXIpKQotCQkJcmV0dXJuIDA7Ci0KLQlyZXR1cm4gMTsKLX0KLQotLyoKLSAqIFdvcmsgb3V0IHdoZXRoZXIgd2UgY2FuIHB1dCB0aGlzIGNvdW50ZXIgZ3JvdXAgb24gdGhlIENQVSBub3cuCi0gKi8KLXN0YXRpYyBpbnQgZ3JvdXBfY2FuX2dvX29uKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQkgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAotCQkJICAgaW50IGNhbl9hZGRfaHcpCi17Ci0JLyoKLQkgKiBHcm91cHMgY29uc2lzdGluZyBlbnRpcmVseSBvZiBzb2Z0d2FyZSBjb3VudGVycyBjYW4gYWx3YXlzIGdvIG9uLgotCSAqLwotCWlmIChpc19zb2Z0d2FyZV9vbmx5X2dyb3VwKGNvdW50ZXIpKQotCQlyZXR1cm4gMTsKLQkvKgotCSAqIElmIGFuIGV4Y2x1c2l2ZSBncm91cCBpcyBhbHJlYWR5IG9uLCBubyBvdGhlciBoYXJkd2FyZQotCSAqIGNvdW50ZXJzIGNhbiBnbyBvbi4KLQkgKi8KLQlpZiAoY3B1Y3R4LT5leGNsdXNpdmUpCi0JCXJldHVybiAwOwotCS8qCi0JICogSWYgdGhpcyBncm91cCBpcyBleGNsdXNpdmUgYW5kIHRoZXJlIGFyZSBhbHJlYWR5Ci0JICogY291bnRlcnMgb24gdGhlIENQVSwgaXQgY2FuJ3QgZ28gb24uCi0JICovCi0JaWYgKGNvdW50ZXItPmF0dHIuZXhjbHVzaXZlICYmIGNwdWN0eC0+YWN0aXZlX29uY3B1KQotCQlyZXR1cm4gMDsKLQkvKgotCSAqIE90aGVyd2lzZSwgdHJ5IHRvIGFkZCBpdCBpZiBhbGwgcHJldmlvdXMgZ3JvdXBzIHdlcmUgYWJsZQotCSAqIHRvIGdvIG9uLgotCSAqLwotCXJldHVybiBjYW5fYWRkX2h3OwotfQotCi1zdGF0aWMgdm9pZCBhZGRfY291bnRlcl90b19jdHgoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwKLQkJCSAgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKLXsKLQlsaXN0X2FkZF9jb3VudGVyKGNvdW50ZXIsIGN0eCk7Ci0JY291bnRlci0+dHN0YW1wX2VuYWJsZWQgPSBjdHgtPnRpbWU7Ci0JY291bnRlci0+dHN0YW1wX3J1bm5pbmcgPSBjdHgtPnRpbWU7Ci0JY291bnRlci0+dHN0YW1wX3N0b3BwZWQgPSBjdHgtPnRpbWU7Ci19Ci0KLS8qCi0gKiBDcm9zcyBDUFUgY2FsbCB0byBpbnN0YWxsIGFuZCBlbmFibGUgYSBwZXJmb3JtYW5jZSBjb3VudGVyCi0gKgotICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQKLSAqLwotc3RhdGljIHZvaWQgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCh2b2lkICppbmZvKQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaW5mbzsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpsZWFkZXIgPSBjb3VudGVyLT5ncm91cF9sZWFkZXI7Ci0JaW50IGNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKLQlpbnQgZXJyOwotCi0JLyoKLQkgKiBJZiB0aGlzIGlzIGEgdGFzayBjb250ZXh0LCB3ZSBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgaXQgaXMKLQkgKiB0aGUgY3VycmVudCB0YXNrIGNvbnRleHQgb2YgdGhpcyBjcHUuIElmIG5vdCBpdCBoYXMgYmVlbgotCSAqIHNjaGVkdWxlZCBvdXQgYmVmb3JlIHRoZSBzbXAgY2FsbCBhcnJpdmVkLgotCSAqIE9yIHBvc3NpYmx5IHRoaXMgaXMgdGhlIHJpZ2h0IGNvbnRleHQgYnV0IGl0IGlzbid0Ci0JICogb24gdGhpcyBjcHUgYmVjYXVzZSBpdCBoYWQgbm8gY291bnRlcnMuCi0JICovCi0JaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkgewotCQlpZiAoY3B1Y3R4LT50YXNrX2N0eCB8fCBjdHgtPnRhc2sgIT0gY3VycmVudCkKLQkJCXJldHVybjsKLQkJY3B1Y3R4LT50YXNrX2N0eCA9IGN0eDsKLQl9Ci0KLQlzcGluX2xvY2soJmN0eC0+bG9jayk7Ci0JY3R4LT5pc19hY3RpdmUgPSAxOwotCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKLQotCS8qCi0JICogUHJvdGVjdCB0aGUgbGlzdCBvcGVyYXRpb24gYWdhaW5zdCBOTUkgYnkgZGlzYWJsaW5nIHRoZQotCSAqIGNvdW50ZXJzIG9uIGEgZ2xvYmFsIGxldmVsLiBOT1AgZm9yIG5vbiBOTUkgYmFzZWQgY291bnRlcnMuCi0JICovCi0JcGVyZl9kaXNhYmxlKCk7Ci0KLQlhZGRfY291bnRlcl90b19jdHgoY291bnRlciwgY3R4KTsKLQotCS8qCi0JICogRG9uJ3QgcHV0IHRoZSBjb3VudGVyIG9uIGlmIGl0IGlzIGRpc2FibGVkIG9yIGlmCi0JICogaXQgaXMgaW4gYSBncm91cCBhbmQgdGhlIGdyb3VwIGlzbid0IG9uLgotCSAqLwotCWlmIChjb3VudGVyLT5zdGF0ZSAhPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUgfHwKLQkgICAgKGxlYWRlciAhPSBjb3VudGVyICYmIGxlYWRlci0+c3RhdGUgIT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkpCi0JCWdvdG8gdW5sb2NrOwotCi0JLyoKLQkgKiBBbiBleGNsdXNpdmUgY291bnRlciBjYW4ndCBnbyBvbiBpZiB0aGVyZSBhcmUgYWxyZWFkeSBhY3RpdmUKLQkgKiBoYXJkd2FyZSBjb3VudGVycywgYW5kIG5vIGhhcmR3YXJlIGNvdW50ZXIgY2FuIGdvIG9uIGlmIHRoZXJlCi0JICogaXMgYWxyZWFkeSBhbiBleGNsdXNpdmUgY291bnRlciBvbi4KLQkgKi8KLQlpZiAoIWdyb3VwX2Nhbl9nb19vbihjb3VudGVyLCBjcHVjdHgsIDEpKQotCQllcnIgPSAtRUVYSVNUOwotCWVsc2UKLQkJZXJyID0gY291bnRlcl9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwgY3B1KTsKLQotCWlmIChlcnIpIHsKLQkJLyoKLQkJICogVGhpcyBjb3VudGVyIGNvdWxkbid0IGdvIG9uLiAgSWYgaXQgaXMgaW4gYSBncm91cAotCQkgKiB0aGVuIHdlIGhhdmUgdG8gcHVsbCB0aGUgd2hvbGUgZ3JvdXAgb2ZmLgotCQkgKiBJZiB0aGUgY291bnRlciBncm91cCBpcyBwaW5uZWQgdGhlbiBwdXQgaXQgaW4gZXJyb3Igc3RhdGUuCi0JCSAqLwotCQlpZiAobGVhZGVyICE9IGNvdW50ZXIpCi0JCQlncm91cF9zY2hlZF9vdXQobGVhZGVyLCBjcHVjdHgsIGN0eCk7Ci0JCWlmIChsZWFkZXItPmF0dHIucGlubmVkKSB7Ci0JCQl1cGRhdGVfZ3JvdXBfdGltZXMobGVhZGVyKTsKLQkJCWxlYWRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfRVJST1I7Ci0JCX0KLQl9Ci0KLQlpZiAoIWVyciAmJiAhY3R4LT50YXNrICYmIGNwdWN0eC0+bWF4X3BlcnRhc2spCi0JCWNwdWN0eC0+bWF4X3BlcnRhc2stLTsKLQotIHVubG9jazoKLQlwZXJmX2VuYWJsZSgpOwotCi0Jc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Ci19Ci0KLS8qCi0gKiBBdHRhY2ggYSBwZXJmb3JtYW5jZSBjb3VudGVyIHRvIGEgY29udGV4dAotICoKLSAqIEZpcnN0IHdlIGFkZCB0aGUgY291bnRlciB0byB0aGUgbGlzdCB3aXRoIHRoZSBoYXJkd2FyZSBlbmFibGUgYml0Ci0gKiBpbiBjb3VudGVyLT5od19jb25maWcgY2xlYXJlZC4KLSAqCi0gKiBJZiB0aGUgY291bnRlciBpcyBhdHRhY2hlZCB0byBhIHRhc2sgd2hpY2ggaXMgb24gYSBDUFUgd2UgdXNlIGEgc21wCi0gKiBjYWxsIHRvIGVuYWJsZSBpdCBpbiB0aGUgdGFzayBjb250ZXh0LiBUaGUgdGFzayBtaWdodCBoYXZlIGJlZW4KLSAqIHNjaGVkdWxlZCBhd2F5LCBidXQgd2UgY2hlY2sgdGhpcyBpbiB0aGUgc21wIGNhbGwgYWdhaW4uCi0gKgotICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQuCi0gKi8KLXN0YXRpYyB2b2lkCi1wZXJmX2luc3RhbGxfaW5fY29udGV4dChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkJCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQlpbnQgY3B1KQotewotCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKLQotCWlmICghdGFzaykgewotCQkvKgotCQkgKiBQZXIgY3B1IGNvdW50ZXJzIGFyZSBpbnN0YWxsZWQgdmlhIGFuIHNtcCBjYWxsIGFuZAotCQkgKiB0aGUgaW5zdGFsbCBpcyBhbHdheXMgc3VjZXNzZnVsLgotCQkgKi8KLQkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGNwdSwgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCwKLQkJCQkJIGNvdW50ZXIsIDEpOwotCQlyZXR1cm47Ci0JfQotCi1yZXRyeToKLQl0YXNrX29uY3B1X2Z1bmN0aW9uX2NhbGwodGFzaywgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCwKLQkJCQkgY291bnRlcik7Ci0KLQlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOwotCS8qCi0JICogd2UgbmVlZCB0byByZXRyeSB0aGUgc21wIGNhbGwuCi0JICovCi0JaWYgKGN0eC0+aXNfYWN0aXZlICYmIGxpc3RfZW1wdHkoJmNvdW50ZXItPmdyb3VwX2VudHJ5KSkgewotCQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Ci0JCWdvdG8gcmV0cnk7Ci0JfQotCi0JLyoKLQkgKiBUaGUgbG9jayBwcmV2ZW50cyB0aGF0IHRoaXMgY29udGV4dCBpcyBzY2hlZHVsZWQgaW4gc28gd2UKLQkgKiBjYW4gYWRkIHRoZSBjb3VudGVyIHNhZmVseSwgaWYgaXQgdGhlIGNhbGwgYWJvdmUgZGlkIG5vdAotCSAqIHN1Y2NlZWQuCi0JICovCi0JaWYgKGxpc3RfZW1wdHkoJmNvdW50ZXItPmdyb3VwX2VudHJ5KSkKLQkJYWRkX2NvdW50ZXJfdG9fY3R4KGNvdW50ZXIsIGN0eCk7Ci0Jc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOwotfQotCi0vKgotICogUHV0IGEgY291bnRlciBpbnRvIGluYWN0aXZlIHN0YXRlIGFuZCB1cGRhdGUgdGltZSBmaWVsZHMuCi0gKiBFbmFibGluZyB0aGUgbGVhZGVyIG9mIGEgZ3JvdXAgZWZmZWN0aXZlbHkgZW5hYmxlcyBhbGwKLSAqIHRoZSBncm91cCBtZW1iZXJzIHRoYXQgYXJlbid0IGV4cGxpY2l0bHkgZGlzYWJsZWQsIHNvIHdlCi0gKiBoYXZlIHRvIHVwZGF0ZSB0aGVpciAtPnRzdGFtcF9lbmFibGVkIGFsc28uCi0gKiBOb3RlOiB0aGlzIHdvcmtzIGZvciBncm91cCBtZW1iZXJzIGFzIHdlbGwgYXMgZ3JvdXAgbGVhZGVycwotICogc2luY2UgdGhlIG5vbi1sZWFkZXIgbWVtYmVycycgc2libGluZ19saXN0cyB3aWxsIGJlIGVtcHR5LgotICovCi1zdGF0aWMgdm9pZCBfX3BlcmZfY291bnRlcl9tYXJrX2VuYWJsZWQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwKLQkJCQkJc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqc3ViOwotCi0JY291bnRlci0+c3RhdGUgPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkU7Ci0JY291bnRlci0+dHN0YW1wX2VuYWJsZWQgPSBjdHgtPnRpbWUgLSBjb3VudGVyLT50b3RhbF90aW1lX2VuYWJsZWQ7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZjb3VudGVyLT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KQotCQlpZiAoc3ViLT5zdGF0ZSA+PSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpCi0JCQlzdWItPnRzdGFtcF9lbmFibGVkID0KLQkJCQljdHgtPnRpbWUgLSBzdWItPnRvdGFsX3RpbWVfZW5hYmxlZDsKLX0KLQotLyoKLSAqIENyb3NzIENQVSBjYWxsIHRvIGVuYWJsZSBhIHBlcmZvcm1hbmNlIGNvdW50ZXIKLSAqLwotc3RhdGljIHZvaWQgX19wZXJmX2NvdW50ZXJfZW5hYmxlKHZvaWQgKmluZm8pCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IGluZm87Ci0Jc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmxlYWRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlcjsKLQlpbnQgZXJyOwotCi0JLyoKLQkgKiBJZiB0aGlzIGlzIGEgcGVyLXRhc2sgY291bnRlciwgbmVlZCB0byBjaGVjayB3aGV0aGVyIHRoaXMKLQkgKiBjb3VudGVyJ3MgdGFzayBpcyB0aGUgY3VycmVudCB0YXNrIG9uIHRoaXMgY3B1LgotCSAqLwotCWlmIChjdHgtPnRhc2sgJiYgY3B1Y3R4LT50YXNrX2N0eCAhPSBjdHgpIHsKLQkJaWYgKGNwdWN0eC0+dGFza19jdHggfHwgY3R4LT50YXNrICE9IGN1cnJlbnQpCi0JCQlyZXR1cm47Ci0JCWNwdWN0eC0+dGFza19jdHggPSBjdHg7Ci0JfQotCi0Jc3Bpbl9sb2NrKCZjdHgtPmxvY2spOwotCWN0eC0+aXNfYWN0aXZlID0gMTsKLQl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7Ci0KLQlpZiAoY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQotCQlnb3RvIHVubG9jazsKLQlfX3BlcmZfY291bnRlcl9tYXJrX2VuYWJsZWQoY291bnRlciwgY3R4KTsKLQotCS8qCi0JICogSWYgdGhlIGNvdW50ZXIgaXMgaW4gYSBncm91cCBhbmQgaXNuJ3QgdGhlIGdyb3VwIGxlYWRlciwKLQkgKiB0aGVuIGRvbid0IHB1dCBpdCBvbiB1bmxlc3MgdGhlIGdyb3VwIGlzIG9uLgotCSAqLwotCWlmIChsZWFkZXIgIT0gY291bnRlciAmJiBsZWFkZXItPnN0YXRlICE9IFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkUpCi0JCWdvdG8gdW5sb2NrOwotCi0JaWYgKCFncm91cF9jYW5fZ29fb24oY291bnRlciwgY3B1Y3R4LCAxKSkgewotCQllcnIgPSAtRUVYSVNUOwotCX0gZWxzZSB7Ci0JCXBlcmZfZGlzYWJsZSgpOwotCQlpZiAoY291bnRlciA9PSBsZWFkZXIpCi0JCQllcnIgPSBncm91cF9zY2hlZF9pbihjb3VudGVyLCBjcHVjdHgsIGN0eCwKLQkJCQkJICAgICBzbXBfcHJvY2Vzc29yX2lkKCkpOwotCQllbHNlCi0JCQllcnIgPSBjb3VudGVyX3NjaGVkX2luKGNvdW50ZXIsIGNwdWN0eCwgY3R4LAotCQkJCQkgICAgICAgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKLQkJcGVyZl9lbmFibGUoKTsKLQl9Ci0KLQlpZiAoZXJyKSB7Ci0JCS8qCi0JCSAqIElmIHRoaXMgY291bnRlciBjYW4ndCBnbyBvbiBhbmQgaXQncyBwYXJ0IG9mIGEKLQkJICogZ3JvdXAsIHRoZW4gdGhlIHdob2xlIGdyb3VwIGhhcyB0byBjb21lIG9mZi4KLQkJICovCi0JCWlmIChsZWFkZXIgIT0gY291bnRlcikKLQkJCWdyb3VwX3NjaGVkX291dChsZWFkZXIsIGNwdWN0eCwgY3R4KTsKLQkJaWYgKGxlYWRlci0+YXR0ci5waW5uZWQpIHsKLQkJCXVwZGF0ZV9ncm91cF90aW1lcyhsZWFkZXIpOwotCQkJbGVhZGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9FUlJPUjsKLQkJfQotCX0KLQotIHVubG9jazoKLQlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKLX0KLQotLyoKLSAqIEVuYWJsZSBhIGNvdW50ZXIuCi0gKgotICogSWYgY291bnRlci0+Y3R4IGlzIGEgY2xvbmVkIGNvbnRleHQsIGNhbGxlcnMgbXVzdCBtYWtlIHN1cmUgdGhhdAotICogZXZlcnkgdGFzayBzdHJ1Y3QgdGhhdCBjb3VudGVyLT5jdHgtPnRhc2sgY291bGQgcG9zc2libHkgcG9pbnQgdG8KLSAqIHJlbWFpbnMgdmFsaWQuICBUaGlzIGNvbmRpdGlvbiBpcyBzYXRpc2ZpZWQgd2hlbiBjYWxsZWQgdGhyb3VnaAotICogcGVyZl9jb3VudGVyX2Zvcl9lYWNoX2NoaWxkIG9yIHBlcmZfY291bnRlcl9mb3JfZWFjaCBhcyBkZXNjcmliZWQKLSAqIGZvciBwZXJmX2NvdW50ZXJfZGlzYWJsZS4KLSAqLwotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2VuYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OwotCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKLQotCWlmICghdGFzaykgewotCQkvKgotCQkgKiBFbmFibGUgdGhlIGNvdW50ZXIgb24gdGhlIGNwdSB0aGF0IGl0J3Mgb24KLQkJICovCi0JCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjb3VudGVyLT5jcHUsIF9fcGVyZl9jb3VudGVyX2VuYWJsZSwKLQkJCQkJIGNvdW50ZXIsIDEpOwotCQlyZXR1cm47Ci0JfQotCi0Jc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKLQlpZiAoY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQotCQlnb3RvIG91dDsKLQotCS8qCi0JICogSWYgdGhlIGNvdW50ZXIgaXMgaW4gZXJyb3Igc3RhdGUsIGNsZWFyIHRoYXQgZmlyc3QuCi0JICogVGhhdCB3YXksIGlmIHdlIHNlZSB0aGUgY291bnRlciBpbiBlcnJvciBzdGF0ZSBiZWxvdywgd2UKLQkgKiBrbm93IHRoYXQgaXQgaGFzIGdvbmUgYmFjayBpbnRvIGVycm9yIHN0YXRlLCBhcyBkaXN0aW5jdAotCSAqIGZyb20gdGhlIHRhc2sgaGF2aW5nIGJlZW4gc2NoZWR1bGVkIGF3YXkgYmVmb3JlIHRoZQotCSAqIGNyb3NzLWNhbGwgYXJyaXZlZC4KLQkgKi8KLQlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0VSUk9SKQotCQljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9PRkY7Ci0KLSByZXRyeToKLQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Ci0JdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9jb3VudGVyX2VuYWJsZSwgY291bnRlcik7Ci0KLQlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOwotCi0JLyoKLQkgKiBJZiB0aGUgY29udGV4dCBpcyBhY3RpdmUgYW5kIHRoZSBjb3VudGVyIGlzIHN0aWxsIG9mZiwKLQkgKiB3ZSBuZWVkIHRvIHJldHJ5IHRoZSBjcm9zcy1jYWxsLgotCSAqLwotCWlmIChjdHgtPmlzX2FjdGl2ZSAmJiBjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKQotCQlnb3RvIHJldHJ5OwotCi0JLyoKLQkgKiBTaW5jZSB3ZSBoYXZlIHRoZSBsb2NrIHRoaXMgY29udGV4dCBjYW4ndCBiZSBzY2hlZHVsZWQKLQkgKiBpbiwgc28gd2UgY2FuIGNoYW5nZSB0aGUgc3RhdGUgc2FmZWx5LgotCSAqLwotCWlmIChjb3VudGVyLT5zdGF0ZSA9PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGKQotCQlfX3BlcmZfY291bnRlcl9tYXJrX2VuYWJsZWQoY291bnRlciwgY3R4KTsKLQotIG91dDoKLQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Ci19Ci0KLXN0YXRpYyBpbnQgcGVyZl9jb3VudGVyX3JlZnJlc2goc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgaW50IHJlZnJlc2gpCi17Ci0JLyoKLQkgKiBub3Qgc3VwcG9ydGVkIG9uIGluaGVyaXRlZCBjb3VudGVycwotCSAqLwotCWlmIChjb3VudGVyLT5hdHRyLmluaGVyaXQpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JYXRvbWljX2FkZChyZWZyZXNoLCAmY291bnRlci0+ZXZlbnRfbGltaXQpOwotCXBlcmZfY291bnRlcl9lbmFibGUoY291bnRlcik7Ci0KLQlyZXR1cm4gMDsKLX0KLQotdm9pZCBfX3BlcmZfY291bnRlcl9zY2hlZF9vdXQoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCi0JCQkgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0KLQlzcGluX2xvY2soJmN0eC0+bG9jayk7Ci0JY3R4LT5pc19hY3RpdmUgPSAwOwotCWlmIChsaWtlbHkoIWN0eC0+bnJfY291bnRlcnMpKQotCQlnb3RvIG91dDsKLQl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7Ci0KLQlwZXJmX2Rpc2FibGUoKTsKLQlpZiAoY3R4LT5ucl9hY3RpdmUpIHsKLQkJbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgewotCQkJaWYgKGNvdW50ZXIgIT0gY291bnRlci0+Z3JvdXBfbGVhZGVyKQotCQkJCWNvdW50ZXJfc2NoZWRfb3V0KGNvdW50ZXIsIGNwdWN0eCwgY3R4KTsKLQkJCWVsc2UKLQkJCQlncm91cF9zY2hlZF9vdXQoY291bnRlciwgY3B1Y3R4LCBjdHgpOwotCQl9Ci0JfQotCXBlcmZfZW5hYmxlKCk7Ci0gb3V0OgotCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwotfQotCi0vKgotICogVGVzdCB3aGV0aGVyIHR3byBjb250ZXh0cyBhcmUgZXF1aXZhbGVudCwgaS5lLiB3aGV0aGVyIHRoZXkKLSAqIGhhdmUgYm90aCBiZWVuIGNsb25lZCBmcm9tIHRoZSBzYW1lIHZlcnNpb24gb2YgdGhlIHNhbWUgY29udGV4dAotICogYW5kIHRoZXkgYm90aCBoYXZlIHRoZSBzYW1lIG51bWJlciBvZiBlbmFibGVkIGNvdW50ZXJzLgotICogSWYgdGhlIG51bWJlciBvZiBlbmFibGVkIGNvdW50ZXJzIGlzIHRoZSBzYW1lLCB0aGVuIHRoZSBzZXQKLSAqIG9mIGVuYWJsZWQgY291bnRlcnMgc2hvdWxkIGJlIHRoZSBzYW1lLCBiZWNhdXNlIHRoZXNlIGFyZSBib3RoCi0gKiBpbmhlcml0ZWQgY29udGV4dHMsIHRoZXJlZm9yZSB3ZSBjYW4ndCBhY2Nlc3MgaW5kaXZpZHVhbCBjb3VudGVycwotICogaW4gdGhlbSBkaXJlY3RseSB3aXRoIGFuIGZkOyB3ZSBjYW4gb25seSBlbmFibGUvZGlzYWJsZSBhbGwKLSAqIGNvdW50ZXJzIHZpYSBwcmN0bCwgb3IgZW5hYmxlL2Rpc2FibGUgYWxsIGNvdW50ZXJzIGluIGEgZmFtaWx5Ci0gKiB2aWEgaW9jdGwsIHdoaWNoIHdpbGwgaGF2ZSB0aGUgc2FtZSBlZmZlY3Qgb24gYm90aCBjb250ZXh0cy4KLSAqLwotc3RhdGljIGludCBjb250ZXh0X2VxdWl2KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4MSwKLQkJCSBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDIpCi17Ci0JcmV0dXJuIGN0eDEtPnBhcmVudF9jdHggJiYgY3R4MS0+cGFyZW50X2N0eCA9PSBjdHgyLT5wYXJlbnRfY3R4Ci0JCSYmIGN0eDEtPnBhcmVudF9nZW4gPT0gY3R4Mi0+cGFyZW50X2dlbgotCQkmJiAhY3R4MS0+cGluX2NvdW50ICYmICFjdHgyLT5waW5fY291bnQ7Ci19Ci0KLXN0YXRpYyB2b2lkIF9fcGVyZl9jb3VudGVyX3JlYWQodm9pZCAqY291bnRlcik7Ci0KLXN0YXRpYyB2b2lkIF9fcGVyZl9jb3VudGVyX3N5bmNfc3RhdChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCSAgICAgc3RydWN0IHBlcmZfY291bnRlciAqbmV4dF9jb3VudGVyKQotewotCXU2NCB2YWx1ZTsKLQotCWlmICghY291bnRlci0+YXR0ci5pbmhlcml0X3N0YXQpCi0JCXJldHVybjsKLQotCS8qCi0JICogVXBkYXRlIHRoZSBjb3VudGVyIHZhbHVlLCB3ZSBjYW5ub3QgdXNlIHBlcmZfY291bnRlcl9yZWFkKCkKLQkgKiBiZWNhdXNlIHdlJ3JlIGluIHRoZSBtaWRkbGUgb2YgYSBjb250ZXh0IHN3aXRjaCBhbmQgaGF2ZSBJUlFzCi0JICogZGlzYWJsZWQsIHdoaWNoIHVwc2V0cyBzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoKSwgaG93ZXZlcgotCSAqIHdlIGtub3cgdGhlIGNvdW50ZXIgbXVzdCBiZSBvbiB0aGUgY3VycmVudCBDUFUsIHRoZXJlZm9yZSB3ZQotCSAqIGRvbid0IG5lZWQgdG8gdXNlIGl0LgotCSAqLwotCXN3aXRjaCAoY291bnRlci0+c3RhdGUpIHsKLQljYXNlIFBFUkZfQ09VTlRFUl9TVEFURV9BQ1RJVkU6Ci0JCV9fcGVyZl9jb3VudGVyX3JlYWQoY291bnRlcik7Ci0JCWJyZWFrOwotCi0JY2FzZSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkU6Ci0JCXVwZGF0ZV9jb3VudGVyX3RpbWVzKGNvdW50ZXIpOwotCQlicmVhazsKLQotCWRlZmF1bHQ6Ci0JCWJyZWFrOwotCX0KLQotCS8qCi0JICogSW4gb3JkZXIgdG8ga2VlcCBwZXItdGFzayBzdGF0cyByZWxpYWJsZSB3ZSBuZWVkIHRvIGZsaXAgdGhlIGNvdW50ZXIKLQkgKiB2YWx1ZXMgd2hlbiB3ZSBmbGlwIHRoZSBjb250ZXh0cy4KLQkgKi8KLQl2YWx1ZSA9IGF0b21pYzY0X3JlYWQoJm5leHRfY291bnRlci0+Y291bnQpOwotCXZhbHVlID0gYXRvbWljNjRfeGNoZygmY291bnRlci0+Y291bnQsIHZhbHVlKTsKLQlhdG9taWM2NF9zZXQoJm5leHRfY291bnRlci0+Y291bnQsIHZhbHVlKTsKLQotCXN3YXAoY291bnRlci0+dG90YWxfdGltZV9lbmFibGVkLCBuZXh0X2NvdW50ZXItPnRvdGFsX3RpbWVfZW5hYmxlZCk7Ci0Jc3dhcChjb3VudGVyLT50b3RhbF90aW1lX3J1bm5pbmcsIG5leHRfY291bnRlci0+dG90YWxfdGltZV9ydW5uaW5nKTsKLQotCS8qCi0JICogU2luY2Ugd2Ugc3dpenpsZWQgdGhlIHZhbHVlcywgdXBkYXRlIHRoZSB1c2VyIHZpc2libGUgZGF0YSB0b28uCi0JICovCi0JcGVyZl9jb3VudGVyX3VwZGF0ZV91c2VycGFnZShjb3VudGVyKTsKLQlwZXJmX2NvdW50ZXJfdXBkYXRlX3VzZXJwYWdlKG5leHRfY291bnRlcik7Ci19Ci0KLSNkZWZpbmUgbGlzdF9uZXh0X2VudHJ5KHBvcywgbWVtYmVyKSBcCi0JbGlzdF9lbnRyeShwb3MtPm1lbWJlci5uZXh0LCB0eXBlb2YoKnBvcyksIG1lbWJlcikKLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX3N5bmNfc3RhdChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkJCQkgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKm5leHRfY3R4KQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsICpuZXh0X2NvdW50ZXI7Ci0KLQlpZiAoIWN0eC0+bnJfc3RhdCkKLQkJcmV0dXJuOwotCi0JY291bnRlciA9IGxpc3RfZmlyc3RfZW50cnkoJmN0eC0+ZXZlbnRfbGlzdCwKLQkJCQkgICBzdHJ1Y3QgcGVyZl9jb3VudGVyLCBldmVudF9lbnRyeSk7Ci0KLQluZXh0X2NvdW50ZXIgPSBsaXN0X2ZpcnN0X2VudHJ5KCZuZXh0X2N0eC0+ZXZlbnRfbGlzdCwKLQkJCQkJc3RydWN0IHBlcmZfY291bnRlciwgZXZlbnRfZW50cnkpOwotCi0Jd2hpbGUgKCZjb3VudGVyLT5ldmVudF9lbnRyeSAhPSAmY3R4LT5ldmVudF9saXN0ICYmCi0JICAgICAgICZuZXh0X2NvdW50ZXItPmV2ZW50X2VudHJ5ICE9ICZuZXh0X2N0eC0+ZXZlbnRfbGlzdCkgewotCi0JCV9fcGVyZl9jb3VudGVyX3N5bmNfc3RhdChjb3VudGVyLCBuZXh0X2NvdW50ZXIpOwotCi0JCWNvdW50ZXIgPSBsaXN0X25leHRfZW50cnkoY291bnRlciwgZXZlbnRfZW50cnkpOwotCQluZXh0X2NvdW50ZXIgPSBsaXN0X25leHRfZW50cnkobmV4dF9jb3VudGVyLCBldmVudF9lbnRyeSk7Ci0JfQotfQotCi0vKgotICogQ2FsbGVkIGZyb20gc2NoZWR1bGVyIHRvIHJlbW92ZSB0aGUgY291bnRlcnMgb2YgdGhlIGN1cnJlbnQgdGFzaywKLSAqIHdpdGggaW50ZXJydXB0cyBkaXNhYmxlZC4KLSAqCi0gKiBXZSBzdG9wIGVhY2ggY291bnRlciBhbmQgdXBkYXRlIHRoZSBjb3VudGVyIHZhbHVlIGluIGNvdW50ZXItPmNvdW50LgotICoKLSAqIFRoaXMgZG9lcyBub3QgcHJvdGVjdCB1cyBhZ2FpbnN0IE5NSSwgYnV0IGRpc2FibGUoKQotICogc2V0cyB0aGUgZGlzYWJsZWQgYml0IGluIHRoZSBjb250cm9sIGZpZWxkIG9mIGNvdW50ZXIgX2JlZm9yZV8KLSAqIGFjY2Vzc2luZyB0aGUgY291bnRlciBjb250cm9sIHJlZ2lzdGVyLiBJZiBhIE5NSSBoaXRzLCB0aGVuIGl0IHdpbGwKLSAqIG5vdCByZXN0YXJ0IHRoZSBjb3VudGVyLgotICovCi12b2lkIHBlcmZfY291bnRlcl90YXNrX3NjaGVkX291dChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssCi0JCQkJIHN0cnVjdCB0YXNrX3N0cnVjdCAqbmV4dCwgaW50IGNwdSkKLXsKLQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IHRhc2stPnBlcmZfY291bnRlcl9jdHhwOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqbmV4dF9jdHg7Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpwYXJlbnQ7Ci0Jc3RydWN0IHB0X3JlZ3MgKnJlZ3M7Ci0JaW50IGRvX3N3aXRjaCA9IDE7Ci0KLQlyZWdzID0gdGFza19wdF9yZWdzKHRhc2spOwotCXBlcmZfc3djb3VudGVyX2V2ZW50KFBFUkZfQ09VTlRfU1dfQ09OVEVYVF9TV0lUQ0hFUywgMSwgMSwgcmVncywgMCk7Ci0KLQlpZiAobGlrZWx5KCFjdHggfHwgIWNwdWN0eC0+dGFza19jdHgpKQotCQlyZXR1cm47Ci0KLQl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0JcGFyZW50ID0gcmN1X2RlcmVmZXJlbmNlKGN0eC0+cGFyZW50X2N0eCk7Ci0JbmV4dF9jdHggPSBuZXh0LT5wZXJmX2NvdW50ZXJfY3R4cDsKLQlpZiAocGFyZW50ICYmIG5leHRfY3R4ICYmCi0JICAgIHJjdV9kZXJlZmVyZW5jZShuZXh0X2N0eC0+cGFyZW50X2N0eCkgPT0gcGFyZW50KSB7Ci0JCS8qCi0JCSAqIExvb2tzIGxpa2UgdGhlIHR3byBjb250ZXh0cyBhcmUgY2xvbmVzLCBzbyB3ZSBtaWdodCBiZQotCQkgKiBhYmxlIHRvIG9wdGltaXplIHRoZSBjb250ZXh0IHN3aXRjaC4gIFdlIGxvY2sgYm90aAotCQkgKiBjb250ZXh0cyBhbmQgY2hlY2sgdGhhdCB0aGV5IGFyZSBjbG9uZXMgdW5kZXIgdGhlCi0JCSAqIGxvY2sgKGluY2x1ZGluZyByZS1jaGVja2luZyB0aGF0IG5laXRoZXIgaGFzIGJlZW4KLQkJICogdW5jbG9uZWQgaW4gdGhlIG1lYW50aW1lKS4gIEl0IGRvZXNuJ3QgbWF0dGVyIHdoaWNoCi0JCSAqIG9yZGVyIHdlIHRha2UgdGhlIGxvY2tzIGJlY2F1c2Ugbm8gb3RoZXIgY3B1IGNvdWxkCi0JCSAqIGJlIHRyeWluZyB0byBsb2NrIGJvdGggb2YgdGhlc2UgdGFza3MuCi0JCSAqLwotCQlzcGluX2xvY2soJmN0eC0+bG9jayk7Ci0JCXNwaW5fbG9ja19uZXN0ZWQoJm5leHRfY3R4LT5sb2NrLCBTSU5HTEVfREVQVEhfTkVTVElORyk7Ci0JCWlmIChjb250ZXh0X2VxdWl2KGN0eCwgbmV4dF9jdHgpKSB7Ci0JCQkvKgotCQkJICogWFhYIGRvIHdlIG5lZWQgYSBtZW1vcnkgYmFycmllciBvZiBzb3J0cwotCQkJICogd3J0IHRvIHJjdV9kZXJlZmVyZW5jZSgpIG9mIHBlcmZfY291bnRlcl9jdHhwCi0JCQkgKi8KLQkJCXRhc2stPnBlcmZfY291bnRlcl9jdHhwID0gbmV4dF9jdHg7Ci0JCQluZXh0LT5wZXJmX2NvdW50ZXJfY3R4cCA9IGN0eDsKLQkJCWN0eC0+dGFzayA9IG5leHQ7Ci0JCQluZXh0X2N0eC0+dGFzayA9IHRhc2s7Ci0JCQlkb19zd2l0Y2ggPSAwOwotCi0JCQlwZXJmX2NvdW50ZXJfc3luY19zdGF0KGN0eCwgbmV4dF9jdHgpOwotCQl9Ci0JCXNwaW5fdW5sb2NrKCZuZXh0X2N0eC0+bG9jayk7Ci0JCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwotCX0KLQlyY3VfcmVhZF91bmxvY2soKTsKLQotCWlmIChkb19zd2l0Y2gpIHsKLQkJX19wZXJmX2NvdW50ZXJfc2NoZWRfb3V0KGN0eCwgY3B1Y3R4KTsKLQkJY3B1Y3R4LT50YXNrX2N0eCA9IE5VTEw7Ci0JfQotfQotCi0vKgotICogQ2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZAotICovCi1zdGF0aWMgdm9pZCBfX3BlcmZfY291bnRlcl90YXNrX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKLXsKLQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJl9fZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7Ci0KLQlpZiAoIWNwdWN0eC0+dGFza19jdHgpCi0JCXJldHVybjsKLQotCWlmIChXQVJOX09OX09OQ0UoY3R4ICE9IGNwdWN0eC0+dGFza19jdHgpKQotCQlyZXR1cm47Ci0KLQlfX3BlcmZfY291bnRlcl9zY2hlZF9vdXQoY3R4LCBjcHVjdHgpOwotCWNwdWN0eC0+dGFza19jdHggPSBOVUxMOwotfQotCi0vKgotICogQ2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZAotICovCi1zdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfY3B1X3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQotewotCV9fcGVyZl9jb3VudGVyX3NjaGVkX291dCgmY3B1Y3R4LT5jdHgsIGNwdWN0eCk7Ci19Ci0KLXN0YXRpYyB2b2lkCi1fX3BlcmZfY291bnRlcl9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkJCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsIGludCBjcHUpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKLQlpbnQgY2FuX2FkZF9odyA9IDE7Ci0KLQlzcGluX2xvY2soJmN0eC0+bG9jayk7Ci0JY3R4LT5pc19hY3RpdmUgPSAxOwotCWlmIChsaWtlbHkoIWN0eC0+bnJfY291bnRlcnMpKQotCQlnb3RvIG91dDsKLQotCWN0eC0+dGltZXN0YW1wID0gcGVyZl9jbG9jaygpOwotCi0JcGVyZl9kaXNhYmxlKCk7Ci0KLQkvKgotCSAqIEZpcnN0IGdvIHRocm91Z2ggdGhlIGxpc3QgYW5kIHB1dCBvbiBhbnkgcGlubmVkIGdyb3VwcwotCSAqIGluIG9yZGVyIHRvIGdpdmUgdGhlbSB0aGUgYmVzdCBjaGFuY2Ugb2YgZ29pbmcgb24uCi0JICovCi0JbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgewotCQlpZiAoY291bnRlci0+c3RhdGUgPD0gUEVSRl9DT1VOVEVSX1NUQVRFX09GRiB8fAotCQkgICAgIWNvdW50ZXItPmF0dHIucGlubmVkKQotCQkJY29udGludWU7Ci0JCWlmIChjb3VudGVyLT5jcHUgIT0gLTEgJiYgY291bnRlci0+Y3B1ICE9IGNwdSkKLQkJCWNvbnRpbnVlOwotCi0JCWlmIChjb3VudGVyICE9IGNvdW50ZXItPmdyb3VwX2xlYWRlcikKLQkJCWNvdW50ZXJfc2NoZWRfaW4oY291bnRlciwgY3B1Y3R4LCBjdHgsIGNwdSk7Ci0JCWVsc2UgewotCQkJaWYgKGdyb3VwX2Nhbl9nb19vbihjb3VudGVyLCBjcHVjdHgsIDEpKQotCQkJCWdyb3VwX3NjaGVkX2luKGNvdW50ZXIsIGNwdWN0eCwgY3R4LCBjcHUpOwotCQl9Ci0KLQkJLyoKLQkJICogSWYgdGhpcyBwaW5uZWQgZ3JvdXAgaGFzbid0IGJlZW4gc2NoZWR1bGVkLAotCQkgKiBwdXQgaXQgaW4gZXJyb3Igc3RhdGUuCi0JCSAqLwotCQlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKSB7Ci0JCQl1cGRhdGVfZ3JvdXBfdGltZXMoY291bnRlcik7Ci0JCQljb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9FUlJPUjsKLQkJfQotCX0KLQotCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKLQkJLyoKLQkJICogSWdub3JlIGNvdW50ZXJzIGluIE9GRiBvciBFUlJPUiBzdGF0ZSwgYW5kCi0JCSAqIGlnbm9yZSBwaW5uZWQgY291bnRlcnMgc2luY2Ugd2UgZGlkIHRoZW0gYWxyZWFkeS4KLQkJICovCi0JCWlmIChjb3VudGVyLT5zdGF0ZSA8PSBQRVJGX0NPVU5URVJfU1RBVEVfT0ZGIHx8Ci0JCSAgICBjb3VudGVyLT5hdHRyLnBpbm5lZCkKLQkJCWNvbnRpbnVlOwotCi0JCS8qCi0JCSAqIExpc3RlbiB0byB0aGUgJ2NwdScgc2NoZWR1bGluZyBmaWx0ZXIgY29uc3RyYWludAotCQkgKiBvZiBjb3VudGVyczoKLQkJICovCi0JCWlmIChjb3VudGVyLT5jcHUgIT0gLTEgJiYgY291bnRlci0+Y3B1ICE9IGNwdSkKLQkJCWNvbnRpbnVlOwotCi0JCWlmIChjb3VudGVyICE9IGNvdW50ZXItPmdyb3VwX2xlYWRlcikgewotCQkJaWYgKGNvdW50ZXJfc2NoZWRfaW4oY291bnRlciwgY3B1Y3R4LCBjdHgsIGNwdSkpCi0JCQkJY2FuX2FkZF9odyA9IDA7Ci0JCX0gZWxzZSB7Ci0JCQlpZiAoZ3JvdXBfY2FuX2dvX29uKGNvdW50ZXIsIGNwdWN0eCwgY2FuX2FkZF9odykpIHsKLQkJCQlpZiAoZ3JvdXBfc2NoZWRfaW4oY291bnRlciwgY3B1Y3R4LCBjdHgsIGNwdSkpCi0JCQkJCWNhbl9hZGRfaHcgPSAwOwotCQkJfQotCQl9Ci0JfQotCXBlcmZfZW5hYmxlKCk7Ci0gb3V0OgotCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwotfQotCi0vKgotICogQ2FsbGVkIGZyb20gc2NoZWR1bGVyIHRvIGFkZCB0aGUgY291bnRlcnMgb2YgdGhlIGN1cnJlbnQgdGFzawotICogd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkLgotICoKLSAqIFdlIHJlc3RvcmUgdGhlIGNvdW50ZXIgdmFsdWUgYW5kIHRoZW4gZW5hYmxlIGl0LgotICoKLSAqIFRoaXMgZG9lcyBub3QgcHJvdGVjdCB1cyBhZ2FpbnN0IE5NSSwgYnV0IGVuYWJsZSgpCi0gKiBzZXRzIHRoZSBlbmFibGVkIGJpdCBpbiB0aGUgY29udHJvbCBmaWVsZCBvZiBjb3VudGVyIF9iZWZvcmVfCi0gKiBhY2Nlc3NpbmcgdGhlIGNvdW50ZXIgY29udHJvbCByZWdpc3Rlci4gSWYgYSBOTUkgaGl0cywgdGhlbiBpdCB3aWxsCi0gKiBrZWVwIHRoZSBjb3VudGVyIHJ1bm5pbmcuCi0gKi8KLXZvaWQgcGVyZl9jb3VudGVyX3Rhc2tfc2NoZWRfaW4oc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLCBpbnQgY3B1KQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gdGFzay0+cGVyZl9jb3VudGVyX2N0eHA7Ci0KLQlpZiAobGlrZWx5KCFjdHgpKQotCQlyZXR1cm47Ci0JaWYgKGNwdWN0eC0+dGFza19jdHggPT0gY3R4KQotCQlyZXR1cm47Ci0JX19wZXJmX2NvdW50ZXJfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIGNwdSk7Ci0JY3B1Y3R4LT50YXNrX2N0eCA9IGN0eDsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2NwdV9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LCBpbnQgY3B1KQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gJmNwdWN0eC0+Y3R4OwotCi0JX19wZXJmX2NvdW50ZXJfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIGNwdSk7Ci19Ci0KLSNkZWZpbmUgTUFYX0lOVEVSUlVQVFMgKH4wVUxMKQotCi1zdGF0aWMgdm9pZCBwZXJmX2xvZ190aHJvdHRsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgZW5hYmxlKTsKLQotc3RhdGljIHZvaWQgcGVyZl9hZGp1c3RfcGVyaW9kKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHU2NCBldmVudHMpCi17Ci0Jc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OwotCXU2NCBwZXJpb2QsIHNhbXBsZV9wZXJpb2Q7Ci0JczY0IGRlbHRhOwotCi0JZXZlbnRzICo9IGh3Yy0+c2FtcGxlX3BlcmlvZDsKLQlwZXJpb2QgPSBkaXY2NF91NjQoZXZlbnRzLCBjb3VudGVyLT5hdHRyLnNhbXBsZV9mcmVxKTsKLQotCWRlbHRhID0gKHM2NCkocGVyaW9kIC0gaHdjLT5zYW1wbGVfcGVyaW9kKTsKLQlkZWx0YSA9IChkZWx0YSArIDcpIC8gODsgLyogbG93IHBhc3MgZmlsdGVyICovCi0KLQlzYW1wbGVfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kICsgZGVsdGE7Ci0KLQlpZiAoIXNhbXBsZV9wZXJpb2QpCi0JCXNhbXBsZV9wZXJpb2QgPSAxOwotCi0JaHdjLT5zYW1wbGVfcGVyaW9kID0gc2FtcGxlX3BlcmlvZDsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jdHhfYWRqdXN0X2ZyZXEoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKLQlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2M7Ci0JdTY0IGludGVycnVwdHMsIGZyZXE7Ci0KLQlzcGluX2xvY2soJmN0eC0+bG9jayk7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShjb3VudGVyLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgewotCQlpZiAoY291bnRlci0+c3RhdGUgIT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKLQkJCWNvbnRpbnVlOwotCi0JCWh3YyA9ICZjb3VudGVyLT5odzsKLQotCQlpbnRlcnJ1cHRzID0gaHdjLT5pbnRlcnJ1cHRzOwotCQlod2MtPmludGVycnVwdHMgPSAwOwotCi0JCS8qCi0JCSAqIHVudGhyb3R0bGUgY291bnRlcnMgb24gdGhlIHRpY2sKLQkJICovCi0JCWlmIChpbnRlcnJ1cHRzID09IE1BWF9JTlRFUlJVUFRTKSB7Ci0JCQlwZXJmX2xvZ190aHJvdHRsZShjb3VudGVyLCAxKTsKLQkJCWNvdW50ZXItPnBtdS0+dW50aHJvdHRsZShjb3VudGVyKTsKLQkJCWludGVycnVwdHMgPSAyKnN5c2N0bF9wZXJmX2NvdW50ZXJfc2FtcGxlX3JhdGUvSFo7Ci0JCX0KLQotCQlpZiAoIWNvdW50ZXItPmF0dHIuZnJlcSB8fCAhY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcSkKLQkJCWNvbnRpbnVlOwotCi0JCS8qCi0JCSAqIGlmIHRoZSBzcGVjaWZpZWQgZnJlcSA8IEhaIHRoZW4gd2UgbmVlZCB0byBza2lwIHRpY2tzCi0JCSAqLwotCQlpZiAoY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcSA8IEhaKSB7Ci0JCQlmcmVxID0gY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcTsKLQotCQkJaHdjLT5mcmVxX2NvdW50ICs9IGZyZXE7Ci0JCQlod2MtPmZyZXFfaW50ZXJydXB0cyArPSBpbnRlcnJ1cHRzOwotCi0JCQlpZiAoaHdjLT5mcmVxX2NvdW50IDwgSFopCi0JCQkJY29udGludWU7Ci0KLQkJCWludGVycnVwdHMgPSBod2MtPmZyZXFfaW50ZXJydXB0czsKLQkJCWh3Yy0+ZnJlcV9pbnRlcnJ1cHRzID0gMDsKLQkJCWh3Yy0+ZnJlcV9jb3VudCAtPSBIWjsKLQkJfSBlbHNlCi0JCQlmcmVxID0gSFo7Ci0KLQkJcGVyZl9hZGp1c3RfcGVyaW9kKGNvdW50ZXIsIGZyZXEgKiBpbnRlcnJ1cHRzKTsKLQotCQkvKgotCQkgKiBJbiBvcmRlciB0byBhdm9pZCBiZWluZyBzdGFsbGVkIGJ5IGFuIChhY2NpZGVudGFsKSBodWdlCi0JCSAqIHNhbXBsZSBwZXJpb2QsIGZvcmNlIHJlc2V0IHRoZSBzYW1wbGUgcGVyaW9kIGlmIHdlIGRpZG4ndAotCQkgKiBnZXQgYW55IGV2ZW50cyBpbiB0aGlzIGZyZXEgcGVyaW9kLgotCQkgKi8KLQkJaWYgKCFpbnRlcnJ1cHRzKSB7Ci0JCQlwZXJmX2Rpc2FibGUoKTsKLQkJCWNvdW50ZXItPnBtdS0+ZGlzYWJsZShjb3VudGVyKTsKLQkJCWF0b21pYzY0X3NldCgmaHdjLT5wZXJpb2RfbGVmdCwgMCk7Ci0JCQljb3VudGVyLT5wbXUtPmVuYWJsZShjb3VudGVyKTsKLQkJCXBlcmZfZW5hYmxlKCk7Ci0JCX0KLQl9Ci0Jc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Ci19Ci0KLS8qCi0gKiBSb3VuZC1yb2JpbiBhIGNvbnRleHQncyBjb3VudGVyczoKLSAqLwotc3RhdGljIHZvaWQgcm90YXRlX2N0eChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCi0JaWYgKCFjdHgtPm5yX2NvdW50ZXJzKQotCQlyZXR1cm47Ci0KLQlzcGluX2xvY2soJmN0eC0+bG9jayk7Ci0JLyoKLQkgKiBSb3RhdGUgdGhlIGZpcnN0IGVudHJ5IGxhc3QgKHdvcmtzIGp1c3QgZmluZSBmb3IgZ3JvdXAgY291bnRlcnMgdG9vKToKLQkgKi8KLQlwZXJmX2Rpc2FibGUoKTsKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdHgtPmdyb3VwX2xpc3QsIGdyb3VwX2VudHJ5KSB7Ci0JCWxpc3RfbW92ZV90YWlsKCZjb3VudGVyLT5ncm91cF9lbnRyeSwgJmN0eC0+Z3JvdXBfbGlzdCk7Ci0JCWJyZWFrOwotCX0KLQlwZXJmX2VuYWJsZSgpOwotCi0Jc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Ci19Ci0KLXZvaWQgcGVyZl9jb3VudGVyX3Rhc2tfdGljayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKmN1cnIsIGludCBjcHUpCi17Ci0Jc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKLQotCWlmICghYXRvbWljX3JlYWQoJm5yX2NvdW50ZXJzKSkKLQkJcmV0dXJuOwotCi0JY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKLQljdHggPSBjdXJyLT5wZXJmX2NvdW50ZXJfY3R4cDsKLQotCXBlcmZfY3R4X2FkanVzdF9mcmVxKCZjcHVjdHgtPmN0eCk7Ci0JaWYgKGN0eCkKLQkJcGVyZl9jdHhfYWRqdXN0X2ZyZXEoY3R4KTsKLQotCXBlcmZfY291bnRlcl9jcHVfc2NoZWRfb3V0KGNwdWN0eCk7Ci0JaWYgKGN0eCkKLQkJX19wZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQoY3R4KTsKLQotCXJvdGF0ZV9jdHgoJmNwdWN0eC0+Y3R4KTsKLQlpZiAoY3R4KQotCQlyb3RhdGVfY3R4KGN0eCk7Ci0KLQlwZXJmX2NvdW50ZXJfY3B1X3NjaGVkX2luKGNwdWN0eCwgY3B1KTsKLQlpZiAoY3R4KQotCQlwZXJmX2NvdW50ZXJfdGFza19zY2hlZF9pbihjdXJyLCBjcHUpOwotfQotCi0vKgotICogRW5hYmxlIGFsbCBvZiBhIHRhc2sncyBjb3VudGVycyB0aGF0IGhhdmUgYmVlbiBtYXJrZWQgZW5hYmxlLW9uLWV4ZWMuCi0gKiBUaGlzIGV4cGVjdHMgdGFzayA9PSBjdXJyZW50LgotICovCi1zdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfZW5hYmxlX29uX2V4ZWMoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0JdW5zaWduZWQgbG9uZyBmbGFnczsKLQlpbnQgZW5hYmxlZCA9IDA7Ci0KLQlsb2NhbF9pcnFfc2F2ZShmbGFncyk7Ci0JY3R4ID0gdGFzay0+cGVyZl9jb3VudGVyX2N0eHA7Ci0JaWYgKCFjdHggfHwgIWN0eC0+bnJfY291bnRlcnMpCi0JCWdvdG8gb3V0OwotCi0JX19wZXJmX2NvdW50ZXJfdGFza19zY2hlZF9vdXQoY3R4KTsKLQotCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKLQotCWxpc3RfZm9yX2VhY2hfZW50cnkoY291bnRlciwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKLQkJaWYgKCFjb3VudGVyLT5hdHRyLmVuYWJsZV9vbl9leGVjKQotCQkJY29udGludWU7Ci0JCWNvdW50ZXItPmF0dHIuZW5hYmxlX29uX2V4ZWMgPSAwOwotCQlpZiAoY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQotCQkJY29udGludWU7Ci0JCV9fcGVyZl9jb3VudGVyX21hcmtfZW5hYmxlZChjb3VudGVyLCBjdHgpOwotCQllbmFibGVkID0gMTsKLQl9Ci0KLQkvKgotCSAqIFVuY2xvbmUgdGhpcyBjb250ZXh0IGlmIHdlIGVuYWJsZWQgYW55IGNvdW50ZXIuCi0JICovCi0JaWYgKGVuYWJsZWQpCi0JCXVuY2xvbmVfY3R4KGN0eCk7Ci0KLQlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKLQotCXBlcmZfY291bnRlcl90YXNrX3NjaGVkX2luKHRhc2ssIHNtcF9wcm9jZXNzb3JfaWQoKSk7Ci0gb3V0OgotCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKLX0KLQotLyoKLSAqIENyb3NzIENQVSBjYWxsIHRvIHJlYWQgdGhlIGhhcmR3YXJlIGNvdW50ZXIKLSAqLwotc3RhdGljIHZvaWQgX19wZXJmX2NvdW50ZXJfcmVhZCh2b2lkICppbmZvKQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gaW5mbzsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCi0JLyoKLQkgKiBJZiB0aGlzIGlzIGEgdGFzayBjb250ZXh0LCB3ZSBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgaXQgaXMKLQkgKiB0aGUgY3VycmVudCB0YXNrIGNvbnRleHQgb2YgdGhpcyBjcHUuICBJZiBub3QgaXQgaGFzIGJlZW4KLQkgKiBzY2hlZHVsZWQgb3V0IGJlZm9yZSB0aGUgc21wIGNhbGwgYXJyaXZlZC4gIEluIHRoYXQgY2FzZQotCSAqIGNvdW50ZXItPmNvdW50IHdvdWxkIGhhdmUgYmVlbiB1cGRhdGVkIHRvIGEgcmVjZW50IHNhbXBsZQotCSAqIHdoZW4gdGhlIGNvdW50ZXIgd2FzIHNjaGVkdWxlZCBvdXQuCi0JICovCi0JaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkKLQkJcmV0dXJuOwotCi0JbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwotCWlmIChjdHgtPmlzX2FjdGl2ZSkKLQkJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOwotCWNvdW50ZXItPnBtdS0+cmVhZChjb3VudGVyKTsKLQl1cGRhdGVfY291bnRlcl90aW1lcyhjb3VudGVyKTsKLQlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Ci19Ci0KLXN0YXRpYyB1NjQgcGVyZl9jb3VudGVyX3JlYWQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQkvKgotCSAqIElmIGNvdW50ZXIgaXMgZW5hYmxlZCBhbmQgY3VycmVudGx5IGFjdGl2ZSBvbiBhIENQVSwgdXBkYXRlIHRoZQotCSAqIHZhbHVlIGluIHRoZSBjb3VudGVyIHN0cnVjdHVyZToKLQkgKi8KLQlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkgewotCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoY291bnRlci0+b25jcHUsCi0JCQkJCSBfX3BlcmZfY291bnRlcl9yZWFkLCBjb3VudGVyLCAxKTsKLQl9IGVsc2UgaWYgKGNvdW50ZXItPnN0YXRlID09IFBFUkZfQ09VTlRFUl9TVEFURV9JTkFDVElWRSkgewotCQl1cGRhdGVfY291bnRlcl90aW1lcyhjb3VudGVyKTsKLQl9Ci0KLQlyZXR1cm4gYXRvbWljNjRfcmVhZCgmY291bnRlci0+Y291bnQpOwotfQotCi0vKgotICogSW5pdGlhbGl6ZSB0aGUgcGVyZl9jb3VudGVyIGNvbnRleHQgaW4gYSB0YXNrX3N0cnVjdDoKLSAqLwotc3RhdGljIHZvaWQKLV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkJCSAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCi17Ci0JbWVtc2V0KGN0eCwgMCwgc2l6ZW9mKCpjdHgpKTsKLQlzcGluX2xvY2tfaW5pdCgmY3R4LT5sb2NrKTsKLQltdXRleF9pbml0KCZjdHgtPm11dGV4KTsKLQlJTklUX0xJU1RfSEVBRCgmY3R4LT5ncm91cF9saXN0KTsKLQlJTklUX0xJU1RfSEVBRCgmY3R4LT5ldmVudF9saXN0KTsKLQlhdG9taWNfc2V0KCZjdHgtPnJlZmNvdW50LCAxKTsKLQljdHgtPnRhc2sgPSB0YXNrOwotfQotCi1zdGF0aWMgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpmaW5kX2dldF9jb250ZXh0KHBpZF90IHBpZCwgaW50IGNwdSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eDsKLQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OwotCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzazsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCWludCBlcnI7Ci0KLQkvKgotCSAqIElmIGNwdSBpcyBub3QgYSB3aWxkY2FyZCB0aGVuIHRoaXMgaXMgYSBwZXJjcHUgY291bnRlcjoKLQkgKi8KLQlpZiAoY3B1ICE9IC0xKSB7Ci0JCS8qIE11c3QgYmUgcm9vdCB0byBvcGVyYXRlIG9uIGEgQ1BVIGNvdW50ZXI6ICovCi0JCWlmIChwZXJmX3BhcmFub2lkX2NwdSgpICYmICFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQotCQkJcmV0dXJuIEVSUl9QVFIoLUVBQ0NFUyk7Ci0KLQkJaWYgKGNwdSA8IDAgfHwgY3B1ID4gbnVtX3Bvc3NpYmxlX2NwdXMoKSkKLQkJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwotCi0JCS8qCi0JCSAqIFdlIGNvdWxkIGJlIGNsZXZlciBhbmQgYWxsb3cgdG8gYXR0YWNoIGEgY291bnRlciB0byBhbgotCQkgKiBvZmZsaW5lIENQVSBhbmQgYWN0aXZhdGUgaXQgd2hlbiB0aGUgQ1BVIGNvbWVzIHVwLCBidXQKLQkJICogdGhhdCdzIGZvciBsYXRlci4KLQkJICovCi0JCWlmICghY3B1X2lzc2V0KGNwdSwgY3B1X29ubGluZV9tYXApKQotCQkJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7Ci0KLQkJY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKLQkJY3R4ID0gJmNwdWN0eC0+Y3R4OwotCQlnZXRfY3R4KGN0eCk7Ci0KLQkJcmV0dXJuIGN0eDsKLQl9Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0JaWYgKCFwaWQpCi0JCXRhc2sgPSBjdXJyZW50OwotCWVsc2UKLQkJdGFzayA9IGZpbmRfdGFza19ieV92cGlkKHBpZCk7Ci0JaWYgKHRhc2spCi0JCWdldF90YXNrX3N0cnVjdCh0YXNrKTsKLQlyY3VfcmVhZF91bmxvY2soKTsKLQotCWlmICghdGFzaykKLQkJcmV0dXJuIEVSUl9QVFIoLUVTUkNIKTsKLQotCS8qCi0JICogQ2FuJ3QgYXR0YWNoIGNvdW50ZXJzIHRvIGEgZHlpbmcgdGFzay4KLQkgKi8KLQllcnIgPSAtRVNSQ0g7Ci0JaWYgKHRhc2stPmZsYWdzICYgUEZfRVhJVElORykKLQkJZ290byBlcnJvdXQ7Ci0KLQkvKiBSZXVzZSBwdHJhY2UgcGVybWlzc2lvbiBjaGVja3MgZm9yIG5vdy4gKi8KLQllcnIgPSAtRUFDQ0VTOwotCWlmICghcHRyYWNlX21heV9hY2Nlc3ModGFzaywgUFRSQUNFX01PREVfUkVBRCkpCi0JCWdvdG8gZXJyb3V0OwotCi0gcmV0cnk6Ci0JY3R4ID0gcGVyZl9sb2NrX3Rhc2tfY29udGV4dCh0YXNrLCAmZmxhZ3MpOwotCWlmIChjdHgpIHsKLQkJdW5jbG9uZV9jdHgoY3R4KTsKLQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCBmbGFncyk7Ci0JfQotCi0JaWYgKCFjdHgpIHsKLQkJY3R4ID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0KSwgR0ZQX0tFUk5FTCk7Ci0JCWVyciA9IC1FTk9NRU07Ci0JCWlmICghY3R4KQotCQkJZ290byBlcnJvdXQ7Ci0JCV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dChjdHgsIHRhc2spOwotCQlnZXRfY3R4KGN0eCk7Ci0JCWlmIChjbXB4Y2hnKCZ0YXNrLT5wZXJmX2NvdW50ZXJfY3R4cCwgTlVMTCwgY3R4KSkgewotCQkJLyoKLQkJCSAqIFdlIHJhY2VkIHdpdGggc29tZSBvdGhlciB0YXNrOyB1c2UKLQkJCSAqIHRoZSBjb250ZXh0IHRoZXkgc2V0LgotCQkJICovCi0JCQlrZnJlZShjdHgpOwotCQkJZ290byByZXRyeTsKLQkJfQotCQlnZXRfdGFza19zdHJ1Y3QodGFzayk7Ci0JfQotCi0JcHV0X3Rhc2tfc3RydWN0KHRhc2spOwotCXJldHVybiBjdHg7Ci0KLSBlcnJvdXQ6Ci0JcHV0X3Rhc2tfc3RydWN0KHRhc2spOwotCXJldHVybiBFUlJfUFRSKGVycik7Ci19Ci0KLXN0YXRpYyB2b2lkIGZyZWVfY291bnRlcl9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0KLQljb3VudGVyID0gY29udGFpbmVyX29mKGhlYWQsIHN0cnVjdCBwZXJmX2NvdW50ZXIsIHJjdV9oZWFkKTsKLQlpZiAoY291bnRlci0+bnMpCi0JCXB1dF9waWRfbnMoY291bnRlci0+bnMpOwotCWtmcmVlKGNvdW50ZXIpOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfc3luYyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKTsKLQotc3RhdGljIHZvaWQgZnJlZV9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JcGVyZl9wZW5kaW5nX3N5bmMoY291bnRlcik7Ci0KLQlpZiAoIWNvdW50ZXItPnBhcmVudCkgewotCQlhdG9taWNfZGVjKCZucl9jb3VudGVycyk7Ci0JCWlmIChjb3VudGVyLT5hdHRyLm1tYXApCi0JCQlhdG9taWNfZGVjKCZucl9tbWFwX2NvdW50ZXJzKTsKLQkJaWYgKGNvdW50ZXItPmF0dHIuY29tbSkKLQkJCWF0b21pY19kZWMoJm5yX2NvbW1fY291bnRlcnMpOwotCQlpZiAoY291bnRlci0+YXR0ci50YXNrKQotCQkJYXRvbWljX2RlYygmbnJfdGFza19jb3VudGVycyk7Ci0JfQotCi0JaWYgKGNvdW50ZXItPm91dHB1dCkgewotCQlmcHV0KGNvdW50ZXItPm91dHB1dC0+ZmlscCk7Ci0JCWNvdW50ZXItPm91dHB1dCA9IE5VTEw7Ci0JfQotCi0JaWYgKGNvdW50ZXItPmRlc3Ryb3kpCi0JCWNvdW50ZXItPmRlc3Ryb3koY291bnRlcik7Ci0KLQlwdXRfY3R4KGNvdW50ZXItPmN0eCk7Ci0JY2FsbF9yY3UoJmNvdW50ZXItPnJjdV9oZWFkLCBmcmVlX2NvdW50ZXJfcmN1KTsKLX0KLQotLyoKLSAqIENhbGxlZCB3aGVuIHRoZSBsYXN0IHJlZmVyZW5jZSB0byB0aGUgZmlsZSBpcyBnb25lLgotICovCi1zdGF0aWMgaW50IHBlcmZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OwotCi0JZmlsZS0+cHJpdmF0ZV9kYXRhID0gTlVMTDsKLQotCVdBUk5fT05fT05DRShjdHgtPnBhcmVudF9jdHgpOwotCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOwotCXBlcmZfY291bnRlcl9yZW1vdmVfZnJvbV9jb250ZXh0KGNvdW50ZXIpOwotCW11dGV4X3VubG9jaygmY3R4LT5tdXRleCk7Ci0KLQltdXRleF9sb2NrKCZjb3VudGVyLT5vd25lci0+cGVyZl9jb3VudGVyX211dGV4KTsKLQlsaXN0X2RlbF9pbml0KCZjb3VudGVyLT5vd25lcl9lbnRyeSk7Ci0JbXV0ZXhfdW5sb2NrKCZjb3VudGVyLT5vd25lci0+cGVyZl9jb3VudGVyX211dGV4KTsKLQlwdXRfdGFza19zdHJ1Y3QoY291bnRlci0+b3duZXIpOwotCi0JZnJlZV9jb3VudGVyKGNvdW50ZXIpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgcGVyZl9jb3VudGVyX3JlYWRfc2l6ZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCWludCBlbnRyeSA9IHNpemVvZih1NjQpOyAvKiB2YWx1ZSAqLwotCWludCBzaXplID0gMDsKLQlpbnQgbnIgPSAxOwotCi0JaWYgKGNvdW50ZXItPmF0dHIucmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX0VOQUJMRUQpCi0JCXNpemUgKz0gc2l6ZW9mKHU2NCk7Ci0KLQlpZiAoY291bnRlci0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfUlVOTklORykKLQkJc2l6ZSArPSBzaXplb2YodTY0KTsKLQotCWlmIChjb3VudGVyLT5hdHRyLnJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfSUQpCi0JCWVudHJ5ICs9IHNpemVvZih1NjQpOwotCi0JaWYgKGNvdW50ZXItPmF0dHIucmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9HUk9VUCkgewotCQluciArPSBjb3VudGVyLT5ncm91cF9sZWFkZXItPm5yX3NpYmxpbmdzOwotCQlzaXplICs9IHNpemVvZih1NjQpOwotCX0KLQotCXNpemUgKz0gZW50cnkgKiBucjsKLQotCXJldHVybiBzaXplOwotfQotCi1zdGF0aWMgdTY0IHBlcmZfY291bnRlcl9yZWFkX3ZhbHVlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY2hpbGQ7Ci0JdTY0IHRvdGFsID0gMDsKLQotCXRvdGFsICs9IHBlcmZfY291bnRlcl9yZWFkKGNvdW50ZXIpOwotCWxpc3RfZm9yX2VhY2hfZW50cnkoY2hpbGQsICZjb3VudGVyLT5jaGlsZF9saXN0LCBjaGlsZF9saXN0KQotCQl0b3RhbCArPSBwZXJmX2NvdW50ZXJfcmVhZChjaGlsZCk7Ci0KLQlyZXR1cm4gdG90YWw7Ci19Ci0KLXN0YXRpYyBpbnQgcGVyZl9jb3VudGVyX3JlYWRfZW50cnkoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwKLQkJCQkgICB1NjQgcmVhZF9mb3JtYXQsIGNoYXIgX191c2VyICpidWYpCi17Ci0JaW50IG4gPSAwLCBjb3VudCA9IDA7Ci0JdTY0IHZhbHVlc1syXTsKLQotCXZhbHVlc1tuKytdID0gcGVyZl9jb3VudGVyX3JlYWRfdmFsdWUoY291bnRlcik7Ci0JaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfSUQpCi0JCXZhbHVlc1tuKytdID0gcHJpbWFyeV9jb3VudGVyX2lkKGNvdW50ZXIpOwotCi0JY291bnQgPSBuICogc2l6ZW9mKHU2NCk7Ci0KLQlpZiAoY29weV90b191c2VyKGJ1ZiwgdmFsdWVzLCBjb3VudCkpCi0JCXJldHVybiAtRUZBVUxUOwotCi0JcmV0dXJuIGNvdW50OwotfQotCi1zdGF0aWMgaW50IHBlcmZfY291bnRlcl9yZWFkX2dyb3VwKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQkJICAgdTY0IHJlYWRfZm9ybWF0LCBjaGFyIF9fdXNlciAqYnVmKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmxlYWRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlciwgKnN1YjsKLQlpbnQgbiA9IDAsIHNpemUgPSAwLCBlcnIgPSAtRUZBVUxUOwotCXU2NCB2YWx1ZXNbM107Ci0KLQl2YWx1ZXNbbisrXSA9IDEgKyBsZWFkZXItPm5yX3NpYmxpbmdzOwotCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCkgewotCQl2YWx1ZXNbbisrXSA9IGxlYWRlci0+dG90YWxfdGltZV9lbmFibGVkICsKLQkJCWF0b21pYzY0X3JlYWQoJmxlYWRlci0+Y2hpbGRfdG90YWxfdGltZV9lbmFibGVkKTsKLQl9Ci0JaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9SVU5OSU5HKSB7Ci0JCXZhbHVlc1tuKytdID0gbGVhZGVyLT50b3RhbF90aW1lX3J1bm5pbmcgKwotCQkJYXRvbWljNjRfcmVhZCgmbGVhZGVyLT5jaGlsZF90b3RhbF90aW1lX3J1bm5pbmcpOwotCX0KLQotCXNpemUgPSBuICogc2l6ZW9mKHU2NCk7Ci0KLQlpZiAoY29weV90b191c2VyKGJ1ZiwgdmFsdWVzLCBzaXplKSkKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQllcnIgPSBwZXJmX2NvdW50ZXJfcmVhZF9lbnRyeShsZWFkZXIsIHJlYWRfZm9ybWF0LCBidWYgKyBzaXplKTsKLQlpZiAoZXJyIDwgMCkKLQkJcmV0dXJuIGVycjsKLQotCXNpemUgKz0gZXJyOwotCi0JbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpIHsKLQkJZXJyID0gcGVyZl9jb3VudGVyX3JlYWRfZW50cnkoc3ViLCByZWFkX2Zvcm1hdCwKLQkJCQlidWYgKyBzaXplKTsKLQkJaWYgKGVyciA8IDApCi0JCQlyZXR1cm4gZXJyOwotCi0JCXNpemUgKz0gZXJyOwotCX0KLQotCXJldHVybiBzaXplOwotfQotCi1zdGF0aWMgaW50IHBlcmZfY291bnRlcl9yZWFkX29uZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCSB1NjQgcmVhZF9mb3JtYXQsIGNoYXIgX191c2VyICpidWYpCi17Ci0JdTY0IHZhbHVlc1s0XTsKLQlpbnQgbiA9IDA7Ci0KLQl2YWx1ZXNbbisrXSA9IHBlcmZfY291bnRlcl9yZWFkX3ZhbHVlKGNvdW50ZXIpOwotCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCkgewotCQl2YWx1ZXNbbisrXSA9IGNvdW50ZXItPnRvdGFsX3RpbWVfZW5hYmxlZCArCi0JCQlhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOwotCX0KLQlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkcpIHsKLQkJdmFsdWVzW24rK10gPSBjb3VudGVyLT50b3RhbF90aW1lX3J1bm5pbmcgKwotCQkJYXRvbWljNjRfcmVhZCgmY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKLQl9Ci0JaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfSUQpCi0JCXZhbHVlc1tuKytdID0gcHJpbWFyeV9jb3VudGVyX2lkKGNvdW50ZXIpOwotCi0JaWYgKGNvcHlfdG9fdXNlcihidWYsIHZhbHVlcywgbiAqIHNpemVvZih1NjQpKSkKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQlyZXR1cm4gbiAqIHNpemVvZih1NjQpOwotfQotCi0vKgotICogUmVhZCB0aGUgcGVyZm9ybWFuY2UgY291bnRlciAtIHNpbXBsZSBub24gYmxvY2tpbmcgdmVyc2lvbiBmb3Igbm93Ci0gKi8KLXN0YXRpYyBzc2l6ZV90Ci1wZXJmX3JlYWRfaHcoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgY2hhciBfX3VzZXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQotewotCXU2NCByZWFkX2Zvcm1hdCA9IGNvdW50ZXItPmF0dHIucmVhZF9mb3JtYXQ7Ci0JaW50IHJldDsKLQotCS8qCi0JICogUmV0dXJuIGVuZC1vZi1maWxlIGZvciBhIHJlYWQgb24gYSBjb3VudGVyIHRoYXQgaXMgaW4KLQkgKiBlcnJvciBzdGF0ZSAoaS5lLiBiZWNhdXNlIGl0IHdhcyBwaW5uZWQgYnV0IGl0IGNvdWxkbid0IGJlCi0JICogc2NoZWR1bGVkIG9uIHRvIHRoZSBDUFUgYXQgc29tZSBwb2ludCkuCi0JICovCi0JaWYgKGNvdW50ZXItPnN0YXRlID09IFBFUkZfQ09VTlRFUl9TVEFURV9FUlJPUikKLQkJcmV0dXJuIDA7Ci0KLQlpZiAoY291bnQgPCBwZXJmX2NvdW50ZXJfcmVhZF9zaXplKGNvdW50ZXIpKQotCQlyZXR1cm4gLUVOT1NQQzsKLQotCVdBUk5fT05fT05DRShjb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOwotCW11dGV4X2xvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKLQlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9HUk9VUCkKLQkJcmV0ID0gcGVyZl9jb3VudGVyX3JlYWRfZ3JvdXAoY291bnRlciwgcmVhZF9mb3JtYXQsIGJ1Zik7Ci0JZWxzZQotCQlyZXQgPSBwZXJmX2NvdW50ZXJfcmVhZF9vbmUoY291bnRlciwgcmVhZF9mb3JtYXQsIGJ1Zik7Ci0JbXV0ZXhfdW5sb2NrKCZjb3VudGVyLT5jaGlsZF9tdXRleCk7Ci0KLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgc3NpemVfdAotcGVyZl9yZWFkKHN0cnVjdCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqYnVmLCBzaXplX3QgY291bnQsIGxvZmZfdCAqcHBvcykKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwotCi0JcmV0dXJuIHBlcmZfcmVhZF9odyhjb3VudGVyLCBidWYsIGNvdW50KTsKLX0KLQotc3RhdGljIHVuc2lnbmVkIGludCBwZXJmX3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHBvbGxfdGFibGUgKndhaXQpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IGZpbGUtPnByaXZhdGVfZGF0YTsKLQlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7Ci0JdW5zaWduZWQgaW50IGV2ZW50cyA9IFBPTExfSFVQOwotCi0JcmN1X3JlYWRfbG9jaygpOwotCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoY291bnRlci0+ZGF0YSk7Ci0JaWYgKGRhdGEpCi0JCWV2ZW50cyA9IGF0b21pY194Y2hnKCZkYXRhLT5wb2xsLCAwKTsKLQlyY3VfcmVhZF91bmxvY2soKTsKLQotCXBvbGxfd2FpdChmaWxlLCAmY291bnRlci0+d2FpdHEsIHdhaXQpOwotCi0JcmV0dXJuIGV2ZW50czsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX3Jlc2V0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JKHZvaWQpcGVyZl9jb3VudGVyX3JlYWQoY291bnRlcik7Ci0JYXRvbWljNjRfc2V0KCZjb3VudGVyLT5jb3VudCwgMCk7Ci0JcGVyZl9jb3VudGVyX3VwZGF0ZV91c2VycGFnZShjb3VudGVyKTsKLX0KLQotLyoKLSAqIEhvbGRpbmcgdGhlIHRvcC1sZXZlbCBjb3VudGVyJ3MgY2hpbGRfbXV0ZXggbWVhbnMgdGhhdCBhbnkKLSAqIGRlc2NlbmRhbnQgcHJvY2VzcyB0aGF0IGhhcyBpbmhlcml0ZWQgdGhpcyBjb3VudGVyIHdpbGwgYmxvY2sKLSAqIGluIHN5bmNfY2hpbGRfY291bnRlciBpZiBpdCBnb2VzIHRvIGV4aXQsIHRodXMgc2F0aXNmeWluZyB0aGUKLSAqIHRhc2sgZXhpc3RlbmNlIHJlcXVpcmVtZW50cyBvZiBwZXJmX2NvdW50ZXJfZW5hYmxlL2Rpc2FibGUuCi0gKi8KLXN0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCQl2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfY291bnRlciAqKSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjaGlsZDsKLQotCVdBUk5fT05fT05DRShjb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOwotCW11dGV4X2xvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKLQlmdW5jKGNvdW50ZXIpOwotCWxpc3RfZm9yX2VhY2hfZW50cnkoY2hpbGQsICZjb3VudGVyLT5jaGlsZF9saXN0LCBjaGlsZF9saXN0KQotCQlmdW5jKGNoaWxkKTsKLQltdXRleF91bmxvY2soJmNvdW50ZXItPmNoaWxkX211dGV4KTsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2Zvcl9lYWNoKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQkJICB2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfY291bnRlciAqKSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IGNvdW50ZXItPmN0eDsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpzaWJsaW5nOwotCi0JV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7Ci0JbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7Ci0JY291bnRlciA9IGNvdW50ZXItPmdyb3VwX2xlYWRlcjsKLQotCXBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChjb3VudGVyLCBmdW5jKTsKLQlmdW5jKGNvdW50ZXIpOwotCWxpc3RfZm9yX2VhY2hfZW50cnkoc2libGluZywgJmNvdW50ZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpCi0JCXBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChjb3VudGVyLCBmdW5jKTsKLQltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOwotfQotCi1zdGF0aWMgaW50IHBlcmZfY291bnRlcl9wZXJpb2Qoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IF9fdXNlciAqYXJnKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gY291bnRlci0+Y3R4OwotCXVuc2lnbmVkIGxvbmcgc2l6ZTsKLQlpbnQgcmV0ID0gMDsKLQl1NjQgdmFsdWU7Ci0KLQlpZiAoIWNvdW50ZXItPmF0dHIuc2FtcGxlX3BlcmlvZCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlzaXplID0gY29weV9mcm9tX3VzZXIoJnZhbHVlLCBhcmcsIHNpemVvZih2YWx1ZSkpOwotCWlmIChzaXplICE9IHNpemVvZih2YWx1ZSkpCi0JCXJldHVybiAtRUZBVUxUOwotCi0JaWYgKCF2YWx1ZSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOwotCWlmIChjb3VudGVyLT5hdHRyLmZyZXEpIHsKLQkJaWYgKHZhbHVlID4gc3lzY3RsX3BlcmZfY291bnRlcl9zYW1wbGVfcmF0ZSkgewotCQkJcmV0ID0gLUVJTlZBTDsKLQkJCWdvdG8gdW5sb2NrOwotCQl9Ci0KLQkJY291bnRlci0+YXR0ci5zYW1wbGVfZnJlcSA9IHZhbHVlOwotCX0gZWxzZSB7Ci0JCWNvdW50ZXItPmF0dHIuc2FtcGxlX3BlcmlvZCA9IHZhbHVlOwotCQljb3VudGVyLT5ody5zYW1wbGVfcGVyaW9kID0gdmFsdWU7Ci0JfQotdW5sb2NrOgotCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKLQotCXJldHVybiByZXQ7Ci19Ci0KLWludCBwZXJmX2NvdW50ZXJfc2V0X291dHB1dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgb3V0cHV0X2ZkKTsKLQotc3RhdGljIGxvbmcgcGVyZl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IGZpbGUtPnByaXZhdGVfZGF0YTsKLQl2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfY291bnRlciAqKTsKLQl1MzIgZmxhZ3MgPSBhcmc7Ci0KLQlzd2l0Y2ggKGNtZCkgewotCWNhc2UgUEVSRl9DT1VOVEVSX0lPQ19FTkFCTEU6Ci0JCWZ1bmMgPSBwZXJmX2NvdW50ZXJfZW5hYmxlOwotCQlicmVhazsKLQljYXNlIFBFUkZfQ09VTlRFUl9JT0NfRElTQUJMRToKLQkJZnVuYyA9IHBlcmZfY291bnRlcl9kaXNhYmxlOwotCQlicmVhazsKLQljYXNlIFBFUkZfQ09VTlRFUl9JT0NfUkVTRVQ6Ci0JCWZ1bmMgPSBwZXJmX2NvdW50ZXJfcmVzZXQ7Ci0JCWJyZWFrOwotCi0JY2FzZSBQRVJGX0NPVU5URVJfSU9DX1JFRlJFU0g6Ci0JCXJldHVybiBwZXJmX2NvdW50ZXJfcmVmcmVzaChjb3VudGVyLCBhcmcpOwotCi0JY2FzZSBQRVJGX0NPVU5URVJfSU9DX1BFUklPRDoKLQkJcmV0dXJuIHBlcmZfY291bnRlcl9wZXJpb2QoY291bnRlciwgKHU2NCBfX3VzZXIgKilhcmcpOwotCi0JY2FzZSBQRVJGX0NPVU5URVJfSU9DX1NFVF9PVVRQVVQ6Ci0JCXJldHVybiBwZXJmX2NvdW50ZXJfc2V0X291dHB1dChjb3VudGVyLCBhcmcpOwotCi0JZGVmYXVsdDoKLQkJcmV0dXJuIC1FTk9UVFk7Ci0JfQotCi0JaWYgKGZsYWdzICYgUEVSRl9JT0NfRkxBR19HUk9VUCkKLQkJcGVyZl9jb3VudGVyX2Zvcl9lYWNoKGNvdW50ZXIsIGZ1bmMpOwotCWVsc2UKLQkJcGVyZl9jb3VudGVyX2Zvcl9lYWNoX2NoaWxkKGNvdW50ZXIsIGZ1bmMpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLWludCBwZXJmX2NvdW50ZXJfdGFza19lbmFibGUodm9pZCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCi0JbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9jb3VudGVyX211dGV4KTsKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbGlzdCwgb3duZXJfZW50cnkpCi0JCXBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChjb3VudGVyLCBwZXJmX2NvdW50ZXJfZW5hYmxlKTsKLQltdXRleF91bmxvY2soJmN1cnJlbnQtPnBlcmZfY291bnRlcl9tdXRleCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotaW50IHBlcmZfY291bnRlcl90YXNrX2Rpc2FibGUodm9pZCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCi0JbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9jb3VudGVyX211dGV4KTsKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvdW50ZXIsICZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbGlzdCwgb3duZXJfZW50cnkpCi0JCXBlcmZfY291bnRlcl9mb3JfZWFjaF9jaGlsZChjb3VudGVyLCBwZXJmX2NvdW50ZXJfZGlzYWJsZSk7Ci0JbXV0ZXhfdW5sb2NrKCZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbXV0ZXgpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLSNpZm5kZWYgUEVSRl9DT1VOVEVSX0lOREVYX09GRlNFVAotIyBkZWZpbmUgUEVSRl9DT1VOVEVSX0lOREVYX09GRlNFVCAwCi0jZW5kaWYKLQotc3RhdGljIGludCBwZXJmX2NvdW50ZXJfaW5kZXgoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQlpZiAoY291bnRlci0+c3RhdGUgIT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKLQkJcmV0dXJuIDA7Ci0KLQlyZXR1cm4gY291bnRlci0+aHcuaWR4ICsgMSAtIFBFUkZfQ09VTlRFUl9JTkRFWF9PRkZTRVQ7Ci19Ci0KLS8qCi0gKiBDYWxsZXJzIG5lZWQgdG8gZW5zdXJlIHRoZXJlIGNhbiBiZSBubyBuZXN0aW5nIG9mIHRoaXMgZnVuY3Rpb24sIG90aGVyd2lzZQotICogdGhlIHNlcWxvY2sgbG9naWMgZ29lcyBiYWQuIFdlIGNhbiBub3Qgc2VyaWFsaXplIHRoaXMgYmVjYXVzZSB0aGUgYXJjaAotICogY29kZSBjYWxscyB0aGlzIGZyb20gTk1JIGNvbnRleHQuCi0gKi8KLXZvaWQgcGVyZl9jb3VudGVyX3VwZGF0ZV91c2VycGFnZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXJfbW1hcF9wYWdlICp1c2VycGc7Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwotCi0JcmN1X3JlYWRfbG9jaygpOwotCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoY291bnRlci0+ZGF0YSk7Ci0JaWYgKCFkYXRhKQotCQlnb3RvIHVubG9jazsKLQotCXVzZXJwZyA9IGRhdGEtPnVzZXJfcGFnZTsKLQotCS8qCi0JICogRGlzYWJsZSBwcmVlbXB0aW9uIHNvIGFzIHRvIG5vdCBsZXQgdGhlIGNvcnJlc3BvbmRpbmcgdXNlci1zcGFjZQotCSAqIHNwaW4gdG9vIGxvbmcgaWYgd2UgZ2V0IHByZWVtcHRlZC4KLQkgKi8KLQlwcmVlbXB0X2Rpc2FibGUoKTsKLQkrK3VzZXJwZy0+bG9jazsKLQliYXJyaWVyKCk7Ci0JdXNlcnBnLT5pbmRleCA9IHBlcmZfY291bnRlcl9pbmRleChjb3VudGVyKTsKLQl1c2VycGctPm9mZnNldCA9IGF0b21pYzY0X3JlYWQoJmNvdW50ZXItPmNvdW50KTsKLQlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKLQkJdXNlcnBnLT5vZmZzZXQgLT0gYXRvbWljNjRfcmVhZCgmY291bnRlci0+aHcucHJldl9jb3VudCk7Ci0KLQl1c2VycGctPnRpbWVfZW5hYmxlZCA9IGNvdW50ZXItPnRvdGFsX3RpbWVfZW5hYmxlZCArCi0JCQlhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOwotCi0JdXNlcnBnLT50aW1lX3J1bm5pbmcgPSBjb3VudGVyLT50b3RhbF90aW1lX3J1bm5pbmcgKwotCQkJYXRvbWljNjRfcmVhZCgmY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKLQotCWJhcnJpZXIoKTsKLQkrK3VzZXJwZy0+bG9jazsKLQlwcmVlbXB0X2VuYWJsZSgpOwotdW5sb2NrOgotCXJjdV9yZWFkX3VubG9jaygpOwotfQotCi1zdGF0aWMgaW50IHBlcmZfbW1hcF9mYXVsdChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgc3RydWN0IHZtX2ZhdWx0ICp2bWYpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciA9IHZtYS0+dm1fZmlsZS0+cHJpdmF0ZV9kYXRhOwotCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKLQlpbnQgcmV0ID0gVk1fRkFVTFRfU0lHQlVTOwotCi0JaWYgKHZtZi0+ZmxhZ3MgJiBGQVVMVF9GTEFHX01LV1JJVEUpIHsKLQkJaWYgKHZtZi0+cGdvZmYgPT0gMCkKLQkJCXJldCA9IDA7Ci0JCXJldHVybiByZXQ7Ci0JfQotCi0JcmN1X3JlYWRfbG9jaygpOwotCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoY291bnRlci0+ZGF0YSk7Ci0JaWYgKCFkYXRhKQotCQlnb3RvIHVubG9jazsKLQotCWlmICh2bWYtPnBnb2ZmID09IDApIHsKLQkJdm1mLT5wYWdlID0gdmlydF90b19wYWdlKGRhdGEtPnVzZXJfcGFnZSk7Ci0JfSBlbHNlIHsKLQkJaW50IG5yID0gdm1mLT5wZ29mZiAtIDE7Ci0KLQkJaWYgKCh1bnNpZ25lZCluciA+IGRhdGEtPm5yX3BhZ2VzKQotCQkJZ290byB1bmxvY2s7Ci0KLQkJaWYgKHZtZi0+ZmxhZ3MgJiBGQVVMVF9GTEFHX1dSSVRFKQotCQkJZ290byB1bmxvY2s7Ci0KLQkJdm1mLT5wYWdlID0gdmlydF90b19wYWdlKGRhdGEtPmRhdGFfcGFnZXNbbnJdKTsKLQl9Ci0KLQlnZXRfcGFnZSh2bWYtPnBhZ2UpOwotCXZtZi0+cGFnZS0+bWFwcGluZyA9IHZtYS0+dm1fZmlsZS0+Zl9tYXBwaW5nOwotCXZtZi0+cGFnZS0+aW5kZXggICA9IHZtZi0+cGdvZmY7Ci0KLQlyZXQgPSAwOwotdW5sb2NrOgotCXJjdV9yZWFkX3VubG9jaygpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIGludCBwZXJmX21tYXBfZGF0YV9hbGxvYyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgbnJfcGFnZXMpCi17Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwotCXVuc2lnbmVkIGxvbmcgc2l6ZTsKLQlpbnQgaTsKLQotCVdBUk5fT04oYXRvbWljX3JlYWQoJmNvdW50ZXItPm1tYXBfY291bnQpKTsKLQotCXNpemUgPSBzaXplb2Yoc3RydWN0IHBlcmZfbW1hcF9kYXRhKTsKLQlzaXplICs9IG5yX3BhZ2VzICogc2l6ZW9mKHZvaWQgKik7Ci0KLQlkYXRhID0ga3phbGxvYyhzaXplLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWRhdGEpCi0JCWdvdG8gZmFpbDsKLQotCWRhdGEtPnVzZXJfcGFnZSA9ICh2b2lkICopZ2V0X3plcm9lZF9wYWdlKEdGUF9LRVJORUwpOwotCWlmICghZGF0YS0+dXNlcl9wYWdlKQotCQlnb3RvIGZhaWxfdXNlcl9wYWdlOwotCi0JZm9yIChpID0gMDsgaSA8IG5yX3BhZ2VzOyBpKyspIHsKLQkJZGF0YS0+ZGF0YV9wYWdlc1tpXSA9ICh2b2lkICopZ2V0X3plcm9lZF9wYWdlKEdGUF9LRVJORUwpOwotCQlpZiAoIWRhdGEtPmRhdGFfcGFnZXNbaV0pCi0JCQlnb3RvIGZhaWxfZGF0YV9wYWdlczsKLQl9Ci0KLQlkYXRhLT5ucl9wYWdlcyA9IG5yX3BhZ2VzOwotCWF0b21pY19zZXQoJmRhdGEtPmxvY2ssIC0xKTsKLQotCWlmIChjb3VudGVyLT5hdHRyLndhdGVybWFyaykgewotCQlkYXRhLT53YXRlcm1hcmsgPSBtaW5fdChsb25nLCBQQUdFX1NJWkUgKiBucl9wYWdlcywKLQkJCQkgICAgICBjb3VudGVyLT5hdHRyLndha2V1cF93YXRlcm1hcmspOwotCX0KLQlpZiAoIWRhdGEtPndhdGVybWFyaykKLQkJZGF0YS0+d2F0ZXJtYXJrID0gbWF4KFBBR0VfU0laRSwgUEFHRV9TSVpFICogbnJfcGFnZXMgLyA0KTsKLQotCXJjdV9hc3NpZ25fcG9pbnRlcihjb3VudGVyLT5kYXRhLCBkYXRhKTsKLQotCXJldHVybiAwOwotCi1mYWlsX2RhdGFfcGFnZXM6Ci0JZm9yIChpLS07IGkgPj0gMDsgaS0tKQotCQlmcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+ZGF0YV9wYWdlc1tpXSk7Ci0KLQlmcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+dXNlcl9wYWdlKTsKLQotZmFpbF91c2VyX3BhZ2U6Ci0Ja2ZyZWUoZGF0YSk7Ci0KLWZhaWw6Ci0JcmV0dXJuIC1FTk9NRU07Ci19Ci0KLXN0YXRpYyB2b2lkIHBlcmZfbW1hcF9mcmVlX3BhZ2UodW5zaWduZWQgbG9uZyBhZGRyKQotewotCXN0cnVjdCBwYWdlICpwYWdlID0gdmlydF90b19wYWdlKCh2b2lkICopYWRkcik7Ci0KLQlwYWdlLT5tYXBwaW5nID0gTlVMTDsKLQlfX2ZyZWVfcGFnZShwYWdlKTsKLX0KLQotc3RhdGljIHZvaWQgX19wZXJmX21tYXBfZGF0YV9mcmVlKHN0cnVjdCByY3VfaGVhZCAqcmN1X2hlYWQpCi17Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwotCWludCBpOwotCi0JZGF0YSA9IGNvbnRhaW5lcl9vZihyY3VfaGVhZCwgc3RydWN0IHBlcmZfbW1hcF9kYXRhLCByY3VfaGVhZCk7Ci0KLQlwZXJmX21tYXBfZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKWRhdGEtPnVzZXJfcGFnZSk7Ci0JZm9yIChpID0gMDsgaSA8IGRhdGEtPm5yX3BhZ2VzOyBpKyspCi0JCXBlcmZfbW1hcF9mcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+ZGF0YV9wYWdlc1tpXSk7Ci0KLQlrZnJlZShkYXRhKTsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9tbWFwX2RhdGFfZnJlZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSA9IGNvdW50ZXItPmRhdGE7Ci0KLQlXQVJOX09OKGF0b21pY19yZWFkKCZjb3VudGVyLT5tbWFwX2NvdW50KSk7Ci0KLQlyY3VfYXNzaWduX3BvaW50ZXIoY291bnRlci0+ZGF0YSwgTlVMTCk7Ci0JY2FsbF9yY3UoJmRhdGEtPnJjdV9oZWFkLCBfX3BlcmZfbW1hcF9kYXRhX2ZyZWUpOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX21tYXBfb3BlbihzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gdm1hLT52bV9maWxlLT5wcml2YXRlX2RhdGE7Ci0KLQlhdG9taWNfaW5jKCZjb3VudGVyLT5tbWFwX2NvdW50KTsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9tbWFwX2Nsb3NlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSB2bWEtPnZtX2ZpbGUtPnByaXZhdGVfZGF0YTsKLQotCVdBUk5fT05fT05DRShjb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOwotCWlmIChhdG9taWNfZGVjX2FuZF9tdXRleF9sb2NrKCZjb3VudGVyLT5tbWFwX2NvdW50LCAmY291bnRlci0+bW1hcF9tdXRleCkpIHsKLQkJc3RydWN0IHVzZXJfc3RydWN0ICp1c2VyID0gY3VycmVudF91c2VyKCk7Ci0KLQkJYXRvbWljX2xvbmdfc3ViKGNvdW50ZXItPmRhdGEtPm5yX3BhZ2VzICsgMSwgJnVzZXItPmxvY2tlZF92bSk7Ci0JCXZtYS0+dm1fbW0tPmxvY2tlZF92bSAtPSBjb3VudGVyLT5kYXRhLT5ucl9sb2NrZWQ7Ci0JCXBlcmZfbW1hcF9kYXRhX2ZyZWUoY291bnRlcik7Ci0JCW11dGV4X3VubG9jaygmY291bnRlci0+bW1hcF9tdXRleCk7Ci0JfQotfQotCi1zdGF0aWMgc3RydWN0IHZtX29wZXJhdGlvbnNfc3RydWN0IHBlcmZfbW1hcF92bW9wcyA9IHsKLQkub3BlbgkJPSBwZXJmX21tYXBfb3BlbiwKLQkuY2xvc2UJCT0gcGVyZl9tbWFwX2Nsb3NlLAotCS5mYXVsdAkJPSBwZXJmX21tYXBfZmF1bHQsCi0JLnBhZ2VfbWt3cml0ZQk9IHBlcmZfbW1hcF9mYXVsdCwKLX07Ci0KLXN0YXRpYyBpbnQgcGVyZl9tbWFwKHN0cnVjdCBmaWxlICpmaWxlLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwotCXVuc2lnbmVkIGxvbmcgdXNlcl9sb2NrZWQsIHVzZXJfbG9ja19saW1pdDsKLQlzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKnVzZXIgPSBjdXJyZW50X3VzZXIoKTsKLQl1bnNpZ25lZCBsb25nIGxvY2tlZCwgbG9ja19saW1pdDsKLQl1bnNpZ25lZCBsb25nIHZtYV9zaXplOwotCXVuc2lnbmVkIGxvbmcgbnJfcGFnZXM7Ci0JbG9uZyB1c2VyX2V4dHJhLCBleHRyYTsKLQlpbnQgcmV0ID0gMDsKLQotCWlmICghKHZtYS0+dm1fZmxhZ3MgJiBWTV9TSEFSRUQpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCXZtYV9zaXplID0gdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0OwotCW5yX3BhZ2VzID0gKHZtYV9zaXplIC8gUEFHRV9TSVpFKSAtIDE7Ci0KLQkvKgotCSAqIElmIHdlIGhhdmUgZGF0YSBwYWdlcyBlbnN1cmUgdGhleSdyZSBhIHBvd2VyLW9mLXR3byBudW1iZXIsIHNvIHdlCi0JICogY2FuIGRvIGJpdG1hc2tzIGluc3RlYWQgb2YgbW9kdWxvLgotCSAqLwotCWlmIChucl9wYWdlcyAhPSAwICYmICFpc19wb3dlcl9vZl8yKG5yX3BhZ2VzKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAodm1hX3NpemUgIT0gUEFHRV9TSVpFICogKDEgKyBucl9wYWdlcykpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWYgKHZtYS0+dm1fcGdvZmYgIT0gMCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlXQVJOX09OX09OQ0UoY291bnRlci0+Y3R4LT5wYXJlbnRfY3R4KTsKLQltdXRleF9sb2NrKCZjb3VudGVyLT5tbWFwX211dGV4KTsKLQlpZiAoY291bnRlci0+b3V0cHV0KSB7Ci0JCXJldCA9IC1FSU5WQUw7Ci0JCWdvdG8gdW5sb2NrOwotCX0KLQotCWlmIChhdG9taWNfaW5jX25vdF96ZXJvKCZjb3VudGVyLT5tbWFwX2NvdW50KSkgewotCQlpZiAobnJfcGFnZXMgIT0gY291bnRlci0+ZGF0YS0+bnJfcGFnZXMpCi0JCQlyZXQgPSAtRUlOVkFMOwotCQlnb3RvIHVubG9jazsKLQl9Ci0KLQl1c2VyX2V4dHJhID0gbnJfcGFnZXMgKyAxOwotCXVzZXJfbG9ja19saW1pdCA9IHN5c2N0bF9wZXJmX2NvdW50ZXJfbWxvY2sgPj4gKFBBR0VfU0hJRlQgLSAxMCk7Ci0KLQkvKgotCSAqIEluY3JlYXNlIHRoZSBsaW1pdCBsaW5lYXJseSB3aXRoIG1vcmUgQ1BVczoKLQkgKi8KLQl1c2VyX2xvY2tfbGltaXQgKj0gbnVtX29ubGluZV9jcHVzKCk7Ci0KLQl1c2VyX2xvY2tlZCA9IGF0b21pY19sb25nX3JlYWQoJnVzZXItPmxvY2tlZF92bSkgKyB1c2VyX2V4dHJhOwotCi0JZXh0cmEgPSAwOwotCWlmICh1c2VyX2xvY2tlZCA+IHVzZXJfbG9ja19saW1pdCkKLQkJZXh0cmEgPSB1c2VyX2xvY2tlZCAtIHVzZXJfbG9ja19saW1pdDsKLQotCWxvY2tfbGltaXQgPSBjdXJyZW50LT5zaWduYWwtPnJsaW1bUkxJTUlUX01FTUxPQ0tdLnJsaW1fY3VyOwotCWxvY2tfbGltaXQgPj49IFBBR0VfU0hJRlQ7Ci0JbG9ja2VkID0gdm1hLT52bV9tbS0+bG9ja2VkX3ZtICsgZXh0cmE7Ci0KLQlpZiAoKGxvY2tlZCA+IGxvY2tfbGltaXQpICYmIHBlcmZfcGFyYW5vaWRfdHJhY2Vwb2ludF9yYXcoKSAmJgotCQkhY2FwYWJsZShDQVBfSVBDX0xPQ0spKSB7Ci0JCXJldCA9IC1FUEVSTTsKLQkJZ290byB1bmxvY2s7Ci0JfQotCi0JV0FSTl9PTihjb3VudGVyLT5kYXRhKTsKLQlyZXQgPSBwZXJmX21tYXBfZGF0YV9hbGxvYyhjb3VudGVyLCBucl9wYWdlcyk7Ci0JaWYgKHJldCkKLQkJZ290byB1bmxvY2s7Ci0KLQlhdG9taWNfc2V0KCZjb3VudGVyLT5tbWFwX2NvdW50LCAxKTsKLQlhdG9taWNfbG9uZ19hZGQodXNlcl9leHRyYSwgJnVzZXItPmxvY2tlZF92bSk7Ci0Jdm1hLT52bV9tbS0+bG9ja2VkX3ZtICs9IGV4dHJhOwotCWNvdW50ZXItPmRhdGEtPm5yX2xvY2tlZCA9IGV4dHJhOwotCWlmICh2bWEtPnZtX2ZsYWdzICYgVk1fV1JJVEUpCi0JCWNvdW50ZXItPmRhdGEtPndyaXRhYmxlID0gMTsKLQotdW5sb2NrOgotCW11dGV4X3VubG9jaygmY291bnRlci0+bW1hcF9tdXRleCk7Ci0KLQl2bWEtPnZtX2ZsYWdzIHw9IFZNX1JFU0VSVkVEOwotCXZtYS0+dm1fb3BzID0gJnBlcmZfbW1hcF92bW9wczsKLQotCXJldHVybiByZXQ7Ci19Ci0KLXN0YXRpYyBpbnQgcGVyZl9mYXN5bmMoaW50IGZkLCBzdHJ1Y3QgZmlsZSAqZmlscCwgaW50IG9uKQotewotCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmaWxwLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBmaWxwLT5wcml2YXRlX2RhdGE7Ci0JaW50IHJldHZhbDsKLQotCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKLQlyZXR2YWwgPSBmYXN5bmNfaGVscGVyKGZkLCBmaWxwLCBvbiwgJmNvdW50ZXItPmZhc3luYyk7Ci0JbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7Ci0KLQlpZiAocmV0dmFsIDwgMCkKLQkJcmV0dXJuIHJldHZhbDsKLQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBwZXJmX2ZvcHMgPSB7Ci0JLnJlbGVhc2UJCT0gcGVyZl9yZWxlYXNlLAotCS5yZWFkCQkJPSBwZXJmX3JlYWQsCi0JLnBvbGwJCQk9IHBlcmZfcG9sbCwKLQkudW5sb2NrZWRfaW9jdGwJCT0gcGVyZl9pb2N0bCwKLQkuY29tcGF0X2lvY3RsCQk9IHBlcmZfaW9jdGwsCi0JLm1tYXAJCQk9IHBlcmZfbW1hcCwKLQkuZmFzeW5jCQkJPSBwZXJmX2Zhc3luYywKLX07Ci0KLS8qCi0gKiBQZXJmIGNvdW50ZXIgd2FrZXVwCi0gKgotICogSWYgdGhlcmUncyBkYXRhLCBlbnN1cmUgd2Ugc2V0IHRoZSBwb2xsKCkgc3RhdGUgYW5kIHB1Ymxpc2ggZXZlcnl0aGluZwotICogdG8gdXNlci1zcGFjZSBiZWZvcmUgd2FraW5nIGV2ZXJ5Ym9keSB1cC4KLSAqLwotCi12b2lkIHBlcmZfY291bnRlcl93YWtldXAoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQl3YWtlX3VwX2FsbCgmY291bnRlci0+d2FpdHEpOwotCi0JaWYgKGNvdW50ZXItPnBlbmRpbmdfa2lsbCkgewotCQlraWxsX2Zhc3luYygmY291bnRlci0+ZmFzeW5jLCBTSUdJTywgY291bnRlci0+cGVuZGluZ19raWxsKTsKLQkJY291bnRlci0+cGVuZGluZ19raWxsID0gMDsKLQl9Ci19Ci0KLS8qCi0gKiBQZW5kaW5nIHdha2V1cHMKLSAqCi0gKiBIYW5kbGUgdGhlIGNhc2Ugd2hlcmUgd2UgbmVlZCB0byB3YWtldXAgdXAgZnJvbSBOTUkgKG9yIHJxLT5sb2NrKSBjb250ZXh0LgotICoKLSAqIFRoZSBOTUkgYml0IG1lYW5zIHdlIGNhbm5vdCBwb3NzaWJseSB0YWtlIGxvY2tzLiBUaGVyZWZvcmUsIG1haW50YWluIGEKLSAqIHNpbmdsZSBsaW5rZWQgbGlzdCBhbmQgdXNlIGNtcHhjaGcoKSB0byBhZGQgZW50cmllcyBsb2NrbGVzcy4KLSAqLwotCi1zdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfY291bnRlcihzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICplbnRyeSkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyID0gY29udGFpbmVyX29mKGVudHJ5LAotCQkJc3RydWN0IHBlcmZfY291bnRlciwgcGVuZGluZyk7Ci0KLQlpZiAoY291bnRlci0+cGVuZGluZ19kaXNhYmxlKSB7Ci0JCWNvdW50ZXItPnBlbmRpbmdfZGlzYWJsZSA9IDA7Ci0JCV9fcGVyZl9jb3VudGVyX2Rpc2FibGUoY291bnRlcik7Ci0JfQotCi0JaWYgKGNvdW50ZXItPnBlbmRpbmdfd2FrZXVwKSB7Ci0JCWNvdW50ZXItPnBlbmRpbmdfd2FrZXVwID0gMDsKLQkJcGVyZl9jb3VudGVyX3dha2V1cChjb3VudGVyKTsKLQl9Ci19Ci0KLSNkZWZpbmUgUEVORElOR19UQUlMICgoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqKS0xVUwpCi0KLXN0YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICosIHBlcmZfcGVuZGluZ19oZWFkKSA9IHsKLQlQRU5ESU5HX1RBSUwsCi19OwotCi1zdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfcXVldWUoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqZW50cnksCi0JCQkgICAgICAgdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKikpCi17Ci0Jc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqKmhlYWQ7Ci0KLQlpZiAoY21weGNoZygmZW50cnktPm5leHQsIE5VTEwsIFBFTkRJTkdfVEFJTCkgIT0gTlVMTCkKLQkJcmV0dXJuOwotCi0JZW50cnktPmZ1bmMgPSBmdW5jOwotCi0JaGVhZCA9ICZnZXRfY3B1X3ZhcihwZXJmX3BlbmRpbmdfaGVhZCk7Ci0KLQlkbyB7Ci0JCWVudHJ5LT5uZXh0ID0gKmhlYWQ7Ci0JfSB3aGlsZSAoY21weGNoZyhoZWFkLCBlbnRyeS0+bmV4dCwgZW50cnkpICE9IGVudHJ5LT5uZXh0KTsKLQotCXNldF9wZXJmX2NvdW50ZXJfcGVuZGluZygpOwotCi0JcHV0X2NwdV92YXIocGVyZl9wZW5kaW5nX2hlYWQpOwotfQotCi1zdGF0aWMgaW50IF9fcGVyZl9wZW5kaW5nX3J1bih2b2lkKQotewotCXN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKmxpc3Q7Ci0JaW50IG5yID0gMDsKLQotCWxpc3QgPSB4Y2hnKCZfX2dldF9jcHVfdmFyKHBlcmZfcGVuZGluZ19oZWFkKSwgUEVORElOR19UQUlMKTsKLQl3aGlsZSAobGlzdCAhPSBQRU5ESU5HX1RBSUwpIHsKLQkJdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKik7Ci0JCXN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKmVudHJ5ID0gbGlzdDsKLQotCQlsaXN0ID0gbGlzdC0+bmV4dDsKLQotCQlmdW5jID0gZW50cnktPmZ1bmM7Ci0JCWVudHJ5LT5uZXh0ID0gTlVMTDsKLQkJLyoKLQkJICogRW5zdXJlIHdlIG9ic2VydmUgdGhlIHVucXVldWUgYmVmb3JlIHdlIGlzc3VlIHRoZSB3YWtldXAsCi0JCSAqIHNvIHRoYXQgd2Ugd29uJ3QgYmUgd2FpdGluZyBmb3JldmVyLgotCQkgKiAtLSBzZWUgcGVyZl9ub3RfcGVuZGluZygpLgotCQkgKi8KLQkJc21wX3dtYigpOwotCi0JCWZ1bmMoZW50cnkpOwotCQlucisrOwotCX0KLQotCXJldHVybiBucjsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgcGVyZl9ub3RfcGVuZGluZyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCS8qCi0JICogSWYgd2UgZmx1c2ggb24gd2hhdGV2ZXIgY3B1IHdlIHJ1biwgdGhlcmUgaXMgYSBjaGFuY2Ugd2UgZG9uJ3QKLQkgKiBuZWVkIHRvIHdhaXQuCi0JICovCi0JZ2V0X2NwdSgpOwotCV9fcGVyZl9wZW5kaW5nX3J1bigpOwotCXB1dF9jcHUoKTsKLQotCS8qCi0JICogRW5zdXJlIHdlIHNlZSB0aGUgcHJvcGVyIHF1ZXVlIHN0YXRlIGJlZm9yZSBnb2luZyB0byBzbGVlcAotCSAqIHNvIHRoYXQgd2UgZG8gbm90IG1pc3MgdGhlIHdha2V1cC4gLS0gc2VlIHBlcmZfcGVuZGluZ19oYW5kbGUoKQotCSAqLwotCXNtcF9ybWIoKTsKLQlyZXR1cm4gY291bnRlci0+cGVuZGluZy5uZXh0ID09IE5VTEw7Ci19Ci0KLXN0YXRpYyB2b2lkIHBlcmZfcGVuZGluZ19zeW5jKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0Jd2FpdF9ldmVudChjb3VudGVyLT53YWl0cSwgcGVyZl9ub3RfcGVuZGluZyhjb3VudGVyKSk7Ci19Ci0KLXZvaWQgcGVyZl9jb3VudGVyX2RvX3BlbmRpbmcodm9pZCkKLXsKLQlfX3BlcmZfcGVuZGluZ19ydW4oKTsKLX0KLQotLyoKLSAqIENhbGxjaGFpbiBzdXBwb3J0IC0tIGFyY2ggc3BlY2lmaWMKLSAqLwotCi1fX3dlYWsgc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5ICpwZXJmX2NhbGxjaGFpbihzdHJ1Y3QgcHRfcmVncyAqcmVncykKLXsKLQlyZXR1cm4gTlVMTDsKLX0KLQotLyoKLSAqIE91dHB1dAotICovCi1zdGF0aWMgYm9vbCBwZXJmX291dHB1dF9zcGFjZShzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGxvbmcgdGFpbCwKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCi17Ci0JdW5zaWduZWQgbG9uZyBtYXNrOwotCi0JaWYgKCFkYXRhLT53cml0YWJsZSkKLQkJcmV0dXJuIHRydWU7Ci0KLQltYXNrID0gKGRhdGEtPm5yX3BhZ2VzIDw8IFBBR0VfU0hJRlQpIC0gMTsKLQotCW9mZnNldCA9IChvZmZzZXQgLSB0YWlsKSAmIG1hc2s7Ci0JaGVhZCAgID0gKGhlYWQgICAtIHRhaWwpICYgbWFzazsKLQotCWlmICgoaW50KShoZWFkIC0gb2Zmc2V0KSA8IDApCi0JCXJldHVybiBmYWxzZTsKLQotCXJldHVybiB0cnVlOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX291dHB1dF93YWtldXAoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQotewotCWF0b21pY19zZXQoJmhhbmRsZS0+ZGF0YS0+cG9sbCwgUE9MTF9JTik7Ci0KLQlpZiAoaGFuZGxlLT5ubWkpIHsKLQkJaGFuZGxlLT5jb3VudGVyLT5wZW5kaW5nX3dha2V1cCA9IDE7Ci0JCXBlcmZfcGVuZGluZ19xdWV1ZSgmaGFuZGxlLT5jb3VudGVyLT5wZW5kaW5nLAotCQkJCSAgIHBlcmZfcGVuZGluZ19jb3VudGVyKTsKLQl9IGVsc2UKLQkJcGVyZl9jb3VudGVyX3dha2V1cChoYW5kbGUtPmNvdW50ZXIpOwotfQotCi0vKgotICogQ3VyaW91cyBsb2NraW5nIGNvbnN0cnVjdC4KLSAqCi0gKiBXZSBuZWVkIHRvIGVuc3VyZSBhIGxhdGVyIGV2ZW50IGRvZXNuJ3QgcHVibGlzaCBhIGhlYWQgd2hlbiBhIGZvcm1lcgotICogZXZlbnQgaXNuJ3QgZG9uZSB3cml0aW5nLiBIb3dldmVyIHNpbmNlIHdlIG5lZWQgdG8gZGVhbCB3aXRoIE5NSXMgd2UKLSAqIGNhbm5vdCBmdWxseSBzZXJpYWxpemUgdGhpbmdzLgotICoKLSAqIFdoYXQgd2UgZG8gaXMgc2VyaWFsaXplIGJldHdlZW4gQ1BVcyBzbyB3ZSBvbmx5IGhhdmUgdG8gZGVhbCB3aXRoIE5NSQotICogbmVzdGluZyBvbiBhIHNpbmdsZSBDUFUuCi0gKgotICogV2Ugb25seSBwdWJsaXNoIHRoZSBoZWFkIChhbmQgZ2VuZXJhdGUgYSB3YWtldXApIHdoZW4gdGhlIG91dGVyLW1vc3QKLSAqIGV2ZW50IGNvbXBsZXRlcy4KLSAqLwotc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfbG9jayhzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUpCi17Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhID0gaGFuZGxlLT5kYXRhOwotCWludCBjcHU7Ci0KLQloYW5kbGUtPmxvY2tlZCA9IDA7Ci0KLQlsb2NhbF9pcnFfc2F2ZShoYW5kbGUtPmZsYWdzKTsKLQljcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7Ci0KLQlpZiAoaW5fbm1pKCkgJiYgYXRvbWljX3JlYWQoJmRhdGEtPmxvY2spID09IGNwdSkKLQkJcmV0dXJuOwotCi0Jd2hpbGUgKGF0b21pY19jbXB4Y2hnKCZkYXRhLT5sb2NrLCAtMSwgY3B1KSAhPSAtMSkKLQkJY3B1X3JlbGF4KCk7Ci0KLQloYW5kbGUtPmxvY2tlZCA9IDE7Ci19Ci0KLXN0YXRpYyB2b2lkIHBlcmZfb3V0cHV0X3VubG9jayhzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUpCi17Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhID0gaGFuZGxlLT5kYXRhOwotCXVuc2lnbmVkIGxvbmcgaGVhZDsKLQlpbnQgY3B1OwotCi0JZGF0YS0+ZG9uZV9oZWFkID0gZGF0YS0+aGVhZDsKLQotCWlmICghaGFuZGxlLT5sb2NrZWQpCi0JCWdvdG8gb3V0OwotCi1hZ2FpbjoKLQkvKgotCSAqIFRoZSB4Y2hnIGltcGxpZXMgYSBmdWxsIGJhcnJpZXIgdGhhdCBlbnN1cmVzIGFsbCB3cml0ZXMgYXJlIGRvbmUKLQkgKiBiZWZvcmUgd2UgcHVibGlzaCB0aGUgbmV3IGhlYWQsIG1hdGNoZWQgYnkgYSBybWIoKSBpbiB1c2Vyc3BhY2Ugd2hlbgotCSAqIHJlYWRpbmcgdGhpcyBwb3NpdGlvbi4KLQkgKi8KLQl3aGlsZSAoKGhlYWQgPSBhdG9taWNfbG9uZ194Y2hnKCZkYXRhLT5kb25lX2hlYWQsIDApKSkKLQkJZGF0YS0+dXNlcl9wYWdlLT5kYXRhX2hlYWQgPSBoZWFkOwotCi0JLyoKLQkgKiBOTUkgY2FuIGhhcHBlbiBoZXJlLCB3aGljaCBtZWFucyB3ZSBjYW4gbWlzcyBhIGRvbmVfaGVhZCB1cGRhdGUuCi0JICovCi0KLQljcHUgPSBhdG9taWNfeGNoZygmZGF0YS0+bG9jaywgLTEpOwotCVdBUk5fT05fT05DRShjcHUgIT0gc21wX3Byb2Nlc3Nvcl9pZCgpKTsKLQotCS8qCi0JICogVGhlcmVmb3JlIHdlIGhhdmUgdG8gdmFsaWRhdGUgd2UgZGlkIG5vdCBpbmRlZWQgZG8gc28uCi0JICovCi0JaWYgKHVubGlrZWx5KGF0b21pY19sb25nX3JlYWQoJmRhdGEtPmRvbmVfaGVhZCkpKSB7Ci0JCS8qCi0JCSAqIFNpbmNlIHdlIGhhZCBpdCBsb2NrZWQsIHdlIGNhbiBsb2NrIGl0IGFnYWluLgotCQkgKi8KLQkJd2hpbGUgKGF0b21pY19jbXB4Y2hnKCZkYXRhLT5sb2NrLCAtMSwgY3B1KSAhPSAtMSkKLQkJCWNwdV9yZWxheCgpOwotCi0JCWdvdG8gYWdhaW47Ci0JfQotCi0JaWYgKGF0b21pY194Y2hnKCZkYXRhLT53YWtldXAsIDApKQotCQlwZXJmX291dHB1dF93YWtldXAoaGFuZGxlKTsKLW91dDoKLQlsb2NhbF9pcnFfcmVzdG9yZShoYW5kbGUtPmZsYWdzKTsKLX0KLQotdm9pZCBwZXJmX291dHB1dF9jb3B5KHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSwKLQkJICAgICAgY29uc3Qgdm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQotewotCXVuc2lnbmVkIGludCBwYWdlc19tYXNrOwotCXVuc2lnbmVkIGludCBvZmZzZXQ7Ci0JdW5zaWduZWQgaW50IHNpemU7Ci0Jdm9pZCAqKnBhZ2VzOwotCi0Jb2Zmc2V0CQk9IGhhbmRsZS0+b2Zmc2V0OwotCXBhZ2VzX21hc2sJPSBoYW5kbGUtPmRhdGEtPm5yX3BhZ2VzIC0gMTsKLQlwYWdlcwkJPSBoYW5kbGUtPmRhdGEtPmRhdGFfcGFnZXM7Ci0KLQlkbyB7Ci0JCXVuc2lnbmVkIGludCBwYWdlX29mZnNldDsKLQkJaW50IG5yOwotCi0JCW5yCSAgICA9IChvZmZzZXQgPj4gUEFHRV9TSElGVCkgJiBwYWdlc19tYXNrOwotCQlwYWdlX29mZnNldCA9IG9mZnNldCAmIChQQUdFX1NJWkUgLSAxKTsKLQkJc2l6ZQkgICAgPSBtaW5fdCh1bnNpZ25lZCBpbnQsIFBBR0VfU0laRSAtIHBhZ2Vfb2Zmc2V0LCBsZW4pOwotCi0JCW1lbWNweShwYWdlc1tucl0gKyBwYWdlX29mZnNldCwgYnVmLCBzaXplKTsKLQotCQlsZW4JICAgIC09IHNpemU7Ci0JCWJ1ZgkgICAgKz0gc2l6ZTsKLQkJb2Zmc2V0CSAgICArPSBzaXplOwotCX0gd2hpbGUgKGxlbik7Ci0KLQloYW5kbGUtPm9mZnNldCA9IG9mZnNldDsKLQotCS8qCi0JICogQ2hlY2sgd2UgZGlkbid0IGNvcHkgcGFzdCBvdXIgcmVzZXJ2YXRpb24gd2luZG93LCB0YWtpbmcgdGhlCi0JICogcG9zc2libGUgdW5zaWduZWQgaW50IHdyYXAgaW50byBhY2NvdW50LgotCSAqLwotCVdBUk5fT05fT05DRSgoKGxvbmcpKGhhbmRsZS0+aGVhZCAtIGhhbmRsZS0+b2Zmc2V0KSkgPCAwKTsKLX0KLQotaW50IHBlcmZfb3V0cHV0X2JlZ2luKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSwKLQkJICAgICAgc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdW5zaWduZWQgaW50IHNpemUsCi0JCSAgICAgIGludCBubWksIGludCBzYW1wbGUpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqb3V0cHV0X2NvdW50ZXI7Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwotCXVuc2lnbmVkIGxvbmcgdGFpbCwgb2Zmc2V0LCBoZWFkOwotCWludCBoYXZlX2xvc3Q7Ci0Jc3RydWN0IHsKLQkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKLQkJdTY0CQkJIGlkOwotCQl1NjQJCQkgbG9zdDsKLQl9IGxvc3RfZXZlbnQ7Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0JLyoKLQkgKiBGb3IgaW5oZXJpdGVkIGNvdW50ZXJzIHdlIHNlbmQgYWxsIHRoZSBvdXRwdXQgdG93YXJkcyB0aGUgcGFyZW50LgotCSAqLwotCWlmIChjb3VudGVyLT5wYXJlbnQpCi0JCWNvdW50ZXIgPSBjb3VudGVyLT5wYXJlbnQ7Ci0KLQlvdXRwdXRfY291bnRlciA9IHJjdV9kZXJlZmVyZW5jZShjb3VudGVyLT5vdXRwdXQpOwotCWlmIChvdXRwdXRfY291bnRlcikKLQkJY291bnRlciA9IG91dHB1dF9jb3VudGVyOwotCi0JZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShjb3VudGVyLT5kYXRhKTsKLQlpZiAoIWRhdGEpCi0JCWdvdG8gb3V0OwotCi0JaGFuZGxlLT5kYXRhCT0gZGF0YTsKLQloYW5kbGUtPmNvdW50ZXIJPSBjb3VudGVyOwotCWhhbmRsZS0+bm1pCT0gbm1pOwotCWhhbmRsZS0+c2FtcGxlCT0gc2FtcGxlOwotCi0JaWYgKCFkYXRhLT5ucl9wYWdlcykKLQkJZ290byBmYWlsOwotCi0JaGF2ZV9sb3N0ID0gYXRvbWljX3JlYWQoJmRhdGEtPmxvc3QpOwotCWlmIChoYXZlX2xvc3QpCi0JCXNpemUgKz0gc2l6ZW9mKGxvc3RfZXZlbnQpOwotCi0JcGVyZl9vdXRwdXRfbG9jayhoYW5kbGUpOwotCi0JZG8gewotCQkvKgotCQkgKiBVc2Vyc3BhY2UgY291bGQgY2hvb3NlIHRvIGlzc3VlIGEgbWIoKSBiZWZvcmUgdXBkYXRpbmcgdGhlCi0JCSAqIHRhaWwgcG9pbnRlci4gU28gdGhhdCBhbGwgcmVhZHMgd2lsbCBiZSBjb21wbGV0ZWQgYmVmb3JlIHRoZQotCQkgKiB3cml0ZSBpcyBpc3N1ZWQuCi0JCSAqLwotCQl0YWlsID0gQUNDRVNTX09OQ0UoZGF0YS0+dXNlcl9wYWdlLT5kYXRhX3RhaWwpOwotCQlzbXBfcm1iKCk7Ci0JCW9mZnNldCA9IGhlYWQgPSBhdG9taWNfbG9uZ19yZWFkKCZkYXRhLT5oZWFkKTsKLQkJaGVhZCArPSBzaXplOwotCQlpZiAodW5saWtlbHkoIXBlcmZfb3V0cHV0X3NwYWNlKGRhdGEsIHRhaWwsIG9mZnNldCwgaGVhZCkpKQotCQkJZ290byBmYWlsOwotCX0gd2hpbGUgKGF0b21pY19sb25nX2NtcHhjaGcoJmRhdGEtPmhlYWQsIG9mZnNldCwgaGVhZCkgIT0gb2Zmc2V0KTsKLQotCWhhbmRsZS0+b2Zmc2V0CT0gb2Zmc2V0OwotCWhhbmRsZS0+aGVhZAk9IGhlYWQ7Ci0KLQlpZiAoaGVhZCAtIHRhaWwgPiBkYXRhLT53YXRlcm1hcmspCi0JCWF0b21pY19zZXQoJmRhdGEtPndha2V1cCwgMSk7Ci0KLQlpZiAoaGF2ZV9sb3N0KSB7Ci0JCWxvc3RfZXZlbnQuaGVhZGVyLnR5cGUgPSBQRVJGX0VWRU5UX0xPU1Q7Ci0JCWxvc3RfZXZlbnQuaGVhZGVyLm1pc2MgPSAwOwotCQlsb3N0X2V2ZW50LmhlYWRlci5zaXplID0gc2l6ZW9mKGxvc3RfZXZlbnQpOwotCQlsb3N0X2V2ZW50LmlkICAgICAgICAgID0gY291bnRlci0+aWQ7Ci0JCWxvc3RfZXZlbnQubG9zdCAgICAgICAgPSBhdG9taWNfeGNoZygmZGF0YS0+bG9zdCwgMCk7Ci0KLQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgbG9zdF9ldmVudCk7Ci0JfQotCi0JcmV0dXJuIDA7Ci0KLWZhaWw6Ci0JYXRvbWljX2luYygmZGF0YS0+bG9zdCk7Ci0JcGVyZl9vdXRwdXRfdW5sb2NrKGhhbmRsZSk7Ci1vdXQ6Ci0JcmN1X3JlYWRfdW5sb2NrKCk7Ci0KLQlyZXR1cm4gLUVOT1NQQzsKLX0KLQotdm9pZCBwZXJmX291dHB1dF9lbmQoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIgPSBoYW5kbGUtPmNvdW50ZXI7Ci0Jc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhID0gaGFuZGxlLT5kYXRhOwotCi0JaW50IHdha2V1cF9ldmVudHMgPSBjb3VudGVyLT5hdHRyLndha2V1cF9ldmVudHM7Ci0KLQlpZiAoaGFuZGxlLT5zYW1wbGUgJiYgd2FrZXVwX2V2ZW50cykgewotCQlpbnQgZXZlbnRzID0gYXRvbWljX2luY19yZXR1cm4oJmRhdGEtPmV2ZW50cyk7Ci0JCWlmIChldmVudHMgPj0gd2FrZXVwX2V2ZW50cykgewotCQkJYXRvbWljX3N1Yih3YWtldXBfZXZlbnRzLCAmZGF0YS0+ZXZlbnRzKTsKLQkJCWF0b21pY19zZXQoJmRhdGEtPndha2V1cCwgMSk7Ci0JCX0KLQl9Ci0KLQlwZXJmX291dHB1dF91bmxvY2soaGFuZGxlKTsKLQlyY3VfcmVhZF91bmxvY2soKTsKLX0KLQotc3RhdGljIHUzMiBwZXJmX2NvdW50ZXJfcGlkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIHN0cnVjdCB0YXNrX3N0cnVjdCAqcCkKLXsKLQkvKgotCSAqIG9ubHkgdG9wIGxldmVsIGNvdW50ZXJzIGhhdmUgdGhlIHBpZCBuYW1lc3BhY2UgdGhleSB3ZXJlIGNyZWF0ZWQgaW4KLQkgKi8KLQlpZiAoY291bnRlci0+cGFyZW50KQotCQljb3VudGVyID0gY291bnRlci0+cGFyZW50OwotCi0JcmV0dXJuIHRhc2tfdGdpZF9ucl9ucyhwLCBjb3VudGVyLT5ucyk7Ci19Ci0KLXN0YXRpYyB1MzIgcGVyZl9jb3VudGVyX3RpZChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCi17Ci0JLyoKLQkgKiBvbmx5IHRvcCBsZXZlbCBjb3VudGVycyBoYXZlIHRoZSBwaWQgbmFtZXNwYWNlIHRoZXkgd2VyZSBjcmVhdGVkIGluCi0JICovCi0JaWYgKGNvdW50ZXItPnBhcmVudCkKLQkJY291bnRlciA9IGNvdW50ZXItPnBhcmVudDsKLQotCXJldHVybiB0YXNrX3BpZF9ucl9ucyhwLCBjb3VudGVyLT5ucyk7Ci19Ci0KLXN0YXRpYyB2b2lkIHBlcmZfb3V0cHV0X3JlYWRfb25lKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSwKLQkJCQkgc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQl1NjQgcmVhZF9mb3JtYXQgPSBjb3VudGVyLT5hdHRyLnJlYWRfZm9ybWF0OwotCXU2NCB2YWx1ZXNbNF07Ci0JaW50IG4gPSAwOwotCi0JdmFsdWVzW24rK10gPSBhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5jb3VudCk7Ci0JaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVEKSB7Ci0JCXZhbHVlc1tuKytdID0gY291bnRlci0+dG90YWxfdGltZV9lbmFibGVkICsKLQkJCWF0b21pYzY0X3JlYWQoJmNvdW50ZXItPmNoaWxkX3RvdGFsX3RpbWVfZW5hYmxlZCk7Ci0JfQotCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfUlVOTklORykgewotCQl2YWx1ZXNbbisrXSA9IGNvdW50ZXItPnRvdGFsX3RpbWVfcnVubmluZyArCi0JCQlhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5jaGlsZF90b3RhbF90aW1lX3J1bm5pbmcpOwotCX0KLQlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9JRCkKLQkJdmFsdWVzW24rK10gPSBwcmltYXJ5X2NvdW50ZXJfaWQoY291bnRlcik7Ci0KLQlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgdmFsdWVzLCBuICogc2l6ZW9mKHU2NCkpOwotfQotCi0vKgotICogWFhYIFBFUkZfRk9STUFUX0dST1VQIHZzIGluaGVyaXRlZCBjb3VudGVycyBzZWVtcyBkaWZmaWN1bHQuCi0gKi8KLXN0YXRpYyB2b2lkIHBlcmZfb3V0cHV0X3JlYWRfZ3JvdXAoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlLAotCQkJICAgIHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqbGVhZGVyID0gY291bnRlci0+Z3JvdXBfbGVhZGVyLCAqc3ViOwotCXU2NCByZWFkX2Zvcm1hdCA9IGNvdW50ZXItPmF0dHIucmVhZF9mb3JtYXQ7Ci0JdTY0IHZhbHVlc1s1XTsKLQlpbnQgbiA9IDA7Ci0KLQl2YWx1ZXNbbisrXSA9IDEgKyBsZWFkZXItPm5yX3NpYmxpbmdzOwotCi0JaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVEKQotCQl2YWx1ZXNbbisrXSA9IGxlYWRlci0+dG90YWxfdGltZV9lbmFibGVkOwotCi0JaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9SVU5OSU5HKQotCQl2YWx1ZXNbbisrXSA9IGxlYWRlci0+dG90YWxfdGltZV9ydW5uaW5nOwotCi0JaWYgKGxlYWRlciAhPSBjb3VudGVyKQotCQlsZWFkZXItPnBtdS0+cmVhZChsZWFkZXIpOwotCi0JdmFsdWVzW24rK10gPSBhdG9taWM2NF9yZWFkKCZsZWFkZXItPmNvdW50KTsKLQlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9JRCkKLQkJdmFsdWVzW24rK10gPSBwcmltYXJ5X2NvdW50ZXJfaWQobGVhZGVyKTsKLQotCXBlcmZfb3V0cHV0X2NvcHkoaGFuZGxlLCB2YWx1ZXMsIG4gKiBzaXplb2YodTY0KSk7Ci0KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHN1YiwgJmxlYWRlci0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkgewotCQluID0gMDsKLQotCQlpZiAoc3ViICE9IGNvdW50ZXIpCi0JCQlzdWItPnBtdS0+cmVhZChzdWIpOwotCi0JCXZhbHVlc1tuKytdID0gYXRvbWljNjRfcmVhZCgmc3ViLT5jb3VudCk7Ci0JCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQotCQkJdmFsdWVzW24rK10gPSBwcmltYXJ5X2NvdW50ZXJfaWQoc3ViKTsKLQotCQlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgdmFsdWVzLCBuICogc2l6ZW9mKHU2NCkpOwotCX0KLX0KLQotc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfcmVhZChzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCi0JCQkgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JaWYgKGNvdW50ZXItPmF0dHIucmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9HUk9VUCkKLQkJcGVyZl9vdXRwdXRfcmVhZF9ncm91cChoYW5kbGUsIGNvdW50ZXIpOwotCWVsc2UKLQkJcGVyZl9vdXRwdXRfcmVhZF9vbmUoaGFuZGxlLCBjb3VudGVyKTsKLX0KLQotdm9pZCBwZXJmX291dHB1dF9zYW1wbGUoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlLAotCQkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyICpoZWFkZXIsCi0JCQlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKLQkJCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JdTY0IHNhbXBsZV90eXBlID0gZGF0YS0+dHlwZTsKLQotCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsICpoZWFkZXIpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSVApCi0JCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPmlwKTsKLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJRCkKLQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+dGlkX2VudHJ5KTsKLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJTUUpCi0JCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPnRpbWUpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQUREUikKLQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+YWRkcik7Ci0KLQlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9JRCkKLQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+aWQpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfU1RSRUFNX0lEKQotCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5zdHJlYW1faWQpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ1BVKQotCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5jcHVfZW50cnkpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUEVSSU9EKQotCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5wZXJpb2QpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkVBRCkKLQkJcGVyZl9vdXRwdXRfcmVhZChoYW5kbGUsIGNvdW50ZXIpOwotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ0FMTENIQUlOKSB7Ci0JCWlmIChkYXRhLT5jYWxsY2hhaW4pIHsKLQkJCWludCBzaXplID0gMTsKLQotCQkJaWYgKGRhdGEtPmNhbGxjaGFpbikKLQkJCQlzaXplICs9IGRhdGEtPmNhbGxjaGFpbi0+bnI7Ci0KLQkJCXNpemUgKj0gc2l6ZW9mKHU2NCk7Ci0KLQkJCXBlcmZfb3V0cHV0X2NvcHkoaGFuZGxlLCBkYXRhLT5jYWxsY2hhaW4sIHNpemUpOwotCQl9IGVsc2UgewotCQkJdTY0IG5yID0gMDsKLQkJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIG5yKTsKLQkJfQotCX0KLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JBVykgewotCQlpZiAoZGF0YS0+cmF3KSB7Ci0JCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5yYXctPnNpemUpOwotCQkJcGVyZl9vdXRwdXRfY29weShoYW5kbGUsIGRhdGEtPnJhdy0+ZGF0YSwKLQkJCQkJIGRhdGEtPnJhdy0+c2l6ZSk7Ci0JCX0gZWxzZSB7Ci0JCQlzdHJ1Y3QgewotCQkJCXUzMglzaXplOwotCQkJCXUzMglkYXRhOwotCQkJfSByYXcgPSB7Ci0JCQkJLnNpemUgPSBzaXplb2YodTMyKSwKLQkJCQkuZGF0YSA9IDAsCi0JCQl9OwotCQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgcmF3KTsKLQkJfQotCX0KLX0KLQotdm9pZCBwZXJmX3ByZXBhcmVfc2FtcGxlKHN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciAqaGVhZGVyLAotCQkJIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAotCQkJIHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQkgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCi17Ci0JdTY0IHNhbXBsZV90eXBlID0gY291bnRlci0+YXR0ci5zYW1wbGVfdHlwZTsKLQotCWRhdGEtPnR5cGUgPSBzYW1wbGVfdHlwZTsKLQotCWhlYWRlci0+dHlwZSA9IFBFUkZfRVZFTlRfU0FNUExFOwotCWhlYWRlci0+c2l6ZSA9IHNpemVvZigqaGVhZGVyKTsKLQotCWhlYWRlci0+bWlzYyA9IDA7Ci0JaGVhZGVyLT5taXNjIHw9IHBlcmZfbWlzY19mbGFncyhyZWdzKTsKLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0lQKSB7Ci0JCWRhdGEtPmlwID0gcGVyZl9pbnN0cnVjdGlvbl9wb2ludGVyKHJlZ3MpOwotCi0JCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+aXApOwotCX0KLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJRCkgewotCQkvKiBuYW1lc3BhY2UgaXNzdWVzICovCi0JCWRhdGEtPnRpZF9lbnRyeS5waWQgPSBwZXJmX2NvdW50ZXJfcGlkKGNvdW50ZXIsIGN1cnJlbnQpOwotCQlkYXRhLT50aWRfZW50cnkudGlkID0gcGVyZl9jb3VudGVyX3RpZChjb3VudGVyLCBjdXJyZW50KTsKLQotCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPnRpZF9lbnRyeSk7Ci0JfQotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfVElNRSkgewotCQlkYXRhLT50aW1lID0gcGVyZl9jbG9jaygpOwotCi0JCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+dGltZSk7Ci0JfQotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQUREUikKLQkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT5hZGRyKTsKLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0lEKSB7Ci0JCWRhdGEtPmlkID0gcHJpbWFyeV9jb3VudGVyX2lkKGNvdW50ZXIpOwotCi0JCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+aWQpOwotCX0KLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1NUUkVBTV9JRCkgewotCQlkYXRhLT5zdHJlYW1faWQgPSBjb3VudGVyLT5pZDsKLQotCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPnN0cmVhbV9pZCk7Ci0JfQotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ1BVKSB7Ci0JCWRhdGEtPmNwdV9lbnRyeS5jcHUJCT0gcmF3X3NtcF9wcm9jZXNzb3JfaWQoKTsKLQkJZGF0YS0+Y3B1X2VudHJ5LnJlc2VydmVkCT0gMDsKLQotCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPmNwdV9lbnRyeSk7Ci0JfQotCi0JaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUEVSSU9EKQotCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPnBlcmlvZCk7Ci0KLQlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9SRUFEKQotCQloZWFkZXItPnNpemUgKz0gcGVyZl9jb3VudGVyX3JlYWRfc2l6ZShjb3VudGVyKTsKLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0NBTExDSEFJTikgewotCQlpbnQgc2l6ZSA9IDE7Ci0KLQkJZGF0YS0+Y2FsbGNoYWluID0gcGVyZl9jYWxsY2hhaW4ocmVncyk7Ci0KLQkJaWYgKGRhdGEtPmNhbGxjaGFpbikKLQkJCXNpemUgKz0gZGF0YS0+Y2FsbGNoYWluLT5ucjsKLQotCQloZWFkZXItPnNpemUgKz0gc2l6ZSAqIHNpemVvZih1NjQpOwotCX0KLQotCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JBVykgewotCQlpbnQgc2l6ZSA9IHNpemVvZih1MzIpOwotCi0JCWlmIChkYXRhLT5yYXcpCi0JCQlzaXplICs9IGRhdGEtPnJhdy0+c2l6ZTsKLQkJZWxzZQotCQkJc2l6ZSArPSBzaXplb2YodTMyKTsKLQotCQlXQVJOX09OX09OQ0Uoc2l6ZSAmIChzaXplb2YodTY0KS0xKSk7Ci0JCWhlYWRlci0+c2l6ZSArPSBzaXplOwotCX0KLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX291dHB1dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgbm1pLAotCQkJCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAotCQkJCXN0cnVjdCBwdF9yZWdzICpyZWdzKQotewotCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOwotCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciBoZWFkZXI7Ci0KLQlwZXJmX3ByZXBhcmVfc2FtcGxlKCZoZWFkZXIsIGRhdGEsIGNvdW50ZXIsIHJlZ3MpOwotCi0JaWYgKHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIGhlYWRlci5zaXplLCBubWksIDEpKQotCQlyZXR1cm47Ci0KLQlwZXJmX291dHB1dF9zYW1wbGUoJmhhbmRsZSwgJmhlYWRlciwgZGF0YSwgY291bnRlcik7Ci0KLQlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Ci19Ci0KLS8qCi0gKiByZWFkIGV2ZW50Ci0gKi8KLQotc3RydWN0IHBlcmZfcmVhZF9ldmVudCB7Ci0Jc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKLQotCXUzMgkJCQlwaWQ7Ci0JdTMyCQkJCXRpZDsKLX07Ci0KLXN0YXRpYyB2b2lkCi1wZXJmX2NvdW50ZXJfcmVhZF9ldmVudChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQotewotCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOwotCXN0cnVjdCBwZXJmX3JlYWRfZXZlbnQgcmVhZF9ldmVudCA9IHsKLQkJLmhlYWRlciA9IHsKLQkJCS50eXBlID0gUEVSRl9FVkVOVF9SRUFELAotCQkJLm1pc2MgPSAwLAotCQkJLnNpemUgPSBzaXplb2YocmVhZF9ldmVudCkgKyBwZXJmX2NvdW50ZXJfcmVhZF9zaXplKGNvdW50ZXIpLAotCQl9LAotCQkucGlkID0gcGVyZl9jb3VudGVyX3BpZChjb3VudGVyLCB0YXNrKSwKLQkJLnRpZCA9IHBlcmZfY291bnRlcl90aWQoY291bnRlciwgdGFzayksCi0JfTsKLQlpbnQgcmV0OwotCi0JcmV0ID0gcGVyZl9vdXRwdXRfYmVnaW4oJmhhbmRsZSwgY291bnRlciwgcmVhZF9ldmVudC5oZWFkZXIuc2l6ZSwgMCwgMCk7Ci0JaWYgKHJldCkKLQkJcmV0dXJuOwotCi0JcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIHJlYWRfZXZlbnQpOwotCXBlcmZfb3V0cHV0X3JlYWQoJmhhbmRsZSwgY291bnRlcik7Ci0KLQlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Ci19Ci0KLS8qCi0gKiB0YXNrIHRyYWNraW5nIC0tIGZvcmsvZXhpdAotICoKLSAqIGVuYWJsZWQgYnk6IGF0dHIuY29tbSB8IGF0dHIubW1hcCB8IGF0dHIudGFzawotICovCi0KLXN0cnVjdCBwZXJmX3Rhc2tfZXZlbnQgewotCXN0cnVjdCB0YXNrX3N0cnVjdAkJKnRhc2s7Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0CSp0YXNrX2N0eDsKLQotCXN0cnVjdCB7Ci0JCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7Ci0KLQkJdTMyCQkJCXBpZDsKLQkJdTMyCQkJCXBwaWQ7Ci0JCXUzMgkJCQl0aWQ7Ci0JCXUzMgkJCQlwdGlkOwotCQl1NjQJCQkJdGltZTsKLQl9IGV2ZW50OwotfTsKLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX3Rhc2tfb3V0cHV0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQkJICAgICBzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50ICp0YXNrX2V2ZW50KQotewotCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOwotCWludCBzaXplOwotCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IHRhc2tfZXZlbnQtPnRhc2s7Ci0JaW50IHJldDsKLQotCXNpemUgID0gdGFza19ldmVudC0+ZXZlbnQuaGVhZGVyLnNpemU7Ci0JcmV0ID0gcGVyZl9vdXRwdXRfYmVnaW4oJmhhbmRsZSwgY291bnRlciwgc2l6ZSwgMCwgMCk7Ci0KLQlpZiAocmV0KQotCQlyZXR1cm47Ci0KLQl0YXNrX2V2ZW50LT5ldmVudC5waWQgPSBwZXJmX2NvdW50ZXJfcGlkKGNvdW50ZXIsIHRhc2spOwotCXRhc2tfZXZlbnQtPmV2ZW50LnBwaWQgPSBwZXJmX2NvdW50ZXJfcGlkKGNvdW50ZXIsIGN1cnJlbnQpOwotCi0JdGFza19ldmVudC0+ZXZlbnQudGlkID0gcGVyZl9jb3VudGVyX3RpZChjb3VudGVyLCB0YXNrKTsKLQl0YXNrX2V2ZW50LT5ldmVudC5wdGlkID0gcGVyZl9jb3VudGVyX3RpZChjb3VudGVyLCBjdXJyZW50KTsKLQotCXRhc2tfZXZlbnQtPmV2ZW50LnRpbWUgPSBwZXJmX2Nsb2NrKCk7Ci0KLQlwZXJmX291dHB1dF9wdXQoJmhhbmRsZSwgdGFza19ldmVudC0+ZXZlbnQpOwotCi0JcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOwotfQotCi1zdGF0aWMgaW50IHBlcmZfY291bnRlcl90YXNrX21hdGNoKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JaWYgKGNvdW50ZXItPmF0dHIuY29tbSB8fCBjb3VudGVyLT5hdHRyLm1tYXAgfHwgY291bnRlci0+YXR0ci50YXNrKQotCQlyZXR1cm4gMTsKLQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfdGFza19jdHgoc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHgsCi0JCQkJICBzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50ICp0YXNrX2V2ZW50KQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0KLQlpZiAoc3lzdGVtX3N0YXRlICE9IFNZU1RFTV9SVU5OSU5HIHx8IGxpc3RfZW1wdHkoJmN0eC0+ZXZlbnRfbGlzdCkpCi0JCXJldHVybjsKLQotCXJjdV9yZWFkX2xvY2soKTsKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShjb3VudGVyLCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkgewotCQlpZiAocGVyZl9jb3VudGVyX3Rhc2tfbWF0Y2goY291bnRlcikpCi0JCQlwZXJmX2NvdW50ZXJfdGFza19vdXRwdXQoY291bnRlciwgdGFza19ldmVudCk7Ci0JfQotCXJjdV9yZWFkX3VubG9jaygpOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX2NvdW50ZXJfdGFza19ldmVudChzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50ICp0YXNrX2V2ZW50KQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHggPSB0YXNrX2V2ZW50LT50YXNrX2N0eDsKLQotCWNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKLQlwZXJmX2NvdW50ZXJfdGFza19jdHgoJmNwdWN0eC0+Y3R4LCB0YXNrX2V2ZW50KTsKLQlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKLQotCXJjdV9yZWFkX2xvY2soKTsKLQlpZiAoIWN0eCkKLQkJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKHRhc2tfZXZlbnQtPnRhc2stPnBlcmZfY291bnRlcl9jdHhwKTsKLQlpZiAoY3R4KQotCQlwZXJmX2NvdW50ZXJfdGFza19jdHgoY3R4LCB0YXNrX2V2ZW50KTsKLQlyY3VfcmVhZF91bmxvY2soKTsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX3Rhc2soc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLAotCQkJICAgICAgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICp0YXNrX2N0eCwKLQkJCSAgICAgIGludCBuZXcpCi17Ci0Jc3RydWN0IHBlcmZfdGFza19ldmVudCB0YXNrX2V2ZW50OwotCi0JaWYgKCFhdG9taWNfcmVhZCgmbnJfY29tbV9jb3VudGVycykgJiYKLQkgICAgIWF0b21pY19yZWFkKCZucl9tbWFwX2NvdW50ZXJzKSAmJgotCSAgICAhYXRvbWljX3JlYWQoJm5yX3Rhc2tfY291bnRlcnMpKQotCQlyZXR1cm47Ci0KLQl0YXNrX2V2ZW50ID0gKHN0cnVjdCBwZXJmX3Rhc2tfZXZlbnQpewotCQkudGFzawkgID0gdGFzaywKLQkJLnRhc2tfY3R4ID0gdGFza19jdHgsCi0JCS5ldmVudCAgICA9IHsKLQkJCS5oZWFkZXIgPSB7Ci0JCQkJLnR5cGUgPSBuZXcgPyBQRVJGX0VWRU5UX0ZPUksgOiBQRVJGX0VWRU5UX0VYSVQsCi0JCQkJLm1pc2MgPSAwLAotCQkJCS5zaXplID0gc2l6ZW9mKHRhc2tfZXZlbnQuZXZlbnQpLAotCQkJfSwKLQkJCS8qIC5waWQgICovCi0JCQkvKiAucHBpZCAqLwotCQkJLyogLnRpZCAgKi8KLQkJCS8qIC5wdGlkICovCi0JCX0sCi0JfTsKLQotCXBlcmZfY291bnRlcl90YXNrX2V2ZW50KCZ0YXNrX2V2ZW50KTsKLX0KLQotdm9pZCBwZXJmX2NvdW50ZXJfZm9yayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCi17Ci0JcGVyZl9jb3VudGVyX3Rhc2sodGFzaywgTlVMTCwgMSk7Ci19Ci0KLS8qCi0gKiBjb21tIHRyYWNraW5nCi0gKi8KLQotc3RydWN0IHBlcmZfY29tbV9ldmVudCB7Ci0Jc3RydWN0IHRhc2tfc3RydWN0CSp0YXNrOwotCWNoYXIJCQkqY29tbTsKLQlpbnQJCQljb21tX3NpemU7Ci0KLQlzdHJ1Y3QgewotCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIJaGVhZGVyOwotCi0JCXUzMgkJCQlwaWQ7Ci0JCXUzMgkJCQl0aWQ7Ci0JfSBldmVudDsKLX07Ci0KLXN0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9jb21tX291dHB1dChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCSAgICAgc3RydWN0IHBlcmZfY29tbV9ldmVudCAqY29tbV9ldmVudCkKLXsKLQlzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlIGhhbmRsZTsKLQlpbnQgc2l6ZSA9IGNvbW1fZXZlbnQtPmV2ZW50LmhlYWRlci5zaXplOwotCWludCByZXQgPSBwZXJmX291dHB1dF9iZWdpbigmaGFuZGxlLCBjb3VudGVyLCBzaXplLCAwLCAwKTsKLQotCWlmIChyZXQpCi0JCXJldHVybjsKLQotCWNvbW1fZXZlbnQtPmV2ZW50LnBpZCA9IHBlcmZfY291bnRlcl9waWQoY291bnRlciwgY29tbV9ldmVudC0+dGFzayk7Ci0JY29tbV9ldmVudC0+ZXZlbnQudGlkID0gcGVyZl9jb3VudGVyX3RpZChjb3VudGVyLCBjb21tX2V2ZW50LT50YXNrKTsKLQotCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBjb21tX2V2ZW50LT5ldmVudCk7Ci0JcGVyZl9vdXRwdXRfY29weSgmaGFuZGxlLCBjb21tX2V2ZW50LT5jb21tLAotCQkJCSAgIGNvbW1fZXZlbnQtPmNvbW1fc2l6ZSk7Ci0JcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOwotfQotCi1zdGF0aWMgaW50IHBlcmZfY291bnRlcl9jb21tX21hdGNoKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JaWYgKGNvdW50ZXItPmF0dHIuY29tbSkKLQkJcmV0dXJuIDE7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2NvbW1fY3R4KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4LAotCQkJCSAgc3RydWN0IHBlcmZfY29tbV9ldmVudCAqY29tbV9ldmVudCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCi0JaWYgKHN5c3RlbV9zdGF0ZSAhPSBTWVNURU1fUlVOTklORyB8fCBsaXN0X2VtcHR5KCZjdHgtPmV2ZW50X2xpc3QpKQotCQlyZXR1cm47Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoY291bnRlciwgJmN0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKLQkJaWYgKHBlcmZfY291bnRlcl9jb21tX21hdGNoKGNvdW50ZXIpKQotCQkJcGVyZl9jb3VudGVyX2NvbW1fb3V0cHV0KGNvdW50ZXIsIGNvbW1fZXZlbnQpOwotCX0KLQlyY3VfcmVhZF91bmxvY2soKTsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX2NvbW1fZXZlbnQoc3RydWN0IHBlcmZfY29tbV9ldmVudCAqY29tbV9ldmVudCkKLXsKLQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OwotCXVuc2lnbmVkIGludCBzaXplOwotCWNoYXIgY29tbVtUQVNLX0NPTU1fTEVOXTsKLQotCW1lbXNldChjb21tLCAwLCBzaXplb2YoY29tbSkpOwotCXN0cm5jcHkoY29tbSwgY29tbV9ldmVudC0+dGFzay0+Y29tbSwgc2l6ZW9mKGNvbW0pKTsKLQlzaXplID0gQUxJR04oc3RybGVuKGNvbW0pKzEsIHNpemVvZih1NjQpKTsKLQotCWNvbW1fZXZlbnQtPmNvbW0gPSBjb21tOwotCWNvbW1fZXZlbnQtPmNvbW1fc2l6ZSA9IHNpemU7Ci0KLQljb21tX2V2ZW50LT5ldmVudC5oZWFkZXIuc2l6ZSA9IHNpemVvZihjb21tX2V2ZW50LT5ldmVudCkgKyBzaXplOwotCi0JY3B1Y3R4ID0gJmdldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwotCXBlcmZfY291bnRlcl9jb21tX2N0eCgmY3B1Y3R4LT5jdHgsIGNvbW1fZXZlbnQpOwotCXB1dF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwotCi0JcmN1X3JlYWRfbG9jaygpOwotCS8qCi0JICogZG9lc24ndCByZWFsbHkgbWF0dGVyIHdoaWNoIG9mIHRoZSBjaGlsZCBjb250ZXh0cyB0aGUKLQkgKiBldmVudHMgZW5kcyB1cCBpbi4KLQkgKi8KLQljdHggPSByY3VfZGVyZWZlcmVuY2UoY3VycmVudC0+cGVyZl9jb3VudGVyX2N0eHApOwotCWlmIChjdHgpCi0JCXBlcmZfY291bnRlcl9jb21tX2N0eChjdHgsIGNvbW1fZXZlbnQpOwotCXJjdV9yZWFkX3VubG9jaygpOwotfQotCi12b2lkIHBlcmZfY291bnRlcl9jb21tKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKLXsKLQlzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50IGNvbW1fZXZlbnQ7Ci0KLQlpZiAodGFzay0+cGVyZl9jb3VudGVyX2N0eHApCi0JCXBlcmZfY291bnRlcl9lbmFibGVfb25fZXhlYyh0YXNrKTsKLQotCWlmICghYXRvbWljX3JlYWQoJm5yX2NvbW1fY291bnRlcnMpKQotCQlyZXR1cm47Ci0KLQljb21tX2V2ZW50ID0gKHN0cnVjdCBwZXJmX2NvbW1fZXZlbnQpewotCQkudGFzawk9IHRhc2ssCi0JCS8qIC5jb21tICAgICAgKi8KLQkJLyogLmNvbW1fc2l6ZSAqLwotCQkuZXZlbnQgID0gewotCQkJLmhlYWRlciA9IHsKLQkJCQkudHlwZSA9IFBFUkZfRVZFTlRfQ09NTSwKLQkJCQkubWlzYyA9IDAsCi0JCQkJLyogLnNpemUgKi8KLQkJCX0sCi0JCQkvKiAucGlkICovCi0JCQkvKiAudGlkICovCi0JCX0sCi0JfTsKLQotCXBlcmZfY291bnRlcl9jb21tX2V2ZW50KCZjb21tX2V2ZW50KTsKLX0KLQotLyoKLSAqIG1tYXAgdHJhY2tpbmcKLSAqLwotCi1zdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50IHsKLQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QJKnZtYTsKLQotCWNvbnN0IGNoYXIJCSpmaWxlX25hbWU7Ci0JaW50CQkJZmlsZV9zaXplOwotCi0Jc3RydWN0IHsKLQkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKLQotCQl1MzIJCQkJcGlkOwotCQl1MzIJCQkJdGlkOwotCQl1NjQJCQkJc3RhcnQ7Ci0JCXU2NAkJCQlsZW47Ci0JCXU2NAkJCQlwZ29mZjsKLQl9IGV2ZW50OwotfTsKLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX21tYXBfb3V0cHV0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsCi0JCQkJICAgICBzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50ICptbWFwX2V2ZW50KQotewotCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOwotCWludCBzaXplID0gbW1hcF9ldmVudC0+ZXZlbnQuaGVhZGVyLnNpemU7Ci0JaW50IHJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIHNpemUsIDAsIDApOwotCi0JaWYgKHJldCkKLQkJcmV0dXJuOwotCi0JbW1hcF9ldmVudC0+ZXZlbnQucGlkID0gcGVyZl9jb3VudGVyX3BpZChjb3VudGVyLCBjdXJyZW50KTsKLQltbWFwX2V2ZW50LT5ldmVudC50aWQgPSBwZXJmX2NvdW50ZXJfdGlkKGNvdW50ZXIsIGN1cnJlbnQpOwotCi0JcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIG1tYXBfZXZlbnQtPmV2ZW50KTsKLQlwZXJmX291dHB1dF9jb3B5KCZoYW5kbGUsIG1tYXBfZXZlbnQtPmZpbGVfbmFtZSwKLQkJCQkgICBtbWFwX2V2ZW50LT5maWxlX3NpemUpOwotCXBlcmZfb3V0cHV0X2VuZCgmaGFuZGxlKTsKLX0KLQotc3RhdGljIGludCBwZXJmX2NvdW50ZXJfbW1hcF9tYXRjaChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCSAgIHN0cnVjdCBwZXJmX21tYXBfZXZlbnQgKm1tYXBfZXZlbnQpCi17Ci0JaWYgKGNvdW50ZXItPmF0dHIubW1hcCkKLQkJcmV0dXJuIDE7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX21tYXBfY3R4KHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4LAotCQkJCSAgc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCi0JaWYgKHN5c3RlbV9zdGF0ZSAhPSBTWVNURU1fUlVOTklORyB8fCBsaXN0X2VtcHR5KCZjdHgtPmV2ZW50X2xpc3QpKQotCQlyZXR1cm47Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoY291bnRlciwgJmN0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKLQkJaWYgKHBlcmZfY291bnRlcl9tbWFwX21hdGNoKGNvdW50ZXIsIG1tYXBfZXZlbnQpKQotCQkJcGVyZl9jb3VudGVyX21tYXBfb3V0cHV0KGNvdW50ZXIsIG1tYXBfZXZlbnQpOwotCX0KLQlyY3VfcmVhZF91bmxvY2soKTsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9jb3VudGVyX21tYXBfZXZlbnQoc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKLXsKLQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OwotCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hID0gbW1hcF9ldmVudC0+dm1hOwotCXN0cnVjdCBmaWxlICpmaWxlID0gdm1hLT52bV9maWxlOwotCXVuc2lnbmVkIGludCBzaXplOwotCWNoYXIgdG1wWzE2XTsKLQljaGFyICpidWYgPSBOVUxMOwotCWNvbnN0IGNoYXIgKm5hbWU7Ci0KLQltZW1zZXQodG1wLCAwLCBzaXplb2YodG1wKSk7Ci0KLQlpZiAoZmlsZSkgewotCQkvKgotCQkgKiBkX3BhdGggd29ya3MgZnJvbSB0aGUgZW5kIG9mIHRoZSBidWZmZXIgYmFja3dhcmRzLCBzbyB3ZQotCQkgKiBuZWVkIHRvIGFkZCBlbm91Z2ggemVybyBieXRlcyBhZnRlciB0aGUgc3RyaW5nIHRvIGhhbmRsZQotCQkgKiB0aGUgNjRiaXQgYWxpZ25tZW50IHdlIGRvIGxhdGVyLgotCQkgKi8KLQkJYnVmID0ga3phbGxvYyhQQVRIX01BWCArIHNpemVvZih1NjQpLCBHRlBfS0VSTkVMKTsKLQkJaWYgKCFidWYpIHsKLQkJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vZW5vbWVtIiwgc2l6ZW9mKHRtcCkpOwotCQkJZ290byBnb3RfbmFtZTsKLQkJfQotCQluYW1lID0gZF9wYXRoKCZmaWxlLT5mX3BhdGgsIGJ1ZiwgUEFUSF9NQVgpOwotCQlpZiAoSVNfRVJSKG5hbWUpKSB7Ci0JCQluYW1lID0gc3RybmNweSh0bXAsICIvL3Rvb2xvbmciLCBzaXplb2YodG1wKSk7Ci0JCQlnb3RvIGdvdF9uYW1lOwotCQl9Ci0JfSBlbHNlIHsKLQkJaWYgKGFyY2hfdm1hX25hbWUobW1hcF9ldmVudC0+dm1hKSkgewotCQkJbmFtZSA9IHN0cm5jcHkodG1wLCBhcmNoX3ZtYV9uYW1lKG1tYXBfZXZlbnQtPnZtYSksCi0JCQkJICAgICAgIHNpemVvZih0bXApKTsKLQkJCWdvdG8gZ290X25hbWU7Ci0JCX0KLQotCQlpZiAoIXZtYS0+dm1fbW0pIHsKLQkJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIlt2ZHNvXSIsIHNpemVvZih0bXApKTsKLQkJCWdvdG8gZ290X25hbWU7Ci0JCX0KLQotCQluYW1lID0gc3RybmNweSh0bXAsICIvL2Fub24iLCBzaXplb2YodG1wKSk7Ci0JCWdvdG8gZ290X25hbWU7Ci0JfQotCi1nb3RfbmFtZToKLQlzaXplID0gQUxJR04oc3RybGVuKG5hbWUpKzEsIHNpemVvZih1NjQpKTsKLQotCW1tYXBfZXZlbnQtPmZpbGVfbmFtZSA9IG5hbWU7Ci0JbW1hcF9ldmVudC0+ZmlsZV9zaXplID0gc2l6ZTsKLQotCW1tYXBfZXZlbnQtPmV2ZW50LmhlYWRlci5zaXplID0gc2l6ZW9mKG1tYXBfZXZlbnQtPmV2ZW50KSArIHNpemU7Ci0KLQljcHVjdHggPSAmZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7Ci0JcGVyZl9jb3VudGVyX21tYXBfY3R4KCZjcHVjdHgtPmN0eCwgbW1hcF9ldmVudCk7Ci0JcHV0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7Ci0KLQlyY3VfcmVhZF9sb2NrKCk7Ci0JLyoKLQkgKiBkb2Vzbid0IHJlYWxseSBtYXR0ZXIgd2hpY2ggb2YgdGhlIGNoaWxkIGNvbnRleHRzIHRoZQotCSAqIGV2ZW50cyBlbmRzIHVwIGluLgotCSAqLwotCWN0eCA9IHJjdV9kZXJlZmVyZW5jZShjdXJyZW50LT5wZXJmX2NvdW50ZXJfY3R4cCk7Ci0JaWYgKGN0eCkKLQkJcGVyZl9jb3VudGVyX21tYXBfY3R4KGN0eCwgbW1hcF9ldmVudCk7Ci0JcmN1X3JlYWRfdW5sb2NrKCk7Ci0KLQlrZnJlZShidWYpOwotfQotCi12b2lkIF9fcGVyZl9jb3VudGVyX21tYXAoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCi17Ci0Jc3RydWN0IHBlcmZfbW1hcF9ldmVudCBtbWFwX2V2ZW50OwotCi0JaWYgKCFhdG9taWNfcmVhZCgmbnJfbW1hcF9jb3VudGVycykpCi0JCXJldHVybjsKLQotCW1tYXBfZXZlbnQgPSAoc3RydWN0IHBlcmZfbW1hcF9ldmVudCl7Ci0JCS52bWEJPSB2bWEsCi0JCS8qIC5maWxlX25hbWUgKi8KLQkJLyogLmZpbGVfc2l6ZSAqLwotCQkuZXZlbnQgID0gewotCQkJLmhlYWRlciA9IHsKLQkJCQkudHlwZSA9IFBFUkZfRVZFTlRfTU1BUCwKLQkJCQkubWlzYyA9IDAsCi0JCQkJLyogLnNpemUgKi8KLQkJCX0sCi0JCQkvKiAucGlkICovCi0JCQkvKiAudGlkICovCi0JCQkuc3RhcnQgID0gdm1hLT52bV9zdGFydCwKLQkJCS5sZW4gICAgPSB2bWEtPnZtX2VuZCAtIHZtYS0+dm1fc3RhcnQsCi0JCQkucGdvZmYgID0gdm1hLT52bV9wZ29mZiwKLQkJfSwKLQl9OwotCi0JcGVyZl9jb3VudGVyX21tYXBfZXZlbnQoJm1tYXBfZXZlbnQpOwotfQotCi0vKgotICogSVJRIHRocm90dGxlIGxvZ2dpbmcKLSAqLwotCi1zdGF0aWMgdm9pZCBwZXJmX2xvZ190aHJvdHRsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLCBpbnQgZW5hYmxlKQotewotCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOwotCWludCByZXQ7Ci0KLQlzdHJ1Y3QgewotCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIJaGVhZGVyOwotCQl1NjQJCQkJdGltZTsKLQkJdTY0CQkJCWlkOwotCQl1NjQJCQkJc3RyZWFtX2lkOwotCX0gdGhyb3R0bGVfZXZlbnQgPSB7Ci0JCS5oZWFkZXIgPSB7Ci0JCQkudHlwZSA9IFBFUkZfRVZFTlRfVEhST1RUTEUsCi0JCQkubWlzYyA9IDAsCi0JCQkuc2l6ZSA9IHNpemVvZih0aHJvdHRsZV9ldmVudCksCi0JCX0sCi0JCS50aW1lCQk9IHBlcmZfY2xvY2soKSwKLQkJLmlkCQk9IHByaW1hcnlfY291bnRlcl9pZChjb3VudGVyKSwKLQkJLnN0cmVhbV9pZAk9IGNvdW50ZXItPmlkLAotCX07Ci0KLQlpZiAoZW5hYmxlKQotCQl0aHJvdHRsZV9ldmVudC5oZWFkZXIudHlwZSA9IFBFUkZfRVZFTlRfVU5USFJPVFRMRTsKLQotCXJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGNvdW50ZXIsIHNpemVvZih0aHJvdHRsZV9ldmVudCksIDEsIDApOwotCWlmIChyZXQpCi0JCXJldHVybjsKLQotCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCB0aHJvdHRsZV9ldmVudCk7Ci0JcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOwotfQotCi0vKgotICogR2VuZXJpYyBjb3VudGVyIG92ZXJmbG93IGhhbmRsaW5nLCBzYW1wbGluZy4KLSAqLwotCi1zdGF0aWMgaW50IF9fcGVyZl9jb3VudGVyX292ZXJmbG93KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGludCBubWksCi0JCQkJICAgaW50IHRocm90dGxlLCBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKLQkJCQkgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKLXsKLQlpbnQgZXZlbnRzID0gYXRvbWljX3JlYWQoJmNvdW50ZXItPmV2ZW50X2xpbWl0KTsKLQlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MgPSAmY291bnRlci0+aHc7Ci0JaW50IHJldCA9IDA7Ci0KLQl0aHJvdHRsZSA9ICh0aHJvdHRsZSAmJiBjb3VudGVyLT5wbXUtPnVudGhyb3R0bGUgIT0gTlVMTCk7Ci0KLQlpZiAoIXRocm90dGxlKSB7Ci0JCWh3Yy0+aW50ZXJydXB0cysrOwotCX0gZWxzZSB7Ci0JCWlmIChod2MtPmludGVycnVwdHMgIT0gTUFYX0lOVEVSUlVQVFMpIHsKLQkJCWh3Yy0+aW50ZXJydXB0cysrOwotCQkJaWYgKEhaICogaHdjLT5pbnRlcnJ1cHRzID4KLQkJCQkJKHU2NClzeXNjdGxfcGVyZl9jb3VudGVyX3NhbXBsZV9yYXRlKSB7Ci0JCQkJaHdjLT5pbnRlcnJ1cHRzID0gTUFYX0lOVEVSUlVQVFM7Ci0JCQkJcGVyZl9sb2dfdGhyb3R0bGUoY291bnRlciwgMCk7Ci0JCQkJcmV0ID0gMTsKLQkJCX0KLQkJfSBlbHNlIHsKLQkJCS8qCi0JCQkgKiBLZWVwIHJlLWRpc2FibGluZyBjb3VudGVycyBldmVuIHRob3VnaCBvbiB0aGUgcHJldmlvdXMKLQkJCSAqIHBhc3Mgd2UgZGlzYWJsZWQgaXQgLSBqdXN0IGluIGNhc2Ugd2UgcmFjZWQgd2l0aCBhCi0JCQkgKiBzY2hlZC1pbiBhbmQgdGhlIGNvdW50ZXIgZ290IGVuYWJsZWQgYWdhaW46Ci0JCQkgKi8KLQkJCXJldCA9IDE7Ci0JCX0KLQl9Ci0KLQlpZiAoY291bnRlci0+YXR0ci5mcmVxKSB7Ci0JCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7Ci0JCXM2NCBkZWx0YSA9IG5vdyAtIGh3Yy0+ZnJlcV9zdGFtcDsKLQotCQlod2MtPmZyZXFfc3RhbXAgPSBub3c7Ci0KLQkJaWYgKGRlbHRhID4gMCAmJiBkZWx0YSA8IFRJQ0tfTlNFQykKLQkJCXBlcmZfYWRqdXN0X3BlcmlvZChjb3VudGVyLCBOU0VDX1BFUl9TRUMgLyAoaW50KWRlbHRhKTsKLQl9Ci0KLQkvKgotCSAqIFhYWCBldmVudF9saW1pdCBtaWdodCBub3QgcXVpdGUgd29yayBhcyBleHBlY3RlZCBvbiBpbmhlcml0ZWQKLQkgKiBjb3VudGVycwotCSAqLwotCi0JY291bnRlci0+cGVuZGluZ19raWxsID0gUE9MTF9JTjsKLQlpZiAoZXZlbnRzICYmIGF0b21pY19kZWNfYW5kX3Rlc3QoJmNvdW50ZXItPmV2ZW50X2xpbWl0KSkgewotCQlyZXQgPSAxOwotCQljb3VudGVyLT5wZW5kaW5nX2tpbGwgPSBQT0xMX0hVUDsKLQkJaWYgKG5taSkgewotCQkJY291bnRlci0+cGVuZGluZ19kaXNhYmxlID0gMTsKLQkJCXBlcmZfcGVuZGluZ19xdWV1ZSgmY291bnRlci0+cGVuZGluZywKLQkJCQkJICAgcGVyZl9wZW5kaW5nX2NvdW50ZXIpOwotCQl9IGVsc2UKLQkJCXBlcmZfY291bnRlcl9kaXNhYmxlKGNvdW50ZXIpOwotCX0KLQotCXBlcmZfY291bnRlcl9vdXRwdXQoY291bnRlciwgbm1pLCBkYXRhLCByZWdzKTsKLQlyZXR1cm4gcmV0OwotfQotCi1pbnQgcGVyZl9jb3VudGVyX292ZXJmbG93KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGludCBubWksCi0JCQkgIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAotCQkJICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKLXsKLQlyZXR1cm4gX19wZXJmX2NvdW50ZXJfb3ZlcmZsb3coY291bnRlciwgbm1pLCAxLCBkYXRhLCByZWdzKTsKLX0KLQotLyoKLSAqIEdlbmVyaWMgc29mdHdhcmUgY291bnRlciBpbmZyYXN0cnVjdHVyZQotICovCi0KLS8qCi0gKiBXZSBkaXJlY3RseSBpbmNyZW1lbnQgY291bnRlci0+Y291bnQgYW5kIGtlZXAgYSBzZWNvbmQgdmFsdWUgaW4KLSAqIGNvdW50ZXItPmh3LnBlcmlvZF9sZWZ0IHRvIGNvdW50IGludGVydmFscy4gVGhpcyBwZXJpb2QgY291bnRlcgotICogaXMga2VwdCBpbiB0aGUgcmFuZ2UgWy1zYW1wbGVfcGVyaW9kLCAwXSBzbyB0aGF0IHdlIGNhbiB1c2UgdGhlCi0gKiBzaWduIGFzIHRyaWdnZXIuCi0gKi8KLQotc3RhdGljIHU2NCBwZXJmX3N3Y291bnRlcl9zZXRfcGVyaW9kKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0Jc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OwotCXU2NCBwZXJpb2QgPSBod2MtPmxhc3RfcGVyaW9kOwotCXU2NCBuciwgb2Zmc2V0OwotCXM2NCBvbGQsIHZhbDsKLQotCWh3Yy0+bGFzdF9wZXJpb2QgPSBod2MtPnNhbXBsZV9wZXJpb2Q7Ci0KLWFnYWluOgotCW9sZCA9IHZhbCA9IGF0b21pYzY0X3JlYWQoJmh3Yy0+cGVyaW9kX2xlZnQpOwotCWlmICh2YWwgPCAwKQotCQlyZXR1cm4gMDsKLQotCW5yID0gZGl2NjRfdTY0KHBlcmlvZCArIHZhbCwgcGVyaW9kKTsKLQlvZmZzZXQgPSBuciAqIHBlcmlvZDsKLQl2YWwgLT0gb2Zmc2V0OwotCWlmIChhdG9taWM2NF9jbXB4Y2hnKCZod2MtPnBlcmlvZF9sZWZ0LCBvbGQsIHZhbCkgIT0gb2xkKQotCQlnb3RvIGFnYWluOwotCi0JcmV0dXJuIG5yOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX3N3Y291bnRlcl9vdmVyZmxvdyhzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCSAgICBpbnQgbm1pLCBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKLQkJCQkgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCi17Ci0Jc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OwotCWludCB0aHJvdHRsZSA9IDA7Ci0JdTY0IG92ZXJmbG93OwotCi0JZGF0YS0+cGVyaW9kID0gY291bnRlci0+aHcubGFzdF9wZXJpb2Q7Ci0Jb3ZlcmZsb3cgPSBwZXJmX3N3Y291bnRlcl9zZXRfcGVyaW9kKGNvdW50ZXIpOwotCi0JaWYgKGh3Yy0+aW50ZXJydXB0cyA9PSBNQVhfSU5URVJSVVBUUykKLQkJcmV0dXJuOwotCi0JZm9yICg7IG92ZXJmbG93OyBvdmVyZmxvdy0tKSB7Ci0JCWlmIChfX3BlcmZfY291bnRlcl9vdmVyZmxvdyhjb3VudGVyLCBubWksIHRocm90dGxlLAotCQkJCQkgICAgZGF0YSwgcmVncykpIHsKLQkJCS8qCi0JCQkgKiBXZSBpbmhpYml0IHRoZSBvdmVyZmxvdyBmcm9tIGhhcHBlbmluZyB3aGVuCi0JCQkgKiBod2MtPmludGVycnVwdHMgPT0gTUFYX0lOVEVSUlVQVFMuCi0JCQkgKi8KLQkJCWJyZWFrOwotCQl9Ci0JCXRocm90dGxlID0gMTsKLQl9Ci19Ci0KLXN0YXRpYyB2b2lkIHBlcmZfc3djb3VudGVyX3VudGhyb3R0bGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQkvKgotCSAqIE5vdGhpbmcgdG8gZG8sIHdlIGFscmVhZHkgcmVzZXQgaHdjLT5pbnRlcnJ1cHRzLgotCSAqLwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX3N3Y291bnRlcl9hZGQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IG5yLAotCQkJICAgICAgIGludCBubWksIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAotCQkJICAgICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzKQotewotCXN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YyA9ICZjb3VudGVyLT5odzsKLQotCWF0b21pYzY0X2FkZChuciwgJmNvdW50ZXItPmNvdW50KTsKLQotCWlmICghaHdjLT5zYW1wbGVfcGVyaW9kKQotCQlyZXR1cm47Ci0KLQlpZiAoIXJlZ3MpCi0JCXJldHVybjsKLQotCWlmICghYXRvbWljNjRfYWRkX25lZ2F0aXZlKG5yLCAmaHdjLT5wZXJpb2RfbGVmdCkpCi0JCXBlcmZfc3djb3VudGVyX292ZXJmbG93KGNvdW50ZXIsIG5taSwgZGF0YSwgcmVncyk7Ci19Ci0KLXN0YXRpYyBpbnQgcGVyZl9zd2NvdW50ZXJfaXNfY291bnRpbmcoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQkvKgotCSAqIFRoZSBjb3VudGVyIGlzIGFjdGl2ZSwgd2UncmUgZ29vZCEKLQkgKi8KLQlpZiAoY291bnRlci0+c3RhdGUgPT0gUEVSRl9DT1VOVEVSX1NUQVRFX0FDVElWRSkKLQkJcmV0dXJuIDE7Ci0KLQkvKgotCSAqIFRoZSBjb3VudGVyIGlzIG9mZi9lcnJvciwgbm90IGNvdW50aW5nLgotCSAqLwotCWlmIChjb3VudGVyLT5zdGF0ZSAhPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkUpCi0JCXJldHVybiAwOwotCi0JLyoKLQkgKiBUaGUgY291bnRlciBpcyBpbmFjdGl2ZSwgaWYgdGhlIGNvbnRleHQgaXMgYWN0aXZlCi0JICogd2UncmUgcGFydCBvZiBhIGdyb3VwIHRoYXQgZGlkbid0IG1ha2UgaXQgb24gdGhlICdwbXUnLAotCSAqIG5vdCBjb3VudGluZy4KLQkgKi8KLQlpZiAoY291bnRlci0+Y3R4LT5pc19hY3RpdmUpCi0JCXJldHVybiAwOwotCi0JLyoKLQkgKiBXZSdyZSBpbmFjdGl2ZSBhbmQgdGhlIGNvbnRleHQgaXMgdG9vLCB0aGlzIG1lYW5zIHRoZQotCSAqIHRhc2sgaXMgc2NoZWR1bGVkIG91dCwgd2UncmUgY291bnRpbmcgZXZlbnRzIHRoYXQgaGFwcGVuCi0JICogdG8gdXMsIGxpa2UgbWlncmF0aW9uIGV2ZW50cy4KLQkgKi8KLQlyZXR1cm4gMTsKLX0KLQotc3RhdGljIGludCBwZXJmX3N3Y291bnRlcl9tYXRjaChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyLAotCQkJCWVudW0gcGVyZl90eXBlX2lkIHR5cGUsCi0JCQkJdTMyIGV2ZW50X2lkLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKLXsKLQlpZiAoIXBlcmZfc3djb3VudGVyX2lzX2NvdW50aW5nKGNvdW50ZXIpKQotCQlyZXR1cm4gMDsKLQotCWlmIChjb3VudGVyLT5hdHRyLnR5cGUgIT0gdHlwZSkKLQkJcmV0dXJuIDA7Ci0JaWYgKGNvdW50ZXItPmF0dHIuY29uZmlnICE9IGV2ZW50X2lkKQotCQlyZXR1cm4gMDsKLQotCWlmIChyZWdzKSB7Ci0JCWlmIChjb3VudGVyLT5hdHRyLmV4Y2x1ZGVfdXNlciAmJiB1c2VyX21vZGUocmVncykpCi0JCQlyZXR1cm4gMDsKLQotCQlpZiAoY291bnRlci0+YXR0ci5leGNsdWRlX2tlcm5lbCAmJiAhdXNlcl9tb2RlKHJlZ3MpKQotCQkJcmV0dXJuIDA7Ci0JfQotCi0JcmV0dXJuIDE7Ci19Ci0KLXN0YXRpYyB2b2lkIHBlcmZfc3djb3VudGVyX2N0eF9ldmVudChzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkJCQkgICAgIGVudW0gcGVyZl90eXBlX2lkIHR5cGUsCi0JCQkJICAgICB1MzIgZXZlbnRfaWQsIHU2NCBuciwgaW50IG5taSwKLQkJCQkgICAgIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAotCQkJCSAgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcjsKLQotCWlmIChzeXN0ZW1fc3RhdGUgIT0gU1lTVEVNX1JVTk5JTkcgfHwgbGlzdF9lbXB0eSgmY3R4LT5ldmVudF9saXN0KSkKLQkJcmV0dXJuOwotCi0JcmN1X3JlYWRfbG9jaygpOwotCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGNvdW50ZXIsICZjdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7Ci0JCWlmIChwZXJmX3N3Y291bnRlcl9tYXRjaChjb3VudGVyLCB0eXBlLCBldmVudF9pZCwgcmVncykpCi0JCQlwZXJmX3N3Y291bnRlcl9hZGQoY291bnRlciwgbnIsIG5taSwgZGF0YSwgcmVncyk7Ci0JfQotCXJjdV9yZWFkX3VubG9jaygpOwotfQotCi1zdGF0aWMgaW50ICpwZXJmX3N3Y291bnRlcl9yZWN1cnNpb25fY29udGV4dChzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQotewotCWlmIChpbl9ubWkoKSkKLQkJcmV0dXJuICZjcHVjdHgtPnJlY3Vyc2lvblszXTsKLQotCWlmIChpbl9pcnEoKSkKLQkJcmV0dXJuICZjcHVjdHgtPnJlY3Vyc2lvblsyXTsKLQotCWlmIChpbl9zb2Z0aXJxKCkpCi0JCXJldHVybiAmY3B1Y3R4LT5yZWN1cnNpb25bMV07Ci0KLQlyZXR1cm4gJmNwdWN0eC0+cmVjdXJzaW9uWzBdOwotfQotCi1zdGF0aWMgdm9pZCBkb19wZXJmX3N3Y291bnRlcl9ldmVudChlbnVtIHBlcmZfdHlwZV9pZCB0eXBlLCB1MzIgZXZlbnQsCi0JCQkJICAgIHU2NCBuciwgaW50IG5taSwKLQkJCQkgICAgc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEsCi0JCQkJICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzKQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7Ci0JaW50ICpyZWN1cnNpb24gPSBwZXJmX3N3Y291bnRlcl9yZWN1cnNpb25fY29udGV4dChjcHVjdHgpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4OwotCi0JaWYgKCpyZWN1cnNpb24pCi0JCWdvdG8gb3V0OwotCi0JKCpyZWN1cnNpb24pKys7Ci0JYmFycmllcigpOwotCi0JcGVyZl9zd2NvdW50ZXJfY3R4X2V2ZW50KCZjcHVjdHgtPmN0eCwgdHlwZSwgZXZlbnQsCi0JCQkJIG5yLCBubWksIGRhdGEsIHJlZ3MpOwotCXJjdV9yZWFkX2xvY2soKTsKLQkvKgotCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCi0JICogZXZlbnRzIGVuZHMgdXAgaW4uCi0JICovCi0JY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfY291bnRlcl9jdHhwKTsKLQlpZiAoY3R4KQotCQlwZXJmX3N3Y291bnRlcl9jdHhfZXZlbnQoY3R4LCB0eXBlLCBldmVudCwgbnIsIG5taSwgZGF0YSwgcmVncyk7Ci0JcmN1X3JlYWRfdW5sb2NrKCk7Ci0KLQliYXJyaWVyKCk7Ci0JKCpyZWN1cnNpb24pLS07Ci0KLW91dDoKLQlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKLX0KLQotdm9pZCBfX3BlcmZfc3djb3VudGVyX2V2ZW50KHUzMiBldmVudCwgdTY0IG5yLCBpbnQgbm1pLAotCQkJICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1NjQgYWRkcikKLXsKLQlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSBkYXRhID0gewotCQkuYWRkciA9IGFkZHIsCi0JfTsKLQotCWRvX3BlcmZfc3djb3VudGVyX2V2ZW50KFBFUkZfVFlQRV9TT0ZUV0FSRSwgZXZlbnQsIG5yLCBubWksCi0JCQkJJmRhdGEsIHJlZ3MpOwotfQotCi1zdGF0aWMgdm9pZCBwZXJmX3N3Y291bnRlcl9yZWFkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci19Ci0KLXN0YXRpYyBpbnQgcGVyZl9zd2NvdW50ZXJfZW5hYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0Jc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjID0gJmNvdW50ZXItPmh3OwotCi0JaWYgKGh3Yy0+c2FtcGxlX3BlcmlvZCkgewotCQlod2MtPmxhc3RfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kOwotCQlwZXJmX3N3Y291bnRlcl9zZXRfcGVyaW9kKGNvdW50ZXIpOwotCX0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgcGVyZl9zd2NvdW50ZXJfZGlzYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IHBtdSBwZXJmX29wc19nZW5lcmljID0gewotCS5lbmFibGUJCT0gcGVyZl9zd2NvdW50ZXJfZW5hYmxlLAotCS5kaXNhYmxlCT0gcGVyZl9zd2NvdW50ZXJfZGlzYWJsZSwKLQkucmVhZAkJPSBwZXJmX3N3Y291bnRlcl9yZWFkLAotCS51bnRocm90dGxlCT0gcGVyZl9zd2NvdW50ZXJfdW50aHJvdHRsZSwKLX07Ci0KLS8qCi0gKiBocnRpbWVyIGJhc2VkIHN3Y291bnRlciBjYWxsYmFjawotICovCi0KLXN0YXRpYyBlbnVtIGhydGltZXJfcmVzdGFydCBwZXJmX3N3Y291bnRlcl9ocnRpbWVyKHN0cnVjdCBocnRpbWVyICpocnRpbWVyKQotewotCWVudW0gaHJ0aW1lcl9yZXN0YXJ0IHJldCA9IEhSVElNRVJfUkVTVEFSVDsKLQlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSBkYXRhOwotCXN0cnVjdCBwdF9yZWdzICpyZWdzOwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0JdTY0IHBlcmlvZDsKLQotCWNvdW50ZXIJPSBjb250YWluZXJfb2YoaHJ0aW1lciwgc3RydWN0IHBlcmZfY291bnRlciwgaHcuaHJ0aW1lcik7Ci0JY291bnRlci0+cG11LT5yZWFkKGNvdW50ZXIpOwotCi0JZGF0YS5hZGRyID0gMDsKLQlyZWdzID0gZ2V0X2lycV9yZWdzKCk7Ci0JLyoKLQkgKiBJbiBjYXNlIHdlIGV4Y2x1ZGUga2VybmVsIElQcyBvciBhcmUgc29tZWhvdyBub3QgaW4gaW50ZXJydXB0Ci0JICogY29udGV4dCwgcHJvdmlkZSB0aGUgbmV4dCBiZXN0IHRoaW5nLCB0aGUgdXNlciBJUC4KLQkgKi8KLQlpZiAoKGNvdW50ZXItPmF0dHIuZXhjbHVkZV9rZXJuZWwgfHwgIXJlZ3MpICYmCi0JCQkhY291bnRlci0+YXR0ci5leGNsdWRlX3VzZXIpCi0JCXJlZ3MgPSB0YXNrX3B0X3JlZ3MoY3VycmVudCk7Ci0KLQlpZiAocmVncykgewotCQlpZiAocGVyZl9jb3VudGVyX292ZXJmbG93KGNvdW50ZXIsIDAsICZkYXRhLCByZWdzKSkKLQkJCXJldCA9IEhSVElNRVJfTk9SRVNUQVJUOwotCX0KLQotCXBlcmlvZCA9IG1heF90KHU2NCwgMTAwMDAsIGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QpOwotCWhydGltZXJfZm9yd2FyZF9ub3coaHJ0aW1lciwgbnNfdG9fa3RpbWUocGVyaW9kKSk7Ci0KLQlyZXR1cm4gcmV0OwotfQotCi0vKgotICogU29mdHdhcmUgY291bnRlcjogY3B1IHdhbGwgdGltZSBjbG9jawotICovCi0KLXN0YXRpYyB2b2lkIGNwdV9jbG9ja19wZXJmX2NvdW50ZXJfdXBkYXRlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JaW50IGNwdSA9IHJhd19zbXBfcHJvY2Vzc29yX2lkKCk7Ci0JczY0IHByZXY7Ci0JdTY0IG5vdzsKLQotCW5vdyA9IGNwdV9jbG9jayhjcHUpOwotCXByZXYgPSBhdG9taWM2NF9yZWFkKCZjb3VudGVyLT5ody5wcmV2X2NvdW50KTsKLQlhdG9taWM2NF9zZXQoJmNvdW50ZXItPmh3LnByZXZfY291bnQsIG5vdyk7Ci0JYXRvbWljNjRfYWRkKG5vdyAtIHByZXYsICZjb3VudGVyLT5jb3VudCk7Ci19Ci0KLXN0YXRpYyBpbnQgY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9lbmFibGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQlzdHJ1Y3QgaHdfcGVyZl9jb3VudGVyICpod2MgPSAmY291bnRlci0+aHc7Ci0JaW50IGNwdSA9IHJhd19zbXBfcHJvY2Vzc29yX2lkKCk7Ci0KLQlhdG9taWM2NF9zZXQoJmh3Yy0+cHJldl9jb3VudCwgY3B1X2Nsb2NrKGNwdSkpOwotCWhydGltZXJfaW5pdCgmaHdjLT5ocnRpbWVyLCBDTE9DS19NT05PVE9OSUMsIEhSVElNRVJfTU9ERV9SRUwpOwotCWh3Yy0+aHJ0aW1lci5mdW5jdGlvbiA9IHBlcmZfc3djb3VudGVyX2hydGltZXI7Ci0JaWYgKGh3Yy0+c2FtcGxlX3BlcmlvZCkgewotCQl1NjQgcGVyaW9kID0gbWF4X3QodTY0LCAxMDAwMCwgaHdjLT5zYW1wbGVfcGVyaW9kKTsKLQkJX19ocnRpbWVyX3N0YXJ0X3JhbmdlX25zKCZod2MtPmhydGltZXIsCi0JCQkJbnNfdG9fa3RpbWUocGVyaW9kKSwgMCwKLQkJCQlIUlRJTUVSX01PREVfUkVMLCAwKTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JaWYgKGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QpCi0JCWhydGltZXJfY2FuY2VsKCZjb3VudGVyLT5ody5ocnRpbWVyKTsKLQljcHVfY2xvY2tfcGVyZl9jb3VudGVyX3VwZGF0ZShjb3VudGVyKTsKLX0KLQotc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9yZWFkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JY3B1X2Nsb2NrX3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlcik7Ci19Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBlcmZfb3BzX2NwdV9jbG9jayA9IHsKLQkuZW5hYmxlCQk9IGNwdV9jbG9ja19wZXJmX2NvdW50ZXJfZW5hYmxlLAotCS5kaXNhYmxlCT0gY3B1X2Nsb2NrX3BlcmZfY291bnRlcl9kaXNhYmxlLAotCS5yZWFkCQk9IGNwdV9jbG9ja19wZXJmX2NvdW50ZXJfcmVhZCwKLX07Ci0KLS8qCi0gKiBTb2Z0d2FyZSBjb3VudGVyOiB0YXNrIHRpbWUgY2xvY2sKLSAqLwotCi1zdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl91cGRhdGUoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlciwgdTY0IG5vdykKLXsKLQl1NjQgcHJldjsKLQlzNjQgZGVsdGE7Ci0KLQlwcmV2ID0gYXRvbWljNjRfeGNoZygmY291bnRlci0+aHcucHJldl9jb3VudCwgbm93KTsKLQlkZWx0YSA9IG5vdyAtIHByZXY7Ci0JYXRvbWljNjRfYWRkKGRlbHRhLCAmY291bnRlci0+Y291bnQpOwotfQotCi1zdGF0aWMgaW50IHRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX2VuYWJsZShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXN0cnVjdCBod19wZXJmX2NvdW50ZXIgKmh3YyA9ICZjb3VudGVyLT5odzsKLQl1NjQgbm93OwotCi0Jbm93ID0gY291bnRlci0+Y3R4LT50aW1lOwotCi0JYXRvbWljNjRfc2V0KCZod2MtPnByZXZfY291bnQsIG5vdyk7Ci0JaHJ0aW1lcl9pbml0KCZod2MtPmhydGltZXIsIENMT0NLX01PTk9UT05JQywgSFJUSU1FUl9NT0RFX1JFTCk7Ci0JaHdjLT5ocnRpbWVyLmZ1bmN0aW9uID0gcGVyZl9zd2NvdW50ZXJfaHJ0aW1lcjsKLQlpZiAoaHdjLT5zYW1wbGVfcGVyaW9kKSB7Ci0JCXU2NCBwZXJpb2QgPSBtYXhfdCh1NjQsIDEwMDAwLCBod2MtPnNhbXBsZV9wZXJpb2QpOwotCQlfX2hydGltZXJfc3RhcnRfcmFuZ2VfbnMoJmh3Yy0+aHJ0aW1lciwKLQkJCQluc190b19rdGltZShwZXJpb2QpLCAwLAotCQkJCUhSVElNRVJfTU9ERV9SRUwsIDApOwotCX0KLQotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl9kaXNhYmxlKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JaWYgKGNvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2QpCi0JCWhydGltZXJfY2FuY2VsKCZjb3VudGVyLT5ody5ocnRpbWVyKTsKLQl0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl91cGRhdGUoY291bnRlciwgY291bnRlci0+Y3R4LT50aW1lKTsKLQotfQotCi1zdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfY291bnRlcl9yZWFkKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JdTY0IHRpbWU7Ci0KLQlpZiAoIWluX25taSgpKSB7Ci0JCXVwZGF0ZV9jb250ZXh0X3RpbWUoY291bnRlci0+Y3R4KTsKLQkJdGltZSA9IGNvdW50ZXItPmN0eC0+dGltZTsKLQl9IGVsc2UgewotCQl1NjQgbm93ID0gcGVyZl9jbG9jaygpOwotCQl1NjQgZGVsdGEgPSBub3cgLSBjb3VudGVyLT5jdHgtPnRpbWVzdGFtcDsKLQkJdGltZSA9IGNvdW50ZXItPmN0eC0+dGltZSArIGRlbHRhOwotCX0KLQotCXRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX3VwZGF0ZShjb3VudGVyLCB0aW1lKTsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgcGVyZl9vcHNfdGFza19jbG9jayA9IHsKLQkuZW5hYmxlCQk9IHRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX2VuYWJsZSwKLQkuZGlzYWJsZQk9IHRhc2tfY2xvY2tfcGVyZl9jb3VudGVyX2Rpc2FibGUsCi0JLnJlYWQJCT0gdGFza19jbG9ja19wZXJmX2NvdW50ZXJfcmVhZCwKLX07Ci0KLSNpZmRlZiBDT05GSUdfRVZFTlRfUFJPRklMRQotdm9pZCBwZXJmX3RwY291bnRlcl9ldmVudChpbnQgZXZlbnRfaWQsIHU2NCBhZGRyLCB1NjQgY291bnQsIHZvaWQgKnJlY29yZCwKLQkJCSAgaW50IGVudHJ5X3NpemUpCi17Ci0Jc3RydWN0IHBlcmZfcmF3X3JlY29yZCByYXcgPSB7Ci0JCS5zaXplID0gZW50cnlfc2l6ZSwKLQkJLmRhdGEgPSByZWNvcmQsCi0JfTsKLQotCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhIGRhdGEgPSB7Ci0JCS5hZGRyID0gYWRkciwKLQkJLnJhdyA9ICZyYXcsCi0JfTsKLQotCXN0cnVjdCBwdF9yZWdzICpyZWdzID0gZ2V0X2lycV9yZWdzKCk7Ci0KLQlpZiAoIXJlZ3MpCi0JCXJlZ3MgPSB0YXNrX3B0X3JlZ3MoY3VycmVudCk7Ci0KLQlkb19wZXJmX3N3Y291bnRlcl9ldmVudChQRVJGX1RZUEVfVFJBQ0VQT0lOVCwgZXZlbnRfaWQsIGNvdW50LCAxLAotCQkJCSZkYXRhLCByZWdzKTsKLX0KLUVYUE9SVF9TWU1CT0xfR1BMKHBlcmZfdHBjb3VudGVyX2V2ZW50KTsKLQotZXh0ZXJuIGludCBmdHJhY2VfcHJvZmlsZV9lbmFibGUoaW50KTsKLWV4dGVybiB2b2lkIGZ0cmFjZV9wcm9maWxlX2Rpc2FibGUoaW50KTsKLQotc3RhdGljIHZvaWQgdHBfcGVyZl9jb3VudGVyX2Rlc3Ryb3koc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQlmdHJhY2VfcHJvZmlsZV9kaXNhYmxlKGNvdW50ZXItPmF0dHIuY29uZmlnKTsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgKnRwX3BlcmZfY291bnRlcl9pbml0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIpCi17Ci0JLyoKLQkgKiBSYXcgdHJhY2Vwb2ludCBkYXRhIGlzIGEgc2V2ZXJlIGRhdGEgbGVhaywgb25seSBhbGxvdyByb290IHRvCi0JICogaGF2ZSB0aGVzZS4KLQkgKi8KLQlpZiAoKGNvdW50ZXItPmF0dHIuc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9SQVcpICYmCi0JCQlwZXJmX3BhcmFub2lkX3RyYWNlcG9pbnRfcmF3KCkgJiYKLQkJCSFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQotCQlyZXR1cm4gRVJSX1BUUigtRVBFUk0pOwotCi0JaWYgKGZ0cmFjZV9wcm9maWxlX2VuYWJsZShjb3VudGVyLT5hdHRyLmNvbmZpZykpCi0JCXJldHVybiBOVUxMOwotCi0JY291bnRlci0+ZGVzdHJveSA9IHRwX3BlcmZfY291bnRlcl9kZXN0cm95OwotCi0JcmV0dXJuICZwZXJmX29wc19nZW5lcmljOwotfQotI2Vsc2UKLXN0YXRpYyBjb25zdCBzdHJ1Y3QgcG11ICp0cF9wZXJmX2NvdW50ZXJfaW5pdChzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXJldHVybiBOVUxMOwotfQotI2VuZGlmCi0KLWF0b21pY190IHBlcmZfc3djb3VudGVyX2VuYWJsZWRbUEVSRl9DT1VOVF9TV19NQVhdOwotCi1zdGF0aWMgdm9pZCBzd19wZXJmX2NvdW50ZXJfZGVzdHJveShzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyKQotewotCXU2NCBldmVudF9pZCA9IGNvdW50ZXItPmF0dHIuY29uZmlnOwotCi0JV0FSTl9PTihjb3VudGVyLT5wYXJlbnQpOwotCi0JYXRvbWljX2RlYygmcGVyZl9zd2NvdW50ZXJfZW5hYmxlZFtldmVudF9pZF0pOwotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IHBtdSAqc3dfcGVyZl9jb3VudGVyX2luaXQoc3RydWN0IHBlcmZfY291bnRlciAqY291bnRlcikKLXsKLQljb25zdCBzdHJ1Y3QgcG11ICpwbXUgPSBOVUxMOwotCXU2NCBldmVudF9pZCA9IGNvdW50ZXItPmF0dHIuY29uZmlnOwotCi0JLyoKLQkgKiBTb2Z0d2FyZSBjb3VudGVycyAoY3VycmVudGx5KSBjYW4ndCBpbiBnZW5lcmFsIGRpc3Rpbmd1aXNoCi0JICogYmV0d2VlbiB1c2VyLCBrZXJuZWwgYW5kIGh5cGVydmlzb3IgZXZlbnRzLgotCSAqIEhvd2V2ZXIsIGNvbnRleHQgc3dpdGNoZXMgYW5kIGNwdSBtaWdyYXRpb25zIGFyZSBjb25zaWRlcmVkCi0JICogdG8gYmUga2VybmVsIGV2ZW50cywgYW5kIHBhZ2UgZmF1bHRzIGFyZSBuZXZlciBoeXBlcnZpc29yCi0JICogZXZlbnRzLgotCSAqLwotCXN3aXRjaCAoZXZlbnRfaWQpIHsKLQljYXNlIFBFUkZfQ09VTlRfU1dfQ1BVX0NMT0NLOgotCQlwbXUgPSAmcGVyZl9vcHNfY3B1X2Nsb2NrOwotCi0JCWJyZWFrOwotCWNhc2UgUEVSRl9DT1VOVF9TV19UQVNLX0NMT0NLOgotCQkvKgotCQkgKiBJZiB0aGUgdXNlciBpbnN0YW50aWF0ZXMgdGhpcyBhcyBhIHBlci1jcHUgY291bnRlciwKLQkJICogdXNlIHRoZSBjcHVfY2xvY2sgY291bnRlciBpbnN0ZWFkLgotCQkgKi8KLQkJaWYgKGNvdW50ZXItPmN0eC0+dGFzaykKLQkJCXBtdSA9ICZwZXJmX29wc190YXNrX2Nsb2NrOwotCQllbHNlCi0JCQlwbXUgPSAmcGVyZl9vcHNfY3B1X2Nsb2NrOwotCi0JCWJyZWFrOwotCWNhc2UgUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUUzoKLQljYXNlIFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUlOOgotCWNhc2UgUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUU19NQUo6Ci0JY2FzZSBQRVJGX0NPVU5UX1NXX0NPTlRFWFRfU1dJVENIRVM6Ci0JY2FzZSBQRVJGX0NPVU5UX1NXX0NQVV9NSUdSQVRJT05TOgotCQlpZiAoIWNvdW50ZXItPnBhcmVudCkgewotCQkJYXRvbWljX2luYygmcGVyZl9zd2NvdW50ZXJfZW5hYmxlZFtldmVudF9pZF0pOwotCQkJY291bnRlci0+ZGVzdHJveSA9IHN3X3BlcmZfY291bnRlcl9kZXN0cm95OwotCQl9Ci0JCXBtdSA9ICZwZXJmX29wc19nZW5lcmljOwotCQlicmVhazsKLQl9Ci0KLQlyZXR1cm4gcG11OwotfQotCi0vKgotICogQWxsb2NhdGUgYW5kIGluaXRpYWxpemUgYSBjb3VudGVyIHN0cnVjdHVyZQotICovCi1zdGF0aWMgc3RydWN0IHBlcmZfY291bnRlciAqCi1wZXJmX2NvdW50ZXJfYWxsb2Moc3RydWN0IHBlcmZfY291bnRlcl9hdHRyICphdHRyLAotCQkgICBpbnQgY3B1LAotCQkgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCwKLQkJICAgc3RydWN0IHBlcmZfY291bnRlciAqZ3JvdXBfbGVhZGVyLAotCQkgICBzdHJ1Y3QgcGVyZl9jb3VudGVyICpwYXJlbnRfY291bnRlciwKLQkJICAgZ2ZwX3QgZ2ZwZmxhZ3MpCi17Ci0JY29uc3Qgc3RydWN0IHBtdSAqcG11OwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXI7Ci0Jc3RydWN0IGh3X3BlcmZfY291bnRlciAqaHdjOwotCWxvbmcgZXJyOwotCi0JY291bnRlciA9IGt6YWxsb2Moc2l6ZW9mKCpjb3VudGVyKSwgZ2ZwZmxhZ3MpOwotCWlmICghY291bnRlcikKLQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Ci0KLQkvKgotCSAqIFNpbmdsZSBjb3VudGVycyBhcmUgdGhlaXIgb3duIGdyb3VwIGxlYWRlcnMsIHdpdGggYW4KLQkgKiBlbXB0eSBzaWJsaW5nIGxpc3Q6Ci0JICovCi0JaWYgKCFncm91cF9sZWFkZXIpCi0JCWdyb3VwX2xlYWRlciA9IGNvdW50ZXI7Ci0KLQltdXRleF9pbml0KCZjb3VudGVyLT5jaGlsZF9tdXRleCk7Ci0JSU5JVF9MSVNUX0hFQUQoJmNvdW50ZXItPmNoaWxkX2xpc3QpOwotCi0JSU5JVF9MSVNUX0hFQUQoJmNvdW50ZXItPmdyb3VwX2VudHJ5KTsKLQlJTklUX0xJU1RfSEVBRCgmY291bnRlci0+ZXZlbnRfZW50cnkpOwotCUlOSVRfTElTVF9IRUFEKCZjb3VudGVyLT5zaWJsaW5nX2xpc3QpOwotCWluaXRfd2FpdHF1ZXVlX2hlYWQoJmNvdW50ZXItPndhaXRxKTsKLQotCW11dGV4X2luaXQoJmNvdW50ZXItPm1tYXBfbXV0ZXgpOwotCi0JY291bnRlci0+Y3B1CQk9IGNwdTsKLQljb3VudGVyLT5hdHRyCQk9ICphdHRyOwotCWNvdW50ZXItPmdyb3VwX2xlYWRlcgk9IGdyb3VwX2xlYWRlcjsKLQljb3VudGVyLT5wbXUJCT0gTlVMTDsKLQljb3VudGVyLT5jdHgJCT0gY3R4OwotCWNvdW50ZXItPm9uY3B1CQk9IC0xOwotCi0JY291bnRlci0+cGFyZW50CQk9IHBhcmVudF9jb3VudGVyOwotCi0JY291bnRlci0+bnMJCT0gZ2V0X3BpZF9ucyhjdXJyZW50LT5uc3Byb3h5LT5waWRfbnMpOwotCWNvdW50ZXItPmlkCQk9IGF0b21pYzY0X2luY19yZXR1cm4oJnBlcmZfY291bnRlcl9pZCk7Ci0KLQljb3VudGVyLT5zdGF0ZQkJPSBQRVJGX0NPVU5URVJfU1RBVEVfSU5BQ1RJVkU7Ci0KLQlpZiAoYXR0ci0+ZGlzYWJsZWQpCi0JCWNvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX09GRjsKLQotCXBtdSA9IE5VTEw7Ci0KLQlod2MgPSAmY291bnRlci0+aHc7Ci0JaHdjLT5zYW1wbGVfcGVyaW9kID0gYXR0ci0+c2FtcGxlX3BlcmlvZDsKLQlpZiAoYXR0ci0+ZnJlcSAmJiBhdHRyLT5zYW1wbGVfZnJlcSkKLQkJaHdjLT5zYW1wbGVfcGVyaW9kID0gMTsKLQlod2MtPmxhc3RfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kOwotCi0JYXRvbWljNjRfc2V0KCZod2MtPnBlcmlvZF9sZWZ0LCBod2MtPnNhbXBsZV9wZXJpb2QpOwotCi0JLyoKLQkgKiB3ZSBjdXJyZW50bHkgZG8gbm90IHN1cHBvcnQgUEVSRl9GT1JNQVRfR1JPVVAgb24gaW5oZXJpdGVkIGNvdW50ZXJzCi0JICovCi0JaWYgKGF0dHItPmluaGVyaXQgJiYgKGF0dHItPnJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfR1JPVVApKQotCQlnb3RvIGRvbmU7Ci0KLQlzd2l0Y2ggKGF0dHItPnR5cGUpIHsKLQljYXNlIFBFUkZfVFlQRV9SQVc6Ci0JY2FzZSBQRVJGX1RZUEVfSEFSRFdBUkU6Ci0JY2FzZSBQRVJGX1RZUEVfSFdfQ0FDSEU6Ci0JCXBtdSA9IGh3X3BlcmZfY291bnRlcl9pbml0KGNvdW50ZXIpOwotCQlicmVhazsKLQotCWNhc2UgUEVSRl9UWVBFX1NPRlRXQVJFOgotCQlwbXUgPSBzd19wZXJmX2NvdW50ZXJfaW5pdChjb3VudGVyKTsKLQkJYnJlYWs7Ci0KLQljYXNlIFBFUkZfVFlQRV9UUkFDRVBPSU5UOgotCQlwbXUgPSB0cF9wZXJmX2NvdW50ZXJfaW5pdChjb3VudGVyKTsKLQkJYnJlYWs7Ci0KLQlkZWZhdWx0OgotCQlicmVhazsKLQl9Ci1kb25lOgotCWVyciA9IDA7Ci0JaWYgKCFwbXUpCi0JCWVyciA9IC1FSU5WQUw7Ci0JZWxzZSBpZiAoSVNfRVJSKHBtdSkpCi0JCWVyciA9IFBUUl9FUlIocG11KTsKLQotCWlmIChlcnIpIHsKLQkJaWYgKGNvdW50ZXItPm5zKQotCQkJcHV0X3BpZF9ucyhjb3VudGVyLT5ucyk7Ci0JCWtmcmVlKGNvdW50ZXIpOwotCQlyZXR1cm4gRVJSX1BUUihlcnIpOwotCX0KLQotCWNvdW50ZXItPnBtdSA9IHBtdTsKLQotCWlmICghY291bnRlci0+cGFyZW50KSB7Ci0JCWF0b21pY19pbmMoJm5yX2NvdW50ZXJzKTsKLQkJaWYgKGNvdW50ZXItPmF0dHIubW1hcCkKLQkJCWF0b21pY19pbmMoJm5yX21tYXBfY291bnRlcnMpOwotCQlpZiAoY291bnRlci0+YXR0ci5jb21tKQotCQkJYXRvbWljX2luYygmbnJfY29tbV9jb3VudGVycyk7Ci0JCWlmIChjb3VudGVyLT5hdHRyLnRhc2spCi0JCQlhdG9taWNfaW5jKCZucl90YXNrX2NvdW50ZXJzKTsKLQl9Ci0KLQlyZXR1cm4gY291bnRlcjsKLX0KLQotc3RhdGljIGludCBwZXJmX2NvcHlfYXR0cihzdHJ1Y3QgcGVyZl9jb3VudGVyX2F0dHIgX191c2VyICp1YXR0ciwKLQkJCSAgc3RydWN0IHBlcmZfY291bnRlcl9hdHRyICphdHRyKQotewotCXUzMiBzaXplOwotCWludCByZXQ7Ci0KLQlpZiAoIWFjY2Vzc19vayhWRVJJRllfV1JJVEUsIHVhdHRyLCBQRVJGX0FUVFJfU0laRV9WRVIwKSkKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0KLQkvKgotCSAqIHplcm8gdGhlIGZ1bGwgc3RydWN0dXJlLCBzbyB0aGF0IGEgc2hvcnQgY29weSB3aWxsIGJlIG5pY2UuCi0JICovCi0JbWVtc2V0KGF0dHIsIDAsIHNpemVvZigqYXR0cikpOwotCi0JcmV0ID0gZ2V0X3VzZXIoc2l6ZSwgJnVhdHRyLT5zaXplKTsKLQlpZiAocmV0KQotCQlyZXR1cm4gcmV0OwotCi0JaWYgKHNpemUgPiBQQUdFX1NJWkUpCS8qIHNpbGx5IGxhcmdlICovCi0JCWdvdG8gZXJyX3NpemU7Ci0KLQlpZiAoIXNpemUpCQkvKiBhYmkgY29tcGF0ICovCi0JCXNpemUgPSBQRVJGX0FUVFJfU0laRV9WRVIwOwotCi0JaWYgKHNpemUgPCBQRVJGX0FUVFJfU0laRV9WRVIwKQotCQlnb3RvIGVycl9zaXplOwotCi0JLyoKLQkgKiBJZiB3ZSdyZSBoYW5kZWQgYSBiaWdnZXIgc3RydWN0IHRoYW4gd2Uga25vdyBvZiwKLQkgKiBlbnN1cmUgYWxsIHRoZSB1bmtub3duIGJpdHMgYXJlIDAgLSBpLmUuIG5ldwotCSAqIHVzZXItc3BhY2UgZG9lcyBub3QgcmVseSBvbiBhbnkga2VybmVsIGZlYXR1cmUKLQkgKiBleHRlbnNpb25zIHdlIGRvbnQga25vdyBhYm91dCB5ZXQuCi0JICovCi0JaWYgKHNpemUgPiBzaXplb2YoKmF0dHIpKSB7Ci0JCXVuc2lnbmVkIGNoYXIgX191c2VyICphZGRyOwotCQl1bnNpZ25lZCBjaGFyIF9fdXNlciAqZW5kOwotCQl1bnNpZ25lZCBjaGFyIHZhbDsKLQotCQlhZGRyID0gKHZvaWQgX191c2VyICopdWF0dHIgKyBzaXplb2YoKmF0dHIpOwotCQllbmQgID0gKHZvaWQgX191c2VyICopdWF0dHIgKyBzaXplOwotCi0JCWZvciAoOyBhZGRyIDwgZW5kOyBhZGRyKyspIHsKLQkJCXJldCA9IGdldF91c2VyKHZhbCwgYWRkcik7Ci0JCQlpZiAocmV0KQotCQkJCXJldHVybiByZXQ7Ci0JCQlpZiAodmFsKQotCQkJCWdvdG8gZXJyX3NpemU7Ci0JCX0KLQkJc2l6ZSA9IHNpemVvZigqYXR0cik7Ci0JfQotCi0JcmV0ID0gY29weV9mcm9tX3VzZXIoYXR0ciwgdWF0dHIsIHNpemUpOwotCWlmIChyZXQpCi0JCXJldHVybiAtRUZBVUxUOwotCi0JLyoKLQkgKiBJZiB0aGUgdHlwZSBleGlzdHMsIHRoZSBjb3JyZXNwb25kaW5nIGNyZWF0aW9uIHdpbGwgdmVyaWZ5Ci0JICogdGhlIGF0dHItPmNvbmZpZy4KLQkgKi8KLQlpZiAoYXR0ci0+dHlwZSA+PSBQRVJGX1RZUEVfTUFYKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWlmIChhdHRyLT5fX3Jlc2VydmVkXzEgfHwgYXR0ci0+X19yZXNlcnZlZF8yIHx8IGF0dHItPl9fcmVzZXJ2ZWRfMykKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAoYXR0ci0+c2FtcGxlX3R5cGUgJiB+KFBFUkZfU0FNUExFX01BWC0xKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAoYXR0ci0+cmVhZF9mb3JtYXQgJiB+KFBFUkZfRk9STUFUX01BWC0xKSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLW91dDoKLQlyZXR1cm4gcmV0OwotCi1lcnJfc2l6ZToKLQlwdXRfdXNlcihzaXplb2YoKmF0dHIpLCAmdWF0dHItPnNpemUpOwotCXJldCA9IC1FMkJJRzsKLQlnb3RvIG91dDsKLX0KLQotaW50IHBlcmZfY291bnRlcl9zZXRfb3V0cHV0KHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsIGludCBvdXRwdXRfZmQpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqb3V0cHV0X2NvdW50ZXIgPSBOVUxMOwotCXN0cnVjdCBmaWxlICpvdXRwdXRfZmlsZSA9IE5VTEw7Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqb2xkX291dHB1dDsKLQlpbnQgZnB1dF9uZWVkZWQgPSAwOwotCWludCByZXQgPSAtRUlOVkFMOwotCi0JaWYgKCFvdXRwdXRfZmQpCi0JCWdvdG8gc2V0OwotCi0Jb3V0cHV0X2ZpbGUgPSBmZ2V0X2xpZ2h0KG91dHB1dF9mZCwgJmZwdXRfbmVlZGVkKTsKLQlpZiAoIW91dHB1dF9maWxlKQotCQlyZXR1cm4gLUVCQURGOwotCi0JaWYgKG91dHB1dF9maWxlLT5mX29wICE9ICZwZXJmX2ZvcHMpCi0JCWdvdG8gb3V0OwotCi0Jb3V0cHV0X2NvdW50ZXIgPSBvdXRwdXRfZmlsZS0+cHJpdmF0ZV9kYXRhOwotCi0JLyogRG9uJ3QgY2hhaW4gb3V0cHV0IGZkcyAqLwotCWlmIChvdXRwdXRfY291bnRlci0+b3V0cHV0KQotCQlnb3RvIG91dDsKLQotCS8qIERvbid0IHNldCBhbiBvdXRwdXQgZmQgd2hlbiB3ZSBhbHJlYWR5IGhhdmUgYW4gb3V0cHV0IGNoYW5uZWwgKi8KLQlpZiAoY291bnRlci0+ZGF0YSkKLQkJZ290byBvdXQ7Ci0KLQlhdG9taWNfbG9uZ19pbmMoJm91dHB1dF9maWxlLT5mX2NvdW50KTsKLQotc2V0OgotCW11dGV4X2xvY2soJmNvdW50ZXItPm1tYXBfbXV0ZXgpOwotCW9sZF9vdXRwdXQgPSBjb3VudGVyLT5vdXRwdXQ7Ci0JcmN1X2Fzc2lnbl9wb2ludGVyKGNvdW50ZXItPm91dHB1dCwgb3V0cHV0X2NvdW50ZXIpOwotCW11dGV4X3VubG9jaygmY291bnRlci0+bW1hcF9tdXRleCk7Ci0KLQlpZiAob2xkX291dHB1dCkgewotCQkvKgotCQkgKiB3ZSBuZWVkIHRvIG1ha2Ugc3VyZSBubyBleGlzdGluZyBwZXJmX291dHB1dF8qKCkKLQkJICogaXMgc3RpbGwgcmVmZXJlbmNpbmcgdGhpcyBjb3VudGVyLgotCQkgKi8KLQkJc3luY2hyb25pemVfcmN1KCk7Ci0JCWZwdXQob2xkX291dHB1dC0+ZmlscCk7Ci0JfQotCi0JcmV0ID0gMDsKLW91dDoKLQlmcHV0X2xpZ2h0KG91dHB1dF9maWxlLCBmcHV0X25lZWRlZCk7Ci0JcmV0dXJuIHJldDsKLX0KLQotLyoqCi0gKiBzeXNfcGVyZl9jb3VudGVyX29wZW4gLSBvcGVuIGEgcGVyZm9ybWFuY2UgY291bnRlciwgYXNzb2NpYXRlIGl0IHRvIGEgdGFzay9jcHUKLSAqCi0gKiBAYXR0cl91cHRyOglldmVudCB0eXBlIGF0dHJpYnV0ZXMgZm9yIG1vbml0b3Jpbmcvc2FtcGxpbmcKLSAqIEBwaWQ6CQl0YXJnZXQgcGlkCi0gKiBAY3B1OgkJdGFyZ2V0IGNwdQotICogQGdyb3VwX2ZkOgkJZ3JvdXAgbGVhZGVyIGNvdW50ZXIgZmQKLSAqLwotU1lTQ0FMTF9ERUZJTkU1KHBlcmZfY291bnRlcl9vcGVuLAotCQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2F0dHIgX191c2VyICosIGF0dHJfdXB0ciwKLQkJcGlkX3QsIHBpZCwgaW50LCBjcHUsIGludCwgZ3JvdXBfZmQsIHVuc2lnbmVkIGxvbmcsIGZsYWdzKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsICpncm91cF9sZWFkZXI7Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9hdHRyIGF0dHI7Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjdHg7Ci0Jc3RydWN0IGZpbGUgKmNvdW50ZXJfZmlsZSA9IE5VTEw7Ci0Jc3RydWN0IGZpbGUgKmdyb3VwX2ZpbGUgPSBOVUxMOwotCWludCBmcHV0X25lZWRlZCA9IDA7Ci0JaW50IGZwdXRfbmVlZGVkMiA9IDA7Ci0JaW50IGVycjsKLQotCS8qIGZvciBmdXR1cmUgZXhwYW5kYWJpbGl0eS4uLiAqLwotCWlmIChmbGFncyAmIH4oUEVSRl9GTEFHX0ZEX05PX0dST1VQIHwgUEVSRl9GTEFHX0ZEX09VVFBVVCkpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JZXJyID0gcGVyZl9jb3B5X2F0dHIoYXR0cl91cHRyLCAmYXR0cik7Ci0JaWYgKGVycikKLQkJcmV0dXJuIGVycjsKLQotCWlmICghYXR0ci5leGNsdWRlX2tlcm5lbCkgewotCQlpZiAocGVyZl9wYXJhbm9pZF9rZXJuZWwoKSAmJiAhY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKLQkJCXJldHVybiAtRUFDQ0VTOwotCX0KLQotCWlmIChhdHRyLmZyZXEpIHsKLQkJaWYgKGF0dHIuc2FtcGxlX2ZyZXEgPiBzeXNjdGxfcGVyZl9jb3VudGVyX3NhbXBsZV9yYXRlKQotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JLyoKLQkgKiBHZXQgdGhlIHRhcmdldCBjb250ZXh0ICh0YXNrIG9yIHBlcmNwdSk6Ci0JICovCi0JY3R4ID0gZmluZF9nZXRfY29udGV4dChwaWQsIGNwdSk7Ci0JaWYgKElTX0VSUihjdHgpKQotCQlyZXR1cm4gUFRSX0VSUihjdHgpOwotCi0JLyoKLQkgKiBMb29rIHVwIHRoZSBncm91cCBsZWFkZXIgKHdlIHdpbGwgYXR0YWNoIHRoaXMgY291bnRlciB0byBpdCk6Ci0JICovCi0JZ3JvdXBfbGVhZGVyID0gTlVMTDsKLQlpZiAoZ3JvdXBfZmQgIT0gLTEgJiYgIShmbGFncyAmIFBFUkZfRkxBR19GRF9OT19HUk9VUCkpIHsKLQkJZXJyID0gLUVJTlZBTDsKLQkJZ3JvdXBfZmlsZSA9IGZnZXRfbGlnaHQoZ3JvdXBfZmQsICZmcHV0X25lZWRlZCk7Ci0JCWlmICghZ3JvdXBfZmlsZSkKLQkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwotCQlpZiAoZ3JvdXBfZmlsZS0+Zl9vcCAhPSAmcGVyZl9mb3BzKQotCQkJZ290byBlcnJfcHV0X2NvbnRleHQ7Ci0KLQkJZ3JvdXBfbGVhZGVyID0gZ3JvdXBfZmlsZS0+cHJpdmF0ZV9kYXRhOwotCQkvKgotCQkgKiBEbyBub3QgYWxsb3cgYSByZWN1cnNpdmUgaGllcmFyY2h5ICh0aGlzIG5ldyBzaWJsaW5nCi0JCSAqIGJlY29taW5nIHBhcnQgb2YgYW5vdGhlciBncm91cC1zaWJsaW5nKToKLQkJICovCi0JCWlmIChncm91cF9sZWFkZXItPmdyb3VwX2xlYWRlciAhPSBncm91cF9sZWFkZXIpCi0JCQlnb3RvIGVycl9wdXRfY29udGV4dDsKLQkJLyoKLQkJICogRG8gbm90IGFsbG93IHRvIGF0dGFjaCB0byBhIGdyb3VwIGluIGEgZGlmZmVyZW50Ci0JCSAqIHRhc2sgb3IgQ1BVIGNvbnRleHQ6Ci0JCSAqLwotCQlpZiAoZ3JvdXBfbGVhZGVyLT5jdHggIT0gY3R4KQotCQkJZ290byBlcnJfcHV0X2NvbnRleHQ7Ci0JCS8qCi0JCSAqIE9ubHkgYSBncm91cCBsZWFkZXIgY2FuIGJlIGV4Y2x1c2l2ZSBvciBwaW5uZWQKLQkJICovCi0JCWlmIChhdHRyLmV4Y2x1c2l2ZSB8fCBhdHRyLnBpbm5lZCkKLQkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwotCX0KLQotCWNvdW50ZXIgPSBwZXJmX2NvdW50ZXJfYWxsb2MoJmF0dHIsIGNwdSwgY3R4LCBncm91cF9sZWFkZXIsCi0JCQkJICAgICBOVUxMLCBHRlBfS0VSTkVMKTsKLQllcnIgPSBQVFJfRVJSKGNvdW50ZXIpOwotCWlmIChJU19FUlIoY291bnRlcikpCi0JCWdvdG8gZXJyX3B1dF9jb250ZXh0OwotCi0JZXJyID0gYW5vbl9pbm9kZV9nZXRmZCgiW3BlcmZfY291bnRlcl0iLCAmcGVyZl9mb3BzLCBjb3VudGVyLCAwKTsKLQlpZiAoZXJyIDwgMCkKLQkJZ290byBlcnJfZnJlZV9wdXRfY29udGV4dDsKLQotCWNvdW50ZXJfZmlsZSA9IGZnZXRfbGlnaHQoZXJyLCAmZnB1dF9uZWVkZWQyKTsKLQlpZiAoIWNvdW50ZXJfZmlsZSkKLQkJZ290byBlcnJfZnJlZV9wdXRfY29udGV4dDsKLQotCWlmIChmbGFncyAmIFBFUkZfRkxBR19GRF9PVVRQVVQpIHsKLQkJZXJyID0gcGVyZl9jb3VudGVyX3NldF9vdXRwdXQoY291bnRlciwgZ3JvdXBfZmQpOwotCQlpZiAoZXJyKQotCQkJZ290byBlcnJfZnB1dF9mcmVlX3B1dF9jb250ZXh0OwotCX0KLQotCWNvdW50ZXItPmZpbHAgPSBjb3VudGVyX2ZpbGU7Ci0JV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7Ci0JbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7Ci0JcGVyZl9pbnN0YWxsX2luX2NvbnRleHQoY3R4LCBjb3VudGVyLCBjcHUpOwotCSsrY3R4LT5nZW5lcmF0aW9uOwotCW11dGV4X3VubG9jaygmY3R4LT5tdXRleCk7Ci0KLQljb3VudGVyLT5vd25lciA9IGN1cnJlbnQ7Ci0JZ2V0X3Rhc2tfc3RydWN0KGN1cnJlbnQpOwotCW11dGV4X2xvY2soJmN1cnJlbnQtPnBlcmZfY291bnRlcl9tdXRleCk7Ci0JbGlzdF9hZGRfdGFpbCgmY291bnRlci0+b3duZXJfZW50cnksICZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbGlzdCk7Ci0JbXV0ZXhfdW5sb2NrKCZjdXJyZW50LT5wZXJmX2NvdW50ZXJfbXV0ZXgpOwotCi1lcnJfZnB1dF9mcmVlX3B1dF9jb250ZXh0OgotCWZwdXRfbGlnaHQoY291bnRlcl9maWxlLCBmcHV0X25lZWRlZDIpOwotCi1lcnJfZnJlZV9wdXRfY29udGV4dDoKLQlpZiAoZXJyIDwgMCkKLQkJa2ZyZWUoY291bnRlcik7Ci0KLWVycl9wdXRfY29udGV4dDoKLQlpZiAoZXJyIDwgMCkKLQkJcHV0X2N0eChjdHgpOwotCi0JZnB1dF9saWdodChncm91cF9maWxlLCBmcHV0X25lZWRlZCk7Ci0KLQlyZXR1cm4gZXJyOwotfQotCi0vKgotICogaW5oZXJpdCBhIGNvdW50ZXIgZnJvbSBwYXJlbnQgdGFzayB0byBjaGlsZCB0YXNrOgotICovCi1zdGF0aWMgc3RydWN0IHBlcmZfY291bnRlciAqCi1pbmhlcml0X2NvdW50ZXIoc3RydWN0IHBlcmZfY291bnRlciAqcGFyZW50X2NvdW50ZXIsCi0JICAgICAgc3RydWN0IHRhc2tfc3RydWN0ICpwYXJlbnQsCi0JICAgICAgc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpwYXJlbnRfY3R4LAotCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQsCi0JICAgICAgc3RydWN0IHBlcmZfY291bnRlciAqZ3JvdXBfbGVhZGVyLAotCSAgICAgIHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY2hpbGRfY3R4KQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNoaWxkX2NvdW50ZXI7Ci0KLQkvKgotCSAqIEluc3RlYWQgb2YgY3JlYXRpbmcgcmVjdXJzaXZlIGhpZXJhcmNoaWVzIG9mIGNvdW50ZXJzLAotCSAqIHdlIGxpbmsgaW5oZXJpdGVkIGNvdW50ZXJzIGJhY2sgdG8gdGhlIG9yaWdpbmFsIHBhcmVudCwKLQkgKiB3aGljaCBoYXMgYSBmaWxwIGZvciBzdXJlLCB3aGljaCB3ZSB1c2UgYXMgdGhlIHJlZmVyZW5jZQotCSAqIGNvdW50OgotCSAqLwotCWlmIChwYXJlbnRfY291bnRlci0+cGFyZW50KQotCQlwYXJlbnRfY291bnRlciA9IHBhcmVudF9jb3VudGVyLT5wYXJlbnQ7Ci0KLQljaGlsZF9jb3VudGVyID0gcGVyZl9jb3VudGVyX2FsbG9jKCZwYXJlbnRfY291bnRlci0+YXR0ciwKLQkJCQkJICAgcGFyZW50X2NvdW50ZXItPmNwdSwgY2hpbGRfY3R4LAotCQkJCQkgICBncm91cF9sZWFkZXIsIHBhcmVudF9jb3VudGVyLAotCQkJCQkgICBHRlBfS0VSTkVMKTsKLQlpZiAoSVNfRVJSKGNoaWxkX2NvdW50ZXIpKQotCQlyZXR1cm4gY2hpbGRfY291bnRlcjsKLQlnZXRfY3R4KGNoaWxkX2N0eCk7Ci0KLQkvKgotCSAqIE1ha2UgdGhlIGNoaWxkIHN0YXRlIGZvbGxvdyB0aGUgc3RhdGUgb2YgdGhlIHBhcmVudCBjb3VudGVyLAotCSAqIG5vdCBpdHMgYXR0ci5kaXNhYmxlZCBiaXQuICBXZSBob2xkIHRoZSBwYXJlbnQncyBtdXRleCwKLQkgKiBzbyB3ZSB3b24ndCByYWNlIHdpdGggcGVyZl9jb3VudGVyX3tlbiwgZGlzfWFibGVfZmFtaWx5LgotCSAqLwotCWlmIChwYXJlbnRfY291bnRlci0+c3RhdGUgPj0gUEVSRl9DT1VOVEVSX1NUQVRFX0lOQUNUSVZFKQotCQljaGlsZF9jb3VudGVyLT5zdGF0ZSA9IFBFUkZfQ09VTlRFUl9TVEFURV9JTkFDVElWRTsKLQllbHNlCi0JCWNoaWxkX2NvdW50ZXItPnN0YXRlID0gUEVSRl9DT1VOVEVSX1NUQVRFX09GRjsKLQotCWlmIChwYXJlbnRfY291bnRlci0+YXR0ci5mcmVxKQotCQljaGlsZF9jb3VudGVyLT5ody5zYW1wbGVfcGVyaW9kID0gcGFyZW50X2NvdW50ZXItPmh3LnNhbXBsZV9wZXJpb2Q7Ci0KLQkvKgotCSAqIExpbmsgaXQgdXAgaW4gdGhlIGNoaWxkJ3MgY29udGV4dDoKLQkgKi8KLQlhZGRfY291bnRlcl90b19jdHgoY2hpbGRfY291bnRlciwgY2hpbGRfY3R4KTsKLQotCS8qCi0JICogR2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBwYXJlbnQgZmlscCAtIHdlIHdpbGwgZnB1dCBpdAotCSAqIHdoZW4gdGhlIGNoaWxkIGNvdW50ZXIgZXhpdHMuIFRoaXMgaXMgc2FmZSB0byBkbyBiZWNhdXNlCi0JICogd2UgYXJlIGluIHRoZSBwYXJlbnQgYW5kIHdlIGtub3cgdGhhdCB0aGUgZmlscCBzdGlsbAotCSAqIGV4aXN0cyBhbmQgaGFzIGEgbm9uemVybyBjb3VudDoKLQkgKi8KLQlhdG9taWNfbG9uZ19pbmMoJnBhcmVudF9jb3VudGVyLT5maWxwLT5mX2NvdW50KTsKLQotCS8qCi0JICogTGluayB0aGlzIGludG8gdGhlIHBhcmVudCBjb3VudGVyJ3MgY2hpbGQgbGlzdAotCSAqLwotCVdBUk5fT05fT05DRShwYXJlbnRfY291bnRlci0+Y3R4LT5wYXJlbnRfY3R4KTsKLQltdXRleF9sb2NrKCZwYXJlbnRfY291bnRlci0+Y2hpbGRfbXV0ZXgpOwotCWxpc3RfYWRkX3RhaWwoJmNoaWxkX2NvdW50ZXItPmNoaWxkX2xpc3QsICZwYXJlbnRfY291bnRlci0+Y2hpbGRfbGlzdCk7Ci0JbXV0ZXhfdW5sb2NrKCZwYXJlbnRfY291bnRlci0+Y2hpbGRfbXV0ZXgpOwotCi0JcmV0dXJuIGNoaWxkX2NvdW50ZXI7Ci19Ci0KLXN0YXRpYyBpbnQgaW5oZXJpdF9ncm91cChzdHJ1Y3QgcGVyZl9jb3VudGVyICpwYXJlbnRfY291bnRlciwKLQkgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnBhcmVudCwKLQkgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKnBhcmVudF9jdHgsCi0JICAgICAgc3RydWN0IHRhc2tfc3RydWN0ICpjaGlsZCwKLQkgICAgICBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmNoaWxkX2N0eCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpsZWFkZXI7Ci0Jc3RydWN0IHBlcmZfY291bnRlciAqc3ViOwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNoaWxkX2N0cjsKLQotCWxlYWRlciA9IGluaGVyaXRfY291bnRlcihwYXJlbnRfY291bnRlciwgcGFyZW50LCBwYXJlbnRfY3R4LAotCQkJCSBjaGlsZCwgTlVMTCwgY2hpbGRfY3R4KTsKLQlpZiAoSVNfRVJSKGxlYWRlcikpCi0JCXJldHVybiBQVFJfRVJSKGxlYWRlcik7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZwYXJlbnRfY291bnRlci0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkgewotCQljaGlsZF9jdHIgPSBpbmhlcml0X2NvdW50ZXIoc3ViLCBwYXJlbnQsIHBhcmVudF9jdHgsCi0JCQkJCSAgICBjaGlsZCwgbGVhZGVyLCBjaGlsZF9jdHgpOwotCQlpZiAoSVNfRVJSKGNoaWxkX2N0cikpCi0JCQlyZXR1cm4gUFRSX0VSUihjaGlsZF9jdHIpOwotCX0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgc3luY19jaGlsZF9jb3VudGVyKHN0cnVjdCBwZXJmX2NvdW50ZXIgKmNoaWxkX2NvdW50ZXIsCi0JCQkgICAgICAgc3RydWN0IHRhc2tfc3RydWN0ICpjaGlsZCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpwYXJlbnRfY291bnRlciA9IGNoaWxkX2NvdW50ZXItPnBhcmVudDsKLQl1NjQgY2hpbGRfdmFsOwotCi0JaWYgKGNoaWxkX2NvdW50ZXItPmF0dHIuaW5oZXJpdF9zdGF0KQotCQlwZXJmX2NvdW50ZXJfcmVhZF9ldmVudChjaGlsZF9jb3VudGVyLCBjaGlsZCk7Ci0KLQljaGlsZF92YWwgPSBhdG9taWM2NF9yZWFkKCZjaGlsZF9jb3VudGVyLT5jb3VudCk7Ci0KLQkvKgotCSAqIEFkZCBiYWNrIHRoZSBjaGlsZCdzIGNvdW50IHRvIHRoZSBwYXJlbnQncyBjb3VudDoKLQkgKi8KLQlhdG9taWM2NF9hZGQoY2hpbGRfdmFsLCAmcGFyZW50X2NvdW50ZXItPmNvdW50KTsKLQlhdG9taWM2NF9hZGQoY2hpbGRfY291bnRlci0+dG90YWxfdGltZV9lbmFibGVkLAotCQkgICAgICZwYXJlbnRfY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9lbmFibGVkKTsKLQlhdG9taWM2NF9hZGQoY2hpbGRfY291bnRlci0+dG90YWxfdGltZV9ydW5uaW5nLAotCQkgICAgICZwYXJlbnRfY291bnRlci0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKLQotCS8qCi0JICogUmVtb3ZlIHRoaXMgY291bnRlciBmcm9tIHRoZSBwYXJlbnQncyBsaXN0Ci0JICovCi0JV0FSTl9PTl9PTkNFKHBhcmVudF9jb3VudGVyLT5jdHgtPnBhcmVudF9jdHgpOwotCW11dGV4X2xvY2soJnBhcmVudF9jb3VudGVyLT5jaGlsZF9tdXRleCk7Ci0JbGlzdF9kZWxfaW5pdCgmY2hpbGRfY291bnRlci0+Y2hpbGRfbGlzdCk7Ci0JbXV0ZXhfdW5sb2NrKCZwYXJlbnRfY291bnRlci0+Y2hpbGRfbXV0ZXgpOwotCi0JLyoKLQkgKiBSZWxlYXNlIHRoZSBwYXJlbnQgY291bnRlciwgaWYgdGhpcyB3YXMgdGhlIGxhc3QKLQkgKiByZWZlcmVuY2UgdG8gaXQuCi0JICovCi0JZnB1dChwYXJlbnRfY291bnRlci0+ZmlscCk7Ci19Ci0KLXN0YXRpYyB2b2lkCi1fX3BlcmZfY291bnRlcl9leGl0X3Rhc2soc3RydWN0IHBlcmZfY291bnRlciAqY2hpbGRfY291bnRlciwKLQkJCSBzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmNoaWxkX2N0eCwKLQkJCSBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkKQotewotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKnBhcmVudF9jb3VudGVyOwotCi0JdXBkYXRlX2NvdW50ZXJfdGltZXMoY2hpbGRfY291bnRlcik7Ci0JcGVyZl9jb3VudGVyX3JlbW92ZV9mcm9tX2NvbnRleHQoY2hpbGRfY291bnRlcik7Ci0KLQlwYXJlbnRfY291bnRlciA9IGNoaWxkX2NvdW50ZXItPnBhcmVudDsKLQkvKgotCSAqIEl0IGNhbiBoYXBwZW4gdGhhdCBwYXJlbnQgZXhpdHMgZmlyc3QsIGFuZCBoYXMgY291bnRlcnMKLQkgKiB0aGF0IGFyZSBzdGlsbCBhcm91bmQgZHVlIHRvIHRoZSBjaGlsZCByZWZlcmVuY2UuIFRoZXNlCi0JICogY291bnRlcnMgbmVlZCB0byBiZSB6YXBwZWQgLSBidXQgb3RoZXJ3aXNlIGxpbmdlci4KLQkgKi8KLQlpZiAocGFyZW50X2NvdW50ZXIpIHsKLQkJc3luY19jaGlsZF9jb3VudGVyKGNoaWxkX2NvdW50ZXIsIGNoaWxkKTsKLQkJZnJlZV9jb3VudGVyKGNoaWxkX2NvdW50ZXIpOwotCX0KLX0KLQotLyoKLSAqIFdoZW4gYSBjaGlsZCB0YXNrIGV4aXRzLCBmZWVkIGJhY2sgY291bnRlciB2YWx1ZXMgdG8gcGFyZW50IGNvdW50ZXJzLgotICovCi12b2lkIHBlcmZfY291bnRlcl9leGl0X3Rhc2soc3RydWN0IHRhc2tfc3RydWN0ICpjaGlsZCkKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjaGlsZF9jb3VudGVyLCAqdG1wOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY2hpbGRfY3R4OwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQlpZiAobGlrZWx5KCFjaGlsZC0+cGVyZl9jb3VudGVyX2N0eHApKSB7Ci0JCXBlcmZfY291bnRlcl90YXNrKGNoaWxkLCBOVUxMLCAwKTsKLQkJcmV0dXJuOwotCX0KLQotCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKLQkvKgotCSAqIFdlIGNhbid0IHJlc2NoZWR1bGUgaGVyZSBiZWNhdXNlIGludGVycnVwdHMgYXJlIGRpc2FibGVkLAotCSAqIGFuZCBlaXRoZXIgY2hpbGQgaXMgY3VycmVudCBvciBpdCBpcyBhIHRhc2sgdGhhdCBjYW4ndCBiZQotCSAqIHNjaGVkdWxlZCwgc28gd2UgYXJlIG5vdyBzYWZlIGZyb20gcmVzY2hlZHVsaW5nIGNoYW5naW5nCi0JICogb3VyIGNvbnRleHQuCi0JICovCi0JY2hpbGRfY3R4ID0gY2hpbGQtPnBlcmZfY291bnRlcl9jdHhwOwotCV9fcGVyZl9jb3VudGVyX3Rhc2tfc2NoZWRfb3V0KGNoaWxkX2N0eCk7Ci0KLQkvKgotCSAqIFRha2UgdGhlIGNvbnRleHQgbG9jayBoZXJlIHNvIHRoYXQgaWYgZmluZF9nZXRfY29udGV4dCBpcwotCSAqIHJlYWRpbmcgY2hpbGQtPnBlcmZfY291bnRlcl9jdHhwLCB3ZSB3YWl0IHVudGlsIGl0IGhhcwotCSAqIGluY3JlbWVudGVkIHRoZSBjb250ZXh0J3MgcmVmY291bnQgYmVmb3JlIHdlIGRvIHB1dF9jdHggYmVsb3cuCi0JICovCi0Jc3Bpbl9sb2NrKCZjaGlsZF9jdHgtPmxvY2spOwotCWNoaWxkLT5wZXJmX2NvdW50ZXJfY3R4cCA9IE5VTEw7Ci0JLyoKLQkgKiBJZiB0aGlzIGNvbnRleHQgaXMgYSBjbG9uZTsgdW5jbG9uZSBpdCBzbyBpdCBjYW4ndCBnZXQKLQkgKiBzd2FwcGVkIHRvIGFub3RoZXIgcHJvY2VzcyB3aGlsZSB3ZSdyZSByZW1vdmluZyBhbGwKLQkgKiB0aGUgY291bnRlcnMgZnJvbSBpdC4KLQkgKi8KLQl1bmNsb25lX2N0eChjaGlsZF9jdHgpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNoaWxkX2N0eC0+bG9jaywgZmxhZ3MpOwotCi0JLyoKLQkgKiBSZXBvcnQgdGhlIHRhc2sgZGVhZCBhZnRlciB1bnNjaGVkdWxpbmcgdGhlIGNvdW50ZXJzIHNvIHRoYXQgd2UKLQkgKiB3b24ndCBnZXQgYW55IHNhbXBsZXMgYWZ0ZXIgUEVSRl9FVkVOVF9FWElULiBXZSBjYW4gaG93ZXZlciBzdGlsbAotCSAqIGdldCBhIGZldyBQRVJGX0VWRU5UX1JFQUQgZXZlbnRzLgotCSAqLwotCXBlcmZfY291bnRlcl90YXNrKGNoaWxkLCBjaGlsZF9jdHgsIDApOwotCi0JLyoKLQkgKiBXZSBjYW4gcmVjdXJzZSBvbiB0aGUgc2FtZSBsb2NrIHR5cGUgdGhyb3VnaDoKLQkgKgotCSAqICAgX19wZXJmX2NvdW50ZXJfZXhpdF90YXNrKCkKLQkgKiAgICAgc3luY19jaGlsZF9jb3VudGVyKCkKLQkgKiAgICAgICBmcHV0KHBhcmVudF9jb3VudGVyLT5maWxwKQotCSAqICAgICAgICAgcGVyZl9yZWxlYXNlKCkKLQkgKiAgICAgICAgICAgbXV0ZXhfbG9jaygmY3R4LT5tdXRleCkKLQkgKgotCSAqIEJ1dCBzaW5jZSBpdHMgdGhlIHBhcmVudCBjb250ZXh0IGl0IHdvbid0IGJlIHRoZSBzYW1lIGluc3RhbmNlLgotCSAqLwotCW11dGV4X2xvY2tfbmVzdGVkKCZjaGlsZF9jdHgtPm11dGV4LCBTSU5HTEVfREVQVEhfTkVTVElORyk7Ci0KLWFnYWluOgotCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShjaGlsZF9jb3VudGVyLCB0bXAsICZjaGlsZF9jdHgtPmdyb3VwX2xpc3QsCi0JCQkJIGdyb3VwX2VudHJ5KQotCQlfX3BlcmZfY291bnRlcl9leGl0X3Rhc2soY2hpbGRfY291bnRlciwgY2hpbGRfY3R4LCBjaGlsZCk7Ci0KLQkvKgotCSAqIElmIHRoZSBsYXN0IGNvdW50ZXIgd2FzIGEgZ3JvdXAgY291bnRlciwgaXQgd2lsbCBoYXZlIGFwcGVuZGVkIGFsbAotCSAqIGl0cyBzaWJsaW5ncyB0byB0aGUgbGlzdCwgYnV0IHdlIG9idGFpbmVkICd0bXAnIGJlZm9yZSB0aGF0IHdoaWNoCi0JICogd2lsbCBzdGlsbCBwb2ludCB0byB0aGUgbGlzdCBoZWFkIHRlcm1pbmF0aW5nIHRoZSBpdGVyYXRpb24uCi0JICovCi0JaWYgKCFsaXN0X2VtcHR5KCZjaGlsZF9jdHgtPmdyb3VwX2xpc3QpKQotCQlnb3RvIGFnYWluOwotCi0JbXV0ZXhfdW5sb2NrKCZjaGlsZF9jdHgtPm11dGV4KTsKLQotCXB1dF9jdHgoY2hpbGRfY3R4KTsKLX0KLQotLyoKLSAqIGZyZWUgYW4gdW5leHBvc2VkLCB1bnVzZWQgY29udGV4dCBhcyBjcmVhdGVkIGJ5IGluaGVyaXRhbmNlIGJ5Ci0gKiBpbml0X3Rhc2sgYmVsb3csIHVzZWQgYnkgZm9yaygpIGluIGNhc2Ugb2YgZmFpbC4KLSAqLwotdm9pZCBwZXJmX2NvdW50ZXJfZnJlZV90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKLXsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyX2NvbnRleHQgKmN0eCA9IHRhc2stPnBlcmZfY291bnRlcl9jdHhwOwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsICp0bXA7Ci0KLQlpZiAoIWN0eCkKLQkJcmV0dXJuOwotCi0JbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7Ci1hZ2FpbjoKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY291bnRlciwgdG1wLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgewotCQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpwYXJlbnQgPSBjb3VudGVyLT5wYXJlbnQ7Ci0KLQkJaWYgKFdBUk5fT05fT05DRSghcGFyZW50KSkKLQkJCWNvbnRpbnVlOwotCi0JCW11dGV4X2xvY2soJnBhcmVudC0+Y2hpbGRfbXV0ZXgpOwotCQlsaXN0X2RlbF9pbml0KCZjb3VudGVyLT5jaGlsZF9saXN0KTsKLQkJbXV0ZXhfdW5sb2NrKCZwYXJlbnQtPmNoaWxkX211dGV4KTsKLQotCQlmcHV0KHBhcmVudC0+ZmlscCk7Ci0KLQkJbGlzdF9kZWxfY291bnRlcihjb3VudGVyLCBjdHgpOwotCQlmcmVlX2NvdW50ZXIoY291bnRlcik7Ci0JfQotCi0JaWYgKCFsaXN0X2VtcHR5KCZjdHgtPmdyb3VwX2xpc3QpKQotCQlnb3RvIGFnYWluOwotCi0JbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKLQotCXB1dF9jdHgoY3R4KTsKLX0KLQotLyoKLSAqIEluaXRpYWxpemUgdGhlIHBlcmZfY291bnRlciBjb250ZXh0IGluIHRhc2tfc3RydWN0Ci0gKi8KLWludCBwZXJmX2NvdW50ZXJfaW5pdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCi17Ci0Jc3RydWN0IHBlcmZfY291bnRlcl9jb250ZXh0ICpjaGlsZF9jdHgsICpwYXJlbnRfY3R4OwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY2xvbmVkX2N0eDsKLQlzdHJ1Y3QgcGVyZl9jb3VudGVyICpjb3VudGVyOwotCXN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50ID0gY3VycmVudDsKLQlpbnQgaW5oZXJpdGVkX2FsbCA9IDE7Ci0JaW50IHJldCA9IDA7Ci0KLQljaGlsZC0+cGVyZl9jb3VudGVyX2N0eHAgPSBOVUxMOwotCi0JbXV0ZXhfaW5pdCgmY2hpbGQtPnBlcmZfY291bnRlcl9tdXRleCk7Ci0JSU5JVF9MSVNUX0hFQUQoJmNoaWxkLT5wZXJmX2NvdW50ZXJfbGlzdCk7Ci0KLQlpZiAobGlrZWx5KCFwYXJlbnQtPnBlcmZfY291bnRlcl9jdHhwKSkKLQkJcmV0dXJuIDA7Ci0KLQkvKgotCSAqIFRoaXMgaXMgZXhlY3V0ZWQgZnJvbSB0aGUgcGFyZW50IHRhc2sgY29udGV4dCwgc28gaW5oZXJpdAotCSAqIGNvdW50ZXJzIHRoYXQgaGF2ZSBiZWVuIG1hcmtlZCBmb3IgY2xvbmluZy4KLQkgKiBGaXJzdCBhbGxvY2F0ZSBhbmQgaW5pdGlhbGl6ZSBhIGNvbnRleHQgZm9yIHRoZSBjaGlsZC4KLQkgKi8KLQotCWNoaWxkX2N0eCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCksIEdGUF9LRVJORUwpOwotCWlmICghY2hpbGRfY3R4KQotCQlyZXR1cm4gLUVOT01FTTsKLQotCV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dChjaGlsZF9jdHgsIGNoaWxkKTsKLQljaGlsZC0+cGVyZl9jb3VudGVyX2N0eHAgPSBjaGlsZF9jdHg7Ci0JZ2V0X3Rhc2tfc3RydWN0KGNoaWxkKTsKLQotCS8qCi0JICogSWYgdGhlIHBhcmVudCdzIGNvbnRleHQgaXMgYSBjbG9uZSwgcGluIGl0IHNvIGl0IHdvbid0IGdldAotCSAqIHN3YXBwZWQgdW5kZXIgdXMuCi0JICovCi0JcGFyZW50X2N0eCA9IHBlcmZfcGluX3Rhc2tfY29udGV4dChwYXJlbnQpOwotCi0JLyoKLQkgKiBObyBuZWVkIHRvIGNoZWNrIGlmIHBhcmVudF9jdHggIT0gTlVMTCBoZXJlOyBzaW5jZSB3ZSBzYXcKLQkgKiBpdCBub24tTlVMTCBlYXJsaWVyLCB0aGUgb25seSByZWFzb24gZm9yIGl0IHRvIGJlY29tZSBOVUxMCi0JICogaXMgaWYgd2UgZXhpdCwgYW5kIHNpbmNlIHdlJ3JlIGN1cnJlbnRseSBpbiB0aGUgbWlkZGxlIG9mCi0JICogYSBmb3JrIHdlIGNhbid0IGJlIGV4aXRpbmcgYXQgdGhlIHNhbWUgdGltZS4KLQkgKi8KLQotCS8qCi0JICogTG9jayB0aGUgcGFyZW50IGxpc3QuIE5vIG5lZWQgdG8gbG9jayB0aGUgY2hpbGQgLSBub3QgUElECi0JICogaGFzaGVkIHlldCBhbmQgbm90IHJ1bm5pbmcsIHNvIG5vYm9keSBjYW4gYWNjZXNzIGl0LgotCSAqLwotCW11dGV4X2xvY2soJnBhcmVudF9jdHgtPm11dGV4KTsKLQotCS8qCi0JICogV2UgZG9udCBoYXZlIHRvIGRpc2FibGUgTk1JcyAtIHdlIGFyZSBvbmx5IGxvb2tpbmcgYXQKLQkgKiB0aGUgbGlzdCwgbm90IG1hbmlwdWxhdGluZyBpdDoKLQkgKi8KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShjb3VudGVyLCAmcGFyZW50X2N0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKLQkJaWYgKGNvdW50ZXIgIT0gY291bnRlci0+Z3JvdXBfbGVhZGVyKQotCQkJY29udGludWU7Ci0KLQkJaWYgKCFjb3VudGVyLT5hdHRyLmluaGVyaXQpIHsKLQkJCWluaGVyaXRlZF9hbGwgPSAwOwotCQkJY29udGludWU7Ci0JCX0KLQotCQlyZXQgPSBpbmhlcml0X2dyb3VwKGNvdW50ZXIsIHBhcmVudCwgcGFyZW50X2N0eCwKLQkJCQkJICAgICBjaGlsZCwgY2hpbGRfY3R4KTsKLQkJaWYgKHJldCkgewotCQkJaW5oZXJpdGVkX2FsbCA9IDA7Ci0JCQlicmVhazsKLQkJfQotCX0KLQotCWlmIChpbmhlcml0ZWRfYWxsKSB7Ci0JCS8qCi0JCSAqIE1hcmsgdGhlIGNoaWxkIGNvbnRleHQgYXMgYSBjbG9uZSBvZiB0aGUgcGFyZW50Ci0JCSAqIGNvbnRleHQsIG9yIG9mIHdoYXRldmVyIHRoZSBwYXJlbnQgaXMgYSBjbG9uZSBvZi4KLQkJICogTm90ZSB0aGF0IGlmIHRoZSBwYXJlbnQgaXMgYSBjbG9uZSwgaXQgY291bGQgZ2V0Ci0JCSAqIHVuY2xvbmVkIGF0IGFueSBwb2ludCwgYnV0IHRoYXQgZG9lc24ndCBtYXR0ZXIKLQkJICogYmVjYXVzZSB0aGUgbGlzdCBvZiBjb3VudGVycyBhbmQgdGhlIGdlbmVyYXRpb24KLQkJICogY291bnQgY2FuJ3QgaGF2ZSBjaGFuZ2VkIHNpbmNlIHdlIHRvb2sgdGhlIG11dGV4LgotCQkgKi8KLQkJY2xvbmVkX2N0eCA9IHJjdV9kZXJlZmVyZW5jZShwYXJlbnRfY3R4LT5wYXJlbnRfY3R4KTsKLQkJaWYgKGNsb25lZF9jdHgpIHsKLQkJCWNoaWxkX2N0eC0+cGFyZW50X2N0eCA9IGNsb25lZF9jdHg7Ci0JCQljaGlsZF9jdHgtPnBhcmVudF9nZW4gPSBwYXJlbnRfY3R4LT5wYXJlbnRfZ2VuOwotCQl9IGVsc2UgewotCQkJY2hpbGRfY3R4LT5wYXJlbnRfY3R4ID0gcGFyZW50X2N0eDsKLQkJCWNoaWxkX2N0eC0+cGFyZW50X2dlbiA9IHBhcmVudF9jdHgtPmdlbmVyYXRpb247Ci0JCX0KLQkJZ2V0X2N0eChjaGlsZF9jdHgtPnBhcmVudF9jdHgpOwotCX0KLQotCW11dGV4X3VubG9jaygmcGFyZW50X2N0eC0+bXV0ZXgpOwotCi0JcGVyZl91bnBpbl9jb250ZXh0KHBhcmVudF9jdHgpOwotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIHZvaWQgX19jcHVpbml0IHBlcmZfY291bnRlcl9pbml0X2NwdShpbnQgY3B1KQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7Ci0KLQljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwotCV9fcGVyZl9jb3VudGVyX2luaXRfY29udGV4dCgmY3B1Y3R4LT5jdHgsIE5VTEwpOwotCi0Jc3Bpbl9sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwotCWNwdWN0eC0+bWF4X3BlcnRhc2sgPSBwZXJmX21heF9jb3VudGVycyAtIHBlcmZfcmVzZXJ2ZWRfcGVyY3B1OwotCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwotCi0JaHdfcGVyZl9jb3VudGVyX3NldHVwKGNwdSk7Ci19Ci0KLSNpZmRlZiBDT05GSUdfSE9UUExVR19DUFUKLXN0YXRpYyB2b2lkIF9fcGVyZl9jb3VudGVyX2V4aXRfY3B1KHZvaWQgKmluZm8pCi17Ci0Jc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gJmNwdWN0eC0+Y3R4OwotCXN0cnVjdCBwZXJmX2NvdW50ZXIgKmNvdW50ZXIsICp0bXA7Ci0KLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY291bnRlciwgdG1wLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkKLQkJX19wZXJmX2NvdW50ZXJfcmVtb3ZlX2Zyb21fY29udGV4dChjb3VudGVyKTsKLX0KLXN0YXRpYyB2b2lkIHBlcmZfY291bnRlcl9leGl0X2NwdShpbnQgY3B1KQotewotCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwotCXN0cnVjdCBwZXJmX2NvdW50ZXJfY29udGV4dCAqY3R4ID0gJmNwdWN0eC0+Y3R4OwotCi0JbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7Ci0Jc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGNwdSwgX19wZXJmX2NvdW50ZXJfZXhpdF9jcHUsIE5VTEwsIDEpOwotCW11dGV4X3VubG9jaygmY3R4LT5tdXRleCk7Ci19Ci0jZWxzZQotc3RhdGljIGlubGluZSB2b2lkIHBlcmZfY291bnRlcl9leGl0X2NwdShpbnQgY3B1KSB7IH0KLSNlbmRpZgotCi1zdGF0aWMgaW50IF9fY3B1aW5pdAotcGVyZl9jcHVfbm90aWZ5KHN0cnVjdCBub3RpZmllcl9ibG9jayAqc2VsZiwgdW5zaWduZWQgbG9uZyBhY3Rpb24sIHZvaWQgKmhjcHUpCi17Ci0JdW5zaWduZWQgaW50IGNwdSA9IChsb25nKWhjcHU7Ci0KLQlzd2l0Y2ggKGFjdGlvbikgewotCi0JY2FzZSBDUFVfVVBfUFJFUEFSRToKLQljYXNlIENQVV9VUF9QUkVQQVJFX0ZST1pFTjoKLQkJcGVyZl9jb3VudGVyX2luaXRfY3B1KGNwdSk7Ci0JCWJyZWFrOwotCi0JY2FzZSBDUFVfT05MSU5FOgotCWNhc2UgQ1BVX09OTElORV9GUk9aRU46Ci0JCWh3X3BlcmZfY291bnRlcl9zZXR1cF9vbmxpbmUoY3B1KTsKLQkJYnJlYWs7Ci0KLQljYXNlIENQVV9ET1dOX1BSRVBBUkU6Ci0JY2FzZSBDUFVfRE9XTl9QUkVQQVJFX0ZST1pFTjoKLQkJcGVyZl9jb3VudGVyX2V4aXRfY3B1KGNwdSk7Ci0JCWJyZWFrOwotCi0JZGVmYXVsdDoKLQkJYnJlYWs7Ci0JfQotCi0JcmV0dXJuIE5PVElGWV9PSzsKLX0KLQotLyoKLSAqIFRoaXMgaGFzIHRvIGhhdmUgYSBoaWdoZXIgcHJpb3JpdHkgdGhhbiBtaWdyYXRpb25fbm90aWZpZXIgaW4gc2NoZWQuYy4KLSAqLwotc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBfX2NwdWluaXRkYXRhIHBlcmZfY3B1X25iID0gewotCS5ub3RpZmllcl9jYWxsCQk9IHBlcmZfY3B1X25vdGlmeSwKLQkucHJpb3JpdHkJCT0gMjAsCi19OwotCi12b2lkIF9faW5pdCBwZXJmX2NvdW50ZXJfaW5pdCh2b2lkKQotewotCXBlcmZfY3B1X25vdGlmeSgmcGVyZl9jcHVfbmIsICh1bnNpZ25lZCBsb25nKUNQVV9VUF9QUkVQQVJFLAotCQkJKHZvaWQgKikobG9uZylzbXBfcHJvY2Vzc29yX2lkKCkpOwotCXBlcmZfY3B1X25vdGlmeSgmcGVyZl9jcHVfbmIsICh1bnNpZ25lZCBsb25nKUNQVV9PTkxJTkUsCi0JCQkodm9pZCAqKShsb25nKXNtcF9wcm9jZXNzb3JfaWQoKSk7Ci0JcmVnaXN0ZXJfY3B1X25vdGlmaWVyKCZwZXJmX2NwdV9uYik7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90IHBlcmZfc2hvd19yZXNlcnZlX3BlcmNwdShzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywgY2hhciAqYnVmKQotewotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7Ci19Ci0KLXN0YXRpYyBzc2l6ZV90Ci1wZXJmX3NldF9yZXNlcnZlX3BlcmNwdShzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywKLQkJCWNvbnN0IGNoYXIgKmJ1ZiwKLQkJCXNpemVfdCBjb3VudCkKLXsKLQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OwotCXVuc2lnbmVkIGxvbmcgdmFsOwotCWludCBlcnIsIGNwdSwgbXB0OwotCi0JZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7Ci0JaWYgKGVycikKLQkJcmV0dXJuIGVycjsKLQlpZiAodmFsID4gcGVyZl9tYXhfY291bnRlcnMpCi0JCXJldHVybiAtRUlOVkFMOwotCi0Jc3Bpbl9sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwotCXBlcmZfcmVzZXJ2ZWRfcGVyY3B1ID0gdmFsOwotCWZvcl9lYWNoX29ubGluZV9jcHUoY3B1KSB7Ci0JCWNwdWN0eCA9ICZwZXJfY3B1KHBlcmZfY3B1X2NvbnRleHQsIGNwdSk7Ci0JCXNwaW5fbG9ja19pcnEoJmNwdWN0eC0+Y3R4LmxvY2spOwotCQltcHQgPSBtaW4ocGVyZl9tYXhfY291bnRlcnMgLSBjcHVjdHgtPmN0eC5ucl9jb3VudGVycywKLQkJCSAgcGVyZl9tYXhfY291bnRlcnMgLSBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7Ci0JCWNwdWN0eC0+bWF4X3BlcnRhc2sgPSBtcHQ7Ci0JCXNwaW5fdW5sb2NrX2lycSgmY3B1Y3R4LT5jdHgubG9jayk7Ci0JfQotCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwotCi0JcmV0dXJuIGNvdW50OwotfQotCi1zdGF0aWMgc3NpemVfdCBwZXJmX3Nob3dfb3ZlcmNvbW1pdChzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywgY2hhciAqYnVmKQotewotCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBwZXJmX292ZXJjb21taXQpOwotfQotCi1zdGF0aWMgc3NpemVfdAotcGVyZl9zZXRfb3ZlcmNvbW1pdChzdHJ1Y3Qgc3lzZGV2X2NsYXNzICpjbGFzcywgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCi17Ci0JdW5zaWduZWQgbG9uZyB2YWw7Ci0JaW50IGVycjsKLQotCWVyciA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMTAsICZ2YWwpOwotCWlmIChlcnIpCi0JCXJldHVybiBlcnI7Ci0JaWYgKHZhbCA+IDEpCi0JCXJldHVybiAtRUlOVkFMOwotCi0Jc3Bpbl9sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwotCXBlcmZfb3ZlcmNvbW1pdCA9IHZhbDsKLQlzcGluX3VubG9jaygmcGVyZl9yZXNvdXJjZV9sb2NrKTsKLQotCXJldHVybiBjb3VudDsKLX0KLQotc3RhdGljIFNZU0RFVl9DTEFTU19BVFRSKAotCQkJCXJlc2VydmVfcGVyY3B1LAotCQkJCTA2NDQsCi0JCQkJcGVyZl9zaG93X3Jlc2VydmVfcGVyY3B1LAotCQkJCXBlcmZfc2V0X3Jlc2VydmVfcGVyY3B1Ci0JCQkpOwotCi1zdGF0aWMgU1lTREVWX0NMQVNTX0FUVFIoCi0JCQkJb3ZlcmNvbW1pdCwKLQkJCQkwNjQ0LAotCQkJCXBlcmZfc2hvd19vdmVyY29tbWl0LAotCQkJCXBlcmZfc2V0X292ZXJjb21taXQKLQkJCSk7Ci0KLXN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpwZXJmY2xhc3NfYXR0cnNbXSA9IHsKLQkmYXR0cl9yZXNlcnZlX3BlcmNwdS5hdHRyLAotCSZhdHRyX292ZXJjb21taXQuYXR0ciwKLQlOVUxMCi19OwotCi1zdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBwZXJmY2xhc3NfYXR0cl9ncm91cCA9IHsKLQkuYXR0cnMJCQk9IHBlcmZjbGFzc19hdHRycywKLQkubmFtZQkJCT0gInBlcmZfY291bnRlcnMiLAotfTsKLQotc3RhdGljIGludCBfX2luaXQgcGVyZl9jb3VudGVyX3N5c2ZzX2luaXQodm9pZCkKLXsKLQlyZXR1cm4gc3lzZnNfY3JlYXRlX2dyb3VwKCZjcHVfc3lzZGV2X2NsYXNzLmtzZXQua29iaiwKLQkJCQkgICZwZXJmY2xhc3NfYXR0cl9ncm91cCk7Ci19Ci1kZXZpY2VfaW5pdGNhbGwocGVyZl9jb3VudGVyX3N5c2ZzX2luaXQpOwpkaWZmIC0tZ2l0IGEva2VybmVsL3BlcmZfZXZlbnQuYyBiL2tlcm5lbC9wZXJmX2V2ZW50LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmU4Yjk5YQotLS0gL2Rldi9udWxsCisrKyBiL2tlcm5lbC9wZXJmX2V2ZW50LmMKQEAgLTAsMCArMSw1MDAwIEBACisvKgorICogUGVyZm9ybWFuY2UgZXZlbnQgY29yZSBjb2RlCisgKgorICogIENvcHlyaWdodCAoQykgMjAwOCBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSBSZWQgSGF0LCBJbmMuLCBJbmdvIE1vbG5hcgorICogIENvcHlyaWdodCAoQykgMjAwOC0yMDA5IFJlZCBIYXQsIEluYy4sIFBldGVyIFppamxzdHJhIDxwemlqbHN0ckByZWRoYXQuY29tPgorICogIENvcHlyaWdodCAgqSAgMjAwOSBQYXVsIE1hY2tlcnJhcywgSUJNIENvcnAuIDxwYXVsdXNAYXUxLmlibS5jb20+CisgKgorICogIEZvciBsaWNlbnNpbmcgZGV0YWlscyBzZWUga2VybmVsLWJhc2UvQ09QWUlORworICovCisKKyNpbmNsdWRlIDxsaW51eC9mcy5oPgorI2luY2x1ZGUgPGxpbnV4L21tLmg+CisjaW5jbHVkZSA8bGludXgvY3B1Lmg+CisjaW5jbHVkZSA8bGludXgvc21wLmg+CisjaW5jbHVkZSA8bGludXgvZmlsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KKyNpbmNsdWRlIDxsaW51eC9zeXNmcy5oPgorI2luY2x1ZGUgPGxpbnV4L2RjYWNoZS5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmNwdS5oPgorI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgorI2luY2x1ZGUgPGxpbnV4L3Ztc3RhdC5oPgorI2luY2x1ZGUgPGxpbnV4L2hhcmRpcnEuaD4KKyNpbmNsdWRlIDxsaW51eC9yY3VsaXN0Lmg+CisjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgorI2luY2x1ZGUgPGxpbnV4L3N5c2NhbGxzLmg+CisjaW5jbHVkZSA8bGludXgvYW5vbl9pbm9kZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWxfc3RhdC5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmZfZXZlbnQuaD4KKworI2luY2x1ZGUgPGFzbS9pcnFfcmVncy5oPgorCisvKgorICogRWFjaCBDUFUgaGFzIGEgbGlzdCBvZiBwZXIgQ1BVIGV2ZW50czoKKyAqLworREVGSU5FX1BFUl9DUFUoc3RydWN0IHBlcmZfY3B1X2NvbnRleHQsIHBlcmZfY3B1X2NvbnRleHQpOworCitpbnQgcGVyZl9tYXhfZXZlbnRzIF9fcmVhZF9tb3N0bHkgPSAxOworc3RhdGljIGludCBwZXJmX3Jlc2VydmVkX3BlcmNwdSBfX3JlYWRfbW9zdGx5Oworc3RhdGljIGludCBwZXJmX292ZXJjb21taXQgX19yZWFkX21vc3RseSA9IDE7CisKK3N0YXRpYyBhdG9taWNfdCBucl9ldmVudHMgX19yZWFkX21vc3RseTsKK3N0YXRpYyBhdG9taWNfdCBucl9tbWFwX2V2ZW50cyBfX3JlYWRfbW9zdGx5Oworc3RhdGljIGF0b21pY190IG5yX2NvbW1fZXZlbnRzIF9fcmVhZF9tb3N0bHk7CitzdGF0aWMgYXRvbWljX3QgbnJfdGFza19ldmVudHMgX19yZWFkX21vc3RseTsKKworLyoKKyAqIHBlcmYgZXZlbnQgcGFyYW5vaWEgbGV2ZWw6CisgKiAgLTEgLSBub3QgcGFyYW5vaWQgYXQgYWxsCisgKiAgIDAgLSBkaXNhbGxvdyByYXcgdHJhY2Vwb2ludCBhY2Nlc3MgZm9yIHVucHJpdgorICogICAxIC0gZGlzYWxsb3cgY3B1IGV2ZW50cyBmb3IgdW5wcml2CisgKiAgIDIgLSBkaXNhbGxvdyBrZXJuZWwgcHJvZmlsaW5nIGZvciB1bnByaXYKKyAqLworaW50IHN5c2N0bF9wZXJmX2V2ZW50X3BhcmFub2lkIF9fcmVhZF9tb3N0bHkgPSAxOworCitzdGF0aWMgaW5saW5lIGJvb2wgcGVyZl9wYXJhbm9pZF90cmFjZXBvaW50X3Jhdyh2b2lkKQoreworCXJldHVybiBzeXNjdGxfcGVyZl9ldmVudF9wYXJhbm9pZCA+IC0xOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgcGVyZl9wYXJhbm9pZF9jcHUodm9pZCkKK3sKKwlyZXR1cm4gc3lzY3RsX3BlcmZfZXZlbnRfcGFyYW5vaWQgPiAwOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgcGVyZl9wYXJhbm9pZF9rZXJuZWwodm9pZCkKK3sKKwlyZXR1cm4gc3lzY3RsX3BlcmZfZXZlbnRfcGFyYW5vaWQgPiAxOworfQorCitpbnQgc3lzY3RsX3BlcmZfZXZlbnRfbWxvY2sgX19yZWFkX21vc3RseSA9IDUxMjsgLyogJ2ZyZWUnIGtiIHBlciB1c2VyICovCisKKy8qCisgKiBtYXggcGVyZiBldmVudCBzYW1wbGUgcmF0ZQorICovCitpbnQgc3lzY3RsX3BlcmZfZXZlbnRfc2FtcGxlX3JhdGUgX19yZWFkX21vc3RseSA9IDEwMDAwMDsKKworc3RhdGljIGF0b21pYzY0X3QgcGVyZl9ldmVudF9pZDsKKworLyoKKyAqIExvY2sgZm9yIChzeXNhZG1pbi1jb25maWd1cmFibGUpIGV2ZW50IHJlc2VydmF0aW9uczoKKyAqLworc3RhdGljIERFRklORV9TUElOTE9DSyhwZXJmX3Jlc291cmNlX2xvY2spOworCisvKgorICogQXJjaGl0ZWN0dXJlIHByb3ZpZGVkIEFQSXMgLSB3ZWFrIGFsaWFzZXM6CisgKi8KK2V4dGVybiBfX3dlYWsgY29uc3Qgc3RydWN0IHBtdSAqaHdfcGVyZl9ldmVudF9pbml0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlyZXR1cm4gTlVMTDsKK30KKwordm9pZCBfX3dlYWsgaHdfcGVyZl9kaXNhYmxlKHZvaWQpCQl7IGJhcnJpZXIoKTsgfQordm9pZCBfX3dlYWsgaHdfcGVyZl9lbmFibGUodm9pZCkJCXsgYmFycmllcigpOyB9CisKK3ZvaWQgX193ZWFrIGh3X3BlcmZfZXZlbnRfc2V0dXAoaW50IGNwdSkJeyBiYXJyaWVyKCk7IH0KK3ZvaWQgX193ZWFrIGh3X3BlcmZfZXZlbnRfc2V0dXBfb25saW5lKGludCBjcHUpCXsgYmFycmllcigpOyB9CisKK2ludCBfX3dlYWsKK2h3X3BlcmZfZ3JvdXBfc2NoZWRfaW4oc3RydWN0IHBlcmZfZXZlbnQgKmdyb3VwX2xlYWRlciwKKwkgICAgICAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKKwkgICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LCBpbnQgY3B1KQoreworCXJldHVybiAwOworfQorCit2b2lkIF9fd2VhayBwZXJmX2V2ZW50X3ByaW50X2RlYnVnKHZvaWQpCXsgfQorCitzdGF0aWMgREVGSU5FX1BFUl9DUFUoaW50LCBwZXJmX2Rpc2FibGVfY291bnQpOworCit2b2lkIF9fcGVyZl9kaXNhYmxlKHZvaWQpCit7CisJX19nZXRfY3B1X3ZhcihwZXJmX2Rpc2FibGVfY291bnQpKys7Cit9CisKK2Jvb2wgX19wZXJmX2VuYWJsZSh2b2lkKQoreworCXJldHVybiAhLS1fX2dldF9jcHVfdmFyKHBlcmZfZGlzYWJsZV9jb3VudCk7Cit9CisKK3ZvaWQgcGVyZl9kaXNhYmxlKHZvaWQpCit7CisJX19wZXJmX2Rpc2FibGUoKTsKKwlod19wZXJmX2Rpc2FibGUoKTsKK30KKwordm9pZCBwZXJmX2VuYWJsZSh2b2lkKQoreworCWlmIChfX3BlcmZfZW5hYmxlKCkpCisJCWh3X3BlcmZfZW5hYmxlKCk7Cit9CisKK3N0YXRpYyB2b2lkIGdldF9jdHgoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCVdBUk5fT04oIWF0b21pY19pbmNfbm90X3plcm8oJmN0eC0+cmVmY291bnQpKTsKK30KKworc3RhdGljIHZvaWQgZnJlZV9jdHgoc3RydWN0IHJjdV9oZWFkICpoZWFkKQoreworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKKworCWN0eCA9IGNvbnRhaW5lcl9vZihoZWFkLCBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0LCByY3VfaGVhZCk7CisJa2ZyZWUoY3R4KTsKK30KKworc3RhdGljIHZvaWQgcHV0X2N0eChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCit7CisJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmN0eC0+cmVmY291bnQpKSB7CisJCWlmIChjdHgtPnBhcmVudF9jdHgpCisJCQlwdXRfY3R4KGN0eC0+cGFyZW50X2N0eCk7CisJCWlmIChjdHgtPnRhc2spCisJCQlwdXRfdGFza19zdHJ1Y3QoY3R4LT50YXNrKTsKKwkJY2FsbF9yY3UoJmN0eC0+cmN1X2hlYWQsIGZyZWVfY3R4KTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHVuY2xvbmVfY3R4KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKK3sKKwlpZiAoY3R4LT5wYXJlbnRfY3R4KSB7CisJCXB1dF9jdHgoY3R4LT5wYXJlbnRfY3R4KTsKKwkJY3R4LT5wYXJlbnRfY3R4ID0gTlVMTDsKKwl9Cit9CisKKy8qCisgKiBJZiB3ZSBpbmhlcml0IGV2ZW50cyB3ZSB3YW50IHRvIHJldHVybiB0aGUgcGFyZW50IGV2ZW50IGlkCisgKiB0byB1c2Vyc3BhY2UuCisgKi8KK3N0YXRpYyB1NjQgcHJpbWFyeV9ldmVudF9pZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJdTY0IGlkID0gZXZlbnQtPmlkOworCisJaWYgKGV2ZW50LT5wYXJlbnQpCisJCWlkID0gZXZlbnQtPnBhcmVudC0+aWQ7CisKKwlyZXR1cm4gaWQ7Cit9CisKKy8qCisgKiBHZXQgdGhlIHBlcmZfZXZlbnRfY29udGV4dCBmb3IgYSB0YXNrIGFuZCBsb2NrIGl0LgorICogVGhpcyBoYXMgdG8gY29wZSB3aXRoIHdpdGggdGhlIGZhY3QgdGhhdCB1bnRpbCBpdCBpcyBsb2NrZWQsCisgKiB0aGUgY29udGV4dCBjb3VsZCBnZXQgbW92ZWQgdG8gYW5vdGhlciB0YXNrLgorICovCitzdGF0aWMgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqCitwZXJmX2xvY2tfdGFza19jb250ZXh0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywgdW5zaWduZWQgbG9uZyAqZmxhZ3MpCit7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4OworCisJcmN1X3JlYWRfbG9jaygpOworIHJldHJ5OgorCWN0eCA9IHJjdV9kZXJlZmVyZW5jZSh0YXNrLT5wZXJmX2V2ZW50X2N0eHApOworCWlmIChjdHgpIHsKKwkJLyoKKwkJICogSWYgdGhpcyBjb250ZXh0IGlzIGEgY2xvbmUgb2YgYW5vdGhlciwgaXQgbWlnaHQKKwkJICogZ2V0IHN3YXBwZWQgZm9yIGFub3RoZXIgdW5kZXJuZWF0aCB1cyBieQorCQkgKiBwZXJmX2V2ZW50X3Rhc2tfc2NoZWRfb3V0LCB0aG91Z2ggdGhlCisJCSAqIHJjdV9yZWFkX2xvY2soKSBwcm90ZWN0cyB1cyBmcm9tIGFueSBjb250ZXh0CisJCSAqIGdldHRpbmcgZnJlZWQuICBMb2NrIHRoZSBjb250ZXh0IGFuZCBjaGVjayBpZiBpdAorCQkgKiBnb3Qgc3dhcHBlZCBiZWZvcmUgd2UgY291bGQgZ2V0IHRoZSBsb2NrLCBhbmQgcmV0cnkKKwkJICogaWYgc28uICBJZiB3ZSBsb2NrZWQgdGhlIHJpZ2h0IGNvbnRleHQsIHRoZW4gaXQKKwkJICogY2FuJ3QgZ2V0IHN3YXBwZWQgb24gdXMgYW55IG1vcmUuCisJCSAqLworCQlzcGluX2xvY2tfaXJxc2F2ZSgmY3R4LT5sb2NrLCAqZmxhZ3MpOworCQlpZiAoY3R4ICE9IHJjdV9kZXJlZmVyZW5jZSh0YXNrLT5wZXJmX2V2ZW50X2N0eHApKSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssICpmbGFncyk7CisJCQlnb3RvIHJldHJ5OworCQl9CisKKwkJaWYgKCFhdG9taWNfaW5jX25vdF96ZXJvKCZjdHgtPnJlZmNvdW50KSkgeworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCAqZmxhZ3MpOworCQkJY3R4ID0gTlVMTDsKKwkJfQorCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKKwlyZXR1cm4gY3R4OworfQorCisvKgorICogR2V0IHRoZSBjb250ZXh0IGZvciBhIHRhc2sgYW5kIGluY3JlbWVudCBpdHMgcGluX2NvdW50IHNvIGl0CisgKiBjYW4ndCBnZXQgc3dhcHBlZCB0byBhbm90aGVyIHRhc2suICBUaGlzIGFsc28gaW5jcmVtZW50cyBpdHMKKyAqIHJlZmVyZW5jZSBjb3VudCBzbyB0aGF0IHRoZSBjb250ZXh0IGNhbid0IGdldCBmcmVlZC4KKyAqLworc3RhdGljIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnBlcmZfcGluX3Rhc2tfY29udGV4dChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwljdHggPSBwZXJmX2xvY2tfdGFza19jb250ZXh0KHRhc2ssICZmbGFncyk7CisJaWYgKGN0eCkgeworCQkrK2N0eC0+cGluX2NvdW50OworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssIGZsYWdzKTsKKwl9CisJcmV0dXJuIGN0eDsKK30KKworc3RhdGljIHZvaWQgcGVyZl91bnBpbl9jb250ZXh0KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmN0eC0+bG9jaywgZmxhZ3MpOworCS0tY3R4LT5waW5fY291bnQ7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCBmbGFncyk7CisJcHV0X2N0eChjdHgpOworfQorCisvKgorICogQWRkIGEgZXZlbnQgZnJvbSB0aGUgbGlzdHMgZm9yIGl0cyBjb250ZXh0LgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGFuZCBjdHgtPmxvY2sgaGVsZC4KKyAqLworc3RhdGljIHZvaWQKK2xpc3RfYWRkX2V2ZW50KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpncm91cF9sZWFkZXIgPSBldmVudC0+Z3JvdXBfbGVhZGVyOworCisJLyoKKwkgKiBEZXBlbmRpbmcgb24gd2hldGhlciBpdCBpcyBhIHN0YW5kYWxvbmUgb3Igc2libGluZyBldmVudCwKKwkgKiBhZGQgaXQgc3RyYWlnaHQgdG8gdGhlIGNvbnRleHQncyBldmVudCBsaXN0LCBvciB0byB0aGUgZ3JvdXAKKwkgKiBsZWFkZXIncyBzaWJsaW5nIGxpc3Q6CisJICovCisJaWYgKGdyb3VwX2xlYWRlciA9PSBldmVudCkKKwkJbGlzdF9hZGRfdGFpbCgmZXZlbnQtPmdyb3VwX2VudHJ5LCAmY3R4LT5ncm91cF9saXN0KTsKKwllbHNlIHsKKwkJbGlzdF9hZGRfdGFpbCgmZXZlbnQtPmdyb3VwX2VudHJ5LCAmZ3JvdXBfbGVhZGVyLT5zaWJsaW5nX2xpc3QpOworCQlncm91cF9sZWFkZXItPm5yX3NpYmxpbmdzKys7CisJfQorCisJbGlzdF9hZGRfcmN1KCZldmVudC0+ZXZlbnRfZW50cnksICZjdHgtPmV2ZW50X2xpc3QpOworCWN0eC0+bnJfZXZlbnRzKys7CisJaWYgKGV2ZW50LT5hdHRyLmluaGVyaXRfc3RhdCkKKwkJY3R4LT5ucl9zdGF0Kys7Cit9CisKKy8qCisgKiBSZW1vdmUgYSBldmVudCBmcm9tIHRoZSBsaXN0cyBmb3IgaXRzIGNvbnRleHQuCisgKiBNdXN0IGJlIGNhbGxlZCB3aXRoIGN0eC0+bXV0ZXggYW5kIGN0eC0+bG9jayBoZWxkLgorICovCitzdGF0aWMgdm9pZAorbGlzdF9kZWxfZXZlbnQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKnNpYmxpbmcsICp0bXA7CisKKwlpZiAobGlzdF9lbXB0eSgmZXZlbnQtPmdyb3VwX2VudHJ5KSkKKwkJcmV0dXJuOworCWN0eC0+bnJfZXZlbnRzLS07CisJaWYgKGV2ZW50LT5hdHRyLmluaGVyaXRfc3RhdCkKKwkJY3R4LT5ucl9zdGF0LS07CisKKwlsaXN0X2RlbF9pbml0KCZldmVudC0+Z3JvdXBfZW50cnkpOworCWxpc3RfZGVsX3JjdSgmZXZlbnQtPmV2ZW50X2VudHJ5KTsKKworCWlmIChldmVudC0+Z3JvdXBfbGVhZGVyICE9IGV2ZW50KQorCQlldmVudC0+Z3JvdXBfbGVhZGVyLT5ucl9zaWJsaW5ncy0tOworCisJLyoKKwkgKiBJZiB0aGlzIHdhcyBhIGdyb3VwIGV2ZW50IHdpdGggc2libGluZyBldmVudHMgdGhlbgorCSAqIHVwZ3JhZGUgdGhlIHNpYmxpbmdzIHRvIHNpbmdsZXRvbiBldmVudHMgYnkgYWRkaW5nIHRoZW0KKwkgKiB0byB0aGUgY29udGV4dCBsaXN0IGRpcmVjdGx5OgorCSAqLworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShzaWJsaW5nLCB0bXAsICZldmVudC0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkgeworCisJCWxpc3RfbW92ZV90YWlsKCZzaWJsaW5nLT5ncm91cF9lbnRyeSwgJmN0eC0+Z3JvdXBfbGlzdCk7CisJCXNpYmxpbmctPmdyb3VwX2xlYWRlciA9IHNpYmxpbmc7CisJfQorfQorCitzdGF0aWMgdm9pZAorZXZlbnRfc2NoZWRfb3V0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCQkgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKK3sKKwlpZiAoZXZlbnQtPnN0YXRlICE9IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQorCQlyZXR1cm47CisKKwlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOworCWlmIChldmVudC0+cGVuZGluZ19kaXNhYmxlKSB7CisJCWV2ZW50LT5wZW5kaW5nX2Rpc2FibGUgPSAwOworCQlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX09GRjsKKwl9CisJZXZlbnQtPnRzdGFtcF9zdG9wcGVkID0gY3R4LT50aW1lOworCWV2ZW50LT5wbXUtPmRpc2FibGUoZXZlbnQpOworCWV2ZW50LT5vbmNwdSA9IC0xOworCisJaWYgKCFpc19zb2Z0d2FyZV9ldmVudChldmVudCkpCisJCWNwdWN0eC0+YWN0aXZlX29uY3B1LS07CisJY3R4LT5ucl9hY3RpdmUtLTsKKwlpZiAoZXZlbnQtPmF0dHIuZXhjbHVzaXZlIHx8ICFjcHVjdHgtPmFjdGl2ZV9vbmNwdSkKKwkJY3B1Y3R4LT5leGNsdXNpdmUgPSAwOworfQorCitzdGF0aWMgdm9pZAorZ3JvdXBfc2NoZWRfb3V0KHN0cnVjdCBwZXJmX2V2ZW50ICpncm91cF9ldmVudCwKKwkJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKKwkJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKworCWlmIChncm91cF9ldmVudC0+c3RhdGUgIT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpCisJCXJldHVybjsKKworCWV2ZW50X3NjaGVkX291dChncm91cF9ldmVudCwgY3B1Y3R4LCBjdHgpOworCisJLyoKKwkgKiBTY2hlZHVsZSBvdXQgc2libGluZ3MgKGlmIGFueSk6CisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmdyb3VwX2V2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KQorCQlldmVudF9zY2hlZF9vdXQoZXZlbnQsIGNwdWN0eCwgY3R4KTsKKworCWlmIChncm91cF9ldmVudC0+YXR0ci5leGNsdXNpdmUpCisJCWNwdWN0eC0+ZXhjbHVzaXZlID0gMDsKK30KKworLyoKKyAqIENyb3NzIENQVSBjYWxsIHRvIHJlbW92ZSBhIHBlcmZvcm1hbmNlIGV2ZW50CisgKgorICogV2UgZGlzYWJsZSB0aGUgZXZlbnQgb24gdGhlIGhhcmR3YXJlIGxldmVsIGZpcnN0LiBBZnRlciB0aGF0IHdlCisgKiByZW1vdmUgaXQgZnJvbSB0aGUgY29udGV4dCBsaXN0LgorICovCitzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dCh2b2lkICppbmZvKQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBpbmZvOworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgYSB0YXNrIGNvbnRleHQsIHdlIG5lZWQgdG8gY2hlY2sgd2hldGhlciBpdCBpcworCSAqIHRoZSBjdXJyZW50IHRhc2sgY29udGV4dCBvZiB0aGlzIGNwdS4gSWYgbm90IGl0IGhhcyBiZWVuCisJICogc2NoZWR1bGVkIG91dCBiZWZvcmUgdGhlIHNtcCBjYWxsIGFycml2ZWQuCisJICovCisJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCS8qCisJICogUHJvdGVjdCB0aGUgbGlzdCBvcGVyYXRpb24gYWdhaW5zdCBOTUkgYnkgZGlzYWJsaW5nIHRoZQorCSAqIGV2ZW50cyBvbiBhIGdsb2JhbCBsZXZlbC4KKwkgKi8KKwlwZXJmX2Rpc2FibGUoKTsKKworCWV2ZW50X3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOworCisJbGlzdF9kZWxfZXZlbnQoZXZlbnQsIGN0eCk7CisKKwlpZiAoIWN0eC0+dGFzaykgeworCQkvKgorCQkgKiBBbGxvdyBtb3JlIHBlciB0YXNrIGV2ZW50cyB3aXRoIHJlc3BlY3QgdG8gdGhlCisJCSAqIHJlc2VydmF0aW9uOgorCQkgKi8KKwkJY3B1Y3R4LT5tYXhfcGVydGFzayA9CisJCQltaW4ocGVyZl9tYXhfZXZlbnRzIC0gY3R4LT5ucl9ldmVudHMsCisJCQkgICAgcGVyZl9tYXhfZXZlbnRzIC0gcGVyZl9yZXNlcnZlZF9wZXJjcHUpOworCX0KKworCXBlcmZfZW5hYmxlKCk7CisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKKworLyoKKyAqIFJlbW92ZSB0aGUgZXZlbnQgZnJvbSBhIHRhc2sncyAob3IgYSBDUFUncykgbGlzdCBvZiBldmVudHMuCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQuCisgKgorICogQ1BVIGV2ZW50cyBhcmUgcmVtb3ZlZCB3aXRoIGEgc21wIGNhbGwuIEZvciB0YXNrIGV2ZW50cyB3ZSBvbmx5CisgKiBjYWxsIHdoZW4gdGhlIHRhc2sgaXMgb24gYSBDUFUuCisgKgorICogSWYgZXZlbnQtPmN0eCBpcyBhIGNsb25lZCBjb250ZXh0LCBjYWxsZXJzIG11c3QgbWFrZSBzdXJlIHRoYXQKKyAqIGV2ZXJ5IHRhc2sgc3RydWN0IHRoYXQgZXZlbnQtPmN0eC0+dGFzayBjb3VsZCBwb3NzaWJseSBwb2ludCB0bworICogcmVtYWlucyB2YWxpZC4gIFRoaXMgaXMgT0sgd2hlbiBjYWxsZWQgZnJvbSBwZXJmX3JlbGVhc2Ugc2luY2UKKyAqIHRoYXQgb25seSBjYWxscyB1cyBvbiB0aGUgdG9wLWxldmVsIGNvbnRleHQsIHdoaWNoIGNhbid0IGJlIGEgY2xvbmUuCisgKiBXaGVuIGNhbGxlZCBmcm9tIHBlcmZfZXZlbnRfZXhpdF90YXNrLCBpdCdzIE9LIGJlY2F1c2UgdGhlCisgKiBjb250ZXh0IGhhcyBiZWVuIGRldGFjaGVkIGZyb20gaXRzIHRhc2suCisgKi8KK3N0YXRpYyB2b2lkIHBlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gZXZlbnQtPmN0eDsKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2sgPSBjdHgtPnRhc2s7CisKKwlpZiAoIXRhc2spIHsKKwkJLyoKKwkJICogUGVyIGNwdSBldmVudHMgYXJlIHJlbW92ZWQgdmlhIGFuIHNtcCBjYWxsIGFuZAorCQkgKiB0aGUgcmVtb3ZhbCBpcyBhbHdheXMgc3VjZXNzZnVsLgorCQkgKi8KKwkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGV2ZW50LT5jcHUsCisJCQkJCSBfX3BlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dCwKKwkJCQkJIGV2ZW50LCAxKTsKKwkJcmV0dXJuOworCX0KKworcmV0cnk6CisJdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9ldmVudF9yZW1vdmVfZnJvbV9jb250ZXh0LAorCQkJCSBldmVudCk7CisKKwlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOworCS8qCisJICogSWYgdGhlIGNvbnRleHQgaXMgYWN0aXZlIHdlIG5lZWQgdG8gcmV0cnkgdGhlIHNtcCBjYWxsLgorCSAqLworCWlmIChjdHgtPm5yX2FjdGl2ZSAmJiAhbGlzdF9lbXB0eSgmZXZlbnQtPmdyb3VwX2VudHJ5KSkgeworCQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7CisJCWdvdG8gcmV0cnk7CisJfQorCisJLyoKKwkgKiBUaGUgbG9jayBwcmV2ZW50cyB0aGF0IHRoaXMgY29udGV4dCBpcyBzY2hlZHVsZWQgaW4gc28gd2UKKwkgKiBjYW4gcmVtb3ZlIHRoZSBldmVudCBzYWZlbHksIGlmIHRoZSBjYWxsIGFib3ZlIGRpZCBub3QKKwkgKiBzdWNjZWVkLgorCSAqLworCWlmICghbGlzdF9lbXB0eSgmZXZlbnQtPmdyb3VwX2VudHJ5KSkgeworCQlsaXN0X2RlbF9ldmVudChldmVudCwgY3R4KTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworfQorCitzdGF0aWMgaW5saW5lIHU2NCBwZXJmX2Nsb2NrKHZvaWQpCit7CisJcmV0dXJuIGNwdV9jbG9jayhzbXBfcHJvY2Vzc29yX2lkKCkpOworfQorCisvKgorICogVXBkYXRlIHRoZSByZWNvcmQgb2YgdGhlIGN1cnJlbnQgdGltZSBpbiBhIGNvbnRleHQuCisgKi8KK3N0YXRpYyB2b2lkIHVwZGF0ZV9jb250ZXh0X3RpbWUoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7CisKKwljdHgtPnRpbWUgKz0gbm93IC0gY3R4LT50aW1lc3RhbXA7CisJY3R4LT50aW1lc3RhbXAgPSBub3c7Cit9CisKKy8qCisgKiBVcGRhdGUgdGhlIHRvdGFsX3RpbWVfZW5hYmxlZCBhbmQgdG90YWxfdGltZV9ydW5uaW5nIGZpZWxkcyBmb3IgYSBldmVudC4KKyAqLworc3RhdGljIHZvaWQgdXBkYXRlX2V2ZW50X3RpbWVzKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OworCXU2NCBydW5fZW5kOworCisJaWYgKGV2ZW50LT5zdGF0ZSA8IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUgfHwKKwkgICAgZXZlbnQtPmdyb3VwX2xlYWRlci0+c3RhdGUgPCBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFKQorCQlyZXR1cm47CisKKwlldmVudC0+dG90YWxfdGltZV9lbmFibGVkID0gY3R4LT50aW1lIC0gZXZlbnQtPnRzdGFtcF9lbmFibGVkOworCisJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFKQorCQlydW5fZW5kID0gZXZlbnQtPnRzdGFtcF9zdG9wcGVkOworCWVsc2UKKwkJcnVuX2VuZCA9IGN0eC0+dGltZTsKKworCWV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcgPSBydW5fZW5kIC0gZXZlbnQtPnRzdGFtcF9ydW5uaW5nOworfQorCisvKgorICogVXBkYXRlIHRvdGFsX3RpbWVfZW5hYmxlZCBhbmQgdG90YWxfdGltZV9ydW5uaW5nIGZvciBhbGwgZXZlbnRzIGluIGEgZ3JvdXAuCisgKi8KK3N0YXRpYyB2b2lkIHVwZGF0ZV9ncm91cF90aW1lcyhzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKworCXVwZGF0ZV9ldmVudF90aW1lcyhsZWFkZXIpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpCisJCXVwZGF0ZV9ldmVudF90aW1lcyhldmVudCk7Cit9CisKKy8qCisgKiBDcm9zcyBDUFUgY2FsbCB0byBkaXNhYmxlIGEgcGVyZm9ybWFuY2UgZXZlbnQKKyAqLworc3RhdGljIHZvaWQgX19wZXJmX2V2ZW50X2Rpc2FibGUodm9pZCAqaW5mbykKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBpbmZvOworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OworCisJLyoKKwkgKiBJZiB0aGlzIGlzIGEgcGVyLXRhc2sgZXZlbnQsIG5lZWQgdG8gY2hlY2sgd2hldGhlciB0aGlzCisJICogZXZlbnQncyB0YXNrIGlzIHRoZSBjdXJyZW50IHRhc2sgb24gdGhpcyBjcHUuCisJICovCisJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkKKwkJcmV0dXJuOworCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCisJLyoKKwkgKiBJZiB0aGUgZXZlbnQgaXMgb24sIHR1cm4gaXQgb2ZmLgorCSAqIElmIGl0IGlzIGluIGVycm9yIHN0YXRlLCBsZWF2ZSBpdCBpbiBlcnJvciBzdGF0ZS4KKwkgKi8KKwlpZiAoZXZlbnQtPnN0YXRlID49IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpIHsKKwkJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOworCQl1cGRhdGVfZ3JvdXBfdGltZXMoZXZlbnQpOworCQlpZiAoZXZlbnQgPT0gZXZlbnQtPmdyb3VwX2xlYWRlcikKKwkJCWdyb3VwX3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOworCQllbHNlCisJCQlldmVudF9zY2hlZF9vdXQoZXZlbnQsIGNwdWN0eCwgY3R4KTsKKwkJZXZlbnQtPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9PRkY7CisJfQorCisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKKy8qCisgKiBEaXNhYmxlIGEgZXZlbnQuCisgKgorICogSWYgZXZlbnQtPmN0eCBpcyBhIGNsb25lZCBjb250ZXh0LCBjYWxsZXJzIG11c3QgbWFrZSBzdXJlIHRoYXQKKyAqIGV2ZXJ5IHRhc2sgc3RydWN0IHRoYXQgZXZlbnQtPmN0eC0+dGFzayBjb3VsZCBwb3NzaWJseSBwb2ludCB0bworICogcmVtYWlucyB2YWxpZC4gIFRoaXMgY29uZGl0aW9uIGlzIHNhdGlzaWZlZCB3aGVuIGNhbGxlZCB0aHJvdWdoCisgKiBwZXJmX2V2ZW50X2Zvcl9lYWNoX2NoaWxkIG9yIHBlcmZfZXZlbnRfZm9yX2VhY2ggYmVjYXVzZSB0aGV5CisgKiBob2xkIHRoZSB0b3AtbGV2ZWwgZXZlbnQncyBjaGlsZF9tdXRleCwgc28gYW55IGRlc2NlbmRhbnQgdGhhdAorICogZ29lcyB0byBleGl0IHdpbGwgYmxvY2sgaW4gc3luY19jaGlsZF9ldmVudC4KKyAqIFdoZW4gY2FsbGVkIGZyb20gcGVyZl9wZW5kaW5nX2V2ZW50IGl0J3MgT0sgYmVjYXVzZSBldmVudC0+Y3R4CisgKiBpcyB0aGUgY3VycmVudCBjb250ZXh0IG9uIHRoaXMgQ1BVIGFuZCBwcmVlbXB0aW9uIGlzIGRpc2FibGVkLAorICogaGVuY2Ugd2UgY2FuJ3QgZ2V0IGludG8gcGVyZl9ldmVudF90YXNrX3NjaGVkX291dCBmb3IgdGhpcyBjb250ZXh0LgorICovCitzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2Rpc2FibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gY3R4LT50YXNrOworCisJaWYgKCF0YXNrKSB7CisJCS8qCisJCSAqIERpc2FibGUgdGhlIGV2ZW50IG9uIHRoZSBjcHUgdGhhdCBpdCdzIG9uCisJCSAqLworCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoZXZlbnQtPmNwdSwgX19wZXJmX2V2ZW50X2Rpc2FibGUsCisJCQkJCSBldmVudCwgMSk7CisJCXJldHVybjsKKwl9CisKKyByZXRyeToKKwl0YXNrX29uY3B1X2Z1bmN0aW9uX2NhbGwodGFzaywgX19wZXJmX2V2ZW50X2Rpc2FibGUsIGV2ZW50KTsKKworCXNwaW5fbG9ja19pcnEoJmN0eC0+bG9jayk7CisJLyoKKwkgKiBJZiB0aGUgZXZlbnQgaXMgc3RpbGwgYWN0aXZlLCB3ZSBuZWVkIHRvIHJldHJ5IHRoZSBjcm9zcy1jYWxsLgorCSAqLworCWlmIChldmVudC0+c3RhdGUgPT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpIHsKKwkJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworCQlnb3RvIHJldHJ5OworCX0KKworCS8qCisJICogU2luY2Ugd2UgaGF2ZSB0aGUgbG9jayB0aGlzIGNvbnRleHQgY2FuJ3QgYmUgc2NoZWR1bGVkCisJICogaW4sIHNvIHdlIGNhbiBjaGFuZ2UgdGhlIHN0YXRlIHNhZmVseS4KKwkgKi8KKwlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpIHsKKwkJdXBkYXRlX2dyb3VwX3RpbWVzKGV2ZW50KTsKKwkJZXZlbnQtPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9PRkY7CisJfQorCisJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworfQorCitzdGF0aWMgaW50CitldmVudF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCSBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCQkgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAorCQkgaW50IGNwdSkKK3sKKwlpZiAoZXZlbnQtPnN0YXRlIDw9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGKQorCQlyZXR1cm4gMDsKKworCWV2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFOworCWV2ZW50LT5vbmNwdSA9IGNwdTsJLyogVE9ETzogcHV0ICdjcHUnIGludG8gY3B1Y3R4LT5jcHUgKi8KKwkvKgorCSAqIFRoZSBuZXcgc3RhdGUgbXVzdCBiZSB2aXNpYmxlIGJlZm9yZSB3ZSB0dXJuIGl0IG9uIGluIHRoZSBoYXJkd2FyZToKKwkgKi8KKwlzbXBfd21iKCk7CisKKwlpZiAoZXZlbnQtPnBtdS0+ZW5hYmxlKGV2ZW50KSkgeworCQlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOworCQlldmVudC0+b25jcHUgPSAtMTsKKwkJcmV0dXJuIC1FQUdBSU47CisJfQorCisJZXZlbnQtPnRzdGFtcF9ydW5uaW5nICs9IGN0eC0+dGltZSAtIGV2ZW50LT50c3RhbXBfc3RvcHBlZDsKKworCWlmICghaXNfc29mdHdhcmVfZXZlbnQoZXZlbnQpKQorCQljcHVjdHgtPmFjdGl2ZV9vbmNwdSsrOworCWN0eC0+bnJfYWN0aXZlKys7CisKKwlpZiAoZXZlbnQtPmF0dHIuZXhjbHVzaXZlKQorCQljcHVjdHgtPmV4Y2x1c2l2ZSA9IDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorZ3JvdXBfc2NoZWRfaW4oc3RydWN0IHBlcmZfZXZlbnQgKmdyb3VwX2V2ZW50LAorCSAgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAorCSAgICAgICBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJICAgICAgIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqcGFydGlhbF9ncm91cDsKKwlpbnQgcmV0OworCisJaWYgKGdyb3VwX2V2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX09GRikKKwkJcmV0dXJuIDA7CisKKwlyZXQgPSBod19wZXJmX2dyb3VwX3NjaGVkX2luKGdyb3VwX2V2ZW50LCBjcHVjdHgsIGN0eCwgY3B1KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0IDwgMCA/IHJldCA6IDA7CisKKwlpZiAoZXZlbnRfc2NoZWRfaW4oZ3JvdXBfZXZlbnQsIGNwdWN0eCwgY3R4LCBjcHUpKQorCQlyZXR1cm4gLUVBR0FJTjsKKworCS8qCisJICogU2NoZWR1bGUgaW4gc2libGluZ3MgYXMgb25lIGdyb3VwIChpZiBhbnkpOgorCSAqLworCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZncm91cF9ldmVudC0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkgeworCQlpZiAoZXZlbnRfc2NoZWRfaW4oZXZlbnQsIGNwdWN0eCwgY3R4LCBjcHUpKSB7CisJCQlwYXJ0aWFsX2dyb3VwID0gZXZlbnQ7CisJCQlnb3RvIGdyb3VwX2Vycm9yOworCQl9CisJfQorCisJcmV0dXJuIDA7CisKK2dyb3VwX2Vycm9yOgorCS8qCisJICogR3JvdXBzIGNhbiBiZSBzY2hlZHVsZWQgaW4gYXMgb25lIHVuaXQgb25seSwgc28gdW5kbyBhbnkKKwkgKiBwYXJ0aWFsIGdyb3VwIGJlZm9yZSByZXR1cm5pbmc6CisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmdyb3VwX2V2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7CisJCWlmIChldmVudCA9PSBwYXJ0aWFsX2dyb3VwKQorCQkJYnJlYWs7CisJCWV2ZW50X3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOworCX0KKwlldmVudF9zY2hlZF9vdXQoZ3JvdXBfZXZlbnQsIGNwdWN0eCwgY3R4KTsKKworCXJldHVybiAtRUFHQUlOOworfQorCisvKgorICogUmV0dXJuIDEgZm9yIGEgZ3JvdXAgY29uc2lzdGluZyBlbnRpcmVseSBvZiBzb2Z0d2FyZSBldmVudHMsCisgKiAwIGlmIHRoZSBncm91cCBjb250YWlucyBhbnkgaGFyZHdhcmUgZXZlbnRzLgorICovCitzdGF0aWMgaW50IGlzX3NvZnR3YXJlX29ubHlfZ3JvdXAoc3RydWN0IHBlcmZfZXZlbnQgKmxlYWRlcikKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CisKKwlpZiAoIWlzX3NvZnR3YXJlX2V2ZW50KGxlYWRlcikpCisJCXJldHVybiAwOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmxlYWRlci0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkKKwkJaWYgKCFpc19zb2Z0d2FyZV9ldmVudChldmVudCkpCisJCQlyZXR1cm4gMDsKKworCXJldHVybiAxOworfQorCisvKgorICogV29yayBvdXQgd2hldGhlciB3ZSBjYW4gcHV0IHRoaXMgZXZlbnQgZ3JvdXAgb24gdGhlIENQVSBub3cuCisgKi8KK3N0YXRpYyBpbnQgZ3JvdXBfY2FuX2dvX29uKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJCSAgIHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsCisJCQkgICBpbnQgY2FuX2FkZF9odykKK3sKKwkvKgorCSAqIEdyb3VwcyBjb25zaXN0aW5nIGVudGlyZWx5IG9mIHNvZnR3YXJlIGV2ZW50cyBjYW4gYWx3YXlzIGdvIG9uLgorCSAqLworCWlmIChpc19zb2Z0d2FyZV9vbmx5X2dyb3VwKGV2ZW50KSkKKwkJcmV0dXJuIDE7CisJLyoKKwkgKiBJZiBhbiBleGNsdXNpdmUgZ3JvdXAgaXMgYWxyZWFkeSBvbiwgbm8gb3RoZXIgaGFyZHdhcmUKKwkgKiBldmVudHMgY2FuIGdvIG9uLgorCSAqLworCWlmIChjcHVjdHgtPmV4Y2x1c2l2ZSkKKwkJcmV0dXJuIDA7CisJLyoKKwkgKiBJZiB0aGlzIGdyb3VwIGlzIGV4Y2x1c2l2ZSBhbmQgdGhlcmUgYXJlIGFscmVhZHkKKwkgKiBldmVudHMgb24gdGhlIENQVSwgaXQgY2FuJ3QgZ28gb24uCisJICovCisJaWYgKGV2ZW50LT5hdHRyLmV4Y2x1c2l2ZSAmJiBjcHVjdHgtPmFjdGl2ZV9vbmNwdSkKKwkJcmV0dXJuIDA7CisJLyoKKwkgKiBPdGhlcndpc2UsIHRyeSB0byBhZGQgaXQgaWYgYWxsIHByZXZpb3VzIGdyb3VwcyB3ZXJlIGFibGUKKwkgKiB0byBnbyBvbi4KKwkgKi8KKwlyZXR1cm4gY2FuX2FkZF9odzsKK30KKworc3RhdGljIHZvaWQgYWRkX2V2ZW50X3RvX2N0eChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkgICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCWxpc3RfYWRkX2V2ZW50KGV2ZW50LCBjdHgpOworCWV2ZW50LT50c3RhbXBfZW5hYmxlZCA9IGN0eC0+dGltZTsKKwlldmVudC0+dHN0YW1wX3J1bm5pbmcgPSBjdHgtPnRpbWU7CisJZXZlbnQtPnRzdGFtcF9zdG9wcGVkID0gY3R4LT50aW1lOworfQorCisvKgorICogQ3Jvc3MgQ1BVIGNhbGwgdG8gaW5zdGFsbCBhbmQgZW5hYmxlIGEgcGVyZm9ybWFuY2UgZXZlbnQKKyAqCisgKiBNdXN0IGJlIGNhbGxlZCB3aXRoIGN0eC0+bXV0ZXggaGVsZAorICovCitzdGF0aWMgdm9pZCBfX3BlcmZfaW5zdGFsbF9pbl9jb250ZXh0KHZvaWQgKmluZm8pCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGluZm87CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gZXZlbnQtPmN0eDsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyID0gZXZlbnQtPmdyb3VwX2xlYWRlcjsKKwlpbnQgY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOworCWludCBlcnI7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgYSB0YXNrIGNvbnRleHQsIHdlIG5lZWQgdG8gY2hlY2sgd2hldGhlciBpdCBpcworCSAqIHRoZSBjdXJyZW50IHRhc2sgY29udGV4dCBvZiB0aGlzIGNwdS4gSWYgbm90IGl0IGhhcyBiZWVuCisJICogc2NoZWR1bGVkIG91dCBiZWZvcmUgdGhlIHNtcCBjYWxsIGFycml2ZWQuCisJICogT3IgcG9zc2libHkgdGhpcyBpcyB0aGUgcmlnaHQgY29udGV4dCBidXQgaXQgaXNuJ3QKKwkgKiBvbiB0aGlzIGNwdSBiZWNhdXNlIGl0IGhhZCBubyBldmVudHMuCisJICovCisJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkgeworCQlpZiAoY3B1Y3R4LT50YXNrX2N0eCB8fCBjdHgtPnRhc2sgIT0gY3VycmVudCkKKwkJCXJldHVybjsKKwkJY3B1Y3R4LT50YXNrX2N0eCA9IGN0eDsKKwl9CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJY3R4LT5pc19hY3RpdmUgPSAxOworCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKKworCS8qCisJICogUHJvdGVjdCB0aGUgbGlzdCBvcGVyYXRpb24gYWdhaW5zdCBOTUkgYnkgZGlzYWJsaW5nIHRoZQorCSAqIGV2ZW50cyBvbiBhIGdsb2JhbCBsZXZlbC4gTk9QIGZvciBub24gTk1JIGJhc2VkIGV2ZW50cy4KKwkgKi8KKwlwZXJmX2Rpc2FibGUoKTsKKworCWFkZF9ldmVudF90b19jdHgoZXZlbnQsIGN0eCk7CisKKwkvKgorCSAqIERvbid0IHB1dCB0aGUgZXZlbnQgb24gaWYgaXQgaXMgZGlzYWJsZWQgb3IgaWYKKwkgKiBpdCBpcyBpbiBhIGdyb3VwIGFuZCB0aGUgZ3JvdXAgaXNuJ3Qgb24uCisJICovCisJaWYgKGV2ZW50LT5zdGF0ZSAhPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFIHx8CisJICAgIChsZWFkZXIgIT0gZXZlbnQgJiYgbGVhZGVyLT5zdGF0ZSAhPSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRSkpCisJCWdvdG8gdW5sb2NrOworCisJLyoKKwkgKiBBbiBleGNsdXNpdmUgZXZlbnQgY2FuJ3QgZ28gb24gaWYgdGhlcmUgYXJlIGFscmVhZHkgYWN0aXZlCisJICogaGFyZHdhcmUgZXZlbnRzLCBhbmQgbm8gaGFyZHdhcmUgZXZlbnQgY2FuIGdvIG9uIGlmIHRoZXJlCisJICogaXMgYWxyZWFkeSBhbiBleGNsdXNpdmUgZXZlbnQgb24uCisJICovCisJaWYgKCFncm91cF9jYW5fZ29fb24oZXZlbnQsIGNwdWN0eCwgMSkpCisJCWVyciA9IC1FRVhJU1Q7CisJZWxzZQorCQllcnIgPSBldmVudF9zY2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgsIGNwdSk7CisKKwlpZiAoZXJyKSB7CisJCS8qCisJCSAqIFRoaXMgZXZlbnQgY291bGRuJ3QgZ28gb24uICBJZiBpdCBpcyBpbiBhIGdyb3VwCisJCSAqIHRoZW4gd2UgaGF2ZSB0byBwdWxsIHRoZSB3aG9sZSBncm91cCBvZmYuCisJCSAqIElmIHRoZSBldmVudCBncm91cCBpcyBwaW5uZWQgdGhlbiBwdXQgaXQgaW4gZXJyb3Igc3RhdGUuCisJCSAqLworCQlpZiAobGVhZGVyICE9IGV2ZW50KQorCQkJZ3JvdXBfc2NoZWRfb3V0KGxlYWRlciwgY3B1Y3R4LCBjdHgpOworCQlpZiAobGVhZGVyLT5hdHRyLnBpbm5lZCkgeworCQkJdXBkYXRlX2dyb3VwX3RpbWVzKGxlYWRlcik7CisJCQlsZWFkZXItPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9FUlJPUjsKKwkJfQorCX0KKworCWlmICghZXJyICYmICFjdHgtPnRhc2sgJiYgY3B1Y3R4LT5tYXhfcGVydGFzaykKKwkJY3B1Y3R4LT5tYXhfcGVydGFzay0tOworCisgdW5sb2NrOgorCXBlcmZfZW5hYmxlKCk7CisKKwlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKK30KKworLyoKKyAqIEF0dGFjaCBhIHBlcmZvcm1hbmNlIGV2ZW50IHRvIGEgY29udGV4dAorICoKKyAqIEZpcnN0IHdlIGFkZCB0aGUgZXZlbnQgdG8gdGhlIGxpc3Qgd2l0aCB0aGUgaGFyZHdhcmUgZW5hYmxlIGJpdAorICogaW4gZXZlbnQtPmh3X2NvbmZpZyBjbGVhcmVkLgorICoKKyAqIElmIHRoZSBldmVudCBpcyBhdHRhY2hlZCB0byBhIHRhc2sgd2hpY2ggaXMgb24gYSBDUFUgd2UgdXNlIGEgc21wCisgKiBjYWxsIHRvIGVuYWJsZSBpdCBpbiB0aGUgdGFzayBjb250ZXh0LiBUaGUgdGFzayBtaWdodCBoYXZlIGJlZW4KKyAqIHNjaGVkdWxlZCBhd2F5LCBidXQgd2UgY2hlY2sgdGhpcyBpbiB0aGUgc21wIGNhbGwgYWdhaW4uCisgKgorICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQuCisgKi8KK3N0YXRpYyB2b2lkCitwZXJmX2luc3RhbGxfaW5fY29udGV4dChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCQlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQlpbnQgY3B1KQoreworCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKKworCWlmICghdGFzaykgeworCQkvKgorCQkgKiBQZXIgY3B1IGV2ZW50cyBhcmUgaW5zdGFsbGVkIHZpYSBhbiBzbXAgY2FsbCBhbmQKKwkJICogdGhlIGluc3RhbGwgaXMgYWx3YXlzIHN1Y2Vzc2Z1bC4KKwkJICovCisJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjcHUsIF9fcGVyZl9pbnN0YWxsX2luX2NvbnRleHQsCisJCQkJCSBldmVudCwgMSk7CisJCXJldHVybjsKKwl9CisKK3JldHJ5OgorCXRhc2tfb25jcHVfZnVuY3Rpb25fY2FsbCh0YXNrLCBfX3BlcmZfaW5zdGFsbF9pbl9jb250ZXh0LAorCQkJCSBldmVudCk7CisKKwlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOworCS8qCisJICogd2UgbmVlZCB0byByZXRyeSB0aGUgc21wIGNhbGwuCisJICovCisJaWYgKGN0eC0+aXNfYWN0aXZlICYmIGxpc3RfZW1wdHkoJmV2ZW50LT5ncm91cF9lbnRyeSkpIHsKKwkJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworCQlnb3RvIHJldHJ5OworCX0KKworCS8qCisJICogVGhlIGxvY2sgcHJldmVudHMgdGhhdCB0aGlzIGNvbnRleHQgaXMgc2NoZWR1bGVkIGluIHNvIHdlCisJICogY2FuIGFkZCB0aGUgZXZlbnQgc2FmZWx5LCBpZiBpdCB0aGUgY2FsbCBhYm92ZSBkaWQgbm90CisJICogc3VjY2VlZC4KKwkgKi8KKwlpZiAobGlzdF9lbXB0eSgmZXZlbnQtPmdyb3VwX2VudHJ5KSkKKwkJYWRkX2V2ZW50X3RvX2N0eChldmVudCwgY3R4KTsKKwlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Cit9CisKKy8qCisgKiBQdXQgYSBldmVudCBpbnRvIGluYWN0aXZlIHN0YXRlIGFuZCB1cGRhdGUgdGltZSBmaWVsZHMuCisgKiBFbmFibGluZyB0aGUgbGVhZGVyIG9mIGEgZ3JvdXAgZWZmZWN0aXZlbHkgZW5hYmxlcyBhbGwKKyAqIHRoZSBncm91cCBtZW1iZXJzIHRoYXQgYXJlbid0IGV4cGxpY2l0bHkgZGlzYWJsZWQsIHNvIHdlCisgKiBoYXZlIHRvIHVwZGF0ZSB0aGVpciAtPnRzdGFtcF9lbmFibGVkIGFsc28uCisgKiBOb3RlOiB0aGlzIHdvcmtzIGZvciBncm91cCBtZW1iZXJzIGFzIHdlbGwgYXMgZ3JvdXAgbGVhZGVycworICogc2luY2UgdGhlIG5vbi1sZWFkZXIgbWVtYmVycycgc2libGluZ19saXN0cyB3aWxsIGJlIGVtcHR5LgorICovCitzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfbWFya19lbmFibGVkKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJCQkJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpzdWI7CisKKwlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOworCWV2ZW50LT50c3RhbXBfZW5hYmxlZCA9IGN0eC0+dGltZSAtIGV2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQ7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZldmVudC0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkKKwkJaWYgKHN1Yi0+c3RhdGUgPj0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKKwkJCXN1Yi0+dHN0YW1wX2VuYWJsZWQgPQorCQkJCWN0eC0+dGltZSAtIHN1Yi0+dG90YWxfdGltZV9lbmFibGVkOworfQorCisvKgorICogQ3Jvc3MgQ1BVIGNhbGwgdG8gZW5hYmxlIGEgcGVyZm9ybWFuY2UgZXZlbnQKKyAqLworc3RhdGljIHZvaWQgX19wZXJmX2V2ZW50X2VuYWJsZSh2b2lkICppbmZvKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGluZm87CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CisJc3RydWN0IHBlcmZfZXZlbnQgKmxlYWRlciA9IGV2ZW50LT5ncm91cF9sZWFkZXI7CisJaW50IGVycjsKKworCS8qCisJICogSWYgdGhpcyBpcyBhIHBlci10YXNrIGV2ZW50LCBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgdGhpcworCSAqIGV2ZW50J3MgdGFzayBpcyB0aGUgY3VycmVudCB0YXNrIG9uIHRoaXMgY3B1LgorCSAqLworCWlmIChjdHgtPnRhc2sgJiYgY3B1Y3R4LT50YXNrX2N0eCAhPSBjdHgpIHsKKwkJaWYgKGNwdWN0eC0+dGFza19jdHggfHwgY3R4LT50YXNrICE9IGN1cnJlbnQpCisJCQlyZXR1cm47CisJCWNwdWN0eC0+dGFza19jdHggPSBjdHg7CisJfQorCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCWN0eC0+aXNfYWN0aXZlID0gMTsKKwl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7CisKKwlpZiAoZXZlbnQtPnN0YXRlID49IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpCisJCWdvdG8gdW5sb2NrOworCV9fcGVyZl9ldmVudF9tYXJrX2VuYWJsZWQoZXZlbnQsIGN0eCk7CisKKwkvKgorCSAqIElmIHRoZSBldmVudCBpcyBpbiBhIGdyb3VwIGFuZCBpc24ndCB0aGUgZ3JvdXAgbGVhZGVyLAorCSAqIHRoZW4gZG9uJ3QgcHV0IGl0IG9uIHVubGVzcyB0aGUgZ3JvdXAgaXMgb24uCisJICovCisJaWYgKGxlYWRlciAhPSBldmVudCAmJiBsZWFkZXItPnN0YXRlICE9IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQorCQlnb3RvIHVubG9jazsKKworCWlmICghZ3JvdXBfY2FuX2dvX29uKGV2ZW50LCBjcHVjdHgsIDEpKSB7CisJCWVyciA9IC1FRVhJU1Q7CisJfSBlbHNlIHsKKwkJcGVyZl9kaXNhYmxlKCk7CisJCWlmIChldmVudCA9PSBsZWFkZXIpCisJCQllcnIgPSBncm91cF9zY2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgsCisJCQkJCSAgICAgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwkJZWxzZQorCQkJZXJyID0gZXZlbnRfc2NoZWRfaW4oZXZlbnQsIGNwdWN0eCwgY3R4LAorCQkJCQkgICAgICAgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwkJcGVyZl9lbmFibGUoKTsKKwl9CisKKwlpZiAoZXJyKSB7CisJCS8qCisJCSAqIElmIHRoaXMgZXZlbnQgY2FuJ3QgZ28gb24gYW5kIGl0J3MgcGFydCBvZiBhCisJCSAqIGdyb3VwLCB0aGVuIHRoZSB3aG9sZSBncm91cCBoYXMgdG8gY29tZSBvZmYuCisJCSAqLworCQlpZiAobGVhZGVyICE9IGV2ZW50KQorCQkJZ3JvdXBfc2NoZWRfb3V0KGxlYWRlciwgY3B1Y3R4LCBjdHgpOworCQlpZiAobGVhZGVyLT5hdHRyLnBpbm5lZCkgeworCQkJdXBkYXRlX2dyb3VwX3RpbWVzKGxlYWRlcik7CisJCQlsZWFkZXItPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9FUlJPUjsKKwkJfQorCX0KKworIHVubG9jazoKKwlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKK30KKworLyoKKyAqIEVuYWJsZSBhIGV2ZW50LgorICoKKyAqIElmIGV2ZW50LT5jdHggaXMgYSBjbG9uZWQgY29udGV4dCwgY2FsbGVycyBtdXN0IG1ha2Ugc3VyZSB0aGF0CisgKiBldmVyeSB0YXNrIHN0cnVjdCB0aGF0IGV2ZW50LT5jdHgtPnRhc2sgY291bGQgcG9zc2libHkgcG9pbnQgdG8KKyAqIHJlbWFpbnMgdmFsaWQuICBUaGlzIGNvbmRpdGlvbiBpcyBzYXRpc2ZpZWQgd2hlbiBjYWxsZWQgdGhyb3VnaAorICogcGVyZl9ldmVudF9mb3JfZWFjaF9jaGlsZCBvciBwZXJmX2V2ZW50X2Zvcl9lYWNoIGFzIGRlc2NyaWJlZAorICogZm9yIHBlcmZfZXZlbnRfZGlzYWJsZS4KKyAqLworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9lbmFibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gY3R4LT50YXNrOworCisJaWYgKCF0YXNrKSB7CisJCS8qCisJCSAqIEVuYWJsZSB0aGUgZXZlbnQgb24gdGhlIGNwdSB0aGF0IGl0J3Mgb24KKwkJICovCisJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShldmVudC0+Y3B1LCBfX3BlcmZfZXZlbnRfZW5hYmxlLAorCQkJCQkgZXZlbnQsIDEpOworCQlyZXR1cm47CisJfQorCisJc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKKwlpZiAoZXZlbnQtPnN0YXRlID49IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpCisJCWdvdG8gb3V0OworCisJLyoKKwkgKiBJZiB0aGUgZXZlbnQgaXMgaW4gZXJyb3Igc3RhdGUsIGNsZWFyIHRoYXQgZmlyc3QuCisJICogVGhhdCB3YXksIGlmIHdlIHNlZSB0aGUgZXZlbnQgaW4gZXJyb3Igc3RhdGUgYmVsb3csIHdlCisJICoga25vdyB0aGF0IGl0IGhhcyBnb25lIGJhY2sgaW50byBlcnJvciBzdGF0ZSwgYXMgZGlzdGluY3QKKwkgKiBmcm9tIHRoZSB0YXNrIGhhdmluZyBiZWVuIHNjaGVkdWxlZCBhd2F5IGJlZm9yZSB0aGUKKwkgKiBjcm9zcy1jYWxsIGFycml2ZWQuCisJICovCisJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SKQorCQlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX09GRjsKKworIHJldHJ5OgorCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKKwl0YXNrX29uY3B1X2Z1bmN0aW9uX2NhbGwodGFzaywgX19wZXJmX2V2ZW50X2VuYWJsZSwgZXZlbnQpOworCisJc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKKworCS8qCisJICogSWYgdGhlIGNvbnRleHQgaXMgYWN0aXZlIGFuZCB0aGUgZXZlbnQgaXMgc3RpbGwgb2ZmLAorCSAqIHdlIG5lZWQgdG8gcmV0cnkgdGhlIGNyb3NzLWNhbGwuCisJICovCisJaWYgKGN0eC0+aXNfYWN0aXZlICYmIGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX09GRikKKwkJZ290byByZXRyeTsKKworCS8qCisJICogU2luY2Ugd2UgaGF2ZSB0aGUgbG9jayB0aGlzIGNvbnRleHQgY2FuJ3QgYmUgc2NoZWR1bGVkCisJICogaW4sIHNvIHdlIGNhbiBjaGFuZ2UgdGhlIHN0YXRlIHNhZmVseS4KKwkgKi8KKwlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfT0ZGKQorCQlfX3BlcmZfZXZlbnRfbWFya19lbmFibGVkKGV2ZW50LCBjdHgpOworCisgb3V0OgorCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKK30KKworc3RhdGljIGludCBwZXJmX2V2ZW50X3JlZnJlc2goc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgcmVmcmVzaCkKK3sKKwkvKgorCSAqIG5vdCBzdXBwb3J0ZWQgb24gaW5oZXJpdGVkIGV2ZW50cworCSAqLworCWlmIChldmVudC0+YXR0ci5pbmhlcml0KQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWF0b21pY19hZGQocmVmcmVzaCwgJmV2ZW50LT5ldmVudF9saW1pdCk7CisJcGVyZl9ldmVudF9lbmFibGUoZXZlbnQpOworCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgX19wZXJmX2V2ZW50X3NjaGVkX291dChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCQkgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKworCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKKwljdHgtPmlzX2FjdGl2ZSA9IDA7CisJaWYgKGxpa2VseSghY3R4LT5ucl9ldmVudHMpKQorCQlnb3RvIG91dDsKKwl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7CisKKwlwZXJmX2Rpc2FibGUoKTsKKwlpZiAoY3R4LT5ucl9hY3RpdmUpIHsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKKwkJCWlmIChldmVudCAhPSBldmVudC0+Z3JvdXBfbGVhZGVyKQorCQkJCWV2ZW50X3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOworCQkJZWxzZQorCQkJCWdyb3VwX3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOworCQl9CisJfQorCXBlcmZfZW5hYmxlKCk7Cisgb3V0OgorCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOworfQorCisvKgorICogVGVzdCB3aGV0aGVyIHR3byBjb250ZXh0cyBhcmUgZXF1aXZhbGVudCwgaS5lLiB3aGV0aGVyIHRoZXkKKyAqIGhhdmUgYm90aCBiZWVuIGNsb25lZCBmcm9tIHRoZSBzYW1lIHZlcnNpb24gb2YgdGhlIHNhbWUgY29udGV4dAorICogYW5kIHRoZXkgYm90aCBoYXZlIHRoZSBzYW1lIG51bWJlciBvZiBlbmFibGVkIGV2ZW50cy4KKyAqIElmIHRoZSBudW1iZXIgb2YgZW5hYmxlZCBldmVudHMgaXMgdGhlIHNhbWUsIHRoZW4gdGhlIHNldAorICogb2YgZW5hYmxlZCBldmVudHMgc2hvdWxkIGJlIHRoZSBzYW1lLCBiZWNhdXNlIHRoZXNlIGFyZSBib3RoCisgKiBpbmhlcml0ZWQgY29udGV4dHMsIHRoZXJlZm9yZSB3ZSBjYW4ndCBhY2Nlc3MgaW5kaXZpZHVhbCBldmVudHMKKyAqIGluIHRoZW0gZGlyZWN0bHkgd2l0aCBhbiBmZDsgd2UgY2FuIG9ubHkgZW5hYmxlL2Rpc2FibGUgYWxsCisgKiBldmVudHMgdmlhIHByY3RsLCBvciBlbmFibGUvZGlzYWJsZSBhbGwgZXZlbnRzIGluIGEgZmFtaWx5CisgKiB2aWEgaW9jdGwsIHdoaWNoIHdpbGwgaGF2ZSB0aGUgc2FtZSBlZmZlY3Qgb24gYm90aCBjb250ZXh0cy4KKyAqLworc3RhdGljIGludCBjb250ZXh0X2VxdWl2KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDEsCisJCQkgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4MikKK3sKKwlyZXR1cm4gY3R4MS0+cGFyZW50X2N0eCAmJiBjdHgxLT5wYXJlbnRfY3R4ID09IGN0eDItPnBhcmVudF9jdHgKKwkJJiYgY3R4MS0+cGFyZW50X2dlbiA9PSBjdHgyLT5wYXJlbnRfZ2VuCisJCSYmICFjdHgxLT5waW5fY291bnQgJiYgIWN0eDItPnBpbl9jb3VudDsKK30KKworc3RhdGljIHZvaWQgX19wZXJmX2V2ZW50X3JlYWQodm9pZCAqZXZlbnQpOworCitzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfc3luY19zdGF0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJCQkgICAgIHN0cnVjdCBwZXJmX2V2ZW50ICpuZXh0X2V2ZW50KQoreworCXU2NCB2YWx1ZTsKKworCWlmICghZXZlbnQtPmF0dHIuaW5oZXJpdF9zdGF0KQorCQlyZXR1cm47CisKKwkvKgorCSAqIFVwZGF0ZSB0aGUgZXZlbnQgdmFsdWUsIHdlIGNhbm5vdCB1c2UgcGVyZl9ldmVudF9yZWFkKCkKKwkgKiBiZWNhdXNlIHdlJ3JlIGluIHRoZSBtaWRkbGUgb2YgYSBjb250ZXh0IHN3aXRjaCBhbmQgaGF2ZSBJUlFzCisJICogZGlzYWJsZWQsIHdoaWNoIHVwc2V0cyBzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoKSwgaG93ZXZlcgorCSAqIHdlIGtub3cgdGhlIGV2ZW50IG11c3QgYmUgb24gdGhlIGN1cnJlbnQgQ1BVLCB0aGVyZWZvcmUgd2UKKwkgKiBkb24ndCBuZWVkIHRvIHVzZSBpdC4KKwkgKi8KKwlzd2l0Y2ggKGV2ZW50LT5zdGF0ZSkgeworCWNhc2UgUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkU6CisJCV9fcGVyZl9ldmVudF9yZWFkKGV2ZW50KTsKKwkJYnJlYWs7CisKKwljYXNlIFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkU6CisJCXVwZGF0ZV9ldmVudF90aW1lcyhldmVudCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJLyoKKwkgKiBJbiBvcmRlciB0byBrZWVwIHBlci10YXNrIHN0YXRzIHJlbGlhYmxlIHdlIG5lZWQgdG8gZmxpcCB0aGUgZXZlbnQKKwkgKiB2YWx1ZXMgd2hlbiB3ZSBmbGlwIHRoZSBjb250ZXh0cy4KKwkgKi8KKwl2YWx1ZSA9IGF0b21pYzY0X3JlYWQoJm5leHRfZXZlbnQtPmNvdW50KTsKKwl2YWx1ZSA9IGF0b21pYzY0X3hjaGcoJmV2ZW50LT5jb3VudCwgdmFsdWUpOworCWF0b21pYzY0X3NldCgmbmV4dF9ldmVudC0+Y291bnQsIHZhbHVlKTsKKworCXN3YXAoZXZlbnQtPnRvdGFsX3RpbWVfZW5hYmxlZCwgbmV4dF9ldmVudC0+dG90YWxfdGltZV9lbmFibGVkKTsKKwlzd2FwKGV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcsIG5leHRfZXZlbnQtPnRvdGFsX3RpbWVfcnVubmluZyk7CisKKwkvKgorCSAqIFNpbmNlIHdlIHN3aXp6bGVkIHRoZSB2YWx1ZXMsIHVwZGF0ZSB0aGUgdXNlciB2aXNpYmxlIGRhdGEgdG9vLgorCSAqLworCXBlcmZfZXZlbnRfdXBkYXRlX3VzZXJwYWdlKGV2ZW50KTsKKwlwZXJmX2V2ZW50X3VwZGF0ZV91c2VycGFnZShuZXh0X2V2ZW50KTsKK30KKworI2RlZmluZSBsaXN0X25leHRfZW50cnkocG9zLCBtZW1iZXIpIFwKKwlsaXN0X2VudHJ5KHBvcy0+bWVtYmVyLm5leHQsIHR5cGVvZigqcG9zKSwgbWVtYmVyKQorCitzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X3N5bmNfc3RhdChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCQkJICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqbmV4dF9jdHgpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqbmV4dF9ldmVudDsKKworCWlmICghY3R4LT5ucl9zdGF0KQorCQlyZXR1cm47CisKKwlldmVudCA9IGxpc3RfZmlyc3RfZW50cnkoJmN0eC0+ZXZlbnRfbGlzdCwKKwkJCQkgICBzdHJ1Y3QgcGVyZl9ldmVudCwgZXZlbnRfZW50cnkpOworCisJbmV4dF9ldmVudCA9IGxpc3RfZmlyc3RfZW50cnkoJm5leHRfY3R4LT5ldmVudF9saXN0LAorCQkJCQlzdHJ1Y3QgcGVyZl9ldmVudCwgZXZlbnRfZW50cnkpOworCisJd2hpbGUgKCZldmVudC0+ZXZlbnRfZW50cnkgIT0gJmN0eC0+ZXZlbnRfbGlzdCAmJgorCSAgICAgICAmbmV4dF9ldmVudC0+ZXZlbnRfZW50cnkgIT0gJm5leHRfY3R4LT5ldmVudF9saXN0KSB7CisKKwkJX19wZXJmX2V2ZW50X3N5bmNfc3RhdChldmVudCwgbmV4dF9ldmVudCk7CisKKwkJZXZlbnQgPSBsaXN0X25leHRfZW50cnkoZXZlbnQsIGV2ZW50X2VudHJ5KTsKKwkJbmV4dF9ldmVudCA9IGxpc3RfbmV4dF9lbnRyeShuZXh0X2V2ZW50LCBldmVudF9lbnRyeSk7CisJfQorfQorCisvKgorICogQ2FsbGVkIGZyb20gc2NoZWR1bGVyIHRvIHJlbW92ZSB0aGUgZXZlbnRzIG9mIHRoZSBjdXJyZW50IHRhc2ssCisgKiB3aXRoIGludGVycnVwdHMgZGlzYWJsZWQuCisgKgorICogV2Ugc3RvcCBlYWNoIGV2ZW50IGFuZCB1cGRhdGUgdGhlIGV2ZW50IHZhbHVlIGluIGV2ZW50LT5jb3VudC4KKyAqCisgKiBUaGlzIGRvZXMgbm90IHByb3RlY3QgdXMgYWdhaW5zdCBOTUksIGJ1dCBkaXNhYmxlKCkKKyAqIHNldHMgdGhlIGRpc2FibGVkIGJpdCBpbiB0aGUgY29udHJvbCBmaWVsZCBvZiBldmVudCBfYmVmb3JlXworICogYWNjZXNzaW5nIHRoZSBldmVudCBjb250cm9sIHJlZ2lzdGVyLiBJZiBhIE5NSSBoaXRzLCB0aGVuIGl0IHdpbGwKKyAqIG5vdCByZXN0YXJ0IHRoZSBldmVudC4KKyAqLwordm9pZCBwZXJmX2V2ZW50X3Rhc2tfc2NoZWRfb3V0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywKKwkJCQkgc3RydWN0IHRhc2tfc3RydWN0ICpuZXh0LCBpbnQgY3B1KQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IHRhc2stPnBlcmZfZXZlbnRfY3R4cDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpuZXh0X2N0eDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpwYXJlbnQ7CisJc3RydWN0IHB0X3JlZ3MgKnJlZ3M7CisJaW50IGRvX3N3aXRjaCA9IDE7CisKKwlyZWdzID0gdGFza19wdF9yZWdzKHRhc2spOworCXBlcmZfc3dfZXZlbnQoUEVSRl9DT1VOVF9TV19DT05URVhUX1NXSVRDSEVTLCAxLCAxLCByZWdzLCAwKTsKKworCWlmIChsaWtlbHkoIWN0eCB8fCAhY3B1Y3R4LT50YXNrX2N0eCkpCisJCXJldHVybjsKKworCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlwYXJlbnQgPSByY3VfZGVyZWZlcmVuY2UoY3R4LT5wYXJlbnRfY3R4KTsKKwluZXh0X2N0eCA9IG5leHQtPnBlcmZfZXZlbnRfY3R4cDsKKwlpZiAocGFyZW50ICYmIG5leHRfY3R4ICYmCisJICAgIHJjdV9kZXJlZmVyZW5jZShuZXh0X2N0eC0+cGFyZW50X2N0eCkgPT0gcGFyZW50KSB7CisJCS8qCisJCSAqIExvb2tzIGxpa2UgdGhlIHR3byBjb250ZXh0cyBhcmUgY2xvbmVzLCBzbyB3ZSBtaWdodCBiZQorCQkgKiBhYmxlIHRvIG9wdGltaXplIHRoZSBjb250ZXh0IHN3aXRjaC4gIFdlIGxvY2sgYm90aAorCQkgKiBjb250ZXh0cyBhbmQgY2hlY2sgdGhhdCB0aGV5IGFyZSBjbG9uZXMgdW5kZXIgdGhlCisJCSAqIGxvY2sgKGluY2x1ZGluZyByZS1jaGVja2luZyB0aGF0IG5laXRoZXIgaGFzIGJlZW4KKwkJICogdW5jbG9uZWQgaW4gdGhlIG1lYW50aW1lKS4gIEl0IGRvZXNuJ3QgbWF0dGVyIHdoaWNoCisJCSAqIG9yZGVyIHdlIHRha2UgdGhlIGxvY2tzIGJlY2F1c2Ugbm8gb3RoZXIgY3B1IGNvdWxkCisJCSAqIGJlIHRyeWluZyB0byBsb2NrIGJvdGggb2YgdGhlc2UgdGFza3MuCisJCSAqLworCQlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJCXNwaW5fbG9ja19uZXN0ZWQoJm5leHRfY3R4LT5sb2NrLCBTSU5HTEVfREVQVEhfTkVTVElORyk7CisJCWlmIChjb250ZXh0X2VxdWl2KGN0eCwgbmV4dF9jdHgpKSB7CisJCQkvKgorCQkJICogWFhYIGRvIHdlIG5lZWQgYSBtZW1vcnkgYmFycmllciBvZiBzb3J0cworCQkJICogd3J0IHRvIHJjdV9kZXJlZmVyZW5jZSgpIG9mIHBlcmZfZXZlbnRfY3R4cAorCQkJICovCisJCQl0YXNrLT5wZXJmX2V2ZW50X2N0eHAgPSBuZXh0X2N0eDsKKwkJCW5leHQtPnBlcmZfZXZlbnRfY3R4cCA9IGN0eDsKKwkJCWN0eC0+dGFzayA9IG5leHQ7CisJCQluZXh0X2N0eC0+dGFzayA9IHRhc2s7CisJCQlkb19zd2l0Y2ggPSAwOworCisJCQlwZXJmX2V2ZW50X3N5bmNfc3RhdChjdHgsIG5leHRfY3R4KTsKKwkJfQorCQlzcGluX3VubG9jaygmbmV4dF9jdHgtPmxvY2spOworCQlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKKwl9CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwlpZiAoZG9fc3dpdGNoKSB7CisJCV9fcGVyZl9ldmVudF9zY2hlZF9vdXQoY3R4LCBjcHVjdHgpOworCQljcHVjdHgtPnRhc2tfY3R4ID0gTlVMTDsKKwl9Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBJUlFzIGRpc2FibGVkCisgKi8KK3N0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF90YXNrX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCisJaWYgKCFjcHVjdHgtPnRhc2tfY3R4KQorCQlyZXR1cm47CisKKwlpZiAoV0FSTl9PTl9PTkNFKGN0eCAhPSBjcHVjdHgtPnRhc2tfY3R4KSkKKwkJcmV0dXJuOworCisJX19wZXJmX2V2ZW50X3NjaGVkX291dChjdHgsIGNwdWN0eCk7CisJY3B1Y3R4LT50YXNrX2N0eCA9IE5VTEw7Cit9CisKKy8qCisgKiBDYWxsZWQgd2l0aCBJUlFzIGRpc2FibGVkCisgKi8KK3N0YXRpYyB2b2lkIHBlcmZfZXZlbnRfY3B1X3NjaGVkX291dChzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQoreworCV9fcGVyZl9ldmVudF9zY2hlZF9vdXQoJmNwdWN0eC0+Y3R4LCBjcHVjdHgpOworfQorCitzdGF0aWMgdm9pZAorX19wZXJmX2V2ZW50X3NjaGVkX2luKHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKKwkJCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCWludCBjYW5fYWRkX2h3ID0gMTsKKworCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKKwljdHgtPmlzX2FjdGl2ZSA9IDE7CisJaWYgKGxpa2VseSghY3R4LT5ucl9ldmVudHMpKQorCQlnb3RvIG91dDsKKworCWN0eC0+dGltZXN0YW1wID0gcGVyZl9jbG9jaygpOworCisJcGVyZl9kaXNhYmxlKCk7CisKKwkvKgorCSAqIEZpcnN0IGdvIHRocm91Z2ggdGhlIGxpc3QgYW5kIHB1dCBvbiBhbnkgcGlubmVkIGdyb3VwcworCSAqIGluIG9yZGVyIHRvIGdpdmUgdGhlbSB0aGUgYmVzdCBjaGFuY2Ugb2YgZ29pbmcgb24uCisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKKwkJaWYgKGV2ZW50LT5zdGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX09GRiB8fAorCQkgICAgIWV2ZW50LT5hdHRyLnBpbm5lZCkKKwkJCWNvbnRpbnVlOworCQlpZiAoZXZlbnQtPmNwdSAhPSAtMSAmJiBldmVudC0+Y3B1ICE9IGNwdSkKKwkJCWNvbnRpbnVlOworCisJCWlmIChldmVudCAhPSBldmVudC0+Z3JvdXBfbGVhZGVyKQorCQkJZXZlbnRfc2NoZWRfaW4oZXZlbnQsIGNwdWN0eCwgY3R4LCBjcHUpOworCQllbHNlIHsKKwkJCWlmIChncm91cF9jYW5fZ29fb24oZXZlbnQsIGNwdWN0eCwgMSkpCisJCQkJZ3JvdXBfc2NoZWRfaW4oZXZlbnQsIGNwdWN0eCwgY3R4LCBjcHUpOworCQl9CisKKwkJLyoKKwkJICogSWYgdGhpcyBwaW5uZWQgZ3JvdXAgaGFzbid0IGJlZW4gc2NoZWR1bGVkLAorCQkgKiBwdXQgaXQgaW4gZXJyb3Igc3RhdGUuCisJCSAqLworCQlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpIHsKKwkJCXVwZGF0ZV9ncm91cF90aW1lcyhldmVudCk7CisJCQlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SOworCQl9CisJfQorCisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKKwkJLyoKKwkJICogSWdub3JlIGV2ZW50cyBpbiBPRkYgb3IgRVJST1Igc3RhdGUsIGFuZAorCQkgKiBpZ25vcmUgcGlubmVkIGV2ZW50cyBzaW5jZSB3ZSBkaWQgdGhlbSBhbHJlYWR5LgorCQkgKi8KKwkJaWYgKGV2ZW50LT5zdGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX09GRiB8fAorCQkgICAgZXZlbnQtPmF0dHIucGlubmVkKQorCQkJY29udGludWU7CisKKwkJLyoKKwkJICogTGlzdGVuIHRvIHRoZSAnY3B1JyBzY2hlZHVsaW5nIGZpbHRlciBjb25zdHJhaW50CisJCSAqIG9mIGV2ZW50czoKKwkJICovCisJCWlmIChldmVudC0+Y3B1ICE9IC0xICYmIGV2ZW50LT5jcHUgIT0gY3B1KQorCQkJY29udGludWU7CisKKwkJaWYgKGV2ZW50ICE9IGV2ZW50LT5ncm91cF9sZWFkZXIpIHsKKwkJCWlmIChldmVudF9zY2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgsIGNwdSkpCisJCQkJY2FuX2FkZF9odyA9IDA7CisJCX0gZWxzZSB7CisJCQlpZiAoZ3JvdXBfY2FuX2dvX29uKGV2ZW50LCBjcHVjdHgsIGNhbl9hZGRfaHcpKSB7CisJCQkJaWYgKGdyb3VwX3NjaGVkX2luKGV2ZW50LCBjcHVjdHgsIGN0eCwgY3B1KSkKKwkJCQkJY2FuX2FkZF9odyA9IDA7CisJCQl9CisJCX0KKwl9CisJcGVyZl9lbmFibGUoKTsKKyBvdXQ6CisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKKy8qCisgKiBDYWxsZWQgZnJvbSBzY2hlZHVsZXIgdG8gYWRkIHRoZSBldmVudHMgb2YgdGhlIGN1cnJlbnQgdGFzaworICogd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkLgorICoKKyAqIFdlIHJlc3RvcmUgdGhlIGV2ZW50IHZhbHVlIGFuZCB0aGVuIGVuYWJsZSBpdC4KKyAqCisgKiBUaGlzIGRvZXMgbm90IHByb3RlY3QgdXMgYWdhaW5zdCBOTUksIGJ1dCBlbmFibGUoKQorICogc2V0cyB0aGUgZW5hYmxlZCBiaXQgaW4gdGhlIGNvbnRyb2wgZmllbGQgb2YgZXZlbnQgX2JlZm9yZV8KKyAqIGFjY2Vzc2luZyB0aGUgZXZlbnQgY29udHJvbCByZWdpc3Rlci4gSWYgYSBOTUkgaGl0cywgdGhlbiBpdCB3aWxsCisgKiBrZWVwIHRoZSBldmVudCBydW5uaW5nLgorICovCit2b2lkIHBlcmZfZXZlbnRfdGFza19zY2hlZF9pbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssIGludCBjcHUpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZwZXJfY3B1KHBlcmZfY3B1X2NvbnRleHQsIGNwdSk7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gdGFzay0+cGVyZl9ldmVudF9jdHhwOworCisJaWYgKGxpa2VseSghY3R4KSkKKwkJcmV0dXJuOworCWlmIChjcHVjdHgtPnRhc2tfY3R4ID09IGN0eCkKKwkJcmV0dXJuOworCV9fcGVyZl9ldmVudF9zY2hlZF9pbihjdHgsIGNwdWN0eCwgY3B1KTsKKwljcHVjdHgtPnRhc2tfY3R4ID0gY3R4OworfQorCitzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2NwdV9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LCBpbnQgY3B1KQoreworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9ICZjcHVjdHgtPmN0eDsKKworCV9fcGVyZl9ldmVudF9zY2hlZF9pbihjdHgsIGNwdWN0eCwgY3B1KTsKK30KKworI2RlZmluZSBNQVhfSU5URVJSVVBUUyAofjBVTEwpCisKK3N0YXRpYyB2b2lkIHBlcmZfbG9nX3Rocm90dGxlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IGVuYWJsZSk7CisKK3N0YXRpYyB2b2lkIHBlcmZfYWRqdXN0X3BlcmlvZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHU2NCBldmVudHMpCit7CisJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CisJdTY0IHBlcmlvZCwgc2FtcGxlX3BlcmlvZDsKKwlzNjQgZGVsdGE7CisKKwlldmVudHMgKj0gaHdjLT5zYW1wbGVfcGVyaW9kOworCXBlcmlvZCA9IGRpdjY0X3U2NChldmVudHMsIGV2ZW50LT5hdHRyLnNhbXBsZV9mcmVxKTsKKworCWRlbHRhID0gKHM2NCkocGVyaW9kIC0gaHdjLT5zYW1wbGVfcGVyaW9kKTsKKwlkZWx0YSA9IChkZWx0YSArIDcpIC8gODsgLyogbG93IHBhc3MgZmlsdGVyICovCisKKwlzYW1wbGVfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kICsgZGVsdGE7CisKKwlpZiAoIXNhbXBsZV9wZXJpb2QpCisJCXNhbXBsZV9wZXJpb2QgPSAxOworCisJaHdjLT5zYW1wbGVfcGVyaW9kID0gc2FtcGxlX3BlcmlvZDsKK30KKworc3RhdGljIHZvaWQgcGVyZl9jdHhfYWRqdXN0X2ZyZXEoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKwlzdHJ1Y3QgaHdfcGVyZl9ldmVudCAqaHdjOworCXU2NCBpbnRlcnJ1cHRzLCBmcmVxOworCisJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZjdHgtPmdyb3VwX2xpc3QsIGdyb3VwX2VudHJ5KSB7CisJCWlmIChldmVudC0+c3RhdGUgIT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpCisJCQljb250aW51ZTsKKworCQlod2MgPSAmZXZlbnQtPmh3OworCisJCWludGVycnVwdHMgPSBod2MtPmludGVycnVwdHM7CisJCWh3Yy0+aW50ZXJydXB0cyA9IDA7CisKKwkJLyoKKwkJICogdW50aHJvdHRsZSBldmVudHMgb24gdGhlIHRpY2sKKwkJICovCisJCWlmIChpbnRlcnJ1cHRzID09IE1BWF9JTlRFUlJVUFRTKSB7CisJCQlwZXJmX2xvZ190aHJvdHRsZShldmVudCwgMSk7CisJCQlldmVudC0+cG11LT51bnRocm90dGxlKGV2ZW50KTsKKwkJCWludGVycnVwdHMgPSAyKnN5c2N0bF9wZXJmX2V2ZW50X3NhbXBsZV9yYXRlL0haOworCQl9CisKKwkJaWYgKCFldmVudC0+YXR0ci5mcmVxIHx8ICFldmVudC0+YXR0ci5zYW1wbGVfZnJlcSkKKwkJCWNvbnRpbnVlOworCisJCS8qCisJCSAqIGlmIHRoZSBzcGVjaWZpZWQgZnJlcSA8IEhaIHRoZW4gd2UgbmVlZCB0byBza2lwIHRpY2tzCisJCSAqLworCQlpZiAoZXZlbnQtPmF0dHIuc2FtcGxlX2ZyZXEgPCBIWikgeworCQkJZnJlcSA9IGV2ZW50LT5hdHRyLnNhbXBsZV9mcmVxOworCisJCQlod2MtPmZyZXFfY291bnQgKz0gZnJlcTsKKwkJCWh3Yy0+ZnJlcV9pbnRlcnJ1cHRzICs9IGludGVycnVwdHM7CisKKwkJCWlmIChod2MtPmZyZXFfY291bnQgPCBIWikKKwkJCQljb250aW51ZTsKKworCQkJaW50ZXJydXB0cyA9IGh3Yy0+ZnJlcV9pbnRlcnJ1cHRzOworCQkJaHdjLT5mcmVxX2ludGVycnVwdHMgPSAwOworCQkJaHdjLT5mcmVxX2NvdW50IC09IEhaOworCQl9IGVsc2UKKwkJCWZyZXEgPSBIWjsKKworCQlwZXJmX2FkanVzdF9wZXJpb2QoZXZlbnQsIGZyZXEgKiBpbnRlcnJ1cHRzKTsKKworCQkvKgorCQkgKiBJbiBvcmRlciB0byBhdm9pZCBiZWluZyBzdGFsbGVkIGJ5IGFuIChhY2NpZGVudGFsKSBodWdlCisJCSAqIHNhbXBsZSBwZXJpb2QsIGZvcmNlIHJlc2V0IHRoZSBzYW1wbGUgcGVyaW9kIGlmIHdlIGRpZG4ndAorCQkgKiBnZXQgYW55IGV2ZW50cyBpbiB0aGlzIGZyZXEgcGVyaW9kLgorCQkgKi8KKwkJaWYgKCFpbnRlcnJ1cHRzKSB7CisJCQlwZXJmX2Rpc2FibGUoKTsKKwkJCWV2ZW50LT5wbXUtPmRpc2FibGUoZXZlbnQpOworCQkJYXRvbWljNjRfc2V0KCZod2MtPnBlcmlvZF9sZWZ0LCAwKTsKKwkJCWV2ZW50LT5wbXUtPmVuYWJsZShldmVudCk7CisJCQlwZXJmX2VuYWJsZSgpOworCQl9CisJfQorCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOworfQorCisvKgorICogUm91bmQtcm9iaW4gYSBjb250ZXh0J3MgZXZlbnRzOgorICovCitzdGF0aWMgdm9pZCByb3RhdGVfY3R4KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CisKKwlpZiAoIWN0eC0+bnJfZXZlbnRzKQorCQlyZXR1cm47CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisJLyoKKwkgKiBSb3RhdGUgdGhlIGZpcnN0IGVudHJ5IGxhc3QgKHdvcmtzIGp1c3QgZmluZSBmb3IgZ3JvdXAgZXZlbnRzIHRvbyk6CisJICovCisJcGVyZl9kaXNhYmxlKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKKwkJbGlzdF9tb3ZlX3RhaWwoJmV2ZW50LT5ncm91cF9lbnRyeSwgJmN0eC0+Z3JvdXBfbGlzdCk7CisJCWJyZWFrOworCX0KKwlwZXJmX2VuYWJsZSgpOworCisJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cit9CisKK3ZvaWQgcGVyZl9ldmVudF90YXNrX3RpY2soc3RydWN0IHRhc2tfc3RydWN0ICpjdXJyLCBpbnQgY3B1KQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4OworCisJaWYgKCFhdG9taWNfcmVhZCgmbnJfZXZlbnRzKSkKKwkJcmV0dXJuOworCisJY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwljdHggPSBjdXJyLT5wZXJmX2V2ZW50X2N0eHA7CisKKwlwZXJmX2N0eF9hZGp1c3RfZnJlcSgmY3B1Y3R4LT5jdHgpOworCWlmIChjdHgpCisJCXBlcmZfY3R4X2FkanVzdF9mcmVxKGN0eCk7CisKKwlwZXJmX2V2ZW50X2NwdV9zY2hlZF9vdXQoY3B1Y3R4KTsKKwlpZiAoY3R4KQorCQlfX3BlcmZfZXZlbnRfdGFza19zY2hlZF9vdXQoY3R4KTsKKworCXJvdGF0ZV9jdHgoJmNwdWN0eC0+Y3R4KTsKKwlpZiAoY3R4KQorCQlyb3RhdGVfY3R4KGN0eCk7CisKKwlwZXJmX2V2ZW50X2NwdV9zY2hlZF9pbihjcHVjdHgsIGNwdSk7CisJaWYgKGN0eCkKKwkJcGVyZl9ldmVudF90YXNrX3NjaGVkX2luKGN1cnIsIGNwdSk7Cit9CisKKy8qCisgKiBFbmFibGUgYWxsIG9mIGEgdGFzaydzIGV2ZW50cyB0aGF0IGhhdmUgYmVlbiBtYXJrZWQgZW5hYmxlLW9uLWV4ZWMuCisgKiBUaGlzIGV4cGVjdHMgdGFzayA9PSBjdXJyZW50LgorICovCitzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2VuYWJsZV9vbl9leGVjKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IGVuYWJsZWQgPSAwOworCisJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCWN0eCA9IHRhc2stPnBlcmZfZXZlbnRfY3R4cDsKKwlpZiAoIWN0eCB8fCAhY3R4LT5ucl9ldmVudHMpCisJCWdvdG8gb3V0OworCisJX19wZXJmX2V2ZW50X3Rhc2tfc2NoZWRfb3V0KGN0eCk7CisKKwlzcGluX2xvY2soJmN0eC0+bG9jayk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgeworCQlpZiAoIWV2ZW50LT5hdHRyLmVuYWJsZV9vbl9leGVjKQorCQkJY29udGludWU7CisJCWV2ZW50LT5hdHRyLmVuYWJsZV9vbl9leGVjID0gMDsKKwkJaWYgKGV2ZW50LT5zdGF0ZSA+PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFKQorCQkJY29udGludWU7CisJCV9fcGVyZl9ldmVudF9tYXJrX2VuYWJsZWQoZXZlbnQsIGN0eCk7CisJCWVuYWJsZWQgPSAxOworCX0KKworCS8qCisJICogVW5jbG9uZSB0aGlzIGNvbnRleHQgaWYgd2UgZW5hYmxlZCBhbnkgZXZlbnQuCisJICovCisJaWYgKGVuYWJsZWQpCisJCXVuY2xvbmVfY3R4KGN0eCk7CisKKwlzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKKworCXBlcmZfZXZlbnRfdGFza19zY2hlZF9pbih0YXNrLCBzbXBfcHJvY2Vzc29yX2lkKCkpOworIG91dDoKKwlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Cit9CisKKy8qCisgKiBDcm9zcyBDUFUgY2FsbCB0byByZWFkIHRoZSBoYXJkd2FyZSBldmVudAorICovCitzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfcmVhZCh2b2lkICppbmZvKQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBpbmZvOworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCS8qCisJICogSWYgdGhpcyBpcyBhIHRhc2sgY29udGV4dCwgd2UgbmVlZCB0byBjaGVjayB3aGV0aGVyIGl0IGlzCisJICogdGhlIGN1cnJlbnQgdGFzayBjb250ZXh0IG9mIHRoaXMgY3B1LiAgSWYgbm90IGl0IGhhcyBiZWVuCisJICogc2NoZWR1bGVkIG91dCBiZWZvcmUgdGhlIHNtcCBjYWxsIGFycml2ZWQuICBJbiB0aGF0IGNhc2UKKwkgKiBldmVudC0+Y291bnQgd291bGQgaGF2ZSBiZWVuIHVwZGF0ZWQgdG8gYSByZWNlbnQgc2FtcGxlCisJICogd2hlbiB0aGUgZXZlbnQgd2FzIHNjaGVkdWxlZCBvdXQuCisJICovCisJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkKKwkJcmV0dXJuOworCisJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOworCWlmIChjdHgtPmlzX2FjdGl2ZSkKKwkJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOworCWV2ZW50LT5wbXUtPnJlYWQoZXZlbnQpOworCXVwZGF0ZV9ldmVudF90aW1lcyhldmVudCk7CisJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOworfQorCitzdGF0aWMgdTY0IHBlcmZfZXZlbnRfcmVhZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJLyoKKwkgKiBJZiBldmVudCBpcyBlbmFibGVkIGFuZCBjdXJyZW50bHkgYWN0aXZlIG9uIGEgQ1BVLCB1cGRhdGUgdGhlCisJICogdmFsdWUgaW4gdGhlIGV2ZW50IHN0cnVjdHVyZToKKwkgKi8KKwlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKSB7CisJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShldmVudC0+b25jcHUsCisJCQkJCSBfX3BlcmZfZXZlbnRfcmVhZCwgZXZlbnQsIDEpOworCX0gZWxzZSBpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpIHsKKwkJdXBkYXRlX2V2ZW50X3RpbWVzKGV2ZW50KTsKKwl9CisKKwlyZXR1cm4gYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNvdW50KTsKK30KKworLyoKKyAqIEluaXRpYWxpemUgdGhlIHBlcmZfZXZlbnQgY29udGV4dCBpbiBhIHRhc2tfc3RydWN0OgorICovCitzdGF0aWMgdm9pZAorX19wZXJmX2V2ZW50X2luaXRfY29udGV4dChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCQkgICAgc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQoreworCW1lbXNldChjdHgsIDAsIHNpemVvZigqY3R4KSk7CisJc3Bpbl9sb2NrX2luaXQoJmN0eC0+bG9jayk7CisJbXV0ZXhfaW5pdCgmY3R4LT5tdXRleCk7CisJSU5JVF9MSVNUX0hFQUQoJmN0eC0+Z3JvdXBfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmN0eC0+ZXZlbnRfbGlzdCk7CisJYXRvbWljX3NldCgmY3R4LT5yZWZjb3VudCwgMSk7CisJY3R4LT50YXNrID0gdGFzazsKK30KKworc3RhdGljIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmZpbmRfZ2V0X2NvbnRleHQocGlkX3QgcGlkLCBpbnQgY3B1KQoreworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OworCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzazsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBlcnI7CisKKwkvKgorCSAqIElmIGNwdSBpcyBub3QgYSB3aWxkY2FyZCB0aGVuIHRoaXMgaXMgYSBwZXJjcHUgZXZlbnQ6CisJICovCisJaWYgKGNwdSAhPSAtMSkgeworCQkvKiBNdXN0IGJlIHJvb3QgdG8gb3BlcmF0ZSBvbiBhIENQVSBldmVudDogKi8KKwkJaWYgKHBlcmZfcGFyYW5vaWRfY3B1KCkgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCisJCQlyZXR1cm4gRVJSX1BUUigtRUFDQ0VTKTsKKworCQlpZiAoY3B1IDwgMCB8fCBjcHUgPiBudW1fcG9zc2libGVfY3B1cygpKQorCQkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisKKwkJLyoKKwkJICogV2UgY291bGQgYmUgY2xldmVyIGFuZCBhbGxvdyB0byBhdHRhY2ggYSBldmVudCB0byBhbgorCQkgKiBvZmZsaW5lIENQVSBhbmQgYWN0aXZhdGUgaXQgd2hlbiB0aGUgQ1BVIGNvbWVzIHVwLCBidXQKKwkJICogdGhhdCdzIGZvciBsYXRlci4KKwkJICovCisJCWlmICghY3B1X2lzc2V0KGNwdSwgY3B1X29ubGluZV9tYXApKQorCQkJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7CisKKwkJY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwkJY3R4ID0gJmNwdWN0eC0+Y3R4OworCQlnZXRfY3R4KGN0eCk7CisKKwkJcmV0dXJuIGN0eDsKKwl9CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJaWYgKCFwaWQpCisJCXRhc2sgPSBjdXJyZW50OworCWVsc2UKKwkJdGFzayA9IGZpbmRfdGFza19ieV92cGlkKHBpZCk7CisJaWYgKHRhc2spCisJCWdldF90YXNrX3N0cnVjdCh0YXNrKTsKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCWlmICghdGFzaykKKwkJcmV0dXJuIEVSUl9QVFIoLUVTUkNIKTsKKworCS8qCisJICogQ2FuJ3QgYXR0YWNoIGV2ZW50cyB0byBhIGR5aW5nIHRhc2suCisJICovCisJZXJyID0gLUVTUkNIOworCWlmICh0YXNrLT5mbGFncyAmIFBGX0VYSVRJTkcpCisJCWdvdG8gZXJyb3V0OworCisJLyogUmV1c2UgcHRyYWNlIHBlcm1pc3Npb24gY2hlY2tzIGZvciBub3cuICovCisJZXJyID0gLUVBQ0NFUzsKKwlpZiAoIXB0cmFjZV9tYXlfYWNjZXNzKHRhc2ssIFBUUkFDRV9NT0RFX1JFQUQpKQorCQlnb3RvIGVycm91dDsKKworIHJldHJ5OgorCWN0eCA9IHBlcmZfbG9ja190YXNrX2NvbnRleHQodGFzaywgJmZsYWdzKTsKKwlpZiAoY3R4KSB7CisJCXVuY2xvbmVfY3R4KGN0eCk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0eC0+bG9jaywgZmxhZ3MpOworCX0KKworCWlmICghY3R4KSB7CisJCWN0eCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQpLCBHRlBfS0VSTkVMKTsKKwkJZXJyID0gLUVOT01FTTsKKwkJaWYgKCFjdHgpCisJCQlnb3RvIGVycm91dDsKKwkJX19wZXJmX2V2ZW50X2luaXRfY29udGV4dChjdHgsIHRhc2spOworCQlnZXRfY3R4KGN0eCk7CisJCWlmIChjbXB4Y2hnKCZ0YXNrLT5wZXJmX2V2ZW50X2N0eHAsIE5VTEwsIGN0eCkpIHsKKwkJCS8qCisJCQkgKiBXZSByYWNlZCB3aXRoIHNvbWUgb3RoZXIgdGFzazsgdXNlCisJCQkgKiB0aGUgY29udGV4dCB0aGV5IHNldC4KKwkJCSAqLworCQkJa2ZyZWUoY3R4KTsKKwkJCWdvdG8gcmV0cnk7CisJCX0KKwkJZ2V0X3Rhc2tfc3RydWN0KHRhc2spOworCX0KKworCXB1dF90YXNrX3N0cnVjdCh0YXNrKTsKKwlyZXR1cm4gY3R4OworCisgZXJyb3V0OgorCXB1dF90YXNrX3N0cnVjdCh0YXNrKTsKKwlyZXR1cm4gRVJSX1BUUihlcnIpOworfQorCitzdGF0aWMgdm9pZCBmcmVlX2V2ZW50X3JjdShzdHJ1Y3QgcmN1X2hlYWQgKmhlYWQpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCisJZXZlbnQgPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IHBlcmZfZXZlbnQsIHJjdV9oZWFkKTsKKwlpZiAoZXZlbnQtPm5zKQorCQlwdXRfcGlkX25zKGV2ZW50LT5ucyk7CisJa2ZyZWUoZXZlbnQpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfc3luYyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpOworCitzdGF0aWMgdm9pZCBmcmVlX2V2ZW50KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlwZXJmX3BlbmRpbmdfc3luYyhldmVudCk7CisKKwlpZiAoIWV2ZW50LT5wYXJlbnQpIHsKKwkJYXRvbWljX2RlYygmbnJfZXZlbnRzKTsKKwkJaWYgKGV2ZW50LT5hdHRyLm1tYXApCisJCQlhdG9taWNfZGVjKCZucl9tbWFwX2V2ZW50cyk7CisJCWlmIChldmVudC0+YXR0ci5jb21tKQorCQkJYXRvbWljX2RlYygmbnJfY29tbV9ldmVudHMpOworCQlpZiAoZXZlbnQtPmF0dHIudGFzaykKKwkJCWF0b21pY19kZWMoJm5yX3Rhc2tfZXZlbnRzKTsKKwl9CisKKwlpZiAoZXZlbnQtPm91dHB1dCkgeworCQlmcHV0KGV2ZW50LT5vdXRwdXQtPmZpbHApOworCQlldmVudC0+b3V0cHV0ID0gTlVMTDsKKwl9CisKKwlpZiAoZXZlbnQtPmRlc3Ryb3kpCisJCWV2ZW50LT5kZXN0cm95KGV2ZW50KTsKKworCXB1dF9jdHgoZXZlbnQtPmN0eCk7CisJY2FsbF9yY3UoJmV2ZW50LT5yY3VfaGVhZCwgZnJlZV9ldmVudF9yY3UpOworfQorCisvKgorICogQ2FsbGVkIHdoZW4gdGhlIGxhc3QgcmVmZXJlbmNlIHRvIHRoZSBmaWxlIGlzIGdvbmUuCisgKi8KK3N0YXRpYyBpbnQgcGVyZl9yZWxlYXNlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OworCisJZmlsZS0+cHJpdmF0ZV9kYXRhID0gTlVMTDsKKworCVdBUk5fT05fT05DRShjdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOworCXBlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dChldmVudCk7CisJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKKworCW11dGV4X2xvY2soJmV2ZW50LT5vd25lci0+cGVyZl9ldmVudF9tdXRleCk7CisJbGlzdF9kZWxfaW5pdCgmZXZlbnQtPm93bmVyX2VudHJ5KTsKKwltdXRleF91bmxvY2soJmV2ZW50LT5vd25lci0+cGVyZl9ldmVudF9tdXRleCk7CisJcHV0X3Rhc2tfc3RydWN0KGV2ZW50LT5vd25lcik7CisKKwlmcmVlX2V2ZW50KGV2ZW50KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBlcmZfZXZlbnRfcmVhZF9zaXplKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlpbnQgZW50cnkgPSBzaXplb2YodTY0KTsgLyogdmFsdWUgKi8KKwlpbnQgc2l6ZSA9IDA7CisJaW50IG5yID0gMTsKKworCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCkKKwkJc2l6ZSArPSBzaXplb2YodTY0KTsKKworCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfUlVOTklORykKKwkJc2l6ZSArPSBzaXplb2YodTY0KTsKKworCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQorCQllbnRyeSArPSBzaXplb2YodTY0KTsKKworCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0dST1VQKSB7CisJCW5yICs9IGV2ZW50LT5ncm91cF9sZWFkZXItPm5yX3NpYmxpbmdzOworCQlzaXplICs9IHNpemVvZih1NjQpOworCX0KKworCXNpemUgKz0gZW50cnkgKiBucjsKKworCXJldHVybiBzaXplOworfQorCitzdGF0aWMgdTY0IHBlcmZfZXZlbnRfcmVhZF92YWx1ZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmNoaWxkOworCXU2NCB0b3RhbCA9IDA7CisKKwl0b3RhbCArPSBwZXJmX2V2ZW50X3JlYWQoZXZlbnQpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoY2hpbGQsICZldmVudC0+Y2hpbGRfbGlzdCwgY2hpbGRfbGlzdCkKKwkJdG90YWwgKz0gcGVyZl9ldmVudF9yZWFkKGNoaWxkKTsKKworCXJldHVybiB0b3RhbDsKK30KKworc3RhdGljIGludCBwZXJmX2V2ZW50X3JlYWRfZW50cnkoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAorCQkJCSAgIHU2NCByZWFkX2Zvcm1hdCwgY2hhciBfX3VzZXIgKmJ1ZikKK3sKKwlpbnQgbiA9IDAsIGNvdW50ID0gMDsKKwl1NjQgdmFsdWVzWzJdOworCisJdmFsdWVzW24rK10gPSBwZXJmX2V2ZW50X3JlYWRfdmFsdWUoZXZlbnQpOworCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQorCQl2YWx1ZXNbbisrXSA9IHByaW1hcnlfZXZlbnRfaWQoZXZlbnQpOworCisJY291bnQgPSBuICogc2l6ZW9mKHU2NCk7CisKKwlpZiAoY29weV90b191c2VyKGJ1ZiwgdmFsdWVzLCBjb3VudCkpCisJCXJldHVybiAtRUZBVUxUOworCisJcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgaW50IHBlcmZfZXZlbnRfcmVhZF9ncm91cChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkJICAgdTY0IHJlYWRfZm9ybWF0LCBjaGFyIF9fdXNlciAqYnVmKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpsZWFkZXIgPSBldmVudC0+Z3JvdXBfbGVhZGVyLCAqc3ViOworCWludCBuID0gMCwgc2l6ZSA9IDAsIGVyciA9IC1FRkFVTFQ7CisJdTY0IHZhbHVlc1szXTsKKworCXZhbHVlc1tuKytdID0gMSArIGxlYWRlci0+bnJfc2libGluZ3M7CisJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVEKSB7CisJCXZhbHVlc1tuKytdID0gbGVhZGVyLT50b3RhbF90aW1lX2VuYWJsZWQgKworCQkJYXRvbWljNjRfcmVhZCgmbGVhZGVyLT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOworCX0KKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkcpIHsKKwkJdmFsdWVzW24rK10gPSBsZWFkZXItPnRvdGFsX3RpbWVfcnVubmluZyArCisJCQlhdG9taWM2NF9yZWFkKCZsZWFkZXItPmNoaWxkX3RvdGFsX3RpbWVfcnVubmluZyk7CisJfQorCisJc2l6ZSA9IG4gKiBzaXplb2YodTY0KTsKKworCWlmIChjb3B5X3RvX3VzZXIoYnVmLCB2YWx1ZXMsIHNpemUpKQorCQlyZXR1cm4gLUVGQVVMVDsKKworCWVyciA9IHBlcmZfZXZlbnRfcmVhZF9lbnRyeShsZWFkZXIsIHJlYWRfZm9ybWF0LCBidWYgKyBzaXplKTsKKwlpZiAoZXJyIDwgMCkKKwkJcmV0dXJuIGVycjsKKworCXNpemUgKz0gZXJyOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpIHsKKwkJZXJyID0gcGVyZl9ldmVudF9yZWFkX2VudHJ5KHN1YiwgcmVhZF9mb3JtYXQsCisJCQkJYnVmICsgc2l6ZSk7CisJCWlmIChlcnIgPCAwKQorCQkJcmV0dXJuIGVycjsKKworCQlzaXplICs9IGVycjsKKwl9CisKKwlyZXR1cm4gc2l6ZTsKK30KKworc3RhdGljIGludCBwZXJmX2V2ZW50X3JlYWRfb25lKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJCQkgdTY0IHJlYWRfZm9ybWF0LCBjaGFyIF9fdXNlciAqYnVmKQoreworCXU2NCB2YWx1ZXNbNF07CisJaW50IG4gPSAwOworCisJdmFsdWVzW24rK10gPSBwZXJmX2V2ZW50X3JlYWRfdmFsdWUoZXZlbnQpOworCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCkgeworCQl2YWx1ZXNbbisrXSA9IGV2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQgKworCQkJYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNoaWxkX3RvdGFsX3RpbWVfZW5hYmxlZCk7CisJfQorCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfUlVOTklORykgeworCQl2YWx1ZXNbbisrXSA9IGV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcgKworCQkJYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNoaWxkX3RvdGFsX3RpbWVfcnVubmluZyk7CisJfQorCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQorCQl2YWx1ZXNbbisrXSA9IHByaW1hcnlfZXZlbnRfaWQoZXZlbnQpOworCisJaWYgKGNvcHlfdG9fdXNlcihidWYsIHZhbHVlcywgbiAqIHNpemVvZih1NjQpKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlyZXR1cm4gbiAqIHNpemVvZih1NjQpOworfQorCisvKgorICogUmVhZCB0aGUgcGVyZm9ybWFuY2UgZXZlbnQgLSBzaW1wbGUgbm9uIGJsb2NraW5nIHZlcnNpb24gZm9yIG5vdworICovCitzdGF0aWMgc3NpemVfdAorcGVyZl9yZWFkX2h3KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgY2hhciBfX3VzZXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXU2NCByZWFkX2Zvcm1hdCA9IGV2ZW50LT5hdHRyLnJlYWRfZm9ybWF0OworCWludCByZXQ7CisKKwkvKgorCSAqIFJldHVybiBlbmQtb2YtZmlsZSBmb3IgYSByZWFkIG9uIGEgZXZlbnQgdGhhdCBpcyBpbgorCSAqIGVycm9yIHN0YXRlIChpLmUuIGJlY2F1c2UgaXQgd2FzIHBpbm5lZCBidXQgaXQgY291bGRuJ3QgYmUKKwkgKiBzY2hlZHVsZWQgb24gdG8gdGhlIENQVSBhdCBzb21lIHBvaW50KS4KKwkgKi8KKwlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfRVJST1IpCisJCXJldHVybiAwOworCisJaWYgKGNvdW50IDwgcGVyZl9ldmVudF9yZWFkX3NpemUoZXZlbnQpKQorCQlyZXR1cm4gLUVOT1NQQzsKKworCVdBUk5fT05fT05DRShldmVudC0+Y3R4LT5wYXJlbnRfY3R4KTsKKwltdXRleF9sb2NrKCZldmVudC0+Y2hpbGRfbXV0ZXgpOworCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0dST1VQKQorCQlyZXQgPSBwZXJmX2V2ZW50X3JlYWRfZ3JvdXAoZXZlbnQsIHJlYWRfZm9ybWF0LCBidWYpOworCWVsc2UKKwkJcmV0ID0gcGVyZl9ldmVudF9yZWFkX29uZShldmVudCwgcmVhZF9mb3JtYXQsIGJ1Zik7CisJbXV0ZXhfdW5sb2NrKCZldmVudC0+Y2hpbGRfbXV0ZXgpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHNzaXplX3QKK3BlcmZfcmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1Ziwgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKnBwb3MpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCisJcmV0dXJuIHBlcmZfcmVhZF9odyhldmVudCwgYnVmLCBjb3VudCk7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBpbnQgcGVyZl9wb2xsKHN0cnVjdCBmaWxlICpmaWxlLCBwb2xsX3RhYmxlICp3YWl0KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CisJdW5zaWduZWQgaW50IGV2ZW50cyA9IFBPTExfSFVQOworCisJcmN1X3JlYWRfbG9jaygpOworCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoZXZlbnQtPmRhdGEpOworCWlmIChkYXRhKQorCQlldmVudHMgPSBhdG9taWNfeGNoZygmZGF0YS0+cG9sbCwgMCk7CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwlwb2xsX3dhaXQoZmlsZSwgJmV2ZW50LT53YWl0cSwgd2FpdCk7CisKKwlyZXR1cm4gZXZlbnRzOworfQorCitzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X3Jlc2V0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwkodm9pZClwZXJmX2V2ZW50X3JlYWQoZXZlbnQpOworCWF0b21pYzY0X3NldCgmZXZlbnQtPmNvdW50LCAwKTsKKwlwZXJmX2V2ZW50X3VwZGF0ZV91c2VycGFnZShldmVudCk7Cit9CisKKy8qCisgKiBIb2xkaW5nIHRoZSB0b3AtbGV2ZWwgZXZlbnQncyBjaGlsZF9tdXRleCBtZWFucyB0aGF0IGFueQorICogZGVzY2VuZGFudCBwcm9jZXNzIHRoYXQgaGFzIGluaGVyaXRlZCB0aGlzIGV2ZW50IHdpbGwgYmxvY2sKKyAqIGluIHN5bmNfY2hpbGRfZXZlbnQgaWYgaXQgZ29lcyB0byBleGl0LCB0aHVzIHNhdGlzZnlpbmcgdGhlCisgKiB0YXNrIGV4aXN0ZW5jZSByZXF1aXJlbWVudHMgb2YgcGVyZl9ldmVudF9lbmFibGUvZGlzYWJsZS4KKyAqLworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9mb3JfZWFjaF9jaGlsZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkJCXZvaWQgKCpmdW5jKShzdHJ1Y3QgcGVyZl9ldmVudCAqKSkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGQ7CisKKwlXQVJOX09OX09OQ0UoZXZlbnQtPmN0eC0+cGFyZW50X2N0eCk7CisJbXV0ZXhfbG9jaygmZXZlbnQtPmNoaWxkX211dGV4KTsKKwlmdW5jKGV2ZW50KTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNoaWxkLCAmZXZlbnQtPmNoaWxkX2xpc3QsIGNoaWxkX2xpc3QpCisJCWZ1bmMoY2hpbGQpOworCW11dGV4X3VubG9jaygmZXZlbnQtPmNoaWxkX211dGV4KTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9mb3JfZWFjaChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkJICB2b2lkICgqZnVuYykoc3RydWN0IHBlcmZfZXZlbnQgKikpCit7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gZXZlbnQtPmN0eDsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqc2libGluZzsKKworCVdBUk5fT05fT05DRShjdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOworCWV2ZW50ID0gZXZlbnQtPmdyb3VwX2xlYWRlcjsKKworCXBlcmZfZXZlbnRfZm9yX2VhY2hfY2hpbGQoZXZlbnQsIGZ1bmMpOworCWZ1bmMoZXZlbnQpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoc2libGluZywgJmV2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KQorCQlwZXJmX2V2ZW50X2Zvcl9lYWNoX2NoaWxkKGV2ZW50LCBmdW5jKTsKKwltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOworfQorCitzdGF0aWMgaW50IHBlcmZfZXZlbnRfcGVyaW9kKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0IF9fdXNlciAqYXJnKQoreworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CisJdW5zaWduZWQgbG9uZyBzaXplOworCWludCByZXQgPSAwOworCXU2NCB2YWx1ZTsKKworCWlmICghZXZlbnQtPmF0dHIuc2FtcGxlX3BlcmlvZCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzaXplID0gY29weV9mcm9tX3VzZXIoJnZhbHVlLCBhcmcsIHNpemVvZih2YWx1ZSkpOworCWlmIChzaXplICE9IHNpemVvZih2YWx1ZSkpCisJCXJldHVybiAtRUZBVUxUOworCisJaWYgKCF2YWx1ZSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOworCWlmIChldmVudC0+YXR0ci5mcmVxKSB7CisJCWlmICh2YWx1ZSA+IHN5c2N0bF9wZXJmX2V2ZW50X3NhbXBsZV9yYXRlKSB7CisJCQlyZXQgPSAtRUlOVkFMOworCQkJZ290byB1bmxvY2s7CisJCX0KKworCQlldmVudC0+YXR0ci5zYW1wbGVfZnJlcSA9IHZhbHVlOworCX0gZWxzZSB7CisJCWV2ZW50LT5hdHRyLnNhbXBsZV9wZXJpb2QgPSB2YWx1ZTsKKwkJZXZlbnQtPmh3LnNhbXBsZV9wZXJpb2QgPSB2YWx1ZTsKKwl9Cit1bmxvY2s6CisJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOworCisJcmV0dXJuIHJldDsKK30KKworaW50IHBlcmZfZXZlbnRfc2V0X291dHB1dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBvdXRwdXRfZmQpOworCitzdGF0aWMgbG9uZyBwZXJmX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX2V2ZW50ICopOworCXUzMiBmbGFncyA9IGFyZzsKKworCXN3aXRjaCAoY21kKSB7CisJY2FzZSBQRVJGX0VWRU5UX0lPQ19FTkFCTEU6CisJCWZ1bmMgPSBwZXJmX2V2ZW50X2VuYWJsZTsKKwkJYnJlYWs7CisJY2FzZSBQRVJGX0VWRU5UX0lPQ19ESVNBQkxFOgorCQlmdW5jID0gcGVyZl9ldmVudF9kaXNhYmxlOworCQlicmVhazsKKwljYXNlIFBFUkZfRVZFTlRfSU9DX1JFU0VUOgorCQlmdW5jID0gcGVyZl9ldmVudF9yZXNldDsKKwkJYnJlYWs7CisKKwljYXNlIFBFUkZfRVZFTlRfSU9DX1JFRlJFU0g6CisJCXJldHVybiBwZXJmX2V2ZW50X3JlZnJlc2goZXZlbnQsIGFyZyk7CisKKwljYXNlIFBFUkZfRVZFTlRfSU9DX1BFUklPRDoKKwkJcmV0dXJuIHBlcmZfZXZlbnRfcGVyaW9kKGV2ZW50LCAodTY0IF9fdXNlciAqKWFyZyk7CisKKwljYXNlIFBFUkZfRVZFTlRfSU9DX1NFVF9PVVRQVVQ6CisJCXJldHVybiBwZXJmX2V2ZW50X3NldF9vdXRwdXQoZXZlbnQsIGFyZyk7CisKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVOT1RUWTsKKwl9CisKKwlpZiAoZmxhZ3MgJiBQRVJGX0lPQ19GTEFHX0dST1VQKQorCQlwZXJmX2V2ZW50X2Zvcl9lYWNoKGV2ZW50LCBmdW5jKTsKKwllbHNlCisJCXBlcmZfZXZlbnRfZm9yX2VhY2hfY2hpbGQoZXZlbnQsIGZ1bmMpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBwZXJmX2V2ZW50X3Rhc2tfZW5hYmxlKHZvaWQpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCisJbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN1cnJlbnQtPnBlcmZfZXZlbnRfbGlzdCwgb3duZXJfZW50cnkpCisJCXBlcmZfZXZlbnRfZm9yX2VhY2hfY2hpbGQoZXZlbnQsIHBlcmZfZXZlbnRfZW5hYmxlKTsKKwltdXRleF91bmxvY2soJmN1cnJlbnQtPnBlcmZfZXZlbnRfbXV0ZXgpOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBwZXJmX2V2ZW50X3Rhc2tfZGlzYWJsZSh2b2lkKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKworCW11dGV4X2xvY2soJmN1cnJlbnQtPnBlcmZfZXZlbnRfbXV0ZXgpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZjdXJyZW50LT5wZXJmX2V2ZW50X2xpc3QsIG93bmVyX2VudHJ5KQorCQlwZXJmX2V2ZW50X2Zvcl9lYWNoX2NoaWxkKGV2ZW50LCBwZXJmX2V2ZW50X2Rpc2FibGUpOworCW11dGV4X3VubG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CisKKwlyZXR1cm4gMDsKK30KKworI2lmbmRlZiBQRVJGX0VWRU5UX0lOREVYX09GRlNFVAorIyBkZWZpbmUgUEVSRl9FVkVOVF9JTkRFWF9PRkZTRVQgMAorI2VuZGlmCisKK3N0YXRpYyBpbnQgcGVyZl9ldmVudF9pbmRleChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJaWYgKGV2ZW50LT5zdGF0ZSAhPSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRSkKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gZXZlbnQtPmh3LmlkeCArIDEgLSBQRVJGX0VWRU5UX0lOREVYX09GRlNFVDsKK30KKworLyoKKyAqIENhbGxlcnMgbmVlZCB0byBlbnN1cmUgdGhlcmUgY2FuIGJlIG5vIG5lc3Rpbmcgb2YgdGhpcyBmdW5jdGlvbiwgb3RoZXJ3aXNlCisgKiB0aGUgc2VxbG9jayBsb2dpYyBnb2VzIGJhZC4gV2UgY2FuIG5vdCBzZXJpYWxpemUgdGhpcyBiZWNhdXNlIHRoZSBhcmNoCisgKiBjb2RlIGNhbGxzIHRoaXMgZnJvbSBOTUkgY29udGV4dC4KKyAqLwordm9pZCBwZXJmX2V2ZW50X3VwZGF0ZV91c2VycGFnZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IHBlcmZfZXZlbnRfbW1hcF9wYWdlICp1c2VycGc7CisJc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOworCisJcmN1X3JlYWRfbG9jaygpOworCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoZXZlbnQtPmRhdGEpOworCWlmICghZGF0YSkKKwkJZ290byB1bmxvY2s7CisKKwl1c2VycGcgPSBkYXRhLT51c2VyX3BhZ2U7CisKKwkvKgorCSAqIERpc2FibGUgcHJlZW1wdGlvbiBzbyBhcyB0byBub3QgbGV0IHRoZSBjb3JyZXNwb25kaW5nIHVzZXItc3BhY2UKKwkgKiBzcGluIHRvbyBsb25nIGlmIHdlIGdldCBwcmVlbXB0ZWQuCisJICovCisJcHJlZW1wdF9kaXNhYmxlKCk7CisJKyt1c2VycGctPmxvY2s7CisJYmFycmllcigpOworCXVzZXJwZy0+aW5kZXggPSBwZXJmX2V2ZW50X2luZGV4KGV2ZW50KTsKKwl1c2VycGctPm9mZnNldCA9IGF0b21pYzY0X3JlYWQoJmV2ZW50LT5jb3VudCk7CisJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRSkKKwkJdXNlcnBnLT5vZmZzZXQgLT0gYXRvbWljNjRfcmVhZCgmZXZlbnQtPmh3LnByZXZfY291bnQpOworCisJdXNlcnBnLT50aW1lX2VuYWJsZWQgPSBldmVudC0+dG90YWxfdGltZV9lbmFibGVkICsKKwkJCWF0b21pYzY0X3JlYWQoJmV2ZW50LT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOworCisJdXNlcnBnLT50aW1lX3J1bm5pbmcgPSBldmVudC0+dG90YWxfdGltZV9ydW5uaW5nICsKKwkJCWF0b21pYzY0X3JlYWQoJmV2ZW50LT5jaGlsZF90b3RhbF90aW1lX3J1bm5pbmcpOworCisJYmFycmllcigpOworCSsrdXNlcnBnLT5sb2NrOworCXByZWVtcHRfZW5hYmxlKCk7Cit1bmxvY2s6CisJcmN1X3JlYWRfdW5sb2NrKCk7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9tbWFwX2ZhdWx0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSB2bWEtPnZtX2ZpbGUtPnByaXZhdGVfZGF0YTsKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CisJaW50IHJldCA9IFZNX0ZBVUxUX1NJR0JVUzsKKworCWlmICh2bWYtPmZsYWdzICYgRkFVTFRfRkxBR19NS1dSSVRFKSB7CisJCWlmICh2bWYtPnBnb2ZmID09IDApCisJCQlyZXQgPSAwOworCQlyZXR1cm4gcmV0OworCX0KKworCXJjdV9yZWFkX2xvY2soKTsKKwlkYXRhID0gcmN1X2RlcmVmZXJlbmNlKGV2ZW50LT5kYXRhKTsKKwlpZiAoIWRhdGEpCisJCWdvdG8gdW5sb2NrOworCisJaWYgKHZtZi0+cGdvZmYgPT0gMCkgeworCQl2bWYtPnBhZ2UgPSB2aXJ0X3RvX3BhZ2UoZGF0YS0+dXNlcl9wYWdlKTsKKwl9IGVsc2UgeworCQlpbnQgbnIgPSB2bWYtPnBnb2ZmIC0gMTsKKworCQlpZiAoKHVuc2lnbmVkKW5yID4gZGF0YS0+bnJfcGFnZXMpCisJCQlnb3RvIHVubG9jazsKKworCQlpZiAodm1mLT5mbGFncyAmIEZBVUxUX0ZMQUdfV1JJVEUpCisJCQlnb3RvIHVubG9jazsKKworCQl2bWYtPnBhZ2UgPSB2aXJ0X3RvX3BhZ2UoZGF0YS0+ZGF0YV9wYWdlc1tucl0pOworCX0KKworCWdldF9wYWdlKHZtZi0+cGFnZSk7CisJdm1mLT5wYWdlLT5tYXBwaW5nID0gdm1hLT52bV9maWxlLT5mX21hcHBpbmc7CisJdm1mLT5wYWdlLT5pbmRleCAgID0gdm1mLT5wZ29mZjsKKworCXJldCA9IDA7Cit1bmxvY2s6CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHBlcmZfbW1hcF9kYXRhX2FsbG9jKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IG5yX3BhZ2VzKQoreworCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBsb25nIHNpemU7CisJaW50IGk7CisKKwlXQVJOX09OKGF0b21pY19yZWFkKCZldmVudC0+bW1hcF9jb3VudCkpOworCisJc2l6ZSA9IHNpemVvZihzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEpOworCXNpemUgKz0gbnJfcGFnZXMgKiBzaXplb2Yodm9pZCAqKTsKKworCWRhdGEgPSBremFsbG9jKHNpemUsIEdGUF9LRVJORUwpOworCWlmICghZGF0YSkKKwkJZ290byBmYWlsOworCisJZGF0YS0+dXNlcl9wYWdlID0gKHZvaWQgKilnZXRfemVyb2VkX3BhZ2UoR0ZQX0tFUk5FTCk7CisJaWYgKCFkYXRhLT51c2VyX3BhZ2UpCisJCWdvdG8gZmFpbF91c2VyX3BhZ2U7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnJfcGFnZXM7IGkrKykgeworCQlkYXRhLT5kYXRhX3BhZ2VzW2ldID0gKHZvaWQgKilnZXRfemVyb2VkX3BhZ2UoR0ZQX0tFUk5FTCk7CisJCWlmICghZGF0YS0+ZGF0YV9wYWdlc1tpXSkKKwkJCWdvdG8gZmFpbF9kYXRhX3BhZ2VzOworCX0KKworCWRhdGEtPm5yX3BhZ2VzID0gbnJfcGFnZXM7CisJYXRvbWljX3NldCgmZGF0YS0+bG9jaywgLTEpOworCisJaWYgKGV2ZW50LT5hdHRyLndhdGVybWFyaykgeworCQlkYXRhLT53YXRlcm1hcmsgPSBtaW5fdChsb25nLCBQQUdFX1NJWkUgKiBucl9wYWdlcywKKwkJCQkgICAgICBldmVudC0+YXR0ci53YWtldXBfd2F0ZXJtYXJrKTsKKwl9CisJaWYgKCFkYXRhLT53YXRlcm1hcmspCisJCWRhdGEtPndhdGVybWFyayA9IG1heChQQUdFX1NJWkUsIFBBR0VfU0laRSAqIG5yX3BhZ2VzIC8gNCk7CisKKwlyY3VfYXNzaWduX3BvaW50ZXIoZXZlbnQtPmRhdGEsIGRhdGEpOworCisJcmV0dXJuIDA7CisKK2ZhaWxfZGF0YV9wYWdlczoKKwlmb3IgKGktLTsgaSA+PSAwOyBpLS0pCisJCWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylkYXRhLT5kYXRhX3BhZ2VzW2ldKTsKKworCWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylkYXRhLT51c2VyX3BhZ2UpOworCitmYWlsX3VzZXJfcGFnZToKKwlrZnJlZShkYXRhKTsKKworZmFpbDoKKwlyZXR1cm4gLUVOT01FTTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9tbWFwX2ZyZWVfcGFnZSh1bnNpZ25lZCBsb25nIGFkZHIpCit7CisJc3RydWN0IHBhZ2UgKnBhZ2UgPSB2aXJ0X3RvX3BhZ2UoKHZvaWQgKilhZGRyKTsKKworCXBhZ2UtPm1hcHBpbmcgPSBOVUxMOworCV9fZnJlZV9wYWdlKHBhZ2UpOworfQorCitzdGF0aWMgdm9pZCBfX3BlcmZfbW1hcF9kYXRhX2ZyZWUoc3RydWN0IHJjdV9oZWFkICpyY3VfaGVhZCkKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CisJaW50IGk7CisKKwlkYXRhID0gY29udGFpbmVyX29mKHJjdV9oZWFkLCBzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEsIHJjdV9oZWFkKTsKKworCXBlcmZfbW1hcF9mcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+dXNlcl9wYWdlKTsKKwlmb3IgKGkgPSAwOyBpIDwgZGF0YS0+bnJfcGFnZXM7IGkrKykKKwkJcGVyZl9tbWFwX2ZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylkYXRhLT5kYXRhX3BhZ2VzW2ldKTsKKworCWtmcmVlKGRhdGEpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX21tYXBfZGF0YV9mcmVlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBldmVudC0+ZGF0YTsKKworCVdBUk5fT04oYXRvbWljX3JlYWQoJmV2ZW50LT5tbWFwX2NvdW50KSk7CisKKwlyY3VfYXNzaWduX3BvaW50ZXIoZXZlbnQtPmRhdGEsIE5VTEwpOworCWNhbGxfcmN1KCZkYXRhLT5yY3VfaGVhZCwgX19wZXJmX21tYXBfZGF0YV9mcmVlKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9tbWFwX29wZW4oc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gdm1hLT52bV9maWxlLT5wcml2YXRlX2RhdGE7CisKKwlhdG9taWNfaW5jKCZldmVudC0+bW1hcF9jb3VudCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfbW1hcF9jbG9zZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSB2bWEtPnZtX2ZpbGUtPnByaXZhdGVfZGF0YTsKKworCVdBUk5fT05fT05DRShldmVudC0+Y3R4LT5wYXJlbnRfY3R4KTsKKwlpZiAoYXRvbWljX2RlY19hbmRfbXV0ZXhfbG9jaygmZXZlbnQtPm1tYXBfY291bnQsICZldmVudC0+bW1hcF9tdXRleCkpIHsKKwkJc3RydWN0IHVzZXJfc3RydWN0ICp1c2VyID0gY3VycmVudF91c2VyKCk7CisKKwkJYXRvbWljX2xvbmdfc3ViKGV2ZW50LT5kYXRhLT5ucl9wYWdlcyArIDEsICZ1c2VyLT5sb2NrZWRfdm0pOworCQl2bWEtPnZtX21tLT5sb2NrZWRfdm0gLT0gZXZlbnQtPmRhdGEtPm5yX2xvY2tlZDsKKwkJcGVyZl9tbWFwX2RhdGFfZnJlZShldmVudCk7CisJCW11dGV4X3VubG9jaygmZXZlbnQtPm1tYXBfbXV0ZXgpOworCX0KK30KKworc3RhdGljIHN0cnVjdCB2bV9vcGVyYXRpb25zX3N0cnVjdCBwZXJmX21tYXBfdm1vcHMgPSB7CisJLm9wZW4JCT0gcGVyZl9tbWFwX29wZW4sCisJLmNsb3NlCQk9IHBlcmZfbW1hcF9jbG9zZSwKKwkuZmF1bHQJCT0gcGVyZl9tbWFwX2ZhdWx0LAorCS5wYWdlX21rd3JpdGUJPSBwZXJmX21tYXBfZmF1bHQsCit9OworCitzdGF0aWMgaW50IHBlcmZfbW1hcChzdHJ1Y3QgZmlsZSAqZmlsZSwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCXVuc2lnbmVkIGxvbmcgdXNlcl9sb2NrZWQsIHVzZXJfbG9ja19saW1pdDsKKwlzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKnVzZXIgPSBjdXJyZW50X3VzZXIoKTsKKwl1bnNpZ25lZCBsb25nIGxvY2tlZCwgbG9ja19saW1pdDsKKwl1bnNpZ25lZCBsb25nIHZtYV9zaXplOworCXVuc2lnbmVkIGxvbmcgbnJfcGFnZXM7CisJbG9uZyB1c2VyX2V4dHJhLCBleHRyYTsKKwlpbnQgcmV0ID0gMDsKKworCWlmICghKHZtYS0+dm1fZmxhZ3MgJiBWTV9TSEFSRUQpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXZtYV9zaXplID0gdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0OworCW5yX3BhZ2VzID0gKHZtYV9zaXplIC8gUEFHRV9TSVpFKSAtIDE7CisKKwkvKgorCSAqIElmIHdlIGhhdmUgZGF0YSBwYWdlcyBlbnN1cmUgdGhleSdyZSBhIHBvd2VyLW9mLXR3byBudW1iZXIsIHNvIHdlCisJICogY2FuIGRvIGJpdG1hc2tzIGluc3RlYWQgb2YgbW9kdWxvLgorCSAqLworCWlmIChucl9wYWdlcyAhPSAwICYmICFpc19wb3dlcl9vZl8yKG5yX3BhZ2VzKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAodm1hX3NpemUgIT0gUEFHRV9TSVpFICogKDEgKyBucl9wYWdlcykpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHZtYS0+dm1fcGdvZmYgIT0gMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlXQVJOX09OX09OQ0UoZXZlbnQtPmN0eC0+cGFyZW50X2N0eCk7CisJbXV0ZXhfbG9jaygmZXZlbnQtPm1tYXBfbXV0ZXgpOworCWlmIChldmVudC0+b3V0cHV0KSB7CisJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gdW5sb2NrOworCX0KKworCWlmIChhdG9taWNfaW5jX25vdF96ZXJvKCZldmVudC0+bW1hcF9jb3VudCkpIHsKKwkJaWYgKG5yX3BhZ2VzICE9IGV2ZW50LT5kYXRhLT5ucl9wYWdlcykKKwkJCXJldCA9IC1FSU5WQUw7CisJCWdvdG8gdW5sb2NrOworCX0KKworCXVzZXJfZXh0cmEgPSBucl9wYWdlcyArIDE7CisJdXNlcl9sb2NrX2xpbWl0ID0gc3lzY3RsX3BlcmZfZXZlbnRfbWxvY2sgPj4gKFBBR0VfU0hJRlQgLSAxMCk7CisKKwkvKgorCSAqIEluY3JlYXNlIHRoZSBsaW1pdCBsaW5lYXJseSB3aXRoIG1vcmUgQ1BVczoKKwkgKi8KKwl1c2VyX2xvY2tfbGltaXQgKj0gbnVtX29ubGluZV9jcHVzKCk7CisKKwl1c2VyX2xvY2tlZCA9IGF0b21pY19sb25nX3JlYWQoJnVzZXItPmxvY2tlZF92bSkgKyB1c2VyX2V4dHJhOworCisJZXh0cmEgPSAwOworCWlmICh1c2VyX2xvY2tlZCA+IHVzZXJfbG9ja19saW1pdCkKKwkJZXh0cmEgPSB1c2VyX2xvY2tlZCAtIHVzZXJfbG9ja19saW1pdDsKKworCWxvY2tfbGltaXQgPSBjdXJyZW50LT5zaWduYWwtPnJsaW1bUkxJTUlUX01FTUxPQ0tdLnJsaW1fY3VyOworCWxvY2tfbGltaXQgPj49IFBBR0VfU0hJRlQ7CisJbG9ja2VkID0gdm1hLT52bV9tbS0+bG9ja2VkX3ZtICsgZXh0cmE7CisKKwlpZiAoKGxvY2tlZCA+IGxvY2tfbGltaXQpICYmIHBlcmZfcGFyYW5vaWRfdHJhY2Vwb2ludF9yYXcoKSAmJgorCQkhY2FwYWJsZShDQVBfSVBDX0xPQ0spKSB7CisJCXJldCA9IC1FUEVSTTsKKwkJZ290byB1bmxvY2s7CisJfQorCisJV0FSTl9PTihldmVudC0+ZGF0YSk7CisJcmV0ID0gcGVyZl9tbWFwX2RhdGFfYWxsb2MoZXZlbnQsIG5yX3BhZ2VzKTsKKwlpZiAocmV0KQorCQlnb3RvIHVubG9jazsKKworCWF0b21pY19zZXQoJmV2ZW50LT5tbWFwX2NvdW50LCAxKTsKKwlhdG9taWNfbG9uZ19hZGQodXNlcl9leHRyYSwgJnVzZXItPmxvY2tlZF92bSk7CisJdm1hLT52bV9tbS0+bG9ja2VkX3ZtICs9IGV4dHJhOworCWV2ZW50LT5kYXRhLT5ucl9sb2NrZWQgPSBleHRyYTsKKwlpZiAodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKQorCQlldmVudC0+ZGF0YS0+d3JpdGFibGUgPSAxOworCit1bmxvY2s6CisJbXV0ZXhfdW5sb2NrKCZldmVudC0+bW1hcF9tdXRleCk7CisKKwl2bWEtPnZtX2ZsYWdzIHw9IFZNX1JFU0VSVkVEOworCXZtYS0+dm1fb3BzID0gJnBlcmZfbW1hcF92bW9wczsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9mYXN5bmMoaW50IGZkLCBzdHJ1Y3QgZmlsZSAqZmlscCwgaW50IG9uKQoreworCXN0cnVjdCBpbm9kZSAqaW5vZGUgPSBmaWxwLT5mX3BhdGguZGVudHJ5LT5kX2lub2RlOworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGZpbHAtPnByaXZhdGVfZGF0YTsKKwlpbnQgcmV0dmFsOworCisJbXV0ZXhfbG9jaygmaW5vZGUtPmlfbXV0ZXgpOworCXJldHZhbCA9IGZhc3luY19oZWxwZXIoZmQsIGZpbHAsIG9uLCAmZXZlbnQtPmZhc3luYyk7CisJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CisKKwlpZiAocmV0dmFsIDwgMCkKKwkJcmV0dXJuIHJldHZhbDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBwZXJmX2ZvcHMgPSB7CisJLnJlbGVhc2UJCT0gcGVyZl9yZWxlYXNlLAorCS5yZWFkCQkJPSBwZXJmX3JlYWQsCisJLnBvbGwJCQk9IHBlcmZfcG9sbCwKKwkudW5sb2NrZWRfaW9jdGwJCT0gcGVyZl9pb2N0bCwKKwkuY29tcGF0X2lvY3RsCQk9IHBlcmZfaW9jdGwsCisJLm1tYXAJCQk9IHBlcmZfbW1hcCwKKwkuZmFzeW5jCQkJPSBwZXJmX2Zhc3luYywKK307CisKKy8qCisgKiBQZXJmIGV2ZW50IHdha2V1cAorICoKKyAqIElmIHRoZXJlJ3MgZGF0YSwgZW5zdXJlIHdlIHNldCB0aGUgcG9sbCgpIHN0YXRlIGFuZCBwdWJsaXNoIGV2ZXJ5dGhpbmcKKyAqIHRvIHVzZXItc3BhY2UgYmVmb3JlIHdha2luZyBldmVyeWJvZHkgdXAuCisgKi8KKwordm9pZCBwZXJmX2V2ZW50X3dha2V1cChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJd2FrZV91cF9hbGwoJmV2ZW50LT53YWl0cSk7CisKKwlpZiAoZXZlbnQtPnBlbmRpbmdfa2lsbCkgeworCQlraWxsX2Zhc3luYygmZXZlbnQtPmZhc3luYywgU0lHSU8sIGV2ZW50LT5wZW5kaW5nX2tpbGwpOworCQlldmVudC0+cGVuZGluZ19raWxsID0gMDsKKwl9Cit9CisKKy8qCisgKiBQZW5kaW5nIHdha2V1cHMKKyAqCisgKiBIYW5kbGUgdGhlIGNhc2Ugd2hlcmUgd2UgbmVlZCB0byB3YWtldXAgdXAgZnJvbSBOTUkgKG9yIHJxLT5sb2NrKSBjb250ZXh0LgorICoKKyAqIFRoZSBOTUkgYml0IG1lYW5zIHdlIGNhbm5vdCBwb3NzaWJseSB0YWtlIGxvY2tzLiBUaGVyZWZvcmUsIG1haW50YWluIGEKKyAqIHNpbmdsZSBsaW5rZWQgbGlzdCBhbmQgdXNlIGNtcHhjaGcoKSB0byBhZGQgZW50cmllcyBsb2NrbGVzcy4KKyAqLworCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfZXZlbnQoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqZW50cnkpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gY29udGFpbmVyX29mKGVudHJ5LAorCQkJc3RydWN0IHBlcmZfZXZlbnQsIHBlbmRpbmcpOworCisJaWYgKGV2ZW50LT5wZW5kaW5nX2Rpc2FibGUpIHsKKwkJZXZlbnQtPnBlbmRpbmdfZGlzYWJsZSA9IDA7CisJCV9fcGVyZl9ldmVudF9kaXNhYmxlKGV2ZW50KTsKKwl9CisKKwlpZiAoZXZlbnQtPnBlbmRpbmdfd2FrZXVwKSB7CisJCWV2ZW50LT5wZW5kaW5nX3dha2V1cCA9IDA7CisJCXBlcmZfZXZlbnRfd2FrZXVwKGV2ZW50KTsKKwl9Cit9CisKKyNkZWZpbmUgUEVORElOR19UQUlMICgoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqKS0xVUwpCisKK3N0YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICosIHBlcmZfcGVuZGluZ19oZWFkKSA9IHsKKwlQRU5ESU5HX1RBSUwsCit9OworCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfcXVldWUoc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqZW50cnksCisJCQkgICAgICAgdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKikpCit7CisJc3RydWN0IHBlcmZfcGVuZGluZ19lbnRyeSAqKmhlYWQ7CisKKwlpZiAoY21weGNoZygmZW50cnktPm5leHQsIE5VTEwsIFBFTkRJTkdfVEFJTCkgIT0gTlVMTCkKKwkJcmV0dXJuOworCisJZW50cnktPmZ1bmMgPSBmdW5jOworCisJaGVhZCA9ICZnZXRfY3B1X3ZhcihwZXJmX3BlbmRpbmdfaGVhZCk7CisKKwlkbyB7CisJCWVudHJ5LT5uZXh0ID0gKmhlYWQ7CisJfSB3aGlsZSAoY21weGNoZyhoZWFkLCBlbnRyeS0+bmV4dCwgZW50cnkpICE9IGVudHJ5LT5uZXh0KTsKKworCXNldF9wZXJmX2V2ZW50X3BlbmRpbmcoKTsKKworCXB1dF9jcHVfdmFyKHBlcmZfcGVuZGluZ19oZWFkKTsKK30KKworc3RhdGljIGludCBfX3BlcmZfcGVuZGluZ19ydW4odm9pZCkKK3sKKwlzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICpsaXN0OworCWludCBuciA9IDA7CisKKwlsaXN0ID0geGNoZygmX19nZXRfY3B1X3ZhcihwZXJmX3BlbmRpbmdfaGVhZCksIFBFTkRJTkdfVEFJTCk7CisJd2hpbGUgKGxpc3QgIT0gUEVORElOR19UQUlMKSB7CisJCXZvaWQgKCpmdW5jKShzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICopOworCQlzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICplbnRyeSA9IGxpc3Q7CisKKwkJbGlzdCA9IGxpc3QtPm5leHQ7CisKKwkJZnVuYyA9IGVudHJ5LT5mdW5jOworCQllbnRyeS0+bmV4dCA9IE5VTEw7CisJCS8qCisJCSAqIEVuc3VyZSB3ZSBvYnNlcnZlIHRoZSB1bnF1ZXVlIGJlZm9yZSB3ZSBpc3N1ZSB0aGUgd2FrZXVwLAorCQkgKiBzbyB0aGF0IHdlIHdvbid0IGJlIHdhaXRpbmcgZm9yZXZlci4KKwkJICogLS0gc2VlIHBlcmZfbm90X3BlbmRpbmcoKS4KKwkJICovCisJCXNtcF93bWIoKTsKKworCQlmdW5jKGVudHJ5KTsKKwkJbnIrKzsKKwl9CisKKwlyZXR1cm4gbnI7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHBlcmZfbm90X3BlbmRpbmcoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCS8qCisJICogSWYgd2UgZmx1c2ggb24gd2hhdGV2ZXIgY3B1IHdlIHJ1biwgdGhlcmUgaXMgYSBjaGFuY2Ugd2UgZG9uJ3QKKwkgKiBuZWVkIHRvIHdhaXQuCisJICovCisJZ2V0X2NwdSgpOworCV9fcGVyZl9wZW5kaW5nX3J1bigpOworCXB1dF9jcHUoKTsKKworCS8qCisJICogRW5zdXJlIHdlIHNlZSB0aGUgcHJvcGVyIHF1ZXVlIHN0YXRlIGJlZm9yZSBnb2luZyB0byBzbGVlcAorCSAqIHNvIHRoYXQgd2UgZG8gbm90IG1pc3MgdGhlIHdha2V1cC4gLS0gc2VlIHBlcmZfcGVuZGluZ19oYW5kbGUoKQorCSAqLworCXNtcF9ybWIoKTsKKwlyZXR1cm4gZXZlbnQtPnBlbmRpbmcubmV4dCA9PSBOVUxMOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfc3luYyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJd2FpdF9ldmVudChldmVudC0+d2FpdHEsIHBlcmZfbm90X3BlbmRpbmcoZXZlbnQpKTsKK30KKwordm9pZCBwZXJmX2V2ZW50X2RvX3BlbmRpbmcodm9pZCkKK3sKKwlfX3BlcmZfcGVuZGluZ19ydW4oKTsKK30KKworLyoKKyAqIENhbGxjaGFpbiBzdXBwb3J0IC0tIGFyY2ggc3BlY2lmaWMKKyAqLworCitfX3dlYWsgc3RydWN0IHBlcmZfY2FsbGNoYWluX2VudHJ5ICpwZXJmX2NhbGxjaGFpbihzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlyZXR1cm4gTlVMTDsKK30KKworLyoKKyAqIE91dHB1dAorICovCitzdGF0aWMgYm9vbCBwZXJmX291dHB1dF9zcGFjZShzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGxvbmcgdGFpbCwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1bnNpZ25lZCBsb25nIGhlYWQpCit7CisJdW5zaWduZWQgbG9uZyBtYXNrOworCisJaWYgKCFkYXRhLT53cml0YWJsZSkKKwkJcmV0dXJuIHRydWU7CisKKwltYXNrID0gKGRhdGEtPm5yX3BhZ2VzIDw8IFBBR0VfU0hJRlQpIC0gMTsKKworCW9mZnNldCA9IChvZmZzZXQgLSB0YWlsKSAmIG1hc2s7CisJaGVhZCAgID0gKGhlYWQgICAtIHRhaWwpICYgbWFzazsKKworCWlmICgoaW50KShoZWFkIC0gb2Zmc2V0KSA8IDApCisJCXJldHVybiBmYWxzZTsKKworCXJldHVybiB0cnVlOworfQorCitzdGF0aWMgdm9pZCBwZXJmX291dHB1dF93YWtldXAoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQoreworCWF0b21pY19zZXQoJmhhbmRsZS0+ZGF0YS0+cG9sbCwgUE9MTF9JTik7CisKKwlpZiAoaGFuZGxlLT5ubWkpIHsKKwkJaGFuZGxlLT5ldmVudC0+cGVuZGluZ193YWtldXAgPSAxOworCQlwZXJmX3BlbmRpbmdfcXVldWUoJmhhbmRsZS0+ZXZlbnQtPnBlbmRpbmcsCisJCQkJICAgcGVyZl9wZW5kaW5nX2V2ZW50KTsKKwl9IGVsc2UKKwkJcGVyZl9ldmVudF93YWtldXAoaGFuZGxlLT5ldmVudCk7Cit9CisKKy8qCisgKiBDdXJpb3VzIGxvY2tpbmcgY29uc3RydWN0LgorICoKKyAqIFdlIG5lZWQgdG8gZW5zdXJlIGEgbGF0ZXIgZXZlbnRfaWQgZG9lc24ndCBwdWJsaXNoIGEgaGVhZCB3aGVuIGEgZm9ybWVyCisgKiBldmVudF9pZCBpc24ndCBkb25lIHdyaXRpbmcuIEhvd2V2ZXIgc2luY2Ugd2UgbmVlZCB0byBkZWFsIHdpdGggTk1JcyB3ZQorICogY2Fubm90IGZ1bGx5IHNlcmlhbGl6ZSB0aGluZ3MuCisgKgorICogV2hhdCB3ZSBkbyBpcyBzZXJpYWxpemUgYmV0d2VlbiBDUFVzIHNvIHdlIG9ubHkgaGF2ZSB0byBkZWFsIHdpdGggTk1JCisgKiBuZXN0aW5nIG9uIGEgc2luZ2xlIENQVS4KKyAqCisgKiBXZSBvbmx5IHB1Ymxpc2ggdGhlIGhlYWQgKGFuZCBnZW5lcmF0ZSBhIHdha2V1cCkgd2hlbiB0aGUgb3V0ZXItbW9zdAorICogZXZlbnRfaWQgY29tcGxldGVzLgorICovCitzdGF0aWMgdm9pZCBwZXJmX291dHB1dF9sb2NrKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSkKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBoYW5kbGUtPmRhdGE7CisJaW50IGNwdTsKKworCWhhbmRsZS0+bG9ja2VkID0gMDsKKworCWxvY2FsX2lycV9zYXZlKGhhbmRsZS0+ZmxhZ3MpOworCWNwdSA9IHNtcF9wcm9jZXNzb3JfaWQoKTsKKworCWlmIChpbl9ubWkoKSAmJiBhdG9taWNfcmVhZCgmZGF0YS0+bG9jaykgPT0gY3B1KQorCQlyZXR1cm47CisKKwl3aGlsZSAoYXRvbWljX2NtcHhjaGcoJmRhdGEtPmxvY2ssIC0xLCBjcHUpICE9IC0xKQorCQljcHVfcmVsYXgoKTsKKworCWhhbmRsZS0+bG9ja2VkID0gMTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfdW5sb2NrKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSkKK3sKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBoYW5kbGUtPmRhdGE7CisJdW5zaWduZWQgbG9uZyBoZWFkOworCWludCBjcHU7CisKKwlkYXRhLT5kb25lX2hlYWQgPSBkYXRhLT5oZWFkOworCisJaWYgKCFoYW5kbGUtPmxvY2tlZCkKKwkJZ290byBvdXQ7CisKK2FnYWluOgorCS8qCisJICogVGhlIHhjaGcgaW1wbGllcyBhIGZ1bGwgYmFycmllciB0aGF0IGVuc3VyZXMgYWxsIHdyaXRlcyBhcmUgZG9uZQorCSAqIGJlZm9yZSB3ZSBwdWJsaXNoIHRoZSBuZXcgaGVhZCwgbWF0Y2hlZCBieSBhIHJtYigpIGluIHVzZXJzcGFjZSB3aGVuCisJICogcmVhZGluZyB0aGlzIHBvc2l0aW9uLgorCSAqLworCXdoaWxlICgoaGVhZCA9IGF0b21pY19sb25nX3hjaGcoJmRhdGEtPmRvbmVfaGVhZCwgMCkpKQorCQlkYXRhLT51c2VyX3BhZ2UtPmRhdGFfaGVhZCA9IGhlYWQ7CisKKwkvKgorCSAqIE5NSSBjYW4gaGFwcGVuIGhlcmUsIHdoaWNoIG1lYW5zIHdlIGNhbiBtaXNzIGEgZG9uZV9oZWFkIHVwZGF0ZS4KKwkgKi8KKworCWNwdSA9IGF0b21pY194Y2hnKCZkYXRhLT5sb2NrLCAtMSk7CisJV0FSTl9PTl9PTkNFKGNwdSAhPSBzbXBfcHJvY2Vzc29yX2lkKCkpOworCisJLyoKKwkgKiBUaGVyZWZvcmUgd2UgaGF2ZSB0byB2YWxpZGF0ZSB3ZSBkaWQgbm90IGluZGVlZCBkbyBzby4KKwkgKi8KKwlpZiAodW5saWtlbHkoYXRvbWljX2xvbmdfcmVhZCgmZGF0YS0+ZG9uZV9oZWFkKSkpIHsKKwkJLyoKKwkJICogU2luY2Ugd2UgaGFkIGl0IGxvY2tlZCwgd2UgY2FuIGxvY2sgaXQgYWdhaW4uCisJCSAqLworCQl3aGlsZSAoYXRvbWljX2NtcHhjaGcoJmRhdGEtPmxvY2ssIC0xLCBjcHUpICE9IC0xKQorCQkJY3B1X3JlbGF4KCk7CisKKwkJZ290byBhZ2FpbjsKKwl9CisKKwlpZiAoYXRvbWljX3hjaGcoJmRhdGEtPndha2V1cCwgMCkpCisJCXBlcmZfb3V0cHV0X3dha2V1cChoYW5kbGUpOworb3V0OgorCWxvY2FsX2lycV9yZXN0b3JlKGhhbmRsZS0+ZmxhZ3MpOworfQorCit2b2lkIHBlcmZfb3V0cHV0X2NvcHkoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlLAorCQkgICAgICBjb25zdCB2b2lkICpidWYsIHVuc2lnbmVkIGludCBsZW4pCit7CisJdW5zaWduZWQgaW50IHBhZ2VzX21hc2s7CisJdW5zaWduZWQgaW50IG9mZnNldDsKKwl1bnNpZ25lZCBpbnQgc2l6ZTsKKwl2b2lkICoqcGFnZXM7CisKKwlvZmZzZXQJCT0gaGFuZGxlLT5vZmZzZXQ7CisJcGFnZXNfbWFzawk9IGhhbmRsZS0+ZGF0YS0+bnJfcGFnZXMgLSAxOworCXBhZ2VzCQk9IGhhbmRsZS0+ZGF0YS0+ZGF0YV9wYWdlczsKKworCWRvIHsKKwkJdW5zaWduZWQgaW50IHBhZ2Vfb2Zmc2V0OworCQlpbnQgbnI7CisKKwkJbnIJICAgID0gKG9mZnNldCA+PiBQQUdFX1NISUZUKSAmIHBhZ2VzX21hc2s7CisJCXBhZ2Vfb2Zmc2V0ID0gb2Zmc2V0ICYgKFBBR0VfU0laRSAtIDEpOworCQlzaXplCSAgICA9IG1pbl90KHVuc2lnbmVkIGludCwgUEFHRV9TSVpFIC0gcGFnZV9vZmZzZXQsIGxlbik7CisKKwkJbWVtY3B5KHBhZ2VzW25yXSArIHBhZ2Vfb2Zmc2V0LCBidWYsIHNpemUpOworCisJCWxlbgkgICAgLT0gc2l6ZTsKKwkJYnVmCSAgICArPSBzaXplOworCQlvZmZzZXQJICAgICs9IHNpemU7CisJfSB3aGlsZSAobGVuKTsKKworCWhhbmRsZS0+b2Zmc2V0ID0gb2Zmc2V0OworCisJLyoKKwkgKiBDaGVjayB3ZSBkaWRuJ3QgY29weSBwYXN0IG91ciByZXNlcnZhdGlvbiB3aW5kb3csIHRha2luZyB0aGUKKwkgKiBwb3NzaWJsZSB1bnNpZ25lZCBpbnQgd3JhcCBpbnRvIGFjY291bnQuCisJICovCisJV0FSTl9PTl9PTkNFKCgobG9uZykoaGFuZGxlLT5oZWFkIC0gaGFuZGxlLT5vZmZzZXQpKSA8IDApOworfQorCitpbnQgcGVyZl9vdXRwdXRfYmVnaW4oc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlLAorCQkgICAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHVuc2lnbmVkIGludCBzaXplLAorCQkgICAgICBpbnQgbm1pLCBpbnQgc2FtcGxlKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpvdXRwdXRfZXZlbnQ7CisJc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOworCXVuc2lnbmVkIGxvbmcgdGFpbCwgb2Zmc2V0LCBoZWFkOworCWludCBoYXZlX2xvc3Q7CisJc3RydWN0IHsKKwkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKKwkJdTY0CQkJIGlkOworCQl1NjQJCQkgbG9zdDsKKwl9IGxvc3RfZXZlbnQ7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJLyoKKwkgKiBGb3IgaW5oZXJpdGVkIGV2ZW50cyB3ZSBzZW5kIGFsbCB0aGUgb3V0cHV0IHRvd2FyZHMgdGhlIHBhcmVudC4KKwkgKi8KKwlpZiAoZXZlbnQtPnBhcmVudCkKKwkJZXZlbnQgPSBldmVudC0+cGFyZW50OworCisJb3V0cHV0X2V2ZW50ID0gcmN1X2RlcmVmZXJlbmNlKGV2ZW50LT5vdXRwdXQpOworCWlmIChvdXRwdXRfZXZlbnQpCisJCWV2ZW50ID0gb3V0cHV0X2V2ZW50OworCisJZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShldmVudC0+ZGF0YSk7CisJaWYgKCFkYXRhKQorCQlnb3RvIG91dDsKKworCWhhbmRsZS0+ZGF0YQk9IGRhdGE7CisJaGFuZGxlLT5ldmVudAk9IGV2ZW50OworCWhhbmRsZS0+bm1pCT0gbm1pOworCWhhbmRsZS0+c2FtcGxlCT0gc2FtcGxlOworCisJaWYgKCFkYXRhLT5ucl9wYWdlcykKKwkJZ290byBmYWlsOworCisJaGF2ZV9sb3N0ID0gYXRvbWljX3JlYWQoJmRhdGEtPmxvc3QpOworCWlmIChoYXZlX2xvc3QpCisJCXNpemUgKz0gc2l6ZW9mKGxvc3RfZXZlbnQpOworCisJcGVyZl9vdXRwdXRfbG9jayhoYW5kbGUpOworCisJZG8geworCQkvKgorCQkgKiBVc2Vyc3BhY2UgY291bGQgY2hvb3NlIHRvIGlzc3VlIGEgbWIoKSBiZWZvcmUgdXBkYXRpbmcgdGhlCisJCSAqIHRhaWwgcG9pbnRlci4gU28gdGhhdCBhbGwgcmVhZHMgd2lsbCBiZSBjb21wbGV0ZWQgYmVmb3JlIHRoZQorCQkgKiB3cml0ZSBpcyBpc3N1ZWQuCisJCSAqLworCQl0YWlsID0gQUNDRVNTX09OQ0UoZGF0YS0+dXNlcl9wYWdlLT5kYXRhX3RhaWwpOworCQlzbXBfcm1iKCk7CisJCW9mZnNldCA9IGhlYWQgPSBhdG9taWNfbG9uZ19yZWFkKCZkYXRhLT5oZWFkKTsKKwkJaGVhZCArPSBzaXplOworCQlpZiAodW5saWtlbHkoIXBlcmZfb3V0cHV0X3NwYWNlKGRhdGEsIHRhaWwsIG9mZnNldCwgaGVhZCkpKQorCQkJZ290byBmYWlsOworCX0gd2hpbGUgKGF0b21pY19sb25nX2NtcHhjaGcoJmRhdGEtPmhlYWQsIG9mZnNldCwgaGVhZCkgIT0gb2Zmc2V0KTsKKworCWhhbmRsZS0+b2Zmc2V0CT0gb2Zmc2V0OworCWhhbmRsZS0+aGVhZAk9IGhlYWQ7CisKKwlpZiAoaGVhZCAtIHRhaWwgPiBkYXRhLT53YXRlcm1hcmspCisJCWF0b21pY19zZXQoJmRhdGEtPndha2V1cCwgMSk7CisKKwlpZiAoaGF2ZV9sb3N0KSB7CisJCWxvc3RfZXZlbnQuaGVhZGVyLnR5cGUgPSBQRVJGX1JFQ09SRF9MT1NUOworCQlsb3N0X2V2ZW50LmhlYWRlci5taXNjID0gMDsKKwkJbG9zdF9ldmVudC5oZWFkZXIuc2l6ZSA9IHNpemVvZihsb3N0X2V2ZW50KTsKKwkJbG9zdF9ldmVudC5pZCAgICAgICAgICA9IGV2ZW50LT5pZDsKKwkJbG9zdF9ldmVudC5sb3N0ICAgICAgICA9IGF0b21pY194Y2hnKCZkYXRhLT5sb3N0LCAwKTsKKworCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBsb3N0X2V2ZW50KTsKKwl9CisKKwlyZXR1cm4gMDsKKworZmFpbDoKKwlhdG9taWNfaW5jKCZkYXRhLT5sb3N0KTsKKwlwZXJmX291dHB1dF91bmxvY2soaGFuZGxlKTsKK291dDoKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCXJldHVybiAtRU5PU1BDOworfQorCit2b2lkIHBlcmZfb3V0cHV0X2VuZChzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gaGFuZGxlLT5ldmVudDsKKwlzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBoYW5kbGUtPmRhdGE7CisKKwlpbnQgd2FrZXVwX2V2ZW50cyA9IGV2ZW50LT5hdHRyLndha2V1cF9ldmVudHM7CisKKwlpZiAoaGFuZGxlLT5zYW1wbGUgJiYgd2FrZXVwX2V2ZW50cykgeworCQlpbnQgZXZlbnRzID0gYXRvbWljX2luY19yZXR1cm4oJmRhdGEtPmV2ZW50cyk7CisJCWlmIChldmVudHMgPj0gd2FrZXVwX2V2ZW50cykgeworCQkJYXRvbWljX3N1Yih3YWtldXBfZXZlbnRzLCAmZGF0YS0+ZXZlbnRzKTsKKwkJCWF0b21pY19zZXQoJmRhdGEtPndha2V1cCwgMSk7CisJCX0KKwl9CisKKwlwZXJmX291dHB1dF91bmxvY2soaGFuZGxlKTsKKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIHUzMiBwZXJmX2V2ZW50X3BpZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHN0cnVjdCB0YXNrX3N0cnVjdCAqcCkKK3sKKwkvKgorCSAqIG9ubHkgdG9wIGxldmVsIGV2ZW50cyBoYXZlIHRoZSBwaWQgbmFtZXNwYWNlIHRoZXkgd2VyZSBjcmVhdGVkIGluCisJICovCisJaWYgKGV2ZW50LT5wYXJlbnQpCisJCWV2ZW50ID0gZXZlbnQtPnBhcmVudDsKKworCXJldHVybiB0YXNrX3RnaWRfbnJfbnMocCwgZXZlbnQtPm5zKTsKK30KKworc3RhdGljIHUzMiBwZXJmX2V2ZW50X3RpZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHN0cnVjdCB0YXNrX3N0cnVjdCAqcCkKK3sKKwkvKgorCSAqIG9ubHkgdG9wIGxldmVsIGV2ZW50cyBoYXZlIHRoZSBwaWQgbmFtZXNwYWNlIHRoZXkgd2VyZSBjcmVhdGVkIGluCisJICovCisJaWYgKGV2ZW50LT5wYXJlbnQpCisJCWV2ZW50ID0gZXZlbnQtPnBhcmVudDsKKworCXJldHVybiB0YXNrX3BpZF9ucl9ucyhwLCBldmVudC0+bnMpOworfQorCitzdGF0aWMgdm9pZCBwZXJmX291dHB1dF9yZWFkX29uZShzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCisJCQkJIHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwl1NjQgcmVhZF9mb3JtYXQgPSBldmVudC0+YXR0ci5yZWFkX2Zvcm1hdDsKKwl1NjQgdmFsdWVzWzRdOworCWludCBuID0gMDsKKworCXZhbHVlc1tuKytdID0gYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNvdW50KTsKKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX0VOQUJMRUQpIHsKKwkJdmFsdWVzW24rK10gPSBldmVudC0+dG90YWxfdGltZV9lbmFibGVkICsKKwkJCWF0b21pYzY0X3JlYWQoJmV2ZW50LT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOworCX0KKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkcpIHsKKwkJdmFsdWVzW24rK10gPSBldmVudC0+dG90YWxfdGltZV9ydW5uaW5nICsKKwkJCWF0b21pYzY0X3JlYWQoJmV2ZW50LT5jaGlsZF90b3RhbF90aW1lX3J1bm5pbmcpOworCX0KKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9JRCkKKwkJdmFsdWVzW24rK10gPSBwcmltYXJ5X2V2ZW50X2lkKGV2ZW50KTsKKworCXBlcmZfb3V0cHV0X2NvcHkoaGFuZGxlLCB2YWx1ZXMsIG4gKiBzaXplb2YodTY0KSk7Cit9CisKKy8qCisgKiBYWFggUEVSRl9GT1JNQVRfR1JPVVAgdnMgaW5oZXJpdGVkIGV2ZW50cyBzZWVtcyBkaWZmaWN1bHQuCisgKi8KK3N0YXRpYyB2b2lkIHBlcmZfb3V0cHV0X3JlYWRfZ3JvdXAoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlLAorCQkJICAgIHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyID0gZXZlbnQtPmdyb3VwX2xlYWRlciwgKnN1YjsKKwl1NjQgcmVhZF9mb3JtYXQgPSBldmVudC0+YXR0ci5yZWFkX2Zvcm1hdDsKKwl1NjQgdmFsdWVzWzVdOworCWludCBuID0gMDsKKworCXZhbHVlc1tuKytdID0gMSArIGxlYWRlci0+bnJfc2libGluZ3M7CisKKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX0VOQUJMRUQpCisJCXZhbHVlc1tuKytdID0gbGVhZGVyLT50b3RhbF90aW1lX2VuYWJsZWQ7CisKKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkcpCisJCXZhbHVlc1tuKytdID0gbGVhZGVyLT50b3RhbF90aW1lX3J1bm5pbmc7CisKKwlpZiAobGVhZGVyICE9IGV2ZW50KQorCQlsZWFkZXItPnBtdS0+cmVhZChsZWFkZXIpOworCisJdmFsdWVzW24rK10gPSBhdG9taWM2NF9yZWFkKCZsZWFkZXItPmNvdW50KTsKKwlpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9JRCkKKwkJdmFsdWVzW24rK10gPSBwcmltYXJ5X2V2ZW50X2lkKGxlYWRlcik7CisKKwlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgdmFsdWVzLCBuICogc2l6ZW9mKHU2NCkpOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpIHsKKwkJbiA9IDA7CisKKwkJaWYgKHN1YiAhPSBldmVudCkKKwkJCXN1Yi0+cG11LT5yZWFkKHN1Yik7CisKKwkJdmFsdWVzW24rK10gPSBhdG9taWM2NF9yZWFkKCZzdWItPmNvdW50KTsKKwkJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfSUQpCisJCQl2YWx1ZXNbbisrXSA9IHByaW1hcnlfZXZlbnRfaWQoc3ViKTsKKworCQlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgdmFsdWVzLCBuICogc2l6ZW9mKHU2NCkpOworCX0KK30KKworc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfcmVhZChzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCisJCQkgICAgIHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlpZiAoZXZlbnQtPmF0dHIucmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9HUk9VUCkKKwkJcGVyZl9vdXRwdXRfcmVhZF9ncm91cChoYW5kbGUsIGV2ZW50KTsKKwllbHNlCisJCXBlcmZfb3V0cHV0X3JlYWRfb25lKGhhbmRsZSwgZXZlbnQpOworfQorCit2b2lkIHBlcmZfb3V0cHV0X3NhbXBsZShzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCisJCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgKmhlYWRlciwKKwkJCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXU2NCBzYW1wbGVfdHlwZSA9IGRhdGEtPnR5cGU7CisKKwlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCAqaGVhZGVyKTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0lQKQorCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5pcCk7CisKKwlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9USUQpCisJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPnRpZF9lbnRyeSk7CisKKwlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9USU1FKQorCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT50aW1lKTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0FERFIpCisJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPmFkZHIpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSUQpCisJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPmlkKTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1NUUkVBTV9JRCkKKwkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+c3RyZWFtX2lkKTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0NQVSkKKwkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+Y3B1X2VudHJ5KTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1BFUklPRCkKKwkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+cGVyaW9kKTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JFQUQpCisJCXBlcmZfb3V0cHV0X3JlYWQoaGFuZGxlLCBldmVudCk7CisKKwlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9DQUxMQ0hBSU4pIHsKKwkJaWYgKGRhdGEtPmNhbGxjaGFpbikgeworCQkJaW50IHNpemUgPSAxOworCisJCQlpZiAoZGF0YS0+Y2FsbGNoYWluKQorCQkJCXNpemUgKz0gZGF0YS0+Y2FsbGNoYWluLT5ucjsKKworCQkJc2l6ZSAqPSBzaXplb2YodTY0KTsKKworCQkJcGVyZl9vdXRwdXRfY29weShoYW5kbGUsIGRhdGEtPmNhbGxjaGFpbiwgc2l6ZSk7CisJCX0gZWxzZSB7CisJCQl1NjQgbnIgPSAwOworCQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgbnIpOworCQl9CisJfQorCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkFXKSB7CisJCWlmIChkYXRhLT5yYXcpIHsKKwkJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPnJhdy0+c2l6ZSk7CisJCQlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgZGF0YS0+cmF3LT5kYXRhLAorCQkJCQkgZGF0YS0+cmF3LT5zaXplKTsKKwkJfSBlbHNlIHsKKwkJCXN0cnVjdCB7CisJCQkJdTMyCXNpemU7CisJCQkJdTMyCWRhdGE7CisJCQl9IHJhdyA9IHsKKwkJCQkuc2l6ZSA9IHNpemVvZih1MzIpLAorCQkJCS5kYXRhID0gMCwKKwkJCX07CisJCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCByYXcpOworCQl9CisJfQorfQorCit2b2lkIHBlcmZfcHJlcGFyZV9zYW1wbGUoc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyICpoZWFkZXIsCisJCQkgc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEsCisJCQkgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAorCQkJIHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXU2NCBzYW1wbGVfdHlwZSA9IGV2ZW50LT5hdHRyLnNhbXBsZV90eXBlOworCisJZGF0YS0+dHlwZSA9IHNhbXBsZV90eXBlOworCisJaGVhZGVyLT50eXBlID0gUEVSRl9SRUNPUkRfU0FNUExFOworCWhlYWRlci0+c2l6ZSA9IHNpemVvZigqaGVhZGVyKTsKKworCWhlYWRlci0+bWlzYyA9IDA7CisJaGVhZGVyLT5taXNjIHw9IHBlcmZfbWlzY19mbGFncyhyZWdzKTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0lQKSB7CisJCWRhdGEtPmlwID0gcGVyZl9pbnN0cnVjdGlvbl9wb2ludGVyKHJlZ3MpOworCisJCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+aXApOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJRCkgeworCQkvKiBuYW1lc3BhY2UgaXNzdWVzICovCisJCWRhdGEtPnRpZF9lbnRyeS5waWQgPSBwZXJmX2V2ZW50X3BpZChldmVudCwgY3VycmVudCk7CisJCWRhdGEtPnRpZF9lbnRyeS50aWQgPSBwZXJmX2V2ZW50X3RpZChldmVudCwgY3VycmVudCk7CisKKwkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT50aWRfZW50cnkpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJTUUpIHsKKwkJZGF0YS0+dGltZSA9IHBlcmZfY2xvY2soKTsKKworCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPnRpbWUpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0FERFIpCisJCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+YWRkcik7CisKKwlpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9JRCkgeworCQlkYXRhLT5pZCA9IHByaW1hcnlfZXZlbnRfaWQoZXZlbnQpOworCisJCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+aWQpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1NUUkVBTV9JRCkgeworCQlkYXRhLT5zdHJlYW1faWQgPSBldmVudC0+aWQ7CisKKwkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT5zdHJlYW1faWQpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0NQVSkgeworCQlkYXRhLT5jcHVfZW50cnkuY3B1CQk9IHJhd19zbXBfcHJvY2Vzc29yX2lkKCk7CisJCWRhdGEtPmNwdV9lbnRyeS5yZXNlcnZlZAk9IDA7CisKKwkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT5jcHVfZW50cnkpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1BFUklPRCkKKwkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT5wZXJpb2QpOworCisJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkVBRCkKKwkJaGVhZGVyLT5zaXplICs9IHBlcmZfZXZlbnRfcmVhZF9zaXplKGV2ZW50KTsKKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0NBTExDSEFJTikgeworCQlpbnQgc2l6ZSA9IDE7CisKKwkJZGF0YS0+Y2FsbGNoYWluID0gcGVyZl9jYWxsY2hhaW4ocmVncyk7CisKKwkJaWYgKGRhdGEtPmNhbGxjaGFpbikKKwkJCXNpemUgKz0gZGF0YS0+Y2FsbGNoYWluLT5ucjsKKworCQloZWFkZXItPnNpemUgKz0gc2l6ZSAqIHNpemVvZih1NjQpOworCX0KKworCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JBVykgeworCQlpbnQgc2l6ZSA9IHNpemVvZih1MzIpOworCisJCWlmIChkYXRhLT5yYXcpCisJCQlzaXplICs9IGRhdGEtPnJhdy0+c2l6ZTsKKwkJZWxzZQorCQkJc2l6ZSArPSBzaXplb2YodTMyKTsKKworCQlXQVJOX09OX09OQ0Uoc2l6ZSAmIChzaXplb2YodTY0KS0xKSk7CisJCWhlYWRlci0+c2l6ZSArPSBzaXplOworCX0KK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9vdXRwdXQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgbm1pLAorCQkJCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJCXN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciBoZWFkZXI7CisKKwlwZXJmX3ByZXBhcmVfc2FtcGxlKCZoZWFkZXIsIGRhdGEsIGV2ZW50LCByZWdzKTsKKworCWlmIChwZXJmX291dHB1dF9iZWdpbigmaGFuZGxlLCBldmVudCwgaGVhZGVyLnNpemUsIG5taSwgMSkpCisJCXJldHVybjsKKworCXBlcmZfb3V0cHV0X3NhbXBsZSgmaGFuZGxlLCAmaGVhZGVyLCBkYXRhLCBldmVudCk7CisKKwlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cit9CisKKy8qCisgKiByZWFkIGV2ZW50X2lkCisgKi8KKworc3RydWN0IHBlcmZfcmVhZF9ldmVudCB7CisJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKworCXUzMgkJCQlwaWQ7CisJdTMyCQkJCXRpZDsKK307CisKK3N0YXRpYyB2b2lkCitwZXJmX2V2ZW50X3JlYWRfZXZlbnQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAorCQkJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCXN0cnVjdCBwZXJmX3JlYWRfZXZlbnQgcmVhZF9ldmVudCA9IHsKKwkJLmhlYWRlciA9IHsKKwkJCS50eXBlID0gUEVSRl9SRUNPUkRfUkVBRCwKKwkJCS5taXNjID0gMCwKKwkJCS5zaXplID0gc2l6ZW9mKHJlYWRfZXZlbnQpICsgcGVyZl9ldmVudF9yZWFkX3NpemUoZXZlbnQpLAorCQl9LAorCQkucGlkID0gcGVyZl9ldmVudF9waWQoZXZlbnQsIHRhc2spLAorCQkudGlkID0gcGVyZl9ldmVudF90aWQoZXZlbnQsIHRhc2spLAorCX07CisJaW50IHJldDsKKworCXJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGV2ZW50LCByZWFkX2V2ZW50LmhlYWRlci5zaXplLCAwLCAwKTsKKwlpZiAocmV0KQorCQlyZXR1cm47CisKKwlwZXJmX291dHB1dF9wdXQoJmhhbmRsZSwgcmVhZF9ldmVudCk7CisJcGVyZl9vdXRwdXRfcmVhZCgmaGFuZGxlLCBldmVudCk7CisKKwlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cit9CisKKy8qCisgKiB0YXNrIHRyYWNraW5nIC0tIGZvcmsvZXhpdAorICoKKyAqIGVuYWJsZWQgYnk6IGF0dHIuY29tbSB8IGF0dHIubW1hcCB8IGF0dHIudGFzaworICovCisKK3N0cnVjdCBwZXJmX3Rhc2tfZXZlbnQgeworCXN0cnVjdCB0YXNrX3N0cnVjdAkJKnRhc2s7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dAkqdGFza19jdHg7CisKKwlzdHJ1Y3QgeworCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIJaGVhZGVyOworCisJCXUzMgkJCQlwaWQ7CisJCXUzMgkJCQlwcGlkOworCQl1MzIJCQkJdGlkOworCQl1MzIJCQkJcHRpZDsKKwkJdTY0CQkJCXRpbWU7CisJfSBldmVudF9pZDsKK307CisKK3N0YXRpYyB2b2lkIHBlcmZfZXZlbnRfdGFza19vdXRwdXQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAorCQkJCSAgICAgc3RydWN0IHBlcmZfdGFza19ldmVudCAqdGFza19ldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlIGhhbmRsZTsKKwlpbnQgc2l6ZTsKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2sgPSB0YXNrX2V2ZW50LT50YXNrOworCWludCByZXQ7CisKKwlzaXplICA9IHRhc2tfZXZlbnQtPmV2ZW50X2lkLmhlYWRlci5zaXplOworCXJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGV2ZW50LCBzaXplLCAwLCAwKTsKKworCWlmIChyZXQpCisJCXJldHVybjsKKworCXRhc2tfZXZlbnQtPmV2ZW50X2lkLnBpZCA9IHBlcmZfZXZlbnRfcGlkKGV2ZW50LCB0YXNrKTsKKwl0YXNrX2V2ZW50LT5ldmVudF9pZC5wcGlkID0gcGVyZl9ldmVudF9waWQoZXZlbnQsIGN1cnJlbnQpOworCisJdGFza19ldmVudC0+ZXZlbnRfaWQudGlkID0gcGVyZl9ldmVudF90aWQoZXZlbnQsIHRhc2spOworCXRhc2tfZXZlbnQtPmV2ZW50X2lkLnB0aWQgPSBwZXJmX2V2ZW50X3RpZChldmVudCwgY3VycmVudCk7CisKKwl0YXNrX2V2ZW50LT5ldmVudF9pZC50aW1lID0gcGVyZl9jbG9jaygpOworCisJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIHRhc2tfZXZlbnQtPmV2ZW50X2lkKTsKKworCXBlcmZfb3V0cHV0X2VuZCgmaGFuZGxlKTsKK30KKworc3RhdGljIGludCBwZXJmX2V2ZW50X3Rhc2tfbWF0Y2goc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCWlmIChldmVudC0+YXR0ci5jb21tIHx8IGV2ZW50LT5hdHRyLm1tYXAgfHwgZXZlbnQtPmF0dHIudGFzaykKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF90YXNrX2N0eChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCQkJICBzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50ICp0YXNrX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKworCWlmIChzeXN0ZW1fc3RhdGUgIT0gU1lTVEVNX1JVTk5JTkcgfHwgbGlzdF9lbXB0eSgmY3R4LT5ldmVudF9saXN0KSkKKwkJcmV0dXJuOworCisJcmN1X3JlYWRfbG9jaygpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGV2ZW50LCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkgeworCQlpZiAocGVyZl9ldmVudF90YXNrX21hdGNoKGV2ZW50KSkKKwkJCXBlcmZfZXZlbnRfdGFza19vdXRwdXQoZXZlbnQsIHRhc2tfZXZlbnQpOworCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF90YXNrX2V2ZW50KHN0cnVjdCBwZXJmX3Rhc2tfZXZlbnQgKnRhc2tfZXZlbnQpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSB0YXNrX2V2ZW50LT50YXNrX2N0eDsKKworCWNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlwZXJmX2V2ZW50X3Rhc2tfY3R4KCZjcHVjdHgtPmN0eCwgdGFza19ldmVudCk7CisJcHV0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJaWYgKCFjdHgpCisJCWN0eCA9IHJjdV9kZXJlZmVyZW5jZSh0YXNrX2V2ZW50LT50YXNrLT5wZXJmX2V2ZW50X2N0eHApOworCWlmIChjdHgpCisJCXBlcmZfZXZlbnRfdGFza19jdHgoY3R4LCB0YXNrX2V2ZW50KTsKKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywKKwkJCSAgICAgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnRhc2tfY3R4LAorCQkJICAgICAgaW50IG5ldykKK3sKKwlzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50IHRhc2tfZXZlbnQ7CisKKwlpZiAoIWF0b21pY19yZWFkKCZucl9jb21tX2V2ZW50cykgJiYKKwkgICAgIWF0b21pY19yZWFkKCZucl9tbWFwX2V2ZW50cykgJiYKKwkgICAgIWF0b21pY19yZWFkKCZucl90YXNrX2V2ZW50cykpCisJCXJldHVybjsKKworCXRhc2tfZXZlbnQgPSAoc3RydWN0IHBlcmZfdGFza19ldmVudCl7CisJCS50YXNrCSAgPSB0YXNrLAorCQkudGFza19jdHggPSB0YXNrX2N0eCwKKwkJLmV2ZW50X2lkICAgID0geworCQkJLmhlYWRlciA9IHsKKwkJCQkudHlwZSA9IG5ldyA/IFBFUkZfUkVDT1JEX0ZPUksgOiBQRVJGX1JFQ09SRF9FWElULAorCQkJCS5taXNjID0gMCwKKwkJCQkuc2l6ZSA9IHNpemVvZih0YXNrX2V2ZW50LmV2ZW50X2lkKSwKKwkJCX0sCisJCQkvKiAucGlkICAqLworCQkJLyogLnBwaWQgKi8KKwkJCS8qIC50aWQgICovCisJCQkvKiAucHRpZCAqLworCQl9LAorCX07CisKKwlwZXJmX2V2ZW50X3Rhc2tfZXZlbnQoJnRhc2tfZXZlbnQpOworfQorCit2b2lkIHBlcmZfZXZlbnRfZm9yayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJcGVyZl9ldmVudF90YXNrKHRhc2ssIE5VTEwsIDEpOworfQorCisvKgorICogY29tbSB0cmFja2luZworICovCisKK3N0cnVjdCBwZXJmX2NvbW1fZXZlbnQgeworCXN0cnVjdCB0YXNrX3N0cnVjdAkqdGFzazsKKwljaGFyCQkJKmNvbW07CisJaW50CQkJY29tbV9zaXplOworCisJc3RydWN0IHsKKwkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKworCQl1MzIJCQkJcGlkOworCQl1MzIJCQkJdGlkOworCX0gZXZlbnRfaWQ7Cit9OworCitzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2NvbW1fb3V0cHV0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJCQkgICAgIHN0cnVjdCBwZXJmX2NvbW1fZXZlbnQgKmNvbW1fZXZlbnQpCit7CisJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CisJaW50IHNpemUgPSBjb21tX2V2ZW50LT5ldmVudF9pZC5oZWFkZXIuc2l6ZTsKKwlpbnQgcmV0ID0gcGVyZl9vdXRwdXRfYmVnaW4oJmhhbmRsZSwgZXZlbnQsIHNpemUsIDAsIDApOworCisJaWYgKHJldCkKKwkJcmV0dXJuOworCisJY29tbV9ldmVudC0+ZXZlbnRfaWQucGlkID0gcGVyZl9ldmVudF9waWQoZXZlbnQsIGNvbW1fZXZlbnQtPnRhc2spOworCWNvbW1fZXZlbnQtPmV2ZW50X2lkLnRpZCA9IHBlcmZfZXZlbnRfdGlkKGV2ZW50LCBjb21tX2V2ZW50LT50YXNrKTsKKworCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCBjb21tX2V2ZW50LT5ldmVudF9pZCk7CisJcGVyZl9vdXRwdXRfY29weSgmaGFuZGxlLCBjb21tX2V2ZW50LT5jb21tLAorCQkJCSAgIGNvbW1fZXZlbnQtPmNvbW1fc2l6ZSk7CisJcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOworfQorCitzdGF0aWMgaW50IHBlcmZfZXZlbnRfY29tbV9tYXRjaChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJaWYgKGV2ZW50LT5hdHRyLmNvbW0pCisJCXJldHVybiAxOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfZXZlbnRfY29tbV9jdHgoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAorCQkJCSAgc3RydWN0IHBlcmZfY29tbV9ldmVudCAqY29tbV9ldmVudCkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CisKKwlpZiAoc3lzdGVtX3N0YXRlICE9IFNZU1RFTV9SVU5OSU5HIHx8IGxpc3RfZW1wdHkoJmN0eC0+ZXZlbnRfbGlzdCkpCisJCXJldHVybjsKKworCXJjdV9yZWFkX2xvY2soKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShldmVudCwgJmN0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKKwkJaWYgKHBlcmZfZXZlbnRfY29tbV9tYXRjaChldmVudCkpCisJCQlwZXJmX2V2ZW50X2NvbW1fb3V0cHV0KGV2ZW50LCBjb21tX2V2ZW50KTsKKwl9CisJcmN1X3JlYWRfdW5sb2NrKCk7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfZXZlbnRfY29tbV9ldmVudChzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50ICpjb21tX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4OworCXVuc2lnbmVkIGludCBzaXplOworCWNoYXIgY29tbVtUQVNLX0NPTU1fTEVOXTsKKworCW1lbXNldChjb21tLCAwLCBzaXplb2YoY29tbSkpOworCXN0cm5jcHkoY29tbSwgY29tbV9ldmVudC0+dGFzay0+Y29tbSwgc2l6ZW9mKGNvbW0pKTsKKwlzaXplID0gQUxJR04oc3RybGVuKGNvbW0pKzEsIHNpemVvZih1NjQpKTsKKworCWNvbW1fZXZlbnQtPmNvbW0gPSBjb21tOworCWNvbW1fZXZlbnQtPmNvbW1fc2l6ZSA9IHNpemU7CisKKwljb21tX2V2ZW50LT5ldmVudF9pZC5oZWFkZXIuc2l6ZSA9IHNpemVvZihjb21tX2V2ZW50LT5ldmVudF9pZCkgKyBzaXplOworCisJY3B1Y3R4ID0gJmdldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCXBlcmZfZXZlbnRfY29tbV9jdHgoJmNwdWN0eC0+Y3R4LCBjb21tX2V2ZW50KTsKKwlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKworCXJjdV9yZWFkX2xvY2soKTsKKwkvKgorCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCisJICogZXZlbnRzIGVuZHMgdXAgaW4uCisJICovCisJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfZXZlbnRfY3R4cCk7CisJaWYgKGN0eCkKKwkJcGVyZl9ldmVudF9jb21tX2N0eChjdHgsIGNvbW1fZXZlbnQpOworCXJjdV9yZWFkX3VubG9jaygpOworfQorCit2b2lkIHBlcmZfZXZlbnRfY29tbShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJc3RydWN0IHBlcmZfY29tbV9ldmVudCBjb21tX2V2ZW50OworCisJaWYgKHRhc2stPnBlcmZfZXZlbnRfY3R4cCkKKwkJcGVyZl9ldmVudF9lbmFibGVfb25fZXhlYyh0YXNrKTsKKworCWlmICghYXRvbWljX3JlYWQoJm5yX2NvbW1fZXZlbnRzKSkKKwkJcmV0dXJuOworCisJY29tbV9ldmVudCA9IChzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50KXsKKwkJLnRhc2sJPSB0YXNrLAorCQkvKiAuY29tbSAgICAgICovCisJCS8qIC5jb21tX3NpemUgKi8KKwkJLmV2ZW50X2lkICA9IHsKKwkJCS5oZWFkZXIgPSB7CisJCQkJLnR5cGUgPSBQRVJGX1JFQ09SRF9DT01NLAorCQkJCS5taXNjID0gMCwKKwkJCQkvKiAuc2l6ZSAqLworCQkJfSwKKwkJCS8qIC5waWQgKi8KKwkJCS8qIC50aWQgKi8KKwkJfSwKKwl9OworCisJcGVyZl9ldmVudF9jb21tX2V2ZW50KCZjb21tX2V2ZW50KTsKK30KKworLyoKKyAqIG1tYXAgdHJhY2tpbmcKKyAqLworCitzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50IHsKKwlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QJKnZtYTsKKworCWNvbnN0IGNoYXIJCSpmaWxlX25hbWU7CisJaW50CQkJZmlsZV9zaXplOworCisJc3RydWN0IHsKKwkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKKworCQl1MzIJCQkJcGlkOworCQl1MzIJCQkJdGlkOworCQl1NjQJCQkJc3RhcnQ7CisJCXU2NAkJCQlsZW47CisJCXU2NAkJCQlwZ29mZjsKKwl9IGV2ZW50X2lkOworfTsKKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9tbWFwX291dHB1dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkJICAgICBzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50ICptbWFwX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOworCWludCBzaXplID0gbW1hcF9ldmVudC0+ZXZlbnRfaWQuaGVhZGVyLnNpemU7CisJaW50IHJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGV2ZW50LCBzaXplLCAwLCAwKTsKKworCWlmIChyZXQpCisJCXJldHVybjsKKworCW1tYXBfZXZlbnQtPmV2ZW50X2lkLnBpZCA9IHBlcmZfZXZlbnRfcGlkKGV2ZW50LCBjdXJyZW50KTsKKwltbWFwX2V2ZW50LT5ldmVudF9pZC50aWQgPSBwZXJmX2V2ZW50X3RpZChldmVudCwgY3VycmVudCk7CisKKwlwZXJmX291dHB1dF9wdXQoJmhhbmRsZSwgbW1hcF9ldmVudC0+ZXZlbnRfaWQpOworCXBlcmZfb3V0cHV0X2NvcHkoJmhhbmRsZSwgbW1hcF9ldmVudC0+ZmlsZV9uYW1lLAorCQkJCSAgIG1tYXBfZXZlbnQtPmZpbGVfc2l6ZSk7CisJcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOworfQorCitzdGF0aWMgaW50IHBlcmZfZXZlbnRfbW1hcF9tYXRjaChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkJICAgc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKK3sKKwlpZiAoZXZlbnQtPmF0dHIubW1hcCkKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9tbWFwX2N0eChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCQkJICBzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50ICptbWFwX2V2ZW50KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKworCWlmIChzeXN0ZW1fc3RhdGUgIT0gU1lTVEVNX1JVTk5JTkcgfHwgbGlzdF9lbXB0eSgmY3R4LT5ldmVudF9saXN0KSkKKwkJcmV0dXJuOworCisJcmN1X3JlYWRfbG9jaygpOworCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGV2ZW50LCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkgeworCQlpZiAocGVyZl9ldmVudF9tbWFwX21hdGNoKGV2ZW50LCBtbWFwX2V2ZW50KSkKKwkJCXBlcmZfZXZlbnRfbW1hcF9vdXRwdXQoZXZlbnQsIG1tYXBfZXZlbnQpOworCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9ldmVudF9tbWFwX2V2ZW50KHN0cnVjdCBwZXJmX21tYXBfZXZlbnQgKm1tYXBfZXZlbnQpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7CisJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEgPSBtbWFwX2V2ZW50LT52bWE7CisJc3RydWN0IGZpbGUgKmZpbGUgPSB2bWEtPnZtX2ZpbGU7CisJdW5zaWduZWQgaW50IHNpemU7CisJY2hhciB0bXBbMTZdOworCWNoYXIgKmJ1ZiA9IE5VTEw7CisJY29uc3QgY2hhciAqbmFtZTsKKworCW1lbXNldCh0bXAsIDAsIHNpemVvZih0bXApKTsKKworCWlmIChmaWxlKSB7CisJCS8qCisJCSAqIGRfcGF0aCB3b3JrcyBmcm9tIHRoZSBlbmQgb2YgdGhlIGJ1ZmZlciBiYWNrd2FyZHMsIHNvIHdlCisJCSAqIG5lZWQgdG8gYWRkIGVub3VnaCB6ZXJvIGJ5dGVzIGFmdGVyIHRoZSBzdHJpbmcgdG8gaGFuZGxlCisJCSAqIHRoZSA2NGJpdCBhbGlnbm1lbnQgd2UgZG8gbGF0ZXIuCisJCSAqLworCQlidWYgPSBremFsbG9jKFBBVEhfTUFYICsgc2l6ZW9mKHU2NCksIEdGUF9LRVJORUwpOworCQlpZiAoIWJ1ZikgeworCQkJbmFtZSA9IHN0cm5jcHkodG1wLCAiLy9lbm9tZW0iLCBzaXplb2YodG1wKSk7CisJCQlnb3RvIGdvdF9uYW1lOworCQl9CisJCW5hbWUgPSBkX3BhdGgoJmZpbGUtPmZfcGF0aCwgYnVmLCBQQVRIX01BWCk7CisJCWlmIChJU19FUlIobmFtZSkpIHsKKwkJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vdG9vbG9uZyIsIHNpemVvZih0bXApKTsKKwkJCWdvdG8gZ290X25hbWU7CisJCX0KKwl9IGVsc2UgeworCQlpZiAoYXJjaF92bWFfbmFtZShtbWFwX2V2ZW50LT52bWEpKSB7CisJCQluYW1lID0gc3RybmNweSh0bXAsIGFyY2hfdm1hX25hbWUobW1hcF9ldmVudC0+dm1hKSwKKwkJCQkgICAgICAgc2l6ZW9mKHRtcCkpOworCQkJZ290byBnb3RfbmFtZTsKKwkJfQorCisJCWlmICghdm1hLT52bV9tbSkgeworCQkJbmFtZSA9IHN0cm5jcHkodG1wLCAiW3Zkc29dIiwgc2l6ZW9mKHRtcCkpOworCQkJZ290byBnb3RfbmFtZTsKKwkJfQorCisJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vYW5vbiIsIHNpemVvZih0bXApKTsKKwkJZ290byBnb3RfbmFtZTsKKwl9CisKK2dvdF9uYW1lOgorCXNpemUgPSBBTElHTihzdHJsZW4obmFtZSkrMSwgc2l6ZW9mKHU2NCkpOworCisJbW1hcF9ldmVudC0+ZmlsZV9uYW1lID0gbmFtZTsKKwltbWFwX2V2ZW50LT5maWxlX3NpemUgPSBzaXplOworCisJbW1hcF9ldmVudC0+ZXZlbnRfaWQuaGVhZGVyLnNpemUgPSBzaXplb2YobW1hcF9ldmVudC0+ZXZlbnRfaWQpICsgc2l6ZTsKKworCWNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKKwlwZXJmX2V2ZW50X21tYXBfY3R4KCZjcHVjdHgtPmN0eCwgbW1hcF9ldmVudCk7CisJcHV0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJLyoKKwkgKiBkb2Vzbid0IHJlYWxseSBtYXR0ZXIgd2hpY2ggb2YgdGhlIGNoaWxkIGNvbnRleHRzIHRoZQorCSAqIGV2ZW50cyBlbmRzIHVwIGluLgorCSAqLworCWN0eCA9IHJjdV9kZXJlZmVyZW5jZShjdXJyZW50LT5wZXJmX2V2ZW50X2N0eHApOworCWlmIChjdHgpCisJCXBlcmZfZXZlbnRfbW1hcF9jdHgoY3R4LCBtbWFwX2V2ZW50KTsKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCWtmcmVlKGJ1Zik7Cit9CisKK3ZvaWQgX19wZXJmX2V2ZW50X21tYXAoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IHBlcmZfbW1hcF9ldmVudCBtbWFwX2V2ZW50OworCisJaWYgKCFhdG9taWNfcmVhZCgmbnJfbW1hcF9ldmVudHMpKQorCQlyZXR1cm47CisKKwltbWFwX2V2ZW50ID0gKHN0cnVjdCBwZXJmX21tYXBfZXZlbnQpeworCQkudm1hCT0gdm1hLAorCQkvKiAuZmlsZV9uYW1lICovCisJCS8qIC5maWxlX3NpemUgKi8KKwkJLmV2ZW50X2lkICA9IHsKKwkJCS5oZWFkZXIgPSB7CisJCQkJLnR5cGUgPSBQRVJGX1JFQ09SRF9NTUFQLAorCQkJCS5taXNjID0gMCwKKwkJCQkvKiAuc2l6ZSAqLworCQkJfSwKKwkJCS8qIC5waWQgKi8KKwkJCS8qIC50aWQgKi8KKwkJCS5zdGFydCAgPSB2bWEtPnZtX3N0YXJ0LAorCQkJLmxlbiAgICA9IHZtYS0+dm1fZW5kIC0gdm1hLT52bV9zdGFydCwKKwkJCS5wZ29mZiAgPSB2bWEtPnZtX3Bnb2ZmLAorCQl9LAorCX07CisKKwlwZXJmX2V2ZW50X21tYXBfZXZlbnQoJm1tYXBfZXZlbnQpOworfQorCisvKgorICogSVJRIHRocm90dGxlIGxvZ2dpbmcKKyAqLworCitzdGF0aWMgdm9pZCBwZXJmX2xvZ190aHJvdHRsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBlbmFibGUpCit7CisJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CisJaW50IHJldDsKKworCXN0cnVjdCB7CisJCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CisJCXU2NAkJCQl0aW1lOworCQl1NjQJCQkJaWQ7CisJCXU2NAkJCQlzdHJlYW1faWQ7CisJfSB0aHJvdHRsZV9ldmVudCA9IHsKKwkJLmhlYWRlciA9IHsKKwkJCS50eXBlID0gUEVSRl9SRUNPUkRfVEhST1RUTEUsCisJCQkubWlzYyA9IDAsCisJCQkuc2l6ZSA9IHNpemVvZih0aHJvdHRsZV9ldmVudCksCisJCX0sCisJCS50aW1lCQk9IHBlcmZfY2xvY2soKSwKKwkJLmlkCQk9IHByaW1hcnlfZXZlbnRfaWQoZXZlbnQpLAorCQkuc3RyZWFtX2lkCT0gZXZlbnQtPmlkLAorCX07CisKKwlpZiAoZW5hYmxlKQorCQl0aHJvdHRsZV9ldmVudC5oZWFkZXIudHlwZSA9IFBFUkZfUkVDT1JEX1VOVEhST1RUTEU7CisKKwlyZXQgPSBwZXJmX291dHB1dF9iZWdpbigmaGFuZGxlLCBldmVudCwgc2l6ZW9mKHRocm90dGxlX2V2ZW50KSwgMSwgMCk7CisJaWYgKHJldCkKKwkJcmV0dXJuOworCisJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIHRocm90dGxlX2V2ZW50KTsKKwlwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cit9CisKKy8qCisgKiBHZW5lcmljIGV2ZW50IG92ZXJmbG93IGhhbmRsaW5nLCBzYW1wbGluZy4KKyAqLworCitzdGF0aWMgaW50IF9fcGVyZl9ldmVudF9vdmVyZmxvdyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBubWksCisJCQkJICAgaW50IHRocm90dGxlLCBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKKwkJCQkgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlpbnQgZXZlbnRzID0gYXRvbWljX3JlYWQoJmV2ZW50LT5ldmVudF9saW1pdCk7CisJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CisJaW50IHJldCA9IDA7CisKKwl0aHJvdHRsZSA9ICh0aHJvdHRsZSAmJiBldmVudC0+cG11LT51bnRocm90dGxlICE9IE5VTEwpOworCisJaWYgKCF0aHJvdHRsZSkgeworCQlod2MtPmludGVycnVwdHMrKzsKKwl9IGVsc2UgeworCQlpZiAoaHdjLT5pbnRlcnJ1cHRzICE9IE1BWF9JTlRFUlJVUFRTKSB7CisJCQlod2MtPmludGVycnVwdHMrKzsKKwkJCWlmIChIWiAqIGh3Yy0+aW50ZXJydXB0cyA+CisJCQkJCSh1NjQpc3lzY3RsX3BlcmZfZXZlbnRfc2FtcGxlX3JhdGUpIHsKKwkJCQlod2MtPmludGVycnVwdHMgPSBNQVhfSU5URVJSVVBUUzsKKwkJCQlwZXJmX2xvZ190aHJvdHRsZShldmVudCwgMCk7CisJCQkJcmV0ID0gMTsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBLZWVwIHJlLWRpc2FibGluZyBldmVudHMgZXZlbiB0aG91Z2ggb24gdGhlIHByZXZpb3VzCisJCQkgKiBwYXNzIHdlIGRpc2FibGVkIGl0IC0ganVzdCBpbiBjYXNlIHdlIHJhY2VkIHdpdGggYQorCQkJICogc2NoZWQtaW4gYW5kIHRoZSBldmVudCBnb3QgZW5hYmxlZCBhZ2FpbjoKKwkJCSAqLworCQkJcmV0ID0gMTsKKwkJfQorCX0KKworCWlmIChldmVudC0+YXR0ci5mcmVxKSB7CisJCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7CisJCXM2NCBkZWx0YSA9IG5vdyAtIGh3Yy0+ZnJlcV9zdGFtcDsKKworCQlod2MtPmZyZXFfc3RhbXAgPSBub3c7CisKKwkJaWYgKGRlbHRhID4gMCAmJiBkZWx0YSA8IFRJQ0tfTlNFQykKKwkJCXBlcmZfYWRqdXN0X3BlcmlvZChldmVudCwgTlNFQ19QRVJfU0VDIC8gKGludClkZWx0YSk7CisJfQorCisJLyoKKwkgKiBYWFggZXZlbnRfbGltaXQgbWlnaHQgbm90IHF1aXRlIHdvcmsgYXMgZXhwZWN0ZWQgb24gaW5oZXJpdGVkCisJICogZXZlbnRzCisJICovCisKKwlldmVudC0+cGVuZGluZ19raWxsID0gUE9MTF9JTjsKKwlpZiAoZXZlbnRzICYmIGF0b21pY19kZWNfYW5kX3Rlc3QoJmV2ZW50LT5ldmVudF9saW1pdCkpIHsKKwkJcmV0ID0gMTsKKwkJZXZlbnQtPnBlbmRpbmdfa2lsbCA9IFBPTExfSFVQOworCQlpZiAobm1pKSB7CisJCQlldmVudC0+cGVuZGluZ19kaXNhYmxlID0gMTsKKwkJCXBlcmZfcGVuZGluZ19xdWV1ZSgmZXZlbnQtPnBlbmRpbmcsCisJCQkJCSAgIHBlcmZfcGVuZGluZ19ldmVudCk7CisJCX0gZWxzZQorCQkJcGVyZl9ldmVudF9kaXNhYmxlKGV2ZW50KTsKKwl9CisKKwlwZXJmX2V2ZW50X291dHB1dChldmVudCwgbm1pLCBkYXRhLCByZWdzKTsKKwlyZXR1cm4gcmV0OworfQorCitpbnQgcGVyZl9ldmVudF9vdmVyZmxvdyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBubWksCisJCQkgIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlyZXR1cm4gX19wZXJmX2V2ZW50X292ZXJmbG93KGV2ZW50LCBubWksIDEsIGRhdGEsIHJlZ3MpOworfQorCisvKgorICogR2VuZXJpYyBzb2Z0d2FyZSBldmVudCBpbmZyYXN0cnVjdHVyZQorICovCisKKy8qCisgKiBXZSBkaXJlY3RseSBpbmNyZW1lbnQgZXZlbnQtPmNvdW50IGFuZCBrZWVwIGEgc2Vjb25kIHZhbHVlIGluCisgKiBldmVudC0+aHcucGVyaW9kX2xlZnQgdG8gY291bnQgaW50ZXJ2YWxzLiBUaGlzIHBlcmlvZCBldmVudAorICogaXMga2VwdCBpbiB0aGUgcmFuZ2UgWy1zYW1wbGVfcGVyaW9kLCAwXSBzbyB0aGF0IHdlIGNhbiB1c2UgdGhlCisgKiBzaWduIGFzIHRyaWdnZXIuCisgKi8KKworc3RhdGljIHU2NCBwZXJmX3N3ZXZlbnRfc2V0X3BlcmlvZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CisJdTY0IHBlcmlvZCA9IGh3Yy0+bGFzdF9wZXJpb2Q7CisJdTY0IG5yLCBvZmZzZXQ7CisJczY0IG9sZCwgdmFsOworCisJaHdjLT5sYXN0X3BlcmlvZCA9IGh3Yy0+c2FtcGxlX3BlcmlvZDsKKworYWdhaW46CisJb2xkID0gdmFsID0gYXRvbWljNjRfcmVhZCgmaHdjLT5wZXJpb2RfbGVmdCk7CisJaWYgKHZhbCA8IDApCisJCXJldHVybiAwOworCisJbnIgPSBkaXY2NF91NjQocGVyaW9kICsgdmFsLCBwZXJpb2QpOworCW9mZnNldCA9IG5yICogcGVyaW9kOworCXZhbCAtPSBvZmZzZXQ7CisJaWYgKGF0b21pYzY0X2NtcHhjaGcoJmh3Yy0+cGVyaW9kX2xlZnQsIG9sZCwgdmFsKSAhPSBvbGQpCisJCWdvdG8gYWdhaW47CisKKwlyZXR1cm4gbnI7Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfc3dldmVudF9vdmVyZmxvdyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCisJCQkJICAgIGludCBubWksIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJCSAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlzdHJ1Y3QgaHdfcGVyZl9ldmVudCAqaHdjID0gJmV2ZW50LT5odzsKKwlpbnQgdGhyb3R0bGUgPSAwOworCXU2NCBvdmVyZmxvdzsKKworCWRhdGEtPnBlcmlvZCA9IGV2ZW50LT5ody5sYXN0X3BlcmlvZDsKKwlvdmVyZmxvdyA9IHBlcmZfc3dldmVudF9zZXRfcGVyaW9kKGV2ZW50KTsKKworCWlmIChod2MtPmludGVycnVwdHMgPT0gTUFYX0lOVEVSUlVQVFMpCisJCXJldHVybjsKKworCWZvciAoOyBvdmVyZmxvdzsgb3ZlcmZsb3ctLSkgeworCQlpZiAoX19wZXJmX2V2ZW50X292ZXJmbG93KGV2ZW50LCBubWksIHRocm90dGxlLAorCQkJCQkgICAgZGF0YSwgcmVncykpIHsKKwkJCS8qCisJCQkgKiBXZSBpbmhpYml0IHRoZSBvdmVyZmxvdyBmcm9tIGhhcHBlbmluZyB3aGVuCisJCQkgKiBod2MtPmludGVycnVwdHMgPT0gTUFYX0lOVEVSUlVQVFMuCisJCQkgKi8KKwkJCWJyZWFrOworCQl9CisJCXRocm90dGxlID0gMTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHBlcmZfc3dldmVudF91bnRocm90dGxlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwkvKgorCSAqIE5vdGhpbmcgdG8gZG8sIHdlIGFscmVhZHkgcmVzZXQgaHdjLT5pbnRlcnJ1cHRzLgorCSAqLworfQorCitzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfYWRkKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0IG5yLAorCQkJICAgICAgIGludCBubWksIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJICAgICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzKQoreworCXN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3OworCisJYXRvbWljNjRfYWRkKG5yLCAmZXZlbnQtPmNvdW50KTsKKworCWlmICghaHdjLT5zYW1wbGVfcGVyaW9kKQorCQlyZXR1cm47CisKKwlpZiAoIXJlZ3MpCisJCXJldHVybjsKKworCWlmICghYXRvbWljNjRfYWRkX25lZ2F0aXZlKG5yLCAmaHdjLT5wZXJpb2RfbGVmdCkpCisJCXBlcmZfc3dldmVudF9vdmVyZmxvdyhldmVudCwgbm1pLCBkYXRhLCByZWdzKTsKK30KKworc3RhdGljIGludCBwZXJmX3N3ZXZlbnRfaXNfY291bnRpbmcoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCS8qCisJICogVGhlIGV2ZW50IGlzIGFjdGl2ZSwgd2UncmUgZ29vZCEKKwkgKi8KKwlpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQorCQlyZXR1cm4gMTsKKworCS8qCisJICogVGhlIGV2ZW50IGlzIG9mZi9lcnJvciwgbm90IGNvdW50aW5nLgorCSAqLworCWlmIChldmVudC0+c3RhdGUgIT0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKKwkJcmV0dXJuIDA7CisKKwkvKgorCSAqIFRoZSBldmVudCBpcyBpbmFjdGl2ZSwgaWYgdGhlIGNvbnRleHQgaXMgYWN0aXZlCisJICogd2UncmUgcGFydCBvZiBhIGdyb3VwIHRoYXQgZGlkbid0IG1ha2UgaXQgb24gdGhlICdwbXUnLAorCSAqIG5vdCBjb3VudGluZy4KKwkgKi8KKwlpZiAoZXZlbnQtPmN0eC0+aXNfYWN0aXZlKQorCQlyZXR1cm4gMDsKKworCS8qCisJICogV2UncmUgaW5hY3RpdmUgYW5kIHRoZSBjb250ZXh0IGlzIHRvbywgdGhpcyBtZWFucyB0aGUKKwkgKiB0YXNrIGlzIHNjaGVkdWxlZCBvdXQsIHdlJ3JlIGNvdW50aW5nIGV2ZW50cyB0aGF0IGhhcHBlbgorCSAqIHRvIHVzLCBsaWtlIG1pZ3JhdGlvbiBldmVudHMuCisJICovCisJcmV0dXJuIDE7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9zd2V2ZW50X21hdGNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKKwkJCQllbnVtIHBlcmZfdHlwZV9pZCB0eXBlLAorCQkJCXUzMiBldmVudF9pZCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJaWYgKCFwZXJmX3N3ZXZlbnRfaXNfY291bnRpbmcoZXZlbnQpKQorCQlyZXR1cm4gMDsKKworCWlmIChldmVudC0+YXR0ci50eXBlICE9IHR5cGUpCisJCXJldHVybiAwOworCWlmIChldmVudC0+YXR0ci5jb25maWcgIT0gZXZlbnRfaWQpCisJCXJldHVybiAwOworCisJaWYgKHJlZ3MpIHsKKwkJaWYgKGV2ZW50LT5hdHRyLmV4Y2x1ZGVfdXNlciAmJiB1c2VyX21vZGUocmVncykpCisJCQlyZXR1cm4gMDsKKworCQlpZiAoZXZlbnQtPmF0dHIuZXhjbHVkZV9rZXJuZWwgJiYgIXVzZXJfbW9kZShyZWdzKSkKKwkJCXJldHVybiAwOworCX0KKworCXJldHVybiAxOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfY3R4X2V2ZW50KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKKwkJCQkgICAgIGVudW0gcGVyZl90eXBlX2lkIHR5cGUsCisJCQkJICAgICB1MzIgZXZlbnRfaWQsIHU2NCBuciwgaW50IG5taSwKKwkJCQkgICAgIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJCSAgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCisJaWYgKHN5c3RlbV9zdGF0ZSAhPSBTWVNURU1fUlVOTklORyB8fCBsaXN0X2VtcHR5KCZjdHgtPmV2ZW50X2xpc3QpKQorCQlyZXR1cm47CisKKwlyY3VfcmVhZF9sb2NrKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoZXZlbnQsICZjdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7CisJCWlmIChwZXJmX3N3ZXZlbnRfbWF0Y2goZXZlbnQsIHR5cGUsIGV2ZW50X2lkLCByZWdzKSkKKwkJCXBlcmZfc3dldmVudF9hZGQoZXZlbnQsIG5yLCBubWksIGRhdGEsIHJlZ3MpOworCX0KKwlyY3VfcmVhZF91bmxvY2soKTsKK30KKworc3RhdGljIGludCAqcGVyZl9zd2V2ZW50X3JlY3Vyc2lvbl9jb250ZXh0KHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgpCit7CisJaWYgKGluX25taSgpKQorCQlyZXR1cm4gJmNwdWN0eC0+cmVjdXJzaW9uWzNdOworCisJaWYgKGluX2lycSgpKQorCQlyZXR1cm4gJmNwdWN0eC0+cmVjdXJzaW9uWzJdOworCisJaWYgKGluX3NvZnRpcnEoKSkKKwkJcmV0dXJuICZjcHVjdHgtPnJlY3Vyc2lvblsxXTsKKworCXJldHVybiAmY3B1Y3R4LT5yZWN1cnNpb25bMF07Cit9CisKK3N0YXRpYyB2b2lkIGRvX3BlcmZfc3dfZXZlbnQoZW51bSBwZXJmX3R5cGVfaWQgdHlwZSwgdTMyIGV2ZW50X2lkLAorCQkJCSAgICB1NjQgbnIsIGludCBubWksCisJCQkJICAgIHN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAorCQkJCSAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJmdldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOworCWludCAqcmVjdXJzaW9uID0gcGVyZl9zd2V2ZW50X3JlY3Vyc2lvbl9jb250ZXh0KGNwdWN0eCk7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4OworCisJaWYgKCpyZWN1cnNpb24pCisJCWdvdG8gb3V0OworCisJKCpyZWN1cnNpb24pKys7CisJYmFycmllcigpOworCisJcGVyZl9zd2V2ZW50X2N0eF9ldmVudCgmY3B1Y3R4LT5jdHgsIHR5cGUsIGV2ZW50X2lkLAorCQkJCSBuciwgbm1pLCBkYXRhLCByZWdzKTsKKwlyY3VfcmVhZF9sb2NrKCk7CisJLyoKKwkgKiBkb2Vzbid0IHJlYWxseSBtYXR0ZXIgd2hpY2ggb2YgdGhlIGNoaWxkIGNvbnRleHRzIHRoZQorCSAqIGV2ZW50cyBlbmRzIHVwIGluLgorCSAqLworCWN0eCA9IHJjdV9kZXJlZmVyZW5jZShjdXJyZW50LT5wZXJmX2V2ZW50X2N0eHApOworCWlmIChjdHgpCisJCXBlcmZfc3dldmVudF9jdHhfZXZlbnQoY3R4LCB0eXBlLCBldmVudF9pZCwgbnIsIG5taSwgZGF0YSwgcmVncyk7CisJcmN1X3JlYWRfdW5sb2NrKCk7CisKKwliYXJyaWVyKCk7CisJKCpyZWN1cnNpb24pLS07CisKK291dDoKKwlwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKK30KKwordm9pZCBfX3BlcmZfc3dfZXZlbnQodTMyIGV2ZW50X2lkLCB1NjQgbnIsIGludCBubWksCisJCQkgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHU2NCBhZGRyKQoreworCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhIGRhdGEgPSB7CisJCS5hZGRyID0gYWRkciwKKwl9OworCisJZG9fcGVyZl9zd19ldmVudChQRVJGX1RZUEVfU09GVFdBUkUsIGV2ZW50X2lkLCBuciwgbm1pLAorCQkJCSZkYXRhLCByZWdzKTsKK30KKworc3RhdGljIHZvaWQgcGVyZl9zd2V2ZW50X3JlYWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworfQorCitzdGF0aWMgaW50IHBlcmZfc3dldmVudF9lbmFibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3OworCisJaWYgKGh3Yy0+c2FtcGxlX3BlcmlvZCkgeworCQlod2MtPmxhc3RfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kOworCQlwZXJmX3N3ZXZlbnRfc2V0X3BlcmlvZChldmVudCk7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfZGlzYWJsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBlcmZfb3BzX2dlbmVyaWMgPSB7CisJLmVuYWJsZQkJPSBwZXJmX3N3ZXZlbnRfZW5hYmxlLAorCS5kaXNhYmxlCT0gcGVyZl9zd2V2ZW50X2Rpc2FibGUsCisJLnJlYWQJCT0gcGVyZl9zd2V2ZW50X3JlYWQsCisJLnVudGhyb3R0bGUJPSBwZXJmX3N3ZXZlbnRfdW50aHJvdHRsZSwKK307CisKKy8qCisgKiBocnRpbWVyIGJhc2VkIHN3ZXZlbnQgY2FsbGJhY2sKKyAqLworCitzdGF0aWMgZW51bSBocnRpbWVyX3Jlc3RhcnQgcGVyZl9zd2V2ZW50X2hydGltZXIoc3RydWN0IGhydGltZXIgKmhydGltZXIpCit7CisJZW51bSBocnRpbWVyX3Jlc3RhcnQgcmV0ID0gSFJUSU1FUl9SRVNUQVJUOworCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhIGRhdGE7CisJc3RydWN0IHB0X3JlZ3MgKnJlZ3M7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OworCXU2NCBwZXJpb2Q7CisKKwlldmVudAk9IGNvbnRhaW5lcl9vZihocnRpbWVyLCBzdHJ1Y3QgcGVyZl9ldmVudCwgaHcuaHJ0aW1lcik7CisJZXZlbnQtPnBtdS0+cmVhZChldmVudCk7CisKKwlkYXRhLmFkZHIgPSAwOworCXJlZ3MgPSBnZXRfaXJxX3JlZ3MoKTsKKwkvKgorCSAqIEluIGNhc2Ugd2UgZXhjbHVkZSBrZXJuZWwgSVBzIG9yIGFyZSBzb21laG93IG5vdCBpbiBpbnRlcnJ1cHQKKwkgKiBjb250ZXh0LCBwcm92aWRlIHRoZSBuZXh0IGJlc3QgdGhpbmcsIHRoZSB1c2VyIElQLgorCSAqLworCWlmICgoZXZlbnQtPmF0dHIuZXhjbHVkZV9rZXJuZWwgfHwgIXJlZ3MpICYmCisJCQkhZXZlbnQtPmF0dHIuZXhjbHVkZV91c2VyKQorCQlyZWdzID0gdGFza19wdF9yZWdzKGN1cnJlbnQpOworCisJaWYgKHJlZ3MpIHsKKwkJaWYgKHBlcmZfZXZlbnRfb3ZlcmZsb3coZXZlbnQsIDAsICZkYXRhLCByZWdzKSkKKwkJCXJldCA9IEhSVElNRVJfTk9SRVNUQVJUOworCX0KKworCXBlcmlvZCA9IG1heF90KHU2NCwgMTAwMDAsIGV2ZW50LT5ody5zYW1wbGVfcGVyaW9kKTsKKwlocnRpbWVyX2ZvcndhcmRfbm93KGhydGltZXIsIG5zX3RvX2t0aW1lKHBlcmlvZCkpOworCisJcmV0dXJuIHJldDsKK30KKworLyoKKyAqIFNvZnR3YXJlIGV2ZW50OiBjcHUgd2FsbCB0aW1lIGNsb2NrCisgKi8KKworc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlpbnQgY3B1ID0gcmF3X3NtcF9wcm9jZXNzb3JfaWQoKTsKKwlzNjQgcHJldjsKKwl1NjQgbm93OworCisJbm93ID0gY3B1X2Nsb2NrKGNwdSk7CisJcHJldiA9IGF0b21pYzY0X3JlYWQoJmV2ZW50LT5ody5wcmV2X2NvdW50KTsKKwlhdG9taWM2NF9zZXQoJmV2ZW50LT5ody5wcmV2X2NvdW50LCBub3cpOworCWF0b21pYzY0X2FkZChub3cgLSBwcmV2LCAmZXZlbnQtPmNvdW50KTsKK30KKworc3RhdGljIGludCBjcHVfY2xvY2tfcGVyZl9ldmVudF9lbmFibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCXN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3OworCWludCBjcHUgPSByYXdfc21wX3Byb2Nlc3Nvcl9pZCgpOworCisJYXRvbWljNjRfc2V0KCZod2MtPnByZXZfY291bnQsIGNwdV9jbG9jayhjcHUpKTsKKwlocnRpbWVyX2luaXQoJmh3Yy0+aHJ0aW1lciwgQ0xPQ0tfTU9OT1RPTklDLCBIUlRJTUVSX01PREVfUkVMKTsKKwlod2MtPmhydGltZXIuZnVuY3Rpb24gPSBwZXJmX3N3ZXZlbnRfaHJ0aW1lcjsKKwlpZiAoaHdjLT5zYW1wbGVfcGVyaW9kKSB7CisJCXU2NCBwZXJpb2QgPSBtYXhfdCh1NjQsIDEwMDAwLCBod2MtPnNhbXBsZV9wZXJpb2QpOworCQlfX2hydGltZXJfc3RhcnRfcmFuZ2VfbnMoJmh3Yy0+aHJ0aW1lciwKKwkJCQluc190b19rdGltZShwZXJpb2QpLCAwLAorCQkJCUhSVElNRVJfTU9ERV9SRUwsIDApOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBjcHVfY2xvY2tfcGVyZl9ldmVudF9kaXNhYmxlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlpZiAoZXZlbnQtPmh3LnNhbXBsZV9wZXJpb2QpCisJCWhydGltZXJfY2FuY2VsKCZldmVudC0+aHcuaHJ0aW1lcik7CisJY3B1X2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKGV2ZW50KTsKK30KKworc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfZXZlbnRfcmVhZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJY3B1X2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKGV2ZW50KTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgcGVyZl9vcHNfY3B1X2Nsb2NrID0geworCS5lbmFibGUJCT0gY3B1X2Nsb2NrX3BlcmZfZXZlbnRfZW5hYmxlLAorCS5kaXNhYmxlCT0gY3B1X2Nsb2NrX3BlcmZfZXZlbnRfZGlzYWJsZSwKKwkucmVhZAkJPSBjcHVfY2xvY2tfcGVyZl9ldmVudF9yZWFkLAorfTsKKworLyoKKyAqIFNvZnR3YXJlIGV2ZW50OiB0YXNrIHRpbWUgY2xvY2sKKyAqLworCitzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0IG5vdykKK3sKKwl1NjQgcHJldjsKKwlzNjQgZGVsdGE7CisKKwlwcmV2ID0gYXRvbWljNjRfeGNoZygmZXZlbnQtPmh3LnByZXZfY291bnQsIG5vdyk7CisJZGVsdGEgPSBub3cgLSBwcmV2OworCWF0b21pYzY0X2FkZChkZWx0YSwgJmV2ZW50LT5jb3VudCk7Cit9CisKK3N0YXRpYyBpbnQgdGFza19jbG9ja19wZXJmX2V2ZW50X2VuYWJsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CisJdTY0IG5vdzsKKworCW5vdyA9IGV2ZW50LT5jdHgtPnRpbWU7CisKKwlhdG9taWM2NF9zZXQoJmh3Yy0+cHJldl9jb3VudCwgbm93KTsKKwlocnRpbWVyX2luaXQoJmh3Yy0+aHJ0aW1lciwgQ0xPQ0tfTU9OT1RPTklDLCBIUlRJTUVSX01PREVfUkVMKTsKKwlod2MtPmhydGltZXIuZnVuY3Rpb24gPSBwZXJmX3N3ZXZlbnRfaHJ0aW1lcjsKKwlpZiAoaHdjLT5zYW1wbGVfcGVyaW9kKSB7CisJCXU2NCBwZXJpb2QgPSBtYXhfdCh1NjQsIDEwMDAwLCBod2MtPnNhbXBsZV9wZXJpb2QpOworCQlfX2hydGltZXJfc3RhcnRfcmFuZ2VfbnMoJmh3Yy0+aHJ0aW1lciwKKwkJCQluc190b19rdGltZShwZXJpb2QpLCAwLAorCQkJCUhSVElNRVJfTU9ERV9SRUwsIDApOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfZXZlbnRfZGlzYWJsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJaWYgKGV2ZW50LT5ody5zYW1wbGVfcGVyaW9kKQorCQlocnRpbWVyX2NhbmNlbCgmZXZlbnQtPmh3LmhydGltZXIpOworCXRhc2tfY2xvY2tfcGVyZl9ldmVudF91cGRhdGUoZXZlbnQsIGV2ZW50LT5jdHgtPnRpbWUpOworCit9CisKK3N0YXRpYyB2b2lkIHRhc2tfY2xvY2tfcGVyZl9ldmVudF9yZWFkKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwl1NjQgdGltZTsKKworCWlmICghaW5fbm1pKCkpIHsKKwkJdXBkYXRlX2NvbnRleHRfdGltZShldmVudC0+Y3R4KTsKKwkJdGltZSA9IGV2ZW50LT5jdHgtPnRpbWU7CisJfSBlbHNlIHsKKwkJdTY0IG5vdyA9IHBlcmZfY2xvY2soKTsKKwkJdTY0IGRlbHRhID0gbm93IC0gZXZlbnQtPmN0eC0+dGltZXN0YW1wOworCQl0aW1lID0gZXZlbnQtPmN0eC0+dGltZSArIGRlbHRhOworCX0KKworCXRhc2tfY2xvY2tfcGVyZl9ldmVudF91cGRhdGUoZXZlbnQsIHRpbWUpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHBtdSBwZXJmX29wc190YXNrX2Nsb2NrID0geworCS5lbmFibGUJCT0gdGFza19jbG9ja19wZXJmX2V2ZW50X2VuYWJsZSwKKwkuZGlzYWJsZQk9IHRhc2tfY2xvY2tfcGVyZl9ldmVudF9kaXNhYmxlLAorCS5yZWFkCQk9IHRhc2tfY2xvY2tfcGVyZl9ldmVudF9yZWFkLAorfTsKKworI2lmZGVmIENPTkZJR19FVkVOVF9QUk9GSUxFCit2b2lkIHBlcmZfdHBfZXZlbnQoaW50IGV2ZW50X2lkLCB1NjQgYWRkciwgdTY0IGNvdW50LCB2b2lkICpyZWNvcmQsCisJCQkgIGludCBlbnRyeV9zaXplKQoreworCXN0cnVjdCBwZXJmX3Jhd19yZWNvcmQgcmF3ID0geworCQkuc2l6ZSA9IGVudHJ5X3NpemUsCisJCS5kYXRhID0gcmVjb3JkLAorCX07CisKKwlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSBkYXRhID0geworCQkuYWRkciA9IGFkZHIsCisJCS5yYXcgPSAmcmF3LAorCX07CisKKwlzdHJ1Y3QgcHRfcmVncyAqcmVncyA9IGdldF9pcnFfcmVncygpOworCisJaWYgKCFyZWdzKQorCQlyZWdzID0gdGFza19wdF9yZWdzKGN1cnJlbnQpOworCisJZG9fcGVyZl9zd19ldmVudChQRVJGX1RZUEVfVFJBQ0VQT0lOVCwgZXZlbnRfaWQsIGNvdW50LCAxLAorCQkJCSZkYXRhLCByZWdzKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHBlcmZfdHBfZXZlbnQpOworCitleHRlcm4gaW50IGZ0cmFjZV9wcm9maWxlX2VuYWJsZShpbnQpOworZXh0ZXJuIHZvaWQgZnRyYWNlX3Byb2ZpbGVfZGlzYWJsZShpbnQpOworCitzdGF0aWMgdm9pZCB0cF9wZXJmX2V2ZW50X2Rlc3Ryb3koc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCWZ0cmFjZV9wcm9maWxlX2Rpc2FibGUoZXZlbnQtPmF0dHIuY29uZmlnKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgKnRwX3BlcmZfZXZlbnRfaW5pdChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJLyoKKwkgKiBSYXcgdHJhY2Vwb2ludCBkYXRhIGlzIGEgc2V2ZXJlIGRhdGEgbGVhaywgb25seSBhbGxvdyByb290IHRvCisJICogaGF2ZSB0aGVzZS4KKwkgKi8KKwlpZiAoKGV2ZW50LT5hdHRyLnNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkFXKSAmJgorCQkJcGVyZl9wYXJhbm9pZF90cmFjZXBvaW50X3JhdygpICYmCisJCQkhY2FwYWJsZShDQVBfU1lTX0FETUlOKSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVQRVJNKTsKKworCWlmIChmdHJhY2VfcHJvZmlsZV9lbmFibGUoZXZlbnQtPmF0dHIuY29uZmlnKSkKKwkJcmV0dXJuIE5VTEw7CisKKwlldmVudC0+ZGVzdHJveSA9IHRwX3BlcmZfZXZlbnRfZGVzdHJveTsKKworCXJldHVybiAmcGVyZl9vcHNfZ2VuZXJpYzsKK30KKyNlbHNlCitzdGF0aWMgY29uc3Qgc3RydWN0IHBtdSAqdHBfcGVyZl9ldmVudF9pbml0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKK3sKKwlyZXR1cm4gTlVMTDsKK30KKyNlbmRpZgorCithdG9taWNfdCBwZXJmX3N3ZXZlbnRfZW5hYmxlZFtQRVJGX0NPVU5UX1NXX01BWF07CisKK3N0YXRpYyB2b2lkIHN3X3BlcmZfZXZlbnRfZGVzdHJveShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCit7CisJdTY0IGV2ZW50X2lkID0gZXZlbnQtPmF0dHIuY29uZmlnOworCisJV0FSTl9PTihldmVudC0+cGFyZW50KTsKKworCWF0b21pY19kZWMoJnBlcmZfc3dldmVudF9lbmFibGVkW2V2ZW50X2lkXSk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcG11ICpzd19wZXJmX2V2ZW50X2luaXQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQoreworCWNvbnN0IHN0cnVjdCBwbXUgKnBtdSA9IE5VTEw7CisJdTY0IGV2ZW50X2lkID0gZXZlbnQtPmF0dHIuY29uZmlnOworCisJLyoKKwkgKiBTb2Z0d2FyZSBldmVudHMgKGN1cnJlbnRseSkgY2FuJ3QgaW4gZ2VuZXJhbCBkaXN0aW5ndWlzaAorCSAqIGJldHdlZW4gdXNlciwga2VybmVsIGFuZCBoeXBlcnZpc29yIGV2ZW50cy4KKwkgKiBIb3dldmVyLCBjb250ZXh0IHN3aXRjaGVzIGFuZCBjcHUgbWlncmF0aW9ucyBhcmUgY29uc2lkZXJlZAorCSAqIHRvIGJlIGtlcm5lbCBldmVudHMsIGFuZCBwYWdlIGZhdWx0cyBhcmUgbmV2ZXIgaHlwZXJ2aXNvcgorCSAqIGV2ZW50cy4KKwkgKi8KKwlzd2l0Y2ggKGV2ZW50X2lkKSB7CisJY2FzZSBQRVJGX0NPVU5UX1NXX0NQVV9DTE9DSzoKKwkJcG11ID0gJnBlcmZfb3BzX2NwdV9jbG9jazsKKworCQlicmVhazsKKwljYXNlIFBFUkZfQ09VTlRfU1dfVEFTS19DTE9DSzoKKwkJLyoKKwkJICogSWYgdGhlIHVzZXIgaW5zdGFudGlhdGVzIHRoaXMgYXMgYSBwZXItY3B1IGV2ZW50LAorCQkgKiB1c2UgdGhlIGNwdV9jbG9jayBldmVudCBpbnN0ZWFkLgorCQkgKi8KKwkJaWYgKGV2ZW50LT5jdHgtPnRhc2spCisJCQlwbXUgPSAmcGVyZl9vcHNfdGFza19jbG9jazsKKwkJZWxzZQorCQkJcG11ID0gJnBlcmZfb3BzX2NwdV9jbG9jazsKKworCQlicmVhazsKKwljYXNlIFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFM6CisJY2FzZSBQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01JTjoKKwljYXNlIFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUFKOgorCWNhc2UgUEVSRl9DT1VOVF9TV19DT05URVhUX1NXSVRDSEVTOgorCWNhc2UgUEVSRl9DT1VOVF9TV19DUFVfTUlHUkFUSU9OUzoKKwkJaWYgKCFldmVudC0+cGFyZW50KSB7CisJCQlhdG9taWNfaW5jKCZwZXJmX3N3ZXZlbnRfZW5hYmxlZFtldmVudF9pZF0pOworCQkJZXZlbnQtPmRlc3Ryb3kgPSBzd19wZXJmX2V2ZW50X2Rlc3Ryb3k7CisJCX0KKwkJcG11ID0gJnBlcmZfb3BzX2dlbmVyaWM7CisJCWJyZWFrOworCX0KKworCXJldHVybiBwbXU7Cit9CisKKy8qCisgKiBBbGxvY2F0ZSBhbmQgaW5pdGlhbGl6ZSBhIGV2ZW50IHN0cnVjdHVyZQorICovCitzdGF0aWMgc3RydWN0IHBlcmZfZXZlbnQgKgorcGVyZl9ldmVudF9hbGxvYyhzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRyLAorCQkgICBpbnQgY3B1LAorCQkgICBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCisJCSAgIHN0cnVjdCBwZXJmX2V2ZW50ICpncm91cF9sZWFkZXIsCisJCSAgIHN0cnVjdCBwZXJmX2V2ZW50ICpwYXJlbnRfZXZlbnQsCisJCSAgIGdmcF90IGdmcGZsYWdzKQoreworCWNvbnN0IHN0cnVjdCBwbXUgKnBtdTsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CisJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YzsKKwlsb25nIGVycjsKKworCWV2ZW50ID0ga3phbGxvYyhzaXplb2YoKmV2ZW50KSwgZ2ZwZmxhZ3MpOworCWlmICghZXZlbnQpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJLyoKKwkgKiBTaW5nbGUgZXZlbnRzIGFyZSB0aGVpciBvd24gZ3JvdXAgbGVhZGVycywgd2l0aCBhbgorCSAqIGVtcHR5IHNpYmxpbmcgbGlzdDoKKwkgKi8KKwlpZiAoIWdyb3VwX2xlYWRlcikKKwkJZ3JvdXBfbGVhZGVyID0gZXZlbnQ7CisKKwltdXRleF9pbml0KCZldmVudC0+Y2hpbGRfbXV0ZXgpOworCUlOSVRfTElTVF9IRUFEKCZldmVudC0+Y2hpbGRfbGlzdCk7CisKKwlJTklUX0xJU1RfSEVBRCgmZXZlbnQtPmdyb3VwX2VudHJ5KTsKKwlJTklUX0xJU1RfSEVBRCgmZXZlbnQtPmV2ZW50X2VudHJ5KTsKKwlJTklUX0xJU1RfSEVBRCgmZXZlbnQtPnNpYmxpbmdfbGlzdCk7CisJaW5pdF93YWl0cXVldWVfaGVhZCgmZXZlbnQtPndhaXRxKTsKKworCW11dGV4X2luaXQoJmV2ZW50LT5tbWFwX211dGV4KTsKKworCWV2ZW50LT5jcHUJCT0gY3B1OworCWV2ZW50LT5hdHRyCQk9ICphdHRyOworCWV2ZW50LT5ncm91cF9sZWFkZXIJPSBncm91cF9sZWFkZXI7CisJZXZlbnQtPnBtdQkJPSBOVUxMOworCWV2ZW50LT5jdHgJCT0gY3R4OworCWV2ZW50LT5vbmNwdQkJPSAtMTsKKworCWV2ZW50LT5wYXJlbnQJCT0gcGFyZW50X2V2ZW50OworCisJZXZlbnQtPm5zCQk9IGdldF9waWRfbnMoY3VycmVudC0+bnNwcm94eS0+cGlkX25zKTsKKwlldmVudC0+aWQJCT0gYXRvbWljNjRfaW5jX3JldHVybigmcGVyZl9ldmVudF9pZCk7CisKKwlldmVudC0+c3RhdGUJCT0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRTsKKworCWlmIChhdHRyLT5kaXNhYmxlZCkKKwkJZXZlbnQtPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9PRkY7CisKKwlwbXUgPSBOVUxMOworCisJaHdjID0gJmV2ZW50LT5odzsKKwlod2MtPnNhbXBsZV9wZXJpb2QgPSBhdHRyLT5zYW1wbGVfcGVyaW9kOworCWlmIChhdHRyLT5mcmVxICYmIGF0dHItPnNhbXBsZV9mcmVxKQorCQlod2MtPnNhbXBsZV9wZXJpb2QgPSAxOworCWh3Yy0+bGFzdF9wZXJpb2QgPSBod2MtPnNhbXBsZV9wZXJpb2Q7CisKKwlhdG9taWM2NF9zZXQoJmh3Yy0+cGVyaW9kX2xlZnQsIGh3Yy0+c2FtcGxlX3BlcmlvZCk7CisKKwkvKgorCSAqIHdlIGN1cnJlbnRseSBkbyBub3Qgc3VwcG9ydCBQRVJGX0ZPUk1BVF9HUk9VUCBvbiBpbmhlcml0ZWQgZXZlbnRzCisJICovCisJaWYgKGF0dHItPmluaGVyaXQgJiYgKGF0dHItPnJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfR1JPVVApKQorCQlnb3RvIGRvbmU7CisKKwlzd2l0Y2ggKGF0dHItPnR5cGUpIHsKKwljYXNlIFBFUkZfVFlQRV9SQVc6CisJY2FzZSBQRVJGX1RZUEVfSEFSRFdBUkU6CisJY2FzZSBQRVJGX1RZUEVfSFdfQ0FDSEU6CisJCXBtdSA9IGh3X3BlcmZfZXZlbnRfaW5pdChldmVudCk7CisJCWJyZWFrOworCisJY2FzZSBQRVJGX1RZUEVfU09GVFdBUkU6CisJCXBtdSA9IHN3X3BlcmZfZXZlbnRfaW5pdChldmVudCk7CisJCWJyZWFrOworCisJY2FzZSBQRVJGX1RZUEVfVFJBQ0VQT0lOVDoKKwkJcG11ID0gdHBfcGVyZl9ldmVudF9pbml0KGV2ZW50KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9Citkb25lOgorCWVyciA9IDA7CisJaWYgKCFwbXUpCisJCWVyciA9IC1FSU5WQUw7CisJZWxzZSBpZiAoSVNfRVJSKHBtdSkpCisJCWVyciA9IFBUUl9FUlIocG11KTsKKworCWlmIChlcnIpIHsKKwkJaWYgKGV2ZW50LT5ucykKKwkJCXB1dF9waWRfbnMoZXZlbnQtPm5zKTsKKwkJa2ZyZWUoZXZlbnQpOworCQlyZXR1cm4gRVJSX1BUUihlcnIpOworCX0KKworCWV2ZW50LT5wbXUgPSBwbXU7CisKKwlpZiAoIWV2ZW50LT5wYXJlbnQpIHsKKwkJYXRvbWljX2luYygmbnJfZXZlbnRzKTsKKwkJaWYgKGV2ZW50LT5hdHRyLm1tYXApCisJCQlhdG9taWNfaW5jKCZucl9tbWFwX2V2ZW50cyk7CisJCWlmIChldmVudC0+YXR0ci5jb21tKQorCQkJYXRvbWljX2luYygmbnJfY29tbV9ldmVudHMpOworCQlpZiAoZXZlbnQtPmF0dHIudGFzaykKKwkJCWF0b21pY19pbmMoJm5yX3Rhc2tfZXZlbnRzKTsKKwl9CisKKwlyZXR1cm4gZXZlbnQ7Cit9CisKK3N0YXRpYyBpbnQgcGVyZl9jb3B5X2F0dHIoc3RydWN0IHBlcmZfZXZlbnRfYXR0ciBfX3VzZXIgKnVhdHRyLAorCQkJICBzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRyKQoreworCXUzMiBzaXplOworCWludCByZXQ7CisKKwlpZiAoIWFjY2Vzc19vayhWRVJJRllfV1JJVEUsIHVhdHRyLCBQRVJGX0FUVFJfU0laRV9WRVIwKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwkvKgorCSAqIHplcm8gdGhlIGZ1bGwgc3RydWN0dXJlLCBzbyB0aGF0IGEgc2hvcnQgY29weSB3aWxsIGJlIG5pY2UuCisJICovCisJbWVtc2V0KGF0dHIsIDAsIHNpemVvZigqYXR0cikpOworCisJcmV0ID0gZ2V0X3VzZXIoc2l6ZSwgJnVhdHRyLT5zaXplKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJaWYgKHNpemUgPiBQQUdFX1NJWkUpCS8qIHNpbGx5IGxhcmdlICovCisJCWdvdG8gZXJyX3NpemU7CisKKwlpZiAoIXNpemUpCQkvKiBhYmkgY29tcGF0ICovCisJCXNpemUgPSBQRVJGX0FUVFJfU0laRV9WRVIwOworCisJaWYgKHNpemUgPCBQRVJGX0FUVFJfU0laRV9WRVIwKQorCQlnb3RvIGVycl9zaXplOworCisJLyoKKwkgKiBJZiB3ZSdyZSBoYW5kZWQgYSBiaWdnZXIgc3RydWN0IHRoYW4gd2Uga25vdyBvZiwKKwkgKiBlbnN1cmUgYWxsIHRoZSB1bmtub3duIGJpdHMgYXJlIDAgLSBpLmUuIG5ldworCSAqIHVzZXItc3BhY2UgZG9lcyBub3QgcmVseSBvbiBhbnkga2VybmVsIGZlYXR1cmUKKwkgKiBleHRlbnNpb25zIHdlIGRvbnQga25vdyBhYm91dCB5ZXQuCisJICovCisJaWYgKHNpemUgPiBzaXplb2YoKmF0dHIpKSB7CisJCXVuc2lnbmVkIGNoYXIgX191c2VyICphZGRyOworCQl1bnNpZ25lZCBjaGFyIF9fdXNlciAqZW5kOworCQl1bnNpZ25lZCBjaGFyIHZhbDsKKworCQlhZGRyID0gKHZvaWQgX191c2VyICopdWF0dHIgKyBzaXplb2YoKmF0dHIpOworCQllbmQgID0gKHZvaWQgX191c2VyICopdWF0dHIgKyBzaXplOworCisJCWZvciAoOyBhZGRyIDwgZW5kOyBhZGRyKyspIHsKKwkJCXJldCA9IGdldF91c2VyKHZhbCwgYWRkcik7CisJCQlpZiAocmV0KQorCQkJCXJldHVybiByZXQ7CisJCQlpZiAodmFsKQorCQkJCWdvdG8gZXJyX3NpemU7CisJCX0KKwkJc2l6ZSA9IHNpemVvZigqYXR0cik7CisJfQorCisJcmV0ID0gY29weV9mcm9tX3VzZXIoYXR0ciwgdWF0dHIsIHNpemUpOworCWlmIChyZXQpCisJCXJldHVybiAtRUZBVUxUOworCisJLyoKKwkgKiBJZiB0aGUgdHlwZSBleGlzdHMsIHRoZSBjb3JyZXNwb25kaW5nIGNyZWF0aW9uIHdpbGwgdmVyaWZ5CisJICogdGhlIGF0dHItPmNvbmZpZy4KKwkgKi8KKwlpZiAoYXR0ci0+dHlwZSA+PSBQRVJGX1RZUEVfTUFYKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChhdHRyLT5fX3Jlc2VydmVkXzEgfHwgYXR0ci0+X19yZXNlcnZlZF8yIHx8IGF0dHItPl9fcmVzZXJ2ZWRfMykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoYXR0ci0+c2FtcGxlX3R5cGUgJiB+KFBFUkZfU0FNUExFX01BWC0xKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoYXR0ci0+cmVhZF9mb3JtYXQgJiB+KFBFUkZfRk9STUFUX01BWC0xKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKK291dDoKKwlyZXR1cm4gcmV0OworCitlcnJfc2l6ZToKKwlwdXRfdXNlcihzaXplb2YoKmF0dHIpLCAmdWF0dHItPnNpemUpOworCXJldCA9IC1FMkJJRzsKKwlnb3RvIG91dDsKK30KKworaW50IHBlcmZfZXZlbnRfc2V0X291dHB1dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBvdXRwdXRfZmQpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKm91dHB1dF9ldmVudCA9IE5VTEw7CisJc3RydWN0IGZpbGUgKm91dHB1dF9maWxlID0gTlVMTDsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqb2xkX291dHB1dDsKKwlpbnQgZnB1dF9uZWVkZWQgPSAwOworCWludCByZXQgPSAtRUlOVkFMOworCisJaWYgKCFvdXRwdXRfZmQpCisJCWdvdG8gc2V0OworCisJb3V0cHV0X2ZpbGUgPSBmZ2V0X2xpZ2h0KG91dHB1dF9mZCwgJmZwdXRfbmVlZGVkKTsKKwlpZiAoIW91dHB1dF9maWxlKQorCQlyZXR1cm4gLUVCQURGOworCisJaWYgKG91dHB1dF9maWxlLT5mX29wICE9ICZwZXJmX2ZvcHMpCisJCWdvdG8gb3V0OworCisJb3V0cHV0X2V2ZW50ID0gb3V0cHV0X2ZpbGUtPnByaXZhdGVfZGF0YTsKKworCS8qIERvbid0IGNoYWluIG91dHB1dCBmZHMgKi8KKwlpZiAob3V0cHV0X2V2ZW50LT5vdXRwdXQpCisJCWdvdG8gb3V0OworCisJLyogRG9uJ3Qgc2V0IGFuIG91dHB1dCBmZCB3aGVuIHdlIGFscmVhZHkgaGF2ZSBhbiBvdXRwdXQgY2hhbm5lbCAqLworCWlmIChldmVudC0+ZGF0YSkKKwkJZ290byBvdXQ7CisKKwlhdG9taWNfbG9uZ19pbmMoJm91dHB1dF9maWxlLT5mX2NvdW50KTsKKworc2V0OgorCW11dGV4X2xvY2soJmV2ZW50LT5tbWFwX211dGV4KTsKKwlvbGRfb3V0cHV0ID0gZXZlbnQtPm91dHB1dDsKKwlyY3VfYXNzaWduX3BvaW50ZXIoZXZlbnQtPm91dHB1dCwgb3V0cHV0X2V2ZW50KTsKKwltdXRleF91bmxvY2soJmV2ZW50LT5tbWFwX211dGV4KTsKKworCWlmIChvbGRfb3V0cHV0KSB7CisJCS8qCisJCSAqIHdlIG5lZWQgdG8gbWFrZSBzdXJlIG5vIGV4aXN0aW5nIHBlcmZfb3V0cHV0XyooKQorCQkgKiBpcyBzdGlsbCByZWZlcmVuY2luZyB0aGlzIGV2ZW50LgorCQkgKi8KKwkJc3luY2hyb25pemVfcmN1KCk7CisJCWZwdXQob2xkX291dHB1dC0+ZmlscCk7CisJfQorCisJcmV0ID0gMDsKK291dDoKKwlmcHV0X2xpZ2h0KG91dHB1dF9maWxlLCBmcHV0X25lZWRlZCk7CisJcmV0dXJuIHJldDsKK30KKworLyoqCisgKiBzeXNfcGVyZl9ldmVudF9vcGVuIC0gb3BlbiBhIHBlcmZvcm1hbmNlIGV2ZW50LCBhc3NvY2lhdGUgaXQgdG8gYSB0YXNrL2NwdQorICoKKyAqIEBhdHRyX3VwdHI6CWV2ZW50X2lkIHR5cGUgYXR0cmlidXRlcyBmb3IgbW9uaXRvcmluZy9zYW1wbGluZworICogQHBpZDoJCXRhcmdldCBwaWQKKyAqIEBjcHU6CQl0YXJnZXQgY3B1CisgKiBAZ3JvdXBfZmQ6CQlncm91cCBsZWFkZXIgZXZlbnQgZmQKKyAqLworU1lTQ0FMTF9ERUZJTkU1KHBlcmZfZXZlbnRfb3BlbiwKKwkJc3RydWN0IHBlcmZfZXZlbnRfYXR0ciBfX3VzZXIgKiwgYXR0cl91cHRyLAorCQlwaWRfdCwgcGlkLCBpbnQsIGNwdSwgaW50LCBncm91cF9mZCwgdW5zaWduZWQgbG9uZywgZmxhZ3MpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqZ3JvdXBfbGVhZGVyOworCXN0cnVjdCBwZXJmX2V2ZW50X2F0dHIgYXR0cjsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7CisJc3RydWN0IGZpbGUgKmV2ZW50X2ZpbGUgPSBOVUxMOworCXN0cnVjdCBmaWxlICpncm91cF9maWxlID0gTlVMTDsKKwlpbnQgZnB1dF9uZWVkZWQgPSAwOworCWludCBmcHV0X25lZWRlZDIgPSAwOworCWludCBlcnI7CisKKwkvKiBmb3IgZnV0dXJlIGV4cGFuZGFiaWxpdHkuLi4gKi8KKwlpZiAoZmxhZ3MgJiB+KFBFUkZfRkxBR19GRF9OT19HUk9VUCB8IFBFUkZfRkxBR19GRF9PVVRQVVQpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWVyciA9IHBlcmZfY29weV9hdHRyKGF0dHJfdXB0ciwgJmF0dHIpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwlpZiAoIWF0dHIuZXhjbHVkZV9rZXJuZWwpIHsKKwkJaWYgKHBlcmZfcGFyYW5vaWRfa2VybmVsKCkgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCisJCQlyZXR1cm4gLUVBQ0NFUzsKKwl9CisKKwlpZiAoYXR0ci5mcmVxKSB7CisJCWlmIChhdHRyLnNhbXBsZV9mcmVxID4gc3lzY3RsX3BlcmZfZXZlbnRfc2FtcGxlX3JhdGUpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKgorCSAqIEdldCB0aGUgdGFyZ2V0IGNvbnRleHQgKHRhc2sgb3IgcGVyY3B1KToKKwkgKi8KKwljdHggPSBmaW5kX2dldF9jb250ZXh0KHBpZCwgY3B1KTsKKwlpZiAoSVNfRVJSKGN0eCkpCisJCXJldHVybiBQVFJfRVJSKGN0eCk7CisKKwkvKgorCSAqIExvb2sgdXAgdGhlIGdyb3VwIGxlYWRlciAod2Ugd2lsbCBhdHRhY2ggdGhpcyBldmVudCB0byBpdCk6CisJICovCisJZ3JvdXBfbGVhZGVyID0gTlVMTDsKKwlpZiAoZ3JvdXBfZmQgIT0gLTEgJiYgIShmbGFncyAmIFBFUkZfRkxBR19GRF9OT19HUk9VUCkpIHsKKwkJZXJyID0gLUVJTlZBTDsKKwkJZ3JvdXBfZmlsZSA9IGZnZXRfbGlnaHQoZ3JvdXBfZmQsICZmcHV0X25lZWRlZCk7CisJCWlmICghZ3JvdXBfZmlsZSkKKwkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OworCQlpZiAoZ3JvdXBfZmlsZS0+Zl9vcCAhPSAmcGVyZl9mb3BzKQorCQkJZ290byBlcnJfcHV0X2NvbnRleHQ7CisKKwkJZ3JvdXBfbGVhZGVyID0gZ3JvdXBfZmlsZS0+cHJpdmF0ZV9kYXRhOworCQkvKgorCQkgKiBEbyBub3QgYWxsb3cgYSByZWN1cnNpdmUgaGllcmFyY2h5ICh0aGlzIG5ldyBzaWJsaW5nCisJCSAqIGJlY29taW5nIHBhcnQgb2YgYW5vdGhlciBncm91cC1zaWJsaW5nKToKKwkJICovCisJCWlmIChncm91cF9sZWFkZXItPmdyb3VwX2xlYWRlciAhPSBncm91cF9sZWFkZXIpCisJCQlnb3RvIGVycl9wdXRfY29udGV4dDsKKwkJLyoKKwkJICogRG8gbm90IGFsbG93IHRvIGF0dGFjaCB0byBhIGdyb3VwIGluIGEgZGlmZmVyZW50CisJCSAqIHRhc2sgb3IgQ1BVIGNvbnRleHQ6CisJCSAqLworCQlpZiAoZ3JvdXBfbGVhZGVyLT5jdHggIT0gY3R4KQorCQkJZ290byBlcnJfcHV0X2NvbnRleHQ7CisJCS8qCisJCSAqIE9ubHkgYSBncm91cCBsZWFkZXIgY2FuIGJlIGV4Y2x1c2l2ZSBvciBwaW5uZWQKKwkJICovCisJCWlmIChhdHRyLmV4Y2x1c2l2ZSB8fCBhdHRyLnBpbm5lZCkKKwkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OworCX0KKworCWV2ZW50ID0gcGVyZl9ldmVudF9hbGxvYygmYXR0ciwgY3B1LCBjdHgsIGdyb3VwX2xlYWRlciwKKwkJCQkgICAgIE5VTEwsIEdGUF9LRVJORUwpOworCWVyciA9IFBUUl9FUlIoZXZlbnQpOworCWlmIChJU19FUlIoZXZlbnQpKQorCQlnb3RvIGVycl9wdXRfY29udGV4dDsKKworCWVyciA9IGFub25faW5vZGVfZ2V0ZmQoIltwZXJmX2V2ZW50XSIsICZwZXJmX2ZvcHMsIGV2ZW50LCAwKTsKKwlpZiAoZXJyIDwgMCkKKwkJZ290byBlcnJfZnJlZV9wdXRfY29udGV4dDsKKworCWV2ZW50X2ZpbGUgPSBmZ2V0X2xpZ2h0KGVyciwgJmZwdXRfbmVlZGVkMik7CisJaWYgKCFldmVudF9maWxlKQorCQlnb3RvIGVycl9mcmVlX3B1dF9jb250ZXh0OworCisJaWYgKGZsYWdzICYgUEVSRl9GTEFHX0ZEX09VVFBVVCkgeworCQllcnIgPSBwZXJmX2V2ZW50X3NldF9vdXRwdXQoZXZlbnQsIGdyb3VwX2ZkKTsKKwkJaWYgKGVycikKKwkJCWdvdG8gZXJyX2ZwdXRfZnJlZV9wdXRfY29udGV4dDsKKwl9CisKKwlldmVudC0+ZmlscCA9IGV2ZW50X2ZpbGU7CisJV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7CisJbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7CisJcGVyZl9pbnN0YWxsX2luX2NvbnRleHQoY3R4LCBldmVudCwgY3B1KTsKKwkrK2N0eC0+Z2VuZXJhdGlvbjsKKwltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOworCisJZXZlbnQtPm93bmVyID0gY3VycmVudDsKKwlnZXRfdGFza19zdHJ1Y3QoY3VycmVudCk7CisJbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CisJbGlzdF9hZGRfdGFpbCgmZXZlbnQtPm93bmVyX2VudHJ5LCAmY3VycmVudC0+cGVyZl9ldmVudF9saXN0KTsKKwltdXRleF91bmxvY2soJmN1cnJlbnQtPnBlcmZfZXZlbnRfbXV0ZXgpOworCitlcnJfZnB1dF9mcmVlX3B1dF9jb250ZXh0OgorCWZwdXRfbGlnaHQoZXZlbnRfZmlsZSwgZnB1dF9uZWVkZWQyKTsKKworZXJyX2ZyZWVfcHV0X2NvbnRleHQ6CisJaWYgKGVyciA8IDApCisJCWtmcmVlKGV2ZW50KTsKKworZXJyX3B1dF9jb250ZXh0OgorCWlmIChlcnIgPCAwKQorCQlwdXRfY3R4KGN0eCk7CisKKwlmcHV0X2xpZ2h0KGdyb3VwX2ZpbGUsIGZwdXRfbmVlZGVkKTsKKworCXJldHVybiBlcnI7Cit9CisKKy8qCisgKiBpbmhlcml0IGEgZXZlbnQgZnJvbSBwYXJlbnQgdGFzayB0byBjaGlsZCB0YXNrOgorICovCitzdGF0aWMgc3RydWN0IHBlcmZfZXZlbnQgKgoraW5oZXJpdF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVudCAqcGFyZW50X2V2ZW50LAorCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50LAorCSAgICAgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnBhcmVudF9jdHgsCisJICAgICAgc3RydWN0IHRhc2tfc3RydWN0ICpjaGlsZCwKKwkgICAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBfbGVhZGVyLAorCSAgICAgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmNoaWxkX2N0eCkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGRfZXZlbnQ7CisKKwkvKgorCSAqIEluc3RlYWQgb2YgY3JlYXRpbmcgcmVjdXJzaXZlIGhpZXJhcmNoaWVzIG9mIGV2ZW50cywKKwkgKiB3ZSBsaW5rIGluaGVyaXRlZCBldmVudHMgYmFjayB0byB0aGUgb3JpZ2luYWwgcGFyZW50LAorCSAqIHdoaWNoIGhhcyBhIGZpbHAgZm9yIHN1cmUsIHdoaWNoIHdlIHVzZSBhcyB0aGUgcmVmZXJlbmNlCisJICogY291bnQ6CisJICovCisJaWYgKHBhcmVudF9ldmVudC0+cGFyZW50KQorCQlwYXJlbnRfZXZlbnQgPSBwYXJlbnRfZXZlbnQtPnBhcmVudDsKKworCWNoaWxkX2V2ZW50ID0gcGVyZl9ldmVudF9hbGxvYygmcGFyZW50X2V2ZW50LT5hdHRyLAorCQkJCQkgICBwYXJlbnRfZXZlbnQtPmNwdSwgY2hpbGRfY3R4LAorCQkJCQkgICBncm91cF9sZWFkZXIsIHBhcmVudF9ldmVudCwKKwkJCQkJICAgR0ZQX0tFUk5FTCk7CisJaWYgKElTX0VSUihjaGlsZF9ldmVudCkpCisJCXJldHVybiBjaGlsZF9ldmVudDsKKwlnZXRfY3R4KGNoaWxkX2N0eCk7CisKKwkvKgorCSAqIE1ha2UgdGhlIGNoaWxkIHN0YXRlIGZvbGxvdyB0aGUgc3RhdGUgb2YgdGhlIHBhcmVudCBldmVudCwKKwkgKiBub3QgaXRzIGF0dHIuZGlzYWJsZWQgYml0LiAgV2UgaG9sZCB0aGUgcGFyZW50J3MgbXV0ZXgsCisJICogc28gd2Ugd29uJ3QgcmFjZSB3aXRoIHBlcmZfZXZlbnRfe2VuLCBkaXN9YWJsZV9mYW1pbHkuCisJICovCisJaWYgKHBhcmVudF9ldmVudC0+c3RhdGUgPj0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKKwkJY2hpbGRfZXZlbnQtPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRTsKKwllbHNlCisJCWNoaWxkX2V2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGOworCisJaWYgKHBhcmVudF9ldmVudC0+YXR0ci5mcmVxKQorCQljaGlsZF9ldmVudC0+aHcuc2FtcGxlX3BlcmlvZCA9IHBhcmVudF9ldmVudC0+aHcuc2FtcGxlX3BlcmlvZDsKKworCS8qCisJICogTGluayBpdCB1cCBpbiB0aGUgY2hpbGQncyBjb250ZXh0OgorCSAqLworCWFkZF9ldmVudF90b19jdHgoY2hpbGRfZXZlbnQsIGNoaWxkX2N0eCk7CisKKwkvKgorCSAqIEdldCBhIHJlZmVyZW5jZSB0byB0aGUgcGFyZW50IGZpbHAgLSB3ZSB3aWxsIGZwdXQgaXQKKwkgKiB3aGVuIHRoZSBjaGlsZCBldmVudCBleGl0cy4gVGhpcyBpcyBzYWZlIHRvIGRvIGJlY2F1c2UKKwkgKiB3ZSBhcmUgaW4gdGhlIHBhcmVudCBhbmQgd2Uga25vdyB0aGF0IHRoZSBmaWxwIHN0aWxsCisJICogZXhpc3RzIGFuZCBoYXMgYSBub256ZXJvIGNvdW50OgorCSAqLworCWF0b21pY19sb25nX2luYygmcGFyZW50X2V2ZW50LT5maWxwLT5mX2NvdW50KTsKKworCS8qCisJICogTGluayB0aGlzIGludG8gdGhlIHBhcmVudCBldmVudCdzIGNoaWxkIGxpc3QKKwkgKi8KKwlXQVJOX09OX09OQ0UocGFyZW50X2V2ZW50LT5jdHgtPnBhcmVudF9jdHgpOworCW11dGV4X2xvY2soJnBhcmVudF9ldmVudC0+Y2hpbGRfbXV0ZXgpOworCWxpc3RfYWRkX3RhaWwoJmNoaWxkX2V2ZW50LT5jaGlsZF9saXN0LCAmcGFyZW50X2V2ZW50LT5jaGlsZF9saXN0KTsKKwltdXRleF91bmxvY2soJnBhcmVudF9ldmVudC0+Y2hpbGRfbXV0ZXgpOworCisJcmV0dXJuIGNoaWxkX2V2ZW50OworfQorCitzdGF0aWMgaW50IGluaGVyaXRfZ3JvdXAoc3RydWN0IHBlcmZfZXZlbnQgKnBhcmVudF9ldmVudCwKKwkgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnBhcmVudCwKKwkgICAgICBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpwYXJlbnRfY3R4LAorCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQsCisJICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2hpbGRfY3R4KQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpsZWFkZXI7CisJc3RydWN0IHBlcmZfZXZlbnQgKnN1YjsKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGRfY3RyOworCisJbGVhZGVyID0gaW5oZXJpdF9ldmVudChwYXJlbnRfZXZlbnQsIHBhcmVudCwgcGFyZW50X2N0eCwKKwkJCQkgY2hpbGQsIE5VTEwsIGNoaWxkX2N0eCk7CisJaWYgKElTX0VSUihsZWFkZXIpKQorCQlyZXR1cm4gUFRSX0VSUihsZWFkZXIpOworCWxpc3RfZm9yX2VhY2hfZW50cnkoc3ViLCAmcGFyZW50X2V2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7CisJCWNoaWxkX2N0ciA9IGluaGVyaXRfZXZlbnQoc3ViLCBwYXJlbnQsIHBhcmVudF9jdHgsCisJCQkJCSAgICBjaGlsZCwgbGVhZGVyLCBjaGlsZF9jdHgpOworCQlpZiAoSVNfRVJSKGNoaWxkX2N0cikpCisJCQlyZXR1cm4gUFRSX0VSUihjaGlsZF9jdHIpOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgc3luY19jaGlsZF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGRfZXZlbnQsCisJCQkgICAgICAgc3RydWN0IHRhc2tfc3RydWN0ICpjaGlsZCkKK3sKKwlzdHJ1Y3QgcGVyZl9ldmVudCAqcGFyZW50X2V2ZW50ID0gY2hpbGRfZXZlbnQtPnBhcmVudDsKKwl1NjQgY2hpbGRfdmFsOworCisJaWYgKGNoaWxkX2V2ZW50LT5hdHRyLmluaGVyaXRfc3RhdCkKKwkJcGVyZl9ldmVudF9yZWFkX2V2ZW50KGNoaWxkX2V2ZW50LCBjaGlsZCk7CisKKwljaGlsZF92YWwgPSBhdG9taWM2NF9yZWFkKCZjaGlsZF9ldmVudC0+Y291bnQpOworCisJLyoKKwkgKiBBZGQgYmFjayB0aGUgY2hpbGQncyBjb3VudCB0byB0aGUgcGFyZW50J3MgY291bnQ6CisJICovCisJYXRvbWljNjRfYWRkKGNoaWxkX3ZhbCwgJnBhcmVudF9ldmVudC0+Y291bnQpOworCWF0b21pYzY0X2FkZChjaGlsZF9ldmVudC0+dG90YWxfdGltZV9lbmFibGVkLAorCQkgICAgICZwYXJlbnRfZXZlbnQtPmNoaWxkX3RvdGFsX3RpbWVfZW5hYmxlZCk7CisJYXRvbWljNjRfYWRkKGNoaWxkX2V2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcsCisJCSAgICAgJnBhcmVudF9ldmVudC0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKKworCS8qCisJICogUmVtb3ZlIHRoaXMgZXZlbnQgZnJvbSB0aGUgcGFyZW50J3MgbGlzdAorCSAqLworCVdBUk5fT05fT05DRShwYXJlbnRfZXZlbnQtPmN0eC0+cGFyZW50X2N0eCk7CisJbXV0ZXhfbG9jaygmcGFyZW50X2V2ZW50LT5jaGlsZF9tdXRleCk7CisJbGlzdF9kZWxfaW5pdCgmY2hpbGRfZXZlbnQtPmNoaWxkX2xpc3QpOworCW11dGV4X3VubG9jaygmcGFyZW50X2V2ZW50LT5jaGlsZF9tdXRleCk7CisKKwkvKgorCSAqIFJlbGVhc2UgdGhlIHBhcmVudCBldmVudCwgaWYgdGhpcyB3YXMgdGhlIGxhc3QKKwkgKiByZWZlcmVuY2UgdG8gaXQuCisJICovCisJZnB1dChwYXJlbnRfZXZlbnQtPmZpbHApOworfQorCitzdGF0aWMgdm9pZAorX19wZXJmX2V2ZW50X2V4aXRfdGFzayhzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGRfZXZlbnQsCisJCQkgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2hpbGRfY3R4LAorCQkJIHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCit7CisJc3RydWN0IHBlcmZfZXZlbnQgKnBhcmVudF9ldmVudDsKKworCXVwZGF0ZV9ldmVudF90aW1lcyhjaGlsZF9ldmVudCk7CisJcGVyZl9ldmVudF9yZW1vdmVfZnJvbV9jb250ZXh0KGNoaWxkX2V2ZW50KTsKKworCXBhcmVudF9ldmVudCA9IGNoaWxkX2V2ZW50LT5wYXJlbnQ7CisJLyoKKwkgKiBJdCBjYW4gaGFwcGVuIHRoYXQgcGFyZW50IGV4aXRzIGZpcnN0LCBhbmQgaGFzIGV2ZW50cworCSAqIHRoYXQgYXJlIHN0aWxsIGFyb3VuZCBkdWUgdG8gdGhlIGNoaWxkIHJlZmVyZW5jZS4gVGhlc2UKKwkgKiBldmVudHMgbmVlZCB0byBiZSB6YXBwZWQgLSBidXQgb3RoZXJ3aXNlIGxpbmdlci4KKwkgKi8KKwlpZiAocGFyZW50X2V2ZW50KSB7CisJCXN5bmNfY2hpbGRfZXZlbnQoY2hpbGRfZXZlbnQsIGNoaWxkKTsKKwkJZnJlZV9ldmVudChjaGlsZF9ldmVudCk7CisJfQorfQorCisvKgorICogV2hlbiBhIGNoaWxkIHRhc2sgZXhpdHMsIGZlZWQgYmFjayBldmVudCB2YWx1ZXMgdG8gcGFyZW50IGV2ZW50cy4KKyAqLwordm9pZCBwZXJmX2V2ZW50X2V4aXRfdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkKQoreworCXN0cnVjdCBwZXJmX2V2ZW50ICpjaGlsZF9ldmVudCwgKnRtcDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjaGlsZF9jdHg7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWlmIChsaWtlbHkoIWNoaWxkLT5wZXJmX2V2ZW50X2N0eHApKSB7CisJCXBlcmZfZXZlbnRfdGFzayhjaGlsZCwgTlVMTCwgMCk7CisJCXJldHVybjsKKwl9CisKKwlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CisJLyoKKwkgKiBXZSBjYW4ndCByZXNjaGVkdWxlIGhlcmUgYmVjYXVzZSBpbnRlcnJ1cHRzIGFyZSBkaXNhYmxlZCwKKwkgKiBhbmQgZWl0aGVyIGNoaWxkIGlzIGN1cnJlbnQgb3IgaXQgaXMgYSB0YXNrIHRoYXQgY2FuJ3QgYmUKKwkgKiBzY2hlZHVsZWQsIHNvIHdlIGFyZSBub3cgc2FmZSBmcm9tIHJlc2NoZWR1bGluZyBjaGFuZ2luZworCSAqIG91ciBjb250ZXh0LgorCSAqLworCWNoaWxkX2N0eCA9IGNoaWxkLT5wZXJmX2V2ZW50X2N0eHA7CisJX19wZXJmX2V2ZW50X3Rhc2tfc2NoZWRfb3V0KGNoaWxkX2N0eCk7CisKKwkvKgorCSAqIFRha2UgdGhlIGNvbnRleHQgbG9jayBoZXJlIHNvIHRoYXQgaWYgZmluZF9nZXRfY29udGV4dCBpcworCSAqIHJlYWRpbmcgY2hpbGQtPnBlcmZfZXZlbnRfY3R4cCwgd2Ugd2FpdCB1bnRpbCBpdCBoYXMKKwkgKiBpbmNyZW1lbnRlZCB0aGUgY29udGV4dCdzIHJlZmNvdW50IGJlZm9yZSB3ZSBkbyBwdXRfY3R4IGJlbG93LgorCSAqLworCXNwaW5fbG9jaygmY2hpbGRfY3R4LT5sb2NrKTsKKwljaGlsZC0+cGVyZl9ldmVudF9jdHhwID0gTlVMTDsKKwkvKgorCSAqIElmIHRoaXMgY29udGV4dCBpcyBhIGNsb25lOyB1bmNsb25lIGl0IHNvIGl0IGNhbid0IGdldAorCSAqIHN3YXBwZWQgdG8gYW5vdGhlciBwcm9jZXNzIHdoaWxlIHdlJ3JlIHJlbW92aW5nIGFsbAorCSAqIHRoZSBldmVudHMgZnJvbSBpdC4KKwkgKi8KKwl1bmNsb25lX2N0eChjaGlsZF9jdHgpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNoaWxkX2N0eC0+bG9jaywgZmxhZ3MpOworCisJLyoKKwkgKiBSZXBvcnQgdGhlIHRhc2sgZGVhZCBhZnRlciB1bnNjaGVkdWxpbmcgdGhlIGV2ZW50cyBzbyB0aGF0IHdlCisJICogd29uJ3QgZ2V0IGFueSBzYW1wbGVzIGFmdGVyIFBFUkZfUkVDT1JEX0VYSVQuIFdlIGNhbiBob3dldmVyIHN0aWxsCisJICogZ2V0IGEgZmV3IFBFUkZfUkVDT1JEX1JFQUQgZXZlbnRzLgorCSAqLworCXBlcmZfZXZlbnRfdGFzayhjaGlsZCwgY2hpbGRfY3R4LCAwKTsKKworCS8qCisJICogV2UgY2FuIHJlY3Vyc2Ugb24gdGhlIHNhbWUgbG9jayB0eXBlIHRocm91Z2g6CisJICoKKwkgKiAgIF9fcGVyZl9ldmVudF9leGl0X3Rhc2soKQorCSAqICAgICBzeW5jX2NoaWxkX2V2ZW50KCkKKwkgKiAgICAgICBmcHV0KHBhcmVudF9ldmVudC0+ZmlscCkKKwkgKiAgICAgICAgIHBlcmZfcmVsZWFzZSgpCisJICogICAgICAgICAgIG11dGV4X2xvY2soJmN0eC0+bXV0ZXgpCisJICoKKwkgKiBCdXQgc2luY2UgaXRzIHRoZSBwYXJlbnQgY29udGV4dCBpdCB3b24ndCBiZSB0aGUgc2FtZSBpbnN0YW5jZS4KKwkgKi8KKwltdXRleF9sb2NrX25lc3RlZCgmY2hpbGRfY3R4LT5tdXRleCwgU0lOR0xFX0RFUFRIX05FU1RJTkcpOworCithZ2FpbjoKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY2hpbGRfZXZlbnQsIHRtcCwgJmNoaWxkX2N0eC0+Z3JvdXBfbGlzdCwKKwkJCQkgZ3JvdXBfZW50cnkpCisJCV9fcGVyZl9ldmVudF9leGl0X3Rhc2soY2hpbGRfZXZlbnQsIGNoaWxkX2N0eCwgY2hpbGQpOworCisJLyoKKwkgKiBJZiB0aGUgbGFzdCBldmVudCB3YXMgYSBncm91cCBldmVudCwgaXQgd2lsbCBoYXZlIGFwcGVuZGVkIGFsbAorCSAqIGl0cyBzaWJsaW5ncyB0byB0aGUgbGlzdCwgYnV0IHdlIG9idGFpbmVkICd0bXAnIGJlZm9yZSB0aGF0IHdoaWNoCisJICogd2lsbCBzdGlsbCBwb2ludCB0byB0aGUgbGlzdCBoZWFkIHRlcm1pbmF0aW5nIHRoZSBpdGVyYXRpb24uCisJICovCisJaWYgKCFsaXN0X2VtcHR5KCZjaGlsZF9jdHgtPmdyb3VwX2xpc3QpKQorCQlnb3RvIGFnYWluOworCisJbXV0ZXhfdW5sb2NrKCZjaGlsZF9jdHgtPm11dGV4KTsKKworCXB1dF9jdHgoY2hpbGRfY3R4KTsKK30KKworLyoKKyAqIGZyZWUgYW4gdW5leHBvc2VkLCB1bnVzZWQgY29udGV4dCBhcyBjcmVhdGVkIGJ5IGluaGVyaXRhbmNlIGJ5CisgKiBpbml0X3Rhc2sgYmVsb3csIHVzZWQgYnkgZm9yaygpIGluIGNhc2Ugb2YgZmFpbC4KKyAqLwordm9pZCBwZXJmX2V2ZW50X2ZyZWVfdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gdGFzay0+cGVyZl9ldmVudF9jdHhwOworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgKnRtcDsKKworCWlmICghY3R4KQorCQlyZXR1cm47CisKKwltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKK2FnYWluOgorCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShldmVudCwgdG1wLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgeworCQlzdHJ1Y3QgcGVyZl9ldmVudCAqcGFyZW50ID0gZXZlbnQtPnBhcmVudDsKKworCQlpZiAoV0FSTl9PTl9PTkNFKCFwYXJlbnQpKQorCQkJY29udGludWU7CisKKwkJbXV0ZXhfbG9jaygmcGFyZW50LT5jaGlsZF9tdXRleCk7CisJCWxpc3RfZGVsX2luaXQoJmV2ZW50LT5jaGlsZF9saXN0KTsKKwkJbXV0ZXhfdW5sb2NrKCZwYXJlbnQtPmNoaWxkX211dGV4KTsKKworCQlmcHV0KHBhcmVudC0+ZmlscCk7CisKKwkJbGlzdF9kZWxfZXZlbnQoZXZlbnQsIGN0eCk7CisJCWZyZWVfZXZlbnQoZXZlbnQpOworCX0KKworCWlmICghbGlzdF9lbXB0eSgmY3R4LT5ncm91cF9saXN0KSkKKwkJZ290byBhZ2FpbjsKKworCW11dGV4X3VubG9jaygmY3R4LT5tdXRleCk7CisKKwlwdXRfY3R4KGN0eCk7Cit9CisKKy8qCisgKiBJbml0aWFsaXplIHRoZSBwZXJmX2V2ZW50IGNvbnRleHQgaW4gdGFza19zdHJ1Y3QKKyAqLworaW50IHBlcmZfZXZlbnRfaW5pdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCit7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2hpbGRfY3R4LCAqcGFyZW50X2N0eDsKKwlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjbG9uZWRfY3R4OworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKKwlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnBhcmVudCA9IGN1cnJlbnQ7CisJaW50IGluaGVyaXRlZF9hbGwgPSAxOworCWludCByZXQgPSAwOworCisJY2hpbGQtPnBlcmZfZXZlbnRfY3R4cCA9IE5VTEw7CisKKwltdXRleF9pbml0KCZjaGlsZC0+cGVyZl9ldmVudF9tdXRleCk7CisJSU5JVF9MSVNUX0hFQUQoJmNoaWxkLT5wZXJmX2V2ZW50X2xpc3QpOworCisJaWYgKGxpa2VseSghcGFyZW50LT5wZXJmX2V2ZW50X2N0eHApKQorCQlyZXR1cm4gMDsKKworCS8qCisJICogVGhpcyBpcyBleGVjdXRlZCBmcm9tIHRoZSBwYXJlbnQgdGFzayBjb250ZXh0LCBzbyBpbmhlcml0CisJICogZXZlbnRzIHRoYXQgaGF2ZSBiZWVuIG1hcmtlZCBmb3IgY2xvbmluZy4KKwkgKiBGaXJzdCBhbGxvY2F0ZSBhbmQgaW5pdGlhbGl6ZSBhIGNvbnRleHQgZm9yIHRoZSBjaGlsZC4KKwkgKi8KKworCWNoaWxkX2N0eCA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWNoaWxkX2N0eCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlfX3BlcmZfZXZlbnRfaW5pdF9jb250ZXh0KGNoaWxkX2N0eCwgY2hpbGQpOworCWNoaWxkLT5wZXJmX2V2ZW50X2N0eHAgPSBjaGlsZF9jdHg7CisJZ2V0X3Rhc2tfc3RydWN0KGNoaWxkKTsKKworCS8qCisJICogSWYgdGhlIHBhcmVudCdzIGNvbnRleHQgaXMgYSBjbG9uZSwgcGluIGl0IHNvIGl0IHdvbid0IGdldAorCSAqIHN3YXBwZWQgdW5kZXIgdXMuCisJICovCisJcGFyZW50X2N0eCA9IHBlcmZfcGluX3Rhc2tfY29udGV4dChwYXJlbnQpOworCisJLyoKKwkgKiBObyBuZWVkIHRvIGNoZWNrIGlmIHBhcmVudF9jdHggIT0gTlVMTCBoZXJlOyBzaW5jZSB3ZSBzYXcKKwkgKiBpdCBub24tTlVMTCBlYXJsaWVyLCB0aGUgb25seSByZWFzb24gZm9yIGl0IHRvIGJlY29tZSBOVUxMCisJICogaXMgaWYgd2UgZXhpdCwgYW5kIHNpbmNlIHdlJ3JlIGN1cnJlbnRseSBpbiB0aGUgbWlkZGxlIG9mCisJICogYSBmb3JrIHdlIGNhbid0IGJlIGV4aXRpbmcgYXQgdGhlIHNhbWUgdGltZS4KKwkgKi8KKworCS8qCisJICogTG9jayB0aGUgcGFyZW50IGxpc3QuIE5vIG5lZWQgdG8gbG9jayB0aGUgY2hpbGQgLSBub3QgUElECisJICogaGFzaGVkIHlldCBhbmQgbm90IHJ1bm5pbmcsIHNvIG5vYm9keSBjYW4gYWNjZXNzIGl0LgorCSAqLworCW11dGV4X2xvY2soJnBhcmVudF9jdHgtPm11dGV4KTsKKworCS8qCisJICogV2UgZG9udCBoYXZlIHRvIGRpc2FibGUgTk1JcyAtIHdlIGFyZSBvbmx5IGxvb2tpbmcgYXQKKwkgKiB0aGUgbGlzdCwgbm90IG1hbmlwdWxhdGluZyBpdDoKKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShldmVudCwgJnBhcmVudF9jdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7CisJCWlmIChldmVudCAhPSBldmVudC0+Z3JvdXBfbGVhZGVyKQorCQkJY29udGludWU7CisKKwkJaWYgKCFldmVudC0+YXR0ci5pbmhlcml0KSB7CisJCQlpbmhlcml0ZWRfYWxsID0gMDsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJcmV0ID0gaW5oZXJpdF9ncm91cChldmVudCwgcGFyZW50LCBwYXJlbnRfY3R4LAorCQkJCQkgICAgIGNoaWxkLCBjaGlsZF9jdHgpOworCQlpZiAocmV0KSB7CisJCQlpbmhlcml0ZWRfYWxsID0gMDsKKwkJCWJyZWFrOworCQl9CisJfQorCisJaWYgKGluaGVyaXRlZF9hbGwpIHsKKwkJLyoKKwkJICogTWFyayB0aGUgY2hpbGQgY29udGV4dCBhcyBhIGNsb25lIG9mIHRoZSBwYXJlbnQKKwkJICogY29udGV4dCwgb3Igb2Ygd2hhdGV2ZXIgdGhlIHBhcmVudCBpcyBhIGNsb25lIG9mLgorCQkgKiBOb3RlIHRoYXQgaWYgdGhlIHBhcmVudCBpcyBhIGNsb25lLCBpdCBjb3VsZCBnZXQKKwkJICogdW5jbG9uZWQgYXQgYW55IHBvaW50LCBidXQgdGhhdCBkb2Vzbid0IG1hdHRlcgorCQkgKiBiZWNhdXNlIHRoZSBsaXN0IG9mIGV2ZW50cyBhbmQgdGhlIGdlbmVyYXRpb24KKwkJICogY291bnQgY2FuJ3QgaGF2ZSBjaGFuZ2VkIHNpbmNlIHdlIHRvb2sgdGhlIG11dGV4LgorCQkgKi8KKwkJY2xvbmVkX2N0eCA9IHJjdV9kZXJlZmVyZW5jZShwYXJlbnRfY3R4LT5wYXJlbnRfY3R4KTsKKwkJaWYgKGNsb25lZF9jdHgpIHsKKwkJCWNoaWxkX2N0eC0+cGFyZW50X2N0eCA9IGNsb25lZF9jdHg7CisJCQljaGlsZF9jdHgtPnBhcmVudF9nZW4gPSBwYXJlbnRfY3R4LT5wYXJlbnRfZ2VuOworCQl9IGVsc2UgeworCQkJY2hpbGRfY3R4LT5wYXJlbnRfY3R4ID0gcGFyZW50X2N0eDsKKwkJCWNoaWxkX2N0eC0+cGFyZW50X2dlbiA9IHBhcmVudF9jdHgtPmdlbmVyYXRpb247CisJCX0KKwkJZ2V0X2N0eChjaGlsZF9jdHgtPnBhcmVudF9jdHgpOworCX0KKworCW11dGV4X3VubG9jaygmcGFyZW50X2N0eC0+bXV0ZXgpOworCisJcGVyZl91bnBpbl9jb250ZXh0KHBhcmVudF9jdHgpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19jcHVpbml0IHBlcmZfZXZlbnRfaW5pdF9jcHUoaW50IGNwdSkKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4OworCisJY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwlfX3BlcmZfZXZlbnRfaW5pdF9jb250ZXh0KCZjcHVjdHgtPmN0eCwgTlVMTCk7CisKKwlzcGluX2xvY2soJnBlcmZfcmVzb3VyY2VfbG9jayk7CisJY3B1Y3R4LT5tYXhfcGVydGFzayA9IHBlcmZfbWF4X2V2ZW50cyAtIHBlcmZfcmVzZXJ2ZWRfcGVyY3B1OworCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCisJaHdfcGVyZl9ldmVudF9zZXR1cChjcHUpOworfQorCisjaWZkZWYgQ09ORklHX0hPVFBMVUdfQ1BVCitzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfZXhpdF9jcHUodm9pZCAqaW5mbykKK3sKKwlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJl9fZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CisJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gJmNwdWN0eC0+Y3R4OworCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgKnRtcDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShldmVudCwgdG1wLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkKKwkJX19wZXJmX2V2ZW50X3JlbW92ZV9mcm9tX2NvbnRleHQoZXZlbnQpOworfQorc3RhdGljIHZvaWQgcGVyZl9ldmVudF9leGl0X2NwdShpbnQgY3B1KQoreworCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOworCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9ICZjcHVjdHgtPmN0eDsKKworCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOworCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjcHUsIF9fcGVyZl9ldmVudF9leGl0X2NwdSwgTlVMTCwgMSk7CisJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKK30KKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgcGVyZl9ldmVudF9leGl0X2NwdShpbnQgY3B1KSB7IH0KKyNlbmRpZgorCitzdGF0aWMgaW50IF9fY3B1aW5pdAorcGVyZl9jcHVfbm90aWZ5KHN0cnVjdCBub3RpZmllcl9ibG9jayAqc2VsZiwgdW5zaWduZWQgbG9uZyBhY3Rpb24sIHZvaWQgKmhjcHUpCit7CisJdW5zaWduZWQgaW50IGNwdSA9IChsb25nKWhjcHU7CisKKwlzd2l0Y2ggKGFjdGlvbikgeworCisJY2FzZSBDUFVfVVBfUFJFUEFSRToKKwljYXNlIENQVV9VUF9QUkVQQVJFX0ZST1pFTjoKKwkJcGVyZl9ldmVudF9pbml0X2NwdShjcHUpOworCQlicmVhazsKKworCWNhc2UgQ1BVX09OTElORToKKwljYXNlIENQVV9PTkxJTkVfRlJPWkVOOgorCQlod19wZXJmX2V2ZW50X3NldHVwX29ubGluZShjcHUpOworCQlicmVhazsKKworCWNhc2UgQ1BVX0RPV05fUFJFUEFSRToKKwljYXNlIENQVV9ET1dOX1BSRVBBUkVfRlJPWkVOOgorCQlwZXJmX2V2ZW50X2V4aXRfY3B1KGNwdSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuIE5PVElGWV9PSzsKK30KKworLyoKKyAqIFRoaXMgaGFzIHRvIGhhdmUgYSBoaWdoZXIgcHJpb3JpdHkgdGhhbiBtaWdyYXRpb25fbm90aWZpZXIgaW4gc2NoZWQuYy4KKyAqLworc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBfX2NwdWluaXRkYXRhIHBlcmZfY3B1X25iID0geworCS5ub3RpZmllcl9jYWxsCQk9IHBlcmZfY3B1X25vdGlmeSwKKwkucHJpb3JpdHkJCT0gMjAsCit9OworCit2b2lkIF9faW5pdCBwZXJmX2V2ZW50X2luaXQodm9pZCkKK3sKKwlwZXJmX2NwdV9ub3RpZnkoJnBlcmZfY3B1X25iLCAodW5zaWduZWQgbG9uZylDUFVfVVBfUFJFUEFSRSwKKwkJCSh2b2lkICopKGxvbmcpc21wX3Byb2Nlc3Nvcl9pZCgpKTsKKwlwZXJmX2NwdV9ub3RpZnkoJnBlcmZfY3B1X25iLCAodW5zaWduZWQgbG9uZylDUFVfT05MSU5FLAorCQkJKHZvaWQgKikobG9uZylzbXBfcHJvY2Vzc29yX2lkKCkpOworCXJlZ2lzdGVyX2NwdV9ub3RpZmllcigmcGVyZl9jcHVfbmIpOworfQorCitzdGF0aWMgc3NpemVfdCBwZXJmX3Nob3dfcmVzZXJ2ZV9wZXJjcHUoc3RydWN0IHN5c2Rldl9jbGFzcyAqY2xhc3MsIGNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgcGVyZl9yZXNlcnZlZF9wZXJjcHUpOworfQorCitzdGF0aWMgc3NpemVfdAorcGVyZl9zZXRfcmVzZXJ2ZV9wZXJjcHUoc3RydWN0IHN5c2Rldl9jbGFzcyAqY2xhc3MsCisJCQljb25zdCBjaGFyICpidWYsCisJCQlzaXplX3QgY291bnQpCit7CisJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKKwl1bnNpZ25lZCBsb25nIHZhbDsKKwlpbnQgZXJyLCBjcHUsIG1wdDsKKworCWVyciA9IHN0cmljdF9zdHJ0b3VsKGJ1ZiwgMTAsICZ2YWwpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisJaWYgKHZhbCA+IHBlcmZfbWF4X2V2ZW50cykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzcGluX2xvY2soJnBlcmZfcmVzb3VyY2VfbG9jayk7CisJcGVyZl9yZXNlcnZlZF9wZXJjcHUgPSB2YWw7CisJZm9yX2VhY2hfb25saW5lX2NwdShjcHUpIHsKKwkJY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKKwkJc3Bpbl9sb2NrX2lycSgmY3B1Y3R4LT5jdHgubG9jayk7CisJCW1wdCA9IG1pbihwZXJmX21heF9ldmVudHMgLSBjcHVjdHgtPmN0eC5ucl9ldmVudHMsCisJCQkgIHBlcmZfbWF4X2V2ZW50cyAtIHBlcmZfcmVzZXJ2ZWRfcGVyY3B1KTsKKwkJY3B1Y3R4LT5tYXhfcGVydGFzayA9IG1wdDsKKwkJc3Bpbl91bmxvY2tfaXJxKCZjcHVjdHgtPmN0eC5sb2NrKTsKKwl9CisJc3Bpbl91bmxvY2soJnBlcmZfcmVzb3VyY2VfbG9jayk7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBzc2l6ZV90IHBlcmZfc2hvd19vdmVyY29tbWl0KHN0cnVjdCBzeXNkZXZfY2xhc3MgKmNsYXNzLCBjaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHBlcmZfb3ZlcmNvbW1pdCk7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitwZXJmX3NldF9vdmVyY29tbWl0KHN0cnVjdCBzeXNkZXZfY2xhc3MgKmNsYXNzLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwl1bnNpZ25lZCBsb25nIHZhbDsKKwlpbnQgZXJyOworCisJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKwlpZiAodmFsID4gMSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzcGluX2xvY2soJnBlcmZfcmVzb3VyY2VfbG9jayk7CisJcGVyZl9vdmVyY29tbWl0ID0gdmFsOworCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOworCisJcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgU1lTREVWX0NMQVNTX0FUVFIoCisJCQkJcmVzZXJ2ZV9wZXJjcHUsCisJCQkJMDY0NCwKKwkJCQlwZXJmX3Nob3dfcmVzZXJ2ZV9wZXJjcHUsCisJCQkJcGVyZl9zZXRfcmVzZXJ2ZV9wZXJjcHUKKwkJCSk7CisKK3N0YXRpYyBTWVNERVZfQ0xBU1NfQVRUUigKKwkJCQlvdmVyY29tbWl0LAorCQkJCTA2NDQsCisJCQkJcGVyZl9zaG93X292ZXJjb21taXQsCisJCQkJcGVyZl9zZXRfb3ZlcmNvbW1pdAorCQkJKTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnBlcmZjbGFzc19hdHRyc1tdID0geworCSZhdHRyX3Jlc2VydmVfcGVyY3B1LmF0dHIsCisJJmF0dHJfb3ZlcmNvbW1pdC5hdHRyLAorCU5VTEwKK307CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIHBlcmZjbGFzc19hdHRyX2dyb3VwID0geworCS5hdHRycwkJCT0gcGVyZmNsYXNzX2F0dHJzLAorCS5uYW1lCQkJPSAicGVyZl9ldmVudHMiLAorfTsKKworc3RhdGljIGludCBfX2luaXQgcGVyZl9ldmVudF9zeXNmc19pbml0KHZvaWQpCit7CisJcmV0dXJuIHN5c2ZzX2NyZWF0ZV9ncm91cCgmY3B1X3N5c2Rldl9jbGFzcy5rc2V0LmtvYmosCisJCQkJICAmcGVyZmNsYXNzX2F0dHJfZ3JvdXApOworfQorZGV2aWNlX2luaXRjYWxsKHBlcmZfZXZlbnRfc3lzZnNfaW5pdCk7CmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWQuYyBiL2tlcm5lbC9zY2hlZC5jCmluZGV4IGZhZjRkNDYuLjI5MWM4ZDIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zY2hlZC5jCisrKyBiL2tlcm5lbC9zY2hlZC5jCkBAIC0zOSw3ICszOSw3IEBACiAjaW5jbHVkZSA8bGludXgvY29tcGxldGlvbi5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbF9zdGF0Lmg+CiAjaW5jbHVkZSA8bGludXgvZGVidWdfbG9ja3MuaD4KLSNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiAjaW5jbHVkZSA8bGludXgvc2VjdXJpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgogI2luY2x1ZGUgPGxpbnV4L3Byb2ZpbGUuaD4KQEAgLTIwNTksNyArMjA1OSw3IEBACiAJCWlmICh0YXNrX2hvdChwLCBvbGRfcnEtPmNsb2NrLCBOVUxMKSkKIAkJCXNjaGVkc3RhdF9pbmMocCwgc2UubnJfZm9yY2VkMl9taWdyYXRpb25zKTsKICNlbmRpZgotCQlwZXJmX3N3Y291bnRlcl9ldmVudChQRVJGX0NPVU5UX1NXX0NQVV9NSUdSQVRJT05TLAorCQlwZXJmX3N3X2V2ZW50KFBFUkZfQ09VTlRfU1dfQ1BVX01JR1JBVElPTlMsCiAJCQkJICAgICAxLCAxLCBOVUxMLCAwKTsKIAl9CiAJcC0+c2UudnJ1bnRpbWUgLT0gb2xkX2Nmc3JxLT5taW5fdnJ1bnRpbWUgLQpAQCAtMjcyNCw3ICsyNzI0LDcgQEAKIAkgKi8KIAlwcmV2X3N0YXRlID0gcHJldi0+c3RhdGU7CiAJZmluaXNoX2FyY2hfc3dpdGNoKHByZXYpOwotCXBlcmZfY291bnRlcl90YXNrX3NjaGVkX2luKGN1cnJlbnQsIGNwdV9vZihycSkpOworCXBlcmZfZXZlbnRfdGFza19zY2hlZF9pbihjdXJyZW50LCBjcHVfb2YocnEpKTsKIAlmaW5pc2hfbG9ja19zd2l0Y2gocnEsIHByZXYpOwogCiAJZmlyZV9zY2hlZF9pbl9wcmVlbXB0X25vdGlmaWVycyhjdXJyZW50KTsKQEAgLTUxOTksNyArNTE5OSw3IEBACiAJY3Vyci0+c2NoZWRfY2xhc3MtPnRhc2tfdGljayhycSwgY3VyciwgMCk7CiAJc3Bpbl91bmxvY2soJnJxLT5sb2NrKTsKIAotCXBlcmZfY291bnRlcl90YXNrX3RpY2soY3VyciwgY3B1KTsKKwlwZXJmX2V2ZW50X3Rhc2tfdGljayhjdXJyLCBjcHUpOwogCiAjaWZkZWYgQ09ORklHX1NNUAogCXJxLT5pZGxlX2F0X3RpY2sgPSBpZGxlX2NwdShjcHUpOwpAQCAtNTQxNSw3ICs1NDE1LDcgQEAKIAogCWlmIChsaWtlbHkocHJldiAhPSBuZXh0KSkgewogCQlzY2hlZF9pbmZvX3N3aXRjaChwcmV2LCBuZXh0KTsKLQkJcGVyZl9jb3VudGVyX3Rhc2tfc2NoZWRfb3V0KHByZXYsIG5leHQsIGNwdSk7CisJCXBlcmZfZXZlbnRfdGFza19zY2hlZF9vdXQocHJldiwgbmV4dCwgY3B1KTsKIAogCQlycS0+bnJfc3dpdGNoZXMrKzsKIAkJcnEtPmN1cnIgPSBuZXh0OwpAQCAtNzY5Miw3ICs3NjkyLDcgQEAKIC8qCiAgKiBSZWdpc3RlciBhdCBoaWdoIHByaW9yaXR5IHNvIHRoYXQgdGFzayBtaWdyYXRpb24gKG1pZ3JhdGVfYWxsX3Rhc2tzKQogICogaGFwcGVucyBiZWZvcmUgZXZlcnl0aGluZyBlbHNlLiAgVGhpcyBoYXMgdG8gYmUgbG93ZXIgcHJpb3JpdHkgdGhhbgotICogdGhlIG5vdGlmaWVyIGluIHRoZSBwZXJmX2NvdW50ZXIgc3Vic3lzdGVtLCB0aG91Z2guCisgKiB0aGUgbm90aWZpZXIgaW4gdGhlIHBlcmZfZXZlbnQgc3Vic3lzdGVtLCB0aG91Z2guCiAgKi8KIHN0YXRpYyBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgX19jcHVpbml0ZGF0YSBtaWdyYXRpb25fbm90aWZpZXIgPSB7CiAJLm5vdGlmaWVyX2NhbGwgPSBtaWdyYXRpb25fY2FsbCwKQEAgLTk1NDksNyArOTU0OSw3IEBACiAJYWxsb2NfY3B1bWFza192YXIoJmNwdV9pc29sYXRlZF9tYXAsIEdGUF9OT1dBSVQpOwogI2VuZGlmIC8qIFNNUCAqLwogCi0JcGVyZl9jb3VudGVyX2luaXQoKTsKKwlwZXJmX2V2ZW50X2luaXQoKTsKIAogCXNjaGVkdWxlcl9ydW5uaW5nID0gMTsKIH0KZGlmZiAtLWdpdCBhL2tlcm5lbC9zeXMuYyBiL2tlcm5lbC9zeXMuYwppbmRleCBiM2YxMDk3Li5lYTVjM2JjIDEwMDY0NAotLS0gYS9rZXJuZWwvc3lzLmMKKysrIGIva2VybmVsL3N5cy5jCkBAIC0xNCw3ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgvcHJjdGwuaD4KICNpbmNsdWRlIDxsaW51eC9oaWdodWlkLmg+CiAjaW5jbHVkZSA8bGludXgvZnMuaD4KLSNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiAjaW5jbHVkZSA8bGludXgvcmVzb3VyY2UuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9rZXhlYy5oPgpAQCAtMTUxMSwxMSArMTUxMSwxMSBAQAogCQljYXNlIFBSX1NFVF9UU0M6CiAJCQllcnJvciA9IFNFVF9UU0NfQ1RMKGFyZzIpOwogCQkJYnJlYWs7Ci0JCWNhc2UgUFJfVEFTS19QRVJGX0NPVU5URVJTX0RJU0FCTEU6Ci0JCQllcnJvciA9IHBlcmZfY291bnRlcl90YXNrX2Rpc2FibGUoKTsKKwkJY2FzZSBQUl9UQVNLX1BFUkZfRVZFTlRTX0RJU0FCTEU6CisJCQllcnJvciA9IHBlcmZfZXZlbnRfdGFza19kaXNhYmxlKCk7CiAJCQlicmVhazsKLQkJY2FzZSBQUl9UQVNLX1BFUkZfQ09VTlRFUlNfRU5BQkxFOgotCQkJZXJyb3IgPSBwZXJmX2NvdW50ZXJfdGFza19lbmFibGUoKTsKKwkJY2FzZSBQUl9UQVNLX1BFUkZfRVZFTlRTX0VOQUJMRToKKwkJCWVycm9yID0gcGVyZl9ldmVudF90YXNrX2VuYWJsZSgpOwogCQkJYnJlYWs7CiAJCWNhc2UgUFJfR0VUX1RJTUVSU0xBQ0s6CiAJCQllcnJvciA9IGN1cnJlbnQtPnRpbWVyX3NsYWNrX25zOwpkaWZmIC0tZ2l0IGEva2VybmVsL3N5c19uaS5jIGIva2VybmVsL3N5c19uaS5jCmluZGV4IDY4MzIwZjYuLjUxNWJjMjMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zeXNfbmkuYworKysgYi9rZXJuZWwvc3lzX25pLmMKQEAgLTE3Nyw0ICsxNzcsNCBAQAogY29uZF9zeXNjYWxsKHN5c19ldmVudGZkMik7CiAKIC8qIHBlcmZvcm1hbmNlIGNvdW50ZXJzOiAqLwotY29uZF9zeXNjYWxsKHN5c19wZXJmX2NvdW50ZXJfb3Blbik7Citjb25kX3N5c2NhbGwoc3lzX3BlcmZfZXZlbnRfb3Blbik7CmRpZmYgLS1naXQgYS9rZXJuZWwvc3lzY3RsLmMgYi9rZXJuZWwvc3lzY3RsLmMKaW5kZXggMWE2MzFiYS4uNmJhNDljNyAxMDA2NDQKLS0tIGEva2VybmVsL3N5c2N0bC5jCisrKyBiL2tlcm5lbC9zeXNjdGwuYwpAQCAtNTAsNyArNTAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3JlYm9vdC5oPgogI2luY2x1ZGUgPGxpbnV4L2Z0cmFjZS5oPgogI2luY2x1ZGUgPGxpbnV4L3Nsb3ctd29yay5oPgotI2luY2x1ZGUgPGxpbnV4L3BlcmZfY291bnRlci5oPgorI2luY2x1ZGUgPGxpbnV4L3BlcmZfZXZlbnQuaD4KIAogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiAjaW5jbHVkZSA8YXNtL3Byb2Nlc3Nvci5oPgpAQCAtOTY0LDI4ICs5NjQsMjggQEAKIAkJLmNoaWxkCQk9IHNsb3dfd29ya19zeXNjdGxzLAogCX0sCiAjZW5kaWYKLSNpZmRlZiBDT05GSUdfUEVSRl9DT1VOVEVSUworI2lmZGVmIENPTkZJR19QRVJGX0VWRU5UUwogCXsKIAkJLmN0bF9uYW1lCT0gQ1RMX1VOTlVNQkVSRUQsCi0JCS5wcm9jbmFtZQk9ICJwZXJmX2NvdW50ZXJfcGFyYW5vaWQiLAotCQkuZGF0YQkJPSAmc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCwKLQkJLm1heGxlbgkJPSBzaXplb2Yoc3lzY3RsX3BlcmZfY291bnRlcl9wYXJhbm9pZCksCisJCS5wcm9jbmFtZQk9ICJwZXJmX2V2ZW50X3BhcmFub2lkIiwKKwkJLmRhdGEJCT0gJnN5c2N0bF9wZXJmX2V2ZW50X3BhcmFub2lkLAorCQkubWF4bGVuCQk9IHNpemVvZihzeXNjdGxfcGVyZl9ldmVudF9wYXJhbm9pZCksCiAJCS5tb2RlCQk9IDA2NDQsCiAJCS5wcm9jX2hhbmRsZXIJPSAmcHJvY19kb2ludHZlYywKIAl9LAogCXsKIAkJLmN0bF9uYW1lCT0gQ1RMX1VOTlVNQkVSRUQsCi0JCS5wcm9jbmFtZQk9ICJwZXJmX2NvdW50ZXJfbWxvY2tfa2IiLAotCQkuZGF0YQkJPSAmc3lzY3RsX3BlcmZfY291bnRlcl9tbG9jaywKLQkJLm1heGxlbgkJPSBzaXplb2Yoc3lzY3RsX3BlcmZfY291bnRlcl9tbG9jayksCisJCS5wcm9jbmFtZQk9ICJwZXJmX2V2ZW50X21sb2NrX2tiIiwKKwkJLmRhdGEJCT0gJnN5c2N0bF9wZXJmX2V2ZW50X21sb2NrLAorCQkubWF4bGVuCQk9IHNpemVvZihzeXNjdGxfcGVyZl9ldmVudF9tbG9jayksCiAJCS5tb2RlCQk9IDA2NDQsCiAJCS5wcm9jX2hhbmRsZXIJPSAmcHJvY19kb2ludHZlYywKIAl9LAogCXsKIAkJLmN0bF9uYW1lCT0gQ1RMX1VOTlVNQkVSRUQsCi0JCS5wcm9jbmFtZQk9ICJwZXJmX2NvdW50ZXJfbWF4X3NhbXBsZV9yYXRlIiwKLQkJLmRhdGEJCT0gJnN5c2N0bF9wZXJmX2NvdW50ZXJfc2FtcGxlX3JhdGUsCi0JCS5tYXhsZW4JCT0gc2l6ZW9mKHN5c2N0bF9wZXJmX2NvdW50ZXJfc2FtcGxlX3JhdGUpLAorCQkucHJvY25hbWUJPSAicGVyZl9ldmVudF9tYXhfc2FtcGxlX3JhdGUiLAorCQkuZGF0YQkJPSAmc3lzY3RsX3BlcmZfZXZlbnRfc2FtcGxlX3JhdGUsCisJCS5tYXhsZW4JCT0gc2l6ZW9mKHN5c2N0bF9wZXJmX2V2ZW50X3NhbXBsZV9yYXRlKSwKIAkJLm1vZGUJCT0gMDY0NCwKIAkJLnByb2NfaGFuZGxlcgk9ICZwcm9jX2RvaW50dmVjLAogCX0sCmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZXIuYyBiL2tlcm5lbC90aW1lci5jCmluZGV4IGJiYjUxMDcuLjgxMWU1YzMgMTAwNjQ0Ci0tLSBhL2tlcm5lbC90aW1lci5jCisrKyBiL2tlcm5lbC90aW1lci5jCkBAIC0zNyw3ICszNyw3IEBACiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC90aWNrLmg+CiAjaW5jbHVkZSA8bGludXgva2FsbHN5bXMuaD4KLSNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiAjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CkBAIC0xMTg3LDcgKzExODcsNyBAQAogewogCXN0cnVjdCB0dmVjX2Jhc2UgKmJhc2UgPSBfX2dldF9jcHVfdmFyKHR2ZWNfYmFzZXMpOwogCi0JcGVyZl9jb3VudGVyX2RvX3BlbmRpbmcoKTsKKwlwZXJmX2V2ZW50X2RvX3BlbmRpbmcoKTsKIAogCWhydGltZXJfcnVuX3BlbmRpbmcoKTsKIApkaWZmIC0tZ2l0IGEva2VybmVsL3RyYWNlL3RyYWNlX3N5c2NhbGxzLmMgYi9rZXJuZWwvdHJhY2UvdHJhY2Vfc3lzY2FsbHMuYwppbmRleCA4NzEyY2UzLi4yMzNmMzQ4IDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2Vfc3lzY2FsbHMuYworKysgYi9rZXJuZWwvdHJhY2UvdHJhY2Vfc3lzY2FsbHMuYwpAQCAtMiw3ICsyLDcgQEAKICNpbmNsdWRlIDx0cmFjZS9ldmVudHMvc3lzY2FsbHMuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9mdHJhY2UuaD4KLSNpbmNsdWRlIDxsaW51eC9wZXJmX2NvdW50ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiAjaW5jbHVkZSA8YXNtL3N5c2NhbGwuaD4KIAogI2luY2x1ZGUgInRyYWNlX291dHB1dC5oIgpAQCAtNDE0LDcgKzQxNCw3IEBACiAJCXJlYy0+bnIgPSBzeXNjYWxsX25yOwogCQlzeXNjYWxsX2dldF9hcmd1bWVudHMoY3VycmVudCwgcmVncywgMCwgc3lzX2RhdGEtPm5iX2FyZ3MsCiAJCQkJICAgICAgICh1bnNpZ25lZCBsb25nICopJnJlYy0+YXJncyk7Ci0JCXBlcmZfdHBjb3VudGVyX2V2ZW50KHN5c19kYXRhLT5lbnRlcl9pZCwgMCwgMSwgcmVjLCBzaXplKTsKKwkJcGVyZl90cF9ldmVudChzeXNfZGF0YS0+ZW50ZXJfaWQsIDAsIDEsIHJlYywgc2l6ZSk7CiAJfSB3aGlsZSgwKTsKIH0KIApAQCAtNDc2LDcgKzQ3Niw3IEBACiAJcmVjLm5yID0gc3lzY2FsbF9ucjsKIAlyZWMucmV0ID0gc3lzY2FsbF9nZXRfcmV0dXJuX3ZhbHVlKGN1cnJlbnQsIHJlZ3MpOwogCi0JcGVyZl90cGNvdW50ZXJfZXZlbnQoc3lzX2RhdGEtPmV4aXRfaWQsIDAsIDEsICZyZWMsIHNpemVvZihyZWMpKTsKKwlwZXJmX3RwX2V2ZW50KHN5c19kYXRhLT5leGl0X2lkLCAwLCAxLCAmcmVjLCBzaXplb2YocmVjKSk7CiB9CiAKIGludCByZWdfcHJvZl9zeXNjYWxsX2V4aXQoY2hhciAqbmFtZSkK