Project home: http://compcache.googlecode.com/
* Changelog: v4 vs v3
- Remove swap notify callback and related bits. This make ramzswap
contained entirely within drivers/staging/.
- Above changes can cause ramzswap to work poorly since it cannot
cleanup stale data from memory unless overwritten by some other data.
(this will be fixed when swap notifer patches are accepted)
- Some cleanups suggested by Marcin.
* Changelog: v3 vs v2
- All cleanups as suggested by Pekka.
- Move to staging (drivers/block/ramzswap/ -> drivers/staging/ramzswap/).
- Remove swap discard hooks -- swap notify support makes these redundant.
- Unify duplicate code between init_device() fail path and reset_device().
- Fix zero-page accounting.
- Do not accept backing swap with bad pages.
* Changelog: v2 vs initial revision
- Use 'struct page' instead of 32-bit PFNs in ramzswap driver and xvmalloc.
This is to make these 64-bit safe.
- xvmalloc is no longer a separate module and does not export any symbols.
Its compiled directly with ramzswap block driver. This is to avoid any
last bit of confusion with any other allocator.
- set_swap_free_notify() now accepts block_device as parameter instead of
swp_entry_t (interface cleanup).
- Fix: Make sure ramzswap disksize matches usable pages in backing swap file.
This caused initialization error in case backing swap file had intra-page
fragmentation.
It creates RAM based block devices which can be used (only) as swap disks.
Pages swapped to these disks are compressed and stored in memory itself. This
is a big win over swapping to slow hard-disk which are typically used as swap
disk. For flash, these suffer from wear-leveling issues when used as swap disk
- so again its helpful. For swapless systems, it allows more apps to run for a
given amount of memory.
It can create multiple ramzswap devices (/dev/ramzswapX, X = 0, 1, 2, ...).
Each of these devices can have separate backing swap (file or disk partition)
which is used when incompressible page is found or memory limit for device is
reached.
A separate userspace utility called rzscontrol is used to manage individual
ramzswap devices.
* Testing notes
Tested on x86, x64, ARM
ARM:
- Cortex-A8 (Beagleboard)
- ARM11 (Android G1)
- OMAP2420 (Nokia N810)
* Performance
All performance numbers/plots can be found at:
http://code.google.com/p/compcache/wiki/Performance
Below is a summary of this data:
General:
- Swap R/W times are reduced from milliseconds (in case of hard disks)
down to microseconds.
Positive cases:
- Shows 33% improvement in 'scan' benchmark which allocates given amount
of memory and linearly reads/writes to this region. This benchmark also
exposes bottlenecks in ramzswap code (global mutex) due to which this gain
is so small.
- On Linux thin clients, it gives the effect of nearly doubling the amount of
memory.
Negative cases:
Any workload that has active working set w.r.t. filesystem cache that is
nearly equal to amount of RAM while has minimal anonymous memory requirement,
is expected to suffer maximum loss in performance with ramzswap enabled.
Iozone filesystem benchmark can simulate exactly this kind of workload.
As expected, this test shows performance loss of ~25% with ramzswap.
drivers/staging/Kconfig | 2 +
drivers/staging/Makefile | 1 +
drivers/staging/ramzswap/Kconfig | 21 +
drivers/staging/ramzswap/Makefile | 3 +
drivers/staging/ramzswap/ramzswap.txt | 51 +
drivers/staging/ramzswap/ramzswap_drv.c | 1462 +++++++++++++++++++++++++++++
drivers/staging/ramzswap/ramzswap_drv.h | 173 ++++
drivers/staging/ramzswap/ramzswap_ioctl.h | 50 +
drivers/staging/ramzswap/xvmalloc.c | 533 +++++++++++
drivers/staging/ramzswap/xvmalloc.h | 30 +
drivers/staging/ramzswap/xvmalloc_int.h | 86 ++
include/linux/swap.h | 5 +
mm/swapfile.c | 34 +
13 files changed, 2451 insertions(+), 0 deletions(-)
* Features:
- Low metadata overhead (just 4 bytes per object)
- O(1) Alloc/Free - except when we have to call system page allocator to
get additional memory.
- Very low fragmentation: In all tests, xvmalloc memory usage is within 12%
of "Ideal".
- Pool based allocator: Each pool can grow and shrink.
- It maps pages only when required. So, it does not hog vmalloc area which
is very small on 32-bit systems.
SLUB allocator could not be used due to fragmentation issues:
http://code.google.com/p/compcache/wiki/AllocatorsComparison
Data here shows kmalloc using ~43% more memory than TLSF and xvMalloc
is showed ~2% more space efficiency than TLSF (due to smaller metadata).
Creating various kmem_caches can reduce space efficiency gap but still
problem of being limited to low memory exists. Also, it depends on
allocating higher order pages to reduce fragmentation - this is not
acceptable for ramzswap as it is used under memory crunch (its a swap
device!).
SLOB allocator could not be used do to reasons mentioned here:
http://lkml.org/lkml/2009/3/18/210
* Implementation:
It uses two-level bitmap search to find free list containing block of
correct size. This idea is taken from TLSF (Two-Level Segregate Fit)
allocator and is well explained in its paper (see [Links] below).
* Limitations:
- Poor scalability: No per-cpu data structures (work in progress).
[Links]
1. Details and Performance data:
http://code.google.com/p/compcache/wiki/xvMalloc
http://code.google.com/p/compcache/wiki/xvMallocPerformance
2. TLSF memory allocator:
home: http://rtportal.upv.es/rtmalloc/
paper: http://rtportal.upv.es/rtmalloc/files/MRBC_2008.pdf
Signed-off-by: Nitin Gupta <[email protected]>
---
drivers/staging/ramzswap/xvmalloc.c | 507 +++++++++++++++++++++++++++++++
drivers/staging/ramzswap/xvmalloc.h | 30 ++
drivers/staging/ramzswap/xvmalloc_int.h | 86 ++++++
3 files changed, 623 insertions(+), 0 deletions(-)
diff --git a/drivers/staging/ramzswap/xvmalloc.c b/drivers/staging/ramzswap/xvmalloc.c
new file mode 100644
index 0000000..b3e986c
--- /dev/null
+++ b/drivers/staging/ramzswap/xvmalloc.c
@@ -0,0 +1,507 @@
+/*
+ * xvmalloc memory allocator
+ *
+ * Copyright (C) 2008, 2009 Nitin Gupta
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ */
+
+#include <linux/bitops.h>
+#include <linux/errno.h>
+#include <linux/highmem.h>
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+
+#include "xvmalloc.h"
+#include "xvmalloc_int.h"
+
+static void stat_inc(u64 *value)
+{
+ *value = *value + 1;
+}
+
+static void stat_dec(u64 *value)
+{
+ *value = *value - 1;
+}
+
+static int test_flag(struct block_header *block, enum blockflags flag)
+{
+ return block->prev & BIT(flag);
+}
+
+static void set_flag(struct block_header *block, enum blockflags flag)
+{
+ block->prev |= BIT(flag);
+}
+
+static void clear_flag(struct block_header *block, enum blockflags flag)
+{
+ block->prev &= ~BIT(flag);
+}
+
+/*
+ * Given <page, offset> pair, provide a derefrencable pointer.
+ * This is called from xv_malloc/xv_free path, so it
+ * needs to be fast.
+ */
+static void *get_ptr_atomic(struct page *page, u16 offset, enum km_type type)
+{
+ unsigned char *base;
+
+ base = kmap_atomic(page, type);
+ return base + offset;
+}
+
+static void put_ptr_atomic(void *ptr, enum km_type type)
+{
+ kunmap_atomic(ptr, type);
+}
+
+static u32 get_blockprev(struct block_header *block)
+{
+ return block->prev & PREV_MASK;
+}
+
+static void set_blockprev(struct block_header *block, u16 new_offset)
+{
+ block->prev = new_offset | (block->prev & FLAGS_MASK);
+}
+
+static struct block_header *BLOCK_NEXT(struct block_header *block)
+{
+ return (struct block_header *)
+ ((char *)block + block->size + XV_ALIGN);
+}
+
+/*
+ * Get index of free list containing blocks of maximum size
+ * which is less than or equal to given size.
+ */
+static u32 get_index_for_insert(u32 size)
+{
+ if (unlikely(size > XV_MAX_ALLOC_SIZE))
+ size = XV_MAX_ALLOC_SIZE;
+ size &= ~FL_DELTA_MASK;
+ return (size - XV_MIN_ALLOC_SIZE) >> FL_DELTA_SHIFT;
+}
+
+/*
+ * Get index of free list having blocks of size greater than
+ * or equal to requested size.
+ */
+static u32 get_index(u32 size)
+{
+ if (unlikely(size < XV_MIN_ALLOC_SIZE))
+ size = XV_MIN_ALLOC_SIZE;
+ size = ALIGN(size, FL_DELTA);
+ return (size - XV_MIN_ALLOC_SIZE) >> FL_DELTA_SHIFT;
+}
+
+/**
+ * find_block - find block of at least given size
+ * @pool: memory pool to search from
+ * @size: size of block required
+ * @page: page containing required block
+ * @offset: offset within the page where block is located.
+ *
+ * Searches two level bitmap to locate block of at least
+ * the given size. If such a block is found, it provides
+ * <page, offset> to identify this block and returns index
+ * in freelist where we found this block.
+ * Otherwise, returns 0 and <page, offset> params are not touched.
+ */
+static u32 find_block(struct xv_pool *pool, u32 size,
+ struct page **page, u32 *offset)
+{
+ ulong flbitmap, slbitmap;
+ u32 flindex, slindex, slbitstart;
+
+ /* There are no free blocks in this pool */
+ if (!pool->flbitmap)
+ return 0;
+
+ /* Get freelist index correspoding to this size */
+ slindex = get_index(size);
+ slbitmap = pool->slbitmap[slindex / BITS_PER_LONG];
+ slbitstart = slindex % BITS_PER_LONG;
+
+ /*
+ * If freelist is not empty at this index, we found the
+ * block - head of this list. This is approximate best-fit match.
+ */
+ if (test_bit(slbitstart, &slbitmap)) {
+ *page = pool->freelist[slindex].page;
+ *offset = pool->freelist[slindex].offset;
+ return slindex;
+ }
+
+ /*
+ * No best-fit found. Search a bit further in bitmap for a free block.
+ * Second level bitmap consists of series of 32-bit chunks. Search
+ * further in the chunk where we expected a best-fit, starting from
+ * index location found above.
+ */
+ slbitstart++;
+ slbitmap >>= slbitstart;
+
+ /* Skip this search if we were already at end of this bitmap chunk */
+ if ((slbitstart != BITS_PER_LONG) && slbitmap) {
+ slindex += __ffs(slbitmap) + 1;
+ *page = pool->freelist[slindex].page;
+ *offset = pool->freelist[slindex].offset;
+ return slindex;
+ }
+
+ /* Now do a full two-level bitmap search to find next nearest fit */
+ flindex = slindex / BITS_PER_LONG;
+
+ flbitmap = (pool->flbitmap) >> (flindex + 1);
+ if (!flbitmap)
+ return 0;
+
+ flindex += __ffs(flbitmap) + 1;
+ slbitmap = pool->slbitmap[flindex];
+ slindex = (flindex * BITS_PER_LONG) + __ffs(slbitmap);
+ *page = pool->freelist[slindex].page;
+ *offset = pool->freelist[slindex].offset;
+
+ return slindex;
+}
+
+/*
+ * Insert block at <page, offset> in freelist of given pool.
+ * freelist used depends on block size.
+ */
+static void insert_block(struct xv_pool *pool, struct page *page, u32 offset,
+ struct block_header *block)
+{
+ u32 flindex, slindex;
+ struct block_header *nextblock;
+
+ slindex = get_index_for_insert(block->size);
+ flindex = slindex / BITS_PER_LONG;
+
+ block->link.prev_page = 0;
+ block->link.prev_offset = 0;
+ block->link.next_page = pool->freelist[slindex].page;
+ block->link.next_offset = pool->freelist[slindex].offset;
+ pool->freelist[slindex].page = page;
+ pool->freelist[slindex].offset = offset;
+
+ if (block->link.next_page) {
+ nextblock = get_ptr_atomic(block->link.next_page,
+ block->link.next_offset, KM_USER1);
+ nextblock->link.prev_page = page;
+ nextblock->link.prev_offset = offset;
+ put_ptr_atomic(nextblock, KM_USER1);
+ }
+
+ __set_bit(slindex % BITS_PER_LONG, &pool->slbitmap[flindex]);
+ __set_bit(flindex, &pool->flbitmap);
+}
+
+/*
+ * Remove block from head of freelist. Index 'slindex' identifies the freelist.
+ */
+static void remove_block_head(struct xv_pool *pool,
+ struct block_header *block, u32 slindex)
+{
+ struct block_header *tmpblock;
+ u32 flindex = slindex / BITS_PER_LONG;
+
+ pool->freelist[slindex].page = block->link.next_page;
+ pool->freelist[slindex].offset = block->link.next_offset;
+ block->link.prev_page = 0;
+ block->link.prev_offset = 0;
+
+ if (!pool->freelist[slindex].page) {
+ __clear_bit(slindex % BITS_PER_LONG, &pool->slbitmap[flindex]);
+ if (!pool->slbitmap[flindex])
+ __clear_bit(flindex, &pool->flbitmap);
+ } else {
+ /*
+ * DEBUG ONLY: We need not reinitialize freelist head previous
+ * pointer to 0 - we never depend on its value. But just for
+ * sanity, lets do it.
+ */
+ tmpblock = get_ptr_atomic(pool->freelist[slindex].page,
+ pool->freelist[slindex].offset, KM_USER1);
+ tmpblock->link.prev_page = 0;
+ tmpblock->link.prev_offset = 0;
+ put_ptr_atomic(tmpblock, KM_USER1);
+ }
+}
+
+/*
+ * Remove block from freelist. Index 'slindex' identifies the freelist.
+ */
+static void remove_block(struct xv_pool *pool, struct page *page, u32 offset,
+ struct block_header *block, u32 slindex)
+{
+ u32 flindex;
+ struct block_header *tmpblock;
+
+ if (pool->freelist[slindex].page == page
+ && pool->freelist[slindex].offset == offset) {
+ remove_block_head(pool, block, slindex);
+ return;
+ }
+
+ flindex = slindex / BITS_PER_LONG;
+
+ if (block->link.prev_page) {
+ tmpblock = get_ptr_atomic(block->link.prev_page,
+ block->link.prev_offset, KM_USER1);
+ tmpblock->link.next_page = block->link.next_page;
+ tmpblock->link.next_offset = block->link.next_offset;
+ put_ptr_atomic(tmpblock, KM_USER1);
+ }
+
+ if (block->link.next_page) {
+ tmpblock = get_ptr_atomic(block->link.next_page,
+ block->link.next_offset, KM_USER1);
+ tmpblock->link.prev_page = block->link.prev_page;
+ tmpblock->link.prev_offset = block->link.prev_offset;
+ put_ptr_atomic(tmpblock, KM_USER1);
+ }
+}
+
+/*
+ * Allocate a page and add it freelist of given pool.
+ */
+static int grow_pool(struct xv_pool *pool, gfp_t flags)
+{
+ struct page *page;
+ struct block_header *block;
+
+ page = alloc_page(flags);
+ if (unlikely(!page))
+ return -ENOMEM;
+
+ stat_inc(&pool->total_pages);
+
+ spin_lock(&pool->lock);
+ block = get_ptr_atomic(page, 0, KM_USER0);
+
+ block->size = PAGE_SIZE - XV_ALIGN;
+ set_flag(block, BLOCK_FREE);
+ clear_flag(block, PREV_FREE);
+ set_blockprev(block, 0);
+
+ insert_block(pool, page, 0, block);
+
+ put_ptr_atomic(block, KM_USER0);
+ spin_unlock(&pool->lock);
+
+ return 0;
+}
+
+/*
+ * Create a memory pool. Allocates freelist, bitmaps and other
+ * per-pool metadata.
+ */
+struct xv_pool *xv_create_pool(void)
+{
+ u32 ovhd_size;
+ struct xv_pool *pool;
+
+ ovhd_size = roundup(sizeof(*pool), PAGE_SIZE);
+ pool = kzalloc(ovhd_size, GFP_KERNEL);
+ if (!pool)
+ return NULL;
+
+ spin_lock_init(&pool->lock);
+
+ return pool;
+}
+
+void xv_destroy_pool(struct xv_pool *pool)
+{
+ kfree(pool);
+}
+
+/**
+ * xv_malloc - Allocate block of given size from pool.
+ * @pool: pool to allocate from
+ * @size: size of block to allocate
+ * @page: page no. that holds the object
+ * @offset: location of object within page
+ *
+ * On success, <page, offset> identifies block allocated
+ * and 0 is returned. On failure, <page, offset> is set to
+ * 0 and -ENOMEM is returned.
+ *
+ * Allocation requests with size > XV_MAX_ALLOC_SIZE will fail.
+ */
+int xv_malloc(struct xv_pool *pool, u32 size, struct page **page,
+ u32 *offset, gfp_t flags)
+{
+ int error;
+ u32 index, tmpsize, origsize, tmpoffset;
+ struct block_header *block, *tmpblock;
+
+ *page = NULL;
+ *offset = 0;
+ origsize = size;
+
+ if (unlikely(!size || size > XV_MAX_ALLOC_SIZE))
+ return -ENOMEM;
+
+ size = ALIGN(size, XV_ALIGN);
+
+ spin_lock(&pool->lock);
+
+ index = find_block(pool, size, page, offset);
+
+ if (!*page) {
+ spin_unlock(&pool->lock);
+ if (flags & GFP_NOWAIT)
+ return -ENOMEM;
+ error = grow_pool(pool, flags);
+ if (unlikely(error))
+ return error;
+
+ spin_lock(&pool->lock);
+ index = find_block(pool, size, page, offset);
+ }
+
+ if (!*page) {
+ spin_unlock(&pool->lock);
+ return -ENOMEM;
+ }
+
+ block = get_ptr_atomic(*page, *offset, KM_USER0);
+
+ remove_block_head(pool, block, index);
+
+ /* Split the block if required */
+ tmpoffset = *offset + size + XV_ALIGN;
+ tmpsize = block->size - size;
+ tmpblock = (struct block_header *)((char *)block + size + XV_ALIGN);
+ if (tmpsize) {
+ tmpblock->size = tmpsize - XV_ALIGN;
+ set_flag(tmpblock, BLOCK_FREE);
+ clear_flag(tmpblock, PREV_FREE);
+
+ set_blockprev(tmpblock, *offset);
+ if (tmpblock->size >= XV_MIN_ALLOC_SIZE)
+ insert_block(pool, *page, tmpoffset, tmpblock);
+
+ if (tmpoffset + XV_ALIGN + tmpblock->size != PAGE_SIZE) {
+ tmpblock = BLOCK_NEXT(tmpblock);
+ set_blockprev(tmpblock, tmpoffset);
+ }
+ } else {
+ /* This block is exact fit */
+ if (tmpoffset != PAGE_SIZE)
+ clear_flag(tmpblock, PREV_FREE);
+ }
+
+ block->size = origsize;
+ clear_flag(block, BLOCK_FREE);
+
+ put_ptr_atomic(block, KM_USER0);
+ spin_unlock(&pool->lock);
+
+ *offset += XV_ALIGN;
+
+ return 0;
+}
+
+/*
+ * Free block identified with <page, offset>
+ */
+void xv_free(struct xv_pool *pool, struct page *page, u32 offset)
+{
+ void *page_start;
+ struct block_header *block, *tmpblock;
+
+ offset -= XV_ALIGN;
+
+ spin_lock(&pool->lock);
+
+ page_start = get_ptr_atomic(page, 0, KM_USER0);
+ block = (struct block_header *)((char *)page_start + offset);
+
+ /* Catch double free bugs */
+ BUG_ON(test_flag(block, BLOCK_FREE));
+
+ block->size = ALIGN(block->size, XV_ALIGN);
+
+ tmpblock = BLOCK_NEXT(block);
+ if (offset + block->size + XV_ALIGN == PAGE_SIZE)
+ tmpblock = NULL;
+
+ /* Merge next block if its free */
+ if (tmpblock && test_flag(tmpblock, BLOCK_FREE)) {
+ /*
+ * Blocks smaller than XV_MIN_ALLOC_SIZE
+ * are not inserted in any free list.
+ */
+ if (tmpblock->size >= XV_MIN_ALLOC_SIZE) {
+ remove_block(pool, page,
+ offset + block->size + XV_ALIGN, tmpblock,
+ get_index_for_insert(tmpblock->size));
+ }
+ block->size += tmpblock->size + XV_ALIGN;
+ }
+
+ /* Merge previous block if its free */
+ if (test_flag(block, PREV_FREE)) {
+ tmpblock = (struct block_header *)((char *)(page_start) +
+ get_blockprev(block));
+ offset = offset - tmpblock->size - XV_ALIGN;
+
+ if (tmpblock->size >= XV_MIN_ALLOC_SIZE)
+ remove_block(pool, page, offset, tmpblock,
+ get_index_for_insert(tmpblock->size));
+
+ tmpblock->size += block->size + XV_ALIGN;
+ block = tmpblock;
+ }
+
+ /* No used objects in this page. Free it. */
+ if (block->size == PAGE_SIZE - XV_ALIGN) {
+ put_ptr_atomic(page_start, KM_USER0);
+ spin_unlock(&pool->lock);
+
+ __free_page(page);
+ stat_dec(&pool->total_pages);
+ return;
+ }
+
+ set_flag(block, BLOCK_FREE);
+ if (block->size >= XV_MIN_ALLOC_SIZE)
+ insert_block(pool, page, offset, block);
+
+ if (offset + block->size + XV_ALIGN != PAGE_SIZE) {
+ tmpblock = BLOCK_NEXT(block);
+ set_flag(tmpblock, PREV_FREE);
+ set_blockprev(tmpblock, offset);
+ }
+
+ put_ptr_atomic(page_start, KM_USER0);
+ spin_unlock(&pool->lock);
+}
+
+u32 xv_get_object_size(void *obj)
+{
+ struct block_header *blk;
+
+ blk = (struct block_header *)((char *)(obj) - XV_ALIGN);
+ return blk->size;
+}
+
+/*
+ * Returns total memory used by allocator (userdata + metadata)
+ */
+u64 xv_get_total_size_bytes(struct xv_pool *pool)
+{
+ return pool->total_pages << PAGE_SHIFT;
+}
diff --git a/drivers/staging/ramzswap/xvmalloc.h b/drivers/staging/ramzswap/xvmalloc.h
new file mode 100644
index 0000000..010c6fe
--- /dev/null
+++ b/drivers/staging/ramzswap/xvmalloc.h
@@ -0,0 +1,30 @@
+/*
+ * xvmalloc memory allocator
+ *
+ * Copyright (C) 2008, 2009 Nitin Gupta
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ */
+
+#ifndef _XV_MALLOC_H_
+#define _XV_MALLOC_H_
+
+#include <linux/types.h>
+
+struct xv_pool;
+
+struct xv_pool *xv_create_pool(void);
+void xv_destroy_pool(struct xv_pool *pool);
+
+int xv_malloc(struct xv_pool *pool, u32 size, struct page **page,
+ u32 *offset, gfp_t flags);
+void xv_free(struct xv_pool *pool, struct page *page, u32 offset);
+
+u32 xv_get_object_size(void *obj);
+u64 xv_get_total_size_bytes(struct xv_pool *pool);
+
+#endif
diff --git a/drivers/staging/ramzswap/xvmalloc_int.h b/drivers/staging/ramzswap/xvmalloc_int.h
new file mode 100644
index 0000000..03c1a65
--- /dev/null
+++ b/drivers/staging/ramzswap/xvmalloc_int.h
@@ -0,0 +1,86 @@
+/*
+ * xvmalloc memory allocator
+ *
+ * Copyright (C) 2008, 2009 Nitin Gupta
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ */
+
+#ifndef _XV_MALLOC_INT_H_
+#define _XV_MALLOC_INT_H_
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+
+/* User configurable params */
+
+/* Must be power of two */
+#define XV_ALIGN_SHIFT 2
+#define XV_ALIGN (1 << XV_ALIGN_SHIFT)
+#define XV_ALIGN_MASK (XV_ALIGN - 1)
+
+/* This must be greater than sizeof(link_free) */
+#define XV_MIN_ALLOC_SIZE 32
+#define XV_MAX_ALLOC_SIZE (PAGE_SIZE - XV_ALIGN)
+
+/* Free lists are separated by FL_DELTA bytes */
+#define FL_DELTA_SHIFT 3
+#define FL_DELTA (1 << FL_DELTA_SHIFT)
+#define FL_DELTA_MASK (FL_DELTA - 1)
+#define NUM_FREE_LISTS ((XV_MAX_ALLOC_SIZE - XV_MIN_ALLOC_SIZE) \
+ / FL_DELTA + 1)
+
+#define MAX_FLI DIV_ROUND_UP(NUM_FREE_LISTS, BITS_PER_LONG)
+
+/* End of user params */
+
+enum blockflags {
+ BLOCK_FREE,
+ PREV_FREE,
+ __NR_BLOCKFLAGS,
+};
+
+#define FLAGS_MASK XV_ALIGN_MASK
+#define PREV_MASK (~FLAGS_MASK)
+
+struct freelist_entry {
+ struct page *page;
+ u16 offset;
+ u16 pad;
+};
+
+struct link_free {
+ struct page *prev_page;
+ struct page *next_page;
+ u16 prev_offset;
+ u16 next_offset;
+};
+
+struct block_header {
+ union {
+ /* This common header must be ALIGN bytes */
+ u8 common[XV_ALIGN];
+ struct {
+ u16 size;
+ u16 prev;
+ };
+ };
+ struct link_free link;
+};
+
+struct xv_pool {
+ ulong flbitmap;
+ ulong slbitmap[MAX_FLI];
+ spinlock_t lock;
+
+ struct freelist_entry freelist[NUM_FREE_LISTS];
+
+ /* stats */
+ u64 total_pages;
+};
+
+#endif
Creates RAM based block devices (/dev/ramzswapX) which can be
used (only) as swap disks. Pages swapped to these are compressed
and stored in memory itself.
The module is called ramzswap.ko. It depends on:
- xvmalloc memory allocator (compiled with this driver)
- lzo_compress.ko
- lzo_decompress.ko
See ramzswap.txt for usage details.
Signed-off-by: Nitin Gupta <[email protected]>
---
drivers/staging/Kconfig | 2 +
drivers/staging/Makefile | 1 +
drivers/staging/ramzswap/Kconfig | 21 +
drivers/staging/ramzswap/Makefile | 3 +
drivers/staging/ramzswap/ramzswap_drv.c | 1435 +++++++++++++++++++++++++++++
drivers/staging/ramzswap/ramzswap_drv.h | 171 ++++
drivers/staging/ramzswap/ramzswap_ioctl.h | 49 +
7 files changed, 1682 insertions(+), 0 deletions(-)
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index 82b3489..fdc8cfd 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -133,5 +133,7 @@ source "drivers/staging/iio/Kconfig"
source "drivers/staging/cowloop/Kconfig"
+source "drivers/staging/ramzswap/Kconfig"
+
endif # !STAGING_EXCLUDE_BUILD
endif # STAGING
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index b1cad0d..8a88bec 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -48,3 +48,4 @@ obj-$(CONFIG_RAR_REGISTER) += rar/
obj-$(CONFIG_DX_SEP) += sep/
obj-$(CONFIG_IIO) += iio/
obj-$(CONFIG_COWLOOP) += cowloop/
+obj-$(CONFIG_RAMZSWAP) += ramzswap/
diff --git a/drivers/staging/ramzswap/Kconfig b/drivers/staging/ramzswap/Kconfig
new file mode 100644
index 0000000..24e2569
--- /dev/null
+++ b/drivers/staging/ramzswap/Kconfig
@@ -0,0 +1,21 @@
+config RAMZSWAP
+ tristate "Compressed in-memory swap device (ramzswap)"
+ depends on SWAP
+ select LZO_COMPRESS
+ select LZO_DECOMPRESS
+ default n
+ help
+ Creates virtual block devices which can be used (only) as a swap
+ disks. Pages swapped to these disks are compressed and stored in
+ memory itself.
+
+ See ramzswap.txt for more information.
+ Project home: http://compcache.googlecode.com/
+
+config RAMZSWAP_STATS
+ bool "Enable ramzswap stats"
+ depends on RAMZSWAP
+ default y
+ help
+ Enable statistics collection for ramzswap. This adds only a minimal
+ overhead. In unsure, say Y.
diff --git a/drivers/staging/ramzswap/Makefile b/drivers/staging/ramzswap/Makefile
new file mode 100644
index 0000000..507d7dc
--- /dev/null
+++ b/drivers/staging/ramzswap/Makefile
@@ -0,0 +1,3 @@
+ramzswap-objs := ramzswap_drv.o xvmalloc.o
+
+obj-$(CONFIG_RAMZSWAP) += ramzswap.o
diff --git a/drivers/staging/ramzswap/ramzswap_drv.c b/drivers/staging/ramzswap/ramzswap_drv.c
new file mode 100644
index 0000000..b839f05
--- /dev/null
+++ b/drivers/staging/ramzswap/ramzswap_drv.c
@@ -0,0 +1,1435 @@
+/*
+ * Compressed RAM based swap device
+ *
+ * Copyright (C) 2008, 2009 Nitin Gupta
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ *
+ * Project home: http://compcache.googlecode.com
+ */
+
+#define KMSG_COMPONENT "ramzswap"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/bitops.h>
+#include <linux/blkdev.h>
+#include <linux/buffer_head.h>
+#include <linux/device.h>
+#include <linux/genhd.h>
+#include <linux/highmem.h>
+#include <linux/lzo.h>
+#include <linux/mutex.h>
+#include <linux/string.h>
+#include <linux/swap.h>
+#include <linux/swapops.h>
+#include <linux/vmalloc.h>
+#include <linux/version.h>
+
+#include "ramzswap_drv.h"
+
+/* Globals */
+static int ramzswap_major;
+static struct ramzswap *devices;
+
+/*
+ * Pages that compress to larger than this size are
+ * forwarded to backing swap, if present or stored
+ * uncompressed in memory otherwise.
+ */
+static unsigned int max_zpage_size;
+
+/* Module params (documentation at end) */
+static unsigned int num_devices;
+
+static int rzs_test_flag(struct ramzswap *rzs, u32 index,
+ enum rzs_pageflags flag)
+{
+ return rzs->table[index].flags & BIT(flag);
+}
+
+static void rzs_set_flag(struct ramzswap *rzs, u32 index,
+ enum rzs_pageflags flag)
+{
+ rzs->table[index].flags |= BIT(flag);
+}
+
+static void rzs_clear_flag(struct ramzswap *rzs, u32 index,
+ enum rzs_pageflags flag)
+{
+ rzs->table[index].flags &= ~BIT(flag);
+}
+
+static int page_zero_filled(void *ptr)
+{
+ unsigned int pos;
+ unsigned long *page;
+
+ page = (unsigned long *)ptr;
+
+ for (pos = 0; pos != PAGE_SIZE / sizeof(*page); pos++) {
+ if (page[pos])
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * memlimit cannot be greater than backing disk size.
+ */
+static void ramzswap_set_memlimit(struct ramzswap *rzs, size_t totalram_bytes)
+{
+ int memlimit_valid = 1;
+
+ if (!rzs->memlimit) {
+ pr_info("Memory limit not set.\n");
+ memlimit_valid = 0;
+ }
+
+ if (rzs->memlimit > rzs->disksize) {
+ pr_info("Memory limit cannot be greater than "
+ "disksize: limit=%zu, disksize=%zu\n",
+ rzs->memlimit, rzs->disksize);
+ memlimit_valid = 0;
+ }
+
+ if (!memlimit_valid) {
+ size_t mempart, disksize;
+ pr_info("Using default: smaller of (%u%% of RAM) and "
+ "(backing disk size).\n",
+ default_memlimit_perc_ram);
+ mempart = default_memlimit_perc_ram * (totalram_bytes / 100);
+ disksize = rzs->disksize;
+ rzs->memlimit = mempart > disksize ? disksize : mempart;
+ }
+
+ if (rzs->memlimit > totalram_bytes / 2) {
+ pr_info(
+ "Its not advisable setting limit more than half of "
+ "size of memory since we expect a 2:1 compression ratio. "
+ "Limit represents amount of *compressed* data we can keep "
+ "in memory!\n"
+ "\tMemory Size: %zu kB\n"
+ "\tLimit you selected: %zu kB\n"
+ "Continuing anyway ...\n",
+ totalram_bytes >> 10, rzs->memlimit >> 10
+ );
+ }
+
+ rzs->memlimit &= PAGE_MASK;
+ BUG_ON(!rzs->memlimit);
+}
+
+static void ramzswap_set_disksize(struct ramzswap *rzs, size_t totalram_bytes)
+{
+ if (!rzs->disksize) {
+ pr_info(
+ "disk size not provided. You can use disksize_kb module "
+ "param to specify size.\nUsing default: (%u%% of RAM).\n",
+ default_disksize_perc_ram
+ );
+ rzs->disksize = default_disksize_perc_ram *
+ (totalram_bytes / 100);
+ }
+
+ if (rzs->disksize > 2 * (totalram_bytes)) {
+ pr_info(
+ "There is little point creating a ramzswap of greater than "
+ "twice the size of memory since we expect a 2:1 compression "
+ "ratio. Note that ramzswap uses about 0.1%% of the size of "
+ "the swap device when not in use so a huge ramzswap is "
+ "wasteful.\n"
+ "\tMemory Size: %zu kB\n"
+ "\tSize you selected: %zu kB\n"
+ "Continuing anyway ...\n",
+ totalram_bytes >> 10, rzs->disksize
+ );
+ }
+
+ rzs->disksize &= PAGE_MASK;
+}
+
+/*
+ * Swap header (1st page of swap device) contains information
+ * to indentify it as a swap partition. Prepare such a header
+ * for ramzswap device (ramzswap0) so that swapon can identify
+ * it as swap partition. In case backing swap device is provided,
+ * copy its swap header.
+ */
+static int setup_swap_header(struct ramzswap *rzs, union swap_header *s)
+{
+ int ret = 0;
+ struct page *page;
+ struct address_space *mapping;
+ union swap_header *backing_swap_header;
+
+ /*
+ * There is no backing swap device. Create a swap header
+ * that is acceptable by swapon.
+ */
+ if (!rzs->backing_swap) {
+ s->info.version = 1;
+ s->info.last_page = (rzs->disksize >> PAGE_SHIFT) - 1;
+ s->info.nr_badpages = 0;
+ memcpy(s->magic.magic, "SWAPSPACE2", 10);
+ return 0;
+ }
+
+ /*
+ * We have a backing swap device. Copy its swap header
+ * to ramzswap device header. If this header contains
+ * invalid information (backing device not a swap
+ * partition, etc.), swapon will fail for ramzswap
+ * which is correct behavior - we don't want to swap
+ * over filesystem partition!
+ */
+
+ /* Read the backing swap header (code from sys_swapon) */
+ mapping = rzs->swap_file->f_mapping;
+ if (!mapping->a_ops->readpage) {
+ ret = -EINVAL;
+ goto out;
+ }
+
+ page = read_mapping_page(mapping, 0, rzs->swap_file);
+ if (IS_ERR(page)) {
+ ret = PTR_ERR(page);
+ goto out;
+ }
+
+ backing_swap_header = kmap(page);
+ memcpy(s, backing_swap_header, sizeof(*s));
+ if (s->info.nr_badpages) {
+ pr_info("Cannot use backing swap with bad pages (%u)\n",
+ s->info.nr_badpages);
+ ret = -EINVAL;
+ }
+ /*
+ * ramzswap disksize equals number of usable pages in backing
+ * swap. Set last_page in swap header to match this disksize
+ * ('last_page' means 0-based index of last usable swap page).
+ */
+ s->info.last_page = (rzs->disksize >> PAGE_SHIFT) - 1;
+ kunmap(page);
+
+out:
+ return ret;
+}
+
+static void ramzswap_flush_dcache_page(struct page *page)
+{
+#ifdef CONFIG_ARM
+ int flag = 0;
+ /*
+ * Ugly hack to get flush_dcache_page() work on ARM.
+ * page_mapping(page) == NULL after clearing this swap cache flag.
+ * Without clearing this flag, flush_dcache_page() will simply set
+ * "PG_dcache_dirty" bit and return.
+ */
+ if (PageSwapCache(page)) {
+ flag = 1;
+ ClearPageSwapCache(page);
+ }
+#endif
+ flush_dcache_page(page);
+#ifdef CONFIG_ARM
+ if (flag)
+ SetPageSwapCache(page);
+#endif
+}
+
+void ramzswap_ioctl_get_stats(struct ramzswap *rzs,
+ struct ramzswap_ioctl_stats *s)
+{
+ strncpy(s->backing_swap_name, rzs->backing_swap_name,
+ MAX_SWAP_NAME_LEN - 1);
+ s->backing_swap_name[MAX_SWAP_NAME_LEN - 1] = '\0';
+
+ s->disksize = rzs->disksize;
+ s->memlimit = rzs->memlimit;
+
+#if defined(CONFIG_RAMZSWAP_STATS)
+ {
+ struct ramzswap_stats *rs = &rzs->stats;
+ size_t succ_writes, mem_used;
+ unsigned int good_compress_perc = 0, no_compress_perc = 0;
+
+ mem_used = xv_get_total_size_bytes(rzs->mem_pool)
+ + (rs->pages_expand << PAGE_SHIFT);
+ succ_writes = rs->num_writes - rs->failed_writes;
+
+ if (succ_writes && rs->pages_stored) {
+ good_compress_perc = rs->good_compress * 100
+ / rs->pages_stored;
+ no_compress_perc = rs->pages_expand * 100
+ / rs->pages_stored;
+ }
+
+ s->num_reads = rs->num_reads;
+ s->num_writes = rs->num_writes;
+ s->failed_reads = rs->failed_reads;
+ s->failed_writes = rs->failed_writes;
+ s->invalid_io = rs->invalid_io;
+ s->pages_zero = rs->pages_zero;
+
+ s->good_compress_pct = good_compress_perc;
+ s->pages_expand_pct = no_compress_perc;
+
+ s->pages_stored = rs->pages_stored;
+ s->pages_used = mem_used >> PAGE_SHIFT;
+ s->orig_data_size = rs->pages_stored << PAGE_SHIFT;
+ s->compr_data_size = rs->compr_size;
+ s->mem_used_total = mem_used;
+
+ s->bdev_num_reads = rs->bdev_num_reads;
+ s->bdev_num_writes = rs->bdev_num_writes;
+ }
+#endif /* CONFIG_RAMZSWAP_STATS */
+}
+
+static int add_backing_swap_extent(struct ramzswap *rzs,
+ pgoff_t phy_pagenum,
+ pgoff_t num_pages)
+{
+ unsigned int idx;
+ struct list_head *head;
+ struct page *curr_page, *new_page;
+ unsigned int extents_per_page = PAGE_SIZE /
+ sizeof(struct ramzswap_backing_extent);
+
+ idx = rzs->num_extents % extents_per_page;
+ if (!idx) {
+ new_page = alloc_page(__GFP_ZERO);
+ if (!new_page)
+ return -ENOMEM;
+
+ if (rzs->num_extents) {
+ curr_page = virt_to_page(rzs->curr_extent);
+ head = &curr_page->lru;
+ } else {
+ head = &rzs->backing_swap_extent_list;
+ }
+
+ list_add(&new_page->lru, head);
+ rzs->curr_extent = page_address(new_page);
+ }
+
+ rzs->curr_extent->phy_pagenum = phy_pagenum;
+ rzs->curr_extent->num_pages = num_pages;
+
+ pr_debug("add_extent: idx=%u, phy_pgnum=%lu, num_pgs=%lu, "
+ "pg_last=%lu, curr_ext=%p\n", idx, phy_pagenum, num_pages,
+ phy_pagenum + num_pages - 1, rzs->curr_extent);
+
+ if (idx != extents_per_page - 1)
+ rzs->curr_extent++;
+
+ return 0;
+}
+
+static int setup_backing_swap_extents(struct ramzswap *rzs,
+ struct inode *inode, unsigned long *num_pages)
+{
+ int ret = 0;
+ unsigned blkbits;
+ unsigned blocks_per_page;
+ pgoff_t contig_pages = 0, total_pages = 0;
+ pgoff_t pagenum = 0, prev_pagenum = 0;
+ sector_t probe_block = 0;
+ sector_t last_block;
+
+ blkbits = inode->i_blkbits;
+ blocks_per_page = PAGE_SIZE >> blkbits;
+
+ last_block = i_size_read(inode) >> blkbits;
+ while (probe_block + blocks_per_page <= last_block) {
+ unsigned block_in_page;
+ sector_t first_block;
+
+ first_block = bmap(inode, probe_block);
+ if (first_block == 0)
+ goto bad_bmap;
+
+ /* It must be PAGE_SIZE aligned on-disk */
+ if (first_block & (blocks_per_page - 1)) {
+ probe_block++;
+ goto probe_next;
+ }
+
+ /* All blocks within this page must be contiguous on disk */
+ for (block_in_page = 1; block_in_page < blocks_per_page;
+ block_in_page++) {
+ sector_t block;
+
+ block = bmap(inode, probe_block + block_in_page);
+ if (block == 0)
+ goto bad_bmap;
+ if (block != first_block + block_in_page) {
+ /* Discontiguity */
+ probe_block++;
+ goto probe_next;
+ }
+ }
+
+ /*
+ * We found a PAGE_SIZE length, PAGE_SIZE aligned
+ * run of blocks.
+ */
+ pagenum = first_block >> (PAGE_SHIFT - blkbits);
+
+ if (total_pages && (pagenum != prev_pagenum + 1)) {
+ ret = add_backing_swap_extent(rzs, prev_pagenum -
+ (contig_pages - 1), contig_pages);
+ if (ret < 0)
+ goto out;
+ rzs->num_extents++;
+ contig_pages = 0;
+ }
+ total_pages++;
+ contig_pages++;
+ prev_pagenum = pagenum;
+ probe_block += blocks_per_page;
+
+probe_next:
+ continue;
+ }
+
+ if (contig_pages) {
+ pr_debug("adding last extent: pagenum=%lu, "
+ "contig_pages=%lu\n", pagenum, contig_pages);
+ ret = add_backing_swap_extent(rzs,
+ prev_pagenum - (contig_pages - 1), contig_pages);
+ if (ret < 0)
+ goto out;
+ rzs->num_extents++;
+ }
+ if (!rzs->num_extents) {
+ pr_err("No swap extents found!\n");
+ ret = -EINVAL;
+ }
+
+ if (!ret) {
+ *num_pages = total_pages;
+ pr_info("Found %lu extents containing %luk\n",
+ rzs->num_extents, *num_pages << (PAGE_SHIFT - 10));
+ }
+ goto out;
+
+bad_bmap:
+ pr_err("Backing swapfile has holes\n");
+ ret = -EINVAL;
+out:
+ while (ret && !list_empty(&rzs->backing_swap_extent_list)) {
+ struct page *page;
+ struct list_head *entry = rzs->backing_swap_extent_list.next;
+ page = list_entry(entry, struct page, lru);
+ list_del(entry);
+ __free_page(page);
+ }
+ return ret;
+}
+
+static void map_backing_swap_extents(struct ramzswap *rzs)
+{
+ struct ramzswap_backing_extent *se;
+ struct page *table_page, *se_page;
+ unsigned long num_pages, num_table_pages, entry;
+ unsigned long se_idx, span;
+ unsigned entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
+ unsigned extents_per_page = PAGE_SIZE / sizeof(*se);
+
+ /* True for block device */
+ if (!rzs->num_extents)
+ return;
+
+ se_page = list_entry(rzs->backing_swap_extent_list.next,
+ struct page, lru);
+ se = page_address(se_page);
+ span = se->num_pages;
+ num_pages = rzs->disksize >> PAGE_SHIFT;
+ num_table_pages = DIV_ROUND_UP(num_pages * sizeof(*rzs->table),
+ PAGE_SIZE);
+
+ entry = 0;
+ se_idx = 0;
+ while (num_table_pages--) {
+ table_page = vmalloc_to_page(&rzs->table[entry]);
+ while (span <= entry) {
+ se_idx++;
+ if (se_idx == rzs->num_extents)
+ BUG();
+
+ if (!(se_idx % extents_per_page)) {
+ se_page = list_entry(se_page->lru.next,
+ struct page, lru);
+ se = page_address(se_page);
+ } else
+ se++;
+
+ span += se->num_pages;
+ }
+ table_page->mapping = (struct address_space *)se;
+ table_page->private = se->num_pages - (span - entry);
+ pr_debug("map_table: entry=%lu, span=%lu, map=%p, priv=%lu\n",
+ entry, span, table_page->mapping, table_page->private);
+ entry += entries_per_page;
+ }
+}
+
+/*
+ * Check if value of backing_swap module param is sane.
+ * Claim this device and set ramzswap size equal to
+ * size of this block device.
+ */
+static int setup_backing_swap(struct ramzswap *rzs)
+{
+ int ret = 0;
+ size_t disksize;
+ unsigned long num_pages = 0;
+ struct inode *inode;
+ struct file *swap_file;
+ struct address_space *mapping;
+ struct block_device *bdev = NULL;
+
+ if (!rzs->backing_swap_name[0]) {
+ pr_debug("backing_swap param not given\n");
+ goto out;
+ }
+
+ pr_info("Using backing swap device: %s\n", rzs->backing_swap_name);
+
+ swap_file = filp_open(rzs->backing_swap_name,
+ O_RDWR | O_LARGEFILE, 0);
+ if (IS_ERR(swap_file)) {
+ pr_err("Error opening backing device: %s\n",
+ rzs->backing_swap_name);
+ ret = -EINVAL;
+ goto out;
+ }
+
+ mapping = swap_file->f_mapping;
+ inode = mapping->host;
+
+ if (S_ISBLK(inode->i_mode)) {
+ bdev = I_BDEV(inode);
+ ret = bd_claim(bdev, setup_backing_swap);
+ if (ret < 0) {
+ bdev = NULL;
+ goto bad_param;
+ }
+ disksize = i_size_read(inode);
+ } else if (S_ISREG(inode->i_mode)) {
+ bdev = inode->i_sb->s_bdev;
+ if (IS_SWAPFILE(inode)) {
+ ret = -EBUSY;
+ goto bad_param;
+ }
+ ret = setup_backing_swap_extents(rzs, inode, &num_pages);
+ if (ret < 0)
+ goto bad_param;
+ disksize = num_pages << PAGE_SHIFT;
+ } else {
+ goto bad_param;
+ }
+
+ rzs->swap_file = swap_file;
+ rzs->backing_swap = bdev;
+ rzs->disksize = disksize;
+ BUG_ON(!rzs->disksize);
+
+ return 0;
+
+bad_param:
+ if (bdev)
+ bd_release(bdev);
+ filp_close(swap_file, NULL);
+
+out:
+ rzs->backing_swap = NULL;
+ return ret;
+}
+
+/*
+ * Map logical page number 'pagenum' to physical page number
+ * on backing swap device. For block device, this is a nop.
+ */
+u32 map_backing_swap_page(struct ramzswap *rzs, u32 pagenum)
+{
+ u32 skip_pages, entries_per_page;
+ size_t delta, se_offset, skipped;
+ struct page *table_page, *se_page;
+ struct ramzswap_backing_extent *se;
+
+ if (!rzs->num_extents)
+ return pagenum;
+
+ entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
+
+ table_page = vmalloc_to_page(&rzs->table[pagenum]);
+ se = (struct ramzswap_backing_extent *)table_page->mapping;
+ se_page = virt_to_page(se);
+
+ skip_pages = pagenum - (pagenum / entries_per_page * entries_per_page);
+ se_offset = table_page->private + skip_pages;
+
+ if (se_offset < se->num_pages)
+ return se->phy_pagenum + se_offset;
+
+ skipped = se->num_pages - table_page->private;
+ do {
+ struct ramzswap_backing_extent *se_base;
+ u32 se_entries_per_page = PAGE_SIZE / sizeof(*se);
+
+ /* Get next swap extent */
+ se_base = (struct ramzswap_backing_extent *)
+ page_address(se_page);
+ if (se - se_base == se_entries_per_page - 1) {
+ se_page = list_entry(se_page->lru.next,
+ struct page, lru);
+ se = page_address(se_page);
+ } else {
+ se++;
+ }
+
+ skipped += se->num_pages;
+ } while (skipped < skip_pages);
+
+ delta = skipped - skip_pages;
+ se_offset = se->num_pages - delta;
+
+ return se->phy_pagenum + se_offset;
+}
+
+static void ramzswap_free_page(struct ramzswap *rzs, size_t index)
+{
+ u32 clen;
+ void *obj;
+
+ struct page *page = rzs->table[index].page;
+ u32 offset = rzs->table[index].offset;
+
+ if (unlikely(!page)) {
+ if (rzs_test_flag(rzs, index, RZS_ZERO)) {
+ rzs_clear_flag(rzs, index, RZS_ZERO);
+ stat_dec(rzs->stats.pages_zero);
+ }
+ return;
+ }
+
+ if (unlikely(rzs_test_flag(rzs, index, RZS_UNCOMPRESSED))) {
+ clen = PAGE_SIZE;
+ __free_page(page);
+ rzs_clear_flag(rzs, index, RZS_UNCOMPRESSED);
+ stat_dec(rzs->stats.pages_expand);
+ goto out;
+ }
+
+ obj = kmap_atomic(page, KM_USER0) + offset;
+ clen = xv_get_object_size(obj) - sizeof(struct zobj_header);
+ kunmap_atomic(obj, KM_USER0);
+
+ xv_free(rzs->mem_pool, page, offset);
+ if (clen <= PAGE_SIZE / 2)
+ stat_dec(rzs->stats.good_compress);
+
+out:
+ rzs->stats.compr_size -= clen;
+ stat_dec(rzs->stats.pages_stored);
+
+ rzs->table[index].page = NULL;
+ rzs->table[index].offset = 0;
+}
+
+static int handle_zero_page(struct bio *bio)
+{
+ void *user_mem;
+ struct page *page = bio->bi_io_vec[0].bv_page;
+
+ user_mem = kmap_atomic(page, KM_USER0);
+ memset(user_mem, 0, PAGE_SIZE);
+ kunmap_atomic(user_mem, KM_USER0);
+
+ ramzswap_flush_dcache_page(page);
+
+ set_bit(BIO_UPTODATE, &bio->bi_flags);
+ bio_endio(bio, 0);
+ return 0;
+}
+
+static int handle_uncompressed_page(struct ramzswap *rzs, struct bio *bio)
+{
+ u32 index;
+ struct page *page;
+ unsigned char *user_mem, *cmem;
+
+ page = bio->bi_io_vec[0].bv_page;
+ index = bio->bi_sector >> SECTORS_PER_PAGE_SHIFT;
+
+ user_mem = kmap_atomic(page, KM_USER0);
+ cmem = kmap_atomic(rzs->table[index].page, KM_USER1) +
+ rzs->table[index].offset;
+
+ memcpy(user_mem, cmem, PAGE_SIZE);
+ kunmap_atomic(user_mem, KM_USER0);
+ kunmap_atomic(cmem, KM_USER1);
+
+ ramzswap_flush_dcache_page(page);
+
+ set_bit(BIO_UPTODATE, &bio->bi_flags);
+ bio_endio(bio, 0);
+ return 0;
+}
+
+
+/*
+ * Called when request page is not present in ramzswap.
+ * Its either in backing swap device (if present) or
+ * this is an attempt to read before any previous write
+ * to this location - this happens due to readahead when
+ * swap device is read from user-space (e.g. during swapon)
+ */
+static int handle_ramzswap_fault(struct ramzswap *rzs, struct bio *bio)
+{
+ /*
+ * Always forward such requests to backing swap
+ * device (if present)
+ */
+ if (rzs->backing_swap) {
+ u32 pagenum;
+ stat_dec(rzs->stats.num_reads);
+ stat_inc(rzs->stats.bdev_num_reads);
+ bio->bi_bdev = rzs->backing_swap;
+
+ /*
+ * In case backing swap is a file, find the right offset within
+ * the file corresponding to logical position 'index'. For block
+ * device, this is a nop.
+ */
+ pagenum = bio->bi_sector >> SECTORS_PER_PAGE_SHIFT;
+ bio->bi_sector = map_backing_swap_page(rzs, pagenum)
+ << SECTORS_PER_PAGE_SHIFT;
+ return 1;
+ }
+
+ /*
+ * Its unlikely event in case backing dev is
+ * not present
+ */
+ pr_debug("Read before write on swap device: "
+ "sector=%lu, size=%u, offset=%u\n",
+ (ulong)(bio->bi_sector), bio->bi_size,
+ bio->bi_io_vec[0].bv_offset);
+
+ /* Do nothing. Just return success */
+ set_bit(BIO_UPTODATE, &bio->bi_flags);
+ bio_endio(bio, 0);
+ return 0;
+}
+
+static int ramzswap_read(struct ramzswap *rzs, struct bio *bio)
+{
+ int ret;
+ u32 index;
+ size_t clen;
+ struct page *page;
+ struct zobj_header *zheader;
+ unsigned char *user_mem, *cmem;
+
+ stat_inc(rzs->stats.num_reads);
+
+ page = bio->bi_io_vec[0].bv_page;
+ index = bio->bi_sector >> SECTORS_PER_PAGE_SHIFT;
+
+ if (rzs_test_flag(rzs, index, RZS_ZERO))
+ return handle_zero_page(bio);
+
+ /* Requested page is not present in compressed area */
+ if (!rzs->table[index].page)
+ return handle_ramzswap_fault(rzs, bio);
+
+ /* Page is stored uncompressed since its incompressible */
+ if (unlikely(rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)))
+ return handle_uncompressed_page(rzs, bio);
+
+ user_mem = kmap_atomic(page, KM_USER0);
+ clen = PAGE_SIZE;
+
+ cmem = kmap_atomic(rzs->table[index].page, KM_USER1) +
+ rzs->table[index].offset;
+
+ ret = lzo1x_decompress_safe(
+ cmem + sizeof(*zheader),
+ xv_get_object_size(cmem) - sizeof(*zheader),
+ user_mem, &clen);
+
+ kunmap_atomic(user_mem, KM_USER0);
+ kunmap_atomic(cmem, KM_USER1);
+
+ /* should NEVER happen */
+ if (unlikely(ret != LZO_E_OK)) {
+ pr_err("Decompression failed! err=%d, page=%u\n",
+ ret, index);
+ stat_inc(rzs->stats.failed_reads);
+ goto out;
+ }
+
+ ramzswap_flush_dcache_page(page);
+
+ set_bit(BIO_UPTODATE, &bio->bi_flags);
+ bio_endio(bio, 0);
+ return 0;
+
+out:
+ bio_io_error(bio);
+ return 0;
+}
+
+static int ramzswap_write(struct ramzswap *rzs, struct bio *bio)
+{
+ int ret, fwd_write_request = 0;
+ u32 offset, index;
+ size_t clen;
+ struct zobj_header *zheader;
+ struct page *page, *page_store;
+ unsigned char *user_mem, *cmem, *src;
+
+ stat_inc(rzs->stats.num_writes);
+
+ page = bio->bi_io_vec[0].bv_page;
+ index = bio->bi_sector >> SECTORS_PER_PAGE_SHIFT;
+
+ src = rzs->compress_buffer;
+
+ /*
+ * System swaps to same sector again when the stored page
+ * is no longer referenced by any process. So, its now safe
+ * to free the memory that was allocated for this page.
+ */
+ if (rzs->table[index].page)
+ ramzswap_free_page(rzs, index);
+
+ /*
+ * No memory ia allocated for zero filled pages.
+ * Simply clear zero page flag.
+ */
+ if (rzs_test_flag(rzs, index, RZS_ZERO)) {
+ stat_dec(rzs->stats.pages_zero);
+ rzs_clear_flag(rzs, index, RZS_ZERO);
+ }
+
+ mutex_lock(&rzs->lock);
+
+ user_mem = kmap_atomic(page, KM_USER0);
+ if (page_zero_filled(user_mem)) {
+ kunmap_atomic(user_mem, KM_USER0);
+ mutex_unlock(&rzs->lock);
+ stat_inc(rzs->stats.pages_zero);
+ rzs_set_flag(rzs, index, RZS_ZERO);
+
+ set_bit(BIO_UPTODATE, &bio->bi_flags);
+ bio_endio(bio, 0);
+ return 0;
+ }
+
+ if (rzs->backing_swap &&
+ (rzs->stats.compr_size > rzs->memlimit - PAGE_SIZE)) {
+ kunmap_atomic(user_mem, KM_USER0);
+ mutex_unlock(&rzs->lock);
+ fwd_write_request = 1;
+ goto out;
+ }
+
+ ret = lzo1x_1_compress(user_mem, PAGE_SIZE, src, &clen,
+ rzs->compress_workmem);
+
+ kunmap_atomic(user_mem, KM_USER0);
+
+ if (unlikely(ret != LZO_E_OK)) {
+ mutex_unlock(&rzs->lock);
+ pr_err("Compression failed! err=%d\n", ret);
+ stat_inc(rzs->stats.failed_writes);
+ goto out;
+ }
+
+ /*
+ * Page is incompressible. Forward it to backing swap
+ * if present. Otherwise, store it as-is (uncompressed)
+ * since we do not want to return too many swap write
+ * errors which has side effect of hanging the system.
+ */
+ if (unlikely(clen > max_zpage_size)) {
+ if (rzs->backing_swap) {
+ mutex_unlock(&rzs->lock);
+ fwd_write_request = 1;
+ goto out;
+ }
+
+ clen = PAGE_SIZE;
+ page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
+ if (unlikely(!page_store)) {
+ mutex_unlock(&rzs->lock);
+ pr_info("Error allocating memory for incompressible "
+ "page: %u\n", index);
+ stat_inc(rzs->stats.failed_writes);
+ goto out;
+ }
+
+ offset = 0;
+ rzs_set_flag(rzs, index, RZS_UNCOMPRESSED);
+ stat_inc(rzs->stats.pages_expand);
+ rzs->table[index].page = page_store;
+ src = kmap_atomic(page, KM_USER0);
+ goto memstore;
+ }
+
+ if (xv_malloc(rzs->mem_pool, clen + sizeof(*zheader),
+ &rzs->table[index].page, &offset,
+ GFP_NOIO | __GFP_HIGHMEM)) {
+ mutex_unlock(&rzs->lock);
+ pr_info("Error allocating memory for compressed "
+ "page: %u, size=%zu\n", index, clen);
+ stat_inc(rzs->stats.failed_writes);
+ if (rzs->backing_swap)
+ fwd_write_request = 1;
+ goto out;
+ }
+
+memstore:
+ rzs->table[index].offset = offset;
+
+ cmem = kmap_atomic(rzs->table[index].page, KM_USER1) +
+ rzs->table[index].offset;
+
+#if 0
+ /* Back-reference needed for memory defragmentation */
+ if (!rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)) {
+ zheader = (struct zobj_header *)cmem;
+ zheader->table_idx = index;
+ cmem += sizeof(*zheader);
+ }
+#endif
+
+ memcpy(cmem, src, clen);
+
+ kunmap_atomic(cmem, KM_USER1);
+ if (unlikely(rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)))
+ kunmap_atomic(src, KM_USER0);
+
+ /* Update stats */
+ rzs->stats.compr_size += clen;
+ stat_inc(rzs->stats.pages_stored);
+ if (clen <= PAGE_SIZE / 2)
+ stat_inc(rzs->stats.good_compress);
+
+ mutex_unlock(&rzs->lock);
+
+ set_bit(BIO_UPTODATE, &bio->bi_flags);
+ bio_endio(bio, 0);
+ return 0;
+
+out:
+ if (fwd_write_request) {
+ stat_inc(rzs->stats.bdev_num_writes);
+ bio->bi_bdev = rzs->backing_swap;
+#if 0
+ /*
+ * TODO: We currently have linear mapping of ramzswap and
+ * backing swap sectors. This is not desired since we want
+ * to optimize writes to backing swap to minimize disk seeks
+ * or have effective wear leveling (for SSDs). Also, a
+ * non-linear mapping is required to implement compressed
+ * on-disk swapping.
+ */
+ bio->bi_sector = get_backing_swap_page()
+ << SECTORS_PER_PAGE_SHIFT;
+#endif
+ /*
+ * In case backing swap is a file, find the right offset within
+ * the file corresponding to logical position 'index'. For block
+ * device, this is a nop.
+ */
+ bio->bi_sector = map_backing_swap_page(rzs, index)
+ << SECTORS_PER_PAGE_SHIFT;
+ return 1;
+ }
+
+ bio_io_error(bio);
+ return 0;
+}
+
+
+/*
+ * Check if request is within bounds and page aligned.
+ */
+static inline int valid_swap_request(struct ramzswap *rzs, struct bio *bio)
+{
+ if (unlikely(
+ (bio->bi_sector >= (rzs->disksize >> SECTOR_SHIFT)) ||
+ (bio->bi_sector & (SECTORS_PER_PAGE - 1)) ||
+ (bio->bi_vcnt != 1) ||
+ (bio->bi_size != PAGE_SIZE) ||
+ (bio->bi_io_vec[0].bv_offset != 0))) {
+
+ return 0;
+ }
+
+ /* swap request is valid */
+ return 1;
+}
+
+/*
+ * Handler function for all ramzswap I/O requests.
+ */
+static int ramzswap_make_request(struct request_queue *queue, struct bio *bio)
+{
+ int ret = 0;
+ struct ramzswap *rzs = queue->queuedata;
+
+ if (unlikely(!rzs->init_done)) {
+ bio_io_error(bio);
+ return 0;
+ }
+
+ if (!valid_swap_request(rzs, bio)) {
+ stat_inc(rzs->stats.invalid_io);
+ bio_io_error(bio);
+ return 0;
+ }
+
+ switch (bio_data_dir(bio)) {
+ case READ:
+ ret = ramzswap_read(rzs, bio);
+ break;
+
+ case WRITE:
+ ret = ramzswap_write(rzs, bio);
+ break;
+ }
+
+ return ret;
+}
+
+static void reset_device(struct ramzswap *rzs)
+{
+ int is_backing_blkdev = 0;
+ size_t index, num_pages;
+ unsigned entries_per_page;
+ unsigned long num_table_pages, entry = 0;
+
+ if (rzs->backing_swap && !rzs->num_extents)
+ is_backing_blkdev = 1;
+
+ num_pages = rzs->disksize >> PAGE_SHIFT;
+
+ /* Free various per-device buffers */
+ kfree(rzs->compress_workmem);
+ free_pages((unsigned long)rzs->compress_buffer, 1);
+
+ rzs->compress_workmem = NULL;
+ rzs->compress_buffer = NULL;
+
+ /* Free all pages that are still in this ramzswap device */
+ for (index = 0; index < num_pages; index++) {
+ struct page *page;
+ u16 offset;
+
+ page = rzs->table[index].page;
+ offset = rzs->table[index].offset;
+
+ if (!page)
+ continue;
+
+ if (unlikely(rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)))
+ __free_page(page);
+ else
+ xv_free(rzs->mem_pool, page, offset);
+ }
+
+ entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
+ num_table_pages = DIV_ROUND_UP(num_pages * sizeof(*rzs->table),
+ PAGE_SIZE);
+ /*
+ * Set page->mapping to NULL for every table page.
+ * Otherwise, we will hit bad_page() during free.
+ */
+ while (rzs->num_extents && num_table_pages--) {
+ struct page *page;
+ page = vmalloc_to_page(&rzs->table[entry]);
+ page->mapping = NULL;
+ entry += entries_per_page;
+ }
+ vfree(rzs->table);
+ rzs->table = NULL;
+
+ xv_destroy_pool(rzs->mem_pool);
+ rzs->mem_pool = NULL;
+
+ /* Free all swap extent pages */
+ while (!list_empty(&rzs->backing_swap_extent_list)) {
+ struct page *page;
+ struct list_head *entry;
+ entry = rzs->backing_swap_extent_list.next;
+ page = list_entry(entry, struct page, lru);
+ list_del(entry);
+ __free_page(page);
+ }
+ INIT_LIST_HEAD(&rzs->backing_swap_extent_list);
+ rzs->num_extents = 0;
+
+ /* Close backing swap device, if present */
+ if (rzs->backing_swap) {
+ if (is_backing_blkdev)
+ bd_release(rzs->backing_swap);
+ filp_close(rzs->swap_file, NULL);
+ rzs->backing_swap = NULL;
+ }
+
+ /* Reset stats */
+ memset(&rzs->stats, 0, sizeof(rzs->stats));
+
+ rzs->disksize = 0;
+ rzs->memlimit = 0;
+
+ /* Back to uninitialized state */
+ rzs->init_done = 0;
+}
+
+static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
+{
+ int ret;
+ size_t num_pages;
+ struct page *page;
+ union swap_header *swap_header;
+
+ if (rzs->init_done) {
+ pr_info("Device already initialized!\n");
+ return -EBUSY;
+ }
+
+ ret = setup_backing_swap(rzs);
+ if (ret)
+ goto fail;
+
+ if (rzs->backing_swap)
+ ramzswap_set_memlimit(rzs, totalram_pages << PAGE_SHIFT);
+ else
+ ramzswap_set_disksize(rzs, totalram_pages << PAGE_SHIFT);
+
+ rzs->compress_workmem = kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
+ if (!rzs->compress_workmem) {
+ pr_err("Error allocating compressor working memory!\n");
+ ret = -ENOMEM;
+ goto fail;
+ }
+
+ rzs->compress_buffer = (void *)__get_free_pages(__GFP_ZERO, 1);
+ if (!rzs->compress_buffer) {
+ pr_err("Error allocating compressor buffer space\n");
+ ret = -ENOMEM;
+ goto fail;
+ }
+
+ num_pages = rzs->disksize >> PAGE_SHIFT;
+ rzs->table = vmalloc(num_pages * sizeof(*rzs->table));
+ if (!rzs->table) {
+ pr_err("Error allocating ramzswap address table\n");
+ /* To prevent accessing table entries during cleanup */
+ rzs->disksize = 0;
+ ret = -ENOMEM;
+ goto fail;
+ }
+ memset(rzs->table, 0, num_pages * sizeof(*rzs->table));
+
+ map_backing_swap_extents(rzs);
+
+ page = alloc_page(__GFP_ZERO);
+ if (!page) {
+ pr_err("Error allocating swap header page\n");
+ ret = -ENOMEM;
+ goto fail;
+ }
+ rzs->table[0].page = page;
+ rzs_set_flag(rzs, 0, RZS_UNCOMPRESSED);
+
+ swap_header = kmap(page);
+ ret = setup_swap_header(rzs, swap_header);
+ kunmap(page);
+ if (ret) {
+ pr_err("Error setting swap header\n");
+ goto fail;
+ }
+
+ set_capacity(rzs->disk, rzs->disksize >> SECTOR_SHIFT);
+
+ /*
+ * We have ident mapping of sectors for ramzswap and
+ * and the backing swap device. So, this queue flag
+ * should be according to backing dev.
+ */
+ if (!rzs->backing_swap ||
+ blk_queue_nonrot(rzs->backing_swap->bd_disk->queue))
+ queue_flag_set_unlocked(QUEUE_FLAG_NONROT, rzs->disk->queue);
+
+ rzs->mem_pool = xv_create_pool();
+ if (!rzs->mem_pool) {
+ pr_err("Error creating memory pool\n");
+ ret = -ENOMEM;
+ goto fail;
+ }
+
+ /*
+ * Pages that compress to size greater than this are forwarded
+ * to physical swap disk (if backing dev is provided)
+ * TODO: make this configurable
+ */
+ if (rzs->backing_swap)
+ max_zpage_size = max_zpage_size_bdev;
+ else
+ max_zpage_size = max_zpage_size_nobdev;
+ pr_debug("Max compressed page size: %u bytes\n", max_zpage_size);
+
+ rzs->init_done = 1;
+
+ pr_debug("Initialization done!\n");
+ return 0;
+
+fail:
+ reset_device(rzs);
+
+ pr_err("Initialization failed: err=%d\n", ret);
+ return ret;
+}
+
+static int ramzswap_ioctl_reset_device(struct ramzswap *rzs)
+{
+ if (rzs->init_done)
+ reset_device(rzs);
+
+ return 0;
+}
+
+static int ramzswap_ioctl(struct block_device *bdev, fmode_t mode,
+ unsigned int cmd, unsigned long arg)
+{
+ int ret = 0;
+ size_t disksize_kb, memlimit_kb;
+
+ struct ramzswap *rzs = bdev->bd_disk->private_data;
+
+ switch (cmd) {
+ case RZSIO_SET_DISKSIZE_KB:
+ if (rzs->init_done) {
+ ret = -EBUSY;
+ goto out;
+ }
+ if (copy_from_user(&disksize_kb, (void *)arg,
+ _IOC_SIZE(cmd))) {
+ ret = -EFAULT;
+ goto out;
+ }
+ rzs->disksize = disksize_kb << 10;
+ pr_info("Disk size set to %zu kB\n", disksize_kb);
+ break;
+
+ case RZSIO_SET_MEMLIMIT_KB:
+ if (rzs->init_done) {
+ /* TODO: allow changing memlimit */
+ ret = -EBUSY;
+ goto out;
+ }
+ if (copy_from_user(&memlimit_kb, (void *)arg,
+ _IOC_SIZE(cmd))) {
+ ret = -EFAULT;
+ goto out;
+ }
+ rzs->memlimit = memlimit_kb << 10;
+ pr_info("Memory limit set to %zu kB\n", memlimit_kb);
+ break;
+
+ case RZSIO_SET_BACKING_SWAP:
+ if (rzs->init_done) {
+ ret = -EBUSY;
+ goto out;
+ }
+
+ if (copy_from_user(&rzs->backing_swap_name, (void *)arg,
+ _IOC_SIZE(cmd))) {
+ ret = -EFAULT;
+ goto out;
+ }
+ rzs->backing_swap_name[MAX_SWAP_NAME_LEN - 1] = '\0';
+ pr_info("Backing swap set to %s\n", rzs->backing_swap_name);
+ break;
+
+ case RZSIO_GET_STATS:
+ {
+ struct ramzswap_ioctl_stats *stats;
+ if (!rzs->init_done) {
+ ret = -ENOTTY;
+ goto out;
+ }
+ stats = kzalloc(sizeof(*stats), GFP_KERNEL);
+ if (!stats) {
+ ret = -ENOMEM;
+ goto out;
+ }
+ ramzswap_ioctl_get_stats(rzs, stats);
+ if (copy_to_user((void *)arg, stats, sizeof(*stats))) {
+ kfree(stats);
+ ret = -EFAULT;
+ goto out;
+ }
+ kfree(stats);
+ break;
+ }
+ case RZSIO_INIT:
+ ret = ramzswap_ioctl_init_device(rzs);
+ break;
+
+ case RZSIO_RESET:
+ /* Do not reset an active device! */
+ if (bdev->bd_holders) {
+ ret = -EBUSY;
+ goto out;
+ }
+ ret = ramzswap_ioctl_reset_device(rzs);
+ break;
+
+ default:
+ pr_info("Invalid ioctl %u\n", cmd);
+ ret = -ENOTTY;
+ }
+
+out:
+ return ret;
+}
+
+static struct block_device_operations ramzswap_devops = {
+ .ioctl = ramzswap_ioctl,
+ .owner = THIS_MODULE,
+};
+
+static void create_device(struct ramzswap *rzs, int device_id)
+{
+ mutex_init(&rzs->lock);
+ INIT_LIST_HEAD(&rzs->backing_swap_extent_list);
+
+ rzs->queue = blk_alloc_queue(GFP_KERNEL);
+ if (!rzs->queue) {
+ pr_err("Error allocating disk queue for device %d\n",
+ device_id);
+ return;
+ }
+
+ blk_queue_make_request(rzs->queue, ramzswap_make_request);
+ rzs->queue->queuedata = rzs;
+
+ /* gendisk structure */
+ rzs->disk = alloc_disk(1);
+ if (!rzs->disk) {
+ blk_cleanup_queue(rzs->queue);
+ pr_warning("Error allocating disk structure for device %d\n",
+ device_id);
+ return;
+ }
+
+ rzs->disk->major = ramzswap_major;
+ rzs->disk->first_minor = device_id;
+ rzs->disk->fops = &ramzswap_devops;
+ rzs->disk->queue = rzs->queue;
+ rzs->disk->private_data = rzs;
+ snprintf(rzs->disk->disk_name, 16, "ramzswap%d", device_id);
+
+ /*
+ * Actual capacity set using RZSIO_SET_DISKSIZE_KB ioctl
+ * or set equal to backing swap device (if provided)
+ */
+ set_capacity(rzs->disk, 0);
+ add_disk(rzs->disk);
+
+ rzs->init_done = 0;
+}
+
+static void destroy_device(struct ramzswap *rzs)
+{
+ if (rzs->disk) {
+ del_gendisk(rzs->disk);
+ put_disk(rzs->disk);
+ }
+
+ if (rzs->queue)
+ blk_cleanup_queue(rzs->queue);
+}
+
+static int __init ramzswap_init(void)
+{
+ int i, ret;
+
+ if (num_devices > max_num_devices) {
+ pr_warning("Invalid value for num_devices: %u\n",
+ num_devices);
+ return -EINVAL;
+ }
+
+ ramzswap_major = register_blkdev(0, "ramzswap");
+ if (ramzswap_major <= 0) {
+ pr_warning("Unable to get major number\n");
+ return -EBUSY;
+ }
+
+ if (!num_devices) {
+ pr_info("num_devices not specified. Using default: 1\n");
+ num_devices = 1;
+ }
+
+ /* Allocate the device array and initialize each one */
+ pr_info("Creating %u devices ...\n", num_devices);
+ devices = kzalloc(num_devices * sizeof(struct ramzswap), GFP_KERNEL);
+ if (!devices) {
+ ret = -ENOMEM;
+ goto out;
+ }
+
+ for (i = 0; i < num_devices; i++)
+ create_device(&devices[i], i);
+
+ return 0;
+out:
+ unregister_blkdev(ramzswap_major, "ramzswap");
+ return ret;
+}
+
+static void __exit ramzswap_exit(void)
+{
+ int i;
+ struct ramzswap *rzs;
+
+ for (i = 0; i < num_devices; i++) {
+ rzs = &devices[i];
+
+ destroy_device(rzs);
+ if (rzs->init_done)
+ reset_device(rzs);
+ }
+
+ unregister_blkdev(ramzswap_major, "ramzswap");
+
+ kfree(devices);
+ pr_debug("Cleanup done!\n");
+}
+
+module_param(num_devices, uint, 0);
+MODULE_PARM_DESC(num_devices, "Number of ramzswap devices");
+
+module_init(ramzswap_init);
+module_exit(ramzswap_exit);
+
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_AUTHOR("Nitin Gupta <[email protected]>");
+MODULE_DESCRIPTION("Compressed RAM Based Swap Device");
diff --git a/drivers/staging/ramzswap/ramzswap_drv.h b/drivers/staging/ramzswap/ramzswap_drv.h
new file mode 100644
index 0000000..a6ea240
--- /dev/null
+++ b/drivers/staging/ramzswap/ramzswap_drv.h
@@ -0,0 +1,171 @@
+/*
+ * Compressed RAM based swap device
+ *
+ * Copyright (C) 2008, 2009 Nitin Gupta
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ *
+ * Project home: http://compcache.googlecode.com
+ */
+
+#ifndef _RAMZSWAP_DRV_H_
+#define _RAMZSWAP_DRV_H_
+
+#include "ramzswap_ioctl.h"
+#include "xvmalloc.h"
+
+/*
+ * Some arbitrary value. This is just to catch
+ * invalid value for num_devices module parameter.
+ */
+static const unsigned max_num_devices = 32;
+
+/*
+ * Stored at beginning of each compressed object.
+ *
+ * It stores back-reference to table entry which points to this
+ * object. This is required to support memory defragmentation or
+ * migrating compressed pages to backing swap disk.
+ */
+struct zobj_header {
+#if 0
+ u32 table_idx;
+#endif
+};
+
+/*-- Configurable parameters */
+
+/* Default ramzswap disk size: 25% of total RAM */
+static const unsigned default_disksize_perc_ram = 25;
+static const unsigned default_memlimit_perc_ram = 15;
+
+/*
+ * Max compressed page size when backing device is provided.
+ * Pages that compress to size greater than this are sent to
+ * physical swap disk.
+ */
+static const unsigned max_zpage_size_bdev = PAGE_SIZE / 2;
+
+/*
+ * Max compressed page size when there is no backing dev.
+ * Pages that compress to size greater than this are stored
+ * uncompressed in memory.
+ */
+static const unsigned max_zpage_size_nobdev = PAGE_SIZE / 4 * 3;
+
+/*
+ * NOTE: max_zpage_size_{bdev,nobdev} sizes must be
+ * less than or equal to:
+ * XV_MAX_ALLOC_SIZE - sizeof(struct zobj_header)
+ * since otherwise xv_malloc would always return failure.
+ */
+
+/*-- End of configurable params */
+
+#define SECTOR_SHIFT 9
+#define SECTOR_SIZE (1 << SECTOR_SHIFT)
+#define SECTORS_PER_PAGE_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)
+#define SECTORS_PER_PAGE (1 << SECTORS_PER_PAGE_SHIFT)
+
+/* Debugging and Stats */
+#if defined(CONFIG_RAMZSWAP_STATS)
+#define stat_inc(stat) ((stat)++)
+#define stat_dec(stat) ((stat)--)
+#else
+#define stat_inc(x)
+#define stat_dec(x)
+#endif
+
+/* Flags for ramzswap pages (table[page_no].flags) */
+enum rzs_pageflags {
+ /* Page is stored uncompressed */
+ RZS_UNCOMPRESSED,
+
+ /* Page consists entirely of zeros */
+ RZS_ZERO,
+
+ __NR_RZS_PAGEFLAGS,
+};
+
+/*-- Data structures */
+
+/*
+ * Allocated for each swap slot, indexed by page no.
+ * These table entries must fit exactly in a page.
+ */
+struct table {
+ struct page *page;
+ u16 offset;
+ u8 count; /* object ref count (not yet used) */
+ u8 flags;
+} __attribute__((aligned(4)));;
+
+/*
+ * Swap extent information in case backing swap is a regular
+ * file. These extent entries must fit exactly in a page.
+ */
+struct ramzswap_backing_extent {
+ pgoff_t phy_pagenum;
+ pgoff_t num_pages;
+} __attribute__((aligned(4)));
+
+struct ramzswap_stats {
+ /* basic stats */
+ size_t compr_size; /* compressed size of pages stored -
+ * needed to enforce memlimit */
+ /* more stats */
+#if defined(CONFIG_RAMZSWAP_STATS)
+ u64 num_reads; /* failed + successful */
+ u64 num_writes; /* --do-- */
+ u64 failed_reads; /* can happen when memory is too low */
+ u64 failed_writes; /* should NEVER! happen */
+ u64 invalid_io; /* non-swap I/O requests */
+ u32 pages_zero; /* no. of zero filled pages */
+ u32 pages_stored; /* no. of pages currently stored */
+ u32 good_compress; /* % of pages with compression ratio<=50% */
+ u32 pages_expand; /* % of incompressible pages */
+ u64 bdev_num_reads; /* no. of reads on backing dev */
+ u64 bdev_num_writes; /* no. of writes on backing dev */
+#endif
+};
+
+struct ramzswap {
+ struct xv_pool *mem_pool;
+ void *compress_workmem;
+ void *compress_buffer;
+ struct table *table;
+ struct mutex lock;
+ struct request_queue *queue;
+ struct gendisk *disk;
+ int init_done;
+ /*
+ * This is limit on compressed data size (stats.compr_size)
+ * Its applicable only when backing swap device is present.
+ */
+ size_t memlimit; /* bytes */
+ /*
+ * This is limit on amount of *uncompressed* worth of data
+ * we can hold. When backing swap device is provided, it is
+ * set equal to device size.
+ */
+ size_t disksize; /* bytes */
+
+ struct ramzswap_stats stats;
+
+ /* backing swap device info */
+ struct ramzswap_backing_extent *curr_extent;
+ struct list_head backing_swap_extent_list;
+ unsigned long num_extents;
+ char backing_swap_name[MAX_SWAP_NAME_LEN];
+ struct block_device *backing_swap;
+ struct file *swap_file;
+};
+
+/*-- */
+
+#endif
+
diff --git a/drivers/staging/ramzswap/ramzswap_ioctl.h b/drivers/staging/ramzswap/ramzswap_ioctl.h
new file mode 100644
index 0000000..c713a09
--- /dev/null
+++ b/drivers/staging/ramzswap/ramzswap_ioctl.h
@@ -0,0 +1,49 @@
+/*
+ * Compressed RAM based swap device
+ *
+ * Copyright (C) 2008, 2009 Nitin Gupta
+ *
+ * This code is released using a dual license strategy: BSD/GPL
+ * You can choose the licence that better fits your requirements.
+ *
+ * Released under the terms of 3-clause BSD License
+ * Released under the terms of GNU General Public License Version 2.0
+ *
+ * Project home: http://compcache.googlecode.com
+ */
+
+#ifndef _RAMZSWAP_IOCTL_H_
+#define _RAMZSWAP_IOCTL_H_
+
+#define MAX_SWAP_NAME_LEN 128
+
+struct ramzswap_ioctl_stats {
+ char backing_swap_name[MAX_SWAP_NAME_LEN];
+ u64 memlimit; /* only applicable if backing swap present */
+ u64 disksize; /* user specified or equal to backing swap
+ * size (if present) */
+ u64 num_reads; /* failed + successful */
+ u64 num_writes; /* --do-- */
+ u64 failed_reads; /* can happen when memory is too low */
+ u64 failed_writes; /* should NEVER! happen */
+ u64 invalid_io; /* non-swap I/O requests */
+ u32 pages_zero; /* no. of zero filled pages */
+ u32 good_compress_pct; /* no. of pages with compression ratio<=50% */
+ u32 pages_expand_pct; /* no. of incompressible pages */
+ u32 pages_stored;
+ u32 pages_used;
+ u64 orig_data_size;
+ u64 compr_data_size;
+ u64 mem_used_total;
+ u64 bdev_num_reads; /* no. of reads on backing dev */
+ u64 bdev_num_writes; /* no. of writes on backing dev */
+} __attribute__ ((packed, aligned(4)));
+
+#define RZSIO_SET_DISKSIZE_KB _IOW('z', 0, size_t)
+#define RZSIO_SET_MEMLIMIT_KB _IOW('z', 1, size_t)
+#define RZSIO_SET_BACKING_SWAP _IOW('z', 2, unsigned char[MAX_SWAP_NAME_LEN])
+#define RZSIO_GET_STATS _IOR('z', 3, struct ramzswap_ioctl_stats)
+#define RZSIO_INIT _IO('z', 4)
+#define RZSIO_RESET _IO('z', 5)
+
+#endif
Short guide on how to setup and use ramzswap.
Signed-off-by: Nitin Gupta <[email protected]>
---
drivers/staging/ramzswap/ramzswap.txt | 51 +++++++++++++++++++++++++++++++++
1 files changed, 51 insertions(+), 0 deletions(-)
diff --git a/drivers/staging/ramzswap/ramzswap.txt b/drivers/staging/ramzswap/ramzswap.txt
new file mode 100644
index 0000000..e9f1619
--- /dev/null
+++ b/drivers/staging/ramzswap/ramzswap.txt
@@ -0,0 +1,51 @@
+ramzswap: Compressed RAM based swap device
+-------------------------------------------
+
+Project home: http://compcache.googlecode.com/
+
+* Introduction
+
+It creates RAM based block devices which can be used (only) as swap disks.
+Pages swapped to these devices are compressed and stored in memory itself.
+See project home for use cases, performance numbers and a lot more.
+
+Individual ramzswap devices are configured and initialized using rzscontrol
+userspace utility as shown in examples below. See rzscontrol man page for more
+details.
+
+* Usage
+
+Following shows a typical sequence of steps for using ramzswap.
+
+1) Load Modules:
+ modprobe ramzswap num_devices=4
+ This creates 4 (uninitialized) devices: /dev/ramzswap{0,1,2,3}
+ (num_devices parameter is optional. Default: 1)
+
+2) Initialize:
+ Use rzscontrol utility to configure and initialize individual
+ ramzswap devices. Example:
+ rzscontrol /dev/ramzswap2 --init # uses default value of disksize_kb
+
+ *See rzscontrol man page for more details and examples*
+
+3) Activate:
+ swapon /dev/ramzswap2 # or any other initialized ramzswap device
+
+4) Stats:
+ rzscontrol /dev/ramzswap2 --stats
+
+5) Deactivate:
+ swapoff /dev/ramzswap2
+
+6) Reset:
+ rzscontrol /dev/ramzswap2 --reset
+ (This frees all the memory allocated for this device).
+
+
+Please report any problems at:
+ - Mailing list: linux-mm-cc at laptop dot org
+ - Issue tracker: http://code.google.com/p/compcache/issues/list
+
+Nitin Gupta
[email protected]
On Tue, 2009-09-22 at 10:26 +0530, Nitin Gupta wrote:
> drivers/staging/Kconfig | 2 +
> drivers/staging/Makefile | 1 +
> drivers/staging/ramzswap/Kconfig | 21 +
> drivers/staging/ramzswap/Makefile | 3 +
> drivers/staging/ramzswap/ramzswap.txt | 51 +
> drivers/staging/ramzswap/ramzswap_drv.c | 1462 +++++++++++++++++++++++++++++
> drivers/staging/ramzswap/ramzswap_drv.h | 173 ++++
> drivers/staging/ramzswap/ramzswap_ioctl.h | 50 +
> drivers/staging/ramzswap/xvmalloc.c | 533 +++++++++++
> drivers/staging/ramzswap/xvmalloc.h | 30 +
> drivers/staging/ramzswap/xvmalloc_int.h | 86 ++
> include/linux/swap.h | 5 +
> mm/swapfile.c | 34 +
> 13 files changed, 2451 insertions(+), 0 deletions(-)
This diffstat is not up to date, I think.
Greg, would you mind taking this driver into staging? There are some
issues that need to be ironed out for it to be merged to kernel proper
but I think it would benefit from being exposed to mainline.
Nitin, you probably should also submit a patch that adds a TODO file
similar to other staging drivers to remind us that swap notifiers and
the CONFIG_ARM thing need to be resolved.
Pekka
On Tue, Sep 22, 2009 at 11:43 AM, Pekka Enberg <[email protected]> wrote:
> On Tue, 2009-09-22 at 10:26 +0530, Nitin Gupta wrote:
>> ?drivers/staging/Kconfig ? ? ? ? ? ? ? ? ? | ? ?2 +
>> ?drivers/staging/Makefile ? ? ? ? ? ? ? ? ?| ? ?1 +
>> ?drivers/staging/ramzswap/Kconfig ? ? ? ? ?| ? 21 +
>> ?drivers/staging/ramzswap/Makefile ? ? ? ? | ? ?3 +
>> ?drivers/staging/ramzswap/ramzswap.txt ? ? | ? 51 +
>> ?drivers/staging/ramzswap/ramzswap_drv.c ? | 1462 +++++++++++++++++++++++++++++
>> ?drivers/staging/ramzswap/ramzswap_drv.h ? | ?173 ++++
>> ?drivers/staging/ramzswap/ramzswap_ioctl.h | ? 50 +
>> ?drivers/staging/ramzswap/xvmalloc.c ? ? ? | ?533 +++++++++++
>> ?drivers/staging/ramzswap/xvmalloc.h ? ? ? | ? 30 +
>> ?drivers/staging/ramzswap/xvmalloc_int.h ? | ? 86 ++
>> ?include/linux/swap.h ? ? ? ? ? ? ? ? ? ? ?| ? ?5 +
>> ?mm/swapfile.c ? ? ? ? ? ? ? ? ? ? ? ? ? ? | ? 34 +
>> ?13 files changed, 2451 insertions(+), 0 deletions(-)
>
> This diffstat is not up to date, I think.
>
Oh! this is from v3. I forgot to update it. I don't have access to my git tree
here in office, so cannot send updated version right now.
> Greg, would you mind taking this driver into staging? There are some
> issues that need to be ironed out for it to be merged to kernel proper
> but I think it would benefit from being exposed to mainline.
>
> Nitin, you probably should also submit a patch that adds a TODO file
> similar to other staging drivers to remind us that swap notifiers and
> the CONFIG_ARM thing need to be resolved.
>
ok, I will send patch for TODO file.
Thanks,
Nitin
On Tue, Sep 22, 2009 at 09:13:50AM +0300, Pekka Enberg wrote:
> On Tue, 2009-09-22 at 10:26 +0530, Nitin Gupta wrote:
> > drivers/staging/Kconfig | 2 +
> > drivers/staging/Makefile | 1 +
> > drivers/staging/ramzswap/Kconfig | 21 +
> > drivers/staging/ramzswap/Makefile | 3 +
> > drivers/staging/ramzswap/ramzswap.txt | 51 +
> > drivers/staging/ramzswap/ramzswap_drv.c | 1462 +++++++++++++++++++++++++++++
> > drivers/staging/ramzswap/ramzswap_drv.h | 173 ++++
> > drivers/staging/ramzswap/ramzswap_ioctl.h | 50 +
> > drivers/staging/ramzswap/xvmalloc.c | 533 +++++++++++
> > drivers/staging/ramzswap/xvmalloc.h | 30 +
> > drivers/staging/ramzswap/xvmalloc_int.h | 86 ++
> > include/linux/swap.h | 5 +
> > mm/swapfile.c | 34 +
> > 13 files changed, 2451 insertions(+), 0 deletions(-)
>
> This diffstat is not up to date, I think.
>
> Greg, would you mind taking this driver into staging? There are some
> issues that need to be ironed out for it to be merged to kernel proper
> but I think it would benefit from being exposed to mainline.
That would be fine, will there be a new set of patches for me to apply,
or is this the correct series?
thanks,
greg k-h
On 09/22/2009 09:07 PM, Greg KH wrote:
> On Tue, Sep 22, 2009 at 09:13:50AM +0300, Pekka Enberg wrote:
>> On Tue, 2009-09-22 at 10:26 +0530, Nitin Gupta wrote:
>>> drivers/staging/Kconfig | 2 +
>>> drivers/staging/Makefile | 1 +
>>> drivers/staging/ramzswap/Kconfig | 21 +
>>> drivers/staging/ramzswap/Makefile | 3 +
>>> drivers/staging/ramzswap/ramzswap.txt | 51 +
>>> drivers/staging/ramzswap/ramzswap_drv.c | 1462 +++++++++++++++++++++++++++++
>>> drivers/staging/ramzswap/ramzswap_drv.h | 173 ++++
>>> drivers/staging/ramzswap/ramzswap_ioctl.h | 50 +
>>> drivers/staging/ramzswap/xvmalloc.c | 533 +++++++++++
>>> drivers/staging/ramzswap/xvmalloc.h | 30 +
>>> drivers/staging/ramzswap/xvmalloc_int.h | 86 ++
>>> include/linux/swap.h | 5 +
>>> mm/swapfile.c | 34 +
>>> 13 files changed, 2451 insertions(+), 0 deletions(-)
>>
>> This diffstat is not up to date, I think.
>>
>> Greg, would you mind taking this driver into staging? There are some
>> issues that need to be ironed out for it to be merged to kernel proper
>> but I think it would benefit from being exposed to mainline.
>
> That would be fine, will there be a new set of patches for me to apply,
> or is this the correct series?
>
This is the correct series.
Thanks,
Nitin
On Tue, Sep 22, 2009 at 09:22:30PM +0530, Nitin Gupta wrote:
> On 09/22/2009 09:07 PM, Greg KH wrote:
> > On Tue, Sep 22, 2009 at 09:13:50AM +0300, Pekka Enberg wrote:
> >> On Tue, 2009-09-22 at 10:26 +0530, Nitin Gupta wrote:
> >>> drivers/staging/Kconfig | 2 +
> >>> drivers/staging/Makefile | 1 +
> >>> drivers/staging/ramzswap/Kconfig | 21 +
> >>> drivers/staging/ramzswap/Makefile | 3 +
> >>> drivers/staging/ramzswap/ramzswap.txt | 51 +
> >>> drivers/staging/ramzswap/ramzswap_drv.c | 1462 +++++++++++++++++++++++++++++
> >>> drivers/staging/ramzswap/ramzswap_drv.h | 173 ++++
> >>> drivers/staging/ramzswap/ramzswap_ioctl.h | 50 +
> >>> drivers/staging/ramzswap/xvmalloc.c | 533 +++++++++++
> >>> drivers/staging/ramzswap/xvmalloc.h | 30 +
> >>> drivers/staging/ramzswap/xvmalloc_int.h | 86 ++
> >>> include/linux/swap.h | 5 +
> >>> mm/swapfile.c | 34 +
> >>> 13 files changed, 2451 insertions(+), 0 deletions(-)
> >>
> >> This diffstat is not up to date, I think.
> >>
> >> Greg, would you mind taking this driver into staging? There are some
> >> issues that need to be ironed out for it to be merged to kernel proper
> >> but I think it would benefit from being exposed to mainline.
> >
> > That would be fine, will there be a new set of patches for me to apply,
> > or is this the correct series?
> >
>
> This is the correct series.
Ok, thanks, I'll queue it up when I get back from the Plumbers
conference.
greg k-h
On Tue, 22 Sep 2009 10:26:53 +0530
Nitin Gupta <[email protected]> wrote:
> Creates RAM based block devices (/dev/ramzswapX) which can be
> used (only) as swap disks. Pages swapped to these are compressed
> and stored in memory itself.
>
> The module is called ramzswap.ko. It depends on:
> - xvmalloc memory allocator (compiled with this driver)
> - lzo_compress.ko
> - lzo_decompress.ko
>
> See ramzswap.txt for usage details.
>
> Signed-off-by: Nitin Gupta <[email protected]>
>
Hm...some concerns.
<snip>
> + if (unlikely(clen > max_zpage_size)) {
> + if (rzs->backing_swap) {
> + mutex_unlock(&rzs->lock);
> + fwd_write_request = 1;
> + goto out;
> + }
> +
> + clen = PAGE_SIZE;
> + page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
Here, and...
> + if (unlikely(!page_store)) {
> + mutex_unlock(&rzs->lock);
> + pr_info("Error allocating memory for incompressible "
> + "page: %u\n", index);
> + stat_inc(rzs->stats.failed_writes);
> + goto out;
> + }
> +
> + offset = 0;
> + rzs_set_flag(rzs, index, RZS_UNCOMPRESSED);
> + stat_inc(rzs->stats.pages_expand);
> + rzs->table[index].page = page_store;
> + src = kmap_atomic(page, KM_USER0);
> + goto memstore;
> + }
> +
> + if (xv_malloc(rzs->mem_pool, clen + sizeof(*zheader),
> + &rzs->table[index].page, &offset,
> + GFP_NOIO | __GFP_HIGHMEM)) {
Here.
Do we need to wait until here for detecting page-allocation-failure ?
Detecting it here means -EIO for end_swap_bio_write()....unhappy
ALERT messages etc..
Can't we add a hook to get_swap_page() for preparing this ("do we have
enough pool?") and use only GFP_ATOMIC throughout codes ?
(memory pool for this swap should be big to some extent.)
>From my user support experience for heavy swap customers, extra memory allocation for swapping out is just bad...in many cases.
(*) I know GFP_IO works well to some extent.
Thanks,
-Kame
> + mutex_unlock(&rzs->lock);
> + pr_info("Error allocating memory for compressed "
> + "page: %u, size=%zu\n", index, clen);
> + stat_inc(rzs->stats.failed_writes);
> + if (rzs->backing_swap)
> + fwd_write_request = 1;
> + goto out;
> + }
> +
> +memstore:
> + rzs->table[index].offset = offset;
> +
> + cmem = kmap_atomic(rzs->table[index].page, KM_USER1) +
> + rzs->table[index].offset;
> +
> +#if 0
> + /* Back-reference needed for memory defragmentation */
> + if (!rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)) {
> + zheader = (struct zobj_header *)cmem;
> + zheader->table_idx = index;
> + cmem += sizeof(*zheader);
> + }
> +#endif
> +
> + memcpy(cmem, src, clen);
> +
> + kunmap_atomic(cmem, KM_USER1);
> + if (unlikely(rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)))
> + kunmap_atomic(src, KM_USER0);
> +
> + /* Update stats */
> + rzs->stats.compr_size += clen;
> + stat_inc(rzs->stats.pages_stored);
> + if (clen <= PAGE_SIZE / 2)
> + stat_inc(rzs->stats.good_compress);
> +
> + mutex_unlock(&rzs->lock);
> +
> + set_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio_endio(bio, 0);
> + return 0;
> +
> +out:
> + if (fwd_write_request) {
> + stat_inc(rzs->stats.bdev_num_writes);
> + bio->bi_bdev = rzs->backing_swap;
> +#if 0
> + /*
> + * TODO: We currently have linear mapping of ramzswap and
> + * backing swap sectors. This is not desired since we want
> + * to optimize writes to backing swap to minimize disk seeks
> + * or have effective wear leveling (for SSDs). Also, a
> + * non-linear mapping is required to implement compressed
> + * on-disk swapping.
> + */
> + bio->bi_sector = get_backing_swap_page()
> + << SECTORS_PER_PAGE_SHIFT;
> +#endif
> + /*
> + * In case backing swap is a file, find the right offset within
> + * the file corresponding to logical position 'index'. For block
> + * device, this is a nop.
> + */
> + bio->bi_sector = map_backing_swap_page(rzs, index)
> + << SECTORS_PER_PAGE_SHIFT;
> + return 1;
> + }
> +
> + bio_io_error(bio);
> + return 0;
> +}
> +
> +
> +/*
> + * Check if request is within bounds and page aligned.
> + */
> +static inline int valid_swap_request(struct ramzswap *rzs, struct bio *bio)
> +{
> + if (unlikely(
> + (bio->bi_sector >= (rzs->disksize >> SECTOR_SHIFT)) ||
> + (bio->bi_sector & (SECTORS_PER_PAGE - 1)) ||
> + (bio->bi_vcnt != 1) ||
> + (bio->bi_size != PAGE_SIZE) ||
> + (bio->bi_io_vec[0].bv_offset != 0))) {
> +
> + return 0;
> + }
> +
> + /* swap request is valid */
> + return 1;
> +}
> +
> +/*
> + * Handler function for all ramzswap I/O requests.
> + */
> +static int ramzswap_make_request(struct request_queue *queue, struct bio *bio)
> +{
> + int ret = 0;
> + struct ramzswap *rzs = queue->queuedata;
> +
> + if (unlikely(!rzs->init_done)) {
> + bio_io_error(bio);
> + return 0;
> + }
> +
> + if (!valid_swap_request(rzs, bio)) {
> + stat_inc(rzs->stats.invalid_io);
> + bio_io_error(bio);
> + return 0;
> + }
> +
> + switch (bio_data_dir(bio)) {
> + case READ:
> + ret = ramzswap_read(rzs, bio);
> + break;
> +
> + case WRITE:
> + ret = ramzswap_write(rzs, bio);
> + break;
> + }
> +
> + return ret;
> +}
> +
> +static void reset_device(struct ramzswap *rzs)
> +{
> + int is_backing_blkdev = 0;
> + size_t index, num_pages;
> + unsigned entries_per_page;
> + unsigned long num_table_pages, entry = 0;
> +
> + if (rzs->backing_swap && !rzs->num_extents)
> + is_backing_blkdev = 1;
> +
> + num_pages = rzs->disksize >> PAGE_SHIFT;
> +
> + /* Free various per-device buffers */
> + kfree(rzs->compress_workmem);
> + free_pages((unsigned long)rzs->compress_buffer, 1);
> +
> + rzs->compress_workmem = NULL;
> + rzs->compress_buffer = NULL;
> +
> + /* Free all pages that are still in this ramzswap device */
> + for (index = 0; index < num_pages; index++) {
> + struct page *page;
> + u16 offset;
> +
> + page = rzs->table[index].page;
> + offset = rzs->table[index].offset;
> +
> + if (!page)
> + continue;
> +
> + if (unlikely(rzs_test_flag(rzs, index, RZS_UNCOMPRESSED)))
> + __free_page(page);
> + else
> + xv_free(rzs->mem_pool, page, offset);
> + }
> +
> + entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
> + num_table_pages = DIV_ROUND_UP(num_pages * sizeof(*rzs->table),
> + PAGE_SIZE);
> + /*
> + * Set page->mapping to NULL for every table page.
> + * Otherwise, we will hit bad_page() during free.
> + */
> + while (rzs->num_extents && num_table_pages--) {
> + struct page *page;
> + page = vmalloc_to_page(&rzs->table[entry]);
> + page->mapping = NULL;
> + entry += entries_per_page;
> + }
> + vfree(rzs->table);
> + rzs->table = NULL;
> +
> + xv_destroy_pool(rzs->mem_pool);
> + rzs->mem_pool = NULL;
> +
> + /* Free all swap extent pages */
> + while (!list_empty(&rzs->backing_swap_extent_list)) {
> + struct page *page;
> + struct list_head *entry;
> + entry = rzs->backing_swap_extent_list.next;
> + page = list_entry(entry, struct page, lru);
> + list_del(entry);
> + __free_page(page);
> + }
> + INIT_LIST_HEAD(&rzs->backing_swap_extent_list);
> + rzs->num_extents = 0;
> +
> + /* Close backing swap device, if present */
> + if (rzs->backing_swap) {
> + if (is_backing_blkdev)
> + bd_release(rzs->backing_swap);
> + filp_close(rzs->swap_file, NULL);
> + rzs->backing_swap = NULL;
> + }
> +
> + /* Reset stats */
> + memset(&rzs->stats, 0, sizeof(rzs->stats));
> +
> + rzs->disksize = 0;
> + rzs->memlimit = 0;
> +
> + /* Back to uninitialized state */
> + rzs->init_done = 0;
> +}
> +
> +static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
> +{
> + int ret;
> + size_t num_pages;
> + struct page *page;
> + union swap_header *swap_header;
> +
> + if (rzs->init_done) {
> + pr_info("Device already initialized!\n");
> + return -EBUSY;
> + }
> +
> + ret = setup_backing_swap(rzs);
> + if (ret)
> + goto fail;
> +
> + if (rzs->backing_swap)
> + ramzswap_set_memlimit(rzs, totalram_pages << PAGE_SHIFT);
> + else
> + ramzswap_set_disksize(rzs, totalram_pages << PAGE_SHIFT);
> +
> + rzs->compress_workmem = kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
> + if (!rzs->compress_workmem) {
> + pr_err("Error allocating compressor working memory!\n");
> + ret = -ENOMEM;
> + goto fail;
> + }
> +
> + rzs->compress_buffer = (void *)__get_free_pages(__GFP_ZERO, 1);
> + if (!rzs->compress_buffer) {
> + pr_err("Error allocating compressor buffer space\n");
> + ret = -ENOMEM;
> + goto fail;
> + }
> +
> + num_pages = rzs->disksize >> PAGE_SHIFT;
> + rzs->table = vmalloc(num_pages * sizeof(*rzs->table));
> + if (!rzs->table) {
> + pr_err("Error allocating ramzswap address table\n");
> + /* To prevent accessing table entries during cleanup */
> + rzs->disksize = 0;
> + ret = -ENOMEM;
> + goto fail;
> + }
> + memset(rzs->table, 0, num_pages * sizeof(*rzs->table));
> +
> + map_backing_swap_extents(rzs);
> +
> + page = alloc_page(__GFP_ZERO);
> + if (!page) {
> + pr_err("Error allocating swap header page\n");
> + ret = -ENOMEM;
> + goto fail;
> + }
> + rzs->table[0].page = page;
> + rzs_set_flag(rzs, 0, RZS_UNCOMPRESSED);
> +
> + swap_header = kmap(page);
> + ret = setup_swap_header(rzs, swap_header);
> + kunmap(page);
> + if (ret) {
> + pr_err("Error setting swap header\n");
> + goto fail;
> + }
> +
> + set_capacity(rzs->disk, rzs->disksize >> SECTOR_SHIFT);
> +
> + /*
> + * We have ident mapping of sectors for ramzswap and
> + * and the backing swap device. So, this queue flag
> + * should be according to backing dev.
> + */
> + if (!rzs->backing_swap ||
> + blk_queue_nonrot(rzs->backing_swap->bd_disk->queue))
> + queue_flag_set_unlocked(QUEUE_FLAG_NONROT, rzs->disk->queue);
> +
> + rzs->mem_pool = xv_create_pool();
> + if (!rzs->mem_pool) {
> + pr_err("Error creating memory pool\n");
> + ret = -ENOMEM;
> + goto fail;
> + }
> +
> + /*
> + * Pages that compress to size greater than this are forwarded
> + * to physical swap disk (if backing dev is provided)
> + * TODO: make this configurable
> + */
> + if (rzs->backing_swap)
> + max_zpage_size = max_zpage_size_bdev;
> + else
> + max_zpage_size = max_zpage_size_nobdev;
> + pr_debug("Max compressed page size: %u bytes\n", max_zpage_size);
> +
> + rzs->init_done = 1;
> +
> + pr_debug("Initialization done!\n");
> + return 0;
> +
> +fail:
> + reset_device(rzs);
> +
> + pr_err("Initialization failed: err=%d\n", ret);
> + return ret;
> +}
> +
> +static int ramzswap_ioctl_reset_device(struct ramzswap *rzs)
> +{
> + if (rzs->init_done)
> + reset_device(rzs);
> +
> + return 0;
> +}
> +
> +static int ramzswap_ioctl(struct block_device *bdev, fmode_t mode,
> + unsigned int cmd, unsigned long arg)
> +{
> + int ret = 0;
> + size_t disksize_kb, memlimit_kb;
> +
> + struct ramzswap *rzs = bdev->bd_disk->private_data;
> +
> + switch (cmd) {
> + case RZSIO_SET_DISKSIZE_KB:
> + if (rzs->init_done) {
> + ret = -EBUSY;
> + goto out;
> + }
> + if (copy_from_user(&disksize_kb, (void *)arg,
> + _IOC_SIZE(cmd))) {
> + ret = -EFAULT;
> + goto out;
> + }
> + rzs->disksize = disksize_kb << 10;
> + pr_info("Disk size set to %zu kB\n", disksize_kb);
> + break;
> +
> + case RZSIO_SET_MEMLIMIT_KB:
> + if (rzs->init_done) {
> + /* TODO: allow changing memlimit */
> + ret = -EBUSY;
> + goto out;
> + }
> + if (copy_from_user(&memlimit_kb, (void *)arg,
> + _IOC_SIZE(cmd))) {
> + ret = -EFAULT;
> + goto out;
> + }
> + rzs->memlimit = memlimit_kb << 10;
> + pr_info("Memory limit set to %zu kB\n", memlimit_kb);
> + break;
> +
> + case RZSIO_SET_BACKING_SWAP:
> + if (rzs->init_done) {
> + ret = -EBUSY;
> + goto out;
> + }
> +
> + if (copy_from_user(&rzs->backing_swap_name, (void *)arg,
> + _IOC_SIZE(cmd))) {
> + ret = -EFAULT;
> + goto out;
> + }
> + rzs->backing_swap_name[MAX_SWAP_NAME_LEN - 1] = '\0';
> + pr_info("Backing swap set to %s\n", rzs->backing_swap_name);
> + break;
> +
> + case RZSIO_GET_STATS:
> + {
> + struct ramzswap_ioctl_stats *stats;
> + if (!rzs->init_done) {
> + ret = -ENOTTY;
> + goto out;
> + }
> + stats = kzalloc(sizeof(*stats), GFP_KERNEL);
> + if (!stats) {
> + ret = -ENOMEM;
> + goto out;
> + }
> + ramzswap_ioctl_get_stats(rzs, stats);
> + if (copy_to_user((void *)arg, stats, sizeof(*stats))) {
> + kfree(stats);
> + ret = -EFAULT;
> + goto out;
> + }
> + kfree(stats);
> + break;
> + }
> + case RZSIO_INIT:
> + ret = ramzswap_ioctl_init_device(rzs);
> + break;
> +
> + case RZSIO_RESET:
> + /* Do not reset an active device! */
> + if (bdev->bd_holders) {
> + ret = -EBUSY;
> + goto out;
> + }
> + ret = ramzswap_ioctl_reset_device(rzs);
> + break;
> +
> + default:
> + pr_info("Invalid ioctl %u\n", cmd);
> + ret = -ENOTTY;
> + }
> +
> +out:
> + return ret;
> +}
> +
> +static struct block_device_operations ramzswap_devops = {
> + .ioctl = ramzswap_ioctl,
> + .owner = THIS_MODULE,
> +};
> +
> +static void create_device(struct ramzswap *rzs, int device_id)
> +{
> + mutex_init(&rzs->lock);
> + INIT_LIST_HEAD(&rzs->backing_swap_extent_list);
> +
> + rzs->queue = blk_alloc_queue(GFP_KERNEL);
> + if (!rzs->queue) {
> + pr_err("Error allocating disk queue for device %d\n",
> + device_id);
> + return;
> + }
> +
> + blk_queue_make_request(rzs->queue, ramzswap_make_request);
> + rzs->queue->queuedata = rzs;
> +
> + /* gendisk structure */
> + rzs->disk = alloc_disk(1);
> + if (!rzs->disk) {
> + blk_cleanup_queue(rzs->queue);
> + pr_warning("Error allocating disk structure for device %d\n",
> + device_id);
> + return;
> + }
> +
> + rzs->disk->major = ramzswap_major;
> + rzs->disk->first_minor = device_id;
> + rzs->disk->fops = &ramzswap_devops;
> + rzs->disk->queue = rzs->queue;
> + rzs->disk->private_data = rzs;
> + snprintf(rzs->disk->disk_name, 16, "ramzswap%d", device_id);
> +
> + /*
> + * Actual capacity set using RZSIO_SET_DISKSIZE_KB ioctl
> + * or set equal to backing swap device (if provided)
> + */
> + set_capacity(rzs->disk, 0);
> + add_disk(rzs->disk);
> +
> + rzs->init_done = 0;
> +}
> +
> +static void destroy_device(struct ramzswap *rzs)
> +{
> + if (rzs->disk) {
> + del_gendisk(rzs->disk);
> + put_disk(rzs->disk);
> + }
> +
> + if (rzs->queue)
> + blk_cleanup_queue(rzs->queue);
> +}
> +
> +static int __init ramzswap_init(void)
> +{
> + int i, ret;
> +
> + if (num_devices > max_num_devices) {
> + pr_warning("Invalid value for num_devices: %u\n",
> + num_devices);
> + return -EINVAL;
> + }
> +
> + ramzswap_major = register_blkdev(0, "ramzswap");
> + if (ramzswap_major <= 0) {
> + pr_warning("Unable to get major number\n");
> + return -EBUSY;
> + }
> +
> + if (!num_devices) {
> + pr_info("num_devices not specified. Using default: 1\n");
> + num_devices = 1;
> + }
> +
> + /* Allocate the device array and initialize each one */
> + pr_info("Creating %u devices ...\n", num_devices);
> + devices = kzalloc(num_devices * sizeof(struct ramzswap), GFP_KERNEL);
> + if (!devices) {
> + ret = -ENOMEM;
> + goto out;
> + }
> +
> + for (i = 0; i < num_devices; i++)
> + create_device(&devices[i], i);
> +
> + return 0;
> +out:
> + unregister_blkdev(ramzswap_major, "ramzswap");
> + return ret;
> +}
> +
> +static void __exit ramzswap_exit(void)
> +{
> + int i;
> + struct ramzswap *rzs;
> +
> + for (i = 0; i < num_devices; i++) {
> + rzs = &devices[i];
> +
> + destroy_device(rzs);
> + if (rzs->init_done)
> + reset_device(rzs);
> + }
> +
> + unregister_blkdev(ramzswap_major, "ramzswap");
> +
> + kfree(devices);
> + pr_debug("Cleanup done!\n");
> +}
> +
> +module_param(num_devices, uint, 0);
> +MODULE_PARM_DESC(num_devices, "Number of ramzswap devices");
> +
> +module_init(ramzswap_init);
> +module_exit(ramzswap_exit);
> +
> +MODULE_LICENSE("Dual BSD/GPL");
> +MODULE_AUTHOR("Nitin Gupta <[email protected]>");
> +MODULE_DESCRIPTION("Compressed RAM Based Swap Device");
> diff --git a/drivers/staging/ramzswap/ramzswap_drv.h b/drivers/staging/ramzswap/ramzswap_drv.h
> new file mode 100644
> index 0000000..a6ea240
> --- /dev/null
> +++ b/drivers/staging/ramzswap/ramzswap_drv.h
> @@ -0,0 +1,171 @@
> +/*
> + * Compressed RAM based swap device
> + *
> + * Copyright (C) 2008, 2009 Nitin Gupta
> + *
> + * This code is released using a dual license strategy: BSD/GPL
> + * You can choose the licence that better fits your requirements.
> + *
> + * Released under the terms of 3-clause BSD License
> + * Released under the terms of GNU General Public License Version 2.0
> + *
> + * Project home: http://compcache.googlecode.com
> + */
> +
> +#ifndef _RAMZSWAP_DRV_H_
> +#define _RAMZSWAP_DRV_H_
> +
> +#include "ramzswap_ioctl.h"
> +#include "xvmalloc.h"
> +
> +/*
> + * Some arbitrary value. This is just to catch
> + * invalid value for num_devices module parameter.
> + */
> +static const unsigned max_num_devices = 32;
> +
> +/*
> + * Stored at beginning of each compressed object.
> + *
> + * It stores back-reference to table entry which points to this
> + * object. This is required to support memory defragmentation or
> + * migrating compressed pages to backing swap disk.
> + */
> +struct zobj_header {
> +#if 0
> + u32 table_idx;
> +#endif
> +};
> +
> +/*-- Configurable parameters */
> +
> +/* Default ramzswap disk size: 25% of total RAM */
> +static const unsigned default_disksize_perc_ram = 25;
> +static const unsigned default_memlimit_perc_ram = 15;
> +
> +/*
> + * Max compressed page size when backing device is provided.
> + * Pages that compress to size greater than this are sent to
> + * physical swap disk.
> + */
> +static const unsigned max_zpage_size_bdev = PAGE_SIZE / 2;
> +
> +/*
> + * Max compressed page size when there is no backing dev.
> + * Pages that compress to size greater than this are stored
> + * uncompressed in memory.
> + */
> +static const unsigned max_zpage_size_nobdev = PAGE_SIZE / 4 * 3;
> +
> +/*
> + * NOTE: max_zpage_size_{bdev,nobdev} sizes must be
> + * less than or equal to:
> + * XV_MAX_ALLOC_SIZE - sizeof(struct zobj_header)
> + * since otherwise xv_malloc would always return failure.
> + */
> +
> +/*-- End of configurable params */
> +
> +#define SECTOR_SHIFT 9
> +#define SECTOR_SIZE (1 << SECTOR_SHIFT)
> +#define SECTORS_PER_PAGE_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)
> +#define SECTORS_PER_PAGE (1 << SECTORS_PER_PAGE_SHIFT)
> +
> +/* Debugging and Stats */
> +#if defined(CONFIG_RAMZSWAP_STATS)
> +#define stat_inc(stat) ((stat)++)
> +#define stat_dec(stat) ((stat)--)
> +#else
> +#define stat_inc(x)
> +#define stat_dec(x)
> +#endif
> +
> +/* Flags for ramzswap pages (table[page_no].flags) */
> +enum rzs_pageflags {
> + /* Page is stored uncompressed */
> + RZS_UNCOMPRESSED,
> +
> + /* Page consists entirely of zeros */
> + RZS_ZERO,
> +
> + __NR_RZS_PAGEFLAGS,
> +};
> +
> +/*-- Data structures */
> +
> +/*
> + * Allocated for each swap slot, indexed by page no.
> + * These table entries must fit exactly in a page.
> + */
> +struct table {
> + struct page *page;
> + u16 offset;
> + u8 count; /* object ref count (not yet used) */
> + u8 flags;
> +} __attribute__((aligned(4)));;
> +
> +/*
> + * Swap extent information in case backing swap is a regular
> + * file. These extent entries must fit exactly in a page.
> + */
> +struct ramzswap_backing_extent {
> + pgoff_t phy_pagenum;
> + pgoff_t num_pages;
> +} __attribute__((aligned(4)));
> +
> +struct ramzswap_stats {
> + /* basic stats */
> + size_t compr_size; /* compressed size of pages stored -
> + * needed to enforce memlimit */
> + /* more stats */
> +#if defined(CONFIG_RAMZSWAP_STATS)
> + u64 num_reads; /* failed + successful */
> + u64 num_writes; /* --do-- */
> + u64 failed_reads; /* can happen when memory is too low */
> + u64 failed_writes; /* should NEVER! happen */
> + u64 invalid_io; /* non-swap I/O requests */
> + u32 pages_zero; /* no. of zero filled pages */
> + u32 pages_stored; /* no. of pages currently stored */
> + u32 good_compress; /* % of pages with compression ratio<=50% */
> + u32 pages_expand; /* % of incompressible pages */
> + u64 bdev_num_reads; /* no. of reads on backing dev */
> + u64 bdev_num_writes; /* no. of writes on backing dev */
> +#endif
> +};
> +
> +struct ramzswap {
> + struct xv_pool *mem_pool;
> + void *compress_workmem;
> + void *compress_buffer;
> + struct table *table;
> + struct mutex lock;
> + struct request_queue *queue;
> + struct gendisk *disk;
> + int init_done;
> + /*
> + * This is limit on compressed data size (stats.compr_size)
> + * Its applicable only when backing swap device is present.
> + */
> + size_t memlimit; /* bytes */
> + /*
> + * This is limit on amount of *uncompressed* worth of data
> + * we can hold. When backing swap device is provided, it is
> + * set equal to device size.
> + */
> + size_t disksize; /* bytes */
> +
> + struct ramzswap_stats stats;
> +
> + /* backing swap device info */
> + struct ramzswap_backing_extent *curr_extent;
> + struct list_head backing_swap_extent_list;
> + unsigned long num_extents;
> + char backing_swap_name[MAX_SWAP_NAME_LEN];
> + struct block_device *backing_swap;
> + struct file *swap_file;
> +};
> +
> +/*-- */
> +
> +#endif
> +
> diff --git a/drivers/staging/ramzswap/ramzswap_ioctl.h b/drivers/staging/ramzswap/ramzswap_ioctl.h
> new file mode 100644
> index 0000000..c713a09
> --- /dev/null
> +++ b/drivers/staging/ramzswap/ramzswap_ioctl.h
> @@ -0,0 +1,49 @@
> +/*
> + * Compressed RAM based swap device
> + *
> + * Copyright (C) 2008, 2009 Nitin Gupta
> + *
> + * This code is released using a dual license strategy: BSD/GPL
> + * You can choose the licence that better fits your requirements.
> + *
> + * Released under the terms of 3-clause BSD License
> + * Released under the terms of GNU General Public License Version 2.0
> + *
> + * Project home: http://compcache.googlecode.com
> + */
> +
> +#ifndef _RAMZSWAP_IOCTL_H_
> +#define _RAMZSWAP_IOCTL_H_
> +
> +#define MAX_SWAP_NAME_LEN 128
> +
> +struct ramzswap_ioctl_stats {
> + char backing_swap_name[MAX_SWAP_NAME_LEN];
> + u64 memlimit; /* only applicable if backing swap present */
> + u64 disksize; /* user specified or equal to backing swap
> + * size (if present) */
> + u64 num_reads; /* failed + successful */
> + u64 num_writes; /* --do-- */
> + u64 failed_reads; /* can happen when memory is too low */
> + u64 failed_writes; /* should NEVER! happen */
> + u64 invalid_io; /* non-swap I/O requests */
> + u32 pages_zero; /* no. of zero filled pages */
> + u32 good_compress_pct; /* no. of pages with compression ratio<=50% */
> + u32 pages_expand_pct; /* no. of incompressible pages */
> + u32 pages_stored;
> + u32 pages_used;
> + u64 orig_data_size;
> + u64 compr_data_size;
> + u64 mem_used_total;
> + u64 bdev_num_reads; /* no. of reads on backing dev */
> + u64 bdev_num_writes; /* no. of writes on backing dev */
> +} __attribute__ ((packed, aligned(4)));
> +
> +#define RZSIO_SET_DISKSIZE_KB _IOW('z', 0, size_t)
> +#define RZSIO_SET_MEMLIMIT_KB _IOW('z', 1, size_t)
> +#define RZSIO_SET_BACKING_SWAP _IOW('z', 2, unsigned char[MAX_SWAP_NAME_LEN])
> +#define RZSIO_GET_STATS _IOR('z', 3, struct ramzswap_ioctl_stats)
> +#define RZSIO_INIT _IO('z', 4)
> +#define RZSIO_RESET _IO('z', 5)
> +
> +#endif
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to [email protected]
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
>
On 09/24/2009 10:41 AM, KAMEZAWA Hiroyuki wrote:
> On Tue, 22 Sep 2009 10:26:53 +0530
> Nitin Gupta <[email protected]> wrote:
>
> <snip>
>> + if (unlikely(clen > max_zpage_size)) {
>> + if (rzs->backing_swap) {
>> + mutex_unlock(&rzs->lock);
>> + fwd_write_request = 1;
>> + goto out;
>> + }
>> +
>> + clen = PAGE_SIZE;
>> + page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
> Here, and...
>
>> + if (unlikely(!page_store)) {
>> + mutex_unlock(&rzs->lock);
>> + pr_info("Error allocating memory for incompressible "
>> + "page: %u\n", index);
>> + stat_inc(rzs->stats.failed_writes);
>> + goto out;
>> + }
>> +
>> + offset = 0;
>> + rzs_set_flag(rzs, index, RZS_UNCOMPRESSED);
>> + stat_inc(rzs->stats.pages_expand);
>> + rzs->table[index].page = page_store;
>> + src = kmap_atomic(page, KM_USER0);
>> + goto memstore;
>> + }
>> +
>> + if (xv_malloc(rzs->mem_pool, clen + sizeof(*zheader),
>> + &rzs->table[index].page, &offset,
>> + GFP_NOIO | __GFP_HIGHMEM)) {
>
> Here.
>
> Do we need to wait until here for detecting page-allocation-failure ?
> Detecting it here means -EIO for end_swap_bio_write()....unhappy
> ALERT messages etc..
>
> Can't we add a hook to get_swap_page() for preparing this ("do we have
> enough pool?") and use only GFP_ATOMIC throughout codes ?
> (memory pool for this swap should be big to some extent.)
>
Yes, we do need to wait until this step for detecting alloc failure since
we don't really know when pool grow will (almost) surely wail.
What we can probably do is, hook into OOM notify chain (oom_notify_list)
and whenever we get this callback, we can start sending pages directly
to backing swap and do not even attempt to do any allocation.
>>From my user support experience for heavy swap customers, extra memory allocation for swapping out is just bad...in many cases.
> (*) I know GFP_IO works well to some extent.
>
We cannot use GFP_IO here as it can cause a deadlock:
ramzswap alloc() --> not enough memory, try to reclaim some --> swap out ...
... some pages to ramzswap --> ramzswap alloc()
Thanks,
Nitin
On Thu, 24 Sep 2009 22:24:50 +0530
Nitin Gupta <[email protected]> wrote:
>
> On 09/24/2009 10:41 AM, KAMEZAWA Hiroyuki wrote:
> > On Tue, 22 Sep 2009 10:26:53 +0530
> > Nitin Gupta <[email protected]> wrote:
> >
> > <snip>
> >> + if (unlikely(clen > max_zpage_size)) {
> >> + if (rzs->backing_swap) {
> >> + mutex_unlock(&rzs->lock);
> >> + fwd_write_request = 1;
> >> + goto out;
> >> + }
> >> +
> >> + clen = PAGE_SIZE;
> >> + page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
> > Here, and...
> >
> >> + if (unlikely(!page_store)) {
> >> + mutex_unlock(&rzs->lock);
> >> + pr_info("Error allocating memory for incompressible "
> >> + "page: %u\n", index);
> >> + stat_inc(rzs->stats.failed_writes);
> >> + goto out;
> >> + }
> >> +
> >> + offset = 0;
> >> + rzs_set_flag(rzs, index, RZS_UNCOMPRESSED);
> >> + stat_inc(rzs->stats.pages_expand);
> >> + rzs->table[index].page = page_store;
> >> + src = kmap_atomic(page, KM_USER0);
> >> + goto memstore;
> >> + }
> >> +
> >> + if (xv_malloc(rzs->mem_pool, clen + sizeof(*zheader),
> >> + &rzs->table[index].page, &offset,
> >> + GFP_NOIO | __GFP_HIGHMEM)) {
> >
> > Here.
> >
> > Do we need to wait until here for detecting page-allocation-failure ?
> > Detecting it here means -EIO for end_swap_bio_write()....unhappy
> > ALERT messages etc..
> >
> > Can't we add a hook to get_swap_page() for preparing this ("do we have
> > enough pool?") and use only GFP_ATOMIC throughout codes ?
> > (memory pool for this swap should be big to some extent.)
> >
>
> Yes, we do need to wait until this step for detecting alloc failure since
> we don't really know when pool grow will (almost) surely wail.
> What we can probably do is, hook into OOM notify chain (oom_notify_list)
> and whenever we get this callback, we can start sending pages directly
> to backing swap and do not even attempt to do any allocation.
>
>
Hmm...then, I never see -EIO ?
>
> >>From my user support experience for heavy swap customers, extra memory allocation for swapping out is just bad...in many cases.
> > (*) I know GFP_IO works well to some extent.
> >
>
> We cannot use GFP_IO here as it can cause a deadlock:
> ramzswap alloc() --> not enough memory, try to reclaim some --> swap out ...
> ... some pages to ramzswap --> ramzswap alloc()
>
Ah, sorry. just my mistake. I wanted to write GFP_NOIO.
Thanks,
-Kame
> Thanks,
> Nitin
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to [email protected]
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
>
On Tue, Sep 22, 2009 at 10:26:54AM +0530, Nitin Gupta wrote:
> Short guide on how to setup and use ramzswap.
Can you also send a patch that adds a drivers/staging/ramzswap/TODO file
that follows the format of the other drivers/staging/*/TODO file
describing what is needed to be done to get the code merged into the
main kernel tree?
thanks,
greg k-h
On Thu, Oct 08, 2009 at 03:57:24PM -0700, Greg KH wrote:
> On Tue, Sep 22, 2009 at 10:26:54AM +0530, Nitin Gupta wrote:
> > Short guide on how to setup and use ramzswap.
>
> Can you also send a patch that adds a drivers/staging/ramzswap/TODO file
> that follows the format of the other drivers/staging/*/TODO file
> describing what is needed to be done to get the code merged into the
> main kernel tree?
Doh, nevermind, you already did that.
stupid me...
greg k-h