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

   1 /*
   2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  */
   4
   5 #include <linux/time.h>
   6 #include <linux/fs.h>
   7 #include <linux/reiserfs_fs.h>
   8 #include <linux/reiserfs_acl.h>
   9 #include <linux/reiserfs_xattr.h>
  10 #include <linux/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 = kzalloc(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                                 }
 938                         }
 939                         if (blocks_needed <= max_to_insert) {
 940                                 /* we are going to add target block to the file. Use allocated
 941                                    block for that */
 942                                 un[blocks_needed - 1] =
 943                                     cpu_to_le32(allocated_block_nr);
 944                                 set_block_dev_mapped(bh_result,
 945                                                      allocated_block_nr, inode);
 946                                 set_buffer_new(bh_result);
 947                                 done = 1;
 948                         } else {
 949                                 /* paste hole to the indirect item */
 950                                 /* If kmalloc failed, max_to_insert becomes zero and it means we
 951                                    only have space for one block */
 952                                 blocks_needed =
 953                                     max_to_insert ? max_to_insert : 1;
 954                         }
 955                         retval =
 956                             reiserfs_paste_into_item(th, &path, &tmp_key, inode,
 957                                                      (char *)un,
 958                                                      UNFM_P_SIZE *
 959                                                      blocks_needed);
 960
 961                         if (blocks_needed != 1)
 962                                 kfree(un);
 963
 964                         if (retval) {
 965                                 reiserfs_free_block(th, inode,
 966                                                     allocated_block_nr, 1);
 967                                 goto failure;
 968                         }
 969                         if (!done) {
 970                                 /* We need to mark new file size in case this function will be
 971                                    interrupted/aborted later on. And we may do this only for
 972                                    holes. */
 973                                 inode->i_size +=
 974                                     inode->i_sb->s_blocksize * blocks_needed;
 975                         }
 976                 }
 977
 978                 if (done == 1)
 979                         break;
 980
 981                 /* this loop could log more blocks than we had originally asked
 982                  ** for.  So, we have to allow the transaction to end if it is
 983                  ** too big or too full.  Update the inode so things are
 984                  ** consistent if we crash before the function returns
 985                  **
 986                  ** release the path so that anybody waiting on the path before
 987                  ** ending their transaction will be able to continue.
 988                  */
 989                 if (journal_transaction_should_end(th, th->t_blocks_allocated)) {
 990                         retval = restart_transaction(th, inode, &path);
 991                         if (retval)
 992                                 goto failure;
 993                 }
 994                 /* inserting indirect pointers for a hole can take a
 995                  ** long time.  reschedule if needed
 996                  */
 997                 cond_resched();
 998
 999                 retval = search_for_position_by_key(inode->i_sb, &key, &path);
