[mirror_qemu.git] / include / sysemu / cryptodev.h

/*
 * QEMU Crypto Device Implementation
 *
 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
 *
 * Authors:
 *    Gonglei <arei.gonglei@huawei.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef CRYPTODEV_H
#define CRYPTODEV_H

#include "qom/object.h"

/**
 * CryptoDevBackend:
 *
 * The CryptoDevBackend object is an interface
 * for different cryptodev backends, which provides crypto
 * operation wrapper.
 *
 */

#define TYPE_CRYPTODEV_BACKEND "cryptodev-backend"

#define CRYPTODEV_BACKEND(obj) \
    OBJECT_CHECK(CryptoDevBackend, \
                 (obj), TYPE_CRYPTODEV_BACKEND)
#define CRYPTODEV_BACKEND_GET_CLASS(obj) \
    OBJECT_GET_CLASS(CryptoDevBackendClass, \
                 (obj), TYPE_CRYPTODEV_BACKEND)
#define CRYPTODEV_BACKEND_CLASS(klass) \
    OBJECT_CLASS_CHECK(CryptoDevBackendClass, \
                (klass), TYPE_CRYPTODEV_BACKEND)


#define MAX_CRYPTO_QUEUE_NUM  64

typedef struct CryptoDevBackendConf CryptoDevBackendConf;
typedef struct CryptoDevBackendPeers CryptoDevBackendPeers;
typedef struct CryptoDevBackendClient
                     CryptoDevBackendClient;
typedef struct CryptoDevBackend CryptoDevBackend;

enum CryptoDevBackendAlgType {
    CRYPTODEV_BACKEND_ALG_SYM,
    CRYPTODEV_BACKEND_ALG__MAX,
};

/**
 * CryptoDevBackendSymSessionInfo:
 *
 * @op_code: operation code (refer to virtio_crypto.h)
 * @cipher_alg: algorithm type of CIPHER
 * @key_len: byte length of cipher key
 * @hash_alg: algorithm type of HASH/MAC
 * @hash_result_len: byte length of HASH operation result
 * @auth_key_len: byte length of authenticated key
 * @add_len: byte length of additional authenticated data
 * @op_type: operation type (refer to virtio_crypto.h)
 * @direction: encryption or direction for CIPHER
 * @hash_mode: HASH mode for HASH operation (refer to virtio_crypto.h)
 * @alg_chain_order: order of algorithm chaining (CIPHER then HASH,
 *                   or HASH then CIPHER)
 * @cipher_key: point to a key of CIPHER
 * @auth_key: point to an authenticated key of MAC
 *
 */
typedef struct CryptoDevBackendSymSessionInfo {
    /* corresponding with virtio crypto spec */
    uint32_t op_code;
    uint32_t cipher_alg;
    uint32_t key_len;
    uint32_t hash_alg;
    uint32_t hash_result_len;
    uint32_t auth_key_len;
    uint32_t add_len;
    uint8_t op_type;
    uint8_t direction;
    uint8_t hash_mode;
    uint8_t alg_chain_order;
    uint8_t *cipher_key;
    uint8_t *auth_key;
} CryptoDevBackendSymSessionInfo;

/**
 * CryptoDevBackendSymOpInfo:
 *
 * @session_id: session index which was previously
 *              created by cryptodev_backend_sym_create_session()
 * @aad_len: byte length of additional authenticated data
 * @iv_len: byte length of initialization vector or counter
 * @src_len: byte length of source data
 * @dst_len: byte length of destination data
 * @digest_result_len: byte length of hash digest result
 * @hash_start_src_offset: Starting point for hash processing, specified
 *  as number of bytes from start of packet in source data, only used for
 *  algorithm chain
 * @cipher_start_src_offset: Starting point for cipher processing, specified
 *  as number of bytes from start of packet in source data, only used for
 *  algorithm chain
 * @len_to_hash: byte length of source data on which the hash
 *  operation will be computed, only used for algorithm chain
 * @len_to_cipher: byte length of source data on which the cipher
 *  operation will be computed, only used for algorithm chain
 * @op_type: operation type (refer to virtio_crypto.h)
 * @iv: point to the initialization vector or counter
 * @src: point to the source data
 * @dst: point to the destination data
 * @aad_data: point to the additional authenticated data
 * @digest_result: point to the digest result data
 * @data[0]: point to the extensional memory by one memory allocation
 *
 */
