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