Received: by 2002:a05:6a10:6744:0:0:0:0 with SMTP id w4csp2655644pxu; Sun, 18 Oct 2020 10:17:09 -0700 (PDT) X-Google-Smtp-Source: ABdhPJyv5hB8h6E9ir1FB9+lu1dLNsfd6vHBPoVwe0HEKMc6XnyRByppKsCWvc4PFIzONWucw9ps X-Received: by 2002:a17:906:1784:: with SMTP id t4mr12091122eje.489.1603041428892; Sun, 18 Oct 2020 10:17:08 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1603041428; cv=none; d=google.com; s=arc-20160816; b=XDabjFMNsSTZSW5OQDhScJjQ90VJTBs5wQ85SwJW29fEP9mN2s2GMwhTG05Ip+wTJb EIfExMZ0jBXYJdVNjXWmKTHKCp0KJSTgyf1osuEvuwBrDtG42btn8zVoFjZnJnL1NghP ZORJon0X7j5+4rbHthsFR1qXRY8IEOu+fEPuyyKy/gubt/GhFdAy/tFQ6RmzZl++gzgO Lzi2uzg2thfww767YFWJb70U21tRjIuQw09stl7g0GTHw0Q6lGo6PAnPnBZnK/wzbGeW Kz7m8y64Io0s/9jANfE5JwQOMJoXbZe37zUwVPTXpqt9QIfUjMxvfYsirsNA0/7NT/Hw u2YQ== 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=2qIV2MKxC/ouvRxETMki4JL2nT2G0OjYsE9LyVSLawg=; b=HaAoPdVqwATL9TYhAib/mcjhIBAIkq+tnkvFU9mvAHxEB/qkIe3GE32ioQ5M6Y6Mjb V3vnl3vmBY7hMGMUyc36/TfvhM9yMFGvAoyw5yrRjy6IY/3cgD4J8GTmInZWjabZUKUw E8C33ZZJVUpKrf633Ch7+6BDMnYrVKV6GlPBChwJNR3x/CAlTycFrQNrEj/qb4NYn1Pf VfTvY7Se0shP8Xj3RVllPsMnnocALMWCPOJ0fa/CkWK5Il08xl89sawAhPuAPtO4td1z U0FT9Y3OVNfD43LCXcqXfRT5VJga39Q4IYLYYUAegHjYwOT1qxzOyiCo6xZo9Py3Zg86 vEuw== 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 i14si6109571eje.464.2020.10.18.10.16.46; Sun, 18 Oct 2020 10:17:08 -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 S1727422AbgJRROE (ORCPT + 99 others); Sun, 18 Oct 2020 13:14:04 -0400 Received: from smtp.infotech.no ([82.134.31.41]:52039 "EHLO smtp.infotech.no" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726725AbgJRRNu (ORCPT ); Sun, 18 Oct 2020 13:13:50 -0400 Received: from localhost (localhost [127.0.0.1]) by smtp.infotech.no (Postfix) with ESMTP id 6545520425C; Sun, 18 Oct 2020 19:13:48 +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 jD2poka938Cf; Sun, 18 Oct 2020 19:13:46 +0200 (CEST) Received: from xtwo70.bingwo.ca (host-104-157-204-209.dyn.295.ca [104.157.204.209]) by smtp.infotech.no (Postfix) with ESMTPA id 9678D204258; Sun, 18 Oct 2020 19:13:43 +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 v2 2/4] scatterlist: add sgl_copy_sgl() function Date: Sun, 18 Oct 2020 13:13:34 -0400 Message-Id: <20201018171336.63839-3-dgilbert@interlog.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201018171336.63839-1-dgilbert@interlog.com> References: <20201018171336.63839-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 copy. Signed-off-by: Douglas Gilbert --- include/linux/scatterlist.h | 4 ++ lib/scatterlist.c | 74 +++++++++++++++++++++++++++++++++++++ 2 files changed, 78 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..a0a86059c10e 100644 --- a/lib/scatterlist.c +++ b/lib/scatterlist.c @@ -974,3 +974,77 @@ 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