Received: by 2002:a05:6a10:6744:0:0:0:0 with SMTP id w4csp3449046pxu; Mon, 19 Oct 2020 12:22:24 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwu9jJRC5jvmSy9U5c/9tMwI5Q8srGwjBMfYFq4wsRCgxP/dWAoZ3CQ1WQFg1oDfis6zK8W X-Received: by 2002:a17:907:208b:: with SMTP id pv11mr1447655ejb.426.1603135344088; Mon, 19 Oct 2020 12:22:24 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1603135344; cv=none; d=google.com; s=arc-20160816; b=QzhfbxBh3+UB0DD+X1QM5EAxBxAovCeJEjZm6G+5QhddSG2SRIt+AIVifOwViu4U+q g0QIUz/gwWXeSLEXqd+50oi+AckCpy3ODhoHHcXeHQbuABElRznpzWuyAy36r/Dcf8SH cq5cA8r34sv64yXkCE/60X0ybxxX4cukgrfLrKPYZ6Xf7uk5zV912FAP1mh1VudShuPW 8QfoN4Hfn4HswmraAiRE00/JtjoGPPoAhllCipuE454HkXoK3Ks8VLHxIpP71Zsygu1q ATWhDZBxalyCcQwlcwxBf4My2L+JhduAIQvaLoNSmQHo7LjGo6GqCySM4/xOE+9V3qJh NU8g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from; bh=vNbCmpquzwWX0rdaXqc/kSyITi/TCHAOTcZCY9Stzhc=; b=mSG4EMO/8iy0QWjwQ8389sdgqiWL7slzpjlSUtr+HYG3kH6PFsxNyT31rRxV/w5z5Q z4GZP7OFqsdNBq6V7ootunkk4nII8w7aUW1cJOmYYZX+PAke/PtLMTAfV1kXeIwABJeN BPyapZmnd6rANHw1/9vmsDwGuW1tEtWtOD/Bul9/025AOLvuD3/Fp+3KWsXbiEbpUjZM uExynoLCJQq3gxEOGlu7/7sWVOSjAlAkX30SwIhL4bJ41/KNwR49Z3uS6KGnn5y4B09Y ysFs+w0pMpS0jPG6y5ppDxAqmyZcrWIkjh69V/0NS8+y6lEyxmdNR+YFLAIrb+oZkKRb YFzg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id t24si646981ejd.39.2020.10.19.12.22.01; Mon, 19 Oct 2020 12:22:24 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731305AbgJSTTw (ORCPT + 99 others); Mon, 19 Oct 2020 15:19:52 -0400 Received: from smtp.infotech.no ([82.134.31.41]:56037 "EHLO smtp.infotech.no" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730938AbgJSTTh (ORCPT ); Mon, 19 Oct 2020 15:19:37 -0400 Received: from localhost (localhost [127.0.0.1]) by smtp.infotech.no (Postfix) with ESMTP id 5A8432041BB; Mon, 19 Oct 2020 21:19:35 +0200 (CEST) X-Virus-Scanned: by amavisd-new-2.6.6 (20110518) (Debian) at infotech.no Received: from smtp.infotech.no ([127.0.0.1]) by localhost (smtp.infotech.no [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id lrXC0i9gKLTe; Mon, 19 Oct 2020 21:19:35 +0200 (CEST) Received: from xtwo70.bingwo.ca (vpn.infotech.no [82.134.31.155]) by smtp.infotech.no (Postfix) with ESMTPA id 083A520414F; Mon, 19 Oct 2020 21:19:33 +0200 (CEST) From: Douglas Gilbert To: linux-scsi@vger.kernel.org, linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Cc: martin.petersen@oracle.com, axboe@kernel.dk, bvanassche@acm.org, bostroesser@gmail.com Subject: [PATCH v3 2/4] scatterlist: add sgl_copy_sgl() function Date: Mon, 19 Oct 2020 15:19:26 -0400 Message-Id: <20201019191928.77845-3-dgilbert@interlog.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201019191928.77845-1-dgilbert@interlog.com> References: <20201019191928.77845-1-dgilbert@interlog.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Both the SCSI and NVMe subsystems receive user data from the block layer in scatterlist_s (aka scatter gather lists (sgl) which are often arrays). If drivers in those subsystems represent storage (e.g. a ramdisk) or cache "hot" user data then they may also choose to use scatterlist_s. Currently there are no sgl to sgl operations in the kernel. Start with a sgl to sgl copy. Stops when the first of the number of requested bytes to copy, or the source sgl, or the destination sgl is exhausted. So the destination sgl will _not_ grow. Signed-off-by: Douglas Gilbert --- include/linux/scatterlist.h | 4 ++ lib/scatterlist.c | 75 +++++++++++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+) diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h index 80178afc2a4a..6649414c0749 100644 --- a/include/linux/scatterlist.h +++ b/include/linux/scatterlist.h @@ -321,6 +321,10 @@ size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents, size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents, size_t buflen, off_t skip); +size_t sgl_copy_sgl(struct scatterlist *d_sgl, unsigned int d_nents, off_t d_skip, + struct scatterlist *s_sgl, unsigned int s_nents, off_t s_skip, + size_t n_bytes); + /* * Maximum number of entries that will be allocated in one piece, if * a list larger than this is required then chaining will be utilized. diff --git a/lib/scatterlist.c b/lib/scatterlist.c index d5770e7f1030..1f9e093ad7da 100644 --- a/lib/scatterlist.c +++ b/lib/scatterlist.c @@ -974,3 +974,78 @@ size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents, return offset; } EXPORT_SYMBOL(sg_zero_buffer); + +/** + * sgl_copy_sgl - Copy over a destination sgl from a source sgl + * @d_sgl: Destination sgl + * @d_nents: Number of SG entries in destination sgl + * @d_skip: Number of bytes to skip in destination before starting + * @s_sgl: Source sgl + * @s_nents: Number of SG entries in source sgl + * @s_skip: Number of bytes to skip in source before starting + * @n_bytes: The (maximum) number of bytes to copy + * + * Returns: + * The number of copied bytes. + * + * Notes: + * Destination arguments appear before the source arguments, as with memcpy(). + * + * Stops copying if either d_sgl, s_sgl or n_bytes is exhausted. + * + * Since memcpy() is used, overlapping copies (where d_sgl and s_sgl belong + * to the same sgl and the copy regions overlap) are not supported. + * + * Large copies are broken into copy segments whose sizes may vary. Those + * copy segment sizes are chosen by the min3() statement in the code below. + * Since SG_MITER_ATOMIC is used for both sides, each copy segment is started + * with kmap_atomic() [in sg_miter_next()] and completed with kunmap_atomic() + * [in sg_miter_stop()]. This means pre-emption is inhibited for relatively + * short periods even in very large copies. + * + * If d_skip is large, potentially spanning multiple d_nents then some + * integer arithmetic to adjust d_sgl may improve performance. For example + * if d_sgl is built using sgl_alloc_order(chainable=false) then the sgl + * will be an array with equally sized segments facilitating that + * arithmetic. The suggestion applies to s_skip, s_sgl and s_nents as well. + * + **/ +size_t sgl_copy_sgl(struct scatterlist *d_sgl, unsigned int d_nents, off_t d_skip, + struct scatterlist *s_sgl, unsigned int s_nents, off_t s_skip, + size_t n_bytes) +{ + size_t len; + size_t offset = 0; + struct sg_mapping_iter d_iter, s_iter; + + if (n_bytes == 0) + return 0; + sg_miter_start(&s_iter, s_sgl, s_nents, SG_MITER_ATOMIC | SG_MITER_FROM_SG); + sg_miter_start(&d_iter, d_sgl, d_nents, SG_MITER_ATOMIC | SG_MITER_TO_SG); + if (!sg_miter_skip(&s_iter, s_skip)) + goto fini; + if (!sg_miter_skip(&d_iter, d_skip)) + goto fini; + + while (offset < n_bytes) { + if (!sg_miter_next(&s_iter)) + break; + if (!sg_miter_next(&d_iter)) + break; + len = min3(d_iter.length, s_iter.length, n_bytes - offset); + + memcpy(d_iter.addr, s_iter.addr, len); + offset += len; + /* LIFO order (stop d_iter before s_iter) needed with SG_MITER_ATOMIC */ + d_iter.consumed = len; + sg_miter_stop(&d_iter); + s_iter.consumed = len; + sg_miter_stop(&s_iter); + } +fini: + sg_miter_stop(&d_iter); + sg_miter_stop(&s_iter); + return offset; +} +EXPORT_SYMBOL(sgl_copy_sgl); + -- 2.25.1