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