selftests/zram: Adding zram tests

TARGETS += user

TARGETS += vm

TARGETS += x86

TARGETS += zram

#Please keep the TARGETS list alphabetically sorted

# Run "make quicktest=1 run_tests" or

# "make quicktest=1 kselftest from top level Makefile

all:

TEST_PROGS := zram.sh

TEST_FILES := zram01.sh zram02.sh zram_lib.sh

include ../lib.mk

run_tests:

	@/bin/bash ./zram.sh

clean:

	$(RM) err.log

zram: Compressed RAM based block devices

----------------------------------------

* Introduction

The zram module creates RAM based block devices named /dev/zram<id>

(<id> = 0, 1, ...). Pages written to these disks are compressed and stored

in memory itself. These disks allow very fast I/O and compression provides

good amounts of memory savings. Some of the usecases include /tmp storage,

use as swap disks, various caches under /var and maybe many more :)

Statistics for individual zram devices are exported through sysfs nodes at

/sys/block/zram<id>/

Kconfig required:

CONFIG_ZRAM=y

CONFIG_ZRAM_LZ4_COMPRESS=y

CONFIG_ZPOOL=y

CONFIG_ZSMALLOC=y

ZRAM Testcases

--------------

zram_lib.sh: create library with initialization/cleanup functions

zram.sh: For sanity check of CONFIG_ZRAM and to run zram01 and zram02

Two functional tests: zram01 and zram02:

zram01.sh: creates general purpose ram disks with ext4 filesystems

zram02.sh: creates block device for swap

Commands required for testing:

 - bc

 - dd

 - free

 - awk

 - mkswap

 - swapon

 - swapoff

 - mkfs/ mkfs.ext4

For more information please refer:

kernel-source-tree/Documentation/blockdev/zram.txt

#!/bin/bash

TCID="zram.sh"

run_zram () {

echo "--------------------"

echo "running zram tests"

echo "--------------------"

./zram01.sh

echo ""

./zram02.sh

}

# check zram module exists

MODULE_PATH=/lib/modules/`uname -r`/kernel/drivers/block/zram/zram.ko

if [ -f $MODULE_PATH ]; then

	run_zram

elif [ -b /dev/zram0 ]; then

	run_zram

else

	echo "$TCID : No zram.ko module or /dev/zram0 device file not found"

	echo "$TCID : CONFIG_ZRAM is not set"

	exit 1

fi

#!/bin/bash

# Copyright (c) 2015 Oracle and/or its affiliates. All Rights Reserved.

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License as

# published by the Free Software Foundation; either version 2 of

# the License, or (at your option) any later version.

#

# This program is distributed in the hope that it would be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the

# GNU General Public License for more details.

#

# Test creates several zram devices with different filesystems on them.

# It fills each device with zeros and checks that compression works.

#

# Author: Alexey Kodanev <alexey.kodanev@oracle.com>

# Modified: Naresh Kamboju <naresh.kamboju@linaro.org>

TCID="zram01"

ERR_CODE=0

. ./zram_lib.sh

# Test will create the following number of zram devices:

dev_num=1

# This is a list of parameters for zram devices.

# Number of items must be equal to 'dev_num' parameter.

zram_max_streams="2"

# The zram sysfs node 'disksize' value can be either in bytes,

# or you can use mem suffixes. But in some old kernels, mem

# suffixes are not supported, for example, in RHEL6.6GA's kernel

# layer, it uses strict_strtoull() to parse disksize which does

# not support mem suffixes, in some newer kernels, they use

# memparse() which supports mem suffixes. So here we just use

# bytes to make sure everything works correctly.

zram_sizes="2097152" # 2MB

zram_mem_limits="2M"

zram_filesystems="ext4"

zram_algs="lzo"

zram_fill_fs()

{

	local mem_free0=$(free -m | awk 'NR==2 {print $4}')

	for i in $(seq 0 $(($dev_num - 1))); do

		echo "fill zram$i..."

		local b=0

		while [ true ]; do

			dd conv=notrunc if=/dev/zero of=zram${i}/file \

				oflag=append count=1 bs=1024 status=none \

				> /dev/null 2>&1 || break

			b=$(($b + 1))

		done

		echo "zram$i can be filled with '$b' KB"

	done

	local mem_free1=$(free -m | awk 'NR==2 {print $4}')

	local used_mem=$(($mem_free0 - $mem_free1))

	local total_size=0

	for sm in $zram_sizes; do

		local s=$(echo $sm | sed 's/M//')

		total_size=$(($total_size + $s))

	done

	echo "zram used ${used_mem}M, zram disk sizes ${total_size}M"

	local v=$((100 * $total_size / $used_mem))

	if [ "$v" -lt 100 ]; then

		echo "FAIL compression ratio: 0.$v:1"

		ERR_CODE=-1

		zram_cleanup

		return

	fi

	echo "zram compression ratio: $(echo "scale=2; $v / 100 " | bc):1: OK"

}

zram_load

zram_max_streams

zram_compress_alg

zram_set_disksizes

zram_set_memlimit

zram_makefs

zram_mount

zram_fill_fs

zram_cleanup

zram_unload

if [ $ERR_CODE -ne 0 ]; then

	echo "$TCID : [FAIL]"

else

	echo "$TCID : [PASS]"

fi