typedef struct CryptoDevBackendSymOpInfo {
    uint64_t session_id;
    uint32_t aad_len;
    uint32_t iv_len;
    uint32_t src_len;
    uint32_t dst_len;
    uint32_t digest_result_len;
    uint32_t hash_start_src_offset;
    uint32_t cipher_start_src_offset;
    uint32_t len_to_hash;
    uint32_t len_to_cipher;
    uint8_t op_type;
    uint8_t *iv;
    uint8_t *src;
    uint8_t *dst;
    uint8_t *aad_data;
    uint8_t *digest_result;
    uint8_t data[0];
} CryptoDevBackendSymOpInfo;

typedef struct CryptoDevBackendClass {
    ObjectClass parent_class;

    void (*init)(CryptoDevBackend *backend, Error **errp);
    void (*cleanup)(CryptoDevBackend *backend, Error **errp);

    int64_t (*create_session)(CryptoDevBackend *backend,
                       CryptoDevBackendSymSessionInfo *sess_info,
                       uint32_t queue_index, Error **errp);
    int (*close_session)(CryptoDevBackend *backend,
                           uint64_t session_id,
                           uint32_t queue_index, Error **errp);
    int (*do_sym_op)(CryptoDevBackend *backend,
                     CryptoDevBackendSymOpInfo *op_info,
                     uint32_t queue_index, Error **errp);
} CryptoDevBackendClass;

typedef enum CryptoDevBackendOptionsType {
    CRYPTODEV_BACKEND_TYPE_NONE = 0,
    CRYPTODEV_BACKEND_TYPE_BUILTIN = 1,
    CRYPTODEV_BACKEND_TYPE_VHOST_USER = 2,
    CRYPTODEV_BACKEND_TYPE__MAX,
} CryptoDevBackendOptionsType;

struct CryptoDevBackendClient {
    CryptoDevBackendOptionsType type;
    char *model;
    char *name;
    char *info_str;
    unsigned int queue_index;
    int vring_enable;
    QTAILQ_ENTRY(CryptoDevBackendClient) next;
};

struct CryptoDevBackendPeers {
    CryptoDevBackendClient *ccs[MAX_CRYPTO_QUEUE_NUM];
    uint32_t queues;
};

struct CryptoDevBackendConf {
    CryptoDevBackendPeers peers;

    /* Supported service mask */
    uint32_t crypto_services;

    /* Detailed algorithms mask */
    uint32_t cipher_algo_l;
    uint32_t cipher_algo_h;
    uint32_t hash_algo;
    uint32_t mac_algo_l;
    uint32_t mac_algo_h;
    uint32_t aead_algo;
    /* Maximum length of cipher key */
    uint32_t max_cipher_key_len;
    /* Maximum length of authenticated key */
    uint32_t max_auth_key_len;
    /* Maximum size of each crypto request's content */
    uint64_t max_size;
};

struct CryptoDevBackend {
    Object parent_obj;

    bool ready;
    /* Tag the cryptodev backend is used by virtio-crypto or not */
    bool is_used;
    CryptoDevBackendConf conf;
};

/**
 * cryptodev_backend_new_client:
 * @model: the cryptodev backend model
 * @name: the cryptodev backend name, can be NULL
 *
 * Creates a new cryptodev backend client object
 * with the @name in the model @model.
 *
 * The returned object must be released with
 * cryptodev_backend_free_client() when no
 * longer required
 *
 * Returns: a new cryptodev backend client object
 */
CryptoDevBackendClient *
cryptodev_backend_new_client(const char *model,
                                    const char *name);
/**
 * cryptodev_backend_free_client:
 * @cc: the cryptodev backend client object
 *
 * Release the memory associated with @cc that
 * was previously allocated by cryptodev_backend_new_client()
 */
void cryptodev_backend_free_client(
                  CryptoDevBackendClient *cc);

/**
 * cryptodev_backend_cleanup:
 * @backend: the cryptodev backend object
 * @errp: pointer to a NULL-initialized error object
 *
 * Clean the resouce associated with @backend that realizaed
 * by the specific backend's init() callback
 */
void cryptodev_backend_cleanup(
           CryptoDevBackend *backend,
           Error **errp);

