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