cifs: Add a function to Hash the contents of an iterator

Add a function to push the contents of a BVEC-, KVEC- or XARRAY-type
iterator into a synchronous hash algorithm.

UBUF- and IOBUF-type iterators are not supported on the assumption that
either we're doing buffered I/O, in which case we won't see them, or we're
doing direct I/O, in which case the iterator will have been extracted into
a BVEC-type iterator higher up.

Signed-off-by: David Howells <dhowells@redhat.com>
cc: Steve French <sfrench@samba.org>
cc: Shyam Prasad N <nspmangalore@gmail.com>
cc: Rohith Surabattula <rohiths.msft@gmail.com>
cc: Jeff Layton <jlayton@kernel.org>
cc: linux-cifs@vger.kernel.org
cc: linux-fsdevel@vger.kernel.org
cc: linux-crypto@vger.kernel.org

Link: https://lore.kernel.org/r/166697257423.61150.12070648579830206483.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/166732029577.3186319.17162612653237909961.stgit@warthog.procyon.org.uk/
Signed-off-by: Steve French <stfrench@microsoft.com>

diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
index cbc18b4..7be589a 100644 (file)
--- a/fs/cifs/cifsencrypt.c
+++ b/fs/cifs/cifsencrypt.c
@@ -24,6 +24,150 @@
 #include "../smbfs_common/arc4.h"
 #include <crypto/aead.h>
 
+/*
+ * Hash data from a BVEC-type iterator.
+ */
+static int cifs_shash_bvec(const struct iov_iter *iter, ssize_t maxsize,
+                          struct shash_desc *shash)
+{
+       const struct bio_vec *bv = iter->bvec;
+       unsigned long start = iter->iov_offset;
+       unsigned int i;
+       void *p;
+       int ret;
+
+       for (i = 0; i < iter->nr_segs; i++) {
+               size_t off, len;
+
+               len = bv[i].bv_len;
+               if (start >= len) {
+                       start -= len;
+                       continue;
+               }
+
+               len = min_t(size_t, maxsize, len - start);
+               off = bv[i].bv_offset + start;
+
+               p = kmap_local_page(bv[i].bv_page);
+               ret = crypto_shash_update(shash, p + off, len);
+               kunmap_local(p);
+               if (ret < 0)
+                       return ret;
+
+               maxsize -= len;
+               if (maxsize <= 0)
+                       break;
+               start = 0;
+       }
+
+       return 0;
+}
+
+/*
+ * Hash data from a KVEC-type iterator.
+ */
+static int cifs_shash_kvec(const struct iov_iter *iter, ssize_t maxsize,
+                          struct shash_desc *shash)
+{
+       const struct kvec *kv = iter->kvec;
+       unsigned long start = iter->iov_offset;
+       unsigned int i;
+       int ret;
+
+       for (i = 0; i < iter->nr_segs; i++) {
+               size_t len;
+
+               len = kv[i].iov_len;
+               if (start >= len) {
+                       start -= len;
+                       continue;
+               }
+
+               len = min_t(size_t, maxsize, len - start);
+               ret = crypto_shash_update(shash, kv[i].iov_base + start, len);
+               if (ret < 0)
+                       return ret;
+               maxsize -= len;
+
+               if (maxsize <= 0)
+                       break;
+               start = 0;
+       }
+
+       return 0;
+}
+
+/*
+ * Hash data from an XARRAY-type iterator.
+ */
+static ssize_t cifs_shash_xarray(const struct iov_iter *iter, ssize_t maxsize,
+                                struct shash_desc *shash)
+{
+       struct folio *folios[16], *folio;
+       unsigned int nr, i, j, npages;
+       loff_t start = iter->xarray_start + iter->iov_offset;
+       pgoff_t last, index = start / PAGE_SIZE;
+       ssize_t ret = 0;
+       size_t len, offset, foffset;
+       void *p;
+
+       if (maxsize == 0)
+               return 0;
+
+       last = (start + maxsize - 1) / PAGE_SIZE;
+       do {
+               nr = xa_extract(iter->xarray, (void **)folios, index, last,
+                               ARRAY_SIZE(folios), XA_PRESENT);
+               if (nr == 0)
+                       return -EIO;
+
+               for (i = 0; i < nr; i++) {
+                       folio = folios[i];
+                       npages = folio_nr_pages(folio);
+                       foffset = start - folio_pos(folio);
+                       offset = foffset % PAGE_SIZE;
+                       for (j = foffset / PAGE_SIZE; j < npages; j++) {
+                               len = min_t(size_t, maxsize, PAGE_SIZE - offset);
+                               p = kmap_local_page(folio_page(folio, j));
+                               ret = crypto_shash_update(shash, p, len);
+                               kunmap_local(p);
+                               if (ret < 0)
+                                       return ret;
+                               maxsize -= len;
+                               if (maxsize <= 0)
+                                       return 0;
+                               start += len;
+                               offset = 0;
+                               index++;
+                       }
+               }
+       } while (nr == ARRAY_SIZE(folios));
+       return 0;
+}
+
+/*
+ * Pass the data from an iterator into a hash.
+ */
+static int cifs_shash_iter(const struct iov_iter *iter, size_t maxsize,
+                          struct shash_desc *shash)
+{
+       if (maxsize == 0)
+               return 0;
+
+       switch (iov_iter_type(iter)) {
+       case ITER_BVEC:
+               return cifs_shash_bvec(iter, maxsize, shash);
+       case ITER_KVEC:
+               return cifs_shash_kvec(iter, maxsize, shash);
+       case ITER_XARRAY:
+               return cifs_shash_xarray(iter, maxsize, shash);
+       default:
+               pr_err("cifs_shash_iter(%u) unsupported\n", iov_iter_type(iter));
+               WARN_ON_ONCE(1);
+               return -EIO;
+       }
+}
+
 int __cifs_calc_signature(struct smb_rqst *rqst,
                        struct TCP_Server_Info *server, char *signature,
                        struct shash_desc *shash)