fs/reiserfs/inode.c

   1 /*
   2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  */
   4
   5 #include <linux/time.h>
   6 #include <linux/fs.h>
   7 #include <linux/reiserfs_fs.h>
   8 #include <linux/reiserfs_acl.h>
   9 #include <linux/reiserfs_xattr.h>
  10 #include <linux/smp_lock.h>
  11 #include <linux/pagemap.h>
  12 #include <linux/highmem.h>
  13 #include <asm/uaccess.h>
  14 #include <asm/unaligned.h>
  15 #include <linux/buffer_head.h>
  16 #include <linux/mpage.h>
  17 #include <linux/writeback.h>
  18 #include <linux/quotaops.h>
  19
  20 static int reiserfs_commit_write(struct file *f, struct page *page,
  21                                  unsigned from, unsigned to);
  22 static int reiserfs_prepare_write(struct file *f, struct page *page,
  23                                   unsigned from, unsigned to);
  24
  25 void reiserfs_delete_inode(struct inode *inode)
  26 {
  27         /* We need blocks for transaction + (user+group) quota update (possibly delete) */
  28         int jbegin_count =
  29             JOURNAL_PER_BALANCE_CNT * 2 +
  30             2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);
  31         struct reiserfs_transaction_handle th;
  32         int err;
  33
  34         truncate_inode_pages(&inode->i_data, 0);
  35
  36         reiserfs_write_lock(inode->i_sb);
  37
  38         /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
  39         if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) {  /* also handles bad_inode case */
  40                 reiserfs_delete_xattrs(inode);
  41
  42                 if (journal_begin(&th, inode->i_sb, jbegin_count))
  43                         goto out;
  44                 reiserfs_update_inode_transaction(inode);
  45
  46                 err = reiserfs_delete_object(&th, inode);
  47
  48                 /* Do quota update inside a transaction for journaled quotas. We must do that
  49                  * after delete_object so that quota updates go into the same transaction as
  50                  * stat data deletion */
  51                 if (!err)
  52                         DQUOT_FREE_INODE(inode);
  53
  54                 if (journal_end(&th, inode->i_sb, jbegin_count))
  55                         goto out;
  56
  57                 /* check return value from reiserfs_delete_object after
  58                  * ending the transaction
  59                  */
  60                 if (err)
  61                     goto out;
  62
  63                 /* all items of file are deleted, so we can remove "save" link */
  64                 remove_save_link(inode, 0 /* not truncate */ ); /* we can't do anything
  65                                                                  * about an error here */
  66         } else {
  67                 /* no object items are in the tree */
  68                 ;
  69         }
  70       out:
  71         clear_inode(inode);     /* note this must go after the journal_end to prevent deadlock */
  72         inode->i_blocks = 0;
  73         reiserfs_write_unlock(inode->i_sb);
  74 }
  75
  76 static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,
  77                           __u32 objectid, loff_t offset, int type, int length)
  78 {
  79         key->version = version;
  80
  81         key->on_disk_key.k_dir_id = dirid;
  82         key->on_disk_key.k_objectid = objectid;
  83         set_cpu_key_k_offset(key, offset);
  84         set_cpu_key_k_type(key, type);
  85         key->key_length = length;
  86 }
  87
  88 /* take base of inode_key (it comes from inode always) (dirid, objectid) and version from an inode, set
  89    offset and type of key */
  90 void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,
  91                   int type, int length)
  92 {
  93         _make_cpu_key(key, get_inode_item_key_version(inode),
  94                       le32_to_cpu(INODE_PKEY(inode)->k_dir_id),
  95                       le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,
  96                       length);
  97 }
  98
  99 //
 100 // when key is 0, do not set version and short key
 101 //
 102 inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
 103                               int version,
 104                               loff_t offset, int type, int length,
 105                               int entry_count /*or ih_free_space */ )
 106 {
 107         if (key) {
 108                 ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);
 109                 ih->ih_key.k_objectid =
 110                     cpu_to_le32(key->on_disk_key.k_objectid);
 111         }
 112         put_ih_version(ih, version);
 113         set_le_ih_k_offset(ih, offset);
 114         set_le_ih_k_type(ih, type);
 115         put_ih_item_len(ih, length);
 116         /*    set_ih_free_space (ih, 0); */
 117         // for directory items it is entry count, for directs and stat
 118         // datas - 0xffff, for indirects - 0
 119         put_ih_entry_count(ih, entry_count);
 120 }
 121
 122 //
 123 // FIXME: we might cache recently accessed indirect item
 124
 125 // Ugh.  Not too eager for that....
 126 //  I cut the code until such time as I see a convincing argument (benchmark).
 127 // I don't want a bloated inode struct..., and I don't like code complexity....
 128
 129 /* cutting the code is fine, since it really isn't in use yet and is easy
 130 ** to add back in.  But, Vladimir has a really good idea here.  Think
 131 ** about what happens for reading a file.  For each page,
 132 ** The VFS layer calls reiserfs_readpage, who searches the tree to find
 133 ** an indirect item.  This indirect item has X number of pointers, where
 134 ** X is a big number if we've done the block allocation right.  But,
 135 ** we only use one or two of these pointers during each call to readpage,
 136 ** needlessly researching again later on.
 137 **
 138 ** The size of the cache could be dynamic based on the size of the file.
 139 **
 140 ** I'd also like to see us cache the location the stat data item, since
 141 ** we are needlessly researching for that frequently.
 142 **
 143 ** --chris
 144 */
 145
 146 /* If this page has a file tail in it, and
 147 ** it was read in by get_block_create_0, the page data is valid,
 148 ** but tail is still sitting in a direct item, and we can't write to
 149 ** it.  So, look through this page, and check all the mapped buffers
 150 ** to make sure they have valid block numbers.  Any that don't need
 151 ** to be unmapped, so that block_prepare_write will correctly call
 152 ** reiserfs_get_block to convert the tail into an unformatted node
 153 */
 154 static inline void fix_tail_page_for_writing(struct page *page)
 155 {
 156         struct buffer_head *head, *next, *bh;
 157
 158         if (page && page_has_buffers(page)) {
 159                 head = page_buffers(page);
 160                 bh = head;
 161                 do {
 162                         next = bh->b_this_page;
 163                         if (buffer_mapped(bh) && bh->b_blocknr == 0) {
 164                                 reiserfs_unmap_buffer(bh);
 165                         }
 166                         bh = next;
 167                 } while (bh != head);
 168         }
 169 }
 170
 171 /* reiserfs_get_block does not need to allocate a block only if it has been
 172    done already or non-hole position has been found in the indirect item */
 173 static inline int allocation_needed(int retval, b_blocknr_t allocated,
 174                                     struct item_head *ih,
 175                                     __le32 * item, int pos_in_item)
 176 {
 177         if (allocated)
 178                 return 0;
 179         if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&
 180             get_block_num(item, pos_in_item))
 181                 return 0;
 182         return 1;
 183 }
 184
 185 static inline int indirect_item_found(int retval, struct item_head *ih)
 186 {
 187         return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);
 188 }
 189
 190 static inline void set_block_dev_mapped(struct buffer_head *bh,
 191                                         b_blocknr_t block, struct inode *inode)
 192 {
 193         map_bh(bh, inode->i_sb, block);
 194 }
 195
 196 //
 197 // files which were created in the earlier version can not be longer,
 198 // than 2 gb
 199 //
 200 static int file_capable(struct inode *inode, long block)
 201 {
 202         if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 ||      // it is new file.
 203             block < (1 << (31 - inode->i_sb->s_blocksize_bits)))        // old file, but 'block' is inside of 2gb
 204                 return 1;
 205
 206         return 0;
 207 }
 208
 209 /*static*/ int restart_transaction(struct reiserfs_transaction_handle *th,
 210                                    struct inode *inode, struct path *path)
 211 {
 212         struct super_block *s = th->t_super;
 213         int len = th->t_blocks_allocated;
 214         int err;
 215
 216         BUG_ON(!th->t_trans_id);
 217         BUG_ON(!th->t_refcount);
 218
 219         pathrelse(path);
 220
 221         /* we cannot restart while nested */
 222         if (th->t_refcount > 1) {
 223                 return 0;
 224         }
 225         reiserfs_update_sd(th, inode);
 226         err = journal_end(th, s, len);
 227         if (!err) {
 228                 err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);
 229                 if (!err)
 230                         reiserfs_update_inode_transaction(inode);
 231         }
 232         return err;
 233 }
 234
 235 // it is called by get_block when create == 0. Returns block number
 236 // for 'block'-th logical block of file. When it hits direct item it
 237 // returns 0 (being called from bmap) or read direct item into piece
 238 // of page (bh_result)
 239
 240 // Please improve the english/clarity in the comment above, as it is
 241 // hard to understand.
 242
 243 static int _get_block_create_0(struct inode *inode, long block,
 244                                struct buffer_head *bh_result, int args)
 245 {
 246         INITIALIZE_PATH(path);
 247         struct cpu_key key;
 248         struct buffer_head *bh;
 249         struct item_head *ih, tmp_ih;
 250         int fs_gen;
 251         int blocknr;
 252         char *p = NULL;
 253         int chars;
 254         int ret;
 255         int result;
 256         int done = 0;
 257         unsigned long offset;
 258
 259         // prepare the key to look for the 'block'-th block of file
 260         make_cpu_key(&key, inode,
 261                      (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,
 262                      3);
 263
 264       research:
 265         result = search_for_position_by_key(inode->i_sb, &key, &path);
 266         if (result != POSITION_FOUND) {
 267                 pathrelse(&path);
 268                 if (p)
 269                         kunmap(bh_result->b_page);
 270                 if (result == IO_ERROR)
 271                         return -EIO;
 272                 // We do not return -ENOENT if there is a hole but page is uptodate, because it means
 273                 // That there is some MMAPED data associated with it that is yet to be written to disk.
 274                 if ((args & GET_BLOCK_NO_HOLE)
 275                     && !PageUptodate(bh_result->b_page)) {
 276                         return -ENOENT;
 277                 }
 278                 return 0;
 279         }
 280         //
 281         bh = get_last_bh(&path);
 282         ih = get_ih(&path);
 283         if (is_indirect_le_ih(ih)) {
 284                 __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
 285
 286                 /* FIXME: here we could cache indirect item or part of it in
 287                    the inode to avoid search_by_key in case of subsequent
 288                    access to file */
 289                 blocknr = get_block_num(ind_item, path.pos_in_item);
 290                 ret = 0;
 291                 if (blocknr) {
 292                         map_bh(bh_result, inode->i_sb, blocknr);
 293                         if (path.pos_in_item ==
 294                             ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {
 295                                 set_buffer_boundary(bh_result);
 296                         }
 297                 } else
 298                         // We do not return -ENOENT if there is a hole but page is uptodate, because it means
 299                         // That there is some MMAPED data associated with it that is yet to  be written to disk.
 300                 if ((args & GET_BLOCK_NO_HOLE)
 301                             && !PageUptodate(bh_result->b_page)) {
 302                         ret = -ENOENT;
 303                 }
 304
 305                 pathrelse(&path);
 306                 if (p)
 307                         kunmap(bh_result->b_page);
 308                 return ret;
 309         }
 310         // requested data are in direct item(s)
 311         if (!(args & GET_BLOCK_READ_DIRECT)) {
 312                 // we are called by bmap. FIXME: we can not map block of file
 313                 // when it is stored in direct item(s)
 314                 pathrelse(&path);
 315                 if (p)
 316                         kunmap(bh_result->b_page);
 317                 return -ENOENT;
 318         }
 319
 320         /* if we've got a direct item, and the buffer or page was uptodate,
 321          ** we don't want to pull data off disk again.  skip to the
 322          ** end, where we map the buffer and return
 323          */
 324         if (buffer_uptodate(bh_result)) {
 325                 goto finished;
 326         } else
 327                 /*
 328                  ** grab_tail_page can trigger calls to reiserfs_get_block on up to date
 329                  ** pages without any buffers.  If the page is up to date, we don't want
 330                  ** read old data off disk.  Set the up to date bit on the buffer instead
 331                  ** and jump to the end
 332                  */
 333         if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {
 334                 set_buffer_uptodate(bh_result);
 335                 goto finished;
 336         }
 337         // read file tail into part of page
 338         offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
 339         fs_gen = get_generation(inode->i_sb);
 340         copy_item_head(&tmp_ih, ih);
 341
 342         /* we only want to kmap if we are reading the tail into the page.
 343          ** this is not the common case, so we don't kmap until we are
 344          ** sure we need to.  But, this means the item might move if
 345          ** kmap schedules
 346          */
 347         if (!p) {
 348                 p = (char *)kmap(bh_result->b_page);
 349                 if (fs_changed(fs_gen, inode->i_sb)
 350                     && item_moved(&tmp_ih, &path)) {
 351                         goto research;
 352                 }
 353         }
 354         p += offset;
 355         memset(p, 0, inode->i_sb->s_blocksize);
 356         do {
 357                 if (!is_direct_le_ih(ih)) {
 358                         BUG();
 359                 }
 360                 /* make sure we don't read more bytes than actually exist in
 361                  ** the file.  This can happen in odd cases where i_size isn't
 362                  ** correct, and when direct item padding results in a few
 363                  ** extra bytes at the end of the direct item
 364                  */
 365                 if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)
 366                         break;
 367                 if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {
 368                         chars =
 369                             inode->i_size - (le_ih_k_offset(ih) - 1) -
 370                             path.pos_in_item;
 371                         done = 1;
 372                 } else {
 373                         chars = ih_item_len(ih) - path.pos_in_item;
 374                 }
 375                 memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
 376
 377                 if (done)
 378                         break;
 379
 380                 p += chars;
 381
 382                 if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))
 383                         // we done, if read direct item is not the last item of
 384                         // node FIXME: we could try to check right delimiting key
 385                         // to see whether direct item continues in the right
 386                         // neighbor or rely on i_size
 387                         break;
 388
 389                 // update key to look for the next piece
 390                 set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);
 391                 result = search_for_position_by_key(inode->i_sb, &key, &path);
 392                 if (result != POSITION_FOUND)
 393                         // i/o error most likely
 394                         break;
 395                 bh = get_last_bh(&path);
 396                 ih = get_ih(&path);
 397         } while (1);
 398
 399         flush_dcache_page(bh_result->b_page);
 400         kunmap(bh_result->b_page);
 401
 402       finished:
 403         pathrelse(&path);
 404
 405         if (result == IO_ERROR)
 406                 return -EIO;
 407
 408         /* this buffer has valid data, but isn't valid for io.  mapping it to
 409          * block #0 tells the rest of reiserfs it just has a tail in it
 410          */
 411         map_bh(bh_result, inode->i_sb, 0);
 412         set_buffer_uptodate(bh_result);
 413         return 0;
 414 }
 415
 416 // this is called to create file map. So, _get_block_create_0 will not
 417 // read direct item
 418 static int reiserfs_bmap(struct inode *inode, sector_t block,
 419                          struct buffer_head *bh_result, int create)
 420 {
 421         if (!file_capable(inode, block))
 422                 return -EFBIG;
 423
 424         reiserfs_write_lock(inode->i_sb);
 425         /* do not read the direct item */
 426         _get_block_create_0(inode, block, bh_result, 0);
 427         reiserfs_write_unlock(inode->i_sb);
 428         return 0;
 429 }
 430
 431 /* special version of get_block that is only used by grab_tail_page right
 432 ** now.  It is sent to block_prepare_write, and when you try to get a
 433 ** block past the end of the file (or a block from a hole) it returns
 434 ** -ENOENT instead of a valid buffer.  block_prepare_write expects to
 435 ** be able to do i/o on the buffers returned, unless an error value
 436 ** is also returned.
 437 **
 438 ** So, this allows block_prepare_write to be used for reading a single block
 439 ** in a page.  Where it does not produce a valid page for holes, or past the
 440 ** end of the file.  This turns out to be exactly what we need for reading
 441 ** tails for conversion.
 442 **
 443 ** The point of the wrapper is forcing a certain value for create, even
 444 ** though the VFS layer is calling this function with create==1.  If you
 445 ** don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,
 446 ** don't use this function.
 447 */
 448 static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
 449                                        struct buffer_head *bh_result,
 450                                        int create)
 451 {
 452         return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);
 453 }
 454
 455 /* This is special helper for reiserfs_get_block in case we are executing
 456    direct_IO request. */
 457 static int reiserfs_get_blocks_direct_io(struct inode *inode,
 458                                          sector_t iblock,
 459                                          struct buffer_head *bh_result,
 460                                          int create)
 461 {
 462         int ret;
 463
 464         bh_result->b_page = NULL;
 465
 466         /* We set the b_size before reiserfs_get_block call since it is
 467            referenced in convert_tail_for_hole() that may be called from
 468            reiserfs_get_block() */
 469         bh_result->b_size = (1 << inode->i_blkbits);
 470
 471         ret = reiserfs_get_block(inode, iblock, bh_result,
 472                                  create | GET_BLOCK_NO_DANGLE);
 473         if (ret)
 474                 goto out;
 475
 476         /* don't allow direct io onto tail pages */
 477         if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
 478                 /* make sure future calls to the direct io funcs for this offset
 479                  ** in the file fail by unmapping the buffer
 480                  */
 481                 clear_buffer_mapped(bh_result);
 482                 ret = -EINVAL;
 483         }
 484         /* Possible unpacked tail. Flush the data before pages have
 485            disappeared */
 486         if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {
 487                 int err;
 488                 lock_kernel();
 489                 err = reiserfs_commit_for_inode(inode);
 490                 REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
 491                 unlock_kernel();
 492                 if (err < 0)
 493                         ret = err;
 494         }
 495       out:
 496         return ret;
 497 }
 498
 499 /*
 500 ** helper function for when reiserfs_get_block is called for a hole
 501 ** but the file tail is still in a direct item
 502 ** bh_result is the buffer head for the hole
 503 ** tail_offset is the offset of the start of the tail in the file
 504 **
 505 ** This calls prepare_write, which will start a new transaction
 506 ** you should not be in a transaction, or have any paths held when you
 507 ** call this.
 508 */
 509 static int convert_tail_for_hole(struct inode *inode,
 510                                  struct buffer_head *bh_result,
 511                                  loff_t tail_offset)
 512 {
 513         unsigned long index;
 514         unsigned long tail_end;
 515         unsigned long tail_start;
 516         struct page *tail_page;
 517         struct page *hole_page = bh_result->b_page;
 518         int retval = 0;
 519
 520         if ((tail_offset & (bh_result->b_size - 1)) != 1)
 521                 return -EIO;
 522
 523         /* always try to read until the end of the block */
 524         tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
 525         tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
 526
 527         index = tail_offset >> PAGE_CACHE_SHIFT;
 528         /* hole_page can be zero in case of direct_io, we are sure
 529            that we cannot get here if we write with O_DIRECT into
 530            tail page */
 531         if (!hole_page || index != hole_page->index) {
 532                 tail_page = grab_cache_page(inode->i_mapping, index);
 533                 retval = -ENOMEM;
 534                 if (!tail_page) {
 535                         goto out;
 536                 }
 537         } else {
 538                 tail_page = hole_page;
 539         }
 540
 541         /* we don't have to make sure the conversion did not happen while
 542          ** we were locking the page because anyone that could convert
 543          ** must first take i_mutex.
 544          **
 545          ** We must fix the tail page for writing because it might have buffers
 546          ** that are mapped, but have a block number of 0.  This indicates tail
 547          ** data that has been read directly into the page, and block_prepare_write
 548          ** won't trigger a get_block in this case.
 549          */
 550         fix_tail_page_for_writing(tail_page);
 551         retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);
 552         if (retval)
 553                 goto unlock;
 554
 555         /* tail conversion might change the data in the page */
 556         flush_dcache_page(tail_page);
 557
 558         retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);
 559
 560       unlock:
 561         if (tail_page != hole_page) {
 562                 unlock_page(tail_page);
 563                 page_cache_release(tail_page);
 564         }
 565       out:
 566         return retval;
 567 }
 568
 569 static inline int _allocate_block(struct reiserfs_transaction_handle *th,
 570                                   long block,
 571                                   struct inode *inode,
 572                                   b_blocknr_t * allocated_block_nr,
 573                                   struct path *path, int flags)
 574 {
 575         BUG_ON(!th->t_trans_id);
 576
 577 #ifdef REISERFS_PREALLOCATE
 578         if (!(flags & GET_BLOCK_NO_IMUX)) {
 579                 return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,
 580                                                   path, block);
 581         }
 582 #endif
 583         return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,
 584                                          block);
 585 }
 586
 587 int reiserfs_get_block(struct inode *inode, sector_t block,
 588                        struct buffer_head *bh_result, int create)
 589 {
 590         int repeat, retval = 0;
 591         b_blocknr_t allocated_block_nr = 0;     // b_blocknr_t is (unsigned) 32 bit int
 592         INITIALIZE_PATH(path);
 593         int pos_in_item;
 594         struct cpu_key key;
 595         struct buffer_head *bh, *unbh = NULL;
 596         struct item_head *ih, tmp_ih;
 597         __le32 *item;
 598         int done;
 599         int fs_gen;
 600         struct reiserfs_transaction_handle *th = NULL;
 601         /* space reserved in transaction batch:
 602            . 3 balancings in direct->indirect conversion
 603            . 1 block involved into reiserfs_update_sd()
 604            XXX in practically impossible worst case direct2indirect()
 605            can incur (much) more than 3 balancings.
 606            quota update for user, group */
 607         int jbegin_count =
 608             JOURNAL_PER_BALANCE_CNT * 3 + 1 +
 609             2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
 610         int version;
 611         int dangle = 1;
 612         loff_t new_offset =
 613             (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;
 614
 615         /* bad.... */
 616         reiserfs_write_lock(inode->i_sb);
 617         version = get_inode_item_key_version(inode);
 618
 619         if (!file_capable(inode, block)) {
 620                 reiserfs_write_unlock(inode->i_sb);
 621                 return -EFBIG;
 622         }
 623
 624         /* if !create, we aren't changing the FS, so we don't need to
 625          ** log anything, so we don't need to start a transaction
 626          */
 627         if (!(create & GET_BLOCK_CREATE)) {
 628                 int ret;
 629                 /* find number of block-th logical block of the file */
 630                 ret = _get_block_create_0(inode, block, bh_result,
 631                                           create | GET_BLOCK_READ_DIRECT);
 632                 reiserfs_write_unlock(inode->i_sb);
 633                 return ret;
 634         }
 635         /*
 636          * if we're already in a transaction, make sure to close
 637          * any new transactions we start in this func
 638          */
 639         if ((create & GET_BLOCK_NO_DANGLE) ||
 640             reiserfs_transaction_running(inode->i_sb))
 641                 dangle = 0;
 642
 643         /* If file is of such a size, that it might have a tail and tails are enabled
 644          ** we should mark it as possibly needing tail packing on close
 645          */
 646         if ((have_large_tails(inode->i_sb)
 647              && inode->i_size < i_block_size(inode) * 4)
 648             || (have_small_tails(inode->i_sb)
 649                 && inode->i_size < i_block_size(inode)))
 650                 REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;
 651
 652         /* set the key of the first byte in the 'block'-th block of file */
 653         make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );
 654         if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {
 655               start_trans:
 656                 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);
 657                 if (!th) {
 658                         retval = -ENOMEM;
 659                         goto failure;
 660                 }
 661                 reiserfs_update_inode_transaction(inode);
 662         }
 663       research:
 664
 665         retval = search_for_position_by_key(inode->i_sb, &key, &path);
 666         if (retval == IO_ERROR) {
 667                 retval = -EIO;
 668                 goto failure;
 669         }
 670
 671         bh = get_last_bh(&path);
 672         ih = get_ih(&path);
 673         item = get_item(&path);
 674         pos_in_item = path.pos_in_item;
 675
 676         fs_gen = get_generation(inode->i_sb);
 677         copy_item_head(&tmp_ih, ih);
 678
 679         if (allocation_needed
 680             (retval, allocated_block_nr, ih, item, pos_in_item)) {
 681                 /* we have to allocate block for the unformatted node */
 682                 if (!th) {
 683                         pathrelse(&path);
 684                         goto start_trans;
 685                 }
 686
 687                 repeat =
 688                     _allocate_block(th, block, inode, &allocated_block_nr,
 689                                     &path, create);
 690
 691                 if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {
 692                         /* restart the transaction to give the journal a chance to free
 693                          ** some blocks.  releases the path, so we have to go back to
 694                          ** research if we succeed on the second try
 695                          */
 696                         SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;
 697                         retval = restart_transaction(th, inode, &path);
 698                         if (retval)
 699                                 goto failure;
 700                         repeat =
 701                             _allocate_block(th, block, inode,
 702                                             &allocated_block_nr, NULL, create);
 703
 704                         if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {
 705                                 goto research;
 706                         }
 707                         if (repeat == QUOTA_EXCEEDED)
 708                                 retval = -EDQUOT;
 709                         else
 710                                 retval = -ENOSPC;
 711                         goto failure;
 712                 }
 713
 714                 if (fs_changed(fs_gen, inode->i_sb)
 715                     && item_moved(&tmp_ih, &path)) {
 716                         goto research;
 717                 }
 718         }
 719
 720         if (indirect_item_found(retval, ih)) {
 721                 b_blocknr_t unfm_ptr;
 722                 /* 'block'-th block is in the file already (there is
 723                    corresponding cell in some indirect item). But it may be
 724                    zero unformatted node pointer (hole) */
 725                 unfm_ptr = get_block_num(item, pos_in_item);
 726                 if (unfm_ptr == 0) {
 727                         /* use allocated block to plug the hole */
 728                         reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
 729                         if (fs_changed(fs_gen, inode->i_sb)
 730                             && item_moved(&tmp_ih, &path)) {
 731                                 reiserfs_restore_prepared_buffer(inode->i_sb,
 732                                                                  bh);
 733                                 goto research;
 734                         }
 735                         set_buffer_new(bh_result);
 736                         if (buffer_dirty(bh_result)
 737                             && reiserfs_data_ordered(inode->i_sb))
 738                                 reiserfs_add_ordered_list(inode, bh_result);
 739                         put_block_num(item, pos_in_item, allocated_block_nr);
 740                         unfm_ptr = allocated_block_nr;
 741                         journal_mark_dirty(th, inode->i_sb, bh);
 742                         reiserfs_update_sd(th, inode);
 743                 }
 744                 set_block_dev_mapped(bh_result, unfm_ptr, inode);
 745                 pathrelse(&path);
 746                 retval = 0;
 747                 if (!dangle && th)
 748                         retval = reiserfs_end_persistent_transaction(th);
 749
 750                 reiserfs_write_unlock(inode->i_sb);
 751
 752                 /* the item was found, so new blocks were not added to the file
 753                  ** there is no need to make sure the inode is updated with this
 754                  ** transaction
 755                  */
 756                 return retval;
 757         }
 758
 759         if (!th) {
 760                 pathrelse(&path);
 761                 goto start_trans;
 762         }
 763
 764         /* desired position is not found or is in the direct item. We have
 765            to append file with holes up to 'block'-th block converting
 766            direct items to indirect one if necessary */
 767         done = 0;
 768         do {
 769                 if (is_statdata_le_ih(ih)) {
 770                         __le32 unp = 0;
 771                         struct cpu_key tmp_key;
 772
 773                         /* indirect item has to be inserted */
 774                         make_le_item_head(&tmp_ih, &key, version, 1,
 775                                           TYPE_INDIRECT, UNFM_P_SIZE,
 776                                           0 /* free_space */ );
 777
 778                         if (cpu_key_k_offset(&key) == 1) {
 779                                 /* we are going to add 'block'-th block to the file. Use
 780                                    allocated block for that */
 781                                 unp = cpu_to_le32(allocated_block_nr);
 782                                 set_block_dev_mapped(bh_result,
 783                                                      allocated_block_nr, inode);
 784                                 set_buffer_new(bh_result);
 785                                 done = 1;
 786                         }
 787                         tmp_key = key;  // ;)
 788                         set_cpu_key_k_offset(&tmp_key, 1);
 789                         PATH_LAST_POSITION(&path)++;
 790
 791                         retval =
 792                             reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,
 793                                                  inode, (char *)&unp);
 794                         if (retval) {
 795                                 reiserfs_free_block(th, inode,
 796                                                     allocated_block_nr, 1);
 797                                 goto failure;   // retval == -ENOSPC, -EDQUOT or -EIO or -EEXIST
 798                         }
 799                         //mark_tail_converted (inode);
 800                 } else if (is_direct_le_ih(ih)) {
 801                         /* direct item has to be converted */
 802                         loff_t tail_offset;
 803
 804                         tail_offset =
 805                             ((le_ih_k_offset(ih) -
 806                               1) & ~(inode->i_sb->s_blocksize - 1)) + 1;
 807                         if (tail_offset == cpu_key_k_offset(&key)) {
 808                                 /* direct item we just found fits into block we have
 809                                    to map. Convert it into unformatted node: use
 810                                    bh_result for the conversion */
 811                                 set_block_dev_mapped(bh_result,
 812                                                      allocated_block_nr, inode);
 813                                 unbh = bh_result;
 814                                 done = 1;
 815                         } else {
 816                                 /* we have to padd file tail stored in direct item(s)
 817                                    up to block size and convert it to unformatted
 818                                    node. FIXME: this should also get into page cache */
 819
 820                                 pathrelse(&path);
 821                                 /*
 822                                  * ugly, but we can only end the transaction if
 823                                  * we aren't nested
 824                                  */
 825                                 BUG_ON(!th->t_refcount);
 826                                 if (th->t_refcount == 1) {
 827                                         retval =
 828                                             reiserfs_end_persistent_transaction
 829                                             (th);
 830                                         th = NULL;
 831                                         if (retval)
 832                                                 goto failure;
 833                                 }
 834
 835                                 retval =
 836                                     convert_tail_for_hole(inode, bh_result,
 837                                                           tail_offset);
 838                                 if (retval) {
 839                                         if (retval != -ENOSPC)
 840                                                 reiserfs_warning(inode->i_sb,
 841                                                                  "clm-6004: convert tail failed inode %lu, error %d",
 842                                                                  inode->i_ino,
 843                                                                  retval);
 844                                         if (allocated_block_nr) {
 845                                                 /* the bitmap, the super, and the stat data == 3 */
 846                                                 if (!th)
 847                                                         th = reiserfs_persistent_transaction(inode->i_sb, 3);
 848                                                 if (th)
 849                                                         reiserfs_free_block(th,
 850                                                                             inode,
 851                                                                             allocated_block_nr,
 852                                                                             1);
 853                                         }
 854                                         goto failure;
 855                                 }
 856                                 goto research;
 857                         }
 858                         retval =
 859                             direct2indirect(th, inode, &path, unbh,
 860                                             tail_offset);
 861                         if (retval) {
 862                                 reiserfs_unmap_buffer(unbh);
 863                                 reiserfs_free_block(th, inode,
 864                                                     allocated_block_nr, 1);
 865                                 goto failure;
 866                         }
 867                         /* it is important the set_buffer_uptodate is done after
 868                          ** the direct2indirect.  The buffer might contain valid
 869                          ** data newer than the data on disk (read by readpage, changed,
 870                          ** and then sent here by writepage).  direct2indirect needs
 871                          ** to know if unbh was already up to date, so it can decide
 872                          ** if the data in unbh needs to be replaced with data from
 873                          ** the disk
 874                          */
 875                         set_buffer_uptodate(unbh);
 876
 877                         /* unbh->b_page == NULL in case of DIRECT_IO request, this means
 878                            buffer will disappear shortly, so it should not be added to
 879                          */
 880                         if (unbh->b_page) {
 881                                 /* we've converted the tail, so we must
 882                                  ** flush unbh before the transaction commits
 883                                  */
 884                                 reiserfs_add_tail_list(inode, unbh);
 885
 886                                 /* mark it dirty now to prevent commit_write from adding
 887                                  ** this buffer to the inode's dirty buffer list
 888                                  */
 889                                 /*
 890                                  * AKPM: changed __mark_buffer_dirty to mark_buffer_dirty().
 891                                  * It's still atomic, but it sets the page dirty too,
 892                                  * which makes it eligible for writeback at any time by the
 893                                  * VM (which was also the case with __mark_buffer_dirty())
 894                                  */
 895                                 mark_buffer_dirty(unbh);
 896                         }
 897                 } else {
 898                         /* append indirect item with holes if needed, when appending
 899                            pointer to 'block'-th block use block, which is already
 900                            allocated */
 901                         struct cpu_key tmp_key;
 902                         unp_t unf_single = 0;   // We use this in case we need to allocate only
 903                         // one block which is a fastpath
 904                         unp_t *un;
 905                         __u64 max_to_insert =
 906                             MAX_ITEM_LEN(inode->i_sb->s_blocksize) /
 907                             UNFM_P_SIZE;
 908                         __u64 blocks_needed;
 909
 910                         RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,
 911                                "vs-804: invalid position for append");
 912                         /* indirect item has to be appended, set up key of that position */
 913                         make_cpu_key(&tmp_key, inode,
 914                                      le_key_k_offset(version,
 915                                                      &(ih->ih_key)) +
 916                                      op_bytes_number(ih,
 917                                                      inode->i_sb->s_blocksize),
 918                                      //pos_in_item * inode->i_sb->s_blocksize,
 919                                      TYPE_INDIRECT, 3); // key type is unimportant
 920
 921                         RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),
 922                                "green-805: invalid offset");
 923                         blocks_needed =
 924                             1 +
 925                             ((cpu_key_k_offset(&key) -
 926                               cpu_key_k_offset(&tmp_key)) >> inode->i_sb->
 927                              s_blocksize_bits);
 928
 929                         if (blocks_needed == 1) {
 930                                 un = &unf_single;
 931                         } else {
 932                                 un = kmalloc(min(blocks_needed, max_to_insert) * UNFM_P_SIZE, GFP_ATOMIC);      // We need to avoid scheduling.
 933                                 if (!un) {
 934                                         un = &unf_single;
 935                                         blocks_needed = 1;
 936                                         max_to_insert = 0;
 937                                 } else
 938                                         memset(un, 0,
 939                                                UNFM_P_SIZE * min(blocks_needed,
 940                                                                  max_to_insert));
 941                         }
 942                         if (blocks_needed <= max_to_insert) {
 943                                 /* we are going to add target block to the file. Use allocated
 944                                    block for that */
 945                                 un[blocks_needed - 1] =
 946                                     cpu_to_le32(allocated_block_nr);
 947                                 set_block_dev_mapped(bh_result,
 948                                                      allocated_block_nr, inode);
 949                                 set_buffer_new(bh_result);
 950                                 done = 1;
 951                         } else {
 952                                 /* paste hole to the indirect item */
 953                                 /* If kmalloc failed, max_to_insert becomes zero and it means we
 954                                    only have space for one block */
 955                                 blocks_needed =
 956                                     max_to_insert ? max_to_insert : 1;
 957                         }
 958                         retval =
 959                             reiserfs_paste_into_item(th, &path, &tmp_key, inode,
 960                                                      (char *)un,
 961                                                      UNFM_P_SIZE *
 962                                                      blocks_needed);
 963
 964                         if (blocks_needed != 1)
 965                                 kfree(un);
 966
 967                         if (retval) {
 968                                 reiserfs_free_block(th, inode,
 969                                                     allocated_block_nr, 1);
 970                                 goto failure;
 971                         }
 972                         if (!done) {
 973                                 /* We need to mark new file size in case this function will be
 974                                    interrupted/aborted later on. And we may do this only for
 975                                    holes. */
 976                                 inode->i_size +=
 977                                     inode->i_sb->s_blocksize * blocks_needed;
 978                         }
 979                 }
 980
 981                 if (done == 1)
 982                         break;
 983
 984                 /* this loop could log more blocks than we had originally asked
 985                  ** for.  So, we have to allow the transaction to end if it is
 986                  ** too big or too full.  Update the inode so things are
 987                  ** consistent if we crash before the function returns
 988                  **
 989                  ** release the path so that anybody waiting on the path before
 990                  ** ending their transaction will be able to continue.
 991                  */
 992                 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
 993                         retval = restart_transaction(th, inode, &path);
 994                         if (retval)
 995                                 goto failure;
 996                 }
 997                 /* inserting indirect pointers for a hole can take a
 998                  ** long time.  reschedule if needed
 999                  */
