fs/crypto/bio.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * This contains encryption functions for per-file encryption.
   4  *
   5  * Copyright (C) 2015, Google, Inc.
   6  * Copyright (C) 2015, Motorola Mobility
   7  *
   8  * Written by Michael Halcrow, 2014.
   9  *
  10  * Filename encryption additions
  11  *      Uday Savagaonkar, 2014
  12  * Encryption policy handling additions
  13  *      Ildar Muslukhov, 2014
  14  * Add fscrypt_pullback_bio_page()
  15  *      Jaegeuk Kim, 2015.
  16  *
  17  * This has not yet undergone a rigorous security audit.
  18  *
  19  * The usage of AES-XTS should conform to recommendations in NIST
  20  * Special Publication 800-38E and IEEE P1619/D16.
  21  */
  22
  23 #include <linux/pagemap.h>
  24 #include <linux/module.h>
  25 #include <linux/bio.h>
  26 #include <linux/namei.h>
  27 #include "fscrypt_private.h"
  28
  29 void fscrypt_decrypt_bio(struct bio *bio)
  30 {
  31         struct bio_vec *bv;
  32         struct bvec_iter_all iter_all;
  33
  34         bio_for_each_segment_all(bv, bio, iter_all) {
  35                 struct page *page = bv->bv_page;
  36                 int ret = fscrypt_decrypt_pagecache_blocks(page, bv->bv_len,
  37                                                            bv->bv_offset);
  38                 if (ret)
  39                         SetPageError(page);
  40         }
  41 }
  42 EXPORT_SYMBOL(fscrypt_decrypt_bio);
  43
  44 int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
  45                                 sector_t pblk, unsigned int len)
  46 {
  47         const unsigned int blockbits = inode->i_blkbits;
  48         const unsigned int blocksize = 1 << blockbits;
  49         struct page *ciphertext_page;
  50         struct bio *bio;
  51         int ret, err = 0;
  52
  53         ciphertext_page = fscrypt_alloc_bounce_page(GFP_NOWAIT);
  54         if (!ciphertext_page)
  55                 return -ENOMEM;
  56
  57         while (len--) {
  58                 err = fscrypt_crypt_block(inode, FS_ENCRYPT, lblk,
  59                                           ZERO_PAGE(0), ciphertext_page,
  60                                           blocksize, 0, GFP_NOFS);
  61                 if (err)
  62                         goto errout;
  63
  64                 bio = bio_alloc(GFP_NOWAIT, 1);
  65                 if (!bio) {
  66                         err = -ENOMEM;
  67                         goto errout;
  68                 }
  69                 bio_set_dev(bio, inode->i_sb->s_bdev);
  70                 bio->bi_iter.bi_sector = pblk << (blockbits - 9);
  71                 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
  72                 ret = bio_add_page(bio, ciphertext_page, blocksize, 0);
  73                 if (WARN_ON(ret != blocksize)) {
  74                         /* should never happen! */
  75                         bio_put(bio);
  76                         err = -EIO;
  77                         goto errout;
  78                 }
  79                 err = submit_bio_wait(bio);
  80                 if (err == 0 && bio->bi_status)
  81                         err = -EIO;
  82                 bio_put(bio);
  83                 if (err)
  84                         goto errout;
  85                 lblk++;
  86                 pblk++;
  87         }
  88         err = 0;
  89 errout:
  90         fscrypt_free_bounce_page(ciphertext_page);
  91         return err;
  92 }
  93 EXPORT_SYMBOL(fscrypt_zeroout_range);