2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
5 #include <linux/time.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>
23 int reiserfs_commit_write(struct file *f, struct page *page,
24 unsigned from, unsigned to);
26 void reiserfs_evict_inode(struct inode *inode)
28 /* We need blocks for transaction + (user+group) quota update (possibly delete) */
30 JOURNAL_PER_BALANCE_CNT * 2 +
31 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
32 struct reiserfs_transaction_handle th;
35 if (!inode->i_nlink && !is_bad_inode(inode))
36 dquot_initialize(inode);
38 truncate_inode_pages_final(&inode->i_data);
42 /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
43 if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) { /* also handles bad_inode case */
45 reiserfs_delete_xattrs(inode);
47 reiserfs_write_lock(inode->i_sb);
49 if (journal_begin(&th, inode->i_sb, jbegin_count))
51 reiserfs_update_inode_transaction(inode);
53 reiserfs_discard_prealloc(&th, inode);
55 err = reiserfs_delete_object(&th, inode);
57 /* Do quota update inside a transaction for journaled quotas. We must do that
58 * after delete_object so that quota updates go into the same transaction as
59 * stat data deletion */
61 int depth = reiserfs_write_unlock_nested(inode->i_sb);
62 dquot_free_inode(inode);
63 reiserfs_write_lock_nested(inode->i_sb, depth);
66 if (journal_end(&th, inode->i_sb, jbegin_count))
69 /* check return value from reiserfs_delete_object after
70 * ending the transaction
75 /* all items of file are deleted, so we can remove "save" link */
76 remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything
77 * about an error here */
79 reiserfs_write_unlock(inode->i_sb);
81 /* no object items are in the tree */
84 clear_inode(inode); /* note this must go after the journal_end to prevent deadlock */
94 static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
95 __u32 objectid, loff_t offset, int type, int length)
97 key->version = version;
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;
106 /* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set
107 offset and type of key */
108 void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
109 int type, int length)
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,
118 // when key is 0, do not set version and short key
120 inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
122 loff_t offset, int type, int length,
123 int entry_count /*or ih_free_space */ )
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);
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 /* set_ih_free_space (ih, 0); */
135 // for directory items it is entry count, for directs and stat
136 // datas - 0xffff, for indirects - 0
137 put_ih_entry_count(ih, entry_count);
141 // FIXME: we might cache recently accessed indirect item
143 // Ugh. Not too eager for that....
144 // I cut the code until such time as I see a convincing argument (benchmark).
145 // I don't want a bloated inode struct..., and I don't like code complexity....
147 /* cutting the code is fine, since it really isn't in use yet and is easy
148 ** to add back in. But, Vladimir has a really good idea here. Think
149 ** about what happens for reading a file. For each page,
150 ** The VFS layer calls reiserfs_readpage, who searches the tree to find
151 ** an indirect item. This indirect item has X number of pointers, where
152 ** X is a big number if we've done the block allocation right. But,
153 ** we only use one or two of these pointers during each call to readpage,
154 ** needlessly researching again later on.
156 ** The size of the cache could be dynamic based on the size of the file.
158 ** I'd also like to see us cache the location the stat data item, since
159 ** we are needlessly researching for that frequently.
164 /* If this page has a file tail in it, and
165 ** it was read in by get_block_create_0, the page data is valid,
166 ** but tail is still sitting in a direct item, and we can't write to
167 ** it. So, look through this page, and check all the mapped buffers
168 ** to make sure they have valid block numbers. Any that don't need
169 ** to be unmapped, so that __block_write_begin will correctly call
170 ** reiserfs_get_block to convert the tail into an unformatted node
172 static inline void fix_tail_page_for_writing(struct page *page)
174 struct buffer_head *head, *next, *bh;
176 if (page && page_has_buffers(page)) {
177 head = page_buffers(page);
180 next = bh->b_this_page;
181 if (buffer_mapped(bh) && bh->b_blocknr == 0) {
182 reiserfs_unmap_buffer(bh);
185 } while (bh != head);
189 /* reiserfs_get_block does not need to allocate a block only if it has been
190 done already or non-hole position has been found in the indirect item */
191 static inline int allocation_needed(int retval, b_blocknr_t allocated,
192 struct item_head *ih,
193 __le32 * item, int pos_in_item)
197 if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
198 get_block_num(item, pos_in_item))
203 static inline int indirect_item_found(int retval, struct item_head *ih)
205 return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
208 static inline void set_block_dev_mapped(struct buffer_head *bh,
209 b_blocknr_t block, struct inode *inode)
211 map_bh(bh, inode->i_sb, block);
215 // files which were created in the earlier version can not be longer,
218 static int file_capable(struct inode *inode, sector_t block)
220 if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 || // it is new file.
221 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) // old file, but 'block' is inside of 2gb
227 static int restart_transaction(struct reiserfs_transaction_handle *th,
228 struct inode *inode, struct treepath *path)
230 struct super_block *s = th->t_super;
231 int len = th->t_blocks_allocated;
234 BUG_ON(!th->t_trans_id);
235 BUG_ON(!th->t_refcount);
239 /* we cannot restart while nested */
240 if (th->t_refcount > 1) {
243 reiserfs_update_sd(th, inode);
244 err = journal_end(th, s, len);
246 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
248 reiserfs_update_inode_transaction(inode);
253 // it is called by get_block when create == 0. Returns block number
254 // for 'block'-th logical block of file. When it hits direct item it
255 // returns 0 (being called from bmap) or read direct item into piece
256 // of page (bh_result)
258 // Please improve the english/clarity in the comment above, as it is
259 // hard to understand.
261 static int _get_block_create_0(struct inode *inode, sector_t block,
262 struct buffer_head *bh_result, int args)
264 INITIALIZE_PATH(path);
266 struct buffer_head *bh;
267 struct item_head *ih, tmp_ih;
274 unsigned long offset;
276 // prepare the key to look for the 'block'-th block of file
277 make_cpu_key(&key, inode,
278 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
281 result = search_for_position_by_key(inode->i_sb, &key, &path);
282 if (result != POSITION_FOUND) {
285 kunmap(bh_result->b_page);
286 if (result == IO_ERROR)
288 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
289 // That there is some MMAPED data associated with it that is yet to be written to disk.
290 if ((args & GET_BLOCK_NO_HOLE)
291 && !PageUptodate(bh_result->b_page)) {
297 bh = get_last_bh(&path);
299 if (is_indirect_le_ih(ih)) {
300 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
302 /* FIXME: here we could cache indirect item or part of it in
303 the inode to avoid search_by_key in case of subsequent
305 blocknr = get_block_num(ind_item, path.pos_in_item);
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);
314 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
315 // That there is some MMAPED data associated with it that is yet to be written to disk.
316 if ((args & GET_BLOCK_NO_HOLE)
317 && !PageUptodate(bh_result->b_page)) {
323 kunmap(bh_result->b_page);
326 // requested data are in direct item(s)
327 if (!(args & GET_BLOCK_READ_DIRECT)) {
328 // we are called by bmap. FIXME: we can not map block of file
329 // when it is stored in direct item(s)
332 kunmap(bh_result->b_page);
336 /* if we've got a direct item, and the buffer or page was uptodate,
337 ** we don't want to pull data off disk again. skip to the
338 ** end, where we map the buffer and return
340 if (buffer_uptodate(bh_result)) {
344 ** grab_tail_page can trigger calls to reiserfs_get_block on up to date
345 ** pages without any buffers. If the page is up to date, we don't want
346 ** read old data off disk. Set the up to date bit on the buffer instead
347 ** and jump to the end
349 if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
350 set_buffer_uptodate(bh_result);
353 // read file tail into part of page
354 offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
355 copy_item_head(&tmp_ih, ih);
357 /* we only want to kmap if we are reading the tail into the page.
358 ** this is not the common case, so we don't kmap until we are
359 ** sure we need to. But, this means the item might move if
363 p = (char *)kmap(bh_result->b_page);
366 memset(p, 0, inode->i_sb->s_blocksize);
368 if (!is_direct_le_ih(ih)) {
371 /* make sure we don't read more bytes than actually exist in
372 ** the file. This can happen in odd cases where i_size isn't
373 ** correct, and when direct item padding results in a few
374 ** extra bytes at the end of the direct item
376 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
378 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
380 inode->i_size - (le_ih_k_offset(ih) - 1) -
384 chars = ih_item_len(ih) - path.pos_in_item;
386 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
393 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
394 // we done, if read direct item is not the last item of
395 // node FIXME: we could try to check right delimiting key
396 // to see whether direct item continues in the right
397 // neighbor or rely on i_size
400 // update key to look for the next piece
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 // i/o error most likely
406 bh = get_last_bh(&path);
410 flush_dcache_page(bh_result->b_page);
411 kunmap(bh_result->b_page);
416 if (result == IO_ERROR)
419 /* this buffer has valid data, but isn't valid for io. mapping it to
420 * block #0 tells the rest of reiserfs it just has a tail in it
422 map_bh(bh_result, inode->i_sb, 0);
423 set_buffer_uptodate(bh_result);
427 // this is called to create file map. So, _get_block_create_0 will not
429 static int reiserfs_bmap(struct inode *inode, sector_t block,
430 struct buffer_head *bh_result, int create)
432 if (!file_capable(inode, block))
435 reiserfs_write_lock(inode->i_sb);
436 /* do not read the direct item */
437 _get_block_create_0(inode, block, bh_result, 0);
438 reiserfs_write_unlock(inode->i_sb);
442 /* special version of get_block that is only used by grab_tail_page right
443 ** now. It is sent to __block_write_begin, and when you try to get a
444 ** block past the end of the file (or a block from a hole) it returns
445 ** -ENOENT instead of a valid buffer. __block_write_begin expects to
446 ** be able to do i/o on the buffers returned, unless an error value
449 ** So, this allows __block_write_begin to be used for reading a single block
450 ** in a page. Where it does not produce a valid page for holes, or past the
451 ** end of the file. This turns out to be exactly what we need for reading
452 ** tails for conversion.
454 ** The point of the wrapper is forcing a certain value for create, even
455 ** though the VFS layer is calling this function with create==1. If you
456 ** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
457 ** don't use this function.
459 static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
460 struct buffer_head *bh_result,
463 return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
466 /* This is special helper for reiserfs_get_block in case we are executing
467 direct_IO request. */
468 static int reiserfs_get_blocks_direct_io(struct inode *inode,
470 struct buffer_head *bh_result,
475 bh_result->b_page = NULL;
477 /* We set the b_size before reiserfs_get_block call since it is
478 referenced in convert_tail_for_hole() that may be called from
479 reiserfs_get_block() */
480 bh_result->b_size = (1 << inode->i_blkbits);
482 ret = reiserfs_get_block(inode, iblock, bh_result,
483 create | GET_BLOCK_NO_DANGLE);
487 /* don't allow direct io onto tail pages */
488 if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
489 /* make sure future calls to the direct io funcs for this offset
490 ** in the file fail by unmapping the buffer
492 clear_buffer_mapped(bh_result);
495 /* Possible unpacked tail. Flush the data before pages have
497 if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
500 reiserfs_write_lock(inode->i_sb);
502 err = reiserfs_commit_for_inode(inode);
503 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
505 reiserfs_write_unlock(inode->i_sb);
515 ** helper function for when reiserfs_get_block is called for a hole
516 ** but the file tail is still in a direct item
517 ** bh_result is the buffer head for the hole
518 ** tail_offset is the offset of the start of the tail in the file
520 ** This calls prepare_write, which will start a new transaction
521 ** you should not be in a transaction, or have any paths held when you
524 static int convert_tail_for_hole(struct inode *inode,
525 struct buffer_head *bh_result,
529 unsigned long tail_end;
530 unsigned long tail_start;
531 struct page *tail_page;
532 struct page *hole_page = bh_result->b_page;
535 if ((tail_offset & (bh_result->b_size - 1)) != 1)
538 /* always try to read until the end of the block */
539 tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
540 tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
542 index = tail_offset >> PAGE_CACHE_SHIFT;
543 /* hole_page can be zero in case of direct_io, we are sure
544 that we cannot get here if we write with O_DIRECT into
546 if (!hole_page || index != hole_page->index) {
547 tail_page = grab_cache_page(inode->i_mapping, index);
553 tail_page = hole_page;
556 /* we don't have to make sure the conversion did not happen while
557 ** we were locking the page because anyone that could convert
558 ** must first take i_mutex.
560 ** We must fix the tail page for writing because it might have buffers
561 ** that are mapped, but have a block number of 0. This indicates tail
562 ** data that has been read directly into the page, and
563 ** __block_write_begin won't trigger a get_block in this case.
565 fix_tail_page_for_writing(tail_page);
566 retval = __reiserfs_write_begin(tail_page, tail_start,
567 tail_end - tail_start);
571 /* tail conversion might change the data in the page */
572 flush_dcache_page(tail_page);
574 retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
577 if (tail_page != hole_page) {
578 unlock_page(tail_page);
579 page_cache_release(tail_page);
585 static inline int _allocate_block(struct reiserfs_transaction_handle *th,
588 b_blocknr_t * allocated_block_nr,
589 struct treepath *path, int flags)
591 BUG_ON(!th->t_trans_id);
593 #ifdef REISERFS_PREALLOCATE
594 if (!(flags & GET_BLOCK_NO_IMUX)) {
595 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
599 return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
603 int reiserfs_get_block(struct inode *inode, sector_t block,
604 struct buffer_head *bh_result, int create)
606 int repeat, retval = 0;
607 b_blocknr_t allocated_block_nr = 0; // b_blocknr_t is (unsigned) 32 bit int
608 INITIALIZE_PATH(path);
611 struct buffer_head *bh, *unbh = NULL;
612 struct item_head *ih, tmp_ih;
616 struct reiserfs_transaction_handle *th = NULL;
617 /* space reserved in transaction batch:
618 . 3 balancings in direct->indirect conversion
619 . 1 block involved into reiserfs_update_sd()
620 XXX in practically impossible worst case direct2indirect()
621 can incur (much) more than 3 balancings.
622 quota update for user, group */
624 JOURNAL_PER_BALANCE_CNT * 3 + 1 +
625 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
629 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
631 reiserfs_write_lock(inode->i_sb);
632 version = get_inode_item_key_version(inode);
634 if (!file_capable(inode, block)) {
635 reiserfs_write_unlock(inode->i_sb);
639 /* if !create, we aren't changing the FS, so we don't need to
640 ** log anything, so we don't need to start a transaction
642 if (!(create & GET_BLOCK_CREATE)) {
644 /* find number of block-th logical block of the file */
645 ret = _get_block_create_0(inode, block, bh_result,
646 create | GET_BLOCK_READ_DIRECT);
647 reiserfs_write_unlock(inode->i_sb);
651 * if we're already in a transaction, make sure to close
652 * any new transactions we start in this func
654 if ((create & GET_BLOCK_NO_DANGLE) ||
655 reiserfs_transaction_running(inode->i_sb))
658 /* If file is of such a size, that it might have a tail and tails are enabled
659 ** we should mark it as possibly needing tail packing on close
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;
667 /* set the key of the first byte in the 'block'-th block of file */
668 make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
669 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
671 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
676 reiserfs_update_inode_transaction(inode);
680 retval = search_for_position_by_key(inode->i_sb, &key, &path);
681 if (retval == IO_ERROR) {
686 bh = get_last_bh(&path);
688 item = get_item(&path);
689 pos_in_item = path.pos_in_item;
691 fs_gen = get_generation(inode->i_sb);
692 copy_item_head(&tmp_ih, ih);
694 if (allocation_needed
695 (retval, allocated_block_nr, ih, item, pos_in_item)) {
696 /* we have to allocate block for the unformatted node */
703 _allocate_block(th, block, inode, &allocated_block_nr,
706 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
707 /* restart the transaction to give the journal a chance to free
708 ** some blocks. releases the path, so we have to go back to
709 ** research if we succeed on the second try
711 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
712 retval = restart_transaction(th, inode, &path);
716 _allocate_block(th, block, inode,
717 &allocated_block_nr, NULL, create);
719 if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
722 if (repeat == QUOTA_EXCEEDED)
729 if (fs_changed(fs_gen, inode->i_sb)
730 && item_moved(&tmp_ih, &path)) {
735 if (indirect_item_found(retval, ih)) {
736 b_blocknr_t unfm_ptr;
737 /* 'block'-th block is in the file already (there is
738 corresponding cell in some indirect item). But it may be
739 zero unformatted node pointer (hole) */
740 unfm_ptr = get_block_num(item, pos_in_item);
742 /* use allocated block to plug the hole */
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,
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);
759 set_block_dev_mapped(bh_result, unfm_ptr, inode);
763 retval = reiserfs_end_persistent_transaction(th);
765 reiserfs_write_unlock(inode->i_sb);
767 /* the item was found, so new blocks were not added to the file
768 ** there is no need to make sure the inode is updated with this
779 /* desired position is not found or is in the direct item. We have
780 to append file with holes up to 'block'-th block converting
781 direct items to indirect one if necessary */
784 if (is_statdata_le_ih(ih)) {
786 struct cpu_key tmp_key;
788 /* indirect item has to be inserted */
789 make_le_item_head(&tmp_ih, &key, version, 1,
790 TYPE_INDIRECT, UNFM_P_SIZE,
791 0 /* free_space */ );
793 if (cpu_key_k_offset(&key) == 1) {
794 /* we are going to add 'block'-th block to the file. Use
795 allocated block for that */
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);
803 set_cpu_key_k_offset(&tmp_key, 1);
804 PATH_LAST_POSITION(&path)++;
807 reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
808 inode, (char *)&unp);
810 reiserfs_free_block(th, inode,
811 allocated_block_nr, 1);
812 goto failure; // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
814 //mark_tail_converted (inode);
815 } else if (is_direct_le_ih(ih)) {
816 /* direct item has to be converted */
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 /* direct item we just found fits into block we have
824 to map. Convert it into unformatted node: use
825 bh_result for the conversion */
826 set_block_dev_mapped(bh_result,
827 allocated_block_nr, inode);
831 /* we have to padd file tail stored in direct item(s)
832 up to block size and convert it to unformatted
833 node. FIXME: this should also get into page cache */
837 * ugly, but we can only end the transaction if
840 BUG_ON(!th->t_refcount);
841 if (th->t_refcount == 1) {
843 reiserfs_end_persistent_transaction
851 convert_tail_for_hole(inode, bh_result,
854 if (retval != -ENOSPC)
855 reiserfs_error(inode->i_sb,
857 "convert tail failed "
858 "inode %lu, error %d",
861 if (allocated_block_nr) {
862 /* the bitmap, the super, and the stat data == 3 */
864 th = reiserfs_persistent_transaction(inode->i_sb, 3);
866 reiserfs_free_block(th,
876 direct2indirect(th, inode, &path, unbh,
879 reiserfs_unmap_buffer(unbh);
880 reiserfs_free_block(th, inode,
881 allocated_block_nr, 1);
884 /* it is important the set_buffer_uptodate is done after
885 ** the direct2indirect. The buffer might contain valid
886 ** data newer than the data on disk (read by readpage, changed,
887 ** and then sent here by writepage). direct2indirect needs
888 ** to know if unbh was already up to date, so it can decide
889 ** if the data in unbh needs to be replaced with data from
892 set_buffer_uptodate(unbh);
894 /* unbh->b_page == NULL in case of DIRECT_IO request, this means
895 buffer will disappear shortly, so it should not be added to
898 /* we've converted the tail, so we must
899 ** flush unbh before the transaction commits
901 reiserfs_add_tail_list(inode, unbh);
903 /* mark it dirty now to prevent commit_write from adding
904 ** this buffer to the inode's dirty buffer list
907 * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
908 * It's still atomic, but it sets the page dirty too,
909 * which makes it eligible for writeback at any time by the
910 * VM (which was also the case with __mark_buffer_dirty())
912 mark_buffer_dirty(unbh);
915 /* append indirect item with holes if needed, when appending
916 pointer to 'block'-th block use block, which is already
918 struct cpu_key tmp_key;
919 unp_t unf_single = 0; // We use this in case we need to allocate only
920 // one block which is a fastpath
922 __u64 max_to_insert =
923 MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
927 RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
928 "vs-804: invalid position for append");
929 /* indirect item has to be appended, set up key of that position */
930 make_cpu_key(&tmp_key, inode,
931 le_key_k_offset(version,
934 inode->i_sb->s_blocksize),
935 //pos_in_item * inode->i_sb->s_blocksize,
936 TYPE_INDIRECT, 3); // key type is unimportant
938 RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),
939 "green-805: invalid offset");
942 ((cpu_key_k_offset(&key) -
943 cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
946 if (blocks_needed == 1) {
949 un = kzalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_NOFS);
956 if (blocks_needed <= max_to_insert) {
957 /* we are going to add target block to the file. Use allocated
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);
966 /* paste hole to the indirect item */
967 /* If kmalloc failed, max_to_insert becomes zero and it means we
968 only have space for one block */
970 max_to_insert ? max_to_insert : 1;
973 reiserfs_paste_into_item(th, &path, &tmp_key, inode,
978 if (blocks_needed != 1)
982 reiserfs_free_block(th, inode,
983 allocated_block_nr, 1);
987 /* We need to mark new file size in case this function will be
988 interrupted/aborted later on. And we may do this only for
991 inode->i_sb->s_blocksize * blocks_needed;
998 /* this loop could log more blocks than we had originally asked
999 ** for. So, we have to allow the transaction to end if it is
1000 ** too big or too full. Update the inode so things are
1001 ** consistent if we crash before the function returns
1003 ** release the path so that anybody waiting on the path before
1004 ** ending their transaction will be able to continue.
1006 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
1007 retval = restart_transaction(th, inode, &path);
1012 * inserting indirect pointers for a hole can take a
1013 * long time. reschedule if needed and also release the write
1016 reiserfs_cond_resched(inode->i_sb);
1018 retval = search_for_position_by_key(inode->i_sb, &key, &path);
1019 if (retval == IO_ERROR) {
1023 if (retval == POSITION_FOUND) {
1024 reiserfs_warning(inode->i_sb, "vs-825",
1025 "%K should not be found", &key);
1027 if (allocated_block_nr)
1028 reiserfs_free_block(th, inode,
1029 allocated_block_nr, 1);
1033 bh = get_last_bh(&path);
1035 item = get_item(&path);
1036 pos_in_item = path.pos_in_item;
1042 if (th && (!dangle || (retval && !th->t_trans_id))) {
1045 reiserfs_update_sd(th, inode);
1046 err = reiserfs_end_persistent_transaction(th);
1051 reiserfs_write_unlock(inode->i_sb);
1052 reiserfs_check_path(&path);
1057 reiserfs_readpages(struct file *file, struct address_space *mapping,
1058 struct list_head *pages, unsigned nr_pages)
1060 return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
1063 /* Compute real number of used bytes by file
1064 * Following three functions can go away when we'll have enough space in stat item
1066 static int real_space_diff(struct inode *inode, int sd_size)
1069 loff_t blocksize = inode->i_sb->s_blocksize;
1071 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1074 /* End of file is also in full block with indirect reference, so round
1075 ** up to the next block.
1077 ** there is just no way to know if the tail is actually packed
1078 ** on the file, so we have to assume it isn't. When we pack the
1079 ** tail, we add 4 bytes to pretend there really is an unformatted
1084 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1089 static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
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));
1096 return ((loff_t) real_space_diff(inode, sd_size)) +
1097 (((loff_t) blocks) << 9);
1100 /* Compute number of blocks used by file in ReiserFS counting */
1101 static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1103 loff_t bytes = inode_get_bytes(inode);
1104 loff_t real_space = real_space_diff(inode, sd_size);
1106 /* keeps fsck and non-quota versions of reiserfs happy */
1107 if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1108 bytes += (loff_t) 511;
1111 /* files from before the quota patch might i_blocks such that
1112 ** bytes < real_space. Deal with that here to prevent it from
1115 if (bytes < real_space)
1117 return (bytes - real_space) >> 9;
1121 // BAD: new directories have stat data of new type and all other items
1122 // of old type. Version stored in the inode says about body items, so
1123 // in update_stat_data we can not rely on inode, but have to check
1124 // item version directly
1127 // called by read_locked_inode
1128 static void init_inode(struct inode *inode, struct treepath *path)
1130 struct buffer_head *bh;
1131 struct item_head *ih;
1133 //int version = ITEM_VERSION_1;
1135 bh = PATH_PLAST_BUFFER(path);
1136 ih = PATH_PITEM_HEAD(path);
1138 copy_key(INODE_PKEY(inode), &(ih->ih_key));
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);
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;
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;
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 // there was a bug in <=3.5.23 when i_blocks could take negative
1173 // values. Starting from 3.5.17 this value could even be stored in
1174 // stat data. For such files we set i_blocks based on file
1175 // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be
1176 // only updated if file's inode will ever change
1177 inode->i_blocks = blocks;
1180 rdev = sd_v1_rdev(sd);
1181 REISERFS_I(inode)->i_first_direct_byte =
1182 sd_v1_first_direct_byte(sd);
1183 /* an early bug in the quota code can give us an odd number for the
1184 ** block count. This is incorrect, fix it here.
1186 if (inode->i_blocks & 1) {
1189 inode_set_bytes(inode,
1190 to_real_used_space(inode, inode->i_blocks,
1192 /* nopack is initially zero for v1 objects. For v2 objects,
1193 nopack is initialised from sd_attrs */
1194 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1196 // new stat data found, but object may have old items
1197 // (directories and symlinks)
1198 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
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);
1217 inode->i_generation = sd_v2_generation(sd);
1219 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1220 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
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,
1228 /* read persistent inode attributes from sd and initialise
1229 generic inode flags from them */
1230 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1231 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
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;
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));
1252 // update new stat data with inode fields
1253 static void inode2sd(void *sd, struct inode *inode, loff_t size)
1255 struct stat_data *sd_v2 = (struct stat_data *)sd;
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));
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);
1276 // used to copy inode's fields to old stat data
1277 static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
1279 struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
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);
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));
1293 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
1295 // Sigh. i_first_direct_byte is back
1296 set_sd_v1_first_direct_byte(sd_v1,
1297 REISERFS_I(inode)->i_first_direct_byte);
1300 /* NOTE, you must prepare the buffer head before sending it here,
1301 ** and then log it after the call
1303 static void update_stat_data(struct treepath *path, struct inode *inode,
1306 struct buffer_head *bh;
1307 struct item_head *ih;
1309 bh = PATH_PLAST_BUFFER(path);
1310 ih = PATH_PITEM_HEAD(path);
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);
1316 if (stat_data_v1(ih)) {
1317 // path points to old stat data
1318 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1320 inode2sd(B_I_PITEM(bh, ih), inode, size);
1326 void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1327 struct inode *inode, loff_t size)
1330 INITIALIZE_PATH(path);
1331 struct buffer_head *bh;
1333 struct item_head *ih, tmp_ih;
1336 BUG_ON(!th->t_trans_id);
1338 make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3); //key type is unimportant
1342 /* look for the object's stat data */
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);
1350 if (retval == ITEM_NOT_FOUND) {
1351 pos = PATH_LAST_POSITION(&path);
1353 if (inode->i_nlink == 0) {
1354 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
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,
1362 reiserfs_check_path(&path);
1366 /* sigh, prepare_for_journal might schedule. When it schedules the
1367 ** FS might change. We have to detect that, and loop back to the
1368 ** search if the stat data item has moved
1370 bh = get_last_bh(&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; /* Stat_data item has been moved after scheduling. */
1382 update_stat_data(&path, inode, size);
1383 journal_mark_dirty(th, th->t_super, bh);
1388 /* reiserfs_read_locked_inode is called to read the inode off disk, and it
1389 ** does a make_bad_inode when things go wrong. But, we need to make sure
1390 ** and clear the key in the private portion of the inode, otherwise a
1391 ** corresponding iput might try to delete whatever object the inode last
1394 static void reiserfs_make_bad_inode(struct inode *inode)
1396 memset(INODE_PKEY(inode), 0, KEY_SIZE);
1397 make_bad_inode(inode);
1401 // initially this function was derived from minix or ext2's analog and
1402 // evolved as the prototype did
1405 int reiserfs_init_locked_inode(struct inode *inode, void *p)
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);
1413 /* looks for stat data in the tree, and fills up the fields of in-core
1414 inode stat data fields */
1415 void reiserfs_read_locked_inode(struct inode *inode,
1416 struct reiserfs_iget_args *args)
1418 INITIALIZE_PATH(path_to_sd);
1420 unsigned long dirino;
1423 dirino = args->dirid;
1425 /* set version 1, version 2 could be used too, because stat data
1426 key is the same in both versions */
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;
1433 /* look for the object's stat data */
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);
1442 if (retval != ITEM_FOUND) {
1443 /* a stale NFS handle can trigger this without it being an error */
1444 pathrelse(&path_to_sd);
1445 reiserfs_make_bad_inode(inode);
1450 init_inode(inode, &path_to_sd);
1452 /* It is possible that knfsd is trying to access inode of a file
1453 that is being removed from the disk by some other thread. As we
1454 update sd on unlink all that is required is to check for nlink
1455 here. This bug was first found by Sizif when debugging
1456 SquidNG/Butterfly, forgotten, and found again after Philippe
1457 Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
1459 More logical fix would require changes in fs/inode.c:iput() to
1460 remove inode from hash-table _after_ fs cleaned disk stuff up and
1461 in iget() to return NULL if I_FREEING inode is found in
1463 /* Currently there is one place where it's ok to meet inode with
1464 nlink==0: processing of open-unlinked and half-truncated files
1465 during mount (fs/reiserfs/super.c:finish_unfinished()). */
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",
1472 reiserfs_make_bad_inode(inode);
1475 reiserfs_check_path(&path_to_sd); /* init inode should be relsing */
1478 * Stat data v1 doesn't support ACLs.
1480 if (get_inode_sd_version(inode) == STAT_DATA_V1)
1481 cache_no_acl(inode);
1485 * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().
1487 * @inode: inode from hash table to check
1488 * @opaque: "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.
1490 * This function is called by iget5_locked() to distinguish reiserfs inodes
1491 * having the same inode numbers. Such inodes can only exist due to some
1492 * error condition. One of them should be bad. Inodes with identical
1493 * inode numbers (objectids) are distinguished by parent directory ids.
1496 int reiserfs_find_actor(struct inode *inode, void *opaque)
1498 struct reiserfs_iget_args *args;
1501 /* args is already in CPU order */
1502 return (inode->i_ino == args->objectid) &&
1503 (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
1506 struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
1508 struct inode *inode;
1509 struct reiserfs_iget_args args;
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,
1518 reiserfs_write_lock_nested(s, depth);
1520 return ERR_PTR(-ENOMEM);
1522 if (inode->i_state & I_NEW) {
1523 reiserfs_read_locked_inode(inode, &args);
1524 unlock_new_inode(inode);
1527 if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1528 /* either due to i/o error or a stale NFS handle */
1535 static struct dentry *reiserfs_get_dentry(struct super_block *sb,
1536 u32 objectid, u32 dir_id, u32 generation)
1540 struct inode *inode;
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) {
1551 reiserfs_write_unlock(sb);
1553 return d_obtain_alias(inode);
1556 struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
1557 int fh_len, int fh_type)
1559 /* fhtype happens to reflect the number of u32s encoded.
1560 * due to a bug in earlier code, fhtype might indicate there
1561 * are more u32s then actually fitted.
1562 * so if fhtype seems to be more than len, reduce fhtype.
1564 * 2 - objectid + dir_id - legacy support
1565 * 3 - objectid + dir_id + generation
1566 * 4 - objectid + dir_id + objectid and dirid of parent - legacy
1567 * 5 - objectid + dir_id + generation + objectid and dirid of parent
1568 * 6 - as above plus generation of directory
1569 * 6 does not fit in NFSv2 handles
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",
1581 return reiserfs_get_dentry(sb, fid->raw[0], fid->raw[1],
1582 (fh_type == 3 || fh_type >= 5) ? fid->raw[2] : 0);
1585 struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,
1586 int fh_len, int fh_type)
1588 if (fh_type > fh_len)
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);
1599 int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,
1600 struct inode *parent)
1604 if (parent && (maxlen < 5)) {
1606 return FILEID_INVALID;
1607 } else if (maxlen < 3) {
1609 return FILEID_INVALID;
1612 data[0] = inode->i_ino;
1613 data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1614 data[2] = inode->i_generation;
1617 data[3] = parent->i_ino;
1618 data[4] = le32_to_cpu(INODE_PKEY(parent)->k_dir_id);
1621 data[5] = parent->i_generation;
1628 /* looks for stat data, then copies fields to it, marks the buffer
1629 containing stat data as dirty */
1630 /* reiserfs inodes are never really dirty, since the dirty inode call
1631 ** always logs them. This call allows the VFS inode marking routines
1632 ** to properly mark inodes for datasync and such, but only actually
1633 ** does something when called for a synchronous update.
1635 int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc)
1637 struct reiserfs_transaction_handle th;
1638 int jbegin_count = 1;
1640 if (inode->i_sb->s_flags & MS_RDONLY)
1642 /* memory pressure can sometimes initiate write_inode calls with sync == 1,
1643 ** these cases are just when the system needs ram, not when the
1644 ** inode needs to reach disk for safety, and they can safely be
1645 ** ignored because the altered inode has already been logged.
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);
1653 reiserfs_write_unlock(inode->i_sb);
1658 /* stat data of new object is inserted already, this inserts the item
1659 containing "." and ".." entries */
1660 static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1661 struct inode *inode,
1662 struct item_head *ih, struct treepath *path,
1665 struct super_block *sb = th->t_super;
1666 char empty_dir[EMPTY_DIR_SIZE];
1667 char *body = empty_dir;
1671 BUG_ON(!th->t_trans_id);
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 /*key length */ );
1677 /* compose item head for new item. Directories consist of items of
1678 old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1679 is done by reiserfs_new_inode */
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);
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);
1689 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1690 TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
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);
1698 /* look for place in the tree for new item */
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");
1705 if (retval == ITEM_FOUND) {
1707 reiserfs_warning(sb, "vs-13070",
1708 "object with this key exists (%k)",
1713 /* insert item, that is empty directory item */
1714 return reiserfs_insert_item(th, path, &key, ih, inode, body);
1717 /* stat data of object has been inserted, this inserts the item
1718 containing the body of symlink */
1719 static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode of symlink */
1720 struct item_head *ih,
1721 struct treepath *path, const char *symname,
1724 struct super_block *sb = th->t_super;
1728 BUG_ON(!th->t_trans_id);
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 /*key length */ );
1735 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1736 0 /*free_space */ );
1738 /* look for place in the tree for new item */
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");
1745 if (retval == ITEM_FOUND) {
1747 reiserfs_warning(sb, "vs-13080",
1748 "object with this key exists (%k)",
1753 /* insert item, that is body of symlink */
1754 return reiserfs_insert_item(th, path, &key, ih, inode, symname);
1757 /* inserts the stat data into the tree, and then calls
1758 reiserfs_new_directory (to insert ".", ".." item if new object is
1759 directory) or reiserfs_new_symlink (to insert symlink body if new
1760 object is symlink) or nothing (if new object is regular file)
1762 NOTE! uid and gid must already be set in the inode. If we return
1763 non-zero due to an error, we have to drop the quota previously allocated
1764 for the fresh inode. This can only be done outside a transaction, so
1765 if we return non-zero, we also end the transaction. */
1766 int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1767 struct inode *dir, umode_t mode, const char *symname,
1768 /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1769 strlen (symname) for symlinks) */
1770 loff_t i_size, struct dentry *dentry,
1771 struct inode *inode,
1772 struct reiserfs_security_handle *security)
1774 struct super_block *sb = dir->i_sb;
1775 struct reiserfs_iget_args args;
1776 INITIALIZE_PATH(path_to_key);
1778 struct item_head ih;
1779 struct stat_data sd;
1784 BUG_ON(!th->t_trans_id);
1786 depth = reiserfs_write_unlock_nested(sb);
1787 err = dquot_alloc_inode(inode);
1788 reiserfs_write_lock_nested(sb, depth);
1791 if (!dir->i_nlink) {
1796 /* item head of new item */
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) {
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);
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);
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);
1822 if (old_format_only(sb))
1823 /* not a perfect generation count, as object ids can be reused, but
1824 ** this is as good as reiserfs can do right now.
1825 ** note that the private part of inode isn't filled in yet, we have
1826 ** to use the directory.
1828 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1830 #if defined( USE_INODE_GENERATION_COUNTER )
1831 inode->i_generation =
1832 le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1834 inode->i_generation = ++event;
1837 /* fill stat data */
1838 set_nlink(inode, (S_ISDIR(mode) ? 2 : 1));
1840 /* uid and gid must already be set by the caller for quota init */
1842 /* symlink cannot be immutable or append only, right? */
1843 if (S_ISLNK(inode->i_mode))
1844 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1846 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1847 inode->i_size = i_size;
1848 inode->i_blocks = 0;
1850 REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1851 U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;
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);
1864 /* key to search for correct place for new stat data */
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 /*key length */ );
1869 /* find proper place for inserting of stat data */
1870 retval = search_item(sb, &key, &path_to_key);
1871 if (retval == IO_ERROR) {
1875 if (retval == ITEM_FOUND) {
1876 pathrelse(&path_to_key);
1880 if (old_format_only(sb)) {
1881 if (i_uid_read(inode) & ~0xffff || i_gid_read(inode) & ~0xffff) {
1882 pathrelse(&path_to_key);
1883 /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1887 inode2sd_v1(&sd, inode, inode->i_size);
1889 inode2sd(&sd, inode, inode->i_size);
1891 // store in in-core inode the key of stat data and version all
1892 // object items will have (directory items will have old offset
1893 // format, other new objects will consist of new items)
1894 if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1895 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
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);
1901 set_inode_sd_version(inode, STAT_DATA_V2);
1903 /* insert the stat data into the tree */
1904 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1905 if (REISERFS_I(dir)->new_packing_locality)
1906 th->displace_new_blocks = 1;
1909 reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1913 reiserfs_check_path(&path_to_key);
1916 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1917 if (!th->displace_new_blocks)
1918 REISERFS_I(dir)->new_packing_locality = 0;
1920 if (S_ISDIR(mode)) {
1921 /* insert item with "." and ".." */
1923 reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1926 if (S_ISLNK(mode)) {
1927 /* insert body of symlink */
1928 if (!old_format_only(sb))
1929 i_size = ROUND_UP(i_size);
1931 reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1936 reiserfs_check_path(&path_to_key);
1937 journal_end(th, th->t_super, th->t_blocks_allocated);
1938 goto out_inserted_sd;
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);
1947 reiserfs_check_path(&path_to_key);
1948 journal_end(th, th->t_super, th->t_blocks_allocated);
1949 goto out_inserted_sd;
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;
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);
1964 reiserfs_check_path(&path_to_key);
1965 retval = journal_end(th, th->t_super,
1966 th->t_blocks_allocated);
1969 goto out_inserted_sd;
1973 reiserfs_update_sd(th, inode);
1974 reiserfs_check_path(&path_to_key);
1978 /* it looks like you can easily compress these two goto targets into
1979 * one. Keeping it like this doesn't actually hurt anything, and they
1980 * are place holders for what the quota code actually needs.
1983 /* Invalidate the object, nothing was inserted yet */
1984 INODE_PKEY(inode)->k_objectid = 0;
1986 /* Quota change must be inside a transaction for journaling */
1987 depth = reiserfs_write_unlock_nested(inode->i_sb);
1988 dquot_free_inode(inode);
1989 reiserfs_write_lock_nested(inode->i_sb, depth);
1992 journal_end(th, th->t_super, th->t_blocks_allocated);
1993 /* Drop can be outside and it needs more credits so it's better to have it outside */
1994 depth = reiserfs_write_unlock_nested(inode->i_sb);
1996 reiserfs_write_lock_nested(inode->i_sb, depth);
1997 inode->i_flags |= S_NOQUOTA;
1998 make_bad_inode(inode);
2002 th->t_trans_id = 0; /* so the caller can't use this handle later */
2003 unlock_new_inode(inode); /* OK to do even if we hadn't locked it */
2009 ** finds the tail page in the page cache,
2010 ** reads the last block in.
2012 ** On success, page_result is set to a locked, pinned page, and bh_result
2013 ** is set to an up to date buffer for the last block in the file. returns 0.
2015 ** tail conversion is not done, so bh_result might not be valid for writing
2016 ** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
2017 ** trying to write the block.
2019 ** on failure, nonzero is returned, page_result and bh_result are untouched.
2021 static int grab_tail_page(struct inode *inode,
2022 struct page **page_result,
2023 struct buffer_head **bh_result)
2026 /* we want the page with the last byte in the file,
2027 ** not the page that will hold the next byte for appending
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;
2039 /* we know that we are only called with inode->i_size > 0.
2040 ** we also know that a file tail can never be as big as a block
2041 ** If i_size % blocksize == 0, our file is currently block aligned
2042 ** and it won't need converting or zeroing after a truncate.
2044 if ((offset & (blocksize - 1)) == 0) {
2047 page = grab_cache_page(inode->i_mapping, index);
2052 /* start within the page of the last block in the file */
2053 start = (offset / blocksize) * blocksize;
2055 error = __block_write_begin(page, start, offset - start,
2056 reiserfs_get_block_create_0);
2060 head = page_buffers(page);
2066 bh = bh->b_this_page;
2068 } while (bh != head);
2070 if (!buffer_uptodate(bh)) {
2071 /* note, this should never happen, prepare_write should
2072 ** be taking care of this for us. If the buffer isn't up to date,
2073 ** I've screwed up the code to find the buffer, or the code to
2074 ** call prepare_write
2076 reiserfs_error(inode->i_sb, "clm-6000",
2077 "error reading block %lu", bh->b_blocknr);
2082 *page_result = page;
2089 page_cache_release(page);
2094 ** vfs version of truncate file. Must NOT be called with
2095 ** a transaction already started.
2097 ** some code taken from block_truncate_page
2099 int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
2101 struct reiserfs_transaction_handle th;
2102 /* we want the offset for the first byte after the end of the file */
2103 unsigned long offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2104 unsigned blocksize = inode->i_sb->s_blocksize;
2106 struct page *page = NULL;
2108 struct buffer_head *bh = NULL;
2111 reiserfs_write_lock(inode->i_sb);
2113 if (inode->i_size > 0) {
2114 error = grab_tail_page(inode, &page, &bh);
2116 // -ENOENT means we truncated past the end of the file,
2117 // and get_block_create_0 could not find a block to read in,
2119 if (error != -ENOENT)
2120 reiserfs_error(inode->i_sb, "clm-6001",
2121 "grab_tail_page failed %d",
2128 /* so, if page != NULL, we have a buffer head for the offset at
2129 ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2130 ** then we have an unformatted node. Otherwise, we have a direct item,
2131 ** and no zeroing is required on disk. We zero after the truncate,
2132 ** because the truncate might pack the item anyway
2133 ** (it will unmap bh if it packs).
2135 /* it is enough to reserve space in transaction for 2 balancings:
2136 one for "save" link adding and another for the first
2137 cut_from_item. 1 is for update_sd */
2138 error = journal_begin(&th, inode->i_sb,
2139 JOURNAL_PER_BALANCE_CNT * 2 + 1);
2142 reiserfs_update_inode_transaction(inode);
2143 if (update_timestamps)
2144 /* we are doing real truncate: if the system crashes before the last
2145 transaction of truncating gets committed - on reboot the file
2146 either appears truncated properly or not truncated at all */
2147 add_save_link(&th, inode, 1);
2148 err2 = reiserfs_do_truncate(&th, inode, page, update_timestamps);
2150 journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2154 /* check reiserfs_do_truncate after ending the transaction */
2160 if (update_timestamps) {
2161 error = remove_save_link(inode, 1 /* truncate */);
2167 length = offset & (blocksize - 1);
2168 /* if we are not on a block boundary */
2170 length = blocksize - length;
2171 zero_user(page, offset, length);
2172 if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2173 mark_buffer_dirty(bh);
2177 page_cache_release(page);
2180 reiserfs_write_unlock(inode->i_sb);
2186 page_cache_release(page);
2189 reiserfs_write_unlock(inode->i_sb);
2194 static int map_block_for_writepage(struct inode *inode,
2195 struct buffer_head *bh_result,
2196 unsigned long block)
2198 struct reiserfs_transaction_handle th;
2200 struct item_head tmp_ih;
2201 struct item_head *ih;
2202 struct buffer_head *bh;
2205 INITIALIZE_PATH(path);
2207 int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2208 loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
2210 int use_get_block = 0;
2211 int bytes_copied = 0;
2213 int trans_running = 0;
2215 /* catch places below that try to log something without starting a trans */
2218 if (!buffer_uptodate(bh_result)) {
2222 kmap(bh_result->b_page);
2224 reiserfs_write_lock(inode->i_sb);
2225 make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
2228 retval = search_for_position_by_key(inode->i_sb, &key, &path);
2229 if (retval != POSITION_FOUND) {
2234 bh = get_last_bh(&path);
2236 item = get_item(&path);
2237 pos_in_item = path.pos_in_item;
2239 /* we've found an unformatted node */
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);
2245 if (!get_block_num(item, pos_in_item)) {
2246 /* crap, we are writing to a hole */
2250 set_block_dev_mapped(bh_result,
2251 get_block_num(item, pos_in_item), inode);
2252 } else if (is_direct_le_ih(ih)) {
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;
2258 fs_gen = get_generation(inode->i_sb);
2259 copy_item_head(&tmp_ih, ih);
2261 if (!trans_running) {
2262 /* vs-3050 is gone, no need to drop the path */
2263 retval = journal_begin(&th, inode->i_sb, jbegin_count);
2266 reiserfs_update_inode_transaction(inode);
2268 if (fs_changed(fs_gen, inode->i_sb)
2269 && item_moved(&tmp_ih, &path)) {
2270 reiserfs_restore_prepared_buffer(inode->i_sb,
2276 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2278 if (fs_changed(fs_gen, inode->i_sb)
2279 && item_moved(&tmp_ih, &path)) {
2280 reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2284 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2287 journal_mark_dirty(&th, inode->i_sb, bh);
2288 bytes_copied += copy_size;
2289 set_block_dev_mapped(bh_result, 0, inode);
2291 /* are there still bytes left? */
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) +
2300 reiserfs_warning(inode->i_sb, "clm-6003",
2301 "bad item inode %lu", inode->i_ino);
2309 if (trans_running) {
2310 int err = journal_end(&th, inode->i_sb, jbegin_count);
2315 reiserfs_write_unlock(inode->i_sb);
2317 /* this is where we fill in holes in the file. */
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);
2323 if (!buffer_mapped(bh_result)
2324 || bh_result->b_blocknr == 0) {
2325 /* get_block failed to find a mapped unformatted node. */
2331 kunmap(bh_result->b_page);
2333 if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2334 /* we've copied data from the page into the direct item, so the
2335 * buffer in the page is now clean, mark it to reflect that.
2337 lock_buffer(bh_result);
2338 clear_buffer_dirty(bh_result);
2339 unlock_buffer(bh_result);
2345 * mason@suse.com: updated in 2.5.54 to follow the same general io
2346 * start/recovery path as __block_write_full_page, along with special
2347 * code to handle reiserfs tails.
2349 static int reiserfs_write_full_page(struct page *page,
2350 struct writeback_control *wbc)
2352 struct inode *inode = page->mapping->host;
2353 unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2355 unsigned long block;
2356 sector_t last_block;
2357 struct buffer_head *head, *bh;
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;
2366 /* no logging allowed when nonblocking or from PF_MEMALLOC */
2367 if (checked && (current->flags & PF_MEMALLOC)) {
2368 redirty_page_for_writepage(wbc, page);
2373 /* The page dirty bit is cleared before writepage is called, which
2374 * means we have to tell create_empty_buffers to make dirty buffers
2375 * The page really should be up to date at this point, so tossing
2376 * in the BH_Uptodate is just a sanity check.
2378 if (!page_has_buffers(page)) {
2379 create_empty_buffers(page, s->s_blocksize,
2380 (1 << BH_Dirty) | (1 << BH_Uptodate));
2382 head = page_buffers(page);
2384 /* last page in the file, zero out any contents past the
2385 ** last byte in the file
2387 if (page->index >= end_index) {
2388 unsigned last_offset;
2390 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2391 /* no file contents in this page */
2392 if (page->index >= end_index + 1 || !last_offset) {
2396 zero_user_segment(page, last_offset, PAGE_CACHE_SIZE);
2399 block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2400 last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
2401 /* first map all the buffers, logging any direct items we find */
2403 if (block > last_block) {
2405 * This can happen when the block size is less than
2406 * the page size. The corresponding bytes in the page
2407 * were zero filled above
2409 clear_buffer_dirty(bh);
2410 set_buffer_uptodate(bh);
2411 } else if ((checked || buffer_dirty(bh)) &&
2412 (!buffer_mapped(bh) || (buffer_mapped(bh)
2415 /* not mapped yet, or it points to a direct item, search
2416 * the btree for the mapping info, and log any direct
2419 if ((error = map_block_for_writepage(inode, bh, block))) {
2423 bh = bh->b_this_page;
2425 } while (bh != head);
2428 * we start the transaction after map_block_for_writepage,
2429 * because it can create holes in the file (an unbounded operation).
2430 * starting it here, we can make a reliable estimate for how many
2431 * blocks we're going to log
2434 ClearPageChecked(page);
2435 reiserfs_write_lock(s);
2436 error = journal_begin(&th, s, bh_per_page + 1);
2438 reiserfs_write_unlock(s);
2441 reiserfs_update_inode_transaction(inode);
2443 /* now go through and lock any dirty buffers on the page */
2446 if (!buffer_mapped(bh))
2448 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2452 reiserfs_prepare_for_journal(s, bh, 1);
2453 journal_mark_dirty(&th, s, bh);
2456 /* from this point on, we know the buffer is mapped to a
2457 * real block and not a direct item
2459 if (wbc->sync_mode != WB_SYNC_NONE) {
2462 if (!trylock_buffer(bh)) {
2463 redirty_page_for_writepage(wbc, page);
2467 if (test_clear_buffer_dirty(bh)) {
2468 mark_buffer_async_write(bh);
2472 } while ((bh = bh->b_this_page) != head);
2475 error = journal_end(&th, s, bh_per_page + 1);
2476 reiserfs_write_unlock(s);
2480 BUG_ON(PageWriteback(page));
2481 set_page_writeback(page);
2485 * since any buffer might be the only dirty buffer on the page,
2486 * the first submit_bh can bring the page out of writeback.
2487 * be careful with the buffers.
2490 struct buffer_head *next = bh->b_this_page;
2491 if (buffer_async_write(bh)) {
2492 submit_bh(WRITE, bh);
2497 } while (bh != head);
2503 * if this page only had a direct item, it is very possible for
2504 * no io to be required without there being an error. Or,
2505 * someone else could have locked them and sent them down the
2506 * pipe without locking the page
2510 if (!buffer_uptodate(bh)) {
2514 bh = bh->b_this_page;
2515 } while (bh != head);
2517 SetPageUptodate(page);
2518 end_page_writeback(page);
2523 /* catches various errors, we need to make sure any valid dirty blocks
2524 * get to the media. The page is currently locked and not marked for
2527 ClearPageUptodate(page);
2531 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2533 mark_buffer_async_write(bh);
2536 * clear any dirty bits that might have come from getting
2537 * attached to a dirty page
2539 clear_buffer_dirty(bh);
2541 bh = bh->b_this_page;
2542 } while (bh != head);
2544 BUG_ON(PageWriteback(page));
2545 set_page_writeback(page);
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);
2556 } while (bh != head);
2560 static int reiserfs_readpage(struct file *f, struct page *page)
2562 return block_read_full_page(page, reiserfs_get_block);
2565 static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
2567 struct inode *inode = page->mapping->host;
2568 reiserfs_wait_on_write_block(inode->i_sb);
2569 return reiserfs_write_full_page(page, wbc);
2572 static void reiserfs_truncate_failed_write(struct inode *inode)
2574 truncate_inode_pages(inode->i_mapping, inode->i_size);
2575 reiserfs_truncate_file(inode, 0);
2578 static 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)
2583 struct inode *inode;
2589 inode = mapping->host;
2591 if (flags & AOP_FLAG_CONT_EXPAND &&
2592 (pos & (inode->i_sb->s_blocksize - 1)) == 0) {
2594 *fsdata = (void *)(unsigned long)flags;
2597 index = pos >> PAGE_CACHE_SHIFT;
2598 page = grab_cache_page_write_begin(mapping, index, flags);
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->
2609 BUG_ON(!th->t_refcount);
2610 BUG_ON(!th->t_trans_id);
2611 old_ref = th->t_refcount;
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 /* this gets a little ugly. If reiserfs_get_block returned an
2618 * error and left a transacstion running, we've got to close it,
2619 * and we've got to free handle if it was a persistent transaction.
2621 * But, if we had nested into an existing transaction, we need
2622 * to just drop the ref count on the handle.
2624 * If old_ref == 0, the transaction is from reiserfs_get_block,
2625 * and it was a persistent trans. Otherwise, it was nested above.
2627 if (th->t_refcount > old_ref) {
2632 reiserfs_write_lock(inode->i_sb);
2633 err = reiserfs_end_persistent_transaction(th);
2634 reiserfs_write_unlock(inode->i_sb);
2642 page_cache_release(page);
2643 /* Truncate allocated blocks */
2644 reiserfs_truncate_failed_write(inode);
2649 int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
2651 struct inode *inode = page->mapping->host;
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);
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->
2665 BUG_ON(!th->t_refcount);
2666 BUG_ON(!th->t_trans_id);
2667 old_ref = th->t_refcount;
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 /* this gets a little ugly. If reiserfs_get_block returned an
2675 * error and left a transacstion running, we've got to close it,
2676 * and we've got to free handle if it was a persistent transaction.
2678 * But, if we had nested into an existing transaction, we need
2679 * to just drop the ref count on the handle.
2681 * If old_ref == 0, the transaction is from reiserfs_get_block,
2682 * and it was a persistent trans. Otherwise, it was nested above.
2684 if (th->t_refcount > old_ref) {
2689 reiserfs_write_lock(inode->i_sb);
2690 err = reiserfs_end_persistent_transaction(th);
2691 reiserfs_write_unlock(inode->i_sb);
2701 static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2703 return generic_block_bmap(as, block, reiserfs_bmap);
2706 static 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)
2710 struct inode *inode = page->mapping->host;
2713 struct reiserfs_transaction_handle *th;
2715 bool locked = false;
2717 if ((unsigned long)fsdata & AOP_FLAG_CONT_EXPAND)
2720 reiserfs_wait_on_write_block(inode->i_sb);
2721 if (reiserfs_transaction_running(inode->i_sb))
2722 th = current->journal_info;
2726 start = pos & (PAGE_CACHE_SIZE - 1);
2727 if (unlikely(copied < len)) {
2728 if (!PageUptodate(page))
2731 page_zero_new_buffers(page, start + copied, start + len);
2733 flush_dcache_page(page);
2735 reiserfs_commit_page(inode, page, start, start + copied);
2737 /* generic_commit_write does this for us, but does not update the
2738 ** transaction tracking stuff when the size changes. So, we have
2739 ** to do the i_size updates here.
2741 if (pos + copied > inode->i_size) {
2742 struct reiserfs_transaction_handle myth;
2743 reiserfs_write_lock(inode->i_sb);
2745 /* If the file have grown beyond the border where it
2746 can have a tail, unmark it as needing a tail
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;
2754 ret = journal_begin(&myth, inode->i_sb, 1);
2758 reiserfs_update_inode_transaction(inode);
2759 inode->i_size = pos + copied;
2761 * this will just nest into our transaction. It's important
2762 * to use mark_inode_dirty so the inode gets pushed around on the
2763 * dirty lists, and so that O_SYNC works as expected
2765 mark_inode_dirty(inode);
2766 reiserfs_update_sd(&myth, inode);
2768 ret = journal_end(&myth, inode->i_sb, 1);
2774 reiserfs_write_lock(inode->i_sb);
2778 mark_inode_dirty(inode);
2779 ret = reiserfs_end_persistent_transaction(th);
2786 reiserfs_write_unlock(inode->i_sb);
2788 page_cache_release(page);
2790 if (pos + len > inode->i_size)
2791 reiserfs_truncate_failed_write(inode);
2793 return ret == 0 ? copied : ret;
2796 reiserfs_write_unlock(inode->i_sb);
2800 reiserfs_update_sd(th, inode);
2801 ret = reiserfs_end_persistent_transaction(th);
2806 int reiserfs_commit_write(struct file *f, struct page *page,
2807 unsigned from, unsigned to)
2809 struct inode *inode = page->mapping->host;
2810 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2813 struct reiserfs_transaction_handle *th = NULL;
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);
2820 if (reiserfs_transaction_running(inode->i_sb)) {
2821 th = current->journal_info;
2823 reiserfs_commit_page(inode, page, from, to);
2825 /* generic_commit_write does this for us, but does not update the
2826 ** transaction tracking stuff when the size changes. So, we have
2827 ** to do the i_size updates here.
2829 if (pos > inode->i_size) {
2830 struct reiserfs_transaction_handle myth;
2831 /* If the file have grown beyond the border where it
2832 can have a tail, unmark it as needing a tail
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;
2840 ret = journal_begin(&myth, inode->i_sb, 1);
2844 reiserfs_update_inode_transaction(inode);
2845 inode->i_size = pos;
2847 * this will just nest into our transaction. It's important
2848 * to use mark_inode_dirty so the inode gets pushed around on the
2849 * dirty lists, and so that O_SYNC works as expected
2851 mark_inode_dirty(inode);
2852 reiserfs_update_sd(&myth, inode);
2854 ret = journal_end(&myth, inode->i_sb, 1);
2860 mark_inode_dirty(inode);
2861 ret = reiserfs_end_persistent_transaction(th);
2872 reiserfs_update_sd(th, inode);
2873 ret = reiserfs_end_persistent_transaction(th);
2879 void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2881 if (reiserfs_attrs(inode->i_sb)) {
2882 if (sd_attrs & REISERFS_SYNC_FL)
2883 inode->i_flags |= S_SYNC;
2885 inode->i_flags &= ~S_SYNC;
2886 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2887 inode->i_flags |= S_IMMUTABLE;
2889 inode->i_flags &= ~S_IMMUTABLE;
2890 if (sd_attrs & REISERFS_APPEND_FL)
2891 inode->i_flags |= S_APPEND;
2893 inode->i_flags &= ~S_APPEND;
2894 if (sd_attrs & REISERFS_NOATIME_FL)
2895 inode->i_flags |= S_NOATIME;
2897 inode->i_flags &= ~S_NOATIME;
2898 if (sd_attrs & REISERFS_NOTAIL_FL)
2899 REISERFS_I(inode)->i_flags |= i_nopack_mask;
2901 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2905 void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
2907 if (reiserfs_attrs(inode->i_sb)) {
2908 if (inode->i_flags & S_IMMUTABLE)
2909 *sd_attrs |= REISERFS_IMMUTABLE_FL;
2911 *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
2912 if (inode->i_flags & S_SYNC)
2913 *sd_attrs |= REISERFS_SYNC_FL;
2915 *sd_attrs &= ~REISERFS_SYNC_FL;
2916 if (inode->i_flags & S_NOATIME)
2917 *sd_attrs |= REISERFS_NOATIME_FL;
2919 *sd_attrs &= ~REISERFS_NOATIME_FL;
2920 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
2921 *sd_attrs |= REISERFS_NOTAIL_FL;
2923 *sd_attrs &= ~REISERFS_NOTAIL_FL;
2927 /* decide if this buffer needs to stay around for data logging or ordered
2930 static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2933 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2936 spin_lock(&j->j_dirty_buffers_lock);
2937 if (!buffer_mapped(bh)) {
2940 /* the page is locked, and the only places that log a data buffer
2941 * also lock the page.
2943 if (reiserfs_file_data_log(inode)) {
2945 * very conservative, leave the buffer pinned if
2946 * anyone might need it.
2948 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2951 } else if (buffer_dirty(bh)) {
2952 struct reiserfs_journal_list *jl;
2953 struct reiserfs_jh *jh = bh->b_private;
2955 /* why is this safe?
2956 * reiserfs_setattr updates i_size in the on disk
2957 * stat data before allowing vmtruncate to be called.
2959 * If buffer was put onto the ordered list for this
2960 * transaction, we know for sure either this transaction
2961 * or an older one already has updated i_size on disk,
2962 * and this ordered data won't be referenced in the file
2965 * if the buffer was put onto the ordered list for an older
2966 * transaction, we need to leave it around
2968 if (jh && (jl = jh->jl)
2969 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2973 if (ret && bh->b_private) {
2974 reiserfs_free_jh(bh);
2976 spin_unlock(&j->j_dirty_buffers_lock);
2981 /* clm -- taken from fs/buffer.c:block_invalidate_page */
2982 static void reiserfs_invalidatepage(struct page *page, unsigned int offset,
2983 unsigned int length)
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);
2992 BUG_ON(!PageLocked(page));
2995 ClearPageChecked(page);
2997 if (!page_has_buffers(page))
3000 head = page_buffers(page);
3003 unsigned int next_off = curr_off + bh->b_size;
3004 next = bh->b_this_page;
3006 if (next_off > stop)
3010 * is this block fully invalidated?
3012 if (offset <= curr_off) {
3013 if (invalidatepage_can_drop(inode, bh))
3014 reiserfs_unmap_buffer(bh);
3018 curr_off = next_off;
3020 } while (bh != head);
3023 * We release buffers only if the entire page is being invalidated.
3024 * The get_block cached value has been unconditionally invalidated,
3025 * so real IO is not possible anymore.
3027 if (!partial_page && ret) {
3028 ret = try_to_release_page(page, 0);
3029 /* maybe should BUG_ON(!ret); - neilb */
3035 static int reiserfs_set_page_dirty(struct page *page)
3037 struct inode *inode = page->mapping->host;
3038 if (reiserfs_file_data_log(inode)) {
3039 SetPageChecked(page);
3040 return __set_page_dirty_nobuffers(page);
3042 return __set_page_dirty_buffers(page);
3046 * Returns 1 if the page's buffers were dropped. The page is locked.
3048 * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads
3049 * in the buffers at page_buffers(page).
3051 * even in -o notail mode, we can't be sure an old mount without -o notail
3052 * didn't create files with tails.
3054 static int reiserfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
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;
3062 WARN_ON(PageChecked(page));
3063 spin_lock(&j->j_dirty_buffers_lock);
3064 head = page_buffers(page);
3067 if (bh->b_private) {
3068 if (!buffer_dirty(bh) && !buffer_locked(bh)) {
3069 reiserfs_free_jh(bh);
3075 bh = bh->b_this_page;
3076 } while (bh != head);
3078 ret = try_to_free_buffers(page);
3079 spin_unlock(&j->j_dirty_buffers_lock);
3083 /* We thank Mingming Cao for helping us understand in great detail what
3084 to do in this section of the code. */
3085 static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
3086 struct iov_iter *iter, loff_t offset)
3088 struct file *file = iocb->ki_filp;
3089 struct inode *inode = file->f_mapping->host;
3090 size_t count = iov_iter_count(iter);
3093 ret = blockdev_direct_IO(rw, iocb, inode, iter, offset,
3094 reiserfs_get_blocks_direct_io);
3097 * In case of error extending write may have instantiated a few
3098 * blocks outside i_size. Trim these off again.
3100 if (unlikely((rw & WRITE) && ret < 0)) {
3101 loff_t isize = i_size_read(inode);
3102 loff_t end = offset + count;
3104 if ((end > isize) && inode_newsize_ok(inode, isize) == 0) {
3105 truncate_setsize(inode, isize);
3106 reiserfs_vfs_truncate_file(inode);
3113 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
3115 struct inode *inode = dentry->d_inode;
3116 unsigned int ia_valid;
3119 error = inode_change_ok(inode, attr);
3123 /* must be turned off for recursive notify_change calls */
3124 ia_valid = attr->ia_valid &= ~(ATTR_KILL_SUID|ATTR_KILL_SGID);
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 /* version 2 items will be caught by the s_maxbytes check
3131 ** done for us in vmtruncate
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);
3140 inode_dio_wait(inode);
3142 /* fill in hole pointers in the expanding truncate case. */
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) {
3147 struct reiserfs_transaction_handle th;
3148 /* we're changing at most 2 bitmaps, inode + super */
3149 err = journal_begin(&th, inode->i_sb, 4);
3151 reiserfs_discard_prealloc(&th, inode);
3152 err = journal_end(&th, inode->i_sb, 4);
3158 reiserfs_write_unlock(inode->i_sb);
3162 * file size is changed, ctime and mtime are
3165 attr->ia_valid |= (ATTR_MTIME | ATTR_CTIME);
3168 reiserfs_write_unlock(inode->i_sb);
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 /* stat data of format v3.5 has 16 bit uid and gid */
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;
3183 (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
3184 REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
3187 error = reiserfs_chown_xattrs(inode, attr);
3192 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
3193 reiserfs_write_lock(inode->i_sb);
3194 error = journal_begin(&th, inode->i_sb, jbegin_count);
3195 reiserfs_write_unlock(inode->i_sb);
3198 error = dquot_transfer(inode, attr);
3199 reiserfs_write_lock(inode->i_sb);
3201 journal_end(&th, inode->i_sb, jbegin_count);
3202 reiserfs_write_unlock(inode->i_sb);
3206 /* Update corresponding info in inode so that everything is in
3207 * one transaction */
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);
3219 if ((attr->ia_valid & ATTR_SIZE) &&
3220 attr->ia_size != i_size_read(inode)) {
3221 error = inode_newsize_ok(inode, attr->ia_size);
3223 truncate_setsize(inode, attr->ia_size);
3224 reiserfs_vfs_truncate_file(inode);
3229 setattr_copy(inode, attr);
3230 mark_inode_dirty(inode);
3233 if (!error && reiserfs_posixacl(inode->i_sb)) {
3234 if (attr->ia_valid & ATTR_MODE)
3235 error = reiserfs_acl_chmod(inode);
3242 const 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,