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