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