From nobody@FreeBSD.org Sun Oct 7 18:58:52 2007 Return-Path: Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id 5A71E16A418 for ; 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 ; 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 ; 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 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: patched >Quarter: >Keywords: >Date-Required: >Class: update >Submitter-Id: current-users >Arrival-Date: Sun Oct 07 19:00:10 GMT 2007 >Closed-Date: >Last-Modified: Fri Dec 16 12:52:03 UTC 2011 >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 To: Scott Brickey 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" To: , "SBrickey.Net - Me" 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

Remko,

 

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.

 

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.

 

This is what was ported to = FBSD…

 

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.

 

This update would be WONDERFUL to have in the FBSD = port.

If further clarification is necessary please feel = free to say so.

 

Thanks,

-Scott

------_=_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 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 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 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 #include -#include #include +#include +#include +#include #include -#include #include #include @@ -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 = ""; + 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 .\" .\" 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 #include +#include #ifdef INET6 #include #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 >Unformatted: