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/highuid.h>
26#include <linux/quotaops.h>
27#include <linux/writeback.h>
28#include <linux/mpage.h>
29#include <linux/namei.h>
30#include "ext3.h"
31#include "xattr.h"
32#include "acl.h"
33
34static int ext3_writepage_trans_blocks(struct inode *inode);
35static int ext3_block_truncate_page(struct inode *inode, loff_t from);
36
37
38
39
40static int ext3_inode_is_fast_symlink(struct inode *inode)
41{
42 int ea_blocks = EXT3_I(inode)->i_file_acl ?
43 (inode->i_sb->s_blocksize >> 9) : 0;
44
45 return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
46}
47
48
49
50
51
52
53
54
55
56
57int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
58 struct buffer_head *bh, ext3_fsblk_t blocknr)
59{
60 int err;
61
62 might_sleep();
63
64 trace_ext3_forget(inode, is_metadata, blocknr);
65 BUFFER_TRACE(bh, "enter");
66
67 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
68 "data mode %lx\n",
69 bh, is_metadata, inode->i_mode,
70 test_opt(inode->i_sb, DATA_FLAGS));
71
72
73
74
75
76
77 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ||
78 (!is_metadata && !ext3_should_journal_data(inode))) {
79 if (bh) {
80 BUFFER_TRACE(bh, "call journal_forget");
81 return ext3_journal_forget(handle, bh);
82 }
83 return 0;
84 }
85
86
87
88
89 BUFFER_TRACE(bh, "call ext3_journal_revoke");
90 err = ext3_journal_revoke(handle, blocknr, bh);
91 if (err)
92 ext3_abort(inode->i_sb, __func__,
93 "error %d when attempting revoke", err);
94 BUFFER_TRACE(bh, "exit");
95 return err;
96}
97
98
99
100
101
102static unsigned long blocks_for_truncate(struct inode *inode)
103{
104 unsigned long needed;
105
106 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
107
108
109
110
111
112
113
114 if (needed < 2)
115 needed = 2;
116
117
118
119 if (needed > EXT3_MAX_TRANS_DATA)
120 needed = EXT3_MAX_TRANS_DATA;
121
122 return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
123}
124
125
126
127
128
129
130
131
132
133
134
135static handle_t *start_transaction(struct inode *inode)
136{
137 handle_t *result;
138
139 result = ext3_journal_start(inode, blocks_for_truncate(inode));
140 if (!IS_ERR(result))
141 return result;
142
143 ext3_std_error(inode->i_sb, PTR_ERR(result));
144 return result;
145}
146
147
148
149
150
151
152
153static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
154{
155 if (handle->h_buffer_credits > EXT3_RESERVE_TRANS_BLOCKS)
156 return 0;
157 if (!ext3_journal_extend(handle, blocks_for_truncate(inode)))
158 return 0;
159 return 1;
160}
161
162
163
164
165
166
167static int truncate_restart_transaction(handle_t *handle, struct inode *inode)
168{
169 int ret;
170
171 jbd_debug(2, "restarting handle %p\n", handle);
172
173
174
175
176
177
178 mutex_unlock(&EXT3_I(inode)->truncate_mutex);
179 ret = ext3_journal_restart(handle, blocks_for_truncate(inode));
180 mutex_lock(&EXT3_I(inode)->truncate_mutex);
181 return ret;
182}
183
184
185
186
187void ext3_evict_inode (struct inode *inode)
188{
189 struct ext3_inode_info *ei = EXT3_I(inode);
190 struct ext3_block_alloc_info *rsv;
191 handle_t *handle;
192 int want_delete = 0;
193
194 trace_ext3_evict_inode(inode);
195 if (!inode->i_nlink && !is_bad_inode(inode)) {
196 dquot_initialize(inode);
197 want_delete = 1;
198 }
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219 if (inode->i_nlink && ext3_should_journal_data(inode) &&
220 EXT3_SB(inode->i_sb)->s_journal &&
221 (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {
222 tid_t commit_tid = atomic_read(&ei->i_datasync_tid);
223 journal_t *journal = EXT3_SB(inode->i_sb)->s_journal;
224
225 log_start_commit(journal, commit_tid);
226 log_wait_commit(journal, commit_tid);
227 filemap_write_and_wait(&inode->i_data);
228 }
229 truncate_inode_pages(&inode->i_data, 0);
230
231 ext3_discard_reservation(inode);
232 rsv = ei->i_block_alloc_info;
233 ei->i_block_alloc_info = NULL;
234 if (unlikely(rsv))
235 kfree(rsv);
236
237 if (!want_delete)
238 goto no_delete;
239
240 handle = start_transaction(inode);
241 if (IS_ERR(handle)) {
242
243
244
245
246
247 ext3_orphan_del(NULL, inode);
248 goto no_delete;
249 }
250
251 if (IS_SYNC(inode))
252 handle->h_sync = 1;
253 inode->i_size = 0;
254 if (inode->i_blocks)
255 ext3_truncate(inode);
256
257
258
259
260
261
262 ext3_orphan_del(handle, inode);
263 ei->i_dtime = get_seconds();
264
265
266
267
268
269
270
271
272 if (ext3_mark_inode_dirty(handle, inode)) {
273
274 dquot_drop(inode);
275 clear_inode(inode);
276 } else {
277 ext3_xattr_delete_inode(handle, inode);
278 dquot_free_inode(inode);
279 dquot_drop(inode);
280 clear_inode(inode);
281 ext3_free_inode(handle, inode);
282 }
283 ext3_journal_stop(handle);
284 return;
285no_delete:
286 clear_inode(inode);
287 dquot_drop(inode);
288}
289
290typedef struct {
291 __le32 *p;
292 __le32 key;
293 struct buffer_head *bh;
294} Indirect;
295
296static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
297{
298 p->key = *(p->p = v);
299 p->bh = bh;
300}
301
302static int verify_chain(Indirect *from, Indirect *to)
303{
304 while (from <= to && from->key == *from->p)
305 from++;
306 return (from > to);
307}
308
309
310
311
312
313
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
340static int ext3_block_to_path(struct inode *inode,
341 long i_block, int offsets[4], int *boundary)
342{
343 int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb);
344 int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb);
345 const long direct_blocks = EXT3_NDIR_BLOCKS,
346 indirect_blocks = ptrs,
347 double_blocks = (1 << (ptrs_bits * 2));
348 int n = 0;
349 int final = 0;
350
351 if (i_block < 0) {
352 ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0");
353 } else if (i_block < direct_blocks) {
354 offsets[n++] = i_block;
355 final = direct_blocks;
356 } else if ( (i_block -= direct_blocks) < indirect_blocks) {
357 offsets[n++] = EXT3_IND_BLOCK;
358 offsets[n++] = i_block;
359 final = ptrs;
360 } else if ((i_block -= indirect_blocks) < double_blocks) {
361 offsets[n++] = EXT3_DIND_BLOCK;
362 offsets[n++] = i_block >> ptrs_bits;
363 offsets[n++] = i_block & (ptrs - 1);
364 final = ptrs;
365 } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
366 offsets[n++] = EXT3_TIND_BLOCK;
367 offsets[n++] = i_block >> (ptrs_bits * 2);
368 offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
369 offsets[n++] = i_block & (ptrs - 1);
370 final = ptrs;
371 } else {
372 ext3_warning(inode->i_sb, "ext3_block_to_path", "block > big");
373 }
374 if (boundary)
375 *boundary = final - 1 - (i_block & (ptrs - 1));
376 return n;
377}
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408static Indirect *ext3_get_branch(struct inode *inode, int depth, int *offsets,
409 Indirect chain[4], int *err)
410{
411 struct super_block *sb = inode->i_sb;
412 Indirect *p = chain;
413 struct buffer_head *bh;
414
415 *err = 0;
416
417 add_chain (chain, NULL, EXT3_I(inode)->i_data + *offsets);
418 if (!p->key)
419 goto no_block;
420 while (--depth) {
421 bh = sb_bread(sb, le32_to_cpu(p->key));
422 if (!bh)
423 goto failure;
424
425 if (!verify_chain(chain, p))
426 goto changed;
427 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
428
429 if (!p->key)
430 goto no_block;
431 }
432 return NULL;
433
434changed:
435 brelse(bh);
436 *err = -EAGAIN;
437 goto no_block;
438failure:
439 *err = -EIO;
440no_block:
441 return p;
442}
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464static ext3_fsblk_t ext3_find_near(struct inode *inode, Indirect *ind)
465{
466 struct ext3_inode_info *ei = EXT3_I(inode);
467 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
468 __le32 *p;
469 ext3_fsblk_t bg_start;
470 ext3_grpblk_t colour;
471
472
473 for (p = ind->p - 1; p >= start; p--) {
474 if (*p)
475 return le32_to_cpu(*p);
476 }
477
478
479 if (ind->bh)
480 return ind->bh->b_blocknr;
481
482
483
484
485
486 bg_start = ext3_group_first_block_no(inode->i_sb, ei->i_block_group);
487 colour = (current->pid % 16) *
488 (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
489 return bg_start + colour;
490}
491
492
493
494
495
496
497
498
499
500
501
502static ext3_fsblk_t ext3_find_goal(struct inode *inode, long block,
503 Indirect *partial)
504{
505 struct ext3_block_alloc_info *block_i;
506
507 block_i = EXT3_I(inode)->i_block_alloc_info;
508
509
510
511
512
513 if (block_i && (block == block_i->last_alloc_logical_block + 1)
514 && (block_i->last_alloc_physical_block != 0)) {
515 return block_i->last_alloc_physical_block + 1;
516 }
517
518 return ext3_find_near(inode, partial);
519}
520
521
522
523
524
525
526
527
528
529
530
531
532
533static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
534 int blocks_to_boundary)
535{
536 unsigned long count = 0;
537
538
539
540
541
542 if (k > 0) {
543
544 if (blks < blocks_to_boundary + 1)
545 count += blks;
546 else
547 count += blocks_to_boundary + 1;
548 return count;
549 }
550
551 count++;
552 while (count < blks && count <= blocks_to_boundary &&
553 le32_to_cpu(*(branch[0].p + count)) == 0) {
554 count++;
555 }
556 return count;
557}
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573static int ext3_alloc_blocks(handle_t *handle, struct inode *inode,
574 ext3_fsblk_t goal, int indirect_blks, int blks,
575 ext3_fsblk_t new_blocks[4], int *err)
576{
577 int target, i;
578 unsigned long count = 0;
579 int index = 0;
580 ext3_fsblk_t current_block = 0;
581 int ret = 0;
582
583
584
585
586
587
588
589
590
591 target = blks + indirect_blks;
592
593 while (1) {
594 count = target;
595
596 current_block = ext3_new_blocks(handle,inode,goal,&count,err);
597 if (*err)
598 goto failed_out;
599
600 target -= count;
601
602 while (index < indirect_blks && count) {
603 new_blocks[index++] = current_block++;
604 count--;
605 }
606
607 if (count > 0)
608 break;
609 }
610
611
612 new_blocks[index] = current_block;
613
614
615 ret = count;
616 *err = 0;
617 return ret;
618failed_out:
619 for (i = 0; i <index; i++)
620 ext3_free_blocks(handle, inode, new_blocks[i], 1);
621 return ret;
622}
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
652 int indirect_blks, int *blks, ext3_fsblk_t goal,
653 int *offsets, Indirect *branch)
654{
655 int blocksize = inode->i_sb->s_blocksize;
656 int i, n = 0;
657 int err = 0;
658 struct buffer_head *bh;
659 int num;
660 ext3_fsblk_t new_blocks[4];
661 ext3_fsblk_t current_block;
662
663 num = ext3_alloc_blocks(handle, inode, goal, indirect_blks,
664 *blks, new_blocks, &err);
665 if (err)
666 return err;
667
668 branch[0].key = cpu_to_le32(new_blocks[0]);
669
670
671
672 for (n = 1; n <= indirect_blks; n++) {
673
674
675
676
677
678 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
679 if (unlikely(!bh)) {
680 err = -ENOMEM;
681 goto failed;
682 }
683 branch[n].bh = bh;
684 lock_buffer(bh);
685 BUFFER_TRACE(bh, "call get_create_access");
686 err = ext3_journal_get_create_access(handle, bh);
687 if (err) {
688 unlock_buffer(bh);
689 brelse(bh);
690 goto failed;
691 }
692
693 memset(bh->b_data, 0, blocksize);
694 branch[n].p = (__le32 *) bh->b_data + offsets[n];
695 branch[n].key = cpu_to_le32(new_blocks[n]);
696 *branch[n].p = branch[n].key;
697 if ( n == indirect_blks) {
698 current_block = new_blocks[n];
699
700
701
702
703
704 for (i=1; i < num; i++)
705 *(branch[n].p + i) = cpu_to_le32(++current_block);
706 }
707 BUFFER_TRACE(bh, "marking uptodate");
708 set_buffer_uptodate(bh);
709 unlock_buffer(bh);
710
711 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
712 err = ext3_journal_dirty_metadata(handle, bh);
713 if (err)
714 goto failed;
715 }
716 *blks = num;
717 return err;
718failed:
719
720 for (i = 1; i <= n ; i++) {
721 BUFFER_TRACE(branch[i].bh, "call journal_forget");
722 ext3_journal_forget(handle, branch[i].bh);
723 }
724 for (i = 0; i < indirect_blks; i++)
725 ext3_free_blocks(handle, inode, new_blocks[i], 1);
726
727 ext3_free_blocks(handle, inode, new_blocks[i], num);
728
729 return err;
730}
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745static int ext3_splice_branch(handle_t *handle, struct inode *inode,
746 long block, Indirect *where, int num, int blks)
747{
748 int i;
749 int err = 0;
750 struct ext3_block_alloc_info *block_i;
751 ext3_fsblk_t current_block;
752 struct ext3_inode_info *ei = EXT3_I(inode);
753 struct timespec now;
754
755 block_i = ei->i_block_alloc_info;
756
757
758
759
760
761 if (where->bh) {
762 BUFFER_TRACE(where->bh, "get_write_access");
763 err = ext3_journal_get_write_access(handle, where->bh);
764 if (err)
765 goto err_out;
766 }
767
768
769 *where->p = where->key;
770
771
772
773
774
775 if (num == 0 && blks > 1) {
776 current_block = le32_to_cpu(where->key) + 1;
777 for (i = 1; i < blks; i++)
778 *(where->p + i ) = cpu_to_le32(current_block++);
779 }
780
781
782
783
784
785
786 if (block_i) {
787 block_i->last_alloc_logical_block = block + blks - 1;
788 block_i->last_alloc_physical_block =
789 le32_to_cpu(where[num].key) + blks - 1;
790 }
791
792
793 now = CURRENT_TIME_SEC;
794 if (!timespec_equal(&inode->i_ctime, &now) || !where->bh) {
795 inode->i_ctime = now;
796 ext3_mark_inode_dirty(handle, inode);
797 }
798
799 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
800
801
802 if (where->bh) {
803
804
805
806
807
808
809
810
811 jbd_debug(5, "splicing indirect only\n");
812 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
813 err = ext3_journal_dirty_metadata(handle, where->bh);
814 if (err)
815 goto err_out;
816 } else {
817
818
819
820
821 jbd_debug(5, "splicing direct\n");
822 }
823 return err;
824
825err_out:
826 for (i = 1; i <= num; i++) {
827 BUFFER_TRACE(where[i].bh, "call journal_forget");
828 ext3_journal_forget(handle, where[i].bh);
829 ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
830 }
831 ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
832
833 return err;
834}
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
856 sector_t iblock, unsigned long maxblocks,
857 struct buffer_head *bh_result,
858 int create)
859{
860 int err = -EIO;
861 int offsets[4];
862 Indirect chain[4];
863 Indirect *partial;
864 ext3_fsblk_t goal;
865 int indirect_blks;
866 int blocks_to_boundary = 0;
867 int depth;
868 struct ext3_inode_info *ei = EXT3_I(inode);
869 int count = 0;
870 ext3_fsblk_t first_block = 0;
871
872
873 trace_ext3_get_blocks_enter(inode, iblock, maxblocks, create);
874 J_ASSERT(handle != NULL || create == 0);
875 depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
876
877 if (depth == 0)
878 goto out;
879
880 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
881
882
883 if (!partial) {
884 first_block = le32_to_cpu(chain[depth - 1].key);
885 clear_buffer_new(bh_result);
886 count++;
887
888 while (count < maxblocks && count <= blocks_to_boundary) {
889 ext3_fsblk_t blk;
890
891 if (!verify_chain(chain, chain + depth - 1)) {
892
893
894
895
896
897
898
899 err = -EAGAIN;
900 count = 0;
901 break;
902 }
903 blk = le32_to_cpu(*(chain[depth-1].p + count));
904
905 if (blk == first_block + count)
906 count++;
907 else
908 break;
909 }
910 if (err != -EAGAIN)
911 goto got_it;
912 }
913
914
915 if (!create || err == -EIO)
916 goto cleanup;
917
918
919
920
921 mutex_lock(&ei->truncate_mutex);
922
923
924
925
926
927
928
929
930
931
932
933
934
935 if (err == -EAGAIN || !verify_chain(chain, partial)) {
936 while (partial > chain) {
937 brelse(partial->bh);
938 partial--;
939 }
940 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
941 if (!partial) {
942 count++;
943 mutex_unlock(&ei->truncate_mutex);
944 if (err)
945 goto cleanup;
946 clear_buffer_new(bh_result);
947 goto got_it;
948 }
949 }
950
951
952
953
954
955 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
956 ext3_init_block_alloc_info(inode);
957
958 goal = ext3_find_goal(inode, iblock, partial);
959
960
961 indirect_blks = (chain + depth) - partial - 1;
962
963
964
965
966
967 count = ext3_blks_to_allocate(partial, indirect_blks,
968 maxblocks, blocks_to_boundary);
969 err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
970 offsets + (partial - chain), partial);
971
972
973
974
975
976
977
978
979 if (!err)
980 err = ext3_splice_branch(handle, inode, iblock,
981 partial, indirect_blks, count);
982 mutex_unlock(&ei->truncate_mutex);
983 if (err)
984 goto cleanup;
985
986 set_buffer_new(bh_result);
987got_it:
988 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
989 if (count > blocks_to_boundary)
990 set_buffer_boundary(bh_result);
991 err = count;
992
993 partial = chain + depth - 1;
994cleanup:
995 while (partial > chain) {
996 BUFFER_TRACE(partial->bh, "call brelse");
997 brelse(partial->bh);
998 partial--;
999 }
1000 BUFFER_TRACE(bh_result, "returned");
1001out:
1002 trace_ext3_get_blocks_exit(inode, iblock,
1003 depth ? le32_to_cpu(chain[depth-1].key) : 0,
1004 count, err);
1005 return err;
1006}
1007
1008
1009#define DIO_MAX_BLOCKS 4096
1010
1011
1012
1013
1014
1015
1016
1017#define DIO_CREDITS 25
1018
1019static int ext3_get_block(struct inode *inode, sector_t iblock,
1020 struct buffer_head *bh_result, int create)
1021{
1022 handle_t *handle = ext3_journal_current_handle();
1023 int ret = 0, started = 0;
1024 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
1025
1026 if (create && !handle) {
1027 if (max_blocks > DIO_MAX_BLOCKS)
1028 max_blocks = DIO_MAX_BLOCKS;
1029 handle = ext3_journal_start(inode, DIO_CREDITS +
1030 EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
1031 if (IS_ERR(handle)) {
1032 ret = PTR_ERR(handle);
1033 goto out;
1034 }
1035 started = 1;
1036 }
1037
1038 ret = ext3_get_blocks_handle(handle, inode, iblock,
1039 max_blocks, bh_result, create);
1040 if (ret > 0) {
1041 bh_result->b_size = (ret << inode->i_blkbits);
1042 ret = 0;
1043 }
1044 if (started)
1045 ext3_journal_stop(handle);
1046out:
1047 return ret;
1048}
1049
1050int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1051 u64 start, u64 len)
1052{
1053 return generic_block_fiemap(inode, fieinfo, start, len,
1054 ext3_get_block);
1055}
1056
1057
1058
1059
1060struct buffer_head *ext3_getblk(handle_t *handle, struct inode *inode,
1061 long block, int create, int *errp)
1062{
1063 struct buffer_head dummy;
1064 int fatal = 0, err;
1065
1066 J_ASSERT(handle != NULL || create == 0);
1067
1068 dummy.b_state = 0;
1069 dummy.b_blocknr = -1000;
1070 buffer_trace_init(&dummy.b_history);
1071 err = ext3_get_blocks_handle(handle, inode, block, 1,
1072 &dummy, create);
1073
1074
1075
1076
1077 if (err > 0) {
1078 WARN_ON(err > 1);
1079 err = 0;
1080 }
1081 *errp = err;
1082 if (!err && buffer_mapped(&dummy)) {
1083 struct buffer_head *bh;
1084 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1085 if (unlikely(!bh)) {
1086 *errp = -ENOMEM;
1087 goto err;
1088 }
1089 if (buffer_new(&dummy)) {
1090 J_ASSERT(create != 0);
1091 J_ASSERT(handle != NULL);
1092
1093
1094
1095
1096
1097
1098
1099
1100 lock_buffer(bh);
1101 BUFFER_TRACE(bh, "call get_create_access");
1102 fatal = ext3_journal_get_create_access(handle, bh);
1103 if (!fatal && !buffer_uptodate(bh)) {
1104 memset(bh->b_data,0,inode->i_sb->s_blocksize);
1105 set_buffer_uptodate(bh);
1106 }
1107 unlock_buffer(bh);
1108 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1109 err = ext3_journal_dirty_metadata(handle, bh);
1110 if (!fatal)
1111 fatal = err;
1112 } else {
1113 BUFFER_TRACE(bh, "not a new buffer");
1114 }
1115 if (fatal) {
1116 *errp = fatal;
1117 brelse(bh);
1118 bh = NULL;
1119 }
1120 return bh;
1121 }
1122err:
1123 return NULL;
1124}
1125
1126struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
1127 int block, int create, int *err)
1128{
1129 struct buffer_head * bh;
1130
1131 bh = ext3_getblk(handle, inode, block, create, err);
1132 if (!bh)
1133 return bh;
1134 if (bh_uptodate_or_lock(bh))
1135 return bh;
1136 get_bh(bh);
1137 bh->b_end_io = end_buffer_read_sync;
1138 submit_bh(READ | REQ_META | REQ_PRIO, bh);
1139 wait_on_buffer(bh);
1140 if (buffer_uptodate(bh))
1141 return bh;
1142 put_bh(bh);
1143 *err = -EIO;
1144 return NULL;
1145}
1146
1147static int walk_page_buffers( handle_t *handle,
1148 struct buffer_head *head,
1149 unsigned from,
1150 unsigned to,
1151 int *partial,
1152 int (*fn)( handle_t *handle,
1153 struct buffer_head *bh))
1154{
1155 struct buffer_head *bh;
1156 unsigned block_start, block_end;
1157 unsigned blocksize = head->b_size;
1158 int err, ret = 0;
1159 struct buffer_head *next;
1160
1161 for ( bh = head, block_start = 0;
1162 ret == 0 && (bh != head || !block_start);
1163 block_start = block_end, bh = next)
1164 {
1165 next = bh->b_this_page;
1166 block_end = block_start + blocksize;
1167 if (block_end <= from || block_start >= to) {
1168 if (partial && !buffer_uptodate(bh))
1169 *partial = 1;
1170 continue;
1171 }
1172 err = (*fn)(handle, bh);
1173 if (!ret)
1174 ret = err;
1175 }
1176 return ret;
1177}
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204static int do_journal_get_write_access(handle_t *handle,
1205 struct buffer_head *bh)
1206{
1207 int dirty = buffer_dirty(bh);
1208 int ret;
1209
1210 if (!buffer_mapped(bh) || buffer_freed(bh))
1211 return 0;
1212
1213
1214
1215
1216
1217
1218
1219
1220 if (dirty)
1221 clear_buffer_dirty(bh);
1222 ret = ext3_journal_get_write_access(handle, bh);
1223 if (!ret && dirty)
1224 ret = ext3_journal_dirty_metadata(handle, bh);
1225 return ret;
1226}
1227
1228
1229
1230
1231
1232static void ext3_truncate_failed_write(struct inode *inode)
1233{
1234 truncate_inode_pages(inode->i_mapping, inode->i_size);
1235 ext3_truncate(inode);
1236}
1237
1238
1239
1240
1241
1242static void ext3_truncate_failed_direct_write(struct inode *inode)
1243{
1244 ext3_block_truncate_page(inode, inode->i_size);
1245 ext3_truncate(inode);
1246}
1247
1248static int ext3_write_begin(struct file *file, struct address_space *mapping,
1249 loff_t pos, unsigned len, unsigned flags,
1250 struct page **pagep, void **fsdata)
1251{
1252 struct inode *inode = mapping->host;
1253 int ret;
1254 handle_t *handle;
1255 int retries = 0;
1256 struct page *page;
1257 pgoff_t index;
1258 unsigned from, to;
1259
1260
1261 int needed_blocks = ext3_writepage_trans_blocks(inode) + 1;
1262
1263 trace_ext3_write_begin(inode, pos, len, flags);
1264
1265 index = pos >> PAGE_CACHE_SHIFT;
1266 from = pos & (PAGE_CACHE_SIZE - 1);
1267 to = from + len;
1268
1269retry:
1270 page = grab_cache_page_write_begin(mapping, index, flags);
1271 if (!page)
1272 return -ENOMEM;
1273 *pagep = page;
1274
1275 handle = ext3_journal_start(inode, needed_blocks);
1276 if (IS_ERR(handle)) {
1277 unlock_page(page);
1278 page_cache_release(page);
1279 ret = PTR_ERR(handle);
1280 goto out;
1281 }
1282 ret = __block_write_begin(page, pos, len, ext3_get_block);
1283 if (ret)
1284 goto write_begin_failed;
1285
1286 if (ext3_should_journal_data(inode)) {
1287 ret = walk_page_buffers(handle, page_buffers(page),
1288 from, to, NULL, do_journal_get_write_access);
1289 }
1290write_begin_failed:
1291 if (ret) {
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1302 ext3_orphan_add(handle, inode);
1303 ext3_journal_stop(handle);
1304 unlock_page(page);
1305 page_cache_release(page);
1306 if (pos + len > inode->i_size)
1307 ext3_truncate_failed_write(inode);
1308 }
1309 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1310 goto retry;
1311out:
1312 return ret;
1313}
1314
1315
1316int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1317{
1318 int err = journal_dirty_data(handle, bh);
1319 if (err)
1320 ext3_journal_abort_handle(__func__, __func__,
1321 bh, handle, err);
1322 return err;
1323}
1324
1325
1326static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1327{
1328
1329
1330
1331
1332 if (buffer_mapped(bh) && buffer_uptodate(bh))
1333 return ext3_journal_dirty_data(handle, bh);
1334 return 0;
1335}
1336
1337
1338static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1339{
1340 if (!buffer_mapped(bh) || buffer_freed(bh))
1341 return 0;
1342 set_buffer_uptodate(bh);
1343 return ext3_journal_dirty_metadata(handle, bh);
1344}
1345
1346
1347
1348
1349
1350
1351
1352static void update_file_sizes(struct inode *inode, loff_t pos, unsigned copied)
1353{
1354
1355 if (pos + copied > inode->i_size)
1356 i_size_write(inode, pos + copied);
1357 if (pos + copied > EXT3_I(inode)->i_disksize) {
1358 EXT3_I(inode)->i_disksize = pos + copied;
1359 mark_inode_dirty(inode);
1360 }
1361}
1362
1363
1364
1365
1366
1367
1368
1369
1370static int ext3_ordered_write_end(struct file *file,
1371 struct address_space *mapping,
1372 loff_t pos, unsigned len, unsigned copied,
1373 struct page *page, void *fsdata)
1374{
1375 handle_t *handle = ext3_journal_current_handle();
1376 struct inode *inode = file->f_mapping->host;
1377 unsigned from, to;
1378 int ret = 0, ret2;
1379
1380 trace_ext3_ordered_write_end(inode, pos, len, copied);
1381 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1382
1383 from = pos & (PAGE_CACHE_SIZE - 1);
1384 to = from + copied;
1385 ret = walk_page_buffers(handle, page_buffers(page),
1386 from, to, NULL, journal_dirty_data_fn);
1387
1388 if (ret == 0)
1389 update_file_sizes(inode, pos, copied);
1390
1391
1392
1393
1394 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1395 ext3_orphan_add(handle, inode);
1396 ret2 = ext3_journal_stop(handle);
1397 if (!ret)
1398 ret = ret2;
1399 unlock_page(page);
1400 page_cache_release(page);
1401
1402 if (pos + len > inode->i_size)
1403 ext3_truncate_failed_write(inode);
1404 return ret ? ret : copied;
1405}
1406
1407static int ext3_writeback_write_end(struct file *file,
1408 struct address_space *mapping,
1409 loff_t pos, unsigned len, unsigned copied,
1410 struct page *page, void *fsdata)
1411{
1412 handle_t *handle = ext3_journal_current_handle();
1413 struct inode *inode = file->f_mapping->host;
1414 int ret;
1415
1416 trace_ext3_writeback_write_end(inode, pos, len, copied);
1417 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1418 update_file_sizes(inode, pos, copied);
1419
1420
1421
1422
1423 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1424 ext3_orphan_add(handle, inode);
1425 ret = ext3_journal_stop(handle);
1426 unlock_page(page);
1427 page_cache_release(page);
1428
1429 if (pos + len > inode->i_size)
1430 ext3_truncate_failed_write(inode);
1431 return ret ? ret : copied;
1432}
1433
1434static int ext3_journalled_write_end(struct file *file,
1435 struct address_space *mapping,
1436 loff_t pos, unsigned len, unsigned copied,
1437 struct page *page, void *fsdata)
1438{
1439 handle_t *handle = ext3_journal_current_handle();
1440 struct inode *inode = mapping->host;
1441 struct ext3_inode_info *ei = EXT3_I(inode);
1442 int ret = 0, ret2;
1443 int partial = 0;
1444 unsigned from, to;
1445
1446 trace_ext3_journalled_write_end(inode, pos, len, copied);
1447 from = pos & (PAGE_CACHE_SIZE - 1);
1448 to = from + len;
1449
1450 if (copied < len) {
1451 if (!PageUptodate(page))
1452 copied = 0;
1453 page_zero_new_buffers(page, from + copied, to);
1454 to = from + copied;
1455 }
1456
1457 ret = walk_page_buffers(handle, page_buffers(page), from,
1458 to, &partial, write_end_fn);
1459 if (!partial)
1460 SetPageUptodate(page);
1461
1462 if (pos + copied > inode->i_size)
1463 i_size_write(inode, pos + copied);
1464
1465
1466
1467
1468 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1469 ext3_orphan_add(handle, inode);
1470 ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1471 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
1472 if (inode->i_size > ei->i_disksize) {
1473 ei->i_disksize = inode->i_size;
1474 ret2 = ext3_mark_inode_dirty(handle, inode);
1475 if (!ret)
1476 ret = ret2;
1477 }
1478
1479 ret2 = ext3_journal_stop(handle);
1480 if (!ret)
1481 ret = ret2;
1482 unlock_page(page);
1483 page_cache_release(page);
1484
1485 if (pos + len > inode->i_size)
1486 ext3_truncate_failed_write(inode);
1487 return ret ? ret : copied;
1488}
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1505{
1506 struct inode *inode = mapping->host;
1507 journal_t *journal;
1508 int err;
1509
1510 if (ext3_test_inode_state(inode, EXT3_STATE_JDATA)) {
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529 ext3_clear_inode_state(inode, EXT3_STATE_JDATA);
1530 journal = EXT3_JOURNAL(inode);
1531 journal_lock_updates(journal);
1532 err = journal_flush(journal);
1533 journal_unlock_updates(journal);
1534
1535 if (err)
1536 return 0;
1537 }
1538
1539 return generic_block_bmap(mapping,block,ext3_get_block);
1540}
1541
1542static int bget_one(handle_t *handle, struct buffer_head *bh)
1543{
1544 get_bh(bh);
1545 return 0;
1546}
1547
1548static int bput_one(handle_t *handle, struct buffer_head *bh)
1549{
1550 put_bh(bh);
1551 return 0;
1552}
1553
1554static int buffer_unmapped(handle_t *handle, struct buffer_head *bh)
1555{
1556 return !buffer_mapped(bh);
1557}
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611static int ext3_ordered_writepage(struct page *page,
1612 struct writeback_control *wbc)
1613{
1614 struct inode *inode = page->mapping->host;
1615 struct buffer_head *page_bufs;
1616 handle_t *handle = NULL;
1617 int ret = 0;
1618 int err;
1619
1620 J_ASSERT(PageLocked(page));
1621
1622
1623
1624
1625
1626 WARN_ON_ONCE(IS_RDONLY(inode) &&
1627 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
1628
1629
1630
1631
1632
1633 if (ext3_journal_current_handle())
1634 goto out_fail;
1635
1636 trace_ext3_ordered_writepage(page);
1637 if (!page_has_buffers(page)) {
1638 create_empty_buffers(page, inode->i_sb->s_blocksize,
1639 (1 << BH_Dirty)|(1 << BH_Uptodate));
1640 page_bufs = page_buffers(page);
1641 } else {
1642 page_bufs = page_buffers(page);
1643 if (!walk_page_buffers(NULL, page_bufs, 0, PAGE_CACHE_SIZE,
1644 NULL, buffer_unmapped)) {
1645
1646
1647 return block_write_full_page(page, NULL, wbc);
1648 }
1649 }
1650 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1651
1652 if (IS_ERR(handle)) {
1653 ret = PTR_ERR(handle);
1654 goto out_fail;
1655 }
1656
1657 walk_page_buffers(handle, page_bufs, 0,
1658 PAGE_CACHE_SIZE, NULL, bget_one);
1659
1660 ret = block_write_full_page(page, ext3_get_block, wbc);
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674 if (ret == 0) {
1675 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1676 NULL, journal_dirty_data_fn);
1677 if (!ret)
1678 ret = err;
1679 }
1680 walk_page_buffers(handle, page_bufs, 0,
1681 PAGE_CACHE_SIZE, NULL, bput_one);
1682 err = ext3_journal_stop(handle);
1683 if (!ret)
1684 ret = err;
1685 return ret;
1686
1687out_fail:
1688 redirty_page_for_writepage(wbc, page);
1689 unlock_page(page);
1690 return ret;
1691}
1692
1693static int ext3_writeback_writepage(struct page *page,
1694 struct writeback_control *wbc)
1695{
1696 struct inode *inode = page->mapping->host;
1697 handle_t *handle = NULL;
1698 int ret = 0;
1699 int err;
1700
1701 J_ASSERT(PageLocked(page));
1702
1703
1704
1705
1706
1707 WARN_ON_ONCE(IS_RDONLY(inode) &&
1708 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
1709
1710 if (ext3_journal_current_handle())
1711 goto out_fail;
1712
1713 trace_ext3_writeback_writepage(page);
1714 if (page_has_buffers(page)) {
1715 if (!walk_page_buffers(NULL, page_buffers(page), 0,
1716 PAGE_CACHE_SIZE, NULL, buffer_unmapped)) {
1717
1718
1719 return block_write_full_page(page, NULL, wbc);
1720 }
1721 }
1722
1723 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1724 if (IS_ERR(handle)) {
1725 ret = PTR_ERR(handle);
1726 goto out_fail;
1727 }
1728
1729 ret = block_write_full_page(page, ext3_get_block, wbc);
1730
1731 err = ext3_journal_stop(handle);
1732 if (!ret)
1733 ret = err;
1734 return ret;
1735
1736out_fail:
1737 redirty_page_for_writepage(wbc, page);
1738 unlock_page(page);
1739 return ret;
1740}
1741
1742static int ext3_journalled_writepage(struct page *page,
1743 struct writeback_control *wbc)
1744{
1745 struct inode *inode = page->mapping->host;
1746 handle_t *handle = NULL;
1747 int ret = 0;
1748 int err;
1749
1750 J_ASSERT(PageLocked(page));
1751
1752
1753
1754
1755
1756 WARN_ON_ONCE(IS_RDONLY(inode) &&
1757 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
1758
1759 if (ext3_journal_current_handle())
1760 goto no_write;
1761
1762 trace_ext3_journalled_writepage(page);
1763 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1764 if (IS_ERR(handle)) {
1765 ret = PTR_ERR(handle);
1766 goto no_write;
1767 }
1768
1769 if (!page_has_buffers(page) || PageChecked(page)) {
1770
1771
1772
1773
1774 ClearPageChecked(page);
1775 ret = __block_write_begin(page, 0, PAGE_CACHE_SIZE,
1776 ext3_get_block);
1777 if (ret != 0) {
1778 ext3_journal_stop(handle);
1779 goto out_unlock;
1780 }
1781 ret = walk_page_buffers(handle, page_buffers(page), 0,
1782 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1783
1784 err = walk_page_buffers(handle, page_buffers(page), 0,
1785 PAGE_CACHE_SIZE, NULL, write_end_fn);
1786 if (ret == 0)
1787 ret = err;
1788 ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1789 atomic_set(&EXT3_I(inode)->i_datasync_tid,
1790 handle->h_transaction->t_tid);
1791 unlock_page(page);
1792 } else {
1793
1794
1795
1796
1797
1798 ret = block_write_full_page(page, ext3_get_block, wbc);
1799 }
1800 err = ext3_journal_stop(handle);
1801 if (!ret)
1802 ret = err;
1803out:
1804 return ret;
1805
1806no_write:
1807 redirty_page_for_writepage(wbc, page);
1808out_unlock:
1809 unlock_page(page);
1810 goto out;
1811}
1812
1813static int ext3_readpage(struct file *file, struct page *page)
1814{
1815 trace_ext3_readpage(page);
1816 return mpage_readpage(page, ext3_get_block);
1817}
1818
1819static int
1820ext3_readpages(struct file *file, struct address_space *mapping,
1821 struct list_head *pages, unsigned nr_pages)
1822{
1823 return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1824}
1825
1826static void ext3_invalidatepage(struct page *page, unsigned long offset)
1827{
1828 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1829
1830 trace_ext3_invalidatepage(page, offset);
1831
1832
1833
1834
1835 if (offset == 0)
1836 ClearPageChecked(page);
1837
1838 journal_invalidatepage(journal, page, offset);
1839}
1840
1841static int ext3_releasepage(struct page *page, gfp_t wait)
1842{
1843 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1844
1845 trace_ext3_releasepage(page);
1846 WARN_ON(PageChecked(page));
1847 if (!page_has_buffers(page))
1848 return 0;
1849 return journal_try_to_free_buffers(journal, page, wait);
1850}
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1862 const struct iovec *iov, loff_t offset,
1863 unsigned long nr_segs)
1864{
1865 struct file *file = iocb->ki_filp;
1866 struct inode *inode = file->f_mapping->host;
1867 struct ext3_inode_info *ei = EXT3_I(inode);
1868 handle_t *handle;
1869 ssize_t ret;
1870 int orphan = 0;
1871 size_t count = iov_length(iov, nr_segs);
1872 int retries = 0;
1873
1874 trace_ext3_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
1875
1876 if (rw == WRITE) {
1877 loff_t final_size = offset + count;
1878
1879 if (final_size > inode->i_size) {
1880
1881 handle = ext3_journal_start(inode, 2);
1882 if (IS_ERR(handle)) {
1883 ret = PTR_ERR(handle);
1884 goto out;
1885 }
1886 ret = ext3_orphan_add(handle, inode);
1887 if (ret) {
1888 ext3_journal_stop(handle);
1889 goto out;
1890 }
1891 orphan = 1;
1892 ei->i_disksize = inode->i_size;
1893 ext3_journal_stop(handle);
1894 }
1895 }
1896
1897retry:
1898 ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
1899 ext3_get_block);
1900
1901
1902
1903
1904 if (unlikely((rw & WRITE) && ret < 0)) {
1905 loff_t isize = i_size_read(inode);
1906 loff_t end = offset + iov_length(iov, nr_segs);
1907
1908 if (end > isize)
1909 ext3_truncate_failed_direct_write(inode);
1910 }
1911 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1912 goto retry;
1913
1914 if (orphan) {
1915 int err;
1916
1917
1918 handle = ext3_journal_start(inode, 2);
1919 if (IS_ERR(handle)) {
1920
1921
1922
1923 ext3_truncate_failed_direct_write(inode);
1924 ret = PTR_ERR(handle);
1925 goto out;
1926 }
1927 if (inode->i_nlink)
1928 ext3_orphan_del(handle, inode);
1929 if (ret > 0) {
1930 loff_t end = offset + ret;
1931 if (end > inode->i_size) {
1932 ei->i_disksize = end;
1933 i_size_write(inode, end);
1934
1935
1936
1937
1938
1939
1940
1941 ext3_mark_inode_dirty(handle, inode);
1942 }
1943 }
1944 err = ext3_journal_stop(handle);
1945 if (ret == 0)
1946 ret = err;
1947 }
1948out:
1949 trace_ext3_direct_IO_exit(inode, offset,
1950 iov_length(iov, nr_segs), rw, ret);
1951 return ret;
1952}
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967static int ext3_journalled_set_page_dirty(struct page *page)
1968{
1969 SetPageChecked(page);
1970 return __set_page_dirty_nobuffers(page);
1971}
1972
1973static const struct address_space_operations ext3_ordered_aops = {
1974 .readpage = ext3_readpage,
1975 .readpages = ext3_readpages,
1976 .writepage = ext3_ordered_writepage,
1977 .write_begin = ext3_write_begin,
1978 .write_end = ext3_ordered_write_end,
1979 .bmap = ext3_bmap,
1980 .invalidatepage = ext3_invalidatepage,
1981 .releasepage = ext3_releasepage,
1982 .direct_IO = ext3_direct_IO,
1983 .migratepage = buffer_migrate_page,
1984 .is_partially_uptodate = block_is_partially_uptodate,
1985 .error_remove_page = generic_error_remove_page,
1986};
1987
1988static const struct address_space_operations ext3_writeback_aops = {
1989 .readpage = ext3_readpage,
1990 .readpages = ext3_readpages,
1991 .writepage = ext3_writeback_writepage,
1992 .write_begin = ext3_write_begin,
1993 .write_end = ext3_writeback_write_end,
1994 .bmap = ext3_bmap,
1995 .invalidatepage = ext3_invalidatepage,
1996 .releasepage = ext3_releasepage,
1997 .direct_IO = ext3_direct_IO,
1998 .migratepage = buffer_migrate_page,
1999 .is_partially_uptodate = block_is_partially_uptodate,
2000 .error_remove_page = generic_error_remove_page,
2001};
2002
2003static const struct address_space_operations ext3_journalled_aops = {
2004 .readpage = ext3_readpage,
2005 .readpages = ext3_readpages,
2006 .writepage = ext3_journalled_writepage,
2007 .write_begin = ext3_write_begin,
2008 .write_end = ext3_journalled_write_end,
2009 .set_page_dirty = ext3_journalled_set_page_dirty,
2010 .bmap = ext3_bmap,
2011 .invalidatepage = ext3_invalidatepage,
2012 .releasepage = ext3_releasepage,
2013 .is_partially_uptodate = block_is_partially_uptodate,
2014 .error_remove_page = generic_error_remove_page,
2015};
2016
2017void ext3_set_aops(struct inode *inode)
2018{
2019 if (ext3_should_order_data(inode))
2020 inode->i_mapping->a_ops = &ext3_ordered_aops;
2021 else if (ext3_should_writeback_data(inode))
2022 inode->i_mapping->a_ops = &ext3_writeback_aops;
2023 else
2024 inode->i_mapping->a_ops = &ext3_journalled_aops;
2025}
2026
2027
2028
2029
2030
2031
2032
2033static int ext3_block_truncate_page(struct inode *inode, loff_t from)
2034{
2035 ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
2036 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
2037 unsigned blocksize, iblock, length, pos;
2038 struct page *page;
2039 handle_t *handle = NULL;
2040 struct buffer_head *bh;
2041 int err = 0;
2042
2043
2044 blocksize = inode->i_sb->s_blocksize;
2045 if ((from & (blocksize - 1)) == 0)
2046 return 0;
2047
2048 page = grab_cache_page(inode->i_mapping, index);
2049 if (!page)
2050 return -ENOMEM;
2051 length = blocksize - (offset & (blocksize - 1));
2052 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
2053
2054 if (!page_has_buffers(page))
2055 create_empty_buffers(page, blocksize, 0);
2056
2057
2058 bh = page_buffers(page);
2059 pos = blocksize;
2060 while (offset >= pos) {
2061 bh = bh->b_this_page;
2062 iblock++;
2063 pos += blocksize;
2064 }
2065
2066 err = 0;
2067 if (buffer_freed(bh)) {
2068 BUFFER_TRACE(bh, "freed: skip");
2069 goto unlock;
2070 }
2071
2072 if (!buffer_mapped(bh)) {
2073 BUFFER_TRACE(bh, "unmapped");
2074 ext3_get_block(inode, iblock, bh, 0);
2075
2076 if (!buffer_mapped(bh)) {
2077 BUFFER_TRACE(bh, "still unmapped");
2078 goto unlock;
2079 }
2080 }
2081
2082
2083 if (PageUptodate(page))
2084 set_buffer_uptodate(bh);
2085
2086 if (!bh_uptodate_or_lock(bh)) {
2087 err = bh_submit_read(bh);
2088
2089 if (err)
2090 goto unlock;
2091 }
2092
2093
2094 if (!ext3_should_writeback_data(inode)) {
2095
2096 handle = ext3_journal_start(inode, 1);
2097 if (IS_ERR(handle)) {
2098 clear_highpage(page);
2099 flush_dcache_page(page);
2100 err = PTR_ERR(handle);
2101 goto unlock;
2102 }
2103 }
2104
2105 if (ext3_should_journal_data(inode)) {
2106 BUFFER_TRACE(bh, "get write access");
2107 err = ext3_journal_get_write_access(handle, bh);
2108 if (err)
2109 goto stop;
2110 }
2111
2112 zero_user(page, offset, length);
2113 BUFFER_TRACE(bh, "zeroed end of block");
2114
2115 err = 0;
2116 if (ext3_should_journal_data(inode)) {
2117 err = ext3_journal_dirty_metadata(handle, bh);
2118 } else {
2119 if (ext3_should_order_data(inode))
2120 err = ext3_journal_dirty_data(handle, bh);
2121 mark_buffer_dirty(bh);
2122 }
2123stop:
2124 if (handle)
2125 ext3_journal_stop(handle);
2126
2127unlock:
2128 unlock_page(page);
2129 page_cache_release(page);
2130 return err;
2131}
2132
2133
2134
2135
2136
2137
2138static inline int all_zeroes(__le32 *p, __le32 *q)
2139{
2140 while (p < q)
2141 if (*p++)
2142 return 0;
2143 return 1;
2144}
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181static Indirect *ext3_find_shared(struct inode *inode, int depth,
2182 int offsets[4], Indirect chain[4], __le32 *top)
2183{
2184 Indirect *partial, *p;
2185 int k, err;
2186
2187 *top = 0;
2188
2189 for (k = depth; k > 1 && !offsets[k-1]; k--)
2190 ;
2191 partial = ext3_get_branch(inode, k, offsets, chain, &err);
2192
2193 if (!partial)
2194 partial = chain + k-1;
2195
2196
2197
2198
2199 if (!partial->key && *partial->p)
2200
2201 goto no_top;
2202 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
2203 ;
2204
2205
2206
2207
2208
2209
2210 if (p == chain + k - 1 && p > chain) {
2211 p->p--;
2212 } else {
2213 *top = *p->p;
2214
2215#if 0
2216 *p->p = 0;
2217#endif
2218 }
2219
2220
2221 while(partial > p) {
2222 brelse(partial->bh);
2223 partial--;
2224 }
2225no_top:
2226 return partial;
2227}
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
2238 struct buffer_head *bh, ext3_fsblk_t block_to_free,
2239 unsigned long count, __le32 *first, __le32 *last)
2240{
2241 __le32 *p;
2242 if (try_to_extend_transaction(handle, inode)) {
2243 if (bh) {
2244 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2245 if (ext3_journal_dirty_metadata(handle, bh))
2246 return;
2247 }
2248 ext3_mark_inode_dirty(handle, inode);
2249 truncate_restart_transaction(handle, inode);
2250 if (bh) {
2251 BUFFER_TRACE(bh, "retaking write access");
2252 if (ext3_journal_get_write_access(handle, bh))
2253 return;
2254 }
2255 }
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265 for (p = first; p < last; p++) {
2266 u32 nr = le32_to_cpu(*p);
2267 if (nr) {
2268 struct buffer_head *bh;
2269
2270 *p = 0;
2271 bh = sb_find_get_block(inode->i_sb, nr);
2272 ext3_forget(handle, 0, inode, bh, nr);
2273 }
2274 }
2275
2276 ext3_free_blocks(handle, inode, block_to_free, count);
2277}
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298static void ext3_free_data(handle_t *handle, struct inode *inode,
2299 struct buffer_head *this_bh,
2300 __le32 *first, __le32 *last)
2301{
2302 ext3_fsblk_t block_to_free = 0;
2303 unsigned long count = 0;
2304 __le32 *block_to_free_p = NULL;
2305
2306
2307 ext3_fsblk_t nr;
2308 __le32 *p;
2309
2310 int err;
2311
2312 if (this_bh) {
2313 BUFFER_TRACE(this_bh, "get_write_access");
2314 err = ext3_journal_get_write_access(handle, this_bh);
2315
2316
2317 if (err)
2318 return;
2319 }
2320
2321 for (p = first; p < last; p++) {
2322 nr = le32_to_cpu(*p);
2323 if (nr) {
2324
2325 if (count == 0) {
2326 block_to_free = nr;
2327 block_to_free_p = p;
2328 count = 1;
2329 } else if (nr == block_to_free + count) {
2330 count++;
2331 } else {
2332 ext3_clear_blocks(handle, inode, this_bh,
2333 block_to_free,
2334 count, block_to_free_p, p);
2335 block_to_free = nr;
2336 block_to_free_p = p;
2337 count = 1;
2338 }
2339 }
2340 }
2341
2342 if (count > 0)
2343 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
2344 count, block_to_free_p, p);
2345
2346 if (this_bh) {
2347 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
2348
2349
2350
2351
2352
2353
2354
2355 if (bh2jh(this_bh))
2356 ext3_journal_dirty_metadata(handle, this_bh);
2357 else
2358 ext3_error(inode->i_sb, "ext3_free_data",
2359 "circular indirect block detected, "
2360 "inode=%lu, block=%llu",
2361 inode->i_ino,
2362 (unsigned long long)this_bh->b_blocknr);
2363 }
2364}
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379static void ext3_free_branches(handle_t *handle, struct inode *inode,
2380 struct buffer_head *parent_bh,
2381 __le32 *first, __le32 *last, int depth)
2382{
2383 ext3_fsblk_t nr;
2384 __le32 *p;
2385
2386 if (is_handle_aborted(handle))
2387 return;
2388
2389 if (depth--) {
2390 struct buffer_head *bh;
2391 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2392 p = last;
2393 while (--p >= first) {
2394 nr = le32_to_cpu(*p);
2395 if (!nr)
2396 continue;
2397
2398
2399 bh = sb_bread(inode->i_sb, nr);
2400
2401
2402
2403
2404
2405 if (!bh) {
2406 ext3_error(inode->i_sb, "ext3_free_branches",
2407 "Read failure, inode=%lu, block="E3FSBLK,
2408 inode->i_ino, nr);
2409 continue;
2410 }
2411
2412
2413 BUFFER_TRACE(bh, "free child branches");
2414 ext3_free_branches(handle, inode, bh,
2415 (__le32*)bh->b_data,
2416 (__le32*)bh->b_data + addr_per_block,
2417 depth);
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435 if (is_handle_aborted(handle))
2436 return;
2437 if (try_to_extend_transaction(handle, inode)) {
2438 ext3_mark_inode_dirty(handle, inode);
2439 truncate_restart_transaction(handle, inode);
2440 }
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2466
2467 ext3_free_blocks(handle, inode, nr, 1);
2468
2469 if (parent_bh) {
2470
2471
2472
2473
2474 BUFFER_TRACE(parent_bh, "get_write_access");
2475 if (!ext3_journal_get_write_access(handle,
2476 parent_bh)){
2477 *p = 0;
2478 BUFFER_TRACE(parent_bh,
2479 "call ext3_journal_dirty_metadata");
2480 ext3_journal_dirty_metadata(handle,
2481 parent_bh);
2482 }
2483 }
2484 }
2485 } else {
2486
2487 BUFFER_TRACE(parent_bh, "free data blocks");
2488 ext3_free_data(handle, inode, parent_bh, first, last);
2489 }
2490}
2491
2492int ext3_can_truncate(struct inode *inode)
2493{
2494 if (S_ISREG(inode->i_mode))
2495 return 1;
2496 if (S_ISDIR(inode->i_mode))
2497 return 1;
2498 if (S_ISLNK(inode->i_mode))
2499 return !ext3_inode_is_fast_symlink(inode);
2500 return 0;
2501}
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531void ext3_truncate(struct inode *inode)
2532{
2533 handle_t *handle;
2534 struct ext3_inode_info *ei = EXT3_I(inode);
2535 __le32 *i_data = ei->i_data;
2536 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2537 int offsets[4];
2538 Indirect chain[4];
2539 Indirect *partial;
2540 __le32 nr = 0;
2541 int n;
2542 long last_block;
2543 unsigned blocksize = inode->i_sb->s_blocksize;
2544
2545 trace_ext3_truncate_enter(inode);
2546
2547 if (!ext3_can_truncate(inode))
2548 goto out_notrans;
2549
2550 if (inode->i_size == 0 && ext3_should_writeback_data(inode))
2551 ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
2552
2553 handle = start_transaction(inode);
2554 if (IS_ERR(handle))
2555 goto out_notrans;
2556
2557 last_block = (inode->i_size + blocksize-1)
2558 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2559 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2560 if (n == 0)
2561 goto out_stop;
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572 if (ext3_orphan_add(handle, inode))
2573 goto out_stop;
2574
2575
2576
2577
2578
2579
2580
2581
2582 ei->i_disksize = inode->i_size;
2583
2584
2585
2586
2587
2588 mutex_lock(&ei->truncate_mutex);
2589
2590 if (n == 1) {
2591 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2592 i_data + EXT3_NDIR_BLOCKS);
2593 goto do_indirects;
2594 }
2595
2596 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2597
2598 if (nr) {
2599 if (partial == chain) {
2600
2601 ext3_free_branches(handle, inode, NULL,
2602 &nr, &nr+1, (chain+n-1) - partial);
2603 *partial->p = 0;
2604
2605
2606
2607
2608 } else {
2609
2610 ext3_free_branches(handle, inode, partial->bh,
2611 partial->p,
2612 partial->p+1, (chain+n-1) - partial);
2613 }
2614 }
2615
2616 while (partial > chain) {
2617 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2618 (__le32*)partial->bh->b_data+addr_per_block,
2619 (chain+n-1) - partial);
2620 BUFFER_TRACE(partial->bh, "call brelse");
2621 brelse (partial->bh);
2622 partial--;
2623 }
2624do_indirects:
2625
2626 switch (offsets[0]) {
2627 default:
2628 nr = i_data[EXT3_IND_BLOCK];
2629 if (nr) {
2630 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
2631 i_data[EXT3_IND_BLOCK] = 0;
2632 }
2633 case EXT3_IND_BLOCK:
2634 nr = i_data[EXT3_DIND_BLOCK];
2635 if (nr) {
2636 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
2637 i_data[EXT3_DIND_BLOCK] = 0;
2638 }
2639 case EXT3_DIND_BLOCK:
2640 nr = i_data[EXT3_TIND_BLOCK];
2641 if (nr) {
2642 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
2643 i_data[EXT3_TIND_BLOCK] = 0;
2644 }
2645 case EXT3_TIND_BLOCK:
2646 ;
2647 }
2648
2649 ext3_discard_reservation(inode);
2650
2651 mutex_unlock(&ei->truncate_mutex);
2652 inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2653 ext3_mark_inode_dirty(handle, inode);
2654
2655
2656
2657
2658
2659 if (IS_SYNC(inode))
2660 handle->h_sync = 1;
2661out_stop:
2662
2663
2664
2665
2666
2667
2668
2669 if (inode->i_nlink)
2670 ext3_orphan_del(handle, inode);
2671
2672 ext3_journal_stop(handle);
2673 trace_ext3_truncate_exit(inode);
2674 return;
2675out_notrans:
2676
2677
2678
2679
2680 if (inode->i_nlink)
2681 ext3_orphan_del(NULL, inode);
2682 trace_ext3_truncate_exit(inode);
2683}
2684
2685static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
2686 unsigned long ino, struct ext3_iloc *iloc)
2687{
2688 unsigned long block_group;
2689 unsigned long offset;
2690 ext3_fsblk_t block;
2691 struct ext3_group_desc *gdp;
2692
2693 if (!ext3_valid_inum(sb, ino)) {
2694
2695
2696
2697
2698
2699 return 0;
2700 }
2701
2702 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2703 gdp = ext3_get_group_desc(sb, block_group, NULL);
2704 if (!gdp)
2705 return 0;
2706
2707
2708
2709 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2710 EXT3_INODE_SIZE(sb);
2711 block = le32_to_cpu(gdp->bg_inode_table) +
2712 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2713
2714 iloc->block_group = block_group;
2715 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2716 return block;
2717}
2718
2719
2720
2721
2722
2723
2724
2725static int __ext3_get_inode_loc(struct inode *inode,
2726 struct ext3_iloc *iloc, int in_mem)
2727{
2728 ext3_fsblk_t block;
2729 struct buffer_head *bh;
2730
2731 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2732 if (!block)
2733 return -EIO;
2734
2735 bh = sb_getblk(inode->i_sb, block);
2736 if (unlikely(!bh)) {
2737 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2738 "unable to read inode block - "
2739 "inode=%lu, block="E3FSBLK,
2740 inode->i_ino, block);
2741 return -ENOMEM;
2742 }
2743 if (!buffer_uptodate(bh)) {
2744 lock_buffer(bh);
2745
2746
2747
2748
2749
2750
2751
2752 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
2753 set_buffer_uptodate(bh);
2754
2755 if (buffer_uptodate(bh)) {
2756
2757 unlock_buffer(bh);
2758 goto has_buffer;
2759 }
2760
2761
2762
2763
2764
2765
2766 if (in_mem) {
2767 struct buffer_head *bitmap_bh;
2768 struct ext3_group_desc *desc;
2769 int inodes_per_buffer;
2770 int inode_offset, i;
2771 int block_group;
2772 int start;
2773
2774 block_group = (inode->i_ino - 1) /
2775 EXT3_INODES_PER_GROUP(inode->i_sb);
2776 inodes_per_buffer = bh->b_size /
2777 EXT3_INODE_SIZE(inode->i_sb);
2778 inode_offset = ((inode->i_ino - 1) %
2779 EXT3_INODES_PER_GROUP(inode->i_sb));
2780 start = inode_offset & ~(inodes_per_buffer - 1);
2781
2782
2783 desc = ext3_get_group_desc(inode->i_sb,
2784 block_group, NULL);
2785 if (!desc)
2786 goto make_io;
2787
2788 bitmap_bh = sb_getblk(inode->i_sb,
2789 le32_to_cpu(desc->bg_inode_bitmap));
2790 if (unlikely(!bitmap_bh))
2791 goto make_io;
2792
2793
2794
2795
2796
2797
2798 if (!buffer_uptodate(bitmap_bh)) {
2799 brelse(bitmap_bh);
2800 goto make_io;
2801 }
2802 for (i = start; i < start + inodes_per_buffer; i++) {
2803 if (i == inode_offset)
2804 continue;
2805 if (ext3_test_bit(i, bitmap_bh->b_data))
2806 break;
2807 }
2808 brelse(bitmap_bh);
2809 if (i == start + inodes_per_buffer) {
2810
2811 memset(bh->b_data, 0, bh->b_size);
2812 set_buffer_uptodate(bh);
2813 unlock_buffer(bh);
2814 goto has_buffer;
2815 }
2816 }
2817
2818make_io:
2819
2820
2821
2822
2823
2824 trace_ext3_load_inode(inode);
2825 get_bh(bh);
2826 bh->b_end_io = end_buffer_read_sync;
2827 submit_bh(READ | REQ_META | REQ_PRIO, bh);
2828 wait_on_buffer(bh);
2829 if (!buffer_uptodate(bh)) {
2830 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2831 "unable to read inode block - "
2832 "inode=%lu, block="E3FSBLK,
2833 inode->i_ino, block);
2834 brelse(bh);
2835 return -EIO;
2836 }
2837 }
2838has_buffer:
2839 iloc->bh = bh;
2840 return 0;
2841}
2842
2843int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2844{
2845
2846 return __ext3_get_inode_loc(inode, iloc,
2847 !ext3_test_inode_state(inode, EXT3_STATE_XATTR));
2848}
2849
2850void ext3_set_inode_flags(struct inode *inode)
2851{
2852 unsigned int flags = EXT3_I(inode)->i_flags;
2853
2854 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2855 if (flags & EXT3_SYNC_FL)
2856 inode->i_flags |= S_SYNC;
2857 if (flags & EXT3_APPEND_FL)
2858 inode->i_flags |= S_APPEND;
2859 if (flags & EXT3_IMMUTABLE_FL)
2860 inode->i_flags |= S_IMMUTABLE;
2861 if (flags & EXT3_NOATIME_FL)
2862 inode->i_flags |= S_NOATIME;
2863 if (flags & EXT3_DIRSYNC_FL)
2864 inode->i_flags |= S_DIRSYNC;
2865}
2866
2867
2868void ext3_get_inode_flags(struct ext3_inode_info *ei)
2869{
2870 unsigned int flags = ei->vfs_inode.i_flags;
2871
2872 ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
2873 EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
2874 if (flags & S_SYNC)
2875 ei->i_flags |= EXT3_SYNC_FL;
2876 if (flags & S_APPEND)
2877 ei->i_flags |= EXT3_APPEND_FL;
2878 if (flags & S_IMMUTABLE)
2879 ei->i_flags |= EXT3_IMMUTABLE_FL;
2880 if (flags & S_NOATIME)
2881 ei->i_flags |= EXT3_NOATIME_FL;
2882 if (flags & S_DIRSYNC)
2883 ei->i_flags |= EXT3_DIRSYNC_FL;
2884}
2885
2886struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
2887{
2888 struct ext3_iloc iloc;
2889 struct ext3_inode *raw_inode;
2890 struct ext3_inode_info *ei;
2891 struct buffer_head *bh;
2892 struct inode *inode;
2893 journal_t *journal = EXT3_SB(sb)->s_journal;
2894 transaction_t *transaction;
2895 long ret;
2896 int block;
2897 uid_t i_uid;
2898 gid_t i_gid;
2899
2900 inode = iget_locked(sb, ino);
2901 if (!inode)
2902 return ERR_PTR(-ENOMEM);
2903 if (!(inode->i_state & I_NEW))
2904 return inode;
2905
2906 ei = EXT3_I(inode);
2907 ei->i_block_alloc_info = NULL;
2908
2909 ret = __ext3_get_inode_loc(inode, &iloc, 0);
2910 if (ret < 0)
2911 goto bad_inode;
2912 bh = iloc.bh;
2913 raw_inode = ext3_raw_inode(&iloc);
2914 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2915 i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2916 i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2917 if(!(test_opt (inode->i_sb, NO_UID32))) {
2918 i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2919 i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2920 }
2921 i_uid_write(inode, i_uid);
2922 i_gid_write(inode, i_gid);
2923 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
2924 inode->i_size = le32_to_cpu(raw_inode->i_size);
2925 inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
2926 inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
2927 inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
2928 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2929
2930 ei->i_state_flags = 0;
2931 ei->i_dir_start_lookup = 0;
2932 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2933
2934
2935
2936
2937
2938 if (inode->i_nlink == 0) {
2939 if (inode->i_mode == 0 ||
2940 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2941
2942 brelse (bh);
2943 ret = -ESTALE;
2944 goto bad_inode;
2945 }
2946
2947
2948
2949
2950 }
2951 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2952 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2953#ifdef EXT3_FRAGMENTS
2954 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2955 ei->i_frag_no = raw_inode->i_frag;
2956 ei->i_frag_size = raw_inode->i_fsize;
2957#endif
2958 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2959 if (!S_ISREG(inode->i_mode)) {
2960 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2961 } else {
2962 inode->i_size |=
2963 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2964 }
2965 ei->i_disksize = inode->i_size;
2966 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2967 ei->i_block_group = iloc.block_group;
2968
2969
2970
2971
2972 for (block = 0; block < EXT3_N_BLOCKS; block++)
2973 ei->i_data[block] = raw_inode->i_block[block];
2974 INIT_LIST_HEAD(&ei->i_orphan);
2975
2976
2977
2978
2979
2980
2981
2982
2983 if (journal) {
2984 tid_t tid;
2985
2986 spin_lock(&journal->j_state_lock);
2987 if (journal->j_running_transaction)
2988 transaction = journal->j_running_transaction;
2989 else
2990 transaction = journal->j_committing_transaction;
2991 if (transaction)
2992 tid = transaction->t_tid;
2993 else
2994 tid = journal->j_commit_sequence;
2995 spin_unlock(&journal->j_state_lock);
2996 atomic_set(&ei->i_sync_tid, tid);
2997 atomic_set(&ei->i_datasync_tid, tid);
2998 }
2999
3000 if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
3001 EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
3002
3003
3004
3005
3006
3007 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3008 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3009 EXT3_INODE_SIZE(inode->i_sb)) {
3010 brelse (bh);
3011 ret = -EIO;
3012 goto bad_inode;
3013 }
3014 if (ei->i_extra_isize == 0) {
3015
3016 ei->i_extra_isize = sizeof(struct ext3_inode) -
3017 EXT3_GOOD_OLD_INODE_SIZE;
3018 } else {
3019 __le32 *magic = (void *)raw_inode +
3020 EXT3_GOOD_OLD_INODE_SIZE +
3021 ei->i_extra_isize;
3022 if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
3023 ext3_set_inode_state(inode, EXT3_STATE_XATTR);
3024 }
3025 } else
3026 ei->i_extra_isize = 0;
3027
3028 if (S_ISREG(inode->i_mode)) {
3029 inode->i_op = &ext3_file_inode_operations;
3030 inode->i_fop = &ext3_file_operations;
3031 ext3_set_aops(inode);
3032 } else if (S_ISDIR(inode->i_mode)) {
3033 inode->i_op = &ext3_dir_inode_operations;
3034 inode->i_fop = &ext3_dir_operations;
3035 } else if (S_ISLNK(inode->i_mode)) {
3036 if (ext3_inode_is_fast_symlink(inode)) {
3037 inode->i_op = &ext3_fast_symlink_inode_operations;
3038 nd_terminate_link(ei->i_data, inode->i_size,
3039 sizeof(ei->i_data) - 1);
3040 } else {
3041 inode->i_op = &ext3_symlink_inode_operations;
3042 ext3_set_aops(inode);
3043 }
3044 } else {
3045 inode->i_op = &ext3_special_inode_operations;
3046 if (raw_inode->i_block[0])
3047 init_special_inode(inode, inode->i_mode,
3048 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3049 else
3050 init_special_inode(inode, inode->i_mode,
3051 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3052 }
3053 brelse (iloc.bh);
3054 ext3_set_inode_flags(inode);
3055 unlock_new_inode(inode);
3056 return inode;
3057
3058bad_inode:
3059 iget_failed(inode);
3060 return ERR_PTR(ret);
3061}
3062
3063
3064
3065
3066
3067
3068
3069
3070static int ext3_do_update_inode(handle_t *handle,
3071 struct inode *inode,
3072 struct ext3_iloc *iloc)
3073{
3074 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
3075 struct ext3_inode_info *ei = EXT3_I(inode);
3076 struct buffer_head *bh = iloc->bh;
3077 int err = 0, rc, block;
3078 int need_datasync = 0;
3079 __le32 disksize;
3080 uid_t i_uid;
3081 gid_t i_gid;
3082
3083again:
3084
3085 lock_buffer(bh);
3086
3087
3088
3089 if (ext3_test_inode_state(inode, EXT3_STATE_NEW))
3090 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
3091
3092 ext3_get_inode_flags(ei);
3093 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
3094 i_uid = i_uid_read(inode);
3095 i_gid = i_gid_read(inode);
3096 if(!(test_opt(inode->i_sb, NO_UID32))) {
3097 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
3098 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
3099
3100
3101
3102
3103 if(!ei->i_dtime) {
3104 raw_inode->i_uid_high =
3105 cpu_to_le16(high_16_bits(i_uid));
3106 raw_inode->i_gid_high =
3107 cpu_to_le16(high_16_bits(i_gid));
3108 } else {
3109 raw_inode->i_uid_high = 0;
3110 raw_inode->i_gid_high = 0;
3111 }
3112 } else {
3113 raw_inode->i_uid_low =
3114 cpu_to_le16(fs_high2lowuid(i_uid));
3115 raw_inode->i_gid_low =
3116 cpu_to_le16(fs_high2lowgid(i_gid));
3117 raw_inode->i_uid_high = 0;
3118 raw_inode->i_gid_high = 0;
3119 }
3120 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
3121 disksize = cpu_to_le32(ei->i_disksize);
3122 if (disksize != raw_inode->i_size) {
3123 need_datasync = 1;
3124 raw_inode->i_size = disksize;
3125 }
3126 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
3127 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
3128 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
3129 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
3130 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
3131 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
3132#ifdef EXT3_FRAGMENTS
3133 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
3134 raw_inode->i_frag = ei->i_frag_no;
3135 raw_inode->i_fsize = ei->i_frag_size;
3136#endif
3137 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
3138 if (!S_ISREG(inode->i_mode)) {
3139 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
3140 } else {
3141 disksize = cpu_to_le32(ei->i_disksize >> 32);
3142 if (disksize != raw_inode->i_size_high) {
3143 raw_inode->i_size_high = disksize;
3144 need_datasync = 1;
3145 }
3146 if (ei->i_disksize > 0x7fffffffULL) {
3147 struct super_block *sb = inode->i_sb;
3148 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
3149 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
3150 EXT3_SB(sb)->s_es->s_rev_level ==
3151 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
3152
3153
3154
3155 unlock_buffer(bh);
3156 err = ext3_journal_get_write_access(handle,
3157 EXT3_SB(sb)->s_sbh);
3158 if (err)
3159 goto out_brelse;
3160
3161 ext3_update_dynamic_rev(sb);
3162 EXT3_SET_RO_COMPAT_FEATURE(sb,
3163 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
3164 handle->h_sync = 1;
3165 err = ext3_journal_dirty_metadata(handle,
3166 EXT3_SB(sb)->s_sbh);
3167
3168 goto again;
3169 }
3170 }
3171 }
3172 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
3173 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
3174 if (old_valid_dev(inode->i_rdev)) {
3175 raw_inode->i_block[0] =
3176 cpu_to_le32(old_encode_dev(inode->i_rdev));
3177 raw_inode->i_block[1] = 0;
3178 } else {
3179 raw_inode->i_block[0] = 0;
3180 raw_inode->i_block[1] =
3181 cpu_to_le32(new_encode_dev(inode->i_rdev));
3182 raw_inode->i_block[2] = 0;
3183 }
3184 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
3185 raw_inode->i_block[block] = ei->i_data[block];
3186
3187 if (ei->i_extra_isize)
3188 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
3189
3190 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
3191 unlock_buffer(bh);
3192 rc = ext3_journal_dirty_metadata(handle, bh);
3193 if (!err)
3194 err = rc;
3195 ext3_clear_inode_state(inode, EXT3_STATE_NEW);
3196
3197 atomic_set(&ei->i_sync_tid, handle->h_transaction->t_tid);
3198 if (need_datasync)
3199 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
3200out_brelse:
3201 brelse (bh);
3202 ext3_std_error(inode->i_sb, err);
3203 return err;
3204}
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241int ext3_write_inode(struct inode *inode, struct writeback_control *wbc)
3242{
3243 if (current->flags & PF_MEMALLOC)
3244 return 0;
3245
3246 if (ext3_journal_current_handle()) {
3247 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
3248 dump_stack();
3249 return -EIO;
3250 }
3251
3252 if (wbc->sync_mode != WB_SYNC_ALL)
3253 return 0;
3254
3255 return ext3_force_commit(inode->i_sb);
3256}
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3276{
3277 struct inode *inode = dentry->d_inode;
3278 int error, rc = 0;
3279 const unsigned int ia_valid = attr->ia_valid;
3280
3281 error = inode_change_ok(inode, attr);
3282 if (error)
3283 return error;
3284
3285 if (is_quota_modification(inode, attr))
3286 dquot_initialize(inode);
3287 if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
3288 (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
3289 handle_t *handle;
3290
3291
3292
3293 handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
3294 EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
3295 if (IS_ERR(handle)) {
3296 error = PTR_ERR(handle);
3297 goto err_out;
3298 }
3299 error = dquot_transfer(inode, attr);
3300 if (error) {
3301 ext3_journal_stop(handle);
3302 return error;
3303 }
3304
3305
3306 if (attr->ia_valid & ATTR_UID)
3307 inode->i_uid = attr->ia_uid;
3308 if (attr->ia_valid & ATTR_GID)
3309 inode->i_gid = attr->ia_gid;
3310 error = ext3_mark_inode_dirty(handle, inode);
3311 ext3_journal_stop(handle);
3312 }
3313
3314 if (attr->ia_valid & ATTR_SIZE)
3315 inode_dio_wait(inode);
3316
3317 if (S_ISREG(inode->i_mode) &&
3318 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
3319 handle_t *handle;
3320
3321 handle = ext3_journal_start(inode, 3);
3322 if (IS_ERR(handle)) {
3323 error = PTR_ERR(handle);
3324 goto err_out;
3325 }
3326
3327 error = ext3_orphan_add(handle, inode);
3328 if (error) {
3329 ext3_journal_stop(handle);
3330 goto err_out;
3331 }
3332 EXT3_I(inode)->i_disksize = attr->ia_size;
3333 error = ext3_mark_inode_dirty(handle, inode);
3334 ext3_journal_stop(handle);
3335 if (error) {
3336
3337 ext3_orphan_del(NULL, inode);
3338 goto err_out;
3339 }
3340 rc = ext3_block_truncate_page(inode, attr->ia_size);
3341 if (rc) {
3342
3343 handle = ext3_journal_start(inode, 3);
3344 if (IS_ERR(handle)) {
3345 ext3_orphan_del(NULL, inode);
3346 goto err_out;
3347 }
3348 ext3_orphan_del(handle, inode);
3349 ext3_journal_stop(handle);
3350 goto err_out;
3351 }
3352 }
3353
3354 if ((attr->ia_valid & ATTR_SIZE) &&
3355 attr->ia_size != i_size_read(inode)) {
3356 truncate_setsize(inode, attr->ia_size);
3357 ext3_truncate(inode);
3358 }
3359
3360 setattr_copy(inode, attr);
3361 mark_inode_dirty(inode);
3362
3363 if (ia_valid & ATTR_MODE)
3364 rc = ext3_acl_chmod(inode);
3365
3366err_out:
3367 ext3_std_error(inode->i_sb, error);
3368 if (!error)
3369 error = rc;
3370 return error;
3371}
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401static int ext3_writepage_trans_blocks(struct inode *inode)
3402{
3403 int bpp = ext3_journal_blocks_per_page(inode);
3404 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
3405 int ret;
3406
3407 if (ext3_should_journal_data(inode))
3408 ret = 3 * (bpp + indirects) + 2;
3409 else
3410 ret = 2 * (bpp + indirects) + indirects + 2;
3411
3412#ifdef CONFIG_QUOTA
3413
3414
3415 ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
3416#endif
3417
3418 return ret;
3419}
3420
3421
3422
3423
3424
3425int ext3_mark_iloc_dirty(handle_t *handle,
3426 struct inode *inode, struct ext3_iloc *iloc)
3427{
3428 int err = 0;
3429
3430
3431 get_bh(iloc->bh);
3432
3433
3434 err = ext3_do_update_inode(handle, inode, iloc);
3435 put_bh(iloc->bh);
3436 return err;
3437}
3438
3439
3440
3441
3442
3443
3444int
3445ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
3446 struct ext3_iloc *iloc)
3447{
3448 int err = 0;
3449 if (handle) {
3450 err = ext3_get_inode_loc(inode, iloc);
3451 if (!err) {
3452 BUFFER_TRACE(iloc->bh, "get_write_access");
3453 err = ext3_journal_get_write_access(handle, iloc->bh);
3454 if (err) {
3455 brelse(iloc->bh);
3456 iloc->bh = NULL;
3457 }
3458 }
3459 }
3460 ext3_std_error(inode->i_sb, err);
3461 return err;
3462}
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3478{
3479 struct ext3_iloc iloc;
3480 int err;
3481
3482 might_sleep();
3483 trace_ext3_mark_inode_dirty(inode, _RET_IP_);
3484 err = ext3_reserve_inode_write(handle, inode, &iloc);
3485 if (!err)
3486 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3487 return err;
3488}
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504void ext3_dirty_inode(struct inode *inode, int flags)
3505{
3506 handle_t *current_handle = ext3_journal_current_handle();
3507 handle_t *handle;
3508
3509 handle = ext3_journal_start(inode, 2);
3510 if (IS_ERR(handle))
3511 goto out;
3512 if (current_handle &&
3513 current_handle->h_transaction != handle->h_transaction) {
3514
3515 printk(KERN_EMERG "%s: transactions do not match!\n",
3516 __func__);
3517 } else {
3518 jbd_debug(5, "marking dirty. outer handle=%p\n",
3519 current_handle);
3520 ext3_mark_inode_dirty(handle, inode);
3521 }
3522 ext3_journal_stop(handle);
3523out:
3524 return;
3525}
3526
3527#if 0
3528
3529
3530
3531
3532
3533
3534
3535static int ext3_pin_inode(handle_t *handle, struct inode *inode)
3536{
3537 struct ext3_iloc iloc;
3538
3539 int err = 0;
3540 if (handle) {
3541 err = ext3_get_inode_loc(inode, &iloc);
3542 if (!err) {
3543 BUFFER_TRACE(iloc.bh, "get_write_access");
3544 err = journal_get_write_access(handle, iloc.bh);
3545 if (!err)
3546 err = ext3_journal_dirty_metadata(handle,
3547 iloc.bh);
3548 brelse(iloc.bh);
3549 }
3550 }
3551 ext3_std_error(inode->i_sb, err);
3552 return err;
3553}
3554#endif
3555
3556int ext3_change_inode_journal_flag(struct inode *inode, int val)
3557{
3558 journal_t *journal;
3559 handle_t *handle;
3560 int err;
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572 journal = EXT3_JOURNAL(inode);
3573 if (is_journal_aborted(journal))
3574 return -EROFS;
3575
3576 journal_lock_updates(journal);
3577 journal_flush(journal);
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587 if (val)
3588 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3589 else
3590 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3591 ext3_set_aops(inode);
3592
3593 journal_unlock_updates(journal);
3594
3595
3596
3597 handle = ext3_journal_start(inode, 1);
3598 if (IS_ERR(handle))
3599 return PTR_ERR(handle);
3600
3601 err = ext3_mark_inode_dirty(handle, inode);
3602 handle->h_sync = 1;
3603 ext3_journal_stop(handle);
3604 ext3_std_error(inode->i_sb, err);
3605
3606 return err;
3607}
3608