1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * truncate.c 4 * 5 * PURPOSE 6 * Truncate handling routines for the OSTA-UDF(tm) filesystem. 7 * 8 * COPYRIGHT 9 * (C) 1999-2004 Ben Fennema 10 * (C) 1999 Stelias Computing Inc 11 * 12 * HISTORY 13 * 14 * 02/24/99 blf Created. 15 * 16 */ 17 18 #include "udfdecl.h" 19 #include <linux/fs.h> 20 #include <linux/mm.h> 21 22 #include "udf_i.h" 23 #include "udf_sb.h" 24 25 static void extent_trunc(struct inode *inode, struct extent_position *epos, 26 struct kernel_lb_addr *eloc, int8_t etype, uint32_t elen, 27 uint32_t nelen) 28 { 29 struct kernel_lb_addr neloc = {}; 30 int last_block = (elen + inode->i_sb->s_blocksize - 1) >> 31 inode->i_sb->s_blocksize_bits; 32 int first_block = (nelen + inode->i_sb->s_blocksize - 1) >> 33 inode->i_sb->s_blocksize_bits; 34 35 if (nelen) { 36 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) { 37 udf_free_blocks(inode->i_sb, inode, eloc, 0, 38 last_block); 39 etype = (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30); 40 } else 41 neloc = *eloc; 42 nelen = (etype << 30) | nelen; 43 } 44 45 if (elen != nelen) { 46 udf_write_aext(inode, epos, &neloc, nelen, 0); 47 if (last_block > first_block) { 48 if (etype == (EXT_RECORDED_ALLOCATED >> 30)) 49 mark_inode_dirty(inode); 50 51 if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) 52 udf_free_blocks(inode->i_sb, inode, eloc, 53 first_block, 54 last_block - first_block); 55 } 56 } 57 } 58 59 /* 60 * Truncate the last extent to match i_size. This function assumes 61 * that preallocation extent is already truncated. 62 */ 63 void udf_truncate_tail_extent(struct inode *inode) 64 { 65 struct extent_position epos = {}; 66 struct kernel_lb_addr eloc; 67 uint32_t elen, nelen; 68 uint64_t lbcount = 0; 69 int8_t etype = -1, netype; 70 int adsize; 71 struct udf_inode_info *iinfo = UDF_I(inode); 72 73 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB || 74 inode->i_size == iinfo->i_lenExtents) 75 return; 76 /* Are we going to delete the file anyway? */ 77 if (inode->i_nlink == 0) 78 return; 79 80 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 81 adsize = sizeof(struct short_ad); 82 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 83 adsize = sizeof(struct long_ad); 84 else 85 BUG(); 86 87 /* Find the last extent in the file */ 88 while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) { 89 etype = netype; 90 lbcount += elen; 91 if (lbcount > inode->i_size) { 92 if (lbcount - inode->i_size >= inode->i_sb->s_blocksize) 93 udf_warn(inode->i_sb, 94 "Too long extent after EOF in inode %u: i_size: %lld lbcount: %lld extent %u+%u\n", 95 (unsigned)inode->i_ino, 96 (long long)inode->i_size, 97 (long long)lbcount, 98 (unsigned)eloc.logicalBlockNum, 99 (unsigned)elen); 100 nelen = elen - (lbcount - inode->i_size); 101 epos.offset -= adsize; 102 extent_trunc(inode, &epos, &eloc, etype, elen, nelen); 103 epos.offset += adsize; 104 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) != -1) 105 udf_err(inode->i_sb, 106 "Extent after EOF in inode %u\n", 107 (unsigned)inode->i_ino); 108 break; 109 } 110 } 111 /* This inode entry is in-memory only and thus we don't have to mark 112 * the inode dirty */ 113 iinfo->i_lenExtents = inode->i_size; 114 brelse(epos.bh); 115 } 116 117 void udf_discard_prealloc(struct inode *inode) 118 { 119 struct extent_position epos = {}; 120 struct extent_position prev_epos = {}; 121 struct kernel_lb_addr eloc; 122 uint32_t elen; 123 uint64_t lbcount = 0; 124 int8_t etype = -1; 125 struct udf_inode_info *iinfo = UDF_I(inode); 126 int bsize = i_blocksize(inode); 127 128 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB || 129 ALIGN(inode->i_size, bsize) == ALIGN(iinfo->i_lenExtents, bsize)) 130 return; 131 132 epos.block = iinfo->i_location; 133 134 /* Find the last extent in the file */ 135 while (udf_next_aext(inode, &epos, &eloc, &elen, 0) != -1) { 136 brelse(prev_epos.bh); 137 prev_epos = epos; 138 if (prev_epos.bh) 139 get_bh(prev_epos.bh); 140 141 etype = udf_next_aext(inode, &epos, &eloc, &elen, 1); 142 lbcount += elen; 143 } 144 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) { 145 lbcount -= elen; 146 udf_delete_aext(inode, prev_epos); 147 udf_free_blocks(inode->i_sb, inode, &eloc, 0, 148 DIV_ROUND_UP(elen, bsize)); 149 } 150 /* This inode entry is in-memory only and thus we don't have to mark 151 * the inode dirty */ 152 iinfo->i_lenExtents = lbcount; 153 brelse(epos.bh); 154 brelse(prev_epos.bh); 155 } 156 157 static void udf_update_alloc_ext_desc(struct inode *inode, 158 struct extent_position *epos, 159 u32 lenalloc) 160 { 161 struct super_block *sb = inode->i_sb; 162 struct udf_sb_info *sbi = UDF_SB(sb); 163 164 struct allocExtDesc *aed = (struct allocExtDesc *) (epos->bh->b_data); 165 int len = sizeof(struct allocExtDesc); 166 167 aed->lengthAllocDescs = cpu_to_le32(lenalloc); 168 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || sbi->s_udfrev >= 0x0201) 169 len += lenalloc; 170 171 udf_update_tag(epos->bh->b_data, len); 172 mark_buffer_dirty_inode(epos->bh, inode); 173 } 174 175 /* 176 * Truncate extents of inode to inode->i_size. This function can be used only 177 * for making file shorter. For making file longer, udf_extend_file() has to 178 * be used. 179 */ 180 int udf_truncate_extents(struct inode *inode) 181 { 182 struct extent_position epos; 183 struct kernel_lb_addr eloc, neloc = {}; 184 uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc; 185 int8_t etype; 186 struct super_block *sb = inode->i_sb; 187 sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset; 188 loff_t byte_offset; 189 int adsize; 190 struct udf_inode_info *iinfo = UDF_I(inode); 191 192 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 193 adsize = sizeof(struct short_ad); 194 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 195 adsize = sizeof(struct long_ad); 196 else 197 BUG(); 198 199 etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset); 200 byte_offset = (offset << sb->s_blocksize_bits) + 201 (inode->i_size & (sb->s_blocksize - 1)); 202 if (etype == -1) { 203 /* We should extend the file? */ 204 WARN_ON(byte_offset); 205 return 0; 206 } 207 epos.offset -= adsize; 208 extent_trunc(inode, &epos, &eloc, etype, elen, byte_offset); 209 epos.offset += adsize; 210 if (byte_offset) 211 lenalloc = epos.offset; 212 else 213 lenalloc = epos.offset - adsize; 214 215 if (!epos.bh) 216 lenalloc -= udf_file_entry_alloc_offset(inode); 217 else 218 lenalloc -= sizeof(struct allocExtDesc); 219 220 while ((etype = udf_current_aext(inode, &epos, &eloc, 221 &elen, 0)) != -1) { 222 if (etype == (EXT_NEXT_EXTENT_ALLOCDESCS >> 30)) { 223 udf_write_aext(inode, &epos, &neloc, nelen, 0); 224 if (indirect_ext_len) { 225 /* We managed to free all extents in the 226 * indirect extent - free it too */ 227 BUG_ON(!epos.bh); 228 udf_free_blocks(sb, NULL, &epos.block, 229 0, indirect_ext_len); 230 } else if (!epos.bh) { 231 iinfo->i_lenAlloc = lenalloc; 232 mark_inode_dirty(inode); 233 } else 234 udf_update_alloc_ext_desc(inode, 235 &epos, lenalloc); 236 brelse(epos.bh); 237 epos.offset = sizeof(struct allocExtDesc); 238 epos.block = eloc; 239 epos.bh = sb_bread(sb, 240 udf_get_lb_pblock(sb, &eloc, 0)); 241 /* Error reading indirect block? */ 242 if (!epos.bh) 243 return -EIO; 244 if (elen) 245 indirect_ext_len = 246 (elen + sb->s_blocksize - 1) >> 247 sb->s_blocksize_bits; 248 else 249 indirect_ext_len = 1; 250 } else { 251 extent_trunc(inode, &epos, &eloc, etype, elen, 0); 252 epos.offset += adsize; 253 } 254 } 255 256 if (indirect_ext_len) { 257 BUG_ON(!epos.bh); 258 udf_free_blocks(sb, NULL, &epos.block, 0, indirect_ext_len); 259 } else if (!epos.bh) { 260 iinfo->i_lenAlloc = lenalloc; 261 mark_inode_dirty(inode); 262 } else 263 udf_update_alloc_ext_desc(inode, &epos, lenalloc); 264 iinfo->i_lenExtents = inode->i_size; 265 266 brelse(epos.bh); 267 return 0; 268 } 269