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#include <linux/module.h>
26#include <linux/fs.h>
27#include <linux/time.h>
28#include <linux/jbd2.h>
29#include <linux/highuid.h>
30#include <linux/pagemap.h>
31#include <linux/quotaops.h>
32#include <linux/string.h>
33#include <linux/buffer_head.h>
34#include <linux/writeback.h>
35#include <linux/pagevec.h>
36#include <linux/mpage.h>
37#include <linux/namei.h>
38#include <linux/uio.h>
39#include <linux/bio.h>
40#include <linux/workqueue.h>
41
42#include "ext4_jbd2.h"
43#include "xattr.h"
44#include "acl.h"
45#include "ext4_extents.h"
46
47#include <trace/events/ext4.h>
48
49#define MPAGE_DA_EXTENT_TAIL 0x01
50
51static inline int ext4_begin_ordered_truncate(struct inode *inode,
52 loff_t new_size)
53{
54 return jbd2_journal_begin_ordered_truncate(
55 EXT4_SB(inode->i_sb)->s_journal,
56 &EXT4_I(inode)->jinode,
57 new_size);
58}
59
60static void ext4_invalidatepage(struct page *page, unsigned long offset);
61
62
63
64
65static int ext4_inode_is_fast_symlink(struct inode *inode)
66{
67 int ea_blocks = EXT4_I(inode)->i_file_acl ?
68 (inode->i_sb->s_blocksize >> 9) : 0;
69
70 return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
71}
72
73
74
75
76
77
78
79
80
81
82
83
84
85int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
86 struct buffer_head *bh, ext4_fsblk_t blocknr)
87{
88 int err;
89
90 might_sleep();
91
92 BUFFER_TRACE(bh, "enter");
93
94 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
95 "data mode %x\n",
96 bh, is_metadata, inode->i_mode,
97 test_opt(inode->i_sb, DATA_FLAGS));
98
99
100
101
102
103
104 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ||
105 (!is_metadata && !ext4_should_journal_data(inode))) {
106 if (bh) {
107 BUFFER_TRACE(bh, "call jbd2_journal_forget");
108 return ext4_journal_forget(handle, bh);
109 }
110 return 0;
111 }
112
113
114
115
116 BUFFER_TRACE(bh, "call ext4_journal_revoke");
117 err = ext4_journal_revoke(handle, blocknr, bh);
118 if (err)
119 ext4_abort(inode->i_sb, __func__,
120 "error %d when attempting revoke", err);
121 BUFFER_TRACE(bh, "exit");
122 return err;
123}
124
125
126
127
128
129static unsigned long blocks_for_truncate(struct inode *inode)
130{
131 ext4_lblk_t needed;
132
133 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
134
135
136
137
138
139
140
141 if (needed < 2)
142 needed = 2;
143
144
145
146 if (needed > EXT4_MAX_TRANS_DATA)
147 needed = EXT4_MAX_TRANS_DATA;
148
149 return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
150}
151
152
153
154
155
156
157
158
159
160
161
162static handle_t *start_transaction(struct inode *inode)
163{
164 handle_t *result;
165
166 result = ext4_journal_start(inode, blocks_for_truncate(inode));
167 if (!IS_ERR(result))
168 return result;
169
170 ext4_std_error(inode->i_sb, PTR_ERR(result));
171 return result;
172}
173
174
175
176
177
178
179
180static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
181{
182 if (!ext4_handle_valid(handle))
183 return 0;
184 if (ext4_handle_has_enough_credits(handle, EXT4_RESERVE_TRANS_BLOCKS+1))
185 return 0;
186 if (!ext4_journal_extend(handle, blocks_for_truncate(inode)))
187 return 0;
188 return 1;
189}
190
191
192
193
194
195
196int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
197 int nblocks)
198{
199 int ret;
200
201
202
203
204
205
206
207 BUG_ON(EXT4_JOURNAL(inode) == NULL);
208 jbd_debug(2, "restarting handle %p\n", handle);
209 up_write(&EXT4_I(inode)->i_data_sem);
210 ret = ext4_journal_restart(handle, blocks_for_truncate(inode));
211 down_write(&EXT4_I(inode)->i_data_sem);
212 ext4_discard_preallocations(inode);
213
214 return ret;
215}
216
217
218
219
220void ext4_delete_inode(struct inode *inode)
221{
222 handle_t *handle;
223 int err;
224
225 if (ext4_should_order_data(inode))
226 ext4_begin_ordered_truncate(inode, 0);
227 truncate_inode_pages(&inode->i_data, 0);
228
229 if (is_bad_inode(inode))
230 goto no_delete;
231
232 handle = ext4_journal_start(inode, blocks_for_truncate(inode)+3);
233 if (IS_ERR(handle)) {
234 ext4_std_error(inode->i_sb, PTR_ERR(handle));
235
236
237
238
239
240 ext4_orphan_del(NULL, inode);
241 goto no_delete;
242 }
243
244 if (IS_SYNC(inode))
245 ext4_handle_sync(handle);
246 inode->i_size = 0;
247 err = ext4_mark_inode_dirty(handle, inode);
248 if (err) {
249 ext4_warning(inode->i_sb, __func__,
250 "couldn't mark inode dirty (err %d)", err);
251 goto stop_handle;
252 }
253 if (inode->i_blocks)
254 ext4_truncate(inode);
255
256
257
258
259
260
261
262 if (!ext4_handle_has_enough_credits(handle, 3)) {
263 err = ext4_journal_extend(handle, 3);
264 if (err > 0)
265 err = ext4_journal_restart(handle, 3);
266 if (err != 0) {
267 ext4_warning(inode->i_sb, __func__,
268 "couldn't extend journal (err %d)", err);
269 stop_handle:
270 ext4_journal_stop(handle);
271 goto no_delete;
272 }
273 }
274
275
276
277
278
279
280
281
282
283 ext4_orphan_del(handle, inode);
284 EXT4_I(inode)->i_dtime = get_seconds();
285
286
287
288
289
290
291
292
293 if (ext4_mark_inode_dirty(handle, inode))
294
295 clear_inode(inode);
296 else
297 ext4_free_inode(handle, inode);
298 ext4_journal_stop(handle);
299 return;
300no_delete:
301 clear_inode(inode);
302}
303
304typedef struct {
305 __le32 *p;
306 __le32 key;
307 struct buffer_head *bh;
308} Indirect;
309
310static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
311{
312 p->key = *(p->p = v);
313 p->bh = bh;
314}
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347static int ext4_block_to_path(struct inode *inode,
348 ext4_lblk_t i_block,
349 ext4_lblk_t offsets[4], int *boundary)
350{
351 int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb);
352 int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb);
353 const long direct_blocks = EXT4_NDIR_BLOCKS,
354 indirect_blocks = ptrs,
355 double_blocks = (1 << (ptrs_bits * 2));
356 int n = 0;
357 int final = 0;
358
359 if (i_block < direct_blocks) {
360 offsets[n++] = i_block;
361 final = direct_blocks;
362 } else if ((i_block -= direct_blocks) < indirect_blocks) {
363 offsets[n++] = EXT4_IND_BLOCK;
364 offsets[n++] = i_block;
365 final = ptrs;
366 } else if ((i_block -= indirect_blocks) < double_blocks) {
367 offsets[n++] = EXT4_DIND_BLOCK;
368 offsets[n++] = i_block >> ptrs_bits;
369 offsets[n++] = i_block & (ptrs - 1);
370 final = ptrs;
371 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
372 offsets[n++] = EXT4_TIND_BLOCK;
373 offsets[n++] = i_block >> (ptrs_bits * 2);
374 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
375 offsets[n++] = i_block & (ptrs - 1);
376 final = ptrs;
377 } else {
378 ext4_warning(inode->i_sb, "ext4_block_to_path",
379 "block %lu > max in inode %lu",
380 i_block + direct_blocks +
381 indirect_blocks + double_blocks, inode->i_ino);
382 }
383 if (boundary)
384 *boundary = final - 1 - (i_block & (ptrs - 1));
385 return n;
386}
387
388static int __ext4_check_blockref(const char *function, struct inode *inode,
389 __le32 *p, unsigned int max)
390{
391 __le32 *bref = p;
392 unsigned int blk;
393
394 while (bref < p+max) {
395 blk = le32_to_cpu(*bref++);
396 if (blk &&
397 unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb),
398 blk, 1))) {
399 ext4_error(inode->i_sb, function,
400 "invalid block reference %u "
401 "in inode #%lu", blk, inode->i_ino);
402 return -EIO;
403 }
404 }
405 return 0;
406}
407
408
409#define ext4_check_indirect_blockref(inode, bh) \
410 __ext4_check_blockref(__func__, inode, (__le32 *)(bh)->b_data, \
411 EXT4_ADDR_PER_BLOCK((inode)->i_sb))
412
413#define ext4_check_inode_blockref(inode) \
414 __ext4_check_blockref(__func__, inode, EXT4_I(inode)->i_data, \
415 EXT4_NDIR_BLOCKS)
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447static Indirect *ext4_get_branch(struct inode *inode, int depth,
448 ext4_lblk_t *offsets,
449 Indirect chain[4], int *err)
450{
451 struct super_block *sb = inode->i_sb;
452 Indirect *p = chain;
453 struct buffer_head *bh;
454
455 *err = 0;
456
457 add_chain(chain, NULL, EXT4_I(inode)->i_data + *offsets);
458 if (!p->key)
459 goto no_block;
460 while (--depth) {
461 bh = sb_getblk(sb, le32_to_cpu(p->key));
462 if (unlikely(!bh))
463 goto failure;
464
465 if (!bh_uptodate_or_lock(bh)) {
466 if (bh_submit_read(bh) < 0) {
467 put_bh(bh);
468 goto failure;
469 }
470
471 if (ext4_check_indirect_blockref(inode, bh)) {
472 put_bh(bh);
473 goto failure;
474 }
475 }
476
477 add_chain(++p, bh, (__le32 *)bh->b_data + *++offsets);
478
479 if (!p->key)
480 goto no_block;
481 }
482 return NULL;
483
484failure:
485 *err = -EIO;
486no_block:
487 return p;
488}
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
511{
512 struct ext4_inode_info *ei = EXT4_I(inode);
513 __le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
514 __le32 *p;
515 ext4_fsblk_t bg_start;
516 ext4_fsblk_t last_block;
517 ext4_grpblk_t colour;
518 ext4_group_t block_group;
519 int flex_size = ext4_flex_bg_size(EXT4_SB(inode->i_sb));
520
521
522 for (p = ind->p - 1; p >= start; p--) {
523 if (*p)
524 return le32_to_cpu(*p);
525 }
526
527
528 if (ind->bh)
529 return ind->bh->b_blocknr;
530
531
532
533
534
535 block_group = ei->i_block_group;
536 if (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) {
537 block_group &= ~(flex_size-1);
538 if (S_ISREG(inode->i_mode))
539 block_group++;
540 }
541 bg_start = ext4_group_first_block_no(inode->i_sb, block_group);
542 last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
543
544
545
546
547
548 if (test_opt(inode->i_sb, DELALLOC))
549 return bg_start;
550
551 if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
552 colour = (current->pid % 16) *
553 (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
554 else
555 colour = (current->pid % 16) * ((last_block - bg_start) / 16);
556 return bg_start + colour;
557}
558
559
560
561
562
563
564
565
566
567
568
569
570static ext4_fsblk_t ext4_find_goal(struct inode *inode, ext4_lblk_t block,
571 Indirect *partial)
572{
573 ext4_fsblk_t goal;
574
575
576
577
578
579 goal = ext4_find_near(inode, partial);
580 goal = goal & EXT4_MAX_BLOCK_FILE_PHYS;
581 return goal;
582}
583
584
585
586
587
588
589
590
591
592
593
594
595
596static int ext4_blks_to_allocate(Indirect *branch, int k, unsigned int blks,
597 int blocks_to_boundary)
598{
599 unsigned int count = 0;
600
601
602
603
604
605 if (k > 0) {
606
607 if (blks < blocks_to_boundary + 1)
608 count += blks;
609 else
610 count += blocks_to_boundary + 1;
611 return count;
612 }
613
614 count++;
615 while (count < blks && count <= blocks_to_boundary &&
616 le32_to_cpu(*(branch[0].p + count)) == 0) {
617 count++;
618 }
619 return count;
620}
621
622
623
624
625
626
627
628
629
630
631
632static int ext4_alloc_blocks(handle_t *handle, struct inode *inode,
633 ext4_lblk_t iblock, ext4_fsblk_t goal,
634 int indirect_blks, int blks,
635 ext4_fsblk_t new_blocks[4], int *err)
636{
637 struct ext4_allocation_request ar;
638 int target, i;
639 unsigned long count = 0, blk_allocated = 0;
640 int index = 0;
641 ext4_fsblk_t current_block = 0;
642 int ret = 0;
643
644
645
646
647
648
649
650
651
652
653 target = indirect_blks;
654 while (target > 0) {
655 count = target;
656
657 current_block = ext4_new_meta_blocks(handle, inode,
658 goal, &count, err);
659 if (*err)
660 goto failed_out;
661
662 BUG_ON(current_block + count > EXT4_MAX_BLOCK_FILE_PHYS);
663
664 target -= count;
665
666 while (index < indirect_blks && count) {
667 new_blocks[index++] = current_block++;
668 count--;
669 }
670 if (count > 0) {
671
672
673
674
675 new_blocks[index] = current_block;
676 printk(KERN_INFO "%s returned more blocks than "
677 "requested\n", __func__);
678 WARN_ON(1);
679 break;
680 }
681 }
682
683 target = blks - count ;
684 blk_allocated = count;
685 if (!target)
686 goto allocated;
687
688 memset(&ar, 0, sizeof(ar));
689 ar.inode = inode;
690 ar.goal = goal;
691 ar.len = target;
692 ar.logical = iblock;
693 if (S_ISREG(inode->i_mode))
694
695 ar.flags = EXT4_MB_HINT_DATA;
696
697 current_block = ext4_mb_new_blocks(handle, &ar, err);
698 BUG_ON(current_block + ar.len > EXT4_MAX_BLOCK_FILE_PHYS);
699
700 if (*err && (target == blks)) {
701
702
703
704
705 goto failed_out;
706 }
707 if (!*err) {
708 if (target == blks) {
709
710
711
712
713 new_blocks[index] = current_block;
714 }
715 blk_allocated += ar.len;
716 }
717allocated:
718
719 ret = blk_allocated;
720 *err = 0;
721 return ret;
722failed_out:
723 for (i = 0; i < index; i++)
724 ext4_free_blocks(handle, inode, new_blocks[i], 1, 0);
725 return ret;
726}
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753static int ext4_alloc_branch(handle_t *handle, struct inode *inode,
754 ext4_lblk_t iblock, int indirect_blks,
755 int *blks, ext4_fsblk_t goal,
756 ext4_lblk_t *offsets, Indirect *branch)
757{
758 int blocksize = inode->i_sb->s_blocksize;
759 int i, n = 0;
760 int err = 0;
761 struct buffer_head *bh;
762 int num;
763 ext4_fsblk_t new_blocks[4];
764 ext4_fsblk_t current_block;
765
766 num = ext4_alloc_blocks(handle, inode, iblock, goal, indirect_blks,
767 *blks, new_blocks, &err);
768 if (err)
769 return err;
770
771 branch[0].key = cpu_to_le32(new_blocks[0]);
772
773
774
775 for (n = 1; n <= indirect_blks; n++) {
776
777
778
779
780
781 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
782 branch[n].bh = bh;
783 lock_buffer(bh);
784 BUFFER_TRACE(bh, "call get_create_access");
785 err = ext4_journal_get_create_access(handle, bh);
786 if (err) {
787
788
789 unlock_buffer(bh);
790 goto failed;
791 }
792
793 memset(bh->b_data, 0, blocksize);
794 branch[n].p = (__le32 *) bh->b_data + offsets[n];
795 branch[n].key = cpu_to_le32(new_blocks[n]);
796 *branch[n].p = branch[n].key;
797 if (n == indirect_blks) {
798 current_block = new_blocks[n];
799
800
801
802
803
804 for (i = 1; i < num; i++)
805 *(branch[n].p + i) = cpu_to_le32(++current_block);
806 }
807 BUFFER_TRACE(bh, "marking uptodate");
808 set_buffer_uptodate(bh);
809 unlock_buffer(bh);
810
811 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
812 err = ext4_handle_dirty_metadata(handle, inode, bh);
813 if (err)
814 goto failed;
815 }
816 *blks = num;
817 return err;
818failed:
819
820 for (i = 1; i <= n ; i++) {
821 BUFFER_TRACE(branch[i].bh, "call jbd2_journal_forget");
822 ext4_journal_forget(handle, branch[i].bh);
823 }
824 for (i = 0; i < indirect_blks; i++)
825 ext4_free_blocks(handle, inode, new_blocks[i], 1, 0);
826
827 ext4_free_blocks(handle, inode, new_blocks[i], num, 0);
828
829 return err;
830}
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846static int ext4_splice_branch(handle_t *handle, struct inode *inode,
847 ext4_lblk_t block, Indirect *where, int num,
848 int blks)
849{
850 int i;
851 int err = 0;
852 ext4_fsblk_t current_block;
853
854
855
856
857
858
859 if (where->bh) {
860 BUFFER_TRACE(where->bh, "get_write_access");
861 err = ext4_journal_get_write_access(handle, where->bh);
862 if (err)
863 goto err_out;
864 }
865
866
867 *where->p = where->key;
868
869
870
871
872
873 if (num == 0 && blks > 1) {
874 current_block = le32_to_cpu(where->key) + 1;
875 for (i = 1; i < blks; i++)
876 *(where->p + i) = cpu_to_le32(current_block++);
877 }
878
879
880
881 if (where->bh) {
882
883
884
885
886
887
888
889
890 jbd_debug(5, "splicing indirect only\n");
891 BUFFER_TRACE(where->bh, "call ext4_handle_dirty_metadata");
892 err = ext4_handle_dirty_metadata(handle, inode, where->bh);
893 if (err)
894 goto err_out;
895 } else {
896
897
898
899 ext4_mark_inode_dirty(handle, inode);
900 jbd_debug(5, "splicing direct\n");
901 }
902 return err;
903
904err_out:
905 for (i = 1; i <= num; i++) {
906 BUFFER_TRACE(where[i].bh, "call jbd2_journal_forget");
907 ext4_journal_forget(handle, where[i].bh);
908 ext4_free_blocks(handle, inode,
909 le32_to_cpu(where[i-1].key), 1, 0);
910 }
911 ext4_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks, 0);
912
913 return err;
914}
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
945 ext4_lblk_t iblock, unsigned int maxblocks,
946 struct buffer_head *bh_result,
947 int flags)
948{
949 int err = -EIO;
950 ext4_lblk_t offsets[4];
951 Indirect chain[4];
952 Indirect *partial;
953 ext4_fsblk_t goal;
954 int indirect_blks;
955 int blocks_to_boundary = 0;
956 int depth;
957 int count = 0;
958 ext4_fsblk_t first_block = 0;
959
960 J_ASSERT(!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL));
961 J_ASSERT(handle != NULL || (flags & EXT4_GET_BLOCKS_CREATE) == 0);
962 depth = ext4_block_to_path(inode, iblock, offsets,
963 &blocks_to_boundary);
964
965 if (depth == 0)
966 goto out;
967
968 partial = ext4_get_branch(inode, depth, offsets, chain, &err);
969
970
971 if (!partial) {
972 first_block = le32_to_cpu(chain[depth - 1].key);
973 clear_buffer_new(bh_result);
974 count++;
975
976 while (count < maxblocks && count <= blocks_to_boundary) {
977 ext4_fsblk_t blk;
978
979 blk = le32_to_cpu(*(chain[depth-1].p + count));
980
981 if (blk == first_block + count)
982 count++;
983 else
984 break;
985 }
986 goto got_it;
987 }
988
989
990 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0 || err == -EIO)
991 goto cleanup;
992
993
994
995
996 goal = ext4_find_goal(inode, iblock, partial);
997
998
999 indirect_blks = (chain + depth) - partial - 1;
1000
1001
1002
1003
1004
1005 count = ext4_blks_to_allocate(partial, indirect_blks,
1006 maxblocks, blocks_to_boundary);
1007
1008
1009
1010 err = ext4_alloc_branch(handle, inode, iblock, indirect_blks,
1011 &count, goal,
1012 offsets + (partial - chain), partial);
1013
1014
1015
1016
1017
1018
1019
1020
1021 if (!err)
1022 err = ext4_splice_branch(handle, inode, iblock,
1023 partial, indirect_blks, count);
1024 else
1025 goto cleanup;
1026
1027 set_buffer_new(bh_result);
1028got_it:
1029 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
1030 if (count > blocks_to_boundary)
1031 set_buffer_boundary(bh_result);
1032 err = count;
1033
1034 partial = chain + depth - 1;
1035cleanup:
1036 while (partial > chain) {
1037 BUFFER_TRACE(partial->bh, "call brelse");
1038 brelse(partial->bh);
1039 partial--;
1040 }
1041 BUFFER_TRACE(bh_result, "returned");
1042out:
1043 return err;
1044}
1045
1046qsize_t ext4_get_reserved_space(struct inode *inode)
1047{
1048 unsigned long long total;
1049
1050 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1051 total = EXT4_I(inode)->i_reserved_data_blocks +
1052 EXT4_I(inode)->i_reserved_meta_blocks;
1053 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1054
1055 return total;
1056}
1057
1058
1059
1060
1061static int ext4_indirect_calc_metadata_amount(struct inode *inode, int blocks)
1062{
1063 int icap = EXT4_ADDR_PER_BLOCK(inode->i_sb);
1064 int ind_blks, dind_blks, tind_blks;
1065
1066
1067 ind_blks = (blocks + icap - 1) / icap;
1068
1069 dind_blks = (ind_blks + icap - 1) / icap;
1070
1071 tind_blks = 1;
1072
1073 return ind_blks + dind_blks + tind_blks;
1074}
1075
1076
1077
1078
1079
1080static int ext4_calc_metadata_amount(struct inode *inode, int blocks)
1081{
1082 if (!blocks)
1083 return 0;
1084
1085 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)
1086 return ext4_ext_calc_metadata_amount(inode, blocks);
1087
1088 return ext4_indirect_calc_metadata_amount(inode, blocks);
1089}
1090
1091static void ext4_da_update_reserve_space(struct inode *inode, int used)
1092{
1093 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1094 int total, mdb, mdb_free;
1095
1096 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1097
1098 total = EXT4_I(inode)->i_reserved_data_blocks - used;
1099 mdb = ext4_calc_metadata_amount(inode, total);
1100
1101
1102 BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1103 mdb_free = EXT4_I(inode)->i_reserved_meta_blocks - mdb;
1104
1105 if (mdb_free) {
1106
1107 mdb_free -= EXT4_I(inode)->i_allocated_meta_blocks;
1108
1109
1110 percpu_counter_sub(&sbi->s_dirtyblocks_counter, mdb_free);
1111 EXT4_I(inode)->i_allocated_meta_blocks = 0;
1112 EXT4_I(inode)->i_reserved_meta_blocks = mdb;
1113 }
1114
1115
1116 BUG_ON(used > EXT4_I(inode)->i_reserved_data_blocks);
1117 EXT4_I(inode)->i_reserved_data_blocks -= used;
1118 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1119
1120
1121
1122
1123 if (mdb_free)
1124 vfs_dq_release_reservation_block(inode, mdb_free);
1125
1126
1127
1128
1129
1130
1131 if (!total && (atomic_read(&inode->i_writecount) == 0))
1132 ext4_discard_preallocations(inode);
1133}
1134
1135static int check_block_validity(struct inode *inode, const char *msg,
1136 sector_t logical, sector_t phys, int len)
1137{
1138 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), phys, len)) {
1139 ext4_error(inode->i_sb, msg,
1140 "inode #%lu logical block %llu mapped to %llu "
1141 "(size %d)", inode->i_ino,
1142 (unsigned long long) logical,
1143 (unsigned long long) phys, len);
1144 return -EIO;
1145 }
1146 return 0;
1147}
1148
1149
1150
1151
1152
1153static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
1154 unsigned int max_pages)
1155{
1156 struct address_space *mapping = inode->i_mapping;
1157 pgoff_t index;
1158 struct pagevec pvec;
1159 pgoff_t num = 0;
1160 int i, nr_pages, done = 0;
1161
1162 if (max_pages == 0)
1163 return 0;
1164 pagevec_init(&pvec, 0);
1165 while (!done) {
1166 index = idx;
1167 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1168 PAGECACHE_TAG_DIRTY,
1169 (pgoff_t)PAGEVEC_SIZE);
1170 if (nr_pages == 0)
1171 break;
1172 for (i = 0; i < nr_pages; i++) {
1173 struct page *page = pvec.pages[i];
1174 struct buffer_head *bh, *head;
1175
1176 lock_page(page);
1177 if (unlikely(page->mapping != mapping) ||
1178 !PageDirty(page) ||
1179 PageWriteback(page) ||
1180 page->index != idx) {
1181 done = 1;
1182 unlock_page(page);
1183 break;
1184 }
1185 if (page_has_buffers(page)) {
1186 bh = head = page_buffers(page);
1187 do {
1188 if (!buffer_delay(bh) &&
1189 !buffer_unwritten(bh))
1190 done = 1;
1191 bh = bh->b_this_page;
1192 } while (!done && (bh != head));
1193 }
1194 unlock_page(page);
1195 if (done)
1196 break;
1197 idx++;
1198 num++;
1199 if (num >= max_pages)
1200 break;
1201 }
1202 pagevec_release(&pvec);
1203 }
1204 return num;
1205}
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block,
1230 unsigned int max_blocks, struct buffer_head *bh,
1231 int flags)
1232{
1233 int retval;
1234
1235 clear_buffer_mapped(bh);
1236 clear_buffer_unwritten(bh);
1237
1238 ext_debug("ext4_get_blocks(): inode %lu, flag %d, max_blocks %u,"
1239 "logical block %lu\n", inode->i_ino, flags, max_blocks,
1240 (unsigned long)block);
1241
1242
1243
1244
1245 down_read((&EXT4_I(inode)->i_data_sem));
1246 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1247 retval = ext4_ext_get_blocks(handle, inode, block, max_blocks,
1248 bh, 0);
1249 } else {
1250 retval = ext4_ind_get_blocks(handle, inode, block, max_blocks,
1251 bh, 0);
1252 }
1253 up_read((&EXT4_I(inode)->i_data_sem));
1254
1255 if (retval > 0 && buffer_mapped(bh)) {
1256 int ret = check_block_validity(inode, "file system corruption",
1257 block, bh->b_blocknr, retval);
1258 if (ret != 0)
1259 return ret;
1260 }
1261
1262
1263 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
1264 return retval;
1265
1266
1267
1268
1269
1270
1271
1272
1273 if (retval > 0 && buffer_mapped(bh))
1274 return retval;
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286 clear_buffer_unwritten(bh);
1287
1288
1289
1290
1291
1292
1293
1294 down_write((&EXT4_I(inode)->i_data_sem));
1295
1296
1297
1298
1299
1300
1301
1302 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
1303 EXT4_I(inode)->i_delalloc_reserved_flag = 1;
1304
1305
1306
1307
1308 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1309 retval = ext4_ext_get_blocks(handle, inode, block, max_blocks,
1310 bh, flags);
1311 } else {
1312 retval = ext4_ind_get_blocks(handle, inode, block,
1313 max_blocks, bh, flags);
1314
1315 if (retval > 0 && buffer_new(bh)) {
1316
1317
1318
1319
1320
1321 EXT4_I(inode)->i_state &= ~EXT4_STATE_EXT_MIGRATE;
1322 }
1323 }
1324
1325 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
1326 EXT4_I(inode)->i_delalloc_reserved_flag = 0;
1327
1328
1329
1330
1331
1332 if ((retval > 0) && (flags & EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE))
1333 ext4_da_update_reserve_space(inode, retval);
1334
1335 up_write((&EXT4_I(inode)->i_data_sem));
1336 if (retval > 0 && buffer_mapped(bh)) {
1337 int ret = check_block_validity(inode, "file system "
1338 "corruption after allocation",
1339 block, bh->b_blocknr, retval);
1340 if (ret != 0)
1341 return ret;
1342 }
1343 return retval;
1344}
1345
1346
1347#define DIO_MAX_BLOCKS 4096
1348
1349int ext4_get_block(struct inode *inode, sector_t iblock,
1350 struct buffer_head *bh_result, int create)
1351{
1352 handle_t *handle = ext4_journal_current_handle();
1353 int ret = 0, started = 0;
1354 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
1355 int dio_credits;
1356
1357 if (create && !handle) {
1358
1359 if (max_blocks > DIO_MAX_BLOCKS)
1360 max_blocks = DIO_MAX_BLOCKS;
1361 dio_credits = ext4_chunk_trans_blocks(inode, max_blocks);
1362 handle = ext4_journal_start(inode, dio_credits);
1363 if (IS_ERR(handle)) {
1364 ret = PTR_ERR(handle);
1365 goto out;
1366 }
1367 started = 1;
1368 }
1369
1370 ret = ext4_get_blocks(handle, inode, iblock, max_blocks, bh_result,
1371 create ? EXT4_GET_BLOCKS_CREATE : 0);
1372 if (ret > 0) {
1373 bh_result->b_size = (ret << inode->i_blkbits);
1374 ret = 0;
1375 }
1376 if (started)
1377 ext4_journal_stop(handle);
1378out:
1379 return ret;
1380}
1381
1382
1383
1384
1385struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
1386 ext4_lblk_t block, int create, int *errp)
1387{
1388 struct buffer_head dummy;
1389 int fatal = 0, err;
1390 int flags = 0;
1391
1392 J_ASSERT(handle != NULL || create == 0);
1393
1394 dummy.b_state = 0;
1395 dummy.b_blocknr = -1000;
1396 buffer_trace_init(&dummy.b_history);
1397 if (create)
1398 flags |= EXT4_GET_BLOCKS_CREATE;
1399 err = ext4_get_blocks(handle, inode, block, 1, &dummy, flags);
1400
1401
1402
1403
1404 if (err > 0) {
1405 if (err > 1)
1406 WARN_ON(1);
1407 err = 0;
1408 }
1409 *errp = err;
1410 if (!err && buffer_mapped(&dummy)) {
1411 struct buffer_head *bh;
1412 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1413 if (!bh) {
1414 *errp = -EIO;
1415 goto err;
1416 }
1417 if (buffer_new(&dummy)) {
1418 J_ASSERT(create != 0);
1419 J_ASSERT(handle != NULL);
1420
1421
1422
1423
1424
1425
1426
1427
1428 lock_buffer(bh);
1429 BUFFER_TRACE(bh, "call get_create_access");
1430 fatal = ext4_journal_get_create_access(handle, bh);
1431 if (!fatal && !buffer_uptodate(bh)) {
1432 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
1433 set_buffer_uptodate(bh);
1434 }
1435 unlock_buffer(bh);
1436 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1437 err = ext4_handle_dirty_metadata(handle, inode, bh);
1438 if (!fatal)
1439 fatal = err;
1440 } else {
1441 BUFFER_TRACE(bh, "not a new buffer");
1442 }
1443 if (fatal) {
1444 *errp = fatal;
1445 brelse(bh);
1446 bh = NULL;
1447 }
1448 return bh;
1449 }
1450err:
1451 return NULL;
1452}
1453
1454struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
1455 ext4_lblk_t block, int create, int *err)
1456{
1457 struct buffer_head *bh;
1458
1459 bh = ext4_getblk(handle, inode, block, create, err);
1460 if (!bh)
1461 return bh;
1462 if (buffer_uptodate(bh))
1463 return bh;
1464 ll_rw_block(READ_META, 1, &bh);
1465 wait_on_buffer(bh);
1466 if (buffer_uptodate(bh))
1467 return bh;
1468 put_bh(bh);
1469 *err = -EIO;
1470 return NULL;
1471}
1472
1473static int walk_page_buffers(handle_t *handle,
1474 struct buffer_head *head,
1475 unsigned from,
1476 unsigned to,
1477 int *partial,
1478 int (*fn)(handle_t *handle,
1479 struct buffer_head *bh))
1480{
1481 struct buffer_head *bh;
1482 unsigned block_start, block_end;
1483 unsigned blocksize = head->b_size;
1484 int err, ret = 0;
1485 struct buffer_head *next;
1486
1487 for (bh = head, block_start = 0;
1488 ret == 0 && (bh != head || !block_start);
1489 block_start = block_end, bh = next) {
1490 next = bh->b_this_page;
1491 block_end = block_start + blocksize;
1492 if (block_end <= from || block_start >= to) {
1493 if (partial && !buffer_uptodate(bh))
1494 *partial = 1;
1495 continue;
1496 }
1497 err = (*fn)(handle, bh);
1498 if (!ret)
1499 ret = err;
1500 }
1501 return ret;
1502}
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529static int do_journal_get_write_access(handle_t *handle,
1530 struct buffer_head *bh)
1531{
1532 if (!buffer_mapped(bh) || buffer_freed(bh))
1533 return 0;
1534 return ext4_journal_get_write_access(handle, bh);
1535}
1536
1537static int ext4_write_begin(struct file *file, struct address_space *mapping,
1538 loff_t pos, unsigned len, unsigned flags,
1539 struct page **pagep, void **fsdata)
1540{
1541 struct inode *inode = mapping->host;
1542 int ret, needed_blocks;
1543 handle_t *handle;
1544 int retries = 0;
1545 struct page *page;
1546 pgoff_t index;
1547 unsigned from, to;
1548
1549 trace_ext4_write_begin(inode, pos, len, flags);
1550
1551
1552
1553
1554 needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
1555 index = pos >> PAGE_CACHE_SHIFT;
1556 from = pos & (PAGE_CACHE_SIZE - 1);
1557 to = from + len;
1558
1559retry:
1560 handle = ext4_journal_start(inode, needed_blocks);
1561 if (IS_ERR(handle)) {
1562 ret = PTR_ERR(handle);
1563 goto out;
1564 }
1565
1566
1567
1568 flags |= AOP_FLAG_NOFS;
1569
1570 page = grab_cache_page_write_begin(mapping, index, flags);
1571 if (!page) {
1572 ext4_journal_stop(handle);
1573 ret = -ENOMEM;
1574 goto out;
1575 }
1576 *pagep = page;
1577
1578 ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
1579 ext4_get_block);
1580
1581 if (!ret && ext4_should_journal_data(inode)) {
1582 ret = walk_page_buffers(handle, page_buffers(page),
1583 from, to, NULL, do_journal_get_write_access);
1584 }
1585
1586 if (ret) {
1587 unlock_page(page);
1588 page_cache_release(page);
1589
1590
1591
1592
1593
1594
1595
1596
1597 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1598 ext4_orphan_add(handle, inode);
1599
1600 ext4_journal_stop(handle);
1601 if (pos + len > inode->i_size) {
1602 ext4_truncate(inode);
1603
1604
1605
1606
1607
1608
1609 if (inode->i_nlink)
1610 ext4_orphan_del(NULL, inode);
1611 }
1612 }
1613
1614 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1615 goto retry;
1616out:
1617 return ret;
1618}
1619
1620
1621static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1622{
1623 if (!buffer_mapped(bh) || buffer_freed(bh))
1624 return 0;
1625 set_buffer_uptodate(bh);
1626 return ext4_handle_dirty_metadata(handle, NULL, bh);
1627}
1628
1629static int ext4_generic_write_end(struct file *file,
1630 struct address_space *mapping,
1631 loff_t pos, unsigned len, unsigned copied,
1632 struct page *page, void *fsdata)
1633{
1634 int i_size_changed = 0;
1635 struct inode *inode = mapping->host;
1636 handle_t *handle = ext4_journal_current_handle();
1637
1638 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1639
1640
1641
1642
1643
1644
1645
1646
1647 if (pos + copied > inode->i_size) {
1648 i_size_write(inode, pos + copied);
1649 i_size_changed = 1;
1650 }
1651
1652 if (pos + copied > EXT4_I(inode)->i_disksize) {
1653
1654
1655
1656
1657 ext4_update_i_disksize(inode, (pos + copied));
1658 i_size_changed = 1;
1659 }
1660 unlock_page(page);
1661 page_cache_release(page);
1662
1663
1664
1665
1666
1667
1668
1669 if (i_size_changed)
1670 ext4_mark_inode_dirty(handle, inode);
1671
1672 return copied;
1673}
1674
1675
1676
1677
1678
1679
1680
1681
1682static int ext4_ordered_write_end(struct file *file,
1683 struct address_space *mapping,
1684 loff_t pos, unsigned len, unsigned copied,
1685 struct page *page, void *fsdata)
1686{
1687 handle_t *handle = ext4_journal_current_handle();
1688 struct inode *inode = mapping->host;
1689 int ret = 0, ret2;
1690
1691 trace_ext4_ordered_write_end(inode, pos, len, copied);
1692 ret = ext4_jbd2_file_inode(handle, inode);
1693
1694 if (ret == 0) {
1695 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
1696 page, fsdata);
1697 copied = ret2;
1698 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1699
1700
1701
1702
1703 ext4_orphan_add(handle, inode);
1704 if (ret2 < 0)
1705 ret = ret2;
1706 }
1707 ret2 = ext4_journal_stop(handle);
1708 if (!ret)
1709 ret = ret2;
1710
1711 if (pos + len > inode->i_size) {
1712 ext4_truncate(inode);
1713
1714
1715
1716
1717
1718 if (inode->i_nlink)
1719 ext4_orphan_del(NULL, inode);
1720 }
1721
1722
1723 return ret ? ret : copied;
1724}
1725
1726static int ext4_writeback_write_end(struct file *file,
1727 struct address_space *mapping,
1728 loff_t pos, unsigned len, unsigned copied,
1729 struct page *page, void *fsdata)
1730{
1731 handle_t *handle = ext4_journal_current_handle();
1732 struct inode *inode = mapping->host;
1733 int ret = 0, ret2;
1734
1735 trace_ext4_writeback_write_end(inode, pos, len, copied);
1736 ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
1737 page, fsdata);
1738 copied = ret2;
1739 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1740
1741
1742
1743
1744 ext4_orphan_add(handle, inode);
1745
1746 if (ret2 < 0)
1747 ret = ret2;
1748
1749 ret2 = ext4_journal_stop(handle);
1750 if (!ret)
1751 ret = ret2;
1752
1753 if (pos + len > inode->i_size) {
1754 ext4_truncate(inode);
1755
1756
1757
1758
1759
1760 if (inode->i_nlink)
1761 ext4_orphan_del(NULL, inode);
1762 }
1763
1764 return ret ? ret : copied;
1765}
1766
1767static int ext4_journalled_write_end(struct file *file,
1768 struct address_space *mapping,
1769 loff_t pos, unsigned len, unsigned copied,
1770 struct page *page, void *fsdata)
1771{
1772 handle_t *handle = ext4_journal_current_handle();
1773 struct inode *inode = mapping->host;
1774 int ret = 0, ret2;
1775 int partial = 0;
1776 unsigned from, to;
1777 loff_t new_i_size;
1778
1779 trace_ext4_journalled_write_end(inode, pos, len, copied);
1780 from = pos & (PAGE_CACHE_SIZE - 1);
1781 to = from + len;
1782
1783 if (copied < len) {
1784 if (!PageUptodate(page))
1785 copied = 0;
1786 page_zero_new_buffers(page, from+copied, to);
1787 }
1788
1789 ret = walk_page_buffers(handle, page_buffers(page), from,
1790 to, &partial, write_end_fn);
1791 if (!partial)
1792 SetPageUptodate(page);
1793 new_i_size = pos + copied;
1794 if (new_i_size > inode->i_size)
1795 i_size_write(inode, pos+copied);
1796 EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
1797 if (new_i_size > EXT4_I(inode)->i_disksize) {
1798 ext4_update_i_disksize(inode, new_i_size);
1799 ret2 = ext4_mark_inode_dirty(handle, inode);
1800 if (!ret)
1801 ret = ret2;
1802 }
1803
1804 unlock_page(page);
1805 page_cache_release(page);
1806 if (pos + len > inode->i_size && ext4_can_truncate(inode))
1807
1808
1809
1810
1811 ext4_orphan_add(handle, inode);
1812
1813 ret2 = ext4_journal_stop(handle);
1814 if (!ret)
1815 ret = ret2;
1816 if (pos + len > inode->i_size) {
1817 ext4_truncate(inode);
1818
1819
1820
1821
1822
1823 if (inode->i_nlink)
1824 ext4_orphan_del(NULL, inode);
1825 }
1826
1827 return ret ? ret : copied;
1828}
1829
1830static int ext4_da_reserve_space(struct inode *inode, int nrblocks)
1831{
1832 int retries = 0;
1833 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1834 unsigned long md_needed, mdblocks, total = 0;
1835
1836
1837
1838
1839
1840
1841repeat:
1842 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1843 total = EXT4_I(inode)->i_reserved_data_blocks + nrblocks;
1844 mdblocks = ext4_calc_metadata_amount(inode, total);
1845 BUG_ON(mdblocks < EXT4_I(inode)->i_reserved_meta_blocks);
1846
1847 md_needed = mdblocks - EXT4_I(inode)->i_reserved_meta_blocks;
1848 total = md_needed + nrblocks;
1849
1850
1851
1852
1853
1854
1855 if (vfs_dq_reserve_block(inode, total)) {
1856 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1857 return -EDQUOT;
1858 }
1859
1860 if (ext4_claim_free_blocks(sbi, total)) {
1861 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1862 vfs_dq_release_reservation_block(inode, total);
1863 if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
1864 yield();
1865 goto repeat;
1866 }
1867 return -ENOSPC;
1868 }
1869 EXT4_I(inode)->i_reserved_data_blocks += nrblocks;
1870 EXT4_I(inode)->i_reserved_meta_blocks = mdblocks;
1871
1872 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1873 return 0;
1874}
1875
1876static void ext4_da_release_space(struct inode *inode, int to_free)
1877{
1878 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1879 int total, mdb, mdb_free, release;
1880
1881 if (!to_free)
1882 return;
1883
1884 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1885
1886 if (!EXT4_I(inode)->i_reserved_data_blocks) {
1887
1888
1889
1890
1891
1892
1893 printk(KERN_INFO "ext4 delalloc try to release %d reserved "
1894 "blocks for inode %lu, but there is no reserved "
1895 "data blocks\n", to_free, inode->i_ino);
1896 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1897 return;
1898 }
1899
1900
1901 total = EXT4_I(inode)->i_reserved_data_blocks - to_free;
1902 mdb = ext4_calc_metadata_amount(inode, total);
1903
1904
1905 BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1906 mdb_free = EXT4_I(inode)->i_reserved_meta_blocks - mdb;
1907
1908 release = to_free + mdb_free;
1909
1910
1911 percpu_counter_sub(&sbi->s_dirtyblocks_counter, release);
1912
1913
1914 BUG_ON(to_free > EXT4_I(inode)->i_reserved_data_blocks);
1915 EXT4_I(inode)->i_reserved_data_blocks -= to_free;
1916
1917 BUG_ON(mdb > EXT4_I(inode)->i_reserved_meta_blocks);
1918 EXT4_I(inode)->i_reserved_meta_blocks = mdb;
1919 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1920
1921 vfs_dq_release_reservation_block(inode, release);
1922}
1923
1924static void ext4_da_page_release_reservation(struct page *page,
1925 unsigned long offset)
1926{
1927 int to_release = 0;
1928 struct buffer_head *head, *bh;
1929 unsigned int curr_off = 0;
1930
1931 head = page_buffers(page);
1932 bh = head;
1933 do {
1934 unsigned int next_off = curr_off + bh->b_size;
1935
1936 if ((offset <= curr_off) && (buffer_delay(bh))) {
1937 to_release++;
1938 clear_buffer_delay(bh);
1939 }
1940 curr_off = next_off;
1941 } while ((bh = bh->b_this_page) != head);
1942 ext4_da_release_space(page->mapping->host, to_release);
1943}
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962static int mpage_da_submit_io(struct mpage_da_data *mpd)
1963{
1964 long pages_skipped;
1965 struct pagevec pvec;
1966 unsigned long index, end;
1967 int ret = 0, err, nr_pages, i;
1968 struct inode *inode = mpd->inode;
1969 struct address_space *mapping = inode->i_mapping;
1970
1971 BUG_ON(mpd->next_page <= mpd->first_page);
1972
1973
1974
1975
1976
1977
1978 index = mpd->first_page;
1979 end = mpd->next_page - 1;
1980
1981 pagevec_init(&pvec, 0);
1982 while (index <= end) {
1983 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1984 if (nr_pages == 0)
1985 break;
1986 for (i = 0; i < nr_pages; i++) {
1987 struct page *page = pvec.pages[i];
1988
1989 index = page->index;
1990 if (index > end)
1991 break;
1992 index++;
1993
1994 BUG_ON(!PageLocked(page));
1995 BUG_ON(PageWriteback(page));
1996
1997 pages_skipped = mpd->wbc->pages_skipped;
1998 err = mapping->a_ops->writepage(page, mpd->wbc);
1999 if (!err && (pages_skipped == mpd->wbc->pages_skipped))
2000
2001
2002
2003
2004 mpd->pages_written++;
2005
2006
2007
2008
2009
2010 if (ret == 0)
2011 ret = err;
2012 }
2013 pagevec_release(&pvec);
2014 }
2015 return ret;
2016}
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029static void mpage_put_bnr_to_bhs(struct mpage_da_data *mpd, sector_t logical,
2030 struct buffer_head *exbh)
2031{
2032 struct inode *inode = mpd->inode;
2033 struct address_space *mapping = inode->i_mapping;
2034 int blocks = exbh->b_size >> inode->i_blkbits;
2035 sector_t pblock = exbh->b_blocknr, cur_logical;
2036 struct buffer_head *head, *bh;
2037 pgoff_t index, end;
2038 struct pagevec pvec;
2039 int nr_pages, i;
2040
2041 index = logical >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
2042 end = (logical + blocks - 1) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
2043 cur_logical = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
2044
2045 pagevec_init(&pvec, 0);
2046
2047 while (index <= end) {
2048
2049 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
2050 if (nr_pages == 0)
2051 break;
2052 for (i = 0; i < nr_pages; i++) {
2053 struct page *page = pvec.pages[i];
2054
2055 index = page->index;
2056 if (index > end)
2057 break;
2058 index++;
2059
2060 BUG_ON(!PageLocked(page));
2061 BUG_ON(PageWriteback(page));
2062 BUG_ON(!page_has_buffers(page));
2063
2064 bh = page_buffers(page);
2065 head = bh;
2066
2067
2068 do {
2069 if (cur_logical >= logical)
2070 break;
2071 cur_logical++;
2072 } while ((bh = bh->b_this_page) != head);
2073
2074 do {
2075 if (cur_logical >= logical + blocks)
2076 break;
2077
2078 if (buffer_delay(bh) ||
2079 buffer_unwritten(bh)) {
2080
2081 BUG_ON(bh->b_bdev != inode->i_sb->s_bdev);
2082
2083 if (buffer_delay(bh)) {
2084 clear_buffer_delay(bh);
2085 bh->b_blocknr = pblock;
2086 } else {
2087
2088
2089
2090
2091 clear_buffer_unwritten(bh);
2092 BUG_ON(bh->b_blocknr != pblock);
2093 }
2094
2095 } else if (buffer_mapped(bh))
2096 BUG_ON(bh->b_blocknr != pblock);
2097
2098 cur_logical++;
2099 pblock++;
2100 } while ((bh = bh->b_this_page) != head);
2101 }
2102 pagevec_release(&pvec);
2103 }
2104}
2105
2106
2107
2108
2109
2110
2111static inline void __unmap_underlying_blocks(struct inode *inode,
2112 struct buffer_head *bh)
2113{
2114 struct block_device *bdev = inode->i_sb->s_bdev;
2115 int blocks, i;
2116
2117 blocks = bh->b_size >> inode->i_blkbits;
2118 for (i = 0; i < blocks; i++)
2119 unmap_underlying_metadata(bdev, bh->b_blocknr + i);
2120}
2121
2122static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd,
2123 sector_t logical, long blk_cnt)
2124{
2125 int nr_pages, i;
2126 pgoff_t index, end;
2127 struct pagevec pvec;
2128 struct inode *inode = mpd->inode;
2129 struct address_space *mapping = inode->i_mapping;
2130
2131 index = logical >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
2132 end = (logical + blk_cnt - 1) >>
2133 (PAGE_CACHE_SHIFT - inode->i_blkbits);
2134 while (index <= end) {
2135 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
2136 if (nr_pages == 0)
2137 break;
2138 for (i = 0; i < nr_pages; i++) {
2139 struct page *page = pvec.pages[i];
2140 index = page->index;
2141 if (index > end)
2142 break;
2143 index++;
2144
2145 BUG_ON(!PageLocked(page));
2146 BUG_ON(PageWriteback(page));
2147 block_invalidatepage(page, 0);
2148 ClearPageUptodate(page);
2149 unlock_page(page);
2150 }
2151 }
2152 return;
2153}
2154
2155static void ext4_print_free_blocks(struct inode *inode)
2156{
2157 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2158 printk(KERN_CRIT "Total free blocks count %lld\n",
2159 ext4_count_free_blocks(inode->i_sb));
2160 printk(KERN_CRIT "Free/Dirty block details\n");
2161 printk(KERN_CRIT "free_blocks=%lld\n",
2162 (long long) percpu_counter_sum(&sbi->s_freeblocks_counter));
2163 printk(KERN_CRIT "dirty_blocks=%lld\n",
2164 (long long) percpu_counter_sum(&sbi->s_dirtyblocks_counter));
2165 printk(KERN_CRIT "Block reservation details\n");
2166 printk(KERN_CRIT "i_reserved_data_blocks=%u\n",
2167 EXT4_I(inode)->i_reserved_data_blocks);
2168 printk(KERN_CRIT "i_reserved_meta_blocks=%u\n",
2169 EXT4_I(inode)->i_reserved_meta_blocks);
2170 return;
2171}
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181static int mpage_da_map_blocks(struct mpage_da_data *mpd)
2182{
2183 int err, blks, get_blocks_flags;
2184 struct buffer_head new;
2185 sector_t next = mpd->b_blocknr;
2186 unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
2187 loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
2188 handle_t *handle = NULL;
2189
2190
2191
2192
2193 if ((mpd->b_state & (1 << BH_Mapped)) &&
2194 !(mpd->b_state & (1 << BH_Delay)) &&
2195 !(mpd->b_state & (1 << BH_Unwritten)))
2196 return 0;
2197
2198
2199
2200
2201 if (!mpd->b_size)
2202 return 0;
2203
2204 handle = ext4_journal_current_handle();
2205 BUG_ON(!handle);
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225 new.b_state = 0;
2226 get_blocks_flags = (EXT4_GET_BLOCKS_CREATE |
2227 EXT4_GET_BLOCKS_DELALLOC_RESERVE);
2228 if (mpd->b_state & (1 << BH_Delay))
2229 get_blocks_flags |= EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE;
2230 blks = ext4_get_blocks(handle, mpd->inode, next, max_blocks,
2231 &new, get_blocks_flags);
2232 if (blks < 0) {
2233 err = blks;
2234
2235
2236
2237
2238
2239 if (err == -EAGAIN)
2240 return 0;
2241
2242 if (err == -ENOSPC &&
2243 ext4_count_free_blocks(mpd->inode->i_sb)) {
2244 mpd->retval = err;
2245 return 0;
2246 }
2247
2248
2249
2250
2251
2252
2253
2254
2255 ext4_msg(mpd->inode->i_sb, KERN_CRIT,
2256 "delayed block allocation failed for inode %lu at "
2257 "logical offset %llu with max blocks %zd with "
2258 "error %d\n", mpd->inode->i_ino,
2259 (unsigned long long) next,
2260 mpd->b_size >> mpd->inode->i_blkbits, err);
2261 printk(KERN_CRIT "This should not happen!! "
2262 "Data will be lost\n");
2263 if (err == -ENOSPC) {
2264 ext4_print_free_blocks(mpd->inode);
2265 }
2266
2267 ext4_da_block_invalidatepages(mpd, next,
2268 mpd->b_size >> mpd->inode->i_blkbits);
2269 return err;
2270 }
2271 BUG_ON(blks == 0);
2272
2273 new.b_size = (blks << mpd->inode->i_blkbits);
2274
2275 if (buffer_new(&new))
2276 __unmap_underlying_blocks(mpd->inode, &new);
2277
2278
2279
2280
2281
2282 if ((mpd->b_state & (1 << BH_Delay)) ||
2283 (mpd->b_state & (1 << BH_Unwritten)))
2284 mpage_put_bnr_to_bhs(mpd, next, &new);
2285
2286 if (ext4_should_order_data(mpd->inode)) {
2287 err = ext4_jbd2_file_inode(handle, mpd->inode);
2288 if (err)
2289 return err;
2290 }
2291
2292
2293
2294
2295 disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
2296 if (disksize > i_size_read(mpd->inode))
2297 disksize = i_size_read(mpd->inode);
2298 if (disksize > EXT4_I(mpd->inode)->i_disksize) {
2299 ext4_update_i_disksize(mpd->inode, disksize);
2300 return ext4_mark_inode_dirty(handle, mpd->inode);
2301 }
2302
2303 return 0;
2304}
2305
2306#define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
2307 (1 << BH_Delay) | (1 << BH_Unwritten))
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
2319 sector_t logical, size_t b_size,
2320 unsigned long b_state)
2321{
2322 sector_t next;
2323 int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
2324
2325
2326 if (!(EXT4_I(mpd->inode)->i_flags & EXT4_EXTENTS_FL)) {
2327 if (nrblocks >= EXT4_MAX_TRANS_DATA) {
2328
2329
2330
2331
2332
2333
2334 goto flush_it;
2335 } else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
2336 EXT4_MAX_TRANS_DATA) {
2337
2338
2339
2340
2341
2342 b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
2343 mpd->inode->i_blkbits;
2344
2345 }
2346 }
2347
2348
2349
2350 if (mpd->b_size == 0) {
2351 mpd->b_blocknr = logical;
2352 mpd->b_size = b_size;
2353 mpd->b_state = b_state & BH_FLAGS;
2354 return;
2355 }
2356
2357 next = mpd->b_blocknr + nrblocks;
2358
2359
2360
2361 if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
2362 mpd->b_size += b_size;
2363 return;
2364 }
2365
2366flush_it:
2367
2368
2369
2370
2371 if (mpage_da_map_blocks(mpd) == 0)
2372 mpage_da_submit_io(mpd);
2373 mpd->io_done = 1;
2374 return;
2375}
2376
2377static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
2378{
2379 return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
2380}
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391static int __mpage_da_writepage(struct page *page,
2392 struct writeback_control *wbc, void *data)
2393{
2394 struct mpage_da_data *mpd = data;
2395 struct inode *inode = mpd->inode;
2396 struct buffer_head *bh, *head;
2397 sector_t logical;
2398
2399 if (mpd->io_done) {
2400
2401
2402
2403
2404
2405
2406 redirty_page_for_writepage(wbc, page);
2407 unlock_page(page);
2408 return MPAGE_DA_EXTENT_TAIL;
2409 }
2410
2411
2412
2413 if (mpd->next_page != page->index) {
2414
2415
2416
2417
2418 if (mpd->next_page != mpd->first_page) {
2419 if (mpage_da_map_blocks(mpd) == 0)
2420 mpage_da_submit_io(mpd);
2421
2422
2423
2424 mpd->io_done = 1;
2425 redirty_page_for_writepage(wbc, page);
2426 unlock_page(page);
2427 return MPAGE_DA_EXTENT_TAIL;
2428 }
2429
2430
2431
2432
2433 mpd->first_page = page->index;
2434
2435
2436
2437
2438 mpd->b_size = 0;
2439 mpd->b_state = 0;
2440 mpd->b_blocknr = 0;
2441 }
2442
2443 mpd->next_page = page->index + 1;
2444 logical = (sector_t) page->index <<
2445 (PAGE_CACHE_SHIFT - inode->i_blkbits);
2446
2447 if (!page_has_buffers(page)) {
2448 mpage_add_bh_to_extent(mpd, logical, PAGE_CACHE_SIZE,
2449 (1 << BH_Dirty) | (1 << BH_Uptodate));
2450 if (mpd->io_done)
2451 return MPAGE_DA_EXTENT_TAIL;
2452 } else {
2453
2454
2455
2456 head = page_buffers(page);
2457 bh = head;
2458 do {
2459 BUG_ON(buffer_locked(bh));
2460
2461
2462
2463
2464
2465
2466 if (ext4_bh_delay_or_unwritten(NULL, bh)) {
2467 mpage_add_bh_to_extent(mpd, logical,
2468 bh->b_size,
2469 bh->b_state);
2470 if (mpd->io_done)
2471 return MPAGE_DA_EXTENT_TAIL;
2472 } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
2473
2474
2475
2476
2477
2478
2479
2480
2481 if (mpd->b_size == 0)
2482 mpd->b_state = bh->b_state & BH_FLAGS;
2483 }
2484 logical++;
2485 } while ((bh = bh->b_this_page) != head);
2486 }
2487
2488 return 0;
2489}
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
2504 struct buffer_head *bh_result, int create)
2505{
2506 int ret = 0;
2507 sector_t invalid_block = ~((sector_t) 0xffff);
2508
2509 if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
2510 invalid_block = ~0;
2511
2512 BUG_ON(create == 0);
2513 BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
2514
2515
2516
2517
2518
2519
2520 ret = ext4_get_blocks(NULL, inode, iblock, 1, bh_result, 0);
2521 if ((ret == 0) && !buffer_delay(bh_result)) {
2522
2523
2524
2525
2526
2527 ret = ext4_da_reserve_space(inode, 1);
2528 if (ret)
2529
2530 return ret;
2531
2532 map_bh(bh_result, inode->i_sb, invalid_block);
2533 set_buffer_new(bh_result);
2534 set_buffer_delay(bh_result);
2535 } else if (ret > 0) {
2536 bh_result->b_size = (ret << inode->i_blkbits);
2537 if (buffer_unwritten(bh_result)) {
2538
2539
2540
2541
2542
2543
2544
2545 set_buffer_new(bh_result);
2546 set_buffer_mapped(bh_result);
2547 }
2548 ret = 0;
2549 }
2550
2551 return ret;
2552}
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
2571 struct buffer_head *bh_result, int create)
2572{
2573 int ret = 0;
2574 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
2575
2576 BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
2577
2578
2579
2580
2581
2582 ret = ext4_get_blocks(NULL, inode, iblock, max_blocks, bh_result, 0);
2583 if (ret > 0) {
2584 bh_result->b_size = (ret << inode->i_blkbits);
2585 ret = 0;
2586 }
2587 return ret;
2588}
2589
2590static int bget_one(handle_t *handle, struct buffer_head *bh)
2591{
2592 get_bh(bh);
2593 return 0;
2594}
2595
2596static int bput_one(handle_t *handle, struct buffer_head *bh)
2597{
2598 put_bh(bh);
2599 return 0;
2600}
2601
2602static int __ext4_journalled_writepage(struct page *page,
2603 struct writeback_control *wbc,
2604 unsigned int len)
2605{
2606 struct address_space *mapping = page->mapping;
2607 struct inode *inode = mapping->host;
2608 struct buffer_head *page_bufs;
2609 handle_t *handle = NULL;
2610 int ret = 0;
2611 int err;
2612
2613 page_bufs = page_buffers(page);
2614 BUG_ON(!page_bufs);
2615 walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
2616
2617
2618 unlock_page(page);
2619
2620 handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
2621 if (IS_ERR(handle)) {
2622 ret = PTR_ERR(handle);
2623 goto out;
2624 }
2625
2626 ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
2627 do_journal_get_write_access);
2628
2629 err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
2630 write_end_fn);
2631 if (ret == 0)
2632 ret = err;
2633 err = ext4_journal_stop(handle);
2634 if (!ret)
2635 ret = err;
2636
2637 walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
2638 EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
2639out:
2640 return ret;
2641}
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684static int ext4_writepage(struct page *page,
2685 struct writeback_control *wbc)
2686{
2687 int ret = 0;
2688 loff_t size;
2689 unsigned int len;
2690 struct buffer_head *page_bufs;
2691 struct inode *inode = page->mapping->host;
2692
2693 trace_ext4_writepage(inode, page);
2694 size = i_size_read(inode);
2695 if (page->index == size >> PAGE_CACHE_SHIFT)
2696 len = size & ~PAGE_CACHE_MASK;
2697 else
2698 len = PAGE_CACHE_SIZE;
2699
2700 if (page_has_buffers(page)) {
2701 page_bufs = page_buffers(page);
2702 if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2703 ext4_bh_delay_or_unwritten)) {
2704
2705
2706
2707
2708
2709
2710
2711
2712 redirty_page_for_writepage(wbc, page);
2713 unlock_page(page);
2714 return 0;
2715 }
2716 } else {
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730 ret = block_prepare_write(page, 0, len,
2731 noalloc_get_block_write);
2732 if (!ret) {
2733 page_bufs = page_buffers(page);
2734
2735 if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
2736 ext4_bh_delay_or_unwritten)) {
2737 redirty_page_for_writepage(wbc, page);
2738 unlock_page(page);
2739 return 0;
2740 }
2741 } else {
2742
2743
2744
2745
2746
2747 redirty_page_for_writepage(wbc, page);
2748 unlock_page(page);
2749 return 0;
2750 }
2751
2752 block_commit_write(page, 0, len);
2753 }
2754
2755 if (PageChecked(page) && ext4_should_journal_data(inode)) {
2756
2757
2758
2759
2760 ClearPageChecked(page);
2761 return __ext4_journalled_writepage(page, wbc, len);
2762 }
2763
2764 if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
2765 ret = nobh_writepage(page, noalloc_get_block_write, wbc);
2766 else
2767 ret = block_write_full_page(page, noalloc_get_block_write,
2768 wbc);
2769
2770 return ret;
2771}
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781static int ext4_da_writepages_trans_blocks(struct inode *inode)
2782{
2783 int max_blocks = EXT4_I(inode)->i_reserved_data_blocks;
2784
2785
2786
2787
2788
2789
2790
2791 if (!(inode->i_flags & EXT4_EXTENTS_FL) &&
2792 (max_blocks > EXT4_MAX_TRANS_DATA))
2793 max_blocks = EXT4_MAX_TRANS_DATA;
2794
2795 return ext4_chunk_trans_blocks(inode, max_blocks);
2796}
2797
2798static int ext4_da_writepages(struct address_space *mapping,
2799 struct writeback_control *wbc)
2800{
2801 pgoff_t index;
2802 int range_whole = 0;
2803 handle_t *handle = NULL;
2804 struct mpage_da_data mpd;
2805 struct inode *inode = mapping->host;
2806 int no_nrwrite_index_update;
2807 int pages_written = 0;
2808 long pages_skipped;
2809 unsigned int max_pages;
2810 int range_cyclic, cycled = 1, io_done = 0;
2811 int needed_blocks, ret = 0;
2812 long desired_nr_to_write, nr_to_writebump = 0;
2813 loff_t range_start = wbc->range_start;
2814 struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2815
2816 trace_ext4_da_writepages(inode, wbc);
2817
2818
2819
2820
2821
2822
2823 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2824 return 0;
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836 if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2837 return -EROFS;
2838
2839 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2840 range_whole = 1;
2841
2842 range_cyclic = wbc->range_cyclic;
2843 if (wbc->range_cyclic) {
2844 index = mapping->writeback_index;
2845 if (index)
2846 cycled = 0;
2847 wbc->range_start = index << PAGE_CACHE_SHIFT;
2848 wbc->range_end = LLONG_MAX;
2849 wbc->range_cyclic = 0;
2850 } else
2851 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869 max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
2870 if (!range_cyclic && range_whole)
2871 desired_nr_to_write = wbc->nr_to_write * 8;
2872 else
2873 desired_nr_to_write = ext4_num_dirty_pages(inode, index,
2874 max_pages);
2875 if (desired_nr_to_write > max_pages)
2876 desired_nr_to_write = max_pages;
2877
2878 if (wbc->nr_to_write < desired_nr_to_write) {
2879 nr_to_writebump = desired_nr_to_write - wbc->nr_to_write;
2880 wbc->nr_to_write = desired_nr_to_write;
2881 }
2882
2883 mpd.wbc = wbc;
2884 mpd.inode = mapping->host;
2885
2886
2887
2888
2889
2890 no_nrwrite_index_update = wbc->no_nrwrite_index_update;
2891 wbc->no_nrwrite_index_update = 1;
2892 pages_skipped = wbc->pages_skipped;
2893
2894retry:
2895 while (!ret && wbc->nr_to_write > 0) {
2896
2897
2898
2899
2900
2901
2902
2903 BUG_ON(ext4_should_journal_data(inode));
2904 needed_blocks = ext4_da_writepages_trans_blocks(inode);
2905
2906
2907 handle = ext4_journal_start(inode, needed_blocks);
2908 if (IS_ERR(handle)) {
2909 ret = PTR_ERR(handle);
2910 ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2911 "%ld pages, ino %lu; err %d\n", __func__,
2912 wbc->nr_to_write, inode->i_ino, ret);
2913 goto out_writepages;
2914 }
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925 mpd.b_size = 0;
2926 mpd.b_state = 0;
2927 mpd.b_blocknr = 0;
2928 mpd.first_page = 0;
2929 mpd.next_page = 0;
2930 mpd.io_done = 0;
2931 mpd.pages_written = 0;
2932 mpd.retval = 0;
2933 ret = write_cache_pages(mapping, wbc, __mpage_da_writepage,
2934 &mpd);
2935
2936
2937
2938
2939
2940 if (!mpd.io_done && mpd.next_page != mpd.first_page) {
2941 if (mpage_da_map_blocks(&mpd) == 0)
2942 mpage_da_submit_io(&mpd);
2943 mpd.io_done = 1;
2944 ret = MPAGE_DA_EXTENT_TAIL;
2945 }
2946 trace_ext4_da_write_pages(inode, &mpd);
2947 wbc->nr_to_write -= mpd.pages_written;
2948
2949 ext4_journal_stop(handle);
2950
2951 if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2952
2953
2954
2955
2956 jbd2_journal_force_commit_nested(sbi->s_journal);
2957 wbc->pages_skipped = pages_skipped;
2958 ret = 0;
2959 } else if (ret == MPAGE_DA_EXTENT_TAIL) {
2960
2961
2962
2963
2964 pages_written += mpd.pages_written;
2965 wbc->pages_skipped = pages_skipped;
2966 ret = 0;
2967 io_done = 1;
2968 } else if (wbc->nr_to_write)
2969
2970
2971
2972
2973
2974 break;
2975 }
2976 if (!io_done && !cycled) {
2977 cycled = 1;
2978 index = 0;
2979 wbc->range_start = index << PAGE_CACHE_SHIFT;
2980 wbc->range_end = mapping->writeback_index - 1;
2981 goto retry;
2982 }
2983 if (pages_skipped != wbc->pages_skipped)
2984 ext4_msg(inode->i_sb, KERN_CRIT,
2985 "This should not happen leaving %s "
2986 "with nr_to_write = %ld ret = %d\n",
2987 __func__, wbc->nr_to_write, ret);
2988
2989
2990 index += pages_written;
2991 wbc->range_cyclic = range_cyclic;
2992 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2993
2994
2995
2996
2997 mapping->writeback_index = index;
2998
2999out_writepages:
3000 if (!no_nrwrite_index_update)
3001 wbc->no_nrwrite_index_update = 0;
3002 if (wbc->nr_to_write > nr_to_writebump)
3003 wbc->nr_to_write -= nr_to_writebump;
3004 wbc->range_start = range_start;
3005 trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
3006 return ret;
3007}
3008
3009#define FALL_BACK_TO_NONDELALLOC 1
3010static int ext4_nonda_switch(struct super_block *sb)
3011{
3012 s64 free_blocks, dirty_blocks;
3013 struct ext4_sb_info *sbi = EXT4_SB(sb);
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023 free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
3024 dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyblocks_counter);
3025 if (2 * free_blocks < 3 * dirty_blocks ||
3026 free_blocks < (dirty_blocks + EXT4_FREEBLOCKS_WATERMARK)) {
3027
3028
3029
3030
3031 return 1;
3032 }
3033 return 0;
3034}
3035
3036static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
3037 loff_t pos, unsigned len, unsigned flags,
3038 struct page **pagep, void **fsdata)
3039{
3040 int ret, retries = 0;
3041 struct page *page;
3042 pgoff_t index;
3043 unsigned from, to;
3044 struct inode *inode = mapping->host;
3045 handle_t *handle;
3046
3047 index = pos >> PAGE_CACHE_SHIFT;
3048 from = pos & (PAGE_CACHE_SIZE - 1);
3049 to = from + len;
3050
3051 if (ext4_nonda_switch(inode->i_sb)) {
3052 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
3053 return ext4_write_begin(file, mapping, pos,
3054 len, flags, pagep, fsdata);
3055 }
3056 *fsdata = (void *)0;
3057 trace_ext4_da_write_begin(inode, pos, len, flags);
3058retry:
3059
3060
3061
3062
3063
3064
3065 handle = ext4_journal_start(inode, 1);
3066 if (IS_ERR(handle)) {
3067 ret = PTR_ERR(handle);
3068 goto out;
3069 }
3070
3071
3072 flags |= AOP_FLAG_NOFS;
3073
3074 page = grab_cache_page_write_begin(mapping, index, flags);
3075 if (!page) {
3076 ext4_journal_stop(handle);
3077 ret = -ENOMEM;
3078 goto out;
3079 }
3080 *pagep = page;
3081
3082 ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
3083 ext4_da_get_block_prep);
3084 if (ret < 0) {
3085 unlock_page(page);
3086 ext4_journal_stop(handle);
3087 page_cache_release(page);
3088
3089
3090
3091
3092
3093 if (pos + len > inode->i_size)
3094 ext4_truncate(inode);
3095 }
3096
3097 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
3098 goto retry;
3099out:
3100 return ret;
3101}
3102
3103
3104
3105
3106
3107static int ext4_da_should_update_i_disksize(struct page *page,
3108 unsigned long offset)
3109{
3110 struct buffer_head *bh;
3111 struct inode *inode = page->mapping->host;
3112 unsigned int idx;
3113 int i;
3114
3115 bh = page_buffers(page);
3116 idx = offset >> inode->i_blkbits;
3117
3118 for (i = 0; i < idx; i++)
3119 bh = bh->b_this_page;
3120
3121 if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
3122 return 0;
3123 return 1;
3124}
3125
3126static int ext4_da_write_end(struct file *file,
3127 struct address_space *mapping,
3128 loff_t pos, unsigned len, unsigned copied,
3129 struct page *page, void *fsdata)
3130{
3131 struct inode *inode = mapping->host;
3132 int ret = 0, ret2;
3133 handle_t *handle = ext4_journal_current_handle();
3134 loff_t new_i_size;
3135 unsigned long start, end;
3136 int write_mode = (int)(unsigned long)fsdata;
3137
3138 if (write_mode == FALL_BACK_TO_NONDELALLOC) {
3139 if (ext4_should_order_data(inode)) {
3140 return ext4_ordered_write_end(file, mapping, pos,
3141 len, copied, page, fsdata);
3142 } else if (ext4_should_writeback_data(inode)) {
3143 return ext4_writeback_write_end(file, mapping, pos,
3144 len, copied, page, fsdata);
3145 } else {
3146 BUG();
3147 }
3148 }
3149
3150 trace_ext4_da_write_end(inode, pos, len, copied);
3151 start = pos & (PAGE_CACHE_SIZE - 1);
3152 end = start + copied - 1;
3153
3154
3155
3156
3157
3158
3159
3160 new_i_size = pos + copied;
3161 if (new_i_size > EXT4_I(inode)->i_disksize) {
3162 if (ext4_da_should_update_i_disksize(page, end)) {
3163 down_write(&EXT4_I(inode)->i_data_sem);
3164 if (new_i_size > EXT4_I(inode)->i_disksize) {
3165
3166
3167
3168
3169 if (ext4_should_order_data(inode))
3170 ret = ext4_jbd2_file_inode(handle,
3171 inode);
3172
3173 EXT4_I(inode)->i_disksize = new_i_size;
3174 }
3175 up_write(&EXT4_I(inode)->i_data_sem);
3176
3177
3178
3179
3180 ext4_mark_inode_dirty(handle, inode);
3181 }
3182 }
3183 ret2 = generic_write_end(file, mapping, pos, len, copied,
3184 page, fsdata);
3185 copied = ret2;
3186 if (ret2 < 0)
3187 ret = ret2;
3188 ret2 = ext4_journal_stop(handle);
3189 if (!ret)
3190 ret = ret2;
3191
3192 return ret ? ret : copied;
3193}
3194
3195static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
3196{
3197
3198
3199
3200 BUG_ON(!PageLocked(page));
3201 if (!page_has_buffers(page))
3202 goto out;
3203
3204 ext4_da_page_release_reservation(page, offset);
3205
3206out:
3207 ext4_invalidatepage(page, offset);
3208
3209 return;
3210}
3211
3212
3213
3214
3215int ext4_alloc_da_blocks(struct inode *inode)
3216{
3217 trace_ext4_alloc_da_blocks(inode);
3218
3219 if (!EXT4_I(inode)->i_reserved_data_blocks &&
3220 !EXT4_I(inode)->i_reserved_meta_blocks)
3221 return 0;
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254 return filemap_flush(inode->i_mapping);
3255}
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
3272{
3273 struct inode *inode = mapping->host;
3274 journal_t *journal;
3275 int err;
3276
3277 if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
3278 test_opt(inode->i_sb, DELALLOC)) {
3279
3280
3281
3282
3283
3284 filemap_write_and_wait(mapping);
3285 }
3286
3287 if (EXT4_JOURNAL(inode) && EXT4_I(inode)->i_state & EXT4_STATE_JDATA) {
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306 EXT4_I(inode)->i_state &= ~EXT4_STATE_JDATA;
3307 journal = EXT4_JOURNAL(inode);
3308 jbd2_journal_lock_updates(journal);
3309 err = jbd2_journal_flush(journal);
3310 jbd2_journal_unlock_updates(journal);
3311
3312 if (err)
3313 return 0;
3314 }
3315
3316 return generic_block_bmap(mapping, block, ext4_get_block);
3317}
3318
3319static int ext4_readpage(struct file *file, struct page *page)
3320{
3321 return mpage_readpage(page, ext4_get_block);
3322}
3323
3324static int
3325ext4_readpages(struct file *file, struct address_space *mapping,
3326 struct list_head *pages, unsigned nr_pages)
3327{
3328 return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
3329}
3330
3331static void ext4_invalidatepage(struct page *page, unsigned long offset)
3332{
3333 journal_t *journal = EXT4_JOURNAL(page->mapping->host);
3334
3335
3336
3337
3338 if (offset == 0)
3339 ClearPageChecked(page);
3340
3341 if (journal)
3342 jbd2_journal_invalidatepage(journal, page, offset);
3343 else
3344 block_invalidatepage(page, offset);
3345}
3346
3347static int ext4_releasepage(struct page *page, gfp_t wait)
3348{
3349 journal_t *journal = EXT4_JOURNAL(page->mapping->host);
3350
3351 WARN_ON(PageChecked(page));
3352 if (!page_has_buffers(page))
3353 return 0;
3354 if (journal)
3355 return jbd2_journal_try_to_free_buffers(journal, page, wait);
3356 else
3357 return try_to_free_buffers(page);
3358}
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371static ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb,
3372 const struct iovec *iov, loff_t offset,
3373 unsigned long nr_segs)
3374{
3375 struct file *file = iocb->ki_filp;
3376 struct inode *inode = file->f_mapping->host;
3377 struct ext4_inode_info *ei = EXT4_I(inode);
3378 handle_t *handle;
3379 ssize_t ret;
3380 int orphan = 0;
3381 size_t count = iov_length(iov, nr_segs);
3382 int retries = 0;
3383
3384 if (rw == WRITE) {
3385 loff_t final_size = offset + count;
3386
3387 if (final_size > inode->i_size) {
3388
3389 handle = ext4_journal_start(inode, 2);
3390 if (IS_ERR(handle)) {
3391 ret = PTR_ERR(handle);
3392 goto out;
3393 }
3394 ret = ext4_orphan_add(handle, inode);
3395 if (ret) {
3396 ext4_journal_stop(handle);
3397 goto out;
3398 }
3399 orphan = 1;
3400 ei->i_disksize = inode->i_size;
3401 ext4_journal_stop(handle);
3402 }
3403 }
3404
3405retry:
3406 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
3407 offset, nr_segs,
3408 ext4_get_block, NULL);
3409 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
3410 goto retry;
3411
3412 if (orphan) {
3413 int err;
3414
3415
3416 handle = ext4_journal_start(inode, 2);
3417 if (IS_ERR(handle)) {
3418
3419
3420
3421 ret = PTR_ERR(handle);
3422 goto out;
3423 }
3424 if (inode->i_nlink)
3425 ext4_orphan_del(handle, inode);
3426 if (ret > 0) {
3427 loff_t end = offset + ret;
3428 if (end > inode->i_size) {
3429 ei->i_disksize = end;
3430 i_size_write(inode, end);
3431
3432
3433
3434
3435
3436
3437
3438 ext4_mark_inode_dirty(handle, inode);
3439 }
3440 }
3441 err = ext4_journal_stop(handle);
3442 if (ret == 0)
3443 ret = err;
3444 }
3445out:
3446 return ret;
3447}
3448
3449static int ext4_get_block_dio_write(struct inode *inode, sector_t iblock,
3450 struct buffer_head *bh_result, int create)
3451{
3452 handle_t *handle = NULL;
3453 int ret = 0;
3454 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
3455 int dio_credits;
3456
3457 ext4_debug("ext4_get_block_dio_write: inode %lu, create flag %d\n",
3458 inode->i_ino, create);
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478 create = EXT4_GET_BLOCKS_DIO_CREATE_EXT;
3479
3480 if (max_blocks > DIO_MAX_BLOCKS)
3481 max_blocks = DIO_MAX_BLOCKS;
3482 dio_credits = ext4_chunk_trans_blocks(inode, max_blocks);
3483 handle = ext4_journal_start(inode, dio_credits);
3484 if (IS_ERR(handle)) {
3485 ret = PTR_ERR(handle);
3486 goto out;
3487 }
3488 ret = ext4_get_blocks(handle, inode, iblock, max_blocks, bh_result,
3489 create);
3490 if (ret > 0) {
3491 bh_result->b_size = (ret << inode->i_blkbits);
3492 ret = 0;
3493 }
3494 ext4_journal_stop(handle);
3495out:
3496 return ret;
3497}
3498
3499static void ext4_free_io_end(ext4_io_end_t *io)
3500{
3501 BUG_ON(!io);
3502 iput(io->inode);
3503 kfree(io);
3504}
3505static void dump_aio_dio_list(struct inode * inode)
3506{
3507#ifdef EXT4_DEBUG
3508 struct list_head *cur, *before, *after;
3509 ext4_io_end_t *io, *io0, *io1;
3510
3511 if (list_empty(&EXT4_I(inode)->i_aio_dio_complete_list)){
3512 ext4_debug("inode %lu aio dio list is empty\n", inode->i_ino);
3513 return;
3514 }
3515
3516 ext4_debug("Dump inode %lu aio_dio_completed_IO list \n", inode->i_ino);
3517 list_for_each_entry(io, &EXT4_I(inode)->i_aio_dio_complete_list, list){
3518 cur = &io->list;
3519 before = cur->prev;
3520 io0 = container_of(before, ext4_io_end_t, list);
3521 after = cur->next;
3522 io1 = container_of(after, ext4_io_end_t, list);
3523
3524 ext4_debug("io 0x%p from inode %lu,prev 0x%p,next 0x%p\n",
3525 io, inode->i_ino, io0, io1);
3526 }
3527#endif
3528}
3529
3530
3531
3532
3533static int ext4_end_aio_dio_nolock(ext4_io_end_t *io)
3534{
3535 struct inode *inode = io->inode;
3536 loff_t offset = io->offset;
3537 size_t size = io->size;
3538 int ret = 0;
3539
3540 ext4_debug("end_aio_dio_onlock: io 0x%p from inode %lu,list->next 0x%p,"
3541 "list->prev 0x%p\n",
3542 io, inode->i_ino, io->list.next, io->list.prev);
3543
3544 if (list_empty(&io->list))
3545 return ret;
3546
3547 if (io->flag != DIO_AIO_UNWRITTEN)
3548 return ret;
3549
3550 if (offset + size <= i_size_read(inode))
3551 ret = ext4_convert_unwritten_extents(inode, offset, size);
3552
3553 if (ret < 0) {
3554 printk(KERN_EMERG "%s: failed to convert unwritten"
3555 "extents to written extents, error is %d"
3556 " io is still on inode %lu aio dio list\n",
3557 __func__, ret, inode->i_ino);
3558 return ret;
3559 }
3560
3561
3562 io->flag = 0;
3563 return ret;
3564}
3565
3566
3567
3568static void ext4_end_aio_dio_work(struct work_struct *work)
3569{
3570 ext4_io_end_t *io = container_of(work, ext4_io_end_t, work);
3571 struct inode *inode = io->inode;
3572 int ret = 0;
3573
3574 mutex_lock(&inode->i_mutex);
3575 ret = ext4_end_aio_dio_nolock(io);
3576 if (ret >= 0) {
3577 if (!list_empty(&io->list))
3578 list_del_init(&io->list);
3579 ext4_free_io_end(io);
3580 }
3581 mutex_unlock(&inode->i_mutex);
3582}
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594int flush_aio_dio_completed_IO(struct inode *inode)
3595{
3596 ext4_io_end_t *io;
3597 int ret = 0;
3598 int ret2 = 0;
3599
3600 if (list_empty(&EXT4_I(inode)->i_aio_dio_complete_list))
3601 return ret;
3602
3603 dump_aio_dio_list(inode);
3604 while (!list_empty(&EXT4_I(inode)->i_aio_dio_complete_list)){
3605 io = list_entry(EXT4_I(inode)->i_aio_dio_complete_list.next,
3606 ext4_io_end_t, list);
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621 ret = ext4_end_aio_dio_nolock(io);
3622 if (ret < 0)
3623 ret2 = ret;
3624 else
3625 list_del_init(&io->list);
3626 }
3627 return (ret2 < 0) ? ret2 : 0;
3628}
3629
3630static ext4_io_end_t *ext4_init_io_end (struct inode *inode)
3631{
3632 ext4_io_end_t *io = NULL;
3633
3634 io = kmalloc(sizeof(*io), GFP_NOFS);
3635
3636 if (io) {
3637 igrab(inode);
3638 io->inode = inode;
3639 io->flag = 0;
3640 io->offset = 0;
3641 io->size = 0;
3642 io->error = 0;
3643 INIT_WORK(&io->work, ext4_end_aio_dio_work);
3644 INIT_LIST_HEAD(&io->list);
3645 }
3646
3647 return io;
3648}
3649
3650static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
3651 ssize_t size, void *private)
3652{
3653 ext4_io_end_t *io_end = iocb->private;
3654 struct workqueue_struct *wq;
3655
3656
3657 if (!io_end || !size)
3658 return;
3659
3660 ext_debug("ext4_end_io_dio(): io_end 0x%p"
3661 "for inode %lu, iocb 0x%p, offset %llu, size %llu\n",
3662 iocb->private, io_end->inode->i_ino, iocb, offset,
3663 size);
3664
3665
3666 if (io_end->flag != DIO_AIO_UNWRITTEN){
3667 ext4_free_io_end(io_end);
3668 iocb->private = NULL;
3669 return;
3670 }
3671
3672 io_end->offset = offset;
3673 io_end->size = size;
3674 wq = EXT4_SB(io_end->inode->i_sb)->dio_unwritten_wq;
3675
3676
3677 queue_work(wq, &io_end->work);
3678
3679
3680 list_add_tail(&io_end->list,
3681 &EXT4_I(io_end->inode)->i_aio_dio_complete_list);
3682 iocb->private = NULL;
3683}
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
3704 const struct iovec *iov, loff_t offset,
3705 unsigned long nr_segs)
3706{
3707 struct file *file = iocb->ki_filp;
3708 struct inode *inode = file->f_mapping->host;
3709 ssize_t ret;
3710 size_t count = iov_length(iov, nr_segs);
3711
3712 loff_t final_size = offset + count;
3713 if (rw == WRITE && final_size <= inode->i_size) {
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734 iocb->private = NULL;
3735 EXT4_I(inode)->cur_aio_dio = NULL;
3736 if (!is_sync_kiocb(iocb)) {
3737 iocb->private = ext4_init_io_end(inode);
3738 if (!iocb->private)
3739 return -ENOMEM;
3740
3741
3742
3743
3744
3745
3746
3747 EXT4_I(inode)->cur_aio_dio = iocb->private;
3748 }
3749
3750 ret = blockdev_direct_IO(rw, iocb, inode,
3751 inode->i_sb->s_bdev, iov,
3752 offset, nr_segs,
3753 ext4_get_block_dio_write,
3754 ext4_end_io_dio);
3755 if (iocb->private)
3756 EXT4_I(inode)->cur_aio_dio = NULL;
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771 if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
3772 ext4_free_io_end(iocb->private);
3773 iocb->private = NULL;
3774 } else if (ret > 0 && (EXT4_I(inode)->i_state &
3775 EXT4_STATE_DIO_UNWRITTEN)) {
3776 int err;
3777
3778
3779
3780
3781 err = ext4_convert_unwritten_extents(inode,
3782 offset, ret);
3783 if (err < 0)
3784 ret = err;
3785 EXT4_I(inode)->i_state &= ~EXT4_STATE_DIO_UNWRITTEN;
3786 }
3787 return ret;
3788 }
3789
3790
3791 return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3792}
3793
3794static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
3795 const struct iovec *iov, loff_t offset,
3796 unsigned long nr_segs)
3797{
3798 struct file *file = iocb->ki_filp;
3799 struct inode *inode = file->f_mapping->host;
3800
3801 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)
3802 return ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
3803
3804 return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
3805}
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820static int ext4_journalled_set_page_dirty(struct page *page)
3821{
3822 SetPageChecked(page);
3823 return __set_page_dirty_nobuffers(page);
3824}
3825
3826static const struct address_space_operations ext4_ordered_aops = {
3827 .readpage = ext4_readpage,
3828 .readpages = ext4_readpages,
3829 .writepage = ext4_writepage,
3830 .sync_page = block_sync_page,
3831 .write_begin = ext4_write_begin,
3832 .write_end = ext4_ordered_write_end,
3833 .bmap = ext4_bmap,
3834 .invalidatepage = ext4_invalidatepage,
3835 .releasepage = ext4_releasepage,
3836 .direct_IO = ext4_direct_IO,
3837 .migratepage = buffer_migrate_page,
3838 .is_partially_uptodate = block_is_partially_uptodate,
3839 .error_remove_page = generic_error_remove_page,
3840};
3841
3842static const struct address_space_operations ext4_writeback_aops = {
3843 .readpage = ext4_readpage,
3844 .readpages = ext4_readpages,
3845 .writepage = ext4_writepage,
3846 .sync_page = block_sync_page,
3847 .write_begin = ext4_write_begin,
3848 .write_end = ext4_writeback_write_end,
3849 .bmap = ext4_bmap,
3850 .invalidatepage = ext4_invalidatepage,
3851 .releasepage = ext4_releasepage,
3852 .direct_IO = ext4_direct_IO,
3853 .migratepage = buffer_migrate_page,
3854 .is_partially_uptodate = block_is_partially_uptodate,
3855 .error_remove_page = generic_error_remove_page,
3856};
3857
3858static const struct address_space_operations ext4_journalled_aops = {
3859 .readpage = ext4_readpage,
3860 .readpages = ext4_readpages,
3861 .writepage = ext4_writepage,
3862 .sync_page = block_sync_page,
3863 .write_begin = ext4_write_begin,
3864 .write_end = ext4_journalled_write_end,
3865 .set_page_dirty = ext4_journalled_set_page_dirty,
3866 .bmap = ext4_bmap,
3867 .invalidatepage = ext4_invalidatepage,
3868 .releasepage = ext4_releasepage,
3869 .is_partially_uptodate = block_is_partially_uptodate,
3870 .error_remove_page = generic_error_remove_page,
3871};
3872
3873static const struct address_space_operations ext4_da_aops = {
3874 .readpage = ext4_readpage,
3875 .readpages = ext4_readpages,
3876 .writepage = ext4_writepage,
3877 .writepages = ext4_da_writepages,
3878 .sync_page = block_sync_page,
3879 .write_begin = ext4_da_write_begin,
3880 .write_end = ext4_da_write_end,
3881 .bmap = ext4_bmap,
3882 .invalidatepage = ext4_da_invalidatepage,
3883 .releasepage = ext4_releasepage,
3884 .direct_IO = ext4_direct_IO,
3885 .migratepage = buffer_migrate_page,
3886 .is_partially_uptodate = block_is_partially_uptodate,
3887 .error_remove_page = generic_error_remove_page,
3888};
3889
3890void ext4_set_aops(struct inode *inode)
3891{
3892 if (ext4_should_order_data(inode) &&
3893 test_opt(inode->i_sb, DELALLOC))
3894 inode->i_mapping->a_ops = &ext4_da_aops;
3895 else if (ext4_should_order_data(inode))
3896 inode->i_mapping->a_ops = &ext4_ordered_aops;
3897 else if (ext4_should_writeback_data(inode) &&
3898 test_opt(inode->i_sb, DELALLOC))
3899 inode->i_mapping->a_ops = &ext4_da_aops;
3900 else if (ext4_should_writeback_data(inode))
3901 inode->i_mapping->a_ops = &ext4_writeback_aops;
3902 else
3903 inode->i_mapping->a_ops = &ext4_journalled_aops;
3904}
3905
3906
3907
3908
3909
3910
3911
3912int ext4_block_truncate_page(handle_t *handle,
3913 struct address_space *mapping, loff_t from)
3914{
3915 ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
3916 unsigned offset = from & (PAGE_CACHE_SIZE-1);
3917 unsigned blocksize, length, pos;
3918 ext4_lblk_t iblock;
3919 struct inode *inode = mapping->host;
3920 struct buffer_head *bh;
3921 struct page *page;
3922 int err = 0;
3923
3924 page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
3925 mapping_gfp_mask(mapping) & ~__GFP_FS);
3926 if (!page)
3927 return -EINVAL;
3928
3929 blocksize = inode->i_sb->s_blocksize;
3930 length = blocksize - (offset & (blocksize - 1));
3931 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
3932
3933
3934
3935
3936
3937 if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
3938 ext4_should_writeback_data(inode) && PageUptodate(page)) {
3939 zero_user(page, offset, length);
3940 set_page_dirty(page);
3941 goto unlock;
3942 }
3943
3944 if (!page_has_buffers(page))
3945 create_empty_buffers(page, blocksize, 0);
3946
3947
3948 bh = page_buffers(page);
3949 pos = blocksize;
3950 while (offset >= pos) {
3951 bh = bh->b_this_page;
3952 iblock++;
3953 pos += blocksize;
3954 }
3955
3956 err = 0;
3957 if (buffer_freed(bh)) {
3958 BUFFER_TRACE(bh, "freed: skip");
3959 goto unlock;
3960 }
3961
3962 if (!buffer_mapped(bh)) {
3963 BUFFER_TRACE(bh, "unmapped");
3964 ext4_get_block(inode, iblock, bh, 0);
3965
3966 if (!buffer_mapped(bh)) {
3967 BUFFER_TRACE(bh, "still unmapped");
3968 goto unlock;
3969 }
3970 }
3971
3972
3973 if (PageUptodate(page))
3974 set_buffer_uptodate(bh);
3975
3976 if (!buffer_uptodate(bh)) {
3977 err = -EIO;
3978 ll_rw_block(READ, 1, &bh);
3979 wait_on_buffer(bh);
3980
3981 if (!buffer_uptodate(bh))
3982 goto unlock;
3983 }
3984
3985 if (ext4_should_journal_data(inode)) {
3986 BUFFER_TRACE(bh, "get write access");
3987 err = ext4_journal_get_write_access(handle, bh);
3988 if (err)
3989 goto unlock;
3990 }
3991
3992 zero_user(page, offset, length);
3993
3994 BUFFER_TRACE(bh, "zeroed end of block");
3995
3996 err = 0;
3997 if (ext4_should_journal_data(inode)) {
3998 err = ext4_handle_dirty_metadata(handle, inode, bh);
3999 } else {
4000 if (ext4_should_order_data(inode))
4001 err = ext4_jbd2_file_inode(handle, inode);
4002 mark_buffer_dirty(bh);
4003 }
4004
4005unlock:
4006 unlock_page(page);
4007 page_cache_release(page);
4008 return err;
4009}
4010
4011
4012
4013
4014
4015
4016static inline int all_zeroes(__le32 *p, __le32 *q)
4017{
4018 while (p < q)
4019 if (*p++)
4020 return 0;
4021 return 1;
4022}
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059static Indirect *ext4_find_shared(struct inode *inode, int depth,
4060 ext4_lblk_t offsets[4], Indirect chain[4],
4061 __le32 *top)
4062{
4063 Indirect *partial, *p;
4064 int k, err;
4065
4066 *top = 0;
4067
4068 for (k = depth; k > 1 && !offsets[k-1]; k--)
4069 ;
4070 partial = ext4_get_branch(inode, k, offsets, chain, &err);
4071
4072 if (!partial)
4073 partial = chain + k-1;
4074
4075
4076
4077
4078 if (!partial->key && *partial->p)
4079
4080 goto no_top;
4081 for (p = partial; (p > chain) && all_zeroes((__le32 *) p->bh->b_data, p->p); p--)
4082 ;
4083
4084
4085
4086
4087
4088
4089 if (p == chain + k - 1 && p > chain) {
4090 p->p--;
4091 } else {
4092 *top = *p->p;
4093
4094#if 0
4095 *p->p = 0;
4096#endif
4097 }
4098
4099
4100 while (partial > p) {
4101 brelse(partial->bh);
4102 partial--;
4103 }
4104no_top:
4105 return partial;
4106}
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116static void ext4_clear_blocks(handle_t *handle, struct inode *inode,
4117 struct buffer_head *bh,
4118 ext4_fsblk_t block_to_free,
4119 unsigned long count, __le32 *first,
4120 __le32 *last)
4121{
4122 __le32 *p;
4123 if (try_to_extend_transaction(handle, inode)) {
4124 if (bh) {
4125 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
4126 ext4_handle_dirty_metadata(handle, inode, bh);
4127 }
4128 ext4_mark_inode_dirty(handle, inode);
4129 ext4_truncate_restart_trans(handle, inode,
4130 blocks_for_truncate(inode));
4131 if (bh) {
4132 BUFFER_TRACE(bh, "retaking write access");
4133 ext4_journal_get_write_access(handle, bh);
4134 }
4135 }
4136
4137
4138
4139
4140
4141
4142
4143
4144
4145
4146 for (p = first; p < last; p++) {
4147 u32 nr = le32_to_cpu(*p);
4148 if (nr) {
4149 struct buffer_head *tbh;
4150
4151 *p = 0;
4152 tbh = sb_find_get_block(inode->i_sb, nr);
4153 ext4_forget(handle, 0, inode, tbh, nr);
4154 }
4155 }
4156
4157 ext4_free_blocks(handle, inode, block_to_free, count, 0);
4158}
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
4175
4176
4177
4178
4179static void ext4_free_data(handle_t *handle, struct inode *inode,
4180 struct buffer_head *this_bh,
4181 __le32 *first, __le32 *last)
4182{
4183 ext4_fsblk_t block_to_free = 0;
4184 unsigned long count = 0;
4185 __le32 *block_to_free_p = NULL;
4186
4187
4188 ext4_fsblk_t nr;
4189 __le32 *p;
4190
4191 int err;
4192
4193 if (this_bh) {
4194 BUFFER_TRACE(this_bh, "get_write_access");
4195 err = ext4_journal_get_write_access(handle, this_bh);
4196
4197
4198 if (err)
4199 return;
4200 }
4201
4202 for (p = first; p < last; p++) {
4203 nr = le32_to_cpu(*p);
4204 if (nr) {
4205
4206 if (count == 0) {
4207 block_to_free = nr;
4208 block_to_free_p = p;
4209 count = 1;
4210 } else if (nr == block_to_free + count) {
4211 count++;
4212 } else {
4213 ext4_clear_blocks(handle, inode, this_bh,
4214 block_to_free,
4215 count, block_to_free_p, p);
4216 block_to_free = nr;
4217 block_to_free_p = p;
4218 count = 1;
4219 }
4220 }
4221 }
4222
4223 if (count > 0)
4224 ext4_clear_blocks(handle, inode, this_bh, block_to_free,
4225 count, block_to_free_p, p);
4226
4227 if (this_bh) {
4228 BUFFER_TRACE(this_bh, "call ext4_handle_dirty_metadata");
4229
4230
4231
4232
4233
4234
4235
4236 if ((EXT4_JOURNAL(inode) == NULL) || bh2jh(this_bh))
4237 ext4_handle_dirty_metadata(handle, inode, this_bh);
4238 else
4239 ext4_error(inode->i_sb, __func__,
4240 "circular indirect block detected, "
4241 "inode=%lu, block=%llu",
4242 inode->i_ino,
4243 (unsigned long long) this_bh->b_blocknr);
4244 }
4245}
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260static void ext4_free_branches(handle_t *handle, struct inode *inode,
4261 struct buffer_head *parent_bh,
4262 __le32 *first, __le32 *last, int depth)
4263{
4264 ext4_fsblk_t nr;
4265 __le32 *p;
4266
4267 if (ext4_handle_is_aborted(handle))
4268 return;
4269
4270 if (depth--) {
4271 struct buffer_head *bh;
4272 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
4273 p = last;
4274 while (--p >= first) {
4275 nr = le32_to_cpu(*p);
4276 if (!nr)
4277 continue;
4278
4279
4280 bh = sb_bread(inode->i_sb, nr);
4281
4282
4283
4284
4285
4286 if (!bh) {
4287 ext4_error(inode->i_sb, "ext4_free_branches",
4288 "Read failure, inode=%lu, block=%llu",
4289 inode->i_ino, nr);
4290 continue;
4291 }
4292
4293
4294 BUFFER_TRACE(bh, "free child branches");
4295 ext4_free_branches(handle, inode, bh,
4296 (__le32 *) bh->b_data,
4297 (__le32 *) bh->b_data + addr_per_block,
4298 depth);
4299
4300
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318
4319 ext4_forget(handle, 1, inode, bh, bh->b_blocknr);
4320
4321
4322
4323
4324
4325
4326
4327
4328
4329
4330
4331
4332
4333
4334
4335
4336
4337 if (ext4_handle_is_aborted(handle))
4338 return;
4339 if (try_to_extend_transaction(handle, inode)) {
4340 ext4_mark_inode_dirty(handle, inode);
4341 ext4_truncate_restart_trans(handle, inode,
4342 blocks_for_truncate(inode));
4343 }
4344
4345 ext4_free_blocks(handle, inode, nr, 1, 1);
4346
4347 if (parent_bh) {
4348
4349
4350
4351
4352 BUFFER_TRACE(parent_bh, "get_write_access");
4353 if (!ext4_journal_get_write_access(handle,
4354 parent_bh)){
4355 *p = 0;
4356 BUFFER_TRACE(parent_bh,
4357 "call ext4_handle_dirty_metadata");
4358 ext4_handle_dirty_metadata(handle,
4359 inode,
4360 parent_bh);
4361 }
4362 }
4363 }
4364 } else {
4365
4366 BUFFER_TRACE(parent_bh, "free data blocks");
4367 ext4_free_data(handle, inode, parent_bh, first, last);
4368 }
4369}
4370
4371int ext4_can_truncate(struct inode *inode)
4372{
4373 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
4374 return 0;
4375 if (S_ISREG(inode->i_mode))
4376 return 1;
4377 if (S_ISDIR(inode->i_mode))
4378 return 1;
4379 if (S_ISLNK(inode->i_mode))
4380 return !ext4_inode_is_fast_symlink(inode);
4381 return 0;
4382}
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411
4412void ext4_truncate(struct inode *inode)
4413{
4414 handle_t *handle;
4415 struct ext4_inode_info *ei = EXT4_I(inode);
4416 __le32 *i_data = ei->i_data;
4417 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb);
4418 struct address_space *mapping = inode->i_mapping;
4419 ext4_lblk_t offsets[4];
4420 Indirect chain[4];
4421 Indirect *partial;
4422 __le32 nr = 0;
4423 int n;
4424 ext4_lblk_t last_block;
4425 unsigned blocksize = inode->i_sb->s_blocksize;
4426
4427 if (!ext4_can_truncate(inode))
4428 return;
4429
4430 if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
4431 ei->i_state |= EXT4_STATE_DA_ALLOC_CLOSE;
4432
4433 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
4434 ext4_ext_truncate(inode);
4435 return;
4436 }
4437
4438 handle = start_transaction(inode);
4439 if (IS_ERR(handle))
4440 return;
4441
4442 last_block = (inode->i_size + blocksize-1)
4443 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb);
4444
4445 if (inode->i_size & (blocksize - 1))
4446 if (ext4_block_truncate_page(handle, mapping, inode->i_size))
4447 goto out_stop;
4448
4449 n = ext4_block_to_path(inode, last_block, offsets, NULL);
4450 if (n == 0)
4451 goto out_stop;
4452
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462 if (ext4_orphan_add(handle, inode))
4463 goto out_stop;
4464
4465
4466
4467
4468
4469 down_write(&ei->i_data_sem);
4470
4471 ext4_discard_preallocations(inode);
4472
4473
4474
4475
4476
4477
4478
4479
4480 ei->i_disksize = inode->i_size;
4481
4482 if (n == 1) {
4483 ext4_free_data(handle, inode, NULL, i_data+offsets[0],
4484 i_data + EXT4_NDIR_BLOCKS);
4485 goto do_indirects;
4486 }
4487
4488 partial = ext4_find_shared(inode, n, offsets, chain, &nr);
4489
4490 if (nr) {
4491 if (partial == chain) {
4492
4493 ext4_free_branches(handle, inode, NULL,
4494 &nr, &nr+1, (chain+n-1) - partial);
4495 *partial->p = 0;
4496
4497
4498
4499
4500 } else {
4501
4502 BUFFER_TRACE(partial->bh, "get_write_access");
4503 ext4_free_branches(handle, inode, partial->bh,
4504 partial->p,
4505 partial->p+1, (chain+n-1) - partial);
4506 }
4507 }
4508
4509 while (partial > chain) {
4510 ext4_free_branches(handle, inode, partial->bh, partial->p + 1,
4511 (__le32*)partial->bh->b_data+addr_per_block,
4512 (chain+n-1) - partial);
4513 BUFFER_TRACE(partial->bh, "call brelse");
4514 brelse(partial->bh);
4515 partial--;
4516 }
4517do_indirects:
4518
4519 switch (offsets[0]) {
4520 default:
4521 nr = i_data[EXT4_IND_BLOCK];
4522 if (nr) {
4523 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
4524 i_data[EXT4_IND_BLOCK] = 0;
4525 }
4526 case EXT4_IND_BLOCK:
4527 nr = i_data[EXT4_DIND_BLOCK];
4528 if (nr) {
4529 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
4530 i_data[EXT4_DIND_BLOCK] = 0;
4531 }
4532 case EXT4_DIND_BLOCK:
4533 nr = i_data[EXT4_TIND_BLOCK];
4534 if (nr) {
4535 ext4_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
4536 i_data[EXT4_TIND_BLOCK] = 0;
4537 }
4538 case EXT4_TIND_BLOCK:
4539 ;
4540 }
4541
4542 up_write(&ei->i_data_sem);
4543 inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
4544 ext4_mark_inode_dirty(handle, inode);
4545
4546
4547
4548
4549
4550 if (IS_SYNC(inode))
4551 ext4_handle_sync(handle);
4552out_stop:
4553
4554
4555
4556
4557
4558
4559
4560 if (inode->i_nlink)
4561 ext4_orphan_del(handle, inode);
4562
4563 ext4_journal_stop(handle);
4564}
4565
4566
4567
4568
4569
4570
4571
4572static int __ext4_get_inode_loc(struct inode *inode,
4573 struct ext4_iloc *iloc, int in_mem)
4574{
4575 struct ext4_group_desc *gdp;
4576 struct buffer_head *bh;
4577 struct super_block *sb = inode->i_sb;
4578 ext4_fsblk_t block;
4579 int inodes_per_block, inode_offset;
4580
4581 iloc->bh = NULL;
4582 if (!ext4_valid_inum(sb, inode->i_ino))
4583 return -EIO;
4584
4585 iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
4586 gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
4587 if (!gdp)
4588 return -EIO;
4589
4590
4591
4592
4593 inodes_per_block = (EXT4_BLOCK_SIZE(sb) / EXT4_INODE_SIZE(sb));
4594 inode_offset = ((inode->i_ino - 1) %
4595 EXT4_INODES_PER_GROUP(sb));
4596 block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
4597 iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);
4598
4599 bh = sb_getblk(sb, block);
4600 if (!bh) {
4601 ext4_error(sb, "ext4_get_inode_loc", "unable to read "
4602 "inode block - inode=%lu, block=%llu",
4603 inode->i_ino, block);
4604 return -EIO;
4605 }
4606 if (!buffer_uptodate(bh)) {
4607 lock_buffer(bh);
4608
4609
4610
4611
4612
4613
4614
4615 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
4616 set_buffer_uptodate(bh);
4617
4618 if (buffer_uptodate(bh)) {
4619
4620 unlock_buffer(bh);
4621 goto has_buffer;
4622 }
4623
4624
4625
4626
4627
4628
4629 if (in_mem) {
4630 struct buffer_head *bitmap_bh;
4631 int i, start;
4632
4633 start = inode_offset & ~(inodes_per_block - 1);
4634
4635
4636 bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
4637 if (!bitmap_bh)
4638 goto make_io;
4639
4640
4641
4642
4643
4644
4645 if (!buffer_uptodate(bitmap_bh)) {
4646 brelse(bitmap_bh);
4647 goto make_io;
4648 }
4649 for (i = start; i < start + inodes_per_block; i++) {
4650 if (i == inode_offset)
4651 continue;
4652 if (ext4_test_bit(i, bitmap_bh->b_data))
4653 break;
4654 }
4655 brelse(bitmap_bh);
4656 if (i == start + inodes_per_block) {
4657
4658 memset(bh->b_data, 0, bh->b_size);
4659 set_buffer_uptodate(bh);
4660 unlock_buffer(bh);
4661 goto has_buffer;
4662 }
4663 }
4664
4665make_io:
4666
4667
4668
4669
4670 if (EXT4_SB(sb)->s_inode_readahead_blks) {
4671 ext4_fsblk_t b, end, table;
4672 unsigned num;
4673
4674 table = ext4_inode_table(sb, gdp);
4675
4676 b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
4677 if (table > b)
4678 b = table;
4679 end = b + EXT4_SB(sb)->s_inode_readahead_blks;
4680 num = EXT4_INODES_PER_GROUP(sb);
4681 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
4682 EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
4683 num -= ext4_itable_unused_count(sb, gdp);
4684 table += num / inodes_per_block;
4685 if (end > table)
4686 end = table;
4687 while (b <= end)
4688 sb_breadahead(sb, b++);
4689 }
4690
4691
4692
4693
4694
4695
4696 get_bh(bh);
4697 bh->b_end_io = end_buffer_read_sync;
4698 submit_bh(READ_META, bh);
4699 wait_on_buffer(bh);
4700 if (!buffer_uptodate(bh)) {
4701 ext4_error(sb, __func__,
4702 "unable to read inode block - inode=%lu, "
4703 "block=%llu", inode->i_ino, block);
4704 brelse(bh);
4705 return -EIO;
4706 }
4707 }
4708has_buffer:
4709 iloc->bh = bh;
4710 return 0;
4711}
4712
4713int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
4714{
4715
4716 return __ext4_get_inode_loc(inode, iloc,
4717 !(EXT4_I(inode)->i_state & EXT4_STATE_XATTR));
4718}
4719
4720void ext4_set_inode_flags(struct inode *inode)
4721{
4722 unsigned int flags = EXT4_I(inode)->i_flags;
4723
4724 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
4725 if (flags & EXT4_SYNC_FL)
4726 inode->i_flags |= S_SYNC;
4727 if (flags & EXT4_APPEND_FL)
4728 inode->i_flags |= S_APPEND;
4729 if (flags & EXT4_IMMUTABLE_FL)
4730 inode->i_flags |= S_IMMUTABLE;
4731 if (flags & EXT4_NOATIME_FL)
4732 inode->i_flags |= S_NOATIME;
4733 if (flags & EXT4_DIRSYNC_FL)
4734 inode->i_flags |= S_DIRSYNC;
4735}
4736
4737
4738void ext4_get_inode_flags(struct ext4_inode_info *ei)
4739{
4740 unsigned int flags = ei->vfs_inode.i_flags;
4741
4742 ei->i_flags &= ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
4743 EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|EXT4_DIRSYNC_FL);
4744 if (flags & S_SYNC)
4745 ei->i_flags |= EXT4_SYNC_FL;
4746 if (flags & S_APPEND)
4747 ei->i_flags |= EXT4_APPEND_FL;
4748 if (flags & S_IMMUTABLE)
4749 ei->i_flags |= EXT4_IMMUTABLE_FL;
4750 if (flags & S_NOATIME)
4751 ei->i_flags |= EXT4_NOATIME_FL;
4752 if (flags & S_DIRSYNC)
4753 ei->i_flags |= EXT4_DIRSYNC_FL;
4754}
4755
4756static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
4757 struct ext4_inode_info *ei)
4758{
4759 blkcnt_t i_blocks ;
4760 struct inode *inode = &(ei->vfs_inode);
4761 struct super_block *sb = inode->i_sb;
4762
4763 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
4764 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
4765
4766 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
4767 le32_to_cpu(raw_inode->i_blocks_lo);
4768 if (ei->i_flags & EXT4_HUGE_FILE_FL) {
4769
4770 return i_blocks << (inode->i_blkbits - 9);
4771 } else {
4772 return i_blocks;
4773 }
4774 } else {
4775 return le32_to_cpu(raw_inode->i_blocks_lo);
4776 }
4777}
4778
4779struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4780{
4781 struct ext4_iloc iloc;
4782 struct ext4_inode *raw_inode;
4783 struct ext4_inode_info *ei;
4784 struct buffer_head *bh;
4785 struct inode *inode;
4786 long ret;
4787 int block;
4788
4789 inode = iget_locked(sb, ino);
4790 if (!inode)
4791 return ERR_PTR(-ENOMEM);
4792 if (!(inode->i_state & I_NEW))
4793 return inode;
4794
4795 ei = EXT4_I(inode);
4796
4797 ret = __ext4_get_inode_loc(inode, &iloc, 0);
4798 if (ret < 0)
4799 goto bad_inode;
4800 bh = iloc.bh;
4801 raw_inode = ext4_raw_inode(&iloc);
4802 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
4803 inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
4804 inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
4805 if (!(test_opt(inode->i_sb, NO_UID32))) {
4806 inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
4807 inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
4808 }
4809 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
4810
4811 ei->i_state = 0;
4812 ei->i_dir_start_lookup = 0;
4813 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
4814
4815
4816
4817
4818
4819 if (inode->i_nlink == 0) {
4820 if (inode->i_mode == 0 ||
4821 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
4822
4823 brelse(bh);
4824 ret = -ESTALE;
4825 goto bad_inode;
4826 }
4827
4828
4829
4830
4831 }
4832 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
4833 inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
4834 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
4835 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
4836 ei->i_file_acl |=
4837 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
4838 inode->i_size = ext4_isize(raw_inode);
4839 ei->i_disksize = inode->i_size;
4840 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
4841 ei->i_block_group = iloc.block_group;
4842 ei->i_last_alloc_group = ~0;
4843
4844
4845
4846
4847 for (block = 0; block < EXT4_N_BLOCKS; block++)
4848 ei->i_data[block] = raw_inode->i_block[block];
4849 INIT_LIST_HEAD(&ei->i_orphan);
4850
4851 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
4852 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
4853 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
4854 EXT4_INODE_SIZE(inode->i_sb)) {
4855 brelse(bh);
4856 ret = -EIO;
4857 goto bad_inode;
4858 }
4859 if (ei->i_extra_isize == 0) {
4860
4861 ei->i_extra_isize = sizeof(struct ext4_inode) -
4862 EXT4_GOOD_OLD_INODE_SIZE;
4863 } else {
4864 __le32 *magic = (void *)raw_inode +
4865 EXT4_GOOD_OLD_INODE_SIZE +
4866 ei->i_extra_isize;
4867 if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
4868 ei->i_state |= EXT4_STATE_XATTR;
4869 }
4870 } else
4871 ei->i_extra_isize = 0;
4872
4873 EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
4874 EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
4875 EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
4876 EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
4877
4878 inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
4879 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
4880 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4881 inode->i_version |=
4882 (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
4883 }
4884
4885 ret = 0;
4886 if (ei->i_file_acl &&
4887 ((ei->i_file_acl <
4888 (le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block) +
4889 EXT4_SB(sb)->s_gdb_count)) ||
4890 (ei->i_file_acl >= ext4_blocks_count(EXT4_SB(sb)->s_es)))) {
4891 ext4_error(sb, __func__,
4892 "bad extended attribute block %llu in inode #%lu",
4893 ei->i_file_acl, inode->i_ino);
4894 ret = -EIO;
4895 goto bad_inode;
4896 } else if (ei->i_flags & EXT4_EXTENTS_FL) {
4897 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
4898 (S_ISLNK(inode->i_mode) &&
4899 !ext4_inode_is_fast_symlink(inode)))
4900
4901 ret = ext4_ext_check_inode(inode);
4902 } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
4903 (S_ISLNK(inode->i_mode) &&
4904 !ext4_inode_is_fast_symlink(inode))) {
4905
4906 ret = ext4_check_inode_blockref(inode);
4907 }
4908 if (ret) {
4909 brelse(bh);
4910 goto bad_inode;
4911 }
4912
4913 if (S_ISREG(inode->i_mode)) {
4914 inode->i_op = &ext4_file_inode_operations;
4915 inode->i_fop = &ext4_file_operations;
4916 ext4_set_aops(inode);
4917 } else if (S_ISDIR(inode->i_mode)) {
4918 inode->i_op = &ext4_dir_inode_operations;
4919 inode->i_fop = &ext4_dir_operations;
4920 } else if (S_ISLNK(inode->i_mode)) {
4921 if (ext4_inode_is_fast_symlink(inode)) {
4922 inode->i_op = &ext4_fast_symlink_inode_operations;
4923 nd_terminate_link(ei->i_data, inode->i_size,
4924 sizeof(ei->i_data) - 1);
4925 } else {
4926 inode->i_op = &ext4_symlink_inode_operations;
4927 ext4_set_aops(inode);
4928 }
4929 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
4930 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
4931 inode->i_op = &ext4_special_inode_operations;
4932 if (raw_inode->i_block[0])
4933 init_special_inode(inode, inode->i_mode,
4934 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
4935 else
4936 init_special_inode(inode, inode->i_mode,
4937 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
4938 } else {
4939 brelse(bh);
4940 ret = -EIO;
4941 ext4_error(inode->i_sb, __func__,
4942 "bogus i_mode (%o) for inode=%lu",
4943 inode->i_mode, inode->i_ino);
4944 goto bad_inode;
4945 }
4946 brelse(iloc.bh);
4947 ext4_set_inode_flags(inode);
4948 unlock_new_inode(inode);
4949 return inode;
4950
4951bad_inode:
4952 iget_failed(inode);
4953 return ERR_PTR(ret);
4954}
4955
4956static int ext4_inode_blocks_set(handle_t *handle,
4957 struct ext4_inode *raw_inode,
4958 struct ext4_inode_info *ei)
4959{
4960 struct inode *inode = &(ei->vfs_inode);
4961 u64 i_blocks = inode->i_blocks;
4962 struct super_block *sb = inode->i_sb;
4963
4964 if (i_blocks <= ~0U) {
4965
4966
4967
4968
4969 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
4970 raw_inode->i_blocks_high = 0;
4971 ei->i_flags &= ~EXT4_HUGE_FILE_FL;
4972 return 0;
4973 }
4974 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
4975 return -EFBIG;
4976
4977 if (i_blocks <= 0xffffffffffffULL) {
4978
4979
4980
4981
4982 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
4983 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4984 ei->i_flags &= ~EXT4_HUGE_FILE_FL;
4985 } else {
4986 ei->i_flags |= EXT4_HUGE_FILE_FL;
4987
4988 i_blocks = i_blocks >> (inode->i_blkbits - 9);
4989 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
4990 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4991 }
4992 return 0;
4993}
4994
4995
4996
4997
4998
4999
5000
5001
5002static int ext4_do_update_inode(handle_t *handle,
5003 struct inode *inode,
5004 struct ext4_iloc *iloc)
5005{
5006 struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
5007 struct ext4_inode_info *ei = EXT4_I(inode);
5008 struct buffer_head *bh = iloc->bh;
5009 int err = 0, rc, block;
5010
5011
5012
5013 if (ei->i_state & EXT4_STATE_NEW)
5014 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
5015
5016 ext4_get_inode_flags(ei);
5017 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
5018 if (!(test_opt(inode->i_sb, NO_UID32))) {
5019 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
5020 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
5021
5022
5023
5024
5025 if (!ei->i_dtime) {
5026 raw_inode->i_uid_high =
5027 cpu_to_le16(high_16_bits(inode->i_uid));
5028 raw_inode->i_gid_high =
5029 cpu_to_le16(high_16_bits(inode->i_gid));
5030 } else {
5031 raw_inode->i_uid_high = 0;
5032 raw_inode->i_gid_high = 0;
5033 }
5034 } else {
5035 raw_inode->i_uid_low =
5036 cpu_to_le16(fs_high2lowuid(inode->i_uid));
5037 raw_inode->i_gid_low =
5038 cpu_to_le16(fs_high2lowgid(inode->i_gid));
5039 raw_inode->i_uid_high = 0;
5040 raw_inode->i_gid_high = 0;
5041 }
5042 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
5043
5044 EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
5045 EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
5046 EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
5047 EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
5048
5049 if (ext4_inode_blocks_set(handle, raw_inode, ei))
5050 goto out_brelse;
5051 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
5052 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
5053 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
5054 cpu_to_le32(EXT4_OS_HURD))
5055 raw_inode->i_file_acl_high =
5056 cpu_to_le16(ei->i_file_acl >> 32);
5057 raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
5058 ext4_isize_set(raw_inode, ei->i_disksize);
5059 if (ei->i_disksize > 0x7fffffffULL) {
5060 struct super_block *sb = inode->i_sb;
5061 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
5062 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
5063 EXT4_SB(sb)->s_es->s_rev_level ==
5064 cpu_to_le32(EXT4_GOOD_OLD_REV)) {
5065
5066
5067
5068 err = ext4_journal_get_write_access(handle,
5069 EXT4_SB(sb)->s_sbh);
5070 if (err)
5071 goto out_brelse;
5072 ext4_update_dynamic_rev(sb);
5073 EXT4_SET_RO_COMPAT_FEATURE(sb,
5074 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
5075 sb->s_dirt = 1;
5076 ext4_handle_sync(handle);
5077 err = ext4_handle_dirty_metadata(handle, inode,
5078 EXT4_SB(sb)->s_sbh);
5079 }
5080 }
5081 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
5082 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
5083 if (old_valid_dev(inode->i_rdev)) {
5084 raw_inode->i_block[0] =
5085 cpu_to_le32(old_encode_dev(inode->i_rdev));
5086 raw_inode->i_block[1] = 0;
5087 } else {
5088 raw_inode->i_block[0] = 0;
5089 raw_inode->i_block[1] =
5090 cpu_to_le32(new_encode_dev(inode->i_rdev));
5091 raw_inode->i_block[2] = 0;
5092 }
5093 } else
5094 for (block = 0; block < EXT4_N_BLOCKS; block++)
5095 raw_inode->i_block[block] = ei->i_data[block];
5096
5097 raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
5098 if (ei->i_extra_isize) {
5099 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
5100 raw_inode->i_version_hi =
5101 cpu_to_le32(inode->i_version >> 32);
5102 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
5103 }
5104
5105 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
5106 rc = ext4_handle_dirty_metadata(handle, inode, bh);
5107 if (!err)
5108 err = rc;
5109 ei->i_state &= ~EXT4_STATE_NEW;
5110
5111out_brelse:
5112 brelse(bh);
5113 ext4_std_error(inode->i_sb, err);
5114 return err;
5115}
5116
5117
5118
5119
5120
5121
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136
5137
5138
5139
5140
5141
5142
5143
5144
5145
5146
5147
5148
5149
5150
5151
5152int ext4_write_inode(struct inode *inode, int wait)
5153{
5154 int err;
5155
5156 if (current->flags & PF_MEMALLOC)
5157 return 0;
5158
5159 if (EXT4_SB(inode->i_sb)->s_journal) {
5160 if (ext4_journal_current_handle()) {
5161 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
5162 dump_stack();
5163 return -EIO;
5164 }
5165
5166 if (!wait)
5167 return 0;
5168
5169 err = ext4_force_commit(inode->i_sb);
5170 } else {
5171 struct ext4_iloc iloc;
5172
5173 err = ext4_get_inode_loc(inode, &iloc);
5174 if (err)
5175 return err;
5176 if (wait)
5177 sync_dirty_buffer(iloc.bh);
5178 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
5179 ext4_error(inode->i_sb, __func__,
5180 "IO error syncing inode, "
5181 "inode=%lu, block=%llu",
5182 inode->i_ino,
5183 (unsigned long long)iloc.bh->b_blocknr);
5184 err = -EIO;
5185 }
5186 }
5187 return err;
5188}
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214int ext4_setattr(struct dentry *dentry, struct iattr *attr)
5215{
5216 struct inode *inode = dentry->d_inode;
5217 int error, rc = 0;
5218 const unsigned int ia_valid = attr->ia_valid;
5219
5220 error = inode_change_ok(inode, attr);
5221 if (error)
5222 return error;
5223
5224 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
5225 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
5226 handle_t *handle;
5227
5228
5229
5230 handle = ext4_journal_start(inode, 2*(EXT4_QUOTA_INIT_BLOCKS(inode->i_sb)+
5231 EXT4_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
5232 if (IS_ERR(handle)) {
5233 error = PTR_ERR(handle);
5234 goto err_out;
5235 }
5236 error = vfs_dq_transfer(inode, attr) ? -EDQUOT : 0;
5237 if (error) {
5238 ext4_journal_stop(handle);
5239 return error;
5240 }
5241
5242
5243 if (attr->ia_valid & ATTR_UID)
5244 inode->i_uid = attr->ia_uid;
5245 if (attr->ia_valid & ATTR_GID)
5246 inode->i_gid = attr->ia_gid;
5247 error = ext4_mark_inode_dirty(handle, inode);
5248 ext4_journal_stop(handle);
5249 }
5250
5251 if (attr->ia_valid & ATTR_SIZE) {
5252 if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL)) {
5253 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5254
5255 if (attr->ia_size > sbi->s_bitmap_maxbytes) {
5256 error = -EFBIG;
5257 goto err_out;
5258 }
5259 }
5260 }
5261
5262 if (S_ISREG(inode->i_mode) &&
5263 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
5264 handle_t *handle;
5265
5266 handle = ext4_journal_start(inode, 3);
5267 if (IS_ERR(handle)) {
5268 error = PTR_ERR(handle);
5269 goto err_out;
5270 }
5271
5272 error = ext4_orphan_add(handle, inode);
5273 EXT4_I(inode)->i_disksize = attr->ia_size;
5274 rc = ext4_mark_inode_dirty(handle, inode);
5275 if (!error)
5276 error = rc;
5277 ext4_journal_stop(handle);
5278
5279 if (ext4_should_order_data(inode)) {
5280 error = ext4_begin_ordered_truncate(inode,
5281 attr->ia_size);
5282 if (error) {
5283
5284 handle = ext4_journal_start(inode, 3);
5285 if (IS_ERR(handle)) {
5286 ext4_orphan_del(NULL, inode);
5287 goto err_out;
5288 }
5289 ext4_orphan_del(handle, inode);
5290 ext4_journal_stop(handle);
5291 goto err_out;
5292 }
5293 }
5294 }
5295
5296 rc = inode_setattr(inode, attr);
5297
5298
5299
5300
5301 if (inode->i_nlink)
5302 ext4_orphan_del(NULL, inode);
5303
5304 if (!rc && (ia_valid & ATTR_MODE))
5305 rc = ext4_acl_chmod(inode);
5306
5307err_out:
5308 ext4_std_error(inode->i_sb, error);
5309 if (!error)
5310 error = rc;
5311 return error;
5312}
5313
5314int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
5315 struct kstat *stat)
5316{
5317 struct inode *inode;
5318 unsigned long delalloc_blocks;
5319
5320 inode = dentry->d_inode;
5321 generic_fillattr(inode, stat);
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
5334 delalloc_blocks = EXT4_I(inode)->i_reserved_data_blocks;
5335 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
5336
5337 stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
5338 return 0;
5339}
5340
5341static int ext4_indirect_trans_blocks(struct inode *inode, int nrblocks,
5342 int chunk)
5343{
5344 int indirects;
5345
5346
5347 if (chunk) {
5348
5349
5350
5351
5352
5353
5354 indirects = nrblocks / EXT4_ADDR_PER_BLOCK(inode->i_sb);
5355 return indirects + 3;
5356 }
5357
5358
5359
5360
5361
5362 indirects = nrblocks * 2 + 1;
5363 return indirects;
5364}
5365
5366static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
5367{
5368 if (!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL))
5369 return ext4_indirect_trans_blocks(inode, nrblocks, chunk);
5370 return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
5371}
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
5385{
5386 ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
5387 int gdpblocks;
5388 int idxblocks;
5389 int ret = 0;
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399 idxblocks = ext4_index_trans_blocks(inode, nrblocks, chunk);
5400
5401 ret = idxblocks;
5402
5403
5404
5405
5406
5407 groups = idxblocks;
5408 if (chunk)
5409 groups += 1;
5410 else
5411 groups += nrblocks;
5412
5413 gdpblocks = groups;
5414 if (groups > ngroups)
5415 groups = ngroups;
5416 if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
5417 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;
5418
5419
5420 ret += groups + gdpblocks;
5421
5422
5423 ret += EXT4_META_TRANS_BLOCKS(inode->i_sb);
5424
5425 return ret;
5426}
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436
5437
5438int ext4_writepage_trans_blocks(struct inode *inode)
5439{
5440 int bpp = ext4_journal_blocks_per_page(inode);
5441 int ret;
5442
5443 ret = ext4_meta_trans_blocks(inode, bpp, 0);
5444
5445
5446 if (ext4_should_journal_data(inode))
5447 ret += bpp;
5448 return ret;
5449}
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459
5460int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
5461{
5462 return ext4_meta_trans_blocks(inode, nrblocks, 1);
5463}
5464
5465
5466
5467
5468
5469int ext4_mark_iloc_dirty(handle_t *handle,
5470 struct inode *inode, struct ext4_iloc *iloc)
5471{
5472 int err = 0;
5473
5474 if (test_opt(inode->i_sb, I_VERSION))
5475 inode_inc_iversion(inode);
5476
5477
5478 get_bh(iloc->bh);
5479
5480
5481 err = ext4_do_update_inode(handle, inode, iloc);
5482 put_bh(iloc->bh);
5483 return err;
5484}
5485
5486
5487
5488
5489
5490
5491int
5492ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
5493 struct ext4_iloc *iloc)
5494{
5495 int err;
5496
5497 err = ext4_get_inode_loc(inode, iloc);
5498 if (!err) {
5499 BUFFER_TRACE(iloc->bh, "get_write_access");
5500 err = ext4_journal_get_write_access(handle, iloc->bh);
5501 if (err) {
5502 brelse(iloc->bh);
5503 iloc->bh = NULL;
5504 }
5505 }
5506 ext4_std_error(inode->i_sb, err);
5507 return err;
5508}
5509
5510
5511
5512
5513
5514static int ext4_expand_extra_isize(struct inode *inode,
5515 unsigned int new_extra_isize,
5516 struct ext4_iloc iloc,
5517 handle_t *handle)
5518{
5519 struct ext4_inode *raw_inode;
5520 struct ext4_xattr_ibody_header *header;
5521 struct ext4_xattr_entry *entry;
5522
5523 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
5524 return 0;
5525
5526 raw_inode = ext4_raw_inode(&iloc);
5527
5528 header = IHDR(inode, raw_inode);
5529 entry = IFIRST(header);
5530
5531
5532 if (!(EXT4_I(inode)->i_state & EXT4_STATE_XATTR) ||
5533 header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
5534 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
5535 new_extra_isize);
5536 EXT4_I(inode)->i_extra_isize = new_extra_isize;
5537 return 0;
5538 }
5539
5540
5541 return ext4_expand_extra_isize_ea(inode, new_extra_isize,
5542 raw_inode, handle);
5543}
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565
5566int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
5567{
5568 struct ext4_iloc iloc;
5569 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5570 static unsigned int mnt_count;
5571 int err, ret;
5572
5573 might_sleep();
5574 err = ext4_reserve_inode_write(handle, inode, &iloc);
5575 if (ext4_handle_valid(handle) &&
5576 EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
5577 !(EXT4_I(inode)->i_state & EXT4_STATE_NO_EXPAND)) {
5578
5579
5580
5581
5582
5583
5584
5585 if ((jbd2_journal_extend(handle,
5586 EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
5587 ret = ext4_expand_extra_isize(inode,
5588 sbi->s_want_extra_isize,
5589 iloc, handle);
5590 if (ret) {
5591 EXT4_I(inode)->i_state |= EXT4_STATE_NO_EXPAND;
5592 if (mnt_count !=
5593 le16_to_cpu(sbi->s_es->s_mnt_count)) {
5594 ext4_warning(inode->i_sb, __func__,
5595 "Unable to expand inode %lu. Delete"
5596 " some EAs or run e2fsck.",
5597 inode->i_ino);
5598 mnt_count =
5599 le16_to_cpu(sbi->s_es->s_mnt_count);
5600 }
5601 }
5602 }
5603 }
5604 if (!err)
5605 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
5606 return err;
5607}
5608
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623void ext4_dirty_inode(struct inode *inode)
5624{
5625 handle_t *handle;
5626
5627 handle = ext4_journal_start(inode, 2);
5628 if (IS_ERR(handle))
5629 goto out;
5630
5631 ext4_mark_inode_dirty(handle, inode);
5632
5633 ext4_journal_stop(handle);
5634out:
5635 return;
5636}
5637
5638#if 0
5639
5640
5641
5642
5643
5644
5645
5646static int ext4_pin_inode(handle_t *handle, struct inode *inode)
5647{
5648 struct ext4_iloc iloc;
5649
5650 int err = 0;
5651 if (handle) {
5652 err = ext4_get_inode_loc(inode, &iloc);
5653 if (!err) {
5654 BUFFER_TRACE(iloc.bh, "get_write_access");
5655 err = jbd2_journal_get_write_access(handle, iloc.bh);
5656 if (!err)
5657 err = ext4_handle_dirty_metadata(handle,
5658 inode,
5659 iloc.bh);
5660 brelse(iloc.bh);
5661 }
5662 }
5663 ext4_std_error(inode->i_sb, err);
5664 return err;
5665}
5666#endif
5667
5668int ext4_change_inode_journal_flag(struct inode *inode, int val)
5669{
5670 journal_t *journal;
5671 handle_t *handle;
5672 int err;
5673
5674
5675
5676
5677
5678
5679
5680
5681
5682
5683
5684 journal = EXT4_JOURNAL(inode);
5685 if (!journal)
5686 return 0;
5687 if (is_journal_aborted(journal))
5688 return -EROFS;
5689
5690 jbd2_journal_lock_updates(journal);
5691 jbd2_journal_flush(journal);
5692
5693
5694
5695
5696
5697
5698
5699
5700
5701 if (val)
5702 EXT4_I(inode)->i_flags |= EXT4_JOURNAL_DATA_FL;
5703 else
5704 EXT4_I(inode)->i_flags &= ~EXT4_JOURNAL_DATA_FL;
5705 ext4_set_aops(inode);
5706
5707 jbd2_journal_unlock_updates(journal);
5708
5709
5710
5711 handle = ext4_journal_start(inode, 1);
5712 if (IS_ERR(handle))
5713 return PTR_ERR(handle);
5714
5715 err = ext4_mark_inode_dirty(handle, inode);
5716 ext4_handle_sync(handle);
5717 ext4_journal_stop(handle);
5718 ext4_std_error(inode->i_sb, err);
5719
5720 return err;
5721}
5722
5723static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
5724{
5725 return !buffer_mapped(bh);
5726}
5727
5728int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
5729{
5730 struct page *page = vmf->page;
5731 loff_t size;
5732 unsigned long len;
5733 int ret = -EINVAL;
5734 void *fsdata;
5735 struct file *file = vma->vm_file;
5736 struct inode *inode = file->f_path.dentry->d_inode;
5737 struct address_space *mapping = inode->i_mapping;
5738
5739
5740
5741
5742
5743 down_read(&inode->i_alloc_sem);
5744 size = i_size_read(inode);
5745 if (page->mapping != mapping || size <= page_offset(page)
5746 || !PageUptodate(page)) {
5747
5748 goto out_unlock;
5749 }
5750 ret = 0;
5751 if (PageMappedToDisk(page))
5752 goto out_unlock;
5753
5754 if (page->index == size >> PAGE_CACHE_SHIFT)
5755 len = size & ~PAGE_CACHE_MASK;
5756 else
5757 len = PAGE_CACHE_SIZE;
5758
5759 lock_page(page);
5760
5761
5762
5763
5764
5765
5766 if (page_has_buffers(page)) {
5767 if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
5768 ext4_bh_unmapped)) {
5769 unlock_page(page);
5770 goto out_unlock;
5771 }
5772 }
5773 unlock_page(page);
5774
5775
5776
5777
5778
5779
5780
5781 ret = mapping->a_ops->write_begin(file, mapping, page_offset(page),
5782 len, AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
5783 if (ret < 0)
5784 goto out_unlock;
5785 ret = mapping->a_ops->write_end(file, mapping, page_offset(page),
5786 len, len, page, fsdata);
5787 if (ret < 0)
5788 goto out_unlock;
5789 ret = 0;
5790out_unlock:
5791 if (ret)
5792 ret = VM_FAULT_SIGBUS;
5793 up_read(&inode->i_alloc_sem);
5794 return ret;
5795}
5796