From raghavendra.koushik@wipro.com Mon Mar 1 00:20:11 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 00:20:31 -0800 (PST) Received: from wiproecmx1.wipro.com (wiproecmx1.wipro.com [164.164.31.5]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i218K2KO023263 for ; Mon, 1 Mar 2004 00:20:06 -0800 Received: from ec-vwall-wd (ec-vwall-wd.wipro.com [10.200.52.125]) by wiproecmx1.wipro.com (8.12.9-20031013/8.12.9) with SMTP id i216LgYO008604 for ; Mon, 1 Mar 2004 11:51:42 +0530 (IST) Received: from blr-ec-bh3.wipro.com ([10.200.50.93]) by ec-vwall-wd with InterScan Messaging Security Suite; Mon, 01 Mar 2004 11:52:55 +0530 Received: from blr-m3-msg.wipro.com ([10.114.50.99]) by blr-ec-bh3.wipro.com with Microsoft SMTPSVC(5.0.2195.6713); Mon, 1 Mar 2004 11:51:40 +0530 X-MimeOLE: Produced By Microsoft Exchange V6.0.6487.1 content-class: urn:content-classes:message MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Subject: RE: Submission #3 for S2io 10GbE driver Date: Mon, 1 Mar 2004 11:51:40 +0530 Message-ID: <4223A04BF7D1B941A25246ADD0462FF50115AD10@blr-m3-msg.wipro.com> X-MS-Has-Attach: X-MS-TNEF-Correlator: Thread-Topic: Submission #3 for S2io 10GbE driver Thread-Index: AcP+OJoiC17+ieJTSVmICXn6FsK2lQBHAAIw From: To: , Cc: , , , , X-OriginalArrivalTime: 01 Mar 2004 06:21:40.0703 (UTC) FILETIME=[759CF6F0:01C3FF55] Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from quoted-printable to 8bit by oss.sgi.com id i218K2KO023263 X-archive-position: 3678 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: raghavendra.koushik@wipro.com Precedence: bulk X-list: netdev Jeff, Regarding Point # 37 >>37) kill all of this: >> >>+/* OS related system calls */ >>+ >>+#ifndef readq >>+static inline u64 read64(void *addr) >>+{ >>+ u64 ret = 0; >>+ ret = readl(addr + 4); >>+ (u64) ret <<= 32; >>+ (u64) ret |= readl(addr); [....] I agree that read/write(32,16,8) are not used so can be eliminated, but the read/write64 macros are essential because not all platforms have defined the readq and writeq system calls. i386 for example doesn't have readq/writeq and to write into the 64 bit registers of the NIC, I use 2 successive 32 bits (readl/writel) operation to achieve the 64 bit equivalent. This procedure does work on all the platforms that we have tested on. Regards Koushik -----Original Message----- From: Jeff Garzik [mailto:jgarzik@pobox.com] Sent: Sunday, February 29, 2004 1:52 AM To: Leonid Grossman Cc: netdev@oss.sgi.com; 'Stephen Hemminger'; 'Christoph Hellwig'; 'ravinandan arakali'; raghavendra.koushik@s2io.com Subject: Re: Submission #3 for S2io 10GbE driver Looking a lot better. A few merge issues remain, and some operational ones as well. There are 39 issues in this review, but IMO they are mostly minor issues that don't require much thought or work. Comments: 0) to repeat myself from an earlier review... grumble... You CANNOT use NETIF_F_HW_CSUM, when your hardware does not provide the checksum value. You must use NETIF_F_IP_CSUM. Your use of NETIF_F_HW_CSUM + CHECKSUM_UNNECESSARY is flat out incorrect. 1) the makefile is for out-of-tree stuff. The proper makefile will be much smaller. So just submit a proper in-tree Makefile. 2) (in general) we don't want the compatibility stuff in-tree, that's for out-of-tree as well. 3) just submit a patch to include/linux/pci_ids.h instead of the following +/* VENDOR and DEVICE ID of XENA. */ +#ifndef PCI_VENDOR_ID_S2IO +#define PCI_VENDOR_ID_S2IO 0x17D5 +#define PCI_DEVICE_ID_S2IO_WIN 0x5731 +#define PCI_DEVICE_ID_S2IO_UNI 0x5831 +#endif 4) just delete the SET_NETDEV_DEV(), FREE_NETDEV, and IRQ_NONE compatibility defines. these are in 2.4 just like 2.6. 5) Many PCI posting bugs remain. FixMacAddress is an excellent illustration: + write64(&bar0->gpio_control, 0x0040600000000000ULL); + udelay(10); + write64(&bar0->gpio_control, 0x0000600000000000ULL); + udelay(10); + write64(&bar0->gpio_control, 0x0020600000000000ULL); + udelay(10); + write64(&bar0->gpio_control, 0x0060600000000000ULL); + udelay(10); The delay is _not_ guaranteed at all, because you do not know when that write64() will actually be sent to the PCI bus. Only a read[bwl,64] is guaranteed to flush the write to the PCI device. So, the above code does not function as you would expect, on all platforms. 6) More examples of PCI posting bugs, in startNic: + write64(&bar0->mc_rldram_mrs, val64); + set_current_state(TASK_UNINTERRUPTIBLE); + schedule_timeout(HZ / 10); and + write64(&bar0->dtx_control, 0x8007051500000000ULL); + udelay(50); + write64(&bar0->dtx_control, 0x80070515000000E0ULL); + udelay(50); + write64(&bar0->dtx_control, 0x80070515001F00E4ULL); + udelay(50); 7) for fragmented skb's, you should be using pci_map_page() not pci_map_single(). Example in drivers/net/tg3.c. 8) (style) in alarmIntrHandler, due to line wrapping, Lindent has rendered the 'do' loop rather unreadable. 9) you cannot sleep inside the interrupt handler. Therefore the schedule_timeout() in alarmIntrHandler is very wrong. 10) never use a plain constant when calling schedule_timeout(), such as in waitForCmdComplete. Always calculate the desired delay based on the HZ constant. Otherwise, your delay varies depending on platform. HZ represents one second, in jiffies. So half a second delay would be "HZ / 2", etc. Also, when fixing, be careful that your HZ-based calculation will never evaluate to zero. 11) ditto s2io_reset 12) ditto s2io_close. etc. 13) in s2io_xmit, kfree the skb (drop it) if you don't have enough free space to queue it. this is normally a BUG condition, since proper use of netif_{start,stop,wake}_queue() will guarantee that s2io_xmit will only be called when there is free space to queue another skb. 14) spin_lock(), not spin_lock_irqsave(), in your interrupt handler. spin_lock_irqsave() is normally used in any of three cases: (1) don't know whether you're in an ISR or not, (2) definitely not in an ISR, or (3) your ISR is called from more than one hardware interrupt. None of these three is the case. 15) does s2io_get_stats need locking? 16) (style) If you are going to comment each function, you might as well do it in the "kernel-doc" style, which allows the comments to be picked up by automated tools. The format is /** * function_name - short description * @argument1: argument 1 description * @argument2: argument 2 description * ... * SOMETHING: * blah blah blah * SOMETHING ELSE: * blah blah blah The "ALL_CAPS:" indicates a new section/paragraph, in the document. Once this is done, you may add a stub document to Documentation/DocBook/ and then create your driver's nicely-formatted documentation using "make pdfdocs", "make psdocs", or "make htmldocs". 17) this define belongs in include/linux/ethtool.h, if it's not there already... +#define SPEED_10000 10000 18) remove #ifdefs such as +#if defined(ETHTOOL_GREGS) + info->regdump_len = XENA_REG_SPACE; +#endif since this exists in both 2.4 and 2.6 kernels. 19) ditto: +#ifdef ETHTOOL_PHYS_ID 20) for the ethtool EEPROM and register dumps, it would be nice to submit a patch to me for ethtool (http://sf.net/projects/gkernel/), which generates a verbose dump rather than a bunch of hex numbers incomprehensible to the user. This is a long, boring, but easy task suitable to an intern, so I understand if it's not done immediately ;-) 21) s2io_ethtool_nway_reset should restart PHY autonegotiation, not reset the entire card 22) eliminate s2io_ethtool_get_link, it duplicates a generic (and equivalent) function in net/core/ethtool.c 23) ditto, for the s2io_ethtool_{get,set}_{sg,rx,tx}_csum stuff 24) don't explicitly set members to NULL in netdev_ethtool_ops 25) the update to s2io_tx_watchdog still leaves something to be desired. You are no longer performing the could-take-a-long-time card reset inside of spin_lock_bh()... you are now doing it inside the timer interrupt :( Move this to process context by using schedule_work() [2.6] or schedule_task [2.4] 27) Unconditional netif_wake_queue() in s2io_link() still unfixed. You must check for room for additional TX, before calling netif_{start,wake}_queue(). Consider what happens if the link goes down under the TX-full condition [netif_stop_queue]... instant bug. 28) do NOT specify PCI latency timer value as non-zero. pci_set_master() chooses an appropriate latency timer value. It is acceptable to leave this in as an option, as long as the module option's default is zero: +static u8 latency_timer = 0xff; 29) (style) don't bother casting a void pointer: +/* Private member variable initialized to s2io NIC structure */ + sp = (nic_t *) dev->priv; 30) redundant assignment of 'sp': + dev->irq = pdev->irq; + dev->base_addr = (unsigned long) sp->bar0; + sp = (nic_t *) dev->priv; 31) kill the #ifdef +#ifdef SET_ETHTOOL_OPS + SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); +#endif This one is particularly silly, because SET_ETHTOOL_OPS() is -designed- to eliminate ifdefs. A driver wishing to be compatible will provide its own SET_ETHTOOL_OPS definition, guaranteeing it can be used unconditionally in the driver code here. 32) mark s2io_starter with "__init" 33) kill this: +#ifndef ETH_ALEN +#define ETH_ALEN 6 +#endif 34) the definitions of SUCCESS and FAILURE are incorrect. The driver should return 0 on success, and a negative errno-based error code on failure. -EBUSY, -EOPNOTSUPP, etc. 35) kill this: +#ifndef SUPPORTED_10000baseT_Full +#define SUPPORTED_10000baseT_Full (1 << 12) +#endif 36) (feature addition) you have a ton of NIC-specific statistics. You should make those available to users, via ethtool. 37) kill all of this: +/* OS related system calls */ + +#ifndef readq +static inline u64 read64(void *addr) +{ + u64 ret = 0; + ret = readl(addr + 4); + (u64) ret <<= 32; + (u64) ret |= readl(addr); + + return ret; +} +#else +static inline u64 read64(void *addr) +{ + u64 ret = readq(addr); + return ret; +} +#endif +#define read32(addr, ret) ret = readl(addr); +#define read16(addr, ret) ret = readw(addr); +#define read8(addr, ret) ret = readb(addr); + +#ifndef writeq +static inline void write64(void *addr, u64 val) +{ + writel((u32) (val), addr); + writel((u32) (val >> 32), (addr + 4)); +} +#else +#define write64(addr, ret) writeq(ret,(void *)addr) +#endif +#define write32(addr, ret) writel(ret,(void *)addr); +#define write16(addr, ret) writew(ret,(void *)addr); +#define write8(addr, ret) writeb(ret,(void *)addr); 38) sysctl_xframe.conf belongs somewhere in Documentation/* From davem@redhat.com Mon Mar 1 00:35:36 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 00:35:51 -0800 (PST) Received: from mx1.redhat.com (mx1.redhat.com [66.187.233.31]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i218ZZKO023862 for ; Mon, 1 Mar 2004 00:35:36 -0800 Received: from int-mx1.corp.redhat.com (int-mx1.corp.redhat.com [172.16.52.254]) by mx1.redhat.com (8.11.6/8.11.6) with ESMTP id i218ZRb14780; Mon, 1 Mar 2004 03:35:27 -0500 Received: from devserv.devel.redhat.com (devserv.devel.redhat.com [172.16.58.1]) by int-mx1.corp.redhat.com (8.11.6/8.11.6) with ESMTP id i218ZQ827288; Mon, 1 Mar 2004 03:35:26 -0500 Received: from cheetah.davemloft.net (localhost.localdomain [127.0.0.1]) by devserv.devel.redhat.com (8.12.10/8.12.10) with SMTP id i218ZLeF001017; Mon, 1 Mar 2004 03:35:21 -0500 Date: Mon, 1 Mar 2004 00:35:25 -0800 From: "David S. Miller" To: Bart De Schuymer Cc: ebtables-devel@lists.sourceforge.net, netdev@oss.sgi.com Subject: Re: [PATCH] 2.6.3 fix vlan-encapsulated fragmented IP traffic Message-Id: <20040301003525.522d6db2.davem@redhat.com> In-Reply-To: <200403010806.29759.bdschuym@pandora.be> References: <200402291914.53578.bdschuym@pandora.be> <20040229215421.0ca987e8.davem@redhat.com> <200403010806.29759.bdschuym@pandora.be> X-Mailer: Sylpheed version 0.9.7 (GTK+ 1.2.10; sparc-unknown-linux-gnu) X-Face: "_;p5u5aPsO,_Vsx"^v-pEq09'CU4&Dc1$fQExov$62l60cgCc%FnIwD=.UF^a>?5'9Kn[;433QFVV9M..2eN.@4ZWPGbdi<=?[:T>y?SD(R*-3It"Vj:)"dP Mime-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit X-archive-position: 3679 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: davem@redhat.com Precedence: bulk X-list: netdev On Mon, 1 Mar 2004 08:06:29 +0100 Bart De Schuymer wrote: > > I'm really concerned, btw, that this is going to propagate to other places > > as well, what if something that gets handled this way gets sent over an > > IPIP tunnel via some route, and then IPIP has to make all of these crazy > > adjustments too? That's going too far and we'll have to find a better > > way if that is the case. > > I'm not sure how IPIP tunnels are implemented, but I'm assuming they strip the > first IP header like the vlan code strips the vlan header when a vlan-packet > arrives on a vlan-enabled device. Then there should be no problem with this. Let us say that on input, br strips the 4 bytes as you say, iptables looks at the thing and rewrites the IP source/destination address or whatever, and this causes the packet to actually get forwarded out via a different IP route, and let us say that this new IP route causes the packet to go out via an IPIP tunnel device, which must do all the same kind of crap the code you're patching here does, that is determine the LL header size etc. in order to make sure there is enough headroom to slap on the new IP encapsulating header. If you can show that this kind of scenerio would never be generated in the cases where br-netfilter is involved, then fine. From maz@misterjones.org Mon Mar 1 02:12:20 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 02:12:33 -0800 (PST) Received: from young-lust.wild-wind.fr.eu.org (lopsy-lu.misterjones.org [62.4.18.26]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i21ACIKO028984 for ; Mon, 1 Mar 2004 02:12:19 -0800 Received: from hina.wild-wind.fr.eu.org ([192.168.70.139]) by young-lust.wild-wind.fr.eu.org with esmtp (Exim 3.35 #1 (Debian)) id 1AxkP8-0002RZ-00; Mon, 01 Mar 2004 11:12:06 +0100 Received: from maz by hina.wild-wind.fr.eu.org with local (Exim 3.36 #1 (Debian)) id 1AxkP8-0002qy-00; Mon, 01 Mar 2004 11:12:06 +0100 To: pawel.sokolowski@muflon.linux.pl Cc: netdev@oss.sgi.com Subject: Re: 2.6.4-rc1 + hp100 EISA, not working Organization: Metropolis -- Nowhere X-Attribution: maz Reply-to: mzyngier@freesurf.fr References: From: Marc Zyngier Date: Mon, 01 Mar 2004 11:12:06 +0100 Message-ID: In-Reply-To: (Pawe's message of "Sun, 29 Feb 2004 22:06:16 +0100 (CET)") Lines: 17 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-archive-position: 3680 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: mzyngier@freesurf.fr Precedence: bulk X-list: netdev >>>>> "Pawel" == Pawe writes: Pawel> I don't know if it's related to this problem but at earlier stage of Pawel> booting I'm getting following messages: Pawel> EISA: Probing bus 0 at eisa0 Pawel> EISA: Mainboard HWPC061 detected. Pawel> EISA: slot 2 : HWP1940 detected (disabled). Pawel> EISA: Detected 1 card. Try passing 'eisa_bus.enable_dev=2' to your kernel parameters. Your card is tagged as unconfigured by BIOS, and thus is skipped by the probing logic. See Documentation/eisa.txt for details. M. -- Places change, faces change. Life is so very strange. From maz@misterjones.org Mon Mar 1 02:25:38 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 02:26:01 -0800 (PST) Received: from young-lust.wild-wind.fr.eu.org (lopsy-lu.misterjones.org [62.4.18.26]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i21APaKO031009 for ; Mon, 1 Mar 2004 02:25:37 -0800 Received: from hina.wild-wind.fr.eu.org ([192.168.70.139]) by young-lust.wild-wind.fr.eu.org with esmtp (Exim 3.35 #1 (Debian)) id 1Axkc1-0002T1-00; Mon, 01 Mar 2004 11:25:25 +0100 Received: from maz by hina.wild-wind.fr.eu.org with local (Exim 3.36 #1 (Debian)) id 1Axkc1-0002rb-00; Mon, 01 Mar 2004 11:25:25 +0100 To: pawel.sokolowski@muflon.linux.pl Cc: netdev@oss.sgi.com, jgarzik@pobox.com Subject: Re: 2.6.4-rc1 + hp100 EISA, not working Organization: Metropolis -- Nowhere X-Attribution: maz Reply-to: mzyngier@freesurf.fr References: From: Marc Zyngier Date: Mon, 01 Mar 2004 11:25:25 +0100 Message-ID: In-Reply-To: (Pawe's message of "Sun, 29 Feb 2004 22:06:16 +0100 (CET)") Lines: 26 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-archive-position: 3681 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: mzyngier@freesurf.fr Precedence: bulk X-list: netdev >>>>> "Pawel" == Pawe writes: Pawel> On 2.6.3 it just Oopsed and didn't work. On 2.6.4-rc1 it does Pawel> not oops but it doesn't work (neither as module nor as build in kernel). Note that hp100 in 2.6.4-rc1 is still broken wrt EISA probing, since it lacks the terminating entry in the EISA ID list. This one-liner should take care of random crashes that are often reported to LKML : ===== drivers/net/hp100.c 1.24 vs edited ===== --- 1.24/drivers/net/hp100.c Wed Feb 18 13:39:41 2004 +++ edited/drivers/net/hp100.c Mon Mar 1 11:18:00 2004 @@ -201,6 +201,7 @@ { "HWP1990" }, /* HP J2577 */ { "CPX0301" }, /* ReadyLink ENET100-VG4 */ { "CPX0401" }, /* FreedomLine 100/VG */ + { "" } /* Mandatory final entry ! */ }; MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl); #endif Jeff, would you please push this to Linus ? M. -- Places change, faces change. Life is so very strange. From kashyapv@us.ibm.com Mon Mar 1 03:10:51 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 03:11:00 -0800 (PST) Received: from e33.co.us.ibm.com (e33.co.us.ibm.com [32.97.110.131]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i21BAiKO001251 for ; Mon, 1 Mar 2004 03:10:50 -0800 Received: from westrelay03.boulder.ibm.com (westrelay03.boulder.ibm.com [9.17.195.12]) by e33.co.us.ibm.com (8.12.10/8.12.2) with ESMTP id i21B9sSL792938; Mon, 1 Mar 2004 06:09:54 -0500 Received: from w-vkashyap95.des.sequent.com (d03av01.boulder.ibm.com [9.17.193.81]) by westrelay03.boulder.ibm.com (8.12.10/NCO/VER6.6) with ESMTP id i21B9bJc186488; Mon, 1 Mar 2004 04:09:50 -0700 Date: Mon, 1 Mar 2004 02:11:11 -0800 (Pacific Standard Time) From: Vivek Kashyap To: "David S. Miller" cc: Ronghua Zhang , , Subject: Re: [PATCH] proportional share accept() In-Reply-To: <20040229220513.68eed11f.davem@redhat.com> Message-ID: X-X-Sender: kashyapv@imap.linux.ibm.com MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII X-archive-position: 3682 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: kashyapv@us.ibm.com Precedence: bulk X-list: netdev On Sun, 29 Feb 2004, David S. Miller wrote: > On Thu, 26 Feb 2004 17:08:23 -0500 (EST) > Ronghua Zhang wrote: > > > www.cs.virginia.edu/~rz5b/research/kernel-qos.htm > > I looked at this, it's basically netfilter TCP port rewriting > which knows about per-socket quotas and limits. > > You could write this as a 10 line netfilter module, with zero > modifications to any of the core net/ipv4 TCP code at all. > And that's how I'd like to see something like this done. Multiple sockets can be forwarded the requests either at an alternative port or address using netfilter. However one has to now mangle the data packets too since the client is still talking to the advertised port (and address). I've modified the earlier post to remove the sysctl and removed the use of STFQ/virtual clock and instead used 'weighted round robin' in tcp_accept(). The solution is very much per socket. The default is to have only one queue that is active. If the shares (simple ratios) are set then the packets are accept()ed in a WRR fashion. Since all work is done in context of a single socket no additional locks have to be held. If the shares are unset then the processing reverts to single queue mode. The per queue backlog is to avoid lower priority requests from filling up the synq and thereby blocking the higher priority requests. Also the iptables' MARK target is quite lightweight. Vivek ----------------------------------------------------------------------------- diff -urN linux-2.6.3_old/include/linux/tcp.h linux-2.6.3/include/linux/tcp.h --- linux-2.6.3_old/include/linux/tcp.h 2004-02-17 19:57:52.000000000 -0800 +++ linux-2.6.3/include/linux/tcp.h 2004-02-29 22:01:11.000000000 -0800 @@ -128,6 +128,10 @@ #define TCP_INFO 11 /* Information about this connection. */ #define TCP_QUICKACK 12 /* Block/reenable quick acks */ +#ifdef CONFIG_ACCEPT_QUEUES +#define TCP_ACCEPTQ_SHARE 13 /* Set accept queue share */ +#endif + #define TCPI_OPT_TIMESTAMPS 1 #define TCPI_OPT_SACK 2 #define TCPI_OPT_WSCALE 4 @@ -185,6 +189,18 @@ __u32 tcpi_reordering; }; +#ifdef CONFIG_ACCEPT_QUEUES + +#define NUM_ACCEPT_QUEUES 8 /* Must be power of 2 */ + +struct tcp_acceptq_info { + unsigned char acceptq_shares; + unsigned long acceptq_wait_time; + unsigned int acceptq_qcount; + unsigned int acceptq_count; +}; +#endif + #ifdef __KERNEL__ #include @@ -362,8 +378,9 @@ /* FIFO of established children */ struct open_request *accept_queue; - struct open_request *accept_queue_tail; - +#ifndef CONFIG_ACCEPT_QUEUES + struct open_request *accept_queue_tail; +#endif int write_pending; /* A write to socket waits to start. */ unsigned int keepalive_time; /* time before keep alive takes place */ @@ -388,6 +405,22 @@ __u32 rtt; __u32 rtt_min; /* minimum observed RTT */ } westwood; + +#ifdef CONFIG_ACCEPT_QUEUES + /* move to listen opt... */ + char class_index; + struct { + struct open_request *aq_head; + struct open_request *aq_tail; + unsigned int aq_cnt; + unsigned int aq_ratio; + unsigned int aq_count; + unsigned int aq_qcount; + unsigned int aq_backlog; + unsigned int aq_wait_time; + int aq_valid; + } acceptq[NUM_ACCEPT_QUEUES]; +#endif }; /* WARNING: don't change the layout of the members in tcp_sock! */ diff -urN linux-2.6.3_old/include/net/tcp.h linux-2.6.3/include/net/tcp.h --- linux-2.6.3_old/include/net/tcp.h 2004-02-17 19:57:16.000000000 -0800 +++ linux-2.6.3/include/net/tcp.h 2004-02-29 21:32:44.000000000 -0800 @@ -639,6 +639,10 @@ struct tcp_v6_open_req v6_req; #endif } af; +#ifdef CONFIG_ACCEPT_QUEUES + unsigned long acceptq_time_stamp; + int acceptq_class; +#endif }; /* SLAB cache for open requests. */ @@ -1688,6 +1692,69 @@ return tcp_win_from_space(sk->sk_rcvbuf); } +#ifdef CONFIG_ACCEPT_QUEUES +static inline void tcp_acceptq_removed(struct sock *sk, int class) +{ + tcp_sk(sk)->acceptq[class].aq_backlog--; +} + +static inline void tcp_acceptq_added(struct sock *sk, int class) +{ + tcp_sk(sk)->acceptq[class].aq_backlog++; +} + +static inline int tcp_acceptq_is_full(struct sock *sk, int class) +{ + return tcp_sk(sk)->acceptq[class].aq_backlog > + sk->sk_max_ack_backlog; +} + +static inline void tcp_set_acceptq(struct tcp_opt *tp, struct open_request *req) +{ + int class = req->acceptq_class; + int prev_class; + + if (!tp->acceptq[class].aq_ratio) { + req->acceptq_class = 0; + class = 0; + } + + tp->acceptq[class].aq_qcount++; + req->acceptq_time_stamp = jiffies; + + if (tp->acceptq[class].aq_tail) { + req->dl_next = tp->acceptq[class].aq_tail->dl_next; + tp->acceptq[class].aq_tail->dl_next = req; + tp->acceptq[class].aq_tail = req; + } else { /* if first request in the class */ + tp->acceptq[class].aq_head = req; + tp->acceptq[class].aq_tail = req; + + prev_class = class - 1; + while (prev_class >= 0) { + if (tp->acceptq[prev_class].aq_tail) + break; + prev_class--; + } + if (prev_class < 0) { + req->dl_next = tp->accept_queue; + tp->accept_queue = req; + } + else { + req->dl_next = tp->acceptq[prev_class].aq_tail->dl_next; + tp->acceptq[prev_class].aq_tail->dl_next = req; + } + } +} +static inline void tcp_acceptq_queue(struct sock *sk, struct open_request *req, + struct sock *child) +{ + tcp_set_acceptq(tcp_sk(sk),req); + req->sk = child; + tcp_acceptq_added(sk,req->acceptq_class); +} + +#else static inline void tcp_acceptq_removed(struct sock *sk) { sk->sk_ack_backlog--; @@ -1720,16 +1787,55 @@ req->dl_next = NULL; } +#endif + struct tcp_listen_opt { u8 max_qlen_log; /* log_2 of maximal queued SYNs */ int qlen; +#ifdef CONFIG_ACCEPT_QUEUES + int qlen_young[NUM_ACCEPT_QUEUES]; +#else int qlen_young; +#endif int clock_hand; u32 hash_rnd; struct open_request *syn_table[TCP_SYNQ_HSIZE]; }; +#ifdef CONFIG_ACCEPT_QUEUES +static inline void +tcp_synq_removed(struct sock *sk, struct open_request *req) +{ + struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt; + + if (--lopt->qlen == 0) + tcp_delete_keepalive_timer(sk); + if (req->retrans == 0) + lopt->qlen_young[req->acceptq_class]--; +} + +static inline void tcp_synq_added(struct sock *sk, struct open_request *req) +{ + struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt; + + if (lopt->qlen++ == 0) + tcp_reset_keepalive_timer(sk, TCP_TIMEOUT_INIT); + lopt->qlen_young[req->acceptq_class]++; +} + +static inline int tcp_synq_len(struct sock *sk) +{ + return tcp_sk(sk)->listen_opt->qlen; +} + +static inline int tcp_synq_young(struct sock *sk, int class) +{ + return tcp_sk(sk)->listen_opt->qlen_young[class]; +} + +#else + static inline void tcp_synq_removed(struct sock *sk, struct open_request *req) { @@ -1759,6 +1865,7 @@ { return tcp_sk(sk)->listen_opt->qlen_young; } +#endif static inline int tcp_synq_is_full(struct sock *sk) { diff -urN linux-2.6.3_old/net/ipv4/Kconfig linux-2.6.3/net/ipv4/Kconfig --- linux-2.6.3_old/net/ipv4/Kconfig 2004-02-17 19:59:05.000000000 -0800 +++ linux-2.6.3/net/ipv4/Kconfig 2004-02-29 13:41:58.000000000 -0800 @@ -379,5 +379,28 @@ If unsure, say Y. +config ACCEPT_QUEUES + bool "IP: TCP Multiple accept queues support" + depends on INET && NETFILTER + ---help--- + Support multiple accept queues per listening socket. If you say Y + here, multiple accept queues will be configured per listening + socket. + + Each queue is mapped to a priority class. Incoming connection + requests can be classified (see iptables(8), MARK target), depending + on the packet's src/dest address or other parameters, into one of + the priority classes. The requests are then queued to the relevant + accept queue. + + Each of the queues can be assigned a weight. The accept()ance + of packets is then scheduled in accordance with the weight + assigned to the priority class. + + Be sure to enable "Network packet filtering" if you wish + to use this feature. + + If unsure, say N. + source "net/ipv4/ipvs/Kconfig" diff -urN linux-2.6.3_old/net/ipv4/tcp.c linux-2.6.3/net/ipv4/tcp.c --- linux-2.6.3_old/net/ipv4/tcp.c 2004-02-17 19:57:21.000000000 -0800 +++ linux-2.6.3/net/ipv4/tcp.c 2004-03-01 00:47:47.000000000 -0800 @@ -534,13 +534,34 @@ int tcp_listen_start(struct sock *sk) { +#ifdef CONFIG_ACCEPT_QUEUES + int i = 0; +#endif struct inet_opt *inet = inet_sk(sk); struct tcp_opt *tp = tcp_sk(sk); struct tcp_listen_opt *lopt; sk->sk_max_ack_backlog = 0; sk->sk_ack_backlog = 0; - tp->accept_queue = tp->accept_queue_tail = NULL; + tp->accept_queue = NULL; +#ifdef CONFIG_ACCEPT_QUEUES + tp->class_index = 0; + for (i=0; i < NUM_ACCEPT_QUEUES; i++) { + tp->acceptq[i].aq_tail = NULL; + tp->acceptq[i].aq_head = NULL; + tp->acceptq[i].aq_wait_time = 0; + tp->acceptq[i].aq_qcount = 0; + tp->acceptq[i].aq_count = 0; + if (i == 0) { + tp->acceptq[i].aq_valid = 1; + tp->acceptq[i].aq_ratio = 1; + } + else { + tp->acceptq[i].aq_valid = 0; + tp->acceptq[i].aq_ratio = 0; + } + } +#endif tp->syn_wait_lock = RW_LOCK_UNLOCKED; tcp_delack_init(tp); @@ -600,7 +621,13 @@ write_lock_bh(&tp->syn_wait_lock); tp->listen_opt = NULL; write_unlock_bh(&tp->syn_wait_lock); - tp->accept_queue = tp->accept_queue_tail = NULL; +#ifdef CONFIG_ACCEPT_QUEUES + for (i = 0; i < NUM_ACCEPT_QUEUES; i++) + tp->acceptq[i].aq_head = tp->acceptq[i].aq_tail = NULL; +#else + tp->accept_queue_tail = NULL; +#endif + tp->accept_queue = NULL; if (lopt->qlen) { for (i = 0; i < TCP_SYNQ_HSIZE; i++) { @@ -646,7 +673,11 @@ local_bh_enable(); sock_put(child); +#ifdef CONFIG_ACCEPT_QUEUES + tcp_acceptq_removed(sk, req->acceptq_class); +#else tcp_acceptq_removed(sk); +#endif tcp_openreq_fastfree(req); } BUG_TRAP(!sk->sk_ack_backlog); @@ -2230,6 +2261,10 @@ struct open_request *req; struct sock *newsk; int error; +#ifdef CONFIG_ACCEPT_QUEUES + int prev_class = 0; + int first; +#endif lock_sock(sk); @@ -2243,7 +2278,6 @@ /* Find already established connection */ if (!tp->accept_queue) { long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); - /* If this is a non blocking socket don't sleep */ error = -EAGAIN; if (!timeo) @@ -2254,12 +2288,46 @@ goto out; } +#ifndef CONFIG_ACCEPT_QUEUES req = tp->accept_queue; if ((tp->accept_queue = req->dl_next) == NULL) tp->accept_queue_tail = NULL; - newsk = req->sk; tcp_acceptq_removed(sk); +#else + first = tp->class_index; + /* We should always have request queued here. The accept_queue + * is already checked for NULL above. + */ + while(!tp->acceptq[first].aq_head) { + tp->acceptq[first].aq_cnt = 0; + first = ++first & ~NUM_ACCEPT_QUEUES; + } + req = tp->acceptq[first].aq_head; + tp->acceptq[first].aq_qcount--; + tp->acceptq[first].aq_count++; + tp->acceptq[first].aq_wait_time+=(jiffies - req->acceptq_time_stamp); + + for (prev_class= first-1 ; prev_class >=0; prev_class--) + if (tp->acceptq[prev_class].aq_tail) + break; + if (prev_class>=0) + tp->acceptq[prev_class].aq_tail->dl_next = req->dl_next; + else + tp->accept_queue = req->dl_next; + + if (req == tp->acceptq[first].aq_tail) + tp->acceptq[first].aq_head = tp->acceptq[first].aq_tail = NULL; + else + tp->acceptq[first].aq_head = req->dl_next; + + if((++(tp->acceptq[first].aq_cnt)) >= tp->acceptq[first].aq_ratio){ + tp->acceptq[first].aq_cnt = 0; + tp->class_index = ++first & ~NUM_ACCEPT_QUEUES; + } + tcp_acceptq_removed(sk, req->acceptq_class); +#endif + newsk = req->sk; tcp_openreq_fastfree(req); BUG_TRAP(newsk->sk_state != TCP_SYN_RECV); release_sock(sk); @@ -2429,6 +2497,49 @@ } } break; + +#ifdef CONFIG_ACCEPT_QUEUES + case TCP_ACCEPTQ_SHARE: + { + char share_wt[NUM_ACCEPT_QUEUES]; + int i,j; + + if (sk->sk_state != TCP_LISTEN) + return -EOPNOTSUPP; + + if (copy_from_user(share_wt,optval, optlen)) { + err = -EFAULT; + break; + } + j = 0; + for (i = 0; i < NUM_ACCEPT_QUEUES; i++) { + if (share_wt[i]) { + if (!j) + j = share_wt[i]; + else if (share_wt[i] < j) { + j = share_wt[i]; + } + tp->acceptq[i].aq_valid = 1; + } + else + tp->acceptq[i].aq_valid = 0; + + } + if (j == 0) { + /* Class 0 is always valid. If nothing is + * specified set class 0 as 1. + */ + share_wt[0] = 1; + tp->acceptq[0].aq_valid = 1; + j = 1; + } + for (i=0; i < NUM_ACCEPT_QUEUES; i++) { + tp->acceptq[i].aq_ratio = share_wt[i]/j; + tp->acceptq[i].aq_cnt = 0; + } + } + break; +#endif default: err = -ENOPROTOOPT; @@ -2555,6 +2666,41 @@ case TCP_QUICKACK: val = !tp->ack.pingpong; break; + +#ifdef CONFIG_ACCEPT_QUEUES + case TCP_ACCEPTQ_SHARE: { + struct tcp_acceptq_info tinfo[NUM_ACCEPT_QUEUES]; + int i; + + if (sk->sk_state != TCP_LISTEN) + return -EOPNOTSUPP; + + if (get_user(len, optlen)) + return -EFAULT; + + memset(tinfo, 0, sizeof(tinfo)); + + for(i=0; i < NUM_ACCEPT_QUEUES; i++) { + tinfo[i].acceptq_wait_time = + tp->acceptq[i].aq_wait_time/(HZ/USER_HZ); + tinfo[i].acceptq_qcount = tp->acceptq[i].aq_qcount; + tinfo[i].acceptq_count = tp->acceptq[i].aq_count; + if (tp->acceptq[i].aq_valid) + tinfo[i].acceptq_shares=tp->acceptq[i].aq_ratio; + else + tinfo[i].acceptq_shares = 0; + } + + len = min_t(unsigned int, len, sizeof(tinfo)); + if (put_user(len, optlen)) + return -EFAULT; + + if (copy_to_user(optval, (char *)tinfo, len)) + return -EFAULT; + + return 0; + } +#endif default: return -ENOPROTOOPT; }; diff -urN linux-2.6.3_old/net/ipv4/tcp_ipv4.c linux-2.6.3/net/ipv4/tcp_ipv4.c --- linux-2.6.3_old/net/ipv4/tcp_ipv4.c 2004-02-17 19:57:22.000000000 -0800 +++ linux-2.6.3/net/ipv4/tcp_ipv4.c 2004-02-29 23:59:09.000000000 -0800 @@ -916,7 +916,11 @@ lopt->syn_table[h] = req; write_unlock(&tp->syn_wait_lock); +#ifdef CONFIG_ACCEPT_QUEUES + tcp_synq_added(sk, req); +#else tcp_synq_added(sk); +#endif } @@ -1413,6 +1417,9 @@ __u32 daddr = skb->nh.iph->daddr; __u32 isn = TCP_SKB_CB(skb)->when; struct dst_entry *dst = NULL; +#ifdef CONFIG_ACCEPT_QUEUES + int class = 0; +#endif #ifdef CONFIG_SYN_COOKIES int want_cookie = 0; #else @@ -1437,12 +1444,32 @@ goto drop; } +#ifdef CONFIG_ACCEPT_QUEUES + class = (skb->nfmark <= 0) ? 0 : + ((skb->nfmark > NUM_ACCEPT_QUEUES) ? NUM_ACCEPT_QUEUES: + skb->nfmark); + /* + * Accept only if the class has shares set or if the default class + * i.e. class 0 has shares + */ + if (!(tcp_sk(sk)->acceptq[class].aq_valid)) { + if (tcp_sk(sk)->acceptq[0].aq_valid) + class = 0; + else + goto drop; + } +#endif + /* Accept backlog is full. If we have already queued enough * of warm entries in syn queue, drop request. It is better than * clogging syn queue with openreqs with exponentially increasing * timeout. */ +#ifdef CONFIG_ACCEPT_QUEUES + if (tcp_acceptq_is_full(sk, class) && tcp_synq_young(sk, class) > 1) +#else if (tcp_acceptq_is_full(sk) && tcp_synq_young(sk) > 1) +#endif goto drop; req = tcp_openreq_alloc(); @@ -1472,7 +1499,10 @@ tp.tstamp_ok = tp.saw_tstamp; tcp_openreq_init(req, &tp, skb); - +#ifdef CONFIG_ACCEPT_QUEUES + req->acceptq_class = class; + req->acceptq_time_stamp = jiffies; +#endif req->af.v4_req.loc_addr = daddr; req->af.v4_req.rmt_addr = saddr; req->af.v4_req.opt = tcp_v4_save_options(sk, skb); @@ -1567,7 +1597,11 @@ struct tcp_opt *newtp; struct sock *newsk; +#ifdef CONFIG_ACCEPT_QUEUES + if (tcp_acceptq_is_full(sk, req->acceptq_class)) +#else if (tcp_acceptq_is_full(sk)) +#endif goto exit_overflow; if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL) diff -urN linux-2.6.3_old/net/ipv4/tcp_minisocks.c linux-2.6.3/net/ipv4/tcp_minisocks.c --- linux-2.6.3_old/net/ipv4/tcp_minisocks.c 2004-02-17 19:58:56.000000000 -0800 +++ linux-2.6.3/net/ipv4/tcp_minisocks.c 2004-02-29 21:49:34.000000000 -0800 @@ -779,7 +779,14 @@ newtp->num_sacks = 0; newtp->urg_data = 0; newtp->listen_opt = NULL; +#ifdef CONFIG_ACCEPT_QUEUES + newtp->accept_queue = NULL; + memset(newtp->acceptq, 0,sizeof(newtp->acceptq)); + newtp->class_index = 0; + +#else newtp->accept_queue = newtp->accept_queue_tail = NULL; +#endif /* Deinitialize syn_wait_lock to trap illegal accesses. */ memset(&newtp->syn_wait_lock, 0, sizeof(newtp->syn_wait_lock)); diff -urN linux-2.6.3_old/net/ipv4/tcp_timer.c linux-2.6.3/net/ipv4/tcp_timer.c --- linux-2.6.3_old/net/ipv4/tcp_timer.c 2004-02-17 19:59:28.000000000 -0800 +++ linux-2.6.3/net/ipv4/tcp_timer.c 2004-02-27 17:38:55.000000000 -0800 @@ -498,7 +498,16 @@ * ones are about to clog our table. */ if (lopt->qlen>>(lopt->max_qlen_log-1)) { +#ifdef CONFIG_ACCEPT_QUEUES + int young = 0; + + for(i=0; i < NUM_ACCEPT_QUEUES; i++) + young += lopt->qlen_young[i]; + + young <<= 1; +#else int young = (lopt->qlen_young<<1); +#endif while (thresh > 2) { if (lopt->qlen < young) @@ -524,9 +533,12 @@ unsigned long timeo; if (req->retrans++ == 0) - lopt->qlen_young--; - timeo = min((TCP_TIMEOUT_INIT << req->retrans), - TCP_RTO_MAX); +#ifdef CONFIG_ACCEPT_QUEUES + lopt->qlen_young[req->acceptq_class]--; +#else + lopt->qlen_young--; +#endif + timeo = min((TCP_TIMEOUT_INIT << req->retrans), TCP_RTO_MAX); req->expires = now + timeo; reqp = &req->dl_next; continue; @@ -538,7 +550,11 @@ write_unlock(&tp->syn_wait_lock); lopt->qlen--; if (req->retrans == 0) - lopt->qlen_young--; +#ifdef CONFIG_ACCEPT_QUEUES + lopt->qlen_young[req->acceptq_class]--; +#else + lopt->qlen_young--; +#endif tcp_openreq_free(req); continue; } From raghavendra.koushik@wipro.com Mon Mar 1 05:05:43 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 05:06:09 -0800 (PST) Received: from wiproecmx2.wipro.com (wiproecmx2.wipro.com [164.164.31.6]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i21D5aKO007752 for ; Mon, 1 Mar 2004 05:05:40 -0800 Received: from ec-vwall-wd (ec-vwall-wd.wipro.com [10.200.52.125]) by wiproecmx2.wipro.com (8.12.9-20031013/8.12.9) with SMTP id i21D5SlU019929 for ; Mon, 1 Mar 2004 18:35:29 +0530 (IST) Received: from blr-ec-bh3.wipro.com ([10.200.50.93]) by ec-vwall-wd with InterScan Messaging Security Suite; Mon, 01 Mar 2004 18:36:43 +0530 Received: from blr-m3-msg.wipro.com ([10.114.50.99]) by blr-ec-bh3.wipro.com with Microsoft SMTPSVC(5.0.2195.6713); Mon, 1 Mar 2004 18:35:27 +0530 X-MimeOLE: Produced By Microsoft Exchange V6.0.6487.1 content-class: urn:content-classes:message MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Subject: RE: Submission #3 for S2io 10GbE driver Date: Mon, 1 Mar 2004 18:35:27 +0530 Message-ID: <4223A04BF7D1B941A25246ADD0462FF50115ADF9@blr-m3-msg.wipro.com> X-MS-Has-Attach: X-MS-TNEF-Correlator: Thread-Topic: Submission #3 for S2io 10GbE driver Thread-Index: AcP/Wff/fbVBm5XxRUWIKOkRQoO4BgAM6D6A From: To: , , Cc: X-OriginalArrivalTime: 01 Mar 2004 13:05:27.0554 (UTC) FILETIME=[DDF10E20:01C3FF8D] Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from quoted-printable to 8bit by oss.sgi.com id i21D5aKO007752 X-archive-position: 3683 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: raghavendra.koushik@wipro.com Precedence: bulk X-list: netdev Hi Leonid, This automated signature will be gone from tomorrow. Our IMG guys are working on it and hopefully by then all mails going out from the s2io guys will not have this "Confidentiality Notice" :-). I have a few more questions to Jeff but I'am holding on to them till this is addressed. Just wanted to keep you posted on this issue. Regards Koushik -----Original Message----- From: Jeff Garzik [mailto:jgarzik@pobox.com] Sent: Monday, March 01, 2004 12:24 PM To: Raghavendra Koushik (WT01 - EMBEDDED & PRODUCT ENGINEERING SOLUTIONS) Cc: leonid.grossman@s2io.com; netdev@oss.sgi.com; shemminger@osdl.org; hch@infradead.org; ravinandan.arakali@s2io.com; raghavendra.koushik@s2io.com Subject: Re: Submission #3 for S2io 10GbE driver raghavendra.koushik@wipro.com wrote: > Jeff, > Regarding Point # 37 > > >>>37) kill all of this: >>> >>>+/* OS related system calls */ >>>+ >>>+#ifndef readq >>>+static inline u64 read64(void *addr) >>>+{ >>>+ u64 ret = 0; >>>+ ret = readl(addr + 4); >>>+ (u64) ret <<= 32; >>>+ (u64) ret |= readl(addr); > > [....] > > I agree that read/write(32,16,8) are not used so can be eliminated, > but the read/write64 macros are essential because not all platforms > have defined the readq and writeq system calls. i386 for example > doesn't have readq/writeq and to write into the 64 bit registers of > the NIC, I use 2 successive 32 bits (readl/writel) operation to > achieve the 64 bit equivalent. This procedure does work on all the > platforms that we have tested on. The code should use the kernel API -- readq/writeq -- not define its own API. With regards to the missing readq/writeq on some architectures... Short term, if some arches do not provide readq/writeq, provide your own definition (i.e. rename your write64 to a conditionally-defined writeq). Long term, all Linux platforms need to provide readq/writeq, so we need to modify the architectures with the missing pieces. > Confidentiality Notice > > The information contained in this electronic message and any > attachments to this message are intended for the exclusive use of the > addressee(s) and may contain confidential or privileged information. > If you are not the intended recipient, please notify the sender at > Wipro or Mailadmin@wipro.com immediately and destroy all copies of > this message and any attachments. Oh really? ;-) You should talk to your lawyers and sysadmins about sending email to open source people and lists... Regards, Jeff From leonid.grossman@s2io.com Mon Mar 1 07:27:09 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 07:27:16 -0800 (PST) Received: from ns1.s2io.com (ns1.s2io.com [216.209.86.101]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i21FR8KO012355 for ; Mon, 1 Mar 2004 07:27:08 -0800 Received: from guinness.s2io.com (gateway.s2io.com [216.209.86.98]) by ns1.s2io.com (8.12.10/8.12.10) with ESMTP id i21FQxjF013510; Mon, 1 Mar 2004 10:26:59 -0500 (EST) Received: from lgt40 ([10.16.16.116]) by guinness.s2io.com (8.12.6/8.12.6) with ESMTP id i21FQvKK028157; Mon, 1 Mar 2004 10:26:57 -0500 (EST) From: "Leonid Grossman" To: , , Cc: Subject: RE: Submission #3 for S2io 10GbE driver Date: Mon, 1 Mar 2004 07:24:25 -0800 Message-ID: <000001c3ffa1$48643490$7410100a@S2IOtech.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit X-Priority: 3 (Normal) X-MSMail-Priority: Normal X-Mailer: Microsoft Outlook, Build 10.0.2627 Importance: Normal In-Reply-To: <4223A04BF7D1B941A25246ADD0462FF50115ADF9@blr-m3-msg.wipro.com> X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2800.1165 X-Spam-Score: -101 X-Spam-Outlook-Score: () X-Spam-Features: IN_REP_TO,QUOTED_EMAIL_TEXT,USER_IN_WHITELIST X-Scanned-By: MIMEDefang 2.34 X-archive-position: 3684 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: leonid.grossman@s2io.com Precedence: bulk X-list: netdev > -----Original Message----- > From: raghavendra.koushik@wipro.com > [mailto:raghavendra.koushik@wipro.com] > Sent: Monday, March 01, 2004 5:05 AM > To: leonid.grossman@s2io.com; netdev@oss.sgi.com; > ravinandan.arakali@s2io.com > Cc: sriram.rapuru@wipro.com > Subject: RE: Submission #3 for S2io 10GbE driver > > > > Hi Leonid, > > > This automated signature will be gone from tomorrow. Our > IMG guys are working on it and hopefully by then all mails > going out from > > the s2io guys will not have this "Confidentiality Notice" > :-). I have a few more questions to Jeff but I'am holding on > to them till this is addressed. Just wanted to keep you > posted on this issue. Sounds good, thanks! There are cases when the notice is required by Wipro of course, but in general it's either a nuisance or plain illegal. Let me know if you need any help from my end to get it removed; alternative would be to use private (or s2io) addresses for Talking to open lists. Leonid > > Regards > Koushik > > > -----Original Message----- > From: Jeff Garzik [mailto:jgarzik@pobox.com] > > Sent: Monday, March 01, 2004 12:24 PM > To: Raghavendra Koushik (WT01 - EMBEDDED & PRODUCT > ENGINEERING SOLUTIONS) > Cc: leonid.grossman@s2io.com; netdev@oss.sgi.com; > shemminger@osdl.org; hch@infradead.org; > ravinandan.arakali@s2io.com; raghavendra.koushik@s2io.com > Subject: Re: Submission #3 for S2io 10GbE driver > > > raghavendra.koushik@wipro.com wrote: > > Jeff, > > Regarding Point # 37 > > > > > > > >>>37) kill all of this: > >>> > >>>+/* OS related system calls */ > >>>+ > >>>+#ifndef readq > >>>+static inline u64 read64(void *addr) > >>>+{ > >>>+ u64 ret = 0; > >>>+ ret = readl(addr + 4); > >>>+ (u64) ret <<= 32; > >>>+ (u64) ret |= readl(addr); > > > > > [....] > > > > > I agree that read/write(32,16,8) are not used so can be eliminated, > > > but the read/write64 macros are essential because not all platforms > > > have defined the readq and writeq system calls. i386 for example > > > doesn't have readq/writeq and to write into the 64 bit registers of > > > the NIC, I use 2 successive 32 bits (readl/writel) operation to > > > achieve the 64 bit equivalent. This procedure does work on all the > > > platforms that we have tested on. > > The code should use the kernel API -- readq/writeq -- not > define its own > > API. With regards to the missing readq/writeq on some > architectures... > > Short term, if some arches do not provide readq/writeq, > provide your own > > definition (i.e. rename your write64 to a > conditionally-defined writeq). > > Long term, all Linux platforms need to provide readq/writeq, > so we need > > to modify the architectures with the missing pieces. > > > > Confidentiality Notice > > > > > The information contained in this electronic message and any > > > attachments to this message are intended for the exclusive > use of the > > > addressee(s) and may contain confidential or privileged information. > > > If you are not the intended recipient, please notify the sender at > > > Wipro or Mailadmin@wipro.com immediately and destroy all copies of > > > this message and any attachments. > > Oh really? ;-) You should talk to your lawyers and sysadmins about > > sending email to open source people and lists... > > Regards, > > Jeff > > > > > Confidentiality Notice > > > The information contained in this electronic message and any > attachments to this message are intended for the exclusive > use of the addressee(s) and may contain confidential or > privileged information. If you are not the intended > recipient, please notify the sender at Wipro or > Mailadmin@wipro.com immediately and destroy all copies of > this message and any attachments. > From kevin.curtis@farsite.co.uk Mon Mar 1 08:06:20 2004 Received: with ECARTIS (v1.0.0; list netdev); Mon, 01 Mar 2004 08:06:27 -0800 (PST) Received: from relay5.ftech.net (relay5.ftech.net [195.200.0.100]) by oss.sgi.com (8.12.10/8.12.9) with SMTP id i21G6IKO013777 for ; Mon, 1 Mar 2004 08:06:19 -0800 Received: from opal.ftech.net ([212.32.16.127] helo=mailgate.ftech.net) by relay5.ftech.net with esmtp (Exim 3.36-ftechp12 #2) id 1Axntj-0006Yq-00; Mon, 01 Mar 2004 13:55:55 +0000 Received: from pc1.faradsl.ftech.co.uk ([212.32.46.162] helo=GENERAL.hq.farsitecommunications.com) by mailgate.ftech.net with esmtp (Exim 3.36-ftechp12 #1) id 1AxntY-00014J-00; Mon, 01 Mar 2004 13:55:44 +0000 Subject: RE: Update FarSync WAN driver in 2.6 Date: Mon, 1 Mar 2004 13:55:44 -0000 Message-ID: <7C078C66B7752B438B88E11E5E20E72E25CC1A@general.hq.farsitecommunications.com> X-MS-Has-Attach: yes MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="----_=_NextPart_001_01C3FF94.E3FBAD9A" X-MS-TNEF-Correlator: Thread-Topic: Update FarSync WAN driver in 2.6 Thread-Index: AcP+9VRqHpr28/PlTpO8fXe/3pey7gAeAfzQAAnIc7A= From: "Kevin Curtis" content-class: urn:content-classes:message To: "Kevin Curtis" , "Jeff Garzik" X-MimeOLE: Produced By Microsoft Exchange V6.0.6487.1 Cc: , X-archive-position: 3685 X-ecartis-version: Ecartis v1.0.0 Sender: netdev-bounce@oss.sgi.com Errors-to: netdev-bounce@oss.sgi.com X-original-sender: kevin.curtis@farsite.co.uk Precedence: bulk X-list: netdev This is a multi-part message in MIME format. ------_=_NextPart_001_01C3FF94.E3FBAD9A Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Here is the modified patch. It installs against 2.6.4-pre1 Best get it in quick before net_device is given back to the hdlc layer again :-> Kevin -----Original Message----- From: Kevin Curtis=20 Sent: 01 March 2004 09:15 To: 'Jeff Garzik'; Kevin Curtis Cc: netdev@oss.sgi.com; davem@redhat.com Subject: RE: Update FarSync WAN driver in 2.6 Hi, looks as though the 2.6.4-pre1 patch has changed farsync.c, which is probably why the patch will not apply. I would re-work the patch against this release. What is the status of the 2.4.x patch that I sent a while back? I still need to make one more change to it. I need to know if to resend the whole patch, or a n additional patch with the change? Kevin -----Original Message----- From: Jeff Garzik [mailto:jgarzik@pobox.com]=20 Sent: 29 February 2004 18:53 To: Kevin Curtis Cc: netdev@oss.sgi.com; davem@redhat.com Subject: Re: Update FarSync WAN driver in 2.6 hum... Patch looks OK to appy, but does not apply against the latest=20 2.6.x kernel. Also, it is possible to split your patch into two pieces: one patch=20 with nothing but indentation/whitespace cleanups, and the other patch=20 with functional changes? Jeff ------_=_NextPart_001_01C3FF94.E3FBAD9A Content-Type: application/octet-stream; name="farsync2.6.patch" Content-Transfer-Encoding: base64 Content-Description: farsync2.6.patch Content-Disposition: attachment; filename="farsync2.6.patch" ZGlmZiAtdXJOIGxpbnV4LTIuNi40LXByZTEtb3JpZy9kcml2ZXJzL25ldC93YW4vZmFyc3luYy5j IGxpbnV4L2RyaXZlcnMvbmV0L3dhbi9mYXJzeW5jLmMKLS0tIGxpbnV4LTIuNi40LXByZTEtb3Jp Zy9kcml2ZXJzL25ldC93YW4vZmFyc3luYy5jCTIwMDQtMDMtMDEgMDk6MTc6MDguMDAwMDAwMDAw ICswMDAwCisrKyBsaW51eC9kcml2ZXJzL25ldC93YW4vZmFyc3luYy5jCTIwMDQtMDMtMDEgMTI6 NTQ6MjIuMjk5Mjg1NzUyICswMDAwCkBAIC0xLDkgKzEsOSBAQAogLyoKLSAqICAgICAgRmFyU3lu YyBYMjEgZHJpdmVyIGZvciBMaW51eCAoZ2VuZXJpYyBIRExDIHZlcnNpb24pCisgKiAgICAgIEZh clN5bmMgV0FOIGRyaXZlciBmb3IgTGludXggKDIuNi54IGtlcm5lbCB2ZXJzaW9uKQogICoKICAq ICAgICAgQWN0dWFsbHkgc3luYyBkcml2ZXIgZm9yIFguMjEsIFYuMzUgYW5kIFYuMjQgb24gRmFy U3luYyBULXNlcmllcyBjYXJkcwogICoKLSAqICAgICAgQ29weXJpZ2h0IChDKSAyMDAxIEZhclNp dGUgQ29tbXVuaWNhdGlvbnMgTHRkLgorICogICAgICBDb3B5cmlnaHQgKEMpIDIwMDEtMjAwNCBG YXJTaXRlIENvbW11bmljYXRpb25zIEx0ZC4KICAqICAgICAgd3d3LmZhcnNpdGUuY28udWsKICAq CiAgKiAgICAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKQEAgLTExLDExICsxMSwxMyBAQAogICogICAgICBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24KICAqICAgICAg MiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4K ICAqCi0gKiAgICAgIEF1dGhvcjogUi5KLkR1bmxvcCAgICAgIDxib2IuZHVubG9wQGZhcnNpdGUu Y28udWs+CisgKiAgICAgIEF1dGhvcjogICAgICBSLkouRHVubG9wICAgIDxib2IuZHVubG9wQGZh cnNpdGUuY28udWs+CisgKiAgICAgIE1haW50YWluZXI6ICBLZXZpbiBDdXJ0aXMgIDxrZXZpbi5j dXJ0aXNAZmFyc2l0ZS5jby51az4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAj aW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgogI2lu Y2x1ZGUgPGxpbnV4L3BjaS5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgogI2luY2x1ZGUg PGxpbnV4L2luaXQuaD4KQEAgLTI1LDQ5ICsyNyw2MiBAQAogCiAjaW5jbHVkZSAiZmFyc3luYy5o IgogCi0KIC8qCiAgKiAgICAgIE1vZHVsZSBpbmZvCiAgKi8KIE1PRFVMRV9BVVRIT1IoIlIuSi5E dW5sb3AgPGJvYi5kdW5sb3BAZmFyc2l0ZS5jby51az4iKTsKLU1PRFVMRV9ERVNDUklQVElPTigi RmFyU3luYyBULVNlcmllcyBYMjEgZHJpdmVyLiBGYXJTaXRlIENvbW11bmljYXRpb25zIEx0ZC4i KTsKK01PRFVMRV9ERVNDUklQVElPTigiRmFyU3luYyBULVNlcmllcyBXQU4gZHJpdmVyLiBGYXJT aXRlIENvbW11bmljYXRpb25zIEx0ZC4iKTsKK01PRFVMRV9QQVJNKGZzdF90eHFfbG93LCAiaSIp OworTU9EVUxFX1BBUk0oZnN0X3R4cV9oaWdoLCAiaSIpOworTU9EVUxFX1BBUk0oZnN0X21heF9y ZWFkcywgImkiKTsKK01PRFVMRV9QQVJNKGZzdF9leGNsdWRlZF9jYXJkcywgImkiKTsKK01PRFVM RV9QQVJNKGZzdF9leGNsdWRlZF9saXN0LCAiMC0zMmkiKTsKIE1PRFVMRV9MSUNFTlNFKCJHUEwi KTsKIAogLyogICAgICBEcml2ZXIgY29uZmlndXJhdGlvbiBhbmQgZ2xvYmFsIHBhcmFtZXRlcnMK ICAqICAgICAgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAgKi8K IAotLyogICAgICBOdW1iZXIgb2YgcG9ydHMgKHBlciBjYXJkKSBzdXBwb3J0ZWQKKy8qICAgICAg TnVtYmVyIG9mIHBvcnRzIChwZXIgY2FyZCkgYW5kIGNhcmRzIHN1cHBvcnRlZAogICovCiAjZGVm aW5lIEZTVF9NQVhfUE9SVFMgICAgICAgICAgIDQKLQotCi0vKiAgICAgIFBDSSB2ZW5kb3IgYW5k IGRldmljZSBJRHMKLSAqLwotI2RlZmluZSBGU0NfUENJX1ZFTkRPUl9JRCAgICAgICAweDE2MTkg IC8qIEZhclNpdGUgQ29tbXVuaWNhdGlvbnMgTHRkICovCi0jZGVmaW5lIFQyUF9QQ0lfREVWSUNF X0lEICAgICAgIDB4MDQwMCAgLyogVDJQIFgyMSAyIHBvcnQgY2FyZCAqLwotI2RlZmluZSBUNFBf UENJX0RFVklDRV9JRCAgICAgICAweDA0NDAgIC8qIFQ0UCBYMjEgNCBwb3J0IGNhcmQgKi8KLQor I2RlZmluZSBGU1RfTUFYX0NBUkRTICAgICAgICAgICAzMgogCiAvKiAgICAgIERlZmF1bHQgcGFy YW1ldGVycyBmb3IgdGhlIGxpbmsKICAqLwotI2RlZmluZSBGU1RfVFhfUVVFVUVfTEVOICAgICAg ICAxMDAgICAgIC8qIEF0IDhNYnBzIGEgbG9uZ2VyIHF1ZXVlIGxlbmd0aCBpcwotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIHVzZWZ1bCwgdGhlIHN5bmNwcHAgbW9k dWxlIGZvcmNlcwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIHRo aXMgZG93biBhc3N1bWluZyBhIHNsb3dlciBsaW5lIEkKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgKiBndWVzcy4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgKi8KLSNkZWZpbmUgRlNUX01BWF9NVFUgICAgICAgICAgICAgODAwMCAgICAv KiBIdWdlIGJ1dCBwb3NzaWJsZSAqLwotI2RlZmluZSBGU1RfREVGX01UVSAgICAgICAgICAgICAx NTAwICAgIC8qIENvbW1vbiBzYW5lIHZhbHVlICovCisjZGVmaW5lIEZTVF9UWF9RVUVVRV9MRU4g ICAgICAgIDEwMAkvKiBBdCA4TWJwcyBhIGxvbmdlciBxdWV1ZSBsZW5ndGggaXMKKwkJCQkJICog dXNlZnVsLCB0aGUgc3luY3BwcCBtb2R1bGUgZm9yY2VzCisJCQkJCSAqIHRoaXMgZG93biBhc3N1 bWluZyBhIHNsb3dlciBsaW5lIEkKKwkJCQkJICogZ3Vlc3MuCisJCQkJCSAqLworI2RlZmluZSBG U1RfVFhRX0RFUFRIICAgICAgICAgICAxNgkvKiBUaGlzIG9uZSBpcyBmb3IgdGhlIGJ1ZmZlcmlu ZworCQkJCQkgKiBvZiBmcmFtZXMgb24gdGhlIHdheSBkb3duIHRvIHRoZSBjYXJkCisJCQkJCSAq IHNvIHRoYXQgd2UgY2FuIGtlZXAgdGhlIGNhcmQgYnVzeQorCQkJCQkgKiBhbmQgbWF4aW1pc2Ug dGhyb3VnaHB1dAorCQkJCQkgKi8KKyNkZWZpbmUgRlNUX0hJR0hfV0FURVJfTUFSSyAgICAgMTIJ LyogUG9pbnQgYXQgd2hpY2ggd2UgZmxvdyBjb250cm9sCisJCQkJCSAqIG5ldHdvcmsgbGF5ZXIg Ki8KKyNkZWZpbmUgRlNUX0xPV19XQVRFUl9NQVJLICAgICAgOAkvKiBQb2ludCBhdCB3aGljaCB3 ZSByZW1vdmUgZmxvdworCQkJCQkgKiBjb250cm9sIGZyb20gbmV0d29yayBsYXllciAqLworI2Rl ZmluZSBGU1RfTUFYX01UVSAgICAgICAgICAgICA4MDAwCS8qIEh1Z2UgYnV0IHBvc3NpYmxlICov CisjZGVmaW5lIEZTVF9ERUZfTVRVICAgICAgICAgICAgIDE1MDAJLyogQ29tbW9uIHNhbmUgdmFs dWUgKi8KIAogI2RlZmluZSBGU1RfVFhfVElNRU9VVCAgICAgICAgICAoMipIWikKIAotCiAjaWZk ZWYgQVJQSFJEX1JBV0hETEMKLSNkZWZpbmUgQVJQSFJEX01ZVFlQRSAgIEFSUEhSRF9SQVdIRExD ICAvKiBSYXcgZnJhbWVzICovCisjZGVmaW5lIEFSUEhSRF9NWVRZUEUgICBBUlBIUkRfUkFXSERM QwkvKiBSYXcgZnJhbWVzICovCiAjZWxzZQotI2RlZmluZSBBUlBIUkRfTVlUWVBFICAgQVJQSFJE X0hETEMgICAgIC8qIENpc2NvLUhETEMgKGtlZXBhbGl2ZXMgZXRjKSAqLworI2RlZmluZSBBUlBI UkRfTVlUWVBFICAgQVJQSFJEX0hETEMJLyogQ2lzY28tSERMQyAoa2VlcGFsaXZlcyBldGMpICov CiAjZW5kaWYKIAorLyoKKyAqIE1vZHVsZXMgcGFyYW1ldGVycyBhbmQgYXNzb2NpYXRlZCB2YXJh aWJsZXMKKyAqLworaW50IGZzdF90eHFfbG93ID0gRlNUX0xPV19XQVRFUl9NQVJLOworaW50IGZz dF90eHFfaGlnaCA9IEZTVF9ISUdIX1dBVEVSX01BUks7CitpbnQgZnN0X21heF9yZWFkcyA9IDc7 CitpbnQgZnN0X2V4Y2x1ZGVkX2NhcmRzID0gMDsKK2ludCBmc3RfZXhjbHVkZWRfbGlzdFtGU1Rf TUFYX0NBUkRTXTsKIAogLyogICAgICBDYXJkIHNoYXJlZCBtZW1vcnkgbGF5b3V0CiAgKiAgICAg ID09PT09PT09PT09PT09PT09PT09PT09PT0KQEAgLTg0LDU4ICs5OSw1NyBAQAogICogICAgICBi ZSB1c2VkIHRvIGNoZWNrIHRoYXQgd2UgaGF2ZSBub3QgZ290IG91dCBvZiBzdGVwIHdpdGggdGhl IGZpcm13YXJlCiAgKiAgICAgIGNvbnRhaW5lZCBpbiB0aGUgLkNERSBmaWxlcy4KICAqLwotI2Rl ZmluZSBTTUNfVkVSU0lPTiAxMQorI2RlZmluZSBTTUNfVkVSU0lPTiAyNAogCi0jZGVmaW5lIEZT VF9NRU1TSVpFIDB4MTAwMDAwICAgIC8qIFNpemUgb2YgY2FyZCBtZW1vcnkgKDFNYikgKi8KKyNk ZWZpbmUgRlNUX01FTVNJWkUgMHgxMDAwMDAJLyogU2l6ZSBvZiBjYXJkIG1lbW9yeSAoMU1iKSAq LwogCi0jZGVmaW5lIFNNQ19CQVNFIDB4MDAwMDIwMDBMICAgIC8qIEJhc2Ugb2Zmc2V0IG9mIHRo ZSBzaGFyZWQgbWVtb3J5IHdpbmRvdyBtYWluCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAqIGNvbmZpZ3VyYXRpb24gc3RydWN0dXJlICovCi0jZGVmaW5lIEJGTV9CQVNFIDB4MDAw MTAwMDBMICAgIC8qIEJhc2Ugb2Zmc2V0IG9mIHRoZSBzaGFyZWQgbWVtb3J5IHdpbmRvdyBETUEK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICogYnVmZmVycyAqLworI2RlZmluZSBT TUNfQkFTRSAweDAwMDAyMDAwTAkvKiBCYXNlIG9mZnNldCBvZiB0aGUgc2hhcmVkIG1lbW9yeSB3 aW5kb3cgbWFpbgorCQkJCSAqIGNvbmZpZ3VyYXRpb24gc3RydWN0dXJlICovCisjZGVmaW5lIEJG TV9CQVNFIDB4MDAwMTAwMDBMCS8qIEJhc2Ugb2Zmc2V0IG9mIHRoZSBzaGFyZWQgbWVtb3J5IHdp bmRvdyBETUEKKwkJCQkgKiBidWZmZXJzICovCiAKLSNkZWZpbmUgTEVOX1RYX0JVRkZFUiA4MTky ICAgICAgLyogU2l6ZSBvZiBwYWNrZXQgYnVmZmVycyAqLworI2RlZmluZSBMRU5fVFhfQlVGRkVS IDgxOTIJLyogU2l6ZSBvZiBwYWNrZXQgYnVmZmVycyAqLwogI2RlZmluZSBMRU5fUlhfQlVGRkVS IDgxOTIKIAotI2RlZmluZSBMRU5fU01BTExfVFhfQlVGRkVSIDI1NiAvKiBTaXplIG9mIG9ic29s ZXRlIGJ1ZmZzIHVzZWQgZm9yIERPUyBkaWFncyAqLworI2RlZmluZSBMRU5fU01BTExfVFhfQlVG RkVSIDI1NgkvKiBTaXplIG9mIG9ic29sZXRlIGJ1ZmZzIHVzZWQgZm9yIERPUyBkaWFncyAqLwog I2RlZmluZSBMRU5fU01BTExfUlhfQlVGRkVSIDI1NgogCi0jZGVmaW5lIE5VTV9UWF9CVUZGRVIg MiAgICAgICAgIC8qIE11c3QgYmUgcG93ZXIgb2YgMi4gRml4ZWQgYnkgZmlybXdhcmUgKi8KKyNk ZWZpbmUgTlVNX1RYX0JVRkZFUiAyCQkvKiBNdXN0IGJlIHBvd2VyIG9mIDIuIEZpeGVkIGJ5IGZp cm13YXJlICovCiAjZGVmaW5lIE5VTV9SWF9CVUZGRVIgOAogCiAvKiBJbnRlcnJ1cHQgcmV0cnkg dGltZSBpbiBtaWxsaXNlY29uZHMgKi8KICNkZWZpbmUgSU5UX1JFVFJZX1RJTUUgMgogCi0KIC8q ICAgICAgVGhlIEFtMTg2Q0gvQ0MgcHJvY2Vzc29ycyBzdXBwb3J0IGEgU21hcnRETUEgbW9kZSB1 c2luZyBjaXJjdWxhciBwb29scwogICogICAgICBvZiBidWZmZXIgZGVzY3JpcHRvcnMuIFRoZSBz dHJ1Y3R1cmUgaXMgYWxtb3N0IGlkZW50aWNhbCB0byB0aGF0IHVzZWQKICAqICAgICAgaW4gdGhl IExBTkNFIEV0aGVybmV0IGNvbnRyb2xsZXJzLiBEZXRhaWxzIGF2YWlsYWJsZSBhcyBQREYgZnJv bSB0aGUKICAqICAgICAgQU1EIHdlYiBzaXRlOiBodHRwOi8vd3d3LmFtZC5jb20vcHJvZHVjdHMv ZXBkL3Byb2Nlc3NvcnMvXAogICogICAgICAgICAgICAgICAgICAgIDIuMTZiaXRjb250LzMuYW0x ODZjeGZhL2EyMTkxNC8yMTkxNC5wZGYKICAqLwotc3RydWN0IHR4ZGVzYyB7ICAgICAgICAgICAg ICAgICAvKiBUcmFuc21pdCBkZXNjcmlwdG9yICovCi0gICAgICAgIHZvbGF0aWxlIHUxNiBsYWRy OyAgICAgIC8qIExvdyBvcmRlciBhZGRyZXNzIG9mIHBhY2tldC4gVGhpcyBpcyBhCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAqIGxpbmVhciBhZGRyZXNzIGluIHRoZSBBbTE4NiBt ZW1vcnkgc3BhY2UKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi0gICAgICAg IHZvbGF0aWxlIHU4ICBoYWRyOyAgICAgIC8qIEhpZ2ggb3JkZXIgYWRkcmVzcy4gTG93IDQgYml0 cyBvbmx5LCBoaWdoIDQKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICogYml0cyBt dXN0IGJlIHplcm8KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi0gICAgICAg IHZvbGF0aWxlIHU4ICBiaXRzOyAgICAgIC8qIFN0YXR1cyBhbmQgY29uZmlnICovCi0gICAgICAg IHZvbGF0aWxlIHUxNiBiY250OyAgICAgIC8qIDJzIGNvbXBsZW1lbnQgb2YgcGFja2V0IHNpemUg aW4gbG93IDE1IGJpdHMuCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIFRyYW5z bWl0IHRlcm1pbmFsIGNvdW50IGludGVycnVwdCBlbmFibGUgaW4KLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICogdG9wIGJpdC4KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICovCi0gICAgICAgICAgICAgICAgIHUxNiB1bnVzZWQ7ICAgIC8qIE5vdCB1c2VkIGluIFR4 ICovCitzdHJ1Y3QgdHhkZXNjIHsJCQkvKiBUcmFuc21pdCBkZXNjcmlwdG9yICovCisJdm9sYXRp bGUgdTE2IGxhZHI7CS8qIExvdyBvcmRlciBhZGRyZXNzIG9mIHBhY2tldC4gVGhpcyBpcyBhCisJ CQkJICogbGluZWFyIGFkZHJlc3MgaW4gdGhlIEFtMTg2IG1lbW9yeSBzcGFjZQorCQkJCSAqLwor CXZvbGF0aWxlIHU4IGhhZHI7CS8qIEhpZ2ggb3JkZXIgYWRkcmVzcy4gTG93IDQgYml0cyBvbmx5 LCBoaWdoIDQKKwkJCQkgKiBiaXRzIG11c3QgYmUgemVybworCQkJCSAqLworCXZvbGF0aWxlIHU4 IGJpdHM7CS8qIFN0YXR1cyBhbmQgY29uZmlnICovCisJdm9sYXRpbGUgdTE2IGJjbnQ7CS8qIDJz IGNvbXBsZW1lbnQgb2YgcGFja2V0IHNpemUgaW4gbG93IDE1IGJpdHMuCisJCQkJICogVHJhbnNt aXQgdGVybWluYWwgY291bnQgaW50ZXJydXB0IGVuYWJsZSBpbgorCQkJCSAqIHRvcCBiaXQuCisJ CQkJICovCisJdTE2IHVudXNlZDsJCS8qIE5vdCB1c2VkIGluIFR4ICovCiB9OwogCi1zdHJ1Y3Qg cnhkZXNjIHsgICAgICAgICAgICAgICAgIC8qIFJlY2VpdmUgZGVzY3JpcHRvciAqLwotICAgICAg ICB2b2xhdGlsZSB1MTYgbGFkcjsgICAgICAvKiBMb3cgb3JkZXIgYWRkcmVzcyBvZiBwYWNrZXQg Ki8KLSAgICAgICAgdm9sYXRpbGUgdTggIGhhZHI7ICAgICAgLyogSGlnaCBvcmRlciBhZGRyZXNz ICovCi0gICAgICAgIHZvbGF0aWxlIHU4ICBiaXRzOyAgICAgIC8qIFN0YXR1cyBhbmQgY29uZmln ICovCi0gICAgICAgIHZvbGF0aWxlIHUxNiBiY250OyAgICAgIC8qIDJzIGNvbXBsZW1lbnQgb2Yg YnVmZmVyIHNpemUgaW4gbG93IDE1IGJpdHMuCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAqIFJlY2VpdmUgdGVybWluYWwgY291bnQgaW50ZXJydXB0IGVuYWJsZSBpbgotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKiB0b3AgYml0LgotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgKi8KLSAgICAgICAgdm9sYXRpbGUgdTE2IG1jbnQ7ICAgICAgLyogTWVz c2FnZSBieXRlIGNvdW50ICgxNSBiaXRzKSAqLworc3RydWN0IHJ4ZGVzYyB7CQkJLyogUmVjZWl2 ZSBkZXNjcmlwdG9yICovCisJdm9sYXRpbGUgdTE2IGxhZHI7CS8qIExvdyBvcmRlciBhZGRyZXNz IG9mIHBhY2tldCAqLworCXZvbGF0aWxlIHU4IGhhZHI7CS8qIEhpZ2ggb3JkZXIgYWRkcmVzcyAq LworCXZvbGF0aWxlIHU4IGJpdHM7CS8qIFN0YXR1cyBhbmQgY29uZmlnICovCisJdm9sYXRpbGUg dTE2IGJjbnQ7CS8qIDJzIGNvbXBsZW1lbnQgb2YgYnVmZmVyIHNpemUgaW4gbG93IDE1IGJpdHMu CisJCQkJICogUmVjZWl2ZSB0ZXJtaW5hbCBjb3VudCBpbnRlcnJ1cHQgZW5hYmxlIGluCisJCQkJ ICogdG9wIGJpdC4KKwkJCQkgKi8KKwl2b2xhdGlsZSB1MTYgbWNudDsJLyogTWVzc2FnZSBieXRl IGNvdW50ICgxNSBiaXRzKSAqLwogfTsKIAogLyogQ29udmVydCBhIGxlbmd0aCBpbnRvIHRoZSAx NSBiaXQgMidzIGNvbXBsZW1lbnQgKi8KQEAgLTE0Niw1NyArMTYwLDk5IEBACiAjZGVmaW5lIGNu dl9iY250KGxlbikgICAoLShsZW4pKQogCiAvKiBTdGF0dXMgYW5kIGNvbmZpZyBiaXRzIGZvciB0 aGUgYWJvdmUgKi8KLSNkZWZpbmUgRE1BX09XTiAgICAgICAgIDB4ODAgICAgICAgICAgICAvKiBT bWFydERNQSBvd25zIHRoZSBkZXNjcmlwdG9yICovCi0jZGVmaW5lIFRYX1NUUCAgICAgICAgICAw eDAyICAgICAgICAgICAgLyogVHg6IHN0YXJ0IG9mIHBhY2tldCAqLwotI2RlZmluZSBUWF9FTlAg ICAgICAgICAgMHgwMSAgICAgICAgICAgIC8qIFR4OiBlbmQgb2YgcGFja2V0ICovCi0jZGVmaW5l IFJYX0VSUiAgICAgICAgICAweDQwICAgICAgICAgICAgLyogUng6IGVycm9yIChPUiBvZiBuZXh0 IDQgYml0cykgKi8KLSNkZWZpbmUgUlhfRlJBTSAgICAgICAgIDB4MjAgICAgICAgICAgICAvKiBS eDogZnJhbWluZyBlcnJvciAqLwotI2RlZmluZSBSWF9PRkxPICAgICAgICAgMHgxMCAgICAgICAg ICAgIC8qIFJ4OiBvdmVyZmxvdyBlcnJvciAqLwotI2RlZmluZSBSWF9DUkMgICAgICAgICAgMHgw OCAgICAgICAgICAgIC8qIFJ4OiBDUkMgZXJyb3IgKi8KLSNkZWZpbmUgUlhfSEJVRiAgICAgICAg IDB4MDQgICAgICAgICAgICAvKiBSeDogYnVmZmVyIGVycm9yICovCi0jZGVmaW5lIFJYX1NUUCAg ICAgICAgICAweDAyICAgICAgICAgICAgLyogUng6IHN0YXJ0IG9mIHBhY2tldCAqLwotI2RlZmlu ZSBSWF9FTlAgICAgICAgICAgMHgwMSAgICAgICAgICAgIC8qIFJ4OiBlbmQgb2YgcGFja2V0ICov Ci0KKyNkZWZpbmUgRE1BX09XTiAgICAgICAgIDB4ODAJLyogU21hcnRETUEgb3ducyB0aGUgZGVz Y3JpcHRvciAqLworI2RlZmluZSBUWF9TVFAgICAgICAgICAgMHgwMgkvKiBUeDogc3RhcnQgb2Yg cGFja2V0ICovCisjZGVmaW5lIFRYX0VOUCAgICAgICAgICAweDAxCS8qIFR4OiBlbmQgb2YgcGFj a2V0ICovCisjZGVmaW5lIFJYX0VSUiAgICAgICAgICAweDQwCS8qIFJ4OiBlcnJvciAoT1Igb2Yg bmV4dCA0IGJpdHMpICovCisjZGVmaW5lIFJYX0ZSQU0gICAgICAgICAweDIwCS8qIFJ4OiBmcmFt aW5nIGVycm9yICovCisjZGVmaW5lIFJYX09GTE8gICAgICAgICAweDEwCS8qIFJ4OiBvdmVyZmxv dyBlcnJvciAqLworI2RlZmluZSBSWF9DUkMgICAgICAgICAgMHgwOAkvKiBSeDogQ1JDIGVycm9y ICovCisjZGVmaW5lIFJYX0hCVUYgICAgICAgICAweDA0CS8qIFJ4OiBidWZmZXIgZXJyb3IgKi8K KyNkZWZpbmUgUlhfU1RQICAgICAgICAgIDB4MDIJLyogUng6IHN0YXJ0IG9mIHBhY2tldCAqLwor I2RlZmluZSBSWF9FTlAgICAgICAgICAgMHgwMQkvKiBSeDogZW5kIG9mIHBhY2tldCAqLwogCi0v KiBJbnRlcnJ1cHRzIGZyb20gdGhlIGNhcmQgYXJlIGNhdXNlZCBieSB2YXJpb3VzIGV2ZW50cyBh bmQgdGhlc2UgYXJlIHByZXNlbnRlZAorLyogSW50ZXJydXB0cyBmcm9tIHRoZSBjYXJkIGFyZSBj YXVzZWQgYnkgdmFyaW91cyBldmVudHMgd2hpY2ggYXJlIHByZXNlbnRlZAogICogaW4gYSBjaXJj dWxhciBidWZmZXIgYXMgc2V2ZXJhbCBldmVudHMgbWF5IGJlIHByb2Nlc3NlZCBvbiBvbmUgcGh5 c2ljYWwgaW50CiAgKi8KICNkZWZpbmUgTUFYX0NJUkJVRkYgICAgIDMyCiAKIHN0cnVjdCBjaXJi dWZmIHsKLSAgICAgICAgdTggcmRpbmRleDsgICAgICAgICAgICAgLyogcmVhZCwgdGhlbiBpbmNy ZW1lbnQgYW5kIHdyYXAgKi8KLSAgICAgICAgdTggd3JpbmRleDsgICAgICAgICAgICAgLyogd3Jp dGUsIHRoZW4gaW5jcmVtZW50IGFuZCB3cmFwICovCi0gICAgICAgIHU4IGV2bnRidWZmW01BWF9D SVJCVUZGXTsKKwl1OCByZGluZGV4OwkJLyogcmVhZCwgdGhlbiBpbmNyZW1lbnQgYW5kIHdyYXAg Ki8KKwl1OCB3cmluZGV4OwkJLyogd3JpdGUsIHRoZW4gaW5jcmVtZW50IGFuZCB3cmFwICovCisJ dTggZXZudGJ1ZmZbTUFYX0NJUkJVRkZdOwogfTsKIAogLyogSW50ZXJydXB0IGV2ZW50IGNvZGVz LgogICogV2hlcmUgYXBwcm9wcmlhdGUgdGhlIHR3byBsb3cgb3JkZXIgYml0cyBpbmRpY2F0ZSB0 aGUgcG9ydCBudW1iZXIKICAqLwotI2RlZmluZSBDVExBX0NIRyAgICAgICAgMHgxOCAgICAvKiBD b250cm9sIHNpZ25hbCBjaGFuZ2VkICovCisjZGVmaW5lIENUTEFfQ0hHICAgICAgICAweDE4CS8q IENvbnRyb2wgc2lnbmFsIGNoYW5nZWQgKi8KICNkZWZpbmUgQ1RMQl9DSEcgICAgICAgIDB4MTkK ICNkZWZpbmUgQ1RMQ19DSEcgICAgICAgIDB4MUEKICNkZWZpbmUgQ1RMRF9DSEcgICAgICAgIDB4 MUIKIAotI2RlZmluZSBJTklUX0NQTFQgICAgICAgMHgyMCAgICAvKiBJbml0aWFsaXNhdGlvbiBj b21wbGV0ZSAqLwotI2RlZmluZSBJTklUX0ZBSUwgICAgICAgMHgyMSAgICAvKiBJbml0aWFsaXNh dGlvbiBmYWlsZWQgKi8KKyNkZWZpbmUgSU5JVF9DUExUICAgICAgIDB4MjAJLyogSW5pdGlhbGlz YXRpb24gY29tcGxldGUgKi8KKyNkZWZpbmUgSU5JVF9GQUlMICAgICAgIDB4MjEJLyogSW5pdGlh bGlzYXRpb24gZmFpbGVkICovCiAKLSNkZWZpbmUgQUJUQV9TRU5UICAgICAgIDB4MjQgICAgLyog QWJvcnQgc2VudCAqLworI2RlZmluZSBBQlRBX1NFTlQgICAgICAgMHgyNAkvKiBBYm9ydCBzZW50 ICovCiAjZGVmaW5lIEFCVEJfU0VOVCAgICAgICAweDI1CiAjZGVmaW5lIEFCVENfU0VOVCAgICAg ICAweDI2CiAjZGVmaW5lIEFCVERfU0VOVCAgICAgICAweDI3CiAKLSNkZWZpbmUgVFhBX1VOREYg ICAgICAgIDB4MjggICAgLyogVHJhbnNtaXNzaW9uIHVuZGVyZmxvdyAqLworI2RlZmluZSBUWEFf VU5ERiAgICAgICAgMHgyOAkvKiBUcmFuc21pc3Npb24gdW5kZXJmbG93ICovCiAjZGVmaW5lIFRY Ql9VTkRGICAgICAgICAweDI5CiAjZGVmaW5lIFRYQ19VTkRGICAgICAgICAweDJBCiAjZGVmaW5l IFRYRF9VTkRGICAgICAgICAweDJCCiAKKyNkZWZpbmUgRjU2X0lOVCAgICAgICAgIDB4MkMKKyNk ZWZpbmUgTTMyX0lOVCAgICAgICAgIDB4MkQKKworI2RlZmluZSBURTFfQUxNQSAgICAgICAgMHgz MAogCiAvKiBQb3J0IHBoeXNpY2FsIGNvbmZpZ3VyYXRpb24uIFNlZSBmYXJzeW5jLmggZm9yIGZp ZWxkIHZhbHVlcyAqLwogc3RydWN0IHBvcnRfY2ZnIHsKLSAgICAgICAgdTE2ICBsaW5lSW50ZXJm YWNlOyAgICAgLyogUGh5c2ljYWwgaW50ZXJmYWNlIHR5cGUgKi8KLSAgICAgICAgdTggICB4MjVv cDsgICAgICAgICAgICAgLyogVW51c2VkIGF0IHByZXNlbnQgKi8KLSAgICAgICAgdTggICBpbnRl cm5hbENsb2NrOyAgICAgLyogMSA9PiBpbnRlcm5hbCBjbG9jaywgMCA9PiBleHRlcm5hbCAqLwot ICAgICAgICB1MzIgIGxpbmVTcGVlZDsgICAgICAgICAvKiBTcGVlZCBpbiBicHMgKi8KKwl1MTYg bGluZUludGVyZmFjZTsJLyogUGh5c2ljYWwgaW50ZXJmYWNlIHR5cGUgKi8KKwl1OCB4MjVvcDsJ CS8qIFVudXNlZCBhdCBwcmVzZW50ICovCisJdTggaW50ZXJuYWxDbG9jazsJLyogMSA9PiBpbnRl cm5hbCBjbG9jaywgMCA9PiBleHRlcm5hbCAqLworCXU4IHRyYW5zcGFyZW50TW9kZTsJLyogMSA9 PiBvbiwgMCA9PiBvZmYgKi8KKwl1OCBpbnZlcnRDbG9jazsJCS8qIDAgPT4gbm9ybWFsLCAxID0+ IGludmVydGVkICovCisJdTggcGFkQnl0ZXNbNl07CQkvKiBQYWRkaW5nICovCisJdTMyIGxpbmVT cGVlZDsJCS8qIFNwZWVkIGluIGJwcyAqLworfTsKKworLyogVEUxIHBvcnQgcGh5c2ljYWwgY29u ZmlndXJhdGlvbiAqLworc3RydWN0IHN1X2NvbmZpZyB7CisJdTMyIGRhdGFSYXRlOworCXU4IGNs b2NraW5nOworCXU4IGZyYW1pbmc7CisJdTggc3RydWN0dXJlOworCXU4IGludGVyZmFjZTsKKwl1 OCBjb2Rpbmc7CisJdTggbGluZUJ1aWxkT3V0OworCXU4IGVxdWFsaXplcjsKKwl1OCB0cmFuc3Bh cmVudE1vZGU7CisJdTggbG9vcE1vZGU7CisJdTggcmFuZ2U7CisJdTggdHhCdWZmZXJNb2RlOwor CXU4IHJ4QnVmZmVyTW9kZTsKKwl1OCBzdGFydGluZ1Nsb3Q7CisJdTggbG9zVGhyZXNob2xkOwor CXU4IGVuYWJsZUlkbGVDb2RlOworCXU4IGlkbGVDb2RlOworCXU4IHNwYXJlWzQ0XTsKK307CisK Ky8qIFRFMSBTdGF0dXMgKi8KK3N0cnVjdCBzdV9zdGF0dXMgeworCXUzMiByZWNlaXZlQnVmZmVy RGVsYXk7CisJdTMyIGZyYW1pbmdFcnJvckNvdW50OworCXUzMiBjb2RlVmlvbGF0aW9uQ291bnQ7 CisJdTMyIGNyY0Vycm9yQ291bnQ7CisJdTMyIGxpbmVBdHRlbnVhdGlvbjsKKwl1OCBwb3J0U3Rh cnRlZDsKKwl1OCBsb3NzT2ZTaWduYWw7CisJdTggcmVjZWl2ZVJlbW90ZUFsYXJtOworCXU4IGFs YXJtSW5kaWNhdGlvblNpZ25hbDsKKwl1OCBzcGFyZVs0MF07CiB9OwogCiAvKiBGaW5hbGx5IHNs aW5nIGFsbCB0aGUgYWJvdmUgdG9nZXRoZXIgaW50byB0aGUgc2hhcmVkIG1lbW9yeSBzdHJ1Y3R1 cmUuCkBAIC0yMDYsMTU0ICsyNjIsMjE2IEBACiAgKiBTZWUgZmFyc3luYy5oIGZvciBzb21lIGZp ZWxkIHZhbHVlcy4KICAqLwogc3RydWN0IGZzdF9zaGFyZWQgewotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAvKiBETUEgZGVzY3JpcHRvciByaW5ncyAqLwotICAgICAgICBzdHJ1Y3Qg cnhkZXNjIHJ4RGVzY3JSaW5nW0ZTVF9NQVhfUE9SVFNdW05VTV9SWF9CVUZGRVJdOwotICAgICAg ICBzdHJ1Y3QgdHhkZXNjIHR4RGVzY3JSaW5nW0ZTVF9NQVhfUE9SVFNdW05VTV9UWF9CVUZGRVJd OworCS8qIERNQSBkZXNjcmlwdG9yIHJpbmdzICovCisJc3RydWN0IHJ4ZGVzYyByeERlc2NyUmlu Z1tGU1RfTUFYX1BPUlRTXVtOVU1fUlhfQlVGRkVSXTsKKwlzdHJ1Y3QgdHhkZXNjIHR4RGVzY3JS aW5nW0ZTVF9NQVhfUE9SVFNdW05VTV9UWF9CVUZGRVJdOworCisJLyogT2Jzb2xldGUgc21hbGwg YnVmZmVycyAqLworCXU4IHNtYWxsUnhCdWZmZXJbRlNUX01BWF9QT1JUU11bTlVNX1JYX0JVRkZF Ul1bTEVOX1NNQUxMX1JYX0JVRkZFUl07CisJdTggc21hbGxUeEJ1ZmZlcltGU1RfTUFYX1BPUlRT XVtOVU1fVFhfQlVGRkVSXVtMRU5fU01BTExfVFhfQlVGRkVSXTsKIAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAvKiBPYnNvbGV0ZSBzbWFsbCBidWZmZXJzICovCi0gICAgICAgIHU4 ICBzbWFsbFJ4QnVmZmVyW0ZTVF9NQVhfUE9SVFNdW05VTV9SWF9CVUZGRVJdW0xFTl9TTUFMTF9S WF9CVUZGRVJdOwotICAgICAgICB1OCAgc21hbGxUeEJ1ZmZlcltGU1RfTUFYX1BPUlRTXVtOVU1f VFhfQlVGRkVSXVtMRU5fU01BTExfVFhfQlVGRkVSXTsKKwl1OCB0YXNrU3RhdHVzOwkJLyogMHgw MCA9PiBpbml0aWFsaXNpbmcsIDB4MDEgPT4gcnVubmluZywKKwkJCQkgKiAweEZGID0+IGhhbHRl ZAorCQkJCSAqLwogCi0gICAgICAgIHU4ICB0YXNrU3RhdHVzOyAgICAgICAgIC8qIDB4MDAgPT4g aW5pdGlhbGlzaW5nLCAweDAxID0+IHJ1bm5pbmcsCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAqIDB4RkYgPT4gaGFsdGVkCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAqLworCXU4IGludGVycnVwdEhhbmRzaGFrZTsJLyogU2V0IHRvIDB4MDEgYnkgYWRhcHRlciB0 byBzaWduYWwgaW50ZXJydXB0LAorCQkJCSAqIHNldCB0byAweEVFIGJ5IGhvc3QgdG8gYWNrbm93 bGVkZ2UgaW50ZXJydXB0CisJCQkJICovCiAKLSAgICAgICAgdTggIGludGVycnVwdEhhbmRzaGFr ZTsgLyogU2V0IHRvIDB4MDEgYnkgYWRhcHRlciB0byBzaWduYWwgaW50ZXJydXB0LAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKiBzZXQgdG8gMHhFRSBieSBob3N0IHRvIGFja25v d2xlZGdlIGludGVycnVwdAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKwl1 MTYgc21jVmVyc2lvbjsJCS8qIE11c3QgbWF0Y2ggU01DX1ZFUlNJT04gKi8KIAotICAgICAgICB1 MTYgc21jVmVyc2lvbjsgICAgICAgICAvKiBNdXN0IG1hdGNoIFNNQ19WRVJTSU9OICovCisJdTMy IHNtY0Zpcm13YXJlVmVyc2lvbjsJLyogMHhJSVZWUlJCQiB3aGVyZSBJSSA9IHByb2R1Y3QgSUQs IFZWID0gbWFqb3IKKwkJCQkgKiB2ZXJzaW9uLCBSUiA9IHJldmlzaW9uIGFuZCBCQiA9IGJ1aWxk CisJCQkJICovCiAKLSAgICAgICAgdTMyIHNtY0Zpcm13YXJlVmVyc2lvbjsgLyogMHhJSVZWUlJC QiB3aGVyZSBJSSA9IHByb2R1Y3QgSUQsIFZWID0gbWFqb3IKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICogdmVyc2lvbiwgUlIgPSByZXZpc2lvbiBhbmQgQkIgPSBidWlsZAotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKwl1MTYgdHhhX2RvbmU7CQkvKiBPYnNv bGV0ZSBjb21wbGV0aW9uIGZsYWdzICovCisJdTE2IHJ4YV9kb25lOworCXUxNiB0eGJfZG9uZTsK Kwl1MTYgcnhiX2RvbmU7CisJdTE2IHR4Y19kb25lOworCXUxNiByeGNfZG9uZTsKKwl1MTYgdHhk X2RvbmU7CisJdTE2IHJ4ZF9kb25lOwogCi0gICAgICAgIHUxNiB0eGFfZG9uZTsgICAgICAgICAg IC8qIE9ic29sZXRlIGNvbXBsZXRpb24gZmxhZ3MgKi8KLSAgICAgICAgdTE2IHJ4YV9kb25lOwot ICAgICAgICB1MTYgdHhiX2RvbmU7Ci0gICAgICAgIHUxNiByeGJfZG9uZTsKLSAgICAgICAgdTE2 IHR4Y19kb25lOwotICAgICAgICB1MTYgcnhjX2RvbmU7Ci0gICAgICAgIHUxNiB0eGRfZG9uZTsK LSAgICAgICAgdTE2IHJ4ZF9kb25lOworCXUxNiBtYWlsYm94WzRdOwkJLyogRGlhZ25vc3RpY3Mg bWFpbGJveC4gTm90IHVzZWQgKi8KIAotICAgICAgICB1MTYgbWFpbGJveFs0XTsgICAgICAgICAv KiBEaWFnbm9zdGljcyBtYWlsYm94LiBOb3QgdXNlZCAqLworCXN0cnVjdCBjaXJidWZmIGludGVy cnVwdEV2ZW50OwkvKiBpbnRlcnJ1cHQgY2F1c2VzICovCiAKLSAgICAgICAgc3RydWN0IGNpcmJ1 ZmYgaW50ZXJydXB0RXZlbnQ7ICAvKiBpbnRlcnJ1cHQgY2F1c2VzICovCisJdTMyIHYyNElwU3Rz W0ZTVF9NQVhfUE9SVFNdOwkvKiBWLjI0IGNvbnRyb2wgaW5wdXQgc3RhdHVzICovCisJdTMyIHYy NE9wU3RzW0ZTVF9NQVhfUE9SVFNdOwkvKiBWLjI0IGNvbnRyb2wgb3V0cHV0IHN0YXR1cyAqLwog Ci0gICAgICAgIHUzMiB2MjRJcFN0c1tGU1RfTUFYX1BPUlRTXTsgICAgLyogVi4yNCBjb250cm9s IGlucHV0IHN0YXR1cyAqLwotICAgICAgICB1MzIgdjI0T3BTdHNbRlNUX01BWF9QT1JUU107ICAg IC8qIFYuMjQgY29udHJvbCBvdXRwdXQgc3RhdHVzICovCisJc3RydWN0IHBvcnRfY2ZnIHBvcnRD b25maWdbRlNUX01BWF9QT1JUU107CiAKLSAgICAgICAgc3RydWN0IHBvcnRfY2ZnIHBvcnRDb25m aWdbRlNUX01BWF9QT1JUU107CisJdTE2IGNsb2NrU3RhdHVzW0ZTVF9NQVhfUE9SVFNdOwkvKiBs c2I6IDA9PiBwcmVzZW50LCAxPT4gYWJzZW50ICovCiAKLSAgICAgICAgdTE2IGNsb2NrU3RhdHVz W0ZTVF9NQVhfUE9SVFNdOyAvKiBsc2I6IDA9PiBwcmVzZW50LCAxPT4gYWJzZW50ICovCisJdTE2 IGNhYmxlU3RhdHVzOwkvKiBsc2I6IDA9PiBwcmVzZW50LCAxPT4gYWJzZW50ICovCiAKLSAgICAg ICAgdTE2IGNhYmxlU3RhdHVzOyAgICAgICAgICAgICAgICAvKiBsc2I6IDA9PiBwcmVzZW50LCAx PT4gYWJzZW50ICovCisJdTE2IHR4RGVzY3JJbmRleFtGU1RfTUFYX1BPUlRTXTsJLyogdHJhbnNt aXQgZGVzY3JpcHRvciByaW5nIGluZGV4ICovCisJdTE2IHJ4RGVzY3JJbmRleFtGU1RfTUFYX1BP UlRTXTsJLyogcmVjZWl2ZSBkZXNjcmlwdG9yIHJpbmcgaW5kZXggKi8KIAotICAgICAgICB1MTYg dHhEZXNjckluZGV4W0ZTVF9NQVhfUE9SVFNdOyAvKiB0cmFuc21pdCBkZXNjcmlwdG9yIHJpbmcg aW5kZXggKi8KLSAgICAgICAgdTE2IHJ4RGVzY3JJbmRleFtGU1RfTUFYX1BPUlRTXTsgLyogcmVj ZWl2ZSBkZXNjcmlwdG9yIHJpbmcgaW5kZXggKi8KKwl1MTYgcG9ydE1haWxib3hbRlNUX01BWF9Q T1JUU11bMl07CS8qIGNvbW1hbmQsIG1vZGlmaWVyICovCisJdTE2IGNhcmRNYWlsYm94WzRdOwkv KiBOb3QgdXNlZCAqLwogCi0gICAgICAgIHUxNiBwb3J0TWFpbGJveFtGU1RfTUFYX1BPUlRTXVsy XTsgICAgICAvKiBjb21tYW5kLCBtb2RpZmllciAqLwotICAgICAgICB1MTYgY2FyZE1haWxib3hb NF07ICAgICAgICAgICAgICAgICAgICAgLyogTm90IHVzZWQgKi8KKwkvKiBOdW1iZXIgb2YgdGlt ZXMgdGhlIGNhcmQgdGhpbmtzIHRoZSBob3N0IGhhcworCSAqIG1pc3NlZCBhbiBpbnRlcnJ1cHQg Ynkgbm90IGFja25vd2xlZGdpbmcKKwkgKiB3aXRoaW4gMm1TIChJIGd1ZXNzIE5UIGhhcyBwcm9i bGVtcykKKwkgKi8KKwl1MzIgaW50ZXJydXB0UmV0cnlDb3VudDsKIAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAvKiBOdW1iZXIgb2YgdGltZXMgdGhhdCBjYXJkIHRoaW5rcyB0aGUg aG9zdCBoYXMKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICogbWlzc2VkIGFuIGlu dGVycnVwdCBieSBub3QgYWNrbm93bGVkZ2luZwotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgKiB3aXRoaW4gMm1TIChJIGd1ZXNzIE5UIGhhcyBwcm9ibGVtcykKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICovCi0gICAgICAgIHUzMiBpbnRlcnJ1cHRSZXRyeUNvdW50 OworCS8qIERyaXZlciBwcml2YXRlIGRhdGEgdXNlZCBhcyBhbiBJRC4gV2UnbGwgbm90CisJICog dXNlIHRoaXMgYXMgSSdkIHJhdGhlciBrZWVwIHN1Y2ggdGhpbmdzCisJICogaW4gbWFpbiBtZW1v cnkgcmF0aGVyIHRoYW4gb24gdGhlIFBDSSBidXMKKwkgKi8KKwl1MzIgcG9ydEhhbmRsZVtGU1Rf TUFYX1BPUlRTXTsKIAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBEcml2ZXIg cHJpdmF0ZSBkYXRhIHVzZWQgYXMgYW4gSUQuIFdlJ2xsIG5vdAotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgKiB1c2UgdGhpcyBvbiBMaW51eCBJJ2QgcmF0aGVyIGtlZXAgc3VjaCB0 aGluZ3MKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICogaW4gbWFpbiBtZW1vcnkg cmF0aGVyIHRoYW4gb24gdGhlIFBDSSBidXMKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICovCi0gICAgICAgIHUzMiBwb3J0SGFuZGxlW0ZTVF9NQVhfUE9SVFNdOworCS8qIENvdW50 IG9mIFR4IHVuZGVyZmxvd3MgZm9yIHN0YXRzICovCisJdTMyIHRyYW5zbWl0QnVmZmVyVW5kZXJm bG93W0ZTVF9NQVhfUE9SVFNdOwogCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8q IENvdW50IG9mIFR4IHVuZGVyZmxvd3MgZm9yIHN0YXRzICovCi0gICAgICAgIHUzMiB0cmFuc21p dEJ1ZmZlclVuZGVyZmxvd1tGU1RfTUFYX1BPUlRTXTsKKwkvKiBEZWJvdW5jZWQgVi4yNCBjb250 cm9sIGlucHV0IHN0YXR1cyAqLworCXUzMiB2MjREZWJvdW5jZWRTdHNbRlNUX01BWF9QT1JUU107 CiAKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogRGVib3VuY2VkIFYuMjQgY29u dHJvbCBpbnB1dCBzdGF0dXMgKi8KLSAgICAgICAgdTMyIHYyNERlYm91bmNlZFN0c1tGU1RfTUFY X1BPUlRTXTsKKwkvKiBBZGFwdGVyIGRlYm91bmNlIHRpbWVycy4gRG9uJ3QgdG91Y2ggKi8KKwl1 MzIgY3RzVGltZXJbRlNUX01BWF9QT1JUU107CisJdTMyIGN0c1RpbWVyUnVuW0ZTVF9NQVhfUE9S VFNdOworCXUzMiBkY2RUaW1lcltGU1RfTUFYX1BPUlRTXTsKKwl1MzIgZGNkVGltZXJSdW5bRlNU X01BWF9QT1JUU107CiAKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogQWRhcHRl ciBkZWJvdW5jZSB0aW1lcnMuIERvbid0IHRvdWNoICovCi0gICAgICAgIHUzMiBjdHNUaW1lcltG U1RfTUFYX1BPUlRTXTsKLSAgICAgICAgdTMyIGN0c1RpbWVyUnVuW0ZTVF9NQVhfUE9SVFNdOwot ICAgICAgICB1MzIgZGNkVGltZXJbRlNUX01BWF9QT1JUU107Ci0gICAgICAgIHUzMiBkY2RUaW1l clJ1bltGU1RfTUFYX1BPUlRTXTsKKwl1MzIgbnVtYmVyT2ZQb3J0czsJLyogTnVtYmVyIG9mIHBv cnRzIGRldGVjdGVkIGF0IHN0YXJ0dXAgKi8KIAotICAgICAgICB1MzIgbnVtYmVyT2ZQb3J0czsg ICAgICAvKiBOdW1iZXIgb2YgcG9ydHMgZGV0ZWN0ZWQgYXQgc3RhcnR1cCAqLworCXUxNiBfcmVz ZXJ2ZWRbNjRdOwogCi0gICAgICAgIHUxNiBfcmVzZXJ2ZWRbNjRdOworCXUxNiBjYXJkTW9kZTsJ CS8qIEJpdC1tYXNrIHRvIGVuYWJsZSBmZWF0dXJlczoKKwkJCQkgKiBCaXQgMDogMSBlbmFibGVz IExFRCBpZGVudGlmeSBtb2RlCisJCQkJICovCiAKLSAgICAgICAgdTE2IGNhcmRNb2RlOyAgICAg ICAgICAgLyogQml0LW1hc2sgdG8gZW5hYmxlIGZlYXR1cmVzOgotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgKiBCaXQgMDogMSBlbmFibGVzIExFRCBpZGVudGlmeSBtb2RlCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLworCXUxNiBwb3J0U2NoZWR1bGVPZmZzZXQ7 CiAKLSAgICAgICAgdTE2IHBvcnRTY2hlZHVsZU9mZnNldDsKKwlzdHJ1Y3Qgc3VfY29uZmlnIHN1 Q29uZmlnOwkvKiBURTEgQml0cyAqLworCXN0cnVjdCBzdV9zdGF0dXMgc3VTdGF0dXM7CiAKLSAg ICAgICAgdTMyIGVuZE9mU21jU2lnbmF0dXJlOyAgLyogZW5kT2ZTbWNTaWduYXR1cmUgTVVTVCBi ZSB0aGUgbGFzdCBtZW1iZXIgb2YKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICog dGhlIHN0cnVjdHVyZSBhbmQgbWFya3MgdGhlIGVuZCBvZiB0aGUgc2hhcmVkCi0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAqIG1lbW9yeS4gQWRhcHRlciBjb2RlIGluaXRpYWxpemVz IGl0cyB2YWx1ZSBhcwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKiBFTkRfU0lH LgotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKwl1MzIgZW5kT2ZTbWNTaWdu YXR1cmU7CS8qIGVuZE9mU21jU2lnbmF0dXJlIE1VU1QgYmUgdGhlIGxhc3QgbWVtYmVyIG9mCisJ CQkJICogdGhlIHN0cnVjdHVyZSBhbmQgbWFya3MgdGhlIGVuZCBvZiBzaGFyZWQKKwkJCQkgKiBt ZW1vcnkuIEFkYXB0ZXIgY29kZSBpbml0aWFsaXplcyBpdCBhcworCQkJCSAqIEVORF9TSUcuCisJ CQkJICovCiB9OwogCiAvKiBlbmRPZlNtY1NpZ25hdHVyZSB2YWx1ZSAqLwogI2RlZmluZSBFTkRf U0lHICAgICAgICAgICAgICAgICAweDEyMzQ1Njc4CiAKIC8qIE1haWxib3ggdmFsdWVzLiAocG9y dE1haWxib3gpICovCi0jZGVmaW5lIE5PUCAgICAgICAgICAgICAwICAgICAgIC8qIE5vIG9wZXJh dGlvbiAqLwotI2RlZmluZSBBQ0sgICAgICAgICAgICAgMSAgICAgICAvKiBQb3NpdGl2ZSBhY2tu b3dsZWRnZW1lbnQgdG8gUEMgZHJpdmVyICovCi0jZGVmaW5lIE5BSyAgICAgICAgICAgICAyICAg ICAgIC8qIE5lZ2F0aXZlIGFja25vd2xlZGdlbWVudCB0byBQQyBkcml2ZXIgKi8KLSNkZWZpbmUg U1RBUlRQT1JUICAgICAgIDMgICAgICAgLyogU3RhcnQgYW4gSERMQyBwb3J0ICovCi0jZGVmaW5l IFNUT1BQT1JUICAgICAgICA0ICAgICAgIC8qIFN0b3AgYW4gSERMQyBwb3J0ICovCi0jZGVmaW5l IEFCT1JUVFggICAgICAgICA1ICAgICAgIC8qIEFib3J0IHRoZSB0cmFuc21pdHRlciBmb3IgYSBw b3J0ICovCi0jZGVmaW5lIFNFVFYyNE8gICAgICAgICA2ICAgICAgIC8qIFNldCBWMjQgb3V0cHV0 cyAqLworI2RlZmluZSBOT1AgICAgICAgICAgICAgMAkvKiBObyBvcGVyYXRpb24gKi8KKyNkZWZp bmUgQUNLICAgICAgICAgICAgIDEJLyogUG9zaXRpdmUgYWNrbm93bGVkZ2VtZW50IHRvIFBDIGRy aXZlciAqLworI2RlZmluZSBOQUsgICAgICAgICAgICAgMgkvKiBOZWdhdGl2ZSBhY2tub3dsZWRn ZW1lbnQgdG8gUEMgZHJpdmVyICovCisjZGVmaW5lIFNUQVJUUE9SVCAgICAgICAzCS8qIFN0YXJ0 IGFuIEhETEMgcG9ydCAqLworI2RlZmluZSBTVE9QUE9SVCAgICAgICAgNAkvKiBTdG9wIGFuIEhE TEMgcG9ydCAqLworI2RlZmluZSBBQk9SVFRYICAgICAgICAgNQkvKiBBYm9ydCB0aGUgdHJhbnNt aXR0ZXIgZm9yIGEgcG9ydCAqLworI2RlZmluZSBTRVRWMjRPICAgICAgICAgNgkvKiBTZXQgVjI0 IG91dHB1dHMgKi8KKworLyogUExYIENoaXAgUmVnaXN0ZXIgT2Zmc2V0cyAqLworI2RlZmluZSBD TlRSTF85MDUyICAgICAgMHg1MAkvKiBDb250cm9sIFJlZ2lzdGVyICovCisjZGVmaW5lIENOVFJM XzkwNTQgICAgICAweDZjCS8qIENvbnRyb2wgUmVnaXN0ZXIgKi8KIAorI2RlZmluZSBJTlRDU1Jf OTA1MiAgICAgMHg0YwkvKiBJbnRlcnJ1cHQgY29udHJvbC9zdGF0dXMgcmVnaXN0ZXIgKi8KKyNk ZWZpbmUgSU5UQ1NSXzkwNTQgICAgIDB4NjgJLyogSW50ZXJydXB0IGNvbnRyb2wvc3RhdHVzIHJl Z2lzdGVyICovCisKKy8qIDkwNTQgRE1BIFJlZ2lzdGVycyAqLworLyoKKyAqIE5vdGUgdGhhdCB3 ZSB3aWxsIGJlIHVzaW5nIERNQSBDaGFubmVsIDAgZm9yIGNvcHlpbmcgcnggZGF0YQorICogYW5k IENoYW5uZWwgMSBmb3IgY29weWluZyB0eCBkYXRhCisgKi8KKyNkZWZpbmUgRE1BTU9ERTAgICAg ICAgIDB4ODAKKyNkZWZpbmUgRE1BUEFEUjAgICAgICAgIDB4ODQKKyNkZWZpbmUgRE1BTEFEUjAg ICAgICAgIDB4ODgKKyNkZWZpbmUgRE1BU0laMCAgICAgICAgIDB4OGMKKyNkZWZpbmUgRE1BRFBS MCAgICAgICAgIDB4OTAKKyNkZWZpbmUgRE1BTU9ERTEgICAgICAgIDB4OTQKKyNkZWZpbmUgRE1B UEFEUjEgICAgICAgIDB4OTgKKyNkZWZpbmUgRE1BTEFEUjEgICAgICAgIDB4OWMKKyNkZWZpbmUg RE1BU0laMSAgICAgICAgIDB4YTAKKyNkZWZpbmUgRE1BRFBSMSAgICAgICAgIDB4YTQKKyNkZWZp bmUgRE1BQ1NSMCAgICAgICAgIDB4YTgKKyNkZWZpbmUgRE1BQ1NSMSAgICAgICAgIDB4YTkKKyNk ZWZpbmUgRE1BQVJCICAgICAgICAgIDB4YWMKKyNkZWZpbmUgRE1BVEhSICAgICAgICAgIDB4YjAK KyNkZWZpbmUgRE1BREFDMCAgICAgICAgIDB4YjQKKyNkZWZpbmUgRE1BREFDMSAgICAgICAgIDB4 YjgKKyNkZWZpbmUgRE1BTUFSQlIgICAgICAgIDB4YWMKKworI2RlZmluZSBGU1RfTUlOX0RNQV9M RU4gNjQKKyNkZWZpbmUgRlNUX1JYX0RNQV9JTlQgIDB4MDEKKyNkZWZpbmUgRlNUX1RYX0RNQV9J TlQgIDB4MDIKKyNkZWZpbmUgRlNUX0NBUkRfSU5UICAgIDB4MDQKIAogLyogTGFyZ2VyIGJ1ZmZl cnMgYXJlIHBvc2l0aW9uZWQgaW4gbWVtb3J5IGF0IG9mZnNldCBCRk1fQkFTRSAqLwogc3RydWN0 IGJ1Zl93aW5kb3cgewotICAgICAgICB1OCB0eEJ1ZmZlcltGU1RfTUFYX1BPUlRTXVtOVU1fVFhf QlVGRkVSXVtMRU5fVFhfQlVGRkVSXTsKLSAgICAgICAgdTggcnhCdWZmZXJbRlNUX01BWF9QT1JU U11bTlVNX1JYX0JVRkZFUl1bTEVOX1JYX0JVRkZFUl07CisJdTggdHhCdWZmZXJbRlNUX01BWF9Q T1JUU11bTlVNX1RYX0JVRkZFUl1bTEVOX1RYX0JVRkZFUl07CisJdTggcnhCdWZmZXJbRlNUX01B WF9QT1JUU11bTlVNX1JYX0JVRkZFUl1bTEVOX1JYX0JVRkZFUl07CiB9OwogCiAvKiBDYWxjdWxh dGUgb2Zmc2V0IG9mIGEgYnVmZmVyIG9iamVjdCB3aXRoaW4gdGhlIHNoYXJlZCBtZW1vcnkgd2lu ZG93ICovCi0jZGVmaW5lIEJVRl9PRkZTRVQoWCkgICBvZmZzZXRvZihzdHJ1Y3QgYnVmX3dpbmRv dywgWCkKKyNkZWZpbmUgQlVGX09GRlNFVChYKSAgICgodW5zaWduZWQgaW50KSYoKChzdHJ1Y3Qg YnVmX3dpbmRvdyAqKUJGTV9CQVNFKS0+WCkpCiAKICNwcmFnbWEgcGFjaygpCiAKLQogLyogICAg ICBEZXZpY2UgZHJpdmVyIHByaXZhdGUgaW5mb3JtYXRpb24KICAqICAgICAgPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09CiAgKi8KIC8qICAgICAgUGVyIHBvcnQgKGxpbmUgb3IgY2hh bm5lbCkgaW5mb3JtYXRpb24KICAqLwogc3RydWN0IGZzdF9wb3J0X2luZm8gewotICAgICAgICBz dHJ1Y3QgbmV0X2RldmljZSAgICAgICpkZXY7Ci0gICAgICAgIHN0cnVjdCBmc3RfY2FyZF9pbmZv ICAgKmNhcmQ7ICAgLyogQ2FyZCB3ZSdyZSBhc3NvY2lhdGVkIHdpdGggKi8KLSAgICAgICAgaW50 ICAgICAgICAgICAgICAgICAgICAgaW5kZXg7ICAvKiBQb3J0IGluZGV4IG9uIHRoZSBjYXJkICov Ci0gICAgICAgIGludCAgICAgICAgICAgICAgICAgICAgIGh3aWY7ICAgLyogTGluZSBoYXJkd2Fy ZSAobGluZUludGVyZmFjZSBjb3B5KSAqLwotICAgICAgICBpbnQgICAgICAgICAgICAgICAgICAg ICBydW47ICAgIC8qIFBvcnQgaXMgcnVubmluZyAqLwotICAgICAgICBpbnQgICAgICAgICAgICAg ICAgICAgICByeHBvczsgIC8qIE5leHQgUnggYnVmZmVyIHRvIHVzZSAqLwotICAgICAgICBpbnQg ICAgICAgICAgICAgICAgICAgICB0eHBvczsgIC8qIE5leHQgVHggYnVmZmVyIHRvIHVzZSAqLwot ICAgICAgICBpbnQgICAgICAgICAgICAgICAgICAgICB0eGlwb3M7IC8qIE5leHQgVHggYnVmZmVy IHRvIGNoZWNrIGZvciBmcmVlICovCi0gICAgICAgIGludCAgICAgICAgICAgICAgICAgICAgIHR4 Y250OyAgLyogQ291bnQgb2YgVHggYnVmZmVycyBpbiB1c2UgKi8KKyAgICAgICAgc3RydWN0IG5l dF9kZXZpY2UgKmRldjsgLyogRGV2aWNlIHN0cnVjdCAtIG11c3QgYmUgZmlyc3QgKi8KKwlzdHJ1 Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZDsJLyogQ2FyZCB3ZSdyZSBhc3NvY2lhdGVkIHdpdGggKi8K KwlpbnQgaW5kZXg7CQkvKiBQb3J0IGluZGV4IG9uIHRoZSBjYXJkICovCisJaW50IGh3aWY7CQkv KiBMaW5lIGhhcmR3YXJlIChsaW5lSW50ZXJmYWNlIGNvcHkpICovCisJaW50IHJ1bjsJCS8qIFBv cnQgaXMgcnVubmluZyAqLworCWludCBtb2RlOwkJLyogTm9ybWFsIG9yIEZhclN5bmMgcmF3ICov CisJaW50IHJ4cG9zOwkJLyogTmV4dCBSeCBidWZmZXIgdG8gdXNlICovCisJaW50IHR4cG9zOwkJ LyogTmV4dCBUeCBidWZmZXIgdG8gdXNlICovCisJaW50IHR4aXBvczsJCS8qIE5leHQgVHggYnVm ZmVyIHRvIGNoZWNrIGZvciBmcmVlICovCisJaW50IHN0YXJ0OwkJLyogSW5kaWNhdGlvbiBvZiBz dGFydC9zdG9wIHRvIG5ldHdvcmsgKi8KKwkvKgorCSAqIEEgc2l4dGVlbiBlbnRyeSB0cmFuc21p dCBxdWV1ZQorCSAqLworCWludCB0eHFzOwkJLyogaW5kZXggdG8gZ2V0IG5leHQgYnVmZmVyIHRv IHR4ICovCisJaW50IHR4cWU7CQkvKiBpbmRleCB0byBxdWV1ZSBuZXh0IHBhY2tldCAqLworCXN0 cnVjdCBza19idWZmICp0eHFbRlNUX1RYUV9ERVBUSF07CS8qIFRoZSBxdWV1ZSAqLworCWludCBy eHFkZXB0aDsKIH07CiAKIC8qICAgICAgUGVyIGNhcmQgaW5mb3JtYXRpb24KICAqLwogc3RydWN0 IGZzdF9jYXJkX2luZm8gewotICAgICAgICBjaGFyICAgICAgICAgICptZW07ICAgICAgICAgICAg IC8qIENhcmQgbWVtb3J5IG1hcHBlZCB0byBrZXJuZWwgc3BhY2UgKi8KLSAgICAgICAgY2hhciAg ICAgICAgICAqY3RsbWVtOyAgICAgICAgICAvKiBDb250cm9sIG1lbW9yeSBmb3IgUENJIGNhcmRz ICovCi0gICAgICAgIHVuc2lnbmVkIGludCAgIHBoeXNfbWVtOyAgICAgICAgLyogUGh5c2ljYWwg bWVtb3J5IHdpbmRvdyBhZGRyZXNzICovCi0gICAgICAgIHVuc2lnbmVkIGludCAgIHBoeXNfY3Rs bWVtOyAgICAgLyogUGh5c2ljYWwgY29udHJvbCBtZW1vcnkgYWRkcmVzcyAqLwotICAgICAgICB1 bnNpZ25lZCBpbnQgICBpcnE7ICAgICAgICAgICAgIC8qIEludGVycnVwdCByZXF1ZXN0IGxpbmUg bnVtYmVyICovCi0gICAgICAgIHVuc2lnbmVkIGludCAgIG5wb3J0czsgICAgICAgICAgLyogTnVt YmVyIG9mIHNlcmlhbCBwb3J0cyAqLwotICAgICAgICB1bnNpZ25lZCBpbnQgICB0eXBlOyAgICAg ICAgICAgIC8qIFR5cGUgaW5kZXggb2YgY2FyZCAqLwotICAgICAgICB1bnNpZ25lZCBpbnQgICBz dGF0ZTsgICAgICAgICAgIC8qIFN0YXRlIG9mIGNhcmQgKi8KLSAgICAgICAgc3BpbmxvY2tfdCAg ICAgY2FyZF9sb2NrOyAgICAgICAvKiBMb2NrIGZvciBTTVAgYWNjZXNzICovCi0gICAgICAgIHVu c2lnbmVkIHNob3J0IHBjaV9jb25mOyAgICAgICAgLyogUENJIGNhcmQgY29uZmlnIGluIEkvTyBz cGFjZSAqLwotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIFBlciBw b3J0IGluZm8gKi8KLSAgICAgICAgc3RydWN0IGZzdF9wb3J0X2luZm8gcG9ydHNbIEZTVF9NQVhf UE9SVFMgXTsKKwljaGFyICptZW07CQkvKiBDYXJkIG1lbW9yeSBtYXBwZWQgdG8ga2VybmVsIHNw YWNlICovCisJY2hhciAqY3RsbWVtOwkJLyogQ29udHJvbCBtZW1vcnkgZm9yIFBDSSBjYXJkcyAq LworCXVuc2lnbmVkIGludCBwaHlzX21lbTsJLyogUGh5c2ljYWwgbWVtb3J5IHdpbmRvdyBhZGRy ZXNzICovCisJdW5zaWduZWQgaW50IHBoeXNfY3RsbWVtOwkvKiBQaHlzaWNhbCBjb250cm9sIG1l bW9yeSBhZGRyZXNzICovCisJdW5zaWduZWQgaW50IGlycTsJLyogSW50ZXJydXB0IHJlcXVlc3Qg bGluZSBudW1iZXIgKi8KKwl1bnNpZ25lZCBpbnQgbnBvcnRzOwkvKiBOdW1iZXIgb2Ygc2VyaWFs IHBvcnRzICovCisJdW5zaWduZWQgaW50IHR5cGU7CS8qIFR5cGUgaW5kZXggb2YgY2FyZCAqLwor CXVuc2lnbmVkIGludCBzdGF0ZTsJLyogU3RhdGUgb2YgY2FyZCAqLworCXNwaW5sb2NrX3QgY2Fy ZF9sb2NrOwkvKiBMb2NrIGZvciBTTVAgYWNjZXNzICovCisJdW5zaWduZWQgc2hvcnQgcGNpX2Nv bmY7CS8qIFBDSSBjYXJkIGNvbmZpZyBpbiBJL08gc3BhY2UgKi8KKwkvKiBQZXIgcG9ydCBpbmZv ICovCisJc3RydWN0IGZzdF9wb3J0X2luZm8gcG9ydHNbRlNUX01BWF9QT1JUU107CisJc3RydWN0 IHBjaV9kZXYgKmRldmljZTsJLyogSW5mb3JtYXRpb24gYWJvdXQgdGhlIHBjaSBkZXZpY2UgKi8K KwlpbnQgY2FyZF9ubzsJCS8qIEluc3Qgb2YgdGhlIGNhcmQgb24gdGhlIHN5c3RlbSAqLworCWlu dCBmYW1pbHk7CQkvKiBUeFAgb3IgVHhVICovCisJaW50IGRtYXJ4X2luX3Byb2dyZXNzOworCWlu dCBkbWF0eF9pbl9wcm9ncmVzczsKKwl1bnNpZ25lZCBsb25nIGludF9jb3VudDsKKwl1bnNpZ25l ZCBsb25nIGludF90aW1lX2F2ZTsKKwl2b2lkICpyeF9kbWFfaGFuZGxlX2hvc3Q7CisJZG1hX2Fk ZHJfdCByeF9kbWFfaGFuZGxlX2NhcmQ7CisJdm9pZCAqdHhfZG1hX2hhbmRsZV9ob3N0OworCWRt YV9hZGRyX3QgdHhfZG1hX2hhbmRsZV9jYXJkOworCXN0cnVjdCBza19idWZmICpkbWFfc2tiX3J4 OworCXN0cnVjdCBmc3RfcG9ydF9pbmZvICpkbWFfcG9ydF9yeDsKKwlzdHJ1Y3QgZnN0X3BvcnRf aW5mbyAqZG1hX3BvcnRfdHg7CisJaW50IGRtYV9sZW5fcng7CisJaW50IGRtYV9sZW5fdHg7CisJ aW50IGRtYV90eHBvczsKKwlpbnQgZG1hX3J4cG9zOwogfTsKIAogLyogQ29udmVydCBhbiBIRExD IGRldmljZSBwb2ludGVyIGludG8gYSBwb3J0IGluZm8gcG9pbnRlciBhbmQgc2ltaWxhciAqLwpA QCAtMzgwLDcgKzQ5OCw2IEBACiAjZGVmaW5lIEZTVF9XUlcoQyxFLFcpICB3cml0ZXcgKChXKSwg KEMpLT5tZW0gKyBXSU5fT0ZGU0VUKEUpKQogI2RlZmluZSBGU1RfV1JMKEMsRSxMKSAgd3JpdGVs ICgoTCksIChDKS0+bWVtICsgV0lOX09GRlNFVChFKSkKIAotCiAvKgogICogICAgICBEZWJ1ZyBz dXBwb3J0CiAgKi8KQEAgLTM5OSwzMCArNTE2LDE1MSBAQAogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBwcmludGsgKCBLRVJOX0RFQlVHIEZTVF9OQU1FICI6ICIgZm10LCAjIyBBICkK IAogI2Vsc2UKLSMgZGVmaW5lIGRiZyhYLi4uKSAgICAgIC8qIE5PUCAqLworI2RlZmluZSBkYmco WC4uLikJCS8qIE5PUCAqLwogI2VuZGlmCiAKLQogLyogICAgICBQcmludGluZyBzaG9ydCBjdXRz CiAgKi8KICNkZWZpbmUgcHJpbnRrX2VycihmbXQsQS4uLikgICAgcHJpbnRrICggS0VSTl9FUlIg ICAgIEZTVF9OQU1FICI6ICIgZm10LCAjIyBBICkKICNkZWZpbmUgcHJpbnRrX3dhcm4oZm10LEEu Li4pICAgcHJpbnRrICggS0VSTl9XQVJOSU5HIEZTVF9OQU1FICI6ICIgZm10LCAjIyBBICkKICNk ZWZpbmUgcHJpbnRrX2luZm8oZm10LEEuLi4pICAgcHJpbnRrICggS0VSTl9JTkZPICAgIEZTVF9O QU1FICI6ICIgZm10LCAjIyBBICkKIAotCiAvKgogICogICAgICBQQ0kgSUQgbG9va3VwIHRhYmxl CiAgKi8KLXN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBmc3RfcGNpX2Rldl9pZFtdID0gewot ICAgICAgICB7IEZTQ19QQ0lfVkVORE9SX0lELCBUMlBfUENJX0RFVklDRV9JRCwgUENJX0FOWV9J RCwgUENJX0FOWV9JRCwgMCwgMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBGU1RfVFlQRV9UMlAgfSwKLSAgICAgICAgeyBGU0NfUENJX1ZFTkRPUl9JRCwgVDRQX1BD SV9ERVZJQ0VfSUQsIFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgRlNUX1RZUEVfVDRQIH0sCi0gICAgICAgIHsgMCwg fSAgICAgICAgICAgICAgICAgICAgICAgICAgLyogRW5kICovCitzdGF0aWMgc3RydWN0IHBjaV9k ZXZpY2VfaWQgZnN0X3BjaV9kZXZfaWRbXSBfX2RldmluaXRkYXRhID0geworCXtQQ0lfVkVORE9S X0lEX0ZBUlNJVEUsIFBDSV9ERVZJQ0VfSURfRkFSU0lURV9UMlAsIFBDSV9BTllfSUQsIAorCSBQ Q0lfQU5ZX0lELCAwLCAwLCBGU1RfVFlQRV9UMlB9LAorCisJe1BDSV9WRU5ET1JfSURfRkFSU0lU RSwgUENJX0RFVklDRV9JRF9GQVJTSVRFX1Q0UCwgUENJX0FOWV9JRCwgCisJIFBDSV9BTllfSUQs IDAsIDAsIEZTVF9UWVBFX1Q0UH0sCisKKwl7UENJX1ZFTkRPUl9JRF9GQVJTSVRFLCBQQ0lfREVW SUNFX0lEX0ZBUlNJVEVfVDFVLCBQQ0lfQU5ZX0lELCAKKwkgUENJX0FOWV9JRCwgMCwgMCwgRlNU X1RZUEVfVDFVfSwKKworCXtQQ0lfVkVORE9SX0lEX0ZBUlNJVEUsIFBDSV9ERVZJQ0VfSURfRkFS U0lURV9UMlUsIFBDSV9BTllfSUQsIAorCSBQQ0lfQU5ZX0lELCAwLCAwLCBGU1RfVFlQRV9UMlV9 LAorCisJe1BDSV9WRU5ET1JfSURfRkFSU0lURSwgUENJX0RFVklDRV9JRF9GQVJTSVRFX1Q0VSwg UENJX0FOWV9JRCwgCisJIFBDSV9BTllfSUQsIDAsIDAsIEZTVF9UWVBFX1Q0VX0sCisKKwl7UENJ X1ZFTkRPUl9JRF9GQVJTSVRFLCBQQ0lfREVWSUNFX0lEX0ZBUlNJVEVfVEUxLCBQQ0lfQU5ZX0lE LCAKKwkgUENJX0FOWV9JRCwgMCwgMCwgRlNUX1RZUEVfVEUxfSwKKworCXtQQ0lfVkVORE9SX0lE X0ZBUlNJVEUsIFBDSV9ERVZJQ0VfSURfRkFSU0lURV9URTFDLCBQQ0lfQU5ZX0lELCAKKwkgUENJ X0FOWV9JRCwgMCwgMCwgRlNUX1RZUEVfVEUxfSwKKwl7MCx9CQkJLyogRW5kICovCiB9OwogCi1N T0RVTEVfREVWSUNFX1RBQkxFICggcGNpLCBmc3RfcGNpX2Rldl9pZCApOworTU9EVUxFX0RFVklD RV9UQUJMRShwY2ksIGZzdF9wY2lfZGV2X2lkKTsKKworLyoKKyAqICAgICAgRGV2aWNlIERyaXZl ciBXb3JrIFF1ZXVlcworICoKKyAqICAgICAgU28gdGhhdCB3ZSBkb24ndCBzcGVuZCB0b28gbXVj aCB0aW1lIHByb2Nlc3NpbmcgZXZlbnRzIGluIHRoZSAKKyAqICAgICAgSW50ZXJydXB0IFNlcnZp Y2Ugcm91dGluZSwgd2Ugd2lsbCBkZWNsYXJlIGEgd29yayBxdWV1ZSBwZXIgQ2FyZCAKKyAqICAg ICAgYW5kIG1ha2UgdGhlIElTUiBzY2hlZHVsZSBhIHRhc2sgaW4gdGhlIHF1ZXVlIGZvciBsYXRl ciBleGVjdXRpb24uCisgKiAgICAgIEluIHRoZSAyLjQgS2VybmVsIHdlIHVzZWQgdG8gdXNlIHRo ZSBpbW1lZGlhdGUgcXVldWUgZm9yIEJIJ3MKKyAqICAgICAgTm93IHRoYXQgdGhleSBhcmUgZ29u ZSwgdGFza2xldHMgc2VlbSB0byBiZSBtdWNoIGJldHRlciB0aGFuIHdvcmsgCisgKiAgICAgIHF1 ZXVlcy4KKyAqLworCitzdGF0aWMgdm9pZCBkb19ib3R0b21faGFsZl90eChzdHJ1Y3QgZnN0X2Nh cmRfaW5mbyAqY2FyZCk7CitzdGF0aWMgdm9pZCBkb19ib3R0b21faGFsZl9yeChzdHJ1Y3QgZnN0 X2NhcmRfaW5mbyAqY2FyZCk7CitzdGF0aWMgdm9pZCBmc3RfcHJvY2Vzc190eF93b3JrX3EodW5z aWduZWQgbG9uZyB3b3JrX3EpOworc3RhdGljIHZvaWQgZnN0X3Byb2Nlc3NfaW50X3dvcmtfcSh1 bnNpZ25lZCBsb25nIHdvcmtfcSk7CisKK0RFQ0xBUkVfVEFTS0xFVChmc3RfdHhfdGFzaywgZnN0 X3Byb2Nlc3NfdHhfd29ya19xLCAwKTsKK0RFQ0xBUkVfVEFTS0xFVChmc3RfaW50X3Rhc2ssIGZz dF9wcm9jZXNzX2ludF93b3JrX3EsIDApOworCitzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqZnN0X2Nh cmRfYXJyYXlbRlNUX01BWF9DQVJEU107CitzcGlubG9ja190IGZzdF93b3JrX3FfbG9jazsKK3U2 NCBmc3Rfd29ya190eHE7Cit1NjQgZnN0X3dvcmtfaW50cTsKKworc3RhdGljIHZvaWQKK2ZzdF9x X3dvcmtfaXRlbSh1NjQgKiBxdWV1ZSwgaW50IGNhcmRfaW5kZXgpCit7CisJdW5zaWduZWQgbG9u ZyBmbGFnczsKKwl1NjQgbWFzazsKKworCS8qCisJICogR3JhYiB0aGUgcXVldWUgZXhjbHVzaXZl bHkKKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnN0X3dvcmtfcV9sb2NrLCBmbGFncyk7CisK KwkvKgorCSAqIE1ha2luZyBhbiBlbnRyeSBpbiB0aGUgcXVldWUgaXMgc2ltcGx5IGEgbWF0dGVy IG9mIHNldHRpbmcKKwkgKiBhIGJpdCBmb3IgdGhlIGNhcmQgaW5kaWNhdGluZyB0aGF0IHRoZXJl IGlzIHdvcmsgdG8gZG8gaW4gdGhlCisJICogYm90dG9tIGhhbGYgZm9yIHRoZSBjYXJkLiAgTm90 ZSB0aGUgbGltaXRhdGlvbiBvZiA2NCBjYXJkcy4KKwkgKiBUaGF0IG91Z2h0IHRvIGJlIGVub3Vn aAorCSAqLworCW1hc2sgPSAxIDw8IGNhcmRfaW5kZXg7CisJKnF1ZXVlIHw9IG1hc2s7CisJc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZnN0X3dvcmtfcV9sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRp YyB2b2lkCitmc3RfcHJvY2Vzc190eF93b3JrX3EodW5zaWduZWQgbG9uZyAvKnZvaWQgKiovd29y a19xKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdTY0IHdvcmtfdHhxOworCWludCBpOwor CisJLyoKKwkgKiBHcmFiIHRoZSBxdWV1ZSBleGNsdXNpdmVseQorCSAqLworCWRiZyhEQkdfVFgs ICJmc3RfcHJvY2Vzc190eF93b3JrX3FcbiIpOworCXNwaW5fbG9ja19pcnFzYXZlKCZmc3Rfd29y a19xX2xvY2ssIGZsYWdzKTsKKwl3b3JrX3R4cSA9IGZzdF93b3JrX3R4cTsKKwlmc3Rfd29ya190 eHEgPSAwOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZzdF93b3JrX3FfbG9jaywgZmxhZ3Mp OworCisJLyoKKwkgKiBDYWxsIHRoZSBib3R0b20gaGFsZiBmb3IgZWFjaCBjYXJkIHdpdGggd29y ayB3YWl0aW5nCisJICovCisJZm9yIChpID0gMDsgaSA8IEZTVF9NQVhfQ0FSRFM7IGkrKykgewor CQlpZiAod29ya190eHEgJiAweDAxKSB7CisJCQlpZiAoZnN0X2NhcmRfYXJyYXlbaV0gIT0gTlVM TCkgeworCQkJCWRiZyhEQkdfVFgsICJDYWxsaW5nIHR4IGJoIGZvciBjYXJkICVkXG4iLCBpKTsK KwkJCQlkb19ib3R0b21faGFsZl90eChmc3RfY2FyZF9hcnJheVtpXSk7CisJCQl9CisJCX0KKwkJ d29ya190eHEgPSB3b3JrX3R4cSA+PiAxOworCX0KK30KIAorc3RhdGljIHZvaWQKK2ZzdF9wcm9j ZXNzX2ludF93b3JrX3EodW5zaWduZWQgbG9uZyAvKnZvaWQgKiovd29ya19xKQoreworCXVuc2ln bmVkIGxvbmcgZmxhZ3M7CisJdTY0IHdvcmtfaW50cTsKKwlpbnQgaTsKKworCS8qCisJICogR3Jh YiB0aGUgcXVldWUgZXhjbHVzaXZlbHkKKwkgKi8KKwlkYmcoREJHX0lOVFIsICJmc3RfcHJvY2Vz c19pbnRfd29ya19xXG4iKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnN0X3dvcmtfcV9sb2NrLCBm bGFncyk7CisJd29ya19pbnRxID0gZnN0X3dvcmtfaW50cTsKKwlmc3Rfd29ya19pbnRxID0gMDsK KwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmc3Rfd29ya19xX2xvY2ssIGZsYWdzKTsKKworCS8q CisJICogQ2FsbCB0aGUgYm90dG9tIGhhbGYgZm9yIGVhY2ggY2FyZCB3aXRoIHdvcmsgd2FpdGlu ZworCSAqLworCWZvciAoaSA9IDA7IGkgPCBGU1RfTUFYX0NBUkRTOyBpKyspIHsKKwkJaWYgKHdv cmtfaW50cSAmIDB4MDEpIHsKKwkJCWlmIChmc3RfY2FyZF9hcnJheVtpXSAhPSBOVUxMKSB7CisJ CQkJZGJnKERCR19JTlRSLAorCQkJCSAgICAiQ2FsbGluZyByeCAmIHR4IGJoIGZvciBjYXJkICVk XG4iLCBpKTsKKwkJCQlkb19ib3R0b21faGFsZl9yeChmc3RfY2FyZF9hcnJheVtpXSk7CisJCQkJ ZG9fYm90dG9tX2hhbGZfdHgoZnN0X2NhcmRfYXJyYXlbaV0pOworCQkJfQorCQl9CisJCXdvcmtf aW50cSA9IHdvcmtfaW50cSA+PiAxOworCX0KK30KIAogLyogICAgICBDYXJkIGNvbnRyb2wgZnVu Y3Rpb25zCiAgKiAgICAgID09PT09PT09PT09PT09PT09PT09PT0KQEAgLTQzMiwxMDA1ICs2NzAs MTcyNSBAQAogICogVXNlZCB0byBiZSBhIHNpbXBsZSB3cml0ZSB0byBjYXJkIGNvbnRyb2wgc3Bh Y2UgYnV0IGEgZ2xpdGNoIGluIHRoZSBsYXRlc3QKICAqIEFNRCBBbTE4NkNIIHByb2Nlc3NvciBt ZWFucyB0aGF0IHdlIG5vdyBoYXZlIHRvIGRvIGl0IGJ5IGFzc2VydGluZyBhbmQgZGUtCiAgKiBh c3NlcnRpbmcgdGhlIFBMWCBjaGlwIFBDSSBBZGFwdGVyIFNvZnR3YXJlIFJlc2V0LiBCaXQgMzAg aW4gQ05UUkwgcmVnaXN0ZXIKLSAqIGF0IG9mZnNldCAweDUwLgorICogYXQgb2Zmc2V0IDkwNTJf Q05UUkwuICBOb3RlIHRoZSB1cGRhdGVzIGZvciB0aGUgVFhVLgogICovCiBzdGF0aWMgaW5saW5l IHZvaWQKLWZzdF9jcHVyZXNldCAoIHN0cnVjdCBmc3RfY2FyZF9pbmZvICpjYXJkICkKK2ZzdF9j cHVyZXNldChzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCkKIHsKLSAgICAgICAgdW5zaWduZWQg aW50IHJlZ3ZhbDsKKwl1bnNpZ25lZCBjaGFyIGludGVycnVwdF9saW5lX3JlZ2lzdGVyOworCXVu c2lnbmVkIGxvbmcgaiA9IGppZmZpZXMgKyAxOworCXVuc2lnbmVkIGludCByZWd2YWw7CisKKwlp ZiAoY2FyZC0+ZmFtaWx5ID09IEZTVF9GQU1JTFlfVFhVKSB7CisJCWlmIChwY2lfcmVhZF9jb25m aWdfYnl0ZQorCQkgICAgKGNhcmQtPmRldmljZSwgUENJX0lOVEVSUlVQVF9MSU5FLCAmaW50ZXJy dXB0X2xpbmVfcmVnaXN0ZXIpKSB7CisJCQlkYmcoREJHX0FTUywKKwkJCSAgICAiRXJyb3IgaW4g cmVhZGluZyBpbnRlcnJ1cHQgbGluZSByZWdpc3RlclxuIik7CisJCX0KKwkJLyoKKwkJICogQXNz ZXJ0IFBMWCBzb2Z0d2FyZSByZXNldCBhbmQgQW0xODYgaGFyZHdhcmUgcmVzZXQKKwkJICogYW5k IHRoZW4gZGVhc3NlcnQgdGhlIFBMWCBzb2Z0d2FyZSByZXNldCBidXQgMTg2IHN0aWxsIGluIHJl c2V0CisJCSAqLworCQlvdXR3KDB4NDQwZiwgY2FyZC0+cGNpX2NvbmYgKyBDTlRSTF85MDU0ICsg Mik7CisJCW91dHcoMHgwNDBmLCBjYXJkLT5wY2lfY29uZiArIENOVFJMXzkwNTQgKyAyKTsKKwkJ LyoKKwkJICogV2UgYXJlIGRlbGF5aW5nIGhlcmUgdG8gYWxsb3cgdGhlIDkwNTQgdG8gcmVzZXQg aXRzZWxmCisJCSAqLworCQlqID0gamlmZmllcyArIDE7CisJCXdoaWxlIChqaWZmaWVzIDwgaikK KwkJCS8qIERvIG5vdGhpbmcgKi8gOworCQlvdXR3KDB4MjQwZiwgY2FyZC0+cGNpX2NvbmYgKyBD TlRSTF85MDU0ICsgMik7CisJCS8qCisJCSAqIFdlIGFyZSBkZWxheWluZyBoZXJlIHRvIGFsbG93 IHRoZSA5MDU0IHRvIHJlbG9hZCBpdHMgZWVwcm9tCisJCSAqLworCQlqID0gamlmZmllcyArIDE7 CisJCXdoaWxlIChqaWZmaWVzIDwgaikKKwkJCS8qIERvIG5vdGhpbmcgKi8gOworCQlvdXR3KDB4 MDQwZiwgY2FyZC0+cGNpX2NvbmYgKyBDTlRSTF85MDU0ICsgMik7CisKKwkJaWYgKHBjaV93cml0 ZV9jb25maWdfYnl0ZQorCQkgICAgKGNhcmQtPmRldmljZSwgUENJX0lOVEVSUlVQVF9MSU5FLCBp bnRlcnJ1cHRfbGluZV9yZWdpc3RlcikpIHsKKwkJCWRiZyhEQkdfQVNTLAorCQkJICAgICJFcnJv ciBpbiB3cml0aW5nIGludGVycnVwdCBsaW5lIHJlZ2lzdGVyXG4iKTsKKwkJfQogCi0gICAgICAg IHJlZ3ZhbCA9IGlubCAoIGNhcmQtPnBjaV9jb25mICsgMHg1MCApOworCX0gZWxzZSB7CisJCXJl Z3ZhbCA9IGlubChjYXJkLT5wY2lfY29uZiArIENOVFJMXzkwNTIpOwogCi0gICAgICAgIG91dGwg KCByZWd2YWwgfCAgMHg0MDAwMDAwMCwgY2FyZC0+cGNpX2NvbmYgKyAweDUwICk7Ci0gICAgICAg IG91dGwgKCByZWd2YWwgJiB+MHg0MDAwMDAwMCwgY2FyZC0+cGNpX2NvbmYgKyAweDUwICk7CisJ CW91dGwocmVndmFsIHwgMHg0MDAwMDAwMCwgY2FyZC0+cGNpX2NvbmYgKyBDTlRSTF85MDUyKTsK KwkJb3V0bChyZWd2YWwgJiB+MHg0MDAwMDAwMCwgY2FyZC0+cGNpX2NvbmYgKyBDTlRSTF85MDUy KTsKKwl9CiB9CiAKIC8qICAgICAgUmVsZWFzZSB0aGUgcHJvY2Vzc29yIGZyb20gcmVzZXQKICAq Lwogc3RhdGljIGlubGluZSB2b2lkCi1mc3RfY3B1cmVsZWFzZSAoIHN0cnVjdCBmc3RfY2FyZF9p bmZvICpjYXJkICkKK2ZzdF9jcHVyZWxlYXNlKHN0cnVjdCBmc3RfY2FyZF9pbmZvICpjYXJkKQog ewotICAgICAgICAodm9pZCkgcmVhZGIgKCBjYXJkLT5jdGxtZW0gKTsKKwlpZiAoY2FyZC0+ZmFt aWx5ID09IEZTVF9GQU1JTFlfVFhVKSB7CisJCS8qCisJCSAqIEZvcmNlIHBvc3RlZCB3cml0ZXMg dG8gY29tcGxldGUKKwkJICovCisJCSh2b2lkKSByZWFkYihjYXJkLT5tZW0pOworCisJCS8qCisJ CSAqIFJlbGVhc2UgTFJFU0VUIERPID0gMQorCQkgKiBUaGVuIHJlbGVhc2UgTG9jYWwgSG9sZCwg RE8gPSAxCisJCSAqLworCQlvdXR3KDB4MDQwZSwgY2FyZC0+cGNpX2NvbmYgKyBDTlRSTF85MDU0 ICsgMik7CisJCW91dHcoMHgwNDBmLCBjYXJkLT5wY2lfY29uZiArIENOVFJMXzkwNTQgKyAyKTsK Kwl9IGVsc2UgeworCQkodm9pZCkgcmVhZGIoY2FyZC0+Y3RsbWVtKTsKKwl9CiB9CiAKIC8qICAg ICAgQ2xlYXIgdGhlIGNhcmRzIGludGVycnVwdCBmbGFnCiAgKi8KIHN0YXRpYyBpbmxpbmUgdm9p ZAotZnN0X2NsZWFyX2ludHIgKCBzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCApCitmc3RfY2xl YXJfaW50cihzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCkKK3sKKwlpZiAoY2FyZC0+ZmFtaWx5 ID09IEZTVF9GQU1JTFlfVFhVKSB7CisJCSh2b2lkKSByZWFkYihjYXJkLT5jdGxtZW0pOworCX0g ZWxzZSB7CisJCS8qIFBva2UgdGhlIGFwcHJvcHJpYXRlIFBMWCBjaGlwIHJlZ2lzdGVyIChzYW1l IGFzIGVuYWJsaW5nIGludGVycnVwdHMpCisJCSAqLworCQlvdXR3KDB4MDU0MywgY2FyZC0+cGNp X2NvbmYgKyBJTlRDU1JfOTA1Mik7CisJfQorfQorCisvKiAgICAgIEVuYWJsZSBjYXJkIGludGVy cnVwdHMKKyAqLworc3RhdGljIGlubGluZSB2b2lkCitmc3RfZW5hYmxlX2ludHIoc3RydWN0IGZz dF9jYXJkX2luZm8gKmNhcmQpCiB7Ci0gICAgICAgIC8qIFBva2UgdGhlIGFwcHJvcHJpYXRlIFBM WCBjaGlwIHJlZ2lzdGVyIChzYW1lIGFzIGVuYWJsaW5nIGludGVycnVwdHMpCi0gICAgICAgICAq LwotICAgICAgICBvdXR3ICggMHgwNTQzLCBjYXJkLT5wY2lfY29uZiArIDB4NEMgKTsKKwlpZiAo Y2FyZC0+ZmFtaWx5ID09IEZTVF9GQU1JTFlfVFhVKSB7CisJCW91dGwoMHgwZjBjMDkwMCwgY2Fy ZC0+cGNpX2NvbmYgKyBJTlRDU1JfOTA1NCk7CisJfSBlbHNlIHsKKwkJb3V0dygweDA1NDMsIGNh cmQtPnBjaV9jb25mICsgSU5UQ1NSXzkwNTIpOworCX0KIH0KIAogLyogICAgICBEaXNhYmxlIGNh cmQgaW50ZXJydXB0cwogICovCiBzdGF0aWMgaW5saW5lIHZvaWQKLWZzdF9kaXNhYmxlX2ludHIg KCBzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCApCitmc3RfZGlzYWJsZV9pbnRyKHN0cnVjdCBm c3RfY2FyZF9pbmZvICpjYXJkKQoreworCWlmIChjYXJkLT5mYW1pbHkgPT0gRlNUX0ZBTUlMWV9U WFUpIHsKKwkJb3V0bCgweDAwMDAwMDAwLCBjYXJkLT5wY2lfY29uZiArIElOVENTUl85MDU0KTsK Kwl9IGVsc2UgeworCQlvdXR3KDB4MDAwMCwgY2FyZC0+cGNpX2NvbmYgKyBJTlRDU1JfOTA1Mik7 CisJfQorfQorCisvKiAgICAgIFByb2Nlc3MgdGhlIHJlc3VsdCBvZiB0cnlpbmcgdG8gcGFzcyBh IHJlY2lldmVkIGZyYW1lIHVwIHRoZSBzdGFjaworICovCitzdGF0aWMgdm9pZAorZnN0X3Byb2Nl c3Nfcnhfc3RhdHVzKGludCByeF9zdGF0dXMsIGNoYXIgKm5hbWUpCiB7Ci0gICAgICAgIG91dHcg KCAweDAwMDAsIGNhcmQtPnBjaV9jb25mICsgMHg0QyApOworCXN3aXRjaCAocnhfc3RhdHVzKSB7 CisJY2FzZSBORVRfUlhfU1VDQ0VTUzoKKwkJeworCQkJLyoKKwkJCSAqIE5vdGhpbmcgdG8gZG8g aGVyZQorCQkJICovCisJCQlicmVhazsKKwkJfQorCisJY2FzZSBORVRfUlhfQ05fTE9XOgorCQl7 CisJCQlkYmcoREJHX0FTUywgIiVzOiBSZWNlaXZlIExvdyBDb25nZXN0aW9uXG4iLCBuYW1lKTsK KwkJCWJyZWFrOworCQl9CisKKwljYXNlIE5FVF9SWF9DTl9NT0Q6CisJCXsKKwkJCWRiZyhEQkdf QVNTLCAiJXM6IFJlY2VpdmUgTW9kZXJhdGUgQ29uZ2VzdGlvblxuIiwgbmFtZSk7CisJCQlicmVh azsKKwkJfQorCisJY2FzZSBORVRfUlhfQ05fSElHSDoKKwkJeworCQkJZGJnKERCR19BU1MsICIl czogUmVjZWl2ZSBIaWdoIENvbmdlc3Rpb25cbiIsIG5hbWUpOworCQkJYnJlYWs7CisJCX0KKwor CWNhc2UgTkVUX1JYX0RST1A6CisJCXsKKwkJCWRiZyhEQkdfQVNTLCAiJXM6IFJlY2VpdmVkIHBh Y2tldCBkcm9wcGVkXG4iLCBuYW1lKTsKKwkJCWJyZWFrOworCQl9CisJfQogfQogCisvKiAgICAg IEluaXRpbGFpc2UgRE1BIGZvciBQTFggOTA1NAorICovCitzdGF0aWMgaW5saW5lIHZvaWQKK2Zz dF9pbml0X2RtYShzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCkKK3sKKwkvKgorCSAqIFRoaXMg aXMgb25seSByZXF1aXJlZCBmb3IgdGhlIFBMWCA5MDU0CisJICovCisJaWYgKGNhcmQtPmZhbWls eSA9PSBGU1RfRkFNSUxZX1RYVSkgeworCSAgICAgICAgcGNpX3NldF9tYXN0ZXIoY2FyZC0+ZGV2 aWNlKTsKKwkJb3V0bCgweDAwMDIwNDQxLCBjYXJkLT5wY2lfY29uZiArIERNQU1PREUwKTsKKwkJ b3V0bCgweDAwMDIwNDQxLCBjYXJkLT5wY2lfY29uZiArIERNQU1PREUxKTsKKwkJb3V0bCgweDAs IGNhcmQtPnBjaV9jb25mICsgRE1BVEhSKTsKKwl9Cit9CisKKy8qICAgICAgVHggZG1hIGNvbXBs ZXRlIGludGVycnVwdAorICovCitzdGF0aWMgdm9pZAorZnN0X3R4X2RtYV9jb21wbGV0ZShzdHJ1 Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCwgc3RydWN0IGZzdF9wb3J0X2luZm8gKnBvcnQsCisJCSAg ICBpbnQgbGVuLCBpbnQgdHhwb3MpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IHBvcnRf dG9fZGV2KHBvcnQpOworCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzdGF0cyA9IGhkbGNfc3Rh dHMoZGV2KTsKKworCS8qCisJICogRXZlcnl0aGluZyBpcyBub3cgc2V0LCBqdXN0IHRlbGwgdGhl IGNhcmQgdG8gZ28KKwkgKi8KKwlkYmcoREJHX1RYLCAiZnN0X3R4X2RtYV9jb21wbGV0ZVxuIik7 CisJRlNUX1dSQihjYXJkLCB0eERlc2NyUmluZ1twb3J0LT5pbmRleF1bdHhwb3NdLmJpdHMsCisJ CURNQV9PV04gfCBUWF9TVFAgfCBUWF9FTlApOworCXN0YXRzLT50eF9wYWNrZXRzKys7CisJc3Rh dHMtPnR4X2J5dGVzICs9IGxlbjsKKwlkZXYtPnRyYW5zX3N0YXJ0ID0gamlmZmllczsKK30KKwor LyogICAgICBSeCBkbWEgY29tcGxldGUgaW50ZXJydXB0CisgKi8KK3N0YXRpYyB2b2lkCitmc3Rf cnhfZG1hX2NvbXBsZXRlKHN0cnVjdCBmc3RfY2FyZF9pbmZvICpjYXJkLCBzdHJ1Y3QgZnN0X3Bv cnRfaW5mbyAqcG9ydCwKKwkJICAgIGludCBsZW4sIHN0cnVjdCBza19idWZmICpza2IsIGludCBy eHApCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IHBvcnRfdG9fZGV2KHBvcnQpOworCXN0 cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzdGF0cyA9IGhkbGNfc3RhdHMoZGV2KTsKKwlpbnQgcGk7 CisJaW50IHJ4X3N0YXR1czsKKworCWRiZyhEQkdfVFgsICJmc3RfcnhfZG1hX2NvbXBsZXRlXG4i KTsKKwlwaSA9IHBvcnQtPmluZGV4OworCW1lbWNweShza2JfcHV0KHNrYiwgbGVuKSwgY2FyZC0+ cnhfZG1hX2hhbmRsZV9ob3N0LCBsZW4pOworCisJLyogUmVzZXQgYnVmZmVyIGRlc2NyaXB0b3Ig Ki8KKwlGU1RfV1JCKGNhcmQsIHJ4RGVzY3JSaW5nW3BpXVtyeHBdLmJpdHMsIERNQV9PV04pOwor CisJLyogVXBkYXRlIHN0YXRzICovCisJc3RhdHMtPnJ4X3BhY2tldHMrKzsKKwlzdGF0cy0+cnhf Ynl0ZXMgKz0gbGVuOworCisJLyogUHVzaCB1cHN0cmVhbSAqLworCWRiZyhEQkdfUlgsICJQdXNo aW5nIHRoZSBmcmFtZSB1cCB0aGUgc3RhY2tcbiIpOworCXNrYi0+bWFjLnJhdyA9IHNrYi0+ZGF0 YTsKKwlza2ItPmRldiA9IGRldjsKKwlpZiAocG9ydC0+bW9kZSA9PSBGU1RfUkFXKSB7CisJCS8q CisJCSAqIE1hcmsgaXQgZm9yIG91ciBvd24gcmF3IHNvY2tldHMgaW50ZXJmYWNlCisJCSAqLwor CQlza2ItPnByb3RvY29sID0gaHRvbnMoRVRIX1BfQ1VTVCk7CisJCXNrYi0+cGt0X3R5cGUgPSBQ QUNLRVRfSE9TVDsKKwl9IGVsc2UgeworCQlza2ItPnByb3RvY29sID0gaGRsY190eXBlX3RyYW5z KHNrYiwgc2tiLT5kZXYpOworCX0KKwlyeF9zdGF0dXMgPSBuZXRpZl9yeChza2IpOworCWZzdF9w cm9jZXNzX3J4X3N0YXR1cyhyeF9zdGF0dXMsIHBvcnRfdG9fZGV2KHBvcnQpLT5uYW1lKTsKKwlp ZiAocnhfc3RhdHVzID09IE5FVF9SWF9EUk9QKQorCQlzdGF0cy0+cnhfZHJvcHBlZCsrOworCWRl di0+bGFzdF9yeCA9IGppZmZpZXM7Cit9CisKKy8qCisgKiAgICAgIFJlY2VpdmUgYSBmcmFtZSB0 aHJvdWdoIHRoZSBETUEKKyAqLworc3RhdGljIGlubGluZSB2b2lkCitmc3RfcnhfZG1hKHN0cnVj dCBmc3RfY2FyZF9pbmZvICpjYXJkLCB1bnNpZ25lZCBjaGFyICpza2IsCisJICAgdW5zaWduZWQg Y2hhciAqbWVtLCBpbnQgbGVuKQoreworCS8qCisJICogVGhpcyByb3V0aW5lIHdpbGwgc2V0dXAg dGhlIERNQSBhbmQgc3RhcnQgaXQKKwkgKi8KKworCWRiZyhEQkdfUlgsICJJbiBmc3RfcnhfZG1h ICVwICVwICVkXG4iLCBza2IsIG1lbSwgbGVuKTsKKwlpZiAoY2FyZC0+ZG1hcnhfaW5fcHJvZ3Jl c3MpIHsKKwkJZGJnKERCR19BU1MsICJJbiBmc3RfcnhfZG1hIHdoaWxlIGRtYSBpbiBwcm9ncmVz c1xuIik7CisJfQorCisJb3V0bCgodW5zaWduZWQgbG9uZykgc2tiLCBjYXJkLT5wY2lfY29uZiAr IERNQVBBRFIwKTsJLyogQ29weSB0byBoZXJlICovCisJb3V0bCgodW5zaWduZWQgbG9uZykgbWVt LCBjYXJkLT5wY2lfY29uZiArIERNQUxBRFIwKTsJLyogZnJvbSBoZXJlICovCisJb3V0bChsZW4s IGNhcmQtPnBjaV9jb25mICsgRE1BU0laMCk7CS8qIGZvciB0aGlzIGxlbmd0aCAqLworCW91dGwo MHgwMDAwMDAwMGMsIGNhcmQtPnBjaV9jb25mICsgRE1BRFBSMCk7CS8qIEluIHRoaXMgZGlyZWN0 aW9uICovCisKKwkvKgorCSAqIFdlIHVzZSB0aGUgZG1hcnhfaW5fcHJvZ3Jlc3MgZmxhZyB0byBm bGFnIHRoZSBjaGFubmVsIGFzIGJ1c3kKKwkgKi8KKwljYXJkLT5kbWFyeF9pbl9wcm9ncmVzcyA9 IDE7CisJb3V0YigweDAzLCBjYXJkLT5wY2lfY29uZiArIERNQUNTUjApOwkvKiBTdGFydCB0aGUg dHJhbnNmZXIgKi8KK30KKworLyoKKyAqICAgICAgU2VuZCBhIGZyYW1lIHRocm91Z2ggdGhlIERN QQorICovCitzdGF0aWMgaW5saW5lIHZvaWQKK2ZzdF90eF9kbWEoc3RydWN0IGZzdF9jYXJkX2lu Zm8gKmNhcmQsIHVuc2lnbmVkIGNoYXIgKnNrYiwKKwkgICB1bnNpZ25lZCBjaGFyICptZW0sIGlu dCBsZW4pCit7CisJLyoKKwkgKiBUaGlzIHJvdXRpbmUgd2lsbCBzZXR1cCB0aGUgRE1BIGFuZCBz dGFydCBpdC4KKwkgKi8KKworCWRiZyhEQkdfVFgsICJJbiBmc3RfdHhfZG1hICVwICVwICVkXG4i LCBza2IsIG1lbSwgbGVuKTsKKwlpZiAoY2FyZC0+ZG1hdHhfaW5fcHJvZ3Jlc3MpIHsKKwkJZGJn KERCR19BU1MsICJJbiBmc3RfdHhfZG1hIHdoaWxlIGRtYSBpbiBwcm9ncmVzc1xuIik7CisJfQor CisJb3V0bCgodW5zaWduZWQgbG9uZykgc2tiLCBjYXJkLT5wY2lfY29uZiArIERNQVBBRFIxKTsJ LyogQ29weSBmcm9tIGhlcmUgKi8KKwlvdXRsKCh1bnNpZ25lZCBsb25nKSBtZW0sIGNhcmQtPnBj aV9jb25mICsgRE1BTEFEUjEpOwkvKiB0byBoZXJlICovCisJb3V0bChsZW4sIGNhcmQtPnBjaV9j b25mICsgRE1BU0laMSk7CS8qIGZvciB0aGlzIGxlbmd0aCAqLworCW91dGwoMHgwMDAwMDAwMDQs IGNhcmQtPnBjaV9jb25mICsgRE1BRFBSMSk7CS8qIEluIHRoaXMgZGlyZWN0aW9uICovCisKKwkv KgorCSAqIFdlIHVzZSB0aGUgZG1hdHhfaW5fcHJvZ3Jlc3MgdG8gZmxhZyB0aGUgY2hhbm5lbCBh cyBidXN5CisJICovCisJY2FyZC0+ZG1hdHhfaW5fcHJvZ3Jlc3MgPSAxOworCW91dGIoMHgwMywg Y2FyZC0+cGNpX2NvbmYgKyBETUFDU1IxKTsJLyogU3RhcnQgdGhlIHRyYW5zZmVyICovCit9CiAK IC8qICAgICAgSXNzdWUgYSBNYWlsYm94IGNvbW1hbmQgZm9yIGEgcG9ydC4KICAqICAgICAgTm90 ZSB3ZSBpc3N1ZSB0aGVtIG9uIGEgZmlyZSBhbmQgZm9yZ2V0IGJhc2lzLCBub3QgZXhwZWN0aW5n IHRvIHNlZSBhbgogICogICAgICBlcnJvciBhbmQgbm90IHdhaXRpbmcgZm9yIGNvbXBsZXRpb24u CiAgKi8KIHN0YXRpYyB2b2lkCi1mc3RfaXNzdWVfY21kICggc3RydWN0IGZzdF9wb3J0X2luZm8g KnBvcnQsIHVuc2lnbmVkIHNob3J0IGNtZCApCitmc3RfaXNzdWVfY21kKHN0cnVjdCBmc3RfcG9y dF9pbmZvICpwb3J0LCB1bnNpZ25lZCBzaG9ydCBjbWQpCiB7Ci0gICAgICAgIHN0cnVjdCBmc3Rf Y2FyZF9pbmZvICpjYXJkOwotICAgICAgICB1bnNpZ25lZCBzaG9ydCBtYnZhbDsKLSAgICAgICAg dW5zaWduZWQgbG9uZyBmbGFnczsKLSAgICAgICAgaW50IHNhZmV0eTsKLQotICAgICAgICBjYXJk ID0gcG9ydC0+Y2FyZDsKLSAgICAgICAgc3Bpbl9sb2NrX2lycXNhdmUgKCAmY2FyZC0+Y2FyZF9s b2NrLCBmbGFncyApOwotICAgICAgICBtYnZhbCA9IEZTVF9SRFcgKCBjYXJkLCBwb3J0TWFpbGJv eFtwb3J0LT5pbmRleF1bMF0pOwotCi0gICAgICAgIHNhZmV0eSA9IDA7Ci0gICAgICAgIC8qIFdh aXQgZm9yIGFueSBwcmV2aW91cyBjb21tYW5kIHRvIGNvbXBsZXRlICovCi0gICAgICAgIHdoaWxl ICggbWJ2YWwgPiBOQUsgKQotICAgICAgICB7Ci0gICAgICAgICAgICAgICAgc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSAoICZjYXJkLT5jYXJkX2xvY2ssIGZsYWdzICk7Ci0gICAgICAgICAgICAgICAg c2NoZWR1bGVfdGltZW91dCAoIDEgKTsKLSAgICAgICAgICAgICAgICBzcGluX2xvY2tfaXJxc2F2 ZSAoICZjYXJkLT5jYXJkX2xvY2ssIGZsYWdzICk7Ci0KLSAgICAgICAgICAgICAgICBpZiAoICsr c2FmZXR5ID4gMTAwMCApCi0gICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAgICAgICAg ICAgcHJpbnRrX2VyciAoIk1haWxib3ggc2FmZXR5IHRpbWVvdXRcbiIpOwotICAgICAgICAgICAg ICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICAgICAgfQorCXN0cnVjdCBmc3RfY2FyZF9p bmZvICpjYXJkOworCXVuc2lnbmVkIHNob3J0IG1idmFsOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7 CisJaW50IHNhZmV0eTsKKworCWNhcmQgPSBwb3J0LT5jYXJkOworCXNwaW5fbG9ja19pcnFzYXZl KCZjYXJkLT5jYXJkX2xvY2ssIGZsYWdzKTsKKwltYnZhbCA9IEZTVF9SRFcoY2FyZCwgcG9ydE1h aWxib3hbcG9ydC0+aW5kZXhdWzBdKTsKKworCXNhZmV0eSA9IDA7CisJLyogV2FpdCBmb3IgYW55 IHByZXZpb3VzIGNvbW1hbmQgdG8gY29tcGxldGUgKi8KKwl3aGlsZSAobWJ2YWwgPiBOQUspIHsK KwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyk7CisJCXNj aGVkdWxlX3RpbWVvdXQoMSk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZjYXJkLT5jYXJkX2xvY2ss IGZsYWdzKTsKKworCQlpZiAoKytzYWZldHkgPiAyMDAwKSB7CisJCQlwcmludGtfZXJyKCJNYWls Ym94IHNhZmV0eSB0aW1lb3V0XG4iKTsKKwkJCWJyZWFrOworCQl9CisKKwkJbWJ2YWwgPSBGU1Rf UkRXKGNhcmQsIHBvcnRNYWlsYm94W3BvcnQtPmluZGV4XVswXSk7CisJfQorCWlmIChzYWZldHkg PiAwKSB7CisJCWRiZyhEQkdfQ01ELCAiTWFpbGJveCBjbGVhciBhZnRlciAlZCBqaWZmaWVzXG4i LCBzYWZldHkpOworCX0KKwlpZiAobWJ2YWwgPT0gTkFLKSB7CisJCWRiZyhEQkdfQ01ELCAiaXNz dWVfY21kOiBwcmV2aW91cyBjb21tYW5kIHdhcyBOQUsnZFxuIik7CisJfQogCi0gICAgICAgICAg ICAgICAgbWJ2YWwgPSBGU1RfUkRXICggY2FyZCwgcG9ydE1haWxib3hbcG9ydC0+aW5kZXhdWzBd KTsKLSAgICAgICAgfQotICAgICAgICBpZiAoIHNhZmV0eSA+IDAgKQotICAgICAgICB7Ci0gICAg ICAgICAgICAgICAgZGJnICggREJHX0NNRCwiTWFpbGJveCBjbGVhciBhZnRlciAlZCBqaWZmaWVz XG4iLCBzYWZldHkgKTsKLSAgICAgICAgfQotICAgICAgICBpZiAoIG1idmFsID09IE5BSyApCi0g ICAgICAgIHsKLSAgICAgICAgICAgICAgICBkYmcgKCBEQkdfQ01ELCJpc3N1ZV9jbWQ6IHByZXZp b3VzIGNvbW1hbmQgd2FzIE5BSydkXG4iKTsKLSAgICAgICAgfQotCi0gICAgICAgIEZTVF9XUlcg KCBjYXJkLCBwb3J0TWFpbGJveFtwb3J0LT5pbmRleF1bMF0sIGNtZCApOwotCi0gICAgICAgIGlm ICggY21kID09IEFCT1JUVFggfHwgY21kID09IFNUQVJUUE9SVCApCi0gICAgICAgIHsKLSAgICAg ICAgICAgICAgICBwb3J0LT50eHBvcyAgPSAwOwotICAgICAgICAgICAgICAgIHBvcnQtPnR4aXBv cyA9IDA7Ci0gICAgICAgICAgICAgICAgcG9ydC0+dHhjbnQgID0gMDsKLSAgICAgICAgfQorCUZT VF9XUlcoY2FyZCwgcG9ydE1haWxib3hbcG9ydC0+aW5kZXhdWzBdLCBjbWQpOwogCi0gICAgICAg IHNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKCAmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyApOwotfQor CWlmIChjbWQgPT0gQUJPUlRUWCB8fCBjbWQgPT0gU1RBUlRQT1JUKSB7CisJCXBvcnQtPnR4cG9z ID0gMDsKKwkJcG9ydC0+dHhpcG9zID0gMDsKKwkJcG9ydC0+c3RhcnQgPSAwOworCX0KIAorCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmNhcmRfbG9jaywgZmxhZ3MpOworfQogCiAvKiAg ICAgIFBvcnQgb3V0cHV0IHNpZ25hbHMgY29udHJvbAogICovCiBzdGF0aWMgaW5saW5lIHZvaWQK LWZzdF9vcF9yYWlzZSAoIHN0cnVjdCBmc3RfcG9ydF9pbmZvICpwb3J0LCB1bnNpZ25lZCBpbnQg b3V0cHV0cyApCitmc3Rfb3BfcmFpc2Uoc3RydWN0IGZzdF9wb3J0X2luZm8gKnBvcnQsIHVuc2ln bmVkIGludCBvdXRwdXRzKQogewotICAgICAgICBvdXRwdXRzIHw9IEZTVF9SREwgKCBwb3J0LT5j YXJkLCB2MjRPcFN0c1twb3J0LT5pbmRleF0pOwotICAgICAgICBGU1RfV1JMICggcG9ydC0+Y2Fy ZCwgdjI0T3BTdHNbcG9ydC0+aW5kZXhdLCBvdXRwdXRzICk7CisJb3V0cHV0cyB8PSBGU1RfUkRM KHBvcnQtPmNhcmQsIHYyNE9wU3RzW3BvcnQtPmluZGV4XSk7CisJRlNUX1dSTChwb3J0LT5jYXJk LCB2MjRPcFN0c1twb3J0LT5pbmRleF0sIG91dHB1dHMpOwogCi0gICAgICAgIGlmICggcG9ydC0+ cnVuICkKLSAgICAgICAgICAgICAgICBmc3RfaXNzdWVfY21kICggcG9ydCwgU0VUVjI0TyApOwor CWlmIChwb3J0LT5ydW4pCisJCWZzdF9pc3N1ZV9jbWQocG9ydCwgU0VUVjI0Tyk7CiB9CiAKIHN0 YXRpYyBpbmxpbmUgdm9pZAotZnN0X29wX2xvd2VyICggc3RydWN0IGZzdF9wb3J0X2luZm8gKnBv cnQsIHVuc2lnbmVkIGludCBvdXRwdXRzICkKK2ZzdF9vcF9sb3dlcihzdHJ1Y3QgZnN0X3BvcnRf aW5mbyAqcG9ydCwgdW5zaWduZWQgaW50IG91dHB1dHMpCiB7Ci0gICAgICAgIG91dHB1dHMgPSB+ b3V0cHV0cyAmIEZTVF9SREwgKCBwb3J0LT5jYXJkLCB2MjRPcFN0c1twb3J0LT5pbmRleF0pOwot ICAgICAgICBGU1RfV1JMICggcG9ydC0+Y2FyZCwgdjI0T3BTdHNbcG9ydC0+aW5kZXhdLCBvdXRw dXRzICk7CisJb3V0cHV0cyA9IH5vdXRwdXRzICYgRlNUX1JETChwb3J0LT5jYXJkLCB2MjRPcFN0 c1twb3J0LT5pbmRleF0pOworCUZTVF9XUkwocG9ydC0+Y2FyZCwgdjI0T3BTdHNbcG9ydC0+aW5k ZXhdLCBvdXRwdXRzKTsKIAotICAgICAgICBpZiAoIHBvcnQtPnJ1biApCi0gICAgICAgICAgICAg ICAgZnN0X2lzc3VlX2NtZCAoIHBvcnQsIFNFVFYyNE8gKTsKKwlpZiAocG9ydC0+cnVuKQorCQlm c3RfaXNzdWVfY21kKHBvcnQsIFNFVFYyNE8pOwogfQogCi0KIC8qCiAgKiAgICAgIFNldHVwIHBv cnQgUnggYnVmZmVycwogICovCiBzdGF0aWMgdm9pZAotZnN0X3J4X2NvbmZpZyAoIHN0cnVjdCBm c3RfcG9ydF9pbmZvICpwb3J0ICkKK2ZzdF9yeF9jb25maWcoc3RydWN0IGZzdF9wb3J0X2luZm8g KnBvcnQpCiB7Ci0gICAgICAgIGludCBpOwotICAgICAgICBpbnQgcGk7Ci0gICAgICAgIHVuc2ln bmVkIGludCBvZmZzZXQ7Ci0gICAgICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0gICAgICAgIHN0 cnVjdCBmc3RfY2FyZF9pbmZvICpjYXJkOwotCi0gICAgICAgIHBpICAgPSBwb3J0LT5pbmRleDsK LSAgICAgICAgY2FyZCA9IHBvcnQtPmNhcmQ7Ci0gICAgICAgIHNwaW5fbG9ja19pcnFzYXZlICgg JmNhcmQtPmNhcmRfbG9jaywgZmxhZ3MgKTsKLSAgICAgICAgZm9yICggaSA9IDAgOyBpIDwgTlVN X1JYX0JVRkZFUiA7IGkrKyApCi0gICAgICAgIHsKLSAgICAgICAgICAgICAgICBvZmZzZXQgPSBC VUZfT0ZGU0VUICggcnhCdWZmZXJbcGldW2ldWzBdKTsKLQotICAgICAgICAgICAgICAgIEZTVF9X UlcgKCBjYXJkLCByeERlc2NyUmluZ1twaV1baV0ubGFkciwgKHUxNikgb2Zmc2V0ICk7Ci0gICAg ICAgICAgICAgICAgRlNUX1dSQiAoIGNhcmQsIHJ4RGVzY3JSaW5nW3BpXVtpXS5oYWRyLCAodTgp KCBvZmZzZXQgPj4gMTYgKSk7Ci0gICAgICAgICAgICAgICAgRlNUX1dSVyAoIGNhcmQsIHJ4RGVz Y3JSaW5nW3BpXVtpXS5iY250LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGNudl9iY250ICggTEVOX1JYX0JVRkZFUiApKTsKLSAgICAgICAgICAgICAgICBGU1RfV1JX ICggY2FyZCwgcnhEZXNjclJpbmdbcGldW2ldLm1jbnQsIDAgKTsKLSAgICAgICAgICAgICAgICBG U1RfV1JCICggY2FyZCwgcnhEZXNjclJpbmdbcGldW2ldLmJpdHMsIERNQV9PV04gKTsKLSAgICAg ICAgfQotICAgICAgICBwb3J0LT5yeHBvcyAgPSAwOwotICAgICAgICBzcGluX3VubG9ja19pcnFy ZXN0b3JlICggJmNhcmQtPmNhcmRfbG9jaywgZmxhZ3MgKTsKKwlpbnQgaTsKKwlpbnQgcGk7CisJ dW5zaWduZWQgaW50IG9mZnNldDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBmc3Rf Y2FyZF9pbmZvICpjYXJkOworCisJcGkgPSBwb3J0LT5pbmRleDsKKwljYXJkID0gcG9ydC0+Y2Fy ZDsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyk7CisJZm9yIChp ID0gMDsgaSA8IE5VTV9SWF9CVUZGRVI7IGkrKykgeworCQlvZmZzZXQgPSBCVUZfT0ZGU0VUKHJ4 QnVmZmVyW3BpXVtpXVswXSk7CisKKwkJRlNUX1dSVyhjYXJkLCByeERlc2NyUmluZ1twaV1baV0u bGFkciwgKHUxNikgb2Zmc2V0KTsKKwkJRlNUX1dSQihjYXJkLCByeERlc2NyUmluZ1twaV1baV0u aGFkciwgKHU4KSAob2Zmc2V0ID4+IDE2KSk7CisJCUZTVF9XUlcoY2FyZCwgcnhEZXNjclJpbmdb cGldW2ldLmJjbnQsIGNudl9iY250KExFTl9SWF9CVUZGRVIpKTsKKwkJRlNUX1dSVyhjYXJkLCBy eERlc2NyUmluZ1twaV1baV0ubWNudCwgTEVOX1JYX0JVRkZFUik7CisJCUZTVF9XUkIoY2FyZCwg cnhEZXNjclJpbmdbcGldW2ldLmJpdHMsIERNQV9PV04pOworCX0KKwlwb3J0LT5yeHBvcyA9IDA7 CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyk7CiB9CiAK LQogLyoKICAqICAgICAgU2V0dXAgcG9ydCBUeCBidWZmZXJzCiAgKi8KIHN0YXRpYyB2b2lkCi1m c3RfdHhfY29uZmlnICggc3RydWN0IGZzdF9wb3J0X2luZm8gKnBvcnQgKQorZnN0X3R4X2NvbmZp ZyhzdHJ1Y3QgZnN0X3BvcnRfaW5mbyAqcG9ydCkKIHsKLSAgICAgICAgaW50IGk7Ci0gICAgICAg IGludCBwaTsKLSAgICAgICAgdW5zaWduZWQgaW50IG9mZnNldDsKLSAgICAgICAgdW5zaWduZWQg bG9uZyBmbGFnczsKLSAgICAgICAgc3RydWN0IGZzdF9jYXJkX2luZm8gKmNhcmQ7Ci0KLSAgICAg ICAgcGkgICA9IHBvcnQtPmluZGV4OwotICAgICAgICBjYXJkID0gcG9ydC0+Y2FyZDsKLSAgICAg ICAgc3Bpbl9sb2NrX2lycXNhdmUgKCAmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyApOwotICAgICAg ICBmb3IgKCBpID0gMCA7IGkgPCBOVU1fVFhfQlVGRkVSIDsgaSsrICkKLSAgICAgICAgewotICAg ICAgICAgICAgICAgIG9mZnNldCA9IEJVRl9PRkZTRVQgKCB0eEJ1ZmZlcltwaV1baV1bMF0pOwot Ci0gICAgICAgICAgICAgICAgRlNUX1dSVyAoIGNhcmQsIHR4RGVzY3JSaW5nW3BpXVtpXS5sYWRy LCAodTE2KSBvZmZzZXQgKTsKLSAgICAgICAgICAgICAgICBGU1RfV1JCICggY2FyZCwgdHhEZXNj clJpbmdbcGldW2ldLmhhZHIsICh1OCkoIG9mZnNldCA+PiAxNiApKTsKLSAgICAgICAgICAgICAg ICBGU1RfV1JXICggY2FyZCwgdHhEZXNjclJpbmdbcGldW2ldLmJjbnQsIDAgKTsKLSAgICAgICAg ICAgICAgICBGU1RfV1JCICggY2FyZCwgdHhEZXNjclJpbmdbcGldW2ldLmJpdHMsIDAgKTsKLSAg ICAgICAgfQotICAgICAgICBwb3J0LT50eHBvcyAgPSAwOwotICAgICAgICBwb3J0LT50eGlwb3Mg PSAwOwotICAgICAgICBwb3J0LT50eGNudCAgPSAwOwotICAgICAgICBzcGluX3VubG9ja19pcnFy ZXN0b3JlICggJmNhcmQtPmNhcmRfbG9jaywgZmxhZ3MgKTsKKwlpbnQgaTsKKwlpbnQgcGk7CisJ dW5zaWduZWQgaW50IG9mZnNldDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBmc3Rf Y2FyZF9pbmZvICpjYXJkOworCisJcGkgPSBwb3J0LT5pbmRleDsKKwljYXJkID0gcG9ydC0+Y2Fy ZDsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyk7CisJZm9yIChp ID0gMDsgaSA8IE5VTV9UWF9CVUZGRVI7IGkrKykgeworCQlvZmZzZXQgPSBCVUZfT0ZGU0VUKHR4 QnVmZmVyW3BpXVtpXVswXSk7CisKKwkJRlNUX1dSVyhjYXJkLCB0eERlc2NyUmluZ1twaV1baV0u bGFkciwgKHUxNikgb2Zmc2V0KTsKKwkJRlNUX1dSQihjYXJkLCB0eERlc2NyUmluZ1twaV1baV0u aGFkciwgKHU4KSAob2Zmc2V0ID4+IDE2KSk7CisJCUZTVF9XUlcoY2FyZCwgdHhEZXNjclJpbmdb cGldW2ldLmJjbnQsIDApOworCQlGU1RfV1JCKGNhcmQsIHR4RGVzY3JSaW5nW3BpXVtpXS5iaXRz LCAwKTsKKwl9CisJcG9ydC0+dHhwb3MgPSAwOworCXBvcnQtPnR4aXBvcyA9IDA7CisJcG9ydC0+ c3RhcnQgPSAwOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmNhcmRfbG9jaywgZmxh Z3MpOwogfQogCisvKiAgICAgIFRFMSBBbGFybSBjaGFuZ2UgaW50ZXJydXB0IGV2ZW50CisgKi8K K3N0YXRpYyB2b2lkCitmc3RfaW50cl90ZTFfYWxhcm0oc3RydWN0IGZzdF9jYXJkX2luZm8gKmNh cmQsIHN0cnVjdCBmc3RfcG9ydF9pbmZvICpwb3J0KQoreworCXU4IGxvczsKKwl1OCBycmE7CisJ dTggYWlzOworCisJbG9zID0gRlNUX1JEQihjYXJkLCBzdVN0YXR1cy5sb3NzT2ZTaWduYWwpOwor CXJyYSA9IEZTVF9SREIoY2FyZCwgc3VTdGF0dXMucmVjZWl2ZVJlbW90ZUFsYXJtKTsKKwlhaXMg PSBGU1RfUkRCKGNhcmQsIHN1U3RhdHVzLmFsYXJtSW5kaWNhdGlvblNpZ25hbCk7CisKKwlpZiAo bG9zKSB7CisJCS8qCisJCSAqIExvc3QgdGhlIGxpbmsKKwkJICovCisJCWlmIChuZXRpZl9jYXJy aWVyX29rKHBvcnRfdG9fZGV2KHBvcnQpKSkgeworCQkJZGJnKERCR19JTlRSLCAiTmV0IGNhcnJp ZXIgb2ZmXG4iKTsKKwkJCW5ldGlmX2NhcnJpZXJfb2ZmKHBvcnRfdG9fZGV2KHBvcnQpKTsKKwkJ fQorCX0gZWxzZSB7CisJCS8qCisJCSAqIExpbmsgYXZhaWxhYmxlCisJCSAqLworCQlpZiAoIW5l dGlmX2NhcnJpZXJfb2socG9ydF90b19kZXYocG9ydCkpKSB7CisJCQlkYmcoREJHX0lOVFIsICJO ZXQgY2FycmllciBvblxuIik7CisJCQluZXRpZl9jYXJyaWVyX29uKHBvcnRfdG9fZGV2KHBvcnQp KTsKKwkJfQorCX0KKworCWlmIChsb3MpCisJCWRiZyhEQkdfSU5UUiwgIkFzc2VydCBMT1MgQWxh cm1cbiIpOworCWVsc2UKKwkJZGJnKERCR19JTlRSLCAiRGUtYXNzZXJ0IExPUyBBbGFybVxuIik7 CisJaWYgKHJyYSkKKwkJZGJnKERCR19JTlRSLCAiQXNzZXJ0IFJSQSBBbGFybVxuIik7CisJZWxz ZQorCQlkYmcoREJHX0lOVFIsICJEZS1hc3NlcnQgUlJBIEFsYXJtXG4iKTsKKworCWlmIChhaXMp CisJCWRiZyhEQkdfSU5UUiwgIkFzc2VydCBBSVMgQWxhcm1cbiIpOworCWVsc2UKKwkJZGJnKERC R19JTlRSLCAiRGUtYXNzZXJ0IEFJUyBBbGFybVxuIik7Cit9CiAKIC8qICAgICAgQ29udHJvbCBz aWduYWwgY2hhbmdlIGludGVycnVwdCBldmVudAogICovCi1zdGF0aWMgaXJxcmV0dXJuX3QKLWZz dF9pbnRyX2N0bGNoZyAoIHN0cnVjdCBmc3RfY2FyZF9pbmZvICpjYXJkLCBzdHJ1Y3QgZnN0X3Bv cnRfaW5mbyAqcG9ydCApCitzdGF0aWMgdm9pZAorZnN0X2ludHJfY3RsY2hnKHN0cnVjdCBmc3Rf Y2FyZF9pbmZvICpjYXJkLCBzdHJ1Y3QgZnN0X3BvcnRfaW5mbyAqcG9ydCkKIHsKLSAgICAgICAg aW50IHNpZ25hbHM7CisJaW50IHNpZ25hbHM7CiAKLSAgICAgICAgc2lnbmFscyA9IEZTVF9SREwg KCBjYXJkLCB2MjREZWJvdW5jZWRTdHNbcG9ydC0+aW5kZXhdKTsKKwlzaWduYWxzID0gRlNUX1JE TChjYXJkLCB2MjREZWJvdW5jZWRTdHNbcG9ydC0+aW5kZXhdKTsKIAotICAgICAgICBpZiAoIHNp Z25hbHMgJiAoKCBwb3J0LT5od2lmID09IFgyMSApID8gSVBTVFNfSU5ESUNBVEUgOiBJUFNUU19E Q0QgKSkKLSAgICAgICAgewotICAgICAgICAgICAgICAgIGlmICggISBuZXRpZl9jYXJyaWVyX29r ICggcG9ydF90b19kZXYgKCBwb3J0ICkpKQotICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAg ICAgICAgICAgICAgIGRiZyAoIERCR19JTlRSLCJEQ0QgYWN0aXZlXG4iKTsKLSAgICAgICAgICAg ICAgICAgICAgICAgIG5ldGlmX2NhcnJpZXJfb24gKCBwb3J0X3RvX2RldiAoIHBvcnQgKSk7Ci0g ICAgICAgICAgICAgICAgfQotICAgICAgICB9Ci0gICAgICAgIGVsc2UKLSAgICAgICAgewotICAg ICAgICAgICAgICAgIGlmICggbmV0aWZfY2Fycmllcl9vayAoIHBvcnRfdG9fZGV2ICggcG9ydCAp KSkKLSAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBkYmcgKCBEQkdf SU5UUiwiRENEIGxvc3RcbiIpOwotICAgICAgICAgICAgICAgICAgICAgICAgbmV0aWZfY2Fycmll cl9vZmYgKCBwb3J0X3RvX2RldiAoIHBvcnQgKSk7Ci0gICAgICAgICAgICAgICAgfQotICAgICAg ICB9Ci0JcmV0dXJuIElSUV9IQU5ETEVEOworCWlmIChzaWduYWxzICYgKCgocG9ydC0+aHdpZiA9 PSBYMjEpIHx8IChwb3J0LT5od2lmID09IFgyMUQpKQorCQkgICAgICAgPyBJUFNUU19JTkRJQ0FU RSA6IElQU1RTX0RDRCkpIHsKKwkJaWYgKCFuZXRpZl9jYXJyaWVyX29rKHBvcnRfdG9fZGV2KHBv cnQpKSkgeworCQkJZGJnKERCR19JTlRSLCAiRENEIGFjdGl2ZVxuIik7CisJCQluZXRpZl9jYXJy aWVyX29uKHBvcnRfdG9fZGV2KHBvcnQpKTsKKwkJfQorCX0gZWxzZSB7CisJCWlmIChuZXRpZl9j YXJyaWVyX29rKHBvcnRfdG9fZGV2KHBvcnQpKSkgeworCQkJZGJnKERCR19JTlRSLCAiRENEIGxv c3RcbiIpOworCQkJbmV0aWZfY2Fycmllcl9vZmYocG9ydF90b19kZXYocG9ydCkpOworCQl9CisJ fQorfQorCisvKiAgICAgIExvZyBSeCBFcnJvcnMKKyAqLworc3RhdGljIHZvaWQKK2ZzdF9sb2df cnhfZXJyb3Ioc3RydWN0IGZzdF9jYXJkX2luZm8gKmNhcmQsIHN0cnVjdCBmc3RfcG9ydF9pbmZv ICpwb3J0LAorCQkgdW5zaWduZWQgY2hhciBkbWFiaXRzLCBpbnQgcnhwLCB1bnNpZ25lZCBzaG9y dCBsZW4pCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IHBvcnRfdG9fZGV2KHBvcnQpOwor CXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzdGF0cyA9IGhkbGNfc3RhdHMoZGV2KTsKKworCS8q IAorCSAqIEluY3JlbWVudCB0aGUgYXBwcm9wcmlhdGUgZXJyb3IgY291bnRlcgorCSAqLworCXN0 YXRzLT5yeF9lcnJvcnMrKzsKKwlpZiAoZG1hYml0cyAmIFJYX09GTE8pIHsKKwkJc3RhdHMtPnJ4 X2ZpZm9fZXJyb3JzKys7CisJCWRiZyhEQkdfQVNTLCAiUnggZmlmbyBlcnJvciBvbiBjYXJkICVk IHBvcnQgJWQgYnVmZmVyICVkXG4iLAorCQkgICAgY2FyZC0+Y2FyZF9ubywgcG9ydC0+aW5kZXgs IHJ4cCk7CisJfQorCWlmIChkbWFiaXRzICYgUlhfQ1JDKSB7CisJCXN0YXRzLT5yeF9jcmNfZXJy b3JzKys7CisJCWRiZyhEQkdfQVNTLCAiUnggY3JjIGVycm9yIG9uIGNhcmQgJWQgcG9ydCAlZFxu IiwKKwkJICAgIGNhcmQtPmNhcmRfbm8sIHBvcnQtPmluZGV4KTsKKwl9CisJaWYgKGRtYWJpdHMg JiBSWF9GUkFNKSB7CisJCXN0YXRzLT5yeF9mcmFtZV9lcnJvcnMrKzsKKwkJZGJnKERCR19BU1Ms ICJSeCBmcmFtZSBlcnJvciBvbiBjYXJkICVkIHBvcnQgJWRcbiIsCisJCSAgICBjYXJkLT5jYXJk X25vLCBwb3J0LT5pbmRleCk7CisJfQorCWlmIChkbWFiaXRzID09IChSWF9TVFAgfCBSWF9FTlAp KSB7CisJCXN0YXRzLT5yeF9sZW5ndGhfZXJyb3JzKys7CisJCWRiZyhEQkdfQVNTLCAiUnggbGVu Z3RoIGVycm9yICglZCkgb24gY2FyZCAlZCBwb3J0ICVkXG4iLAorCQkgICAgbGVuLCBjYXJkLT5j YXJkX25vLCBwb3J0LT5pbmRleCk7CisJfQogfQogCisvKiAgICAgIFJ4IEVycm9yIFJlY292ZXJ5 CisgKi8KK3N0YXRpYyB2b2lkCitmc3RfcmVjb3Zlcl9yeF9lcnJvcihzdHJ1Y3QgZnN0X2NhcmRf aW5mbyAqY2FyZCwgc3RydWN0IGZzdF9wb3J0X2luZm8gKnBvcnQsCisJCSAgICAgdW5zaWduZWQg Y2hhciBkbWFiaXRzLCBpbnQgcnhwLCB1bnNpZ25lZCBzaG9ydCBsZW4pCit7CisJaW50IGk7CisJ aW50IHBpOworCisJcGkgPSBwb3J0LT5pbmRleDsKKwkvKiAKKwkgKiBEaXNjYXJkIGJ1ZmZlciBk ZXNjcmlwdG9ycyB1bnRpbCB3ZSBzZWUgdGhlIHN0YXJ0IG9mIHRoZQorCSAqIG5leHQgZnJhbWUu ICBOb3RlIHRoYXQgZm9yIGxvbmcgZnJhbWVzIHRoaXMgY291bGQgYmUgaW4KKwkgKiBhIHN1YnNl cXVlbnQgaW50ZXJydXB0LiAKKwkgKi8KKwlpID0gMDsKKwl3aGlsZSAoKGRtYWJpdHMgJiAoRE1B X09XTiB8IFJYX1NUUCkpID09IDApIHsKKwkJRlNUX1dSQihjYXJkLCByeERlc2NyUmluZ1twaV1b cnhwXS5iaXRzLCBETUFfT1dOKTsKKwkJcnhwID0gKHJ4cCsxKSAlIE5VTV9SWF9CVUZGRVI7CisJ CWlmICgrK2kgPiBOVU1fUlhfQlVGRkVSKSB7CisJCQlkYmcoREJHX0FTUywgImludHJfcng6IERp c2NhcmRpbmcgbW9yZSBidWZzIgorCQkJICAgICIgdGhhbiB3ZSBoYXZlXG4iKTsKKwkJCWJyZWFr OworCQl9CisJCWRtYWJpdHMgPSBGU1RfUkRCKGNhcmQsIHJ4RGVzY3JSaW5nW3BpXVtyeHBdLmJp dHMpOworCQlkYmcoREJHX0FTUywgIkRNQSBCaXRzIG9mIG5leHQgYnVmZmVyIHdhcyAleFxuIiwg ZG1hYml0cyk7CisJfQorCWRiZyhEQkdfQVNTLCAiVGhlcmUgd2VyZSAlZCBzdWJzZXF1ZW50IGJ1 ZmZlcnMgaW4gZXJyb3JcbiIsIGkpOworCisJLyogRGlzY2FyZCB0aGUgdGVybWluYWwgYnVmZmVy ICovCisJaWYgKCEoZG1hYml0cyAmIERNQV9PV04pKSB7CisJCUZTVF9XUkIoY2FyZCwgcnhEZXNj clJpbmdbcGldW3J4cF0uYml0cywgRE1BX09XTik7CisJCXJ4cCA9IChyeHArMSkgJSBOVU1fUlhf QlVGRkVSOworCX0KKwlwb3J0LT5yeHBvcyA9IHJ4cDsKKwlyZXR1cm47CisKK30KIAogLyogICAg ICBSeCBjb21wbGV0ZSBpbnRlcnJ1cHQKICAqLwogc3RhdGljIHZvaWQKLWZzdF9pbnRyX3J4ICgg c3RydWN0IGZzdF9jYXJkX2luZm8gKmNhcmQsIHN0cnVjdCBmc3RfcG9ydF9pbmZvICpwb3J0ICkK K2ZzdF9pbnRyX3J4KHN0cnVjdCBmc3RfY2FyZF9pbmZvICpjYXJkLCBzdHJ1Y3QgZnN0X3BvcnRf aW5mbyAqcG9ydCkKIHsKLSAgICAgICAgdW5zaWduZWQgY2hhciBkbWFiaXRzOwotICAgICAgICBp bnQgcGk7Ci0gICAgICAgIGludCByeHA7Ci0gICAgICAgIHVuc2lnbmVkIHNob3J0IGxlbjsKLSAg ICAgICAgc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwl1bnNpZ25lZCBjaGFyIGRtYWJpdHM7CisJaW50 IHBpOworCWludCByeHA7CisJaW50IHJ4X3N0YXR1czsKKwl1bnNpZ25lZCBzaG9ydCBsZW47CisJ c3RydWN0IHNrX2J1ZmYgKnNrYjsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gcG9ydF90b19k ZXYocG9ydCk7CiAJc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzID0gaGRsY19zdGF0cyhk ZXYpOwotICAgICAgICBpbnQgaTsKIAorCS8qIENoZWNrIHdlIGhhdmUgYSBidWZmZXIgdG8gcHJv Y2VzcyAqLworCXBpID0gcG9ydC0+aW5kZXg7CisJcnhwID0gcG9ydC0+cnhwb3M7CisJZG1hYml0 cyA9IEZTVF9SREIoY2FyZCwgcnhEZXNjclJpbmdbcGldW3J4cF0uYml0cyk7CisJaWYgKGRtYWJp dHMgJiBETUFfT1dOKSB7CisJCWRiZyhEQkdfUlggfCBEQkdfSU5UUiwgImludHJfcng6IE5vIGJ1 ZmZlciBwb3J0ICVkIHBvcyAlZFxuIiwKKwkJICAgIHBpLCByeHApOworCQlyZXR1cm47CisJfQor CWlmIChjYXJkLT5kbWFyeF9pbl9wcm9ncmVzcykgeworCQlyZXR1cm47CisJfQogCi0gICAgICAg IC8qIENoZWNrIHdlIGhhdmUgYSBidWZmZXIgdG8gcHJvY2VzcyAqLwotICAgICAgICBwaSAgPSBw b3J0LT5pbmRleDsKLSAgICAgICAgcnhwID0gcG9ydC0+cnhwb3M7Ci0gICAgICAgIGRtYWJpdHMg PSBGU1RfUkRCICggY2FyZCwgcnhEZXNjclJpbmdbcGldW3J4cF0uYml0cyApOwotICAgICAgICBp ZiAoIGRtYWJpdHMgJiBETUFfT1dOICkKLSAgICAgICAgewotICAgICAgICAgICAgICAgIGRiZyAo IERCR19SWCB8IERCR19JTlRSLCJpbnRyX3J4OiBObyBidWZmZXIgcG9ydCAlZCBwb3MgJWRcbiIs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGksIHJ4cCApOwotICAg ICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgfQotCi0gICAgICAgIC8qIEdldCBidWZmZXIg bGVuZ3RoICovCi0gICAgICAgIGxlbiA9IEZTVF9SRFcgKCBjYXJkLCByeERlc2NyUmluZ1twaV1b cnhwXS5tY250ICk7Ci0gICAgICAgIC8qIERpc2NhcmQgdGhlIENSQyAqLwotICAgICAgICBsZW4g LT0gMjsKLQotICAgICAgICAvKiBDaGVjayBidWZmZXIgbGVuZ3RoIGFuZCBmb3Igb3RoZXIgZXJy b3JzLiBXZSBpbnNpc3Qgb24gb25lIHBhY2tldAotICAgICAgICAgKiBpbiBvbmUgYnVmZmVyLiBU aGlzIHNpbXBsaWZpZXMgdGhpbmdzIGdyZWF0bHkgYW5kIHNpbmNlIHdlJ3ZlCi0gICAgICAgICAq IGFsbG9jYXRlZCA4SyBpdCBzaG91bGRuJ3QgYmUgYSByZWFsIHdvcmxkIGxpbWl0YXRpb24KLSAg ICAgICAgICovCi0gICAgICAgIGRiZyAoIERCR19SWCwiaW50cl9yeDogJWQsJWQ6IGZsYWdzICV4 IGxlbiAlZFxuIiwgcGksIHJ4cCwgZG1hYml0cywKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBsZW4gKTsKLSAgICAgICAgaWYgKCBkbWFiaXRzICE9ICggUlhfU1RQIHwg UlhfRU5QICkgfHwgbGVuID4gTEVOX1JYX0JVRkZFUiAtIDIgKQotICAgICAgICB7Ci0gICAgICAg ICAgICAgICAgc3RhdHMtPnJ4X2Vycm9ycysrOwotCi0gICAgICAgICAgICAgICAgLyogVXBkYXRl IGVycm9yIHN0YXRzIGFuZCBkaXNjYXJkIGJ1ZmZlciAqLwotICAgICAgICAgICAgICAgIGlmICgg ZG1hYml0cyAmIFJYX09GTE8gKQotICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAg ICAgICAgIHN0YXRzLT5yeF9maWZvX2Vycm9ycysrOwotICAgICAgICAgICAgICAgIH0KLSAgICAg ICAgICAgICAgICBpZiAoIGRtYWJpdHMgJiBSWF9DUkMgKQotICAgICAgICAgICAgICAgIHsKLSAg ICAgICAgICAgICAgICAgICAgICAgIHN0YXRzLT5yeF9jcmNfZXJyb3JzKys7Ci0gICAgICAgICAg ICAgICAgfQotICAgICAgICAgICAgICAgIGlmICggZG1hYml0cyAmIFJYX0ZSQU0gKQotICAgICAg ICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgIHN0YXRzLT5yeF9mcmFtZV9lcnJv cnMrKzsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAgICAgaWYgKCBkbWFiaXRzID09 ICggUlhfU1RQIHwgUlhfRU5QICkpCi0gICAgICAgICAgICAgICAgewotICAgICAgICAgICAgICAg ICAgICAgICAgc3RhdHMtPnJ4X2xlbmd0aF9lcnJvcnMrKzsKLSAgICAgICAgICAgICAgICB9CisJ LyogR2V0IGJ1ZmZlciBsZW5ndGggKi8KKwlsZW4gPSBGU1RfUkRXKGNhcmQsIHJ4RGVzY3JSaW5n W3BpXVtyeHBdLm1jbnQpOworCS8qIERpc2NhcmQgdGhlIENSQyAqLworCWxlbiAtPSAyOworCWlm IChsZW4gPT0gMCkgeworCQkvKgorCQkgKiBUaGlzIHNlZW1zIHRvIGhhcHBlbiBvbiB0aGUgVEUx IGludGVyZmFjZSBzb21ldGltZXMKKwkJICogc28gdGhyb3cgdGhlIGZyYW1lIGF3YXkgYW5kIGxv ZyB0aGUgZXZlbnQuCisJCSAqLworCQlwcmludGtfZXJyKCJGcmFtZSByZWNlaXZlZCB3aXRoIDAg bGVuZ3RoLiBDYXJkICVkIFBvcnQgJWRcbiIsCisJCQkgICBjYXJkLT5jYXJkX25vLCBwb3J0LT5p bmRleCk7CisJCS8qIFJldHVybiBkZXNjcmlwdG9yIHRvIGNhcmQgKi8KKwkJRlNUX1dSQihjYXJk LCByeERlc2NyUmluZ1twaV1bcnhwXS5iaXRzLCBETUFfT1dOKTsKKworCQlyeHAgPSAocnhwKzEp ICUgTlVNX1JYX0JVRkZFUjsKKwkJcG9ydC0+cnhwb3MgPSByeHA7CisJCXJldHVybjsKKwl9CiAK LSAgICAgICAgICAgICAgICAvKiBEaXNjYXJkIGJ1ZmZlciBkZXNjcmlwdG9ycyB1bnRpbCB3ZSBz ZWUgdGhlIGVuZCBvZiBwYWNrZXQKLSAgICAgICAgICAgICAgICAgKiBtYXJrZXIKLSAgICAgICAg ICAgICAgICAgKi8KLSAgICAgICAgICAgICAgICBpID0gMDsKLSAgICAgICAgICAgICAgICB3aGls ZSAoKCBkbWFiaXRzICYgKCBETUFfT1dOIHwgUlhfRU5QICkpID09IDAgKQotICAgICAgICAgICAg ICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAgIEZTVF9XUkIgKCBjYXJkLCByeERlc2NyUmlu Z1twaV1bcnhwXS5iaXRzLCBETUFfT1dOICk7Ci0gICAgICAgICAgICAgICAgICAgICAgICBpZiAo ICsrcnhwID49IE5VTV9SWF9CVUZGRVIgKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICByeHAgPSAwOwotICAgICAgICAgICAgICAgICAgICAgICAgaWYgKCArK2kgPiBOVU1fUlhfQlVG RkVSICkKLSAgICAgICAgICAgICAgICAgICAgICAgIHsKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZGJnICggREJHX0FTUywiaW50cl9yeDogRGlzY2FyZGluZyBtb3JlIGJ1ZnMiCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiIHRoYW4gd2Ug aGF2ZVxuIik7Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOwotICAgICAg ICAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgICAgICAgICAgZG1hYml0cyA9IEZT VF9SREIgKCBjYXJkLCByeERlc2NyUmluZ1twaV1bcnhwXS5iaXRzICk7Ci0gICAgICAgICAgICAg ICAgfQorCS8qIENoZWNrIGJ1ZmZlciBsZW5ndGggYW5kIGZvciBvdGhlciBlcnJvcnMuIFdlIGlu c2lzdCBvbiBvbmUgcGFja2V0CisJICogaW4gb25lIGJ1ZmZlci4gVGhpcyBzaW1wbGlmaWVzIHRo aW5ncyBncmVhdGx5IGFuZCBzaW5jZSB3ZSd2ZQorCSAqIGFsbG9jYXRlZCA4SyBpdCBzaG91bGRu J3QgYmUgYSByZWFsIHdvcmxkIGxpbWl0YXRpb24KKwkgKi8KKwlkYmcoREJHX1JYLCAiaW50cl9y eDogJWQsJWQ6IGZsYWdzICV4IGxlbiAlZFxuIiwgcGksIHJ4cCwgZG1hYml0cywgbGVuKTsKKwlp ZiAoZG1hYml0cyAhPSAoUlhfU1RQIHwgUlhfRU5QKSB8fCBsZW4gPiBMRU5fUlhfQlVGRkVSIC0g MikgeworCQlmc3RfbG9nX3J4X2Vycm9yKGNhcmQsIHBvcnQsIGRtYWJpdHMsIHJ4cCwgbGVuKTsK KwkJZnN0X3JlY292ZXJfcnhfZXJyb3IoY2FyZCwgcG9ydCwgZG1hYml0cywgcnhwLCBsZW4pOwor CQlyZXR1cm47CisJfQogCi0gICAgICAgICAgICAgICAgLyogRGlzY2FyZCB0aGUgdGVybWluYWwg YnVmZmVyICovCi0gICAgICAgICAgICAgICAgaWYgKCAhICggZG1hYml0cyAmIERNQV9PV04gKSkK LSAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgICAgICBGU1RfV1JCICggY2Fy ZCwgcnhEZXNjclJpbmdbcGldW3J4cF0uYml0cywgRE1BX09XTiApOwotICAgICAgICAgICAgICAg ICAgICAgICAgaWYgKCArK3J4cCA+PSBOVU1fUlhfQlVGRkVSICkKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcnhwID0gMDsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICAg ICAgcG9ydC0+cnhwb3MgPSByeHA7Ci0gICAgICAgICAgICAgICAgcmV0dXJuOwotICAgICAgICB9 Ci0KLSAgICAgICAgLyogQWxsb2NhdGUgU0tCICovCi0gICAgICAgIGlmICgoIHNrYiA9IGRldl9h bGxvY19za2IgKCBsZW4gKSkgPT0gTlVMTCApCi0gICAgICAgIHsKLSAgICAgICAgICAgICAgICBk YmcgKCBEQkdfUlgsImludHJfcng6IGNhbid0IGFsbG9jYXRlIGJ1ZmZlclxuIik7Ci0KLSAgICAg ICAgICAgICAgICBzdGF0cy0+cnhfZHJvcHBlZCsrOwotCi0gICAgICAgICAgICAgICAgLyogUmV0 dXJuIGRlc2NyaXB0b3IgdG8gY2FyZCAqLwotICAgICAgICAgICAgICAgIEZTVF9XUkIgKCBjYXJk LCByeERlc2NyUmluZ1twaV1bcnhwXS5iaXRzLCBETUFfT1dOICk7Ci0KLSAgICAgICAgICAgICAg ICBpZiAoICsrcnhwID49IE5VTV9SWF9CVUZGRVIgKQotICAgICAgICAgICAgICAgICAgICAgICAg cG9ydC0+cnhwb3MgPSAwOwotICAgICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICAg ICAgICAgIHBvcnQtPnJ4cG9zID0gcnhwOwotICAgICAgICAgICAgICAgIHJldHVybjsKLSAgICAg ICAgfQotCi0gICAgICAgIG1lbWNweV9mcm9taW8gKCBza2JfcHV0ICggc2tiLCBsZW4gKSwKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY2FyZC0+bWVtICsgQlVGX09GRlNFVCAoIHJ4 QnVmZmVyW3BpXVtyeHBdWzBdKSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbGVu ICk7Ci0KLSAgICAgICAgLyogUmVzZXQgYnVmZmVyIGRlc2NyaXB0b3IgKi8KLSAgICAgICAgRlNU X1dSQiAoIGNhcmQsIHJ4RGVzY3JSaW5nW3BpXVtyeHBdLmJpdHMsIERNQV9PV04gKTsKLSAgICAg ICAgaWYgKCArK3J4cCA+PSBOVU1fUlhfQlVGRkVSICkKLSAgICAgICAgICAgICAgICBwb3J0LT5y eHBvcyA9IDA7Ci0gICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICBwb3J0LT5yeHBvcyA9IHJ4 cDsKLQotICAgICAgICAvKiBVcGRhdGUgc3RhdHMgKi8KLSAgICAgICAgc3RhdHMtPnJ4X3BhY2tl dHMrKzsKLSAgICAgICAgc3RhdHMtPnJ4X2J5dGVzICs9IGxlbjsKLQotICAgICAgICAvKiBQdXNo IHVwc3RyZWFtICovCi0gICAgICAgIHNrYi0+bWFjLnJhdyA9IHNrYi0+ZGF0YTsKLSAgICAgICAg c2tiLT5kZXYgPSBkZXY7Ci0gICAgICAgIHNrYi0+cHJvdG9jb2wgPSBoZGxjX3R5cGVfdHJhbnMo c2tiLCBza2ItPmRldik7Ci0gICAgICAgIG5ldGlmX3J4ICggc2tiICk7CisJLyogQWxsb2NhdGUg U0tCICovCisJaWYgKChza2IgPSBkZXZfYWxsb2Nfc2tiKGxlbikpID09IE5VTEwpIHsKKwkJZGJn KERCR19SWCwgImludHJfcng6IGNhbid0IGFsbG9jYXRlIGJ1ZmZlclxuIik7CisKKwkJc3RhdHMt PnJ4X2Ryb3BwZWQrKzsKKworCQkvKiBSZXR1cm4gZGVzY3JpcHRvciB0byBjYXJkICovCisJCUZT VF9XUkIoY2FyZCwgcnhEZXNjclJpbmdbcGldW3J4cF0uYml0cywgRE1BX09XTik7CisKKwkJcnhw ID0gKHJ4cCsxKSAlIE5VTV9SWF9CVUZGRVI7CisJCXBvcnQtPnJ4cG9zID0gcnhwOworCQlyZXR1 cm47CisJfQogCi0gICAgICAgIGRldi0+bGFzdF9yeCA9IGppZmZpZXM7CisJLyoKKwkgKiBXZSBr bm93IHRoZSBsZW5ndGggd2UgbmVlZCB0byByZWNlaXZlLCBsZW4uCisJICogSXQncyBub3Qgd29y dGggdXNpbmcgdGhlIERNQSBmb3IgcmVhZHMgb2YgbGVzcyB0aGFuCisJICogRlNUX01JTl9ETUFf TEVOCisJICovCisKKwlpZiAoKGxlbiA8IEZTVF9NSU5fRE1BX0xFTikgfHwgKGNhcmQtPmZhbWls eSA9PSBGU1RfRkFNSUxZX1RYUCkpIHsKKwkJbWVtY3B5X2Zyb21pbyhza2JfcHV0KHNrYiwgbGVu KSwKKwkJCSAgICAgIGNhcmQtPm1lbSArIEJVRl9PRkZTRVQocnhCdWZmZXJbcGldW3J4cF1bMF0p LAorCQkJICAgICAgbGVuKTsKKworCQkvKiBSZXNldCBidWZmZXIgZGVzY3JpcHRvciAqLworCQlG U1RfV1JCKGNhcmQsIHJ4RGVzY3JSaW5nW3BpXVtyeHBdLmJpdHMsIERNQV9PV04pOworCisJCS8q IFVwZGF0ZSBzdGF0cyAqLworCQlzdGF0cy0+cnhfcGFja2V0cysrOworCQlzdGF0cy0+cnhfYnl0 ZXMgKz0gbGVuOworCisJCS8qIFB1c2ggdXBzdHJlYW0gKi8KKwkJZGJnKERCR19SWCwgIlB1c2hp bmcgZnJhbWUgdXAgdGhlIHN0YWNrXG4iKTsKKwkJc2tiLT5tYWMucmF3ID0gc2tiLT5kYXRhOwor CQlza2ItPmRldiA9IGRldjsKKwkJaWYgKHBvcnQtPm1vZGUgPT0gRlNUX1JBVykgeworCQkJLyoK KwkJCSAqIE1hcmsgaXQgZm9yIG91ciBvd24gcmF3IHNvY2tldHMgaW50ZXJmYWNlCisJCQkgKi8K KwkJCXNrYi0+cHJvdG9jb2wgPSBodG9ucyhFVEhfUF9DVVNUKTsKKwkJCXNrYi0+cGt0X3R5cGUg PSBQQUNLRVRfSE9TVDsKKwkJfSBlbHNlIHsKKwkJCXNrYi0+cHJvdG9jb2wgPSBoZGxjX3R5cGVf dHJhbnMoc2tiLCBza2ItPmRldik7CisJCX0KKwkJcnhfc3RhdHVzID0gbmV0aWZfcngoc2tiKTsK KwkJZnN0X3Byb2Nlc3Nfcnhfc3RhdHVzKHJ4X3N0YXR1cywgcG9ydF90b19kZXYocG9ydCktPm5h bWUpOworCQlpZiAocnhfc3RhdHVzID09IE5FVF9SWF9EUk9QKSB7CisJCQlzdGF0cy0+cnhfZHJv cHBlZCsrOworCQl9CisJCWRldi0+bGFzdF9yeCA9IGppZmZpZXM7CisJfSBlbHNlIHsKKwkJY2Fy ZC0+ZG1hX3NrYl9yeCA9IHNrYjsKKwkJY2FyZC0+ZG1hX3BvcnRfcnggPSBwb3J0OworCQljYXJk LT5kbWFfbGVuX3J4ID0gbGVuOworCQljYXJkLT5kbWFfcnhwb3MgPSByeHA7CisJCWZzdF9yeF9k bWEoY2FyZCwgKGNoYXIgKikgY2FyZC0+cnhfZG1hX2hhbmRsZV9jYXJkLAorCQkJICAgKGNoYXIg KikgQlVGX09GRlNFVChyeEJ1ZmZlcltwaV1bcnhwXVswXSksIGxlbik7CisJfQorCWlmIChyeHAg IT0gcG9ydC0+cnhwb3MpIHsKKwkJZGJnKERCR19BU1MsICJBYm91dCB0byBpbmNyZW1lbnQgcnhw b3MgYnkgbW9yZSB0aGFuIDFcbiIpOworCQlkYmcoREJHX0FTUywgInJ4cCA9ICVkIHJ4cG9zID0g JWRcbiIsIHJ4cCwgcG9ydC0+cnhwb3MpOworCX0KKwlyeHAgPSAocnhwKzEpICUgTlVNX1JYX0JV RkZFUjsKKwlwb3J0LT5yeHBvcyA9IHJ4cDsKIH0KIAorLyoKKyAqICAgICAgVGhlIGJvdHRvbSBo YWxmcyB0byB0aGUgSVNSCisgKgorICovCisKK3N0YXRpYyB2b2lkCitkb19ib3R0b21faGFsZl90 eChzdHJ1Y3QgZnN0X2NhcmRfaW5mbyAqY2FyZCkKK3sKKwlzdHJ1Y3QgZnN0X3BvcnRfaW5mbyAq cG9ydDsKKwlpbnQgcGk7CisJaW50IHR4cV9sZW5ndGg7CisJc3RydWN0IHNrX2J1ZmYgKnNrYjsK Kwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXN0cnVjdCBuZXRfZGV2aWNlICpkZXY7CisJc3RydWN0 IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzOworCisJLyoKKwkgKiAgRmluZCBhIGZyZWUgYnVmZmVy IGZvciB0aGUgdHJhbnNtaXQKKwkgKiAgU3RlcCB0aHJvdWdoIGVhY2ggcG9ydCBvbiB0aGlzIGNh cmQKKwkgKi8KKworCWRiZyhEQkdfVFgsICJkb19ib3R0b21faGFsZl90eFxuIik7CisJZm9yIChw aSA9IDAsIHBvcnQgPSBjYXJkLT5wb3J0czsgcGkgPCBjYXJkLT5ucG9ydHM7IHBpKyssIHBvcnQr KykgeworCQlpZiAoIXBvcnQtPnJ1bikKKwkJCWNvbnRpbnVlOworCisgICAgICAgICAgICAgICAg ZGV2ID0gcG9ydF90b19kZXYocG9ydCk7CisgICAgICAgICAgICAgICAgc3RhdHMgPSBoZGxjX3N0 YXRzKGRldik7CisJCXdoaWxlICghCisJCSAgICAgICAoRlNUX1JEQihjYXJkLCB0eERlc2NyUmlu Z1twaV1bcG9ydC0+dHhwb3NdLmJpdHMpICYKKwkJCURNQV9PV04pCisgICAgICAgICAgICAgICAg ICAgICAgICYmICEoY2FyZC0+ZG1hdHhfaW5fcHJvZ3Jlc3MpKSB7CisJCQkvKgorCQkJICogVGhl cmUgZG9lc24ndCBzZWVtIHRvIGJlIGEgdHhkb25lIGV2ZW50IHBlci1zZQorCQkJICogV2Ugc2Vl bSB0byBoYXZlIHRvIGRlZHVjZSBpdCwgYnkgY2hlY2tpbmcgdGhlIERNQV9PV04KKwkJCSAqIGJp dCBvbiB0aGUgbmV4dCBidWZmZXIgd2UgdGhpbmsgd2UgY2FuIHVzZQorCQkJICovCisJCQlzcGlu X2xvY2tfaXJxc2F2ZSgmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyk7CisJCQlpZiAoKHR4cV9sZW5n dGggPSBwb3J0LT50eHFlIC0gcG9ydC0+dHhxcykgPCAwKSB7CisJCQkJLyoKKwkJCQkgKiBUaGlz IGlzIHRoZSBjYXNlIHdoZXJlIG9uZSBoYXMgd3JhcHBlZCBhbmQgdGhlCisJCQkJICogbWF0aHMg Z2l2ZXMgdXMgYSBuZWdhdGl2ZSBudW1iZXIKKwkJCQkgKi8KKwkJCQl0eHFfbGVuZ3RoID0gdHhx X2xlbmd0aCArIEZTVF9UWFFfREVQVEg7CisJCQl9CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZjYXJkLT5jYXJkX2xvY2ssIGZsYWdzKTsKKwkJCWlmICh0eHFfbGVuZ3RoID4gMCkgeworCQkJ CS8qCisJCQkJICogVGhlcmUgaXMgc29tZXRoaW5nIHRvIHNlbmQKKwkJCQkgKi8KKwkJCQlzcGlu X2xvY2tfaXJxc2F2ZSgmY2FyZC0+Y2FyZF9sb2NrLCBmbGFncyk7CisJCQkJc2tiID0gcG9ydC0+ dHhxW3BvcnQtPnR4cXNdOworCQkJCXBvcnQtPnR4cXMrKzsKKwkJCQlpZiAocG9ydC0+dHhxcyA9 PSBGU1RfVFhRX0RFUFRIKSB7CisJCQkJCXBvcnQtPnR4cXMgPSAwOworCQkJCX0KKwkJCQlzcGlu X3VubG9ja19pcnFyZXN0b3JlKCZjYXJkLT5jYXJkX2xvY