Lines Matching refs:inode
21 static int ext4_get_inline_size(struct inode *inode)
23 if (EXT4_I(inode)->i_inline_off)
24 return EXT4_I(inode)->i_inline_size;
29 static int get_max_inline_xattr_value_size(struct inode *inode,
38 if (!EXT4_INODE_HAS_XATTR_SPACE(inode))
41 min_offs = EXT4_SB(inode->i_sb)->s_inode_size -
43 EXT4_I(inode)->i_extra_isize -
47 * We need to subtract another sizeof(__u32) since an in-inode xattr
51 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR))
57 header = IHDR(inode, raw_inode);
59 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size;
66 EXT4_ERROR_INODE(inode,
67 "corrupt xattr in inline inode");
80 if (EXT4_I(inode)->i_inline_off) {
82 ((void *)raw_inode + EXT4_I(inode)->i_inline_off);
100 * Get the maximum size we now can store in an inode.
104 int ext4_get_max_inline_size(struct inode *inode)
109 if (EXT4_I(inode)->i_extra_isize == 0)
112 error = ext4_get_inode_loc(inode, &iloc);
114 ext4_error_inode_err(inode, __func__, __LINE__, 0, -error,
115 "can't get inode location %lu",
116 inode->i_ino);
120 down_read(&EXT4_I(inode)->xattr_sem);
121 max_inline_size = get_max_inline_xattr_value_size(inode, &iloc);
122 up_read(&EXT4_I(inode)->xattr_sem);
135 * the new inode has been unlocked
137 int ext4_find_inline_data_nolock(struct inode *inode)
148 if (EXT4_I(inode)->i_extra_isize == 0)
151 error = ext4_get_inode_loc(inode, &is.iloc);
155 error = ext4_xattr_ibody_find(inode, &i, &is);
161 EXT4_ERROR_INODE(inode, "inline data xattr refers "
162 "to an external xattr inode");
166 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
168 EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
176 static int ext4_read_inline_data(struct inode *inode, void *buffer,
188 BUG_ON(len > EXT4_I(inode)->i_inline_size);
202 header = IHDR(inode, raw_inode);
204 EXT4_I(inode)->i_inline_off);
217 * write the buffer to the inline inode.
222 static void ext4_write_inline_data(struct inode *inode, struct ext4_iloc *iloc,
230 if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
233 BUG_ON(!EXT4_I(inode)->i_inline_off);
234 BUG_ON(pos + len > EXT4_I(inode)->i_inline_size);
253 header = IHDR(inode, raw_inode);
255 EXT4_I(inode)->i_inline_off);
262 struct inode *inode, unsigned len)
274 error = ext4_get_inode_loc(inode, &is.iloc);
295 error = ext4_xattr_ibody_find(inode, &i, &is);
301 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
304 ext4_clear_inode_state(inode,
312 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
314 EXT4_I(inode)->i_inline_size = len + EXT4_MIN_INLINE_DATA_SIZE;
315 ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
316 ext4_set_inode_flag(inode, EXT4_INODE_INLINE_DATA);
318 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
325 static int ext4_update_inline_data(handle_t *handle, struct inode *inode,
339 if (len <= EXT4_I(inode)->i_inline_size)
342 error = ext4_get_inode_loc(inode, &is.iloc);
346 error = ext4_xattr_ibody_find(inode, &i, &is);
359 error = ext4_xattr_ibody_get(inode, i.name_index, i.name,
373 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
377 EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
379 EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
381 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
383 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
391 static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,
395 struct ext4_inode_info *ei = EXT4_I(inode);
397 if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA))
400 size = ext4_get_max_inline_size(inode);
404 ext4_write_lock_xattr(inode, &no_expand);
407 ret = ext4_update_inline_data(handle, inode, len);
409 ret = ext4_create_inline_data(handle, inode, len);
411 ext4_write_unlock_xattr(inode, &no_expand);
416 struct inode *inode)
418 struct ext4_inode_info *ei = EXT4_I(inode);
433 error = ext4_get_inode_loc(inode, &is.iloc);
437 error = ext4_xattr_ibody_find(inode, &i, &is);
446 error = ext4_xattr_ibody_set(handle, inode, &i, &is);
454 if (ext4_has_feature_extents(inode->i_sb)) {
455 if (S_ISDIR(inode->i_mode) ||
456 S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) {
457 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
458 ext4_ext_tree_init(handle, inode);
461 ext4_clear_inode_flag(inode, EXT4_INODE_INLINE_DATA);
464 error = ext4_mark_iloc_dirty(handle, inode, &is.iloc);
466 EXT4_I(inode)->i_inline_off = 0;
467 EXT4_I(inode)->i_inline_size = 0;
468 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
476 static int ext4_read_inline_page(struct inode *inode, struct page *page)
484 BUG_ON(!ext4_has_inline_data(inode));
487 if (!EXT4_I(inode)->i_inline_off) {
488 ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.",
489 inode->i_ino);
493 ret = ext4_get_inode_loc(inode, &iloc);
497 len = min_t(size_t, ext4_get_inline_size(inode), i_size_read(inode));
499 ret = ext4_read_inline_data(inode, kaddr, len, &iloc);
510 int ext4_readpage_inline(struct inode *inode, struct page *page)
514 down_read(&EXT4_I(inode)->xattr_sem);
515 if (!ext4_has_inline_data(inode)) {
516 up_read(&EXT4_I(inode)->xattr_sem);
525 ret = ext4_read_inline_page(inode, page);
531 up_read(&EXT4_I(inode)->xattr_sem);
538 struct inode *inode,
548 if (!ext4_has_inline_data(inode)) {
553 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
557 needed_blocks = ext4_writepage_trans_blocks(inode);
559 ret = ext4_get_inode_loc(inode, &iloc);
564 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
581 ext4_write_lock_xattr(inode, &no_expand);
584 if (!ext4_has_inline_data(inode)) {
590 to = ext4_get_inline_size(inode);
592 ret = ext4_read_inline_page(inode, page);
597 ret = ext4_destroy_inline_data_nolock(handle, inode);
601 if (ext4_should_dioread_nolock(inode)) {
607 if (!ret && ext4_should_journal_data(inode)) {
617 ext4_orphan_add(handle, inode);
618 ext4_write_unlock_xattr(inode, &no_expand);
622 ext4_truncate_failed_write(inode);
624 * If truncate failed early the inode might
626 * make sure the inode is removed from the
629 if (inode->i_nlink)
630 ext4_orphan_del(NULL, inode);
633 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
644 ext4_write_unlock_xattr(inode, &no_expand);
652 * Try to write data in the inode.
653 * If the inode has inline data, check whether the new write can be
654 * in the inode also. If not, create the page the handle, move the data
658 struct inode *inode,
668 if (pos + len > ext4_get_max_inline_size(inode))
671 ret = ext4_get_inode_loc(inode, &iloc);
676 * The possible write could happen in the inode,
677 * so try to reserve the space in inode first.
679 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
686 ret = ext4_prepare_inline_data(handle, inode, pos + len);
690 /* We don't have space in inline inode, so convert it to extent. */
710 down_read(&EXT4_I(inode)->xattr_sem);
711 if (!ext4_has_inline_data(inode)) {
719 ret = ext4_read_inline_page(inode, page);
730 up_read(&EXT4_I(inode)->xattr_sem);
738 inode, flags);
741 int ext4_write_inline_data_end(struct inode *inode, loff_t pos, unsigned len,
754 ret = ext4_get_inode_loc(inode, &iloc);
758 ext4_std_error(inode->i_sb, ret);
761 ext4_write_lock_xattr(inode, &no_expand);
762 BUG_ON(!ext4_has_inline_data(inode));
769 (void) ext4_find_inline_data_nolock(inode);
772 ext4_write_inline_data(inode, &iloc, kaddr, pos, copied);
778 ext4_write_unlock_xattr(inode, &no_expand);
786 ext4_update_inode_size(inode, pos + copied);
792 * Don't mark the inode dirty under page lock. First, it unnecessarily
798 mark_inode_dirty(inode);
804 if (pos + len > inode->i_size && ext4_can_truncate(inode))
805 ext4_orphan_add(handle, inode);
810 if (pos + len > inode->i_size) {
811 ext4_truncate_failed_write(inode);
813 * If truncate failed early the inode might still be
814 * on the orphan list; we need to make sure the inode
817 if (inode->i_nlink)
818 ext4_orphan_del(NULL, inode);
824 ext4_journalled_write_inline_data(struct inode *inode,
832 ret = ext4_get_inode_loc(inode, &iloc);
834 ext4_std_error(inode->i_sb, ret);
838 ext4_write_lock_xattr(inode, &no_expand);
840 ext4_write_inline_data(inode, &iloc, kaddr, 0, len);
842 ext4_write_unlock_xattr(inode, &no_expand);
850 * 1. The inode is created and the first write exceeds inline size. We can
851 * clear the inode state safely.
852 * 2. The inode has inline data, then we need to read the data, make it
857 struct inode *inode,
868 down_read(&EXT4_I(inode)->xattr_sem);
869 if (!ext4_has_inline_data(inode)) {
870 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
874 inline_size = ext4_get_inline_size(inode);
877 ret = ext4_read_inline_page(inode, page);
885 up_read(&EXT4_I(inode)->xattr_sem);
888 ext4_truncate_failed_write(inode);
894 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
898 up_read(&EXT4_I(inode)->xattr_sem);
908 * If the data can be written into the inode, we just read
915 struct inode *inode,
927 ret = ext4_get_inode_loc(inode, &iloc);
932 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
938 inline_size = ext4_get_max_inline_size(inode);
942 ret = ext4_prepare_inline_data(handle, inode, pos + len);
956 inode,
960 ext4_should_retry_alloc(inode->i_sb, &retries))
971 down_read(&EXT4_I(inode)->xattr_sem);
972 if (!ext4_has_inline_data(inode)) {
978 ret = ext4_read_inline_page(inode, page);
986 up_read(&EXT4_I(inode)->xattr_sem);
991 up_read(&EXT4_I(inode)->xattr_sem);
1002 void ext4_show_inline_dir(struct inode *dir, struct buffer_head *bh,
1010 trace_printk("inode %lu\n", dir->i_ino);
1016 de->name_len, le32_to_cpu(de->inode));
1036 struct inode *dir,
1037 struct inode *inode,
1044 err = ext4_find_dest_de(dir, inode, iloc->bh, inline_start,
1053 ext4_insert_dentry(inode, de, inline_size, fname);
1064 * recovery deletes the inode, so the worst that can
1074 static void *ext4_get_inline_xattr_pos(struct inode *inode,
1080 BUG_ON(!EXT4_I(inode)->i_inline_off);
1082 header = IHDR(inode, ext4_raw_inode(iloc));
1084 EXT4_I(inode)->i_inline_off);
1110 de->inode = 0;
1115 static int ext4_update_inline_dir(handle_t *handle, struct inode *dir,
1137 static void ext4_restore_inline_data(handle_t *handle, struct inode *inode,
1143 ret = ext4_create_inline_data(handle, inode, inline_size);
1145 ext4_msg(inode->i_sb, KERN_EMERG,
1146 "error restoring inline_data for inode -- potential data loss! (inode %lu, error %d)",
1147 inode->i_ino, ret);
1150 ext4_write_inline_data(inode, iloc, buf, 0, inline_size);
1151 ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1155 struct inode *inode,
1169 de = ext4_init_dot_dotdot(inode, de,
1170 inode->i_sb->s_blocksize, csum_size,
1171 le32_to_cpu(((struct ext4_dir_entry_2 *)buf)->inode), 1);
1177 if (ext4_has_metadata_csum(inode->i_sb))
1180 inode->i_size = inode->i_sb->s_blocksize;
1181 i_size_write(inode, inode->i_sb->s_blocksize);
1182 EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize;
1185 inode->i_sb->s_blocksize - csum_size);
1189 inode->i_sb->s_blocksize);
1192 err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
1196 return ext4_mark_inode_dirty(handle, inode);
1200 struct inode *inode,
1209 inline_size = ext4_get_inline_size(inode);
1216 error = ext4_read_inline_data(inode, buf, inline_size, iloc);
1224 if (S_ISDIR(inode->i_mode)) {
1225 error = ext4_check_all_de(inode, iloc->bh,
1232 error = ext4_destroy_inline_data_nolock(handle, inode);
1239 error = ext4_map_blocks(handle, inode, &map, EXT4_GET_BLOCKS_CREATE);
1247 data_bh = sb_getblk(inode->i_sb, map.m_pblk);
1260 memset(data_bh->b_data, 0, inode->i_sb->s_blocksize);
1262 if (!S_ISDIR(inode->i_mode)) {
1267 inode, data_bh);
1269 error = ext4_finish_convert_inline_dir(handle, inode, data_bh,
1275 ext4_restore_inline_data(handle, inode, iloc, buf, inline_size);
1289 struct inode *dir, struct inode *inode)
1307 ret = ext4_add_dirent_to_inline(handle, fname, dir, inode, &iloc,
1329 inode, &iloc, inline_start,
1358 struct inode *dir, ext4_lblk_t block,
1367 struct inode *inode = file_inode(dir_file);
1374 ret = ext4_get_inode_loc(inode, &iloc);
1378 down_read(&EXT4_I(inode)->xattr_sem);
1379 if (!ext4_has_inline_data(inode)) {
1380 up_read(&EXT4_I(inode)->xattr_sem);
1385 inline_size = ext4_get_inline_size(inode);
1389 up_read(&EXT4_I(inode)->xattr_sem);
1393 ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
1394 up_read(&EXT4_I(inode)->xattr_sem);
1399 parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
1403 * only the inode number of '..' is stored, we have to handle
1407 fake.inode = cpu_to_le32(inode->i_ino);
1413 ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
1417 fake.inode = cpu_to_le32(parent_ino);
1423 ext4_set_de_type(inode->i_sb, &fake, S_IFDIR);
1429 if (ext4_check_dir_entry(inode, dir_file, de,
1442 if (de->inode == 0)
1477 struct inode *inode = file_inode(file);
1483 ret = ext4_get_inode_loc(inode, &iloc);
1487 down_read(&EXT4_I(inode)->xattr_sem);
1488 if (!ext4_has_inline_data(inode)) {
1489 up_read(&EXT4_I(inode)->xattr_sem);
1494 inline_size = ext4_get_inline_size(inode);
1498 up_read(&EXT4_I(inode)->xattr_sem);
1502 ret = ext4_read_inline_data(inode, dir_buf, inline_size, &iloc);
1503 up_read(&EXT4_I(inode)->xattr_sem);
1508 sb = inode->i_sb;
1509 parent_ino = le32_to_cpu(((struct ext4_dir_entry_2 *)dir_buf)->inode);
1530 if (!inode_eq_iversion(inode, file->f_version)) {
1562 file->f_version = inode_query_iversion(inode);
1567 if (!dir_emit(ctx, ".", 1, inode->i_ino, DT_DIR))
1582 if (ext4_check_dir_entry(inode, file, de, iloc.bh, dir_buf,
1585 if (le32_to_cpu(de->inode)) {
1587 le32_to_cpu(de->inode),
1599 struct buffer_head *ext4_get_first_inline_block(struct inode *inode,
1605 *retval = ext4_get_inode_loc(inode, &iloc);
1619 int ext4_try_create_inline_dir(handle_t *handle, struct inode *parent,
1620 struct inode *inode)
1626 ret = ext4_get_inode_loc(inode, &iloc);
1630 ret = ext4_prepare_inline_data(handle, inode, inline_size);
1635 * For inline dir, we only save the inode information for the ".."
1639 de->inode = cpu_to_le32(parent->i_ino);
1641 de->inode = 0;
1645 set_nlink(inode, 2);
1646 inode->i_size = EXT4_I(inode)->i_disksize = inline_size;
1652 struct buffer_head *ext4_find_inline_entry(struct inode *dir,
1701 struct inode *dir,
1757 ext4_get_inline_entry(struct inode *inode,
1765 BUG_ON(offset > ext4_get_inline_size(inode));
1771 inline_pos = ext4_get_inline_xattr_pos(inode, iloc);
1773 *inline_size = ext4_get_inline_size(inode) -
1782 bool empty_inline_dir(struct inode *dir, int *has_inline_data)
1795 "error %d getting inode %lu block",
1808 if (!le32_to_cpu(de->inode)) {
1825 "inode %u, rec_len %u, name_len %d"
1827 dir->i_ino, le32_to_cpu(de->inode),
1832 if (le32_to_cpu(de->inode)) {
1845 int ext4_destroy_inline_data(handle_t *handle, struct inode *inode)
1849 ext4_write_lock_xattr(inode, &no_expand);
1850 ret = ext4_destroy_inline_data_nolock(handle, inode);
1851 ext4_write_unlock_xattr(inode, &no_expand);
1856 int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap)
1862 down_read(&EXT4_I(inode)->xattr_sem);
1863 if (!ext4_has_inline_data(inode))
1866 error = ext4_get_inode_loc(inode, &iloc);
1870 addr = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits;
1878 iomap->length = min_t(loff_t, ext4_get_inline_size(inode),
1879 i_size_read(inode));
1884 up_read(&EXT4_I(inode)->xattr_sem);
1888 int ext4_inline_data_truncate(struct inode *inode, int *has_inline)
1903 needed_blocks = ext4_writepage_trans_blocks(inode);
1904 handle = ext4_journal_start(inode, EXT4_HT_INODE, needed_blocks);
1908 ext4_write_lock_xattr(inode, &no_expand);
1909 if (!ext4_has_inline_data(inode)) {
1910 ext4_write_unlock_xattr(inode, &no_expand);
1916 if ((err = ext4_orphan_add(handle, inode)) != 0)
1919 if ((err = ext4_get_inode_loc(inode, &is.iloc)) != 0)
1922 down_write(&EXT4_I(inode)->i_data_sem);
1923 i_size = inode->i_size;
1924 inline_size = ext4_get_inline_size(inode);
1925 EXT4_I(inode)->i_disksize = i_size;
1930 if ((err = ext4_xattr_ibody_find(inode, &i, &is)) != 0)
1942 err = ext4_xattr_ibody_get(inode, i.name_index,
1950 err = ext4_xattr_ibody_set(handle, inode, &i, &is);
1962 EXT4_I(inode)->i_inline_size = i_size <
1968 up_write(&EXT4_I(inode)->i_data_sem);
1971 ext4_write_unlock_xattr(inode, &no_expand);
1973 if (inode->i_nlink)
1974 ext4_orphan_del(handle, inode);
1977 inode->i_mtime = inode->i_ctime = current_time(inode);
1978 err = ext4_mark_inode_dirty(handle, inode);
1979 if (IS_SYNC(inode))
1986 int ext4_convert_inline_data(struct inode *inode)
1992 if (!ext4_has_inline_data(inode)) {
1993 ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
1995 } else if (!ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
2002 error = filemap_flush(inode->i_mapping);
2005 if (!ext4_has_inline_data(inode))
2009 needed_blocks = ext4_writepage_trans_blocks(inode);
2012 error = ext4_get_inode_loc(inode, &iloc);
2016 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
2022 ext4_write_lock_xattr(inode, &no_expand);
2023 if (ext4_has_inline_data(inode))
2024 error = ext4_convert_inline_data_nolock(handle, inode, &iloc);
2025 ext4_write_unlock_xattr(inode, &no_expand);