[mirror_ubuntu-artful-kernel.git] / fs / crypto / bio.c

/*
 * This contains encryption functions for per-file encryption.
 *
 * Copyright (C) 2015, Google, Inc.
 * Copyright (C) 2015, Motorola Mobility
 *
 * Written by Michael Halcrow, 2014.
 *
 * Filename encryption additions
 *	Uday Savagaonkar, 2014
 * Encryption policy handling additions
 *	Ildar Muslukhov, 2014
 * Add fscrypt_pullback_bio_page()
 *	Jaegeuk Kim, 2015.
 *
 * This has not yet undergone a rigorous security audit.
 *
 * The usage of AES-XTS should conform to recommendations in NIST
 * Special Publication 800-38E and IEEE P1619/D16.
 */

#include <linux/pagemap.h>
#include <linux/module.h>
#include <linux/bio.h>
#include <linux/namei.h>
#include "fscrypt_private.h"

/*
 * Call fscrypt_decrypt_page on every single page, reusing the encryption
 * context.
 */
static void completion_pages(struct work_struct *work)
{
	struct fscrypt_ctx *ctx =
		container_of(work, struct fscrypt_ctx, r.work);
	struct bio *bio = ctx->r.bio;
	struct bio_vec *bv;
	int i;

	bio_for_each_segment_all(bv, bio, i) {
		struct page *page = bv->bv_page;
		int ret = fscrypt_decrypt_page(page->mapping->host, page,
				PAGE_SIZE, 0, page->index);

		if (ret) {
			WARN_ON_ONCE(1);
			SetPageError(page);
		} else {
			SetPageUptodate(page);
		}
		unlock_page(page);
	}
	fscrypt_release_ctx(ctx);
	bio_put(bio);
}

void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *ctx, struct bio *bio)
{
	INIT_WORK(&ctx->r.work, completion_pages);
	ctx->r.bio = bio;
	queue_work(fscrypt_read_workqueue, &ctx->r.work);
}
EXPORT_SYMBOL(fscrypt_decrypt_bio_pages);

void fscrypt_pullback_bio_page(struct page **page, bool restore)
{
	struct fscrypt_ctx *ctx;
	struct page *bounce_page;

	/* The bounce data pages are unmapped. */
	if ((*page)->mapping)
		return;

	/* The bounce data page is unmapped. */
	bounce_page = *page;
	ctx = (struct fscrypt_ctx *)page_private(bounce_page);

	/* restore control page */
	*page = ctx->w.control_page;

	if (restore)
		fscrypt_restore_control_page(bounce_page);
}
EXPORT_SYMBOL(fscrypt_pullback_bio_page);

int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
				sector_t pblk, unsigned int len)
{
	struct fscrypt_ctx *ctx;
	struct page *ciphertext_page = NULL;
	struct bio *bio;
	int ret, err = 0;

	BUG_ON(inode->i_sb->s_blocksize != PAGE_SIZE);

	ctx = fscrypt_get_ctx(inode, GFP_NOFS);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);

	ciphertext_page = fscrypt_alloc_bounce_page(ctx, GFP_NOWAIT);
	if (IS_ERR(ciphertext_page)) {
		err = PTR_ERR(ciphertext_page);
		goto errout;
	}

	while (len--) {
		err = fscrypt_do_page_crypto(inode, FS_ENCRYPT, lblk,
					     ZERO_PAGE(0), ciphertext_page,
					     PAGE_SIZE, 0, GFP_NOFS);
		if (err)
			goto errout;

		bio = bio_alloc(GFP_NOWAIT, 1);
		if (!bio) {
			err = -ENOMEM;
			goto errout;
		}
		bio->bi_bdev = inode->i_sb->s_bdev;
		bio->bi_iter.bi_sector =
			pblk << (inode->i_sb->s_blocksize_bits - 9);
		bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
		ret = bio_add_page(bio, ciphertext_page,
					inode->i_sb->s_blocksize, 0);
		if (ret != inode->i_sb->s_blocksize) {
			/* should never happen! */
			WARN_ON(1);
			bio_put(bio);
			err = -EIO;
			goto errout;
		}
		err = submit_bio_wait(bio);
		if (err == 0 && bio->bi_status)
			err = -EIO;
		bio_put(bio);
		if (err)
			goto errout;
		lblk++;
		pblk++;
	}
	err = 0;
