Branch data Line data Source code
1 : : /*
2 : : * linux/fs/ext2/inode.c
3 : : *
4 : : * Copyright (C) 1992, 1993, 1994, 1995
5 : : * Remy Card (card@masi.ibp.fr)
6 : : * Laboratoire MASI - Institut Blaise Pascal
7 : : * Universite Pierre et Marie Curie (Paris VI)
8 : : *
9 : : * from
10 : : *
11 : : * linux/fs/minix/inode.c
12 : : *
13 : : * Copyright (C) 1991, 1992 Linus Torvalds
14 : : *
15 : : * Goal-directed block allocation by Stephen Tweedie
16 : : * (sct@dcs.ed.ac.uk), 1993, 1998
17 : : * Big-endian to little-endian byte-swapping/bitmaps by
18 : : * David S. Miller (davem@caip.rutgers.edu), 1995
19 : : * 64-bit file support on 64-bit platforms by Jakub Jelinek
20 : : * (jj@sunsite.ms.mff.cuni.cz)
21 : : *
22 : : * Assorted race fixes, rewrite of ext2_get_block() by Al Viro, 2000
23 : : */
24 : :
25 : : #include <linux/time.h>
26 : : #include <linux/highuid.h>
27 : : #include <linux/pagemap.h>
28 : : #include <linux/quotaops.h>
29 : : #include <linux/writeback.h>
30 : : #include <linux/buffer_head.h>
31 : : #include <linux/mpage.h>
32 : : #include <linux/fiemap.h>
33 : : #include <linux/namei.h>
34 : : #include <linux/aio.h>
35 : : #include "ext2.h"
36 : : #include "acl.h"
37 : : #include "xip.h"
38 : : #include "xattr.h"
39 : :
40 : : static int __ext2_write_inode(struct inode *inode, int do_sync);
41 : :
42 : : /*
43 : : * Test whether an inode is a fast symlink.
44 : : */
45 : : static inline int ext2_inode_is_fast_symlink(struct inode *inode)
46 : : {
47 [ # # ][ # # ]: 0 : int ea_blocks = EXT2_I(inode)->i_file_acl ?
[ # # ]
48 : 0 : (inode->i_sb->s_blocksize >> 9) : 0;
49 : :
50 [ # # ][ # # ]: 0 : return (S_ISLNK(inode->i_mode) &&
[ # # ][ # # ]
[ # # ][ # # ]
51 : 0 : inode->i_blocks - ea_blocks == 0);
52 : : }
53 : :
54 : : static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
55 : :
56 : 0 : static void ext2_write_failed(struct address_space *mapping, loff_t to)
57 : : {
58 : 0 : struct inode *inode = mapping->host;
59 : :
60 [ # # ]: 0 : if (to > inode->i_size) {
61 : 0 : truncate_pagecache(inode, inode->i_size);
62 : 0 : ext2_truncate_blocks(inode, inode->i_size);
63 : : }
64 : 0 : }
65 : :
66 : : /*
67 : : * Called at the last iput() if i_nlink is zero.
68 : : */
69 : 0 : void ext2_evict_inode(struct inode * inode)
70 : : {
71 : : struct ext2_block_alloc_info *rsv;
72 : : int want_delete = 0;
73 : :
74 [ # # ][ # # ]: 0 : if (!inode->i_nlink && !is_bad_inode(inode)) {
75 : : want_delete = 1;
76 : 0 : dquot_initialize(inode);
77 : : } else {
78 : 0 : dquot_drop(inode);
79 : : }
80 : :
81 : 0 : truncate_inode_pages(&inode->i_data, 0);
82 : :
83 [ # # ]: 0 : if (want_delete) {
84 : 0 : sb_start_intwrite(inode->i_sb);
85 : : /* set dtime */
86 : 0 : EXT2_I(inode)->i_dtime = get_seconds();
87 : : mark_inode_dirty(inode);
88 : 0 : __ext2_write_inode(inode, inode_needs_sync(inode));
89 : : /* truncate to 0 */
90 : 0 : inode->i_size = 0;
91 [ # # ]: 0 : if (inode->i_blocks)
92 : 0 : ext2_truncate_blocks(inode, 0);
93 : : ext2_xattr_delete_inode(inode);
94 : : }
95 : :
96 : 0 : invalidate_inode_buffers(inode);
97 : 0 : clear_inode(inode);
98 : :
99 : 0 : ext2_discard_reservation(inode);
100 : 0 : rsv = EXT2_I(inode)->i_block_alloc_info;
101 : 0 : EXT2_I(inode)->i_block_alloc_info = NULL;
102 [ # # ]: 0 : if (unlikely(rsv))
103 : 0 : kfree(rsv);
104 : :
105 [ # # ]: 0 : if (want_delete) {
106 : 0 : ext2_free_inode(inode);
107 : 0 : sb_end_intwrite(inode->i_sb);
108 : : }
109 : 0 : }
110 : :
111 : : typedef struct {
112 : : __le32 *p;
113 : : __le32 key;
114 : : struct buffer_head *bh;
115 : : } Indirect;
116 : :
117 : : static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
118 : : {
119 : 0 : p->key = *(p->p = v);
120 : 0 : p->bh = bh;
121 : : }
122 : :
123 : : static inline int verify_chain(Indirect *from, Indirect *to)
124 : : {
125 [ # # ][ # # ]: 0 : while (from <= to && from->key == *from->p)
[ # # ][ # # ]
[ # # ][ # # ]
126 : 0 : from++;
127 : : return (from > to);
128 : : }
129 : :
130 : : /**
131 : : * ext2_block_to_path - parse the block number into array of offsets
132 : : * @inode: inode in question (we are only interested in its superblock)
133 : : * @i_block: block number to be parsed
134 : : * @offsets: array to store the offsets in
135 : : * @boundary: set this non-zero if the referred-to block is likely to be
136 : : * followed (on disk) by an indirect block.
137 : : * To store the locations of file's data ext2 uses a data structure common
138 : : * for UNIX filesystems - tree of pointers anchored in the inode, with
139 : : * data blocks at leaves and indirect blocks in intermediate nodes.
140 : : * This function translates the block number into path in that tree -
141 : : * return value is the path length and @offsets[n] is the offset of
142 : : * pointer to (n+1)th node in the nth one. If @block is out of range
143 : : * (negative or too large) warning is printed and zero returned.
144 : : *
145 : : * Note: function doesn't find node addresses, so no IO is needed. All
146 : : * we need to know is the capacity of indirect blocks (taken from the
147 : : * inode->i_sb).
148 : : */
149 : :
150 : : /*
151 : : * Portability note: the last comparison (check that we fit into triple
152 : : * indirect block) is spelled differently, because otherwise on an
153 : : * architecture with 32-bit longs and 8Kb pages we might get into trouble
154 : : * if our filesystem had 8Kb blocks. We might use long long, but that would
155 : : * kill us on x86. Oh, well, at least the sign propagation does not matter -
156 : : * i_block would have to be negative in the very beginning, so we would not
157 : : * get there at all.
158 : : */
159 : :
160 : 0 : static int ext2_block_to_path(struct inode *inode,
161 : : long i_block, int offsets[4], int *boundary)
162 : : {
163 : 0 : int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
164 : 0 : int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
165 : : const long direct_blocks = EXT2_NDIR_BLOCKS,
166 : : indirect_blocks = ptrs,
167 : 0 : double_blocks = (1 << (ptrs_bits * 2));
168 : : int n = 0;
169 : : int final = 0;
170 : :
171 [ # # ]: 0 : if (i_block < 0) {
172 : 0 : ext2_msg(inode->i_sb, KERN_WARNING,
173 : : "warning: %s: block < 0", __func__);
174 [ # # ]: 0 : } else if (i_block < direct_blocks) {
175 : 0 : offsets[n++] = i_block;
176 : : final = direct_blocks;
177 [ # # ]: 0 : } else if ( (i_block -= direct_blocks) < indirect_blocks) {
178 : 0 : offsets[n++] = EXT2_IND_BLOCK;
179 : 0 : offsets[n++] = i_block;
180 : : final = ptrs;
181 [ # # ]: 0 : } else if ((i_block -= indirect_blocks) < double_blocks) {
182 : 0 : offsets[n++] = EXT2_DIND_BLOCK;
183 : 0 : offsets[n++] = i_block >> ptrs_bits;
184 : 0 : offsets[n++] = i_block & (ptrs - 1);
185 : : final = ptrs;
186 [ # # ]: 0 : } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
187 : 0 : offsets[n++] = EXT2_TIND_BLOCK;
188 : 0 : offsets[n++] = i_block >> (ptrs_bits * 2);
189 : 0 : offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
190 : 0 : offsets[n++] = i_block & (ptrs - 1);
191 : : final = ptrs;
192 : : } else {
193 : 0 : ext2_msg(inode->i_sb, KERN_WARNING,
194 : : "warning: %s: block is too big", __func__);
195 : : }
196 [ # # ]: 0 : if (boundary)
197 : 0 : *boundary = final - 1 - (i_block & (ptrs - 1));
198 : :
199 : 0 : return n;
200 : : }
201 : :
202 : : /**
203 : : * ext2_get_branch - read the chain of indirect blocks leading to data
204 : : * @inode: inode in question
205 : : * @depth: depth of the chain (1 - direct pointer, etc.)
206 : : * @offsets: offsets of pointers in inode/indirect blocks
207 : : * @chain: place to store the result
208 : : * @err: here we store the error value
209 : : *
210 : : * Function fills the array of triples <key, p, bh> and returns %NULL
211 : : * if everything went OK or the pointer to the last filled triple
212 : : * (incomplete one) otherwise. Upon the return chain[i].key contains
213 : : * the number of (i+1)-th block in the chain (as it is stored in memory,
214 : : * i.e. little-endian 32-bit), chain[i].p contains the address of that
215 : : * number (it points into struct inode for i==0 and into the bh->b_data
216 : : * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
217 : : * block for i>0 and NULL for i==0. In other words, it holds the block
218 : : * numbers of the chain, addresses they were taken from (and where we can
219 : : * verify that chain did not change) and buffer_heads hosting these
220 : : * numbers.
221 : : *
222 : : * Function stops when it stumbles upon zero pointer (absent block)
223 : : * (pointer to last triple returned, *@err == 0)
224 : : * or when it gets an IO error reading an indirect block
225 : : * (ditto, *@err == -EIO)
226 : : * or when it notices that chain had been changed while it was reading
227 : : * (ditto, *@err == -EAGAIN)
228 : : * or when it reads all @depth-1 indirect blocks successfully and finds
229 : : * the whole chain, all way to the data (returns %NULL, *err == 0).
230 : : */
231 : 0 : static Indirect *ext2_get_branch(struct inode *inode,
232 : : int depth,
233 : : int *offsets,
234 : : Indirect chain[4],
235 : : int *err)
236 : : {
237 : 0 : struct super_block *sb = inode->i_sb;
238 : : Indirect *p = chain;
239 : : struct buffer_head *bh;
240 : :
241 : 0 : *err = 0;
242 : : /* i_data is not going away, no lock needed */
243 : 0 : add_chain (chain, NULL, EXT2_I(inode)->i_data + *offsets);
244 [ # # ]: 0 : if (!p->key)
245 : : goto no_block;
246 [ # # ]: 0 : while (--depth) {
247 : 0 : bh = sb_bread(sb, le32_to_cpu(p->key));
248 [ # # ]: 0 : if (!bh)
249 : : goto failure;
250 : 0 : read_lock(&EXT2_I(inode)->i_meta_lock);
251 [ # # ]: 0 : if (!verify_chain(chain, p))
252 : : goto changed;
253 : 0 : add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
254 : : read_unlock(&EXT2_I(inode)->i_meta_lock);
255 [ # # ]: 0 : if (!p->key)
256 : : goto no_block;
257 : : }
258 : : return NULL;
259 : :
260 : : changed:
261 : : read_unlock(&EXT2_I(inode)->i_meta_lock);
262 : : brelse(bh);
263 : 0 : *err = -EAGAIN;
264 : 0 : goto no_block;
265 : : failure:
266 : 0 : *err = -EIO;
267 : : no_block:
268 : 0 : return p;
269 : : }
270 : :
271 : : /**
272 : : * ext2_find_near - find a place for allocation with sufficient locality
273 : : * @inode: owner
274 : : * @ind: descriptor of indirect block.
275 : : *
276 : : * This function returns the preferred place for block allocation.
277 : : * It is used when heuristic for sequential allocation fails.
278 : : * Rules are:
279 : : * + if there is a block to the left of our position - allocate near it.
280 : : * + if pointer will live in indirect block - allocate near that block.
281 : : * + if pointer will live in inode - allocate in the same cylinder group.
282 : : *
283 : : * In the latter case we colour the starting block by the callers PID to
284 : : * prevent it from clashing with concurrent allocations for a different inode
285 : : * in the same block group. The PID is used here so that functionally related
286 : : * files will be close-by on-disk.
287 : : *
288 : : * Caller must make sure that @ind is valid and will stay that way.
289 : : */
290 : :
291 : 0 : static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
292 : : {
293 : : struct ext2_inode_info *ei = EXT2_I(inode);
294 [ # # ]: 0 : __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
295 : : __le32 *p;
296 : : ext2_fsblk_t bg_start;
297 : : ext2_fsblk_t colour;
298 : :
299 : : /* Try to find previous block */
300 [ # # ]: 0 : for (p = ind->p - 1; p >= start; p--)
301 [ # # ]: 0 : if (*p)
302 : : return le32_to_cpu(*p);
303 : :
304 : : /* No such thing, so let's try location of indirect block */
305 [ # # ]: 0 : if (ind->bh)
306 : 0 : return ind->bh->b_blocknr;
307 : :
308 : : /*
309 : : * It is going to be referred from inode itself? OK, just put it into
310 : : * the same cylinder group then.
311 : : */
312 : 0 : bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group);
313 : 0 : colour = (current->pid % 16) *
314 : 0 : (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
315 : 0 : return bg_start + colour;
316 : : }
317 : :
318 : : /**
319 : : * ext2_find_goal - find a preferred place for allocation.
320 : : * @inode: owner
321 : : * @block: block we want
322 : : * @partial: pointer to the last triple within a chain
323 : : *
324 : : * Returns preferred place for a block (the goal).
325 : : */
326 : :
327 : : static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
328 : 0 : Indirect *partial)
329 : : {
330 : : struct ext2_block_alloc_info *block_i;
331 : :
332 : 0 : block_i = EXT2_I(inode)->i_block_alloc_info;
333 : :
334 : : /*
335 : : * try the heuristic for sequential allocation,
336 : : * failing that at least try to get decent locality.
337 : : */
338 [ # # ][ # # ]: 0 : if (block_i && (block == block_i->last_alloc_logical_block + 1)
339 [ # # ]: 0 : && (block_i->last_alloc_physical_block != 0)) {
340 : 0 : return block_i->last_alloc_physical_block + 1;
341 : : }
342 : :
343 : 0 : return ext2_find_near(inode, partial);
344 : : }
345 : :
346 : : /**
347 : : * ext2_blks_to_allocate: Look up the block map and count the number
348 : : * of direct blocks need to be allocated for the given branch.
349 : : *
350 : : * @branch: chain of indirect blocks
351 : : * @k: number of blocks need for indirect blocks
352 : : * @blks: number of data blocks to be mapped.
353 : : * @blocks_to_boundary: the offset in the indirect block
354 : : *
355 : : * return the total number of blocks to be allocate, including the
356 : : * direct and indirect blocks.
357 : : */
358 : : static int
359 : 0 : ext2_blks_to_allocate(Indirect * branch, int k, unsigned long blks,
360 : : int blocks_to_boundary)
361 : : {
362 : : unsigned long count = 0;
363 : :
364 : : /*
365 : : * Simple case, [t,d]Indirect block(s) has not allocated yet
366 : : * then it's clear blocks on that path have not allocated
367 : : */
368 [ # # ]: 0 : if (k > 0) {
369 : : /* right now don't hanel cross boundary allocation */
370 [ # # ]: 0 : if (blks < blocks_to_boundary + 1)
371 : : count += blks;
372 : : else
373 : 0 : count += blocks_to_boundary + 1;
374 : 0 : return count;
375 : : }
376 : :
377 : : count++;
378 [ # # ]: 0 : while (count < blks && count <= blocks_to_boundary
379 [ # # ]: 0 : && le32_to_cpu(*(branch[0].p + count)) == 0) {
380 : 0 : count++;
381 : : }
382 : 0 : return count;
383 : : }
384 : :
385 : : /**
386 : : * ext2_alloc_blocks: multiple allocate blocks needed for a branch
387 : : * @indirect_blks: the number of blocks need to allocate for indirect
388 : : * blocks
389 : : *
390 : : * @new_blocks: on return it will store the new block numbers for
391 : : * the indirect blocks(if needed) and the first direct block,
392 : : * @blks: on return it will store the total number of allocated
393 : : * direct blocks
394 : : */
395 : 0 : static int ext2_alloc_blocks(struct inode *inode,
396 : : ext2_fsblk_t goal, int indirect_blks, int blks,
397 : : ext2_fsblk_t new_blocks[4], int *err)
398 : : {
399 : : int target, i;
400 : 0 : unsigned long count = 0;
401 : : int index = 0;
402 : : ext2_fsblk_t current_block = 0;
403 : : int ret = 0;
404 : :
405 : : /*
406 : : * Here we try to allocate the requested multiple blocks at once,
407 : : * on a best-effort basis.
408 : : * To build a branch, we should allocate blocks for
409 : : * the indirect blocks(if not allocated yet), and at least
410 : : * the first direct block of this branch. That's the
411 : : * minimum number of blocks need to allocate(required)
412 : : */
413 : 0 : target = blks + indirect_blks;
414 : :
415 : : while (1) {
416 : 0 : count = target;
417 : : /* allocating blocks for indirect blocks and direct blocks */
418 : 0 : current_block = ext2_new_blocks(inode,goal,&count,err);
419 [ # # ]: 0 : if (*err)
420 : : goto failed_out;
421 : :
422 : 0 : target -= count;
423 : : /* allocate blocks for indirect blocks */
424 [ # # ][ # # ]: 0 : while (index < indirect_blks && count) {
425 : 0 : new_blocks[index++] = current_block++;
426 : 0 : count--;
427 : : }
428 : :
429 [ # # ]: 0 : if (count > 0)
430 : : break;
431 : : }
432 : :
433 : : /* save the new block number for the first direct block */
434 : 0 : new_blocks[index] = current_block;
435 : :
436 : : /* total number of blocks allocated for direct blocks */
437 : 0 : ret = count;
438 : 0 : *err = 0;
439 : 0 : return ret;
440 : : failed_out:
441 [ # # ]: 0 : for (i = 0; i <index; i++)
442 : 0 : ext2_free_blocks(inode, new_blocks[i], 1);
443 [ # # ]: 0 : if (index)
444 : : mark_inode_dirty(inode);
445 : : return ret;
446 : : }
447 : :
448 : : /**
449 : : * ext2_alloc_branch - allocate and set up a chain of blocks.
450 : : * @inode: owner
451 : : * @num: depth of the chain (number of blocks to allocate)
452 : : * @offsets: offsets (in the blocks) to store the pointers to next.
453 : : * @branch: place to store the chain in.
454 : : *
455 : : * This function allocates @num blocks, zeroes out all but the last one,
456 : : * links them into chain and (if we are synchronous) writes them to disk.
457 : : * In other words, it prepares a branch that can be spliced onto the
458 : : * inode. It stores the information about that chain in the branch[], in
459 : : * the same format as ext2_get_branch() would do. We are calling it after
460 : : * we had read the existing part of chain and partial points to the last
461 : : * triple of that (one with zero ->key). Upon the exit we have the same
462 : : * picture as after the successful ext2_get_block(), except that in one
463 : : * place chain is disconnected - *branch->p is still zero (we did not
464 : : * set the last link), but branch->key contains the number that should
465 : : * be placed into *branch->p to fill that gap.
466 : : *
467 : : * If allocation fails we free all blocks we've allocated (and forget
468 : : * their buffer_heads) and return the error value the from failed
469 : : * ext2_alloc_block() (normally -ENOSPC). Otherwise we set the chain
470 : : * as described above and return 0.
471 : : */
472 : :
473 : 0 : static int ext2_alloc_branch(struct inode *inode,
474 : : int indirect_blks, int *blks, ext2_fsblk_t goal,
475 : : int *offsets, Indirect *branch)
476 : : {
477 : 0 : int blocksize = inode->i_sb->s_blocksize;
478 : : int i, n = 0;
479 : 0 : int err = 0;
480 : : struct buffer_head *bh;
481 : : int num;
482 : : ext2_fsblk_t new_blocks[4];
483 : : ext2_fsblk_t current_block;
484 : :
485 : 0 : num = ext2_alloc_blocks(inode, goal, indirect_blks,
486 : : *blks, new_blocks, &err);
487 [ # # ]: 0 : if (err)
488 : : return err;
489 : :
490 : 0 : branch[0].key = cpu_to_le32(new_blocks[0]);
491 : : /*
492 : : * metadata blocks and data blocks are allocated.
493 : : */
494 [ # # ]: 0 : for (n = 1; n <= indirect_blks; n++) {
495 : : /*
496 : : * Get buffer_head for parent block, zero it out
497 : : * and set the pointer to new one, then send
498 : : * parent to disk.
499 : : */
500 : 0 : bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
501 [ # # ]: 0 : if (unlikely(!bh)) {
502 : 0 : err = -ENOMEM;
503 : : goto failed;
504 : : }
505 : 0 : branch[n].bh = bh;
506 : : lock_buffer(bh);
507 [ # # ]: 0 : memset(bh->b_data, 0, blocksize);
508 : 0 : branch[n].p = (__le32 *) bh->b_data + offsets[n];
509 : 0 : branch[n].key = cpu_to_le32(new_blocks[n]);
510 : 0 : *branch[n].p = branch[n].key;
511 [ # # ]: 0 : if ( n == indirect_blks) {
512 : 0 : current_block = new_blocks[n];
513 : : /*
514 : : * End of chain, update the last new metablock of
515 : : * the chain to point to the new allocated
516 : : * data blocks numbers
517 : : */
518 [ # # ]: 0 : for (i=1; i < num; i++)
519 : 0 : *(branch[n].p + i) = cpu_to_le32(++current_block);
520 : : }
521 : : set_buffer_uptodate(bh);
522 : 0 : unlock_buffer(bh);
523 : 0 : mark_buffer_dirty_inode(bh, inode);
524 : : /* We used to sync bh here if IS_SYNC(inode).
525 : : * But we now rely upon generic_write_sync()
526 : : * and b_inode_buffers. But not for directories.
527 : : */
528 [ # # ][ # # ]: 0 : if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
[ # # ]
529 : 0 : sync_dirty_buffer(bh);
530 : : }
531 : 0 : *blks = num;
532 : 0 : return err;
533 : :
534 : : failed:
535 [ # # ]: 0 : for (i = 1; i < n; i++)
536 : 0 : bforget(branch[i].bh);
537 [ # # ]: 0 : for (i = 0; i < indirect_blks; i++)
538 : 0 : ext2_free_blocks(inode, new_blocks[i], 1);
539 : 0 : ext2_free_blocks(inode, new_blocks[i], num);
540 : 0 : return err;
541 : : }
542 : :
543 : : /**
544 : : * ext2_splice_branch - splice the allocated branch onto inode.
545 : : * @inode: owner
546 : : * @block: (logical) number of block we are adding
547 : : * @where: location of missing link
548 : : * @num: number of indirect blocks we are adding
549 : : * @blks: number of direct blocks we are adding
550 : : *
551 : : * This function fills the missing link and does all housekeeping needed in
552 : : * inode (->i_blocks, etc.). In case of success we end up with the full
553 : : * chain to new block and return 0.
554 : : */
555 : 0 : static void ext2_splice_branch(struct inode *inode,
556 : : long block, Indirect *where, int num, int blks)
557 : : {
558 : : int i;
559 : : struct ext2_block_alloc_info *block_i;
560 : : ext2_fsblk_t current_block;
561 : :
562 : 0 : block_i = EXT2_I(inode)->i_block_alloc_info;
563 : :
564 : : /* XXX LOCKING probably should have i_meta_lock ?*/
565 : : /* That's it */
566 : :
567 : 0 : *where->p = where->key;
568 : :
569 : : /*
570 : : * Update the host buffer_head or inode to point to more just allocated
571 : : * direct blocks blocks
572 : : */
573 [ # # ]: 0 : if (num == 0 && blks > 1) {
574 : 0 : current_block = le32_to_cpu(where->key) + 1;
575 [ # # ]: 0 : for (i = 1; i < blks; i++)
576 : 0 : *(where->p + i ) = cpu_to_le32(current_block++);
577 : : }
578 : :
579 : : /*
580 : : * update the most recently allocated logical & physical block
581 : : * in i_block_alloc_info, to assist find the proper goal block for next
582 : : * allocation
583 : : */
584 [ # # ]: 0 : if (block_i) {
585 : 0 : block_i->last_alloc_logical_block = block + blks - 1;
586 : 0 : block_i->last_alloc_physical_block =
587 : 0 : le32_to_cpu(where[num].key) + blks - 1;
588 : : }
589 : :
590 : : /* We are done with atomic stuff, now do the rest of housekeeping */
591 : :
592 : : /* had we spliced it onto indirect block? */
593 [ # # ]: 0 : if (where->bh)
594 : 0 : mark_buffer_dirty_inode(where->bh, inode);
595 : :
596 : 0 : inode->i_ctime = CURRENT_TIME_SEC;
597 : : mark_inode_dirty(inode);
598 : 0 : }
599 : :
600 : : /*
601 : : * Allocation strategy is simple: if we have to allocate something, we will
602 : : * have to go the whole way to leaf. So let's do it before attaching anything
603 : : * to tree, set linkage between the newborn blocks, write them if sync is
604 : : * required, recheck the path, free and repeat if check fails, otherwise
605 : : * set the last missing link (that will protect us from any truncate-generated
606 : : * removals - all blocks on the path are immune now) and possibly force the
607 : : * write on the parent block.
608 : : * That has a nice additional property: no special recovery from the failed
609 : : * allocations is needed - we simply release blocks and do not touch anything
610 : : * reachable from inode.
611 : : *
612 : : * `handle' can be NULL if create == 0.
613 : : *
614 : : * return > 0, # of blocks mapped or allocated.
615 : : * return = 0, if plain lookup failed.
616 : : * return < 0, error case.
617 : : */
618 : 0 : static int ext2_get_blocks(struct inode *inode,
619 : : sector_t iblock, unsigned long maxblocks,
620 : : struct buffer_head *bh_result,
621 : : int create)
622 : : {
623 : 0 : int err = -EIO;
624 : : int offsets[4];
625 : : Indirect chain[4];
626 : : Indirect *partial;
627 : : ext2_fsblk_t goal;
628 : : int indirect_blks;
629 : 0 : int blocks_to_boundary = 0;
630 : : int depth;
631 : : struct ext2_inode_info *ei = EXT2_I(inode);
632 : 0 : int count = 0;
633 : : ext2_fsblk_t first_block = 0;
634 : :
635 [ # # ]: 0 : BUG_ON(maxblocks == 0);
636 : :
637 : 0 : depth = ext2_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
638 : :
639 [ # # ]: 0 : if (depth == 0)
640 : 0 : return (err);
641 : :
642 : 0 : partial = ext2_get_branch(inode, depth, offsets, chain, &err);
643 : : /* Simplest case - block found, no allocation needed */
644 [ # # ]: 0 : if (!partial) {
645 : 0 : first_block = le32_to_cpu(chain[depth - 1].key);
646 : : clear_buffer_new(bh_result); /* What's this do? */
647 : 0 : count++;
648 : : /*map more blocks*/
649 [ # # ][ # # ]: 0 : while (count < maxblocks && count <= blocks_to_boundary) {
650 : : ext2_fsblk_t blk;
651 : :
652 [ # # ]: 0 : if (!verify_chain(chain, chain + depth - 1)) {
653 : : /*
654 : : * Indirect block might be removed by
655 : : * truncate while we were reading it.
656 : : * Handling of that case: forget what we've
657 : : * got now, go to reread.
658 : : */
659 : 0 : err = -EAGAIN;
660 : 0 : count = 0;
661 : 0 : break;
662 : : }
663 : 0 : blk = le32_to_cpu(*(chain[depth-1].p + count));
664 [ # # ]: 0 : if (blk == first_block + count)
665 : 0 : count++;
666 : : else
667 : : break;
668 : : }
669 [ # # ]: 0 : if (err != -EAGAIN)
670 : : goto got_it;
671 : : }
672 : :
673 : : /* Next simple case - plain lookup or failed read of indirect block */
674 [ # # ][ # # ]: 0 : if (!create || err == -EIO)
675 : : goto cleanup;
676 : :
677 : 0 : mutex_lock(&ei->truncate_mutex);
678 : : /*
679 : : * If the indirect block is missing while we are reading
680 : : * the chain(ext2_get_branch() returns -EAGAIN err), or
681 : : * if the chain has been changed after we grab the semaphore,
682 : : * (either because another process truncated this branch, or
683 : : * another get_block allocated this branch) re-grab the chain to see if
684 : : * the request block has been allocated or not.
685 : : *
686 : : * Since we already block the truncate/other get_block
687 : : * at this point, we will have the current copy of the chain when we
688 : : * splice the branch into the tree.
689 : : */
690 [ # # ][ # # ]: 0 : if (err == -EAGAIN || !verify_chain(chain, partial)) {
691 [ # # ]: 0 : while (partial > chain) {
692 : 0 : brelse(partial->bh);
693 : 0 : partial--;
694 : : }
695 : 0 : partial = ext2_get_branch(inode, depth, offsets, chain, &err);
696 [ # # ]: 0 : if (!partial) {
697 : 0 : count++;
698 : 0 : mutex_unlock(&ei->truncate_mutex);
699 [ # # ]: 0 : if (err)
700 : : goto cleanup;
701 : : clear_buffer_new(bh_result);
702 : : goto got_it;
703 : : }
704 : : }
705 : :
706 : : /*
707 : : * Okay, we need to do block allocation. Lazily initialize the block
708 : : * allocation info here if necessary
709 : : */
710 [ # # ][ # # ]: 0 : if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
711 : 0 : ext2_init_block_alloc_info(inode);
712 : :
713 : : goal = ext2_find_goal(inode, iblock, partial);
714 : :
715 : : /* the number of blocks need to allocate for [d,t]indirect blocks */
716 : 0 : indirect_blks = (chain + depth) - partial - 1;
717 : : /*
718 : : * Next look up the indirect map to count the totoal number of
719 : : * direct blocks to allocate for this branch.
720 : : */
721 : 0 : count = ext2_blks_to_allocate(partial, indirect_blks,
722 : : maxblocks, blocks_to_boundary);
723 : : /*
724 : : * XXX ???? Block out ext2_truncate while we alter the tree
725 : : */
726 : 0 : err = ext2_alloc_branch(inode, indirect_blks, &count, goal,
727 : 0 : offsets + (partial - chain), partial);
728 : :
729 [ # # ]: 0 : if (err) {
730 : 0 : mutex_unlock(&ei->truncate_mutex);
731 : 0 : goto cleanup;
732 : : }
733 : :
734 : : if (ext2_use_xip(inode->i_sb)) {
735 : : /*
736 : : * we need to clear the block
737 : : */
738 : : err = ext2_clear_xip_target (inode,
739 : : le32_to_cpu(chain[depth-1].key));
740 : : if (err) {
741 : : mutex_unlock(&ei->truncate_mutex);
742 : : goto cleanup;
743 : : }
744 : : }
745 : :
746 : 0 : ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
747 : 0 : mutex_unlock(&ei->truncate_mutex);
748 : : set_buffer_new(bh_result);
749 : : got_it:
750 : 0 : map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
751 [ # # ]: 0 : if (count > blocks_to_boundary)
752 : : set_buffer_boundary(bh_result);
753 : 0 : err = count;
754 : : /* Clean up and exit */
755 : 0 : partial = chain + depth - 1; /* the whole chain */
756 : : cleanup:
757 [ # # ]: 0 : while (partial > chain) {
758 : 0 : brelse(partial->bh);
759 : 0 : partial--;
760 : : }
761 : 0 : return err;
762 : : }
763 : :
764 : 0 : int ext2_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
765 : : {
766 : 0 : unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
767 : 0 : int ret = ext2_get_blocks(inode, iblock, max_blocks,
768 : : bh_result, create);
769 [ # # ]: 0 : if (ret > 0) {
770 : 0 : bh_result->b_size = (ret << inode->i_blkbits);
771 : : ret = 0;
772 : : }
773 : 0 : return ret;
774 : :
775 : : }
776 : :
777 : 0 : int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
778 : : u64 start, u64 len)
779 : : {
780 : 0 : return generic_block_fiemap(inode, fieinfo, start, len,
781 : : ext2_get_block);
782 : : }
783 : :
784 : 0 : static int ext2_writepage(struct page *page, struct writeback_control *wbc)
785 : : {
786 : 0 : return block_write_full_page(page, ext2_get_block, wbc);
787 : : }
788 : :
789 : 0 : static int ext2_readpage(struct file *file, struct page *page)
790 : : {
791 : 0 : return mpage_readpage(page, ext2_get_block);
792 : : }
793 : :
794 : : static int
795 : 0 : ext2_readpages(struct file *file, struct address_space *mapping,
796 : : struct list_head *pages, unsigned nr_pages)
797 : : {
798 : 0 : return mpage_readpages(mapping, pages, nr_pages, ext2_get_block);
799 : : }
800 : :
801 : : static int
802 : 0 : ext2_write_begin(struct file *file, struct address_space *mapping,
803 : : loff_t pos, unsigned len, unsigned flags,
804 : : struct page **pagep, void **fsdata)
805 : : {
806 : : int ret;
807 : :
808 : 0 : ret = block_write_begin(mapping, pos, len, flags, pagep,
809 : : ext2_get_block);
810 [ # # ]: 0 : if (ret < 0)
811 : 0 : ext2_write_failed(mapping, pos + len);
812 : 0 : return ret;
813 : : }
814 : :
815 : 0 : static int ext2_write_end(struct file *file, struct address_space *mapping,
816 : : loff_t pos, unsigned len, unsigned copied,
817 : : struct page *page, void *fsdata)
818 : : {
819 : : int ret;
820 : :
821 : 0 : ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
822 [ # # ]: 0 : if (ret < len)
823 : 0 : ext2_write_failed(mapping, pos + len);
824 : 0 : return ret;
825 : : }
826 : :
827 : : static int
828 : 0 : ext2_nobh_write_begin(struct file *file, struct address_space *mapping,
829 : : loff_t pos, unsigned len, unsigned flags,
830 : : struct page **pagep, void **fsdata)
831 : : {
832 : : int ret;
833 : :
834 : 0 : ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
835 : : ext2_get_block);
836 [ # # ]: 0 : if (ret < 0)
837 : 0 : ext2_write_failed(mapping, pos + len);
838 : 0 : return ret;
839 : : }
840 : :
841 : 0 : static int ext2_nobh_writepage(struct page *page,
842 : : struct writeback_control *wbc)
843 : : {
844 : 0 : return nobh_writepage(page, ext2_get_block, wbc);
845 : : }
846 : :
847 : 0 : static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
848 : : {
849 : 0 : return generic_block_bmap(mapping,block,ext2_get_block);
850 : : }
851 : :
852 : : static ssize_t
853 : 0 : ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
854 : : loff_t offset, unsigned long nr_segs)
855 : : {
856 : 0 : struct file *file = iocb->ki_filp;
857 : 0 : struct address_space *mapping = file->f_mapping;
858 : 0 : struct inode *inode = mapping->host;
859 : : ssize_t ret;
860 : :
861 : : ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
862 : : ext2_get_block);
863 [ # # ][ # # ]: 0 : if (ret < 0 && (rw & WRITE))
864 : 0 : ext2_write_failed(mapping, offset + iov_length(iov, nr_segs));
865 : 0 : return ret;
866 : : }
867 : :
868 : : static int
869 : 0 : ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
870 : : {
871 : 0 : return mpage_writepages(mapping, wbc, ext2_get_block);
872 : : }
873 : :
874 : : const struct address_space_operations ext2_aops = {
875 : : .readpage = ext2_readpage,
876 : : .readpages = ext2_readpages,
877 : : .writepage = ext2_writepage,
878 : : .write_begin = ext2_write_begin,
879 : : .write_end = ext2_write_end,
880 : : .bmap = ext2_bmap,
881 : : .direct_IO = ext2_direct_IO,
882 : : .writepages = ext2_writepages,
883 : : .migratepage = buffer_migrate_page,
884 : : .is_partially_uptodate = block_is_partially_uptodate,
885 : : .error_remove_page = generic_error_remove_page,
886 : : };
887 : :
888 : : const struct address_space_operations ext2_aops_xip = {
889 : : .bmap = ext2_bmap,
890 : : .get_xip_mem = ext2_get_xip_mem,
891 : : };
892 : :
893 : : const struct address_space_operations ext2_nobh_aops = {
894 : : .readpage = ext2_readpage,
895 : : .readpages = ext2_readpages,
896 : : .writepage = ext2_nobh_writepage,
897 : : .write_begin = ext2_nobh_write_begin,
898 : : .write_end = nobh_write_end,
899 : : .bmap = ext2_bmap,
900 : : .direct_IO = ext2_direct_IO,
901 : : .writepages = ext2_writepages,
902 : : .migratepage = buffer_migrate_page,
903 : : .error_remove_page = generic_error_remove_page,
904 : : };
905 : :
906 : : /*
907 : : * Probably it should be a library function... search for first non-zero word
908 : : * or memcmp with zero_page, whatever is better for particular architecture.
909 : : * Linus?
910 : : */
911 : : static inline int all_zeroes(__le32 *p, __le32 *q)
912 : : {
913 [ # # ]: 0 : while (p < q)
914 [ # # ]: 0 : if (*p++)
915 : : return 0;
916 : : return 1;
917 : : }
918 : :
919 : : /**
920 : : * ext2_find_shared - find the indirect blocks for partial truncation.
921 : : * @inode: inode in question
922 : : * @depth: depth of the affected branch
923 : : * @offsets: offsets of pointers in that branch (see ext2_block_to_path)
924 : : * @chain: place to store the pointers to partial indirect blocks
925 : : * @top: place to the (detached) top of branch
926 : : *
927 : : * This is a helper function used by ext2_truncate().
928 : : *
929 : : * When we do truncate() we may have to clean the ends of several indirect
930 : : * blocks but leave the blocks themselves alive. Block is partially
931 : : * truncated if some data below the new i_size is referred from it (and
932 : : * it is on the path to the first completely truncated data block, indeed).
933 : : * We have to free the top of that path along with everything to the right
934 : : * of the path. Since no allocation past the truncation point is possible
935 : : * until ext2_truncate() finishes, we may safely do the latter, but top
936 : : * of branch may require special attention - pageout below the truncation
937 : : * point might try to populate it.
938 : : *
939 : : * We atomically detach the top of branch from the tree, store the block
940 : : * number of its root in *@top, pointers to buffer_heads of partially
941 : : * truncated blocks - in @chain[].bh and pointers to their last elements
942 : : * that should not be removed - in @chain[].p. Return value is the pointer
943 : : * to last filled element of @chain.
944 : : *
945 : : * The work left to caller to do the actual freeing of subtrees:
946 : : * a) free the subtree starting from *@top
947 : : * b) free the subtrees whose roots are stored in
948 : : * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
949 : : * c) free the subtrees growing from the inode past the @chain[0].p
950 : : * (no partially truncated stuff there).
951 : : */
952 : :
953 : 0 : static Indirect *ext2_find_shared(struct inode *inode,
954 : : int depth,
955 : : int offsets[4],
956 : : Indirect chain[4],
957 : : __le32 *top)
958 : : {
959 : : Indirect *partial, *p;
960 : : int k, err;
961 : :
962 : 0 : *top = 0;
963 [ # # ][ # # ]: 0 : for (k = depth; k > 1 && !offsets[k-1]; k--)
964 : : ;
965 : 0 : partial = ext2_get_branch(inode, k, offsets, chain, &err);
966 [ # # ]: 0 : if (!partial)
967 : 0 : partial = chain + k-1;
968 : : /*
969 : : * If the branch acquired continuation since we've looked at it -
970 : : * fine, it should all survive and (new) top doesn't belong to us.
971 : : */
972 : 0 : write_lock(&EXT2_I(inode)->i_meta_lock);
973 [ # # ][ # # ]: 0 : if (!partial->key && *partial->p) {
974 : : write_unlock(&EXT2_I(inode)->i_meta_lock);
975 : : goto no_top;
976 : : }
977 [ # # ][ # # ]: 0 : for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
978 : : ;
979 : : /*
980 : : * OK, we've found the last block that must survive. The rest of our
981 : : * branch should be detached before unlocking. However, if that rest
982 : : * of branch is all ours and does not grow immediately from the inode
983 : : * it's easier to cheat and just decrement partial->p.
984 : : */
985 [ # # ][ # # ]: 0 : if (p == chain + k - 1 && p > chain) {
986 : 0 : p->p--;
987 : : } else {
988 : 0 : *top = *p->p;
989 : 0 : *p->p = 0;
990 : : }
991 : : write_unlock(&EXT2_I(inode)->i_meta_lock);
992 : :
993 [ # # ]: 0 : while(partial > p)
994 : : {
995 : 0 : brelse(partial->bh);
996 : 0 : partial--;
997 : : }
998 : : no_top:
999 : 0 : return partial;
1000 : : }
1001 : :
1002 : : /**
1003 : : * ext2_free_data - free a list of data blocks
1004 : : * @inode: inode we are dealing with
1005 : : * @p: array of block numbers
1006 : : * @q: points immediately past the end of array
1007 : : *
1008 : : * We are freeing all blocks referred from that array (numbers are
1009 : : * stored as little-endian 32-bit) and updating @inode->i_blocks
1010 : : * appropriately.
1011 : : */
1012 : : static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
1013 : : {
1014 : : unsigned long block_to_free = 0, count = 0;
1015 : : unsigned long nr;
1016 : :
1017 [ # # ][ # # ]: 0 : for ( ; p < q ; p++) {
1018 : 0 : nr = le32_to_cpu(*p);
1019 [ # # ][ # # ]: 0 : if (nr) {
1020 : 0 : *p = 0;
1021 : : /* accumulate blocks to free if they're contiguous */
1022 [ # # ][ # # ]: 0 : if (count == 0)
1023 : : goto free_this;
1024 [ # # ][ # # ]: 0 : else if (block_to_free == nr - count)
1025 : 0 : count++;
1026 : : else {
1027 : 0 : ext2_free_blocks (inode, block_to_free, count);
1028 : : mark_inode_dirty(inode);
1029 : : free_this:
1030 : : block_to_free = nr;
1031 : : count = 1;
1032 : : }
1033 : : }
1034 : : }
1035 [ # # ][ # # ]: 0 : if (count > 0) {
1036 : 0 : ext2_free_blocks (inode, block_to_free, count);
1037 : : mark_inode_dirty(inode);
1038 : : }
1039 : : }
1040 : :
1041 : : /**
1042 : : * ext2_free_branches - free an array of branches
1043 : : * @inode: inode we are dealing with
1044 : : * @p: array of block numbers
1045 : : * @q: pointer immediately past the end of array
1046 : : * @depth: depth of the branches to free
1047 : : *
1048 : : * We are freeing all blocks referred from these branches (numbers are
1049 : : * stored as little-endian 32-bit) and updating @inode->i_blocks
1050 : : * appropriately.
1051 : : */
1052 : 0 : static void ext2_free_branches(struct inode *inode, __le32 *p, __le32 *q, int depth)
1053 : : {
1054 : : struct buffer_head * bh;
1055 : : unsigned long nr;
1056 : :
1057 [ # # ]: 0 : if (depth--) {
1058 : 0 : int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1059 [ # # ]: 0 : for ( ; p < q ; p++) {
1060 : 0 : nr = le32_to_cpu(*p);
1061 [ # # ]: 0 : if (!nr)
1062 : 0 : continue;
1063 : 0 : *p = 0;
1064 : 0 : bh = sb_bread(inode->i_sb, nr);
1065 : : /*
1066 : : * A read failure? Report error and clear slot
1067 : : * (should be rare).
1068 : : */
1069 [ # # ]: 0 : if (!bh) {
1070 : 0 : ext2_error(inode->i_sb, "ext2_free_branches",
1071 : : "Read failure, inode=%ld, block=%ld",
1072 : : inode->i_ino, nr);
1073 : 0 : continue;
1074 : : }
1075 : 0 : ext2_free_branches(inode,
1076 : : (__le32*)bh->b_data,
1077 : 0 : (__le32*)bh->b_data + addr_per_block,
1078 : : depth);
1079 : : bforget(bh);
1080 : 0 : ext2_free_blocks(inode, nr, 1);
1081 : : mark_inode_dirty(inode);
1082 : : }
1083 : : } else
1084 : : ext2_free_data(inode, p, q);
1085 : 0 : }
1086 : :
1087 : 0 : static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
1088 : : {
1089 : 0 : __le32 *i_data = EXT2_I(inode)->i_data;
1090 : : struct ext2_inode_info *ei = EXT2_I(inode);
1091 : 0 : int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1092 : : int offsets[4];
1093 : : Indirect chain[4];
1094 : : Indirect *partial;
1095 : 0 : __le32 nr = 0;
1096 : : int n;
1097 : : long iblock;
1098 : : unsigned blocksize;
1099 : : blocksize = inode->i_sb->s_blocksize;
1100 : 0 : iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
1101 : :
1102 : 0 : n = ext2_block_to_path(inode, iblock, offsets, NULL);
1103 [ # # ]: 0 : if (n == 0)
1104 : 0 : return;
1105 : :
1106 : : /*
1107 : : * From here we block out all ext2_get_block() callers who want to
1108 : : * modify the block allocation tree.
1109 : : */
1110 : 0 : mutex_lock(&ei->truncate_mutex);
1111 : :
1112 [ # # ]: 0 : if (n == 1) {
1113 : 0 : ext2_free_data(inode, i_data+offsets[0],
1114 : : i_data + EXT2_NDIR_BLOCKS);
1115 : : goto do_indirects;
1116 : : }
1117 : :
1118 : 0 : partial = ext2_find_shared(inode, n, offsets, chain, &nr);
1119 : : /* Kill the top of shared branch (already detached) */
1120 [ # # ]: 0 : if (nr) {
1121 [ # # ]: 0 : if (partial == chain)
1122 : : mark_inode_dirty(inode);
1123 : : else
1124 : 0 : mark_buffer_dirty_inode(partial->bh, inode);
1125 : 0 : ext2_free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);
1126 : : }
1127 : : /* Clear the ends of indirect blocks on the shared branch */
1128 [ # # ]: 0 : while (partial > chain) {
1129 : 0 : ext2_free_branches(inode,
1130 : 0 : partial->p + 1,
1131 : 0 : (__le32*)partial->bh->b_data+addr_per_block,
1132 : 0 : (chain+n-1) - partial);
1133 : 0 : mark_buffer_dirty_inode(partial->bh, inode);
1134 : 0 : brelse (partial->bh);
1135 : 0 : partial--;
1136 : : }
1137 : : do_indirects:
1138 : : /* Kill the remaining (whole) subtrees */
1139 [ # # # # ]: 0 : switch (offsets[0]) {
1140 : : default:
1141 : 0 : nr = i_data[EXT2_IND_BLOCK];
1142 [ # # ]: 0 : if (nr) {
1143 : 0 : i_data[EXT2_IND_BLOCK] = 0;
1144 : : mark_inode_dirty(inode);
1145 : 0 : ext2_free_branches(inode, &nr, &nr+1, 1);
1146 : : }
1147 : : case EXT2_IND_BLOCK:
1148 : 0 : nr = i_data[EXT2_DIND_BLOCK];
1149 [ # # ]: 0 : if (nr) {
1150 : 0 : i_data[EXT2_DIND_BLOCK] = 0;
1151 : : mark_inode_dirty(inode);
1152 : 0 : ext2_free_branches(inode, &nr, &nr+1, 2);
1153 : : }
1154 : : case EXT2_DIND_BLOCK:
1155 : 0 : nr = i_data[EXT2_TIND_BLOCK];
1156 [ # # ]: 0 : if (nr) {
1157 : 0 : i_data[EXT2_TIND_BLOCK] = 0;
1158 : : mark_inode_dirty(inode);
1159 : 0 : ext2_free_branches(inode, &nr, &nr+1, 3);
1160 : : }
1161 : : case EXT2_TIND_BLOCK:
1162 : : ;
1163 : : }
1164 : :
1165 : 0 : ext2_discard_reservation(inode);
1166 : :
1167 : 0 : mutex_unlock(&ei->truncate_mutex);
1168 : : }
1169 : :
1170 : 0 : static void ext2_truncate_blocks(struct inode *inode, loff_t offset)
1171 : : {
1172 : : /*
1173 : : * XXX: it seems like a bug here that we don't allow
1174 : : * IS_APPEND inode to have blocks-past-i_size trimmed off.
1175 : : * review and fix this.
1176 : : *
1177 : : * Also would be nice to be able to handle IO errors and such,
1178 : : * but that's probably too much to ask.
1179 : : */
1180 [ # # ][ # # ]: 0 : if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1181 : : S_ISLNK(inode->i_mode)))
1182 : : return;
1183 [ # # ]: 0 : if (ext2_inode_is_fast_symlink(inode))
1184 : : return;
1185 [ # # ]: 0 : if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1186 : : return;
1187 : 0 : __ext2_truncate_blocks(inode, offset);
1188 : : }
1189 : :
1190 : 0 : static int ext2_setsize(struct inode *inode, loff_t newsize)
1191 : : {
1192 : : int error;
1193 : :
1194 [ # # ][ # # ]: 0 : if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1195 : : S_ISLNK(inode->i_mode)))
1196 : : return -EINVAL;
1197 [ # # ]: 0 : if (ext2_inode_is_fast_symlink(inode))
1198 : : return -EINVAL;
1199 [ # # ]: 0 : if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1200 : : return -EPERM;
1201 : :
1202 : 0 : inode_dio_wait(inode);
1203 : :
1204 : : if (mapping_is_xip(inode->i_mapping))
1205 : : error = xip_truncate_page(inode->i_mapping, newsize);
1206 [ # # ]: 0 : else if (test_opt(inode->i_sb, NOBH))
1207 : 0 : error = nobh_truncate_page(inode->i_mapping,
1208 : : newsize, ext2_get_block);
1209 : : else
1210 : 0 : error = block_truncate_page(inode->i_mapping,
1211 : : newsize, ext2_get_block);
1212 [ # # ]: 0 : if (error)
1213 : : return error;
1214 : :
1215 : 0 : truncate_setsize(inode, newsize);
1216 : 0 : __ext2_truncate_blocks(inode, newsize);
1217 : :
1218 : 0 : inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
1219 [ # # ]: 0 : if (inode_needs_sync(inode)) {
1220 : 0 : sync_mapping_buffers(inode->i_mapping);
1221 : 0 : sync_inode_metadata(inode, 1);
1222 : : } else {
1223 : : mark_inode_dirty(inode);
1224 : : }
1225 : :
1226 : : return 0;
1227 : : }
1228 : :
1229 : 0 : static struct ext2_inode *ext2_get_inode(struct super_block *sb, ino_t ino,
1230 : : struct buffer_head **p)
1231 : : {
1232 : : struct buffer_head * bh;
1233 : : unsigned long block_group;
1234 : : unsigned long block;
1235 : : unsigned long offset;
1236 : : struct ext2_group_desc * gdp;
1237 : :
1238 : 0 : *p = NULL;
1239 [ # # ][ # # ]: 0 : if ((ino != EXT2_ROOT_INO && ino < EXT2_FIRST_INO(sb)) ||
[ # # ]
1240 : 0 : ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
1241 : : goto Einval;
1242 : :
1243 : 0 : block_group = (ino - 1) / EXT2_INODES_PER_GROUP(sb);
1244 : 0 : gdp = ext2_get_group_desc(sb, block_group, NULL);
1245 [ # # ]: 0 : if (!gdp)
1246 : : goto Egdp;
1247 : : /*
1248 : : * Figure out the offset within the block group inode table
1249 : : */
1250 : 0 : offset = ((ino - 1) % EXT2_INODES_PER_GROUP(sb)) * EXT2_INODE_SIZE(sb);
1251 : 0 : block = le32_to_cpu(gdp->bg_inode_table) +
1252 : 0 : (offset >> EXT2_BLOCK_SIZE_BITS(sb));
1253 [ # # ]: 0 : if (!(bh = sb_bread(sb, block)))
1254 : : goto Eio;
1255 : :
1256 : 0 : *p = bh;
1257 : 0 : offset &= (EXT2_BLOCK_SIZE(sb) - 1);
1258 : 0 : return (struct ext2_inode *) (bh->b_data + offset);
1259 : :
1260 : : Einval:
1261 : 0 : ext2_error(sb, "ext2_get_inode", "bad inode number: %lu",
1262 : : (unsigned long) ino);
1263 : 0 : return ERR_PTR(-EINVAL);
1264 : : Eio:
1265 : 0 : ext2_error(sb, "ext2_get_inode",
1266 : : "unable to read inode block - inode=%lu, block=%lu",
1267 : : (unsigned long) ino, block);
1268 : : Egdp:
1269 : : return ERR_PTR(-EIO);
1270 : : }
1271 : :
1272 : 0 : void ext2_set_inode_flags(struct inode *inode)
1273 : : {
1274 : 0 : unsigned int flags = EXT2_I(inode)->i_flags;
1275 : :
1276 : 0 : inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
1277 [ # # ]: 0 : if (flags & EXT2_SYNC_FL)
1278 : 0 : inode->i_flags |= S_SYNC;
1279 [ # # ]: 0 : if (flags & EXT2_APPEND_FL)
1280 : 0 : inode->i_flags |= S_APPEND;
1281 [ # # ]: 0 : if (flags & EXT2_IMMUTABLE_FL)
1282 : 0 : inode->i_flags |= S_IMMUTABLE;
1283 [ # # ]: 0 : if (flags & EXT2_NOATIME_FL)
1284 : 0 : inode->i_flags |= S_NOATIME;
1285 [ # # ]: 0 : if (flags & EXT2_DIRSYNC_FL)
1286 : 0 : inode->i_flags |= S_DIRSYNC;
1287 : 0 : }
1288 : :
1289 : : /* Propagate flags from i_flags to EXT2_I(inode)->i_flags */
1290 : 0 : void ext2_get_inode_flags(struct ext2_inode_info *ei)
1291 : : {
1292 : 0 : unsigned int flags = ei->vfs_inode.i_flags;
1293 : :
1294 : 0 : ei->i_flags &= ~(EXT2_SYNC_FL|EXT2_APPEND_FL|
1295 : : EXT2_IMMUTABLE_FL|EXT2_NOATIME_FL|EXT2_DIRSYNC_FL);
1296 [ # # ]: 0 : if (flags & S_SYNC)
1297 : 0 : ei->i_flags |= EXT2_SYNC_FL;
1298 [ # # ]: 0 : if (flags & S_APPEND)
1299 : 0 : ei->i_flags |= EXT2_APPEND_FL;
1300 [ # # ]: 0 : if (flags & S_IMMUTABLE)
1301 : 0 : ei->i_flags |= EXT2_IMMUTABLE_FL;
1302 [ # # ]: 0 : if (flags & S_NOATIME)
1303 : 0 : ei->i_flags |= EXT2_NOATIME_FL;
1304 [ # # ]: 0 : if (flags & S_DIRSYNC)
1305 : 0 : ei->i_flags |= EXT2_DIRSYNC_FL;
1306 : 0 : }
1307 : :
1308 : 0 : struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
1309 : : {
1310 : : struct ext2_inode_info *ei;
1311 : : struct buffer_head * bh;
1312 : : struct ext2_inode *raw_inode;
1313 : : struct inode *inode;
1314 : : long ret = -EIO;
1315 : : int n;
1316 : : uid_t i_uid;
1317 : : gid_t i_gid;
1318 : :
1319 : 0 : inode = iget_locked(sb, ino);
1320 [ # # ]: 0 : if (!inode)
1321 : : return ERR_PTR(-ENOMEM);
1322 [ # # ]: 0 : if (!(inode->i_state & I_NEW))
1323 : : return inode;
1324 : :
1325 : : ei = EXT2_I(inode);
1326 : 0 : ei->i_block_alloc_info = NULL;
1327 : :
1328 : 0 : raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
1329 [ # # ]: 0 : if (IS_ERR(raw_inode)) {
1330 : : ret = PTR_ERR(raw_inode);
1331 : 0 : goto bad_inode;
1332 : : }
1333 : :
1334 : 0 : inode->i_mode = le16_to_cpu(raw_inode->i_mode);
1335 : 0 : i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
1336 : 0 : i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
1337 [ # # ]: 0 : if (!(test_opt (inode->i_sb, NO_UID32))) {
1338 : 0 : i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
1339 : 0 : i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
1340 : : }
1341 : : i_uid_write(inode, i_uid);
1342 : : i_gid_write(inode, i_gid);
1343 : 0 : set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
1344 : 0 : inode->i_size = le32_to_cpu(raw_inode->i_size);
1345 : 0 : inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
1346 : 0 : inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
1347 : 0 : inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
1348 : 0 : inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = 0;
1349 : 0 : ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
1350 : : /* We now have enough fields to check if the inode was active or not.
1351 : : * This is needed because nfsd might try to access dead inodes
1352 : : * the test is that same one that e2fsck uses
1353 : : * NeilBrown 1999oct15
1354 : : */
1355 [ # # ][ # # ]: 0 : if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
[ # # ]
1356 : : /* this inode is deleted */
1357 : 0 : brelse (bh);
1358 : : ret = -ESTALE;
1359 : : goto bad_inode;
1360 : : }
1361 : 0 : inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
1362 : 0 : ei->i_flags = le32_to_cpu(raw_inode->i_flags);
1363 : 0 : ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
1364 : 0 : ei->i_frag_no = raw_inode->i_frag;
1365 : 0 : ei->i_frag_size = raw_inode->i_fsize;
1366 : 0 : ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
1367 : 0 : ei->i_dir_acl = 0;
1368 [ # # ]: 0 : if (S_ISREG(inode->i_mode))
1369 : 0 : inode->i_size |= ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
1370 : : else
1371 : 0 : ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
1372 : 0 : ei->i_dtime = 0;
1373 : 0 : inode->i_generation = le32_to_cpu(raw_inode->i_generation);
1374 : 0 : ei->i_state = 0;
1375 : 0 : ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
1376 : 0 : ei->i_dir_start_lookup = 0;
1377 : :
1378 : : /*
1379 : : * NOTE! The in-memory inode i_data array is in little-endian order
1380 : : * even on big-endian machines: we do NOT byteswap the block numbers!
1381 : : */
1382 [ # # ]: 0 : for (n = 0; n < EXT2_N_BLOCKS; n++)
1383 : 0 : ei->i_data[n] = raw_inode->i_block[n];
1384 : :
1385 [ # # ]: 0 : if (S_ISREG(inode->i_mode)) {
1386 : 0 : inode->i_op = &ext2_file_inode_operations;
1387 : : if (ext2_use_xip(inode->i_sb)) {
1388 : : inode->i_mapping->a_ops = &ext2_aops_xip;
1389 : : inode->i_fop = &ext2_xip_file_operations;
1390 [ # # ]: 0 : } else if (test_opt(inode->i_sb, NOBH)) {
1391 : 0 : inode->i_mapping->a_ops = &ext2_nobh_aops;
1392 : 0 : inode->i_fop = &ext2_file_operations;
1393 : : } else {
1394 : 0 : inode->i_mapping->a_ops = &ext2_aops;
1395 : 0 : inode->i_fop = &ext2_file_operations;
1396 : : }
1397 [ # # ]: 0 : } else if (S_ISDIR(inode->i_mode)) {
1398 : 0 : inode->i_op = &ext2_dir_inode_operations;
1399 : 0 : inode->i_fop = &ext2_dir_operations;
1400 [ # # ]: 0 : if (test_opt(inode->i_sb, NOBH))
1401 : 0 : inode->i_mapping->a_ops = &ext2_nobh_aops;
1402 : : else
1403 : 0 : inode->i_mapping->a_ops = &ext2_aops;
1404 [ # # ]: 0 : } else if (S_ISLNK(inode->i_mode)) {
1405 [ # # ]: 0 : if (ext2_inode_is_fast_symlink(inode)) {
1406 : 0 : inode->i_op = &ext2_fast_symlink_inode_operations;
1407 : 0 : nd_terminate_link(ei->i_data, inode->i_size,
1408 : : sizeof(ei->i_data) - 1);
1409 : : } else {
1410 : 0 : inode->i_op = &ext2_symlink_inode_operations;
1411 [ # # ]: 0 : if (test_opt(inode->i_sb, NOBH))
1412 : 0 : inode->i_mapping->a_ops = &ext2_nobh_aops;
1413 : : else
1414 : 0 : inode->i_mapping->a_ops = &ext2_aops;
1415 : : }
1416 : : } else {
1417 : 0 : inode->i_op = &ext2_special_inode_operations;
1418 [ # # ]: 0 : if (raw_inode->i_block[0])
1419 : 0 : init_special_inode(inode, inode->i_mode,
1420 : : old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
1421 : : else
1422 : 0 : init_special_inode(inode, inode->i_mode,
1423 : : new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
1424 : : }
1425 : 0 : brelse (bh);
1426 : 0 : ext2_set_inode_flags(inode);
1427 : 0 : unlock_new_inode(inode);
1428 : 0 : return inode;
1429 : :
1430 : : bad_inode:
1431 : 0 : iget_failed(inode);
1432 : 0 : return ERR_PTR(ret);
1433 : : }
1434 : :
1435 : 0 : static int __ext2_write_inode(struct inode *inode, int do_sync)
1436 : : {
1437 : 0 : struct ext2_inode_info *ei = EXT2_I(inode);
1438 : 0 : struct super_block *sb = inode->i_sb;
1439 : 0 : ino_t ino = inode->i_ino;
1440 : : uid_t uid = i_uid_read(inode);
1441 : : gid_t gid = i_gid_read(inode);
1442 : : struct buffer_head * bh;
1443 : 0 : struct ext2_inode * raw_inode = ext2_get_inode(sb, ino, &bh);
1444 : : int n;
1445 : : int err = 0;
1446 : :
1447 [ # # ]: 0 : if (IS_ERR(raw_inode))
1448 : : return -EIO;
1449 : :
1450 : : /* For fields not not tracking in the in-memory inode,
1451 : : * initialise them to zero for new inodes. */
1452 [ # # ]: 0 : if (ei->i_state & EXT2_STATE_NEW)
1453 [ # # ]: 0 : memset(raw_inode, 0, EXT2_SB(sb)->s_inode_size);
1454 : :
1455 : 0 : ext2_get_inode_flags(ei);
1456 : 0 : raw_inode->i_mode = cpu_to_le16(inode->i_mode);
1457 [ # # ]: 0 : if (!(test_opt(sb, NO_UID32))) {
1458 : 0 : raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
1459 : 0 : raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
1460 : : /*
1461 : : * Fix up interoperability with old kernels. Otherwise, old inodes get
1462 : : * re-used with the upper 16 bits of the uid/gid intact
1463 : : */
1464 [ # # ]: 0 : if (!ei->i_dtime) {
1465 : 0 : raw_inode->i_uid_high = cpu_to_le16(high_16_bits(uid));
1466 : 0 : raw_inode->i_gid_high = cpu_to_le16(high_16_bits(gid));
1467 : : } else {
1468 : 0 : raw_inode->i_uid_high = 0;
1469 : 0 : raw_inode->i_gid_high = 0;
1470 : : }
1471 : : } else {
1472 [ # # ]: 0 : raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(uid));
1473 [ # # ]: 0 : raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(gid));
1474 : 0 : raw_inode->i_uid_high = 0;
1475 : 0 : raw_inode->i_gid_high = 0;
1476 : : }
1477 : 0 : raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
1478 : 0 : raw_inode->i_size = cpu_to_le32(inode->i_size);
1479 : 0 : raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
1480 : 0 : raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
1481 : 0 : raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
1482 : :
1483 : 0 : raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
1484 : 0 : raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
1485 : 0 : raw_inode->i_flags = cpu_to_le32(ei->i_flags);
1486 : 0 : raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
1487 : 0 : raw_inode->i_frag = ei->i_frag_no;
1488 : 0 : raw_inode->i_fsize = ei->i_frag_size;
1489 : 0 : raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
1490 [ # # ]: 0 : if (!S_ISREG(inode->i_mode))
1491 : 0 : raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
1492 : : else {
1493 : 0 : raw_inode->i_size_high = cpu_to_le32(inode->i_size >> 32);
1494 [ # # ]: 0 : if (inode->i_size > 0x7fffffffULL) {
1495 [ # # ]: 0 : if (!EXT2_HAS_RO_COMPAT_FEATURE(sb,
1496 [ # # ]: 0 : EXT2_FEATURE_RO_COMPAT_LARGE_FILE) ||
1497 : 0 : EXT2_SB(sb)->s_es->s_rev_level ==
1498 : : cpu_to_le32(EXT2_GOOD_OLD_REV)) {
1499 : : /* If this is the first large file
1500 : : * created, add a flag to the superblock.
1501 : : */
1502 : : spin_lock(&EXT2_SB(sb)->s_lock);
1503 : 0 : ext2_update_dynamic_rev(sb);
1504 : 0 : EXT2_SET_RO_COMPAT_FEATURE(sb,
1505 : : EXT2_FEATURE_RO_COMPAT_LARGE_FILE);
1506 : : spin_unlock(&EXT2_SB(sb)->s_lock);
1507 : 0 : ext2_write_super(sb);
1508 : : }
1509 : : }
1510 : : }
1511 : :
1512 : 0 : raw_inode->i_generation = cpu_to_le32(inode->i_generation);
1513 [ # # ]: 0 : if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1514 [ # # ]: 0 : if (old_valid_dev(inode->i_rdev)) {
1515 : 0 : raw_inode->i_block[0] =
1516 : 0 : cpu_to_le32(old_encode_dev(inode->i_rdev));
1517 : 0 : raw_inode->i_block[1] = 0;
1518 : : } else {
1519 : 0 : raw_inode->i_block[0] = 0;
1520 : 0 : raw_inode->i_block[1] =
1521 : 0 : cpu_to_le32(new_encode_dev(inode->i_rdev));
1522 : 0 : raw_inode->i_block[2] = 0;
1523 : : }
1524 [ # # ]: 0 : } else for (n = 0; n < EXT2_N_BLOCKS; n++)
1525 : 0 : raw_inode->i_block[n] = ei->i_data[n];
1526 : 0 : mark_buffer_dirty(bh);
1527 [ # # ]: 0 : if (do_sync) {
1528 : 0 : sync_dirty_buffer(bh);
1529 [ # # ][ # # ]: 0 : if (buffer_req(bh) && !buffer_uptodate(bh)) {
1530 : 0 : printk ("IO error syncing ext2 inode [%s:%08lx]\n",
1531 : 0 : sb->s_id, (unsigned long) ino);
1532 : : err = -EIO;
1533 : : }
1534 : : }
1535 : 0 : ei->i_state &= ~EXT2_STATE_NEW;
1536 : 0 : brelse (bh);
1537 : 0 : return err;
1538 : : }
1539 : :
1540 : 0 : int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
1541 : : {
1542 : 0 : return __ext2_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1543 : : }
1544 : :
1545 : 0 : int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
1546 : : {
1547 : 0 : struct inode *inode = dentry->d_inode;
1548 : : int error;
1549 : :
1550 : 0 : error = inode_change_ok(inode, iattr);
1551 [ # # ]: 0 : if (error)
1552 : : return error;
1553 : :
1554 [ # # ]: 0 : if (is_quota_modification(inode, iattr))
1555 : 0 : dquot_initialize(inode);
1556 [ # # ][ # # ]: 0 : if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) ||
[ # # ]
1557 [ # # ]: 0 : (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) {
1558 : 0 : error = dquot_transfer(inode, iattr);
1559 [ # # ]: 0 : if (error)
1560 : : return error;
1561 : : }
1562 [ # # ][ # # ]: 0 : if (iattr->ia_valid & ATTR_SIZE && iattr->ia_size != inode->i_size) {
1563 : 0 : error = ext2_setsize(inode, iattr->ia_size);
1564 [ # # ]: 0 : if (error)
1565 : : return error;
1566 : : }
1567 : 0 : setattr_copy(inode, iattr);
1568 [ # # ]: 0 : if (iattr->ia_valid & ATTR_MODE)
1569 : : error = ext2_acl_chmod(inode);
1570 : : mark_inode_dirty(inode);
1571 : :
1572 : 0 : return error;
1573 : : }
|
