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