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 <linux/fiemap.h>
40#include "ext2.h"
41#include "acl.h"
42#include "xattr.h"
43
44static int __ext2_write_inode(struct inode *inode, int do_sync);
45
46
47
48
49static inline int ext2_inode_is_fast_symlink(struct inode *inode)
50{
51 int ea_blocks = EXT2_I(inode)->i_file_acl ?
52 (inode->i_sb->s_blocksize >> 9) : 0;
53
54 return (S_ISLNK(inode->i_mode) &&
55 inode->i_blocks - ea_blocks == 0);
56}
57
58static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
59
60static void ext2_write_failed(struct address_space *mapping, loff_t to)
61{
62 struct inode *inode = mapping->host;
63
64 if (to > inode->i_size) {
65 truncate_pagecache(inode, inode->i_size);
66 ext2_truncate_blocks(inode, inode->i_size);
67 }
68}
69
70
71
72
73void ext2_evict_inode(struct inode * inode)
74{
75 struct ext2_block_alloc_info *rsv;
76 int want_delete = 0;
77
78 if (!inode->i_nlink && !is_bad_inode(inode)) {
79 want_delete = 1;
80 dquot_initialize(inode);
81 } else {
82 dquot_drop(inode);
83 }
84
85 truncate_inode_pages_final(&inode->i_data);
86
87 if (want_delete) {
88 sb_start_intwrite(inode->i_sb);
89
90 EXT2_I(inode)->i_dtime = ktime_get_real_seconds();
91 mark_inode_dirty(inode);
92 __ext2_write_inode(inode, inode_needs_sync(inode));
93
94 inode->i_size = 0;
95 if (inode->i_blocks)
96 ext2_truncate_blocks(inode, 0);
97 ext2_xattr_delete_inode(inode);
98 }
99
100 invalidate_inode_buffers(inode);
101 clear_inode(inode);
102
103 ext2_discard_reservation(inode);
104 rsv = EXT2_I(inode)->i_block_alloc_info;
105 EXT2_I(inode)->i_block_alloc_info = NULL;
106 if (unlikely(rsv))
107 kfree(rsv);
108
109 if (want_delete) {
110 ext2_free_inode(inode);
111 sb_end_intwrite(inode->i_sb);
112 }
113}
114
115typedef struct {
116 __le32 *p;
117 __le32 key;
118 struct buffer_head *bh;
119} Indirect;
120
121static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
122{
123 p->key = *(p->p = v);
124 p->bh = bh;
125}
126
127static inline int verify_chain(Indirect *from, Indirect *to)
128{
129 while (from <= to && from->key == *from->p)
130 from++;
131 return (from > to);
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
163
164static int ext2_block_to_path(struct inode *inode,
165 long i_block, int offsets[4], int *boundary)
166{
167 int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
168 int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
169 const long direct_blocks = EXT2_NDIR_BLOCKS,
170 indirect_blocks = ptrs,
171 double_blocks = (1 << (ptrs_bits * 2));
172 int n = 0;
173 int final = 0;
174
175 if (i_block < 0) {
176 ext2_msg(inode->i_sb, KERN_WARNING,
177 "warning: %s: block < 0", __func__);
178 } else if (i_block < direct_blocks) {
179 offsets[n++] = i_block;
180 final = direct_blocks;
181 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
182 offsets[n++] = EXT2_IND_BLOCK;
183 offsets[n++] = i_block;
184 final = ptrs;
185 } else if ((i_block -= indirect_blocks) < double_blocks) {
186 offsets[n++] = EXT2_DIND_BLOCK;
187 offsets[n++] = i_block >> ptrs_bits;
188 offsets[n++] = i_block & (ptrs - 1);
189 final = ptrs;
190 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
191 offsets[n++] = EXT2_TIND_BLOCK;
192 offsets[n++] = i_block >> (ptrs_bits * 2);
193 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
194 offsets[n++] = i_block & (ptrs - 1);
195 final = ptrs;
196 } else {
197 ext2_msg(inode->i_sb, KERN_WARNING,
198 "warning: %s: block is too big", __func__);
199 }
200 if (boundary)
201 *boundary = final - 1 - (i_block & (ptrs - 1));
202
203 return n;
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
234
235static Indirect *ext2_get_branch(struct inode *inode,
236 int depth,
237 int *offsets,
238 Indirect chain[4],
239 int *err)
240{
241 struct super_block *sb = inode->i_sb;
242 Indirect *p = chain;
243 struct buffer_head *bh;
244
245 *err = 0;
246
247 add_chain (chain, NULL, EXT2_I(inode)->i_data + *offsets);
248 if (!p->key)
249 goto no_block;
250 while (--depth) {
251 bh = sb_bread(sb, le32_to_cpu(p->key));
252 if (!bh)
253 goto failure;
254 read_lock(&EXT2_I(inode)->i_meta_lock);
255 if (!verify_chain(chain, p))
256 goto changed;
257 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
258 read_unlock(&EXT2_I(inode)->i_meta_lock);
259 if (!p->key)
260 goto no_block;
261 }
262 return NULL;
263
264changed:
265 read_unlock(&EXT2_I(inode)->i_meta_lock);
266 brelse(bh);
267 *err = -EAGAIN;
268 goto no_block;
269failure:
270 *err = -EIO;
271no_block:
272 return p;
273}
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
296{
297 struct ext2_inode_info *ei = EXT2_I(inode);
298 __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
299 __le32 *p;
300 ext2_fsblk_t bg_start;
301 ext2_fsblk_t colour;
302
303
304 for (p = ind->p - 1; p >= start; p--)
305 if (*p)
306 return le32_to_cpu(*p);
307
308
309 if (ind->bh)
310 return ind->bh->b_blocknr;
311
312
313
314
315
316 bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group);
317 colour = (current->pid % 16) *
318 (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
319 return bg_start + colour;
320}
321
322
323
324
325
326
327
328
329
330
331static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
332 Indirect *partial)
333{
334 struct ext2_block_alloc_info *block_i;
335
336 block_i = EXT2_I(inode)->i_block_alloc_info;
337
338
339
340
341
342 if (block_i && (block == block_i->last_alloc_logical_block + 1)
343 && (block_i->last_alloc_physical_block != 0)) {
344 return block_i->last_alloc_physical_block + 1;
345 }
346
347 return ext2_find_near(inode, partial);
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
396static int ext2_alloc_blocks(struct inode *inode,
397 ext2_fsblk_t goal, int indirect_blks, int blks,
398 ext2_fsblk_t new_blocks[4], int *err)
399{
400 int target, i;
401 unsigned long count = 0;
402 int index = 0;
403 ext2_fsblk_t current_block = 0;
404 int ret = 0;
405
406
407
408
409
410
411
412
413
414 target = blks + indirect_blks;
415
416 while (1) {
417 count = target;
418
419 current_block = ext2_new_blocks(inode,goal,&count,err);
420 if (*err)
421 goto failed_out;
422
423 target -= count;
424
425 while (index < indirect_blks && count) {
426 new_blocks[index++] = current_block++;
427 count--;
428 }
429
430 if (count > 0)
431 break;
432 }
433
434
435 new_blocks[index] = current_block;
436
437
438 ret = count;
439 *err = 0;
440 return ret;
441failed_out:
442 for (i = 0; i <index; i++)
443 ext2_free_blocks(inode, new_blocks[i], 1);
444 if (index)
445 mark_inode_dirty(inode);
446 return ret;
447}
448
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
476static int ext2_alloc_branch(struct inode *inode,
477 int indirect_blks, int *blks, ext2_fsblk_t goal,
478 int *offsets, Indirect *branch)
479{
480 int blocksize = inode->i_sb->s_blocksize;
481 int i, n = 0;
482 int err = 0;
483 struct buffer_head *bh;
484 int num;
485 ext2_fsblk_t new_blocks[4];
486 ext2_fsblk_t current_block;
487
488 num = ext2_alloc_blocks(inode, goal, indirect_blks,
489 *blks, new_blocks, &err);
490 if (err)
491 return err;
492
493 branch[0].key = cpu_to_le32(new_blocks[0]);
494
495
496
497 for (n = 1; n <= indirect_blks; n++) {
498
499
500
501
502
503 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
504 if (unlikely(!bh)) {
505 err = -ENOMEM;
506 goto failed;
507 }
508 branch[n].bh = bh;
509 lock_buffer(bh);
510 memset(bh->b_data, 0, blocksize);
511 branch[n].p = (__le32 *) bh->b_data + offsets[n];
512 branch[n].key = cpu_to_le32(new_blocks[n]);
513 *branch[n].p = branch[n].key;
514 if ( n == indirect_blks) {
515 current_block = new_blocks[n];
516
517
518
519
520
521 for (i=1; i < num; i++)
522 *(branch[n].p + i) = cpu_to_le32(++current_block);
523 }
524 set_buffer_uptodate(bh);
525 unlock_buffer(bh);
526 mark_buffer_dirty_inode(bh, inode);
527
528
529
530
531 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
532 sync_dirty_buffer(bh);
533 }
534 *blks = num;
535 return err;
536
537failed:
538 for (i = 1; i < n; i++)
539 bforget(branch[i].bh);
540 for (i = 0; i < indirect_blks; i++)
541 ext2_free_blocks(inode, new_blocks[i], 1);
542 ext2_free_blocks(inode, new_blocks[i], num);
543 return err;
544}
545
546
547
548
549
550
551
552
553
554
555
556
557
558static void ext2_splice_branch(struct inode *inode,
559 long block, Indirect *where, int num, int blks)
560{
561 int i;
562 struct ext2_block_alloc_info *block_i;
563 ext2_fsblk_t current_block;
564
565 block_i = EXT2_I(inode)->i_block_alloc_info;
566
567
568
569
570 *where->p = where->key;
571
572
573
574
575
576 if (num == 0 && blks > 1) {
577 current_block = le32_to_cpu(where->key) + 1;
578 for (i = 1; i < blks; i++)
579 *(where->p + i ) = cpu_to_le32(current_block++);
580 }
581
582
583
584
585
586
587 if (block_i) {
588 block_i->last_alloc_logical_block = block + blks - 1;
589 block_i->last_alloc_physical_block =
590 le32_to_cpu(where[num].key) + blks - 1;
591 }
592
593
594
595
596 if (where->bh)
597 mark_buffer_dirty_inode(where->bh, inode);
598
599 inode->i_ctime = current_time(inode);
600 mark_inode_dirty(inode);
601}
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621static int ext2_get_blocks(struct inode *inode,
622 sector_t iblock, unsigned long maxblocks,
623 u32 *bno, bool *new, bool *boundary,
624 int create)
625{
626 int err;
627 int offsets[4];
628 Indirect chain[4];
629 Indirect *partial;
630 ext2_fsblk_t goal;
631 int indirect_blks;
632 int blocks_to_boundary = 0;
633 int depth;
634 struct ext2_inode_info *ei = EXT2_I(inode);
635 int count = 0;
636 ext2_fsblk_t first_block = 0;
637
638 BUG_ON(maxblocks == 0);
639
640 depth = ext2_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
641
642 if (depth == 0)
643 return -EIO;
644
645 partial = ext2_get_branch(inode, depth, offsets, chain, &err);
646
647 if (!partial) {
648 first_block = le32_to_cpu(chain[depth - 1].key);
649 count++;
650
651 while (count < maxblocks && count <= blocks_to_boundary) {
652 ext2_fsblk_t blk;
653
654 if (!verify_chain(chain, chain + depth - 1)) {
655
656
657
658
659
660
661 err = -EAGAIN;
662 count = 0;
663 partial = chain + depth - 1;
664 break;
665 }
666 blk = le32_to_cpu(*(chain[depth-1].p + count));
667 if (blk == first_block + count)
668 count++;
669 else
670 break;
671 }
672 if (err != -EAGAIN)
673 goto got_it;
674 }
675
676
677 if (!create || err == -EIO)
678 goto cleanup;
679
680 mutex_lock(&ei->truncate_mutex);
681
682
683
684
685
686
687
688
689
690
691
692
693 if (err == -EAGAIN || !verify_chain(chain, partial)) {
694 while (partial > chain) {
695 brelse(partial->bh);
696 partial--;
697 }
698 partial = ext2_get_branch(inode, depth, offsets, chain, &err);
699 if (!partial) {
700 count++;
701 mutex_unlock(&ei->truncate_mutex);
702 goto got_it;
703 }
704
705 if (err) {
706 mutex_unlock(&ei->truncate_mutex);
707 goto cleanup;
708 }
709 }
710
711
712
713
714
715 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
716 ext2_init_block_alloc_info(inode);
717
718 goal = ext2_find_goal(inode, iblock, partial);
719
720
721 indirect_blks = (chain + depth) - partial - 1;
722
723
724
725
726 count = ext2_blks_to_allocate(partial, indirect_blks,
727 maxblocks, blocks_to_boundary);
728
729
730
731 err = ext2_alloc_branch(inode, indirect_blks, &count, goal,
732 offsets + (partial - chain), partial);
733
734 if (err) {
735 mutex_unlock(&ei->truncate_mutex);
736 goto cleanup;
737 }
738
739 if (IS_DAX(inode)) {
740
741
742
743
744 clean_bdev_aliases(inode->i_sb->s_bdev,
745 le32_to_cpu(chain[depth-1].key),
746 count);
747
748
749
750
751
752 err = sb_issue_zeroout(inode->i_sb,
753 le32_to_cpu(chain[depth-1].key), count,
754 GFP_NOFS);
755 if (err) {
756 mutex_unlock(&ei->truncate_mutex);
757 goto cleanup;
758 }
759 }
760 *new = true;
761
762 ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
763 mutex_unlock(&ei->truncate_mutex);
764got_it:
765 if (count > blocks_to_boundary)
766 *boundary = true;
767 err = count;
768
769 partial = chain + depth - 1;
770cleanup:
771 while (partial > chain) {
772 brelse(partial->bh);
773 partial--;
774 }
775 if (err > 0)
776 *bno = le32_to_cpu(chain[depth-1].key);
777 return err;
778}
779
780int ext2_get_block(struct inode *inode, sector_t iblock,
781 struct buffer_head *bh_result, int create)
782{
783 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
784 bool new = false, boundary = false;
785 u32 bno;
786 int ret;
787
788 ret = ext2_get_blocks(inode, iblock, max_blocks, &bno, &new, &boundary,
789 create);
790 if (ret <= 0)
791 return ret;
792
793 map_bh(bh_result, inode->i_sb, bno);
794 bh_result->b_size = (ret << inode->i_blkbits);
795 if (new)
796 set_buffer_new(bh_result);
797 if (boundary)
798 set_buffer_boundary(bh_result);
799 return 0;
800
801}
802
803#ifdef CONFIG_FS_DAX
804static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
805 unsigned flags, struct iomap *iomap, struct iomap *srcmap)
806{
807 unsigned int blkbits = inode->i_blkbits;
808 unsigned long first_block = offset >> blkbits;
809 unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
810 struct ext2_sb_info *sbi = EXT2_SB(inode->i_sb);
811 bool new = false, boundary = false;
812 u32 bno;
813 int ret;
814
815 ret = ext2_get_blocks(inode, first_block, max_blocks,
816 &bno, &new, &boundary, flags & IOMAP_WRITE);
817 if (ret < 0)
818 return ret;
819
820 iomap->flags = 0;
821 iomap->bdev = inode->i_sb->s_bdev;
822 iomap->offset = (u64)first_block << blkbits;
823 iomap->dax_dev = sbi->s_daxdev;
824
825 if (ret == 0) {
826 iomap->type = IOMAP_HOLE;
827 iomap->addr = IOMAP_NULL_ADDR;
828 iomap->length = 1 << blkbits;
829 } else {
830 iomap->type = IOMAP_MAPPED;
831 iomap->addr = (u64)bno << blkbits;
832 iomap->length = (u64)ret << blkbits;
833 iomap->flags |= IOMAP_F_MERGED;
834 }
835
836 if (new)
837 iomap->flags |= IOMAP_F_NEW;
838 return 0;
839}
840
841static int
842ext2_iomap_end(struct inode *inode, loff_t offset, loff_t length,
843 ssize_t written, unsigned flags, struct iomap *iomap)
844{
845 if (iomap->type == IOMAP_MAPPED &&
846 written < length &&
847 (flags & IOMAP_WRITE))
848 ext2_write_failed(inode->i_mapping, offset + length);
849 return 0;
850}
851
852const struct iomap_ops ext2_iomap_ops = {
853 .iomap_begin = ext2_iomap_begin,
854 .iomap_end = ext2_iomap_end,
855};
856#else
857
858const struct iomap_ops ext2_iomap_ops;
859#endif
860
861int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
862 u64 start, u64 len)
863{
864 return generic_block_fiemap(inode, fieinfo, start, len,
865 ext2_get_block);
866}
867
868static int ext2_writepage(struct page *page, struct writeback_control *wbc)
869{
870 return block_write_full_page(page, ext2_get_block, wbc);
871}
872
873static int ext2_readpage(struct file *file, struct page *page)
874{
875 return mpage_readpage(page, ext2_get_block);
876}
877
878static void ext2_readahead(struct readahead_control *rac)
879{
880 mpage_readahead(rac, ext2_get_block);
881}
882
883static int
884ext2_write_begin(struct file *file, struct address_space *mapping,
885 loff_t pos, unsigned len, unsigned flags,
886 struct page **pagep, void **fsdata)
887{
888 int ret;
889
890 ret = block_write_begin(mapping, pos, len, flags, pagep,
891 ext2_get_block);
892 if (ret < 0)
893 ext2_write_failed(mapping, pos + len);
894 return ret;
895}
896
897static int ext2_write_end(struct file *file, struct address_space *mapping,
898 loff_t pos, unsigned len, unsigned copied,
899 struct page *page, void *fsdata)
900{
901 int ret;
902
903 ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
904 if (ret < len)
905 ext2_write_failed(mapping, pos + len);
906 return ret;
907}
908
909static int
910ext2_nobh_write_begin(struct file *file, struct address_space *mapping,
911 loff_t pos, unsigned len, unsigned flags,
912 struct page **pagep, void **fsdata)
913{
914 int ret;
915
916 ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
917 ext2_get_block);
918 if (ret < 0)
919 ext2_write_failed(mapping, pos + len);
920 return ret;
921}
922
923static int ext2_nobh_writepage(struct page *page,
924 struct writeback_control *wbc)
925{
926 return nobh_writepage(page, ext2_get_block, wbc);
927}
928
929static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
930{
931 return generic_block_bmap(mapping,block,ext2_get_block);
932}
933
934static ssize_t
935ext2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
936{
937 struct file *file = iocb->ki_filp;
938 struct address_space *mapping = file->f_mapping;
939 struct inode *inode = mapping->host;
940 size_t count = iov_iter_count(iter);
941 loff_t offset = iocb->ki_pos;
942 ssize_t ret;
943
944 ret = blockdev_direct_IO(iocb, inode, iter, ext2_get_block);
945 if (ret < 0 && iov_iter_rw(iter) == WRITE)
946 ext2_write_failed(mapping, offset + count);
947 return ret;
948}
949
950static int
951ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
952{
953 return mpage_writepages(mapping, wbc, ext2_get_block);
954}
955
956static int
957ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc)
958{
959 struct ext2_sb_info *sbi = EXT2_SB(mapping->host->i_sb);
960
961 return dax_writeback_mapping_range(mapping, sbi->s_daxdev, wbc);
962}
963
964const struct address_space_operations ext2_aops = {
965 .readpage = ext2_readpage,
966 .readahead = ext2_readahead,
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 .readahead = ext2_readahead,
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 fallthrough;
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 fallthrough;
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