From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=pass header.oldest-pass=0 smtp.remote-ip=198.175.65.21 ARC-Seal: i=2; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=pass; t=1795114056; b=NZIZowRCURUhIHA9nBftxHRLpPgAWTBdI9wTqLTK9lg5D+7hsq3grQN33i3HqsVrV8VZ G4RE/roi3tspwOMDhKFxodbXWi3nv0DRTFfm3V/340v4RnntsVuj6e1gFqlvE+P9aONGl sfr7QWAZB12RbH+k/AJnyKaMzr+12ngPj6JVCOVYCh/YrIlE88WLZXCmI/w4/2z6adE9X JW7J1LZlfEGB30C4wLlqrHgYJnqsSUVR6/iuX9kp89bFS9nFK7b83btNrjlC3VwFjBBSO CiJyVEo2SOiKkMe1tDQ1UQdphypNI+j21wV1fvKTr6mTzdmRSM53WAKuUKj1PiHhKrw== ARC-Message-Signature: i=2; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795114056; h=DMARC-Filter:DKIM-Signature:X-CSE-ConnectionGUID:X-CSE-MsgGUID: X-IronPort-AV:X-IronPort-AV:Received:X-CSE-ConnectionGUID: X-CSE-MsgGUID:X-ExtLoop1:X-IronPort-AV:Received:Received:Received: Received:DKIM-Signature:Received:Received:Date:From:To:CC:Subject: Message-ID:References:Content-Type:Content-Disposition:In-Reply-To: X-ClientProxiedBy:MIME-Version:X-MS-PublicTrafficType: X-MS-TrafficTypeDiagnostic:X-MS-Office365-Filtering-Correlation-Id: X-MS-Exchange-SenderADCheck:X-MS-Exchange-AntiSpam-Relay: X-Microsoft-Antispam:X-Microsoft-Antispam-Message-Info: X-Forefront-Antispam-Report: X-MS-Exchange-AntiSpam-MessageData-ChunkCount: X-MS-Exchange-AntiSpam-MessageData-0:X-Exchange-RoutingPolicyChecked: X-MS-Exchange-CrossTenant-Network-Message-Id: X-MS-Exchange-CrossTenant-AuthSource:X-MS-Exchange-CrossTenant-AuthAs: X-MS-Exchange-CrossTenant-OriginalArrivalTime: X-MS-Exchange-CrossTenant-FromEntityHeader: X-MS-Exchange-CrossTenant-Id:X-MS-Exchange-CrossTenant-MailboxType: X-MS-Exchange-CrossTenant-UserPrincipalName: X-MS-Exchange-Transport-CrossTenantHeadersStamped:X-OriginatorOrg; bh=Sb5B9LD8RbeNIWFh0g4YmPvppNTDQVGxFVRRYCpov58=; b=oTDFD61haQEEkobzi5Wxl+CBVsQh1/6b6g4sz25x8vA7KVLvEQPwvZIoURNfnUgP+v0V XHcV5ZdtekivXMJLVo33ezYh/yj0zWSLfkWO1s/bV5W1Ddm0Ae6KR7c4DscJ7qftT0L+a lvvEEp15jU06B5dINFmYCniNSfV66E839acTf/7W5QJKBaGTX1C6/OpDo2ouGiW6f5mjS cgd5KZP1fg7mNpMzjSfeR+gFJ/OJlo+mOR+Knfcel1aQSdI4jyaTfNulPXc1k5erLSfT1 yWu8cLyd3NCPSkTi2G64owwvUiR8dQXwmAVF2hZr1Lc/2b7b2NuOBxAo2T6yFA8BohA== ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass header.from=intel.com; spf=pass smtp.mailfrom=intel.com; dkim=pass header.d=intel.com header.i=@intel.com header.a=rsa-sha256 header.s=Intel header.b=XS8WDBHs; dkim=pass header.d=intel.com header.i=@intel.com header.a=rsa-sha256 header.s=selector1 header.b=epzzlOM2; arc=pass header.oldest-pass=0 smtp.remote-ip=198.175.65.21 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.21]) (using TLSv1.2 with cipher ECDHE-ECDSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A7083606A331 for ; Thu, 19 Nov 2026 18:47:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org A7083606A331 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.a=rsa-sha256 header.s=Intel header.b=XS8WDBHs; dkim=pass (1024-bit key, unprotected) header.d=intel.com header.i=@intel.com header.a=rsa-sha256 header.s=selector1 header.b=epzzlOM2 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1795114056; x=1826650056; h=date:from:to:cc:subject:message-id:references: in-reply-to:mime-version; bh=R/fNRaNW/+iL8K45bbsXvVrljbSHeFH/2+2JIVDy3hY=; b=XS8WDBHsOzde2S2J9NDYr1Smi3ioQXrx743FBae9AI6z/C04tO6pW8q1 ICXo3BCel7OeWUc2domuNOFmVJG2pXt7mGzI2canYVUDEumMf+UaWdiOb G6WH22gBJJZgbxn+ZrsM4ExfFuZDoLpVtLxFAvNcmw4a7M3xODfddyVmU odezuokAPQgJvz+Iw8saguti8e4a3+H4eGOHlsGoAe27ct63DwBLeMbVz lPBbqG05U//dnsBzs24gLQ6s6BXYm3/Zq+4Sb+74nPk7TeuUqGyVniqv4 Eh98XREtn5DrIuHHQ3kjMAHZF4RbcR0JtMJvxyytwGbkd2pkbihJw9hei Q==; X-CSE-ConnectionGUID: bf4RBksUSL6lgFsYcrUrdg== X-CSE-MsgGUID: VSXUQ4G7TDGwy3jrqo413A== X-IronPort-AV: E=McAfee;i="6800,10657,11971"; a="4058137" X-IronPort-AV: E=Sophos;i="6.27,221,1787036400"; d="scan'208";a="4058137" Received: from fmviesa009.fm.intel.com ([10.60.135.149]) by orvoesa113.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 19 Nov 2026 10:47:35 -0800 X-CSE-ConnectionGUID: qi7RUY0aS1i2DJ/jUpMZbA== X-CSE-MsgGUID: fOZoOY5sR4mZfdZS/9K3uQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.27,221,1787036400"; d="scan'208";a="10835049" Received: from fmsmsx903.amr.corp.intel.com ([10.18.126.92]) by fmviesa009.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 19 Nov 2026 10:47:35 -0800 Received: from FMSMSX901.amr.corp.intel.com (10.18.126.90) by fmsmsx903.amr.corp.intel.com (10.18.126.92) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.2562.56; Thu, 19 Nov 2026 10:47:34 -0800 Received: from fmsedg903.ED.cps.intel.com (10.1.192.145) by FMSMSX901.amr.corp.intel.com (10.18.126.90) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.2562.56 via Frontend Transport; Thu, 19 Nov 2026 10:47:34 -0800 Received: from DM5PR21CU001.outbound.protection.outlook.com (52.101.62.13) by edgegateway.intel.com (192.55.55.83) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.2562.56; Thu, 19 Nov 2026 10:47:34 -0800 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=YgmNYMm2vQ2xm+4wp87gI3E5w7waaurl1tk9WxGKAdfz4SLG4eXUZ9/Fb3pqLIhsvNPw9Tkh07p+y1DTWYELbiA0qFGqhbSssl2X9aulPYbNdZax6sbnIq6AOIo52xesPvxHwrqH5Nbm/CU6S5Z6cBn1PxdUH31o7VEZLKOim2GrUU30Ild5S+9yWNgLpmcCRZ8Syrio9PkC4UA1+lczXAbgouGQvsYW/1ky1h4Ura4AoD9qMU6C0ojpFAhszhpGpmBM9iC8ZFaJhK+7ONXang+H2InVB+9++BI3MT84L5IApy2kk2P6tTogvHXGFzW8moz+J/AWP8sdftT5btKQIw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=Sb5B9LD8RbeNIWFh0g4YmPvppNTDQVGxFVRRYCpov58=; b=NPOL2y6F1n6zkPGlRSdregtuLQ4SWfKn0ssdMizy7pB4cLpttTbalXWyoFwWUaOcn+gdGHWdA4SuWVd64Bh75D+Ld3sGFt9iYvnmU+GzaLj6nu9M2EuomF/2eJBXQwzSpqxGVRxJ3gF43pRXS6VwmPgFKKyQ3mlcecDkUGXhA8P+Tz0lltSxcwRqeD/CruEy006sq3I9dVWWqSGQcCVOtzcBkAGn+wtdJK4Ipii8nmDF+u30D2Q3fiJUDcMvdwzdeyKfddLQJbkJtSbaxjxpz1AEETyOrmiAyBal6qUXBVxdv49Q8MCQUpMfsXQAxoIsxid82nBQU2SS2ZDlQQi7Og== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=intel.com; dmarc=pass action=none header.from=intel.com; dkim=pass header.d=intel.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=intel.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Sb5B9LD8RbeNIWFh0g4YmPvppNTDQVGxFVRRYCpov58=; b=epzzlOM2/xfgI28KNvG+GImxwMluaJoixoTcIIVNUaAdaZpGe3u43hMOp3KYkD9CIjoKHCsMNBIoQ3J/kA5WN5mX7dTZq9og9wgw4RJVACH4+LIkcCTk1G7EOXzHp3e2tH+L305+529KEcs1R4yU+pb8yNCb/YLGtyqIyNzPW7g= Authentication-Results: mx.microsoft.com 1; dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=intel.com; Received: from LV2PR11MB868673.namprd11.prod.outlook.com (2603:10b6:408:422::13) by CH3PR11MB8413.namprd11.prod.outlook.com (2603:10b6:610:170::8) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.21.615.14; Thu, 19 Nov 2026 18:47:25 +0000 Received: from LV2PR11MB868673.namprd11.prod.outlook.com ([fe80::5bfd:6afe:a9db:b7de]) by LV2PR11MB868673.namprd11.prod.outlook.com ([fe80::5bfd:6afe:a9db:b7de%4]) with mapi id 15.21.0615.013; Thu, 19 Nov 2026 18:47:24 +0000 Date: Thu, 19 Nov 2026 19:47:13 +0100 From: Maciej Fijalkowski To: Magnus Karlsson CC: , , , , , , , , , , , , , Subject: Re: [PATCH net-next 1/5] xsk: add USO support for skb path Message-ID: References: <20261119165340.1071525-1-magnus.karlsson@intel.com> <20261119165340.1071525-2-magnus.karlsson@intel.com> Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20261119165340.1071525-2-magnus.karlsson@intel.com> X-ClientProxiedBy: DU7P251CA0010.EURP251.PROD.OUTLOOK.COM (2603:10a6:10:551::27) To LV2PR11MB868673.namprd11.prod.outlook.com (2603:10b6:408:422::13) X-Mailing-List: netdev@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: LV2PR11MB868673:EE_|CH3PR11MB8413:EE_ X-MS-Office365-Filtering-Correlation-Id: 2bdb717e-2700-4742-7ee1-08df466d8d5b X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|1800799024|7416014|376014|366016|23010399003|261028144727099003|261022105027099003|261026140227099003|56012099006|11063799006|4143699003|261102123227099003|10067099003|261102130727099003|261021123027099003|261021121427099003|261022115727099003|261022113327099003|261022075727099003|261009223027099003|261026121527099003|22082099003|18002099003|6133799003|3023799007; X-Microsoft-Antispam-Message-Info: 4eoI0YvZTUyegPQGdxUE/XeqEVYSgdZQQNqM4tWSfJLxYA+hgIRCKkJCn4zLpAyj5g7oCdELoi0dFlWZAqQ/DbetqCvl9Z78amek/2m03lcMW7S3DnTnF6nbzk57UkqaxHDXiXvKvypS5ZNRVN5ywD0xwovBmwoWe0Q3ZQ536I1kMUgbVSLDBHt5ZnxIq+TNh3GXNyvjNm/uAp6zffCoVXb8BEagxsAZnnW+fjXtwMOk8NjW7+xy76BHeXQDFgPefPXrlUpVAFbXBntSReC+AM7+7k3ssQUaXFuxAPDk7FV5nEeKCDq+XOQ5vJU1gEV3x0U8GqqEgpQm4DS3kx2HNkYg6vtLBn35okaGC++fPll7TyPvt5P1dvfij/S4njIbjh29EuJMppg01sdZJRaBzohDz8Cd6QlhLJIYQGad8Zdfkr3x40zTzEYCEQtQVqbsBuh73PEgda/aTB+/N5KjCmIdUe36YbHr4BoqdcOBVuoHMgZ5rhO6YeKMd35shbFmfuI6eYzbznaZGLbpVLpQhYWWDFQ8FGSAP5GegfplWJUroh56tKuqJMLkGW7zM8cX3LDVRvGgh/r3cjroJFtPoeqSp8NmCgt0gqhXB/c+1P8dEuouwaS65a85JutBLnLvso107aBDsa2Ha+/HcBvVsnjbBgJ+hj+LHdY7b7wpc7Y= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:LV2PR11MB868673.namprd11.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(1800799024)(7416014)(376014)(366016)(23010399003)(261028144727099003)(261022105027099003)(261026140227099003)(56012099006)(11063799006)(4143699003)(261102123227099003)(10067099003)(261102130727099003)(261021123027099003)(261021121427099003)(261022115727099003)(261022113327099003)(261022075727099003)(261009223027099003)(261026121527099003)(22082099003)(18002099003)(6133799003)(3023799007);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?KYOYVcL0a3cWhj7vpQorGfnDbgTAdnLnvnFlLiwouEHBL1IrQsrzr1WomU5a?= =?us-ascii?Q?gnC4u6AkccSwvUO3o+j5A8n6z6VvKhGUYwY+lka7Q/h1ljyhcz6hZdOpZAyf?= =?us-ascii?Q?1k43q65/l7JGogbWgFXXYqPHAOPJbtd6HyZgJuUk/XUFXMUYmJP8WavrRztH?= =?us-ascii?Q?Zb1uDMLJoVehjuR1oO0vWS12sShC7NjjCvXlZigIS8SZXZTT725gqIUMmV0U?= =?us-ascii?Q?66l9ElvD+InLUm8FpjaXNoYZczASIpkNSp+SFp/gGwW72U/fgnHBfQM+q7VZ?= =?us-ascii?Q?otRMN/Q1+U1hONa1Wz/CDA4VVAYobsjIn3Qwaa57Lj6GPsLQG/9ZSlRQrGOz?= =?us-ascii?Q?HfSdEgln+PL4S2yqFSC+VL6Uzjq8RnVARIXrN1DrYgpcpqHcboV6hPBSzQpQ?= =?us-ascii?Q?zl0zVCg0InPX11zutSQ/eR4yLtZ+h17j/yTXe8fc9Lgq43TjDo9aMo9qIl6V?= =?us-ascii?Q?ZxldHvkKRyVkiYkTf0f6Qw9fJZhn/RLpbQnRAOz8yxIu3JRCy7QyJEo7w2Do?= =?us-ascii?Q?x+rni9CtEZKSf9tpw3By2eUinI1aV9XOE52yvlXrW9f9mfeTdiaIvhCUA0kN?= =?us-ascii?Q?t5ju8gFbd5P+LlQdiaa1owBgAmwI7Irq8fW4mGtdZWRMmV1Brw0V4Yam+LBN?= =?us-ascii?Q?XYOZS5xQTXKh0VLlX52KU6q/Pc0/KH59Sz0+yGujcHUt7UF4kp6+xS/P/O+b?= =?us-ascii?Q?v0Lw8DzfXY2fZzKgnaFcKtuRnkgB61Z1JlkYWLvdY0I1YWiGGMfONtaP3bTG?= =?us-ascii?Q?zJ4QPDFUrhISr3fCbjREyCP6ORmLoyMeNJNcqUM95S7uIjr+6K5hMpoh/0Q9?= =?us-ascii?Q?szQv3TYh9Mw5j8Zv4wL+GakTZlBxbopanzWGCt3S6XqajksAX4wrqM8H2bzb?= =?us-ascii?Q?mwxhi6abDeP7jrzMC7lBPhQe6wOyVzbJxNmvNmLUILF96Dup+K8VEMAJ7g3+?= =?us-ascii?Q?OLbrJKknhoQar/weZJWqsTdOT2Nl68sT4gU8VPgbGkbJXoYf8zfQ+rT6Qo2V?= =?us-ascii?Q?LLknY0CMXyycOre17RnM+bOFEXGUyRgC6tSgZ3azzwtEdtURITIydaQfVenX?= =?us-ascii?Q?55L/7DMMZiU9HADexXopQMl/f020pj/U5wxpo6P184jIyadaXh6gnYo2Ufb8?= =?us-ascii?Q?VTYfSGaB57YKxXbqvaxJlKrrjN17854opufHo3LWqQj2DvjlF6z/If+imnaW?= =?us-ascii?Q?KCoNAz/n+jymhtBRBDyTRrvBDNMPHcweDCCLMNB5bIgVeAo35463AtQdHBdT?= =?us-ascii?Q?7wZLb8qkdrgl1cjKAgitdQXR8OirGDR27gFYsRPET0baZj7mNMcLGs+5FG3C?= =?us-ascii?Q?lnZINkzNbSsdNjcJzY6bmKGoyrrRRoyfSCWi3brv67CNIri40t8WCyuOPiFx?= =?us-ascii?Q?RZg6cO4abD4KUXqIWAK6mWE7p68ZNl0YnT/E/yexjSO4VPQMyZdyxMB/JDm+?= =?us-ascii?Q?VAJppQk0YNlS7iYRLAJXySOKh5Ha96CBWcmHg5zzgOCEoXKptSWVxyY3WV1Y?= =?us-ascii?Q?Ow9DXdoCIGqQWASraG/TGeoposErIKe6ABITWbgumyws5MEiHSRLlgjg+I3y?= =?us-ascii?Q?QL/+6OGlZg8qM4rftTx4P6LYVI5aaIyoc3UtDBdLWXTgR+8s9M+lie7UsUOu?= =?us-ascii?Q?uSgdV+TxmT4NOCiCiRsawGtEF+WqvuK/+a+z1WX8FXstUHShFurL9c5lyK3r?= =?us-ascii?Q?prRTEIS5XToQBO3FLKme8ONs+IljeEzCBMfDr2ZgEAnUBRPKbE23YKi0mSeE?= =?us-ascii?Q?mcFp1sLyBxcd8XuLMrhSCUAQOjePuTc=3D?= X-Exchange-RoutingPolicyChecked: uxHj2SakvfEEVtp4E4YiSoZlgbgiDC3dYQYKNXS+E9KSeezwdTT9unoegDj+6E6HR1CA6gMBkadK5G1/mjyNKceLzQI8zcAOUNstkxhuafk5wonZgdHoWsEBjOKEj9mlyVrIPj7xbAY+Bp6lS+S7ujQrky+yq3q4KJTIAtLyolg6Hx29GVxt4F4lTA6SLbdRm9g2HfJ1gz/AzhTgX9GDXMaFHzBM4qEG9kLThOKnmq06Zwc4ikoovP8qgbGyiC+YPnYpHMMKUGQN/pBub0ytvYs03MMZ9lstJqdiRV2gD+tJe0KzgM4NAXDxE6VdUtkl7/1p7qEqB37OYqNhiV9NAQ== X-MS-Exchange-CrossTenant-Network-Message-Id: 2bdb717e-2700-4742-7ee1-08df466d8d5b X-MS-Exchange-CrossTenant-AuthSource: LV2PR11MB868673.namprd11.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 19 Nov 2026 18:47:24.8489 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 46c98d88-e344-4ed4-8496-4ed7712e255d X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: 4Rd0zmRNFtJ4nQ0GY59x0sNOmSoT9EhgSxvIFFPj51yxCHKOP2r9mNE7ef3xqujCQbSq+pH8lWL88xPIs7jvUMeaoS044pAW90KY0Eo0XP8= X-MS-Exchange-Transport-CrossTenantHeadersStamped: CH3PR11MB8413 X-OriginatorOrg: intel.com On Thu, Nov 19, 2026 at 05:53:36PM +0100, Magnus Karlsson wrote: > Add UDP Segmentation Offload (USO) to the AF_XDP Tx metadata interface > and implement it for copy mode. An application submits one Ethernet > frame holding a single IP and UDP header followed by the aggregate UDP > payload, and the device emits a train of MTU-sized UDP datagrams. > > The uAPI adds the XDP_TXMD_FLAGS_USO flag and splits the reserved u32 > in the request part of struct xsk_tx_metadata into two u16 fields: > gso_size, the UDP payload bytes per output datagram, and > network_offset, the IP header offset. USO requires > XDP_TXMD_FLAGS_CHECKSUM, with csum_start pointing at the UDP header, > csum_offset at its checksum field and the checksum field seeded with > the partial pseudoheader checksum of the aggregate packet. It cannot > be combined with XDP_TXMD_FLAGS_TIMESTAMP or > XDP_UMEM_TX_SW_CSUM. Launch time is supported and applies to the start > of the segmented packet. > > The request is turned into a GSO skb of type SKB_GSO_UDP_L4. Before > transmission, the headers are validated. The link layer is not parsed: > the IP header starts at network_offset and its version selects > unfragmented IPv4 or IPv6 without extension headers, followed by UDP. > The IP and UDP lengths must describe the aggregate packet, every output > datagram must fit the MTU, and the number of segments is limited to > UDP_MAX_SEGMENTS. As skb drivers find L3 through the EtherType, the skb > path also requires the EtherType, after any VLAN tags, to lead to the > same IP header. A request that fits in one datagram is sent as an > ordinary checksum offload request. > > network_offset is part of the uAPI because csum_start only locates L4, > while segmentation also needs the start of L3: the device rewrites the > IP header of every datagram and needs the L2 and L3 lengths, and on > the skb path it becomes the network header. With it, the kernel does > not need to understand the link layer, and the fields can be reused > later. Any future tunnel segmentation extension to the uAPI could then > treat network_offset as the outer L3 offset and csum_start as the > inner L4 offset, adding only the outer L4 and inner L3 offsets. > > AF_XDP never segments these packets itself. A request that produces more > than one datagram is rejected unless the bound device advertises > NETIF_F_GSO_UDP_L4, and the GSO skb is passed to its driver unsegmented. > As with UDP_SEGMENT sockets, how the segmentation is carried out is up > to the driver. Stacked devices such as VLAN or bonding forward the > packet to a lower device that may segment it in software. > > A new pool field, tx_uso_supported, records whether USO requests are > accepted on a pool. It is set only for Ethernet devices (ARPHRD_ETHER) > and is cleared when XDP_UMEM_TX_SW_CSUM is used. > > A USO request that fails validation is dropped: its buffers are > completed and counted in tx_invalid_descs. Errors in other Tx metadata > keep failing sendmsg() and leave the descriptor on the Tx ring, so the > existing behaviour for non-USO requests is unchanged. A USO request > that cannot be processed for lack of memory is also left on the Tx > ring, and sendmsg() fails with -EAGAIN, unless part of it was already > released to user space, either by an earlier call or while peeking > further descriptors. That part may already have been reused, so the > request is then dropped. > > The header validator works on a raw header copy instead of an skb, so > that the zero-copy path in a later patch can reuse it. It lives in > the new files net/xdp/xsk_tx_uso.c and include/net/xsk_tx_uso.h. > > Signed-off-by: Magnus Karlsson Hmm - this looks good to me! Reviewed-by: Maciej Fijalkowski I only had minor comments/questions. > --- > Documentation/networking/xsk-tx-metadata.rst | 91 +++++++++++++ > MAINTAINERS | 1 + > include/net/xdp_sock_drv.h | 12 ++ > include/net/xsk_buff_pool.h | 4 + > include/net/xsk_tx_uso.h | 30 +++++ > include/uapi/linux/if_xdp.h | 13 +- > net/xdp/Makefile | 1 + > net/xdp/xsk.c | 130 +++++++++++++++++-- > net/xdp/xsk_buff_pool.c | 4 + > net/xdp/xsk_queue.h | 6 + > net/xdp/xsk_tx_uso.c | 77 +++++++++++ > tools/include/uapi/linux/if_xdp.h | 13 +- > 12 files changed, 371 insertions(+), 11 deletions(-) > create mode 100644 include/net/xsk_tx_uso.h > create mode 100644 net/xdp/xsk_tx_uso.c > > diff --git a/Documentation/networking/xsk-tx-metadata.rst b/Documentation/networking/xsk-tx-metadata.rst > index ac15e5fddc6b..41cfc5482b15 100644 > --- a/Documentation/networking/xsk-tx-metadata.rst > +++ b/Documentation/networking/xsk-tx-metadata.rst > @@ -55,6 +55,9 @@ The flags field enables the particular offload: > packet for transmission at a pre-determined time called launch time. The > value of launch time is indicated by ``request.launch_time`` field of > ``struct xsk_tx_metadata``. > +- ``XDP_TXMD_FLAGS_USO``: requests UDP segmentation offload. > + ``request.gso_size`` specifies UDP payload bytes per output datagram; > + ``request.network_offset`` identifies the IP header. > > Besides the flags above, in order to trigger the offloads, the first > packet's ``struct xdp_desc`` descriptor should set ``XDP_TX_METADATA`` > @@ -70,6 +73,69 @@ In this case, when running in ``XDP_COPY`` mode, the TX checksum > is calculated on the CPU. Do not enable this option in production because > it will negatively affect performance. > > +UDP Segmentation > +================ > + > +To request UDP segmentation offload (USO), bind the socket in > +``XDP_COPY`` mode and set ``XDP_TXMD_FLAGS_USO | XDP_TXMD_FLAGS_CHECKSUM`` > +in the Tx metadata. Reserve at least 16 bytes of metadata and set > +``XDP_TX_METADATA`` on the first descriptor of the packet. > + > +Submit an Ethernet frame containing one IP header, one UDP header, and the > +aggregate UDP payload. Set ``request.network_offset`` to the IP header > +offset, ``request.csum_start`` to the UDP header offset, and > +``request.csum_offset`` to the UDP checksum field offset (6 bytes). > +Header offsets are measured from the first descriptor's packet-data address, > +excluding metadata. Set ``request.gso_size`` to the number of UDP payload > +bytes per output datagram, excluding headers; the last datagram may be > +shorter. > + > +USO is only available on Ethernet devices. ``request.network_offset`` > +locates the IP header, and its version selects IPv4 or IPv6. In copy mode, > +the EtherType, after up to six VLAN tags, must lead to the same IP header, > +since drivers rely on it. IPv4 headers may carry options but must not be > +fragmented. In IPv6, the UDP header must directly follow the fixed header; > +extension headers are not supported. > + > +The IP and UDP lengths must describe the aggregate packet. Initialize the > +UDP checksum field with the partial pseudoheader checksum seed for that > +packet. The device generates the per-datagram lengths and UDP checksums and, > +for IPv4 segmentation, the IP header checksums. Supply a valid IPv4 header > +checksum as well, since a request that fits in one datagram uses ordinary > +checksum offload without segmentation. > + > +All headers through UDP must be in the first buffer. Multi-buffer packets > +use ``XDP_USE_SG`` and ``XDP_PKT_CONTD``, with metadata only on the first > +descriptor. Each output IP packet must fit the device MTU, and requests > +remain subject to the device's segmentation limits. Query > +``tx-udp-segmentation`` through ethtool to check whether skb UDP segmentation > +offload is enabled. > + > +AF_XDP never segments the packet itself. In copy mode, a request that > +produces more than one datagram is rejected unless the bound device > +advertises UDP segmentation offload, and the packet is passed to its driver > +unsegmented. A request that fits in one datagram does not need the offload, > +so its success does not show that the device supports USO. As with > +``UDP_SEGMENT`` sockets, how the segmentation is carried out is up to the > +driver, which may build the per-datagram headers in software. Stacked > +devices such as VLAN, bonding, or macvlan advertise UDP segmentation > +regardless of the lower device and forward the packet through the lower > +device's qdisc, where it is segmented in software if the lower device lacks > +the offload. > + > +A USO request that is rejected is dropped: its buffers are returned > +through the completion ring and counted in the socket's ``tx_invalid_descs`` > +statistic. This is the only indication of the failure, whatever its cause: > +invalid metadata or headers, the MTU, segmentation limits, or a device > +without the offload. A request that cannot be processed for lack of memory > +is instead left on the Tx ring, and ``sendmsg()`` fails with ``EAGAIN``, > +unless part of a multi-buffer request was already released to user space; > +it is then dropped. Errors in other Tx metadata also fail ``sendmsg()`` and > +leave the descriptor on the Tx ring. > + > +USO cannot be combined with ``XDP_UMEM_TX_SW_CSUM`` or > +``XDP_TXMD_FLAGS_TIMESTAMP``. > + > Launch Time > =========== > > @@ -127,6 +193,31 @@ cycle time is set to 1 second, the horizon of the launch time ranges > from 1 second to 2 seconds, depending on where the Qbv cycle is currently > running. > > +USO with launch time > +==================== > + > +Add ``XDP_TXMD_FLAGS_LAUNCH_TIME`` to the USO and checksum flags and set > +``request.launch_time`` to schedule the segmented packet. This combination > +requires at least 24 bytes of Tx metadata. > + > +The launch time applies to the start of the segmented packet: the first > +output UDP datagram is scheduled, and subsequent datagrams follow according > +to the device's scheduling rules. This does not request per-datagram pacing > +or separate launch times. > + > +The skb path passes one unsegmented GSO skb and its launch time directly to > +the bound device's driver, bypassing that device's qdisc, including ETF. > +On stacked devices, the lower device's qdisc and software segmentation > +may still apply, as described above. The driver and selected queue > +must support UDP segmentation and launch time together. Separate support > +for either offload does not establish support for their combination. > +As with ordinary launch-time requests, drivers may ignore the time when > +scheduling is disabled or unsupported. Acceptance or Tx completion alone > +does not prove that a packet was transmitted at the requested time. > + > +The clock, queue configuration, and scheduling horizon requirements above > +also apply to USO launch-time requests. > + > Querying Device Capabilities > ============================ > > diff --git a/MAINTAINERS b/MAINTAINERS > index 40bb77cbc6b0..9b5f6f307d53 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -30588,6 +30588,7 @@ F: Documentation/networking/af_xdp.rst > F: include/net/netns/xdp.h > F: include/net/xdp_sock* > F: include/net/xsk_buff_pool.h > +F: include/net/xsk_tx_uso.h > F: include/uapi/linux/if_xdp.h > F: include/uapi/linux/xdp_diag.h > F: net/xdp/ > diff --git a/include/net/xdp_sock_drv.h b/include/net/xdp_sock_drv.h > index a40ad3f90f13..6b5bb7b29f87 100644 > --- a/include/net/xdp_sock_drv.h > +++ b/include/net/xdp_sock_drv.h > @@ -263,6 +263,7 @@ xsk_buff_raw_get_ctx(const struct xsk_buff_pool *pool, u64 addr, u32 options) > XDP_TXMD_FLAGS_TIMESTAMP | \ > XDP_TXMD_FLAGS_CHECKSUM | \ > XDP_TXMD_FLAGS_LAUNCH_TIME | \ > + XDP_TXMD_FLAGS_USO | \ > 0) > > static inline bool > @@ -270,6 +271,10 @@ xsk_buff_valid_tx_metadata(const struct xsk_buff_pool *pool, > const struct xsk_tx_metadata *meta, u64 *flags) > { > *flags = READ_ONCE(meta->flags); > + if (*flags & XDP_TXMD_FLAGS_USO) > + if (!pool->tx_uso_supported || pool->tx_metadata_len < > + offsetofend(struct xsk_tx_metadata, request.network_offset)) > + return false; > if (*flags & XDP_TXMD_FLAGS_LAUNCH_TIME) > if (pool->tx_metadata_len < > offsetofend(struct xsk_tx_metadata, request.launch_time)) > @@ -277,6 +282,13 @@ xsk_buff_valid_tx_metadata(const struct xsk_buff_pool *pool, > return !(*flags & ~XDP_TXMD_FLAGS_VALID); > } > > +/* USO requires checksum offload and cannot report a Tx timestamp. */ > +static inline bool xsk_tx_uso_flags_valid(u64 flags) > +{ > + return (flags & XDP_TXMD_FLAGS_CHECKSUM) && > + !(flags & XDP_TXMD_FLAGS_TIMESTAMP); > +} > + > /** > * xsk_tx_metadata_request - Evaluate AF_XDP TX metadata at submission > * and call appropriate xsk_tx_metadata_ops operation. > diff --git a/include/net/xsk_buff_pool.h b/include/net/xsk_buff_pool.h > index 02e89350faf9..ea2ff3680efa 100644 > --- a/include/net/xsk_buff_pool.h > +++ b/include/net/xsk_buff_pool.h > @@ -89,6 +89,10 @@ struct xsk_buff_pool { > bool uses_need_wakeup; > bool unaligned; > bool tx_sw_csum; > + /* USO requests accepted: Ethernet device without SW checksum, and > + * driver support in zero-copy mode. Set when the pool is bound. > + */ > + bool tx_uso_supported; > void *addrs; > /* Mutual exclusion of the completion ring in the SKB mode. > * Protect: NAPI TX thread and sendmsg error paths in the SKB > diff --git a/include/net/xsk_tx_uso.h b/include/net/xsk_tx_uso.h > new file mode 100644 > index 000000000000..f23384077712 > --- /dev/null > +++ b/include/net/xsk_tx_uso.h > @@ -0,0 +1,30 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +#ifndef _NET_XSK_TX_USO_H > +#define _NET_XSK_TX_USO_H > + > +#include > +#include > +#include > + > +/* Header offsets are relative to the start of the supplied Ethernet frame. */ > +struct xsk_tx_uso_info { > + struct xsk_tx_metadata metadata; > + u32 len; > + u16 header_len; > + u16 gso_segs; > + __be16 protocol; > + u8 l4_protocol; > +}; > + > +#ifdef CONFIG_XDP_SOCKETS > +int xsk_tx_uso_validate(const void *header, struct xsk_tx_uso_info *uso, > + u32 mtu); > +#else > +static inline int > +xsk_tx_uso_validate(const void *header, struct xsk_tx_uso_info *uso, u32 mtu) > +{ > + return -EOPNOTSUPP; > +} > +#endif > + > +#endif > diff --git a/include/uapi/linux/if_xdp.h b/include/uapi/linux/if_xdp.h > index 50d67df78911..0f7ba4859218 100644 > --- a/include/uapi/linux/if_xdp.h > +++ b/include/uapi/linux/if_xdp.h > @@ -134,6 +134,12 @@ struct xdp_options { > */ > #define XDP_TXMD_FLAGS_LAUNCH_TIME (1 << 2) > > +/* Request UDP segmentation offload in XDP_COPY mode. Requires CHECKSUM. > + * Segment size and IP header offset are in request. > + * With LAUNCH_TIME, scheduling applies to the start of the segmented packet. > + */ > +#define XDP_TXMD_FLAGS_USO (1 << 3) > + > /* AF_XDP offloads request. 'request' union member is consumed by the driver > * when the packet is being transmitted. 'completion' union member is > * filled by the driver when the transmit completion arrives. > @@ -149,7 +155,12 @@ struct xsk_tx_metadata { > __u16 csum_start; > /* Offset from csum_start where checksum should be stored. */ > __u16 csum_offset; > - __u32 reserved; > + > + /* XDP_TXMD_FLAGS_USO */ > + /* UDP payload bytes per output datagram. */ > + __u16 gso_size; > + /* IP header offset from desc->addr. */ > + __u16 network_offset; > > /* XDP_TXMD_FLAGS_LAUNCH_TIME */ > /* Launch time in nanosecond against the PTP HW Clock */ > diff --git a/net/xdp/Makefile b/net/xdp/Makefile > index 30cdc4315f42..b6109e0e5547 100644 > --- a/net/xdp/Makefile > +++ b/net/xdp/Makefile > @@ -1,4 +1,5 @@ > # SPDX-License-Identifier: GPL-2.0-only > obj-$(CONFIG_XDP_SOCKETS) += xsk.o xdp_umem.o xsk_queue.o xskmap.o > obj-$(CONFIG_XDP_SOCKETS) += xsk_buff_pool.o > +obj-$(CONFIG_XDP_SOCKETS) += xsk_tx_uso.o > obj-$(CONFIG_XDP_SOCKETS_DIAG) += xsk_diag.o > diff --git a/net/xdp/xsk.c b/net/xdp/xsk.c > index f22f9a2cdbbe..14be62b8de5f 100644 > --- a/net/xdp/xsk.c > +++ b/net/xdp/xsk.c > @@ -11,6 +11,8 @@ > > #define pr_fmt(fmt) "AF_XDP: %s: " fmt, __func__ > > +#include > +#include > #include > #include > #include > @@ -22,6 +24,7 @@ > #include > #include > #include > +#include > #include > #include > > @@ -31,6 +34,7 @@ > #include > #include > #include > +#include > > #include "../core/dev.h" > > @@ -986,12 +990,62 @@ static void xsk_drop_skb(struct sk_buff *skb) > xs->skb = NULL; > } > > +static int xsk_skb_uso(struct sk_buff *skb) > +{ > + struct xsk_tx_uso_info uso = { > + .metadata.request = { > + .gso_size = skb_shinfo(skb)->gso_size, > + .csum_start = skb_transport_offset(skb), > + .network_offset = skb_network_offset(skb), > + }, > + .header_len = skb_transport_offset(skb) + sizeof(struct udphdr), > + .len = skb->len, > + }; > + int depth, err; > + > + /* Best effort: a bond or team device can change type while the pool > + * is bound, also after this check. > + */ > + if (READ_ONCE(skb->dev->type) != ARPHRD_ETHER) > + return -EINVAL; > + if (!pskb_may_pull(skb, uso.header_len)) > + return -ENOMEM; > + > + err = xsk_tx_uso_validate(skb->data, &uso, READ_ONCE(skb->dev->mtu)); > + if (err) > + return err; > + > + skb_reset_mac_header(skb); > + skb->protocol = eth_hdr(skb)->h_proto; > + /* skb drivers find L3 through the EtherType and VLAN tags. Parse them > + * from the end of the Ethernet header, not from network_offset. > + */ > + skb->mac_len = ETH_HLEN; > + if (__vlan_get_protocol(skb, skb->protocol, &depth) != uso.protocol || > + depth != skb_network_offset(skb)) > + return -EINVAL; > + skb_reset_mac_len(skb); > + if (uso.gso_segs == 1) { > + skb_gso_reset(skb); > + return 0; > + } > + > + skb_shinfo(skb)->gso_segs = uso.gso_segs; > + if (netif_needs_gso(skb, netif_skb_features(skb))) > + return -EOPNOTSUPP; > + > + return 0; > +} > + > +/* A failed USO request returns -EOVERFLOW, so that the packet is dropped. Other > + * metadata errors are returned to user space. > + */ > static int xsk_skb_metadata(struct sk_buff *skb, void *buffer, > struct xdp_desc *desc, struct xsk_buff_pool *pool, > u32 hr) > { > struct xsk_tx_metadata *meta = NULL; > - u16 csum_start, csum_offset; > + int err = -EINVAL; > u64 flags; > > if (unlikely(pool->tx_metadata_len == 0)) > @@ -999,18 +1053,43 @@ static int xsk_skb_metadata(struct sk_buff *skb, void *buffer, > > meta = buffer - pool->tx_metadata_len; > if (unlikely(!xsk_buff_valid_tx_metadata(pool, meta, &flags))) > - return -EINVAL; > + goto err; > + > + if (flags & XDP_TXMD_FLAGS_USO) { > + u16 nhoff = READ_ONCE(meta->request.network_offset); > + u16 offset = READ_ONCE(meta->request.csum_offset); > + u16 thoff = READ_ONCE(meta->request.csum_start); > + u16 size = READ_ONCE(meta->request.gso_size); > + > + if (!xsk_tx_uso_flags_valid(flags)) > + goto err; > + if (!size || size == GSO_BY_FRAGS || > + nhoff < ETH_HLEN || thoff < nhoff || > + thoff + sizeof(struct udphdr) > desc->len || > + offset != offsetof(struct udphdr, check) || > + hr + thoff >= U16_MAX) > + goto err; > + > + skb_set_network_header(skb, nhoff); > + skb_set_transport_header(skb, thoff); > + skb_shinfo(skb)->gso_size = size; > + skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4; > + } > > if (flags & XDP_TXMD_FLAGS_CHECKSUM) { > - csum_start = READ_ONCE(meta->request.csum_start); > - csum_offset = READ_ONCE(meta->request.csum_offset); > + if (flags & XDP_TXMD_FLAGS_USO) { you're doing it like this as you still want to execute XDP_TXMD_FLAGS_CHECKSUM which is present for USO, ok. > + skb->csum_start = skb_transport_offset(skb); > + skb->csum_offset = offsetof(struct udphdr, check); > + } else { > + skb->csum_start = READ_ONCE(meta->request.csum_start); > + skb->csum_offset = READ_ONCE(meta->request.csum_offset); > + } > > - if (unlikely(csum_start + csum_offset + > + if (unlikely(skb->csum_start + skb->csum_offset + > sizeof(__sum16) > desc->len)) > - return -EINVAL; > + goto err; > > - skb->csum_start = hr + csum_start; > - skb->csum_offset = csum_offset; > + skb->csum_start += hr; > skb->ip_summed = CHECKSUM_PARTIAL; > } > > @@ -1021,6 +1100,9 @@ static int xsk_skb_metadata(struct sk_buff *skb, void *buffer, > xsk_tx_metadata_to_compl(meta, &skb_shinfo(skb)->xsk_meta); > > return 0; > + > +err: > + return flags & XDP_TXMD_FLAGS_USO ? -EOVERFLOW : err; could you stick to explicit returns maybe and be consistent with rest of flags? > } > > static int xsk_skb_sw_csum(struct sk_buff *skb, struct xsk_buff_pool *pool) > @@ -1108,6 +1190,10 @@ static struct sk_buff *xsk_build_skb_zerocopy(struct xdp_sock *xs, > return skb; > } > > +/* On -EOVERFLOW, the packet was dropped and its descriptors were consumed and > + * completed as invalid. Other errors leave the descriptor on the Tx ring for > + * the application to retry. > + */ > static struct sk_buff *xsk_build_skb(struct xdp_sock *xs, > struct xdp_desc *desc) > { > @@ -1196,13 +1282,17 @@ static struct sk_buff *xsk_build_skb(struct xdp_sock *xs, > if (skb && !xs->skb) > kfree_skb(skb); > > + /* Too many descriptors and invalid USO requests drop the packet. Only > + * the latter can fail on the first descriptor, which is completed > + * here. Other errors are returned so that the application can retry. > + */ > if (err == -EOVERFLOW) { > if (xs->skb) { > /* Drop the packet */ > xsk_inc_num_desc(xs->skb); > xsk_drop_skb(xs->skb); > } else { > - xsk_cq_cancel_locked(xs->pool, 1); > + xsk_cq_submit_addr_single_locked(xs->pool, desc); > xs->tx->invalid_descs++; > } > xskq_cons_release(xs->tx); > @@ -1279,6 +1369,28 @@ static int __xsk_generic_xmit(struct sock *sk) > continue; > } > > + if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4) { > + err = xsk_skb_uso(skb); > + /* Descriptors already released to user space may be > + * reused, so the packet can only be put back if none > + * of them has been released. Otherwise it is dropped. This is the only part i don't follow. > + */ > + if (err == -ENOMEM && > + xskq_cons_nb_unreleased(xs->tx) >= > + xsk_get_num_desc(skb)) { > + /* Tell user-space to retry the send */ > + xskq_cons_cancel_n(xs->tx, xsk_get_num_desc(skb)); > + xsk_consume_skb(skb); > + err = -EAGAIN; > + goto out; > + } > + if (err) { > + xsk_drop_skb(skb); > + err = 0; > + continue; > + } > + } > + > err = xsk_skb_sw_csum(skb, xs->pool); > if (unlikely(err)) { > xsk_drop_skb(skb); > diff --git a/net/xdp/xsk_buff_pool.c b/net/xdp/xsk_buff_pool.c > index 5ec092f7cb6f..e62f3c2b3362 100644 > --- a/net/xdp/xsk_buff_pool.c > +++ b/net/xdp/xsk_buff_pool.c > @@ -1,5 +1,6 @@ > // SPDX-License-Identifier: GPL-2.0 > > +#include > #include > #include > #include > @@ -192,6 +193,8 @@ int xp_assign_dev(struct xsk_buff_pool *pool, > err = xsk_reg_pool_at_qid(netdev, pool, queue_id); > if (err) > return err; > + pool->tx_uso_supported = !pool->tx_sw_csum && > + netdev->type == ARPHRD_ETHER; > > if (mbuf) > pool->umem->flags |= XDP_UMEM_SG_FLAG; > @@ -260,6 +263,7 @@ int xp_assign_dev(struct xsk_buff_pool *pool, > goto err_unreg_xsk; > } > pool->umem->zc = true; > + pool->tx_uso_supported = false; I assume this will be lifted on later patch > pool->xdp_zc_max_segs = netdev->xdp_zc_max_segs; > return 0; > > diff --git a/net/xdp/xsk_queue.h b/net/xdp/xsk_queue.h > index 1bc42c8902f4..182cd1cccb74 100644 > --- a/net/xdp/xsk_queue.h > +++ b/net/xdp/xsk_queue.h > @@ -390,6 +390,12 @@ static inline void xskq_cons_release(struct xsk_queue *q) > q->cached_cons++; > } > > +/* Entries consumed locally but not yet released to the producer. */ > +static inline u32 xskq_cons_nb_unreleased(struct xsk_queue *q) > +{ > + return q->cached_cons - q->ring->consumer; READ_ONCE(q->ring->consumer) ? > +} > + > static inline void xskq_cons_cancel_n(struct xsk_queue *q, u32 cnt) > { > q->cached_cons -= cnt; > diff --git a/net/xdp/xsk_tx_uso.c b/net/xdp/xsk_tx_uso.c > new file mode 100644 > index 000000000000..a7313ade1092 > --- /dev/null > +++ b/net/xdp/xsk_tx_uso.c > @@ -0,0 +1,77 @@ > +// SPDX-License-Identifier: GPL-2.0 > +#include > +#include > +#include > +#include > + > +/** > + * xsk_tx_uso_validate - validate a kernel-owned plain UDP header > + * @header: kernel-owned buffer containing at least uso->header_len bytes > + * @uso: packet length and metadata offsets; receives protocol and segment count > + * @mtu: maximum output IP packet length > + * > + * The link-layer header is not parsed. The IP header starts at network_offset > + * and its version selects IPv4 or IPv6. The caller must provide a nonzero > + * gso_size other than GSO_BY_FRAGS and header_len equal to transport_offset > + * plus the UDP header size. > + * > + * Return: zero on success or a negative error code. > + */ > +int xsk_tx_uso_validate(const void *header, struct xsk_tx_uso_info *uso, > + u32 mtu) > +{ > + const struct xsk_tx_metadata *meta = &uso->metadata; > + u32 nhoff = meta->request.network_offset; > + u32 thoff = meta->request.csum_start; > + u32 udp_len, payload_len, network_len; > + const struct udphdr *uh; > + __be16 protocol; > + > + if (nhoff < ETH_HLEN || thoff <= nhoff || uso->header_len < thoff || > + uso->len < uso->header_len) > + return -EINVAL; > + > + network_len = uso->len - nhoff; > + switch (((const struct iphdr *)(header + nhoff))->version) { > + case 4: { > + const struct iphdr *iph = header + nhoff; > + > + if (thoff - nhoff < sizeof(*iph) || > + iph->ihl < 5 || iph->ihl * 4 != thoff - nhoff || > + ip_is_fragment(iph) || > + ntohs(iph->tot_len) != network_len) question: i keep on seeing this validation of iphdr - don't we have somewhere a generic routine for that? > + return -EINVAL; > + protocol = htons(ETH_P_IP); > + uso->l4_protocol = iph->protocol; > + break; > + } > + case 6: { > + const struct ipv6hdr *ip6h = header + nhoff; > + > + if (thoff - nhoff != sizeof(*ip6h) || > + ntohs(ip6h->payload_len) != network_len - sizeof(*ip6h)) > + return -EINVAL; > + protocol = htons(ETH_P_IPV6); > + uso->l4_protocol = ip6h->nexthdr; > + break; > + } > + default: > + return -EPROTONOSUPPORT; > + } > + uso->protocol = protocol; > + udp_len = uso->len - thoff; > + uh = header + thoff; > + if (uso->l4_protocol != IPPROTO_UDP || udp_len > U16_MAX || > + ntohs(uh->len) != udp_len) > + return -EINVAL; nit: i think you should start with this validation? > + payload_len = udp_len - sizeof(*uh); > + if (payload_len > meta->request.gso_size * UDP_MAX_SEGMENTS || > + uso->header_len - nhoff + > + min_t(u32, payload_len, meta->request.gso_size) > mtu) > + return -EINVAL; > + > + uso->gso_segs = max_t(u32, 1, DIV_ROUND_UP(payload_len, > + meta->request.gso_size)); > + return 0; > +} > +EXPORT_SYMBOL_GPL(xsk_tx_uso_validate); > diff --git a/tools/include/uapi/linux/if_xdp.h b/tools/include/uapi/linux/if_xdp.h > index 50d67df78911..0f7ba4859218 100644 > --- a/tools/include/uapi/linux/if_xdp.h > +++ b/tools/include/uapi/linux/if_xdp.h > @@ -134,6 +134,12 @@ struct xdp_options { > */ > #define XDP_TXMD_FLAGS_LAUNCH_TIME (1 << 2) > > +/* Request UDP segmentation offload in XDP_COPY mode. Requires CHECKSUM. > + * Segment size and IP header offset are in request. > + * With LAUNCH_TIME, scheduling applies to the start of the segmented packet. > + */ > +#define XDP_TXMD_FLAGS_USO (1 << 3) > + > /* AF_XDP offloads request. 'request' union member is consumed by the driver > * when the packet is being transmitted. 'completion' union member is > * filled by the driver when the transmit completion arrives. > @@ -149,7 +155,12 @@ struct xsk_tx_metadata { > __u16 csum_start; > /* Offset from csum_start where checksum should be stored. */ > __u16 csum_offset; > - __u32 reserved; > + > + /* XDP_TXMD_FLAGS_USO */ > + /* UDP payload bytes per output datagram. */ > + __u16 gso_size; > + /* IP header offset from desc->addr. */ > + __u16 network_offset; > > /* XDP_TXMD_FLAGS_LAUNCH_TIME */ > /* Launch time in nanosecond against the PTP HW Clock */ > -- > 2.38.1 >