LyoKICogUGVyZm9ybWFuY2UgZXZlbnRzIGNvcmUgY29kZToKICoKICogIENvcHlyaWdodCAoQykgMjAwOCBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KICogIENvcHlyaWdodCAoQykgMjAwOC0yMDA5IFJlZCBIYXQsIEluYy4sIEluZ28gTW9sbmFyCiAqICBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSBSZWQgSGF0LCBJbmMuLCBQZXRlciBaaWpsc3RyYSA8cHppamxzdHJAcmVkaGF0LmNvbT4KICogIENvcHlyaWdodCAgqSAgMjAwOSBQYXVsIE1hY2tlcnJhcywgSUJNIENvcnAuIDxwYXVsdXNAYXUxLmlibS5jb20+CiAqCiAqIEZvciBsaWNlbnNpbmcgZGV0YWlscyBzZWUga2VybmVsLWJhc2UvQ09QWUlORwogKi8KCiNpbmNsdWRlIDxsaW51eC9mcy5oPgojaW5jbHVkZSA8bGludXgvbW0uaD4KI2luY2x1ZGUgPGxpbnV4L2NwdS5oPgojaW5jbHVkZSA8bGludXgvc21wLmg+CiNpbmNsdWRlIDxsaW51eC9maWxlLmg+CiNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CiNpbmNsdWRlIDxsaW51eC9zeXNmcy5oPgojaW5jbHVkZSA8bGludXgvZGNhY2hlLmg+CiNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgojaW5jbHVkZSA8bGludXgvdm1zdGF0Lmg+CiNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+CiNpbmNsdWRlIDxsaW51eC9oYXJkaXJxLmg+CiNpbmNsdWRlIDxsaW51eC9yY3VsaXN0Lmg+CiNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CiNpbmNsdWRlIDxsaW51eC9zeXNjYWxscy5oPgojaW5jbHVkZSA8bGludXgvYW5vbl9pbm9kZXMuaD4KI2luY2x1ZGUgPGxpbnV4L2tlcm5lbF9zdGF0Lmg+CiNpbmNsdWRlIDxsaW51eC9wZXJmX2V2ZW50Lmg+CiNpbmNsdWRlIDxsaW51eC9mdHJhY2VfZXZlbnQuaD4KI2luY2x1ZGUgPGxpbnV4L2h3X2JyZWFrcG9pbnQuaD4KCiNpbmNsdWRlIDxhc20vaXJxX3JlZ3MuaD4KCi8qCiAqIEVhY2ggQ1BVIGhhcyBhIGxpc3Qgb2YgcGVyIENQVSBldmVudHM6CiAqLwpERUZJTkVfUEVSX0NQVShzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCwgcGVyZl9jcHVfY29udGV4dCk7CgppbnQgcGVyZl9tYXhfZXZlbnRzIF9fcmVhZF9tb3N0bHkgPSAxOwpzdGF0aWMgaW50IHBlcmZfcmVzZXJ2ZWRfcGVyY3B1IF9fcmVhZF9tb3N0bHk7CnN0YXRpYyBpbnQgcGVyZl9vdmVyY29tbWl0IF9fcmVhZF9tb3N0bHkgPSAxOwoKc3RhdGljIGF0b21pY190IG5yX2V2ZW50cyBfX3JlYWRfbW9zdGx5OwpzdGF0aWMgYXRvbWljX3QgbnJfbW1hcF9ldmVudHMgX19yZWFkX21vc3RseTsKc3RhdGljIGF0b21pY190IG5yX2NvbW1fZXZlbnRzIF9fcmVhZF9tb3N0bHk7CnN0YXRpYyBhdG9taWNfdCBucl90YXNrX2V2ZW50cyBfX3JlYWRfbW9zdGx5OwoKLyoKICogcGVyZiBldmVudCBwYXJhbm9pYSBsZXZlbDoKICogIC0xIC0gbm90IHBhcmFub2lkIGF0IGFsbAogKiAgIDAgLSBkaXNhbGxvdyByYXcgdHJhY2Vwb2ludCBhY2Nlc3MgZm9yIHVucHJpdgogKiAgIDEgLSBkaXNhbGxvdyBjcHUgZXZlbnRzIGZvciB1bnByaXYKICogICAyIC0gZGlzYWxsb3cga2VybmVsIHByb2ZpbGluZyBmb3IgdW5wcml2CiAqLwppbnQgc3lzY3RsX3BlcmZfZXZlbnRfcGFyYW5vaWQgX19yZWFkX21vc3RseSA9IDE7CgpzdGF0aWMgaW5saW5lIGJvb2wgcGVyZl9wYXJhbm9pZF90cmFjZXBvaW50X3Jhdyh2b2lkKQp7CglyZXR1cm4gc3lzY3RsX3BlcmZfZXZlbnRfcGFyYW5vaWQgPiAtMTsKfQoKc3RhdGljIGlubGluZSBib29sIHBlcmZfcGFyYW5vaWRfY3B1KHZvaWQpCnsKCXJldHVybiBzeXNjdGxfcGVyZl9ldmVudF9wYXJhbm9pZCA+IDA7Cn0KCnN0YXRpYyBpbmxpbmUgYm9vbCBwZXJmX3BhcmFub2lkX2tlcm5lbCh2b2lkKQp7CglyZXR1cm4gc3lzY3RsX3BlcmZfZXZlbnRfcGFyYW5vaWQgPiAxOwp9CgppbnQgc3lzY3RsX3BlcmZfZXZlbnRfbWxvY2sgX19yZWFkX21vc3RseSA9IDUxMjsgLyogJ2ZyZWUnIGtiIHBlciB1c2VyICovCgovKgogKiBtYXggcGVyZiBldmVudCBzYW1wbGUgcmF0ZQogKi8KaW50IHN5c2N0bF9wZXJmX2V2ZW50X3NhbXBsZV9yYXRlIF9fcmVhZF9tb3N0bHkgPSAxMDAwMDA7CgpzdGF0aWMgYXRvbWljNjRfdCBwZXJmX2V2ZW50X2lkOwoKLyoKICogTG9jayBmb3IgKHN5c2FkbWluLWNvbmZpZ3VyYWJsZSkgZXZlbnQgcmVzZXJ2YXRpb25zOgogKi8Kc3RhdGljIERFRklORV9TUElOTE9DSyhwZXJmX3Jlc291cmNlX2xvY2spOwoKLyoKICogQXJjaGl0ZWN0dXJlIHByb3ZpZGVkIEFQSXMgLSB3ZWFrIGFsaWFzZXM6CiAqLwpleHRlcm4gX193ZWFrIGNvbnN0IHN0cnVjdCBwbXUgKmh3X3BlcmZfZXZlbnRfaW5pdChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXJldHVybiBOVUxMOwp9Cgp2b2lkIF9fd2VhayBod19wZXJmX2Rpc2FibGUodm9pZCkJCXsgYmFycmllcigpOyB9CnZvaWQgX193ZWFrIGh3X3BlcmZfZW5hYmxlKHZvaWQpCQl7IGJhcnJpZXIoKTsgfQoKdm9pZCBfX3dlYWsgaHdfcGVyZl9ldmVudF9zZXR1cChpbnQgY3B1KQl7IGJhcnJpZXIoKTsgfQp2b2lkIF9fd2VhayBod19wZXJmX2V2ZW50X3NldHVwX29ubGluZShpbnQgY3B1KQl7IGJhcnJpZXIoKTsgfQoKaW50IF9fd2Vhawpod19wZXJmX2dyb3VwX3NjaGVkX2luKHN0cnVjdCBwZXJmX2V2ZW50ICpncm91cF9sZWFkZXIsCgkgICAgICAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKCSAgICAgICBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsIGludCBjcHUpCnsKCXJldHVybiAwOwp9Cgp2b2lkIF9fd2VhayBwZXJmX2V2ZW50X3ByaW50X2RlYnVnKHZvaWQpCXsgfQoKc3RhdGljIERFRklORV9QRVJfQ1BVKGludCwgcGVyZl9kaXNhYmxlX2NvdW50KTsKCnZvaWQgX19wZXJmX2Rpc2FibGUodm9pZCkKewoJX19nZXRfY3B1X3ZhcihwZXJmX2Rpc2FibGVfY291bnQpKys7Cn0KCmJvb2wgX19wZXJmX2VuYWJsZSh2b2lkKQp7CglyZXR1cm4gIS0tX19nZXRfY3B1X3ZhcihwZXJmX2Rpc2FibGVfY291bnQpOwp9Cgp2b2lkIHBlcmZfZGlzYWJsZSh2b2lkKQp7CglfX3BlcmZfZGlzYWJsZSgpOwoJaHdfcGVyZl9kaXNhYmxlKCk7Cn0KCnZvaWQgcGVyZl9lbmFibGUodm9pZCkKewoJaWYgKF9fcGVyZl9lbmFibGUoKSkKCQlod19wZXJmX2VuYWJsZSgpOwp9CgpzdGF0aWMgdm9pZCBnZXRfY3R4KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKewoJV0FSTl9PTighYXRvbWljX2luY19ub3RfemVybygmY3R4LT5yZWZjb3VudCkpOwp9CgpzdGF0aWMgdm9pZCBmcmVlX2N0eChzdHJ1Y3QgcmN1X2hlYWQgKmhlYWQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCgljdHggPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCwgcmN1X2hlYWQpOwoJa2ZyZWUoY3R4KTsKfQoKc3RhdGljIHZvaWQgcHV0X2N0eChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCnsKCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZjdHgtPnJlZmNvdW50KSkgewoJCWlmIChjdHgtPnBhcmVudF9jdHgpCgkJCXB1dF9jdHgoY3R4LT5wYXJlbnRfY3R4KTsKCQlpZiAoY3R4LT50YXNrKQoJCQlwdXRfdGFza19zdHJ1Y3QoY3R4LT50YXNrKTsKCQljYWxsX3JjdSgmY3R4LT5yY3VfaGVhZCwgZnJlZV9jdHgpOwoJfQp9CgpzdGF0aWMgdm9pZCB1bmNsb25lX2N0eChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCnsKCWlmIChjdHgtPnBhcmVudF9jdHgpIHsKCQlwdXRfY3R4KGN0eC0+cGFyZW50X2N0eCk7CgkJY3R4LT5wYXJlbnRfY3R4ID0gTlVMTDsKCX0KfQoKLyoKICogSWYgd2UgaW5oZXJpdCBldmVudHMgd2Ugd2FudCB0byByZXR1cm4gdGhlIHBhcmVudCBldmVudCBpZAogKiB0byB1c2Vyc3BhY2UuCiAqLwpzdGF0aWMgdTY0IHByaW1hcnlfZXZlbnRfaWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7Cgl1NjQgaWQgPSBldmVudC0+aWQ7CgoJaWYgKGV2ZW50LT5wYXJlbnQpCgkJaWQgPSBldmVudC0+cGFyZW50LT5pZDsKCglyZXR1cm4gaWQ7Cn0KCi8qCiAqIEdldCB0aGUgcGVyZl9ldmVudF9jb250ZXh0IGZvciBhIHRhc2sgYW5kIGxvY2sgaXQuCiAqIFRoaXMgaGFzIHRvIGNvcGUgd2l0aCB3aXRoIHRoZSBmYWN0IHRoYXQgdW50aWwgaXQgaXMgbG9ja2VkLAogKiB0aGUgY29udGV4dCBjb3VsZCBnZXQgbW92ZWQgdG8gYW5vdGhlciB0YXNrLgogKi8Kc3RhdGljIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKgpwZXJmX2xvY2tfdGFza19jb250ZXh0KHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaywgdW5zaWduZWQgbG9uZyAqZmxhZ3MpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCglyY3VfcmVhZF9sb2NrKCk7CiByZXRyeToKCWN0eCA9IHJjdV9kZXJlZmVyZW5jZSh0YXNrLT5wZXJmX2V2ZW50X2N0eHApOwoJaWYgKGN0eCkgewoJCS8qCgkJICogSWYgdGhpcyBjb250ZXh0IGlzIGEgY2xvbmUgb2YgYW5vdGhlciwgaXQgbWlnaHQKCQkgKiBnZXQgc3dhcHBlZCBmb3IgYW5vdGhlciB1bmRlcm5lYXRoIHVzIGJ5CgkJICogcGVyZl9ldmVudF90YXNrX3NjaGVkX291dCwgdGhvdWdoIHRoZQoJCSAqIHJjdV9yZWFkX2xvY2soKSBwcm90ZWN0cyB1cyBmcm9tIGFueSBjb250ZXh0CgkJICogZ2V0dGluZyBmcmVlZC4gIExvY2sgdGhlIGNvbnRleHQgYW5kIGNoZWNrIGlmIGl0CgkJICogZ290IHN3YXBwZWQgYmVmb3JlIHdlIGNvdWxkIGdldCB0aGUgbG9jaywgYW5kIHJldHJ5CgkJICogaWYgc28uICBJZiB3ZSBsb2NrZWQgdGhlIHJpZ2h0IGNvbnRleHQsIHRoZW4gaXQKCQkgKiBjYW4ndCBnZXQgc3dhcHBlZCBvbiB1cyBhbnkgbW9yZS4KCQkgKi8KCQlzcGluX2xvY2tfaXJxc2F2ZSgmY3R4LT5sb2NrLCAqZmxhZ3MpOwoJCWlmIChjdHggIT0gcmN1X2RlcmVmZXJlbmNlKHRhc2stPnBlcmZfZXZlbnRfY3R4cCkpIHsKCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCAqZmxhZ3MpOwoJCQlnb3RvIHJldHJ5OwoJCX0KCgkJaWYgKCFhdG9taWNfaW5jX25vdF96ZXJvKCZjdHgtPnJlZmNvdW50KSkgewoJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjdHgtPmxvY2ssICpmbGFncyk7CgkJCWN0eCA9IE5VTEw7CgkJfQoJfQoJcmN1X3JlYWRfdW5sb2NrKCk7CglyZXR1cm4gY3R4Owp9CgovKgogKiBHZXQgdGhlIGNvbnRleHQgZm9yIGEgdGFzayBhbmQgaW5jcmVtZW50IGl0cyBwaW5fY291bnQgc28gaXQKICogY2FuJ3QgZ2V0IHN3YXBwZWQgdG8gYW5vdGhlciB0YXNrLiAgVGhpcyBhbHNvIGluY3JlbWVudHMgaXRzCiAqIHJlZmVyZW5jZSBjb3VudCBzbyB0aGF0IHRoZSBjb250ZXh0IGNhbid0IGdldCBmcmVlZC4KICovCnN0YXRpYyBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpwZXJmX3Bpbl90YXNrX2NvbnRleHQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQp7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCWN0eCA9IHBlcmZfbG9ja190YXNrX2NvbnRleHQodGFzaywgJmZsYWdzKTsKCWlmIChjdHgpIHsKCQkrK2N0eC0+cGluX2NvdW50OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0eC0+bG9jaywgZmxhZ3MpOwoJfQoJcmV0dXJuIGN0eDsKfQoKc3RhdGljIHZvaWQgcGVyZl91bnBpbl9jb250ZXh0KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglzcGluX2xvY2tfaXJxc2F2ZSgmY3R4LT5sb2NrLCBmbGFncyk7CgktLWN0eC0+cGluX2NvdW50OwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY3R4LT5sb2NrLCBmbGFncyk7CglwdXRfY3R4KGN0eCk7Cn0KCi8qCiAqIEFkZCBhIGV2ZW50IGZyb20gdGhlIGxpc3RzIGZvciBpdHMgY29udGV4dC4KICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGFuZCBjdHgtPmxvY2sgaGVsZC4KICovCnN0YXRpYyB2b2lkCmxpc3RfYWRkX2V2ZW50KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBfbGVhZGVyID0gZXZlbnQtPmdyb3VwX2xlYWRlcjsKCgkvKgoJICogRGVwZW5kaW5nIG9uIHdoZXRoZXIgaXQgaXMgYSBzdGFuZGFsb25lIG9yIHNpYmxpbmcgZXZlbnQsCgkgKiBhZGQgaXQgc3RyYWlnaHQgdG8gdGhlIGNvbnRleHQncyBldmVudCBsaXN0LCBvciB0byB0aGUgZ3JvdXAKCSAqIGxlYWRlcidzIHNpYmxpbmcgbGlzdDoKCSAqLwoJaWYgKGdyb3VwX2xlYWRlciA9PSBldmVudCkKCQlsaXN0X2FkZF90YWlsKCZldmVudC0+Z3JvdXBfZW50cnksICZjdHgtPmdyb3VwX2xpc3QpOwoJZWxzZSB7CgkJbGlzdF9hZGRfdGFpbCgmZXZlbnQtPmdyb3VwX2VudHJ5LCAmZ3JvdXBfbGVhZGVyLT5zaWJsaW5nX2xpc3QpOwoJCWdyb3VwX2xlYWRlci0+bnJfc2libGluZ3MrKzsKCX0KCglsaXN0X2FkZF9yY3UoJmV2ZW50LT5ldmVudF9lbnRyeSwgJmN0eC0+ZXZlbnRfbGlzdCk7CgljdHgtPm5yX2V2ZW50cysrOwoJaWYgKGV2ZW50LT5hdHRyLmluaGVyaXRfc3RhdCkKCQljdHgtPm5yX3N0YXQrKzsKfQoKLyoKICogUmVtb3ZlIGEgZXZlbnQgZnJvbSB0aGUgbGlzdHMgZm9yIGl0cyBjb250ZXh0LgogKiBNdXN0IGJlIGNhbGxlZCB3aXRoIGN0eC0+bXV0ZXggYW5kIGN0eC0+bG9jayBoZWxkLgogKi8Kc3RhdGljIHZvaWQKbGlzdF9kZWxfZXZlbnQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpzaWJsaW5nLCAqdG1wOwoKCWlmIChsaXN0X2VtcHR5KCZldmVudC0+Z3JvdXBfZW50cnkpKQoJCXJldHVybjsKCWN0eC0+bnJfZXZlbnRzLS07CglpZiAoZXZlbnQtPmF0dHIuaW5oZXJpdF9zdGF0KQoJCWN0eC0+bnJfc3RhdC0tOwoKCWxpc3RfZGVsX2luaXQoJmV2ZW50LT5ncm91cF9lbnRyeSk7CglsaXN0X2RlbF9yY3UoJmV2ZW50LT5ldmVudF9lbnRyeSk7CgoJaWYgKGV2ZW50LT5ncm91cF9sZWFkZXIgIT0gZXZlbnQpCgkJZXZlbnQtPmdyb3VwX2xlYWRlci0+bnJfc2libGluZ3MtLTsKCgkvKgoJICogSWYgdGhpcyB3YXMgYSBncm91cCBldmVudCB3aXRoIHNpYmxpbmcgZXZlbnRzIHRoZW4KCSAqIHVwZ3JhZGUgdGhlIHNpYmxpbmdzIHRvIHNpbmdsZXRvbiBldmVudHMgYnkgYWRkaW5nIHRoZW0KCSAqIHRvIHRoZSBjb250ZXh0IGxpc3QgZGlyZWN0bHk6CgkgKi8KCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShzaWJsaW5nLCB0bXAsICZldmVudC0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkgewoKCQlsaXN0X21vdmVfdGFpbCgmc2libGluZy0+Z3JvdXBfZW50cnksICZjdHgtPmdyb3VwX2xpc3QpOwoJCXNpYmxpbmctPmdyb3VwX2xlYWRlciA9IHNpYmxpbmc7Cgl9Cn0KCnN0YXRpYyB2b2lkCmV2ZW50X3NjaGVkX291dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCgkJICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAoJCSAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQp7CglpZiAoZXZlbnQtPnN0YXRlICE9IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQoJCXJldHVybjsKCglldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOwoJaWYgKGV2ZW50LT5wZW5kaW5nX2Rpc2FibGUpIHsKCQlldmVudC0+cGVuZGluZ19kaXNhYmxlID0gMDsKCQlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX09GRjsKCX0KCWV2ZW50LT50c3RhbXBfc3RvcHBlZCA9IGN0eC0+dGltZTsKCWV2ZW50LT5wbXUtPmRpc2FibGUoZXZlbnQpOwoJZXZlbnQtPm9uY3B1ID0gLTE7CgoJaWYgKCFpc19zb2Z0d2FyZV9ldmVudChldmVudCkpCgkJY3B1Y3R4LT5hY3RpdmVfb25jcHUtLTsKCWN0eC0+bnJfYWN0aXZlLS07CglpZiAoZXZlbnQtPmF0dHIuZXhjbHVzaXZlIHx8ICFjcHVjdHgtPmFjdGl2ZV9vbmNwdSkKCQljcHVjdHgtPmV4Y2x1c2l2ZSA9IDA7Cn0KCnN0YXRpYyB2b2lkCmdyb3VwX3NjaGVkX291dChzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBfZXZlbnQsCgkJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKCQlzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCglpZiAoZ3JvdXBfZXZlbnQtPnN0YXRlICE9IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQoJCXJldHVybjsKCglldmVudF9zY2hlZF9vdXQoZ3JvdXBfZXZlbnQsIGNwdWN0eCwgY3R4KTsKCgkvKgoJICogU2NoZWR1bGUgb3V0IHNpYmxpbmdzIChpZiBhbnkpOgoJICovCglsaXN0X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmZ3JvdXBfZXZlbnQtPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpCgkJZXZlbnRfc2NoZWRfb3V0KGV2ZW50LCBjcHVjdHgsIGN0eCk7CgoJaWYgKGdyb3VwX2V2ZW50LT5hdHRyLmV4Y2x1c2l2ZSkKCQljcHVjdHgtPmV4Y2x1c2l2ZSA9IDA7Cn0KCi8qCiAqIENyb3NzIENQVSBjYWxsIHRvIHJlbW92ZSBhIHBlcmZvcm1hbmNlIGV2ZW50CiAqCiAqIFdlIGRpc2FibGUgdGhlIGV2ZW50IG9uIHRoZSBoYXJkd2FyZSBsZXZlbCBmaXJzdC4gQWZ0ZXIgdGhhdCB3ZQogKiByZW1vdmUgaXQgZnJvbSB0aGUgY29udGV4dCBsaXN0LgogKi8Kc3RhdGljIHZvaWQgX19wZXJmX2V2ZW50X3JlbW92ZV9mcm9tX2NvbnRleHQodm9pZCAqaW5mbykKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gaW5mbzsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CgoJLyoKCSAqIElmIHRoaXMgaXMgYSB0YXNrIGNvbnRleHQsIHdlIG5lZWQgdG8gY2hlY2sgd2hldGhlciBpdCBpcwoJICogdGhlIGN1cnJlbnQgdGFzayBjb250ZXh0IG9mIHRoaXMgY3B1LiBJZiBub3QgaXQgaGFzIGJlZW4KCSAqIHNjaGVkdWxlZCBvdXQgYmVmb3JlIHRoZSBzbXAgY2FsbCBhcnJpdmVkLgoJICovCglpZiAoY3R4LT50YXNrICYmIGNwdWN0eC0+dGFza19jdHggIT0gY3R4KQoJCXJldHVybjsKCglzcGluX2xvY2soJmN0eC0+bG9jayk7CgkvKgoJICogUHJvdGVjdCB0aGUgbGlzdCBvcGVyYXRpb24gYWdhaW5zdCBOTUkgYnkgZGlzYWJsaW5nIHRoZQoJICogZXZlbnRzIG9uIGEgZ2xvYmFsIGxldmVsLgoJICovCglwZXJmX2Rpc2FibGUoKTsKCglldmVudF9zY2hlZF9vdXQoZXZlbnQsIGNwdWN0eCwgY3R4KTsKCglsaXN0X2RlbF9ldmVudChldmVudCwgY3R4KTsKCglpZiAoIWN0eC0+dGFzaykgewoJCS8qCgkJICogQWxsb3cgbW9yZSBwZXIgdGFzayBldmVudHMgd2l0aCByZXNwZWN0IHRvIHRoZQoJCSAqIHJlc2VydmF0aW9uOgoJCSAqLwoJCWNwdWN0eC0+bWF4X3BlcnRhc2sgPQoJCQltaW4ocGVyZl9tYXhfZXZlbnRzIC0gY3R4LT5ucl9ldmVudHMsCgkJCSAgICBwZXJmX21heF9ldmVudHMgLSBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7Cgl9CgoJcGVyZl9lbmFibGUoKTsKCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwp9CgoKLyoKICogUmVtb3ZlIHRoZSBldmVudCBmcm9tIGEgdGFzaydzIChvciBhIENQVSdzKSBsaXN0IG9mIGV2ZW50cy4KICoKICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQuCiAqCiAqIENQVSBldmVudHMgYXJlIHJlbW92ZWQgd2l0aCBhIHNtcCBjYWxsLiBGb3IgdGFzayBldmVudHMgd2Ugb25seQogKiBjYWxsIHdoZW4gdGhlIHRhc2sgaXMgb24gYSBDUFUuCiAqCiAqIElmIGV2ZW50LT5jdHggaXMgYSBjbG9uZWQgY29udGV4dCwgY2FsbGVycyBtdXN0IG1ha2Ugc3VyZSB0aGF0CiAqIGV2ZXJ5IHRhc2sgc3RydWN0IHRoYXQgZXZlbnQtPmN0eC0+dGFzayBjb3VsZCBwb3NzaWJseSBwb2ludCB0bwogKiByZW1haW5zIHZhbGlkLiAgVGhpcyBpcyBPSyB3aGVuIGNhbGxlZCBmcm9tIHBlcmZfcmVsZWFzZSBzaW5jZQogKiB0aGF0IG9ubHkgY2FsbHMgdXMgb24gdGhlIHRvcC1sZXZlbCBjb250ZXh0LCB3aGljaCBjYW4ndCBiZSBhIGNsb25lLgogKiBXaGVuIGNhbGxlZCBmcm9tIHBlcmZfZXZlbnRfZXhpdF90YXNrLCBpdCdzIE9LIGJlY2F1c2UgdGhlCiAqIGNvbnRleHQgaGFzIGJlZW4gZGV0YWNoZWQgZnJvbSBpdHMgdGFzay4KICovCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CglzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2sgPSBjdHgtPnRhc2s7CgoJaWYgKCF0YXNrKSB7CgkJLyoKCQkgKiBQZXIgY3B1IGV2ZW50cyBhcmUgcmVtb3ZlZCB2aWEgYW4gc21wIGNhbGwgYW5kCgkJICogdGhlIHJlbW92YWwgaXMgYWx3YXlzIHN1Y2Vzc2Z1bC4KCQkgKi8KCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoZXZlbnQtPmNwdSwKCQkJCQkgX19wZXJmX2V2ZW50X3JlbW92ZV9mcm9tX2NvbnRleHQsCgkJCQkJIGV2ZW50LCAxKTsKCQlyZXR1cm47Cgl9CgpyZXRyeToKCXRhc2tfb25jcHVfZnVuY3Rpb25fY2FsbCh0YXNrLCBfX3BlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dCwKCQkJCSBldmVudCk7CgoJc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKCS8qCgkgKiBJZiB0aGUgY29udGV4dCBpcyBhY3RpdmUgd2UgbmVlZCB0byByZXRyeSB0aGUgc21wIGNhbGwuCgkgKi8KCWlmIChjdHgtPm5yX2FjdGl2ZSAmJiAhbGlzdF9lbXB0eSgmZXZlbnQtPmdyb3VwX2VudHJ5KSkgewoJCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKCQlnb3RvIHJldHJ5OwoJfQoKCS8qCgkgKiBUaGUgbG9jayBwcmV2ZW50cyB0aGF0IHRoaXMgY29udGV4dCBpcyBzY2hlZHVsZWQgaW4gc28gd2UKCSAqIGNhbiByZW1vdmUgdGhlIGV2ZW50IHNhZmVseSwgaWYgdGhlIGNhbGwgYWJvdmUgZGlkIG5vdAoJICogc3VjY2VlZC4KCSAqLwoJaWYgKCFsaXN0X2VtcHR5KCZldmVudC0+Z3JvdXBfZW50cnkpKSB7CgkJbGlzdF9kZWxfZXZlbnQoZXZlbnQsIGN0eCk7Cgl9CglzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7Cn0KCnN0YXRpYyBpbmxpbmUgdTY0IHBlcmZfY2xvY2sodm9pZCkKewoJcmV0dXJuIGNwdV9jbG9jayhzbXBfcHJvY2Vzc29yX2lkKCkpOwp9CgovKgogKiBVcGRhdGUgdGhlIHJlY29yZCBvZiB0aGUgY3VycmVudCB0aW1lIGluIGEgY29udGV4dC4KICovCnN0YXRpYyB2b2lkIHVwZGF0ZV9jb250ZXh0X3RpbWUoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQp7Cgl1NjQgbm93ID0gcGVyZl9jbG9jaygpOwoKCWN0eC0+dGltZSArPSBub3cgLSBjdHgtPnRpbWVzdGFtcDsKCWN0eC0+dGltZXN0YW1wID0gbm93Owp9CgovKgogKiBVcGRhdGUgdGhlIHRvdGFsX3RpbWVfZW5hYmxlZCBhbmQgdG90YWxfdGltZV9ydW5uaW5nIGZpZWxkcyBmb3IgYSBldmVudC4KICovCnN0YXRpYyB2b2lkIHVwZGF0ZV9ldmVudF90aW1lcyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7Cgl1NjQgcnVuX2VuZDsKCglpZiAoZXZlbnQtPnN0YXRlIDwgUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSB8fAoJICAgIGV2ZW50LT5ncm91cF9sZWFkZXItPnN0YXRlIDwgUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKCQlyZXR1cm47CgoJZXZlbnQtPnRvdGFsX3RpbWVfZW5hYmxlZCA9IGN0eC0+dGltZSAtIGV2ZW50LT50c3RhbXBfZW5hYmxlZDsKCglpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpCgkJcnVuX2VuZCA9IGV2ZW50LT50c3RhbXBfc3RvcHBlZDsKCWVsc2UKCQlydW5fZW5kID0gY3R4LT50aW1lOwoKCWV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcgPSBydW5fZW5kIC0gZXZlbnQtPnRzdGFtcF9ydW5uaW5nOwp9CgovKgogKiBVcGRhdGUgdG90YWxfdGltZV9lbmFibGVkIGFuZCB0b3RhbF90aW1lX3J1bm5pbmcgZm9yIGFsbCBldmVudHMgaW4gYSBncm91cC4KICovCnN0YXRpYyB2b2lkIHVwZGF0ZV9ncm91cF90aW1lcyhzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CgoJdXBkYXRlX2V2ZW50X3RpbWVzKGxlYWRlcik7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmbGVhZGVyLT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KQoJCXVwZGF0ZV9ldmVudF90aW1lcyhldmVudCk7Cn0KCi8qCiAqIENyb3NzIENQVSBjYWxsIHRvIGRpc2FibGUgYSBwZXJmb3JtYW5jZSBldmVudAogKi8Kc3RhdGljIHZvaWQgX19wZXJmX2V2ZW50X2Rpc2FibGUodm9pZCAqaW5mbykKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gaW5mbzsKCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CgoJLyoKCSAqIElmIHRoaXMgaXMgYSBwZXItdGFzayBldmVudCwgbmVlZCB0byBjaGVjayB3aGV0aGVyIHRoaXMKCSAqIGV2ZW50J3MgdGFzayBpcyB0aGUgY3VycmVudCB0YXNrIG9uIHRoaXMgY3B1LgoJICovCglpZiAoY3R4LT50YXNrICYmIGNwdWN0eC0+dGFza19jdHggIT0gY3R4KQoJCXJldHVybjsKCglzcGluX2xvY2soJmN0eC0+bG9jayk7CgoJLyoKCSAqIElmIHRoZSBldmVudCBpcyBvbiwgdHVybiBpdCBvZmYuCgkgKiBJZiBpdCBpcyBpbiBlcnJvciBzdGF0ZSwgbGVhdmUgaXQgaW4gZXJyb3Igc3RhdGUuCgkgKi8KCWlmIChldmVudC0+c3RhdGUgPj0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkgewoJCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKCQl1cGRhdGVfZ3JvdXBfdGltZXMoZXZlbnQpOwoJCWlmIChldmVudCA9PSBldmVudC0+Z3JvdXBfbGVhZGVyKQoJCQlncm91cF9zY2hlZF9vdXQoZXZlbnQsIGNwdWN0eCwgY3R4KTsKCQllbHNlCgkJCWV2ZW50X3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOwoJCWV2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGOwoJfQoKCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwp9CgovKgogKiBEaXNhYmxlIGEgZXZlbnQuCiAqCiAqIElmIGV2ZW50LT5jdHggaXMgYSBjbG9uZWQgY29udGV4dCwgY2FsbGVycyBtdXN0IG1ha2Ugc3VyZSB0aGF0CiAqIGV2ZXJ5IHRhc2sgc3RydWN0IHRoYXQgZXZlbnQtPmN0eC0+dGFzayBjb3VsZCBwb3NzaWJseSBwb2ludCB0bwogKiByZW1haW5zIHZhbGlkLiAgVGhpcyBjb25kaXRpb24gaXMgc2F0aXNpZmVkIHdoZW4gY2FsbGVkIHRocm91Z2gKICogcGVyZl9ldmVudF9mb3JfZWFjaF9jaGlsZCBvciBwZXJmX2V2ZW50X2Zvcl9lYWNoIGJlY2F1c2UgdGhleQogKiBob2xkIHRoZSB0b3AtbGV2ZWwgZXZlbnQncyBjaGlsZF9tdXRleCwgc28gYW55IGRlc2NlbmRhbnQgdGhhdAogKiBnb2VzIHRvIGV4aXQgd2lsbCBibG9jayBpbiBzeW5jX2NoaWxkX2V2ZW50LgogKiBXaGVuIGNhbGxlZCBmcm9tIHBlcmZfcGVuZGluZ19ldmVudCBpdCdzIE9LIGJlY2F1c2UgZXZlbnQtPmN0eAogKiBpcyB0aGUgY3VycmVudCBjb250ZXh0IG9uIHRoaXMgQ1BVIGFuZCBwcmVlbXB0aW9uIGlzIGRpc2FibGVkLAogKiBoZW5jZSB3ZSBjYW4ndCBnZXQgaW50byBwZXJmX2V2ZW50X3Rhc2tfc2NoZWRfb3V0IGZvciB0aGlzIGNvbnRleHQuCiAqLwpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2Rpc2FibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OwoJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gY3R4LT50YXNrOwoKCWlmICghdGFzaykgewoJCS8qCgkJICogRGlzYWJsZSB0aGUgZXZlbnQgb24gdGhlIGNwdSB0aGF0IGl0J3Mgb24KCQkgKi8KCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoZXZlbnQtPmNwdSwgX19wZXJmX2V2ZW50X2Rpc2FibGUsCgkJCQkJIGV2ZW50LCAxKTsKCQlyZXR1cm47Cgl9CgogcmV0cnk6Cgl0YXNrX29uY3B1X2Z1bmN0aW9uX2NhbGwodGFzaywgX19wZXJmX2V2ZW50X2Rpc2FibGUsIGV2ZW50KTsKCglzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOwoJLyoKCSAqIElmIHRoZSBldmVudCBpcyBzdGlsbCBhY3RpdmUsIHdlIG5lZWQgdG8gcmV0cnkgdGhlIGNyb3NzLWNhbGwuCgkgKi8KCWlmIChldmVudC0+c3RhdGUgPT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpIHsKCQlzcGluX3VubG9ja19pcnEoJmN0eC0+bG9jayk7CgkJZ290byByZXRyeTsKCX0KCgkvKgoJICogU2luY2Ugd2UgaGF2ZSB0aGUgbG9jayB0aGlzIGNvbnRleHQgY2FuJ3QgYmUgc2NoZWR1bGVkCgkgKiBpbiwgc28gd2UgY2FuIGNoYW5nZSB0aGUgc3RhdGUgc2FmZWx5LgoJICovCglpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpIHsKCQl1cGRhdGVfZ3JvdXBfdGltZXMoZXZlbnQpOwoJCWV2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGOwoJfQoKCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKfQoKc3RhdGljIGludApldmVudF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCgkJIHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsCgkJIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKCQkgaW50IGNwdSkKewoJaWYgKGV2ZW50LT5zdGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX09GRikKCQlyZXR1cm4gMDsKCglldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRTsKCWV2ZW50LT5vbmNwdSA9IGNwdTsJLyogVE9ETzogcHV0ICdjcHUnIGludG8gY3B1Y3R4LT5jcHUgKi8KCS8qCgkgKiBUaGUgbmV3IHN0YXRlIG11c3QgYmUgdmlzaWJsZSBiZWZvcmUgd2UgdHVybiBpdCBvbiBpbiB0aGUgaGFyZHdhcmU6CgkgKi8KCXNtcF93bWIoKTsKCglpZiAoZXZlbnQtPnBtdS0+ZW5hYmxlKGV2ZW50KSkgewoJCWV2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkU7CgkJZXZlbnQtPm9uY3B1ID0gLTE7CgkJcmV0dXJuIC1FQUdBSU47Cgl9CgoJZXZlbnQtPnRzdGFtcF9ydW5uaW5nICs9IGN0eC0+dGltZSAtIGV2ZW50LT50c3RhbXBfc3RvcHBlZDsKCglpZiAoIWlzX3NvZnR3YXJlX2V2ZW50KGV2ZW50KSkKCQljcHVjdHgtPmFjdGl2ZV9vbmNwdSsrOwoJY3R4LT5ucl9hY3RpdmUrKzsKCglpZiAoZXZlbnQtPmF0dHIuZXhjbHVzaXZlKQoJCWNwdWN0eC0+ZXhjbHVzaXZlID0gMTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludApncm91cF9zY2hlZF9pbihzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBfZXZlbnQsCgkgICAgICAgc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCwKCSAgICAgICBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCgkgICAgICAgaW50IGNwdSkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqcGFydGlhbF9ncm91cDsKCWludCByZXQ7CgoJaWYgKGdyb3VwX2V2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX09GRikKCQlyZXR1cm4gMDsKCglyZXQgPSBod19wZXJmX2dyb3VwX3NjaGVkX2luKGdyb3VwX2V2ZW50LCBjcHVjdHgsIGN0eCwgY3B1KTsKCWlmIChyZXQpCgkJcmV0dXJuIHJldCA8IDAgPyByZXQgOiAwOwoKCWlmIChldmVudF9zY2hlZF9pbihncm91cF9ldmVudCwgY3B1Y3R4LCBjdHgsIGNwdSkpCgkJcmV0dXJuIC1FQUdBSU47CgoJLyoKCSAqIFNjaGVkdWxlIGluIHNpYmxpbmdzIGFzIG9uZSBncm91cCAoaWYgYW55KToKCSAqLwoJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmdyb3VwX2V2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7CgkJaWYgKGV2ZW50X3NjaGVkX2luKGV2ZW50LCBjcHVjdHgsIGN0eCwgY3B1KSkgewoJCQlwYXJ0aWFsX2dyb3VwID0gZXZlbnQ7CgkJCWdvdG8gZ3JvdXBfZXJyb3I7CgkJfQoJfQoKCXJldHVybiAwOwoKZ3JvdXBfZXJyb3I6CgkvKgoJICogR3JvdXBzIGNhbiBiZSBzY2hlZHVsZWQgaW4gYXMgb25lIHVuaXQgb25seSwgc28gdW5kbyBhbnkKCSAqIHBhcnRpYWwgZ3JvdXAgYmVmb3JlIHJldHVybmluZzoKCSAqLwoJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmdyb3VwX2V2ZW50LT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7CgkJaWYgKGV2ZW50ID09IHBhcnRpYWxfZ3JvdXApCgkJCWJyZWFrOwoJCWV2ZW50X3NjaGVkX291dChldmVudCwgY3B1Y3R4LCBjdHgpOwoJfQoJZXZlbnRfc2NoZWRfb3V0KGdyb3VwX2V2ZW50LCBjcHVjdHgsIGN0eCk7CgoJcmV0dXJuIC1FQUdBSU47Cn0KCi8qCiAqIFJldHVybiAxIGZvciBhIGdyb3VwIGNvbnNpc3RpbmcgZW50aXJlbHkgb2Ygc29mdHdhcmUgZXZlbnRzLAogKiAwIGlmIHRoZSBncm91cCBjb250YWlucyBhbnkgaGFyZHdhcmUgZXZlbnRzLgogKi8Kc3RhdGljIGludCBpc19zb2Z0d2FyZV9vbmx5X2dyb3VwKHN0cnVjdCBwZXJmX2V2ZW50ICpsZWFkZXIpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCglpZiAoIWlzX3NvZnR3YXJlX2V2ZW50KGxlYWRlcikpCgkJcmV0dXJuIDA7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmxlYWRlci0+c2libGluZ19saXN0LCBncm91cF9lbnRyeSkKCQlpZiAoIWlzX3NvZnR3YXJlX2V2ZW50KGV2ZW50KSkKCQkJcmV0dXJuIDA7CgoJcmV0dXJuIDE7Cn0KCi8qCiAqIFdvcmsgb3V0IHdoZXRoZXIgd2UgY2FuIHB1dCB0aGlzIGV2ZW50IGdyb3VwIG9uIHRoZSBDUFUgbm93LgogKi8Kc3RhdGljIGludCBncm91cF9jYW5fZ29fb24oc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LAoJCQkgICBpbnQgY2FuX2FkZF9odykKewoJLyoKCSAqIEdyb3VwcyBjb25zaXN0aW5nIGVudGlyZWx5IG9mIHNvZnR3YXJlIGV2ZW50cyBjYW4gYWx3YXlzIGdvIG9uLgoJICovCglpZiAoaXNfc29mdHdhcmVfb25seV9ncm91cChldmVudCkpCgkJcmV0dXJuIDE7CgkvKgoJICogSWYgYW4gZXhjbHVzaXZlIGdyb3VwIGlzIGFscmVhZHkgb24sIG5vIG90aGVyIGhhcmR3YXJlCgkgKiBldmVudHMgY2FuIGdvIG9uLgoJICovCglpZiAoY3B1Y3R4LT5leGNsdXNpdmUpCgkJcmV0dXJuIDA7CgkvKgoJICogSWYgdGhpcyBncm91cCBpcyBleGNsdXNpdmUgYW5kIHRoZXJlIGFyZSBhbHJlYWR5CgkgKiBldmVudHMgb24gdGhlIENQVSwgaXQgY2FuJ3QgZ28gb24uCgkgKi8KCWlmIChldmVudC0+YXR0ci5leGNsdXNpdmUgJiYgY3B1Y3R4LT5hY3RpdmVfb25jcHUpCgkJcmV0dXJuIDA7CgkvKgoJICogT3RoZXJ3aXNlLCB0cnkgdG8gYWRkIGl0IGlmIGFsbCBwcmV2aW91cyBncm91cHMgd2VyZSBhYmxlCgkgKiB0byBnbyBvbi4KCSAqLwoJcmV0dXJuIGNhbl9hZGRfaHc7Cn0KCnN0YXRpYyB2b2lkIGFkZF9ldmVudF90b19jdHgoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkgICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQp7CglsaXN0X2FkZF9ldmVudChldmVudCwgY3R4KTsKCWV2ZW50LT50c3RhbXBfZW5hYmxlZCA9IGN0eC0+dGltZTsKCWV2ZW50LT50c3RhbXBfcnVubmluZyA9IGN0eC0+dGltZTsKCWV2ZW50LT50c3RhbXBfc3RvcHBlZCA9IGN0eC0+dGltZTsKfQoKLyoKICogQ3Jvc3MgQ1BVIGNhbGwgdG8gaW5zdGFsbCBhbmQgZW5hYmxlIGEgcGVyZm9ybWFuY2UgZXZlbnQKICoKICogTXVzdCBiZSBjYWxsZWQgd2l0aCBjdHgtPm11dGV4IGhlbGQKICovCnN0YXRpYyB2b2lkIF9fcGVyZl9pbnN0YWxsX2luX2NvbnRleHQodm9pZCAqaW5mbykKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gaW5mbzsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CglzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyID0gZXZlbnQtPmdyb3VwX2xlYWRlcjsKCWludCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7CglpbnQgZXJyOwoKCS8qCgkgKiBJZiB0aGlzIGlzIGEgdGFzayBjb250ZXh0LCB3ZSBuZWVkIHRvIGNoZWNrIHdoZXRoZXIgaXQgaXMKCSAqIHRoZSBjdXJyZW50IHRhc2sgY29udGV4dCBvZiB0aGlzIGNwdS4gSWYgbm90IGl0IGhhcyBiZWVuCgkgKiBzY2hlZHVsZWQgb3V0IGJlZm9yZSB0aGUgc21wIGNhbGwgYXJyaXZlZC4KCSAqIE9yIHBvc3NpYmx5IHRoaXMgaXMgdGhlIHJpZ2h0IGNvbnRleHQgYnV0IGl0IGlzbid0CgkgKiBvbiB0aGlzIGNwdSBiZWNhdXNlIGl0IGhhZCBubyBldmVudHMuCgkgKi8KCWlmIChjdHgtPnRhc2sgJiYgY3B1Y3R4LT50YXNrX2N0eCAhPSBjdHgpIHsKCQlpZiAoY3B1Y3R4LT50YXNrX2N0eCB8fCBjdHgtPnRhc2sgIT0gY3VycmVudCkKCQkJcmV0dXJuOwoJCWNwdWN0eC0+dGFza19jdHggPSBjdHg7Cgl9CgoJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOwoJY3R4LT5pc19hY3RpdmUgPSAxOwoJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOwoKCS8qCgkgKiBQcm90ZWN0IHRoZSBsaXN0IG9wZXJhdGlvbiBhZ2FpbnN0IE5NSSBieSBkaXNhYmxpbmcgdGhlCgkgKiBldmVudHMgb24gYSBnbG9iYWwgbGV2ZWwuIE5PUCBmb3Igbm9uIE5NSSBiYXNlZCBldmVudHMuCgkgKi8KCXBlcmZfZGlzYWJsZSgpOwoKCWFkZF9ldmVudF90b19jdHgoZXZlbnQsIGN0eCk7CgoJLyoKCSAqIERvbid0IHB1dCB0aGUgZXZlbnQgb24gaWYgaXQgaXMgZGlzYWJsZWQgb3IgaWYKCSAqIGl0IGlzIGluIGEgZ3JvdXAgYW5kIHRoZSBncm91cCBpc24ndCBvbi4KCSAqLwoJaWYgKGV2ZW50LT5zdGF0ZSAhPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFIHx8CgkgICAgKGxlYWRlciAhPSBldmVudCAmJiBsZWFkZXItPnN0YXRlICE9IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKSkKCQlnb3RvIHVubG9jazsKCgkvKgoJICogQW4gZXhjbHVzaXZlIGV2ZW50IGNhbid0IGdvIG9uIGlmIHRoZXJlIGFyZSBhbHJlYWR5IGFjdGl2ZQoJICogaGFyZHdhcmUgZXZlbnRzLCBhbmQgbm8gaGFyZHdhcmUgZXZlbnQgY2FuIGdvIG9uIGlmIHRoZXJlCgkgKiBpcyBhbHJlYWR5IGFuIGV4Y2x1c2l2ZSBldmVudCBvbi4KCSAqLwoJaWYgKCFncm91cF9jYW5fZ29fb24oZXZlbnQsIGNwdWN0eCwgMSkpCgkJZXJyID0gLUVFWElTVDsKCWVsc2UKCQllcnIgPSBldmVudF9zY2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgsIGNwdSk7CgoJaWYgKGVycikgewoJCS8qCgkJICogVGhpcyBldmVudCBjb3VsZG4ndCBnbyBvbi4gIElmIGl0IGlzIGluIGEgZ3JvdXAKCQkgKiB0aGVuIHdlIGhhdmUgdG8gcHVsbCB0aGUgd2hvbGUgZ3JvdXAgb2ZmLgoJCSAqIElmIHRoZSBldmVudCBncm91cCBpcyBwaW5uZWQgdGhlbiBwdXQgaXQgaW4gZXJyb3Igc3RhdGUuCgkJICovCgkJaWYgKGxlYWRlciAhPSBldmVudCkKCQkJZ3JvdXBfc2NoZWRfb3V0KGxlYWRlciwgY3B1Y3R4LCBjdHgpOwoJCWlmIChsZWFkZXItPmF0dHIucGlubmVkKSB7CgkJCXVwZGF0ZV9ncm91cF90aW1lcyhsZWFkZXIpOwoJCQlsZWFkZXItPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9FUlJPUjsKCQl9Cgl9CgoJaWYgKCFlcnIgJiYgIWN0eC0+dGFzayAmJiBjcHVjdHgtPm1heF9wZXJ0YXNrKQoJCWNwdWN0eC0+bWF4X3BlcnRhc2stLTsKCiB1bmxvY2s6CglwZXJmX2VuYWJsZSgpOwoKCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwp9CgovKgogKiBBdHRhY2ggYSBwZXJmb3JtYW5jZSBldmVudCB0byBhIGNvbnRleHQKICoKICogRmlyc3Qgd2UgYWRkIHRoZSBldmVudCB0byB0aGUgbGlzdCB3aXRoIHRoZSBoYXJkd2FyZSBlbmFibGUgYml0CiAqIGluIGV2ZW50LT5od19jb25maWcgY2xlYXJlZC4KICoKICogSWYgdGhlIGV2ZW50IGlzIGF0dGFjaGVkIHRvIGEgdGFzayB3aGljaCBpcyBvbiBhIENQVSB3ZSB1c2UgYSBzbXAKICogY2FsbCB0byBlbmFibGUgaXQgaW4gdGhlIHRhc2sgY29udGV4dC4gVGhlIHRhc2sgbWlnaHQgaGF2ZSBiZWVuCiAqIHNjaGVkdWxlZCBhd2F5LCBidXQgd2UgY2hlY2sgdGhpcyBpbiB0aGUgc21wIGNhbGwgYWdhaW4uCiAqCiAqIE11c3QgYmUgY2FsbGVkIHdpdGggY3R4LT5tdXRleCBoZWxkLgogKi8Kc3RhdGljIHZvaWQKcGVyZl9pbnN0YWxsX2luX2NvbnRleHQoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAoJCQlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCgkJCWludCBjcHUpCnsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKCglpZiAoIXRhc2spIHsKCQkvKgoJCSAqIFBlciBjcHUgZXZlbnRzIGFyZSBpbnN0YWxsZWQgdmlhIGFuIHNtcCBjYWxsIGFuZAoJCSAqIHRoZSBpbnN0YWxsIGlzIGFsd2F5cyBzdWNlc3NmdWwuCgkJICovCgkJc21wX2NhbGxfZnVuY3Rpb25fc2luZ2xlKGNwdSwgX19wZXJmX2luc3RhbGxfaW5fY29udGV4dCwKCQkJCQkgZXZlbnQsIDEpOwoJCXJldHVybjsKCX0KCnJldHJ5OgoJdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9pbnN0YWxsX2luX2NvbnRleHQsCgkJCQkgZXZlbnQpOwoKCXNwaW5fbG9ja19pcnEoJmN0eC0+bG9jayk7CgkvKgoJICogd2UgbmVlZCB0byByZXRyeSB0aGUgc21wIGNhbGwuCgkgKi8KCWlmIChjdHgtPmlzX2FjdGl2ZSAmJiBsaXN0X2VtcHR5KCZldmVudC0+Z3JvdXBfZW50cnkpKSB7CgkJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOwoJCWdvdG8gcmV0cnk7Cgl9CgoJLyoKCSAqIFRoZSBsb2NrIHByZXZlbnRzIHRoYXQgdGhpcyBjb250ZXh0IGlzIHNjaGVkdWxlZCBpbiBzbyB3ZQoJICogY2FuIGFkZCB0aGUgZXZlbnQgc2FmZWx5LCBpZiBpdCB0aGUgY2FsbCBhYm92ZSBkaWQgbm90CgkgKiBzdWNjZWVkLgoJICovCglpZiAobGlzdF9lbXB0eSgmZXZlbnQtPmdyb3VwX2VudHJ5KSkKCQlhZGRfZXZlbnRfdG9fY3R4KGV2ZW50LCBjdHgpOwoJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOwp9CgovKgogKiBQdXQgYSBldmVudCBpbnRvIGluYWN0aXZlIHN0YXRlIGFuZCB1cGRhdGUgdGltZSBmaWVsZHMuCiAqIEVuYWJsaW5nIHRoZSBsZWFkZXIgb2YgYSBncm91cCBlZmZlY3RpdmVseSBlbmFibGVzIGFsbAogKiB0aGUgZ3JvdXAgbWVtYmVycyB0aGF0IGFyZW4ndCBleHBsaWNpdGx5IGRpc2FibGVkLCBzbyB3ZQogKiBoYXZlIHRvIHVwZGF0ZSB0aGVpciAtPnRzdGFtcF9lbmFibGVkIGFsc28uCiAqIE5vdGU6IHRoaXMgd29ya3MgZm9yIGdyb3VwIG1lbWJlcnMgYXMgd2VsbCBhcyBncm91cCBsZWFkZXJzCiAqIHNpbmNlIHRoZSBub24tbGVhZGVyIG1lbWJlcnMnIHNpYmxpbmdfbGlzdHMgd2lsbCBiZSBlbXB0eS4KICovCnN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9tYXJrX2VuYWJsZWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkJCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKewoJc3RydWN0IHBlcmZfZXZlbnQgKnN1YjsKCglldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOwoJZXZlbnQtPnRzdGFtcF9lbmFibGVkID0gY3R4LT50aW1lIC0gZXZlbnQtPnRvdGFsX3RpbWVfZW5hYmxlZDsKCWxpc3RfZm9yX2VhY2hfZW50cnkoc3ViLCAmZXZlbnQtPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpCgkJaWYgKHN1Yi0+c3RhdGUgPj0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKCQkJc3ViLT50c3RhbXBfZW5hYmxlZCA9CgkJCQljdHgtPnRpbWUgLSBzdWItPnRvdGFsX3RpbWVfZW5hYmxlZDsKfQoKLyoKICogQ3Jvc3MgQ1BVIGNhbGwgdG8gZW5hYmxlIGEgcGVyZm9ybWFuY2UgZXZlbnQKICovCnN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9lbmFibGUodm9pZCAqaW5mbykKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gaW5mbzsKCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CglzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyID0gZXZlbnQtPmdyb3VwX2xlYWRlcjsKCWludCBlcnI7CgoJLyoKCSAqIElmIHRoaXMgaXMgYSBwZXItdGFzayBldmVudCwgbmVlZCB0byBjaGVjayB3aGV0aGVyIHRoaXMKCSAqIGV2ZW50J3MgdGFzayBpcyB0aGUgY3VycmVudCB0YXNrIG9uIHRoaXMgY3B1LgoJICovCglpZiAoY3R4LT50YXNrICYmIGNwdWN0eC0+dGFza19jdHggIT0gY3R4KSB7CgkJaWYgKGNwdWN0eC0+dGFza19jdHggfHwgY3R4LT50YXNrICE9IGN1cnJlbnQpCgkJCXJldHVybjsKCQljcHVjdHgtPnRhc2tfY3R4ID0gY3R4OwoJfQoKCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKCWN0eC0+aXNfYWN0aXZlID0gMTsKCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKCglpZiAoZXZlbnQtPnN0YXRlID49IFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkUpCgkJZ290byB1bmxvY2s7CglfX3BlcmZfZXZlbnRfbWFya19lbmFibGVkKGV2ZW50LCBjdHgpOwoKCS8qCgkgKiBJZiB0aGUgZXZlbnQgaXMgaW4gYSBncm91cCBhbmQgaXNuJ3QgdGhlIGdyb3VwIGxlYWRlciwKCSAqIHRoZW4gZG9uJ3QgcHV0IGl0IG9uIHVubGVzcyB0aGUgZ3JvdXAgaXMgb24uCgkgKi8KCWlmIChsZWFkZXIgIT0gZXZlbnQgJiYgbGVhZGVyLT5zdGF0ZSAhPSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRSkKCQlnb3RvIHVubG9jazsKCglpZiAoIWdyb3VwX2Nhbl9nb19vbihldmVudCwgY3B1Y3R4LCAxKSkgewoJCWVyciA9IC1FRVhJU1Q7Cgl9IGVsc2UgewoJCXBlcmZfZGlzYWJsZSgpOwoJCWlmIChldmVudCA9PSBsZWFkZXIpCgkJCWVyciA9IGdyb3VwX3NjaGVkX2luKGV2ZW50LCBjcHVjdHgsIGN0eCwKCQkJCQkgICAgIHNtcF9wcm9jZXNzb3JfaWQoKSk7CgkJZWxzZQoJCQllcnIgPSBldmVudF9zY2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgsCgkJCQkJICAgICAgIHNtcF9wcm9jZXNzb3JfaWQoKSk7CgkJcGVyZl9lbmFibGUoKTsKCX0KCglpZiAoZXJyKSB7CgkJLyoKCQkgKiBJZiB0aGlzIGV2ZW50IGNhbid0IGdvIG9uIGFuZCBpdCdzIHBhcnQgb2YgYQoJCSAqIGdyb3VwLCB0aGVuIHRoZSB3aG9sZSBncm91cCBoYXMgdG8gY29tZSBvZmYuCgkJICovCgkJaWYgKGxlYWRlciAhPSBldmVudCkKCQkJZ3JvdXBfc2NoZWRfb3V0KGxlYWRlciwgY3B1Y3R4LCBjdHgpOwoJCWlmIChsZWFkZXItPmF0dHIucGlubmVkKSB7CgkJCXVwZGF0ZV9ncm91cF90aW1lcyhsZWFkZXIpOwoJCQlsZWFkZXItPnN0YXRlID0gUEVSRl9FVkVOVF9TVEFURV9FUlJPUjsKCQl9Cgl9CgogdW5sb2NrOgoJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cn0KCi8qCiAqIEVuYWJsZSBhIGV2ZW50LgogKgogKiBJZiBldmVudC0+Y3R4IGlzIGEgY2xvbmVkIGNvbnRleHQsIGNhbGxlcnMgbXVzdCBtYWtlIHN1cmUgdGhhdAogKiBldmVyeSB0YXNrIHN0cnVjdCB0aGF0IGV2ZW50LT5jdHgtPnRhc2sgY291bGQgcG9zc2libHkgcG9pbnQgdG8KICogcmVtYWlucyB2YWxpZC4gIFRoaXMgY29uZGl0aW9uIGlzIHNhdGlzZmllZCB3aGVuIGNhbGxlZCB0aHJvdWdoCiAqIHBlcmZfZXZlbnRfZm9yX2VhY2hfY2hpbGQgb3IgcGVyZl9ldmVudF9mb3JfZWFjaCBhcyBkZXNjcmliZWQKICogZm9yIHBlcmZfZXZlbnRfZGlzYWJsZS4KICovCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfZW5hYmxlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gZXZlbnQtPmN0eDsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IGN0eC0+dGFzazsKCglpZiAoIXRhc2spIHsKCQkvKgoJCSAqIEVuYWJsZSB0aGUgZXZlbnQgb24gdGhlIGNwdSB0aGF0IGl0J3Mgb24KCQkgKi8KCQlzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoZXZlbnQtPmNwdSwgX19wZXJmX2V2ZW50X2VuYWJsZSwKCQkJCQkgZXZlbnQsIDEpOwoJCXJldHVybjsKCX0KCglzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOwoJaWYgKGV2ZW50LT5zdGF0ZSA+PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFKQoJCWdvdG8gb3V0OwoKCS8qCgkgKiBJZiB0aGUgZXZlbnQgaXMgaW4gZXJyb3Igc3RhdGUsIGNsZWFyIHRoYXQgZmlyc3QuCgkgKiBUaGF0IHdheSwgaWYgd2Ugc2VlIHRoZSBldmVudCBpbiBlcnJvciBzdGF0ZSBiZWxvdywgd2UKCSAqIGtub3cgdGhhdCBpdCBoYXMgZ29uZSBiYWNrIGludG8gZXJyb3Igc3RhdGUsIGFzIGRpc3RpbmN0CgkgKiBmcm9tIHRoZSB0YXNrIGhhdmluZyBiZWVuIHNjaGVkdWxlZCBhd2F5IGJlZm9yZSB0aGUKCSAqIGNyb3NzLWNhbGwgYXJyaXZlZC4KCSAqLwoJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SKQoJCWV2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGOwoKIHJldHJ5OgoJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOwoJdGFza19vbmNwdV9mdW5jdGlvbl9jYWxsKHRhc2ssIF9fcGVyZl9ldmVudF9lbmFibGUsIGV2ZW50KTsKCglzcGluX2xvY2tfaXJxKCZjdHgtPmxvY2spOwoKCS8qCgkgKiBJZiB0aGUgY29udGV4dCBpcyBhY3RpdmUgYW5kIHRoZSBldmVudCBpcyBzdGlsbCBvZmYsCgkgKiB3ZSBuZWVkIHRvIHJldHJ5IHRoZSBjcm9zcy1jYWxsLgoJICovCglpZiAoY3R4LT5pc19hY3RpdmUgJiYgZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfT0ZGKQoJCWdvdG8gcmV0cnk7CgoJLyoKCSAqIFNpbmNlIHdlIGhhdmUgdGhlIGxvY2sgdGhpcyBjb250ZXh0IGNhbid0IGJlIHNjaGVkdWxlZAoJICogaW4sIHNvIHdlIGNhbiBjaGFuZ2UgdGhlIHN0YXRlIHNhZmVseS4KCSAqLwoJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX09GRikKCQlfX3BlcmZfZXZlbnRfbWFya19lbmFibGVkKGV2ZW50LCBjdHgpOwoKIG91dDoKCXNwaW5fdW5sb2NrX2lycSgmY3R4LT5sb2NrKTsKfQoKc3RhdGljIGludCBwZXJmX2V2ZW50X3JlZnJlc2goc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgcmVmcmVzaCkKewoJLyoKCSAqIG5vdCBzdXBwb3J0ZWQgb24gaW5oZXJpdGVkIGV2ZW50cwoJICovCglpZiAoZXZlbnQtPmF0dHIuaW5oZXJpdCkKCQlyZXR1cm4gLUVJTlZBTDsKCglhdG9taWNfYWRkKHJlZnJlc2gsICZldmVudC0+ZXZlbnRfbGltaXQpOwoJcGVyZl9ldmVudF9lbmFibGUoZXZlbnQpOwoKCXJldHVybiAwOwp9Cgp2b2lkIF9fcGVyZl9ldmVudF9zY2hlZF9vdXQoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAoJCQkgICAgICBzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CgoJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOwoJY3R4LT5pc19hY3RpdmUgPSAwOwoJaWYgKGxpa2VseSghY3R4LT5ucl9ldmVudHMpKQoJCWdvdG8gb3V0OwoJdXBkYXRlX2NvbnRleHRfdGltZShjdHgpOwoKCXBlcmZfZGlzYWJsZSgpOwoJaWYgKGN0eC0+bnJfYWN0aXZlKQoJCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZjdHgtPmdyb3VwX2xpc3QsIGdyb3VwX2VudHJ5KQoJCQlncm91cF9zY2hlZF9vdXQoZXZlbnQsIGNwdWN0eCwgY3R4KTsKCglwZXJmX2VuYWJsZSgpOwogb3V0OgoJc3Bpbl91bmxvY2soJmN0eC0+bG9jayk7Cn0KCi8qCiAqIFRlc3Qgd2hldGhlciB0d28gY29udGV4dHMgYXJlIGVxdWl2YWxlbnQsIGkuZS4gd2hldGhlciB0aGV5CiAqIGhhdmUgYm90aCBiZWVuIGNsb25lZCBmcm9tIHRoZSBzYW1lIHZlcnNpb24gb2YgdGhlIHNhbWUgY29udGV4dAogKiBhbmQgdGhleSBib3RoIGhhdmUgdGhlIHNhbWUgbnVtYmVyIG9mIGVuYWJsZWQgZXZlbnRzLgogKiBJZiB0aGUgbnVtYmVyIG9mIGVuYWJsZWQgZXZlbnRzIGlzIHRoZSBzYW1lLCB0aGVuIHRoZSBzZXQKICogb2YgZW5hYmxlZCBldmVudHMgc2hvdWxkIGJlIHRoZSBzYW1lLCBiZWNhdXNlIHRoZXNlIGFyZSBib3RoCiAqIGluaGVyaXRlZCBjb250ZXh0cywgdGhlcmVmb3JlIHdlIGNhbid0IGFjY2VzcyBpbmRpdmlkdWFsIGV2ZW50cwogKiBpbiB0aGVtIGRpcmVjdGx5IHdpdGggYW4gZmQ7IHdlIGNhbiBvbmx5IGVuYWJsZS9kaXNhYmxlIGFsbAogKiBldmVudHMgdmlhIHByY3RsLCBvciBlbmFibGUvZGlzYWJsZSBhbGwgZXZlbnRzIGluIGEgZmFtaWx5CiAqIHZpYSBpb2N0bCwgd2hpY2ggd2lsbCBoYXZlIHRoZSBzYW1lIGVmZmVjdCBvbiBib3RoIGNvbnRleHRzLgogKi8Kc3RhdGljIGludCBjb250ZXh0X2VxdWl2KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDEsCgkJCSBzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgyKQp7CglyZXR1cm4gY3R4MS0+cGFyZW50X2N0eCAmJiBjdHgxLT5wYXJlbnRfY3R4ID09IGN0eDItPnBhcmVudF9jdHgKCQkmJiBjdHgxLT5wYXJlbnRfZ2VuID09IGN0eDItPnBhcmVudF9nZW4KCQkmJiAhY3R4MS0+cGluX2NvdW50ICYmICFjdHgyLT5waW5fY291bnQ7Cn0KCnN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9yZWFkKHZvaWQgKmV2ZW50KTsKCnN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9zeW5jX3N0YXQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkJICAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqbmV4dF9ldmVudCkKewoJdTY0IHZhbHVlOwoKCWlmICghZXZlbnQtPmF0dHIuaW5oZXJpdF9zdGF0KQoJCXJldHVybjsKCgkvKgoJICogVXBkYXRlIHRoZSBldmVudCB2YWx1ZSwgd2UgY2Fubm90IHVzZSBwZXJmX2V2ZW50X3JlYWQoKQoJICogYmVjYXVzZSB3ZSdyZSBpbiB0aGUgbWlkZGxlIG9mIGEgY29udGV4dCBzd2l0Y2ggYW5kIGhhdmUgSVJRcwoJICogZGlzYWJsZWQsIHdoaWNoIHVwc2V0cyBzbXBfY2FsbF9mdW5jdGlvbl9zaW5nbGUoKSwgaG93ZXZlcgoJICogd2Uga25vdyB0aGUgZXZlbnQgbXVzdCBiZSBvbiB0aGUgY3VycmVudCBDUFUsIHRoZXJlZm9yZSB3ZQoJICogZG9uJ3QgbmVlZCB0byB1c2UgaXQuCgkgKi8KCXN3aXRjaCAoZXZlbnQtPnN0YXRlKSB7CgljYXNlIFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFOgoJCV9fcGVyZl9ldmVudF9yZWFkKGV2ZW50KTsKCQlicmVhazsKCgljYXNlIFBFUkZfRVZFTlRfU1RBVEVfSU5BQ1RJVkU6CgkJdXBkYXRlX2V2ZW50X3RpbWVzKGV2ZW50KTsKCQlicmVhazsKCglkZWZhdWx0OgoJCWJyZWFrOwoJfQoKCS8qCgkgKiBJbiBvcmRlciB0byBrZWVwIHBlci10YXNrIHN0YXRzIHJlbGlhYmxlIHdlIG5lZWQgdG8gZmxpcCB0aGUgZXZlbnQKCSAqIHZhbHVlcyB3aGVuIHdlIGZsaXAgdGhlIGNvbnRleHRzLgoJICovCgl2YWx1ZSA9IGF0b21pYzY0X3JlYWQoJm5leHRfZXZlbnQtPmNvdW50KTsKCXZhbHVlID0gYXRvbWljNjRfeGNoZygmZXZlbnQtPmNvdW50LCB2YWx1ZSk7CglhdG9taWM2NF9zZXQoJm5leHRfZXZlbnQtPmNvdW50LCB2YWx1ZSk7CgoJc3dhcChldmVudC0+dG90YWxfdGltZV9lbmFibGVkLCBuZXh0X2V2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQpOwoJc3dhcChldmVudC0+dG90YWxfdGltZV9ydW5uaW5nLCBuZXh0X2V2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcpOwoKCS8qCgkgKiBTaW5jZSB3ZSBzd2l6emxlZCB0aGUgdmFsdWVzLCB1cGRhdGUgdGhlIHVzZXIgdmlzaWJsZSBkYXRhIHRvby4KCSAqLwoJcGVyZl9ldmVudF91cGRhdGVfdXNlcnBhZ2UoZXZlbnQpOwoJcGVyZl9ldmVudF91cGRhdGVfdXNlcnBhZ2UobmV4dF9ldmVudCk7Cn0KCiNkZWZpbmUgbGlzdF9uZXh0X2VudHJ5KHBvcywgbWVtYmVyKSBcCglsaXN0X2VudHJ5KHBvcy0+bWVtYmVyLm5leHQsIHR5cGVvZigqcG9zKSwgbWVtYmVyKQoKc3RhdGljIHZvaWQgcGVyZl9ldmVudF9zeW5jX3N0YXQoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAoJCQkJICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqbmV4dF9jdHgpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgKm5leHRfZXZlbnQ7CgoJaWYgKCFjdHgtPm5yX3N0YXQpCgkJcmV0dXJuOwoKCWV2ZW50ID0gbGlzdF9maXJzdF9lbnRyeSgmY3R4LT5ldmVudF9saXN0LAoJCQkJICAgc3RydWN0IHBlcmZfZXZlbnQsIGV2ZW50X2VudHJ5KTsKCgluZXh0X2V2ZW50ID0gbGlzdF9maXJzdF9lbnRyeSgmbmV4dF9jdHgtPmV2ZW50X2xpc3QsCgkJCQkJc3RydWN0IHBlcmZfZXZlbnQsIGV2ZW50X2VudHJ5KTsKCgl3aGlsZSAoJmV2ZW50LT5ldmVudF9lbnRyeSAhPSAmY3R4LT5ldmVudF9saXN0ICYmCgkgICAgICAgJm5leHRfZXZlbnQtPmV2ZW50X2VudHJ5ICE9ICZuZXh0X2N0eC0+ZXZlbnRfbGlzdCkgewoKCQlfX3BlcmZfZXZlbnRfc3luY19zdGF0KGV2ZW50LCBuZXh0X2V2ZW50KTsKCgkJZXZlbnQgPSBsaXN0X25leHRfZW50cnkoZXZlbnQsIGV2ZW50X2VudHJ5KTsKCQluZXh0X2V2ZW50ID0gbGlzdF9uZXh0X2VudHJ5KG5leHRfZXZlbnQsIGV2ZW50X2VudHJ5KTsKCX0KfQoKLyoKICogQ2FsbGVkIGZyb20gc2NoZWR1bGVyIHRvIHJlbW92ZSB0aGUgZXZlbnRzIG9mIHRoZSBjdXJyZW50IHRhc2ssCiAqIHdpdGggaW50ZXJydXB0cyBkaXNhYmxlZC4KICoKICogV2Ugc3RvcCBlYWNoIGV2ZW50IGFuZCB1cGRhdGUgdGhlIGV2ZW50IHZhbHVlIGluIGV2ZW50LT5jb3VudC4KICoKICogVGhpcyBkb2VzIG5vdCBwcm90ZWN0IHVzIGFnYWluc3QgTk1JLCBidXQgZGlzYWJsZSgpCiAqIHNldHMgdGhlIGRpc2FibGVkIGJpdCBpbiB0aGUgY29udHJvbCBmaWVsZCBvZiBldmVudCBfYmVmb3JlXwogKiBhY2Nlc3NpbmcgdGhlIGV2ZW50IGNvbnRyb2wgcmVnaXN0ZXIuIElmIGEgTk1JIGhpdHMsIHRoZW4gaXQgd2lsbAogKiBub3QgcmVzdGFydCB0aGUgZXZlbnQuCiAqLwp2b2lkIHBlcmZfZXZlbnRfdGFza19zY2hlZF9vdXQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrLAoJCQkJIHN0cnVjdCB0YXNrX3N0cnVjdCAqbmV4dCwgaW50IGNwdSkKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZwZXJfY3B1KHBlcmZfY3B1X2NvbnRleHQsIGNwdSk7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSB0YXNrLT5wZXJmX2V2ZW50X2N0eHA7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpuZXh0X2N0eDsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnBhcmVudDsKCXN0cnVjdCBwdF9yZWdzICpyZWdzOwoJaW50IGRvX3N3aXRjaCA9IDE7CgoJcmVncyA9IHRhc2tfcHRfcmVncyh0YXNrKTsKCXBlcmZfc3dfZXZlbnQoUEVSRl9DT1VOVF9TV19DT05URVhUX1NXSVRDSEVTLCAxLCAxLCByZWdzLCAwKTsKCglpZiAobGlrZWx5KCFjdHggfHwgIWNwdWN0eC0+dGFza19jdHgpKQoJCXJldHVybjsKCgl1cGRhdGVfY29udGV4dF90aW1lKGN0eCk7CgoJcmN1X3JlYWRfbG9jaygpOwoJcGFyZW50ID0gcmN1X2RlcmVmZXJlbmNlKGN0eC0+cGFyZW50X2N0eCk7CgluZXh0X2N0eCA9IG5leHQtPnBlcmZfZXZlbnRfY3R4cDsKCWlmIChwYXJlbnQgJiYgbmV4dF9jdHggJiYKCSAgICByY3VfZGVyZWZlcmVuY2UobmV4dF9jdHgtPnBhcmVudF9jdHgpID09IHBhcmVudCkgewoJCS8qCgkJICogTG9va3MgbGlrZSB0aGUgdHdvIGNvbnRleHRzIGFyZSBjbG9uZXMsIHNvIHdlIG1pZ2h0IGJlCgkJICogYWJsZSB0byBvcHRpbWl6ZSB0aGUgY29udGV4dCBzd2l0Y2guICBXZSBsb2NrIGJvdGgKCQkgKiBjb250ZXh0cyBhbmQgY2hlY2sgdGhhdCB0aGV5IGFyZSBjbG9uZXMgdW5kZXIgdGhlCgkJICogbG9jayAoaW5jbHVkaW5nIHJlLWNoZWNraW5nIHRoYXQgbmVpdGhlciBoYXMgYmVlbgoJCSAqIHVuY2xvbmVkIGluIHRoZSBtZWFudGltZSkuICBJdCBkb2Vzbid0IG1hdHRlciB3aGljaAoJCSAqIG9yZGVyIHdlIHRha2UgdGhlIGxvY2tzIGJlY2F1c2Ugbm8gb3RoZXIgY3B1IGNvdWxkCgkJICogYmUgdHJ5aW5nIHRvIGxvY2sgYm90aCBvZiB0aGVzZSB0YXNrcy4KCQkgKi8KCQlzcGluX2xvY2soJmN0eC0+bG9jayk7CgkJc3Bpbl9sb2NrX25lc3RlZCgmbmV4dF9jdHgtPmxvY2ssIFNJTkdMRV9ERVBUSF9ORVNUSU5HKTsKCQlpZiAoY29udGV4dF9lcXVpdihjdHgsIG5leHRfY3R4KSkgewoJCQkvKgoJCQkgKiBYWFggZG8gd2UgbmVlZCBhIG1lbW9yeSBiYXJyaWVyIG9mIHNvcnRzCgkJCSAqIHdydCB0byByY3VfZGVyZWZlcmVuY2UoKSBvZiBwZXJmX2V2ZW50X2N0eHAKCQkJICovCgkJCXRhc2stPnBlcmZfZXZlbnRfY3R4cCA9IG5leHRfY3R4OwoJCQluZXh0LT5wZXJmX2V2ZW50X2N0eHAgPSBjdHg7CgkJCWN0eC0+dGFzayA9IG5leHQ7CgkJCW5leHRfY3R4LT50YXNrID0gdGFzazsKCQkJZG9fc3dpdGNoID0gMDsKCgkJCXBlcmZfZXZlbnRfc3luY19zdGF0KGN0eCwgbmV4dF9jdHgpOwoJCX0KCQlzcGluX3VubG9jaygmbmV4dF9jdHgtPmxvY2spOwoJCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwoJfQoJcmN1X3JlYWRfdW5sb2NrKCk7CgoJaWYgKGRvX3N3aXRjaCkgewoJCV9fcGVyZl9ldmVudF9zY2hlZF9vdXQoY3R4LCBjcHVjdHgpOwoJCWNwdWN0eC0+dGFza19jdHggPSBOVUxMOwoJfQp9CgovKgogKiBDYWxsZWQgd2l0aCBJUlFzIGRpc2FibGVkCiAqLwpzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfdGFza19zY2hlZF9vdXQoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4KQp7CglzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJl9fZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CgoJaWYgKCFjcHVjdHgtPnRhc2tfY3R4KQoJCXJldHVybjsKCglpZiAoV0FSTl9PTl9PTkNFKGN0eCAhPSBjcHVjdHgtPnRhc2tfY3R4KSkKCQlyZXR1cm47CgoJX19wZXJmX2V2ZW50X3NjaGVkX291dChjdHgsIGNwdWN0eCk7CgljcHVjdHgtPnRhc2tfY3R4ID0gTlVMTDsKfQoKLyoKICogQ2FsbGVkIHdpdGggSVJRcyBkaXNhYmxlZAogKi8Kc3RhdGljIHZvaWQgcGVyZl9ldmVudF9jcHVfc2NoZWRfb3V0KHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgpCnsKCV9fcGVyZl9ldmVudF9zY2hlZF9vdXQoJmNwdWN0eC0+Y3R4LCBjcHVjdHgpOwp9CgpzdGF0aWMgdm9pZApfX3BlcmZfZXZlbnRfc2NoZWRfaW4oc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAoJCQlzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4LCBpbnQgY3B1KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CglpbnQgY2FuX2FkZF9odyA9IDE7CgoJc3Bpbl9sb2NrKCZjdHgtPmxvY2spOwoJY3R4LT5pc19hY3RpdmUgPSAxOwoJaWYgKGxpa2VseSghY3R4LT5ucl9ldmVudHMpKQoJCWdvdG8gb3V0OwoKCWN0eC0+dGltZXN0YW1wID0gcGVyZl9jbG9jaygpOwoKCXBlcmZfZGlzYWJsZSgpOwoKCS8qCgkgKiBGaXJzdCBnbyB0aHJvdWdoIHRoZSBsaXN0IGFuZCBwdXQgb24gYW55IHBpbm5lZCBncm91cHMKCSAqIGluIG9yZGVyIHRvIGdpdmUgdGhlbSB0aGUgYmVzdCBjaGFuY2Ugb2YgZ29pbmcgb24uCgkgKi8KCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZjdHgtPmdyb3VwX2xpc3QsIGdyb3VwX2VudHJ5KSB7CgkJaWYgKGV2ZW50LT5zdGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX09GRiB8fAoJCSAgICAhZXZlbnQtPmF0dHIucGlubmVkKQoJCQljb250aW51ZTsKCQlpZiAoZXZlbnQtPmNwdSAhPSAtMSAmJiBldmVudC0+Y3B1ICE9IGNwdSkKCQkJY29udGludWU7CgoJCWlmIChncm91cF9jYW5fZ29fb24oZXZlbnQsIGNwdWN0eCwgMSkpCgkJCWdyb3VwX3NjaGVkX2luKGV2ZW50LCBjcHVjdHgsIGN0eCwgY3B1KTsKCgkJLyoKCQkgKiBJZiB0aGlzIHBpbm5lZCBncm91cCBoYXNuJ3QgYmVlbiBzY2hlZHVsZWQsCgkJICogcHV0IGl0IGluIGVycm9yIHN0YXRlLgoJCSAqLwoJCWlmIChldmVudC0+c3RhdGUgPT0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkgewoJCQl1cGRhdGVfZ3JvdXBfdGltZXMoZXZlbnQpOwoJCQlldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SOwoJCX0KCX0KCglsaXN0X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkgewoJCS8qCgkJICogSWdub3JlIGV2ZW50cyBpbiBPRkYgb3IgRVJST1Igc3RhdGUsIGFuZAoJCSAqIGlnbm9yZSBwaW5uZWQgZXZlbnRzIHNpbmNlIHdlIGRpZCB0aGVtIGFscmVhZHkuCgkJICovCgkJaWYgKGV2ZW50LT5zdGF0ZSA8PSBQRVJGX0VWRU5UX1NUQVRFX09GRiB8fAoJCSAgICBldmVudC0+YXR0ci5waW5uZWQpCgkJCWNvbnRpbnVlOwoKCQkvKgoJCSAqIExpc3RlbiB0byB0aGUgJ2NwdScgc2NoZWR1bGluZyBmaWx0ZXIgY29uc3RyYWludAoJCSAqIG9mIGV2ZW50czoKCQkgKi8KCQlpZiAoZXZlbnQtPmNwdSAhPSAtMSAmJiBldmVudC0+Y3B1ICE9IGNwdSkKCQkJY29udGludWU7CgoJCWlmIChncm91cF9jYW5fZ29fb24oZXZlbnQsIGNwdWN0eCwgY2FuX2FkZF9odykpCgkJCWlmIChncm91cF9zY2hlZF9pbihldmVudCwgY3B1Y3R4LCBjdHgsIGNwdSkpCgkJCQljYW5fYWRkX2h3ID0gMDsKCX0KCXBlcmZfZW5hYmxlKCk7CiBvdXQ6CglzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKfQoKLyoKICogQ2FsbGVkIGZyb20gc2NoZWR1bGVyIHRvIGFkZCB0aGUgZXZlbnRzIG9mIHRoZSBjdXJyZW50IHRhc2sKICogd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkLgogKgogKiBXZSByZXN0b3JlIHRoZSBldmVudCB2YWx1ZSBhbmQgdGhlbiBlbmFibGUgaXQuCiAqCiAqIFRoaXMgZG9lcyBub3QgcHJvdGVjdCB1cyBhZ2FpbnN0IE5NSSwgYnV0IGVuYWJsZSgpCiAqIHNldHMgdGhlIGVuYWJsZWQgYml0IGluIHRoZSBjb250cm9sIGZpZWxkIG9mIGV2ZW50IF9iZWZvcmVfCiAqIGFjY2Vzc2luZyB0aGUgZXZlbnQgY29udHJvbCByZWdpc3Rlci4gSWYgYSBOTUkgaGl0cywgdGhlbiBpdCB3aWxsCiAqIGtlZXAgdGhlIGV2ZW50IHJ1bm5pbmcuCiAqLwp2b2lkIHBlcmZfZXZlbnRfdGFza19zY2hlZF9pbihzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssIGludCBjcHUpCnsKCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gdGFzay0+cGVyZl9ldmVudF9jdHhwOwoKCWlmIChsaWtlbHkoIWN0eCkpCgkJcmV0dXJuOwoJaWYgKGNwdWN0eC0+dGFza19jdHggPT0gY3R4KQoJCXJldHVybjsKCV9fcGVyZl9ldmVudF9zY2hlZF9pbihjdHgsIGNwdWN0eCwgY3B1KTsKCWNwdWN0eC0+dGFza19jdHggPSBjdHg7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfY3B1X3NjaGVkX2luKHN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHgsIGludCBjcHUpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9ICZjcHVjdHgtPmN0eDsKCglfX3BlcmZfZXZlbnRfc2NoZWRfaW4oY3R4LCBjcHVjdHgsIGNwdSk7Cn0KCiNkZWZpbmUgTUFYX0lOVEVSUlVQVFMgKH4wVUxMKQoKc3RhdGljIHZvaWQgcGVyZl9sb2dfdGhyb3R0bGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgZW5hYmxlKTsKCnN0YXRpYyB2b2lkIHBlcmZfYWRqdXN0X3BlcmlvZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHU2NCBldmVudHMpCnsKCXN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3OwoJdTY0IHBlcmlvZCwgc2FtcGxlX3BlcmlvZDsKCXM2NCBkZWx0YTsKCglldmVudHMgKj0gaHdjLT5zYW1wbGVfcGVyaW9kOwoJcGVyaW9kID0gZGl2NjRfdTY0KGV2ZW50cywgZXZlbnQtPmF0dHIuc2FtcGxlX2ZyZXEpOwoKCWRlbHRhID0gKHM2NCkocGVyaW9kIC0gaHdjLT5zYW1wbGVfcGVyaW9kKTsKCWRlbHRhID0gKGRlbHRhICsgNykgLyA4OyAvKiBsb3cgcGFzcyBmaWx0ZXIgKi8KCglzYW1wbGVfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kICsgZGVsdGE7CgoJaWYgKCFzYW1wbGVfcGVyaW9kKQoJCXNhbXBsZV9wZXJpb2QgPSAxOwoKCWh3Yy0+c2FtcGxlX3BlcmlvZCA9IHNhbXBsZV9wZXJpb2Q7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfY3R4X2FkanVzdF9mcmVxKHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OwoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YzsKCXU2NCBpbnRlcnJ1cHRzLCBmcmVxOwoKCXNwaW5fbG9jaygmY3R4LT5sb2NrKTsKCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGV2ZW50LCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkgewoJCWlmIChldmVudC0+c3RhdGUgIT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpCgkJCWNvbnRpbnVlOwoKCQlod2MgPSAmZXZlbnQtPmh3OwoKCQlpbnRlcnJ1cHRzID0gaHdjLT5pbnRlcnJ1cHRzOwoJCWh3Yy0+aW50ZXJydXB0cyA9IDA7CgoJCS8qCgkJICogdW50aHJvdHRsZSBldmVudHMgb24gdGhlIHRpY2sKCQkgKi8KCQlpZiAoaW50ZXJydXB0cyA9PSBNQVhfSU5URVJSVVBUUykgewoJCQlwZXJmX2xvZ190aHJvdHRsZShldmVudCwgMSk7CgkJCWV2ZW50LT5wbXUtPnVudGhyb3R0bGUoZXZlbnQpOwoJCQlpbnRlcnJ1cHRzID0gMipzeXNjdGxfcGVyZl9ldmVudF9zYW1wbGVfcmF0ZS9IWjsKCQl9CgoJCWlmICghZXZlbnQtPmF0dHIuZnJlcSB8fCAhZXZlbnQtPmF0dHIuc2FtcGxlX2ZyZXEpCgkJCWNvbnRpbnVlOwoKCQkvKgoJCSAqIGlmIHRoZSBzcGVjaWZpZWQgZnJlcSA8IEhaIHRoZW4gd2UgbmVlZCB0byBza2lwIHRpY2tzCgkJICovCgkJaWYgKGV2ZW50LT5hdHRyLnNhbXBsZV9mcmVxIDwgSFopIHsKCQkJZnJlcSA9IGV2ZW50LT5hdHRyLnNhbXBsZV9mcmVxOwoKCQkJaHdjLT5mcmVxX2NvdW50ICs9IGZyZXE7CgkJCWh3Yy0+ZnJlcV9pbnRlcnJ1cHRzICs9IGludGVycnVwdHM7CgoJCQlpZiAoaHdjLT5mcmVxX2NvdW50IDwgSFopCgkJCQljb250aW51ZTsKCgkJCWludGVycnVwdHMgPSBod2MtPmZyZXFfaW50ZXJydXB0czsKCQkJaHdjLT5mcmVxX2ludGVycnVwdHMgPSAwOwoJCQlod2MtPmZyZXFfY291bnQgLT0gSFo7CgkJfSBlbHNlCgkJCWZyZXEgPSBIWjsKCgkJcGVyZl9hZGp1c3RfcGVyaW9kKGV2ZW50LCBmcmVxICogaW50ZXJydXB0cyk7CgoJCS8qCgkJICogSW4gb3JkZXIgdG8gYXZvaWQgYmVpbmcgc3RhbGxlZCBieSBhbiAoYWNjaWRlbnRhbCkgaHVnZQoJCSAqIHNhbXBsZSBwZXJpb2QsIGZvcmNlIHJlc2V0IHRoZSBzYW1wbGUgcGVyaW9kIGlmIHdlIGRpZG4ndAoJCSAqIGdldCBhbnkgZXZlbnRzIGluIHRoaXMgZnJlcSBwZXJpb2QuCgkJICovCgkJaWYgKCFpbnRlcnJ1cHRzKSB7CgkJCXBlcmZfZGlzYWJsZSgpOwoJCQlldmVudC0+cG11LT5kaXNhYmxlKGV2ZW50KTsKCQkJYXRvbWljNjRfc2V0KCZod2MtPnBlcmlvZF9sZWZ0LCAwKTsKCQkJZXZlbnQtPnBtdS0+ZW5hYmxlKGV2ZW50KTsKCQkJcGVyZl9lbmFibGUoKTsKCQl9Cgl9CglzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKfQoKLyoKICogUm91bmQtcm9iaW4gYSBjb250ZXh0J3MgZXZlbnRzOgogKi8Kc3RhdGljIHZvaWQgcm90YXRlX2N0eChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCglpZiAoIWN0eC0+bnJfZXZlbnRzKQoJCXJldHVybjsKCglzcGluX2xvY2soJmN0eC0+bG9jayk7CgkvKgoJICogUm90YXRlIHRoZSBmaXJzdCBlbnRyeSBsYXN0ICh3b3JrcyBqdXN0IGZpbmUgZm9yIGdyb3VwIGV2ZW50cyB0b28pOgoJICovCglwZXJmX2Rpc2FibGUoKTsKCWxpc3RfZm9yX2VhY2hfZW50cnkoZXZlbnQsICZjdHgtPmdyb3VwX2xpc3QsIGdyb3VwX2VudHJ5KSB7CgkJbGlzdF9tb3ZlX3RhaWwoJmV2ZW50LT5ncm91cF9lbnRyeSwgJmN0eC0+Z3JvdXBfbGlzdCk7CgkJYnJlYWs7Cgl9CglwZXJmX2VuYWJsZSgpOwoKCXNwaW5fdW5sb2NrKCZjdHgtPmxvY2spOwp9Cgp2b2lkIHBlcmZfZXZlbnRfdGFza190aWNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY3VyciwgaW50IGNwdSkKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCglpZiAoIWF0b21pY19yZWFkKCZucl9ldmVudHMpKQoJCXJldHVybjsKCgljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwoJY3R4ID0gY3Vyci0+cGVyZl9ldmVudF9jdHhwOwoKCXBlcmZfY3R4X2FkanVzdF9mcmVxKCZjcHVjdHgtPmN0eCk7CglpZiAoY3R4KQoJCXBlcmZfY3R4X2FkanVzdF9mcmVxKGN0eCk7CgoJcGVyZl9ldmVudF9jcHVfc2NoZWRfb3V0KGNwdWN0eCk7CglpZiAoY3R4KQoJCV9fcGVyZl9ldmVudF90YXNrX3NjaGVkX291dChjdHgpOwoKCXJvdGF0ZV9jdHgoJmNwdWN0eC0+Y3R4KTsKCWlmIChjdHgpCgkJcm90YXRlX2N0eChjdHgpOwoKCXBlcmZfZXZlbnRfY3B1X3NjaGVkX2luKGNwdWN0eCwgY3B1KTsKCWlmIChjdHgpCgkJcGVyZl9ldmVudF90YXNrX3NjaGVkX2luKGN1cnIsIGNwdSk7Cn0KCi8qCiAqIEVuYWJsZSBhbGwgb2YgYSB0YXNrJ3MgZXZlbnRzIHRoYXQgaGF2ZSBiZWVuIG1hcmtlZCBlbmFibGUtb24tZXhlYy4KICogVGhpcyBleHBlY3RzIHRhc2sgPT0gY3VycmVudC4KICovCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfZW5hYmxlX29uX2V4ZWMoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQp7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJaW50IGVuYWJsZWQgPSAwOwoKCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKCWN0eCA9IHRhc2stPnBlcmZfZXZlbnRfY3R4cDsKCWlmICghY3R4IHx8ICFjdHgtPm5yX2V2ZW50cykKCQlnb3RvIG91dDsKCglfX3BlcmZfZXZlbnRfdGFza19zY2hlZF9vdXQoY3R4KTsKCglzcGluX2xvY2soJmN0eC0+bG9jayk7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKCQlpZiAoIWV2ZW50LT5hdHRyLmVuYWJsZV9vbl9leGVjKQoJCQljb250aW51ZTsKCQlldmVudC0+YXR0ci5lbmFibGVfb25fZXhlYyA9IDA7CgkJaWYgKGV2ZW50LT5zdGF0ZSA+PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFKQoJCQljb250aW51ZTsKCQlfX3BlcmZfZXZlbnRfbWFya19lbmFibGVkKGV2ZW50LCBjdHgpOwoJCWVuYWJsZWQgPSAxOwoJfQoKCS8qCgkgKiBVbmNsb25lIHRoaXMgY29udGV4dCBpZiB3ZSBlbmFibGVkIGFueSBldmVudC4KCSAqLwoJaWYgKGVuYWJsZWQpCgkJdW5jbG9uZV9jdHgoY3R4KTsKCglzcGluX3VubG9jaygmY3R4LT5sb2NrKTsKCglwZXJmX2V2ZW50X3Rhc2tfc2NoZWRfaW4odGFzaywgc21wX3Byb2Nlc3Nvcl9pZCgpKTsKIG91dDoKCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKfQoKLyoKICogQ3Jvc3MgQ1BVIGNhbGwgdG8gcmVhZCB0aGUgaGFyZHdhcmUgZXZlbnQKICovCnN0YXRpYyB2b2lkIF9fcGVyZl9ldmVudF9yZWFkKHZvaWQgKmluZm8pCnsKCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHggPSAmX19nZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGluZm87CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCgkvKgoJICogSWYgdGhpcyBpcyBhIHRhc2sgY29udGV4dCwgd2UgbmVlZCB0byBjaGVjayB3aGV0aGVyIGl0IGlzCgkgKiB0aGUgY3VycmVudCB0YXNrIGNvbnRleHQgb2YgdGhpcyBjcHUuICBJZiBub3QgaXQgaGFzIGJlZW4KCSAqIHNjaGVkdWxlZCBvdXQgYmVmb3JlIHRoZSBzbXAgY2FsbCBhcnJpdmVkLiAgSW4gdGhhdCBjYXNlCgkgKiBldmVudC0+Y291bnQgd291bGQgaGF2ZSBiZWVuIHVwZGF0ZWQgdG8gYSByZWNlbnQgc2FtcGxlCgkgKiB3aGVuIHRoZSBldmVudCB3YXMgc2NoZWR1bGVkIG91dC4KCSAqLwoJaWYgKGN0eC0+dGFzayAmJiBjcHVjdHgtPnRhc2tfY3R4ICE9IGN0eCkKCQlyZXR1cm47CgoJbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwoJaWYgKGN0eC0+aXNfYWN0aXZlKQoJCXVwZGF0ZV9jb250ZXh0X3RpbWUoY3R4KTsKCWV2ZW50LT5wbXUtPnJlYWQoZXZlbnQpOwoJdXBkYXRlX2V2ZW50X3RpbWVzKGV2ZW50KTsKCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKfQoKc3RhdGljIHU2NCBwZXJmX2V2ZW50X3JlYWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CgkvKgoJICogSWYgZXZlbnQgaXMgZW5hYmxlZCBhbmQgY3VycmVudGx5IGFjdGl2ZSBvbiBhIENQVSwgdXBkYXRlIHRoZQoJICogdmFsdWUgaW4gdGhlIGV2ZW50IHN0cnVjdHVyZToKCSAqLwoJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0FDVElWRSkgewoJCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShldmVudC0+b25jcHUsCgkJCQkJIF9fcGVyZl9ldmVudF9yZWFkLCBldmVudCwgMSk7Cgl9IGVsc2UgaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFKSB7CgkJdXBkYXRlX2V2ZW50X3RpbWVzKGV2ZW50KTsKCX0KCglyZXR1cm4gYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNvdW50KTsKfQoKLyoKICogSW5pdGlhbGl6ZSB0aGUgcGVyZl9ldmVudCBjb250ZXh0IGluIGEgdGFza19zdHJ1Y3Q6CiAqLwpzdGF0aWMgdm9pZApfX3BlcmZfZXZlbnRfaW5pdF9jb250ZXh0KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKCQkJICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKewoJbWVtc2V0KGN0eCwgMCwgc2l6ZW9mKCpjdHgpKTsKCXNwaW5fbG9ja19pbml0KCZjdHgtPmxvY2spOwoJbXV0ZXhfaW5pdCgmY3R4LT5tdXRleCk7CglJTklUX0xJU1RfSEVBRCgmY3R4LT5ncm91cF9saXN0KTsKCUlOSVRfTElTVF9IRUFEKCZjdHgtPmV2ZW50X2xpc3QpOwoJYXRvbWljX3NldCgmY3R4LT5yZWZjb3VudCwgMSk7CgljdHgtPnRhc2sgPSB0YXNrOwp9CgpzdGF0aWMgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqZmluZF9nZXRfY29udGV4dChwaWRfdCBwaWQsIGludCBjcHUpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CglzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2s7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJaW50IGVycjsKCgkvKgoJICogSWYgY3B1IGlzIG5vdCBhIHdpbGRjYXJkIHRoZW4gdGhpcyBpcyBhIHBlcmNwdSBldmVudDoKCSAqLwoJaWYgKGNwdSAhPSAtMSkgewoJCS8qIE11c3QgYmUgcm9vdCB0byBvcGVyYXRlIG9uIGEgQ1BVIGV2ZW50OiAqLwoJCWlmIChwZXJmX3BhcmFub2lkX2NwdSgpICYmICFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQoJCQlyZXR1cm4gRVJSX1BUUigtRUFDQ0VTKTsKCgkJaWYgKGNwdSA8IDAgfHwgY3B1ID4gbnVtX3Bvc3NpYmxlX2NwdXMoKSkKCQkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CgoJCS8qCgkJICogV2UgY291bGQgYmUgY2xldmVyIGFuZCBhbGxvdyB0byBhdHRhY2ggYSBldmVudCB0byBhbgoJCSAqIG9mZmxpbmUgQ1BVIGFuZCBhY3RpdmF0ZSBpdCB3aGVuIHRoZSBDUFUgY29tZXMgdXAsIGJ1dAoJCSAqIHRoYXQncyBmb3IgbGF0ZXIuCgkJICovCgkJaWYgKCFjcHVfaXNzZXQoY3B1LCBjcHVfb25saW5lX21hcCkpCgkJCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOwoKCQljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwoJCWN0eCA9ICZjcHVjdHgtPmN0eDsKCQlnZXRfY3R4KGN0eCk7CgoJCXJldHVybiBjdHg7Cgl9CgoJcmN1X3JlYWRfbG9jaygpOwoJaWYgKCFwaWQpCgkJdGFzayA9IGN1cnJlbnQ7CgllbHNlCgkJdGFzayA9IGZpbmRfdGFza19ieV92cGlkKHBpZCk7CglpZiAodGFzaykKCQlnZXRfdGFza19zdHJ1Y3QodGFzayk7CglyY3VfcmVhZF91bmxvY2soKTsKCglpZiAoIXRhc2spCgkJcmV0dXJuIEVSUl9QVFIoLUVTUkNIKTsKCgkvKgoJICogQ2FuJ3QgYXR0YWNoIGV2ZW50cyB0byBhIGR5aW5nIHRhc2suCgkgKi8KCWVyciA9IC1FU1JDSDsKCWlmICh0YXNrLT5mbGFncyAmIFBGX0VYSVRJTkcpCgkJZ290byBlcnJvdXQ7CgoJLyogUmV1c2UgcHRyYWNlIHBlcm1pc3Npb24gY2hlY2tzIGZvciBub3cuICovCgllcnIgPSAtRUFDQ0VTOwoJaWYgKCFwdHJhY2VfbWF5X2FjY2Vzcyh0YXNrLCBQVFJBQ0VfTU9ERV9SRUFEKSkKCQlnb3RvIGVycm91dDsKCiByZXRyeToKCWN0eCA9IHBlcmZfbG9ja190YXNrX2NvbnRleHQodGFzaywgJmZsYWdzKTsKCWlmIChjdHgpIHsKCQl1bmNsb25lX2N0eChjdHgpOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0eC0+bG9jaywgZmxhZ3MpOwoJfQoKCWlmICghY3R4KSB7CgkJY3R4ID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCksIEdGUF9LRVJORUwpOwoJCWVyciA9IC1FTk9NRU07CgkJaWYgKCFjdHgpCgkJCWdvdG8gZXJyb3V0OwoJCV9fcGVyZl9ldmVudF9pbml0X2NvbnRleHQoY3R4LCB0YXNrKTsKCQlnZXRfY3R4KGN0eCk7CgkJaWYgKGNtcHhjaGcoJnRhc2stPnBlcmZfZXZlbnRfY3R4cCwgTlVMTCwgY3R4KSkgewoJCQkvKgoJCQkgKiBXZSByYWNlZCB3aXRoIHNvbWUgb3RoZXIgdGFzazsgdXNlCgkJCSAqIHRoZSBjb250ZXh0IHRoZXkgc2V0LgoJCQkgKi8KCQkJa2ZyZWUoY3R4KTsKCQkJZ290byByZXRyeTsKCQl9CgkJZ2V0X3Rhc2tfc3RydWN0KHRhc2spOwoJfQoKCXB1dF90YXNrX3N0cnVjdCh0YXNrKTsKCXJldHVybiBjdHg7CgogZXJyb3V0OgoJcHV0X3Rhc2tfc3RydWN0KHRhc2spOwoJcmV0dXJuIEVSUl9QVFIoZXJyKTsKfQoKc3RhdGljIHZvaWQgcGVyZl9ldmVudF9mcmVlX2ZpbHRlcihzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpOwoKc3RhdGljIHZvaWQgZnJlZV9ldmVudF9yY3Uoc3RydWN0IHJjdV9oZWFkICpoZWFkKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CgoJZXZlbnQgPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IHBlcmZfZXZlbnQsIHJjdV9oZWFkKTsKCWlmIChldmVudC0+bnMpCgkJcHV0X3BpZF9ucyhldmVudC0+bnMpOwoJcGVyZl9ldmVudF9mcmVlX2ZpbHRlcihldmVudCk7CglrZnJlZShldmVudCk7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfcGVuZGluZ19zeW5jKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCk7CgpzdGF0aWMgdm9pZCBmcmVlX2V2ZW50KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJcGVyZl9wZW5kaW5nX3N5bmMoZXZlbnQpOwoKCWlmICghZXZlbnQtPnBhcmVudCkgewoJCWF0b21pY19kZWMoJm5yX2V2ZW50cyk7CgkJaWYgKGV2ZW50LT5hdHRyLm1tYXApCgkJCWF0b21pY19kZWMoJm5yX21tYXBfZXZlbnRzKTsKCQlpZiAoZXZlbnQtPmF0dHIuY29tbSkKCQkJYXRvbWljX2RlYygmbnJfY29tbV9ldmVudHMpOwoJCWlmIChldmVudC0+YXR0ci50YXNrKQoJCQlhdG9taWNfZGVjKCZucl90YXNrX2V2ZW50cyk7Cgl9CgoJaWYgKGV2ZW50LT5vdXRwdXQpIHsKCQlmcHV0KGV2ZW50LT5vdXRwdXQtPmZpbHApOwoJCWV2ZW50LT5vdXRwdXQgPSBOVUxMOwoJfQoKCWlmIChldmVudC0+ZGVzdHJveSkKCQlldmVudC0+ZGVzdHJveShldmVudCk7CgoJcHV0X2N0eChldmVudC0+Y3R4KTsKCWNhbGxfcmN1KCZldmVudC0+cmN1X2hlYWQsIGZyZWVfZXZlbnRfcmN1KTsKfQoKLyoKICogQ2FsbGVkIHdoZW4gdGhlIGxhc3QgcmVmZXJlbmNlIHRvIHRoZSBmaWxlIGlzIGdvbmUuCiAqLwpzdGF0aWMgaW50IHBlcmZfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gZXZlbnQtPmN0eDsKCglmaWxlLT5wcml2YXRlX2RhdGEgPSBOVUxMOwoKCVdBUk5fT05fT05DRShjdHgtPnBhcmVudF9jdHgpOwoJbXV0ZXhfbG9jaygmY3R4LT5tdXRleCk7CglwZXJmX2V2ZW50X3JlbW92ZV9mcm9tX2NvbnRleHQoZXZlbnQpOwoJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKCgltdXRleF9sb2NrKCZldmVudC0+b3duZXItPnBlcmZfZXZlbnRfbXV0ZXgpOwoJbGlzdF9kZWxfaW5pdCgmZXZlbnQtPm93bmVyX2VudHJ5KTsKCW11dGV4X3VubG9jaygmZXZlbnQtPm93bmVyLT5wZXJmX2V2ZW50X211dGV4KTsKCXB1dF90YXNrX3N0cnVjdChldmVudC0+b3duZXIpOwoKCWZyZWVfZXZlbnQoZXZlbnQpOwoKCXJldHVybiAwOwp9CgppbnQgcGVyZl9ldmVudF9yZWxlYXNlX2tlcm5lbChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9IGV2ZW50LT5jdHg7CgoJV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7CgltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKCXBlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dChldmVudCk7CgltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOwoKCW11dGV4X2xvY2soJmV2ZW50LT5vd25lci0+cGVyZl9ldmVudF9tdXRleCk7CglsaXN0X2RlbF9pbml0KCZldmVudC0+b3duZXJfZW50cnkpOwoJbXV0ZXhfdW5sb2NrKCZldmVudC0+b3duZXItPnBlcmZfZXZlbnRfbXV0ZXgpOwoJcHV0X3Rhc2tfc3RydWN0KGV2ZW50LT5vd25lcik7CgoJZnJlZV9ldmVudChldmVudCk7CgoJcmV0dXJuIDA7Cn0KRVhQT1JUX1NZTUJPTF9HUEwocGVyZl9ldmVudF9yZWxlYXNlX2tlcm5lbCk7CgpzdGF0aWMgaW50IHBlcmZfZXZlbnRfcmVhZF9zaXplKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJaW50IGVudHJ5ID0gc2l6ZW9mKHU2NCk7IC8qIHZhbHVlICovCglpbnQgc2l6ZSA9IDA7CglpbnQgbnIgPSAxOwoKCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfRU5BQkxFRCkKCQlzaXplICs9IHNpemVvZih1NjQpOwoKCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX1RPVEFMX1RJTUVfUlVOTklORykKCQlzaXplICs9IHNpemVvZih1NjQpOwoKCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQoJCWVudHJ5ICs9IHNpemVvZih1NjQpOwoKCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0dST1VQKSB7CgkJbnIgKz0gZXZlbnQtPmdyb3VwX2xlYWRlci0+bnJfc2libGluZ3M7CgkJc2l6ZSArPSBzaXplb2YodTY0KTsKCX0KCglzaXplICs9IGVudHJ5ICogbnI7CgoJcmV0dXJuIHNpemU7Cn0KCnU2NCBwZXJmX2V2ZW50X3JlYWRfdmFsdWUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGQ7Cgl1NjQgdG90YWwgPSAwOwoKCXRvdGFsICs9IHBlcmZfZXZlbnRfcmVhZChldmVudCk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGNoaWxkLCAmZXZlbnQtPmNoaWxkX2xpc3QsIGNoaWxkX2xpc3QpCgkJdG90YWwgKz0gcGVyZl9ldmVudF9yZWFkKGNoaWxkKTsKCglyZXR1cm4gdG90YWw7Cn0KRVhQT1JUX1NZTUJPTF9HUEwocGVyZl9ldmVudF9yZWFkX3ZhbHVlKTsKCnN0YXRpYyBpbnQgcGVyZl9ldmVudF9yZWFkX2VudHJ5KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCSAgIHU2NCByZWFkX2Zvcm1hdCwgY2hhciBfX3VzZXIgKmJ1ZikKewoJaW50IG4gPSAwLCBjb3VudCA9IDA7Cgl1NjQgdmFsdWVzWzJdOwoKCXZhbHVlc1tuKytdID0gcGVyZl9ldmVudF9yZWFkX3ZhbHVlKGV2ZW50KTsKCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQoJCXZhbHVlc1tuKytdID0gcHJpbWFyeV9ldmVudF9pZChldmVudCk7CgoJY291bnQgPSBuICogc2l6ZW9mKHU2NCk7CgoJaWYgKGNvcHlfdG9fdXNlcihidWYsIHZhbHVlcywgY291bnQpKQoJCXJldHVybiAtRUZBVUxUOwoKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIGludCBwZXJmX2V2ZW50X3JlYWRfZ3JvdXAoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkJICAgdTY0IHJlYWRfZm9ybWF0LCBjaGFyIF9fdXNlciAqYnVmKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyID0gZXZlbnQtPmdyb3VwX2xlYWRlciwgKnN1YjsKCWludCBuID0gMCwgc2l6ZSA9IDAsIGVyciA9IC1FRkFVTFQ7Cgl1NjQgdmFsdWVzWzNdOwoKCXZhbHVlc1tuKytdID0gMSArIGxlYWRlci0+bnJfc2libGluZ3M7CglpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX0VOQUJMRUQpIHsKCQl2YWx1ZXNbbisrXSA9IGxlYWRlci0+dG90YWxfdGltZV9lbmFibGVkICsKCQkJYXRvbWljNjRfcmVhZCgmbGVhZGVyLT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOwoJfQoJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9SVU5OSU5HKSB7CgkJdmFsdWVzW24rK10gPSBsZWFkZXItPnRvdGFsX3RpbWVfcnVubmluZyArCgkJCWF0b21pYzY0X3JlYWQoJmxlYWRlci0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKCX0KCglzaXplID0gbiAqIHNpemVvZih1NjQpOwoKCWlmIChjb3B5X3RvX3VzZXIoYnVmLCB2YWx1ZXMsIHNpemUpKQoJCXJldHVybiAtRUZBVUxUOwoKCWVyciA9IHBlcmZfZXZlbnRfcmVhZF9lbnRyeShsZWFkZXIsIHJlYWRfZm9ybWF0LCBidWYgKyBzaXplKTsKCWlmIChlcnIgPCAwKQoJCXJldHVybiBlcnI7CgoJc2l6ZSArPSBlcnI7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZsZWFkZXItPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpIHsKCQllcnIgPSBwZXJmX2V2ZW50X3JlYWRfZW50cnkoc3ViLCByZWFkX2Zvcm1hdCwKCQkJCWJ1ZiArIHNpemUpOwoJCWlmIChlcnIgPCAwKQoJCQlyZXR1cm4gZXJyOwoKCQlzaXplICs9IGVycjsKCX0KCglyZXR1cm4gc2l6ZTsKfQoKc3RhdGljIGludCBwZXJmX2V2ZW50X3JlYWRfb25lKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCSB1NjQgcmVhZF9mb3JtYXQsIGNoYXIgX191c2VyICpidWYpCnsKCXU2NCB2YWx1ZXNbNF07CglpbnQgbiA9IDA7CgoJdmFsdWVzW24rK10gPSBwZXJmX2V2ZW50X3JlYWRfdmFsdWUoZXZlbnQpOwoJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVEKSB7CgkJdmFsdWVzW24rK10gPSBldmVudC0+dG90YWxfdGltZV9lbmFibGVkICsKCQkJYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNoaWxkX3RvdGFsX3RpbWVfZW5hYmxlZCk7Cgl9CglpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkcpIHsKCQl2YWx1ZXNbbisrXSA9IGV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcgKwoJCQlhdG9taWM2NF9yZWFkKCZldmVudC0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKCX0KCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQoJCXZhbHVlc1tuKytdID0gcHJpbWFyeV9ldmVudF9pZChldmVudCk7CgoJaWYgKGNvcHlfdG9fdXNlcihidWYsIHZhbHVlcywgbiAqIHNpemVvZih1NjQpKSkKCQlyZXR1cm4gLUVGQVVMVDsKCglyZXR1cm4gbiAqIHNpemVvZih1NjQpOwp9CgovKgogKiBSZWFkIHRoZSBwZXJmb3JtYW5jZSBldmVudCAtIHNpbXBsZSBub24gYmxvY2tpbmcgdmVyc2lvbiBmb3Igbm93CiAqLwpzdGF0aWMgc3NpemVfdApwZXJmX3JlYWRfaHcoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBjaGFyIF9fdXNlciAqYnVmLCBzaXplX3QgY291bnQpCnsKCXU2NCByZWFkX2Zvcm1hdCA9IGV2ZW50LT5hdHRyLnJlYWRfZm9ybWF0OwoJaW50IHJldDsKCgkvKgoJICogUmV0dXJuIGVuZC1vZi1maWxlIGZvciBhIHJlYWQgb24gYSBldmVudCB0aGF0IGlzIGluCgkgKiBlcnJvciBzdGF0ZSAoaS5lLiBiZWNhdXNlIGl0IHdhcyBwaW5uZWQgYnV0IGl0IGNvdWxkbid0IGJlCgkgKiBzY2hlZHVsZWQgb24gdG8gdGhlIENQVSBhdCBzb21lIHBvaW50KS4KCSAqLwoJaWYgKGV2ZW50LT5zdGF0ZSA9PSBQRVJGX0VWRU5UX1NUQVRFX0VSUk9SKQoJCXJldHVybiAwOwoKCWlmIChjb3VudCA8IHBlcmZfZXZlbnRfcmVhZF9zaXplKGV2ZW50KSkKCQlyZXR1cm4gLUVOT1NQQzsKCglXQVJOX09OX09OQ0UoZXZlbnQtPmN0eC0+cGFyZW50X2N0eCk7CgltdXRleF9sb2NrKCZldmVudC0+Y2hpbGRfbXV0ZXgpOwoJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfR1JPVVApCgkJcmV0ID0gcGVyZl9ldmVudF9yZWFkX2dyb3VwKGV2ZW50LCByZWFkX2Zvcm1hdCwgYnVmKTsKCWVsc2UKCQlyZXQgPSBwZXJmX2V2ZW50X3JlYWRfb25lKGV2ZW50LCByZWFkX2Zvcm1hdCwgYnVmKTsKCW11dGV4X3VubG9jaygmZXZlbnQtPmNoaWxkX211dGV4KTsKCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgc3NpemVfdApwZXJmX3JlYWQoc3RydWN0IGZpbGUgKmZpbGUsIGNoYXIgX191c2VyICpidWYsIHNpemVfdCBjb3VudCwgbG9mZl90ICpwcG9zKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBmaWxlLT5wcml2YXRlX2RhdGE7CgoJcmV0dXJuIHBlcmZfcmVhZF9odyhldmVudCwgYnVmLCBjb3VudCk7Cn0KCnN0YXRpYyB1bnNpZ25lZCBpbnQgcGVyZl9wb2xsKHN0cnVjdCBmaWxlICpmaWxlLCBwb2xsX3RhYmxlICp3YWl0KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBmaWxlLT5wcml2YXRlX2RhdGE7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7Cgl1bnNpZ25lZCBpbnQgZXZlbnRzID0gUE9MTF9IVVA7CgoJcmN1X3JlYWRfbG9jaygpOwoJZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShldmVudC0+ZGF0YSk7CglpZiAoZGF0YSkKCQlldmVudHMgPSBhdG9taWNfeGNoZygmZGF0YS0+cG9sbCwgMCk7CglyY3VfcmVhZF91bmxvY2soKTsKCglwb2xsX3dhaXQoZmlsZSwgJmV2ZW50LT53YWl0cSwgd2FpdCk7CgoJcmV0dXJuIGV2ZW50czsKfQoKc3RhdGljIHZvaWQgcGVyZl9ldmVudF9yZXNldChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCSh2b2lkKXBlcmZfZXZlbnRfcmVhZChldmVudCk7CglhdG9taWM2NF9zZXQoJmV2ZW50LT5jb3VudCwgMCk7CglwZXJmX2V2ZW50X3VwZGF0ZV91c2VycGFnZShldmVudCk7Cn0KCi8qCiAqIEhvbGRpbmcgdGhlIHRvcC1sZXZlbCBldmVudCdzIGNoaWxkX211dGV4IG1lYW5zIHRoYXQgYW55CiAqIGRlc2NlbmRhbnQgcHJvY2VzcyB0aGF0IGhhcyBpbmhlcml0ZWQgdGhpcyBldmVudCB3aWxsIGJsb2NrCiAqIGluIHN5bmNfY2hpbGRfZXZlbnQgaWYgaXQgZ29lcyB0byBleGl0LCB0aHVzIHNhdGlzZnlpbmcgdGhlCiAqIHRhc2sgZXhpc3RlbmNlIHJlcXVpcmVtZW50cyBvZiBwZXJmX2V2ZW50X2VuYWJsZS9kaXNhYmxlLgogKi8Kc3RhdGljIHZvaWQgcGVyZl9ldmVudF9mb3JfZWFjaF9jaGlsZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCgkJCQkJdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX2V2ZW50ICopKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGQ7CgoJV0FSTl9PTl9PTkNFKGV2ZW50LT5jdHgtPnBhcmVudF9jdHgpOwoJbXV0ZXhfbG9jaygmZXZlbnQtPmNoaWxkX211dGV4KTsKCWZ1bmMoZXZlbnQpOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShjaGlsZCwgJmV2ZW50LT5jaGlsZF9saXN0LCBjaGlsZF9saXN0KQoJCWZ1bmMoY2hpbGQpOwoJbXV0ZXhfdW5sb2NrKCZldmVudC0+Y2hpbGRfbXV0ZXgpOwp9CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2Zvcl9lYWNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCSAgdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX2V2ZW50ICopKQp7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OwoJc3RydWN0IHBlcmZfZXZlbnQgKnNpYmxpbmc7CgoJV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7CgltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKCWV2ZW50ID0gZXZlbnQtPmdyb3VwX2xlYWRlcjsKCglwZXJmX2V2ZW50X2Zvcl9lYWNoX2NoaWxkKGV2ZW50LCBmdW5jKTsKCWZ1bmMoZXZlbnQpOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShzaWJsaW5nLCAmZXZlbnQtPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpCgkJcGVyZl9ldmVudF9mb3JfZWFjaF9jaGlsZChldmVudCwgZnVuYyk7CgltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOwp9CgpzdGF0aWMgaW50IHBlcmZfZXZlbnRfcGVyaW9kKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0IF9fdXNlciAqYXJnKQp7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSBldmVudC0+Y3R4OwoJdW5zaWduZWQgbG9uZyBzaXplOwoJaW50IHJldCA9IDA7Cgl1NjQgdmFsdWU7CgoJaWYgKCFldmVudC0+YXR0ci5zYW1wbGVfcGVyaW9kKQoJCXJldHVybiAtRUlOVkFMOwoKCXNpemUgPSBjb3B5X2Zyb21fdXNlcigmdmFsdWUsIGFyZywgc2l6ZW9mKHZhbHVlKSk7CglpZiAoc2l6ZSAhPSBzaXplb2YodmFsdWUpKQoJCXJldHVybiAtRUZBVUxUOwoKCWlmICghdmFsdWUpCgkJcmV0dXJuIC1FSU5WQUw7CgoJc3Bpbl9sb2NrX2lycSgmY3R4LT5sb2NrKTsKCWlmIChldmVudC0+YXR0ci5mcmVxKSB7CgkJaWYgKHZhbHVlID4gc3lzY3RsX3BlcmZfZXZlbnRfc2FtcGxlX3JhdGUpIHsKCQkJcmV0ID0gLUVJTlZBTDsKCQkJZ290byB1bmxvY2s7CgkJfQoKCQlldmVudC0+YXR0ci5zYW1wbGVfZnJlcSA9IHZhbHVlOwoJfSBlbHNlIHsKCQlldmVudC0+YXR0ci5zYW1wbGVfcGVyaW9kID0gdmFsdWU7CgkJZXZlbnQtPmh3LnNhbXBsZV9wZXJpb2QgPSB2YWx1ZTsKCX0KdW5sb2NrOgoJc3Bpbl91bmxvY2tfaXJxKCZjdHgtPmxvY2spOwoKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgcGVyZl9ldmVudF9zZXRfb3V0cHV0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IG91dHB1dF9mZCk7CnN0YXRpYyBpbnQgcGVyZl9ldmVudF9zZXRfZmlsdGVyKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdm9pZCBfX3VzZXIgKmFyZyk7CgpzdGF0aWMgbG9uZyBwZXJmX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwoJdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX2V2ZW50ICopOwoJdTMyIGZsYWdzID0gYXJnOwoKCXN3aXRjaCAoY21kKSB7CgljYXNlIFBFUkZfRVZFTlRfSU9DX0VOQUJMRToKCQlmdW5jID0gcGVyZl9ldmVudF9lbmFibGU7CgkJYnJlYWs7CgljYXNlIFBFUkZfRVZFTlRfSU9DX0RJU0FCTEU6CgkJZnVuYyA9IHBlcmZfZXZlbnRfZGlzYWJsZTsKCQlicmVhazsKCWNhc2UgUEVSRl9FVkVOVF9JT0NfUkVTRVQ6CgkJZnVuYyA9IHBlcmZfZXZlbnRfcmVzZXQ7CgkJYnJlYWs7CgoJY2FzZSBQRVJGX0VWRU5UX0lPQ19SRUZSRVNIOgoJCXJldHVybiBwZXJmX2V2ZW50X3JlZnJlc2goZXZlbnQsIGFyZyk7CgoJY2FzZSBQRVJGX0VWRU5UX0lPQ19QRVJJT0Q6CgkJcmV0dXJuIHBlcmZfZXZlbnRfcGVyaW9kKGV2ZW50LCAodTY0IF9fdXNlciAqKWFyZyk7CgoJY2FzZSBQRVJGX0VWRU5UX0lPQ19TRVRfT1VUUFVUOgoJCXJldHVybiBwZXJmX2V2ZW50X3NldF9vdXRwdXQoZXZlbnQsIGFyZyk7CgoJY2FzZSBQRVJGX0VWRU5UX0lPQ19TRVRfRklMVEVSOgoJCXJldHVybiBwZXJmX2V2ZW50X3NldF9maWx0ZXIoZXZlbnQsICh2b2lkIF9fdXNlciAqKWFyZyk7CgoJZGVmYXVsdDoKCQlyZXR1cm4gLUVOT1RUWTsKCX0KCglpZiAoZmxhZ3MgJiBQRVJGX0lPQ19GTEFHX0dST1VQKQoJCXBlcmZfZXZlbnRfZm9yX2VhY2goZXZlbnQsIGZ1bmMpOwoJZWxzZQoJCXBlcmZfZXZlbnRfZm9yX2VhY2hfY2hpbGQoZXZlbnQsIGZ1bmMpOwoKCXJldHVybiAwOwp9CgppbnQgcGVyZl9ldmVudF90YXNrX2VuYWJsZSh2b2lkKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CgoJbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGV2ZW50LCAmY3VycmVudC0+cGVyZl9ldmVudF9saXN0LCBvd25lcl9lbnRyeSkKCQlwZXJmX2V2ZW50X2Zvcl9lYWNoX2NoaWxkKGV2ZW50LCBwZXJmX2V2ZW50X2VuYWJsZSk7CgltdXRleF91bmxvY2soJmN1cnJlbnQtPnBlcmZfZXZlbnRfbXV0ZXgpOwoKCXJldHVybiAwOwp9CgppbnQgcGVyZl9ldmVudF90YXNrX2Rpc2FibGUodm9pZCkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OwoKCW11dGV4X2xvY2soJmN1cnJlbnQtPnBlcmZfZXZlbnRfbXV0ZXgpOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJmN1cnJlbnQtPnBlcmZfZXZlbnRfbGlzdCwgb3duZXJfZW50cnkpCgkJcGVyZl9ldmVudF9mb3JfZWFjaF9jaGlsZChldmVudCwgcGVyZl9ldmVudF9kaXNhYmxlKTsKCW11dGV4X3VubG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CgoJcmV0dXJuIDA7Cn0KCiNpZm5kZWYgUEVSRl9FVkVOVF9JTkRFWF9PRkZTRVQKIyBkZWZpbmUgUEVSRl9FVkVOVF9JTkRFWF9PRkZTRVQgMAojZW5kaWYKCnN0YXRpYyBpbnQgcGVyZl9ldmVudF9pbmRleChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCWlmIChldmVudC0+c3RhdGUgIT0gUEVSRl9FVkVOVF9TVEFURV9BQ1RJVkUpCgkJcmV0dXJuIDA7CgoJcmV0dXJuIGV2ZW50LT5ody5pZHggKyAxIC0gUEVSRl9FVkVOVF9JTkRFWF9PRkZTRVQ7Cn0KCi8qCiAqIENhbGxlcnMgbmVlZCB0byBlbnN1cmUgdGhlcmUgY2FuIGJlIG5vIG5lc3Rpbmcgb2YgdGhpcyBmdW5jdGlvbiwgb3RoZXJ3aXNlCiAqIHRoZSBzZXFsb2NrIGxvZ2ljIGdvZXMgYmFkLiBXZSBjYW4gbm90IHNlcmlhbGl6ZSB0aGlzIGJlY2F1c2UgdGhlIGFyY2gKICogY29kZSBjYWxscyB0aGlzIGZyb20gTk1JIGNvbnRleHQuCiAqLwp2b2lkIHBlcmZfZXZlbnRfdXBkYXRlX3VzZXJwYWdlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJc3RydWN0IHBlcmZfZXZlbnRfbW1hcF9wYWdlICp1c2VycGc7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CgoJcmN1X3JlYWRfbG9jaygpOwoJZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShldmVudC0+ZGF0YSk7CglpZiAoIWRhdGEpCgkJZ290byB1bmxvY2s7CgoJdXNlcnBnID0gZGF0YS0+dXNlcl9wYWdlOwoKCS8qCgkgKiBEaXNhYmxlIHByZWVtcHRpb24gc28gYXMgdG8gbm90IGxldCB0aGUgY29ycmVzcG9uZGluZyB1c2VyLXNwYWNlCgkgKiBzcGluIHRvbyBsb25nIGlmIHdlIGdldCBwcmVlbXB0ZWQuCgkgKi8KCXByZWVtcHRfZGlzYWJsZSgpOwoJKyt1c2VycGctPmxvY2s7CgliYXJyaWVyKCk7Cgl1c2VycGctPmluZGV4ID0gcGVyZl9ldmVudF9pbmRleChldmVudCk7Cgl1c2VycGctPm9mZnNldCA9IGF0b21pYzY0X3JlYWQoJmV2ZW50LT5jb3VudCk7CglpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQoJCXVzZXJwZy0+b2Zmc2V0IC09IGF0b21pYzY0X3JlYWQoJmV2ZW50LT5ody5wcmV2X2NvdW50KTsKCgl1c2VycGctPnRpbWVfZW5hYmxlZCA9IGV2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQgKwoJCQlhdG9taWM2NF9yZWFkKCZldmVudC0+Y2hpbGRfdG90YWxfdGltZV9lbmFibGVkKTsKCgl1c2VycGctPnRpbWVfcnVubmluZyA9IGV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcgKwoJCQlhdG9taWM2NF9yZWFkKCZldmVudC0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKCgliYXJyaWVyKCk7CgkrK3VzZXJwZy0+bG9jazsKCXByZWVtcHRfZW5hYmxlKCk7CnVubG9jazoKCXJjdV9yZWFkX3VubG9jaygpOwp9CgpzdGF0aWMgdW5zaWduZWQgbG9uZyBwZXJmX2RhdGFfc2l6ZShzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEpCnsKCXJldHVybiBkYXRhLT5ucl9wYWdlcyA8PCAoUEFHRV9TSElGVCArIGRhdGEtPmRhdGFfb3JkZXIpOwp9CgojaWZuZGVmIENPTkZJR19QRVJGX1VTRV9WTUFMTE9DCgovKgogKiBCYWNrIHBlcmZfbW1hcCgpIHdpdGggcmVndWxhciBHRlBfS0VSTkVMLTAgcGFnZXMuCiAqLwoKc3RhdGljIHN0cnVjdCBwYWdlICoKcGVyZl9tbWFwX3RvX3BhZ2Uoc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhLCB1bnNpZ25lZCBsb25nIHBnb2ZmKQp7CglpZiAocGdvZmYgPiBkYXRhLT5ucl9wYWdlcykKCQlyZXR1cm4gTlVMTDsKCglpZiAocGdvZmYgPT0gMCkKCQlyZXR1cm4gdmlydF90b19wYWdlKGRhdGEtPnVzZXJfcGFnZSk7CgoJcmV0dXJuIHZpcnRfdG9fcGFnZShkYXRhLT5kYXRhX3BhZ2VzW3Bnb2ZmIC0gMV0pOwp9CgpzdGF0aWMgc3RydWN0IHBlcmZfbW1hcF9kYXRhICoKcGVyZl9tbWFwX2RhdGFfYWxsb2Moc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgbnJfcGFnZXMpCnsKCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKCXVuc2lnbmVkIGxvbmcgc2l6ZTsKCWludCBpOwoKCVdBUk5fT04oYXRvbWljX3JlYWQoJmV2ZW50LT5tbWFwX2NvdW50KSk7CgoJc2l6ZSA9IHNpemVvZihzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEpOwoJc2l6ZSArPSBucl9wYWdlcyAqIHNpemVvZih2b2lkICopOwoKCWRhdGEgPSBremFsbG9jKHNpemUsIEdGUF9LRVJORUwpOwoJaWYgKCFkYXRhKQoJCWdvdG8gZmFpbDsKCglkYXRhLT51c2VyX3BhZ2UgPSAodm9pZCAqKWdldF96ZXJvZWRfcGFnZShHRlBfS0VSTkVMKTsKCWlmICghZGF0YS0+dXNlcl9wYWdlKQoJCWdvdG8gZmFpbF91c2VyX3BhZ2U7CgoJZm9yIChpID0gMDsgaSA8IG5yX3BhZ2VzOyBpKyspIHsKCQlkYXRhLT5kYXRhX3BhZ2VzW2ldID0gKHZvaWQgKilnZXRfemVyb2VkX3BhZ2UoR0ZQX0tFUk5FTCk7CgkJaWYgKCFkYXRhLT5kYXRhX3BhZ2VzW2ldKQoJCQlnb3RvIGZhaWxfZGF0YV9wYWdlczsKCX0KCglkYXRhLT5kYXRhX29yZGVyID0gMDsKCWRhdGEtPm5yX3BhZ2VzID0gbnJfcGFnZXM7CgoJcmV0dXJuIGRhdGE7CgpmYWlsX2RhdGFfcGFnZXM6Cglmb3IgKGktLTsgaSA+PSAwOyBpLS0pCgkJZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKWRhdGEtPmRhdGFfcGFnZXNbaV0pOwoKCWZyZWVfcGFnZSgodW5zaWduZWQgbG9uZylkYXRhLT51c2VyX3BhZ2UpOwoKZmFpbF91c2VyX3BhZ2U6CglrZnJlZShkYXRhKTsKCmZhaWw6CglyZXR1cm4gTlVMTDsKfQoKc3RhdGljIHZvaWQgcGVyZl9tbWFwX2ZyZWVfcGFnZSh1bnNpZ25lZCBsb25nIGFkZHIpCnsKCXN0cnVjdCBwYWdlICpwYWdlID0gdmlydF90b19wYWdlKCh2b2lkICopYWRkcik7CgoJcGFnZS0+bWFwcGluZyA9IE5VTEw7CglfX2ZyZWVfcGFnZShwYWdlKTsKfQoKc3RhdGljIHZvaWQgcGVyZl9tbWFwX2RhdGFfZnJlZShzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEpCnsKCWludCBpOwoKCXBlcmZfbW1hcF9mcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+dXNlcl9wYWdlKTsKCWZvciAoaSA9IDA7IGkgPCBkYXRhLT5ucl9wYWdlczsgaSsrKQoJCXBlcmZfbW1hcF9mcmVlX3BhZ2UoKHVuc2lnbmVkIGxvbmcpZGF0YS0+ZGF0YV9wYWdlc1tpXSk7Cn0KCiNlbHNlCgovKgogKiBCYWNrIHBlcmZfbW1hcCgpIHdpdGggdm1hbGxvYyBtZW1vcnkuCiAqCiAqIFJlcXVpcmVkIGZvciBhcmNoaXRlY3R1cmVzIHRoYXQgaGF2ZSBkLWNhY2hlIGFsaWFzaW5nIGlzc3Vlcy4KICovCgpzdGF0aWMgc3RydWN0IHBhZ2UgKgpwZXJmX21tYXBfdG9fcGFnZShzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEsIHVuc2lnbmVkIGxvbmcgcGdvZmYpCnsKCWlmIChwZ29mZiA+ICgxVUwgPDwgZGF0YS0+ZGF0YV9vcmRlcikpCgkJcmV0dXJuIE5VTEw7CgoJcmV0dXJuIHZtYWxsb2NfdG9fcGFnZSgodm9pZCAqKWRhdGEtPnVzZXJfcGFnZSArIHBnb2ZmICogUEFHRV9TSVpFKTsKfQoKc3RhdGljIHZvaWQgcGVyZl9tbWFwX3VubWFya19wYWdlKHZvaWQgKmFkZHIpCnsKCXN0cnVjdCBwYWdlICpwYWdlID0gdm1hbGxvY190b19wYWdlKGFkZHIpOwoKCXBhZ2UtPm1hcHBpbmcgPSBOVUxMOwp9CgpzdGF0aWMgdm9pZCBwZXJmX21tYXBfZGF0YV9mcmVlX3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQp7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7Cgl2b2lkICpiYXNlOwoJaW50IGksIG5yOwoKCWRhdGEgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHBlcmZfbW1hcF9kYXRhLCB3b3JrKTsKCW5yID0gMSA8PCBkYXRhLT5kYXRhX29yZGVyOwoKCWJhc2UgPSBkYXRhLT51c2VyX3BhZ2U7Cglmb3IgKGkgPSAwOyBpIDwgbnIgKyAxOyBpKyspCgkJcGVyZl9tbWFwX3VubWFya19wYWdlKGJhc2UgKyAoaSAqIFBBR0VfU0laRSkpOwoKCXZmcmVlKGJhc2UpOwp9CgpzdGF0aWMgdm9pZCBwZXJmX21tYXBfZGF0YV9mcmVlKHN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSkKewoJc2NoZWR1bGVfd29yaygmZGF0YS0+d29yayk7Cn0KCnN0YXRpYyBzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKgpwZXJmX21tYXBfZGF0YV9hbGxvYyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBucl9wYWdlcykKewoJc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwoJdW5zaWduZWQgbG9uZyBzaXplOwoJdm9pZCAqYWxsX2J1ZjsKCglXQVJOX09OKGF0b21pY19yZWFkKCZldmVudC0+bW1hcF9jb3VudCkpOwoKCXNpemUgPSBzaXplb2Yoc3RydWN0IHBlcmZfbW1hcF9kYXRhKTsKCXNpemUgKz0gc2l6ZW9mKHZvaWQgKik7CgoJZGF0YSA9IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7CglpZiAoIWRhdGEpCgkJZ290byBmYWlsOwoKCUlOSVRfV09SSygmZGF0YS0+d29yaywgcGVyZl9tbWFwX2RhdGFfZnJlZV93b3JrKTsKCglhbGxfYnVmID0gdm1hbGxvY191c2VyKChucl9wYWdlcyArIDEpICogUEFHRV9TSVpFKTsKCWlmICghYWxsX2J1ZikKCQlnb3RvIGZhaWxfYWxsX2J1ZjsKCglkYXRhLT51c2VyX3BhZ2UgPSBhbGxfYnVmOwoJZGF0YS0+ZGF0YV9wYWdlc1swXSA9IGFsbF9idWYgKyBQQUdFX1NJWkU7CglkYXRhLT5kYXRhX29yZGVyID0gaWxvZzIobnJfcGFnZXMpOwoJZGF0YS0+bnJfcGFnZXMgPSAxOwoKCXJldHVybiBkYXRhOwoKZmFpbF9hbGxfYnVmOgoJa2ZyZWUoZGF0YSk7CgpmYWlsOgoJcmV0dXJuIE5VTEw7Cn0KCiNlbmRpZgoKc3RhdGljIGludCBwZXJmX21tYXBfZmF1bHQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHN0cnVjdCB2bV9mYXVsdCAqdm1mKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSB2bWEtPnZtX2ZpbGUtPnByaXZhdGVfZGF0YTsKCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YTsKCWludCByZXQgPSBWTV9GQVVMVF9TSUdCVVM7CgoJaWYgKHZtZi0+ZmxhZ3MgJiBGQVVMVF9GTEFHX01LV1JJVEUpIHsKCQlpZiAodm1mLT5wZ29mZiA9PSAwKQoJCQlyZXQgPSAwOwoJCXJldHVybiByZXQ7Cgl9CgoJcmN1X3JlYWRfbG9jaygpOwoJZGF0YSA9IHJjdV9kZXJlZmVyZW5jZShldmVudC0+ZGF0YSk7CglpZiAoIWRhdGEpCgkJZ290byB1bmxvY2s7CgoJaWYgKHZtZi0+cGdvZmYgJiYgKHZtZi0+ZmxhZ3MgJiBGQVVMVF9GTEFHX1dSSVRFKSkKCQlnb3RvIHVubG9jazsKCgl2bWYtPnBhZ2UgPSBwZXJmX21tYXBfdG9fcGFnZShkYXRhLCB2bWYtPnBnb2ZmKTsKCWlmICghdm1mLT5wYWdlKQoJCWdvdG8gdW5sb2NrOwoKCWdldF9wYWdlKHZtZi0+cGFnZSk7Cgl2bWYtPnBhZ2UtPm1hcHBpbmcgPSB2bWEtPnZtX2ZpbGUtPmZfbWFwcGluZzsKCXZtZi0+cGFnZS0+aW5kZXggICA9IHZtZi0+cGdvZmY7CgoJcmV0ID0gMDsKdW5sb2NrOgoJcmN1X3JlYWRfdW5sb2NrKCk7CgoJcmV0dXJuIHJldDsKfQoKc3RhdGljIHZvaWQKcGVyZl9tbWFwX2RhdGFfaW5pdChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSkKewoJbG9uZyBtYXhfc2l6ZSA9IHBlcmZfZGF0YV9zaXplKGRhdGEpOwoKCWF0b21pY19zZXQoJmRhdGEtPmxvY2ssIC0xKTsKCglpZiAoZXZlbnQtPmF0dHIud2F0ZXJtYXJrKSB7CgkJZGF0YS0+d2F0ZXJtYXJrID0gbWluX3QobG9uZywgbWF4X3NpemUsCgkJCQkJZXZlbnQtPmF0dHIud2FrZXVwX3dhdGVybWFyayk7Cgl9CgoJaWYgKCFkYXRhLT53YXRlcm1hcmspCgkJZGF0YS0+d2F0ZXJtYXJrID0gbWF4X3QobG9uZywgUEFHRV9TSVpFLCBtYXhfc2l6ZSAvIDIpOwoKCglyY3VfYXNzaWduX3BvaW50ZXIoZXZlbnQtPmRhdGEsIGRhdGEpOwp9CgpzdGF0aWMgdm9pZCBwZXJmX21tYXBfZGF0YV9mcmVlX3JjdShzdHJ1Y3QgcmN1X2hlYWQgKnJjdV9oZWFkKQp7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGE7CgoJZGF0YSA9IGNvbnRhaW5lcl9vZihyY3VfaGVhZCwgc3RydWN0IHBlcmZfbW1hcF9kYXRhLCByY3VfaGVhZCk7CglwZXJmX21tYXBfZGF0YV9mcmVlKGRhdGEpOwoJa2ZyZWUoZGF0YSk7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfbW1hcF9kYXRhX3JlbGVhc2Uoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBldmVudC0+ZGF0YTsKCglXQVJOX09OKGF0b21pY19yZWFkKCZldmVudC0+bW1hcF9jb3VudCkpOwoKCXJjdV9hc3NpZ25fcG9pbnRlcihldmVudC0+ZGF0YSwgTlVMTCk7CgljYWxsX3JjdSgmZGF0YS0+cmN1X2hlYWQsIHBlcmZfbW1hcF9kYXRhX2ZyZWVfcmN1KTsKfQoKc3RhdGljIHZvaWQgcGVyZl9tbWFwX29wZW4oc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IHZtYS0+dm1fZmlsZS0+cHJpdmF0ZV9kYXRhOwoKCWF0b21pY19pbmMoJmV2ZW50LT5tbWFwX2NvdW50KTsKfQoKc3RhdGljIHZvaWQgcGVyZl9tbWFwX2Nsb3NlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSB2bWEtPnZtX2ZpbGUtPnByaXZhdGVfZGF0YTsKCglXQVJOX09OX09OQ0UoZXZlbnQtPmN0eC0+cGFyZW50X2N0eCk7CglpZiAoYXRvbWljX2RlY19hbmRfbXV0ZXhfbG9jaygmZXZlbnQtPm1tYXBfY291bnQsICZldmVudC0+bW1hcF9tdXRleCkpIHsKCQl1bnNpZ25lZCBsb25nIHNpemUgPSBwZXJmX2RhdGFfc2l6ZShldmVudC0+ZGF0YSk7CgkJc3RydWN0IHVzZXJfc3RydWN0ICp1c2VyID0gY3VycmVudF91c2VyKCk7CgoJCWF0b21pY19sb25nX3N1Yigoc2l6ZSA+PiBQQUdFX1NISUZUKSArIDEsICZ1c2VyLT5sb2NrZWRfdm0pOwoJCXZtYS0+dm1fbW0tPmxvY2tlZF92bSAtPSBldmVudC0+ZGF0YS0+bnJfbG9ja2VkOwoJCXBlcmZfbW1hcF9kYXRhX3JlbGVhc2UoZXZlbnQpOwoJCW11dGV4X3VubG9jaygmZXZlbnQtPm1tYXBfbXV0ZXgpOwoJfQp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IHZtX29wZXJhdGlvbnNfc3RydWN0IHBlcmZfbW1hcF92bW9wcyA9IHsKCS5vcGVuCQk9IHBlcmZfbW1hcF9vcGVuLAoJLmNsb3NlCQk9IHBlcmZfbW1hcF9jbG9zZSwKCS5mYXVsdAkJPSBwZXJmX21tYXBfZmF1bHQsCgkucGFnZV9ta3dyaXRlCT0gcGVyZl9tbWFwX2ZhdWx0LAp9OwoKc3RhdGljIGludCBwZXJmX21tYXAoc3RydWN0IGZpbGUgKmZpbGUsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQgPSBmaWxlLT5wcml2YXRlX2RhdGE7Cgl1bnNpZ25lZCBsb25nIHVzZXJfbG9ja2VkLCB1c2VyX2xvY2tfbGltaXQ7CglzdHJ1Y3QgdXNlcl9zdHJ1Y3QgKnVzZXIgPSBjdXJyZW50X3VzZXIoKTsKCXVuc2lnbmVkIGxvbmcgbG9ja2VkLCBsb2NrX2xpbWl0OwoJc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwoJdW5zaWduZWQgbG9uZyB2bWFfc2l6ZTsKCXVuc2lnbmVkIGxvbmcgbnJfcGFnZXM7Cglsb25nIHVzZXJfZXh0cmEsIGV4dHJhOwoJaW50IHJldCA9IDA7CgoJaWYgKCEodm1hLT52bV9mbGFncyAmIFZNX1NIQVJFRCkpCgkJcmV0dXJuIC1FSU5WQUw7CgoJdm1hX3NpemUgPSB2bWEtPnZtX2VuZCAtIHZtYS0+dm1fc3RhcnQ7Cglucl9wYWdlcyA9ICh2bWFfc2l6ZSAvIFBBR0VfU0laRSkgLSAxOwoKCS8qCgkgKiBJZiB3ZSBoYXZlIGRhdGEgcGFnZXMgZW5zdXJlIHRoZXkncmUgYSBwb3dlci1vZi10d28gbnVtYmVyLCBzbyB3ZQoJICogY2FuIGRvIGJpdG1hc2tzIGluc3RlYWQgb2YgbW9kdWxvLgoJICovCglpZiAobnJfcGFnZXMgIT0gMCAmJiAhaXNfcG93ZXJfb2ZfMihucl9wYWdlcykpCgkJcmV0dXJuIC1FSU5WQUw7CgoJaWYgKHZtYV9zaXplICE9IFBBR0VfU0laRSAqICgxICsgbnJfcGFnZXMpKQoJCXJldHVybiAtRUlOVkFMOwoKCWlmICh2bWEtPnZtX3Bnb2ZmICE9IDApCgkJcmV0dXJuIC1FSU5WQUw7CgoJV0FSTl9PTl9PTkNFKGV2ZW50LT5jdHgtPnBhcmVudF9jdHgpOwoJbXV0ZXhfbG9jaygmZXZlbnQtPm1tYXBfbXV0ZXgpOwoJaWYgKGV2ZW50LT5vdXRwdXQpIHsKCQlyZXQgPSAtRUlOVkFMOwoJCWdvdG8gdW5sb2NrOwoJfQoKCWlmIChhdG9taWNfaW5jX25vdF96ZXJvKCZldmVudC0+bW1hcF9jb3VudCkpIHsKCQlpZiAobnJfcGFnZXMgIT0gZXZlbnQtPmRhdGEtPm5yX3BhZ2VzKQoJCQlyZXQgPSAtRUlOVkFMOwoJCWdvdG8gdW5sb2NrOwoJfQoKCXVzZXJfZXh0cmEgPSBucl9wYWdlcyArIDE7Cgl1c2VyX2xvY2tfbGltaXQgPSBzeXNjdGxfcGVyZl9ldmVudF9tbG9jayA+PiAoUEFHRV9TSElGVCAtIDEwKTsKCgkvKgoJICogSW5jcmVhc2UgdGhlIGxpbWl0IGxpbmVhcmx5IHdpdGggbW9yZSBDUFVzOgoJICovCgl1c2VyX2xvY2tfbGltaXQgKj0gbnVtX29ubGluZV9jcHVzKCk7CgoJdXNlcl9sb2NrZWQgPSBhdG9taWNfbG9uZ19yZWFkKCZ1c2VyLT5sb2NrZWRfdm0pICsgdXNlcl9leHRyYTsKCglleHRyYSA9IDA7CglpZiAodXNlcl9sb2NrZWQgPiB1c2VyX2xvY2tfbGltaXQpCgkJZXh0cmEgPSB1c2VyX2xvY2tlZCAtIHVzZXJfbG9ja19saW1pdDsKCglsb2NrX2xpbWl0ID0gY3VycmVudC0+c2lnbmFsLT5ybGltW1JMSU1JVF9NRU1MT0NLXS5ybGltX2N1cjsKCWxvY2tfbGltaXQgPj49IFBBR0VfU0hJRlQ7Cglsb2NrZWQgPSB2bWEtPnZtX21tLT5sb2NrZWRfdm0gKyBleHRyYTsKCglpZiAoKGxvY2tlZCA+IGxvY2tfbGltaXQpICYmIHBlcmZfcGFyYW5vaWRfdHJhY2Vwb2ludF9yYXcoKSAmJgoJCSFjYXBhYmxlKENBUF9JUENfTE9DSykpIHsKCQlyZXQgPSAtRVBFUk07CgkJZ290byB1bmxvY2s7Cgl9CgoJV0FSTl9PTihldmVudC0+ZGF0YSk7CgoJZGF0YSA9IHBlcmZfbW1hcF9kYXRhX2FsbG9jKGV2ZW50LCBucl9wYWdlcyk7CglyZXQgPSAtRU5PTUVNOwoJaWYgKCFkYXRhKQoJCWdvdG8gdW5sb2NrOwoKCXJldCA9IDA7CglwZXJmX21tYXBfZGF0YV9pbml0KGV2ZW50LCBkYXRhKTsKCglhdG9taWNfc2V0KCZldmVudC0+bW1hcF9jb3VudCwgMSk7CglhdG9taWNfbG9uZ19hZGQodXNlcl9leHRyYSwgJnVzZXItPmxvY2tlZF92bSk7Cgl2bWEtPnZtX21tLT5sb2NrZWRfdm0gKz0gZXh0cmE7CglldmVudC0+ZGF0YS0+bnJfbG9ja2VkID0gZXh0cmE7CglpZiAodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKQoJCWV2ZW50LT5kYXRhLT53cml0YWJsZSA9IDE7Cgp1bmxvY2s6CgltdXRleF91bmxvY2soJmV2ZW50LT5tbWFwX211dGV4KTsKCgl2bWEtPnZtX2ZsYWdzIHw9IFZNX1JFU0VSVkVEOwoJdm1hLT52bV9vcHMgPSAmcGVyZl9tbWFwX3Ztb3BzOwoKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQgcGVyZl9mYXN5bmMoaW50IGZkLCBzdHJ1Y3QgZmlsZSAqZmlscCwgaW50IG9uKQp7CglzdHJ1Y3QgaW5vZGUgKmlub2RlID0gZmlscC0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZTsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCA9IGZpbHAtPnByaXZhdGVfZGF0YTsKCWludCByZXR2YWw7CgoJbXV0ZXhfbG9jaygmaW5vZGUtPmlfbXV0ZXgpOwoJcmV0dmFsID0gZmFzeW5jX2hlbHBlcihmZCwgZmlscCwgb24sICZldmVudC0+ZmFzeW5jKTsKCW11dGV4X3VubG9jaygmaW5vZGUtPmlfbXV0ZXgpOwoKCWlmIChyZXR2YWwgPCAwKQoJCXJldHVybiByZXR2YWw7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHBlcmZfZm9wcyA9IHsKCS5yZWxlYXNlCQk9IHBlcmZfcmVsZWFzZSwKCS5yZWFkCQkJPSBwZXJmX3JlYWQsCgkucG9sbAkJCT0gcGVyZl9wb2xsLAoJLnVubG9ja2VkX2lvY3RsCQk9IHBlcmZfaW9jdGwsCgkuY29tcGF0X2lvY3RsCQk9IHBlcmZfaW9jdGwsCgkubW1hcAkJCT0gcGVyZl9tbWFwLAoJLmZhc3luYwkJCT0gcGVyZl9mYXN5bmMsCn07CgovKgogKiBQZXJmIGV2ZW50IHdha2V1cAogKgogKiBJZiB0aGVyZSdzIGRhdGEsIGVuc3VyZSB3ZSBzZXQgdGhlIHBvbGwoKSBzdGF0ZSBhbmQgcHVibGlzaCBldmVyeXRoaW5nCiAqIHRvIHVzZXItc3BhY2UgYmVmb3JlIHdha2luZyBldmVyeWJvZHkgdXAuCiAqLwoKdm9pZCBwZXJmX2V2ZW50X3dha2V1cChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXdha2VfdXBfYWxsKCZldmVudC0+d2FpdHEpOwoKCWlmIChldmVudC0+cGVuZGluZ19raWxsKSB7CgkJa2lsbF9mYXN5bmMoJmV2ZW50LT5mYXN5bmMsIFNJR0lPLCBldmVudC0+cGVuZGluZ19raWxsKTsKCQlldmVudC0+cGVuZGluZ19raWxsID0gMDsKCX0KfQoKLyoKICogUGVuZGluZyB3YWtldXBzCiAqCiAqIEhhbmRsZSB0aGUgY2FzZSB3aGVyZSB3ZSBuZWVkIHRvIHdha2V1cCB1cCBmcm9tIE5NSSAob3IgcnEtPmxvY2spIGNvbnRleHQuCiAqCiAqIFRoZSBOTUkgYml0IG1lYW5zIHdlIGNhbm5vdCBwb3NzaWJseSB0YWtlIGxvY2tzLiBUaGVyZWZvcmUsIG1haW50YWluIGEKICogc2luZ2xlIGxpbmtlZCBsaXN0IGFuZCB1c2UgY21weGNoZygpIHRvIGFkZCBlbnRyaWVzIGxvY2tsZXNzLgogKi8KCnN0YXRpYyB2b2lkIHBlcmZfcGVuZGluZ19ldmVudChzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICplbnRyeSkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gY29udGFpbmVyX29mKGVudHJ5LAoJCQlzdHJ1Y3QgcGVyZl9ldmVudCwgcGVuZGluZyk7CgoJaWYgKGV2ZW50LT5wZW5kaW5nX2Rpc2FibGUpIHsKCQlldmVudC0+cGVuZGluZ19kaXNhYmxlID0gMDsKCQlfX3BlcmZfZXZlbnRfZGlzYWJsZShldmVudCk7Cgl9CgoJaWYgKGV2ZW50LT5wZW5kaW5nX3dha2V1cCkgewoJCWV2ZW50LT5wZW5kaW5nX3dha2V1cCA9IDA7CgkJcGVyZl9ldmVudF93YWtldXAoZXZlbnQpOwoJfQp9CgojZGVmaW5lIFBFTkRJTkdfVEFJTCAoKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKiktMVVMKQoKc3RhdGljIERFRklORV9QRVJfQ1BVKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKiwgcGVyZl9wZW5kaW5nX2hlYWQpID0gewoJUEVORElOR19UQUlMLAp9OwoKc3RhdGljIHZvaWQgcGVyZl9wZW5kaW5nX3F1ZXVlKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKmVudHJ5LAoJCQkgICAgICAgdm9pZCAoKmZ1bmMpKHN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKikpCnsKCXN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKipoZWFkOwoKCWlmIChjbXB4Y2hnKCZlbnRyeS0+bmV4dCwgTlVMTCwgUEVORElOR19UQUlMKSAhPSBOVUxMKQoJCXJldHVybjsKCgllbnRyeS0+ZnVuYyA9IGZ1bmM7CgoJaGVhZCA9ICZnZXRfY3B1X3ZhcihwZXJmX3BlbmRpbmdfaGVhZCk7CgoJZG8gewoJCWVudHJ5LT5uZXh0ID0gKmhlYWQ7Cgl9IHdoaWxlIChjbXB4Y2hnKGhlYWQsIGVudHJ5LT5uZXh0LCBlbnRyeSkgIT0gZW50cnktPm5leHQpOwoKCXNldF9wZXJmX2V2ZW50X3BlbmRpbmcoKTsKCglwdXRfY3B1X3ZhcihwZXJmX3BlbmRpbmdfaGVhZCk7Cn0KCnN0YXRpYyBpbnQgX19wZXJmX3BlbmRpbmdfcnVuKHZvaWQpCnsKCXN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKmxpc3Q7CglpbnQgbnIgPSAwOwoKCWxpc3QgPSB4Y2hnKCZfX2dldF9jcHVfdmFyKHBlcmZfcGVuZGluZ19oZWFkKSwgUEVORElOR19UQUlMKTsKCXdoaWxlIChsaXN0ICE9IFBFTkRJTkdfVEFJTCkgewoJCXZvaWQgKCpmdW5jKShzdHJ1Y3QgcGVyZl9wZW5kaW5nX2VudHJ5ICopOwoJCXN0cnVjdCBwZXJmX3BlbmRpbmdfZW50cnkgKmVudHJ5ID0gbGlzdDsKCgkJbGlzdCA9IGxpc3QtPm5leHQ7CgoJCWZ1bmMgPSBlbnRyeS0+ZnVuYzsKCQllbnRyeS0+bmV4dCA9IE5VTEw7CgkJLyoKCQkgKiBFbnN1cmUgd2Ugb2JzZXJ2ZSB0aGUgdW5xdWV1ZSBiZWZvcmUgd2UgaXNzdWUgdGhlIHdha2V1cCwKCQkgKiBzbyB0aGF0IHdlIHdvbid0IGJlIHdhaXRpbmcgZm9yZXZlci4KCQkgKiAtLSBzZWUgcGVyZl9ub3RfcGVuZGluZygpLgoJCSAqLwoJCXNtcF93bWIoKTsKCgkJZnVuYyhlbnRyeSk7CgkJbnIrKzsKCX0KCglyZXR1cm4gbnI7Cn0KCnN0YXRpYyBpbmxpbmUgaW50IHBlcmZfbm90X3BlbmRpbmcoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CgkvKgoJICogSWYgd2UgZmx1c2ggb24gd2hhdGV2ZXIgY3B1IHdlIHJ1biwgdGhlcmUgaXMgYSBjaGFuY2Ugd2UgZG9uJ3QKCSAqIG5lZWQgdG8gd2FpdC4KCSAqLwoJZ2V0X2NwdSgpOwoJX19wZXJmX3BlbmRpbmdfcnVuKCk7CglwdXRfY3B1KCk7CgoJLyoKCSAqIEVuc3VyZSB3ZSBzZWUgdGhlIHByb3BlciBxdWV1ZSBzdGF0ZSBiZWZvcmUgZ29pbmcgdG8gc2xlZXAKCSAqIHNvIHRoYXQgd2UgZG8gbm90IG1pc3MgdGhlIHdha2V1cC4gLS0gc2VlIHBlcmZfcGVuZGluZ19oYW5kbGUoKQoJICovCglzbXBfcm1iKCk7CglyZXR1cm4gZXZlbnQtPnBlbmRpbmcubmV4dCA9PSBOVUxMOwp9CgpzdGF0aWMgdm9pZCBwZXJmX3BlbmRpbmdfc3luYyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXdhaXRfZXZlbnQoZXZlbnQtPndhaXRxLCBwZXJmX25vdF9wZW5kaW5nKGV2ZW50KSk7Cn0KCnZvaWQgcGVyZl9ldmVudF9kb19wZW5kaW5nKHZvaWQpCnsKCV9fcGVyZl9wZW5kaW5nX3J1bigpOwp9CgovKgogKiBDYWxsY2hhaW4gc3VwcG9ydCAtLSBhcmNoIHNwZWNpZmljCiAqLwoKX193ZWFrIHN0cnVjdCBwZXJmX2NhbGxjaGFpbl9lbnRyeSAqcGVyZl9jYWxsY2hhaW4oc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCnsKCXJldHVybiBOVUxMOwp9CgovKgogKiBPdXRwdXQKICovCnN0YXRpYyBib29sIHBlcmZfb3V0cHV0X3NwYWNlKHN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSwgdW5zaWduZWQgbG9uZyB0YWlsLAoJCQkgICAgICB1bnNpZ25lZCBsb25nIG9mZnNldCwgdW5zaWduZWQgbG9uZyBoZWFkKQp7Cgl1bnNpZ25lZCBsb25nIG1hc2s7CgoJaWYgKCFkYXRhLT53cml0YWJsZSkKCQlyZXR1cm4gdHJ1ZTsKCgltYXNrID0gcGVyZl9kYXRhX3NpemUoZGF0YSkgLSAxOwoKCW9mZnNldCA9IChvZmZzZXQgLSB0YWlsKSAmIG1hc2s7CgloZWFkICAgPSAoaGVhZCAgIC0gdGFpbCkgJiBtYXNrOwoKCWlmICgoaW50KShoZWFkIC0gb2Zmc2V0KSA8IDApCgkJcmV0dXJuIGZhbHNlOwoKCXJldHVybiB0cnVlOwp9CgpzdGF0aWMgdm9pZCBwZXJmX291dHB1dF93YWtldXAoc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQp7CglhdG9taWNfc2V0KCZoYW5kbGUtPmRhdGEtPnBvbGwsIFBPTExfSU4pOwoKCWlmIChoYW5kbGUtPm5taSkgewoJCWhhbmRsZS0+ZXZlbnQtPnBlbmRpbmdfd2FrZXVwID0gMTsKCQlwZXJmX3BlbmRpbmdfcXVldWUoJmhhbmRsZS0+ZXZlbnQtPnBlbmRpbmcsCgkJCQkgICBwZXJmX3BlbmRpbmdfZXZlbnQpOwoJfSBlbHNlCgkJcGVyZl9ldmVudF93YWtldXAoaGFuZGxlLT5ldmVudCk7Cn0KCi8qCiAqIEN1cmlvdXMgbG9ja2luZyBjb25zdHJ1Y3QuCiAqCiAqIFdlIG5lZWQgdG8gZW5zdXJlIGEgbGF0ZXIgZXZlbnRfaWQgZG9lc24ndCBwdWJsaXNoIGEgaGVhZCB3aGVuIGEgZm9ybWVyCiAqIGV2ZW50X2lkIGlzbid0IGRvbmUgd3JpdGluZy4gSG93ZXZlciBzaW5jZSB3ZSBuZWVkIHRvIGRlYWwgd2l0aCBOTUlzIHdlCiAqIGNhbm5vdCBmdWxseSBzZXJpYWxpemUgdGhpbmdzLgogKgogKiBXaGF0IHdlIGRvIGlzIHNlcmlhbGl6ZSBiZXR3ZWVuIENQVXMgc28gd2Ugb25seSBoYXZlIHRvIGRlYWwgd2l0aCBOTUkKICogbmVzdGluZyBvbiBhIHNpbmdsZSBDUFUuCiAqCiAqIFdlIG9ubHkgcHVibGlzaCB0aGUgaGVhZCAoYW5kIGdlbmVyYXRlIGEgd2FrZXVwKSB3aGVuIHRoZSBvdXRlci1tb3N0CiAqIGV2ZW50X2lkIGNvbXBsZXRlcy4KICovCnN0YXRpYyB2b2lkIHBlcmZfb3V0cHV0X2xvY2soc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQp7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBoYW5kbGUtPmRhdGE7CglpbnQgY3VyLCBjcHUgPSBnZXRfY3B1KCk7CgoJaGFuZGxlLT5sb2NrZWQgPSAwOwoKCWZvciAoOzspIHsKCQljdXIgPSBhdG9taWNfY21weGNoZygmZGF0YS0+bG9jaywgLTEsIGNwdSk7CgkJaWYgKGN1ciA9PSAtMSkgewoJCQloYW5kbGUtPmxvY2tlZCA9IDE7CgkJCWJyZWFrOwoJCX0KCQlpZiAoY3VyID09IGNwdSkKCQkJYnJlYWs7CgoJCWNwdV9yZWxheCgpOwoJfQp9CgpzdGF0aWMgdm9pZCBwZXJmX291dHB1dF91bmxvY2soc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSAqaGFuZGxlKQp7CglzdHJ1Y3QgcGVyZl9tbWFwX2RhdGEgKmRhdGEgPSBoYW5kbGUtPmRhdGE7Cgl1bnNpZ25lZCBsb25nIGhlYWQ7CglpbnQgY3B1OwoKCWRhdGEtPmRvbmVfaGVhZCA9IGRhdGEtPmhlYWQ7CgoJaWYgKCFoYW5kbGUtPmxvY2tlZCkKCQlnb3RvIG91dDsKCmFnYWluOgoJLyoKCSAqIFRoZSB4Y2hnIGltcGxpZXMgYSBmdWxsIGJhcnJpZXIgdGhhdCBlbnN1cmVzIGFsbCB3cml0ZXMgYXJlIGRvbmUKCSAqIGJlZm9yZSB3ZSBwdWJsaXNoIHRoZSBuZXcgaGVhZCwgbWF0Y2hlZCBieSBhIHJtYigpIGluIHVzZXJzcGFjZSB3aGVuCgkgKiByZWFkaW5nIHRoaXMgcG9zaXRpb24uCgkgKi8KCXdoaWxlICgoaGVhZCA9IGF0b21pY19sb25nX3hjaGcoJmRhdGEtPmRvbmVfaGVhZCwgMCkpKQoJCWRhdGEtPnVzZXJfcGFnZS0+ZGF0YV9oZWFkID0gaGVhZDsKCgkvKgoJICogTk1JIGNhbiBoYXBwZW4gaGVyZSwgd2hpY2ggbWVhbnMgd2UgY2FuIG1pc3MgYSBkb25lX2hlYWQgdXBkYXRlLgoJICovCgoJY3B1ID0gYXRvbWljX3hjaGcoJmRhdGEtPmxvY2ssIC0xKTsKCVdBUk5fT05fT05DRShjcHUgIT0gc21wX3Byb2Nlc3Nvcl9pZCgpKTsKCgkvKgoJICogVGhlcmVmb3JlIHdlIGhhdmUgdG8gdmFsaWRhdGUgd2UgZGlkIG5vdCBpbmRlZWQgZG8gc28uCgkgKi8KCWlmICh1bmxpa2VseShhdG9taWNfbG9uZ19yZWFkKCZkYXRhLT5kb25lX2hlYWQpKSkgewoJCS8qCgkJICogU2luY2Ugd2UgaGFkIGl0IGxvY2tlZCwgd2UgY2FuIGxvY2sgaXQgYWdhaW4uCgkJICovCgkJd2hpbGUgKGF0b21pY19jbXB4Y2hnKCZkYXRhLT5sb2NrLCAtMSwgY3B1KSAhPSAtMSkKCQkJY3B1X3JlbGF4KCk7CgoJCWdvdG8gYWdhaW47Cgl9CgoJaWYgKGF0b21pY194Y2hnKCZkYXRhLT53YWtldXAsIDApKQoJCXBlcmZfb3V0cHV0X3dha2V1cChoYW5kbGUpOwpvdXQ6CglwdXRfY3B1KCk7Cn0KCnZvaWQgcGVyZl9vdXRwdXRfY29weShzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCgkJICAgICAgY29uc3Qgdm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuKQp7Cgl1bnNpZ25lZCBpbnQgcGFnZXNfbWFzazsKCXVuc2lnbmVkIGxvbmcgb2Zmc2V0OwoJdW5zaWduZWQgaW50IHNpemU7Cgl2b2lkICoqcGFnZXM7CgoJb2Zmc2V0CQk9IGhhbmRsZS0+b2Zmc2V0OwoJcGFnZXNfbWFzawk9IGhhbmRsZS0+ZGF0YS0+bnJfcGFnZXMgLSAxOwoJcGFnZXMJCT0gaGFuZGxlLT5kYXRhLT5kYXRhX3BhZ2VzOwoKCWRvIHsKCQl1bnNpZ25lZCBsb25nIHBhZ2Vfb2Zmc2V0OwoJCXVuc2lnbmVkIGxvbmcgcGFnZV9zaXplOwoJCWludCBucjsKCgkJbnIJICAgID0gKG9mZnNldCA+PiBQQUdFX1NISUZUKSAmIHBhZ2VzX21hc2s7CgkJcGFnZV9zaXplICAgPSAxVUwgPDwgKGhhbmRsZS0+ZGF0YS0+ZGF0YV9vcmRlciArIFBBR0VfU0hJRlQpOwoJCXBhZ2Vfb2Zmc2V0ID0gb2Zmc2V0ICYgKHBhZ2Vfc2l6ZSAtIDEpOwoJCXNpemUJICAgID0gbWluX3QodW5zaWduZWQgaW50LCBwYWdlX3NpemUgLSBwYWdlX29mZnNldCwgbGVuKTsKCgkJbWVtY3B5KHBhZ2VzW25yXSArIHBhZ2Vfb2Zmc2V0LCBidWYsIHNpemUpOwoKCQlsZW4JICAgIC09IHNpemU7CgkJYnVmCSAgICArPSBzaXplOwoJCW9mZnNldAkgICAgKz0gc2l6ZTsKCX0gd2hpbGUgKGxlbik7CgoJaGFuZGxlLT5vZmZzZXQgPSBvZmZzZXQ7CgoJLyoKCSAqIENoZWNrIHdlIGRpZG4ndCBjb3B5IHBhc3Qgb3VyIHJlc2VydmF0aW9uIHdpbmRvdywgdGFraW5nIHRoZQoJICogcG9zc2libGUgdW5zaWduZWQgaW50IHdyYXAgaW50byBhY2NvdW50LgoJICovCglXQVJOX09OX09OQ0UoKChsb25nKShoYW5kbGUtPmhlYWQgLSBoYW5kbGUtPm9mZnNldCkpIDwgMCk7Cn0KCmludCBwZXJmX291dHB1dF9iZWdpbihzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCgkJICAgICAgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCB1bnNpZ25lZCBpbnQgc2l6ZSwKCQkgICAgICBpbnQgbm1pLCBpbnQgc2FtcGxlKQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqb3V0cHV0X2V2ZW50OwoJc3RydWN0IHBlcmZfbW1hcF9kYXRhICpkYXRhOwoJdW5zaWduZWQgbG9uZyB0YWlsLCBvZmZzZXQsIGhlYWQ7CglpbnQgaGF2ZV9sb3N0OwoJc3RydWN0IHsKCQlzdHJ1Y3QgcGVyZl9ldmVudF9oZWFkZXIgaGVhZGVyOwoJCXU2NAkJCSBpZDsKCQl1NjQJCQkgbG9zdDsKCX0gbG9zdF9ldmVudDsKCglyY3VfcmVhZF9sb2NrKCk7CgkvKgoJICogRm9yIGluaGVyaXRlZCBldmVudHMgd2Ugc2VuZCBhbGwgdGhlIG91dHB1dCB0b3dhcmRzIHRoZSBwYXJlbnQuCgkgKi8KCWlmIChldmVudC0+cGFyZW50KQoJCWV2ZW50ID0gZXZlbnQtPnBhcmVudDsKCglvdXRwdXRfZXZlbnQgPSByY3VfZGVyZWZlcmVuY2UoZXZlbnQtPm91dHB1dCk7CglpZiAob3V0cHV0X2V2ZW50KQoJCWV2ZW50ID0gb3V0cHV0X2V2ZW50OwoKCWRhdGEgPSByY3VfZGVyZWZlcmVuY2UoZXZlbnQtPmRhdGEpOwoJaWYgKCFkYXRhKQoJCWdvdG8gb3V0OwoKCWhhbmRsZS0+ZGF0YQk9IGRhdGE7CgloYW5kbGUtPmV2ZW50CT0gZXZlbnQ7CgloYW5kbGUtPm5taQk9IG5taTsKCWhhbmRsZS0+c2FtcGxlCT0gc2FtcGxlOwoKCWlmICghZGF0YS0+bnJfcGFnZXMpCgkJZ290byBmYWlsOwoKCWhhdmVfbG9zdCA9IGF0b21pY19yZWFkKCZkYXRhLT5sb3N0KTsKCWlmIChoYXZlX2xvc3QpCgkJc2l6ZSArPSBzaXplb2YobG9zdF9ldmVudCk7CgoJcGVyZl9vdXRwdXRfbG9jayhoYW5kbGUpOwoKCWRvIHsKCQkvKgoJCSAqIFVzZXJzcGFjZSBjb3VsZCBjaG9vc2UgdG8gaXNzdWUgYSBtYigpIGJlZm9yZSB1cGRhdGluZyB0aGUKCQkgKiB0YWlsIHBvaW50ZXIuIFNvIHRoYXQgYWxsIHJlYWRzIHdpbGwgYmUgY29tcGxldGVkIGJlZm9yZSB0aGUKCQkgKiB3cml0ZSBpcyBpc3N1ZWQuCgkJICovCgkJdGFpbCA9IEFDQ0VTU19PTkNFKGRhdGEtPnVzZXJfcGFnZS0+ZGF0YV90YWlsKTsKCQlzbXBfcm1iKCk7CgkJb2Zmc2V0ID0gaGVhZCA9IGF0b21pY19sb25nX3JlYWQoJmRhdGEtPmhlYWQpOwoJCWhlYWQgKz0gc2l6ZTsKCQlpZiAodW5saWtlbHkoIXBlcmZfb3V0cHV0X3NwYWNlKGRhdGEsIHRhaWwsIG9mZnNldCwgaGVhZCkpKQoJCQlnb3RvIGZhaWw7Cgl9IHdoaWxlIChhdG9taWNfbG9uZ19jbXB4Y2hnKCZkYXRhLT5oZWFkLCBvZmZzZXQsIGhlYWQpICE9IG9mZnNldCk7CgoJaGFuZGxlLT5vZmZzZXQJPSBvZmZzZXQ7CgloYW5kbGUtPmhlYWQJPSBoZWFkOwoKCWlmIChoZWFkIC0gdGFpbCA+IGRhdGEtPndhdGVybWFyaykKCQlhdG9taWNfc2V0KCZkYXRhLT53YWtldXAsIDEpOwoKCWlmIChoYXZlX2xvc3QpIHsKCQlsb3N0X2V2ZW50LmhlYWRlci50eXBlID0gUEVSRl9SRUNPUkRfTE9TVDsKCQlsb3N0X2V2ZW50LmhlYWRlci5taXNjID0gMDsKCQlsb3N0X2V2ZW50LmhlYWRlci5zaXplID0gc2l6ZW9mKGxvc3RfZXZlbnQpOwoJCWxvc3RfZXZlbnQuaWQgICAgICAgICAgPSBldmVudC0+aWQ7CgkJbG9zdF9ldmVudC5sb3N0ICAgICAgICA9IGF0b21pY194Y2hnKCZkYXRhLT5sb3N0LCAwKTsKCgkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgbG9zdF9ldmVudCk7Cgl9CgoJcmV0dXJuIDA7CgpmYWlsOgoJYXRvbWljX2luYygmZGF0YS0+bG9zdCk7CglwZXJmX291dHB1dF91bmxvY2soaGFuZGxlKTsKb3V0OgoJcmN1X3JlYWRfdW5sb2NrKCk7CgoJcmV0dXJuIC1FTk9TUEM7Cn0KCnZvaWQgcGVyZl9vdXRwdXRfZW5kKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50ID0gaGFuZGxlLT5ldmVudDsKCXN0cnVjdCBwZXJmX21tYXBfZGF0YSAqZGF0YSA9IGhhbmRsZS0+ZGF0YTsKCglpbnQgd2FrZXVwX2V2ZW50cyA9IGV2ZW50LT5hdHRyLndha2V1cF9ldmVudHM7CgoJaWYgKGhhbmRsZS0+c2FtcGxlICYmIHdha2V1cF9ldmVudHMpIHsKCQlpbnQgZXZlbnRzID0gYXRvbWljX2luY19yZXR1cm4oJmRhdGEtPmV2ZW50cyk7CgkJaWYgKGV2ZW50cyA+PSB3YWtldXBfZXZlbnRzKSB7CgkJCWF0b21pY19zdWIod2FrZXVwX2V2ZW50cywgJmRhdGEtPmV2ZW50cyk7CgkJCWF0b21pY19zZXQoJmRhdGEtPndha2V1cCwgMSk7CgkJfQoJfQoKCXBlcmZfb3V0cHV0X3VubG9jayhoYW5kbGUpOwoJcmN1X3JlYWRfdW5sb2NrKCk7Cn0KCnN0YXRpYyB1MzIgcGVyZl9ldmVudF9waWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnApCnsKCS8qCgkgKiBvbmx5IHRvcCBsZXZlbCBldmVudHMgaGF2ZSB0aGUgcGlkIG5hbWVzcGFjZSB0aGV5IHdlcmUgY3JlYXRlZCBpbgoJICovCglpZiAoZXZlbnQtPnBhcmVudCkKCQlldmVudCA9IGV2ZW50LT5wYXJlbnQ7CgoJcmV0dXJuIHRhc2tfdGdpZF9ucl9ucyhwLCBldmVudC0+bnMpOwp9CgpzdGF0aWMgdTMyIHBlcmZfZXZlbnRfdGlkKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgc3RydWN0IHRhc2tfc3RydWN0ICpwKQp7CgkvKgoJICogb25seSB0b3AgbGV2ZWwgZXZlbnRzIGhhdmUgdGhlIHBpZCBuYW1lc3BhY2UgdGhleSB3ZXJlIGNyZWF0ZWQgaW4KCSAqLwoJaWYgKGV2ZW50LT5wYXJlbnQpCgkJZXZlbnQgPSBldmVudC0+cGFyZW50OwoKCXJldHVybiB0YXNrX3BpZF9ucl9ucyhwLCBldmVudC0+bnMpOwp9CgpzdGF0aWMgdm9pZCBwZXJmX291dHB1dF9yZWFkX29uZShzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCgkJCQkgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7Cgl1NjQgcmVhZF9mb3JtYXQgPSBldmVudC0+YXR0ci5yZWFkX2Zvcm1hdDsKCXU2NCB2YWx1ZXNbNF07CglpbnQgbiA9IDA7CgoJdmFsdWVzW24rK10gPSBhdG9taWM2NF9yZWFkKCZldmVudC0+Y291bnQpOwoJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVEKSB7CgkJdmFsdWVzW24rK10gPSBldmVudC0+dG90YWxfdGltZV9lbmFibGVkICsKCQkJYXRvbWljNjRfcmVhZCgmZXZlbnQtPmNoaWxkX3RvdGFsX3RpbWVfZW5hYmxlZCk7Cgl9CglpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9UT1RBTF9USU1FX1JVTk5JTkcpIHsKCQl2YWx1ZXNbbisrXSA9IGV2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcgKwoJCQlhdG9taWM2NF9yZWFkKCZldmVudC0+Y2hpbGRfdG90YWxfdGltZV9ydW5uaW5nKTsKCX0KCWlmIChyZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0lEKQoJCXZhbHVlc1tuKytdID0gcHJpbWFyeV9ldmVudF9pZChldmVudCk7CgoJcGVyZl9vdXRwdXRfY29weShoYW5kbGUsIHZhbHVlcywgbiAqIHNpemVvZih1NjQpKTsKfQoKLyoKICogWFhYIFBFUkZfRk9STUFUX0dST1VQIHZzIGluaGVyaXRlZCBldmVudHMgc2VlbXMgZGlmZmljdWx0LgogKi8Kc3RhdGljIHZvaWQgcGVyZl9vdXRwdXRfcmVhZF9ncm91cChzdHJ1Y3QgcGVyZl9vdXRwdXRfaGFuZGxlICpoYW5kbGUsCgkJCSAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpsZWFkZXIgPSBldmVudC0+Z3JvdXBfbGVhZGVyLCAqc3ViOwoJdTY0IHJlYWRfZm9ybWF0ID0gZXZlbnQtPmF0dHIucmVhZF9mb3JtYXQ7Cgl1NjQgdmFsdWVzWzVdOwoJaW50IG4gPSAwOwoKCXZhbHVlc1tuKytdID0gMSArIGxlYWRlci0+bnJfc2libGluZ3M7CgoJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9FTkFCTEVEKQoJCXZhbHVlc1tuKytdID0gbGVhZGVyLT50b3RhbF90aW1lX2VuYWJsZWQ7CgoJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfVE9UQUxfVElNRV9SVU5OSU5HKQoJCXZhbHVlc1tuKytdID0gbGVhZGVyLT50b3RhbF90aW1lX3J1bm5pbmc7CgoJaWYgKGxlYWRlciAhPSBldmVudCkKCQlsZWFkZXItPnBtdS0+cmVhZChsZWFkZXIpOwoKCXZhbHVlc1tuKytdID0gYXRvbWljNjRfcmVhZCgmbGVhZGVyLT5jb3VudCk7CglpZiAocmVhZF9mb3JtYXQgJiBQRVJGX0ZPUk1BVF9JRCkKCQl2YWx1ZXNbbisrXSA9IHByaW1hcnlfZXZlbnRfaWQobGVhZGVyKTsKCglwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgdmFsdWVzLCBuICogc2l6ZW9mKHU2NCkpOwoKCWxpc3RfZm9yX2VhY2hfZW50cnkoc3ViLCAmbGVhZGVyLT5zaWJsaW5nX2xpc3QsIGdyb3VwX2VudHJ5KSB7CgkJbiA9IDA7CgoJCWlmIChzdWIgIT0gZXZlbnQpCgkJCXN1Yi0+cG11LT5yZWFkKHN1Yik7CgoJCXZhbHVlc1tuKytdID0gYXRvbWljNjRfcmVhZCgmc3ViLT5jb3VudCk7CgkJaWYgKHJlYWRfZm9ybWF0ICYgUEVSRl9GT1JNQVRfSUQpCgkJCXZhbHVlc1tuKytdID0gcHJpbWFyeV9ldmVudF9pZChzdWIpOwoKCQlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgdmFsdWVzLCBuICogc2l6ZW9mKHU2NCkpOwoJfQp9CgpzdGF0aWMgdm9pZCBwZXJmX291dHB1dF9yZWFkKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSwKCQkJICAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCWlmIChldmVudC0+YXR0ci5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0dST1VQKQoJCXBlcmZfb3V0cHV0X3JlYWRfZ3JvdXAoaGFuZGxlLCBldmVudCk7CgllbHNlCgkJcGVyZl9vdXRwdXRfcmVhZF9vbmUoaGFuZGxlLCBldmVudCk7Cn0KCnZvaWQgcGVyZl9vdXRwdXRfc2FtcGxlKHN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgKmhhbmRsZSwKCQkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyICpoZWFkZXIsCgkJCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAoJCQlzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXU2NCBzYW1wbGVfdHlwZSA9IGRhdGEtPnR5cGU7CgoJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgKmhlYWRlcik7CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfSVApCgkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+aXApOwoKCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJRCkKCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT50aWRfZW50cnkpOwoKCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1RJTUUpCgkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+dGltZSk7CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQUREUikKCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5hZGRyKTsKCglpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9JRCkKCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBkYXRhLT5pZCk7CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfU1RSRUFNX0lEKQoJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPnN0cmVhbV9pZCk7CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ1BVKQoJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPmNwdV9lbnRyeSk7CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUEVSSU9EKQoJCXBlcmZfb3V0cHV0X3B1dChoYW5kbGUsIGRhdGEtPnBlcmlvZCk7CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkVBRCkKCQlwZXJmX291dHB1dF9yZWFkKGhhbmRsZSwgZXZlbnQpOwoKCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0NBTExDSEFJTikgewoJCWlmIChkYXRhLT5jYWxsY2hhaW4pIHsKCQkJaW50IHNpemUgPSAxOwoKCQkJaWYgKGRhdGEtPmNhbGxjaGFpbikKCQkJCXNpemUgKz0gZGF0YS0+Y2FsbGNoYWluLT5ucjsKCgkJCXNpemUgKj0gc2l6ZW9mKHU2NCk7CgoJCQlwZXJmX291dHB1dF9jb3B5KGhhbmRsZSwgZGF0YS0+Y2FsbGNoYWluLCBzaXplKTsKCQl9IGVsc2UgewoJCQl1NjQgbnIgPSAwOwoJCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCBucik7CgkJfQoJfQoKCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JBVykgewoJCWlmIChkYXRhLT5yYXcpIHsKCQkJcGVyZl9vdXRwdXRfcHV0KGhhbmRsZSwgZGF0YS0+cmF3LT5zaXplKTsKCQkJcGVyZl9vdXRwdXRfY29weShoYW5kbGUsIGRhdGEtPnJhdy0+ZGF0YSwKCQkJCQkgZGF0YS0+cmF3LT5zaXplKTsKCQl9IGVsc2UgewoJCQlzdHJ1Y3QgewoJCQkJdTMyCXNpemU7CgkJCQl1MzIJZGF0YTsKCQkJfSByYXcgPSB7CgkJCQkuc2l6ZSA9IHNpemVvZih1MzIpLAoJCQkJLmRhdGEgPSAwLAoJCQl9OwoJCQlwZXJmX291dHB1dF9wdXQoaGFuZGxlLCByYXcpOwoJCX0KCX0KfQoKdm9pZCBwZXJmX3ByZXBhcmVfc2FtcGxlKHN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlciAqaGVhZGVyLAoJCQkgc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEsCgkJCSBzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCgkJCSBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJdTY0IHNhbXBsZV90eXBlID0gZXZlbnQtPmF0dHIuc2FtcGxlX3R5cGU7CgoJZGF0YS0+dHlwZSA9IHNhbXBsZV90eXBlOwoKCWhlYWRlci0+dHlwZSA9IFBFUkZfUkVDT1JEX1NBTVBMRTsKCWhlYWRlci0+c2l6ZSA9IHNpemVvZigqaGVhZGVyKTsKCgloZWFkZXItPm1pc2MgPSAwOwoJaGVhZGVyLT5taXNjIHw9IHBlcmZfbWlzY19mbGFncyhyZWdzKTsKCglpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9JUCkgewoJCWRhdGEtPmlwID0gcGVyZl9pbnN0cnVjdGlvbl9wb2ludGVyKHJlZ3MpOwoKCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPmlwKTsKCX0KCglpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9USUQpIHsKCQkvKiBuYW1lc3BhY2UgaXNzdWVzICovCgkJZGF0YS0+dGlkX2VudHJ5LnBpZCA9IHBlcmZfZXZlbnRfcGlkKGV2ZW50LCBjdXJyZW50KTsKCQlkYXRhLT50aWRfZW50cnkudGlkID0gcGVyZl9ldmVudF90aWQoZXZlbnQsIGN1cnJlbnQpOwoKCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPnRpZF9lbnRyeSk7Cgl9CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfVElNRSkgewoJCWRhdGEtPnRpbWUgPSBwZXJmX2Nsb2NrKCk7CgoJCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+dGltZSk7Cgl9CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQUREUikKCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPmFkZHIpOwoKCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX0lEKSB7CgkJZGF0YS0+aWQgPSBwcmltYXJ5X2V2ZW50X2lkKGV2ZW50KTsKCgkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT5pZCk7Cgl9CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfU1RSRUFNX0lEKSB7CgkJZGF0YS0+c3RyZWFtX2lkID0gZXZlbnQtPmlkOwoKCQloZWFkZXItPnNpemUgKz0gc2l6ZW9mKGRhdGEtPnN0cmVhbV9pZCk7Cgl9CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfQ1BVKSB7CgkJZGF0YS0+Y3B1X2VudHJ5LmNwdQkJPSByYXdfc21wX3Byb2Nlc3Nvcl9pZCgpOwoJCWRhdGEtPmNwdV9lbnRyeS5yZXNlcnZlZAk9IDA7CgoJCWhlYWRlci0+c2l6ZSArPSBzaXplb2YoZGF0YS0+Y3B1X2VudHJ5KTsKCX0KCglpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9QRVJJT0QpCgkJaGVhZGVyLT5zaXplICs9IHNpemVvZihkYXRhLT5wZXJpb2QpOwoKCWlmIChzYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JFQUQpCgkJaGVhZGVyLT5zaXplICs9IHBlcmZfZXZlbnRfcmVhZF9zaXplKGV2ZW50KTsKCglpZiAoc2FtcGxlX3R5cGUgJiBQRVJGX1NBTVBMRV9DQUxMQ0hBSU4pIHsKCQlpbnQgc2l6ZSA9IDE7CgoJCWRhdGEtPmNhbGxjaGFpbiA9IHBlcmZfY2FsbGNoYWluKHJlZ3MpOwoKCQlpZiAoZGF0YS0+Y2FsbGNoYWluKQoJCQlzaXplICs9IGRhdGEtPmNhbGxjaGFpbi0+bnI7CgoJCWhlYWRlci0+c2l6ZSArPSBzaXplICogc2l6ZW9mKHU2NCk7Cgl9CgoJaWYgKHNhbXBsZV90eXBlICYgUEVSRl9TQU1QTEVfUkFXKSB7CgkJaW50IHNpemUgPSBzaXplb2YodTMyKTsKCgkJaWYgKGRhdGEtPnJhdykKCQkJc2l6ZSArPSBkYXRhLT5yYXctPnNpemU7CgkJZWxzZQoJCQlzaXplICs9IHNpemVvZih1MzIpOwoKCQlXQVJOX09OX09OQ0Uoc2l6ZSAmIChzaXplb2YodTY0KS0xKSk7CgkJaGVhZGVyLT5zaXplICs9IHNpemU7Cgl9Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfb3V0cHV0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IG5taSwKCQkJCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhLAoJCQkJc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCnsKCXN0cnVjdCBwZXJmX291dHB1dF9oYW5kbGUgaGFuZGxlOwoJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyIGhlYWRlcjsKCglwZXJmX3ByZXBhcmVfc2FtcGxlKCZoZWFkZXIsIGRhdGEsIGV2ZW50LCByZWdzKTsKCglpZiAocGVyZl9vdXRwdXRfYmVnaW4oJmhhbmRsZSwgZXZlbnQsIGhlYWRlci5zaXplLCBubWksIDEpKQoJCXJldHVybjsKCglwZXJmX291dHB1dF9zYW1wbGUoJmhhbmRsZSwgJmhlYWRlciwgZGF0YSwgZXZlbnQpOwoKCXBlcmZfb3V0cHV0X2VuZCgmaGFuZGxlKTsKfQoKLyoKICogcmVhZCBldmVudF9pZAogKi8KCnN0cnVjdCBwZXJmX3JlYWRfZXZlbnQgewoJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKCgl1MzIJCQkJcGlkOwoJdTMyCQkJCXRpZDsKfTsKCnN0YXRpYyB2b2lkCnBlcmZfZXZlbnRfcmVhZF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsCgkJCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKewoJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CglzdHJ1Y3QgcGVyZl9yZWFkX2V2ZW50IHJlYWRfZXZlbnQgPSB7CgkJLmhlYWRlciA9IHsKCQkJLnR5cGUgPSBQRVJGX1JFQ09SRF9SRUFELAoJCQkubWlzYyA9IDAsCgkJCS5zaXplID0gc2l6ZW9mKHJlYWRfZXZlbnQpICsgcGVyZl9ldmVudF9yZWFkX3NpemUoZXZlbnQpLAoJCX0sCgkJLnBpZCA9IHBlcmZfZXZlbnRfcGlkKGV2ZW50LCB0YXNrKSwKCQkudGlkID0gcGVyZl9ldmVudF90aWQoZXZlbnQsIHRhc2spLAoJfTsKCWludCByZXQ7CgoJcmV0ID0gcGVyZl9vdXRwdXRfYmVnaW4oJmhhbmRsZSwgZXZlbnQsIHJlYWRfZXZlbnQuaGVhZGVyLnNpemUsIDAsIDApOwoJaWYgKHJldCkKCQlyZXR1cm47CgoJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIHJlYWRfZXZlbnQpOwoJcGVyZl9vdXRwdXRfcmVhZCgmaGFuZGxlLCBldmVudCk7CgoJcGVyZl9vdXRwdXRfZW5kKCZoYW5kbGUpOwp9CgovKgogKiB0YXNrIHRyYWNraW5nIC0tIGZvcmsvZXhpdAogKgogKiBlbmFibGVkIGJ5OiBhdHRyLmNvbW0gfCBhdHRyLm1tYXAgfCBhdHRyLnRhc2sKICovCgpzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50IHsKCXN0cnVjdCB0YXNrX3N0cnVjdAkJKnRhc2s7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0CSp0YXNrX2N0eDsKCglzdHJ1Y3QgewoJCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CgoJCXUzMgkJCQlwaWQ7CgkJdTMyCQkJCXBwaWQ7CgkJdTMyCQkJCXRpZDsKCQl1MzIJCQkJcHRpZDsKCQl1NjQJCQkJdGltZTsKCX0gZXZlbnRfaWQ7Cn07CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X3Rhc2tfb3V0cHV0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCSAgICAgc3RydWN0IHBlcmZfdGFza19ldmVudCAqdGFza19ldmVudCkKewoJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CglpbnQgc2l6ZTsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayA9IHRhc2tfZXZlbnQtPnRhc2s7CglpbnQgcmV0OwoKCXNpemUgID0gdGFza19ldmVudC0+ZXZlbnRfaWQuaGVhZGVyLnNpemU7CglyZXQgPSBwZXJmX291dHB1dF9iZWdpbigmaGFuZGxlLCBldmVudCwgc2l6ZSwgMCwgMCk7CgoJaWYgKHJldCkKCQlyZXR1cm47CgoJdGFza19ldmVudC0+ZXZlbnRfaWQucGlkID0gcGVyZl9ldmVudF9waWQoZXZlbnQsIHRhc2spOwoJdGFza19ldmVudC0+ZXZlbnRfaWQucHBpZCA9IHBlcmZfZXZlbnRfcGlkKGV2ZW50LCBjdXJyZW50KTsKCgl0YXNrX2V2ZW50LT5ldmVudF9pZC50aWQgPSBwZXJmX2V2ZW50X3RpZChldmVudCwgdGFzayk7Cgl0YXNrX2V2ZW50LT5ldmVudF9pZC5wdGlkID0gcGVyZl9ldmVudF90aWQoZXZlbnQsIGN1cnJlbnQpOwoKCXRhc2tfZXZlbnQtPmV2ZW50X2lkLnRpbWUgPSBwZXJmX2Nsb2NrKCk7CgoJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIHRhc2tfZXZlbnQtPmV2ZW50X2lkKTsKCglwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cn0KCnN0YXRpYyBpbnQgcGVyZl9ldmVudF90YXNrX21hdGNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJaWYgKGV2ZW50LT5hdHRyLmNvbW0gfHwgZXZlbnQtPmF0dHIubW1hcCB8fCBldmVudC0+YXR0ci50YXNrKQoJCXJldHVybiAxOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X3Rhc2tfY3R4KHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKCQkJCSAgc3RydWN0IHBlcmZfdGFza19ldmVudCAqdGFza19ldmVudCkKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50OwoKCWxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KGV2ZW50LCAmY3R4LT5ldmVudF9saXN0LCBldmVudF9lbnRyeSkgewoJCWlmIChwZXJmX2V2ZW50X3Rhc2tfbWF0Y2goZXZlbnQpKQoJCQlwZXJmX2V2ZW50X3Rhc2tfb3V0cHV0KGV2ZW50LCB0YXNrX2V2ZW50KTsKCX0KfQoKc3RhdGljIHZvaWQgcGVyZl9ldmVudF90YXNrX2V2ZW50KHN0cnVjdCBwZXJmX3Rhc2tfZXZlbnQgKnRhc2tfZXZlbnQpCnsKCXN0cnVjdCBwZXJmX2NwdV9jb250ZXh0ICpjcHVjdHg7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHggPSB0YXNrX2V2ZW50LT50YXNrX2N0eDsKCglyY3VfcmVhZF9sb2NrKCk7CgljcHVjdHggPSAmZ2V0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CglwZXJmX2V2ZW50X3Rhc2tfY3R4KCZjcHVjdHgtPmN0eCwgdGFza19ldmVudCk7CglwdXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKCglpZiAoIWN0eCkKCQljdHggPSByY3VfZGVyZWZlcmVuY2UodGFza19ldmVudC0+dGFzay0+cGVyZl9ldmVudF9jdHhwKTsKCWlmIChjdHgpCgkJcGVyZl9ldmVudF90YXNrX2N0eChjdHgsIHRhc2tfZXZlbnQpOwoJcmN1X3JlYWRfdW5sb2NrKCk7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2ssCgkJCSAgICAgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnRhc2tfY3R4LAoJCQkgICAgICBpbnQgbmV3KQp7CglzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50IHRhc2tfZXZlbnQ7CgoJaWYgKCFhdG9taWNfcmVhZCgmbnJfY29tbV9ldmVudHMpICYmCgkgICAgIWF0b21pY19yZWFkKCZucl9tbWFwX2V2ZW50cykgJiYKCSAgICAhYXRvbWljX3JlYWQoJm5yX3Rhc2tfZXZlbnRzKSkKCQlyZXR1cm47CgoJdGFza19ldmVudCA9IChzdHJ1Y3QgcGVyZl90YXNrX2V2ZW50KXsKCQkudGFzawkgID0gdGFzaywKCQkudGFza19jdHggPSB0YXNrX2N0eCwKCQkuZXZlbnRfaWQgICAgPSB7CgkJCS5oZWFkZXIgPSB7CgkJCQkudHlwZSA9IG5ldyA/IFBFUkZfUkVDT1JEX0ZPUksgOiBQRVJGX1JFQ09SRF9FWElULAoJCQkJLm1pc2MgPSAwLAoJCQkJLnNpemUgPSBzaXplb2YodGFza19ldmVudC5ldmVudF9pZCksCgkJCX0sCgkJCS8qIC5waWQgICovCgkJCS8qIC5wcGlkICovCgkJCS8qIC50aWQgICovCgkJCS8qIC5wdGlkICovCgkJfSwKCX07CgoJcGVyZl9ldmVudF90YXNrX2V2ZW50KCZ0YXNrX2V2ZW50KTsKfQoKdm9pZCBwZXJmX2V2ZW50X2Zvcmsoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQp7CglwZXJmX2V2ZW50X3Rhc2sodGFzaywgTlVMTCwgMSk7Cn0KCi8qCiAqIGNvbW0gdHJhY2tpbmcKICovCgpzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50IHsKCXN0cnVjdCB0YXNrX3N0cnVjdAkqdGFzazsKCWNoYXIJCQkqY29tbTsKCWludAkJCWNvbW1fc2l6ZTsKCglzdHJ1Y3QgewoJCXN0cnVjdCBwZXJmX2V2ZW50X2hlYWRlcgloZWFkZXI7CgoJCXUzMgkJCQlwaWQ7CgkJdTMyCQkJCXRpZDsKCX0gZXZlbnRfaWQ7Cn07CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2NvbW1fb3V0cHV0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCSAgICAgc3RydWN0IHBlcmZfY29tbV9ldmVudCAqY29tbV9ldmVudCkKewoJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CglpbnQgc2l6ZSA9IGNvbW1fZXZlbnQtPmV2ZW50X2lkLmhlYWRlci5zaXplOwoJaW50IHJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGV2ZW50LCBzaXplLCAwLCAwKTsKCglpZiAocmV0KQoJCXJldHVybjsKCgljb21tX2V2ZW50LT5ldmVudF9pZC5waWQgPSBwZXJmX2V2ZW50X3BpZChldmVudCwgY29tbV9ldmVudC0+dGFzayk7Cgljb21tX2V2ZW50LT5ldmVudF9pZC50aWQgPSBwZXJmX2V2ZW50X3RpZChldmVudCwgY29tbV9ldmVudC0+dGFzayk7CgoJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIGNvbW1fZXZlbnQtPmV2ZW50X2lkKTsKCXBlcmZfb3V0cHV0X2NvcHkoJmhhbmRsZSwgY29tbV9ldmVudC0+Y29tbSwKCQkJCSAgIGNvbW1fZXZlbnQtPmNvbW1fc2l6ZSk7CglwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cn0KCnN0YXRpYyBpbnQgcGVyZl9ldmVudF9jb21tX21hdGNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJaWYgKGV2ZW50LT5hdHRyLmNvbW0pCgkJcmV0dXJuIDE7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfY29tbV9jdHgoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAoJCQkJICBzdHJ1Y3QgcGVyZl9jb21tX2V2ZW50ICpjb21tX2V2ZW50KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoZXZlbnQsICZjdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7CgkJaWYgKHBlcmZfZXZlbnRfY29tbV9tYXRjaChldmVudCkpCgkJCXBlcmZfZXZlbnRfY29tbV9vdXRwdXQoZXZlbnQsIGNvbW1fZXZlbnQpOwoJfQp9CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X2NvbW1fZXZlbnQoc3RydWN0IHBlcmZfY29tbV9ldmVudCAqY29tbV9ldmVudCkKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCXVuc2lnbmVkIGludCBzaXplOwoJY2hhciBjb21tW1RBU0tfQ09NTV9MRU5dOwoKCW1lbXNldChjb21tLCAwLCBzaXplb2YoY29tbSkpOwoJc3RybmNweShjb21tLCBjb21tX2V2ZW50LT50YXNrLT5jb21tLCBzaXplb2YoY29tbSkpOwoJc2l6ZSA9IEFMSUdOKHN0cmxlbihjb21tKSsxLCBzaXplb2YodTY0KSk7CgoJY29tbV9ldmVudC0+Y29tbSA9IGNvbW07Cgljb21tX2V2ZW50LT5jb21tX3NpemUgPSBzaXplOwoKCWNvbW1fZXZlbnQtPmV2ZW50X2lkLmhlYWRlci5zaXplID0gc2l6ZW9mKGNvbW1fZXZlbnQtPmV2ZW50X2lkKSArIHNpemU7CgoJcmN1X3JlYWRfbG9jaygpOwoJY3B1Y3R4ID0gJmdldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwoJcGVyZl9ldmVudF9jb21tX2N0eCgmY3B1Y3R4LT5jdHgsIGNvbW1fZXZlbnQpOwoJcHV0X2NwdV92YXIocGVyZl9jcHVfY29udGV4dCk7CgoJLyoKCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCgkgKiBldmVudHMgZW5kcyB1cCBpbi4KCSAqLwoJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfZXZlbnRfY3R4cCk7CglpZiAoY3R4KQoJCXBlcmZfZXZlbnRfY29tbV9jdHgoY3R4LCBjb21tX2V2ZW50KTsKCXJjdV9yZWFkX3VubG9jaygpOwp9Cgp2b2lkIHBlcmZfZXZlbnRfY29tbShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCnsKCXN0cnVjdCBwZXJmX2NvbW1fZXZlbnQgY29tbV9ldmVudDsKCglpZiAodGFzay0+cGVyZl9ldmVudF9jdHhwKQoJCXBlcmZfZXZlbnRfZW5hYmxlX29uX2V4ZWModGFzayk7CgoJaWYgKCFhdG9taWNfcmVhZCgmbnJfY29tbV9ldmVudHMpKQoJCXJldHVybjsKCgljb21tX2V2ZW50ID0gKHN0cnVjdCBwZXJmX2NvbW1fZXZlbnQpewoJCS50YXNrCT0gdGFzaywKCQkvKiAuY29tbSAgICAgICovCgkJLyogLmNvbW1fc2l6ZSAqLwoJCS5ldmVudF9pZCAgPSB7CgkJCS5oZWFkZXIgPSB7CgkJCQkudHlwZSA9IFBFUkZfUkVDT1JEX0NPTU0sCgkJCQkubWlzYyA9IDAsCgkJCQkvKiAuc2l6ZSAqLwoJCQl9LAoJCQkvKiAucGlkICovCgkJCS8qIC50aWQgKi8KCQl9LAoJfTsKCglwZXJmX2V2ZW50X2NvbW1fZXZlbnQoJmNvbW1fZXZlbnQpOwp9CgovKgogKiBtbWFwIHRyYWNraW5nCiAqLwoKc3RydWN0IHBlcmZfbW1hcF9ldmVudCB7CglzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QJKnZtYTsKCgljb25zdCBjaGFyCQkqZmlsZV9uYW1lOwoJaW50CQkJZmlsZV9zaXplOwoKCXN0cnVjdCB7CgkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKCgkJdTMyCQkJCXBpZDsKCQl1MzIJCQkJdGlkOwoJCXU2NAkJCQlzdGFydDsKCQl1NjQJCQkJbGVuOwoJCXU2NAkJCQlwZ29mZjsKCX0gZXZlbnRfaWQ7Cn07CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X21tYXBfb3V0cHV0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCSAgICAgc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKewoJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CglpbnQgc2l6ZSA9IG1tYXBfZXZlbnQtPmV2ZW50X2lkLmhlYWRlci5zaXplOwoJaW50IHJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGV2ZW50LCBzaXplLCAwLCAwKTsKCglpZiAocmV0KQoJCXJldHVybjsKCgltbWFwX2V2ZW50LT5ldmVudF9pZC5waWQgPSBwZXJmX2V2ZW50X3BpZChldmVudCwgY3VycmVudCk7CgltbWFwX2V2ZW50LT5ldmVudF9pZC50aWQgPSBwZXJmX2V2ZW50X3RpZChldmVudCwgY3VycmVudCk7CgoJcGVyZl9vdXRwdXRfcHV0KCZoYW5kbGUsIG1tYXBfZXZlbnQtPmV2ZW50X2lkKTsKCXBlcmZfb3V0cHV0X2NvcHkoJmhhbmRsZSwgbW1hcF9ldmVudC0+ZmlsZV9uYW1lLAoJCQkJICAgbW1hcF9ldmVudC0+ZmlsZV9zaXplKTsKCXBlcmZfb3V0cHV0X2VuZCgmaGFuZGxlKTsKfQoKc3RhdGljIGludCBwZXJmX2V2ZW50X21tYXBfbWF0Y2goc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkJICAgc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKewoJaWYgKGV2ZW50LT5hdHRyLm1tYXApCgkJcmV0dXJuIDE7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfbW1hcF9jdHgoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4LAoJCQkJICBzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50ICptbWFwX2V2ZW50KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CgoJbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UoZXZlbnQsICZjdHgtPmV2ZW50X2xpc3QsIGV2ZW50X2VudHJ5KSB7CgkJaWYgKHBlcmZfZXZlbnRfbW1hcF9tYXRjaChldmVudCwgbW1hcF9ldmVudCkpCgkJCXBlcmZfZXZlbnRfbW1hcF9vdXRwdXQoZXZlbnQsIG1tYXBfZXZlbnQpOwoJfQp9CgpzdGF0aWMgdm9pZCBwZXJmX2V2ZW50X21tYXBfZXZlbnQoc3RydWN0IHBlcmZfbW1hcF9ldmVudCAqbW1hcF9ldmVudCkKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hID0gbW1hcF9ldmVudC0+dm1hOwoJc3RydWN0IGZpbGUgKmZpbGUgPSB2bWEtPnZtX2ZpbGU7Cgl1bnNpZ25lZCBpbnQgc2l6ZTsKCWNoYXIgdG1wWzE2XTsKCWNoYXIgKmJ1ZiA9IE5VTEw7Cgljb25zdCBjaGFyICpuYW1lOwoKCW1lbXNldCh0bXAsIDAsIHNpemVvZih0bXApKTsKCglpZiAoZmlsZSkgewoJCS8qCgkJICogZF9wYXRoIHdvcmtzIGZyb20gdGhlIGVuZCBvZiB0aGUgYnVmZmVyIGJhY2t3YXJkcywgc28gd2UKCQkgKiBuZWVkIHRvIGFkZCBlbm91Z2ggemVybyBieXRlcyBhZnRlciB0aGUgc3RyaW5nIHRvIGhhbmRsZQoJCSAqIHRoZSA2NGJpdCBhbGlnbm1lbnQgd2UgZG8gbGF0ZXIuCgkJICovCgkJYnVmID0ga3phbGxvYyhQQVRIX01BWCArIHNpemVvZih1NjQpLCBHRlBfS0VSTkVMKTsKCQlpZiAoIWJ1ZikgewoJCQluYW1lID0gc3RybmNweSh0bXAsICIvL2Vub21lbSIsIHNpemVvZih0bXApKTsKCQkJZ290byBnb3RfbmFtZTsKCQl9CgkJbmFtZSA9IGRfcGF0aCgmZmlsZS0+Zl9wYXRoLCBidWYsIFBBVEhfTUFYKTsKCQlpZiAoSVNfRVJSKG5hbWUpKSB7CgkJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vdG9vbG9uZyIsIHNpemVvZih0bXApKTsKCQkJZ290byBnb3RfbmFtZTsKCQl9Cgl9IGVsc2UgewoJCWlmIChhcmNoX3ZtYV9uYW1lKG1tYXBfZXZlbnQtPnZtYSkpIHsKCQkJbmFtZSA9IHN0cm5jcHkodG1wLCBhcmNoX3ZtYV9uYW1lKG1tYXBfZXZlbnQtPnZtYSksCgkJCQkgICAgICAgc2l6ZW9mKHRtcCkpOwoJCQlnb3RvIGdvdF9uYW1lOwoJCX0KCgkJaWYgKCF2bWEtPnZtX21tKSB7CgkJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIlt2ZHNvXSIsIHNpemVvZih0bXApKTsKCQkJZ290byBnb3RfbmFtZTsKCQl9CgoJCW5hbWUgPSBzdHJuY3B5KHRtcCwgIi8vYW5vbiIsIHNpemVvZih0bXApKTsKCQlnb3RvIGdvdF9uYW1lOwoJfQoKZ290X25hbWU6CglzaXplID0gQUxJR04oc3RybGVuKG5hbWUpKzEsIHNpemVvZih1NjQpKTsKCgltbWFwX2V2ZW50LT5maWxlX25hbWUgPSBuYW1lOwoJbW1hcF9ldmVudC0+ZmlsZV9zaXplID0gc2l6ZTsKCgltbWFwX2V2ZW50LT5ldmVudF9pZC5oZWFkZXIuc2l6ZSA9IHNpemVvZihtbWFwX2V2ZW50LT5ldmVudF9pZCkgKyBzaXplOwoKCXJjdV9yZWFkX2xvY2soKTsKCWNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKCXBlcmZfZXZlbnRfbW1hcF9jdHgoJmNwdWN0eC0+Y3R4LCBtbWFwX2V2ZW50KTsKCXB1dF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwoKCS8qCgkgKiBkb2Vzbid0IHJlYWxseSBtYXR0ZXIgd2hpY2ggb2YgdGhlIGNoaWxkIGNvbnRleHRzIHRoZQoJICogZXZlbnRzIGVuZHMgdXAgaW4uCgkgKi8KCWN0eCA9IHJjdV9kZXJlZmVyZW5jZShjdXJyZW50LT5wZXJmX2V2ZW50X2N0eHApOwoJaWYgKGN0eCkKCQlwZXJmX2V2ZW50X21tYXBfY3R4KGN0eCwgbW1hcF9ldmVudCk7CglyY3VfcmVhZF91bmxvY2soKTsKCglrZnJlZShidWYpOwp9Cgp2b2lkIF9fcGVyZl9ldmVudF9tbWFwKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQp7CglzdHJ1Y3QgcGVyZl9tbWFwX2V2ZW50IG1tYXBfZXZlbnQ7CgoJaWYgKCFhdG9taWNfcmVhZCgmbnJfbW1hcF9ldmVudHMpKQoJCXJldHVybjsKCgltbWFwX2V2ZW50ID0gKHN0cnVjdCBwZXJmX21tYXBfZXZlbnQpewoJCS52bWEJPSB2bWEsCgkJLyogLmZpbGVfbmFtZSAqLwoJCS8qIC5maWxlX3NpemUgKi8KCQkuZXZlbnRfaWQgID0gewoJCQkuaGVhZGVyID0gewoJCQkJLnR5cGUgPSBQRVJGX1JFQ09SRF9NTUFQLAoJCQkJLm1pc2MgPSAwLAoJCQkJLyogLnNpemUgKi8KCQkJfSwKCQkJLyogLnBpZCAqLwoJCQkvKiAudGlkICovCgkJCS5zdGFydCAgPSB2bWEtPnZtX3N0YXJ0LAoJCQkubGVuICAgID0gdm1hLT52bV9lbmQgLSB2bWEtPnZtX3N0YXJ0LAoJCQkucGdvZmYgID0gdm1hLT52bV9wZ29mZiwKCQl9LAoJfTsKCglwZXJmX2V2ZW50X21tYXBfZXZlbnQoJm1tYXBfZXZlbnQpOwp9CgovKgogKiBJUlEgdGhyb3R0bGUgbG9nZ2luZwogKi8KCnN0YXRpYyB2b2lkIHBlcmZfbG9nX3Rocm90dGxlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IGVuYWJsZSkKewoJc3RydWN0IHBlcmZfb3V0cHV0X2hhbmRsZSBoYW5kbGU7CglpbnQgcmV0OwoKCXN0cnVjdCB7CgkJc3RydWN0IHBlcmZfZXZlbnRfaGVhZGVyCWhlYWRlcjsKCQl1NjQJCQkJdGltZTsKCQl1NjQJCQkJaWQ7CgkJdTY0CQkJCXN0cmVhbV9pZDsKCX0gdGhyb3R0bGVfZXZlbnQgPSB7CgkJLmhlYWRlciA9IHsKCQkJLnR5cGUgPSBQRVJGX1JFQ09SRF9USFJPVFRMRSwKCQkJLm1pc2MgPSAwLAoJCQkuc2l6ZSA9IHNpemVvZih0aHJvdHRsZV9ldmVudCksCgkJfSwKCQkudGltZQkJPSBwZXJmX2Nsb2NrKCksCgkJLmlkCQk9IHByaW1hcnlfZXZlbnRfaWQoZXZlbnQpLAoJCS5zdHJlYW1faWQJPSBldmVudC0+aWQsCgl9OwoKCWlmIChlbmFibGUpCgkJdGhyb3R0bGVfZXZlbnQuaGVhZGVyLnR5cGUgPSBQRVJGX1JFQ09SRF9VTlRIUk9UVExFOwoKCXJldCA9IHBlcmZfb3V0cHV0X2JlZ2luKCZoYW5kbGUsIGV2ZW50LCBzaXplb2YodGhyb3R0bGVfZXZlbnQpLCAxLCAwKTsKCWlmIChyZXQpCgkJcmV0dXJuOwoKCXBlcmZfb3V0cHV0X3B1dCgmaGFuZGxlLCB0aHJvdHRsZV9ldmVudCk7CglwZXJmX291dHB1dF9lbmQoJmhhbmRsZSk7Cn0KCi8qCiAqIEdlbmVyaWMgZXZlbnQgb3ZlcmZsb3cgaGFuZGxpbmcsIHNhbXBsaW5nLgogKi8KCnN0YXRpYyBpbnQgX19wZXJmX2V2ZW50X292ZXJmbG93KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IG5taSwKCQkJCSAgIGludCB0aHJvdHRsZSwgc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEsCgkJCQkgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJaW50IGV2ZW50cyA9IGF0b21pY19yZWFkKCZldmVudC0+ZXZlbnRfbGltaXQpOwoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CglpbnQgcmV0ID0gMDsKCgl0aHJvdHRsZSA9ICh0aHJvdHRsZSAmJiBldmVudC0+cG11LT51bnRocm90dGxlICE9IE5VTEwpOwoKCWlmICghdGhyb3R0bGUpIHsKCQlod2MtPmludGVycnVwdHMrKzsKCX0gZWxzZSB7CgkJaWYgKGh3Yy0+aW50ZXJydXB0cyAhPSBNQVhfSU5URVJSVVBUUykgewoJCQlod2MtPmludGVycnVwdHMrKzsKCQkJaWYgKEhaICogaHdjLT5pbnRlcnJ1cHRzID4KCQkJCQkodTY0KXN5c2N0bF9wZXJmX2V2ZW50X3NhbXBsZV9yYXRlKSB7CgkJCQlod2MtPmludGVycnVwdHMgPSBNQVhfSU5URVJSVVBUUzsKCQkJCXBlcmZfbG9nX3Rocm90dGxlKGV2ZW50LCAwKTsKCQkJCXJldCA9IDE7CgkJCX0KCQl9IGVsc2UgewoJCQkvKgoJCQkgKiBLZWVwIHJlLWRpc2FibGluZyBldmVudHMgZXZlbiB0aG91Z2ggb24gdGhlIHByZXZpb3VzCgkJCSAqIHBhc3Mgd2UgZGlzYWJsZWQgaXQgLSBqdXN0IGluIGNhc2Ugd2UgcmFjZWQgd2l0aCBhCgkJCSAqIHNjaGVkLWluIGFuZCB0aGUgZXZlbnQgZ290IGVuYWJsZWQgYWdhaW46CgkJCSAqLwoJCQlyZXQgPSAxOwoJCX0KCX0KCglpZiAoZXZlbnQtPmF0dHIuZnJlcSkgewoJCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7CgkJczY0IGRlbHRhID0gbm93IC0gaHdjLT5mcmVxX3N0YW1wOwoKCQlod2MtPmZyZXFfc3RhbXAgPSBub3c7CgoJCWlmIChkZWx0YSA+IDAgJiYgZGVsdGEgPCBUSUNLX05TRUMpCgkJCXBlcmZfYWRqdXN0X3BlcmlvZChldmVudCwgTlNFQ19QRVJfU0VDIC8gKGludClkZWx0YSk7Cgl9CgoJLyoKCSAqIFhYWCBldmVudF9saW1pdCBtaWdodCBub3QgcXVpdGUgd29yayBhcyBleHBlY3RlZCBvbiBpbmhlcml0ZWQKCSAqIGV2ZW50cwoJICovCgoJZXZlbnQtPnBlbmRpbmdfa2lsbCA9IFBPTExfSU47CglpZiAoZXZlbnRzICYmIGF0b21pY19kZWNfYW5kX3Rlc3QoJmV2ZW50LT5ldmVudF9saW1pdCkpIHsKCQlyZXQgPSAxOwoJCWV2ZW50LT5wZW5kaW5nX2tpbGwgPSBQT0xMX0hVUDsKCQlpZiAobm1pKSB7CgkJCWV2ZW50LT5wZW5kaW5nX2Rpc2FibGUgPSAxOwoJCQlwZXJmX3BlbmRpbmdfcXVldWUoJmV2ZW50LT5wZW5kaW5nLAoJCQkJCSAgIHBlcmZfcGVuZGluZ19ldmVudCk7CgkJfSBlbHNlCgkJCXBlcmZfZXZlbnRfZGlzYWJsZShldmVudCk7Cgl9CgoJaWYgKGV2ZW50LT5vdmVyZmxvd19oYW5kbGVyKQoJCWV2ZW50LT5vdmVyZmxvd19oYW5kbGVyKGV2ZW50LCBubWksIGRhdGEsIHJlZ3MpOwoJZWxzZQoJCXBlcmZfZXZlbnRfb3V0cHV0KGV2ZW50LCBubWksIGRhdGEsIHJlZ3MpOwoKCXJldHVybiByZXQ7Cn0KCmludCBwZXJmX2V2ZW50X292ZXJmbG93KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgaW50IG5taSwKCQkJICBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKCQkJICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJcmV0dXJuIF9fcGVyZl9ldmVudF9vdmVyZmxvdyhldmVudCwgbm1pLCAxLCBkYXRhLCByZWdzKTsKfQoKLyoKICogR2VuZXJpYyBzb2Z0d2FyZSBldmVudCBpbmZyYXN0cnVjdHVyZQogKi8KCi8qCiAqIFdlIGRpcmVjdGx5IGluY3JlbWVudCBldmVudC0+Y291bnQgYW5kIGtlZXAgYSBzZWNvbmQgdmFsdWUgaW4KICogZXZlbnQtPmh3LnBlcmlvZF9sZWZ0IHRvIGNvdW50IGludGVydmFscy4gVGhpcyBwZXJpb2QgZXZlbnQKICogaXMga2VwdCBpbiB0aGUgcmFuZ2UgWy1zYW1wbGVfcGVyaW9kLCAwXSBzbyB0aGF0IHdlIGNhbiB1c2UgdGhlCiAqIHNpZ24gYXMgdHJpZ2dlci4KICovCgpzdGF0aWMgdTY0IHBlcmZfc3dldmVudF9zZXRfcGVyaW9kKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7Cgl1NjQgcGVyaW9kID0gaHdjLT5sYXN0X3BlcmlvZDsKCXU2NCBuciwgb2Zmc2V0OwoJczY0IG9sZCwgdmFsOwoKCWh3Yy0+bGFzdF9wZXJpb2QgPSBod2MtPnNhbXBsZV9wZXJpb2Q7CgphZ2FpbjoKCW9sZCA9IHZhbCA9IGF0b21pYzY0X3JlYWQoJmh3Yy0+cGVyaW9kX2xlZnQpOwoJaWYgKHZhbCA8IDApCgkJcmV0dXJuIDA7CgoJbnIgPSBkaXY2NF91NjQocGVyaW9kICsgdmFsLCBwZXJpb2QpOwoJb2Zmc2V0ID0gbnIgKiBwZXJpb2Q7Cgl2YWwgLT0gb2Zmc2V0OwoJaWYgKGF0b21pYzY0X2NtcHhjaGcoJmh3Yy0+cGVyaW9kX2xlZnQsIG9sZCwgdmFsKSAhPSBvbGQpCgkJZ290byBhZ2FpbjsKCglyZXR1cm4gbnI7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfc3dldmVudF9vdmVyZmxvdyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIHU2NCBvdmVyZmxvdywKCQkJCSAgICBpbnQgbm1pLCBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKCQkJCSAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CglpbnQgdGhyb3R0bGUgPSAwOwoKCWRhdGEtPnBlcmlvZCA9IGV2ZW50LT5ody5sYXN0X3BlcmlvZDsKCWlmICghb3ZlcmZsb3cpCgkJb3ZlcmZsb3cgPSBwZXJmX3N3ZXZlbnRfc2V0X3BlcmlvZChldmVudCk7CgoJaWYgKGh3Yy0+aW50ZXJydXB0cyA9PSBNQVhfSU5URVJSVVBUUykKCQlyZXR1cm47CgoJZm9yICg7IG92ZXJmbG93OyBvdmVyZmxvdy0tKSB7CgkJaWYgKF9fcGVyZl9ldmVudF9vdmVyZmxvdyhldmVudCwgbm1pLCB0aHJvdHRsZSwKCQkJCQkgICAgZGF0YSwgcmVncykpIHsKCQkJLyoKCQkJICogV2UgaW5oaWJpdCB0aGUgb3ZlcmZsb3cgZnJvbSBoYXBwZW5pbmcgd2hlbgoJCQkgKiBod2MtPmludGVycnVwdHMgPT0gTUFYX0lOVEVSUlVQVFMuCgkJCSAqLwoJCQlicmVhazsKCQl9CgkJdGhyb3R0bGUgPSAxOwoJfQp9CgpzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfdW50aHJvdHRsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCS8qCgkgKiBOb3RoaW5nIHRvIGRvLCB3ZSBhbHJlYWR5IHJlc2V0IGh3Yy0+aW50ZXJydXB0cy4KCSAqLwp9CgpzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfYWRkKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0IG5yLAoJCQkgICAgICAgaW50IG5taSwgc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEsCgkJCSAgICAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CgoJYXRvbWljNjRfYWRkKG5yLCAmZXZlbnQtPmNvdW50KTsKCglpZiAoIXJlZ3MpCgkJcmV0dXJuOwoKCWlmICghaHdjLT5zYW1wbGVfcGVyaW9kKQoJCXJldHVybjsKCglpZiAobnIgPT0gMSAmJiBod2MtPnNhbXBsZV9wZXJpb2QgPT0gMSAmJiAhZXZlbnQtPmF0dHIuZnJlcSkKCQlyZXR1cm4gcGVyZl9zd2V2ZW50X292ZXJmbG93KGV2ZW50LCAxLCBubWksIGRhdGEsIHJlZ3MpOwoKCWlmIChhdG9taWM2NF9hZGRfbmVnYXRpdmUobnIsICZod2MtPnBlcmlvZF9sZWZ0KSkKCQlyZXR1cm47CgoJcGVyZl9zd2V2ZW50X292ZXJmbG93KGV2ZW50LCAwLCBubWksIGRhdGEsIHJlZ3MpOwp9CgpzdGF0aWMgaW50IHBlcmZfc3dldmVudF9pc19jb3VudGluZyhzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCS8qCgkgKiBUaGUgZXZlbnQgaXMgYWN0aXZlLCB3ZSdyZSBnb29kIQoJICovCglpZiAoZXZlbnQtPnN0YXRlID09IFBFUkZfRVZFTlRfU1RBVEVfQUNUSVZFKQoJCXJldHVybiAxOwoKCS8qCgkgKiBUaGUgZXZlbnQgaXMgb2ZmL2Vycm9yLCBub3QgY291bnRpbmcuCgkgKi8KCWlmIChldmVudC0+c3RhdGUgIT0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKCQlyZXR1cm4gMDsKCgkvKgoJICogVGhlIGV2ZW50IGlzIGluYWN0aXZlLCBpZiB0aGUgY29udGV4dCBpcyBhY3RpdmUKCSAqIHdlJ3JlIHBhcnQgb2YgYSBncm91cCB0aGF0IGRpZG4ndCBtYWtlIGl0IG9uIHRoZSAncG11JywKCSAqIG5vdCBjb3VudGluZy4KCSAqLwoJaWYgKGV2ZW50LT5jdHgtPmlzX2FjdGl2ZSkKCQlyZXR1cm4gMDsKCgkvKgoJICogV2UncmUgaW5hY3RpdmUgYW5kIHRoZSBjb250ZXh0IGlzIHRvbywgdGhpcyBtZWFucyB0aGUKCSAqIHRhc2sgaXMgc2NoZWR1bGVkIG91dCwgd2UncmUgY291bnRpbmcgZXZlbnRzIHRoYXQgaGFwcGVuCgkgKiB0byB1cywgbGlrZSBtaWdyYXRpb24gZXZlbnRzLgoJICovCglyZXR1cm4gMTsKfQoKc3RhdGljIGludCBwZXJmX3RwX2V2ZW50X21hdGNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhICpkYXRhKTsKCnN0YXRpYyBpbnQgcGVyZl9zd2V2ZW50X21hdGNoKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwKCQkJCWVudW0gcGVyZl90eXBlX2lkIHR5cGUsCgkJCQl1MzIgZXZlbnRfaWQsCgkJCQlzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKCQkJCXN0cnVjdCBwdF9yZWdzICpyZWdzKQp7CglpZiAoIXBlcmZfc3dldmVudF9pc19jb3VudGluZyhldmVudCkpCgkJcmV0dXJuIDA7CgoJaWYgKGV2ZW50LT5hdHRyLnR5cGUgIT0gdHlwZSkKCQlyZXR1cm4gMDsKCWlmIChldmVudC0+YXR0ci5jb25maWcgIT0gZXZlbnRfaWQpCgkJcmV0dXJuIDA7CgoJaWYgKHJlZ3MpIHsKCQlpZiAoZXZlbnQtPmF0dHIuZXhjbHVkZV91c2VyICYmIHVzZXJfbW9kZShyZWdzKSkKCQkJcmV0dXJuIDA7CgoJCWlmIChldmVudC0+YXR0ci5leGNsdWRlX2tlcm5lbCAmJiAhdXNlcl9tb2RlKHJlZ3MpKQoJCQlyZXR1cm4gMDsKCX0KCglpZiAoZXZlbnQtPmF0dHIudHlwZSA9PSBQRVJGX1RZUEVfVFJBQ0VQT0lOVCAmJgoJICAgICFwZXJmX3RwX2V2ZW50X21hdGNoKGV2ZW50LCBkYXRhKSkKCQlyZXR1cm4gMDsKCglyZXR1cm4gMTsKfQoKc3RhdGljIHZvaWQgcGVyZl9zd2V2ZW50X2N0eF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHgsCgkJCQkgICAgIGVudW0gcGVyZl90eXBlX2lkIHR5cGUsCgkJCQkgICAgIHUzMiBldmVudF9pZCwgdTY0IG5yLCBpbnQgbm1pLAoJCQkJICAgICBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKCQkJCSAgICAgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCglsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShldmVudCwgJmN0eC0+ZXZlbnRfbGlzdCwgZXZlbnRfZW50cnkpIHsKCQlpZiAocGVyZl9zd2V2ZW50X21hdGNoKGV2ZW50LCB0eXBlLCBldmVudF9pZCwgZGF0YSwgcmVncykpCgkJCXBlcmZfc3dldmVudF9hZGQoZXZlbnQsIG5yLCBubWksIGRhdGEsIHJlZ3MpOwoJfQp9CgpzdGF0aWMgaW50ICpwZXJmX3N3ZXZlbnRfcmVjdXJzaW9uX2NvbnRleHQoc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCkKewoJaWYgKGluX25taSgpKQoJCXJldHVybiAmY3B1Y3R4LT5yZWN1cnNpb25bM107CgoJaWYgKGluX2lycSgpKQoJCXJldHVybiAmY3B1Y3R4LT5yZWN1cnNpb25bMl07CgoJaWYgKGluX3NvZnRpcnEoKSkKCQlyZXR1cm4gJmNwdWN0eC0+cmVjdXJzaW9uWzFdOwoKCXJldHVybiAmY3B1Y3R4LT5yZWN1cnNpb25bMF07Cn0KCnN0YXRpYyB2b2lkIGRvX3BlcmZfc3dfZXZlbnQoZW51bSBwZXJmX3R5cGVfaWQgdHlwZSwgdTMyIGV2ZW50X2lkLAoJCQkJICAgIHU2NCBuciwgaW50IG5taSwKCQkJCSAgICBzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSAqZGF0YSwKCQkJCSAgICBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZnZXRfY3B1X3ZhcihwZXJmX2NwdV9jb250ZXh0KTsKCWludCAqcmVjdXJzaW9uID0gcGVyZl9zd2V2ZW50X3JlY3Vyc2lvbl9jb250ZXh0KGNwdWN0eCk7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjdHg7CgoJaWYgKCpyZWN1cnNpb24pCgkJZ290byBvdXQ7CgoJKCpyZWN1cnNpb24pKys7CgliYXJyaWVyKCk7CgoJcmN1X3JlYWRfbG9jaygpOwoJcGVyZl9zd2V2ZW50X2N0eF9ldmVudCgmY3B1Y3R4LT5jdHgsIHR5cGUsIGV2ZW50X2lkLAoJCQkJIG5yLCBubWksIGRhdGEsIHJlZ3MpOwoJLyoKCSAqIGRvZXNuJ3QgcmVhbGx5IG1hdHRlciB3aGljaCBvZiB0aGUgY2hpbGQgY29udGV4dHMgdGhlCgkgKiBldmVudHMgZW5kcyB1cCBpbi4KCSAqLwoJY3R4ID0gcmN1X2RlcmVmZXJlbmNlKGN1cnJlbnQtPnBlcmZfZXZlbnRfY3R4cCk7CglpZiAoY3R4KQoJCXBlcmZfc3dldmVudF9jdHhfZXZlbnQoY3R4LCB0eXBlLCBldmVudF9pZCwgbnIsIG5taSwgZGF0YSwgcmVncyk7CglyY3VfcmVhZF91bmxvY2soKTsKCgliYXJyaWVyKCk7CgkoKnJlY3Vyc2lvbiktLTsKCm91dDoKCXB1dF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwp9Cgp2b2lkIF9fcGVyZl9zd19ldmVudCh1MzIgZXZlbnRfaWQsIHU2NCBuciwgaW50IG5taSwKCQkJICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzLCB1NjQgYWRkcikKewoJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgZGF0YSA9IHsKCQkuYWRkciA9IGFkZHIsCgl9OwoKCWRvX3BlcmZfc3dfZXZlbnQoUEVSRl9UWVBFX1NPRlRXQVJFLCBldmVudF9pZCwgbnIsIG5taSwKCQkJCSZkYXRhLCByZWdzKTsKfQoKc3RhdGljIHZvaWQgcGVyZl9zd2V2ZW50X3JlYWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7Cn0KCnN0YXRpYyBpbnQgcGVyZl9zd2V2ZW50X2VuYWJsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3OwoKCWlmIChod2MtPnNhbXBsZV9wZXJpb2QpIHsKCQlod2MtPmxhc3RfcGVyaW9kID0gaHdjLT5zYW1wbGVfcGVyaW9kOwoJCXBlcmZfc3dldmVudF9zZXRfcGVyaW9kKGV2ZW50KTsKCX0KCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfZGlzYWJsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKfQoKc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgcGVyZl9vcHNfZ2VuZXJpYyA9IHsKCS5lbmFibGUJCT0gcGVyZl9zd2V2ZW50X2VuYWJsZSwKCS5kaXNhYmxlCT0gcGVyZl9zd2V2ZW50X2Rpc2FibGUsCgkucmVhZAkJPSBwZXJmX3N3ZXZlbnRfcmVhZCwKCS51bnRocm90dGxlCT0gcGVyZl9zd2V2ZW50X3VudGhyb3R0bGUsCn07CgovKgogKiBocnRpbWVyIGJhc2VkIHN3ZXZlbnQgY2FsbGJhY2sKICovCgpzdGF0aWMgZW51bSBocnRpbWVyX3Jlc3RhcnQgcGVyZl9zd2V2ZW50X2hydGltZXIoc3RydWN0IGhydGltZXIgKmhydGltZXIpCnsKCWVudW0gaHJ0aW1lcl9yZXN0YXJ0IHJldCA9IEhSVElNRVJfUkVTVEFSVDsKCXN0cnVjdCBwZXJmX3NhbXBsZV9kYXRhIGRhdGE7CglzdHJ1Y3QgcHRfcmVncyAqcmVnczsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCXU2NCBwZXJpb2Q7CgoJZXZlbnQJPSBjb250YWluZXJfb2YoaHJ0aW1lciwgc3RydWN0IHBlcmZfZXZlbnQsIGh3LmhydGltZXIpOwoJZXZlbnQtPnBtdS0+cmVhZChldmVudCk7CgoJZGF0YS5hZGRyID0gMDsKCXJlZ3MgPSBnZXRfaXJxX3JlZ3MoKTsKCS8qCgkgKiBJbiBjYXNlIHdlIGV4Y2x1ZGUga2VybmVsIElQcyBvciBhcmUgc29tZWhvdyBub3QgaW4gaW50ZXJydXB0CgkgKiBjb250ZXh0LCBwcm92aWRlIHRoZSBuZXh0IGJlc3QgdGhpbmcsIHRoZSB1c2VyIElQLgoJICovCglpZiAoKGV2ZW50LT5hdHRyLmV4Y2x1ZGVfa2VybmVsIHx8ICFyZWdzKSAmJgoJCQkhZXZlbnQtPmF0dHIuZXhjbHVkZV91c2VyKQoJCXJlZ3MgPSB0YXNrX3B0X3JlZ3MoY3VycmVudCk7CgoJaWYgKHJlZ3MpIHsKCQlpZiAoIShldmVudC0+YXR0ci5leGNsdWRlX2lkbGUgJiYgY3VycmVudC0+cGlkID09IDApKQoJCQlpZiAocGVyZl9ldmVudF9vdmVyZmxvdyhldmVudCwgMCwgJmRhdGEsIHJlZ3MpKQoJCQkJcmV0ID0gSFJUSU1FUl9OT1JFU1RBUlQ7Cgl9CgoJcGVyaW9kID0gbWF4X3QodTY0LCAxMDAwMCwgZXZlbnQtPmh3LnNhbXBsZV9wZXJpb2QpOwoJaHJ0aW1lcl9mb3J3YXJkX25vdyhocnRpbWVyLCBuc190b19rdGltZShwZXJpb2QpKTsKCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgdm9pZCBwZXJmX3N3ZXZlbnRfc3RhcnRfaHJ0aW1lcihzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3OwoKCWhydGltZXJfaW5pdCgmaHdjLT5ocnRpbWVyLCBDTE9DS19NT05PVE9OSUMsIEhSVElNRVJfTU9ERV9SRUwpOwoJaHdjLT5ocnRpbWVyLmZ1bmN0aW9uID0gcGVyZl9zd2V2ZW50X2hydGltZXI7CglpZiAoaHdjLT5zYW1wbGVfcGVyaW9kKSB7CgkJdTY0IHBlcmlvZDsKCgkJaWYgKGh3Yy0+cmVtYWluaW5nKSB7CgkJCWlmIChod2MtPnJlbWFpbmluZyA8IDApCgkJCQlwZXJpb2QgPSAxMDAwMDsKCQkJZWxzZQoJCQkJcGVyaW9kID0gaHdjLT5yZW1haW5pbmc7CgkJCWh3Yy0+cmVtYWluaW5nID0gMDsKCQl9IGVsc2UgewoJCQlwZXJpb2QgPSBtYXhfdCh1NjQsIDEwMDAwLCBod2MtPnNhbXBsZV9wZXJpb2QpOwoJCX0KCQlfX2hydGltZXJfc3RhcnRfcmFuZ2VfbnMoJmh3Yy0+aHJ0aW1lciwKCQkJCW5zX3RvX2t0aW1lKHBlcmlvZCksIDAsCgkJCQlIUlRJTUVSX01PREVfUkVMLCAwKTsKCX0KfQoKc3RhdGljIHZvaWQgcGVyZl9zd2V2ZW50X2NhbmNlbF9ocnRpbWVyKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7CgoJaWYgKGh3Yy0+c2FtcGxlX3BlcmlvZCkgewoJCWt0aW1lX3QgcmVtYWluaW5nID0gaHJ0aW1lcl9nZXRfcmVtYWluaW5nKCZod2MtPmhydGltZXIpOwoJCWh3Yy0+cmVtYWluaW5nID0ga3RpbWVfdG9fbnMocmVtYWluaW5nKTsKCgkJaHJ0aW1lcl9jYW5jZWwoJmh3Yy0+aHJ0aW1lcik7Cgl9Cn0KCi8qCiAqIFNvZnR3YXJlIGV2ZW50OiBjcHUgd2FsbCB0aW1lIGNsb2NrCiAqLwoKc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJaW50IGNwdSA9IHJhd19zbXBfcHJvY2Vzc29yX2lkKCk7CglzNjQgcHJldjsKCXU2NCBub3c7CgoJbm93ID0gY3B1X2Nsb2NrKGNwdSk7CglwcmV2ID0gYXRvbWljNjRfcmVhZCgmZXZlbnQtPmh3LnByZXZfY291bnQpOwoJYXRvbWljNjRfc2V0KCZldmVudC0+aHcucHJldl9jb3VudCwgbm93KTsKCWF0b21pYzY0X2FkZChub3cgLSBwcmV2LCAmZXZlbnQtPmNvdW50KTsKfQoKc3RhdGljIGludCBjcHVfY2xvY2tfcGVyZl9ldmVudF9lbmFibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglzdHJ1Y3QgaHdfcGVyZl9ldmVudCAqaHdjID0gJmV2ZW50LT5odzsKCWludCBjcHUgPSByYXdfc21wX3Byb2Nlc3Nvcl9pZCgpOwoKCWF0b21pYzY0X3NldCgmaHdjLT5wcmV2X2NvdW50LCBjcHVfY2xvY2soY3B1KSk7CglwZXJmX3N3ZXZlbnRfc3RhcnRfaHJ0aW1lcihldmVudCk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkIGNwdV9jbG9ja19wZXJmX2V2ZW50X2Rpc2FibGUoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglwZXJmX3N3ZXZlbnRfY2FuY2VsX2hydGltZXIoZXZlbnQpOwoJY3B1X2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKGV2ZW50KTsKfQoKc3RhdGljIHZvaWQgY3B1X2Nsb2NrX3BlcmZfZXZlbnRfcmVhZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCWNwdV9jbG9ja19wZXJmX2V2ZW50X3VwZGF0ZShldmVudCk7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBlcmZfb3BzX2NwdV9jbG9jayA9IHsKCS5lbmFibGUJCT0gY3B1X2Nsb2NrX3BlcmZfZXZlbnRfZW5hYmxlLAoJLmRpc2FibGUJPSBjcHVfY2xvY2tfcGVyZl9ldmVudF9kaXNhYmxlLAoJLnJlYWQJCT0gY3B1X2Nsb2NrX3BlcmZfZXZlbnRfcmVhZCwKfTsKCi8qCiAqIFNvZnR3YXJlIGV2ZW50OiB0YXNrIHRpbWUgY2xvY2sKICovCgpzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0IG5vdykKewoJdTY0IHByZXY7CglzNjQgZGVsdGE7CgoJcHJldiA9IGF0b21pYzY0X3hjaGcoJmV2ZW50LT5ody5wcmV2X2NvdW50LCBub3cpOwoJZGVsdGEgPSBub3cgLSBwcmV2OwoJYXRvbWljNjRfYWRkKGRlbHRhLCAmZXZlbnQtPmNvdW50KTsKfQoKc3RhdGljIGludCB0YXNrX2Nsb2NrX3BlcmZfZXZlbnRfZW5hYmxlKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7Cgl1NjQgbm93OwoKCW5vdyA9IGV2ZW50LT5jdHgtPnRpbWU7CgoJYXRvbWljNjRfc2V0KCZod2MtPnByZXZfY291bnQsIG5vdyk7CgoJcGVyZl9zd2V2ZW50X3N0YXJ0X2hydGltZXIoZXZlbnQpOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCB0YXNrX2Nsb2NrX3BlcmZfZXZlbnRfZGlzYWJsZShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXBlcmZfc3dldmVudF9jYW5jZWxfaHJ0aW1lcihldmVudCk7Cgl0YXNrX2Nsb2NrX3BlcmZfZXZlbnRfdXBkYXRlKGV2ZW50LCBldmVudC0+Y3R4LT50aW1lKTsKCn0KCnN0YXRpYyB2b2lkIHRhc2tfY2xvY2tfcGVyZl9ldmVudF9yZWFkKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJdTY0IHRpbWU7CgoJaWYgKCFpbl9ubWkoKSkgewoJCXVwZGF0ZV9jb250ZXh0X3RpbWUoZXZlbnQtPmN0eCk7CgkJdGltZSA9IGV2ZW50LT5jdHgtPnRpbWU7Cgl9IGVsc2UgewoJCXU2NCBub3cgPSBwZXJmX2Nsb2NrKCk7CgkJdTY0IGRlbHRhID0gbm93IC0gZXZlbnQtPmN0eC0+dGltZXN0YW1wOwoJCXRpbWUgPSBldmVudC0+Y3R4LT50aW1lICsgZGVsdGE7Cgl9CgoJdGFza19jbG9ja19wZXJmX2V2ZW50X3VwZGF0ZShldmVudCwgdGltZSk7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgcG11IHBlcmZfb3BzX3Rhc2tfY2xvY2sgPSB7CgkuZW5hYmxlCQk9IHRhc2tfY2xvY2tfcGVyZl9ldmVudF9lbmFibGUsCgkuZGlzYWJsZQk9IHRhc2tfY2xvY2tfcGVyZl9ldmVudF9kaXNhYmxlLAoJLnJlYWQJCT0gdGFza19jbG9ja19wZXJmX2V2ZW50X3JlYWQsCn07CgojaWZkZWYgQ09ORklHX0VWRU5UX1BST0ZJTEUKCnZvaWQgcGVyZl90cF9ldmVudChpbnQgZXZlbnRfaWQsIHU2NCBhZGRyLCB1NjQgY291bnQsIHZvaWQgKnJlY29yZCwKCQkJICBpbnQgZW50cnlfc2l6ZSkKewoJc3RydWN0IHBlcmZfcmF3X3JlY29yZCByYXcgPSB7CgkJLnNpemUgPSBlbnRyeV9zaXplLAoJCS5kYXRhID0gcmVjb3JkLAoJfTsKCglzdHJ1Y3QgcGVyZl9zYW1wbGVfZGF0YSBkYXRhID0gewoJCS5hZGRyID0gYWRkciwKCQkucmF3ID0gJnJhdywKCX07CgoJc3RydWN0IHB0X3JlZ3MgKnJlZ3MgPSBnZXRfaXJxX3JlZ3MoKTsKCglpZiAoIXJlZ3MpCgkJcmVncyA9IHRhc2tfcHRfcmVncyhjdXJyZW50KTsKCglkb19wZXJmX3N3X2V2ZW50KFBFUkZfVFlQRV9UUkFDRVBPSU5ULCBldmVudF9pZCwgY291bnQsIDEsCgkJCQkmZGF0YSwgcmVncyk7Cn0KRVhQT1JUX1NZTUJPTF9HUEwocGVyZl90cF9ldmVudCk7CgpzdGF0aWMgaW50IHBlcmZfdHBfZXZlbnRfbWF0Y2goc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEpCnsKCXZvaWQgKnJlY29yZCA9IGRhdGEtPnJhdy0+ZGF0YTsKCglpZiAobGlrZWx5KCFldmVudC0+ZmlsdGVyKSB8fCBmaWx0ZXJfbWF0Y2hfcHJlZHMoZXZlbnQtPmZpbHRlciwgcmVjb3JkKSkKCQlyZXR1cm4gMTsKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCB0cF9wZXJmX2V2ZW50X2Rlc3Ryb3koc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglmdHJhY2VfcHJvZmlsZV9kaXNhYmxlKGV2ZW50LT5hdHRyLmNvbmZpZyk7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgcG11ICp0cF9wZXJmX2V2ZW50X2luaXQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CgkvKgoJICogUmF3IHRyYWNlcG9pbnQgZGF0YSBpcyBhIHNldmVyZSBkYXRhIGxlYWssIG9ubHkgYWxsb3cgcm9vdCB0bwoJICogaGF2ZSB0aGVzZS4KCSAqLwoJaWYgKChldmVudC0+YXR0ci5zYW1wbGVfdHlwZSAmIFBFUkZfU0FNUExFX1JBVykgJiYKCQkJcGVyZl9wYXJhbm9pZF90cmFjZXBvaW50X3JhdygpICYmCgkJCSFjYXBhYmxlKENBUF9TWVNfQURNSU4pKQoJCXJldHVybiBFUlJfUFRSKC1FUEVSTSk7CgoJaWYgKGZ0cmFjZV9wcm9maWxlX2VuYWJsZShldmVudC0+YXR0ci5jb25maWcpKQoJCXJldHVybiBOVUxMOwoKCWV2ZW50LT5kZXN0cm95ID0gdHBfcGVyZl9ldmVudF9kZXN0cm95OwoKCXJldHVybiAmcGVyZl9vcHNfZ2VuZXJpYzsKfQoKc3RhdGljIGludCBwZXJmX2V2ZW50X3NldF9maWx0ZXIoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCB2b2lkIF9fdXNlciAqYXJnKQp7CgljaGFyICpmaWx0ZXJfc3RyOwoJaW50IHJldDsKCglpZiAoZXZlbnQtPmF0dHIudHlwZSAhPSBQRVJGX1RZUEVfVFJBQ0VQT0lOVCkKCQlyZXR1cm4gLUVJTlZBTDsKCglmaWx0ZXJfc3RyID0gc3RybmR1cF91c2VyKGFyZywgUEFHRV9TSVpFKTsKCWlmIChJU19FUlIoZmlsdGVyX3N0cikpCgkJcmV0dXJuIFBUUl9FUlIoZmlsdGVyX3N0cik7CgoJcmV0ID0gZnRyYWNlX3Byb2ZpbGVfc2V0X2ZpbHRlcihldmVudCwgZXZlbnQtPmF0dHIuY29uZmlnLCBmaWx0ZXJfc3RyKTsKCglrZnJlZShmaWx0ZXJfc3RyKTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfZnJlZV9maWx0ZXIoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7CglmdHJhY2VfcHJvZmlsZV9mcmVlX2ZpbHRlcihldmVudCk7Cn0KCiNlbHNlCgpzdGF0aWMgaW50IHBlcmZfdHBfZXZlbnRfbWF0Y2goc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LAoJCQkJc3RydWN0IHBlcmZfc2FtcGxlX2RhdGEgKmRhdGEpCnsKCXJldHVybiAxOwp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IHBtdSAqdHBfcGVyZl9ldmVudF9pbml0KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJcmV0dXJuIE5VTEw7Cn0KCnN0YXRpYyBpbnQgcGVyZl9ldmVudF9zZXRfZmlsdGVyKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdm9pZCBfX3VzZXIgKmFyZykKewoJcmV0dXJuIC1FTk9FTlQ7Cn0KCnN0YXRpYyB2b2lkIHBlcmZfZXZlbnRfZnJlZV9maWx0ZXIoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7Cn0KCiNlbmRpZiAvKiBDT05GSUdfRVZFTlRfUFJPRklMRSAqLwoKI2lmZGVmIENPTkZJR19IQVZFX0hXX0JSRUFLUE9JTlQKc3RhdGljIHZvaWQgYnBfcGVyZl9ldmVudF9kZXN0cm95KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewoJcmVsZWFzZV9icF9zbG90KGV2ZW50KTsKfQoKc3RhdGljIGNvbnN0IHN0cnVjdCBwbXUgKmJwX3BlcmZfZXZlbnRfaW5pdChzdHJ1Y3QgcGVyZl9ldmVudCAqYnApCnsKCWludCBlcnI7CgkvKgoJICogVGhlIGJyZWFrcG9pbnQgaXMgYWxyZWFkeSBmaWxsZWQgaWYgd2UgaGF2ZW4ndCBjcmVhdGVkIHRoZSBjb3VudGVyCgkgKiB0aHJvdWdoIHBlcmYgc3lzY2FsbAoJICogRklYTUU6IG1hbmFnZSB0byBnZXQgdHJpZ2VycmVkIHRvIE5VTEwgaWYgaXQgY29tZXMgZnJvbSBzeXNjYWxscwoJICovCglpZiAoIWJwLT5jYWxsYmFjaykKCQllcnIgPSByZWdpc3Rlcl9wZXJmX2h3X2JyZWFrcG9pbnQoYnApOwoJZWxzZQoJCWVyciA9IF9fcmVnaXN0ZXJfcGVyZl9od19icmVha3BvaW50KGJwKTsKCWlmIChlcnIpCgkJcmV0dXJuIEVSUl9QVFIoZXJyKTsKCglicC0+ZGVzdHJveSA9IGJwX3BlcmZfZXZlbnRfZGVzdHJveTsKCglyZXR1cm4gJnBlcmZfb3BzX2JwOwp9Cgp2b2lkIHBlcmZfYnBfZXZlbnQoc3RydWN0IHBlcmZfZXZlbnQgKmJwLCB2b2lkICpyZWdzKQp7CgkvKiBUT0RPICovCn0KI2Vsc2UKc3RhdGljIHZvaWQgYnBfcGVyZl9ldmVudF9kZXN0cm95KHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCkKewp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IHBtdSAqYnBfcGVyZl9ldmVudF9pbml0KHN0cnVjdCBwZXJmX2V2ZW50ICpicCkKewoJcmV0dXJuIE5VTEw7Cn0KCnZvaWQgcGVyZl9icF9ldmVudChzdHJ1Y3QgcGVyZl9ldmVudCAqYnAsIHZvaWQgKnJlZ3MpCnsKfQojZW5kaWYKCmF0b21pY190IHBlcmZfc3dldmVudF9lbmFibGVkW1BFUkZfQ09VTlRfU1dfTUFYXTsKCnN0YXRpYyB2b2lkIHN3X3BlcmZfZXZlbnRfZGVzdHJveShzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpCnsKCXU2NCBldmVudF9pZCA9IGV2ZW50LT5hdHRyLmNvbmZpZzsKCglXQVJOX09OKGV2ZW50LT5wYXJlbnQpOwoKCWF0b21pY19kZWMoJnBlcmZfc3dldmVudF9lbmFibGVkW2V2ZW50X2lkXSk7Cn0KCnN0YXRpYyBjb25zdCBzdHJ1Y3QgcG11ICpzd19wZXJmX2V2ZW50X2luaXQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQp7Cgljb25zdCBzdHJ1Y3QgcG11ICpwbXUgPSBOVUxMOwoJdTY0IGV2ZW50X2lkID0gZXZlbnQtPmF0dHIuY29uZmlnOwoKCS8qCgkgKiBTb2Z0d2FyZSBldmVudHMgKGN1cnJlbnRseSkgY2FuJ3QgaW4gZ2VuZXJhbCBkaXN0aW5ndWlzaAoJICogYmV0d2VlbiB1c2VyLCBrZXJuZWwgYW5kIGh5cGVydmlzb3IgZXZlbnRzLgoJICogSG93ZXZlciwgY29udGV4dCBzd2l0Y2hlcyBhbmQgY3B1IG1pZ3JhdGlvbnMgYXJlIGNvbnNpZGVyZWQKCSAqIHRvIGJlIGtlcm5lbCBldmVudHMsIGFuZCBwYWdlIGZhdWx0cyBhcmUgbmV2ZXIgaHlwZXJ2aXNvcgoJICogZXZlbnRzLgoJICovCglzd2l0Y2ggKGV2ZW50X2lkKSB7CgljYXNlIFBFUkZfQ09VTlRfU1dfQ1BVX0NMT0NLOgoJCXBtdSA9ICZwZXJmX29wc19jcHVfY2xvY2s7CgoJCWJyZWFrOwoJY2FzZSBQRVJGX0NPVU5UX1NXX1RBU0tfQ0xPQ0s6CgkJLyoKCQkgKiBJZiB0aGUgdXNlciBpbnN0YW50aWF0ZXMgdGhpcyBhcyBhIHBlci1jcHUgZXZlbnQsCgkJICogdXNlIHRoZSBjcHVfY2xvY2sgZXZlbnQgaW5zdGVhZC4KCQkgKi8KCQlpZiAoZXZlbnQtPmN0eC0+dGFzaykKCQkJcG11ID0gJnBlcmZfb3BzX3Rhc2tfY2xvY2s7CgkJZWxzZQoJCQlwbXUgPSAmcGVyZl9vcHNfY3B1X2Nsb2NrOwoKCQlicmVhazsKCWNhc2UgUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUUzoKCWNhc2UgUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUU19NSU46CgljYXNlIFBFUkZfQ09VTlRfU1dfUEFHRV9GQVVMVFNfTUFKOgoJY2FzZSBQRVJGX0NPVU5UX1NXX0NPTlRFWFRfU1dJVENIRVM6CgljYXNlIFBFUkZfQ09VTlRfU1dfQ1BVX01JR1JBVElPTlM6CgljYXNlIFBFUkZfQ09VTlRfU1dfQUxJR05NRU5UX0ZBVUxUUzoKCWNhc2UgUEVSRl9DT1VOVF9TV19FTVVMQVRJT05fRkFVTFRTOgoJCWlmICghZXZlbnQtPnBhcmVudCkgewoJCQlhdG9taWNfaW5jKCZwZXJmX3N3ZXZlbnRfZW5hYmxlZFtldmVudF9pZF0pOwoJCQlldmVudC0+ZGVzdHJveSA9IHN3X3BlcmZfZXZlbnRfZGVzdHJveTsKCQl9CgkJcG11ID0gJnBlcmZfb3BzX2dlbmVyaWM7CgkJYnJlYWs7Cgl9CgoJcmV0dXJuIHBtdTsKfQoKLyoKICogQWxsb2NhdGUgYW5kIGluaXRpYWxpemUgYSBldmVudCBzdHJ1Y3R1cmUKICovCnN0YXRpYyBzdHJ1Y3QgcGVyZl9ldmVudCAqCnBlcmZfZXZlbnRfYWxsb2Moc3RydWN0IHBlcmZfZXZlbnRfYXR0ciAqYXR0ciwKCQkgICBpbnQgY3B1LAoJCSAgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCwKCQkgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBfbGVhZGVyLAoJCSAgIHN0cnVjdCBwZXJmX2V2ZW50ICpwYXJlbnRfZXZlbnQsCgkJICAgcGVyZl9jYWxsYmFja190IGNhbGxiYWNrLAoJCSAgIGdmcF90IGdmcGZsYWdzKQp7Cgljb25zdCBzdHJ1Y3QgcG11ICpwbXU7CglzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQ7CglzdHJ1Y3QgaHdfcGVyZl9ldmVudCAqaHdjOwoJbG9uZyBlcnI7CgoJZXZlbnQgPSBremFsbG9jKHNpemVvZigqZXZlbnQpLCBnZnBmbGFncyk7CglpZiAoIWV2ZW50KQoJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwoKCS8qCgkgKiBTaW5nbGUgZXZlbnRzIGFyZSB0aGVpciBvd24gZ3JvdXAgbGVhZGVycywgd2l0aCBhbgoJICogZW1wdHkgc2libGluZyBsaXN0OgoJICovCglpZiAoIWdyb3VwX2xlYWRlcikKCQlncm91cF9sZWFkZXIgPSBldmVudDsKCgltdXRleF9pbml0KCZldmVudC0+Y2hpbGRfbXV0ZXgpOwoJSU5JVF9MSVNUX0hFQUQoJmV2ZW50LT5jaGlsZF9saXN0KTsKCglJTklUX0xJU1RfSEVBRCgmZXZlbnQtPmdyb3VwX2VudHJ5KTsKCUlOSVRfTElTVF9IRUFEKCZldmVudC0+ZXZlbnRfZW50cnkpOwoJSU5JVF9MSVNUX0hFQUQoJmV2ZW50LT5zaWJsaW5nX2xpc3QpOwoJaW5pdF93YWl0cXVldWVfaGVhZCgmZXZlbnQtPndhaXRxKTsKCgltdXRleF9pbml0KCZldmVudC0+bW1hcF9tdXRleCk7CgoJZXZlbnQtPmNwdQkJPSBjcHU7CglldmVudC0+YXR0cgkJPSAqYXR0cjsKCWV2ZW50LT5ncm91cF9sZWFkZXIJPSBncm91cF9sZWFkZXI7CglldmVudC0+cG11CQk9IE5VTEw7CglldmVudC0+Y3R4CQk9IGN0eDsKCWV2ZW50LT5vbmNwdQkJPSAtMTsKCglldmVudC0+cGFyZW50CQk9IHBhcmVudF9ldmVudDsKCglldmVudC0+bnMJCT0gZ2V0X3BpZF9ucyhjdXJyZW50LT5uc3Byb3h5LT5waWRfbnMpOwoJZXZlbnQtPmlkCQk9IGF0b21pYzY0X2luY19yZXR1cm4oJnBlcmZfZXZlbnRfaWQpOwoKCWV2ZW50LT5zdGF0ZQkJPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOwoKCWlmICghY2FsbGJhY2sgJiYgcGFyZW50X2V2ZW50KQoJCWNhbGxiYWNrID0gcGFyZW50X2V2ZW50LT5jYWxsYmFjazsKCQoJZXZlbnQtPmNhbGxiYWNrCT0gY2FsbGJhY2s7CgoJaWYgKGF0dHItPmRpc2FibGVkKQoJCWV2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGOwoKCXBtdSA9IE5VTEw7CgoJaHdjID0gJmV2ZW50LT5odzsKCWh3Yy0+c2FtcGxlX3BlcmlvZCA9IGF0dHItPnNhbXBsZV9wZXJpb2Q7CglpZiAoYXR0ci0+ZnJlcSAmJiBhdHRyLT5zYW1wbGVfZnJlcSkKCQlod2MtPnNhbXBsZV9wZXJpb2QgPSAxOwoJaHdjLT5sYXN0X3BlcmlvZCA9IGh3Yy0+c2FtcGxlX3BlcmlvZDsKCglhdG9taWM2NF9zZXQoJmh3Yy0+cGVyaW9kX2xlZnQsIGh3Yy0+c2FtcGxlX3BlcmlvZCk7CgoJLyoKCSAqIHdlIGN1cnJlbnRseSBkbyBub3Qgc3VwcG9ydCBQRVJGX0ZPUk1BVF9HUk9VUCBvbiBpbmhlcml0ZWQgZXZlbnRzCgkgKi8KCWlmIChhdHRyLT5pbmhlcml0ICYmIChhdHRyLT5yZWFkX2Zvcm1hdCAmIFBFUkZfRk9STUFUX0dST1VQKSkKCQlnb3RvIGRvbmU7CgoJc3dpdGNoIChhdHRyLT50eXBlKSB7CgljYXNlIFBFUkZfVFlQRV9SQVc6CgljYXNlIFBFUkZfVFlQRV9IQVJEV0FSRToKCWNhc2UgUEVSRl9UWVBFX0hXX0NBQ0hFOgoJCXBtdSA9IGh3X3BlcmZfZXZlbnRfaW5pdChldmVudCk7CgkJYnJlYWs7CgoJY2FzZSBQRVJGX1RZUEVfU09GVFdBUkU6CgkJcG11ID0gc3dfcGVyZl9ldmVudF9pbml0KGV2ZW50KTsKCQlicmVhazsKCgljYXNlIFBFUkZfVFlQRV9UUkFDRVBPSU5UOgoJCXBtdSA9IHRwX3BlcmZfZXZlbnRfaW5pdChldmVudCk7CgkJYnJlYWs7CgoJY2FzZSBQRVJGX1RZUEVfQlJFQUtQT0lOVDoKCQlwbXUgPSBicF9wZXJmX2V2ZW50X2luaXQoZXZlbnQpOwoJCWJyZWFrOwoKCglkZWZhdWx0OgoJCWJyZWFrOwoJfQpkb25lOgoJZXJyID0gMDsKCWlmICghcG11KQoJCWVyciA9IC1FSU5WQUw7CgllbHNlIGlmIChJU19FUlIocG11KSkKCQllcnIgPSBQVFJfRVJSKHBtdSk7CgoJaWYgKGVycikgewoJCWlmIChldmVudC0+bnMpCgkJCXB1dF9waWRfbnMoZXZlbnQtPm5zKTsKCQlrZnJlZShldmVudCk7CgkJcmV0dXJuIEVSUl9QVFIoZXJyKTsKCX0KCglldmVudC0+cG11ID0gcG11OwoKCWlmICghZXZlbnQtPnBhcmVudCkgewoJCWF0b21pY19pbmMoJm5yX2V2ZW50cyk7CgkJaWYgKGV2ZW50LT5hdHRyLm1tYXApCgkJCWF0b21pY19pbmMoJm5yX21tYXBfZXZlbnRzKTsKCQlpZiAoZXZlbnQtPmF0dHIuY29tbSkKCQkJYXRvbWljX2luYygmbnJfY29tbV9ldmVudHMpOwoJCWlmIChldmVudC0+YXR0ci50YXNrKQoJCQlhdG9taWNfaW5jKCZucl90YXNrX2V2ZW50cyk7Cgl9CgoJcmV0dXJuIGV2ZW50Owp9CgpzdGF0aWMgaW50IHBlcmZfY29weV9hdHRyKHN0cnVjdCBwZXJmX2V2ZW50X2F0dHIgX191c2VyICp1YXR0ciwKCQkJICBzdHJ1Y3QgcGVyZl9ldmVudF9hdHRyICphdHRyKQp7Cgl1MzIgc2l6ZTsKCWludCByZXQ7CgoJaWYgKCFhY2Nlc3Nfb2soVkVSSUZZX1dSSVRFLCB1YXR0ciwgUEVSRl9BVFRSX1NJWkVfVkVSMCkpCgkJcmV0dXJuIC1FRkFVTFQ7CgoJLyoKCSAqIHplcm8gdGhlIGZ1bGwgc3RydWN0dXJlLCBzbyB0aGF0IGEgc2hvcnQgY29weSB3aWxsIGJlIG5pY2UuCgkgKi8KCW1lbXNldChhdHRyLCAwLCBzaXplb2YoKmF0dHIpKTsKCglyZXQgPSBnZXRfdXNlcihzaXplLCAmdWF0dHItPnNpemUpOwoJaWYgKHJldCkKCQlyZXR1cm4gcmV0OwoKCWlmIChzaXplID4gUEFHRV9TSVpFKQkvKiBzaWxseSBsYXJnZSAqLwoJCWdvdG8gZXJyX3NpemU7CgoJaWYgKCFzaXplKQkJLyogYWJpIGNvbXBhdCAqLwoJCXNpemUgPSBQRVJGX0FUVFJfU0laRV9WRVIwOwoKCWlmIChzaXplIDwgUEVSRl9BVFRSX1NJWkVfVkVSMCkKCQlnb3RvIGVycl9zaXplOwoKCS8qCgkgKiBJZiB3ZSdyZSBoYW5kZWQgYSBiaWdnZXIgc3RydWN0IHRoYW4gd2Uga25vdyBvZiwKCSAqIGVuc3VyZSBhbGwgdGhlIHVua25vd24gYml0cyBhcmUgMCAtIGkuZS4gbmV3CgkgKiB1c2VyLXNwYWNlIGRvZXMgbm90IHJlbHkgb24gYW55IGtlcm5lbCBmZWF0dXJlCgkgKiBleHRlbnNpb25zIHdlIGRvbnQga25vdyBhYm91dCB5ZXQuCgkgKi8KCWlmIChzaXplID4gc2l6ZW9mKCphdHRyKSkgewoJCXVuc2lnbmVkIGNoYXIgX191c2VyICphZGRyOwoJCXVuc2lnbmVkIGNoYXIgX191c2VyICplbmQ7CgkJdW5zaWduZWQgY2hhciB2YWw7CgoJCWFkZHIgPSAodm9pZCBfX3VzZXIgKil1YXR0ciArIHNpemVvZigqYXR0cik7CgkJZW5kICA9ICh2b2lkIF9fdXNlciAqKXVhdHRyICsgc2l6ZTsKCgkJZm9yICg7IGFkZHIgPCBlbmQ7IGFkZHIrKykgewoJCQlyZXQgPSBnZXRfdXNlcih2YWwsIGFkZHIpOwoJCQlpZiAocmV0KQoJCQkJcmV0dXJuIHJldDsKCQkJaWYgKHZhbCkKCQkJCWdvdG8gZXJyX3NpemU7CgkJfQoJCXNpemUgPSBzaXplb2YoKmF0dHIpOwoJfQoKCXJldCA9IGNvcHlfZnJvbV91c2VyKGF0dHIsIHVhdHRyLCBzaXplKTsKCWlmIChyZXQpCgkJcmV0dXJuIC1FRkFVTFQ7CgoJLyoKCSAqIElmIHRoZSB0eXBlIGV4aXN0cywgdGhlIGNvcnJlc3BvbmRpbmcgY3JlYXRpb24gd2lsbCB2ZXJpZnkKCSAqIHRoZSBhdHRyLT5jb25maWcuCgkgKi8KCWlmIChhdHRyLT50eXBlID49IFBFUkZfVFlQRV9NQVgpCgkJcmV0dXJuIC1FSU5WQUw7CgoJaWYgKGF0dHItPl9fcmVzZXJ2ZWRfMSB8fCBhdHRyLT5fX3Jlc2VydmVkXzIgfHwgYXR0ci0+X19yZXNlcnZlZF8zKQoJCXJldHVybiAtRUlOVkFMOwoKCWlmIChhdHRyLT5zYW1wbGVfdHlwZSAmIH4oUEVSRl9TQU1QTEVfTUFYLTEpKQoJCXJldHVybiAtRUlOVkFMOwoKCWlmIChhdHRyLT5yZWFkX2Zvcm1hdCAmIH4oUEVSRl9GT1JNQVRfTUFYLTEpKQoJCXJldHVybiAtRUlOVkFMOwoKb3V0OgoJcmV0dXJuIHJldDsKCmVycl9zaXplOgoJcHV0X3VzZXIoc2l6ZW9mKCphdHRyKSwgJnVhdHRyLT5zaXplKTsKCXJldCA9IC1FMkJJRzsKCWdvdG8gb3V0Owp9CgpzdGF0aWMgaW50IHBlcmZfZXZlbnRfc2V0X291dHB1dChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBvdXRwdXRfZmQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpvdXRwdXRfZXZlbnQgPSBOVUxMOwoJc3RydWN0IGZpbGUgKm91dHB1dF9maWxlID0gTlVMTDsKCXN0cnVjdCBwZXJmX2V2ZW50ICpvbGRfb3V0cHV0OwoJaW50IGZwdXRfbmVlZGVkID0gMDsKCWludCByZXQgPSAtRUlOVkFMOwoKCWlmICghb3V0cHV0X2ZkKQoJCWdvdG8gc2V0OwoKCW91dHB1dF9maWxlID0gZmdldF9saWdodChvdXRwdXRfZmQsICZmcHV0X25lZWRlZCk7CglpZiAoIW91dHB1dF9maWxlKQoJCXJldHVybiAtRUJBREY7CgoJaWYgKG91dHB1dF9maWxlLT5mX29wICE9ICZwZXJmX2ZvcHMpCgkJZ290byBvdXQ7CgoJb3V0cHV0X2V2ZW50ID0gb3V0cHV0X2ZpbGUtPnByaXZhdGVfZGF0YTsKCgkvKiBEb24ndCBjaGFpbiBvdXRwdXQgZmRzICovCglpZiAob3V0cHV0X2V2ZW50LT5vdXRwdXQpCgkJZ290byBvdXQ7CgoJLyogRG9uJ3Qgc2V0IGFuIG91dHB1dCBmZCB3aGVuIHdlIGFscmVhZHkgaGF2ZSBhbiBvdXRwdXQgY2hhbm5lbCAqLwoJaWYgKGV2ZW50LT5kYXRhKQoJCWdvdG8gb3V0OwoKCWF0b21pY19sb25nX2luYygmb3V0cHV0X2ZpbGUtPmZfY291bnQpOwoKc2V0OgoJbXV0ZXhfbG9jaygmZXZlbnQtPm1tYXBfbXV0ZXgpOwoJb2xkX291dHB1dCA9IGV2ZW50LT5vdXRwdXQ7CglyY3VfYXNzaWduX3BvaW50ZXIoZXZlbnQtPm91dHB1dCwgb3V0cHV0X2V2ZW50KTsKCW11dGV4X3VubG9jaygmZXZlbnQtPm1tYXBfbXV0ZXgpOwoKCWlmIChvbGRfb3V0cHV0KSB7CgkJLyoKCQkgKiB3ZSBuZWVkIHRvIG1ha2Ugc3VyZSBubyBleGlzdGluZyBwZXJmX291dHB1dF8qKCkKCQkgKiBpcyBzdGlsbCByZWZlcmVuY2luZyB0aGlzIGV2ZW50LgoJCSAqLwoJCXN5bmNocm9uaXplX3JjdSgpOwoJCWZwdXQob2xkX291dHB1dC0+ZmlscCk7Cgl9CgoJcmV0ID0gMDsKb3V0OgoJZnB1dF9saWdodChvdXRwdXRfZmlsZSwgZnB1dF9uZWVkZWQpOwoJcmV0dXJuIHJldDsKfQoKLyoqCiAqIHN5c19wZXJmX2V2ZW50X29wZW4gLSBvcGVuIGEgcGVyZm9ybWFuY2UgZXZlbnQsIGFzc29jaWF0ZSBpdCB0byBhIHRhc2svY3B1CiAqCiAqIEBhdHRyX3VwdHI6CWV2ZW50X2lkIHR5cGUgYXR0cmlidXRlcyBmb3IgbW9uaXRvcmluZy9zYW1wbGluZwogKiBAcGlkOgkJdGFyZ2V0IHBpZAogKiBAY3B1OgkJdGFyZ2V0IGNwdQogKiBAZ3JvdXBfZmQ6CQlncm91cCBsZWFkZXIgZXZlbnQgZmQKICovClNZU0NBTExfREVGSU5FNShwZXJmX2V2ZW50X29wZW4sCgkJc3RydWN0IHBlcmZfZXZlbnRfYXR0ciBfX3VzZXIgKiwgYXR0cl91cHRyLAoJCXBpZF90LCBwaWQsIGludCwgY3B1LCBpbnQsIGdyb3VwX2ZkLCB1bnNpZ25lZCBsb25nLCBmbGFncykKewoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqZ3JvdXBfbGVhZGVyOwoJc3RydWN0IHBlcmZfZXZlbnRfYXR0ciBhdHRyOwoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4OwoJc3RydWN0IGZpbGUgKmV2ZW50X2ZpbGUgPSBOVUxMOwoJc3RydWN0IGZpbGUgKmdyb3VwX2ZpbGUgPSBOVUxMOwoJaW50IGZwdXRfbmVlZGVkID0gMDsKCWludCBmcHV0X25lZWRlZDIgPSAwOwoJaW50IGVycjsKCgkvKiBmb3IgZnV0dXJlIGV4cGFuZGFiaWxpdHkuLi4gKi8KCWlmIChmbGFncyAmIH4oUEVSRl9GTEFHX0ZEX05PX0dST1VQIHwgUEVSRl9GTEFHX0ZEX09VVFBVVCkpCgkJcmV0dXJuIC1FSU5WQUw7CgoJZXJyID0gcGVyZl9jb3B5X2F0dHIoYXR0cl91cHRyLCAmYXR0cik7CglpZiAoZXJyKQoJCXJldHVybiBlcnI7CgoJaWYgKCFhdHRyLmV4Y2x1ZGVfa2VybmVsKSB7CgkJaWYgKHBlcmZfcGFyYW5vaWRfa2VybmVsKCkgJiYgIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpCgkJCXJldHVybiAtRUFDQ0VTOwoJfQoKCWlmIChhdHRyLmZyZXEpIHsKCQlpZiAoYXR0ci5zYW1wbGVfZnJlcSA+IHN5c2N0bF9wZXJmX2V2ZW50X3NhbXBsZV9yYXRlKQoJCQlyZXR1cm4gLUVJTlZBTDsKCX0KCgkvKgoJICogR2V0IHRoZSB0YXJnZXQgY29udGV4dCAodGFzayBvciBwZXJjcHUpOgoJICovCgljdHggPSBmaW5kX2dldF9jb250ZXh0KHBpZCwgY3B1KTsKCWlmIChJU19FUlIoY3R4KSkKCQlyZXR1cm4gUFRSX0VSUihjdHgpOwoKCS8qCgkgKiBMb29rIHVwIHRoZSBncm91cCBsZWFkZXIgKHdlIHdpbGwgYXR0YWNoIHRoaXMgZXZlbnQgdG8gaXQpOgoJICovCglncm91cF9sZWFkZXIgPSBOVUxMOwoJaWYgKGdyb3VwX2ZkICE9IC0xICYmICEoZmxhZ3MgJiBQRVJGX0ZMQUdfRkRfTk9fR1JPVVApKSB7CgkJZXJyID0gLUVJTlZBTDsKCQlncm91cF9maWxlID0gZmdldF9saWdodChncm91cF9mZCwgJmZwdXRfbmVlZGVkKTsKCQlpZiAoIWdyb3VwX2ZpbGUpCgkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwoJCWlmIChncm91cF9maWxlLT5mX29wICE9ICZwZXJmX2ZvcHMpCgkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwoKCQlncm91cF9sZWFkZXIgPSBncm91cF9maWxlLT5wcml2YXRlX2RhdGE7CgkJLyoKCQkgKiBEbyBub3QgYWxsb3cgYSByZWN1cnNpdmUgaGllcmFyY2h5ICh0aGlzIG5ldyBzaWJsaW5nCgkJICogYmVjb21pbmcgcGFydCBvZiBhbm90aGVyIGdyb3VwLXNpYmxpbmcpOgoJCSAqLwoJCWlmIChncm91cF9sZWFkZXItPmdyb3VwX2xlYWRlciAhPSBncm91cF9sZWFkZXIpCgkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwoJCS8qCgkJICogRG8gbm90IGFsbG93IHRvIGF0dGFjaCB0byBhIGdyb3VwIGluIGEgZGlmZmVyZW50CgkJICogdGFzayBvciBDUFUgY29udGV4dDoKCQkgKi8KCQlpZiAoZ3JvdXBfbGVhZGVyLT5jdHggIT0gY3R4KQoJCQlnb3RvIGVycl9wdXRfY29udGV4dDsKCQkvKgoJCSAqIE9ubHkgYSBncm91cCBsZWFkZXIgY2FuIGJlIGV4Y2x1c2l2ZSBvciBwaW5uZWQKCQkgKi8KCQlpZiAoYXR0ci5leGNsdXNpdmUgfHwgYXR0ci5waW5uZWQpCgkJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwoJfQoKCWV2ZW50ID0gcGVyZl9ldmVudF9hbGxvYygmYXR0ciwgY3B1LCBjdHgsIGdyb3VwX2xlYWRlciwKCQkJCSAgICAgTlVMTCwgTlVMTCwgR0ZQX0tFUk5FTCk7CgllcnIgPSBQVFJfRVJSKGV2ZW50KTsKCWlmIChJU19FUlIoZXZlbnQpKQoJCWdvdG8gZXJyX3B1dF9jb250ZXh0OwoKCWVyciA9IGFub25faW5vZGVfZ2V0ZmQoIltwZXJmX2V2ZW50XSIsICZwZXJmX2ZvcHMsIGV2ZW50LCAwKTsKCWlmIChlcnIgPCAwKQoJCWdvdG8gZXJyX2ZyZWVfcHV0X2NvbnRleHQ7CgoJZXZlbnRfZmlsZSA9IGZnZXRfbGlnaHQoZXJyLCAmZnB1dF9uZWVkZWQyKTsKCWlmICghZXZlbnRfZmlsZSkKCQlnb3RvIGVycl9mcmVlX3B1dF9jb250ZXh0OwoKCWlmIChmbGFncyAmIFBFUkZfRkxBR19GRF9PVVRQVVQpIHsKCQllcnIgPSBwZXJmX2V2ZW50X3NldF9vdXRwdXQoZXZlbnQsIGdyb3VwX2ZkKTsKCQlpZiAoZXJyKQoJCQlnb3RvIGVycl9mcHV0X2ZyZWVfcHV0X2NvbnRleHQ7Cgl9CgoJZXZlbnQtPmZpbHAgPSBldmVudF9maWxlOwoJV0FSTl9PTl9PTkNFKGN0eC0+cGFyZW50X2N0eCk7CgltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKCXBlcmZfaW5zdGFsbF9pbl9jb250ZXh0KGN0eCwgZXZlbnQsIGNwdSk7CgkrK2N0eC0+Z2VuZXJhdGlvbjsKCW11dGV4X3VubG9jaygmY3R4LT5tdXRleCk7CgoJZXZlbnQtPm93bmVyID0gY3VycmVudDsKCWdldF90YXNrX3N0cnVjdChjdXJyZW50KTsKCW11dGV4X2xvY2soJmN1cnJlbnQtPnBlcmZfZXZlbnRfbXV0ZXgpOwoJbGlzdF9hZGRfdGFpbCgmZXZlbnQtPm93bmVyX2VudHJ5LCAmY3VycmVudC0+cGVyZl9ldmVudF9saXN0KTsKCW11dGV4X3VubG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CgplcnJfZnB1dF9mcmVlX3B1dF9jb250ZXh0OgoJZnB1dF9saWdodChldmVudF9maWxlLCBmcHV0X25lZWRlZDIpOwoKZXJyX2ZyZWVfcHV0X2NvbnRleHQ6CglpZiAoZXJyIDwgMCkKCQlrZnJlZShldmVudCk7CgplcnJfcHV0X2NvbnRleHQ6CglpZiAoZXJyIDwgMCkKCQlwdXRfY3R4KGN0eCk7CgoJZnB1dF9saWdodChncm91cF9maWxlLCBmcHV0X25lZWRlZCk7CgoJcmV0dXJuIGVycjsKfQoKLyoqCiAqIHBlcmZfZXZlbnRfY3JlYXRlX2tlcm5lbF9jb3VudGVyCiAqCiAqIEBhdHRyOiBhdHRyaWJ1dGVzIG9mIHRoZSBjb3VudGVyIHRvIGNyZWF0ZQogKiBAY3B1OiBjcHUgaW4gd2hpY2ggdGhlIGNvdW50ZXIgaXMgYm91bmQKICogQHBpZDogdGFzayB0byBwcm9maWxlCiAqLwpzdHJ1Y3QgcGVyZl9ldmVudCAqCnBlcmZfZXZlbnRfY3JlYXRlX2tlcm5lbF9jb3VudGVyKHN0cnVjdCBwZXJmX2V2ZW50X2F0dHIgKmF0dHIsIGludCBjcHUsCgkJCQkgcGlkX3QgcGlkLCBwZXJmX2NhbGxiYWNrX3QgY2FsbGJhY2spCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eDsKCWludCBlcnI7CgoJLyoKCSAqIEdldCB0aGUgdGFyZ2V0IGNvbnRleHQgKHRhc2sgb3IgcGVyY3B1KToKCSAqLwoKCWN0eCA9IGZpbmRfZ2V0X2NvbnRleHQocGlkLCBjcHUpOwoJaWYgKElTX0VSUihjdHgpKQoJCXJldHVybiBOVUxMOwoKCWV2ZW50ID0gcGVyZl9ldmVudF9hbGxvYyhhdHRyLCBjcHUsIGN0eCwgTlVMTCwKCQkJCSAgICAgTlVMTCwgY2FsbGJhY2ssIEdGUF9LRVJORUwpOwoJZXJyID0gUFRSX0VSUihldmVudCk7CglpZiAoSVNfRVJSKGV2ZW50KSkKCQlnb3RvIGVycl9wdXRfY29udGV4dDsKCglldmVudC0+ZmlscCA9IE5VTEw7CglXQVJOX09OX09OQ0UoY3R4LT5wYXJlbnRfY3R4KTsKCW11dGV4X2xvY2soJmN0eC0+bXV0ZXgpOwoJcGVyZl9pbnN0YWxsX2luX2NvbnRleHQoY3R4LCBldmVudCwgY3B1KTsKCSsrY3R4LT5nZW5lcmF0aW9uOwoJbXV0ZXhfdW5sb2NrKCZjdHgtPm11dGV4KTsKCglldmVudC0+b3duZXIgPSBjdXJyZW50OwoJZ2V0X3Rhc2tfc3RydWN0KGN1cnJlbnQpOwoJbXV0ZXhfbG9jaygmY3VycmVudC0+cGVyZl9ldmVudF9tdXRleCk7CglsaXN0X2FkZF90YWlsKCZldmVudC0+b3duZXJfZW50cnksICZjdXJyZW50LT5wZXJmX2V2ZW50X2xpc3QpOwoJbXV0ZXhfdW5sb2NrKCZjdXJyZW50LT5wZXJmX2V2ZW50X211dGV4KTsKCglyZXR1cm4gZXZlbnQ7CgplcnJfcHV0X2NvbnRleHQ6CglpZiAoZXJyIDwgMCkKCQlwdXRfY3R4KGN0eCk7CgoJcmV0dXJuIE5VTEw7Cn0KRVhQT1JUX1NZTUJPTF9HUEwocGVyZl9ldmVudF9jcmVhdGVfa2VybmVsX2NvdW50ZXIpOwoKLyoKICogaW5oZXJpdCBhIGV2ZW50IGZyb20gcGFyZW50IHRhc2sgdG8gY2hpbGQgdGFzazoKICovCnN0YXRpYyBzdHJ1Y3QgcGVyZl9ldmVudCAqCmluaGVyaXRfZXZlbnQoc3RydWN0IHBlcmZfZXZlbnQgKnBhcmVudF9ldmVudCwKCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50LAoJICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqcGFyZW50X2N0eCwKCSAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQsCgkgICAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZ3JvdXBfbGVhZGVyLAoJICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2hpbGRfY3R4KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqY2hpbGRfZXZlbnQ7CgoJLyoKCSAqIEluc3RlYWQgb2YgY3JlYXRpbmcgcmVjdXJzaXZlIGhpZXJhcmNoaWVzIG9mIGV2ZW50cywKCSAqIHdlIGxpbmsgaW5oZXJpdGVkIGV2ZW50cyBiYWNrIHRvIHRoZSBvcmlnaW5hbCBwYXJlbnQsCgkgKiB3aGljaCBoYXMgYSBmaWxwIGZvciBzdXJlLCB3aGljaCB3ZSB1c2UgYXMgdGhlIHJlZmVyZW5jZQoJICogY291bnQ6CgkgKi8KCWlmIChwYXJlbnRfZXZlbnQtPnBhcmVudCkKCQlwYXJlbnRfZXZlbnQgPSBwYXJlbnRfZXZlbnQtPnBhcmVudDsKCgljaGlsZF9ldmVudCA9IHBlcmZfZXZlbnRfYWxsb2MoJnBhcmVudF9ldmVudC0+YXR0ciwKCQkJCQkgICBwYXJlbnRfZXZlbnQtPmNwdSwgY2hpbGRfY3R4LAoJCQkJCSAgIGdyb3VwX2xlYWRlciwgcGFyZW50X2V2ZW50LAoJCQkJCSAgIE5VTEwsIEdGUF9LRVJORUwpOwoJaWYgKElTX0VSUihjaGlsZF9ldmVudCkpCgkJcmV0dXJuIGNoaWxkX2V2ZW50OwoJZ2V0X2N0eChjaGlsZF9jdHgpOwoKCS8qCgkgKiBNYWtlIHRoZSBjaGlsZCBzdGF0ZSBmb2xsb3cgdGhlIHN0YXRlIG9mIHRoZSBwYXJlbnQgZXZlbnQsCgkgKiBub3QgaXRzIGF0dHIuZGlzYWJsZWQgYml0LiAgV2UgaG9sZCB0aGUgcGFyZW50J3MgbXV0ZXgsCgkgKiBzbyB3ZSB3b24ndCByYWNlIHdpdGggcGVyZl9ldmVudF97ZW4sIGRpc31hYmxlX2ZhbWlseS4KCSAqLwoJaWYgKHBhcmVudF9ldmVudC0+c3RhdGUgPj0gUEVSRl9FVkVOVF9TVEFURV9JTkFDVElWRSkKCQljaGlsZF9ldmVudC0+c3RhdGUgPSBQRVJGX0VWRU5UX1NUQVRFX0lOQUNUSVZFOwoJZWxzZQoJCWNoaWxkX2V2ZW50LT5zdGF0ZSA9IFBFUkZfRVZFTlRfU1RBVEVfT0ZGOwoKCWlmIChwYXJlbnRfZXZlbnQtPmF0dHIuZnJlcSkKCQljaGlsZF9ldmVudC0+aHcuc2FtcGxlX3BlcmlvZCA9IHBhcmVudF9ldmVudC0+aHcuc2FtcGxlX3BlcmlvZDsKCgljaGlsZF9ldmVudC0+b3ZlcmZsb3dfaGFuZGxlciA9IHBhcmVudF9ldmVudC0+b3ZlcmZsb3dfaGFuZGxlcjsKCgkvKgoJICogTGluayBpdCB1cCBpbiB0aGUgY2hpbGQncyBjb250ZXh0OgoJICovCglhZGRfZXZlbnRfdG9fY3R4KGNoaWxkX2V2ZW50LCBjaGlsZF9jdHgpOwoKCS8qCgkgKiBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHBhcmVudCBmaWxwIC0gd2Ugd2lsbCBmcHV0IGl0CgkgKiB3aGVuIHRoZSBjaGlsZCBldmVudCBleGl0cy4gVGhpcyBpcyBzYWZlIHRvIGRvIGJlY2F1c2UKCSAqIHdlIGFyZSBpbiB0aGUgcGFyZW50IGFuZCB3ZSBrbm93IHRoYXQgdGhlIGZpbHAgc3RpbGwKCSAqIGV4aXN0cyBhbmQgaGFzIGEgbm9uemVybyBjb3VudDoKCSAqLwoJYXRvbWljX2xvbmdfaW5jKCZwYXJlbnRfZXZlbnQtPmZpbHAtPmZfY291bnQpOwoKCS8qCgkgKiBMaW5rIHRoaXMgaW50byB0aGUgcGFyZW50IGV2ZW50J3MgY2hpbGQgbGlzdAoJICovCglXQVJOX09OX09OQ0UocGFyZW50X2V2ZW50LT5jdHgtPnBhcmVudF9jdHgpOwoJbXV0ZXhfbG9jaygmcGFyZW50X2V2ZW50LT5jaGlsZF9tdXRleCk7CglsaXN0X2FkZF90YWlsKCZjaGlsZF9ldmVudC0+Y2hpbGRfbGlzdCwgJnBhcmVudF9ldmVudC0+Y2hpbGRfbGlzdCk7CgltdXRleF91bmxvY2soJnBhcmVudF9ldmVudC0+Y2hpbGRfbXV0ZXgpOwoKCXJldHVybiBjaGlsZF9ldmVudDsKfQoKc3RhdGljIGludCBpbmhlcml0X2dyb3VwKHN0cnVjdCBwZXJmX2V2ZW50ICpwYXJlbnRfZXZlbnQsCgkgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnBhcmVudCwKCSAgICAgIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKnBhcmVudF9jdHgsCgkgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkLAoJICAgICAgc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2hpbGRfY3R4KQp7CglzdHJ1Y3QgcGVyZl9ldmVudCAqbGVhZGVyOwoJc3RydWN0IHBlcmZfZXZlbnQgKnN1YjsKCXN0cnVjdCBwZXJmX2V2ZW50ICpjaGlsZF9jdHI7CgoJbGVhZGVyID0gaW5oZXJpdF9ldmVudChwYXJlbnRfZXZlbnQsIHBhcmVudCwgcGFyZW50X2N0eCwKCQkJCSBjaGlsZCwgTlVMTCwgY2hpbGRfY3R4KTsKCWlmIChJU19FUlIobGVhZGVyKSkKCQlyZXR1cm4gUFRSX0VSUihsZWFkZXIpOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShzdWIsICZwYXJlbnRfZXZlbnQtPnNpYmxpbmdfbGlzdCwgZ3JvdXBfZW50cnkpIHsKCQljaGlsZF9jdHIgPSBpbmhlcml0X2V2ZW50KHN1YiwgcGFyZW50LCBwYXJlbnRfY3R4LAoJCQkJCSAgICBjaGlsZCwgbGVhZGVyLCBjaGlsZF9jdHgpOwoJCWlmIChJU19FUlIoY2hpbGRfY3RyKSkKCQkJcmV0dXJuIFBUUl9FUlIoY2hpbGRfY3RyKTsKCX0KCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBzeW5jX2NoaWxkX2V2ZW50KHN0cnVjdCBwZXJmX2V2ZW50ICpjaGlsZF9ldmVudCwKCQkJICAgICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpwYXJlbnRfZXZlbnQgPSBjaGlsZF9ldmVudC0+cGFyZW50OwoJdTY0IGNoaWxkX3ZhbDsKCglpZiAoY2hpbGRfZXZlbnQtPmF0dHIuaW5oZXJpdF9zdGF0KQoJCXBlcmZfZXZlbnRfcmVhZF9ldmVudChjaGlsZF9ldmVudCwgY2hpbGQpOwoKCWNoaWxkX3ZhbCA9IGF0b21pYzY0X3JlYWQoJmNoaWxkX2V2ZW50LT5jb3VudCk7CgoJLyoKCSAqIEFkZCBiYWNrIHRoZSBjaGlsZCdzIGNvdW50IHRvIHRoZSBwYXJlbnQncyBjb3VudDoKCSAqLwoJYXRvbWljNjRfYWRkKGNoaWxkX3ZhbCwgJnBhcmVudF9ldmVudC0+Y291bnQpOwoJYXRvbWljNjRfYWRkKGNoaWxkX2V2ZW50LT50b3RhbF90aW1lX2VuYWJsZWQsCgkJICAgICAmcGFyZW50X2V2ZW50LT5jaGlsZF90b3RhbF90aW1lX2VuYWJsZWQpOwoJYXRvbWljNjRfYWRkKGNoaWxkX2V2ZW50LT50b3RhbF90aW1lX3J1bm5pbmcsCgkJICAgICAmcGFyZW50X2V2ZW50LT5jaGlsZF90b3RhbF90aW1lX3J1bm5pbmcpOwoKCS8qCgkgKiBSZW1vdmUgdGhpcyBldmVudCBmcm9tIHRoZSBwYXJlbnQncyBsaXN0CgkgKi8KCVdBUk5fT05fT05DRShwYXJlbnRfZXZlbnQtPmN0eC0+cGFyZW50X2N0eCk7CgltdXRleF9sb2NrKCZwYXJlbnRfZXZlbnQtPmNoaWxkX211dGV4KTsKCWxpc3RfZGVsX2luaXQoJmNoaWxkX2V2ZW50LT5jaGlsZF9saXN0KTsKCW11dGV4X3VubG9jaygmcGFyZW50X2V2ZW50LT5jaGlsZF9tdXRleCk7CgoJLyoKCSAqIFJlbGVhc2UgdGhlIHBhcmVudCBldmVudCwgaWYgdGhpcyB3YXMgdGhlIGxhc3QKCSAqIHJlZmVyZW5jZSB0byBpdC4KCSAqLwoJZnB1dChwYXJlbnRfZXZlbnQtPmZpbHApOwp9CgpzdGF0aWMgdm9pZApfX3BlcmZfZXZlbnRfZXhpdF90YXNrKHN0cnVjdCBwZXJmX2V2ZW50ICpjaGlsZF9ldmVudCwKCQkJIHN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmNoaWxkX2N0eCwKCQkJIHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpwYXJlbnRfZXZlbnQ7CgoJdXBkYXRlX2V2ZW50X3RpbWVzKGNoaWxkX2V2ZW50KTsKCXBlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dChjaGlsZF9ldmVudCk7CgoJcGFyZW50X2V2ZW50ID0gY2hpbGRfZXZlbnQtPnBhcmVudDsKCS8qCgkgKiBJdCBjYW4gaGFwcGVuIHRoYXQgcGFyZW50IGV4aXRzIGZpcnN0LCBhbmQgaGFzIGV2ZW50cwoJICogdGhhdCBhcmUgc3RpbGwgYXJvdW5kIGR1ZSB0byB0aGUgY2hpbGQgcmVmZXJlbmNlLiBUaGVzZQoJICogZXZlbnRzIG5lZWQgdG8gYmUgemFwcGVkIC0gYnV0IG90aGVyd2lzZSBsaW5nZXIuCgkgKi8KCWlmIChwYXJlbnRfZXZlbnQpIHsKCQlzeW5jX2NoaWxkX2V2ZW50KGNoaWxkX2V2ZW50LCBjaGlsZCk7CgkJZnJlZV9ldmVudChjaGlsZF9ldmVudCk7Cgl9Cn0KCi8qCiAqIFdoZW4gYSBjaGlsZCB0YXNrIGV4aXRzLCBmZWVkIGJhY2sgZXZlbnQgdmFsdWVzIHRvIHBhcmVudCBldmVudHMuCiAqLwp2b2lkIHBlcmZfZXZlbnRfZXhpdF90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqY2hpbGQpCnsKCXN0cnVjdCBwZXJmX2V2ZW50ICpjaGlsZF9ldmVudCwgKnRtcDsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmNoaWxkX2N0eDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJaWYgKGxpa2VseSghY2hpbGQtPnBlcmZfZXZlbnRfY3R4cCkpIHsKCQlwZXJmX2V2ZW50X3Rhc2soY2hpbGQsIE5VTEwsIDApOwoJCXJldHVybjsKCX0KCglsb2NhbF9pcnFfc2F2ZShmbGFncyk7CgkvKgoJICogV2UgY2FuJ3QgcmVzY2hlZHVsZSBoZXJlIGJlY2F1c2UgaW50ZXJydXB0cyBhcmUgZGlzYWJsZWQsCgkgKiBhbmQgZWl0aGVyIGNoaWxkIGlzIGN1cnJlbnQgb3IgaXQgaXMgYSB0YXNrIHRoYXQgY2FuJ3QgYmUKCSAqIHNjaGVkdWxlZCwgc28gd2UgYXJlIG5vdyBzYWZlIGZyb20gcmVzY2hlZHVsaW5nIGNoYW5naW5nCgkgKiBvdXIgY29udGV4dC4KCSAqLwoJY2hpbGRfY3R4ID0gY2hpbGQtPnBlcmZfZXZlbnRfY3R4cDsKCV9fcGVyZl9ldmVudF90YXNrX3NjaGVkX291dChjaGlsZF9jdHgpOwoKCS8qCgkgKiBUYWtlIHRoZSBjb250ZXh0IGxvY2sgaGVyZSBzbyB0aGF0IGlmIGZpbmRfZ2V0X2NvbnRleHQgaXMKCSAqIHJlYWRpbmcgY2hpbGQtPnBlcmZfZXZlbnRfY3R4cCwgd2Ugd2FpdCB1bnRpbCBpdCBoYXMKCSAqIGluY3JlbWVudGVkIHRoZSBjb250ZXh0J3MgcmVmY291bnQgYmVmb3JlIHdlIGRvIHB1dF9jdHggYmVsb3cuCgkgKi8KCXNwaW5fbG9jaygmY2hpbGRfY3R4LT5sb2NrKTsKCWNoaWxkLT5wZXJmX2V2ZW50X2N0eHAgPSBOVUxMOwoJLyoKCSAqIElmIHRoaXMgY29udGV4dCBpcyBhIGNsb25lOyB1bmNsb25lIGl0IHNvIGl0IGNhbid0IGdldAoJICogc3dhcHBlZCB0byBhbm90aGVyIHByb2Nlc3Mgd2hpbGUgd2UncmUgcmVtb3ZpbmcgYWxsCgkgKiB0aGUgZXZlbnRzIGZyb20gaXQuCgkgKi8KCXVuY2xvbmVfY3R4KGNoaWxkX2N0eCk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjaGlsZF9jdHgtPmxvY2ssIGZsYWdzKTsKCgkvKgoJICogUmVwb3J0IHRoZSB0YXNrIGRlYWQgYWZ0ZXIgdW5zY2hlZHVsaW5nIHRoZSBldmVudHMgc28gdGhhdCB3ZQoJICogd29uJ3QgZ2V0IGFueSBzYW1wbGVzIGFmdGVyIFBFUkZfUkVDT1JEX0VYSVQuIFdlIGNhbiBob3dldmVyIHN0aWxsCgkgKiBnZXQgYSBmZXcgUEVSRl9SRUNPUkRfUkVBRCBldmVudHMuCgkgKi8KCXBlcmZfZXZlbnRfdGFzayhjaGlsZCwgY2hpbGRfY3R4LCAwKTsKCgkvKgoJICogV2UgY2FuIHJlY3Vyc2Ugb24gdGhlIHNhbWUgbG9jayB0eXBlIHRocm91Z2g6CgkgKgoJICogICBfX3BlcmZfZXZlbnRfZXhpdF90YXNrKCkKCSAqICAgICBzeW5jX2NoaWxkX2V2ZW50KCkKCSAqICAgICAgIGZwdXQocGFyZW50X2V2ZW50LT5maWxwKQoJICogICAgICAgICBwZXJmX3JlbGVhc2UoKQoJICogICAgICAgICAgIG11dGV4X2xvY2soJmN0eC0+bXV0ZXgpCgkgKgoJICogQnV0IHNpbmNlIGl0cyB0aGUgcGFyZW50IGNvbnRleHQgaXQgd29uJ3QgYmUgdGhlIHNhbWUgaW5zdGFuY2UuCgkgKi8KCW11dGV4X2xvY2tfbmVzdGVkKCZjaGlsZF9jdHgtPm11dGV4LCBTSU5HTEVfREVQVEhfTkVTVElORyk7CgphZ2FpbjoKCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShjaGlsZF9ldmVudCwgdG1wLCAmY2hpbGRfY3R4LT5ncm91cF9saXN0LAoJCQkJIGdyb3VwX2VudHJ5KQoJCV9fcGVyZl9ldmVudF9leGl0X3Rhc2soY2hpbGRfZXZlbnQsIGNoaWxkX2N0eCwgY2hpbGQpOwoKCS8qCgkgKiBJZiB0aGUgbGFzdCBldmVudCB3YXMgYSBncm91cCBldmVudCwgaXQgd2lsbCBoYXZlIGFwcGVuZGVkIGFsbAoJICogaXRzIHNpYmxpbmdzIHRvIHRoZSBsaXN0LCBidXQgd2Ugb2J0YWluZWQgJ3RtcCcgYmVmb3JlIHRoYXQgd2hpY2gKCSAqIHdpbGwgc3RpbGwgcG9pbnQgdG8gdGhlIGxpc3QgaGVhZCB0ZXJtaW5hdGluZyB0aGUgaXRlcmF0aW9uLgoJICovCglpZiAoIWxpc3RfZW1wdHkoJmNoaWxkX2N0eC0+Z3JvdXBfbGlzdCkpCgkJZ290byBhZ2FpbjsKCgltdXRleF91bmxvY2soJmNoaWxkX2N0eC0+bXV0ZXgpOwoKCXB1dF9jdHgoY2hpbGRfY3R4KTsKfQoKLyoKICogZnJlZSBhbiB1bmV4cG9zZWQsIHVudXNlZCBjb250ZXh0IGFzIGNyZWF0ZWQgYnkgaW5oZXJpdGFuY2UgYnkKICogaW5pdF90YXNrIGJlbG93LCB1c2VkIGJ5IGZvcmsoKSBpbiBjYXNlIG9mIGZhaWwuCiAqLwp2b2lkIHBlcmZfZXZlbnRfZnJlZV90YXNrKHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzaykKewoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gdGFzay0+cGVyZl9ldmVudF9jdHhwOwoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqdG1wOwoKCWlmICghY3R4KQoJCXJldHVybjsKCgltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKYWdhaW46CglsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZXZlbnQsIHRtcCwgJmN0eC0+Z3JvdXBfbGlzdCwgZ3JvdXBfZW50cnkpIHsKCQlzdHJ1Y3QgcGVyZl9ldmVudCAqcGFyZW50ID0gZXZlbnQtPnBhcmVudDsKCgkJaWYgKFdBUk5fT05fT05DRSghcGFyZW50KSkKCQkJY29udGludWU7CgoJCW11dGV4X2xvY2soJnBhcmVudC0+Y2hpbGRfbXV0ZXgpOwoJCWxpc3RfZGVsX2luaXQoJmV2ZW50LT5jaGlsZF9saXN0KTsKCQltdXRleF91bmxvY2soJnBhcmVudC0+Y2hpbGRfbXV0ZXgpOwoKCQlmcHV0KHBhcmVudC0+ZmlscCk7CgoJCWxpc3RfZGVsX2V2ZW50KGV2ZW50LCBjdHgpOwoJCWZyZWVfZXZlbnQoZXZlbnQpOwoJfQoKCWlmICghbGlzdF9lbXB0eSgmY3R4LT5ncm91cF9saXN0KSkKCQlnb3RvIGFnYWluOwoKCW11dGV4X3VubG9jaygmY3R4LT5tdXRleCk7CgoJcHV0X2N0eChjdHgpOwp9CgovKgogKiBJbml0aWFsaXplIHRoZSBwZXJmX2V2ZW50IGNvbnRleHQgaW4gdGFza19zdHJ1Y3QKICovCmludCBwZXJmX2V2ZW50X2luaXRfdGFzayhzdHJ1Y3QgdGFza19zdHJ1Y3QgKmNoaWxkKQp7CglzdHJ1Y3QgcGVyZl9ldmVudF9jb250ZXh0ICpjaGlsZF9jdHgsICpwYXJlbnRfY3R4OwoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY2xvbmVkX2N0eDsKCXN0cnVjdCBwZXJmX2V2ZW50ICpldmVudDsKCXN0cnVjdCB0YXNrX3N0cnVjdCAqcGFyZW50ID0gY3VycmVudDsKCWludCBpbmhlcml0ZWRfYWxsID0gMTsKCWludCByZXQgPSAwOwoKCWNoaWxkLT5wZXJmX2V2ZW50X2N0eHAgPSBOVUxMOwoKCW11dGV4X2luaXQoJmNoaWxkLT5wZXJmX2V2ZW50X211dGV4KTsKCUlOSVRfTElTVF9IRUFEKCZjaGlsZC0+cGVyZl9ldmVudF9saXN0KTsKCglpZiAobGlrZWx5KCFwYXJlbnQtPnBlcmZfZXZlbnRfY3R4cCkpCgkJcmV0dXJuIDA7CgoJLyoKCSAqIFRoaXMgaXMgZXhlY3V0ZWQgZnJvbSB0aGUgcGFyZW50IHRhc2sgY29udGV4dCwgc28gaW5oZXJpdAoJICogZXZlbnRzIHRoYXQgaGF2ZSBiZWVuIG1hcmtlZCBmb3IgY2xvbmluZy4KCSAqIEZpcnN0IGFsbG9jYXRlIGFuZCBpbml0aWFsaXplIGEgY29udGV4dCBmb3IgdGhlIGNoaWxkLgoJICovCgoJY2hpbGRfY3R4ID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCksIEdGUF9LRVJORUwpOwoJaWYgKCFjaGlsZF9jdHgpCgkJcmV0dXJuIC1FTk9NRU07CgoJX19wZXJmX2V2ZW50X2luaXRfY29udGV4dChjaGlsZF9jdHgsIGNoaWxkKTsKCWNoaWxkLT5wZXJmX2V2ZW50X2N0eHAgPSBjaGlsZF9jdHg7CglnZXRfdGFza19zdHJ1Y3QoY2hpbGQpOwoKCS8qCgkgKiBJZiB0aGUgcGFyZW50J3MgY29udGV4dCBpcyBhIGNsb25lLCBwaW4gaXQgc28gaXQgd29uJ3QgZ2V0CgkgKiBzd2FwcGVkIHVuZGVyIHVzLgoJICovCglwYXJlbnRfY3R4ID0gcGVyZl9waW5fdGFza19jb250ZXh0KHBhcmVudCk7CgoJLyoKCSAqIE5vIG5lZWQgdG8gY2hlY2sgaWYgcGFyZW50X2N0eCAhPSBOVUxMIGhlcmU7IHNpbmNlIHdlIHNhdwoJICogaXQgbm9uLU5VTEwgZWFybGllciwgdGhlIG9ubHkgcmVhc29uIGZvciBpdCB0byBiZWNvbWUgTlVMTAoJICogaXMgaWYgd2UgZXhpdCwgYW5kIHNpbmNlIHdlJ3JlIGN1cnJlbnRseSBpbiB0aGUgbWlkZGxlIG9mCgkgKiBhIGZvcmsgd2UgY2FuJ3QgYmUgZXhpdGluZyBhdCB0aGUgc2FtZSB0aW1lLgoJICovCgoJLyoKCSAqIExvY2sgdGhlIHBhcmVudCBsaXN0LiBObyBuZWVkIHRvIGxvY2sgdGhlIGNoaWxkIC0gbm90IFBJRAoJICogaGFzaGVkIHlldCBhbmQgbm90IHJ1bm5pbmcsIHNvIG5vYm9keSBjYW4gYWNjZXNzIGl0LgoJICovCgltdXRleF9sb2NrKCZwYXJlbnRfY3R4LT5tdXRleCk7CgoJLyoKCSAqIFdlIGRvbnQgaGF2ZSB0byBkaXNhYmxlIE5NSXMgLSB3ZSBhcmUgb25seSBsb29raW5nIGF0CgkgKiB0aGUgbGlzdCwgbm90IG1hbmlwdWxhdGluZyBpdDoKCSAqLwoJbGlzdF9mb3JfZWFjaF9lbnRyeShldmVudCwgJnBhcmVudF9jdHgtPmdyb3VwX2xpc3QsIGdyb3VwX2VudHJ5KSB7CgoJCWlmICghZXZlbnQtPmF0dHIuaW5oZXJpdCkgewoJCQlpbmhlcml0ZWRfYWxsID0gMDsKCQkJY29udGludWU7CgkJfQoKCQlyZXQgPSBpbmhlcml0X2dyb3VwKGV2ZW50LCBwYXJlbnQsIHBhcmVudF9jdHgsCgkJCQkJICAgICBjaGlsZCwgY2hpbGRfY3R4KTsKCQlpZiAocmV0KSB7CgkJCWluaGVyaXRlZF9hbGwgPSAwOwoJCQlicmVhazsKCQl9Cgl9CgoJaWYgKGluaGVyaXRlZF9hbGwpIHsKCQkvKgoJCSAqIE1hcmsgdGhlIGNoaWxkIGNvbnRleHQgYXMgYSBjbG9uZSBvZiB0aGUgcGFyZW50CgkJICogY29udGV4dCwgb3Igb2Ygd2hhdGV2ZXIgdGhlIHBhcmVudCBpcyBhIGNsb25lIG9mLgoJCSAqIE5vdGUgdGhhdCBpZiB0aGUgcGFyZW50IGlzIGEgY2xvbmUsIGl0IGNvdWxkIGdldAoJCSAqIHVuY2xvbmVkIGF0IGFueSBwb2ludCwgYnV0IHRoYXQgZG9lc24ndCBtYXR0ZXIKCQkgKiBiZWNhdXNlIHRoZSBsaXN0IG9mIGV2ZW50cyBhbmQgdGhlIGdlbmVyYXRpb24KCQkgKiBjb3VudCBjYW4ndCBoYXZlIGNoYW5nZWQgc2luY2Ugd2UgdG9vayB0aGUgbXV0ZXguCgkJICovCgkJY2xvbmVkX2N0eCA9IHJjdV9kZXJlZmVyZW5jZShwYXJlbnRfY3R4LT5wYXJlbnRfY3R4KTsKCQlpZiAoY2xvbmVkX2N0eCkgewoJCQljaGlsZF9jdHgtPnBhcmVudF9jdHggPSBjbG9uZWRfY3R4OwoJCQljaGlsZF9jdHgtPnBhcmVudF9nZW4gPSBwYXJlbnRfY3R4LT5wYXJlbnRfZ2VuOwoJCX0gZWxzZSB7CgkJCWNoaWxkX2N0eC0+cGFyZW50X2N0eCA9IHBhcmVudF9jdHg7CgkJCWNoaWxkX2N0eC0+cGFyZW50X2dlbiA9IHBhcmVudF9jdHgtPmdlbmVyYXRpb247CgkJfQoJCWdldF9jdHgoY2hpbGRfY3R4LT5wYXJlbnRfY3R4KTsKCX0KCgltdXRleF91bmxvY2soJnBhcmVudF9jdHgtPm11dGV4KTsKCglwZXJmX3VucGluX2NvbnRleHQocGFyZW50X2N0eCk7CgoJcmV0dXJuIHJldDsKfQoKc3RhdGljIHZvaWQgX19jcHVpbml0IHBlcmZfZXZlbnRfaW5pdF9jcHUoaW50IGNwdSkKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKCgljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwoJX19wZXJmX2V2ZW50X2luaXRfY29udGV4dCgmY3B1Y3R4LT5jdHgsIE5VTEwpOwoKCXNwaW5fbG9jaygmcGVyZl9yZXNvdXJjZV9sb2NrKTsKCWNwdWN0eC0+bWF4X3BlcnRhc2sgPSBwZXJmX21heF9ldmVudHMgLSBwZXJmX3Jlc2VydmVkX3BlcmNwdTsKCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwoKCWh3X3BlcmZfZXZlbnRfc2V0dXAoY3B1KTsKfQoKI2lmZGVmIENPTkZJR19IT1RQTFVHX0NQVQpzdGF0aWMgdm9pZCBfX3BlcmZfZXZlbnRfZXhpdF9jcHUodm9pZCAqaW5mbykKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eCA9ICZfX2dldF9jcHVfdmFyKHBlcmZfY3B1X2NvbnRleHQpOwoJc3RydWN0IHBlcmZfZXZlbnRfY29udGV4dCAqY3R4ID0gJmNwdWN0eC0+Y3R4OwoJc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCAqdG1wOwoKCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShldmVudCwgdG1wLCAmY3R4LT5ncm91cF9saXN0LCBncm91cF9lbnRyeSkKCQlfX3BlcmZfZXZlbnRfcmVtb3ZlX2Zyb21fY29udGV4dChldmVudCk7Cn0Kc3RhdGljIHZvaWQgcGVyZl9ldmVudF9leGl0X2NwdShpbnQgY3B1KQp7CglzdHJ1Y3QgcGVyZl9jcHVfY29udGV4dCAqY3B1Y3R4ID0gJnBlcl9jcHUocGVyZl9jcHVfY29udGV4dCwgY3B1KTsKCXN0cnVjdCBwZXJmX2V2ZW50X2NvbnRleHQgKmN0eCA9ICZjcHVjdHgtPmN0eDsKCgltdXRleF9sb2NrKCZjdHgtPm11dGV4KTsKCXNtcF9jYWxsX2Z1bmN0aW9uX3NpbmdsZShjcHUsIF9fcGVyZl9ldmVudF9leGl0X2NwdSwgTlVMTCwgMSk7CgltdXRleF91bmxvY2soJmN0eC0+bXV0ZXgpOwp9CiNlbHNlCnN0YXRpYyBpbmxpbmUgdm9pZCBwZXJmX2V2ZW50X2V4aXRfY3B1KGludCBjcHUpIHsgfQojZW5kaWYKCnN0YXRpYyBpbnQgX19jcHVpbml0CnBlcmZfY3B1X25vdGlmeShzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnNlbGYsIHVuc2lnbmVkIGxvbmcgYWN0aW9uLCB2b2lkICpoY3B1KQp7Cgl1bnNpZ25lZCBpbnQgY3B1ID0gKGxvbmcpaGNwdTsKCglzd2l0Y2ggKGFjdGlvbikgewoKCWNhc2UgQ1BVX1VQX1BSRVBBUkU6CgljYXNlIENQVV9VUF9QUkVQQVJFX0ZST1pFTjoKCQlwZXJmX2V2ZW50X2luaXRfY3B1KGNwdSk7CgkJYnJlYWs7CgoJY2FzZSBDUFVfT05MSU5FOgoJY2FzZSBDUFVfT05MSU5FX0ZST1pFTjoKCQlod19wZXJmX2V2ZW50X3NldHVwX29ubGluZShjcHUpOwoJCWJyZWFrOwoKCWNhc2UgQ1BVX0RPV05fUFJFUEFSRToKCWNhc2UgQ1BVX0RPV05fUFJFUEFSRV9GUk9aRU46CgkJcGVyZl9ldmVudF9leGl0X2NwdShjcHUpOwoJCWJyZWFrOwoKCWRlZmF1bHQ6CgkJYnJlYWs7Cgl9CgoJcmV0dXJuIE5PVElGWV9PSzsKfQoKLyoKICogVGhpcyBoYXMgdG8gaGF2ZSBhIGhpZ2hlciBwcmlvcml0eSB0aGFuIG1pZ3JhdGlvbl9ub3RpZmllciBpbiBzY2hlZC5jLgogKi8Kc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBfX2NwdWluaXRkYXRhIHBlcmZfY3B1X25iID0gewoJLm5vdGlmaWVyX2NhbGwJCT0gcGVyZl9jcHVfbm90aWZ5LAoJLnByaW9yaXR5CQk9IDIwLAp9OwoKdm9pZCBfX2luaXQgcGVyZl9ldmVudF9pbml0KHZvaWQpCnsKCXBlcmZfY3B1X25vdGlmeSgmcGVyZl9jcHVfbmIsICh1bnNpZ25lZCBsb25nKUNQVV9VUF9QUkVQQVJFLAoJCQkodm9pZCAqKShsb25nKXNtcF9wcm9jZXNzb3JfaWQoKSk7CglwZXJmX2NwdV9ub3RpZnkoJnBlcmZfY3B1X25iLCAodW5zaWduZWQgbG9uZylDUFVfT05MSU5FLAoJCQkodm9pZCAqKShsb25nKXNtcF9wcm9jZXNzb3JfaWQoKSk7CglyZWdpc3Rlcl9jcHVfbm90aWZpZXIoJnBlcmZfY3B1X25iKTsKfQoKc3RhdGljIHNzaXplX3QgcGVyZl9zaG93X3Jlc2VydmVfcGVyY3B1KHN0cnVjdCBzeXNkZXZfY2xhc3MgKmNsYXNzLCBjaGFyICpidWYpCnsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBwZXJmX3Jlc2VydmVkX3BlcmNwdSk7Cn0KCnN0YXRpYyBzc2l6ZV90CnBlcmZfc2V0X3Jlc2VydmVfcGVyY3B1KHN0cnVjdCBzeXNkZXZfY2xhc3MgKmNsYXNzLAoJCQljb25zdCBjaGFyICpidWYsCgkJCXNpemVfdCBjb3VudCkKewoJc3RydWN0IHBlcmZfY3B1X2NvbnRleHQgKmNwdWN0eDsKCXVuc2lnbmVkIGxvbmcgdmFsOwoJaW50IGVyciwgY3B1LCBtcHQ7CgoJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7CglpZiAoZXJyKQoJCXJldHVybiBlcnI7CglpZiAodmFsID4gcGVyZl9tYXhfZXZlbnRzKQoJCXJldHVybiAtRUlOVkFMOwoKCXNwaW5fbG9jaygmcGVyZl9yZXNvdXJjZV9sb2NrKTsKCXBlcmZfcmVzZXJ2ZWRfcGVyY3B1ID0gdmFsOwoJZm9yX2VhY2hfb25saW5lX2NwdShjcHUpIHsKCQljcHVjdHggPSAmcGVyX2NwdShwZXJmX2NwdV9jb250ZXh0LCBjcHUpOwoJCXNwaW5fbG9ja19pcnEoJmNwdWN0eC0+Y3R4LmxvY2spOwoJCW1wdCA9IG1pbihwZXJmX21heF9ldmVudHMgLSBjcHVjdHgtPmN0eC5ucl9ldmVudHMsCgkJCSAgcGVyZl9tYXhfZXZlbnRzIC0gcGVyZl9yZXNlcnZlZF9wZXJjcHUpOwoJCWNwdWN0eC0+bWF4X3BlcnRhc2sgPSBtcHQ7CgkJc3Bpbl91bmxvY2tfaXJxKCZjcHVjdHgtPmN0eC5sb2NrKTsKCX0KCXNwaW5fdW5sb2NrKCZwZXJmX3Jlc291cmNlX2xvY2spOwoKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIHNzaXplX3QgcGVyZl9zaG93X292ZXJjb21taXQoc3RydWN0IHN5c2Rldl9jbGFzcyAqY2xhc3MsIGNoYXIgKmJ1ZikKewoJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIHBlcmZfb3ZlcmNvbW1pdCk7Cn0KCnN0YXRpYyBzc2l6ZV90CnBlcmZfc2V0X292ZXJjb21taXQoc3RydWN0IHN5c2Rldl9jbGFzcyAqY2xhc3MsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQp7Cgl1bnNpZ25lZCBsb25nIHZhbDsKCWludCBlcnI7CgoJZXJyID0gc3RyaWN0X3N0cnRvdWwoYnVmLCAxMCwgJnZhbCk7CglpZiAoZXJyKQoJCXJldHVybiBlcnI7CglpZiAodmFsID4gMSkKCQlyZXR1cm4gLUVJTlZBTDsKCglzcGluX2xvY2soJnBlcmZfcmVzb3VyY2VfbG9jayk7CglwZXJmX292ZXJjb21taXQgPSB2YWw7CglzcGluX3VubG9jaygmcGVyZl9yZXNvdXJjZV9sb2NrKTsKCglyZXR1cm4gY291bnQ7Cn0KCnN0YXRpYyBTWVNERVZfQ0xBU1NfQVRUUigKCQkJCXJlc2VydmVfcGVyY3B1LAoJCQkJMDY0NCwKCQkJCXBlcmZfc2hvd19yZXNlcnZlX3BlcmNwdSwKCQkJCXBlcmZfc2V0X3Jlc2VydmVfcGVyY3B1CgkJCSk7CgpzdGF0aWMgU1lTREVWX0NMQVNTX0FUVFIoCgkJCQlvdmVyY29tbWl0LAoJCQkJMDY0NCwKCQkJCXBlcmZfc2hvd19vdmVyY29tbWl0LAoJCQkJcGVyZl9zZXRfb3ZlcmNvbW1pdAoJCQkpOwoKc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUgKnBlcmZjbGFzc19hdHRyc1tdID0gewoJJmF0dHJfcmVzZXJ2ZV9wZXJjcHUuYXR0ciwKCSZhdHRyX292ZXJjb21taXQuYXR0ciwKCU5VTEwKfTsKCnN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIHBlcmZjbGFzc19hdHRyX2dyb3VwID0gewoJLmF0dHJzCQkJPSBwZXJmY2xhc3NfYXR0cnMsCgkubmFtZQkJCT0gInBlcmZfZXZlbnRzIiwKfTsKCnN0YXRpYyBpbnQgX19pbml0IHBlcmZfZXZlbnRfc3lzZnNfaW5pdCh2b2lkKQp7CglyZXR1cm4gc3lzZnNfY3JlYXRlX2dyb3VwKCZjcHVfc3lzZGV2X2NsYXNzLmtzZXQua29iaiwKCQkJCSAgJnBlcmZjbGFzc19hdHRyX2dyb3VwKTsKfQpkZXZpY2VfaW5pdGNhbGwocGVyZl9ldmVudF9zeXNmc19pbml0KTsK