1000                 if (retval == IO_ERROR) {
1001                         retval = -EIO;
1002                         goto failure;
1003                 }
1004                 if (retval == POSITION_FOUND) {
1005                         reiserfs_warning(inode->i_sb,
1006                                          "vs-825: reiserfs_get_block: "
1007                                          "%K should not be found", &key);
1008                         retval = -EEXIST;
1009                         if (allocated_block_nr)
1010                                 reiserfs_free_block(th, inode,
1011                                                     allocated_block_nr, 1);
1012                         pathrelse(&path);
1013                         goto failure;
1014                 }
1015                 bh = get_last_bh(&path);
1016                 ih = get_ih(&path);
1017                 item = get_item(&path);
1018                 pos_in_item = path.pos_in_item;
1019         } while (1);
1020
1021         retval = 0;
1022
1023       failure:
1024         if (th && (!dangle || (retval && !th->t_trans_id))) {
1025                 int err;
1026                 if (th->t_trans_id)
1027                         reiserfs_update_sd(th, inode);
1028                 err = reiserfs_end_persistent_transaction(th);
1029                 if (err)
1030                         retval = err;
1031         }
1032
1033         reiserfs_write_unlock(inode->i_sb);
1034         reiserfs_check_path(&path);
1035         return retval;
1036 }
1037
1038 static int
1039 reiserfs_readpages(struct file *file, struct address_space *mapping,
1040                    struct list_head *pages, unsigned nr_pages)
1041 {
1042         return mpage_readpages(mapping, pages, nr_pages, reiserfs_get_block);
1043 }
1044
1045 /* Compute real number of used bytes by file
1046  * Following three functions can go away when we'll have enough space in stat item
1047  */
1048 static int real_space_diff(struct inode *inode, int sd_size)
1049 {
1050         int bytes;
1051         loff_t blocksize = inode->i_sb->s_blocksize;
1052
1053         if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))
1054                 return sd_size;
1055
1056         /* End of file is also in full block with indirect reference, so round
1057          ** up to the next block.
1058          **
1059          ** there is just no way to know if the tail is actually packed
1060          ** on the file, so we have to assume it isn't.  When we pack the
1061          ** tail, we add 4 bytes to pretend there really is an unformatted
1062          ** node pointer
1063          */
1064         bytes =
1065             ((inode->i_size +
1066               (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +
1067             sd_size;
1068         return bytes;
1069 }
1070
1071 static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,
1072                                         int sd_size)
1073 {
1074         if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1075                 return inode->i_size +
1076                     (loff_t) (real_space_diff(inode, sd_size));
1077         }
1078         return ((loff_t) real_space_diff(inode, sd_size)) +
1079             (((loff_t) blocks) << 9);
1080 }
1081
1082 /* Compute number of blocks used by file in ReiserFS counting */
1083 static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)
1084 {
1085         loff_t bytes = inode_get_bytes(inode);
1086         loff_t real_space = real_space_diff(inode, sd_size);
1087
1088         /* keeps fsck and non-quota versions of reiserfs happy */
1089         if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {
1090                 bytes += (loff_t) 511;
1091         }
1092
1093         /* files from before the quota patch might i_blocks such that
1094          ** bytes < real_space.  Deal with that here to prevent it from
1095          ** going negative.
1096          */
1097         if (bytes < real_space)
1098                 return 0;
1099         return (bytes - real_space) >> 9;
1100 }
1101
1102 //
1103 // BAD: new directories have stat data of new type and all other items
1104 // of old type. Version stored in the inode says about body items, so
1105 // in update_stat_data we can not rely on inode, but have to check
1106 // item version directly
1107 //
1108
1109 // called by read_locked_inode
1110 static void init_inode(struct inode *inode, struct path *path)
1111 {
1112         struct buffer_head *bh;
1113         struct item_head *ih;
1114         __u32 rdev;
1115         //int version = ITEM_VERSION_1;
1116
1117         bh = PATH_PLAST_BUFFER(path);
1118         ih = PATH_PITEM_HEAD(path);
1119
1120         copy_key(INODE_PKEY(inode), &(ih->ih_key));
1121
1122         INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1123         REISERFS_I(inode)->i_flags = 0;
1124         REISERFS_I(inode)->i_prealloc_block = 0;
1125         REISERFS_I(inode)->i_prealloc_count = 0;
1126         REISERFS_I(inode)->i_trans_id = 0;
1127         REISERFS_I(inode)->i_jl = NULL;
1128         reiserfs_init_acl_access(inode);
1129         reiserfs_init_acl_default(inode);
1130         reiserfs_init_xattr_rwsem(inode);
1131
1132         if (stat_data_v1(ih)) {
1133                 struct stat_data_v1 *sd =
1134                     (struct stat_data_v1 *)B_I_PITEM(bh, ih);
1135                 unsigned long blocks;
1136
1137                 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1138                 set_inode_sd_version(inode, STAT_DATA_V1);
1139                 inode->i_mode = sd_v1_mode(sd);
1140                 inode->i_nlink = sd_v1_nlink(sd);
1141                 inode->i_uid = sd_v1_uid(sd);
1142                 inode->i_gid = sd_v1_gid(sd);
1143                 inode->i_size = sd_v1_size(sd);
1144                 inode->i_atime.tv_sec = sd_v1_atime(sd);
1145                 inode->i_mtime.tv_sec = sd_v1_mtime(sd);
1146                 inode->i_ctime.tv_sec = sd_v1_ctime(sd);
1147                 inode->i_atime.tv_nsec = 0;
1148                 inode->i_ctime.tv_nsec = 0;
1149                 inode->i_mtime.tv_nsec = 0;
1150
1151                 inode->i_blocks = sd_v1_blocks(sd);
1152                 inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1153                 blocks = (inode->i_size + 511) >> 9;
1154                 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);
1155                 if (inode->i_blocks > blocks) {
1156                         // there was a bug in <=3.5.23 when i_blocks could take negative
1157                         // values. Starting from 3.5.17 this value could even be stored in
1158                         // stat data. For such files we set i_blocks based on file
1159                         // size. Just 2 notes: this can be wrong for sparce files. On-disk value will be
1160                         // only updated if file's inode will ever change
1161                         inode->i_blocks = blocks;
1162                 }
1163
1164                 rdev = sd_v1_rdev(sd);
1165                 REISERFS_I(inode)->i_first_direct_byte =
1166                     sd_v1_first_direct_byte(sd);
1167                 /* an early bug in the quota code can give us an odd number for the
1168                  ** block count.  This is incorrect, fix it here.
1169                  */
1170                 if (inode->i_blocks & 1) {
1171                         inode->i_blocks++;
1172                 }
1173                 inode_set_bytes(inode,
1174                                 to_real_used_space(inode, inode->i_blocks,
1175                                                    SD_V1_SIZE));
1176                 /* nopack is initially zero for v1 objects. For v2 objects,
1177                    nopack is initialised from sd_attrs */
1178                 REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
1179         } else {
1180                 // new stat data found, but object may have old items
1181                 // (directories and symlinks)
1182                 struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
1183
1184                 inode->i_mode = sd_v2_mode(sd);
1185                 inode->i_nlink = sd_v2_nlink(sd);
1186                 inode->i_uid = sd_v2_uid(sd);
1187                 inode->i_size = sd_v2_size(sd);
1188                 inode->i_gid = sd_v2_gid(sd);
1189                 inode->i_mtime.tv_sec = sd_v2_mtime(sd);
1190                 inode->i_atime.tv_sec = sd_v2_atime(sd);
1191                 inode->i_ctime.tv_sec = sd_v2_ctime(sd);
1192                 inode->i_ctime.tv_nsec = 0;
1193                 inode->i_mtime.tv_nsec = 0;
1194                 inode->i_atime.tv_nsec = 0;
1195                 inode->i_blocks = sd_v2_blocks(sd);
1196                 rdev = sd_v2_rdev(sd);
1197                 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1198                         inode->i_generation =
1199                             le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1200                 else
1201                         inode->i_generation = sd_v2_generation(sd);
1202
1203                 if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
1204                         set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1205                 else
1206                         set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1207                 REISERFS_I(inode)->i_first_direct_byte = 0;
1208                 set_inode_sd_version(inode, STAT_DATA_V2);
1209                 inode_set_bytes(inode,
1210                                 to_real_used_space(inode, inode->i_blocks,
1211                                                    SD_V2_SIZE));
1212                 /* read persistent inode attributes from sd and initalise
1213                    generic inode flags from them */
1214                 REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);
1215                 sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);
1216         }
1217
1218         pathrelse(path);
1219         if (S_ISREG(inode->i_mode)) {
1220                 inode->i_op = &reiserfs_file_inode_operations;
1221                 inode->i_fop = &reiserfs_file_operations;
1222                 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1223         } else if (S_ISDIR(inode->i_mode)) {
1224                 inode->i_op = &reiserfs_dir_inode_operations;
1225                 inode->i_fop = &reiserfs_dir_operations;
1226         } else if (S_ISLNK(inode->i_mode)) {
1227                 inode->i_op = &reiserfs_symlink_inode_operations;
1228                 inode->i_mapping->a_ops = &reiserfs_address_space_operations;
1229         } else {
1230                 inode->i_blocks = 0;
1231                 inode->i_op = &reiserfs_special_inode_operations;
1232                 init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));
1233         }
1234 }
1235
1236 // update new stat data with inode fields
1237 static void inode2sd(void *sd, struct inode *inode, loff_t size)
1238 {
1239         struct stat_data *sd_v2 = (struct stat_data *)sd;
1240         __u16 flags;
1241
1242         set_sd_v2_mode(sd_v2, inode->i_mode);
1243         set_sd_v2_nlink(sd_v2, inode->i_nlink);
1244         set_sd_v2_uid(sd_v2, inode->i_uid);
1245         set_sd_v2_size(sd_v2, size);
1246         set_sd_v2_gid(sd_v2, inode->i_gid);
1247         set_sd_v2_mtime(sd_v2, inode->i_mtime.tv_sec);
1248         set_sd_v2_atime(sd_v2, inode->i_atime.tv_sec);
1249         set_sd_v2_ctime(sd_v2, inode->i_ctime.tv_sec);
1250         set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));
1251         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1252                 set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));
1253         else
1254                 set_sd_v2_generation(sd_v2, inode->i_generation);
1255         flags = REISERFS_I(inode)->i_attrs;
1256         i_attrs_to_sd_attrs(inode, &flags);
1257         set_sd_v2_attrs(sd_v2, flags);
1258 }
1259
1260 // used to copy inode's fields to old stat data
1261 static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)
1262 {
1263         struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
1264
1265         set_sd_v1_mode(sd_v1, inode->i_mode);
1266         set_sd_v1_uid(sd_v1, inode->i_uid);
1267         set_sd_v1_gid(sd_v1, inode->i_gid);
1268         set_sd_v1_nlink(sd_v1, inode->i_nlink);
1269         set_sd_v1_size(sd_v1, size);
1270         set_sd_v1_atime(sd_v1, inode->i_atime.tv_sec);
1271         set_sd_v1_ctime(sd_v1, inode->i_ctime.tv_sec);
1272         set_sd_v1_mtime(sd_v1, inode->i_mtime.tv_sec);
1273
1274         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1275                 set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));
1276         else
1277                 set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));
1278
1279         // Sigh. i_first_direct_byte is back
1280         set_sd_v1_first_direct_byte(sd_v1,
1281                                     REISERFS_I(inode)->i_first_direct_byte);
1282 }
1283
1284 /* NOTE, you must prepare the buffer head before sending it here,
1285 ** and then log it after the call
1286 */
1287 static void update_stat_data(struct path *path, struct inode *inode,
1288                              loff_t size)
1289 {
1290         struct buffer_head *bh;
1291         struct item_head *ih;
1292
1293         bh = PATH_PLAST_BUFFER(path);
1294         ih = PATH_PITEM_HEAD(path);
1295
1296         if (!is_statdata_le_ih(ih))
1297                 reiserfs_panic(inode->i_sb,
1298                                "vs-13065: update_stat_data: key %k, found item %h",
1299                                INODE_PKEY(inode), ih);
1300
1301         if (stat_data_v1(ih)) {
1302                 // path points to old stat data
1303                 inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
1304         } else {
1305                 inode2sd(B_I_PITEM(bh, ih), inode, size);
1306         }
1307
1308         return;
1309 }
1310
1311 void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
1312                              struct inode *inode, loff_t size)
1313 {
1314         struct cpu_key key;
1315         INITIALIZE_PATH(path);
1316         struct buffer_head *bh;
1317         int fs_gen;
1318         struct item_head *ih, tmp_ih;
1319         int retval;
1320
1321         BUG_ON(!th->t_trans_id);
1322
1323         make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3);        //key type is unimportant
1324
1325         for (;;) {
1326                 int pos;
1327                 /* look for the object's stat data */
1328                 retval = search_item(inode->i_sb, &key, &path);
1329                 if (retval == IO_ERROR) {
1330                         reiserfs_warning(inode->i_sb,
1331                                          "vs-13050: reiserfs_update_sd: "
1332                                          "i/o failure occurred trying to update %K stat data",
1333                                          &key);
1334                         return;
1335                 }
1336                 if (retval == ITEM_NOT_FOUND) {
1337                         pos = PATH_LAST_POSITION(&path);
1338                         pathrelse(&path);
1339                         if (inode->i_nlink == 0) {
1340                                 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */
1341                                 return;
1342                         }
1343                         reiserfs_warning(inode->i_sb,
1344                                          "vs-13060: reiserfs_update_sd: "
1345                                          "stat data of object %k (nlink == %d) not found (pos %d)",
1346                                          INODE_PKEY(inode), inode->i_nlink,
1347                                          pos);
1348                         reiserfs_check_path(&path);
1349                         return;
1350                 }
1351
1352                 /* sigh, prepare_for_journal might schedule.  When it schedules the
1353                  ** FS might change.  We have to detect that, and loop back to the
1354                  ** search if the stat data item has moved
1355                  */
1356                 bh = get_last_bh(&path);
1357                 ih = get_ih(&path);
1358                 copy_item_head(&tmp_ih, ih);
1359                 fs_gen = get_generation(inode->i_sb);
1360                 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
1361                 if (fs_changed(fs_gen, inode->i_sb)
1362                     && item_moved(&tmp_ih, &path)) {
1363                         reiserfs_restore_prepared_buffer(inode->i_sb, bh);
1364                         continue;       /* Stat_data item has been moved after scheduling. */
1365                 }
1366                 break;
1367         }
1368         update_stat_data(&path, inode, size);
1369         journal_mark_dirty(th, th->t_super, bh);
1370         pathrelse(&path);
1371         return;
1372 }
1373
1374 /* reiserfs_read_locked_inode is called to read the inode off disk, and it
1375 ** does a make_bad_inode when things go wrong.  But, we need to make sure
1376 ** and clear the key in the private portion of the inode, otherwise a
1377 ** corresponding iput might try to delete whatever object the inode last
1378 ** represented.
1379 */
1380 static void reiserfs_make_bad_inode(struct inode *inode)
1381 {
1382         memset(INODE_PKEY(inode), 0, KEY_SIZE);
1383         make_bad_inode(inode);
1384 }
1385
1386 //
1387 // initially this function was derived from minix or ext2's analog and
1388 // evolved as the prototype did
1389 //
1390
1391 int reiserfs_init_locked_inode(struct inode *inode, void *p)
1392 {
1393         struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;
1394         inode->i_ino = args->objectid;
1395         INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);
1396         return 0;
1397 }
1398
1399 /* looks for stat data in the tree, and fills up the fields of in-core
1400    inode stat data fields */
1401 void reiserfs_read_locked_inode(struct inode *inode,
1402                                 struct reiserfs_iget_args *args)
1403 {
1404         INITIALIZE_PATH(path_to_sd);
1405         struct cpu_key key;
1406         unsigned long dirino;
1407         int retval;
1408
1409         dirino = args->dirid;
1410
1411         /* set version 1, version 2 could be used too, because stat data
1412            key is the same in both versions */
1413         key.version = KEY_FORMAT_3_5;
1414         key.on_disk_key.k_dir_id = dirino;
1415         key.on_disk_key.k_objectid = inode->i_ino;
1416         key.on_disk_key.k_offset = 0;
1417         key.on_disk_key.k_type = 0;
1418
1419         /* look for the object's stat data */
1420         retval = search_item(inode->i_sb, &key, &path_to_sd);
1421         if (retval == IO_ERROR) {
1422                 reiserfs_warning(inode->i_sb,
1423                                  "vs-13070: reiserfs_read_locked_inode: "
1424                                  "i/o failure occurred trying to find stat data of %K",
1425                                  &key);
1426                 reiserfs_make_bad_inode(inode);
1427                 return;
1428         }
1429         if (retval != ITEM_FOUND) {
1430                 /* a stale NFS handle can trigger this without it being an error */
1431                 pathrelse(&path_to_sd);
1432                 reiserfs_make_bad_inode(inode);
1433                 inode->i_nlink = 0;
1434                 return;
1435         }
1436
1437         init_inode(inode, &path_to_sd);
1438
1439         /* It is possible that knfsd is trying to access inode of a file
1440            that is being removed from the disk by some other thread. As we
1441            update sd on unlink all that is required is to check for nlink
1442            here. This bug was first found by Sizif when debugging
1443            SquidNG/Butterfly, forgotten, and found again after Philippe
1444            Gramoulle <philippe.gramoulle@mmania.com> reproduced it.
1445
1446            More logical fix would require changes in fs/inode.c:iput() to
1447            remove inode from hash-table _after_ fs cleaned disk stuff up and
1448            in iget() to return NULL if I_FREEING inode is found in
1449            hash-table. */
1450         /* Currently there is one place where it's ok to meet inode with
1451            nlink==0: processing of open-unlinked and half-truncated files
1452            during mount (fs/reiserfs/super.c:finish_unfinished()). */
1453         if ((inode->i_nlink == 0) &&
1454             !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {
1455                 reiserfs_warning(inode->i_sb,
1456                                  "vs-13075: reiserfs_read_locked_inode: "
1457                                  "dead inode read from disk %K. "
1458                                  "This is likely to be race with knfsd. Ignore",
1459                                  &key);
1460                 reiserfs_make_bad_inode(inode);
1461         }
1462
1463         reiserfs_check_path(&path_to_sd);       /* init inode should be relsing */
1464
1465 }
1466
1467 /**
1468  * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().
1469  *
1470  * @inode:    inode from hash table to check
1471  * @opaque:   "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.
1472  *
1473  * This function is called by iget5_locked() to distinguish reiserfs inodes
1474  * having the same inode numbers. Such inodes can only exist due to some
1475  * error condition. One of them should be bad. Inodes with identical
1476  * inode numbers (objectids) are distinguished by parent directory ids.
1477  *
1478  */
1479 int reiserfs_find_actor(struct inode *inode, void *opaque)
1480 {
1481         struct reiserfs_iget_args *args;
1482
1483         args = opaque;
1484         /* args is already in CPU order */
1485         return (inode->i_ino == args->objectid) &&
1486             (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);
1487 }
1488
1489 struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)
1490 {
1491         struct inode *inode;
1492         struct reiserfs_iget_args args;
1493
1494         args.objectid = key->on_disk_key.k_objectid;
1495         args.dirid = key->on_disk_key.k_dir_id;
1496         inode = iget5_locked(s, key->on_disk_key.k_objectid,
1497                              reiserfs_find_actor, reiserfs_init_locked_inode,
1498                              (void *)(&args));
1499         if (!inode)
1500                 return ERR_PTR(-ENOMEM);
1501
1502         if (inode->i_state & I_NEW) {
1503                 reiserfs_read_locked_inode(inode, &args);
1504                 unlock_new_inode(inode);
1505         }
1506
1507         if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {
1508                 /* either due to i/o error or a stale NFS handle */
1509                 iput(inode);
1510                 inode = NULL;
1511         }
1512         return inode;
1513 }
1514
1515 struct dentry *reiserfs_get_dentry(struct super_block *sb, void *vobjp)
1516 {
1517         __u32 *data = vobjp;
1518         struct cpu_key key;
1519         struct dentry *result;
1520         struct inode *inode;
1521
1522         key.on_disk_key.k_objectid = data[0];
1523         key.on_disk_key.k_dir_id = data[1];
1524         reiserfs_write_lock(sb);
1525         inode = reiserfs_iget(sb, &key);
1526         if (inode && !IS_ERR(inode) && data[2] != 0 &&
1527             data[2] != inode->i_generation) {
1528                 iput(inode);
1529                 inode = NULL;
1530         }
1531         reiserfs_write_unlock(sb);
1532         if (!inode)
1533                 inode = ERR_PTR(-ESTALE);
1534         if (IS_ERR(inode))
1535                 return ERR_PTR(PTR_ERR(inode));
1536         result = d_alloc_anon(inode);
1537         if (!result) {
1538                 iput(inode);
1539                 return ERR_PTR(-ENOMEM);
1540         }
1541         return result;
1542 }
1543
1544 struct dentry *reiserfs_decode_fh(struct super_block *sb, __u32 * data,
1545                                   int len, int fhtype,
1546                                   int (*acceptable) (void *contect,
1547                                                      struct dentry * de),
1548                                   void *context)
1549 {
1550         __u32 obj[3], parent[3];
1551
1552         /* fhtype happens to reflect the number of u32s encoded.
1553          * due to a bug in earlier code, fhtype might indicate there
1554          * are more u32s then actually fitted.
1555          * so if fhtype seems to be more than len, reduce fhtype.
1556          * Valid types are:
1557          *   2 - objectid + dir_id - legacy support
1558          *   3 - objectid + dir_id + generation
1559          *   4 - objectid + dir_id + objectid and dirid of parent - legacy
1560          *   5 - objectid + dir_id + generation + objectid and dirid of parent
1561          *   6 - as above plus generation of directory
1562          * 6 does not fit in NFSv2 handles
1563          */
1564         if (fhtype > len) {
1565                 if (fhtype != 6 || len != 5)
1566                         reiserfs_warning(sb,
1567                                          "nfsd/reiserfs, fhtype=%d, len=%d - odd",
1568                                          fhtype, len);
1569                 fhtype = 5;
1570         }
1571
1572         obj[0] = data[0];
1573         obj[1] = data[1];
1574         if (fhtype == 3 || fhtype >= 5)
1575                 obj[2] = data[2];
1576         else
1577                 obj[2] = 0;     /* generation number */
1578
1579         if (fhtype >= 4) {
1580                 parent[0] = data[fhtype >= 5 ? 3 : 2];
1581                 parent[1] = data[fhtype >= 5 ? 4 : 3];
1582                 if (fhtype == 6)
1583                         parent[2] = data[5];
1584                 else
1585                         parent[2] = 0;
1586         }
1587         return sb->s_export_op->find_exported_dentry(sb, obj,
1588                                                      fhtype < 4 ? NULL : parent,
1589                                                      acceptable, context);
1590 }
1591
1592 int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
1593                        int need_parent)
1594 {
1595         struct inode *inode = dentry->d_inode;
1596         int maxlen = *lenp;
1597
1598         if (maxlen < 3)
1599                 return 255;
1600
1601         data[0] = inode->i_ino;
1602         data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1603         data[2] = inode->i_generation;
1604         *lenp = 3;
1605         /* no room for directory info? return what we've stored so far */
1606         if (maxlen < 5 || !need_parent)
1607                 return 3;
1608
1609         spin_lock(&dentry->d_lock);
1610         inode = dentry->d_parent->d_inode;
1611         data[3] = inode->i_ino;
1612         data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
1613         *lenp = 5;
1614         if (maxlen >= 6) {
1615                 data[5] = inode->i_generation;
1616                 *lenp = 6;
1617         }
1618         spin_unlock(&dentry->d_lock);
1619         return *lenp;
1620 }
1621
1622 /* looks for stat data, then copies fields to it, marks the buffer
1623    containing stat data as dirty */
1624 /* reiserfs inodes are never really dirty, since the dirty inode call
1625 ** always logs them.  This call allows the VFS inode marking routines
1626 ** to properly mark inodes for datasync and such, but only actually
1627 ** does something when called for a synchronous update.
1628 */
1629 int reiserfs_write_inode(struct inode *inode, int do_sync)
1630 {
1631         struct reiserfs_transaction_handle th;
1632         int jbegin_count = 1;
1633
1634         if (inode->i_sb->s_flags & MS_RDONLY)
1635                 return -EROFS;
1636         /* memory pressure can sometimes initiate write_inode calls with sync == 1,
1637          ** these cases are just when the system needs ram, not when the
1638          ** inode needs to reach disk for safety, and they can safely be
1639          ** ignored because the altered inode has already been logged.
1640          */
1641         if (do_sync && !(current->flags & PF_MEMALLOC)) {
1642                 reiserfs_write_lock(inode->i_sb);
1643                 if (!journal_begin(&th, inode->i_sb, jbegin_count)) {
1644                         reiserfs_update_sd(&th, inode);
1645                         journal_end_sync(&th, inode->i_sb, jbegin_count);
1646                 }
1647                 reiserfs_write_unlock(inode->i_sb);
1648         }
1649         return 0;
1650 }
1651
1652 /* stat data of new object is inserted already, this inserts the item
1653    containing "." and ".." entries */
1654 static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,
1655                                   struct inode *inode,
1656                                   struct item_head *ih, struct path *path,
1657                                   struct inode *dir)
1658 {
1659         struct super_block *sb = th->t_super;
1660         char empty_dir[EMPTY_DIR_SIZE];
1661         char *body = empty_dir;
1662         struct cpu_key key;
1663         int retval;
1664
1665         BUG_ON(!th->t_trans_id);
1666
1667         _make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),
1668                       le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,
1669                       TYPE_DIRENTRY, 3 /*key length */ );
1670
1671         /* compose item head for new item. Directories consist of items of
1672            old type (ITEM_VERSION_1). Do not set key (second arg is 0), it
1673            is done by reiserfs_new_inode */
1674         if (old_format_only(sb)) {
1675                 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1676                                   TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);
1677
1678                 make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,
1679                                        ih->ih_key.k_objectid,
1680                                        INODE_PKEY(dir)->k_dir_id,
1681                                        INODE_PKEY(dir)->k_objectid);
1682         } else {
1683                 make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,
1684                                   TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);
1685
1686                 make_empty_dir_item(body, ih->ih_key.k_dir_id,
1687                                     ih->ih_key.k_objectid,
1688                                     INODE_PKEY(dir)->k_dir_id,
1689                                     INODE_PKEY(dir)->k_objectid);
1690         }
1691
1692         /* look for place in the tree for new item */
1693         retval = search_item(sb, &key, path);
1694         if (retval == IO_ERROR) {
1695                 reiserfs_warning(sb, "vs-13080: reiserfs_new_directory: "
1696                                  "i/o failure occurred creating new directory");
1697                 return -EIO;
1698         }
1699         if (retval == ITEM_FOUND) {
1700                 pathrelse(path);
1701                 reiserfs_warning(sb, "vs-13070: reiserfs_new_directory: "
1702                                  "object with this key exists (%k)",
1703                                  &(ih->ih_key));
1704                 return -EEXIST;
1705         }
1706
1707         /* insert item, that is empty directory item */
1708         return reiserfs_insert_item(th, path, &key, ih, inode, body);
1709 }
1710
1711 /* stat data of object has been inserted, this inserts the item
1712    containing the body of symlink */
1713 static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th, struct inode *inode,    /* Inode of symlink */
1714                                 struct item_head *ih,
1715                                 struct path *path, const char *symname,
1716                                 int item_len)
1717 {
1718         struct super_block *sb = th->t_super;
1719         struct cpu_key key;
1720         int retval;
1721
1722         BUG_ON(!th->t_trans_id);
1723
1724         _make_cpu_key(&key, KEY_FORMAT_3_5,
1725                       le32_to_cpu(ih->ih_key.k_dir_id),
1726                       le32_to_cpu(ih->ih_key.k_objectid),
1727                       1, TYPE_DIRECT, 3 /*key length */ );
1728
1729         make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,
1730                           0 /*free_space */ );
1731
1732         /* look for place in the tree for new item */
1733         retval = search_item(sb, &key, path);
1734         if (retval == IO_ERROR) {
1735                 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlinik: "
1736                                  "i/o failure occurred creating new symlink");
1737                 return -EIO;
1738         }
1739         if (retval == ITEM_FOUND) {
1740                 pathrelse(path);
1741                 reiserfs_warning(sb, "vs-13080: reiserfs_new_symlink: "
1742                                  "object with this key exists (%k)",
1743                                  &(ih->ih_key));
1744                 return -EEXIST;
1745         }
1746
1747         /* insert item, that is body of symlink */
1748         return reiserfs_insert_item(th, path, &key, ih, inode, symname);
1749 }
1750
1751 /* inserts the stat data into the tree, and then calls
1752    reiserfs_new_directory (to insert ".", ".." item if new object is
1753    directory) or reiserfs_new_symlink (to insert symlink body if new
1754    object is symlink) or nothing (if new object is regular file)
1755
1756    NOTE! uid and gid must already be set in the inode.  If we return
1757    non-zero due to an error, we have to drop the quota previously allocated
1758    for the fresh inode.  This can only be done outside a transaction, so
1759    if we return non-zero, we also end the transaction.  */
1760 int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
1761                        struct inode *dir, int mode, const char *symname,
1762                        /* 0 for regular, EMTRY_DIR_SIZE for dirs,
1763                           strlen (symname) for symlinks) */
1764                        loff_t i_size, struct dentry *dentry,
1765                        struct inode *inode)
1766 {
1767         struct super_block *sb;
1768         INITIALIZE_PATH(path_to_key);
1769         struct cpu_key key;
1770         struct item_head ih;
1771         struct stat_data sd;
1772         int retval;
1773         int err;
1774
1775         BUG_ON(!th->t_trans_id);
1776
1777         if (DQUOT_ALLOC_INODE(inode)) {
1778                 err = -EDQUOT;
1779                 goto out_end_trans;
1780         }
1781         if (!dir->i_nlink) {
1782                 err = -EPERM;
1783                 goto out_bad_inode;
1784         }
1785
1786         sb = dir->i_sb;
1787
1788         /* item head of new item */
1789         ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);
1790         ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));
1791         if (!ih.ih_key.k_objectid) {
1792                 err = -ENOMEM;
1793                 goto out_bad_inode;
1794         }
1795         if (old_format_only(sb))
1796                 /* not a perfect generation count, as object ids can be reused, but
1797                  ** this is as good as reiserfs can do right now.
1798                  ** note that the private part of inode isn't filled in yet, we have
1799                  ** to use the directory.
1800                  */
1801                 inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);
1802         else
1803 #if defined( USE_INODE_GENERATION_COUNTER )
1804                 inode->i_generation =
1805                     le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);
1806 #else
1807                 inode->i_generation = ++event;
1808 #endif
1809
1810         /* fill stat data */
1811         inode->i_nlink = (S_ISDIR(mode) ? 2 : 1);
1812
1813         /* uid and gid must already be set by the caller for quota init */
1814
1815         /* symlink cannot be immutable or append only, right? */
1816         if (S_ISLNK(inode->i_mode))
1817                 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
1818
1819         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
1820         inode->i_size = i_size;
1821         inode->i_blocks = 0;
1822         inode->i_bytes = 0;
1823         REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :
1824             U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;
1825
1826         INIT_LIST_HEAD(&(REISERFS_I(inode)->i_prealloc_list));
1827         REISERFS_I(inode)->i_flags = 0;
1828         REISERFS_I(inode)->i_prealloc_block = 0;
1829         REISERFS_I(inode)->i_prealloc_count = 0;
1830         REISERFS_I(inode)->i_trans_id = 0;
1831         REISERFS_I(inode)->i_jl = NULL;
1832         REISERFS_I(inode)->i_attrs =
1833             REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;
1834         sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);
1835         reiserfs_init_acl_access(inode);
1836         reiserfs_init_acl_default(inode);
1837         reiserfs_init_xattr_rwsem(inode);
1838
1839         if (old_format_only(sb))
1840                 make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,
1841                                   TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);
1842         else
1843                 make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,
1844                                   TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);
1845
1846         /* key to search for correct place for new stat data */
1847         _make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),
1848                       le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,
1849                       TYPE_STAT_DATA, 3 /*key length */ );
1850
1851         /* find proper place for inserting of stat data */
1852         retval = search_item(sb, &key, &path_to_key);
1853         if (retval == IO_ERROR) {
1854                 err = -EIO;
1855                 goto out_bad_inode;
1856         }
1857         if (retval == ITEM_FOUND) {
1858                 pathrelse(&path_to_key);
1859                 err = -EEXIST;
1860                 goto out_bad_inode;
1861         }
1862         if (old_format_only(sb)) {
1863                 if (inode->i_uid & ~0xffff || inode->i_gid & ~0xffff) {
1864                         pathrelse(&path_to_key);
1865                         /* i_uid or i_gid is too big to be stored in stat data v3.5 */
1866                         err = -EINVAL;
1867                         goto out_bad_inode;
1868                 }
1869                 inode2sd_v1(&sd, inode, inode->i_size);
1870         } else {
1871                 inode2sd(&sd, inode, inode->i_size);
1872         }
1873         // these do not go to on-disk stat data
1874         inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);
1875
1876         // store in in-core inode the key of stat data and version all
1877         // object items will have (directory items will have old offset
1878         // format, other new objects will consist of new items)
1879         memcpy(INODE_PKEY(inode), &(ih.ih_key), KEY_SIZE);
1880         if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))
1881                 set_inode_item_key_version(inode, KEY_FORMAT_3_5);
1882         else
1883                 set_inode_item_key_version(inode, KEY_FORMAT_3_6);
1884         if (old_format_only(sb))
1885                 set_inode_sd_version(inode, STAT_DATA_V1);
1886         else
1887                 set_inode_sd_version(inode, STAT_DATA_V2);
1888
1889         /* insert the stat data into the tree */
1890 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1891         if (REISERFS_I(dir)->new_packing_locality)
1892                 th->displace_new_blocks = 1;
1893 #endif
1894         retval =
1895             reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,
1896                                  (char *)(&sd));
1897         if (retval) {
1898                 err = retval;
1899                 reiserfs_check_path(&path_to_key);
1900                 goto out_bad_inode;
1901         }
1902 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1903         if (!th->displace_new_blocks)
1904                 REISERFS_I(dir)->new_packing_locality = 0;
1905 #endif
1906         if (S_ISDIR(mode)) {
1907                 /* insert item with "." and ".." */
1908                 retval =
1909                     reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);
1910         }
1911
1912         if (S_ISLNK(mode)) {
1913                 /* insert body of symlink */
1914                 if (!old_format_only(sb))
1915                         i_size = ROUND_UP(i_size);
1916                 retval =
1917                     reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,
1918                                          i_size);
1919         }
1920         if (retval) {
1921                 err = retval;
1922                 reiserfs_check_path(&path_to_key);
1923                 journal_end(th, th->t_super, th->t_blocks_allocated);
1924                 goto out_inserted_sd;
1925         }
1926
1927         /* XXX CHECK THIS */
1928         if (reiserfs_posixacl(inode->i_sb)) {
1929                 retval = reiserfs_inherit_default_acl(dir, dentry, inode);
1930                 if (retval) {
1931                         err = retval;
1932                         reiserfs_check_path(&path_to_key);
1933                         journal_end(th, th->t_super, th->t_blocks_allocated);
1934                         goto out_inserted_sd;
1935                 }
1936         } else if (inode->i_sb->s_flags & MS_POSIXACL) {
1937                 reiserfs_warning(inode->i_sb, "ACLs aren't enabled in the fs, "
1938                                  "but vfs thinks they are!");
1939         } else if (is_reiserfs_priv_object(dir)) {
1940                 reiserfs_mark_inode_private(inode);
1941         }
1942
1943         insert_inode_hash(inode);
1944         reiserfs_update_sd(th, inode);
1945         reiserfs_check_path(&path_to_key);
1946
1947         return 0;
1948
1949 /* it looks like you can easily compress these two goto targets into
1950  * one.  Keeping it like this doesn't actually hurt anything, and they
1951  * are place holders for what the quota code actually needs.
1952  */
1953       out_bad_inode:
1954         /* Invalidate the object, nothing was inserted yet */
1955         INODE_PKEY(inode)->k_objectid = 0;
1956
1957         /* Quota change must be inside a transaction for journaling */
1958         DQUOT_FREE_INODE(inode);
1959
1960       out_end_trans:
1961         journal_end(th, th->t_super, th->t_blocks_allocated);
1962         /* Drop can be outside and it needs more credits so it's better to have it outside */
1963         DQUOT_DROP(inode);
1964         inode->i_flags |= S_NOQUOTA;
1965         make_bad_inode(inode);
1966
1967       out_inserted_sd:
1968         inode->i_nlink = 0;
1969         th->t_trans_id = 0;     /* so the caller can't use this handle later */
1970
1971         /* If we were inheriting an ACL, we need to release the lock so that
1972          * iput doesn't deadlock in reiserfs_delete_xattrs. The locking
1973          * code really needs to be reworked, but this will take care of it
1974          * for now. -jeffm */
1975 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1976         if (REISERFS_I(dir)->i_acl_default && !IS_ERR(REISERFS_I(dir)->i_acl_default)) {
1977                 reiserfs_write_unlock_xattrs(dir->i_sb);
1978                 iput(inode);
1979                 reiserfs_write_lock_xattrs(dir->i_sb);
1980         } else
1981 #endif
1982                 iput(inode);
1983         return err;
1984 }
1985
1986 /*
1987 ** finds the tail page in the page cache,
1988 ** reads the last block in.
1989 **
1990 ** On success, page_result is set to a locked, pinned page, and bh_result
1991 ** is set to an up to date buffer for the last block in the file.  returns 0.
1992 **
1993 ** tail conversion is not done, so bh_result might not be valid for writing
1994 ** check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before
1995 ** trying to write the block.
1996 **
1997 ** on failure, nonzero is returned, page_result and bh_result are untouched.
1998 */
1999 static int grab_tail_page(struct inode *p_s_inode,
2000                           struct page **page_result,
2001                           struct buffer_head **bh_result)
2002 {
2003
2004         /* we want the page with the last byte in the file,
2005          ** not the page that will hold the next byte for appending
2006          */
2007         unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT;
2008         unsigned long pos = 0;
2009         unsigned long start = 0;
2010         unsigned long blocksize = p_s_inode->i_sb->s_blocksize;
2011         unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1);
2012         struct buffer_head *bh;
2013         struct buffer_head *head;
2014         struct page *page;
2015         int error;
2016
2017         /* we know that we are only called with inode->i_size > 0.
2018          ** we also know that a file tail can never be as big as a block
2019          ** If i_size % blocksize == 0, our file is currently block aligned
2020          ** and it won't need converting or zeroing after a truncate.
2021          */
2022         if ((offset & (blocksize - 1)) == 0) {
2023                 return -ENOENT;
2024         }
2025         page = grab_cache_page(p_s_inode->i_mapping, index);
2026         error = -ENOMEM;
2027         if (!page) {
2028                 goto out;
2029         }
2030         /* start within the page of the last block in the file */
2031         start = (offset / blocksize) * blocksize;
2032
2033         error = block_prepare_write(page, start, offset,
2034                                     reiserfs_get_block_create_0);
2035         if (error)
2036                 goto unlock;
2037
2038         head = page_buffers(page);
2039         bh = head;
2040         do {
2041                 if (pos >= start) {
2042                         break;
2043                 }
2044                 bh = bh->b_this_page;
2045                 pos += blocksize;
2046         } while (bh != head);
2047
2048         if (!buffer_uptodate(bh)) {
2049                 /* note, this should never happen, prepare_write should
2050                  ** be taking care of this for us.  If the buffer isn't up to date,
2051                  ** I've screwed up the code to find the buffer, or the code to
2052                  ** call prepare_write
2053                  */
2054                 reiserfs_warning(p_s_inode->i_sb,
2055                                  "clm-6000: error reading block %lu on dev %s",
2056                                  bh->b_blocknr,
2057                                  reiserfs_bdevname(p_s_inode->i_sb));
2058                 error = -EIO;
2059                 goto unlock;
2060         }
2061         *bh_result = bh;
2062         *page_result = page;
2063
2064       out:
2065         return error;
2066
2067       unlock:
2068         unlock_page(page);
2069         page_cache_release(page);
2070         return error;
2071 }
2072
2073 /*
2074 ** vfs version of truncate file.  Must NOT be called with
2075 ** a transaction already started.
2076 **
2077 ** some code taken from block_truncate_page
2078 */
2079 int reiserfs_truncate_file(struct inode *p_s_inode, int update_timestamps)
2080 {
2081         struct reiserfs_transaction_handle th;
2082         /* we want the offset for the first byte after the end of the file */
2083         unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1);
2084         unsigned blocksize = p_s_inode->i_sb->s_blocksize;
2085         unsigned length;
2086         struct page *page = NULL;
2087         int error;
2088         struct buffer_head *bh = NULL;
2089         int err2;
2090
2091         reiserfs_write_lock(p_s_inode->i_sb);
2092
2093         if (p_s_inode->i_size > 0) {
2094                 if ((error = grab_tail_page(p_s_inode, &page, &bh))) {
2095                         // -ENOENT means we truncated past the end of the file,
2096                         // and get_block_create_0 could not find a block to read in,
2097                         // which is ok.
2098                         if (error != -ENOENT)
2099                                 reiserfs_warning(p_s_inode->i_sb,
2100                                                  "clm-6001: grab_tail_page failed %d",
2101                                                  error);
2102                         page = NULL;
2103                         bh = NULL;
2104                 }
2105         }
2106
2107         /* so, if page != NULL, we have a buffer head for the offset at
2108          ** the end of the file. if the bh is mapped, and bh->b_blocknr != 0,
2109          ** then we have an unformatted node.  Otherwise, we have a direct item,
2110          ** and no zeroing is required on disk.  We zero after the truncate,
2111          ** because the truncate might pack the item anyway
2112          ** (it will unmap bh if it packs).
2113          */
2114         /* it is enough to reserve space in transaction for 2 balancings:
2115            one for "save" link adding and another for the first
2116            cut_from_item. 1 is for update_sd */
2117         error = journal_begin(&th, p_s_inode->i_sb,
2118                               JOURNAL_PER_BALANCE_CNT * 2 + 1);
2119         if (error)
2120                 goto out;
2121         reiserfs_update_inode_transaction(p_s_inode);
2122         if (update_timestamps)
2123                 /* we are doing real truncate: if the system crashes before the last
2124                    transaction of truncating gets committed - on reboot the file
2125                    either appears truncated properly or not truncated at all */
2126                 add_save_link(&th, p_s_inode, 1);
2127         err2 = reiserfs_do_truncate(&th, p_s_inode, page, update_timestamps);
2128         error =
2129             journal_end(&th, p_s_inode->i_sb, JOURNAL_PER_BALANCE_CNT * 2 + 1);
2130         if (error)
2131                 goto out;
2132
2133         /* check reiserfs_do_truncate after ending the transaction */
2134         if (err2) {
2135                 error = err2;
2136                 goto out;
2137         }
2138
2139         if (update_timestamps) {
2140                 error = remove_save_link(p_s_inode, 1 /* truncate */ );
2141                 if (error)
2142                         goto out;
2143         }
2144
2145         if (page) {
2146                 length = offset & (blocksize - 1);
2147                 /* if we are not on a block boundary */
2148                 if (length) {
2149                         char *kaddr;
2150
2151                         length = blocksize - length;
2152                         kaddr = kmap_atomic(page, KM_USER0);
2153                         memset(kaddr + offset, 0, length);
2154                         flush_dcache_page(page);
2155                         kunmap_atomic(kaddr, KM_USER0);
2156                         if (buffer_mapped(bh) && bh->b_blocknr != 0) {
2157                                 mark_buffer_dirty(bh);
2158                         }
2159                 }
2160                 unlock_page(page);
2161                 page_cache_release(page);
2162         }
2163
2164         reiserfs_write_unlock(p_s_inode->i_sb);
2165         return 0;
2166       out:
2167         if (page) {
2168                 unlock_page(page);
2169                 page_cache_release(page);
2170         }
2171         reiserfs_write_unlock(p_s_inode->i_sb);
2172         return error;
2173 }
2174
2175 static int map_block_for_writepage(struct inode *inode,
2176                                    struct buffer_head *bh_result,
2177                                    unsigned long block)
2178 {
2179         struct reiserfs_transaction_handle th;
2180         int fs_gen;
2181         struct item_head tmp_ih;
2182         struct item_head *ih;
2183         struct buffer_head *bh;
2184         __le32 *item;
2185         struct cpu_key key;
2186         INITIALIZE_PATH(path);
2187         int pos_in_item;
2188         int jbegin_count = JOURNAL_PER_BALANCE_CNT;
2189         loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;
2190         int retval;
2191         int use_get_block = 0;
2192         int bytes_copied = 0;
2193         int copy_size;
2194         int trans_running = 0;
2195
2196         /* catch places below that try to log something without starting a trans */
2197         th.t_trans_id = 0;
2198
2199         if (!buffer_uptodate(bh_result)) {
2200                 return -EIO;
2201         }
2202
2203         kmap(bh_result->b_page);
2204       start_over:
2205         reiserfs_write_lock(inode->i_sb);
2206         make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);
2207
2208       research:
2209         retval = search_for_position_by_key(inode->i_sb, &key, &path);
2210         if (retval != POSITION_FOUND) {
2211                 use_get_block = 1;
2212                 goto out;
2213         }
2214
2215         bh = get_last_bh(&path);
2216         ih = get_ih(&path);
2217         item = get_item(&path);
2218         pos_in_item = path.pos_in_item;
2219
2220         /* we've found an unformatted node */
2221         if (indirect_item_found(retval, ih)) {
2222                 if (bytes_copied > 0) {
2223                         reiserfs_warning(inode->i_sb,
2224                                          "clm-6002: bytes_copied %d",
2225                                          bytes_copied);
2226                 }
2227                 if (!get_block_num(item, pos_in_item)) {
2228                         /* crap, we are writing to a hole */
2229                         use_get_block = 1;
2230                         goto out;
2231                 }
2232                 set_block_dev_mapped(bh_result,
2233                                      get_block_num(item, pos_in_item), inode);
2234         } else if (is_direct_le_ih(ih)) {
2235                 char *p;
2236                 p = page_address(bh_result->b_page);
2237                 p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
2238                 copy_size = ih_item_len(ih) - pos_in_item;
2239
2240                 fs_gen = get_generation(inode->i_sb);
2241                 copy_item_head(&tmp_ih, ih);
2242
2243                 if (!trans_running) {
2244                         /* vs-3050 is gone, no need to drop the path */
2245                         retval = journal_begin(&th, inode->i_sb, jbegin_count);
2246                         if (retval)
2247                                 goto out;
2248                         reiserfs_update_inode_transaction(inode);
2249                         trans_running = 1;
2250                         if (fs_changed(fs_gen, inode->i_sb)
2251                             && item_moved(&tmp_ih, &path)) {
2252                                 reiserfs_restore_prepared_buffer(inode->i_sb,
2253                                                                  bh);
2254                                 goto research;
2255                         }
2256                 }
2257
2258                 reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
2259
2260                 if (fs_changed(fs_gen, inode->i_sb)
2261                     && item_moved(&tmp_ih, &path)) {
2262                         reiserfs_restore_prepared_buffer(inode->i_sb, bh);
2263                         goto research;
2264                 }
2265
2266                 memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
2267                        copy_size);
2268
2269                 journal_mark_dirty(&th, inode->i_sb, bh);
2270                 bytes_copied += copy_size;
2271                 set_block_dev_mapped(bh_result, 0, inode);
2272
2273                 /* are there still bytes left? */
2274                 if (bytes_copied < bh_result->b_size &&
2275                     (byte_offset + bytes_copied) < inode->i_size) {
2276                         set_cpu_key_k_offset(&key,
2277                                              cpu_key_k_offset(&key) +
2278                                              copy_size);
2279                         goto research;
2280                 }
2281         } else {
2282                 reiserfs_warning(inode->i_sb,
2283                                  "clm-6003: bad item inode %lu, device %s",
2284                                  inode->i_ino, reiserfs_bdevname(inode->i_sb));
2285                 retval = -EIO;
2286                 goto out;
2287         }
2288         retval = 0;
2289
2290       out:
2291         pathrelse(&path);
2292         if (trans_running) {
2293                 int err = journal_end(&th, inode->i_sb, jbegin_count);
2294                 if (err)
2295                         retval = err;
2296                 trans_running = 0;
2297         }
2298         reiserfs_write_unlock(inode->i_sb);
2299
2300         /* this is where we fill in holes in the file. */
2301         if (use_get_block) {
2302                 retval = reiserfs_get_block(inode, block, bh_result,
2303                                             GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX
2304                                             | GET_BLOCK_NO_DANGLE);
2305                 if (!retval) {
2306                         if (!buffer_mapped(bh_result)
2307                             || bh_result->b_blocknr == 0) {
2308                                 /* get_block failed to find a mapped unformatted node. */
2309                                 use_get_block = 0;
2310                                 goto start_over;
2311                         }
2312                 }
2313         }
2314         kunmap(bh_result->b_page);
2315
2316         if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {
2317                 /* we've copied data from the page into the direct item, so the
2318                  * buffer in the page is now clean, mark it to reflect that.
2319                  */
2320                 lock_buffer(bh_result);
2321                 clear_buffer_dirty(bh_result);
2322                 unlock_buffer(bh_result);
2323         }
2324         return retval;
2325 }
2326
2327 /*
2328  * mason@suse.com: updated in 2.5.54 to follow the same general io
2329  * start/recovery path as __block_write_full_page, along with special
2330  * code to handle reiserfs tails.
2331  */
2332 static int reiserfs_write_full_page(struct page *page,
2333                                     struct writeback_control *wbc)
2334 {
2335         struct inode *inode = page->mapping->host;
2336         unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
2337         int error = 0;
2338         unsigned long block;
2339         sector_t last_block;
2340         struct buffer_head *head, *bh;
2341         int partial = 0;
2342         int nr = 0;
2343         int checked = PageChecked(page);
2344         struct reiserfs_transaction_handle th;
2345         struct super_block *s = inode->i_sb;
2346         int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
2347         th.t_trans_id = 0;
2348
2349         /* no logging allowed when nonblocking or from PF_MEMALLOC */
2350         if (checked && (current->flags & PF_MEMALLOC)) {
2351                 redirty_page_for_writepage(wbc, page);
2352                 unlock_page(page);
2353                 return 0;
2354         }
2355
2356         /* The page dirty bit is cleared before writepage is called, which
2357          * means we have to tell create_empty_buffers to make dirty buffers
2358          * The page really should be up to date at this point, so tossing
2359          * in the BH_Uptodate is just a sanity check.
2360          */
2361         if (!page_has_buffers(page)) {
2362                 create_empty_buffers(page, s->s_blocksize,
2363                                      (1 << BH_Dirty) | (1 << BH_Uptodate));
2364         }
2365         head = page_buffers(page);
2366
2367         /* last page in the file, zero out any contents past the
2368          ** last byte in the file
2369          */
2370         if (page->index >= end_index) {
2371                 char *kaddr;
2372                 unsigned last_offset;
2373
2374                 last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
2375                 /* no file contents in this page */
2376                 if (page->index >= end_index + 1 || !last_offset) {
2377                         unlock_page(page);
2378                         return 0;
2379                 }
2380                 kaddr = kmap_atomic(page, KM_USER0);
2381                 memset(kaddr + last_offset, 0, PAGE_CACHE_SIZE - last_offset);
2382                 flush_dcache_page(page);
2383                 kunmap_atomic(kaddr, KM_USER0);
2384         }
2385         bh = head;
2386         block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
2387         last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
2388         /* first map all the buffers, logging any direct items we find */
2389         do {
2390                 if (block > last_block) {
2391                         /*
2392                          * This can happen when the block size is less than
2393                          * the page size.  The corresponding bytes in the page
2394                          * were zero filled above
2395                          */
2396                         clear_buffer_dirty(bh);
2397                         set_buffer_uptodate(bh);
2398                 } else if ((checked || buffer_dirty(bh)) &&
2399                            (!buffer_mapped(bh) || (buffer_mapped(bh)
2400                                                        && bh->b_blocknr ==
2401                                                        0))) {
2402                         /* not mapped yet, or it points to a direct item, search
2403                          * the btree for the mapping info, and log any direct
2404                          * items found
2405                          */
2406                         if ((error = map_block_for_writepage(inode, bh, block))) {
2407                                 goto fail;
2408                         }
2409                 }
2410                 bh = bh->b_this_page;
2411                 block++;
2412         } while (bh != head);
2413
2414         /*
2415          * we start the transaction after map_block_for_writepage,
2416          * because it can create holes in the file (an unbounded operation).
2417          * starting it here, we can make a reliable estimate for how many
2418          * blocks we're going to log
2419          */
2420         if (checked) {
2421                 ClearPageChecked(page);
2422                 reiserfs_write_lock(s);
2423                 error = journal_begin(&th, s, bh_per_page + 1);
2424                 if (error) {
2425                         reiserfs_write_unlock(s);
2426                         goto fail;
2427                 }
2428                 reiserfs_update_inode_transaction(inode);
2429         }
2430         /* now go through and lock any dirty buffers on the page */
2431         do {
2432                 get_bh(bh);
2433                 if (!buffer_mapped(bh))
2434                         continue;
2435                 if (buffer_mapped(bh) && bh->b_blocknr == 0)
2436                         continue;
2437
2438                 if (checked) {
2439                         reiserfs_prepare_for_journal(s, bh, 1);
2440                         journal_mark_dirty(&th, s, bh);
2441                         continue;
2442                 }
2443                 /* from this point on, we know the buffer is mapped to a
2444                  * real block and not a direct item
2445                  */
2446                 if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
2447                         lock_buffer(bh);
2448                 } else {
2449                         if (test_set_buffer_locked(bh)) {
2450                                 redirty_page_for_writepage(wbc, page);
2451                                 continue;
2452                         }
2453                 }
2454                 if (test_clear_buffer_dirty(bh)) {
2455                         mark_buffer_async_write(bh);
2456                 } else {
2457                         unlock_buffer(bh);
2458                 }
2459         } while ((bh = bh->b_this_page) != head);
2460
2461         if (checked) {
2462                 error = journal_end(&th, s, bh_per_page + 1);
2463                 reiserfs_write_unlock(s);
2464                 if (error)
2465                         goto fail;
2466         }
2467         BUG_ON(PageWriteback(page));
2468         set_page_writeback(page);
2469         unlock_page(page);
2470
2471         /*
2472          * since any buffer might be the only dirty buffer on the page,
2473          * the first submit_bh can bring the page out of writeback.
2474          * be careful with the buffers.
2475          */
2476         do {
2477                 struct buffer_head *next = bh->b_this_page;
2478                 if (buffer_async_write(bh)) {
2479                         submit_bh(WRITE, bh);
2480                         nr++;
2481                 }
2482                 put_bh(bh);
2483                 bh = next;
2484         } while (bh != head);
2485
2486         error = 0;
2487       done:
2488         if (nr == 0) {
2489                 /*
2490                  * if this page only had a direct item, it is very possible for
2491                  * no io to be required without there being an error.  Or,
2492                  * someone else could have locked them and sent them down the
2493                  * pipe without locking the page
2494                  */
2495                 bh = head;
2496                 do {
2497                         if (!buffer_uptodate(bh)) {
2498                                 partial = 1;
2499                                 break;
2500                         }
2501                         bh = bh->b_this_page;
2502                 } while (bh != head);
2503                 if (!partial)
2504                         SetPageUptodate(page);
2505                 end_page_writeback(page);
2506         }
2507         return error;
2508
2509       fail:
2510         /* catches various errors, we need to make sure any valid dirty blocks
2511          * get to the media.  The page is currently locked and not marked for
2512          * writeback
2513          */
2514         ClearPageUptodate(page);
2515         bh = head;
2516         do {
2517                 get_bh(bh);
2518                 if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {
2519                         lock_buffer(bh);
2520                         mark_buffer_async_write(bh);
2521                 } else {
2522                         /*
2523                          * clear any dirty bits that might have come from getting
2524                          * attached to a dirty page
2525                          */
2526                         clear_buffer_dirty(bh);
2527                 }
2528                 bh = bh->b_this_page;
2529         } while (bh != head);
2530         SetPageError(page);
2531         BUG_ON(PageWriteback(page));
2532         set_page_writeback(page);
2533         unlock_page(page);
2534         do {
2535                 struct buffer_head *next = bh->b_this_page;
2536                 if (buffer_async_write(bh)) {
2537                         clear_buffer_dirty(bh);
2538                         submit_bh(WRITE, bh);
2539                         nr++;
2540                 }
2541                 put_bh(bh);
2542                 bh = next;
2543         } while (bh != head);
2544         goto done;
2545 }
2546
2547 static int reiserfs_readpage(struct file *f, struct page *page)
2548 {
2549         return block_read_full_page(page, reiserfs_get_block);
2550 }
2551
2552 static int reiserfs_writepage(struct page *page, struct writeback_control *wbc)
2553 {
2554         struct inode *inode = page->mapping->host;
2555         reiserfs_wait_on_write_block(inode->i_sb);
2556         return reiserfs_write_full_page(page, wbc);
2557 }
2558
2559 static int reiserfs_prepare_write(struct file *f, struct page *page,
2560                                   unsigned from, unsigned to)
2561 {
2562         struct inode *inode = page->mapping->host;
2563         int ret;
2564         int old_ref = 0;
2565
2566         reiserfs_wait_on_write_block(inode->i_sb);
2567         fix_tail_page_for_writing(page);
2568         if (reiserfs_transaction_running(inode->i_sb)) {
2569                 struct reiserfs_transaction_handle *th;
2570                 th = (struct reiserfs_transaction_handle *)current->
2571                     journal_info;
2572                 BUG_ON(!th->t_refcount);
2573                 BUG_ON(!th->t_trans_id);
2574                 old_ref = th->t_refcount;
2575                 th->t_refcount++;
2576         }
2577
2578         ret = block_prepare_write(page, from, to, reiserfs_get_block);
2579         if (ret && reiserfs_transaction_running(inode->i_sb)) {
2580                 struct reiserfs_transaction_handle *th = current->journal_info;
2581                 /* this gets a little ugly.  If reiserfs_get_block returned an
2582                  * error and left a transacstion running, we've got to close it,
2583                  * and we've got to free handle if it was a persistent transaction.
2584                  *
2585                  * But, if we had nested into an existing transaction, we need
2586                  * to just drop the ref count on the handle.
2587                  *
2588                  * If old_ref == 0, the transaction is from reiserfs_get_block,
2589                  * and it was a persistent trans.  Otherwise, it was nested above.
2590                  */
2591                 if (th->t_refcount > old_ref) {
2592                         if (old_ref)
2593                                 th->t_refcount--;
2594                         else {
2595                                 int err;
2596                                 reiserfs_write_lock(inode->i_sb);
2597                                 err = reiserfs_end_persistent_transaction(th);
2598                                 reiserfs_write_unlock(inode->i_sb);
2599                                 if (err)
2600                                         ret = err;
2601                         }
2602                 }
2603         }
2604         return ret;
2605
2606 }
2607
2608 static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)
2609 {
2610         return generic_block_bmap(as, block, reiserfs_bmap);
2611 }
2612
2613 static int reiserfs_commit_write(struct file *f, struct page *page,
2614                                  unsigned from, unsigned to)
2615 {
2616         struct inode *inode = page->mapping->host;
2617         loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
2618         int ret = 0;
2619         int update_sd = 0;
2620         struct reiserfs_transaction_handle *th = NULL;
2621
2622         reiserfs_wait_on_write_block(inode->i_sb);
2623         if (reiserfs_transaction_running(inode->i_sb)) {
2624                 th = current->journal_info;
2625         }
2626         reiserfs_commit_page(inode, page, from, to);
2627
2628         /* generic_commit_write does this for us, but does not update the
2629          ** transaction tracking stuff when the size changes.  So, we have
2630          ** to do the i_size updates here.
2631          */
2632         if (pos > inode->i_size) {
2633                 struct reiserfs_transaction_handle myth;
2634                 reiserfs_write_lock(inode->i_sb);
2635                 /* If the file have grown beyond the border where it
2636                    can have a tail, unmark it as needing a tail
2637                    packing */
2638                 if ((have_large_tails(inode->i_sb)
2639                      && inode->i_size > i_block_size(inode) * 4)
2640                     || (have_small_tails(inode->i_sb)
2641                         && inode->i_size > i_block_size(inode)))
2642                         REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;
2643
2644                 ret = journal_begin(&myth, inode->i_sb, 1);
2645                 if (ret) {
2646                         reiserfs_write_unlock(inode->i_sb);
2647                         goto journal_error;
2648                 }
2649                 reiserfs_update_inode_transaction(inode);
2650                 inode->i_size = pos;
2651                 /*
2652                  * this will just nest into our transaction.  It's important
2653                  * to use mark_inode_dirty so the inode gets pushed around on the
2654                  * dirty lists, and so that O_SYNC works as expected
2655                  */
2656                 mark_inode_dirty(inode);
2657                 reiserfs_update_sd(&myth, inode);
2658                 update_sd = 1;
2659                 ret = journal_end(&myth, inode->i_sb, 1);
2660                 reiserfs_write_unlock(inode->i_sb);
2661                 if (ret)
2662                         goto journal_error;
2663         }
2664         if (th) {
2665                 reiserfs_write_lock(inode->i_sb);
2666                 if (!update_sd)
2667                         mark_inode_dirty(inode);
2668                 ret = reiserfs_end_persistent_transaction(th);
2669                 reiserfs_write_unlock(inode->i_sb);
2670                 if (ret)
2671                         goto out;
2672         }
2673
2674       out:
2675         return ret;
2676
2677       journal_error:
2678         if (th) {
2679                 reiserfs_write_lock(inode->i_sb);
2680                 if (!update_sd)
2681                         reiserfs_update_sd(th, inode);
2682                 ret = reiserfs_end_persistent_transaction(th);
2683                 reiserfs_write_unlock(inode->i_sb);
2684         }
2685
2686         return ret;
2687 }
2688
2689 void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)
2690 {
2691         if (reiserfs_attrs(inode->i_sb)) {
2692                 if (sd_attrs & REISERFS_SYNC_FL)
2693                         inode->i_flags |= S_SYNC;
2694                 else
2695                         inode->i_flags &= ~S_SYNC;
2696                 if (sd_attrs & REISERFS_IMMUTABLE_FL)
2697                         inode->i_flags |= S_IMMUTABLE;
2698                 else
2699                         inode->i_flags &= ~S_IMMUTABLE;
2700                 if (sd_attrs & REISERFS_APPEND_FL)
2701                         inode->i_flags |= S_APPEND;
2702                 else
2703                         inode->i_flags &= ~S_APPEND;
2704                 if (sd_attrs & REISERFS_NOATIME_FL)
2705                         inode->i_flags |= S_NOATIME;
2706                 else
2707                         inode->i_flags &= ~S_NOATIME;
2708                 if (sd_attrs & REISERFS_NOTAIL_FL)
2709                         REISERFS_I(inode)->i_flags |= i_nopack_mask;
2710                 else
2711                         REISERFS_I(inode)->i_flags &= ~i_nopack_mask;
2712         }
2713 }
2714
2715 void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs)
2716 {
2717         if (reiserfs_attrs(inode->i_sb)) {
2718                 if (inode->i_flags & S_IMMUTABLE)
2719                         *sd_attrs |= REISERFS_IMMUTABLE_FL;
2720                 else
2721                         *sd_attrs &= ~REISERFS_IMMUTABLE_FL;
2722                 if (inode->i_flags & S_SYNC)
2723                         *sd_attrs |= REISERFS_SYNC_FL;
2724                 else
2725                         *sd_attrs &= ~REISERFS_SYNC_FL;
2726                 if (inode->i_flags & S_NOATIME)
2727                         *sd_attrs |= REISERFS_NOATIME_FL;
2728                 else
2729                         *sd_attrs &= ~REISERFS_NOATIME_FL;
2730                 if (REISERFS_I(inode)->i_flags & i_nopack_mask)
2731                         *sd_attrs |= REISERFS_NOTAIL_FL;
2732                 else
2733                         *sd_attrs &= ~REISERFS_NOTAIL_FL;
2734         }
2735 }
2736
2737 /* decide if this buffer needs to stay around for data logging or ordered
2738 ** write purposes
2739 */
2740 static int invalidatepage_can_drop(struct inode *inode, struct buffer_head *bh)
2741 {
2742         int ret = 1;
2743         struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2744
2745         lock_buffer(bh);
2746         spin_lock(&j->j_dirty_buffers_lock);
2747         if (!buffer_mapped(bh)) {
2748                 goto free_jh;
2749         }
2750         /* the page is locked, and the only places that log a data buffer
2751          * also lock the page.
2752          */
2753         if (reiserfs_file_data_log(inode)) {
2754                 /*
2755                  * very conservative, leave the buffer pinned if
2756                  * anyone might need it.
2757                  */
2758                 if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
2759                         ret = 0;
2760                 }
2761         } else  if (buffer_dirty(bh)) {
2762                 struct reiserfs_journal_list *jl;
2763                 struct reiserfs_jh *jh = bh->b_private;
2764
2765                 /* why is this safe?
2766                  * reiserfs_setattr updates i_size in the on disk
2767                  * stat data before allowing vmtruncate to be called.
2768                  *
2769                  * If buffer was put onto the ordered list for this
2770                  * transaction, we know for sure either this transaction
2771                  * or an older one already has updated i_size on disk,
2772                  * and this ordered data won't be referenced in the file
2773                  * if we crash.
2774                  *
2775                  * if the buffer was put onto the ordered list for an older
2776                  * transaction, we need to leave it around
2777                  */
2778                 if (jh && (jl = jh->jl)
2779                     && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)
2780                         ret = 0;
2781         }
2782       free_jh:
2783         if (ret && bh->b_private) {
2784                 reiserfs_free_jh(bh);
2785         }
2786         spin_unlock(&j->j_dirty_buffers_lock);
2787         unlock_buffer(bh);
2788         return ret;
2789 }
2790
2791 /* clm -- taken from fs/buffer.c:block_invalidate_page */
2792 static void reiserfs_invalidatepage(struct page *page, unsigned long offset)
2793 {
2794         struct buffer_head *head, *bh, *next;
2795         struct inode *inode = page->mapping->host;
2796         unsigned int curr_off = 0;
2797         int ret = 1;
2798
2799         BUG_ON(!PageLocked(page));
2800
2801         if (offset == 0)
2802                 ClearPageChecked(page);
2803
2804         if (!page_has_buffers(page))
2805                 goto out;
2806
2807         head = page_buffers(page);
2808         bh = head;
2809         do {
2810                 unsigned int next_off = curr_off + bh->b_size;
2811                 next = bh->b_this_page;
2812
2813                 /*
2814                  * is this block fully invalidated?
2815                  */
2816                 if (offset <= curr_off) {
2817                         if (invalidatepage_can_drop(inode, bh))
2818                                 reiserfs_unmap_buffer(bh);
2819                         else
2820                                 ret = 0;
2821                 }
2822                 curr_off = next_off;
2823                 bh = next;
2824         } while (bh != head);
2825
2826         /*
2827          * We release buffers only if the entire page is being invalidated.
2828          * The get_block cached value has been unconditionally invalidated,
2829          * so real IO is not possible anymore.
2830          */
2831         if (!offset && ret) {
2832                 ret = try_to_release_page(page, 0);
2833                 /* maybe should BUG_ON(!ret); - neilb */
2834         }
2835       out:
2836         return;
2837 }
2838
2839 static int reiserfs_set_page_dirty(struct page *page)
2840 {
2841         struct inode *inode = page->mapping->host;
2842         if (reiserfs_file_data_log(inode)) {
2843                 SetPageChecked(page);
2844                 return __set_page_dirty_nobuffers(page);
2845         }
2846         return __set_page_dirty_buffers(page);
2847 }
2848
2849 /*
2850  * Returns 1 if the page's buffers were dropped.  The page is locked.
2851  *
2852  * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads
2853  * in the buffers at page_buffers(page).
2854  *
2855  * even in -o notail mode, we can't be sure an old mount without -o notail
2856  * didn't create files with tails.
2857  */
2858 static int reiserfs_releasepage(struct page *page, gfp_t unused_gfp_flags)
2859 {
2860         struct inode *inode = page->mapping->host;
2861         struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
2862         struct buffer_head *head;
2863         struct buffer_head *bh;
2864         int ret = 1;
2865
2866         WARN_ON(PageChecked(page));
2867         spin_lock(&j->j_dirty_buffers_lock);
2868         head = page_buffers(page);
2869         bh = head;
2870         do {
2871                 if (bh->b_private) {
2872                         if (!buffer_dirty(bh) && !buffer_locked(bh)) {
2873                                 reiserfs_free_jh(bh);
2874                         } else {
2875                                 ret = 0;
2876                                 break;
2877                         }
2878                 }
2879                 bh = bh->b_this_page;
2880         } while (bh != head);
2881         if (ret)
2882                 ret = try_to_free_buffers(page);
2883         spin_unlock(&j->j_dirty_buffers_lock);
2884         return ret;
2885 }
2886
2887 /* We thank Mingming Cao for helping us understand in great detail what
2888    to do in this section of the code. */
2889 static ssize_t reiserfs_direct_IO(int rw, struct kiocb *iocb,
2890                                   const struct iovec *iov, loff_t offset,
2891                                   unsigned long nr_segs)
2892 {
2893         struct file *file = iocb->ki_filp;
2894         struct inode *inode = file->f_mapping->host;
2895
2896         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
2897                                   offset, nr_segs,
2898                                   reiserfs_get_blocks_direct_io, NULL);
2899 }
2900
2901 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
2902 {
2903         struct inode *inode = dentry->d_inode;
2904         int error;
2905         unsigned int ia_valid = attr->ia_valid;
2906         reiserfs_write_lock(inode->i_sb);
2907         if (attr->ia_valid & ATTR_SIZE) {
2908                 /* version 2 items will be caught by the s_maxbytes check
2909                  ** done for us in vmtruncate
2910                  */
2911                 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&
2912                     attr->ia_size > MAX_NON_LFS) {
2913                         error = -EFBIG;
2914                         goto out;
2915                 }
2916                 /* fill in hole pointers in the expanding truncate case. */
2917                 if (attr->ia_size > inode->i_size) {
2918                         error = generic_cont_expand(inode, attr->ia_size);
2919                         if (REISERFS_I(inode)->i_prealloc_count > 0) {
2920                                 int err;
2921                                 struct reiserfs_transaction_handle th;
2922                                 /* we're changing at most 2 bitmaps, inode + super */
2923                                 err = journal_begin(&th, inode->i_sb, 4);
2924                                 if (!err) {
2925                                         reiserfs_discard_prealloc(&th, inode);
2926                                         err = journal_end(&th, inode->i_sb, 4);
2927                                 }
2928                                 if (err)
2929                                         error = err;
2930                         }
2931                         if (error)
2932                                 goto out;
2933                         /*
2934                          * file size is changed, ctime and mtime are
2935                          * to be updated
2936                          */
2937                         attr->ia_valid |= (ATTR_MTIME | ATTR_CTIME);
2938                 }
2939         }
2940
2941         if ((((attr->ia_valid & ATTR_UID) && (attr->ia_uid & ~0xffff)) ||
2942              ((attr->ia_valid & ATTR_GID) && (attr->ia_gid & ~0xffff))) &&
2943             (get_inode_sd_version(inode) == STAT_DATA_V1)) {
2944                 /* stat data of format v3.5 has 16 bit uid and gid */
2945                 error = -EINVAL;
2946                 goto out;
2947         }
2948
2949         error = inode_change_ok(inode, attr);
2950         if (!error) {
2951                 if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
2952                     (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
2953                         error = reiserfs_chown_xattrs(inode, attr);
2954
2955                         if (!error) {
2956                                 struct reiserfs_transaction_handle th;
2957                                 int jbegin_count =
2958                                     2 *
2959                                     (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +
2960                                      REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +
2961                                     2;
2962
2963                                 /* (user+group)*(old+new) structure - we count quota info and , inode write (sb, inode) */
2964                                 error =
2965                                     journal_begin(&th, inode->i_sb,
2966                                                   jbegin_count);
2967                                 if (error)
2968                                         goto out;
2969                                 error =
2970                                     DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
2971                                 if (error) {
2972                                         journal_end(&th, inode->i_sb,
2973                                                     jbegin_count);
2974                                         goto out;
2975                                 }
2976                                 /* Update corresponding info in inode so that everything is in
2977                                  * one transaction */
2978                                 if (attr->ia_valid & ATTR_UID)
2979                                         inode->i_uid = attr->ia_uid;
2980                                 if (attr->ia_valid & ATTR_GID)
2981                                         inode->i_gid = attr->ia_gid;
2982                                 mark_inode_dirty(inode);
2983                                 error =
2984                                     journal_end(&th, inode->i_sb, jbegin_count);
2985                         }
2986                 }
2987                 if (!error)
2988                         error = inode_setattr(inode, attr);
2989         }
2990
2991         if (!error && reiserfs_posixacl(inode->i_sb)) {
2992                 if (attr->ia_valid & ATTR_MODE)
2993                         error = reiserfs_acl_chmod(inode);
2994         }
2995
2996       out:
2997         reiserfs_write_unlock(inode->i_sb);
2998         return error;
2999 }
3000
3001 const struct address_space_operations reiserfs_address_space_operations = {
3002         .writepage = reiserfs_writepage,
3003         .readpage = reiserfs_readpage,
3004         .readpages = reiserfs_readpages,
3005         .releasepage = reiserfs_releasepage,
3006         .invalidatepage = reiserfs_invalidatepage,
3007         .sync_page = block_sync_page,
3008         .prepare_write = reiserfs_prepare_write,
3009         .commit_write = reiserfs_commit_write,
3010         .bmap = reiserfs_aop_bmap,
3011         .direct_IO = reiserfs_direct_IO,
3012         .set_page_dirty = reiserfs_set_page_dirty,
3013 };