a queue (device) has been associated with the bio and
        before submission.
 
-  wbc_account_io(@wbc, @page, @bytes)
+  wbc_account_cgroup_owner(@wbc, @page, @bytes)
        Should be called for each data segment being written out.
        While this function doesn't care exactly when it's called
        during the writeback session, it's the easiest and most
 
                        bio = NULL;
                } else {
                        if (wbc)
-                               wbc_account_io(wbc, page, page_size);
+                               wbc_account_cgroup_owner(wbc, page, page_size);
                        return 0;
                }
        }
        bio->bi_opf = opf;
        if (wbc) {
                wbc_init_bio(wbc, bio);
-               wbc_account_io(wbc, page, page_size);
+               wbc_account_cgroup_owner(wbc, page, page_size);
        }
 
        *bio_ret = bio;
 
 
        if (wbc) {
                wbc_init_bio(wbc, bio);
-               wbc_account_io(wbc, bh->b_page, bh->b_size);
+               wbc_account_cgroup_owner(wbc, bh->b_page, bh->b_size);
        }
 
        submit_bio(bio);
 
        ret = bio_add_page(io->io_bio, page, bh->b_size, bh_offset(bh));
        if (ret != bh->b_size)
                goto submit_and_retry;
-       wbc_account_io(io->io_wbc, page, bh->b_size);
+       wbc_account_cgroup_owner(io->io_wbc, page, bh->b_size);
        io->io_next_block++;
        return 0;
 }
 
        }
 
        if (fio->io_wbc && !is_read_io(fio->op))
-               wbc_account_io(fio->io_wbc, page, PAGE_SIZE);
+               wbc_account_cgroup_owner(fio->io_wbc, page, PAGE_SIZE);
 
        bio_set_op_attrs(bio, fio->op, fio->op_flags);
 
        }
 
        if (fio->io_wbc)
-               wbc_account_io(fio->io_wbc, bio_page, PAGE_SIZE);
+               wbc_account_cgroup_owner(fio->io_wbc, bio_page, PAGE_SIZE);
 
        io->last_block_in_bio = fio->new_blkaddr;
        f2fs_trace_ios(fio, 0);
 
 EXPORT_SYMBOL_GPL(wbc_detach_inode);
 
 /**
- * wbc_account_io - account IO issued during writeback
+ * wbc_account_cgroup_owner - account writeback to update inode cgroup ownership
  * @wbc: writeback_control of the writeback in progress
  * @page: page being written out
  * @bytes: number of bytes being written out
  * controlled by @wbc.  Keep the book for foreign inode detection.  See
  * wbc_detach_inode().
  */
-void wbc_account_io(struct writeback_control *wbc, struct page *page,
-                   size_t bytes)
+void wbc_account_cgroup_owner(struct writeback_control *wbc, struct page *page,
+                             size_t bytes)
 {
        struct cgroup_subsys_state *css;
        int id;
        else
                wbc->wb_tcand_bytes -= min(bytes, wbc->wb_tcand_bytes);
 }
-EXPORT_SYMBOL_GPL(wbc_account_io);
+EXPORT_SYMBOL_GPL(wbc_account_cgroup_owner);
 
 /**
  * inode_congested - test whether an inode is congested
 
         * the confused fail path above (OOM) will be very confused when
         * it finds all bh marked clean (i.e. it will not write anything)
         */
-       wbc_account_io(wbc, page, PAGE_SIZE);
+       wbc_account_cgroup_owner(wbc, page, PAGE_SIZE);
        length = first_unmapped << blkbits;
        if (bio_add_page(bio, page, length, 0) < length) {
                bio = mpage_bio_submit(REQ_OP_WRITE, op_flags, bio);
 
                                 struct inode *inode)
        __releases(&inode->i_lock);
 void wbc_detach_inode(struct writeback_control *wbc);
-void wbc_account_io(struct writeback_control *wbc, struct page *page,
-                   size_t bytes);
+void wbc_account_cgroup_owner(struct writeback_control *wbc, struct page *page,
+                             size_t bytes);
 void cgroup_writeback_umount(void);
 
 /**
 {
 }
 
-static inline void wbc_account_io(struct writeback_control *wbc,
-                                 struct page *page, size_t bytes)
+static inline void wbc_account_cgroup_owner(struct writeback_control *wbc,
+                                           struct page *page, size_t bytes)
 {
 }