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 long offset)
1829{
1830 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1831
1832 trace_ext3_invalidatepage(page, offset);
1833
1834
1835
1836
1837 if (offset == 0)
1838 ClearPageChecked(page);
1839
1840 journal_invalidatepage(journal, page, offset);
1841}
1842
1843static int ext3_releasepage(struct page *page, gfp_t wait)
1844{
1845 journal_t *journal = EXT3_JOURNAL(page->mapping->host);
1846
1847 trace_ext3_releasepage(page);
1848 WARN_ON(PageChecked(page));
1849 if (!page_has_buffers(page))
1850 return 0;
1851 return journal_try_to_free_buffers(journal, page, wait);
1852}
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863static ssize_t ext3_direct_IO(int rw, struct kiocb *iocb,
1864 const struct iovec *iov, loff_t offset,
1865 unsigned long nr_segs)
1866{
1867 struct file *file = iocb->ki_filp;
1868 struct inode *inode = file->f_mapping->host;
1869 struct ext3_inode_info *ei = EXT3_I(inode);
1870 handle_t *handle;
1871 ssize_t ret;
1872 int orphan = 0;
1873 size_t count = iov_length(iov, nr_segs);
1874 int retries = 0;
1875
1876 trace_ext3_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
1877
1878 if (rw == WRITE) {
1879 loff_t final_size = offset + count;
1880
1881 if (final_size > inode->i_size) {
1882
1883 handle = ext3_journal_start(inode, 2);
1884 if (IS_ERR(handle)) {
1885 ret = PTR_ERR(handle);
1886 goto out;
1887 }
1888 ret = ext3_orphan_add(handle, inode);
1889 if (ret) {
1890 ext3_journal_stop(handle);
1891 goto out;
1892 }
1893 orphan = 1;
1894 ei->i_disksize = inode->i_size;
1895 ext3_journal_stop(handle);
1896 }
1897 }
1898
1899retry:
1900 ret = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
1901 ext3_get_block);
1902
1903
1904
1905
1906 if (unlikely((rw & WRITE) && ret < 0)) {
1907 loff_t isize = i_size_read(inode);
1908 loff_t end = offset + iov_length(iov, nr_segs);
1909
1910 if (end > isize)
1911 ext3_truncate_failed_direct_write(inode);
1912 }
1913 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
1914 goto retry;
1915
1916 if (orphan) {
1917 int err;
1918
1919
1920 handle = ext3_journal_start(inode, 2);
1921 if (IS_ERR(handle)) {
1922
1923
1924
1925 ext3_truncate_failed_direct_write(inode);
1926 ret = PTR_ERR(handle);
1927 goto out;
1928 }
1929 if (inode->i_nlink)
1930 ext3_orphan_del(handle, inode);
1931 if (ret > 0) {
1932 loff_t end = offset + ret;
1933 if (end > inode->i_size) {
1934 ei->i_disksize = end;
1935 i_size_write(inode, end);
1936
1937
1938
1939
1940
1941
1942
1943 ext3_mark_inode_dirty(handle, inode);
1944 }
1945 }
1946 err = ext3_journal_stop(handle);
1947 if (ret == 0)
1948 ret = err;
1949 }
1950out:
1951 trace_ext3_direct_IO_exit(inode, offset,
1952 iov_length(iov, nr_segs), rw, ret);
1953 return ret;
1954}
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969static int ext3_journalled_set_page_dirty(struct page *page)
1970{
1971 SetPageChecked(page);
1972 return __set_page_dirty_nobuffers(page);
1973}
1974
1975static const struct address_space_operations ext3_ordered_aops = {
1976 .readpage = ext3_readpage,
1977 .readpages = ext3_readpages,
1978 .writepage = ext3_ordered_writepage,
1979 .write_begin = ext3_write_begin,
1980 .write_end = ext3_ordered_write_end,
1981 .bmap = ext3_bmap,
1982 .invalidatepage = ext3_invalidatepage,
1983 .releasepage = ext3_releasepage,
1984 .direct_IO = ext3_direct_IO,
1985 .migratepage = buffer_migrate_page,
1986 .is_partially_uptodate = block_is_partially_uptodate,
1987 .error_remove_page = generic_error_remove_page,
1988};
1989
1990static const struct address_space_operations ext3_writeback_aops = {
1991 .readpage = ext3_readpage,
1992 .readpages = ext3_readpages,
1993 .writepage = ext3_writeback_writepage,
1994 .write_begin = ext3_write_begin,
1995 .write_end = ext3_writeback_write_end,
1996 .bmap = ext3_bmap,
1997 .invalidatepage = ext3_invalidatepage,
1998 .releasepage = ext3_releasepage,
1999 .direct_IO = ext3_direct_IO,
2000 .migratepage = buffer_migrate_page,
2001 .is_partially_uptodate = block_is_partially_uptodate,
2002 .error_remove_page = generic_error_remove_page,
2003};
2004
2005static const struct address_space_operations ext3_journalled_aops = {
2006 .readpage = ext3_readpage,
2007 .readpages = ext3_readpages,
2008 .writepage = ext3_journalled_writepage,
2009 .write_begin = ext3_write_begin,
2010 .write_end = ext3_journalled_write_end,
2011 .set_page_dirty = ext3_journalled_set_page_dirty,
2012 .bmap = ext3_bmap,
2013 .invalidatepage = ext3_invalidatepage,
2014 .releasepage = ext3_releasepage,
2015 .is_partially_uptodate = block_is_partially_uptodate,
2016 .error_remove_page = generic_error_remove_page,
2017};
2018
2019void ext3_set_aops(struct inode *inode)
2020{
2021 if (ext3_should_order_data(inode))
2022 inode->i_mapping->a_ops = &ext3_ordered_aops;
2023 else if (ext3_should_writeback_data(inode))
2024 inode->i_mapping->a_ops = &ext3_writeback_aops;
2025 else
2026 inode->i_mapping->a_ops = &ext3_journalled_aops;
2027}
2028
2029
2030
2031
2032
2033
2034
2035static int ext3_block_truncate_page(struct inode *inode, loff_t from)
2036{
2037 ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
2038 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
2039 unsigned blocksize, iblock, length, pos;
2040 struct page *page;
2041 handle_t *handle = NULL;
2042 struct buffer_head *bh;
2043 int err = 0;
2044
2045
2046 blocksize = inode->i_sb->s_blocksize;
2047 if ((from & (blocksize - 1)) == 0)
2048 return 0;
2049
2050 page = grab_cache_page(inode->i_mapping, index);
2051 if (!page)
2052 return -ENOMEM;
2053 length = blocksize - (offset & (blocksize - 1));
2054 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
2055
2056 if (!page_has_buffers(page))
2057 create_empty_buffers(page, blocksize, 0);
2058
2059
2060 bh = page_buffers(page);
2061 pos = blocksize;
2062 while (offset >= pos) {
2063 bh = bh->b_this_page;
2064 iblock++;
2065 pos += blocksize;
2066 }
2067
2068 err = 0;
2069 if (buffer_freed(bh)) {
2070 BUFFER_TRACE(bh, "freed: skip");
2071 goto unlock;
2072 }
2073
2074 if (!buffer_mapped(bh)) {
2075 BUFFER_TRACE(bh, "unmapped");
2076 ext3_get_block(inode, iblock, bh, 0);
2077
2078 if (!buffer_mapped(bh)) {
2079 BUFFER_TRACE(bh, "still unmapped");
2080 goto unlock;
2081 }
2082 }
2083
2084
2085 if (PageUptodate(page))
2086 set_buffer_uptodate(bh);
2087
2088 if (!bh_uptodate_or_lock(bh)) {
2089 err = bh_submit_read(bh);
2090
2091 if (err)
2092 goto unlock;
2093 }
2094
2095
2096 if (!ext3_should_writeback_data(inode)) {
2097
2098 handle = ext3_journal_start(inode, 1);
2099 if (IS_ERR(handle)) {
2100 clear_highpage(page);
2101 flush_dcache_page(page);
2102 err = PTR_ERR(handle);
2103 goto unlock;
2104 }
2105 }
2106
2107 if (ext3_should_journal_data(inode)) {
2108 BUFFER_TRACE(bh, "get write access");
2109 err = ext3_journal_get_write_access(handle, bh);
2110 if (err)
2111 goto stop;
2112 }
2113
2114 zero_user(page, offset, length);
2115 BUFFER_TRACE(bh, "zeroed end of block");
2116
2117 err = 0;
2118 if (ext3_should_journal_data(inode)) {
2119 err = ext3_journal_dirty_metadata(handle, bh);
2120 } else {
2121 if (ext3_should_order_data(inode))
2122 err = ext3_journal_dirty_data(handle, bh);
2123 mark_buffer_dirty(bh);
2124 }
2125stop:
2126 if (handle)
2127 ext3_journal_stop(handle);
2128
2129unlock:
2130 unlock_page(page);
2131 page_cache_release(page);
2132 return err;
2133}
2134
2135
2136
2137
2138
2139
2140static inline int all_zeroes(__le32 *p, __le32 *q)
2141{
2142 while (p < q)
2143 if (*p++)
2144 return 0;
2145 return 1;
2146}
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183static Indirect *ext3_find_shared(struct inode *inode, int depth,
2184 int offsets[4], Indirect chain[4], __le32 *top)
2185{
2186 Indirect *partial, *p;
2187 int k, err;
2188
2189 *top = 0;
2190
2191 for (k = depth; k > 1 && !offsets[k-1]; k--)
2192 ;
2193 partial = ext3_get_branch(inode, k, offsets, chain, &err);
2194
2195 if (!partial)
2196 partial = chain + k-1;
2197
2198
2199
2200
2201 if (!partial->key && *partial->p)
2202
2203 goto no_top;
2204 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
2205 ;
2206
2207
2208
2209
2210
2211
2212 if (p == chain + k - 1 && p > chain) {
2213 p->p--;
2214 } else {
2215 *top = *p->p;
2216
2217#if 0
2218 *p->p = 0;
2219#endif
2220 }
2221
2222
2223 while(partial > p) {
2224 brelse(partial->bh);
2225 partial--;
2226 }
2227no_top:
2228 return partial;
2229}
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
2240 struct buffer_head *bh, ext3_fsblk_t block_to_free,
2241 unsigned long count, __le32 *first, __le32 *last)
2242{
2243 __le32 *p;
2244 if (try_to_extend_transaction(handle, inode)) {
2245 if (bh) {
2246 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2247 if (ext3_journal_dirty_metadata(handle, bh))
2248 return;
2249 }
2250 ext3_mark_inode_dirty(handle, inode);
2251 truncate_restart_transaction(handle, inode);
2252 if (bh) {
2253 BUFFER_TRACE(bh, "retaking write access");
2254 if (ext3_journal_get_write_access(handle, bh))
2255 return;
2256 }
2257 }
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267 for (p = first; p < last; p++) {
2268 u32 nr = le32_to_cpu(*p);
2269 if (nr) {
2270 struct buffer_head *bh;
2271
2272 *p = 0;
2273 bh = sb_find_get_block(inode->i_sb, nr);
2274 ext3_forget(handle, 0, inode, bh, nr);
2275 }
2276 }
2277
2278 ext3_free_blocks(handle, inode, block_to_free, count);
2279}
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300static void ext3_free_data(handle_t *handle, struct inode *inode,
2301 struct buffer_head *this_bh,
2302 __le32 *first, __le32 *last)
2303{
2304 ext3_fsblk_t block_to_free = 0;
2305 unsigned long count = 0;
2306 __le32 *block_to_free_p = NULL;
2307
2308
2309 ext3_fsblk_t nr;
2310 __le32 *p;
2311
2312 int err;
2313
2314 if (this_bh) {
2315 BUFFER_TRACE(this_bh, "get_write_access");
2316 err = ext3_journal_get_write_access(handle, this_bh);
2317
2318
2319 if (err)
2320 return;
2321 }
2322
2323 for (p = first; p < last; p++) {
2324 nr = le32_to_cpu(*p);
2325 if (nr) {
2326
2327 if (count == 0) {
2328 block_to_free = nr;
2329 block_to_free_p = p;
2330 count = 1;
2331 } else if (nr == block_to_free + count) {
2332 count++;
2333 } else {
2334 ext3_clear_blocks(handle, inode, this_bh,
2335 block_to_free,
2336 count, block_to_free_p, p);
2337 block_to_free = nr;
2338 block_to_free_p = p;
2339 count = 1;
2340 }
2341 }
2342 }
2343
2344 if (count > 0)
2345 ext3_clear_blocks(handle, inode, this_bh, block_to_free,
2346 count, block_to_free_p, p);
2347
2348 if (this_bh) {
2349 BUFFER_TRACE(this_bh, "call ext3_journal_dirty_metadata");
2350
2351
2352
2353
2354
2355
2356
2357 if (bh2jh(this_bh))
2358 ext3_journal_dirty_metadata(handle, this_bh);
2359 else
2360 ext3_error(inode->i_sb, "ext3_free_data",
2361 "circular indirect block detected, "
2362 "inode=%lu, block=%llu",
2363 inode->i_ino,
2364 (unsigned long long)this_bh->b_blocknr);
2365 }
2366}
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381static void ext3_free_branches(handle_t *handle, struct inode *inode,
2382 struct buffer_head *parent_bh,
2383 __le32 *first, __le32 *last, int depth)
2384{
2385 ext3_fsblk_t nr;
2386 __le32 *p;
2387
2388 if (is_handle_aborted(handle))
2389 return;
2390
2391 if (depth--) {
2392 struct buffer_head *bh;
2393 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2394 p = last;
2395 while (--p >= first) {
2396 nr = le32_to_cpu(*p);
2397 if (!nr)
2398 continue;
2399
2400
2401 bh = sb_bread(inode->i_sb, nr);
2402
2403
2404
2405
2406
2407 if (!bh) {
2408 ext3_error(inode->i_sb, "ext3_free_branches",
2409 "Read failure, inode=%lu, block="E3FSBLK,
2410 inode->i_ino, nr);
2411 continue;
2412 }
2413
2414
2415 BUFFER_TRACE(bh, "free child branches");
2416 ext3_free_branches(handle, inode, bh,
2417 (__le32*)bh->b_data,
2418 (__le32*)bh->b_data + addr_per_block,
2419 depth);
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437 if (is_handle_aborted(handle))
2438 return;
2439 if (try_to_extend_transaction(handle, inode)) {
2440 ext3_mark_inode_dirty(handle, inode);
2441 truncate_restart_transaction(handle, inode);
2442 }
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2468
2469 ext3_free_blocks(handle, inode, nr, 1);
2470
2471 if (parent_bh) {
2472
2473
2474
2475
2476 BUFFER_TRACE(parent_bh, "get_write_access");
2477 if (!ext3_journal_get_write_access(handle,
2478 parent_bh)){
2479 *p = 0;
2480 BUFFER_TRACE(parent_bh,
2481 "call ext3_journal_dirty_metadata");
2482 ext3_journal_dirty_metadata(handle,
2483 parent_bh);
2484 }
2485 }
2486 }
2487 } else {
2488
2489 BUFFER_TRACE(parent_bh, "free data blocks");
2490 ext3_free_data(handle, inode, parent_bh, first, last);
2491 }
2492}
2493
2494int ext3_can_truncate(struct inode *inode)
2495{
2496 if (S_ISREG(inode->i_mode))
2497 return 1;
2498 if (S_ISDIR(inode->i_mode))
2499 return 1;
2500 if (S_ISLNK(inode->i_mode))
2501 return !ext3_inode_is_fast_symlink(inode);
2502 return 0;
2503}
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533void ext3_truncate(struct inode *inode)
2534{
2535 handle_t *handle;
2536 struct ext3_inode_info *ei = EXT3_I(inode);
2537 __le32 *i_data = ei->i_data;
2538 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb);
2539 int offsets[4];
2540 Indirect chain[4];
2541 Indirect *partial;
2542 __le32 nr = 0;
2543 int n;
2544 long last_block;
2545 unsigned blocksize = inode->i_sb->s_blocksize;
2546
2547 trace_ext3_truncate_enter(inode);
2548
2549 if (!ext3_can_truncate(inode))
2550 goto out_notrans;
2551
2552 if (inode->i_size == 0 && ext3_should_writeback_data(inode))
2553 ext3_set_inode_state(inode, EXT3_STATE_FLUSH_ON_CLOSE);
2554
2555 handle = start_transaction(inode);
2556 if (IS_ERR(handle))
2557 goto out_notrans;
2558
2559 last_block = (inode->i_size + blocksize-1)
2560 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb);
2561 n = ext3_block_to_path(inode, last_block, offsets, NULL);
2562 if (n == 0)
2563 goto out_stop;
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574 if (ext3_orphan_add(handle, inode))
2575 goto out_stop;
2576
2577
2578
2579
2580
2581
2582
2583
2584 ei->i_disksize = inode->i_size;
2585
2586
2587
2588
2589
2590 mutex_lock(&ei->truncate_mutex);
2591
2592 if (n == 1) {
2593 ext3_free_data(handle, inode, NULL, i_data+offsets[0],
2594 i_data + EXT3_NDIR_BLOCKS);
2595 goto do_indirects;
2596 }
2597
2598 partial = ext3_find_shared(inode, n, offsets, chain, &nr);
2599
2600 if (nr) {
2601 if (partial == chain) {
2602
2603 ext3_free_branches(handle, inode, NULL,
2604 &nr, &nr+1, (chain+n-1) - partial);
2605 *partial->p = 0;
2606
2607
2608
2609
2610 } else {
2611
2612 ext3_free_branches(handle, inode, partial->bh,
2613 partial->p,
2614 partial->p+1, (chain+n-1) - partial);
2615 }
2616 }
2617
2618 while (partial > chain) {
2619 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2620 (__le32*)partial->bh->b_data+addr_per_block,
2621 (chain+n-1) - partial);
2622 BUFFER_TRACE(partial->bh, "call brelse");
2623 brelse (partial->bh);
2624 partial--;
2625 }
2626do_indirects:
2627
2628 switch (offsets[0]) {
2629 default:
2630 nr = i_data[EXT3_IND_BLOCK];
2631 if (nr) {
2632 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
2633 i_data[EXT3_IND_BLOCK] = 0;
2634 }
2635 case EXT3_IND_BLOCK:
2636 nr = i_data[EXT3_DIND_BLOCK];
2637 if (nr) {
2638 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
2639 i_data[EXT3_DIND_BLOCK] = 0;
2640 }
2641 case EXT3_DIND_BLOCK:
2642 nr = i_data[EXT3_TIND_BLOCK];
2643 if (nr) {
2644 ext3_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
2645 i_data[EXT3_TIND_BLOCK] = 0;
2646 }
2647 case EXT3_TIND_BLOCK:
2648 ;
2649 }
2650
2651 ext3_discard_reservation(inode);
2652
2653 mutex_unlock(&ei->truncate_mutex);
2654 inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
2655 ext3_mark_inode_dirty(handle, inode);
2656
2657
2658
2659
2660
2661 if (IS_SYNC(inode))
2662 handle->h_sync = 1;
2663out_stop:
2664
2665
2666
2667
2668
2669
2670
2671 if (inode->i_nlink)
2672 ext3_orphan_del(handle, inode);
2673
2674 ext3_journal_stop(handle);
2675 trace_ext3_truncate_exit(inode);
2676 return;
2677out_notrans:
2678
2679
2680
2681
2682 if (inode->i_nlink)
2683 ext3_orphan_del(NULL, inode);
2684 trace_ext3_truncate_exit(inode);
2685}
2686
2687static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
2688 unsigned long ino, struct ext3_iloc *iloc)
2689{
2690 unsigned long block_group;
2691 unsigned long offset;
2692 ext3_fsblk_t block;
2693 struct ext3_group_desc *gdp;
2694
2695 if (!ext3_valid_inum(sb, ino)) {
2696
2697
2698
2699
2700
2701 return 0;
2702 }
2703
2704 block_group = (ino - 1) / EXT3_INODES_PER_GROUP(sb);
2705 gdp = ext3_get_group_desc(sb, block_group, NULL);
2706 if (!gdp)
2707 return 0;
2708
2709
2710
2711 offset = ((ino - 1) % EXT3_INODES_PER_GROUP(sb)) *
2712 EXT3_INODE_SIZE(sb);
2713 block = le32_to_cpu(gdp->bg_inode_table) +
2714 (offset >> EXT3_BLOCK_SIZE_BITS(sb));
2715
2716 iloc->block_group = block_group;
2717 iloc->offset = offset & (EXT3_BLOCK_SIZE(sb) - 1);
2718 return block;
2719}
2720
2721
2722
2723
2724
2725
2726
2727static int __ext3_get_inode_loc(struct inode *inode,
2728 struct ext3_iloc *iloc, int in_mem)
2729{
2730 ext3_fsblk_t block;
2731 struct buffer_head *bh;
2732
2733 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
2734 if (!block)
2735 return -EIO;
2736
2737 bh = sb_getblk(inode->i_sb, block);
2738 if (unlikely(!bh)) {
2739 ext3_error (inode->i_sb, "ext3_get_inode_loc",
2740 "unable to read inode block - "
2741 "inode=%lu, block="E3FSBLK,
2742 inode->i_ino, block);
2743 return -ENOMEM;
2744 }
2745 if (!buffer_uptodate(bh)) {
2746 lock_buffer(bh);
2747
2748
2749
2750
2751
2752
2753
2754 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
2755 set_buffer_uptodate(bh);
2756
2757 if (buffer_uptodate(bh)) {
2758
2759 unlock_buffer(bh);
2760 goto has_buffer;
2761 }
2762
2763
2764
2765
2766
2767
2768 if (in_mem) {
2769 struct buffer_head *bitmap_bh;
2770 struct ext3_group_desc *desc;
2771 int inodes_per_buffer;
2772 int inode_offset, i;
2773 int block_group;
2774 int start;
2775
2776 block_group = (inode->i_ino - 1) /
2777 EXT3_INODES_PER_GROUP(inode->i_sb);
2778 inodes_per_buffer = bh->b_size /
2779 EXT3_INODE_SIZE(inode->i_sb);
2780 inode_offset = ((inode->i_ino - 1) %
2781 EXT3_INODES_PER_GROUP(inode->i_sb));
2782 start = inode_offset & ~(inodes_per_buffer - 1);
2783
2784
2785 desc = ext3_get_group_desc(inode->i_sb,
2786 block_group, NULL);
2787 if (!desc)
2788 goto make_io;
2789
2790 bitmap_bh = sb_getblk(inode->i_sb,
2791 le32_to_cpu(desc->bg_inode_bitmap));
2792 if (unlikely(!bitmap_bh))
2793 goto make_io;
2794
2795
2796
2797
2798
2799
2800 if (!buffer_uptodate(bitmap_bh)) {
2801 brelse(bitmap_bh);
2802 goto make_io;
2803 }
2804 for (i = start; i < start + inodes_per_buffer; i++) {
2805 if (i == inode_offset)
2806 continue;
2807 if (ext3_test_bit(i, bitmap_bh->b_data))
2808 break;
2809 }
2810 brelse(bitmap_bh);
2811 if (i == start + inodes_per_buffer) {
2812
2813 memset(bh->b_data, 0, bh->b_size);
2814 set_buffer_uptodate(bh);
2815 unlock_buffer(bh);
2816 goto has_buffer;
2817 }
2818 }
2819
2820make_io:
2821
2822
2823
2824
2825
2826 trace_ext3_load_inode(inode);
2827 get_bh(bh);
2828 bh->b_end_io = end_buffer_read_sync;
2829 submit_bh(READ | REQ_META | REQ_PRIO, bh);
2830 wait_on_buffer(bh);
2831 if (!buffer_uptodate(bh)) {
2832 ext3_error(inode->i_sb, "ext3_get_inode_loc",
2833 "unable to read inode block - "
2834 "inode=%lu, block="E3FSBLK,
2835 inode->i_ino, block);
2836 brelse(bh);
2837 return -EIO;
2838 }
2839 }
2840has_buffer:
2841 iloc->bh = bh;
2842 return 0;
2843}
2844
2845int ext3_get_inode_loc(struct inode *inode, struct ext3_iloc *iloc)
2846{
2847
2848 return __ext3_get_inode_loc(inode, iloc,
2849 !ext3_test_inode_state(inode, EXT3_STATE_XATTR));
2850}
2851
2852void ext3_set_inode_flags(struct inode *inode)
2853{
2854 unsigned int flags = EXT3_I(inode)->i_flags;
2855
2856 inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
2857 if (flags & EXT3_SYNC_FL)
2858 inode->i_flags |= S_SYNC;
2859 if (flags & EXT3_APPEND_FL)
2860 inode->i_flags |= S_APPEND;
2861 if (flags & EXT3_IMMUTABLE_FL)
2862 inode->i_flags |= S_IMMUTABLE;
2863 if (flags & EXT3_NOATIME_FL)
2864 inode->i_flags |= S_NOATIME;
2865 if (flags & EXT3_DIRSYNC_FL)
2866 inode->i_flags |= S_DIRSYNC;
2867}
2868
2869
2870void ext3_get_inode_flags(struct ext3_inode_info *ei)
2871{
2872 unsigned int flags = ei->vfs_inode.i_flags;
2873
2874 ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
2875 EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
2876 if (flags & S_SYNC)
2877 ei->i_flags |= EXT3_SYNC_FL;
2878 if (flags & S_APPEND)
2879 ei->i_flags |= EXT3_APPEND_FL;
2880 if (flags & S_IMMUTABLE)
2881 ei->i_flags |= EXT3_IMMUTABLE_FL;
2882 if (flags & S_NOATIME)
2883 ei->i_flags |= EXT3_NOATIME_FL;
2884 if (flags & S_DIRSYNC)
2885 ei->i_flags |= EXT3_DIRSYNC_FL;
2886}
2887
2888struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
2889{
2890 struct ext3_iloc iloc;
2891 struct ext3_inode *raw_inode;
2892 struct ext3_inode_info *ei;
2893 struct buffer_head *bh;
2894 struct inode *inode;
2895 journal_t *journal = EXT3_SB(sb)->s_journal;
2896 transaction_t *transaction;
2897 long ret;
2898 int block;
2899 uid_t i_uid;
2900 gid_t i_gid;
2901
2902 inode = iget_locked(sb, ino);
2903 if (!inode)
2904 return ERR_PTR(-ENOMEM);
2905 if (!(inode->i_state & I_NEW))
2906 return inode;
2907
2908 ei = EXT3_I(inode);
2909 ei->i_block_alloc_info = NULL;
2910
2911 ret = __ext3_get_inode_loc(inode, &iloc, 0);
2912 if (ret < 0)
2913 goto bad_inode;
2914 bh = iloc.bh;
2915 raw_inode = ext3_raw_inode(&iloc);
2916 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
2917 i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
2918 i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
2919 if(!(test_opt (inode->i_sb, NO_UID32))) {
2920 i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
2921 i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
2922 }
2923 i_uid_write(inode, i_uid);
2924 i_gid_write(inode, i_gid);
2925 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
2926 inode->i_size = le32_to_cpu(raw_inode->i_size);
2927 inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
2928 inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
2929 inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
2930 inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
2931
2932 ei->i_state_flags = 0;
2933 ei->i_dir_start_lookup = 0;
2934 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
2935
2936
2937
2938
2939
2940 if (inode->i_nlink == 0) {
2941 if (inode->i_mode == 0 ||
2942 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) {
2943
2944 brelse (bh);
2945 ret = -ESTALE;
2946 goto bad_inode;
2947 }
2948
2949
2950
2951
2952 }
2953 inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
2954 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
2955#ifdef EXT3_FRAGMENTS
2956 ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
2957 ei->i_frag_no = raw_inode->i_frag;
2958 ei->i_frag_size = raw_inode->i_fsize;
2959#endif
2960 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
2961 if (!S_ISREG(inode->i_mode)) {
2962 ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
2963 } else {
2964 inode->i_size |=
2965 ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
2966 }
2967 ei->i_disksize = inode->i_size;
2968 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
2969 ei->i_block_group = iloc.block_group;
2970
2971
2972
2973
2974 for (block = 0; block < EXT3_N_BLOCKS; block++)
2975 ei->i_data[block] = raw_inode->i_block[block];
2976 INIT_LIST_HEAD(&ei->i_orphan);
2977
2978
2979
2980
2981
2982
2983
2984
2985 if (journal) {
2986 tid_t tid;
2987
2988 spin_lock(&journal->j_state_lock);
2989 if (journal->j_running_transaction)
2990 transaction = journal->j_running_transaction;
2991 else
2992 transaction = journal->j_committing_transaction;
2993 if (transaction)
2994 tid = transaction->t_tid;
2995 else
2996 tid = journal->j_commit_sequence;
2997 spin_unlock(&journal->j_state_lock);
2998 atomic_set(&ei->i_sync_tid, tid);
2999 atomic_set(&ei->i_datasync_tid, tid);
3000 }
3001
3002 if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 &&
3003 EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) {
3004
3005
3006
3007
3008
3009 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3010 if (EXT3_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3011 EXT3_INODE_SIZE(inode->i_sb)) {
3012 brelse (bh);
3013 ret = -EIO;
3014 goto bad_inode;
3015 }
3016 if (ei->i_extra_isize == 0) {
3017
3018 ei->i_extra_isize = sizeof(struct ext3_inode) -
3019 EXT3_GOOD_OLD_INODE_SIZE;
3020 } else {
3021 __le32 *magic = (void *)raw_inode +
3022 EXT3_GOOD_OLD_INODE_SIZE +
3023 ei->i_extra_isize;
3024 if (*magic == cpu_to_le32(EXT3_XATTR_MAGIC))
3025 ext3_set_inode_state(inode, EXT3_STATE_XATTR);
3026 }
3027 } else
3028 ei->i_extra_isize = 0;
3029
3030 if (S_ISREG(inode->i_mode)) {
3031 inode->i_op = &ext3_file_inode_operations;
3032 inode->i_fop = &ext3_file_operations;
3033 ext3_set_aops(inode);
3034 } else if (S_ISDIR(inode->i_mode)) {
3035 inode->i_op = &ext3_dir_inode_operations;
3036 inode->i_fop = &ext3_dir_operations;
3037 } else if (S_ISLNK(inode->i_mode)) {
3038 if (ext3_inode_is_fast_symlink(inode)) {
3039 inode->i_op = &ext3_fast_symlink_inode_operations;
3040 nd_terminate_link(ei->i_data, inode->i_size,
3041 sizeof(ei->i_data) - 1);
3042 } else {
3043 inode->i_op = &ext3_symlink_inode_operations;
3044 ext3_set_aops(inode);
3045 }
3046 } else {
3047 inode->i_op = &ext3_special_inode_operations;
3048 if (raw_inode->i_block[0])
3049 init_special_inode(inode, inode->i_mode,
3050 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
3051 else
3052 init_special_inode(inode, inode->i_mode,
3053 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3054 }
3055 brelse (iloc.bh);
3056 ext3_set_inode_flags(inode);
3057 unlock_new_inode(inode);
3058 return inode;
3059
3060bad_inode:
3061 iget_failed(inode);
3062 return ERR_PTR(ret);
3063}
3064
3065
3066
3067
3068
3069
3070
3071
3072static int ext3_do_update_inode(handle_t *handle,
3073 struct inode *inode,
3074 struct ext3_iloc *iloc)
3075{
3076 struct ext3_inode *raw_inode = ext3_raw_inode(iloc);
3077 struct ext3_inode_info *ei = EXT3_I(inode);
3078 struct buffer_head *bh = iloc->bh;
3079 int err = 0, rc, block;
3080 int need_datasync = 0;
3081 __le32 disksize;
3082 uid_t i_uid;
3083 gid_t i_gid;
3084
3085again:
3086
3087 lock_buffer(bh);
3088
3089
3090
3091 if (ext3_test_inode_state(inode, EXT3_STATE_NEW))
3092 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
3093
3094 ext3_get_inode_flags(ei);
3095 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
3096 i_uid = i_uid_read(inode);
3097 i_gid = i_gid_read(inode);
3098 if(!(test_opt(inode->i_sb, NO_UID32))) {
3099 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
3100 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
3101
3102
3103
3104
3105 if(!ei->i_dtime) {
3106 raw_inode->i_uid_high =
3107 cpu_to_le16(high_16_bits(i_uid));
3108 raw_inode->i_gid_high =
3109 cpu_to_le16(high_16_bits(i_gid));
3110 } else {
3111 raw_inode->i_uid_high = 0;
3112 raw_inode->i_gid_high = 0;
3113 }
3114 } else {
3115 raw_inode->i_uid_low =
3116 cpu_to_le16(fs_high2lowuid(i_uid));
3117 raw_inode->i_gid_low =
3118 cpu_to_le16(fs_high2lowgid(i_gid));
3119 raw_inode->i_uid_high = 0;
3120 raw_inode->i_gid_high = 0;
3121 }
3122 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
3123 disksize = cpu_to_le32(ei->i_disksize);
3124 if (disksize != raw_inode->i_size) {
3125 need_datasync = 1;
3126 raw_inode->i_size = disksize;
3127 }
3128 raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
3129 raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
3130 raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
3131 raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
3132 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
3133 raw_inode->i_flags = cpu_to_le32(ei->i_flags);
3134#ifdef EXT3_FRAGMENTS
3135 raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
3136 raw_inode->i_frag = ei->i_frag_no;
3137 raw_inode->i_fsize = ei->i_frag_size;
3138#endif
3139 raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
3140 if (!S_ISREG(inode->i_mode)) {
3141 raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
3142 } else {
3143 disksize = cpu_to_le32(ei->i_disksize >> 32);
3144 if (disksize != raw_inode->i_size_high) {
3145 raw_inode->i_size_high = disksize;
3146 need_datasync = 1;
3147 }
3148 if (ei->i_disksize > 0x7fffffffULL) {
3149 struct super_block *sb = inode->i_sb;
3150 if (!EXT3_HAS_RO_COMPAT_FEATURE(sb,
3151 EXT3_FEATURE_RO_COMPAT_LARGE_FILE) ||
3152 EXT3_SB(sb)->s_es->s_rev_level ==
3153 cpu_to_le32(EXT3_GOOD_OLD_REV)) {
3154
3155
3156
3157 unlock_buffer(bh);
3158 err = ext3_journal_get_write_access(handle,
3159 EXT3_SB(sb)->s_sbh);
3160 if (err)
3161 goto out_brelse;
3162
3163 ext3_update_dynamic_rev(sb);
3164 EXT3_SET_RO_COMPAT_FEATURE(sb,
3165 EXT3_FEATURE_RO_COMPAT_LARGE_FILE);
3166 handle->h_sync = 1;
3167 err = ext3_journal_dirty_metadata(handle,
3168 EXT3_SB(sb)->s_sbh);
3169
3170 goto again;
3171 }
3172 }
3173 }
3174 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
3175 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
3176 if (old_valid_dev(inode->i_rdev)) {
3177 raw_inode->i_block[0] =
3178 cpu_to_le32(old_encode_dev(inode->i_rdev));
3179 raw_inode->i_block[1] = 0;
3180 } else {
3181 raw_inode->i_block[0] = 0;
3182 raw_inode->i_block[1] =
3183 cpu_to_le32(new_encode_dev(inode->i_rdev));
3184 raw_inode->i_block[2] = 0;
3185 }
3186 } else for (block = 0; block < EXT3_N_BLOCKS; block++)
3187 raw_inode->i_block[block] = ei->i_data[block];
3188
3189 if (ei->i_extra_isize)
3190 raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
3191
3192 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
3193 unlock_buffer(bh);
3194 rc = ext3_journal_dirty_metadata(handle, bh);
3195 if (!err)
3196 err = rc;
3197 ext3_clear_inode_state(inode, EXT3_STATE_NEW);
3198
3199 atomic_set(&ei->i_sync_tid, handle->h_transaction->t_tid);
3200 if (need_datasync)
3201 atomic_set(&ei->i_datasync_tid, handle->h_transaction->t_tid);
3202out_brelse:
3203 brelse (bh);
3204 ext3_std_error(inode->i_sb, err);
3205 return err;
3206}
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243int ext3_write_inode(struct inode *inode, struct writeback_control *wbc)
3244{
3245 if (current->flags & PF_MEMALLOC)
3246 return 0;
3247
3248 if (ext3_journal_current_handle()) {
3249 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
3250 dump_stack();
3251 return -EIO;
3252 }
3253
3254 if (wbc->sync_mode != WB_SYNC_ALL)
3255 return 0;
3256
3257 return ext3_force_commit(inode->i_sb);
3258}
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277int ext3_setattr(struct dentry *dentry, struct iattr *attr)
3278{
3279 struct inode *inode = dentry->d_inode;
3280 int error, rc = 0;
3281 const unsigned int ia_valid = attr->ia_valid;
3282
3283 error = inode_change_ok(inode, attr);
3284 if (error)
3285 return error;
3286
3287 if (is_quota_modification(inode, attr))
3288 dquot_initialize(inode);
3289 if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
3290 (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
3291 handle_t *handle;
3292
3293
3294
3295 handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
3296 EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3);
3297 if (IS_ERR(handle)) {
3298 error = PTR_ERR(handle);
3299 goto err_out;
3300 }
3301 error = dquot_transfer(inode, attr);
3302 if (error) {
3303 ext3_journal_stop(handle);
3304 return error;
3305 }
3306
3307
3308 if (attr->ia_valid & ATTR_UID)
3309 inode->i_uid = attr->ia_uid;
3310 if (attr->ia_valid & ATTR_GID)
3311 inode->i_gid = attr->ia_gid;
3312 error = ext3_mark_inode_dirty(handle, inode);
3313 ext3_journal_stop(handle);
3314 }
3315
3316 if (attr->ia_valid & ATTR_SIZE)
3317 inode_dio_wait(inode);
3318
3319 if (S_ISREG(inode->i_mode) &&
3320 attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
3321 handle_t *handle;
3322
3323 handle = ext3_journal_start(inode, 3);
3324 if (IS_ERR(handle)) {
3325 error = PTR_ERR(handle);
3326 goto err_out;
3327 }
3328
3329 error = ext3_orphan_add(handle, inode);
3330 if (error) {
3331 ext3_journal_stop(handle);
3332 goto err_out;
3333 }
3334 EXT3_I(inode)->i_disksize = attr->ia_size;
3335 error = ext3_mark_inode_dirty(handle, inode);
3336 ext3_journal_stop(handle);
3337 if (error) {
3338
3339 ext3_orphan_del(NULL, inode);
3340 goto err_out;
3341 }
3342 rc = ext3_block_truncate_page(inode, attr->ia_size);
3343 if (rc) {
3344
3345 handle = ext3_journal_start(inode, 3);
3346 if (IS_ERR(handle)) {
3347 ext3_orphan_del(NULL, inode);
3348 goto err_out;
3349 }
3350 ext3_orphan_del(handle, inode);
3351 ext3_journal_stop(handle);
3352 goto err_out;
3353 }
3354 }
3355
3356 if ((attr->ia_valid & ATTR_SIZE) &&
3357 attr->ia_size != i_size_read(inode)) {
3358 truncate_setsize(inode, attr->ia_size);
3359 ext3_truncate(inode);
3360 }
3361
3362 setattr_copy(inode, attr);
3363 mark_inode_dirty(inode);
3364
3365 if (ia_valid & ATTR_MODE)
3366 rc = ext3_acl_chmod(inode);
3367
3368err_out:
3369 ext3_std_error(inode->i_sb, error);
3370 if (!error)
3371 error = rc;
3372 return error;
3373}
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403static int ext3_writepage_trans_blocks(struct inode *inode)
3404{
3405 int bpp = ext3_journal_blocks_per_page(inode);
3406 int indirects = (EXT3_NDIR_BLOCKS % bpp) ? 5 : 3;
3407 int ret;
3408
3409 if (ext3_should_journal_data(inode))
3410 ret = 3 * (bpp + indirects) + 2;
3411 else
3412 ret = 2 * (bpp + indirects) + indirects + 2;
3413
3414#ifdef CONFIG_QUOTA
3415
3416
3417 ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
3418#endif
3419
3420 return ret;
3421}
3422
3423
3424
3425
3426
3427int ext3_mark_iloc_dirty(handle_t *handle,
3428 struct inode *inode, struct ext3_iloc *iloc)
3429{
3430 int err = 0;
3431
3432
3433 get_bh(iloc->bh);
3434
3435
3436 err = ext3_do_update_inode(handle, inode, iloc);
3437 put_bh(iloc->bh);
3438 return err;
3439}
3440
3441
3442
3443
3444
3445
3446int
3447ext3_reserve_inode_write(handle_t *handle, struct inode *inode,
3448 struct ext3_iloc *iloc)
3449{
3450 int err = 0;
3451 if (handle) {
3452 err = ext3_get_inode_loc(inode, iloc);
3453 if (!err) {
3454 BUFFER_TRACE(iloc->bh, "get_write_access");
3455 err = ext3_journal_get_write_access(handle, iloc->bh);
3456 if (err) {
3457 brelse(iloc->bh);
3458 iloc->bh = NULL;
3459 }
3460 }
3461 }
3462 ext3_std_error(inode->i_sb, err);
3463 return err;
3464}
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479int ext3_mark_inode_dirty(handle_t *handle, struct inode *inode)
3480{
3481 struct ext3_iloc iloc;
3482 int err;
3483
3484 might_sleep();
3485 trace_ext3_mark_inode_dirty(inode, _RET_IP_);
3486 err = ext3_reserve_inode_write(handle, inode, &iloc);
3487 if (!err)
3488 err = ext3_mark_iloc_dirty(handle, inode, &iloc);
3489 return err;
3490}
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506void ext3_dirty_inode(struct inode *inode, int flags)
3507{
3508 handle_t *current_handle = ext3_journal_current_handle();
3509 handle_t *handle;
3510
3511 handle = ext3_journal_start(inode, 2);
3512 if (IS_ERR(handle))
3513 goto out;
3514 if (current_handle &&
3515 current_handle->h_transaction != handle->h_transaction) {
3516
3517 printk(KERN_EMERG "%s: transactions do not match!\n",
3518 __func__);
3519 } else {
3520 jbd_debug(5, "marking dirty. outer handle=%p\n",
3521 current_handle);
3522 ext3_mark_inode_dirty(handle, inode);
3523 }
3524 ext3_journal_stop(handle);
3525out:
3526 return;
3527}
3528
3529#if 0
3530
3531
3532
3533
3534
3535
3536
3537static int ext3_pin_inode(handle_t *handle, struct inode *inode)
3538{
3539 struct ext3_iloc iloc;
3540
3541 int err = 0;
3542 if (handle) {
3543 err = ext3_get_inode_loc(inode, &iloc);
3544 if (!err) {
3545 BUFFER_TRACE(iloc.bh, "get_write_access");
3546 err = journal_get_write_access(handle, iloc.bh);
3547 if (!err)
3548 err = ext3_journal_dirty_metadata(handle,
3549 iloc.bh);
3550 brelse(iloc.bh);
3551 }
3552 }
3553 ext3_std_error(inode->i_sb, err);
3554 return err;
3555}
3556#endif
3557
3558int ext3_change_inode_journal_flag(struct inode *inode, int val)
3559{
3560 journal_t *journal;
3561 handle_t *handle;
3562 int err;
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574 journal = EXT3_JOURNAL(inode);
3575 if (is_journal_aborted(journal))
3576 return -EROFS;
3577
3578 journal_lock_updates(journal);
3579 journal_flush(journal);
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589 if (val)
3590 EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
3591 else
3592 EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
3593 ext3_set_aops(inode);
3594
3595 journal_unlock_updates(journal);
3596
3597
3598
3599 handle = ext3_journal_start(inode, 1);
3600 if (IS_ERR(handle))
3601 return PTR_ERR(handle);
3602
3603 err = ext3_mark_inode_dirty(handle, inode);
3604 handle->h_sync = 1;
3605 ext3_journal_stop(handle);
3606 ext3_std_error(inode->i_sb, err);
3607
3608 return err;
3609}
3610