/**
 * cryptodev_backend_sym_create_session:
 * @backend: the cryptodev backend object
 * @sess_info: parameters needed by session creating
 * @queue_index: queue index of cryptodev backend client
 * @errp: pointer to a NULL-initialized error object
 *
 * Create a session for symmetric algorithms
 *
 * Returns: session id on success, or -1 on error
 */
int64_t cryptodev_backend_sym_create_session(
           CryptoDevBackend *backend,
           CryptoDevBackendSymSessionInfo *sess_info,
           uint32_t queue_index, Error **errp);

/**
 * cryptodev_backend_sym_close_session:
 * @backend: the cryptodev backend object
 * @session_id: the session id
 * @queue_index: queue index of cryptodev backend client
 * @errp: pointer to a NULL-initialized error object
 *
 * Close a session for symmetric algorithms which was previously
 * created by cryptodev_backend_sym_create_session()
 *
 * Returns: 0 on success, or Negative on error
 */
int cryptodev_backend_sym_close_session(
           CryptoDevBackend *backend,
           uint64_t session_id,
           uint32_t queue_index, Error **errp);

/**
 * cryptodev_backend_crypto_operation:
 * @backend: the cryptodev backend object
 * @opaque: pointer to a VirtIOCryptoReq object
 * @queue_index: queue index of cryptodev backend client
 * @errp: pointer to a NULL-initialized error object
 *
 * Do crypto operation, such as encryption and
 * decryption
 *
 * Returns: VIRTIO_CRYPTO_OK on success,
 *         or -VIRTIO_CRYPTO_* on error
 */
int cryptodev_backend_crypto_operation(
                 CryptoDevBackend *backend,
                 void *opaque,
                 uint32_t queue_index, Error **errp);

/**
 * cryptodev_backend_set_used:
 * @backend: the cryptodev backend object
 * @used: ture or false
 *
 * Set the cryptodev backend is used by virtio-crypto or not
 */
void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used);

/**
 * cryptodev_backend_is_used:
 * @backend: the cryptodev backend object
 *
 * Return the status that the cryptodev backend is used
 * by virtio-crypto or not
 *
 * Returns: true on used, or false on not used
 */
bool cryptodev_backend_is_used(CryptoDevBackend *backend);

/**
 * cryptodev_backend_set_ready:
 * @backend: the cryptodev backend object
 * @ready: ture or false
 *
 * Set the cryptodev backend is ready or not, which is called
 * by the children of the cryptodev banckend interface.
 */
void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready);

/**
 * cryptodev_backend_is_ready:
 * @backend: the cryptodev backend object
 *
 * Return the status that the cryptodev backend is ready or not
 *
 * Returns: true on ready, or false on not ready
 */
bool cryptodev_backend_is_ready(CryptoDevBackend *backend);

#endif /* CRYPTODEV_H */
Commit	Line	Data
d0ee7a13 GA	1	/*
	2	* QEMU Crypto Device Implementation
	3	*
	4	* Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
	5	*
	6	* Authors:
	7	* Gonglei <arei.gonglei@huawei.com>
	8	*
	9	* This library is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU Lesser General Public
	11	* License as published by the Free Software Foundation; either
	12	* version 2 of the License, or (at your option) any later version.
	13	*
	14	* This library is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* Lesser General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU Lesser General Public
	20	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	21	*
	22	*/
	23	#ifndef CRYPTODEV_H
	24	#define CRYPTODEV_H
	25
	26	#include "qom/object.h"
d0ee7a13 GA	27
	28	/**
	29	* CryptoDevBackend:
	30	*
	31	* The CryptoDevBackend object is an interface
	32	* for different cryptodev backends, which provides crypto
	33	* operation wrapper.
	34	*
	35	*/
	36
	37	#define TYPE_CRYPTODEV_BACKEND "cryptodev-backend"
	38
	39	#define CRYPTODEV_BACKEND(obj) \
	40	OBJECT_CHECK(CryptoDevBackend, \
	41	(obj), TYPE_CRYPTODEV_BACKEND)
	42	#define CRYPTODEV_BACKEND_GET_CLASS(obj) \
	43	OBJECT_GET_CLASS(CryptoDevBackendClass, \
	44	(obj), TYPE_CRYPTODEV_BACKEND)
	45	#define CRYPTODEV_BACKEND_CLASS(klass) \
	46	OBJECT_CLASS_CHECK(CryptoDevBackendClass, \
	47	(klass), TYPE_CRYPTODEV_BACKEND)
	48
	49
	50	#define MAX_CRYPTO_QUEUE_NUM 64
	51
	52	typedef struct CryptoDevBackendConf CryptoDevBackendConf;
	53	typedef struct CryptoDevBackendPeers CryptoDevBackendPeers;
	54	typedef struct CryptoDevBackendClient
	55	CryptoDevBackendClient;
	56	typedef struct CryptoDevBackend CryptoDevBackend;
	57
