fs/reiserfs/inode.c

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