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