From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.0 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id F2360C004C9 for ; Tue, 7 May 2019 20:14:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A574320675 for ; Tue, 7 May 2019 20:14:15 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=darbyshire-bryant.me.uk header.i=@darbyshire-bryant.me.uk header.b="IOz4eKRT" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727125AbfEGUOO (ORCPT ); Tue, 7 May 2019 16:14:14 -0400 Received: from mail-eopbgr50065.outbound.protection.outlook.com ([40.107.5.65]:23107 "EHLO EUR03-VE1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726225AbfEGUON (ORCPT ); Tue, 7 May 2019 16:14:13 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=darbyshire-bryant.me.uk; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=HhhdADETVi+TLEXzv5uHtvKeNLT8JmpJw3h/ogIk2jw=; b=IOz4eKRTOmuRKXF4aAzShYecVtOEhCugQFg4b8xthLB2IBs6t1eEkPBI6NVpk30yCg0v49W3cVK848QW5wtfphYjO50hT6bQi8yQzXkNLCF8cF9absh1Az/a9mrOiSrHOliexg42msqOjO7cW9UkheLaaJM2/66oGRzhGZsIAdY= Received: from VI1PR0302MB2750.eurprd03.prod.outlook.com (10.171.105.143) by VI1PR0302MB2672.eurprd03.prod.outlook.com (10.171.104.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1856.11; Tue, 7 May 2019 20:12:14 +0000 Received: from VI1PR0302MB2750.eurprd03.prod.outlook.com ([fe80::a096:fef7:568:7358]) by VI1PR0302MB2750.eurprd03.prod.outlook.com ([fe80::a096:fef7:568:7358%7]) with mapi id 15.20.1856.012; Tue, 7 May 2019 20:12:14 +0000 From: Kevin 'ldir' Darbyshire-Bryant To: "davem@davemloft.net" CC: "jhs@mojatatu.com" , "jiri@resnulli.us" , Kevin 'ldir' Darbyshire-Bryant , "linux-kernel@vger.kernel.org" , "linux-kselftest@vger.kernel.org" , "netdev@vger.kernel.org" , "shuah@kernel.org" , "xiyou.wangcong@gmail.com" Subject: [PATCH net-next v4] net: sched: Introduce act_ctinfo action Thread-Topic: [PATCH net-next v4] net: sched: Introduce act_ctinfo action Thread-Index: AQHVBREof9SUD1rIBEGMErsp08m2pA== Date: Tue, 7 May 2019 20:12:13 +0000 Message-ID: <20190507201154.97646-1-ldir@darbyshire-bryant.me.uk> References: <20190507.123952.2046042425594195721.davem@davemloft.net> In-Reply-To: <20190507.123952.2046042425594195721.davem@davemloft.net> Accept-Language: en-GB, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: LO2P265CA0265.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:a1::13) To VI1PR0302MB2750.eurprd03.prod.outlook.com (2603:10a6:800:e2::15) authentication-results: spf=none (sender IP is ) smtp.mailfrom=ldir@darbyshire-bryant.me.uk; x-ms-exchange-messagesentrepresentingtype: 1 x-mailer: git-send-email 2.20.1 (Apple Git-117) x-originating-ip: [2a02:c7f:1268:6500::dc83] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: d0c6c97c-e57e-4f97-a71b-08d6d3284b3e x-microsoft-antispam: BCL:0;PCL:0;RULEID:(2390118)(7020095)(4652040)(7021145)(8989299)(4534185)(7022145)(4603075)(4627221)(201702281549075)(8990200)(7048125)(7024125)(7027125)(7023125)(5600141)(711020)(4605104)(2017052603328)(7193020);SRVR:VI1PR0302MB2672; x-ms-traffictypediagnostic: VI1PR0302MB2672: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:5516; x-forefront-prvs: 0030839EEE x-forefront-antispam-report: SFV:NSPM;SFS:(10009020)(136003)(366004)(346002)(376002)(39830400003)(396003)(199004)(189003)(476003)(36756003)(8676002)(11346002)(71190400001)(5640700003)(2616005)(54906003)(46003)(446003)(81166006)(8936002)(50226002)(6916009)(508600001)(316002)(74482002)(2351001)(186003)(7736002)(256004)(486006)(14454004)(14444005)(99286004)(305945005)(66574012)(52116002)(2501003)(86362001)(6486002)(1076003)(30864003)(71200400001)(73956011)(66946007)(66476007)(66556008)(64756008)(6116002)(66446008)(6436002)(1730700003)(81156014)(102836004)(2906002)(6512007)(25786009)(5660300002)(6506007)(76176011)(68736007)(4326008)(53936002)(386003)(53946003);DIR:OUT;SFP:1101;SCL:1;SRVR:VI1PR0302MB2672;H:VI1PR0302MB2750.eurprd03.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; received-spf: None (protection.outlook.com: darbyshire-bryant.me.uk does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: jwVfwy+MpRNTh0HRkbI4OLZasJCmMy8vJlEQHvcbLpC7FwiNJurM9IdEqnMHIickrp9JnmU4KBcKJ1OlMO2jmc07EnQJFurRFDyJbSlhToASH/MPNEhk8z0bIWDrW8gr4/yjm9o615eOAWypGfdKGzUnh7wxOIDuoxuvy2WcVwkmkE944GQylFJRdKJl7waHLigbwD+0cCtNPa7YteIAvPfbDPtZIe+bY0xNflos613yMYTyzk/VPso3mjWUWLqZ3JV9jf86wmUxxWLUAXBK4GF65HAKN/z0CWOGKJm4DMHSHlfyeNnUC8kz6gt3HCwzCvgGTOQ9FkKkvlVq/xt61Qvo+CdXQnT4/nx+yA89SQM/o1PlVf3PMNYPFWCYZLI15zMoPCj/PU7iJH3/H0COqjEHUohS6zPNOb7+A3+VvnI= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-OriginatorOrg: darbyshire-bryant.me.uk X-MS-Exchange-CrossTenant-Network-Message-Id: d0c6c97c-e57e-4f97-a71b-08d6d3284b3e X-MS-Exchange-CrossTenant-originalarrivaltime: 07 May 2019 20:12:14.1079 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 9151708b-c553-406f-8e56-694f435154a4 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR0302MB2672 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Y3RpbmZvIGlzIGEgbmV3IHRjIGZpbHRlciBhY3Rpb24gbW9kdWxlLiAgSXQgaXMgZGVzaWduZWQg dG8gcmVzdG9yZQ0KaW5mb3JtYXRpb24gY29udGFpbmVkIGluIGNvbm50cmFjayBtYXJrcyB0byBv dGhlciBwbGFjZXMuICBBdCBwcmVzZW50IGl0DQpjYW4gcmVzdG9yZSBEU0NQIHZhbHVlcyB0byBJ UHY0LzYgZGlmZnNlcnYgZmllbGRzIGFuZCBhbHNvIGNvcHkNCmNvbm50cmFjayBtYXJrcyB0byBz a2IgbWFya3MuICBBcyBzdWNoIHRoZSAybmQgZnVuY3Rpb24gZWZmZWN0aXZlbHkNCnJlcGxhY2Vz IHRoZSBleGlzdGluZyBhY3RfY29ubm1hcmsgbW9kdWxlDQoNClRoZSBEU0NQIHJlc3RvcmF0aW9u IGlzIGludGVuZGVkIGZvciB1c2UgYW5kIGhhcyBiZWVuIGZvdW5kIHVzZWZ1bCBmb3INCnJlc3Rv cmluZyBpbmdyZXNzIGNsYXNzaWZpY2F0aW9ucyBiYXNlZCBvbiBlZ3Jlc3MgY2xhc3NpZmljYXRp b25zIGFjcm9zcw0KbGlua3MgdGhhdCBibGVhY2ggb3Igb3RoZXJ3aXNlIGNoYW5nZSBEU0NQLCB0 eXBpY2FsbHkgaG9tZSBJU1AgSW50ZXJuZXQNCmxpbmtzLiAgUmVzdG9yaW5nIERTQ1Agb24gaW5n cmVzcyBvbiB0aGUgV0FOIGxpbmsgYWxsb3dzIHFkaXNjcyBzdWNoIGFzDQpDQUtFIHRvIHNoYXBl IGluYm91bmQgcGFja2V0cyBhY2NvcmRpbmcgdG8gcG9saWNpZXMgdGhhdCBhcmUgZWFzaWVyIHRv DQppbmRpY2F0ZSBvbiBlZ3Jlc3MuDQoNCkluZ3Jlc3MgY2xhc3NpZmljYXRpb24gaXMgdHJhZGl0 aW9uYWxseSBhIGNoYWxsZW5naW5nIHRhc2sgc2luY2UNCmlwdGFibGVzIHJ1bGVzIGhhdmVuJ3Qg eWV0IHJ1biBhbmQgdGMgZmlsdGVyL2VCUEYgcHJvZ3JhbXMgYXJlIHByZS1OQVQNCmxvb2t1cHMs IGhlbmNlIGFyZSB1bmFibGUgdG8gc2VlIGludGVybmFsIElQdjQgYWRkcmVzc2VzIGFzIHVzZWQg b24gdGhlDQp0eXBpY2FsIGhvbWUgbWFzcXVlcmFkaW5nIGdhdGV3YXkuDQoNCmN0aW5mbyB1bmRl cnN0YW5kcyB0aGUgZm9sbG93aW5nIHBhcmFtZXRlcnM6DQoNCmRzY3AgZHNjcG1hc2tbL3N0YXRl bWFza10NCg0KZHNjcG1hc2sgLSBhIDMyIGJpdCBtYXNrIG9mIGF0IGxlYXN0IDYgY29udGlndW91 cyBiaXRzIGFuZCBpbmRpY2F0ZXMNCndoZXJlIGN0aW5mbyB3aWxsIGZpbmQgdGhlIERTQ1AgYml0 cyBzdG9yZWQgaW4gdGhlIGNvbm50cmFjayBtYXJrLg0KDQpzdGF0ZW1hc2sgLSBhIDMyIGJpdCBt YXNrIG9mICh1c3VhbGx5KSAxIGJpdCBsZW5ndGgsIG91dHNpZGUgdGhlIGFyZWENCnNwZWNpZmll ZCBieSBkc2NwbWFzay4gIFRoaXMgcmVwcmVzZW50cyBhIGNvbmRpdGlvbmFsIG9wZXJhdGlvbiBm bGFnDQp3aGVyZWJ5IHRoZSBEU0NQIGlzIG9ubHkgcmVzdG9yZWQgaWYgdGhlIGZsYWcgaXMgc2V0 LiAgVGhpcyBpcyB1c2VmdWwgdG8NCmltcGxlbWVudCBhICdvbmUgc2hvdCcgaXB0YWJsZXMgYmFz ZWQgY2xhc3NpZmljYXRpb24gd2hlcmUgdGhlDQonY29tcGxpY2F0ZWQnIGlwdGFibGVzIHJ1bGVz IGFyZSBvbmx5IHJ1biBvbmNlIHRvIGNsYXNzaWZ5IHRoZQ0KY29ubmVjdGlvbiBvbiBpbml0aWFs IChlZ3Jlc3MpIHBhY2tldCBhbmQgc3Vic2VxdWVudCBwYWNrZXRzIGFyZSBhbGwNCm1hcmtlZC9y ZXN0b3JlZCB3aXRoIHRoZSBzYW1lIERTQ1AuICBBIG1hc2sgb2YgemVybyBkaXNhYmxlcyB0aGUN CmNvbmRpdGlvbmFsIGJlaGF2aW91ciBpZS4gdGhlIGNvbm50cmFjayBtYXJrIERTQ1AgYml0cyBh cmUgYWx3YXlzDQpyZXN0b3JlZCB0byB0aGUgaXAgZGlmZnNlcnYgZmllbGQgKGFzc3VtaW5nIHRo ZSBjb25udHJhY2sgZW50cnkgaXMgZm91bmQNCiYgdGhlIHNrYiBpcyBhbiBpcHY0L2lwdjYgdHlw ZSkNCg0KbWFyayBbbWFza10NCg0KbWFyayAtIGVuYWJsZXMgY29weWluZyB0aGUgY29ubnRyYWNr IGNvbm5tYXJrIHZhbHVlIHRvIHRoZSBza2IgbWFyaw0KDQptYXNrIC0gYSAzMiBiaXQgbWFzayBh cHBsaWVkIHRvIHRoZSBtYXJrIHRvIG1hc2sgb3V0IGJpdCB1bndhbnRlZCBmb3INCnJlc3RvcmF0 aW9uLiAgVGhlIENBS0UgcWRpc2MgZm9yIGV4YW1wbGUgdW5kZXJzdGFuZHMgYm90aCBEU0NQIGFu ZCAndGluJw0KY2xhc3NpZmljYXRpb24gc3RvcmVkIHRoZSBtYXJrLCB0aHVzIGFjdF9jdGluZm8g bWF5IGJlIHVzZWQgdG8gcmVzdG9yZQ0KYm90aCBhc3BlY3RzIG9mIGNsYXNzaWZpY2F0aW9uIGZv ciBDQUtFIGluIG9uZSBhY3Rpb24uICBBIGRlZmF1bHQgbWFzaw0Kb2YgMHhmZmZmZmZmZiBpcyBh cHBsaWVkIGlmIG5vdCBzcGVjaWZpZWQuDQoNCnpvbmUgLSBjb25udHJhY2sgem9uZQ0KDQpjb250 cm9sIC0gYWN0aW9uIHJlbGF0ZWQgY29udHJvbCAocmVjbGFzc2lmeSB8IHBpcGUgfCBkcm9wIHwg Y29udGludWUgfA0Kb2sgfCBnb3RvIGNoYWluIDxDSEFJTl9JTkRFWD4pDQoNCmUuZy4gZHNjcCAw eGZjMDAwMDAwLzB4MDEwMDAwMDANCg0KfC0tLS0weEZDLS0tLWNvbm50cmFjayBtYXJrLS0tLTAw MDAwMC0tLXwNCnwgQml0cyAzMS0yNiB8IGJpdCAyNSB8IGJpdDI0IHx+fn4gQml0IDB8DQp8IERT Q1AgICAgICAgfCB1bnVzZWQgfCBmbGFnICB8dW51c2VkICAgfA0KfC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tMHgwMS0tLTAwMDAwMC0tLXwNCiAgICAgIHwgICAgICAgICAgICAgICAgICAgfA0KICAg ICAgfCAgICAgICAgICAgICAgICAgICB8DQogICAgICAtLS18ICAgICAgICAgICAgIENvbmRpdGlv bmFsIGZsYWcNCiAgICAgICAgIHYgICAgICAgICAgICAgb25seSByZXN0b3JlIGlmIHNldA0KfC1p cCBkaWZmc2Vydi18DQp8IDYgYml0cyAgICAgIHwNCnwtLS0tLS0tLS0tLS0tfA0KDQplLmcuIG1h cmsgMHgwMGZmZmZmZg0KDQp8LS0tLTB4MDAtLS0tY29ubnRyYWNrIG1hcmstLS0tZmZmZmZmLS0t fA0KfCBCaXRzIDMxLTI0IHwgICAgICAgICAgICAgICAgICAgICAgICAgIHwNCnwgRFNDUCAmIGZs YWd8ICAgICAgICAgICAgICAgICAgICAgICAgICB8DQp8LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tfA0KCQkJfA0KCQkJfA0KCQkJdg0KfC0tLS0tLS0tLS0tLXNrYiBtYXJr LS0tLS0tLS0tLS0tLS0tLS0tLXwNCnwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8DQp8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfA0KfC0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLXwNCg0KU2lnbmVkLW9mZi1ieTogS2V2 aW4gRGFyYnlzaGlyZS1CcnlhbnQgPGxkaXJAZGFyYnlzaGlyZS1icnlhbnQubWUudWs+DQotLS0N CnYyIC0gYWRkIGVxdWl2YWxlbnQgY29ubm1hcmsgZnVuY3Rpb25hbGl0eSB3aXRoIGFuIGVuaGFu Y2VtZW50DQogICAgIHRvIGFjY2VwdCBhIG1hc2sNCiAgICAgcGFzcyBzdGF0aXN0aWNzIGZvciBl YWNoIHN1Yi1mdW5jdGlvbiBhcyBpbmRpdmlkdWFsIG5ldGxpbmsNCiAgICAgYXR0cmlidXRlcyBh bmQgc3RvcCAoYWIpdXNpbmcgb3ZlcmxpbWl0cywgZHJvcHMNCiAgICAgdXBkYXRlIHRoZSB0ZXN0 aW5nIGNvbmZpZyBjb3JyZWN0bHkNCnYzIC0gZml4IGEgbGljZW5zaW5nIHNpbGx5ICYgdGlkeSB1 cCBHUEwgYm9pbGVycGxhdGUNCnY0IC0gZHJvcCBzdHJheSBjb3B5IHBhc3RlIGlubGluZQ0KICAg ICByZXZlcnNlIGNocmlzdG1hcyB0cmVlIGxvY2FsIHZhcnMNCg0KIGluY2x1ZGUvbmV0L3RjX2Fj dC90Y19jdGluZm8uaCAgICAgICAgICAgIHwgIDI4ICsrDQogaW5jbHVkZS91YXBpL2xpbnV4L3Br dF9jbHMuaCAgICAgICAgICAgICAgfCAgIDEgKw0KIGluY2x1ZGUvdWFwaS9saW51eC90Y19hY3Qv dGNfY3RpbmZvLmggICAgIHwgIDQzICsrKw0KIG5ldC9zY2hlZC9LY29uZmlnICAgICAgICAgICAg ICAgICAgICAgICAgIHwgIDE3ICsNCiBuZXQvc2NoZWQvTWFrZWZpbGUgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgMSArDQogbmV0L3NjaGVkL2FjdF9jdGluZm8uYyAgICAgICAgICAgICAgICAg ICAgfCA0MDIgKysrKysrKysrKysrKysrKysrKysrKw0KIHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3Rz L3RjLXRlc3RpbmcvY29uZmlnIHwgICAxICsNCiA3IGZpbGVzIGNoYW5nZWQsIDQ5MyBpbnNlcnRp b25zKCspDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbmV0L3RjX2FjdC90Y19jdGluZm8u aA0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3VhcGkvbGludXgvdGNfYWN0L3RjX2N0aW5m by5oDQogY3JlYXRlIG1vZGUgMTAwNjQ0IG5ldC9zY2hlZC9hY3RfY3RpbmZvLmMNCg0KZGlmZiAt LWdpdCBhL2luY2x1ZGUvbmV0L3RjX2FjdC90Y19jdGluZm8uaCBiL2luY2x1ZGUvbmV0L3RjX2Fj dC90Y19jdGluZm8uaA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAwMDAwMC4u ODczMzQxMjBkY2I2DQotLS0gL2Rldi9udWxsDQorKysgYi9pbmNsdWRlL25ldC90Y19hY3QvdGNf Y3RpbmZvLmgNCkBAIC0wLDAgKzEsMjggQEANCisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMCAqLw0KKyNpZm5kZWYgX19ORVRfVENfQ1RJTkZPX0gNCisjZGVmaW5lIF9fTkVUX1RD X0NUSU5GT19IDQorDQorI2luY2x1ZGUgPG5ldC9hY3RfYXBpLmg+DQorDQorc3RydWN0IHRjZl9j dGluZm9fcGFyYW1zIHsNCisJc3RydWN0IG5ldCAqbmV0Ow0KKwl1MzIgZHNjcG1hc2s7DQorCXUz MiBkc2Nwc3RhdGVtYXNrOw0KKwl1MzIgbWFya21hc2s7DQorCXUxNiB6b25lOw0KKwl1OCBtb2Rl Ow0KKwl1OCBkc2NwbWFza3NoaWZ0Ow0KKwlzdHJ1Y3QgcmN1X2hlYWQgcmN1Ow0KK307DQorDQor c3RydWN0IHRjZl9jdGluZm8gew0KKwlzdHJ1Y3QgdGNfYWN0aW9uIGNvbW1vbjsNCisJc3RydWN0 IHRjZl9jdGluZm9fcGFyYW1zIF9fcmN1ICpwYXJhbXM7DQorCXU2NCBzdGF0c19kc2NwX3NldDsN CisJdTY0IHN0YXRzX2RzY3BfZXJyb3I7DQorCXU2NCBzdGF0c19tYXJrX3NldDsNCit9Ow0KKw0K KyNkZWZpbmUgdG9fY3RpbmZvKGEpICgoc3RydWN0IHRjZl9jdGluZm8gKilhKQ0KKw0KKyNlbmRp ZiAvKiBfX05FVF9UQ19DVElORk9fSCAqLw0KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51 eC9wa3RfY2xzLmggYi9pbmNsdWRlL3VhcGkvbGludXgvcGt0X2Nscy5oDQppbmRleCA1MWEwNDk2 Zjc4ZWEuLmE5MzY4MGZjNGJmYSAxMDA2NDQNCi0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9wa3Rf Y2xzLmgNCisrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9wa3RfY2xzLmgNCkBAIC0xMDUsNiArMTA1 LDcgQEAgZW51bSB0Y2FfaWQgew0KIAlUQ0FfSURfSUZFID0gVENBX0FDVF9JRkUsDQogCVRDQV9J RF9TQU1QTEUgPSBUQ0FfQUNUX1NBTVBMRSwNCiAJLyogb3RoZXIgYWN0aW9ucyBnbyBoZXJlICov DQorCVRDQV9JRF9DVElORk8sDQogCV9fVENBX0lEX01BWCA9IDI1NQ0KIH07DQogDQpkaWZmIC0t Z2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3RjX2FjdC90Y19jdGluZm8uaCBiL2luY2x1ZGUvdWFw aS9saW51eC90Y19hY3QvdGNfY3RpbmZvLmgNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAw MDAwMDAwMDAwMDAuLjhkMjU0YjgyMTUxYw0KLS0tIC9kZXYvbnVsbA0KKysrIGIvaW5jbHVkZS91 YXBpL2xpbnV4L3RjX2FjdC90Y19jdGluZm8uaA0KQEAgLTAsMCArMSw0MyBAQA0KKy8qIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIFdJVEggTGludXgtc3lzY2FsbC1ub3RlICovDQor I2lmbmRlZiBfX1VBUElfVENfQ1RJTkZPX0gNCisjZGVmaW5lIF9fVUFQSV9UQ19DVElORk9fSA0K Kw0KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPg0KKyNpbmNsdWRlIDxsaW51eC9wa3RfY2xzLmg+ DQorDQorc3RydWN0IHRjX2N0aW5mbyB7DQorCXRjX2dlbjsNCit9Ow0KKw0KK3N0cnVjdCB0Y19j dGluZm9fZHNjcCB7DQorCV9fdTMyIG1hc2s7DQorCV9fdTMyIHN0YXRlbWFzazsNCit9Ow0KKw0K K3N0cnVjdCB0Y19jdGluZm9fc3RhdHNfZHNjcCB7DQorCV9fdTY0IHNldDsNCisJX191NjQgZXJy b3I7DQorfTsNCisNCitlbnVtIHsNCisJVENBX0NUSU5GT19VTlNQRUMsDQorCVRDQV9DVElORk9f QUNULA0KKwlUQ0FfQ1RJTkZPX1pPTkUsDQorCVRDQV9DVElORk9fRFNDUF9QQVJNUywNCisJVENB X0NUSU5GT19NQVJLX01BU0ssDQorCVRDQV9DVElORk9fTU9ERV9EU0NQLA0KKwlUQ0FfQ1RJTkZP X01PREVfTUFSSywNCisJVENBX0NUSU5GT19TVEFUU19EU0NQLA0KKwlUQ0FfQ1RJTkZPX1NUQVRT X01BUkssDQorCVRDQV9DVElORk9fVE0sDQorCVRDQV9DVElORk9fUEFELA0KKwlfX1RDQV9DVElO Rk9fTUFYDQorfTsNCisjZGVmaW5lIFRDQV9DVElORk9fTUFYIChfX1RDQV9DVElORk9fTUFYIC0g MSkNCisNCitlbnVtIHsNCisJQ1RJTkZPX01PREVfU0VURFNDUAk9IEJJVCgwKSwNCisJQ1RJTkZP X01PREVfU0VUTUFSSwk9IEJJVCgxKQ0KK307DQorDQorI2VuZGlmDQpkaWZmIC0tZ2l0IGEvbmV0 L3NjaGVkL0tjb25maWcgYi9uZXQvc2NoZWQvS2NvbmZpZw0KaW5kZXggNWMwMmFkOTdlZjIzLi5m NTc3M2VmZmNmZGMgMTAwNjQ0DQotLS0gYS9uZXQvc2NoZWQvS2NvbmZpZw0KKysrIGIvbmV0L3Nj aGVkL0tjb25maWcNCkBAIC04NzYsNiArODc2LDIzIEBAIGNvbmZpZyBORVRfQUNUX0NPTk5NQVJL DQogCSAgVG8gY29tcGlsZSB0aGlzIGNvZGUgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRo ZQ0KIAkgIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCBhY3RfY29ubm1hcmsuDQogDQorY29uZmlnIE5F VF9BQ1RfQ1RJTkZPDQorICAgICAgICB0cmlzdGF0ZSAiTmV0ZmlsdGVyIENvbm5lY3Rpb24gTWFy ayBBY3Rpb25zIg0KKyAgICAgICAgZGVwZW5kcyBvbiBORVRfQ0xTX0FDVCAmJiBORVRGSUxURVIg JiYgSVBfTkZfSVBUQUJMRVMNCisgICAgICAgIGRlcGVuZHMgb24gTkZfQ09OTlRSQUNLICYmIE5G X0NPTk5UUkFDS19NQVJLDQorICAgICAgICBoZWxwDQorCSAgU2F5IFkgaGVyZSB0byBhbGxvdyB0 cmFuc2ZlciBvZiBhIGNvbm5tYXJrIHN0b3JlZCBpbmZvcm1hdGlvbi4NCisJICBDdXJyZW50IGFj dGlvbnMgdHJhbnNmZXIgY29ubm1hcmsgc3RvcmVkIERTQ1AgaW50bw0KKwkgIGlwdjQvdjYgZGlm ZnNlcnYgYW5kL29yIHRvIHRyYW5zZmVyIGNvbm5tYXJrIHRvIHBhY2tldA0KKwkgIG1hcmsuICBC b3RoIGFyZSB1c2VmdWwgZm9yIHJlc3RvcmluZyBlZ3Jlc3MgYmFzZWQgbWFya3MNCisJICBiYWNr IG9udG8gaW5ncmVzcyBjb25uZWN0aW9ucyBmb3IgcWRpc2MgcHJpb3JpdHkgbWFwcGluZw0KKwkg IHB1cnBvc2VzLg0KKw0KKwkgIElmIHVuc3VyZSwgc2F5IE4uDQorDQorCSAgVG8gY29tcGlsZSB0 aGlzIGNvZGUgYXMgYSBtb2R1bGUsIGNob29zZSBNIGhlcmU6IHRoZQ0KKwkgIG1vZHVsZSB3aWxs IGJlIGNhbGxlZCBhY3RfY3RpbmZvLg0KKw0KIGNvbmZpZyBORVRfQUNUX1NLQk1PRA0KICAgICAg ICAgdHJpc3RhdGUgInNrYiBkYXRhIG1vZGlmaWNhdGlvbiBhY3Rpb24iDQogICAgICAgICBkZXBl bmRzIG9uIE5FVF9DTFNfQUNUDQpkaWZmIC0tZ2l0IGEvbmV0L3NjaGVkL01ha2VmaWxlIGIvbmV0 L3NjaGVkL01ha2VmaWxlDQppbmRleCA4YTQwNDMxZDdiNWMuLmQ1NGJmY2JkNzk4MSAxMDA2NDQN Ci0tLSBhL25ldC9zY2hlZC9NYWtlZmlsZQ0KKysrIGIvbmV0L3NjaGVkL01ha2VmaWxlDQpAQCAt MjEsNiArMjEsNyBAQCBvYmotJChDT05GSUdfTkVUX0FDVF9DU1VNKQkrPSBhY3RfY3N1bS5vDQog b2JqLSQoQ09ORklHX05FVF9BQ1RfVkxBTikJKz0gYWN0X3ZsYW4ubw0KIG9iai0kKENPTkZJR19O RVRfQUNUX0JQRikJKz0gYWN0X2JwZi5vDQogb2JqLSQoQ09ORklHX05FVF9BQ1RfQ09OTk1BUksp CSs9IGFjdF9jb25ubWFyay5vDQorb2JqLSQoQ09ORklHX05FVF9BQ1RfQ1RJTkZPKQkrPSBhY3Rf Y3RpbmZvLm8NCiBvYmotJChDT05GSUdfTkVUX0FDVF9TS0JNT0QpCSs9IGFjdF9za2Jtb2Qubw0K IG9iai0kKENPTkZJR19ORVRfQUNUX0lGRSkJKz0gYWN0X2lmZS5vDQogb2JqLSQoQ09ORklHX05F VF9JRkVfU0tCTUFSSykJKz0gYWN0X21ldGFfbWFyay5vDQpkaWZmIC0tZ2l0IGEvbmV0L3NjaGVk L2FjdF9jdGluZm8uYyBiL25ldC9zY2hlZC9hY3RfY3RpbmZvLmMNCm5ldyBmaWxlIG1vZGUgMTAw NjQ0DQppbmRleCAwMDAwMDAwMDAwMDAuLjkzZjk4ZDYyYTk2Mg0KLS0tIC9kZXYvbnVsbA0KKysr IGIvbmV0L3NjaGVkL2FjdF9jdGluZm8uYw0KQEAgLTAsMCArMSw0MDIgQEANCisvLyBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsNCisvKiBuZXQvc2NoZWQvYWN0X2N0aW5mby5jICBu ZXRmaWx0ZXIgY3RpbmZvIGNvbm5tYXJrIGFjdGlvbnMNCisgKg0KKyAqIENvcHlyaWdodCAoYykg MjAxOSBLZXZpbiBEYXJieXNoaXJlLUJyeWFudCA8bGRpckBkYXJieXNoaXJlLWJyeWFudC5tZS51 az4NCisgKi8NCisNCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4 L2luaXQuaD4NCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+DQorI2luY2x1ZGUgPGxpbnV4L3Nr YnVmZi5oPg0KKyNpbmNsdWRlIDxsaW51eC9ydG5ldGxpbmsuaD4NCisjaW5jbHVkZSA8bGludXgv cGt0X2Nscy5oPg0KKyNpbmNsdWRlIDxsaW51eC9pcC5oPg0KKyNpbmNsdWRlIDxsaW51eC9pcHY2 Lmg+DQorI2luY2x1ZGUgPG5ldC9uZXRsaW5rLmg+DQorI2luY2x1ZGUgPG5ldC9wa3Rfc2NoZWQu aD4NCisjaW5jbHVkZSA8bmV0L2FjdF9hcGkuaD4NCisjaW5jbHVkZSA8bmV0L3BrdF9jbHMuaD4N CisjaW5jbHVkZSA8dWFwaS9saW51eC90Y19hY3QvdGNfY3RpbmZvLmg+DQorI2luY2x1ZGUgPG5l dC90Y19hY3QvdGNfY3RpbmZvLmg+DQorDQorI2luY2x1ZGUgPG5ldC9uZXRmaWx0ZXIvbmZfY29u bnRyYWNrLmg+DQorI2luY2x1ZGUgPG5ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2NvcmUuaD4N CisjaW5jbHVkZSA8bmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfZWNhY2hlLmg+DQorI2luY2x1 ZGUgPG5ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX3pvbmVzLmg+DQorDQorc3RhdGljIHVuc2ln bmVkIGludCBjdGluZm9fbmV0X2lkOw0KK3N0YXRpYyBzdHJ1Y3QgdGNfYWN0aW9uX29wcyBhY3Rf Y3RpbmZvX29wczsNCisNCitzdGF0aWMgdm9pZCB0Y2ZfY3RpbmZvX2RzY3Bfc2V0KHN0cnVjdCBu Zl9jb25uICpjdCwgc3RydWN0IHRjZl9jdGluZm8gKmNhLA0KKwkJCQlzdHJ1Y3QgdGNmX2N0aW5m b19wYXJhbXMgKmNwLA0KKwkJCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBpbnQgd2xlbiwgaW50IHBy b3RvKQ0KK3sNCisJdTggZHNjcCwgbmV3ZHNjcDsNCisNCisJbmV3ZHNjcCA9ICgoKGN0LT5tYXJr ICYgY3AtPmRzY3BtYXNrKSA+PiBjcC0+ZHNjcG1hc2tzaGlmdCkgPDwgMikgJg0KKwkJICAgICB+ SU5FVF9FQ05fTUFTSzsNCisNCisJc3dpdGNoIChwcm90bykgew0KKwljYXNlIE5GUFJPVE9fSVBW NDoNCisJCWRzY3AgPSBpcHY0X2dldF9kc2ZpZWxkKGlwX2hkcihza2IpKSAmIH5JTkVUX0VDTl9N QVNLOw0KKwkJaWYgKGRzY3AgIT0gbmV3ZHNjcCkgew0KKwkJCWlmIChsaWtlbHkoIXNrYl90cnlf bWFrZV93cml0YWJsZShza2IsIHdsZW4pKSkgew0KKwkJCQlpcHY0X2NoYW5nZV9kc2ZpZWxkKGlw X2hkcihza2IpLA0KKwkJCQkJCSAgICBJTkVUX0VDTl9NQVNLLA0KKwkJCQkJCSAgICBuZXdkc2Nw KTsNCisJCQkJY2EtPnN0YXRzX2RzY3Bfc2V0Kys7DQorCQkJfSBlbHNlIHsNCisJCQkJY2EtPnN0 YXRzX2RzY3BfZXJyb3IrKzsNCisJCQl9DQorCQl9DQorCQlicmVhazsNCisJY2FzZSBORlBST1RP X0lQVjY6DQorCQlkc2NwID0gaXB2Nl9nZXRfZHNmaWVsZChpcHY2X2hkcihza2IpKSAmIH5JTkVU X0VDTl9NQVNLOw0KKwkJaWYgKGRzY3AgIT0gbmV3ZHNjcCkgew0KKwkJCWlmIChsaWtlbHkoIXNr Yl90cnlfbWFrZV93cml0YWJsZShza2IsIHdsZW4pKSkgew0KKwkJCQlpcHY2X2NoYW5nZV9kc2Zp ZWxkKGlwdjZfaGRyKHNrYiksDQorCQkJCQkJICAgIElORVRfRUNOX01BU0ssDQorCQkJCQkJICAg IG5ld2RzY3ApOw0KKwkJCQljYS0+c3RhdHNfZHNjcF9zZXQrKzsNCisJCQl9IGVsc2Ugew0KKwkJ CQljYS0+c3RhdHNfZHNjcF9lcnJvcisrOw0KKwkJCX0NCisJCX0NCisJCWJyZWFrOw0KKwlkZWZh dWx0Og0KKwkJYnJlYWs7DQorCX0NCit9DQorDQorc3RhdGljIHZvaWQgdGNmX2N0aW5mb19tYXJr X3NldChzdHJ1Y3QgbmZfY29ubiAqY3QsIHN0cnVjdCB0Y2ZfY3RpbmZvICpjYSwNCisJCQkJc3Ry dWN0IHRjZl9jdGluZm9fcGFyYW1zICpjcCwNCisJCQkJc3RydWN0IHNrX2J1ZmYgKnNrYikNCit7 DQorCWNhLT5zdGF0c19tYXJrX3NldCsrOw0KKwlza2ItPm1hcmsgPSBjdC0+bWFyayAmIGNwLT5t YXJrbWFzazsNCit9DQorDQorc3RhdGljIGludCB0Y2ZfY3RpbmZvX2FjdChzdHJ1Y3Qgc2tfYnVm ZiAqc2tiLCBjb25zdCBzdHJ1Y3QgdGNfYWN0aW9uICphLA0KKwkJCSAgc3RydWN0IHRjZl9yZXN1 bHQgKnJlcykNCit7DQorCWNvbnN0IHN0cnVjdCBuZl9jb25udHJhY2tfdHVwbGVfaGFzaCAqdGhh c2ggPSBOVUxMOw0KKwlzdHJ1Y3QgdGNmX2N0aW5mbyAqY2EgPSB0b19jdGluZm8oYSk7DQorCXN0 cnVjdCBuZl9jb25udHJhY2tfdHVwbGUgdHVwbGU7DQorCXN0cnVjdCBuZl9jb25udHJhY2tfem9u ZSB6b25lOw0KKwllbnVtIGlwX2Nvbm50cmFja19pbmZvIGN0aW5mbzsNCisJc3RydWN0IHRjZl9j dGluZm9fcGFyYW1zICpjcDsNCisJc3RydWN0IG5mX2Nvbm4gKmN0Ow0KKwlpbnQgcHJvdG8sIHds ZW47DQorCWludCBhY3Rpb247DQorDQorCWNwID0gcmN1X2RlcmVmZXJlbmNlX2JoKGNhLT5wYXJh bXMpOw0KKw0KKwl0Y2ZfbGFzdHVzZV91cGRhdGUoJmNhLT50Y2ZfdG0pOw0KKwlic3RhdHNfdXBk YXRlKCZjYS0+dGNmX2JzdGF0cywgc2tiKTsNCisJYWN0aW9uID0gUkVBRF9PTkNFKGNhLT50Y2Zf YWN0aW9uKTsNCisNCisJd2xlbiA9IHNrYl9uZXR3b3JrX29mZnNldChza2IpOw0KKwlpZiAodGNf c2tiX3Byb3RvY29sKHNrYikgPT0gaHRvbnMoRVRIX1BfSVApKSB7DQorCQl3bGVuICs9IHNpemVv ZihzdHJ1Y3QgaXBoZHIpOw0KKwkJaWYgKCFwc2tiX21heV9wdWxsKHNrYiwgd2xlbikpDQorCQkJ Z290byBvdXQ7DQorDQorCQlwcm90byA9IE5GUFJPVE9fSVBWNDsNCisJfSBlbHNlIGlmICh0Y19z a2JfcHJvdG9jb2woc2tiKSA9PSBodG9ucyhFVEhfUF9JUFY2KSkgew0KKwkJd2xlbiArPSBzaXpl b2Yoc3RydWN0IGlwdjZoZHIpOw0KKwkJaWYgKCFwc2tiX21heV9wdWxsKHNrYiwgd2xlbikpDQor CQkJZ290byBvdXQ7DQorDQorCQlwcm90byA9IE5GUFJPVE9fSVBWNjsNCisJfSBlbHNlIHsNCisJ CWdvdG8gb3V0Ow0KKwl9DQorDQorCWN0ID0gbmZfY3RfZ2V0KHNrYiwgJmN0aW5mbyk7DQorCWlm ICghY3QpIHsgLyogbG9vayBoYXJkZXIsIHVzdWFsbHkgaW5ncmVzcyAqLw0KKwkJaWYgKCFuZl9j dF9nZXRfdHVwbGVwcihza2IsIHNrYl9uZXR3b3JrX29mZnNldChza2IpLA0KKwkJCQkgICAgICAg cHJvdG8sIGNwLT5uZXQsICZ0dXBsZSkpDQorCQkJZ290byBvdXQ7DQorCQl6b25lLmlkID0gY3At PnpvbmU7DQorCQl6b25lLmRpciA9IE5GX0NUX0RFRkFVTFRfWk9ORV9ESVI7DQorDQorCQl0aGFz aCA9IG5mX2Nvbm50cmFja19maW5kX2dldChjcC0+bmV0LCAmem9uZSwgJnR1cGxlKTsNCisJCWlm ICghdGhhc2gpDQorCQkJZ290byBvdXQ7DQorDQorCQljdCA9IG5mX2N0X3R1cGxlaGFzaF90b19j dHJhY2sodGhhc2gpOw0KKwl9DQorDQorCWlmIChjcC0+bW9kZSAmIENUSU5GT19NT0RFX1NFVERT Q1ApDQorCQlpZiAoIWNwLT5kc2Nwc3RhdGVtYXNrIHx8IChjdC0+bWFyayAmIGNwLT5kc2Nwc3Rh dGVtYXNrKSkNCisJCQl0Y2ZfY3RpbmZvX2RzY3Bfc2V0KGN0LCBjYSwgY3AsIHNrYiwgd2xlbiwg cHJvdG8pOw0KKw0KKwlpZiAoY3AtPm1vZGUgJiBDVElORk9fTU9ERV9TRVRNQVJLKQ0KKwkJdGNm X2N0aW5mb19tYXJrX3NldChjdCwgY2EsIGNwLCBza2IpOw0KKw0KKwlpZiAodGhhc2gpDQorCQlu Zl9jdF9wdXQoY3QpOw0KK291dDoNCisJcmV0dXJuIGFjdGlvbjsNCit9DQorDQorc3RhdGljIGNv bnN0IHN0cnVjdCBubGFfcG9saWN5IGN0aW5mb19wb2xpY3lbVENBX0NUSU5GT19NQVggKyAxXSA9 IHsNCisJW1RDQV9DVElORk9fQUNUXSA9IHsgLmxlbiA9IHNpemVvZihzdHJ1Y3QgdGNfY3RpbmZv KSB9LA0KKwlbVENBX0NUSU5GT19aT05FXSA9IHsgLnR5cGUgPSBOTEFfVTE2IH0sDQorCVtUQ0Ff Q1RJTkZPX01PREVfRFNDUF0gPSB7IC50eXBlID0gTkxBX0ZMQUcgfSwNCisJW1RDQV9DVElORk9f TU9ERV9NQVJLXSA9IHsgLnR5cGUgPSBOTEFfRkxBRyB9LA0KKwlbVENBX0NUSU5GT19EU0NQX1BB Uk1TXSA9IHsgLmxlbiA9IHNpemVvZihzdHJ1Y3QgdGNfY3RpbmZvX2RzY3ApIH0sDQorfTsNCisN CitzdGF0aWMgaW50IHRjZl9jdGluZm9faW5pdChzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCBubGF0 dHIgKm5sYSwNCisJCQkgICBzdHJ1Y3QgbmxhdHRyICplc3QsIHN0cnVjdCB0Y19hY3Rpb24gKiph LA0KKwkJCSAgIGludCBvdnIsIGludCBiaW5kLCBib29sIHJ0bmxfaGVsZCwNCisJCQkgICBzdHJ1 Y3QgdGNmX3Byb3RvICp0cCwNCisJCQkgICBzdHJ1Y3QgbmV0bGlua19leHRfYWNrICpleHRhY2sp DQorew0KKwlzdHJ1Y3QgdGNfYWN0aW9uX25ldCAqdG4gPSBuZXRfZ2VuZXJpYyhuZXQsIGN0aW5m b19uZXRfaWQpOw0KKwlzdHJ1Y3QgbmxhdHRyICp0YltUQ0FfQ1RJTkZPX01BWCArIDFdOw0KKwlz dHJ1Y3QgdGNmX2N0aW5mb19wYXJhbXMgKmNwX25ldzsNCisJc3RydWN0IHRjZl9jaGFpbiAqZ290 b19jaCA9IE5VTEw7DQorCXN0cnVjdCB0Y19jdGluZm9fZHNjcCAqZHNjcHBhcm07DQorCXN0cnVj dCB0Y2ZfY3RpbmZvICpjaTsNCisJc3RydWN0IHRjX2N0aW5mbyAqYWN0cGFybTsNCisJaW50IHJl dCA9IDAsIGVyciwgaTsNCisNCisJaWYgKCFubGEpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJ ZXJyID0gbmxhX3BhcnNlX25lc3RlZCh0YiwgVENBX0NUSU5GT19NQVgsIG5sYSwgY3RpbmZvX3Bv bGljeSwgTlVMTCk7DQorCWlmIChlcnIgPCAwKQ0KKwkJcmV0dXJuIGVycjsNCisNCisJaWYgKCF0 YltUQ0FfQ1RJTkZPX0FDVF0pDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJaWYgKHRiW1RDQV9D VElORk9fTU9ERV9EU0NQXSAmJiAhdGJbVENBX0NUSU5GT19EU0NQX1BBUk1TXSkNCisJCXJldHVy biAtRUlOVkFMOw0KKw0KKwlhY3RwYXJtID0gbmxhX2RhdGEodGJbVENBX0NUSU5GT19BQ1RdKTsN CisJZHNjcHBhcm0gPSBubGFfZGF0YSh0YltUQ0FfQ1RJTkZPX0RTQ1BfUEFSTVNdKTsNCisNCisJ aWYgKGRzY3BwYXJtKSB7DQorCQkvKiBuZWVkIGF0IGxlYXN0IGNvbnRpZ3VvdXMgNiBiaXQgbWFz ayAqLw0KKwkJaSA9IGRzY3BwYXJtLT5tYXNrID8gX19mZnMoZHNjcHBhcm0tPm1hc2spIDogMDsN CisJCWlmICgoMHgzZiAmIChkc2NwcGFybS0+bWFzayA+PiBpKSkgIT0gMHgzZikNCisJCQlyZXR1 cm4gLUVJTlZBTDsNCisJCS8qIG1hc2sgJiBzdGF0ZW1hc2sgbXVzdCBub3Qgb3ZlcmxhcCAqLw0K KwkJaWYgKGRzY3BwYXJtLT5tYXNrICYgZHNjcHBhcm0tPnN0YXRlbWFzaykNCisJCQlyZXR1cm4g LUVJTlZBTDsNCisJfQ0KKw0KKwkvKiBkb25lIHRoZSB2YWxpZGF0aW9uOm5vdyB0byB0aGUgYWN0 dWFsIGFjdGlvbiBhbGxvY2F0aW9uICovDQorCWVyciA9IHRjZl9pZHJfY2hlY2tfYWxsb2ModG4s ICZhY3RwYXJtLT5pbmRleCwgYSwgYmluZCk7DQorCWlmICghZXJyKSB7DQorCQlyZXQgPSB0Y2Zf aWRyX2NyZWF0ZSh0biwgYWN0cGFybS0+aW5kZXgsIGVzdCwgYSwNCisJCQkJICAgICAmYWN0X2N0 aW5mb19vcHMsIGJpbmQsIGZhbHNlKTsNCisJCWlmIChyZXQpIHsNCisJCQl0Y2ZfaWRyX2NsZWFu dXAodG4sIGFjdHBhcm0tPmluZGV4KTsNCisJCQlyZXR1cm4gcmV0Ow0KKwkJfQ0KKwl9IGVsc2Ug aWYgKGVyciA+IDApIHsNCisJCWlmIChiaW5kKSAvKiBkb24ndCBvdmVycmlkZSBkZWZhdWx0cyAq Lw0KKwkJCXJldHVybiAwOw0KKwkJaWYgKCFvdnIpIHsNCisJCQl0Y2ZfaWRyX3JlbGVhc2UoKmEs IGJpbmQpOw0KKwkJCXJldHVybiAtRUVYSVNUOw0KKwkJfQ0KKwl9IGVsc2Ugew0KKwkJcmV0dXJu IGVycjsNCisJfQ0KKw0KKwllcnIgPSB0Y2ZfYWN0aW9uX2NoZWNrX2N0cmxhY3QoYWN0cGFybS0+ YWN0aW9uLCB0cCwgJmdvdG9fY2gsIGV4dGFjayk7DQorCWlmIChlcnIgPCAwKQ0KKwkJZ290byBy ZWxlYXNlX2lkcjsNCisNCisJY2kgPSB0b19jdGluZm8oKmEpOw0KKw0KKwljcF9uZXcgPSBremFs bG9jKHNpemVvZigqY3BfbmV3KSwgR0ZQX0tFUk5FTCk7DQorCWlmICh1bmxpa2VseSghY3BfbmV3 KSkgew0KKwkJZXJyID0gLUVOT01FTTsNCisJCWdvdG8gcHV0X2NoYWluOw0KKwl9DQorDQorCWNw X25ldy0+bmV0ID0gbmV0Ow0KKwljcF9uZXctPnpvbmUgPSB0YltUQ0FfQ1RJTkZPX1pPTkVdID8N CisJCQlubGFfZ2V0X3UxNih0YltUQ0FfQ1RJTkZPX1pPTkVdKSA6IDA7DQorCWlmIChkc2NwcGFy bSkgew0KKwkJY3BfbmV3LT5kc2NwbWFzayA9IGRzY3BwYXJtLT5tYXNrOw0KKwkJY3BfbmV3LT5k c2NwbWFza3NoaWZ0ID0gY3BfbmV3LT5kc2NwbWFzayA/DQorCQkJCV9fZmZzKGNwX25ldy0+ZHNj cG1hc2spIDogMDsNCisJCWNwX25ldy0+ZHNjcHN0YXRlbWFzayA9IGRzY3BwYXJtLT5zdGF0ZW1h c2s7DQorCX0NCisJY3BfbmV3LT5tYXJrbWFzayA9IHRiW1RDQV9DVElORk9fTUFSS19NQVNLXSA/ DQorCQkJbmxhX2dldF91MzIodGJbVENBX0NUSU5GT19NQVJLX01BU0tdKSA6IH4wOw0KKw0KKwlp ZiAodGJbVENBX0NUSU5GT19NT0RFX0RTQ1BdKQ0KKwkJY3BfbmV3LT5tb2RlIHw9IENUSU5GT19N T0RFX1NFVERTQ1A7DQorCWVsc2UNCisJCWNwX25ldy0+bW9kZSAmPSB+Q1RJTkZPX01PREVfU0VU RFNDUDsNCisNCisJaWYgKHRiW1RDQV9DVElORk9fTU9ERV9NQVJLXSkNCisJCWNwX25ldy0+bW9k ZSB8PSBDVElORk9fTU9ERV9TRVRNQVJLOw0KKwllbHNlDQorCQljcF9uZXctPm1vZGUgJj0gfkNU SU5GT19NT0RFX1NFVE1BUks7DQorDQorCXNwaW5fbG9ja19iaCgmY2ktPnRjZl9sb2NrKTsNCisJ Z290b19jaCA9IHRjZl9hY3Rpb25fc2V0X2N0cmxhY3QoKmEsIGFjdHBhcm0tPmFjdGlvbiwgZ290 b19jaCk7DQorCXJjdV9zd2FwX3Byb3RlY3RlZChjaS0+cGFyYW1zLCBjcF9uZXcsDQorCQkJICAg bG9ja2RlcF9pc19oZWxkKCZjaS0+dGNmX2xvY2spKTsNCisJc3Bpbl91bmxvY2tfYmgoJmNpLT50 Y2ZfbG9jayk7DQorDQorCWlmIChnb3RvX2NoKQ0KKwkJdGNmX2NoYWluX3B1dF9ieV9hY3QoZ290 b19jaCk7DQorCWlmIChjcF9uZXcpDQorCQlrZnJlZV9yY3UoY3BfbmV3LCByY3UpOw0KKw0KKwlp ZiAocmV0ID09IEFDVF9QX0NSRUFURUQpDQorCQl0Y2ZfaWRyX2luc2VydCh0biwgKmEpOw0KKw0K KwlyZXR1cm4gcmV0Ow0KKw0KK3B1dF9jaGFpbjoNCisJaWYgKGdvdG9fY2gpDQorCQl0Y2ZfY2hh aW5fcHV0X2J5X2FjdChnb3RvX2NoKTsNCityZWxlYXNlX2lkcjoNCisJdGNmX2lkcl9yZWxlYXNl KCphLCBiaW5kKTsNCisJcmV0dXJuIGVycjsNCit9DQorDQorc3RhdGljIGludCB0Y2ZfY3RpbmZv X2R1bXAoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IHRjX2FjdGlvbiAqYSwNCisJCQkgICBp bnQgYmluZCwgaW50IHJlZikNCit7DQorCXN0cnVjdCB0Y2ZfY3RpbmZvICpjaSA9IHRvX2N0aW5m byhhKTsNCisJc3RydWN0IHRjX2N0aW5mbyBvcHQgPSB7DQorCQkucmVmY250ICA9IHJlZmNvdW50 X3JlYWQoJmNpLT50Y2ZfcmVmY250KSAtIHJlZiwNCisJCS5iaW5kY250ID0gYXRvbWljX3JlYWQo JmNpLT50Y2ZfYmluZGNudCkgLSBiaW5kLA0KKwkJLmluZGV4ICAgPSBjaS0+dGNmX2luZGV4LA0K Kwl9Ow0KKwl1bnNpZ25lZCBjaGFyICpiID0gc2tiX3RhaWxfcG9pbnRlcihza2IpOw0KKwlzdHJ1 Y3QgdGNfY3RpbmZvX3N0YXRzX2RzY3AgZHNjcHN0YXRzOw0KKwlzdHJ1Y3QgdGNfY3RpbmZvX2Rz Y3AgZHNjcHBhcm07DQorCXN0cnVjdCB0Y2ZfY3RpbmZvX3BhcmFtcyAqY3A7DQorCXN0cnVjdCB0 Y2ZfdCB0Ow0KKw0KKwlzcGluX2xvY2tfYmgoJmNpLT50Y2ZfbG9jayk7DQorCWNwID0gcmN1X2Rl cmVmZXJlbmNlX3Byb3RlY3RlZChjaS0+cGFyYW1zLA0KKwkJCQkgICAgICAgbG9ja2RlcF9pc19o ZWxkKCZjaS0+dGNmX2xvY2spKTsNCisJb3B0LmFjdGlvbiA9IGNpLT50Y2ZfYWN0aW9uOw0KKw0K KwlpZiAobmxhX3B1dChza2IsIFRDQV9DVElORk9fQUNULCBzaXplb2Yob3B0KSwgJm9wdCkpDQor CQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsNCisNCisJaWYgKGNwLT5tb2RlICYgQ1RJTkZPX01PREVf U0VURFNDUCkgew0KKwkJZHNjcHBhcm0ubWFzayA9IGNwLT5kc2NwbWFzazsNCisJCWRzY3BwYXJt LnN0YXRlbWFzayA9IGNwLT5kc2Nwc3RhdGVtYXNrOw0KKwkJaWYgKG5sYV9wdXQoc2tiLCBUQ0Ff Q1RJTkZPX0RTQ1BfUEFSTVMsIHNpemVvZihkc2NwcGFybSksDQorCQkJICAgICZkc2NwcGFybSkp DQorCQkJZ290byBubGFfcHV0X2ZhaWx1cmU7DQorDQorCQlpZiAobmxhX3B1dF9mbGFnKHNrYiwg VENBX0NUSU5GT19NT0RFX0RTQ1ApKQ0KKwkJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOw0KKw0KKwkJ ZHNjcHN0YXRzLnNldCA9IGNpLT5zdGF0c19kc2NwX3NldDsNCisJCWRzY3BzdGF0cy5lcnJvciA9 IGNpLT5zdGF0c19kc2NwX2Vycm9yOw0KKwkJaWYgKG5sYV9wdXQoc2tiLCBUQ0FfQ1RJTkZPX1NU QVRTX0RTQ1AsIHNpemVvZihkc2Nwc3RhdHMpLA0KKwkJCSAgICAmZHNjcHN0YXRzKSkNCisJCQln b3RvIG5sYV9wdXRfZmFpbHVyZTsNCisJfQ0KKw0KKwlpZiAoY3AtPm1vZGUgJiBDVElORk9fTU9E RV9TRVRNQVJLKSB7DQorCQlpZiAobmxhX3B1dF91MzIoc2tiLCBUQ0FfQ1RJTkZPX01BUktfTUFT SywgY3AtPm1hcmttYXNrKSkNCisJCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsNCisNCisJCWlmIChu bGFfcHV0X2ZsYWcoc2tiLCBUQ0FfQ1RJTkZPX01PREVfTUFSSykpDQorCQkJZ290byBubGFfcHV0 X2ZhaWx1cmU7DQorDQorCQlpZiAobmxhX3B1dF91NjRfNjRiaXQoc2tiLCBUQ0FfQ1RJTkZPX1NU QVRTX01BUkssDQorCQkJCSAgICAgIGNpLT5zdGF0c19tYXJrX3NldCwgVENBX0NUSU5GT19QQUQp KQ0KKwkJCWdvdG8gbmxhX3B1dF9mYWlsdXJlOw0KKwl9DQorDQorCWlmIChjcC0+em9uZSkgew0K KwkJaWYgKG5sYV9wdXRfdTE2KHNrYiwgVENBX0NUSU5GT19aT05FLCBjcC0+em9uZSkpDQorCQkJ Z290byBubGFfcHV0X2ZhaWx1cmU7DQorCX0NCisNCisJdGNmX3RtX2R1bXAoJnQsICZjaS0+dGNm X3RtKTsNCisJaWYgKG5sYV9wdXRfNjRiaXQoc2tiLCBUQ0FfQ1RJTkZPX1RNLCBzaXplb2YodCks ICZ0LCBUQ0FfQ1RJTkZPX1BBRCkpDQorCQlnb3RvIG5sYV9wdXRfZmFpbHVyZTsNCisNCisJc3Bp bl91bmxvY2tfYmgoJmNpLT50Y2ZfbG9jayk7DQorCXJldHVybiBza2ItPmxlbjsNCisNCitubGFf cHV0X2ZhaWx1cmU6DQorCXNwaW5fdW5sb2NrX2JoKCZjaS0+dGNmX2xvY2spOw0KKwlubG1zZ190 cmltKHNrYiwgYik7DQorCXJldHVybiAtMTsNCit9DQorDQorc3RhdGljIGludCB0Y2ZfY3RpbmZv X3dhbGtlcihzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCBza19idWZmICpza2IsDQorCQkJICAgICBz dHJ1Y3QgbmV0bGlua19jYWxsYmFjayAqY2IsIGludCB0eXBlLA0KKwkJCSAgICAgY29uc3Qgc3Ry dWN0IHRjX2FjdGlvbl9vcHMgKm9wcywNCisJCQkgICAgIHN0cnVjdCBuZXRsaW5rX2V4dF9hY2sg KmV4dGFjaykNCit7DQorCXN0cnVjdCB0Y19hY3Rpb25fbmV0ICp0biA9IG5ldF9nZW5lcmljKG5l dCwgY3RpbmZvX25ldF9pZCk7DQorDQorCXJldHVybiB0Y2ZfZ2VuZXJpY193YWxrZXIodG4sIHNr YiwgY2IsIHR5cGUsIG9wcywgZXh0YWNrKTsNCit9DQorDQorc3RhdGljIGludCB0Y2ZfY3RpbmZv X3NlYXJjaChzdHJ1Y3QgbmV0ICpuZXQsIHN0cnVjdCB0Y19hY3Rpb24gKiphLCB1MzIgaW5kZXgp DQorew0KKwlzdHJ1Y3QgdGNfYWN0aW9uX25ldCAqdG4gPSBuZXRfZ2VuZXJpYyhuZXQsIGN0aW5m b19uZXRfaWQpOw0KKw0KKwlyZXR1cm4gdGNmX2lkcl9zZWFyY2godG4sIGEsIGluZGV4KTsNCit9 DQorDQorc3RhdGljIHN0cnVjdCB0Y19hY3Rpb25fb3BzIGFjdF9jdGluZm9fb3BzID0gew0KKwku a2luZAkJPQkiY3RpbmZvIiwNCisJLmlkCQk9CVRDQV9JRF9DVElORk8sDQorCS5vd25lcgkJPQlU SElTX01PRFVMRSwNCisJLmFjdAkJPQl0Y2ZfY3RpbmZvX2FjdCwNCisJLmR1bXAJCT0JdGNmX2N0 aW5mb19kdW1wLA0KKwkuaW5pdAkJPQl0Y2ZfY3RpbmZvX2luaXQsDQorCS53YWxrCQk9CXRjZl9j dGluZm9fd2Fsa2VyLA0KKwkubG9va3VwCQk9CXRjZl9jdGluZm9fc2VhcmNoLA0KKwkuc2l6ZQkJ PQlzaXplb2Yoc3RydWN0IHRjZl9jdGluZm8pLA0KK307DQorDQorc3RhdGljIF9fbmV0X2luaXQg aW50IGN0aW5mb19pbml0X25ldChzdHJ1Y3QgbmV0ICpuZXQpDQorew0KKwlzdHJ1Y3QgdGNfYWN0 aW9uX25ldCAqdG4gPSBuZXRfZ2VuZXJpYyhuZXQsIGN0aW5mb19uZXRfaWQpOw0KKw0KKwlyZXR1 cm4gdGNfYWN0aW9uX25ldF9pbml0KHRuLCAmYWN0X2N0aW5mb19vcHMpOw0KK30NCisNCitzdGF0 aWMgdm9pZCBfX25ldF9leGl0IGN0aW5mb19leGl0X25ldChzdHJ1Y3QgbGlzdF9oZWFkICpuZXRf bGlzdCkNCit7DQorCXRjX2FjdGlvbl9uZXRfZXhpdChuZXRfbGlzdCwgY3RpbmZvX25ldF9pZCk7 DQorfQ0KKw0KK3N0YXRpYyBzdHJ1Y3QgcGVybmV0X29wZXJhdGlvbnMgY3RpbmZvX25ldF9vcHMg PSB7DQorCS5pbml0ID0gY3RpbmZvX2luaXRfbmV0LA0KKwkuZXhpdF9iYXRjaCA9IGN0aW5mb19l eGl0X25ldCwNCisJLmlkICAgPSAmY3RpbmZvX25ldF9pZCwNCisJLnNpemUgPSBzaXplb2Yoc3Ry dWN0IHRjX2FjdGlvbl9uZXQpLA0KK307DQorDQorc3RhdGljIGludCBfX2luaXQgY3RpbmZvX2lu aXRfbW9kdWxlKHZvaWQpDQorew0KKwlyZXR1cm4gdGNmX3JlZ2lzdGVyX2FjdGlvbigmYWN0X2N0 aW5mb19vcHMsICZjdGluZm9fbmV0X29wcyk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIF9fZXhpdCBj dGluZm9fY2xlYW51cF9tb2R1bGUodm9pZCkNCit7DQorCXRjZl91bnJlZ2lzdGVyX2FjdGlvbigm YWN0X2N0aW5mb19vcHMsICZjdGluZm9fbmV0X29wcyk7DQorfQ0KKw0KK21vZHVsZV9pbml0KGN0 aW5mb19pbml0X21vZHVsZSk7DQorbW9kdWxlX2V4aXQoY3RpbmZvX2NsZWFudXBfbW9kdWxlKTsN CitNT0RVTEVfQVVUSE9SKCJLZXZpbiBEYXJieXNoaXJlLUJyeWFudCA8bGRpckBkYXJieXNoaXJl LWJyeWFudC5tZS51az4iKTsNCitNT0RVTEVfREVTQ1JJUFRJT04oIkNvbm5lY3Rpb24gdHJhY2tp bmcgbWFyayBhY3Rpb25zIik7DQorTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOw0KZGlmZiAtLWdpdCBh L3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3RjLXRlc3RpbmcvY29uZmlnIGIvdG9vbHMvdGVzdGlu Zy9zZWxmdGVzdHMvdGMtdGVzdGluZy9jb25maWcNCmluZGV4IDIwMzMwMjA2NTQ1OC4uYjIzNWVm ZDU1MzY3IDEwMDY0NA0KLS0tIGEvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvdGMtdGVzdGluZy9j b25maWcNCisrKyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3RjLXRlc3RpbmcvY29uZmlnDQpA QCAtMzgsNiArMzgsNyBAQCBDT05GSUdfTkVUX0FDVF9DU1VNPW0NCiBDT05GSUdfTkVUX0FDVF9W TEFOPW0NCiBDT05GSUdfTkVUX0FDVF9CUEY9bQ0KIENPTkZJR19ORVRfQUNUX0NPTk5NQVJLPW0N CitDT05GSUdfTkVUX0FDVF9DVElORk89bQ0KIENPTkZJR19ORVRfQUNUX1NLQk1PRD1tDQogQ09O RklHX05FVF9BQ1RfSUZFPW0NCiBDT05GSUdfTkVUX0FDVF9UVU5ORUxfS0VZPW0NCi0tIA0KMi4y MC4xIChBcHBsZSBHaXQtMTE3KQ0KDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: ldir at darbyshire-bryant.me.uk (Kevin 'ldir' Darbyshire-Bryant) Date: Tue, 7 May 2019 20:12:13 +0000 Subject: [PATCH net-next v4] net: sched: Introduce act_ctinfo action In-Reply-To: <20190507.123952.2046042425594195721.davem@davemloft.net> References: <20190507.123952.2046042425594195721.davem@davemloft.net> Message-ID: <20190507201154.97646-1-ldir@darbyshire-bryant.me.uk> ctinfo is a new tc filter action module. It is designed to restore information contained in conntrack marks to other places. At present it can restore DSCP values to IPv4/6 diffserv fields and also copy conntrack marks to skb marks. As such the 2nd function effectively replaces the existing act_connmark module The DSCP restoration is intended for use and has been found useful for restoring ingress classifications based on egress classifications across links that bleach or otherwise change DSCP, typically home ISP Internet links. Restoring DSCP on ingress on the WAN link allows qdiscs such as CAKE to shape inbound packets according to policies that are easier to indicate on egress. Ingress classification is traditionally a challenging task since iptables rules haven't yet run and tc filter/eBPF programs are pre-NAT lookups, hence are unable to see internal IPv4 addresses as used on the typical home masquerading gateway. ctinfo understands the following parameters: dscp dscpmask[/statemask] dscpmask - a 32 bit mask of at least 6 contiguous bits and indicates where ctinfo will find the DSCP bits stored in the conntrack mark. statemask - a 32 bit mask of (usually) 1 bit length, outside the area specified by dscpmask. This represents a conditional operation flag whereby the DSCP is only restored if the flag is set. This is useful to implement a 'one shot' iptables based classification where the 'complicated' iptables rules are only run once to classify the connection on initial (egress) packet and subsequent packets are all marked/restored with the same DSCP. A mask of zero disables the conditional behaviour ie. the conntrack mark DSCP bits are always restored to the ip diffserv field (assuming the conntrack entry is found & the skb is an ipv4/ipv6 type) mark [mask] mark - enables copying the conntrack connmark value to the skb mark mask - a 32 bit mask applied to the mark to mask out bit unwanted for restoration. The CAKE qdisc for example understands both DSCP and 'tin' classification stored the mark, thus act_ctinfo may be used to restore both aspects of classification for CAKE in one action. A default mask of 0xffffffff is applied if not specified. zone - conntrack zone control - action related control (reclassify | pipe | drop | continue | ok | goto chain ) e.g. dscp 0xfc000000/0x01000000 |----0xFC----conntrack mark----000000---| | Bits 31-26 | bit 25 | bit24 |~~~ Bit 0| | DSCP | unused | flag |unused | |-----------------------0x01---000000---| | | | | ---| Conditional flag v only restore if set |-ip diffserv-| | 6 bits | |-------------| e.g. mark 0x00ffffff |----0x00----conntrack mark----ffffff---| | Bits 31-24 | | | DSCP & flag| | |---------------------------------------| | | v |------------skb mark-------------------| | | | | |---------------------------------------| Signed-off-by: Kevin Darbyshire-Bryant --- v2 - add equivalent connmark functionality with an enhancement to accept a mask pass statistics for each sub-function as individual netlink attributes and stop (ab)using overlimits, drops update the testing config correctly v3 - fix a licensing silly & tidy up GPL boilerplate v4 - drop stray copy paste inline reverse christmas tree local vars include/net/tc_act/tc_ctinfo.h | 28 ++ include/uapi/linux/pkt_cls.h | 1 + include/uapi/linux/tc_act/tc_ctinfo.h | 43 +++ net/sched/Kconfig | 17 + net/sched/Makefile | 1 + net/sched/act_ctinfo.c | 402 ++++++++++++++++++++++ tools/testing/selftests/tc-testing/config | 1 + 7 files changed, 493 insertions(+) create mode 100644 include/net/tc_act/tc_ctinfo.h create mode 100644 include/uapi/linux/tc_act/tc_ctinfo.h create mode 100644 net/sched/act_ctinfo.c diff --git a/include/net/tc_act/tc_ctinfo.h b/include/net/tc_act/tc_ctinfo.h new file mode 100644 index 000000000000..87334120dcb6 --- /dev/null +++ b/include/net/tc_act/tc_ctinfo.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __NET_TC_CTINFO_H +#define __NET_TC_CTINFO_H + +#include + +struct tcf_ctinfo_params { + struct net *net; + u32 dscpmask; + u32 dscpstatemask; + u32 markmask; + u16 zone; + u8 mode; + u8 dscpmaskshift; + struct rcu_head rcu; +}; + +struct tcf_ctinfo { + struct tc_action common; + struct tcf_ctinfo_params __rcu *params; + u64 stats_dscp_set; + u64 stats_dscp_error; + u64 stats_mark_set; +}; + +#define to_ctinfo(a) ((struct tcf_ctinfo *)a) + +#endif /* __NET_TC_CTINFO_H */ diff --git a/include/uapi/linux/pkt_cls.h b/include/uapi/linux/pkt_cls.h index 51a0496f78ea..a93680fc4bfa 100644 --- a/include/uapi/linux/pkt_cls.h +++ b/include/uapi/linux/pkt_cls.h @@ -105,6 +105,7 @@ enum tca_id { TCA_ID_IFE = TCA_ACT_IFE, TCA_ID_SAMPLE = TCA_ACT_SAMPLE, /* other actions go here */ + TCA_ID_CTINFO, __TCA_ID_MAX = 255 }; diff --git a/include/uapi/linux/tc_act/tc_ctinfo.h b/include/uapi/linux/tc_act/tc_ctinfo.h new file mode 100644 index 000000000000..8d254b82151c --- /dev/null +++ b/include/uapi/linux/tc_act/tc_ctinfo.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef __UAPI_TC_CTINFO_H +#define __UAPI_TC_CTINFO_H + +#include +#include + +struct tc_ctinfo { + tc_gen; +}; + +struct tc_ctinfo_dscp { + __u32 mask; + __u32 statemask; +}; + +struct tc_ctinfo_stats_dscp { + __u64 set; + __u64 error; +}; + +enum { + TCA_CTINFO_UNSPEC, + TCA_CTINFO_ACT, + TCA_CTINFO_ZONE, + TCA_CTINFO_DSCP_PARMS, + TCA_CTINFO_MARK_MASK, + TCA_CTINFO_MODE_DSCP, + TCA_CTINFO_MODE_MARK, + TCA_CTINFO_STATS_DSCP, + TCA_CTINFO_STATS_MARK, + TCA_CTINFO_TM, + TCA_CTINFO_PAD, + __TCA_CTINFO_MAX +}; +#define TCA_CTINFO_MAX (__TCA_CTINFO_MAX - 1) + +enum { + CTINFO_MODE_SETDSCP = BIT(0), + CTINFO_MODE_SETMARK = BIT(1) +}; + +#endif diff --git a/net/sched/Kconfig b/net/sched/Kconfig index 5c02ad97ef23..f5773effcfdc 100644 --- a/net/sched/Kconfig +++ b/net/sched/Kconfig @@ -876,6 +876,23 @@ config NET_ACT_CONNMARK To compile this code as a module, choose M here: the module will be called act_connmark. +config NET_ACT_CTINFO + tristate "Netfilter Connection Mark Actions" + depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES + depends on NF_CONNTRACK && NF_CONNTRACK_MARK + help + Say Y here to allow transfer of a connmark stored information. + Current actions transfer connmark stored DSCP into + ipv4/v6 diffserv and/or to transfer connmark to packet + mark. Both are useful for restoring egress based marks + back onto ingress connections for qdisc priority mapping + purposes. + + If unsure, say N. + + To compile this code as a module, choose M here: the + module will be called act_ctinfo. + config NET_ACT_SKBMOD tristate "skb data modification action" depends on NET_CLS_ACT diff --git a/net/sched/Makefile b/net/sched/Makefile index 8a40431d7b5c..d54bfcbd7981 100644 --- a/net/sched/Makefile +++ b/net/sched/Makefile @@ -21,6 +21,7 @@ obj-$(CONFIG_NET_ACT_CSUM) += act_csum.o obj-$(CONFIG_NET_ACT_VLAN) += act_vlan.o obj-$(CONFIG_NET_ACT_BPF) += act_bpf.o obj-$(CONFIG_NET_ACT_CONNMARK) += act_connmark.o +obj-$(CONFIG_NET_ACT_CTINFO) += act_ctinfo.o obj-$(CONFIG_NET_ACT_SKBMOD) += act_skbmod.o obj-$(CONFIG_NET_ACT_IFE) += act_ife.o obj-$(CONFIG_NET_IFE_SKBMARK) += act_meta_mark.o diff --git a/net/sched/act_ctinfo.c b/net/sched/act_ctinfo.c new file mode 100644 index 000000000000..93f98d62a962 --- /dev/null +++ b/net/sched/act_ctinfo.c @@ -0,0 +1,402 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* net/sched/act_ctinfo.c netfilter ctinfo connmark actions + * + * Copyright (c) 2019 Kevin Darbyshire-Bryant + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +static unsigned int ctinfo_net_id; +static struct tc_action_ops act_ctinfo_ops; + +static void tcf_ctinfo_dscp_set(struct nf_conn *ct, struct tcf_ctinfo *ca, + struct tcf_ctinfo_params *cp, + struct sk_buff *skb, int wlen, int proto) +{ + u8 dscp, newdscp; + + newdscp = (((ct->mark & cp->dscpmask) >> cp->dscpmaskshift) << 2) & + ~INET_ECN_MASK; + + switch (proto) { + case NFPROTO_IPV4: + dscp = ipv4_get_dsfield(ip_hdr(skb)) & ~INET_ECN_MASK; + if (dscp != newdscp) { + if (likely(!skb_try_make_writable(skb, wlen))) { + ipv4_change_dsfield(ip_hdr(skb), + INET_ECN_MASK, + newdscp); + ca->stats_dscp_set++; + } else { + ca->stats_dscp_error++; + } + } + break; + case NFPROTO_IPV6: + dscp = ipv6_get_dsfield(ipv6_hdr(skb)) & ~INET_ECN_MASK; + if (dscp != newdscp) { + if (likely(!skb_try_make_writable(skb, wlen))) { + ipv6_change_dsfield(ipv6_hdr(skb), + INET_ECN_MASK, + newdscp); + ca->stats_dscp_set++; + } else { + ca->stats_dscp_error++; + } + } + break; + default: + break; + } +} + +static void tcf_ctinfo_mark_set(struct nf_conn *ct, struct tcf_ctinfo *ca, + struct tcf_ctinfo_params *cp, + struct sk_buff *skb) +{ + ca->stats_mark_set++; + skb->mark = ct->mark & cp->markmask; +} + +static int tcf_ctinfo_act(struct sk_buff *skb, const struct tc_action *a, + struct tcf_result *res) +{ + const struct nf_conntrack_tuple_hash *thash = NULL; + struct tcf_ctinfo *ca = to_ctinfo(a); + struct nf_conntrack_tuple tuple; + struct nf_conntrack_zone zone; + enum ip_conntrack_info ctinfo; + struct tcf_ctinfo_params *cp; + struct nf_conn *ct; + int proto, wlen; + int action; + + cp = rcu_dereference_bh(ca->params); + + tcf_lastuse_update(&ca->tcf_tm); + bstats_update(&ca->tcf_bstats, skb); + action = READ_ONCE(ca->tcf_action); + + wlen = skb_network_offset(skb); + if (tc_skb_protocol(skb) == htons(ETH_P_IP)) { + wlen += sizeof(struct iphdr); + if (!pskb_may_pull(skb, wlen)) + goto out; + + proto = NFPROTO_IPV4; + } else if (tc_skb_protocol(skb) == htons(ETH_P_IPV6)) { + wlen += sizeof(struct ipv6hdr); + if (!pskb_may_pull(skb, wlen)) + goto out; + + proto = NFPROTO_IPV6; + } else { + goto out; + } + + ct = nf_ct_get(skb, &ctinfo); + if (!ct) { /* look harder, usually ingress */ + if (!nf_ct_get_tuplepr(skb, skb_network_offset(skb), + proto, cp->net, &tuple)) + goto out; + zone.id = cp->zone; + zone.dir = NF_CT_DEFAULT_ZONE_DIR; + + thash = nf_conntrack_find_get(cp->net, &zone, &tuple); + if (!thash) + goto out; + + ct = nf_ct_tuplehash_to_ctrack(thash); + } + + if (cp->mode & CTINFO_MODE_SETDSCP) + if (!cp->dscpstatemask || (ct->mark & cp->dscpstatemask)) + tcf_ctinfo_dscp_set(ct, ca, cp, skb, wlen, proto); + + if (cp->mode & CTINFO_MODE_SETMARK) + tcf_ctinfo_mark_set(ct, ca, cp, skb); + + if (thash) + nf_ct_put(ct); +out: + return action; +} + +static const struct nla_policy ctinfo_policy[TCA_CTINFO_MAX + 1] = { + [TCA_CTINFO_ACT] = { .len = sizeof(struct tc_ctinfo) }, + [TCA_CTINFO_ZONE] = { .type = NLA_U16 }, + [TCA_CTINFO_MODE_DSCP] = { .type = NLA_FLAG }, + [TCA_CTINFO_MODE_MARK] = { .type = NLA_FLAG }, + [TCA_CTINFO_DSCP_PARMS] = { .len = sizeof(struct tc_ctinfo_dscp) }, +}; + +static int tcf_ctinfo_init(struct net *net, struct nlattr *nla, + struct nlattr *est, struct tc_action **a, + int ovr, int bind, bool rtnl_held, + struct tcf_proto *tp, + struct netlink_ext_ack *extack) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + struct nlattr *tb[TCA_CTINFO_MAX + 1]; + struct tcf_ctinfo_params *cp_new; + struct tcf_chain *goto_ch = NULL; + struct tc_ctinfo_dscp *dscpparm; + struct tcf_ctinfo *ci; + struct tc_ctinfo *actparm; + int ret = 0, err, i; + + if (!nla) + return -EINVAL; + + err = nla_parse_nested(tb, TCA_CTINFO_MAX, nla, ctinfo_policy, NULL); + if (err < 0) + return err; + + if (!tb[TCA_CTINFO_ACT]) + return -EINVAL; + + if (tb[TCA_CTINFO_MODE_DSCP] && !tb[TCA_CTINFO_DSCP_PARMS]) + return -EINVAL; + + actparm = nla_data(tb[TCA_CTINFO_ACT]); + dscpparm = nla_data(tb[TCA_CTINFO_DSCP_PARMS]); + + if (dscpparm) { + /* need at least contiguous 6 bit mask */ + i = dscpparm->mask ? __ffs(dscpparm->mask) : 0; + if ((0x3f & (dscpparm->mask >> i)) != 0x3f) + return -EINVAL; + /* mask & statemask must not overlap */ + if (dscpparm->mask & dscpparm->statemask) + return -EINVAL; + } + + /* done the validation:now to the actual action allocation */ + err = tcf_idr_check_alloc(tn, &actparm->index, a, bind); + if (!err) { + ret = tcf_idr_create(tn, actparm->index, est, a, + &act_ctinfo_ops, bind, false); + if (ret) { + tcf_idr_cleanup(tn, actparm->index); + return ret; + } + } else if (err > 0) { + if (bind) /* don't override defaults */ + return 0; + if (!ovr) { + tcf_idr_release(*a, bind); + return -EEXIST; + } + } else { + return err; + } + + err = tcf_action_check_ctrlact(actparm->action, tp, &goto_ch, extack); + if (err < 0) + goto release_idr; + + ci = to_ctinfo(*a); + + cp_new = kzalloc(sizeof(*cp_new), GFP_KERNEL); + if (unlikely(!cp_new)) { + err = -ENOMEM; + goto put_chain; + } + + cp_new->net = net; + cp_new->zone = tb[TCA_CTINFO_ZONE] ? + nla_get_u16(tb[TCA_CTINFO_ZONE]) : 0; + if (dscpparm) { + cp_new->dscpmask = dscpparm->mask; + cp_new->dscpmaskshift = cp_new->dscpmask ? + __ffs(cp_new->dscpmask) : 0; + cp_new->dscpstatemask = dscpparm->statemask; + } + cp_new->markmask = tb[TCA_CTINFO_MARK_MASK] ? + nla_get_u32(tb[TCA_CTINFO_MARK_MASK]) : ~0; + + if (tb[TCA_CTINFO_MODE_DSCP]) + cp_new->mode |= CTINFO_MODE_SETDSCP; + else + cp_new->mode &= ~CTINFO_MODE_SETDSCP; + + if (tb[TCA_CTINFO_MODE_MARK]) + cp_new->mode |= CTINFO_MODE_SETMARK; + else + cp_new->mode &= ~CTINFO_MODE_SETMARK; + + spin_lock_bh(&ci->tcf_lock); + goto_ch = tcf_action_set_ctrlact(*a, actparm->action, goto_ch); + rcu_swap_protected(ci->params, cp_new, + lockdep_is_held(&ci->tcf_lock)); + spin_unlock_bh(&ci->tcf_lock); + + if (goto_ch) + tcf_chain_put_by_act(goto_ch); + if (cp_new) + kfree_rcu(cp_new, rcu); + + if (ret == ACT_P_CREATED) + tcf_idr_insert(tn, *a); + + return ret; + +put_chain: + if (goto_ch) + tcf_chain_put_by_act(goto_ch); +release_idr: + tcf_idr_release(*a, bind); + return err; +} + +static int tcf_ctinfo_dump(struct sk_buff *skb, struct tc_action *a, + int bind, int ref) +{ + struct tcf_ctinfo *ci = to_ctinfo(a); + struct tc_ctinfo opt = { + .refcnt = refcount_read(&ci->tcf_refcnt) - ref, + .bindcnt = atomic_read(&ci->tcf_bindcnt) - bind, + .index = ci->tcf_index, + }; + unsigned char *b = skb_tail_pointer(skb); + struct tc_ctinfo_stats_dscp dscpstats; + struct tc_ctinfo_dscp dscpparm; + struct tcf_ctinfo_params *cp; + struct tcf_t t; + + spin_lock_bh(&ci->tcf_lock); + cp = rcu_dereference_protected(ci->params, + lockdep_is_held(&ci->tcf_lock)); + opt.action = ci->tcf_action; + + if (nla_put(skb, TCA_CTINFO_ACT, sizeof(opt), &opt)) + goto nla_put_failure; + + if (cp->mode & CTINFO_MODE_SETDSCP) { + dscpparm.mask = cp->dscpmask; + dscpparm.statemask = cp->dscpstatemask; + if (nla_put(skb, TCA_CTINFO_DSCP_PARMS, sizeof(dscpparm), + &dscpparm)) + goto nla_put_failure; + + if (nla_put_flag(skb, TCA_CTINFO_MODE_DSCP)) + goto nla_put_failure; + + dscpstats.set = ci->stats_dscp_set; + dscpstats.error = ci->stats_dscp_error; + if (nla_put(skb, TCA_CTINFO_STATS_DSCP, sizeof(dscpstats), + &dscpstats)) + goto nla_put_failure; + } + + if (cp->mode & CTINFO_MODE_SETMARK) { + if (nla_put_u32(skb, TCA_CTINFO_MARK_MASK, cp->markmask)) + goto nla_put_failure; + + if (nla_put_flag(skb, TCA_CTINFO_MODE_MARK)) + goto nla_put_failure; + + if (nla_put_u64_64bit(skb, TCA_CTINFO_STATS_MARK, + ci->stats_mark_set, TCA_CTINFO_PAD)) + goto nla_put_failure; + } + + if (cp->zone) { + if (nla_put_u16(skb, TCA_CTINFO_ZONE, cp->zone)) + goto nla_put_failure; + } + + tcf_tm_dump(&t, &ci->tcf_tm); + if (nla_put_64bit(skb, TCA_CTINFO_TM, sizeof(t), &t, TCA_CTINFO_PAD)) + goto nla_put_failure; + + spin_unlock_bh(&ci->tcf_lock); + return skb->len; + +nla_put_failure: + spin_unlock_bh(&ci->tcf_lock); + nlmsg_trim(skb, b); + return -1; +} + +static int tcf_ctinfo_walker(struct net *net, struct sk_buff *skb, + struct netlink_callback *cb, int type, + const struct tc_action_ops *ops, + struct netlink_ext_ack *extack) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + + return tcf_generic_walker(tn, skb, cb, type, ops, extack); +} + +static int tcf_ctinfo_search(struct net *net, struct tc_action **a, u32 index) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + + return tcf_idr_search(tn, a, index); +} + +static struct tc_action_ops act_ctinfo_ops = { + .kind = "ctinfo", + .id = TCA_ID_CTINFO, + .owner = THIS_MODULE, + .act = tcf_ctinfo_act, + .dump = tcf_ctinfo_dump, + .init = tcf_ctinfo_init, + .walk = tcf_ctinfo_walker, + .lookup = tcf_ctinfo_search, + .size = sizeof(struct tcf_ctinfo), +}; + +static __net_init int ctinfo_init_net(struct net *net) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + + return tc_action_net_init(tn, &act_ctinfo_ops); +} + +static void __net_exit ctinfo_exit_net(struct list_head *net_list) +{ + tc_action_net_exit(net_list, ctinfo_net_id); +} + +static struct pernet_operations ctinfo_net_ops = { + .init = ctinfo_init_net, + .exit_batch = ctinfo_exit_net, + .id = &ctinfo_net_id, + .size = sizeof(struct tc_action_net), +}; + +static int __init ctinfo_init_module(void) +{ + return tcf_register_action(&act_ctinfo_ops, &ctinfo_net_ops); +} + +static void __exit ctinfo_cleanup_module(void) +{ + tcf_unregister_action(&act_ctinfo_ops, &ctinfo_net_ops); +} + +module_init(ctinfo_init_module); +module_exit(ctinfo_cleanup_module); +MODULE_AUTHOR("Kevin Darbyshire-Bryant "); +MODULE_DESCRIPTION("Connection tracking mark actions"); +MODULE_LICENSE("GPL"); diff --git a/tools/testing/selftests/tc-testing/config b/tools/testing/selftests/tc-testing/config index 203302065458..b235efd55367 100644 --- a/tools/testing/selftests/tc-testing/config +++ b/tools/testing/selftests/tc-testing/config @@ -38,6 +38,7 @@ CONFIG_NET_ACT_CSUM=m CONFIG_NET_ACT_VLAN=m CONFIG_NET_ACT_BPF=m CONFIG_NET_ACT_CONNMARK=m +CONFIG_NET_ACT_CTINFO=m CONFIG_NET_ACT_SKBMOD=m CONFIG_NET_ACT_IFE=m CONFIG_NET_ACT_TUNNEL_KEY=m -- 2.20.1 (Apple Git-117) From mboxrd@z Thu Jan 1 00:00:00 1970 From: ldir@darbyshire-bryant.me.uk (Kevin 'ldir' Darbyshire-Bryant) Date: Tue, 7 May 2019 20:12:13 +0000 Subject: [PATCH net-next v4] net: sched: Introduce act_ctinfo action In-Reply-To: <20190507.123952.2046042425594195721.davem@davemloft.net> References: <20190507.123952.2046042425594195721.davem@davemloft.net> Message-ID: <20190507201154.97646-1-ldir@darbyshire-bryant.me.uk> Content-Type: text/plain; charset="UTF-8" Message-ID: <20190507201213.dqx_6rglfdeE9_BEI-YoFbbyYdz5V4aeqDLbxJQ_M4w@z> ctinfo is a new tc filter action module. It is designed to restore information contained in conntrack marks to other places. At present it can restore DSCP values to IPv4/6 diffserv fields and also copy conntrack marks to skb marks. As such the 2nd function effectively replaces the existing act_connmark module The DSCP restoration is intended for use and has been found useful for restoring ingress classifications based on egress classifications across links that bleach or otherwise change DSCP, typically home ISP Internet links. Restoring DSCP on ingress on the WAN link allows qdiscs such as CAKE to shape inbound packets according to policies that are easier to indicate on egress. Ingress classification is traditionally a challenging task since iptables rules haven't yet run and tc filter/eBPF programs are pre-NAT lookups, hence are unable to see internal IPv4 addresses as used on the typical home masquerading gateway. ctinfo understands the following parameters: dscp dscpmask[/statemask] dscpmask - a 32 bit mask of at least 6 contiguous bits and indicates where ctinfo will find the DSCP bits stored in the conntrack mark. statemask - a 32 bit mask of (usually) 1 bit length, outside the area specified by dscpmask. This represents a conditional operation flag whereby the DSCP is only restored if the flag is set. This is useful to implement a 'one shot' iptables based classification where the 'complicated' iptables rules are only run once to classify the connection on initial (egress) packet and subsequent packets are all marked/restored with the same DSCP. A mask of zero disables the conditional behaviour ie. the conntrack mark DSCP bits are always restored to the ip diffserv field (assuming the conntrack entry is found & the skb is an ipv4/ipv6 type) mark [mask] mark - enables copying the conntrack connmark value to the skb mark mask - a 32 bit mask applied to the mark to mask out bit unwanted for restoration. The CAKE qdisc for example understands both DSCP and 'tin' classification stored the mark, thus act_ctinfo may be used to restore both aspects of classification for CAKE in one action. A default mask of 0xffffffff is applied if not specified. zone - conntrack zone control - action related control (reclassify | pipe | drop | continue | ok | goto chain ) e.g. dscp 0xfc000000/0x01000000 |----0xFC----conntrack mark----000000---| | Bits 31-26 | bit 25 | bit24 |~~~ Bit 0| | DSCP | unused | flag |unused | |-----------------------0x01---000000---| | | | | ---| Conditional flag v only restore if set |-ip diffserv-| | 6 bits | |-------------| e.g. mark 0x00ffffff |----0x00----conntrack mark----ffffff---| | Bits 31-24 | | | DSCP & flag| | |---------------------------------------| | | v |------------skb mark-------------------| | | | | |---------------------------------------| Signed-off-by: Kevin Darbyshire-Bryant --- v2 - add equivalent connmark functionality with an enhancement to accept a mask pass statistics for each sub-function as individual netlink attributes and stop (ab)using overlimits, drops update the testing config correctly v3 - fix a licensing silly & tidy up GPL boilerplate v4 - drop stray copy paste inline reverse christmas tree local vars include/net/tc_act/tc_ctinfo.h | 28 ++ include/uapi/linux/pkt_cls.h | 1 + include/uapi/linux/tc_act/tc_ctinfo.h | 43 +++ net/sched/Kconfig | 17 + net/sched/Makefile | 1 + net/sched/act_ctinfo.c | 402 ++++++++++++++++++++++ tools/testing/selftests/tc-testing/config | 1 + 7 files changed, 493 insertions(+) create mode 100644 include/net/tc_act/tc_ctinfo.h create mode 100644 include/uapi/linux/tc_act/tc_ctinfo.h create mode 100644 net/sched/act_ctinfo.c diff --git a/include/net/tc_act/tc_ctinfo.h b/include/net/tc_act/tc_ctinfo.h new file mode 100644 index 000000000000..87334120dcb6 --- /dev/null +++ b/include/net/tc_act/tc_ctinfo.h @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __NET_TC_CTINFO_H +#define __NET_TC_CTINFO_H + +#include + +struct tcf_ctinfo_params { + struct net *net; + u32 dscpmask; + u32 dscpstatemask; + u32 markmask; + u16 zone; + u8 mode; + u8 dscpmaskshift; + struct rcu_head rcu; +}; + +struct tcf_ctinfo { + struct tc_action common; + struct tcf_ctinfo_params __rcu *params; + u64 stats_dscp_set; + u64 stats_dscp_error; + u64 stats_mark_set; +}; + +#define to_ctinfo(a) ((struct tcf_ctinfo *)a) + +#endif /* __NET_TC_CTINFO_H */ diff --git a/include/uapi/linux/pkt_cls.h b/include/uapi/linux/pkt_cls.h index 51a0496f78ea..a93680fc4bfa 100644 --- a/include/uapi/linux/pkt_cls.h +++ b/include/uapi/linux/pkt_cls.h @@ -105,6 +105,7 @@ enum tca_id { TCA_ID_IFE = TCA_ACT_IFE, TCA_ID_SAMPLE = TCA_ACT_SAMPLE, /* other actions go here */ + TCA_ID_CTINFO, __TCA_ID_MAX = 255 }; diff --git a/include/uapi/linux/tc_act/tc_ctinfo.h b/include/uapi/linux/tc_act/tc_ctinfo.h new file mode 100644 index 000000000000..8d254b82151c --- /dev/null +++ b/include/uapi/linux/tc_act/tc_ctinfo.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef __UAPI_TC_CTINFO_H +#define __UAPI_TC_CTINFO_H + +#include +#include + +struct tc_ctinfo { + tc_gen; +}; + +struct tc_ctinfo_dscp { + __u32 mask; + __u32 statemask; +}; + +struct tc_ctinfo_stats_dscp { + __u64 set; + __u64 error; +}; + +enum { + TCA_CTINFO_UNSPEC, + TCA_CTINFO_ACT, + TCA_CTINFO_ZONE, + TCA_CTINFO_DSCP_PARMS, + TCA_CTINFO_MARK_MASK, + TCA_CTINFO_MODE_DSCP, + TCA_CTINFO_MODE_MARK, + TCA_CTINFO_STATS_DSCP, + TCA_CTINFO_STATS_MARK, + TCA_CTINFO_TM, + TCA_CTINFO_PAD, + __TCA_CTINFO_MAX +}; +#define TCA_CTINFO_MAX (__TCA_CTINFO_MAX - 1) + +enum { + CTINFO_MODE_SETDSCP = BIT(0), + CTINFO_MODE_SETMARK = BIT(1) +}; + +#endif diff --git a/net/sched/Kconfig b/net/sched/Kconfig index 5c02ad97ef23..f5773effcfdc 100644 --- a/net/sched/Kconfig +++ b/net/sched/Kconfig @@ -876,6 +876,23 @@ config NET_ACT_CONNMARK To compile this code as a module, choose M here: the module will be called act_connmark. +config NET_ACT_CTINFO + tristate "Netfilter Connection Mark Actions" + depends on NET_CLS_ACT && NETFILTER && IP_NF_IPTABLES + depends on NF_CONNTRACK && NF_CONNTRACK_MARK + help + Say Y here to allow transfer of a connmark stored information. + Current actions transfer connmark stored DSCP into + ipv4/v6 diffserv and/or to transfer connmark to packet + mark. Both are useful for restoring egress based marks + back onto ingress connections for qdisc priority mapping + purposes. + + If unsure, say N. + + To compile this code as a module, choose M here: the + module will be called act_ctinfo. + config NET_ACT_SKBMOD tristate "skb data modification action" depends on NET_CLS_ACT diff --git a/net/sched/Makefile b/net/sched/Makefile index 8a40431d7b5c..d54bfcbd7981 100644 --- a/net/sched/Makefile +++ b/net/sched/Makefile @@ -21,6 +21,7 @@ obj-$(CONFIG_NET_ACT_CSUM) += act_csum.o obj-$(CONFIG_NET_ACT_VLAN) += act_vlan.o obj-$(CONFIG_NET_ACT_BPF) += act_bpf.o obj-$(CONFIG_NET_ACT_CONNMARK) += act_connmark.o +obj-$(CONFIG_NET_ACT_CTINFO) += act_ctinfo.o obj-$(CONFIG_NET_ACT_SKBMOD) += act_skbmod.o obj-$(CONFIG_NET_ACT_IFE) += act_ife.o obj-$(CONFIG_NET_IFE_SKBMARK) += act_meta_mark.o diff --git a/net/sched/act_ctinfo.c b/net/sched/act_ctinfo.c new file mode 100644 index 000000000000..93f98d62a962 --- /dev/null +++ b/net/sched/act_ctinfo.c @@ -0,0 +1,402 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* net/sched/act_ctinfo.c netfilter ctinfo connmark actions + * + * Copyright (c) 2019 Kevin Darbyshire-Bryant + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +static unsigned int ctinfo_net_id; +static struct tc_action_ops act_ctinfo_ops; + +static void tcf_ctinfo_dscp_set(struct nf_conn *ct, struct tcf_ctinfo *ca, + struct tcf_ctinfo_params *cp, + struct sk_buff *skb, int wlen, int proto) +{ + u8 dscp, newdscp; + + newdscp = (((ct->mark & cp->dscpmask) >> cp->dscpmaskshift) << 2) & + ~INET_ECN_MASK; + + switch (proto) { + case NFPROTO_IPV4: + dscp = ipv4_get_dsfield(ip_hdr(skb)) & ~INET_ECN_MASK; + if (dscp != newdscp) { + if (likely(!skb_try_make_writable(skb, wlen))) { + ipv4_change_dsfield(ip_hdr(skb), + INET_ECN_MASK, + newdscp); + ca->stats_dscp_set++; + } else { + ca->stats_dscp_error++; + } + } + break; + case NFPROTO_IPV6: + dscp = ipv6_get_dsfield(ipv6_hdr(skb)) & ~INET_ECN_MASK; + if (dscp != newdscp) { + if (likely(!skb_try_make_writable(skb, wlen))) { + ipv6_change_dsfield(ipv6_hdr(skb), + INET_ECN_MASK, + newdscp); + ca->stats_dscp_set++; + } else { + ca->stats_dscp_error++; + } + } + break; + default: + break; + } +} + +static void tcf_ctinfo_mark_set(struct nf_conn *ct, struct tcf_ctinfo *ca, + struct tcf_ctinfo_params *cp, + struct sk_buff *skb) +{ + ca->stats_mark_set++; + skb->mark = ct->mark & cp->markmask; +} + +static int tcf_ctinfo_act(struct sk_buff *skb, const struct tc_action *a, + struct tcf_result *res) +{ + const struct nf_conntrack_tuple_hash *thash = NULL; + struct tcf_ctinfo *ca = to_ctinfo(a); + struct nf_conntrack_tuple tuple; + struct nf_conntrack_zone zone; + enum ip_conntrack_info ctinfo; + struct tcf_ctinfo_params *cp; + struct nf_conn *ct; + int proto, wlen; + int action; + + cp = rcu_dereference_bh(ca->params); + + tcf_lastuse_update(&ca->tcf_tm); + bstats_update(&ca->tcf_bstats, skb); + action = READ_ONCE(ca->tcf_action); + + wlen = skb_network_offset(skb); + if (tc_skb_protocol(skb) == htons(ETH_P_IP)) { + wlen += sizeof(struct iphdr); + if (!pskb_may_pull(skb, wlen)) + goto out; + + proto = NFPROTO_IPV4; + } else if (tc_skb_protocol(skb) == htons(ETH_P_IPV6)) { + wlen += sizeof(struct ipv6hdr); + if (!pskb_may_pull(skb, wlen)) + goto out; + + proto = NFPROTO_IPV6; + } else { + goto out; + } + + ct = nf_ct_get(skb, &ctinfo); + if (!ct) { /* look harder, usually ingress */ + if (!nf_ct_get_tuplepr(skb, skb_network_offset(skb), + proto, cp->net, &tuple)) + goto out; + zone.id = cp->zone; + zone.dir = NF_CT_DEFAULT_ZONE_DIR; + + thash = nf_conntrack_find_get(cp->net, &zone, &tuple); + if (!thash) + goto out; + + ct = nf_ct_tuplehash_to_ctrack(thash); + } + + if (cp->mode & CTINFO_MODE_SETDSCP) + if (!cp->dscpstatemask || (ct->mark & cp->dscpstatemask)) + tcf_ctinfo_dscp_set(ct, ca, cp, skb, wlen, proto); + + if (cp->mode & CTINFO_MODE_SETMARK) + tcf_ctinfo_mark_set(ct, ca, cp, skb); + + if (thash) + nf_ct_put(ct); +out: + return action; +} + +static const struct nla_policy ctinfo_policy[TCA_CTINFO_MAX + 1] = { + [TCA_CTINFO_ACT] = { .len = sizeof(struct tc_ctinfo) }, + [TCA_CTINFO_ZONE] = { .type = NLA_U16 }, + [TCA_CTINFO_MODE_DSCP] = { .type = NLA_FLAG }, + [TCA_CTINFO_MODE_MARK] = { .type = NLA_FLAG }, + [TCA_CTINFO_DSCP_PARMS] = { .len = sizeof(struct tc_ctinfo_dscp) }, +}; + +static int tcf_ctinfo_init(struct net *net, struct nlattr *nla, + struct nlattr *est, struct tc_action **a, + int ovr, int bind, bool rtnl_held, + struct tcf_proto *tp, + struct netlink_ext_ack *extack) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + struct nlattr *tb[TCA_CTINFO_MAX + 1]; + struct tcf_ctinfo_params *cp_new; + struct tcf_chain *goto_ch = NULL; + struct tc_ctinfo_dscp *dscpparm; + struct tcf_ctinfo *ci; + struct tc_ctinfo *actparm; + int ret = 0, err, i; + + if (!nla) + return -EINVAL; + + err = nla_parse_nested(tb, TCA_CTINFO_MAX, nla, ctinfo_policy, NULL); + if (err < 0) + return err; + + if (!tb[TCA_CTINFO_ACT]) + return -EINVAL; + + if (tb[TCA_CTINFO_MODE_DSCP] && !tb[TCA_CTINFO_DSCP_PARMS]) + return -EINVAL; + + actparm = nla_data(tb[TCA_CTINFO_ACT]); + dscpparm = nla_data(tb[TCA_CTINFO_DSCP_PARMS]); + + if (dscpparm) { + /* need at least contiguous 6 bit mask */ + i = dscpparm->mask ? __ffs(dscpparm->mask) : 0; + if ((0x3f & (dscpparm->mask >> i)) != 0x3f) + return -EINVAL; + /* mask & statemask must not overlap */ + if (dscpparm->mask & dscpparm->statemask) + return -EINVAL; + } + + /* done the validation:now to the actual action allocation */ + err = tcf_idr_check_alloc(tn, &actparm->index, a, bind); + if (!err) { + ret = tcf_idr_create(tn, actparm->index, est, a, + &act_ctinfo_ops, bind, false); + if (ret) { + tcf_idr_cleanup(tn, actparm->index); + return ret; + } + } else if (err > 0) { + if (bind) /* don't override defaults */ + return 0; + if (!ovr) { + tcf_idr_release(*a, bind); + return -EEXIST; + } + } else { + return err; + } + + err = tcf_action_check_ctrlact(actparm->action, tp, &goto_ch, extack); + if (err < 0) + goto release_idr; + + ci = to_ctinfo(*a); + + cp_new = kzalloc(sizeof(*cp_new), GFP_KERNEL); + if (unlikely(!cp_new)) { + err = -ENOMEM; + goto put_chain; + } + + cp_new->net = net; + cp_new->zone = tb[TCA_CTINFO_ZONE] ? + nla_get_u16(tb[TCA_CTINFO_ZONE]) : 0; + if (dscpparm) { + cp_new->dscpmask = dscpparm->mask; + cp_new->dscpmaskshift = cp_new->dscpmask ? + __ffs(cp_new->dscpmask) : 0; + cp_new->dscpstatemask = dscpparm->statemask; + } + cp_new->markmask = tb[TCA_CTINFO_MARK_MASK] ? + nla_get_u32(tb[TCA_CTINFO_MARK_MASK]) : ~0; + + if (tb[TCA_CTINFO_MODE_DSCP]) + cp_new->mode |= CTINFO_MODE_SETDSCP; + else + cp_new->mode &= ~CTINFO_MODE_SETDSCP; + + if (tb[TCA_CTINFO_MODE_MARK]) + cp_new->mode |= CTINFO_MODE_SETMARK; + else + cp_new->mode &= ~CTINFO_MODE_SETMARK; + + spin_lock_bh(&ci->tcf_lock); + goto_ch = tcf_action_set_ctrlact(*a, actparm->action, goto_ch); + rcu_swap_protected(ci->params, cp_new, + lockdep_is_held(&ci->tcf_lock)); + spin_unlock_bh(&ci->tcf_lock); + + if (goto_ch) + tcf_chain_put_by_act(goto_ch); + if (cp_new) + kfree_rcu(cp_new, rcu); + + if (ret == ACT_P_CREATED) + tcf_idr_insert(tn, *a); + + return ret; + +put_chain: + if (goto_ch) + tcf_chain_put_by_act(goto_ch); +release_idr: + tcf_idr_release(*a, bind); + return err; +} + +static int tcf_ctinfo_dump(struct sk_buff *skb, struct tc_action *a, + int bind, int ref) +{ + struct tcf_ctinfo *ci = to_ctinfo(a); + struct tc_ctinfo opt = { + .refcnt = refcount_read(&ci->tcf_refcnt) - ref, + .bindcnt = atomic_read(&ci->tcf_bindcnt) - bind, + .index = ci->tcf_index, + }; + unsigned char *b = skb_tail_pointer(skb); + struct tc_ctinfo_stats_dscp dscpstats; + struct tc_ctinfo_dscp dscpparm; + struct tcf_ctinfo_params *cp; + struct tcf_t t; + + spin_lock_bh(&ci->tcf_lock); + cp = rcu_dereference_protected(ci->params, + lockdep_is_held(&ci->tcf_lock)); + opt.action = ci->tcf_action; + + if (nla_put(skb, TCA_CTINFO_ACT, sizeof(opt), &opt)) + goto nla_put_failure; + + if (cp->mode & CTINFO_MODE_SETDSCP) { + dscpparm.mask = cp->dscpmask; + dscpparm.statemask = cp->dscpstatemask; + if (nla_put(skb, TCA_CTINFO_DSCP_PARMS, sizeof(dscpparm), + &dscpparm)) + goto nla_put_failure; + + if (nla_put_flag(skb, TCA_CTINFO_MODE_DSCP)) + goto nla_put_failure; + + dscpstats.set = ci->stats_dscp_set; + dscpstats.error = ci->stats_dscp_error; + if (nla_put(skb, TCA_CTINFO_STATS_DSCP, sizeof(dscpstats), + &dscpstats)) + goto nla_put_failure; + } + + if (cp->mode & CTINFO_MODE_SETMARK) { + if (nla_put_u32(skb, TCA_CTINFO_MARK_MASK, cp->markmask)) + goto nla_put_failure; + + if (nla_put_flag(skb, TCA_CTINFO_MODE_MARK)) + goto nla_put_failure; + + if (nla_put_u64_64bit(skb, TCA_CTINFO_STATS_MARK, + ci->stats_mark_set, TCA_CTINFO_PAD)) + goto nla_put_failure; + } + + if (cp->zone) { + if (nla_put_u16(skb, TCA_CTINFO_ZONE, cp->zone)) + goto nla_put_failure; + } + + tcf_tm_dump(&t, &ci->tcf_tm); + if (nla_put_64bit(skb, TCA_CTINFO_TM, sizeof(t), &t, TCA_CTINFO_PAD)) + goto nla_put_failure; + + spin_unlock_bh(&ci->tcf_lock); + return skb->len; + +nla_put_failure: + spin_unlock_bh(&ci->tcf_lock); + nlmsg_trim(skb, b); + return -1; +} + +static int tcf_ctinfo_walker(struct net *net, struct sk_buff *skb, + struct netlink_callback *cb, int type, + const struct tc_action_ops *ops, + struct netlink_ext_ack *extack) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + + return tcf_generic_walker(tn, skb, cb, type, ops, extack); +} + +static int tcf_ctinfo_search(struct net *net, struct tc_action **a, u32 index) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + + return tcf_idr_search(tn, a, index); +} + +static struct tc_action_ops act_ctinfo_ops = { + .kind = "ctinfo", + .id = TCA_ID_CTINFO, + .owner = THIS_MODULE, + .act = tcf_ctinfo_act, + .dump = tcf_ctinfo_dump, + .init = tcf_ctinfo_init, + .walk = tcf_ctinfo_walker, + .lookup = tcf_ctinfo_search, + .size = sizeof(struct tcf_ctinfo), +}; + +static __net_init int ctinfo_init_net(struct net *net) +{ + struct tc_action_net *tn = net_generic(net, ctinfo_net_id); + + return tc_action_net_init(tn, &act_ctinfo_ops); +} + +static void __net_exit ctinfo_exit_net(struct list_head *net_list) +{ + tc_action_net_exit(net_list, ctinfo_net_id); +} + +static struct pernet_operations ctinfo_net_ops = { + .init = ctinfo_init_net, + .exit_batch = ctinfo_exit_net, + .id = &ctinfo_net_id, + .size = sizeof(struct tc_action_net), +}; + +static int __init ctinfo_init_module(void) +{ + return tcf_register_action(&act_ctinfo_ops, &ctinfo_net_ops); +} + +static void __exit ctinfo_cleanup_module(void) +{ + tcf_unregister_action(&act_ctinfo_ops, &ctinfo_net_ops); +} + +module_init(ctinfo_init_module); +module_exit(ctinfo_cleanup_module); +MODULE_AUTHOR("Kevin Darbyshire-Bryant "); +MODULE_DESCRIPTION("Connection tracking mark actions"); +MODULE_LICENSE("GPL"); diff --git a/tools/testing/selftests/tc-testing/config b/tools/testing/selftests/tc-testing/config index 203302065458..b235efd55367 100644 --- a/tools/testing/selftests/tc-testing/config +++ b/tools/testing/selftests/tc-testing/config @@ -38,6 +38,7 @@ CONFIG_NET_ACT_CSUM=m CONFIG_NET_ACT_VLAN=m CONFIG_NET_ACT_BPF=m CONFIG_NET_ACT_CONNMARK=m +CONFIG_NET_ACT_CTINFO=m CONFIG_NET_ACT_SKBMOD=m CONFIG_NET_ACT_IFE=m CONFIG_NET_ACT_TUNNEL_KEY=m -- 2.20.1 (Apple Git-117)