LyoKICogIGxpbnV4L2ZzL3N1cGVyLmMKICoKICogIENvcHlyaWdodCAoQykgMTk5MSwgMTk5MiAgTGludXMgVG9ydmFsZHMKICoKICogIHN1cGVyLmMgY29udGFpbnMgY29kZSB0byBoYW5kbGU6IC0gbW91bnQgc3RydWN0dXJlcwogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLSBzdXBlci1ibG9jayB0YWJsZXMKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gZmlsZXN5c3RlbSBkcml2ZXJzIGxpc3QKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gbW91bnQgc3lzdGVtIGNhbGwKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gdW1vdW50IHN5c3RlbSBjYWxsCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtIHVzdGF0IHN5c3RlbSBjYWxsCiAqCiAqIEdLIDIvNS85NSAgLSAgQ2hhbmdlZCB0byBzdXBwb3J0IG1vdW50aW5nIHRoZSByb290IGZzIHZpYSBORlMKICoKICogIEFkZGVkIGtlcm5lbGQgc3VwcG9ydDogSmFjcXVlcyBHZWxpbmFzIGFuZCBCam9ybiBFa3dhbGwKICogIEFkZGVkIGNoYW5nZV9yb290OiBXZXJuZXIgQWxtZXNiZXJnZXIgJiBIYW5zIExlcm1lbiwgRmViICc5NgogKiAgQWRkZWQgb3B0aW9ucyB0byAvcHJvYy9tb3VudHM6CiAqICAgIFRvcmJq9nJuIExpbmRoICh0b3Jiam9ybi5saW5kaEBnb3B0YS5zZSksIEFwcmlsIDE0LCAxOTk2LgogKiAgQWRkZWQgZGV2ZnMgc3VwcG9ydDogUmljaGFyZCBHb29jaCA8cmdvb2NoQGF0bmYuY3Npcm8uYXU+LCAxMy1KQU4tMTk5OAogKiAgSGVhdmlseSByZXdyaXR0ZW4gZm9yICdvbmUgZnMgLSBvbmUgdHJlZScgZGNhY2hlIGFyY2hpdGVjdHVyZS4gQVYsIE1hciAyMDAwCiAqLwoKI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvc2xhYi5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KI2luY2x1ZGUgPGxpbnV4L2FjY3QuaD4KI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgojaW5jbHVkZSA8bGludXgvcXVvdGFvcHMuaD4KI2luY2x1ZGUgPGxpbnV4L25hbWVpLmg+CiNpbmNsdWRlIDxsaW51eC9idWZmZXJfaGVhZC5oPgkJLyogZm9yIGZzeW5jX3N1cGVyKCkgKi8KI2luY2x1ZGUgPGxpbnV4L21vdW50Lmg+CiNpbmNsdWRlIDxsaW51eC9zZWN1cml0eS5oPgojaW5jbHVkZSA8bGludXgvc3lzY2FsbHMuaD4KI2luY2x1ZGUgPGxpbnV4L3Zmcy5oPgojaW5jbHVkZSA8bGludXgvd3JpdGViYWNrLmg+CQkvKiBmb3IgdGhlIGVtZXJnZW5jeSByZW1vdW50IHN0dWZmICovCiNpbmNsdWRlIDxsaW51eC9pZHIuaD4KI2luY2x1ZGUgPGxpbnV4L2tvYmplY3QuaD4KI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgoKCnZvaWQgZ2V0X2ZpbGVzeXN0ZW0oc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgKmZzKTsKdm9pZCBwdXRfZmlsZXN5c3RlbShzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqZnMpOwpzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqZ2V0X2ZzX3R5cGUoY29uc3QgY2hhciAqbmFtZSk7CgpMSVNUX0hFQUQoc3VwZXJfYmxvY2tzKTsKREVGSU5FX1NQSU5MT0NLKHNiX2xvY2spOwoKLyoqCiAqCWFsbG9jX3N1cGVyCS0JY3JlYXRlIG5ldyBzdXBlcmJsb2NrCiAqCUB0eXBlOglmaWxlc3lzdGVtIHR5cGUgc3VwZXJibG9jayBzaG91bGQgYmVsb25nIHRvCiAqCiAqCUFsbG9jYXRlcyBhbmQgaW5pdGlhbGl6ZXMgYSBuZXcgJnN0cnVjdCBzdXBlcl9ibG9jay4gIGFsbG9jX3N1cGVyKCkKICoJcmV0dXJucyBhIHBvaW50ZXIgbmV3IHN1cGVyYmxvY2sgb3IgJU5VTEwgaWYgYWxsb2NhdGlvbiBoYWQgZmFpbGVkLgogKi8Kc3RhdGljIHN0cnVjdCBzdXBlcl9ibG9jayAqYWxsb2Nfc3VwZXIoc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgKnR5cGUpCnsKCXN0cnVjdCBzdXBlcl9ibG9jayAqcyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzdXBlcl9ibG9jayksICBHRlBfVVNFUik7CglzdGF0aWMgc3RydWN0IHN1cGVyX29wZXJhdGlvbnMgZGVmYXVsdF9vcDsKCglpZiAocykgewoJCWlmIChzZWN1cml0eV9zYl9hbGxvYyhzKSkgewoJCQlrZnJlZShzKTsKCQkJcyA9IE5VTEw7CgkJCWdvdG8gb3V0OwoJCX0KCQlJTklUX0xJU1RfSEVBRCgmcy0+c19kaXJ0eSk7CgkJSU5JVF9MSVNUX0hFQUQoJnMtPnNfaW8pOwoJCUlOSVRfTElTVF9IRUFEKCZzLT5zX2ZpbGVzKTsKCQlJTklUX0xJU1RfSEVBRCgmcy0+c19pbnN0YW5jZXMpOwoJCUlOSVRfSExJU1RfSEVBRCgmcy0+c19hbm9uKTsKCQlJTklUX0xJU1RfSEVBRCgmcy0+c19pbm9kZXMpOwoJCWluaXRfcndzZW0oJnMtPnNfdW1vdW50KTsKCQltdXRleF9pbml0KCZzLT5zX2xvY2spOwoJCWxvY2tkZXBfc2V0X2NsYXNzKCZzLT5zX3Vtb3VudCwgJnR5cGUtPnNfdW1vdW50X2tleSk7CgkJLyoKCQkgKiBUaGUgbG9ja2luZyBydWxlcyBmb3Igc19sb2NrIGFyZSB1cCB0byB0aGUKCQkgKiBmaWxlc3lzdGVtLiBGb3IgZXhhbXBsZSBleHQzZnMgaGFzIGRpZmZlcmVudAoJCSAqIGxvY2sgb3JkZXJpbmcgdGhhbiB1c2JmczoKCQkgKi8KCQlsb2NrZGVwX3NldF9jbGFzcygmcy0+c19sb2NrLCAmdHlwZS0+c19sb2NrX2tleSk7CgkJZG93bl93cml0ZSgmcy0+c191bW91bnQpOwoJCXMtPnNfY291bnQgPSBTX0JJQVM7CgkJYXRvbWljX3NldCgmcy0+c19hY3RpdmUsIDEpOwoJCW11dGV4X2luaXQoJnMtPnNfdmZzX3JlbmFtZV9tdXRleCk7CgkJbXV0ZXhfaW5pdCgmcy0+c19kcXVvdC5kcWlvX211dGV4KTsKCQltdXRleF9pbml0KCZzLT5zX2RxdW90LmRxb25vZmZfbXV0ZXgpOwoJCWluaXRfcndzZW0oJnMtPnNfZHF1b3QuZHFwdHJfc2VtKTsKCQlpbml0X3dhaXRxdWV1ZV9oZWFkKCZzLT5zX3dhaXRfdW5mcm96ZW4pOwoJCXMtPnNfbWF4Ynl0ZXMgPSBNQVhfTk9OX0xGUzsKCQlzLT5kcV9vcCA9IHNiX2RxdW90X29wczsKCQlzLT5zX3Fjb3AgPSBzYl9xdW90YWN0bF9vcHM7CgkJcy0+c19vcCA9ICZkZWZhdWx0X29wOwoJCXMtPnNfdGltZV9ncmFuID0gMTAwMDAwMDAwMDsKCX0Kb3V0OgoJcmV0dXJuIHM7Cn0KCi8qKgogKglkZXN0cm95X3N1cGVyCS0JZnJlZXMgYSBzdXBlcmJsb2NrCiAqCUBzOiBzdXBlcmJsb2NrIHRvIGZyZWUKICoKICoJRnJlZXMgYSBzdXBlcmJsb2NrLgogKi8Kc3RhdGljIGlubGluZSB2b2lkIGRlc3Ryb3lfc3VwZXIoc3RydWN0IHN1cGVyX2Jsb2NrICpzKQp7CglzZWN1cml0eV9zYl9mcmVlKHMpOwoJa2ZyZWUocyk7Cn0KCi8qIFN1cGVyYmxvY2sgcmVmY291bnRpbmcgICovCgovKgogKiBEcm9wIGEgc3VwZXJibG9jaydzIHJlZmNvdW50LiAgUmV0dXJucyBub24temVybyBpZiB0aGUgc3VwZXJibG9jayB3YXMKICogZGVzdHJveWVkLiAgVGhlIGNhbGxlciBtdXN0IGhvbGQgc2JfbG9jay4KICovCmludCBfX3B1dF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglpbnQgcmV0ID0gMDsKCglpZiAoIS0tc2ItPnNfY291bnQpIHsKCQlkZXN0cm95X3N1cGVyKHNiKTsKCQlyZXQgPSAxOwoJfQoJcmV0dXJuIHJldDsKfQoKLyoKICogRHJvcCBhIHN1cGVyYmxvY2sncyByZWZjb3VudC4KICogUmV0dXJucyBub24temVybyBpZiB0aGUgc3VwZXJibG9jayBpcyBhYm91dCB0byBiZSBkZXN0cm95ZWQgYW5kCiAqIGF0IGxlYXN0IGlzIGFscmVhZHkgcmVtb3ZlZCBmcm9tIHN1cGVyX2Jsb2NrcyBsaXN0LCBzbyBpZiB3ZSBhcmUKICogbWFraW5nIGEgbG9vcCB0aHJvdWdoIHN1cGVyIGJsb2NrcyB0aGVuIHdlIG5lZWQgdG8gcmVzdGFydC4KICogVGhlIGNhbGxlciBtdXN0IGhvbGQgc2JfbG9jay4KICovCmludCBfX3B1dF9zdXBlcl9hbmRfbmVlZF9yZXN0YXJ0KHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCS8qIGNoZWNrIGZvciByYWNlIHdpdGggZ2VuZXJpY19zaHV0ZG93bl9zdXBlcigpICovCglpZiAobGlzdF9lbXB0eSgmc2ItPnNfbGlzdCkpIHsKCQkvKiBzdXBlciBibG9jayBpcyByZW1vdmVkLCBuZWVkIHRvIHJlc3RhcnQuLi4gKi8KCQlfX3B1dF9zdXBlcihzYik7CgkJcmV0dXJuIDE7Cgl9CgkvKiBjYW4ndCBiZSB0aGUgbGFzdCwgc2luY2Ugc19saXN0IGlzIHN0aWxsIGluIHVzZSAqLwoJc2ItPnNfY291bnQtLTsKCUJVR19PTihzYi0+c19jb3VudCA9PSAwKTsKCXJldHVybiAwOwp9CgovKioKICoJcHV0X3N1cGVyCS0JZHJvcCBhIHRlbXBvcmFyeSByZWZlcmVuY2UgdG8gc3VwZXJibG9jawogKglAc2I6IHN1cGVyYmxvY2sgaW4gcXVlc3Rpb24KICoKICoJRHJvcHMgYSB0ZW1wb3JhcnkgcmVmZXJlbmNlLCBmcmVlcyBzdXBlcmJsb2NrIGlmIHRoZXJlJ3Mgbm8KICoJcmVmZXJlbmNlcyBsZWZ0LgogKi8Kc3RhdGljIHZvaWQgcHV0X3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCXNwaW5fbG9jaygmc2JfbG9jayk7CglfX3B1dF9zdXBlcihzYik7CglzcGluX3VubG9jaygmc2JfbG9jayk7Cn0KCgovKioKICoJZGVhY3RpdmF0ZV9zdXBlcgktCWRyb3AgYW4gYWN0aXZlIHJlZmVyZW5jZSB0byBzdXBlcmJsb2NrCiAqCUBzOiBzdXBlcmJsb2NrIHRvIGRlYWN0aXZhdGUKICoKICoJRHJvcHMgYW4gYWN0aXZlIHJlZmVyZW5jZSB0byBzdXBlcmJsb2NrLCBhY3F1aXJpbmcgYSB0ZW1wcm9yeSBvbmUgaWYKICoJdGhlcmUgaXMgbm8gYWN0aXZlIHJlZmVyZW5jZXMgbGVmdC4gIEluIHRoYXQgY2FzZSB3ZSBsb2NrIHN1cGVyYmxvY2ssCiAqCXRlbGwgZnMgZHJpdmVyIHRvIHNodXQgaXQgZG93biBhbmQgZHJvcCB0aGUgdGVtcG9yYXJ5IHJlZmVyZW5jZSB3ZQogKgloYWQganVzdCBhY3F1aXJlZC4KICovCnZvaWQgZGVhY3RpdmF0ZV9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMpCnsKCXN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICpmcyA9IHMtPnNfdHlwZTsKCWlmIChhdG9taWNfZGVjX2FuZF9sb2NrKCZzLT5zX2FjdGl2ZSwgJnNiX2xvY2spKSB7CgkJcy0+c19jb3VudCAtPSBTX0JJQVMtMTsKCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJRFFVT1RfT0ZGKHMpOwoJCWRvd25fd3JpdGUoJnMtPnNfdW1vdW50KTsKCQlmcy0+a2lsbF9zYihzKTsKCQlwdXRfZmlsZXN5c3RlbShmcyk7CgkJcHV0X3N1cGVyKHMpOwoJfQp9CgpFWFBPUlRfU1lNQk9MKGRlYWN0aXZhdGVfc3VwZXIpOwoKLyoqCiAqCWdyYWJfc3VwZXIgLSBhY3F1aXJlIGFuIGFjdGl2ZSByZWZlcmVuY2UKICoJQHM6IHJlZmVyZW5jZSB3ZSBhcmUgdHJ5aW5nIHRvIG1ha2UgYWN0aXZlCiAqCiAqCVRyaWVzIHRvIGFjcXVpcmUgYW4gYWN0aXZlIHJlZmVyZW5jZS4gIGdyYWJfc3VwZXIoKSBpcyB1c2VkIHdoZW4gd2UKICogCWhhZCBqdXN0IGZvdW5kIGEgc3VwZXJibG9jayBpbiBzdXBlcl9ibG9ja3Mgb3IgZnNfdHlwZS0+ZnNfc3VwZXJzCiAqCWFuZCB3YW50IHRvIHR1cm4gaXQgaW50byBhIGZ1bGwtYmxvd24gYWN0aXZlIHJlZmVyZW5jZS4gIGdyYWJfc3VwZXIoKQogKglpcyBjYWxsZWQgd2l0aCBzYl9sb2NrIGhlbGQgYW5kIGRyb3BzIGl0LiAgUmV0dXJucyAxIGluIGNhc2Ugb2YKICoJc3VjY2VzcywgMCBpZiB3ZSBoYWQgZmFpbGVkIChzdXBlcmJsb2NrIGNvbnRlbnRzIHdhcyBhbHJlYWR5IGRlYWQgb3IKICoJZHlpbmcgd2hlbiBncmFiX3N1cGVyKCkgaGFkIGJlZW4gY2FsbGVkKS4KICovCnN0YXRpYyBpbnQgZ3JhYl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMpIF9fcmVsZWFzZXMoc2JfbG9jaykKewoJcy0+c19jb3VudCsrOwoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJZG93bl93cml0ZSgmcy0+c191bW91bnQpOwoJaWYgKHMtPnNfcm9vdCkgewoJCXNwaW5fbG9jaygmc2JfbG9jayk7CgkJaWYgKHMtPnNfY291bnQgPiBTX0JJQVMpIHsKCQkJYXRvbWljX2luYygmcy0+c19hY3RpdmUpOwoJCQlzLT5zX2NvdW50LS07CgkJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCQkJcmV0dXJuIDE7CgkJfQoJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCX0KCXVwX3dyaXRlKCZzLT5zX3Vtb3VudCk7CglwdXRfc3VwZXIocyk7Cgl5aWVsZCgpOwoJcmV0dXJuIDA7Cn0KCi8qCiAqIFN1cGVyYmxvY2sgbG9ja2luZy4gIFdlIHJlYWxseSBvdWdodCB0byBnZXQgcmlkIG9mIHRoZXNlIHR3by4KICovCnZvaWQgbG9ja19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiBzYikKewoJZ2V0X2ZzX2V4Y2woKTsKCW11dGV4X2xvY2soJnNiLT5zX2xvY2spOwp9Cgp2b2lkIHVubG9ja19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiBzYikKewoJcHV0X2ZzX2V4Y2woKTsKCW11dGV4X3VubG9jaygmc2ItPnNfbG9jayk7Cn0KCkVYUE9SVF9TWU1CT0wobG9ja19zdXBlcik7CkVYUE9SVF9TWU1CT0wodW5sb2NrX3N1cGVyKTsKCi8qCiAqIFdyaXRlIG91dCBhbmQgd2FpdCB1cG9uIGFsbCBkaXJ0eSBkYXRhIGFzc29jaWF0ZWQgd2l0aCB0aGlzCiAqIHN1cGVyYmxvY2suICBGaWxlc3lzdGVtIGRhdGEgYXMgd2VsbCBhcyB0aGUgdW5kZXJseWluZyBibG9jawogKiBkZXZpY2UuICBUYWtlcyB0aGUgc3VwZXJibG9jayBsb2NrLiAgUmVxdWlyZXMgYSBzZWNvbmQgYmxrZGV2CiAqIGZsdXNoIGJ5IHRoZSBjYWxsZXIgdG8gY29tcGxldGUgdGhlIG9wZXJhdGlvbi4KICovCnZvaWQgX19mc3luY19zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglzeW5jX2lub2Rlc19zYihzYiwgMCk7CglEUVVPVF9TWU5DKHNiKTsKCWxvY2tfc3VwZXIoc2IpOwoJaWYgKHNiLT5zX2RpcnQgJiYgc2ItPnNfb3AtPndyaXRlX3N1cGVyKQoJCXNiLT5zX29wLT53cml0ZV9zdXBlcihzYik7Cgl1bmxvY2tfc3VwZXIoc2IpOwoJaWYgKHNiLT5zX29wLT5zeW5jX2ZzKQoJCXNiLT5zX29wLT5zeW5jX2ZzKHNiLCAxKTsKCXN5bmNfYmxvY2tkZXYoc2ItPnNfYmRldik7CglzeW5jX2lub2Rlc19zYihzYiwgMSk7Cn0KCi8qCiAqIFdyaXRlIG91dCBhbmQgd2FpdCB1cG9uIGFsbCBkaXJ0eSBkYXRhIGFzc29jaWF0ZWQgd2l0aCB0aGlzCiAqIHN1cGVyYmxvY2suICBGaWxlc3lzdGVtIGRhdGEgYXMgd2VsbCBhcyB0aGUgdW5kZXJseWluZyBibG9jawogKiBkZXZpY2UuICBUYWtlcyB0aGUgc3VwZXJibG9jayBsb2NrLgogKi8KaW50IGZzeW5jX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCV9fZnN5bmNfc3VwZXIoc2IpOwoJcmV0dXJuIHN5bmNfYmxvY2tkZXYoc2ItPnNfYmRldik7Cn0KCi8qKgogKglnZW5lcmljX3NodXRkb3duX3N1cGVyCS0JY29tbW9uIGhlbHBlciBmb3IgLT5raWxsX3NiKCkKICoJQHNiOiBzdXBlcmJsb2NrIHRvIGtpbGwKICoKICoJZ2VuZXJpY19zaHV0ZG93bl9zdXBlcigpIGRvZXMgYWxsIGZzLWluZGVwZW5kZW50IHdvcmsgb24gc3VwZXJibG9jawogKglzaHV0ZG93bi4gIFR5cGljYWwgLT5raWxsX3NiKCkgc2hvdWxkIHBpY2sgYWxsIGZzLXNwZWNpZmljIG9iamVjdHMKICoJdGhhdCBuZWVkIGRlc3RydWN0aW9uIG91dCBvZiBzdXBlcmJsb2NrLCBjYWxsIGdlbmVyaWNfc2h1dGRvd25fc3VwZXIoKQogKglhbmQgcmVsZWFzZSBhZm9yZW1lbnRpb25lZCBvYmplY3RzLiAgTm90ZTogZGVudHJpZXMgYW5kIGlub2RlcyBfYXJlXwogKgl0YWtlbiBjYXJlIG9mIGFuZCBkbyBub3QgbmVlZCBzcGVjaWZpYyBoYW5kbGluZy4KICoKICoJVXBvbiBjYWxsaW5nIHRoaXMgZnVuY3Rpb24sIHRoZSBmaWxlc3lzdGVtIG1heSBubyBsb25nZXIgYWx0ZXIgb3IKICoJcmVhcnJhbmdlIHRoZSBzZXQgb2YgZGVudHJpZXMgYmVsb25naW5nIHRvIHRoaXMgc3VwZXJfYmxvY2ssIG5vciBtYXkgaXQKICoJY2hhbmdlIHRoZSBhdHRhY2htZW50cyBvZiBkZW50cmllcyB0byBpbm9kZXMuCiAqLwp2b2lkIGdlbmVyaWNfc2h1dGRvd25fc3VwZXIoc3RydWN0IHN1cGVyX2Jsb2NrICpzYikKewoJc3RydWN0IHN1cGVyX29wZXJhdGlvbnMgKnNvcCA9IHNiLT5zX29wOwoKCWlmIChzYi0+c19yb290KSB7CgkJc2hyaW5rX2RjYWNoZV9mb3JfdW1vdW50KHNiKTsKCQlmc3luY19zdXBlcihzYik7CgkJbG9ja19zdXBlcihzYik7CgkJc2ItPnNfZmxhZ3MgJj0gfk1TX0FDVElWRTsKCQkvKiBiYWQgbmFtZSAtIGl0IHNob3VsZCBiZSBldmljdF9pbm9kZXMoKSAqLwoJCWludmFsaWRhdGVfaW5vZGVzKHNiKTsKCQlsb2NrX2tlcm5lbCgpOwoKCQlpZiAoc29wLT53cml0ZV9zdXBlciAmJiBzYi0+c19kaXJ0KQoJCQlzb3AtPndyaXRlX3N1cGVyKHNiKTsKCQlpZiAoc29wLT5wdXRfc3VwZXIpCgkJCXNvcC0+cHV0X3N1cGVyKHNiKTsKCgkJLyogRm9yZ2V0IGFueSByZW1haW5pbmcgaW5vZGVzICovCgkJaWYgKGludmFsaWRhdGVfaW5vZGVzKHNiKSkgewoJCQlwcmludGsoIlZGUzogQnVzeSBpbm9kZXMgYWZ0ZXIgdW5tb3VudCBvZiAlcy4gIgoJCQkgICAiU2VsZi1kZXN0cnVjdCBpbiA1IHNlY29uZHMuICBIYXZlIGEgbmljZSBkYXkuLi5cbiIsCgkJCSAgIHNiLT5zX2lkKTsKCQl9CgoJCXVubG9ja19rZXJuZWwoKTsKCQl1bmxvY2tfc3VwZXIoc2IpOwoJfQoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCS8qIHNob3VsZCBiZSBpbml0aWFsaXplZCBmb3IgX19wdXRfc3VwZXJfYW5kX25lZWRfcmVzdGFydCgpICovCglsaXN0X2RlbF9pbml0KCZzYi0+c19saXN0KTsKCWxpc3RfZGVsKCZzYi0+c19pbnN0YW5jZXMpOwoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJdXBfd3JpdGUoJnNiLT5zX3Vtb3VudCk7Cn0KCkVYUE9SVF9TWU1CT0woZ2VuZXJpY19zaHV0ZG93bl9zdXBlcik7CgovKioKICoJc2dldAktCWZpbmQgb3IgY3JlYXRlIGEgc3VwZXJibG9jawogKglAdHlwZToJZmlsZXN5c3RlbSB0eXBlIHN1cGVyYmxvY2sgc2hvdWxkIGJlbG9uZyB0bwogKglAdGVzdDoJY29tcGFyaXNvbiBjYWxsYmFjawogKglAc2V0OglzZXR1cCBjYWxsYmFjawogKglAZGF0YToJYXJndW1lbnQgdG8gZWFjaCBvZiB0aGVtCiAqLwpzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNnZXQoc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgKnR5cGUsCgkJCWludCAoKnRlc3QpKHN0cnVjdCBzdXBlcl9ibG9jayAqLHZvaWQgKiksCgkJCWludCAoKnNldCkoc3RydWN0IHN1cGVyX2Jsb2NrICosdm9pZCAqKSwKCQkJdm9pZCAqZGF0YSkKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzID0gTlVMTDsKCXN0cnVjdCBsaXN0X2hlYWQgKnA7CglpbnQgZXJyOwoKcmV0cnk6CglzcGluX2xvY2soJnNiX2xvY2spOwoJaWYgKHRlc3QpIGxpc3RfZm9yX2VhY2gocCwgJnR5cGUtPmZzX3N1cGVycykgewoJCXN0cnVjdCBzdXBlcl9ibG9jayAqb2xkOwoJCW9sZCA9IGxpc3RfZW50cnkocCwgc3RydWN0IHN1cGVyX2Jsb2NrLCBzX2luc3RhbmNlcyk7CgkJaWYgKCF0ZXN0KG9sZCwgZGF0YSkpCgkJCWNvbnRpbnVlOwoJCWlmICghZ3JhYl9zdXBlcihvbGQpKQoJCQlnb3RvIHJldHJ5OwoJCWlmIChzKQoJCQlkZXN0cm95X3N1cGVyKHMpOwoJCXJldHVybiBvbGQ7Cgl9CglpZiAoIXMpIHsKCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJcyA9IGFsbG9jX3N1cGVyKHR5cGUpOwoJCWlmICghcykKCQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CgkJZ290byByZXRyeTsKCX0KCQkKCWVyciA9IHNldChzLCBkYXRhKTsKCWlmIChlcnIpIHsKCQlzcGluX3VubG9jaygmc2JfbG9jayk7CgkJZGVzdHJveV9zdXBlcihzKTsKCQlyZXR1cm4gRVJSX1BUUihlcnIpOwoJfQoJcy0+c190eXBlID0gdHlwZTsKCXN0cmxjcHkocy0+c19pZCwgdHlwZS0+bmFtZSwgc2l6ZW9mKHMtPnNfaWQpKTsKCWxpc3RfYWRkX3RhaWwoJnMtPnNfbGlzdCwgJnN1cGVyX2Jsb2Nrcyk7CglsaXN0X2FkZCgmcy0+c19pbnN0YW5jZXMsICZ0eXBlLT5mc19zdXBlcnMpOwoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJZ2V0X2ZpbGVzeXN0ZW0odHlwZSk7CglyZXR1cm4gczsKfQoKRVhQT1JUX1NZTUJPTChzZ2V0KTsKCnZvaWQgZHJvcF9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7Cgl1cF9yZWFkKCZzYi0+c191bW91bnQpOwoJcHV0X3N1cGVyKHNiKTsKfQoKRVhQT1JUX1NZTUJPTChkcm9wX3N1cGVyKTsKCnN0YXRpYyBpbmxpbmUgdm9pZCB3cml0ZV9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7Cglsb2NrX3N1cGVyKHNiKTsKCWlmIChzYi0+c19yb290ICYmIHNiLT5zX2RpcnQpCgkJaWYgKHNiLT5zX29wLT53cml0ZV9zdXBlcikKCQkJc2ItPnNfb3AtPndyaXRlX3N1cGVyKHNiKTsKCXVubG9ja19zdXBlcihzYik7Cn0KCi8qCiAqIE5vdGU6IGNoZWNrIHRoZSBkaXJ0eSBmbGFnIGJlZm9yZSB3YWl0aW5nLCBzbyB3ZSBkb24ndAogKiBob2xkIHVwIHRoZSBzeW5jIHdoaWxlIG1vdW50aW5nIGEgZGV2aWNlLiAoVGhlIG5ld2x5CiAqIG1vdW50ZWQgZGV2aWNlIHdvbid0IG5lZWQgc3luY2luZy4pCiAqLwp2b2lkIHN5bmNfc3VwZXJzKHZvaWQpCnsKCXN0cnVjdCBzdXBlcl9ibG9jayAqc2I7CgoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKcmVzdGFydDoKCWxpc3RfZm9yX2VhY2hfZW50cnkoc2IsICZzdXBlcl9ibG9ja3MsIHNfbGlzdCkgewoJCWlmIChzYi0+c19kaXJ0KSB7CgkJCXNiLT5zX2NvdW50Kys7CgkJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCQkJZG93bl9yZWFkKCZzYi0+c191bW91bnQpOwoJCQl3cml0ZV9zdXBlcihzYik7CgkJCXVwX3JlYWQoJnNiLT5zX3Vtb3VudCk7CgkJCXNwaW5fbG9jaygmc2JfbG9jayk7CgkJCWlmIChfX3B1dF9zdXBlcl9hbmRfbmVlZF9yZXN0YXJ0KHNiKSkKCQkJCWdvdG8gcmVzdGFydDsKCQl9Cgl9CglzcGluX3VubG9jaygmc2JfbG9jayk7Cn0KCi8qCiAqIENhbGwgdGhlIC0+c3luY19mcyBzdXBlcl9vcCBhZ2FpbnN0IGFsbCBmaWxlc3l0ZW1zIHdoaWNoIGFyZSByL3cgYW5kCiAqIHdoaWNoIGltcGxlbWVudCBpdC4KICoKICogVGhpcyBvcGVyYXRpb24gaXMgY2FyZWZ1bCB0byBhdm9pZCB0aGUgbGl2ZWxvY2sgd2hpY2ggY291bGQgZWFzaWx5IGhhcHBlbgogKiBpZiB0d28gb3IgbW9yZSBmaWxlc3lzdGVtcyBhcmUgYmVpbmcgY29udGludW91c2x5IGRpcnRpZWQuICBzX25lZWRfc3luY19mcwogKiBpcyB1c2VkIG9ubHkgaGVyZS4gIFdlIHNldCBpdCBhZ2FpbnN0IGFsbCBmaWxlc3lzdGVtcyBhbmQgdGhlbiBjbGVhciBpdCBhcwogKiB3ZSBzeW5jIHRoZW0uICBTbyByZWRpcnRpZWQgZmlsZXN5c3RlbXMgYXJlIHNraXBwZWQuCiAqCiAqIEJ1dCBpZiBwcm9jZXNzIEEgaXMgY3VycmVudGx5IHJ1bm5pbmcgc3luY19maWxlc3l0ZW1zIGFuZCB0aGVuIHByb2Nlc3MgQgogKiBjYWxscyBzeW5jX2ZpbGVzeXN0ZW1zIGFzIHdlbGwsIHByb2Nlc3MgQiB3aWxsIHNldCBhbGwgdGhlIHNfbmVlZF9zeW5jX2ZzCiAqIGZsYWdzIGFnYWluLCB3aGljaCB3aWxsIGNhdXNlIHByb2Nlc3MgQSB0byByZXN5bmMgZXZlcnl0aGluZy4gIEZpeCB0aGF0IHdpdGgKICogYSBsb2NhbCBtdXRleC4KICoKICogKEZhYmlhbikgQXZvaWQgc3luY19mcyB3aXRoIGNsZWFuIGZzICYgd2FpdCBtb2RlIDAKICovCnZvaWQgc3luY19maWxlc3lzdGVtcyhpbnQgd2FpdCkKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzYjsKCXN0YXRpYyBERUZJTkVfTVVURVgobXV0ZXgpOwoKCW11dGV4X2xvY2soJm11dGV4KTsJCS8qIENvdWxkIGJlIGRvd25faW50ZXJydXB0aWJsZSAqLwoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCWxpc3RfZm9yX2VhY2hfZW50cnkoc2IsICZzdXBlcl9ibG9ja3MsIHNfbGlzdCkgewoJCWlmICghc2ItPnNfb3AtPnN5bmNfZnMpCgkJCWNvbnRpbnVlOwoJCWlmIChzYi0+c19mbGFncyAmIE1TX1JET05MWSkKCQkJY29udGludWU7CgkJc2ItPnNfbmVlZF9zeW5jX2ZzID0gMTsKCX0KCnJlc3RhcnQ6CglsaXN0X2Zvcl9lYWNoX2VudHJ5KHNiLCAmc3VwZXJfYmxvY2tzLCBzX2xpc3QpIHsKCQlpZiAoIXNiLT5zX25lZWRfc3luY19mcykKCQkJY29udGludWU7CgkJc2ItPnNfbmVlZF9zeW5jX2ZzID0gMDsKCQlpZiAoc2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpCgkJCWNvbnRpbnVlOwkvKiBobS4gIFdhcyByZW1vdW50ZWQgci9vIG1lYW53aGlsZSAqLwoJCXNiLT5zX2NvdW50Kys7CgkJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJCWRvd25fcmVhZCgmc2ItPnNfdW1vdW50KTsKCQlpZiAoc2ItPnNfcm9vdCAmJiAod2FpdCB8fCBzYi0+c19kaXJ0KSkKCQkJc2ItPnNfb3AtPnN5bmNfZnMoc2IsIHdhaXQpOwoJCXVwX3JlYWQoJnNiLT5zX3Vtb3VudCk7CgkJLyogcmVzdGFydCBvbmx5IHdoZW4gc2IgaXMgbm8gbG9uZ2VyIG9uIHRoZSBsaXN0ICovCgkJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCQlpZiAoX19wdXRfc3VwZXJfYW5kX25lZWRfcmVzdGFydChzYikpCgkJCWdvdG8gcmVzdGFydDsKCX0KCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCW11dGV4X3VubG9jaygmbXV0ZXgpOwp9CgovKioKICoJZ2V0X3N1cGVyIC0gZ2V0IHRoZSBzdXBlcmJsb2NrIG9mIGEgZGV2aWNlCiAqCUBiZGV2OiBkZXZpY2UgdG8gZ2V0IHRoZSBzdXBlcmJsb2NrIGZvcgogKgkKICoJU2NhbnMgdGhlIHN1cGVyYmxvY2sgbGlzdCBhbmQgZmluZHMgdGhlIHN1cGVyYmxvY2sgb2YgdGhlIGZpbGUgc3lzdGVtCiAqCW1vdW50ZWQgb24gdGhlIGRldmljZSBnaXZlbi4gJU5VTEwgaXMgcmV0dXJuZWQgaWYgbm8gbWF0Y2ggaXMgZm91bmQuCiAqLwoKc3RydWN0IHN1cGVyX2Jsb2NrICogZ2V0X3N1cGVyKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYpCnsKCXN0cnVjdCBzdXBlcl9ibG9jayAqc2I7CgoJaWYgKCFiZGV2KQoJCXJldHVybiBOVUxMOwoKCXNwaW5fbG9jaygmc2JfbG9jayk7CnJlc2NhbjoKCWxpc3RfZm9yX2VhY2hfZW50cnkoc2IsICZzdXBlcl9ibG9ja3MsIHNfbGlzdCkgewoJCWlmIChzYi0+c19iZGV2ID09IGJkZXYpIHsKCQkJc2ItPnNfY291bnQrKzsKCQkJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJCQlkb3duX3JlYWQoJnNiLT5zX3Vtb3VudCk7CgkJCWlmIChzYi0+c19yb290KQoJCQkJcmV0dXJuIHNiOwoJCQl1cF9yZWFkKCZzYi0+c191bW91bnQpOwoJCQkvKiByZXN0YXJ0IG9ubHkgd2hlbiBzYiBpcyBubyBsb25nZXIgb24gdGhlIGxpc3QgKi8KCQkJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCQkJaWYgKF9fcHV0X3N1cGVyX2FuZF9uZWVkX3Jlc3RhcnQoc2IpKQoJCQkJZ290byByZXNjYW47CgkJfQoJfQoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJcmV0dXJuIE5VTEw7Cn0KCkVYUE9SVF9TWU1CT0woZ2V0X3N1cGVyKTsKIApzdHJ1Y3Qgc3VwZXJfYmxvY2sgKiB1c2VyX2dldF9zdXBlcihkZXZfdCBkZXYpCnsKCXN0cnVjdCBzdXBlcl9ibG9jayAqc2I7CgoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKcmVzY2FuOgoJbGlzdF9mb3JfZWFjaF9lbnRyeShzYiwgJnN1cGVyX2Jsb2Nrcywgc19saXN0KSB7CgkJaWYgKHNiLT5zX2RldiA9PSAgZGV2KSB7CgkJCXNiLT5zX2NvdW50Kys7CgkJCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCQkJZG93bl9yZWFkKCZzYi0+c191bW91bnQpOwoJCQlpZiAoc2ItPnNfcm9vdCkKCQkJCXJldHVybiBzYjsKCQkJdXBfcmVhZCgmc2ItPnNfdW1vdW50KTsKCQkJLyogcmVzdGFydCBvbmx5IHdoZW4gc2IgaXMgbm8gbG9uZ2VyIG9uIHRoZSBsaXN0ICovCgkJCXNwaW5fbG9jaygmc2JfbG9jayk7CgkJCWlmIChfX3B1dF9zdXBlcl9hbmRfbmVlZF9yZXN0YXJ0KHNiKSkKCQkJCWdvdG8gcmVzY2FuOwoJCX0KCX0KCXNwaW5fdW5sb2NrKCZzYl9sb2NrKTsKCXJldHVybiBOVUxMOwp9Cgphc21saW5rYWdlIGxvbmcgc3lzX3VzdGF0KHVuc2lnbmVkIGRldiwgc3RydWN0IHVzdGF0IF9fdXNlciAqIHVidWYpCnsKICAgICAgICBzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnM7CiAgICAgICAgc3RydWN0IHVzdGF0IHRtcDsKICAgICAgICBzdHJ1Y3Qga3N0YXRmcyBzYnVmOwoJaW50IGVyciA9IC1FSU5WQUw7CgogICAgICAgIHMgPSB1c2VyX2dldF9zdXBlcihuZXdfZGVjb2RlX2RldihkZXYpKTsKICAgICAgICBpZiAocyA9PSBOVUxMKQogICAgICAgICAgICAgICAgZ290byBvdXQ7CgllcnIgPSB2ZnNfc3RhdGZzKHMtPnNfcm9vdCwgJnNidWYpOwoJZHJvcF9zdXBlcihzKTsKCWlmIChlcnIpCgkJZ290byBvdXQ7CgogICAgICAgIG1lbXNldCgmdG1wLDAsc2l6ZW9mKHN0cnVjdCB1c3RhdCkpOwogICAgICAgIHRtcC5mX3RmcmVlID0gc2J1Zi5mX2JmcmVlOwogICAgICAgIHRtcC5mX3Rpbm9kZSA9IHNidWYuZl9mZnJlZTsKCiAgICAgICAgZXJyID0gY29weV90b191c2VyKHVidWYsJnRtcCxzaXplb2Yoc3RydWN0IHVzdGF0KSkgPyAtRUZBVUxUIDogMDsKb3V0OgoJcmV0dXJuIGVycjsKfQoKLyoqCiAqCW1hcmtfZmlsZXNfcm8KICoJQHNiOiBzdXBlcmJsb2NrIGluIHF1ZXN0aW9uCiAqCiAqCUFsbCBmaWxlcyBhcmUgbWFya2VkIHJlYWQvb25seS4gIFdlIGRvbid0IGNhcmUgYWJvdXQgcGVuZGluZwogKglkZWxldGUgZmlsZXMgc28gdGhpcyBzaG91bGQgYmUgdXNlZCBpbiAnZm9yY2UnIG1vZGUgb25seQogKi8KCnN0YXRpYyB2b2lkIG1hcmtfZmlsZXNfcm8oc3RydWN0IHN1cGVyX2Jsb2NrICpzYikKewoJc3RydWN0IGZpbGUgKmY7CgoJZmlsZV9saXN0X2xvY2soKTsKCWxpc3RfZm9yX2VhY2hfZW50cnkoZiwgJnNiLT5zX2ZpbGVzLCBmX3UuZnVfbGlzdCkgewoJCWlmIChTX0lTUkVHKGYtPmZfcGF0aC5kZW50cnktPmRfaW5vZGUtPmlfbW9kZSkgJiYgZmlsZV9jb3VudChmKSkKCQkJZi0+Zl9tb2RlICY9IH5GTU9ERV9XUklURTsKCX0KCWZpbGVfbGlzdF91bmxvY2soKTsKfQoKLyoqCiAqCWRvX3JlbW91bnRfc2IgLSBhc2tzIGZpbGVzeXN0ZW0gdG8gY2hhbmdlIG1vdW50IG9wdGlvbnMuCiAqCUBzYjoJc3VwZXJibG9jayBpbiBxdWVzdGlvbgogKglAZmxhZ3M6CW51bWVyaWMgcGFydCBvZiBvcHRpb25zCiAqCUBkYXRhOgl0aGUgcmVzdCBvZiBvcHRpb25zCiAqICAgICAgQGZvcmNlOiB3aGV0aGVyIG9yIG5vdCB0byBmb3JjZSB0aGUgY2hhbmdlCiAqCiAqCUFsdGVycyB0aGUgbW91bnQgb3B0aW9ucyBvZiBhIG1vdW50ZWQgZmlsZSBzeXN0ZW0uCiAqLwppbnQgZG9fcmVtb3VudF9zYihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBpbnQgZmxhZ3MsIHZvaWQgKmRhdGEsIGludCBmb3JjZSkKewoJaW50IHJldHZhbDsKCQojaWZkZWYgQ09ORklHX0JMT0NLCglpZiAoIShmbGFncyAmIE1TX1JET05MWSkgJiYgYmRldl9yZWFkX29ubHkoc2ItPnNfYmRldikpCgkJcmV0dXJuIC1FQUNDRVM7CiNlbmRpZgoJaWYgKGZsYWdzICYgTVNfUkRPTkxZKQoJCWFjY3RfYXV0b19jbG9zZShzYik7CglzaHJpbmtfZGNhY2hlX3NiKHNiKTsKCWZzeW5jX3N1cGVyKHNiKTsKCgkvKiBJZiB3ZSBhcmUgcmVtb3VudGluZyBSRE9OTFkgYW5kIGN1cnJlbnQgc2IgaXMgcmVhZC93cml0ZSwKCSAgIG1ha2Ugc3VyZSB0aGVyZSBhcmUgbm8gcncgZmlsZXMgb3BlbmVkICovCglpZiAoKGZsYWdzICYgTVNfUkRPTkxZKSAmJiAhKHNiLT5zX2ZsYWdzICYgTVNfUkRPTkxZKSkgewoJCWlmIChmb3JjZSkKCQkJbWFya19maWxlc19ybyhzYik7CgkJZWxzZSBpZiAoIWZzX21heV9yZW1vdW50X3JvKHNiKSkKCQkJcmV0dXJuIC1FQlVTWTsKCX0KCglpZiAoc2ItPnNfb3AtPnJlbW91bnRfZnMpIHsKCQlsb2NrX3N1cGVyKHNiKTsKCQlyZXR2YWwgPSBzYi0+c19vcC0+cmVtb3VudF9mcyhzYiwgJmZsYWdzLCBkYXRhKTsKCQl1bmxvY2tfc3VwZXIoc2IpOwoJCWlmIChyZXR2YWwpCgkJCXJldHVybiByZXR2YWw7Cgl9CglzYi0+c19mbGFncyA9IChzYi0+c19mbGFncyAmIH5NU19STVRfTUFTSykgfCAoZmxhZ3MgJiBNU19STVRfTUFTSyk7CglyZXR1cm4gMDsKfQoKc3RhdGljIHZvaWQgZG9fZW1lcmdlbmN5X3JlbW91bnQodW5zaWduZWQgbG9uZyBmb28pCnsKCXN0cnVjdCBzdXBlcl9ibG9jayAqc2I7CgoJc3Bpbl9sb2NrKCZzYl9sb2NrKTsKCWxpc3RfZm9yX2VhY2hfZW50cnkoc2IsICZzdXBlcl9ibG9ja3MsIHNfbGlzdCkgewoJCXNiLT5zX2NvdW50Kys7CgkJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJCWRvd25fcmVhZCgmc2ItPnNfdW1vdW50KTsKCQlpZiAoc2ItPnNfcm9vdCAmJiBzYi0+c19iZGV2ICYmICEoc2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpKSB7CgkJCS8qCgkJCSAqIC0+cmVtb3VudF9mcyBuZWVkcyBsb2NrX2tlcm5lbCgpLgoJCQkgKgoJCQkgKiBXaGF0IGxvY2sgcHJvdGVjdHMgc2ItPnNfZmxhZ3M/PwoJCQkgKi8KCQkJbG9ja19rZXJuZWwoKTsKCQkJZG9fcmVtb3VudF9zYihzYiwgTVNfUkRPTkxZLCBOVUxMLCAxKTsKCQkJdW5sb2NrX2tlcm5lbCgpOwoJCX0KCQlkcm9wX3N1cGVyKHNiKTsKCQlzcGluX2xvY2soJnNiX2xvY2spOwoJfQoJc3Bpbl91bmxvY2soJnNiX2xvY2spOwoJcHJpbnRrKCJFbWVyZ2VuY3kgUmVtb3VudCBjb21wbGV0ZVxuIik7Cn0KCnZvaWQgZW1lcmdlbmN5X3JlbW91bnQodm9pZCkKewoJcGRmbHVzaF9vcGVyYXRpb24oZG9fZW1lcmdlbmN5X3JlbW91bnQsIDApOwp9CgovKgogKiBVbm5hbWVkIGJsb2NrIGRldmljZXMgYXJlIGR1bW15IGRldmljZXMgdXNlZCBieSB2aXJ0dWFsCiAqIGZpbGVzeXN0ZW1zIHdoaWNoIGRvbid0IHVzZSByZWFsIGJsb2NrLWRldmljZXMuICAtLSBqcnMKICovCgpzdGF0aWMgc3RydWN0IGlkciB1bm5hbWVkX2Rldl9pZHI7CnN0YXRpYyBERUZJTkVfU1BJTkxPQ0sodW5uYW1lZF9kZXZfbG9jayk7LyogcHJvdGVjdHMgdGhlIGFib3ZlICovCgppbnQgc2V0X2Fub25fc3VwZXIoc3RydWN0IHN1cGVyX2Jsb2NrICpzLCB2b2lkICpkYXRhKQp7CglpbnQgZGV2OwoJaW50IGVycm9yOwoKIHJldHJ5OgoJaWYgKGlkcl9wcmVfZ2V0KCZ1bm5hbWVkX2Rldl9pZHIsIEdGUF9BVE9NSUMpID09IDApCgkJcmV0dXJuIC1FTk9NRU07CglzcGluX2xvY2soJnVubmFtZWRfZGV2X2xvY2spOwoJZXJyb3IgPSBpZHJfZ2V0X25ldygmdW5uYW1lZF9kZXZfaWRyLCBOVUxMLCAmZGV2KTsKCXNwaW5fdW5sb2NrKCZ1bm5hbWVkX2Rldl9sb2NrKTsKCWlmIChlcnJvciA9PSAtRUFHQUlOKQoJCS8qIFdlIHJhY2VkIGFuZCBsb3N0IHdpdGggYW5vdGhlciBDUFUuICovCgkJZ290byByZXRyeTsKCWVsc2UgaWYgKGVycm9yKQoJCXJldHVybiAtRUFHQUlOOwoKCWlmICgoZGV2ICYgTUFYX0lEX01BU0spID09ICgxIDw8IE1JTk9SQklUUykpIHsKCQlzcGluX2xvY2soJnVubmFtZWRfZGV2X2xvY2spOwoJCWlkcl9yZW1vdmUoJnVubmFtZWRfZGV2X2lkciwgZGV2KTsKCQlzcGluX3VubG9jaygmdW5uYW1lZF9kZXZfbG9jayk7CgkJcmV0dXJuIC1FTUZJTEU7Cgl9CglzLT5zX2RldiA9IE1LREVWKDAsIGRldiAmIE1JTk9STUFTSyk7CglyZXR1cm4gMDsKfQoKRVhQT1JUX1NZTUJPTChzZXRfYW5vbl9zdXBlcik7Cgp2b2lkIGtpbGxfYW5vbl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglpbnQgc2xvdCA9IE1JTk9SKHNiLT5zX2Rldik7CgoJZ2VuZXJpY19zaHV0ZG93bl9zdXBlcihzYik7CglzcGluX2xvY2soJnVubmFtZWRfZGV2X2xvY2spOwoJaWRyX3JlbW92ZSgmdW5uYW1lZF9kZXZfaWRyLCBzbG90KTsKCXNwaW5fdW5sb2NrKCZ1bm5hbWVkX2Rldl9sb2NrKTsKfQoKRVhQT1JUX1NZTUJPTChraWxsX2Fub25fc3VwZXIpOwoKdm9pZCBfX2luaXQgdW5uYW1lZF9kZXZfaW5pdCh2b2lkKQp7CglpZHJfaW5pdCgmdW5uYW1lZF9kZXZfaWRyKTsKfQoKdm9pZCBraWxsX2xpdHRlcl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiKQp7CglpZiAoc2ItPnNfcm9vdCkKCQlkX2dlbm9jaWRlKHNiLT5zX3Jvb3QpOwoJa2lsbF9hbm9uX3N1cGVyKHNiKTsKfQoKRVhQT1JUX1NZTUJPTChraWxsX2xpdHRlcl9zdXBlcik7CgojaWZkZWYgQ09ORklHX0JMT0NLCnN0YXRpYyBpbnQgc2V0X2JkZXZfc3VwZXIoc3RydWN0IHN1cGVyX2Jsb2NrICpzLCB2b2lkICpkYXRhKQp7CglzLT5zX2JkZXYgPSBkYXRhOwoJcy0+c19kZXYgPSBzLT5zX2JkZXYtPmJkX2RldjsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IHRlc3RfYmRldl9zdXBlcihzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMsIHZvaWQgKmRhdGEpCnsKCXJldHVybiAodm9pZCAqKXMtPnNfYmRldiA9PSBkYXRhOwp9CgpzdGF0aWMgdm9pZCBiZGV2X3VldmVudChzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBlbnVtIGtvYmplY3RfYWN0aW9uIGFjdGlvbikKewoJaWYgKGJkZXYtPmJkX2Rpc2spIHsKCQlpZiAoYmRldi0+YmRfcGFydCkKCQkJa29iamVjdF91ZXZlbnQoJmJkZXYtPmJkX3BhcnQtPmtvYmosIGFjdGlvbik7CgkJZWxzZQoJCQlrb2JqZWN0X3VldmVudCgmYmRldi0+YmRfZGlzay0+a29iaiwgYWN0aW9uKTsKCX0KfQoKaW50IGdldF9zYl9iZGV2KHN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICpmc190eXBlLAoJaW50IGZsYWdzLCBjb25zdCBjaGFyICpkZXZfbmFtZSwgdm9pZCAqZGF0YSwKCWludCAoKmZpbGxfc3VwZXIpKHN0cnVjdCBzdXBlcl9ibG9jayAqLCB2b2lkICosIGludCksCglzdHJ1Y3QgdmZzbW91bnQgKm1udCkKewoJc3RydWN0IGJsb2NrX2RldmljZSAqYmRldjsKCXN0cnVjdCBzdXBlcl9ibG9jayAqczsKCWludCBlcnJvciA9IDA7CgoJYmRldiA9IG9wZW5fYmRldl9leGNsKGRldl9uYW1lLCBmbGFncywgZnNfdHlwZSk7CglpZiAoSVNfRVJSKGJkZXYpKQoJCXJldHVybiBQVFJfRVJSKGJkZXYpOwoKCS8qCgkgKiBvbmNlIHRoZSBzdXBlciBpcyBpbnNlcnRlZCBpbnRvIHRoZSBsaXN0IGJ5IHNnZXQsIHNfdW1vdW50CgkgKiB3aWxsIHByb3RlY3QgdGhlIGxvY2tmcyBjb2RlIGZyb20gdHJ5aW5nIHRvIHN0YXJ0IGEgc25hcHNob3QKCSAqIHdoaWxlIHdlIGFyZSBtb3VudGluZwoJICovCglkb3duKCZiZGV2LT5iZF9tb3VudF9zZW0pOwoJcyA9IHNnZXQoZnNfdHlwZSwgdGVzdF9iZGV2X3N1cGVyLCBzZXRfYmRldl9zdXBlciwgYmRldik7Cgl1cCgmYmRldi0+YmRfbW91bnRfc2VtKTsKCWlmIChJU19FUlIocykpCgkJZ290byBlcnJvcl9zOwoKCWlmIChzLT5zX3Jvb3QpIHsKCQlpZiAoKGZsYWdzIF4gcy0+c19mbGFncykgJiBNU19SRE9OTFkpIHsKCQkJdXBfd3JpdGUoJnMtPnNfdW1vdW50KTsKCQkJZGVhY3RpdmF0ZV9zdXBlcihzKTsKCQkJZXJyb3IgPSAtRUJVU1k7CgkJCWdvdG8gZXJyb3JfYmRldjsKCQl9CgoJCWNsb3NlX2JkZXZfZXhjbChiZGV2KTsKCX0gZWxzZSB7CgkJY2hhciBiW0JERVZOQU1FX1NJWkVdOwoKCQlzLT5zX2ZsYWdzID0gZmxhZ3M7CgkJc3RybGNweShzLT5zX2lkLCBiZGV2bmFtZShiZGV2LCBiKSwgc2l6ZW9mKHMtPnNfaWQpKTsKCQlzYl9zZXRfYmxvY2tzaXplKHMsIGJsb2NrX3NpemUoYmRldikpOwoJCWVycm9yID0gZmlsbF9zdXBlcihzLCBkYXRhLCBmbGFncyAmIE1TX1NJTEVOVCA/IDEgOiAwKTsKCQlpZiAoZXJyb3IpIHsKCQkJdXBfd3JpdGUoJnMtPnNfdW1vdW50KTsKCQkJZGVhY3RpdmF0ZV9zdXBlcihzKTsKCQkJZ290byBlcnJvcjsKCQl9CgoJCXMtPnNfZmxhZ3MgfD0gTVNfQUNUSVZFOwoJCWJkZXZfdWV2ZW50KGJkZXYsIEtPQkpfTU9VTlQpOwoJfQoKCXJldHVybiBzaW1wbGVfc2V0X21udChtbnQsIHMpOwoKZXJyb3JfczoKCWVycm9yID0gUFRSX0VSUihzKTsKZXJyb3JfYmRldjoKCWNsb3NlX2JkZXZfZXhjbChiZGV2KTsKZXJyb3I6CglyZXR1cm4gZXJyb3I7Cn0KCkVYUE9SVF9TWU1CT0woZ2V0X3NiX2JkZXYpOwoKdm9pZCBraWxsX2Jsb2NrX3N1cGVyKHN0cnVjdCBzdXBlcl9ibG9jayAqc2IpCnsKCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYgPSBzYi0+c19iZGV2OwoKCWJkZXZfdWV2ZW50KGJkZXYsIEtPQkpfVU1PVU5UKTsKCWdlbmVyaWNfc2h1dGRvd25fc3VwZXIoc2IpOwoJc3luY19ibG9ja2RldihiZGV2KTsKCWNsb3NlX2JkZXZfZXhjbChiZGV2KTsKfQoKRVhQT1JUX1NZTUJPTChraWxsX2Jsb2NrX3N1cGVyKTsKI2VuZGlmCgppbnQgZ2V0X3NiX25vZGV2KHN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICpmc190eXBlLAoJaW50IGZsYWdzLCB2b2lkICpkYXRhLAoJaW50ICgqZmlsbF9zdXBlcikoc3RydWN0IHN1cGVyX2Jsb2NrICosIHZvaWQgKiwgaW50KSwKCXN0cnVjdCB2ZnNtb3VudCAqbW50KQp7CglpbnQgZXJyb3I7CglzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMgPSBzZ2V0KGZzX3R5cGUsIE5VTEwsIHNldF9hbm9uX3N1cGVyLCBOVUxMKTsKCglpZiAoSVNfRVJSKHMpKQoJCXJldHVybiBQVFJfRVJSKHMpOwoKCXMtPnNfZmxhZ3MgPSBmbGFnczsKCgllcnJvciA9IGZpbGxfc3VwZXIocywgZGF0YSwgZmxhZ3MgJiBNU19TSUxFTlQgPyAxIDogMCk7CglpZiAoZXJyb3IpIHsKCQl1cF93cml0ZSgmcy0+c191bW91bnQpOwoJCWRlYWN0aXZhdGVfc3VwZXIocyk7CgkJcmV0dXJuIGVycm9yOwoJfQoJcy0+c19mbGFncyB8PSBNU19BQ1RJVkU7CglyZXR1cm4gc2ltcGxlX3NldF9tbnQobW50LCBzKTsKfQoKRVhQT1JUX1NZTUJPTChnZXRfc2Jfbm9kZXYpOwoKc3RhdGljIGludCBjb21wYXJlX3NpbmdsZShzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnMsIHZvaWQgKnApCnsKCXJldHVybiAxOwp9CgppbnQgZ2V0X3NiX3NpbmdsZShzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqZnNfdHlwZSwKCWludCBmbGFncywgdm9pZCAqZGF0YSwKCWludCAoKmZpbGxfc3VwZXIpKHN0cnVjdCBzdXBlcl9ibG9jayAqLCB2b2lkICosIGludCksCglzdHJ1Y3QgdmZzbW91bnQgKm1udCkKewoJc3RydWN0IHN1cGVyX2Jsb2NrICpzOwoJaW50IGVycm9yOwoKCXMgPSBzZ2V0KGZzX3R5cGUsIGNvbXBhcmVfc2luZ2xlLCBzZXRfYW5vbl9zdXBlciwgTlVMTCk7CglpZiAoSVNfRVJSKHMpKQoJCXJldHVybiBQVFJfRVJSKHMpOwoJaWYgKCFzLT5zX3Jvb3QpIHsKCQlzLT5zX2ZsYWdzID0gZmxhZ3M7CgkJZXJyb3IgPSBmaWxsX3N1cGVyKHMsIGRhdGEsIGZsYWdzICYgTVNfU0lMRU5UID8gMSA6IDApOwoJCWlmIChlcnJvcikgewoJCQl1cF93cml0ZSgmcy0+c191bW91bnQpOwoJCQlkZWFjdGl2YXRlX3N1cGVyKHMpOwoJCQlyZXR1cm4gZXJyb3I7CgkJfQoJCXMtPnNfZmxhZ3MgfD0gTVNfQUNUSVZFOwoJfQoJZG9fcmVtb3VudF9zYihzLCBmbGFncywgZGF0YSwgMCk7CglyZXR1cm4gc2ltcGxlX3NldF9tbnQobW50LCBzKTsKfQoKRVhQT1JUX1NZTUJPTChnZXRfc2Jfc2luZ2xlKTsKCnN0cnVjdCB2ZnNtb3VudCAqCnZmc19rZXJuX21vdW50KHN0cnVjdCBmaWxlX3N5c3RlbV90eXBlICp0eXBlLCBpbnQgZmxhZ3MsIGNvbnN0IGNoYXIgKm5hbWUsIHZvaWQgKmRhdGEpCnsKCXN0cnVjdCB2ZnNtb3VudCAqbW50OwoJY2hhciAqc2VjZGF0YSA9IE5VTEw7CglpbnQgZXJyb3I7CgoJaWYgKCF0eXBlKQoJCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOwoKCWVycm9yID0gLUVOT01FTTsKCW1udCA9IGFsbG9jX3Zmc21udChuYW1lKTsKCWlmICghbW50KQoJCWdvdG8gb3V0OwoKCWlmIChkYXRhKSB7CgkJc2VjZGF0YSA9IGFsbG9jX3NlY2RhdGEoKTsKCQlpZiAoIXNlY2RhdGEpCgkJCWdvdG8gb3V0X21udDsKCgkJZXJyb3IgPSBzZWN1cml0eV9zYl9jb3B5X2RhdGEodHlwZSwgZGF0YSwgc2VjZGF0YSk7CgkJaWYgKGVycm9yKQoJCQlnb3RvIG91dF9mcmVlX3NlY2RhdGE7Cgl9CgoJZXJyb3IgPSB0eXBlLT5nZXRfc2IodHlwZSwgZmxhZ3MsIG5hbWUsIGRhdGEsIG1udCk7CglpZiAoZXJyb3IgPCAwKQoJCWdvdG8gb3V0X2ZyZWVfc2VjZGF0YTsKCiAJZXJyb3IgPSBzZWN1cml0eV9zYl9rZXJuX21vdW50KG1udC0+bW50X3NiLCBzZWNkYXRhKTsKIAlpZiAoZXJyb3IpCiAJCWdvdG8gb3V0X3NiOwoKCW1udC0+bW50X21vdW50cG9pbnQgPSBtbnQtPm1udF9yb290OwoJbW50LT5tbnRfcGFyZW50ID0gbW50OwoJdXBfd3JpdGUoJm1udC0+bW50X3NiLT5zX3Vtb3VudCk7CglmcmVlX3NlY2RhdGEoc2VjZGF0YSk7CglyZXR1cm4gbW50OwpvdXRfc2I6CglkcHV0KG1udC0+bW50X3Jvb3QpOwoJdXBfd3JpdGUoJm1udC0+bW50X3NiLT5zX3Vtb3VudCk7CglkZWFjdGl2YXRlX3N1cGVyKG1udC0+bW50X3NiKTsKb3V0X2ZyZWVfc2VjZGF0YToKCWZyZWVfc2VjZGF0YShzZWNkYXRhKTsKb3V0X21udDoKCWZyZWVfdmZzbW50KG1udCk7Cm91dDoKCXJldHVybiBFUlJfUFRSKGVycm9yKTsKfQoKRVhQT1JUX1NZTUJPTF9HUEwodmZzX2tlcm5fbW91bnQpOwoKc3RydWN0IHZmc21vdW50ICoKZG9fa2Vybl9tb3VudChjb25zdCBjaGFyICpmc3R5cGUsIGludCBmbGFncywgY29uc3QgY2hhciAqbmFtZSwgdm9pZCAqZGF0YSkKewoJc3RydWN0IGZpbGVfc3lzdGVtX3R5cGUgKnR5cGUgPSBnZXRfZnNfdHlwZShmc3R5cGUpOwoJc3RydWN0IHZmc21vdW50ICptbnQ7CglpZiAoIXR5cGUpCgkJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7CgltbnQgPSB2ZnNfa2Vybl9tb3VudCh0eXBlLCBmbGFncywgbmFtZSwgZGF0YSk7CglwdXRfZmlsZXN5c3RlbSh0eXBlKTsKCXJldHVybiBtbnQ7Cn0KCnN0cnVjdCB2ZnNtb3VudCAqa2Vybl9tb3VudChzdHJ1Y3QgZmlsZV9zeXN0ZW1fdHlwZSAqdHlwZSkKewoJcmV0dXJuIHZmc19rZXJuX21vdW50KHR5cGUsIDAsIHR5cGUtPm5hbWUsIE5VTEwpOwp9CgpFWFBPUlRfU1lNQk9MKGtlcm5fbW91bnQpOwo=