1
2
3
4
5#include <linux/time.h>
6#include <linux/fs.h>
7#include <linux/reiserfs_fs.h>
8#include <linux/reiserfs_acl.h>
9#include <linux/reiserfs_xattr.h>
10#include <linux/exportfs.h>
11#include <linux/pagemap.h>
12#include <linux/highmem.h>
13#include <linux/slab.h>
14#include <asm/uaccess.h>
15#include <asm/unaligned.h>
16#include <linux/buffer_head.h>
17#include <linux/mpage.h>
18#include <linux/writeback.h>
19#include <linux/quotaops.h>
20#include <linux/swap.h>
21
22int reiserfs_commit_write(struct file *f, struct page *page,
23 unsigned from, unsigned to);
24
25void reiserfs_evict_inode(struct inode *inode)
26{
27
28 int jbegin_count =
29 JOURNAL_PER_BALANCE_CNT * 2 +
30 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
31 struct reiserfs_transaction_handle th;
32 int depth;
33 int err;
34
35 if (!inode->i_nlink && !is_bad_inode(inode))
36 dquot_initialize(inode);
37
38 truncate_inode_pages(&inode->i_data, 0);
39 if (inode->i_nlink)
40 goto no_delete;
41
42 depth = reiserfs_write_lock_once(inode->i_sb);
43
44
45 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) {
46 reiserfs_delete_xattrs(inode);
47
48 if (journal_begin(&th, inode->i_sb, jbegin_count))
49 goto out;
50 reiserfs_update_inode_transaction(inode);
51
52 reiserfs_discard_prealloc(&th, inode);
53
54 err = reiserfs_delete_object(&th, inode);
55
56
57
58
59 if (!err)
60 dquot_free_inode(inode);
61
62 if (journal_end(&th, inode->i_sb, jbegin_count))
63 goto out;
64
65
66
67
68 if (err)
69 goto out;
70
71
72 remove_save_link(inode, 0 );
73
74 } else {
75
76 ;
77 }
78 out:
79 end_writeback(inode);
80 dquot_drop(inode);
81 inode->i_blocks = 0;
82 reiserfs_write_unlock_once(inode->i_sb, depth);
83 return;
84
85no_delete:
86 end_writeback(inode);
87 dquot_drop(inode);
88}
89
90static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
91 __u32 objectid, loff_t offset, int type, int length)
92{
93 key->version = version;
94
95 key->on_disk_key.k_dir_id = dirid;
96 key->on_disk_key.k_objectid = objectid;
97 set_cpu_key_k_offset(key, offset);
98 set_cpu_key_k_type(key, type);
99 key->key_length = length;
100}
101
102
103
104void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
105 int type, int length)
106{
107 _make_cpu_key(key, get_inode_item_key_version(inode),
108 le32_to_cpu(INODE_PKEY(inode)->k_dir_id),
109 le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,
110 length);
111}
112
113
114
115
116inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
117 int version,
118 loff_t offset, int type, int length,
119 int entry_count )
120{
121 if (key) {
122 ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);
123 ih->ih_key.k_objectid =
124 cpu_to_le32(key->on_disk_key.k_objectid);
125 }
126 put_ih_version(ih, version);
127 set_le_ih_k_offset(ih, offset);
128 set_le_ih_k_type(ih, type);
129 put_ih_item_len(ih, length);
130
131
132
133 put_ih_entry_count(ih, entry_count);
134}
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168static inline void fix_tail_page_for_writing(struct page *page)
169{
170 struct buffer_head *head, *next, *bh;
171
172 if (page && page_has_buffers(page)) {
173 head = page_buffers(page);
174 bh = head;
175 do {
176 next = bh->b_this_page;
177 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
178 reiserfs_unmap_buffer(bh);
179 }
180 bh = next;
181 } while (bh != head);
182 }
183}
184
185
186
187static inline int allocation_needed(int retval, b_blocknr_t allocated,
188 struct item_head *ih,
189 __le32 * item, int pos_in_item)
190{
191 if (allocated)
192 return 0;
193 if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
194 get_block_num(item, pos_in_item))
195 return 0;
196 return 1;
197}
198
199static inline int indirect_item_found(int retval, struct item_head *ih)
200{
201 return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
202}
203
204static inline void set_block_dev_mapped(struct buffer_head *bh,
205 b_blocknr_t block, struct inode *inode)
206{
207 map_bh(bh, inode->i_sb, block);
208}
209
210
211
212
213
214static int file_capable(struct inode *inode, sector_t block)
215{
216 if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 ||
217 block < (1 << (31 - inode->i_sb->s_blocksize_bits)))
218 return 1;
219
220 return 0;
221}
222
223static int restart_transaction(struct reiserfs_transaction_handle *th,
224 struct inode *inode, struct treepath *path)
225{
226 struct super_block *s = th->t_super;
227 int len = th->t_blocks_allocated;
228 int err;
229
230 BUG_ON(!th->t_trans_id);
231 BUG_ON(!th->t_refcount);
232
233 pathrelse(path);
234
235
236 if (th->t_refcount > 1) {
237 return 0;
238 }
239 reiserfs_update_sd(th, inode);
240 err = journal_end(th, s, len);
241 if (!err) {
242 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
243 if (!err)
244 reiserfs_update_inode_transaction(inode);
245 }
246 return err;
247}
248
249
250
251
252
253
254
255
256
257static int _get_block_create_0(struct inode *inode, sector_t block,
258 struct buffer_head *bh_result, int args)
259{
260 INITIALIZE_PATH(path);
261 struct cpu_key key;
262 struct buffer_head *bh;
263 struct item_head *ih, tmp_ih;
264 b_blocknr_t blocknr;
265 char *p = NULL;
266 int chars;
267 int ret;
268 int result;
269 int done = 0;
270 unsigned long offset;
271
272
273 make_cpu_key(&key, inode,
274 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
275 3);
276
277 result = search_for_position_by_key(inode->i_sb, &key, &path);
278 if (result != POSITION_FOUND) {
279 pathrelse(&path);
280 if (p)
281 kunmap(bh_result->b_page);
282 if (result == IO_ERROR)
283 return -EIO;
284
285
286 if ((args & GET_BLOCK_NO_HOLE)
287 && !PageUptodate(bh_result->b_page)) {
288 return -ENOENT;
289 }
290 return 0;
291 }
292
293 bh = get_last_bh(&path);
294 ih = get_ih(&path);
295 if (is_indirect_le_ih(ih)) {
296 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
297
298
299
300
301 blocknr = get_block_num(ind_item, path.pos_in_item);
302 ret = 0;
303 if (blocknr) {
304 map_bh(bh_result, inode->i_sb, blocknr);
305 if (path.pos_in_item ==
306 ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
307 set_buffer_boundary(bh_result);
308 }
309 } else
310
311
312 if ((args & GET_BLOCK_NO_HOLE)
313 && !PageUptodate(bh_result->b_page)) {
314 ret = -ENOENT;
315 }
316
317 pathrelse(&path);
318 if (p)
319 kunmap(bh_result->b_page);
320 return ret;
321 }
322
323 if (!(args & GET_BLOCK_READ_DIRECT)) {
324
325
326 pathrelse(&path);
327 if (p)
328 kunmap(bh_result->b_page);
329 return -ENOENT;
330 }
331
332
333
334
335
336 if (buffer_uptodate(bh_result)) {
337 goto finished;
338 } else
339
340
341
342
343
344
345 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
346 set_buffer_uptodate(bh_result);
347 goto finished;
348 }
349
350 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
351 copy_item_head(&tmp_ih, ih);
352
353
354
355
356
357
358 if (!p)
359 p = (char *)kmap(bh_result->b_page);
360
361 p += offset;
362 memset(p, 0, inode->i_sb->s_blocksize);
363 do {
364 if (!is_direct_le_ih(ih)) {
365 BUG();
366 }
367
368
369
370
371
372 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
373 break;
374 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
375 chars =
376 inode->i_size - (le_ih_k_offset(ih) - 1) -
377 path.pos_in_item;
378 done = 1;
379 } else {
380 chars = ih_item_len(ih) - path.pos_in_item;
381 }
382 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
383
384 if (done)
385 break;
386
387 p += chars;
388
389 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
390
391
392
393
394 break;
395
396
397 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
398 result = search_for_position_by_key(inode->i_sb, &key, &path);
399 if (result != POSITION_FOUND)
400
401 break;
402 bh = get_last_bh(&path);
403 ih = get_ih(&path);
404 } while (1);
405
406 flush_dcache_page(bh_result->b_page);
407 kunmap(bh_result->b_page);
408
409 finished:
410 pathrelse(&path);
411
412 if (result == IO_ERROR)
413 return -EIO;
414
415
416
417
418 map_bh(bh_result, inode->i_sb, 0);
419 set_buffer_uptodate(bh_result);
420 return 0;
421}
422
423
424
425static int reiserfs_bmap(struct inode *inode, sector_t block,
426 struct buffer_head *bh_result, int create)
427{
428 if (!file_capable(inode, block))
429 return -EFBIG;
430
431 reiserfs_write_lock(inode->i_sb);
432
433 _get_block_create_0(inode, block, bh_result, 0);
434 reiserfs_write_unlock(inode->i_sb);
435 return 0;
436}
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
456 struct buffer_head *bh_result,
457 int create)
458{
459 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
460}
461
462
463
464static int reiserfs_get_blocks_direct_io(struct inode *inode,
465 sector_t iblock,
466 struct buffer_head *bh_result,
467 int create)
468{
469 int ret;
470
471 bh_result->b_page = NULL;
472
473
474
475
476 bh_result->b_size = (1 << inode->i_blkbits);
477
478 ret = reiserfs_get_block(inode, iblock, bh_result,
479 create | GET_BLOCK_NO_DANGLE);
480 if (ret)
481 goto out;
482
483
484 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
485
486
487
488 clear_buffer_mapped(bh_result);
489 ret = -EINVAL;
490 }
491
492
493 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
494 int err;
495
496 reiserfs_write_lock(inode->i_sb);
497
498 err = reiserfs_commit_for_inode(inode);
499 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
500
501 reiserfs_write_unlock(inode->i_sb);
502
503 if (err < 0)
504 ret = err;
505 }
506 out:
507 return ret;
508}
509
510
511
512
513
514
515
516
517
518
519
520static int convert_tail_for_hole(struct inode *inode,
521 struct buffer_head *bh_result,
522 loff_t tail_offset)
523{
524 unsigned long index;
525 unsigned long tail_end;
526 unsigned long tail_start;
527 struct page *tail_page;
528 struct page *hole_page = bh_result->b_page;
529 int retval = 0;
530
531 if ((tail_offset & (bh_result->b_size - 1)) != 1)
532 return -EIO;
533
534
535 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
536 tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
537
538 index = tail_offset >> PAGE_CACHE_SHIFT;
539
540
541
542 if (!hole_page || index != hole_page->index) {
543 tail_page = grab_cache_page(inode->i_mapping, index);
544 retval = -ENOMEM;
545 if (!tail_page) {
546 goto out;
547 }
548 } else {
549 tail_page = hole_page;
550 }
551
552
553
554
555
556
557
558
559
560
561 fix_tail_page_for_writing(tail_page);
562 retval = __reiserfs_write_begin(tail_page, tail_start,
563 tail_end - tail_start);
564 if (retval)
565 goto unlock;
566
567
568 flush_dcache_page(tail_page);
569
570 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
571
572 unlock:
573 if (tail_page != hole_page) {
574 unlock_page(tail_page);
575 page_cache_release(tail_page);
576 }
577 out:
578 return retval;
579}
580
581static inline int _allocate_block(struct reiserfs_transaction_handle *th,
582 sector_t block,
583 struct inode *inode,
584 b_blocknr_t * allocated_block_nr,
585 struct treepath *path, int flags)
586{
587 BUG_ON(!th->t_trans_id);
588
589#ifdef REISERFS_PREALLOCATE
590 if (!(flags & GET_BLOCK_NO_IMUX)) {
591 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
592 path, block);
593 }
594#endif
595 return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
596 block);
597}
598
599int reiserfs_get_block(struct inode *inode, sector_t block,
600 struct buffer_head *bh_result, int create)
601{
602 int repeat, retval = 0;
603 b_blocknr_t allocated_block_nr = 0;
604 INITIALIZE_PATH(path);
605 int pos_in_item;
606 struct cpu_key key;
607 struct buffer_head *bh, *unbh = NULL;
608 struct item_head *ih, tmp_ih;
609 __le32 *item;
610 int done;
611 int fs_gen;
612 int lock_depth;
613 struct reiserfs_transaction_handle *th = NULL;
614
615
616
617
618
619
620 int jbegin_count =
621 JOURNAL_PER_BALANCE_CNT * 3 + 1 +
622 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
623 int version;
624 int dangle = 1;
625 loff_t new_offset =
626 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
627
628 lock_depth = reiserfs_write_lock_once(inode->i_sb);
629 version = get_inode_item_key_version(inode);
630
631 if (!file_capable(inode, block)) {
632 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
633 return -EFBIG;
634 }
635
636
637
638
639 if (!(create & GET_BLOCK_CREATE)) {
640 int ret;
641
642 ret = _get_block_create_0(inode, block, bh_result,
643 create | GET_BLOCK_READ_DIRECT);
644 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
645 return ret;
646 }
647
648
649
650
651 if ((create & GET_BLOCK_NO_DANGLE) ||
652 reiserfs_transaction_running(inode->i_sb))
653 dangle = 0;
654
655
656
657
658 if ((have_large_tails(inode->i_sb)
659 && inode->i_size < i_block_size(inode) * 4)
660 || (have_small_tails(inode->i_sb)
661 && inode->i_size < i_block_size(inode)))
662 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
663
664
665 make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 );
666 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
667 start_trans:
668 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
669 if (!th) {
670 retval = -ENOMEM;
671 goto failure;
672 }
673 reiserfs_update_inode_transaction(inode);
674 }
675 research:
676
677 retval = search_for_position_by_key(inode->i_sb, &key, &path);
678 if (retval == IO_ERROR) {
679 retval = -EIO;
680 goto failure;
681 }
682
683 bh = get_last_bh(&path);
684 ih = get_ih(&path);
685 item = get_item(&path);
686 pos_in_item = path.pos_in_item;
687
688 fs_gen = get_generation(inode->i_sb);
689 copy_item_head(&tmp_ih, ih);
690
691 if (allocation_needed
692 (retval, allocated_block_nr, ih, item, pos_in_item)) {
693
694 if (!th) {
695 pathrelse(&path);
696 goto start_trans;
697 }
698
699 repeat =
700 _allocate_block(th, block, inode, &allocated_block_nr,
701 &path, create);
702
703 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
704
705
706
707
708 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
709 retval = restart_transaction(th, inode, &path);
710 if (retval)
711 goto failure;
712 repeat =
713 _allocate_block(th, block, inode,
714 &allocated_block_nr, NULL, create);
715
716 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
717 goto research;
718 }
719 if (repeat == QUOTA_EXCEEDED)
720 retval = -EDQUOT;
721 else
722 retval = -ENOSPC;
723 goto failure;
724 }
725
726 if (fs_changed(fs_gen, inode->i_sb)
727 && item_moved(&tmp_ih, &path)) {
728 goto research;
729 }
730 }
731
732 if (indirect_item_found(retval, ih)) {
733 b_blocknr_t unfm_ptr;
734
735
736
737 unfm_ptr = get_block_num(item, pos_in_item);
738 if (unfm_ptr == 0) {
739
740 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
741 if (fs_changed(fs_gen, inode->i_sb)
742 && item_moved(&tmp_ih, &path)) {
743 reiserfs_restore_prepared_buffer(inode->i_sb,
744 bh);
745 goto research;
746 }
747 set_buffer_new(bh_result);
748 if (buffer_dirty(bh_result)
749 && reiserfs_data_ordered(inode->i_sb))
750 reiserfs_add_ordered_list(inode, bh_result);
751 put_block_num(item, pos_in_item, allocated_block_nr);
752 unfm_ptr = allocated_block_nr;
753 journal_mark_dirty(th, inode->i_sb, bh);
754 reiserfs_update_sd(th, inode);
755 }
756 set_block_dev_mapped(bh_result, unfm_ptr, inode);
757 pathrelse(&path);
758 retval = 0;
759 if (!dangle && th)
760 retval = reiserfs_end_persistent_transaction(th);
761
762 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
763
764
765
766
767
768 return retval;
769 }
770
771 if (!th) {
772 pathrelse(&path);
773 goto start_trans;
774 }
775
776
777
778
779 done = 0;
780 do {
781 if (is_statdata_le_ih(ih)) {
782 __le32 unp = 0;
783 struct cpu_key tmp_key;
784
785
786 make_le_item_head(&tmp_ih, &key, version, 1,
787 TYPE_INDIRECT, UNFM_P_SIZE,
788 0 );
789
790 if (cpu_key_k_offset(&key) == 1) {
791
792
793 unp = cpu_to_le32(allocated_block_nr);
794 set_block_dev_mapped(bh_result,
795 allocated_block_nr, inode);
796 set_buffer_new(bh_result);
797 done = 1;
798 }
799 tmp_key = key;
800 set_cpu_key_k_offset(&tmp_key, 1);
801 PATH_LAST_POSITION(&path)++;
802
803 retval =
804 reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
805 inode, (char *)&unp);
806 if (retval) {
807 reiserfs_free_block(th, inode,
808 allocated_block_nr, 1);
809 goto failure;
810 }
811
812 } else if (is_direct_le_ih(ih)) {
813
814 loff_t tail_offset;
815
816 tail_offset =
817 ((le_ih_k_offset(ih) -
818 1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
819 if (tail_offset == cpu_key_k_offset(&key)) {
820
821
822
823 set_block_dev_mapped(bh_result,
824 allocated_block_nr, inode);
825 unbh = bh_result;
826 done = 1;
827 } else {
828
829
830
831
832 pathrelse(&path);
833
834
835
836
837 BUG_ON(!th->t_refcount);
838 if (th->t_refcount == 1) {
839 retval =
840 reiserfs_end_persistent_transaction
841 (th);
842 th = NULL;
843 if (retval)
844 goto failure;
845 }
846
847 retval =
848 convert_tail_for_hole(inode, bh_result,
849 tail_offset);
850 if (retval) {
851 if (retval != -ENOSPC)
852 reiserfs_error(inode->i_sb,
853 "clm-6004",
854 "convert tail failed "
855 "inode %lu, error %d",
856 inode->i_ino,
857 retval);
858 if (allocated_block_nr) {
859
860 if (!th)
861 th = reiserfs_persistent_transaction(inode->i_sb, 3);
862 if (th)
863 reiserfs_free_block(th,
864 inode,
865 allocated_block_nr,
866 1);
867 }
868 goto failure;
869 }
870 goto research;
871 }
872 retval =
873 direct2indirect(th, inode, &path, unbh,
874 tail_offset);
875 if (retval) {
876 reiserfs_unmap_buffer(unbh);
877 reiserfs_free_block(th, inode,
878 allocated_block_nr, 1);
879 goto failure;
880 }
881
882
883
884
885
886
887
888
889 set_buffer_uptodate(unbh);
890
891
892
893
894 if (unbh->b_page) {
895
896
897
898 reiserfs_add_tail_list(inode, unbh);
899
900
901
902
903
904
905
906
907
908
909 mark_buffer_dirty(unbh);
910 }
911 } else {
912
913
914
915 struct cpu_key tmp_key;
916 unp_t unf_single = 0;
917
918 unp_t *un;
919 __u64 max_to_insert =
920 MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
921 UNFM_P_SIZE;
922 __u64 blocks_needed;
923
924 RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
925 "vs-804: invalid position for append");
926
927 make_cpu_key(&tmp_key, inode,
928 le_key_k_offset(version,
929 &(ih->ih_key)) +
930 op_bytes_number(ih,
931 inode->i_sb->s_blocksize),
932
933 TYPE_INDIRECT, 3);
934
935 RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),
936 "green-805: invalid offset");
937 blocks_needed =
938 1 +
939 ((cpu_key_k_offset(&key) -
940 cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
941 s_blocksize_bits);
942
943 if (blocks_needed == 1) {
944 un = &unf_single;
945 } else {
946 un = kzalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_NOFS);
947 if (!un) {
948 un = &unf_single;
949 blocks_needed = 1;
950 max_to_insert = 0;
951 }
952 }
953 if (blocks_needed <= max_to_insert) {
954
955
956 un[blocks_needed - 1] =
957 cpu_to_le32(allocated_block_nr);
958 set_block_dev_mapped(bh_result,
959 allocated_block_nr, inode);
960 set_buffer_new(bh_result);
961 done = 1;
962 } else {
963
964
965
966 blocks_needed =
967 max_to_insert ? max_to_insert : 1;
968 }
969 retval =
970 reiserfs_paste_into_item(th, &path, &tmp_key, inode,
971 (char *)un,
972 UNFM_P_SIZE *
973 blocks_needed);
974
975 if (blocks_needed != 1)
976 kfree(un);
977
978 if (retval) {
979 reiserfs_free_block(th, inode,
980 allocated_block_nr, 1);
981 goto failure;
982 }
983 if (!done) {
984
985
986
987 inode->i_size +=
988 inode->i_sb->s_blocksize * blocks_needed;
989 }
990 }
991
992 if (done == 1)
993 break;
994
995
996
997
998
999
1000
1001
1002
1003 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
1004 retval = restart_transaction(th, inode, &path);
1005 if (retval)
1006 goto failure;
1007 }
1008
1009
1010
1011
1012
1013 if (need_resched()) {
1014 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
1015 schedule();
1016 lock_depth = reiserfs_write_lock_once(inode->i_sb);
1017 }
1018
1019 retval = search_for_position_by_key(inode->i_sb, &key, &path);
1020 if (retval == IO_ERROR) {
1021 retval = -EIO;
1022 goto failure;
1023 }
1024 if (retval == POSITION_FOUND) {
1025 reiserfs_warning(inode->i_sb, "vs-825",
1026 "%K should not be found", &key);
1027 retval = -EEXIST;
1028 if (allocated_block_nr)
1029 reiserfs_free_block(th, inode,
1030 allocated_block_nr, 1);
1031 pathrelse(&path);
1032 goto failure;
1033 }
1034 bh = get_last_bh(&path);
1035 ih = get_ih(&path);
1036 item = get_item(&path);
1037 pos_in_item = path.pos_in_item;
1038 } while (1);
1039
1040 retval = 0;
1041
1042 failure:
1043 if (th && (!dangle || (retval && !th->t_trans_id))) {
1044 int err;
1045 if (th->t_trans_id)
1046 reiserfs_update_sd(th, inode);
1047 err = reiserfs_end_persistent_transaction(th);
1048 if (err)
1049 retval = err;
1050 }
1051
1052 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
1053 reiserfs_check_path(&path);
1054 return retval;
1055}
1056
1057static int
1058reiserfs_readpages(struct file *file, struct address_space *mapping,
1059 struct list_head *pages, unsigned nr_pages)
1060{
1061 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
1062}
1063
1064
1065
1066
1067static int real_space_diff(struct inode *inode, int sd_size)
1068{
1069 int bytes;
1070 loff_t blocksize = inode->i_sb->s_blocksize;
1071
1072 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1073 return sd_size;
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083 bytes =
1084 ((inode->i_size +
1085 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1086 sd_size;
1087 return bytes;
1088}
1089
1090static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
1091 int sd_size)
1092{
1093 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1094 return inode->i_size +
1095 (loff_t) (real_space_diff(inode, sd_size));
1096 }
1097 return ((loff_t) real_space_diff(inode, sd_size)) +
1098 (((loff_t) blocks) << 9);
1099}
1100
1101
1102static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1103{
1104 loff_t bytes = inode_get_bytes(inode);
1105 loff_t real_space = real_space_diff(inode, sd_size);
1106
1107
1108 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1109 bytes += (loff_t) 511;
1110 }
1111
1112
1113
1114
1115
1116 if (bytes < real_space)
1117 return 0;
1118 return (bytes - real_space) >> 9;
1119}
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129static void init_inode(struct inode *inode, struct treepath *path)
1130{
1131 struct buffer_head *bh;
1132 struct item_head *ih;
1133 __u32 rdev;
1134
1135
1136 bh = PATH_PLAST_BUFFER(path);
1137 ih = PATH_PITEM_HEAD(path);
1138
1139 copy_key(INODE_PKEY(inode), &(ih->ih_key));
1140
1141 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1142 REISERFS_I(inode)->i_flags = 0;
1143 REISERFS_I(inode)->i_prealloc_block = 0;
1144 REISERFS_I(inode)->i_prealloc_count = 0;
1145 REISERFS_I(inode)->i_trans_id = 0;
1146 REISERFS_I(inode)->i_jl = NULL;
1147 reiserfs_init_xattr_rwsem(inode);
1148
1149 if (stat_data_v1(ih)) {
1150 struct stat_data_v1 *sd =
1151 (struct stat_data_v1 *)B_I_PITEM(bh, ih);
1152 unsigned long blocks;
1153
1154 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1155 set_inode_sd_version(inode, STAT_DATA_V1);
1156 inode->i_mode = sd_v1_mode(sd);
1157 inode->i_nlink = sd_v1_nlink(sd);
1158 inode->i_uid = sd_v1_uid(sd);
1159 inode->i_gid = sd_v1_gid(sd);
1160 inode->i_size = sd_v1_size(sd);
1161 inode->i_atime.tv_sec = sd_v1_atime(sd);
1162 inode->i_mtime.tv_sec = sd_v1_mtime(sd);
1163 inode->i_ctime.tv_sec = sd_v1_ctime(sd);
1164 inode->i_atime.tv_nsec = 0;
1165 inode->i_ctime.tv_nsec = 0;
1166 inode->i_mtime.tv_nsec = 0;
1167
1168 inode->i_blocks = sd_v1_blocks(sd);
1169 inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1170 blocks = (inode->i_size + 511) >> 9;
1171 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
1172 if (inode->i_blocks > blocks) {
1173
1174
1175
1176
1177
1178 inode->i_blocks = blocks;
1179 }
1180
1181 rdev = sd_v1_rdev(sd);
1182 REISERFS_I(inode)->i_first_direct_byte =
1183 sd_v1_first_direct_byte(sd);
1184
1185
1186
1187 if (inode->i_blocks & 1) {
1188 inode->i_blocks++;
1189 }
1190 inode_set_bytes(inode,
1191 to_real_used_space(inode, inode->i_blocks,
1192 SD_V1_SIZE));
1193
1194
1195 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1196 } else {
1197
1198
1199 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
1200
1201 inode->i_mode = sd_v2_mode(sd);
1202 inode->i_nlink = sd_v2_nlink(sd);
1203 inode->i_uid = sd_v2_uid(sd);
1204 inode->i_size = sd_v2_size(sd);
1205 inode->i_gid = sd_v2_gid(sd);
1206 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1207 inode->i_atime.tv_sec = sd_v2_atime(sd);
1208 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1209 inode->i_ctime.tv_nsec = 0;
1210 inode->i_mtime.tv_nsec = 0;
1211 inode->i_atime.tv_nsec = 0;
1212 inode->i_blocks = sd_v2_blocks(sd);
1213 rdev = sd_v2_rdev(sd);
1214 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1215 inode->i_generation =
1216 le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1217 else
1218 inode->i_generation = sd_v2_generation(sd);
1219
1220 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1221 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1222 else
1223 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1224 REISERFS_I(inode)->i_first_direct_byte = 0;
1225 set_inode_sd_version(inode, STAT_DATA_V2);
1226 inode_set_bytes(inode,
1227 to_real_used_space(inode, inode->i_blocks,
1228 SD_V2_SIZE));
1229
1230
1231 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1232 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
1233 }
1234
1235 pathrelse(path);
1236 if (S_ISREG(inode->i_mode)) {
1237 inode->i_op = &reiserfs_file_inode_operations;
1238 inode->i_fop = &reiserfs_file_operations;
1239 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1240 } else if (S_ISDIR(inode->i_mode)) {
1241 inode->i_op = &reiserfs_dir_inode_operations;
1242 inode->i_fop = &reiserfs_dir_operations;
1243 } else if (S_ISLNK(inode->i_mode)) {
1244 inode->i_op = &reiserfs_symlink_inode_operations;
1245 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1246 } else {
1247 inode->i_blocks = 0;
1248 inode->i_op = &reiserfs_special_inode_operations;
1249 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
1250 }
1251}
1252
1253
1254static void inode2sd(void *sd, struct inode *inode, loff_t size)
1255{
1256 struct stat_data *sd_v2 = (struct stat_data *)sd;
1257 __u16 flags;
1258
1259 set_sd_v2_mode(sd_v2, inode->i_mode);
1260 set_sd_v2_nlink(sd_v2, inode->i_nlink);
1261 set_sd_v2_uid(sd_v2, inode->i_uid);
1262 set_sd_v2_size(sd_v2, size);
1263 set_sd_v2_gid(sd_v2, inode->i_gid);
1264 set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);
1265 set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);
1266 set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);
1267 set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));
1268 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1269 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));
1270 else
1271 set_sd_v2_generation(sd_v2, inode->i_generation);
1272 flags = REISERFS_I(inode)->i_attrs;
1273 i_attrs_to_sd_attrs(inode, &flags);
1274 set_sd_v2_attrs(sd_v2, flags);
1275}
1276
1277
1278static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
1279{
1280 struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
1281
1282 set_sd_v1_mode(sd_v1, inode->i_mode);
1283 set_sd_v1_uid(sd_v1, inode->i_uid);
1284 set_sd_v1_gid(sd_v1, inode->i_gid);
1285 set_sd_v1_nlink(sd_v1, inode->i_nlink);
1286 set_sd_v1_size(sd_v1, size);
1287 set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);
1288 set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);
1289 set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);
1290
1291 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1292 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));
1293 else
1294 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
1295
1296
1297 set_sd_v1_first_direct_byte(sd_v1,
1298 REISERFS_I(inode)->i_first_direct_byte);
1299}
1300
1301
1302
1303
1304static void update_stat_data(struct treepath *path, struct inode *inode,
1305 loff_t size)
1306{
1307 struct buffer_head *bh;
1308 struct item_head *ih;
1309
1310 bh = PATH_PLAST_BUFFER(path);
1311 ih = PATH_PITEM_HEAD(path);
1312
1313 if (!is_statdata_le_ih(ih))
1314 reiserfs_panic(inode->i_sb, "vs-13065", "key %k, found item %h",
1315 INODE_PKEY(inode), ih);
1316
1317 if (stat_data_v1(ih)) {
1318
1319 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1320 } else {
1321 inode2sd(B_I_PITEM(bh, ih), inode, size);
1322 }
1323
1324 return;
1325}
1326
1327void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1328 struct inode *inode, loff_t size)
1329{
1330 struct cpu_key key;
1331 INITIALIZE_PATH(path);
1332 struct buffer_head *bh;
1333 int fs_gen;
1334 struct item_head *ih, tmp_ih;
1335 int retval;
1336
1337 BUG_ON(!th->t_trans_id);
1338
1339 make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3);
1340
1341 for (;;) {
1342 int pos;
1343
1344 retval = search_item(inode->i_sb, &key, &path);
1345 if (retval == IO_ERROR) {
1346 reiserfs_error(inode->i_sb, "vs-13050",
1347 "i/o failure occurred trying to "
1348 "update %K stat data", &key);
1349 return;
1350 }
1351 if (retval == ITEM_NOT_FOUND) {
1352 pos = PATH_LAST_POSITION(&path);
1353 pathrelse(&path);
1354 if (inode->i_nlink == 0) {
1355
1356 return;
1357 }
1358 reiserfs_warning(inode->i_sb, "vs-13060",
1359 "stat data of object %k (nlink == %d) "
1360 "not found (pos %d)",
1361 INODE_PKEY(inode), inode->i_nlink,
1362 pos);
1363 reiserfs_check_path(&path);
1364 return;
1365 }
1366
1367
1368
1369
1370
1371 bh = get_last_bh(&path);
1372 ih = get_ih(&path);
1373 copy_item_head(&tmp_ih, ih);
1374 fs_gen = get_generation(inode->i_sb);
1375 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
1376 if (fs_changed(fs_gen, inode->i_sb)
1377 && item_moved(&tmp_ih, &path)) {
1378 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
1379 continue;
1380 }
1381 break;
1382 }
1383 update_stat_data(&path, inode, size);
1384 journal_mark_dirty(th, th->t_super, bh);
1385 pathrelse(&path);
1386 return;
1387}
1388
1389
1390
1391
1392
1393
1394
1395static void reiserfs_make_bad_inode(struct inode *inode)
1396{
1397 memset(INODE_PKEY(inode), 0, KEY_SIZE);
1398 make_bad_inode(inode);
1399}
1400
1401
1402
1403
1404
1405
1406int reiserfs_init_locked_inode(struct inode *inode, void *p)
1407{
1408 struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;
1409 inode->i_ino = args->objectid;
1410 INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);
1411 return 0;
1412}
1413
1414
1415
1416void reiserfs_read_locked_inode(struct inode *inode,
1417 struct reiserfs_iget_args *args)
1418{
1419 INITIALIZE_PATH(path_to_sd);
1420 struct cpu_key key;
1421 unsigned long dirino;
1422 int retval;
1423
1424 dirino = args->dirid;
1425
1426
1427
1428 key.version = KEY_FORMAT_3_5;
1429 key.on_disk_key.k_dir_id = dirino;
1430 key.on_disk_key.k_objectid = inode->i_ino;
1431 key.on_disk_key.k_offset = 0;
1432 key.on_disk_key.k_type = 0;
1433
1434
1435 retval = search_item(inode->i_sb, &key, &path_to_sd);
1436 if (retval == IO_ERROR) {
1437 reiserfs_error(inode->i_sb, "vs-13070",
1438 "i/o failure occurred trying to find "
1439 "stat data of %K", &key);
1440 reiserfs_make_bad_inode(inode);
1441 return;
1442 }
1443 if (retval != ITEM_FOUND) {
1444
1445 pathrelse(&path_to_sd);
1446 reiserfs_make_bad_inode(inode);
1447 inode->i_nlink = 0;
1448 return;
1449 }
1450
1451 init_inode(inode, &path_to_sd);
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467 if ((inode->i_nlink == 0) &&
1468 !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
1469 reiserfs_warning(inode->i_sb, "vs-13075",
1470 "dead inode read from disk %K. "
1471 "This is likely to be race with knfsd. Ignore",
1472 &key);
1473 reiserfs_make_bad_inode(inode);
1474 }
1475
1476 reiserfs_check_path(&path_to_sd);
1477
1478}
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492int reiserfs_find_actor(struct inode *inode, void *opaque)
1493{
1494 struct reiserfs_iget_args *args;
1495
1496 args = opaque;
1497
1498 return (inode->i_ino == args->objectid) &&
1499 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
1500}
1501
1502struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
1503{
1504 struct inode *inode;
1505 struct reiserfs_iget_args args;
1506
1507 args.objectid = key->on_disk_key.k_objectid;
1508 args.dirid = key->on_disk_key.k_dir_id;
1509 reiserfs_write_unlock(s);
1510 inode = iget5_locked(s, key->on_disk_key.k_objectid,
1511 reiserfs_find_actor, reiserfs_init_locked_inode,
1512 (void *)(&args));
1513 reiserfs_write_lock(s);
1514 if (!inode)
1515 return ERR_PTR(-ENOMEM);
1516
1517 if (inode->i_state & I_NEW) {
1518 reiserfs_read_locked_inode(inode, &args);
1519 unlock_new_inode(inode);
1520 }
1521
1522 if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1523
1524 iput(inode);
1525 inode = NULL;
1526 }
1527 return inode;
1528}
1529
1530static struct dentry *reiserfs_get_dentry(struct super_block *sb,
1531 u32 objectid, u32 dir_id, u32 generation)
1532
1533{
1534 struct cpu_key key;
1535 struct inode *inode;
1536
1537 key.on_disk_key.k_objectid = objectid;
1538 key.on_disk_key.k_dir_id = dir_id;
1539 reiserfs_write_lock(sb);
1540 inode = reiserfs_iget(sb, &key);
1541 if (inode && !IS_ERR(inode) && generation != 0 &&
1542 generation != inode->i_generation) {
1543 iput(inode);
1544 inode = NULL;
1545 }
1546 reiserfs_write_unlock(sb);
1547
1548 return d_obtain_alias(inode);
1549}
1550
1551struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
1552 int fh_len, int fh_type)
1553{
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566 if (fh_type > fh_len) {
1567 if (fh_type != 6 || fh_len != 5)
1568 reiserfs_warning(sb, "reiserfs-13077",
1569 "nfsd/reiserfs, fhtype=%d, len=%d - odd",
1570 fh_type, fh_len);
1571 fh_type = 5;
1572 }
1573
1574 return reiserfs_get_dentry(sb, fid->raw[0], fid->raw[1],
1575 (fh_type == 3 || fh_type >= 5) ? fid->raw[2] : 0);
1576}
1577
1578struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,
1579 int fh_len, int fh_type)
1580{
1581 if (fh_type < 4)
1582 return NULL;
1583
1584 return reiserfs_get_dentry(sb,
1585 (fh_type >= 5) ? fid->raw[3] : fid->raw[2],
1586 (fh_type >= 5) ? fid->raw[4] : fid->raw[3],
1587 (fh_type == 6) ? fid->raw[5] : 0);
1588}
1589
1590int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
1591 int need_parent)
1592{
1593 struct inode *inode = dentry->d_inode;
1594 int maxlen = *lenp;
1595
1596 if (maxlen < 3)
1597 return 255;
1598
1599 data[0] = inode->i_ino;
1600 data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1601 data[2] = inode->i_generation;
1602 *lenp = 3;
1603
1604 if (maxlen < 5 || !need_parent)
1605 return 3;
1606
1607 spin_lock(&dentry->d_lock);
1608 inode = dentry->d_parent->d_inode;
1609 data[3] = inode->i_ino;
1610 data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1611 *lenp = 5;
1612 if (maxlen >= 6) {
1613 data[5] = inode->i_generation;
1614 *lenp = 6;
1615 }
1616 spin_unlock(&dentry->d_lock);
1617 return *lenp;
1618}
1619
1620
1621
1622
1623
1624
1625
1626
1627int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc)
1628{
1629 struct reiserfs_transaction_handle th;
1630 int jbegin_count = 1;
1631
1632 if (inode->i_sb->s_flags & MS_RDONLY)
1633 return -EROFS;
1634
1635
1636
1637
1638
1639 if (wbc->sync_mode == WB_SYNC_ALL && !(current->flags & PF_MEMALLOC)) {
1640 reiserfs_write_lock(inode->i_sb);
1641 if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
1642 reiserfs_update_sd(&th, inode);
1643 journal_end_sync(&th, inode->i_sb, jbegin_count);
1644 }
1645 reiserfs_write_unlock(inode->i_sb);
1646 }
1647 return 0;
1648}
1649
1650
1651
1652static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1653 struct inode *inode,
1654 struct item_head *ih, struct treepath *path,
1655 struct inode *dir)
1656{
1657 struct super_block *sb = th->t_super;
1658 char empty_dir[EMPTY_DIR_SIZE];
1659 char *body = empty_dir;
1660 struct cpu_key key;
1661 int retval;
1662
1663 BUG_ON(!th->t_trans_id);
1664
1665 _make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),
1666 le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,
1667 TYPE_DIRENTRY, 3 );
1668
1669
1670
1671
1672 if (old_format_only(sb)) {
1673 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1674 TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);
1675
1676 make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,
1677 ih->ih_key.k_objectid,
1678 INODE_PKEY(dir)->k_dir_id,
1679 INODE_PKEY(dir)->k_objectid);
1680 } else {
1681 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1682 TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
1683
1684 make_empty_dir_item(body, ih->ih_key.k_dir_id,
1685 ih->ih_key.k_objectid,
1686 INODE_PKEY(dir)->k_dir_id,
1687 INODE_PKEY(dir)->k_objectid);
1688 }
1689
1690
1691 retval = search_item(sb, &key, path);
1692 if (retval == IO_ERROR) {
1693 reiserfs_error(sb, "vs-13080",
1694 "i/o failure occurred creating new directory");
1695 return -EIO;
1696 }
1697 if (retval == ITEM_FOUND) {
1698 pathrelse(path);
1699 reiserfs_warning(sb, "vs-13070",
1700 "object with this key exists (%k)",
1701 &(ih->ih_key));
1702 return -EEXIST;
1703 }
1704
1705
1706 return reiserfs_insert_item(th, path, &key, ih, inode, body);
1707}
1708
1709
1710
1711static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode,
1712 struct item_head *ih,
1713 struct treepath *path, const char *symname,
1714 int item_len)
1715{
1716 struct super_block *sb = th->t_super;
1717 struct cpu_key key;
1718 int retval;
1719
1720 BUG_ON(!th->t_trans_id);
1721
1722 _make_cpu_key(&key, KEY_FORMAT_3_5,
1723 le32_to_cpu(ih->ih_key.k_dir_id),
1724 le32_to_cpu(ih->ih_key.k_objectid),
1725 1, TYPE_DIRECT, 3 );
1726
1727 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1728 0 );
1729
1730
1731 retval = search_item(sb, &key, path);
1732 if (retval == IO_ERROR) {
1733 reiserfs_error(sb, "vs-13080",
1734 "i/o failure occurred creating new symlink");
1735 return -EIO;
1736 }
1737 if (retval == ITEM_FOUND) {
1738 pathrelse(path);
1739 reiserfs_warning(sb, "vs-13080",
1740 "object with this key exists (%k)",
1741 &(ih->ih_key));
1742 return -EEXIST;
1743 }
1744
1745
1746 return reiserfs_insert_item(th, path, &key, ih, inode, symname);
1747}
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1759 struct inode *dir, int mode, const char *symname,
1760
1761
1762 loff_t i_size, struct dentry *dentry,
1763 struct inode *inode,
1764 struct reiserfs_security_handle *security)
1765{
1766 struct super_block *sb;
1767 struct reiserfs_iget_args args;
1768 INITIALIZE_PATH(path_to_key);
1769 struct cpu_key key;
1770 struct item_head ih;
1771 struct stat_data sd;
1772 int retval;
1773 int err;
1774
1775 BUG_ON(!th->t_trans_id);
1776
1777 dquot_initialize(inode);
1778 err = dquot_alloc_inode(inode);
1779 if (err)
1780 goto out_end_trans;
1781 if (!dir->i_nlink) {
1782 err = -EPERM;
1783 goto out_bad_inode;
1784 }
1785
1786 sb = dir->i_sb;
1787
1788
1789 ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);
1790 ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));
1791 if (!ih.ih_key.k_objectid) {
1792 err = -ENOMEM;
1793 goto out_bad_inode;
1794 }
1795 args.objectid = inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1796 if (old_format_only(sb))
1797 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1798 TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1799 else
1800 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1801 TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1802 memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1803 args.dirid = le32_to_cpu(ih.ih_key.k_dir_id);
1804 if (insert_inode_locked4(inode, args.objectid,
1805 reiserfs_find_actor, &args) < 0) {
1806 err = -EINVAL;
1807 goto out_bad_inode;
1808 }
1809 if (old_format_only(sb))
1810
1811
1812
1813
1814
1815 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1816 else
1817#if defined( USE_INODE_GENERATION_COUNTER )
1818 inode->i_generation =
1819 le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1820#else
1821 inode->i_generation = ++event;
1822#endif
1823
1824
1825 inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);
1826
1827
1828
1829
1830 if (S_ISLNK(inode->i_mode))
1831 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1832
1833 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1834 inode->i_size = i_size;
1835 inode->i_blocks = 0;
1836 inode->i_bytes = 0;
1837 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1838 U32_MAX ;
1839
1840 INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1841 REISERFS_I(inode)->i_flags = 0;
1842 REISERFS_I(inode)->i_prealloc_block = 0;
1843 REISERFS_I(inode)->i_prealloc_count = 0;
1844 REISERFS_I(inode)->i_trans_id = 0;
1845 REISERFS_I(inode)->i_jl = NULL;
1846 REISERFS_I(inode)->i_attrs =
1847 REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;
1848 sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);
1849 reiserfs_init_xattr_rwsem(inode);
1850
1851
1852 _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1853 le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1854 TYPE_STAT_DATA, 3 );
1855
1856
1857 retval = search_item(sb, &key, &path_to_key);
1858 if (retval == IO_ERROR) {
1859 err = -EIO;
1860 goto out_bad_inode;
1861 }
1862 if (retval == ITEM_FOUND) {
1863 pathrelse(&path_to_key);
1864 err = -EEXIST;
1865 goto out_bad_inode;
1866 }
1867 if (old_format_only(sb)) {
1868 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1869 pathrelse(&path_to_key);
1870
1871 err = -EINVAL;
1872 goto out_bad_inode;
1873 }
1874 inode2sd_v1(&sd, inode, inode->i_size);
1875 } else {
1876 inode2sd(&sd, inode, inode->i_size);
1877 }
1878
1879
1880
1881 if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1882 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1883 else
1884 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1885 if (old_format_only(sb))
1886 set_inode_sd_version(inode, STAT_DATA_V1);
1887 else
1888 set_inode_sd_version(inode, STAT_DATA_V2);
1889
1890
1891#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1892 if (REISERFS_I(dir)->new_packing_locality)
1893 th->displace_new_blocks = 1;
1894#endif
1895 retval =
1896 reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1897 (char *)(&sd));
1898 if (retval) {
1899 err = retval;
1900 reiserfs_check_path(&path_to_key);
1901 goto out_bad_inode;
1902 }
1903#ifdef DISPLACE_NEW_PACKING_LOCALITIES
1904 if (!th->displace_new_blocks)
1905 REISERFS_I(dir)->new_packing_locality = 0;
1906#endif
1907 if (S_ISDIR(mode)) {
1908
1909 retval =
1910 reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1911 }
1912
1913 if (S_ISLNK(mode)) {
1914
1915 if (!old_format_only(sb))
1916 i_size = ROUND_UP(i_size);
1917 retval =
1918 reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1919 i_size);
1920 }
1921 if (retval) {
1922 err = retval;
1923 reiserfs_check_path(&path_to_key);
1924 journal_end(th, th->t_super, th->t_blocks_allocated);
1925 goto out_inserted_sd;
1926 }
1927
1928 if (reiserfs_posixacl(inode->i_sb)) {
1929 retval = reiserfs_inherit_default_acl(th, dir, dentry, inode);
1930 if (retval) {
1931 err = retval;
1932 reiserfs_check_path(&path_to_key);
1933 journal_end(th, th->t_super, th->t_blocks_allocated);
1934 goto out_inserted_sd;
1935 }
1936 } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1937 reiserfs_warning(inode->i_sb, "jdm-13090",
1938 "ACLs aren't enabled in the fs, "
1939 "but vfs thinks they are!");
1940 } else if (IS_PRIVATE(dir))
1941 inode->i_flags |= S_PRIVATE;
1942
1943 if (security->name) {
1944 retval = reiserfs_security_write(th, inode, security);
1945 if (retval) {
1946 err = retval;
1947 reiserfs_check_path(&path_to_key);
1948 retval = journal_end(th, th->t_super,
1949 th->t_blocks_allocated);
1950 if (retval)
1951 err = retval;
1952 goto out_inserted_sd;
1953 }
1954 }
1955
1956 reiserfs_update_sd(th, inode);
1957 reiserfs_check_path(&path_to_key);
1958
1959 return 0;
1960
1961
1962
1963
1964
1965 out_bad_inode:
1966
1967 INODE_PKEY(inode)->k_objectid = 0;
1968
1969
1970 dquot_free_inode(inode);
1971
1972 out_end_trans:
1973 journal_end(th, th->t_super, th->t_blocks_allocated);
1974
1975 dquot_drop(inode);
1976 inode->i_flags |= S_NOQUOTA;
1977 make_bad_inode(inode);
1978
1979 out_inserted_sd:
1980 inode->i_nlink = 0;
1981 th->t_trans_id = 0;
1982 unlock_new_inode(inode);
1983 iput(inode);
1984 return err;
1985}
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000static int grab_tail_page(struct inode *inode,
2001 struct page **page_result,
2002 struct buffer_head **bh_result)
2003{
2004
2005
2006
2007
2008 unsigned long index = (inode->i_size - 1) >> PAGE_CACHE_SHIFT;
2009 unsigned long pos = 0;
2010 unsigned long start = 0;
2011 unsigned long blocksize = inode->i_sb->s_blocksize;
2012 unsigned long offset = (inode->i_size) & (PAGE_CACHE_SIZE - 1);
2013 struct buffer_head *bh;
2014 struct buffer_head *head;
2015 struct page *page;
2016 int error;
2017
2018
2019
2020
2021
2022
2023 if ((offset & (blocksize - 1)) == 0) {
2024 return -ENOENT;
2025 }
2026 page = grab_cache_page(inode->i_mapping, index);
2027 error = -ENOMEM;
2028 if (!page) {
2029 goto out;
2030 }
2031
2032 start = (offset / blocksize) * blocksize;
2033
2034 error = __block_write_begin(page, start, offset - start,
2035 reiserfs_get_block_create_0);
2036 if (error)
2037 goto unlock;
2038
2039 head = page_buffers(page);
2040 bh = head;
2041 do {
2042 if (pos >= start) {
2043 break;
2044 }
2045 bh = bh->b_this_page;
2046 pos += blocksize;
2047 } while (bh != head);
2048
2049 if (!buffer_uptodate(bh)) {
2050
2051
2052
2053
2054
2055 reiserfs_error(inode->i_sb, "clm-6000",
2056 "error reading block %lu", bh->b_blocknr);
2057 error = -EIO;
2058 goto unlock;
2059 }
2060 *bh_result = bh;
2061 *page_result = page;
2062
2063 out:
2064 return error;
2065
2066 unlock:
2067 unlock_page(page);
2068 page_cache_release(page);
2069 return error;
2070}
2071
2072
2073
2074
2075
2076
2077
2078int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
2079{
2080 struct reiserfs_transaction_handle th;
2081
2082 unsigned long offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2083 unsigned blocksize = inode->i_sb->s_blocksize;
2084 unsigned length;
2085 struct page *page = NULL;
2086 int error;
2087 struct buffer_head *bh = NULL;
2088 int err2;
2089 int lock_depth;
2090
2091 lock_depth = reiserfs_write_lock_once(inode->i_sb);
2092
2093 if (inode->i_size > 0) {
2094 error = grab_tail_page(inode, &page, &bh);
2095 if (error) {
2096
2097
2098
2099 if (error != -ENOENT)
2100 reiserfs_error(inode->i_sb, "clm-6001",
2101 "grab_tail_page failed %d",
2102 error);
2103 page = NULL;
2104 bh = NULL;
2105 }
2106 }
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118 error = journal_begin(&th, inode->i_sb,
2119 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2120 if (error)
2121 goto out;
2122 reiserfs_update_inode_transaction(inode);
2123 if (update_timestamps)
2124
2125
2126
2127 add_save_link(&th, inode, 1);
2128 err2 = reiserfs_do_truncate(&th, inode, page, update_timestamps);
2129 error =
2130 journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2131 if (error)
2132 goto out;
2133
2134
2135 if (err2) {
2136 error = err2;
2137 goto out;
2138 }
2139
2140 if (update_timestamps) {
2141 error = remove_save_link(inode, 1 );
2142 if (error)
2143 goto out;
2144 }
2145
2146 if (page) {
2147 length = offset & (blocksize - 1);
2148
2149 if (length) {
2150 length = blocksize - length;
2151 zero_user(page, offset, length);
2152 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2153 mark_buffer_dirty(bh);
2154 }
2155 }
2156 unlock_page(page);
2157 page_cache_release(page);
2158 }
2159
2160 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
2161
2162 return 0;
2163 out:
2164 if (page) {
2165 unlock_page(page);
2166 page_cache_release(page);
2167 }
2168
2169 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
2170
2171 return error;
2172}
2173
2174static int map_block_for_writepage(struct inode *inode,
2175 struct buffer_head *bh_result,
2176 unsigned long block)
2177{
2178 struct reiserfs_transaction_handle th;
2179 int fs_gen;
2180 struct item_head tmp_ih;
2181 struct item_head *ih;
2182 struct buffer_head *bh;
2183 __le32 *item;
2184 struct cpu_key key;
2185 INITIALIZE_PATH(path);
2186 int pos_in_item;
2187 int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2188 loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
2189 int retval;
2190 int use_get_block = 0;
2191 int bytes_copied = 0;
2192 int copy_size;
2193 int trans_running = 0;
2194
2195
2196 th.t_trans_id = 0;
2197
2198 if (!buffer_uptodate(bh_result)) {
2199 return -EIO;
2200 }
2201
2202 kmap(bh_result->b_page);
2203 start_over:
2204 reiserfs_write_lock(inode->i_sb);
2205 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
2206
2207 research:
2208 retval = search_for_position_by_key(inode->i_sb, &key, &path);
2209 if (retval != POSITION_FOUND) {
2210 use_get_block = 1;
2211 goto out;
2212 }
2213
2214 bh = get_last_bh(&path);
2215 ih = get_ih(&path);
2216 item = get_item(&path);
2217 pos_in_item = path.pos_in_item;
2218
2219
2220 if (indirect_item_found(retval, ih)) {
2221 if (bytes_copied > 0) {
2222 reiserfs_warning(inode->i_sb, "clm-6002",
2223 "bytes_copied %d", bytes_copied);
2224 }
2225 if (!get_block_num(item, pos_in_item)) {
2226
2227 use_get_block = 1;
2228 goto out;
2229 }
2230 set_block_dev_mapped(bh_result,
2231 get_block_num(item, pos_in_item), inode);
2232 } else if (is_direct_le_ih(ih)) {
2233 char *p;
2234 p = page_address(bh_result->b_page);
2235 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2236 copy_size = ih_item_len(ih) - pos_in_item;
2237
2238 fs_gen = get_generation(inode->i_sb);
2239 copy_item_head(&tmp_ih, ih);
2240
2241 if (!trans_running) {
2242
2243 retval = journal_begin(&th, inode->i_sb, jbegin_count);
2244 if (retval)
2245 goto out;
2246 reiserfs_update_inode_transaction(inode);
2247 trans_running = 1;
2248 if (fs_changed(fs_gen, inode->i_sb)
2249 && item_moved(&tmp_ih, &path)) {
2250 reiserfs_restore_prepared_buffer(inode->i_sb,
2251 bh);
2252 goto research;
2253 }
2254 }
2255
2256 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2257
2258 if (fs_changed(fs_gen, inode->i_sb)
2259 && item_moved(&tmp_ih, &path)) {
2260 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2261 goto research;
2262 }
2263
2264 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2265 copy_size);
2266
2267 journal_mark_dirty(&th, inode->i_sb, bh);
2268 bytes_copied += copy_size;
2269 set_block_dev_mapped(bh_result, 0, inode);
2270
2271
2272 if (bytes_copied < bh_result->b_size &&
2273 (byte_offset + bytes_copied) < inode->i_size) {
2274 set_cpu_key_k_offset(&key,
2275 cpu_key_k_offset(&key) +
2276 copy_size);
2277 goto research;
2278 }
2279 } else {
2280 reiserfs_warning(inode->i_sb, "clm-6003",
2281 "bad item inode %lu", inode->i_ino);
2282 retval = -EIO;
2283 goto out;
2284 }
2285 retval = 0;
2286
2287 out:
2288 pathrelse(&path);
2289 if (trans_running) {
2290 int err = journal_end(&th, inode->i_sb, jbegin_count);
2291 if (err)
2292 retval = err;
2293 trans_running = 0;
2294 }
2295 reiserfs_write_unlock(inode->i_sb);
2296
2297
2298 if (use_get_block) {
2299 retval = reiserfs_get_block(inode, block, bh_result,
2300 GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
2301 | GET_BLOCK_NO_DANGLE);
2302 if (!retval) {
2303 if (!buffer_mapped(bh_result)
2304 || bh_result->b_blocknr == 0) {
2305
2306 use_get_block = 0;
2307 goto start_over;
2308 }
2309 }
2310 }
2311 kunmap(bh_result->b_page);
2312
2313 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2314
2315
2316
2317 lock_buffer(bh_result);
2318 clear_buffer_dirty(bh_result);
2319 unlock_buffer(bh_result);
2320 }
2321 return retval;
2322}
2323
2324
2325
2326
2327
2328
2329static int reiserfs_write_full_page(struct page *page,
2330 struct writeback_control *wbc)
2331{
2332 struct inode *inode = page->mapping->host;
2333 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2334 int error = 0;
2335 unsigned long block;
2336 sector_t last_block;
2337 struct buffer_head *head, *bh;
2338 int partial = 0;
2339 int nr = 0;
2340 int checked = PageChecked(page);
2341 struct reiserfs_transaction_handle th;
2342 struct super_block *s = inode->i_sb;
2343 int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2344 th.t_trans_id = 0;
2345
2346
2347 if (checked && (current->flags & PF_MEMALLOC)) {
2348 redirty_page_for_writepage(wbc, page);
2349 unlock_page(page);
2350 return 0;
2351 }
2352
2353
2354
2355
2356
2357
2358 if (!page_has_buffers(page)) {
2359 create_empty_buffers(page, s->s_blocksize,
2360 (1 << BH_Dirty) | (1 << BH_Uptodate));
2361 }
2362 head = page_buffers(page);
2363
2364
2365
2366
2367 if (page->index >= end_index) {
2368 unsigned last_offset;
2369
2370 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2371
2372 if (page->index >= end_index + 1 || !last_offset) {
2373 unlock_page(page);
2374 return 0;
2375 }
2376 zero_user_segment(page, last_offset, PAGE_CACHE_SIZE);
2377 }
2378 bh = head;
2379 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2380 last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
2381
2382 do {
2383 if (block > last_block) {
2384
2385
2386
2387
2388
2389 clear_buffer_dirty(bh);
2390 set_buffer_uptodate(bh);
2391 } else if ((checked || buffer_dirty(bh)) &&
2392 (!buffer_mapped(bh) || (buffer_mapped(bh)
2393 && bh->b_blocknr ==
2394 0))) {
2395
2396
2397
2398
2399 if ((error = map_block_for_writepage(inode, bh, block))) {
2400 goto fail;
2401 }
2402 }
2403 bh = bh->b_this_page;
2404 block++;
2405 } while (bh != head);
2406
2407
2408
2409
2410
2411
2412
2413 if (checked) {
2414 ClearPageChecked(page);
2415 reiserfs_write_lock(s);
2416 error = journal_begin(&th, s, bh_per_page + 1);
2417 if (error) {
2418 reiserfs_write_unlock(s);
2419 goto fail;
2420 }
2421 reiserfs_update_inode_transaction(inode);
2422 }
2423
2424 do {
2425 get_bh(bh);
2426 if (!buffer_mapped(bh))
2427 continue;
2428 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2429 continue;
2430
2431 if (checked) {
2432 reiserfs_prepare_for_journal(s, bh, 1);
2433 journal_mark_dirty(&th, s, bh);
2434 continue;
2435 }
2436
2437
2438
2439 if (wbc->sync_mode != WB_SYNC_NONE) {
2440 lock_buffer(bh);
2441 } else {
2442 if (!trylock_buffer(bh)) {
2443 redirty_page_for_writepage(wbc, page);
2444 continue;
2445 }
2446 }
2447 if (test_clear_buffer_dirty(bh)) {
2448 mark_buffer_async_write(bh);
2449 } else {
2450 unlock_buffer(bh);
2451 }
2452 } while ((bh = bh->b_this_page) != head);
2453
2454 if (checked) {
2455 error = journal_end(&th, s, bh_per_page + 1);
2456 reiserfs_write_unlock(s);
2457 if (error)
2458 goto fail;
2459 }
2460 BUG_ON(PageWriteback(page));
2461 set_page_writeback(page);
2462 unlock_page(page);
2463
2464
2465
2466
2467
2468
2469 do {
2470 struct buffer_head *next = bh->b_this_page;
2471 if (buffer_async_write(bh)) {
2472 submit_bh(WRITE, bh);
2473 nr++;
2474 }
2475 put_bh(bh);
2476 bh = next;
2477 } while (bh != head);
2478
2479 error = 0;
2480 done:
2481 if (nr == 0) {
2482
2483
2484
2485
2486
2487
2488 bh = head;
2489 do {
2490 if (!buffer_uptodate(bh)) {
2491 partial = 1;
2492 break;
2493 }
2494 bh = bh->b_this_page;
2495 } while (bh != head);
2496 if (!partial)
2497 SetPageUptodate(page);
2498 end_page_writeback(page);
2499 }
2500 return error;
2501
2502 fail:
2503
2504
2505
2506
2507 ClearPageUptodate(page);
2508 bh = head;
2509 do {
2510 get_bh(bh);
2511 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2512 lock_buffer(bh);
2513 mark_buffer_async_write(bh);
2514 } else {
2515
2516
2517
2518
2519 clear_buffer_dirty(bh);
2520 }
2521 bh = bh->b_this_page;
2522 } while (bh != head);
2523 SetPageError(page);
2524 BUG_ON(PageWriteback(page));
2525 set_page_writeback(page);
2526 unlock_page(page);
2527 do {
2528 struct buffer_head *next = bh->b_this_page;
2529 if (buffer_async_write(bh)) {
2530 clear_buffer_dirty(bh);
2531 submit_bh(WRITE, bh);
2532 nr++;
2533 }
2534 put_bh(bh);
2535 bh = next;
2536 } while (bh != head);
2537 goto done;
2538}
2539
2540static int reiserfs_readpage(struct file *f, struct page *page)
2541{
2542 return block_read_full_page(page, reiserfs_get_block);
2543}
2544
2545static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
2546{
2547 struct inode *inode = page->mapping->host;
2548 reiserfs_wait_on_write_block(inode->i_sb);
2549 return reiserfs_write_full_page(page, wbc);
2550}
2551
2552static void reiserfs_truncate_failed_write(struct inode *inode)
2553{
2554 truncate_inode_pages(inode->i_mapping, inode->i_size);
2555 reiserfs_truncate_file(inode, 0);
2556}
2557
2558static int reiserfs_write_begin(struct file *file,
2559 struct address_space *mapping,
2560 loff_t pos, unsigned len, unsigned flags,
2561 struct page **pagep, void **fsdata)
2562{
2563 struct inode *inode;
2564 struct page *page;
2565 pgoff_t index;
2566 int ret;
2567 int old_ref = 0;
2568
2569 inode = mapping->host;
2570 *fsdata = 0;
2571 if (flags & AOP_FLAG_CONT_EXPAND &&
2572 (pos & (inode->i_sb->s_blocksize - 1)) == 0) {
2573 pos ++;
2574 *fsdata = (void *)(unsigned long)flags;
2575 }
2576
2577 index = pos >> PAGE_CACHE_SHIFT;
2578 page = grab_cache_page_write_begin(mapping, index, flags);
2579 if (!page)
2580 return -ENOMEM;
2581 *pagep = page;
2582
2583 reiserfs_wait_on_write_block(inode->i_sb);
2584 fix_tail_page_for_writing(page);
2585 if (reiserfs_transaction_running(inode->i_sb)) {
2586 struct reiserfs_transaction_handle *th;
2587 th = (struct reiserfs_transaction_handle *)current->
2588 journal_info;
2589 BUG_ON(!th->t_refcount);
2590 BUG_ON(!th->t_trans_id);
2591 old_ref = th->t_refcount;
2592 th->t_refcount++;
2593 }
2594 ret = __block_write_begin(page, pos, len, reiserfs_get_block);
2595 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2596 struct reiserfs_transaction_handle *th = current->journal_info;
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607 if (th->t_refcount > old_ref) {
2608 if (old_ref)
2609 th->t_refcount--;
2610 else {
2611 int err;
2612 reiserfs_write_lock(inode->i_sb);
2613 err = reiserfs_end_persistent_transaction(th);
2614 reiserfs_write_unlock(inode->i_sb);
2615 if (err)
2616 ret = err;
2617 }
2618 }
2619 }
2620 if (ret) {
2621 unlock_page(page);
2622 page_cache_release(page);
2623
2624 reiserfs_truncate_failed_write(inode);
2625 }
2626 return ret;
2627}
2628
2629int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
2630{
2631 struct inode *inode = page->mapping->host;
2632 int ret;
2633 int old_ref = 0;
2634
2635 reiserfs_write_unlock(inode->i_sb);
2636 reiserfs_wait_on_write_block(inode->i_sb);
2637 reiserfs_write_lock(inode->i_sb);
2638
2639 fix_tail_page_for_writing(page);
2640 if (reiserfs_transaction_running(inode->i_sb)) {
2641 struct reiserfs_transaction_handle *th;
2642 th = (struct reiserfs_transaction_handle *)current->
2643 journal_info;
2644 BUG_ON(!th->t_refcount);
2645 BUG_ON(!th->t_trans_id);
2646 old_ref = th->t_refcount;
2647 th->t_refcount++;
2648 }
2649
2650 ret = __block_write_begin(page, from, len, reiserfs_get_block);
2651 if (ret && reiserfs_transaction_running(inode->i_sb)) {
2652 struct reiserfs_transaction_handle *th = current->journal_info;
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663 if (th->t_refcount > old_ref) {
2664 if (old_ref)
2665 th->t_refcount--;
2666 else {
2667 int err;
2668 reiserfs_write_lock(inode->i_sb);
2669 err = reiserfs_end_persistent_transaction(th);
2670 reiserfs_write_unlock(inode->i_sb);
2671 if (err)
2672 ret = err;
2673 }
2674 }
2675 }
2676 return ret;
2677
2678}
2679
2680static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2681{
2682 return generic_block_bmap(as, block, reiserfs_bmap);
2683}
2684
2685static int reiserfs_write_end(struct file *file, struct address_space *mapping,
2686 loff_t pos, unsigned len, unsigned copied,
2687 struct page *page, void *fsdata)
2688{
2689 struct inode *inode = page->mapping->host;
2690 int ret = 0;
2691 int update_sd = 0;
2692 struct reiserfs_transaction_handle *th;
2693 unsigned start;
2694 int lock_depth = 0;
2695 bool locked = false;
2696
2697 if ((unsigned long)fsdata & AOP_FLAG_CONT_EXPAND)
2698 pos ++;
2699
2700 reiserfs_wait_on_write_block(inode->i_sb);
2701 if (reiserfs_transaction_running(inode->i_sb))
2702 th = current->journal_info;
2703 else
2704 th = NULL;
2705
2706 start = pos & (PAGE_CACHE_SIZE - 1);
2707 if (unlikely(copied < len)) {
2708 if (!PageUptodate(page))
2709 copied = 0;
2710
2711 page_zero_new_buffers(page, start + copied, start + len);
2712 }
2713 flush_dcache_page(page);
2714
2715 reiserfs_commit_page(inode, page, start, start + copied);
2716
2717
2718
2719
2720
2721 if (pos + copied > inode->i_size) {
2722 struct reiserfs_transaction_handle myth;
2723 lock_depth = reiserfs_write_lock_once(inode->i_sb);
2724 locked = true;
2725
2726
2727
2728 if ((have_large_tails(inode->i_sb)
2729 && inode->i_size > i_block_size(inode) * 4)
2730 || (have_small_tails(inode->i_sb)
2731 && inode->i_size > i_block_size(inode)))
2732 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2733
2734 ret = journal_begin(&myth, inode->i_sb, 1);
2735 if (ret)
2736 goto journal_error;
2737
2738 reiserfs_update_inode_transaction(inode);
2739 inode->i_size = pos + copied;
2740
2741
2742
2743
2744
2745 mark_inode_dirty(inode);
2746 reiserfs_update_sd(&myth, inode);
2747 update_sd = 1;
2748 ret = journal_end(&myth, inode->i_sb, 1);
2749 if (ret)
2750 goto journal_error;
2751 }
2752 if (th) {
2753 if (!locked) {
2754 lock_depth = reiserfs_write_lock_once(inode->i_sb);
2755 locked = true;
2756 }
2757 if (!update_sd)
2758 mark_inode_dirty(inode);
2759 ret = reiserfs_end_persistent_transaction(th);
2760 if (ret)
2761 goto out;
2762 }
2763
2764 out:
2765 if (locked)
2766 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
2767 unlock_page(page);
2768 page_cache_release(page);
2769
2770 if (pos + len > inode->i_size)
2771 reiserfs_truncate_failed_write(inode);
2772
2773 return ret == 0 ? copied : ret;
2774
2775 journal_error:
2776 reiserfs_write_unlock_once(inode->i_sb, lock_depth);
2777 locked = false;
2778 if (th) {
2779 if (!update_sd)
2780 reiserfs_update_sd(th, inode);
2781 ret = reiserfs_end_persistent_transaction(th);
2782 }
2783 goto out;
2784}
2785
2786int reiserfs_commit_write(struct file *f, struct page *page,
2787 unsigned from, unsigned to)
2788{
2789 struct inode *inode = page->mapping->host;
2790 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2791 int ret = 0;
2792 int update_sd = 0;
2793 struct reiserfs_transaction_handle *th = NULL;
2794
2795 reiserfs_write_unlock(inode->i_sb);
2796 reiserfs_wait_on_write_block(inode->i_sb);
2797 reiserfs_write_lock(inode->i_sb);
2798
2799 if (reiserfs_transaction_running(inode->i_sb)) {
2800 th = current->journal_info;
2801 }
2802 reiserfs_commit_page(inode, page, from, to);
2803
2804
2805
2806
2807
2808 if (pos > inode->i_size) {
2809 struct reiserfs_transaction_handle myth;
2810
2811
2812
2813 if ((have_large_tails(inode->i_sb)
2814 && inode->i_size > i_block_size(inode) * 4)
2815 || (have_small_tails(inode->i_sb)
2816 && inode->i_size > i_block_size(inode)))
2817 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2818
2819 ret = journal_begin(&myth, inode->i_sb, 1);
2820 if (ret)
2821 goto journal_error;
2822
2823 reiserfs_update_inode_transaction(inode);
2824 inode->i_size = pos;
2825
2826
2827
2828
2829
2830 mark_inode_dirty(inode);
2831 reiserfs_update_sd(&myth, inode);
2832 update_sd = 1;
2833 ret = journal_end(&myth, inode->i_sb, 1);
2834 if (ret)
2835 goto journal_error;
2836 }
2837 if (th) {
2838 if (!update_sd)
2839 mark_inode_dirty(inode);
2840 ret = reiserfs_end_persistent_transaction(th);
2841 if (ret)
2842 goto out;
2843 }
2844
2845 out:
2846 return ret;
2847
2848 journal_error:
2849 if (th) {
2850 if (!update_sd)
2851 reiserfs_update_sd(th, inode);
2852 ret = reiserfs_end_persistent_transaction(th);
2853 }
2854
2855 return ret;
2856}
2857
2858void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2859{
2860 if (reiserfs_attrs(inode->i_sb)) {
2861 if (sd_attrs & REISERFS_SYNC_FL)
2862 inode->i_flags |= S_SYNC;
2863 else
2864 inode->i_flags &= ~S_SYNC;
2865 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2866 inode->i_flags |= S_IMMUTABLE;
2867 else
2868 inode->i_flags &= ~S_IMMUTABLE;
2869 if (sd_attrs & REISERFS_APPEND_FL)
2870 inode->i_flags |= S_APPEND;
2871 else
2872 inode->i_flags &= ~S_APPEND;
2873 if (sd_attrs & REISERFS_NOATIME_FL)
2874 inode->i_flags |= S_NOATIME;
2875 else
2876 inode->i_flags &= ~S_NOATIME;
2877 if (sd_attrs & REISERFS_NOTAIL_FL)
2878 REISERFS_I(inode)->i_flags |= i_nopack_mask;
2879 else
2880 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2881 }
2882}
2883
2884void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
2885{
2886 if (reiserfs_attrs(inode->i_sb)) {
2887 if (inode->i_flags & S_IMMUTABLE)
2888 *sd_attrs |= REISERFS_IMMUTABLE_FL;
2889 else
2890 *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
2891 if (inode->i_flags & S_SYNC)
2892 *sd_attrs |= REISERFS_SYNC_FL;
2893 else
2894 *sd_attrs &= ~REISERFS_SYNC_FL;
2895 if (inode->i_flags & S_NOATIME)
2896 *sd_attrs |= REISERFS_NOATIME_FL;
2897 else
2898 *sd_attrs &= ~REISERFS_NOATIME_FL;
2899 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
2900 *sd_attrs |= REISERFS_NOTAIL_FL;
2901 else
2902 *sd_attrs &= ~REISERFS_NOTAIL_FL;
2903 }
2904}
2905
2906
2907
2908
2909static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2910{
2911 int ret = 1;
2912 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2913
2914 lock_buffer(bh);
2915 spin_lock(&j->j_dirty_buffers_lock);
2916 if (!buffer_mapped(bh)) {
2917 goto free_jh;
2918 }
2919
2920
2921
2922 if (reiserfs_file_data_log(inode)) {
2923
2924
2925
2926
2927 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2928 ret = 0;
2929 }
2930 } else if (buffer_dirty(bh)) {
2931 struct reiserfs_journal_list *jl;
2932 struct reiserfs_jh *jh = bh->b_private;
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947 if (jh && (jl = jh->jl)
2948 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2949 ret = 0;
2950 }
2951 free_jh:
2952 if (ret && bh->b_private) {
2953 reiserfs_free_jh(bh);
2954 }
2955 spin_unlock(&j->j_dirty_buffers_lock);
2956 unlock_buffer(bh);
2957 return ret;
2958}
2959
2960
2961static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
2962{
2963 struct buffer_head *head, *bh, *next;
2964 struct inode *inode = page->mapping->host;
2965 unsigned int curr_off = 0;
2966 int ret = 1;
2967
2968 BUG_ON(!PageLocked(page));
2969
2970 if (offset == 0)
2971 ClearPageChecked(page);
2972
2973 if (!page_has_buffers(page))
2974 goto out;
2975
2976 head = page_buffers(page);
2977 bh = head;
2978 do {
2979 unsigned int next_off = curr_off + bh->b_size;
2980 next = bh->b_this_page;
2981
2982
2983
2984
2985 if (offset <= curr_off) {
2986 if (invalidatepage_can_drop(inode, bh))
2987 reiserfs_unmap_buffer(bh);
2988 else
2989 ret = 0;
2990 }
2991 curr_off = next_off;
2992 bh = next;
2993 } while (bh != head);
2994
2995
2996
2997
2998
2999
3000 if (!offset && ret) {
3001 ret = try_to_release_page(page, 0);
3002
3003 }
3004 out:
3005 return;
3006}
3007
3008static int reiserfs_set_page_dirty(struct page *page)
3009{
3010 struct inode *inode = page->mapping->host;
3011 if (reiserfs_file_data_log(inode)) {
3012 SetPageChecked(page);
3013 return __set_page_dirty_nobuffers(page);
3014 }
3015 return __set_page_dirty_buffers(page);
3016}
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027static int reiserfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
3028{
3029 struct inode *inode = page->mapping->host;
3030 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
3031 struct buffer_head *head;
3032 struct buffer_head *bh;
3033 int ret = 1;
3034
3035 WARN_ON(PageChecked(page));
3036 spin_lock(&j->j_dirty_buffers_lock);
3037 head = page_buffers(page);
3038 bh = head;
3039 do {
3040 if (bh->b_private) {
3041 if (!buffer_dirty(bh) && !buffer_locked(bh)) {
3042 reiserfs_free_jh(bh);
3043 } else {
3044 ret = 0;
3045 break;
3046 }
3047 }
3048 bh = bh->b_this_page;
3049 } while (bh != head);
3050 if (ret)
3051 ret = try_to_free_buffers(page);
3052 spin_unlock(&j->j_dirty_buffers_lock);
3053 return ret;
3054}
3055
3056
3057
3058static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
3059 const struct iovec *iov, loff_t offset,
3060 unsigned long nr_segs)
3061{
3062 struct file *file = iocb->ki_filp;
3063 struct inode *inode = file->f_mapping->host;
3064 ssize_t ret;
3065
3066 ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
3067 offset, nr_segs,
3068 reiserfs_get_blocks_direct_io, NULL);
3069
3070
3071
3072
3073
3074 if (unlikely((rw & WRITE) && ret < 0)) {
3075 loff_t isize = i_size_read(inode);
3076 loff_t end = offset + iov_length(iov, nr_segs);
3077
3078 if (end > isize)
3079 vmtruncate(inode, isize);
3080 }
3081
3082 return ret;
3083}
3084
3085int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
3086{
3087 struct inode *inode = dentry->d_inode;
3088 unsigned int ia_valid;
3089 int depth;
3090 int error;
3091
3092 error = inode_change_ok(inode, attr);
3093 if (error)
3094 return error;
3095
3096
3097 ia_valid = attr->ia_valid &= ~(ATTR_KILL_SUID|ATTR_KILL_SGID);
3098
3099 depth = reiserfs_write_lock_once(inode->i_sb);
3100 if (is_quota_modification(inode, attr))
3101 dquot_initialize(inode);
3102
3103 if (attr->ia_valid & ATTR_SIZE) {
3104
3105
3106
3107 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
3108 attr->ia_size > MAX_NON_LFS) {
3109 error = -EFBIG;
3110 goto out;
3111 }
3112
3113 if (attr->ia_size > inode->i_size) {
3114 error = generic_cont_expand_simple(inode, attr->ia_size);
3115 if (REISERFS_I(inode)->i_prealloc_count > 0) {
3116 int err;
3117 struct reiserfs_transaction_handle th;
3118
3119 err = journal_begin(&th, inode->i_sb, 4);
3120 if (!err) {
3121 reiserfs_discard_prealloc(&th, inode);
3122 err = journal_end(&th, inode->i_sb, 4);
3123 }
3124 if (err)
3125 error = err;
3126 }
3127 if (error)
3128 goto out;
3129
3130
3131
3132
3133 attr->ia_valid |= (ATTR_MTIME | ATTR_CTIME);
3134 }
3135 }
3136
3137 if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||
3138 ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&
3139 (get_inode_sd_version(inode) == STAT_DATA_V1)) {
3140
3141 error = -EINVAL;
3142 goto out;
3143 }
3144
3145 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
3146 (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
3147 struct reiserfs_transaction_handle th;
3148 int jbegin_count =
3149 2 *
3150 (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
3151 REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
3152 2;
3153
3154 error = reiserfs_chown_xattrs(inode, attr);
3155
3156 if (error)
3157 return error;
3158
3159
3160 error = journal_begin(&th, inode->i_sb, jbegin_count);
3161 if (error)
3162 goto out;
3163 error = dquot_transfer(inode, attr);
3164 if (error) {
3165 journal_end(&th, inode->i_sb, jbegin_count);
3166 goto out;
3167 }
3168
3169
3170
3171 if (attr->ia_valid & ATTR_UID)
3172 inode->i_uid = attr->ia_uid;
3173 if (attr->ia_valid & ATTR_GID)
3174 inode->i_gid = attr->ia_gid;
3175 mark_inode_dirty(inode);
3176 error = journal_end(&th, inode->i_sb, jbegin_count);
3177 if (error)
3178 goto out;
3179 }
3180
3181
3182
3183
3184
3185
3186
3187 reiserfs_write_unlock_once(inode->i_sb, depth);
3188 if ((attr->ia_valid & ATTR_SIZE) &&
3189 attr->ia_size != i_size_read(inode))
3190 error = vmtruncate(inode, attr->ia_size);
3191
3192 if (!error) {
3193 setattr_copy(inode, attr);
3194 mark_inode_dirty(inode);
3195 }
3196 depth = reiserfs_write_lock_once(inode->i_sb);
3197
3198 if (!error && reiserfs_posixacl(inode->i_sb)) {
3199 if (attr->ia_valid & ATTR_MODE)
3200 error = reiserfs_acl_chmod(inode);
3201 }
3202
3203 out:
3204 reiserfs_write_unlock_once(inode->i_sb, depth);
3205
3206 return error;
3207}
3208
3209const struct address_space_operations reiserfs_address_space_operations = {
3210 .writepage = reiserfs_writepage,
3211 .readpage = reiserfs_readpage,
3212 .readpages = reiserfs_readpages,
3213 .releasepage = reiserfs_releasepage,
3214 .invalidatepage = reiserfs_invalidatepage,
3215 .sync_page = block_sync_page,
3216 .write_begin = reiserfs_write_begin,
3217 .write_end = reiserfs_write_end,
3218 .bmap = reiserfs_aop_bmap,
3219 .direct_IO = reiserfs_direct_IO,
3220 .set_page_dirty = reiserfs_set_page_dirty,
3221};
3222