Lines Matching refs:inode
3 * inode.c
54 static int udf_update_inode(struct inode *, int);
55 static int udf_sync_inode(struct inode *inode);
56 static int udf_alloc_i_data(struct inode *inode, size_t size);
57 static int inode_getblk(struct inode *inode, struct udf_map_rq *map);
58 static int udf_insert_aext(struct inode *, struct extent_position,
60 static void udf_split_extents(struct inode *, int *, int, udf_pblk_t,
62 static void udf_prealloc_extents(struct inode *, int, int,
64 static void udf_merge_extents(struct inode *, struct kernel_long_ad *, int *);
65 static int udf_update_extents(struct inode *, struct kernel_long_ad *, int,
67 static int udf_get_block_wb(struct inode *inode, sector_t block,
70 static void __udf_clear_extent_cache(struct inode *inode)
72 struct udf_inode_info *iinfo = UDF_I(inode);
81 static void udf_clear_extent_cache(struct inode *inode)
83 struct udf_inode_info *iinfo = UDF_I(inode);
86 __udf_clear_extent_cache(inode);
91 static int udf_read_extent_cache(struct inode *inode, loff_t bcount,
94 struct udf_inode_info *iinfo = UDF_I(inode);
113 static void udf_update_extent_cache(struct inode *inode, loff_t estart,
116 struct udf_inode_info *iinfo = UDF_I(inode);
120 __udf_clear_extent_cache(inode);
136 void udf_evict_inode(struct inode *inode)
138 struct udf_inode_info *iinfo = UDF_I(inode);
141 if (!is_bad_inode(inode)) {
142 if (!inode->i_nlink) {
144 udf_setsize(inode, 0);
145 udf_update_inode(inode, IS_SYNC(inode));
148 inode->i_size != iinfo->i_lenExtents) {
149 udf_warn(inode->i_sb,
150 "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
151 inode->i_ino, inode->i_mode,
152 (unsigned long long)inode->i_size,
156 truncate_inode_pages_final(&inode->i_data);
157 invalidate_inode_buffers(inode);
158 clear_inode(inode);
161 udf_clear_extent_cache(inode);
163 udf_free_inode(inode);
169 struct inode *inode = mapping->host;
170 struct udf_inode_info *iinfo = UDF_I(inode);
171 loff_t isize = inode->i_size;
174 truncate_pagecache(inode, isize);
177 udf_clear_extent_cache(inode);
178 udf_truncate_extents(inode);
187 struct inode *inode = folio->mapping->host;
188 struct udf_inode_info *iinfo = UDF_I(inode);
193 i_size_read(inode));
195 mark_inode_dirty(inode);
203 struct inode *inode = mapping->host;
204 struct udf_inode_info *iinfo = UDF_I(inode);
213 struct inode *inode = page->mapping->host;
215 struct udf_inode_info *iinfo = UDF_I(inode);
216 loff_t isize = i_size_read(inode);
282 struct inode *inode = file_inode(file);
285 if (UDF_I(inode)->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB)
289 if (last_pos > inode->i_size)
290 i_size_write(inode, last_pos);
302 struct inode *inode = mapping->host;
307 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
309 ret = blockdev_direct_IO(iocb, inode, iter, udf_get_block);
342 int udf_expand_file_adinicb(struct inode *inode)
345 struct udf_inode_info *iinfo = UDF_I(inode);
348 WARN_ON_ONCE(!inode_is_locked(inode));
351 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
356 mark_inode_dirty(inode);
360 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
370 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
377 err = filemap_fdatawrite(inode->i_mapping);
383 inode->i_size);
386 iinfo->i_lenAlloc = inode->i_size;
390 mark_inode_dirty(inode);
408 static int udf_map_block(struct inode *inode, struct udf_map_rq *map)
411 struct udf_inode_info *iinfo = UDF_I(inode);
424 if (inode_bmap(inode, map->lblk, &epos, &eloc, &elen, &offset)
426 map->pblk = udf_get_lb_pblock(inode->i_sb, &eloc,
441 if (((loff_t)map->lblk) << inode->i_blkbits >= iinfo->i_lenExtents)
442 udf_discard_prealloc(inode);
443 udf_clear_extent_cache(inode);
444 err = inode_getblk(inode, map);
449 static int __udf_get_block(struct inode *inode, sector_t block,
458 err = udf_map_block(inode, &map);
462 map_bh(bh_result, inode->i_sb, map.pblk);
469 int udf_get_block(struct inode *inode, sector_t block,
480 if (!S_ISREG(inode->i_mode))
482 return __udf_get_block(inode, block, bh_result, flags);
491 static int udf_get_block_wb(struct inode *inode, sector_t block,
494 return __udf_get_block(inode, block, bh_result, 0);
500 static int udf_do_extend_file(struct inode *inode,
507 struct super_block *sb = inode->i_sb;
516 iinfo = UDF_I(inode);
541 err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
550 udf_write_aext(inode, last_pos, &last_ext->extLocation,
559 udf_next_aext(inode, last_pos, &tmploc, &tmplen, 0);
576 err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
586 err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
606 udf_clear_extent_cache(inode);
607 udf_truncate_extents(inode);
612 static void udf_do_extend_final_block(struct inode *inode,
627 UDF_I(inode)->i_lenExtents += added_bytes;
629 udf_write_aext(inode, last_pos, &last_ext->extLocation,
633 static int udf_extend_file(struct inode *inode, loff_t newsize)
640 struct super_block *sb = inode->i_sb;
644 struct udf_inode_info *iinfo = UDF_I(inode);
661 udf_discard_prealloc(inode);
663 etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
667 elen > ((loff_t)offset + 1) << inode->i_blkbits);
669 if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) ||
678 etype = udf_next_aext(inode, &epos, &extent.extLocation,
683 new_elen = ((loff_t)offset << inode->i_blkbits) |
691 udf_do_extend_final_block(inode, &epos, &extent, new_elen);
693 err = udf_do_extend_file(inode, &epos, &extent, new_elen);
705 static int inode_getblk(struct inode *inode, struct udf_map_rq *map)
717 struct udf_inode_info *iinfo = UDF_I(inode);
723 prev_epos.offset = udf_file_entry_alloc_offset(inode);
727 b_off = (loff_t)map->lblk << inode->i_sb->s_blocksize_bits;
752 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
763 ((elen + inode->i_sb->s_blocksize - 1) >>
764 inode->i_sb->s_blocksize_bits);
770 offset = b_off >> inode->i_sb->s_blocksize_bits;
775 udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
776 udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
782 if (elen & (inode->i_sb->s_blocksize - 1)) {
784 ((elen + inode->i_sb->s_blocksize - 1) &
785 ~(inode->i_sb->s_blocksize - 1));
788 inode->i_sb->s_blocksize);
789 udf_write_aext(inode, &cur_epos, &eloc, elen, 1);
792 map->pblk = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
815 hole_len = (loff_t)offset << inode->i_blkbits;
816 ret = udf_do_extend_file(inode, &prev_epos, laarr, hole_len);
829 inode->i_sb->s_blocksize;
850 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
874 newblocknum = udf_new_block(inode->i_sb, inode,
880 iinfo->i_lenExtents += inode->i_sb->s_blocksize;
887 udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
890 udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
893 udf_merge_extents(inode, laarr, &endnum);
898 ret = udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
902 map->pblk = udf_get_pblock(inode->i_sb, newblocknum,
911 inode_set_ctime_current(inode);
913 if (IS_SYNC(inode))
914 udf_sync_inode(inode);
916 mark_inode_dirty(inode);
925 static void udf_split_extents(struct inode *inode, int *c, int offset,
929 unsigned long blocksize = inode->i_sb->s_blocksize;
930 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
952 udf_free_blocks(inode->i_sb, inode,
972 UDF_I(inode)->i_location.partitionReferenceNum;
989 static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
1007 inode->i_sb->s_blocksize - 1) >>
1008 inode->i_sb->s_blocksize_bits);
1021 inode->i_sb->s_blocksize - 1) >>
1022 inode->i_sb->s_blocksize_bits);
1030 inode->i_sb->s_blocksize - 1) >>
1031 inode->i_sb->s_blocksize_bits);
1032 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
1041 inode->i_sb->s_blocksize_bits);
1053 inode->i_sb->s_blocksize_bits);
1060 inode->i_sb->s_blocksize - 1) >>
1061 inode->i_sb->s_blocksize_bits;
1066 inode->i_sb->s_blocksize_bits);
1079 UDF_I(inode)->i_lenExtents +=
1080 numalloc << inode->i_sb->s_blocksize_bits;
1085 static void udf_merge_extents(struct inode *inode, struct kernel_long_ad *laarr,
1089 unsigned long blocksize = inode->i_sb->s_blocksize;
1090 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1122 udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0,
1155 udf_free_blocks(inode->i_sb, inode,
1169 static int udf_update_extents(struct inode *inode, struct kernel_long_ad *laarr,
1180 udf_delete_aext(inode, *epos);
1183 err = udf_insert_aext(inode, *epos,
1193 udf_next_aext(inode, epos, &laarr[i].extLocation,
1200 udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
1201 udf_write_aext(inode, epos, &laarr[i].extLocation,
1207 struct buffer_head *udf_bread(struct inode *inode, udf_pblk_t block,
1216 *err = udf_map_block(inode, &map);
1220 bh = sb_getblk(inode->i_sb, map.pblk);
1227 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
1230 mark_buffer_dirty_inode(bh, inode);
1242 int udf_setsize(struct inode *inode, loff_t newsize)
1246 unsigned int bsize = i_blocksize(inode);
1248 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1249 S_ISLNK(inode->i_mode)))
1251 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1254 filemap_invalidate_lock(inode->i_mapping);
1255 iinfo = UDF_I(inode);
1256 if (newsize > inode->i_size) {
1259 (udf_file_entry_alloc_offset(inode) + newsize)) {
1265 err = udf_expand_file_adinicb(inode);
1269 err = udf_extend_file(inode, newsize);
1273 truncate_setsize(inode, newsize);
1277 udf_clear_extent_cache(inode);
1280 udf_file_entry_alloc_offset(inode));
1282 truncate_setsize(inode, newsize);
1286 err = block_truncate_page(inode->i_mapping, newsize,
1290 truncate_setsize(inode, newsize);
1292 udf_clear_extent_cache(inode);
1293 err = udf_truncate_extents(inode);
1299 inode->i_mtime = inode_set_ctime_current(inode);
1300 if (IS_SYNC(inode))
1301 udf_sync_inode(inode);
1303 mark_inode_dirty(inode);
1305 filemap_invalidate_unlock(inode->i_mapping);
1312 * inode on write-once media but avoid looping for too long on corrupted media.
1316 static int udf_read_inode(struct inode *inode, bool hidden_inode)
1322 struct udf_inode_info *iinfo = UDF_I(inode);
1323 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1327 int bs = inode->i_sb->s_blocksize;
1347 * Set defaults, but the inode is still incomplete!
1348 * Note: get_new_inode() sets the following on a new inode:
1358 bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
1360 udf_err(inode->i_sb, "(ino %lu) failed !bh\n", inode->i_ino);
1366 udf_err(inode->i_sb, "(ino %lu) failed ident=%u\n",
1367 inode->i_ino, ident);
1377 ibh = udf_read_ptagged(inode->i_sb, iloc, 1, &ident);
1390 udf_err(inode->i_sb,
1402 udf_err(inode->i_sb, "unsupported strategy type: %u\n",
1429 ret = udf_alloc_i_data(inode, bs -
1439 ret = udf_alloc_i_data(inode, bs - sizeof(struct fileEntry));
1451 ret = udf_alloc_i_data(inode, bs -
1465 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
1466 inode->i_uid = sbi->s_uid;
1468 i_uid_write(inode, uid);
1472 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
1473 inode->i_gid = sbi->s_gid;
1475 i_gid_write(inode, gid);
1479 inode->i_mode = sbi->s_fmode;
1482 inode->i_mode = sbi->s_dmode;
1484 inode->i_mode = udf_convert_permissions(fe);
1485 inode->i_mode &= ~sbi->s_umask;
1498 set_nlink(inode, link_count);
1500 inode->i_size = le64_to_cpu(fe->informationLength);
1501 iinfo->i_lenExtents = inode->i_size;
1504 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1505 (inode->i_sb->s_blocksize_bits - 9);
1507 udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime);
1508 udf_disk_stamp_to_time(&inode->i_mtime, fe->modificationTime);
1510 inode_set_ctime_to_ts(inode, ctime);
1519 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1520 (inode->i_sb->s_blocksize_bits - 9);
1522 udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime);
1523 udf_disk_stamp_to_time(&inode->i_mtime, efe->modificationTime);
1526 inode_set_ctime_to_ts(inode, ctime);
1538 if (iinfo->i_lenStreams >= inode->i_size)
1539 iinfo->i_lenStreams -= inode->i_size;
1543 inode->i_generation = iinfo->i_unique;
1552 if (udf_file_entry_alloc_offset(inode) + iinfo->i_lenAlloc > bs)
1560 if (iinfo->i_lenAlloc != inode->i_size)
1563 if (inode->i_size > bs - udf_file_entry_alloc_offset(inode))
1569 inode->i_op = &udf_dir_inode_operations;
1570 inode->i_fop = &udf_dir_operations;
1571 inode->i_mode |= S_IFDIR;
1572 inc_nlink(inode);
1578 inode->i_data.a_ops = &udf_aops;
1579 inode->i_op = &udf_file_inode_operations;
1580 inode->i_fop = &udf_file_operations;
1581 inode->i_mode |= S_IFREG;
1584 inode->i_mode |= S_IFBLK;
1587 inode->i_mode |= S_IFCHR;
1590 init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1593 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1596 inode->i_data.a_ops = &udf_symlink_aops;
1597 inode->i_op = &udf_symlink_inode_operations;
1598 inode_nohighmem(inode);
1599 inode->i_mode = S_IFLNK | 0777;
1611 udf_err(inode->i_sb, "(ino %lu) failed unknown file type=%u\n",
1612 inode->i_ino, fe->icbTag.fileType);
1615 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1617 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1619 init_special_inode(inode, inode->i_mode,
1632 static int udf_alloc_i_data(struct inode *inode, size_t size)
1634 struct udf_inode_info *iinfo = UDF_I(inode);
1660 void udf_update_extra_perms(struct inode *inode, umode_t mode)
1662 struct udf_inode_info *iinfo = UDF_I(inode);
1677 int udf_write_inode(struct inode *inode, struct writeback_control *wbc)
1679 return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1682 static int udf_sync_inode(struct inode *inode)
1684 return udf_update_inode(inode, 1);
1695 static int udf_update_inode(struct inode *inode, int do_sync)
1705 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1706 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1707 struct udf_inode_info *iinfo = UDF_I(inode);
1709 bh = sb_getblk(inode->i_sb,
1710 udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0));
1717 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
1727 iinfo->i_data, inode->i_sb->s_blocksize -
1735 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1738 fe->uid = cpu_to_le32(i_uid_read(inode));
1740 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1743 fe->gid = cpu_to_le32(i_gid_read(inode));
1745 udfperms = ((inode->i_mode & 0007)) |
1746 ((inode->i_mode & 0070) << 2) |
1747 ((inode->i_mode & 0700) << 4);
1752 if (S_ISDIR(inode->i_mode) && inode->i_nlink > 0)
1753 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1758 fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1761 fe->informationLength = cpu_to_le64(inode->i_size);
1763 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1766 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1769 udf_add_extendedattr(inode,
1784 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1785 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1792 (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
1798 inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1801 udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime);
1802 udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime);
1803 udf_time_to_disk_stamp(&fe->attrTime, inode_get_ctime(inode));
1817 inode->i_sb->s_blocksize -
1820 cpu_to_le64(inode->i_size + iinfo->i_lenStreams);
1829 cpu_to_le32(inode->i_sb->s_blocksize);
1832 udf_adjust_time(iinfo, inode->i_atime);
1833 udf_adjust_time(iinfo, inode->i_mtime);
1834 udf_adjust_time(iinfo, inode_get_ctime(inode));
1836 udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime);
1837 udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime);
1839 udf_time_to_disk_stamp(&efe->attrTime, inode_get_ctime(inode));
1865 else if (S_ISDIR(inode->i_mode))
1867 else if (S_ISREG(inode->i_mode))
1869 else if (S_ISLNK(inode->i_mode))
1871 else if (S_ISBLK(inode->i_mode))
1873 else if (S_ISCHR(inode->i_mode))
1875 else if (S_ISFIFO(inode->i_mode))
1877 else if (S_ISSOCK(inode->i_mode))
1881 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1882 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1883 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1910 udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
1911 inode->i_ino);
1920 struct inode *__udf_iget(struct super_block *sb, struct kernel_lb_addr *ino,
1924 struct inode *inode = iget_locked(sb, block);
1927 if (!inode)
1930 if (!(inode->i_state & I_NEW)) {
1931 if (UDF_I(inode)->i_hidden != hidden_inode) {
1932 iput(inode);
1935 return inode;
1938 memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));
1939 err = udf_read_inode(inode, hidden_inode);
1941 iget_failed(inode);
1944 unlock_new_inode(inode);
1946 return inode;
1949 int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
1952 struct super_block *sb = inode->i_sb;
1959 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1961 else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1976 mark_buffer_dirty_inode(bh, inode);
2005 cp_type = udf_current_aext(inode, epos, &cp_loc, &cp_len, 0);
2008 __udf_add_aext(inode, &nepos, &cp_loc, cp_len, 1);
2009 udf_write_aext(inode, epos, &nepos.block,
2012 __udf_add_aext(inode, epos, &nepos.block,
2023 * Append extent at the given position - should be the first free one in inode
2024 * / indirect extent. This function assumes there is enough space in the inode
2027 int __udf_add_aext(struct inode *inode, struct extent_position *epos,
2030 struct udf_inode_info *iinfo = UDF_I(inode);
2043 epos->offset - udf_file_entry_alloc_offset(inode));
2048 WARN_ON(epos->offset + adsize > inode->i_sb->s_blocksize);
2051 udf_write_aext(inode, epos, eloc, elen, inc);
2055 mark_inode_dirty(inode);
2059 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2060 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2066 mark_buffer_dirty_inode(epos->bh, inode);
2073 * Append extent at given position - should be the first free one in inode
2076 int udf_add_aext(struct inode *inode, struct extent_position *epos,
2080 struct super_block *sb = inode->i_sb;
2082 if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
2084 else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
2099 err = udf_setup_indirect_aext(inode, new_block, epos);
2104 return __udf_add_aext(inode, epos, eloc, elen, inc);
2107 void udf_write_aext(struct inode *inode, struct extent_position *epos,
2114 struct udf_inode_info *iinfo = UDF_I(inode);
2118 udf_file_entry_alloc_offset(inode) +
2142 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2143 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
2150 mark_buffer_dirty_inode(epos->bh, inode);
2152 mark_inode_dirty(inode);
2165 int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
2171 while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
2176 udf_err(inode->i_sb,
2177 "too many indirect extents in inode %lu\n",
2178 inode->i_ino);
2185 block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
2186 epos->bh = sb_bread(inode->i_sb, block);
2196 int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
2204 struct udf_inode_info *iinfo = UDF_I(inode);
2208 epos->offset = udf_file_entry_alloc_offset(inode);
2210 udf_file_entry_alloc_offset(inode) +
2212 alen = udf_file_entry_alloc_offset(inode) +
2250 static int udf_insert_aext(struct inode *inode, struct extent_position epos,
2261 while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
2262 udf_write_aext(inode, &epos, &neloc, nelen, 1);
2266 err = udf_add_aext(inode, &epos, &neloc, nelen, 1);
2272 int8_t udf_delete_aext(struct inode *inode, struct extent_position epos)
2287 iinfo = UDF_I(inode);
2296 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
2299 while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
2300 udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);
2313 udf_free_blocks(inode->i_sb, inode, &epos.block, 0, 1);
2314 udf_write_aext(inode, &oepos, &eloc, elen, 1);
2315 udf_write_aext(inode, &oepos, &eloc, elen, 1);
2318 mark_inode_dirty(inode);
2322 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2323 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2329 mark_buffer_dirty_inode(oepos.bh, inode);
2332 udf_write_aext(inode, &oepos, &eloc, elen, 1);
2335 mark_inode_dirty(inode);
2339 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2340 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2346 mark_buffer_dirty_inode(oepos.bh, inode);
2356 int8_t inode_bmap(struct inode *inode, sector_t block,
2360 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2365 iinfo = UDF_I(inode);
2366 if (!udf_read_extent_cache(inode, bcount, &lbcount, pos)) {
2373 etype = udf_next_aext(inode, pos, eloc, elen, 1);
2382 udf_update_extent_cache(inode, lbcount - *elen, pos);