Lines Matching refs:inode
2 * inode.c
56 static int udf_update_inode(struct inode *, int);
57 static int udf_sync_inode(struct inode *inode);
58 static int udf_alloc_i_data(struct inode *inode, size_t size);
59 static sector_t inode_getblk(struct inode *, sector_t, int *, int *);
60 static int udf_insert_aext(struct inode *, struct extent_position,
62 static void udf_split_extents(struct inode *, int *, int, udf_pblk_t,
64 static void udf_prealloc_extents(struct inode *, int, int,
66 static void udf_merge_extents(struct inode *, struct kernel_long_ad *, int *);
67 static int udf_update_extents(struct inode *, struct kernel_long_ad *, int,
69 static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
71 static void __udf_clear_extent_cache(struct inode *inode)
73 struct udf_inode_info *iinfo = UDF_I(inode);
82 static void udf_clear_extent_cache(struct inode *inode)
84 struct udf_inode_info *iinfo = UDF_I(inode);
87 __udf_clear_extent_cache(inode);
92 static int udf_read_extent_cache(struct inode *inode, loff_t bcount,
95 struct udf_inode_info *iinfo = UDF_I(inode);
114 static void udf_update_extent_cache(struct inode *inode, loff_t estart,
117 struct udf_inode_info *iinfo = UDF_I(inode);
121 __udf_clear_extent_cache(inode);
137 void udf_evict_inode(struct inode *inode)
139 struct udf_inode_info *iinfo = UDF_I(inode);
142 if (!is_bad_inode(inode)) {
143 if (!inode->i_nlink) {
145 udf_setsize(inode, 0);
146 udf_update_inode(inode, IS_SYNC(inode));
149 inode->i_size != iinfo->i_lenExtents) {
150 udf_warn(inode->i_sb,
151 "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
152 inode->i_ino, inode->i_mode,
153 (unsigned long long)inode->i_size,
157 truncate_inode_pages_final(&inode->i_data);
158 invalidate_inode_buffers(inode);
159 clear_inode(inode);
162 udf_clear_extent_cache(inode);
164 udf_free_inode(inode);
170 struct inode *inode = mapping->host;
171 struct udf_inode_info *iinfo = UDF_I(inode);
172 loff_t isize = inode->i_size;
175 truncate_pagecache(inode, isize);
178 udf_clear_extent_cache(inode);
179 udf_truncate_extents(inode);
222 struct inode *inode = mapping->host;
226 ret = blockdev_direct_IO(iocb, inode, iter, udf_get_block);
254 int udf_expand_file_adinicb(struct inode *inode)
258 struct udf_inode_info *iinfo = UDF_I(inode);
261 WARN_ON_ONCE(!inode_is_locked(inode));
263 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
268 inode->i_data.a_ops = &udf_aops;
270 mark_inode_dirty(inode);
279 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
297 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
302 inode->i_data.a_ops = &udf_aops;
306 err = filemap_fdatawrite(inode->i_mapping);
312 memcpy(iinfo->i_data + iinfo->i_lenEAttr, kaddr, inode->i_size);
316 inode->i_data.a_ops = &udf_adinicb_aops;
317 iinfo->i_lenAlloc = inode->i_size;
321 mark_inode_dirty(inode);
326 struct buffer_head *udf_expand_dir_adinicb(struct inode *inode,
336 loff_t f_pos = udf_ext0_offset(inode);
337 int size = udf_ext0_offset(inode) + inode->i_size;
339 struct udf_inode_info *iinfo = UDF_I(inode);
341 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
346 if (!inode->i_size) {
348 mark_inode_dirty(inode);
353 *block = udf_new_block(inode->i_sb, inode,
358 newblock = udf_get_pblock(inode->i_sb, *block,
363 dbh = udf_tgetblk(inode->i_sb, newblock);
367 memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
370 mark_buffer_dirty_inode(dbh, inode);
373 f_pos & (inode->i_sb->s_blocksize - 1);
379 sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
390 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
398 mark_buffer_dirty_inode(dbh, inode);
405 iinfo->i_lenExtents = inode->i_size;
408 epos.offset = udf_file_entry_alloc_offset(inode);
409 udf_add_aext(inode, &epos, &eloc, inode->i_size, 0);
413 mark_inode_dirty(inode);
417 static int udf_get_block(struct inode *inode, sector_t block,
425 phys = udf_block_map(inode, block);
427 map_bh(bh_result, inode->i_sb, phys);
433 iinfo = UDF_I(inode);
445 if (((loff_t)block) << inode->i_blkbits >= iinfo->i_lenExtents)
446 udf_discard_prealloc(inode);
447 udf_clear_extent_cache(inode);
448 phys = inode_getblk(inode, block, &err, &new);
454 map_bh(bh_result, inode->i_sb, phys);
461 static struct buffer_head *udf_getblk(struct inode *inode, udf_pblk_t block,
469 *err = udf_get_block(inode, block, &dummy, create);
471 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
474 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
477 mark_buffer_dirty_inode(bh, inode);
488 static int udf_do_extend_file(struct inode *inode,
495 struct super_block *sb = inode->i_sb;
504 iinfo = UDF_I(inode);
528 err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
537 udf_write_aext(inode, last_pos, &last_ext->extLocation,
546 udf_next_aext(inode, last_pos, &tmploc, &tmplen, 0);
562 err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
571 err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
590 udf_clear_extent_cache(inode);
591 udf_truncate_extents(inode);
596 static void udf_do_extend_final_block(struct inode *inode,
611 UDF_I(inode)->i_lenExtents += added_bytes;
613 udf_write_aext(inode, last_pos, &last_ext->extLocation,
617 static int udf_extend_file(struct inode *inode, loff_t newsize)
624 struct super_block *sb = inode->i_sb;
628 struct udf_inode_info *iinfo = UDF_I(inode);
644 udf_discard_prealloc(inode);
646 etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
650 elen > ((loff_t)offset + 1) << inode->i_blkbits);
652 if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) ||
661 etype = udf_next_aext(inode, &epos, &extent.extLocation,
666 new_elen = ((loff_t)offset << inode->i_blkbits) |
674 udf_do_extend_final_block(inode, &epos, &extent, new_elen);
676 err = udf_do_extend_file(inode, &epos, &extent, new_elen);
688 static sector_t inode_getblk(struct inode *inode, sector_t block,
701 struct udf_inode_info *iinfo = UDF_I(inode);
708 prev_epos.offset = udf_file_entry_alloc_offset(inode);
712 b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
737 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
748 ((elen + inode->i_sb->s_blocksize - 1) >>
749 inode->i_sb->s_blocksize_bits);
755 offset = b_off >> inode->i_sb->s_blocksize_bits;
760 udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
761 udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
767 if (elen & (inode->i_sb->s_blocksize - 1)) {
769 ((elen + inode->i_sb->s_blocksize - 1) &
770 ~(inode->i_sb->s_blocksize - 1));
771 udf_write_aext(inode, &cur_epos, &eloc, elen, 1);
773 newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
797 hole_len = (loff_t)offset << inode->i_blkbits;
798 ret = udf_do_extend_file(inode, &prev_epos, laarr, hole_len);
813 inode->i_sb->s_blocksize;
834 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
858 newblocknum = udf_new_block(inode->i_sb, inode,
866 iinfo->i_lenExtents += inode->i_sb->s_blocksize;
873 udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
879 if (S_ISREG(inode->i_mode))
880 udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
883 udf_merge_extents(inode, laarr, &endnum);
888 *err = udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
892 newblock = udf_get_pblock(inode->i_sb, newblocknum,
901 inode->i_ctime = current_time(inode);
903 if (IS_SYNC(inode))
904 udf_sync_inode(inode);
906 mark_inode_dirty(inode);
914 static void udf_split_extents(struct inode *inode, int *c, int offset,
918 unsigned long blocksize = inode->i_sb->s_blocksize;
919 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
941 udf_free_blocks(inode->i_sb, inode,
961 UDF_I(inode)->i_location.partitionReferenceNum;
978 static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
996 inode->i_sb->s_blocksize - 1) >>
997 inode->i_sb->s_blocksize_bits);
1010 inode->i_sb->s_blocksize - 1) >>
1011 inode->i_sb->s_blocksize_bits);
1019 inode->i_sb->s_blocksize - 1) >>
1020 inode->i_sb->s_blocksize_bits);
1021 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
1030 inode->i_sb->s_blocksize_bits);
1042 inode->i_sb->s_blocksize_bits);
1049 inode->i_sb->s_blocksize - 1) >>
1050 inode->i_sb->s_blocksize_bits;
1055 inode->i_sb->s_blocksize_bits);
1068 UDF_I(inode)->i_lenExtents +=
1069 numalloc << inode->i_sb->s_blocksize_bits;
1074 static void udf_merge_extents(struct inode *inode, struct kernel_long_ad *laarr,
1078 unsigned long blocksize = inode->i_sb->s_blocksize;
1079 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1111 udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0,
1144 udf_free_blocks(inode->i_sb, inode,
1158 static int udf_update_extents(struct inode *inode, struct kernel_long_ad *laarr,
1169 udf_delete_aext(inode, *epos);
1172 err = udf_insert_aext(inode, *epos,
1182 udf_next_aext(inode, epos, &laarr[i].extLocation,
1189 udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
1190 udf_write_aext(inode, epos, &laarr[i].extLocation,
1196 struct buffer_head *udf_bread(struct inode *inode, udf_pblk_t block,
1201 bh = udf_getblk(inode, block, create, err);
1219 int udf_setsize(struct inode *inode, loff_t newsize)
1223 unsigned int bsize = i_blocksize(inode);
1225 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1226 S_ISLNK(inode->i_mode)))
1228 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1231 iinfo = UDF_I(inode);
1232 if (newsize > inode->i_size) {
1236 (udf_file_entry_alloc_offset(inode) + newsize)) {
1237 err = udf_expand_file_adinicb(inode);
1246 err = udf_extend_file(inode, newsize);
1253 truncate_setsize(inode, newsize);
1257 udf_clear_extent_cache(inode);
1260 udf_file_entry_alloc_offset(inode));
1262 truncate_setsize(inode, newsize);
1266 err = block_truncate_page(inode->i_mapping, newsize,
1270 truncate_setsize(inode, newsize);
1272 udf_clear_extent_cache(inode);
1273 err = udf_truncate_extents(inode);
1279 inode->i_mtime = inode->i_ctime = current_time(inode);
1280 if (IS_SYNC(inode))
1281 udf_sync_inode(inode);
1283 mark_inode_dirty(inode);
1290 * inode on write-once media but avoid looping for too long on corrupted media.
1294 static int udf_read_inode(struct inode *inode, bool hidden_inode)
1300 struct udf_inode_info *iinfo = UDF_I(inode);
1301 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1305 int bs = inode->i_sb->s_blocksize;
1324 * Set defaults, but the inode is still incomplete!
1325 * Note: get_new_inode() sets the following on a new inode:
1335 bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
1337 udf_err(inode->i_sb, "(ino %lu) failed !bh\n", inode->i_ino);
1343 udf_err(inode->i_sb, "(ino %lu) failed ident=%u\n",
1344 inode->i_ino, ident);
1354 ibh = udf_read_ptagged(inode->i_sb, iloc, 1, &ident);
1367 udf_err(inode->i_sb,
1379 udf_err(inode->i_sb, "unsupported strategy type: %u\n",
1406 ret = udf_alloc_i_data(inode, bs -
1416 ret = udf_alloc_i_data(inode, bs - sizeof(struct fileEntry));
1428 ret = udf_alloc_i_data(inode, bs -
1442 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
1443 inode->i_uid = sbi->s_uid;
1445 i_uid_write(inode, uid);
1449 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
1450 inode->i_gid = sbi->s_gid;
1452 i_gid_write(inode, gid);
1456 inode->i_mode = sbi->s_fmode;
1459 inode->i_mode = sbi->s_dmode;
1461 inode->i_mode = udf_convert_permissions(fe);
1462 inode->i_mode &= ~sbi->s_umask;
1475 set_nlink(inode, link_count);
1477 inode->i_size = le64_to_cpu(fe->informationLength);
1478 iinfo->i_lenExtents = inode->i_size;
1481 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1482 (inode->i_sb->s_blocksize_bits - 9);
1484 udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime);
1485 udf_disk_stamp_to_time(&inode->i_mtime, fe->modificationTime);
1486 udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime);
1495 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1496 (inode->i_sb->s_blocksize_bits - 9);
1498 udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime);
1499 udf_disk_stamp_to_time(&inode->i_mtime, efe->modificationTime);
1501 udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime);
1513 if (iinfo->i_lenStreams >= inode->i_size)
1514 iinfo->i_lenStreams -= inode->i_size;
1518 inode->i_generation = iinfo->i_unique;
1527 if (udf_file_entry_alloc_offset(inode) + iinfo->i_lenAlloc > bs)
1535 if (iinfo->i_lenAlloc != inode->i_size)
1538 if (inode->i_size > bs - udf_file_entry_alloc_offset(inode))
1544 inode->i_op = &udf_dir_inode_operations;
1545 inode->i_fop = &udf_dir_operations;
1546 inode->i_mode |= S_IFDIR;
1547 inc_nlink(inode);
1554 inode->i_data.a_ops = &udf_adinicb_aops;
1556 inode->i_data.a_ops = &udf_aops;
1557 inode->i_op = &udf_file_inode_operations;
1558 inode->i_fop = &udf_file_operations;
1559 inode->i_mode |= S_IFREG;
1562 inode->i_mode |= S_IFBLK;
1565 inode->i_mode |= S_IFCHR;
1568 init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1571 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1574 inode->i_data.a_ops = &udf_symlink_aops;
1575 inode->i_op = &udf_symlink_inode_operations;
1576 inode_nohighmem(inode);
1577 inode->i_mode = S_IFLNK | 0777;
1589 udf_err(inode->i_sb, "(ino %lu) failed unknown file type=%u\n",
1590 inode->i_ino, fe->icbTag.fileType);
1593 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1595 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1597 init_special_inode(inode, inode->i_mode,
1610 static int udf_alloc_i_data(struct inode *inode, size_t size)
1612 struct udf_inode_info *iinfo = UDF_I(inode);
1638 void udf_update_extra_perms(struct inode *inode, umode_t mode)
1640 struct udf_inode_info *iinfo = UDF_I(inode);
1655 int udf_write_inode(struct inode *inode, struct writeback_control *wbc)
1657 return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1660 static int udf_sync_inode(struct inode *inode)
1662 return udf_update_inode(inode, 1);
1673 static int udf_update_inode(struct inode *inode, int do_sync)
1683 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1684 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1685 struct udf_inode_info *iinfo = UDF_I(inode);
1687 bh = udf_tgetblk(inode->i_sb,
1688 udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0));
1695 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
1705 iinfo->i_data, inode->i_sb->s_blocksize -
1713 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1716 fe->uid = cpu_to_le32(i_uid_read(inode));
1718 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1721 fe->gid = cpu_to_le32(i_gid_read(inode));
1723 udfperms = ((inode->i_mode & 0007)) |
1724 ((inode->i_mode & 0070) << 2) |
1725 ((inode->i_mode & 0700) << 4);
1730 if (S_ISDIR(inode->i_mode) && inode->i_nlink > 0)
1731 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1736 fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1739 fe->informationLength = cpu_to_le64(inode->i_size);
1741 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1744 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1747 udf_add_extendedattr(inode,
1762 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1763 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1770 (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
1776 inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1779 udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime);
1780 udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime);
1781 udf_time_to_disk_stamp(&fe->attrTime, inode->i_ctime);
1795 inode->i_sb->s_blocksize -
1798 cpu_to_le64(inode->i_size + iinfo->i_lenStreams);
1807 cpu_to_le32(inode->i_sb->s_blocksize);
1810 udf_adjust_time(iinfo, inode->i_atime);
1811 udf_adjust_time(iinfo, inode->i_mtime);
1812 udf_adjust_time(iinfo, inode->i_ctime);
1814 udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime);
1815 udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime);
1817 udf_time_to_disk_stamp(&efe->attrTime, inode->i_ctime);
1843 else if (S_ISDIR(inode->i_mode))
1845 else if (S_ISREG(inode->i_mode))
1847 else if (S_ISLNK(inode->i_mode))
1849 else if (S_ISBLK(inode->i_mode))
1851 else if (S_ISCHR(inode->i_mode))
1853 else if (S_ISFIFO(inode->i_mode))
1855 else if (S_ISSOCK(inode->i_mode))
1859 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1860 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1861 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1888 udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
1889 inode->i_ino);
1898 struct inode *__udf_iget(struct super_block *sb, struct kernel_lb_addr *ino,
1902 struct inode *inode = iget_locked(sb, block);
1905 if (!inode)
1908 if (!(inode->i_state & I_NEW)) {
1909 if (UDF_I(inode)->i_hidden != hidden_inode) {
1910 iput(inode);
1913 return inode;
1916 memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));
1917 err = udf_read_inode(inode, hidden_inode);
1919 iget_failed(inode);
1922 unlock_new_inode(inode);
1924 return inode;
1927 int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
1930 struct super_block *sb = inode->i_sb;
1937 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1939 else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1954 mark_buffer_dirty_inode(bh, inode);
1983 cp_type = udf_current_aext(inode, epos, &cp_loc, &cp_len, 0);
1986 __udf_add_aext(inode, &nepos, &cp_loc, cp_len, 1);
1987 udf_write_aext(inode, epos, &nepos.block,
1990 __udf_add_aext(inode, epos, &nepos.block,
2001 * Append extent at the given position - should be the first free one in inode
2002 * / indirect extent. This function assumes there is enough space in the inode
2005 int __udf_add_aext(struct inode *inode, struct extent_position *epos,
2008 struct udf_inode_info *iinfo = UDF_I(inode);
2021 epos->offset - udf_file_entry_alloc_offset(inode));
2026 WARN_ON(epos->offset + adsize > inode->i_sb->s_blocksize);
2029 udf_write_aext(inode, epos, eloc, elen, inc);
2033 mark_inode_dirty(inode);
2037 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2038 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2044 mark_buffer_dirty_inode(epos->bh, inode);
2051 * Append extent at given position - should be the first free one in inode
2054 int udf_add_aext(struct inode *inode, struct extent_position *epos,
2058 struct super_block *sb = inode->i_sb;
2060 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
2062 else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
2077 err = udf_setup_indirect_aext(inode, new_block, epos);
2082 return __udf_add_aext(inode, epos, eloc, elen, inc);
2085 void udf_write_aext(struct inode *inode, struct extent_position *epos,
2092 struct udf_inode_info *iinfo = UDF_I(inode);
2096 udf_file_entry_alloc_offset(inode) +
2120 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2121 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
2128 mark_buffer_dirty_inode(epos->bh, inode);
2130 mark_inode_dirty(inode);
2143 int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
2149 while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
2154 udf_err(inode->i_sb,
2155 "too many indirect extents in inode %lu\n",
2156 inode->i_ino);
2163 block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
2164 epos->bh = udf_tread(inode->i_sb, block);
2174 int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
2182 struct udf_inode_info *iinfo = UDF_I(inode);
2186 epos->offset = udf_file_entry_alloc_offset(inode);
2188 udf_file_entry_alloc_offset(inode) +
2190 alen = udf_file_entry_alloc_offset(inode) +
2228 static int udf_insert_aext(struct inode *inode, struct extent_position epos,
2239 while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
2240 udf_write_aext(inode, &epos, &neloc, nelen, 1);
2244 err = udf_add_aext(inode, &epos, &neloc, nelen, 1);
2250 int8_t udf_delete_aext(struct inode *inode, struct extent_position epos)
2265 iinfo = UDF_I(inode);
2274 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
2277 while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
2278 udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);
2291 udf_free_blocks(inode->i_sb, inode, &epos.block, 0, 1);
2292 udf_write_aext(inode, &oepos, &eloc, elen, 1);
2293 udf_write_aext(inode, &oepos, &eloc, elen, 1);
2296 mark_inode_dirty(inode);
2300 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2301 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2307 mark_buffer_dirty_inode(oepos.bh, inode);
2310 udf_write_aext(inode, &oepos, &eloc, elen, 1);
2313 mark_inode_dirty(inode);
2317 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2318 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2324 mark_buffer_dirty_inode(oepos.bh, inode);
2334 int8_t inode_bmap(struct inode *inode, sector_t block,
2338 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2343 iinfo = UDF_I(inode);
2344 if (!udf_read_extent_cache(inode, bcount, &lbcount, pos)) {
2351 etype = udf_next_aext(inode, pos, eloc, elen, 1);
2360 udf_update_extent_cache(inode, lbcount - *elen, pos);
2366 udf_pblk_t udf_block_map(struct inode *inode, sector_t block)
2374 down_read(&UDF_I(inode)->i_data_sem);
2376 if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
2378 ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
2382 up_read(&UDF_I(inode)->i_data_sem);
2385 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))