1000                 cond_resched();
1001
1002                 retval = search_for_position_by_key(inode->i_sb, &key, &path);
1003                 if (retval == IO_ERROR) {
1004                         retval = -EIO;
1005                         goto failure;
1006                 }
1007                 if (retval == POSITION_FOUND) {
1008                         reiserfs_warning(inode->i_sb,
1009                                          "vs-825: reiserfs_get_block: "
1010                                          "%K should not be found", &key);
1011                         retval = -EEXIST;
1012                         if (allocated_block_nr)
1013                                 reiserfs_free_block(th, inode,
1014                                                     allocated_block_nr, 1);
1015                         pathrelse(&path);
1016                         goto failure;
1017                 }
1018                 bh = get_last_bh(&path);
1019                 ih = get_ih(&path);
1020                 item = get_item(&path);
1021                 pos_in_item = path.pos_in_item;
1022         } while (1);
1023
1024         retval = 0;
1025
1026       failure:
1027         if (th && (!dangle || (retval && !th->t_trans_id))) {
1028                 int err;
1029                 if (th->t_trans_id)
1030                         reiserfs_update_sd(th, inode);
1031                 err = reiserfs_end_persistent_transaction(th);
1032                 if (err)
1033                         retval = err;
1034         }
1035
1036         reiserfs_write_unlock(inode->i_sb);
1037         reiserfs_check_path(&path);
1038         return retval;
1039 }
1040
1041 static int
1042 reiserfs_readpages(struct file *file, struct address_space *mapping,
1043                    struct list_head *pages, unsigned nr_pages)
1044 {
1045         return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
1046 }
1047
1048 /* Compute real number of used bytes by file
1049  * Following three functions can go away when we'll have enough space in stat item
1050  */
1051 static int real_space_diff(struct inode *inode, int sd_size)
1052 {
1053         int bytes;
1054         loff_t blocksize = inode->i_sb->s_blocksize;
1055
1056         if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1057                 return sd_size;
1058
1059         /* End of file is also in full block with indirect reference, so round
1060          ** up to the next block.
1061          **
1062          ** there is just no way to know if the tail is actually packed
1063          ** on the file, so we have to assume it isn't.  When we pack the
1064          ** tail, we add 4 bytes to pretend there really is an unformatted
1065          ** node pointer
1066          */
1067         bytes =
1068             ((inode->i_size +
1069               (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1070             sd_size;
1071         return bytes;
1072 }
1073
1074 static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
1075                                         int sd_size)
1076 {
1077         if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1078                 return inode->i_size +
1079                     (loff_t) (real_space_diff(inode, sd_size));
1080         }
1081         return ((loff_t) real_space_diff(inode, sd_size)) +
1082             (((loff_t) blocks) << 9);
1083 }
1084
1085 /* Compute number of blocks used by file in ReiserFS counting */
1086 static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1087 {
1088         loff_t bytes = inode_get_bytes(inode);
1089         loff_t real_space = real_space_diff(inode, sd_size);
1090
1091         /* keeps fsck and non-quota versions of reiserfs happy */
1092         if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1093                 bytes += (loff_t) 511;
1094         }
1095
1096         /* files from before the quota patch might i_blocks such that
1097          ** bytes < real_space.  Deal with that here to prevent it from
1098          ** going negative.
1099          */
1100         if (bytes < real_space)
1101                 return 0;
1102         return (bytes - real_space) >> 9;
1103 }
1104
1105 //
1106 // BAD: new directories have stat data of new type and all other items
1107 // of old type. Version stored in the inode says about body items, so
1108 // in update_stat_data we can not rely on inode, but have to check
1109 // item version directly
1110 //
1111
1112 // called by read_locked_inode
1113 static void init_inode(struct inode *inode, struct path *path)
1114 {
1115         struct buffer_head *bh;
1116         struct item_head *ih;
1117         __u32 rdev;
1118         //int version = ITEM_VERSION_1;
1119
1120         bh = PATH_PLAST_BUFFER(path);
1121         ih = PATH_PITEM_HEAD(path);
1122
1123         copy_key(INODE_PKEY(inode), &(ih->ih_key));
1124
1125         INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1126         REISERFS_I(inode)->i_flags = 0;
1127         REISERFS_I(inode)->i_prealloc_block = 0;
1128         REISERFS_I(inode)->i_prealloc_count = 0;
1129         REISERFS_I(inode)->i_trans_id = 0;
1130         REISERFS_I(inode)->i_jl = NULL;
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 path *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 path *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 path *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         reiserfs_init_acl_access(inode);
1839         reiserfs_init_acl_default(inode);
1840         reiserfs_init_xattr_rwsem(inode);
1841
1842         if (old_format_only(sb))
1843                 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1844                                   TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1845         else
1846                 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1847                                   TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1848
1849         /* key to search for correct place for new stat data */
1850         _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1851                       le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1852                       TYPE_STAT_DATA, 3 /*key length */ );
1853
1854         /* find proper place for inserting of stat data */
1855         retval = search_item(sb, &key, &path_to_key);
1856         if (retval == IO_ERROR) {
1857                 err = -EIO;
1858                 goto out_bad_inode;
1859         }
1860         if (retval == ITEM_FOUND) {
1861                 pathrelse(&path_to_key);
1862                 err = -EEXIST;
1863                 goto out_bad_inode;
1864         }
1865         if (old_format_only(sb)) {
1866                 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1867                         pathrelse(&path_to_key);
1868                         /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1869                         err = -EINVAL;
1870                         goto out_bad_inode;
1871                 }
1872                 inode2sd_v1(&sd, inode, inode->i_size);
1873         } else {
1874                 inode2sd(&sd, inode, inode->i_size);
1875         }
1876         // these do not go to on-disk stat data
1877         inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1878
1879         // store in in-core inode the key of stat data and version all
1880         // object items will have (directory items will have old offset
1881         // format, other new objects will consist of new items)
1882         memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1883         if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1884                 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1885         else
1886                 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1887         if (old_format_only(sb))
1888                 set_inode_sd_version(inode, STAT_DATA_V1);
1889         else
1890                 set_inode_sd_version(inode, STAT_DATA_V2);
1891
1892         /* insert the stat data into the tree */
1893 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1894         if (REISERFS_I(dir)->new_packing_locality)
1895                 th->displace_new_blocks = 1;
1896 #endif
1897         retval =
1898             reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1899                                  (char *)(&sd));
1900         if (retval) {
1901                 err = retval;
1902                 reiserfs_check_path(&path_to_key);
1903                 goto out_bad_inode;
1904         }
1905 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1906         if (!th->displace_new_blocks)
1907                 REISERFS_I(dir)->new_packing_locality = 0;
1908 #endif
1909         if (S_ISDIR(mode)) {
1910                 /* insert item with "." and ".." */
1911                 retval =
1912                     reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1913         }
1914
1915         if (S_ISLNK(mode)) {
1916                 /* insert body of symlink */
1917                 if (!old_format_only(sb))
1918                         i_size = ROUND_UP(i_size);
1919                 retval =
1920                     reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1921                                          i_size);
1922         }
1923         if (retval) {
1924                 err = retval;
1925                 reiserfs_check_path(&path_to_key);
1926                 journal_end(th, th->t_super, th->t_blocks_allocated);
1927                 goto out_inserted_sd;
1928         }
1929
1930         /* XXX CHECK THIS */
1931         if (reiserfs_posixacl(inode->i_sb)) {
1932                 retval = reiserfs_inherit_default_acl(dir, dentry, inode);
1933                 if (retval) {
1934                         err = retval;
1935                         reiserfs_check_path(&path_to_key);
1936                         journal_end(th, th->t_super, th->t_blocks_allocated);
1937                         goto out_inserted_sd;
1938                 }
1939         } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1940                 reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
1941                                  "but vfs thinks they are!");
1942         } else if (is_reiserfs_priv_object(dir)) {
1943                 reiserfs_mark_inode_private(inode);
1944         }
1945
1946         insert_inode_hash(inode);
1947         reiserfs_update_sd(th, inode);
1948         reiserfs_check_path(&path_to_key);
1949
1950         return 0;
1951
1952 /* it looks like you can easily compress these two goto targets into
1953  * one.  Keeping it like this doesn't actually hurt anything, and they
1954  * are place holders for what the quota code actually needs.
1955  */
1956       out_bad_inode:
1957         /* Invalidate the object, nothing was inserted yet */
1958         INODE_PKEY(inode)->k_objectid = 0;
1959
1960         /* Quota change must be inside a transaction for journaling */
1961         DQUOT_FREE_INODE(inode);
1962
1963       out_end_trans:
1964         journal_end(th, th->t_super, th->t_blocks_allocated);
1965         /* Drop can be outside and it needs more credits so it's better to have it outside */
1966         DQUOT_DROP(inode);
1967         inode->i_flags |= S_NOQUOTA;
1968         make_bad_inode(inode);
1969
1970       out_inserted_sd:
1971         inode->i_nlink = 0;
1972         th->t_trans_id = 0;     /* so the caller can't use this handle later */
1973
1974         /* If we were inheriting an ACL, we need to release the lock so that
1975          * iput doesn't deadlock in reiserfs_delete_xattrs. The locking
1976          * code really needs to be reworked, but this will take care of it
1977          * for now. -jeffm */
1978 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1979         if (REISERFS_I(dir)->i_acl_default && !IS_ERR(REISERFS_I(dir)->i_acl_default)) {
1980                 reiserfs_write_unlock_xattrs(dir->i_sb);
1981                 iput(inode);
1982                 reiserfs_write_lock_xattrs(dir->i_sb);
1983         } else
1984 #endif
1985                 iput(inode);
1986         return err;
1987 }
1988
1989 /*
1990 ** finds the tail page in the page cache,
1991 ** reads the last block in.
1992 **
1993 ** On success, page_result is set to a locked, pinned page, and bh_result
1994 ** is set to an up to date buffer for the last block in the file.  returns 0.
1995 **
1996 ** tail conversion is not done, so bh_result might not be valid for writing
1997 ** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
1998 ** trying to write the block.
1999 **
2000 ** on failure, nonzero is returned, page_result and bh_result are untouched.
2001 */
2002 static int grab_tail_page(struct inode *p_s_inode,
2003                           struct page **page_result,
2004                           struct buffer_head **bh_result)
2005 {
2006
2007         /* we want the page with the last byte in the file,
2008          ** not the page that will hold the next byte for appending
2009          */
2010         unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;
2011         unsigned long pos = 0;
2012         unsigned long start = 0;
2013         unsigned long blocksize = p_s_inode->i_sb->s_blocksize;
2014         unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);
2015         struct buffer_head *bh;
2016         struct buffer_head *head;
2017         struct page *page;
2018         int error;
2019
2020         /* we know that we are only called with inode->i_size > 0.
2021          ** we also know that a file tail can never be as big as a block
2022          ** If i_size % blocksize == 0, our file is currently block aligned
2023          ** and it won't need converting or zeroing after a truncate.
2024          */
2025         if ((offset & (blocksize - 1)) == 0) {
2026                 return -ENOENT;
2027         }
2028         page = grab_cache_page(p_s_inode->i_mapping, index);
2029         error = -ENOMEM;
2030         if (!page) {
2031                 goto out;
2032         }
2033         /* start within the page of the last block in the file */
2034         start = (offset / blocksize) * blocksize;
2035
2036         error = block_prepare_write(page, start, offset,
2037                                     reiserfs_get_block_create_0);
2038         if (error)
2039                 goto unlock;
2040
2041         head = page_buffers(page);
2042         bh = head;
2043         do {
2044                 if (pos >= start) {
2045                         break;
2046                 }
2047                 bh = bh->b_this_page;
2048                 pos += blocksize;
2049         } while (bh != head);
2050
2051         if (!buffer_uptodate(bh)) {
2052                 /* note, this should never happen, prepare_write should
2053                  ** be taking care of this for us.  If the buffer isn't up to date,
2054                  ** I've screwed up the code to find the buffer, or the code to
2055                  ** call prepare_write
2056                  */
2057                 reiserfs_warning(p_s_inode->i_sb,
2058                                  "clm-6000: error reading block %lu on dev %s",
2059                                  bh->b_blocknr,
2060                                  reiserfs_bdevname(p_s_inode->i_sb));
2061                 error = -EIO;
2062                 goto unlock;
2063         }
2064         *bh_result = bh;
2065         *page_result = page;
2066
2067       out:
2068         return error;
2069
2070       unlock:
2071         unlock_page(page);
2072         page_cache_release(page);
2073         return error;
2074 }
2075
2076 /*
2077 ** vfs version of truncate file.  Must NOT be called with
2078 ** a transaction already started.
2079 **
2080 ** some code taken from block_truncate_page
2081 */
2082 int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
2083 {
2084         struct reiserfs_transaction_handle th;
2085         /* we want the offset for the first byte after the end of the file */
2086         unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);
2087         unsigned blocksize = p_s_inode->i_sb->s_blocksize;
2088         unsigned length;
2089         struct page *page = NULL;
2090         int error;
2091         struct buffer_head *bh = NULL;
2092         int err2;
2093
2094         reiserfs_write_lock(p_s_inode->i_sb);
2095
2096         if (p_s_inode->i_size > 0) {
2097                 if ((error = grab_tail_page(p_s_inode, &page, &bh))) {
2098                         // -ENOENT means we truncated past the end of the file,
2099                         // and get_block_create_0 could not find a block to read in,
2100                         // which is ok.
2101                         if (error != -ENOENT)
2102                                 reiserfs_warning(p_s_inode->i_sb,
2103                                                  "clm-6001: grab_tail_page failed %d",
2104                                                  error);
2105                         page = NULL;
2106                         bh = NULL;
2107                 }
2108         }
2109
2110         /* so, if page != NULL, we have a buffer head for the offset at
2111          ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2112          ** then we have an unformatted node.  Otherwise, we have a direct item,
2113          ** and no zeroing is required on disk.  We zero after the truncate,
2114          ** because the truncate might pack the item anyway
2115          ** (it will unmap bh if it packs).
2116          */
2117         /* it is enough to reserve space in transaction for 2 balancings:
2118            one for "save" link adding and another for the first
2119            cut_from_item. 1 is for update_sd */
2120         error = journal_begin(&th, p_s_inode->i_sb,
2121                               JOURNAL_PER_BALANCE_CNT * 2 + 1);
2122         if (error)
2123                 goto out;
2124         reiserfs_update_inode_transaction(p_s_inode);
2125         if (update_timestamps)
2126                 /* we are doing real truncate: if the system crashes before the last
2127                    transaction of truncating gets committed - on reboot the file
2128                    either appears truncated properly or not truncated at all */
2129                 add_save_link(&th, p_s_inode, 1);
2130         err2 = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);
2131         error =
2132             journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2133         if (error)
2134                 goto out;
2135
2136         /* check reiserfs_do_truncate after ending the transaction */
2137         if (err2) {
2138                 error = err2;
2139                 goto out;
2140         }
2141
2142         if (update_timestamps) {
2143                 error = remove_save_link(p_s_inode, 1 /* truncate */ );
2144                 if (error)
2145                         goto out;
2146         }
2147
2148         if (page) {
2149                 length = offset & (blocksize - 1);
2150                 /* if we are not on a block boundary */
2151                 if (length) {
2152                         char *kaddr;
2153
2154                         length = blocksize - length;
2155                         kaddr = kmap_atomic(page, KM_USER0);
2156                         memset(kaddr + offset, 0, length);
2157                         flush_dcache_page(page);
2158                         kunmap_atomic(kaddr, KM_USER0);
2159                         if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2160                                 mark_buffer_dirty(bh);
2161                         }
2162                 }
2163                 unlock_page(page);
2164                 page_cache_release(page);
2165         }
2166
2167         reiserfs_write_unlock(p_s_inode->i_sb);
2168         return 0;
2169       out:
2170         if (page) {
2171                 unlock_page(page);
2172                 page_cache_release(page);
2173         }
2174         reiserfs_write_unlock(p_s_inode->i_sb);
2175         return error;
2176 }
2177
2178 static int map_block_for_writepage(struct inode *inode,
2179                                    struct buffer_head *bh_result,
2180                                    unsigned long block)
2181 {
2182         struct reiserfs_transaction_handle th;
2183         int fs_gen;
2184         struct item_head tmp_ih;
2185         struct item_head *ih;
2186         struct buffer_head *bh;
2187         __le32 *item;
2188         struct cpu_key key;
2189         INITIALIZE_PATH(path);
2190         int pos_in_item;
2191         int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2192         loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
2193         int retval;
2194         int use_get_block = 0;
2195         int bytes_copied = 0;
2196         int copy_size;
2197         int trans_running = 0;
2198
2199         /* catch places below that try to log something without starting a trans */
2200         th.t_trans_id = 0;
2201
2202         if (!buffer_uptodate(bh_result)) {
2203                 return -EIO;
2204         }
2205
2206         kmap(bh_result->b_page);
2207       start_over:
2208         reiserfs_write_lock(inode->i_sb);
2209         make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
2210
2211       research:
2212         retval = search_for_position_by_key(inode->i_sb, &key, &path);
2213         if (retval != POSITION_FOUND) {
2214                 use_get_block = 1;
2215                 goto out;
2216         }
2217
2218         bh = get_last_bh(&path);
2219         ih = get_ih(&path);
2220         item = get_item(&path);
2221         pos_in_item = path.pos_in_item;
2222
2223         /* we've found an unformatted node */
2224         if (indirect_item_found(retval, ih)) {
2225                 if (bytes_copied > 0) {
2226                         reiserfs_warning(inode->i_sb,
2227                                          "clm-6002: bytes_copied %d",
2228                                          bytes_copied);
2229                 }
2230                 if (!get_block_num(item, pos_in_item)) {
2231                         /* crap, we are writing to a hole */
2232                         use_get_block = 1;
2233                         goto out;
2234                 }
2235                 set_block_dev_mapped(bh_result,
2236                                      get_block_num(item, pos_in_item), inode);
2237         } else if (is_direct_le_ih(ih)) {
2238                 char *p;
2239                 p = page_address(bh_result->b_page);
2240                 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2241                 copy_size = ih_item_len(ih) - pos_in_item;
2242
2243                 fs_gen = get_generation(inode->i_sb);
2244                 copy_item_head(&tmp_ih, ih);
2245
2246                 if (!trans_running) {
2247                         /* vs-3050 is gone, no need to drop the path */
2248                         retval = journal_begin(&th, inode->i_sb, jbegin_count);
2249                         if (retval)
2250                                 goto out;
2251                         reiserfs_update_inode_transaction(inode);
2252                         trans_running = 1;
2253                         if (fs_changed(fs_gen, inode->i_sb)
2254                             && item_moved(&tmp_ih, &path)) {
2255                                 reiserfs_restore_prepared_buffer(inode->i_sb,
2256                                                                  bh);
2257                                 goto research;
2258                         }
2259                 }
2260
2261                 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2262
2263                 if (fs_changed(fs_gen, inode->i_sb)
2264                     && item_moved(&tmp_ih, &path)) {
2265                         reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2266                         goto research;
2267                 }
2268
2269                 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2270                        copy_size);
2271
2272                 journal_mark_dirty(&th, inode->i_sb, bh);
2273                 bytes_copied += copy_size;
2274                 set_block_dev_mapped(bh_result, 0, inode);
2275
2276                 /* are there still bytes left? */
2277                 if (bytes_copied < bh_result->b_size &&
2278                     (byte_offset + bytes_copied) < inode->i_size) {
2279                         set_cpu_key_k_offset(&key,
2280                                              cpu_key_k_offset(&key) +
2281                                              copy_size);
2282                         goto research;
2283                 }
2284         } else {
2285                 reiserfs_warning(inode->i_sb,
2286                                  "clm-6003: bad item inode %lu, device %s",
2287                                  inode->i_ino, reiserfs_bdevname(inode->i_sb));
2288                 retval = -EIO;
2289                 goto out;
2290         }
2291         retval = 0;
2292
2293       out:
2294         pathrelse(&path);
2295         if (trans_running) {
2296                 int err = journal_end(&th, inode->i_sb, jbegin_count);
2297                 if (err)
2298                         retval = err;
2299                 trans_running = 0;
2300         }
2301         reiserfs_write_unlock(inode->i_sb);
2302
2303         /* this is where we fill in holes in the file. */
2304         if (use_get_block) {
2305                 retval = reiserfs_get_block(inode, block, bh_result,
2306                                             GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
2307                                             | GET_BLOCK_NO_DANGLE);
2308                 if (!retval) {
2309                         if (!buffer_mapped(bh_result)
2310                             || bh_result->b_blocknr == 0) {
2311                                 /* get_block failed to find a mapped unformatted node. */
2312                                 use_get_block = 0;
2313                                 goto start_over;
2314                         }
2315                 }
2316         }
2317         kunmap(bh_result->b_page);
2318
2319         if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2320                 /* we've copied data from the page into the direct item, so the
2321                  * buffer in the page is now clean, mark it to reflect that.
2322                  */
2323                 lock_buffer(bh_result);
2324                 clear_buffer_dirty(bh_result);
2325                 unlock_buffer(bh_result);
2326         }
2327         return retval;
2328 }
2329
2330 /*
2331  * mason@suse.com: updated in 2.5.54 to follow the same general io
2332  * start/recovery path as __block_write_full_page, along with special
2333  * code to handle reiserfs tails.
2334  */
2335 static int reiserfs_write_full_page(struct page *page,
2336                                     struct writeback_control *wbc)
2337 {
2338         struct inode *inode = page->mapping->host;
2339         unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2340         int error = 0;
2341         unsigned long block;
2342         sector_t last_block;
2343         struct buffer_head *head, *bh;
2344         int partial = 0;
2345         int nr = 0;
2346         int checked = PageChecked(page);
2347         struct reiserfs_transaction_handle th;
2348         struct super_block *s = inode->i_sb;
2349         int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2350         th.t_trans_id = 0;
2351
2352         /* no logging allowed when nonblocking or from PF_MEMALLOC */
2353         if (checked && (current->flags & PF_MEMALLOC)) {
2354                 redirty_page_for_writepage(wbc, page);
2355                 unlock_page(page);
2356                 return 0;
2357         }
2358
2359         /* The page dirty bit is cleared before writepage is called, which
2360          * means we have to tell create_empty_buffers to make dirty buffers
2361          * The page really should be up to date at this point, so tossing
2362          * in the BH_Uptodate is just a sanity check.
2363          */
2364         if (!page_has_buffers(page)) {
2365                 create_empty_buffers(page, s->s_blocksize,
2366                                      (1 << BH_Dirty) | (1 << BH_Uptodate));
2367         }
2368         head = page_buffers(page);
2369
2370         /* last page in the file, zero out any contents past the
2371          ** last byte in the file
2372          */
2373         if (page->index >= end_index) {
2374                 char *kaddr;
2375                 unsigned last_offset;
2376
2377                 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2378                 /* no file contents in this page */
2379                 if (page->index >= end_index + 1 || !last_offset) {
2380                         unlock_page(page);
2381                         return 0;
2382                 }
2383                 kaddr = kmap_atomic(page, KM_USER0);
2384                 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);
2385                 flush_dcache_page(page);
2386                 kunmap_atomic(kaddr, KM_USER0);
2387         }
2388         bh = head;
2389         block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2390         last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
2391         /* first map all the buffers, logging any direct items we find */
2392         do {
2393                 if (block > last_block) {
2394                         /*
2395                          * This can happen when the block size is less than
2396                          * the page size.  The corresponding bytes in the page
2397                          * were zero filled above
2398                          */
2399                         clear_buffer_dirty(bh);
2400                         set_buffer_uptodate(bh);
2401                 } else if ((checked || buffer_dirty(bh)) &&
2402                            (!buffer_mapped(bh) || (buffer_mapped(bh)
2403                                                        && bh->b_blocknr ==
2404                                                        0))) {
2405                         /* not mapped yet, or it points to a direct item, search
2406                          * the btree for the mapping info, and log any direct
2407                          * items found
2408                          */
2409                         if ((error = map_block_for_writepage(inode, bh, block))) {
2410                                 goto fail;
2411                         }
2412                 }
2413                 bh = bh->b_this_page;
2414                 block++;
2415         } while (bh != head);
2416
2417         /*
2418          * we start the transaction after map_block_for_writepage,
2419          * because it can create holes in the file (an unbounded operation).
2420          * starting it here, we can make a reliable estimate for how many
2421          * blocks we're going to log
2422          */
2423         if (checked) {
2424                 ClearPageChecked(page);
2425                 reiserfs_write_lock(s);
2426                 error = journal_begin(&th, s, bh_per_page + 1);
2427                 if (error) {
2428                         reiserfs_write_unlock(s);
2429                         goto fail;
2430                 }
2431                 reiserfs_update_inode_transaction(inode);
2432         }
2433         /* now go through and lock any dirty buffers on the page */
2434         do {
2435                 get_bh(bh);
2436                 if (!buffer_mapped(bh))
2437                         continue;
2438                 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2439                         continue;
2440
2441                 if (checked) {
2442                         reiserfs_prepare_for_journal(s, bh, 1);
2443                         journal_mark_dirty(&th, s, bh);
2444                         continue;
2445                 }
2446                 /* from this point on, we know the buffer is mapped to a
2447                  * real block and not a direct item
2448                  */
2449                 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
2450                         lock_buffer(bh);
2451                 } else {
2452                         if (test_set_buffer_locked(bh)) {
2453                                 redirty_page_for_writepage(wbc, page);
2454                                 continue;
2455                         }
2456                 }
2457                 if (test_clear_buffer_dirty(bh)) {
2458                         mark_buffer_async_write(bh);
2459                 } else {
2460                         unlock_buffer(bh);
2461                 }
2462         } while ((bh = bh->b_this_page) != head);
2463
2464         if (checked) {
2465                 error = journal_end(&th, s, bh_per_page + 1);
2466                 reiserfs_write_unlock(s);
2467                 if (error)
2468                         goto fail;
2469         }
2470         BUG_ON(PageWriteback(page));
2471         set_page_writeback(page);
2472         unlock_page(page);
2473
2474         /*
2475          * since any buffer might be the only dirty buffer on the page,
2476          * the first submit_bh can bring the page out of writeback.
2477          * be careful with the buffers.
2478          */
2479         do {
2480                 struct buffer_head *next = bh->b_this_page;
2481                 if (buffer_async_write(bh)) {
2482                         submit_bh(WRITE, bh);
2483                         nr++;
2484                 }
2485                 put_bh(bh);
2486                 bh = next;
2487         } while (bh != head);
2488
2489         error = 0;
2490       done:
2491         if (nr == 0) {
2492                 /*
2493                  * if this page only had a direct item, it is very possible for
2494                  * no io to be required without there being an error.  Or,
2495                  * someone else could have locked them and sent them down the
2496                  * pipe without locking the page
2497                  */
2498                 bh = head;
2499                 do {
2500                         if (!buffer_uptodate(bh)) {
2501                                 partial = 1;
2502                                 break;
2503                         }
2504                         bh = bh->b_this_page;
2505                 } while (bh != head);
2506                 if (!partial)
2507                         SetPageUptodate(page);
2508                 end_page_writeback(page);
2509         }
2510         return error;
2511
2512       fail:
2513         /* catches various errors, we need to make sure any valid dirty blocks
2514          * get to the media.  The page is currently locked and not marked for
2515          * writeback
2516          */
2517         ClearPageUptodate(page);
2518         bh = head;
2519         do {
2520                 get_bh(bh);
2521                 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2522                         lock_buffer(bh);
2523                         mark_buffer_async_write(bh);
2524                 } else {
2525                         /*
2526                          * clear any dirty bits that might have come from getting
2527                          * attached to a dirty page
2528                          */
2529                         clear_buffer_dirty(bh);
2530                 }
2531                 bh = bh->b_this_page;
2532         } while (bh != head);
2533         SetPageError(page);
2534         BUG_ON(PageWriteback(page));
2535         set_page_writeback(page);
2536         unlock_page(page);
2537         do {
2538                 struct buffer_head *next = bh->b_this_page;
2539                 if (buffer_async_write(bh)) {
2540                         clear_buffer_dirty(bh);
2541                         submit_bh(WRITE, bh);
2542                         nr++;
2543                 }
2544                 put_bh(bh);
2545                 bh = next;
2546         } while (bh != head);
2547         goto done;
2548 }
2549
2550 static int reiserfs_readpage(struct file *f, struct page *page)
2551 {
2552         return block_read_full_page(page, reiserfs_get_block);
2553 }
2554
2555 static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
2556 {
2557         struct inode *inode = page->mapping->host;
2558         reiserfs_wait_on_write_block(inode->i_sb);
2559         return reiserfs_write_full_page(page, wbc);
2560 }
2561
2562 static int reiserfs_prepare_write(struct file *f, struct page *page,
2563                                   unsigned from, unsigned to)
2564 {
2565         struct inode *inode = page->mapping->host;
2566         int ret;
2567         int old_ref = 0;
2568
2569         reiserfs_wait_on_write_block(inode->i_sb);
2570         fix_tail_page_for_writing(page);
2571         if (reiserfs_transaction_running(inode->i_sb)) {
2572                 struct reiserfs_transaction_handle *th;
2573                 th = (struct reiserfs_transaction_handle *)current->
2574                     journal_info;
2575                 BUG_ON(!th->t_refcount);
2576                 BUG_ON(!th->t_trans_id);
2577                 old_ref = th->t_refcount;
2578                 th->t_refcount++;
2579         }
2580
2581         ret = block_prepare_write(page, from, to, reiserfs_get_block);
2582         if (ret && reiserfs_transaction_running(inode->i_sb)) {
2583                 struct reiserfs_transaction_handle *th = current->journal_info;
2584                 /* this gets a little ugly.  If reiserfs_get_block returned an
2585                  * error and left a transacstion running, we've got to close it,
2586                  * and we've got to free handle if it was a persistent transaction.
2587                  *
2588                  * But, if we had nested into an existing transaction, we need
2589                  * to just drop the ref count on the handle.
2590                  *
2591                  * If old_ref == 0, the transaction is from reiserfs_get_block,
2592                  * and it was a persistent trans.  Otherwise, it was nested above.
2593                  */
2594                 if (th->t_refcount > old_ref) {
2595                         if (old_ref)
2596                                 th->t_refcount--;
2597                         else {
2598                                 int err;
2599                                 reiserfs_write_lock(inode->i_sb);
2600                                 err = reiserfs_end_persistent_transaction(th);
2601                                 reiserfs_write_unlock(inode->i_sb);
2602                                 if (err)
2603                                         ret = err;
2604                         }
2605                 }
2606         }
2607         return ret;
2608
2609 }
2610
2611 static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2612 {
2613         return generic_block_bmap(as, block, reiserfs_bmap);
2614 }
2615
2616 static int reiserfs_commit_write(struct file *f, struct page *page,
2617                                  unsigned from, unsigned to)
2618 {
2619         struct inode *inode = page->mapping->host;
2620         loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2621         int ret = 0;
2622         int update_sd = 0;
2623         struct reiserfs_transaction_handle *th = NULL;
2624
2625         reiserfs_wait_on_write_block(inode->i_sb);
2626         if (reiserfs_transaction_running(inode->i_sb)) {
2627                 th = current->journal_info;
2628         }
2629         reiserfs_commit_page(inode, page, from, to);
2630
2631         /* generic_commit_write does this for us, but does not update the
2632          ** transaction tracking stuff when the size changes.  So, we have
2633          ** to do the i_size updates here.
2634          */
2635         if (pos > inode->i_size) {
2636                 struct reiserfs_transaction_handle myth;
2637                 reiserfs_write_lock(inode->i_sb);
2638                 /* If the file have grown beyond the border where it
2639                    can have a tail, unmark it as needing a tail
2640                    packing */
2641                 if ((have_large_tails(inode->i_sb)
2642                      && inode->i_size > i_block_size(inode) * 4)
2643                     || (have_small_tails(inode->i_sb)
2644                         && inode->i_size > i_block_size(inode)))
2645                         REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2646
2647                 ret = journal_begin(&myth, inode->i_sb, 1);
2648                 if (ret) {
2649                         reiserfs_write_unlock(inode->i_sb);
2650                         goto journal_error;
2651                 }
2652                 reiserfs_update_inode_transaction(inode);
2653                 inode->i_size = pos;
2654                 /*
2655                  * this will just nest into our transaction.  It's important
2656                  * to use mark_inode_dirty so the inode gets pushed around on the
2657                  * dirty lists, and so that O_SYNC works as expected
2658                  */
2659                 mark_inode_dirty(inode);
2660                 reiserfs_update_sd(&myth, inode);
2661                 update_sd = 1;
2662                 ret = journal_end(&myth, inode->i_sb, 1);
2663                 reiserfs_write_unlock(inode->i_sb);
2664                 if (ret)
2665                         goto journal_error;
2666         }
2667         if (th) {
2668                 reiserfs_write_lock(inode->i_sb);
2669                 if (!update_sd)
2670                         mark_inode_dirty(inode);
2671                 ret = reiserfs_end_persistent_transaction(th);
2672                 reiserfs_write_unlock(inode->i_sb);
2673                 if (ret)
2674                         goto out;
2675         }
2676
2677       out:
2678         return ret;
2679
2680       journal_error:
2681         if (th) {
2682                 reiserfs_write_lock(inode->i_sb);
2683                 if (!update_sd)
2684                         reiserfs_update_sd(th, inode);
2685                 ret = reiserfs_end_persistent_transaction(th);
2686                 reiserfs_write_unlock(inode->i_sb);
2687         }
2688
2689         return ret;
2690 }
2691
2692 void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2693 {
2694         if (reiserfs_attrs(inode->i_sb)) {
2695                 if (sd_attrs & REISERFS_SYNC_FL)
2696                         inode->i_flags |= S_SYNC;
2697                 else
2698                         inode->i_flags &= ~S_SYNC;
2699                 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2700                         inode->i_flags |= S_IMMUTABLE;
2701                 else
2702                         inode->i_flags &= ~S_IMMUTABLE;
2703                 if (sd_attrs & REISERFS_APPEND_FL)
2704                         inode->i_flags |= S_APPEND;
2705                 else
2706                         inode->i_flags &= ~S_APPEND;
2707                 if (sd_attrs & REISERFS_NOATIME_FL)
2708                         inode->i_flags |= S_NOATIME;
2709                 else
2710                         inode->i_flags &= ~S_NOATIME;
2711                 if (sd_attrs & REISERFS_NOTAIL_FL)
2712                         REISERFS_I(inode)->i_flags |= i_nopack_mask;
2713                 else
2714                         REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2715         }
2716 }
2717
2718 void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
2719 {
2720         if (reiserfs_attrs(inode->i_sb)) {
2721                 if (inode->i_flags & S_IMMUTABLE)
2722                         *sd_attrs |= REISERFS_IMMUTABLE_FL;
2723                 else
2724                         *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
2725                 if (inode->i_flags & S_SYNC)
2726                         *sd_attrs |= REISERFS_SYNC_FL;
2727                 else
2728                         *sd_attrs &= ~REISERFS_SYNC_FL;
2729                 if (inode->i_flags & S_NOATIME)
2730                         *sd_attrs |= REISERFS_NOATIME_FL;
2731                 else
2732                         *sd_attrs &= ~REISERFS_NOATIME_FL;
2733                 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
2734                         *sd_attrs |= REISERFS_NOTAIL_FL;
2735                 else
2736                         *sd_attrs &= ~REISERFS_NOTAIL_FL;
2737         }
2738 }
2739
2740 /* decide if this buffer needs to stay around for data logging or ordered
2741 ** write purposes
2742 */
2743 static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2744 {
2745         int ret = 1;
2746         struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2747
2748         lock_buffer(bh);
2749         spin_lock(&j->j_dirty_buffers_lock);
2750         if (!buffer_mapped(bh)) {
2751                 goto free_jh;
2752         }
2753         /* the page is locked, and the only places that log a data buffer
2754          * also lock the page.
2755          */
2756         if (reiserfs_file_data_log(inode)) {
2757                 /*
2758                  * very conservative, leave the buffer pinned if
2759                  * anyone might need it.
2760                  */
2761                 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2762                         ret = 0;
2763                 }
2764         } else  if (buffer_dirty(bh)) {
2765                 struct reiserfs_journal_list *jl;
2766                 struct reiserfs_jh *jh = bh->b_private;
2767
2768                 /* why is this safe?
2769                  * reiserfs_setattr updates i_size in the on disk
2770                  * stat data before allowing vmtruncate to be called.
2771                  *
2772                  * If buffer was put onto the ordered list for this
2773                  * transaction, we know for sure either this transaction
2774                  * or an older one already has updated i_size on disk,
2775                  * and this ordered data won't be referenced in the file
2776                  * if we crash.
2777                  *
2778                  * if the buffer was put onto the ordered list for an older
2779                  * transaction, we need to leave it around
2780                  */
2781                 if (jh && (jl = jh->jl)
2782                     && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2783                         ret = 0;
2784         }
2785       free_jh:
2786         if (ret && bh->b_private) {
2787                 reiserfs_free_jh(bh);
2788         }
2789         spin_unlock(&j->j_dirty_buffers_lock);
2790         unlock_buffer(bh);
2791         return ret;
2792 }
2793
2794 /* clm -- taken from fs/buffer.c:block_invalidate_page */
2795 static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
2796 {
2797         struct buffer_head *head, *bh, *next;
2798         struct inode *inode = page->mapping->host;
2799         unsigned int curr_off = 0;
2800         int ret = 1;
2801
2802         BUG_ON(!PageLocked(page));
2803
2804         if (offset == 0)
2805                 ClearPageChecked(page);
2806
2807         if (!page_has_buffers(page))
2808                 goto out;
2809
2810         head = page_buffers(page);
2811         bh = head;
2812         do {
2813                 unsigned int next_off = curr_off + bh->b_size;
2814                 next = bh->b_this_page;
2815
2816                 /*
2817                  * is this block fully invalidated?
2818                  */
2819                 if (offset <= curr_off) {
2820                         if (invalidatepage_can_drop(inode, bh))
2821                                 reiserfs_unmap_buffer(bh);
2822                         else
2823                                 ret = 0;
2824                 }
2825                 curr_off = next_off;
2826                 bh = next;
2827         } while (bh != head);
2828
2829         /*
2830          * We release buffers only if the entire page is being invalidated.
2831          * The get_block cached value has been unconditionally invalidated,
2832          * so real IO is not possible anymore.
2833          */
2834         if (!offset && ret) {
2835                 ret = try_to_release_page(page, 0);
2836                 /* maybe should BUG_ON(!ret); - neilb */
2837         }
2838       out:
2839         return;
2840 }
2841
2842 static int reiserfs_set_page_dirty(struct page *page)
2843 {
2844         struct inode *inode = page->mapping->host;
2845         if (reiserfs_file_data_log(inode)) {
2846                 SetPageChecked(page);
2847                 return __set_page_dirty_nobuffers(page);
2848         }
2849         return __set_page_dirty_buffers(page);
2850 }
2851
2852 /*
2853  * Returns 1 if the page's buffers were dropped.  The page is locked.
2854  *
2855  * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads
2856  * in the buffers at page_buffers(page).
2857  *
2858  * even in -o notail mode, we can't be sure an old mount without -o notail
2859  * didn't create files with tails.
2860  */
2861 static int reiserfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
2862 {
2863         struct inode *inode = page->mapping->host;
2864         struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2865         struct buffer_head *head;
2866         struct buffer_head *bh;
2867         int ret = 1;
2868
2869         WARN_ON(PageChecked(page));
2870         spin_lock(&j->j_dirty_buffers_lock);
2871         head = page_buffers(page);
2872         bh = head;
2873         do {
2874                 if (bh->b_private) {
2875                         if (!buffer_dirty(bh) && !buffer_locked(bh)) {
2876                                 reiserfs_free_jh(bh);
2877                         } else {
2878                                 ret = 0;
2879                                 break;
2880                         }
2881                 }
2882                 bh = bh->b_this_page;
2883         } while (bh != head);
2884         if (ret)
2885                 ret = try_to_free_buffers(page);
2886         spin_unlock(&j->j_dirty_buffers_lock);
2887         return ret;
2888 }
2889
2890 /* We thank Mingming Cao for helping us understand in great detail what
2891    to do in this section of the code. */
2892 static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
2893                                   const struct iovec *iov, loff_t offset,
2894                                   unsigned long nr_segs)
2895 {
2896         struct file *file = iocb->ki_filp;
2897         struct inode *inode = file->f_mapping->host;
2898
2899         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2900                                   offset, nr_segs,
2901                                   reiserfs_get_blocks_direct_io, NULL);
2902 }
2903
2904 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
2905 {
2906         struct inode *inode = dentry->d_inode;
2907         int error;
2908         unsigned int ia_valid = attr->ia_valid;
2909         reiserfs_write_lock(inode->i_sb);
2910         if (attr->ia_valid & ATTR_SIZE) {
2911                 /* version 2 items will be caught by the s_maxbytes check
2912                  ** done for us in vmtruncate
2913                  */
2914                 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
2915                     attr->ia_size > MAX_NON_LFS) {
2916                         error = -EFBIG;
2917                         goto out;
2918                 }
2919                 /* fill in hole pointers in the expanding truncate case. */
2920                 if (attr->ia_size > inode->i_size) {
2921                         error = generic_cont_expand(inode, attr->ia_size);
2922                         if (REISERFS_I(inode)->i_prealloc_count > 0) {
2923                                 int err;
2924                                 struct reiserfs_transaction_handle th;
2925                                 /* we're changing at most 2 bitmaps, inode + super */
2926                                 err = journal_begin(&th, inode->i_sb, 4);
2927                                 if (!err) {
2928                                         reiserfs_discard_prealloc(&th, inode);
2929                                         err = journal_end(&th, inode->i_sb, 4);
2930                                 }
2931                                 if (err)
2932                                         error = err;
2933                         }
2934                         if (error)
2935                                 goto out;
2936                         /*
2937                          * file size is changed, ctime and mtime are
2938                          * to be updated
2939                          */
2940                         attr->ia_valid |= (ATTR_MTIME | ATTR_CTIME);
2941                 }
2942         }
2943
2944         if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||
2945              ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&
2946             (get_inode_sd_version(inode) == STAT_DATA_V1)) {
2947                 /* stat data of format v3.5 has 16 bit uid and gid */
2948                 error = -EINVAL;
2949                 goto out;
2950         }
2951
2952         error = inode_change_ok(inode, attr);
2953         if (!error) {
2954                 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2955                     (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2956                         error = reiserfs_chown_xattrs(inode, attr);
2957
2958                         if (!error) {
2959                                 struct reiserfs_transaction_handle th;
2960                                 int jbegin_count =
2961                                     2 *
2962                                     (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
2963                                      REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
2964                                     2;
2965
2966                                 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2967                                 error =
2968                                     journal_begin(&th, inode->i_sb,
2969                                                   jbegin_count);
2970                                 if (error)
2971                                         goto out;
2972                                 error =
2973                                     DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2974                                 if (error) {
2975                                         journal_end(&th, inode->i_sb,
2976                                                     jbegin_count);
2977                                         goto out;
2978                                 }
2979                                 /* Update corresponding info in inode so that everything is in
2980                                  * one transaction */
2981                                 if (attr->ia_valid & ATTR_UID)
2982                                         inode->i_uid = attr->ia_uid;
2983                                 if (attr->ia_valid & ATTR_GID)
2984                                         inode->i_gid = attr->ia_gid;
2985                                 mark_inode_dirty(inode);
2986                                 error =
2987                                     journal_end(&th, inode->i_sb, jbegin_count);
2988                         }
2989                 }
2990                 if (!error)
2991                         error = inode_setattr(inode, attr);
2992         }
2993
2994         if (!error && reiserfs_posixacl(inode->i_sb)) {
2995                 if (attr->ia_valid & ATTR_MODE)
2996                         error = reiserfs_acl_chmod(inode);
2997         }
2998
2999       out:
3000         reiserfs_write_unlock(inode->i_sb);
3001         return error;
3002 }
3003
3004 const struct address_space_operations reiserfs_address_space_operations = {
3005         .writepage = reiserfs_writepage,
3006         .readpage = reiserfs_readpage,
3007         .readpages = reiserfs_readpages,
3008         .releasepage = reiserfs_releasepage,
3009         .invalidatepage = reiserfs_invalidatepage,
3010         .sync_page = block_sync_page,
3011         .prepare_write = reiserfs_prepare_write,
3012         .commit_write = reiserfs_commit_write,
3013         .bmap = reiserfs_aop_bmap,
3014         .direct_IO = reiserfs_direct_IO,
3015         .set_page_dirty = reiserfs_set_page_dirty,
3016 };