Lines Matching refs:fio
440 static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages)
442 struct f2fs_sb_info *sbi = fio->sbi;
447 f2fs_target_device(sbi, fio->new_blkaddr, bio);
448 if (is_read_io(fio->op)) {
455 fio->type, fio->temp);
457 if (fio->io_wbc)
458 wbc_init_bio(fio->io_wbc, bio);
465 const struct f2fs_io_info *fio,
472 if (!fio || !fio->encrypted_page)
478 const struct f2fs_io_info *fio)
484 if (fio && fio->encrypted_page)
546 static void __attach_io_flag(struct f2fs_io_info *fio)
548 struct f2fs_sb_info *sbi = fio->sbi;
552 if (fio->type == DATA)
554 else if (fio->type == NODE)
568 if ((1 << fio->temp) & meta_flag)
569 fio->op_flags |= REQ_META;
570 if ((1 << fio->temp) & fua_flag)
571 fio->op_flags |= REQ_FUA;
576 struct f2fs_io_info *fio = &io->fio;
581 __attach_io_flag(fio);
582 bio_set_op_attrs(io->bio, fio->op, fio->op_flags);
584 if (is_read_io(fio->op))
585 trace_f2fs_prepare_read_bio(io->sbi->sb, fio->type, io->bio);
587 trace_f2fs_prepare_write_bio(io->sbi->sb, fio->type, io->bio);
589 __submit_bio(io->sbi, io->bio, fio->type);
640 io->fio.type = META_FLUSH;
641 io->fio.op = REQ_OP_WRITE;
642 io->fio.op_flags = REQ_META | REQ_PRIO | REQ_SYNC;
644 io->fio.op_flags |= REQ_PREFLUSH | REQ_FUA;
698 int f2fs_submit_page_bio(struct f2fs_io_info *fio)
701 struct page *page = fio->encrypted_page ?
702 fio->encrypted_page : fio->page;
704 if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
705 fio->is_por ? META_POR : (__is_meta_io(fio) ?
709 trace_f2fs_submit_page_bio(page, fio);
710 f2fs_trace_ios(fio, 0);
713 bio = __bio_alloc(fio, 1);
715 f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,
716 fio->page->index, fio, GFP_NOIO);
723 if (fio->io_wbc && !is_read_io(fio->op))
724 wbc_account_cgroup_owner(fio->io_wbc, fio->page, PAGE_SIZE);
726 __attach_io_flag(fio);
727 bio_set_op_attrs(bio, fio->op, fio->op_flags);
729 inc_page_count(fio->sbi, is_read_io(fio->op) ?
730 __read_io_type(page): WB_DATA_TYPE(fio->page));
732 __submit_bio(fio->sbi, bio, fio->type);
745 struct f2fs_io_info *fio)
747 if (io->fio.op != fio->op)
749 return io->fio.op_flags == fio->op_flags;
754 struct f2fs_io_info *fio,
758 if (F2FS_IO_ALIGNED(sbi) && (fio->type == DATA || fio->type == NODE)) {
770 return io_type_is_mergeable(io, fio);
797 static int add_ipu_page(struct f2fs_io_info *fio, struct bio **bio,
800 struct f2fs_sb_info *sbi = fio->sbi;
818 *fio->last_block,
819 fio->new_blkaddr));
821 fio->page->mapping->host,
822 fio->page->index, fio) &&
903 int f2fs_merge_page_bio(struct f2fs_io_info *fio)
905 struct bio *bio = *fio->bio;
906 struct page *page = fio->encrypted_page ?
907 fio->encrypted_page : fio->page;
909 if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
910 __is_meta_io(fio) ? META_GENERIC : DATA_GENERIC))
913 trace_f2fs_submit_page_bio(page, fio);
914 f2fs_trace_ios(fio, 0);
916 if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block,
917 fio->new_blkaddr))
918 f2fs_submit_merged_ipu_write(fio->sbi, &bio, NULL);
921 bio = __bio_alloc(fio, BIO_MAX_PAGES);
922 __attach_io_flag(fio);
923 f2fs_set_bio_crypt_ctx(bio, fio->page->mapping->host,
924 fio->page->index, fio, GFP_NOIO);
925 bio_set_op_attrs(bio, fio->op, fio->op_flags);
927 add_bio_entry(fio->sbi, bio, page, fio->temp);
929 if (add_ipu_page(fio, &bio, page))
933 if (fio->io_wbc)
934 wbc_account_cgroup_owner(fio->io_wbc, fio->page, PAGE_SIZE);
936 inc_page_count(fio->sbi, WB_DATA_TYPE(page));
938 *fio->last_block = fio->new_blkaddr;
939 *fio->bio = bio;
944 void f2fs_submit_page_write(struct f2fs_io_info *fio)
946 struct f2fs_sb_info *sbi = fio->sbi;
947 enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
948 struct f2fs_bio_info *io = sbi->write_io[btype] + fio->temp;
951 f2fs_bug_on(sbi, is_read_io(fio->op));
955 if (fio->in_list) {
961 fio = list_first_entry(&io->io_list,
963 list_del(&fio->list);
967 verify_fio_blkaddr(fio);
969 if (fio->encrypted_page)
970 bio_page = fio->encrypted_page;
971 else if (fio->compressed_page)
972 bio_page = fio->compressed_page;
974 bio_page = fio->page;
977 fio->submitted = true;
982 (!io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio,
983 fio->new_blkaddr) ||
984 !f2fs_crypt_mergeable_bio(io->bio, fio->page->mapping->host,
985 bio_page->index, fio)))
990 (fio->type == DATA || fio->type == NODE) &&
991 fio->new_blkaddr & F2FS_IO_SIZE_MASK(sbi)) {
993 fio->retry = true;
996 io->bio = __bio_alloc(fio, BIO_MAX_PAGES);
997 f2fs_set_bio_crypt_ctx(io->bio, fio->page->mapping->host,
998 bio_page->index, fio, GFP_NOIO);
999 io->fio = *fio;
1007 if (fio->io_wbc)
1008 wbc_account_cgroup_owner(fio->io_wbc, fio->page, PAGE_SIZE);
1010 io->last_block_in_bio = fio->new_blkaddr;
1011 f2fs_trace_ios(fio, 0);
1013 trace_f2fs_submit_page_write(fio->page, fio);
1015 if (fio->in_list)
2538 int f2fs_encrypt_one_page(struct f2fs_io_info *fio)
2540 struct inode *inode = fio->page->mapping->host;
2547 page = fio->compressed_page ? fio->compressed_page : fio->page;
2550 f2fs_wait_on_block_writeback(inode, fio->old_blkaddr);
2556 fio->encrypted_page = fscrypt_encrypt_pagecache_blocks(page,
2558 if (IS_ERR(fio->encrypted_page)) {
2560 if (PTR_ERR(fio->encrypted_page) == -ENOMEM) {
2561 f2fs_flush_merged_writes(fio->sbi);
2566 return PTR_ERR(fio->encrypted_page);
2569 mpage = find_lock_page(META_MAPPING(fio->sbi), fio->old_blkaddr);
2573 page_address(fio->encrypted_page), PAGE_SIZE);
2580 struct f2fs_io_info *fio)
2600 fio && fio->op == REQ_OP_WRITE &&
2601 !(fio->op_flags & REQ_SYNC) &&
2610 if (unlikely(fio && is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
2611 !f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
2617 bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio)
2626 return check_inplace_update_policy(inode, fio);
2629 bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
2641 if (fio) {
2642 if (is_cold_data(fio->page))
2644 if (IS_ATOMIC_WRITTEN_PAGE(fio->page))
2647 f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
2653 static inline bool need_inplace_update(struct f2fs_io_info *fio)
2655 struct inode *inode = fio->page->mapping->host;
2657 if (f2fs_should_update_outplace(inode, fio))
2660 return f2fs_should_update_inplace(inode, fio);
2663 int f2fs_do_write_data_page(struct f2fs_io_info *fio)
2665 struct page *page = fio->page;
2674 if (need_inplace_update(fio) &&
2676 fio->old_blkaddr = ei.blk + page->index - ei.fofs;
2678 if (!f2fs_is_valid_blkaddr(fio->sbi, fio->old_blkaddr,
2683 fio->need_lock = LOCK_DONE;
2688 if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi))
2695 fio->old_blkaddr = dn.data_blkaddr;
2698 if (fio->old_blkaddr == NULL_ADDR) {
2704 if (__is_valid_data_blkaddr(fio->old_blkaddr) &&
2705 !f2fs_is_valid_blkaddr(fio->sbi, fio->old_blkaddr,
2715 (__is_valid_data_blkaddr(fio->old_blkaddr) &&
2716 need_inplace_update(fio))) {
2717 err = f2fs_encrypt_one_page(fio);
2724 if (fio->need_lock == LOCK_REQ)
2725 f2fs_unlock_op(fio->sbi);
2726 err = f2fs_inplace_write_data(fio);
2729 fscrypt_finalize_bounce_page(&fio->encrypted_page);
2735 trace_f2fs_do_write_data_page(fio->page, IPU);
2739 if (fio->need_lock == LOCK_RETRY) {
2740 if (!f2fs_trylock_op(fio->sbi)) {
2744 fio->need_lock = LOCK_REQ;
2747 err = f2fs_get_node_info(fio->sbi, dn.nid, &ni);
2751 fio->version = ni.version;
2753 err = f2fs_encrypt_one_page(fio);
2760 if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
2761 f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
2764 f2fs_outplace_write_data(&dn, fio);
2772 if (fio->need_lock == LOCK_REQ)
2773 f2fs_unlock_op(fio->sbi);
2794 struct f2fs_io_info fio = {
2863 fio.need_lock = LOCK_DONE;
2864 err = f2fs_do_write_data_page(&fio);
2887 err = f2fs_do_write_data_page(&fio);
2889 fio.need_lock = LOCK_REQ;
2890 err = f2fs_do_write_data_page(&fio);
2933 *submitted = fio.submitted ? 1 : 0;