fs/reiserfs/inode.c

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