Linux-2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 115 insertions, 0 deletions

diff --git a/crypto/scatterwalk.c b/crypto/scatterwalk.c
new file mode 100644
index 00000000000..50c9461e8cc
--- /dev/null
+++ b/crypto/scatterwalk.c
@@ -0,0 +1,115 @@
+/*
+ * Cryptographic API.
+ *
+ * Cipher operations.
+ *
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ *               2002 Adam J. Richter <adam@yggdrasil.com>
+ *               2004 Jean-Luc Cooke <jlcooke@certainkey.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/highmem.h>
+#include <asm/bug.h>
+#include <asm/scatterlist.h>
+#include "internal.h"
+#include "scatterwalk.h"
+
+enum km_type crypto_km_types[] = {
+        KM_USER0,
+        KM_USER1,
+        KM_SOFTIRQ0,
+        KM_SOFTIRQ1,
+};
+
+static void memcpy_dir(void *buf, void *sgdata, size_t nbytes, int out)
+{
+        if (out)
+                memcpy(sgdata, buf, nbytes);
+        else
+                memcpy(buf, sgdata, nbytes);
+}
+
+void scatterwalk_start(struct scatter_walk *walk, struct scatterlist *sg)
+{
+        unsigned int rest_of_page;
+
+        walk->sg = sg;
+
+        walk->page = sg->page;
+        walk->len_this_segment = sg->length;
+
+        BUG_ON(!sg->length);
+
+        rest_of_page = PAGE_CACHE_SIZE - (sg->offset & (PAGE_CACHE_SIZE - 1));
+        walk->len_this_page = min(sg->length, rest_of_page);
+        walk->offset = sg->offset;
+}
+
+void scatterwalk_map(struct scatter_walk *walk, int out)
+{
+        walk->data = crypto_kmap(walk->page, out) + walk->offset;
+}
+
+static inline void scatterwalk_unmap(struct scatter_walk *walk, int out)
+{
+        /* walk->data may be pointing the first byte of the next page;
+           however, we know we transfered at least one byte.  So,
+           walk->data - 1 will be a virtual address in the mapped page. */
+        crypto_kunmap(walk->data - 1, out);
+}
+
+static void scatterwalk_pagedone(struct scatter_walk *walk, int out,
+                                 unsigned int more)
+{
+        if (out)
+                flush_dcache_page(walk->page);
+
+        if (more) {
+                walk->len_this_segment -= walk->len_this_page;
+
+                if (walk->len_this_segment) {
+                        walk->page++;
+                        walk->len_this_page = min(walk->len_this_segment,
+                                                  (unsigned)PAGE_CACHE_SIZE);
+                        walk->offset = 0;
+                }
+                else
+                        scatterwalk_start(walk, sg_next(walk->sg));
+        }
+}
+
+void scatterwalk_done(struct scatter_walk *walk, int out, int more)
+{
+        scatterwalk_unmap(walk, out);
+        if (walk->len_this_page == 0 || !more)
+                scatterwalk_pagedone(walk, out, more);
+}
+
+/*
+ * Do not call this unless the total length of all of the fragments
+ * has been verified as multiple of the block size.
+ */
+int scatterwalk_copychunks(void *buf, struct scatter_walk *walk,
+                           size_t nbytes, int out)
+{
+        do {
+                memcpy_dir(buf, walk->data, walk->len_this_page, out);
+                buf += walk->len_this_page;
+                nbytes -= walk->len_this_page;
+
+                scatterwalk_unmap(walk, out);
+                scatterwalk_pagedone(walk, out, 1);
+                scatterwalk_map(walk, out);
+        } while (nbytes > walk->len_this_page);
+
+        memcpy_dir(buf, walk->data, nbytes, out);
+        return nbytes;
+}