errout:
	fscrypt_release_ctx(ctx);
	return err;
}
EXPORT_SYMBOL(fscrypt_zeroout_range);
Commit	Line	Data
58ae7468 RW	1	/*
	2	* This contains encryption functions for per-file encryption.
	3	*
	4	* Copyright (C) 2015, Google, Inc.
	5	* Copyright (C) 2015, Motorola Mobility
	6	*
	7	* Written by Michael Halcrow, 2014.
	8	*
	9	* Filename encryption additions
	10	* Uday Savagaonkar, 2014
	11	* Encryption policy handling additions
	12	* Ildar Muslukhov, 2014
	13	* Add fscrypt_pullback_bio_page()
	14	* Jaegeuk Kim, 2015.
	15	*
	16	* This has not yet undergone a rigorous security audit.
	17	*
	18	* The usage of AES-XTS should conform to recommendations in NIST
	19	* Special Publication 800-38E and IEEE P1619/D16.
	20	*/
	21
	22	#include <linux/pagemap.h>
	23	#include <linux/module.h>
	24	#include <linux/bio.h>
	25	#include <linux/namei.h>
	26	#include "fscrypt_private.h"
	27
	28	/*
	29	* Call fscrypt_decrypt_page on every single page, reusing the encryption
	30	* context.
	31	*/
	32	static void completion_pages(struct work_struct *work)
	33	{
	34	struct fscrypt_ctx *ctx =
	35	container_of(work, struct fscrypt_ctx, r.work);
	36	struct bio *bio = ctx->r.bio;
	37	struct bio_vec *bv;
	38	int i;
	39
	40	bio_for_each_segment_all(bv, bio, i) {
	41	struct page *page = bv->bv_page;
	42	int ret = fscrypt_decrypt_page(page->mapping->host, page,
	43	PAGE_SIZE, 0, page->index);
	44
	45	if (ret) {
	46	WARN_ON_ONCE(1);
	47	SetPageError(page);
	48	} else {
	49	SetPageUptodate(page);
	50	}
	51	unlock_page(page);
	52	}
	53	fscrypt_release_ctx(ctx);
	54	bio_put(bio);
	55	}
	56
	57	void fscrypt_decrypt_bio_pages(struct fscrypt_ctx ctx, struct bio bio)
	58	{
	59	INIT_WORK(&ctx->r.work, completion_pages);
	60	ctx->r.bio = bio;
	61	queue_work(fscrypt_read_workqueue, &ctx->r.work);
	62	}
	63	EXPORT_SYMBOL(fscrypt_decrypt_bio_pages);
	64
65	void fscrypt_pullback_bio_page(struct page **page, bool restore)
66	{
67	struct fscrypt_ctx *ctx;
68	struct page *bounce_page;
69
70	/* The bounce data pages are unmapped. */
71	if ((*page)->mapping)
72	return;
73
74	/* The bounce data page is unmapped. */
75	bounce_page = *page;
76	ctx = (struct fscrypt_ctx *)page_private(bounce_page);
77
78	/* restore control page */
79	*page = ctx->w.control_page;
80
81	if (restore)
82	fscrypt_restore_control_page(bounce_page);
83	}
84	EXPORT_SYMBOL(fscrypt_pullback_bio_page);
85
86	int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
87	sector_t pblk, unsigned int len)
88	{
89	struct fscrypt_ctx *ctx;
90	struct page *ciphertext_page = NULL;
91	struct bio *bio;
92	int ret, err = 0;
93
94	BUG_ON(inode->i_sb->s_blocksize != PAGE_SIZE);
95
96	ctx = fscrypt_get_ctx(inode, GFP_NOFS);
97	if (IS_ERR(ctx))
98	return PTR_ERR(ctx);
99
100	ciphertext_page = fscrypt_alloc_bounce_page(ctx, GFP_NOWAIT);
101	if (IS_ERR(ciphertext_page)) {
102	err = PTR_ERR(ciphertext_page);
103	goto errout;
104	}
105
106	while (len--) {
107	err = fscrypt_do_page_crypto(inode, FS_ENCRYPT, lblk,
108	ZERO_PAGE(0), ciphertext_page,
109	PAGE_SIZE, 0, GFP_NOFS);
110	if (err)
111	goto errout;
112
113	bio = bio_alloc(GFP_NOWAIT, 1);
114	if (!bio) {
115	err = -ENOMEM;
116	goto errout;
117	}
118	bio->bi_bdev = inode->i_sb->s_bdev;
119	bio->bi_iter.bi_sector =
120	pblk << (inode->i_sb->s_blocksize_bits - 9);
121	bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
122	ret = bio_add_page(bio, ciphertext_page,
123	inode->i_sb->s_blocksize, 0);
124	if (ret != inode->i_sb->s_blocksize) {
125	/* should never happen! */
126	WARN_ON(1);
127	bio_put(bio);
128	err = -EIO;
129	goto errout;
130	}
131	err = submit_bio_wait(bio);
4e4cbee9	132	if (err == 0 && bio->bi_status)
58ae7468 RW	133	err = -EIO;
	134	bio_put(bio);
	135	if (err)
	136	goto errout;
	137	lblk++;
	138	pblk++;
	139	}
	140	err = 0;
	141	errout:
	142	fscrypt_release_ctx(ctx);
	143	return err;
	144	}
	145	EXPORT_SYMBOL(fscrypt_zeroout_range);