f2fs: move f2fs to use reader-unfair rwsems

[linux-2.6-microblaze.git] / fs / f2fs / file.c

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 3c98ef6..6ccdd6e 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -237,13 +237,13 @@ static void try_to_fix_pino(struct inode *inode)
        struct f2fs_inode_info *fi = F2FS_I(inode);
        nid_t pino;
 
-       down_write(&fi->i_sem);
+       f2fs_down_write(&fi->i_sem);
        if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
                        get_parent_ino(inode, &pino)) {
                f2fs_i_pino_write(inode, pino);
                file_got_pino(inode);
        }
-       up_write(&fi->i_sem);
+       f2fs_up_write(&fi->i_sem);
 }
 
 static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
@@ -318,9 +318,9 @@ go_write:
         * Both of fdatasync() and fsync() are able to be recovered from
         * sudden-power-off.
         */
-       down_read(&F2FS_I(inode)->i_sem);
+       f2fs_down_read(&F2FS_I(inode)->i_sem);
        cp_reason = need_do_checkpoint(inode);
-       up_read(&F2FS_I(inode)->i_sem);
+       f2fs_up_read(&F2FS_I(inode)->i_sem);
 
        if (cp_reason) {
                /* all the dirty node pages should be flushed for POR */
@@ -958,7 +958,7 @@ int f2fs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
                                return err;
                }
 
-               down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+               f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                filemap_invalidate_lock(inode->i_mapping);
 
                truncate_setsize(inode, attr->ia_size);
@@ -970,7 +970,7 @@ int f2fs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
                 * larger than i_size.
                 */
                filemap_invalidate_unlock(inode->i_mapping);
-               up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+               f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                if (err)
                        return err;
 
@@ -1112,7 +1112,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
                        blk_start = (loff_t)pg_start << PAGE_SHIFT;
                        blk_end = (loff_t)pg_end << PAGE_SHIFT;
 
-                       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+                       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                        filemap_invalidate_lock(inode->i_mapping);
 
                        truncate_pagecache_range(inode, blk_start, blk_end - 1);
@@ -1122,7 +1122,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
                        f2fs_unlock_op(sbi);
 
                        filemap_invalidate_unlock(inode->i_mapping);
-                       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+                       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                }
        }
 
@@ -1355,7 +1355,7 @@ static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
        f2fs_balance_fs(sbi, true);
 
        /* avoid gc operation during block exchange */
-       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        filemap_invalidate_lock(inode->i_mapping);
 
        f2fs_lock_op(sbi);
@@ -1365,7 +1365,7 @@ static int f2fs_do_collapse(struct inode *inode, loff_t offset, loff_t len)
        f2fs_unlock_op(sbi);
 
        filemap_invalidate_unlock(inode->i_mapping);
-       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        return ret;
 }
 
@@ -1500,7 +1500,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
                        unsigned int end_offset;
                        pgoff_t end;
 
-                       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+                       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                        filemap_invalidate_lock(mapping);
 
                        truncate_pagecache_range(inode,
@@ -1514,7 +1514,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
                        if (ret) {
                                f2fs_unlock_op(sbi);
                                filemap_invalidate_unlock(mapping);
-                               up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+                               f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                                goto out;
                        }
 
@@ -1526,7 +1526,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
 
                        f2fs_unlock_op(sbi);
                        filemap_invalidate_unlock(mapping);
-                       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+                       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 
                        f2fs_balance_fs(sbi, dn.node_changed);
 
@@ -1600,7 +1600,7 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
        idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
 
        /* avoid gc operation during block exchange */
-       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        filemap_invalidate_lock(mapping);
        truncate_pagecache(inode, offset);
 
@@ -1618,7 +1618,7 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
                f2fs_unlock_op(sbi);
        }
        filemap_invalidate_unlock(mapping);
-       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 
        /* write out all moved pages, if possible */
        filemap_invalidate_lock(mapping);
@@ -1674,13 +1674,13 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
 next_alloc:
                if (has_not_enough_free_secs(sbi, 0,
                        GET_SEC_FROM_SEG(sbi, overprovision_segments(sbi)))) {
-                       down_write(&sbi->gc_lock);
+                       f2fs_down_write(&sbi->gc_lock);
                        err = f2fs_gc(sbi, true, false, false, NULL_SEGNO);
                        if (err && err != -ENODATA && err != -EAGAIN)
                                goto out_err;
                }
 
-               down_write(&sbi->pin_sem);
+               f2fs_down_write(&sbi->pin_sem);
 
                f2fs_lock_op(sbi);
                f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
@@ -1690,7 +1690,7 @@ next_alloc:
                err = f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);
                file_dont_truncate(inode);
 
