From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id B1E6C425D5; Mon, 18 Sep 2023 13:02:58 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 9F13040263; Mon, 18 Sep 2023 13:02:58 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 683224021F for ; Mon, 18 Sep 2023 13:02:57 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 38HMgC58031893; Mon, 18 Sep 2023 04:02:56 -0700 Received: from nam11-dm6-obe.outbound.protection.outlook.com (mail-dm6nam11lp2172.outbound.protection.outlook.com [104.47.57.172]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 3t5bvkku6p-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 18 Sep 2023 04:02:56 -0700 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=KRma0KPl75Tu+lNPuMOZ+YQGZP/POv+hJRa3shKYETchbBpQvXsawfvdacKH9IoR8+yh42v13uwvAh5k0R8cIFzWS2PBKLESwF5LyeWXGmLJdmA6oQ1W633nF5RX2KBMxqIagCNJDsCMpTxG93AhIz8XXqg7aD9yc/7cBF//q3L3wlrdLKEvNH3vb2BycPvMBBvMXjLM2iNzONqegfeLfdvqypOla6sgjkVahu45qkMZAN8Aq3+zcqDl+N9fxjixc06wg9AQ7tlm2YGvQmftNX03XozcJT1JXXqBXgwpkIySni1WZ2vdMy8732p+TU1ks2lmpPO/4gLKO3TPBHTqzQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=n+mGsN0GSCrxexhhNE4o9/lz/D7B/EsUfQ7uebw8SVU=; b=Os8K8FfGrOwqiIuIAPZd7M6ygf++eAn0e+wnp7z15L1gejRwSSyahvltPJ63pQJCrbJPpKYpOYmWluGHh0Je/1rX2658oZMUhU/TNeL6XHbBQAMrYnQcMCNbX3AuxyjKJSRCijfqtB1ATF/+nNM2Xxb5F15GviJmYYILpIO/TsFIXztDktjtthAH3hi/B647/dU6f/fDCdIlXALjfVfk/NEcd8B8c+9ZDulU70za5GZF18WdI7fjFjqYMm4xfnwKJzbqXp6aydAHFNqOBAUNfnd3Dip0+gQ768vwsk1ehm8SBHgsxYHNaL/OEJvCjH0V2u6dRbdeKl3vlEWU0AGcMw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=marvell.com; dmarc=pass action=none header.from=marvell.com; dkim=pass header.d=marvell.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.onmicrosoft.com; s=selector1-marvell-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=n+mGsN0GSCrxexhhNE4o9/lz/D7B/EsUfQ7uebw8SVU=; b=txhHV7R00ZUGD+lzYtSE5pbESWoHmEwmZj0oCQWqK+3seHlnH/aee2DcPEbuzRBVe8Q9mBZjhyJggEeFOMZKpFYBO21FRBPxKeB6ikVd+Sgvof37AW2VpOXltctx0L87bBQIkf/64/+D9wOXBSW7W9A370uPGwY28HyHvWuhy34= Received: from PH0PR18MB4672.namprd18.prod.outlook.com (2603:10b6:510:c9::16) by CO6PR18MB3892.namprd18.prod.outlook.com (2603:10b6:5:351::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6792.27; Mon, 18 Sep 2023 11:02:52 +0000 Received: from PH0PR18MB4672.namprd18.prod.outlook.com ([fe80::cd84:2ed1:5222:7527]) by PH0PR18MB4672.namprd18.prod.outlook.com ([fe80::cd84:2ed1:5222:7527%6]) with mapi id 15.20.6792.026; Mon, 18 Sep 2023 11:02:52 +0000 From: Anoob Joseph To: David Coyle CC: "kai.ji@intel.com" , "kevin.osullivan@intel.com" , "dev@dpdk.org" , Jerin Jacob Kollanukkaran Subject: RE: [EXT] [PATCH v3 1/2] crypto/scheduler: support DOCSIS security protocol Thread-Topic: [EXT] [PATCH v3 1/2] crypto/scheduler: support DOCSIS security protocol Thread-Index: AQHZ5yFK/dxObv6aPUytShc7NAE/2rAgZIXw Date: Mon, 18 Sep 2023 11:02:51 +0000 Message-ID: References: <20230811102401.12552-1-david.coyle@intel.com> <20230914152207.19794-1-david.coyle@intel.com> <20230914152207.19794-2-david.coyle@intel.com> In-Reply-To: <20230914152207.19794-2-david.coyle@intel.com> Accept-Language: en-IN, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-dg-rorf: true x-dg-ref: =?us-ascii?Q?PG1ldGE+PGF0IG5tPSJib2R5LnR4dCIgcD0iYzpcdXNlcnNcYW5vb2JqXGFw?= =?us-ascii?Q?cGRhdGFccm9hbWluZ1wwOWQ4NDliNi0zMmQzLTRhNDAtODVlZS02Yjg0YmEy?= =?us-ascii?Q?OWUzNWJcbXNnc1xtc2ctZTI3NTJmZDUtNTYxMi0xMWVlLTljNjYtNGMwMzRm?= =?us-ascii?Q?NWY5YjRmXGFtZS10ZXN0XGUyNzUyZmQ3LTU2MTItMTFlZS05YzY2LTRjMDM0?= =?us-ascii?Q?ZjVmOWI0ZmJvZHkudHh0IiBzej0iMzI4OTAiIHQ9IjEzMzM5NTA4NTYxNDE5?= =?us-ascii?Q?MzUyNCIgaD0idEd0OE1EaDRSUGxTdXcvUjBjUTRZc0g3TzZFPSIgaWQ9IiIg?= =?us-ascii?Q?Ymw9IjAiIGJvPSIxIiBjaT0iY0FBQUFFUkhVMVJTUlVGTkNnVUFBTjRQQUFC?= =?us-ascii?Q?MEc5R2tIK3JaQVJFeFpjdTJ5YkRCRVRGbHk3YkpzTUVaQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUhBQUFBQnVEd0FBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUVBQVFFQkFBQUE5UmVuTHdDQUFRQUFBQUFBQUFBQUFKNEFBQUJoQUdRQVpB?= =?us-ascii?Q?QnlBR1VBY3dCekFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?RUFBQUFBQUFBQUFnQUFBQUFBbmdBQUFHTUFkUUJ6QUhRQWJ3QnRBRjhBY0FC?= =?us-ascii?Q?bEFISUFjd0J2QUc0QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFCQUFBQUFBQUFBQUFBQUFBQVFBQUFBQUFBQUFDQUFB?= =?us-ascii?Q?QUFBQ2VBQUFBWXdCMUFITUFkQUJ2QUcwQVh3QndBR2dBYndCdUFHVUFiZ0Ix?= =?us-ascii?Q?QUcwQVlnQmxBSElBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUJBQUFBQUFBQUFBSUFBQUFBQUo0QUFBQmpBSFVB?= =?us-ascii?Q?Y3dCMEFHOEFiUUJmQUhNQWN3QnVBRjhBWkFCaEFITUFhQUJmQUhZQU1BQXlB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= x-dg-refone: =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFFQUFBQUFBQUFBQWdBQUFBQUFuZ0FBQUdN?= =?us-ascii?Q?QWRRQnpBSFFBYndCdEFGOEFjd0J6QUc0QVh3QnJBR1VBZVFCM0FHOEFjZ0Jr?= =?us-ascii?Q?QUhNQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBUUFBQUFBQUFBQUNBQUFBQUFDZUFBQUFZd0IxQUhNQWRBQnZBRzBB?= =?us-ascii?Q?WHdCekFITUFiZ0JmQUc0QWJ3QmtBR1VBYkFCcEFHMEFhUUIwQUdVQWNnQmZB?= =?us-ascii?Q?SFlBTUFBeUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQkFBQUFBQUFB?= =?us-ascii?Q?QUFJQUFBQUFBSjRBQUFCakFIVUFjd0IwQUc4QWJRQmZBSE1BY3dCdUFGOEFj?= =?us-ascii?Q?d0J3QUdFQVl3QmxBRjhBZGdBd0FESUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUVBQUFBQUFBQUFBZ0FBQUFBQW5nQUFB?= =?us-ascii?Q?R1FBYkFCd0FGOEFjd0JyQUhrQWNBQmxBRjhBWXdCb0FHRUFkQUJmQUcwQVpR?= =?us-ascii?Q?QnpBSE1BWVFCbkFHVUFYd0IyQURBQU1nQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFRQUFBQUFBQUFBQ0FBQUFBQUNlQUFBQVpBQnNBSEFBWHdCekFH?= =?us-ascii?Q?d0FZUUJqQUdzQVh3QmpBR2dBWVFCMEFGOEFiUUJsQUhNQWN3QmhBR2NBWlFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= x-dg-reftwo: =?us-ascii?Q?QUFBQUFBQUFBQUFCQUFBQUFBQUFBQUlBQUFBQUFKNEFBQUJrQUd3QWNBQmZB?= =?us-ascii?Q?SFFBWlFCaEFHMEFjd0JmQUc4QWJnQmxBR1FBY2dCcEFIWUFaUUJmQUdZQWFR?= =?us-ascii?Q?QnNBR1VBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBRUFB?= =?us-ascii?Q?QUFBQUFBQUFnQUFBQUFBbmdBQUFHVUFiUUJoQUdrQWJBQmZBR0VBWkFCa0FI?= =?us-ascii?Q?SUFaUUJ6QUhNQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFDQUFBQUFBQUFBQUFBQUFBQVFBQUFBQUFBQUFDQUFBQUFB?= =?us-ascii?Q?Q2VBQUFBYlFCaEFISUFkZ0JsQUd3QVh3QndBSElBYndCcUFHVUFZd0IwQUY4?= =?us-ascii?Q?QWJnQmhBRzBBWlFCekFGOEFZd0J2QUc0QVpnQnBBR1FBWlFCdUFIUUFhUUJo?= =?us-ascii?Q?QUd3QVh3QmhBR3dBYndCdUFHVUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUJBQUFBQUFBQUFBSUFBQUFBQUo0QUFBQnRBR0VBY2dC?= =?us-ascii?Q?MkFHVUFiQUJmQUhBQWNnQnZBR29BWlFCakFIUUFYd0J1QUdFQWJRQmxBSE1B?= =?us-ascii?Q?WHdCeUFHVUFjd0IwQUhJQWFRQmpBSFFBWlFCa0FGOEFZUUJzQUc4QWJnQmxB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFF?= =?us-ascii?Q?QUFBQUFBQUFBQWdBQUFBQUFuZ0FBQUcwQVlRQnlBSFlBWlFCc0FGOEFjQUJ5?= =?us-ascii?Q?QUc4QWFnQmxBR01BZEFCZkFHNEFZUUJ0QUdVQWN3QmZBSElBWlFCekFIUUFj?= =?us-ascii?Q?Z0JwQUdNQWRBQmxBR1FBWHdCb0FHVUFlQUJqQUc4QVpBQmxBSE1BQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBUUFBQUFBQUFBQUNBQUFB?= =?us-ascii?Q?QUFDZUFBQUFiUUJoQUhJQWRnQmxBR3dBYkFCZkFHRUFjZ0J0QUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= x-dg-refthree: =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQkFBQUFBQUFBQUFJ?= =?us-ascii?Q?QUFBQUFBSjRBQUFCdEFHRUFjZ0IyQUdVQWJBQnNBRjhBWndCdkFHOEFad0Jz?= =?us-ascii?Q?QUdVQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUVBQUFBQUFBQUFBZ0FBQUFBQW5nQUFBRzBB?= =?us-ascii?Q?WVFCeUFIWUFaUUJzQUd3QVh3QndBSElBYndCcUFHVUFZd0IwQUY4QVl3QnZB?= =?us-ascii?Q?R1FBWlFCekFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFRQUFBQUFBQUFBQ0FBQUFBQUNlQUFBQWJRQmhBSElBZGdCbEFHd0Fi?= =?us-ascii?Q?QUJmQUhBQWNnQnZBR29BWlFCakFIUUFYd0JqQUc4QVpBQmxBSE1BWHdCa0FH?= =?us-ascii?Q?a0FZd0IwQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFCQUFBQUFBQUFB?= =?us-ascii?Q?QUlBQUFBQUFKNEFBQUJ0QUdFQWNnQjJBR1VBYkFCc0FGOEFjQUJ5QUc4QWFn?= =?us-ascii?Q?QmxBR01BZEFCZkFHNEFZUUJ0QUdVQWN3QmZBR01BYndCdUFHWUFhUUJrQUdV?= =?us-ascii?Q?QWJnQjBBR2tBWVFCc0FGOEFiUUJoQUhJQWRnQmxBR3dBYkFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBRUFBQUFBQUFBQUFnQUFBQUFBbmdBQUFH?= =?us-ascii?Q?MEFZUUJ5QUhZQVpRQnNBR3dBWHdCd0FISUFid0JxQUdVQVl3QjBBRjhBYmdC?= =?us-ascii?Q?aEFHMEFaUUJ6QUY4QVl3QnZBRzRBWmdCcEFHUUFaUUJ1QUhRQWFRQmhBR3dB?= =?us-ascii?Q?WHdCdEFHRUFjZ0IyQUdVQWJBQnNBRjhBYndCeUFGOEFZUUJ5QUcwQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= x-dg-reffour: =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQVFBQUFBQUFBQUFDQUFBQUFBQ2VB?= =?us-ascii?Q?QUFBYlFCaEFISUFkZ0JsQUd3QWJBQmZBSEFBY2dCdkFHb0FaUUJqQUhRQVh3?= =?us-ascii?Q?QnVBR0VBYlFCbEFITUFYd0JqQUc4QWJnQm1BR2tBWkFCbEFHNEFkQUJwQUdF?= =?us-ascii?Q?QWJBQmZBRzBBWVFCeUFIWUFaUUJzQUd3QVh3QnZBSElBWHdCbkFHOEFid0Ju?= =?us-ascii?Q?QUd3QVpRQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUJBQUFBQUFBQUFBSUFBQUFBQUo0QUFBQnRBR0VBY2dCMkFH?= =?us-ascii?Q?VUFiQUJzQUY4QWNBQnlBRzhBYWdCbEFHTUFkQUJmQUc0QVlRQnRBR1VBY3dC?= =?us-ascii?Q?ZkFISUFaUUJ6QUhRQWNnQnBBR01BZEFCbEFHUUFYd0J0QUdFQWNnQjJBR1VB?= =?us-ascii?Q?YkFCc0FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFFQUFB?= =?us-ascii?Q?QUFBQUFBQWdBQUFBQUFuZ0FBQUcwQVlRQnlBSFlBWlFCc0FHd0FYd0J3QUhJ?= =?us-ascii?Q?QWJ3QnFBR1VBWXdCMEFGOEFiZ0JoQUcwQVpRQnpBRjhBY2dCbEFITUFkQUJ5?= =?us-ascii?Q?QUdrQVl3QjBBR1VBWkFCZkFHMEFZUUJ5QUhZQVpRQnNBR3dBWHdCdkFISUFY?= =?us-ascii?Q?d0JoQUhJQWJRQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBUUFBQUFBQUFBQUNBQUFBQUFD?= =?us-ascii?Q?ZUFBQUFiUUJoQUhJQWRnQmxBR3dBYkFCZkFIUUFaUUJ5QUcwQWFRQnVBSFVB?= =?us-ascii?Q?Y3dBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQkFBQUFBQUFBQUFJQUFBQUFBSjRBQUFCdEFHRUFjZ0Iy?= =?us-ascii?Q?QUdVQWJBQnNBRjhBZHdCdkFISUFaQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB?= =?us-ascii?Q?QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUVB?= =?us-ascii?Q?QUFBQUFBQUFBZ0FBQUFBQSIvPjwvbWV0YT4=3D?= x-ms-publictraffictype: Email x-ms-traffictypediagnostic: PH0PR18MB4672:EE_|CO6PR18MB3892:EE_ x-ms-office365-filtering-correlation-id: 12b1d4ed-e448-4551-08e8-08dbb836cd8c x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: L/7tf5p27qaA2jpEg3VsjSS6ySJbjrw6fDKGsIMEDM2GPVO77aWuuBH1c41Y1R0HvLaN+RobxF2kaXRftPPeuonxLV+ZVxYLig96XUETbXpdtCb50QpLru5vOL5sKidgo1NVNPbEBTThD8BcXoXuRuSS8+EnnxDW9eioBe6AdCFgOuG/5X8m1MRS+Jyksngb8XFiK6cQKncYFwR+NALpdn9j/nmm6bm/BLhcP7puXiAM5TNFzAeji4nSFdp8j7NG69O9I1i0Ih0vL1nvuKdTamUCpqnGI/cKn6tL1I2V0XZVQQmXBgI9PfGzg+EqOtxjxd7vTGOHG8RoNHMirQMhC51o++hAvhnckgXzxcJivKVlu1bFbFX8wtD6+Pt2mv7MZxn/7YRruSeuaJCgr2z4tPbOY2Yn6lCULtaIJiob7uhTztyRH6yE6kN16jQ8O9RGOArPjs4QIY4hqV9cwpJQy5IHWqN0SfsJRPHhF2N2x1YO6KE78q6NZOo4liCsfPBQ1NP7r2NtbXidC07BwZHFGqZMNjOMCWWwFUaig/7Z4kSVNhRVwoRTUM3uRgA9V+raOmP8BVjBDj29IdJu3tGpeFvSX4oqFU1/PqNjJb9xm/Qv/GORXa1qaDrOiurkALqI x-forefront-antispam-report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:PH0PR18MB4672.namprd18.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(39850400004)(346002)(136003)(376002)(396003)(366004)(451199024)(186009)(1800799009)(2906002)(30864003)(83380400001)(38100700002)(38070700005)(107886003)(71200400001)(86362001)(9686003)(53546011)(7696005)(6506007)(33656002)(478600001)(26005)(55016003)(4326008)(8676002)(8936002)(41300700001)(5660300002)(52536014)(6916009)(76116006)(64756008)(54906003)(66446008)(66476007)(66946007)(66556008)(122000001)(316002)(15650500001)(559001)(579004); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?us-ascii?Q?OvA9wPoJbK06wV4sk1IyClhNs27T/h2WSejWhrV3DSKLZJYerIjYUE8rWwj0?= =?us-ascii?Q?Zv+hyJ8zE5Drm/6kc9CjDIPUEWuclXQsxYecasWEpjUmkpZB79apYAm6FzgJ?= =?us-ascii?Q?vdjLQMBhIaqB3Zb9aHyAvFoaIlw4DEihmIltpFFKC9fRSJmokzzqhEoXbtue?= =?us-ascii?Q?PtwtatRxdX35QbzgSodqvqoHD0bqV2Bj6ZvMcfJPrYgXkBFf4ABJlT5RHOwJ?= =?us-ascii?Q?hIIhokgrlt1rfkNkIKQ2tnQ3PhrvMNFydb522uKvw9iHUraqAwqlHSwxrrEN?= =?us-ascii?Q?iA1Zacle9pK9Vq8vkhuGY9oj8gug8ZTLCw2IfYOXoCOIR+7qD4EsMfTdUemK?= =?us-ascii?Q?8FlopOONm8x2motOjj+ooR3sccXRUFPEHpW9QTgZKYLH047LcWwDjC24XA8+?= =?us-ascii?Q?XasBowSKnYHfydWADtUAg/XHzACzwKP0m6U+YRjj+nhE1ugoiEAqDwWfA6ex?= =?us-ascii?Q?z8gnAs9wdfg7HLVIw99pGn1nn+6A25Owvo26YxMSQ5R8qGYyLcFeAcGOajdl?= =?us-ascii?Q?UzYfi5Vye13Ke2QBwDEOHp4rrI/CM5Zcvz3VBZ/wNK1fS4uS6gcUBaV3rAWI?= =?us-ascii?Q?Iqa4MVyPtb07JBoDu+xzhjmE6E0+jxsDLchIJo2hBCMxjPaHt+Yk9SBZsyA/?= =?us-ascii?Q?dYf7BTMjT1OKK1toSesjCo4ABjOjPUJ8XOb8jMc4YK+fZFeJDYCm2Cn0uKjY?= =?us-ascii?Q?JJrWvHFwiNvypVF75Q0e4YUwdqRECKFfZjFCGhzXLVRxsBlldl/JWS/noP8y?= =?us-ascii?Q?LabQEtxj3mQxxJy4kC87ABwlkP+rCICxmx5oiKK3bbV5/pzNa2AypanPd1mw?= =?us-ascii?Q?8OKLJ32FZDfPXPHuGNu5gNL5y5OnjXcY6Be2NfZrQwP8n3o4CwDtv6aknsRp?= =?us-ascii?Q?716vh+39p2cVioamSF7MJUvo8eK0h1IXzz2T9VjIpagHahjPbRL7KmI7V3VG?= =?us-ascii?Q?1NaRXweCDbry5O+zUXE0k/nbAcAcb0goh4B2Oqt7lXxXzAthWPIoW/9El0D9?= =?us-ascii?Q?IrtmLHt0YvS51mO+/BBenBS1bSh7g02bK232ARZAe3d+B+OKraLBpSqd/wQh?= =?us-ascii?Q?VpPJHA+dek7mkJQspwyJPOID7ZYiQRMMqZXPhVPvCmek3WRy0Lla4A4ETddP?= =?us-ascii?Q?k9h1xT+L7EhRQz8G6evZD7obqHZl7Jfdn5dRg/a0WrTTc+kt80X/2WIKP3CE?= =?us-ascii?Q?iIg3MiKUKSszz9gpWwAj/Zl+OZMhEYwy5fJL0SoQSdAuLZ54+gYwhuCsnV5U?= =?us-ascii?Q?9rJCT0P1xsctYVmtR9CwHX0i71dYDAWb8alw5JdJ8SHlC5huCYZUYnyqQLt/?= =?us-ascii?Q?VQ/UsYC3IUO848r8t/DgbkUeQfwbM9Xisv+XPQXdnJUwjjypZb7J9EG3LSDy?= =?us-ascii?Q?D8tTtQq2Sn2iMET18k7ofJ184+WWFPghVdf0XcqYA6IrYNspiNBnhEtaE76Y?= =?us-ascii?Q?8hZ113cxmcaf1nqpBZnerEIPqfi3oRTzcxyU5iOR/hyfyc6BYFDOJkec13re?= =?us-ascii?Q?yHFw0zAs+ig+X/IRMhLAhk0WMAs9ZL3Ef5vYbCAHPjm/Q8aho2u4Kdt6A3Tg?= =?us-ascii?Q?qV3V4JPDwUbxjzhy5As=3D?= Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-OriginatorOrg: marvell.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: PH0PR18MB4672.namprd18.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 12b1d4ed-e448-4551-08e8-08dbb836cd8c X-MS-Exchange-CrossTenant-originalarrivaltime: 18 Sep 2023 11:02:51.9294 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 70e1fb47-1155-421d-87fc-2e58f638b6e0 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: BWtGXj8m1Mgjdh0kgWPcpG3SeZS+saXpQrQBzsAjn4ybIjUOQQmm5X6/Dsv064Za8lFV8CYXGROwW6FnUP8eWA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: CO6PR18MB3892 X-Proofpoint-GUID: G2pQ4Dr09Zc4grLTtRMT966P3CF-jgAG X-Proofpoint-ORIG-GUID: G2pQ4Dr09Zc4grLTtRMT966P3CF-jgAG X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.267,Aquarius:18.0.980,Hydra:6.0.601,FMLib:17.11.176.26 definitions=2023-09-18_03,2023-09-18_01,2023-05-22_02 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Hi David, Thanks for updating the patches based on the comments provided on previous = version. Please see inline for some comments on code. Thanks, Anoob > -----Original Message----- > From: David Coyle > Sent: Thursday, September 14, 2023 8:52 PM > To: dev@dpdk.org > Cc: kai.ji@intel.com; Anoob Joseph ; > kevin.osullivan@intel.com; David Coyle > Subject: [EXT] [PATCH v3 1/2] crypto/scheduler: support DOCSIS security > protocol >=20 > External Email >=20 > ---------------------------------------------------------------------- > Add support to the cryptodev scheduler PMD for the DOCSIS security > protocol. This includes adding the following to the scheduler: > - synchronization of worker's security capabilities > - retrieval of the scheduler's synchronized security capabilities > - retrieval of the security session size i.e. maximum session size > across all workers > - creation of security sessions on each worker > - deletion of security sessions on each worker >=20 > Signed-off-by: David Coyle > Signed-off-by: Kevin O'Sullivan > --- > doc/guides/rel_notes/release_23_11.rst | 4 + > drivers/crypto/scheduler/meson.build | 2 +- > .../scheduler/rte_cryptodev_scheduler.c | 221 +++++++++- > drivers/crypto/scheduler/scheduler_failover.c | 12 +- > .../crypto/scheduler/scheduler_multicore.c | 10 +- > .../scheduler/scheduler_pkt_size_distr.c | 54 +-- > drivers/crypto/scheduler/scheduler_pmd.c | 33 ++ > drivers/crypto/scheduler/scheduler_pmd_ops.c | 381 +++++++++++++----- > .../crypto/scheduler/scheduler_pmd_private.h | 159 +++++--- > .../crypto/scheduler/scheduler_roundrobin.c | 6 +- > 10 files changed, 653 insertions(+), 229 deletions(-) >=20 > diff --git a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c > b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c > index 258d6f8c43..e8b905af2f 100644 > --- a/drivers/crypto/scheduler/rte_cryptodev_scheduler.c > +++ b/drivers/crypto/scheduler/rte_cryptodev_scheduler.c > @@ -5,11 +5,14 @@ > #include > #include > #include > +#include > #include >=20 > #include "rte_cryptodev_scheduler.h" > #include "scheduler_pmd_private.h" >=20 > +#define MAX_CAPS 256 > + > /** update the scheduler pmd's capability with attaching device's > * capability. > * For each device to be attached, the scheduler's capability should be= @@ - > 59,7 +62,6 @@ sync_caps(struct rte_cryptodev_capabilities *caps, > cap->sym.auth.digest_size.max ? > s_cap->sym.auth.digest_size.max : > cap->sym.auth.digest_size.max; > - > } >=20 > if (s_cap->sym.xform_type =3D=3D > @@ -81,25 +83,176 @@ sync_caps(struct rte_cryptodev_capabilities *caps, >=20 > memset(&caps[sync_nb_caps - 1], 0, sizeof(*cap)); > sync_nb_caps--; > + i--; > } >=20 > return sync_nb_caps; > } >=20 > static int > -update_scheduler_capability(struct scheduler_ctx *sched_ctx) > +check_sec_cap_equal(const struct rte_security_capability *sec_cap1, > + struct rte_security_capability *sec_cap2) { > + if (sec_cap1->action !=3D sec_cap2->action || > + sec_cap1->protocol !=3D sec_cap2->protocol || > + sec_cap1->ol_flags !=3D sec_cap2->ol_flags) > + return 0; > + > + if (sec_cap1->protocol =3D=3D RTE_SECURITY_PROTOCOL_DOCSIS) > + return !memcmp(&sec_cap1->docsis, &sec_cap2->docsis, > + sizeof(sec_cap1->docsis)); > + else > + return 0; > +} > + > +static void > +copy_sec_cap(struct rte_security_capability *dst_sec_cap, > + struct rte_security_capability *src_sec_cap) { > + dst_sec_cap->action =3D src_sec_cap->action; > + dst_sec_cap->protocol =3D src_sec_cap->protocol; > + if (src_sec_cap->protocol =3D=3D RTE_SECURITY_PROTOCOL_DOCSIS) > + dst_sec_cap->docsis =3D src_sec_cap->docsis; > + dst_sec_cap->ol_flags =3D src_sec_cap->ol_flags; } > + > +static uint32_t > +sync_sec_crypto_caps(struct rte_cryptodev_capabilities > *tmp_sec_crypto_caps, > + const struct rte_cryptodev_capabilities *sec_crypto_caps, > + const struct rte_cryptodev_capabilities > *worker_sec_crypto_caps) { > + uint8_t nb_caps =3D 0; > + > + nb_caps =3D sync_caps(tmp_sec_crypto_caps, nb_caps, > sec_crypto_caps); > + sync_caps(tmp_sec_crypto_caps, nb_caps, > worker_sec_crypto_caps); > + > + return nb_caps; > +} > + > +/** update the scheduler pmd's security capability with attaching > +device's > + * security capability. > + * For each device to be attached, the scheduler's security capability > +should > + * be the common capability set of all workers **/ static uint32_t > +sync_sec_caps(uint32_t worker_idx, > + struct rte_security_capability *sec_caps, > + struct rte_cryptodev_capabilities > sec_crypto_caps[][MAX_CAPS], > + uint32_t nb_sec_caps, > + const struct rte_security_capability *worker_sec_caps) > { > - struct rte_cryptodev_capabilities tmp_caps[256] =3D { {0} }; > - uint32_t nb_caps =3D 0, i; > + uint32_t nb_worker_sec_caps =3D 0, i; > + > + if (worker_sec_caps =3D=3D NULL) > + return 0; > + > + while (worker_sec_caps[nb_worker_sec_caps].action !=3D > + > RTE_SECURITY_ACTION_TYPE_NONE) > + nb_worker_sec_caps++; > + > + /* Handle first worker */ > + if (worker_idx =3D=3D 0) { > + uint32_t nb_worker_sec_crypto_caps =3D 0; > + uint32_t nb_worker_supp_sec_caps =3D 0; > + > + for (i =3D 0; i < nb_worker_sec_caps; i++) { > + /* Check for supported security protocols */ > + if > (!scheduler_check_sec_proto_supp(worker_sec_caps[i].action, > + worker_sec_caps[i].protocol)) > + continue; >=20 > - if (sched_ctx->capabilities) { > - rte_free(sched_ctx->capabilities); > - sched_ctx->capabilities =3D NULL; > + sec_caps[nb_worker_supp_sec_caps] =3D > worker_sec_caps[i]; > + > + while (worker_sec_caps[i].crypto_capabilities[ > + nb_worker_sec_crypto_caps].op !=3D > + > RTE_CRYPTO_OP_TYPE_UNDEFINED) > + nb_worker_sec_crypto_caps++; > + > + > rte_memcpy(&sec_crypto_caps[nb_worker_supp_sec_caps][0], > + &worker_sec_caps[i].crypto_capabilities[0], [Anoob] Isn't it possible to have 2 different security devices which may di= ffer in crypto capabilities? My understanding is, the code assumes that cry= pto capability of both devices would match. It's okay to document it as a k= nown limitation if it is too difficult to solve. > + > sizeof(sec_crypto_caps[nb_worker_supp_sec_caps][0]) * > + nb_worker_sec_crypto_caps); > + > + nb_worker_supp_sec_caps++; > + } > + return nb_worker_supp_sec_caps; > } >=20 > diff --git a/drivers/crypto/scheduler/scheduler_pmd.c > b/drivers/crypto/scheduler/scheduler_pmd.c > index 4e8bbf0e09..6dad9bc3dd 100644 > --- a/drivers/crypto/scheduler/scheduler_pmd.c > +++ b/drivers/crypto/scheduler/scheduler_pmd.c > @@ -8,6 +8,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -233,6 +234,35 @@ cryptodev_scheduler_create(const char *name, > return -ENOMEM; > } >=20 > + struct rte_security_ctx *security_instance; > + security_instance =3D rte_zmalloc_socket(NULL, > + sizeof(struct rte_security_ctx), > + RTE_CACHE_LINE_SIZE, > SOCKET_ID_ANY); > + if (security_instance =3D=3D NULL) { > + CR_SCHED_LOG(ERR, "rte_security_ctx memory alloc > failed"); > + return -ENOMEM; [Anoob] The lines above this adds regular cryptodev capabilities. Don't we = need to free that as well?=20 > + } > + > + security_instance->device =3D (void *)dev; > + security_instance->ops =3D rte_crypto_scheduler_pmd_sec_ops; > + security_instance->sess_cnt =3D 0; > + dev->security_ctx =3D security_instance; > + > + /* > + * Initialize security capabilities structure as an empty structure, > + * in case device information is requested when no workers are > attached > + */ > + sched_ctx->sec_capabilities =3D rte_zmalloc_socket(NULL, > + sizeof(struct rte_security_capability), > + 0, SOCKET_ID_ANY); > + > + if (!sched_ctx->sec_capabilities) { > + rte_free(security_instance); > + CR_SCHED_LOG(ERR, "Not enough memory for security > capability " > + "information"); > + return -ENOMEM; > + } > + > rte_cryptodev_pmd_probing_finish(dev); >=20 > return 0; > @@ -263,6 +293,9 @@ cryptodev_scheduler_remove(struct > rte_vdev_device *vdev) > sched_ctx->workers[i].dev_id); > } >=20 > + rte_free(dev->security_ctx); > + dev->security_ctx =3D NULL; > + > return rte_cryptodev_pmd_destroy(dev); } >=20 > diff --git a/drivers/crypto/scheduler/scheduler_pmd_ops.c > b/drivers/crypto/scheduler/scheduler_pmd_ops.c > index 294aab4452..34d20ee2de 100644 > --- a/drivers/crypto/scheduler/scheduler_pmd_ops.c > +++ b/drivers/crypto/scheduler/scheduler_pmd_ops.c > @@ -8,11 +8,212 @@ > #include > #include > #include > +#include > #include > #include >=20 > #include "scheduler_pmd_private.h" >=20 > +struct scheduler_configured_sess_info { > + uint8_t dev_id; > + uint8_t driver_id; > + union { > + struct rte_cryptodev_sym_session *sess; > + struct { > + struct rte_security_session *sec_sess; > + struct rte_security_ctx *sec_ctx; > + }; > + }; > +}; > + > +static int > +scheduler_session_create(void *sess, void *sess_params, > + struct scheduler_ctx *sched_ctx, > + enum rte_crypto_op_sess_type session_type) { > + struct rte_mempool *mp =3D rte_mempool_from_obj(sess); > + struct scheduler_session_ctx *sess_ctx; > + struct scheduler_configured_sess_info configured_sess[ > + RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS] > =3D {{0}}; > + uint32_t i, j, n_configured_sess =3D 0; > + int ret =3D 0; > + > + if (session_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > + sess_ctx =3D CRYPTODEV_GET_SYM_SESS_PRIV( > + (struct rte_cryptodev_sym_session *)sess); > + else > + sess_ctx =3D SECURITY_GET_SESS_PRIV( > + (struct rte_security_session *)sess); > + > + if (mp =3D=3D NULL) > + return -EINVAL; > + > + for (i =3D 0; i < sched_ctx->nb_workers; i++) { > + struct scheduler_worker *worker =3D &sched_ctx->workers[i]; > + struct rte_cryptodev *dev =3D &rte_cryptodevs[worker- > >dev_id]; > + uint8_t next_worker =3D 0; > + > + for (j =3D 0; j < n_configured_sess; j++) { > + if (configured_sess[j].driver_id =3D=3D worker- > >driver_id) { > + if (session_type =3D=3D > RTE_CRYPTO_OP_WITH_SESSION) > + sess_ctx->worker_sess[i] =3D > + configured_sess[j].sess; > + else > + sess_ctx->worker_sec_sess[i] =3D > + configured_sess[j].sec_sess; > + > + next_worker =3D 1; > + break; > + } > + } > + if (next_worker) > + continue; > + > + if (rte_mempool_avail_count(mp) =3D=3D 0) { > + ret =3D -ENOMEM; > + goto error_exit; > + } > + > + if (session_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > + struct rte_cryptodev_sym_session *worker_sess =3D > + rte_cryptodev_sym_session_create(worker- > >dev_id, > + (struct > rte_crypto_sym_xform *) [Anoob] Is this cast required? > + sess_params, mp); > + > + if (worker_sess =3D=3D NULL) { > + ret =3D -rte_errno; > + goto error_exit; > + } > + > + worker_sess->opaque_data =3D (uint64_t)sess; > + sess_ctx->worker_sess[i] =3D worker_sess; > + configured_sess[n_configured_sess].sess =3D > worker_sess; > + } else { > + struct rte_security_session *worker_sess =3D > + rte_security_session_create(dev- > >security_ctx, > + (struct rte_security_session_conf *) > + sess_params, mp); > + > + if (worker_sess =3D=3D NULL) { > + ret =3D -rte_errno; > + goto error_exit; > + } > + > + worker_sess->opaque_data =3D (uint64_t)sess; > + sess_ctx->worker_sec_sess[i] =3D worker_sess; > + configured_sess[n_configured_sess].sec_sess =3D > + worker_sess; > + configured_sess[n_configured_sess].sec_ctx =3D > + dev->security_ctx; > + } > + > + configured_sess[n_configured_sess].driver_id =3D > + worker->driver_id; > + configured_sess[n_configured_sess].dev_id =3D worker- > >dev_id; > + n_configured_sess++; > + } > + > + return 0; > + > +error_exit: > + sess_ctx->ref_cnt =3D sched_ctx->ref_cnt; > + for (i =3D 0; i < n_configured_sess; i++) { > + if (session_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > + rte_cryptodev_sym_session_free( > + configured_sess[i].dev_id, > + configured_sess[i].sess); > + else > + rte_security_session_destroy( > + configured_sess[i].sec_ctx, > + configured_sess[i].sec_sess); > + } > + > + return ret; > +} > + > +static void > +scheduler_session_destroy(void *sess, struct scheduler_ctx *sched_ctx, > + uint8_t session_type) > +{ > + struct scheduler_session_ctx *sess_ctx; > + struct scheduler_configured_sess_info deleted_sess[ > + RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS] > =3D {{0}}; > + uint32_t i, j, n_deleted_sess =3D 0; > + > + if (session_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > + sess_ctx =3D CRYPTODEV_GET_SYM_SESS_PRIV( > + (struct rte_cryptodev_sym_session *)sess); > + else > + sess_ctx =3D SECURITY_GET_SESS_PRIV( > + (struct rte_security_session *)sess); > + > + if (sched_ctx->ref_cnt !=3D sess_ctx->ref_cnt) { > + CR_SCHED_LOG(WARNING, > + "Worker updated between session > creation/deletion. " > + "The session may not be freed fully."); > + } > + > + for (i =3D 0; i < sched_ctx->nb_workers; i++) { > + struct scheduler_worker *worker =3D &sched_ctx->workers[i]; > + struct rte_cryptodev *dev =3D &rte_cryptodevs[worker- > >dev_id]; > + uint8_t next_worker =3D 0; > + > + for (j =3D 0; j < n_deleted_sess; j++) { > + if (deleted_sess[j].driver_id =3D=3D worker->driver_id) { > + if (session_type =3D=3D > RTE_CRYPTO_OP_WITH_SESSION) > + sess_ctx->worker_sess[i] =3D NULL; > + else > + sess_ctx->worker_sec_sess[i] =3D > NULL; > + > + next_worker =3D 1; > + break; > + } > + } > + if (next_worker) > + continue; > + > + if (session_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > + rte_cryptodev_sym_session_free(worker->dev_id, > + sess_ctx->worker_sess[i]); > + sess_ctx->worker_sess[i] =3D NULL; > + } else { > + rte_security_session_destroy(dev->security_ctx, > + sess_ctx- > >worker_sec_sess[i]); > + sess_ctx->worker_sec_sess[i] =3D NULL; > + } > + > + deleted_sess[n_deleted_sess++].driver_id =3D worker- > >driver_id; > + } > +} > + > +static unsigned int > +scheduler_session_size_get(struct scheduler_ctx *sched_ctx, > + uint8_t session_type) > +{ > + uint8_t i =3D 0; > + uint32_t max_priv_sess_size =3D 0; > + > + /* Check what is the maximum private session size for all workers */ > + for (i =3D 0; i < sched_ctx->nb_workers; i++) { > + uint8_t worker_dev_id =3D sched_ctx->workers[i].dev_id; > + struct rte_cryptodev *dev =3D > &rte_cryptodevs[worker_dev_id]; > + struct rte_security_ctx *sec_ctx =3D dev->security_ctx; > + uint32_t priv_sess_size =3D 0; > + > + if (session_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > + priv_sess_size =3D > + (*dev->dev_ops- > >sym_session_get_size)(dev); > + } else { > + priv_sess_size =3D (*sec_ctx->ops- > >session_get_size)(dev); > + } > + > + if (max_priv_sess_size < priv_sess_size) > + max_priv_sess_size =3D priv_sess_size; [Anoob] Should we use RTE_MAX? > + } > + > + return max_priv_sess_size; > +} > + > /** attaching the workers predefined by scheduler's EAL options */ stat= ic > int scheduler_attach_init_worker(struct rte_cryptodev *dev) @@ -265,10 > +466,7 @@ scheduler_pmd_close(struct rte_cryptodev *dev) > sched_ctx->private_ctx =3D NULL; > } >=20 > - if (sched_ctx->capabilities) { > - rte_free(sched_ctx->capabilities); > - sched_ctx->capabilities =3D NULL; > - } > + scheduler_free_capabilities(sched_ctx); >=20 > return 0; > } > @@ -451,92 +649,22 @@ scheduler_pmd_qp_setup(struct rte_cryptodev > *dev, uint16_t qp_id, } >=20 > static uint32_t > -scheduler_pmd_sym_session_get_size(struct rte_cryptodev *dev > __rte_unused) > +scheduler_pmd_sym_session_get_size(struct rte_cryptodev *dev) > { > struct scheduler_ctx *sched_ctx =3D dev->data->dev_private; > - uint8_t i =3D 0; > - uint32_t max_priv_sess_size =3D 0; > - > - /* Check what is the maximum private session size for all workers */ > - for (i =3D 0; i < sched_ctx->nb_workers; i++) { > - uint8_t worker_dev_id =3D sched_ctx->workers[i].dev_id; > - struct rte_cryptodev *dev =3D > &rte_cryptodevs[worker_dev_id]; > - uint32_t priv_sess_size =3D (*dev->dev_ops- > >sym_session_get_size)(dev); >=20 > - if (max_priv_sess_size < priv_sess_size) > - max_priv_sess_size =3D priv_sess_size; > - } > - > - return max_priv_sess_size; > + return scheduler_session_size_get(sched_ctx, > +RTE_CRYPTO_OP_WITH_SESSION); > } >=20 > -struct scheduler_configured_sess_info { > - uint8_t dev_id; > - uint8_t driver_id; > - struct rte_cryptodev_sym_session *sess; > -}; > - > static int > scheduler_pmd_sym_session_configure(struct rte_cryptodev *dev, > struct rte_crypto_sym_xform *xform, > struct rte_cryptodev_sym_session *sess) { > struct scheduler_ctx *sched_ctx =3D dev->data->dev_private; > - struct rte_mempool *mp =3D rte_mempool_from_obj(sess); > - struct scheduler_session_ctx *sess_ctx =3D > CRYPTODEV_GET_SYM_SESS_PRIV(sess); > - struct scheduler_configured_sess_info configured_sess[ > - RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS] > =3D {{0}}; > - uint32_t i, j, n_configured_sess =3D 0; > - int ret =3D 0; > - > - if (mp =3D=3D NULL) > - return -EINVAL; >=20 > - for (i =3D 0; i < sched_ctx->nb_workers; i++) { > - struct scheduler_worker *worker =3D &sched_ctx->workers[i]; > - struct rte_cryptodev_sym_session *worker_sess; > - uint8_t next_worker =3D 0; > - > - for (j =3D 0; j < n_configured_sess; j++) { > - if (configured_sess[j].driver_id =3D=3D > - worker->driver_id) { > - sess_ctx->worker_sess[i] =3D > - configured_sess[j].sess; > - next_worker =3D 1; > - break; > - } > - } > - if (next_worker) > - continue; > - > - if (rte_mempool_avail_count(mp) =3D=3D 0) { > - ret =3D -ENOMEM; > - goto error_exit; > - } > - > - worker_sess =3D rte_cryptodev_sym_session_create(worker- > >dev_id, > - xform, mp); > - if (worker_sess =3D=3D NULL) { > - ret =3D -rte_errno; > - goto error_exit; > - } > - > - worker_sess->opaque_data =3D (uint64_t)sess; > - sess_ctx->worker_sess[i] =3D worker_sess; > - configured_sess[n_configured_sess].driver_id =3D > - worker->driver_id; > - configured_sess[n_configured_sess].dev_id =3D worker- > >dev_id; > - configured_sess[n_configured_sess].sess =3D worker_sess; > - n_configured_sess++; > - } > - > - return 0; > -error_exit: > - sess_ctx->ref_cnt =3D sched_ctx->ref_cnt; > - for (i =3D 0; i < n_configured_sess; i++) > - > rte_cryptodev_sym_session_free(configured_sess[i].dev_id, > - configured_sess[i].sess); > - return ret; > + return scheduler_session_create((void *)sess, (void *)xform, > sched_ctx, > + RTE_CRYPTO_OP_WITH_SESSION); > } >=20 > /** Clear the memory of session so it doesn't leave key material behind = */ > @@ -545,37 +673,9 @@ scheduler_pmd_sym_session_clear(struct > rte_cryptodev *dev, > struct rte_cryptodev_sym_session *sess) { > struct scheduler_ctx *sched_ctx =3D dev->data->dev_private; > - struct scheduler_session_ctx *sess_ctx =3D > CRYPTODEV_GET_SYM_SESS_PRIV(sess); > - struct scheduler_configured_sess_info deleted_sess[ > - RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS] > =3D {{0}}; > - uint32_t i, j, n_deleted_sess =3D 0; > - > - if (sched_ctx->ref_cnt !=3D sess_ctx->ref_cnt) { > - CR_SCHED_LOG(WARNING, > - "Worker updated between session > creation/deletion. " > - "The session may not be freed fully."); > - } > - > - for (i =3D 0; i < sched_ctx->nb_workers; i++) { > - struct scheduler_worker *worker =3D &sched_ctx->workers[i]; > - uint8_t next_worker =3D 0; >=20 > - for (j =3D 0; j < n_deleted_sess; j++) { > - if (deleted_sess[j].driver_id =3D=3D worker->driver_id) { > - sess_ctx->worker_sess[i] =3D NULL; > - next_worker =3D 1; > - break; > - } > - } > - if (next_worker) > - continue; > - > - rte_cryptodev_sym_session_free(worker->dev_id, > - sess_ctx->worker_sess[i]); > - > - deleted_sess[n_deleted_sess++].driver_id =3D worker- > >driver_id; > - sess_ctx->worker_sess[i] =3D NULL; > - } > + scheduler_session_destroy((void *)sess, sched_ctx, > + RTE_CRYPTO_OP_WITH_SESSION); > } >=20 > static struct rte_cryptodev_ops scheduler_pmd_ops =3D { @@ -598,3 +698,6= 8 > @@ static struct rte_cryptodev_ops scheduler_pmd_ops =3D { }; >=20 > struct rte_cryptodev_ops *rte_crypto_scheduler_pmd_ops =3D > &scheduler_pmd_ops; > + > +/** Configure a scheduler session from a security session configuration > +*/ static int scheduler_pmd_sec_sess_create(void *dev, struct > +rte_security_session_conf *conf, > + struct rte_security_session *sess) > +{ > + struct rte_cryptodev *cdev =3D (struct rte_cryptodev *)dev; [Anoob] Is this cast required? > + struct scheduler_ctx *sched_ctx =3D cdev->data->dev_private; > + > + /* Check for supported security protocols */ > + if (!scheduler_check_sec_proto_supp(conf->action_type, conf- > >protocol)) { > + CR_SCHED_LOG(ERR, "Unsupported security protocol"); > + return -ENOTSUP; > + } > + > + return scheduler_session_create((void *)sess, (void *)conf, > sched_ctx, > + RTE_CRYPTO_OP_SECURITY_SESSION); > +} > + > +/** Clear the memory of session so it doesn't leave key material behind > +*/ static int scheduler_pmd_sec_sess_destroy(void *dev, > + struct rte_security_session *sess) { > + struct rte_cryptodev *cdev =3D (struct rte_cryptodev *)dev; [Anoob] Is this cast required? > + struct scheduler_ctx *sched_ctx =3D cdev->data->dev_private; > + > + scheduler_session_destroy((void *)sess, sched_ctx, > + RTE_CRYPTO_OP_SECURITY_SESSION); > + > + return 0; > +} > + > +/** Get sync security capabilities for scheduler pmds */ static const > +struct rte_security_capability * scheduler_pmd_sec_capa_get(void *dev) > +{ > + struct rte_cryptodev *cdev =3D (struct rte_cryptodev *)dev; [Anoob] Is this cast required? > + struct scheduler_ctx *sched_ctx =3D cdev->data->dev_private; > + > + return sched_ctx->sec_capabilities; > +} > + > +static unsigned int > +scheduler_pmd_sec_sess_size_get(void *dev) { > + struct rte_cryptodev *cdev =3D (struct rte_cryptodev *)dev; [Anoob] Is this cast required? > + struct scheduler_ctx *sched_ctx =3D cdev->data->dev_private; > + > + return scheduler_session_size_get(sched_ctx, > + RTE_CRYPTO_OP_SECURITY_SESSION); > +} > + > +static struct rte_security_ops scheduler_pmd_sec_ops =3D { > + .session_create =3D scheduler_pmd_sec_sess_create, > + .session_update =3D NULL, > + .session_get_size =3D scheduler_pmd_sec_sess_size_get, > + .session_stats_get =3D NULL, > + .session_destroy =3D scheduler_pmd_sec_sess_destroy, > + .set_pkt_metadata =3D NULL, > + .capabilities_get =3D scheduler_pmd_sec_capa_get }; > + > +struct rte_security_ops *rte_crypto_scheduler_pmd_sec_ops =3D > + > &scheduler_pmd_sec_ops; > diff --git a/drivers/crypto/scheduler/scheduler_pmd_private.h > b/drivers/crypto/scheduler/scheduler_pmd_private.h > index 36d0bb6307..ff1e7a83e8 100644 > --- a/drivers/crypto/scheduler/scheduler_pmd_private.h > +++ b/drivers/crypto/scheduler/scheduler_pmd_private.h > @@ -5,6 +5,8 @@ > #ifndef _SCHEDULER_PMD_PRIVATE_H > #define _SCHEDULER_PMD_PRIVATE_H >=20 > +#include > + > #include "rte_cryptodev_scheduler.h" >=20 > #define CRYPTODEV_NAME_SCHEDULER_PMD crypto_scheduler > @@ -30,7 +32,8 @@ struct scheduler_ctx { > /**< private scheduler context pointer */ >=20 > struct rte_cryptodev_capabilities *capabilities; > - uint32_t nb_capabilities; > + struct rte_security_capability *sec_capabilities; > + struct rte_cryptodev_capabilities **sec_crypto_capabilities; >=20 > uint32_t max_nb_queue_pairs; >=20 > @@ -64,8 +67,12 @@ struct scheduler_qp_ctx { >=20 > struct scheduler_session_ctx { > uint32_t ref_cnt; > - struct rte_cryptodev_sym_session *worker_sess[ > - RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS]; > + union { > + struct rte_cryptodev_sym_session *worker_sess[ > + RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS]; > + struct rte_security_session *worker_sec_sess[ > + RTE_CRYPTODEV_SCHEDULER_MAX_NB_WORKERS]; > + }; > }; >=20 > extern uint8_t cryptodev_scheduler_driver_id; @@ -108,7 +115,22 @@ > scheduler_order_drain(struct rte_ring *order_ring, } >=20 > static __rte_always_inline void > -scheduler_set_worker_session(struct rte_crypto_op **ops, uint16_t > nb_ops, > +scheduler_set_single_worker_session(struct rte_crypto_op *op, > + uint8_t worker_idx) > +{ > + if (op->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > + struct scheduler_session_ctx *sess_ctx =3D > + CRYPTODEV_GET_SYM_SESS_PRIV(op->sym- > >session); > + op->sym->session =3D sess_ctx->worker_sess[worker_idx]; > + } else if (op->sess_type =3D=3D RTE_CRYPTO_OP_SECURITY_SESSION) { > + struct scheduler_session_ctx *sess_ctx =3D > + SECURITY_GET_SESS_PRIV(op->sym- > >session); > + op->sym->session =3D sess_ctx- > >worker_sec_sess[worker_idx]; > + } > +} > + > +static __rte_always_inline void > +scheduler_set_worker_sessions(struct rte_crypto_op **ops, uint16_t > +nb_ops, > uint8_t worker_index) > { > struct rte_crypto_op **op =3D ops; > @@ -129,52 +151,34 @@ scheduler_set_worker_session(struct > rte_crypto_op **ops, uint16_t nb_ops, > rte_prefetch0(op[7]->sym->session); > } >=20 > - if (op[0]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > - struct scheduler_session_ctx *sess_ctx =3D > - CRYPTODEV_GET_SYM_SESS_PRIV(op[0]- > >sym->session); > - op[0]->sym->session =3D > - sess_ctx->worker_sess[worker_index]; > - } > - > - if (op[1]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > - struct scheduler_session_ctx *sess_ctx =3D > - CRYPTODEV_GET_SYM_SESS_PRIV(op[1]- > >sym->session); > - op[1]->sym->session =3D > - sess_ctx->worker_sess[worker_index]; > - } > - > - if (op[2]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > - struct scheduler_session_ctx *sess_ctx =3D > - CRYPTODEV_GET_SYM_SESS_PRIV(op[2]- > >sym->session); > - op[2]->sym->session =3D > - sess_ctx->worker_sess[worker_index]; > - } > - > - if (op[3]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > - struct scheduler_session_ctx *sess_ctx =3D > - CRYPTODEV_GET_SYM_SESS_PRIV(op[3]- > >sym->session); > - op[3]->sym->session =3D > - sess_ctx->worker_sess[worker_index]; > - } > + scheduler_set_single_worker_session(op[0], > worker_index); > + scheduler_set_single_worker_session(op[1], > worker_index); > + scheduler_set_single_worker_session(op[2], > worker_index); > + scheduler_set_single_worker_session(op[3], > worker_index); >=20 > op +=3D 4; > n -=3D 4; > } >=20 > while (n--) { > - if (op[0]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) { > - struct scheduler_session_ctx *sess_ctx =3D > - CRYPTODEV_GET_SYM_SESS_PRIV(op[0]- > >sym->session); > - > - op[0]->sym->session =3D > - sess_ctx->worker_sess[worker_index]; > - op++; > - } > + scheduler_set_single_worker_session(op[0], > worker_index); > + op++; > } > } >=20 > static __rte_always_inline void > -scheduler_retrieve_session(struct rte_crypto_op **ops, uint16_t nb_ops) > +scheduler_retrieve_single_session(struct rte_crypto_op *op) { > + if (op->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > + op->sym->session =3D (void *)(uintptr_t) > + rte_cryptodev_sym_session_opaque_data_get(op- > >sym->session); > + else if (op->sess_type =3D=3D RTE_CRYPTO_OP_SECURITY_SESSION) > + op->sym->session =3D (void *)(uintptr_t) > + rte_security_session_opaque_data_get(op->sym- > >session); > +} > + > +static __rte_always_inline void > +scheduler_retrieve_sessions(struct rte_crypto_op **ops, uint16_t > +nb_ops) > { > uint16_t n =3D nb_ops; > struct rte_crypto_op **op =3D ops; > @@ -194,32 +198,77 @@ scheduler_retrieve_session(struct rte_crypto_op > **ops, uint16_t nb_ops) > rte_prefetch0(op[7]->sym->session); > } >=20 > - if (op[0]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > - op[0]->sym->session =3D (void *)(uintptr_t) > - > rte_cryptodev_sym_session_opaque_data_get(op[0]->sym- > >session); > - if (op[1]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > - op[1]->sym->session =3D (void *)(uintptr_t) > - > rte_cryptodev_sym_session_opaque_data_get(op[1]->sym- > >session); > - if (op[2]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > - op[2]->sym->session =3D (void *)(uintptr_t) > - > rte_cryptodev_sym_session_opaque_data_get(op[2]->sym- > >session); > - if (op[3]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > - op[3]->sym->session =3D (void *)(uintptr_t) > - > rte_cryptodev_sym_session_opaque_data_get(op[3]->sym- > >session); > + scheduler_retrieve_single_session(op[0]); > + scheduler_retrieve_single_session(op[1]); > + scheduler_retrieve_single_session(op[2]); > + scheduler_retrieve_single_session(op[3]); >=20 > op +=3D 4; > n -=3D 4; > } >=20 > while (n--) { > - if (op[0]->sess_type =3D=3D RTE_CRYPTO_OP_WITH_SESSION) > - op[0]->sym->session =3D (void *)(uintptr_t) > - > rte_cryptodev_sym_session_opaque_data_get(op[0]->sym- > >session); > + scheduler_retrieve_single_session(op[0]); > op++; > } > } >=20 > +static __rte_always_inline uint32_t > +scheduler_get_job_len(struct rte_crypto_op *op) { > + uint32_t job_len; > + > + /* op_len is initialized as cipher data length, if > + * it is 0, then it is set to auth data length > + */ > + job_len =3D op->sym->cipher.data.length; > + job_len +=3D (op->sym->cipher.data.length =3D=3D 0) * > + op->sym->auth.data.length; > + > + return job_len; > +} > + > +static __rte_always_inline void > +scheduler_free_capabilities(struct scheduler_ctx *sched_ctx) { > + uint32_t i; > + > + if (sched_ctx->capabilities) { > + rte_free(sched_ctx->capabilities); > + sched_ctx->capabilities =3D NULL; > + } > + > + if (sched_ctx->sec_crypto_capabilities) { > + i =3D 0; > + while (sched_ctx->sec_crypto_capabilities[i] !=3D NULL) { > + rte_free(sched_ctx->sec_crypto_capabilities[i]); > + sched_ctx->sec_crypto_capabilities[i] =3D NULL; > + i++; > + } > + > + rte_free(sched_ctx->sec_crypto_capabilities); > + sched_ctx->sec_crypto_capabilities =3D NULL; > + } > + > + if (sched_ctx->sec_capabilities) { > + rte_free(sched_ctx->sec_capabilities); > + sched_ctx->sec_capabilities =3D NULL; > + } > +} > + > +static __rte_always_inline int > +scheduler_check_sec_proto_supp(enum > rte_security_session_action_type action, > + enum rte_security_session_protocol protocol) { > + if (action =3D=3D RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL > && > + protocol =3D=3D RTE_SECURITY_PROTOCOL_DOCSIS) > + return 1; > + > + return 0; > +} > + > /** device specific operations function pointer structure */ extern str= uct > rte_cryptodev_ops *rte_crypto_scheduler_pmd_ops; > +extern struct rte_security_ops *rte_crypto_scheduler_pmd_sec_ops; >=20 > #endif /* _SCHEDULER_PMD_PRIVATE_H */ > diff --git a/drivers/crypto/scheduler/scheduler_roundrobin.c > b/drivers/crypto/scheduler/scheduler_roundrobin.c > index ad3f8b842a..08041887a8 100644 > --- a/drivers/crypto/scheduler/scheduler_roundrobin.c > +++ b/drivers/crypto/scheduler/scheduler_roundrobin.c > @@ -28,11 +28,11 @@ schedule_enqueue(void *qp, struct rte_crypto_op > **ops, uint16_t nb_ops) > if (unlikely(nb_ops =3D=3D 0)) > return 0; >=20 > - scheduler_set_worker_session(ops, nb_ops, worker_idx); > + scheduler_set_worker_sessions(ops, nb_ops, worker_idx); > processed_ops =3D rte_cryptodev_enqueue_burst(worker->dev_id, > worker->qp_id, ops, nb_ops); > if (processed_ops < nb_ops) > - scheduler_retrieve_session(ops + processed_ops, > + scheduler_retrieve_sessions(ops + processed_ops, > nb_ops - processed_ops); >=20 > worker->nb_inflight_cops +=3D processed_ops; @@ -87,7 +87,7 @@ > schedule_dequeue(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops) >=20 > nb_deq_ops =3D rte_cryptodev_dequeue_burst(worker->dev_id, > worker->qp_id, ops, nb_ops); > - scheduler_retrieve_session(ops, nb_deq_ops); > + scheduler_retrieve_sessions(ops, nb_deq_ops); > last_worker_idx +=3D 1; > last_worker_idx %=3D rr_qp_ctx->nb_workers; >=20 > -- > 2.25.1