9e4f86a8 GA	58	enum CryptoDevBackendAlgType {
	59	CRYPTODEV_BACKEND_ALG_SYM,
	60	CRYPTODEV_BACKEND_ALG__MAX,
	61	};
	62
	63	/**
	64	* CryptoDevBackendSymSessionInfo:
	65	*
	66	* @op_code: operation code (refer to virtio_crypto.h)
	67	* @cipher_alg: algorithm type of CIPHER
	68	* @key_len: byte length of cipher key
	69	* @hash_alg: algorithm type of HASH/MAC
	70	* @hash_result_len: byte length of HASH operation result
	71	* @auth_key_len: byte length of authenticated key
	72	* @add_len: byte length of additional authenticated data
	73	* @op_type: operation type (refer to virtio_crypto.h)
	74	* @direction: encryption or direction for CIPHER
	75	* @hash_mode: HASH mode for HASH operation (refer to virtio_crypto.h)
	76	* @alg_chain_order: order of algorithm chaining (CIPHER then HASH,
	77	* or HASH then CIPHER)
	78	* @cipher_key: point to a key of CIPHER
	79	* @auth_key: point to an authenticated key of MAC
	80	*
	81	*/
	82	typedef struct CryptoDevBackendSymSessionInfo {
	83	/* corresponding with virtio crypto spec */
	84	uint32_t op_code;
	85	uint32_t cipher_alg;
	86	uint32_t key_len;
	87	uint32_t hash_alg;
	88	uint32_t hash_result_len;
	89	uint32_t auth_key_len;
	90	uint32_t add_len;
	91	uint8_t op_type;
	92	uint8_t direction;
	93	uint8_t hash_mode;
	94	uint8_t alg_chain_order;
	95	uint8_t *cipher_key;
	96	uint8_t *auth_key;
	97	} CryptoDevBackendSymSessionInfo;
	98
	99	/**
	100	* CryptoDevBackendSymOpInfo:
	101	*
	102	* @session_id: session index which was previously
	103	* created by cryptodev_backend_sym_create_session()
	104	* @aad_len: byte length of additional authenticated data
	105	* @iv_len: byte length of initialization vector or counter
	106	* @src_len: byte length of source data
	107	* @dst_len: byte length of destination data
	108	* @digest_result_len: byte length of hash digest result
	109	* @hash_start_src_offset: Starting point for hash processing, specified
	110	* as number of bytes from start of packet in source data, only used for
	111	* algorithm chain
	112	* @cipher_start_src_offset: Starting point for cipher processing, specified
	113	* as number of bytes from start of packet in source data, only used for
	114	* algorithm chain
	115	* @len_to_hash: byte length of source data on which the hash
	116	* operation will be computed, only used for algorithm chain
	117	* @len_to_cipher: byte length of source data on which the cipher
	118	* operation will be computed, only used for algorithm chain
	119	* @op_type: operation type (refer to virtio_crypto.h)
	120	* @iv: point to the initialization vector or counter
	121	* @src: point to the source data
122	* @dst: point to the destination data
123	* @aad_data: point to the additional authenticated data
124	* @digest_result: point to the digest result data
125	* @data[0]: point to the extensional memory by one memory allocation
126	*
127	*/
128	typedef struct CryptoDevBackendSymOpInfo {
129	uint64_t session_id;
130	uint32_t aad_len;
131	uint32_t iv_len;
132	uint32_t src_len;
133	uint32_t dst_len;
134	uint32_t digest_result_len;
135	uint32_t hash_start_src_offset;
136	uint32_t cipher_start_src_offset;
137	uint32_t len_to_hash;
138	uint32_t len_to_cipher;
139	uint8_t op_type;
140	uint8_t *iv;
141	uint8_t *src;
142	uint8_t *dst;
143	uint8_t *aad_data;
144	uint8_t *digest_result;
145	uint8_t data[0];
146	} CryptoDevBackendSymOpInfo;
d0ee7a13 GA	147
	148	typedef struct CryptoDevBackendClass {
	149	ObjectClass parent_class;
	150
	151	void (init)(CryptoDevBackend backend, Error **errp);
	152	void (cleanup)(CryptoDevBackend backend, Error **errp);
9e4f86a8 GA	153
	154	int64_t (create_session)(CryptoDevBackend backend,
	155	CryptoDevBackendSymSessionInfo *sess_info,
	156	uint32_t queue_index, Error **errp);
	157	int (close_session)(CryptoDevBackend backend,
	158	uint64_t session_id,
	159	uint32_t queue_index, Error **errp);
	160	int (do_sym_op)(CryptoDevBackend backend,
	161	CryptoDevBackendSymOpInfo *op_info,
	162	uint32_t queue_index, Error **errp);
d0ee7a13 GA	163	} CryptoDevBackendClass;
d0ee7a13 GA	164
5da73dab GA	165	typedef enum CryptoDevBackendOptionsType {
	166	CRYPTODEV_BACKEND_TYPE_NONE = 0,
	167	CRYPTODEV_BACKEND_TYPE_BUILTIN = 1,
	168	CRYPTODEV_BACKEND_TYPE_VHOST_USER = 2,
	169	CRYPTODEV_BACKEND_TYPE__MAX,
	170	} CryptoDevBackendOptionsType;