-               up_write(&sbi->pin_sem);
+               f2fs_up_write(&sbi->pin_sem);
 
                expanded += map.m_len;
                sec_len -= map.m_len;
@@ -2020,7 +2020,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
        if (ret)
                goto out;
 
-       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 
        /*
         * Should wait end_io to count F2FS_WB_CP_DATA correctly by
@@ -2031,7 +2031,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
                          inode->i_ino, get_dirty_pages(inode));
        ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
        if (ret) {
-               up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+               f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                goto out;
        }
 
@@ -2044,7 +2044,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
        /* add inode in inmem_list first and set atomic_file */
        set_inode_flag(inode, FI_ATOMIC_FILE);
        clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
-       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 
        f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        F2FS_I(inode)->inmem_task = current;
@@ -2351,7 +2351,7 @@ static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
        if (err)
                return err;
 
-       down_write(&sbi->sb_lock);
+       f2fs_down_write(&sbi->sb_lock);
 
        if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))
                goto got_it;
@@ -2370,7 +2370,7 @@ got_it:
                                                                        16))
                err = -EFAULT;
 out_err:
-       up_write(&sbi->sb_lock);
+       f2fs_up_write(&sbi->sb_lock);
        mnt_drop_write_file(filp);
        return err;
 }
@@ -2447,12 +2447,12 @@ static int f2fs_ioc_gc(struct file *filp, unsigned long arg)
                return ret;
 
        if (!sync) {
-               if (!down_write_trylock(&sbi->gc_lock)) {
+               if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
                        ret = -EBUSY;
                        goto out;
                }
        } else {
-               down_write(&sbi->gc_lock);
+               f2fs_down_write(&sbi->gc_lock);
        }
 
        ret = f2fs_gc(sbi, sync, true, false, NULL_SEGNO);
@@ -2483,12 +2483,12 @@ static int __f2fs_ioc_gc_range(struct file *filp, struct f2fs_gc_range *range)
 
 do_more:
        if (!range->sync) {
-               if (!down_write_trylock(&sbi->gc_lock)) {
+               if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
                        ret = -EBUSY;
                        goto out;
                }
        } else {
-               down_write(&sbi->gc_lock);
+               f2fs_down_write(&sbi->gc_lock);
        }
 
        ret = f2fs_gc(sbi, range->sync, true, false,
@@ -2820,10 +2820,10 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
 
        f2fs_balance_fs(sbi, true);
 
-       down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
        if (src != dst) {
                ret = -EBUSY;
-               if (!down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
+               if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))
                        goto out_src;
        }
 
@@ -2841,9 +2841,9 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
        f2fs_unlock_op(sbi);
 
        if (src != dst)
-               up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
+               f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);
 out_src:
-       up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(src)->i_gc_rwsem[WRITE]);
 out_unlock:
        if (src != dst)
                inode_unlock(dst);
@@ -2938,7 +2938,7 @@ static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
        end_segno = min(start_segno + range.segments, dev_end_segno);
 
        while (start_segno < end_segno) {
-               if (!down_write_trylock(&sbi->gc_lock)) {
+               if (!f2fs_down_write_trylock(&sbi->gc_lock)) {
                        ret = -EBUSY;
                        goto out;
                }
@@ -3215,9 +3215,9 @@ int f2fs_precache_extents(struct inode *inode)
        while (map.m_lblk < end) {
                map.m_len = end - map.m_lblk;
 
-               down_write(&fi->i_gc_rwsem[WRITE]);
+               f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
                err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
-               up_write(&fi->i_gc_rwsem[WRITE]);
+               f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
                if (err)
                        return err;
 
@@ -3294,11 +3294,11 @@ static int f2fs_ioc_getfslabel(struct file *filp, unsigned long arg)
        if (!vbuf)
                return -ENOMEM;
 
-       down_read(&sbi->sb_lock);
+       f2fs_down_read(&sbi->sb_lock);
        count = utf16s_to_utf8s(sbi->raw_super->volume_name,
                        ARRAY_SIZE(sbi->raw_super->volume_name),
                        UTF16_LITTLE_ENDIAN, vbuf, MAX_VOLUME_NAME);
-       up_read(&sbi->sb_lock);
+       f2fs_up_read(&sbi->sb_lock);
 
        if (copy_to_user((char __user *)arg, vbuf,
                                min(FSLABEL_MAX, count)))
@@ -3326,7 +3326,7 @@ static int f2fs_ioc_setfslabel(struct file *filp, unsigned long arg)
        if (err)
                goto out;
 
-       down_write(&sbi->sb_lock);
+       f2fs_down_write(&sbi->sb_lock);
 
        memset(sbi->raw_super->volume_name, 0,
                        sizeof(sbi->raw_super->volume_name));
@@ -3336,7 +3336,7 @@ static int f2fs_ioc_setfslabel(struct file *filp, unsigned long arg)
 
        err = f2fs_commit_super(sbi, false);
 
-       up_write(&sbi->sb_lock);
+       f2fs_up_write(&sbi->sb_lock);
 
        mnt_drop_write_file(filp);
 out:
@@ -3462,7 +3462,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
        if (!atomic_read(&F2FS_I(inode)->i_compr_blocks))
                goto out;
 
-       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        filemap_invalidate_lock(inode->i_mapping);
 
        last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
@@ -3499,7 +3499,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
        }
 
        filemap_invalidate_unlock(inode->i_mapping);
-       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 out:
        inode_unlock(inode);
 
@@ -3615,7 +3615,7 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
                goto unlock_inode;
        }
 
-       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        filemap_invalidate_lock(inode->i_mapping);
 
        last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
@@ -3652,7 +3652,7 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
        }
 
        filemap_invalidate_unlock(inode->i_mapping);
