@ -4,8 +4,6 @@
* SPDX - License - Identifier : GPL - 2.0 +
*/
# define DEBUG
# include <common.h>
# include <bootm.h>
# include <command.h>
@ -21,6 +19,9 @@
# include <lzma/LzmaTools.h>
# include <linux/lzo.h>
# include <test/compression.h>
# include <test/suites.h>
# include <test/ut.h>
static const char plain [ ] =
" I am a highly compressable bit of text. \n "
@ -120,10 +121,11 @@ static const unsigned long lz4_compressed_size = 276;
# define TEST_BUFFER_SIZE 512
typedef int ( * mutate_func ) ( void * , unsigned long , void * , unsigned long ,
unsigned long * ) ;
typedef int ( * mutate_func ) ( struct unit_test_state * uts , void * , unsigned long ,
void * , unsigned long , unsigned long * ) ;
static int compress_using_gzip ( void * in , unsigned long in_size ,
static int compress_using_gzip ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -137,7 +139,8 @@ static int compress_using_gzip(void *in, unsigned long in_size,
return ret ;
}
static int uncompress_using_gzip ( void * in , unsigned long in_size ,
static int uncompress_using_gzip ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -151,13 +154,14 @@ static int uncompress_using_gzip(void *in, unsigned long in_size,
return ret ;
}
static int compress_using_bzip2 ( void * in , unsigned long in_size ,
static int compress_using_bzip2 ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
/* There is no bzip2 compression in u-boot, so fake it. */
assert ( in_size = = strlen ( plain ) ) ;
assert ( memcmp ( plain , in , in_size ) = = 0 ) ;
ut_ asserteq ( in_size , strlen ( plain ) ) ;
ut_ asserteq ( 0 , memcmp ( plain , in , in_size ) ) ;
if ( bzip2_compressed_size > out_max )
return - 1 ;
@ -169,7 +173,8 @@ static int compress_using_bzip2(void *in, unsigned long in_size,
return 0 ;
}
static int uncompress_using_bzip2 ( void * in , unsigned long in_size ,
static int uncompress_using_bzip2 ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -184,13 +189,14 @@ static int uncompress_using_bzip2(void *in, unsigned long in_size,
return ( ret ! = BZ_OK ) ;
}
static int compress_using_lzma ( void * in , unsigned long in_size ,
static int compress_using_lzma ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
/* There is no lzma compression in u-boot, so fake it. */
assert ( in_size = = strlen ( plain ) ) ;
assert ( memcmp ( plain , in , in_size ) = = 0 ) ;
ut_ asserteq ( in_size , strlen ( plain ) ) ;
ut_ asserteq ( 0 , memcmp ( plain , in , in_size ) ) ;
if ( lzma_compressed_size > out_max )
return - 1 ;
@ -202,7 +208,8 @@ static int compress_using_lzma(void *in, unsigned long in_size,
return 0 ;
}
static int uncompress_using_lzma ( void * in , unsigned long in_size ,
static int uncompress_using_lzma ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -216,13 +223,14 @@ static int uncompress_using_lzma(void *in, unsigned long in_size,
return ( ret ! = SZ_OK ) ;
}
static int compress_using_lzo ( void * in , unsigned long in_size ,
static int compress_using_lzo ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
/* There is no lzo compression in u-boot, so fake it. */
assert ( in_size = = strlen ( plain ) ) ;
assert ( memcmp ( plain , in , in_size ) = = 0 ) ;
ut_ asserteq ( in_size , strlen ( plain ) ) ;
ut_ asserteq ( 0 , memcmp ( plain , in , in_size ) ) ;
if ( lzo_compressed_size > out_max )
return - 1 ;
@ -234,7 +242,8 @@ static int compress_using_lzo(void *in, unsigned long in_size,
return 0 ;
}
static int uncompress_using_lzo ( void * in , unsigned long in_size ,
static int uncompress_using_lzo ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -249,13 +258,14 @@ static int uncompress_using_lzo(void *in, unsigned long in_size,
return ( ret ! = LZO_E_OK ) ;
}
static int compress_using_lz4 ( void * in , unsigned long in_size ,
static int compress_using_lz4 ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
/* There is no lz4 compression in u-boot, so fake it. */
assert ( in_size = = strlen ( plain ) ) ;
assert ( memcmp ( plain , in , in_size ) = = 0 ) ;
ut_ asserteq ( in_size , strlen ( plain ) ) ;
ut_ asserteq ( 0 , memcmp ( plain , in , in_size ) ) ;
if ( lz4_compressed_size > out_max )
return - 1 ;
@ -267,7 +277,8 @@ static int compress_using_lz4(void *in, unsigned long in_size,
return 0 ;
}
static int uncompress_using_lz4 ( void * in , unsigned long in_size ,
static int uncompress_using_lz4 ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -298,7 +309,7 @@ struct buf_state {
void * compare_buf ;
} ;
static int run_test_internal ( char * name ,
static int run_test_internal ( struct unit_test_state * uts , char * name ,
mutate_func compress , mutate_func uncompress ,
struct buf_state * buf )
{
@ -307,8 +318,9 @@ static int run_test_internal(char *name,
/* Compress works as expected. */
printf ( " \t orig_size:%lu \n " , buf - > orig_size ) ;
memset ( buf - > compressed_buf , ' A ' , TEST_BUFFER_SIZE ) ;
errcheck ( compress ( buf - > orig_buf , buf - > orig_size , buf - > compressed_buf ,
buf - > compressed_size , & buf - > compressed_size ) = = 0 ) ;
errcheck ( compress ( uts , buf - > orig_buf , buf - > orig_size ,
buf - > compressed_buf , buf - > compressed_size ,
& buf - > compressed_size ) = = 0 ) ;
printf ( " \t compressed_size:%lu \n " , buf - > compressed_size ) ;
errcheck ( buf - > compressed_size > 0 ) ;
errcheck ( buf - > compressed_size < buf - > orig_size ) ;
@ -317,7 +329,7 @@ static int run_test_internal(char *name,
errcheck ( ( ( char * ) buf - > compressed_buf ) [ buf - > compressed_size ] = = ' A ' ) ;
/* Uncompresses with space remaining. */
errcheck ( uncompress ( buf - > compressed_buf , buf - > compressed_size ,
errcheck ( uncompress ( uts , buf - > compressed_buf , buf - > compressed_size ,
buf - > uncompressed_buf , buf - > uncompressed_size ,
& buf - > uncompressed_size ) = = 0 ) ;
printf ( " \t uncompressed_size:%lu \n " , buf - > uncompressed_size ) ;
@ -327,7 +339,7 @@ static int run_test_internal(char *name,
/* Uncompresses with exactly the right size output buffer. */
memset ( buf - > uncompressed_buf , ' A ' , TEST_BUFFER_SIZE ) ;
errcheck ( uncompress ( buf - > compressed_buf , buf - > compressed_size ,
errcheck ( uncompress ( uts , buf - > compressed_buf , buf - > compressed_size ,
buf - > uncompressed_buf , buf - > orig_size ,
& buf - > uncompressed_size ) = = 0 ) ;
errcheck ( buf - > uncompressed_size = = buf - > orig_size ) ;
@ -337,7 +349,7 @@ static int run_test_internal(char *name,
/* Make sure compression does not over-run. */
memset ( buf - > compare_buf , ' A ' , TEST_BUFFER_SIZE ) ;
ret = compress ( buf - > orig_buf , buf - > orig_size ,
ret = compress ( uts , buf - > orig_buf , buf - > orig_size ,
buf - > compare_buf , buf - > compressed_size - 1 ,
NULL ) ;
errcheck ( ( ( char * ) buf - > compare_buf ) [ buf - > compressed_size ] = = ' A ' ) ;
@ -346,7 +358,7 @@ static int run_test_internal(char *name,
/* Make sure decompression does not over-run. */
memset ( buf - > compare_buf , ' A ' , TEST_BUFFER_SIZE ) ;
ret = uncompress ( buf - > compressed_buf , buf - > compressed_size ,
ret = uncompress ( uts , buf - > compressed_buf , buf - > compressed_size ,
buf - > compare_buf , buf - > uncompressed_size - 1 ,
NULL ) ;
errcheck ( ( ( char * ) buf - > compare_buf ) [ buf - > uncompressed_size - 1 ] = = ' A ' ) ;
@ -360,7 +372,8 @@ out:
return ret ;
}
static int run_test ( char * name , mutate_func compress , mutate_func uncompress )
static int run_test ( struct unit_test_state * uts , char * name ,
mutate_func compress , mutate_func uncompress )
{
struct buf_state sbuf , * buf = & sbuf ;
int ret ;
@ -380,7 +393,7 @@ static int run_test(char *name, mutate_func compress, mutate_func uncompress)
buf - > compare_buf = malloc ( buf - > uncompressed_size ) ;
errcheck ( buf - > compare_buf ) ;
ret = run_test_internal ( name , compress , uncompress , buf ) ;
ret = run_test_internal ( uts , name , compress , uncompress , buf ) ;
out :
printf ( " %s: %s \n " , name , ret = = 0 ? " ok " : " FAILED " ) ;
@ -391,23 +404,41 @@ out:
return ret ;
}
static int do_ut_compression ( cmd_tbl_t * cmdtp , int flag , int argc ,
char * const argv [ ] )
static int compression_test_gzip ( struct unit_test_state * uts )
{
int err = 0 ;
return run_test ( uts , " gzip " , compress_using_gzip ,
uncompress_using_gzip ) ;
}
COMPRESSION_TEST ( compression_test_gzip , 0 ) ;
err + = run_test ( " gzip " , compress_using_gzip , uncompress_using_gzip ) ;
err + = run_test ( " bzip2 " , compress_using_bzip2 , uncompress_using_bzip2 ) ;
err + = run_test ( " lzma " , compress_using_lzma , uncompress_using_lzma ) ;
err + = run_test ( " lzo " , compress_using_lzo , uncompress_using_lzo ) ;
err + = run_test ( " lz4 " , compress_using_lz4 , uncompress_using_lz4 ) ;
static int compression_test_bzip2 ( struct unit_test_state * uts )
{
return run_test ( uts , " bzip2 " , compress_using_bzip2 ,
uncompress_using_bzip2 ) ;
}
COMPRESSION_TEST ( compression_test_bzip2 , 0 ) ;
static int compression_test_lzma ( struct unit_test_state * uts )
{
return run_test ( uts , " lzma " , compress_using_lzma ,
uncompress_using_lzma ) ;
}
COMPRESSION_TEST ( compression_test_lzma , 0 ) ;
printf ( " ut_compression %s \n " , err = = 0 ? " ok " : " FAILED " ) ;
static int compression_test_lzo ( struct unit_test_state * uts )
{
return run_test ( uts , " lzo " , compress_using_lzo , uncompress_using_lzo ) ;
}
COMPRESSION_TEST ( compression_test_lzo , 0 ) ;
return err ;
static int compression_test_lz4 ( struct unit_test_state * uts )
{
return run_test ( uts , " lz4 " , compress_using_lz4 , uncompress_using_lz4 ) ;
}
COMPRESSION_TEST ( compression_test_lz4 , 0 ) ;
static int compress_using_none ( void * in , unsigned long in_size ,
static int compress_using_none ( struct unit_test_state * uts ,
void * in , unsigned long in_size ,
void * out , unsigned long out_max ,
unsigned long * out_size )
{
@ -425,7 +456,8 @@ static int compress_using_none(void *in, unsigned long in_size,
* @ compress : Our function to compress data
* @ return 0 if OK , non - zero on failure
*/
static int run_bootm_test ( int comp_type , mutate_func compress )
static int run_bootm_test ( struct unit_test_state * uts , int comp_type ,
mutate_func compress )
{
ulong compress_size = 1024 ;
void * compress_buff ;
@ -438,20 +470,18 @@ static int run_bootm_test(int comp_type, mutate_func compress)
printf ( " Testing: %s \n " , genimg_get_comp_name ( comp_type ) ) ;
compress_buff = map_sysmem ( image_start , 0 ) ;
unc_len = strlen ( plain ) ;
compress ( ( void * ) plain , unc_len , compress_buff , compress_size ,
compress ( uts , ( void * ) plain , unc_len , compress_buff , compress_size ,
& compress_size ) ;
err = bootm_decomp_image ( comp_type , load_addr , image_start ,
IH_TYPE_KERNEL , map_sysmem ( load_addr , 0 ) ,
compress_buff , compress_size , unc_len ,
& load_end ) ;
if ( err )
return err ;
ut_assertok ( err ) ;
err = bootm_decomp_image ( comp_type , load_addr , image_start ,
IH_TYPE_KERNEL , map_sysmem ( load_addr , 0 ) ,
compress_buff , compress_size , unc_len - 1 ,
& load_end ) ;
if ( ! err )
return - EINVAL ;
ut_assert ( err ) ;
/* We can't detect corruption when not decompressing */
if ( comp_type = = IH_COMP_NONE )
@ -462,35 +492,52 @@ static int run_bootm_test(int comp_type, mutate_func compress)
IH_TYPE_KERNEL , map_sysmem ( load_addr , 0 ) ,
compress_buff , compress_size , 0x10000 ,
& load_end ) ;
if ( ! err )
return - EINVAL ;
ut_assert ( err ) ;
return 0 ;
}
static int do_ut_image_decomp ( cmd_tbl_t * cmdtp , int flag , int argc ,
char * const argv [ ] )
static int compression_test_bootm_gzip ( struct unit_test_state * uts )
{
int err = 0 ;
return run_bootm_test ( uts , IH_COMP_GZIP , compress_using_gzip ) ;
}
COMPRESSION_TEST ( compression_test_bootm_gzip , 0 ) ;
err = run_bootm_test ( IH_COMP_GZIP , compress_using_gzip ) ;
err | = run_bootm_test ( IH_COMP_BZIP2 , compress_using_bzip2 ) ;
err | = run_bootm_test ( IH_COMP_LZMA , compress_using_lzma ) ;
err | = run_bootm_test ( IH_COMP_LZO , compress_using_lzo ) ;
err | = run_bootm_test ( IH_COMP_LZ4 , compress_using_lz4 ) ;
err | = run_bootm_test ( IH_COMP_NONE , compress_using_none ) ;
static int compression_test_bootm_bzip2 ( struct unit_test_state * uts )
{
return run_bootm_test ( uts , IH_COMP_BZIP2 , compress_using_bzip2 ) ;
}
COMPRESSION_TEST ( compression_test_bootm_bzip2 , 0 ) ;
printf ( " ut_image_decomp %s \n " , err = = 0 ? " ok " : " FAILED " ) ;
static int compression_test_bootm_lzma ( struct unit_test_state * uts )
{
return run_bootm_test ( uts , IH_COMP_LZMA , compress_using_lzma ) ;
}
COMPRESSION_TEST ( compression_test_bootm_lzma , 0 ) ;
return 0 ;
static int compression_test_bootm_lzo ( struct unit_test_state * uts )
{
return run_bootm_test ( uts , IH_COMP_LZO , compress_using_lzo ) ;
}
COMPRESSION_TEST ( compression_test_bootm_lzo , 0 ) ;
U_BOOT_CMD (
ut_compression , 5 , 1 , do_ut_compression ,
" Basic test of compressors: gzip bzip2 lzma lzo " , " "
) ;
static int compression_test_bootm_lz4 ( struct unit_test_state * uts )
{
return run_bootm_test ( uts , IH_COMP_LZ4 , compress_using_lz4 ) ;
}
COMPRESSION_TEST ( compression_test_bootm_lz4 , 0 ) ;
U_BOOT_CMD (
ut_image_decomp , 5 , 1 , do_ut_image_decomp ,
" Basic test of bootm decompression " , " "
) ;
static int compression_test_bootm_none ( struct unit_test_state * uts )
{
return run_bootm_test ( uts , IH_COMP_NONE , compress_using_none ) ;
}
COMPRESSION_TEST ( compression_test_bootm_none , 0 ) ;
int do_ut_compression ( cmd_tbl_t * cmdtp , int flag , int argc , char * const argv [ ] )
{
struct unit_test * tests = ll_entry_start ( struct unit_test ,
compression_test ) ;
const int n_ents = ll_entry_count ( struct unit_test , compression_test ) ;
return cmd_ut_category ( " compression " , tests , n_ents , argc , argv ) ;
}