From nobody@FreeBSD.org  Sun Oct  7 18:58:52 2007
Return-Path: <nobody@FreeBSD.org>
Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34])
	by hub.freebsd.org (Postfix) with ESMTP id 5A71E16A418
	for <freebsd-gnats-submit@FreeBSD.org>; Sun,  7 Oct 2007 18:58:52 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from www.freebsd.org (www.freebsd.org [IPv6:2001:4f8:fff6::21])
	by mx1.freebsd.org (Postfix) with ESMTP id 2DED713C45D
	for <freebsd-gnats-submit@FreeBSD.org>; Sun,  7 Oct 2007 18:58:52 +0000 (UTC)
	(envelope-from nobody@FreeBSD.org)
Received: from www.freebsd.org (localhost [127.0.0.1])
	by www.freebsd.org (8.14.1/8.14.1) with ESMTP id l97IwpUt010585
	for <freebsd-gnats-submit@FreeBSD.org>; Sun, 7 Oct 2007 18:58:51 GMT
	(envelope-from nobody@www.freebsd.org)
Received: (from nobody@localhost)
	by www.freebsd.org (8.14.1/8.14.1/Submit) id l97IwpUH010584;
	Sun, 7 Oct 2007 18:58:51 GMT
	(envelope-from nobody)
Message-Id: <200710071858.l97IwpUH010584@www.freebsd.org>
Date: Sun, 7 Oct 2007 18:58:51 GMT
From: Scott Brickey <Me@SBrickey.net>
To: freebsd-gnats-submit@FreeBSD.org
Subject: CARP using address-less host NIC (carpdev)
X-Send-Pr-Version: www-3.1
X-GNATS-Notify:

>Number:         117000
>Category:       kern
>Synopsis:       [carp] CARP using address-less host NIC (carpdev)
>Confidential:   no
>Severity:       non-critical
>Priority:       low
>Responsible:    glebius
>State:          closed
>Quarter:        
>Keywords:       
>Date-Required:  
>Class:          update
>Submitter-Id:   current-users
>Arrival-Date:   Sun Oct 07 19:00:10 GMT 2007
>Closed-Date:    Wed Jan 22 09:13:06 UTC 2014
>Last-Modified:  Wed Jan 22 09:13:06 UTC 2014
>Originator:     Scott Brickey
>Release:        6.2
>Organization:
>Environment:
FreeBSD host.domain 6.2-RELEASE-p5 FreeBSD 6.2-RELEASE-p5 #0: Mon Jul  2 20:09:36 EDT 2007     sullrich@builder6.pfsense.com:/usr/obj.pfSense/usr/src/sys/pfSense.6  i386
>Description:
OpenBSD calls it the "carpdev" option... it allows the host NIC to remain
ip-less, and as a result allows CARP to be utilized when only a single IP
is available.
>How-To-Repeat:
try to utilize CARP when you've only got a single address to use.
>Fix:
use OpenBSD

>Release-Note:
>Audit-Trail:

From: Remko Lodder <remko@FreeBSD.org>
To: Scott Brickey <Me@SBrickey.net>
Cc: freebsd-gnats-submit@FreeBSD.org
Subject: Re: misc/117000: CARP using address-less host NIC (carpdev)
Date: Sun, 07 Oct 2007 21:11:01 +0200

 Hello,
 
 Perhaps I am ignorant or something but what exactly is the problem?
 You want to use CARP but something goes wrong clearly; but it's not
 clear to me what goes wrong. I have to admit that I never played
 with Carp and dont know it's details at all; so that might be a
 part of the reason I dont understand.
 
 If you want proper help, please be more clear about your problem.
 
 Cheers,
 remko
 
 
 -- 
 Kind regards,
 
      Remko Lodder               ** remko@elvandar.org
      FreeBSD                    ** remko@FreeBSD.org
 
      /* Quis custodiet ipsos custodes */

From: "SBrickey.Net - Me" <Me@sbrickey.net>
To: <bug-followup@FreeBSD.org>,
	"SBrickey.Net - Me" <Me@sbrickey.net>