d0ee7a13 GA	171
d0ee7a13 GA	172	struct CryptoDevBackendClient {
5da73dab	173	CryptoDevBackendOptionsType type;
d0ee7a13 GA	174	char *model;
	175	char *name;
	176	char *info_str;
	177	unsigned int queue_index;
5da73dab	178	int vring_enable;
d0ee7a13 GA	179	QTAILQ_ENTRY(CryptoDevBackendClient) next;
	180	};
	181
	182	struct CryptoDevBackendPeers {
	183	CryptoDevBackendClient *ccs[MAX_CRYPTO_QUEUE_NUM];
	184	uint32_t queues;
	185	};
	186
	187	struct CryptoDevBackendConf {
	188	CryptoDevBackendPeers peers;
	189
	190	/* Supported service mask */
	191	uint32_t crypto_services;
	192
	193	/* Detailed algorithms mask */
	194	uint32_t cipher_algo_l;
	195	uint32_t cipher_algo_h;
	196	uint32_t hash_algo;
	197	uint32_t mac_algo_l;
	198	uint32_t mac_algo_h;
	199	uint32_t aead_algo;
	200	/* Maximum length of cipher key */
	201	uint32_t max_cipher_key_len;
	202	/* Maximum length of authenticated key */
	203	uint32_t max_auth_key_len;
	204	/* Maximum size of each crypto request's content */
	205	uint64_t max_size;
	206	};
	207
	208	struct CryptoDevBackend {
	209	Object parent_obj;
	210
	211	bool ready;
46fd1705 GA	212	/* Tag the cryptodev backend is used by virtio-crypto or not */
46fd1705 GA	213	bool is_used;
d0ee7a13 GA	214	CryptoDevBackendConf conf;
	215	};
	216
	217	/**
	218	* cryptodev_backend_new_client:
	219	* @model: the cryptodev backend model
	220	* @name: the cryptodev backend name, can be NULL
	221	*
	222	* Creates a new cryptodev backend client object
	223	* with the @name in the model @model.
	224	*
	225	* The returned object must be released with
	226	* cryptodev_backend_free_client() when no
	227	* longer required
	228	*
	229	* Returns: a new cryptodev backend client object
	230	*/
	231	CryptoDevBackendClient *
	232	cryptodev_backend_new_client(const char *model,
	233	const char *name);
	234	/**
	235	* cryptodev_backend_free_client:
	236	* @cc: the cryptodev backend client object
	237	*
	238	* Release the memory associated with @cc that
	239	* was previously allocated by cryptodev_backend_new_client()
	240	*/
	241	void cryptodev_backend_free_client(
	242	CryptoDevBackendClient *cc);
	243
	244	/**
	245	* cryptodev_backend_cleanup:
	246	* @backend: the cryptodev backend object
	247	* @errp: pointer to a NULL-initialized error object
	248	*
	249	* Clean the resouce associated with @backend that realizaed
	250	* by the specific backend's init() callback
	251	*/
	252	void cryptodev_backend_cleanup(
	253	CryptoDevBackend *backend,
	254	Error **errp);
	255
