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
) =
158 udf_file_entry_alloc_offset(inode
);
159 mark_inode_dirty(inode
);
161 struct allocExtDesc
*aed
=
162 (struct allocExtDesc
*)(epos
.bh
->b_data
);
163 aed
->lengthAllocDescs
=
164 cpu_to_le32(epos
.offset
-
165 sizeof(struct allocExtDesc
));
166 if (!UDF_QUERY_FLAG(inode
->i_sb
, UDF_FLAG_STRICT
) ||
167 UDF_SB(inode
->i_sb
)->s_udfrev
>= 0x0201)
168 udf_update_tag(epos
.bh
->b_data
, epos
.offset
);
170 udf_update_tag(epos
.bh
->b_data
,
171 sizeof(struct allocExtDesc
));
172 mark_buffer_dirty_inode(epos
.bh
, inode
);
175 /* This inode entry is in-memory only and thus we don't have to mark
177 UDF_I_LENEXTENTS(inode
) = lbcount
;
181 void udf_truncate_extents(struct inode
*inode
)
183 struct extent_position epos
;
184 kernel_lb_addr eloc
, neloc
= {};
185 uint32_t elen
, nelen
= 0, indirect_ext_len
= 0, lenalloc
;
187 struct super_block
*sb
= inode
->i_sb
;
188 struct udf_sb_info
*sbi
= UDF_SB(sb
);
189 sector_t first_block
= inode
->i_size
>> sb
->s_blocksize_bits
, offset
;
193 if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_SHORT
)
194 adsize
= sizeof(short_ad
);
195 else if (UDF_I_ALLOCTYPE(inode
) == ICBTAG_FLAG_AD_LONG
)
196 adsize
= sizeof(long_ad
);
200 etype
= inode_bmap(inode
, first_block
, &epos
, &eloc
, &elen
, &offset
);
201 byte_offset
= (offset
<< sb
->s_blocksize_bits
) +
202 (inode
->i_size
& (sb
->s_blocksize
- 1));
204 epos
.offset
-= adsize
;
205 extent_trunc(inode
, &epos
, eloc
, etype
, elen
, byte_offset
);
206 epos
.offset
+= adsize
;
208 lenalloc
= epos
.offset
;
210 lenalloc
= epos
.offset
- adsize
;
213 lenalloc
-= udf_file_entry_alloc_offset(inode
);
215 lenalloc
-= sizeof(struct allocExtDesc
);
217 while ((etype
= udf_current_aext(inode
, &epos
, &eloc
,
219 if (etype
== (EXT_NEXT_EXTENT_ALLOCDECS
>> 30)) {
220 udf_write_aext(inode
, &epos
, neloc
, nelen
, 0);
221 if (indirect_ext_len
) {
222 /* We managed to free all extents in the
223 * indirect extent - free it too */
226 udf_free_blocks(sb
, inode
, epos
.block
,
227 0, indirect_ext_len
);
230 UDF_I_LENALLOC(inode
) =
232 mark_inode_dirty(inode
);
234 struct allocExtDesc
*aed
=
235 (struct allocExtDesc
*)
238 sizeof(struct allocExtDesc
);
240 aed
->lengthAllocDescs
=
241 cpu_to_le32(lenalloc
);
242 if (!UDF_QUERY_FLAG(sb
,
244 sbi
->s_udfrev
>= 0x0201)
247 udf_update_tag(epos
.bh
->b_data
,
249 mark_buffer_dirty_inode(
254 epos
.offset
= sizeof(struct allocExtDesc
);
256 epos
.bh
= udf_tread(sb
,
257 udf_get_lb_pblock(sb
, eloc
, 0));
260 (elen
+ sb
->s_blocksize
- 1) >>
261 sb
->s_blocksize_bits
;
263 indirect_ext_len
= 1;
265 extent_trunc(inode
, &epos
, eloc
, etype
,
267 epos
.offset
+= adsize
;
271 if (indirect_ext_len
) {
274 udf_free_blocks(sb
, inode
, epos
.block
, 0,
278 UDF_I_LENALLOC(inode
) = lenalloc
;
279 mark_inode_dirty(inode
);
281 struct allocExtDesc
*aed
=
282 (struct allocExtDesc
*)(epos
.bh
->b_data
);
283 aed
->lengthAllocDescs
= cpu_to_le32(lenalloc
);
284 if (!UDF_QUERY_FLAG(sb
, UDF_FLAG_STRICT
) ||
285 sbi
->s_udfrev
>= 0x0201)
286 udf_update_tag(epos
.bh
->b_data
,
288 sizeof(struct allocExtDesc
));
290 udf_update_tag(epos
.bh
->b_data
,
291 sizeof(struct allocExtDesc
));
292 mark_buffer_dirty_inode(epos
.bh
, inode
);
295 } else if (inode
->i_size
) {
297 kernel_long_ad extent
;
300 * OK, there is not extent covering inode->i_size and
301 * no extent above inode->i_size => truncate is
302 * extending the file by 'offset' blocks.
306 udf_file_entry_alloc_offset(inode
)) ||
307 (epos
.bh
&& epos
.offset
==
308 sizeof(struct allocExtDesc
))) {
309 /* File has no extents at all or has empty last
310 * indirect extent! Create a fake extent... */
311 extent
.extLocation
.logicalBlockNum
= 0;
312 extent
.extLocation
.partitionReferenceNum
= 0;
314 EXT_NOT_RECORDED_NOT_ALLOCATED
;
316 epos
.offset
-= adsize
;
317 etype
= udf_next_aext(inode
, &epos
,
319 &extent
.extLength
, 0);
320 extent
.extLength
|= etype
<< 30;
322 udf_extend_file(inode
, &epos
, &extent
,
325 (sb
->s_blocksize
- 1)) != 0));
328 UDF_I_LENEXTENTS(inode
) = inode
->i_size
;