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