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 branch[n].bh = bh;
680 lock_buffer(bh);
681 BUFFER_TRACE(bh, "call get_create_access");
682 err = ext3_journal_get_create_access(handle, bh);
683 if (err) {
684 unlock_buffer(bh);
685 brelse(bh);
686 goto failed;
687 }
688
689 memset(bh->b_data, 0, blocksize);
690 branch[n].p = (__le32 *) bh->b_data + offsets[n];
691 branch[n].key = cpu_to_le32(new_blocks[n]);
692 *branch[n].p = branch[n].key;
693 if ( n == indirect_blks) {
694 current_block = new_blocks[n];
695
696
697
698
699
700 for (i=1; i < num; i++)
701 *(branch[n].p + i) = cpu_to_le32(++current_block);
702 }
703 BUFFER_TRACE(bh, "marking uptodate");
704 set_buffer_uptodate(bh);
705 unlock_buffer(bh);
706
707 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
708 err = ext3_journal_dirty_metadata(handle, bh);
709 if (err)
710 goto failed;
711 }
712 *blks = num;
713 return err;
714failed:
715
716 for (i = 1; i <= n ; i++) {
717 BUFFER_TRACE(branch[i].bh, "call journal_forget");
718 ext3_journal_forget(handle, branch[i].bh);
719 }
720 for (i = 0; i <indirect_blks; i++)
721 ext3_free_blocks(handle, inode, new_blocks[i], 1);
722
723 ext3_free_blocks(handle, inode, new_blocks[i], num);
724
725 return err;
726}
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741static int ext3_splice_branch(handle_t *handle, struct inode *inode,
742 long block, Indirect *where, int num, int blks)
743{
744 int i;
745 int err = 0;
746 struct ext3_block_alloc_info *block_i;
747 ext3_fsblk_t current_block;
748 struct ext3_inode_info *ei = EXT3_I(inode);
749 struct timespec now;
750
751 block_i = ei->i_block_alloc_info;
752
753
754
755
756
757 if (where->bh) {
758 BUFFER_TRACE(where->bh, "get_write_access");
759 err = ext3_journal_get_write_access(handle, where->bh);
760 if (err)
761 goto err_out;
762 }
763
764
765 *where->p = where->key;
766
767
768
769
770
771 if (num == 0 && blks > 1) {
772 current_block = le32_to_cpu(where->key) + 1;
773 for (i = 1; i < blks; i++)
774 *(where->p + i ) = cpu_to_le32(current_block++);
775 }
776
777
778
779
780
781
782 if (block_i) {
783 block_i->last_alloc_logical_block = block + blks - 1;
784 block_i->last_alloc_physical_block =
785 le32_to_cpu(where[num].key) + blks - 1;
786 }
787
788
789 now = CURRENT_TIME_SEC;
790 if (!timespec_equal(&inode->i_ctime, &now) || !where->bh) {
791 inode->i_ctime = now;
792 ext3_mark_inode_dirty(handle, inode);
793 }
794
795 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
796
797
798 if (where->bh) {
799
800
801
802
803
804
805
806
807 jbd_debug(5, "splicing indirect only\n");
808 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
809 err = ext3_journal_dirty_metadata(handle, where->bh);
810 if (err)
811 goto err_out;
812 } else {
813
814
815
816
817 jbd_debug(5, "splicing direct\n");
818 }
819 return err;
820
821err_out:
822 for (i = 1; i <= num; i++) {
823 BUFFER_TRACE(where[i].bh, "call journal_forget");
824 ext3_journal_forget(handle, where[i].bh);
825 ext3_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
826 }
827 ext3_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
828
829 return err;
830}
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
852 sector_t iblock, unsigned long maxblocks,
853 struct buffer_head *bh_result,
854 int create)
855{
856 int err = -EIO;
857 int offsets[4];
858 Indirect chain[4];
859 Indirect *partial;
860 ext3_fsblk_t goal;
861 int indirect_blks;
862 int blocks_to_boundary = 0;
863 int depth;
864 struct ext3_inode_info *ei = EXT3_I(inode);
865 int count = 0;
866 ext3_fsblk_t first_block = 0;
867
868
869 trace_ext3_get_blocks_enter(inode, iblock, maxblocks, create);
870 J_ASSERT(handle != NULL || create == 0);
871 depth = ext3_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
872
873 if (depth == 0)
874 goto out;
875
876 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
877
878
879 if (!partial) {
880 first_block = le32_to_cpu(chain[depth - 1].key);
881 clear_buffer_new(bh_result);
882 count++;
883
884 while (count < maxblocks && count <= blocks_to_boundary) {
885 ext3_fsblk_t blk;
886
887 if (!verify_chain(chain, chain + depth - 1)) {
888
889
890
891
892
893
894
895 err = -EAGAIN;
896 count = 0;
897 break;
898 }
899 blk = le32_to_cpu(*(chain[depth-1].p + count));
900
901 if (blk == first_block + count)
902 count++;
903 else
904 break;
905 }
906 if (err != -EAGAIN)
907 goto got_it;
908 }
909
910
911 if (!create || err == -EIO)
912 goto cleanup;
913
914
915
916
917 mutex_lock(&ei->truncate_mutex);
918
919
920
921
922
923
924
925
926
927
928
929
930
931 if (err == -EAGAIN || !verify_chain(chain, partial)) {
932 while (partial > chain) {
933 brelse(partial->bh);
934 partial--;
935 }
936 partial = ext3_get_branch(inode, depth, offsets, chain, &err);
937 if (!partial) {
938 count++;
939 mutex_unlock(&ei->truncate_mutex);
940 if (err)
941 goto cleanup;
942 clear_buffer_new(bh_result);
943 goto got_it;
944 }
945 }
946
947
948
949
950
951 if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
952 ext3_init_block_alloc_info(inode);
953
954 goal = ext3_find_goal(inode, iblock, partial);
955
956
957 indirect_blks = (chain + depth) - partial - 1;
958
959
960
961
962
963 count = ext3_blks_to_allocate(partial, indirect_blks,
964 maxblocks, blocks_to_boundary);
965 err = ext3_alloc_branch(handle, inode, indirect_blks, &count, goal,
966 offsets + (partial - chain), partial);
967
968
969
970
971
972
973
974
975 if (!err)
976 err = ext3_splice_branch(handle, inode, iblock,
977 partial, indirect_blks, count);
978 mutex_unlock(&ei->truncate_mutex);
979 if (err)
980 goto cleanup;
981
982 set_buffer_new(bh_result);
983got_it:
984 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
985 if (count > blocks_to_boundary)
986 set_buffer_boundary(bh_result);
987 err = count;
988
989 partial = chain + depth - 1;
990cleanup:
991 while (partial > chain) {
992 BUFFER_TRACE(partial->bh, "call brelse");
993 brelse(partial->bh);
994 partial--;
995 }
996 BUFFER_TRACE(bh_result, "returned");
997out:
998 trace_ext3_get_blocks_exit(inode, iblock,
999 depth ? le32_to_cpu(chain[depth-1].key) : 0,
1000 count, err);
1001 return err;
1002}
1003
1004
1005#define DIO_MAX_BLOCKS 4096
1006
1007
1008
1009
1010
1011
1012
1013#define DIO_CREDITS 25
1014
1015static int ext3_get_block(struct inode *inode, sector_t iblock,
1016 struct buffer_head *bh_result, int create)
1017{
1018 handle_t *handle = ext3_journal_current_handle();
1019 int ret = 0, started = 0;
1020 unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
1021
1022 if (create && !handle) {
1023 if (max_blocks > DIO_MAX_BLOCKS)
1024 max_blocks = DIO_MAX_BLOCKS;
1025 handle = ext3_journal_start(inode, DIO_CREDITS +
1026 EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
1027 if (IS_ERR(handle)) {
1028 ret = PTR_ERR(handle);
1029 goto out;
1030 }
1031 started = 1;
1032 }
1033
1034 ret = ext3_get_blocks_handle(handle, inode, iblock,
1035 max_blocks, bh_result, create);
1036 if (ret > 0) {
1037 bh_result->b_size = (ret << inode->i_blkbits);
1038 ret = 0;
1039 }
1040 if (started)
1041 ext3_journal_stop(handle);
1042out:
1043 return ret;
1044}
1045
1046int ext3_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1047 u64 start, u64 len)
1048{
1049 return generic_block_fiemap(inode, fieinfo, start, len,
1050 ext3_get_block);
1051}
1052
1053
1054
1055
1056struct buffer_head *ext3_getblk(handle_t *handle, struct inode *inode,
1057 long block, int create, int *errp)
1058{
1059 struct buffer_head dummy;
1060 int fatal = 0, err;
1061
1062 J_ASSERT(handle != NULL || create == 0);
1063
1064 dummy.b_state = 0;
1065 dummy.b_blocknr = -1000;
1066 buffer_trace_init(&dummy.b_history);
1067 err = ext3_get_blocks_handle(handle, inode, block, 1,
1068 &dummy, create);
1069
1070
1071
1072
1073 if (err > 0) {
1074 WARN_ON(err > 1);
1075 err = 0;
1076 }
1077 *errp = err;
1078 if (!err && buffer_mapped(&dummy)) {
1079 struct buffer_head *bh;
1080 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1081 if (!bh) {
1082 *errp = -EIO;
1083 goto err;
1084 }
1085 if (buffer_new(&dummy)) {
1086 J_ASSERT(create != 0);
1087 J_ASSERT(handle != NULL);
1088
1089
1090
1091
1092
1093
1094
1095
1096 lock_buffer(bh);
1097 BUFFER_TRACE(bh, "call get_create_access");
1098 fatal = ext3_journal_get_create_access(handle, bh);
1099 if (!fatal && !buffer_uptodate(bh)) {
1100 memset(bh->b_data,0,inode->i_sb->s_blocksize);
1101 set_buffer_uptodate(bh);
1102 }
1103 unlock_buffer(bh);
1104 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1105 err = ext3_journal_dirty_metadata(handle, bh);
1106 if (!fatal)
1107 fatal = err;
1108 } else {
1109 BUFFER_TRACE(bh, "not a new buffer");
1110 }
1111 if (fatal) {
1112 *errp = fatal;
1113 brelse(bh);
1114 bh = NULL;
1115 }
1116 return bh;
1117 }
1118err:
1119 return NULL;
1120}
1121
1122struct buffer_head *ext3_bread(handle_t *handle, struct inode *inode,
1123 int block, int create, int *err)
1124{
1125 struct buffer_head * bh;
1126
1127 bh = ext3_getblk(handle, inode, block, create, err);
1128 if (!bh)
1129 return bh;
1130 if (bh_uptodate_or_lock(bh))
1131 return bh;
1132 get_bh(bh);
1133 bh->b_end_io = end_buffer_read_sync;
1134 submit_bh(READ | REQ_META | REQ_PRIO, bh);
1135 wait_on_buffer(bh);
1136 if (buffer_uptodate(bh))
1137 return bh;
1138 put_bh(bh);
1139 *err = -EIO;
1140 return NULL;
1141}
1142
1143static int walk_page_buffers( handle_t *handle,
1144 struct buffer_head *head,
1145 unsigned from,
1146 unsigned to,
1147 int *partial,
1148 int (*fn)( handle_t *handle,
1149 struct buffer_head *bh))
1150{
1151 struct buffer_head *bh;
1152 unsigned block_start, block_end;
1153 unsigned blocksize = head->b_size;
1154 int err, ret = 0;
1155 struct buffer_head *next;
1156
1157 for ( bh = head, block_start = 0;
1158 ret == 0 && (bh != head || !block_start);
1159 block_start = block_end, bh = next)
1160 {
1161 next = bh->b_this_page;
1162 block_end = block_start + blocksize;
1163 if (block_end <= from || block_start >= to) {
1164 if (partial && !buffer_uptodate(bh))
1165 *partial = 1;
1166 continue;
1167 }
1168 err = (*fn)(handle, bh);
1169 if (!ret)
1170 ret = err;
1171 }
1172 return ret;
1173}
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200static int do_journal_get_write_access(handle_t *handle,
1201 struct buffer_head *bh)
1202{
1203 int dirty = buffer_dirty(bh);
1204 int ret;
1205
1206 if (!buffer_mapped(bh) || buffer_freed(bh))
1207 return 0;
1208
1209
1210
1211
1212
1213
1214
1215
1216 if (dirty)
1217 clear_buffer_dirty(bh);
1218 ret = ext3_journal_get_write_access(handle, bh);
1219 if (!ret && dirty)
1220 ret = ext3_journal_dirty_metadata(handle, bh);
1221 return ret;
1222}
1223
1224
1225
1226
1227
1228static void ext3_truncate_failed_write(struct inode *inode)
1229{
1230 truncate_inode_pages(inode->i_mapping, inode->i_size);
1231 ext3_truncate(inode);
1232}
1233
1234
1235
1236
1237
1238static void ext3_truncate_failed_direct_write(struct inode *inode)
1239{
1240 ext3_block_truncate_page(inode, inode->i_size);
1241 ext3_truncate(inode);
1242}
1243
1244static int ext3_write_begin(struct file *file, struct address_space *mapping,
1245 loff_t pos, unsigned len, unsigned flags,
1246 struct page **pagep, void **fsdata)
1247{
1248 struct inode *inode = mapping->host;
1249 int ret;
1250 handle_t *handle;
1251 int retries = 0;
1252 struct page *page;
1253 pgoff_t index;
1254 unsigned from, to;
1255
1256
1257 int needed_blocks = ext3_writepage_trans_blocks(inode) + 1;
1258
1259 trace_ext3_write_begin(inode, pos, len, flags);
1260
1261 index = pos >> PAGE_CACHE_SHIFT;
1262 from = pos & (PAGE_CACHE_SIZE - 1);
1263 to = from + len;
1264
1265retry:
1266 page = grab_cache_page_write_begin(mapping, index, flags);
1267 if (!page)
1268 return -ENOMEM;
1269 *pagep = page;
1270
1271 handle = ext3_journal_start(inode, needed_blocks);
1272 if (IS_ERR(handle)) {
1273 unlock_page(page);
1274 page_cache_release(page);
1275 ret = PTR_ERR(handle);
1276 goto out;
1277 }
1278 ret = __block_write_begin(page, pos, len, ext3_get_block);
1279 if (ret)
1280 goto write_begin_failed;
1281
1282 if (ext3_should_journal_data(inode)) {
1283 ret = walk_page_buffers(handle, page_buffers(page),
1284 from, to, NULL, do_journal_get_write_access);
1285 }
1286write_begin_failed:
1287 if (ret) {
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1298 ext3_orphan_add(handle, inode);
1299 ext3_journal_stop(handle);
1300 unlock_page(page);
1301 page_cache_release(page);
1302 if (pos + len > inode->i_size)
1303 ext3_truncate_failed_write(inode);
1304 }
1305 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1306 goto retry;
1307out:
1308 return ret;
1309}
1310
1311
1312int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1313{
1314 int err = journal_dirty_data(handle, bh);
1315 if (err)
1316 ext3_journal_abort_handle(__func__, __func__,
1317 bh, handle, err);
1318 return err;
1319}
1320
1321
1322static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1323{
1324
1325
1326
1327
1328 if (buffer_mapped(bh) && buffer_uptodate(bh))
1329 return ext3_journal_dirty_data(handle, bh);
1330 return 0;
1331}
1332
1333
1334static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1335{
1336 if (!buffer_mapped(bh) || buffer_freed(bh))
1337 return 0;
1338 set_buffer_uptodate(bh);
1339 return ext3_journal_dirty_metadata(handle, bh);
1340}
1341
1342
1343
1344
1345
1346
1347
1348static void update_file_sizes(struct inode *inode, loff_t pos, unsigned copied)
1349{
1350
1351 if (pos + copied > inode->i_size)
1352 i_size_write(inode, pos + copied);
1353 if (pos + copied > EXT3_I(inode)->i_disksize) {
1354 EXT3_I(inode)->i_disksize = pos + copied;
1355 mark_inode_dirty(inode);
1356 }
1357}
1358
1359
1360
1361
1362
1363
1364
1365
1366static int ext3_ordered_write_end(struct file *file,
1367 struct address_space *mapping,
1368 loff_t pos, unsigned len, unsigned copied,
1369 struct page *page, void *fsdata)
1370{
1371 handle_t *handle = ext3_journal_current_handle();
1372 struct inode *inode = file->f_mapping->host;
1373 unsigned from, to;
1374 int ret = 0, ret2;
1375
1376 trace_ext3_ordered_write_end(inode, pos, len, copied);
1377 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1378
1379 from = pos & (PAGE_CACHE_SIZE - 1);
1380 to = from + copied;
1381 ret = walk_page_buffers(handle, page_buffers(page),
1382 from, to, NULL, journal_dirty_data_fn);
1383
1384 if (ret == 0)
1385 update_file_sizes(inode, pos, copied);
1386
1387
1388
1389
1390 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1391 ext3_orphan_add(handle, inode);
1392 ret2 = ext3_journal_stop(handle);
1393 if (!ret)
1394 ret = ret2;
1395 unlock_page(page);
1396 page_cache_release(page);
1397
1398 if (pos + len > inode->i_size)
1399 ext3_truncate_failed_write(inode);
1400 return ret ? ret : copied;
1401}
1402
1403static int ext3_writeback_write_end(struct file *file,
1404 struct address_space *mapping,
1405 loff_t pos, unsigned len, unsigned copied,
1406 struct page *page, void *fsdata)
1407{
1408 handle_t *handle = ext3_journal_current_handle();
1409 struct inode *inode = file->f_mapping->host;
1410 int ret;
1411
1412 trace_ext3_writeback_write_end(inode, pos, len, copied);
1413 copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
1414 update_file_sizes(inode, pos, copied);
1415
1416
1417
1418
1419 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1420 ext3_orphan_add(handle, inode);
1421 ret = ext3_journal_stop(handle);
1422 unlock_page(page);
1423 page_cache_release(page);
1424
1425 if (pos + len > inode->i_size)
1426 ext3_truncate_failed_write(inode);
1427 return ret ? ret : copied;
1428}
1429
1430static int ext3_journalled_write_end(struct file *file,
1431 struct address_space *mapping,
1432 loff_t pos, unsigned len, unsigned copied,
1433 struct page *page, void *fsdata)
1434{
1435 handle_t *handle = ext3_journal_current_handle();
1436 struct inode *inode = mapping->host;
1437 struct ext3_inode_info *ei = EXT3_I(inode);
1438 int ret = 0, ret2;
1439 int partial = 0;
1440 unsigned from, to;
1441
1442 trace_ext3_journalled_write_end(inode, pos, len, copied);
1443 from = pos & (PAGE_CACHE_SIZE - 1);
1444 to = from + len;
1445
1446 if (copied < len) {
1447 if (!PageUptodate(page))
1448 copied = 0;
1449 page_zero_new_buffers(page, from + copied, to);
1450 to = from + copied;
1451 }
1452
1453 ret = walk_page_buffers(handle, page_buffers(page), from,
1454 to, &partial, write_end_fn);
1455 if (!partial)
1456 SetPageUptodate(page);
1457
1458 if (pos + copied > inode->i_size)
1459 i_size_write(inode, pos + copied);
1460
1461
1462
1463
1464 if (pos + len > inode->i_size && ext3_can_truncate(inode))
1465 ext3_orphan_add(handle, inode);
1466 ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1467 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
1468 if (inode->i_size > ei->i_disksize) {
1469 ei->i_disksize = inode->i_size;
1470 ret2 = ext3_mark_inode_dirty(handle, inode);
1471 if (!ret)
1472 ret = ret2;
1473 }
1474
1475 ret2 = ext3_journal_stop(handle);
1476 if (!ret)
1477 ret = ret2;
1478 unlock_page(page);
1479 page_cache_release(page);
1480
1481 if (pos + len > inode->i_size)
1482 ext3_truncate_failed_write(inode);
1483 return ret ? ret : copied;
1484}
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500static sector_t ext3_bmap(struct address_space *mapping, sector_t block)
1501{
1502 struct inode *inode = mapping->host;
1503 journal_t *journal;
1504 int err;
1505
1506 if (ext3_test_inode_state(inode, EXT3_STATE_JDATA)) {
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525 ext3_clear_inode_state(inode, EXT3_STATE_JDATA);
1526 journal = EXT3_JOURNAL(inode);
1527 journal_lock_updates(journal);
1528 err = journal_flush(journal);
1529 journal_unlock_updates(journal);
1530
1531 if (err)
1532 return 0;
1533 }
1534
1535 return generic_block_bmap(mapping,block,ext3_get_block);
1536}
1537
1538static int bget_one(handle_t *handle, struct buffer_head *bh)
1539{
1540 get_bh(bh);
1541 return 0;
1542}
1543
1544static int bput_one(handle_t *handle, struct buffer_head *bh)
1545{
1546 put_bh(bh);
1547 return 0;
1548}
1549
1550static int buffer_unmapped(handle_t *handle, struct buffer_head *bh)
1551{
1552 return !buffer_mapped(bh);
1553}
1554
1555
1556
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
1607static int ext3_ordered_writepage(struct page *page,
1608 struct writeback_control *wbc)
1609{
1610 struct inode *inode = page->mapping->host;
1611 struct buffer_head *page_bufs;
1612 handle_t *handle = NULL;
1613 int ret = 0;
1614 int err;
1615
1616 J_ASSERT(PageLocked(page));
1617
1618
1619
1620
1621
1622 WARN_ON_ONCE(IS_RDONLY(inode) &&
1623 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
1624
1625
1626
1627
1628
1629 if (ext3_journal_current_handle())
1630 goto out_fail;
1631
1632 trace_ext3_ordered_writepage(page);
1633 if (!page_has_buffers(page)) {
1634 create_empty_buffers(page, inode->i_sb->s_blocksize,
1635 (1 << BH_Dirty)|(1 << BH_Uptodate));
1636 page_bufs = page_buffers(page);
1637 } else {
1638 page_bufs = page_buffers(page);
1639 if (!walk_page_buffers(NULL, page_bufs, 0, PAGE_CACHE_SIZE,
1640 NULL, buffer_unmapped)) {
1641
1642
1643 return block_write_full_page(page, NULL, wbc);
1644 }
1645 }
1646 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1647
1648 if (IS_ERR(handle)) {
1649 ret = PTR_ERR(handle);
1650 goto out_fail;
1651 }
1652
1653 walk_page_buffers(handle, page_bufs, 0,
1654 PAGE_CACHE_SIZE, NULL, bget_one);
1655
1656 ret = block_write_full_page(page, ext3_get_block, wbc);
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670 if (ret == 0) {
1671 err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
1672 NULL, journal_dirty_data_fn);
1673 if (!ret)
1674 ret = err;
1675 }
1676 walk_page_buffers(handle, page_bufs, 0,
1677 PAGE_CACHE_SIZE, NULL, bput_one);
1678 err = ext3_journal_stop(handle);
1679 if (!ret)
1680 ret = err;
1681 return ret;
1682
1683out_fail:
1684 redirty_page_for_writepage(wbc, page);
1685 unlock_page(page);
1686 return ret;
1687}
1688
1689static int ext3_writeback_writepage(struct page *page,
1690 struct writeback_control *wbc)
1691{
1692 struct inode *inode = page->mapping->host;
1693 handle_t *handle = NULL;
1694 int ret = 0;
1695 int err;
1696
1697 J_ASSERT(PageLocked(page));
1698
1699
1700
1701
1702
1703 WARN_ON_ONCE(IS_RDONLY(inode) &&
1704 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
1705
1706 if (ext3_journal_current_handle())
1707 goto out_fail;
1708
1709 trace_ext3_writeback_writepage(page);
1710 if (page_has_buffers(page)) {
1711 if (!walk_page_buffers(NULL, page_buffers(page), 0,
1712 PAGE_CACHE_SIZE, NULL, buffer_unmapped)) {
1713
1714
1715 return block_write_full_page(page, NULL, wbc);
1716 }
1717 }
1718
1719 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1720 if (IS_ERR(handle)) {
1721 ret = PTR_ERR(handle);
1722 goto out_fail;
1723 }
1724
1725 ret = block_write_full_page(page, ext3_get_block, wbc);
1726
1727 err = ext3_journal_stop(handle);
1728 if (!ret)
1729 ret = err;
1730 return ret;
1731
1732out_fail:
1733 redirty_page_for_writepage(wbc, page);
1734 unlock_page(page);
1735 return ret;
1736}
1737
1738static int ext3_journalled_writepage(struct page *page,
1739 struct writeback_control *wbc)
1740{
1741 struct inode *inode = page->mapping->host;
1742 handle_t *handle = NULL;
1743 int ret = 0;
1744 int err;
1745
1746 J_ASSERT(PageLocked(page));
1747
1748
1749
1750
1751
1752 WARN_ON_ONCE(IS_RDONLY(inode) &&
1753 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS));
1754
1755 if (ext3_journal_current_handle())
1756 goto no_write;
1757
1758 trace_ext3_journalled_writepage(page);
1759 handle = ext3_journal_start(inode, ext3_writepage_trans_blocks(inode));
1760 if (IS_ERR(handle)) {
1761 ret = PTR_ERR(handle);
1762 goto no_write;
1763 }
1764
1765 if (!page_has_buffers(page) || PageChecked(page)) {
1766
1767
1768
1769
1770 ClearPageChecked(page);
1771 ret = __block_write_begin(page, 0, PAGE_CACHE_SIZE,
1772 ext3_get_block);
1773 if (ret != 0) {
1774 ext3_journal_stop(handle);
1775 goto out_unlock;
1776 }
1777 ret = walk_page_buffers(handle, page_buffers(page), 0,
1778 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
1779
1780 err = walk_page_buffers(handle, page_buffers(page), 0,
1781 PAGE_CACHE_SIZE, NULL, write_end_fn);
1782 if (ret == 0)
1783 ret = err;
1784 ext3_set_inode_state(inode, EXT3_STATE_JDATA);
1785 atomic_set(&EXT3_I(inode)->i_datasync_tid,
1786 handle->h_transaction->t_tid);
1787 unlock_page(page);
1788 } else {
1789
1790
1791
1792
1793
1794 ret = block_write_full_page(page, ext3_get_block, wbc);
1795 }
1796 err = ext3_journal_stop(handle);
1797 if (!ret)
1798 ret = err;
1799out:
1800 return ret;
1801
1802no_write:
1803 redirty_page_for_writepage(wbc, page);
1804out_unlock:
1805 unlock_page(page);
1806 goto out;
1807}
1808
1809static int ext3_readpage(struct file *file, struct page *page)
1810{
1811 trace_ext3_readpage(page);
1812 return mpage_readpage(page, ext3_get_block);
1813}
1814
1815static int
1816ext3_readpages(struct file *file, struct address_space *mapping,
1817 struct list_head *pages, unsigned nr_pages)
1818{
1819 return mpage_readpages(mapping, pages, nr_pages, ext3_get_block);
1820}
1821
1822static void ext3_invalidatepage(struct page *page, unsigned long offset)
1823{
1824 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1825
1826 trace_ext3_invalidatepage(page, offset);
1827
1828
1829
1830
1831 if (offset == 0)
1832 ClearPageChecked(page);
1833
1834 journal_invalidatepage(journal, page, offset);
1835}
1836
1837static int ext3_releasepage(struct page *page, gfp_t wait)
1838{
1839 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1840
1841 trace_ext3_releasepage(page);
1842 WARN_ON(PageChecked(page));
1843 if (!page_has_buffers(page))
1844 return 0;
1845 return journal_try_to_free_buffers(journal, page, wait);
1846}
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1858 const struct iovec *iov, loff_t offset,
1859 unsigned long nr_segs)
1860{
1861 struct file *file = iocb->ki_filp;
1862 struct inode *inode = file->f_mapping->host;
1863 struct ext3_inode_info *ei = EXT3_I(inode);
1864 handle_t *handle;
1865 ssize_t ret;
1866 int orphan = 0;
1867 size_t count = iov_length(iov, nr_segs);
1868 int retries = 0;
1869
1870 trace_ext3_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
1871
1872 if (rw == WRITE) {
1873 loff_t final_size = offset + count;
1874
1875 if (final_size > inode->i_size) {
1876
1877 handle = ext3_journal_start(inode, 2);
1878 if (IS_ERR(handle)) {
1879 ret = PTR_ERR(handle);
1880 goto out;
1881 }
1882 ret = ext3_orphan_add(handle, inode);
1883 if (ret) {
1884 ext3_journal_stop(handle);
1885 goto out;
1886 }
1887 orphan = 1;
1888 ei->i_disksize = inode->i_size;
1889 ext3_journal_stop(handle);
1890 }
1891 }
1892
1893retry:
1894 ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
1895 ext3_get_block);
1896
1897
1898
1899
1900 if (unlikely((rw & WRITE) && ret < 0)) {
1901 loff_t isize = i_size_read(inode);
1902 loff_t end = offset + iov_length(iov, nr_segs);
1903
1904 if (end > isize)
1905 ext3_truncate_failed_direct_write(inode);
1906 }
1907 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1908 goto retry;
1909
1910 if (orphan) {
1911 int err;
1912
1913
1914 handle = ext3_journal_start(inode, 2);
1915 if (IS_ERR(handle)) {
1916
1917
1918
1919 ext3_truncate_failed_direct_write(inode);
1920 ret = PTR_ERR(handle);
1921 goto out;
1922 }
1923 if (inode->i_nlink)
1924 ext3_orphan_del(handle, inode);
1925 if (ret > 0) {
1926 loff_t end = offset + ret;
1927 if (end > inode->i_size) {
1928 ei->i_disksize = end;
1929 i_size_write(inode, end);
1930
1931
1932
1933
1934
1935
1936
1937 ext3_mark_inode_dirty(handle, inode);
1938 }
1939 }
1940 err = ext3_journal_stop(handle);
1941 if (ret == 0)
1942 ret = err;
1943 }
1944out:
1945 trace_ext3_direct_IO_exit(inode, offset,
1946 iov_length(iov, nr_segs), rw, ret);
1947 return ret;
1948}
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963static int ext3_journalled_set_page_dirty(struct page *page)
1964{
1965 SetPageChecked(page);
1966 return __set_page_dirty_nobuffers(page);
1967}
1968
1969static const struct address_space_operations ext3_ordered_aops = {
1970 .readpage = ext3_readpage,
1971 .readpages = ext3_readpages,
1972 .writepage = ext3_ordered_writepage,
1973 .write_begin = ext3_write_begin,
1974 .write_end = ext3_ordered_write_end,
1975 .bmap = ext3_bmap,
1976 .invalidatepage = ext3_invalidatepage,
1977 .releasepage = ext3_releasepage,
1978 .direct_IO = ext3_direct_IO,
1979 .migratepage = buffer_migrate_page,
1980 .is_partially_uptodate = block_is_partially_uptodate,
1981 .error_remove_page = generic_error_remove_page,
1982};
1983
1984static const struct address_space_operations ext3_writeback_aops = {
1985 .readpage = ext3_readpage,
1986 .readpages = ext3_readpages,
1987 .writepage = ext3_writeback_writepage,
1988 .write_begin = ext3_write_begin,
1989 .write_end = ext3_writeback_write_end,
1990 .bmap = ext3_bmap,
1991 .invalidatepage = ext3_invalidatepage,
1992 .releasepage = ext3_releasepage,
1993 .direct_IO = ext3_direct_IO,
1994 .migratepage = buffer_migrate_page,
1995 .is_partially_uptodate = block_is_partially_uptodate,
1996 .error_remove_page = generic_error_remove_page,
1997};
1998
1999static const struct address_space_operations ext3_journalled_aops = {
2000 .readpage = ext3_readpage,
2001 .readpages = ext3_readpages,
2002 .writepage = ext3_journalled_writepage,
2003 .write_begin = ext3_write_begin,
2004 .write_end = ext3_journalled_write_end,
2005 .set_page_dirty = ext3_journalled_set_page_dirty,
2006 .bmap = ext3_bmap,
2007 .invalidatepage = ext3_invalidatepage,
2008 .releasepage = ext3_releasepage,
2009 .is_partially_uptodate = block_is_partially_uptodate,
2010 .error_remove_page = generic_error_remove_page,
2011};
2012
2013void ext3_set_aops(struct inode *inode)
2014{
2015 if (ext3_should_order_data(inode))
2016 inode->i_mapping->a_ops = &ext3_ordered_aops;
2017 else if (ext3_should_writeback_data(inode))
2018 inode->i_mapping->a_ops = &ext3_writeback_aops;
2019 else
2020 inode->i_mapping->a_ops = &ext3_journalled_aops;
2021}
2022
2023
2024
2025
2026
2027
2028
2029static int ext3_block_truncate_page(struct inode *inode, loff_t from)
2030{
2031 ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
2032 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
2033 unsigned blocksize, iblock, length, pos;
2034 struct page *page;
2035 handle_t *handle = NULL;
2036 struct buffer_head *bh;
2037 int err = 0;
2038
2039
2040 blocksize = inode->i_sb->s_blocksize;
2041 if ((from & (blocksize - 1)) == 0)
2042 return 0;
2043
2044 page = grab_cache_page(inode->i_mapping, index);
2045 if (!page)
2046 return -ENOMEM;
2047 length = blocksize - (offset & (blocksize - 1));
2048 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
2049
2050 if (!page_has_buffers(page))
2051 create_empty_buffers(page, blocksize, 0);
2052
2053
2054 bh = page_buffers(page);
2055 pos = blocksize;
2056 while (offset >= pos) {
2057 bh = bh->b_this_page;
2058 iblock++;
2059 pos += blocksize;
2060 }
2061
2062 err = 0;
2063 if (buffer_freed(bh)) {
2064 BUFFER_TRACE(bh, "freed: skip");
2065 goto unlock;
2066 }
2067
2068 if (!buffer_mapped(bh)) {
2069 BUFFER_TRACE(bh, "unmapped");
2070 ext3_get_block(inode, iblock, bh, 0);
2071
2072 if (!buffer_mapped(bh)) {
2073 BUFFER_TRACE(bh, "still unmapped");
2074 goto unlock;
2075 }
2076 }
2077
2078
2079 if (PageUptodate(page))
2080 set_buffer_uptodate(bh);
2081
2082 if (!bh_uptodate_or_lock(bh)) {
2083 err = bh_submit_read(bh);
2084
2085 if (err)
2086 goto unlock;
2087 }
2088
2089
2090 if (!ext3_should_writeback_data(inode)) {
2091
2092 handle = ext3_journal_start(inode, 1);
2093 if (IS_ERR(handle)) {
2094 clear_highpage(page);
2095 flush_dcache_page(page);
2096 err = PTR_ERR(handle);
2097 goto unlock;
2098 }
2099 }
2100
2101 if (ext3_should_journal_data(inode)) {
2102 BUFFER_TRACE(bh, "get write access");
2103 err = ext3_journal_get_write_access(handle, bh);
2104 if (err)
2105 goto stop;
2106 }
2107
2108 zero_user(page, offset, length);
2109 BUFFER_TRACE(bh, "zeroed end of block");
2110
2111 err = 0;
2112 if (ext3_should_journal_data(inode)) {
2113 err = ext3_journal_dirty_metadata(handle, bh);
2114 } else {
2115 if (ext3_should_order_data(inode))
2116 err = ext3_journal_dirty_data(handle, bh);
2117 mark_buffer_dirty(bh);
2118 }
2119stop:
2120 if (handle)
2121 ext3_journal_stop(handle);
2122
2123unlock:
2124 unlock_page(page);
2125 page_cache_release(page);
2126 return err;
2127}
2128
2129
2130
2131
2132
2133
2134static inline int all_zeroes(__le32 *p, __le32 *q)
2135{
2136 while (p < q)
2137 if (*p++)
2138 return 0;
2139 return 1;
2140}
2141
2142
2143
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
2177static Indirect *ext3_find_shared(struct inode *inode, int depth,
2178 int offsets[4], Indirect chain[4], __le32 *top)
2179{
2180 Indirect *partial, *p;
2181 int k, err;
2182
2183 *top = 0;
2184
2185 for (k = depth; k > 1 && !offsets[k-1]; k--)
2186 ;
2187 partial = ext3_get_branch(inode, k, offsets, chain, &err);
2188
2189 if (!partial)
2190 partial = chain + k-1;
2191
2192
2193
2194
2195 if (!partial->key && *partial->p)
2196
2197 goto no_top;
2198 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
2199 ;
2200
2201
2202
2203
2204
2205
2206 if (p == chain + k - 1 && p > chain) {
2207 p->p--;
2208 } else {
2209 *top = *p->p;
2210
2211#if 0
2212 *p->p = 0;
2213#endif
2214 }
2215
2216
2217 while(partial > p) {
2218 brelse(partial->bh);
2219 partial--;
2220 }
2221no_top:
2222 return partial;
2223}
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
2234 struct buffer_head *bh, ext3_fsblk_t block_to_free,
2235 unsigned long count, __le32 *first, __le32 *last)
2236{
2237 __le32 *p;
2238 if (try_to_extend_transaction(handle, inode)) {
2239 if (bh) {
2240 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2241 if (ext3_journal_dirty_metadata(handle, bh))
2242 return;
2243 }
2244 ext3_mark_inode_dirty(handle, inode);
2245 truncate_restart_transaction(handle, inode);
2246 if (bh) {
2247 BUFFER_TRACE(bh, "retaking write access");
2248 if (ext3_journal_get_write_access(handle, bh))
2249 return;
2250 }
2251 }
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261 for (p = first; p < last; p++) {
2262 u32 nr = le32_to_cpu(*p);
2263 if (nr) {
2264 struct buffer_head *bh;
2265
2266 *p = 0;
2267 bh = sb_find_get_block(inode->i_sb, nr);
2268 ext3_forget(handle, 0, inode, bh, nr);
2269 }
2270 }
2271
2272 ext3_free_blocks(handle, inode, block_to_free, count);
2273}
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294static void ext3_free_data(handle_t *handle, struct inode *inode,
2295 struct buffer_head *this_bh,
2296 __le32 *first, __le32 *last)
2297{
2298 ext3_fsblk_t block_to_free = 0;
2299 unsigned long count = 0;
2300 __le32 *block_to_free_p = NULL;
2301
2302
2303 ext3_fsblk_t nr;
2304 __le32 *p;
2305
2306 int err;
2307
2308 if (this_bh) {
2309 BUFFER_TRACE(this_bh, "get_write_access");
2310 err = ext3_journal_get_write_access(handle, this_bh);
2311
2312
2313 if (err)
2314 return;
2315 }
2316
2317 for (p = first; p < last; p++) {
2318 nr = le32_to_cpu(*p);
2319 if (nr) {
2320
2321 if (count == 0) {
2322 block_to_free = nr;
2323 block_to_free_p = p;
2324 count = 1;
2325 } else if (nr == block_to_free + count) {
2326 count++;
2327 } else {
2328 ext3_clear_blocks(handle, inode, this_bh,
2329 block_to_free,
2330 count, block_to_free_p, p);
2331 block_to_free = nr;
2332 block_to_free_p = p;
2333 count = 1;
2334 }
2335 }
2336 }
2337
2338 if (count > 0)
2339 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
2340 count, block_to_free_p, p);
2341
2342 if (this_bh) {
2343 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
2344
2345
2346
2347
2348
2349
2350
2351 if (bh2jh(this_bh))
2352 ext3_journal_dirty_metadata(handle, this_bh);
2353 else
2354 ext3_error(inode->i_sb, "ext3_free_data",
2355 "circular indirect block detected, "
2356 "inode=%lu, block=%llu",
2357 inode->i_ino,
2358 (unsigned long long)this_bh->b_blocknr);
2359 }
2360}
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375static void ext3_free_branches(handle_t *handle, struct inode *inode,
2376 struct buffer_head *parent_bh,
2377 __le32 *first, __le32 *last, int depth)
2378{
2379 ext3_fsblk_t nr;
2380 __le32 *p;
2381
2382 if (is_handle_aborted(handle))
2383 return;
2384
2385 if (depth--) {
2386 struct buffer_head *bh;
2387 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2388 p = last;
2389 while (--p >= first) {
2390 nr = le32_to_cpu(*p);
2391 if (!nr)
2392 continue;
2393
2394
2395 bh = sb_bread(inode->i_sb, nr);
2396
2397
2398
2399
2400
2401 if (!bh) {
2402 ext3_error(inode->i_sb, "ext3_free_branches",
2403 "Read failure, inode=%lu, block="E3FSBLK,
2404 inode->i_ino, nr);
2405 continue;
2406 }
2407
2408
2409 BUFFER_TRACE(bh, "free child branches");
2410 ext3_free_branches(handle, inode, bh,
2411 (__le32*)bh->b_data,
2412 (__le32*)bh->b_data + addr_per_block,
2413 depth);
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431 if (is_handle_aborted(handle))
2432 return;
2433 if (try_to_extend_transaction(handle, inode)) {
2434 ext3_mark_inode_dirty(handle, inode);
2435 truncate_restart_transaction(handle, inode);
2436 }
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2462
2463 ext3_free_blocks(handle, inode, nr, 1);
2464
2465 if (parent_bh) {
2466
2467
2468
2469
2470 BUFFER_TRACE(parent_bh, "get_write_access");
2471 if (!ext3_journal_get_write_access(handle,
2472 parent_bh)){
2473 *p = 0;
2474 BUFFER_TRACE(parent_bh,
2475 "call ext3_journal_dirty_metadata");
2476 ext3_journal_dirty_metadata(handle,
2477 parent_bh);
2478 }
2479 }
2480 }
2481 } else {
2482
2483 BUFFER_TRACE(parent_bh, "free data blocks");
2484 ext3_free_data(handle, inode, parent_bh, first, last);
2485 }
2486}
2487
2488int ext3_can_truncate(struct inode *inode)
2489{
2490 if (S_ISREG(inode->i_mode))
2491 return 1;
2492 if (S_ISDIR(inode->i_mode))
2493 return 1;
2494 if (S_ISLNK(inode->i_mode))
2495 return !ext3_inode_is_fast_symlink(inode);
2496 return 0;
2497}
2498
2499
2500
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
2527void ext3_truncate(struct inode *inode)
2528{
2529 handle_t *handle;
2530 struct ext3_inode_info *ei = EXT3_I(inode);
2531 __le32 *i_data = ei->i_data;
2532 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2533 int offsets[4];
2534 Indirect chain[4];
2535 Indirect *partial;
2536 __le32 nr = 0;
2537 int n;
2538 long last_block;
2539 unsigned blocksize = inode->i_sb->s_blocksize;
2540
2541 trace_ext3_truncate_enter(inode);
2542
2543 if (!ext3_can_truncate(inode))
2544 goto out_notrans;
2545
2546 if (inode->i_size == 0 && ext3_should_writeback_data(inode))
2547 ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
2548
2549 handle = start_transaction(inode);
2550 if (IS_ERR(handle))
2551 goto out_notrans;
2552
2553 last_block = (inode->i_size + blocksize-1)
2554 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2555 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2556 if (n == 0)
2557 goto out_stop;
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568 if (ext3_orphan_add(handle, inode))
2569 goto out_stop;
2570
2571
2572
2573
2574
2575
2576
2577
2578 ei->i_disksize = inode->i_size;
2579
2580
2581
2582
2583
2584 mutex_lock(&ei->truncate_mutex);
2585
2586 if (n == 1) {
2587 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2588 i_data + EXT3_NDIR_BLOCKS);
2589 goto do_indirects;
2590 }
2591
2592 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2593
2594 if (nr) {
2595 if (partial == chain) {
2596
2597 ext3_free_branches(handle, inode, NULL,
2598 &nr, &nr+1, (chain+n-1) - partial);
2599 *partial->p = 0;
2600
2601
2602
2603
2604 } else {
2605
2606 ext3_free_branches(handle, inode, partial->bh,
2607 partial->p,
2608 partial->p+1, (chain+n-1) - partial);
2609 }
2610 }
2611
2612 while (partial > chain) {
2613 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2614 (__le32*)partial->bh->b_data+addr_per_block,
2615 (chain+n-1) - partial);
2616 BUFFER_TRACE(partial->bh, "call brelse");
2617 brelse (partial->bh);
2618 partial--;
2619 }
2620do_indirects:
2621
2622 switch (offsets[0]) {
2623 default:
2624 nr = i_data[EXT3_IND_BLOCK];
2625 if (nr) {
2626 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
2627 i_data[EXT3_IND_BLOCK] = 0;
2628 }
2629 case EXT3_IND_BLOCK:
2630 nr = i_data[EXT3_DIND_BLOCK];
2631 if (nr) {
2632 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
2633 i_data[EXT3_DIND_BLOCK] = 0;
2634 }
2635 case EXT3_DIND_BLOCK:
2636 nr = i_data[EXT3_TIND_BLOCK];
2637 if (nr) {
2638 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
2639 i_data[EXT3_TIND_BLOCK] = 0;
2640 }
2641 case EXT3_TIND_BLOCK:
2642 ;
2643 }
2644
2645 ext3_discard_reservation(inode);
2646
2647 mutex_unlock(&ei->truncate_mutex);
2648 inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2649 ext3_mark_inode_dirty(handle, inode);
2650
2651
2652
2653
2654
2655 if (IS_SYNC(inode))
2656 handle->h_sync = 1;
2657out_stop:
2658
2659
2660
2661
2662
2663
2664
2665 if (inode->i_nlink)
2666 ext3_orphan_del(handle, inode);
2667
2668 ext3_journal_stop(handle);
2669 trace_ext3_truncate_exit(inode);
2670 return;
2671out_notrans:
2672
2673
2674
2675
2676 if (inode->i_nlink)
2677 ext3_orphan_del(NULL, inode);
2678 trace_ext3_truncate_exit(inode);
2679}
2680
2681static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
2682 unsigned long ino, struct ext3_iloc *iloc)
2683{
2684 unsigned long block_group;
2685 unsigned long offset;
2686 ext3_fsblk_t block;
2687 struct ext3_group_desc *gdp;
2688
2689 if (!ext3_valid_inum(sb, ino)) {
2690
2691
2692
2693
2694
2695 return 0;
2696 }
2697
2698 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2699 gdp = ext3_get_group_desc(sb, block_group, NULL);
2700 if (!gdp)
2701 return 0;
2702
2703
2704
2705 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2706 EXT3_INODE_SIZE(sb);
2707 block = le32_to_cpu(gdp->bg_inode_table) +
2708 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2709
2710 iloc->block_group = block_group;
2711 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2712 return block;
2713}
2714
2715
2716
2717
2718
2719
2720
2721static int __ext3_get_inode_loc(struct inode *inode,
2722 struct ext3_iloc *iloc, int in_mem)
2723{
2724 ext3_fsblk_t block;
2725 struct buffer_head *bh;
2726
2727 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2728 if (!block)
2729 return -EIO;
2730
2731 bh = sb_getblk(inode->i_sb, block);
2732 if (!bh) {
2733 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2734 "unable to read inode block - "
2735 "inode=%lu, block="E3FSBLK,
2736 inode->i_ino, block);
2737 return -EIO;
2738 }
2739 if (!buffer_uptodate(bh)) {
2740 lock_buffer(bh);
2741
2742
2743
2744
2745
2746
2747
2748 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
2749 set_buffer_uptodate(bh);
2750
2751 if (buffer_uptodate(bh)) {
2752
2753 unlock_buffer(bh);
2754 goto has_buffer;
2755 }
2756
2757
2758
2759
2760
2761
2762 if (in_mem) {
2763 struct buffer_head *bitmap_bh;
2764 struct ext3_group_desc *desc;
2765 int inodes_per_buffer;
2766 int inode_offset, i;
2767 int block_group;
2768 int start;
2769
2770 block_group = (inode->i_ino - 1) /
2771 EXT3_INODES_PER_GROUP(inode->i_sb);
2772 inodes_per_buffer = bh->b_size /
2773 EXT3_INODE_SIZE(inode->i_sb);
2774 inode_offset = ((inode->i_ino - 1) %
2775 EXT3_INODES_PER_GROUP(inode->i_sb));
2776 start = inode_offset & ~(inodes_per_buffer - 1);
2777
2778
2779 desc = ext3_get_group_desc(inode->i_sb,
2780 block_group, NULL);
2781 if (!desc)
2782 goto make_io;
2783
2784 bitmap_bh = sb_getblk(inode->i_sb,
2785 le32_to_cpu(desc->bg_inode_bitmap));
2786 if (!bitmap_bh)
2787 goto make_io;
2788
2789
2790
2791
2792
2793
2794 if (!buffer_uptodate(bitmap_bh)) {
2795 brelse(bitmap_bh);
2796 goto make_io;
2797 }
2798 for (i = start; i < start + inodes_per_buffer; i++) {
2799 if (i == inode_offset)
2800 continue;
2801 if (ext3_test_bit(i, bitmap_bh->b_data))
2802 break;
2803 }
2804 brelse(bitmap_bh);
2805 if (i == start + inodes_per_buffer) {
2806
2807 memset(bh->b_data, 0, bh->b_size);
2808 set_buffer_uptodate(bh);
2809 unlock_buffer(bh);
2810 goto has_buffer;
2811 }
2812 }
2813
2814make_io:
2815
2816
2817
2818
2819
2820 trace_ext3_load_inode(inode);
2821 get_bh(bh);
2822 bh->b_end_io = end_buffer_read_sync;
2823 submit_bh(READ | REQ_META | REQ_PRIO, bh);
2824 wait_on_buffer(bh);
2825 if (!buffer_uptodate(bh)) {
2826 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2827 "unable to read inode block - "
2828 "inode=%lu, block="E3FSBLK,
2829 inode->i_ino, block);
2830 brelse(bh);
2831 return -EIO;
2832 }
2833 }
2834has_buffer:
2835 iloc->bh = bh;
2836 return 0;
2837}
2838
2839int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2840{
2841
2842 return __ext3_get_inode_loc(inode, iloc,
2843 !ext3_test_inode_state(inode, EXT3_STATE_XATTR));
2844}
2845
2846void ext3_set_inode_flags(struct inode *inode)
2847{
2848 unsigned int flags = EXT3_I(inode)->i_flags;
2849
2850 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2851 if (flags & EXT3_SYNC_FL)
2852 inode->i_flags |= S_SYNC;
2853 if (flags & EXT3_APPEND_FL)
2854 inode->i_flags |= S_APPEND;
2855 if (flags & EXT3_IMMUTABLE_FL)
2856 inode->i_flags |= S_IMMUTABLE;
2857 if (flags & EXT3_NOATIME_FL)
2858 inode->i_flags |= S_NOATIME;
2859 if (flags & EXT3_DIRSYNC_FL)
2860 inode->i_flags |= S_DIRSYNC;
2861}
2862
2863
2864void ext3_get_inode_flags(struct ext3_inode_info *ei)
2865{
2866 unsigned int flags = ei->vfs_inode.i_flags;
2867
2868 ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
2869 EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
2870 if (flags & S_SYNC)
2871 ei->i_flags |= EXT3_SYNC_FL;
2872 if (flags & S_APPEND)
2873 ei->i_flags |= EXT3_APPEND_FL;
2874 if (flags & S_IMMUTABLE)
2875 ei->i_flags |= EXT3_IMMUTABLE_FL;
2876 if (flags & S_NOATIME)
2877 ei->i_flags |= EXT3_NOATIME_FL;
2878 if (flags & S_DIRSYNC)
2879 ei->i_flags |= EXT3_DIRSYNC_FL;
2880}
2881
2882struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
2883{
2884 struct ext3_iloc iloc;
2885 struct ext3_inode *raw_inode;
2886 struct ext3_inode_info *ei;
2887 struct buffer_head *bh;
2888 struct inode *inode;
2889 journal_t *journal = EXT3_SB(sb)->s_journal;
2890 transaction_t *transaction;
2891 long ret;
2892 int block;
2893 uid_t i_uid;
2894 gid_t i_gid;
2895
2896 inode = iget_locked(sb, ino);
2897 if (!inode)
2898 return ERR_PTR(-ENOMEM);
2899 if (!(inode->i_state & I_NEW))
2900 return inode;
2901
2902 ei = EXT3_I(inode);
2903 ei->i_block_alloc_info = NULL;
2904
2905 ret = __ext3_get_inode_loc(inode, &iloc, 0);
2906 if (ret < 0)
2907 goto bad_inode;
2908 bh = iloc.bh;
2909 raw_inode = ext3_raw_inode(&iloc);
2910 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2911 i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2912 i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2913 if(!(test_opt (inode->i_sb, NO_UID32))) {
2914 i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2915 i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2916 }
2917 i_uid_write(inode, i_uid);
2918 i_gid_write(inode, i_gid);
2919 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
2920 inode->i_size = le32_to_cpu(raw_inode->i_size);
2921 inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
2922 inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
2923 inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
2924 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2925
2926 ei->i_state_flags = 0;
2927 ei->i_dir_start_lookup = 0;
2928 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2929
2930
2931
2932
2933
2934 if (inode->i_nlink == 0) {
2935 if (inode->i_mode == 0 ||
2936 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2937
2938 brelse (bh);
2939 ret = -ESTALE;
2940 goto bad_inode;
2941 }
2942
2943
2944
2945
2946 }
2947 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2948 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2949#ifdef EXT3_FRAGMENTS
2950 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2951 ei->i_frag_no = raw_inode->i_frag;
2952 ei->i_frag_size = raw_inode->i_fsize;
2953#endif
2954 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2955 if (!S_ISREG(inode->i_mode)) {
2956 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2957 } else {
2958 inode->i_size |=
2959 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2960 }
2961 ei->i_disksize = inode->i_size;
2962 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2963 ei->i_block_group = iloc.block_group;
2964
2965
2966
2967
2968 for (block = 0; block < EXT3_N_BLOCKS; block++)
2969 ei->i_data[block] = raw_inode->i_block[block];
2970 INIT_LIST_HEAD(&ei->i_orphan);
2971
2972
2973
2974
2975
2976
2977
2978
2979 if (journal) {
2980 tid_t tid;
2981
2982 spin_lock(&journal->j_state_lock);
2983 if (journal->j_running_transaction)
2984 transaction = journal->j_running_transaction;
2985 else
2986 transaction = journal->j_committing_transaction;
2987 if (transaction)
2988 tid = transaction->t_tid;
2989 else
2990 tid = journal->j_commit_sequence;
2991 spin_unlock(&journal->j_state_lock);
2992 atomic_set(&ei->i_sync_tid, tid);
2993 atomic_set(&ei->i_datasync_tid, tid);
2994 }
2995
2996 if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
2997 EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
2998
2999
3000
3001
3002
3003 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3004 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3005 EXT3_INODE_SIZE(inode->i_sb)) {
3006 brelse (bh);
3007 ret = -EIO;
3008 goto bad_inode;
3009 }
3010 if (ei->i_extra_isize == 0) {
3011
3012 ei->i_extra_isize = sizeof(struct ext3_inode) -
3013 EXT3_GOOD_OLD_INODE_SIZE;
3014 } else {
3015 __le32 *magic = (void *)raw_inode +
3016 EXT3_GOOD_OLD_INODE_SIZE +
3017 ei->i_extra_isize;
3018 if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
3019 ext3_set_inode_state(inode, EXT3_STATE_XATTR);
3020 }
3021 } else
3022 ei->i_extra_isize = 0;
3023
3024 if (S_ISREG(inode->i_mode)) {
3025 inode->i_op = &ext3_file_inode_operations;
3026 inode->i_fop = &ext3_file_operations;
3027 ext3_set_aops(inode);
3028 } else if (S_ISDIR(inode->i_mode)) {
3029 inode->i_op = &ext3_dir_inode_operations;
3030 inode->i_fop = &ext3_dir_operations;
3031 } else if (S_ISLNK(inode->i_mode)) {
3032 if (ext3_inode_is_fast_symlink(inode)) {
3033 inode->i_op = &ext3_fast_symlink_inode_operations;
3034 nd_terminate_link(ei->i_data, inode->i_size,
3035 sizeof(ei->i_data) - 1);
3036 } else {
3037 inode->i_op = &ext3_symlink_inode_operations;
3038 ext3_set_aops(inode);
3039 }
3040 } else {
3041 inode->i_op = &ext3_special_inode_operations;
3042 if (raw_inode->i_block[0])
3043 init_special_inode(inode, inode->i_mode,
3044 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3045 else
3046 init_special_inode(inode, inode->i_mode,
3047 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3048 }
3049 brelse (iloc.bh);
3050 ext3_set_inode_flags(inode);
3051 unlock_new_inode(inode);
3052 return inode;
3053
3054bad_inode:
3055 iget_failed(inode);
3056 return ERR_PTR(ret);
3057}
3058
3059
3060
3061
3062
3063
3064
3065
3066static int ext3_do_update_inode(handle_t *handle,
3067 struct inode *inode,
3068 struct ext3_iloc *iloc)
3069{
3070 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
3071 struct ext3_inode_info *ei = EXT3_I(inode);
3072 struct buffer_head *bh = iloc->bh;
3073 int err = 0, rc, block;
3074 int need_datasync = 0;
3075 __le32 disksize;
3076 uid_t i_uid;
3077 gid_t i_gid;
3078
3079again:
3080
3081 lock_buffer(bh);
3082
3083
3084
3085 if (ext3_test_inode_state(inode, EXT3_STATE_NEW))
3086 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
3087
3088 ext3_get_inode_flags(ei);
3089 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
3090 i_uid = i_uid_read(inode);
3091 i_gid = i_gid_read(inode);
3092 if(!(test_opt(inode->i_sb, NO_UID32))) {
3093 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
3094 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
3095
3096
3097
3098
3099 if(!ei->i_dtime) {
3100 raw_inode->i_uid_high =
3101 cpu_to_le16(high_16_bits(i_uid));
3102 raw_inode->i_gid_high =
3103 cpu_to_le16(high_16_bits(i_gid));
3104 } else {
3105 raw_inode->i_uid_high = 0;
3106 raw_inode->i_gid_high = 0;
3107 }
3108 } else {
3109 raw_inode->i_uid_low =
3110 cpu_to_le16(fs_high2lowuid(i_uid));
3111 raw_inode->i_gid_low =
3112 cpu_to_le16(fs_high2lowgid(i_gid));
3113 raw_inode->i_uid_high = 0;
3114 raw_inode->i_gid_high = 0;
3115 }
3116 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
3117 disksize = cpu_to_le32(ei->i_disksize);
3118 if (disksize != raw_inode->i_size) {
3119 need_datasync = 1;
3120 raw_inode->i_size = disksize;
3121 }
3122 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
3123 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
3124 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
3125 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
3126 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
3127 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
3128#ifdef EXT3_FRAGMENTS
3129 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
3130 raw_inode->i_frag = ei->i_frag_no;
3131 raw_inode->i_fsize = ei->i_frag_size;
3132#endif
3133 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
3134 if (!S_ISREG(inode->i_mode)) {
3135 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
3136 } else {
3137 disksize = cpu_to_le32(ei->i_disksize >> 32);
3138 if (disksize != raw_inode->i_size_high) {
3139 raw_inode->i_size_high = disksize;
3140 need_datasync = 1;
3141 }
3142 if (ei->i_disksize > 0x7fffffffULL) {
3143 struct super_block *sb = inode->i_sb;
3144 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
3145 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
3146 EXT3_SB(sb)->s_es->s_rev_level ==
3147 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
3148
3149
3150
3151 unlock_buffer(bh);
3152 err = ext3_journal_get_write_access(handle,
3153 EXT3_SB(sb)->s_sbh);
3154 if (err)
3155 goto out_brelse;
3156
3157 ext3_update_dynamic_rev(sb);
3158 EXT3_SET_RO_COMPAT_FEATURE(sb,
3159 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
3160 handle->h_sync = 1;
3161 err = ext3_journal_dirty_metadata(handle,
3162 EXT3_SB(sb)->s_sbh);
3163
3164 goto again;
3165 }
3166 }
3167 }
3168 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
3169 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
3170 if (old_valid_dev(inode->i_rdev)) {
3171 raw_inode->i_block[0] =
3172 cpu_to_le32(old_encode_dev(inode->i_rdev));
3173 raw_inode->i_block[1] = 0;
3174 } else {
3175 raw_inode->i_block[0] = 0;
3176 raw_inode->i_block[1] =
3177 cpu_to_le32(new_encode_dev(inode->i_rdev));
3178 raw_inode->i_block[2] = 0;
3179 }
3180 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
3181 raw_inode->i_block[block] = ei->i_data[block];
3182
3183 if (ei->i_extra_isize)
3184 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
3185
3186 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
3187 unlock_buffer(bh);
3188 rc = ext3_journal_dirty_metadata(handle, bh);
3189 if (!err)
3190 err = rc;
3191 ext3_clear_inode_state(inode, EXT3_STATE_NEW);
3192
3193 atomic_set(&ei->i_sync_tid, handle->h_transaction->t_tid);
3194 if (need_datasync)
3195 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
3196out_brelse:
3197 brelse (bh);
3198 ext3_std_error(inode->i_sb, err);
3199 return err;
3200}
3201
3202
3203
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
3237int ext3_write_inode(struct inode *inode, struct writeback_control *wbc)
3238{
3239 if (current->flags & PF_MEMALLOC)
3240 return 0;
3241
3242 if (ext3_journal_current_handle()) {
3243 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
3244 dump_stack();
3245 return -EIO;
3246 }
3247
3248 if (wbc->sync_mode != WB_SYNC_ALL)
3249 return 0;
3250
3251 return ext3_force_commit(inode->i_sb);
3252}
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3272{
3273 struct inode *inode = dentry->d_inode;
3274 int error, rc = 0;
3275 const unsigned int ia_valid = attr->ia_valid;
3276
3277 error = inode_change_ok(inode, attr);
3278 if (error)
3279 return error;
3280
3281 if (is_quota_modification(inode, attr))
3282 dquot_initialize(inode);
3283 if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
3284 (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
3285 handle_t *handle;
3286
3287
3288
3289 handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
3290 EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
3291 if (IS_ERR(handle)) {
3292 error = PTR_ERR(handle);
3293 goto err_out;
3294 }
3295 error = dquot_transfer(inode, attr);
3296 if (error) {
3297 ext3_journal_stop(handle);
3298 return error;
3299 }
3300
3301
3302 if (attr->ia_valid & ATTR_UID)
3303 inode->i_uid = attr->ia_uid;
3304 if (attr->ia_valid & ATTR_GID)
3305 inode->i_gid = attr->ia_gid;
3306 error = ext3_mark_inode_dirty(handle, inode);
3307 ext3_journal_stop(handle);
3308 }
3309
3310 if (attr->ia_valid & ATTR_SIZE)
3311 inode_dio_wait(inode);
3312
3313 if (S_ISREG(inode->i_mode) &&
3314 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
3315 handle_t *handle;
3316
3317 handle = ext3_journal_start(inode, 3);
3318 if (IS_ERR(handle)) {
3319 error = PTR_ERR(handle);
3320 goto err_out;
3321 }
3322
3323 error = ext3_orphan_add(handle, inode);
3324 if (error) {
3325 ext3_journal_stop(handle);
3326 goto err_out;
3327 }
3328 EXT3_I(inode)->i_disksize = attr->ia_size;
3329 error = ext3_mark_inode_dirty(handle, inode);
3330 ext3_journal_stop(handle);
3331 if (error) {
3332
3333 ext3_orphan_del(NULL, inode);
3334 goto err_out;
3335 }
3336 rc = ext3_block_truncate_page(inode, attr->ia_size);
3337 if (rc) {
3338
3339 handle = ext3_journal_start(inode, 3);
3340 if (IS_ERR(handle)) {
3341 ext3_orphan_del(NULL, inode);
3342 goto err_out;
3343 }
3344 ext3_orphan_del(handle, inode);
3345 ext3_journal_stop(handle);
3346 goto err_out;
3347 }
3348 }
3349
3350 if ((attr->ia_valid & ATTR_SIZE) &&
3351 attr->ia_size != i_size_read(inode)) {
3352 truncate_setsize(inode, attr->ia_size);
3353 ext3_truncate(inode);
3354 }
3355
3356 setattr_copy(inode, attr);
3357 mark_inode_dirty(inode);
3358
3359 if (ia_valid & ATTR_MODE)
3360 rc = ext3_acl_chmod(inode);
3361
3362err_out:
3363 ext3_std_error(inode->i_sb, error);
3364 if (!error)
3365 error = rc;
3366 return error;
3367}
3368
3369
3370
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
3397static int ext3_writepage_trans_blocks(struct inode *inode)
3398{
3399 int bpp = ext3_journal_blocks_per_page(inode);
3400 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
3401 int ret;
3402
3403 if (ext3_should_journal_data(inode))
3404 ret = 3 * (bpp + indirects) + 2;
3405 else
3406 ret = 2 * (bpp + indirects) + indirects + 2;
3407
3408#ifdef CONFIG_QUOTA
3409
3410
3411 ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
3412#endif
3413
3414 return ret;
3415}
3416
3417
3418
3419
3420
3421int ext3_mark_iloc_dirty(handle_t *handle,
3422 struct inode *inode, struct ext3_iloc *iloc)
3423{
3424 int err = 0;
3425
3426
3427 get_bh(iloc->bh);
3428
3429
3430 err = ext3_do_update_inode(handle, inode, iloc);
3431 put_bh(iloc->bh);
3432 return err;
3433}
3434
3435
3436
3437
3438
3439
3440int
3441ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
3442 struct ext3_iloc *iloc)
3443{
3444 int err = 0;
3445 if (handle) {
3446 err = ext3_get_inode_loc(inode, iloc);
3447 if (!err) {
3448 BUFFER_TRACE(iloc->bh, "get_write_access");
3449 err = ext3_journal_get_write_access(handle, iloc->bh);
3450 if (err) {
3451 brelse(iloc->bh);
3452 iloc->bh = NULL;
3453 }
3454 }
3455 }
3456 ext3_std_error(inode->i_sb, err);
3457 return err;
3458}
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3474{
3475 struct ext3_iloc iloc;
3476 int err;
3477
3478 might_sleep();
3479 trace_ext3_mark_inode_dirty(inode, _RET_IP_);
3480 err = ext3_reserve_inode_write(handle, inode, &iloc);
3481 if (!err)
3482 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3483 return err;
3484}
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500void ext3_dirty_inode(struct inode *inode, int flags)
3501{
3502 handle_t *current_handle = ext3_journal_current_handle();
3503 handle_t *handle;
3504
3505 handle = ext3_journal_start(inode, 2);
3506 if (IS_ERR(handle))
3507 goto out;
3508 if (current_handle &&
3509 current_handle->h_transaction != handle->h_transaction) {
3510
3511 printk(KERN_EMERG "%s: transactions do not match!\n",
3512 __func__);
3513 } else {
3514 jbd_debug(5, "marking dirty. outer handle=%p\n",
3515 current_handle);
3516 ext3_mark_inode_dirty(handle, inode);
3517 }
3518 ext3_journal_stop(handle);
3519out:
3520 return;
3521}
3522
3523#if 0
3524
3525
3526
3527
3528
3529
3530
3531static int ext3_pin_inode(handle_t *handle, struct inode *inode)
3532{
3533 struct ext3_iloc iloc;
3534
3535 int err = 0;
3536 if (handle) {
3537 err = ext3_get_inode_loc(inode, &iloc);
3538 if (!err) {
3539 BUFFER_TRACE(iloc.bh, "get_write_access");
3540 err = journal_get_write_access(handle, iloc.bh);
3541 if (!err)
3542 err = ext3_journal_dirty_metadata(handle,
3543 iloc.bh);
3544 brelse(iloc.bh);
3545 }
3546 }
3547 ext3_std_error(inode->i_sb, err);
3548 return err;
3549}
3550#endif
3551
3552int ext3_change_inode_journal_flag(struct inode *inode, int val)
3553{
3554 journal_t *journal;
3555 handle_t *handle;
3556 int err;
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567
3568 journal = EXT3_JOURNAL(inode);
3569 if (is_journal_aborted(journal))
3570 return -EROFS;
3571
3572 journal_lock_updates(journal);
3573 journal_flush(journal);
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583 if (val)
3584 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3585 else
3586 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3587 ext3_set_aops(inode);
3588
3589 journal_unlock_updates(journal);
3590
3591
3592
3593 handle = ext3_journal_start(inode, 1);
3594 if (IS_ERR(handle))
3595 return PTR_ERR(handle);
3596
3597 err = ext3_mark_inode_dirty(handle, inode);
3598 handle->h_sync = 1;
3599 ext3_journal_stop(handle);
3600 ext3_std_error(inode->i_sb, err);
3601
3602 return err;
3603}
3604