Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/ufs/truncate.c | |
3 | * | |
4 | * Copyright (C) 1998 | |
5 | * Daniel Pirkl <daniel.pirkl@email.cz> | |
6 | * Charles University, Faculty of Mathematics and Physics | |
7 | * | |
8 | * from | |
9 | * | |
10 | * linux/fs/ext2/truncate.c | |
11 | * | |
12 | * Copyright (C) 1992, 1993, 1994, 1995 | |
13 | * Remy Card (card@masi.ibp.fr) | |
14 | * Laboratoire MASI - Institut Blaise Pascal | |
15 | * Universite Pierre et Marie Curie (Paris VI) | |
16 | * | |
17 | * from | |
18 | * | |
19 | * linux/fs/minix/truncate.c | |
20 | * | |
21 | * Copyright (C) 1991, 1992 Linus Torvalds | |
22 | * | |
23 | * Big-endian to little-endian byte-swapping/bitmaps by | |
24 | * David S. Miller (davem@caip.rutgers.edu), 1995 | |
25 | */ | |
26 | ||
27 | /* | |
28 | * Real random numbers for secure rm added 94/02/18 | |
29 | * Idea from Pierre del Perugia <delperug@gla.ecoledoc.ibp.fr> | |
30 | */ | |
31 | ||
09114eb8 | 32 | /* |
54fb996a ED |
33 | * Adoptation to use page cache and UFS2 write support by |
34 | * Evgeniy Dushistov <dushistov@mail.ru>, 2006-2007 | |
09114eb8 ED |
35 | */ |
36 | ||
1da177e4 LT |
37 | #include <linux/errno.h> |
38 | #include <linux/fs.h> | |
1da177e4 LT |
39 | #include <linux/fcntl.h> |
40 | #include <linux/time.h> | |
41 | #include <linux/stat.h> | |
42 | #include <linux/string.h> | |
43 | #include <linux/smp_lock.h> | |
44 | #include <linux/buffer_head.h> | |
45 | #include <linux/blkdev.h> | |
46 | #include <linux/sched.h> | |
47 | ||
e5420598 | 48 | #include "ufs_fs.h" |
bcd6d4ec | 49 | #include "ufs.h" |
1da177e4 LT |
50 | #include "swab.h" |
51 | #include "util.h" | |
52 | ||
1da177e4 LT |
53 | /* |
54 | * Secure deletion currently doesn't work. It interacts very badly | |
55 | * with buffers shared with memory mappings, and for that reason | |
56 | * can't be done in the truncate() routines. It should instead be | |
57 | * done separately in "release()" before calling the truncate routines | |
58 | * that will release the actual file blocks. | |
59 | * | |
60 | * Linus | |
61 | */ | |
62 | ||
63 | #define DIRECT_BLOCK ((inode->i_size + uspi->s_bsize - 1) >> uspi->s_bshift) | |
64 | #define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift) | |
65 | ||
1da177e4 | 66 | |
54fb996a | 67 | static int ufs_trunc_direct(struct inode *inode) |
1da177e4 LT |
68 | { |
69 | struct ufs_inode_info *ufsi = UFS_I(inode); | |
70 | struct super_block * sb; | |
71 | struct ufs_sb_private_info * uspi; | |
54fb996a ED |
72 | void *p; |
73 | u64 frag1, frag2, frag3, frag4, block1, block2; | |
1da177e4 | 74 | unsigned frag_to_free, free_count; |
09114eb8 | 75 | unsigned i, tmp; |
1da177e4 LT |
76 | int retry; |
77 | ||
4b25a37e | 78 | UFSD("ENTER: ino %lu\n", inode->i_ino); |
1da177e4 LT |
79 | |
80 | sb = inode->i_sb; | |
81 | uspi = UFS_SB(sb)->s_uspi; | |
82 | ||
83 | frag_to_free = 0; | |
84 | free_count = 0; | |
85 | retry = 0; | |
86 | ||
87 | frag1 = DIRECT_FRAGMENT; | |
88 | frag4 = min_t(u32, UFS_NDIR_FRAGMENT, ufsi->i_lastfrag); | |
89 | frag2 = ((frag1 & uspi->s_fpbmask) ? ((frag1 | uspi->s_fpbmask) + 1) : frag1); | |
90 | frag3 = frag4 & ~uspi->s_fpbmask; | |
91 | block1 = block2 = 0; | |
92 | if (frag2 > frag3) { | |
93 | frag2 = frag4; | |
94 | frag3 = frag4 = 0; | |
54fb996a | 95 | } else if (frag2 < frag3) { |
1da177e4 LT |
96 | block1 = ufs_fragstoblks (frag2); |
97 | block2 = ufs_fragstoblks (frag3); | |
98 | } | |
99 | ||
4b25a37e ED |
100 | UFSD("ino %lu, frag1 %llu, frag2 %llu, block1 %llu, block2 %llu," |
101 | " frag3 %llu, frag4 %llu\n", inode->i_ino, | |
54fb996a ED |
102 | (unsigned long long)frag1, (unsigned long long)frag2, |
103 | (unsigned long long)block1, (unsigned long long)block2, | |
104 | (unsigned long long)frag3, (unsigned long long)frag4); | |
1da177e4 LT |
105 | |
106 | if (frag1 >= frag2) | |
107 | goto next1; | |
108 | ||
109 | /* | |
110 | * Free first free fragments | |
111 | */ | |
54fb996a ED |
112 | p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag1)); |
113 | tmp = ufs_data_ptr_to_cpu(sb, p); | |
1da177e4 LT |
114 | if (!tmp ) |
115 | ufs_panic (sb, "ufs_trunc_direct", "internal error"); | |
8682164a | 116 | frag2 -= frag1; |
1da177e4 | 117 | frag1 = ufs_fragnum (frag1); |
09114eb8 | 118 | |
8682164a | 119 | ufs_free_fragments(inode, tmp + frag1, frag2); |
50aa4eb0 | 120 | mark_inode_dirty(inode); |
1da177e4 LT |
121 | frag_to_free = tmp + frag1; |
122 | ||
123 | next1: | |
124 | /* | |
125 | * Free whole blocks | |
126 | */ | |
127 | for (i = block1 ; i < block2; i++) { | |
54fb996a ED |
128 | p = ufs_get_direct_data_ptr(uspi, ufsi, i); |
129 | tmp = ufs_data_ptr_to_cpu(sb, p); | |
1da177e4 LT |
130 | if (!tmp) |
131 | continue; | |
54fb996a | 132 | ufs_data_ptr_clear(uspi, p); |
50aa4eb0 | 133 | |
1da177e4 LT |
134 | if (free_count == 0) { |
135 | frag_to_free = tmp; | |
136 | free_count = uspi->s_fpb; | |
137 | } else if (free_count > 0 && frag_to_free == tmp - free_count) | |
138 | free_count += uspi->s_fpb; | |
139 | else { | |
140 | ufs_free_blocks (inode, frag_to_free, free_count); | |
141 | frag_to_free = tmp; | |
142 | free_count = uspi->s_fpb; | |
143 | } | |
50aa4eb0 | 144 | mark_inode_dirty(inode); |
1da177e4 LT |
145 | } |
146 | ||
147 | if (free_count > 0) | |
148 | ufs_free_blocks (inode, frag_to_free, free_count); | |
149 | ||
150 | if (frag3 >= frag4) | |
151 | goto next3; | |
152 | ||
153 | /* | |
154 | * Free last free fragments | |
155 | */ | |
54fb996a ED |
156 | p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag3)); |
157 | tmp = ufs_data_ptr_to_cpu(sb, p); | |
1da177e4 LT |
158 | if (!tmp ) |
159 | ufs_panic(sb, "ufs_truncate_direct", "internal error"); | |
160 | frag4 = ufs_fragnum (frag4); | |
54fb996a | 161 | ufs_data_ptr_clear(uspi, p); |
50aa4eb0 | 162 | |
1da177e4 | 163 | ufs_free_fragments (inode, tmp, frag4); |
50aa4eb0 | 164 | mark_inode_dirty(inode); |
1da177e4 LT |
165 | next3: |
166 | ||
4b25a37e | 167 | UFSD("EXIT: ino %lu\n", inode->i_ino); |
1da177e4 LT |
168 | return retry; |
169 | } | |
170 | ||
171 | ||
54fb996a | 172 | static int ufs_trunc_indirect(struct inode *inode, u64 offset, void *p) |
1da177e4 LT |
173 | { |
174 | struct super_block * sb; | |
175 | struct ufs_sb_private_info * uspi; | |
176 | struct ufs_buffer_head * ind_ubh; | |
54fb996a ED |
177 | void *ind; |
178 | u64 tmp, indirect_block, i, frag_to_free; | |
179 | unsigned free_count; | |
1da177e4 LT |
180 | int retry; |
181 | ||
54fb996a ED |
182 | UFSD("ENTER: ino %lu, offset %llu, p: %p\n", |
183 | inode->i_ino, (unsigned long long)offset, p); | |
184 | ||
185 | BUG_ON(!p); | |
1da177e4 LT |
186 | |
187 | sb = inode->i_sb; | |
188 | uspi = UFS_SB(sb)->s_uspi; | |
189 | ||
190 | frag_to_free = 0; | |
191 | free_count = 0; | |
192 | retry = 0; | |
193 | ||
54fb996a | 194 | tmp = ufs_data_ptr_to_cpu(sb, p); |
1da177e4 LT |
195 | if (!tmp) |
196 | return 0; | |
197 | ind_ubh = ubh_bread(sb, tmp, uspi->s_bsize); | |
54fb996a | 198 | if (tmp != ufs_data_ptr_to_cpu(sb, p)) { |
1da177e4 LT |
199 | ubh_brelse (ind_ubh); |
200 | return 1; | |
201 | } | |
202 | if (!ind_ubh) { | |
54fb996a | 203 | ufs_data_ptr_clear(uspi, p); |
1da177e4 LT |
204 | return 0; |
205 | } | |
206 | ||
207 | indirect_block = (DIRECT_BLOCK > offset) ? (DIRECT_BLOCK - offset) : 0; | |
208 | for (i = indirect_block; i < uspi->s_apb; i++) { | |
54fb996a ED |
209 | ind = ubh_get_data_ptr(uspi, ind_ubh, i); |
210 | tmp = ufs_data_ptr_to_cpu(sb, ind); | |
1da177e4 LT |
211 | if (!tmp) |
212 | continue; | |
09114eb8 | 213 | |
54fb996a | 214 | ufs_data_ptr_clear(uspi, ind); |
1da177e4 LT |
215 | ubh_mark_buffer_dirty(ind_ubh); |
216 | if (free_count == 0) { | |
217 | frag_to_free = tmp; | |
218 | free_count = uspi->s_fpb; | |
219 | } else if (free_count > 0 && frag_to_free == tmp - free_count) | |
220 | free_count += uspi->s_fpb; | |
221 | else { | |
222 | ufs_free_blocks (inode, frag_to_free, free_count); | |
223 | frag_to_free = tmp; | |
224 | free_count = uspi->s_fpb; | |
225 | } | |
50aa4eb0 | 226 | |
1da177e4 | 227 | mark_inode_dirty(inode); |
1da177e4 LT |
228 | } |
229 | ||
230 | if (free_count > 0) { | |
231 | ufs_free_blocks (inode, frag_to_free, free_count); | |
232 | } | |
233 | for (i = 0; i < uspi->s_apb; i++) | |
54fb996a ED |
234 | if (!ufs_is_data_ptr_zero(uspi, |
235 | ubh_get_data_ptr(uspi, ind_ubh, i))) | |
1da177e4 LT |
236 | break; |
237 | if (i >= uspi->s_apb) { | |
54fb996a ED |
238 | tmp = ufs_data_ptr_to_cpu(sb, p); |
239 | ufs_data_ptr_clear(uspi, p); | |
50aa4eb0 | 240 | |
2061df0f | 241 | ufs_free_blocks (inode, tmp, uspi->s_fpb); |
50aa4eb0 | 242 | mark_inode_dirty(inode); |
2061df0f ED |
243 | ubh_bforget(ind_ubh); |
244 | ind_ubh = NULL; | |
1da177e4 LT |
245 | } |
246 | if (IS_SYNC(inode) && ind_ubh && ubh_buffer_dirty(ind_ubh)) { | |
098d5af7 | 247 | ubh_ll_rw_block(SWRITE, ind_ubh); |
1da177e4 LT |
248 | ubh_wait_on_buffer (ind_ubh); |
249 | } | |
250 | ubh_brelse (ind_ubh); | |
251 | ||
4b25a37e | 252 | UFSD("EXIT: ino %lu\n", inode->i_ino); |
1da177e4 LT |
253 | |
254 | return retry; | |
255 | } | |
256 | ||
54fb996a | 257 | static int ufs_trunc_dindirect(struct inode *inode, u64 offset, void *p) |
1da177e4 LT |
258 | { |
259 | struct super_block * sb; | |
260 | struct ufs_sb_private_info * uspi; | |
54fb996a ED |
261 | struct ufs_buffer_head *dind_bh; |
262 | u64 i, tmp, dindirect_block; | |
263 | void *dind; | |
1da177e4 LT |
264 | int retry = 0; |
265 | ||
4b25a37e | 266 | UFSD("ENTER: ino %lu\n", inode->i_ino); |
1da177e4 LT |
267 | |
268 | sb = inode->i_sb; | |
269 | uspi = UFS_SB(sb)->s_uspi; | |
270 | ||
271 | dindirect_block = (DIRECT_BLOCK > offset) | |
272 | ? ((DIRECT_BLOCK - offset) >> uspi->s_apbshift) : 0; | |
273 | retry = 0; | |
274 | ||
54fb996a | 275 | tmp = ufs_data_ptr_to_cpu(sb, p); |
1da177e4 LT |
276 | if (!tmp) |
277 | return 0; | |
278 | dind_bh = ubh_bread(sb, tmp, uspi->s_bsize); | |
54fb996a | 279 | if (tmp != ufs_data_ptr_to_cpu(sb, p)) { |
1da177e4 LT |
280 | ubh_brelse (dind_bh); |
281 | return 1; | |
282 | } | |
283 | if (!dind_bh) { | |
54fb996a | 284 | ufs_data_ptr_clear(uspi, p); |
1da177e4 LT |
285 | return 0; |
286 | } | |
287 | ||
288 | for (i = dindirect_block ; i < uspi->s_apb ; i++) { | |
54fb996a ED |
289 | dind = ubh_get_data_ptr(uspi, dind_bh, i); |
290 | tmp = ufs_data_ptr_to_cpu(sb, dind); | |
1da177e4 LT |
291 | if (!tmp) |
292 | continue; | |
293 | retry |= ufs_trunc_indirect (inode, offset + (i << uspi->s_apbshift), dind); | |
294 | ubh_mark_buffer_dirty(dind_bh); | |
295 | } | |
296 | ||
297 | for (i = 0; i < uspi->s_apb; i++) | |
54fb996a ED |
298 | if (!ufs_is_data_ptr_zero(uspi, |
299 | ubh_get_data_ptr(uspi, dind_bh, i))) | |
1da177e4 LT |
300 | break; |
301 | if (i >= uspi->s_apb) { | |
54fb996a ED |
302 | tmp = ufs_data_ptr_to_cpu(sb, p); |
303 | ufs_data_ptr_clear(uspi, p); | |
50aa4eb0 ED |
304 | |
305 | ufs_free_blocks(inode, tmp, uspi->s_fpb); | |
2061df0f | 306 | mark_inode_dirty(inode); |
2061df0f ED |
307 | ubh_bforget(dind_bh); |
308 | dind_bh = NULL; | |
1da177e4 LT |
309 | } |
310 | if (IS_SYNC(inode) && dind_bh && ubh_buffer_dirty(dind_bh)) { | |
098d5af7 | 311 | ubh_ll_rw_block(SWRITE, dind_bh); |
1da177e4 LT |
312 | ubh_wait_on_buffer (dind_bh); |
313 | } | |
314 | ubh_brelse (dind_bh); | |
315 | ||
4b25a37e | 316 | UFSD("EXIT: ino %lu\n", inode->i_ino); |
1da177e4 LT |
317 | |
318 | return retry; | |
319 | } | |
320 | ||
54fb996a | 321 | static int ufs_trunc_tindirect(struct inode *inode) |
1da177e4 | 322 | { |
54fb996a ED |
323 | struct super_block *sb = inode->i_sb; |
324 | struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi; | |
1da177e4 | 325 | struct ufs_inode_info *ufsi = UFS_I(inode); |
1da177e4 | 326 | struct ufs_buffer_head * tind_bh; |
54fb996a ED |
327 | u64 tindirect_block, tmp, i; |
328 | void *tind, *p; | |
1da177e4 LT |
329 | int retry; |
330 | ||
4b25a37e | 331 | UFSD("ENTER: ino %lu\n", inode->i_ino); |
1da177e4 | 332 | |
1da177e4 LT |
333 | retry = 0; |
334 | ||
335 | tindirect_block = (DIRECT_BLOCK > (UFS_NDADDR + uspi->s_apb + uspi->s_2apb)) | |
336 | ? ((DIRECT_BLOCK - UFS_NDADDR - uspi->s_apb - uspi->s_2apb) >> uspi->s_2apbshift) : 0; | |
54fb996a ED |
337 | |
338 | p = ufs_get_direct_data_ptr(uspi, ufsi, UFS_TIND_BLOCK); | |
339 | if (!(tmp = ufs_data_ptr_to_cpu(sb, p))) | |
1da177e4 LT |
340 | return 0; |
341 | tind_bh = ubh_bread (sb, tmp, uspi->s_bsize); | |
54fb996a | 342 | if (tmp != ufs_data_ptr_to_cpu(sb, p)) { |
1da177e4 LT |
343 | ubh_brelse (tind_bh); |
344 | return 1; | |
345 | } | |
346 | if (!tind_bh) { | |
54fb996a | 347 | ufs_data_ptr_clear(uspi, p); |
1da177e4 LT |
348 | return 0; |
349 | } | |
350 | ||
351 | for (i = tindirect_block ; i < uspi->s_apb ; i++) { | |
0465fc0a | 352 | tind = ubh_get_data_ptr(uspi, tind_bh, i); |
1da177e4 LT |
353 | retry |= ufs_trunc_dindirect(inode, UFS_NDADDR + |
354 | uspi->s_apb + ((i + 1) << uspi->s_2apbshift), tind); | |
355 | ubh_mark_buffer_dirty(tind_bh); | |
356 | } | |
357 | for (i = 0; i < uspi->s_apb; i++) | |
54fb996a ED |
358 | if (!ufs_is_data_ptr_zero(uspi, |
359 | ubh_get_data_ptr(uspi, tind_bh, i))) | |
1da177e4 LT |
360 | break; |
361 | if (i >= uspi->s_apb) { | |
54fb996a ED |
362 | tmp = ufs_data_ptr_to_cpu(sb, p); |
363 | ufs_data_ptr_clear(uspi, p); | |
50aa4eb0 ED |
364 | |
365 | ufs_free_blocks(inode, tmp, uspi->s_fpb); | |
2061df0f | 366 | mark_inode_dirty(inode); |
2061df0f ED |
367 | ubh_bforget(tind_bh); |
368 | tind_bh = NULL; | |
1da177e4 LT |
369 | } |
370 | if (IS_SYNC(inode) && tind_bh && ubh_buffer_dirty(tind_bh)) { | |
098d5af7 | 371 | ubh_ll_rw_block(SWRITE, tind_bh); |
1da177e4 LT |
372 | ubh_wait_on_buffer (tind_bh); |
373 | } | |
374 | ubh_brelse (tind_bh); | |
375 | ||
4b25a37e | 376 | UFSD("EXIT: ino %lu\n", inode->i_ino); |
1da177e4 LT |
377 | return retry; |
378 | } | |
10e5dce0 ED |
379 | |
380 | static int ufs_alloc_lastblock(struct inode *inode) | |
1da177e4 | 381 | { |
10e5dce0 | 382 | int err = 0; |
4b25a37e | 383 | struct super_block *sb = inode->i_sb; |
10e5dce0 | 384 | struct address_space *mapping = inode->i_mapping; |
4b25a37e | 385 | struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi; |
54fb996a ED |
386 | unsigned i, end; |
387 | sector_t lastfrag; | |
10e5dce0 ED |
388 | struct page *lastpage; |
389 | struct buffer_head *bh; | |
4b25a37e | 390 | u64 phys64; |
10e5dce0 ED |
391 | |
392 | lastfrag = (i_size_read(inode) + uspi->s_fsize - 1) >> uspi->s_fshift; | |
393 | ||
ecdc6394 | 394 | if (!lastfrag) |
10e5dce0 | 395 | goto out; |
ecdc6394 | 396 | |
10e5dce0 ED |
397 | lastfrag--; |
398 | ||
399 | lastpage = ufs_get_locked_page(mapping, lastfrag >> | |
400 | (PAGE_CACHE_SHIFT - inode->i_blkbits)); | |
401 | if (IS_ERR(lastpage)) { | |
402 | err = -EIO; | |
403 | goto out; | |
404 | } | |
405 | ||
406 | end = lastfrag & ((1 << (PAGE_CACHE_SHIFT - inode->i_blkbits)) - 1); | |
407 | bh = page_buffers(lastpage); | |
408 | for (i = 0; i < end; ++i) | |
409 | bh = bh->b_this_page; | |
410 | ||
ecdc6394 ED |
411 | |
412 | err = ufs_getfrag_block(inode, lastfrag, bh, 1); | |
413 | ||
414 | if (unlikely(err)) | |
415 | goto out_unlock; | |
416 | ||
417 | if (buffer_new(bh)) { | |
418 | clear_buffer_new(bh); | |
419 | unmap_underlying_metadata(bh->b_bdev, | |
420 | bh->b_blocknr); | |
421 | /* | |
422 | * we do not zeroize fragment, because of | |
423 | * if it maped to hole, it already contains zeroes | |
424 | */ | |
425 | set_buffer_uptodate(bh); | |
426 | mark_buffer_dirty(bh); | |
427 | set_page_dirty(lastpage); | |
10e5dce0 | 428 | } |
ecdc6394 | 429 | |
4b25a37e ED |
430 | if (lastfrag >= UFS_IND_FRAGMENT) { |
431 | end = uspi->s_fpb - ufs_fragnum(lastfrag) - 1; | |
432 | phys64 = bh->b_blocknr + 1; | |
433 | for (i = 0; i < end; ++i) { | |
434 | bh = sb_getblk(sb, i + phys64); | |
435 | lock_buffer(bh); | |
436 | memset(bh->b_data, 0, sb->s_blocksize); | |
437 | set_buffer_uptodate(bh); | |
438 | mark_buffer_dirty(bh); | |
439 | unlock_buffer(bh); | |
440 | sync_dirty_buffer(bh); | |
441 | brelse(bh); | |
442 | } | |
443 | } | |
10e5dce0 ED |
444 | out_unlock: |
445 | ufs_put_locked_page(lastpage); | |
446 | out: | |
447 | return err; | |
448 | } | |
449 | ||
450 | int ufs_truncate(struct inode *inode, loff_t old_i_size) | |
451 | { | |
452 | struct ufs_inode_info *ufsi = UFS_I(inode); | |
453 | struct super_block *sb = inode->i_sb; | |
454 | struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi; | |
455 | int retry, err = 0; | |
1da177e4 | 456 | |
54fb996a ED |
457 | UFSD("ENTER: ino %lu, i_size: %llu, old_i_size: %llu\n", |
458 | inode->i_ino, (unsigned long long)i_size_read(inode), | |
459 | (unsigned long long)old_i_size); | |
1da177e4 | 460 | |
10e5dce0 ED |
461 | if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || |
462 | S_ISLNK(inode->i_mode))) | |
463 | return -EINVAL; | |
1da177e4 | 464 | if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) |
10e5dce0 ED |
465 | return -EPERM; |
466 | ||
ecdc6394 | 467 | err = ufs_alloc_lastblock(inode); |
10e5dce0 | 468 | |
ecdc6394 ED |
469 | if (err) { |
470 | i_size_write(inode, old_i_size); | |
471 | goto out; | |
10e5dce0 | 472 | } |
09114eb8 | 473 | |
10e5dce0 | 474 | block_truncate_page(inode->i_mapping, inode->i_size, ufs_getfrag_block); |
09114eb8 | 475 | |
1da177e4 LT |
476 | lock_kernel(); |
477 | while (1) { | |
478 | retry = ufs_trunc_direct(inode); | |
54fb996a ED |
479 | retry |= ufs_trunc_indirect(inode, UFS_IND_BLOCK, |
480 | ufs_get_direct_data_ptr(uspi, ufsi, | |
481 | UFS_IND_BLOCK)); | |
482 | retry |= ufs_trunc_dindirect(inode, UFS_IND_BLOCK + uspi->s_apb, | |
483 | ufs_get_direct_data_ptr(uspi, ufsi, | |
484 | UFS_DIND_BLOCK)); | |
1da177e4 LT |
485 | retry |= ufs_trunc_tindirect (inode); |
486 | if (!retry) | |
487 | break; | |
488 | if (IS_SYNC(inode) && (inode->i_state & I_DIRTY)) | |
489 | ufs_sync_inode (inode); | |
490 | blk_run_address_space(inode->i_mapping); | |
491 | yield(); | |
492 | } | |
09114eb8 | 493 | |
1da177e4 | 494 | inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC; |
ecdc6394 | 495 | ufsi->i_lastfrag = DIRECT_FRAGMENT; |
1da177e4 LT |
496 | unlock_kernel(); |
497 | mark_inode_dirty(inode); | |
10e5dce0 ED |
498 | out: |
499 | UFSD("EXIT: err %d\n", err); | |
500 | return err; | |
1da177e4 | 501 | } |
10e5dce0 ED |
502 | |
503 | ||
504 | /* | |
505 | * We don't define our `inode->i_op->truncate', and call it here, | |
506 | * because of: | |
507 | * - there is no way to know old size | |
508 | * - there is no way inform user about error, if it happens in `truncate' | |
509 | */ | |
510 | static int ufs_setattr(struct dentry *dentry, struct iattr *attr) | |
511 | { | |
512 | struct inode *inode = dentry->d_inode; | |
513 | unsigned int ia_valid = attr->ia_valid; | |
514 | int error; | |
515 | ||
516 | error = inode_change_ok(inode, attr); | |
517 | if (error) | |
518 | return error; | |
519 | ||
520 | if (ia_valid & ATTR_SIZE && | |
521 | attr->ia_size != i_size_read(inode)) { | |
522 | loff_t old_i_size = inode->i_size; | |
523 | error = vmtruncate(inode, attr->ia_size); | |
524 | if (error) | |
525 | return error; | |
526 | error = ufs_truncate(inode, old_i_size); | |
527 | if (error) | |
528 | return error; | |
529 | } | |
530 | return inode_setattr(inode, attr); | |
531 | } | |
532 | ||
c5ef1c42 | 533 | const struct inode_operations ufs_file_inode_operations = { |
10e5dce0 ED |
534 | .setattr = ufs_setattr, |
535 | }; |