4 files changed, 237 insertions, 0 deletions

diff --git a/drivers/block/zram/zcomp.c b/drivers/block/zram/zcomp.c
new file mode 100644
index 000000000000..22f4ae235660
--- /dev/null
+++ b/drivers/block/zram/zcomp.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * 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/string.h>
+#include <linux/slab.h>
+#include <linux/wait.h>
+#include <linux/sched.h>
+
+#include "zcomp.h"
+#include "zcomp_lzo.h"
+
+static struct zcomp_backend *find_backend(const char *compress)
+{
+        if (strncmp(compress, "lzo", 3) == 0)
+                return &zcomp_lzo;
+        return NULL;
+}
+
+static void zcomp_strm_free(struct zcomp *comp, struct zcomp_strm *zstrm)
+{
+        if (zstrm->private)
+                comp->backend->destroy(zstrm->private);
+        free_pages((unsigned long)zstrm->buffer, 1);
+        kfree(zstrm);
+}
+
+/*
+ * allocate new zcomp_strm structure with ->private initialized by
+ * backend, return NULL on error
+ */
+static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp)
+{
+        struct zcomp_strm *zstrm = kmalloc(sizeof(*zstrm), GFP_KERNEL);
+        if (!zstrm)
+                return NULL;
+
+        zstrm->private = comp->backend->create();
+        /*
+         * allocate 2 pages. 1 for compressed data, plus 1 extra for the
+         * case when compressed size is larger than the original one
+         */
+        zstrm->buffer = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 1);
+        if (!zstrm->private || !zstrm->buffer) {
+                zcomp_strm_free(comp, zstrm);
+                zstrm = NULL;
+        }
+        return zstrm;
+}
+
+struct zcomp_strm *zcomp_strm_find(struct zcomp *comp)
+{
+        mutex_lock(&comp->strm_lock);
+        return comp->zstrm;
+}
+
+void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm)
+{
+        mutex_unlock(&comp->strm_lock);
+}
+
+int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
+                const unsigned char *src, size_t *dst_len)
+{
+        return comp->backend->compress(src, zstrm->buffer, dst_len,
+                        zstrm->private);
+}
+
+int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
+                size_t src_len, unsigned char *dst)
+{
+        return comp->backend->decompress(src, src_len, dst);
+}
+
+void zcomp_destroy(struct zcomp *comp)
+{
+        zcomp_strm_free(comp, comp->zstrm);
+        kfree(comp);
+}
+
+/*
+ * search available compressors for requested algorithm.
+ * allocate new zcomp and initialize it. return NULL
+ * if requested algorithm is not supported or in case
+ * of init error
+ */
+struct zcomp *zcomp_create(const char *compress)
+{
+        struct zcomp *comp;
+        struct zcomp_backend *backend;
+
+        backend = find_backend(compress);
+        if (!backend)
+                return NULL;
+
+        comp = kzalloc(sizeof(struct zcomp), GFP_KERNEL);
+        if (!comp)
+                return NULL;
+
+        comp->backend = backend;
+        mutex_init(&comp->strm_lock);
+
+        comp->zstrm = zcomp_strm_alloc(comp);
+        if (!comp->zstrm) {
+                kfree(comp);
+                return NULL;
+        }
+        return comp;
+}
diff --git a/drivers/block/zram/zcomp.h b/drivers/block/zram/zcomp.h
new file mode 100644
index 000000000000..c9a98e1317fe
--- /dev/null
+++ b/drivers/block/zram/zcomp.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * 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.
+ */
+
+#ifndef _ZCOMP_H_
+#define _ZCOMP_H_
+
+#include <linux/mutex.h>
+
+struct zcomp_strm {
+        /* compression/decompression buffer */
+        void *buffer;
+        /*
+         * The private data of the compression stream, only compression
+         * stream backend can touch this (e.g. compression algorithm
+         * working memory)
+         */
+        void *private;
+};
+
+/* static compression backend */
+struct zcomp_backend {
+        int (*compress)(const unsigned char *src, unsigned char *dst,
+                        size_t *dst_len, void *private);
+
+        int (*decompress)(const unsigned char *src, size_t src_len,
+                        unsigned char *dst);
+
+        void *(*create)(void);
+        void (*destroy)(void *private);
+
+        const char *name;
+};
+
+/* dynamic per-device compression frontend */
+struct zcomp {
+        struct mutex strm_lock;
+        struct zcomp_strm *zstrm;
+        struct zcomp_backend *backend;
+};
+
+struct zcomp *zcomp_create(const char *comp);
+void zcomp_destroy(struct zcomp *comp);
+
+struct zcomp_strm *zcomp_strm_find(struct zcomp *comp);
+void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm);
+
+int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
+                const unsigned char *src, size_t *dst_len);
+
+int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
+                size_t src_len, unsigned char *dst);
+#endif /* _ZCOMP_H_ */
diff --git a/drivers/block/zram/zcomp_lzo.c b/drivers/block/zram/zcomp_lzo.c
new file mode 100644
index 000000000000..da1bc47d588e
--- /dev/null
+++ b/drivers/block/zram/zcomp_lzo.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * 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/slab.h>
+#include <linux/lzo.h>
+
+#include "zcomp_lzo.h"
+
+static void *lzo_create(void)
+{
+        return kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
+}
+
+static void lzo_destroy(void *private)
+{
+        kfree(private);
+}
+
+static int lzo_compress(const unsigned char *src, unsigned char *dst,
+                size_t *dst_len, void *private)
+{
+        int ret = lzo1x_1_compress(src, PAGE_SIZE, dst, dst_len, private);
+        return ret == LZO_E_OK ? 0 : ret;
+}
+
+static int lzo_decompress(const unsigned char *src, size_t src_len,
+                unsigned char *dst)
+{
+        size_t dst_len = PAGE_SIZE;
+        int ret = lzo1x_decompress_safe(src, src_len, dst, &dst_len);
+        return ret == LZO_E_OK ? 0 : ret;
+}
+
+struct zcomp_backend zcomp_lzo = {
+        .compress = lzo_compress,
+        .decompress = lzo_decompress,
+        .create = lzo_create,
+        .destroy = lzo_destroy,
+        .name = "lzo",
+};
diff --git a/drivers/block/zram/zcomp_lzo.h b/drivers/block/zram/zcomp_lzo.h
new file mode 100644
index 000000000000..128c5807fa14
--- /dev/null
+++ b/drivers/block/zram/zcomp_lzo.h
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2014 Sergey Senozhatsky.
+ *
+ * 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.
+ */
+
+#ifndef _ZCOMP_LZO_H_
+#define _ZCOMP_LZO_H_
+
+#include "zcomp.h"
+
+extern struct zcomp_backend zcomp_lzo;
+
+#endif /* _ZCOMP_LZO_H_ */