2019-05-27 09:55:01 +03:00
// SPDX-License-Identifier: GPL-2.0-or-later
2016-10-21 15:19:47 +03:00
/*
* Asynchronous Compression operations
*
* Copyright ( c ) 2016 , Intel Corporation
* Authors : Weigang Li < weigang . li @ intel . com >
* Giovanni Cabiddu < giovanni . cabiddu @ intel . com >
*/
2023-02-16 13:35:17 +03:00
# include <crypto/internal/acompress.h>
# include <linux/cryptouser.h>
2016-10-21 15:19:47 +03:00
# include <linux/errno.h>
# include <linux/kernel.h>
# include <linux/module.h>
# include <linux/seq_file.h>
# include <linux/slab.h>
# include <linux/string.h>
# include <net/netlink.h>
2023-02-16 13:35:17 +03:00
# include "compress.h"
struct crypto_scomp ;
2016-10-21 15:19:47 +03:00
2016-10-21 15:19:48 +03:00
static const struct crypto_type crypto_acomp_type ;
2023-02-16 13:35:17 +03:00
static inline struct acomp_alg * __crypto_acomp_alg ( struct crypto_alg * alg )
{
return container_of ( alg , struct acomp_alg , calg . base ) ;
}
static inline struct acomp_alg * crypto_acomp_alg ( struct crypto_acomp * tfm )
{
return __crypto_acomp_alg ( crypto_acomp_tfm ( tfm ) - > __crt_alg ) ;
}
2023-02-16 13:35:28 +03:00
static int __maybe_unused crypto_acomp_report (
struct sk_buff * skb , struct crypto_alg * alg )
2016-10-21 15:19:47 +03:00
{
struct crypto_report_acomp racomp ;
2018-11-04 00:56:03 +03:00
memset ( & racomp , 0 , sizeof ( racomp ) ) ;
2016-10-21 15:19:47 +03:00
2018-11-04 00:56:03 +03:00
strscpy ( racomp . type , " acomp " , sizeof ( racomp . type ) ) ;
2016-10-21 15:19:47 +03:00
2018-11-04 00:56:03 +03:00
return nla_put ( skb , CRYPTOCFGA_REPORT_ACOMP , sizeof ( racomp ) , & racomp ) ;
2016-10-21 15:19:47 +03:00
}
static void crypto_acomp_show ( struct seq_file * m , struct crypto_alg * alg )
2016-12-31 18:56:23 +03:00
__maybe_unused ;
2016-10-21 15:19:47 +03:00
static void crypto_acomp_show ( struct seq_file * m , struct crypto_alg * alg )
{
seq_puts ( m , " type : acomp \n " ) ;
}
static void crypto_acomp_exit_tfm ( struct crypto_tfm * tfm )
{
struct crypto_acomp * acomp = __crypto_acomp_tfm ( tfm ) ;
struct acomp_alg * alg = crypto_acomp_alg ( acomp ) ;
alg - > exit ( acomp ) ;
}
static int crypto_acomp_init_tfm ( struct crypto_tfm * tfm )
{
struct crypto_acomp * acomp = __crypto_acomp_tfm ( tfm ) ;
struct acomp_alg * alg = crypto_acomp_alg ( acomp ) ;
2016-10-21 15:19:48 +03:00
if ( tfm - > __crt_alg - > cra_type ! = & crypto_acomp_type )
return crypto_init_scomp_ops_async ( tfm ) ;
acomp - > compress = alg - > compress ;
acomp - > decompress = alg - > decompress ;
acomp - > dst_free = alg - > dst_free ;
acomp - > reqsize = alg - > reqsize ;
2016-10-21 15:19:47 +03:00
if ( alg - > exit )
acomp - > base . exit = crypto_acomp_exit_tfm ;
if ( alg - > init )
return alg - > init ( acomp ) ;
return 0 ;
}
2016-10-21 15:19:48 +03:00
static unsigned int crypto_acomp_extsize ( struct crypto_alg * alg )
{
int extsize = crypto_alg_extsize ( alg ) ;
if ( alg - > cra_type ! = & crypto_acomp_type )
extsize + = sizeof ( struct crypto_scomp * ) ;
return extsize ;
}
2016-10-21 15:19:47 +03:00
static const struct crypto_type crypto_acomp_type = {
2016-10-21 15:19:48 +03:00
. extsize = crypto_acomp_extsize ,
2016-10-21 15:19:47 +03:00
. init_tfm = crypto_acomp_init_tfm ,
# ifdef CONFIG_PROC_FS
. show = crypto_acomp_show ,
# endif
2023-05-02 11:02:33 +03:00
# if IS_ENABLED(CONFIG_CRYPTO_USER)
2016-10-21 15:19:47 +03:00
. report = crypto_acomp_report ,
2023-02-16 13:35:17 +03:00
# endif
2016-10-21 15:19:47 +03:00
. maskclear = ~ CRYPTO_ALG_TYPE_MASK ,
2016-10-21 15:19:48 +03:00
. maskset = CRYPTO_ALG_TYPE_ACOMPRESS_MASK ,
2016-10-21 15:19:47 +03:00
. type = CRYPTO_ALG_TYPE_ACOMPRESS ,
. tfmsize = offsetof ( struct crypto_acomp , base ) ,
} ;
struct crypto_acomp * crypto_alloc_acomp ( const char * alg_name , u32 type ,
u32 mask )
{
return crypto_alloc_tfm ( alg_name , & crypto_acomp_type , type , mask ) ;
}
EXPORT_SYMBOL_GPL ( crypto_alloc_acomp ) ;
2020-07-05 12:18:58 +03:00
struct crypto_acomp * crypto_alloc_acomp_node ( const char * alg_name , u32 type ,
u32 mask , int node )
{
return crypto_alloc_tfm_node ( alg_name , & crypto_acomp_type , type , mask ,
node ) ;
}
EXPORT_SYMBOL_GPL ( crypto_alloc_acomp_node ) ;
2016-10-21 15:19:48 +03:00
struct acomp_req * acomp_request_alloc ( struct crypto_acomp * acomp )
{
struct crypto_tfm * tfm = crypto_acomp_tfm ( acomp ) ;
struct acomp_req * req ;
req = __acomp_request_alloc ( acomp ) ;
if ( req & & ( tfm - > __crt_alg - > cra_type ! = & crypto_acomp_type ) )
return crypto_acomp_scomp_alloc_ctx ( req ) ;
return req ;
}
EXPORT_SYMBOL_GPL ( acomp_request_alloc ) ;
void acomp_request_free ( struct acomp_req * req )
{
struct crypto_acomp * acomp = crypto_acomp_reqtfm ( req ) ;
struct crypto_tfm * tfm = crypto_acomp_tfm ( acomp ) ;
if ( tfm - > __crt_alg - > cra_type ! = & crypto_acomp_type )
crypto_acomp_scomp_free_ctx ( req ) ;
if ( req - > flags & CRYPTO_ACOMP_ALLOC_OUTPUT ) {
acomp - > dst_free ( req - > dst ) ;
req - > dst = NULL ;
}
__acomp_request_free ( req ) ;
}
EXPORT_SYMBOL_GPL ( acomp_request_free ) ;
2023-02-16 13:35:17 +03:00
void comp_prepare_alg ( struct comp_alg_common * alg )
2016-10-21 15:19:47 +03:00
{
struct crypto_alg * base = & alg - > base ;
base - > cra_flags & = ~ CRYPTO_ALG_TYPE_MASK ;
2023-02-16 13:35:17 +03:00
}
int crypto_register_acomp ( struct acomp_alg * alg )
{
struct crypto_alg * base = & alg - > calg . base ;
comp_prepare_alg ( & alg - > calg ) ;
base - > cra_type = & crypto_acomp_type ;
2016-10-21 15:19:47 +03:00
base - > cra_flags | = CRYPTO_ALG_TYPE_ACOMPRESS ;
return crypto_register_alg ( base ) ;
}
EXPORT_SYMBOL_GPL ( crypto_register_acomp ) ;
2019-12-16 02:51:19 +03:00
void crypto_unregister_acomp ( struct acomp_alg * alg )
2016-10-21 15:19:47 +03:00
{
2019-12-16 02:51:19 +03:00
crypto_unregister_alg ( & alg - > base ) ;
2016-10-21 15:19:47 +03:00
}
EXPORT_SYMBOL_GPL ( crypto_unregister_acomp ) ;
2017-04-19 16:23:05 +03:00
int crypto_register_acomps ( struct acomp_alg * algs , int count )
{
int i , ret ;
for ( i = 0 ; i < count ; i + + ) {
ret = crypto_register_acomp ( & algs [ i ] ) ;
if ( ret )
goto err ;
}
return 0 ;
err :
for ( - - i ; i > = 0 ; - - i )
crypto_unregister_acomp ( & algs [ i ] ) ;
return ret ;
}
EXPORT_SYMBOL_GPL ( crypto_register_acomps ) ;
void crypto_unregister_acomps ( struct acomp_alg * algs , int count )
{
int i ;
for ( i = count - 1 ; i > = 0 ; - - i )
crypto_unregister_acomp ( & algs [ i ] ) ;
}
EXPORT_SYMBOL_GPL ( crypto_unregister_acomps ) ;
2016-10-21 15:19:47 +03:00
MODULE_LICENSE ( " GPL " ) ;
MODULE_DESCRIPTION ( " Asynchronous compression type " ) ;