LyoKICogIGxpbnV4L2ZzL3N1cGVyLmMKICoKICogIENvcHlyaWdodCAoQykgMTk5MSwgMTk5MiAgTGludXMgVG9ydmFsZHMKICoKICogIHN1cGVyLmMgY29udGFpbnMgY29kZSB0byBoYW5kbGU6IC0gbW91bnQgc3RydWN0dXJlcwogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLSBzdXBlci1ibG9jayB0YWJsZXMKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gZmlsZXN5c3RlbSBkcml2ZXJzIGxpc3QKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gbW91bnQgc3lzdGVtIGNhbGwKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gdW1vdW50IHN5c3RlbSBjYWxsCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtIHVzdGF0IHN5c3RlbSBjYWxsCiAqCiAqIEdLIDIvNS85NSAgLSAgQ2hhbmdlZCB0byBzdXBwb3J0IG1vdW50aW5nIHRoZSByb290IGZzIHZpYSBORlMKICoKICogIEFkZGVkIGtlcm5lbGQgc3VwcG9ydDogSmFjcXVlcyBHZWxpbmFzIGFuZCBCam9ybiBFa3dhbGwKICogIEFkZGVkIGNoYW5nZV9yb290OiBXZXJuZXIgQWxtZXNiZXJnZXIgJiBIYW5zIExlcm1lbiwgRmViICc5NgogKiAgQWRkZWQgb3B0aW9ucyB0byAvcHJvYy9tb3VudHM6CiAqICAgIFRvcmJq9nJuIExpbmRoICh0b3Jiam9ybi5saW5kaEBnb3B0YS5zZSksIEFwcmlsIDE0LCAxOTk2LgogKiAgQWRkZWQgZGV2ZnMgc3VwcG9ydDogUmljaGFyZCBHb29jaCA8cmdvb2NoQGF0bmYuY3Npcm8uYXU+LCAxMy1KQU4tMTk5OAogKiAgSGVhdmlseSByZXdyaXR0ZW4gZm9yICdvbmUgZnMgLSBvbmUgdHJlZScgZGNhY2hlIGFyY2hpdGVjdHVyZS4gQVYsIE1hciAyMDAwCiAqLwoKI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvc2xhYi5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KI2luY2x1ZGUgPGxpbnV4L2FjY3QuaD4KI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgojaW5jbHVkZSA8bGludXgvcXVvdGFvcHMuaD4KI2luY2x1ZGUgPGxpbnV4L25hbWVpLmg+CiNpbmNsdWRlIDxsaW51eC9idWZmZXJfaGVhZC5oPgkJLyogZm9yIGZzeW5jX3N1cGVyKCkgKi8KI2luY2x1ZGUgPGxpbnV4L21vdW50Lmg+CiNpbmNsdWRlIDxsaW51eC9zZWN1cml0eS5oPgojaW5jbHVkZSA8bGludXgvc3lzY2FsbHMuaD4KI2luY2x1ZGUgPGxpbnV4L3Zmcy5oPgojaW5jbHVkZSA8bGludXgvd3JpdGViYWNrLmg+CQkvKiBmb3IgdGhlIGVtZXJnZW5jeSByZW1vdW50IHN0dWZmICovCiNpbmNsdWRlIDxsaW51eC9pZHIuaD4KI2luY2x1ZGUgPGxpbnV4L2tvYmplY3QuaD4KI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgoKCkxJU1RfSEVBRChzdXBlcl9ibG9ja3MpOwpERUZJTkVfU1BJTkxPQ0soc2JfbG9jayk7CgovKioKICoJYWxsb2Nfc3VwZXIJLQljcmVhdGUgbmV3IHN1cGVyYmxvY2sKICoJQHR5cGU6CWZpbGVzeXN0ZW0gdHlwZSBzdXBlcmJsb2NrIHNob3VsZCBiZWxvbmcgdG8KICoKICoJQWxsb2NhdGVzIGFuZCBpbml0aWFsaXplcyBhIG5ldyAmc3RydWN0IHN1cGVyX2Jsb2NrLiAgYWxsb2Nfc3VwZXIoKQogKglyZXR1cm5zIGEgcG9pbnRlciBuZXcgc3VwZXJibG9jayBvciAlTlVMTCBpZiBhbGxvY2F0aW9uIGhhZCBmYWlsZWQuCiAqLwpzdGF0aWMgc3RydWN0IHN1cGVyX2Jsb2NrICphbGxvY19zdXBlcihzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqdHlwZSkKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHN1cGVyX2Jsb2NrKSwgIEdGUF9VU0VSKTsKCXN0YXRpYyBzdHJ1Y3Qgc3VwZXJfb3BlcmF0aW9ucyBkZWZhdWx0X29wOwoKCWlmIChzKSB7CgkJaWYgKHNlY3VyaXR5X3NiX2FsbG9jKHMpKSB7CgkJCWtmcmVlKHMpOwoJCQlzID0gTlVMTDsKCQkJZ290byBvdXQ7CgkJfQoJCUlOSVRfTElTVF9IRUFEKCZzLT5zX2RpcnR5KTsKCQlJTklUX0xJU1RfSEVBRCgmcy0+c19pbyk7CgkJSU5JVF9MSVNUX0hFQUQoJnMtPnNfbW9yZV9pbyk7CgkJSU5JVF9MSVNUX0hFQUQoJnMtPnNfZmlsZXMpOwoJCUlOSVRfTElTVF9IRUFEKCZzLT5zX2luc3RhbmNlcyk7CgkJSU5JVF9ITElTVF9IRUFEKCZzLT5zX2Fub24pOwoJCUlOSVRfTElTVF9IRUFEKCZzLT5zX2lub2Rlcyk7CgkJaW5pdF9yd3NlbSgmcy0+c191bW91bnQpOwoJCW11dGV4X2luaXQoJnMtPnNfbG9jayk7CgkJbG9ja2RlcF9zZXRfY2xhc3MoJnMtPnNfdW1vdW50LCAmdHlwZS0+c191bW91bnRfa2V5KTsKCQkvKgoJCSAqIFRoZSBsb2NraW5nIHJ1bGVzIGZvciBzX2xvY2sgYXJlIHVwIHRvIHRoZQoJCSAqIGZpbGVzeXN0ZW0uIEZvciBleGFtcGxlIGV4dDNmcyBoYXMgZGlmZmVyZW50CgkJICogbG9jayBvcmRlcmluZyB0aGFuIHVzYmZzOgoJCSAqLwoJCWxvY2tkZXBfc2V0X2NsYXNzKCZzLT5zX2xvY2ssICZ0eXBlLT5zX2xvY2tfa2V5KTsKCQlkb3duX3dyaXRlKCZzLT5zX3Vtb3VudCk7CgkJcy0+c19jb3VudCA9IFNfQklBUzsKCQlhdG9taWNfc2V0KCZzLT5zX2FjdGl2ZSwgMSk7CgkJbXV0ZXhfaW5pdCgmcy0+c192ZnNfcmVuYW1lX211dGV4KTsKCQltdXRleF9pbml0KCZzLT5zX2RxdW90LmRxaW9fbXV0ZXgpOwoJCW11dGV4X2luaXQoJnMtPnNfZHF1b3QuZHFvbm9mZl9tdXRleCk7CgkJaW5pdF9yd3NlbSgmcy0+c19kcXVvdC5kcXB0cl9zZW0pOwoJCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnMtPnNfd2FpdF91bmZyb3plbik7CgkJcy0+c19tYXhieXRlcyA9IE1BWF9OT05fTEZTOwoJCXMtPmRxX29wID0gc2JfZHF1b3Rfb3BzOwoJCXMtPnNfcWNvcCA9IHNiX3F1b3RhY3RsX29wczsKCQlzLT5zX29wID0gJmRlZmF1bHRfb3A7CgkJcy0+c190aW1lX2dyYW4gPSAxMDAwMDAwMDAwOwoJfQpvdXQ6CglyZXR1cm4gczsKfQoKLyoqCiAqCWRlc3Ryb3lfc3VwZXIJLQlmcmVlcyBhIHN1cGVyYmxvY2sKICoJQHM6IHN1cGVyYmxvY2sgdG8gZnJlZQogKgogKglGcmVlcyBhIHN1cGVyYmxvY2suCiAqLwpzdGF0aWMgaW5saW5lIHZvaWQgZGVzdHJveV9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMpCnsKCXNlY3VyaXR5X3NiX2ZyZWUocyk7CglrZnJlZShzLT5zX3N1YnR5cGUpOwoJa2ZyZWUocyk7Cn0KCi8qIFN1cGVyYmxvY2sgcmVmY291bnRpbmcgICovCgovKgogKiBEcm9wIGEgc3VwZXJibG9jaydzIHJlZmNvdW50LiAgUmV0dXJucyBub24temVybyBpZiB0aGUgc3VwZXJibG9jayB3YXMKICogZGVzdHJveWVkLiAgVGhlIGNhbGxlciBtdXN0IGhvbGQgc2JfbG9jay4KICovCmludCBfX3B1dF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglpbnQgcmV0ID0gMDsKCglpZiAoIS0tc2ItPnNfY291bnQpIHsKCQlkZXN0cm95X3N1cGVyKHNiKTsKCQlyZXQgPSAxOwoJfQoJcmV0dXJuIHJldDsKfQoKLyoKICogRHJvcCBhIHN1cGVyYmxvY2sncyByZWZjb3VudC4KICogUmV0dXJucyBub24temVybyBpZiB0aGUgc3VwZXJibG9jayBpcyBhYm91dCB0byBiZSBkZXN0cm95ZWQgYW5kCiAqIGF0IGxlYXN0IGlzIGFscmVhZHkgcmVtb3ZlZCBmcm9tIHN1cGVyX2Jsb2NrcyBsaXN0LCBzbyBpZiB3ZSBhcmUKICogbWFraW5nIGEgbG9vcCB0aHJvdWdoIHN1cGVyIGJsb2NrcyB0aGVuIHdlIG5lZWQgdG8gcmVzdGFydC4KICogVGhlIGNhbGxlciBtdXN0IGhvbGQgc2JfbG9jay4KICovCmludCBfX3B1dF9zdXBlcl9hbmRfbmVlZF9yZXN0YXJ0KHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCS8qIGNoZWNrIGZvciByYWNlIHdpdGggZ2VuZXJpY19zaHV0ZG93bl9zdXBlcigpICovCglpZiAobGlzdF9lbXB0eSgmc2ItPnNfbGlzdCkpIHsKCQkvKiBzdXBlciBibG9jayBpcyByZW1vdmVkLCBuZWVkIHRvIHJlc3RhcnQuLi4gKi8KCQlfX3B1dF9zdXBlcihzYik7CgkJcmV0dXJuIDE7Cgl9CgkvKiBjYW4ndCBiZSB0aGUgbGFzdCwgc2luY2Ugc19saXN0IGlzIHN0aWxsIGluIHVzZSAqLwoJc2ItPnNfY291bnQtLTsKCUJVR19PTihzYi0+c19jb3VudCA9PSAwKTsKCXJldHVybiAwOwp9CgovKioKICoJcHV0X3N1cGVyCS0JZHJvcCBhIHRlbXBvcmFyeSByZWZlcmVuY2UgdG8gc3VwZXJibG9jawogKglAc2I6IHN1cGVyYmxvY2sgaW4gcXVlc3Rpb24KICoKICoJRHJvcHMgYSB0ZW1wb3JhcnkgcmVmZXJlbmNlLCBmcmVlcyBzdXBlcmJsb2NrIGlmIHRoZXJlJ3Mgbm8KICoJcmVmZXJlbmNlcyBsZWZ0LgogKi8Kc3RhdGljIHZvaWQgcHV0X3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCXNwaW5fbG9jaygmc2JfbG9jayk7CglfX3B1dF9zdXBlcihzYik7CglzcGluX3VubG9jaygmc2JfbG9jayk7Cn0KCgovKioKICoJZGVhY3RpdmF0ZV9zdXBlcgktCWRyb3AgYW4gYWN0aXZlIHJlZmVyZW5jZSB0byBzdXBlcmJsb2NrCiAqCUBzOiBzdXBlcmJsb2NrIHRvIGRlYWN0aXZhdGUKICoKICoJRHJvcHMgYW4gYWN0aXZlIHJlZmVyZW5jZSB0byBzdXBlcmJsb2NrLCBhY3F1aXJpbmcgYSB0ZW1wcm9yeSBvbmUgaWYKICoJdGhlcmUgaXMgbm8gYWN0aXZlIHJlZmVyZW5jZXMgbGVmdC4gIEluIHRoYXQgY2FzZSB3ZSBsb2NrIHN1cGVyYmxvY2ssCiAqCXRlbGwgZnMgZHJpdmVyIHRvIHNodXQgaXQgZG93biBhbmQgZHJvcCB0aGUgdGVtcG9yYXJ5IHJlZmVyZW5jZSB3ZQogKgloYWQganVzdCBhY3F1aXJlZC4KICovCnZvaWQgZGVhY3RpdmF0ZV9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMpCnsKCXN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICpmcyA9IHMtPnNfdHlwZTsKCWlmIChhdG9taWNfZGVjX2FuZF9sb2NrKCZzLT5zX2FjdGl2ZSwgJnNiX2xvY2spKSB7CgkJcy0+c19jb3VudCAtPSBTX0JJQVMtMTsKCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJRFFVT1RfT0ZGKHMpOwoJCWRvd25fd3JpdGUoJnMtPnNfdW1vdW50KTsKCQlmcy0+a2lsbF9zYihzKTsKCQlwdXRfZmlsZXN5c3RlbShmcyk7CgkJcHV0X3N1cGVyKHMpOwoJfQp9CgpFWFBPUlRfU1lNQk9MKGRlYWN0aXZhdGVfc3VwZXIpOwoKLyoqCiAqCWdyYWJfc3VwZXIgLSBhY3F1aXJlIGFuIGFjdGl2ZSByZWZlcmVuY2UKICoJQHM6IHJlZmVyZW5jZSB3ZSBhcmUgdHJ5aW5nIHRvIG1ha2UgYWN0aXZlCiAqCiAqCVRyaWVzIHRvIGFjcXVpcmUgYW4gYWN0aXZlIHJlZmVyZW5jZS4gIGdyYWJfc3VwZXIoKSBpcyB1c2VkIHdoZW4gd2UKICogCWhhZCBqdXN0IGZvdW5kIGEgc3VwZXJibG9jayBpbiBzdXBlcl9ibG9ja3Mgb3IgZnNfdHlwZS0+ZnNfc3VwZXJzCiAqCWFuZCB3YW50IHRvIHR1cm4gaXQgaW50byBhIGZ1bGwtYmxvd24gYWN0aXZlIHJlZmVyZW5jZS4gIGdyYWJfc3VwZXIoKQogKglpcyBjYWxsZWQgd2l0aCBzYl9sb2NrIGhlbGQgYW5kIGRyb3BzIGl0LiAgUmV0dXJucyAxIGluIGNhc2Ugb2YKICoJc3VjY2VzcywgMCBpZiB3ZSBoYWQgZmFpbGVkIChzdXBlcmJsb2NrIGNvbnRlbnRzIHdhcyBhbHJlYWR5IGRlYWQgb3IKICoJZHlpbmcgd2hlbiBncmFiX3N1cGVyKCkgaGFkIGJlZW4gY2FsbGVkKS4KICovCnN0YXRpYyBpbnQgZ3JhYl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMpIF9fcmVsZWFzZXMoc2JfbG9jaykKewoJcy0+c19jb3VudCsrOwoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJZG93bl93cml0ZSgmcy0+c191bW91bnQpOwoJaWYgKHMtPnNfcm9vdCkgewoJCXNwaW5fbG9jaygmc2JfbG9jayk7CgkJaWYgKHMtPnNfY291bnQgPiBTX0JJQVMpIHsKCQkJYXRvbWljX2luYygmcy0+c19hY3RpdmUpOwoJCQlzLT5zX2NvdW50LS07CgkJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCQkJcmV0dXJuIDE7CgkJfQoJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCX0KCXVwX3dyaXRlKCZzLT5zX3Vtb3VudCk7CglwdXRfc3VwZXIocyk7Cgl5aWVsZCgpOwoJcmV0dXJuIDA7Cn0KCi8qCiAqIFN1cGVyYmxvY2sgbG9ja2luZy4gIFdlIHJlYWxseSBvdWdodCB0byBnZXQgcmlkIG9mIHRoZXNlIHR3by4KICovCnZvaWQgbG9ja19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiBzYikKewoJZ2V0X2ZzX2V4Y2woKTsKCW11dGV4X2xvY2soJnNiLT5zX2xvY2spOwp9Cgp2b2lkIHVubG9ja19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiBzYikKewoJcHV0X2ZzX2V4Y2woKTsKCW11dGV4X3VubG9jaygmc2ItPnNfbG9jayk7Cn0KCkVYUE9SVF9TWU1CT0wobG9ja19zdXBlcik7CkVYUE9SVF9TWU1CT0wodW5sb2NrX3N1cGVyKTsKCi8qCiAqIFdyaXRlIG91dCBhbmQgd2FpdCB1cG9uIGFsbCBkaXJ0eSBkYXRhIGFzc29jaWF0ZWQgd2l0aCB0aGlzCiAqIHN1cGVyYmxvY2suICBGaWxlc3lzdGVtIGRhdGEgYXMgd2VsbCBhcyB0aGUgdW5kZXJseWluZyBibG9jawogKiBkZXZpY2UuICBUYWtlcyB0aGUgc3VwZXJibG9jayBsb2NrLiAgUmVxdWlyZXMgYSBzZWNvbmQgYmxrZGV2CiAqIGZsdXNoIGJ5IHRoZSBjYWxsZXIgdG8gY29tcGxldGUgdGhlIG9wZXJhdGlvbi4KICovCnZvaWQgX19mc3luY19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglzeW5jX2lub2Rlc19zYihzYiwgMCk7CglEUVVPVF9TWU5DKHNiKTsKCWxvY2tfc3VwZXIoc2IpOwoJaWYgKHNiLT5zX2RpcnQgJiYgc2ItPnNfb3AtPndyaXRlX3N1cGVyKQoJCXNiLT5zX29wLT53cml0ZV9zdXBlcihzYik7Cgl1bmxvY2tfc3VwZXIoc2IpOwoJaWYgKHNiLT5zX29wLT5zeW5jX2ZzKQoJCXNiLT5zX29wLT5zeW5jX2ZzKHNiLCAxKTsKCXN5bmNfYmxvY2tkZXYoc2ItPnNfYmRldik7CglzeW5jX2lub2Rlc19zYihzYiwgMSk7Cn0KCi8qCiAqIFdyaXRlIG91dCBhbmQgd2FpdCB1cG9uIGFsbCBkaXJ0eSBkYXRhIGFzc29jaWF0ZWQgd2l0aCB0aGlzCiAqIHN1cGVyYmxvY2suICBGaWxlc3lzdGVtIGRhdGEgYXMgd2VsbCBhcyB0aGUgdW5kZXJseWluZyBibG9jawogKiBkZXZpY2UuICBUYWtlcyB0aGUgc3VwZXJibG9jayBsb2NrLgogKi8KaW50IGZzeW5jX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCV9fZnN5bmNfc3VwZXIoc2IpOwoJcmV0dXJuIHN5bmNfYmxvY2tkZXYoc2ItPnNfYmRldik7Cn0KCi8qKgogKglnZW5lcmljX3NodXRkb3duX3N1cGVyCS0JY29tbW9uIGhlbHBlciBmb3IgLT5raWxsX3NiKCkKICoJQHNiOiBzdXBlcmJsb2NrIHRvIGtpbGwKICoKICoJZ2VuZXJpY19zaHV0ZG93bl9zdXBlcigpIGRvZXMgYWxsIGZzLWluZGVwZW5kZW50IHdvcmsgb24gc3VwZXJibG9jawogKglzaHV0ZG93bi4gIFR5cGljYWwgLT5raWxsX3NiKCkgc2hvdWxkIHBpY2sgYWxsIGZzLXNwZWNpZmljIG9iamVjdHMKICoJdGhhdCBuZWVkIGRlc3RydWN0aW9uIG91dCBvZiBzdXBlcmJsb2NrLCBjYWxsIGdlbmVyaWNfc2h1dGRvd25fc3VwZXIoKQogKglhbmQgcmVsZWFzZSBhZm9yZW1lbnRpb25lZCBvYmplY3RzLiAgTm90ZTogZGVudHJpZXMgYW5kIGlub2RlcyBfYXJlXwogKgl0YWtlbiBjYXJlIG9mIGFuZCBkbyBub3QgbmVlZCBzcGVjaWZpYyBoYW5kbGluZy4KICoKICoJVXBvbiBjYWxsaW5nIHRoaXMgZnVuY3Rpb24sIHRoZSBmaWxlc3lzdGVtIG1heSBubyBsb25nZXIgYWx0ZXIgb3IKICoJcmVhcnJhbmdlIHRoZSBzZXQgb2YgZGVudHJpZXMgYmVsb25naW5nIHRvIHRoaXMgc3VwZXJfYmxvY2ssIG5vciBtYXkgaXQKICoJY2hhbmdlIHRoZSBhdHRhY2htZW50cyBvZiBkZW50cmllcyB0byBpbm9kZXMuCiAqLwp2b2lkIGdlbmVyaWNfc2h1dGRvd25fc3VwZXIoc3RydWN0IHN1cGVyX2Jsb2NrICpzYikKewoJY29uc3Qgc3RydWN0IHN1cGVyX29wZXJhdGlvbnMgKnNvcCA9IHNiLT5zX29wOwoKCWlmIChzYi0+c19yb290KSB7CgkJc2hyaW5rX2RjYWNoZV9mb3JfdW1vdW50KHNiKTsKCQlmc3luY19zdXBlcihzYik7CgkJbG9ja19zdXBlcihzYik7CgkJc2ItPnNfZmxhZ3MgJj0gfk1TX0FDVElWRTsKCQkvKiBiYWQgbmFtZSAtIGl0IHNob3VsZCBiZSBldmljdF9pbm9kZXMoKSAqLwoJCWludmFsaWRhdGVfaW5vZGVzKHNiKTsKCQlsb2NrX2tlcm5lbCgpOwoKCQlpZiAoc29wLT53cml0ZV9zdXBlciAmJiBzYi0+c19kaXJ0KQoJCQlzb3AtPndyaXRlX3N1cGVyKHNiKTsKCQlpZiAoc29wLT5wdXRfc3VwZXIpCgkJCXNvcC0+cHV0X3N1cGVyKHNiKTsKCgkJLyogRm9yZ2V0IGFueSByZW1haW5pbmcgaW5vZGVzICovCgkJaWYgKGludmFsaWRhdGVfaW5vZGVzKHNiKSkgewoJCQlwcmludGsoIlZGUzogQnVzeSBpbm9kZXMgYWZ0ZXIgdW5tb3VudCBvZiAlcy4gIgoJCQkgICAiU2VsZi1kZXN0cnVjdCBpbiA1IHNlY29uZHMuICBIYXZlIGEgbmljZSBkYXkuLi5cbiIsCgkJCSAgIHNiLT5zX2lkKTsKCQl9CgoJCXVubG9ja19rZXJuZWwoKTsKCQl1bmxvY2tfc3VwZXIoc2IpOwoJfQoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCS8qIHNob3VsZCBiZSBpbml0aWFsaXplZCBmb3IgX19wdXRfc3VwZXJfYW5kX25lZWRfcmVzdGFydCgpICovCglsaXN0X2RlbF9pbml0KCZzYi0+c19saXN0KTsKCWxpc3RfZGVsKCZzYi0+c19pbnN0YW5jZXMpOwoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJdXBfd3JpdGUoJnNiLT5zX3Vtb3VudCk7Cn0KCkVYUE9SVF9TWU1CT0woZ2VuZXJpY19zaHV0ZG93bl9zdXBlcik7CgovKioKICoJc2dldAktCWZpbmQgb3IgY3JlYXRlIGEgc3VwZXJibG9jawogKglAdHlwZToJZmlsZXN5c3RlbSB0eXBlIHN1cGVyYmxvY2sgc2hvdWxkIGJlbG9uZyB0bwogKglAdGVzdDoJY29tcGFyaXNvbiBjYWxsYmFjawogKglAc2V0OglzZXR1cCBjYWxsYmFjawogKglAZGF0YToJYXJndW1lbnQgdG8gZWFjaCBvZiB0aGVtCiAqLwpzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNnZXQoc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgKnR5cGUsCgkJCWludCAoKnRlc3QpKHN0cnVjdCBzdXBlcl9ibG9jayAqLHZvaWQgKiksCgkJCWludCAoKnNldCkoc3RydWN0IHN1cGVyX2Jsb2NrICosdm9pZCAqKSwKCQkJdm9pZCAqZGF0YSkKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzID0gTlVMTDsKCXN0cnVjdCBzdXBlcl9ibG9jayAqb2xkOwoJaW50IGVycjsKCnJldHJ5OgoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCWlmICh0ZXN0KSB7CgkJbGlzdF9mb3JfZWFjaF9lbnRyeShvbGQsICZ0eXBlLT5mc19zdXBlcnMsIHNfaW5zdGFuY2VzKSB7CgkJCWlmICghdGVzdChvbGQsIGRhdGEpKQoJCQkJY29udGludWU7CgkJCWlmICghZ3JhYl9zdXBlcihvbGQpKQoJCQkJZ290byByZXRyeTsKCQkJaWYgKHMpCgkJCQlkZXN0cm95X3N1cGVyKHMpOwoJCQlyZXR1cm4gb2xkOwoJCX0KCX0KCWlmICghcykgewoJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCQlzID0gYWxsb2Nfc3VwZXIodHlwZSk7CgkJaWYgKCFzKQoJCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKCQlnb3RvIHJldHJ5OwoJfQoJCQoJZXJyID0gc2V0KHMsIGRhdGEpOwoJaWYgKGVycikgewoJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCQlkZXN0cm95X3N1cGVyKHMpOwoJCXJldHVybiBFUlJfUFRSKGVycik7Cgl9CglzLT5zX3R5cGUgPSB0eXBlOwoJc3RybGNweShzLT5zX2lkLCB0eXBlLT5uYW1lLCBzaXplb2Yocy0+c19pZCkpOwoJbGlzdF9hZGRfdGFpbCgmcy0+c19saXN0LCAmc3VwZXJfYmxvY2tzKTsKCWxpc3RfYWRkKCZzLT5zX2luc3RhbmNlcywgJnR5cGUtPmZzX3N1cGVycyk7CglzcGluX3VubG9jaygmc2JfbG9jayk7CglnZXRfZmlsZXN5c3RlbSh0eXBlKTsKCXJldHVybiBzOwp9CgpFWFBPUlRfU1lNQk9MKHNnZXQpOwoKdm9pZCBkcm9wX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCXVwX3JlYWQoJnNiLT5zX3Vtb3VudCk7CglwdXRfc3VwZXIoc2IpOwp9CgpFWFBPUlRfU1lNQk9MKGRyb3Bfc3VwZXIpOwoKc3RhdGljIGlubGluZSB2b2lkIHdyaXRlX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCWxvY2tfc3VwZXIoc2IpOwoJaWYgKHNiLT5zX3Jvb3QgJiYgc2ItPnNfZGlydCkKCQlpZiAoc2ItPnNfb3AtPndyaXRlX3N1cGVyKQoJCQlzYi0+c19vcC0+d3JpdGVfc3VwZXIoc2IpOwoJdW5sb2NrX3N1cGVyKHNiKTsKfQoKLyoKICogTm90ZTogY2hlY2sgdGhlIGRpcnR5IGZsYWcgYmVmb3JlIHdhaXRpbmcsIHNvIHdlIGRvbid0CiAqIGhvbGQgdXAgdGhlIHN5bmMgd2hpbGUgbW91bnRpbmcgYSBkZXZpY2UuIChUaGUgbmV3bHkKICogbW91bnRlZCBkZXZpY2Ugd29uJ3QgbmVlZCBzeW5jaW5nLikKICovCnZvaWQgc3luY19zdXBlcnModm9pZCkKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzYjsKCglzcGluX2xvY2soJnNiX2xvY2spOwpyZXN0YXJ0OgoJbGlzdF9mb3JfZWFjaF9lbnRyeShzYiwgJnN1cGVyX2Jsb2Nrcywgc19saXN0KSB7CgkJaWYgKHNiLT5zX2RpcnQpIHsKCQkJc2ItPnNfY291bnQrKzsKCQkJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJCQlkb3duX3JlYWQoJnNiLT5zX3Vtb3VudCk7CgkJCXdyaXRlX3N1cGVyKHNiKTsKCQkJdXBfcmVhZCgmc2ItPnNfdW1vdW50KTsKCQkJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCQkJaWYgKF9fcHV0X3N1cGVyX2FuZF9uZWVkX3Jlc3RhcnQoc2IpKQoJCQkJZ290byByZXN0YXJ0OwoJCX0KCX0KCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKfQoKLyoKICogQ2FsbCB0aGUgLT5zeW5jX2ZzIHN1cGVyX29wIGFnYWluc3QgYWxsIGZpbGVzeXRlbXMgd2hpY2ggYXJlIHIvdyBhbmQKICogd2hpY2ggaW1wbGVtZW50IGl0LgogKgogKiBUaGlzIG9wZXJhdGlvbiBpcyBjYXJlZnVsIHRvIGF2b2lkIHRoZSBsaXZlbG9jayB3aGljaCBjb3VsZCBlYXNpbHkgaGFwcGVuCiAqIGlmIHR3byBvciBtb3JlIGZpbGVzeXN0ZW1zIGFyZSBiZWluZyBjb250aW51b3VzbHkgZGlydGllZC4gIHNfbmVlZF9zeW5jX2ZzCiAqIGlzIHVzZWQgb25seSBoZXJlLiAgV2Ugc2V0IGl0IGFnYWluc3QgYWxsIGZpbGVzeXN0ZW1zIGFuZCB0aGVuIGNsZWFyIGl0IGFzCiAqIHdlIHN5bmMgdGhlbS4gIFNvIHJlZGlydGllZCBmaWxlc3lzdGVtcyBhcmUgc2tpcHBlZC4KICoKICogQnV0IGlmIHByb2Nlc3MgQSBpcyBjdXJyZW50bHkgcnVubmluZyBzeW5jX2ZpbGVzeXRlbXMgYW5kIHRoZW4gcHJvY2VzcyBCCiAqIGNhbGxzIHN5bmNfZmlsZXN5c3RlbXMgYXMgd2VsbCwgcHJvY2VzcyBCIHdpbGwgc2V0IGFsbCB0aGUgc19uZWVkX3N5bmNfZnMKICogZmxhZ3MgYWdhaW4sIHdoaWNoIHdpbGwgY2F1c2UgcHJvY2VzcyBBIHRvIHJlc3luYyBldmVyeXRoaW5nLiAgRml4IHRoYXQgd2l0aAogKiBhIGxvY2FsIG11dGV4LgogKgogKiAoRmFiaWFuKSBBdm9pZCBzeW5jX2ZzIHdpdGggY2xlYW4gZnMgJiB3YWl0IG1vZGUgMAogKi8Kdm9pZCBzeW5jX2ZpbGVzeXN0ZW1zKGludCB3YWl0KQp7CglzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiOwoJc3RhdGljIERFRklORV9NVVRFWChtdXRleCk7CgoJbXV0ZXhfbG9jaygmbXV0ZXgpOwkJLyogQ291bGQgYmUgZG93bl9pbnRlcnJ1cHRpYmxlICovCglzcGluX2xvY2soJnNiX2xvY2spOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShzYiwgJnN1cGVyX2Jsb2Nrcywgc19saXN0KSB7CgkJaWYgKCFzYi0+c19vcC0+c3luY19mcykKCQkJY29udGludWU7CgkJaWYgKHNiLT5zX2ZsYWdzICYgTVNfUkRPTkxZKQoJCQljb250aW51ZTsKCQlzYi0+c19uZWVkX3N5bmNfZnMgPSAxOwoJfQoKcmVzdGFydDoKCWxpc3RfZm9yX2VhY2hfZW50cnkoc2IsICZzdXBlcl9ibG9ja3MsIHNfbGlzdCkgewoJCWlmICghc2ItPnNfbmVlZF9zeW5jX2ZzKQoJCQljb250aW51ZTsKCQlzYi0+c19uZWVkX3N5bmNfZnMgPSAwOwoJCWlmIChzYi0+c19mbGFncyAmIE1TX1JET05MWSkKCQkJY29udGludWU7CS8qIGhtLiAgV2FzIHJlbW91bnRlZCByL28gbWVhbndoaWxlICovCgkJc2ItPnNfY291bnQrKzsKCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJZG93bl9yZWFkKCZzYi0+c191bW91bnQpOwoJCWlmIChzYi0+c19yb290ICYmICh3YWl0IHx8IHNiLT5zX2RpcnQpKQoJCQlzYi0+c19vcC0+c3luY19mcyhzYiwgd2FpdCk7CgkJdXBfcmVhZCgmc2ItPnNfdW1vdW50KTsKCQkvKiByZXN0YXJ0IG9ubHkgd2hlbiBzYiBpcyBubyBsb25nZXIgb24gdGhlIGxpc3QgKi8KCQlzcGluX2xvY2soJnNiX2xvY2spOwoJCWlmIChfX3B1dF9zdXBlcl9hbmRfbmVlZF9yZXN0YXJ0KHNiKSkKCQkJZ290byByZXN0YXJ0OwoJfQoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJbXV0ZXhfdW5sb2NrKCZtdXRleCk7Cn0KCi8qKgogKglnZXRfc3VwZXIgLSBnZXQgdGhlIHN1cGVyYmxvY2sgb2YgYSBkZXZpY2UKICoJQGJkZXY6IGRldmljZSB0byBnZXQgdGhlIHN1cGVyYmxvY2sgZm9yCiAqCQogKglTY2FucyB0aGUgc3VwZXJibG9jayBsaXN0IGFuZCBmaW5kcyB0aGUgc3VwZXJibG9jayBvZiB0aGUgZmlsZSBzeXN0ZW0KICoJbW91bnRlZCBvbiB0aGUgZGV2aWNlIGdpdmVuLiAlTlVMTCBpcyByZXR1cm5lZCBpZiBubyBtYXRjaCBpcyBmb3VuZC4KICovCgpzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiBnZXRfc3VwZXIoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldikKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzYjsKCglpZiAoIWJkZXYpCgkJcmV0dXJuIE5VTEw7CgoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKcmVzY2FuOgoJbGlzdF9mb3JfZWFjaF9lbnRyeShzYiwgJnN1cGVyX2Jsb2Nrcywgc19saXN0KSB7CgkJaWYgKHNiLT5zX2JkZXYgPT0gYmRldikgewoJCQlzYi0+c19jb3VudCsrOwoJCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJCWRvd25fcmVhZCgmc2ItPnNfdW1vdW50KTsKCQkJaWYgKHNiLT5zX3Jvb3QpCgkJCQlyZXR1cm4gc2I7CgkJCXVwX3JlYWQoJnNiLT5zX3Vtb3VudCk7CgkJCS8qIHJlc3RhcnQgb25seSB3aGVuIHNiIGlzIG5vIGxvbmdlciBvbiB0aGUgbGlzdCAqLwoJCQlzcGluX2xvY2soJnNiX2xvY2spOwoJCQlpZiAoX19wdXRfc3VwZXJfYW5kX25lZWRfcmVzdGFydChzYikpCgkJCQlnb3RvIHJlc2NhbjsKCQl9Cgl9CglzcGluX3VubG9jaygmc2JfbG9jayk7CglyZXR1cm4gTlVMTDsKfQoKRVhQT1JUX1NZTUJPTChnZXRfc3VwZXIpOwogCnN0cnVjdCBzdXBlcl9ibG9jayAqIHVzZXJfZ2V0X3N1cGVyKGRldl90IGRldikKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzYjsKCglzcGluX2xvY2soJnNiX2xvY2spOwpyZXNjYW46CglsaXN0X2Zvcl9lYWNoX2VudHJ5KHNiLCAmc3VwZXJfYmxvY2tzLCBzX2xpc3QpIHsKCQlpZiAoc2ItPnNfZGV2ID09ICBkZXYpIHsKCQkJc2ItPnNfY291bnQrKzsKCQkJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJCQlkb3duX3JlYWQoJnNiLT5zX3Vtb3VudCk7CgkJCWlmIChzYi0+c19yb290KQoJCQkJcmV0dXJuIHNiOwoJCQl1cF9yZWFkKCZzYi0+c191bW91bnQpOwoJCQkvKiByZXN0YXJ0IG9ubHkgd2hlbiBzYiBpcyBubyBsb25nZXIgb24gdGhlIGxpc3QgKi8KCQkJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCQkJaWYgKF9fcHV0X3N1cGVyX2FuZF9uZWVkX3Jlc3RhcnQoc2IpKQoJCQkJZ290byByZXNjYW47CgkJfQoJfQoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJcmV0dXJuIE5VTEw7Cn0KCmFzbWxpbmthZ2UgbG9uZyBzeXNfdXN0YXQodW5zaWduZWQgZGV2LCBzdHJ1Y3QgdXN0YXQgX191c2VyICogdWJ1ZikKewogICAgICAgIHN0cnVjdCBzdXBlcl9ibG9jayAqczsKICAgICAgICBzdHJ1Y3QgdXN0YXQgdG1wOwogICAgICAgIHN0cnVjdCBrc3RhdGZzIHNidWY7CglpbnQgZXJyID0gLUVJTlZBTDsKCiAgICAgICAgcyA9IHVzZXJfZ2V0X3N1cGVyKG5ld19kZWNvZGVfZGV2KGRldikpOwogICAgICAgIGlmIChzID09IE5VTEwpCiAgICAgICAgICAgICAgICBnb3RvIG91dDsKCWVyciA9IHZmc19zdGF0ZnMocy0+c19yb290LCAmc2J1Zik7Cglkcm9wX3N1cGVyKHMpOwoJaWYgKGVycikKCQlnb3RvIG91dDsKCiAgICAgICAgbWVtc2V0KCZ0bXAsMCxzaXplb2Yoc3RydWN0IHVzdGF0KSk7CiAgICAgICAgdG1wLmZfdGZyZWUgPSBzYnVmLmZfYmZyZWU7CiAgICAgICAgdG1wLmZfdGlub2RlID0gc2J1Zi5mX2ZmcmVlOwoKICAgICAgICBlcnIgPSBjb3B5X3RvX3VzZXIodWJ1ZiwmdG1wLHNpemVvZihzdHJ1Y3QgdXN0YXQpKSA/IC1FRkFVTFQgOiAwOwpvdXQ6CglyZXR1cm4gZXJyOwp9CgovKioKICoJbWFya19maWxlc19ybwogKglAc2I6IHN1cGVyYmxvY2sgaW4gcXVlc3Rpb24KICoKICoJQWxsIGZpbGVzIGFyZSBtYXJrZWQgcmVhZC9vbmx5LiAgV2UgZG9uJ3QgY2FyZSBhYm91dCBwZW5kaW5nCiAqCWRlbGV0ZSBmaWxlcyBzbyB0aGlzIHNob3VsZCBiZSB1c2VkIGluICdmb3JjZScgbW9kZSBvbmx5CiAqLwoKc3RhdGljIHZvaWQgbWFya19maWxlc19ybyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglzdHJ1Y3QgZmlsZSAqZjsKCglmaWxlX2xpc3RfbG9jaygpOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShmLCAmc2ItPnNfZmlsZXMsIGZfdS5mdV9saXN0KSB7CgkJaWYgKFNfSVNSRUcoZi0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZS0+aV9tb2RlKSAmJiBmaWxlX2NvdW50KGYpKQoJCQlmLT5mX21vZGUgJj0gfkZNT0RFX1dSSVRFOwoJfQoJZmlsZV9saXN0X3VubG9jaygpOwp9CgovKioKICoJZG9fcmVtb3VudF9zYiAtIGFza3MgZmlsZXN5c3RlbSB0byBjaGFuZ2UgbW91bnQgb3B0aW9ucy4KICoJQHNiOglzdXBlcmJsb2NrIGluIHF1ZXN0aW9uCiAqCUBmbGFnczoJbnVtZXJpYyBwYXJ0IG9mIG9wdGlvbnMKICoJQGRhdGE6CXRoZSByZXN0IG9mIG9wdGlvbnMKICogICAgICBAZm9yY2U6IHdoZXRoZXIgb3Igbm90IHRvIGZvcmNlIHRoZSBjaGFuZ2UKICoKICoJQWx0ZXJzIHRoZSBtb3VudCBvcHRpb25zIG9mIGEgbW91bnRlZCBmaWxlIHN5c3RlbS4KICovCmludCBkb19yZW1vdW50X3NiKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IsIGludCBmbGFncywgdm9pZCAqZGF0YSwgaW50IGZvcmNlKQp7CglpbnQgcmV0dmFsOwoJCiNpZmRlZiBDT05GSUdfQkxPQ0sKCWlmICghKGZsYWdzICYgTVNfUkRPTkxZKSAmJiBiZGV2X3JlYWRfb25seShzYi0+c19iZGV2KSkKCQlyZXR1cm4gLUVBQ0NFUzsKI2VuZGlmCglpZiAoZmxhZ3MgJiBNU19SRE9OTFkpCgkJYWNjdF9hdXRvX2Nsb3NlKHNiKTsKCXNocmlua19kY2FjaGVfc2Ioc2IpOwoJZnN5bmNfc3VwZXIoc2IpOwoKCS8qIElmIHdlIGFyZSByZW1vdW50aW5nIFJET05MWSBhbmQgY3VycmVudCBzYiBpcyByZWFkL3dyaXRlLAoJICAgbWFrZSBzdXJlIHRoZXJlIGFyZSBubyBydyBmaWxlcyBvcGVuZWQgKi8KCWlmICgoZmxhZ3MgJiBNU19SRE9OTFkpICYmICEoc2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpKSB7CgkJaWYgKGZvcmNlKQoJCQltYXJrX2ZpbGVzX3JvKHNiKTsKCQllbHNlIGlmICghZnNfbWF5X3JlbW91bnRfcm8oc2IpKQoJCQlyZXR1cm4gLUVCVVNZOwoJfQoKCWlmIChzYi0+c19vcC0+cmVtb3VudF9mcykgewoJCWxvY2tfc3VwZXIoc2IpOwoJCXJldHZhbCA9IHNiLT5zX29wLT5yZW1vdW50X2ZzKHNiLCAmZmxhZ3MsIGRhdGEpOwoJCXVubG9ja19zdXBlcihzYik7CgkJaWYgKHJldHZhbCkKCQkJcmV0dXJuIHJldHZhbDsKCX0KCXNiLT5zX2ZsYWdzID0gKHNiLT5zX2ZsYWdzICYgfk1TX1JNVF9NQVNLKSB8IChmbGFncyAmIE1TX1JNVF9NQVNLKTsKCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBkb19lbWVyZ2VuY3lfcmVtb3VudCh1bnNpZ25lZCBsb25nIGZvbykKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzYjsKCglzcGluX2xvY2soJnNiX2xvY2spOwoJbGlzdF9mb3JfZWFjaF9lbnRyeShzYiwgJnN1cGVyX2Jsb2Nrcywgc19saXN0KSB7CgkJc2ItPnNfY291bnQrKzsKCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJZG93bl9yZWFkKCZzYi0+c191bW91bnQpOwoJCWlmIChzYi0+c19yb290ICYmIHNiLT5zX2JkZXYgJiYgIShzYi0+c19mbGFncyAmIE1TX1JET05MWSkpIHsKCQkJLyoKCQkJICogLT5yZW1vdW50X2ZzIG5lZWRzIGxvY2tfa2VybmVsKCkuCgkJCSAqCgkJCSAqIFdoYXQgbG9jayBwcm90ZWN0cyBzYi0+c19mbGFncz8/CgkJCSAqLwoJCQlsb2NrX2tlcm5lbCgpOwoJCQlkb19yZW1vdW50X3NiKHNiLCBNU19SRE9OTFksIE5VTEwsIDEpOwoJCQl1bmxvY2tfa2VybmVsKCk7CgkJfQoJCWRyb3Bfc3VwZXIoc2IpOwoJCXNwaW5fbG9jaygmc2JfbG9jayk7Cgl9CglzcGluX3VubG9jaygmc2JfbG9jayk7CglwcmludGsoIkVtZXJnZW5jeSBSZW1vdW50IGNvbXBsZXRlXG4iKTsKfQoKdm9pZCBlbWVyZ2VuY3lfcmVtb3VudCh2b2lkKQp7CglwZGZsdXNoX29wZXJhdGlvbihkb19lbWVyZ2VuY3lfcmVtb3VudCwgMCk7Cn0KCi8qCiAqIFVubmFtZWQgYmxvY2sgZGV2aWNlcyBhcmUgZHVtbXkgZGV2aWNlcyB1c2VkIGJ5IHZpcnR1YWwKICogZmlsZXN5c3RlbXMgd2hpY2ggZG9uJ3QgdXNlIHJlYWwgYmxvY2stZGV2aWNlcy4gIC0tIGpycwogKi8KCnN0YXRpYyBzdHJ1Y3QgaWRyIHVubmFtZWRfZGV2X2lkcjsKc3RhdGljIERFRklORV9TUElOTE9DSyh1bm5hbWVkX2Rldl9sb2NrKTsvKiBwcm90ZWN0cyB0aGUgYWJvdmUgKi8KCmludCBzZXRfYW5vbl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMsIHZvaWQgKmRhdGEpCnsKCWludCBkZXY7CglpbnQgZXJyb3I7CgogcmV0cnk6CglpZiAoaWRyX3ByZV9nZXQoJnVubmFtZWRfZGV2X2lkciwgR0ZQX0FUT01JQykgPT0gMCkKCQlyZXR1cm4gLUVOT01FTTsKCXNwaW5fbG9jaygmdW5uYW1lZF9kZXZfbG9jayk7CgllcnJvciA9IGlkcl9nZXRfbmV3KCZ1bm5hbWVkX2Rldl9pZHIsIE5VTEwsICZkZXYpOwoJc3Bpbl91bmxvY2soJnVubmFtZWRfZGV2X2xvY2spOwoJaWYgKGVycm9yID09IC1FQUdBSU4pCgkJLyogV2UgcmFjZWQgYW5kIGxvc3Qgd2l0aCBhbm90aGVyIENQVS4gKi8KCQlnb3RvIHJldHJ5OwoJZWxzZSBpZiAoZXJyb3IpCgkJcmV0dXJuIC1FQUdBSU47CgoJaWYgKChkZXYgJiBNQVhfSURfTUFTSykgPT0gKDEgPDwgTUlOT1JCSVRTKSkgewoJCXNwaW5fbG9jaygmdW5uYW1lZF9kZXZfbG9jayk7CgkJaWRyX3JlbW92ZSgmdW5uYW1lZF9kZXZfaWRyLCBkZXYpOwoJCXNwaW5fdW5sb2NrKCZ1bm5hbWVkX2Rldl9sb2NrKTsKCQlyZXR1cm4gLUVNRklMRTsKCX0KCXMtPnNfZGV2ID0gTUtERVYoMCwgZGV2ICYgTUlOT1JNQVNLKTsKCXJldHVybiAwOwp9CgpFWFBPUlRfU1lNQk9MKHNldF9hbm9uX3N1cGVyKTsKCnZvaWQga2lsbF9hbm9uX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCWludCBzbG90ID0gTUlOT1Ioc2ItPnNfZGV2KTsKCglnZW5lcmljX3NodXRkb3duX3N1cGVyKHNiKTsKCXNwaW5fbG9jaygmdW5uYW1lZF9kZXZfbG9jayk7CglpZHJfcmVtb3ZlKCZ1bm5hbWVkX2Rldl9pZHIsIHNsb3QpOwoJc3Bpbl91bmxvY2soJnVubmFtZWRfZGV2X2xvY2spOwp9CgpFWFBPUlRfU1lNQk9MKGtpbGxfYW5vbl9zdXBlcik7Cgp2b2lkIF9faW5pdCB1bm5hbWVkX2Rldl9pbml0KHZvaWQpCnsKCWlkcl9pbml0KCZ1bm5hbWVkX2Rldl9pZHIpOwp9Cgp2b2lkIGtpbGxfbGl0dGVyX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCWlmIChzYi0+c19yb290KQoJCWRfZ2Vub2NpZGUoc2ItPnNfcm9vdCk7CglraWxsX2Fub25fc3VwZXIoc2IpOwp9CgpFWFBPUlRfU1lNQk9MKGtpbGxfbGl0dGVyX3N1cGVyKTsKCiNpZmRlZiBDT05GSUdfQkxPQ0sKc3RhdGljIGludCBzZXRfYmRldl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMsIHZvaWQgKmRhdGEpCnsKCXMtPnNfYmRldiA9IGRhdGE7CglzLT5zX2RldiA9IHMtPnNfYmRldi0+YmRfZGV2OwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgdGVzdF9iZGV2X3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqcywgdm9pZCAqZGF0YSkKewoJcmV0dXJuICh2b2lkICopcy0+c19iZGV2ID09IGRhdGE7Cn0KCmludCBnZXRfc2JfYmRldihzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqZnNfdHlwZSwKCWludCBmbGFncywgY29uc3QgY2hhciAqZGV2X25hbWUsIHZvaWQgKmRhdGEsCglpbnQgKCpmaWxsX3N1cGVyKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgdm9pZCAqLCBpbnQpLAoJc3RydWN0IHZmc21vdW50ICptbnQpCnsKCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXY7CglzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnM7CglpbnQgZXJyb3IgPSAwOwoKCWJkZXYgPSBvcGVuX2JkZXZfZXhjbChkZXZfbmFtZSwgZmxhZ3MsIGZzX3R5cGUpOwoJaWYgKElTX0VSUihiZGV2KSkKCQlyZXR1cm4gUFRSX0VSUihiZGV2KTsKCgkvKgoJICogb25jZSB0aGUgc3VwZXIgaXMgaW5zZXJ0ZWQgaW50byB0aGUgbGlzdCBieSBzZ2V0LCBzX3Vtb3VudAoJICogd2lsbCBwcm90ZWN0IHRoZSBsb2NrZnMgY29kZSBmcm9tIHRyeWluZyB0byBzdGFydCBhIHNuYXBzaG90CgkgKiB3aGlsZSB3ZSBhcmUgbW91bnRpbmcKCSAqLwoJZG93bigmYmRldi0+YmRfbW91bnRfc2VtKTsKCXMgPSBzZ2V0KGZzX3R5cGUsIHRlc3RfYmRldl9zdXBlciwgc2V0X2JkZXZfc3VwZXIsIGJkZXYpOwoJdXAoJmJkZXYtPmJkX21vdW50X3NlbSk7CglpZiAoSVNfRVJSKHMpKQoJCWdvdG8gZXJyb3JfczsKCglpZiAocy0+c19yb290KSB7CgkJaWYgKChmbGFncyBeIHMtPnNfZmxhZ3MpICYgTVNfUkRPTkxZKSB7CgkJCXVwX3dyaXRlKCZzLT5zX3Vtb3VudCk7CgkJCWRlYWN0aXZhdGVfc3VwZXIocyk7CgkJCWVycm9yID0gLUVCVVNZOwoJCQlnb3RvIGVycm9yX2JkZXY7CgkJfQoKCQljbG9zZV9iZGV2X2V4Y2woYmRldik7Cgl9IGVsc2UgewoJCWNoYXIgYltCREVWTkFNRV9TSVpFXTsKCgkJcy0+c19mbGFncyA9IGZsYWdzOwoJCXN0cmxjcHkocy0+c19pZCwgYmRldm5hbWUoYmRldiwgYiksIHNpemVvZihzLT5zX2lkKSk7CgkJc2Jfc2V0X2Jsb2Nrc2l6ZShzLCBibG9ja19zaXplKGJkZXYpKTsKCQllcnJvciA9IGZpbGxfc3VwZXIocywgZGF0YSwgZmxhZ3MgJiBNU19TSUxFTlQgPyAxIDogMCk7CgkJaWYgKGVycm9yKSB7CgkJCXVwX3dyaXRlKCZzLT5zX3Vtb3VudCk7CgkJCWRlYWN0aXZhdGVfc3VwZXIocyk7CgkJCWdvdG8gZXJyb3I7CgkJfQoKCQlzLT5zX2ZsYWdzIHw9IE1TX0FDVElWRTsKCX0KCglyZXR1cm4gc2ltcGxlX3NldF9tbnQobW50LCBzKTsKCmVycm9yX3M6CgllcnJvciA9IFBUUl9FUlIocyk7CmVycm9yX2JkZXY6CgljbG9zZV9iZGV2X2V4Y2woYmRldik7CmVycm9yOgoJcmV0dXJuIGVycm9yOwp9CgpFWFBPUlRfU1lNQk9MKGdldF9zYl9iZGV2KTsKCnZvaWQga2lsbF9ibG9ja19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2ID0gc2ItPnNfYmRldjsKCglnZW5lcmljX3NodXRkb3duX3N1cGVyKHNiKTsKCXN5bmNfYmxvY2tkZXYoYmRldik7CgljbG9zZV9iZGV2X2V4Y2woYmRldik7Cn0KCkVYUE9SVF9TWU1CT0woa2lsbF9ibG9ja19zdXBlcik7CiNlbmRpZgoKaW50IGdldF9zYl9ub2RldihzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqZnNfdHlwZSwKCWludCBmbGFncywgdm9pZCAqZGF0YSwKCWludCAoKmZpbGxfc3VwZXIpKHN0cnVjdCBzdXBlcl9ibG9jayAqLCB2b2lkICosIGludCksCglzdHJ1Y3QgdmZzbW91bnQgKm1udCkKewoJaW50IGVycm9yOwoJc3RydWN0IHN1cGVyX2Jsb2NrICpzID0gc2dldChmc190eXBlLCBOVUxMLCBzZXRfYW5vbl9zdXBlciwgTlVMTCk7CgoJaWYgKElTX0VSUihzKSkKCQlyZXR1cm4gUFRSX0VSUihzKTsKCglzLT5zX2ZsYWdzID0gZmxhZ3M7CgoJZXJyb3IgPSBmaWxsX3N1cGVyKHMsIGRhdGEsIGZsYWdzICYgTVNfU0lMRU5UID8gMSA6IDApOwoJaWYgKGVycm9yKSB7CgkJdXBfd3JpdGUoJnMtPnNfdW1vdW50KTsKCQlkZWFjdGl2YXRlX3N1cGVyKHMpOwoJCXJldHVybiBlcnJvcjsKCX0KCXMtPnNfZmxhZ3MgfD0gTVNfQUNUSVZFOwoJcmV0dXJuIHNpbXBsZV9zZXRfbW50KG1udCwgcyk7Cn0KCkVYUE9SVF9TWU1CT0woZ2V0X3NiX25vZGV2KTsKCnN0YXRpYyBpbnQgY29tcGFyZV9zaW5nbGUoc3RydWN0IHN1cGVyX2Jsb2NrICpzLCB2b2lkICpwKQp7CglyZXR1cm4gMTsKfQoKaW50IGdldF9zYl9zaW5nbGUoc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgKmZzX3R5cGUsCglpbnQgZmxhZ3MsIHZvaWQgKmRhdGEsCglpbnQgKCpmaWxsX3N1cGVyKShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiwgdm9pZCAqLCBpbnQpLAoJc3RydWN0IHZmc21vdW50ICptbnQpCnsKCXN0cnVjdCBzdXBlcl9ibG9jayAqczsKCWludCBlcnJvcjsKCglzID0gc2dldChmc190eXBlLCBjb21wYXJlX3NpbmdsZSwgc2V0X2Fub25fc3VwZXIsIE5VTEwpOwoJaWYgKElTX0VSUihzKSkKCQlyZXR1cm4gUFRSX0VSUihzKTsKCWlmICghcy0+c19yb290KSB7CgkJcy0+c19mbGFncyA9IGZsYWdzOwoJCWVycm9yID0gZmlsbF9zdXBlcihzLCBkYXRhLCBmbGFncyAmIE1TX1NJTEVOVCA/IDEgOiAwKTsKCQlpZiAoZXJyb3IpIHsKCQkJdXBfd3JpdGUoJnMtPnNfdW1vdW50KTsKCQkJZGVhY3RpdmF0ZV9zdXBlcihzKTsKCQkJcmV0dXJuIGVycm9yOwoJCX0KCQlzLT5zX2ZsYWdzIHw9IE1TX0FDVElWRTsKCX0KCWRvX3JlbW91bnRfc2IocywgZmxhZ3MsIGRhdGEsIDApOwoJcmV0dXJuIHNpbXBsZV9zZXRfbW50KG1udCwgcyk7Cn0KCkVYUE9SVF9TWU1CT0woZ2V0X3NiX3NpbmdsZSk7CgpzdHJ1Y3QgdmZzbW91bnQgKgp2ZnNfa2Vybl9tb3VudChzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqdHlwZSwgaW50IGZsYWdzLCBjb25zdCBjaGFyICpuYW1lLCB2b2lkICpkYXRhKQp7CglzdHJ1Y3QgdmZzbW91bnQgKm1udDsKCWNoYXIgKnNlY2RhdGEgPSBOVUxMOwoJaW50IGVycm9yOwoKCWlmICghdHlwZSkKCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKCgllcnJvciA9IC1FTk9NRU07CgltbnQgPSBhbGxvY192ZnNtbnQobmFtZSk7CglpZiAoIW1udCkKCQlnb3RvIG91dDsKCglpZiAoZGF0YSkgewoJCXNlY2RhdGEgPSBhbGxvY19zZWNkYXRhKCk7CgkJaWYgKCFzZWNkYXRhKQoJCQlnb3RvIG91dF9tbnQ7CgoJCWVycm9yID0gc2VjdXJpdHlfc2JfY29weV9kYXRhKHR5cGUsIGRhdGEsIHNlY2RhdGEpOwoJCWlmIChlcnJvcikKCQkJZ290byBvdXRfZnJlZV9zZWNkYXRhOwoJfQoKCWVycm9yID0gdHlwZS0+Z2V0X3NiKHR5cGUsIGZsYWdzLCBuYW1lLCBkYXRhLCBtbnQpOwoJaWYgKGVycm9yIDwgMCkKCQlnb3RvIG91dF9mcmVlX3NlY2RhdGE7CglCVUdfT04oIW1udC0+bW50X3NiKTsKCiAJZXJyb3IgPSBzZWN1cml0eV9zYl9rZXJuX21vdW50KG1udC0+bW50X3NiLCBzZWNkYXRhKTsKIAlpZiAoZXJyb3IpCiAJCWdvdG8gb3V0X3NiOwoKCW1udC0+bW50X21vdW50cG9pbnQgPSBtbnQtPm1udF9yb290OwoJbW50LT5tbnRfcGFyZW50ID0gbW50OwoJdXBfd3JpdGUoJm1udC0+bW50X3NiLT5zX3Vtb3VudCk7CglmcmVlX3NlY2RhdGEoc2VjZGF0YSk7CglyZXR1cm4gbW50OwpvdXRfc2I6CglkcHV0KG1udC0+bW50X3Jvb3QpOwoJdXBfd3JpdGUoJm1udC0+bW50X3NiLT5zX3Vtb3VudCk7CglkZWFjdGl2YXRlX3N1cGVyKG1udC0+bW50X3NiKTsKb3V0X2ZyZWVfc2VjZGF0YToKCWZyZWVfc2VjZGF0YShzZWNkYXRhKTsKb3V0X21udDoKCWZyZWVfdmZzbW50KG1udCk7Cm91dDoKCXJldHVybiBFUlJfUFRSKGVycm9yKTsKfQoKRVhQT1JUX1NZTUJPTF9HUEwodmZzX2tlcm5fbW91bnQpOwoKc3RhdGljIHN0cnVjdCB2ZnNtb3VudCAqZnNfc2V0X3N1YnR5cGUoc3RydWN0IHZmc21vdW50ICptbnQsIGNvbnN0IGNoYXIgKmZzdHlwZSkKewoJaW50IGVycjsKCWNvbnN0IGNoYXIgKnN1YnR5cGUgPSBzdHJjaHIoZnN0eXBlLCAnLicpOwoJaWYgKHN1YnR5cGUpIHsKCQlzdWJ0eXBlKys7CgkJZXJyID0gLUVJTlZBTDsKCQlpZiAoIXN1YnR5cGVbMF0pCgkJCWdvdG8gZXJyOwoJfSBlbHNlCgkJc3VidHlwZSA9ICIiOwoKCW1udC0+bW50X3NiLT5zX3N1YnR5cGUgPSBrc3RyZHVwKHN1YnR5cGUsIEdGUF9LRVJORUwpOwoJZXJyID0gLUVOT01FTTsKCWlmICghbW50LT5tbnRfc2ItPnNfc3VidHlwZSkKCQlnb3RvIGVycjsKCXJldHVybiBtbnQ7CgogZXJyOgoJbW50cHV0KG1udCk7CglyZXR1cm4gRVJSX1BUUihlcnIpOwp9CgpzdHJ1Y3QgdmZzbW91bnQgKgpkb19rZXJuX21vdW50KGNvbnN0IGNoYXIgKmZzdHlwZSwgaW50IGZsYWdzLCBjb25zdCBjaGFyICpuYW1lLCB2b2lkICpkYXRhKQp7CglzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqdHlwZSA9IGdldF9mc190eXBlKGZzdHlwZSk7CglzdHJ1Y3QgdmZzbW91bnQgKm1udDsKCWlmICghdHlwZSkKCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKCW1udCA9IHZmc19rZXJuX21vdW50KHR5cGUsIGZsYWdzLCBuYW1lLCBkYXRhKTsKCWlmICghSVNfRVJSKG1udCkgJiYgKHR5cGUtPmZzX2ZsYWdzICYgRlNfSEFTX1NVQlRZUEUpICYmCgkgICAgIW1udC0+bW50X3NiLT5zX3N1YnR5cGUpCgkJbW50ID0gZnNfc2V0X3N1YnR5cGUobW50LCBmc3R5cGUpOwoJcHV0X2ZpbGVzeXN0ZW0odHlwZSk7CglyZXR1cm4gbW50Owp9CgpzdHJ1Y3QgdmZzbW91bnQgKmtlcm5fbW91bnRfZGF0YShzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqdHlwZSwgdm9pZCAqZGF0YSkKewoJcmV0dXJuIHZmc19rZXJuX21vdW50KHR5cGUsIE1TX0tFUk5NT1VOVCwgdHlwZS0+bmFtZSwgZGF0YSk7Cn0KCkVYUE9SVF9TWU1CT0xfR1BMKGtlcm5fbW91bnRfZGF0YSk7Cg==