Lines Matching refs:inode
3 * inode.c
30 #include "inode.h"
55 static int ocfs2_read_locked_inode(struct inode *inode,
57 static int ocfs2_init_locked_inode(struct inode *inode, void *opaque);
58 static int ocfs2_find_actor(struct inode *inode, void *opaque);
60 struct inode *inode,
63 static int ocfs2_filecheck_read_inode_block_full(struct inode *inode,
71 void ocfs2_set_inode_flags(struct inode *inode)
73 unsigned int flags = OCFS2_I(inode)->ip_attr;
75 inode->i_flags &= ~(S_IMMUTABLE |
79 inode->i_flags |= S_IMMUTABLE;
82 inode->i_flags |= S_SYNC;
84 inode->i_flags |= S_APPEND;
86 inode->i_flags |= S_NOATIME;
88 inode->i_flags |= S_DIRSYNC;
91 /* Propagate flags from i_flags to OCFS2_I(inode)->ip_attr */
110 struct inode *ocfs2_ilookup(struct super_block *sb, u64 blkno)
121 struct inode *ocfs2_iget(struct ocfs2_super *osb, u64 blkno, unsigned flags,
125 struct inode *inode = NULL;
137 inode = ERR_PTR(-EINVAL);
138 mlog_errno(PTR_ERR(inode));
147 inode = iget5_locked(sb, args.fi_ino, ocfs2_find_actor,
149 /* inode was *not* in the inode cache. 2.6.x requires
152 if (inode == NULL) {
153 inode = ERR_PTR(-ENOMEM);
154 mlog_errno(PTR_ERR(inode));
157 trace_ocfs2_iget5_locked(inode->i_state);
158 if (inode->i_state & I_NEW) {
159 rc = ocfs2_read_locked_inode(inode, &args);
160 unlock_new_inode(inode);
162 if (is_bad_inode(inode)) {
163 iput(inode);
164 inode = ERR_PTR(rc);
171 * as we cannot be sure that the inode or some of its metadata isn't
172 * part of the transaction - the inode could have been reclaimed and
178 struct ocfs2_inode_info *oi = OCFS2_I(inode);
195 if (!IS_ERR(inode)) {
196 trace_ocfs2_iget_end(inode,
197 (unsigned long long)OCFS2_I(inode)->ip_blkno);
200 return inode;
207 * found? : return the in-memory inode
211 static int ocfs2_find_actor(struct inode *inode, void *opaque)
214 struct ocfs2_inode_info *oi = OCFS2_I(inode);
219 mlog_bug_on_msg(!inode, "No inode in find actor!\n");
221 trace_ocfs2_find_actor(inode, inode->i_ino, opaque, args->fi_blkno);
232 * initialize the new inode, but don't do anything that would cause
236 static int ocfs2_init_locked_inode(struct inode *inode, void *opaque)
242 inode->i_ino = args->fi_ino;
243 OCFS2_I(inode)->ip_blkno = args->fi_blkno;
245 lockdep_set_class(&inode->i_rwsem,
251 lockdep_set_class(&OCFS2_I(inode)->ip_alloc_sem,
254 lockdep_set_class(&OCFS2_I(inode)->ip_alloc_sem,
260 void ocfs2_populate_inode(struct inode *inode, struct ocfs2_dinode *fe,
267 sb = inode->i_sb;
280 inode today. change if
286 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
287 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
288 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features);
290 inode_set_iversion(inode, 1);
291 inode->i_generation = le32_to_cpu(fe->i_generation);
292 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
293 inode->i_mode = le16_to_cpu(fe->i_mode);
294 i_uid_write(inode, le32_to_cpu(fe->i_uid));
295 i_gid_write(inode, le32_to_cpu(fe->i_gid));
298 if (S_ISLNK(inode->i_mode) && !fe->i_clusters) {
299 inode->i_blocks = 0;
300 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops;
302 inode->i_blocks = ocfs2_inode_sector_count(inode);
303 inode->i_mapping->a_ops = &ocfs2_aops;
305 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
306 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
307 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
308 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
309 inode_set_ctime(inode, le64_to_cpu(fe->i_ctime),
312 if (OCFS2_I(inode)->ip_blkno != le64_to_cpu(fe->i_blkno))
315 (unsigned long long)OCFS2_I(inode)->ip_blkno,
318 set_nlink(inode, ocfs2_read_links_count(fe));
320 trace_ocfs2_populate_inode(OCFS2_I(inode)->ip_blkno,
323 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SYSTEM_FILE;
324 inode->i_flags |= S_NOQUOTA;
328 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
330 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_BITMAP;
332 inode->i_flags |= S_NOQUOTA;
339 switch (inode->i_mode & S_IFMT) {
342 inode->i_fop = &ocfs2_fops;
344 inode->i_fop = &ocfs2_fops_no_plocks;
345 inode->i_op = &ocfs2_file_iops;
346 i_size_write(inode, le64_to_cpu(fe->i_size));
349 inode->i_op = &ocfs2_dir_iops;
351 inode->i_fop = &ocfs2_dops;
353 inode->i_fop = &ocfs2_dops_no_plocks;
354 i_size_write(inode, le64_to_cpu(fe->i_size));
355 OCFS2_I(inode)->ip_dir_lock_gen = 1;
358 inode->i_op = &ocfs2_symlink_inode_operations;
359 inode_nohighmem(inode);
360 i_size_write(inode, le64_to_cpu(fe->i_size));
363 inode->i_op = &ocfs2_special_file_iops;
364 init_special_inode(inode, inode->i_mode,
365 inode->i_rdev);
370 inode->i_ino = ino_from_blkno(inode->i_sb,
380 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres,
381 OCFS2_LOCK_TYPE_META, 0, inode);
383 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres,
384 OCFS2_LOCK_TYPE_OPEN, 0, inode);
387 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_rw_lockres,
388 OCFS2_LOCK_TYPE_RW, inode->i_generation,
389 inode);
391 ocfs2_set_inode_flags(inode);
393 OCFS2_I(inode)->ip_last_used_slot = 0;
394 OCFS2_I(inode)->ip_last_used_group = 0;
396 if (S_ISDIR(inode->i_mode))
397 ocfs2_resv_set_type(&OCFS2_I(inode)->ip_la_data_resv,
401 static int ocfs2_read_locked_inode(struct inode *inode,
412 sb = inode->i_sb;
416 * To improve performance of cold-cache inode stats, we take
419 * Generally, OCFS2 never trusts the contents of an inode
449 (unsigned long long)OCFS2_I(inode)->ip_blkno, can_lock);
461 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_inode_lockres,
463 generation, inode);
465 ocfs2_inode_lock_res_init(&OCFS2_I(inode)->ip_open_lockres,
467 0, inode);
470 status = ocfs2_open_lock(inode);
472 make_bad_inode(inode);
476 status = ocfs2_inode_lock(inode, NULL, lock_level);
478 make_bad_inode(inode);
485 status = ocfs2_try_open_lock(inode, 0);
487 make_bad_inode(inode);
494 status = ocfs2_filecheck_read_inode_block_full(inode,
497 status = ocfs2_filecheck_read_inode_block_full(inode,
500 status = ocfs2_read_inode_block_full(inode,
530 * understand whether it is asking for a system file inode or
540 inode->i_rdev = huge_decode_dev(le64_to_cpu(fe->id1.dev1.i_rdev));
542 ocfs2_populate_inode(inode, fe, 0);
548 ocfs2_inode_unlock(inode, lock_level);
550 ocfs2_inode_lock(inode, NULL, lock_level);
552 status = ocfs2_write_block(osb, bh, INODE_CACHE(inode));
563 ocfs2_inode_unlock(inode, lock_level);
566 make_bad_inode(inode);
579 struct inode *inode,
593 if (ocfs2_should_order_data(inode))
594 ocfs2_begin_ordered_truncate(inode, 0);
604 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
612 i_size_write(inode, 0);
614 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
623 status = ocfs2_commit_truncate(osb, inode, fe_bh);
634 static int ocfs2_remove_inode(struct inode *inode,
636 struct inode *orphan_dir_inode,
640 struct inode *inode_alloc_inode = NULL;
643 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
665 ocfs2_quota_trans_credits(inode->i_sb));
672 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR)) {
673 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
682 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
693 ocfs2_remove_from_cache(INODE_CACHE(inode), di_bh);
694 dquot_free_inode(inode);
717 * and exit early - recovery will wipe this inode for us.
748 static int ocfs2_wipe_inode(struct inode *inode,
752 struct inode *orphan_dir_inode = NULL;
754 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
757 if (!(OCFS2_I(inode)->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR)) {
788 * inode delete underneath us -- this will result in two nodes
790 status = ocfs2_truncate_for_delete(osb, inode, di_bh);
797 if (S_ISDIR(inode->i_mode)) {
798 status = ocfs2_dx_dir_truncate(inode, di_bh);
805 /*Free extended attribute resources associated with this inode.*/
806 status = ocfs2_xattr_remove(inode, di_bh);
812 status = ocfs2_remove_refcount_tree(inode, di_bh);
818 status = ocfs2_remove_inode(inode, di_bh, orphan_dir_inode,
824 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SKIP_ORPHAN_DIR)
839 static int ocfs2_inode_is_valid_to_delete(struct inode *inode)
842 struct ocfs2_inode_info *oi = OCFS2_I(inode);
843 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
850 * inode.. */
851 if (inode == osb->root_inode) {
852 mlog(ML_ERROR, "Skipping delete of root inode.\n");
858 * voting [hello, deadlock city!] so we cannot delete the inode. But
859 * since we dropped last inode ref when downconverting dentry lock,
861 * take care of deleting the inode.
883 /* Query the cluster to determine whether we should wipe an inode from
886 * Requires the inode to have the cluster lock. */
887 static int ocfs2_query_inode_wipe(struct inode *inode,
892 struct ocfs2_inode_info *oi = OCFS2_I(inode);
898 inode->i_nlink);
902 * the inode. Recheck our flags to catch this. */
903 if (!ocfs2_inode_is_valid_to_delete(inode)) {
908 /* Now that we have an up to date inode, we can double check
910 if (inode->i_nlink)
913 /* Do some basic inode verification... */
934 "Disk flags 0x%x, inode flags 0x%x\n",
949 * This is how ocfs2 determines whether an inode is still live
951 * the inode open lock in ocfs2_read_locked_inode(). When we
953 * lock to an exclusive. Trylocks are serialized by the inode
954 * meta data lock. If the upconvert succeeds, we know the inode
960 status = ocfs2_try_open_lock(inode, 1);
980 * inode data in a consistent state for clear_inode. Always truncates
982 static void ocfs2_cleanup_delete_inode(struct inode *inode,
986 (unsigned long long)OCFS2_I(inode)->ip_blkno, sync_data);
988 filemap_write_and_wait(inode->i_mapping);
989 truncate_inode_pages_final(&inode->i_data);
992 static void ocfs2_delete_inode(struct inode *inode)
999 trace_ocfs2_delete_inode(inode->i_ino,
1000 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1001 is_bad_inode(inode));
1003 /* When we fail in read_inode() we mark inode as bad. The second test
1004 * catches the case when inode allocation fails before allocating
1005 * a block for inode. */
1006 if (is_bad_inode(inode) || !OCFS2_I(inode)->ip_blkno)
1009 if (!ocfs2_inode_is_valid_to_delete(inode)) {
1013 ocfs2_cleanup_delete_inode(inode, 0);
1017 dquot_initialize(inode);
1030 status = ocfs2_nfs_sync_lock(OCFS2_SB(inode->i_sb), 0);
1033 ocfs2_cleanup_delete_inode(inode, 0);
1036 /* Lock down the inode. This gives us an up to date view of
1044 status = ocfs2_inode_lock(inode, &di_bh, 1);
1048 ocfs2_cleanup_delete_inode(inode, 0);
1053 /* Skip inode deletion and wait for dio orphan entry recovered
1056 ocfs2_cleanup_delete_inode(inode, 0);
1061 * before we go ahead and wipe the inode. */
1062 status = ocfs2_query_inode_wipe(inode, di_bh, &wipe);
1064 /* Error and remote inode busy both mean we won't be
1065 * removing the inode, so they take almost the same
1071 * this inode, or it was never completely
1073 ocfs2_cleanup_delete_inode(inode, 1);
1077 ocfs2_cleanup_delete_inode(inode, 0);
1079 status = ocfs2_wipe_inode(inode, di_bh);
1087 * Mark the inode as successfully deleted.
1095 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_DELETED;
1098 ocfs2_inode_unlock(inode, 1);
1102 ocfs2_nfs_sync_unlock(OCFS2_SB(inode->i_sb), 0);
1110 static void ocfs2_clear_inode(struct inode *inode)
1113 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1114 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1116 clear_inode(inode);
1118 inode->i_nlink);
1121 "Inode=%lu\n", inode->i_ino);
1123 dquot_drop(inode);
1127 ocfs2_open_unlock(inode);
1146 ocfs2_checkpoint_inode(inode);
1149 "Clear inode of %llu, inode has io markers\n",
1152 "Clear inode of %llu, inode has unwritten extents\n",
1155 ocfs2_extent_map_trunc(inode, 0);
1157 status = ocfs2_drop_inode_locks(inode);
1165 ocfs2_metadata_cache_exit(INODE_CACHE(inode));
1167 mlog_bug_on_msg(INODE_CACHE(inode)->ci_num_cached,
1168 "Clear inode of %llu, inode has %u cache items\n",
1170 INODE_CACHE(inode)->ci_num_cached);
1172 mlog_bug_on_msg(!(INODE_CACHE(inode)->ci_flags & OCFS2_CACHE_FL_INLINE),
1173 "Clear inode of %llu, inode has a bad flag\n",
1177 "Clear inode of %llu, inode is locked\n",
1181 "Clear inode of %llu, io_mutex is locked\n",
1190 "Clear inode of %llu, alloc_sem is locked\n",
1195 "Clear inode of %llu has open count %d\n",
1204 * ip_jinode is used to track txns against this inode. We ensure that
1212 void ocfs2_evict_inode(struct inode *inode)
1214 if (!inode->i_nlink ||
1215 (OCFS2_I(inode)->ip_flags & OCFS2_INODE_MAYBE_ORPHANED)) {
1216 ocfs2_delete_inode(inode);
1218 truncate_inode_pages_final(&inode->i_data);
1220 ocfs2_clear_inode(inode);
1224 * struct inode, so it's safe here to check the flags field
1226 int ocfs2_drop_inode(struct inode *inode)
1228 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1231 inode->i_nlink, oi->ip_flags);
1233 assert_spin_locked(&inode->i_lock);
1234 inode->i_state |= I_WILL_FREE;
1235 spin_unlock(&inode->i_lock);
1236 write_inode_now(inode, 1);
1237 spin_lock(&inode->i_lock);
1238 WARN_ON(inode->i_state & I_NEW);
1239 inode->i_state &= ~I_WILL_FREE;
1249 struct inode *inode = d_inode(dentry);
1252 trace_ocfs2_inode_revalidate(inode,
1253 inode ? (unsigned long long)OCFS2_I(inode)->ip_blkno : 0ULL,
1254 inode ? (unsigned long long)OCFS2_I(inode)->ip_flags : 0);
1256 if (!inode) {
1261 spin_lock(&OCFS2_I(inode)->ip_lock);
1262 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
1263 spin_unlock(&OCFS2_I(inode)->ip_lock);
1267 spin_unlock(&OCFS2_I(inode)->ip_lock);
1270 * inode for us. */
1271 status = ocfs2_inode_lock(inode, NULL, 0);
1277 ocfs2_inode_unlock(inode, 0);
1283 * Updates a disk inode from a
1284 * struct inode.
1288 struct inode *inode,
1294 trace_ocfs2_mark_inode_dirty((unsigned long long)OCFS2_I(inode)->ip_blkno);
1296 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
1303 spin_lock(&OCFS2_I(inode)->ip_lock);
1304 fe->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
1305 ocfs2_get_inode_flags(OCFS2_I(inode));
1306 fe->i_attr = cpu_to_le32(OCFS2_I(inode)->ip_attr);
1307 fe->i_dyn_features = cpu_to_le16(OCFS2_I(inode)->ip_dyn_features);
1308 spin_unlock(&OCFS2_I(inode)->ip_lock);
1310 fe->i_size = cpu_to_le64(i_size_read(inode));
1311 ocfs2_set_links_count(fe, inode->i_nlink);
1312 fe->i_uid = cpu_to_le32(i_uid_read(inode));
1313 fe->i_gid = cpu_to_le32(i_gid_read(inode));
1314 fe->i_mode = cpu_to_le16(inode->i_mode);
1315 fe->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
1316 fe->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
1317 fe->i_ctime = cpu_to_le64(inode_get_ctime(inode).tv_sec);
1318 fe->i_ctime_nsec = cpu_to_le32(inode_get_ctime(inode).tv_nsec);
1319 fe->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
1320 fe->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
1323 ocfs2_update_inode_fsync_trans(handle, inode, 1);
1330 * Updates a struct inode from a disk inode.
1333 void ocfs2_refresh_inode(struct inode *inode,
1336 spin_lock(&OCFS2_I(inode)->ip_lock);
1338 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters);
1339 OCFS2_I(inode)->ip_attr = le32_to_cpu(fe->i_attr);
1340 OCFS2_I(inode)->ip_dyn_features = le16_to_cpu(fe->i_dyn_features);
1341 ocfs2_set_inode_flags(inode);
1342 i_size_write(inode, le64_to_cpu(fe->i_size));
1343 set_nlink(inode, ocfs2_read_links_count(fe));
1344 i_uid_write(inode, le32_to_cpu(fe->i_uid));
1345 i_gid_write(inode, le32_to_cpu(fe->i_gid));
1346 inode->i_mode = le16_to_cpu(fe->i_mode);
1347 if (S_ISLNK(inode->i_mode) && le32_to_cpu(fe->i_clusters) == 0)
1348 inode->i_blocks = 0;
1350 inode->i_blocks = ocfs2_inode_sector_count(inode);
1351 inode->i_atime.tv_sec = le64_to_cpu(fe->i_atime);
1352 inode->i_atime.tv_nsec = le32_to_cpu(fe->i_atime_nsec);
1353 inode->i_mtime.tv_sec = le64_to_cpu(fe->i_mtime);
1354 inode->i_mtime.tv_nsec = le32_to_cpu(fe->i_mtime_nsec);
1355 inode_set_ctime(inode, le64_to_cpu(fe->i_ctime),
1358 spin_unlock(&OCFS2_I(inode)->ip_lock);
1440 * inode number inputed.
1520 /* Cannot fix invalid inode block */
1562 ocfs2_filecheck_read_inode_block_full(struct inode *inode,
1569 if (!type) /* Check inode block */
1570 rc = ocfs2_read_blocks(INODE_CACHE(inode),
1571 OCFS2_I(inode)->ip_blkno,
1574 else /* Repair inode block */
1575 rc = ocfs2_read_blocks(INODE_CACHE(inode),
1576 OCFS2_I(inode)->ip_blkno,
1587 int ocfs2_read_inode_block_full(struct inode *inode, struct buffer_head **bh,
1593 rc = ocfs2_read_blocks(INODE_CACHE(inode), OCFS2_I(inode)->ip_blkno,
1603 int ocfs2_read_inode_block(struct inode *inode, struct buffer_head **bh)
1605 return ocfs2_read_inode_block_full(inode, bh, 0);