From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from esa3.mentor.iphmx.com (esa3.mentor.iphmx.com [68.232.137.180]) by sourceware.org (Postfix) with ESMTPS id 417F83858012; Mon, 15 Aug 2022 11:06:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 417F83858012 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com X-IronPort-AV: E=Sophos;i="5.93,238,1654588800"; d="diff'?scan'208";a="81179594" Received: from orw-gwy-02-in.mentorg.com ([192.94.38.167]) by esa3.mentor.iphmx.com with ESMTP; 15 Aug 2022 03:06:26 -0800 IronPort-SDR: 0nRELq7TWQAVFovqM13XdIn2VHZy8P/A/PpahawEj52qY4XbTy1M3oO8JVn/zc1tpWIGuggqt9 Q5xLm7WTerPeLwlEqOKL0qfDi2tr9oVRx7WZsKwemeE02rPgcN/E3J1bG+9ZE7VgqNQPs6C5Xz 0chU6/DjYkd4D+dnCDfU9joLIkpmGb0jkRJCR9/pFSkd041T6Y0gJmaKss4Xf5GM+rH1mppwlz pIpvkdASprEZJd/IkRvpoCzAG2HnD+v0qAUYzI/h09LVpoBvU7CkFk4CB4yucUKnD7yG5PpryK nZ0= Content-Type: multipart/mixed; boundary="------------EgEh90duUE7z3iUe8aZ7YpvH" Message-ID: <81de6e4c-b8e1-9bdd-f84d-18a0c0b9806f@codesourcery.com> Date: Mon, 15 Aug 2022 19:06:18 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0) Gecko/20100101 Thunderbird/91.12.0 Content-Language: en-US From: Chung-Lin Tang Subject: [PATCH, OpenMP, Fortran] requires unified_shared_memory 2/2: insert USM allocators into libgfortran To: gcc-patches , Fortran List , Tobias Burnus , Andrew Stubbs , Catherine Moore , Jakub Jelinek X-ClientProxiedBy: SVR-ORW-MBX-09.mgc.mentorg.com (147.34.90.209) To svr-orw-mbx-10.mgc.mentorg.com (147.34.90.210) X-Spam-Status: No, score=-10.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, KAM_MANYTO, SPF_HELO_PASS, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: fortran@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Fortran mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 15 Aug 2022 11:06:32 -0000 --------------EgEh90duUE7z3iUe8aZ7YpvH Content-Type: text/plain; charset="UTF-8"; format=flowed Content-Transfer-Encoding: 7bit After the first libgfortran memory allocator preparation patch, this is the actual patch that organizes unified_shared_memory allocation into libgfortran. In the current OpenMP requires implementation, the requires_mask is collected through offload LTO processing, and presented to libgomp when registering offload images through GOMP_offload_register_ver() (called by the mkoffload generated constructor linked into the program binary) This means that the only reliable place to access omp_requires_mask is in GOMP_offload_register_ver, however since it is called through an ELF constructor in the *main program*, this runs later than libgfortran/runtime/main.c:init() constructor, and because some libgfortran init actions there start allocating memory, this can cause more deallocation errors later. Another issue is that CUDA appears to be registering some cleanup actions using atexit(), which forces libgomp to register gomp_target_fini() using atexit as well (to properly run before the underlying CUDA stuff disappears). This happens to us here as well. So to summarize we need to: (1) order libgfortran init actions after omp_requires_mask processing is done, and (2) order libgfortran cleanup actions before gomp_target_fini, to properly deallocate stuff without crashing. The above explanation is for why there's a little new set of definitions, as well as callback registering functions exported from libgomp to libgfortran, basically to register libgfortran init/fini actions into libgomp to run. Inside GOMP_offload_register_ver, after omp_requires_mask processing is done, we call into libgfortran through a new _gfortran_mem_allocators_init function to insert the omp_free/alloc/etc. based allocators into the Fortran runtime, when GOMP_REQUIRES_UNIFIED_SHARED_MEMORY is set. All symbol references between libgfortran/libgomp are defined with weak symbols. Test of the weak symbols are also used to determine if the other library exists in this program. A final issue is: the case where we have an OpenMP program that does NOT have offloading. We cannot passively determine in libgomp/libgfortran whether offloading exists or not, only the main program itself can, by seeing if the hidden __OFFLOAD_TABLE__ exists. When we do init/fini libgomp callback registering for OpenMP programs, those with no offloading will not have those callback properly run (because of no offload image loading) Therefore the solution here is a constructor added into the crtoffloadend.o fragment that does a "null" call of GOMP_offload_register_ver, solely for triggering the post-offload_register callbacks when __OFFLOAD_TABLE__ is NULL. (and because of this, the crtoffloadend.o Makefile rule is adjusted to compile with PIC) I know this is a big pile of yarn wrt how the main program/libgomp/libgfortran interacts, but it's finally working. Again tested without regressions. Preparing to commit to devel/omp/gcc-12, and seeking approval for mainline when the requires patches are in. Thanks, Chung-Lin 2022-08-15 Chung-Lin Tang libgcc/ * Makefile.in (crtoffloadend$(objext)): Add $(PICFLAG) to compile rule. * offloadstuff.c (GOMP_offload_register_ver): Add declaration of weak symbol. (__OFFLOAD_TABLE__): Likewise. (init_non_offload): New function. libgfortran/ * gfortran.map (GFORTRAN_13): New namespace. (_gfortran_mem_allocators_init): New name inside GFORTRAN_13. * libgfortran.h (mem_allocators_init): New exported declaration. * runtime/main.c (do_init): Rename from init, add run-once guard code. (cleanup): Add run-once guard code. (GOMP_post_offload_register_callback): Declare weak symbol. (GOMP_pre_gomp_target_fini_callback): Likewise. (init): New constructor to register offload callbacks, or call do_init when not OpenMP. * runtime/memory.c (gfortran_malloc): New pointer variable. (gfortran_calloc): Likewise. (gfortran_realloc): Likewise. (gfortran_free): Likewise. (mem_allocators_init): New function. (xmalloc): Use gfortran_malloc. (xmallocarray): Use gfortran_malloc. (xcalloc): Use gfortran_calloc. (xrealloc): Use gfortran_realloc. (xfree): Use gfortran_free. libgomp/ * libgomp.map (GOMP_5.1.2): New version namespace. (GOMP_post_offload_register_callback): New name inside GOMP_5.1.2. (GOMP_pre_gomp_target_fini_callback): Likewise. (GOMP_DEFINE_CALLBACK_SET): Macro to define callback set. (post_offload_register): Define callback set for after offload image register. (pre_gomp_target_fini): Define callback set for before gomp_target_fini is called. (libgfortran_malloc_usm): New function. (libgfortran_calloc_usm): Likewise (libgfortran_realloc_usm): Likewise (libgfortran_free_usm): Likewise. (_gfortran_mem_allocators_init): Declare weak symbol. (gomp_libgfortran_omp_allocators_init): New function. (GOMP_offload_register_ver): Add handling of host_table == NULL, calling into libgfortran to set unified_shared_memory allocators, and execution of post_offload_register callbacks. (gomp_target_init): Register all pre_gomp_target_fini callbacks to run at end of main using atexit(). --------------EgEh90duUE7z3iUe8aZ7YpvH Content-Type: text/plain; charset="UTF-8"; name="b.diff" Content-Disposition: attachment; filename="b.diff" Content-Transfer-Encoding: base64 ZGlmZiAtLWdpdCBhL2xpYmdjYy9NYWtlZmlsZS5pbiBiL2xpYmdjYy9NYWtlZmlsZS5pbgpp bmRleCAwOWIzZWM4Li43MDcyMGNjIDEwMDY0NAotLS0gYS9saWJnY2MvTWFrZWZpbGUuaW4K KysrIGIvbGliZ2NjL01ha2VmaWxlLmluCkBAIC0xMDQ1LDggKzEwNDUsOSBAQCBjcnRiZWdp blQkKG9iamV4dCk6ICQoc3JjZGlyKS9jcnRzdHVmZi5jCiBjcnRvZmZsb2FkYmVnaW4kKG9i amV4dCk6ICQoc3JjZGlyKS9vZmZsb2Fkc3R1ZmYuYwogCSQoY3J0X2NvbXBpbGUpICQoQ1JU U1RVRkZfVF9DRkxBR1MpIC1jICQ8IC1EQ1JUX0JFR0lOCiAKKyMgY3J0b2ZmbG9hZGVuZCBj b250YWlucyBhIGNvbnN0cnVjdG9yIHdpdGggY2FsbHMgdG8gbGliZ29tcCwgc28gYnVpbGQg YXMgUElDLgogY3J0b2ZmbG9hZGVuZCQob2JqZXh0KTogJChzcmNkaXIpL29mZmxvYWRzdHVm Zi5jCi0JJChjcnRfY29tcGlsZSkgJChDUlRTVFVGRl9UX0NGTEFHUykgLWMgJDwgLURDUlRf RU5ECisJJChjcnRfY29tcGlsZSkgJChDUlRTVFVGRl9UX0NGTEFHUykgJChQSUNGTEFHKSAt YyAkPCAtRENSVF9FTkQKIAogY3J0b2ZmbG9hZHRhYmxlJChvYmpleHQpOiAkKHNyY2Rpcikv b2ZmbG9hZHN0dWZmLmMKIAkkKGNydF9jb21waWxlKSAkKENSVFNUVUZGX1RfQ0ZMQUdTKSAt YyAkPCAtRENSVF9UQUJMRQpkaWZmIC0tZ2l0IGEvbGliZ2NjL29mZmxvYWRzdHVmZi5jIGIv bGliZ2NjL29mZmxvYWRzdHVmZi5jCmluZGV4IDEwZTFmZTEuLjJlZGI2ODEgMTAwNjQ0Ci0t LSBhL2xpYmdjYy9vZmZsb2Fkc3R1ZmYuYworKysgYi9saWJnY2Mvb2ZmbG9hZHN0dWZmLmMK QEAgLTYzLDYgKzYzLDE5IEBAIGNvbnN0IHZvaWQgKmNvbnN0IF9fb2ZmbG9hZF92YXJzX2Vu ZFswXQogICBfX2F0dHJpYnV0ZV9fICgoX191c2VkX18sIHZpc2liaWxpdHkgKCJoaWRkZW4i KSwKIAkJICBzZWN0aW9uIChPRkZMT0FEX1ZBUl9UQUJMRV9TRUNUSU9OX05BTUUpKSkgPSB7 IH07CiAKK2V4dGVybiB2b2lkIEdPTVBfb2ZmbG9hZF9yZWdpc3Rlcl92ZXIgKHVuc2lnbmVk LCBjb25zdCB2b2lkICosIGludCwKKwkJCQkgICAgICAgY29uc3Qgdm9pZCAqKTsKK2V4dGVy biBjb25zdCB2b2lkICpjb25zdCBfX09GRkxPQURfVEFCTEVfX1swXSBfX2F0dHJpYnV0ZV9f ICgod2VhaykpOworc3RhdGljIHZvaWQgX19hdHRyaWJ1dGVfXygoY29uc3RydWN0b3IpKQor aW5pdF9ub25fb2ZmbG9hZCAodm9pZCkKK3sKKyAgLyogSWYgYW4gT3Blbk1QIHByb2dyYW0g aGFzIG5vIG9mZmxvYWRpbmcsIHBvc3Qtb2ZmbG9hZF9yZWdpc3RlciBjYWxsYmFja3MKKyAg ICAgdGhhdCBuZWVkIHRvIHJ1biB3aWxsIHJlcXVpcmUgYSBjYWxsIHRvIEdPTVBfb2ZmbG9h ZF9yZWdpc3Rlcl92ZXIsIGluCisgICAgIG9yZGVyIHRvIHByb3Blcmx5IHRyaWdnZXIgdGhv c2UgY2FsbGJhY2tzIGR1cmluZyBpbml0LiAgKi8KKyAgaWYgKF9fT0ZGTE9BRF9UQUJMRV9f ID09IE5VTEwpCisgICAgR09NUF9vZmZsb2FkX3JlZ2lzdGVyX3ZlciAoMCwgTlVMTCwgMCwg TlVMTCk7Cit9CisKICNlbGlmIGRlZmluZWQgQ1JUX1RBQkxFCiAKIGV4dGVybiBjb25zdCB2 b2lkICpjb25zdCBfX29mZmxvYWRfZnVuY190YWJsZVtdOwpkaWZmIC0tZ2l0IGEvbGliZ2Zv cnRyYW4vZ2ZvcnRyYW4ubWFwIGIvbGliZ2ZvcnRyYW4vZ2ZvcnRyYW4ubWFwCmluZGV4IGUw ZTc5NWMuLjU1ZDJhNTIgMTAwNjQ0Ci0tLSBhL2xpYmdmb3J0cmFuL2dmb3J0cmFuLm1hcAor KysgYi9saWJnZm9ydHJhbi9nZm9ydHJhbi5tYXAKQEAgLTE3NTksMyArMTc1OSw4IEBAIEdG T1JUUkFOXzEyIHsKICAgX2dmb3J0cmFuX3RyYW5zZmVyX3JlYWwxMjhfd3JpdGU7CiAjZW5k aWYKIH0gR0ZPUlRSQU5fMTAuMjsKKworR0ZPUlRSQU5fMTMgeworICBnbG9iYWw6CisgIF9n Zm9ydHJhbl9tZW1fYWxsb2NhdG9yc19pbml0OworfSBHRk9SVFJBTl8xMjsKZGlmZiAtLWdp dCBhL2xpYmdmb3J0cmFuL2xpYmdmb3J0cmFuLmggYi9saWJnZm9ydHJhbi9saWJnZm9ydHJh bi5oCmluZGV4IDBiODkzYTUuLmU1MThiMzkgMTAwNjQ0Ci0tLSBhL2xpYmdmb3J0cmFuL2xp Ymdmb3J0cmFuLmgKKysrIGIvbGliZ2ZvcnRyYW4vbGliZ2ZvcnRyYW4uaApAQCAtODc0LDYg Kzg3NCwxMSBAQCBpbnRlcm5hbF9wcm90byh4cmVhbGxvYyk7CiBleHRlcm4gdm9pZCB4ZnJl ZSAodm9pZCAqKTsKIGludGVybmFsX3Byb3RvKHhmcmVlKTsKIAorI2lmbmRlZiBMSUJHRk9S X01JTklNQUwKK2V4dGVybiB2b2lkIG1lbV9hbGxvY2F0b3JzX2luaXQgKHZvaWQgKiwgdm9p ZCAqLCB2b2lkICosIHZvaWQgKik7CitleHBvcnRfcHJvdG8obWVtX2FsbG9jYXRvcnNfaW5p dCk7CisjZW5kaWYKKwogLyogZW52aXJvbi5jICovCiAKIGV4dGVybiB2b2lkIGluaXRfdmFy aWFibGVzICh2b2lkKTsKZGlmZiAtLWdpdCBhL2xpYmdmb3J0cmFuL3J1bnRpbWUvbWFpbi5j IGIvbGliZ2ZvcnRyYW4vcnVudGltZS9tYWluLmMKaW5kZXggNTE2MmE4Zi4uOGFhNjg4ZSAx MDA2NDQKLS0tIGEvbGliZ2ZvcnRyYW4vcnVudGltZS9tYWluLmMKKysrIGIvbGliZ2ZvcnRy YW4vcnVudGltZS9tYWluLmMKQEAgLTYxLDkgKzYxLDE2IEBAIGdldF9hcmdzIChpbnQgKmFy Z2MsIGNoYXIgKioqYXJndikKIAogLyogSW5pdGlhbGl6ZSB0aGUgcnVudGltZSBsaWJyYXJ5 LiAgKi8KIAotc3RhdGljIHZvaWQgX19hdHRyaWJ1dGVfXygoY29uc3RydWN0b3IpKQotaW5p dCAodm9pZCkKK3N0YXRpYyB2b2lkCitkb19pbml0ICh2b2lkKQogeworI2lmbmRlZiBMSUJH Rk9SX01JTklNQUwKKyAgc3RhdGljIGJvb2wgZG9faW5pdF9yYW4gPSBmYWxzZTsKKyAgaWYg KGRvX2luaXRfcmFuKQorICAgIHJldHVybjsKKyAgZG9faW5pdF9yYW4gPSB0cnVlOworI2Vu ZGlmCisKICAgLyogTXVzdCBiZSBmaXJzdCAqLwogICBpbml0X3ZhcmlhYmxlcyAoKTsKIApA QCAtODIsNSArODksMzcgQEAgaW5pdCAodm9pZCkKIHN0YXRpYyB2b2lkIF9fYXR0cmlidXRl X18oKGRlc3RydWN0b3IpKQogY2xlYW51cCAodm9pZCkKIHsKKyNpZm5kZWYgTElCR0ZPUl9N SU5JTUFMCisgIHN0YXRpYyBib29sIGNsZWFudXBfcmFuID0gZmFsc2U7CisgIGlmIChjbGVh bnVwX3JhbikKKyAgICByZXR1cm47CisgIGNsZWFudXBfcmFuID0gdHJ1ZTsKKyNlbmRpZgor CiAgIGNsb3NlX3VuaXRzICgpOwogfQorCisjaWZuZGVmIExJQkdGT1JfTUlOSU1BTAorZXh0 ZXJuIHZvaWQgX19hdHRyaWJ1dGVfXygod2VhaykpCitHT01QX3Bvc3Rfb2ZmbG9hZF9yZWdp c3Rlcl9jYWxsYmFjayAodm9pZCAoKmZ1bmMpKHZvaWQpKTsKKworZXh0ZXJuIHZvaWQgX19h dHRyaWJ1dGVfXygod2VhaykpCitHT01QX3ByZV9nb21wX3RhcmdldF9maW5pX2NhbGxiYWNr ICh2b2lkICgqZnVuYykodm9pZCkpOworI2VuZGlmCisKK3N0YXRpYyB2b2lkIF9fYXR0cmli dXRlX18oKGNvbnN0cnVjdG9yKSkKK2luaXQgKHZvaWQpCit7CisjaWZuZGVmIExJQkdGT1Jf TUlOSU1BTAorICBpZiAoR09NUF9wb3N0X29mZmxvYWRfcmVnaXN0ZXJfY2FsbGJhY2spCisg ICAgeworICAgICAgR09NUF9wb3N0X29mZmxvYWRfcmVnaXN0ZXJfY2FsbGJhY2sgKGRvX2lu aXQpOworICAgICAgR09NUF9wcmVfZ29tcF90YXJnZXRfZmluaV9jYWxsYmFjayAoY2xlYW51 cCk7CisgICAgICByZXR1cm47CisgICAgfQorI2VuZGlmCisKKyAgLyogSWYgbGliZ29tcCBp cyBub3QgcHJlc2VudCwgdGhlbiB3ZSBjYW4gZ28gYWhlYWQgYW5kIGNhbGwgZG9faW5pdAor ICAgICBkaXJlY3RseS4gICovCisgIGRvX2luaXQgKCk7Cit9CmRpZmYgLS1naXQgYS9saWJn Zm9ydHJhbi9ydW50aW1lL21lbW9yeS5jIGIvbGliZ2ZvcnRyYW4vcnVudGltZS9tZW1vcnku YwppbmRleCBjYmNlYzdjLi44YmY1YjYwIDEwMDY0NAotLS0gYS9saWJnZm9ydHJhbi9ydW50 aW1lL21lbW9yeS5jCisrKyBiL2xpYmdmb3J0cmFuL3J1bnRpbWUvbWVtb3J5LmMKQEAgLTI2 LDYgKzI2LDI4IEBAIHNlZSB0aGUgZmlsZXMgQ09QWUlORzMgYW5kIENPUFlJTkcuUlVOVElN RSByZXNwZWN0aXZlbHkuICBJZiBub3QsIHNlZQogI2luY2x1ZGUgImxpYmdmb3J0cmFuLmgi CiAjaW5jbHVkZSA8ZXJybm8uaD4KIAorI2lmbmRlZiBMSUJHRk9SX01JTklNQUwKK3N0YXRp YyB2b2lkICogKCpnZm9ydHJhbl9tYWxsb2MpKHNpemVfdCkgPSBtYWxsb2M7CitzdGF0aWMg dm9pZCAqICgqZ2ZvcnRyYW5fY2FsbG9jKShzaXplX3QsIHNpemVfdCkgPSBjYWxsb2M7Citz dGF0aWMgdm9pZCAqICgqZ2ZvcnRyYW5fcmVhbGxvYykodm9pZCAqLCBzaXplX3QpID0gcmVh bGxvYzsKK3N0YXRpYyB2b2lkICgqZ2ZvcnRyYW5fZnJlZSkodm9pZCAqKSA9IGZyZWU7CisK K3ZvaWQKK21lbV9hbGxvY2F0b3JzX2luaXQgKHZvaWQgKm1hbGxvY19wdHIsIHZvaWQgKmNh bGxvY19wdHIsCisJCSAgICAgdm9pZCAqcmVhbGxvY19wdHIsIHZvaWQgKmZyZWVfcHRyKQor eworICBnZm9ydHJhbl9tYWxsb2MgPSBtYWxsb2NfcHRyOworICBnZm9ydHJhbl9jYWxsb2Mg PSBjYWxsb2NfcHRyOworICBnZm9ydHJhbl9yZWFsbG9jID0gcmVhbGxvY19wdHI7CisgIGdm b3J0cmFuX2ZyZWUgPSBmcmVlX3B0cjsKK30KKworI2Vsc2UKKyNkZWZpbmUgZ2ZvcnRyYW5f bWFsbG9jIG1hbGxvYworI2RlZmluZSBnZm9ydHJhbl9jYWxsb2MgY2FsbG9jCisjZGVmaW5l IGdmb3J0cmFuX3JlYWxsb2MgcmVhbGxvYworI2RlZmluZSBnZm9ydHJhbl9mcmVlIGZyZWUK KyNlbmRpZgogCiB2b2lkICoKIHhtYWxsb2MgKHNpemVfdCBuKQpAQCAtMzUsNyArNTcsNyBA QCB4bWFsbG9jIChzaXplX3QgbikKICAgaWYgKG4gPT0gMCkKICAgICBuID0gMTsKIAotICBw ID0gbWFsbG9jIChuKTsKKyAgcCA9IGdmb3J0cmFuX21hbGxvYyAobik7CiAKICAgaWYgKHAg PT0gTlVMTCkKICAgICBvc19lcnJvciAoIk1lbW9yeSBhbGxvY2F0aW9uIGZhaWxlZCIpOwpA QCAtNTcsNyArNzksNyBAQCB4bWFsbG9jYXJyYXkgKHNpemVfdCBubWVtYiwgc2l6ZV90IHNp emUpCiAgICAgICBvc19lcnJvciAoIkludGVnZXIgb3ZlcmZsb3cgaW4geG1hbGxvY2FycmF5 Iik7CiAgICAgfQogCi0gIHAgPSBtYWxsb2MgKHByb2QpOworICBwID0gZ2ZvcnRyYW5fbWFs bG9jIChwcm9kKTsKIAogICBpZiAoIXApCiAgICAgb3NfZXJyb3IgKCJNZW1vcnkgYWxsb2Nh dGlvbiBmYWlsZWQgaW4geG1hbGxvY2FycmF5Iik7CkBAIC03Myw3ICs5NSw3IEBAIHhjYWxs b2MgKHNpemVfdCBubWVtYiwgc2l6ZV90IHNpemUpCiAgIGlmICghbm1lbWIgfHwgIXNpemUp CiAgICAgbm1lbWIgPSBzaXplID0gMTsKIAotICB2b2lkICpwID0gY2FsbG9jIChubWVtYiwg c2l6ZSk7CisgIHZvaWQgKnAgPSBnZm9ydHJhbl9jYWxsb2MgKG5tZW1iLCBzaXplKTsKICAg aWYgKCFwKQogICAgIG9zX2Vycm9yICgiQWxsb2NhdGluZyBjbGVhcmVkIG1lbW9yeSBmYWls ZWQiKTsKIApAQCAtODYsNyArMTA4LDcgQEAgeHJlYWxsb2MgKHZvaWQgKnB0ciwgc2l6ZV90 IHNpemUpCiAgIGlmIChzaXplID09IDApCiAgICAgc2l6ZSA9IDE7CiAKLSAgdm9pZCAqbmV3 cCA9IHJlYWxsb2MgKHB0ciwgc2l6ZSk7CisgIHZvaWQgKm5ld3AgPSBnZm9ydHJhbl9yZWFs bG9jIChwdHIsIHNpemUpOwogICBpZiAoIW5ld3ApCiAgICAgb3NfZXJyb3IgKCJNZW1vcnkg YWxsb2NhdGlvbiBmYWlsdXJlIGluIHhyZWFsbG9jIik7CiAKQEAgLTk2LDUgKzExOCw1IEBA IHhyZWFsbG9jICh2b2lkICpwdHIsIHNpemVfdCBzaXplKQogdm9pZAogeGZyZWUgKHZvaWQg KnB0cikKIHsKLSAgZnJlZSAocHRyKTsKKyAgZ2ZvcnRyYW5fZnJlZSAocHRyKTsKIH0KZGlm ZiAtLWdpdCBhL2xpYmdvbXAvbGliZ29tcC5tYXAgYi9saWJnb21wL2xpYmdvbXAubWFwCmlu ZGV4IDVhZjVjMmQuLmMzYWY3NWMgMTAwNjQ0Ci0tLSBhL2xpYmdvbXAvbGliZ29tcC5tYXAK KysrIGIvbGliZ29tcC9saWJnb21wLm1hcApAQCAtNjI0LDMgKzYyNCw5IEBAIEdPTVBfUExV R0lOXzEuMyB7CiAJR09NUF9QTFVHSU5fZ29hY2NfcHJvZmlsaW5nX2Rpc3BhdGNoOwogCUdP TVBfUExVR0lOX2dvYWNjX3RocmVhZDsKIH0gR09NUF9QTFVHSU5fMS4yOworCitHT01QXzUu MS4yIHsKKyAgZ2xvYmFsOgorCUdPTVBfcG9zdF9vZmZsb2FkX3JlZ2lzdGVyX2NhbGxiYWNr OworCUdPTVBfcHJlX2dvbXBfdGFyZ2V0X2ZpbmlfY2FsbGJhY2s7Cit9IEdPTVBfNS4xLjE7 CmRpZmYgLS1naXQgYS9saWJnb21wL3RhcmdldC5jIGIvbGliZ29tcC90YXJnZXQuYwppbmRl eCA5OTdiMmFhLi42YTVjMGJiIDEwMDY0NAotLS0gYS9saWJnb21wL3RhcmdldC5jCisrKyBi L2xpYmdvbXAvdGFyZ2V0LmMKQEAgLTI1MjIsNiArMjUyMiw3MCBAQCBnb21wX3JlcXVpcmVz X3RvX25hbWUgKGNoYXIgKmJ1Ziwgc2l6ZV90IHNpemUsIGludCByZXF1aXJlc19tYXNrKQog CQkgICAocCA9PSBidWYgPyAiIiA6ICIsICIpKTsKIH0KIAorLyogTWFjcm8gdG8gZGVmaW5l IGEgY2FsbGJhY2sgc2V0IHdpdGggYSBuYW1lLCBhbmQgcm91dGluZSB0byByZWdpc3Rlcgor ICAgYSBjYWxsYmFjayBmdW5jdGlvbiBpbnRvIHNldC4gICovCisjZGVmaW5lIEdPTVBfREVG SU5FX0NBTExCQUNLX1NFVChuYW1lKQkJCQlcCisgIHN0YXRpYyB1bnNpZ25lZCBpbnQgbnVt XyAjIyBuYW1lICMjIF9jYWxsYmFja3MgPSAwOwkJXAorICBzdGF0aWMgdm9pZCAoKm5hbWUg IyMgX2NhbGxiYWNrc1s0XSkodm9pZCk7CQkJXAorICB2b2lkIEdPTVBfICMjIG5hbWUgIyMg X2NhbGxiYWNrICh2b2lkICgqZm4pKHZvaWQpKQkJXAorICB7CQkJCQkJCQlcCisgICAgaWYg KG51bV8gIyMgbmFtZSAjIyBfY2FsbGJhY2tzCQkJCVwKKwk8IChzaXplb2YgKG5hbWUgIyMg X2NhbGxiYWNrcykJCQkJXAorCSAgIC8gc2l6ZW9mIChuYW1lICMjIF9jYWxsYmFja3NbMF0p KSkJCQlcCisgICAgICB7CQkJCQkJCQlcCisJbmFtZSAjIyBfY2FsbGJhY2tzW251bV8gIyMg bmFtZSAjIyBfY2FsbGJhY2tzXSA9IGZuOwlcCisJbnVtXyAjIyBuYW1lICMjIF9jYWxsYmFj a3MgKz0gMTsJCQlcCisgICAgICB9CQkJCQkJCQlcCisgIH0KK0dPTVBfREVGSU5FX0NBTExC QUNLX1NFVChwb3N0X29mZmxvYWRfcmVnaXN0ZXIpCitHT01QX0RFRklORV9DQUxMQkFDS19T RVQocHJlX2dvbXBfdGFyZ2V0X2ZpbmkpCisjdW5kZWYgR09NUF9ERUZJTkVfQ0FMTEJBQ0tf U0VUCisKKy8qIFJvdXRpbmVzIHRvIGluc2VydCBpbnRvIGxpYmdmb3J0cmFuLCB1bmRlciB1 bmlmaWVkX3NoYXJlZF9tZW1vcnkuICAqLworc3RhdGljIHZvaWQgKgorbGliZ2ZvcnRyYW5f bWFsbG9jX3VzbSAoc2l6ZV90IHNpemUpCit7CisgIHJldHVybiBvbXBfYWxsb2MgKHNpemUs IG9tcHhfdW5pZmllZF9zaGFyZWRfbWVtX2FsbG9jKTsKK30KKworc3RhdGljIHZvaWQgKgor bGliZ2ZvcnRyYW5fY2FsbG9jX3VzbSAoc2l6ZV90IG4sIHNpemVfdCBzaXplKQoreworICBy ZXR1cm4gb21wX2NhbGxvYyAobiwgc2l6ZSwgb21weF91bmlmaWVkX3NoYXJlZF9tZW1fYWxs b2MpOworfQorCitzdGF0aWMgdm9pZCAqCitsaWJnZm9ydHJhbl9yZWFsbG9jX3VzbSAodm9p ZCAqcHRyLCBzaXplX3Qgc2l6ZSkKK3sKKyAgcmV0dXJuIG9tcF9yZWFsbG9jIChwdHIsIHNp emUsIG9tcHhfdW5pZmllZF9zaGFyZWRfbWVtX2FsbG9jLAorCQkgICAgICBvbXB4X3VuaWZp ZWRfc2hhcmVkX21lbV9hbGxvYyk7Cit9CisKK3N0YXRpYyB2b2lkCitsaWJnZm9ydHJhbl9m cmVlX3VzbSAodm9pZCAqcHRyKQoreworICBvbXBfZnJlZSAocHRyLCBvbXB4X3VuaWZpZWRf c2hhcmVkX21lbV9hbGxvYyk7Cit9CisKK2V4dGVybiB2b2lkIF9fYXR0cmlidXRlX18oKHdl YWspKQorX2dmb3J0cmFuX21lbV9hbGxvY2F0b3JzX2luaXQgKHZvaWQgKiwgdm9pZCAqLCB2 b2lkICosIHZvaWQgKik7CisKK3N0YXRpYyB2b2lkCitnb21wX2xpYmdmb3J0cmFuX29tcF9h bGxvY2F0b3JzX2luaXQgKGludCBvbXBfcmVxdWlyZXNfbWFzaykKK3sKKyAgc3RhdGljIGJv b2wgaW5pdCA9IGZhbHNlOworICBpZiAoaW5pdCkKKyAgICByZXR1cm47CisgIGluaXQgPSB0 cnVlOworCisgIGlmICgob21wX3JlcXVpcmVzX21hc2sgJiBHT01QX1JFUVVJUkVTX1VOSUZJ RURfU0hBUkVEX01FTU9SWSkKKyAgICAgICYmIF9nZm9ydHJhbl9tZW1fYWxsb2NhdG9yc19p bml0ICE9IE5VTEwpCisgICAgX2dmb3J0cmFuX21lbV9hbGxvY2F0b3JzX2luaXQgKGxpYmdm b3J0cmFuX21hbGxvY191c20sCisJCQkJICAgbGliZ2ZvcnRyYW5fY2FsbG9jX3VzbSwKKwkJ CQkgICBsaWJnZm9ydHJhbl9yZWFsbG9jX3VzbSwKKwkJCQkgICBsaWJnZm9ydHJhbl9mcmVl X3VzbSk7Cit9CisKIC8qIFRoaXMgZnVuY3Rpb24gc2hvdWxkIGJlIGNhbGxlZCBmcm9tIGV2 ZXJ5IG9mZmxvYWQgaW1hZ2Ugd2hpbGUgbG9hZGluZy4KICAgIEl0IGdldHMgdGhlIGRlc2Ny aXB0b3Igb2YgdGhlIGhvc3QgZnVuYyBhbmQgdmFyIHRhYmxlcyBIT1NUX1RBQkxFLCBUWVBF IG9mCiAgICB0aGUgdGFyZ2V0LCBhbmQgREFUQS4gICovCkBAIC0yNTMyLDYgKzI1OTYsOSBA QCBHT01QX29mZmxvYWRfcmVnaXN0ZXJfdmVyICh1bnNpZ25lZCB2ZXJzaW9uLCBjb25zdCB2 b2lkICpob3N0X3RhYmxlLAogewogICBpbnQgaTsKIAorICBpZiAoaG9zdF90YWJsZSA9PSBO VUxMKQorICAgIGdvdG8gZW5kOworCiAgIGlmIChHT01QX1ZFUlNJT05fTElCICh2ZXJzaW9u KSA+IEdPTVBfVkVSU0lPTikKICAgICBnb21wX2ZhdGFsICgiTGlicmFyeSB0b28gb2xkIGZv ciBvZmZsb2FkICh2ZXJzaW9uICV1IDwgJXUpIiwKIAkJR09NUF9WRVJTSU9OLCBHT01QX1ZF UlNJT05fTElCICh2ZXJzaW9uKSk7CkBAIC0yNTk4LDYgKzI2NjUsMTQgQEAgR09NUF9vZmZs b2FkX3JlZ2lzdGVyX3ZlciAodW5zaWduZWQgdmVyc2lvbiwgY29uc3Qgdm9pZCAqaG9zdF90 YWJsZSwKIAogICBudW1fb2ZmbG9hZF9pbWFnZXMrKzsKICAgZ29tcF9tdXRleF91bmxvY2sg KCZyZWdpc3Rlcl9sb2NrKTsKKworICAvKiBDYWxsIGludG8gbGliZ2ZvcnRyYW4gdG8gaW5p dGlhbGl6ZSBPcGVuTVAgbWVtb3J5IGFsbG9jYXRvcnMuICAqLworICBnb21wX2xpYmdmb3J0 cmFuX29tcF9hbGxvY2F0b3JzX2luaXQgKG9tcF9yZXF1aXJlc19tYXNrKTsKKworIGVuZDoK KyAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1fcG9zdF9vZmZsb2FkX3JlZ2lzdGVyX2NhbGxi YWNrczsgaSsrKQorICAgIHBvc3Rfb2ZmbG9hZF9yZWdpc3Rlcl9jYWxsYmFja3NbaV0gKCk7 CisgIG51bV9wb3N0X29mZmxvYWRfcmVnaXN0ZXJfY2FsbGJhY2tzID0gMDsKIH0KIAogLyog TGVnYWN5IGVudHJ5IHBvaW50LiAgKi8KQEAgLTI3MTAsNyArMjc4NSw3IEBAIGdvbXBfdW5s b2FkX2RldmljZSAoc3RydWN0IGdvbXBfZGV2aWNlX2Rlc2NyICpkZXZpY2VwKQogICBpZiAo ZGV2aWNlcC0+c3RhdGUgPT0gR09NUF9ERVZJQ0VfSU5JVElBTElaRUQpCiAgICAgewogICAg ICAgdW5zaWduZWQgaTsKLSAgICAgIAorCiAgICAgICAvKiBVbmxvYWQgZnJvbSBkZXZpY2Ug YWxsIGltYWdlcyByZWdpc3RlcmVkIGF0IHRoZSBtb21lbnQuICAqLwogICAgICAgZm9yIChp ID0gMDsgaSA8IG51bV9vZmZsb2FkX2ltYWdlczsgaSsrKQogCXsKQEAgLTQ1NzAsNiArNDY0 NSwxMyBAQCBnb21wX3RhcmdldF9pbml0ICh2b2lkKQogICBkZXZpY2VzID0gZGV2czsKICAg aWYgKGF0ZXhpdCAoZ29tcF90YXJnZXRfZmluaSkgIT0gMCkKICAgICBnb21wX2ZhdGFsICgi YXRleGl0IGZhaWxlZCIpOworCisgIC8qIFJlZ2lzdGVyICdwcmVfZ29tcF90YXJnZXRfZmlu aScgY2FsbGJhY2tzIHRvIHJ1biBiZWZvcmUgZ29tcF90YXJnZXRfZmluaQorICAgICBkdXJp bmcgZmluYWxpemF0aW9uLiAgKi8KKyAgZm9yIChpbnQgaSA9IDA7IGkgPCBudW1fcHJlX2dv bXBfdGFyZ2V0X2ZpbmlfY2FsbGJhY2tzOyBpKyspCisgICAgaWYgKGF0ZXhpdCAocHJlX2dv bXBfdGFyZ2V0X2ZpbmlfY2FsbGJhY2tzW2ldKSAhPSAwKQorICAgICAgZ29tcF9mYXRhbCAo ImF0ZXhpdCBmYWlsZWQiKTsKKyAgbnVtX3ByZV9nb21wX3RhcmdldF9maW5pX2NhbGxiYWNr cyA9IDA7CiB9CiAKICNlbHNlIC8qIFBMVUdJTl9TVVBQT1JUICovCg== --------------EgEh90duUE7z3iUe8aZ7YpvH--