fs/crypto/bio.c

   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);
 132                 if ((err == 0) && bio->bi_error)
 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);