Merge tag 'ofs-pull-tag-1' of git://git.kernel.org/pub/scm/linux/kernel/git/hubcap...

[deliverable/linux.git] / fs / f2fs / data.c

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index ca99a2aca1072a2b3bf450ca6d0358e1ecd41fee..e5c762b372390b59fd0ceb011fea75ab19a41fe7 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -34,9 +34,9 @@ static void f2fs_read_end_io(struct bio *bio)
 
        if (f2fs_bio_encrypted(bio)) {
                if (bio->bi_error) {
-                       f2fs_release_crypto_ctx(bio->bi_private);
+                       fscrypt_release_ctx(bio->bi_private);
                } else {
-                       f2fs_end_io_crypto_work(bio->bi_private, bio);
+                       fscrypt_decrypt_bio_pages(bio->bi_private, bio);
                        return;
                }
        }
@@ -64,7 +64,7 @@ static void f2fs_write_end_io(struct bio *bio)
        bio_for_each_segment_all(bvec, bio, i) {
                struct page *page = bvec->bv_page;
 
-               f2fs_restore_and_release_control_page(&page);
+               fscrypt_pullback_bio_page(&page, true);
 
                if (unlikely(bio->bi_error)) {
                        set_bit(AS_EIO, &page->mapping->flags);
@@ -129,16 +129,10 @@ static bool __has_merged_page(struct f2fs_bio_info *io, struct inode *inode,
 
        bio_for_each_segment_all(bvec, io->bio, i) {
 
-               if (bvec->bv_page->mapping) {
+               if (bvec->bv_page->mapping)
                        target = bvec->bv_page;
-               } else {
-                       struct f2fs_crypto_ctx *ctx;
-
-                       /* encrypted page */
-                       ctx = (struct f2fs_crypto_ctx *)page_private(
-                                                               bvec->bv_page);
-                       target = ctx->w.control_page;
-               }
+               else
+                       target = fscrypt_control_page(bvec->bv_page);
 
                if (inode && inode == target->mapping->host)
                        return true;
@@ -206,6 +200,13 @@ void f2fs_submit_merged_bio_cond(struct f2fs_sb_info *sbi,
                __f2fs_submit_merged_bio(sbi, inode, page, ino, type, rw);
 }
 
+void f2fs_flush_merged_bios(struct f2fs_sb_info *sbi)
+{
+       f2fs_submit_merged_bio(sbi, DATA, WRITE);
+       f2fs_submit_merged_bio(sbi, NODE, WRITE);
+       f2fs_submit_merged_bio(sbi, META, WRITE);
+}
+
 /*
  * Fill the locked page with data located in the block address.
  * Return unlocked page.
@@ -213,13 +214,14 @@ void f2fs_submit_merged_bio_cond(struct f2fs_sb_info *sbi,
 int f2fs_submit_page_bio(struct f2fs_io_info *fio)
 {
        struct bio *bio;
-       struct page *page = fio->encrypted_page ? fio->encrypted_page : fio->page;
+       struct page *page = fio->encrypted_page ?
+                       fio->encrypted_page : fio->page;
 
        trace_f2fs_submit_page_bio(page, fio);
        f2fs_trace_ios(fio, 0);
 
        /* Allocate a new bio */
-       bio = __bio_alloc(fio->sbi, fio->blk_addr, 1, is_read_io(fio->rw));
+       bio = __bio_alloc(fio->sbi, fio->new_blkaddr, 1, is_read_io(fio->rw));
 
        if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
                bio_put(bio);
@@ -240,21 +242,24 @@ void f2fs_submit_page_mbio(struct f2fs_io_info *fio)
 
        io = is_read ? &sbi->read_io : &sbi->write_io[btype];
 
-       verify_block_addr(sbi, fio->blk_addr);
+       if (fio->old_blkaddr != NEW_ADDR)
+               verify_block_addr(sbi, fio->old_blkaddr);
+       verify_block_addr(sbi, fio->new_blkaddr);
 
        down_write(&io->io_rwsem);
 
        if (!is_read)
                inc_page_count(sbi, F2FS_WRITEBACK);
 
-       if (io->bio && (io->last_block_in_bio != fio->blk_addr - 1 ||
+       if (io->bio && (io->last_block_in_bio != fio->new_blkaddr - 1 ||
                                                io->fio.rw != fio->rw))
                __submit_merged_bio(io);
 alloc_new:
        if (io->bio == NULL) {
                int bio_blocks = MAX_BIO_BLOCKS(sbi);
 
-               io->bio = __bio_alloc(sbi, fio->blk_addr, bio_blocks, is_read);
+               io->bio = __bio_alloc(sbi, fio->new_blkaddr,
+                                               bio_blocks, is_read);
                io->fio = *fio;
        }
 
@@ -266,7 +271,7 @@ alloc_new:
                goto alloc_new;
        }
 
-       io->last_block_in_bio = fio->blk_addr;
+       io->last_block_in_bio = fio->new_blkaddr;
        f2fs_trace_ios(fio, 0);
 
        up_write(&io->io_rwsem);
@@ -297,6 +302,13 @@ void set_data_blkaddr(struct dnode_of_data *dn)
                dn->node_changed = true;
 }
 
+void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr)
+{
+       dn->data_blkaddr = blkaddr;
+       set_data_blkaddr(dn);
+       f2fs_update_extent_cache(dn);
+}
+
 int reserve_new_block(struct dnode_of_data *dn)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
@@ -400,7 +412,7 @@ got_it:
                return page;
        }
 
-       fio.blk_addr = dn.data_blkaddr;
+       fio.new_blkaddr = fio.old_blkaddr = dn.data_blkaddr;
        fio.page = page;
        err = f2fs_submit_page_bio(&fio);
        if (err)
@@ -975,12 +987,12 @@ submit_and_realloc:
                        bio = NULL;
                }
                if (bio == NULL) {
-                       struct f2fs_crypto_ctx *ctx = NULL;
+                       struct fscrypt_ctx *ctx = NULL;
 
                        if (f2fs_encrypted_inode(inode) &&
                                        S_ISREG(inode->i_mode)) {
 
-                               ctx = f2fs_get_crypto_ctx(inode);
+                               ctx = fscrypt_get_ctx(inode);
                                if (IS_ERR(ctx))
                                        goto set_error_page;
 
@@ -993,7 +1005,7 @@ submit_and_realloc:
                                min_t(int, nr_pages, BIO_MAX_PAGES));
                        if (!bio) {
                                if (ctx)
-                                       f2fs_release_crypto_ctx(ctx);
+                                       fscrypt_release_ctx(ctx);
                                goto set_error_page;
                        }
                        bio->bi_bdev = bdev;
@@ -1071,10 +1083,10 @@ int do_write_data_page(struct f2fs_io_info *fio)
        if (err)
                return err;
 
-       fio->blk_addr = dn.data_blkaddr;
+       fio->old_blkaddr = dn.data_blkaddr;
 
        /* This page is already truncated */
-       if (fio->blk_addr == NULL_ADDR) {
+       if (fio->old_blkaddr == NULL_ADDR) {
                ClearPageUptodate(page);
                goto out_writepage;
        }
@@ -1083,9 +1095,9 @@ int do_write_data_page(struct f2fs_io_info *fio)
 
                /* wait for GCed encrypted page writeback */
                f2fs_wait_on_encrypted_page_writeback(F2FS_I_SB(inode),
-                                                       fio->blk_addr);
+                                                       fio->old_blkaddr);
 
-               fio->encrypted_page = f2fs_encrypt(inode, fio->page);
+               fio->encrypted_page = fscrypt_encrypt_page(inode, fio->page);
                if (IS_ERR(fio->encrypted_page)) {
                        err = PTR_ERR(fio->encrypted_page);
                        goto out_writepage;
@@ -1098,7 +1110,7 @@ int do_write_data_page(struct f2fs_io_info *fio)
         * If current allocation needs SSR,
         * it had better in-place writes for updated data.
         */
-       if (unlikely(fio->blk_addr != NEW_ADDR &&
+       if (unlikely(fio->old_blkaddr != NEW_ADDR &&
                        !is_cold_data(page) &&
                        !IS_ATOMIC_WRITTEN_PAGE(page) &&
                        need_inplace_update(inode))) {
@@ -1107,8 +1119,6 @@ int do_write_data_page(struct f2fs_io_info *fio)
                trace_f2fs_do_write_data_page(page, IPU);
        } else {
                write_data_page(&dn, fio);
-               set_data_blkaddr(&dn);
-               f2fs_update_extent_cache(&dn);
                trace_f2fs_do_write_data_page(page, OPU);
                set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
                if (page->index == 0)
@@ -1572,7 +1582,8 @@ repeat:
                        .sbi = sbi,
                        .type = DATA,
                        .rw = READ_SYNC,
-                       .blk_addr = blkaddr,
+                       .old_blkaddr = blkaddr,
+                       .new_blkaddr = blkaddr,
                        .page = page,
                        .encrypted_page = NULL,
                };
@@ -1592,7 +1603,7 @@ repeat:
 
                /* avoid symlink page */
                if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {
-                       err = f2fs_decrypt(page);
+                       err = fscrypt_decrypt_page(page);
                        if (err)
                                goto fail;
                }