block/blk-crypt.c - LeafOS-Devices/android_kernel_samsung_gta4xl - Gitiles

 /*
  * Copyright (C) 2018 Samsung Electronics Co., Ltd.
  *
  * 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.
  *
  * Functions related to blk-crypt(for inline encryption) handling
  *
  * NOTE :
  * blk-crypt implementation not depends on a inline encryption hardware.
  *
  * TODO :
  * We need to agonize what lock we use between spin_lock_irq and spin_lock
  * for algorithm_manager.
  */

 #include <linux/module.h>
 #include <linux/blkdev.h>
 #include <crypto/skcipher.h>

 #define BLK_CRYPT_ALG_NAMELEN_MAX	(15)
 #define BLK_CRYPT_VERSION		"1.0.0"
 #define BLK_CRYPT_MODE_PRIVATE		(127)

 struct blk_crypt_algorithm {
 	struct list_head list;
 	atomic_t ref;
 	unsigned int mode;
 	struct block_device *bdev;
 	char name[BLK_CRYPT_ALG_NAMELEN_MAX+1];
 	const struct blk_crypt_algorithm_cbs *hw_cbs;
 };

 struct blk_crypt_context {
 	struct blk_crypt_algorithm *bc_alg;
 	void *bc_private;
 };

 struct blk_crypt_algorithm_manager {
 	struct list_head list;
 	spinlock_t lock;
 	atomic_t ref;
 	struct blk_crypt_algorithm *last_acc;
 };

 /* Initialize algorithm manager */
 static struct blk_crypt_algorithm_manager alg_manager = {
 	.list = LIST_HEAD_INIT(alg_manager.list),
 	.lock = __SPIN_LOCK_UNLOCKED(alg_manager.lock),
 	.ref = ATOMIC_INIT(0),
 	.last_acc = NULL,
 };

 static struct kmem_cache *blk_crypt_cachep = NULL;

 /* Static functions */
 /**
  * blk_crypt_alloc_context() - allocate blk_crypt_context structure
  * @mode: filesystem encryption mode.
  *
  * Find hardware algorithm matched with specified mode and
  * calling the hw callback function to allocate crypt_info structure.
  *
  * Return: Allocated blk_crypt_context if succeed to find algorithm mode,
  * -ENOKEY otherwise.
  */
 static blk_crypt_t *blk_crypt_alloc_context(struct block_device *bdev, const char *cipher_str)
 {
 	struct blk_crypt_algorithm *alg;
 	struct blk_crypt_context *bctx;
 	int res = -ENOENT;

 	spin_lock_irq(&alg_manager.lock);
 	if (alg_manager.last_acc && !strcmp(alg_manager.last_acc->name, cipher_str)) {
 		alg = alg_manager.last_acc;
 		atomic_inc(&alg->ref);
 		goto unlock;
 	}

 	list_for_each_entry(alg, &alg_manager.list, list) {
 		if (strcmp(alg->name, cipher_str)) {
 			pr_info("blk-crypt: no matched alg(%s) != requested alg(%s)\n",
 				alg->name, cipher_str);
 			continue;
 		}

 		if (alg->bdev && alg->bdev != bdev) {
 			pr_info("blk-crypt: no matched alg(%s)->bdev != bdev\n",
 				cipher_str);
 			continue;
 		}

 		alg_manager.last_acc = alg;
 		atomic_inc(&alg->ref);
 		break;
 	}
 unlock:
 	spin_unlock_irq(&alg_manager.lock);

 	if (alg == (void *)&alg_manager.list)
 		return ERR_PTR(-ENOENT);

 	bctx = kmem_cache_zalloc(blk_crypt_cachep, GFP_NOFS);
 	if (!bctx) {
 		res = -ENOMEM;
 		goto err_free;
 	}

 	bctx->bc_alg = alg;
 	bctx->bc_private = alg->hw_cbs->alloc();
 	if (IS_ERR(bctx->bc_private)) {
 		res = PTR_ERR(bctx->bc_private);
 		pr_err("blk-crypt: failed to alloc data for alg(%s), err:%d\n",
 				alg->name, res);
 		goto err_free;
 	}

 	return bctx;
 err_free:
 	atomic_dec(&alg->ref);
 	if (bctx)
 		kmem_cache_free(blk_crypt_cachep, bctx);
 	return ERR_PTR(res);
 }


 static inline blk_crypt_t *__bio_crypt(const struct bio *bio)
 {
 	if (bio && (bio->bi_opf & REQ_CRYPT))
 		return bio->bi_cryptd;

 	return NULL;
 }

 bool blk_crypt_encrypted(const struct bio *bio)
 {
 	return __bio_crypt(bio) ? true : false;
 }

 bool blk_crypt_mergeable(const struct bio *a, const struct bio *b)
 {
 #ifdef CONFIG_BLK_DEV_CRYPT
 	if (__bio_crypt(a) != __bio_crypt(b))
 		return false;

 #ifdef CONFIG_BLK_DEV_CRYPT_DUN
 	if (__bio_crypt(a)) {
 		if (!bio_dun(a) ^ !bio_dun(b))
 			return false;
 		if (bio_dun(a) && bio_end_dun(a) != bio_dun(b))
 			return false;
 	}
 #endif
 #endif
 	return true;
 }

 /* Filesystem APIs */
 blk_crypt_t *blk_crypt_get_context(struct block_device *bdev, const char *cipher_str)
 {
 	struct blk_crypt_t *bctx;
 	bctx = blk_crypt_alloc_context(bdev, cipher_str);
 	if (IS_ERR(bctx)) {
 		pr_debug("error allocating diskciher '%s' err: %d",
 			cipher_str, PTR_ERR(bctx));
 		return bctx;
 	}

 	return bctx;
 }

 unsigned char *blk_crypt_get_key(blk_crypt_t *bc_ctx)
 {
 	struct blk_crypt_context *bctx = bc_ctx;

 	if (!bctx)
 		return ERR_PTR(-EINVAL);

 	return bctx->bc_alg->hw_cbs->get_key(bctx->bc_private);
 }

 int blk_crypt_set_key(blk_crypt_t *bc_ctx, u8 *raw_key, u32 keysize, void *priv)
 {
 	struct blk_crypt_context *bctx = bc_ctx;

 	if (!bctx)
 		return -EINVAL;

 	return bctx->bc_alg->hw_cbs->set_key(bctx->bc_private, raw_key, keysize, priv);
 }

 void *blk_crypt_get_data(blk_crypt_t *bc_ctx)
 {
 	struct blk_crypt_context *bctx = bc_ctx;
 	return bctx->bc_private;
 }

 void blk_crypt_put_context(blk_crypt_t *bc_ctx)
 {
 	struct blk_crypt_context *bctx = bc_ctx;

 	if (!bctx)
 		return;

 	bctx->bc_alg->hw_cbs->free(bctx->bc_private);
 	atomic_dec(&(bctx->bc_alg->ref));
 	kmem_cache_free(blk_crypt_cachep, bctx);
 }

 /* H/W algorithm APIs */
 static int blk_crypt_initialize()
 {
 	if (likely(blk_crypt_cachep))
 		return 0;

 	blk_crypt_cachep = KMEM_CACHE(blk_crypt_context, SLAB_RECLAIM_ACCOUNT);
 	if (!blk_crypt_cachep)
 		return -ENOMEM;

 	return 0;
 }

 /**
  * blk_crypt_alg_register() - register a hw algorithm in algorithm manager
  * @name: name of algorithm
  * @mode: filesystem encryption mode
  * @hw_cbs: hardware callback functions
  *
  * A mode and name must be unique value so that these values are used to
  * differentiate each algorithm. If the algorithm manager finds duplicated
  * mode or name in algorithm list, it considers that as existing algorithm.
  *
  * Return: hw algorithm pointer on success,
  * -EEXIST if already registered.
  */
 void *blk_crypt_alg_register(struct block_device *bdev, const char *name,
 	const unsigned int mode, const struct blk_crypt_algorithm_cbs *hw_cbs)
 {
 	struct blk_crypt_algorithm *hw_alg, *new_alg;

 	if (unlikely(blk_crypt_initialize())) {
 		pr_err("blk-crypt: failed to initialize\n");
 		return ERR_PTR(-ENOMEM);
 	}

 	if (!name || strlen(name) > BLK_CRYPT_ALG_NAMELEN_MAX) {
 		pr_err("blk-crypt: invalid algorithm name or namelen\n");
 		return ERR_PTR(-EINVAL);
 	}

 	/* Allocate new dhe_algorithm */
 	new_alg = kzalloc(sizeof(struct blk_crypt_algorithm), GFP_KERNEL);
 	if (!new_alg)
 		return ERR_PTR(-ENOMEM);

 	/* Initialize new hw_algorithm */
 	strncpy(new_alg->name, name, BLK_CRYPT_ALG_NAMELEN_MAX);
 	new_alg->bdev = bdev;
 	new_alg->mode = mode;
 	new_alg->hw_cbs = hw_cbs;
 	INIT_LIST_HEAD(&new_alg->list);

 	/* Check the existence of same thing. */
 	spin_lock_irq(&alg_manager.lock);
 	list_for_each_entry(hw_alg, &alg_manager.list, list) {
 		/* an algorithm can be allocated for multiple devices */
 		if (hw_alg->bdev && bdev && (hw_alg->bdev != bdev))
 			continue;
 		if (hw_alg->mode == mode)
 			break;
 		if (!strcmp(hw_alg->name, name))
 			break;
 	}

 	/* Already exist, can not register new one */
 	if (&alg_manager.list != &hw_alg->list) {
 		spin_unlock_irq(&alg_manager.lock);
 		pr_err("blk-crypt: algorithm(%s) already exists\n", name);
 		kfree(new_alg);
 		return ERR_PTR(-EEXIST);
 	}

 	/* Add to algorithm manager */
 	list_add(&new_alg->list, &alg_manager.list);
 	spin_unlock_irq(&alg_manager.lock);
 	pr_info("blk_crypt: registed algorithm(%s)\n", name);

 	return new_alg;
 }
 EXPORT_SYMBOL(blk_crypt_alg_register);

 /**
  * blk_crypt_alg_unregister() - unregister hw algorithm from the algorithm manager
  * @handle: The pointer of hw algorithm that returned by blk_crypt_alg_register().
  *
  * Free and unregister specified handle if there is no ref count.
  */
 int blk_crypt_alg_unregister(void *handle)
 {
 	struct blk_crypt_algorithm *alg;

 	if (!handle)
 		return -EINVAL;

 	alg = (struct blk_crypt_algorithm *)handle;

 	/* prevent unregister if an algorithm is  being referenced */
 	if (atomic_read(&alg->ref))
 		return -EBUSY;

 	/* just unlink this algorithm from the manager */
 	spin_lock_irq(&alg_manager.lock);
 	list_del_init(&alg->list);
 	spin_unlock_irq(&alg_manager.lock);

 	kfree(handle);
 	return 0;
 }
 EXPORT_SYMBOL(blk_crypt_alg_unregister);

 /* Blk-crypt core functions */
 static int __init blk_crypt_init(void)
 {
 	pr_info("%s\n", __func__);
 	blk_crypt_initialize();
 	return 0;
 }

 static void __exit blk_crypt_exit(void)
 {
 	pr_info("%s\n", __func__);
 	if (atomic_read(&alg_manager.ref)) {
 		pr_warn("blk-crypt: remailed %d registered algorithm\n",
 				atomic_read(&alg_manager.ref));
 	}

 	kmem_cache_destroy(blk_crypt_cachep);
 	blk_crypt_cachep = NULL;
 }

 module_init(blk_crypt_init);
 module_exit(blk_crypt_exit);
	/*
	* Copyright (C) 2018 Samsung Electronics Co., Ltd.
	*
	* 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.
	*
	* Functions related to blk-crypt(for inline encryption) handling
	*
	* NOTE :
	* blk-crypt implementation not depends on a inline encryption hardware.
	*
	* TODO :
	* We need to agonize what lock we use between spin_lock_irq and spin_lock
	* for algorithm_manager.
	*/

	#include <linux/module.h>
	#include <linux/blkdev.h>
	#include <crypto/skcipher.h>

	#define BLK_CRYPT_ALG_NAMELEN_MAX (15)
	#define BLK_CRYPT_VERSION "1.0.0"
	#define BLK_CRYPT_MODE_PRIVATE (127)

	struct blk_crypt_algorithm {
	struct list_head list;
	atomic_t ref;
	unsigned int mode;
	struct block_device *bdev;
	char name[BLK_CRYPT_ALG_NAMELEN_MAX+1];
	const struct blk_crypt_algorithm_cbs *hw_cbs;
	};

	struct blk_crypt_context {
	struct blk_crypt_algorithm *bc_alg;
	void *bc_private;
	};

	struct blk_crypt_algorithm_manager {
	struct list_head list;
	spinlock_t lock;
	atomic_t ref;
	struct blk_crypt_algorithm *last_acc;
	};

	/* Initialize algorithm manager */
	static struct blk_crypt_algorithm_manager alg_manager = {
	.list = LIST_HEAD_INIT(alg_manager.list),
	.lock = __SPIN_LOCK_UNLOCKED(alg_manager.lock),
	.ref = ATOMIC_INIT(0),
	.last_acc = NULL,
	};

	static struct kmem_cache *blk_crypt_cachep = NULL;

	/* Static functions */
	/**
	* blk_crypt_alloc_context() - allocate blk_crypt_context structure
	* @mode: filesystem encryption mode.
	*
	* Find hardware algorithm matched with specified mode and
	* calling the hw callback function to allocate crypt_info structure.
	*
	* Return: Allocated blk_crypt_context if succeed to find algorithm mode,
	* -ENOKEY otherwise.
	*/
	static blk_crypt_t blk_crypt_alloc_context(struct block_device bdev, const char *cipher_str)
	{
	struct blk_crypt_algorithm *alg;
	struct blk_crypt_context *bctx;
	int res = -ENOENT;

	spin_lock_irq(&alg_manager.lock);
	if (alg_manager.last_acc && !strcmp(alg_manager.last_acc->name, cipher_str)) {
	alg = alg_manager.last_acc;
	atomic_inc(&alg->ref);
	goto unlock;
	}

	list_for_each_entry(alg, &alg_manager.list, list) {
	if (strcmp(alg->name, cipher_str)) {
	pr_info("blk-crypt: no matched alg(%s) != requested alg(%s)\n",
	alg->name, cipher_str);
	continue;
	}

	if (alg->bdev && alg->bdev != bdev) {
	pr_info("blk-crypt: no matched alg(%s)->bdev != bdev\n",
	cipher_str);
	continue;
	}

	alg_manager.last_acc = alg;
	atomic_inc(&alg->ref);
	break;
	}
	unlock:
	spin_unlock_irq(&alg_manager.lock);

	if (alg == (void *)&alg_manager.list)
	return ERR_PTR(-ENOENT);

	bctx = kmem_cache_zalloc(blk_crypt_cachep, GFP_NOFS);
	if (!bctx) {
	res = -ENOMEM;
	goto err_free;
	}

	bctx->bc_alg = alg;
	bctx->bc_private = alg->hw_cbs->alloc();
	if (IS_ERR(bctx->bc_private)) {
	res = PTR_ERR(bctx->bc_private);
	pr_err("blk-crypt: failed to alloc data for alg(%s), err:%d\n",
	alg->name, res);
	goto err_free;
	}

	return bctx;
	err_free:
	atomic_dec(&alg->ref);
	if (bctx)
	kmem_cache_free(blk_crypt_cachep, bctx);
	return ERR_PTR(res);
	}


	static inline blk_crypt_t __bio_crypt(const struct bio bio)
	{
	if (bio && (bio->bi_opf & REQ_CRYPT))
	return bio->bi_cryptd;

	return NULL;
	}

	bool blk_crypt_encrypted(const struct bio *bio)
	{
	return __bio_crypt(bio) ? true : false;
	}

	bool blk_crypt_mergeable(const struct bio a, const struct bio b)
	{
	#ifdef CONFIG_BLK_DEV_CRYPT
	if (__bio_crypt(a) != __bio_crypt(b))
	return false;

	#ifdef CONFIG_BLK_DEV_CRYPT_DUN
	if (__bio_crypt(a)) {
	if (!bio_dun(a) ^ !bio_dun(b))
	return false;
	if (bio_dun(a) && bio_end_dun(a) != bio_dun(b))
	return false;
	}
	#endif
	#endif
	return true;
	}

	/* Filesystem APIs */
	blk_crypt_t blk_crypt_get_context(struct block_device bdev, const char *cipher_str)
	{
	struct blk_crypt_t *bctx;
	bctx = blk_crypt_alloc_context(bdev, cipher_str);
	if (IS_ERR(bctx)) {
	pr_debug("error allocating diskciher '%s' err: %d",
	cipher_str, PTR_ERR(bctx));
	return bctx;
	}

	return bctx;
	}

	unsigned char blk_crypt_get_key(blk_crypt_t bc_ctx)
	{
	struct blk_crypt_context *bctx = bc_ctx;

	if (!bctx)
	return ERR_PTR(-EINVAL);

	return bctx->bc_alg->hw_cbs->get_key(bctx->bc_private);
	}

	int blk_crypt_set_key(blk_crypt_t bc_ctx, u8 raw_key, u32 keysize, void *priv)
	{
	struct blk_crypt_context *bctx = bc_ctx;

	if (!bctx)
	return -EINVAL;

	return bctx->bc_alg->hw_cbs->set_key(bctx->bc_private, raw_key, keysize, priv);
	}

	void blk_crypt_get_data(blk_crypt_t bc_ctx)
	{
	struct blk_crypt_context *bctx = bc_ctx;
	return bctx->bc_private;
	}

	void blk_crypt_put_context(blk_crypt_t *bc_ctx)
	{
	struct blk_crypt_context *bctx = bc_ctx;

	if (!bctx)
	return;

	bctx->bc_alg->hw_cbs->free(bctx->bc_private);
	atomic_dec(&(bctx->bc_alg->ref));
	kmem_cache_free(blk_crypt_cachep, bctx);
	}

	/* H/W algorithm APIs */
	static int blk_crypt_initialize()
	{
	if (likely(blk_crypt_cachep))
	return 0;

	blk_crypt_cachep = KMEM_CACHE(blk_crypt_context, SLAB_RECLAIM_ACCOUNT);
	if (!blk_crypt_cachep)
	return -ENOMEM;

	return 0;
	}

	/**
	* blk_crypt_alg_register() - register a hw algorithm in algorithm manager
	* @name: name of algorithm
	* @mode: filesystem encryption mode
	* @hw_cbs: hardware callback functions
	*
	* A mode and name must be unique value so that these values are used to
	* differentiate each algorithm. If the algorithm manager finds duplicated
	* mode or name in algorithm list, it considers that as existing algorithm.
	*
	* Return: hw algorithm pointer on success,
	* -EEXIST if already registered.
	*/
	void blk_crypt_alg_register(struct block_device bdev, const char *name,
	const unsigned int mode, const struct blk_crypt_algorithm_cbs *hw_cbs)
	{
	struct blk_crypt_algorithm hw_alg, new_alg;

	if (unlikely(blk_crypt_initialize())) {
	pr_err("blk-crypt: failed to initialize\n");
	return ERR_PTR(-ENOMEM);
	}

	if (!name \|\| strlen(name) > BLK_CRYPT_ALG_NAMELEN_MAX) {
	pr_err("blk-crypt: invalid algorithm name or namelen\n");
	return ERR_PTR(-EINVAL);
	}

	/* Allocate new dhe_algorithm */
	new_alg = kzalloc(sizeof(struct blk_crypt_algorithm), GFP_KERNEL);
	if (!new_alg)
	return ERR_PTR(-ENOMEM);

	/* Initialize new hw_algorithm */
	strncpy(new_alg->name, name, BLK_CRYPT_ALG_NAMELEN_MAX);
	new_alg->bdev = bdev;
	new_alg->mode = mode;
	new_alg->hw_cbs = hw_cbs;
	INIT_LIST_HEAD(&new_alg->list);

	/* Check the existence of same thing. */
	spin_lock_irq(&alg_manager.lock);
	list_for_each_entry(hw_alg, &alg_manager.list, list) {
	/* an algorithm can be allocated for multiple devices */
	if (hw_alg->bdev && bdev && (hw_alg->bdev != bdev))
	continue;
	if (hw_alg->mode == mode)
	break;
	if (!strcmp(hw_alg->name, name))
	break;
	}

	/* Already exist, can not register new one */
	if (&alg_manager.list != &hw_alg->list) {
	spin_unlock_irq(&alg_manager.lock);
	pr_err("blk-crypt: algorithm(%s) already exists\n", name);
	kfree(new_alg);
	return ERR_PTR(-EEXIST);
	}

	/* Add to algorithm manager */
	list_add(&new_alg->list, &alg_manager.list);
	spin_unlock_irq(&alg_manager.lock);
	pr_info("blk_crypt: registed algorithm(%s)\n", name);

	return new_alg;
	}
	EXPORT_SYMBOL(blk_crypt_alg_register);

	/**
	* blk_crypt_alg_unregister() - unregister hw algorithm from the algorithm manager
	* @handle: The pointer of hw algorithm that returned by blk_crypt_alg_register().
	*
	* Free and unregister specified handle if there is no ref count.
	*/
	int blk_crypt_alg_unregister(void *handle)
	{
	struct blk_crypt_algorithm *alg;

	if (!handle)
	return -EINVAL;

	alg = (struct blk_crypt_algorithm *)handle;

	/* prevent unregister if an algorithm is being referenced */
	if (atomic_read(&alg->ref))
	return -EBUSY;

	/* just unlink this algorithm from the manager */
	spin_lock_irq(&alg_manager.lock);
	list_del_init(&alg->list);
	spin_unlock_irq(&alg_manager.lock);

	kfree(handle);
	return 0;
	}
	EXPORT_SYMBOL(blk_crypt_alg_unregister);

	/* Blk-crypt core functions */
	static int __init blk_crypt_init(void)
	{
	pr_info("%s\n", __func__);
	blk_crypt_initialize();
	return 0;
	}

	static void __exit blk_crypt_exit(void)
	{
	pr_info("%s\n", __func__);
	if (atomic_read(&alg_manager.ref)) {
	pr_warn("blk-crypt: remailed %d registered algorithm\n",
	atomic_read(&alg_manager.ref));
	}

	kmem_cache_destroy(blk_crypt_cachep);
	blk_crypt_cachep = NULL;
	}

	module_init(blk_crypt_init);
	module_exit(blk_crypt_exit);