9e4f86a8 GA	256	/**
	257	* cryptodev_backend_sym_create_session:
	258	* @backend: the cryptodev backend object
	259	* @sess_info: parameters needed by session creating
	260	* @queue_index: queue index of cryptodev backend client
	261	* @errp: pointer to a NULL-initialized error object
	262	*
	263	* Create a session for symmetric algorithms
	264	*
	265	* Returns: session id on success, or -1 on error
	266	*/
	267	int64_t cryptodev_backend_sym_create_session(
	268	CryptoDevBackend *backend,
	269	CryptoDevBackendSymSessionInfo *sess_info,
	270	uint32_t queue_index, Error **errp);
	271
	272	/**
	273	* cryptodev_backend_sym_close_session:
	274	* @backend: the cryptodev backend object
	275	* @session_id: the session id
	276	* @queue_index: queue index of cryptodev backend client
	277	* @errp: pointer to a NULL-initialized error object
	278	*
	279	* Close a session for symmetric algorithms which was previously
	280	* created by cryptodev_backend_sym_create_session()
	281	*
	282	* Returns: 0 on success, or Negative on error
	283	*/
	284	int cryptodev_backend_sym_close_session(
	285	CryptoDevBackend *backend,
	286	uint64_t session_id,
	287	uint32_t queue_index, Error **errp);
	288
	289	/**
d6634ac0	290	* cryptodev_backend_crypto_operation:
9e4f86a8	291	* @backend: the cryptodev backend object
d6634ac0	292	* @opaque: pointer to a VirtIOCryptoReq object
9e4f86a8 GA	293	* @queue_index: queue index of cryptodev backend client
	294	* @errp: pointer to a NULL-initialized error object
	295	*
d6634ac0	296	* Do crypto operation, such as encryption and
9e4f86a8 GA	297	* decryption
9e4f86a8 GA	298	*
d6634ac0 GA	299	* Returns: VIRTIO_CRYPTO_OK on success,
d6634ac0 GA	300	* or -VIRTIO_CRYPTO_* on error
9e4f86a8	301	*/
d6634ac0	302	int cryptodev_backend_crypto_operation(
9e4f86a8	303	CryptoDevBackend *backend,
d6634ac0	304	void *opaque,
9e4f86a8 GA	305	uint32_t queue_index, Error **errp);
9e4f86a8 GA	306
46fd1705 GA	307	/**
	308	* cryptodev_backend_set_used:
	309	* @backend: the cryptodev backend object
	310	* @used: ture or false
	311	*
	312	* Set the cryptodev backend is used by virtio-crypto or not
	313	*/
	314	void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used);
	315
	316	/**
	317	* cryptodev_backend_is_used:
	318	* @backend: the cryptodev backend object
	319	*
	320	* Return the status that the cryptodev backend is used
	321	* by virtio-crypto or not
	322	*
	323	* Returns: true on used, or false on not used
	324	*/
	325	bool cryptodev_backend_is_used(CryptoDevBackend *backend);
	326
6138dbda GA	327	/**
	328	* cryptodev_backend_set_ready:
	329	* @backend: the cryptodev backend object
	330	* @ready: ture or false
	331	*
	332	* Set the cryptodev backend is ready or not, which is called
	333	* by the children of the cryptodev banckend interface.
	334	*/
	335	void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready);
	336
	337	/**
	338	* cryptodev_backend_is_ready:
	339	* @backend: the cryptodev backend object
	340	*
	341	* Return the status that the cryptodev backend is ready or not
	342	*
	343	* Returns: true on ready, or false on not ready
	344	*/
	345	bool cryptodev_backend_is_ready(CryptoDevBackend *backend);
46fd1705	346
d0ee7a13	347	#endif /* CRYPTODEV_H */