5 * Truncate handling routines for the OSTA-UDF(tm) filesystem.
8 * This file is distributed under the terms of the GNU General Public
9 * License (GPL). Copies of the GPL can be obtained from:
10 * ftp://prep.ai.mit.edu/pub/gnu/GPL
11 * Each contributing author retains all rights to their own work.
13 * (C) 1999-2004 Ben Fennema
14 * (C) 1999 Stelias Computing Inc
18 * 02/24/99 blf Created.
25 #include <linux/udf_fs.h>
26 #include <linux/buffer_head.h>
31 static void extent_trunc(struct inode
*inode
, struct extent_position
*epos
,
32 kernel_lb_addr eloc
, int8_t etype
, uint32_t elen
,
35 kernel_lb_addr neloc
= {};
36 int last_block
= (elen
+ inode
->i_sb
->s_blocksize
- 1) >>
37 inode
->i_sb
->s_blocksize_bits
;
38 int first_block
= (nelen
+ inode
->i_sb
->s_blocksize
- 1) >>
39 inode
->i_sb
->s_blocksize_bits
;
42 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
43 udf_free_blocks(inode
->i_sb
, inode
, eloc
, 0,
45 etype
= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30);
48 nelen
= (etype
<< 30) | nelen
;
52 udf_write_aext(inode
, epos
, neloc
, nelen
, 0);
53 if (last_block
- first_block
> 0) {
54 if (etype
== (EXT_RECORDED_ALLOCATED
>> 30))
55 mark_inode_dirty(inode
);
57 if (etype
!= (EXT_NOT_RECORDED_NOT_ALLOCATED
>> 30))
58 udf_free_blocks(inode
->i_sb
, inode
, eloc
,
60 last_block
- first_block
);
66 * Truncate the last extent to match i_size. This function assumes
67 * that preallocation extent is already truncated.
69 void udf_truncate_tail_extent(struct inode
*inode
)
71 struct extent_position epos
= {};
75 int8_t etype
= -1, netype
;
78 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
||
79 inode
->i_size
== UDF_I_LENEXTENTS(inode
))
81 /* Are we going to delete the file anyway? */
82 if (inode
->i_nlink
== 0)
85 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_SHORT
)
86 adsize
= sizeof(short_ad
);
87 else if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_LONG
)
88 adsize
= sizeof(long_ad
);
92 /* Find the last extent in the file */
93 while ((netype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
96 if (lbcount
> inode
->i_size
) {
97 if (lbcount
- inode
->i_size
>= inode
->i_sb
->s_blocksize
)
99 "udf_truncate_tail_extent(): Too long "
100 "extent after EOF in inode %u: i_size: "
101 "%Ld lbcount: %Ld extent %u+%u\n",
102 (unsigned)inode
->i_ino
,
103 (long long)inode
->i_size
,
105 (unsigned)eloc
.logicalBlockNum
,
107 nelen
= elen
- (lbcount
- inode
->i_size
);
108 epos
.offset
-= adsize
;
109 extent_trunc(inode
, &epos
, eloc
, etype
, elen
, nelen
);
110 epos
.offset
+= adsize
;
111 if (udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1) != -1)
112 printk(KERN_ERR
"udf_truncate_tail_extent(): "
113 "Extent after EOF in inode %u.\n",
114 (unsigned)inode
->i_ino
);
118 /* This inode entry is in-memory only and thus we don't have to mark
120 UDF_I_LENEXTENTS(inode
) = inode
->i_size
;
124 void udf_discard_prealloc(struct inode
*inode
)
126 struct extent_position epos
= { NULL
, 0, {0, 0} };
129 uint64_t lbcount
= 0;
130 int8_t etype
= -1, netype
;
133 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_IN_ICB
||
134 inode
->i_size
== UDF_I_LENEXTENTS(inode
))
137 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_SHORT
)
138 adsize
= sizeof(short_ad
);
139 else if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_LONG
)
140 adsize
= sizeof(long_ad
);
144 epos
.block
= UDF_I_LOCATION(inode
);
146 /* Find the last extent in the file */
147 while ((netype
= udf_next_aext(inode
, &epos
, &eloc
, &elen
, 1)) != -1) {
151 if (etype
== (EXT_NOT_RECORDED_ALLOCATED
>> 30)) {
152 epos
.offset
-= adsize
;
154 extent_trunc(inode
, &epos
, eloc
, etype
, elen
, 0);
156 UDF_I_LENALLOC(inode
) =
157 epos
.offset
- udf_file_entry_alloc_offset(inode
);
158 mark_inode_dirty(inode
);
160 struct allocExtDesc
*aed
=
161 (struct allocExtDesc
*)(epos
.bh
->b_data
);
162 aed
->lengthAllocDescs
=
163 cpu_to_le32(epos
.offset
-
164 sizeof(struct allocExtDesc
));
165 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
166 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
167 udf_update_tag(epos
.bh
->b_data
, epos
.offset
);
169 udf_update_tag(epos
.bh
->b_data
,
170 sizeof(struct allocExtDesc
));
171 mark_buffer_dirty_inode(epos
.bh
, inode
);
174 /* This inode entry is in-memory only and thus we don't have to mark
176 UDF_I_LENEXTENTS(inode
) = lbcount
;
180 void udf_truncate_extents(struct inode
*inode
)
182 struct extent_position epos
;
183 kernel_lb_addr eloc
, neloc
= {};
184 uint32_t elen
, nelen
= 0, indirect_ext_len
= 0, lenalloc
;
186 struct super_block
*sb
= inode
->i_sb
;
187 struct udf_sb_info
*sbi
= UDF_SB(sb
);
188 sector_t first_block
= inode
->i_size
>> sb
->s_blocksize_bits
, offset
;
192 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_SHORT
)
193 adsize
= sizeof(short_ad
);
194 else if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_LONG
)
195 adsize
= sizeof(long_ad
);
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));
203 epos
.offset
-= adsize
;
204 extent_trunc(inode
, &epos
, eloc
, etype
, elen
, byte_offset
);
205 epos
.offset
+= adsize
;
207 lenalloc
= epos
.offset
;
209 lenalloc
= epos
.offset
- adsize
;
212 lenalloc
-= udf_file_entry_alloc_offset(inode
);
214 lenalloc
-= sizeof(struct allocExtDesc
);
216 while ((etype
= udf_current_aext(inode
, &epos
, &eloc
, &elen
, 0)) != -1) {
217 if (etype
== (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
218 udf_write_aext(inode
, &epos
, neloc
, nelen
, 0);
219 if (indirect_ext_len
) {
220 /* We managed to free all extents in the
221 * indirect extent - free it too */
224 udf_free_blocks(sb
, inode
, epos
.block
,
225 0, indirect_ext_len
);
228 UDF_I_LENALLOC(inode
) = lenalloc
;
229 mark_inode_dirty(inode
);
231 struct allocExtDesc
*aed
=
232 (struct allocExtDesc
*)(epos
.bh
->b_data
);
233 aed
->lengthAllocDescs
=
234 cpu_to_le32(lenalloc
);
235 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_STRICT
) ||
236 sbi
->s_udfrev
>= 0x0201)
237 udf_update_tag(epos
.bh
->b_data
,
239 sizeof(struct allocExtDesc
));
241 udf_update_tag(epos
.bh
->b_data
,
242 sizeof(struct allocExtDesc
));
243 mark_buffer_dirty_inode(epos
.bh
, inode
);
247 epos
.offset
= sizeof(struct allocExtDesc
);
249 epos
.bh
= udf_tread(sb
, udf_get_lb_pblock(sb
, eloc
, 0));
251 indirect_ext_len
= (elen
+ sb
->s_blocksize
-1) >>
252 sb
->s_blocksize_bits
;
254 indirect_ext_len
= 1;
256 extent_trunc(inode
, &epos
, eloc
, etype
, elen
, 0);
257 epos
.offset
+= adsize
;
261 if (indirect_ext_len
) {
264 udf_free_blocks(sb
, inode
, epos
.block
, 0,
268 UDF_I_LENALLOC(inode
) = lenalloc
;
269 mark_inode_dirty(inode
);
271 struct allocExtDesc
*aed
=
272 (struct allocExtDesc
*)(epos
.bh
->b_data
);
273 aed
->lengthAllocDescs
= cpu_to_le32(lenalloc
);
274 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_STRICT
) ||
275 sbi
->s_udfrev
>= 0x0201)
276 udf_update_tag(epos
.bh
->b_data
,
277 lenalloc
+ sizeof(struct allocExtDesc
));
279 udf_update_tag(epos
.bh
->b_data
,
280 sizeof(struct allocExtDesc
));
281 mark_buffer_dirty_inode(epos
.bh
, inode
);
284 } else if (inode
->i_size
) {
286 kernel_long_ad extent
;
289 * OK, there is not extent covering inode->i_size and
290 * no extent above inode->i_size => truncate is
291 * extending the file by 'offset' blocks.
294 epos
.offset
== udf_file_entry_alloc_offset(inode
)) ||
295 (epos
.bh
&& epos
.offset
== sizeof(struct allocExtDesc
))) {
296 /* File has no extents at all or has empty last
297 * indirect extent! Create a fake extent... */
298 extent
.extLocation
.logicalBlockNum
= 0;
299 extent
.extLocation
.partitionReferenceNum
= 0;
300 extent
.extLength
= EXT_NOT_RECORDED_NOT_ALLOCATED
;
302 epos
.offset
-= adsize
;
303 etype
= udf_next_aext(inode
, &epos
,
305 &extent
.extLength
, 0);
306 extent
.extLength
|= etype
<< 30;
308 udf_extend_file(inode
, &epos
, &extent
,
309 offset
+ ((inode
->i_size
& (sb
->s_blocksize
- 1)) != 0));
312 UDF_I_LENEXTENTS(inode
) = inode
->i_size
;