Commit 9cc97529 authored by Sergey Senozhatsky's avatar Sergey Senozhatsky Committed by Linus Torvalds

zram: factor out single stream compression

This is preparation patch to add multi stream support to zcomp.

Introduce struct zcomp_strm_single and a set of functions to manage
zcomp_strm stream access.  zcomp_strm_single implements single compession
stream, same way as current zcomp implementation.  This moves zcomp_strm
stream control and locking from zcomp, so compressing backend zcomp is not
aware of required locking.

Single and multi streams require different locking schemes.  Minchan Kim
reported that spinlock-based locking scheme (which is used in multi stream
implementation) has demonstrated a severe perfomance regression for single
compression stream case, comparing to mutex-based.  see
https://lkml.org/lkml/2014/2/18/16

The following set of functions added:
- zcomp_strm_single_find()/zcomp_strm_single_release()
  find and release a compression stream, implement required locking
- zcomp_strm_single_create()/zcomp_strm_single_destroy()
  create and destroy zcomp_strm_single

New ->strm_find() and ->strm_release() callbacks added to zcomp, which are
set to zcomp_strm_single_find() and zcomp_strm_single_release() during
initialisation.  Instead of direct locking and zcomp_strm access from
zcomp_strm_find() and zcomp_strm_release(), zcomp now calls ->strm_find()
and ->strm_release() correspondingly.
Signed-off-by: default avatarSergey Senozhatsky <sergey.senozhatsky@gmail.com>
Acked-by: default avatarMinchan Kim <minchan@kernel.org>
Cc: Jerome Marchand <jmarchan@redhat.com>
Cc: Nitin Gupta <ngupta@vflare.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent b7ca232e
...@@ -16,6 +16,14 @@ ...@@ -16,6 +16,14 @@
#include "zcomp.h" #include "zcomp.h"
#include "zcomp_lzo.h" #include "zcomp_lzo.h"
/*
* single zcomp_strm backend
*/
struct zcomp_strm_single {
struct mutex strm_lock;
struct zcomp_strm *zstrm;
};
static struct zcomp_backend *find_backend(const char *compress) static struct zcomp_backend *find_backend(const char *compress)
{ {
if (strncmp(compress, "lzo", 3) == 0) if (strncmp(compress, "lzo", 3) == 0)
...@@ -54,15 +62,56 @@ static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp) ...@@ -54,15 +62,56 @@ static struct zcomp_strm *zcomp_strm_alloc(struct zcomp *comp)
return zstrm; return zstrm;
} }
static struct zcomp_strm *zcomp_strm_single_find(struct zcomp *comp)
{
struct zcomp_strm_single *zs = comp->stream;
mutex_lock(&zs->strm_lock);
return zs->zstrm;
}
static void zcomp_strm_single_release(struct zcomp *comp,
struct zcomp_strm *zstrm)
{
struct zcomp_strm_single *zs = comp->stream;
mutex_unlock(&zs->strm_lock);
}
static void zcomp_strm_single_destroy(struct zcomp *comp)
{
struct zcomp_strm_single *zs = comp->stream;
zcomp_strm_free(comp, zs->zstrm);
kfree(zs);
}
static int zcomp_strm_single_create(struct zcomp *comp)
{
struct zcomp_strm_single *zs;
comp->destroy = zcomp_strm_single_destroy;
comp->strm_find = zcomp_strm_single_find;
comp->strm_release = zcomp_strm_single_release;
zs = kmalloc(sizeof(struct zcomp_strm_single), GFP_KERNEL);
if (!zs)
return -ENOMEM;
comp->stream = zs;
mutex_init(&zs->strm_lock);
zs->zstrm = zcomp_strm_alloc(comp);
if (!zs->zstrm) {
kfree(zs);
return -ENOMEM;
}
return 0;
}
struct zcomp_strm *zcomp_strm_find(struct zcomp *comp) struct zcomp_strm *zcomp_strm_find(struct zcomp *comp)
{ {
mutex_lock(&comp->strm_lock); return comp->strm_find(comp);
return comp->zstrm;
} }
void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm) void zcomp_strm_release(struct zcomp *comp, struct zcomp_strm *zstrm)
{ {
mutex_unlock(&comp->strm_lock); comp->strm_release(comp, zstrm);
} }
int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm, int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
...@@ -80,7 +129,7 @@ int zcomp_decompress(struct zcomp *comp, const unsigned char *src, ...@@ -80,7 +129,7 @@ int zcomp_decompress(struct zcomp *comp, const unsigned char *src,
void zcomp_destroy(struct zcomp *comp) void zcomp_destroy(struct zcomp *comp)
{ {
zcomp_strm_free(comp, comp->zstrm); comp->destroy(comp);
kfree(comp); kfree(comp);
} }
...@@ -104,10 +153,7 @@ struct zcomp *zcomp_create(const char *compress) ...@@ -104,10 +153,7 @@ struct zcomp *zcomp_create(const char *compress)
return NULL; return NULL;
comp->backend = backend; comp->backend = backend;
mutex_init(&comp->strm_lock); if (zcomp_strm_single_create(comp) != 0) {
comp->zstrm = zcomp_strm_alloc(comp);
if (!comp->zstrm) {
kfree(comp); kfree(comp);
return NULL; return NULL;
} }
......
...@@ -39,9 +39,12 @@ struct zcomp_backend { ...@@ -39,9 +39,12 @@ struct zcomp_backend {
/* dynamic per-device compression frontend */ /* dynamic per-device compression frontend */
struct zcomp { struct zcomp {
struct mutex strm_lock; void *stream;
struct zcomp_strm *zstrm;
struct zcomp_backend *backend; struct zcomp_backend *backend;
struct zcomp_strm *(*strm_find)(struct zcomp *comp);
void (*strm_release)(struct zcomp *comp, struct zcomp_strm *zstrm);
void (*destroy)(struct zcomp *comp);
}; };
struct zcomp *zcomp_create(const char *comp); struct zcomp *zcomp_create(const char *comp);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment