1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/time.h>
27#include <linux/highuid.h>
28#include <linux/pagemap.h>
29#include <linux/dax.h>
30#include <linux/blkdev.h>
31#include <linux/quotaops.h>
32#include <linux/writeback.h>
33#include <linux/buffer_head.h>
34#include <linux/mpage.h>
35#include <linux/fiemap.h>
36#include <linux/iomap.h>
37#include <linux/namei.h>
38#include <linux/uio.h>
39#include "ext2.h"
40#include "acl.h"
41#include "xattr.h"
42
43static int __ext2_write_inode(struct inode *inode, int do_sync);
44
45
46
47
48static inline int ext2_inode_is_fast_symlink(struct inode *inode)
49{
50 int ea_blocks = EXT2_I(inode)->i_file_acl ?
51 (inode->i_sb->s_blocksize >> 9) : 0;
52
53 return (S_ISLNK(inode->i_mode) &&
54 inode->i_blocks - ea_blocks == 0);
55}
56
57static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
58
59static void ext2_write_failed(struct address_space *mapping, loff_t to)
60{
61 struct inode *inode = mapping->host;
62
63 if (to > inode->i_size) {
64 truncate_pagecache(inode, inode->i_size);
65 ext2_truncate_blocks(inode, inode->i_size);
66 }
67}
68
69
70
71
72void ext2_evict_inode(struct inode * inode)
73{
74 struct ext2_block_alloc_info *rsv;
75 int want_delete = 0;
76
77 if (!inode->i_nlink && !is_bad_inode(inode)) {
78 want_delete = 1;
79 dquot_initialize(inode);
80 } else {
81 dquot_drop(inode);
82 }
83
84 truncate_inode_pages_final(&inode->i_data);
85
86 if (want_delete) {
87 sb_start_intwrite(inode->i_sb);
88
89 EXT2_I(inode)->i_dtime = ktime_get_real_seconds();
90 mark_inode_dirty(inode);
91 __ext2_write_inode(inode, inode_needs_sync(inode));
92
93 inode->i_size = 0;
94 if (inode->i_blocks)
95 ext2_truncate_blocks(inode, 0);
96 ext2_xattr_delete_inode(inode);
97 }
98
99 invalidate_inode_buffers(inode);
100 clear_inode(inode);
101
102 ext2_discard_reservation(inode);
103 rsv = EXT2_I(inode)->i_block_alloc_info;
104 EXT2_I(inode)->i_block_alloc_info = NULL;
105 if (unlikely(rsv))
106 kfree(rsv);
107
108 if (want_delete) {
109 ext2_free_inode(inode);
110 sb_end_intwrite(inode->i_sb);
111 }
112}
113
114typedef struct {
115 __le32 *p;
116 __le32 key;
117 struct buffer_head *bh;
118} Indirect;
119
120static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
121{
122 p->key = *(p->p = v);
123 p->bh = bh;
124}
125
126static inline int verify_chain(Indirect *from, Indirect *to)
127{
128 while (from <= to && from->key == *from->p)
129 from++;
130 return (from > to);
131}
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163static int ext2_block_to_path(struct inode *inode,
164 long i_block, int offsets[4], int *boundary)
165{
166 int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
167 int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
168 const long direct_blocks = EXT2_NDIR_BLOCKS,
169 indirect_blocks = ptrs,
170 double_blocks = (1 << (ptrs_bits * 2));
171 int n = 0;
172 int final = 0;
173
174 if (i_block < 0) {
175 ext2_msg(inode->i_sb, KERN_WARNING,
176 "warning: %s: block < 0", __func__);
177 } else if (i_block < direct_blocks) {
178 offsets[n++] = i_block;
179 final = direct_blocks;
180 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
181 offsets[n++] = EXT2_IND_BLOCK;
182 offsets[n++] = i_block;
183 final = ptrs;
184 } else if ((i_block -= indirect_blocks) < double_blocks) {
185 offsets[n++] = EXT2_DIND_BLOCK;
186 offsets[n++] = i_block >> ptrs_bits;
187 offsets[n++] = i_block & (ptrs - 1);
188 final = ptrs;
189 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
190 offsets[n++] = EXT2_TIND_BLOCK;
191 offsets[n++] = i_block >> (ptrs_bits * 2);
192 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
193 offsets[n++] = i_block & (ptrs - 1);
194 final = ptrs;
195 } else {
196 ext2_msg(inode->i_sb, KERN_WARNING,
197 "warning: %s: block is too big", __func__);
198 }
199 if (boundary)
200 *boundary = final - 1 - (i_block & (ptrs - 1));
201
202 return n;
203}
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234static Indirect *ext2_get_branch(struct inode *inode,
235 int depth,
236 int *offsets,
237 Indirect chain[4],
238 int *err)
239{
240 struct super_block *sb = inode->i_sb;
241 Indirect *p = chain;
242 struct buffer_head *bh;
243
244 *err = 0;
245
246 add_chain (chain, NULL, EXT2_I(inode)->i_data + *offsets);
247 if (!p->key)
248 goto no_block;
249 while (--depth) {
250 bh = sb_bread(sb, le32_to_cpu(p->key));
251 if (!bh)
252 goto failure;
253 read_lock(&EXT2_I(inode)->i_meta_lock);
254 if (!verify_chain(chain, p))
255 goto changed;
256 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
257 read_unlock(&EXT2_I(inode)->i_meta_lock);
258 if (!p->key)
259 goto no_block;
260 }
261 return NULL;
262
263changed:
264 read_unlock(&EXT2_I(inode)->i_meta_lock);
265 brelse(bh);
266 *err = -EAGAIN;
267 goto no_block;
268failure:
269 *err = -EIO;
270no_block:
271 return p;
272}
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
295{
296 struct ext2_inode_info *ei = EXT2_I(inode);
297 __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
298 __le32 *p;
299 ext2_fsblk_t bg_start;
300 ext2_fsblk_t colour;
301
302
303 for (p = ind->p - 1; p >= start; p--)
304 if (*p)
305 return le32_to_cpu(*p);
306
307
308 if (ind->bh)
309 return ind->bh->b_blocknr;
310
311
312
313
314
315 bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group);
316 colour = (current->pid % 16) *
317 (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
318 return bg_start + colour;
319}
320
321
322
323
324
325
326
327
328
329
330static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
331 Indirect *partial)
332{
333 struct ext2_block_alloc_info *block_i;
334
335 block_i = EXT2_I(inode)->i_block_alloc_info;
336
337
338
339
340
341 if (block_i && (block == block_i->last_alloc_logical_block + 1)
342 && (block_i->last_alloc_physical_block != 0)) {
343 return block_i->last_alloc_physical_block + 1;
344 }
345
346 return ext2_find_near(inode, partial);
347}
348
349
350
351
352
353
354
355
356
357
358
359
360
361static int
362ext2_blks_to_allocate(Indirect * branch, int k, unsigned long blks,
363 int blocks_to_boundary)
364{
365 unsigned long count = 0;
366
367
368
369
370
371 if (k > 0) {
372
373 if (blks < blocks_to_boundary + 1)
374 count += blks;
375 else
376 count += blocks_to_boundary + 1;
377 return count;
378 }
379
380 count++;
381 while (count < blks && count <= blocks_to_boundary
382 && le32_to_cpu(*(branch[0].p + count)) == 0) {
383 count++;
384 }
385 return count;
386}
387
388
389
390
391
392
393
394
395
396
397
398static int ext2_alloc_blocks(struct inode *inode,
399 ext2_fsblk_t goal, int indirect_blks, int blks,
400 ext2_fsblk_t new_blocks[4], int *err)
401{
402 int target, i;
403 unsigned long count = 0;
404 int index = 0;
405 ext2_fsblk_t current_block = 0;
406 int ret = 0;
407
408
409
410
411
412
413
414
415
416 target = blks + indirect_blks;
417
418 while (1) {
419 count = target;
420
421 current_block = ext2_new_blocks(inode,goal,&count,err);
422 if (*err)
423 goto failed_out;
424
425 target -= count;
426
427 while (index < indirect_blks && count) {
428 new_blocks[index++] = current_block++;
429 count--;
430 }
431
432 if (count > 0)
433 break;
434 }
435
436
437 new_blocks[index] = current_block;
438
439
440 ret = count;
441 *err = 0;
442 return ret;
443failed_out:
444 for (i = 0; i <index; i++)
445 ext2_free_blocks(inode, new_blocks[i], 1);
446 if (index)
447 mark_inode_dirty(inode);
448 return ret;
449}
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478static int ext2_alloc_branch(struct inode *inode,
479 int indirect_blks, int *blks, ext2_fsblk_t goal,
480 int *offsets, Indirect *branch)
481{
482 int blocksize = inode->i_sb->s_blocksize;
483 int i, n = 0;
484 int err = 0;
485 struct buffer_head *bh;
486 int num;
487 ext2_fsblk_t new_blocks[4];
488 ext2_fsblk_t current_block;
489
490 num = ext2_alloc_blocks(inode, goal, indirect_blks,
491 *blks, new_blocks, &err);
492 if (err)
493 return err;
494
495 branch[0].key = cpu_to_le32(new_blocks[0]);
496
497
498
499 for (n = 1; n <= indirect_blks; n++) {
500
501
502
503
504
505 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
506 if (unlikely(!bh)) {
507 err = -ENOMEM;
508 goto failed;
509 }
510 branch[n].bh = bh;
511 lock_buffer(bh);
512 memset(bh->b_data, 0, blocksize);
513 branch[n].p = (__le32 *) bh->b_data + offsets[n];
514 branch[n].key = cpu_to_le32(new_blocks[n]);
515 *branch[n].p = branch[n].key;
516 if ( n == indirect_blks) {
517 current_block = new_blocks[n];
518
519
520
521
522
523 for (i=1; i < num; i++)
524 *(branch[n].p + i) = cpu_to_le32(++current_block);
525 }
526 set_buffer_uptodate(bh);
527 unlock_buffer(bh);
528 mark_buffer_dirty_inode(bh, inode);
529
530
531
532
533 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
534 sync_dirty_buffer(bh);
535 }
536 *blks = num;
537 return err;
538
539failed:
540 for (i = 1; i < n; i++)
541 bforget(branch[i].bh);
542 for (i = 0; i < indirect_blks; i++)
543 ext2_free_blocks(inode, new_blocks[i], 1);
544 ext2_free_blocks(inode, new_blocks[i], num);
545 return err;
546}
547
548
549
550
551
552
553
554
555
556
557
558
559
560static void ext2_splice_branch(struct inode *inode,
561 long block, Indirect *where, int num, int blks)
562{
563 int i;
564 struct ext2_block_alloc_info *block_i;
565 ext2_fsblk_t current_block;
566
567 block_i = EXT2_I(inode)->i_block_alloc_info;
568
569
570
571
572 *where->p = where->key;
573
574
575
576
577
578 if (num == 0 && blks > 1) {
579 current_block = le32_to_cpu(where->key) + 1;
580 for (i = 1; i < blks; i++)
581 *(where->p + i ) = cpu_to_le32(current_block++);
582 }
583
584
585
586
587
588
589 if (block_i) {
590 block_i->last_alloc_logical_block = block + blks - 1;
591 block_i->last_alloc_physical_block =
592 le32_to_cpu(where[num].key) + blks - 1;
593 }
594
595
596
597
598 if (where->bh)
599 mark_buffer_dirty_inode(where->bh, inode);
600
601 inode->i_ctime = current_time(inode);
602 mark_inode_dirty(inode);
603}
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623static int ext2_get_blocks(struct inode *inode,
624 sector_t iblock, unsigned long maxblocks,
625 u32 *bno, bool *new, bool *boundary,
626 int create)
627{
628 int err;
629 int offsets[4];
630 Indirect chain[4];
631 Indirect *partial;
632 ext2_fsblk_t goal;
633 int indirect_blks;
634 int blocks_to_boundary = 0;
635 int depth;
636 struct ext2_inode_info *ei = EXT2_I(inode);
637 int count = 0;
638 ext2_fsblk_t first_block = 0;
639
640 BUG_ON(maxblocks == 0);
641
642 depth = ext2_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
643
644 if (depth == 0)
645 return -EIO;
646
647 partial = ext2_get_branch(inode, depth, offsets, chain, &err);
648
649 if (!partial) {
650 first_block = le32_to_cpu(chain[depth - 1].key);
651 count++;
652
653 while (count < maxblocks && count <= blocks_to_boundary) {
654 ext2_fsblk_t blk;
655
656 if (!verify_chain(chain, chain + depth - 1)) {
657
658
659
660
661
662
663 err = -EAGAIN;
664 count = 0;
665 partial = chain + depth - 1;
666 break;
667 }
668 blk = le32_to_cpu(*(chain[depth-1].p + count));
669 if (blk == first_block + count)
670 count++;
671 else
672 break;
673 }
674 if (err != -EAGAIN)
675 goto got_it;
676 }
677
678
679 if (!create || err == -EIO)
680 goto cleanup;
681
682 mutex_lock(&ei->truncate_mutex);
683
684
685
686
687
688
689
690
691
692
693
694
695 if (err == -EAGAIN || !verify_chain(chain, partial)) {
696 while (partial > chain) {
697 brelse(partial->bh);
698 partial--;
699 }
700 partial = ext2_get_branch(inode, depth, offsets, chain, &err);
701 if (!partial) {
702 count++;
703 mutex_unlock(&ei->truncate_mutex);
704 if (err)
705 goto cleanup;
706 goto got_it;
707 }
708 }
709
710
711
712
713
714 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
715 ext2_init_block_alloc_info(inode);
716
717 goal = ext2_find_goal(inode, iblock, partial);
718
719
720 indirect_blks = (chain + depth) - partial - 1;
721
722
723
724
725 count = ext2_blks_to_allocate(partial, indirect_blks,
726 maxblocks, blocks_to_boundary);
727
728
729
730 err = ext2_alloc_branch(inode, indirect_blks, &count, goal,
731 offsets + (partial - chain), partial);
732
733 if (err) {
734 mutex_unlock(&ei->truncate_mutex);
735 goto cleanup;
736 }
737
738 if (IS_DAX(inode)) {
739
740
741
742
743 clean_bdev_aliases(inode->i_sb->s_bdev,
744 le32_to_cpu(chain[depth-1].key),
745 count);
746
747
748
749
750
751 err = sb_issue_zeroout(inode->i_sb,
752 le32_to_cpu(chain[depth-1].key), count,
753 GFP_NOFS);
754 if (err) {
755 mutex_unlock(&ei->truncate_mutex);
756 goto cleanup;
757 }
758 }
759 *new = true;
760
761 ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
762 mutex_unlock(&ei->truncate_mutex);
763got_it:
764 if (count > blocks_to_boundary)
765 *boundary = true;
766 err = count;
767
768 partial = chain + depth - 1;
769cleanup:
770 while (partial > chain) {
771 brelse(partial->bh);
772 partial--;
773 }
774 if (err > 0)
775 *bno = le32_to_cpu(chain[depth-1].key);
776 return err;
777}
778
779int ext2_get_block(struct inode *inode, sector_t iblock,
780 struct buffer_head *bh_result, int create)
781{
782 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
783 bool new = false, boundary = false;
784 u32 bno;
785 int ret;
786
787 ret = ext2_get_blocks(inode, iblock, max_blocks, &bno, &new, &boundary,
788 create);
789 if (ret <= 0)
790 return ret;
791
792 map_bh(bh_result, inode->i_sb, bno);
793 bh_result->b_size = (ret << inode->i_blkbits);
794 if (new)
795 set_buffer_new(bh_result);
796 if (boundary)
797 set_buffer_boundary(bh_result);
798 return 0;
799
800}
801
802#ifdef CONFIG_FS_DAX
803static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
804 unsigned flags, struct iomap *iomap)
805{
806 unsigned int blkbits = inode->i_blkbits;
807 unsigned long first_block = offset >> blkbits;
808 unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
809 struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
810 bool new = false, boundary = false;
811 u32 bno;
812 int ret;
813
814 ret = ext2_get_blocks(inode, first_block, max_blocks,
815 &bno, &new, &boundary, flags & IOMAP_WRITE);
816 if (ret < 0)
817 return ret;
818
819 iomap->flags = 0;
820 iomap->bdev = inode->i_sb->s_bdev;
821 iomap->offset = (u64)first_block << blkbits;
822 iomap->dax_dev = sbi->s_daxdev;
823
824 if (ret == 0) {
825 iomap->type = IOMAP_HOLE;
826 iomap->addr = IOMAP_NULL_ADDR;
827 iomap->length = 1 << blkbits;
828 } else {
829 iomap->type = IOMAP_MAPPED;
830 iomap->addr = (u64)bno << blkbits;
831 iomap->length = (u64)ret << blkbits;
832 iomap->flags |= IOMAP_F_MERGED;
833 }
834
835 if (new)
836 iomap->flags |= IOMAP_F_NEW;
837 return 0;
838}
839
840static int
841ext2_iomap_end(struct inode *inode, loff_t offset, loff_t length,
842 ssize_t written, unsigned flags, struct iomap *iomap)
843{
844 if (iomap->type == IOMAP_MAPPED &&
845 written < length &&
846 (flags & IOMAP_WRITE))
847 ext2_write_failed(inode->i_mapping, offset + length);
848 return 0;
849}
850
851const struct iomap_ops ext2_iomap_ops = {
852 .iomap_begin = ext2_iomap_begin,
853 .iomap_end = ext2_iomap_end,
854};
855#else
856
857const struct iomap_ops ext2_iomap_ops;
858#endif
859
860int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
861 u64 start, u64 len)
862{
863 return generic_block_fiemap(inode, fieinfo, start, len,
864 ext2_get_block);
865}
866
867static int ext2_writepage(struct page *page, struct writeback_control *wbc)
868{
869 return block_write_full_page(page, ext2_get_block, wbc);
870}
871
872static int ext2_readpage(struct file *file, struct page *page)
873{
874 return mpage_readpage(page, ext2_get_block);
875}
876
877static int
878ext2_readpages(struct file *file, struct address_space *mapping,
879 struct list_head *pages, unsigned nr_pages)
880{
881 return mpage_readpages(mapping, pages, nr_pages, ext2_get_block);
882}
883
884static int
885ext2_write_begin(struct file *file, struct address_space *mapping,
886 loff_t pos, unsigned len, unsigned flags,
887 struct page **pagep, void **fsdata)
888{
889 int ret;
890
891 ret = block_write_begin(mapping, pos, len, flags, pagep,
892 ext2_get_block);
893 if (ret < 0)
894 ext2_write_failed(mapping, pos + len);
895 return ret;
896}
897
898static int ext2_write_end(struct file *file, struct address_space *mapping,
899 loff_t pos, unsigned len, unsigned copied,
900 struct page *page, void *fsdata)
901{
902 int ret;
903
904 ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
905 if (ret < len)
906 ext2_write_failed(mapping, pos + len);
907 return ret;
908}
909
910static int
911ext2_nobh_write_begin(struct file *file, struct address_space *mapping,
912 loff_t pos, unsigned len, unsigned flags,
913 struct page **pagep, void **fsdata)
914{
915 int ret;
916
917 ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
918 ext2_get_block);
919 if (ret < 0)
920 ext2_write_failed(mapping, pos + len);
921 return ret;
922}
923
924static int ext2_nobh_writepage(struct page *page,
925 struct writeback_control *wbc)
926{
927 return nobh_writepage(page, ext2_get_block, wbc);
928}
929
930static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
931{
932 return generic_block_bmap(mapping,block,ext2_get_block);
933}
934
935static ssize_t
936ext2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
937{
938 struct file *file = iocb->ki_filp;
939 struct address_space *mapping = file->f_mapping;
940 struct inode *inode = mapping->host;
941 size_t count = iov_iter_count(iter);
942 loff_t offset = iocb->ki_pos;
943 ssize_t ret;
944
945 ret = blockdev_direct_IO(iocb, inode, iter, ext2_get_block);
946 if (ret < 0 && iov_iter_rw(iter) == WRITE)
947 ext2_write_failed(mapping, offset + count);
948 return ret;
949}
950
951static int
952ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
953{
954 return mpage_writepages(mapping, wbc, ext2_get_block);
955}
956
957static int
958ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc)
959{
960 return dax_writeback_mapping_range(mapping,
961 mapping->host->i_sb->s_bdev, wbc);
962}
963
964const struct address_space_operations ext2_aops = {
965 .readpage = ext2_readpage,
966 .readpages = ext2_readpages,
967 .writepage = ext2_writepage,
968 .write_begin = ext2_write_begin,
969 .write_end = ext2_write_end,
970 .bmap = ext2_bmap,
971 .direct_IO = ext2_direct_IO,
972 .writepages = ext2_writepages,
973 .migratepage = buffer_migrate_page,
974 .is_partially_uptodate = block_is_partially_uptodate,
975 .error_remove_page = generic_error_remove_page,
976};
977
978const struct address_space_operations ext2_nobh_aops = {
979 .readpage = ext2_readpage,
980 .readpages = ext2_readpages,
981 .writepage = ext2_nobh_writepage,
982 .write_begin = ext2_nobh_write_begin,
983 .write_end = nobh_write_end,
984 .bmap = ext2_bmap,
985 .direct_IO = ext2_direct_IO,
986 .writepages = ext2_writepages,
987 .migratepage = buffer_migrate_page,
988 .error_remove_page = generic_error_remove_page,
989};
990
991static const struct address_space_operations ext2_dax_aops = {
992 .writepages = ext2_dax_writepages,
993 .direct_IO = noop_direct_IO,
994 .set_page_dirty = noop_set_page_dirty,
995 .invalidatepage = noop_invalidatepage,
996};
997
998
999
1000
1001
1002
1003static inline int all_zeroes(__le32 *p, __le32 *q)
1004{
1005 while (p < q)
1006 if (*p++)
1007 return 0;
1008 return 1;
1009}
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045static Indirect *ext2_find_shared(struct inode *inode,
1046 int depth,
1047 int offsets[4],
1048 Indirect chain[4],
1049 __le32 *top)
1050{
1051 Indirect *partial, *p;
1052 int k, err;
1053
1054 *top = 0;
1055 for (k = depth; k > 1 && !offsets[k-1]; k--)
1056 ;
1057 partial = ext2_get_branch(inode, k, offsets, chain, &err);
1058 if (!partial)
1059 partial = chain + k-1;
1060
1061
1062
1063
1064 write_lock(&EXT2_I(inode)->i_meta_lock);
1065 if (!partial->key && *partial->p) {
1066 write_unlock(&EXT2_I(inode)->i_meta_lock);
1067 goto no_top;
1068 }
1069 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1070 ;
1071
1072
1073
1074
1075
1076
1077 if (p == chain + k - 1 && p > chain) {
1078 p->p--;
1079 } else {
1080 *top = *p->p;
1081 *p->p = 0;
1082 }
1083 write_unlock(&EXT2_I(inode)->i_meta_lock);
1084
1085 while(partial > p)
1086 {
1087 brelse(partial->bh);
1088 partial--;
1089 }
1090no_top:
1091 return partial;
1092}
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
1105{
1106 unsigned long block_to_free = 0, count = 0;
1107 unsigned long nr;
1108
1109 for ( ; p < q ; p++) {
1110 nr = le32_to_cpu(*p);
1111 if (nr) {
1112 *p = 0;
1113
1114 if (count == 0)
1115 goto free_this;
1116 else if (block_to_free == nr - count)
1117 count++;
1118 else {
1119 ext2_free_blocks (inode, block_to_free, count);
1120 mark_inode_dirty(inode);
1121 free_this:
1122 block_to_free = nr;
1123 count = 1;
1124 }
1125 }
1126 }
1127 if (count > 0) {
1128 ext2_free_blocks (inode, block_to_free, count);
1129 mark_inode_dirty(inode);
1130 }
1131}
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144static void ext2_free_branches(struct inode *inode, __le32 *p, __le32 *q, int depth)
1145{
1146 struct buffer_head * bh;
1147 unsigned long nr;
1148
1149 if (depth--) {
1150 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1151 for ( ; p < q ; p++) {
1152 nr = le32_to_cpu(*p);
1153 if (!nr)
1154 continue;
1155 *p = 0;
1156 bh = sb_bread(inode->i_sb, nr);
1157
1158
1159
1160
1161 if (!bh) {
1162 ext2_error(inode->i_sb, "ext2_free_branches",
1163 "Read failure, inode=%ld, block=%ld",
1164 inode->i_ino, nr);
1165 continue;
1166 }
1167 ext2_free_branches(inode,
1168 (__le32*)bh->b_data,
1169 (__le32*)bh->b_data + addr_per_block,
1170 depth);
1171 bforget(bh);
1172 ext2_free_blocks(inode, nr, 1);
1173 mark_inode_dirty(inode);
1174 }
1175 } else
1176 ext2_free_data(inode, p, q);
1177}
1178
1179
1180static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
1181{
1182 __le32 *i_data = EXT2_I(inode)->i_data;
1183 struct ext2_inode_info *ei = EXT2_I(inode);
1184 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1185 int offsets[4];
1186 Indirect chain[4];
1187 Indirect *partial;
1188 __le32 nr = 0;
1189 int n;
1190 long iblock;
1191 unsigned blocksize;
1192 blocksize = inode->i_sb->s_blocksize;
1193 iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
1194
1195#ifdef CONFIG_FS_DAX
1196 WARN_ON(!rwsem_is_locked(&ei->dax_sem));
1197#endif
1198
1199 n = ext2_block_to_path(inode, iblock, offsets, NULL);
1200 if (n == 0)
1201 return;
1202
1203
1204
1205
1206
1207 mutex_lock(&ei->truncate_mutex);
1208
1209 if (n == 1) {
1210 ext2_free_data(inode, i_data+offsets[0],
1211 i_data + EXT2_NDIR_BLOCKS);
1212 goto do_indirects;
1213 }
1214
1215 partial = ext2_find_shared(inode, n, offsets, chain, &nr);
1216
1217 if (nr) {
1218 if (partial == chain)
1219 mark_inode_dirty(inode);
1220 else
1221 mark_buffer_dirty_inode(partial->bh, inode);
1222 ext2_free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);
1223 }
1224
1225 while (partial > chain) {
1226 ext2_free_branches(inode,
1227 partial->p + 1,
1228 (__le32*)partial->bh->b_data+addr_per_block,
1229 (chain+n-1) - partial);
1230 mark_buffer_dirty_inode(partial->bh, inode);
1231 brelse (partial->bh);
1232 partial--;
1233 }
1234do_indirects:
1235
1236 switch (offsets[0]) {
1237 default:
1238 nr = i_data[EXT2_IND_BLOCK];
1239 if (nr) {
1240 i_data[EXT2_IND_BLOCK] = 0;
1241 mark_inode_dirty(inode);
1242 ext2_free_branches(inode, &nr, &nr+1, 1);
1243 }
1244
1245 case EXT2_IND_BLOCK:
1246 nr = i_data[EXT2_DIND_BLOCK];
1247 if (nr) {
1248 i_data[EXT2_DIND_BLOCK] = 0;
1249 mark_inode_dirty(inode);
1250 ext2_free_branches(inode, &nr, &nr+1, 2);
1251 }
1252
1253 case EXT2_DIND_BLOCK:
1254 nr = i_data[EXT2_TIND_BLOCK];
1255 if (nr) {
1256 i_data[EXT2_TIND_BLOCK] = 0;
1257 mark_inode_dirty(inode);
1258 ext2_free_branches(inode, &nr, &nr+1, 3);
1259 }
1260 case EXT2_TIND_BLOCK:
1261 ;
1262 }
1263
1264 ext2_discard_reservation(inode);
1265
1266 mutex_unlock(&ei->truncate_mutex);
1267}
1268
1269static void ext2_truncate_blocks(struct inode *inode, loff_t offset)
1270{
1271 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1272 S_ISLNK(inode->i_mode)))
1273 return;
1274 if (ext2_inode_is_fast_symlink(inode))
1275 return;
1276
1277 dax_sem_down_write(EXT2_I(inode));
1278 __ext2_truncate_blocks(inode, offset);
1279 dax_sem_up_write(EXT2_I(inode));
1280}
1281
1282static int ext2_setsize(struct inode *inode, loff_t newsize)
1283{
1284 int error;
1285
1286 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1287 S_ISLNK(inode->i_mode)))
1288 return -EINVAL;
1289 if (ext2_inode_is_fast_symlink(inode))
1290 return -EINVAL;
1291 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1292 return -EPERM;
1293
1294 inode_dio_wait(inode);
1295
1296 if (IS_DAX(inode)) {
1297 error = iomap_zero_range(inode, newsize,
1298 PAGE_ALIGN(newsize) - newsize, NULL,
1299 &ext2_iomap_ops);
1300 } else if (test_opt(inode->i_sb, NOBH))
1301 error = nobh_truncate_page(inode->i_mapping,
1302 newsize, ext2_get_block);
1303 else
1304 error = block_truncate_page(inode->i_mapping,
1305 newsize, ext2_get_block);
1306 if (error)
1307 return error;
1308
1309 dax_sem_down_write(EXT2_I(inode));
1310 truncate_setsize(inode, newsize);
1311 __ext2_truncate_blocks(inode, newsize);
1312 dax_sem_up_write(EXT2_I(inode));
1313
1314 inode->i_mtime = inode->i_ctime = current_time(inode);
1315 if (inode_needs_sync(inode)) {
1316 sync_mapping_buffers(inode->i_mapping);
1317 sync_inode_metadata(inode, 1);
1318 } else {
1319 mark_inode_dirty(inode);
1320 }
1321
1322 return 0;
1323}
1324
1325static struct ext2_inode *ext2_get_inode(struct super_block *sb, ino_t ino,
1326 struct buffer_head **p)
1327{
1328 struct buffer_head * bh;
1329 unsigned long block_group;
1330 unsigned long block;
1331 unsigned long offset;
1332 struct ext2_group_desc * gdp;
1333
1334 *p = NULL;
1335 if ((ino != EXT2_ROOT_INO && ino < EXT2_FIRST_INO(sb)) ||
1336 ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
1337 goto Einval;
1338
1339 block_group = (ino - 1) / EXT2_INODES_PER_GROUP(sb);
1340 gdp = ext2_get_group_desc(sb, block_group, NULL);
1341 if (!gdp)
1342 goto Egdp;
1343
1344
1345
1346 offset = ((ino - 1) % EXT2_INODES_PER_GROUP(sb)) * EXT2_INODE_SIZE(sb);
1347 block = le32_to_cpu(gdp->bg_inode_table) +
1348 (offset >> EXT2_BLOCK_SIZE_BITS(sb));
1349 if (!(bh = sb_bread(sb, block)))
1350 goto Eio;
1351
1352 *p = bh;
1353 offset &= (EXT2_BLOCK_SIZE(sb) - 1);
1354 return (struct ext2_inode *) (bh->b_data + offset);
1355
1356Einval:
1357 ext2_error(sb, "ext2_get_inode", "bad inode number: %lu",
1358 (unsigned long) ino);
1359 return ERR_PTR(-EINVAL);
1360Eio:
1361 ext2_error(sb, "ext2_get_inode",
1362 "unable to read inode block - inode=%lu, block=%lu",
1363 (unsigned long) ino, block);
1364Egdp:
1365 return ERR_PTR(-EIO);
1366}
1367
1368void ext2_set_inode_flags(struct inode *inode)
1369{
1370 unsigned int flags = EXT2_I(inode)->i_flags;
1371
1372 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME |
1373 S_DIRSYNC | S_DAX);
1374 if (flags & EXT2_SYNC_FL)
1375 inode->i_flags |= S_SYNC;
1376 if (flags & EXT2_APPEND_FL)
1377 inode->i_flags |= S_APPEND;
1378 if (flags & EXT2_IMMUTABLE_FL)
1379 inode->i_flags |= S_IMMUTABLE;
1380 if (flags & EXT2_NOATIME_FL)
1381 inode->i_flags |= S_NOATIME;
1382 if (flags & EXT2_DIRSYNC_FL)
1383 inode->i_flags |= S_DIRSYNC;
1384 if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode))
1385 inode->i_flags |= S_DAX;
1386}
1387
1388void ext2_set_file_ops(struct inode *inode)
1389{
1390 inode->i_op = &ext2_file_inode_operations;
1391 inode->i_fop = &ext2_file_operations;
1392 if (IS_DAX(inode))
1393 inode->i_mapping->a_ops = &ext2_dax_aops;
1394 else if (test_opt(inode->i_sb, NOBH))
1395 inode->i_mapping->a_ops = &ext2_nobh_aops;
1396 else
1397 inode->i_mapping->a_ops = &ext2_aops;
1398}
1399
1400struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
1401{
1402 struct ext2_inode_info *ei;
1403 struct buffer_head * bh = NULL;
1404 struct ext2_inode *raw_inode;
1405 struct inode *inode;
1406 long ret = -EIO;
1407 int n;
1408 uid_t i_uid;
1409 gid_t i_gid;
1410
1411 inode = iget_locked(sb, ino);
1412 if (!inode)
1413 return ERR_PTR(-ENOMEM);
1414 if (!(inode->i_state & I_NEW))
1415 return inode;
1416
1417 ei = EXT2_I(inode);
1418 ei->i_block_alloc_info = NULL;
1419
1420 raw_inode = ext2_get_inode(inode->i_sb, ino, &bh);
1421 if (IS_ERR(raw_inode)) {
1422 ret = PTR_ERR(raw_inode);
1423 goto bad_inode;
1424 }
1425
1426 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
1427 i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
1428 i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
1429 if (!(test_opt (inode->i_sb, NO_UID32))) {
1430 i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
1431 i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
1432 }
1433 i_uid_write(inode, i_uid);
1434 i_gid_write(inode, i_gid);
1435 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
1436 inode->i_size = le32_to_cpu(raw_inode->i_size);
1437 inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
1438 inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
1439 inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
1440 inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = 0;
1441 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
1442
1443
1444
1445
1446
1447 if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
1448
1449 ret = -ESTALE;
1450 goto bad_inode;
1451 }
1452 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
1453 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
1454 ext2_set_inode_flags(inode);
1455 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
1456 ei->i_frag_no = raw_inode->i_frag;
1457 ei->i_frag_size = raw_inode->i_fsize;
1458 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
1459 ei->i_dir_acl = 0;
1460
1461 if (ei->i_file_acl &&
1462 !ext2_data_block_valid(EXT2_SB(sb), ei->i_file_acl, 1)) {
1463 ext2_error(sb, "ext2_iget", "bad extended attribute block %u",
1464 ei->i_file_acl);
1465 ret = -EFSCORRUPTED;
1466 goto bad_inode;
1467 }
1468
1469 if (S_ISREG(inode->i_mode))
1470 inode->i_size |= ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
1471 else
1472 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
1473 if (i_size_read(inode) < 0) {
1474 ret = -EFSCORRUPTED;
1475 goto bad_inode;
1476 }
1477 ei->i_dtime = 0;
1478 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
1479 ei->i_state = 0;
1480 ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
1481 ei->i_dir_start_lookup = 0;
1482
1483
1484
1485
1486
1487 for (n = 0; n < EXT2_N_BLOCKS; n++)
1488 ei->i_data[n] = raw_inode->i_block[n];
1489
1490 if (S_ISREG(inode->i_mode)) {
1491 ext2_set_file_ops(inode);
1492 } else if (S_ISDIR(inode->i_mode)) {
1493 inode->i_op = &ext2_dir_inode_operations;
1494 inode->i_fop = &ext2_dir_operations;
1495 if (test_opt(inode->i_sb, NOBH))
1496 inode->i_mapping->a_ops = &ext2_nobh_aops;
1497 else
1498 inode->i_mapping->a_ops = &ext2_aops;
1499 } else if (S_ISLNK(inode->i_mode)) {
1500 if (ext2_inode_is_fast_symlink(inode)) {
1501 inode->i_link = (char *)ei->i_data;
1502 inode->i_op = &ext2_fast_symlink_inode_operations;
1503 nd_terminate_link(ei->i_data, inode->i_size,
1504 sizeof(ei->i_data) - 1);
1505 } else {
1506 inode->i_op = &ext2_symlink_inode_operations;
1507 inode_nohighmem(inode);
1508 if (test_opt(inode->i_sb, NOBH))
1509 inode->i_mapping->a_ops = &ext2_nobh_aops;
1510 else
1511 inode->i_mapping->a_ops = &ext2_aops;
1512 }
1513 } else {
1514 inode->i_op = &ext2_special_inode_operations;
1515 if (raw_inode->i_block[0])
1516 init_special_inode(inode, inode->i_mode,
1517 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
1518 else
1519 init_special_inode(inode, inode->i_mode,
1520 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
1521 }
1522 brelse (bh);
1523 unlock_new_inode(inode);
1524 return inode;
1525
1526bad_inode:
1527 brelse(bh);
1528 iget_failed(inode);
1529 return ERR_PTR(ret);
1530}
1531
1532static int __ext2_write_inode(struct inode *inode, int do_sync)
1533{
1534 struct ext2_inode_info *ei = EXT2_I(inode);
1535 struct super_block *sb = inode->i_sb;
1536 ino_t ino = inode->i_ino;
1537 uid_t uid = i_uid_read(inode);
1538 gid_t gid = i_gid_read(inode);
1539 struct buffer_head * bh;
1540 struct ext2_inode * raw_inode = ext2_get_inode(sb, ino, &bh);
1541 int n;
1542 int err = 0;
1543
1544 if (IS_ERR(raw_inode))
1545 return -EIO;
1546
1547
1548
1549 if (ei->i_state & EXT2_STATE_NEW)
1550 memset(raw_inode, 0, EXT2_SB(sb)->s_inode_size);
1551
1552 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
1553 if (!(test_opt(sb, NO_UID32))) {
1554 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
1555 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
1556
1557
1558
1559
1560 if (!ei->i_dtime) {
1561 raw_inode->i_uid_high = cpu_to_le16(high_16_bits(uid));
1562 raw_inode->i_gid_high = cpu_to_le16(high_16_bits(gid));
1563 } else {
1564 raw_inode->i_uid_high = 0;
1565 raw_inode->i_gid_high = 0;
1566 }
1567 } else {
1568 raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(uid));
1569 raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(gid));
1570 raw_inode->i_uid_high = 0;
1571 raw_inode->i_gid_high = 0;
1572 }
1573 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
1574 raw_inode->i_size = cpu_to_le32(inode->i_size);
1575 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
1576 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
1577 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
1578
1579 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
1580 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
1581 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
1582 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
1583 raw_inode->i_frag = ei->i_frag_no;
1584 raw_inode->i_fsize = ei->i_frag_size;
1585 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
1586 if (!S_ISREG(inode->i_mode))
1587 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
1588 else {
1589 raw_inode->i_size_high = cpu_to_le32(inode->i_size >> 32);
1590 if (inode->i_size > 0x7fffffffULL) {
1591 if (!EXT2_HAS_RO_COMPAT_FEATURE(sb,
1592 EXT2_FEATURE_RO_COMPAT_LARGE_FILE) ||
1593 EXT2_SB(sb)->s_es->s_rev_level ==
1594 cpu_to_le32(EXT2_GOOD_OLD_REV)) {
1595
1596
1597
1598 spin_lock(&EXT2_SB(sb)->s_lock);
1599 ext2_update_dynamic_rev(sb);
1600 EXT2_SET_RO_COMPAT_FEATURE(sb,
1601 EXT2_FEATURE_RO_COMPAT_LARGE_FILE);
1602 spin_unlock(&EXT2_SB(sb)->s_lock);
1603 ext2_sync_super(sb, EXT2_SB(sb)->s_es, 1);
1604 }
1605 }
1606 }
1607
1608 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
1609 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1610 if (old_valid_dev(inode->i_rdev)) {
1611 raw_inode->i_block[0] =
1612 cpu_to_le32(old_encode_dev(inode->i_rdev));
1613 raw_inode->i_block[1] = 0;
1614 } else {
1615 raw_inode->i_block[0] = 0;
1616 raw_inode->i_block[1] =
1617 cpu_to_le32(new_encode_dev(inode->i_rdev));
1618 raw_inode->i_block[2] = 0;
1619 }
1620 } else for (n = 0; n < EXT2_N_BLOCKS; n++)
1621 raw_inode->i_block[n] = ei->i_data[n];
1622 mark_buffer_dirty(bh);
1623 if (do_sync) {
1624 sync_dirty_buffer(bh);
1625 if (buffer_req(bh) && !buffer_uptodate(bh)) {
1626 printk ("IO error syncing ext2 inode [%s:%08lx]\n",
1627 sb->s_id, (unsigned long) ino);
1628 err = -EIO;
1629 }
1630 }
1631 ei->i_state &= ~EXT2_STATE_NEW;
1632 brelse (bh);
1633 return err;
1634}
1635
1636int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
1637{
1638 return __ext2_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1639}
1640
1641int ext2_getattr(const struct path *path, struct kstat *stat,
1642 u32 request_mask, unsigned int query_flags)
1643{
1644 struct inode *inode = d_inode(path->dentry);
1645 struct ext2_inode_info *ei = EXT2_I(inode);
1646 unsigned int flags;
1647
1648 flags = ei->i_flags & EXT2_FL_USER_VISIBLE;
1649 if (flags & EXT2_APPEND_FL)
1650 stat->attributes |= STATX_ATTR_APPEND;
1651 if (flags & EXT2_COMPR_FL)
1652 stat->attributes |= STATX_ATTR_COMPRESSED;
1653 if (flags & EXT2_IMMUTABLE_FL)
1654 stat->attributes |= STATX_ATTR_IMMUTABLE;
1655 if (flags & EXT2_NODUMP_FL)
1656 stat->attributes |= STATX_ATTR_NODUMP;
1657 stat->attributes_mask |= (STATX_ATTR_APPEND |
1658 STATX_ATTR_COMPRESSED |
1659 STATX_ATTR_ENCRYPTED |
1660 STATX_ATTR_IMMUTABLE |
1661 STATX_ATTR_NODUMP);
1662
1663 generic_fillattr(inode, stat);
1664 return 0;
1665}
1666
1667int ext2_setattr(struct dentry *dentry, struct iattr *iattr)
1668{
1669 struct inode *inode = d_inode(dentry);
1670 int error;
1671
1672 error = setattr_prepare(dentry, iattr);
1673 if (error)
1674 return error;
1675
1676 if (is_quota_modification(inode, iattr)) {
1677 error = dquot_initialize(inode);
1678 if (error)
1679 return error;
1680 }
1681 if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) ||
1682 (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) {
1683 error = dquot_transfer(inode, iattr);
1684 if (error)
1685 return error;
1686 }
1687 if (iattr->ia_valid & ATTR_SIZE && iattr->ia_size != inode->i_size) {
1688 error = ext2_setsize(inode, iattr->ia_size);
1689 if (error)
1690 return error;
1691 }
1692 setattr_copy(inode, iattr);
1693 if (iattr->ia_valid & ATTR_MODE)
1694 error = posix_acl_chmod(inode, inode->i_mode);
1695 mark_inode_dirty(inode);
1696
1697 return error;
1698}
1699