Lines Matching defs:inode
12 * linux/fs/minix/inode.c
87 static struct inode *ext4_get_journal_inode(struct super_block *sb,
93 * Note the difference between i_mmap_sem (EXT4_I(inode)->i_mmap_sem) and
94 * i_mmap_rwsem (inode->i_mmap_rwsem)!
430 struct inode *bd_inode = sb->s_bdev->bd_inode;
487 * inode range tracking is not exact) or if the currently running
760 void __ext4_error_inode(struct inode *inode, const char *function,
767 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
770 trace_ext4_error(inode->i_sb, function, line);
771 if (ext4_error_ratelimit(inode->i_sb)) {
777 "inode #%lu: block %llu: comm %s: %pV\n",
778 inode->i_sb->s_id, function, line, inode->i_ino,
782 "inode #%lu: comm %s: %pV\n",
783 inode->i_sb->s_id, function, line, inode->i_ino,
787 ext4_handle_error(inode->i_sb, false, error, inode->i_ino, block,
797 struct inode *inode = file_inode(file);
800 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
803 trace_ext4_error(inode->i_sb, function, line);
804 if (ext4_error_ratelimit(inode->i_sb)) {
813 "EXT4-fs error (device %s): %s:%d: inode #%lu: "
815 inode->i_sb->s_id, function, line, inode->i_ino,
819 "EXT4-fs error (device %s): %s:%d: inode #%lu: "
821 inode->i_sb->s_id, function, line, inode->i_ino,
825 ext4_handle_error(inode->i_sb, false, EFSCORRUPTED, inode->i_ino, block,
937 void __ext4_warning_inode(const struct inode *inode, const char *function,
943 if (!ext4_warning_ratelimit(inode->i_sb))
950 "inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
951 function, line, inode->i_ino, current->comm, &vaf);
976 printk(KERN_CONT "inode %lu: ", ino);
1112 static inline struct inode *orphan_list_entry(struct list_head *l)
1126 struct inode *inode = orphan_list_entry(l);
1128 "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
1129 inode->i_sb->s_id, inode->i_ino, inode,
1130 inode->i_mode, inode->i_nlink,
1131 NEXT_ORPHAN(inode));
1142 /* Use our quota_off function to clear inode flags etc. */
1235 /* Debugging code just in case the in-memory inode orphan list
1282 static struct inode *ext4_alloc_inode(struct super_block *sb)
1321 static int ext4_drop_inode(struct inode *inode)
1323 int drop = generic_drop_inode(inode);
1326 drop = fscrypt_drop_inode(inode);
1328 trace_ext4_drop_inode(inode, drop);
1332 static void ext4_free_in_core_inode(struct inode *inode)
1334 fscrypt_free_inode(inode);
1335 if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
1336 pr_warn("%s: inode %ld still in fc list",
1337 __func__, inode->i_ino);
1339 kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
1342 static void ext4_destroy_inode(struct inode *inode)
1344 if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
1345 ext4_msg(inode->i_sb, KERN_ERR,
1347 inode->i_ino, EXT4_I(inode));
1349 EXT4_I(inode), sizeof(struct ext4_inode_info),
1354 if (EXT4_I(inode)->i_reserved_data_blocks)
1355 ext4_msg(inode->i_sb, KERN_ERR,
1357 inode->i_ino, EXT4_I(inode),
1358 EXT4_I(inode)->i_reserved_data_blocks);
1397 void ext4_clear_inode(struct inode *inode)
1399 ext4_fc_del(inode);
1400 invalidate_inode_buffers(inode);
1401 clear_inode(inode);
1402 ext4_discard_preallocations(inode, 0);
1403 ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
1404 dquot_drop(inode);
1405 if (EXT4_I(inode)->jinode) {
1406 jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1407 EXT4_I(inode)->jinode);
1408 jbd2_free_inode(EXT4_I(inode)->jinode);
1409 EXT4_I(inode)->jinode = NULL;
1411 fscrypt_put_encryption_info(inode);
1412 fsverity_cleanup_inode(inode);
1415 static struct inode *ext4_nfs_get_inode(struct super_block *sb,
1418 struct inode *inode;
1424 inode = ext4_iget(sb, ino, EXT4_IGET_HANDLE);
1425 if (IS_ERR(inode))
1426 return ERR_CAST(inode);
1427 if (generation && inode->i_generation != generation) {
1428 iput(inode);
1432 return inode;
1449 static int ext4_nfs_commit_metadata(struct inode *inode)
1455 trace_ext4_nfs_commit_metadata(inode);
1456 return ext4_write_inode(inode, &wbc);
1460 static int ext4_get_context(struct inode *inode, void *ctx, size_t len)
1462 return ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
1466 static int ext4_set_context(struct inode *inode, const void *ctx, size_t len,
1478 if (inode->i_ino == EXT4_ROOT_INO)
1481 if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))
1484 if (ext4_test_inode_flag(inode, EXT4_INODE_DAX))
1487 res = ext4_convert_inline_data(inode);
1493 * being set on a new inode via inheritance and is part of a larger
1494 * transaction to create the inode. Otherwise the encryption context is
1495 * being set on an existing inode in its own transaction. Only in the
1500 res = ext4_xattr_set_handle(handle, inode,
1505 ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
1506 ext4_clear_inode_state(inode,
1509 * Update inode->i_flags - S_ENCRYPTED will be enabled,
1512 ext4_set_inode_flags(inode, false);
1517 res = dquot_initialize(inode);
1521 res = ext4_xattr_set_credits(inode, len, false /* is_create */,
1526 handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
1530 res = ext4_xattr_set_handle(handle, inode, EXT4_XATTR_INDEX_ENCRYPTION,
1534 ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
1536 * Update inode->i_flags - S_ENCRYPTED will be enabled,
1539 ext4_set_inode_flags(inode, false);
1540 res = ext4_mark_inode_dirty(handle, inode);
1542 EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
1546 if (res == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1602 static struct dquot **ext4_get_dquots(struct inode *inode)
1604 return EXT4_I(inode)->i_dquot;
1749 {Opt_dax_inode, "dax=inode"},
2259 struct inode *journal_inode;
2626 SEQ_OPTS_PUTS("dax=inode");
2973 * In order to keep the orphan inode chain consistent during traversal (in
2974 * case of crash during recovery), we link each inode into the superblock
2975 * orphan list_head and handle it the same way as an inode deletion during
2978 * We only do an iget() and an iput() on each inode, which is very safe if we
2979 * accidentally point at an in-use or already deleted inode. The worst that
2981 * ext4_free_inode(). The only reason we would point at a wrong inode is if
2983 * inode cleanup for us, so we can safely abort without any further action.
3058 struct inode *inode;
3070 inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
3071 if (IS_ERR(inode)) {
3076 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
3077 dquot_initialize(inode);
3078 if (inode->i_nlink) {
3081 "%s: truncating inode %lu to %lld bytes",
3082 __func__, inode->i_ino, inode->i_size);
3083 jbd_debug(2, "truncating inode %lu to %lld bytes\n",
3084 inode->i_ino, inode->i_size);
3085 inode_lock(inode);
3086 truncate_inode_pages(inode->i_mapping, inode->i_size);
3087 ret = ext4_truncate(inode);
3094 ext4_orphan_del(NULL, inode);
3095 ext4_std_error(inode->i_sb, ret);
3097 inode_unlock(inode);
3102 "%s: deleting unreferenced inode %lu",
3103 __func__, inode->i_ino);
3104 jbd_debug(2, "deleting unreferenced inode %lu\n",
3105 inode->i_ino);
3108 iput(inode); /* The delete magic happens here! */
3114 ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
3135 * in the vfs. ext4 inode has 48 bits of i_block in fsblock units,
3196 * !has_huge_files or implies that the inode i_block field
3198 * size of vfs inode i_blocks * 8
3387 printk(KERN_CONT ": inode %u",
3402 printk(KERN_CONT ": inode %u",
3636 printk(KERN_CRIT "EXT4-fs: error %d creating inode table "
3647 * If there is at least one uninitialized inode table, return
3709 * spread the inode table initialization requests
3913 struct inode *j_inode;
4013 struct inode *root;
4217 "unsupported inode size: %d",
4721 * set up enough so that it can read an inode
4777 * The first inode we look at is the journal inode. Don't try
4952 ext4_msg(sb, KERN_ERR, "get root inode failed");
4958 ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
5022 * Update the checksum after updating free space/inode
5243 static struct inode *ext4_get_journal_inode(struct super_block *sb,
5246 struct inode *journal_inode;
5249 * Test for the existence of a valid inode on disk. Bad things
5250 * happen if we iget() an unused inode, as the subsequent iput()
5261 ext4_msg(sb, KERN_ERR, "journal inode is deleted");
5265 jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
5268 ext4_msg(sb, KERN_ERR, "invalid journal inode");
5278 struct inode *journal_inode;
5290 ext4_msg(sb, KERN_ERR, "Could not load journal inode");
5417 "filesystem has both journal inode and journal device!");
6018 "orphan inode list. Please "
6238 static inline struct inode *dquot_to_inode(struct dquot *dquot)
6247 struct inode *inode;
6249 inode = dquot_to_inode(dquot);
6250 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
6316 /* Data block + inode block */
6337 static void lockdep_set_quota_inode(struct inode *inode, int subclass)
6339 struct ext4_inode_info *ei = EXT4_I(inode);
6406 struct inode *inode = d_inode(path->dentry);
6410 * Set inode flags to prevent userspace from messing with quota
6414 inode_lock(inode);
6415 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6418 EXT4_I(inode)->i_flags |= EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL;
6419 inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
6421 err = ext4_mark_inode_dirty(handle, inode);
6424 inode_unlock(inode);
6452 struct inode *qf_inode;
6472 ext4_error(sb, "Bad quota inode: %lu, type: %d",
6516 struct inode *inode;
6518 inode = sb_dqopt(sb)->files[type];
6519 if (inode)
6520 inode = igrab(inode);
6522 if (inode) {
6523 lockdep_set_quota_inode(inode,
6525 iput(inode);
6538 struct inode *inode = sb_dqopt(sb)->files[type];
6547 if (!inode || !igrab(inode))
6554 inode_lock(inode);
6560 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6565 EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
6566 inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
6567 inode->i_mtime = inode->i_ctime = current_time(inode);
6568 err = ext4_mark_inode_dirty(handle, inode);
6571 inode_unlock(inode);
6573 lockdep_set_quota_inode(inode, I_DATA_SEM_NORMAL);
6574 iput(inode);
6587 struct inode *inode = sb_dqopt(sb)->files[type];
6593 loff_t i_size = i_size_read(inode);
6603 bh = ext4_bread(NULL, inode, blk, 0);
6624 struct inode *inode = sb_dqopt(sb)->files[type];
6649 bh = ext4_bread(handle, inode, blk,
6653 ext4_should_retry_alloc(inode->i_sb, &retries));
6671 if (inode->i_size < off + len) {
6672 i_size_write(inode, off + len);
6673 EXT4_I(inode)->i_disksize = inode->i_size;
6674 err2 = ext4_mark_inode_dirty(handle, inode);