Commit | Line | Data |
---|---|---|
5ce34554 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * truncate.c | |
4 | * | |
5 | * PURPOSE | |
6 | * Truncate handling routines for the OSTA-UDF(tm) filesystem. | |
7 | * | |
1da177e4 | 8 | * COPYRIGHT |
1da177e4 LT |
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> | |
1da177e4 LT |
21 | |
22 | #include "udf_i.h" | |
23 | #include "udf_sb.h" | |
24 | ||
cb00ea35 | 25 | static void extent_trunc(struct inode *inode, struct extent_position *epos, |
97e961fd | 26 | struct kernel_lb_addr *eloc, int8_t etype, uint32_t elen, |
cb00ea35 | 27 | uint32_t nelen) |
1da177e4 | 28 | { |
5ca4e4be | 29 | struct kernel_lb_addr neloc = {}; |
28de7948 CG |
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; | |
1da177e4 | 34 | |
cb00ea35 CG |
35 | if (nelen) { |
36 | if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) { | |
37 | udf_free_blocks(inode->i_sb, inode, eloc, 0, | |
38 | last_block); | |
1da177e4 | 39 | etype = (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30); |
cb00ea35 | 40 | } else |
97e961fd | 41 | neloc = *eloc; |
1da177e4 LT |
42 | nelen = (etype << 30) | nelen; |
43 | } | |
44 | ||
cb00ea35 | 45 | if (elen != nelen) { |
97e961fd | 46 | udf_write_aext(inode, epos, &neloc, nelen, 0); |
b490bdd6 | 47 | if (last_block > first_block) { |
1da177e4 LT |
48 | if (etype == (EXT_RECORDED_ALLOCATED >> 30)) |
49 | mark_inode_dirty(inode); | |
50 | ||
51 | if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) | |
cb00ea35 CG |
52 | udf_free_blocks(inode->i_sb, inode, eloc, |
53 | first_block, | |
54 | last_block - first_block); | |
1da177e4 LT |
55 | } |
56 | } | |
57 | } | |
58 | ||
74584ae5 JK |
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) | |
1da177e4 | 64 | { |
28de7948 | 65 | struct extent_position epos = {}; |
5ca4e4be | 66 | struct kernel_lb_addr eloc; |
ff116fc8 | 67 | uint32_t elen, nelen; |
1da177e4 LT |
68 | uint64_t lbcount = 0; |
69 | int8_t etype = -1, netype; | |
1da177e4 | 70 | int adsize; |
48d6d8ff | 71 | struct udf_inode_info *iinfo = UDF_I(inode); |
1da177e4 | 72 | |
48d6d8ff MS |
73 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB || |
74 | inode->i_size == iinfo->i_lenExtents) | |
74584ae5 JK |
75 | return; |
76 | /* Are we going to delete the file anyway? */ | |
77 | if (inode->i_nlink == 0) | |
1da177e4 | 78 | return; |
1da177e4 | 79 | |
48d6d8ff | 80 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
5ca4e4be | 81 | adsize = sizeof(struct short_ad); |
48d6d8ff | 82 | else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) |
5ca4e4be | 83 | adsize = sizeof(struct long_ad); |
1da177e4 | 84 | else |
74584ae5 | 85 | BUG(); |
1da177e4 | 86 | |
ff116fc8 | 87 | /* Find the last extent in the file */ |
cb00ea35 | 88 | while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) { |
1da177e4 LT |
89 | etype = netype; |
90 | lbcount += elen; | |
74584ae5 JK |
91 | if (lbcount > inode->i_size) { |
92 | if (lbcount - inode->i_size >= inode->i_sb->s_blocksize) | |
78ace70c JP |
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); | |
1da177e4 | 100 | nelen = elen - (lbcount - inode->i_size); |
ff116fc8 | 101 | epos.offset -= adsize; |
97e961fd | 102 | extent_trunc(inode, &epos, &eloc, etype, elen, nelen); |
ff116fc8 | 103 | epos.offset += adsize; |
74584ae5 | 104 | if (udf_next_aext(inode, &epos, &eloc, &elen, 1) != -1) |
78ace70c JP |
105 | udf_err(inode->i_sb, |
106 | "Extent after EOF in inode %u\n", | |
107 | (unsigned)inode->i_ino); | |
74584ae5 | 108 | break; |
1da177e4 LT |
109 | } |
110 | } | |
74584ae5 JK |
111 | /* This inode entry is in-memory only and thus we don't have to mark |
112 | * the inode dirty */ | |
48d6d8ff | 113 | iinfo->i_lenExtents = inode->i_size; |
74584ae5 JK |
114 | brelse(epos.bh); |
115 | } | |
116 | ||
117 | void udf_discard_prealloc(struct inode *inode) | |
118 | { | |
cfe4c1b2 JK |
119 | struct extent_position epos = {}; |
120 | struct extent_position prev_epos = {}; | |
5ca4e4be | 121 | struct kernel_lb_addr eloc; |
74584ae5 JK |
122 | uint32_t elen; |
123 | uint64_t lbcount = 0; | |
1fb40763 | 124 | int8_t etype = -1; |
48d6d8ff | 125 | struct udf_inode_info *iinfo = UDF_I(inode); |
f768dc3c | 126 | int bsize = i_blocksize(inode); |
74584ae5 | 127 | |
48d6d8ff | 128 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB || |
6ad53f0f | 129 | ALIGN(inode->i_size, bsize) == ALIGN(iinfo->i_lenExtents, bsize)) |
74584ae5 JK |
130 | return; |
131 | ||
48d6d8ff | 132 | epos.block = iinfo->i_location; |
74584ae5 JK |
133 | |
134 | /* Find the last extent in the file */ | |
1fb40763 | 135 | while (udf_next_aext(inode, &epos, &eloc, &elen, 0) != -1) { |
cfe4c1b2 JK |
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); | |
74584ae5 JK |
142 | lbcount += elen; |
143 | } | |
ff116fc8 | 144 | if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) { |
1da177e4 | 145 | lbcount -= elen; |
cfe4c1b2 JK |
146 | udf_delete_aext(inode, prev_epos); |
147 | udf_free_blocks(inode->i_sb, inode, &eloc, 0, | |
f768dc3c | 148 | DIV_ROUND_UP(elen, bsize)); |
1da177e4 | 149 | } |
74584ae5 JK |
150 | /* This inode entry is in-memory only and thus we don't have to mark |
151 | * the inode dirty */ | |
48d6d8ff | 152 | iinfo->i_lenExtents = lbcount; |
3bf25cb4 | 153 | brelse(epos.bh); |
cfe4c1b2 | 154 | brelse(prev_epos.bh); |
1da177e4 LT |
155 | } |
156 | ||
456390de | 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 | ||
7e49b6f2 JK |
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 | */ | |
2b42be5e | 180 | int udf_truncate_extents(struct inode *inode) |
1da177e4 | 181 | { |
ff116fc8 | 182 | struct extent_position epos; |
5ca4e4be | 183 | struct kernel_lb_addr eloc, neloc = {}; |
ff116fc8 | 184 | uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc; |
1da177e4 | 185 | int8_t etype; |
31170b6a JK |
186 | struct super_block *sb = inode->i_sb; |
187 | sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset; | |
60448b1d | 188 | loff_t byte_offset; |
1da177e4 | 189 | int adsize; |
48d6d8ff | 190 | struct udf_inode_info *iinfo = UDF_I(inode); |
1da177e4 | 191 | |
48d6d8ff | 192 | if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) |
5ca4e4be | 193 | adsize = sizeof(struct short_ad); |
48d6d8ff | 194 | else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) |
5ca4e4be | 195 | adsize = sizeof(struct long_ad); |
1da177e4 | 196 | else |
ff116fc8 | 197 | BUG(); |
1da177e4 | 198 | |
ff116fc8 | 199 | etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset); |
28de7948 CG |
200 | byte_offset = (offset << sb->s_blocksize_bits) + |
201 | (inode->i_size & (sb->s_blocksize - 1)); | |
7e49b6f2 JK |
202 | if (etype == -1) { |
203 | /* We should extend the file? */ | |
204 | WARN_ON(byte_offset); | |
2b42be5e | 205 | return 0; |
7e49b6f2 JK |
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; | |
1da177e4 | 214 | |
7e49b6f2 JK |
215 | if (!epos.bh) |
216 | lenalloc -= udf_file_entry_alloc_offset(inode); | |
217 | else | |
218 | lenalloc -= sizeof(struct allocExtDesc); | |
31170b6a | 219 | |
7e49b6f2 JK |
220 | while ((etype = udf_current_aext(inode, &epos, &eloc, |
221 | &elen, 0)) != -1) { | |
800552ce | 222 | if (etype == (EXT_NEXT_EXTENT_ALLOCDESCS >> 30)) { |
7e49b6f2 JK |
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); | |
17dc59ba | 228 | udf_free_blocks(sb, NULL, &epos.block, |
7e49b6f2 JK |
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; | |
101ee137 | 239 | epos.bh = sb_bread(sb, |
7e49b6f2 | 240 | udf_get_lb_pblock(sb, &eloc, 0)); |
d3ca4651 JK |
241 | /* Error reading indirect block? */ |
242 | if (!epos.bh) | |
2b42be5e | 243 | return -EIO; |
7e49b6f2 JK |
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; | |
1da177e4 LT |
253 | } |
254 | } | |
7e49b6f2 JK |
255 | |
256 | if (indirect_ext_len) { | |
257 | BUG_ON(!epos.bh); | |
17dc59ba | 258 | udf_free_blocks(sb, NULL, &epos.block, 0, indirect_ext_len); |
7e49b6f2 JK |
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); | |
48d6d8ff | 264 | iinfo->i_lenExtents = inode->i_size; |
1da177e4 | 265 | |
3bf25cb4 | 266 | brelse(epos.bh); |
2b42be5e | 267 | return 0; |
1da177e4 | 268 | } |