Lines Matching defs:inode
13 * ea-in-inode support by Alex Tomas <alex@clusterfs.com> aka bzzz
20 * field contains the block number if an inode uses an additional block. All
21 * attributes must fit in the inode and one additional block. Blocks that
47 * EXT4_I(inode)->i_file_acl is protected by EXT4_I(inode)->xattr_sem.
48 * EA blocks are only changed if they are exclusive to an inode, so
66 # define ea_idebug(inode, fmt, ...) \
67 printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \
68 inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)
73 # define ea_idebug(inode, fmt, ...) no_printk(fmt, ##__VA_ARGS__)
80 ext4_xattr_block_cache_find(struct inode *, struct ext4_xattr_header *,
111 #define EA_BLOCK_CACHE(inode) (((struct ext4_sb_info *) \
112 inode->i_sb->s_fs_info)->s_ea_block_cache)
114 #define EA_INODE_CACHE(inode) (((struct ext4_sb_info *) \
115 inode->i_sb->s_fs_info)->s_ea_inode_cache)
119 struct inode *inode);
122 void ext4_xattr_inode_set_class(struct inode *ea_inode)
132 static __le32 ext4_xattr_block_csum(struct inode *inode,
136 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
148 EXT4_BLOCK_SIZE(inode->i_sb) - offset);
153 static int ext4_xattr_block_csum_verify(struct inode *inode,
159 if (ext4_has_metadata_csum(inode->i_sb)) {
161 ret = (hdr->h_checksum == ext4_xattr_block_csum(inode,
168 static void ext4_xattr_block_csum_set(struct inode *inode,
171 if (ext4_has_metadata_csum(inode->i_sb))
172 BHDR(bh)->h_checksum = ext4_xattr_block_csum(inode,
191 check_xattrs(struct inode *inode, struct buffer_head *bh,
207 if (!ext4_xattr_block_csum_verify(inode, bh)) {
217 err_str = "in-inode xattr block too small";
221 err_str = "bad magic number in in-inode xattr";
245 if (!ext4_has_feature_ea_inode(inode->i_sb) && ea_ino) {
250 !ext4_valid_inum(inode->i_sb, ea_ino))) {
289 __ext4_error_inode(inode, function, line, 0, -err,
294 __ext4_error_inode(inode, function, line, 0, -err,
295 "corrupted in-inode xattr: %s", err_str);
300 __ext4_xattr_check_block(struct inode *inode, struct buffer_head *bh,
303 return check_xattrs(inode, bh, BFIRST(bh), bh->b_data + bh->b_size,
307 #define ext4_xattr_check_block(inode, bh) \
308 __ext4_xattr_check_block((inode), (bh), __func__, __LINE__)
312 __xattr_check_inode(struct inode *inode, struct ext4_xattr_ibody_header *header,
315 return check_xattrs(inode, NULL, IFIRST(header), end, IFIRST(header),
319 #define xattr_check_inode(inode, header, end) \
320 __xattr_check_inode((inode), (header), (end), __func__, __LINE__)
323 xattr_find_entry(struct inode *inode, struct ext4_xattr_entry **pentry,
336 EXT4_ERROR_INODE(inode, "corrupted xattr entries");
357 static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)
363 static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)
369 static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode)
374 static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash)
380 * Read the EA value from an inode.
382 static int ext4_xattr_inode_read(struct inode *ea_inode, void *buf, size_t size)
421 #define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode)->i_mtime.tv_sec)
423 static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,
424 u32 ea_inode_hash, struct inode **ea_inode)
426 struct inode *inode;
432 * parent inode.
436 "Parent and EA inode have the same ino %lu", ea_ino);
440 inode = ext4_iget(parent->i_sb, ea_ino, EXT4_IGET_EA_INODE);
441 if (IS_ERR(inode)) {
442 err = PTR_ERR(inode);
444 "error while reading EA inode %lu err=%d", ea_ino,
448 ext4_xattr_inode_set_class(inode);
451 * Check whether this is an old Lustre-style xattr inode. Lustre
453 * backpointer from ea_inode to the parent inode.
455 if (ea_inode_hash != ext4_xattr_inode_get_hash(inode) &&
456 EXT4_XATTR_INODE_GET_PARENT(inode) == parent->i_ino &&
457 inode->i_generation == parent->i_generation) {
458 ext4_set_inode_state(inode, EXT4_STATE_LUSTRE_EA_INODE);
459 ext4_xattr_inode_set_ref(inode, 1);
461 inode_lock(inode);
462 inode->i_flags |= S_NOQUOTA;
463 inode_unlock(inode);
466 *ea_inode = inode;
470 /* Remove entry from mbcache when EA inode is getting evicted */
471 void ext4_evict_ea_inode(struct inode *inode)
475 if (!EA_INODE_CACHE(inode))
478 while ((oe = mb_cache_entry_delete_or_get(EA_INODE_CACHE(inode),
479 ext4_xattr_inode_get_hash(inode), inode->i_ino))) {
481 mb_cache_entry_put(EA_INODE_CACHE(inode), oe);
486 ext4_xattr_inode_verify_hashes(struct inode *ea_inode,
525 * Read xattr value from the EA inode.
528 ext4_xattr_inode_get(struct inode *inode, struct ext4_xattr_entry *entry,
531 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
532 struct inode *ea_inode;
535 err = ext4_xattr_inode_iget(inode, le32_to_cpu(entry->e_value_inum),
559 "EA inode hash validation failed");
574 ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
582 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
584 ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
587 if (!EXT4_I(inode)->i_file_acl)
589 ea_idebug(inode, "reading block %llu",
590 (unsigned long long)EXT4_I(inode)->i_file_acl);
591 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
596 error = ext4_xattr_check_block(inode, bh);
602 error = xattr_find_entry(inode, &entry, end, name_index, name, 1);
613 error = ext4_xattr_inode_get(inode, entry, buffer,
634 ext4_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
645 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
647 error = ext4_get_inode_loc(inode, &iloc);
651 header = IHDR(inode, raw_inode);
652 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
653 error = xattr_check_inode(inode, header, end);
657 error = xattr_find_entry(inode, &entry, end, name_index, name, 0);
668 error = ext4_xattr_inode_get(inode, entry, buffer,
699 ext4_xattr_get(struct inode *inode, int name_index, const char *name,
704 if (unlikely(ext4_forced_shutdown(inode->i_sb)))
710 down_read(&EXT4_I(inode)->xattr_sem);
711 error = ext4_xattr_ibody_get(inode, name_index, name, buffer,
714 error = ext4_xattr_block_get(inode, name_index, name, buffer,
716 up_read(&EXT4_I(inode)->xattr_sem);
752 struct inode *inode = d_inode(dentry);
756 ea_idebug(inode, "buffer=%p, buffer_size=%ld",
759 if (!EXT4_I(inode)->i_file_acl)
761 ea_idebug(inode, "reading block %llu",
762 (unsigned long long)EXT4_I(inode)->i_file_acl);
763 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
768 error = ext4_xattr_check_block(inode, bh);
771 ext4_xattr_block_cache_insert(EA_BLOCK_CACHE(inode), bh);
782 struct inode *inode = d_inode(dentry);
789 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
791 error = ext4_get_inode_loc(inode, &iloc);
795 header = IHDR(inode, raw_inode);
796 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
797 error = xattr_check_inode(inode, header, end);
863 int ext4_get_inode_usage(struct inode *inode, qsize_t *usage)
874 lockdep_assert_held_read(&EXT4_I(inode)->xattr_sem);
876 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
877 ret = ext4_get_inode_loc(inode, &iloc);
881 header = IHDR(inode, raw_inode);
882 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
883 ret = xattr_check_inode(inode, header, end);
893 if (EXT4_I(inode)->i_file_acl) {
894 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
901 ret = ext4_xattr_check_block(inode, bh);
918 static inline size_t round_up_cluster(struct inode *inode, size_t length)
920 struct super_block *sb = inode->i_sb;
922 inode->i_blkbits);
928 static int ext4_xattr_inode_alloc_quota(struct inode *inode, size_t len)
932 err = dquot_alloc_inode(inode);
935 err = dquot_alloc_space_nodirty(inode, round_up_cluster(inode, len));
937 dquot_free_inode(inode);
941 static void ext4_xattr_inode_free_quota(struct inode *parent,
942 struct inode *ea_inode,
952 int __ext4_xattr_set_credits(struct super_block *sb, struct inode *inode,
960 * 1) Owner inode update
981 if (inode && ext4_has_inline_data(inode))
982 credits += ext4_writepage_trans_blocks(inode) + 1;
988 /* New ea_inode, inode map, block bitmap, group descriptor. */
1005 * Old ea_inode, inode map, block bitmap, group descriptor.
1035 static int ext4_xattr_inode_update_ref(handle_t *handle, struct inode *ea_inode,
1053 WARN_ONCE(ref_count <= 0, "EA inode %lu ref_count=%lld",
1057 WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",
1064 WARN_ONCE(ref_count < 0, "EA inode %lu ref_count=%lld",
1069 "EA inode %lu i_nlink=%u",
1086 static int ext4_xattr_inode_inc_ref(handle_t *handle, struct inode *ea_inode)
1091 static int ext4_xattr_inode_dec_ref(handle_t *handle, struct inode *ea_inode)
1096 static int ext4_xattr_inode_inc_ref_all(handle_t *handle, struct inode *parent,
1099 struct inode *ea_inode;
1152 static int ext4_xattr_restart_fn(handle_t *handle, struct inode *inode,
1159 ext4_xattr_block_csum_set(inode, bh);
1162 ext4_warning(inode->i_sb, "Handle metadata (error %d)",
1171 ext4_xattr_inode_dec_ref_all(handle_t *handle, struct inode *parent,
1177 struct inode *ea_inode;
1201 "Expand inode array err=%d", err);
1268 ext4_xattr_release_block(handle_t *handle, struct inode *inode,
1273 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
1278 error = ext4_journal_get_write_access(handle, inode->i_sb, bh,
1308 if (ext4_has_feature_ea_inode(inode->i_sb))
1309 ext4_xattr_inode_dec_ref_all(handle, inode, bh,
1315 ext4_free_blocks(handle, inode, bh, 0, 1,
1334 ext4_xattr_block_csum_set(inode, bh);
1346 error = ext4_handle_dirty_metadata(handle, inode, bh);
1349 error = ext4_handle_dirty_metadata(handle, inode, bh);
1350 if (IS_SYNC(inode))
1352 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1));
1357 ext4_std_error(inode->i_sb, error);
1381 * Write the value of the EA in an inode.
1383 static int ext4_xattr_inode_write(handle_t *handle, struct inode *ea_inode,
1460 * Create an inode to store the value of a large EA.
1462 static struct inode *ext4_xattr_inode_create(handle_t *handle,
1463 struct inode *inode, u32 hash)
1465 struct inode *ea_inode = NULL;
1466 uid_t owner[2] = { i_uid_read(inode), i_gid_read(inode) };
1469 if (inode->i_sb->s_root == NULL) {
1470 ext4_warning(inode->i_sb,
1471 "refuse to create EA inode when umounting");
1477 * Let the next inode be the goal, so we try and allocate the EA inode
1480 ea_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
1481 S_IFREG | 0600, NULL, inode->i_ino + 1, owner,
1516 static struct inode *
1517 ext4_xattr_inode_cache_find(struct inode *inode, const void *value,
1520 struct inode *ea_inode;
1522 struct mb_cache *ea_inode_cache = EA_INODE_CACHE(inode);
1542 ea_inode = ext4_iget(inode->i_sb, ce->e_value,
1566 * Add value of the EA in an inode.
1568 static int ext4_xattr_inode_lookup_create(handle_t *handle, struct inode *inode,
1570 struct inode **ret_inode)
1572 struct inode *ea_inode;
1576 hash = ext4_xattr_inode_hash(EXT4_SB(inode->i_sb), value, value_len);
1577 ea_inode = ext4_xattr_inode_cache_find(inode, value, value_len, hash);
1589 /* Create an inode for the EA value */
1590 ea_inode = ext4_xattr_inode_create(handle, inode, hash);
1602 if (EA_INODE_CACHE(inode))
1603 mb_cache_entry_create(EA_INODE_CACHE(inode), GFP_NOFS, hash,
1614 #define EXT4_XATTR_BLOCK_RESERVE(inode) min(i_blocksize(inode)/8, 1024U)
1618 handle_t *handle, struct inode *inode,
1625 struct inode *old_ea_inode = NULL;
1626 struct inode *new_ea_inode = NULL;
1659 EXT4_ERROR_INODE(inode, "corrupted xattr entries");
1684 * If storing the value in an external inode is an option,
1689 if (ext4_has_feature_ea_inode(inode->i_sb) &&
1692 EXT4_XATTR_BLOCK_RESERVE(inode)) {
1703 ret = ext4_xattr_inode_iget(inode,
1715 ret = ext4_xattr_inode_alloc_quota(inode, i->value_len);
1719 ret = ext4_xattr_inode_lookup_create(handle, inode, i->value,
1724 ext4_xattr_inode_free_quota(inode, NULL, i->value_len);
1743 ext4_xattr_inode_free_quota(inode, new_ea_inode,
1749 ext4_xattr_inode_free_quota(inode, old_ea_inode,
1791 if (!is_block && ext4_has_inline_data(inode)) {
1792 ret = ext4_find_inline_data_nolock(inode);
1794 ext4_warning_inode(inode,
1881 ext4_xattr_block_find(struct inode *inode, struct ext4_xattr_info *i,
1884 struct super_block *sb = inode->i_sb;
1887 ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
1890 if (EXT4_I(inode)->i_file_acl) {
1891 /* The inode already has an extended attribute block. */
1892 bs->bh = ext4_sb_bread(sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
1901 error = ext4_xattr_check_block(inode, bs->bh);
1909 error = xattr_find_entry(inode, &bs->s.here, bs->s.end,
1919 ext4_xattr_block_set(handle_t *handle, struct inode *inode,
1923 struct super_block *sb = inode->i_sb;
1929 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
1930 struct inode *ea_inode = NULL, *tmp_inode;
1970 error = ext4_xattr_set_entry(i, s, handle, inode,
1972 ext4_xattr_block_csum_set(inode, bs->bh);
1978 inode,
1997 * If existing entry points to an xattr inode, we need
2005 error = ext4_xattr_inode_iget(inode, ea_ino,
2015 * inode until success is guaranteed.
2039 error = ext4_xattr_set_entry(i, s, handle, inode, true /* is_block */);
2053 error = ext4_xattr_inode_iget(inode, ea_ino,
2064 new_bh = ext4_xattr_block_cache_find(inode, header(s->base),
2074 WARN_ON_ONCE(dquot_initialize_needed(inode));
2077 the inode. */
2078 error = dquot_alloc_block(inode,
2103 dquot_free_block(inode,
2117 ext4_xattr_block_csum_set(inode, new_bh);
2120 inode,
2139 WARN_ON_ONCE(dquot_initialize_needed(inode));
2142 EXT4_I(inode)->i_block_group);
2143 block = ext4_new_meta_blocks(handle, inode, goal, 0,
2148 ea_idebug(inode, "creating block %llu",
2155 ext4_free_blocks(handle, inode, NULL, block, 1,
2159 error = ext4_xattr_inode_inc_ref_all(handle, inode,
2184 ext4_xattr_block_csum_set(inode, new_bh);
2188 error = ext4_handle_dirty_metadata(handle, inode,
2196 ext4_xattr_inode_free_quota(inode, NULL, old_ea_inode_quota);
2198 /* Update the inode. */
2199 EXT4_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
2205 ext4_xattr_release_block(handle, inode, bs->bh,
2223 ext4_xattr_inode_free_quota(inode, ea_inode,
2236 dquot_free_block(inode, EXT4_C2B(EXT4_SB(sb), 1));
2240 EXT4_ERROR_INODE(inode, "bad block %llu",
2241 EXT4_I(inode)->i_file_acl);
2247 int ext4_xattr_ibody_find(struct inode *inode, struct ext4_xattr_info *i,
2254 if (!EXT4_INODE_HAS_XATTR_SPACE(inode))
2258 header = IHDR(inode, raw_inode);
2261 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
2262 if (ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
2263 error = xattr_check_inode(inode, header, is->s.end);
2267 error = xattr_find_entry(inode, &is->s.here, is->s.end,
2276 int ext4_xattr_ibody_set(handle_t *handle, struct inode *inode,
2284 if (!EXT4_INODE_HAS_XATTR_SPACE(inode))
2287 error = ext4_xattr_set_entry(i, s, handle, inode, false /* is_block */);
2290 header = IHDR(inode, ext4_raw_inode(&is->iloc));
2293 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
2296 ext4_clear_inode_state(inode, EXT4_STATE_XATTR);
2315 static struct buffer_head *ext4_xattr_get_block(struct inode *inode)
2320 if (!EXT4_I(inode)->i_file_acl)
2322 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
2325 error = ext4_xattr_check_block(inode, bh);
2336 * Create, replace or remove an extended attribute for this inode. Value
2346 ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
2371 ext4_write_lock_xattr(inode, &no_expand);
2378 bh = ext4_xattr_get_block(inode);
2384 credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
2396 error = ext4_reserve_inode_write(handle, inode, &is.iloc);
2400 if (ext4_test_inode_state(inode, EXT4_STATE_NEW)) {
2402 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
2403 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
2406 error = ext4_xattr_ibody_find(inode, &i, &is);
2410 error = ext4_xattr_block_find(inode, &i, &bs);
2428 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
2430 error = ext4_xattr_block_set(handle, inode, &i, &bs);
2439 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2441 EXT4_XATTR_MIN_LARGE_EA_SIZE(inode->i_sb->s_blocksize)))
2444 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
2447 error = ext4_xattr_block_set(handle, inode, &i, &bs);
2449 if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
2452 error = ext4_xattr_block_find(inode, &i, &bs);
2456 error = ext4_xattr_block_set(handle, inode, &i, &bs);
2459 error = ext4_xattr_ibody_set(handle, inode, &i,
2464 * external inode if possible.
2466 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2475 ext4_xattr_update_super_block(handle, inode->i_sb);
2476 inode_set_ctime_current(inode);
2477 inode_inc_iversion(inode);
2480 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
2486 if (IS_SYNC(inode))
2489 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, handle);
2494 ext4_write_unlock_xattr(inode, &no_expand);
2498 int ext4_xattr_set_credits(struct inode *inode, size_t value_len,
2506 if (!EXT4_SB(inode->i_sb)->s_journal)
2509 down_read(&EXT4_I(inode)->xattr_sem);
2511 bh = ext4_xattr_get_block(inode);
2515 *credits = __ext4_xattr_set_credits(inode->i_sb, inode, bh,
2521 up_read(&EXT4_I(inode)->xattr_sem);
2528 * Like ext4_xattr_set_handle, but start from an inode. This extended
2534 ext4_xattr_set(struct inode *inode, int name_index, const char *name,
2538 struct super_block *sb = inode->i_sb;
2542 error = dquot_initialize(inode);
2547 error = ext4_xattr_set_credits(inode, value_len, flags & XATTR_CREATE,
2552 handle = ext4_journal_start(inode, EXT4_HT_XATTR, credits);
2558 error = ext4_xattr_set_handle(handle, inode, name_index, name,
2567 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, NULL);
2573 * Shift the EA entries in the inode to create space for the increased
2599 * Move xattr pointed to by 'entry' from inode into external xattr block
2601 static int ext4_xattr_move_to_block(handle_t *handle, struct inode *inode,
2615 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
2640 error = ext4_xattr_inode_get(inode, entry, buffer, value_size);
2652 error = ext4_get_inode_loc(inode, &is->iloc);
2656 error = ext4_xattr_ibody_find(inode, &i, is);
2662 error = ext4_xattr_block_find(inode, &i, bs);
2666 /* Move ea entry from the inode into the block */
2667 error = ext4_xattr_block_set(handle, inode, &i, bs);
2671 /* Remove the chosen entry from the inode */
2674 error = ext4_xattr_ibody_set(handle, inode, &i, is);
2690 static int ext4_xattr_make_inode_space(handle_t *handle, struct inode *inode,
2695 struct ext4_xattr_ibody_header *header = IHDR(inode, raw_inode);
2711 /* never move system.data out of the inode */
2742 error = ext4_xattr_move_to_block(handle, inode, raw_inode,
2756 * Expand an inode by new_extra_isize bytes when EAs are present.
2759 int ext4_expand_extra_isize_ea(struct inode *inode, int new_extra_isize,
2763 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2774 isize_diff = new_extra_isize - EXT4_I(inode)->i_extra_isize;
2775 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
2778 header = IHDR(inode, raw_inode);
2781 * Check if enough free space is available in the inode to shift the
2786 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
2790 error = xattr_check_inode(inode, header, end);
2799 * Enough free space isn't available in the inode, check if
2802 if (EXT4_I(inode)->i_file_acl) {
2805 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
2810 error = ext4_xattr_check_block(inode, bh);
2831 bfree = inode->i_sb->s_blocksize;
2834 error = ext4_xattr_make_inode_space(handle, inode, raw_inode,
2848 ext4_xattr_shift_entries(IFIRST(header), EXT4_I(inode)->i_extra_isize
2852 EXT4_I(inode)->i_extra_isize = new_extra_isize;
2854 if (ext4_has_inline_data(inode))
2855 error = ext4_find_inline_data_nolock(inode);
2859 ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
2860 inode->i_ino);
2869 /* Add the large xattr @inode into @ea_inode_array for deferred iput().
2875 struct inode *inode)
2906 (*ea_inode_array)->inodes[(*ea_inode_array)->count++] = inode;
2913 * Free extended attribute resources associated with this inode. Traverse
2915 * inode. This is called immediately before an inode is freed. We have exclusive
2916 * access to the inode. If an orphan inode is deleted it will also release its
2919 int ext4_xattr_delete_inode(handle_t *handle, struct inode *inode,
2927 struct inode *ea_inode;
2931 ext4_free_metadata_revoke_credits(inode->i_sb, 1));
2933 EXT4_ERROR_INODE(inode, "ensure credits (error %d)", error);
2937 if (ext4_has_feature_ea_inode(inode->i_sb) &&
2938 ext4_test_inode_state(inode, EXT4_STATE_XATTR)) {
2940 error = ext4_get_inode_loc(inode, &iloc);
2942 EXT4_ERROR_INODE(inode, "inode loc (error %d)", error);
2946 error = ext4_journal_get_write_access(handle, inode->i_sb,
2949 EXT4_ERROR_INODE(inode, "write access (error %d)",
2954 header = IHDR(inode, ext4_raw_inode(&iloc));
2956 ext4_xattr_inode_dec_ref_all(handle, inode, iloc.bh,
2964 if (EXT4_I(inode)->i_file_acl) {
2965 bh = ext4_sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl, REQ_PRIO);
2969 EXT4_ERROR_INODE_ERR(inode, EIO,
2971 EXT4_I(inode)->i_file_acl);
2976 error = ext4_xattr_check_block(inode, bh);
2980 if (ext4_has_feature_ea_inode(inode->i_sb)) {
2985 error = ext4_xattr_inode_iget(inode,
2991 ext4_xattr_inode_free_quota(inode, ea_inode,
2998 ext4_xattr_release_block(handle, inode, bh, ea_inode_array,
3004 EXT4_I(inode)->i_file_acl = 0;
3005 error = ext4_mark_inode_dirty(handle, inode);
3007 EXT4_ERROR_INODE(inode, "mark inode dirty (error %d)",
3011 ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_XATTR, handle);
3110 ext4_xattr_block_cache_find(struct inode *inode,
3116 struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
3122 ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
3127 bh = ext4_sb_bread(inode->i_sb, ce->e_value, REQ_PRIO);
3132 EXT4_ERROR_INODE(inode, "block %lu read error",