git.oblomov.eu Git - linux-2.6/blob - fs/reiserfs/inode.c

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