From patchwork Wed Nov 6 19:20:53 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865316 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7538DD59F6B for ; Wed, 6 Nov 2024 19:21:14 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id A82E56B0082; Wed, 6 Nov 2024 14:21:12 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id A31F36B0085; Wed, 6 Nov 2024 14:21:12 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 8F9EA6B0088; Wed, 6 Nov 2024 14:21:12 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id 5EB726B0082 for ; Wed, 6 Nov 2024 14:21:12 -0500 (EST) Received: from smtpin30.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id DDD45140DCB for ; Wed, 6 Nov 2024 19:21:11 +0000 (UTC) X-FDA: 82756637334.30.74CB1AB Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf18.hostedemail.com (Postfix) with ESMTP id 567A81C0022 for ; Wed, 6 Nov 2024 19:20:54 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=XyzWp1nd; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920785; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=eAOM1k5eBgatCXxcKi5hWs7e/Nc/Gb2n04WWWLD5dIE=; b=D0OKh1Yg7LOftSyqelZUdS6Tjbkxba2cEhNBV+5GAuTAw840gpjmLCZQnfGgfYkiLZcWM9 NFl2iFv9QaoeQSwbg3695plcaIUdwbde6L5KBDCOW+7IqzMM1yY6b4RCef5NwtZr2btJYo r2hi5LbaBzIvL9cpBQGRAreLDRTG0co= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=XyzWp1nd; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920785; a=rsa-sha256; cv=none; b=m9SGV+ZMhpJG+0tziZZwYHjI13fp4zLpbRPhybu3zTq8L2/SP52OWfsYg6H/8trnc9B+lK QQIG/hihDIXEwL+iVKUsCzzdIKHE38E325pvtKdEdYwr1s9agK5NuVvhnvfqbPr/OzcG4i tHnTDgVHwM7QIym+tHo4nN4Y9l+Pdy0= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920870; x=1762456870; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=8jyV13JKHn0vIl+wBpuhM8EZ+NN4RHEftxJMCaIna00=; b=XyzWp1ndO0TYHtEeV6th812s3RVdRyzCyiVdDJVhuXwbW2t/rlBiNclq vdwEOLOczbHg1bOJqg8wX5MaolMtMraIKo5vvzHezogFvmbsM8cmutzQH AgJ59UZN+cO8T7hePCNISJojEwkxaKhnOQQoPSyqAcbjbcrMPoBpA33C7 G9vDu+YDtDTV/GMgIRvSL1YqV3YBINEg5PKTDsOuJ3PJJ62bcEEN3gTLB 1sm6vxwKdgO/g9v7RxgVZShbT4NLpeRp5L0SaquHb56WyiKs1YHSCbny0 uMFI0T53n0XcC46o6IdNsTeLPmjN7AclOuu3P1ErcF+3+U2xsNbnc+u0R w==; X-CSE-ConnectionGUID: oITy57RURtmkJOUFOEB+5g== X-CSE-MsgGUID: kMJxIU8tQ62qDTJZ3HhZww== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41291935" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41291935" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:07 -0800 X-CSE-ConnectionGUID: 7GLWqB4ETRmTzg1kJtlu0g== X-CSE-MsgGUID: NcmQoX70Qnihkta38JlJxQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695359" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:06 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 01/13] crypto: acomp - Define two new interfaces for compress/decompress batching. Date: Wed, 6 Nov 2024 11:20:53 -0800 Message-Id: <20241106192105.6731-2-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: 567A81C0022 X-Stat-Signature: haqh6khfkqto8qkm6bqijmfun6scp5rx X-HE-Tag: 1730920854-380760 X-HE-Meta: U2FsdGVkX19WjzT/jdBaZGVk7N1i9U2Xye6Qat0+oNMXH9gPWmN6+6QqbzsgpTY4P73Rp/1nUpbGhdiWm1es0e3f9wLCy1n2yUKjoEpnpewgAbsx3wdWQqNte8Dw1oJN0PrBMl6PwDGJcm6spUiO9N2hb0YAGyC4QM8z8NL/j6bxue00I2ysdcOZOd60fAwTrbgnl3p04o/vXPYIcwRyo09n7Ku2cqsllhrxbQIPaubDnH4R2rc+tzw7eWEU8WnsSJb+qD4AweOhnZx5AdRNQ853U2mkqnA7w5/NmEbFwk6WfK6sg525/FhhunAOa0inkwV9fadx2I7FNvFNf9FMKkntBScRWQkCd9CQ9YMwl69MdE1wAhkR1AyN/znkZ1xvHrXkUjU+9dbk2M3XKx7Sj/4kzMhxnL/fQC+MYO5JgOeW62jz6jQtXW7NnALgFhH8cUfI3cQJKkaBOJLottrxFaK2vH2I15+7RTPAA5dHZJLoyXiNkUT/tvyCDozw4yGQN4uQkZpIyyGzUI6hgvMu/V3XUtgV7ByLG3OT6BMnMAp49NYBbK2TqwRrWe3F/mIEMihwrzlgcZf3pjDsXIWO7qvqKN8pY2VKmQnYGg6ON0hMgPuUgO8Jn1MgVSLaBhjEffJmTkhyKKika7WKDyC+5LUUjjTiOyfKGFEZ6o1RAETIt6yT4sAmqlL79+iLJh6fyoWxFRRBMuupmjNXwwg2+Hf3Kr2NON8tcAg9lJDg8MqWuNvvSoRbHaa+ceNVHYU7+Vxo0x+N9GWeTpF7lwmOhgTFzxG6fqdlsoN/cPRxZCJnXjUzu49qAtqJh3hC+7AN9NEPvvPgX5Go3Mgnd3Eqwt72zcZL0fyCXedEQqVGGY8S1OpOKDbNCcJocchbDt8ozDVZJgC3N/qxe2lzIKh6b4c0Jw1f8HWdy2eL69dpEEv2NAbXjcUa/NRoMX+zntTlrSQdHA4sXxNOQz7QemW 8imInu/Q RxsmS5osglnE1gheeood7cN/GNTP7pO/ujRYtCoNnMKhAiHD/bn5Z8rJC3dalVx5UBl2ujDPYdvYfhBv2+Py4Z1cAqNShTTsuyrHd6NuPIFz4MXx06clBxmurBxaO33srlHFzoy4IQf2aRVQFFjWODsS4Uh2b2X53zpK/4K6TiWjhKf0Jeq0SncA9Vg== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This commit adds batch_compress() and batch_decompress() interfaces to: struct acomp_alg struct crypto_acomp This allows the iaa_crypto Intel IAA driver to register implementation for batch_compress() and batch_decompress() API, that can subsequently be invoked from the kernel zswap/zram swap modules to compress/decompress up to CRYPTO_BATCH_SIZE (i.e. 8) pages in parallel in the IAA hardware accelerator to improve swapout/swapin performance. Signed-off-by: Kanchana P Sridhar --- crypto/acompress.c | 2 + include/crypto/acompress.h | 82 +++++++++++++++++++++++++++++ include/crypto/internal/acompress.h | 16 ++++++ 3 files changed, 100 insertions(+) diff --git a/crypto/acompress.c b/crypto/acompress.c index 6fdf0ff9f3c0..a506db499a37 100644 --- a/crypto/acompress.c +++ b/crypto/acompress.c @@ -71,6 +71,8 @@ static int crypto_acomp_init_tfm(struct crypto_tfm *tfm) acomp->compress = alg->compress; acomp->decompress = alg->decompress; + acomp->batch_compress = alg->batch_compress; + acomp->batch_decompress = alg->batch_decompress; acomp->dst_free = alg->dst_free; acomp->reqsize = alg->reqsize; diff --git a/include/crypto/acompress.h b/include/crypto/acompress.h index 54937b615239..ab0d9987bde1 100644 --- a/include/crypto/acompress.h +++ b/include/crypto/acompress.h @@ -37,12 +37,20 @@ struct acomp_req { void *__ctx[] CRYPTO_MINALIGN_ATTR; }; +/* + * The max compress/decompress batch size, for crypto algorithms + * that support batch_compress and batch_decompress API. + */ +#define CRYPTO_BATCH_SIZE 8UL + /** * struct crypto_acomp - user-instantiated objects which encapsulate * algorithms and core processing logic * * @compress: Function performs a compress operation * @decompress: Function performs a de-compress operation + * @batch_compress: Function performs a batch compress operation + * @batch_decompress: Function performs a batch decompress operation * @dst_free: Frees destination buffer if allocated inside the * algorithm * @reqsize: Context size for (de)compression requests @@ -51,6 +59,20 @@ struct acomp_req { struct crypto_acomp { int (*compress)(struct acomp_req *req); int (*decompress)(struct acomp_req *req); + void (*batch_compress)(struct acomp_req *reqs[], + struct crypto_wait *wait, + struct page *pages[], + u8 *dsts[], + unsigned int dlens[], + int errors[], + int nr_pages); + void (*batch_decompress)(struct acomp_req *reqs[], + struct crypto_wait *wait, + u8 *srcs[], + struct page *pages[], + unsigned int slens[], + int errors[], + int nr_pages); void (*dst_free)(struct scatterlist *dst); unsigned int reqsize; struct crypto_tfm base; @@ -265,4 +287,64 @@ static inline int crypto_acomp_decompress(struct acomp_req *req) return crypto_acomp_reqtfm(req)->decompress(req); } +/** + * crypto_acomp_batch_compress() -- compress a batch of requests + * + * Function invokes the batch compress operation + * + * @reqs: @nr_pages asynchronous compress requests. + * @wait: crypto_wait for synchronous acomp batch compress. If NULL, the + * driver must provide a way to process completions asynchronously. + * @pages: Pages to be compressed. + * @dsts: Pre-allocated destination buffers to store results of compression. + * @dlens: Will contain the compressed lengths. + * @errors: zero on successful compression of the corresponding + * req, or error code in case of error. + * @nr_pages: The number of pages, up to CRYPTO_BATCH_SIZE, + * to be compressed. + */ +static inline void crypto_acomp_batch_compress(struct acomp_req *reqs[], + struct crypto_wait *wait, + struct page *pages[], + u8 *dsts[], + unsigned int dlens[], + int errors[], + int nr_pages) +{ + struct crypto_acomp *tfm = crypto_acomp_reqtfm(reqs[0]); + + return tfm->batch_compress(reqs, wait, pages, dsts, + dlens, errors, nr_pages); +} + +/** + * crypto_acomp_batch_decompress() -- decompress a batch of requests + * + * Function invokes the batch decompress operation + * + * @reqs: @nr_pages asynchronous decompress requests. + * @wait: crypto_wait for synchronous acomp batch decompress. If NULL, the + * driver must provide a way to process completions asynchronously. + * @srcs: The src buffers to be decompressed. + * @pages: The pages to store the decompressed buffers. + * @slens: Compressed lengths of @srcs. + * @errors: zero on successful compression of the corresponding + * req, or error code in case of error. + * @nr_pages: The number of pages, up to CRYPTO_BATCH_SIZE, + * to be decompressed. + */ +static inline void crypto_acomp_batch_decompress(struct acomp_req *reqs[], + struct crypto_wait *wait, + u8 *srcs[], + struct page *pages[], + unsigned int slens[], + int errors[], + int nr_pages) +{ + struct crypto_acomp *tfm = crypto_acomp_reqtfm(reqs[0]); + + return tfm->batch_decompress(reqs, wait, srcs, pages, + slens, errors, nr_pages); +} + #endif diff --git a/include/crypto/internal/acompress.h b/include/crypto/internal/acompress.h index 8831edaafc05..acfe2d9d5a83 100644 --- a/include/crypto/internal/acompress.h +++ b/include/crypto/internal/acompress.h @@ -17,6 +17,8 @@ * * @compress: Function performs a compress operation * @decompress: Function performs a de-compress operation + * @batch_compress: Function performs a batch compress operation + * @batch_decompress: Function performs a batch decompress operation * @dst_free: Frees destination buffer if allocated inside the algorithm * @init: Initialize the cryptographic transformation object. * This function is used to initialize the cryptographic @@ -37,6 +39,20 @@ struct acomp_alg { int (*compress)(struct acomp_req *req); int (*decompress)(struct acomp_req *req); + void (*batch_compress)(struct acomp_req *reqs[], + struct crypto_wait *wait, + struct page *pages[], + u8 *dsts[], + unsigned int dlens[], + int errors[], + int nr_pages); + void (*batch_decompress)(struct acomp_req *reqs[], + struct crypto_wait *wait, + u8 *srcs[], + struct page *pages[], + unsigned int slens[], + int errors[], + int nr_pages); void (*dst_free)(struct scatterlist *dst); int (*init)(struct crypto_acomp *tfm); void (*exit)(struct crypto_acomp *tfm); From patchwork Wed Nov 6 19:20:54 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865317 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0052CD59F6A for ; Wed, 6 Nov 2024 19:21:16 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 15C916B0085; Wed, 6 Nov 2024 14:21:14 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 10AAD6B0088; Wed, 6 Nov 2024 14:21:14 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id EC6946B0089; Wed, 6 Nov 2024 14:21:13 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0010.hostedemail.com [216.40.44.10]) by kanga.kvack.org (Postfix) with ESMTP id C8B0A6B0085 for ; Wed, 6 Nov 2024 14:21:13 -0500 (EST) Received: from smtpin04.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay09.hostedemail.com (Postfix) with ESMTP id 7B79980C17 for ; Wed, 6 Nov 2024 19:21:13 +0000 (UTC) X-FDA: 82756637754.04.5255613 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf23.hostedemail.com (Postfix) with ESMTP id A1DB5140018 for ; Wed, 6 Nov 2024 19:20:48 +0000 (UTC) Authentication-Results: imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=G0emlv75; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920812; a=rsa-sha256; cv=none; b=rrdAydCYXacQKJg8gsCvbPE7d/RKeHJUKTSqZgpsgJjYzzb5jdVtwkC3YMHlwff9giJ/Q3 VfUnbOdICuCijkxyOHLLv3CSsWbtaD0CsSpqPD/VsAM2t8wiYRyscuQxK/q7aeRo6ZW+3e 799oc5uS0MBbATJmyjcV1bsYCFIzFKY= ARC-Authentication-Results: i=1; imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=G0emlv75; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920812; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=I/oxNup6yHKTkAJUW7pkB0pJRmgS83/ZcHxjD5s3KGY=; b=nbTcwBvWXrtTTnOZHBAftdRelMjp7W/KRci9Ki+hysS7DJT6+LJoD77MxZbhRrDaZLdDTk VPNwKhHn8csqjhQx9SXoauxNFAs/li3NCNvMTlDWAYmrRi4nnmH0gSmE4SDHDmI+dR25j+ vNJgzfa4TBAG65BcGTcsbugy3TpLZs8= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920872; x=1762456872; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=LsH6bLbkT8Oq6ZmvZizx30VKkaEZwigMJxQ/s5KiGZI=; b=G0emlv75VFl9pyZS/qRHFqWLotqqqia1F8V+0ikcFfjWfCTLe8Uj8BD9 /oa2yyGWubeYw+/3w8/H/snsisSPjUKFV31gx/0kwADO/9cSOQ0thP3rb D7whI1yXLyPMPP5aBd6gvrKwaX7wYYZGMXyuyko7V2jv/qsauzc8faPEC Prp6YJvDQsvWMeBToAe/mbUiY87KUbGz7h/14EIV4fG6wtOyyC54ZsQTx qHORg36u2Obw6SAW5ujo9wrR0dJZju+pU5KucFoDWAUilWAcuLv5XFRYm oTmPXv4LCOpLA6WmN+yM3TwdzIjhKCeg3sJWA+t3q07Mn5hcxRpPPk//q A==; X-CSE-ConnectionGUID: al9oM9h3TxKNbf6bEauxrg== X-CSE-MsgGUID: lC4VG1IFQlOC4dsrvD93Ug== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41291948" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41291948" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:08 -0800 X-CSE-ConnectionGUID: 45D0axoXRkqG1lvhXbXrLQ== X-CSE-MsgGUID: I5t60IOLTB+NwG+Q6dcZ5A== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695369" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:07 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 02/13] crypto: iaa - Add an acomp_req flag CRYPTO_ACOMP_REQ_POLL to enable async mode. Date: Wed, 6 Nov 2024 11:20:54 -0800 Message-Id: <20241106192105.6731-3-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: A1DB5140018 X-Rspamd-Server: rspam11 X-Stat-Signature: mkzw117gji1xgu8b7mbd6i3ck4ww9gpo X-HE-Tag: 1730920848-261070 X-HE-Meta: U2FsdGVkX1/jd3jP7Oin5/0yvHwTzZupryrnxcxjfx7yHyq6LvbzTunfwlulJpQZ13Watm9TTW20bz9GxIoOnbUs2q4nsyQOb56H0kwL6xme2ksMGMiuTWUH98Rg1bQ6Jueh+JVX8CR1zWUto+vGx+guC76XRevmDkxf64btO1+YxPe5D7zHCgKXn6uzBTE+mXG1bRCX0kwmVX/SWtMWKjJkQFbvnSqcolan+m2EyiT5kQ7g53GgGq+AaWxkCyyCYm2V78RlCYnUhc1PTFGAKaORQblX0oivDnLc/MdRw35z1P2arcH8bYcA7HtVr6jRF/qf0PYt69xK0JEHiof3mWluPUvrFKaSQYra3cBuLWNm0Y3RHtyzlSVNnruXm9HWphzh3Ahcn1NaU8LrLXQJTZdFGpLc9xb4yEcQ0RKXJyOAGsM4BTtdqZSayVDLK3C11mG6WogsAPh85IAjevz4Kw/AqtyFN1zRPZwUFDD8unkA9P7ovle8+95dVxmZFPGFHrVXYLiTf/YCPCUXxJSsk0EBu2m5vn4yNQn1ryN5s6HuqyTeu9wJ6No77/1Yz4IdWvfhM2D9JIApEP/7edHbZXwbYK2xKsYWDIFSEQvle8TH4nxO7VvkCeYJXCANfhaOvcfG11W4b20MZ2iLT5Gof+Tol8kRtIo1sc+i8rmGw0REIAnHyHtFZ8SwLA385RAydQBujFYCxvRlYiUDSTex5iRFTzfaHKGOxWMlFj4BOwyC1P+rZHBx9DiMxLh7oC0ut9c+vPKbB20ZdT/53WMVCNJ99Yk+fpsEP1QKXDjBg6RfMUValCrgMmBMSuPswtKVgm3g5+qxeQHvpe2cy+UcZPIRdKeHKoG+bBZS6BlET4H6wVJnsQ4lIJAIZlavyBBRdTUV2sl6/gF2OJqacBfle5SJErVz89690GRX1sXK89VtdorCdvaSRNvyyEnWpB/bJGb0wmfpKILh2OWQgsM b7GZtJls gOE7VfKRBd00BUUIZ29SL67RDAAUQtXSM5tYOmt/Sz1XNJYT/CzzUxy6TOsl9823ssL5tUWuosa/iNCvllXiUrGmkwzSmVcwlNpjsY1WZA2ftXscye96GLNhKceLbhf4Odye6K2uv4sv8mhJ4NVN9p5/OBrh8/WemZlbdgdZcp4CaXNkCWhI21bzRUDZVN4c8Zaun/CrVLYfJKVYiUo4+uAcXSbyR71HNodqNrQp1u2nJYPeiASkEGEek/F24dCQpsLGGve0IDvtmshIEakOMLEyjo4dkps9eJlni X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: If the iaa_crypto driver has async_mode set to true, and use_irq set to false, it can still be forced to use synchronous mode by turning off the CRYPTO_ACOMP_REQ_POLL flag in req->flags. All three of the following need to be true for a request to be processed in fully async poll mode: 1) async_mode should be "true" 2) use_irq should be "false" 3) req->flags & CRYPTO_ACOMP_REQ_POLL should be "true" Suggested-by: Herbert Xu Signed-off-by: Kanchana P Sridhar --- drivers/crypto/intel/iaa/iaa_crypto_main.c | 11 ++++++++++- include/crypto/acompress.h | 5 +++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/drivers/crypto/intel/iaa/iaa_crypto_main.c b/drivers/crypto/intel/iaa/iaa_crypto_main.c index 237f87000070..2edaecd42cc6 100644 --- a/drivers/crypto/intel/iaa/iaa_crypto_main.c +++ b/drivers/crypto/intel/iaa/iaa_crypto_main.c @@ -1510,6 +1510,10 @@ static int iaa_comp_acompress(struct acomp_req *req) return -EINVAL; } + /* If the caller has requested no polling, disable async. */ + if (!(req->flags & CRYPTO_ACOMP_REQ_POLL)) + disable_async = true; + cpu = get_cpu(); wq = wq_table_next_wq(cpu); put_cpu(); @@ -1702,6 +1706,7 @@ static int iaa_comp_adecompress(struct acomp_req *req) { struct crypto_tfm *tfm = req->base.tfm; dma_addr_t src_addr, dst_addr; + bool disable_async = false; int nr_sgs, cpu, ret = 0; struct iaa_wq *iaa_wq; struct device *dev; @@ -1717,6 +1722,10 @@ static int iaa_comp_adecompress(struct acomp_req *req) return -EINVAL; } + /* If the caller has requested no polling, disable async. */ + if (!(req->flags & CRYPTO_ACOMP_REQ_POLL)) + disable_async = true; + if (!req->dst) return iaa_comp_adecompress_alloc_dest(req); @@ -1765,7 +1774,7 @@ static int iaa_comp_adecompress(struct acomp_req *req) req->dst, req->dlen, sg_dma_len(req->dst)); ret = iaa_decompress(tfm, req, wq, src_addr, req->slen, - dst_addr, &req->dlen, false); + dst_addr, &req->dlen, disable_async); if (ret == -EINPROGRESS) return ret; diff --git a/include/crypto/acompress.h b/include/crypto/acompress.h index ab0d9987bde1..5973f5f67954 100644 --- a/include/crypto/acompress.h +++ b/include/crypto/acompress.h @@ -14,6 +14,11 @@ #include #define CRYPTO_ACOMP_ALLOC_OUTPUT 0x00000001 +/* + * If set, the driver must have a way to submit the req, then + * poll its completion status for success/error. + */ +#define CRYPTO_ACOMP_REQ_POLL 0x00000002 #define CRYPTO_ACOMP_DST_MAX 131072 /** From patchwork Wed Nov 6 19:20:55 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865319 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 07BC4D59F6A for ; Wed, 6 Nov 2024 19:21:22 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 3A6096B0089; Wed, 6 Nov 2024 14:21:15 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 32DBB6B008A; Wed, 6 Nov 2024 14:21:15 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 159F66B008C; Wed, 6 Nov 2024 14:21:15 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id E984B6B008A for ; Wed, 6 Nov 2024 14:21:14 -0500 (EST) Received: from smtpin18.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay06.hostedemail.com (Postfix) with ESMTP id 2249CA8039 for ; Wed, 6 Nov 2024 19:21:14 +0000 (UTC) X-FDA: 82756637754.18.5D2D654 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf12.hostedemail.com (Postfix) with ESMTP id 3027B40005 for ; Wed, 6 Nov 2024 19:20:56 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=RFQRWU5w; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920686; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=mixV1IFnrI70cdoC3pE58mO5Bj3BpF3rnTx+GdEXUh8=; b=M42Rx0ojs9v0HRxQNIHUhij0+NWzemghWzT5v39+JYMAzAGUQrveN28z7XnxgrtsTVnw8j aysLjmmtD56Kzg9SFiACXbRdffQXtApZQh59uHdaRl/yjsyU+UvIVjwV6YQNFxkXA5SfCX Wqsq70YkcwSoneh2BNDApwL858wDqgQ= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=RFQRWU5w; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920686; a=rsa-sha256; cv=none; b=kOT3HVeQkpco0W/BcxFSWoYdFOA8Zb60D8YGoD0LA2a6h9SOS4ngbCRxObubyR4fKNlnY1 LXv3eb8pGDqacIgcH01otiuw2fT5p7qGTVCW7Iint/cq/E3SE6jaKR1HejV2l5g5XpU72O B7HbA/A4NkJ4tjLZomDqr2bY4MtuA8w= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920872; x=1762456872; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=A/Xb7b4ZlfpZ9fjf2/i7i8CtYcuuNebRbHMn7yrPUpE=; b=RFQRWU5wxqUsPd6uPHdyA42uoLPKNOkyn0hyYGrB7468JwcVqHO20zbS DDWlxtYR8XJrTwk/ojt4oyM91QPaGYlQK+mUGiRNipVoMqzgYv4JWrzKB DoQZ0GtzhvzNX/GvX6inRLA2k4NUi4bzP0ByAz8ivn3vN7/3qbORs/Wsz 1cDx1zuJKX4r4jLh/B1Np9czzVDKKqY8cbp1IWaycucyhLRiC978onJ6D 5aQluSUj68IZxzSd067ivLhrcbgZnT46BkLIo2cq70y/pAfKkCaoNjPuk fvTXJlnDz7DrwR/r6JqGJdfS16PQnhj3VKGwVt7HiytE3IPCsm0bFLrhH w==; X-CSE-ConnectionGUID: TXdveL+GSjGlsKkW3S1yQg== X-CSE-MsgGUID: PMDkundJSSKFJic7qRUFIQ== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41291960" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41291960" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:09 -0800 X-CSE-ConnectionGUID: YnR07wRTSxqUng2Og5HOsw== X-CSE-MsgGUID: VUfqMGvuRHiegyDSKYUhJA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695374" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:08 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 03/13] crypto: iaa - Implement compress/decompress batching API in iaa_crypto. Date: Wed, 6 Nov 2024 11:20:55 -0800 Message-Id: <20241106192105.6731-4-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 3027B40005 X-Stat-Signature: eiq4yqgzpho4ygje5caw5zadm91ht437 X-Rspam-User: X-HE-Tag: 1730920856-461490 X-HE-Meta: U2FsdGVkX19KlfJl2ncztA8x2r0tTveXqXVlDBA1krfB2haXxwnDY9FWgMpBycSw+5h/PiX0NdWEgbtD30ZJAOh8PkvnU6MK57kuqiataS9VyQp6VHE6Qp8I1upcsZFqBqsgXBn23M3PObmS21WS3AfpC6tronxyY1Rg8F0ZlZauA8uIgqKcym++7XZUMCqljVOMSRnHyvhghPg7CEHjt6kh1VboSkzWYXaM0U+oWi8dFgUS+W6IFMqX31RtsWeKvaeVu+G69XcSJDVzaDmwT54FwITpQ/q7DBMWCGhxSeEGeR2KNtkhIGQQA8JyNY0wJOixDtRai8isnqH8+oHk+OM62iJntb/6mzF2qFFY2T80/9alzaxqziY4hjqYKg3acewYf6zludg/xR32sG5b2wNk7QPvtMZ8hJqsTFIiX9VRuenBTqcRzqGJke0xgzbNmWXI1DcJRp7uEJecwLLXOePOr78TU6bp3lW5ZGvJHi5K+BhfUjFroGt5b9+3kaNRxYKPsO3WUUSnctiDHQYcUi+fXVmhpy+Buppca1vgR8hJ8kdUTlnw294Vd3q6LLX0mzX/QOzC2hKqojIrD5NgE1qBW+DwX+vxTs4hGPzjNCuObDpP/j2CwVMFFVSRfwH1zsxUWz1UeJBc2KjKkqYjXbMu+Y+NGF9EHfZJ40yJrlQBFgOyb93tQ7v5hsMCbdj4U51j6jy3ujxnU4GlHzQJUOBIVkp6NWHcBxoM55+OSGhH0cBRzJNcnZ+yRZeCKiOp2LmPJRSJ8EfMyMG2s/KdABQHgs4IJNCBVqWG5roaTqU+pA/Qra0ZQozAl2oMT6mIU7oWJnfen2EiJXVbmsAuS8TcQxbZyODdoVld8gyGhX/VqugzmxRtoMLR2JERrZWExO8QzFkIU8fUcy2Yeyxlwglox3z8VbqzAAl3I2O9gWmWpUne4wpor+fbRt5Csxctdw+qV2O4KOdFXPVz8t3 1yzPf3Ih ubEHLvT/C6zCbrdMY3+9D4Y5CAPNRJqY4tfnhdivSHBoP8YEmWEK90SkOpa+Cth3e7mRFH66YBjYv1XhYjrx+CHeRsUz3e4iotCFL2RCB5woKyCTQth9mAbfMQ84fgmWHWz2cKDMZBX8KcrASk8XPsxO6HkIV3RgRYqa4QnmgVWQFrchLT14GYn2BoS5Te7YxsTU0hpwpWUKAYfcJiZVFwrUERKlwhZHvQPnPDQB51LUflb0fDDgMLLtsveTGfaNisZoA82XoBiAquPvg07CXu5d4fhHVsqe627OYJPK3YtVL8LhRIiazNWManA== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This patch provides iaa_crypto driver implementations for the newly added crypto_acomp batch_compress() and batch_decompress() interfaces. This allows swap modules such as zswap/zram to invoke batch parallel compression/decompression of pages on systems with Intel IAA, by invoking these API, respectively: crypto_acomp_batch_compress(...); crypto_acomp_batch_decompress(...); This enables zswap_store() compress batching code to be developed in a manner similar to the current single-page synchronous calls to: crypto_acomp_compress(...); crypto_acomp_decompress(...); thereby, facilitating encapsulated and modular hand-off between the kernel zswap/zram code and the crypto_acomp layer. Suggested-by: Yosry Ahmed Suggested-by: Herbert Xu Signed-off-by: Kanchana P Sridhar --- drivers/crypto/intel/iaa/iaa_crypto_main.c | 313 +++++++++++++++++++++ 1 file changed, 313 insertions(+) diff --git a/drivers/crypto/intel/iaa/iaa_crypto_main.c b/drivers/crypto/intel/iaa/iaa_crypto_main.c index 2edaecd42cc6..3ac3a37fd2e6 100644 --- a/drivers/crypto/intel/iaa/iaa_crypto_main.c +++ b/drivers/crypto/intel/iaa/iaa_crypto_main.c @@ -1797,6 +1797,317 @@ static void compression_ctx_init(struct iaa_compression_ctx *ctx) ctx->use_irq = use_irq; } +static int iaa_comp_poll(struct acomp_req *req) +{ + struct idxd_desc *idxd_desc; + struct idxd_device *idxd; + struct iaa_wq *iaa_wq; + struct pci_dev *pdev; + struct device *dev; + struct idxd_wq *wq; + bool compress_op; + int ret; + + idxd_desc = req->base.data; + if (!idxd_desc) + return -EAGAIN; + + compress_op = (idxd_desc->iax_hw->opcode == IAX_OPCODE_COMPRESS); + wq = idxd_desc->wq; + iaa_wq = idxd_wq_get_private(wq); + idxd = iaa_wq->iaa_device->idxd; + pdev = idxd->pdev; + dev = &pdev->dev; + + ret = check_completion(dev, idxd_desc->iax_completion, true, true); + if (ret == -EAGAIN) + return ret; + if (ret) + goto out; + + req->dlen = idxd_desc->iax_completion->output_size; + + /* Update stats */ + if (compress_op) { + update_total_comp_bytes_out(req->dlen); + update_wq_comp_bytes(wq, req->dlen); + } else { + update_total_decomp_bytes_in(req->slen); + update_wq_decomp_bytes(wq, req->slen); + } + + if (iaa_verify_compress && (idxd_desc->iax_hw->opcode == IAX_OPCODE_COMPRESS)) { + struct crypto_tfm *tfm = req->base.tfm; + dma_addr_t src_addr, dst_addr; + u32 compression_crc; + + compression_crc = idxd_desc->iax_completion->crc; + + dma_sync_sg_for_device(dev, req->dst, 1, DMA_FROM_DEVICE); + dma_sync_sg_for_device(dev, req->src, 1, DMA_TO_DEVICE); + + src_addr = sg_dma_address(req->src); + dst_addr = sg_dma_address(req->dst); + + ret = iaa_compress_verify(tfm, req, wq, src_addr, req->slen, + dst_addr, &req->dlen, compression_crc); + } +out: + /* caller doesn't call crypto_wait_req, so no acomp_request_complete() */ + + dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE); + dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE); + + idxd_free_desc(idxd_desc->wq, idxd_desc); + + dev_dbg(dev, "%s: returning ret=%d\n", __func__, ret); + + return ret; +} + +static void iaa_set_req_poll( + struct acomp_req *reqs[], + int nr_reqs, + bool set_flag) +{ + int i; + + for (i = 0; i < nr_reqs; ++i) { + set_flag ? (reqs[i]->flags |= CRYPTO_ACOMP_REQ_POLL) : + (reqs[i]->flags &= ~CRYPTO_ACOMP_REQ_POLL); + } +} + +/** + * This API provides IAA compress batching functionality for use by swap + * modules. + * + * @reqs: @nr_pages asynchronous compress requests. + * @wait: crypto_wait for synchronous acomp batch compress. If NULL, the + * completions will be processed asynchronously. + * @pages: Pages to be compressed by IAA in parallel. + * @dsts: Pre-allocated destination buffers to store results of IAA + * compression. Each element of @dsts must be of size "PAGE_SIZE * 2". + * @dlens: Will contain the compressed lengths. + * @errors: zero on successful compression of the corresponding + * req, or error code in case of error. + * @nr_pages: The number of pages, up to CRYPTO_BATCH_SIZE, + * to be compressed. + */ +static void iaa_comp_acompress_batch( + struct acomp_req *reqs[], + struct crypto_wait *wait, + struct page *pages[], + u8 *dsts[], + unsigned int dlens[], + int errors[], + int nr_pages) +{ + struct scatterlist inputs[CRYPTO_BATCH_SIZE]; + struct scatterlist outputs[CRYPTO_BATCH_SIZE]; + bool compressions_done = false; + bool poll = (async_mode && !use_irq); + int i; + + BUG_ON(nr_pages > CRYPTO_BATCH_SIZE); + BUG_ON(!poll && !wait); + + if (poll) + iaa_set_req_poll(reqs, nr_pages, true); + else + iaa_set_req_poll(reqs, nr_pages, false); + + /* + * Prepare and submit acomp_reqs to IAA. IAA will process these + * compress jobs in parallel if async-poll mode is enabled. + * If IAA is used in sync mode, the jobs will be processed sequentially + * using "wait". + */ + for (i = 0; i < nr_pages; ++i) { + sg_init_table(&inputs[i], 1); + sg_set_page(&inputs[i], pages[i], PAGE_SIZE, 0); + + /* + * Each dst buffer should be of size (PAGE_SIZE * 2). + * Reflect same in sg_list. + */ + sg_init_one(&outputs[i], dsts[i], PAGE_SIZE * 2); + acomp_request_set_params(reqs[i], &inputs[i], + &outputs[i], PAGE_SIZE, dlens[i]); + + /* + * If poll is in effect, submit the request now, and poll for + * a completion status later, after all descriptors have been + * submitted. If polling is not enabled, submit the request + * and wait for it to complete, i.e., synchronously, before + * moving on to the next request. + */ + if (poll) { + errors[i] = iaa_comp_acompress(reqs[i]); + + if (errors[i] != -EINPROGRESS) + errors[i] = -EINVAL; + else + errors[i] = -EAGAIN; + } else { + acomp_request_set_callback(reqs[i], + CRYPTO_TFM_REQ_MAY_BACKLOG, + crypto_req_done, wait); + errors[i] = crypto_wait_req(iaa_comp_acompress(reqs[i]), + wait); + if (!errors[i]) + dlens[i] = reqs[i]->dlen; + } + } + + /* + * If not doing async compressions, the batch has been processed at + * this point and we can return. + */ + if (!poll) + return; + + /* + * Poll for and process IAA compress job completions + * in out-of-order manner. + */ + while (!compressions_done) { + compressions_done = true; + + for (i = 0; i < nr_pages; ++i) { + /* + * Skip, if the compression has already completed + * successfully or with an error. + */ + if (errors[i] != -EAGAIN) + continue; + + errors[i] = iaa_comp_poll(reqs[i]); + + if (errors[i]) { + if (errors[i] == -EAGAIN) + compressions_done = false; + } else { + dlens[i] = reqs[i]->dlen; + } + } + } +} + +/** + * This API provides IAA decompress batching functionality for use by swap + * modules. + * + * @reqs: @nr_pages asynchronous decompress requests. + * @wait: crypto_wait for synchronous acomp batch decompress. If NULL, the + * driver must provide a way to process completions asynchronously. + * @srcs: The src buffers to be decompressed by IAA in parallel. + * @pages: The pages to store the decompressed buffers. + * @slens: Compressed lengths of @srcs. + * @errors: zero on successful compression of the corresponding + * req, or error code in case of error. + * @nr_pages: The number of pages, up to CRYPTO_BATCH_SIZE, + * to be decompressed. + */ +static void iaa_comp_adecompress_batch( + struct acomp_req *reqs[], + struct crypto_wait *wait, + u8 *srcs[], + struct page *pages[], + unsigned int slens[], + int errors[], + int nr_pages) +{ + struct scatterlist inputs[CRYPTO_BATCH_SIZE]; + struct scatterlist outputs[CRYPTO_BATCH_SIZE]; + unsigned int dlens[CRYPTO_BATCH_SIZE]; + bool decompressions_done = false; + bool poll = (async_mode && !use_irq); + int i; + + BUG_ON(nr_pages > CRYPTO_BATCH_SIZE); + BUG_ON(!poll && !wait); + + if (poll) + iaa_set_req_poll(reqs, nr_pages, true); + else + iaa_set_req_poll(reqs, nr_pages, false); + + /* + * Prepare and submit acomp_reqs to IAA. IAA will process these + * decompress jobs in parallel if async-poll mode is enabled. + * If IAA is used in sync mode, the jobs will be processed sequentially + * using "wait". + */ + for (i = 0; i < nr_pages; ++i) { + dlens[i] = PAGE_SIZE; + sg_init_one(&inputs[i], srcs[i], slens[i]); + sg_init_table(&outputs[i], 1); + sg_set_page(&outputs[i], pages[i], PAGE_SIZE, 0); + acomp_request_set_params(reqs[i], &inputs[i], + &outputs[i], slens[i], dlens[i]); + /* + * If poll is in effect, submit the request now, and poll for + * a completion status later, after all descriptors have been + * submitted. If polling is not enabled, submit the request + * and wait for it to complete, i.e., synchronously, before + * moving on to the next request. + */ + if (poll) { + errors[i] = iaa_comp_adecompress(reqs[i]); + + if (errors[i] != -EINPROGRESS) + errors[i] = -EINVAL; + else + errors[i] = -EAGAIN; + } else { + acomp_request_set_callback(reqs[i], + CRYPTO_TFM_REQ_MAY_BACKLOG, + crypto_req_done, wait); + errors[i] = crypto_wait_req(iaa_comp_adecompress(reqs[i]), + wait); + if (!errors[i]) { + dlens[i] = reqs[i]->dlen; + BUG_ON(dlens[i] != PAGE_SIZE); + } + } + } + + /* + * If not doing async decompressions, the batch has been processed at + * this point and we can return. + */ + if (!poll) + return; + + /* + * Poll for and process IAA decompress job completions + * in out-of-order manner. + */ + while (!decompressions_done) { + decompressions_done = true; + + for (i = 0; i < nr_pages; ++i) { + /* + * Skip, if the decompression has already completed + * successfully or with an error. + */ + if (errors[i] != -EAGAIN) + continue; + + errors[i] = iaa_comp_poll(reqs[i]); + + if (errors[i]) { + if (errors[i] == -EAGAIN) + decompressions_done = false; + } else { + dlens[i] = reqs[i]->dlen; + BUG_ON(dlens[i] != PAGE_SIZE); + } + } + } +} + static int iaa_comp_init_fixed(struct crypto_acomp *acomp_tfm) { struct crypto_tfm *tfm = crypto_acomp_tfm(acomp_tfm); @@ -1822,6 +2133,8 @@ static struct acomp_alg iaa_acomp_fixed_deflate = { .compress = iaa_comp_acompress, .decompress = iaa_comp_adecompress, .dst_free = dst_free, + .batch_compress = iaa_comp_acompress_batch, + .batch_decompress = iaa_comp_adecompress_batch, .base = { .cra_name = "deflate", .cra_driver_name = "deflate-iaa", From patchwork Wed Nov 6 19:20:56 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865318 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4ECDFD59F6B for ; Wed, 6 Nov 2024 19:21:19 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id BE40B6B0088; Wed, 6 Nov 2024 14:21:14 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id B1D986B0089; Wed, 6 Nov 2024 14:21:14 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 971096B008A; Wed, 6 Nov 2024 14:21:14 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 6985F6B0088 for ; Wed, 6 Nov 2024 14:21:14 -0500 (EST) Received: from smtpin24.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 12150140AA2 for ; Wed, 6 Nov 2024 19:21:14 +0000 (UTC) X-FDA: 82756637418.24.5E59A95 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf18.hostedemail.com (Postfix) with ESMTP id 9709C1C0010 for ; Wed, 6 Nov 2024 19:20:56 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=V5iWsLNn; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920788; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=S7KSdyx1Yt75nyZU3ul+IeNaI1n+U4GJzibDvgrqEXQ=; b=IAlUX94zY0FMF83lGOARWHCuvNLTUHIo6LmQ9PIFW3jVPxESKHXPH5lKr1V05qjFiyAM4S Z3AW/nrLAl8Dc2JvUJXvTpLOFJiWVcd93r3BYCrMG6Ep1N66g8xDFqoH6OxcmVK52Pu5bX LLNxvpavb4YwGs1vdX9F8kzIW0HNC9Q= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=V5iWsLNn; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920788; a=rsa-sha256; cv=none; b=lz7jQxAedAPLBWePK0fyKBRyzX+Bz7n2pVT29UZer0Q4doiiQ5BKV2gQwHs1YQ/p37S/nz 5g0Di2hFZ10X4ALvYDDeaXpNOHLQsQIxtstr/Gppab/jynfbRz3z196P6OIxlqqldqQWjn pjzLrqN4/bfM2xeO+CVYEk2UD+pb/Bs= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920872; x=1762456872; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=pX2jvauw5wJ2+nUrjP9yXpyaB7Rg+Ni/oUTJYJHTKmc=; b=V5iWsLNnAkBBz6t9dXRb0yf3D03W0v/BhUh6qmsk8ONXkc2EFds+Sm91 mE1QgWjzr4jWA3TAqXhheTPwHlf7pHYXmQoy9rb/NomOLGbyxsgD01DgG INr/r8PGdIrbHmB+dXmtoS2qcOb7oZvEQ7R+vZ19sSw1t9UNUBcyondi6 AxKOsgXCHJtKQVbi3OJg1Z3kSFH4LsblHj9kzkh6k/xnLc5qafAMR6sLh AEu3MyXm66aWva2LTUe3YJp/Zo2uC/KVKuWeywoy9AXSJPg5izKoX0fyH 9cwuay5ERQ9jmm/n+8IdoMW0aa9oFZGfy+XMKj2XKsjlBAlSd5jiJGFiK A==; X-CSE-ConnectionGUID: BPDcYFWcSCSJQQmWSPXUpw== X-CSE-MsgGUID: tOO5VQdASoyoV8hqbC1pww== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41291974" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41291974" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:09 -0800 X-CSE-ConnectionGUID: npxTDlYWQ0e93T1biJ33MA== X-CSE-MsgGUID: tQcgnDEyR0mPpreuHOVDRQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695381" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:08 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 04/13] crypto: iaa - Make async mode the default. Date: Wed, 6 Nov 2024 11:20:56 -0800 Message-Id: <20241106192105.6731-5-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: 9709C1C0010 X-Stat-Signature: iawiph1rhukhn11zyap7yyhafn5hqkek X-HE-Tag: 1730920856-287602 X-HE-Meta: U2FsdGVkX188IliNRbZVmcqUl+rqb6/WwCpQ4ky41zf4iCG5iPYwUT0xbW7lX4hz3TAFVhWbvrtW5wfuPiEuWovsD8WadNzeByykd3nL2XpDN1a825x9mIGF+nNAxC8FRdnXjba496cE+VB8vBGrYvELc5N74Ry1Ox0lC0zRS/IW6z7m1SiR/1plbX5um6JFduZYzaOFOADlJ4Iq7uF6ydOBzxaVOyTE9Co3LhGXIpLGh7oecUpvteQmZVvcrjhGC68S4N1X2TxzbKS7D4+2piw8OfgErjOSUFuvfKD3CGO+0NoQqsDVK8lwfeGddYec0UOujBVb++X8F2GX8iPiB4JBHyHOZtiNBCcdZZH9KxYoPjuvPzmFL6FqsrSbFqis69YKvjILJ4QfDO1qNCTiPOaK2dyTtGYwq1pGVVK/A3PfN6ab7bsungWu/Mw+e0IP9rfAqNw8RO+wCp6txSMXfhwR9+AXvXa/+W867XPJjPgHNfzyE8hJiGZFWy1lPmCKDtDYNwmfGeAdhkV8rzlDK7SNo5uOqP8CKkPX6VhGgaE5XWdqi5iAto7s1xWlOeU7B6bhLOKYJV/jIRMes1Mbyz+nZa/oQ1nqTZNy85XyYj/DL/39C9v3pQ2Iohps7ovSOwYtQpIKaL9b5SU3pC/gnCIfoaF8lRshOTsvYDqCZIday6CMA+SgKyB1MfnVrlJ3CB/vNUjwsf+ciQuR2PQ0TMNjtghYNpGo30WvUVoqgM7X+OjlV58YCUBLDKxhj1eShBjIdslG0yaYdwcc0SUg+GksZT28ZrBmvBQLuWa0XNlZhSiJsgK5BKt4YxIaPtrbdwVS0J7GtlYQJaz4eM3kfm6XQKnj0Nrc/o9HXigCo2UJPQS+IQ44KSedlK4/YtOCPTMLeMgKOnD/1CzHOySkX61qHOER2HSUT8yyxg1e5PcnsV6CuyagIv6IvYeELJCVeYVWCRPxwGBMGjHNfKM CsoFV7Um 5SNTYoa8205gmS12ESBKXuMWJSjwIvmeZzveNKkbqaDGAj2VjgTMlDtGC6myf5jg2gg93N7lYp0gRc0Y4289q3WtEeSeHtpFvfqj0kS4uu76IXiKHLo0BG9ClWXb1FoYdzGQM3wseed1FcFE1lkwbLOBgxllHlgeiUTORymjdo2atPtAKeEAAb1S42w== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This patch makes it easier for IAA hardware acceleration in the iaa_crypto driver to be loaded by default in the most efficient/recommended "async" mode for parallel compressions/decompressions, namely, asynchronous submission of descriptors, followed by polling for job completions. Earlier, the "sync" mode used to be the default. This way, anyone that wants to use IAA can do so after building the kernel, and without having to go through these steps to use async poll: 1) disable all the IAA device/wq bindings that happen at boot time 2) rmmod iaa_crypto 3) modprobe iaa_crypto 4) echo async > /sys/bus/dsa/drivers/crypto/sync_mode 5) re-run initialization of the IAA devices and wqs Signed-off-by: Kanchana P Sridhar --- drivers/crypto/intel/iaa/iaa_crypto_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/crypto/intel/iaa/iaa_crypto_main.c b/drivers/crypto/intel/iaa/iaa_crypto_main.c index 3ac3a37fd2e6..13f9d22811ff 100644 --- a/drivers/crypto/intel/iaa/iaa_crypto_main.c +++ b/drivers/crypto/intel/iaa/iaa_crypto_main.c @@ -153,7 +153,7 @@ static DRIVER_ATTR_RW(verify_compress); */ /* Use async mode */ -static bool async_mode; +static bool async_mode = true; /* Use interrupts */ static bool use_irq; From patchwork Wed Nov 6 19:20:57 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865320 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id EE856D59F6C for ; Wed, 6 Nov 2024 19:21:24 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 74DEB6B008C; Wed, 6 Nov 2024 14:21:16 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 6FF066B0092; Wed, 6 Nov 2024 14:21:16 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 505B36B0096; Wed, 6 Nov 2024 14:21:16 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id 2EC6C6B008C for ; Wed, 6 Nov 2024 14:21:16 -0500 (EST) Received: from smtpin06.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay04.hostedemail.com (Postfix) with ESMTP id E99DE1A0BD2 for ; Wed, 6 Nov 2024 19:21:15 +0000 (UTC) X-FDA: 82756637208.06.BA3B3E3 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf23.hostedemail.com (Postfix) with ESMTP id 2524D14001E for ; Wed, 6 Nov 2024 19:20:50 +0000 (UTC) Authentication-Results: imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=J1Os5YoT; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920814; a=rsa-sha256; cv=none; b=Lc84vP4pKN+0pzEv+qvxJGHmozdSVW4sBR/nNd1JcihoRdhjVXC61BufPYwCMMzmV5BndE dyriuBL7U0hsN1zpFmT0+Yo/RINpmSlrI0UpBLR6+VjuDZpUfVPDkIt18UF++5QYNGqS8f lPRc5Danwq8DXtt0/cSGhT8VpBexn84= ARC-Authentication-Results: i=1; imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=J1Os5YoT; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920814; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=oauYIVWgF52IbGjNwKTzwuD93EHH4qPYrLAmXIwHNFc=; b=zieB2k6ip/HwLzNOHqeWHle024ZAVBbwpKhYLtKmBJtzGQN4XRIx7GIsjhWXC7Z2lU638Z GM80IPkoUOI2wPD9LFYpoCyDPrMd8ll0uWbHHtR0OgsYYzQmYIOX+6+KGFv+RUHbF3b7No xRCp1tbqkvhEgQ7P1rdIIzE/zchYCjs= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920874; x=1762456874; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=yFcfU2b3t6Krq275SHD6OXxnKnpJ7Jmrcy/87R0bztw=; b=J1Os5YoTQeL/fioSd16ZsBghQLJI4Q7LLEigMI0zVEiJs/DeM0oiL6SR h8Z2qxWOhwtcSkb8r7yj3KX5c2bEMX37rtjwuhJr9f4k4qYYijw6aNwBm g6UufwflrOTDMlvDYZuFRWB65N7hZpbIE958lmz7bMsTWFes/xs1HW450 BLlFma85doWrqaTGmJK8En6GLEfdpxVYUBTRQMcbBWo6EVjPF3m3qrhzP SEDI3cexW94IrdETj1eiPbEpHfaRtGxMXpXzbwDGLXSXtHhKT0cDse9JF jdLGrMm+3n8JSr/fExdYcbMP+DKmbog9YWncOoYRVnueI75SdIRiJG2Ii w==; X-CSE-ConnectionGUID: acIdtwfpTjWjNK5LvvnJTw== X-CSE-MsgGUID: 3LrRH6NZRNeVY3BiBdntJA== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41291986" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41291986" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:10 -0800 X-CSE-ConnectionGUID: X7LtG8ZhSOm9GUcPjmI2MQ== X-CSE-MsgGUID: Ch43AaPUSz63XfnLGxWmQg== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695388" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:09 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 05/13] crypto: iaa - Disable iaa_verify_compress by default. Date: Wed, 6 Nov 2024 11:20:57 -0800 Message-Id: <20241106192105.6731-6-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 2524D14001E X-Rspamd-Server: rspam11 X-Stat-Signature: 5rb9o97n6aejbjmqfj3qzwdk1ez68u5n X-HE-Tag: 1730920850-942183 X-HE-Meta: U2FsdGVkX18z6fhFpdpc7YhcjoUKUEnAEL/QG/sk6JLT6DGo1VAO8GbLT7pEVyN10DCmFEcpiCUJB1XQnWHN1gPNxRjiHtlZxikVIiZmSbtIITwRkxVqx7qXdvs37xAjWJWpQqT0fezY89M9+S6yIjFO5sM1pVF46/9LTUALsEplF9lWU0FL9TZiSTA0nXB7zmJsD11ydJ/6wL10Hs/EGpK8i+mQc3FuIXaXhO7+/htH0J7p7I9oHp4kcH+TMELCG7pTkKklk9i2fHPc/VEx7k+WBZBoYenGODuuQfV7Ci6p6ZhFOJgvoRdxWFSK1wOJLF3Fg02BygNshIejdpBpP14qvuCaKDXswU5LaQFtIgPXm01MAPXMQAWKA7Rwv3+6HrLDYw8juUay9ikebs58Y9t29WXT4xdQRtGXmk23YsJj5IuU9U/BCaBZ0HecZpdx8XIRRm5iHZ3nI+EBPltoU1w+nyHGNLhHRY5VtaHoN2lUXhd78NOnsFefWCHtFx0eYZ4lKUkbFu8QU8vz9MJsVbYjiT88EGerFepgJ+Jw8MtrXaQrAduOvXMgf0MhHxRwukU4eGwdMiMs2v//Jl3fpb9DHc7BrAuwH4YSP5K6FDyVmbtffYsPoSPFBHvGbOLmNlPQEJSTwSf0ycWebpQDU9t4X/eNBu9B5PK5+NSw1B7dQ4krCRMsj6s/ySVM2TmVHwvbDtqwo3SDdxf57DNFS/jdsyIMabZ++jHSoxN1i/qdhWmHfUiGqNNJVkpocku/lN4ox+hatkChg9Tybs0n1rOnk5x0uImiKYFTR7MldvdVM+gbf6VEAR0gd8Mq387JFbwPsdmg/1GlHkbCDCxfcU8Xd7mRYluO8s3qvs5RUEOO+Fx/0fW6+KktCxwCCGp76i4sIRfZgraIti5mgePDy0eg9BYmeOspdNjOPNT+5/7L1XOWhcKWbSPHQMZ9l7iT9oSdR+2UR0JDcvV0CfV ChqNS/uZ Y5ZxW4clmYjVkQmIxE88hvRx6XrISYSf3D044EuqKEg9hxajYFdSyRKDO3Mcit/ygfxul1cLemVN8Xk/QIaK1hfGeRT3/9RQvLFvZM/rejowVpTunHlhV3oSR41Pnbg0r19nCLHW7KwJUcE8ZWziBZLBbBRswDXXED8pZ3U8VEILbwLNUpRzBA5eVg7+6BnsQyFqK0oU/7Vm7tf8MpR3muV1s3gTa872wECMq X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This patch makes it easier for IAA hardware acceleration in the iaa_crypto driver to be loaded by default with "iaa_verify_compress" disabled, to facilitate performance comparisons with software compressors (which also do not run compress verification by default). Earlier, iaa_crypto compress verification used to be enabled by default. With this patch, if users want to enable compress verification, they can do so with these steps: 1) disable all the IAA device/wq bindings that happen at boot time 2) rmmod iaa_crypto 3) modprobe iaa_crypto 4) echo 1 > /sys/bus/dsa/drivers/crypto/verify_compress 5) re-run initialization of the IAA devices and wqs Signed-off-by: Kanchana P Sridhar --- drivers/crypto/intel/iaa/iaa_crypto_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/crypto/intel/iaa/iaa_crypto_main.c b/drivers/crypto/intel/iaa/iaa_crypto_main.c index 13f9d22811ff..c4b143dd1ddd 100644 --- a/drivers/crypto/intel/iaa/iaa_crypto_main.c +++ b/drivers/crypto/intel/iaa/iaa_crypto_main.c @@ -94,7 +94,7 @@ static bool iaa_crypto_enabled; static bool iaa_crypto_registered; /* Verify results of IAA compress or not */ -static bool iaa_verify_compress = true; +static bool iaa_verify_compress = false; static ssize_t verify_compress_show(struct device_driver *driver, char *buf) { From patchwork Wed Nov 6 19:20:58 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865321 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id B57D1D59F6A for ; Wed, 6 Nov 2024 19:21:27 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 26E466B0096; Wed, 6 Nov 2024 14:21:17 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 1F65B6B0099; Wed, 6 Nov 2024 14:21:17 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id F147D6B0098; Wed, 6 Nov 2024 14:21:16 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0017.hostedemail.com [216.40.44.17]) by kanga.kvack.org (Postfix) with ESMTP id D37886B0092 for ; Wed, 6 Nov 2024 14:21:16 -0500 (EST) Received: from smtpin28.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay01.hostedemail.com (Postfix) with ESMTP id 5A2681C1D65 for ; Wed, 6 Nov 2024 19:21:16 +0000 (UTC) X-FDA: 82756638216.28.177E426 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf18.hostedemail.com (Postfix) with ESMTP id CA2B41C0010 for ; Wed, 6 Nov 2024 19:20:58 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=W+H5dWi5; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920790; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=wN2LmZ5a5qfTWVX1cLgoIE5geGN37SlJY4gc3Svdtbo=; b=dczrFBM8SXpbK7ign3m2h7WPwyb7im0G6d4LqWRcSZH5OKfIUVx8sQ1QkVNgWD5lxLQYDE zUppqCey/rJyR2tjtPSv8xZGozD4JrwNQxfV3B/adGdO6REwjaRGpgLMu6tUAm5GIA3TAJ 2dPuTtxjESw8l+/GjbMkphroKYYGSbk= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=W+H5dWi5; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920790; a=rsa-sha256; cv=none; b=JHH/wMNpG7bbh82lqTu94WgBaUZebUsGbDFknMAp5cKjJ9pqnemrVCoBX917//OEGdTxs0 GxVs6fS4lbv17lLh8KeXeO+6XAjQekZm01oK2zBxI7Z/Vt2pBSd+X4CDggX4y130jrNvlC rtzxXOILct5e935/NcVOKCc45QErvNQ= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920875; x=1762456875; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=dsGJj+DqE0i7pg9VVqHrElSTuA3RtibV8w9INDbEh+Q=; b=W+H5dWi5UKA/lwVNKpuFKCeJT4POrMWQ9nSW7YPsCGrURrjh3z1KDukg Vd95X8d/au1WcmGih72Ol54UXk7ofSVfInrNkY/1vFbAJz7+tUtQw8B1f CYaKnOXttv2LhE+iQWNjRgHstDUY9po39cKSg1IvDLbsYhOxkDHZQzzIw a+agzvv2qAfNvM9dKWZ0E/BfYcizEC99Syq3+z90Ct6Y4LdjpcVpcbFFh mPFNykDos4R7ccn/w5Bh6pooHyf2P1g3wtW+d3Wet5QqIjsV9jaXLMUBk n4ep/H+iBgeKhV+B5ChRLa3ElKFQMFHFRnGwNASYsgwkR0x1LqA9uoxuY w==; X-CSE-ConnectionGUID: 7AZRCzaTR2yojC1989GtCA== X-CSE-MsgGUID: 0zL4IgDPRz2OoyTojCjEJQ== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41291999" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41291999" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:10 -0800 X-CSE-ConnectionGUID: OWkevIq+QMWqgKgle/FXXA== X-CSE-MsgGUID: mh/T3E6IR1CskRaqe4OZ8Q== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695393" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:10 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 06/13] crypto: iaa - Change cpu-to-iaa mappings to evenly balance cores to IAAs. Date: Wed, 6 Nov 2024 11:20:58 -0800 Message-Id: <20241106192105.6731-7-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: CA2B41C0010 X-Stat-Signature: 64k4cbxt4gxgubm45bz3ny165htm9xii X-HE-Tag: 1730920858-194732 X-HE-Meta: U2FsdGVkX1/wL/ChGP8DX7nJairCpjvaR1yjLbheu7KOYNtf/sEowhhTmEBjQNLepIWpX71dXrdyyPUzWHqVLGTPaP+uv1SWL5ZBUkYlciTGF4l6VpoQNNrkszHq66AP7NenvVsP2XDSdk39pdAURKenZmrPNogtYfYRpHmnL+/xHyqaqss/UFF96rNhoJlYLvCnzWB+KLdoOhVeWyvJ1nHrpfVFzqshyb3zPHfltbtPOL+ozpd107Erio8EaGlQKKpyBWKYim+4rYox3ibGiRGJaQu+XzaS6Ax32hZbBSy9Vux17SwDT/Fy7gd6TpfMaLBq2CTMi/k/3Fn9PEJZSwFFFH15MMpeTf/UhDmyyeAbIacRCoPrZoX39wRRaxzObU+b1YtoeDpreErgWaUy5UzvP8w6GyCbASrTUb1LBdNwepmm+BdhhB9kEl4Hw8uYbs3WKhynik8FpMgAAxYvdjocd3WkSO5nui8pFjsvJw30n9jsPOLVkkx5SHNRKBWp3P1g7Nfjyv9LaYbduTLNsOO0EYpFHJS11gSbpzMHdLhkwWyjm7vpWrs/0+8hyR1PfEun2V/PWxBg2bySMSlclgi1gQ/2Iz9BslgjpQAQ61AvaUQ4weMfj7evocGeuW6wOqujn4+Zi7PjDjJrPUmfnlncYPWGYxhGTVdk7tysfQcTnRaPScmjw9IdNehbCMhNLjF1FyBcj5moNGjy+Rovn4JpUMXhfmiYYRY24LKT52wrbRtkIZElJ1ULNdLsac6a0UKnYqOk7G/JyZ3p4oDOyFW2Y+pf0kjvoRhz72n6qwA0AZ4iuS9d00MeThBmwIEFxW5rUJJ3SuD7jE9sVfyadHcV/H5oqzOEdR7EkFpOMWMRu3ej1Wr6x9mPlUOOg9h/ZvmbafZ138drt/Qican0zHE/Bi0vm1Zrpoxj/maTk7SgiFQYGfPPTGvIehDfVijgdNqLlUQLgGHC6YbtEyo fr0KElzM a8K+ZkownKPY9Z6+yjYUjWccNZHvcOxccdVeWnydd1jtf0pCnEaLHvaB0hKAmb6tGcy2BEsM4JpseW514mA4mdJOf/1AiZQwmX0mTzBBajdLntqpIINl4eOP6MYGmgbpPBiSMOdMHI/QLecPCJ7ufvAWVjDJmr6EqeG+lN89vc2pO3ZFZ620rqEfcNyN43sZZnb+sM8YhF7dZTyVAah3B7I9DpJecUHFdRyNOykqMl58kTo4x7cjlfYtcYbHs2l7D6x+l X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This change distributes the cpus more evenly among the IAAs in each socket. Old algorithm to assign cpus to IAA: ------------------------------------ If "nr_cpus" = nr_logical_cpus (includes hyper-threading), the current algorithm determines "nr_cpus_per_node" = nr_cpus / nr_nodes. Hence, on a 2-socket Sapphire Rapids server where each socket has 56 cores and 4 IAA devices, nr_cpus_per_node = 112. Further, cpus_per_iaa = (nr_nodes * nr_cpus_per_node) / nr_iaa Hence, cpus_per_iaa = 224/8 = 28. The iaa_crypto driver then assigns 28 "logical" node cpus per IAA device on that node, that results in this cpu-to-iaa mapping: lscpu|grep NUMA NUMA node(s): 2 NUMA node0 CPU(s): 0-55,112-167 NUMA node1 CPU(s): 56-111,168-223 NUMA node 0: cpu 0-27 28-55 112-139 140-167 iaa iax1 iax3 iax5 iax7 NUMA node 1: cpu 56-83 84-111 168-195 196-223 iaa iax9 iax11 iax13 iax15 This appears non-optimal for a few reasons: 1) The 2 logical threads on a core will get assigned to different IAA devices. For e.g.: cpu 0: iax1 cpu 112: iax5 2) One of the logical threads on a core is assigned to an IAA that is not closest to that core. For e.g. cpu 112. 3) If numactl is used to start processes sequentially on the logical cores, some of the IAA devices on the socket could be over-subscribed, while some could be under-utilized. This patch introduces a scheme to more evenly balance the logical cores to IAA devices on a socket. New algorithm to assign cpus to IAA: ------------------------------------ We introduce a function "cpu_to_iaa()" that takes a logical cpu and returns the IAA device closest to it. If "nr_cpus" = nr_logical_cpus (includes hyper-threading), the new algorithm determines "nr_cpus_per_node" = topology_num_cores_per_package(). Hence, on a 2-socket Sapphire Rapids server where each socket has 56 cores and 4 IAA devices, nr_cpus_per_node = 56. Further, cpus_per_iaa = (nr_nodes * nr_cpus_per_node) / nr_iaa Hence, cpus_per_iaa = 112/8 = 14. The iaa_crypto driver then assigns 14 "logical" node cpus per IAA device on that node, that results in this cpu-to-iaa mapping: NUMA node 0: cpu 0-13,112-125 14-27,126-139 28-41,140-153 42-55,154-167 iaa iax1 iax3 iax5 iax7 NUMA node 1: cpu 56-69,168-181 70-83,182-195 84-97,196-209 98-111,210-223 iaa iax9 iax11 iax13 iax15 This resolves the 3 issues with non-optimality of cpu-to-iaa mappings pointed out earlier with the existing approach. Originally-by: Tom Zanussi Signed-off-by: Kanchana P Sridhar --- drivers/crypto/intel/iaa/iaa_crypto_main.c | 84 ++++++++++++++-------- 1 file changed, 54 insertions(+), 30 deletions(-) diff --git a/drivers/crypto/intel/iaa/iaa_crypto_main.c b/drivers/crypto/intel/iaa/iaa_crypto_main.c index c4b143dd1ddd..a12a8f9caa84 100644 --- a/drivers/crypto/intel/iaa/iaa_crypto_main.c +++ b/drivers/crypto/intel/iaa/iaa_crypto_main.c @@ -55,6 +55,46 @@ static struct idxd_wq *wq_table_next_wq(int cpu) return entry->wqs[entry->cur_wq]; } +/* + * Given a cpu, find the closest IAA instance. The idea is to try to + * choose the most appropriate IAA instance for a caller and spread + * available workqueues around to clients. + */ +static inline int cpu_to_iaa(int cpu) +{ + int node, n_cpus = 0, test_cpu, iaa = 0; + int nr_iaa_per_node; + const struct cpumask *node_cpus; + + if (!nr_nodes) + return 0; + + nr_iaa_per_node = nr_iaa / nr_nodes; + if (!nr_iaa_per_node) + return 0; + + for_each_online_node(node) { + node_cpus = cpumask_of_node(node); + if (!cpumask_test_cpu(cpu, node_cpus)) + continue; + + for_each_cpu(test_cpu, node_cpus) { + if ((n_cpus % nr_cpus_per_node) == 0) + iaa = node * nr_iaa_per_node; + + if (test_cpu == cpu) + return iaa; + + n_cpus++; + + if ((n_cpus % cpus_per_iaa) == 0) + iaa++; + } + } + + return -1; +} + static void wq_table_add(int cpu, struct idxd_wq *wq) { struct wq_table_entry *entry = per_cpu_ptr(wq_table, cpu); @@ -895,8 +935,7 @@ static int wq_table_add_wqs(int iaa, int cpu) */ static void rebalance_wq_table(void) { - const struct cpumask *node_cpus; - int node, cpu, iaa = -1; + int cpu, iaa; if (nr_iaa == 0) return; @@ -906,37 +945,22 @@ static void rebalance_wq_table(void) clear_wq_table(); - if (nr_iaa == 1) { - for (cpu = 0; cpu < nr_cpus; cpu++) { - if (WARN_ON(wq_table_add_wqs(0, cpu))) { - pr_debug("could not add any wqs for iaa 0 to cpu %d!\n", cpu); - return; - } - } - - return; - } - - for_each_node_with_cpus(node) { - node_cpus = cpumask_of_node(node); - - for (cpu = 0; cpu < cpumask_weight(node_cpus); cpu++) { - int node_cpu = cpumask_nth(cpu, node_cpus); - - if (WARN_ON(node_cpu >= nr_cpu_ids)) { - pr_debug("node_cpu %d doesn't exist!\n", node_cpu); - return; - } + for (cpu = 0; cpu < nr_cpus; cpu++) { + iaa = cpu_to_iaa(cpu); + pr_debug("rebalance: cpu=%d iaa=%d\n", cpu, iaa); - if ((cpu % cpus_per_iaa) == 0) - iaa++; + if (WARN_ON(iaa == -1)) { + pr_debug("rebalance (cpu_to_iaa(%d)) failed!\n", cpu); + return; + } - if (WARN_ON(wq_table_add_wqs(iaa, node_cpu))) { - pr_debug("could not add any wqs for iaa %d to cpu %d!\n", iaa, cpu); - return; - } + if (WARN_ON(wq_table_add_wqs(iaa, cpu))) { + pr_debug("could not add any wqs for iaa %d to cpu %d!\n", iaa, cpu); + return; } } + + pr_debug("Finished rebalance local wqs."); } static inline int check_completion(struct device *dev, @@ -2332,7 +2356,7 @@ static int __init iaa_crypto_init_module(void) pr_err("IAA couldn't find any nodes with cpus\n"); return -ENODEV; } - nr_cpus_per_node = nr_cpus / nr_nodes; + nr_cpus_per_node = topology_num_cores_per_package(); if (crypto_has_comp("deflate-generic", 0, 0)) deflate_generic_tfm = crypto_alloc_comp("deflate-generic", 0, 0); From patchwork Wed Nov 6 19:20:59 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865322 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4B3F9D59F6B for ; Wed, 6 Nov 2024 19:21:30 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 726FD6B0092; Wed, 6 Nov 2024 14:21:17 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 6B3346B0098; Wed, 6 Nov 2024 14:21:17 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 3A4E16B009A; Wed, 6 Nov 2024 14:21:17 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id 0F5766B0092 for ; Wed, 6 Nov 2024 14:21:17 -0500 (EST) Received: from smtpin12.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id BC327140DB8 for ; Wed, 6 Nov 2024 19:21:16 +0000 (UTC) X-FDA: 82756637586.12.4B7A00A Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf12.hostedemail.com (Postfix) with ESMTP id 829BA40025 for ; Wed, 6 Nov 2024 19:20:58 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=C2D6jjSf; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920689; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=/rB+AkisounQykFuvz+8msoIYVtOJaxKQVdKG+ZGBnM=; b=LPY1WT9ZVYqNp/jTFLVjrPxUA25SMOd5yuDjXcTjq+BHskKd66RELBy+Ghzn7MYvOSDH03 1Q5shrMw7i9ZezDxpbmfCky3vPl3u5IqhoQ4hRvD9LBNylbArV5BsQSugSJgVF1dmed3D6 nBOWY40afYtSIfg+P1fA/Q1wSdaNV6E= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=C2D6jjSf; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920689; a=rsa-sha256; cv=none; b=qdeudBUbr5RVWi5x1Z7wpbVMT2CF6wGn0+EZirkdzstVmTXRFCxPKFgt2BQdPdP8kkFg3q N6IWqpxG+SkVKaw1Xvk6FwqIoL9+vINtubVd6CGtclJz9+9jkFxDOSVQEbttKT86q/w6YY tClLJyA2XJEAHpIqJIVJ6/Umki0Fu3c= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920875; x=1762456875; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=xaKYi5UD1EXb+8QE17eRVa6qtYmQdKerYV4Ficq5ajk=; b=C2D6jjSf6X2TZPmZHjoIRhJBQ99jn7n6KkMxeJDK4gnL2Amf1E3YL9mY 3J17Xywmq8eS2vrNg6G7VLT9fqVqJFLmUDBo0mbbTxHVzkcYJ0S5Sh5zD yJms3lZc8ehnvyoASHhvQ4t9Hv1w2nB93wjenJjzsswAXJkV3C2NAW8/I cDoHZ4fG/i84+DwWlD0KJDnHZ7TYjKPvddHt64wa1KOupisCSric/z+gp mwBQRLY1S1aTp0mUijtv/ip+ZtLstfpxtUQ6FkfDUD4DawCdr8/1exB5k oBuPjPELX9eun5mcoyZuY5NrKGyvQhqtGmkepexFEwdvMaT3WCBeFzkuj g==; X-CSE-ConnectionGUID: dMyxb2xrRjWTXX20Llgj+g== X-CSE-MsgGUID: IsP4wrZiT7qzquXJ5yqD2g== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292011" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292011" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:11 -0800 X-CSE-ConnectionGUID: +Z5vOFvCTR6cWN9dNz77NQ== X-CSE-MsgGUID: FoxFzadKSE+f4ae5fyvaeQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695396" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:10 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 07/13] crypto: iaa - Distribute compress jobs to all IAA devices on a NUMA node. Date: Wed, 6 Nov 2024 11:20:59 -0800 Message-Id: <20241106192105.6731-8-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 829BA40025 X-Stat-Signature: pa6exdmms3jqcrskh6mguew4wfy8hpwq X-Rspam-User: X-HE-Tag: 1730920858-973381 X-HE-Meta: U2FsdGVkX19mO/sCyAIMTjfjnfBxrAIiWh50WDx4xDd3+PjB9fUpHLsou27pmxPkxKf9lvdOxa0MAlOmFK1WHixRvY4wNIG8uKx7xz1VetJ8CbZ90cP31/+SenPVS0mt07UrRuN1iV+J3IEzX1HtMWT9cOpJBUph8pMG6bO0XDc7h5QBEd2NAMDxPfBchtU5yKN31VGSuK9xpyQdvmBadKEZurJV7tirL55GiKDefbPlWLitP4/AxnJWc0qA8PoN0IyJwivVCrOjLNFdoMfpSsF8WxLcCP3jOJLFGR/cuyZwe3TwF8by5RNwKchEcZ+9ggXk65l6ZOqQj4nsSCAaukuMZquq9Ur6qSZmL8MtNgP5Tx0hKXoLUDHTglSYdD2ux5epJQDmPR60GKkABz294COa9v+Btlu+3i77d8QjKYObknCCCTiq0385mCkXjXx4fb7pHpb4IgjlaefI7B1tVJ0Df3vrhfAhWQpeZTZTcEMdY8enYx4+cZ47hlLrurWMsZ6Wgh1ZdLG44CDtg/wshCBeqSrdHY6+1ZG6q8ACOrCjblrCWAdN4yGq//YVhu0nlhpnZ1rb5IdfAVE2W5Cfb0+PX6O9UYZrimj86fKJo3KVist7o/z34HmxfLi+xSx/27BAMfUA9Qsbv18cFcpiz+Vi9Wj8dpufxzMr4ee//RuGU0+SQKE1Hz5f6aGgCyAg+tAXXQ5BJdxoVMBu9uChZEfx0N7B5l52bQ5mUls2WN7Ag3OaGGWEw7+hvlQ84vHLw+PgpFP9/jj931KvjcWO5RZgGYtP++00xn2RDJvDKIwmaEHSJwEb74lTC1v8QqVm8UFmRt4kVtb0IXEVoBTJD1fCbsvKZ4Ey8BYaJ1k6G2J8uVi9E0aL7emr3zpUh7Hdg+MP+C3s3Y2AmCjf9UVwwHngiYrxaNr6NHn16AvXn5Rt+17uFX8X4r93fkZgtoWgZEQEh0Op67Vyv1DUEq5 diKyO7Wp gC0s22ed99GDmt+D+ROyzI9v7MFNBNpmh1McgM0D4v2mfeelZy9g5NK3fePVqxXnt8tTLSsjnFax1PYXagQp8yktl40XR8irnSrwWDAeubPwXlt6c9fpVlgfzLiWDEqGIoA16L0tV569uTZ5bYml/olCHtiTgijHhohLfsLqNODcvxDDVPoUghX9xcA== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This change enables processes running on any logical core on a NUMA node to use all the IAA devices enabled on that NUMA node for compress jobs. In other words, compressions originating from any process in a node will be distributed in round-robin manner to the available IAA devices on the same socket. The main premise behind this change is to make sure that no compress engines on any IAA device are left un-utilized/under-utilized. In other words, the compress engines on all IAA devices are considered a global resource for that socket. This allows the use of all IAA devices present in a given NUMA node for (batched) compressions originating from zswap/zram, from all cores on this node. A new per-cpu "global_wq_table" implements this in the iaa_crypto driver. We can think of the global WQ per IAA as a WQ to which all cores on that socket can submit compress jobs. To avail of this feature, the user must configure 2 WQs per IAA in order to enable distribution of compress jobs to multiple IAA devices. Each IAA will have 2 WQs: wq.0 (local WQ): Used for decompress jobs from cores mapped by the cpu_to_iaa() "even balancing of logical cores to IAA devices" algorithm. wq.1 (global WQ): Used for compress jobs from *all* logical cores on that socket. The iaa_crypto driver will place all global WQs from all same-socket IAA devices in the global_wq_table per cpu on that socket. When the driver receives a compress job, it will lookup the "next" global WQ in the cpu's global_wq_table to submit the descriptor. The starting wq in the global_wq_table for each cpu is the global wq associated with the IAA nearest to it, so that we stagger the starting global wq for each process. This results in very uniform usage of all IAAs for compress jobs. Two new driver module parameters are added for this feature: g_wqs_per_iaa (default 1): /sys/bus/dsa/drivers/crypto/g_wqs_per_iaa This represents the number of global WQs that can be configured per IAA device. The default is 1, and is the recommended setting to enable the use of this feature once the user configures 2 WQs per IAA using higher level scripts as described in Documentation/driver-api/crypto/iaa/iaa-crypto.rst. g_consec_descs_per_gwq (default 1): /sys/bus/dsa/drivers/crypto/g_consec_descs_per_gwq This represents the number of consecutive compress jobs that will be submitted to the same global WQ (i.e. to the same IAA device) from a given core, before moving to the next global WQ. The default is 1, which is also the recommended setting to avail of this feature. The decompress jobs from any core will be sent to the "local" IAA, namely the one that the driver assigns with the cpu_to_iaa() mapping algorithm that evenly balances the assignment of logical cores to IAA devices on a NUMA node. On a 2-socket Sapphire Rapids server where each socket has 56 cores and 4 IAA devices, this is how the compress/decompress jobs will be mapped when the user configures 2 WQs per IAA device (which implies wq.1 will be added to the global WQ table for each logical core on that NUMA node): lscpu|grep NUMA NUMA node(s): 2 NUMA node0 CPU(s): 0-55,112-167 NUMA node1 CPU(s): 56-111,168-223 Compress jobs: -------------- NUMA node 0: All cpus (0-55,112-167) can send compress jobs to all IAA devices on the socket (iax1/iax3/iax5/iax7) in round-robin manner: iaa iax1 iax3 iax5 iax7 NUMA node 1: All cpus (56-111,168-223) can send compress jobs to all IAA devices on the socket (iax9/iax11/iax13/iax15) in round-robin manner: iaa iax9 iax11 iax13 iax15 Decompress jobs: ---------------- NUMA node 0: cpu 0-13,112-125 14-27,126-139 28-41,140-153 42-55,154-167 iaa iax1 iax3 iax5 iax7 NUMA node 1: cpu 56-69,168-181 70-83,182-195 84-97,196-209 98-111,210-223 iaa iax9 iax11 iax13 iax15 Signed-off-by: Kanchana P Sridhar --- drivers/crypto/intel/iaa/iaa_crypto_main.c | 305 ++++++++++++++++++++- 1 file changed, 290 insertions(+), 15 deletions(-) diff --git a/drivers/crypto/intel/iaa/iaa_crypto_main.c b/drivers/crypto/intel/iaa/iaa_crypto_main.c index a12a8f9caa84..ca0a71b8f31d 100644 --- a/drivers/crypto/intel/iaa/iaa_crypto_main.c +++ b/drivers/crypto/intel/iaa/iaa_crypto_main.c @@ -29,14 +29,23 @@ static unsigned int nr_iaa; static unsigned int nr_cpus; static unsigned int nr_nodes; static unsigned int nr_cpus_per_node; - /* Number of physical cpus sharing each iaa instance */ static unsigned int cpus_per_iaa; static struct crypto_comp *deflate_generic_tfm; /* Per-cpu lookup table for balanced wqs */ -static struct wq_table_entry __percpu *wq_table; +static struct wq_table_entry __percpu *wq_table = NULL; + +/* Per-cpu lookup table for global wqs shared by all cpus. */ +static struct wq_table_entry __percpu *global_wq_table = NULL; + +/* + * Per-cpu counter of consecutive descriptors allocated to + * the same wq in the global_wq_table, so that we know + * when to switch to the next wq in the global_wq_table. + */ +static int __percpu *num_consec_descs_per_wq = NULL; static struct idxd_wq *wq_table_next_wq(int cpu) { @@ -104,26 +113,68 @@ static void wq_table_add(int cpu, struct idxd_wq *wq) entry->wqs[entry->n_wqs++] = wq; - pr_debug("%s: added iaa wq %d.%d to idx %d of cpu %d\n", __func__, - entry->wqs[entry->n_wqs - 1]->idxd->id, - entry->wqs[entry->n_wqs - 1]->id, entry->n_wqs - 1, cpu); + pr_debug("%s: added iaa local wq %d.%d to idx %d of cpu %d\n", __func__, + entry->wqs[entry->n_wqs - 1]->idxd->id, + entry->wqs[entry->n_wqs - 1]->id, entry->n_wqs - 1, cpu); +} + +static void global_wq_table_add(int cpu, struct idxd_wq *wq) +{ + struct wq_table_entry *entry = per_cpu_ptr(global_wq_table, cpu); + + if (WARN_ON(entry->n_wqs == entry->max_wqs)) + return; + + entry->wqs[entry->n_wqs++] = wq; + + pr_debug("%s: added iaa global wq %d.%d to idx %d of cpu %d\n", __func__, + entry->wqs[entry->n_wqs - 1]->idxd->id, + entry->wqs[entry->n_wqs - 1]->id, entry->n_wqs - 1, cpu); +} + +static void global_wq_table_set_start_wq(int cpu) +{ + struct wq_table_entry *entry = per_cpu_ptr(global_wq_table, cpu); + int start_wq = (entry->n_wqs / nr_iaa) * cpu_to_iaa(cpu); + + if ((start_wq >= 0) && (start_wq < entry->n_wqs)) + entry->cur_wq = start_wq; } static void wq_table_free_entry(int cpu) { struct wq_table_entry *entry = per_cpu_ptr(wq_table, cpu); - kfree(entry->wqs); - memset(entry, 0, sizeof(*entry)); + if (entry) { + kfree(entry->wqs); + memset(entry, 0, sizeof(*entry)); + } + + entry = per_cpu_ptr(global_wq_table, cpu); + + if (entry) { + kfree(entry->wqs); + memset(entry, 0, sizeof(*entry)); + } } static void wq_table_clear_entry(int cpu) { struct wq_table_entry *entry = per_cpu_ptr(wq_table, cpu); - entry->n_wqs = 0; - entry->cur_wq = 0; - memset(entry->wqs, 0, entry->max_wqs * sizeof(struct idxd_wq *)); + if (entry) { + entry->n_wqs = 0; + entry->cur_wq = 0; + memset(entry->wqs, 0, entry->max_wqs * sizeof(struct idxd_wq *)); + } + + entry = per_cpu_ptr(global_wq_table, cpu); + + if (entry) { + entry->n_wqs = 0; + entry->cur_wq = 0; + memset(entry->wqs, 0, entry->max_wqs * sizeof(struct idxd_wq *)); + } } LIST_HEAD(iaa_devices); @@ -163,6 +214,70 @@ static ssize_t verify_compress_store(struct device_driver *driver, } static DRIVER_ATTR_RW(verify_compress); +/* Number of global wqs per iaa*/ +static int g_wqs_per_iaa = 1; + +static ssize_t g_wqs_per_iaa_show(struct device_driver *driver, char *buf) +{ + return sprintf(buf, "%d\n", g_wqs_per_iaa); +} + +static ssize_t g_wqs_per_iaa_store(struct device_driver *driver, + const char *buf, size_t count) +{ + int ret = -EBUSY; + + mutex_lock(&iaa_devices_lock); + + if (iaa_crypto_enabled) + goto out; + + ret = kstrtoint(buf, 10, &g_wqs_per_iaa); + if (ret) + goto out; + + ret = count; +out: + mutex_unlock(&iaa_devices_lock); + + return ret; +} +static DRIVER_ATTR_RW(g_wqs_per_iaa); + +/* + * Number of consecutive descriptors to allocate from a + * given global wq before switching to the next wq in + * the global_wq_table. + */ +static int g_consec_descs_per_gwq = 1; + +static ssize_t g_consec_descs_per_gwq_show(struct device_driver *driver, char *buf) +{ + return sprintf(buf, "%d\n", g_consec_descs_per_gwq); +} + +static ssize_t g_consec_descs_per_gwq_store(struct device_driver *driver, + const char *buf, size_t count) +{ + int ret = -EBUSY; + + mutex_lock(&iaa_devices_lock); + + if (iaa_crypto_enabled) + goto out; + + ret = kstrtoint(buf, 10, &g_consec_descs_per_gwq); + if (ret) + goto out; + + ret = count; +out: + mutex_unlock(&iaa_devices_lock); + + return ret; +} +static DRIVER_ATTR_RW(g_consec_descs_per_gwq); + /* * The iaa crypto driver supports three 'sync' methods determining how * compressions and decompressions are performed: @@ -751,7 +866,20 @@ static void free_wq_table(void) for (cpu = 0; cpu < nr_cpus; cpu++) wq_table_free_entry(cpu); - free_percpu(wq_table); + if (wq_table) { + free_percpu(wq_table); + wq_table = NULL; + } + + if (global_wq_table) { + free_percpu(global_wq_table); + global_wq_table = NULL; + } + + if (num_consec_descs_per_wq) { + free_percpu(num_consec_descs_per_wq); + num_consec_descs_per_wq = NULL; + } pr_debug("freed wq table\n"); } @@ -774,6 +902,38 @@ static int alloc_wq_table(int max_wqs) } entry->max_wqs = max_wqs; + entry->n_wqs = 0; + entry->cur_wq = 0; + } + + global_wq_table = alloc_percpu(struct wq_table_entry); + if (!global_wq_table) { + free_wq_table(); + return -ENOMEM; + } + + for (cpu = 0; cpu < nr_cpus; cpu++) { + entry = per_cpu_ptr(global_wq_table, cpu); + entry->wqs = kzalloc(GFP_KERNEL, max_wqs * sizeof(struct wq *)); + if (!entry->wqs) { + free_wq_table(); + return -ENOMEM; + } + + entry->max_wqs = max_wqs; + entry->n_wqs = 0; + entry->cur_wq = 0; + } + + num_consec_descs_per_wq = alloc_percpu(int); + if (!num_consec_descs_per_wq) { + free_wq_table(); + return -ENOMEM; + } + + for (cpu = 0; cpu < nr_cpus; cpu++) { + int *num_consec_descs = per_cpu_ptr(num_consec_descs_per_wq, cpu); + *num_consec_descs = 0; } pr_debug("initialized wq table\n"); @@ -912,9 +1072,14 @@ static int wq_table_add_wqs(int iaa, int cpu) } list_for_each_entry(iaa_wq, &found_device->wqs, list) { - wq_table_add(cpu, iaa_wq->wq); + + if (((found_device->n_wq - g_wqs_per_iaa) < 1) || + (n_wqs_added < (found_device->n_wq - g_wqs_per_iaa))) { + wq_table_add(cpu, iaa_wq->wq); + } + pr_debug("rebalance: added wq for cpu=%d: iaa wq %d.%d\n", - cpu, iaa_wq->wq->idxd->id, iaa_wq->wq->id); + cpu, iaa_wq->wq->idxd->id, iaa_wq->wq->id); n_wqs_added++; } @@ -927,6 +1092,63 @@ static int wq_table_add_wqs(int iaa, int cpu) return ret; } +static int global_wq_table_add_wqs(void) +{ + struct iaa_device *iaa_device; + int ret = 0, n_wqs_added; + struct idxd_device *idxd; + struct iaa_wq *iaa_wq; + struct pci_dev *pdev; + struct device *dev; + int cpu, node, node_of_cpu = -1; + + for (cpu = 0; cpu < nr_cpus; cpu++) { + +#ifdef CONFIG_NUMA + node_of_cpu = -1; + for_each_online_node(node) { + const struct cpumask *node_cpus; + node_cpus = cpumask_of_node(node); + if (!cpumask_test_cpu(cpu, node_cpus)) + continue; + node_of_cpu = node; + break; + } +#endif + list_for_each_entry(iaa_device, &iaa_devices, list) { + idxd = iaa_device->idxd; + pdev = idxd->pdev; + dev = &pdev->dev; + +#ifdef CONFIG_NUMA + if (dev && (node_of_cpu != dev->numa_node)) + continue; +#endif + + if (iaa_device->n_wq <= g_wqs_per_iaa) + continue; + + n_wqs_added = 0; + + list_for_each_entry(iaa_wq, &iaa_device->wqs, list) { + + if (n_wqs_added < (iaa_device->n_wq - g_wqs_per_iaa)) { + n_wqs_added++; + } + else { + global_wq_table_add(cpu, iaa_wq->wq); + pr_debug("rebalance: added global wq for cpu=%d: iaa wq %d.%d\n", + cpu, iaa_wq->wq->idxd->id, iaa_wq->wq->id); + } + } + } + + global_wq_table_set_start_wq(cpu); + } + + return ret; +} + /* * Rebalance the wq table so that given a cpu, it's easy to find the * closest IAA instance. The idea is to try to choose the most @@ -961,6 +1183,7 @@ static void rebalance_wq_table(void) } pr_debug("Finished rebalance local wqs."); + global_wq_table_add_wqs(); } static inline int check_completion(struct device *dev, @@ -1509,6 +1732,27 @@ static int iaa_decompress(struct crypto_tfm *tfm, struct acomp_req *req, goto out; } +/* + * Caller should make sure to call only if the + * per_cpu_ptr "global_wq_table" is non-NULL + * and has at least one wq configured. + */ +static struct idxd_wq *global_wq_table_next_wq(int cpu) +{ + struct wq_table_entry *entry = per_cpu_ptr(global_wq_table, cpu); + int *num_consec_descs = per_cpu_ptr(num_consec_descs_per_wq, cpu); + + if ((*num_consec_descs) == g_consec_descs_per_gwq) { + if (++entry->cur_wq >= entry->n_wqs) + entry->cur_wq = 0; + *num_consec_descs = 0; + } + + ++(*num_consec_descs); + + return entry->wqs[entry->cur_wq]; +} + static int iaa_comp_acompress(struct acomp_req *req) { struct iaa_compression_ctx *compression_ctx; @@ -1521,6 +1765,7 @@ static int iaa_comp_acompress(struct acomp_req *req) struct idxd_wq *wq; struct device *dev; int order = -1; + struct wq_table_entry *entry; compression_ctx = crypto_tfm_ctx(tfm); @@ -1539,8 +1784,15 @@ static int iaa_comp_acompress(struct acomp_req *req) disable_async = true; cpu = get_cpu(); - wq = wq_table_next_wq(cpu); + entry = per_cpu_ptr(global_wq_table, cpu); + + if (!entry || entry->n_wqs == 0) { + wq = wq_table_next_wq(cpu); + } else { + wq = global_wq_table_next_wq(cpu); + } put_cpu(); + if (!wq) { pr_debug("no wq configured for cpu=%d\n", cpu); return -ENODEV; @@ -2393,13 +2645,32 @@ static int __init iaa_crypto_init_module(void) goto err_sync_attr_create; } + ret = driver_create_file(&iaa_crypto_driver.drv, + &driver_attr_g_wqs_per_iaa); + if (ret) { + pr_debug("IAA g_wqs_per_iaa attr creation failed\n"); + goto err_g_wqs_per_iaa_attr_create; + } + + ret = driver_create_file(&iaa_crypto_driver.drv, + &driver_attr_g_consec_descs_per_gwq); + if (ret) { + pr_debug("IAA g_consec_descs_per_gwq attr creation failed\n"); + goto err_g_consec_descs_per_gwq_attr_create; + } + if (iaa_crypto_debugfs_init()) pr_warn("debugfs init failed, stats not available\n"); pr_debug("initialized\n"); out: return ret; - +err_g_consec_descs_per_gwq_attr_create: + driver_remove_file(&iaa_crypto_driver.drv, + &driver_attr_g_wqs_per_iaa); +err_g_wqs_per_iaa_attr_create: + driver_remove_file(&iaa_crypto_driver.drv, + &driver_attr_sync_mode); err_sync_attr_create: driver_remove_file(&iaa_crypto_driver.drv, &driver_attr_verify_compress); @@ -2423,6 +2694,10 @@ static void __exit iaa_crypto_cleanup_module(void) &driver_attr_sync_mode); driver_remove_file(&iaa_crypto_driver.drv, &driver_attr_verify_compress); + driver_remove_file(&iaa_crypto_driver.drv, + &driver_attr_g_wqs_per_iaa); + driver_remove_file(&iaa_crypto_driver.drv, + &driver_attr_g_consec_descs_per_gwq); idxd_driver_unregister(&iaa_crypto_driver); iaa_aecs_cleanup_fixed(); crypto_free_comp(deflate_generic_tfm); From patchwork Wed Nov 6 19:21:00 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865323 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 10686D59F6C for ; Wed, 6 Nov 2024 19:21:33 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id A179C6B0099; Wed, 6 Nov 2024 14:21:18 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 9BD356B009A; Wed, 6 Nov 2024 14:21:18 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 810526B009B; Wed, 6 Nov 2024 14:21:18 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 5EE636B0099 for ; Wed, 6 Nov 2024 14:21:18 -0500 (EST) Received: from smtpin25.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay04.hostedemail.com (Postfix) with ESMTP id 24AEC1A06CF for ; Wed, 6 Nov 2024 19:21:18 +0000 (UTC) X-FDA: 82756637292.25.B561C6F Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf23.hostedemail.com (Postfix) with ESMTP id 5A11C14001D for ; Wed, 6 Nov 2024 19:20:53 +0000 (UTC) Authentication-Results: imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=UiPFPSU8; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920816; a=rsa-sha256; cv=none; b=UqTivA0NFvyMW6tVSMQLiXyKbmX/oNC3N+dXHS+ymEupzPWN+z5OgQBnl/T+uK00eUJmd0 bfSiJL4hUMiwkIEuK69GTpmxCT+iy6NrQD4ZrOukdNM5SzWuhNCxhGopz7Zn6aJ8WeHlfX /1WRz2bidZghFclJ37I+sCwTN7Efq6k= ARC-Authentication-Results: i=1; imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=UiPFPSU8; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920816; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=Qxz8u9Shn/SiPqBxAwwlyMbQX8CsM2ppl302cd3vziA=; b=Fjmnjp/pODocZihziSdRXM6WnrwYTTJhda012ITsGc3dax+jOfowqcpjY1GSuN1Z+SXmND aVNf5OHRqw4/bvG0ykBL44vu7ORh6zjfnp0FnTBcd6KdTGc+ai8mblDKQ12C6YrCvqeBBR HfMyx+ERE+3/MvGDYuGCZUIru3f/qmY= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920876; x=1762456876; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=e3w3jsrwSRn0skEK+1OKRkuNEeuFjmM/VVAG1YViexY=; b=UiPFPSU8Ov7UOiS7tp2v9uaefhC5/EiITiGp9//V/RUpgtVv3Ec3d4Ai hURV99CwD/6cLIFQ/lLiThGLkaJ0yTa5lFGKfZO3HNruJDFNdePC1aRmh rzwYzetNzEy2QDF/R+3iWu3ewoE5UcZEcpMcussE8VAtMwVO+WJcnZYBb T0w6PesVK+txE8bTmpSK/zhlDO3+9LqeIouxqnuMHSpJG1QfxgGqlPXMt KHpiCn/DAtTrYp38pSW+BwQlKyGfuxz8AVh7js8XWjzYEocHHIYrMBGlv TXBj9X31XwrVmE58g8jfQQPVw7h5K9rlV9QIQANg2z/Qah0dAtbRzwnMs w==; X-CSE-ConnectionGUID: W3CMmoTWRgyA9rHSDa2tVw== X-CSE-MsgGUID: g6YagjqxQ1anNsUVUgMtnA== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292024" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292024" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:12 -0800 X-CSE-ConnectionGUID: JuZp7wgeTZupSYi8bw+nGA== X-CSE-MsgGUID: /kRNAQktRwSLiBLyCdU2qg== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695402" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:11 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 08/13] mm: zswap: acomp_ctx mutex lock/unlock optimizations. Date: Wed, 6 Nov 2024 11:21:00 -0800 Message-Id: <20241106192105.6731-9-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 5A11C14001D X-Rspamd-Server: rspam11 X-Stat-Signature: kzwhnmpr6bm5zmst9zxkxkedgj33g8gu X-HE-Tag: 1730920853-584332 X-HE-Meta: U2FsdGVkX1/nKCcqmgIO7eDDPWZ/rPdVeOLalcVN04i06hJobhpgkVb92mZHnmUxvHfl5kPU7yF18OqjKQCgx2HI7xhh2JJeU+xhczmcvNGWpIybYpYkoX73b6tPwHKGse1kwjIhg7Y6+0YdOTUFh36GjVGsuVZUOJHqvmNkzMTrNpWFxRna6Ux4meKB1avmMY7ZA+HdigWK+NmidPgdCOUsCNP4kZA//VSWOtJdDvxPY6CIOYvcnDXEV//51RXhHZ5mXp6NqcxatGB90OCulkoCjEnkXl4DupJp0qlenLEi2/kCbPLXApFSjt3aVwEhjJ2ZsxxxNDfmbgonDZwqUdylgMnCqVZ1D8uPWxQHBiatB40ihQDyiq/mY0MmcfO19AtgVCzNifclEy5Qzmo5D+S/oUJyKJt+9KbKpa2wD3FqXfQ8L0/Yh3CAQWF4yb+uWTIlLH7B34IBGw10oH5hVhwLoUAqFdY7P3bcDNLvVsgnC2k0rNHt7GjF0yMS5Vnk7ki7/vVBfhYHexgayoceug8IXSB9XiLuGxrDCD6Wv/g+I9YbtvKwHoOQhPZ/SjsQ4b8ycMacbZcXKwYXPrSblLj6yXfOvynvvisNk9546UjRsp1JzRKS1/bv+mDmL+rTt0Qd0mv41Z38cViYw96xm0wCgYMzMggwt7VndWmterhHJkqkfRVU4XX/rSk2tr9URkmGpI5hoNEnWrSI56XxALXw3m+EPnhXsZO6m2N0zPFNBFJnC3h7952UGT4LV22sood+DNqsXk5tdE1sAlR2ibYaOtX3oCcqlFVhttSwkSX3gS7auLzCpI49CP+vgbgXDMXzeNMupHZCWJGjpDFa7QSbUvitOtfZZwCTw0alEvPN7XEvPDwFmu/8nZA53uFfdNwi3Y9rNzAwPJ2R7Fviv9otIwpZ1hbXJe1eh34rKYN3Yw96vq541xawcyqMk0vZ/I9Mj88fWT96owgUxfx 0MrI+NmI dmcOvG+YmI8UjDusCsuEW6BUaKNNJ3AN9yrQuQhZnr/h7g8xUFf5IhlBT1XjDXYLjC8ek+PP9s1rR8vOhkmZZoSw2fmA7X5Zu7oFBlNiRhVRkAirdFBsf0pqp86TXoDnASEzi6VWDYlCw3JotZLZ9fcyVmGHYid5RYKFx09axd4mhIbTVGT0jd2ap+6DhQlL1Oba55u7e+Re4OR8vihFu+ifOSZGeGjCe92Z7L+zhKFAPR64Sxz5CYTWc25w1BCV1BxwrHohgNIwA8+E= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This patch implements two changes with respect to the acomp_ctx mutex lock: 1) The mutex lock is not acquired/released in zswap_compress(). Instead, zswap_store() acquires the mutex lock once before compressing each page in a large folio, and releases the lock once all pages in the folio have been compressed. This should reduce some compute cycles in case of large folio stores. 2) In zswap_decompress(), the mutex lock is released after the conditional zpool_unmap_handle() based on "src != acomp_ctx->buffer" rather than before. This ensures that the value of "src" obtained earlier does not change. If the mutex lock is released before the comparison of "src" it is possible that another call to reclaim by the same process could obtain the mutex lock and over-write the value of "src". Signed-off-by: Kanchana P Sridhar --- mm/zswap.c | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/mm/zswap.c b/mm/zswap.c index f6316b66fb23..3e899fa61445 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -880,6 +880,9 @@ static int zswap_cpu_comp_dead(unsigned int cpu, struct hlist_node *node) return 0; } +/* + * The acomp_ctx->mutex must be locked/unlocked in the calling procedure. + */ static bool zswap_compress(struct page *page, struct zswap_entry *entry, struct zswap_pool *pool) { @@ -895,8 +898,6 @@ static bool zswap_compress(struct page *page, struct zswap_entry *entry, acomp_ctx = raw_cpu_ptr(pool->acomp_ctx); - mutex_lock(&acomp_ctx->mutex); - dst = acomp_ctx->buffer; sg_init_table(&input, 1); sg_set_page(&input, page, PAGE_SIZE, 0); @@ -949,7 +950,6 @@ static bool zswap_compress(struct page *page, struct zswap_entry *entry, else if (alloc_ret) zswap_reject_alloc_fail++; - mutex_unlock(&acomp_ctx->mutex); return comp_ret == 0 && alloc_ret == 0; } @@ -986,10 +986,16 @@ static void zswap_decompress(struct zswap_entry *entry, struct folio *folio) acomp_request_set_params(acomp_ctx->req, &input, &output, entry->length, PAGE_SIZE); BUG_ON(crypto_wait_req(crypto_acomp_decompress(acomp_ctx->req), &acomp_ctx->wait)); BUG_ON(acomp_ctx->req->dlen != PAGE_SIZE); - mutex_unlock(&acomp_ctx->mutex); if (src != acomp_ctx->buffer) zpool_unmap_handle(zpool, entry->handle); + + /* + * It is safer to unlock the mutex after the check for + * "src != acomp_ctx->buffer" so that the value of "src" + * does not change. + */ + mutex_unlock(&acomp_ctx->mutex); } /********************************* @@ -1487,6 +1493,7 @@ bool zswap_store(struct folio *folio) { long nr_pages = folio_nr_pages(folio); swp_entry_t swp = folio->swap; + struct crypto_acomp_ctx *acomp_ctx; struct obj_cgroup *objcg = NULL; struct mem_cgroup *memcg = NULL; struct zswap_pool *pool; @@ -1526,6 +1533,9 @@ bool zswap_store(struct folio *folio) mem_cgroup_put(memcg); } + acomp_ctx = raw_cpu_ptr(pool->acomp_ctx); + mutex_lock(&acomp_ctx->mutex); + for (index = 0; index < nr_pages; ++index) { struct page *page = folio_page(folio, index); ssize_t bytes; @@ -1547,6 +1557,7 @@ bool zswap_store(struct folio *folio) ret = true; put_pool: + mutex_unlock(&acomp_ctx->mutex); zswap_pool_put(pool); put_objcg: obj_cgroup_put(objcg); From patchwork Wed Nov 6 19:21:01 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865324 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id BF591D59F6B for ; Wed, 6 Nov 2024 19:21:35 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 4B9066B009B; Wed, 6 Nov 2024 14:21:19 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 46A416B009C; Wed, 6 Nov 2024 14:21:19 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 2BAF46B009D; Wed, 6 Nov 2024 14:21:19 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 058F06B009A for ; Wed, 6 Nov 2024 14:21:18 -0500 (EST) Received: from smtpin25.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id AC172121D60 for ; Wed, 6 Nov 2024 19:21:18 +0000 (UTC) X-FDA: 82756637334.25.DD3A023 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf18.hostedemail.com (Postfix) with ESMTP id 243091C0010 for ; Wed, 6 Nov 2024 19:21:00 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=A2CMKXob; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920792; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=aYdW0zq6nuiuC3om5oGcxQH/8ZdFh38GqlmuO3OCSvQ=; b=dk3ssuQLTaHjx6G1lrWSGWMndTa2cBgEXtHUi+9fRWw3bjeqYCKNq+iizSMFAZA6JkHY92 5xn7mRHAG2f5M4WH18rzb0LFYNVS5VcNF8jwbVmzDHOLEJ6I6yP7VTC25u2qfYv79DGjYM yK3mD9CWUvxZp9IexzK/CwO1eXToSSQ= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=A2CMKXob; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920792; a=rsa-sha256; cv=none; b=X+hM024D8oSM8zM7Q0w3GgTnx6wqFFIBs6MwIFLKIsVWmKASqT3OLIDZYd0NofvZMO9diw s3uykt7P5juxbWYo4MaD2Nkr6Zyle4r6I7QkWQ0PowuD4LnoJ/uE4en0bVEimmBfZlbfG1 c5L4ebM225CiMncQPKNX1TPFJmjrrLE= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920877; x=1762456877; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=r/PiZ6L9gIKB3NWj5x6kNiz1Cz0bRXxaZZCRHikpYT4=; b=A2CMKXobzn98lTpPpLJ/pnmIsH8rGzC/N8Py3XXDdlxP45tETgSFDPX2 bB6bxmO/htZ1lGZqfrc+1+n+N1Vij1ziYUSnwwqjh0TUAh4ZDECPkAQpF GMFRU6BXZN6DhV9kQmQj06foQj+j+CbPly+ldArKaFUfJIsspE/jMM8ve zK2Jh5VYB30CoRmaOJE/ejcGaIM4E1oOvxXXdxKTP2+fZ2JILOlw1I5fD zPBPqJVF2/hBIKj5lNGRTc3zFzSnPj753WjYGwpRMpbkJ5K1TOMlPmxbr DzViTbqj/Yb2Qo1eEDQAwIGzlyC8kG8fA67G1N6X1D+cHkIU0E0LI8SYW g==; X-CSE-ConnectionGUID: 1DKdQZo1QZmM0cpXw0q2SA== X-CSE-MsgGUID: D/L2vyjXSLqqUNEKt43gJg== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292037" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292037" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:12 -0800 X-CSE-ConnectionGUID: dprjYx6MRXCZ/IHxNSx7pA== X-CSE-MsgGUID: QW0E949yR+eziFEtkGDYIA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695405" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:11 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 09/13] mm: zswap: Modify struct crypto_acomp_ctx to be configurable in nr of acomp_reqs. Date: Wed, 6 Nov 2024 11:21:01 -0800 Message-Id: <20241106192105.6731-10-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: 243091C0010 X-Stat-Signature: pf6gudikirgtgfoe6wcg6dpj4zkzhdoe X-HE-Tag: 1730920860-279956 X-HE-Meta: U2FsdGVkX18PCv3S6WabM/8ZRWLXp+DM6XlH3QAsv0NVtH4IUvOAbbX0v4gHTo/VbqOXoOVY1U1/CILpBYfdxxK4tWhPEzeMVkuKwO0avbW/+Rc3XS81JqeiVNG2dtQmLh4L+a8ZHZbS1o86kqSNuBGLxez1zSEcb20RO4Ot/j14QIxf0JCFDJjlb/d0X825HD1UEYeQ0Zdm1K1/Wz3+zfZPD/BcPQkGtUIxFce8efl8ipMJXHhJQXubcueSmwgdMxtf5M5b3bx3HyDyQDYQIBgDmoWnZNhKZd4HwHQ8axkHCr5E8kDZIz/oC3pbpLAGkJvv0WblZXEcFdF7g356KNLxoUM/KjDAnKNDKGsTmFT90gBulpffA1jTApMcQavVdSABxQsBxjvArUcn/OgMzcdX0Do7EGlFYT50FA5KVAT2ijeXnwmv9UmsmmHdxnCAR5BrINKyLwA0oB9kXA1+BkEF6mabnnlR1TVSVQCOLJbdbzaNDa2fDUDxmfBLnin93oY7Ja4YtQXQEwSm7DlZ7oE6vd7o2Bz8VMRqrz0dbf9F12QRAkLnDpxtmHdlUM3rqxgPM58o+TY74LyLqoJTbNsgzsb2IKLIEK6+Te3O1XhH3zTVwkPd0TnDSUjPE/bWcoSSApVrArpPBW3DyNKu8LwNwwRIZZOECSqFe8ojRknQLsTiDqkjo1pe5hiziI/Smc5HGn9DKlyW8kTUbVy68ImnhHaDM/R0WkFvBco4osSSgPtSDVupe+oQrI480inFwM5x6JJLNDjvV7J/7T8V23gfA0rqfd3qFcJnyuS4ZCA2hvtyIvj20Aa7aLS+xhv+bGhqNgKPgPv/Jzta8YFGAUfmW195ktpcxiI/qSTE01BEHprJUGJJL6IacQVnTjmL4gwEb/jw766e7rydvKNLeelrQuloCuvS7BsPBk+0Rb+wt4RmCyfn1oAOCPxaA0HSiU8xd34CAjtVVnkol0T g316XfUp ORSbEjh/YY4d4PebRQ2VAz1cieJQPECWY+wfudVFpCjSeRoBr+wUrNXQ9Byrk4pFouZqODDoG6SQDDKgXuaO2CXqPoVfIjqVhMI6CAlPwYDIKRJP9Epq2NrFo5BsTOgyrTHnJnWiUrME/vfhJfaKJn5UvKOgkGTKrEPOF+Vp6pE36/NFASxY1M6Sc4vSMseLcC/tR6rgazifcc8gbVagmCSdRjWS/TA80TGg75eRVQ4rrJp8= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Modified the definition of "struct crypto_acomp_ctx" to represent a configurable number of acomp_reqs and the required number of buffers. Accordingly, refactored the code that allocates/deallocates the acomp_ctx resources, so that it can be called to create a regular acomp_ctx with exactly one acomp_req/buffer, for use in the the existing non-batching zswap_store(), as well as to create a separate "batching acomp_ctx" with multiple acomp_reqs/buffers for IAA compress batching. Signed-off-by: Kanchana P Sridhar --- mm/zswap.c | 149 ++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 107 insertions(+), 42 deletions(-) diff --git a/mm/zswap.c b/mm/zswap.c index 3e899fa61445..02e031122fdf 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -143,9 +143,10 @@ bool zswap_never_enabled(void) struct crypto_acomp_ctx { struct crypto_acomp *acomp; - struct acomp_req *req; + struct acomp_req **reqs; + u8 **buffers; + unsigned int nr_reqs; struct crypto_wait wait; - u8 *buffer; struct mutex mutex; bool is_sleepable; }; @@ -241,6 +242,11 @@ static inline struct xarray *swap_zswap_tree(swp_entry_t swp) pr_debug("%s pool %s/%s\n", msg, (p)->tfm_name, \ zpool_get_type((p)->zpool)) +static int zswap_create_acomp_ctx(unsigned int cpu, + struct crypto_acomp_ctx *acomp_ctx, + char *tfm_name, + unsigned int nr_reqs); + /********************************* * pool functions **********************************/ @@ -813,69 +819,128 @@ static void zswap_entry_free(struct zswap_entry *entry) /********************************* * compressed storage functions **********************************/ -static int zswap_cpu_comp_prepare(unsigned int cpu, struct hlist_node *node) +static int zswap_create_acomp_ctx(unsigned int cpu, + struct crypto_acomp_ctx *acomp_ctx, + char *tfm_name, + unsigned int nr_reqs) { - struct zswap_pool *pool = hlist_entry(node, struct zswap_pool, node); - struct crypto_acomp_ctx *acomp_ctx = per_cpu_ptr(pool->acomp_ctx, cpu); struct crypto_acomp *acomp; - struct acomp_req *req; - int ret; + int ret = -ENOMEM; + int i, j; + acomp_ctx->nr_reqs = 0; mutex_init(&acomp_ctx->mutex); - acomp_ctx->buffer = kmalloc_node(PAGE_SIZE * 2, GFP_KERNEL, cpu_to_node(cpu)); - if (!acomp_ctx->buffer) - return -ENOMEM; - - acomp = crypto_alloc_acomp_node(pool->tfm_name, 0, 0, cpu_to_node(cpu)); + acomp = crypto_alloc_acomp_node(tfm_name, 0, 0, cpu_to_node(cpu)); if (IS_ERR(acomp)) { pr_err("could not alloc crypto acomp %s : %ld\n", - pool->tfm_name, PTR_ERR(acomp)); - ret = PTR_ERR(acomp); - goto acomp_fail; + tfm_name, PTR_ERR(acomp)); + return PTR_ERR(acomp); } + acomp_ctx->acomp = acomp; acomp_ctx->is_sleepable = acomp_is_async(acomp); - req = acomp_request_alloc(acomp_ctx->acomp); - if (!req) { - pr_err("could not alloc crypto acomp_request %s\n", - pool->tfm_name); - ret = -ENOMEM; + acomp_ctx->buffers = kmalloc_node(nr_reqs * sizeof(u8 *), + GFP_KERNEL, cpu_to_node(cpu)); + if (!acomp_ctx->buffers) + goto buf_fail; + + for (i = 0; i < nr_reqs; ++i) { + acomp_ctx->buffers[i] = kmalloc_node(PAGE_SIZE * 2, + GFP_KERNEL, cpu_to_node(cpu)); + if (!acomp_ctx->buffers[i]) { + for (j = 0; j < i; ++j) + kfree(acomp_ctx->buffers[j]); + kfree(acomp_ctx->buffers); + ret = -ENOMEM; + goto buf_fail; + } + } + + acomp_ctx->reqs = kmalloc_node(nr_reqs * sizeof(struct acomp_req *), + GFP_KERNEL, cpu_to_node(cpu)); + if (!acomp_ctx->reqs) goto req_fail; + + for (i = 0; i < nr_reqs; ++i) { + acomp_ctx->reqs[i] = acomp_request_alloc(acomp_ctx->acomp); + if (!acomp_ctx->reqs[i]) { + pr_err("could not alloc crypto acomp_request reqs[%d] %s\n", + i, tfm_name); + for (j = 0; j < i; ++j) + acomp_request_free(acomp_ctx->reqs[j]); + kfree(acomp_ctx->reqs); + ret = -ENOMEM; + goto req_fail; + } } - acomp_ctx->req = req; + /* + * The crypto_wait is used only in fully synchronous, i.e., with scomp + * or non-poll mode of acomp, hence there is only one "wait" per + * acomp_ctx, with callback set to reqs[0], under the assumption that + * there is at least 1 request per acomp_ctx. + */ crypto_init_wait(&acomp_ctx->wait); /* * if the backend of acomp is async zip, crypto_req_done() will wakeup * crypto_wait_req(); if the backend of acomp is scomp, the callback * won't be called, crypto_wait_req() will return without blocking. */ - acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, + acomp_request_set_callback(acomp_ctx->reqs[0], CRYPTO_TFM_REQ_MAY_BACKLOG, crypto_req_done, &acomp_ctx->wait); + acomp_ctx->nr_reqs = nr_reqs; return 0; req_fail: + for (i = 0; i < nr_reqs; ++i) + kfree(acomp_ctx->buffers[i]); + kfree(acomp_ctx->buffers); +buf_fail: crypto_free_acomp(acomp_ctx->acomp); -acomp_fail: - kfree(acomp_ctx->buffer); return ret; } -static int zswap_cpu_comp_dead(unsigned int cpu, struct hlist_node *node) +static void zswap_delete_acomp_ctx(struct crypto_acomp_ctx *acomp_ctx) { - struct zswap_pool *pool = hlist_entry(node, struct zswap_pool, node); - struct crypto_acomp_ctx *acomp_ctx = per_cpu_ptr(pool->acomp_ctx, cpu); - if (!IS_ERR_OR_NULL(acomp_ctx)) { - if (!IS_ERR_OR_NULL(acomp_ctx->req)) - acomp_request_free(acomp_ctx->req); + int i; + + for (i = 0; i < acomp_ctx->nr_reqs; ++i) + if (!IS_ERR_OR_NULL(acomp_ctx->reqs[i])) + acomp_request_free(acomp_ctx->reqs[i]); + kfree(acomp_ctx->reqs); + + for (i = 0; i < acomp_ctx->nr_reqs; ++i) + kfree(acomp_ctx->buffers[i]); + kfree(acomp_ctx->buffers); + if (!IS_ERR_OR_NULL(acomp_ctx->acomp)) crypto_free_acomp(acomp_ctx->acomp); - kfree(acomp_ctx->buffer); + + acomp_ctx->nr_reqs = 0; + acomp_ctx = NULL; } +} + +static int zswap_cpu_comp_prepare(unsigned int cpu, struct hlist_node *node) +{ + struct zswap_pool *pool = hlist_entry(node, struct zswap_pool, node); + struct crypto_acomp_ctx *acomp_ctx; + + acomp_ctx = per_cpu_ptr(pool->acomp_ctx, cpu); + return zswap_create_acomp_ctx(cpu, acomp_ctx, pool->tfm_name, 1); +} + +static int zswap_cpu_comp_dead(unsigned int cpu, struct hlist_node *node) +{ + struct zswap_pool *pool = hlist_entry(node, struct zswap_pool, node); + struct crypto_acomp_ctx *acomp_ctx; + + acomp_ctx = per_cpu_ptr(pool->acomp_ctx, cpu); + zswap_delete_acomp_ctx(acomp_ctx); return 0; } @@ -898,7 +963,7 @@ static bool zswap_compress(struct page *page, struct zswap_entry *entry, acomp_ctx = raw_cpu_ptr(pool->acomp_ctx); - dst = acomp_ctx->buffer; + dst = acomp_ctx->buffers[0]; sg_init_table(&input, 1); sg_set_page(&input, page, PAGE_SIZE, 0); @@ -908,7 +973,7 @@ static bool zswap_compress(struct page *page, struct zswap_entry *entry, * giving the dst buffer with enough length to avoid buffer overflow. */ sg_init_one(&output, dst, PAGE_SIZE * 2); - acomp_request_set_params(acomp_ctx->req, &input, &output, PAGE_SIZE, dlen); + acomp_request_set_params(acomp_ctx->reqs[0], &input, &output, PAGE_SIZE, dlen); /* * it maybe looks a little bit silly that we send an asynchronous request, @@ -922,8 +987,8 @@ static bool zswap_compress(struct page *page, struct zswap_entry *entry, * but in different threads running on different cpu, we have different * acomp instance, so multiple threads can do (de)compression in parallel. */ - comp_ret = crypto_wait_req(crypto_acomp_compress(acomp_ctx->req), &acomp_ctx->wait); - dlen = acomp_ctx->req->dlen; + comp_ret = crypto_wait_req(crypto_acomp_compress(acomp_ctx->reqs[0]), &acomp_ctx->wait); + dlen = acomp_ctx->reqs[0]->dlen; if (comp_ret) goto unlock; @@ -975,24 +1040,24 @@ static void zswap_decompress(struct zswap_entry *entry, struct folio *folio) */ if ((acomp_ctx->is_sleepable && !zpool_can_sleep_mapped(zpool)) || !virt_addr_valid(src)) { - memcpy(acomp_ctx->buffer, src, entry->length); - src = acomp_ctx->buffer; + memcpy(acomp_ctx->buffers[0], src, entry->length); + src = acomp_ctx->buffers[0]; zpool_unmap_handle(zpool, entry->handle); } sg_init_one(&input, src, entry->length); sg_init_table(&output, 1); sg_set_folio(&output, folio, PAGE_SIZE, 0); - acomp_request_set_params(acomp_ctx->req, &input, &output, entry->length, PAGE_SIZE); - BUG_ON(crypto_wait_req(crypto_acomp_decompress(acomp_ctx->req), &acomp_ctx->wait)); - BUG_ON(acomp_ctx->req->dlen != PAGE_SIZE); + acomp_request_set_params(acomp_ctx->reqs[0], &input, &output, entry->length, PAGE_SIZE); + BUG_ON(crypto_wait_req(crypto_acomp_decompress(acomp_ctx->reqs[0]), &acomp_ctx->wait)); + BUG_ON(acomp_ctx->reqs[0]->dlen != PAGE_SIZE); - if (src != acomp_ctx->buffer) + if (src != acomp_ctx->buffers[0]) zpool_unmap_handle(zpool, entry->handle); /* * It is safer to unlock the mutex after the check for - * "src != acomp_ctx->buffer" so that the value of "src" + * "src != acomp_ctx->buffers[0]" so that the value of "src" * does not change. */ mutex_unlock(&acomp_ctx->mutex); From patchwork Wed Nov 6 19:21:02 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865325 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id BC222D59F6B for ; Wed, 6 Nov 2024 19:21:38 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 785FF6B009A; Wed, 6 Nov 2024 14:21:19 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 7272A6B009D; Wed, 6 Nov 2024 14:21:19 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 4B4176B009A; Wed, 6 Nov 2024 14:21:19 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 23FF36B009B for ; Wed, 6 Nov 2024 14:21:19 -0500 (EST) Received: from smtpin08.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id CD350121CCE for ; Wed, 6 Nov 2024 19:21:18 +0000 (UTC) X-FDA: 82756637082.08.94D3376 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf12.hostedemail.com (Postfix) with ESMTP id D2EDC4001D for ; Wed, 6 Nov 2024 19:21:00 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=G6HeRrHw; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920691; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=F/Uy7y3NcF6okk5WlByY6be1T9l4fQSEE1YVDAB/Rzs=; b=wJYrOOi6GuAhZetTgpFpchZoFXYIXZw2c4DiIO8HHRGHaQey2iKDNxSGnFOJElKHvYdOi3 VaBOVTbXw1MQBuof8dKrB8fNZLk7jjRt8EOj3uU2kmX8iz6qoP525eg+arJBYKse2X8gN4 Mb0iCSc+gYGRoqbzIMVW8a/tsia5fyI= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=G6HeRrHw; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920691; a=rsa-sha256; cv=none; b=2wO/dUhfm+6rm8yy0TAKFNbqdNhejACt6muDUh52gOZvc8zS6htkjUeNkmXouK/KIlARoW 0U6lqq9XS5VqiOlMKyfio4Z50IgnajPf8VSRFARaSqzWea9A4bVYpDgouOFk3oQ3Wvlo/O OsC3p8dv6iF+gnHv1PaIe+pG9an413Y= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920877; x=1762456877; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=FAnZNiRqeUl7Ne2U4+z2H8Xn+OqrQ2UYadwz7Qe0Ap8=; b=G6HeRrHw86TOtV0MWO30bZo3sTq5CIZ0idzSQPgldGUjD3BhBb/Tr5wW 5o4qwqH6yPJ+HHAcUGYIRb3TAzEmMGqdoZgR2LdvrwYQZf/cWHcZst8MF hGl2URfpw5H4XjrEAbz02JYEhApTu+2TdCHMeI49hYeLjd8lqXe8uzJao mVuGcawHMCvuVs3UUOFdKYzOU+8LBOpnYkFa3BMfdrspJHppQ5+p1x0B3 N0NORNKAoP13ADui7fkpSvPD85d95bXgMW8fAdGw5rSoLMdWFteWQvr0/ kAghaOga0rnaJ2Axd4DD8mr4jnsmK573TRvN01qU3MrmyAONjCDGWdOUi g==; X-CSE-ConnectionGUID: hQLCDQrBQiOyInhVRwJl6w== X-CSE-MsgGUID: KVjK8+thTZSdhis+kJekag== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292049" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292049" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:13 -0800 X-CSE-ConnectionGUID: 6oXbOKZDRWiqdJfoYia+Yg== X-CSE-MsgGUID: 7yNp1XuCTqGZv0eIhDj5ZQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695410" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:12 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 10/13] mm: zswap: Add a per-cpu "acomp_batch_ctx" to struct zswap_pool. Date: Wed, 6 Nov 2024 11:21:02 -0800 Message-Id: <20241106192105.6731-11-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: D2EDC4001D X-Stat-Signature: 6qsc49d39uh6yn97w7eqp47axrfkukpo X-Rspam-User: X-HE-Tag: 1730920860-367380 X-HE-Meta: U2FsdGVkX18ipfXYjNCNlf1q4rYxTkhFH064NdbioVaJRch9sRzb5wm2dsqPLIUlt5AuTu/dZ/KRbSNJ7wfna9DeoNo9UIfTLd+mv+RNSolj6QzNq/qzK2sw6bVDkoU9p5YvBqYsLhBlOhgpjVEzOvmUvt1fCXKJVwrQUp/HZttNaW5BgUuqYkWW8SKYJic6KzRs0SHVccD7TPQ4Jc5KEC97yh8fF4Uk2sYXBU5Btwl1dprH0QjCSGm5QbNswjxQ8vewzXpEE1T+uyeNg8QE9V9seOb3ywSokRLmtLIS0++KSyfI8sbtk1HUjvpnf2tbb1fn4jFSsBWUUJgDEQQecOZpT4sQCifj3yt2hRrTyrKenQb4WwAciAkmBqkA6uYT6o321SyNcbmE4280LiHGzpWG0Y1uyzZcQSH3ve8UZZ7mmVRuw7o8Ym7dWxndrjdP1c2HKGQYDhEsqvoKhmikgaZ5rA/o6oitTMwYUDfLOk+D5bio1j+nLv3o9aPNvNsLWYBHCg3h6oe9PpZ14QRkPHJC76zZk5dyu2spF9xYL52g837RGDf5gte5YQ7pmhOnsLKdwLFHOjjTN/Kfgi582RwZlejmKNb5Ofw0UCrWlTqH+ELOzmtiS4DMXxK7mN1cisOz79Ojreyp2QRdh6EwhY6H04diwU35Zzwz4yvm1AwcEtbb14Xpc0YNL7qJyxiKMnkuUOInOAFClba0yZE0hWAWmr2vnwqmdcaAi1c91Y/WgHKL221yUBxXrLvnfOVNt3h/29SlEMrbxkcLfTSRLQsUT4sXE0OaLFIxbXdGBY2L6nzD0fX1oKW8ah5Gr7VhNV1PwgKOv2vOyXdXAuRBefMhtw2wqMKn0UhFBrc/aQOKHpLJJLZcDlvILaKGVYS7UrKN0B9D5VZqeb/9QZHJMlb7nc8UOkjNMXsEqx5XEWYJyEOTBECiYu1JQLvuhespMOcv4C4yT83ny5Beyqb BCtHjzNB H1RVNpML9hWKFrVsE+UsBtFtPw29Ekpno94sR21qpev7ltRTgIjAK1smFYx7x8OJsVMM8DPRnv9aTmWYPZ8Pqn6b0SFH+SwhXiTY9UwJn2vk1QyD1WfEgKpBd8Iy2z2abPiMgf1DCPsuebzBXR7PYtBNQHtAR/JR+1sReyrQ1DhBr1i0vzxuMUsVGhFQSHKO8TlFf8udgFZtGQ9HVztodzIb+T3Cza638Iqelk16rE7wSr3XogVuQZABny8tL61NZryaS X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This patch adds a separate per-cpu batching acomp context "acomp_batch_ctx" to the zswap_pool. The per-cpu acomp_batch_ctx pointer is allocated at pool creation time, but no per-cpu resources are allocated for it. The idea is to not incur the memory footprint cost of multiple acomp_reqs and buffers in the existing "acomp_ctx" for cases where compress batching is not possible; for instance, with software compressor algorithms, on systems without IAA, on systems with IAA that want to run the existing non-batching implementation of zswap_store() of large folios. By creating a separate acomp_batch_ctx, we have the ability to allocate additional memory per-cpu only if the zswap compressor supports batching, and if the user wants to enable the use of compress batching in zswap_store() to improve swapout performance of large folios. Suggested-by: Yosry Ahmed Signed-off-by: Kanchana P Sridhar --- mm/zswap.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/mm/zswap.c b/mm/zswap.c index 02e031122fdf..80a928cf0f7e 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -160,6 +160,7 @@ struct crypto_acomp_ctx { struct zswap_pool { struct zpool *zpool; struct crypto_acomp_ctx __percpu *acomp_ctx; + struct crypto_acomp_ctx __percpu *acomp_batch_ctx; struct percpu_ref ref; struct list_head list; struct work_struct release_work; @@ -287,10 +288,14 @@ static struct zswap_pool *zswap_pool_create(char *type, char *compressor) pool->acomp_ctx = alloc_percpu(*pool->acomp_ctx); if (!pool->acomp_ctx) { - pr_err("percpu alloc failed\n"); + pr_err("percpu acomp_ctx alloc failed\n"); goto error; } + pool->acomp_batch_ctx = alloc_percpu(*pool->acomp_batch_ctx); + if (!pool->acomp_batch_ctx) + pr_err("percpu acomp_batch_ctx alloc failed\n"); + ret = cpuhp_state_add_instance(CPUHP_MM_ZSWP_POOL_PREPARE, &pool->node); if (ret) @@ -312,6 +317,8 @@ static struct zswap_pool *zswap_pool_create(char *type, char *compressor) ref_fail: cpuhp_state_remove_instance(CPUHP_MM_ZSWP_POOL_PREPARE, &pool->node); error: + if (pool->acomp_batch_ctx) + free_percpu(pool->acomp_batch_ctx); if (pool->acomp_ctx) free_percpu(pool->acomp_ctx); if (pool->zpool) @@ -368,6 +375,8 @@ static void zswap_pool_destroy(struct zswap_pool *pool) cpuhp_state_remove_instance(CPUHP_MM_ZSWP_POOL_PREPARE, &pool->node); free_percpu(pool->acomp_ctx); + if (pool->acomp_batch_ctx) + free_percpu(pool->acomp_batch_ctx); zpool_destroy_pool(pool->zpool); kfree(pool); @@ -930,6 +939,11 @@ static int zswap_cpu_comp_prepare(unsigned int cpu, struct hlist_node *node) struct zswap_pool *pool = hlist_entry(node, struct zswap_pool, node); struct crypto_acomp_ctx *acomp_ctx; + if (pool->acomp_batch_ctx) { + acomp_ctx = per_cpu_ptr(pool->acomp_batch_ctx, cpu); + acomp_ctx->nr_reqs = 0; + } + acomp_ctx = per_cpu_ptr(pool->acomp_ctx, cpu); return zswap_create_acomp_ctx(cpu, acomp_ctx, pool->tfm_name, 1); } @@ -939,6 +953,12 @@ static int zswap_cpu_comp_dead(unsigned int cpu, struct hlist_node *node) struct zswap_pool *pool = hlist_entry(node, struct zswap_pool, node); struct crypto_acomp_ctx *acomp_ctx; + if (pool->acomp_batch_ctx) { + acomp_ctx = per_cpu_ptr(pool->acomp_batch_ctx, cpu); + if (!IS_ERR_OR_NULL(acomp_ctx) && (acomp_ctx->nr_reqs > 0)) + zswap_delete_acomp_ctx(acomp_ctx); + } + acomp_ctx = per_cpu_ptr(pool->acomp_ctx, cpu); zswap_delete_acomp_ctx(acomp_ctx); From patchwork Wed Nov 6 19:21:03 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865326 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id D8CEFD59F6D for ; Wed, 6 Nov 2024 19:21:41 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id EB18B6B009D; Wed, 6 Nov 2024 14:21:20 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id E5F686B009E; Wed, 6 Nov 2024 14:21:20 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id CA67E6B009F; Wed, 6 Nov 2024 14:21:20 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id A7FC36B009D for ; Wed, 6 Nov 2024 14:21:20 -0500 (EST) Received: from smtpin08.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id 5B549C109F for ; Wed, 6 Nov 2024 19:21:20 +0000 (UTC) X-FDA: 82756637166.08.D82E9F7 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf23.hostedemail.com (Postfix) with ESMTP id 91572140017 for ; Wed, 6 Nov 2024 19:20:55 +0000 (UTC) Authentication-Results: imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=GRJ2qCys; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920819; a=rsa-sha256; cv=none; b=iY7WUKRe8jWZkQ+Hky4wqhCjWXpSyDXE9PvEC1W0Ta+U9e6C8COH9t2gwd+AkuR8juNBVW Ekwb5cAM8dl39y36Skg1UFuY9O5LLm9MxY1p05hRk2ulUvjX3BRSidj97xY7ZhDXLfmXtG OIyL0ZugjsjcEOjZ2liXE9ymy45hd4o= ARC-Authentication-Results: i=1; imf23.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=GRJ2qCys; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf23.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920819; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=HmtlXH4iAJI0KGsE9A/FwBYg8OH5mCluZRrs/ikqQMM=; b=mFEYe9G/xAGJVpq60hb0Hj0AqS+V1kMpTulZg9a8iKmbhKJNL4zoIJ+m269kkc9+yu9PUH ItS3GjFvz5iQCOsqHoTA8ExpAikAs9USKp1TaDKeQfZcTlbVHGoHgJH0APPqzMBbZcTD8n s/NYp/afyhSet5dlAlLG0uxcZmH1bUI= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920879; x=1762456879; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=SK7AuRma8nAYQQn2EcAOmsROSQ044juQI+TJ7g6xS7U=; b=GRJ2qCysNXOVMVjA7pCL/t53ha+vVbGrFnRJ21qfR71b1o4CrZRjfoBG /svYIX4aJbnd3P+N7b852HLU1HtejNwbADAqUf/BLwQwb3wMVb1sJwsSX Eg1cQlTeC01sUwFyAVy4xEKlU3OsP+pHK3BISg5ysgT9WJBZfLs8LfvO/ IwHV41lDcxewMjBClVfewDGvTPKi1U8pKxKYAvh20gKxbcFUyOveaXfiH cB1GPXDhpOMYf81ZzCbjEHq8fs/WYSFTw3iRVtjDm0JmrY3KYkb3z5rFy +9zTU/9iigNkwRupuXeFlZne9sN4nYCUNNCb3W0X1QJZriu+Gcl2T9Dka g==; X-CSE-ConnectionGUID: oqJOkQq+QpuKkehB8s4fFQ== X-CSE-MsgGUID: a0K+V9VWRqG2kRihP4gnbw== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292061" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292061" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:14 -0800 X-CSE-ConnectionGUID: ClMLUI8HQiKSghkT7rDUWg== X-CSE-MsgGUID: EuVmJ52UQjmumLK5h0SBhQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695416" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:13 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 11/13] mm: zswap: Allocate acomp_batch_ctx resources for a given zswap_pool. Date: Wed, 6 Nov 2024 11:21:03 -0800 Message-Id: <20241106192105.6731-12-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Queue-Id: 91572140017 X-Rspamd-Server: rspam11 X-Stat-Signature: ot7uc5mum1hyx96a75ctsjooadgu3hzt X-HE-Tag: 1730920855-207991 X-HE-Meta: U2FsdGVkX1/s7qY12IZOeJGyyuJbAixmZVZlFSuIeHxNtb3HdXAulYfjzl+SaUCUl01xdtwfqYfUwz55sg6khpfMh4UFXTrYIbx3X7EsAG2tNaZat2xfWsEwCey82euTp5wjddZleAvewkOwKNV580N28YpgvFhI7nlTOUK1d0rLMnkBT/8BTkFW+iRZD00BbMGQkaOc6pZYHqV4lcRbpgfjanp5xGOKAYhreRsPd45tdQ38BAkRZ84/IpHQbWRupM0BuYFuBXCL5++KTfOX9zQpK66ya7ygSCz3Bo60HxcT7TzPnbjx7ZL7B5icl+e0FNeOnXKiWXL9vA8a3usGbq71b9qJizsUrHCvCjdqGh+ij1Iqas+V2brc3/mfRq3IozzLr4d7UTXc6BLmU5u+7cZ420Pqi7Euj2ogIWlC1NPlFP63yFL+Q5yyMjgUNbEmnk+d3VFv1Krpot4um/YnQR4Jy/IN/K0MSA2ok2AYHTPQxPs2T7NgAkKCI/zur1ZrVVB4oZzWz7Ex3MazQssrmRBlamZKrQqWVcTFfq3BZ7ydDnLSm8Vm6d6xjudPMsFTa8K8kGAokjv8JGqcodJe+jJU06kyqTuNZo2WZxH05LehhZgysNO7vYWoC72nhM2RtHMFX22j+go+dJPoO5aXv/+dlge1j1MzWCS3Me0AcA8CI/ThCZZg0Wn89HKUu02Bq+1H8ZOvOvzOo0X5E2OddXOf+ThlG2VHUlJGdtKTe8dHkLTMZsm3Kao7mqjGNOePI6CfC/KfG0svJ7ho4Pi/so8yc3U0upkb+wFSXRA0FkKPCkuZBwMAvbcfXGCR1fed/yfR54rAAvgA0a1VRpGEC/b8fbmjsZULVfdDe6hkxhvLTqNxnmCTal7ZhV+UTcaEBV1UXmjvJp3Ml/2nitxysUfnj1RzlMAw1wPsiKiuCSc+9eLKLZdjBUodTY3GYEedtUA+0PJJ4vArM5+l7lx FXHkCOIp y0td3/tH/+8hBERYhzlsdH16bUYicZMYqfCeC877ykP9DNkpntxACojo2qY6CzGAZ1Qul9yiZ8ngk6XEjhqGpfWLRq/D14o8HysxWmLaJhXDH8tIEDxASlBkr7fGE4M/mP9/IceN7Fo55dT+Qksh8W0j5fDXXz4VT3QPZO13H4Zl1qthuoAqLB1NojH8BnzmxifUjOLcoDGZf7oiYzEaQVTx5Pbn+piFyEdSpvBrwC18QgUsEw7gg8OfPKWgcYEh+nj9p X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: If the zswap_pool is associated with an acomp_alg/crypto_acomp that has registered batch_compress() and batch_decompress() API, we can allocate the necessary batching resources for the pool's acomp_batch_ctx. This patch makes the above determination on incurring the per-cpu memory footprint cost for batching, and if so, goes ahead and allocates SWAP_CRYPTO_BATCH_SIZE (i.e. 8) acomp_reqs/buffers for the pool->acomp_batch_ctx on that specific cpu. It also "remembers" the pool's batching readiness as a result of the above, through a new enum batch_comp_status can_batch_comp; member added to struct zswap_pool, for fast retrieval during zswap_store(). This allows us a way to only incur the memory footprint cost of the pool->acomp_batch_ctx resources for a given cpu on which zswap_store() needs to process a large folio. Suggested-by: Yosry Ahmed Suggested-by: Ying Huang Signed-off-by: Kanchana P Sridhar --- include/linux/zswap.h | 7 ++++++ mm/zswap.c | 52 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/include/linux/zswap.h b/include/linux/zswap.h index d961ead91bf1..9ad27ab3d222 100644 --- a/include/linux/zswap.h +++ b/include/linux/zswap.h @@ -7,6 +7,13 @@ struct lruvec; +/* + * For IAA compression batching: + * Maximum number of IAA acomp compress requests that will be processed + * in a batch: in parallel, if iaa_crypto async/no irq mode is enabled + * (the default); else sequentially, if iaa_crypto sync mode is in effect. + */ +#define SWAP_CRYPTO_BATCH_SIZE 8UL extern atomic_long_t zswap_stored_pages; #ifdef CONFIG_ZSWAP diff --git a/mm/zswap.c b/mm/zswap.c index 80a928cf0f7e..2af736e38213 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -151,6 +151,12 @@ struct crypto_acomp_ctx { bool is_sleepable; }; +enum batch_comp_status { + UNINIT_BATCH_COMP = -1, + CANNOT_BATCH_COMP = 0, + BATCH_COMP_ENABLED = 1, +}; + /* * The lock ordering is zswap_tree.lock -> zswap_pool.lru_lock. * The only case where lru_lock is not acquired while holding tree.lock is @@ -159,6 +165,7 @@ struct crypto_acomp_ctx { */ struct zswap_pool { struct zpool *zpool; + enum batch_comp_status can_batch_comp; struct crypto_acomp_ctx __percpu *acomp_ctx; struct crypto_acomp_ctx __percpu *acomp_batch_ctx; struct percpu_ref ref; @@ -310,6 +317,7 @@ static struct zswap_pool *zswap_pool_create(char *type, char *compressor) goto ref_fail; INIT_LIST_HEAD(&pool->list); + pool->can_batch_comp = UNINIT_BATCH_COMP; zswap_pool_debug("created", pool); return pool; @@ -695,6 +703,39 @@ static int zswap_enabled_param_set(const char *val, return ret; } +/* Called only if sysctl vm.compress-batching is set to "1". */ +static __always_inline bool zswap_pool_can_batch(struct zswap_pool *pool) +{ + struct crypto_acomp_ctx *acomp_ctx; + + if ((pool->can_batch_comp == BATCH_COMP_ENABLED) && + !IS_ERR_OR_NULL((acomp_ctx = raw_cpu_ptr(pool->acomp_batch_ctx))) && + (acomp_ctx->nr_reqs == SWAP_CRYPTO_BATCH_SIZE)) + return true; + + if (pool->can_batch_comp == CANNOT_BATCH_COMP) + return false; + + if ((pool->can_batch_comp == UNINIT_BATCH_COMP) && pool->acomp_batch_ctx) { + acomp_ctx = raw_cpu_ptr(pool->acomp_batch_ctx); + + if (!IS_ERR_OR_NULL(acomp_ctx)) { + if ((acomp_ctx->nr_reqs == SWAP_CRYPTO_BATCH_SIZE) || + (!acomp_ctx->nr_reqs && + !zswap_create_acomp_ctx(raw_smp_processor_id(), + acomp_ctx, + pool->tfm_name, + SWAP_CRYPTO_BATCH_SIZE))) { + pool->can_batch_comp = BATCH_COMP_ENABLED; + return true; + } + } + } + + pool->can_batch_comp = CANNOT_BATCH_COMP; + return false; +} + /********************************* * lru functions **********************************/ @@ -850,6 +891,17 @@ static int zswap_create_acomp_ctx(unsigned int cpu, acomp_ctx->acomp = acomp; acomp_ctx->is_sleepable = acomp_is_async(acomp); + /* + * Cannot create a batching ctx without the crypto acomp alg supporting + * batch_compress and batch_decompress API. + */ + if ((nr_reqs > 1) && (!acomp->batch_compress || !acomp->batch_decompress)) { + WARN_ONCE(1, "Cannot alloc acomp_ctx with %d reqs since crypto acomp %s\nhas not registered batch_compress() and/or batch_decompress()\n", + nr_reqs, tfm_name); + ret = -ENODEV; + goto buf_fail; + } + acomp_ctx->buffers = kmalloc_node(nr_reqs * sizeof(u8 *), GFP_KERNEL, cpu_to_node(cpu)); if (!acomp_ctx->buffers) From patchwork Wed Nov 6 19:21:04 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865327 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id CAED6D59F6A for ; Wed, 6 Nov 2024 19:21:44 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 9998E6B009F; Wed, 6 Nov 2024 14:21:21 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 949C26B00A1; Wed, 6 Nov 2024 14:21:21 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 79E726B00A0; Wed, 6 Nov 2024 14:21:21 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0017.hostedemail.com [216.40.44.17]) by kanga.kvack.org (Postfix) with ESMTP id 53CF96B009E for ; Wed, 6 Nov 2024 14:21:21 -0500 (EST) Received: from smtpin18.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id 0FA1D121D6E for ; Wed, 6 Nov 2024 19:21:21 +0000 (UTC) X-FDA: 82756638006.18.06FE1D6 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf18.hostedemail.com (Postfix) with ESMTP id 740231C0010 for ; Wed, 6 Nov 2024 19:21:03 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=nkoFg+fu; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920795; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=A2OQWF+jRt4/xufhX9UbIWAE7obRnbYO4ug11BP+78o=; b=NWYQIBF5sSZl/6C9rMt5JBixfe+v5Iyee91xdXpw5AHoC2qazKw/9J9A6MVXT2NET/cX8P 4VFy89cecybXalsMbEIFdHzXn5LB0tGdTfXioZCc2mQBIwP4Qk1YPhXEiqIuv45Ysf9K3k gv9GQDYSU0oax4FmIplBdwmsaGYaQXQ= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=nkoFg+fu; dmarc=pass (policy=none) header.from=intel.com; spf=pass (imf18.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920795; a=rsa-sha256; cv=none; b=dC4IP/6XkF7zbNg5gPFKBwXNFAMBi8fw3d52qV4EnJzKA+YGxNDGu2Ys/clgMd3tDQbF7y bkdYK47J/nVivM+clQfYz6OBA4FNceY2Bv8qrSP6wl3UBSptVrnHv9s9/ViHb0kTEtRM2Y gqE6sIxYt24Hn4zvCdKnfEOli9V8snU= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920879; x=1762456879; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=RvYO56c7H8o1E9i8DrptIuQN+cu6z6PTo04ljSRvTjY=; b=nkoFg+fucaBR4Shhlmb1ouckZNRwFMqspFu8Cb/yFzUjRM0FvLOK5iki YzqhF5pKwjzC4uCD7kvDhIgm6RQvwa6tZABc509JlT8Oq31y0wb/ZCHVD ksG0yMy2mdrBZnDaU1pb+APcbx2phVHp5PXABuJeUo9CqC0QXdPsHFBRW 82cxEnE76UwZR4sY4+rB/GaVne4cFhXXWJMg8S/B891qklvGqhNuM8sPG YUPRIZDmi1CQzANvvGQ012gqNcAOuMh+E7kBCqnWF7sLLYcYK+qunvwqB HFS1xJ3ng0kNDtUePOyyppUqLpmsxvJU2KHyx+6DcxBkEPRxzwxXmQx6u Q==; X-CSE-ConnectionGUID: Ey3+d9h9QAGVSvsjThkjSA== X-CSE-MsgGUID: 0wpcc7TSQFyD/DLFg++e7Q== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292074" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292074" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:14 -0800 X-CSE-ConnectionGUID: nN2+UNtXTT6rc/74ttu3rw== X-CSE-MsgGUID: KjGO/gTnShy76yRTS9Bp3g== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695422" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:13 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 12/13] mm: Add sysctl vm.compress-batching switch for compress batching during swapout. Date: Wed, 6 Nov 2024 11:21:04 -0800 Message-Id: <20241106192105.6731-13-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: 740231C0010 X-Stat-Signature: inu5oap15h5jx6tmbfy4oyb4ue1gjg4t X-HE-Tag: 1730920863-168357 X-HE-Meta: U2FsdGVkX1/vPAFKmTK2Tba22gdnpsg1f+q58mL85zzZ9XEssA3GMdYDcmWKS2b6fdG9r/60gTwfrvbh1B1Tp0d42rN+PWN3J6jfYO4FeDvblfTsWXyig7ObqLwDIYyvZGwKeWhToZagoIpLl/P7RHSi3EhkeCfjHrWCrINKU2ekPLFV2BPsjtuX79kxe+NHq8PqKHziFmVBouf7ir2DZmMedR1MQ4kirvfP9rOAmVN3upyO8SccYVFWvoVLloRIMTNUbBTYL3r1XAG4OAQyaJ3lpdfPY/OrkNJvIytKu4hg39ePvkcvncQiehVztVudMefY9zrnZB68yZuTEi/oibm8LLGFtzEct7DWQrYe5H8mxVJ+qKs2ZZB9/BBw3TailBZqD9/cTiVgjTDwNMzOa0Kw595wXC6by6RNUIgrQSW8kDYd7YV2JkXZQcqIJ212eHEOPjV9eSpDZgkp5Djg42ppHZJGmH3zxphPHm90FRcwbe5P1a7kPSbScSL3GjgwdI0LWOSZ6jiPbCeYMwMWYARpdQ5xZ80dDxVWWZlLi5D22q6UM3x19ZwEdgeRBP82AD5g4/gxsskXzNTj5YQski2lB1OpynczxiHSO61pZAB4Syh4fgASFvLqE757dlYjha3Ie4q6ZxZ9YDWlQrKDxoUtg7CZLPO3NfXWFVwFne7k/KijprzaWEMVGwN7Ycpdd/GWJSHZJrEeRnxGeKels4S2RF77ZxsUlR2bMq0IPyB4eXsIWmGyx7lbBwzRsZW4m2FFIsHYK7LPvjt7Th3nZrV4Da6DEp+b3c0znjdADTqXRdoPc8vbfixcmDZwbq2XvOMc1xtG0CMuytsxPnUJYK2AmuVfYdlbXvPu8U5netTqd59+sK6yruOybaKBHt6BMBcUGx4LCxuMFzK/MRccX88SUef+aN6xshi9qq2hHNNwFZf2VB4u58pETHJwOS+aeA3LPw0G2mv3cEYo8Fp VKPBJrks V/CgeN2zw2FvUc8sZuYdewWuVOFmTZ022wf4b4eINgJgiGxunQtQZ/eK4/MZ7GVQXXpqsK+RMsOxQhzeYEOn2GuCZPuBxdCPq+jjGSqm/HjImZsDhkFpA7UMpcREXiHUcf6Edyohh3L4p17tUAXZRLfLHYyCzLpgdKd3xRgvmjXUd/nJnOqb6hedXkQ== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: The sysctl vm.compress-batching parameter is 0 by default. If the platform has Intel IAA, the user can run experiments with IAA compress batching of large folios in zswap_store() as follows: sysctl vm.compress-batching=1 echo deflate-iaa > /sys/module/zswap/parameters/compressor This is expected to significantly improve zswap_store() latency of swapping out large folios due to parallel compression of 8 pages in the large folio at a time, in hardware. Setting vm.compress-batching to "1" takes effect only if the zswap compression algorithm's crypto_acomp registers implementations for the batch_compress() and batch_decompress() API. In other words, compress batching works only with the iaa_crypto driver, that does register these new batching API. It is a no-op for compressors that do not register the batching API. The sysctl vm.compress-batching acts as a switch because it takes effect upon future zswap_store() calls on any given core. If the switch is "1", large folios will use parallel batched compression of the folio's pages. If the switch is "0", zswap_store() will use sequential compression for storing every page in a large folio. Signed-off-by: Kanchana P Sridhar --- include/linux/mm.h | 2 ++ kernel/sysctl.c | 9 +++++++++ mm/swap.c | 6 ++++++ 3 files changed, 17 insertions(+) diff --git a/include/linux/mm.h b/include/linux/mm.h index fecd47239fa9..f61915aa2f37 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -82,8 +82,10 @@ extern const int page_cluster_max; #ifdef CONFIG_SYSCTL extern int sysctl_legacy_va_layout; +extern unsigned int compress_batching; #else #define sysctl_legacy_va_layout 0 +#define compress_batching 0 #endif #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS diff --git a/kernel/sysctl.c b/kernel/sysctl.c index 79e6cb1d5c48..e298857595b4 100644 --- a/kernel/sysctl.c +++ b/kernel/sysctl.c @@ -2064,6 +2064,15 @@ static struct ctl_table vm_table[] = { .extra1 = SYSCTL_ZERO, .extra2 = (void *)&page_cluster_max, }, + { + .procname = "compress-batching", + .data = &compress_batching, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_ONE, + }, { .procname = "dirtytime_expire_seconds", .data = &dirtytime_expire_interval, diff --git a/mm/swap.c b/mm/swap.c index 638a3f001676..bc4c9079769e 100644 --- a/mm/swap.c +++ b/mm/swap.c @@ -47,6 +47,9 @@ int page_cluster; const int page_cluster_max = 31; +/* Enable/disable compress batching during swapout. */ +unsigned int compress_batching; + struct cpu_fbatches { /* * The following folio batches are grouped together because they are protected @@ -1074,4 +1077,7 @@ void __init swap_setup(void) * Right now other parts of the system means that we * _really_ don't want to cluster much more */ + + /* Disable compress batching during swapout by default. */ + compress_batching = 0; } From patchwork Wed Nov 6 19:21:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sridhar, Kanchana P" X-Patchwork-Id: 13865328 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 220EFD59F6B for ; Wed, 6 Nov 2024 19:21:48 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id EA54D6B009E; Wed, 6 Nov 2024 14:21:21 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id E2B156B00A0; Wed, 6 Nov 2024 14:21:21 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id BC2D46B00A2; Wed, 6 Nov 2024 14:21:21 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0017.hostedemail.com [216.40.44.17]) by kanga.kvack.org (Postfix) with ESMTP id 86BFB6B009E for ; Wed, 6 Nov 2024 14:21:21 -0500 (EST) Received: from smtpin06.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay07.hostedemail.com (Postfix) with ESMTP id 32F63160F3F for ; Wed, 6 Nov 2024 19:21:21 +0000 (UTC) X-FDA: 82756637418.06.4A497B9 Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.11]) by imf12.hostedemail.com (Postfix) with ESMTP id 1F1F040005 for ; Wed, 6 Nov 2024 19:21:02 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=hkLH3+i2; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1730920693; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=GPHM+FUsXTOMU0Ng1Q/Zku476yeUSV1HJ/dMFLz+y3M=; b=NPuR3Zwho5kF8R7wsvTudhfgujkBlejOyT7DjE0VRFORt2DqBv0kSTHqvSkhS7JYUsztST 2zm16U/vCT2qyrv2NPBCZ3/NSSPyeXb04609yJTFHYV0pk8ZGggF6H0JCZNQqoQ7h/JUcY DcWBYzzvUqoifkQ9Y98UF9h3bMkbZ7M= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=intel.com header.s=Intel header.b=hkLH3+i2; spf=pass (imf12.hostedemail.com: domain of kanchana.p.sridhar@intel.com designates 198.175.65.11 as permitted sender) smtp.mailfrom=kanchana.p.sridhar@intel.com; dmarc=pass (policy=none) header.from=intel.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1730920693; a=rsa-sha256; cv=none; b=Z0ByPyZn2W9eiPAi655MfbHdBeTAIqYdCcxFwN+CWyo+Xgk+Zn9X/2ROxYxVPYbCRilyaw aWcVwcDv3BJODKr8ht1eurWJEo4t+Wi9XS62PpAXUh7V86KSvl8BmKPNd57ualSEVZIhBW l7B0/hgv5mTR1HLiqhiI1lkZXMxVH7E= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1730920879; x=1762456879; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=FlPYJq03aC9C19q/epaXuLssNFFJoAITJ0+v337FiR4=; b=hkLH3+i29yCfzv/OdmOwMCZ8hOOSDCMOAufwFkDAUDPebfMoeTS/ay6V 7WobLdiAF0HcDGnvNBlyYk8SCH6f9sIgrD+hMO7vHeIty/8WdCbEnstV7 zGJ1LEU+SHlWcN39VoFTV4FC9fMXTrRP+MCAL/fiDZYO+sUIQAfvq+Sk/ TWb5LP2qfCxnyJYamphgsJWk56Qhh39V4hCPn8sZOANo2B+3t5gYE/Imf KwGcYtpd2jMemrADPhrOcrBhXB8sXWfIpiTe44/ofoKi6Q9ctejVcVef6 vuSJwWI6JyFxD2V5L1TElNWOuNGS/wOUgoo+IEHDeTe/JcT+4b0M+pOCa w==; X-CSE-ConnectionGUID: R1QSFFU4T4mJ/mVx/2djug== X-CSE-MsgGUID: RZ9mOFG8RlexJzdF8ompYA== X-IronPort-AV: E=McAfee;i="6700,10204,11222"; a="41292087" X-IronPort-AV: E=Sophos;i="6.11,199,1725346800"; d="scan'208";a="41292087" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 Nov 2024 11:21:15 -0800 X-CSE-ConnectionGUID: /WpRQSw2Tk6HZkve1NOlqg== X-CSE-MsgGUID: 1hlBHY9oTpSI3/zILtznOA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.11,263,1725346800"; d="scan'208";a="88695434" Received: from unknown (HELO JF5300-B11A338T.jf.intel.com) ([10.242.51.115]) by fmviesa003.fm.intel.com with ESMTP; 06 Nov 2024 11:21:14 -0800 From: Kanchana P Sridhar To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, hannes@cmpxchg.org, yosryahmed@google.com, nphamcs@gmail.com, chengming.zhou@linux.dev, usamaarif642@gmail.com, ryan.roberts@arm.com, ying.huang@intel.com, 21cnbao@gmail.com, akpm@linux-foundation.org, linux-crypto@vger.kernel.org, herbert@gondor.apana.org.au, davem@davemloft.net, clabbe@baylibre.com, ardb@kernel.org, ebiggers@google.com, surenb@google.com, kristen.c.accardi@intel.com, zanussi@kernel.org Cc: wajdi.k.feghali@intel.com, vinodh.gopal@intel.com, kanchana.p.sridhar@intel.com Subject: [PATCH v3 13/13] mm: zswap: Compress batching with Intel IAA in zswap_store() of large folios. Date: Wed, 6 Nov 2024 11:21:05 -0800 Message-Id: <20241106192105.6731-14-kanchana.p.sridhar@intel.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> References: <20241106192105.6731-1-kanchana.p.sridhar@intel.com> MIME-Version: 1.0 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 1F1F040005 X-Stat-Signature: 8eoi15nknanqoc99t8y5h83jsjaa3gye X-Rspam-User: X-HE-Tag: 1730920862-651567 X-HE-Meta: U2FsdGVkX18U0r3TZmmNz+3HFcZlCtYJmEYMAvR44WxZ0iZpxJc2SXpv8y4mSLwzYx3T14anBclXaXFH1CGZOK78i59/qwbobJRQ8NNKLsoHwbupj0EBEmQBKSHpUO5A0EXw5F284hJdFI0KipNoaTHGkmRh03R05UehUCTmxF0Oot2oAiSvRukEMN/KgbrsyqR6lYvL5RdzsZVX+oFScAw/EJBLGRqZXFgccSfkwd1ZysG7wvN3RGdGyli6Gzq5CDd9isJCcrI+2IzxQCKMy4YkKtkJUyy86ALXS9VR8nNmi9AotOgsNvbCvErHT5RVp2v8f2BI37g/1S9oXBFWEwIEBc52hUk27z2Auf9Kww6lstmDN7I29bdgvg4UOVtRI6VaSHbyOiZXpBguja8x2J0+SeCD2xlrjWd6pw3/1CkouwRoq3MLYe14CFC04P1rTPW5rkF8aweyZRhTo51zF5F92S7sOkPhMKGGFU4nRENNtoi9O6Y5ftJXGWap2ofVHxZX1Huf8dALprgOERRD5n0J3WjLvXUX2tSM0WLoiEhbQjNtSoqagPqytcG6u8BWbj+E6OPXtPl61zH1GmlfNgKvvtGtyC+372DVtS/kUORwBGnA8DrW0vKOYZ/FlxYll4vujPW1gJo+fbl7kIbTdswLF+ZcUfg5NdJn1YVuAUOplxvnYGX4nd+2W5G/gbYdr+M43eccFgoD2xO0FTBlyq2MLVqMyUhsjfoHszRqL4J5ijwbk1rrWJH/lmIXnNyLkcht8UYhRyoiNaicCYS6bKAqKe+5RthEkylCrErnl0e8HJ9UUJJzalCKuuyFhLl3ewkGbLvX71EUmfkd0YgzAMOvnLfa6UdPfbFtedf3j4mVOHlhZ7LjpC63llnCLY547fuVxxrSchN+0qp8h28Zh1aYiEX7EJqyIP+8Ued4q50N+tChVkB9Kck+hqJvp13Qg5AibS2NG4m7zipIxPf oXEw4e+W uJUczAwplgsqp1bBPmfQ5OD0hvTJnSkaDMPg1C3F9YLSqFTDzhHC4lrJ+u++ejU7SZpkPi/CZ/ZEUnhXLwOF1hHGfZLn2gVNli3GdrVtwTFSBzF2GIILuq0zKKet90/zLirzWVWxp66etChDrtTpRI4KZ5OuVNe+Gxe5HQr7y7N/C+13NYUibKN42MbhlsFvyWgtqnAzfyJTjU8lTCLaBeMTpP4puWcCN6fM42JgSMJQ1gGE= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: If the system has Intel IAA, and if sysctl vm.compress-batching is set to "1", zswap_store() will call crypto_acomp_batch_compress() to compress up to SWAP_CRYPTO_BATCH_SIZE (i.e. 8) pages in large folios in parallel using the multiple compress engines available in IAA hardware. On platforms with multiple IAA devices per socket, compress jobs from all cores in a socket will be distributed among all IAA devices on the socket by the iaa_crypto driver. With deflate-iaa configured as the zswap compressor, and sysctl vm.compress-batching is enabled, the first time zswap_store() has to swapout a large folio on any given cpu, it will allocate the pool->acomp_batch_ctx resources on that cpu, and set pool->can_batch_comp to BATCH_COMP_ENABLED. It will then proceed to call the main __zswap_store_batch_core() compress batching function. Subsequent calls to zswap_store() on the same cpu will go ahead and use the acomp_batch_ctx by checking the pool->can_batch_comp status. Hence, we allocate the per-cpu pool->acomp_batch_ctx resources only on an as-needed basis, to reduce memory footprint cost. The cost is not incurred on cores that never get to swapout a large folio. This patch introduces the main __zswap_store_batch_core() function for compress batching. This interface represents the extensible compress batching architecture that can potentially be called with a batch of any-order folios from shrink_folio_list(). In other words, although zswap_store() calls __zswap_store_batch_core() with exactly one large folio in this patch, we can reuse this interface to reclaim a batch of folios, to significantly improve the reclaim path efficiency due to IAA's parallel compression capability. The newly added functions that implement batched stores follow the general structure of zswap_store() of a large folio. Some amount of restructuring and optimization is done to minimize failure points for a batch, fail early and maximize the zswap store pipeline occupancy with SWAP_CRYPTO_BATCH_SIZE pages, potentially from multiple folios. This is intended to maximize reclaim throughput with the IAA hardware parallel compressions. Signed-off-by: Kanchana P Sridhar --- include/linux/zswap.h | 84 ++++++ mm/zswap.c | 625 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 709 insertions(+) diff --git a/include/linux/zswap.h b/include/linux/zswap.h index 9ad27ab3d222..6d3ef4780c69 100644 --- a/include/linux/zswap.h +++ b/include/linux/zswap.h @@ -31,6 +31,88 @@ struct zswap_lruvec_state { atomic_long_t nr_disk_swapins; }; +/* + * struct zswap_store_sub_batch_page: + * + * This represents one "zswap batching element", namely, the + * attributes associated with a page in a large folio that will + * be compressed and stored in zswap. The term "batch" is reserved + * for a conceptual "batch" of folios that can be sent to + * zswap_store() by reclaim. The term "sub-batch" is used to describe + * a collection of "zswap batching elements", i.e., an array of + * "struct zswap_store_sub_batch_page *". + * + * The zswap compress sub-batch size is specified by + * SWAP_CRYPTO_BATCH_SIZE, currently set as 8UL if the + * platform has Intel IAA. This means zswap can store a large folio + * by creating sub-batches of up to 8 pages and compressing this + * batch using IAA to parallelize the 8 compress jobs in hardware. + * For e.g., a 64KB folio can be compressed as 2 sub-batches of + * 8 pages each. This can significantly improve the zswap_store() + * performance for large folios. + * + * Although the page itself is represented directly, the structure + * adds a "u8 batch_idx" to represent an index for the folio in a + * conceptual "batch of folios" that can be passed to zswap_store(). + * Conceptually, this allows for up to 256 folios that can be passed + * to zswap_store(). If this conceptual number of folios sent to + * zswap_store() exceeds 256, the "batch_idx" needs to become u16. + */ +struct zswap_store_sub_batch_page { + u8 batch_idx; + swp_entry_t swpentry; + struct obj_cgroup *objcg; + struct zswap_entry *entry; + int error; /* folio error status. */ +}; + +/* + * struct zswap_store_pipeline_state: + * + * This stores state during IAA compress batching of (conceptually, a batch of) + * folios. The term pipelining in this context, refers to breaking down + * the batch of folios being reclaimed into sub-batches of + * SWAP_CRYPTO_BATCH_SIZE pages, batch compressing and storing the + * sub-batch. This concept could be further evolved to use overlap of CPU + * computes with IAA computes. For instance, we could stage the post-compress + * computes for sub-batch "N-1" to happen in parallel with IAA batch + * compression of sub-batch "N". + * + * We begin by developing the concept of compress batching. Pipelining with + * overlap can be future work. + * + * @errors: The errors status for the batch of reclaim folios passed in from + * a higher mm layer such as swap_writepage(). + * @pool: A valid zswap_pool. + * @acomp_ctx: The per-cpu pointer to the crypto_acomp_ctx for the @pool. + * @sub_batch: This is an array that represents the sub-batch of up to + * SWAP_CRYPTO_BATCH_SIZE pages that are being stored + * in zswap. + * @comp_dsts: The destination buffers for crypto_acomp_compress() for each + * page being compressed. + * @comp_dlens: The destination buffers' lengths from crypto_acomp_compress() + * obtained after crypto_acomp_poll() returns completion status, + * for each page being compressed. + * @comp_errors: Compression errors for each page being compressed. + * @nr_comp_pages: Total number of pages in @sub_batch. + * + * Note: + * The max sub-batch size is SWAP_CRYPTO_BATCH_SIZE, currently 8UL. + * Hence, if SWAP_CRYPTO_BATCH_SIZE exceeds 256, some of the + * u8 members (except @comp_dsts) need to become u16. + */ +struct zswap_store_pipeline_state { + int *errors; + struct zswap_pool *pool; + struct crypto_acomp_ctx *acomp_ctx; + struct zswap_store_sub_batch_page *sub_batch; + struct page **comp_pages; + u8 **comp_dsts; + unsigned int *comp_dlens; + int *comp_errors; + u8 nr_comp_pages; +}; + unsigned long zswap_total_pages(void); bool zswap_store(struct folio *folio); bool zswap_load(struct folio *folio); @@ -45,6 +127,8 @@ bool zswap_never_enabled(void); #else struct zswap_lruvec_state {}; +struct zswap_store_sub_batch_page {}; +struct zswap_store_pipeline_state {}; static inline bool zswap_store(struct folio *folio) { diff --git a/mm/zswap.c b/mm/zswap.c index 2af736e38213..538aac3fb552 100644 --- a/mm/zswap.c +++ b/mm/zswap.c @@ -255,6 +255,12 @@ static int zswap_create_acomp_ctx(unsigned int cpu, char *tfm_name, unsigned int nr_reqs); +static bool __zswap_store_batch_core( + int node_id, + struct folio **folios, + int *errors, + unsigned int nr_folios); + /********************************* * pool functions **********************************/ @@ -1626,6 +1632,12 @@ static ssize_t zswap_store_page(struct page *page, return -EINVAL; } +/* + * Modified to use the IAA compress batching framework implemented in + * __zswap_store_batch_core() if sysctl vm.compress-batching is 1. + * The batching code is intended to significantly improve folio store + * performance over the sequential code. + */ bool zswap_store(struct folio *folio) { long nr_pages = folio_nr_pages(folio); @@ -1638,6 +1650,38 @@ bool zswap_store(struct folio *folio) bool ret = false; long index; + /* + * Improve large folio zswap_store() latency with IAA compress batching, + * if this is enabled by setting sysctl vm.compress-batching to "1". + * If enabled, the large folio's pages are compressed in parallel in + * batches of SWAP_CRYPTO_BATCH_SIZE pages. If disabled, every page in + * the large folio is compressed sequentially. + */ + if (folio_test_large(folio) && READ_ONCE(compress_batching)) { + pool = zswap_pool_current_get(); + if (!pool) { + pr_err("Cannot setup acomp_batch_ctx for compress batching: no current pool found\n"); + goto sequential_store; + } + + if (zswap_pool_can_batch(pool)) { + int error = -1; + bool store_batch = __zswap_store_batch_core( + folio_nid(folio), + &folio, &error, 1); + + if (store_batch) { + zswap_pool_put(pool); + if (!error) + ret = true; + return ret; + } + } + zswap_pool_put(pool); + } + +sequential_store: + VM_WARN_ON_ONCE(!folio_test_locked(folio)); VM_WARN_ON_ONCE(!folio_test_swapcache(folio)); @@ -1724,6 +1768,587 @@ bool zswap_store(struct folio *folio) return ret; } +/* + * Note: If SWAP_CRYPTO_BATCH_SIZE exceeds 256, change the + * u8 stack variables in the next several functions, to u16. + */ + +/* + * Propagate the "sbp" error condition to other batch elements belonging to + * the same folio as "sbp". + */ +static __always_inline void zswap_store_propagate_errors( + struct zswap_store_pipeline_state *zst, + u8 error_batch_idx) +{ + u8 i; + + if (zst->errors[error_batch_idx]) + return; + + for (i = 0; i < zst->nr_comp_pages; ++i) { + struct zswap_store_sub_batch_page *sbp = &zst->sub_batch[i]; + + if (sbp->batch_idx == error_batch_idx) { + if (!sbp->error) { + if (sbp->entry) { + if (!IS_ERR_VALUE(sbp->entry->handle)) + zpool_free(zst->pool->zpool, sbp->entry->handle); + + zswap_entry_cache_free(sbp->entry); + sbp->entry = NULL; + } + sbp->error = -EINVAL; + } + } + } + + /* + * Set zswap status for the folio to "error" + * for use in swap_writepage. + */ + zst->errors[error_batch_idx] = -EINVAL; +} + +static __always_inline void zswap_process_comp_errors( + struct zswap_store_pipeline_state *zst) +{ + u8 i; + + for (i = 0; i < zst->nr_comp_pages; ++i) { + struct zswap_store_sub_batch_page *sbp = &zst->sub_batch[i]; + + if (zst->comp_errors[i]) { + if (zst->comp_errors[i] == -ENOSPC) + zswap_reject_compress_poor++; + else + zswap_reject_compress_fail++; + + if (!sbp->error) + zswap_store_propagate_errors(zst, + sbp->batch_idx); + } + } +} + +static void zswap_compress_batch(struct zswap_store_pipeline_state *zst) +{ + /* + * Compress up to SWAP_CRYPTO_BATCH_SIZE pages. + * It is important to note that the zswap pool's per-cpu "acomp_batch_ctx" + * resources are allocated only if the crypto_acomp has registered both, + * crypto_acomp_batch_compress() and crypto_acomp_batch_decompress() API. + * The iaa_crypto driver registers implementations for both these API. + * Hence, if IAA is the zswap compressor and sysctl vm.compress-batching + * is set to "1", the call to crypto_acomp_batch_compress() will + * compresses the pages in parallel, leading to significant performance + * improvements as compared to software compressors. + */ + crypto_acomp_batch_compress( + zst->acomp_ctx->reqs, + &zst->acomp_ctx->wait, + zst->comp_pages, + zst->comp_dsts, + zst->comp_dlens, + zst->comp_errors, + zst->nr_comp_pages); + + /* + * Scan the sub-batch for any compression errors, + * and invalidate pages with errors, along with other + * pages belonging to the same folio as the error pages. + */ + zswap_process_comp_errors(zst); +} + +static void zswap_zpool_store_sub_batch( + struct zswap_store_pipeline_state *zst) +{ + u8 i; + + for (i = 0; i < zst->nr_comp_pages; ++i) { + struct zswap_store_sub_batch_page *sbp = &zst->sub_batch[i]; + struct zpool *zpool; + unsigned long handle; + char *buf; + gfp_t gfp; + int err; + + /* Skip pages that had compress errors. */ + if (sbp->error) + continue; + + zpool = zst->pool->zpool; + gfp = __GFP_NORETRY | __GFP_NOWARN | __GFP_KSWAPD_RECLAIM; + if (zpool_malloc_support_movable(zpool)) + gfp |= __GFP_HIGHMEM | __GFP_MOVABLE; + err = zpool_malloc(zpool, zst->comp_dlens[i], gfp, &handle); + + if (err) { + if (err == -ENOSPC) + zswap_reject_compress_poor++; + else + zswap_reject_alloc_fail++; + + /* + * An error should be propagated to other pages of the + * same folio in the sub-batch, and zpool resources for + * those pages (in sub-batch order prior to this zpool + * error) should be de-allocated. + */ + zswap_store_propagate_errors(zst, sbp->batch_idx); + continue; + } + + buf = zpool_map_handle(zpool, handle, ZPOOL_MM_WO); + memcpy(buf, zst->comp_dsts[i], zst->comp_dlens[i]); + zpool_unmap_handle(zpool, handle); + + sbp->entry->handle = handle; + sbp->entry->length = zst->comp_dlens[i]; + } +} + +/* + * Returns true if the entry was successfully + * stored in the xarray, and false otherwise. + */ +static bool zswap_store_entry(swp_entry_t page_swpentry, + struct zswap_entry *entry) +{ + struct zswap_entry *old = xa_store(swap_zswap_tree(page_swpentry), + swp_offset(page_swpentry), + entry, GFP_KERNEL); + if (xa_is_err(old)) { + int err = xa_err(old); + + WARN_ONCE(err != -ENOMEM, "unexpected xarray error: %d\n", err); + zswap_reject_alloc_fail++; + return false; + } + + /* + * We may have had an existing entry that became stale when + * the folio was redirtied and now the new version is being + * swapped out. Get rid of the old. + */ + if (old) + zswap_entry_free(old); + + return true; +} + +static void zswap_batch_compress_post_proc( + struct zswap_store_pipeline_state *zst) +{ + int nr_objcg_pages = 0, nr_pages = 0; + struct obj_cgroup *objcg = NULL; + size_t compressed_bytes = 0; + u8 i; + + zswap_zpool_store_sub_batch(zst); + + for (i = 0; i < zst->nr_comp_pages; ++i) { + struct zswap_store_sub_batch_page *sbp = &zst->sub_batch[i]; + + if (sbp->error) + continue; + + if (!zswap_store_entry(sbp->swpentry, sbp->entry)) { + zswap_store_propagate_errors(zst, sbp->batch_idx); + continue; + } + + /* + * The entry is successfully compressed and stored in the tree, + * there is no further possibility of failure. Grab refs to the + * pool and objcg. These refs will be dropped by + * zswap_entry_free() when the entry is removed from the tree. + */ + zswap_pool_get(zst->pool); + if (sbp->objcg) + obj_cgroup_get(sbp->objcg); + + /* + * We finish initializing the entry while it's already in xarray. + * This is safe because: + * + * 1. Concurrent stores and invalidations are excluded by folio + * lock. + * + * 2. Writeback is excluded by the entry not being on the LRU yet. + * The publishing order matters to prevent writeback from seeing + * an incoherent entry. + */ + sbp->entry->pool = zst->pool; + sbp->entry->swpentry = sbp->swpentry; + sbp->entry->objcg = sbp->objcg; + sbp->entry->referenced = true; + if (sbp->entry->length) { + INIT_LIST_HEAD(&sbp->entry->lru); + zswap_lru_add(&zswap_list_lru, sbp->entry); + } + + if (!objcg && sbp->objcg) { + objcg = sbp->objcg; + } else if (objcg && sbp->objcg && (objcg != sbp->objcg)) { + obj_cgroup_charge_zswap(objcg, compressed_bytes); + count_objcg_events(objcg, ZSWPOUT, nr_objcg_pages); + compressed_bytes = 0; + nr_objcg_pages = 0; + objcg = sbp->objcg; + } + + if (sbp->objcg) { + compressed_bytes += sbp->entry->length; + ++nr_objcg_pages; + } + + ++nr_pages; + } /* for sub-batch pages. */ + + if (objcg) { + obj_cgroup_charge_zswap(objcg, compressed_bytes); + count_objcg_events(objcg, ZSWPOUT, nr_objcg_pages); + } + + atomic_long_add(nr_pages, &zswap_stored_pages); + count_vm_events(ZSWPOUT, nr_pages); +} + +static void zswap_store_sub_batch(struct zswap_store_pipeline_state *zst) +{ + u8 i; + + for (i = 0; i < zst->nr_comp_pages; ++i) { + zst->comp_dsts[i] = zst->acomp_ctx->buffers[i]; + zst->comp_dlens[i] = PAGE_SIZE; + } /* for sub-batch pages. */ + + /* + * Batch compress sub-batch "N". If IAA is the compressor, the + * hardware will compress multiple pages in parallel. + */ + zswap_compress_batch(zst); + + zswap_batch_compress_post_proc(zst); +} + +static void zswap_add_folio_pages_to_sb( + struct zswap_store_pipeline_state *zst, + struct folio* folio, + u8 batch_idx, + struct obj_cgroup *objcg, + struct zswap_entry *entries[], + long start_idx, + u8 add_nr_pages) +{ + long index; + + for (index = start_idx; index < (start_idx + add_nr_pages); ++index) { + u8 i = zst->nr_comp_pages; + struct zswap_store_sub_batch_page *sbp = &zst->sub_batch[i]; + struct page *page = folio_page(folio, index); + zst->comp_pages[i] = page; + sbp->swpentry = page_swap_entry(page); + sbp->batch_idx = batch_idx; + sbp->objcg = objcg; + sbp->entry = entries[index - start_idx]; + sbp->error = 0; + ++zst->nr_comp_pages; + } +} + +static __always_inline void zswap_store_reset_sub_batch( + struct zswap_store_pipeline_state *zst) +{ + zst->nr_comp_pages = 0; +} + +/* Allocate entries for the next sub-batch. */ +static int zswap_alloc_entries(u8 nr_entries, + struct zswap_entry *entries[], + int node_id) +{ + u8 i; + + for (i = 0; i < nr_entries; ++i) { + entries[i] = zswap_entry_cache_alloc(GFP_KERNEL, node_id); + if (!entries[i]) { + u8 j; + + zswap_reject_kmemcache_fail++; + for (j = 0; j < i; ++j) + zswap_entry_cache_free(entries[j]); + return -EINVAL; + } + + entries[i]->handle = (unsigned long)ERR_PTR(-EINVAL); + } + + return 0; +} + +/* + * If the zswap store fails or zswap is disabled, we must invalidate + * the possibly stale entries which were previously stored at the + * offsets corresponding to each page of the folio. Otherwise, + * writeback could overwrite the new data in the swapfile. + */ +static void zswap_delete_stored_entries(struct folio *folio) +{ + swp_entry_t swp = folio->swap; + unsigned type = swp_type(swp); + pgoff_t offset = swp_offset(swp); + struct zswap_entry *entry; + struct xarray *tree; + long index; + + for (index = 0; index < folio_nr_pages(folio); ++index) { + tree = swap_zswap_tree(swp_entry(type, offset + index)); + entry = xa_erase(tree, offset + index); + if (entry) + zswap_entry_free(entry); + } +} + +static void zswap_store_process_folio_errors( + struct folio **folios, + int *errors, + unsigned int nr_folios) +{ + u8 batch_idx; + + for (batch_idx = 0; batch_idx < nr_folios; ++batch_idx) + if (errors[batch_idx]) + zswap_delete_stored_entries(folios[batch_idx]); +} + +/* + * Store a (batch of) any-order large folio(s) in zswap. Each folio will be + * broken into sub-batches of SWAP_CRYPTO_BATCH_SIZE pages, the + * sub-batch will be compressed by IAA in parallel, and stored in zpool/xarray. + * + * This the main procedure for batching of folios, and batching within + * large folios. + * + * This procedure should only be called if zswap supports batching of stores. + * Otherwise, the sequential implementation for storing folios as in the + * current zswap_store() should be used. + * + * The signature of this procedure is meant to allow the calling function, + * (for instance, swap_writepage()) to pass an array @folios + * (the "reclaim batch") of @nr_folios folios to be stored in zswap. + * All folios in the batch must have the same swap type and folio_nid @node_id + * (simplifying assumptions only to manage code complexity). + * + * @errors and @folios have @nr_folios number of entries, with one-one + * correspondence (@errors[i] represents the error status of @folios[i], + * for i in @nr_folios). + * The calling function (for instance, swap_writepage()) should initialize + * @errors[i] to a non-0 value. + * If zswap successfully stores @folios[i], it will set @errors[i] to 0. + * If there is an error in zswap, it will set @errors[i] to -EINVAL. + */ +static bool __zswap_store_batch_core( + int node_id, + struct folio **folios, + int *errors, + unsigned int nr_folios) +{ + struct zswap_store_sub_batch_page sub_batch[SWAP_CRYPTO_BATCH_SIZE]; + struct page *comp_pages[SWAP_CRYPTO_BATCH_SIZE]; + u8 *comp_dsts[SWAP_CRYPTO_BATCH_SIZE] = { NULL }; + unsigned int comp_dlens[SWAP_CRYPTO_BATCH_SIZE]; + int comp_errors[SWAP_CRYPTO_BATCH_SIZE]; + struct crypto_acomp_ctx *acomp_ctx, *acomp_batch_ctx; + struct zswap_pool *pool; + /* + * For now, lets say a max of 256 large folios can be reclaimed + * at a time, as a batch. If this exceeds 256, change this to u16. + */ + u8 batch_idx; + + /* Initialize the compress batching pipeline state. */ + struct zswap_store_pipeline_state zst = { + .errors = errors, + .pool = NULL, + .acomp_ctx = NULL, + .sub_batch = sub_batch, + .comp_pages = comp_pages, + .comp_dsts = comp_dsts, + .comp_dlens = comp_dlens, + .comp_errors = comp_errors, + .nr_comp_pages = 0, + }; + + pool = zswap_pool_current_get(); + if (!pool) { + if (zswap_check_limits()) + queue_work(shrink_wq, &zswap_shrink_work); + goto check_old; + } + + /* + * Caller should make sure that __zswap_store_batch_core() is + * invoked only if sysctl vm.compress-batching is set to "1". + * + * Verify if we are still on the same cpu for which batching + * resources in acomp_batch_ctx were allocated in zswap_store(). + * If not, return to zswap_store() for sequential store of the folio. + */ + acomp_ctx = raw_cpu_ptr(pool->acomp_ctx); + mutex_lock(&acomp_ctx->mutex); + + acomp_batch_ctx = raw_cpu_ptr(pool->acomp_batch_ctx); + if (!acomp_batch_ctx || !acomp_batch_ctx->nr_reqs) { + mutex_unlock(&acomp_ctx->mutex); + zswap_pool_put(pool); + return false; + } + + mutex_lock(&acomp_batch_ctx->mutex); + mutex_unlock(&acomp_ctx->mutex); + + zst.pool = pool; + zst.acomp_ctx = acomp_batch_ctx; + + /* + * Iterate over the folios passed in. Construct sub-batches of up to + * SWAP_CRYPTO_BATCH_SIZE pages, if necessary, by iterating through + * multiple folios from the input "folios". Process each sub-batch + * with IAA batch compression. Detect errors from batch compression + * and set the impacted folio's error status (this happens in + * zswap_store_process_errors()). + */ + for (batch_idx = 0; batch_idx < nr_folios; ++batch_idx) { + struct folio *folio = folios[batch_idx]; + BUG_ON(!folio); + long folio_start_idx, nr_pages = folio_nr_pages(folio); + struct zswap_entry *entries[SWAP_CRYPTO_BATCH_SIZE]; + struct obj_cgroup *objcg = NULL; + struct mem_cgroup *memcg = NULL; + + VM_WARN_ON_ONCE(!folio_test_locked(folio)); + VM_WARN_ON_ONCE(!folio_test_swapcache(folio)); + + /* + * If zswap is disabled, we must invalidate the possibly stale entry + * which was previously stored at this offset. Otherwise, writeback + * could overwrite the new data in the swapfile. + */ + if (!zswap_enabled) + continue; + + /* Check cgroup limits */ + objcg = get_obj_cgroup_from_folio(folio); + if (objcg && !obj_cgroup_may_zswap(objcg)) { + memcg = get_mem_cgroup_from_objcg(objcg); + if (shrink_memcg(memcg)) { + mem_cgroup_put(memcg); + goto put_objcg; + } + mem_cgroup_put(memcg); + } + + if (zswap_check_limits()) + goto put_objcg; + + if (objcg) { + memcg = get_mem_cgroup_from_objcg(objcg); + if (memcg_list_lru_alloc(memcg, &zswap_list_lru, GFP_KERNEL)) { + mem_cgroup_put(memcg); + goto put_objcg; + } + mem_cgroup_put(memcg); + } + + /* + * By default, set zswap status to "success" for use in + * swap_writepage() when this returns. In case of errors, + * a negative error number will over-write this when + * zswap_store_process_errors() is called. + */ + errors[batch_idx] = 0; + + folio_start_idx = 0; + + while (nr_pages > 0) { + u8 add_nr_pages; + + /* + * If we have accumulated SWAP_CRYPTO_BATCH_SIZE + * pages, process the sub-batch: it could contain pages + * from multiple folios. + */ + if (zst.nr_comp_pages == SWAP_CRYPTO_BATCH_SIZE) { + zswap_store_sub_batch(&zst); + zswap_store_reset_sub_batch(&zst); + /* + * Stop processing this folio if it had + * compress errors. + */ + if (errors[batch_idx]) + goto put_objcg; + } + + add_nr_pages = min3(( + (long)SWAP_CRYPTO_BATCH_SIZE - + (long)zst.nr_comp_pages), + nr_pages, + (long)SWAP_CRYPTO_BATCH_SIZE); + + /* + * Allocate zswap_entries for this sub-batch. If we + * get errors while doing so, we can flag an error + * for the folio, call the shrinker and move on. + */ + if (zswap_alloc_entries(add_nr_pages, + entries, node_id)) { + zswap_store_reset_sub_batch(&zst); + errors[batch_idx] = -EINVAL; + goto put_objcg; + } + + zswap_add_folio_pages_to_sb( + &zst, + folio, + batch_idx, + objcg, + entries, + folio_start_idx, + add_nr_pages); + + nr_pages -= add_nr_pages; + folio_start_idx += add_nr_pages; + } /* this folio has pages to be compressed. */ + + obj_cgroup_put(objcg); + continue; + +put_objcg: + obj_cgroup_put(objcg); + if (zswap_pool_reached_full) + queue_work(shrink_wq, &zswap_shrink_work); + } /* for batch folios */ + + if (!zswap_enabled) + goto check_old; + + /* + * Process last sub-batch: it could contain pages from + * multiple folios. + */ + if (zst.nr_comp_pages) + zswap_store_sub_batch(&zst); + + mutex_unlock(&acomp_batch_ctx->mutex); + zswap_pool_put(pool); +check_old: + zswap_store_process_folio_errors(folios, errors, nr_folios); + return true; +} + bool zswap_load(struct folio *folio) { swp_entry_t swp = folio->swap;