Lines Matching refs:inode
37 #include "inode.h"
52 static int ocfs2_init_file_private(struct inode *inode, struct file *file)
68 static void ocfs2_free_file_private(struct inode *inode, struct file *file)
71 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
81 static int ocfs2_file_open(struct inode *inode, struct file *file)
85 struct ocfs2_inode_info *oi = OCFS2_I(inode);
87 trace_ocfs2_file_open(inode, file, file->f_path.dentry,
93 status = dquot_initialize(inode);
100 /* Check that the inode hasn't been wiped from disk by another
116 status = ocfs2_init_file_private(inode, file);
133 static int ocfs2_file_release(struct inode *inode, struct file *file)
135 struct ocfs2_inode_info *oi = OCFS2_I(inode);
141 trace_ocfs2_file_release(inode, file, file->f_path.dentry,
148 ocfs2_free_file_private(inode, file);
153 static int ocfs2_dir_open(struct inode *inode, struct file *file)
155 return ocfs2_init_file_private(inode, file);
158 static int ocfs2_dir_release(struct inode *inode, struct file *file)
160 ocfs2_free_file_private(inode, file);
168 struct inode *inode = file->f_mapping->host;
169 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
170 struct ocfs2_inode_info *oi = OCFS2_I(inode);
176 trace_ocfs2_sync_file(inode, file, file->f_path.dentry,
195 ret = blkdev_issue_flush(inode->i_sb->s_bdev);
206 int ocfs2_should_update_atime(struct inode *inode,
210 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
215 if ((inode->i_flags & S_NOATIME) ||
216 ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode)))
231 ((vfsmnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
235 struct timespec64 ctime = inode_get_ctime(inode);
237 if ((timespec64_compare(&inode->i_atime, &inode->i_mtime) <= 0) ||
238 (timespec64_compare(&inode->i_atime, &ctime) <= 0))
244 now = current_time(inode);
245 if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
251 int ocfs2_update_inode_atime(struct inode *inode,
255 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
266 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
276 * inode fields.
278 inode->i_atime = current_time(inode);
279 di->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
280 di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
281 ocfs2_update_inode_fsync_trans(handle, inode, 0);
291 struct inode *inode,
297 i_size_write(inode, new_i_size);
298 inode->i_blocks = ocfs2_inode_sector_count(inode);
299 inode->i_mtime = inode_set_ctime_current(inode);
301 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
311 int ocfs2_simple_size_update(struct inode *inode,
316 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
326 ret = ocfs2_set_inode_size(handle, inode, di_bh,
331 ocfs2_update_inode_fsync_trans(handle, inode, 0);
337 static int ocfs2_cow_file_pos(struct inode *inode,
342 u32 phys, cpos = offset >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
351 if ((offset & (OCFS2_SB(inode->i_sb)->s_clustersize - 1)) == 0)
354 status = ocfs2_get_clusters(inode, cpos, &phys,
364 return ocfs2_refcount_cow(inode, fe_bh, cpos, 1, cpos+1);
371 struct inode *inode,
385 status = ocfs2_cow_file_pos(inode, fe_bh, new_i_size);
391 /* TODO: This needs to actually orphan the inode in this
401 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
411 cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size);
412 status = ocfs2_zero_range_for_truncate(inode, handle, new_i_size,
419 i_size_write(inode, new_i_size);
420 inode->i_mtime = inode_set_ctime_current(inode);
424 di->i_ctime = di->i_mtime = cpu_to_le64(inode_get_ctime(inode).tv_sec);
425 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode_get_ctime(inode).tv_nsec);
426 ocfs2_update_inode_fsync_trans(handle, inode, 0);
436 int ocfs2_truncate_file(struct inode *inode,
442 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
448 trace_ocfs2_truncate_file((unsigned long long)OCFS2_I(inode)->ip_blkno,
452 mlog_bug_on_msg(le64_to_cpu(fe->i_size) != i_size_read(inode),
453 "Inode %llu, inode i_size = %lld != di "
455 (unsigned long long)OCFS2_I(inode)->ip_blkno,
456 i_size_read(inode),
469 down_write(&OCFS2_I(inode)->ip_alloc_sem);
472 &OCFS2_I(inode)->ip_la_data_resv);
475 * The inode lock forced other nodes to sync and drop their
482 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
483 unmap_mapping_range(inode->i_mapping,
485 truncate_inode_pages(inode->i_mapping, new_i_size);
486 status = ocfs2_truncate_inline(inode, di_bh, new_i_size,
487 i_size_read(inode), 1);
495 * change. Orphan the inode so that recovery can complete the
498 status = ocfs2_orphan_for_truncate(osb, inode, di_bh, new_i_size);
504 unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
505 truncate_inode_pages(inode->i_mapping, new_i_size);
507 status = ocfs2_commit_truncate(osb, inode, di_bh);
515 up_write(&OCFS2_I(inode)->ip_alloc_sem);
518 if (!status && OCFS2_I(inode)->ip_clusters == 0)
519 status = ocfs2_try_remove_refcount_tree(inode, di_bh);
535 struct inode *inode,
547 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), fe_bh);
553 static int ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
566 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
576 status = ocfs2_read_inode_block(inode, &bh);
584 BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters);
586 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), bh);
587 status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
605 (unsigned long long)OCFS2_I(inode)->ip_blkno,
606 (unsigned long long)i_size_read(inode),
610 status = dquot_alloc_space_nodirty(inode,
619 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
626 prev_clusters = OCFS2_I(inode)->ip_clusters;
629 inode,
643 ocfs2_update_inode_fsync_trans(handle, inode, 1);
646 spin_lock(&OCFS2_I(inode)->ip_lock);
647 clusters_to_add -= (OCFS2_I(inode)->ip_clusters - prev_clusters);
648 spin_unlock(&OCFS2_I(inode)->ip_lock);
650 dquot_free_space(inode,
673 trace_ocfs2_extend_allocation_end(OCFS2_I(inode)->ip_blkno,
676 OCFS2_I(inode)->ip_clusters,
677 (unsigned long long)i_size_read(inode));
681 dquot_free_space(inode,
709 static handle_t *ocfs2_zero_start_ordered_transaction(struct inode *inode,
714 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
718 if (!ocfs2_should_order_data(inode))
728 ret = ocfs2_jbd2_inode_add_write(handle, inode, start_byte, length);
734 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
738 ocfs2_update_inode_fsync_trans(handle, inode, 1);
752 static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from,
755 struct address_space *mapping = inode->i_mapping;
765 BUG_ON(abs_from & (inode->i_blkbits - 1));
767 handle = ocfs2_zero_start_ordered_transaction(inode, di_bh,
789 (unsigned long long)OCFS2_I(inode)->ip_blkno,
797 block_end = block_start + i_blocksize(inode);
818 * whose offset are over inode size, the release happens at
821 i_size_write(inode, abs_to);
822 inode->i_blocks = ocfs2_inode_sector_count(inode);
823 di->i_size = cpu_to_le64((u64)i_size_read(inode));
824 inode->i_mtime = inode_set_ctime_current(inode);
825 di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
826 di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
830 ocfs2_update_inode_fsync_trans(handle, inode, 1);
838 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
855 static int ocfs2_zero_extend_get_range(struct inode *inode,
863 zero_start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
864 u32 last_cpos = ocfs2_clusters_for_bytes(inode->i_sb, zero_end);
869 rc = ocfs2_get_clusters(inode, zero_cpos, &p_cpos,
891 rc = ocfs2_get_clusters(inode, zero_cpos + zero_clusters,
909 rc = ocfs2_refcount_cow(inode, di_bh, zero_cpos,
917 *range_start = ocfs2_clusters_to_bytes(inode->i_sb, zero_cpos);
918 *range_end = ocfs2_clusters_to_bytes(inode->i_sb,
929 static int ocfs2_zero_extend_range(struct inode *inode, u64 range_start,
937 (unsigned long long)OCFS2_I(inode)->ip_blkno,
946 rc = ocfs2_write_zero_page(inode, zero_pos, next_pos, di_bh);
963 int ocfs2_zero_extend(struct inode *inode, struct buffer_head *di_bh,
968 struct super_block *sb = inode->i_sb;
970 zero_start = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode));
971 trace_ocfs2_zero_extend((unsigned long long)OCFS2_I(inode)->ip_blkno,
973 (unsigned long long)i_size_read(inode));
975 ret = ocfs2_zero_extend_get_range(inode, di_bh, zero_start,
991 ret = ocfs2_zero_extend_range(inode, range_start,
1003 int ocfs2_extend_no_holes(struct inode *inode, struct buffer_head *di_bh,
1008 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1014 BUG_ON(!di_bh && ocfs2_is_refcount_inode(inode));
1017 clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size);
1024 ret = ocfs2_extend_allocation(inode, oi->ip_clusters,
1037 ret = ocfs2_zero_extend(inode, di_bh, zero_to);
1045 static int ocfs2_extend_file(struct inode *inode,
1050 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1058 if (i_size_read(inode) == new_i_size)
1060 BUG_ON(new_i_size < i_size_read(inode));
1081 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
1089 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
1090 ret = ocfs2_zero_extend(inode, di_bh, new_i_size);
1092 ret = ocfs2_extend_no_holes(inode, di_bh, new_i_size,
1103 ret = ocfs2_simple_size_update(inode, di_bh, new_i_size);
1116 struct inode *inode = d_inode(dentry);
1117 struct super_block *sb = inode->i_sb;
1126 trace_ocfs2_setattr(inode, dentry,
1127 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1134 if (S_ISLNK(inode->i_mode))
1146 if (is_quota_modification(&nop_mnt_idmap, inode, attr)) {
1147 status = dquot_initialize(inode);
1151 size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
1154 * Here we should wait dio to finish before inode lock
1158 inode_dio_wait(inode);
1160 status = ocfs2_rw_lock(inode, 1);
1167 had_lock = ocfs2_inode_lock_tracker(inode, &bh, 1, &oh);
1195 status = inode_newsize_ok(inode, attr->ia_size);
1199 if (i_size_read(inode) >= attr->ia_size) {
1200 if (ocfs2_should_order_data(inode)) {
1201 status = ocfs2_begin_ordered_truncate(inode,
1206 status = ocfs2_truncate_file(inode, bh, attr->ia_size);
1208 status = ocfs2_extend_file(inode, bh, attr->ia_size);
1217 if ((attr->ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
1218 (attr->ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
1224 if (attr->ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)
1234 if (attr->ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid)
1244 down_write(&OCFS2_I(inode)->ip_alloc_sem);
1252 status = __dquot_transfer(inode, transfer_to);
1256 down_write(&OCFS2_I(inode)->ip_alloc_sem);
1265 setattr_copy(&nop_mnt_idmap, inode, attr);
1266 mark_inode_dirty(inode);
1268 status = ocfs2_mark_inode_dirty(handle, inode, bh);
1275 up_write(&OCFS2_I(inode)->ip_alloc_sem);
1278 ocfs2_inode_unlock_tracker(inode, 1, &oh, had_lock);
1283 ocfs2_rw_unlock(inode, 1);
1291 status = ocfs2_acl_chmod(inode, bh);
1296 ocfs2_inode_unlock_tracker(inode, 1, &oh, had_lock);
1305 struct inode *inode = d_inode(path->dentry);
1317 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
1319 * If there is inline data in the inode, the inode will normally not
1324 if (unlikely(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
1334 int ocfs2_permission(struct mnt_idmap *idmap, struct inode *inode,
1343 had_lock = ocfs2_inode_lock_tracker(inode, NULL, 0, &oh);
1360 ret = generic_permission(&nop_mnt_idmap, inode, mask);
1362 ocfs2_inode_unlock_tracker(inode, 0, &oh, had_lock);
1367 static int __ocfs2_write_remove_suid(struct inode *inode,
1372 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1376 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1377 inode->i_mode);
1386 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
1393 inode->i_mode &= ~S_ISUID;
1394 if ((inode->i_mode & S_ISGID) && (inode->i_mode & S_IXGRP))
1395 inode->i_mode &= ~S_ISGID;
1398 di->i_mode = cpu_to_le16(inode->i_mode);
1399 ocfs2_update_inode_fsync_trans(handle, inode, 0);
1409 static int ocfs2_write_remove_suid(struct inode *inode)
1414 ret = ocfs2_read_inode_block(inode, &bh);
1420 ret = __ocfs2_write_remove_suid(inode, bh);
1431 static int ocfs2_allocate_unwritten_extents(struct inode *inode,
1439 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1440 ret = ocfs2_read_inode_block(inode, &di_bh);
1448 * fits within the inode.
1453 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
1463 cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
1464 clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len);
1468 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1490 ret = ocfs2_extend_allocation(inode, cpos, alloc_size, 1);
1513 static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start,
1516 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1518 struct address_space *mapping = inode->i_mapping;
1520 start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start);
1537 static int ocfs2_zeroout_partial_cluster(struct inode *inode,
1544 struct super_block *sb = inode->i_sb;
1557 ret = ocfs2_get_clusters(inode, cluster, &p_cluster,
1569 static int ocfs2_zero_partial_clusters(struct inode *inode,
1575 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1578 loff_t isize = i_size_read(inode);
1588 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1609 ret = ocfs2_zeroout_partial_cluster(inode, isize,
1647 ret = ocfs2_zero_range_for_truncate(inode, handle, start,
1664 ret = ocfs2_zero_range_for_truncate(inode, handle, start, end);
1668 ocfs2_update_inode_fsync_trans(handle, inode, 1);
1699 static void ocfs2_calc_trunc_pos(struct inode *inode,
1738 ocfs2_clusters_to_blocks(inode->i_sb, coff);
1755 int ocfs2_remove_inode_range(struct inode *inode,
1762 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1764 struct address_space *mapping = inode->i_mapping;
1772 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
1776 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1783 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1784 ret = ocfs2_truncate_inline(inode, di_bh, byte_start,
1792 * truncate of an inline-data inode. We're talking
1807 if (ocfs2_is_refcount_inode(inode)) {
1808 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start);
1814 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start + byte_len);
1825 ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len);
1840 ret = ocfs2_find_path(INODE_CACHE(inode), path,
1857 ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
1885 ocfs2_calc_trunc_pos(inode, el, rec, trunc_start, &trunc_cpos,
1891 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
1893 ret = ocfs2_remove_btree_range(inode, &et, trunc_cpos,
1906 ocfs2_truncate_cluster_pages(inode, byte_start, byte_len);
1919 static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
1927 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1930 unsigned long long max_off = inode->i_sb->s_maxbytes;
1935 inode_lock(inode);
1940 ret = ocfs2_rw_lock(inode, 1);
1946 ret = ocfs2_inode_lock(inode, &di_bh, 1);
1952 if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
1964 sr->l_start += i_size_read(inode);
1992 ret = __ocfs2_write_remove_suid(inode, di_bh);
1999 down_write(&OCFS2_I(inode)->ip_alloc_sem);
2007 ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start,
2012 ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start,
2019 orig_isize = i_size_read(inode);
2022 ret = ocfs2_zeroout_partial_cluster(inode, orig_isize,
2025 i_size_write(inode, size);
2027 up_write(&OCFS2_I(inode)->ip_alloc_sem);
2043 inode->i_mtime = inode_set_ctime_current(inode);
2044 ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
2055 ocfs2_inode_unlock(inode, 1);
2057 ocfs2_rw_unlock(inode, 1);
2060 inode_unlock(inode);
2067 struct inode *inode = file_inode(file);
2068 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2078 if (!S_ISREG(inode->i_mode))
2087 ret = __ocfs2_change_file_space(file, inode, file->f_pos, cmd, sr, 0);
2095 struct inode *inode = file_inode(file);
2096 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2110 ret = inode_newsize_ok(inode, offset + len);
2122 return __ocfs2_change_file_space(NULL, inode, offset, cmd, &sr,
2126 int ocfs2_check_range_for_refcount(struct inode *inode, loff_t pos,
2132 struct super_block *sb = inode->i_sb;
2134 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)) ||
2135 !ocfs2_is_refcount_inode(inode) ||
2136 OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
2143 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
2165 static int ocfs2_is_io_unaligned(struct inode *inode, size_t count, loff_t pos)
2167 int blockmask = inode->i_sb->s_blocksize - 1;
2175 static int ocfs2_inode_lock_for_extent_tree(struct inode *inode,
2184 ret = ocfs2_inode_lock(inode, di_bh, meta_level);
2186 ret = ocfs2_try_inode_lock(inode, di_bh, meta_level);
2192 down_write(&OCFS2_I(inode)->ip_alloc_sem);
2194 down_read(&OCFS2_I(inode)->ip_alloc_sem);
2197 ret = down_write_trylock(&OCFS2_I(inode)->ip_alloc_sem);
2199 ret = down_read_trylock(&OCFS2_I(inode)->ip_alloc_sem);
2212 ocfs2_inode_unlock(inode, meta_level);
2217 static void ocfs2_inode_unlock_for_extent_tree(struct inode *inode,
2223 up_write(&OCFS2_I(inode)->ip_alloc_sem);
2225 up_read(&OCFS2_I(inode)->ip_alloc_sem);
2231 ocfs2_inode_unlock(inode, meta_level);
2240 struct inode *inode = d_inode(dentry);
2250 ret = ocfs2_inode_lock_for_extent_tree(inode,
2268 ret = ocfs2_overwrite_io(inode, di_bh, pos, count);
2282 * inode. There's also the dinode i_size state which
2284 * set inode->i_size at the end of a write. */
2285 if (setattr_should_drop_suidgid(&nop_mnt_idmap, inode)) {
2287 ocfs2_inode_unlock_for_extent_tree(inode,
2295 ret = ocfs2_write_remove_suid(inode);
2302 ret = ocfs2_check_range_for_refcount(inode, pos, count);
2304 ocfs2_inode_unlock_for_extent_tree(inode,
2310 ret = ocfs2_inode_lock_for_extent_tree(inode,
2321 cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
2323 ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos;
2324 ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
2337 trace_ocfs2_prepare_inode_for_write(OCFS2_I(inode)->ip_blkno,
2340 ocfs2_inode_unlock_for_extent_tree(inode,
2357 struct inode *inode = file_inode(file);
2358 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2363 i_size_read(inode) ? 1 : 0);
2367 trace_ocfs2_file_write_iter(inode, file, file->f_path.dentry,
2368 (unsigned long long)OCFS2_I(inode)->ip_blkno,
2380 if (!inode_trylock(inode))
2383 inode_lock(inode);
2393 ret = ocfs2_try_rw_lock(inode, rw_level);
2395 ret = ocfs2_rw_lock(inode, rw_level);
2408 * We need to take and drop the inode lock to force
2413 ret = ocfs2_try_inode_lock(inode, NULL, 1);
2415 ret = ocfs2_inode_lock(inode, NULL, 1);
2422 ocfs2_inode_unlock(inode, 1);
2441 ocfs2_is_io_unaligned(inode, count, iocb->ki_pos)) {
2472 IS_SYNC(inode)) {
2496 ocfs2_rw_unlock(inode, rw_level);
2499 inode_unlock(inode);
2511 struct inode *inode = file_inode(filp);
2515 trace_ocfs2_file_read_iter(inode, filp, filp->f_path.dentry,
2516 (unsigned long long)OCFS2_I(inode)->ip_blkno,
2522 if (!inode) {
2537 ret = ocfs2_try_rw_lock(inode, 0);
2539 ret = ocfs2_rw_lock(inode, 0);
2556 * Take and drop the meta data lock to update inode fields
2560 ret = ocfs2_inode_lock_atime(inode, filp->f_path.mnt, &lock_level,
2567 ocfs2_inode_unlock(inode, lock_level);
2582 ocfs2_rw_unlock(inode, rw_level);
2591 struct inode *inode = file_inode(in);
2595 trace_ocfs2_file_splice_read(inode, in, in->f_path.dentry,
2596 (unsigned long long)OCFS2_I(inode)->ip_blkno,
2606 * Take and drop the meta data lock to update inode fields like i_size.
2610 ret = ocfs2_inode_lock_atime(inode, in->f_path.mnt, &lock_level, 1);
2616 ocfs2_inode_unlock(inode, lock_level);
2627 struct inode *inode = file->f_mapping->host;
2630 inode_lock(inode);
2636 /* SEEK_END requires the OCFS2 inode lock for the file
2639 ret = ocfs2_inode_lock(inode, NULL, 0);
2644 offset += i_size_read(inode);
2645 ocfs2_inode_unlock(inode, 0);
2665 offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
2668 inode_unlock(inode);
2678 struct inode *inode_in = file_inode(file_in);
2679 struct inode *inode_out = file_inode(file_out);