-       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 
        if (ret >= 0) {
                clear_inode_flag(inode, FI_COMPRESS_RELEASED);
@@ -3770,7 +3770,7 @@ static int f2fs_sec_trim_file(struct file *filp, unsigned long arg)
        if (ret)
                goto err;
 
-       down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        filemap_invalidate_lock(mapping);
 
        ret = filemap_write_and_wait_range(mapping, range.start,
@@ -3859,7 +3859,7 @@ static int f2fs_sec_trim_file(struct file *filp, unsigned long arg)
                                prev_block, len, range.flags);
 out:
        filemap_invalidate_unlock(mapping);
-       up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+       f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
 err:
        inode_unlock(inode);
        file_end_write(filp);
@@ -4291,12 +4291,12 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
        trace_f2fs_direct_IO_enter(inode, iocb, count, READ);
 
        if (iocb->ki_flags & IOCB_NOWAIT) {
-               if (!down_read_trylock(&fi->i_gc_rwsem[READ])) {
+               if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
                        ret = -EAGAIN;
                        goto out;
                }
        } else {
-               down_read(&fi->i_gc_rwsem[READ]);
+               f2fs_down_read(&fi->i_gc_rwsem[READ]);
        }
 
        /*
@@ -4315,7 +4315,7 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
                ret = iomap_dio_complete(dio);
        }
 
-       up_read(&fi->i_gc_rwsem[READ]);
+       f2fs_up_read(&fi->i_gc_rwsem[READ]);
 
        file_accessed(file);
 out:
@@ -4497,12 +4497,12 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,
                        goto out;
                }
 
-               if (!down_read_trylock(&fi->i_gc_rwsem[WRITE])) {
+               if (!f2fs_down_read_trylock(&fi->i_gc_rwsem[WRITE])) {
                        ret = -EAGAIN;
                        goto out;
                }
-               if (do_opu && !down_read_trylock(&fi->i_gc_rwsem[READ])) {
-                       up_read(&fi->i_gc_rwsem[WRITE]);
+               if (do_opu && !f2fs_down_read_trylock(&fi->i_gc_rwsem[READ])) {
+                       f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
                        ret = -EAGAIN;
                        goto out;
                }
@@ -4511,9 +4511,9 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,
                if (ret)
                        goto out;
 
-               down_read(&fi->i_gc_rwsem[WRITE]);
+               f2fs_down_read(&fi->i_gc_rwsem[WRITE]);
                if (do_opu)
-                       down_read(&fi->i_gc_rwsem[READ]);
+                       f2fs_down_read(&fi->i_gc_rwsem[READ]);
        }
        if (whint_mode == WHINT_MODE_OFF)
                iocb->ki_hint = WRITE_LIFE_NOT_SET;
@@ -4542,8 +4542,8 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,
        if (whint_mode == WHINT_MODE_OFF)
                iocb->ki_hint = hint;
        if (do_opu)
-               up_read(&fi->i_gc_rwsem[READ]);
-       up_read(&fi->i_gc_rwsem[WRITE]);
+               f2fs_up_read(&fi->i_gc_rwsem[READ]);
+       f2fs_up_read(&fi->i_gc_rwsem[WRITE]);
 
        if (ret < 0)
                goto out;
@@ -4644,12 +4644,12 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 
        /* Don't leave any preallocated blocks around past i_size. */
        if (preallocated && i_size_read(inode) < target_size) {
-               down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+               f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
                filemap_invalidate_lock(inode->i_mapping);
                if (!f2fs_truncate(inode))
                        file_dont_truncate(inode);
                filemap_invalidate_unlock(inode->i_mapping);
-               up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
+               f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
        } else {
                file_dont_truncate(inode);
        }