From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 7770 invoked by alias); 18 Jan 2013 01:17:19 -0000 Received: (qmail 7761 invoked by uid 22791); 18 Jan 2013 01:17:17 -0000 X-SWARE-Spam-Status: No, hits=-4.5 required=5.0 tests=AWL,BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,KHOP_RCVD_TRUST,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_YE,TW_CP,TW_EG,TW_RV,TW_TR,TW_XS,TW_XZ X-Spam-Check-By: sourceware.org Received: from mail-ob0-f171.google.com (HELO mail-ob0-f171.google.com) (209.85.214.171) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 18 Jan 2013 01:17:05 +0000 Received: by mail-ob0-f171.google.com with SMTP id dn14so3218005obc.2 for ; Thu, 17 Jan 2013 17:17:04 -0800 (PST) X-Received: by 10.182.77.230 with SMTP id v6mr5662021obw.66.1358471824816; Thu, 17 Jan 2013 17:17:04 -0800 (PST) MIME-Version: 1.0 Received: by 10.60.84.5 with HTTP; Thu, 17 Jan 2013 17:16:24 -0800 (PST) In-Reply-To: References: <50AC3217.6040608@mentor.com> <878v9k5g46.fsf@fleche.redhat.com> <87hamy0x0q.fsf@fleche.redhat.com> From: Hui Zhu Date: Fri, 18 Jan 2013 01:17:00 -0000 Message-ID: Subject: Re: [PATCH] Add CTF support to GDB [1/4] Add "-ctf" to tsave command To: "Abid, Hafiz" Cc: Tom Tromey , "Zhu, Hui" , "gdb-patches@sourceware.org" Content-Type: multipart/mixed; boundary=f46d0443ff7e8e3a9b04d385de69 X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2013-01/txt/msg00397.txt.bz2 --f46d0443ff7e8e3a9b04d385de69 Content-Type: text/plain; charset=ISO-8859-1 Content-length: 13708 Hi Abid, Thanks for your review. On Mon, Jan 14, 2013 at 10:27 PM, Abid, Hafiz wrote: > Hi Hui, > I tested your patch and found a few problems. I used 'tsave -ctf output' and then used babeltrace to get a text dump of the output. > > 1. In case of array, the tracing results are off by one. > 2. Struct members values are not shown correctly in case of bitfields. Could you give me some example about this 2 issues? And I just fixed some type issue with while-stepping. I think maybe they were fixed in the new patch. > 3. When I use while-stepping on tracepoints actions, I see some error in the babeltrace. Fixed. And I think it is a good idea for test. So I updated test for this issue. > 4. It looks that TYPE_CODE_FLT is not supported which cause the following warning when I use collect $reg on the tracepoint actions. > "warning: error saving tracepoint 2 "$st0" to CTF file: type is not support." Yes. current patch is still not support all the type of GDB. > > Below are some comments on the code. I see many tab characters in the patch. It may be problem in my editor but something to keep an eye on. > >>+#define CTF_PACKET_SIZE 4096 > It may be my ignorance but is this size sufficient? Should it be possible to increase the limit using some command? Yes, add a command to change current ctf_packet_size is a good idea. Do you mind I add it after CTF patch get commit? Then we can keep focus on the current function of CTF patch. > >>+ /* This is the content size of current packet. */ >>+ size_t content_size; > ... >>+ /* This is the content size of current packet and event that is >>+ being written to file. >>+ Check size use it. */ >>+ size_t current_content_size; > I don't fully understand the difference between these 2 variables. Probably they need a more helpful comment. > I update it to: /* This is the temp value of CONTENT_SIZE when GDB write a event to CTF file. If this event save success, CURRENT_CONTENT_SIZE will set to CONTENT_SIZE. */ size_t current_content_size; >> +error saving tracepoint %d \"%s\" to CTF file: type is not support."), > 'supported' instead of 'support'. Fixed. > >>+ sprintf (regname, "$%s", name); >>+ sprintf (file_name, "%s/%s", dirname, CTF_METADATA_NAME); >>+ sprintf (file_name, "%s/%s", dirname, CTF_DATASTREAM_NAME); > Please use xsnprintf. There are also a bunch of snprintf calls in this file. The size of file_name is alloca as the right size for both this string. So I think this part doesn't need xsnprintf. file_name = alloca (strlen (dirname) + 1 + strlen (CTF_DATASTREAM_NAME) + 1); > >>+ case '$': >>+ collect->ctf_str >>+ = ctf_save_metadata_change_char (collect->ctf_str, >>+ i, "dollar"); > This will change expression like $eip in gdb to dollar_eip in ctf. Does CTF forbid these characters? No. > >>+static void >>+tsv_save_do_loc_arg_collect (const char *print_name, >>+ struct symbol *sym, >>+ void *cb_data) >>+{ >>+ struct loc_arg_collect_data *p = cb_data; >>+ char *name; >>+ >>+ name = alloca (strlen (print_name) + 1); >>+ strcpy (name, print_name); >>+ ctf_save_collect_get_1 (p->tcsp, p->tps, name); >>+} > Is there any real need to make a copy of the print_name? I think it can be passed directly to the ctf_save_collect_get_1. This is because print_name is a const but ctf_save_collect_get_1's argument name need to be a string that is not a const. Added comments for that. > >>+ tmp = alloca (strlen (collect->ctf_str) + 30); >>+ strcpy (tmp, collect->ctf_str); >>+ while (1) >>+ { >>+ struct ctf_save_collect_s *collect2; >>+ int i = 0; >>+ >>+ for (collect2 = tps->collect; collect2; >>+ collect2 = collect2->next) >>+ { >>+ if (collect2->ctf_str >>+ && strcmp (collect2->ctf_str, tmp) == 0) >>+ break; >>+ } >>+ if (collect2 == NULL) >>+ break; >>+ >>+ snprintf (tmp, strlen (collect->ctf_str) + 30, >>+ "%s_%d", collect->ctf_str, i++); >>+ } > What is the purpose of this loop? It only writes a new string in the tmp local variable which is not used after the loop. Fixed. > >>+\"%s\" of tracepoint %d rename to \"%s\" in CTF file."), > I think 'is renamed' will be better instead of rename here. Fixed. > >>+ if (try_count > 1 || 4 + 4 + 4 == tcs.content_size) > what is the significance of this 4 + 4 + 4 Change it to CONTENT_HEADER_SIZE > >>+traceframe %d of tracepoint %d need save data that bigger than packet size %d.\n\ > should be "needs to save data that is bigger than the packet size" Fixed. > >>+traceframe %d is dropped because try to get the value of \"%s\" got error: %s"), > This probably needs to re-phrased. Fixed. > > Also many comments can be improved grammatically. This will make them easier to understand. Please let me know if I need any help there. > > Thanks, > Abid Post a new version according to your comments. Thanks, Hui 2013-01-18 Hui Zhu * Makefile.in (REMOTE_OBS): Add ctf.o. (SFILES): Add ctf.c. (HFILES_NO_SRCDIR): Add ctf.h. * ctf.c, ctf.h: New files. * breakpoint.c (tracepoint_count): Remove static. * mi/mi-main.c (ctf.h): New include. (mi_cmd_trace_save): Add "-ctf". * tracepoint.c (ctf.h): New include. (collect_pseudocommand): Remove static. (trace_save_command): Add "-ctf". (_initialize_tracepoint): Ditto. * tracepoint.h (stack.h): New include. (collect_pseudocommand): Add extern. > > ________________________________________ > From: gdb-patches-owner@sourceware.org [gdb-patches-owner@sourceware.org] on behalf of Hui Zhu [teawater@gmail.com] > Sent: Monday, January 14, 2013 5:18 AM > To: Tom Tromey > Cc: Zhu, Hui; gdb-patches@sourceware.org > Subject: Re: [PATCH] Add CTF support to GDB [1/4] Add "-ctf" to tsave command > > Hi Tom, > > I found a bug when I use test to test this patch. > So I post a new version to fix this bug. > The change of this patch is change the same type check to: > static void > ctf_save_type_define_write (struct ctf_save_s *tcsp, struct type *type) > { > struct ctf_save_type_s *t; > > for (t = tcsp->type; t; t = t->next) > { > if (t->type == type > || (TYPE_NAME (t->type) && TYPE_NAME (type) > && strcmp (TYPE_NAME (t->type), TYPE_NAME (type)) == 0)) > return; > } > > Thanks, > Hui > > On Tue, Jan 8, 2013 at 9:40 AM, Hui Zhu wrote: >> Hi Tom, >> >> Thanks for your review. >> >> On Fri, Jan 4, 2013 at 5:36 AM, Tom Tromey wrote: >>>>>>>> "Hui" == Hui Zhu writes: >>> >>> Hui> +struct ctf_save_collect_s >>> Hui> +{ >>> Hui> + struct ctf_save_collect_s *next; >>> Hui> + char *str; >>> Hui> + char *ctf_str; >>> Hui> + int align_size; >>> Hui> + struct expression *expr; >>> Hui> + struct type *type; >>> Hui> + int is_ret; >>> Hui> +}; >>> >>>>> Like Hafiz said -- comments would be nice. >>> >>> Hui> I added some comments in the new patches. >>> >>> I looked at the new patches and did not see comments. For example, I >>> looked at this struct I quoted above. >>> >>> Every new structure, field, and function ought to have a comment. >> >> OK. I added comments for them in the new patch. >> >>> >>> >>> Hui> + case TYPE_CODE_ARRAY: >>> Hui> + for (; TYPE_CODE (type) == TYPE_CODE_ARRAY; >>> Hui> + type = TYPE_TARGET_TYPE (type)) >>> Hui> + ; >>> >>> Tom> You probably want some check_typedef calls in there. >>> >>> Hui> Because typedef will be handle as a type in this part, so this part >>> Hui> doesn't need check_typedef. >>> >>> That seems peculiar to me, but I don't really know CTF. >>> In this case you need a comment, since the result will be non-obvious to >>> gdb developers. >>> >>> Tom> check_typedef; though if your intent is to peel just a single layer, >>> Tom> then it is a bit trickier -- I think the best you can do is always call >>> Tom> it, then use TYPE_TARGET_TYPE if it is non-NULL or the result of >>> Tom> check_typedef otherwise. >>> >>> Hui> If use check_typedef, this part will generate the define that >>> Hui> different with the type descriptor of the code. >>> >>> You need to call check_typedef before you can even examine >>> TYPE_TARGET_TYPE of a typedef. This is what I meant by using it before >>> using TYPE_TARGET_TYPE. Otherwise with stubs I think you will see >>> crashes -- check_typedef is what sets this field. >>> >>> If you then use TYPE_TARGET_TYPE and get NULL, you ought to instead use >>> the result of check_typedef. This means the stub had to resolve to a >>> typedef in a different objfile. >> >> I change it to following part: >> case TYPE_CODE_ARRAY: >> /* This part just to get the real name of this array. >> This part should keep typedef if it can. */ >> for (; TYPE_CODE (type) == TYPE_CODE_ARRAY; >> type = TYPE_TARGET_TYPE (type) ? TYPE_TARGET_TYPE (type) >> : check_typedef (type)) >> ; >> >>> >>> Hui> If use TYPE_TARGET_TYPE, it will generate following metadata: >>> Hui> typedef char test_t1; >>> Hui> typedef test_t1 test_t2; >>> Hui> typedef test_t2 test_t3; >>> >>> I suppose there should be a test case doing this. >> >> OK. I will write a test for all this function. >> >>> >>> Hui> + case TYPE_CODE_PTR: >>> Hui> + align_size = TYPE_LENGTH (type); >>> Hui> + break; >>> >>> Tom> Surely the alignment rules are ABI dependent. >>> Tom> I would guess that what you have will work in many cases, but definitely >>> Tom> not all of them. >>> >>> Hui> All the type will be handle and record in function >>> Hui> ctf_save_type_check_and_write. >>> Hui> The size align will be handle in this function too. >>> >>> I don't think this really addresses the issue. >>> Not all platforms use the alignment rules currently coded in >>> ctf_save_type_check_and_write. But maybe it doesn't matter. >>> >>> Hui> + frame = get_current_frame (); >>> Hui> + if (!frame) >>> Hui> + error (_("get current frame fail")); >>> Hui> + frame = get_prev_frame (frame); >>> Hui> + if (!frame) >>> Hui> + error (_("get prev frame fail")); >>> Tom> >>> Tom> These messages could be improved. >>> >>> Actually, I don't think get_current_frame can return NULL, can it? >>> >>> For the second error, how about "could not find previous frame"? >> >> Fixed. >> >>> >>> Hui> + warning (_("\ >>> Hui> +Not save \"%s\" of tracepoint %d to ctf file because get its >>> Hui> value fail: %s"), >>> Hui> + str, tps->tp->base.number, e.message); >>> Tom> >>> Tom> Likewise. >>> >>> Hui> Could you help me with this part? :) >>> >>> How about "error saving tracepoint %d to CTF file %s: %s". >> >> It is more better. I updated them all. >> >>> >>> Tom> Although, this approach just seems weird, since it seems like you >>> Tom> already have the symbol and you want its value; constructing and parsing >>> Tom> an expression to get this is very roundabout. >>> Tom> >>> Tom> I'm not sure I really understand the goal here; but the parsing approach >>> Tom> is particularly fragile if you have shadowing. >>> >>> Hui> Function ctf_save_collect_get will parse the collect string and add >>> Hui> them to struct. >>> Hui> Each tracepoint will call this function just once. >>> >>> Ok, I don't know the answer here. >> >> I am sorry that this part is not very clear. So I update the comments >> of ctf_save_collect_get to: >> /* Get var that want to collect from STR and put them to TPS->collect. >> This function will not be call when GDB add a new TP. */ >> >> static void >> ctf_save_collect_get (struct ctf_save_s *tcsp, struct ctf_save_tp_s *tps, >> char *str) >> >> How about this? >> >>> >>> Tom> Hmm, a lot of this code looks like code from tracepoint.c. >>> Tom> I think it would be better to share the code if that is possible. >>> >>> Hui> I tried to share code with function add_local_symbols. But it is not >>> Hui> a big function and use different way to get block. >>> >>> I wonder why, and whether this means that the different ways of saving >>> will in fact write out different data. >> >> I added function add_local_symbols_1 for that. >> >>> >>> Hui> + if (collect->expr) >>> Hui> + free_current_contents (&collect->expr); >>> >>> Tom> Why free_current_contents here? >>> Tom> That seems weird. >>> >>> Hui> If this collect is $_ret, it will not have collect->expr. Or maybe >>> Hui> this collect will be free because when setup this collect get >>> Hui> error. So check it before free it. >>> >>> You can just write xfree (collect->expr). >>> You don't need a NULL check here. >>> This applies to all those xfree calls. >>> >> >> OK. Fixed. >> >> I post a new version. Please help me review it. >> >> Thanks, >> Hui >> >> 2013-01-08 Hui Zhu >> >> * Makefile.in (REMOTE_OBS): Add ctf.o. >> (SFILES): Add ctf.c. >> (HFILES_NO_SRCDIR): Add ctf.h. >> * ctf.c, ctf.h: New files. >> * mi/mi-main.c (ctf.h): New include. >> (mi_cmd_trace_save): Add "-ctf". >> * tracepoint.c (ctf.h): New include. >> (collect_pseudocommand): Remove static. >> (trace_save_command): Add "-ctf". >> (_initialize_tracepoint): Ditto. >> * tracepoint.h (stack.h): New include. >> (collect_pseudocommand): Add extern. --f46d0443ff7e8e3a9b04d385de69 Content-Type: text/plain; charset=US-ASCII; name="tsave-ctf.txt" Content-Disposition: attachment; filename="tsave-ctf.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hc2mfz3j0 Content-length: 58569 LS0tIGEvTWFrZWZpbGUuaW4KKysrIGIvTWFrZWZpbGUuaW4KQEAgLTUwOCw3 ICs1MDgsNyBAQCBTRVJfSEFSRFdJUkUgPSBAU0VSX0hBUkRXSVJFQAogIyBU aGUgYHJlbW90ZScgZGVidWdnaW5nIHRhcmdldCBpcyBzdXBwb3J0ZWQgZm9y IG1vc3QgYXJjaGl0ZWN0dXJlcywKICMgYnV0IG5vdCBhbGwgKGUuZy4gOTYw KQogUkVNT1RFX09CUyA9IHJlbW90ZS5vIGRjYWNoZS5vIHRyYWNlcG9pbnQu byBheC1nZW5lcmFsLm8gYXgtZ2RiLm8gcmVtb3RlLWZpbGVpby5vIFwKLQly ZW1vdGUtbm90aWYubworCXJlbW90ZS1ub3RpZi5vIGN0Zi5vCiAKICMgVGhp cyBpcyByZW1vdGUtc2ltLm8gaWYgYSBzaW11bGF0b3IgaXMgdG8gYmUgbGlu a2VkIGluLgogU0lNX09CUyA9IEBTSU1fT0JTQApAQCAtNzU1LDcgKzc1NSw3 IEBAIFNGSUxFUyA9IGFkYS1leHAueSBhZGEtbGFuZy5jIGFkYS10eXBlcHIK IAlyZWdzZXQuYyBzb2wtdGhyZWFkLmMgd2luZG93cy10ZXJtY2FwLmMgXAog CWNvbW1vbi9nZGJfdmVjcy5jIGNvbW1vbi9jb21tb24tdXRpbHMuYyBjb21t b24veG1sLXV0aWxzLmMgXAogCWNvbW1vbi9wdGlkLmMgY29tbW9uL2J1ZmZl ci5jIGdkYi1kbGZjbi5jIGNvbW1vbi9hZ2VudC5jIFwKLQljb21tb24vZm9y bWF0LmMKKwljb21tb24vZm9ybWF0LmMgY3RmLmMKIAogTElOVEZJTEVTID0g JChTRklMRVMpICQoWVlGSUxFUykgJChDT05GSUdfU1JDUykgaW5pdC5jCiAK QEAgLTgzMSw3ICs4MzEsNyBAQCBnbnVsaWIvaW1wb3J0L3N0ZGRlZi5pbi5o IGdudWxpYi9pbXBvcnQvCiBjb21tb24vY29tbW9uLXV0aWxzLmggY29tbW9u L3htbC11dGlscy5oIGNvbW1vbi9idWZmZXIuaCBjb21tb24vcHRpZC5oIFwK IGNvbW1vbi9mb3JtYXQuaCBjb21tb24vaG9zdC1kZWZzLmggdXRpbHMuaCBj b21tb24vcXVldWUuaCBcCiBjb21tb24vbGludXgtb3NkYXRhLmggZ2RiLWRs ZmNuLmggYXV0by1sb2FkLmggcHJvYmUuaCBzdGFwLXByb2JlLmggXAotZ2Ri X2JmZC5oIHNwYXJjLXJhdmVuc2Nhci10aHJlYWQuaCBwcGMtcmF2ZW5zY2Fy LXRocmVhZC5oCitnZGJfYmZkLmggc3BhcmMtcmF2ZW5zY2FyLXRocmVhZC5o IHBwYy1yYXZlbnNjYXItdGhyZWFkLmggY3RmLmgKIAogIyBIZWFkZXIgZmls ZXMgdGhhdCBhbHJlYWR5IGhhdmUgc3JjZGlyIGluIHRoZW0sIG9yIHdoaWNo IGFyZSBpbiBvYmpkaXIuCiAKLS0tIGEvYnJlYWtwb2ludC5jCisrKyBiL2Jy ZWFrcG9pbnQuYwpAQCAtNjE1LDcgKzYxNSw3IEBAIHN0YXRpYyBpbnQgcHJl dl9icmVha3BvaW50X2NvdW50OwogCiAvKiBOdW1iZXIgb2YgbGFzdCB0cmFj ZXBvaW50IG1hZGUuICAqLwogCi1zdGF0aWMgaW50IHRyYWNlcG9pbnRfY291 bnQ7CitpbnQgdHJhY2Vwb2ludF9jb3VudDsKIAogc3RhdGljIHN0cnVjdCBj bWRfbGlzdF9lbGVtZW50ICpicmVha3BvaW50X3NldF9jbWRsaXN0Owogc3Rh dGljIHN0cnVjdCBjbWRfbGlzdF9lbGVtZW50ICpicmVha3BvaW50X3Nob3df Y21kbGlzdDsKLS0tIC9kZXYvbnVsbAorKysgYi9jdGYuYwpAQCAtMCwwICsx LDEzNDAgQEAKKy8qIENURiBmb3JtYXQgc3VwcG9ydC4KKworICAgQ29weXJp Z2h0IChDKSAyMDEyLTIwMTMgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuCisKKyAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEdEQi4KKworICAgVGhp cyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIg dmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAgKGF0IHlvdXIgb3B0 aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhpcyBwcm9ncmFtIGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgIGFsb25nIHdp dGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251 Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworI2luY2x1ZGUgImRlZnMuaCIKKyNp bmNsdWRlICJjdGYuaCIKKyNpbmNsdWRlICJ0cmFjZXBvaW50LmgiCisjaW5j bHVkZSAicmVnY2FjaGUuaCIKKyNpbmNsdWRlICJnZGJjbWQuaCIKKyNpbmNs dWRlICJleGNlcHRpb25zLmgiCisjaW5jbHVkZSAic3RhY2suaCIKKworI2lu Y2x1ZGUgPGN0eXBlLmg+CisKKy8qIEZvbGxvd2luZyBwYXJ0IGlzIGZvciB0 c2F2ZS4gICovCisKKyNkZWZpbmUgQ1RGX01BR0lDCQkweEMxRkMxRkMxCisj ZGVmaW5lIENURl9TQVZFX01BSk9SCQkxCisjZGVmaW5lIENURl9TQVZFX01J Tk9SCQk4CisKKyNkZWZpbmUgQ1RGX01FVEFEQVRBX05BTUUJIm1ldGFkYXRh IgorI2RlZmluZSBDVEZfREFUQVNUUkVBTV9OQU1FCSJkYXRhc3RyZWFtIgor CisjZGVmaW5lIENURl9QQUNLRVRfU0laRQkJNDA5NgorCisjZGVmaW5lIEFM SUdOX1NJWkUoc2l6ZSwgYWxpZ24pIFwKKwkoKCgoYWxpZ24pICsgKHNpemUp IC0gMSkgJiAofigoYWxpZ24pIC0gMSkpKSAtIChzaXplKSkKKworLyogVGhl IGVudHJ5IG9mIGNvbGxlY3QgbGlzdCBvZiBhIFRQLiAgKi8KKworc3RydWN0 IGN0Zl9zYXZlX2NvbGxlY3RfcworeworICBzdHJ1Y3QgY3RmX3NhdmVfY29s bGVjdF9zICpuZXh0OworCisgIC8qIFBvaW50IHRoZSBvcmlnaW5hbCBjb2xs ZWN0IHN0cmluZy4gICovCisKKyAgY2hhciAqc3RyOworCisgIC8qIFBvaW50 IHN0cmluZyB0aGUgY29udmVydCBmcm9tIFNUUiB0byB0aGUgZm9ybWF0Cisg ICAgIHRoYXQgY2FuIHNhdmUgdG8gQ1RGLiAqLworCisgIGNoYXIgKmN0Zl9z dHI7CisKKyAgLyogQWxpZ24gc2l6ZSBvZiB0aGlzIGNvbGxlY3QuICAqLwor CisgIGludCBhbGlnbl9zaXplOworCisgIC8qIFRoZSBleHByZXNzaW9uIHRo YXQgZ2V0IGZyb20gU1RSLiAqLworCisgIHN0cnVjdCBleHByZXNzaW9uICpl eHByOworCisgIC8qIFRoZSB0eXBlIG9mIHRoaXMgY29sbGVjdC4gICovCisK KyAgc3RydWN0IHR5cGUgKnR5cGU7CisKKyAgLyogSWYgdHJ1ZSwgdGhpcyBj b2xsZWN0IGlzICRfcmV0LiAgKi8KKworICBpbnQgaXNfcmV0OworfTsKKwor LyogVGhlIGVudHJ5IG9mIHRyYWNlcG9pbnQgbGlzdCB0aGF0IHdpbGwgc2F2 ZSB0byBDVEYuICAqLworCitzdHJ1Y3QgY3RmX3NhdmVfdHBfcworeworICBz dHJ1Y3QgY3RmX3NhdmVfdHBfcyAqbmV4dDsKKworICBzdHJ1Y3QgdHJhY2Vw b2ludCAqdHA7CisKKyAgLyogSWYgdHJ1ZSwgdGhpcyBpcyB0aGUgc3RlcCBj b2xsZWN0IG9mIHRoaXMgVFAuCisgICAgIERpdmlkZSBUUCB0byBub24tc3Rl cCBjb2xsZWN0IGFuZCBzdGVwIGNvbGxlY3QKKyAgICAgYmVjYXVzZSB0aGV5 IGNvbGxlY3QgZGlmZmVyZW50IHZhbHVlLiAgKi8KKworICBpbnQgc3RlcHBp bmdfZnJhbWU7CisKKyAgLyogVGhpcyBpcyB0aGUgaWQgdGhhdCB3aWxsIHNh dmUgdG8gQ1RGIGZpbGUuCisgICAgIERvZXNuJ3QgdXNlIFRQUy0+VFAtPkJB U0UuTlVNQkVSIGRpcmVjdGx5IGJlY2F1c2Ugc3RlcHBpbmdfZnJhbWUKKyAg ICAgZXZlbnQgbmVlZCB1c2UgZGlmZmVyZW50IHdpdGggb3JpZ2luYWwgZXZl bnQuICAqLworICBpbnQgaWQ7CisKKyAgLyogVGhlIGNvbGxlY3QgbGlzdCBm b3IgdGhpcyBUUC4gICovCisKKyAgc3RydWN0IGN0Zl9zYXZlX2NvbGxlY3Rf cyAqY29sbGVjdDsKKworICAvKiBFYWNoIHRyYWNlZnJhbWUgZW50cnkgb2Yg YSB0cmFjZXBvaW50IHdpbGwgc2F2ZSBhcyBhIGRhdGEgZm9ybWF0CisgICAg IGxpa2UgYSBzdHJ1Y3QuCisgICAgIFRoaXMgaXMgdGhlIGFsaWduIHNpemUg b2YgdGhpcyBzdHJ1Y3QuICAqLworCisgIGludCBhbGlnbl9zaXplOworCisg IC8qIElmIHRydWUsIHRoZSBzaXplIG9mIHRoaXMgc3RydWN0IGlzIHZhcmlh YmxlLiAgKi8KKworICBpbnQgaXNfdmFyaWFibGVfbGVuZ3RoOworCisgIC8q IElmIHRydWUsIGFsbCB0aGUgdHJhY2VmcmFtZSBlbnRyeSBvZiB0aGlzIFRQ IHdpbGwgbm90IHNhdmUgdG8gQ1RGLgorICAgICBBZGQgYSBmbGFnIGluc3Rl YWQgb2YganVzdCByZW1vdmUgdGhpcyBzdHJ1Y3QgYmVjYXVzZSBHREIganVz dCBjYW4KKyAgICAgZ2V0IHRyYWNlcG9pbnQgaW5mb3JtYXRpb24gdGhyb3Vn aCB0cmFjZWZyYW1lIGVudHJ5LgorICAgICBJZiBqdXN0IHJlbW92ZSB0aGlz IHN0cnVjdCwgR0RCIHdpbGwgYWRkIGEgbmV3IHN0cnVjdCB3aGVuIEdEQiBn ZXQKKyAgICAgYW5vdGhlciB0cmFjZWZyYW1lIG9mIHRoaXMgVFAuCisgICAg IFVzZSBhIGZsYWcsIHdoZW4gR0RCIGdldCBhbm90aGVyIHRyYWNlZnJhbWUg b2YgdGhpcyBUUCwgR0RCIHdpbGwKKyAgICAga25vdyB0aGlzIHRyYWNlZnJh bWUgbmVlZCB0byBiZSBkcm9wcGVkIHdoZW4gaXQgZ2V0IGl0IHRocm91Z2gK KyAgICAgdGhpcyBmbGFnLiAgKi8KKworICBpbnQgaXNfZHJvcHBlZDsKK307 CisKKy8qIFRoZSBlbnRyeSBvZiB0eXBlIGxpc3QgdGhhdCB3aWxsIHNhdmUg dG8gQ1RGLiAgKi8KKworc3RydWN0IGN0Zl9zYXZlX3R5cGVfcworeworICBz dHJ1Y3QgY3RmX3NhdmVfdHlwZV9zICpuZXh0OworCisgIHN0cnVjdCB0eXBl ICp0eXBlOworfTsKKworLyogVGhlIGRhdGEgc3RydWN0IGZvciBDVEZfU0FW RS4gICovCisKK3N0cnVjdCBjdGZfc2F2ZV9zCit7CisgIEZJTEUgKm1ldGFk YXRhX2ZkOworICBGSUxFICpkYXRhc3RyZWFtX2ZkOworCisgIC8qIFRoaXMg aXMgdGhlIGNvbnRlbnQgc2l6ZSBvZiBjdXJyZW50IHBhY2tldC4gICovCisg IHNpemVfdCBjb250ZW50X3NpemU7CisKKyAgLyogVGhpcyBpcyB0aGUgYmVn aW4gb2Zmc2V0IG9mIGN1cnJlbnQgcGFja2V0LiAgKi8KKyAgbG9uZyBwYWNr ZXRfYmVnaW47CisKKyAgLyogSWYgdHJ1ZSwgbmVlZCBjaGVjayBpZiBjb250 ZW50X3NpemUgYmlnZ2VyIHRoYW4gQ1RGX1BBQ0tFVF9TSVpFLiAgKi8KKyAg aW50IGNoZWNrX3NpemU7CisKKyAgLyogVGhpcyBpcyB0aGUgdGVtcCB2YWx1 ZSBvZiBDT05URU5UX1NJWkUgd2hlbiBHREIgd3JpdGUgYSBldmVudCB0bwor ICAgICBDVEYgZmlsZS4KKyAgICAgSWYgdGhpcyBldmVudCBzYXZlIHN1Y2Nl c3MsIENVUlJFTlRfQ09OVEVOVF9TSVpFIHdpbGwgc2V0IHRvCisgICAgIENP TlRFTlRfU0laRS4gICovCisgIHNpemVfdCBjdXJyZW50X2NvbnRlbnRfc2l6 ZTsKKworICAvKiBTYXZlIHRoZSBudW1iZXIgb2YgdHJhY2UgZnJhbWUgYmVm b3JlIGNhbGwgY3RmX3NhdmUuCisgICAgIFNldCBpdCBiYWNrIHdoZW4gcmV0 dXJuIGN0Zl9zYXZlLiAgKi8KKyAgaW50IG9sZF90cmFjZWZyYW1lX251bTsK KworICAvKiBUcmFjZXBvaW50IGxpc3QuICAqLworICBzdHJ1Y3QgY3RmX3Nh dmVfdHBfcyAqdHA7CisKKyAgLyogVHlwZSBsaXN0LiAgKi8KKyAgc3RydWN0 IGN0Zl9zYXZlX3R5cGVfcyAqdHlwZTsKKworICBjb25zdCBjaGFyICp0YWI7 Cit9OworCitzdGF0aWMgdm9pZAorY3RmX3NhdmVfZndyaXRlIChGSUxFICpm ZCwgY29uc3QgZ2RiX2J5dGUgKmJ1Ziwgc2l6ZV90IHNpemUpCit7CisgIGlm IChmd3JpdGUgKGJ1Ziwgc2l6ZSwgMSwgZmQpICE9IDEpCisgICAgZXJyb3Ig KF8oIlVuYWJsZSB0byB3cml0ZSBmaWxlIGZvciBzYXZpbmcgdHJhY2UgZGF0 YSAoJXMpIiksCisJICAgc2FmZV9zdHJlcnJvciAoZXJybm8pKTsKK30KKwor c3RhdGljIHZvaWQKK2N0Zl9zYXZlX2Z3cml0ZV9mb3JtYXRfMSAoRklMRSAq ZmQsIGNvbnN0IGNoYXIgKmZvcm1hdCwgdmFfbGlzdCBhcmdzKQoreworICBj aGFyICpsaW5lYnVmZmVyOworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFu dXBzOworCisgIGxpbmVidWZmZXIgPSB4c3RydnByaW50ZiAoZm9ybWF0LCBh cmdzKTsKKyAgb2xkX2NsZWFudXBzID0gbWFrZV9jbGVhbnVwICh4ZnJlZSwg bGluZWJ1ZmZlcik7CisgIGN0Zl9zYXZlX2Z3cml0ZSAoZmQsIGxpbmVidWZm ZXIsIHN0cmxlbiAobGluZWJ1ZmZlcikpOworICBkb19jbGVhbnVwcyAob2xk X2NsZWFudXBzKTsKK30KKworLyogV3JpdGUgZGF0YSBpbiBGT1JNQVQgdG8g RkQuICAqLworCitzdGF0aWMgdm9pZAorY3RmX3NhdmVfZndyaXRlX2Zvcm1h dCAoRklMRSAqZmQsIGNvbnN0IGNoYXIgKmZvcm1hdCwgLi4uKQoreworICB2 YV9saXN0IGFyZ3M7CisKKyAgdmFfc3RhcnQgKGFyZ3MsIGZvcm1hdCk7Cisg IGN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXRfMSAoZmQsIGZvcm1hdCwgYXJncyk7 CisgIHZhX2VuZCAoYXJncyk7Cit9CisKKy8qIFdyaXRlIEJVRiB0aGF0IHNp emUgaXMgU0laRSB0byBkYXRhc3RyZWFtIGZpbGUuICAqLworCitzdGF0aWMg aW50CitjdGZfc2F2ZV93cml0ZSAoc3RydWN0IGN0Zl9zYXZlX3MgKnRjc3As IGNvbnN0IGdkYl9ieXRlICpidWYsIHNpemVfdCBzaXplKQoreworICBpZiAo dGNzcC0+Y2hlY2tfc2l6ZSkKKyAgICB7CisgICAgICBpZiAodGNzcC0+Y3Vy cmVudF9jb250ZW50X3NpemUgKyBzaXplID4gQ1RGX1BBQ0tFVF9TSVpFKQor ICAgICAgICByZXR1cm4gLTE7CisgICAgfQorCisgIGN0Zl9zYXZlX2Z3cml0 ZSAodGNzcC0+ZGF0YXN0cmVhbV9mZCwgYnVmLCBzaXplKTsKKworICB0Y3Nw LT5jdXJyZW50X2NvbnRlbnRfc2l6ZSArPSBzaXplOworCisgIHJldHVybiAw OworfQorCisvKiBTZXQgZGF0YXN0cmVhbSBmaWxlIHBvc2l0aW9uIGluZGlj YXRvciBhY2NvcmRpbmcgdG8gT0ZGU0VUCisgICBhbmQgV0hFTkNFLiAgKi8K Kworc3RhdGljIGludAorY3RmX3NhdmVfZnNlZWsgKHN0cnVjdCBjdGZfc2F2 ZV9zICp0Y3NwLCBsb25nIG9mZnNldCwgaW50IHdoZW5jZSkKK3sKKyAgaWYg KHdoZW5jZSA9PSBTRUVLX0NVUiAmJiB0Y3NwLT5jaGVja19zaXplKQorICAg IHsKKyAgICAgIGlmICh0Y3NwLT5jdXJyZW50X2NvbnRlbnRfc2l6ZSArIG9m ZnNldCA+IENURl9QQUNLRVRfU0laRSkKKyAgICAgICAgcmV0dXJuIC0xOwor ICAgIH0KKworICBpZiAoZnNlZWsgKHRjc3AtPmRhdGFzdHJlYW1fZmQsIG9m ZnNldCwgd2hlbmNlKSkKKyAgICBlcnJvciAoXygiVW5hYmxlIHRvIHNlZWsg ZmlsZSBmb3Igc2F2aW5nIHRyYWNlIGRhdGEgKCVzKSIpLAorCSAgIHNhZmVf c3RyZXJyb3IgKGVycm5vKSk7CisKKyAgaWYgKHdoZW5jZSA9PSBTRUVLX0NV UikKKyAgICB0Y3NwLT5jdXJyZW50X2NvbnRlbnRfc2l6ZSArPSBvZmZzZXQ7 CisKKyAgcmV0dXJuIDA7Cit9CisKKy8qIEFsaWduZWQgQUxJR05fU0laRSB3 cml0ZSBCVUYgdGhhdCBzaXplIGlzIFNJWkUKKyAgIHRvIGRhdGFzdHJlYW0g ZmlsZS4gICovCisKK3N0YXRpYyBpbnQKK2N0Zl9zYXZlX2FsaWduX3dyaXRl IChzdHJ1Y3QgY3RmX3NhdmVfcyAqdGNzcCwgY29uc3QgZ2RiX2J5dGUgKmJ1 ZiwKKwkJICAgICAgc2l6ZV90IHNpemUsIHNpemVfdCBhbGlnbl9zaXplKQor eworICBpZiAoY3RmX3NhdmVfZnNlZWsgKHRjc3AsCisJCSAgICAgIEFMSUdO X1NJWkUgKHRjc3AtPmN1cnJlbnRfY29udGVudF9zaXplLCBhbGlnbl9zaXpl KSwKKwkJICAgICAgU0VFS19DVVIpKQorICAgIHJldHVybiAtMTsKKworICBp ZiAoY3RmX3NhdmVfd3JpdGUgKHRjc3AsIGJ1Ziwgc2l6ZSkpCisgICAgcmV0 dXJuIC0xOworCisgIHJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBjdGZf c2F2ZV90eXBlX2RlZmluZV93cml0ZSAoc3RydWN0IGN0Zl9zYXZlX3MgKnRj c3AsCisJCQkJCXN0cnVjdCB0eXBlICp0eXBlLCBpbnQgbG9jYWwpOworCisv KiBXcml0ZSB0aGUgdHlwZSBwYXJ0IG9mIGEgdmFyIGRlZmluZSB0byBDVEYg bWV0YWRhdGEgZmlsZS4gICovCisKK3N0YXRpYyB2b2lkCitjdGZfc2F2ZV90 eXBlX25hbWVfd3JpdGUgKHN0cnVjdCBjdGZfc2F2ZV9zICp0Y3NwLCBzdHJ1 Y3QgdHlwZSAqdHlwZSkKK3sKKyAgc3dpdGNoIChUWVBFX0NPREUgKHR5cGUp KQorICAgIHsKKyAgICBjYXNlIFRZUEVfQ09ERV9BUlJBWToKKyAgICAgIC8q IFRoaXMgcGFydCBqdXN0IHRvIGdldCB0aGUgcmVhbCBuYW1lIG9mIHRoaXMg YXJyYXkuCisgICAgICAgICBUaGlzIHBhcnQgc2hvdWxkIGtlZXAgdHlwZWRl ZiBpZiBpdCBjYW4uICAqLworICAgICAgZm9yICg7IFRZUEVfQ09ERSAodHlw ZSkgPT0gVFlQRV9DT0RFX0FSUkFZOworCSAgIHR5cGUgPSBUWVBFX1RBUkdF VF9UWVBFICh0eXBlKSA/IFRZUEVfVEFSR0VUX1RZUEUgKHR5cGUpCisJCQkJ CSAgOiBjaGVja190eXBlZGVmICh0eXBlKSkKKwk7CisgICAgICBpZiAoVFlQ RV9OQU1FICh0eXBlKSkKKyAgICAgICAgY3RmX3NhdmVfZndyaXRlX2Zvcm1h dCAodGNzcC0+bWV0YWRhdGFfZmQsICIlcyIsIFRZUEVfTkFNRSAodHlwZSkp OworICAgICAgZWxzZQorCWN0Zl9zYXZlX3R5cGVfZGVmaW5lX3dyaXRlICh0 Y3NwLCB0eXBlLCAxKTsKKyAgICAgIGJyZWFrOworCisgICAgY2FzZSBUWVBF X0NPREVfUFRSOgorICAgICAgaWYgKFRZUEVfTEVOR1RIICh0eXBlKSA9PSA4 KQorCWN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXQgKHRjc3AtPm1ldGFkYXRhX2Zk LCAidWludDY0X3QiKTsKKyAgICAgIGVsc2UKKwljdGZfc2F2ZV9md3JpdGVf Zm9ybWF0ICh0Y3NwLT5tZXRhZGF0YV9mZCwgInVpbnQzMl90Iik7CisgICAg ICBicmVhazsKKworICAgIGNhc2UgVFlQRV9DT0RFX1NUUlVDVDoKKyAgICBj YXNlIFRZUEVfQ09ERV9FTlVNOgorICAgICAgaWYgKFRZUEVfVEFHX05BTUUg KHR5cGUpKQorICAgICAgICBjdGZfc2F2ZV9md3JpdGVfZm9ybWF0ICh0Y3Nw LT5tZXRhZGF0YV9mZCwgIiVzICVzIiwKKwkJCQlUWVBFX0NPREUgKHR5cGUp ID09IFRZUEVfQ09ERV9TVFJVQ1QgPworCQkJCSJzdHJ1Y3QiIDogImVudW0i LAorCQkJCVRZUEVfVEFHX05BTUUgKHR5cGUpKTsKKyAgICAgIGVsc2UKKwlj dGZfc2F2ZV90eXBlX2RlZmluZV93cml0ZSAodGNzcCwgdHlwZSwgMSk7Cisg ICAgICBicmVhazsKKworICAgIGNhc2UgVFlQRV9DT0RFX1VOSU9OOgorICAg ICAgeworCWludCBpLCBiaWdnZXN0X2lkLCBiaWdnZXN0X3NpemUgPSAwOwor CisJZm9yIChpID0gMDsgaSA8IFRZUEVfTkZJRUxEUyAodHlwZSk7ICsraSkK KwkgIHsKKwkgICAgaWYgKGJpZ2dlc3Rfc2l6ZSA8IFRZUEVfTEVOR1RIIChU WVBFX0ZJRUxEX1RZUEUgKHR5cGUsIGkpKSkKKwkgICAgICB7CisJCWJpZ2dl c3Rfc2l6ZSA9IFRZUEVfTEVOR1RIIChUWVBFX0ZJRUxEX1RZUEUgKHR5cGUs IGkpKTsKKwkJYmlnZ2VzdF9pZCA9IGk7CisJICAgICAgfQorCSAgfQorCWN0 Zl9zYXZlX3R5cGVfbmFtZV93cml0ZSAodGNzcCwgVFlQRV9GSUVMRF9UWVBF ICh0eXBlLCBiaWdnZXN0X2lkKSk7CisJYnJlYWs7CisgICAgICB9CisKKyAg ICBkZWZhdWx0OgorICAgICAgY3RmX3NhdmVfZndyaXRlX2Zvcm1hdCAodGNz cC0+bWV0YWRhdGFfZmQsICIlcyIsIFRZUEVfTkFNRSAodHlwZSkpOworICAg ICAgYnJlYWs7CisgICAgfQorfQorCisvKiBXcml0ZSB0aGUgc2l6ZSBwYXJ0 IG9mIGEgdmFyIGRlZmluZSB0byBDVEYgbWV0YWRhdGEgZmlsZS4gICovCisK K3N0YXRpYyB2b2lkCitjdGZfc2F2ZV90eXBlX3NpemVfd3JpdGUgKHN0cnVj dCBjdGZfc2F2ZV9zICp0Y3NwLCBzdHJ1Y3QgdHlwZSAqdHlwZSkKK3sKKyAg aWYgKFRZUEVfQ09ERSAodHlwZSkgPT0gVFlQRV9DT0RFX0FSUkFZKQorICAg IHsKKyAgICAgIC8qIFRoaXMgcGFydCBqdXN0IHRvIGdldCB0aGUgcmVhbCBu YW1lIG9mIHRoaXMgYXJyYXkuCisgICAgICAgICBUaGlzIHBhcnQgc2hvdWxk IGtlZXAgdHlwZWRlZiBpZiBpdCBjYW4uICAqLworICAgICAgZm9yICg7IFRZ UEVfQ09ERSAodHlwZSkgPT0gVFlQRV9DT0RFX0FSUkFZOworCSAgIHR5cGUg PSBUWVBFX1RBUkdFVF9UWVBFICh0eXBlKSA/IFRZUEVfVEFSR0VUX1RZUEUg KHR5cGUpCisJCQkJCSAgOiBjaGVja190eXBlZGVmICh0eXBlKSkKKwljdGZf c2F2ZV9md3JpdGVfZm9ybWF0ICh0Y3NwLT5tZXRhZGF0YV9mZCwgIlslZF0i LAorCQkJCVRZUEVfTEVOR1RIICh0eXBlKSAvCisJCQkJVFlQRV9MRU5HVEgg KFRZUEVfVEFSR0VUX1RZUEUgKHR5cGUpKSk7CisgICAgfQorfQorCisvKiBX cml0ZSBhIHZhciBkZWZpbmUgdG8gQ1RGIG1ldGFkYXRhIGZpbGUuICAqLwor CitzdGF0aWMgdm9pZAorY3RmX3NhdmVfdmFyX2RlZmluZV93cml0ZSAoc3Ry dWN0IGN0Zl9zYXZlX3MgKnRjc3AsIHN0cnVjdCB0eXBlICp0eXBlLAorCQkJ ICAgY29uc3QgY2hhciAqbmFtZSkKK3sKKyAgY3RmX3NhdmVfdHlwZV9uYW1l X3dyaXRlICh0Y3NwLCB0eXBlKTsKKyAgY3RmX3NhdmVfZndyaXRlX2Zvcm1h dCAodGNzcC0+bWV0YWRhdGFfZmQsICIgJXMiLCBuYW1lKTsKKyAgY3RmX3Nh dmVfdHlwZV9zaXplX3dyaXRlICh0Y3NwLCB0eXBlKTsKKyAgY3RmX3NhdmVf ZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICI7XG4iKTsKK30K KworLyogUmV0dXJuIHRydWUgaWYgVDEgYW5kIFQyIGlzIHNhbWUuICAqLwor CitzdGF0aWMgaW50CitjdGZfc2F2ZV90eXBlX2lzX3NhbWUgKHN0cnVjdCB0 eXBlICp0MSwgc3RydWN0IHR5cGUgKnQyKQoreworICBjb25zdCBjaGFyICpu YW1lMSwgKm5hbWUyOworCisgIGlmICh0MSA9PSB0MikKKyAgICByZXR1cm4g MTsKKworICBpZiAoVFlQRV9DT0RFICh0MSkgIT0gVFlQRV9DT0RFICh0Mikp CisgICAgcmV0dXJuIDA7CisKKyAgaWYgKFRZUEVfQ09ERSAodDEpID09IFRZ UEVfQ09ERV9TVFJVQ1QgfHwgVFlQRV9DT0RFICh0MSkgPT0gVFlQRV9DT0RF X0VOVU0pCisgICAgeworICAgICAgbmFtZTEgPSBUWVBFX1RBR19OQU1FICh0 MSk7CisgICAgICBuYW1lMiA9IFRZUEVfVEFHX05BTUUgKHQyKTsKKyAgICB9 CisgIGVsc2UKKyAgICB7CisgICAgICBuYW1lMSA9IFRZUEVfTkFNRSAodDEp OworICAgICAgbmFtZTIgPSBUWVBFX05BTUUgKHQyKTsKKyAgICB9CisKKyAg aWYgKG5hbWUxICYmIG5hbWUyICYmIHN0cmNtcCAobmFtZTEsIG5hbWUyKSA9 PSAwKQorICAgIHJldHVybiAxOworCisgIHJldHVybiAwOworfQorCisvKiBD aGVjayBpZiBUWVBFIGluIFRDU1AtPlRZUEUuCisgICBJZiBub3QsIHdyaXRl IFRZUEUgdG8gVENTUC0+bWV0YWRhdGFfZmQuCisgICBJZiBMT0NBTCBpcyB0 cnVlLCB0aGlzIHR5cGUgZGVmaW5lIGp1c3QgZGVmaW5lIHdpdGggYSB2YXIu ICAqLworCitzdGF0aWMgdm9pZAorY3RmX3NhdmVfdHlwZV9kZWZpbmVfd3Jp dGUgKHN0cnVjdCBjdGZfc2F2ZV9zICp0Y3NwLCBzdHJ1Y3QgdHlwZSAqdHlw ZSwKKwkJCSAgICBpbnQgbG9jYWwpCit7CisgIHN0cnVjdCBjdGZfc2F2ZV90 eXBlX3MgKnQ7CisKKyAgLyogSWdub3JlIHR5cGUgdWludDMyX3QgYW5kIHVp bnQ2NF90IGJlY2F1c2UgdGhleSBoYXZlIHdyaXR0ZW4KKyAgICAgaW4gZnVu Y3Rpb24gY3RmX3NhdmVfbWV0YWRhdGFfaGVhZGVyLiAgKi8KKyAgaWYgKFRZ UEVfTkFNRSAodHlwZSkgJiYgKHN0cmNtcCAoVFlQRV9OQU1FICh0eXBlKSwg InVpbnQzMl90IikgPT0gMAorCQkJICAgfHwgc3RyY21wIChUWVBFX05BTUUg KHR5cGUpLCAidWludDY0X3QiKSA9PSAwKSkKKyAgICByZXR1cm47CisKKyAg aWYgKCFsb2NhbCkKKyAgICB7CisgICAgICBmb3IgKHQgPSB0Y3NwLT50eXBl OyB0OyB0ID0gdC0+bmV4dCkKKwl7CisJICBpZiAoY3RmX3NhdmVfdHlwZV9p c19zYW1lICh0eXBlLCB0LT50eXBlKSkKKwkgICAgcmV0dXJuOworCX0KKwor ICAgICAgdCA9IChzdHJ1Y3QgY3RmX3NhdmVfdHlwZV9zICopIHh6YWxsb2Mg KHNpemVvZiAoKnQpKTsKKyAgICAgIHQtPnR5cGUgPSB0eXBlOworICAgICAg dC0+bmV4dCA9IHRjc3AtPnR5cGU7CisgICAgICB0Y3NwLT50eXBlID0gdDsK KyAgICB9CisKKyAgc3dpdGNoIChUWVBFX0NPREUgKHR5cGUpKQorICAgIHsK KyAgICAgIGNhc2UgVFlQRV9DT0RFX1RZUEVERUY6CisJY3RmX3NhdmVfZndy aXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICJ0eXBlZGVmICIpOwor CWN0Zl9zYXZlX3Zhcl9kZWZpbmVfd3JpdGUgKHRjc3AsIFRZUEVfVEFSR0VU X1RZUEUgKHR5cGUpLAorCQkJCSAgIFRZUEVfTkFNRSAodHlwZSkpOworCWJy ZWFrOworCisgICAgICBjYXNlIFRZUEVfQ09ERV9JTlQ6CisJY3RmX3NhdmVf ZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICJcCit0eXBlYWxp YXMgaW50ZWdlciB7IHNpemUgPSAlZDsgYWxpZ24gPSAlZDsgc2lnbmVkID0g JXM7IH0gOj0gJXM7XG4iLAorCQkJCVRZUEVfTEVOR1RIICh0eXBlKSAqIFRB UkdFVF9DSEFSX0JJVCwKKwkJCQlUWVBFX0xFTkdUSCAodHlwZSkgKiBUQVJH RVRfQ0hBUl9CSVQsCisJCQkJIVRZUEVfVU5TSUdORUQgKHR5cGUpID8gInRy dWUiIDogImZhbHNlIiwKKwkJCQlUWVBFX05BTUUgKHR5cGUpKTsKKwlicmVh azsKKworICAgICAgY2FzZSBUWVBFX0NPREVfU1RSVUNUOgorICAgICAgY2Fz ZSBUWVBFX0NPREVfRU5VTToKKyAgICAgICAgeworCSAgaW50IGk7CisJICBj aGFyIHRhYlsyNTZdOworCSAgY29uc3QgY2hhciAqb2xkX3RhYjsKKworCSAg Y3RmX3NhdmVfZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICIl cyAlcyB7XG4iLAorCQkJCSAgVFlQRV9DT0RFICh0eXBlKSA9PSBUWVBFX0NP REVfU1RSVUNUID8KKwkJCQkgICJzdHJ1Y3QiIDogImVudW0iLAorCQkJCSAg VFlQRV9UQUdfTkFNRSAodHlwZSkgPyBUWVBFX1RBR19OQU1FICh0eXBlKQor CQkJCQkJICAgICAgIDogIiIpOworCisJICBvbGRfdGFiID0gdGNzcC0+dGFi OworCSAgc25wcmludGYgKHRhYiwgMjU2LCAiJXNcdCIsIG9sZF90YWIpOwor CSAgdGNzcC0+dGFiID0gdGFiOworCSAgZm9yIChpID0gMDsgaSA8IFRZUEVf TkZJRUxEUyAodHlwZSk7ICsraSkKKwkgICAgeworCSAgICAgIGlmIChUWVBF X0NPREUgKHR5cGUpID09IFRZUEVfQ09ERV9TVFJVQ1QpCisJICAgICAgICB7 CisJCSAgY3RmX3NhdmVfZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFf ZmQsIHRjc3AtPnRhYik7CisJCSAgY3RmX3NhdmVfdmFyX2RlZmluZV93cml0 ZSAodGNzcCwgVFlQRV9GSUVMRF9UWVBFICh0eXBlLCBpKSwKKwkJCQkJICAg ICBUWVBFX0ZJRUxEX05BTUUgKHR5cGUsIGkpKTsKKwkJfQorCSAgICAgIGVs c2UKKwkJY3RmX3NhdmVfZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFf ZmQsICIlcyVzID0gJXMsXG4iLAorCQkJCQl0Y3NwLT50YWIsIFRZUEVfRklF TERfTkFNRSAodHlwZSwgaSksCisJCQkJCXBsb25nZXN0IChUWVBFX0ZJRUxE X0VOVU1WQUwgKHR5cGUsIGkpKSk7CisJICAgIH0KKwkgIHRjc3AtPnRhYiA9 IG9sZF90YWI7CisJICBjdGZfc2F2ZV9md3JpdGVfZm9ybWF0ICh0Y3NwLT5t ZXRhZGF0YV9mZCwgIiVzfSIsIHRjc3AtPnRhYik7CisJICBpZiAoVFlQRV9U QUdfTkFNRSAodHlwZSkpCisJICAgIGN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXQg KHRjc3AtPm1ldGFkYXRhX2ZkLCAiO1xuIik7CisJICBicmVhazsKKwl9Cisg ICAgfQorfQorCisvKiBDaGVjayBpZiB0aGlzIHR5cGUgaXMgc3VwcG9ydGVk IGJ5IEdEQi4KKyAgIFJldHVybiB0aGUgYWxpZ24gc2l6ZS4gICovCisKK3N0 YXRpYyBpbnQKK2N0Zl9zYXZlX3R5cGVfY2hlY2tfYW5kX3dyaXRlIChzdHJ1 Y3QgY3RmX3NhdmVfcyAqdGNzcCwgc3RydWN0IHR5cGUgKnR5cGUpCit7Cisg IGludCBhbGlnbl9zaXplID0gMDsKKworICBzd2l0Y2ggKFRZUEVfQ09ERSAo dHlwZSkpCisgICAgeworICAgICAgY2FzZSBUWVBFX0NPREVfVFlQRURFRjoK KwlhbGlnbl9zaXplID0gY3RmX3NhdmVfdHlwZV9jaGVja19hbmRfd3JpdGUg KHRjc3AsCisJCQkJCQkgICAgVFlQRV9UQVJHRVRfVFlQRSAodHlwZSkpOwor CWlmIChhbGlnbl9zaXplIDwgMCkKKwkgIHJldHVybiBhbGlnbl9zaXplOwor CWN0Zl9zYXZlX3R5cGVfZGVmaW5lX3dyaXRlICh0Y3NwLCB0eXBlLCAwKTsK KwlicmVhazsKKworICAgICAgY2FzZSBUWVBFX0NPREVfQVJSQVk6CisJYWxp Z25fc2l6ZSA9IGN0Zl9zYXZlX3R5cGVfY2hlY2tfYW5kX3dyaXRlICh0Y3Nw LAorCQkJCQkJICAgIFRZUEVfVEFSR0VUX1RZUEUgKHR5cGUpKTsKKwlpZiAo YWxpZ25fc2l6ZSA8IDApCisJICByZXR1cm4gYWxpZ25fc2l6ZTsKKwlicmVh azsKKworICAgICAgY2FzZSBUWVBFX0NPREVfSU5UOgorCWN0Zl9zYXZlX3R5 cGVfZGVmaW5lX3dyaXRlICh0Y3NwLCB0eXBlLCAwKTsKKwlhbGlnbl9zaXpl ID0gVFlQRV9MRU5HVEggKHR5cGUpOworCWJyZWFrOworCisgICAgICBjYXNl IFRZUEVfQ09ERV9QVFI6CisJYWxpZ25fc2l6ZSA9IFRZUEVfTEVOR1RIICh0 eXBlKTsKKwlicmVhazsKKworICAgICAgY2FzZSBUWVBFX0NPREVfU1RSVUNU OgorICAgICAgICB7CisJICBpbnQgaSwgc19hbGlnbl9zaXplOworCisJICBm b3IgKGkgPSAwOyBpIDwgVFlQRV9ORklFTERTICh0eXBlKTsgKytpKQorCSAg ICB7CisJICAgICAgc19hbGlnbl9zaXplCisJCSAgPSBjdGZfc2F2ZV90eXBl X2NoZWNrX2FuZF93cml0ZSAodGNzcCwKKwkJCQkJCSAgIFRZUEVfRklFTERf VFlQRSAodHlwZSwgaSkpOworCSAgICAgIGlmIChzX2FsaWduX3NpemUgPCAw KQorCQlyZXR1cm4gc19hbGlnbl9zaXplOworCisJICAgICAgaWYgKGFsaWdu X3NpemUgPCBzX2FsaWduX3NpemUpCisJCWFsaWduX3NpemUgPSBzX2FsaWdu X3NpemU7CisJICAgIH0KKwkgIGlmIChUWVBFX1RBR19OQU1FICh0eXBlKSkK KwkgICAgY3RmX3NhdmVfdHlwZV9kZWZpbmVfd3JpdGUgKHRjc3AsIHR5cGUs IDApOworCSAgYnJlYWs7CisJfQorCisgICAgICBjYXNlIFRZUEVfQ09ERV9F TlVNOgorCWFsaWduX3NpemUgPSBUWVBFX0xFTkdUSCAodHlwZSk7CisJaWYg KFRZUEVfVEFHX05BTUUgKHR5cGUpKQorCSAgY3RmX3NhdmVfdHlwZV9kZWZp bmVfd3JpdGUgKHRjc3AsIHR5cGUsIDApOworCWJyZWFrOworCisgICAgICBj YXNlIFRZUEVfQ09ERV9VTklPTjoKKyAgICAgICAgeworCSAgaW50IGksIHNf YWxpZ25fc2l6ZTsKKworCSAgZm9yIChpID0gMDsgaSA8IFRZUEVfTkZJRUxE UyAodHlwZSk7ICsraSkKKwkgICAgeworCSAgICAgIHNfYWxpZ25fc2l6ZQor CQkgID0gY3RmX3NhdmVfdHlwZV9jaGVja19hbmRfd3JpdGUgKHRjc3AsCisJ CQkJCQkgICBUWVBFX0ZJRUxEX1RZUEUgKHR5cGUsIGkpKTsKKwkgICAgICBp ZiAoc19hbGlnbl9zaXplIDwgMCkKKwkJcmV0dXJuIHNfYWxpZ25fc2l6ZTsK KworCSAgICAgIGlmIChhbGlnbl9zaXplIDwgc19hbGlnbl9zaXplKQorCQlh bGlnbl9zaXplID0gc19hbGlnbl9zaXplOworCSAgICB9CisJICBicmVhazsK Kwl9CisKKyAgICAgIGRlZmF1bHQ6CisJYWxpZ25fc2l6ZSA9IC0xOworCWJy ZWFrOworICAgIH0KKworICByZXR1cm4gYWxpZ25fc2l6ZTsKK30KKworc3Rh dGljIHZvaWQKK2N0Zl9zYXZlX2NvbGxlY3RfZ2V0XzEgKHN0cnVjdCBjdGZf c2F2ZV9zICp0Y3NwLCBzdHJ1Y3QgY3RmX3NhdmVfdHBfcyAqdHBzLAorCQkJ Y2hhciAqc3RyKQoreworICBzdHJ1Y3QgZXhwcmVzc2lvbiAqZXhwcjsKKyAg c3RydWN0IGN0Zl9zYXZlX2NvbGxlY3RfcyAqY29sbGVjdDsKKyAgdm9sYXRp bGUgc3RydWN0IGdkYl9leGNlcHRpb24gZTsKKyAgc3RydWN0IHR5cGUgKnR5 cGU7CisgIGludCBpc19yZXQgPSAwOworICBpbnQgYWxpZ25fc2l6ZTsKKwor ICAvKiBDaGVjayBpZiBhY3Rpb25fZXhwIGlzIGFscmVhZHkgZXhpc3QgaW4g dHBzLT5jb2xsZWN0LiAgKi8KKyAgZm9yIChjb2xsZWN0ID0gdHBzLT5jb2xs ZWN0OyBjb2xsZWN0OyBjb2xsZWN0ID0gY29sbGVjdC0+bmV4dCkKKyAgICB7 CisgICAgICBpZiAoc3RyY21wIChjb2xsZWN0LT5zdHIsIHN0cikgPT0gMCkK KwlyZXR1cm47CisgICAgfQorCisgIGlmICgwID09IHN0cm5jYXNlY21wIChz dHIsICIkX3JldCIsIDUpKQorICAgIGlzX3JldCA9IDE7CisKKyAgVFJZX0NB VENIIChlLCBSRVRVUk5fTUFTS19FUlJPUikKKyAgICB7CisgICAgICBpZiAo aXNfcmV0KQorICAgICAgICB7CisJICBDT1JFX0FERFIgcGM7CisJICBzdHJ1 Y3QgZnJhbWVfaW5mbyAqZnJhbWU7CisKKwkgIGZyYW1lID0gZ2V0X3ByZXZf ZnJhbWUgKGdldF9jdXJyZW50X2ZyYW1lICgpKTsKKwkgIGlmICghZnJhbWUp CisJICAgIGVycm9yIChfKCJjb3VsZCBub3QgZmluZCBwcmV2aW91cyBmcmFt ZSIpKTsKKworCSAgaWYgKCFnZXRfZnJhbWVfcGNfaWZfYXZhaWxhYmxlIChm cmFtZSwgJnBjKSkKKwkgICAgZXJyb3IgKF8oIlBDIHVuYXZhaWxhYmxlIikp OworCX0KKyAgICAgIGVsc2UKKyAgICAgICAgeworCSAgc3RydWN0IGNsZWFu dXAgKm9sZF9jaGFpbjsKKwkgIHN0cnVjdCB2YWx1ZSAqdmFsOworCisJICBl eHByID0gcGFyc2VfZXhwcmVzc2lvbiAoc3RyKTsKKwkgIG9sZF9jaGFpbiA9 IG1ha2VfY2xlYW51cCAoZnJlZV9jdXJyZW50X2NvbnRlbnRzLCAmZXhwcik7 CisJICB0eXBlID0gdmFsdWVfdHlwZSAoZXZhbHVhdGVfZXhwcmVzc2lvbiAo ZXhwcikpOworCSAgZG9fY2xlYW51cHMgKG9sZF9jaGFpbik7CisJfQorICAg IH0KKyAgaWYgKGUucmVhc29uIDwgMCkKKyAgICB7CisgICAgICB3YXJuaW5n IChfKCJlcnJvciBzYXZpbmcgdHJhY2Vwb2ludCAlZCBcIiVzXCIgdG8gQ1RG IGZpbGU6ICVzIiksCisJICAgICAgIHRwcy0+dHAtPmJhc2UubnVtYmVyLCBz dHIsIGUubWVzc2FnZSk7CisgICAgICByZXR1cm47CisgICAgfQorCisgIGlm IChpc19yZXQpCisgICAgYWxpZ25fc2l6ZSA9IDg7CisgIGVsc2UKKyAgICB7 CisgICAgICBhbGlnbl9zaXplID0gY3RmX3NhdmVfdHlwZV9jaGVja19hbmRf d3JpdGUgKHRjc3AsIHR5cGUpOworICAgICAgaWYgKGFsaWduX3NpemUgPCAw KQorCXsKKwkgIHdhcm5pbmcgKF8oIlwKK2Vycm9yIHNhdmluZyB0cmFjZXBv aW50ICVkIFwiJXNcIiB0byBDVEYgZmlsZTogdHlwZSBpcyBub3Qgc3VwcG9y dGVkLiIpLAorCQkgICB0cHMtPnRwLT5iYXNlLm51bWJlciwgc3RyKTsKKwkg IHJldHVybjsKKwl9CisgICAgfQorCisgIGNvbGxlY3QgPSAoc3RydWN0IGN0 Zl9zYXZlX2NvbGxlY3RfcyAqKSB4emFsbG9jIChzaXplb2YgKCpjb2xsZWN0 KSk7CisKKyAgLyogQWRkIHRwIHRvIHRoZSBsaXN0LiAgKi8KKyAgY29sbGVj dC0+bmV4dCA9IHRwcy0+Y29sbGVjdDsKKyAgdHBzLT5jb2xsZWN0ID0gY29s bGVjdDsKKworICBjb2xsZWN0LT5zdHIgPSB4c3RyZHVwIChzdHIpOworICBj b2xsZWN0LT5pc19yZXQgPSBpc19yZXQ7CisKKyAgaWYgKCFpc19yZXQpCisg ICAgeworICAgICAgY29sbGVjdC0+dHlwZSA9IHR5cGU7CisKKyAgICAgIGNv bGxlY3QtPmFsaWduX3NpemUgPSBhbGlnbl9zaXplOworICAgICAgaWYgKGNv bGxlY3QtPmFsaWduX3NpemUgPiB0cHMtPmFsaWduX3NpemUpCisgICAgICAg IHRwcy0+YWxpZ25fc2l6ZSA9IGNvbGxlY3QtPmFsaWduX3NpemU7CisKKyAg ICAgIGNvbGxlY3QtPmV4cHIgPSBwYXJzZV9leHByZXNzaW9uIChzdHIpOwor ICAgIH0KK30KKworc3RydWN0IGxvY19hcmdfY29sbGVjdF9kYXRhCit7Cisg IHN0cnVjdCBjdGZfc2F2ZV9zICp0Y3NwOworICBzdHJ1Y3QgY3RmX3NhdmVf dHBfcyAqdHBzOworfTsKKworc3RhdGljIHZvaWQKK3Rzdl9zYXZlX2RvX2xv Y19hcmdfY29sbGVjdCAoY29uc3QgY2hhciAqcHJpbnRfbmFtZSwKKwkJCSAg ICAgc3RydWN0IHN5bWJvbCAqc3ltLAorCQkJICAgICB2b2lkICpjYl9kYXRh KQoreworICBzdHJ1Y3QgbG9jX2FyZ19jb2xsZWN0X2RhdGEgKnAgPSBjYl9k YXRhOworICBjaGFyICpuYW1lOworCisgIC8qIEFsbG9jYSBOQU1FIGJlY2F1 c2UgY3RmX3NhdmVfY29sbGVjdF9nZXRfMSBuZWVkIGFyZ3VtZW50CisgICAg IGlzIG5vdCBhIGNvbnN0IHN0cmluZy4gICovCisgIG5hbWUgPSBhbGxvY2Eg KHN0cmxlbiAocHJpbnRfbmFtZSkgKyAxKTsKKyAgc3RyY3B5IChuYW1lLCBw cmludF9uYW1lKTsKKworICBjdGZfc2F2ZV9jb2xsZWN0X2dldF8xIChwLT50 Y3NwLCBwLT50cHMsIG5hbWUpOworfQorCisvKiB3b3JrZXIgZnVuY3Rpb24g KGNsZWFudXApICovCitzdGF0aWMgdm9pZAorcmVwbGFjZV9jb21tYSAodm9p ZCAqZGF0YSkKK3sKKyAgY2hhciAqY29tbWEgPSBkYXRhOworICAqY29tbWEg PSAnLCc7Cit9CisKKy8qIEdldCB2YXIgdGhhdCB3YW50IHRvIGNvbGxlY3Qg ZnJvbSBTVFIgYW5kIHB1dCB0aGVtIHRvIFRQUy0+Y29sbGVjdC4KKyAgIFRo aXMgZnVuY3Rpb24gd2lsbCBub3QgYmUgY2FsbCB3aGVuIEdEQiBhZGQgYSBu ZXcgVFAuICAqLworCitzdGF0aWMgdm9pZAorY3RmX3NhdmVfY29sbGVjdF9n ZXQgKHN0cnVjdCBjdGZfc2F2ZV9zICp0Y3NwLCBzdHJ1Y3QgY3RmX3NhdmVf dHBfcyAqdHBzLAorCQkgICAgICBjaGFyICpzdHIpCit7CisgIGNoYXIgKmFj dGlvbl9leHAgPSBzdHIsICpuZXh0X2NvbW1hOworICBzdHJ1Y3QgY2xlYW51 cCAqb2xkX2NoYWluOworCisgIGRvCisgICAgeworICAgICAgaWYgKCphY3Rp b25fZXhwID09ICcsJykKKwlhY3Rpb25fZXhwKys7CisgICAgICB3aGlsZSAo aXNzcGFjZSAoKGludCkgKmFjdGlvbl9leHApKQorCWFjdGlvbl9leHArKzsK KworICAgICAgbmV4dF9jb21tYSA9IHN0cmNociAoYWN0aW9uX2V4cCwgJywn KTsKKyAgICAgIGlmIChuZXh0X2NvbW1hKQorCXsKKwkgIG9sZF9jaGFpbiA9 IG1ha2VfY2xlYW51cCAocmVwbGFjZV9jb21tYSwgbmV4dF9jb21tYSk7CisJ ICAqbmV4dF9jb21tYSA9ICdcMCc7CisJfQorCisgICAgICBpZiAoMCA9PSBz dHJuY2FzZWNtcCAoYWN0aW9uX2V4cCwgIiRyZWciLCA0KSkKKyAgICAgICAg eworCSAgaW50IGk7CisJICBzdHJ1Y3QgZ2RiYXJjaCAqYXJjaCA9IHRwcy0+ dHAtPmJhc2UubG9jLT5nZGJhcmNoOworCisJICBmb3IgKGkgPSAwOyBpIDwg Z2RiYXJjaF9udW1fcmVncyAoYXJjaCk7IGkrKykKKwkgICAgeworCSAgICAg IGNvbnN0IGNoYXIgKm5hbWUgPSBnZGJhcmNoX3JlZ2lzdGVyX25hbWUgKGFy Y2gsIGkpOworCSAgICAgIGludCBuYW1lX3NpemUgPSBzdHJsZW4gKG5hbWUp OworCSAgICAgIGNoYXIgcmVnbmFtZVsxICsgbmFtZV9zaXplICsgMV07CisK KwkgICAgICBpZiAobmFtZV9zaXplID09IDApCisJCWNvbnRpbnVlOworCisJ ICAgICAgc3ByaW50ZiAocmVnbmFtZSwgIiQlcyIsIG5hbWUpOworCisJICAg ICAgY3RmX3NhdmVfY29sbGVjdF9nZXRfMSAodGNzcCwgdHBzLCByZWduYW1l KTsKKwkgICAgfQorCX0KKyAgICAgIGVsc2UgaWYgKDAgPT0gc3RybmNhc2Vj bXAgKGFjdGlvbl9leHAsICIkbG9jIiwgNCkKKwkgICAgICAgfHwgMCA9PSBz dHJuY2FzZWNtcCAoYWN0aW9uX2V4cCwgIiRhcmciLCA0KSkKKwl7CisJICBD T1JFX0FERFIgcGM7CisJICBzdHJ1Y3QgbG9jX2FyZ19jb2xsZWN0X2RhdGEg Y2JfZGF0YTsKKwkgIHZvbGF0aWxlIHN0cnVjdCBnZGJfZXhjZXB0aW9uIGU7 CisKKwkgIGNiX2RhdGEudGNzcCA9IHRjc3A7CisJICBjYl9kYXRhLnRwcyA9 IHRwczsKKworCSAgVFJZX0NBVENIIChlLCBSRVRVUk5fTUFTS19FUlJPUikK KwkgICAgeworCSAgICAgIHBjID0gcmVnY2FjaGVfcmVhZF9wYyAoZ2V0X2N1 cnJlbnRfcmVnY2FjaGUgKCkpOworCSAgICB9CisJICBpZiAoZS5yZWFzb24g PCAwKQorCSAgICB7CisJICAgICAgd2FybmluZyAoXygiZXJyb3Igc2F2aW5n IHRyYWNlcG9pbnQgJWQgXCIlc1wiIHRvIENURiBmaWxlOiAlcyIpLAorCQkg ICAgICAgdHBzLT50cC0+YmFzZS5udW1iZXIsIGFjdGlvbl9leHAsIGUubWVz c2FnZSk7CisJICAgICAgY29udGludWU7CisJICAgIH0KKworCSAgaWYgKGFk ZF9sb2NhbF9zeW1ib2xzXzEgKCgwID09IHN0cm5jYXNlY21wIChhY3Rpb25f ZXhwLCAiJGxvYyIsIDQpCisJCQkJCT8gJ0wnIDogJ0EnKSwKKwkJCQkgICBw YywgdHN2X3NhdmVfZG9fbG9jX2FyZ19jb2xsZWN0LAorCQkJCSAgICZjYl9k YXRhKSkKKwkgICAgeworCSAgICAgIHdhcm5pbmcgKF8oIlwKK2Vycm9yIHNh dmluZyB0cmFjZXBvaW50ICVkIFwiJXNcIiB0byBDVEYgZmlsZTogbm8gc3lt Ym9sIHRhYmxlIGluZm8gYXZhaWxhYmxlLiIpLAorCQkgICAgICAgdHBzLT50 cC0+YmFzZS5udW1iZXIsIGFjdGlvbl9leHApOworCSAgICAgIGNvbnRpbnVl OworCSAgICB9CisJfQorICAgICAgZWxzZQorCWN0Zl9zYXZlX2NvbGxlY3Rf Z2V0XzEgKHRjc3AsIHRwcywgYWN0aW9uX2V4cCk7CisKKyAgICAgIGlmIChu ZXh0X2NvbW1hKQorCWRvX2NsZWFudXBzIChvbGRfY2hhaW4pOworICAgICAg YWN0aW9uX2V4cCA9IG5leHRfY29tbWE7CisgICAgfQorICB3aGlsZSAoYWN0 aW9uX2V4cCAmJiAqYWN0aW9uX2V4cCA9PSAnLCcpOworfQorCisvKiBDYWxs IGZ1bmN0aW9uIGN0Zl9zYXZlX2NvbGxlY3RfZ2V0IEFkZCBhY3Rpb24gbGlz dCBBQ1RJT04gb2YgVFBTCisgICB0byBUUFMtPmNvbGxlY3QuCisgICBTVEVQ UElOR19GUkFNRSBpcyB0cnVlIGlmIGl0IGlzIHN0ZXAgYWN0aW9uLiAgKi8K Kworc3RhdGljIHZvaWQKK2N0Zl9zYXZlX3RwX2FjdGlvbnMgKHN0cnVjdCBj dGZfc2F2ZV9zICp0Y3NwLCBzdHJ1Y3QgY3RmX3NhdmVfdHBfcyAqdHBzLAor CQkgICAgIHN0cnVjdCBjb21tYW5kX2xpbmUgKmFjdGlvbiwgaW50IHN0ZXBw aW5nX2ZyYW1lKQoreworICBmb3IgKDsgYWN0aW9uICE9IE5VTEw7IGFjdGlv biA9IGFjdGlvbi0+bmV4dCkKKyAgICB7CisgICAgICBjaGFyICphY3Rpb25f ZXhwOworICAgICAgc3RydWN0IGNtZF9saXN0X2VsZW1lbnQgKmNtZDsKKwor ICAgICAgUVVJVDsKKyAgICAgIGFjdGlvbl9leHAgPSBhY3Rpb24tPmxpbmU7 CisgICAgICB3aGlsZSAoaXNzcGFjZSAoKGludCkgKmFjdGlvbl9leHApKQor CWFjdGlvbl9leHArKzsKKyAgICAgIGlmICgqYWN0aW9uX2V4cCA9PSAnIycp CisJY29udGludWU7CisKKyAgICAgIGNtZCA9IGxvb2t1cF9jbWQgKCZhY3Rp b25fZXhwLCBjbWRsaXN0LCAiIiwgLTEsIDEpOworICAgICAgaWYgKGNtZCA9 PSAwKQorCWVycm9yIChfKCJCYWQgYWN0aW9uIGxpc3QgaXRlbTogJXMiKSwg YWN0aW9uX2V4cCk7CisKKyAgICAgIGlmIChjbWRfY2Z1bmNfZXEgKGNtZCwg d2hpbGVfc3RlcHBpbmdfcHNldWRvY29tbWFuZCkpCisJeworCSAgaW50IGk7 CisKKwkgIGZvciAoaSA9IDA7IGkgPCBhY3Rpb24tPmJvZHlfY291bnQ7ICsr aSkKKwkgICAgY3RmX3NhdmVfdHBfYWN0aW9ucyAodGNzcCwgdHBzLCBhY3Rp b24tPmJvZHlfbGlzdFtpXSwgMSk7CisJfQorICAgICAgZWxzZSBpZiAoY21k X2NmdW5jX2VxIChjbWQsIGNvbGxlY3RfcHNldWRvY29tbWFuZCkpCisJewor CSAgaWYgKHN0ZXBwaW5nX2ZyYW1lICE9IHRwcy0+c3RlcHBpbmdfZnJhbWUp CisJICAgIGNvbnRpbnVlOworCSAgaWYgKCphY3Rpb25fZXhwID09ICcvJykK KwkgICAgYWN0aW9uX2V4cCA9IGRlY29kZV9hZ2VudF9vcHRpb25zIChhY3Rp b25fZXhwKTsKKwkgIGN0Zl9zYXZlX2NvbGxlY3RfZ2V0ICh0Y3NwLCB0cHMs IGFjdGlvbl9leHApOworCX0KKyAgICB9Cit9CisKKworLyogVHJ5IHRvIGZp bmQgdGhlIGN0Zl9zYXZlX3RwX3Mgc3RydWN0IGluIHRoZSBUQ1NQLT50cC4K KyAgIElmIGNhbm5vdCBmaW5kIGl0IGluIHRoZSBUQ1NQLT50cCwgbWFrZSBh IG5ldyBvbmUgZm9yIFRQCisgICBhbmQgYWRkIGl0IHRvIFRDU1AtPnRwLiAg Ki8KKworc3RhdGljIHN0cnVjdCBjdGZfc2F2ZV90cF9zICoKK2N0Zl9zYXZl X3RwX2ZpbmQgKHN0cnVjdCBjdGZfc2F2ZV9zICp0Y3NwLCBzdHJ1Y3QgdHJh Y2Vwb2ludCAqdHApCit7CisgIHN0cnVjdCBjdGZfc2F2ZV90cF9zICpyZXQ7 CisgIHN0cnVjdCBicF9sb2NhdGlvbiAqbG9jOworICBzdHJ1Y3QgcmVnY2Fj aGUgKnJlZ2NhY2hlOworICBpbnQgc3RlcHBpbmdfZnJhbWUgPSAwOworICBz dHJ1Y3QgY29tbWFuZF9saW5lICphY3Rpb247CisgIHZvbGF0aWxlIHN0cnVj dCBnZGJfZXhjZXB0aW9uIGU7CisgIENPUkVfQUREUiBwYzsKKyAgZXh0ZXJu IGludCB0cmFjZXBvaW50X2NvdW50OworCisgIFRSWV9DQVRDSCAoZSwgUkVU VVJOX01BU0tfRVJST1IpCisgICAgeworICAgICAgcGMgPSByZWdjYWNoZV9y ZWFkX3BjIChnZXRfY3VycmVudF9yZWdjYWNoZSAoKSk7CisgICAgfQorICBp ZiAoZS5yZWFzb24gPj0gMCkKKyAgICB7CisgICAgICBzdGVwcGluZ19mcmFt ZSA9IDE7CisgICAgICBmb3IgKGxvYyA9IHRwLT5iYXNlLmxvYzsgbG9jOyBs b2MgPSBsb2MtPm5leHQpCisJeworCSAgaWYgKGxvYy0+YWRkcmVzcyA9PSBw YykKKyAgICAgICAgICAgIHsKKwkgICAgICBzdGVwcGluZ19mcmFtZSA9IDA7 CisJICAgICAgYnJlYWs7CisJICAgIH0KKyAgICAgICAgfQorICAgIH0KKwor ICBmb3IgKHJldCA9IHRjc3AtPnRwOyByZXQ7IHJldCA9IHJldC0+bmV4dCkK KyAgICB7CisgICAgICBpZiAocmV0LT50cCA9PSB0cCAmJiByZXQtPnN0ZXBw aW5nX2ZyYW1lID09IHN0ZXBwaW5nX2ZyYW1lKQorCXJldHVybiByZXQ7Cisg ICAgfQorCisgIHJldCA9IChzdHJ1Y3QgY3RmX3NhdmVfdHBfcyAqKSB4emFs bG9jIChzaXplb2YgKCpyZXQpKTsKKworICAvKiBBZGQgdHAgdG8gdGhlIGxp c3QuICAqLworICByZXQtPm5leHQgPSB0Y3NwLT50cDsKKyAgdGNzcC0+dHAg PSByZXQ7CisKKyAgcmV0LT5zdGVwcGluZ19mcmFtZSA9IHN0ZXBwaW5nX2Zy YW1lOworICBpZiAoc3RlcHBpbmdfZnJhbWUpCisgICAgcmV0LT5pZCA9IHRy YWNlcG9pbnRfY291bnQgKyB0cC0+YmFzZS5udW1iZXI7CisgIGVsc2UKKyAg ICByZXQtPmlkID0gdHAtPmJhc2UubnVtYmVyOworICByZXQtPnRwID0gdHA7 CisKKyAgaWYgKCFzdGVwcGluZ19mcmFtZSAmJiAqZGVmYXVsdF9jb2xsZWN0 KQorICAgIGN0Zl9zYXZlX2NvbGxlY3RfZ2V0ICh0Y3NwLCByZXQsIGRlZmF1 bHRfY29sbGVjdCk7CisKKyAgY3RmX3NhdmVfdHBfYWN0aW9ucyAodGNzcCwg cmV0LCBicmVha3BvaW50X2NvbW1hbmRzICgmdHAtPmJhc2UpLCAwKTsKKwor ICByZXR1cm4gcmV0OworfQorCisvKiBMZXQgVENTUC0+ZGF0YXN0cmVhbV9m ZCBwb2ludCB0byB0aGUgcGFydCBmb3IgbmV4dCBwYWNrZXQuICAqLworCitz dGF0aWMgdm9pZAorY3RmX3NhdmVfbmV4dF9wYWNrZXQgKHN0cnVjdCBjdGZf c2F2ZV9zICp0Y3NwKQoreworICB0Y3NwLT5wYWNrZXRfYmVnaW4gKz0gQ1RG X1BBQ0tFVF9TSVpFOworICBjdGZfc2F2ZV9mc2VlayAodGNzcCwgdGNzcC0+ cGFja2V0X2JlZ2luLCBTRUVLX1NFVCk7CisgIHRjc3AtPmNvbnRlbnRfc2l6 ZSA9IDA7Cit9CisKKy8qIFdyaXRlIHRoZSBjb250ZW50IHNpemUgdG8gcGFj a2V0IGhlYWRlciBjb250ZXh0LiAqLworCitzdGF0aWMgdm9pZAorY3RmX3Nh dmVfd3JpdGVfY29udGVudF9zaXplIChzdHJ1Y3QgY3RmX3NhdmVfcyAqdGNz cCkKK3sKKyAgdWludDMyX3QgdTMyOworCisgIGN0Zl9zYXZlX2ZzZWVrICh0 Y3NwLCB0Y3NwLT5wYWNrZXRfYmVnaW4gKyA0LCBTRUVLX1NFVCk7CisgIHUz MiA9IHRjc3AtPmNvbnRlbnRfc2l6ZSAqIFRBUkdFVF9DSEFSX0JJVDsKKyAg Y3RmX3NhdmVfd3JpdGUgKHRjc3AsICh2b2lkICopJnUzMiwgNCk7Cit9CisK Ky8qIFdyaXRlIHRoZSBDVEYgZGF0YSBwYWNrZXQgaGVhZGVyIGNvbnRleHQu ICAqLworCisjZGVmaW5lIFBBQ0tFVF9IRUFERVJfU0laRQkoNCArIDQgKyA0 KQorCitzdGF0aWMgdm9pZAorY3RmX3NhdmVfd3JpdGVfcGFja2V0X2hlYWRl cl9jb250ZXh0IChzdHJ1Y3QgY3RmX3NhdmVfcyAqdGNzcCkKK3sKKyAgdWlu dDMyX3QgdTMyOworCisgIC8qIG1hZ2ljLiAgKi8KKyAgdTMyID0gQ1RGX01B R0lDOworICBjdGZfc2F2ZV93cml0ZSAodGNzcCwgKHZvaWQgKikmdTMyLCA0 KTsKKyAgdGNzcC0+Y29udGVudF9zaXplICs9IDQ7CisKKyAgLyogY29udGVu dF9zaXplLiAgV2Ugc3RpbGwgZG9uJ3Qga25vdyB0aGUgc2l6ZSwgd3JpdGUg aXQgbGF0ZXIuICAqLworICBjdGZfc2F2ZV9mc2VlayAodGNzcCwgNCwgU0VF S19DVVIpOworICB0Y3NwLT5jb250ZW50X3NpemUgKz0gNDsKKworICAvKiBw YWNrZXRfc2l6ZSAqLworICB1MzIgPSBDVEZfUEFDS0VUX1NJWkUgKiBUQVJH RVRfQ0hBUl9CSVQ7CisgIGN0Zl9zYXZlX3dyaXRlICh0Y3NwLCAodm9pZCAq KSZ1MzIsIDQpOworICB0Y3NwLT5jb250ZW50X3NpemUgKz0gNDsKKworICB0 Y3NwLT5jdXJyZW50X2NvbnRlbnRfc2l6ZSA9IHRjc3AtPmNvbnRlbnRfc2l6 ZTsKKworICAvKiBNYWtlIHRoaXMgcGFja2V0IGFsbCBpbnRvIGZpbGUuICAq LworICBjdGZfc2F2ZV9mc2VlayAodGNzcCwgdGNzcC0+cGFja2V0X2JlZ2lu ICsgQ1RGX1BBQ0tFVF9TSVpFIC0gNCwgU0VFS19TRVQpOworICB1MzIgPSAw OworICBjdGZfc2F2ZV93cml0ZSAodGNzcCwgKHZvaWQgKikmdTMyLCA0KTsK KyAgY3RmX3NhdmVfZnNlZWsgKHRjc3AsIHRjc3AtPnBhY2tldF9iZWdpbiAr IHRjc3AtPmNvbnRlbnRfc2l6ZSwgU0VFS19TRVQpOworfQorCisvKiBDaGFu Z2UgSS10aCBjaGFyIGluIENURl9TVFIgdG8gU1RSLiAgKi8KKworc3RhdGlj IGNoYXIgKgorY3RmX3NhdmVfbWV0YWRhdGFfY2hhbmdlX2NoYXIgKGNoYXIg KmN0Zl9zdHIsIGludCBpLCBjb25zdCBjaGFyICpzdHIpCit7CisgIGNoYXIg Km5ldzsKKworICBjdGZfc3RyW2ldID0gJ1wwJzsKKyAgbmV3ID0geHN0cnBy aW50ZiAoIiVzJXMlc18lcyIsIGN0Zl9zdHIsIChpID8gIl8iIDogIiIpLAor CQkgICAgc3RyLCBjdGZfc3RyICsgaSArIDEpOworICB4ZnJlZSAoY3RmX3N0 cik7CisKKyAgcmV0dXJuIG5ldzsKK30KKworLyogV3JpdGUgdGhlIGhlYWRl ciBvZiBDVEYncyBtZXRhZGF0YSB0byBUQ1NQLT5NRVRBREFUQV9GRC4gICov CisKK3N0YXRpYyB2b2lkCitjdGZfc2F2ZV9tZXRhZGF0YV9oZWFkZXIgKHN0 cnVjdCBjdGZfc2F2ZV9zICp0Y3NwKQoreworICBjb25zdCBjaGFyIG1ldGFk YXRhX2ZtdFtdID0KKyAgIlxudHJhY2Uge1xuIgorICAiCW1ham9yID0gJXU7 XG4iCisgICIJbWlub3IgPSAldTtcbiIKKyAgIglieXRlX29yZGVyID0gJXM7 XG4iCQkvKiBiZSBvciBsZSAqLworICAiCXBhY2tldC5oZWFkZXIgOj0gc3Ry dWN0IHtcbiIKKyAgIgkJdWludDMyX3QgbWFnaWM7XG4iCisgICIJfTtcbiIK KyAgIn07XG4iCisgICJcbiIKKyAgInN0cmVhbSB7XG4iCisgICIJcGFja2V0 LmNvbnRleHQgOj0gc3RydWN0IHtcbiIKKyAgIgkJdWludDMyX3QgY29udGVu dF9zaXplO1xuIgorICAiCQl1aW50MzJfdCBwYWNrZXRfc2l6ZTtcbiIKKyAg Igl9O1xuIgorICAiCWV2ZW50LmhlYWRlciA6PSBzdHJ1Y3Qge1xuIgorICAi CQl1aW50MzJfdCBpZDtcbiIKKyAgIgl9O1xuIgorICAifTtcbiI7CisKKyAg Y3RmX3NhdmVfZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICIv KiBDVEYgJWQuJWQgKi9cbiIsCisJCQkgIENURl9TQVZFX01BSk9SLCBDVEZf U0FWRV9NSU5PUik7CisgIGN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXQgKHRjc3At Pm1ldGFkYXRhX2ZkLCAiXAordHlwZWFsaWFzIGludGVnZXIgeyBzaXplID0g MzI7IGFsaWduID0gMzI7IHNpZ25lZCA9IGZhbHNlOyB9IDo9IHVpbnQzMl90 O1xuIik7CisgIGN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXQgKHRjc3AtPm1ldGFk YXRhX2ZkLCAiXAordHlwZWFsaWFzIGludGVnZXIgeyBzaXplID0gNjQ7IGFs aWduID0gNjQ7IHNpZ25lZCA9IGZhbHNlOyB9IDo9IHVpbnQ2NF90O1xuIik7 CisgIGN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXQgKHRjc3AtPm1ldGFkYXRhX2Zk LCAiXG4iKTsKKworICBjdGZfc2F2ZV9md3JpdGVfZm9ybWF0ICh0Y3NwLT5t ZXRhZGF0YV9mZCwgbWV0YWRhdGFfZm10LAorCQkJICBDVEZfU0FWRV9NQUpP UiwgQ1RGX1NBVkVfTUlOT1IsCisJCQkgIEJZVEVfT1JERVIgPT0gTElUVExF X0VORElBTiA/ICJsZSIgOiAiYmUiKTsKKyAgY3RmX3NhdmVfZndyaXRlX2Zv cm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICJcbiIpOworfQorCisvKiBXcml0 ZSB0aGUgYm9keSBvZiBDVEYncyBtZXRhZGF0YSB0byBUQ1NQLT5NRVRBREFU QV9GRC4gICovCisKK3N0YXRpYyB2b2lkCitjdGZfc2F2ZV9tZXRhZGF0YSAo c3RydWN0IGN0Zl9zYXZlX3MgKnRjc3ApCit7CisgIHN0cnVjdCBjdGZfc2F2 ZV90cF9zICp0cHM7CisgIHN0cnVjdCBjdGZfc2F2ZV9jb2xsZWN0X3MgKmNv bGxlY3Q7CisgIHN0cnVjdCBjdGZfc2F2ZV90eXBlX3MgKnQ7CisKKyAgY3Rm X3NhdmVfZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsICJcbiIp OworCisgIC8qIFdyaXRlIGV2ZW50LiAgKi8KKyAgZm9yICh0cHMgPSB0Y3Nw LT50cDsgdHBzOyB0cHMgPSB0cHMtPm5leHQpCisgICAgeworICAgICAgY3Rm X3NhdmVfZndyaXRlX2Zvcm1hdCAodGNzcC0+bWV0YWRhdGFfZmQsCisJCQkg ICAgICAiZXZlbnQge1xuXHRuYW1lID0gXCIlcyVzXCI7XG5cdGlkID0gJXU7 XG4iCisJCQkgICAgICAiXHRmaWVsZHMgOj0gc3RydWN0IHsgXG4iLAorCQkJ ICAgICAgdHBzLT50cC0+YmFzZS5hZGRyX3N0cmluZywKKwkJCSAgICAgIHRw cy0+c3RlcHBpbmdfZnJhbWUgPyAiIHdoaWxlLXN0ZXBwaW5nIiA6ICIiLAor CQkJICAgICAgdHBzLT5pZCk7CisgICAgICBmb3IgKGNvbGxlY3QgPSB0cHMt PmNvbGxlY3Q7IGNvbGxlY3Q7IGNvbGxlY3QgPSBjb2xsZWN0LT5uZXh0KQor ICAgICAgICB7CisJICBjaGFyICp0bXA7CisJICBjb25zdCBjaGFyICpvbGRf dGFiOworCSAgaW50IGZpbmRfc2FtZSA9IDA7CisKKwkgIGlmIChjb2xsZWN0 LT5pc19yZXQpCisJICAgIGNvbGxlY3QtPmN0Zl9zdHIgPSB4c3RyZHVwICgi cmV0X3BjIik7CisJICBlbHNlCisJICAgIHsKKwkgICAgICBjaGFyICpuZXc7 CisJICAgICAgaW50IG5lZWRfcmVjaGVjazsKKwkgICAgICBpbnQgaTsKKwor CSAgICAgIGNvbGxlY3QtPmN0Zl9zdHIgPSB4c3RyZHVwIChjb2xsZWN0LT5z dHIpOworCSAgICAgIGZvciAoaSA9IDA7IGNvbGxlY3QtPmN0Zl9zdHJbaV0g IT0gJ1wwJzsgKytpKQorCSAgICAgICAgeworCQkgIHN3aXRjaCAoY29sbGVj dC0+Y3RmX3N0cltpXSkKKwkJICAgIHsKKwkJICAgIGNhc2UgJyQnOgorCQkg ICAgICBjb2xsZWN0LT5jdGZfc3RyCisJCQkgID0gY3RmX3NhdmVfbWV0YWRh dGFfY2hhbmdlX2NoYXIgKGNvbGxlY3QtPmN0Zl9zdHIsCisJCQkJCQkJICAg aSwgImRvbGxhciIpOworCQkgICAgICBicmVhazsKKwkJICAgIGNhc2UgJyon OgorCQkgICAgICBjb2xsZWN0LT5jdGZfc3RyCisJCQkgID0gY3RmX3NhdmVf bWV0YWRhdGFfY2hhbmdlX2NoYXIgKGNvbGxlY3QtPmN0Zl9zdHIsCisJCQkJ CQkJICAgaSwgInN0YXIiKTsKKwkJICAgICAgYnJlYWs7CisJCSAgICBjYXNl ICcgJzoKKwkJICAgICAgY29sbGVjdC0+Y3RmX3N0cltpXSA9ICdfJzsKKwkJ ICAgICAgYnJlYWs7CisJCSAgICB9CisJCX0KKwkgICAgfQorCisJICAvKiBD aGVjayBpZiBUUFMgaW5jbHVkZSBhIGNvbGxlY3QgdGhhdCBDVEZfU1RSIHNh bWUKKwkgICAgIHdpdGggQ09MTEVDVC0+Q1RGX1NUUi4KKwkgICAgIElmIHNv LCByZW5hbWUgaXQgYW5kIGtlZXAgY2hlY2suICAqLworCSAgdG1wID0gYWxs b2NhIChzdHJsZW4gKGNvbGxlY3QtPmN0Zl9zdHIpICsgMzApOworCSAgc3Ry Y3B5ICh0bXAsIGNvbGxlY3QtPmN0Zl9zdHIpOworCSAgd2hpbGUgKDEpCisJ ICAgIHsKKwkgICAgICBzdHJ1Y3QgY3RmX3NhdmVfY29sbGVjdF9zICpjb2xs ZWN0MjsKKwkgICAgICBpbnQgaSA9IDA7CisKKwkgICAgICBmb3IgKGNvbGxl Y3QyID0gdHBzLT5jb2xsZWN0OyBjb2xsZWN0MjsKKwkJICAgY29sbGVjdDIg PSBjb2xsZWN0Mi0+bmV4dCkKKwkJeworCQkgIGlmIChjb2xsZWN0ICE9IGNv bGxlY3QyICYmIGNvbGxlY3QyLT5jdGZfc3RyCisJCSAgICAgICYmIHN0cmNt cCAoY29sbGVjdDItPmN0Zl9zdHIsIHRtcCkgPT0gMCkKKwkJICAgIGJyZWFr OworCQl9CisJICAgICAgaWYgKGNvbGxlY3QyID09IE5VTEwpCisJCWJyZWFr OworCisJICAgICAgZmluZF9zYW1lID0gMTsKKwkgICAgICB4c25wcmludGYg KHRtcCwgc3RybGVuIChjb2xsZWN0LT5jdGZfc3RyKSArIDMwLAorCQkJICIl c18lZCIsIGNvbGxlY3QtPmN0Zl9zdHIsIGkrKyk7CisJICAgIH0KKwkgIGlm IChmaW5kX3NhbWUpCisJICAgIHsKKwkgICAgICB4ZnJlZSAoY29sbGVjdC0+ Y3RmX3N0cik7CisJICAgICAgY29sbGVjdC0+Y3RmX3N0ciA9IHhzdHJkdXAg KHRtcCk7CisJICAgIH0KKworCSAgaWYgKHN0cmNtcCAoY29sbGVjdC0+Y3Rm X3N0ciwgY29sbGVjdC0+c3RyKSkKKwkgICAgd2FybmluZyAoXygiXAorXCIl c1wiIG9mIHRyYWNlcG9pbnQgJWQgcmVuYW1lZCB0byBcIiVzXCIgaW4gQ1RG IGZpbGUuIiksCisJCSAgICAgICBjb2xsZWN0LT5zdHIsIHRwcy0+dHAtPmJh c2UubnVtYmVyLAorCQkgICAgICAgY29sbGVjdC0+Y3RmX3N0cik7CisKKwkg IG9sZF90YWIgPSB0Y3NwLT50YWI7CisJICB0Y3NwLT50YWIgPSAiXHRcdCI7 CisJICBjdGZfc2F2ZV9md3JpdGVfZm9ybWF0ICh0Y3NwLT5tZXRhZGF0YV9m ZCwgdGNzcC0+dGFiKTsKKwkgIGlmIChjb2xsZWN0LT5pc19yZXQpCisJICAg IGN0Zl9zYXZlX2Z3cml0ZV9mb3JtYXQgKHRjc3AtPm1ldGFkYXRhX2ZkLCAi dWludDY0X3QgJXM7XG4iLAorCQkJCSAgICBjb2xsZWN0LT5jdGZfc3RyKTsK KwkgIGVsc2UKKwkgICAgY3RmX3NhdmVfdmFyX2RlZmluZV93cml0ZSAodGNz cCwgY29sbGVjdC0+dHlwZSwgY29sbGVjdC0+Y3RmX3N0cik7CisJICB0Y3Nw LT50YWIgPSBvbGRfdGFiOworCX0KKyAgICAgIGN0Zl9zYXZlX2Z3cml0ZV9m b3JtYXQgKHRjc3AtPm1ldGFkYXRhX2ZkLCAiXHR9O1xufTtcbiIpOworICAg IH0KK30KKworLyogQ2xlYW4gZnVuY3Rpb24gZm9yIGN0Zl9zYXZlLiAgKi8K Kworc3RhdGljIHZvaWQKK2N0Zl9zYXZlX2NsZWFudXAgKHZvaWQgKnApCit7 CisgIHN0cnVjdCBjdGZfc2F2ZV9zICp0Y3NwID0gcDsKKyAgc3RydWN0IGN0 Zl9zYXZlX3RwX3MgKnRwLCAqdG1wX3RwOworICBzdHJ1Y3QgY3RmX3NhdmVf dHlwZV9zICp0eXBlLCAqdG1wX3R5cGU7CisKKyAgaWYgKHRjc3AtPm1ldGFk YXRhX2ZkKQorICAgIHsKKyAgICAgIGN0Zl9zYXZlX21ldGFkYXRhICh0Y3Nw KTsKKyAgICAgIGZjbG9zZSAodGNzcC0+bWV0YWRhdGFfZmQpOworICAgIH0K KworICBpZiAodGNzcC0+ZGF0YXN0cmVhbV9mZCkKKyAgICBmY2xvc2UgKHRj c3AtPmRhdGFzdHJlYW1fZmQpOworCisgIGZvciAodHAgPSB0Y3NwLT50cDsg dHA7IHRwID0gdG1wX3RwKQorICAgIHsKKyAgICAgIHN0cnVjdCBjdGZfc2F2 ZV9jb2xsZWN0X3MgKmNvbGxlY3QsICp0bXBfY29sbGVjdDsKKworICAgICAg Zm9yIChjb2xsZWN0ID0gdHAtPmNvbGxlY3Q7IGNvbGxlY3Q7IGNvbGxlY3Qg PSB0bXBfY29sbGVjdCkKKyAgICAgICAgeworCSAgeGZyZWUgKGNvbGxlY3Qt PmV4cHIpOworCSAgeGZyZWUgKGNvbGxlY3QtPnN0cik7CisJICB4ZnJlZSAo Y29sbGVjdC0+Y3RmX3N0cik7CisJICB0bXBfY29sbGVjdCA9IGNvbGxlY3Qt Pm5leHQ7CisJICB4ZnJlZSAoY29sbGVjdCk7CisgICAgICAgIH0KKyAgICAg IHRtcF90cCA9IHRwLT5uZXh0OworICAgICAgeGZyZWUgKHRwKTsKKyAgICB9 CisKKyAgZm9yICh0eXBlID0gdGNzcC0+dHlwZTsgdHlwZTsgdHlwZSA9IHRt cF90eXBlKQorICAgIHsKKyAgICAgIHRtcF90eXBlID0gdHlwZS0+bmV4dDsK KyAgICAgIHhmcmVlICh0eXBlKTsKKyAgICB9CisKKyAgcmVpbml0X2ZyYW1l X2NhY2hlICgpOworICB0YXJnZXRfZGNhY2hlX2ludmFsaWRhdGUgKCk7Cisg IHNldF9jdXJyZW50X3RyYWNlZnJhbWUgKHRjc3AtPm9sZF90cmFjZWZyYW1l X251bSk7Cit9CisKKy8qIFNhdmUgY3VycmVudCB0cmFjZSBmcmFtZSB0byBE SVJOQU1FLiAgKi8KKwordm9pZAorY3RmX3NhdmUgKGNvbnN0IGNoYXIgKmRp cm5hbWUpCit7CisgIHN0cnVjdCBjdGZfc2F2ZV9zIHRjczsKKyAgc3RydWN0 IGNsZWFudXAgKm9sZF9jaGFpbjsKKyAgaW50IGZyYW1lX251bTsKKyAgY2hh ciAqZmlsZV9uYW1lOworICBzdHJ1Y3QgY3RmX3NhdmVfdHlwZV9zICp0Owor ICBjaGFyIHRhYltdID0gIiI7CisKKyAgLyogQ3JlYXRlIERJUk5BTUUuICAq LworICBmaWxlX25hbWUgPSBhbGxvY2EgKHN0cmxlbiAoZGlybmFtZSkgKyAx CisJCSAgICAgICsgc3RybGVuIChDVEZfREFUQVNUUkVBTV9OQU1FKSArIDEp OworICBpZiAobWtkaXIgKGRpcm5hbWUsIFNfSVJXWFUgfCBTX0lSR1JQIHwg U19JWEdSUCB8IFNfSVJPVEggfCBTX0lYT1RIKQorICAgICAgJiYgZXJybm8g IT0gRUVYSVNUKQorICAgIGVycm9yIChfKCJVbmFibGUgdG8gb3BlbiBkaXJl Y3RvcnkgJyVzJyBmb3Igc2F2aW5nIHRyYWNlIGRhdGEgKCVzKSIpLAorCSAg IGRpcm5hbWUsIHNhZmVfc3RyZXJyb3IgKGVycm5vKSk7CisKKyAgbWVtc2V0 ICgmdGNzLCAnXDAnLCBzaXplb2YgKHRjcykpOworICB0Y3Mub2xkX3RyYWNl ZnJhbWVfbnVtID0gZ2V0X3RyYWNlZnJhbWVfbnVtYmVyICgpOworICBvbGRf Y2hhaW4gPSBtYWtlX2NsZWFudXAgKGN0Zl9zYXZlX2NsZWFudXAsICZ0Y3Mp OworICB0Y3MudGFiID0gdGFiOworCisgIHNwcmludGYgKGZpbGVfbmFtZSwg IiVzLyVzIiwgZGlybmFtZSwgQ1RGX01FVEFEQVRBX05BTUUpOworICB0Y3Mu bWV0YWRhdGFfZmQgPSBmb3BlbiAoZmlsZV9uYW1lLCAidyIpOworICBpZiAo IXRjcy5tZXRhZGF0YV9mZCkKKyAgICBlcnJvciAoXygiVW5hYmxlIHRvIG9w ZW4gZmlsZSAnJXMnIGZvciBzYXZpbmcgdHJhY2UgZGF0YSAoJXMpIiksCisJ ICAgZmlsZV9uYW1lLCBzYWZlX3N0cmVycm9yIChlcnJubykpOworICBjdGZf c2F2ZV9tZXRhZGF0YV9oZWFkZXIgKCZ0Y3MpOworCisgIHNwcmludGYgKGZp bGVfbmFtZSwgIiVzLyVzIiwgZGlybmFtZSwgQ1RGX0RBVEFTVFJFQU1fTkFN RSk7CisgIHRjcy5kYXRhc3RyZWFtX2ZkID0gZm9wZW4gKGZpbGVfbmFtZSwg InciKTsKKyAgaWYgKCF0Y3MuZGF0YXN0cmVhbV9mZCkKKyAgICBlcnJvciAo XygiVW5hYmxlIHRvIG9wZW4gZmlsZSAnJXMnIGZvciBzYXZpbmcgdHJhY2Ug ZGF0YSAoJXMpIiksCisJICAgZmlsZV9uYW1lLCBzYWZlX3N0cmVycm9yIChl cnJubykpOworCisgIGN0Zl9zYXZlX3dyaXRlX3BhY2tldF9oZWFkZXJfY29u dGV4dCAoJnRjcyk7CisKKyAgZm9yIChmcmFtZV9udW0gPSAwOyAxOyBmcmFt ZV9udW0gKyspCisgICAgeworICAgICAgaW50IHRudW07CisgICAgICBzdHJ1 Y3QgdHJhY2Vwb2ludCAqdHA7CisgICAgICBpbnQgdHJ5X2NvdW50OworICAg ICAgdWludDMyX3QgdTMyOworICAgICAgc3RydWN0IGN0Zl9zYXZlX3RwX3Mg KnRwczsKKyAgICAgIHN0cnVjdCBjdGZfc2F2ZV9jb2xsZWN0X3MgKmNvbGxl Y3Q7CisgICAgICBpbnQgdHJhY2VmcmFtZV9pc19kcm9wcGVkID0gMDsKKwor ICAgICAgLyogQWxsb3cgdXNlciB0byBiYWlsIG91dCB3aXRoIF5DLiAgKi8K KyAgICAgIFFVSVQ7CisKKyAgICAgIC8qIEdvdG8gdHJhY2VmcmFtZSBmcmFt ZV9udW0gYW5kIHNldCB0cC4gICovCisgICAgICBmcmFtZV9udW0gPSB0YXJn ZXRfdHJhY2VfZmluZCAodGZpbmRfbnVtYmVyLCBmcmFtZV9udW0sIDAsIDAs ICZ0bnVtKTsKKyAgICAgIGlmIChmcmFtZV9udW0gPCAwKQorCWJyZWFrOwor ICAgICAgdHAgPSBnZXRfdHJhY2Vwb2ludF9ieV9udW1iZXJfb25fdGFyZ2V0 ICh0bnVtKTsKKyAgICAgIGlmICghdHApCisgICAgICAgIHsKKwkgIHdhcm5p bmcgKF8oImRyb3AgdHJhY2VmcmFtZSAlZCBiZWNhdXNlIGNhbm5vdCBmaW5k IHRyYWNlcG9pbnQgJWQuIiksCisJCSAgIGZyYW1lX251bSwgdG51bSk7CisJ ICBjb250aW51ZTsKKwl9CisgICAgICBpZiAoIXRwLT5iYXNlLmxvYykKKyAg ICAgICAgeworCSAgd2FybmluZyAoXygiZHJvcCB0cmFjZWZyYW1lICVkIGJl Y2F1c2UgdHJhY2Vwb2ludCAlZCBpcyBwZW5kaW5nLiIpLAorCQkgICBmcmFt ZV9udW0sIHRwLT5iYXNlLm51bWJlcik7CisJICBjb250aW51ZTsKKwl9Cisg ICAgICByZWluaXRfZnJhbWVfY2FjaGUgKCk7CisgICAgICB0YXJnZXRfZGNh Y2hlX2ludmFsaWRhdGUgKCk7CisgICAgICBzZXRfY3VycmVudF90cmFjZWZy YW1lIChmcmFtZV9udW0pOworCisgICAgICB0cHMgPSBjdGZfc2F2ZV90cF9m aW5kICgmdGNzLCB0cCk7CisKKyAgICAgIC8qIFRoZSB0cCBpcyBub3QgdmFy aWFibGUtbGVuZ3RoIGFuZCBiaWdnZXIgdGhhbiBDVEZfUEFDS0VUX1NJWkUu CisgICAgICAgICBTbyBkcm9wIGl0LiAgKi8KKyAgICAgIGlmICh0cHMtPmlz X2Ryb3BwZWQpCisJY29udGludWU7CisKKyAgICAgIC8qIFRyeSBjb3VudCBm b3IgY3VycmVudCB0cCB3cml0ZS4KKyAgICAgICAgIElmIHRyeSBzZWNvbmQg dGltZSwgdGhlIGV2ZW50IHNpemUgYmlnZ2VyIHRoYW4gYSBwYWNrZXQuCisg ICAgICAgICBUaGVuIGRyb3AgdGhpcyBldmVudC4gICovCisgICAgICB0cnlf Y291bnQgPSAwOworCityZV93cml0ZV90cDoKKyAgICAgIGlmICh0cnlfY291 bnQgPiAwKQorICAgICAgICB7CisJICAvKiBIYW5kbGUgcmV0cnkuICAqLwor CSAgaWYgKHRyeV9jb3VudCA+IDEgfHwgUEFDS0VUX0hFQURFUl9TSVpFID09 IHRjcy5jb250ZW50X3NpemUpCisJICAgIHsKKwkgICAgICAvKiBTZWNvbmQg cmV0cnkgb3IgcGFja2V0IGp1c3Qgd3JpdGUgdGhhdCBwYWNrZXQgbWVhbnMK KwkgICAgICAgICB0aGlzIFRQIGlzIHRvbyBiaWcuICBTbyBkcm9wIGl0LiAg Ki8KKwkgICAgICBpZiAodHBzLT5pc192YXJpYWJsZV9sZW5ndGgpCisJICAg ICAgICB7CisJCSAgLyogVGhlIHRwIGlzIHZhcmlhYmxlLWxlbmd0aC4gICov CisJCSAgd2FybmluZyAoXygiXAordHJhY2VmcmFtZSAlZCBvZiB0cmFjZXBv aW50ICVkIG5lZWRzIHRvIHNhdmUgZGF0YSB0aGF0IGlzIGJpZ2dlciB0aGFu IHBhY2tldCBzaXplICVkLlxuXAorU28gaXQgd2lsbCBiZSBkcm9wcGVkLiIp LCBmcmFtZV9udW0sIHRwcy0+dHAtPmJhc2UubnVtYmVyLCBDVEZfUEFDS0VU X1NJWkUpOworCQl9CisJICAgICAgZWxzZQorCSAgICAgICAgeworCQkgIC8q IFRoZSB0cCBpcyBub3QgdmFyaWFibGUtbGVuZ3RoLiAgKi8KKwkJICB3YXJu aW5nIChfKCJcCit0cmFjZXBvaW50ICVkIG5lZWQgc2F2ZSBkYXRhIHRoYXQg YmlnZ2VyIHRoYW4gcGFja2V0IHNpemUgJWQuXG5cCitTbyBhbGwgb2YgaXRz IHRyYWNlZnJhbWVzIHdpbGwgYmUgZHJvcHBlZC4iKSwKKwkJCSAgIHRwcy0+ dHAtPmJhc2UubnVtYmVyLCBDVEZfUEFDS0VUX1NJWkUpOworCQkgIC8qIE1h cmsgdGhpcyB0cCB0byBsZXQgR0RCIGRyb3AgaXRzIHRyYWNlZnJhbWVzLiAg Ki8KKwkJICB0cHMtPmlzX2Ryb3BwZWQgPSAxOworCQl9CisJICAgICAgY29u dGludWU7CisJICAgIH0KKworCSAgdGNzLmNoZWNrX3NpemUgPSAwOworCSAg Y3RmX3NhdmVfd3JpdGVfY29udGVudF9zaXplICgmdGNzKTsKKyAgICAgICAg ICBjdGZfc2F2ZV9uZXh0X3BhY2tldCAoJnRjcyk7CisJICBjdGZfc2F2ZV93 cml0ZV9wYWNrZXRfaGVhZGVyX2NvbnRleHQgKCZ0Y3MpOworCX0KKworICAg ICAgdHJ5X2NvdW50ICsrOworCisgICAgICB0Y3MuY3VycmVudF9jb250ZW50 X3NpemUgPSB0Y3MuY29udGVudF9zaXplOworICAgICAgdGNzLmNoZWNrX3Np emUgPSAxOworCisgICAgICB1MzIgPSAodWludDMyX3QpIHRwcy0+aWQ7Cisg ICAgICBpZiAoY3RmX3NhdmVfYWxpZ25fd3JpdGUgKCZ0Y3MsICh2b2lkICop JnUzMiwgc2l6ZW9mICh1MzIpLAorCQkJCXNpemVvZiAodTMyKSkpCisJZ290 byByZV93cml0ZV90cDsKKworICAgICAgLyogQWxpZ24uICAqLworICAgICAg aWYgKHRwcy0+YWxpZ25fc2l6ZSkKKyAgICAgICAgeworCSAgaWYgKGN0Zl9z YXZlX2ZzZWVrICgmdGNzLAorCQkJICAgICAgQUxJR05fU0laRSAodGNzLmN1 cnJlbnRfY29udGVudF9zaXplLAorCQkJCQkgIHRwcy0+YWxpZ25fc2l6ZSks CisJCQkgICAgICBTRUVLX0NVUikpCisJICAgIGdvdG8gcmVfd3JpdGVfdHA7 CisJfQorCisgICAgICBmb3IgKGNvbGxlY3QgPSB0cHMtPmNvbGxlY3Q7IGNv bGxlY3Q7IGNvbGxlY3QgPSBjb2xsZWN0LT5uZXh0KQorICAgICAgICB7CisJ ICB2b2xhdGlsZSBzdHJ1Y3QgZ2RiX2V4Y2VwdGlvbiBlOworCisJICBpZiAo Y29sbGVjdC0+aXNfcmV0KQorCSAgICB7CisJICAgICAgQ09SRV9BRERSIHBj OworCSAgICAgIHVpbnQ2NF90IHU2NDsKKworCSAgICAgIFRSWV9DQVRDSCAo ZSwgUkVUVVJOX01BU0tfRVJST1IpCisJCXsKKwkJICBzdHJ1Y3QgZnJhbWVf aW5mbyAqZnJhbWU7CisKKwkJICBmcmFtZSA9IGdldF9jdXJyZW50X2ZyYW1l ICgpOworCQkgIGlmICghZnJhbWUpCisJCSAgICBlcnJvciAoXygiZ2V0IGN1 cnJlbnQgZnJhbWUgZmFpbCIpKTsKKwkJICBmcmFtZSA9IGdldF9wcmV2X2Zy YW1lIChmcmFtZSk7CisJCSAgaWYgKCFmcmFtZSkKKwkJICAgIGVycm9yIChf KCJnZXQgcHJldiBmcmFtZSBmYWlsIikpOworCisJCSAgaWYgKCFnZXRfZnJh bWVfcGNfaWZfYXZhaWxhYmxlIChmcmFtZSwgJnBjKSkKKwkJICAgIGVycm9y IChfKCJQQyB1bmF2YWlsYWJsZSIpKTsKKwkJfQorCSAgICAgIGlmIChlLnJl YXNvbiA8IDApCisJCXsKKwkJICB3YXJuaW5nIChfKCJcCit0cmFjZWZyYW1l ICVkIGlzIGRyb3BwZWQgYmVjYXVzZSBHREIgdHJ5IHRvIGdldCB0aGUgdmFs dWUgb2YgXCIlc1wiIGdvdCBlcnJvcjogJXMiKSwKKwkJCSAgIGZyYW1lX251 bSwgY29sbGVjdC0+c3RyLCBlLm1lc3NhZ2UpOworCQkgIHRyYWNlZnJhbWVf aXNfZHJvcHBlZCA9IDE7CisJCSAgYnJlYWs7CisJCX0KKworCSAgICAgIHU2 NCA9IHBjOworCSAgICAgIGlmIChjdGZfc2F2ZV9hbGlnbl93cml0ZSAoJnRj cywgKGdkYl9ieXRlICopICZ1NjQsCisJCQkJCXNpemVvZiAodTY0KSwgc2l6 ZW9mICh1NjQpKSkKKwkJZ290byByZV93cml0ZV90cDsKKwkgICAgfQorCSAg ZWxzZQorICAgICAgICAgICAgeworCSAgICAgIHN0cnVjdCB2YWx1ZSAqdmFs OworCSAgICAgIHN0cnVjdCBjbGVhbnVwICpiYWNrX2NoYWluOworCSAgICAg IGNvbnN0IGdkYl9ieXRlICpjb250ZW50OworCisJICAgICAgYmFja19jaGFp biA9IG1ha2VfY2xlYW51cCAobnVsbF9jbGVhbnVwLCBOVUxMKTsKKwkgICAg ICBUUllfQ0FUQ0ggKGUsIFJFVFVSTl9NQVNLX0VSUk9SKQorCSAgICAgICAg eworCQkgIHZhbCA9IGV2YWx1YXRlX2V4cHJlc3Npb24gKGNvbGxlY3QtPmV4 cHIpOworCQkgIGNvbnRlbnQgPSB2YWx1ZV9jb250ZW50cyAodmFsKTsKKwkJ fQorCSAgICAgIGlmIChlLnJlYXNvbiA8IDAgfHwgY29sbGVjdC0+dHlwZSAh PSB2YWx1ZV90eXBlICh2YWwpKQorCQl7CisJCSAgaWYgKGUucmVhc29uIDwg MCkKKwkJICAgIHdhcm5pbmcgKF8oIlwKK3RyYWNlZnJhbWUgJWQgaXMgZHJv cHBlZCBiZWNhdXNlIHRyeSB0byBnZXQgdGhlIHZhbHVlIG9mIFwiJXNcIiBn b3QgZXJyb3I6ICVzIiksCisJCQkgICAgIGZyYW1lX251bSwgY29sbGVjdC0+ c3RyLCBlLm1lc3NhZ2UpOworCQkgIGVsc2UKKwkJICAgIHdhcm5pbmcgKF8o IlwKK3RyYWNlZnJhbWUgJWQgaXMgZHJvcHBlZCBiZWNhdXNlIHR5cGUgb2Yg XCIlc1wiIGlzIHdyb25nLiIpLAorCQkJICAgICBmcmFtZV9udW0sIGNvbGxl Y3QtPnN0cik7CisJCSAgdHJhY2VmcmFtZV9pc19kcm9wcGVkID0gMTsKKwkJ ICBkb19jbGVhbnVwcyAoYmFja19jaGFpbik7CisJCSAgYnJlYWs7CisJCX0K KworCSAgICAgIC8qIFdyaXRlIHRoaXMgdmFsIGFjY29yZGluZyB0byB0eXBl LiAgKi8KKwkgICAgICBpZiAoY3RmX3NhdmVfYWxpZ25fd3JpdGUgKCZ0Y3Ms IGNvbnRlbnQsCisJCQkJCVRZUEVfTEVOR1RIIChjb2xsZWN0LT50eXBlKSwK KwkJCQkJY29sbGVjdC0+YWxpZ25fc2l6ZSkpCisJCXsKKwkJICBkb19jbGVh bnVwcyAoYmFja19jaGFpbik7CisJCSAgZ290byByZV93cml0ZV90cDsKKwkJ fQorCisJICAgICAgLyogRnJlZSB0aGUgbWVtb3J5IHRoYXQgYWxsb2MgYnkg ZXZhbHVhdGVfZXhwcmVzc2lvbi4gICovCisJICAgICAgZG9fY2xlYW51cHMg KGJhY2tfY2hhaW4pOworCSAgICB9CisJfQorCisgICAgICBpZiAodHJhY2Vm cmFtZV9pc19kcm9wcGVkKQorCWNvbnRpbnVlOworCisgICAgICB0Y3MuY29u dGVudF9zaXplID0gdGNzLmN1cnJlbnRfY29udGVudF9zaXplOworICAgIH0K KyAgY3RmX3NhdmVfd3JpdGVfY29udGVudF9zaXplICgmdGNzKTsKKworICBk b19jbGVhbnVwcyAob2xkX2NoYWluKTsKK30KLS0tIC9kZXYvbnVsbAorKysg Yi9jdGYuaApAQCAtMCwwICsxLDI1IEBACisvKiBDVEYgZm9ybWF0IHN1cHBv cnQuCisKKyAgIENvcHlyaWdodCAoQykgMjAxMiBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb24sIEluYy4KKworICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RC LgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisgICAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGlz IHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICBNRVJD SEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0 cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisjaWZuZGVmIENU Rl9ICisjZGVmaW5lIENURl9ICisKK2V4dGVybiB2b2lkIGN0Zl9zYXZlIChj b25zdCBjaGFyICpkaXJuYW1lKTsKKworI2VuZGlmCi0tLSBhL21pL21pLW1h aW4uYworKysgYi9taS9taS1tYWluLmMKQEAgLTQ5LDYgKzQ5LDcgQEAKICNp bmNsdWRlICJvc2RhdGEuaCIKICNpbmNsdWRlICJzcGxheS10cmVlLmgiCiAj aW5jbHVkZSAidHJhY2Vwb2ludC5oIgorI2luY2x1ZGUgImN0Zi5oIgogI2lu Y2x1ZGUgImFkYS1sYW5nLmgiCiAjaW5jbHVkZSAibGluZXNwZWMuaCIKIApA QCAtMjQ5NSwxNiArMjQ5NiwxOSBAQCB2b2lkCiBtaV9jbWRfdHJhY2Vfc2F2 ZSAoY2hhciAqY29tbWFuZCwgY2hhciAqKmFyZ3YsIGludCBhcmdjKQogewog ICBpbnQgdGFyZ2V0X3NhdmVzID0gMDsKKyAgaW50IGdlbmVyYXRlX2N0ZiA9 IDA7CiAgIGNoYXIgKmZpbGVuYW1lOwogCiAgIGlmIChhcmdjICE9IDEgJiYg YXJnYyAhPSAyKQotICAgIGVycm9yIChfKCJVc2FnZTogLXRyYWNlLXNhdmUg Wy1yXSBmaWxlbmFtZSIpKTsKKyAgICBlcnJvciAoXygiVXNhZ2U6IC10cmFj ZS1zYXZlIFstcl0gWy1jdGZdIGZpbGVuYW1lIikpOwogCiAgIGlmIChhcmdj ID09IDIpCiAgICAgewogICAgICAgZmlsZW5hbWUgPSBhcmd2WzFdOwogICAg ICAgaWYgKHN0cmNtcCAoYXJndlswXSwgIi1yIikgPT0gMCkKIAl0YXJnZXRf c2F2ZXMgPSAxOworICAgICAgaWYgKHN0cmNtcCAoYXJndlswXSwgIi1jdGYi KSA9PSAwKQorCWdlbmVyYXRlX2N0ZiA9IDE7CiAgICAgICBlbHNlCiAJZXJy b3IgKF8oIkludmFsaWQgb3B0aW9uOiAlcyIpLCBhcmd2WzBdKTsKICAgICB9 CkBAIC0yNTEzLDcgKzI1MTcsMTAgQEAgbWlfY21kX3RyYWNlX3NhdmUgKGNo YXIgKmNvbW1hbmQsIGNoYXIgKgogICAgICAgZmlsZW5hbWUgPSBhcmd2WzBd OwogICAgIH0KIAotICB0cmFjZV9zYXZlIChmaWxlbmFtZSwgdGFyZ2V0X3Nh dmVzKTsKKyAgaWYgKGdlbmVyYXRlX2N0ZikKKyAgICBjdGZfc2F2ZSAoZmls ZW5hbWUpOworICBlbHNlCisgICAgdHJhY2Vfc2F2ZSAoZmlsZW5hbWUsIHRh cmdldF9zYXZlcyk7CiB9CiAKIHZvaWQKLS0tIGEvdHJhY2Vwb2ludC5jCisr KyBiL3RyYWNlcG9pbnQuYwpAQCAtNTMsNiArNTMsNyBAQAogI2luY2x1ZGUg ImV4Y2VwdGlvbnMuaCIKICNpbmNsdWRlICJjbGkvY2xpLXV0aWxzLmgiCiAj aW5jbHVkZSAicHJvYmUuaCIKKyNpbmNsdWRlICJjdGYuaCIKIAogLyogcmVh ZGxpbmUgaW5jbHVkZSBmaWxlcyAqLwogI2luY2x1ZGUgInJlYWRsaW5lL3Jl YWRsaW5lLmgiCkBAIC01NzMsNyArNTc0LDcgQEAgd2hpbGVfc3RlcHBpbmdf cHNldWRvY29tbWFuZCAoY2hhciAqYXJncwogICBlcnJvciAoXygiVGhpcyBj b21tYW5kIGNhbiBvbmx5IGJlIHVzZWQgaW4gYSB0cmFjZXBvaW50IGFjdGlv bnMgbGlzdC4iKSk7CiB9CiAKLXN0YXRpYyB2b2lkCit2b2lkCiBjb2xsZWN0 X3BzZXVkb2NvbW1hbmQgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0eSkKIHsK ICAgZXJyb3IgKF8oIlRoaXMgY29tbWFuZCBjYW4gb25seSBiZSB1c2VkIGlu IGEgdHJhY2Vwb2ludCBhY3Rpb25zIGxpc3QuIikpOwpAQCAtMTE0Nyw2ICsx MTQ4LDM0IEBAIGRvX2NvbGxlY3Rfc3ltYm9sIChjb25zdCBjaGFyICpwcmlu dF9uYW0KICAgcC0+Y291bnQrKzsKIH0KIAoraW50CithZGRfbG9jYWxfc3lt Ym9sc18xIChpbnQgdHlwZSwgQ09SRV9BRERSIHBjLAorCQkgICAgIGl0ZXJh dGVfb3Zlcl9ibG9ja19hcmdfbG9jYWxfdmFyc19jYiBjYiwKKwkJICAgICB2 b2lkICpjYl9kYXRhKQoreworICBzdHJ1Y3QgYmxvY2sgKmJsb2NrOworCisg IGlmICh0eXBlID09ICdMJykKKyAgICB7CisgICAgICBibG9jayA9IGJsb2Nr X2Zvcl9wYyAocGMpOworICAgICAgaWYgKGJsb2NrID09IE5VTEwpCisJcmV0 dXJuIC0xOworCisgICAgICBpdGVyYXRlX292ZXJfYmxvY2tfbG9jYWxfdmFy cyAoYmxvY2ssIGNiLCBjYl9kYXRhKTsKKyAgICB9CisgIGVsc2UKKyAgICB7 CisgICAgICBwYyA9IGdldF9wY19mdW5jdGlvbl9zdGFydCAocGMpOworICAg ICAgYmxvY2sgPSBibG9ja19mb3JfcGMgKHBjKTsKKyAgICAgIGlmIChibG9j ayA9PSBOVUxMKQorCXJldHVybiAtMTsKKworICAgICAgaXRlcmF0ZV9vdmVy X2Jsb2NrX2FyZ192YXJzIChibG9jaywgY2IsIGNiX2RhdGEpOworICAgIH0K KworICByZXR1cm4gMDsKK30KKwogLyogQWRkIGFsbCBsb2NhbHMgKG9yIGFy Z3MpIHN5bWJvbHMgdG8gY29sbGVjdGlvbiBsaXN0LiAgKi8KIHN0YXRpYyB2 b2lkCiBhZGRfbG9jYWxfc3ltYm9scyAoc3RydWN0IGNvbGxlY3Rpb25fbGlz dCAqY29sbGVjdCwKQEAgLTExNTUsNiArMTE4NCw3IEBAIGFkZF9sb2NhbF9z eW1ib2xzIChzdHJ1Y3QgY29sbGVjdGlvbl9saXMKIHsKICAgc3RydWN0IGJs b2NrICpibG9jazsKICAgc3RydWN0IGFkZF9sb2NhbF9zeW1ib2xzX2RhdGEg Y2JfZGF0YTsKKyAgY29uc3QgY2hhciAqbmFtZTsKIAogICBjYl9kYXRhLmNv bGxlY3QgPSBjb2xsZWN0OwogICBjYl9kYXRhLmdkYmFyY2ggPSBnZGJhcmNo OwpAQCAtMTE2NCwzMyArMTE5NCwxOSBAQCBhZGRfbG9jYWxfc3ltYm9scyAo c3RydWN0IGNvbGxlY3Rpb25fbGlzCiAgIGNiX2RhdGEuY291bnQgPSAwOwog CiAgIGlmICh0eXBlID09ICdMJykKLSAgICB7Ci0gICAgICBibG9jayA9IGJs b2NrX2Zvcl9wYyAocGMpOwotICAgICAgaWYgKGJsb2NrID09IE5VTEwpCi0J ewotCSAgd2FybmluZyAoXygiQ2FuJ3QgY29sbGVjdCBsb2NhbHM7ICIKLQkJ ICAgICAibm8gc3ltYm9sIHRhYmxlIGluZm8gYXZhaWxhYmxlLlxuIikpOwot CSAgcmV0dXJuOwotCX0KLQotICAgICAgaXRlcmF0ZV9vdmVyX2Jsb2NrX2xv Y2FsX3ZhcnMgKGJsb2NrLCBkb19jb2xsZWN0X3N5bWJvbCwgJmNiX2RhdGEp OwotICAgICAgaWYgKGNiX2RhdGEuY291bnQgPT0gMCkKLQl3YXJuaW5nIChf KCJObyBsb2NhbHMgZm91bmQgaW4gc2NvcGUuIikpOwotICAgIH0KKyAgICBu YW1lID0gImxvY2FscyI7CiAgIGVsc2UKLSAgICB7Ci0gICAgICBwYyA9IGdl dF9wY19mdW5jdGlvbl9zdGFydCAocGMpOwotICAgICAgYmxvY2sgPSBibG9j a19mb3JfcGMgKHBjKTsKLSAgICAgIGlmIChibG9jayA9PSBOVUxMKQotCXsK LQkgIHdhcm5pbmcgKF8oIkNhbid0IGNvbGxlY3QgYXJnczsgbm8gc3ltYm9s IHRhYmxlIGluZm8gYXZhaWxhYmxlLiIpKTsKLQkgIHJldHVybjsKLQl9Cisg ICAgbmFtZSA9ICJhcmdzIjsKIAotICAgICAgaXRlcmF0ZV9vdmVyX2Jsb2Nr X2FyZ192YXJzIChibG9jaywgZG9fY29sbGVjdF9zeW1ib2wsICZjYl9kYXRh KTsKLSAgICAgIGlmIChjYl9kYXRhLmNvdW50ID09IDApCi0Jd2FybmluZyAo XygiTm8gYXJncyBmb3VuZCBpbiBzY29wZS4iKSk7CisgIGlmIChhZGRfbG9j YWxfc3ltYm9sc18xICh0eXBlLCBwYywgZG9fY29sbGVjdF9zeW1ib2wsICZj Yl9kYXRhKSkKKyAgICB7CisgICAgICB3YXJuaW5nIChfKCJDYW4ndCBjb2xs ZWN0ICVzOyBubyBzeW1ib2wgdGFibGUgaW5mbyBhdmFpbGFibGUuXG4iKSwK KwkgICAgICAgbmFtZSk7CisgICAgICByZXR1cm47CiAgICAgfQorCisgIGlm IChjYl9kYXRhLmNvdW50ID09IDApCisgICAgd2FybmluZyAoXygiTm8gJXMg Zm91bmQgaW4gc2NvcGUuIiksIG5hbWUpOwogfQogCiBzdGF0aWMgdm9pZApA QCAtMzE1MSw2ICszMTY3LDcgQEAgc3RhdGljIHZvaWQKIHRyYWNlX3NhdmVf Y29tbWFuZCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5KQogewogICBpbnQg dGFyZ2V0X2RvZXNfc2F2ZSA9IDA7CisgIGludCBnZW5lcmF0ZV9jdGYgPSAw OwogICBjaGFyICoqYXJndjsKICAgY2hhciAqZmlsZW5hbWUgPSBOVUxMOwog ICBzdHJ1Y3QgY2xlYW51cCAqYmFja190bzsKQEAgLTMxNjUsNiArMzE4Miw4 IEBAIHRyYWNlX3NhdmVfY29tbWFuZCAoY2hhciAqYXJncywgaW50IGZyb20K ICAgICB7CiAgICAgICBpZiAoc3RyY21wICgqYXJndiwgIi1yIikgPT0gMCkK IAl0YXJnZXRfZG9lc19zYXZlID0gMTsKKyAgICAgIGlmIChzdHJjbXAgKCph cmd2LCAiLWN0ZiIpID09IDApCisJZ2VuZXJhdGVfY3RmID0gMTsKICAgICAg IGVsc2UgaWYgKCoqYXJndiA9PSAnLScpCiAJZXJyb3IgKF8oInVua25vd24g b3B0aW9uIGAlcyciKSwgKmFyZ3YpOwogICAgICAgZWxzZQpAQCAtMzE3NCwx MCArMzE5MywxOCBAQCB0cmFjZV9zYXZlX2NvbW1hbmQgKGNoYXIgKmFyZ3Ms IGludCBmcm9tCiAgIGlmICghZmlsZW5hbWUpCiAgICAgZXJyb3Jfbm9fYXJn IChfKCJmaWxlIGluIHdoaWNoIHRvIHNhdmUgdHJhY2UgZGF0YSIpKTsKIAot ICB0cmFjZV9zYXZlIChmaWxlbmFtZSwgdGFyZ2V0X2RvZXNfc2F2ZSk7Cisg IGlmIChnZW5lcmF0ZV9jdGYpCisgICAgeworICAgICAgaWYgKHRhcmdldF9k b2VzX3NhdmUpCisJZXJyb3Jfbm9fYXJnIChfKCItciBjYW5ub3QgYmUgdXNl ZCB3aXRoIC1jdGYuIikpOworICAgICAgY3RmX3NhdmUgKGZpbGVuYW1lKTsK KyAgICB9CisgIGVsc2UKKyAgICB0cmFjZV9zYXZlIChmaWxlbmFtZSwgdGFy Z2V0X2RvZXNfc2F2ZSk7CiAKICAgaWYgKGZyb21fdHR5KQotICAgIHByaW50 Zl9maWx0ZXJlZCAoXygiVHJhY2UgZGF0YSBzYXZlZCB0byBmaWxlICclcycu XG4iKSwgZmlsZW5hbWUpOworICAgIHByaW50Zl9maWx0ZXJlZCAoXygiVHJh Y2UgZGF0YSBzYXZlZCB0byAlcyAnJXMnLlxuIiksCisJCSAgICAgZ2VuZXJh dGVfY3RmID8gImRpcmVjdG9yeSIgOiAiZmlsZSIsIGZpbGVuYW1lKTsKIAog ICBkb19jbGVhbnVwcyAoYmFja190byk7CiB9CkBAIC01MjIwLDYgKzUyNDcs NyBAQCBfaW5pdGlhbGl6ZV90cmFjZXBvaW50ICh2b2lkKQogICBhZGRfY29t ICgidHNhdmUiLCBjbGFzc190cmFjZSwgdHJhY2Vfc2F2ZV9jb21tYW5kLCBf KCJcCiBTYXZlIHRoZSB0cmFjZSBkYXRhIHRvIGEgZmlsZS5cblwKIFVzZSB0 aGUgJy1yJyBvcHRpb24gdG8gZGlyZWN0IHRoZSB0YXJnZXQgdG8gc2F2ZSBk aXJlY3RseSB0byB0aGUgZmlsZSxcblwKK1VzZSB0aGUgJy1jdGYnIG9wdGlv biB0byBzYXZlIHRoZSBkYXRhIHRvIENURiBmb3JtYXQsXG5cCiB1c2luZyBp dHMgb3duIGZpbGVzeXN0ZW0uIikpOwogCiAgIGMgPSBhZGRfY29tICgidHZh cmlhYmxlIiwgY2xhc3NfdHJhY2UsIHRyYWNlX3ZhcmlhYmxlX2NvbW1hbmQs XygiXAotLS0gYS90cmFjZXBvaW50LmgKKysrIGIvdHJhY2Vwb2ludC5oCkBA IC0yMyw2ICsyMyw3IEBACiAjaW5jbHVkZSAidGFyZ2V0LmgiCiAjaW5jbHVk ZSAibWVtcmFuZ2UuaCIKICNpbmNsdWRlICJnZGJfdmVjcy5oIgorI2luY2x1 ZGUgInN0YWNrLmgiCiAKIC8qIEEgdHJhY2Ugc3RhdGUgdmFyaWFibGUgaXMg YSB2YWx1ZSBtYW5hZ2VkIGJ5IGEgdGFyZ2V0IGJlaW5nCiAgICB0cmFjZWQu ICBBIHRyYWNlIHN0YXRlIHZhcmlhYmxlIChvciB0c3YgZm9yIHNob3J0KSBj YW4gYmUgYWNjZXNzZWQKQEAgLTI0Niw2ICsyNDcsNyBAQCBleHRlcm4gdm9p ZCB2YWxpZGF0ZV9hY3Rpb25saW5lIChjaGFyICoqCiAKIGV4dGVybiB2b2lk IGVuZF9hY3Rpb25zX3BzZXVkb2NvbW1hbmQgKGNoYXIgKmFyZ3MsIGludCBm cm9tX3R0eSk7CiBleHRlcm4gdm9pZCB3aGlsZV9zdGVwcGluZ19wc2V1ZG9j b21tYW5kIChjaGFyICphcmdzLCBpbnQgZnJvbV90dHkpOworZXh0ZXJuIHZv aWQgY29sbGVjdF9wc2V1ZG9jb21tYW5kIChjaGFyICphcmdzLCBpbnQgZnJv bV90dHkpOwogCiBleHRlcm4gc3RydWN0IHRyYWNlX3N0YXRlX3ZhcmlhYmxl ICpmaW5kX3RyYWNlX3N0YXRlX3ZhcmlhYmxlIChjb25zdCBjaGFyICpuYW1l KTsKIGV4dGVybiBzdHJ1Y3QgdHJhY2Vfc3RhdGVfdmFyaWFibGUgKmNyZWF0 ZV90cmFjZV9zdGF0ZV92YXJpYWJsZSAoY29uc3QgY2hhciAqbmFtZSk7CkBA IC0yOTAsNCArMjkyLDcgQEAgZXh0ZXJuIHN0cnVjdCB0cmFjZWZyYW1lX2lu Zm8gKnBhcnNlX3RyYQogZXh0ZXJuIGludCB0cmFjZWZyYW1lX2F2YWlsYWJs ZV9tZW1vcnkgKFZFQyhtZW1fcmFuZ2VfcykgKipyZXN1bHQsCiAJCQkJCUNP UkVfQUREUiBtZW1hZGRyLCBVTE9OR0VTVCBsZW4pOwogCitleHRlcm4gaW50 IGFkZF9sb2NhbF9zeW1ib2xzXzEgKGludCB0eXBlLCBDT1JFX0FERFIgcGMs CisJCQkJaXRlcmF0ZV9vdmVyX2Jsb2NrX2FyZ19sb2NhbF92YXJzX2NiIGNi LAorCQkJCXZvaWQgKmNiX2RhdGEpOwogI2VuZGlmCS8qIFRSQUNFUE9JTlRf SCAqLwo= --f46d0443ff7e8e3a9b04d385de69--