Cc:  
Subject: Re: kern/117000: [carp] CARP using address-less host NIC (carpdev)
Date: Sun, 7 Oct 2007 22:04:43 -0400

 This is a multi-part message in MIME format.
 
 ------_=_NextPart_001_01C8094F.97A79F3F
 Content-Type: text/plain;
 	charset="us-ascii"
 Content-Transfer-Encoding: quoted-printable
 
 Remko,
 
 =20
 
 Apologies... CARP is a redundancy protocol in which (one or) multiple
 host computers participate in listening and responding from a virtual IP
 (similar to an alias, but the IP and its traffic is shared/split among
 the host computers)... allows for some REALLY redundant router
 configurations.
 
 =20
 
 The issue is that when CARP first came out (from OpenBSD), the virtual
 IP was created based on the IP/subnets of the hosts' physical NICs... so
 the virtual IP had to be within the network/subnet of the host NIC...
 From what little analysis I performed, it seemed that traffic would be
 transmitted with a source address of the host NIC (it would "listen" on
 the CARP address, but respond from the host NIC)... this requires that
 an address space of Host+CARP addresses be available on the desired
 network...
 
 This means that for small addresses (say single static IP's as are
 common in the small business sector), CARP is not an option as the
 networks are too "small" (few IP's) for the ISP's gateway to acknowledge
 the hosts.
 
 =20
 
 This is what was ported to FBSD...
 
 =20
 
 In the meantime, the OpenBSD team has responded to  this by adding a
 "carpdev" option to the interface which allows specifying the interface
 directly without referencing IP/subnet range... this allows the host NIC
 to remain IP-less, while supporting the virtual IP... allowing for CARP
 to function in limited environments such as single IP addresses.
 
 =20
 
 This update would be WONDERFUL to have in the FBSD port.
 
 If further clarification is necessary please feel free to say so.
 
 =20
 
 Thanks,
 
 -Scott
 
 
 ------_=_NextPart_001_01C8094F.97A79F3F
 Content-Type: text/html;
 	charset="us-ascii"
 Content-Transfer-Encoding: quoted-printable
 
 <html xmlns:v=3D"urn:schemas-microsoft-com:vml" =
 xmlns:o=3D"urn:schemas-microsoft-com:office:office" =
 xmlns:w=3D"urn:schemas-microsoft-com:office:word" =
 xmlns:m=3D"http://schemas.microsoft.com/office/2004/12/omml" =
 xmlns=3D"http://www.w3.org/TR/REC-html40">
 
 <head>
 <meta http-equiv=3DContent-Type content=3D"text/html; =
 charset=3Dus-ascii">
 <meta name=3DGenerator content=3D"Microsoft Word 12 (filtered medium)">
 <style>
 <!--
  /* Font Definitions */
  @font-face
 	{font-family:"Cambria Math";
 	panose-1:2 4 5 3 5 4 6 3 2 4;}
 @font-face
 	{font-family:Calibri;
 	panose-1:2 15 5 2 2 2 4 3 2 4;}
  /* Style Definitions */
  p.MsoNormal, li.MsoNormal, div.MsoNormal
 	{margin:0in;
 	margin-bottom:.0001pt;
 	font-size:11.0pt;
 	font-family:"Calibri","sans-serif";}
 a:link, span.MsoHyperlink
 	{mso-style-priority:99;
 	color:blue;
 	text-decoration:underline;}
 a:visited, span.MsoHyperlinkFollowed
 	{mso-style-priority:99;
 	color:purple;
 	text-decoration:underline;}
 span.EmailStyle17
 	{mso-style-type:personal-compose;
 	font-family:"Calibri","sans-serif";
 	color:windowtext;}
 .MsoChpDefault
 	{mso-style-type:export-only;}
 @page Section1
 	{size:8.5in 11.0in;
 	margin:1.0in 1.0in 1.0in 1.0in;}
 div.Section1
 	{page:Section1;}
 -->
 </style>
 <!--[if gte mso 9]><xml>
  <o:shapedefaults v:ext=3D"edit" spidmax=3D"1026" />
 </xml><![endif]--><!--[if gte mso 9]><xml>
  <o:shapelayout v:ext=3D"edit">
   <o:idmap v:ext=3D"edit" data=3D"1" />
  </o:shapelayout></xml><![endif]-->
 </head>
 
 <body lang=3DEN-US link=3Dblue vlink=3Dpurple>
 
 <div class=3DSection1>
 
 <p class=3DMsoNormal>Remko,<o:p></o:p></p>
 
 <p class=3DMsoNormal><o:p>&nbsp;</o:p></p>
 
 <p class=3DMsoNormal>Apologies&#8230; CARP is a redundancy protocol in =
 which (one
 or) multiple host computers participate in listening and responding from =
 a
 virtual IP (similar to an alias, but the IP and its traffic is =
 shared/split among
 the host computers)&#8230; allows for some REALLY redundant router
 configurations.<o:p></o:p></p>
 
 <p class=3DMsoNormal><o:p>&nbsp;</o:p></p>
 
 <p class=3DMsoNormal>The issue is that when CARP first came out (from =
 OpenBSD),
 the virtual IP was created based on the IP/subnets of the hosts&#8217; =
 physical
 NICs&#8230; so the virtual IP had to be within the network/subnet of the =
 host
 NIC&#8230; From what little analysis I performed, it seemed that traffic =
 would
 be transmitted with a source address of the host NIC (it would =
 &#8220;listen&#8221;
 on the CARP address, but respond from the host NIC)&#8230; this requires =
 that an
 address space of Host+CARP addresses be available on the desired =
 network&#8230;<o:p></o:p></p>
 
 <p class=3DMsoNormal>This means that for small addresses (say single =
 static IP&#8217;s
 as are common in the small business sector), CARP is not an option as =
 the
 networks are too &#8220;small&#8221; (few IP&#8217;s) for the =
 ISP&#8217;s
 gateway to acknowledge the hosts.<o:p></o:p></p>
 
 <p class=3DMsoNormal><o:p>&nbsp;</o:p></p>
 
 <p class=3DMsoNormal>This is what was ported to =
 FBSD&#8230;<o:p></o:p></p>
 
 <p class=3DMsoNormal><o:p>&nbsp;</o:p></p>
 
 <p class=3DMsoNormal>In the meantime, the OpenBSD team has responded to =
 &nbsp;this
 by adding a &#8220;carpdev&#8221; option to the interface which allows
 specifying the interface directly without referencing IP/subnet =
 range&#8230;
 this allows the host NIC to remain IP-less, while supporting the virtual =
 IP&#8230;
 allowing for CARP to function in limited environments such as single IP
 addresses.<o:p></o:p></p>
 
 <p class=3DMsoNormal><o:p>&nbsp;</o:p></p>
 
 <p class=3DMsoNormal>This update would be WONDERFUL to have in the FBSD =
 port.<o:p></o:p></p>
 
 <p class=3DMsoNormal>If further clarification is necessary please feel =
 free to
 say so.<o:p></o:p></p>
 
 <p class=3DMsoNormal><o:p>&nbsp;</o:p></p>
 
 <p class=3DMsoNormal>Thanks,<o:p></o:p></p>
 
 <p class=3DMsoNormal>-Scott<o:p></o:p></p>
 
 </div>
 
 </body>
 
 </html>
 
 ------_=_NextPart_001_01C8094F.97A79F3F--
Responsible-Changed-From-To: freebsd-bugs->glebius 
Responsible-Changed-By: remko 
Responsible-Changed-When: Wed Oct 10 18:40:06 UTC 2007 
Responsible-Changed-Why:  
Hi glebius, can you have a look at this request please? I think that 
this is at least something you have experience with (as far as I can 
remember). Could you otherwise point me to the correct person so that 
we can try to resolve this? 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117000 

From: Freddie Cash <fjwcash@gmail.com>
To: bug-followup@freebsd.org, Me@sbrickey.net
Cc:  
Subject: Re: kern/117000: [carp] CARP using address-less host NIC (carpdev)
Date: Wed, 18 Nov 2009 13:59:43 -0800

 --00504502af1430370c0478ac5c5d
 Content-Type: text/plain; charset=UTF-8
 
 Max Laier was working on this back in June of 2008.  He came up with
 the attached patch (carpdev.BETA2.diff).  I helpded with the testing
 of the BETA1 patch prior to that.  But, from what I gather online, not
 much testing has been done with this patch, and it looks like nothing
 has happened with it since then.
 
 The basic issue is that it would be nice to be able to do something
 like (note how there is no IP assigned to em0):
 
 ifconfig em0 up
 ifconfig carp0 create
 ifconfig carp0 cardev em0 vhid 1 pass abcdef 192.168.0.1/24
 
 
 Then on the other host do (again, note how there is no IP assigned to fxp0):
 
 ifconfig fxp0 up
 ifconfig carp0 create
 ifconfig carp0 carpdev fxp0 vhid 1 pass abcdef advskew 100 192.168.0.1/24
 
 Currently, the CARP code looks at the virtual IP and compares that to
 the real IP assigned to an interface, in order to determine which
 interface to use for the CARP traffic.  On a mulit-homed,
 multi-IP-using system, this can "waste" a lot of IPs (each carp pair
 requires 3 IPs, 2 real, 1 virtual)
 
 While one does need a unique IP on each host in order to connect to it
 for management purposes, one should not need unique IPs on every CARP
 interface pair.
 
 -- 
 Freddie Cash
 fjwcash@gmail.com
 
 --00504502af1430370c0478ac5c5d
 Content-Type: text/x-diff; charset=US-ASCII; name="carpdev.BETA2.diff"
 Content-Disposition: attachment; filename="carpdev.BETA2.diff"
 Content-Transfer-Encoding: base64
 X-Attachment-Id: f_g26mppb60
 
 ZGlmZiAtLWdpdCBhL3NiaW4vaWZjb25maWcvaWZjYXJwLmMgYi9zYmluL2lmY29uZmlnL2lmY2Fy
 cC5jCmluZGV4IDljOTYxYjcuLjgyZGJkNTAgMTAwNjQ0Ci0tLSBhL3NiaW4vaWZjb25maWcvaWZj
 YXJwLmMKKysrIGIvc2Jpbi9pZmNvbmZpZy9pZmNhcnAuYwpAQCAtNTIsMTMgKzUyLDcgQEAKIAog
 c3RhdGljIGNvbnN0IGNoYXIgKmNhcnBfc3RhdGVzW10gPSB7IENBUlBfU1RBVEVTIH07CiAKLXZv
 aWQgY2FycF9zdGF0dXMoaW50IHMpOwotdm9pZCBzZXRjYXJwX2FkdmJhc2UoY29uc3QgY2hhciAq
 LGludCwgaW50LCBjb25zdCBzdHJ1Y3QgYWZzd3RjaCAqcmFmcCk7Ci12b2lkIHNldGNhcnBfYWR2
 c2tldyhjb25zdCBjaGFyICosIGludCwgaW50LCBjb25zdCBzdHJ1Y3QgYWZzd3RjaCAqcmFmcCk7
 Ci12b2lkIHNldGNhcnBfcGFzc3dkKGNvbnN0IGNoYXIgKiwgaW50LCBpbnQsIGNvbnN0IHN0cnVj
 dCBhZnN3dGNoICpyYWZwKTsKLXZvaWQgc2V0Y2FycF92aGlkKGNvbnN0IGNoYXIgKiwgaW50LCBp
 bnQsIGNvbnN0IHN0cnVjdCBhZnN3dGNoICpyYWZwKTsKLQotdm9pZAorc3RhdGljIHZvaWQKIGNh
 cnBfc3RhdHVzKGludCBzKQogewogCWNvbnN0IGNoYXIgKnN0YXRlOwpAQCAtNzYsMTcgKzcwLDE3
 IEBAIGNhcnBfc3RhdHVzKGludCBzKQogCQllbHNlCiAJCQlzdGF0ZSA9IGNhcnBfc3RhdGVzW2Nh
 cnByLmNhcnByX3N0YXRlXTsKIAotCQlwcmludGYoIlx0Y2FycDogJXMgdmhpZCAlZCBhZHZiYXNl
 ICVkIGFkdnNrZXcgJWRcbiIsCi0JCSAgICBzdGF0ZSwgY2FycHIuY2FycHJfdmhpZCwgY2FycHIu
 Y2FycHJfYWR2YmFzZSwKLQkJICAgIGNhcnByLmNhcnByX2FkdnNrZXcpOworCQlwcmludGYoIlx0
 Y2FycDogJXMgY2FycGRldiAlcyB2aGlkICVkIGFkdmJhc2UgJWQgYWR2c2tldyAlZFxuIiwKKwkJ
 ICAgIHN0YXRlLCBjYXJwci5jYXJwcl9jYXJwZGV2LCBjYXJwci5jYXJwcl92aGlkLAorCQkgICAg
 Y2FycHIuY2FycHJfYWR2YmFzZSwgY2FycHIuY2FycHJfYWR2c2tldyk7CiAJfQogCiAJcmV0dXJu
 OwogCiB9CiAKLXZvaWQKLXNldGNhcnBfcGFzc3dkKGNvbnN0IGNoYXIgKnZhbCwgaW50IGQsIGlu
 dCBzLCBjb25zdCBzdHJ1Y3QgYWZzd3RjaCAqYWZwKQorc3RhdGljCitERUNMX0NNRF9GVU5DKHNl
 dGNhcnBfcGFzc3dkLCB2YWwsIGQpCiB7CiAJc3RydWN0IGNhcnByZXEgY2FycHI7CiAKQEAgLTEw
 NSw4ICs5OSw4IEBAIHNldGNhcnBfcGFzc3dkKGNvbnN0IGNoYXIgKnZhbCwgaW50IGQsIGludCBz
 LCBjb25zdCBzdHJ1Y3QgYWZzd3RjaCAqYWZwKQogCXJldHVybjsKIH0KIAotdm9pZAotc2V0Y2Fy
 cF92aGlkKGNvbnN0IGNoYXIgKnZhbCwgaW50IGQsIGludCBzLCBjb25zdCBzdHJ1Y3QgYWZzd3Rj
 aCAqYWZwKQorc3RhdGljCitERUNMX0NNRF9GVU5DKHNldGNhcnBfdmhpZCwgdmFsLCBkKQogewog
 CWludCB2aGlkOwogCXN0cnVjdCBjYXJwcmVxIGNhcnByOwpAQCAtMTMwLDggKzEyNCw4IEBAIHNl
 dGNhcnBfdmhpZChjb25zdCBjaGFyICp2YWwsIGludCBkLCBpbnQgcywgY29uc3Qgc3RydWN0IGFm
 c3d0Y2ggKmFmcCkKIAlyZXR1cm47CiB9CiAKLXZvaWQKLXNldGNhcnBfYWR2c2tldyhjb25zdCBj
 aGFyICp2YWwsIGludCBkLCBpbnQgcywgY29uc3Qgc3RydWN0IGFmc3d0Y2ggKmFmcCkKK3N0YXRp
 YworREVDTF9DTURfRlVOQyhzZXRjYXJwX2FkdnNrZXcsIHZhbCwgZCkKIHsKIAlpbnQgYWR2c2tl
 dzsKIAlzdHJ1Y3QgY2FycHJlcSBjYXJwcjsKQEAgLTE1Miw4ICsxNDYsOCBAQCBzZXRjYXJwX2Fk
 dnNrZXcoY29uc3QgY2hhciAqdmFsLCBpbnQgZCwgaW50IHMsIGNvbnN0IHN0cnVjdCBhZnN3dGNo
 ICphZnApCiAJcmV0dXJuOwogfQogCi12b2lkCi1zZXRjYXJwX2FkdmJhc2UoY29uc3QgY2hhciAq
 dmFsLCBpbnQgZCwgaW50IHMsIGNvbnN0IHN0cnVjdCBhZnN3dGNoICphZnApCitzdGF0aWMKK0RF
 Q0xfQ01EX0ZVTkMoc2V0Y2FycF9hZHZiYXNlLCB2YWwsIGQpCiB7CiAJaW50IGFkdmJhc2U7CiAJ
 c3RydWN0IGNhcnByZXEgY2FycHI7CkBAIC0xNzQsMTEgKzE2OCw1MSBAQCBzZXRjYXJwX2FkdmJh
 c2UoY29uc3QgY2hhciAqdmFsLCBpbnQgZCwgaW50IHMsIGNvbnN0IHN0cnVjdCBhZnN3dGNoICph
 ZnApCiAJcmV0dXJuOwogfQogCitzdGF0aWMKK0RFQ0xfQ01EX0ZVTkMoc2V0Y2FycF9jYXJwZGV2
 LCB2YWwsIGQpCit7CisJc3RydWN0IGNhcnByZXEgY2FycHI7CisKKwltZW1zZXQoKGNoYXIgKikm
 Y2FycHIsIDAsIHNpemVvZihzdHJ1Y3QgY2FycHJlcSkpOworCWlmci5pZnJfZGF0YSA9IChjYWRk
 cl90KSZjYXJwcjsKKworCWlmIChpb2N0bChzLCBTSU9DR1ZILCAoY2FkZHJfdCkmaWZyKSA9PSAt
 MSkKKwkJZXJyKDEsICJTSU9DR1ZIIik7CisKKwlzdHJsY3B5KGNhcnByLmNhcnByX2NhcnBkZXYs
 IHZhbCwgc2l6ZW9mKGNhcnByLmNhcnByX2NhcnBkZXYpKTsKKworCWlmIChpb2N0bChzLCBTSU9D
 U1ZILCAoY2FkZHJfdCkmaWZyKSA9PSAtMSkKKwkJZXJyKDEsICJTSU9DU1ZIIik7CisKKwlyZXR1
 cm47Cit9CisKK3N0YXRpYworREVDTF9DTURfRlVOQyhzZXRjYXJwX3Vuc2V0Y2FycGRldiwgdmFs
 LCBkKQoreworCXN0cnVjdCBjYXJwcmVxIGNhcnByOworCisJbWVtc2V0KChjaGFyICopJmNhcnBy
 LCAwLCBzaXplb2Yoc3RydWN0IGNhcnByZXEpKTsKKwlpZnIuaWZyX2RhdGEgPSAoY2FkZHJfdCkm
 Y2FycHI7CisKKwlpZiAoaW9jdGwocywgU0lPQ0dWSCwgKGNhZGRyX3QpJmlmcikgPT0gLTEpCisJ
 CWVycigxLCAiU0lPQ0dWSCIpOworCisJbWVtc2V0KGNhcnByLmNhcnByX2NhcnBkZXYsIDAsIHNp
 emVvZihjYXJwci5jYXJwcl9jYXJwZGV2KSk7CisKKwlpZiAoaW9jdGwocywgU0lPQ1NWSCwgKGNh
 ZGRyX3QpJmlmcikgPT0gLTEpCisJCWVycigxLCAiU0lPQ1NWSCIpOworCisJcmV0dXJuOworfQor
 CiBzdGF0aWMgc3RydWN0IGNtZCBjYXJwX2NtZHNbXSA9IHsKIAlERUZfQ01EX0FSRygiYWR2YmFz
 ZSIsCXNldGNhcnBfYWR2YmFzZSksCiAJREVGX0NNRF9BUkcoImFkdnNrZXciLAlzZXRjYXJwX2Fk
 dnNrZXcpLAogCURFRl9DTURfQVJHKCJwYXNzIiwJc2V0Y2FycF9wYXNzd2QpLAogCURFRl9DTURf
 QVJHKCJ2aGlkIiwJc2V0Y2FycF92aGlkKSwKKwlERUZfQ01EX0FSRygiY2FycGRldiIsCXNldGNh
 cnBfY2FycGRldiksCisJREVGX0NNRF9PUFRBUkcoIi1jYXJwZGV2IiwJc2V0Y2FycF91bnNldGNh
 cnBkZXYpLAogfTsKIHN0YXRpYyBzdHJ1Y3QgYWZzd3RjaCBhZl9jYXJwID0gewogCS5hZl9uYW1l
 CT0gImFmX2NhcnAiLApkaWZmIC0tZ2l0IGEvc3lzL2FtZDY0L2NvbmYvQ0FSUCBiL3N5cy9hbWQ2
 NC9jb25mL0NBUlAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzEwYTk3MAot
 LS0gL2Rldi9udWxsCisrKyBiL3N5cy9hbWQ2NC9jb25mL0NBUlAKQEAgLTAsMCArMSw0IEBACitp
 bmNsdWRlIAlHRU5FUklDCitpZGVudCAJCUNBUlAKKworZGV2aWNlCQljYXJwCmRpZmYgLS1naXQg
 YS9zeXMvbmV0L2V0aGVybmV0LmggYi9zeXMvbmV0L2V0aGVybmV0LmgKaW5kZXggN2Q0NWNlMy4u
 ZTdhMzQ1MCAxMDA2NDQKLS0tIGEvc3lzL25ldC9ldGhlcm5ldC5oCisrKyBiL3N5cy9uZXQvZXRo
 ZXJuZXQuaApAQCAtMzgwLDYgKzM4MCw3IEBAIGV4dGVybgl2b2lkIGV0aGVyX2RlbXV4KHN0cnVj
 dCBpZm5ldCAqLCBzdHJ1Y3QgbWJ1ZiAqKTsKIGV4dGVybgl2b2lkIGV0aGVyX2lmYXR0YWNoKHN0
 cnVjdCBpZm5ldCAqLCBjb25zdCB1X2ludDhfdCAqKTsKIGV4dGVybgl2b2lkIGV0aGVyX2lmZGV0
 YWNoKHN0cnVjdCBpZm5ldCAqKTsKIGV4dGVybglpbnQgIGV0aGVyX2lvY3RsKHN0cnVjdCBpZm5l
 dCAqLCB1X2xvbmcsIGNhZGRyX3QpOworZXh0ZXJuCXZvaWQgZXRoZXJfaW5wdXQoc3RydWN0IGlm
 bmV0ICosIHN0cnVjdCBtYnVmICopOwogZXh0ZXJuCWludCAgZXRoZXJfb3V0cHV0KHN0cnVjdCBp
 Zm5ldCAqLAogCQkgICBzdHJ1Y3QgbWJ1ZiAqLCBzdHJ1Y3Qgc29ja2FkZHIgKiwgc3RydWN0IHJ0
 ZW50cnkgKik7CiBleHRlcm4JaW50ICBldGhlcl9vdXRwdXRfZnJhbWUoc3RydWN0IGlmbmV0ICos
 IHN0cnVjdCBtYnVmICopOwpkaWZmIC0tZ2l0IGEvc3lzL25ldC9pZi5jIGIvc3lzL25ldC9pZi5j
 CmluZGV4IDlkYjg5MzUuLjkxNzhhM2QgMTAwNjQ0Ci0tLSBhL3N5cy9uZXQvaWYuYworKysgYi9z
 eXMvbmV0L2lmLmMKQEAgLTEzMDksOCArMTMwOSw3IEBAIGlmX3Vucm91dGUoc3RydWN0IGlmbmV0
 ICppZnAsIGludCBmbGFnLCBpbnQgZmFtKQogCQkJcGZjdGxpbnB1dChQUkNfSUZET1dOLCBpZmEt
 PmlmYV9hZGRyKTsKIAlpZl9xZmx1c2goJmlmcC0+aWZfc25kKTsKICNpZmRlZiBERVZfQ0FSUAot
 CWlmIChpZnAtPmlmX2NhcnApCi0JCWNhcnBfY2FycGRldl9zdGF0ZShpZnAtPmlmX2NhcnApOwor
 CWNhcnBfY2FycGRldl9zdGF0ZShpZnApOwogI2VuZGlmCiAJcnRfaWZtc2coaWZwKTsKIH0KQEAg
 LTEzMzMsOCArMTMzMiw3IEBAIGlmX3JvdXRlKHN0cnVjdCBpZm5ldCAqaWZwLCBpbnQgZmxhZywg
 aW50IGZhbSkKIAkJaWYgKGZhbSA9PSBQRl9VTlNQRUMgfHwgKGZhbSA9PSBpZmEtPmlmYV9hZGRy
 LT5zYV9mYW1pbHkpKQogCQkJcGZjdGxpbnB1dChQUkNfSUZVUCwgaWZhLT5pZmFfYWRkcik7CiAj
 aWZkZWYgREVWX0NBUlAKLQlpZiAoaWZwLT5pZl9jYXJwKQotCQljYXJwX2NhcnBkZXZfc3RhdGUo
 aWZwLT5pZl9jYXJwKTsKKwljYXJwX2NhcnBkZXZfc3RhdGUoaWZwKTsKICNlbmRpZgogCXJ0X2lm
 bXNnKGlmcCk7CiAjaWZkZWYgSU5FVDYKQEAgLTEzODYsOCArMTM4NCw3IEBAIGRvX2xpbmtfc3Rh
 dGVfY2hhbmdlKHZvaWQgKmFyZywgaW50IHBlbmRpbmcpCiAJICAgIElGUDJBQyhpZnApLT5hY19u
 ZXRncmFwaCAhPSBOVUxMKQogCQkoKm5nX2V0aGVyX2xpbmtfc3RhdGVfcCkoaWZwLCBsaW5rX3N0
 YXRlKTsKICNpZmRlZiBERVZfQ0FSUAotCWlmIChpZnAtPmlmX2NhcnApCi0JCWNhcnBfY2FycGRl
 dl9zdGF0ZShpZnAtPmlmX2NhcnApOworCWNhcnBfY2FycGRldl9zdGF0ZShpZnApOwogI2VuZGlm
 CiAJaWYgKGlmcC0+aWZfYnJpZGdlKSB7CiAJCUtBU1NFUlQoYnN0cF9saW5rc3RhdGVfcCAhPSBO
 VUxMLCgiaWZfYnJpZGdlIGJzdHAgbm90IGxvYWRlZCEiKSk7CmRpZmYgLS1naXQgYS9zeXMvbmV0
 L2lmX2V0aGVyc3Vici5jIGIvc3lzL25ldC9pZl9ldGhlcnN1YnIuYwppbmRleCA3MDIzZTljLi4x
 NzBiY2M3IDEwMDY0NAotLS0gYS9zeXMvbmV0L2lmX2V0aGVyc3Vici5jCisrKyBiL3N5cy9uZXQv
 aWZfZXRoZXJzdWJyLmMKQEAgLTE1Myw2ICsxNTMsOSBAQCBldGhlcl9vdXRwdXQoc3RydWN0IGlm
 bmV0ICppZnAsIHN0cnVjdCBtYnVmICptLAogCXVfY2hhciBlc3JjW0VUSEVSX0FERFJfTEVOXSwg
 ZWRzdFtFVEhFUl9BRERSX0xFTl07CiAJc3RydWN0IGV0aGVyX2hlYWRlciAqZWg7CiAJc3RydWN0
 IHBmX210YWcgKnQ7CisjaWZkZWYgREVWX0NBUlAKKwlzdHJ1Y3QgaWZuZXQgKmlmcDAgPSBpZnA7
 CisjZW5kaWYKIAlpbnQgbG9vcF9jb3B5ID0gMTsKIAlpbnQgaGxlbjsJLyogbGluayBsYXllciBo
 ZWFkZXIgbGVuZ3RoICovCiAKQEAgLTE2Miw2ICsxNjUsMTkgQEAgZXRoZXJfb3V0cHV0KHN0cnVj
 dCBpZm5ldCAqaWZwLCBzdHJ1Y3QgbWJ1ZiAqbSwKIAkJc2VuZGVycihlcnJvcik7CiAjZW5kaWYK
 IAorI2lmZGVmIERFVl9DQVJQCisJaWYgKGlmcC0+aWZfdHlwZSA9PSBJRlRfQ0FSUCkgeworCQlz
 dHJ1Y3QgaWZhZGRyICppZmE7CisKKwkJaWYgKGRzdCAhPSBOVUxMICYmIGlmcC0+aWZfbGlua19z
 dGF0ZSA9PSBMSU5LX1NUQVRFX1VQICYmCisJCSAgICAoaWZhID0gaWZhX2lmd2l0aGFkZHIoZHN0
 KSkgIT0gTlVMTCAmJgorCQkgICAgaWZhLT5pZmFfaWZwID09IGlmcCkKKwkJCXJldHVybiAobG9v
 dXRwdXQoaWZwLCBtLCBkc3QsIHJ0MCkpOworCisJCWlmcCA9IGlmcC0+aWZfY2FycGRldjsKKwl9
 CisjZW5kaWYKKwogCWlmIChpZnAtPmlmX2ZsYWdzICYgSUZGX01PTklUT1IpCiAJCXNlbmRlcnIo
 RU5FVERPV04pOwogCWlmICghKChpZnAtPmlmX2ZsYWdzICYgSUZGX1VQKSAmJgpAQCAtMTcyLDcg
 KzE4OCwxMSBAQCBldGhlcl9vdXRwdXQoc3RydWN0IGlmbmV0ICppZnAsIHN0cnVjdCBtYnVmICpt
 LAogCXN3aXRjaCAoZHN0LT5zYV9mYW1pbHkpIHsKICNpZmRlZiBJTkVUCiAJY2FzZSBBRl9JTkVU
 OgorI2lmZGVmIERFVl9DQVJQCisJCWVycm9yID0gYXJwcmVzb2x2ZShpZnAwLCBydDAsIG0sIGRz
 dCwgZWRzdCk7CisjZWxzZQogCQllcnJvciA9IGFycHJlc29sdmUoaWZwLCBydDAsIG0sIGRzdCwg
 ZWRzdCk7CisjZW5kaWYKIAkJaWYgKGVycm9yKQogCQkJcmV0dXJuIChlcnJvciA9PSBFV09VTERC
 TE9DSyA/IDAgOiBlcnJvcik7CiAJCXR5cGUgPSBodG9ucyhFVEhFUlRZUEVfSVApOwpAQCAtMjkz
 LDYgKzMxMywxNCBAQCBldGhlcl9vdXRwdXQoc3RydWN0IGlmbmV0ICppZnAsIHN0cnVjdCBtYnVm
 ICptLAogCQkodm9pZCltZW1jcHkoZWgtPmV0aGVyX3Nob3N0LCBJRl9MTEFERFIoaWZwKSwKIAkJ
 CXNpemVvZihlaC0+ZXRoZXJfc2hvc3QpKTsKIAorI2lmZGVmIERFVl9DQVJQCisJaWYgKGlmcDAg
 IT0gaWZwICYmIGlmcDAtPmlmX3R5cGUgPT0gSUZUX0NBUlApIHsKKwkJLyogWFhYOiBMSU5LMSAq
 LworCQkodm9pZCltZW1jcHkoZWgtPmV0aGVyX3Nob3N0LCBJRl9MTEFERFIoaWZwMCksCisJCSAg
 ICBzaXplb2YoZWgtPmV0aGVyX3Nob3N0KSk7CisJfQorI2VuZGlmCisKIAkvKgogCSAqIElmIGEg
 c2ltcGxleCBpbnRlcmZhY2UsIGFuZCB0aGUgcGFja2V0IGlzIGJlaW5nIHNlbnQgdG8gb3VyCiAJ
 ICogRXRoZXJuZXQgYWRkcmVzcyBvciBhIGJyb2FkY2FzdCBhZGRyZXNzLCBsb29wYmFjayBhIGNv
 cHkuCkBAIC0zNTEsMTIgKzM3OSw2IEBAIGV0aGVyX291dHB1dChzdHJ1Y3QgaWZuZXQgKmlmcCwg
 c3RydWN0IG1idWYgKm0sCiAJCXJldHVybiAoZXJyb3IpOwogCX0KIAotI2lmZGVmIERFVl9DQVJQ
 Ci0JaWYgKGlmcC0+aWZfY2FycCAmJgotCSAgICAoZXJyb3IgPSBjYXJwX291dHB1dChpZnAsIG0s
 IGRzdCwgTlVMTCkpKQotCQlnb3RvIGJhZDsKLSNlbmRpZgotCiAJLyogSGFuZGxlIG5nX2V0aGVy
 KDQpIHByb2Nlc3NpbmcsIGlmIGFueSAqLwogCWlmIChJRlAyQUMoaWZwKS0+YWNfbmV0Z3JhcGgg
 IT0gTlVMTCkgewogCQlLQVNTRVJUKG5nX2V0aGVyX291dHB1dF9wICE9IE5VTEwsCkBAIC01MDYs
 NyArNTI4LDcgQEAgZXRoZXJfaXBmd19jaGsoc3RydWN0IG1idWYgKiptMCwgc3RydWN0IGlmbmV0
 ICpkc3QsCiAgKiBQcm9jZXNzIGEgcmVjZWl2ZWQgRXRoZXJuZXQgcGFja2V0OyB0aGUgcGFja2V0
 IGlzIGluIHRoZQogICogbWJ1ZiBjaGFpbiBtIHdpdGggdGhlIGV0aGVybmV0IGhlYWRlciBhdCB0
 aGUgZnJvbnQuCiAgKi8KLXN0YXRpYyB2b2lkCit2b2lkCiBldGhlcl9pbnB1dChzdHJ1Y3QgaWZu
 ZXQgKmlmcCwgc3RydWN0IG1idWYgKm0pCiB7CiAJc3RydWN0IGV0aGVyX2hlYWRlciAqZWg7CkBA
 IC02NTgsMTkgKzY4MCwxNSBAQCBldGhlcl9pbnB1dChzdHJ1Y3QgaWZuZXQgKmlmcCwgc3RydWN0
 IG1idWYgKm0pCiAJfQogCiAjaWZkZWYgREVWX0NBUlAKLQkvKgotCSAqIENsZWFyIE1fUFJPTUlT
 QyBvbiBmcmFtZSBzbyB0aGF0IGNhcnAoNCkgd2lsbCBzZWUgaXQgd2hlbiB0aGUKLQkgKiBtYnVm
 IGZsb3dzIHVwIHRvIExheWVyIDMuCi0JICogRnJlZUJTRCdzIGltcGxlbWVudGF0aW9uIG9mIGNh
 cnAoNCkgdXNlcyB0aGUgaW5wcm90b3N3Ci0JICogdG8gZGlzcGF0Y2ggSVBQUk9UT19DQVJQLiBj
 YXJwKDQpIGFsc28gYWxsb2NhdGVzIGl0cyBvd24KLQkgKiBFdGhlcm5ldCBhZGRyZXNzZXMgb2Yg
 dGhlIGZvcm0gMDA6MDA6NWU6MDA6MDE6eHgsIHdoaWNoCi0JICogaXMgb3V0c2lkZSB0aGUgc2Nv
 cGUgb2YgdGhlIE1fUFJPTUlTQyB0ZXN0IGJlbG93LgotCSAqIFRPRE86IE1haW50YWluIGEgaGFz
 aCB0YWJsZSBvZiBldGhlcm5ldCBhZGRyZXNzZXMgb3RoZXIgdGhhbgotCSAqIGV0aGVyX2Rob3N0
 IHdoaWNoIG1heSBiZSBhY3RpdmUgb24gdGhpcyBpZnAuCi0JICovCi0JaWYgKGlmcC0+aWZfY2Fy
 cCAmJiBjYXJwX2ZvcnVzKGlmcC0+aWZfY2FycCwgZWgtPmV0aGVyX2Rob3N0KSkgewotCQltLT5t
 X2ZsYWdzICY9IH5NX1BST01JU0M7Ci0JfSBlbHNlCisJaWYgKGlmcC0+aWZfY2FycCkgeworCQlp
 ZiAoaWZwLT5pZl90eXBlICE9IElGVF9DQVJQICYmIChjYXJwX2lucHV0KG0pID09IDApKQorCQkJ
 cmV0dXJuOworCQllbHNlIGlmIChpZnAtPmlmX3R5cGUgPT0gSUZUX0NBUlAgJiYKKwkJICAgIC8q
 IFhYWDogTElOSzIgKi8KKwkJICAgIG0tPm1fZmxhZ3MgJiAoTV9CQ0FTVCB8IE1fTUNBU1QpICYm
 CisJCSAgICAhYmNtcChJRlAyQUMoaWZwKSwgZWgtPmV0aGVyX2Rob3N0LCBFVEhFUl9BRERSX0xF
 TikpCisJCQltLT5tX2ZsYWdzICY9IH4oTV9CQ0FTVCB8IE1fTUNBU1QpOworCX0KICNlbmRpZgog
 CXsKIAkJLyoKZGlmZiAtLWdpdCBhL3N5cy9uZXQvaWZfbG9vcC5jIGIvc3lzL25ldC9pZl9sb29w
 LmMKaW5kZXggYmQxNWJkZi4uMTcwNmY1OCAxMDA2NDQKLS0tIGEvc3lzL25ldC9pZl9sb29wLmMK
 KysrIGIvc3lzL25ldC9pZl9sb29wLmMKQEAgLTk4LDggKzk4LDYgQEAgc3RydWN0IGxvX3NvZnRj
 IHsKIAogaW50CQlsb2lvY3RsKHN0cnVjdCBpZm5ldCAqLCB1X2xvbmcsIGNhZGRyX3QpOwogc3Rh
 dGljIHZvaWQJbG9ydHJlcXVlc3QoaW50LCBzdHJ1Y3QgcnRlbnRyeSAqLCBzdHJ1Y3QgcnRfYWRk
 cmluZm8gKik7Ci1pbnQJCWxvb3V0cHV0KHN0cnVjdCBpZm5ldCAqaWZwLCBzdHJ1Y3QgbWJ1ZiAq
 bSwKLQkJICAgIHN0cnVjdCBzb2NrYWRkciAqZHN0LCBzdHJ1Y3QgcnRlbnRyeSAqcnQpOwogc3Rh
 dGljIGludAlsb19jbG9uZV9jcmVhdGUoc3RydWN0IGlmX2Nsb25lICosIGludCwgY2FkZHJfdCk7
 CiBzdGF0aWMgdm9pZAlsb19jbG9uZV9kZXN0cm95KHN0cnVjdCBpZm5ldCAqKTsKIApkaWZmIC0t
 Z2l0IGEvc3lzL25ldC9pZl92YXIuaCBiL3N5cy9uZXQvaWZfdmFyLmgKaW5kZXggNDRhMjk3ZS4u
 YjBkYTU5OSAxMDA2NDQKLS0tIGEvc3lzL25ldC9pZl92YXIuaAorKysgYi9zeXMvbmV0L2lmX3Zh
 ci5oCkBAIC0xMzEsNyArMTMxLDEyIEBAIHN0cnVjdCBpZm5ldCB7CiAJCSAqLwogCXN0cnVjdAlr
 bmxpc3QgaWZfa2xpc3Q7CS8qIGV2ZW50cyBhdHRhY2hlZCB0byB0aGlzIGlmICovCiAJaW50CWlm
 X3Bjb3VudDsJCS8qIG51bWJlciBvZiBwcm9taXNjdW91cyBsaXN0ZW5lcnMgKi8KLQlzdHJ1Y3QJ
 Y2FycF9pZiAqaWZfY2FycDsJLyogY2FycCBpbnRlcmZhY2Ugc3RydWN0dXJlICovCisJdW5pb24g
 eworCQlzdHJ1Y3QgY2FycF9pZiAqY2FycF9zOworCQlzdHJ1Y3QgaWZuZXQgKmNhcnBfZDsKKwl9
 IGlmX2NhcnBfcHRyOworI2RlZmluZQlpZl9jYXJwCQlpZl9jYXJwX3B0ci5jYXJwX3MKKyNkZWZp
 bmUJaWZfY2FycGRldglpZl9jYXJwX3B0ci5jYXJwX2QKIAlzdHJ1Y3QJYnBmX2lmICppZl9icGY7
 CQkvKiBwYWNrZXQgZmlsdGVyIHN0cnVjdHVyZSAqLwogCXVfc2hvcnQJaWZfaW5kZXg7CQkvKiBu
 dW1lcmljIGFiYnJldmlhdGlvbiBmb3IgdGhpcyBpZiAgKi8KIAlzaG9ydAlpZl90aW1lcjsJCS8q
 IHRpbWUgJ3RpbCBpZl93YXRjaGRvZyBjYWxsZWQgKi8KQEAgLTY5Miw2ICs2OTcsOCBAQCBzdHJ1
 Y3QJaWZhZGRyICppZmFfaWZ3aXRocm91dGUoaW50LCBzdHJ1Y3Qgc29ja2FkZHIgKiwgc3RydWN0
 IHNvY2thZGRyICopOwogc3RydWN0CWlmYWRkciAqaWZhb2ZfaWZwZm9yYWRkcihzdHJ1Y3Qgc29j
 a2FkZHIgKiwgc3RydWN0IGlmbmV0ICopOwogCiBpbnQJaWZfc2ltbG9vcChzdHJ1Y3QgaWZuZXQg
 KmlmcCwgc3RydWN0IG1idWYgKm0sIGludCBhZiwgaW50IGhsZW4pOworaW50CWxvb3V0cHV0KHN0
 cnVjdCBpZm5ldCAqaWZwLCBzdHJ1Y3QgbWJ1ZiAqbSwgc3RydWN0IHNvY2thZGRyICpkc3QsCisJ
 ICAgIHN0cnVjdCBydGVudHJ5ICpydCk7CiAKIHR5cGVkZWYJdm9pZCAqaWZfY29tX2FsbG9jX3Qo
 dV9jaGFyIHR5cGUsIHN0cnVjdCBpZm5ldCAqaWZwKTsKIHR5cGVkZWYJdm9pZCBpZl9jb21fZnJl
 ZV90KHZvaWQgKmNvbSwgdV9jaGFyIHR5cGUpOwpkaWZmIC0tZ2l0IGEvc3lzL25ldGluZXQvaWZf
 ZXRoZXIuYyBiL3N5cy9uZXRpbmV0L2lmX2V0aGVyLmMKaW5kZXggMTNmMmMwNi4uYjRmNjY3ZCAx
 MDA2NDQKLS0tIGEvc3lzL25ldGluZXQvaWZfZXRoZXIuYworKysgYi9zeXMvbmV0aW5ldC9pZl9l
 dGhlci5jCkBAIC0xMTAsNyArMTEwLDYgQEAgU1lTQ1RMX0lOVChfbmV0X2xpbmtfZXRoZXJfaW5l
 dCwgT0lEX0FVVE8sIHByb3h5YWxsLCBDVExGTEFHX1JXLAogCSAgICZhcnBfcHJveHlhbGwsIDAs
 ICJFbmFibGUgcHJveHkgQVJQIGZvciBhbGwgc3VpdGFibGUgcmVxdWVzdHMiKTsKIAogc3RhdGlj
 IHZvaWQJYXJwX2luaXQodm9pZCk7Ci1zdGF0aWMgdm9pZAlhcnBfcnRyZXF1ZXN0KGludCwgc3Ry
 dWN0IHJ0ZW50cnkgKiwgc3RydWN0IHJ0X2FkZHJpbmZvICopOwogc3RhdGljIHZvaWQJYXJwcmVx
 dWVzdChzdHJ1Y3QgaWZuZXQgKiwKIAkJCXN0cnVjdCBpbl9hZGRyICosIHN0cnVjdCBpbl9hZGRy
 ICosIHVfY2hhciAqKTsKIHN0YXRpYyB2b2lkCWFycGludHIoc3RydWN0IG1idWYgKik7CkBAIC0x
 NDQsNyArMTQzLDcgQEAgYXJwdGltZXIodm9pZCAqYXJnKQogLyoKICAqIFBhcmFsbGVsIHRvIGxs
 Y19ydHJlcXVlc3QuCiAgKi8KLXN0YXRpYyB2b2lkCit2b2lkCiBhcnBfcnRyZXF1ZXN0KGludCBy
 ZXEsIHN0cnVjdCBydGVudHJ5ICpydCwgc3RydWN0IHJ0X2FkZHJpbmZvICppbmZvKQogewogCXN0
 cnVjdCBzb2NrYWRkciAqZ2F0ZTsKQEAgLTU3NSw5ICs1NzQsNiBAQCBpbl9hcnBpbnB1dChzdHJ1
 Y3QgbWJ1ZiAqbSkKIAlpbnQgb3AsIHJpZl9sZW47CiAJaW50IHJlcV9sZW47CiAJaW50IGJyaWRn
 ZWQgPSAwOwotI2lmZGVmIERFVl9DQVJQCi0JaW50IGNhcnBfbWF0Y2ggPSAwOwotI2VuZGlmCiAK
 IAlpZiAoaWZwLT5pZl9icmlkZ2UpCiAJCWJyaWRnZWQgPSAxOwpAQCAtNjA4LDEyICs2MDQsMTEg
 QEAgaW5fYXJwaW5wdXQoc3RydWN0IG1idWYgKm0pCiAJCSAgICBpdGFkZHIuc19hZGRyID09IGlh
 LT5pYV9hZGRyLnNpbl9hZGRyLnNfYWRkcikKIAkJCWdvdG8gbWF0Y2g7CiAjaWZkZWYgREVWX0NB
 UlAKLQkJaWYgKGlmcC0+aWZfY2FycCAhPSBOVUxMICYmCisJCWlmIChpZnAtPmlmX3R5cGUgIT0g
 SUZUX0NBUlAgJiYgaWZwLT5pZl9jYXJwICE9IE5VTEwgJiYKKwkJICAgIGlhLT5pYV9pZnAtPmlm
 X3R5cGUgPT0gSUZUX0NBUlAgJiYKIAkJICAgIGNhcnBfaWFtYXRjaChpZnAtPmlmX2NhcnAsIGlh
 LCAmaXNhZGRyLCAmZW5hZGRyKSAmJgotCQkgICAgaXRhZGRyLnNfYWRkciA9PSBpYS0+aWFfYWRk
 ci5zaW5fYWRkci5zX2FkZHIpIHsKLQkJCWNhcnBfbWF0Y2ggPSAxOworCQkgICAgaXRhZGRyLnNf
 YWRkciA9PSBpYS0+aWFfYWRkci5zaW5fYWRkci5zX2FkZHIpCiAJCQlnb3RvIG1hdGNoOwotCQl9
 CiAjZW5kaWYKIAl9CiAJTElTVF9GT1JFQUNIKGlhLCBJTkFERFJfSEFTSChpc2FkZHIuc19hZGRy
 KSwgaWFfaGFzaCkKQEAgLTY3Niw3ICs2NzEsOSBAQCBtYXRjaDoKIAkvKiBUaGUgZm9sbG93aW5n
 IGlzIG5vdCBhbiBlcnJvciB3aGVuIGRvaW5nIGJyaWRnaW5nLiAqLwogCWlmICghYnJpZGdlZCAm
 JiBydC0+cnRfaWZwICE9IGlmcAogI2lmZGVmIERFVl9DQVJQCi0JICAgICYmIChpZnAtPmlmX3R5
 cGUgIT0gSUZUX0NBUlAgfHwgIWNhcnBfbWF0Y2gpCisJICAgICYmICEocnQtPnJ0X2lmcC0+aWZf
 dHlwZSA9PSBJRlRfQ0FSUCAmJgorCSAgICBydC0+cnRfaWZwLT5pZl9jYXJwZGV2ID09IGlmcCkg
 JiYKKwkgICAgIShpZnAtPmlmX3R5cGUgPT0gSUZUX0NBUlAgJiYgaWZwLT5pZl9jYXJwZGV2ID09
 IHJ0LT5ydF9pZnApCiAjZW5kaWYKIAkJCQkJCQkpIHsKIAkJaWYgKGxvZ19hcnBfd3JvbmdfaWZh
 Y2UpCmRpZmYgLS1naXQgYS9zeXMvbmV0aW5ldC9pZl9ldGhlci5oIGIvc3lzL25ldGluZXQvaWZf
 ZXRoZXIuaAppbmRleCA5YmM2YjdiLi44YzM2ZTAyIDEwMDY0NAotLS0gYS9zeXMvbmV0aW5ldC9p
 Zl9ldGhlci5oCisrKyBiL3N5cy9uZXRpbmV0L2lmX2V0aGVyLmgKQEAgLTExMyw2ICsxMTMsNyBA
 QCBpbnQJYXJwcmVzb2x2ZShzdHJ1Y3QgaWZuZXQgKmlmcCwgc3RydWN0IHJ0ZW50cnkgKnJ0LAog
 CQlzdHJ1Y3QgbWJ1ZiAqbSwgc3RydWN0IHNvY2thZGRyICpkc3QsIHVfY2hhciAqZGVzdGVuKTsK
 IHZvaWQJYXJwX2lmaW5pdChzdHJ1Y3QgaWZuZXQgKiwgc3RydWN0IGlmYWRkciAqKTsKIHZvaWQJ
 YXJwX2lmaW5pdDIoc3RydWN0IGlmbmV0ICosIHN0cnVjdCBpZmFkZHIgKiwgdV9jaGFyICopOwor
 dm9pZAlhcnBfcnRyZXF1ZXN0KGludCwgc3RydWN0IHJ0ZW50cnkgKiwgc3RydWN0IHJ0X2FkZHJp
 bmZvICopOwogI2VuZGlmCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvc3lzL25ldGluZXQvaW5fcHJv
 dG8uYyBiL3N5cy9uZXRpbmV0L2luX3Byb3RvLmMKaW5kZXggNTIzOTgwNS4uZjY0MmJiOSAxMDA2
 NDQKLS0tIGEvc3lzL25ldGluZXQvaW5fcHJvdG8uYworKysgYi9zeXMvbmV0aW5ldC9pbl9wcm90
 by5jCkBAIC0zMTgsNyArMzE4LDcgQEAgc3RydWN0IHByb3Rvc3cgaW5ldHN3W10gPSB7CiAJLnBy
 X2RvbWFpbiA9CQkmaW5ldGRvbWFpbiwKIAkucHJfcHJvdG9jb2wgPQkJSVBQUk9UT19DQVJQLAog
 CS5wcl9mbGFncyA9CQlQUl9BVE9NSUN8UFJfQUREUiwKLQkucHJfaW5wdXQgPQkJY2FycF9pbnB1
 dCwKKwkucHJfaW5wdXQgPQkJY2FycF9wcm90b19pbnB1dCwKIAkucHJfb3V0cHV0ID0JCShwcl9v
 dXRwdXRfdCopcmlwX291dHB1dCwKIAkucHJfY3Rsb3V0cHV0ID0JCXJpcF9jdGxvdXRwdXQsCiAJ
 LnByX3VzcnJlcXMgPQkJJnJpcF91c3JyZXFzCmRpZmYgLS1naXQgYS9zeXMvbmV0aW5ldC9pcF9j
 YXJwLmMgYi9zeXMvbmV0aW5ldC9pcF9jYXJwLmMKaW5kZXggYzA4ZDM5Zi4uYWVhMzUxOCAxMDA2
 NDQKLS0tIGEvc3lzL25ldGluZXQvaXBfY2FycC5jCisrKyBiL3N5cy9uZXRpbmV0L2lwX2NhcnAu
 YwpAQCAtOTIsMTEgKzkyLDkgQEAgU1lTQ1RMX0RFQ0woX25ldF9pbmV0X2NhcnApOwogCiBzdHJ1
 Y3QgY2FycF9zb2Z0YyB7CiAJc3RydWN0IGlmbmV0CSAJKnNjX2lmcDsJLyogSW50ZXJmYWNlIGNs
 dWUgKi8KLQlzdHJ1Y3QgaWZuZXQJCSpzY19jYXJwZGV2OwkvKiBQb2ludGVyIHRvIHBhcmVudCBp
 bnRlcmZhY2UgKi8KLQlzdHJ1Y3QgaW5faWZhZGRyIAkqc2NfaWE7CQkvKiBwcmltYXJ5IGlmYWNl
 IGFkZHJlc3MgKi8KKyNkZWZpbmUJc2NfY2FycGRldiBzY19pZnAtPmlmX2NhcnBkZXYKIAlzdHJ1
 Y3QgaXBfbW9wdGlvbnMgCSBzY19pbW87CiAjaWZkZWYgSU5FVDYKLQlzdHJ1Y3QgaW42X2lmYWRk
 ciAJKnNjX2lhNjsJLyogcHJpbWFyeSBpZmFjZSBhZGRyZXNzIHY2ICovCiAJc3RydWN0IGlwNl9t
 b3B0aW9ucyAJIHNjX2ltNm87CiAjZW5kaWYgLyogSU5FVDYgKi8KIAlUQUlMUV9FTlRSWShjYXJw
 X3NvZnRjKQkgc2NfbGlzdDsKQEAgLTE1OSw3ICsxNTcsNyBAQCBzdHJ1Y3QgY2FycF9pZiB7CiAJ
 c3RydWN0IG10eAkgdmhpZl9tdHg7CiB9OwogCi0vKiBHZXQgY2FycF9pZiBmcm9tIHNvZnRjLiBW
 YWxpZCBhZnRlciBjYXJwX3NldF9hZGRyeyw2fS4gKi8KKy8qIEdldCBjYXJwX2lmIGZyb20gc29m
 dGMuIFZhbGlkIGFmdGVyIGNhcnBfc2V0X3thZGRyWzZdLGlmcH0uICovCiAjZGVmaW5lCVNDMkNJ
 RihzYykJCSgoc3RydWN0IGNhcnBfaWYgKikoc2MpLT5zY19jYXJwZGV2LT5pZl9jYXJwKQogCiAv
 KiBsb2NrIHBlciBjYXJwX2lmIHF1ZXVlICovCkBAIC0xOTAsNyArMTg4LDcgQEAgc3RhdGljIHZv
 aWQJY2FycF9obWFjX2dlbmVyYXRlKHN0cnVjdCBjYXJwX3NvZnRjICosIHVfaW50MzJfdCAqLAog
 c3RhdGljIGludAljYXJwX2htYWNfdmVyaWZ5KHN0cnVjdCBjYXJwX3NvZnRjICosIHVfaW50MzJf
 dCAqLAogCQkgICAgdW5zaWduZWQgY2hhciAqKTsKIHN0YXRpYyB2b2lkCWNhcnBfc2V0cm91dGUo
 c3RydWN0IGNhcnBfc29mdGMgKiwgaW50KTsKLXN0YXRpYyB2b2lkCWNhcnBfaW5wdXRfYyhzdHJ1
 Y3QgbWJ1ZiAqLCBzdHJ1Y3QgY2FycF9oZWFkZXIgKiwgc2FfZmFtaWx5X3QpOworc3RhdGljIHZv
 aWQJY2FycF9wcm90b19pbnB1dF9jKHN0cnVjdCBtYnVmICosIHN0cnVjdCBjYXJwX2hlYWRlciAq
 LCBzYV9mYW1pbHlfdCk7CiBzdGF0aWMgaW50IAljYXJwX2Nsb25lX2NyZWF0ZShzdHJ1Y3QgaWZf
 Y2xvbmUgKiwgaW50LCBjYWRkcl90KTsKIHN0YXRpYyB2b2lkIAljYXJwX2Nsb25lX2Rlc3Ryb3ko
 c3RydWN0IGlmbmV0ICopOwogc3RhdGljIHZvaWQJY2FycGRldGFjaChzdHJ1Y3QgY2FycF9zb2Z0
 YyAqLCBpbnQpOwpAQCAtMjAzLDcgKzIwMSw3IEBAIHN0YXRpYyB2b2lkCWNhcnBfc2VuZF9hcnAo
 c3RydWN0IGNhcnBfc29mdGMgKik7CiBzdGF0aWMgdm9pZAljYXJwX21hc3Rlcl9kb3duKHZvaWQg
 Kik7CiBzdGF0aWMgdm9pZAljYXJwX21hc3Rlcl9kb3duX2xvY2tlZChzdHJ1Y3QgY2FycF9zb2Z0
 YyAqKTsKIHN0YXRpYyBpbnQJY2FycF9pb2N0bChzdHJ1Y3QgaWZuZXQgKiwgdV9sb25nLCBjYWRk
 cl90KTsKLXN0YXRpYyBpbnQJY2FycF9sb291dHB1dChzdHJ1Y3QgaWZuZXQgKiwgc3RydWN0IG1i
 dWYgKiwgc3RydWN0IHNvY2thZGRyICosCitzdGF0aWMgaW50CWNhcnBfb3V0cHV0KHN0cnVjdCBp
 Zm5ldCAqLCBzdHJ1Y3QgbWJ1ZiAqLCBzdHJ1Y3Qgc29ja2FkZHIgKiwKIAkJICAgIHN0cnVjdCBy
 dGVudHJ5ICopOwogc3RhdGljIHZvaWQJY2FycF9zdGFydChzdHJ1Y3QgaWZuZXQgKik7CiBzdGF0
 aWMgdm9pZAljYXJwX3NldHJ1bihzdHJ1Y3QgY2FycF9zb2Z0YyAqLCBzYV9mYW1pbHlfdCk7CkBA
 IC0yMTIsMTMgKzIxMCwxNiBAQCBzdGF0aWMgaW50CWNhcnBfYWRkcmNvdW50KHN0cnVjdCBjYXJw
 X2lmICosIHN0cnVjdCBpbl9pZmFkZHIgKiwgaW50KTsKIGVudW0JeyBDQVJQX0NPVU5UX01BU1RF
 UiwgQ0FSUF9DT1VOVF9SVU5OSU5HIH07CiAKIHN0YXRpYyB2b2lkCWNhcnBfbXVsdGljYXN0X2Ns
 ZWFudXAoc3RydWN0IGNhcnBfc29mdGMgKik7CitzdGF0aWMgaW50CWNhcnBfc2V0X2lmcChzdHJ1
 Y3QgY2FycF9zb2Z0YyAqLCBzdHJ1Y3QgaWZuZXQgKik7CiBzdGF0aWMgaW50CWNhcnBfc2V0X2Fk
 ZHIoc3RydWN0IGNhcnBfc29mdGMgKiwgc3RydWN0IHNvY2thZGRyX2luICopOworc3RhdGljIGlu
 dAljYXJwX2pvaW5fbXVsdGljYXN0KHN0cnVjdCBjYXJwX3NvZnRjICopOwogc3RhdGljIGludAlj
 YXJwX2RlbF9hZGRyKHN0cnVjdCBjYXJwX3NvZnRjICosIHN0cnVjdCBzb2NrYWRkcl9pbiAqKTsK
 IHN0YXRpYyB2b2lkCWNhcnBfY2FycGRldl9zdGF0ZV9sb2NrZWQoc3RydWN0IGNhcnBfaWYgKik7
 CiBzdGF0aWMgdm9pZAljYXJwX3NjX3N0YXRlX2xvY2tlZChzdHJ1Y3QgY2FycF9zb2Z0YyAqKTsK
 ICNpZmRlZiBJTkVUNgogc3RhdGljIHZvaWQJY2FycF9zZW5kX25hKHN0cnVjdCBjYXJwX3NvZnRj
 ICopOwogc3RhdGljIGludAljYXJwX3NldF9hZGRyNihzdHJ1Y3QgY2FycF9zb2Z0YyAqLCBzdHJ1
 Y3Qgc29ja2FkZHJfaW42ICopOworc3RhdGljIGludAljYXJwX2pvaW5fbXVsdGljYXN0NihzdHJ1
 Y3QgY2FycF9zb2Z0YyAqKTsKIHN0YXRpYyBpbnQJY2FycF9kZWxfYWRkcjYoc3RydWN0IGNhcnBf
 c29mdGMgKiwgc3RydWN0IHNvY2thZGRyX2luNiAqKTsKIHN0YXRpYyB2b2lkCWNhcnBfbXVsdGlj
 YXN0Nl9jbGVhbnVwKHN0cnVjdCBjYXJwX3NvZnRjICopOwogI2VuZGlmCkBAIC0yNDcsOSArMjQ4
 LDkgQEAgY2FycF9obWFjX3ByZXBhcmUoc3RydWN0IGNhcnBfc29mdGMgKnNjKQogI2VuZGlmCiAK
 IAlpZiAoc2MtPnNjX2NhcnBkZXYpCi0JCUNBUlBfU0NMT0NLKHNjKTsKKwkJQ0FSUF9TQ0xPQ0tf
 QVNTRVJUKHNjKTsKIAotCS8qIFhYWDogcG9zc2libGUgcmFjZSBoZXJlICovCisJLyogWFhYOiBw
 b3NzaWJsZSByYWNlIGhlcmUgLSByZWFsbHk/ICovCiAKIAkvKiBjb21wdXRlIGlwYWQgZnJvbSBr
 ZXkgKi8KIAliemVybyhzYy0+c2NfcGFkLCBzaXplb2Yoc2MtPnNjX3BhZCkpOwpAQCAtMjg1LDgg
 KzI4Niw2IEBAIGNhcnBfaG1hY19wcmVwYXJlKHN0cnVjdCBjYXJwX3NvZnRjICpzYykKIAlmb3Ig
 KGkgPSAwOyBpIDwgc2l6ZW9mKHNjLT5zY19wYWQpOyBpKyspCiAJCXNjLT5zY19wYWRbaV0gXj0g
 MHgzNiBeIDB4NWM7CiAKLQlpZiAoc2MtPnNjX2NhcnBkZXYpCi0JCUNBUlBfU0NVTkxPQ0soc2Mp
 OwogfQogCiBzdGF0aWMgdm9pZApAQCAtMzM0LDEzICszMzMsMTA2IEBAIGNhcnBfc2V0cm91dGUo
 c3RydWN0IGNhcnBfc29mdGMgKnNjLCBpbnQgY21kKQogCVRBSUxRX0ZPUkVBQ0goaWZhLCAmU0My
 SUZQKHNjKS0+aWZfYWRkcmxpc3QsIGlmYV9saXN0KSB7CiAJCWlmIChpZmEtPmlmYV9hZGRyLT5z
 YV9mYW1pbHkgPT0gQUZfSU5FVCAmJgogCQkgICAgc2MtPnNjX2NhcnBkZXYgIT0gTlVMTCkgewot
 CQkJaW50IGNvdW50ID0gY2FycF9hZGRyY291bnQoCi0JCQkgICAgKHN0cnVjdCBjYXJwX2lmICop
 c2MtPnNjX2NhcnBkZXYtPmlmX2NhcnAsCi0JCQkgICAgaWZhdG9pYShpZmEpLCBDQVJQX0NPVU5U
 X01BU1RFUik7CisJCQlpbnQgY291bnQgPSAwLCBlcnJvcjsKKwkJCXN0cnVjdCBzb2NrYWRkciBz
 YTsKKwkJCXN0cnVjdCBydGVudHJ5ICpydDsKKwkJCXN0cnVjdCByYWRpeF9ub2RlX2hlYWQgKnJu
 aDsKKwkJCXN0cnVjdCByYWRpeF9ub2RlICpybjsKKwkJCXN0cnVjdCBydF9hZGRyaW5mbyBpbmZv
 OworCQkJaW50IGhyX290aGVyaWYsIG5yX291cmlmOworCisJCQkvKgorCQkJICogQXZvaWQgc2Ny
 ZXdpbmcgd2l0aCB0aGUgcm91dGVzIGlmIHRoZXJlIGFyZSBvdGhlcgorCQkJICogY2FycCBpbnRl
 cmZhY2VzIHdoaWNoIGFyZSBtYXN0ZXIgYW5kIGhhdmUgdGhlIHNhbWUKKwkJCSAqIGFkZHJlc3Mu
 CisJCQkgKi8KKwkJCWlmIChzYy0+c2NfY2FycGRldiAhPSBOVUxMICYmCisJCQkgICAgc2MtPnNj
 X2NhcnBkZXYtPmlmX2NhcnAgIT0gTlVMTCkgeworCQkJCWNvdW50ID0gY2FycF9hZGRyY291bnQo
 CisJCQkJICAgIChzdHJ1Y3QgY2FycF9pZiAqKXNjLT5zY19jYXJwZGV2LT5pZl9jYXJwLAorCQkJ
 CSAgICBpZmF0b2lhKGlmYSksIENBUlBfQ09VTlRfTUFTVEVSKTsKKwkJCQlpZiAoKGNtZCA9PSBS
 VE1fQUREICYmIGNvdW50ICE9IDEpIHx8CisJCQkJICAgIChjbWQgPT0gUlRNX0RFTEVURSAmJiBj
 b3VudCAhPSAwKSkKKwkJCQkJY29udGludWU7CisJCQl9CiAKLQkJCWlmICgoY21kID09IFJUTV9B
 REQgJiYgY291bnQgPT0gMSkgfHwKLQkJCSAgICAoY21kID09IFJUTV9ERUxFVEUgJiYgY291bnQg
 PT0gMCkpCi0JCQkJcnRpbml0KGlmYSwgY21kLCBSVEZfVVAgfCBSVEZfSE9TVCk7CisJCQkvKiBS
 ZW1vdmUgdGhlIGV4aXN0aW5nIGhvc3Qgcm91dGUsIGlmIGFueSAqLworCQkJYnplcm8oJmluZm8s
 IHNpemVvZihpbmZvKSk7CisJCQlpbmZvLnJ0aV9pbmZvW1JUQVhfRFNUXSA9IGlmYS0+aWZhX2Fk
 ZHI7CisJCQlpbmZvLnJ0aV9mbGFncyA9IFJURl9IT1NUOworCQkJZXJyb3IgPSBydHJlcXVlc3Qx
 KFJUTV9ERUxFVEUsICZpbmZvLCBOVUxMKTsKKwkJCXJ0X21pc3Ntc2coUlRNX0RFTEVURSwgJmlu
 Zm8sIGluZm8ucnRpX2ZsYWdzLCBlcnJvcik7CisKKwkJCS8qIENoZWNrIGZvciBvdXIgYWRkcmVz
 cyBvbiBhbm90aGVyIGludGVyZmFjZSAqLworCQkJLyogWFhYIGNyaWVzIGZvciBwcm9wZXIgQVBJ
 ICovCisJCQlybmggPSBydF90YWJsZXNbaWZhLT5pZmFfYWRkci0+c2FfZmFtaWx5XTsKKwkJCVJB
 RElYX05PREVfSEVBRF9MT0NLKHJuaCk7CisJCQlybiA9IHJuaC0+cm5oX21hdGNoYWRkcihpZmEt
 PmlmYV9hZGRyLCBybmgpOworCQkJcnQgPSAoc3RydWN0IHJ0ZW50cnkgKilybjsKKwkJCWhyX290
 aGVyaWYgPSAocnQgJiYgcnQtPnJ0X2lmcCAhPSBzYy0+c2NfaWZwICYmCisJCQkgICAgcnQtPnJ0
 X2ZsYWdzICYgKFJURl9DTE9OSU5HfFJURl9XQVNDTE9ORUQpKTsKKworCQkJLyogQ2hlY2sgZm9y
 IGEgbmV0d29yayByb3V0ZSBvbiBvdXIgaW50ZXJmYWNlICovCisJCQliY29weShpZmEtPmlmYV9h
 ZGRyLCAmc2EsIHNpemVvZihzYSkpOworCQkJc2F0b3Npbigmc2EpLT5zaW5fYWRkci5zX2FkZHIg
 PSBzYXRvc2luKGlmYS0+aWZhX25ldG1hc2sKKwkJCSAgICApLT5zaW5fYWRkci5zX2FkZHIgJiBz
 YXRvc2luKCZzYSktPnNpbl9hZGRyLnNfYWRkcjsKKwkJCXJuID0gcm5oLT5ybmhfbG9va3VwKCZz
 YSwgaWZhLT5pZmFfbmV0bWFzaywgcm5oKTsKKwkJCXJ0ID0gKHN0cnVjdCBydGVudHJ5ICopcm47
 CisJCQlucl9vdXJpZiA9IChydCAmJiBydC0+cnRfaWZwID09IHNjLT5zY19pZnApOworCQkJUkFE
 SVhfTk9ERV9IRUFEX1VOTE9DSyhybmgpOworCisJCQlzd2l0Y2ggKGNtZCkgeworCQkJY2FzZSBS
 VE1fQUREOgorCQkJCWlmIChocl9vdGhlcmlmKSB7CisJCQkJCWlmYS0+aWZhX3J0cmVxdWVzdCA9
 IE5VTEw7CisJCQkJCWlmYS0+aWZhX2ZsYWdzICY9IH5SVEZfQ0xPTklORzsKKwkJCQkJYnplcm8o
 JmluZm8sIHNpemVvZihpbmZvKSk7CisJCQkJCWluZm8ucnRpX2luZm9bUlRBWF9EU1RdID0KKwkJ
 CQkJICAgIGlmYS0+aWZhX2FkZHI7CisJCQkJCWluZm8ucnRpX2luZm9bUlRBWF9HQVRFV0FZXSA9
 CisJCQkJCSAgICBpZmEtPmlmYV9hZGRyOworCQkJCQlpbmZvLnJ0aV9mbGFncyA9IFJURl9VUCB8
 IFJURl9IT1NUOworCQkJCQllcnJvciA9IHJ0cmVxdWVzdDEoUlRNX0FERCwgJmluZm8sCisJCQkJ
 CSAgICBOVUxMKTsKKwkJCQkJcnRfbWlzc21zZyhSVE1fQURELCAmaW5mbywKKwkJCQkJICAgIGlu
 Zm8ucnRpX2ZsYWdzLCBlcnJvcik7CisJCQkJfQorCQkJCWlmICghaHJfb3RoZXJpZiB8fCBucl9v
 dXJpZiB8fCAhcnQpIHsKKwkJCQkJaWYgKG5yX291cmlmICYmICEocnQtPnJ0X2ZsYWdzICYKKwkJ
 CQkJICAgIFJURl9DTE9OSU5HKSkgeworCQkJCQkJYnplcm8oJmluZm8sIHNpemVvZihpbmZvKSk7
 CisJCQkJCQlpbmZvLnJ0aV9pbmZvW1JUQVhfRFNUXSA9ICZzYTsKKwkJCQkJCWluZm8ucnRpX2lu
 Zm9bUlRBWF9ORVRNQVNLXSA9CisJCQkJCQkgICAgaWZhLT5pZmFfbmV0bWFzazsKKwkJCQkJCWVy
 cm9yID0gcnRyZXF1ZXN0MShSVE1fREVMRVRFLAorCQkJCQkJICAgICZpbmZvLCBOVUxMKTsKKwkJ
 CQkJCXJ0X21pc3Ntc2coUlRNX0RFTEVURSwgJmluZm8sCisJCQkJCQkgICAgaW5mby5ydGlfZmxh
 Z3MsIGVycm9yKTsKKwkJCQkJfQorCisJCQkJCWlmYS0+aWZhX3J0cmVxdWVzdCA9IGFycF9ydHJl
 cXVlc3Q7CisJCQkJCWlmYS0+aWZhX2ZsYWdzIHw9IFJURl9DTE9OSU5HOworCisJCQkJCWJ6ZXJv
 KCZpbmZvLCBzaXplb2YoaW5mbykpOworCQkJCQlpbmZvLnJ0aV9pbmZvW1JUQVhfRFNUXSA9ICZz
 YTsKKwkJCQkJaW5mby5ydGlfaW5mb1tSVEFYX0dBVEVXQVldID0KKwkJCQkJICAgIGlmYS0+aWZh
 X2FkZHI7CisJCQkJCWluZm8ucnRpX2luZm9bUlRBWF9ORVRNQVNLXSA9CisJCQkJCSAgICBpZmEt
 PmlmYV9uZXRtYXNrOworCQkJCQllcnJvciA9IHJ0cmVxdWVzdDEoUlRNX0FERCwgJmluZm8sCisJ
 CQkJCSAgICBOVUxMKTsKKwkJCQkJaWYgKGVycm9yID09IDApCisJCQkJCQlpZmEtPmlmYV9mbGFn
 cyB8PSBJRkFfUk9VVEU7CisJCQkJCXJ0X21pc3Ntc2coUlRNX0FERCwgJmluZm8sCisJCQkJCSAg
 ICBpbmZvLnJ0aV9mbGFncywgZXJyb3IpOworCQkJCX0KKwkJCQlicmVhazsKKwkJCWNhc2UgUlRN
 X0RFTEVURToKKwkJCQlicmVhazsKKwkJCWRlZmF1bHQ6CisJCQkJYnJlYWs7CisJCQl9CisJCQli
 cmVhazsKIAkJfQogI2lmZGVmIElORVQ2CiAJCWlmIChpZmEtPmlmYV9hZGRyLT5zYV9mYW1pbHkg
 PT0gQUZfSU5FVDYpIHsKQEAgLTM2MCw2ICs0NTIsNyBAQCBjYXJwX2Nsb25lX2NyZWF0ZShzdHJ1
 Y3QgaWZfY2xvbmUgKmlmYywgaW50IHVuaXQsIGNhZGRyX3QgcGFyYW1zKQogCiAJc3RydWN0IGNh
 cnBfc29mdGMgKnNjOwogCXN0cnVjdCBpZm5ldCAqaWZwOworCXN0YXRpYyBjb25zdCB1X2NoYXIg
 ZWFkZHJbRVRIRVJfQUREUl9MRU5dOyAvKiAwMDowMDowMDowMDowMDowMCAqLwogCiAJTUFMTE9D
 KHNjLCBzdHJ1Y3QgY2FycF9zb2Z0YyAqLCBzaXplb2YoKnNjKSwgTV9DQVJQLCBNX1dBSVRPS3xN
 X1pFUk8pOwogCWlmcCA9IFNDMklGUChzYykgPSBpZl9hbGxvYyhJRlRfRVRIRVIpOwpAQCAtMzkx
 LDE2ICs0ODQsMTMgQEAgY2FycF9jbG9uZV9jcmVhdGUoc3RydWN0IGlmX2Nsb25lICppZmMsIGlu
 dCB1bml0LCBjYWRkcl90IHBhcmFtcykKIAkKIAlpZnAtPmlmX3NvZnRjID0gc2M7CiAJaWZfaW5p
 dG5hbWUoaWZwLCBDQVJQX0lGTkFNRSwgdW5pdCk7Ci0JaWZwLT5pZl9tdHUgPSBFVEhFUk1UVTsK
 LQlpZnAtPmlmX2ZsYWdzID0gSUZGX0xPT1BCQUNLOworCWV0aGVyX2lmYXR0YWNoKGlmcCwgZWFk
 ZHIpOworCWlmcC0+aWZfZmxhZ3MgPSBJRkZfQlJPQURDQVNUIHwgSUZGX1NJTVBMRVggfCBJRkZf
 TVVMVElDQVNUOwogCWlmcC0+aWZfaW9jdGwgPSBjYXJwX2lvY3RsOwotCWlmcC0+aWZfb3V0cHV0
 ID0gY2FycF9sb291dHB1dDsKKwlpZnAtPmlmX291dHB1dCA9IGNhcnBfb3V0cHV0OwogCWlmcC0+
 aWZfc3RhcnQgPSBjYXJwX3N0YXJ0OwogCWlmcC0+aWZfdHlwZSA9IElGVF9DQVJQOwogCWlmcC0+
 aWZfc25kLmlmcV9tYXhsZW4gPSBpZnFtYXhsZW47Ci0JaWZwLT5pZl9oZHJsZW4gPSAwOwotCWlm
 X2F0dGFjaChpZnApOwotCWJwZmF0dGFjaChTQzJJRlAoc2MpLCBETFRfTlVMTCwgc2l6ZW9mKHVf
 aW50MzJfdCkpOwogCW10eF9sb2NrKCZjYXJwX210eCk7CiAJTElTVF9JTlNFUlRfSEVBRCgmY2Fy
 cGlmX2xpc3QsIHNjLCBzY19uZXh0KTsKIAltdHhfdW5sb2NrKCZjYXJwX210eCk7CkBAIC01MDMs
 NyArNTkzLDcgQEAgY2FycF9pZmRldGFjaCh2b2lkICphcmcgX191bnVzZWQsIHN0cnVjdCBpZm5l
 dCAqaWZwKQogICogYnV0IGl0IHNlZW1zIG1vcmUgZWZmaWNpZW50IHRoaXMgd2F5IG9yIG5vdCBw
 b3NzaWJsZSBvdGhlcndpc2UuCiAgKi8KIHZvaWQKLWNhcnBfaW5wdXQoc3RydWN0IG1idWYgKm0s
 IGludCBobGVuKQorY2FycF9wcm90b19pbnB1dChzdHJ1Y3QgbWJ1ZiAqbSwgaW50IGhsZW4pCiB7
 CiAJc3RydWN0IGlwICppcCA9IG10b2QobSwgc3RydWN0IGlwICopOwogCXN0cnVjdCBjYXJwX2hl
 YWRlciAqY2g7CkBAIC01MTcsOSArNjA3LDkgQEAgY2FycF9pbnB1dChzdHJ1Y3QgbWJ1ZiAqbSwg
 aW50IGhsZW4pCiAJfQogCiAJLyogY2hlY2sgaWYgcmVjZWl2ZWQgb24gYSB2YWxpZCBjYXJwIGlu
 dGVyZmFjZSAqLwotCWlmIChtLT5tX3BrdGhkci5yY3ZpZi0+aWZfY2FycCA9PSBOVUxMKSB7CisJ
 aWYgKG0tPm1fcGt0aGRyLnJjdmlmLT5pZl90eXBlICE9IElGVF9DQVJQKSB7CiAJCWNhcnBzdGF0
 cy5jYXJwc19iYWRpZisrOwotCQlDQVJQX0xPRygiY2FycF9pbnB1dDogcGFja2V0IHJlY2VpdmVk
 IG9uIG5vbi1jYXJwICIKKwkJQ0FSUF9MT0coImNhcnBfcHJvdG9faW5wdXQ6IHBhY2tldCByZWNl
 aXZlZCBvbiBub24tY2FycCAiCiAJCSAgICAiaW50ZXJmYWNlOiAlc1xuIiwKIAkJICAgIG0tPm1f
 cGt0aGRyLnJjdmlmLT5pZl94bmFtZSk7CiAJCW1fZnJlZW0obSk7CkBAIC01MjksNyArNjE5LDcg
 QEAgY2FycF9pbnB1dChzdHJ1Y3QgbWJ1ZiAqbSwgaW50IGhsZW4pCiAJLyogdmVyaWZ5IHRoYXQg
 dGhlIElQIFRUTCBpcyAyNTUuICAqLwogCWlmIChpcC0+aXBfdHRsICE9IENBUlBfREZMVFRMKSB7
 CiAJCWNhcnBzdGF0cy5jYXJwc19iYWR0dGwrKzsKLQkJQ0FSUF9MT0coImNhcnBfaW5wdXQ6IHJl
 Y2VpdmVkIHR0bCAlZCAhPSAyNTVpIG9uICVzXG4iLAorCQlDQVJQX0xPRygiY2FycF9wcm90b19p
 bnB1dDogcmVjZWl2ZWQgdHRsICVkICE9IDI1NWkgb24gJXNcbiIsCiAJCSAgICBpcC0+aXBfdHRs
 LAogCQkgICAgbS0+bV9wa3RoZHIucmN2aWYtPmlmX3huYW1lKTsKIAkJbV9mcmVlbShtKTsKQEAg
 LTU0MCw3ICs2MzAsNyBAQCBjYXJwX2lucHV0KHN0cnVjdCBtYnVmICptLCBpbnQgaGxlbikKIAog
 CWlmIChtLT5tX3BrdGhkci5sZW4gPCBpcGxlbiArIHNpemVvZigqY2gpKSB7CiAJCWNhcnBzdGF0
 cy5jYXJwc19iYWRsZW4rKzsKLQkJQ0FSUF9MT0coImNhcnBfaW5wdXQ6IHJlY2VpdmVkIGxlbiAl
 emQgPCAiCisJCUNBUlBfTE9HKCJjYXJwX3Byb3RvX2lucHV0OiByZWNlaXZlZCBsZW4gJXpkIDwg
 IgogCQkgICAgInNpemVvZihzdHJ1Y3QgY2FycF9oZWFkZXIpXG4iLAogCQkgICAgbS0+bV9sZW4g
 LSBzaXplb2Yoc3RydWN0IGlwKSk7CiAJCW1fZnJlZW0obSk7CkBAIC01NTAsNyArNjQwLDcgQEAg
 Y2FycF9pbnB1dChzdHJ1Y3QgbWJ1ZiAqbSwgaW50IGhsZW4pCiAJaWYgKGlwbGVuICsgc2l6ZW9m
 KCpjaCkgPCBtLT5tX2xlbikgewogCQlpZiAoKG0gPSBtX3B1bGx1cChtLCBpcGxlbiArIHNpemVv
 ZigqY2gpKSkgPT0gTlVMTCkgewogCQkJY2FycHN0YXRzLmNhcnBzX2hkcm9wcysrOwotCQkJQ0FS
 UF9MT0coImNhcnBfaW5wdXQ6IHB1bGx1cCBmYWlsZWRcbiIpOworCQkJQ0FSUF9MT0coImNhcnBf
 cHJvdG9faW5wdXQ6IHB1bGx1cCBmYWlsZWRcbiIpOwogCQkJcmV0dXJuOwogCQl9CiAJCWlwID0g
 bXRvZChtLCBzdHJ1Y3QgaXAgKik7CkBAIC01NjQsNyArNjU0LDcgQEAgY2FycF9pbnB1dChzdHJ1
 Y3QgbWJ1ZiAqbSwgaW50IGhsZW4pCiAJbGVuID0gaXBsZW4gKyBzaXplb2YoKmNoKTsKIAlpZiAo
 bGVuID4gbS0+bV9wa3RoZHIubGVuKSB7CiAJCWNhcnBzdGF0cy5jYXJwc19iYWRsZW4rKzsKLQkJ
 Q0FSUF9MT0coImNhcnBfaW5wdXQ6IHBhY2tldCB0b28gc2hvcnQgJWQgb24gJXNcbiIsCisJCUNB
 UlBfTE9HKCJjYXJwX3Byb3RvX2lucHV0OiBwYWNrZXQgdG9vIHNob3J0ICVkIG9uICVzXG4iLAog
 CQkgICAgbS0+bV9wa3RoZHIubGVuLAogCQkgICAgbS0+bV9wa3RoZHIucmN2aWYtPmlmX3huYW1l
 KTsKIAkJbV9mcmVlbShtKTsKQEAgLTU4MiwxOSArNjcyLDE5IEBAIGNhcnBfaW5wdXQoc3RydWN0
 IG1idWYgKm0sIGludCBobGVuKQogCW0tPm1fZGF0YSArPSBpcGxlbjsKIAlpZiAoY2FycF9ja3N1
 bShtLCBsZW4gLSBpcGxlbikpIHsKIAkJY2FycHN0YXRzLmNhcnBzX2JhZHN1bSsrOwotCQlDQVJQ
 X0xPRygiY2FycF9pbnB1dDogY2hlY2tzdW0gZmFpbGVkIG9uICVzXG4iLAorCQlDQVJQX0xPRygi
 Y2FycF9wcm90b19pbnB1dDogY2hlY2tzdW0gZmFpbGVkIG9uICVzXG4iLAogCQkgICAgbS0+bV9w
 a3RoZHIucmN2aWYtPmlmX3huYW1lKTsKIAkJbV9mcmVlbShtKTsKIAkJcmV0dXJuOwogCX0KIAlt
 LT5tX2RhdGEgLT0gaXBsZW47CiAKLQljYXJwX2lucHV0X2MobSwgY2gsIEFGX0lORVQpOworCWNh
 cnBfcHJvdG9faW5wdXRfYyhtLCBjaCwgQUZfSU5FVCk7CiB9CiAKICNpZmRlZiBJTkVUNgogaW50
 Ci1jYXJwNl9pbnB1dChzdHJ1Y3QgbWJ1ZiAqKm1wLCBpbnQgKm9mZnAsIGludCBwcm90bykKK2Nh
 cnA2X3Byb3RvX2lucHV0KHN0cnVjdCBtYnVmICoqbXAsIGludCAqb2ZmcCwgaW50IHByb3RvKQog
 ewogCXN0cnVjdCBtYnVmICptID0gKm1wOwogCXN0cnVjdCBpcDZfaGRyICppcDYgPSBtdG9kKG0s
 IHN0cnVjdCBpcDZfaGRyICopOwpAQCAtNjA5LDkgKzY5OSw5IEBAIGNhcnA2X2lucHV0KHN0cnVj
 dCBtYnVmICoqbXAsIGludCAqb2ZmcCwgaW50IHByb3RvKQogCX0KIAogCS8qIGNoZWNrIGlmIHJl
 Y2VpdmVkIG9uIGEgdmFsaWQgY2FycCBpbnRlcmZhY2UgKi8KLQlpZiAobS0+bV9wa3RoZHIucmN2
 aWYtPmlmX2NhcnAgPT0gTlVMTCkgeworCWlmIChtLT5tX3BrdGhkci5yY3ZpZi0+aWZfdHlwZSAh
 PSBJRlRfQ0FSUCkgewogCQljYXJwc3RhdHMuY2FycHNfYmFkaWYrKzsKLQkJQ0FSUF9MT0coImNh
 cnA2X2lucHV0OiBwYWNrZXQgcmVjZWl2ZWQgb24gbm9uLWNhcnAgIgorCQlDQVJQX0xPRygiY2Fy
 cDZfcHJvdG9faW5wdXQ6IHBhY2tldCByZWNlaXZlZCBvbiBub24tY2FycCAiCiAJCSAgICAiaW50
 ZXJmYWNlOiAlc1xuIiwKIAkJICAgIG0tPm1fcGt0aGRyLnJjdmlmLT5pZl94bmFtZSk7CiAJCW1f
 ZnJlZW0obSk7CkBAIC02MjEsNyArNzExLDcgQEAgY2FycDZfaW5wdXQoc3RydWN0IG1idWYgKipt
 cCwgaW50ICpvZmZwLCBpbnQgcHJvdG8pCiAJLyogdmVyaWZ5IHRoYXQgdGhlIElQIFRUTCBpcyAy
 NTUgKi8KIAlpZiAoaXA2LT5pcDZfaGxpbSAhPSBDQVJQX0RGTFRUTCkgewogCQljYXJwc3RhdHMu
 Y2FycHNfYmFkdHRsKys7Ci0JCUNBUlBfTE9HKCJjYXJwNl9pbnB1dDogcmVjZWl2ZWQgdHRsICVk
 ICE9IDI1NSBvbiAlc1xuIiwKKwkJQ0FSUF9MT0coImNhcnA2X3Byb3RvX2lucHV0OiByZWNlaXZl
 ZCB0dGwgJWQgIT0gMjU1IG9uICVzXG4iLAogCQkgICAgaXA2LT5pcDZfaGxpbSwKIAkJICAgIG0t
 Pm1fcGt0aGRyLnJjdmlmLT5pZl94bmFtZSk7CiAJCW1fZnJlZW0obSk7CkBAIC02MzMsNyArNzIz
 LDcgQEAgY2FycDZfaW5wdXQoc3RydWN0IG1idWYgKiptcCwgaW50ICpvZmZwLCBpbnQgcHJvdG8p
 CiAJSVA2X0VYVEhEUl9HRVQoY2gsIHN0cnVjdCBjYXJwX2hlYWRlciAqLCBtLCAqb2ZmcCwgc2l6
 ZW9mKCpjaCkpOwogCWlmIChjaCA9PSBOVUxMKSB7CiAJCWNhcnBzdGF0cy5jYXJwc19iYWRsZW4r
 KzsKLQkJQ0FSUF9MT0coImNhcnA2X2lucHV0OiBwYWNrZXQgc2l6ZSAldSB0b28gc21hbGxcbiIs
 IGxlbik7CisJCUNBUlBfTE9HKCJjYXJwNl9wcm90b19pbnB1dDogcGFja2V0IHNpemUgJXUgdG9v
 IHNtYWxsXG4iLCBsZW4pOwogCQlyZXR1cm4gKElQUFJPVE9fRE9ORSk7CiAJfQogCkBAIC02NDIs
 MjIgKzczMiwyMiBAQCBjYXJwNl9pbnB1dChzdHJ1Y3QgbWJ1ZiAqKm1wLCBpbnQgKm9mZnAsIGlu
 dCBwcm90bykKIAltLT5tX2RhdGEgKz0gKm9mZnA7CiAJaWYgKGNhcnBfY2tzdW0obSwgc2l6ZW9m
 KCpjaCkpKSB7CiAJCWNhcnBzdGF0cy5jYXJwc19iYWRzdW0rKzsKLQkJQ0FSUF9MT0coImNhcnA2
 X2lucHV0OiBjaGVja3N1bSBmYWlsZWQsIG9uICVzXG4iLAorCQlDQVJQX0xPRygiY2FycDZfcHJv
 dG9faW5wdXQ6IGNoZWNrc3VtIGZhaWxlZCwgb24gJXNcbiIsCiAJCSAgICBtLT5tX3BrdGhkci5y
 Y3ZpZi0+aWZfeG5hbWUpOwogCQltX2ZyZWVtKG0pOwogCQlyZXR1cm4gKElQUFJPVE9fRE9ORSk7
 CiAJfQogCW0tPm1fZGF0YSAtPSAqb2ZmcDsKIAotCWNhcnBfaW5wdXRfYyhtLCBjaCwgQUZfSU5F
 VDYpOworCWNhcnBfcHJvdG9faW5wdXRfYyhtLCBjaCwgQUZfSU5FVDYpOwogCXJldHVybiAoSVBQ
 Uk9UT19ET05FKTsKIH0KICNlbmRpZiAvKiBJTkVUNiAqLwogCiBzdGF0aWMgdm9pZAotY2FycF9p
 bnB1dF9jKHN0cnVjdCBtYnVmICptLCBzdHJ1Y3QgY2FycF9oZWFkZXIgKmNoLCBzYV9mYW1pbHlf
 dCBhZikKK2NhcnBfcHJvdG9faW5wdXRfYyhzdHJ1Y3QgbWJ1ZiAqbSwgc3RydWN0IGNhcnBfaGVh
 ZGVyICpjaCwgc2FfZmFtaWx5X3QgYWYpCiB7Ci0Jc3RydWN0IGlmbmV0ICppZnAgPSBtLT5tX3Br
 dGhkci5yY3ZpZjsKKwlzdHJ1Y3QgaWZuZXQgKmlmcCA9IG0tPm1fcGt0aGRyLnJjdmlmLT5pZl9j
 YXJwZGV2OwogCXN0cnVjdCBjYXJwX3NvZnRjICpzYzsKIAl1X2ludDY0X3QgdG1wX2NvdW50ZXI7
 CiAJc3RydWN0IHRpbWV2YWwgc2NfdHYsIGNoX3R2OwpAQCAtNzkzLDkgKzg4Myw2IEBAIGNhcnBf
 aW5wdXRfYyhzdHJ1Y3QgbWJ1ZiAqbSwgc3RydWN0IGNhcnBfaGVhZGVyICpjaCwgc2FfZmFtaWx5
 X3QgYWYpCiBzdGF0aWMgaW50CiBjYXJwX3ByZXBhcmVfYWQoc3RydWN0IG1idWYgKm0sIHN0cnVj
 dCBjYXJwX3NvZnRjICpzYywgc3RydWN0IGNhcnBfaGVhZGVyICpjaCkKIHsKLQlzdHJ1Y3QgbV90
 YWcgKm10YWc7Ci0Jc3RydWN0IGlmbmV0ICppZnAgPSBTQzJJRlAoc2MpOwotCiAJaWYgKHNjLT5z
 Y19pbml0X2NvdW50ZXIpIHsKIAkJLyogdGhpcyBjb3VsZCBhbHNvIGJlIHNlY29uZHMgc2luY2Ug
 dW5peCBlcG9jaCAqLwogCQlzYy0+c2NfY291bnRlciA9IGFyYzRyYW5kb20oKTsKQEAgLTgwOSwx
 NiArODk2LDYgQEAgY2FycF9wcmVwYXJlX2FkKHN0cnVjdCBtYnVmICptLCBzdHJ1Y3QgY2FycF9z
 b2Z0YyAqc2MsIHN0cnVjdCBjYXJwX2hlYWRlciAqY2gpCiAKIAljYXJwX2htYWNfZ2VuZXJhdGUo
 c2MsIGNoLT5jYXJwX2NvdW50ZXIsIGNoLT5jYXJwX21kKTsKIAotCS8qIFRhZyBwYWNrZXQgZm9y
 IGNhcnBfb3V0cHV0ICovCi0JbXRhZyA9IG1fdGFnX2dldChQQUNLRVRfVEFHX0NBUlAsIHNpemVv
 ZihzdHJ1Y3QgaWZuZXQgKiksIE1fTk9XQUlUKTsKLQlpZiAobXRhZyA9PSBOVUxMKSB7Ci0JCW1f
 ZnJlZW0obSk7Ci0JCVNDMklGUChzYyktPmlmX29lcnJvcnMrKzsKLQkJcmV0dXJuIChFTk9NRU0p
 OwotCX0KLQliY29weSgmaWZwLCAoY2FkZHJfdCkobXRhZyArIDEpLCBzaXplb2Yoc3RydWN0IGlm
 bmV0ICopKTsKLQltX3RhZ19wcmVwZW5kKG0sIG10YWcpOwotCiAJcmV0dXJuICgwKTsKIH0KIApA
 QCAtODU5LDYgKzkzNiw4IEBAIGNhcnBfc2VuZF9hZF9sb2NrZWQoc3RydWN0IGNhcnBfc29mdGMg
 KnNjKQogCXN0cnVjdCBjYXJwX2hlYWRlciAqY2hfcHRyOwogCXN0cnVjdCBtYnVmICptOwogCWlu
 dCBsZW4sIGFkdmJhc2UsIGFkdnNrZXc7CisJc3RydWN0IGlmYWRkciAqaWZhOworCXN0cnVjdCBz
 b2NrYWRkciBzYTsKIAogCUNBUlBfU0NMT0NLX0FTU0VSVChzYyk7CiAKQEAgLTg4Nyw3ICs5NjYs
 NyBAQCBjYXJwX3NlbmRfYWRfbG9ja2VkKHN0cnVjdCBjYXJwX3NvZnRjICpzYykKIAljaC5jYXJw
 X2Nrc3VtID0gMDsKIAogI2lmZGVmIElORVQKLQlpZiAoc2MtPnNjX2lhKSB7CisJaWYgKHNjLT5z
 Y19uYWRkcnMpIHsKIAkJc3RydWN0IGlwICppcDsKIAogCQlNR0VUSERSKG0sIE1fRE9OVFdBSVQs
 IE1UX0hFQURFUik7CkBAIC05MTYsNyArOTk1LDE1IEBAIGNhcnBfc2VuZF9hZF9sb2NrZWQoc3Ry
 dWN0IGNhcnBfc29mdGMgKnNjKQogCQlpcC0+aXBfdHRsID0gQ0FSUF9ERkxUVEw7CiAJCWlwLT5p
 cF9wID0gSVBQUk9UT19DQVJQOwogCQlpcC0+aXBfc3VtID0gMDsKLQkJaXAtPmlwX3NyYy5zX2Fk
 ZHIgPSBzYy0+c2NfaWEtPmlhX2FkZHIuc2luX2FkZHIuc19hZGRyOworCisJCWJ6ZXJvKCZzYSwg
 c2l6ZW9mKHNhKSk7CisJCXNhLnNhX2ZhbWlseSA9IEFGX0lORVQ7CisJCWlmYSA9IGlmYW9mX2lm
 cGZvcmFkZHIoJnNhLCBTQzJJRlAoc2MpKTsKKwkJaWYgKGlmYSA9PSBOVUxMKQorCQkJaXAtPmlw
 X3NyYy5zX2FkZHIgPSAwOworCQllbHNlCisJCQlpcC0+aXBfc3JjLnNfYWRkciA9CisJCQkgICAg
 aWZhdG9pYShpZmEpLT5pYV9hZGRyLnNpbl9hZGRyLnNfYWRkcjsKIAkJaXAtPmlwX2RzdC5zX2Fk
 ZHIgPSBodG9ubChJTkFERFJfQ0FSUF9HUk9VUCk7CiAKIAkJY2hfcHRyID0gKHN0cnVjdCBjYXJw
 X2hlYWRlciAqKSgmaXBbMV0pOwpAQCAtOTU5LDcgKzEwNDYsNyBAQCBjYXJwX3NlbmRfYWRfbG9j
 a2VkKHN0cnVjdCBjYXJwX3NvZnRjICpzYykKIAl9CiAjZW5kaWYgLyogSU5FVCAqLwogI2lmZGVm
 IElORVQ2Ci0JaWYgKHNjLT5zY19pYTYpIHsKKwlpZiAoc2MtPnNjX25hZGRyczYpIHsKIAkJc3Ry
 dWN0IGlwNl9oZHIgKmlwNjsKIAogCQlNR0VUSERSKG0sIE1fRE9OVFdBSVQsIE1UX0hFQURFUik7
 CkBAIC05ODMsOCArMTA3MCwxNSBAQCBjYXJwX3NlbmRfYWRfbG9ja2VkKHN0cnVjdCBjYXJwX3Nv
 ZnRjICpzYykKIAkJaXA2LT5pcDZfdmZjIHw9IElQVjZfVkVSU0lPTjsKIAkJaXA2LT5pcDZfaGxp
 bSA9IENBUlBfREZMVFRMOwogCQlpcDYtPmlwNl9ueHQgPSBJUFBST1RPX0NBUlA7Ci0JCWJjb3B5
 KCZzYy0+c2NfaWE2LT5pYV9hZGRyLnNpbjZfYWRkciwgJmlwNi0+aXA2X3NyYywKLQkJICAgIHNp
 emVvZihzdHJ1Y3QgaW42X2FkZHIpKTsKKworCQliemVybygmc2EsIHNpemVvZihzYSkpOworCQlz
 YS5zYV9mYW1pbHkgPSBBRl9JTkVUNjsKKwkJaWZhID0gaWZhb2ZfaWZwZm9yYWRkcigmc2EsIFND
 MklGUChzYykpOworCQlpZiAoaWZhID09IE5VTEwpCisJCQliemVybygmaXA2LT5pcDZfc3JjLCBz
 aXplb2Yoc3RydWN0IGluNl9hZGRyKSk7CisJCWVsc2UKKwkJCWJjb3B5KGlmYXRvaWE2KGlmYSkt
 PmlhX2FkZHIuc2luNl9hZGRyLnM2X2FkZHIsCisJCQkgICAgJmlwNi0+aXA2X3NyYywgc2l6ZW9m
 KHN0cnVjdCBpbjZfYWRkcikpOwogCQkvKiBzZXQgdGhlIG11bHRpY2FzdCBkZXN0aW5hdGlvbiAq
 LwogCiAJCWlwNi0+aXA2X2RzdC5zNl9hZGRyMTZbMF0gPSBodG9ucygweGZmMDIpOwpAQCAtMTA1
 OCw3ICsxMTUyLDcgQEAgY2FycF9zZW5kX2FycChzdHJ1Y3QgY2FycF9zb2Z0YyAqc2MpCiAJCQlj
 b250aW51ZTsKIAogLyoJCWFycHJlcXVlc3Qoc2MtPnNjX2NhcnBkZXYsICZpbiwgJmluLCBJRl9M
 TEFERFIoc2MtPnNjX2lmcCkpOyAqLwotCQlhcnBfaWZpbml0MihzYy0+c2NfY2FycGRldiwgaWZh
 LCBJRl9MTEFERFIoc2MtPnNjX2lmcCkpOworCQlhcnBfaWZpbml0MihTQzJJRlAoc2MpLCBpZmEs
 IElGX0xMQUREUihzYy0+c2NfaWZwKSk7CiAKIAkJREVMQVkoMTAwMCk7CS8qIFhYWCAqLwogCX0K
 QEAgLTEyMTEsNyArMTMwNSw2IEBAIGNhcnBfaWFtYXRjaDYodm9pZCAqdiwgc3RydWN0IGluNl9h
 ZGRyICp0YWRkcikKIHZvaWQgKgogY2FycF9tYWNtYXRjaDYodm9pZCAqdiwgc3RydWN0IG1idWYg
 Km0sIGNvbnN0IHN0cnVjdCBpbjZfYWRkciAqdGFkZHIpCiB7Ci0Jc3RydWN0IG1fdGFnICptdGFn
 OwogCXN0cnVjdCBjYXJwX2lmICpjaWYgPSB2OwogCXN0cnVjdCBjYXJwX3NvZnRjICpzYzsKIAlz
 dHJ1Y3QgaWZhZGRyICppZmE7CkBAIC0xMjIzLDE4ICsxMzE2LDYgQEAgY2FycF9tYWNtYXRjaDYo
 dm9pZCAqdiwgc3RydWN0IG1idWYgKm0sIGNvbnN0IHN0cnVjdCBpbjZfYWRkciAqdGFkZHIpCiAJ
 CQkgICAgJmlmYXRvaWE2KGlmYSktPmlhX2FkZHIuc2luNl9hZGRyKSAmJgogIAkJCSAgICAoU0My
 SUZQKHNjKS0+aWZfZmxhZ3MgJiBJRkZfVVApICYmCiAJCQkgICAgKFNDMklGUChzYyktPmlmX2Ry
 dl9mbGFncyAmIElGRl9EUlZfUlVOTklORykpIHsKLQkJCQlzdHJ1Y3QgaWZuZXQgKmlmcCA9IFND
 MklGUChzYyk7Ci0JCQkJbXRhZyA9IG1fdGFnX2dldChQQUNLRVRfVEFHX0NBUlAsCi0JCQkJICAg
 IHNpemVvZihzdHJ1Y3QgaWZuZXQgKiksIE1fTk9XQUlUKTsKLQkJCQlpZiAobXRhZyA9PSBOVUxM
 KSB7Ci0JCQkJCS8qIGJldHRlciBhIGJpdCB0aGFuIG5vdGhpbmcgKi8KLQkJCQkJQ0FSUF9VTkxP
 Q0soY2lmKTsKLQkJCQkJcmV0dXJuIChJRl9MTEFERFIoc2MtPnNjX2lmcCkpOwotCQkJCX0KLQkJ
 CQliY29weSgmaWZwLCAoY2FkZHJfdCkobXRhZyArIDEpLAotCQkJCSAgICBzaXplb2Yoc3RydWN0
 IGlmbmV0ICopKTsKLQkJCQltX3RhZ19wcmVwZW5kKG0sIG10YWcpOwotCiAJCQkJQ0FSUF9VTkxP
 Q0soY2lmKTsKIAkJCQlyZXR1cm4gKElGX0xMQUREUihzYy0+c2NfaWZwKSk7CiAJCQl9CkBAIC0x
 NDIzLDE1ICsxNTA0LDExNiBAQCBjYXJwX211bHRpY2FzdDZfY2xlYW51cChzdHJ1Y3QgY2FycF9z
 b2Z0YyAqc2MpCiAjZW5kaWYKIAogc3RhdGljIGludAorY2FycF9zZXRfaWZwKHN0cnVjdCBjYXJw
 X3NvZnRjICpzYywgc3RydWN0IGlmbmV0ICppZnApCit7CisJc3RydWN0IGNhcnBfaWYgKmNpZiA9
 IE5VTEwsICpuY2lmID0gTlVMTDsKKwlzdHJ1Y3QgY2FycF9zb2Z0YyAqdnIsICphZnRlciA9IE5V
 TEw7CisJaW50IG15c2VsZiA9IDAsIGVycm9yID0gMDsKKworCWlmIChpZnAgPT0gc2MtPnNjX2Nh
 cnBkZXYpCisJCXJldHVybiAoMCk7CisKKwlpZiAoaWZwICE9IE5VTEwpIHsKKwkJaWYgKChpZnAt
 PmlmX2ZsYWdzICYgSUZGX01VTFRJQ0FTVCkgPT0gMCkKKwkJCXJldHVybiAoRU5PREVWKTsKKwkJ
 aWYgKGlmcC0+aWZfdHlwZSA9PSBJRlRfQ0FSUCkKKwkJCXJldHVybiAoRUlOVkFMKTsKKworCQlp
 ZiAoaWZwLT5pZl9jYXJwID09IE5VTEwpIHsKKwkJCU1BTExPQyhuY2lmLCBzdHJ1Y3QgY2FycF9p
 ZiAqLCBzaXplb2YoKm5jaWYpLCBNX0NBUlAsCisJCQkgICAgTV9XQUlUT0t8TV9aRVJPKTsKKwkJ
 CWlmICghbmNpZikKKwkJCQlyZXR1cm4gKEVOT0JVRlMpOworCQkJaWYgKChlcnJvciA9IGlmcHJv
 bWlzYyhpZnAsIDEpKSkgeworCQkJCUZSRUUobmNpZiwgTV9DQVJQKTsKKwkJCQlyZXR1cm4gKGVy
 cm9yKTsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCWNpZiA9IChzdHJ1Y3QgY2FycF9pZiAqKWlmcC0+
 aWZfY2FycDsKKwkJCUNBUlBfTE9DSyhjaWYpOworCQkJVEFJTFFfRk9SRUFDSCh2ciwgJmNpZi0+
 dmhpZl92cnMsIHNjX2xpc3QpCisJCQkJaWYgKHZyICE9IHNjICYmIHZyLT5zY192aGlkID09IHNj
 LT5zY192aGlkKSB7CisJCQkJCUNBUlBfVU5MT0NLKGNpZik7CisJCQkJCXJldHVybiAoRUlOVkFM
 KTsKKwkJCQl9CisJCX0KKworCQkvKiBkZXRhY2ggZnJvbSBvbGQgaW50ZXJmYWNlICovCisJCWlm
 IChzYy0+c2NfY2FycGRldiAhPSBOVUxMKSB7CisJCQlDQVJQX1NDTE9DSyhzYyk7CisJCQljYXJw
 ZGV0YWNoKHNjLCAxKTsKKwkJfQorCisJCWlmIChzYy0+c2NfbmFkZHJzICE9IDAgJiYKKwkJICAg
 IChlcnJvciA9IGNhcnBfam9pbl9tdWx0aWNhc3Qoc2MpKSAhPSAwKQorCQkgICAgCWdvdG8gY2xl
 YW51cDsKKyNpZmRlZiBJTkVUNgorCQlpZiAoc2MtPnNjX25hZGRyczYgIT0gMCAmJgorCQkgICAg
 KGVycm9yID0gY2FycF9qb2luX211bHRpY2FzdDYoc2MpKSAhPSAwKSB7CisJCSAgICAJY2FycF9t
 dWx0aWNhc3RfY2xlYW51cChzYyk7CisJCSAgICAJZ290byBjbGVhbnVwOworCQl9CisjZW5kaWYK
 KworCQkvKiBhdHRhY2ggY2FycCBnbHVlIHRvIHBoeXNpY2FsIGludGVyZmFjZSAqLworCQlpZiAo
 bmNpZiAhPSBOVUxMKSB7CisJCQlDQVJQX0xPQ0tfSU5JVChuY2lmKTsKKwkJCUNBUlBfTE9DSyhu
 Y2lmKTsKKwkJCW5jaWYtPnZoaWZfaWZwID0gaWZwOworCQkJVEFJTFFfSU5JVCgmbmNpZi0+dmhp
 Zl92cnMpOworCQkJVEFJTFFfSU5TRVJUX0hFQUQoJm5jaWYtPnZoaWZfdnJzLCBzYywgc2NfbGlz
 dCk7CisJCQluY2lmLT52aGlmX252cnMrKzsKKwkJCWlmcC0+aWZfY2FycCA9IG5jaWY7CisJCQlD
 QVJQX1VOTE9DSyhuY2lmKTsKKwkJfSBlbHNlIHsKKwkJCWNpZiA9IChzdHJ1Y3QgY2FycF9pZiAq
 KWlmcC0+aWZfY2FycDsKKwkJCVRBSUxRX0ZPUkVBQ0godnIsICZjaWYtPnZoaWZfdnJzLCBzY19s
 aXN0KSB7CisJCQkJaWYgKHZyID09IHNjKQorCQkJCQlteXNlbGYgPSAxOworCQkJCWlmICh2ci0+
 c2NfdmhpZCA8IHNjLT5zY192aGlkKQorCQkJCQlhZnRlciA9IHZyOworCQkJfQorCQkJaWYgKCFt
 eXNlbGYpIHsKKwkJCQlpZiAoYWZ0ZXIgPT0gTlVMTCkgeworCQkJCQlUQUlMUV9JTlNFUlRfVEFJ
 TCgmY2lmLT52aGlmX3Zycywgc2MsCisJCQkJCSAgICBzY19saXN0KTsKKwkJCQl9IGVsc2Ugewor
 CQkJCQlUQUlMUV9JTlNFUlRfQUZURVIoJmNpZi0+dmhpZl92cnMsCisJCQkJCSAgICBhZnRlciwg
 c2MsIHNjX2xpc3QpOworCQkJCX0KKwkJCQljaWYtPnZoaWZfbnZycysrOworCQkJfQorCQkJQ0FS
 UF9VTkxPQ0soY2lmKTsKKwkJfQorCisJCXNjLT5zY19jYXJwZGV2ID0gaWZwOworCQlpZiAoc2Mt
 PnNjX25hZGRycyB8fCBzYy0+c2NfbmFkZHJzNikKKwkJCXNjLT5zY19pZnAtPmlmX2ZsYWdzIHw9
 IElGRl9VUDsKKwkJY2FycF9jYXJwZGV2X3N0YXRlKGlmcCk7CisJfSBlbHNlIHsKKwkJQ0FSUF9T
 Q0xPQ0soc2MpOworCQljYXJwZGV0YWNoKHNjLCAxKTsKKwkJU0MySUZQKHNjKS0+aWZfZmxhZ3Mg
 Jj0gfklGRl9VUDsKKwkJU0MySUZQKHNjKS0+aWZfZHJ2X2ZsYWdzICY9IH5JRkZfRFJWX1JVTk5J
 Tkc7CisJfQorCisJcmV0dXJuICgwKTsKK2NsZWFudXA6CisJaWYgKG5jaWYpCisJCUZSRUUobmNp
 ZiwgTV9DQVJQKTsKKwllbHNlCisJCUNBUlBfVU5MT0NLKGNpZik7CisKKwlyZXR1cm4gKGVycm9y
 KTsKK30KKworc3RhdGljIGludAogY2FycF9zZXRfYWRkcihzdHJ1Y3QgY2FycF9zb2Z0YyAqc2Ms
 IHN0cnVjdCBzb2NrYWRkcl9pbiAqc2luKQogewotCXN0cnVjdCBpZm5ldCAqaWZwOwotCXN0cnVj
 dCBjYXJwX2lmICpjaWY7CisJc3RydWN0IGlmbmV0ICppZnAgPSBzYy0+c2NfY2FycGRldjsKIAlz
 dHJ1Y3QgaW5faWZhZGRyICppYSwgKmlhX2lmOwotCXN0cnVjdCBpcF9tb3B0aW9ucyAqaW1vID0g
 JnNjLT5zY19pbW87Ci0Jc3RydWN0IGluX2FkZHIgYWRkcjsKIAl1X2xvbmcgaWFkZHIgPSBodG9u
 bChzaW4tPnNpbl9hZGRyLnNfYWRkcik7Ci0JaW50IG93biwgZXJyb3I7CisJaW50IGVycm9yOwog
 CiAJaWYgKHNpbi0+c2luX2FkZHIuc19hZGRyID09IDApIHsKIAkJaWYgKCEoU0MySUZQKHNjKS0+
 aWZfZmxhZ3MgJiBJRkZfVVApKQpAQCAtMTQ0Myw3ICsxNjI1LDcgQEAgY2FycF9zZXRfYWRkcihz
 dHJ1Y3QgY2FycF9zb2Z0YyAqc2MsIHN0cnVjdCBzb2NrYWRkcl9pbiAqc2luKQogCX0KIAogCS8q
 IHdlIGhhdmUgdG8gZG8gaXQgYnkgaGFuZHMgdG8gY2hlY2sgd2Ugd29uJ3QgbWF0Y2ggb24gdXMg
 Ki8KLQlpYV9pZiA9IE5VTEw7IG93biA9IDA7CisJaWFfaWYgPSBOVUxMOwogCVRBSUxRX0ZPUkVB
 Q0goaWEsICZpbl9pZmFkZHJoZWFkLCBpYV9saW5rKSB7CiAJCS8qIGFuZCwgeWVhaCwgd2UgbmVl
 ZCBhIG11bHRpY2FzdC1jYXBhYmxlIGlmYWNlIHRvbyAqLwogCQlpZiAoaWEtPmlhX2lmcCAhPSBT
 QzJJRlAoc2MpICYmCkBAIC0xNDUxLDEwNiArMTYzMyw2NSBAQCBjYXJwX3NldF9hZGRyKHN0cnVj
 dCBjYXJwX3NvZnRjICpzYywgc3RydWN0IHNvY2thZGRyX2luICpzaW4pCiAJCSAgICAoaWFkZHIg
 JiBpYS0+aWFfc3VibmV0bWFzaykgPT0gaWEtPmlhX3N1Ym5ldCkgewogCQkJaWYgKCFpYV9pZikK
 IAkJCQlpYV9pZiA9IGlhOwotCQkJaWYgKHNpbi0+c2luX2FkZHIuc19hZGRyID09Ci0JCQkgICAg
 aWEtPmlhX2FkZHIuc2luX2FkZHIuc19hZGRyKQotCQkJCW93bisrOwogCQl9CiAJfQogCi0JaWYg
 KCFpYV9pZikKLQkJcmV0dXJuIChFQUREUk5PVEFWQUlMKTsKLQotCWlhID0gaWFfaWY7Ci0JaWZw
 ID0gaWEtPmlhX2lmcDsKLQotCWlmIChpZnAgPT0gTlVMTCB8fCAoaWZwLT5pZl9mbGFncyAmIElG
 Rl9NVUxUSUNBU1QpID09IDAgfHwKLQkgICAgKGltby0+aW1vX211bHRpY2FzdF9pZnAgJiYgaW1v
 LT5pbW9fbXVsdGljYXN0X2lmcCAhPSBpZnApKQotCQlyZXR1cm4gKEVBRERSTk9UQVZBSUwpOwot
 Ci0JaWYgKGltby0+aW1vX251bV9tZW1iZXJzaGlwcyA9PSAwKSB7Ci0JCWFkZHIuc19hZGRyID0g
 aHRvbmwoSU5BRERSX0NBUlBfR1JPVVApOwotCQlpZiAoKGltby0+aW1vX21lbWJlcnNoaXBbMF0g
 PSBpbl9hZGRtdWx0aSgmYWRkciwgaWZwKSkgPT0gTlVMTCkKLQkJCXJldHVybiAoRU5PQlVGUyk7
 Ci0JCWltby0+aW1vX251bV9tZW1iZXJzaGlwcysrOwotCQlpbW8tPmltb19tdWx0aWNhc3RfaWZw
 ID0gaWZwOwotCQlpbW8tPmltb19tdWx0aWNhc3RfdHRsID0gQ0FSUF9ERkxUVEw7Ci0JCWltby0+
 aW1vX211bHRpY2FzdF9sb29wID0gMDsKLQl9Ci0KLQlpZiAoIWlmcC0+aWZfY2FycCkgewotCi0J
 CU1BTExPQyhjaWYsIHN0cnVjdCBjYXJwX2lmICosIHNpemVvZigqY2lmKSwgTV9DQVJQLAotCQkg
 ICAgTV9XQUlUT0t8TV9aRVJPKTsKLQkJaWYgKCFjaWYpIHsKLQkJCWVycm9yID0gRU5PQlVGUzsK
 LQkJCWdvdG8gY2xlYW51cDsKLQkJfQotCQlpZiAoKGVycm9yID0gaWZwcm9taXNjKGlmcCwgMSkp
 KSB7Ci0JCQlGUkVFKGNpZiwgTV9DQVJQKTsKLQkJCWdvdG8gY2xlYW51cDsKKwlpZiAoaWFfaWYp
 IHsKKwkJaWEgPSBpYV9pZjsKKwkJaWYgKGlmcCkgeworCQkJaWYgKGlmcCAhPSBpYS0+aWFfaWZw
 KQorCQkJCXJldHVybiAoRUFERFJOT1RBVkFJTCk7CisJCX0gZWxzZSB7CisJCQlpZnAgPSBpYS0+
 aWFfaWZwOwogCQl9Ci0JCQotCQlDQVJQX0xPQ0tfSU5JVChjaWYpOwotCQlDQVJQX0xPQ0soY2lm
 KTsKLQkJY2lmLT52aGlmX2lmcCA9IGlmcDsKLQkJVEFJTFFfSU5JVCgmY2lmLT52aGlmX3Zycyk7
 Ci0JCWlmcC0+aWZfY2FycCA9IGNpZjsKLQotCX0gZWxzZSB7Ci0JCXN0cnVjdCBjYXJwX3NvZnRj
 ICp2cjsKLQotCQljaWYgPSAoc3RydWN0IGNhcnBfaWYgKilpZnAtPmlmX2NhcnA7Ci0JCUNBUlBf
 TE9DSyhjaWYpOwotCQlUQUlMUV9GT1JFQUNIKHZyLCAmY2lmLT52aGlmX3Zycywgc2NfbGlzdCkK
 LQkJCWlmICh2ciAhPSBzYyAmJiB2ci0+c2NfdmhpZCA9PSBzYy0+c2NfdmhpZCkgewotCQkJCUNB
 UlBfVU5MT0NLKGNpZik7Ci0JCQkJZXJyb3IgPSBFSU5WQUw7Ci0JCQkJZ290byBjbGVhbnVwOwot
 CQkJfQogCX0KLQlzYy0+c2NfaWEgPSBpYTsKLQlzYy0+c2NfY2FycGRldiA9IGlmcDsKIAotCXsg
 LyogWFhYIHByZXZlbnQgZW5kbGVzcyBsb29wIGlmIGFscmVhZHkgaW4gcXVldWUgKi8KLQlzdHJ1
 Y3QgY2FycF9zb2Z0YyAqdnIsICphZnRlciA9IE5VTEw7Ci0JaW50IG15c2VsZiA9IDA7Ci0JY2lm
 ID0gKHN0cnVjdCBjYXJwX2lmICopaWZwLT5pZl9jYXJwOworCWlmICgoZXJyb3IgPSBjYXJwX3Nl
 dF9pZnAoc2MsIGlmcCkpKQorCQlyZXR1cm4gKGVycm9yKTsKIAotCS8qIFhYWDogY2lmIHNob3Vs
 ZCBub3QgY2hhbmdlLCByaWdodD8gU28gd2Ugc3RpbGwgaG9sZCB0aGUgbG9jayAqLwotCUNBUlBf
 TE9DS19BU1NFUlQoY2lmKTsKLQotCVRBSUxRX0ZPUkVBQ0godnIsICZjaWYtPnZoaWZfdnJzLCBz
 Y19saXN0KSB7Ci0JCWlmICh2ciA9PSBzYykKLQkJCW15c2VsZiA9IDE7Ci0JCWlmICh2ci0+c2Nf
 dmhpZCA8IHNjLT5zY192aGlkKQotCQkJYWZ0ZXIgPSB2cjsKLQl9CisJaWYgKHNjLT5zY19jYXJw
 ZGV2ID09IE5VTEwpCisJCXJldHVybiAoRUFERFJOT1RBVkFJTCk7CiAKLQlpZiAoIW15c2VsZikg
 ewotCQkvKiBXZSdyZSB0cnlpbmcgdG8ga2VlcCB0aGluZ3MgaW4gb3JkZXIgKi8KLQkJaWYgKGFm
 dGVyID09IE5VTEwpIHsKLQkJCVRBSUxRX0lOU0VSVF9UQUlMKCZjaWYtPnZoaWZfdnJzLCBzYywg
 c2NfbGlzdCk7Ci0JCX0gZWxzZSB7Ci0JCQlUQUlMUV9JTlNFUlRfQUZURVIoJmNpZi0+dmhpZl92
 cnMsIGFmdGVyLCBzYywgc2NfbGlzdCk7Ci0JCX0KLQkJY2lmLT52aGlmX252cnMrKzsKLQl9CisJ
 Q0FSUF9TQ0xPQ0soc2MpOworCWlmIChzYy0+c2NfbmFkZHJzID09IDAgJiYgKGVycm9yID0gY2Fy
 cF9qb2luX211bHRpY2FzdChzYykpICE9IDApIHsKKwkJQ0FSUF9TQ1VOTE9DSyhzYyk7CisJCXJl
 dHVybiAoZXJyb3IpOwogCX0KIAogCXNjLT5zY19uYWRkcnMrKzsKIAlTQzJJRlAoc2MpLT5pZl9m
 bGFncyB8PSBJRkZfVVA7Ci0JaWYgKG93bikKLQkJc2MtPnNjX2FkdnNrZXcgPSAwOwogCWNhcnBf
 c2Nfc3RhdGVfbG9ja2VkKHNjKTsKIAljYXJwX3NldHJ1bihzYywgMCk7Ci0KLQlDQVJQX1VOTE9D
 SyhjaWYpOworCUNBUlBfU0NVTkxPQ0soc2MpOwogCiAJcmV0dXJuICgwKTsKIAotY2xlYW51cDoK
 LQlpbl9kZWxtdWx0aShpbW8tPmltb19tZW1iZXJzaGlwWy0taW1vLT5pbW9fbnVtX21lbWJlcnNo
 aXBzXSk7Ci0JcmV0dXJuIChlcnJvcik7CisvKgorICogWFhYOiBjbGVhbnVwIG11bHRpPworICog
 Y2xlYW51cDoKKyAqCXJldHVybiAoZXJyb3IpOworICovCit9CisKK3N0YXRpYyBpbnQKK2NhcnBf
 am9pbl9tdWx0aWNhc3Qoc3RydWN0IGNhcnBfc29mdGMgKnNjKQoreworCXN0cnVjdCBpcF9tb3B0
 aW9ucyAqaW1vID0gJnNjLT5zY19pbW87CisJc3RydWN0IGluX2FkZHIgYWRkcjsKKworCUtBU1NF
 UlQoaW1vLT5pbW9fbnVtX21lbWJlcnNoaXBzID09IDAsCisJICAgICgiY2FycF9qb2luX211bHRp
 Y2FzdDogbGVmdG92ZXIgbXVsdGljYXN0IG1lbWJlcnNoaXBzIikpOworCisJYWRkci5zX2FkZHIg
 PSBodG9ubChJTkFERFJfQ0FSUF9HUk9VUCk7CisJaWYgKChpbW8tPmltb19tZW1iZXJzaGlwWzBd
 ID0KKwkgICAgaW5fYWRkbXVsdGkoJmFkZHIsIFNDMklGUChzYykpKSA9PSBOVUxMKQorCQlyZXR1
 cm4gKEVOT0JVRlMpOworCWltby0+aW1vX251bV9tZW1iZXJzaGlwcysrOworCWltby0+aW1vX211
 bHRpY2FzdF9pZnAgPSBTQzJJRlAoc2MpOworCWltby0+aW1vX211bHRpY2FzdF90dGwgPSBDQVJQ
 X0RGTFRUTDsKKwlpbW8tPmltb19tdWx0aWNhc3RfbG9vcCA9IDA7CisKKwlyZXR1cm4gKDApOwog
 fQogCiBzdGF0aWMgaW50CkBAIC0xNTg3LDEyICsxNzI4LDggQEAgc3RhdGljIGludAogY2FycF9z
 ZXRfYWRkcjYoc3RydWN0IGNhcnBfc29mdGMgKnNjLCBzdHJ1Y3Qgc29ja2FkZHJfaW42ICpzaW42
 KQogewogCXN0cnVjdCBpZm5ldCAqaWZwOwotCXN0cnVjdCBjYXJwX2lmICpjaWY7CiAJc3RydWN0
 IGluNl9pZmFkZHIgKmlhLCAqaWFfaWY7Ci0Jc3RydWN0IGlwNl9tb3B0aW9ucyAqaW02byA9ICZz
 Yy0+c2NfaW02bzsKLQlzdHJ1Y3QgaW42X211bHRpX21zaGlwICppbW07Ci0Jc3RydWN0IGluNl9h
 ZGRyIGluNjsKLQlpbnQgb3duLCBlcnJvcjsKKwlpbnQgb3duOwogCiAJaWYgKElONl9JU19BRERS
 X1VOU1BFQ0lGSUVEKCZzaW42LT5zaW42X2FkZHIpKSB7CiAJCWlmICghKFNDMklGUChzYyktPmlm
 X2ZsYWdzICYgSUZGX1VQKSkKQEAgLTE2MzMsOTMgKzE3NzAsMTIgQEAgY2FycF9zZXRfYWRkcjYo
 c3RydWN0IGNhcnBfc29mdGMgKnNjLCBzdHJ1Y3Qgc29ja2FkZHJfaW42ICpzaW42KQogCWlmcCA9
 IGlhLT5pYV9pZnA7CiAKIAlpZiAoaWZwID09IE5VTEwgfHwgKGlmcC0+aWZfZmxhZ3MgJiBJRkZf
 TVVMVElDQVNUKSA9PSAwIHx8Ci0JICAgIChpbTZvLT5pbTZvX211bHRpY2FzdF9pZnAgJiYgaW02
 by0+aW02b19tdWx0aWNhc3RfaWZwICE9IGlmcCkpCisJICAgIChzYy0+c2NfaW02by5pbTZvX211
 bHRpY2FzdF9pZnAgJiYKKwkgICAgc2MtPnNjX2ltNm8uaW02b19tdWx0aWNhc3RfaWZwICE9IGlm
 cCkpCiAJCXJldHVybiAoRUFERFJOT1RBVkFJTCk7CiAKLQlpZiAoIXNjLT5zY19uYWRkcnM2KSB7
 Ci0JCWltNm8tPmltNm9fbXVsdGljYXN0X2lmcCA9IGlmcDsKLQotCQkvKiBqb2luIENBUlAgbXVs
 dGljYXN0IGFkZHJlc3MgKi8KLQkJYnplcm8oJmluNiwgc2l6ZW9mKGluNikpOwotCQlpbjYuczZf
 YWRkcjE2WzBdID0gaHRvbnMoMHhmZjAyKTsKLQkJaW42LnM2X2FkZHI4WzE1XSA9IDB4MTI7Ci0J
 CWlmIChpbjZfc2V0c2NvcGUoJmluNiwgaWZwLCBOVUxMKSAhPSAwKQotCQkJZ290byBjbGVhbnVw
 OwotCQlpZiAoKGltbSA9IGluNl9qb2luZ3JvdXAoaWZwLCAmaW42LCAmZXJyb3IsIDApKSA9PSBO
 VUxMKQotCQkJZ290byBjbGVhbnVwOwotCQlMSVNUX0lOU0VSVF9IRUFEKCZpbTZvLT5pbTZvX21l
 bWJlcnNoaXBzLCBpbW0sIGk2bW1fY2hhaW4pOwotCi0JCS8qIGpvaW4gc29saWNpdGVkIG11bHRp
 Y2FzdCBhZGRyZXNzICovCi0JCWJ6ZXJvKCZpbjYsIHNpemVvZihpbjYpKTsKLQkJaW42LnM2X2Fk
 ZHIxNlswXSA9IGh0b25zKDB4ZmYwMik7Ci0JCWluNi5zNl9hZGRyMzJbMV0gPSAwOwotCQlpbjYu
 czZfYWRkcjMyWzJdID0gaHRvbmwoMSk7Ci0JCWluNi5zNl9hZGRyMzJbM10gPSBzaW42LT5zaW42
 X2FkZHIuczZfYWRkcjMyWzNdOwotCQlpbjYuczZfYWRkcjhbMTJdID0gMHhmZjsKLQkJaWYgKGlu
 Nl9zZXRzY29wZSgmaW42LCBpZnAsIE5VTEwpICE9IDApCi0JCQlnb3RvIGNsZWFudXA7Ci0JCWlm
 ICgoaW1tID0gaW42X2pvaW5ncm91cChpZnAsICZpbjYsICZlcnJvciwgMCkpID09IE5VTEwpCi0J
 CQlnb3RvIGNsZWFudXA7Ci0JCUxJU1RfSU5TRVJUX0hFQUQoJmltNm8tPmltNm9fbWVtYmVyc2hp
 cHMsIGltbSwgaTZtbV9jaGFpbik7Ci0JfQotCi0JaWYgKCFpZnAtPmlmX2NhcnApIHsKLQkJTUFM
 TE9DKGNpZiwgc3RydWN0IGNhcnBfaWYgKiwgc2l6ZW9mKCpjaWYpLCBNX0NBUlAsCi0JCSAgICBN
 X1dBSVRPS3xNX1pFUk8pOwotCQlpZiAoIWNpZikgewotCQkJZXJyb3IgPSBFTk9CVUZTOwotCQkJ
 Z290byBjbGVhbnVwOwotCQl9Ci0JCWlmICgoZXJyb3IgPSBpZnByb21pc2MoaWZwLCAxKSkpIHsK
 LQkJCUZSRUUoY2lmLCBNX0NBUlApOwotCQkJZ290byBjbGVhbnVwOwotCQl9Ci0KLQkJQ0FSUF9M
 T0NLX0lOSVQoY2lmKTsKLQkJQ0FSUF9MT0NLKGNpZik7Ci0JCWNpZi0+dmhpZl9pZnAgPSBpZnA7
 Ci0JCVRBSUxRX0lOSVQoJmNpZi0+dmhpZl92cnMpOwotCQlpZnAtPmlmX2NhcnAgPSBjaWY7Ci0K
 LQl9IGVsc2UgewotCQlzdHJ1Y3QgY2FycF9zb2Z0YyAqdnI7Ci0KLQkJY2lmID0gKHN0cnVjdCBj
 YXJwX2lmICopaWZwLT5pZl9jYXJwOwotCQlDQVJQX0xPQ0soY2lmKTsKLQkJVEFJTFFfRk9SRUFD
 SCh2ciwgJmNpZi0+dmhpZl92cnMsIHNjX2xpc3QpCi0JCQlpZiAodnIgIT0gc2MgJiYgdnItPnNj
 X3ZoaWQgPT0gc2MtPnNjX3ZoaWQpIHsKLQkJCQlDQVJQX1VOTE9DSyhjaWYpOwotCQkJCWVycm9y
 ID0gRUlOVkFMOwotCQkJCWdvdG8gY2xlYW51cDsKLQkJCX0KLQl9Ci0Jc2MtPnNjX2lhNiA9IGlh
 OwogCXNjLT5zY19jYXJwZGV2ID0gaWZwOwogCi0JeyAvKiBYWFggcHJldmVudCBlbmRsZXNzIGxv
 b3AgaWYgYWxyZWFkeSBpbiBxdWV1ZSAqLwotCXN0cnVjdCBjYXJwX3NvZnRjICp2ciwgKmFmdGVy
 ID0gTlVMTDsKLQlpbnQgbXlzZWxmID0gMDsKLQljaWYgPSAoc3RydWN0IGNhcnBfaWYgKilpZnAt
 PmlmX2NhcnA7Ci0JQ0FSUF9MT0NLX0FTU0VSVChjaWYpOwotCi0JVEFJTFFfRk9SRUFDSCh2ciwg
 JmNpZi0+dmhpZl92cnMsIHNjX2xpc3QpIHsKLQkJaWYgKHZyID09IHNjKQotCQkJbXlzZWxmID0g
 MTsKLQkJaWYgKHZyLT5zY192aGlkIDwgc2MtPnNjX3ZoaWQpCi0JCQlhZnRlciA9IHZyOwotCX0K
 LQotCWlmICghbXlzZWxmKSB7Ci0JCS8qIFdlJ3JlIHRyeWluZyB0byBrZWVwIHRoaW5ncyBpbiBv
 cmRlciAqLwotCQlpZiAoYWZ0ZXIgPT0gTlVMTCkgewotCQkJVEFJTFFfSU5TRVJUX1RBSUwoJmNp
 Zi0+dmhpZl92cnMsIHNjLCBzY19saXN0KTsKLQkJfSBlbHNlIHsKLQkJCVRBSUxRX0lOU0VSVF9B
 RlRFUigmY2lmLT52aGlmX3ZycywgYWZ0ZXIsIHNjLCBzY19saXN0KTsKLQkJfQotCQljaWYtPnZo
 aWZfbnZycysrOwotCX0KLQl9Ci0KIAlzYy0+c2NfbmFkZHJzNisrOwogCVNDMklGUChzYyktPmlm
 X2ZsYWdzIHw9IElGRl9VUDsKIAlpZiAob3duKQpAQCAtMTcyNywyMCArMTc4Myw2MSBAQCBjYXJw
 X3NldF9hZGRyNihzdHJ1Y3QgY2FycF9zb2Z0YyAqc2MsIHN0cnVjdCBzb2NrYWRkcl9pbjYgKnNp
 bjYpCiAJY2FycF9zY19zdGF0ZV9sb2NrZWQoc2MpOwogCWNhcnBfc2V0cnVuKHNjLCAwKTsKIAot
 CUNBUlBfVU5MT0NLKGNpZik7Ci0KIAlyZXR1cm4gKDApOwogCi1jbGVhbnVwOgotCS8qIGNsZWFu
 IHVwIG11bHRpY2FzdCBtZW1iZXJzaGlwcyAqLwotCWlmICghc2MtPnNjX25hZGRyczYpIHsKLQkJ
 d2hpbGUgKCFMSVNUX0VNUFRZKCZpbTZvLT5pbTZvX21lbWJlcnNoaXBzKSkgewotCQkJaW1tID0g
 TElTVF9GSVJTVCgmaW02by0+aW02b19tZW1iZXJzaGlwcyk7Ci0JCQlMSVNUX1JFTU9WRShpbW0s
 IGk2bW1fY2hhaW4pOwotCQkJaW42X2xlYXZlZ3JvdXAoaW1tKTsKLQkJfQorLyogWFhYOgorICog
 Y2xlYW51cDoKKyAqCSAqIGNsZWFuIHVwIG11bHRpY2FzdCBtZW1iZXJzaGlwcyAqCisgKglpZiAo
 IXNjLT5zY19uYWRkcnM2KSB7CisgKgkJd2hpbGUgKCFMSVNUX0VNUFRZKCZpbTZvLT5pbTZvX21l
 bWJlcnNoaXBzKSkgeworICoJCQlpbW0gPSBMSVNUX0ZJUlNUKCZpbTZvLT5pbTZvX21lbWJlcnNo
 aXBzKTsKKyAqCQkJTElTVF9SRU1PVkUoaW1tLCBpNm1tX2NoYWluKTsKKyAqCQkJaW42X2xlYXZl
 Z3JvdXAoaW1tKTsKKyAqCQl9CisgKgl9CisgKglyZXR1cm4gKGVycm9yKTsKKyAqLworfQorCitz
 dGF0aWMgaW50CitjYXJwX2pvaW5fbXVsdGljYXN0NihzdHJ1Y3QgY2FycF9zb2Z0YyAqc2MpCit7
 CisJc3RydWN0IGlwNl9tb3B0aW9ucyAqaW02byA9ICZzYy0+c2NfaW02bzsKKwlzdHJ1Y3QgaW42
 X211bHRpX21zaGlwICppbW0sICppbW0yOworCXN0cnVjdCBpbjZfYWRkciBpbjY7CisJaW50IGVy
 cm9yID0gMDsKKworCS8qIGpvaW4gQ0FSUCBtdWx0aWNhc3QgYWRkcmVzcyAqLworCWJ6ZXJvKCZp
 bjYsIHNpemVvZihpbjYpKTsKKwlpbjYuczZfYWRkcjE2WzBdID0gaHRvbnMoMHhmZjAyKTsKKwlp
 bjYuczZfYWRkcjhbMTVdID0gMHgxMjsKKwlpZiAoKGVycm9yID0gaW42X3NldHNjb3BlKCZpbjYs
 IHNjLT5zY19jYXJwZGV2LCBOVUxMKSkgIT0gMCkKKwkJcmV0dXJuIChlcnJvcik7CisJaWYgKChp
 bW0gPSBpbjZfam9pbmdyb3VwKHNjLT5zY19jYXJwZGV2LCAmaW42LCAmZXJyb3IsIDApKSA9PSBO
 VUxMKQorCQlyZXR1cm4gKGVycm9yKTsKKworCS8qIGpvaW4gc29saWNpdGVkIG11bHRpY2FzdCBh
 ZGRyZXNzICovCisJYnplcm8oJmluNiwgc2l6ZW9mKGluNikpOworCWluNi5zNl9hZGRyMTZbMF0g
 PSBodG9ucygweGZmMDIpOworCWluNi5zNl9hZGRyMzJbMV0gPSAwOworCWluNi5zNl9hZGRyMzJb
 Ml0gPSBodG9ubCgxKTsKKwlpbjYuczZfYWRkcjMyWzNdID0gMDsgLyogWFhYOiBzaW42LT5zaW42
 X2FkZHIuczZfYWRkcjMyWzNdOyAqLworCWluNi5zNl9hZGRyOFsxMl0gPSAweGZmOworCWlmICgo
 ZXJyb3IgPSBpbjZfc2V0c2NvcGUoJmluNiwgc2MtPnNjX2NhcnBkZXYsIE5VTEwpKSAhPSAwKSB7
 CisJCWluNl9sZWF2ZWdyb3VwKGltbSk7CisJCXJldHVybiAoZXJyb3IpOwogCX0KLQlyZXR1cm4g
 KGVycm9yKTsKKwlpZiAoKGltbTIgPSBpbjZfam9pbmdyb3VwKHNjLT5zY19jYXJwZGV2LCAmaW42
 LCAmZXJyb3IsIDApKSA9PSBOVUxMKSB7CisJCWluNl9sZWF2ZWdyb3VwKGltbSk7CisJCXJldHVy
 biAoZXJyb3IpOworCX0KKworCWltNm8tPmltNm9fbXVsdGljYXN0X2lmcCA9IHNjLT5zY19jYXJw
 ZGV2OworCisJTElTVF9JTlNFUlRfSEVBRCgmaW02by0+aW02b19tZW1iZXJzaGlwcywgaW1tLCBp
 Nm1tX2NoYWluKTsKKwlMSVNUX0lOU0VSVF9IRUFEKCZpbTZvLT5pbTZvX21lbWJlcnNoaXBzLCBp
 bW0yLCBpNm1tX2NoYWluKTsKKworCXJldHVybiAoMCk7CiB9CiAKIHN0YXRpYyBpbnQKQEAgLTE3
 ODYsNyArMTg4Myw4IEBAIGNhcnBfaW9jdGwoc3RydWN0IGlmbmV0ICppZnAsIHVfbG9uZyBjbWQs
 IGNhZGRyX3QgYWRkcikKIAlzdHJ1Y3QgaWZhZGRyICppZmE7CiAJc3RydWN0IGlmcmVxICppZnI7
 CiAJc3RydWN0IGlmYWxpYXNyZXEgKmlmcmE7Ci0JaW50IGxvY2tlZCA9IDAsIGVycm9yID0gMDsK
 KwlzdHJ1Y3QgaWZuZXQgKmNkZXYgPSBOVUxMOworCWludCBsb2NrZWQgPSAwLCBlcnJvciA9IDAs
 IGNoYW5nZWQgPSAwOwogCiAJaWZhID0gKHN0cnVjdCBpZmFkZHIgKilhZGRyOwogCWlmcmEgPSAo
 c3RydWN0IGlmYWxpYXNyZXEgKilhZGRyOwpAQCAtMTc5NCwxMiArMTg5MiwxMiBAQCBjYXJwX2lv
 Y3RsKHN0cnVjdCBpZm5ldCAqaWZwLCB1X2xvbmcgY21kLCBjYWRkcl90IGFkZHIpCiAKIAlzd2l0
 Y2ggKGNtZCkgewogCWNhc2UgU0lPQ1NJRkFERFI6CisJY2FzZSBTSU9DQUlGQUREUjoKKwkJY2hh
 bmdlZCsrOwogCQlzd2l0Y2ggKGlmYS0+aWZhX2FkZHItPnNhX2ZhbWlseSkgewogI2lmZGVmIElO
 RVQKIAkJY2FzZSBBRl9JTkVUOgogCQkJU0MySUZQKHNjKS0+aWZfZmxhZ3MgfD0gSUZGX1VQOwot
 CQkJYmNvcHkoaWZhLT5pZmFfYWRkciwgaWZhLT5pZmFfZHN0YWRkciwKLQkJCSAgICBzaXplb2Yo
 c3RydWN0IHNvY2thZGRyKSk7CiAJCQllcnJvciA9IGNhcnBfc2V0X2FkZHIoc2MsIHNhdG9zaW4o
 aWZhLT5pZmFfYWRkcikpOwogCQkJYnJlYWs7CiAjZW5kaWYgLyogSU5FVCAqLwpAQCAtMTgxNSwy
 OSArMTkxMyw4IEBAIGNhcnBfaW9jdGwoc3RydWN0IGlmbmV0ICppZnAsIHVfbG9uZyBjbWQsIGNh
 ZGRyX3QgYWRkcikKIAkJfQogCQlicmVhazsKIAotCWNhc2UgU0lPQ0FJRkFERFI6Ci0JCXN3aXRj
 aCAoaWZhLT5pZmFfYWRkci0+c2FfZmFtaWx5KSB7Ci0jaWZkZWYgSU5FVAotCQljYXNlIEFGX0lO
 RVQ6Ci0JCQlTQzJJRlAoc2MpLT5pZl9mbGFncyB8PSBJRkZfVVA7Ci0JCQliY29weShpZmEtPmlm
 YV9hZGRyLCBpZmEtPmlmYV9kc3RhZGRyLAotCQkJICAgIHNpemVvZihzdHJ1Y3Qgc29ja2FkZHIp
 KTsKLQkJCWVycm9yID0gY2FycF9zZXRfYWRkcihzYywgc2F0b3NpbigmaWZyYS0+aWZyYV9hZGRy
 KSk7Ci0JCQlicmVhazsKLSNlbmRpZiAvKiBJTkVUICovCi0jaWZkZWYgSU5FVDYKLQkJY2FzZSBB
 Rl9JTkVUNjoKLQkJCVNDMklGUChzYyktPmlmX2ZsYWdzIHw9IElGRl9VUDsKLQkJCWVycm9yID0g
 Y2FycF9zZXRfYWRkcjYoc2MsIHNhdG9zaW42KCZpZnJhLT5pZnJhX2FkZHIpKTsKLQkJCWJyZWFr
 OwotI2VuZGlmIC8qIElORVQ2ICovCi0JCWRlZmF1bHQ6Ci0JCQllcnJvciA9IEVBRk5PU1VQUE9S
 VDsKLQkJCWJyZWFrOwotCQl9Ci0JCWJyZWFrOwotCiAJY2FzZSBTSU9DRElGQUREUjoKKwkJY2hh
 bmdlZCsrOwogCQlzd2l0Y2ggKGlmYS0+aWZhX2FkZHItPnNhX2ZhbWlseSkgewogI2lmZGVmIElO
 RVQKIAkJY2FzZSBBRl9JTkVUOgpAQCAtMTg4MSw2ICsxOTU4LDE0IEBAIGNhcnBfaW9jdGwoc3Ry
 dWN0IGlmbmV0ICppZnAsIHVfbG9uZyBjbWQsIGNhZGRyX3QgYWRkcikKIAkJaWYgKChlcnJvciA9
 IGNvcHlpbihpZnItPmlmcl9kYXRhLCAmY2FycHIsIHNpemVvZiBjYXJwcikpKQogCQkJYnJlYWs7
 CiAJCWVycm9yID0gMTsKKwkJY2hhbmdlZCsrOworCQlpZiAoY2FycHIuY2FycHJfY2FycGRldlsw
 XSAhPSAnXDAnICYmCisJCSAgICAoY2RldiA9IGlmdW5pdChjYXJwci5jYXJwcl9jYXJwZGV2KSkg
 PT0gTlVMTCkgeworCQkgICAgCWVycm9yID0gRUlOVkFMOworCQkgICAgCWJyZWFrOworCQl9CisJ
 CWlmICgoZXJyb3IgPSBjYXJwX3NldF9pZnAoc2MsIGNkZXYpKSkKKwkJCWJyZWFrOwogCQlpZiAo
 c2MtPnNjX2NhcnBkZXYpIHsKIAkJCWxvY2tlZCA9IDE7CiAJCQlDQVJQX1NDTE9DSyhzYyk7CkBA
 IC0xOTU5LDY0ICsyMDQ0LDM3IEBAIGNhcnBfaW9jdGwoc3RydWN0IGlmbmV0ICppZnAsIHVfbG9u
 ZyBjbWQsIGNhZGRyX3QgYWRkcikKIAkJaWYgKGVycm9yID09IDApCiAJCQliY29weShzYy0+c2Nf
 a2V5LCBjYXJwci5jYXJwcl9rZXksCiAJCQkgICAgc2l6ZW9mKGNhcnByLmNhcnByX2tleSkpOwor
 CQlpZiAoc2MtPnNjX2NhcnBkZXYgIT0gTlVMTCkKKwkJCXN0cmxjcHkoY2FycHIuY2FycHJfY2Fy
 cGRldiwgc2MtPnNjX2NhcnBkZXYtPmlmX3huYW1lLAorCQkJICAgIENBUlBERVZOQU1TSVopOwog
 CQllcnJvciA9IGNvcHlvdXQoJmNhcnByLCBpZnItPmlmcl9kYXRhLCBzaXplb2YoY2FycHIpKTsK
 IAkJYnJlYWs7CiAKKwljYXNlIFNJT0NBRERNVUxUSToKKwljYXNlIFNJT0NERUxNVUxUSToKKwkJ
 LyogVE9ETzogdGVsbCBjYXJwZGV2ICovCisJCWJyZWFrOworCiAJZGVmYXVsdDoKIAkJZXJyb3Ig
 PSBFSU5WQUw7CiAJfQogCisJaWYgKGNoYW5nZWQpIHsKKwkJaWYgKCFsb2NrZWQgJiYgc2MtPnNj
 X2NhcnBkZXYpIHsKKwkJCS8qIFhYWDogVGhpcyByZWFsbHkgc2hvdWxkbid0IGhhcHBlbiAqLwor
 CQkJQ0FSUF9TQ0xPQ0soc2MpOworCQkJbG9ja2VkID0gMTsKKwkJfQorCQljYXJwX2htYWNfcHJl
 cGFyZShzYyk7CisJfQorCiAJaWYgKGxvY2tlZCkKIAkJQ0FSUF9TQ1VOTE9DSyhzYyk7CiAKLQlj
 YXJwX2htYWNfcHJlcGFyZShzYyk7Ci0KIAlyZXR1cm4gKGVycm9yKTsKIH0KIAogLyoKLSAqIFhY
 WDogdGhpcyBpcyBsb291dHB1dC4gV2Ugc2hvdWxkIGV2ZW50dWFsbHkgdXNlIGl0IGZyb20gdGhl
 cmUuCi0gKi8KLXN0YXRpYyBpbnQKLWNhcnBfbG9vdXRwdXQoc3RydWN0IGlmbmV0ICppZnAsIHN0
 cnVjdCBtYnVmICptLCBzdHJ1Y3Qgc29ja2FkZHIgKmRzdCwKLSAgICBzdHJ1Y3QgcnRlbnRyeSAq
 cnQpCi17Ci0JdV9pbnQzMl90IGFmOwotCi0JTV9BU1NFUlRQS1RIRFIobSk7IC8qIGNoZWNrIGlm
 IHdlIGhhdmUgdGhlIHBhY2tldCBoZWFkZXIgKi8KLQotCWlmIChydCAmJiBydC0+cnRfZmxhZ3Mg
 JiAoUlRGX1JFSkVDVHxSVEZfQkxBQ0tIT0xFKSkgewotCQltX2ZyZWVtKG0pOwotCQlyZXR1cm4g
 KHJ0LT5ydF9mbGFncyAmIFJURl9CTEFDS0hPTEUgPyAwIDoKLQkJCXJ0LT5ydF9mbGFncyAmIFJU
 Rl9IT1NUID8gRUhPU1RVTlJFQUNIIDogRU5FVFVOUkVBQ0gpOwotCX0KLQotCWlmcC0+aWZfb3Bh
 Y2tldHMrKzsKLQlpZnAtPmlmX29ieXRlcyArPSBtLT5tX3BrdGhkci5sZW47Ci0KLQkvKiBCUEYg
 d3JpdGVzIG5lZWQgdG8gYmUgaGFuZGxlZCBzcGVjaWFsbHkuICovCi0JaWYgKGRzdC0+c2FfZmFt
 aWx5ID09IEFGX1VOU1BFQykgewotCQliY29weShkc3QtPnNhX2RhdGEsICZhZiwgc2l6ZW9mKGFm
 KSk7Ci0JCWRzdC0+c2FfZmFtaWx5ID0gYWY7Ci0JfQotCi0jaWYgMQkvKiBYWFggKi8KLQlzd2l0
 Y2ggKGRzdC0+c2FfZmFtaWx5KSB7Ci0JY2FzZSBBRl9JTkVUOgotCWNhc2UgQUZfSU5FVDY6Ci0J
 Y2FzZSBBRl9JUFg6Ci0JY2FzZSBBRl9BUFBMRVRBTEs6Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0J
 CXByaW50ZigiY2FycF9sb291dHB1dDogYWY9JWQgdW5leHBlY3RlZFxuIiwgZHN0LT5zYV9mYW1p
 bHkpOwotCQltX2ZyZWVtKG0pOwotCQlyZXR1cm4gKEVBRk5PU1VQUE9SVCk7Ci0JfQotI2VuZGlm
 Ci0JcmV0dXJuKGlmX3NpbWxvb3AoaWZwLCBtLCBkc3QtPnNhX2ZhbWlseSwgMCkpOwotfQotCi0v
 KgogICogU3RhcnQgb3V0cHV0IG9uIGNhcnAgaW50ZXJmYWNlLiBUaGlzIGZ1bmN0aW9uIHNob3Vs
 ZCBuZXZlciBiZSBjYWxsZWQuCiAgKi8KIHN0YXRpYyB2b2lkCkBAIC0yMDI3LDgxICsyMDg1LDg0
 IEBAIGNhcnBfc3RhcnQoc3RydWN0IGlmbmV0ICppZnApCiAjZW5kaWYKIH0KIAotaW50CitzdGF0
 aWMgaW50CiBjYXJwX291dHB1dChzdHJ1Y3QgaWZuZXQgKmlmcCwgc3RydWN0IG1idWYgKm0sIHN0
 cnVjdCBzb2NrYWRkciAqc2EsCiAgICAgc3RydWN0IHJ0ZW50cnkgKnJ0KQogewotCXN0cnVjdCBt
 X3RhZyAqbXRhZzsKLQlzdHJ1Y3QgY2FycF9zb2Z0YyAqc2M7Ci0Jc3RydWN0IGlmbmV0ICpjYXJw
 X2lmcDsKKwlzdHJ1Y3QgY2FycF9zb2Z0YyAqc2MgPSBpZnAtPmlmX3NvZnRjOwogCi0JaWYgKCFz
 YSkKLQkJcmV0dXJuICgwKTsKKwlpZiAoc2MtPnNjX2NhcnBkZXYgIT0gTlVMTCAmJiBzYy0+c2Nf
 c3RhdGUgPT0gTUFTVEVSKQorCQlyZXR1cm4gKHNjLT5zY19jYXJwZGV2LT5pZl9vdXRwdXQoaWZw
 LCBtLCBzYSwgcnQpKTsKKwllbHNlIHsKKwkJbV9mcmVlbShtKTsKKwkJcmV0dXJuIChFTkVUVU5S
 RUFDSCk7CisJfQorfQogCi0Jc3dpdGNoIChzYS0+c2FfZmFtaWx5KSB7Ci0jaWZkZWYgSU5FVAot
 CWNhc2UgQUZfSU5FVDoKLQkJYnJlYWs7Ci0jZW5kaWYgLyogSU5FVCAqLwotI2lmZGVmIElORVQ2
 Ci0JY2FzZSBBRl9JTkVUNjoKLQkJYnJlYWs7Ci0jZW5kaWYgLyogSU5FVDYgKi8KLQlkZWZhdWx0
 OgotCQlyZXR1cm4gKDApOworc3RydWN0IGlmbmV0ICoKK2NhcnBfb3VyZXRoZXIodm9pZCAqdiwg
 c3RydWN0IGV0aGVyX2hlYWRlciAqZWgsIHVfY2hhciBpZnR5cGUsIGludCBzcmMpCit7CisJc3Ry
 dWN0IGNhcnBfaWYgKmNpZiA9IChzdHJ1Y3QgY2FycF9pZiAqKXY7CisJc3RydWN0IGNhcnBfc29m
 dGMgKnZoOworCXVfaW50OF90ICplbmE7CisKKwlpZiAoc3JjKQorCQllbmEgPSAodV9pbnQ4X3Qg
 KikmZWgtPmV0aGVyX3Nob3N0OworCWVsc2UKKwkJZW5hID0gKHVfaW50OF90ICopJmVoLT5ldGhl
 cl9kaG9zdDsKKworCVRBSUxRX0ZPUkVBQ0godmgsICZjaWYtPnZoaWZfdnJzLCBzY19saXN0KSB7
 CisJCWlmICgodmgtPnNjX2lmcC0+aWZfZmxhZ3MgJiAoSUZGX1VQKSkgIT0gKElGRl9VUCkpCisJ
 CQljb250aW51ZTsKKwkJaWYgKCh2aC0+c2Nfc3RhdGUgPT0gTUFTVEVSIC8qIHx8IHZoLT5zY19p
 ZnAtPmlmX2ZsYWdzICYgSUZGX0xJTkswICovKQorCQkgICAgJiYgIWJjbXAoZW5hLCBJRl9MTEFE
 RFIodmgtPnNjX2lmcCksIEVUSEVSX0FERFJfTEVOKSkKKwkJCXJldHVybiAodmgtPnNjX2lmcCk7
 CiAJfQorCXJldHVybiAoTlVMTCk7Cit9CiAKLQltdGFnID0gbV90YWdfZmluZChtLCBQQUNLRVRf
 VEFHX0NBUlAsIE5VTEwpOwotCWlmIChtdGFnID09IE5VTEwpCi0JCXJldHVybiAoMCk7CitpbnQK
 K2NhcnBfaW5wdXQoc3RydWN0IG1idWYgKm0pCit7CisJc3RydWN0IGV0aGVyX2hlYWRlciAqZWg7
 CisJc3RydWN0IGNhcnBfaWYgKmNpZiA9IChzdHJ1Y3QgY2FycF9pZiAqKW0tPm1fcGt0aGRyLnJj
 dmlmLT5pZl9jYXJwOworCXN0cnVjdCBpZm5ldCAqaWZwOwogCi0JYmNvcHkobXRhZyArIDEsICZj
 YXJwX2lmcCwgc2l6ZW9mKHN0cnVjdCBpZm5ldCAqKSk7Ci0Jc2MgPSBjYXJwX2lmcC0+aWZfc29m
 dGM7Ci0KLQkvKiBTZXQgdGhlIHNvdXJjZSBNQUMgYWRkcmVzcyB0byBWaXJ0dWFsIFJvdXRlciBN
 QUMgQWRkcmVzcyAqLwotCXN3aXRjaCAoaWZwLT5pZl90eXBlKSB7Ci0JY2FzZSBJRlRfRVRIRVI6
 Ci0JY2FzZSBJRlRfTDJWTEFOOiB7Ci0JCQlzdHJ1Y3QgZXRoZXJfaGVhZGVyICplaDsKLQotCQkJ
 ZWggPSBtdG9kKG0sIHN0cnVjdCBldGhlcl9oZWFkZXIgKik7Ci0JCQllaC0+ZXRoZXJfc2hvc3Rb
 MF0gPSAwOwotCQkJZWgtPmV0aGVyX3Nob3N0WzFdID0gMDsKLQkJCWVoLT5ldGhlcl9zaG9zdFsy
 XSA9IDB4NWU7Ci0JCQllaC0+ZXRoZXJfc2hvc3RbM10gPSAwOwotCQkJZWgtPmV0aGVyX3Nob3N0
 WzRdID0gMTsKLQkJCWVoLT5ldGhlcl9zaG9zdFs1XSA9IHNjLT5zY192aGlkOwotCQl9Ci0JCWJy
 ZWFrOwotCWNhc2UgSUZUX0ZEREk6IHsKLQkJCXN0cnVjdCBmZGRpX2hlYWRlciAqZmg7Ci0KLQkJ
 CWZoID0gbXRvZChtLCBzdHJ1Y3QgZmRkaV9oZWFkZXIgKik7Ci0JCQlmaC0+ZmRkaV9zaG9zdFsw
 XSA9IDA7Ci0JCQlmaC0+ZmRkaV9zaG9zdFsxXSA9IDA7Ci0JCQlmaC0+ZmRkaV9zaG9zdFsyXSA9
 IDB4NWU7Ci0JCQlmaC0+ZmRkaV9zaG9zdFszXSA9IDA7Ci0JCQlmaC0+ZmRkaV9zaG9zdFs0XSA9
 IDE7Ci0JCQlmaC0+ZmRkaV9zaG9zdFs1XSA9IHNjLT5zY192aGlkOwotCQl9Ci0JCWJyZWFrOwot
 CWNhc2UgSUZUX0lTTzg4MDI1OiB7Ci0gCQkJc3RydWN0IGlzbzg4MDI1X2hlYWRlciAqdGg7Ci0g
 CQkJdGggPSBtdG9kKG0sIHN0cnVjdCBpc284ODAyNV9oZWFkZXIgKik7Ci0JCQl0aC0+aXNvODgw
 MjVfc2hvc3RbMF0gPSAzOwotCQkJdGgtPmlzbzg4MDI1X3Nob3N0WzFdID0gMDsKLQkJCXRoLT5p
 c284ODAyNV9zaG9zdFsyXSA9IDB4NDAgPj4gKHNjLT5zY192aGlkIC0gMSk7Ci0JCQl0aC0+aXNv
 ODgwMjVfc2hvc3RbM10gPSAweDQwMDAwID4+IChzYy0+c2NfdmhpZCAtIDEpOwotCQkJdGgtPmlz
 bzg4MDI1X3Nob3N0WzRdID0gMDsKLQkJCXRoLT5pc284ODAyNV9zaG9zdFs1XSA9IDA7CisJZWgg
 PSBtdG9kKG0sIHN0cnVjdCBldGhlcl9oZWFkZXIgKik7CisKKwlpZiAoKGlmcCA9IGNhcnBfb3Vy
 ZXRoZXIoY2lmLCBlaCwgbS0+bV9wa3RoZHIucmN2aWYtPmlmX3R5cGUsIDApKSkKKwkJOworCWVs
 c2UgaWYgKG0tPm1fZmxhZ3MgJiAoTV9CQ0FTVHxNX01DQVNUKSkgeworCQlzdHJ1Y3QgY2FycF9z
 b2Z0YyAqdmg7CisJCXN0cnVjdCBtYnVmICptMDsKKworCQkvKgorCQkgKiBYWFggU2hvdWxkIHJl
 YWxseSBjaGVjayB0aGUgbGlzdCBvZiBtdWx0aWNhc3QgYWRkcmVzc2VzCisJCSAqIGZvciBlYWNo
 IENBUlAgaW50ZXJmYWNlIF9iZWZvcmVfIGNvcHlpbmcuCisJCSAqLworCQlUQUlMUV9GT1JFQUNI
 KHZoLCAmY2lmLT52aGlmX3Zycywgc2NfbGlzdCkgeworCQkJbTAgPSBtX2R1cChtLCBNX0RPTlRX
 QUlUKTsKKwkJCWlmIChtMCA9PSBOVUxMKQorCQkJCWNvbnRpbnVlOworCQkJbTAtPm1fcGt0aGRy
 LnJjdmlmID0gdmgtPnNjX2lmcDsKKwkJCWV0aGVyX2lucHV0KHZoLT5zY19pZnAsIG0wKTsKIAkJ
 fQotCQlicmVhazsKLQlkZWZhdWx0OgotCQlwcmludGYoIiVzOiBjYXJwIGlzIG5vdCBzdXBwb3J0
 ZWQgZm9yIHRoaXMgaW50ZXJmYWNlIHR5cGVcbiIsCi0JCSAgICBpZnAtPmlmX3huYW1lKTsKLQkJ
 cmV0dXJuIChFT1BOT1RTVVBQKTsKKwkJcmV0dXJuICgxKTsKIAl9CiAKKwlpZiAoaWZwID09IE5V
 TEwpCisJCXJldHVybiAoMSk7CisKKwltLT5tX3BrdGhkci5yY3ZpZiA9IGlmcDsKKworI2lmIDAg
 LyogWFhYOiBCUEYgKi8KKwlpZiAoaWZwLT5pZl9icGYpCisJCWJwZl9tdGFwX2hkcihpZnAtPmlm
 X2JwZiwgKGNoYXIgKikmZWgsIEVUSEVSX0hEUl9MRU4sIG0sCisJCSAgICBCUEZfRElSRUNUSU9O
 X0lOKTsKKyNlbmRpZgorCWlmcC0+aWZfaXBhY2tldHMrKzsKKwlldGhlcl9pbnB1dChpZnAsIG0p
 OworCiAJcmV0dXJuICgwKTsKIH0KIApAQCAtMjEzMSw5ICsyMTkyLDE0IEBAIGNhcnBfc2V0X3N0
 YXRlKHN0cnVjdCBjYXJwX3NvZnRjICpzYywgaW50IHN0YXRlKQogfQogCiB2b2lkCi1jYXJwX2Nh
 cnBkZXZfc3RhdGUodm9pZCAqdikKK2NhcnBfY2FycGRldl9zdGF0ZShzdHJ1Y3QgaWZuZXQgKmlm
 cCkKIHsKLQlzdHJ1Y3QgY2FycF9pZiAqY2lmID0gdjsKKwlzdHJ1Y3QgY2FycF9pZiAqY2lmOwor
 CisJaWYgKGlmcC0+aWZfdHlwZSA9PSBJRlRfQ0FSUCB8fCBpZnAtPmlmX2NhcnAgPT0gTlVMTCkK
 KwkJcmV0dXJuOworCisJY2lmID0gaWZwLT5pZl9jYXJwOwogCiAJQ0FSUF9MT0NLKGNpZik7CiAJ
 Y2FycF9jYXJwZGV2X3N0YXRlX2xvY2tlZChjaWYpOwpkaWZmIC0tZ2l0IGEvc3lzL25ldGluZXQv
 aXBfY2FycC5oIGIvc3lzL25ldGluZXQvaXBfY2FycC5oCmluZGV4IDE2ODhiMDEuLjM1MjVhYjkg
 MTAwNjQ0Ci0tLSBhL3N5cy9uZXRpbmV0L2lwX2NhcnAuaAorKysgYi9zeXMvbmV0aW5ldC9pcF9j
 YXJwLmgKQEAgLTExNyw2ICsxMTcsMTMgQEAgc3RydWN0IGNhcnBzdGF0cyB7CiAJdWludDY0X3QJ
 Y2FycHNfcHJlZW1wdDsJCS8qIGlmIGVuYWJsZWQsIHByZWVtcHRpb25zICovCiB9OwogCisjZGVm
 aW5lCUNBUlBERVZOQU1TSVoJMTYKKyNpZmRlZiBJRk5BTVNJWgorI2lmIENBUlBERVZOQU1TSVog
 IT0gSUZOQU1TSVoKKyNlcnJvcgorI2VuZGlmCisjZW5kaWYKKwogLyoKICAqIENvbmZpZ3VyYXRp
 b24gc3RydWN0dXJlIGZvciBTSU9DU1ZIIFNJT0NHVkgKICAqLwpAQCAtMTI4LDYgKzEzNSw3IEBA
 IHN0cnVjdCBjYXJwcmVxIHsKIAlpbnQJCWNhcnByX2FkdnNrZXc7CiAJaW50CQljYXJwcl9hZHZi
 YXNlOwogCXVuc2lnbmVkIGNoYXIJY2FycHJfa2V5W0NBUlBfS0VZX0xFTl07CisJY2hhcgkJY2Fy
 cHJfY2FycGRldltDQVJQREVWTkFNU0laXTsKIH07CiAjZGVmaW5lCVNJT0NTVkgJX0lPV1IoJ2kn
 LCAyNDUsIHN0cnVjdCBpZnJlcSkKICNkZWZpbmUJU0lPQ0dWSAlfSU9XUignaScsIDI0Niwgc3Ry
 dWN0IGlmcmVxKQpAQCAtMTUyLDE1ICsxNjAsMTUgQEAgc3RydWN0IGNhcnByZXEgewogfQogCiAj
 aWZkZWYgX0tFUk5FTAotdm9pZAkJIGNhcnBfY2FycGRldl9zdGF0ZSh2b2lkICopOwotdm9pZAkJ
 IGNhcnBfaW5wdXQgKHN0cnVjdCBtYnVmICosIGludCk7Ci1pbnQJCSBjYXJwNl9pbnB1dCAoc3Ry
 dWN0IG1idWYgKiosIGludCAqLCBpbnQpOwotaW50CQkgY2FycF9vdXRwdXQgKHN0cnVjdCBpZm5l
 dCAqLCBzdHJ1Y3QgbWJ1ZiAqLCBzdHJ1Y3Qgc29ja2FkZHIgKiwKLQkJICAgICBzdHJ1Y3QgcnRl
 bnRyeSAqKTsKLWludAkJIGNhcnBfaWFtYXRjaCAodm9pZCAqLCBzdHJ1Y3QgaW5faWZhZGRyICos
 IHN0cnVjdCBpbl9hZGRyICosCit2b2lkCQkgY2FycF9jYXJwZGV2X3N0YXRlKHN0cnVjdCBpZm5l
 dCAqKTsKK3ZvaWQJCSBjYXJwX3Byb3RvX2lucHV0KHN0cnVjdCBtYnVmICosIGludCk7CitpbnQJ
 CSBjYXJwNl9wcm90b19pbnB1dChzdHJ1Y3QgbWJ1ZiAqKiwgaW50ICosIGludCk7CitpbnQJCSBj
 YXJwX2lhbWF0Y2godm9pZCAqLCBzdHJ1Y3QgaW5faWZhZGRyICosIHN0cnVjdCBpbl9hZGRyICos
 CiAJCSAgICAgdV9pbnQ4X3QgKiopOwogc3RydWN0IGlmYWRkcgkqY2FycF9pYW1hdGNoNih2b2lk
 ICosIHN0cnVjdCBpbjZfYWRkciAqKTsKIHZvaWQJCSpjYXJwX21hY21hdGNoNih2b2lkICosIHN0
 cnVjdCBtYnVmICosIGNvbnN0IHN0cnVjdCBpbjZfYWRkciAqKTsKLXN0cnVjdAlpZm5ldAkqY2Fy
 cF9mb3J1cyAodm9pZCAqLCB2b2lkICopOworc3RydWN0CWlmbmV0CSpjYXJwX2ZvcnVzKHZvaWQg
 Kiwgdm9pZCAqKTsKK3N0cnVjdCBpZm5ldAkqY2FycF9vdXJldGhlcih2b2lkICosIHN0cnVjdCBl
 dGhlcl9oZWFkZXIgKiwgdV9jaGFyLCBpbnQpOworaW50CQkgY2FycF9pbnB1dChzdHJ1Y3QgbWJ1
 ZiAqKTsKICNlbmRpZgogI2VuZGlmIC8qIF9JUF9DQVJQX0ggKi8KZGlmZiAtLWdpdCBhL3N5cy9u
 ZXRpbmV0Ni9pbjZfcHJvdG8uYyBiL3N5cy9uZXRpbmV0Ni9pbjZfcHJvdG8uYwppbmRleCAyMjMw
 NzQxLi5mYmQwMjJkIDEwMDY0NAotLS0gYS9zeXMvbmV0aW5ldDYvaW42X3Byb3RvLmMKKysrIGIv
 c3lzL25ldGluZXQ2L2luNl9wcm90by5jCkBAIC0zMTksNyArMzE5LDcgQEAgc3RydWN0IGlwNnBy
 b3Rvc3cgaW5ldDZzd1tdID0gewogCS5wcl9kb21haW4gPQkJJmluZXQ2ZG9tYWluLAogCS5wcl9w
 cm90b2NvbCA9CQlJUFBST1RPX0NBUlAsCiAJLnByX2ZsYWdzID0JCVBSX0FUT01JQ3xQUl9BRERS
 LAotCS5wcl9pbnB1dCA9CQljYXJwNl9pbnB1dCwKKwkucHJfaW5wdXQgPQkJY2FycDZfcHJvdG9f
 aW5wdXQsCiAJLnByX291dHB1dCA9CQlyaXA2X291dHB1dCwKIAkucHJfY3Rsb3V0cHV0ID0JCXJp
 cDZfY3Rsb3V0cHV0LAogCS5wcl91c3JyZXFzID0JCSZyaXA2X3VzcnJlcXMK
 --00504502af1430370c0478ac5c5d--

From: Alex Deiter <alex.deiter@gmail.com>
To: bug-followup@FreeBSD.org, Me@SBrickey.net, glebius@FreeBSD.org, 
	remko@FreeBSD.org
Cc:  
Subject: Re: kern/117000: [carp] CARP using address-less host NIC (carpdev)
Date: Wed, 3 Mar 2010 00:11:31 +0300

 Dear All,
 
 Do you have any progress ?
 Could you please update this PR ?
 
 Thanks a lot!

From: Anders Larsson <anderslarsson.listor@exait.se>
To: bug-followup@FreeBSD.org, Me@SBrickey.net
Cc: fjwcash@gmail.com
Subject: Re: kern/117000: [carp] CARP using address-less host NIC (carpdev)
Date: Fri, 29 Oct 2010 16:48:52 +0200

 Is anyone working on the carpdev.BETA2 attached in the PR?
 I think this bug should get some more attention since IPv4 address space 
 is getting more and more crowded.
 And FreeBSD should not "waste" IPv4 addresses in this way. :-/
 
 On which FreeBSD version was the patch working on? (Since it is dated 
 from June 2008)
 
 I do not have the coding skills to fix it, but i do have resources to 
 test them if anyone could
 "update" the diff from the previous release to FreeBSD 8.1-RELEASE or newer?
 
 With Regards
 /Anders
 

From: dfilter@FreeBSD.ORG (dfilter service)
To: bug-followup@FreeBSD.org
Cc:  
Subject: Re: kern/117000: commit references a PR
Date: Fri, 16 Dec 2011 12:17:08 +0000 (UTC)

 Author: glebius
 Date: Fri Dec 16 12:16:56 2011
 New Revision: 228571
 URL: http://svn.freebsd.org/changeset/base/228571
 
 Log:
   A major overhaul of the CARP implementation. The ip_carp.c was started
   from scratch, copying needed functionality from the old implemenation
   on demand, with a thorough review of all code. The main change is that
   interface layer has been removed from the CARP. Now redundant addresses
   are configured exactly on the interfaces, they run on.
   
   The CARP configuration itself is, as before, configured and read via
   SIOCSVH/SIOCGVH ioctls. A new prefix created with SIOCAIFADDR or
   SIOCAIFADDR_IN6 may now be configured to a particular virtual host id,
   which makes the prefix redundant.
   
   ifconfig(8) semantics has been changed too: now one doesn't need
   to clone carpXX interface, he/she should directly configure a vhid
   on a Ethernet interface.
   
   To supply vhid data from the kernel to an application the getifaddrs(8)
   function had been changed to pass ifam_data with each address. [1]
   
   The new implementation definitely closes all PRs related to carp(4)
   being an interface, and may close several others. It also allows
   to run a single redundant IP per interface.
   
   Big thanks to Bjoern Zeeb for his help with inet6 part of patch, for
   idea on using ifam_data and for several rounds of reviewing!
   
   PR:		kern/117000, kern/126945, kern/126714, kern/120130, kern/117448
   Reviewed by:	bz
   Submitted by:	bz [1]
 
 Modified:
   head/UPDATING
   head/lib/libc/net/getifaddrs.c
   head/sbin/ifconfig/af_inet.c
   head/sbin/ifconfig/af_inet6.c
   head/sbin/ifconfig/ifcarp.c
   head/sbin/ifconfig/ifconfig.8
   head/sbin/ifconfig/ifconfig.c
   head/sbin/ifconfig/ifconfig.h
   head/share/man/man4/carp.4
   head/sys/net/if.c
   head/sys/net/if.h
   head/sys/net/if_ethersubr.c
   head/sys/net/if_types.h
   head/sys/net/if_var.h
   head/sys/net/rtsock.c
   head/sys/netinet/if_ether.c
   head/sys/netinet/if_ether.h
   head/sys/netinet/in.c
   head/sys/netinet/in_var.h
   head/sys/netinet/ip_carp.c
   head/sys/netinet/ip_carp.h
   head/sys/netinet6/in6.c
   head/sys/netinet6/in6_ifattach.c
   head/sys/netinet6/in6_var.h
   head/sys/netinet6/nd6.c
   head/sys/netinet6/nd6_nbr.c
   head/sys/sys/param.h
 
 Modified: head/UPDATING
 ==============================================================================
 --- head/UPDATING	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/UPDATING	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -22,6 +22,17 @@ NOTE TO PEOPLE WHO THINK THAT FreeBSD 10
  	machines to maximize performance.  (To disable malloc debugging, run
  	ln -s aj /etc/malloc.conf.)
  
 +20111215:
 +	The carp(4) facility has been changed significantly. Configuration
 +	of the CARP protocol via ifconfig(8) has changed, as well as format
 +	of CARP events submitted to devd(8) has changed. See manual pages
 +	for more information. The arpbalance feature of carp(4) is currently
 +	not supported anymore.
 +
 +	Size of struct in_aliasreq, struct in6_aliasreq has changed. User
 +	utilities using SIOCAIFADDR, SIOCAIFADDR_IN6, e.g. ifconfig(8),
 +	need to be recompiled.
 +
  20111122:
  	The acpi_wmi(4) status device /dev/wmistat has been renamed to
  	/dev/wmistat0.
 
 Modified: head/lib/libc/net/getifaddrs.c
 ==============================================================================
 --- head/lib/libc/net/getifaddrs.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/lib/libc/net/getifaddrs.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -76,7 +76,7 @@ __FBSDID("$FreeBSD$");
  #define	HAVE_IFM_DATA
  #endif
  
 -#if	_BSDI_VERSION >= 199802
 +#if	(_BSDI_VERSION >= 199802) || (__FreeBSD_version >= 1000003) 
  /* ifam_data is very specific to recent versions of bsdi */
  #define	HAVE_IFAM_DATA
  #endif
 
 Modified: head/sbin/ifconfig/af_inet.c
 ==============================================================================
 --- head/sbin/ifconfig/af_inet.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sbin/ifconfig/af_inet.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -84,8 +84,11 @@ in_status(int s __unused, const struct i
  	if (ifa->ifa_flags & IFF_BROADCAST) {
  		sin = (struct sockaddr_in *)ifa->ifa_broadaddr;
  		if (sin != NULL && sin->sin_addr.s_addr != 0)
 -			printf("broadcast %s", inet_ntoa(sin->sin_addr));
 +			printf("broadcast %s ", inet_ntoa(sin->sin_addr));
  	}
 +
 +	print_vhid(ifa, " ");
 +
  	putchar('\n');
  }
  
 
 Modified: head/sbin/ifconfig/af_inet6.c
 ==============================================================================
 --- head/sbin/ifconfig/af_inet6.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sbin/ifconfig/af_inet6.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -307,6 +307,8 @@ in6_status(int s __unused, const struct 
  			printf("infty ");
  	}
  
 +	print_vhid(ifa, " ");
 +
  	putchar('\n');
  }
  
 
 Modified: head/sbin/ifconfig/ifcarp.c
 ==============================================================================
 --- head/sbin/ifconfig/ifcarp.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sbin/ifconfig/ifcarp.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -35,10 +35,11 @@
  #include <stdlib.h>
  #include <unistd.h>
  
 -#include <net/ethernet.h>
  #include <net/if.h>
 +#include <net/if_var.h>
 +#include <netinet/in.h>
 +#include <netinet/in_var.h>
  #include <netinet/ip_carp.h>
 -#include <net/route.h>
  
  #include <ctype.h>
  #include <stdio.h>
 @@ -52,127 +53,153 @@
  
  static const char *carp_states[] = { CARP_STATES };
  
 -void carp_status(int s);
 -void setcarp_advbase(const char *,int, int, const struct afswtch *rafp);
 -void setcarp_advskew(const char *, int, int, const struct afswtch *rafp);
 -void setcarp_passwd(const char *, int, int, const struct afswtch *rafp);
 -void setcarp_vhid(const char *, int, int, const struct afswtch *rafp);
 +static void carp_status(int s);
 +static void setcarp_vhid(const char *, int, int, const struct afswtch *rafp);
 +static void setcarp_callback(int, void *);
 +static void setcarp_advbase(const char *,int, int, const struct afswtch *rafp);
 +static void setcarp_advskew(const char *, int, int, const struct afswtch *rafp);
 +static void setcarp_passwd(const char *, int, int, const struct afswtch *rafp);
 +
 +static int carpr_vhid = -1;
 +static int carpr_advskew = -1;
 +static int carpr_advbase = -1;
 +static int carpr_state = -1;
 +static unsigned char const *carpr_key;
  
 -void
 +static void
  carp_status(int s)
  {
 -	const char *state;
 -	struct carpreq carpr;
 +	struct carpreq carpr[CARP_MAXVHID];
 +	int i;
  
 -	memset((char *)&carpr, 0, sizeof(struct carpreq));
 +	bzero(carpr, sizeof(struct carpreq) * CARP_MAXVHID);
 +	carpr[0].carpr_count = CARP_MAXVHID;
  	ifr.ifr_data = (caddr_t)&carpr;
  
  	if (ioctl(s, SIOCGVH, (caddr_t)&ifr) == -1)
  		return;
  
 -	if (carpr.carpr_vhid > 0) {
 -		if (carpr.carpr_state > CARP_MAXSTATE)
 -			state = "<UNKNOWN>";
 +	for (i = 0; i < carpr[0].carpr_count; i++) {
 +		printf("\tcarp: %s vhid %d advbase %d advskew %d",
 +		    carp_states[carpr[i].carpr_state], carpr[i].carpr_vhid,
 +		    carpr[i].carpr_advbase, carpr[i].carpr_advskew);
 +		if (printkeys && carpr[i].carpr_key[0] != '\0')
 +			printf(" key \"%s\"\n", carpr[i].carpr_key);
  		else
 -			state = carp_states[carpr.carpr_state];
 -
 -		printf("\tcarp: %s vhid %d advbase %d advskew %d\n",
 -		    state, carpr.carpr_vhid, carpr.carpr_advbase,
 -		    carpr.carpr_advskew);
 +			printf("\n");
  	}
 -
 -	return;
 -
  }
  
 -void
 -setcarp_passwd(const char *val, int d, int s, const struct afswtch *afp)
 +static void
 +setcarp_vhid(const char *val, int d, int s, const struct afswtch *afp)
  {
 -	struct carpreq carpr;
  
 -	memset((char *)&carpr, 0, sizeof(struct carpreq));
 -	ifr.ifr_data = (caddr_t)&carpr;
 +	carpr_vhid = atoi(val);
  
 -	if (ioctl(s, SIOCGVH, (caddr_t)&ifr) == -1)
 -		err(1, "SIOCGVH");
 -
 -	memset(carpr.carpr_key, 0, sizeof(carpr.carpr_key));
 -	/* XXX Should hash the password into the key here, perhaps? */
 -	strlcpy(carpr.carpr_key, val, CARP_KEY_LEN);
 -
 -	if (ioctl(s, SIOCSVH, (caddr_t)&ifr) == -1)
 -		err(1, "SIOCSVH");
 +	if (carpr_vhid <= 0 || carpr_vhid > CARP_MAXVHID)
 +		errx(1, "vhid must be greater than 0 and less than %u",
 +		    CARP_MAXVHID);
 +
 +	switch (afp->af_af) {
 +#ifdef INET
 +	case AF_INET:
 +	    {
 +		struct in_aliasreq *ifra;
 +
 +		ifra = (struct in_aliasreq *)afp->af_addreq;
 +		ifra->ifra_vhid = carpr_vhid;
 +		break;
 +	    }
 +#endif
 +#ifdef INET6
 +	case AF_INET6:
 +	    {
 +		struct in6_aliasreq *ifra;
 +
 +		ifra = (struct in6_aliasreq *)afp->af_addreq;
 +		ifra->ifra_vhid = carpr_vhid;
 +		break;
 +	    }
 +#endif
 +	default:
 +		errx(1, "%s doesn't support carp(4)", afp->af_name);
 +	}
  
 -	return;
 +	callback_register(setcarp_callback, NULL);
  }
  
 -void
 -setcarp_vhid(const char *val, int d, int s, const struct afswtch *afp)
 +static void
 +setcarp_callback(int s, void *arg __unused)
  {
 -	int vhid;
  	struct carpreq carpr;
  
 -	vhid = atoi(val);
 -
 -	if (vhid <= 0)
 -		errx(1, "vhid must be greater than 0");
 -
 -	memset((char *)&carpr, 0, sizeof(struct carpreq));
 +	bzero(&carpr, sizeof(struct carpreq));
 +	carpr.carpr_vhid = carpr_vhid;
 +	carpr.carpr_count = 1;
  	ifr.ifr_data = (caddr_t)&carpr;
  
 -	if (ioctl(s, SIOCGVH, (caddr_t)&ifr) == -1)
 +	if (ioctl(s, SIOCGVH, (caddr_t)&ifr) == -1 && errno != ENOENT)
  		err(1, "SIOCGVH");
  
 -	carpr.carpr_vhid = vhid;
 +	if (carpr_key != NULL)
 +		/* XXX Should hash the password into the key here? */
 +		strlcpy(carpr.carpr_key, carpr_key, CARP_KEY_LEN);
 +	if (carpr_advskew > -1)
 +		carpr.carpr_advskew = carpr_advskew;
 +	if (carpr_advbase > -1)
 +		carpr.carpr_advbase = carpr_advbase;
 +	if (carpr_state > -1)
 +		carpr.carpr_state = carpr_state;
  
  	if (ioctl(s, SIOCSVH, (caddr_t)&ifr) == -1)
  		err(1, "SIOCSVH");
 -
 -	return;
  }
  
 -void
 -setcarp_advskew(const char *val, int d, int s, const struct afswtch *afp)
 +static void
 +setcarp_passwd(const char *val, int d, int s, const struct afswtch *afp)
  {
 -	int advskew;
 -	struct carpreq carpr;
  
 -	advskew = atoi(val);
 +	if (carpr_vhid == -1)
 +		errx(1, "passwd requires vhid");
  
 -	memset((char *)&carpr, 0, sizeof(struct carpreq));
 -	ifr.ifr_data = (caddr_t)&carpr;
 +	carpr_key = val;
 +}
  
 -	if (ioctl(s, SIOCGVH, (caddr_t)&ifr) == -1)
 -		err(1, "SIOCGVH");
 +static void
 +setcarp_advskew(const char *val, int d, int s, const struct afswtch *afp)
 +{
  
 -	carpr.carpr_advskew = advskew;
 +	if (carpr_vhid == -1)
 +		errx(1, "advskew requires vhid");
  
 -	if (ioctl(s, SIOCSVH, (caddr_t)&ifr) == -1)
 -		err(1, "SIOCSVH");
 -
 -	return;
 +	carpr_advskew = atoi(val);
  }
  
 -void
 +static void
  setcarp_advbase(const char *val, int d, int s, const struct afswtch *afp)
  {
 -	int advbase;
 -	struct carpreq carpr;
  
 -	advbase = atoi(val);
 +	if (carpr_vhid == -1)
 +		errx(1, "advbase requires vhid");
  
 -	memset((char *)&carpr, 0, sizeof(struct carpreq));
 -	ifr.ifr_data = (caddr_t)&carpr;
 +	carpr_advbase = atoi(val);
 +}
  
 -	if (ioctl(s, SIOCGVH, (caddr_t)&ifr) == -1)
 -		err(1, "SIOCGVH");
 +static void
 +setcarp_state(const char *val, int d, int s, const struct afswtch *afp)
 +{
 +	int i;
  
 -	carpr.carpr_advbase = advbase;
 +	if (carpr_vhid == -1)
 +		errx(1, "state requires vhid");
  
 -	if (ioctl(s, SIOCSVH, (caddr_t)&ifr) == -1)
 -		err(1, "SIOCSVH");
 +	for (i = 0; i <= CARP_MAXSTATE; i++)
 +		if (strcasecmp(carp_states[i], val) == 0) {
 +			carpr_state = i;
 +			return;
 +		}
  
 -	return;
 +	errx(1, "unknown state");
  }
  
  static struct cmd carp_cmds[] = {
 @@ -180,6 +207,7 @@ static struct cmd carp_cmds[] = {
  	DEF_CMD_ARG("advskew",	setcarp_advskew),
  	DEF_CMD_ARG("pass",	setcarp_passwd),
  	DEF_CMD_ARG("vhid",	setcarp_vhid),
 +	DEF_CMD_ARG("state",	setcarp_state),
  };
  static struct afswtch af_carp = {
  	.af_name	= "af_carp",
 
 Modified: head/sbin/ifconfig/ifconfig.8
 ==============================================================================
 --- head/sbin/ifconfig/ifconfig.8	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sbin/ifconfig/ifconfig.8	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -28,7 +28,7 @@
  .\"     From: @(#)ifconfig.8	8.3 (Berkeley) 1/5/94
  .\" $FreeBSD$
  .\"
 -.Dd November 12, 2011
 +.Dd December 16, 2011
  .Dt IFCONFIG 8
  .Os
  .Sh NAME
 @@ -2445,16 +2445,36 @@ The
  argument is useless and hence deprecated.
  .El
  .Pp
 -The following parameters are specific to
 +The following parameters are used to configure
  .Xr carp 4
 -interfaces:
 +protocol on an interface:
  .Bl -tag -width indent
 +.It Cm vhid Ar n
 +Set the virtual host ID.
 +This is a required setting to initiate
 +.Xr carp 4 .
 +If the virtual host ID doesn't exist yet, it is created and attached to the
 +interface, otherwise configuration of an existing vhid is adjusted.
 +If the
 +.Cm vhid
 +keyword is supplied along with an
 +.Dq inet6
 +or
 +.Dq inet
 +address, then this address is configured to be run under control of the
 +specified vhid.
 +Whenever a last address that refers to a particular vhid is removed from an
 +interface, the vhid is automatically removed from interface and destroyed.
 +Any other configuration parameters for the
 +.Xr carp 4
 +protocol should be supplied along with the
 +.Cm vhid
 +keyword.
 +Acceptable values for vhid are 1 to 255.
  .It Cm advbase Ar seconds
  Specifies the base of the advertisement interval in seconds.
  The acceptable values are 1 to 255.
  The default value is 1.
 -.\" The default value is
 -.\" .Dv CARP_DFLTINTV .
  .It Cm advskew Ar interval
  Specifies the skew to add to the base advertisement interval to
  make one host advertise slower than another host.
 @@ -2464,10 +2484,8 @@ The default value is 0.
  .It Cm pass Ar phrase
  Set the authentication key to
  .Ar phrase .
 -.It Cm vhid Ar n
 -Set the virtual host ID.
 -This is a required setting.
 -Acceptable values are 1 to 255.
 +.It Cm state Ar MASTER|BACKUP
 +Forcibly change state of a given vhid.
  .El
  .Pp
  The
 @@ -2530,8 +2548,9 @@ The
  .Fl k
  flag causes keying information for the interface, if available, to be
  printed.
 -For example, the values of 802.11 WEP keys will be printed, if accessible to
 -the current user.
 +For example, the values of 802.11 WEP keys and
 +.Xr carp 4
 +passphrases will be printed, if accessible to the current user.
  This information is not printed by default, as it may be considered
  sensitive.
  .Pp 
 @@ -2593,6 +2612,11 @@ as a synonym for the canonical form of t
  .Fl alias :
  .Dl # ifconfig em0 inet6 2001:db8:bdbd::123/48 delete
  .Pp
 +Configure a single CARP redundant address on igb0, and then switch it
 +to be master:
 +.Dl # ifconfig igb0 vhid 1 10.0.0.1/24 pass foobar
 +.Dl # ifconfig igb0 vhid 1 state master
 +.Pp
  Configure the interface
  .Li xl0 ,
  to use 100baseTX, full duplex Ethernet media options:
 
 Modified: head/sbin/ifconfig/ifconfig.c
 ==============================================================================
 --- head/sbin/ifconfig/ifconfig.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sbin/ifconfig/ifconfig.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -1078,6 +1078,21 @@ printb(const char *s, unsigned v, const 
  }
  
  void
 +print_vhid(const struct ifaddrs *ifa, const char *s)
 +{
 +	struct if_data *ifd;
 +
 +	if (ifa->ifa_data == NULL)
 +		return;
 +
 +	ifd = ifa->ifa_data;
 +	if (ifd->ifi_vhid == 0)
 +		return;
 +	
 +	printf("vhid %d ", ifd->ifi_vhid);
 +}
 +
 +void
  ifmaybeload(const char *name)
  {
  #define MOD_PREFIX_LEN		3	/* "if_" */
 
 Modified: head/sbin/ifconfig/ifconfig.h
 ==============================================================================
 --- head/sbin/ifconfig/ifconfig.h	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sbin/ifconfig/ifconfig.h	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -148,3 +148,6 @@ void	clone_setdefcallback(const char *, 
   * operations on ifmedia can avoid cmd line ordering confusion.
   */
  struct ifmediareq *ifmedia_getstate(int s);
 +
 +void print_vhid(const struct ifaddrs *, const char *);
 +
 
 Modified: head/share/man/man4/carp.4
 ==============================================================================
 --- head/share/man/man4/carp.4	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/share/man/man4/carp.4	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -1,6 +1,7 @@
  .\"	$OpenBSD: carp.4,v 1.16 2004/12/07 23:41:35 jmc Exp $
  .\"
  .\" Copyright (c) 2003, Ryan McBride.  All rights reserved.
 +.\" Copyright (c) 2011, Gleb Smirnoff <glebius@FreeBSD.org>
  .\"
  .\" Redistribution and use in source and binary forms, with or without
  .\" modification, are permitted provided that the following conditions
 @@ -25,7 +26,7 @@
  .\"
  .\" $FreeBSD$
  .\"
 -.Dd August 15, 2011
 +.Dd December 16, 2011
  .Dt CARP 4
  .Os
  .Sh NAME
 @@ -34,33 +35,17 @@
  .Sh SYNOPSIS
  .Cd "device carp"
  .Sh DESCRIPTION
 -The
 -.Nm
 -interface is a pseudo-device that implements and controls the
 -CARP protocol.
 -CARP allows multiple hosts on the same local network to share a set of IP addresses.
 +The CARP allows multiple hosts on the same local network to share a set of
 +IPv4 and/or IPv6 addresses.
  Its primary purpose is to ensure that these
 -addresses are always available, but in some configurations
 -.Nm
 -can also provide load balancing functionality.
 -.Pp
 -A
 -.Nm
 -interface can be created at runtime using the
 -.Nm ifconfig Li carp Ns Ar N Cm create
 -command or by configuring
 -it via
 -.Va cloned_interfaces
 -in the
 -.Pa /etc/rc.conf
 -file.
 +addresses are always available.
  .Pp
  To use
  .Nm ,
 -the administrator needs to configure at minimum a common virtual host ID (VHID)
 -and virtual host IP address on each machine which is to take part in the virtual
 -group.
 -Additional parameters can also be set on a per-interface basis:
 +the administrator needs to configure at minimum a common virtual host ID
 +(vhid) and attach at least one IP address to this vhid on each machine which
 +is to take part in the virtual group.
 +Additional parameters can also be set on a per-vhid basis:
  .Cm advbase
  and
  .Cm advskew ,
 @@ -93,9 +78,20 @@ or through the
  .Dv SIOCSVH
  .Xr ioctl 2 .
  .Pp
 +CARP virtual hosts can be configured on multicast capable interfaces: Ethernet,
 +layer 2 VLAN, FDDI and Token Ring.
 +An arbitrary number of virtual host IDs can be configured on an interface.
 +An arbitrary number of IPv4 or IPv6 addresses can be attached to a particular
 +vhid.
 +It is important that all hosts participating in a vhid have the same list
 +of prefixes configured on the vhid, since all prefixes are included in the
 +cryptographic checksum supplied in each advertisement.
 +Multiple vhids running on one interface participate in master/backup
 +elections independently.
 +.Pp
  Additionally, there are a number of global parameters which can be set using
  .Xr sysctl 8 :
 -.Bl -tag -width ".Va net.inet.carp.arpbalance"
 +.Bl -tag -width ".Va net.inet.carp.preempt"
  .It Va net.inet.carp.allow
  Accept incoming
  .Nm
 @@ -125,9 +121,6 @@ Values above 1 enable logging of bad
  .Nm
  packets.
  Default value is 1.
 -.It Va net.inet.carp.arpbalance
 -Balance local traffic using ARP (see below).
 -Disabled by default.
  .It Va net.inet.carp.suppress_preempt
  A read only value showing the status of preemption suppression.
  Preemption can be suppressed if link on an interface is down
 @@ -138,36 +131,36 @@ Value of 0 means that preemption is not 
  problems are detected.
  Every problem increments suppression counter.
  .El
 -.Sh ARP level load balancing
 -The
 -.Nm
 -has limited abilities for load balancing the incoming connections
 -between hosts in Ethernet network.
 -For load balancing operation, one needs several CARP interfaces that
 -are configured to the same IP address, but to a different VHIDs.
 -Once an ARP request is received, the CARP protocol will use a hashing
 -function against the source IP address in the ARP request to determine
 -which VHID should this request belong to.
 -If the corresponding CARP interface is in master state, the ARP request
 -will be replied, otherwise it will be ignored.
 -See the
 -.Sx EXAMPLES
 -section for a practical example of load balancing.
 -.Pp
 -The ARP load balancing has some limitations.
 -First, ARP balancing only works on the local network segment.
 -It cannot balance traffic that crosses a router, because the
 -router itself will always be balanced to the same virtual host.
 -Second, ARP load balancing can lead to asymmetric routing
 -of incoming and outgoing traffic, and thus combining it with
 -.Xr pfsync 4
 -is dangerous, because this creates a race condition between
 -balanced routers and a host they are serving.
 -Imagine an incoming packet creating state on the first router, being
 -forwarded to its destination, and destination replying faster
 -than the state information is packed and synced with the second router.
 -If the reply would be load balanced to second router, it will be
 -dropped due to no state.
 +.\".Sh ARP level load balancing
 +.\"The
 +.\".Nm
 +.\"has limited abilities for load balancing the incoming connections
 +.\"between hosts in Ethernet network.
 +.\"For load balancing operation, one needs several CARP interfaces that
 +.\"are configured to the same IP address, but to a different vhids.
 +.\"Once an ARP request is received, the CARP protocol will use a hashing
 +.\"function against the source IP address in the ARP request to determine
 +.\"which vhid should this request belong to.
 +.\"If the corresponding CARP interface is in master state, the ARP request
 +.\"will be replied, otherwise it will be ignored.
 +.\"See the
 +.\".Sx EXAMPLES
 +.\"section for a practical example of load balancing.
 +.\".Pp
 +.\"The ARP load balancing has some limitations.
 +.\"First, ARP balancing only works on the local network segment.
 +.\"It cannot balance traffic that crosses a router, because the
 +.\"router itself will always be balanced to the same virtual host.
 +.\"Second, ARP load balancing can lead to asymmetric routing
 +.\"of incoming and outgoing traffic, and thus combining it with
 +.\".Xr pfsync 4
 +.\"is dangerous, because this creates a race condition between
 +.\"balanced routers and a host they are serving.
 +.\"Imagine an incoming packet creating state on the first router, being
 +.\"forwarded to its destination, and destination replying faster
 +.\"than the state information is packed and synced with the second router.
 +.\"If the reply would be load balanced to second router, it will be
 +.\"dropped due to no state.
  .Sh STATE CHANGE NOTIFICATIONS
  Sometimes it is useful to get notified about
  .Nm
 @@ -175,13 +168,10 @@ status change events.
  This can be accomplished by using
  .Xr devd 8
  hooks.
 -Master/slave events are signalled as
 -.Nm
 -interface
 -.Dv LINK_UP
 -or
 -.Dv LINK_DOWN
 -event.
 +Master/slave events are signalled under system
 +.Dv CARP .
 +Subsystem specifies vhid and name of interface, where event occured.
 +Type of the message displays new state of vhid.
  Please see
  .Xr devd.conf 5
  and 
 @@ -197,23 +187,19 @@ Enable it on both host A and B:
  .Pp
  .Dl sysctl net.inet.carp.preempt=1
  .Pp
 -Assume that host A is the preferred master and 192.168.1.x/24 is
 -configured on one physical interface and 192.168.2.y/24 on another.
 +Assume that host A is the preferred master and we are running the
 +192.168.1.0/24 prefix on em0 and 192.168.2.0/24 on em1.
  This is the setup for host A:
  .Bd -literal -offset indent
 -ifconfig carp0 create
 -ifconfig carp0 vhid 1 pass mekmitasdigoat 192.168.1.1/24
 -ifconfig carp1 create
 -ifconfig carp1 vhid 2 pass mekmitasdigoat 192.168.2.1/24
 +ifconfig em0 vhid 1 pass mekmitasdigoat 192.168.1.1/24
 +ifconfig em1 vhid 2 pass mekmitasdigoat 192.168.2.1/24
  .Ed
  .Pp
  The setup for host B is identical, but it has a higher
  .Cm advskew :
  .Bd -literal -offset indent
 -ifconfig carp0 create
 -ifconfig carp0 vhid 1 advskew 100 pass mekmitasdigoat 192.168.1.1/24
 -ifconfig carp1 create
 -ifconfig carp1 vhid 2 advskew 100 pass mekmitasdigoat 192.168.2.1/24
 +ifconfig em0 vhid 1 advskew 100 pass mekmitasdigoat 192.168.1.1/24
 +ifconfig em1 vhid 2 advskew 100 pass mekmitasdigoat 192.168.2.1/24
  .Ed
  .Pp
  Because of the preempt option, when one of the physical interfaces of
 @@ -224,67 +210,60 @@ is adjusted to 240 on all its
  interfaces.
  This will cause host B to preempt on both interfaces instead of
  just the failed one.
 -.Pp
 -In order to set up an ARP balanced virtual host, it is necessary to configure
 -one virtual host for each physical host which would respond to ARP requests
 -and thus handle the traffic.
 -In the following example, two virtual hosts are configured on two hosts to
 -provide balancing and failover for the IP address 192.168.1.10.
 -.Pp
 -First the
 -.Nm
 -interfaces on host A are configured.
 -The
 -.Cm advskew
 -of 100 on the second virtual host means that its advertisements will be sent
 -out slightly less frequently.
 -.Bd -literal -offset indent
 -ifconfig carp0 create
 -ifconfig carp0 vhid 1 pass mekmitasdigoat 192.168.1.10/24
 -ifconfig carp1 create
 -ifconfig carp1 vhid 2 advskew 100 pass mekmitasdigoat 192.168.1.10/24
 -.Ed
 -.Pp
 -The configuration for host B is identical, except the
 -.Cm advskew
 -is on virtual host 1 rather than virtual host 2.
 -.Bd -literal -offset indent
 -ifconfig carp0 create
 -ifconfig carp0 vhid 1 advskew 100 pass mekmitasdigoat 192.168.1.10/24
 -ifconfig carp1 create
 -ifconfig carp1 vhid 2 pass mekmitasdigoat 192.168.1.10/24
 -.Ed
 -.Pp
 -Finally, the ARP balancing feature must be enabled on both hosts:
 -.Pp
 -.Dl sysctl net.inet.carp.arpbalance=1
 -.Pp
 -When the hosts receive an ARP request for 192.168.1.10, the source IP address
 -of the request is used to compute which virtual host should answer the request.
 -The host which is master of the selected virtual host will reply to the
 -request, the other(s) will ignore it.
 -.Pp
 -This way, locally connected systems will receive different ARP replies and
 -subsequent IP traffic will be balanced among the hosts.
 -If one of the hosts fails, the other will take over the virtual MAC address,
 -and begin answering ARP requests on its behalf.
 +.\".Pp
 +.\"In order to set up an ARP balanced virtual host, it is necessary to configure
 +.\"one virtual host for each physical host which would respond to ARP requests
 +.\"and thus handle the traffic.
 +.\"In the following example, two virtual hosts are configured on two hosts to
 +.\"provide balancing and failover for the IP address 192.168.1.10.
 +.\".Pp
 +.\"First the
 +.\".Nm
 +.\"interfaces on host A are configured.
 +.\"The
 +.\".Cm advskew
 +.\"of 100 on the second virtual host means that its advertisements will be sent
 +.\"out slightly less frequently.
 +.\".Bd -literal -offset indent
 +.\"ifconfig carp0 create
 +.\"ifconfig carp0 vhid 1 pass mekmitasdigoat 192.168.1.10/24
 +.\"ifconfig carp1 create
 +.\"ifconfig carp1 vhid 2 advskew 100 pass mekmitasdigoat 192.168.1.10/24
 +.\".Ed
 +.\".Pp
 +.\"The configuration for host B is identical, except the
 +.\".Cm advskew
 +.\"is on virtual host 1 rather than virtual host 2.
 +.\".Bd -literal -offset indent
 +.\"ifconfig carp0 create
 +.\"ifconfig carp0 vhid 1 advskew 100 pass mekmitasdigoat 192.168.1.10/24
 +.\"ifconfig carp1 create
 +.\"ifconfig carp1 vhid 2 pass mekmitasdigoat 192.168.1.10/24
 +.\".Ed
 +.\".Pp
 +.\"Finally, the ARP balancing feature must be enabled on both hosts:
 +.\".Pp
 +.\".Dl sysctl net.inet.carp.arpbalance=1
 +.\".Pp
 +.\"When the hosts receive an ARP request for 192.168.1.10, the source IP address
 +.\"of the request is used to compute which virtual host should answer the request.
 +.\"The host which is master of the selected virtual host will reply to the
 +.\"request, the other(s) will ignore it.
 +.\".Pp
 +.\"This way, locally connected systems will receive different ARP replies and
 +.\"subsequent IP traffic will be balanced among the hosts.
 +.\"If one of the hosts fails, the other will take over the virtual MAC address,
 +.\"and begin answering ARP requests on its behalf.
  .Pp
  Processing of
  .Nm
 -status change events can be set up by using the following devd.conf rules:
 +status change events can be set up by using the following devd.conf rule:
  .Bd -literal -offset indent
  notify 0 {
 -	match "system"          "IFNET";
 -	match "type"            "LINK_UP";
 -	match "subsystem"       "carp*";
 -	action "/root/carpcontrol.sh $type $subsystem";
 -};
 -
 -notify 0 {
 -	match "system"          "IFNET";
 -	match "type"            "LINK_DOWN";
 -	match "subsystem"       "carp*";
 -	action "/root/carpcontrol.sh $type $subsystem";
 +	match "system"          "CARP";
 +	match "subsystem"       "[0-9]+@";
 +	match "type"            "(MASTER|BACKUP)";
 +	action "/root/carpcontrol.sh $subsystem $type";
  };
  .Ed
  .Sh SEE ALSO
 @@ -303,3 +282,8 @@ The
  .Nm
  device was imported into
  .Fx 5.4 .
 +In
 +.Fx 10
 +the
 +.Nm
 +was significantly rewritten, and is no longer a pseudo-interface.
 
 Modified: head/sys/net/if.c
 ==============================================================================
 --- head/sys/net/if.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/net/if.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -130,17 +130,19 @@ void	(*lagg_linkstate_p)(struct ifnet *i
  /* These are external hooks for CARP. */
  void	(*carp_linkstate_p)(struct ifnet *ifp);
  #if defined(INET) || defined(INET6)
 -struct ifnet *(*carp_forus_p)(struct ifnet *ifp, u_char *dhost);
 +int	(*carp_forus_p)(struct ifnet *ifp, u_char *dhost);
  int	(*carp_output_p)(struct ifnet *ifp, struct mbuf *m,
 -    struct sockaddr *sa, struct rtentry *rt);
 +    struct sockaddr *sa);
 +int	(*carp_ioctl_p)(struct ifreq *, u_long, struct thread *);   
 +int	(*carp_attach_p)(struct ifaddr *, int);
 +void	(*carp_detach_p)(struct ifaddr *);
  #endif
  #ifdef INET
 -int (*carp_iamatch_p)(struct ifnet *, struct in_ifaddr *, struct in_addr *,
 -    u_int8_t **);
 +int	(*carp_iamatch_p)(struct ifaddr *, uint8_t **);
  #endif
  #ifdef INET6
  struct ifaddr *(*carp_iamatch6_p)(struct ifnet *ifp, struct in6_addr *taddr6);
 -caddr_t (*carp_macmatch6_p)(struct ifnet *ifp, struct mbuf *m,
 +caddr_t	(*carp_macmatch6_p)(struct ifnet *ifp, struct mbuf *m,
      const struct in6_addr *taddr);
  #endif
  
 @@ -2506,6 +2508,16 @@ ifioctl(struct socket *so, u_long cmd, c
  		error = if_getgroupmembers((struct ifgroupreq *)data);
  		CURVNET_RESTORE();
  		return (error);
 +#if defined(INET) || defined(INET6)
 +	case SIOCSVH:
 +	case SIOCGVH:
 +		if (carp_ioctl_p == NULL)
 +			error = EPROTONOSUPPORT;
 +		else
 +			error = (*carp_ioctl_p)(ifr, cmd, td);
 +		CURVNET_RESTORE();
 +		return (error);
 +#endif
  	}
  
  	ifp = ifunit_ref(ifr->ifr_name);
 
 Modified: head/sys/net/if.h
 ==============================================================================
 --- head/sys/net/if.h	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/net/if.h	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -85,7 +85,7 @@ struct if_data {
  	u_char	ifi_addrlen;		/* media address length */
  	u_char	ifi_hdrlen;		/* media header length */
  	u_char	ifi_link_state;		/* current link state */
 -	u_char	ifi_spare_char1;	/* spare byte */
 +	u_char	ifi_vhid;		/* carp vhid */
  	u_char	ifi_spare_char2;	/* spare byte */
  	u_char	ifi_datalen;		/* length of this data struct */
  	u_long	ifi_mtu;		/* maximum transmission unit */
 @@ -267,6 +267,8 @@ struct ifa_msghdr {
  	int	ifam_flags;	/* value of ifa_flags */
  	u_short	ifam_index;	/* index for associated ifp */
  	int	ifam_metric;	/* value of ifa_metric */
 +	struct	if_data ifam_data;/* statistics and other data about if or
 +				 * address */
  };
  
  /*
 @@ -357,6 +359,7 @@ struct ifaliasreq {
  	struct	sockaddr ifra_addr;
  	struct	sockaddr ifra_broadaddr;
  	struct	sockaddr ifra_mask;
 +	int	ifra_vhid;
  };
  
  struct ifmediareq {
 
 Modified: head/sys/net/if_ethersubr.c
 ==============================================================================
 --- head/sys/net/if_ethersubr.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/net/if_ethersubr.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -397,7 +397,7 @@ ether_output(struct ifnet *ifp, struct m
  
  #if defined(INET) || defined(INET6)
  	if (ifp->if_carp &&
 -	    (error = (*carp_output_p)(ifp, m, dst, NULL)))
 +	    (error = (*carp_output_p)(ifp, m, dst)))
  		goto bad;
  #endif
  
 
 Modified: head/sys/net/if_types.h
 ==============================================================================
 --- head/sys/net/if_types.h	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/net/if_types.h	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -250,6 +250,5 @@
  #define	IFT_ENC		0xf4
  #define	IFT_PFLOG	0xf6
  #define	IFT_PFSYNC	0xf7
 -#define	IFT_CARP	0xf8	/* Common Address Redundancy Protocol */
  #define IFT_IPXIP	0xf9	/* IPX over IP tunneling; no longer used. */
  #endif /* !_NET_IF_TYPES_H_ */
 
 Modified: head/sys/net/if_var.h
 ==============================================================================
 --- head/sys/net/if_var.h	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/net/if_var.h	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -69,6 +69,7 @@ struct	rt_addrinfo;
  struct	socket;
  struct	ether_header;
  struct	carp_if;
 +struct	carp_softc;
  struct  ifvlantrunk;
  struct	route;
  struct	vnet;
 @@ -729,6 +730,7 @@ struct ifaddr {
  	struct	sockaddr *ifa_netmask;	/* used to determine subnet */
  	struct	if_data if_data;	/* not all members are meaningful */
  	struct	ifnet *ifa_ifp;		/* back-pointer to interface */
 +	struct	carp_softc *ifa_carp;	/* pointer to CARP data */
  	TAILQ_ENTRY(ifaddr) ifa_link;	/* queue macro glue */
  	void	(*ifa_rtrequest)	/* check or clean routes (+ or -)'d */
  		(int, struct rtentry *, struct rt_addrinfo *);
 
 Modified: head/sys/net/rtsock.c
 ==============================================================================
 --- head/sys/net/rtsock.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/net/rtsock.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -63,6 +63,7 @@
  
  #include <netinet/in.h>
  #include <netinet/if_ether.h>
 +#include <netinet/ip_carp.h>
  #ifdef INET6
  #include <netinet6/scope6_var.h>
  #endif
 @@ -83,7 +84,7 @@ struct if_data32 {
  	uint8_t	ifi_addrlen;
  	uint8_t	ifi_hdrlen;
  	uint8_t	ifi_link_state;
 -	uint8_t	ifi_spare_char1;
 +	uint8_t	ifi_vhid;
  	uint8_t	ifi_spare_char2;
  	uint8_t	ifi_datalen;
  	uint32_t ifi_mtu;
 @@ -122,6 +123,9 @@ MALLOC_DEFINE(M_RTABLE, "routetbl", "rou
  static struct	sockaddr route_src = { 2, PF_ROUTE, };
  static struct	sockaddr sa_zero   = { sizeof(sa_zero), AF_INET, };
  
 +/* These are external hooks for CARP. */
 +int	(*carp_get_vhid_p)(struct ifaddr *);
 +
  /*
   * Used by rtsock/raw_input callback code to decide whether to filter the update
   * notification to a socket bound to a particular FIB.
 @@ -1508,6 +1512,7 @@ copy_ifdata32(struct if_data *src, struc
  	CP(*src, *dst, ifi_addrlen);
  	CP(*src, *dst, ifi_hdrlen);
  	CP(*src, *dst, ifi_link_state);
 +	CP(*src, *dst, ifi_vhid);
  	dst->ifi_datalen = sizeof(struct if_data32);
  	CP(*src, *dst, ifi_mtu);
  	CP(*src, *dst, ifi_metric);
 @@ -1559,6 +1564,9 @@ sysctl_iflist(int af, struct walkarg *w)
  				ifm32->ifm_flags = ifp->if_flags |
  				    ifp->if_drv_flags;
  				copy_ifdata32(&ifp->if_data, &ifm32->ifm_data);
 +				if (carp_get_vhid_p != NULL)
 +					ifm32->ifm_data.ifi_vhid =
 +					    (*carp_get_vhid_p)(ifa);
  				ifm32->ifm_addrs = info.rti_addrs;
  				error = SYSCTL_OUT(w->w_req, (caddr_t)ifm32,
  				    len);
 @@ -1569,6 +1577,9 @@ sysctl_iflist(int af, struct walkarg *w)
  			ifm->ifm_index = ifp->if_index;
  			ifm->ifm_flags = ifp->if_flags | ifp->if_drv_flags;
  			ifm->ifm_data = ifp->if_data;
 +			if (carp_get_vhid_p != NULL)
 +				ifm->ifm_data.ifi_vhid =
 +				    (*carp_get_vhid_p)(ifa);
  			ifm->ifm_addrs = info.rti_addrs;
  			error = SYSCTL_OUT(w->w_req, (caddr_t)ifm, len);
  #ifdef COMPAT_FREEBSD32
 @@ -1595,6 +1606,9 @@ sysctl_iflist(int af, struct walkarg *w)
  				ifam->ifam_flags = ifa->ifa_flags;
  				ifam->ifam_metric = ifa->ifa_metric;
  				ifam->ifam_addrs = info.rti_addrs;
 +				if (carp_get_vhid_p != NULL)
 +					ifam->ifam_data.ifi_vhid =
 +					    (*carp_get_vhid_p)(ifa);
  				error = SYSCTL_OUT(w->w_req, w->w_tmem, len);
  				if (error)
  					goto done;
 
 Modified: head/sys/netinet/if_ether.c
 ==============================================================================
 --- head/sys/netinet/if_ether.c	Fri Dec 16 11:52:33 2011	(r228570)
 +++ head/sys/netinet/if_ether.c	Fri Dec 16 12:16:56 2011	(r228571)
 @@ -139,8 +139,6 @@ static const struct netisr_handler arp_n
  };
  
  #ifdef AF_INET
 -void arp_ifscrub(struct ifnet *ifp, uint32_t addr);
 -
  /*
   * called by in_ifscrub to remove entry from the table when
   * the interface goes away
 @@ -516,7 +514,7 @@ in_arpinput(struct mbuf *m)
  	int op, flags;
  	int req_len;
  	int bridged = 0, is_bridge = 0;
 -	int carp_match = 0;
 +	int carped;
  	struct sockaddr_in sin;
  	sin.sin_len = sizeof(struct sockaddr_in);
  	sin.sin_family = AF_INET;
 @@ -561,24 +559,14 @@ in_arpinput(struct mbuf *m)
  	 * For a bridge, we want to check the address irrespective
  	 * of the receive interface. (This will change slightly
  	 * when we have clusters of interfaces).
 -	 * If the interface does not match, but the recieving interface
 -	 * is part of carp, we call carp_iamatch to see if this is a
 -	 * request for the virtual host ip.
 -	 * XXX: This is really ugly!
  	 */
  	IN_IFADDR_RLOCK();
  	LIST_FOREACH(ia, INADDR_HASH(itaddr.s_addr), ia_hash) {
  		if (((bridged && ia->ia_ifp->if_bridge == ifp->if_bridge) ||
  		    ia->ia_ifp == ifp) &&
 -		    itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) {
 -			ifa_ref(&ia->ia_ifa);
 -			IN_IFADDR_RUNLOCK();
 -			goto match;
 -		}
 -		if (ifp->if_carp != NULL &&
 -		    (*carp_iamatch_p)(ifp, ia, &isaddr, &enaddr) &&
 -		    itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) {
 -			carp_match = 1;
 +		    itaddr.s_addr == ia->ia_addr.sin_addr.s_addr &&
 +		    (ia->ia_ifa.ifa_carp == NULL ||
 +		    (*carp_iamatch_p)(&ia->ia_ifa, &enaddr))) {
  			ifa_ref(&ia->ia_ifa);
  			IN_IFADDR_RUNLOCK();
  			goto match;
 @@ -643,6 +631,7 @@ in_arpinput(struct mbuf *m)
  match:
  	if (!enaddr)
  		enaddr = (u_int8_t *)IF_LLADDR(ifp);
 +	carped = (ia->ia_ifa.ifa_carp != NULL);
  	myaddr = ia->ia_addr.sin_addr;
  	ifa_free(&ia->ia_ifa);
  	if (!bcmp(ar_sha(ah), enaddr, ifp->if_addrlen))
 @@ -659,9 +648,9 @@ match:
  	 * case we suppress the warning to avoid false positive complaints of
  	 * potential misconfiguration.
 
 *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
 _______________________________________________
 svn-src-all@freebsd.org mailing list
 http://lists.freebsd.org/mailman/listinfo/svn-src-all
 To unsubscribe, send any mail to "svn-src-all-unsubscribe@freebsd.org"
 
State-Changed-From-To: open->patched 
State-Changed-By: glebius 
State-Changed-When: Fri Dec 16 12:51:27 UTC 2011 
State-Changed-Why:  
No longer applicable to FreeBSD 10. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117000 
State-Changed-From-To: patched->closed 
State-Changed-By: eadler 
State-Changed-When: Fri Mar 15 23:41:57 UTC 2013 
State-Changed-Why:  
MFCed/fixed by now or it will never be MFCed 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117000 
State-Changed-From-To: closed->patched 
State-Changed-By: glebius 
State-Changed-When: Sat Mar 16 07:31:21 UTC 2013 
State-Changed-Why:  
The PR can be closed only after 10.0-RELEASE is out. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117000 
State-Changed-From-To: patched->closed 
State-Changed-By: glebius 
State-Changed-When: Wed Jan 22 09:11:58 UTC 2014 
State-Changed-Why:  
In FreeBSD 10 carp(4) address can be configured on an interface, that 
doesn't have any additional static addresses. 

http://www.freebsd.org/cgi/query-pr.cgi?pr=117000 
>Unformatted:
