fs/reiserfs/stree.c

   1 /*
   2  *  Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3  */
   4
   5 /*
   6  *  Written by Anatoly P. Pinchuk pap@namesys.botik.ru
   7  *  Programm System Institute
   8  *  Pereslavl-Zalessky Russia
   9  */
  10
  11 /*
  12  *  This file contains functions dealing with S+tree
  13  *
  14  * B_IS_IN_TREE
  15  * copy_item_head
  16  * comp_short_keys
  17  * comp_keys
  18  * comp_short_le_keys
  19  * le_key2cpu_key
  20  * comp_le_keys
  21  * bin_search
  22  * get_lkey
  23  * get_rkey
  24  * key_in_buffer
  25  * decrement_bcount
  26  * decrement_counters_in_path
  27  * reiserfs_check_path
  28  * pathrelse_and_restore
  29  * pathrelse
  30  * search_by_key_reada
  31  * search_by_key
  32  * search_for_position_by_key
  33  * comp_items
  34  * prepare_for_direct_item
  35  * prepare_for_direntry_item
  36  * prepare_for_delete_or_cut
  37  * calc_deleted_bytes_number
  38  * init_tb_struct
  39  * padd_item
  40  * reiserfs_delete_item
  41  * reiserfs_delete_solid_item
  42  * reiserfs_delete_object
  43  * maybe_indirect_to_direct
  44  * indirect_to_direct_roll_back
  45  * reiserfs_cut_from_item
  46  * truncate_directory
  47  * reiserfs_do_truncate
  48  * reiserfs_paste_into_item
  49  * reiserfs_insert_item
  50  */
  51
  52 #include <linux/time.h>
  53 #include <linux/string.h>
  54 #include <linux/pagemap.h>
  55 #include <linux/reiserfs_fs.h>
  56 #include <linux/smp_lock.h>
  57 #include <linux/buffer_head.h>
  58 #include <linux/quotaops.h>
  59 #include <linux/vs_dlimit.h>
  60
  61 /* Does the buffer contain a disk block which is in the tree. */
  62 inline int B_IS_IN_TREE(const struct buffer_head *p_s_bh)
  63 {
  64
  65         RFALSE(B_LEVEL(p_s_bh) > MAX_HEIGHT,
  66                "PAP-1010: block (%b) has too big level (%z)", p_s_bh, p_s_bh);
  67
  68         return (B_LEVEL(p_s_bh) != FREE_LEVEL);
  69 }
  70
  71 //
  72 // to gets item head in le form
  73 //
  74 inline void copy_item_head(struct item_head *p_v_to,
  75                            const struct item_head *p_v_from)
  76 {
  77         memcpy(p_v_to, p_v_from, IH_SIZE);
  78 }
  79
  80 /* k1 is pointer to on-disk structure which is stored in little-endian
  81    form. k2 is pointer to cpu variable. For key of items of the same
  82    object this returns 0.
  83    Returns: -1 if key1 < key2
  84    0 if key1 == key2
  85    1 if key1 > key2 */
  86 inline int comp_short_keys(const struct reiserfs_key *le_key,
  87                            const struct cpu_key *cpu_key)
  88 {
  89         __u32 n;
  90         n = le32_to_cpu(le_key->k_dir_id);
  91         if (n < cpu_key->on_disk_key.k_dir_id)
  92                 return -1;
  93         if (n > cpu_key->on_disk_key.k_dir_id)
  94                 return 1;
  95         n = le32_to_cpu(le_key->k_objectid);
  96         if (n < cpu_key->on_disk_key.k_objectid)
  97                 return -1;
  98         if (n > cpu_key->on_disk_key.k_objectid)
  99                 return 1;
 100         return 0;
 101 }
 102
 103 /* k1 is pointer to on-disk structure which is stored in little-endian
 104    form. k2 is pointer to cpu variable.
 105    Compare keys using all 4 key fields.
 106    Returns: -1 if key1 < key2 0
 107    if key1 = key2 1 if key1 > key2 */
 108 static inline int comp_keys(const struct reiserfs_key *le_key,
 109                             const struct cpu_key *cpu_key)
 110 {
 111         int retval;
 112
 113         retval = comp_short_keys(le_key, cpu_key);
 114         if (retval)
 115                 return retval;
 116         if (le_key_k_offset(le_key_version(le_key), le_key) <
 117             cpu_key_k_offset(cpu_key))
 118                 return -1;
 119         if (le_key_k_offset(le_key_version(le_key), le_key) >
 120             cpu_key_k_offset(cpu_key))
 121                 return 1;
 122
 123         if (cpu_key->key_length == 3)
 124                 return 0;
 125
 126         /* this part is needed only when tail conversion is in progress */
 127         if (le_key_k_type(le_key_version(le_key), le_key) <
 128             cpu_key_k_type(cpu_key))
 129                 return -1;
 130
 131         if (le_key_k_type(le_key_version(le_key), le_key) >
 132             cpu_key_k_type(cpu_key))
 133                 return 1;
 134
 135         return 0;
 136 }
 137
 138 inline int comp_short_le_keys(const struct reiserfs_key *key1,
 139                               const struct reiserfs_key *key2)
 140 {
 141         __u32 *p_s_1_u32, *p_s_2_u32;
 142         int n_key_length = REISERFS_SHORT_KEY_LEN;
 143
 144         p_s_1_u32 = (__u32 *) key1;
 145         p_s_2_u32 = (__u32 *) key2;
 146         for (; n_key_length--; ++p_s_1_u32, ++p_s_2_u32) {
 147                 if (le32_to_cpu(*p_s_1_u32) < le32_to_cpu(*p_s_2_u32))
 148                         return -1;
 149                 if (le32_to_cpu(*p_s_1_u32) > le32_to_cpu(*p_s_2_u32))
 150                         return 1;
 151         }
 152         return 0;
 153 }
 154
 155 inline void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from)
 156 {
 157         int version;
 158         to->on_disk_key.k_dir_id = le32_to_cpu(from->k_dir_id);
 159         to->on_disk_key.k_objectid = le32_to_cpu(from->k_objectid);
 160
 161         // find out version of the key
 162         version = le_key_version(from);
 163         to->version = version;
 164         to->on_disk_key.k_offset = le_key_k_offset(version, from);
 165         to->on_disk_key.k_type = le_key_k_type(version, from);
 166 }
 167
 168 // this does not say which one is bigger, it only returns 1 if keys
 169 // are not equal, 0 otherwise
 170 inline int comp_le_keys(const struct reiserfs_key *k1,
 171                         const struct reiserfs_key *k2)
 172 {
 173         return memcmp(k1, k2, sizeof(struct reiserfs_key));
 174 }
 175
 176 /**************************************************************************
 177  *  Binary search toolkit function                                        *
 178  *  Search for an item in the array by the item key                       *
 179  *  Returns:    1 if found,  0 if not found;                              *
 180  *        *p_n_pos = number of the searched element if found, else the    *
 181  *        number of the first element that is larger than p_v_key.        *
 182  **************************************************************************/
 183 /* For those not familiar with binary search: n_lbound is the leftmost item that it
 184  could be, n_rbound the rightmost item that it could be.  We examine the item
 185  halfway between n_lbound and n_rbound, and that tells us either that we can increase
 186  n_lbound, or decrease n_rbound, or that we have found it, or if n_lbound <= n_rbound that
 187  there are no possible items, and we have not found it. With each examination we
 188  cut the number of possible items it could be by one more than half rounded down,
 189  or we find it. */
 190 static inline int bin_search(const void *p_v_key,       /* Key to search for.                   */
 191                              const void *p_v_base,      /* First item in the array.             */
 192                              int p_n_num,       /* Number of items in the array.        */
 193                              int p_n_width,     /* Item size in the array.
 194                                                    searched. Lest the reader be
 195                                                    confused, note that this is crafted
 196                                                    as a general function, and when it
 197                                                    is applied specifically to the array
 198                                                    of item headers in a node, p_n_width
 199                                                    is actually the item header size not
 200                                                    the item size.                      */
 201                              int *p_n_pos       /* Number of the searched for element. */
 202     )
 203 {
 204         int n_rbound, n_lbound, n_j;
 205
 206         for (n_j = ((n_rbound = p_n_num - 1) + (n_lbound = 0)) / 2;
 207              n_lbound <= n_rbound; n_j = (n_rbound + n_lbound) / 2)
 208                 switch (comp_keys
 209                         ((struct reiserfs_key *)((char *)p_v_base +
 210                                                  n_j * p_n_width),
 211                          (struct cpu_key *)p_v_key)) {
 212                 case -1:
 213                         n_lbound = n_j + 1;
 214                         continue;
 215                 case 1:
 216                         n_rbound = n_j - 1;
 217                         continue;
 218                 case 0:
 219                         *p_n_pos = n_j;
 220                         return ITEM_FOUND;      /* Key found in the array.  */
 221                 }
 222
 223         /* bin_search did not find given key, it returns position of key,
 224            that is minimal and greater than the given one. */
 225         *p_n_pos = n_lbound;
 226         return ITEM_NOT_FOUND;
 227 }
 228
 229 #ifdef CONFIG_REISERFS_CHECK
 230 extern struct tree_balance *cur_tb;
 231 #endif
 232
 233 /* Minimal possible key. It is never in the tree. */
 234 const struct reiserfs_key MIN_KEY = { 0, 0, {{0, 0},} };
 235
 236 /* Maximal possible key. It is never in the tree. */
 237 static const struct reiserfs_key MAX_KEY = {
 238         __constant_cpu_to_le32(0xffffffff),
 239         __constant_cpu_to_le32(0xffffffff),
 240         {{__constant_cpu_to_le32(0xffffffff),
 241           __constant_cpu_to_le32(0xffffffff)},}
 242 };
 243
 244 /* Get delimiting key of the buffer by looking for it in the buffers in the path, starting from the bottom
 245    of the path, and going upwards.  We must check the path's validity at each step.  If the key is not in
 246    the path, there is no delimiting key in the tree (buffer is first or last buffer in tree), and in this
 247    case we return a special key, either MIN_KEY or MAX_KEY. */
 248 static inline const struct reiserfs_key *get_lkey(const struct path
 249                                                   *p_s_chk_path,
 250                                                   const struct super_block
 251                                                   *p_s_sb)
 252 {
 253         int n_position, n_path_offset = p_s_chk_path->path_length;
 254         struct buffer_head *p_s_parent;
 255
 256         RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET,
 257                "PAP-5010: invalid offset in the path");
 258
 259         /* While not higher in path than first element. */
 260         while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
 261
 262                 RFALSE(!buffer_uptodate
 263                        (PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)),
 264                        "PAP-5020: parent is not uptodate");
 265
 266                 /* Parent at the path is not in the tree now. */
 267                 if (!B_IS_IN_TREE
 268                     (p_s_parent =
 269                      PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)))
 270                         return &MAX_KEY;
 271                 /* Check whether position in the parent is correct. */
 272                 if ((n_position =
 273                      PATH_OFFSET_POSITION(p_s_chk_path,
 274                                           n_path_offset)) >
 275                     B_NR_ITEMS(p_s_parent))
 276                         return &MAX_KEY;
 277                 /* Check whether parent at the path really points to the child. */
 278                 if (B_N_CHILD_NUM(p_s_parent, n_position) !=
 279                     PATH_OFFSET_PBUFFER(p_s_chk_path,
 280                                         n_path_offset + 1)->b_blocknr)
 281                         return &MAX_KEY;
 282                 /* Return delimiting key if position in the parent is not equal to zero. */
 283                 if (n_position)
 284                         return B_N_PDELIM_KEY(p_s_parent, n_position - 1);
 285         }
 286         /* Return MIN_KEY if we are in the root of the buffer tree. */
 287         if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
 288             b_blocknr == SB_ROOT_BLOCK(p_s_sb))
 289                 return &MIN_KEY;
 290         return &MAX_KEY;
 291 }
 292
 293 /* Get delimiting key of the buffer at the path and its right neighbor. */
 294 inline const struct reiserfs_key *get_rkey(const struct path *p_s_chk_path,
 295                                            const struct super_block *p_s_sb)
 296 {
 297         int n_position, n_path_offset = p_s_chk_path->path_length;
 298         struct buffer_head *p_s_parent;
 299
 300         RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET,
 301                "PAP-5030: invalid offset in the path");
 302
 303         while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
 304
 305                 RFALSE(!buffer_uptodate
 306                        (PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)),
 307                        "PAP-5040: parent is not uptodate");
 308
 309                 /* Parent at the path is not in the tree now. */
 310                 if (!B_IS_IN_TREE
 311                     (p_s_parent =
 312                      PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)))
 313                         return &MIN_KEY;
 314                 /* Check whether position in the parent is correct. */
 315                 if ((n_position =
 316                      PATH_OFFSET_POSITION(p_s_chk_path,
 317                                           n_path_offset)) >
 318                     B_NR_ITEMS(p_s_parent))
 319                         return &MIN_KEY;
 320                 /* Check whether parent at the path really points to the child. */
 321                 if (B_N_CHILD_NUM(p_s_parent, n_position) !=
 322                     PATH_OFFSET_PBUFFER(p_s_chk_path,
 323                                         n_path_offset + 1)->b_blocknr)
 324                         return &MIN_KEY;
 325                 /* Return delimiting key if position in the parent is not the last one. */
 326                 if (n_position != B_NR_ITEMS(p_s_parent))
 327                         return B_N_PDELIM_KEY(p_s_parent, n_position);
 328         }
 329         /* Return MAX_KEY if we are in the root of the buffer tree. */
 330         if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
 331             b_blocknr == SB_ROOT_BLOCK(p_s_sb))
 332                 return &MAX_KEY;
 333         return &MIN_KEY;
 334 }
 335
 336 /* Check whether a key is contained in the tree rooted from a buffer at a path. */
 337 /* This works by looking at the left and right delimiting keys for the buffer in the last path_element in
 338    the path.  These delimiting keys are stored at least one level above that buffer in the tree. If the
 339    buffer is the first or last node in the tree order then one of the delimiting keys may be absent, and in
 340    this case get_lkey and get_rkey return a special key which is MIN_KEY or MAX_KEY. */
 341 static inline int key_in_buffer(struct path *p_s_chk_path,      /* Path which should be checked.  */
 342                                 const struct cpu_key *p_s_key,  /* Key which should be checked.   */
 343                                 struct super_block *p_s_sb      /* Super block pointer.           */
 344     )
 345 {
 346
 347         RFALSE(!p_s_key || p_s_chk_path->path_length < FIRST_PATH_ELEMENT_OFFSET
 348                || p_s_chk_path->path_length > MAX_HEIGHT,
 349                "PAP-5050: pointer to the key(%p) is NULL or invalid path length(%d)",
 350                p_s_key, p_s_chk_path->path_length);
 351         RFALSE(!PATH_PLAST_BUFFER(p_s_chk_path)->b_bdev,
 352                "PAP-5060: device must not be NODEV");
 353
 354         if (comp_keys(get_lkey(p_s_chk_path, p_s_sb), p_s_key) == 1)
 355                 /* left delimiting key is bigger, that the key we look for */
 356                 return 0;
 357         //  if ( comp_keys(p_s_key, get_rkey(p_s_chk_path, p_s_sb)) != -1 )
 358         if (comp_keys(get_rkey(p_s_chk_path, p_s_sb), p_s_key) != 1)
 359                 /* p_s_key must be less than right delimitiing key */
 360                 return 0;
 361         return 1;
 362 }
 363
 364 inline void decrement_bcount(struct buffer_head *p_s_bh)
 365 {
 366         if (p_s_bh) {
 367                 if (atomic_read(&(p_s_bh->b_count))) {
 368                         put_bh(p_s_bh);
 369                         return;
 370                 }
 371                 reiserfs_panic(NULL,
 372                                "PAP-5070: decrement_bcount: trying to free free buffer %b",
 373                                p_s_bh);
 374         }
 375 }
 376
 377 /* Decrement b_count field of the all buffers in the path. */
 378 void decrement_counters_in_path(struct path *p_s_search_path)
 379 {
 380         int n_path_offset = p_s_search_path->path_length;
 381
 382         RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET ||
 383                n_path_offset > EXTENDED_MAX_HEIGHT - 1,
 384                "PAP-5080: invalid path offset of %d", n_path_offset);
 385
 386         while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
 387                 struct buffer_head *bh;
 388
 389                 bh = PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--);
 390                 decrement_bcount(bh);
 391         }
 392         p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 393 }
 394
 395 int reiserfs_check_path(struct path *p)
 396 {
 397         RFALSE(p->path_length != ILLEGAL_PATH_ELEMENT_OFFSET,
 398                "path not properly relsed");
 399         return 0;
 400 }
 401
 402 /* Release all buffers in the path. Restore dirty bits clean
 403 ** when preparing the buffer for the log
 404 **
 405 ** only called from fix_nodes()
 406 */
 407 void pathrelse_and_restore(struct super_block *s, struct path *p_s_search_path)
 408 {
 409         int n_path_offset = p_s_search_path->path_length;
 410
 411         RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
 412                "clm-4000: invalid path offset");
 413
 414         while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
 415                 reiserfs_restore_prepared_buffer(s,
 416                                                  PATH_OFFSET_PBUFFER
 417                                                  (p_s_search_path,
 418                                                   n_path_offset));
 419                 brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
 420         }
 421         p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 422 }
 423
 424 /* Release all buffers in the path. */
 425 void pathrelse(struct path *p_s_search_path)
 426 {
 427         int n_path_offset = p_s_search_path->path_length;
 428
 429         RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
 430                "PAP-5090: invalid path offset");
 431
 432         while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET)
 433                 brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
 434
 435         p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 436 }
 437
 438 static int is_leaf(char *buf, int blocksize, struct buffer_head *bh)
 439 {
 440         struct block_head *blkh;
 441         struct item_head *ih;
 442         int used_space;
 443         int prev_location;
 444         int i;
 445         int nr;
 446
 447         blkh = (struct block_head *)buf;
 448         if (blkh_level(blkh) != DISK_LEAF_NODE_LEVEL) {
 449                 reiserfs_warning(NULL,
 450                                  "is_leaf: this should be caught earlier");
 451                 return 0;
 452         }
 453
 454         nr = blkh_nr_item(blkh);
 455         if (nr < 1 || nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN))) {
 456                 /* item number is too big or too small */
 457                 reiserfs_warning(NULL, "is_leaf: nr_item seems wrong: %z", bh);
 458                 return 0;
 459         }
 460         ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
 461         used_space = BLKH_SIZE + IH_SIZE * nr + (blocksize - ih_location(ih));
 462         if (used_space != blocksize - blkh_free_space(blkh)) {
 463                 /* free space does not match to calculated amount of use space */
 464                 reiserfs_warning(NULL, "is_leaf: free space seems wrong: %z",
 465                                  bh);
 466                 return 0;
 467         }
 468         // FIXME: it is_leaf will hit performance too much - we may have
 469         // return 1 here
 470
 471         /* check tables of item heads */
 472         ih = (struct item_head *)(buf + BLKH_SIZE);
 473         prev_location = blocksize;
 474         for (i = 0; i < nr; i++, ih++) {
 475                 if (le_ih_k_type(ih) == TYPE_ANY) {
 476                         reiserfs_warning(NULL,
 477                                          "is_leaf: wrong item type for item %h",
 478                                          ih);
 479                         return 0;
 480                 }
 481                 if (ih_location(ih) >= blocksize
 482                     || ih_location(ih) < IH_SIZE * nr) {
 483                         reiserfs_warning(NULL,
 484                                          "is_leaf: item location seems wrong: %h",
 485                                          ih);
 486                         return 0;
 487                 }
 488                 if (ih_item_len(ih) < 1
 489                     || ih_item_len(ih) > MAX_ITEM_LEN(blocksize)) {
 490                         reiserfs_warning(NULL,
 491                                          "is_leaf: item length seems wrong: %h",
 492                                          ih);
 493                         return 0;
 494                 }
 495                 if (prev_location - ih_location(ih) != ih_item_len(ih)) {
 496                         reiserfs_warning(NULL,
 497                                          "is_leaf: item location seems wrong (second one): %h",
 498                                          ih);
 499                         return 0;
 500                 }
 501                 prev_location = ih_location(ih);
 502         }
 503
 504         // one may imagine much more checks
 505         return 1;
 506 }
 507
 508 /* returns 1 if buf looks like an internal node, 0 otherwise */
 509 static int is_internal(char *buf, int blocksize, struct buffer_head *bh)
 510 {
 511         struct block_head *blkh;
 512         int nr;
 513         int used_space;
 514
 515         blkh = (struct block_head *)buf;
 516         nr = blkh_level(blkh);
 517         if (nr <= DISK_LEAF_NODE_LEVEL || nr > MAX_HEIGHT) {
 518                 /* this level is not possible for internal nodes */
 519                 reiserfs_warning(NULL,
 520                                  "is_internal: this should be caught earlier");
 521                 return 0;
 522         }
 523
 524         nr = blkh_nr_item(blkh);
 525         if (nr > (blocksize - BLKH_SIZE - DC_SIZE) / (KEY_SIZE + DC_SIZE)) {
 526                 /* for internal which is not root we might check min number of keys */
 527                 reiserfs_warning(NULL,
 528                                  "is_internal: number of key seems wrong: %z",
 529                                  bh);
 530                 return 0;
 531         }
 532
 533         used_space = BLKH_SIZE + KEY_SIZE * nr + DC_SIZE * (nr + 1);
 534         if (used_space != blocksize - blkh_free_space(blkh)) {
 535                 reiserfs_warning(NULL,
 536                                  "is_internal: free space seems wrong: %z", bh);
 537                 return 0;
 538         }
 539         // one may imagine much more checks
 540         return 1;
 541 }
 542
 543 // make sure that bh contains formatted node of reiserfs tree of
 544 // 'level'-th level
 545 static int is_tree_node(struct buffer_head *bh, int level)
 546 {
 547         if (B_LEVEL(bh) != level) {
 548                 reiserfs_warning(NULL,
 549                                  "is_tree_node: node level %d does not match to the expected one %d",
 550                                  B_LEVEL(bh), level);
 551                 return 0;
 552         }
 553         if (level == DISK_LEAF_NODE_LEVEL)
 554                 return is_leaf(bh->b_data, bh->b_size, bh);
 555
 556         return is_internal(bh->b_data, bh->b_size, bh);
 557 }
 558
 559 #define SEARCH_BY_KEY_READA 16
 560
 561 /* The function is NOT SCHEDULE-SAFE! */
 562 static void search_by_key_reada(struct super_block *s,
 563                                 struct buffer_head **bh,
 564                                 unsigned long *b, int num)
 565 {
 566         int i, j;
 567
 568         for (i = 0; i < num; i++) {
 569                 bh[i] = sb_getblk(s, b[i]);
 570         }
 571         for (j = 0; j < i; j++) {
 572                 /*
 573                  * note, this needs attention if we are getting rid of the BKL
 574                  * you have to make sure the prepared bit isn't set on this buffer
 575                  */
 576                 if (!buffer_uptodate(bh[j]))
 577                         ll_rw_block(READA, 1, bh + j);
 578                 brelse(bh[j]);
 579         }
 580 }
 581
 582 /**************************************************************************
 583  * Algorithm   SearchByKey                                                *
 584  *             look for item in the Disk S+Tree by its key                *
 585  * Input:  p_s_sb   -  super block                                        *
 586  *         p_s_key  - pointer to the key to search                        *
 587  * Output: ITEM_FOUND, ITEM_NOT_FOUND or IO_ERROR                         *
 588  *         p_s_search_path - path from the root to the needed leaf        *
 589  **************************************************************************/
 590
 591 /* This function fills up the path from the root to the leaf as it
 592    descends the tree looking for the key.  It uses reiserfs_bread to
 593    try to find buffers in the cache given their block number.  If it
 594    does not find them in the cache it reads them from disk.  For each
 595    node search_by_key finds using reiserfs_bread it then uses
 596    bin_search to look through that node.  bin_search will find the
 597    position of the block_number of the next node if it is looking
 598    through an internal node.  If it is looking through a leaf node
 599    bin_search will find the position of the item which has key either
 600    equal to given key, or which is the maximal key less than the given
 601    key.  search_by_key returns a path that must be checked for the
 602    correctness of the top of the path but need not be checked for the
 603    correctness of the bottom of the path */
 604 /* The function is NOT SCHEDULE-SAFE! */
 605 int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key,    /* Key to search. */
 606                   struct path *p_s_search_path, /* This structure was
 607                                                    allocated and initialized
 608                                                    by the calling
 609                                                    function. It is filled up
 610                                                    by this function.  */
 611                   int n_stop_level      /* How far down the tree to search. To
 612                                            stop at leaf level - set to
 613                                            DISK_LEAF_NODE_LEVEL */
 614     )
 615 {
 616         int n_block_number;
 617         int expected_level;
 618         struct buffer_head *p_s_bh;
 619         struct path_element *p_s_last_element;
 620         int n_node_level, n_retval;
 621         int right_neighbor_of_leaf_node;
 622         int fs_gen;
 623         struct buffer_head *reada_bh[SEARCH_BY_KEY_READA];
 624         unsigned long reada_blocks[SEARCH_BY_KEY_READA];
 625         int reada_count = 0;
 626
 627 #ifdef CONFIG_REISERFS_CHECK
 628         int n_repeat_counter = 0;
 629 #endif
 630
 631         PROC_INFO_INC(p_s_sb, search_by_key);
 632
 633         /* As we add each node to a path we increase its count.  This means that
 634            we must be careful to release all nodes in a path before we either
 635            discard the path struct or re-use the path struct, as we do here. */
 636
 637         decrement_counters_in_path(p_s_search_path);
 638
 639         right_neighbor_of_leaf_node = 0;
 640
 641         /* With each iteration of this loop we search through the items in the
 642            current node, and calculate the next current node(next path element)
 643            for the next iteration of this loop.. */
 644         n_block_number = SB_ROOT_BLOCK(p_s_sb);
 645         expected_level = -1;
 646         while (1) {
 647
 648 #ifdef CONFIG_REISERFS_CHECK
 649                 if (!(++n_repeat_counter % 50000))
 650                         reiserfs_warning(p_s_sb, "PAP-5100: search_by_key: %s:"
 651                                          "there were %d iterations of while loop "
 652                                          "looking for key %K",
 653                                          current->comm, n_repeat_counter,
 654                                          p_s_key);
 655 #endif
 656
 657                 /* prep path to have another element added to it. */
 658                 p_s_last_element =
 659                     PATH_OFFSET_PELEMENT(p_s_search_path,
 660                                          ++p_s_search_path->path_length);
 661                 fs_gen = get_generation(p_s_sb);
 662
 663                 /* Read the next tree node, and set the last element in the path to
 664                    have a pointer to it. */
 665                 if ((p_s_bh = p_s_last_element->pe_buffer =
 666                      sb_getblk(p_s_sb, n_block_number))) {
 667                         if (!buffer_uptodate(p_s_bh) && reada_count > 1) {
 668                                 search_by_key_reada(p_s_sb, reada_bh,
 669                                                     reada_blocks, reada_count);
 670                         }
 671                         ll_rw_block(READ, 1, &p_s_bh);
 672                         wait_on_buffer(p_s_bh);
 673                         if (!buffer_uptodate(p_s_bh))
 674                                 goto io_error;
 675                 } else {
 676                       io_error:
 677                         p_s_search_path->path_length--;
 678                         pathrelse(p_s_search_path);
 679                         return IO_ERROR;
 680                 }
 681                 reada_count = 0;
 682                 if (expected_level == -1)
 683                         expected_level = SB_TREE_HEIGHT(p_s_sb);
 684                 expected_level--;
 685
 686                 /* It is possible that schedule occurred. We must check whether the key
 687                    to search is still in the tree rooted from the current buffer. If
 688                    not then repeat search from the root. */
 689                 if (fs_changed(fs_gen, p_s_sb) &&
 690                     (!B_IS_IN_TREE(p_s_bh) ||
 691                      B_LEVEL(p_s_bh) != expected_level ||
 692                      !key_in_buffer(p_s_search_path, p_s_key, p_s_sb))) {
 693                         PROC_INFO_INC(p_s_sb, search_by_key_fs_changed);
 694                         PROC_INFO_INC(p_s_sb, search_by_key_restarted);
 695                         PROC_INFO_INC(p_s_sb,
 696                                       sbk_restarted[expected_level - 1]);
 697                         decrement_counters_in_path(p_s_search_path);
 698
 699                         /* Get the root block number so that we can repeat the search
 700                            starting from the root. */
 701                         n_block_number = SB_ROOT_BLOCK(p_s_sb);
 702                         expected_level = -1;
 703                         right_neighbor_of_leaf_node = 0;
 704
 705                         /* repeat search from the root */
 706                         continue;
 707                 }
 708
 709                 /* only check that the key is in the buffer if p_s_key is not
 710                    equal to the MAX_KEY. Latter case is only possible in
 711                    "finish_unfinished()" processing during mount. */
 712                 RFALSE(comp_keys(&MAX_KEY, p_s_key) &&
 713                        !key_in_buffer(p_s_search_path, p_s_key, p_s_sb),
 714                        "PAP-5130: key is not in the buffer");
 715 #ifdef CONFIG_REISERFS_CHECK
 716                 if (cur_tb) {
 717                         print_cur_tb("5140");
 718                         reiserfs_panic(p_s_sb,
 719                                        "PAP-5140: search_by_key: schedule occurred in do_balance!");
 720                 }
 721 #endif
 722
 723                 // make sure, that the node contents look like a node of
 724                 // certain level
 725                 if (!is_tree_node(p_s_bh, expected_level)) {
 726                         reiserfs_warning(p_s_sb, "vs-5150: search_by_key: "
 727                                          "invalid format found in block %ld. Fsck?",
 728                                          p_s_bh->b_blocknr);
 729                         pathrelse(p_s_search_path);
 730                         return IO_ERROR;
 731                 }
 732
 733                 /* ok, we have acquired next formatted node in the tree */
 734                 n_node_level = B_LEVEL(p_s_bh);
 735
 736                 PROC_INFO_BH_STAT(p_s_sb, p_s_bh, n_node_level - 1);
 737
 738                 RFALSE(n_node_level < n_stop_level,
 739                        "vs-5152: tree level (%d) is less than stop level (%d)",
 740                        n_node_level, n_stop_level);
 741
 742                 n_retval = bin_search(p_s_key, B_N_PITEM_HEAD(p_s_bh, 0),
 743                                       B_NR_ITEMS(p_s_bh),
 744                                       (n_node_level ==
 745                                        DISK_LEAF_NODE_LEVEL) ? IH_SIZE :
 746                                       KEY_SIZE,
 747                                       &(p_s_last_element->pe_position));
 748                 if (n_node_level == n_stop_level) {
 749                         return n_retval;
 750                 }
 751
 752                 /* we are not in the stop level */
 753                 if (n_retval == ITEM_FOUND)
 754                         /* item has been found, so we choose the pointer which is to the right of the found one */
 755                         p_s_last_element->pe_position++;
 756
 757                 /* if item was not found we choose the position which is to
 758                    the left of the found item. This requires no code,
 759                    bin_search did it already. */
 760
 761                 /* So we have chosen a position in the current node which is
 762                    an internal node.  Now we calculate child block number by
 763                    position in the node. */
 764                 n_block_number =
 765                     B_N_CHILD_NUM(p_s_bh, p_s_last_element->pe_position);
 766
 767                 /* if we are going to read leaf nodes, try for read ahead as well */
 768                 if ((p_s_search_path->reada & PATH_READA) &&
 769                     n_node_level == DISK_LEAF_NODE_LEVEL + 1) {
 770                         int pos = p_s_last_element->pe_position;
 771                         int limit = B_NR_ITEMS(p_s_bh);
 772                         struct reiserfs_key *le_key;
 773
 774                         if (p_s_search_path->reada & PATH_READA_BACK)
 775                                 limit = 0;
 776                         while (reada_count < SEARCH_BY_KEY_READA) {
 777                                 if (pos == limit)
 778                                         break;
 779                                 reada_blocks[reada_count++] =
 780                                     B_N_CHILD_NUM(p_s_bh, pos);
 781                                 if (p_s_search_path->reada & PATH_READA_BACK)
 782                                         pos--;
 783                                 else
 784                                         pos++;
 785
 786                                 /*
 787                                  * check to make sure we're in the same object
 788                                  */
 789                                 le_key = B_N_PDELIM_KEY(p_s_bh, pos);
 790                                 if (le32_to_cpu(le_key->k_objectid) !=
 791                                     p_s_key->on_disk_key.k_objectid) {
 792                                         break;
 793                                 }
 794                         }
 795                 }
 796         }
 797 }
 798
 799 /* Form the path to an item and position in this item which contains
 800    file byte defined by p_s_key. If there is no such item
 801    corresponding to the key, we point the path to the item with
 802    maximal key less than p_s_key, and *p_n_pos_in_item is set to one
 803    past the last entry/byte in the item.  If searching for entry in a
 804    directory item, and it is not found, *p_n_pos_in_item is set to one
 805    entry more than the entry with maximal key which is less than the
 806    sought key.
 807
 808    Note that if there is no entry in this same node which is one more,
 809    then we point to an imaginary entry.  for direct items, the
 810    position is in units of bytes, for indirect items the position is
 811    in units of blocknr entries, for directory items the position is in
 812    units of directory entries.  */
 813
 814 /* The function is NOT SCHEDULE-SAFE! */
 815 int search_for_position_by_key(struct super_block *p_s_sb,      /* Pointer to the super block.          */
 816                                const struct cpu_key *p_cpu_key, /* Key to search (cpu variable)         */
 817                                struct path *p_s_search_path     /* Filled up by this function.          */
 818     )
 819 {
 820         struct item_head *p_le_ih;      /* pointer to on-disk structure */
 821         int n_blk_size;
 822         loff_t item_offset, offset;
 823         struct reiserfs_dir_entry de;
 824         int retval;
 825
 826         /* If searching for directory entry. */
 827         if (is_direntry_cpu_key(p_cpu_key))
 828                 return search_by_entry_key(p_s_sb, p_cpu_key, p_s_search_path,
 829                                            &de);
 830
 831         /* If not searching for directory entry. */
 832
 833         /* If item is found. */
 834         retval = search_item(p_s_sb, p_cpu_key, p_s_search_path);
 835         if (retval == IO_ERROR)
 836                 return retval;
 837         if (retval == ITEM_FOUND) {
 838
 839                 RFALSE(!ih_item_len
 840                        (B_N_PITEM_HEAD
 841                         (PATH_PLAST_BUFFER(p_s_search_path),
 842                          PATH_LAST_POSITION(p_s_search_path))),
 843                        "PAP-5165: item length equals zero");
 844
 845                 pos_in_item(p_s_search_path) = 0;
 846                 return POSITION_FOUND;
 847         }
 848
 849         RFALSE(!PATH_LAST_POSITION(p_s_search_path),
 850                "PAP-5170: position equals zero");
 851
 852         /* Item is not found. Set path to the previous item. */
 853         p_le_ih =
 854             B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path),
 855                            --PATH_LAST_POSITION(p_s_search_path));
 856         n_blk_size = p_s_sb->s_blocksize;
 857
 858         if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
 859                 return FILE_NOT_FOUND;
 860         }
 861         // FIXME: quite ugly this far
 862
 863         item_offset = le_ih_k_offset(p_le_ih);
 864         offset = cpu_key_k_offset(p_cpu_key);
 865
 866         /* Needed byte is contained in the item pointed to by the path. */
 867         if (item_offset <= offset &&
 868             item_offset + op_bytes_number(p_le_ih, n_blk_size) > offset) {
 869                 pos_in_item(p_s_search_path) = offset - item_offset;
 870                 if (is_indirect_le_ih(p_le_ih)) {
 871                         pos_in_item(p_s_search_path) /= n_blk_size;
 872                 }
 873                 return POSITION_FOUND;
 874         }
 875
 876         /* Needed byte is not contained in the item pointed to by the
 877            path. Set pos_in_item out of the item. */
 878         if (is_indirect_le_ih(p_le_ih))
 879                 pos_in_item(p_s_search_path) =
 880                     ih_item_len(p_le_ih) / UNFM_P_SIZE;
 881         else
 882                 pos_in_item(p_s_search_path) = ih_item_len(p_le_ih);
 883
 884         return POSITION_NOT_FOUND;
 885 }
 886
 887 /* Compare given item and item pointed to by the path. */
 888 int comp_items(const struct item_head *stored_ih, const struct path *p_s_path)
 889 {
 890         struct buffer_head *p_s_bh;
 891         struct item_head *ih;
 892
 893         /* Last buffer at the path is not in the tree. */
 894         if (!B_IS_IN_TREE(p_s_bh = PATH_PLAST_BUFFER(p_s_path)))
 895                 return 1;
 896
 897         /* Last path position is invalid. */
 898         if (PATH_LAST_POSITION(p_s_path) >= B_NR_ITEMS(p_s_bh))
 899                 return 1;
 900
 901         /* we need only to know, whether it is the same item */
 902         ih = get_ih(p_s_path);
 903         return memcmp(stored_ih, ih, IH_SIZE);
 904 }
 905
 906 /* unformatted nodes are not logged anymore, ever.  This is safe
 907 ** now
 908 */
 909 #define held_by_others(bh) (atomic_read(&(bh)->b_count) > 1)
 910
 911 // block can not be forgotten as it is in I/O or held by someone
 912 #define block_in_use(bh) (buffer_locked(bh) || (held_by_others(bh)))
 913
 914 // prepare for delete or cut of direct item
 915 static inline int prepare_for_direct_item(struct path *path,
 916                                           struct item_head *le_ih,
 917                                           struct inode *inode,
 918                                           loff_t new_file_length, int *cut_size)
 919 {
 920         loff_t round_len;
 921
 922         if (new_file_length == max_reiserfs_offset(inode)) {
 923                 /* item has to be deleted */
 924                 *cut_size = -(IH_SIZE + ih_item_len(le_ih));
 925                 return M_DELETE;
 926         }
 927         // new file gets truncated
 928         if (get_inode_item_key_version(inode) == KEY_FORMAT_3_6) {
 929                 //
 930                 round_len = ROUND_UP(new_file_length);
 931                 /* this was n_new_file_length < le_ih ... */
 932                 if (round_len < le_ih_k_offset(le_ih)) {
 933                         *cut_size = -(IH_SIZE + ih_item_len(le_ih));
 934                         return M_DELETE;        /* Delete this item. */
 935                 }
 936                 /* Calculate first position and size for cutting from item. */
 937                 pos_in_item(path) = round_len - (le_ih_k_offset(le_ih) - 1);
 938                 *cut_size = -(ih_item_len(le_ih) - pos_in_item(path));
 939
 940                 return M_CUT;   /* Cut from this item. */
 941         }
 942
 943         // old file: items may have any length
 944
 945         if (new_file_length < le_ih_k_offset(le_ih)) {
 946                 *cut_size = -(IH_SIZE + ih_item_len(le_ih));
 947                 return M_DELETE;        /* Delete this item. */
 948         }
 949         /* Calculate first position and size for cutting from item. */
 950         *cut_size = -(ih_item_len(le_ih) -
 951                       (pos_in_item(path) =
 952                        new_file_length + 1 - le_ih_k_offset(le_ih)));
 953         return M_CUT;           /* Cut from this item. */
 954 }
 955
 956 static inline int prepare_for_direntry_item(struct path *path,
 957                                             struct item_head *le_ih,
 958                                             struct inode *inode,
 959                                             loff_t new_file_length,
 960                                             int *cut_size)
 961 {
 962         if (le_ih_k_offset(le_ih) == DOT_OFFSET &&
 963             new_file_length == max_reiserfs_offset(inode)) {
 964                 RFALSE(ih_entry_count(le_ih) != 2,
 965                        "PAP-5220: incorrect empty directory item (%h)", le_ih);
 966                 *cut_size = -(IH_SIZE + ih_item_len(le_ih));
 967                 return M_DELETE;        /* Delete the directory item containing "." and ".." entry. */
 968         }
 969
 970         if (ih_entry_count(le_ih) == 1) {
 971                 /* Delete the directory item such as there is one record only
 972                    in this item */
 973                 *cut_size = -(IH_SIZE + ih_item_len(le_ih));
 974                 return M_DELETE;
 975         }
 976
 977         /* Cut one record from the directory item. */
 978         *cut_size =
 979             -(DEH_SIZE +
 980               entry_length(get_last_bh(path), le_ih, pos_in_item(path)));
 981         return M_CUT;
 982 }
 983
 984 #define JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD (2 * JOURNAL_PER_BALANCE_CNT + 1)
 985
 986 /*  If the path points to a directory or direct item, calculate mode and the size cut, for balance.
 987     If the path points to an indirect item, remove some number of its unformatted nodes.
 988     In case of file truncate calculate whether this item must be deleted/truncated or last
 989     unformatted node of this item will be converted to a direct item.
 990     This function returns a determination of what balance mode the calling function should employ. */
 991 static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, struct inode *inode, struct path *p_s_path, const struct cpu_key *p_s_item_key, int *p_n_removed, /* Number of unformatted nodes which were removed
 992                                                                                                                                                                                    from end of the file. */
 993                                       int *p_n_cut_size, unsigned long long n_new_file_length   /* MAX_KEY_OFFSET in case of delete. */
 994     )
 995 {
 996         struct super_block *p_s_sb = inode->i_sb;
 997         struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_path);
 998         struct buffer_head *p_s_bh = PATH_PLAST_BUFFER(p_s_path);
 999
1000         BUG_ON(!th->t_trans_id);
1001
1002         /* Stat_data item. */
1003         if (is_statdata_le_ih(p_le_ih)) {
1004
1005                 RFALSE(n_new_file_length != max_reiserfs_offset(inode),
1006                        "PAP-5210: mode must be M_DELETE");
1007
1008                 *p_n_cut_size = -(IH_SIZE + ih_item_len(p_le_ih));
1009                 return M_DELETE;
1010         }
1011
1012         /* Directory item. */
1013         if (is_direntry_le_ih(p_le_ih))
1014                 return prepare_for_direntry_item(p_s_path, p_le_ih, inode,
1015                                                  n_new_file_length,
1016                                                  p_n_cut_size);
1017
1018         /* Direct item. */
1019         if (is_direct_le_ih(p_le_ih))
1020                 return prepare_for_direct_item(p_s_path, p_le_ih, inode,
1021                                                n_new_file_length, p_n_cut_size);
1022
1023         /* Case of an indirect item. */
1024         {
1025             int blk_size = p_s_sb->s_blocksize;
1026             struct item_head s_ih;
1027             int need_re_search;
1028             int delete = 0;
1029             int result = M_CUT;
1030             int pos = 0;
1031
1032             if ( n_new_file_length == max_reiserfs_offset (inode) ) {
1033                 /* prepare_for_delete_or_cut() is called by
1034                  * reiserfs_delete_item() */
1035                 n_new_file_length = 0;
1036                 delete = 1;
1037             }
1038
1039             do {
1040                 need_re_search = 0;
1041                 *p_n_cut_size = 0;
1042                 p_s_bh = PATH_PLAST_BUFFER(p_s_path);
1043                 copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
1044                 pos = I_UNFM_NUM(&s_ih);
1045
1046                 while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) {
1047                     __u32 *unfm, block;
1048
1049                     /* Each unformatted block deletion may involve one additional
1050                      * bitmap block into the transaction, thereby the initial
1051                      * journal space reservation might not be enough. */
1052                     if (!delete && (*p_n_cut_size) != 0 &&
1053                         reiserfs_transaction_free_space(th) < JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
1054                         break;
1055                     }
1056
1057                     unfm = (__u32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1;
1058                     block = get_block_num(unfm, 0);
1059
1060                     if (block != 0) {
1061                         reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1);
1062                         put_block_num(unfm, 0, 0);
1063                         journal_mark_dirty (th, p_s_sb, p_s_bh);
1064                         reiserfs_free_block(th, inode, block, 1);
1065                     }
1066
1067                     cond_resched();
1068
1069                     if (item_moved (&s_ih, p_s_path))  {
1070                         need_re_search = 1;
1071                         break;
1072                     }
1073
1074                     pos --;
1075                     (*p_n_removed) ++;
1076                     (*p_n_cut_size) -= UNFM_P_SIZE;
1077
1078                     if (pos == 0) {
1079                         (*p_n_cut_size) -= IH_SIZE;
1080                         result = M_DELETE;
1081                         break;
1082                     }
1083                 }
1084                 /* a trick.  If the buffer has been logged, this will do nothing.  If
1085                 ** we've broken the loop without logging it, it will restore the
1086                 ** buffer */
1087                 reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh);
1088             } while (need_re_search &&
1089                      search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path) == POSITION_FOUND);
1090             pos_in_item(p_s_path) = pos * UNFM_P_SIZE;
1091
1092             if (*p_n_cut_size == 0) {
1093                 /* Nothing were cut. maybe convert last unformatted node to the
1094                  * direct item? */
1095                 result = M_CONVERT;
1096             }
1097             return result;
1098         }
1099 }
1100
1101 /* Calculate number of bytes which will be deleted or cut during balance */
1102 static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)
1103 {
1104         int n_del_size;
1105         struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_tb->tb_path);
1106
1107         if (is_statdata_le_ih(p_le_ih))
1108                 return 0;
1109
1110         n_del_size =
1111             (c_mode ==
1112              M_DELETE) ? ih_item_len(p_le_ih) : -p_s_tb->insert_size[0];
1113         if (is_direntry_le_ih(p_le_ih)) {
1114                 // return EMPTY_DIR_SIZE; /* We delete emty directoris only. */
1115                 // we can't use EMPTY_DIR_SIZE, as old format dirs have a different
1116                 // empty size.  ick. FIXME, is this right?
1117                 //
1118                 return n_del_size;
1119         }
1120
1121         if (is_indirect_le_ih(p_le_ih))
1122                 n_del_size = (n_del_size / UNFM_P_SIZE) * (PATH_PLAST_BUFFER(p_s_tb->tb_path)->b_size); // - get_ih_free_space (p_le_ih);
1123         return n_del_size;
1124 }
1125
1126 static void init_tb_struct(struct reiserfs_transaction_handle *th,
1127                            struct tree_balance *p_s_tb,
1128                            struct super_block *p_s_sb,
1129                            struct path *p_s_path, int n_size)
1130 {
1131
1132         BUG_ON(!th->t_trans_id);
1133
1134         memset(p_s_tb, '\0', sizeof(struct tree_balance));
1135         p_s_tb->transaction_handle = th;
1136         p_s_tb->tb_sb = p_s_sb;
1137         p_s_tb->tb_path = p_s_path;
1138         PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
1139         PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
1140         p_s_tb->insert_size[0] = n_size;
1141 }
1142
1143 void padd_item(char *item, int total_length, int length)
1144 {
1145         int i;
1146
1147         for (i = total_length; i > length;)
1148                 item[--i] = 0;
1149 }
1150
1151 #ifdef REISERQUOTA_DEBUG
1152 char key2type(struct reiserfs_key *ih)
1153 {
1154         if (is_direntry_le_key(2, ih))
1155                 return 'd';
1156         if (is_direct_le_key(2, ih))
1157                 return 'D';
1158         if (is_indirect_le_key(2, ih))
1159                 return 'i';
1160         if (is_statdata_le_key(2, ih))
1161                 return 's';
1162         return 'u';
1163 }
1164
1165 char head2type(struct item_head *ih)
1166 {
1167         if (is_direntry_le_ih(ih))
1168                 return 'd';
1169         if (is_direct_le_ih(ih))
1170                 return 'D';
1171         if (is_indirect_le_ih(ih))
1172                 return 'i';
1173         if (is_statdata_le_ih(ih))
1174                 return 's';
1175         return 'u';
1176 }
1177 #endif
1178
1179 /* Delete object item. */
1180 int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct path *p_s_path, /* Path to the deleted item. */
1181                          const struct cpu_key *p_s_item_key,    /* Key to search for the deleted item.  */
1182                          struct inode *p_s_inode,       /* inode is here just to update i_blocks and quotas */
1183                          struct buffer_head *p_s_un_bh)
1184 {                               /* NULL or unformatted node pointer.    */
1185         struct super_block *p_s_sb = p_s_inode->i_sb;
1186         struct tree_balance s_del_balance;
1187         struct item_head s_ih;
1188         struct item_head *q_ih;
1189         int quota_cut_bytes;
1190         int n_ret_value, n_del_size, n_removed;
1191
1192 #ifdef CONFIG_REISERFS_CHECK
1193         char c_mode;
1194         int n_iter = 0;
1195 #endif
1196
1197         BUG_ON(!th->t_trans_id);
1198
1199         init_tb_struct(th, &s_del_balance, p_s_sb, p_s_path,
1200                        0 /*size is unknown */ );
1201
1202         while (1) {
1203                 n_removed = 0;
1204
1205 #ifdef CONFIG_REISERFS_CHECK
1206                 n_iter++;
1207                 c_mode =
1208 #endif
1209                     prepare_for_delete_or_cut(th, p_s_inode, p_s_path,
1210                                               p_s_item_key, &n_removed,
1211                                               &n_del_size,
1212                                               max_reiserfs_offset(p_s_inode));
1213
1214                 RFALSE(c_mode != M_DELETE, "PAP-5320: mode must be M_DELETE");
1215
1216                 copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
1217                 s_del_balance.insert_size[0] = n_del_size;
1218
1219                 n_ret_value = fix_nodes(M_DELETE, &s_del_balance, NULL, NULL);
1220                 if (n_ret_value != REPEAT_SEARCH)
1221                         break;
1222
1223                 PROC_INFO_INC(p_s_sb, delete_item_restarted);
1224
1225                 // file system changed, repeat search
1226                 n_ret_value =
1227                     search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path);
1228                 if (n_ret_value == IO_ERROR)
1229                         break;
1230                 if (n_ret_value == FILE_NOT_FOUND) {
1231                         reiserfs_warning(p_s_sb,
1232                                          "vs-5340: reiserfs_delete_item: "
1233                                          "no items of the file %K found",
1234                                          p_s_item_key);
1235                         break;
1236                 }
1237         }                       /* while (1) */
1238
1239         if (n_ret_value != CARRY_ON) {
1240                 unfix_nodes(&s_del_balance);
1241                 return 0;
1242         }
1243         // reiserfs_delete_item returns item length when success
1244         n_ret_value = calc_deleted_bytes_number(&s_del_balance, M_DELETE);
1245         q_ih = get_ih(p_s_path);
1246         quota_cut_bytes = ih_item_len(q_ih);
1247
1248         /* hack so the quota code doesn't have to guess if the file
1249          ** has a tail.  On tail insert, we allocate quota for 1 unformatted node.
1250          ** We test the offset because the tail might have been
1251          ** split into multiple items, and we only want to decrement for
1252          ** the unfm node once
1253          */
1254         if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(q_ih)) {
1255                 if ((le_ih_k_offset(q_ih) & (p_s_sb->s_blocksize - 1)) == 1) {
1256                         quota_cut_bytes = p_s_sb->s_blocksize + UNFM_P_SIZE;
1257                 } else {
1258                         quota_cut_bytes = 0;
1259                 }
1260         }
1261
1262         if (p_s_un_bh) {
1263                 int off;
1264                 char *data;
1265
1266                 /* We are in direct2indirect conversion, so move tail contents
1267                    to the unformatted node */
1268                 /* note, we do the copy before preparing the buffer because we
1269                  ** don't care about the contents of the unformatted node yet.
1270                  ** the only thing we really care about is the direct item's data
1271                  ** is in the unformatted node.
1272                  **
1273                  ** Otherwise, we would have to call reiserfs_prepare_for_journal on
1274                  ** the unformatted node, which might schedule, meaning we'd have to
1275                  ** loop all the way back up to the start of the while loop.
1276                  **
1277                  ** The unformatted node must be dirtied later on.  We can't be
1278                  ** sure here if the entire tail has been deleted yet.
1279                  **
1280                  ** p_s_un_bh is from the page cache (all unformatted nodes are
1281                  ** from the page cache) and might be a highmem page.  So, we
1282                  ** can't use p_s_un_bh->b_data.
1283                  ** -clm
1284                  */
1285
1286                 data = kmap_atomic(p_s_un_bh->b_page, KM_USER0);
1287                 off = ((le_ih_k_offset(&s_ih) - 1) & (PAGE_CACHE_SIZE - 1));
1288                 memcpy(data + off,
1289                        B_I_PITEM(PATH_PLAST_BUFFER(p_s_path), &s_ih),
1290                        n_ret_value);
1291                 kunmap_atomic(data, KM_USER0);
1292         }
1293         /* Perform balancing after all resources have been collected at once. */
1294         do_balance(&s_del_balance, NULL, NULL, M_DELETE);
1295
1296 #ifdef REISERQUOTA_DEBUG
1297         reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE,
1298                        "reiserquota delete_item(): freeing %u, id=%u type=%c",
1299                        quota_cut_bytes, p_s_inode->i_uid, head2type(&s_ih));
1300 #endif
1301         DLIMIT_FREE_SPACE(p_s_inode, quota_cut_bytes);
1302         DQUOT_FREE_SPACE_NODIRTY(p_s_inode, quota_cut_bytes);
1303
1304         /* Return deleted body length */
1305         return n_ret_value;
1306 }
1307
1308 /* Summary Of Mechanisms For Handling Collisions Between Processes:
1309
1310  deletion of the body of the object is performed by iput(), with the
1311  result that if multiple processes are operating on a file, the
1312  deletion of the body of the file is deferred until the last process
1313  that has an open inode performs its iput().
1314
1315  writes and truncates are protected from collisions by use of
1316  semaphores.
1317
1318  creates, linking, and mknod are protected from collisions with other
1319  processes by making the reiserfs_add_entry() the last step in the
1320  creation, and then rolling back all changes if there was a collision.
1321  - Hans
1322 */
1323
1324 /* this deletes item which never gets split */
1325 void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
1326                                 struct inode *inode, struct reiserfs_key *key)
1327 {
1328         struct tree_balance tb;
1329         INITIALIZE_PATH(path);
1330         int item_len = 0;
1331         int tb_init = 0;
1332         struct cpu_key cpu_key;
1333         int retval;
1334         int quota_cut_bytes = 0;
1335
1336         BUG_ON(!th->t_trans_id);
1337
1338         le_key2cpu_key(&cpu_key, key);
1339
1340         while (1) {
1341                 retval = search_item(th->t_super, &cpu_key, &path);
1342                 if (retval == IO_ERROR) {
1343                         reiserfs_warning(th->t_super,
1344                                          "vs-5350: reiserfs_delete_solid_item: "
1345                                          "i/o failure occurred trying to delete %K",
1346                                          &cpu_key);
1347                         break;
1348                 }
1349                 if (retval != ITEM_FOUND) {
1350                         pathrelse(&path);
1351                         // No need for a warning, if there is just no free space to insert '..' item into the newly-created subdir
1352                         if (!
1353                             ((unsigned long long)
1354                              GET_HASH_VALUE(le_key_k_offset
1355                                             (le_key_version(key), key)) == 0
1356                              && (unsigned long long)
1357                              GET_GENERATION_NUMBER(le_key_k_offset
1358                                                    (le_key_version(key),
1359                                                     key)) == 1))
1360                                 reiserfs_warning(th->t_super,
1361                                                  "vs-5355: reiserfs_delete_solid_item: %k not found",
1362                                                  key);
1363                         break;
1364                 }
1365                 if (!tb_init) {
1366                         tb_init = 1;
1367                         item_len = ih_item_len(PATH_PITEM_HEAD(&path));
1368                         init_tb_struct(th, &tb, th->t_super, &path,
1369                                        -(IH_SIZE + item_len));
1370                 }
1371                 quota_cut_bytes = ih_item_len(PATH_PITEM_HEAD(&path));
1372
1373                 retval = fix_nodes(M_DELETE, &tb, NULL, NULL);
1374                 if (retval == REPEAT_SEARCH) {
1375                         PROC_INFO_INC(th->t_super, delete_solid_item_restarted);
1376                         continue;
1377                 }
1378
1379                 if (retval == CARRY_ON) {
1380                         do_balance(&tb, NULL, NULL, M_DELETE);
1381                         if (inode) {    /* Should we count quota for item? (we don't count quotas for save-links) */
1382 #ifdef REISERQUOTA_DEBUG
1383                                 reiserfs_debug(th->t_super, REISERFS_DEBUG_CODE,
1384                                                "reiserquota delete_solid_item(): freeing %u id=%u type=%c",
1385                                                quota_cut_bytes, inode->i_uid,
1386                                                key2type(key));
1387 #endif
1388                                 DLIMIT_FREE_SPACE(inode, quota_cut_bytes);
1389                                 DQUOT_FREE_SPACE_NODIRTY(inode,
1390                                                          quota_cut_bytes);
1391                         }
1392                         break;
1393                 }
1394                 // IO_ERROR, NO_DISK_SPACE, etc
1395                 reiserfs_warning(th->t_super,
1396                                  "vs-5360: reiserfs_delete_solid_item: "
1397                                  "could not delete %K due to fix_nodes failure",
1398                                  &cpu_key);
1399                 unfix_nodes(&tb);
1400                 break;
1401         }
1402
1403         reiserfs_check_path(&path);
1404 }
1405
1406 int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
1407                            struct inode *inode)
1408 {
1409         int err;
1410         inode->i_size = 0;
1411         BUG_ON(!th->t_trans_id);
1412
1413         /* for directory this deletes item containing "." and ".." */
1414         err =
1415             reiserfs_do_truncate(th, inode, NULL, 0 /*no timestamp updates */ );
1416         if (err)
1417                 return err;
1418
1419 #if defined( USE_INODE_GENERATION_COUNTER )
1420         if (!old_format_only(th->t_super)) {
1421                 __le32 *inode_generation;
1422
1423                 inode_generation =
1424                     &REISERFS_SB(th->t_super)->s_rs->s_inode_generation;
1425                 *inode_generation =
1426                     cpu_to_le32(le32_to_cpu(*inode_generation) + 1);
1427         }
1428 /* USE_INODE_GENERATION_COUNTER */
1429 #endif
1430         reiserfs_delete_solid_item(th, inode, INODE_PKEY(inode));
1431
1432         return err;
1433 }
1434
1435 static void unmap_buffers(struct page *page, loff_t pos)
1436 {
1437         struct buffer_head *bh;
1438         struct buffer_head *head;
1439         struct buffer_head *next;
1440         unsigned long tail_index;
1441         unsigned long cur_index;
1442
1443         if (page) {
1444                 if (page_has_buffers(page)) {
1445                         tail_index = pos & (PAGE_CACHE_SIZE - 1);
1446                         cur_index = 0;
1447                         head = page_buffers(page);
1448                         bh = head;
1449                         do {
1450                                 next = bh->b_this_page;
1451
1452                                 /* we want to unmap the buffers that contain the tail, and
1453                                  ** all the buffers after it (since the tail must be at the
1454                                  ** end of the file).  We don't want to unmap file data
1455                                  ** before the tail, since it might be dirty and waiting to
1456                                  ** reach disk
1457                                  */
1458                                 cur_index += bh->b_size;
1459                                 if (cur_index > tail_index) {
1460                                         reiserfs_unmap_buffer(bh);
1461                                 }
1462                                 bh = next;
1463                         } while (bh != head);
1464                         if (PAGE_SIZE == bh->b_size) {
1465                                 clear_page_dirty(page);
1466                         }
1467                 }
1468         }
1469 }
1470
1471 static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
1472                                     struct inode *p_s_inode,
1473                                     struct page *page,
1474                                     struct path *p_s_path,
1475                                     const struct cpu_key *p_s_item_key,
1476                                     loff_t n_new_file_size, char *p_c_mode)
1477 {
1478         struct super_block *p_s_sb = p_s_inode->i_sb;
1479         int n_block_size = p_s_sb->s_blocksize;
1480         int cut_bytes;
1481         BUG_ON(!th->t_trans_id);
1482
1483         if (n_new_file_size != p_s_inode->i_size)
1484                 BUG();
1485
1486         /* the page being sent in could be NULL if there was an i/o error
1487          ** reading in the last block.  The user will hit problems trying to
1488          ** read the file, but for now we just skip the indirect2direct
1489          */
1490         if (atomic_read(&p_s_inode->i_count) > 1 ||
1491             !tail_has_to_be_packed(p_s_inode) ||
1492             !page || (REISERFS_I(p_s_inode)->i_flags & i_nopack_mask)) {
1493                 // leave tail in an unformatted node
1494                 *p_c_mode = M_SKIP_BALANCING;
1495                 cut_bytes =
1496                     n_block_size - (n_new_file_size & (n_block_size - 1));
1497                 pathrelse(p_s_path);
1498                 return cut_bytes;
1499         }
1500         /* Permorm the conversion to a direct_item. */
1501         /*return indirect_to_direct (p_s_inode, p_s_path, p_s_item_key, n_new_file_size, p_c_mode); */
1502         return indirect2direct(th, p_s_inode, page, p_s_path, p_s_item_key,
1503                                n_new_file_size, p_c_mode);
1504 }
1505
1506 /* we did indirect_to_direct conversion. And we have inserted direct
1507    item successesfully, but there were no disk space to cut unfm
1508    pointer being converted. Therefore we have to delete inserted
1509    direct item(s) */
1510 static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
1511                                          struct inode *inode, struct path *path)
1512 {
1513         struct cpu_key tail_key;
1514         int tail_len;
1515         int removed;
1516         BUG_ON(!th->t_trans_id);
1517
1518         make_cpu_key(&tail_key, inode, inode->i_size + 1, TYPE_DIRECT, 4);      // !!!!
1519         tail_key.key_length = 4;
1520
1521         tail_len =
1522             (cpu_key_k_offset(&tail_key) & (inode->i_sb->s_blocksize - 1)) - 1;
1523         while (tail_len) {
1524                 /* look for the last byte of the tail */
1525                 if (search_for_position_by_key(inode->i_sb, &tail_key, path) ==
1526                     POSITION_NOT_FOUND)
1527                         reiserfs_panic(inode->i_sb,
1528                                        "vs-5615: indirect_to_direct_roll_back: found invalid item");
1529                 RFALSE(path->pos_in_item !=
1530                        ih_item_len(PATH_PITEM_HEAD(path)) - 1,
1531                        "vs-5616: appended bytes found");
1532                 PATH_LAST_POSITION(path)--;
1533
1534                 removed =
1535                     reiserfs_delete_item(th, path, &tail_key, inode,
1536                                          NULL /*unbh not needed */ );
1537                 RFALSE(removed <= 0
1538                        || removed > tail_len,
1539                        "vs-5617: there was tail %d bytes, removed item length %d bytes",
1540                        tail_len, removed);
1541                 tail_len -= removed;
1542                 set_cpu_key_k_offset(&tail_key,
1543                                      cpu_key_k_offset(&tail_key) - removed);
1544         }
1545         reiserfs_warning(inode->i_sb,
1546                          "indirect_to_direct_roll_back: indirect_to_direct conversion has been rolled back due to lack of disk space");
1547         //mark_file_without_tail (inode);
1548         mark_inode_dirty(inode);
1549 }
1550
1551 /* (Truncate or cut entry) or delete object item. Returns < 0 on failure */
1552 int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
1553                            struct path *p_s_path,
1554                            struct cpu_key *p_s_item_key,
1555                            struct inode *p_s_inode,
1556                            struct page *page, loff_t n_new_file_size)
1557 {
1558         struct super_block *p_s_sb = p_s_inode->i_sb;
1559         /* Every function which is going to call do_balance must first
1560            create a tree_balance structure.  Then it must fill up this
1561            structure by using the init_tb_struct and fix_nodes functions.
1562            After that we can make tree balancing. */
1563         struct tree_balance s_cut_balance;
1564         struct item_head *p_le_ih;
1565         int n_cut_size = 0,     /* Amount to be cut. */
1566             n_ret_value = CARRY_ON, n_removed = 0,      /* Number of the removed unformatted nodes. */
1567             n_is_inode_locked = 0;
1568         char c_mode;            /* Mode of the balance. */
1569         int retval2 = -1;
1570         int quota_cut_bytes;
1571         loff_t tail_pos = 0;
1572
1573         BUG_ON(!th->t_trans_id);
1574
1575         init_tb_struct(th, &s_cut_balance, p_s_inode->i_sb, p_s_path,
1576                        n_cut_size);
1577
1578         /* Repeat this loop until we either cut the item without needing
1579            to balance, or we fix_nodes without schedule occurring */
1580         while (1) {
1581                 /* Determine the balance mode, position of the first byte to
1582                    be cut, and size to be cut.  In case of the indirect item
1583                    free unformatted nodes which are pointed to by the cut
1584                    pointers. */
1585
1586                 c_mode =
1587                     prepare_for_delete_or_cut(th, p_s_inode, p_s_path,
1588                                               p_s_item_key, &n_removed,
1589                                               &n_cut_size, n_new_file_size);
1590                 if (c_mode == M_CONVERT) {
1591                         /* convert last unformatted node to direct item or leave
1592                            tail in the unformatted node */
1593                         RFALSE(n_ret_value != CARRY_ON,
1594                                "PAP-5570: can not convert twice");
1595
1596                         n_ret_value =
1597                             maybe_indirect_to_direct(th, p_s_inode, page,
1598                                                      p_s_path, p_s_item_key,
1599                                                      n_new_file_size, &c_mode);
1600                         if (c_mode == M_SKIP_BALANCING)
1601                                 /* tail has been left in the unformatted node */
1602                                 return n_ret_value;
1603
1604                         n_is_inode_locked = 1;
1605
1606                         /* removing of last unformatted node will change value we
1607                            have to return to truncate. Save it */
1608                         retval2 = n_ret_value;
1609                         /*retval2 = p_s_sb->s_blocksize - (n_new_file_size & (p_s_sb->s_blocksize - 1)); */
1610
1611                         /* So, we have performed the first part of the conversion:
1612                            inserting the new direct item.  Now we are removing the
1613                            last unformatted node pointer. Set key to search for
1614                            it. */
1615                         set_cpu_key_k_type(p_s_item_key, TYPE_INDIRECT);
1616                         p_s_item_key->key_length = 4;
1617                         n_new_file_size -=
1618                             (n_new_file_size & (p_s_sb->s_blocksize - 1));
1619                         tail_pos = n_new_file_size;
1620                         set_cpu_key_k_offset(p_s_item_key, n_new_file_size + 1);
1621                         if (search_for_position_by_key
1622                             (p_s_sb, p_s_item_key,
1623                              p_s_path) == POSITION_NOT_FOUND) {
1624                                 print_block(PATH_PLAST_BUFFER(p_s_path), 3,
1625                                             PATH_LAST_POSITION(p_s_path) - 1,
1626                                             PATH_LAST_POSITION(p_s_path) + 1);
1627                                 reiserfs_panic(p_s_sb,
1628                                                "PAP-5580: reiserfs_cut_from_item: item to convert does not exist (%K)",
1629                                                p_s_item_key);
1630                         }
1631                         continue;
1632                 }
1633                 if (n_cut_size == 0) {
1634                         pathrelse(p_s_path);
1635                         return 0;
1636                 }
1637
1638                 s_cut_balance.insert_size[0] = n_cut_size;
1639
1640                 n_ret_value = fix_nodes(c_mode, &s_cut_balance, NULL, NULL);
1641                 if (n_ret_value != REPEAT_SEARCH)
1642                         break;
1643
1644                 PROC_INFO_INC(p_s_sb, cut_from_item_restarted);
1645
1646                 n_ret_value =
1647                     search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path);
1648                 if (n_ret_value == POSITION_FOUND)
1649                         continue;
1650
1651                 reiserfs_warning(p_s_sb,
1652                                  "PAP-5610: reiserfs_cut_from_item: item %K not found",
1653                                  p_s_item_key);
1654                 unfix_nodes(&s_cut_balance);
1655                 return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT;
1656         }                       /* while */
1657
1658         // check fix_nodes results (IO_ERROR or NO_DISK_SPACE)
1659         if (n_ret_value != CARRY_ON) {
1660                 if (n_is_inode_locked) {
1661                         // FIXME: this seems to be not needed: we are always able
1662                         // to cut item
1663                         indirect_to_direct_roll_back(th, p_s_inode, p_s_path);
1664                 }
1665                 if (n_ret_value == NO_DISK_SPACE)
1666                         reiserfs_warning(p_s_sb, "NO_DISK_SPACE");
1667                 unfix_nodes(&s_cut_balance);
1668                 return -EIO;
1669         }
1670
1671         /* go ahead and perform balancing */
1672
1673         RFALSE(c_mode == M_PASTE || c_mode == M_INSERT, "invalid mode");
1674
1675         /* Calculate number of bytes that need to be cut from the item. */
1676         quota_cut_bytes =
1677             (c_mode ==
1678              M_DELETE) ? ih_item_len(get_ih(p_s_path)) : -s_cut_balance.
1679             insert_size[0];
1680         if (retval2 == -1)
1681                 n_ret_value = calc_deleted_bytes_number(&s_cut_balance, c_mode);
1682         else
1683                 n_ret_value = retval2;
1684
1685         /* For direct items, we only change the quota when deleting the last
1686          ** item.
1687          */
1688         p_le_ih = PATH_PITEM_HEAD(s_cut_balance.tb_path);
1689         if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(p_le_ih)) {
1690                 if (c_mode == M_DELETE &&
1691                     (le_ih_k_offset(p_le_ih) & (p_s_sb->s_blocksize - 1)) ==
1692                     1) {
1693                         // FIXME: this is to keep 3.5 happy
1694                         REISERFS_I(p_s_inode)->i_first_direct_byte = U32_MAX;
1695                         quota_cut_bytes = p_s_sb->s_blocksize + UNFM_P_SIZE;
1696                 } else {
1697                         quota_cut_bytes = 0;
1698                 }
1699         }
1700 #ifdef CONFIG_REISERFS_CHECK
1701         if (n_is_inode_locked) {
1702                 struct item_head *le_ih =
1703                     PATH_PITEM_HEAD(s_cut_balance.tb_path);
1704                 /* we are going to complete indirect2direct conversion. Make
1705                    sure, that we exactly remove last unformatted node pointer
1706                    of the item */
1707                 if (!is_indirect_le_ih(le_ih))
1708                         reiserfs_panic(p_s_sb,
1709                                        "vs-5652: reiserfs_cut_from_item: "
1710                                        "item must be indirect %h", le_ih);
1711
1712                 if (c_mode == M_DELETE && ih_item_len(le_ih) != UNFM_P_SIZE)
1713                         reiserfs_panic(p_s_sb,
1714                                        "vs-5653: reiserfs_cut_from_item: "
1715                                        "completing indirect2direct conversion indirect item %h "
1716                                        "being deleted must be of 4 byte long",
1717                                        le_ih);
1718
1719                 if (c_mode == M_CUT
1720                     && s_cut_balance.insert_size[0] != -UNFM_P_SIZE) {
1721                         reiserfs_panic(p_s_sb,
1722                                        "vs-5654: reiserfs_cut_from_item: "
1723                                        "can not complete indirect2direct conversion of %h (CUT, insert_size==%d)",
1724                                        le_ih, s_cut_balance.insert_size[0]);
1725                 }
1726                 /* it would be useful to make sure, that right neighboring
1727                    item is direct item of this file */
1728         }
1729 #endif
1730
1731         do_balance(&s_cut_balance, NULL, NULL, c_mode);
1732         if (n_is_inode_locked) {
1733                 /* we've done an indirect->direct conversion.  when the data block
1734                  ** was freed, it was removed from the list of blocks that must
1735                  ** be flushed before the transaction commits, make sure to
1736                  ** unmap and invalidate it
1737                  */
1738                 unmap_buffers(page, tail_pos);
1739                 REISERFS_I(p_s_inode)->i_flags &= ~i_pack_on_close_mask;
1740         }
1741 #ifdef REISERQUOTA_DEBUG
1742         reiserfs_debug(p_s_inode->i_sb, REISERFS_DEBUG_CODE,
1743                        "reiserquota cut_from_item(): freeing %u id=%u type=%c",
1744                        quota_cut_bytes, p_s_inode->i_uid, '?');
1745 #endif
1746         DLIMIT_FREE_SPACE(p_s_inode, quota_cut_bytes);
1747         DQUOT_FREE_SPACE_NODIRTY(p_s_inode, quota_cut_bytes);
1748         return n_ret_value;
1749 }
1750
1751 static void truncate_directory(struct reiserfs_transaction_handle *th,
1752                                struct inode *inode)
1753 {
1754         BUG_ON(!th->t_trans_id);
1755         if (inode->i_nlink)
1756                 reiserfs_warning(inode->i_sb,
1757                                  "vs-5655: truncate_directory: link count != 0");
1758
1759         set_le_key_k_offset(KEY_FORMAT_3_5, INODE_PKEY(inode), DOT_OFFSET);
1760         set_le_key_k_type(KEY_FORMAT_3_5, INODE_PKEY(inode), TYPE_DIRENTRY);
1761         reiserfs_delete_solid_item(th, inode, INODE_PKEY(inode));
1762         reiserfs_update_sd(th, inode);
1763         set_le_key_k_offset(KEY_FORMAT_3_5, INODE_PKEY(inode), SD_OFFSET);
1764         set_le_key_k_type(KEY_FORMAT_3_5, INODE_PKEY(inode), TYPE_STAT_DATA);
1765 }
1766
1767 /* Truncate file to the new size. Note, this must be called with a transaction
1768    already started */
1769 int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p_s_inode,       /* ->i_size contains new
1770                                                                                                    size */
1771                          struct page *page,     /* up to date for last block */
1772                          int update_timestamps  /* when it is called by
1773                                                    file_release to convert
1774                                                    the tail - no timestamps
1775                                                    should be updated */
1776     )
1777 {
1778         INITIALIZE_PATH(s_search_path); /* Path to the current object item. */
1779         struct item_head *p_le_ih;      /* Pointer to an item header. */
1780         struct cpu_key s_item_key;      /* Key to search for a previous file item. */
1781         loff_t n_file_size,     /* Old file size. */
1782          n_new_file_size;       /* New file size. */
1783         int n_deleted;          /* Number of deleted or truncated bytes. */
1784         int retval;
1785         int err = 0;
1786
1787         BUG_ON(!th->t_trans_id);
1788         if (!
1789             (S_ISREG(p_s_inode->i_mode) || S_ISDIR(p_s_inode->i_mode)
1790              || S_ISLNK(p_s_inode->i_mode)))
1791                 return 0;
1792
1793         if (S_ISDIR(p_s_inode->i_mode)) {
1794                 // deletion of directory - no need to update timestamps
1795                 truncate_directory(th, p_s_inode);
1796                 return 0;
1797         }
1798
1799         /* Get new file size. */
1800         n_new_file_size = p_s_inode->i_size;
1801
1802         // FIXME: note, that key type is unimportant here
1803         make_cpu_key(&s_item_key, p_s_inode, max_reiserfs_offset(p_s_inode),
1804                      TYPE_DIRECT, 3);
1805
1806         retval =
1807             search_for_position_by_key(p_s_inode->i_sb, &s_item_key,
1808                                        &s_search_path);
1809         if (retval == IO_ERROR) {
1810                 reiserfs_warning(p_s_inode->i_sb,
1811                                  "vs-5657: reiserfs_do_truncate: "
1812                                  "i/o failure occurred trying to truncate %K",
1813                                  &s_item_key);
1814                 err = -EIO;
1815                 goto out;
1816         }
1817         if (retval == POSITION_FOUND || retval == FILE_NOT_FOUND) {
1818                 reiserfs_warning(p_s_inode->i_sb,
1819                                  "PAP-5660: reiserfs_do_truncate: "
1820                                  "wrong result %d of search for %K", retval,
1821                                  &s_item_key);
1822
1823                 err = -EIO;
1824                 goto out;
1825         }
1826
1827         s_search_path.pos_in_item--;
1828
1829         /* Get real file size (total length of all file items) */
1830         p_le_ih = PATH_PITEM_HEAD(&s_search_path);
1831         if (is_statdata_le_ih(p_le_ih))
1832                 n_file_size = 0;
1833         else {
1834                 loff_t offset = le_ih_k_offset(p_le_ih);
1835                 int bytes =
1836                     op_bytes_number(p_le_ih, p_s_inode->i_sb->s_blocksize);
1837
1838                 /* this may mismatch with real file size: if last direct item
1839                    had no padding zeros and last unformatted node had no free
1840                    space, this file would have this file size */
1841                 n_file_size = offset + bytes - 1;
1842         }
1843         /*
1844          * are we doing a full truncate or delete, if so
1845          * kick in the reada code
1846          */
1847         if (n_new_file_size == 0)
1848                 s_search_path.reada = PATH_READA | PATH_READA_BACK;
1849
1850         if (n_file_size == 0 || n_file_size < n_new_file_size) {
1851                 goto update_and_out;
1852         }
1853
1854         /* Update key to search for the last file item. */
1855         set_cpu_key_k_offset(&s_item_key, n_file_size);
1856
1857         do {
1858                 /* Cut or delete file item. */
1859                 n_deleted =
1860                     reiserfs_cut_from_item(th, &s_search_path, &s_item_key,
1861                                            p_s_inode, page, n_new_file_size);
1862                 if (n_deleted < 0) {
1863                         reiserfs_warning(p_s_inode->i_sb,
1864                                          "vs-5665: reiserfs_do_truncate: reiserfs_cut_from_item failed");
1865                         reiserfs_check_path(&s_search_path);
1866                         return 0;
1867                 }
1868
1869                 RFALSE(n_deleted > n_file_size,
1870                        "PAP-5670: reiserfs_cut_from_item: too many bytes deleted: deleted %d, file_size %lu, item_key %K",
1871                        n_deleted, n_file_size, &s_item_key);
1872
1873                 /* Change key to search the last file item. */
1874                 n_file_size -= n_deleted;
1875
1876                 set_cpu_key_k_offset(&s_item_key, n_file_size);
1877
1878                 /* While there are bytes to truncate and previous file item is presented in the tree. */
1879
1880                 /*
1881                  ** This loop could take a really long time, and could log
1882                  ** many more blocks than a transaction can hold.  So, we do a polite
1883                  ** journal end here, and if the transaction needs ending, we make
1884                  ** sure the file is consistent before ending the current trans
1885                  ** and starting a new one
1886                  */
1887                 if (journal_transaction_should_end(th, 0) ||
1888                     reiserfs_transaction_free_space(th) <= JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
1889                         int orig_len_alloc = th->t_blocks_allocated;
1890                         decrement_counters_in_path(&s_search_path);
1891
1892                         if (update_timestamps) {
1893                                 p_s_inode->i_mtime = p_s_inode->i_ctime =
1894                                     CURRENT_TIME_SEC;
1895                         }
1896                         reiserfs_update_sd(th, p_s_inode);
1897
1898                         err = journal_end(th, p_s_inode->i_sb, orig_len_alloc);
1899                         if (err)
1900                                 goto out;
1901                         err = journal_begin(th, p_s_inode->i_sb,
1902                                             JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD + JOURNAL_PER_BALANCE_CNT * 4) ;
1903                         if (err)
1904                                 goto out;
1905                         reiserfs_update_inode_transaction(p_s_inode);
1906                 }
1907         } while (n_file_size > ROUND_UP(n_new_file_size) &&
1908                  search_for_position_by_key(p_s_inode->i_sb, &s_item_key,
1909                                             &s_search_path) == POSITION_FOUND);
1910
1911         RFALSE(n_file_size > ROUND_UP(n_new_file_size),
1912                "PAP-5680: truncate did not finish: new_file_size %Ld, current %Ld, oid %d",
1913                n_new_file_size, n_file_size, s_item_key.on_disk_key.k_objectid);
1914
1915       update_and_out:
1916         if (update_timestamps) {
1917                 // this is truncate, not file closing
1918                 p_s_inode->i_mtime = p_s_inode->i_ctime = CURRENT_TIME_SEC;
1919         }
1920         reiserfs_update_sd(th, p_s_inode);
1921
1922       out:
1923         pathrelse(&s_search_path);
1924         return err;
1925 }
1926
1927 #ifdef CONFIG_REISERFS_CHECK
1928 // this makes sure, that we __append__, not overwrite or add holes
1929 static void check_research_for_paste(struct path *path,
1930                                      const struct cpu_key *p_s_key)
1931 {
1932         struct item_head *found_ih = get_ih(path);
1933
1934         if (is_direct_le_ih(found_ih)) {
1935                 if (le_ih_k_offset(found_ih) +
1936                     op_bytes_number(found_ih,
1937                                     get_last_bh(path)->b_size) !=
1938                     cpu_key_k_offset(p_s_key)
1939                     || op_bytes_number(found_ih,
1940                                        get_last_bh(path)->b_size) !=
1941                     pos_in_item(path))
1942                         reiserfs_panic(NULL,
1943                                        "PAP-5720: check_research_for_paste: "
1944                                        "found direct item %h or position (%d) does not match to key %K",
1945                                        found_ih, pos_in_item(path), p_s_key);
1946         }
1947         if (is_indirect_le_ih(found_ih)) {
1948                 if (le_ih_k_offset(found_ih) +
1949                     op_bytes_number(found_ih,
1950                                     get_last_bh(path)->b_size) !=
1951                     cpu_key_k_offset(p_s_key)
1952                     || I_UNFM_NUM(found_ih) != pos_in_item(path)
1953                     || get_ih_free_space(found_ih) != 0)
1954                         reiserfs_panic(NULL,
1955                                        "PAP-5730: check_research_for_paste: "
1956                                        "found indirect item (%h) or position (%d) does not match to key (%K)",
1957                                        found_ih, pos_in_item(path), p_s_key);
1958         }
1959 }
1960 #endif                          /* config reiserfs check */
1961
1962 /* Paste bytes to the existing item. Returns bytes number pasted into the item. */
1963 int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct path *p_s_search_path,      /* Path to the pasted item.          */
1964                              const struct cpu_key *p_s_key,     /* Key to search for the needed item. */
1965                              struct inode *inode,       /* Inode item belongs to */
1966                              const char *p_c_body,      /* Pointer to the bytes to paste.    */
1967                              int n_pasted_size)
1968 {                               /* Size of pasted bytes.             */
1969         struct tree_balance s_paste_balance;
1970         int retval;
1971         int fs_gen;
1972
1973         BUG_ON(!th->t_trans_id);
1974
1975         fs_gen = get_generation(inode->i_sb);
1976
1977 #ifdef REISERQUOTA_DEBUG
1978         reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
1979                        "reiserquota paste_into_item(): allocating %u id=%u type=%c",
1980                        n_pasted_size, inode->i_uid,
1981                        key2type(&(p_s_key->on_disk_key)));
1982 #endif
1983
1984         if (DQUOT_ALLOC_SPACE_NODIRTY(inode, n_pasted_size)) {
1985                 pathrelse(p_s_search_path);
1986                 return -EDQUOT;
1987         }
1988         if (DLIMIT_ALLOC_SPACE(inode, n_pasted_size)) {
1989                 DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size);
1990                 pathrelse(p_s_search_path);
1991                 return -ENOSPC;
1992         }
1993         init_tb_struct(th, &s_paste_balance, th->t_super, p_s_search_path,
1994                        n_pasted_size);
1995 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1996         s_paste_balance.key = p_s_key->on_disk_key;
1997 #endif
1998
1999         /* DQUOT_* can schedule, must check before the fix_nodes */
2000         if (fs_changed(fs_gen, inode->i_sb)) {
2001                 goto search_again;
2002         }
2003
2004         while ((retval =
2005                 fix_nodes(M_PASTE, &s_paste_balance, NULL,
2006                           p_c_body)) == REPEAT_SEARCH) {
2007               search_again:
2008                 /* file system changed while we were in the fix_nodes */
2009                 PROC_INFO_INC(th->t_super, paste_into_item_restarted);
2010                 retval =
2011                     search_for_position_by_key(th->t_super, p_s_key,
2012                                                p_s_search_path);
2013                 if (retval == IO_ERROR) {
2014                         retval = -EIO;
2015                         goto error_out;
2016                 }
2017                 if (retval == POSITION_FOUND) {
2018                         reiserfs_warning(inode->i_sb,
2019                                          "PAP-5710: reiserfs_paste_into_item: entry or pasted byte (%K) exists",
2020                                          p_s_key);
2021                         retval = -EEXIST;
2022                         goto error_out;
2023                 }
2024 #ifdef CONFIG_REISERFS_CHECK
2025                 check_research_for_paste(p_s_search_path, p_s_key);
2026 #endif
2027         }
2028
2029         /* Perform balancing after all resources are collected by fix_nodes, and
2030            accessing them will not risk triggering schedule. */
2031         if (retval == CARRY_ON) {
2032                 do_balance(&s_paste_balance, NULL /*ih */ , p_c_body, M_PASTE);
2033                 return 0;
2034         }
2035         retval = (retval == NO_DISK_SPACE) ? -ENOSPC : -EIO;
2036       error_out:
2037         /* this also releases the path */
2038         unfix_nodes(&s_paste_balance);
2039 #ifdef REISERQUOTA_DEBUG
2040         reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
2041                        "reiserquota paste_into_item(): freeing %u id=%u type=%c",
2042                        n_pasted_size, inode->i_uid,
2043                        key2type(&(p_s_key->on_disk_key)));
2044 #endif
2045         DLIMIT_FREE_SPACE(inode, n_pasted_size);
2046         DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size);
2047         return retval;
2048 }
2049
2050 /* Insert new item into the buffer at the path. */
2051 int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct path *p_s_path, /* Path to the inserteded item.         */
2052                          const struct cpu_key *key, struct item_head *p_s_ih,   /* Pointer to the item header to insert. */
2053                          struct inode *inode, const char *p_c_body)
2054 {                               /* Pointer to the bytes to insert.      */
2055         struct tree_balance s_ins_balance;
2056         int retval;
2057         int fs_gen = 0;
2058         int quota_bytes = 0;
2059
2060         BUG_ON(!th->t_trans_id);
2061
2062         if (inode) {            /* Do we count quotas for item? */
2063                 fs_gen = get_generation(inode->i_sb);
2064                 quota_bytes = ih_item_len(p_s_ih);
2065
2066                 /* hack so the quota code doesn't have to guess if the file has
2067                  ** a tail, links are always tails, so there's no guessing needed
2068                  */
2069                 if (!S_ISLNK(inode->i_mode) && is_direct_le_ih(p_s_ih)) {
2070                         quota_bytes = inode->i_sb->s_blocksize + UNFM_P_SIZE;
2071                 }
2072 #ifdef REISERQUOTA_DEBUG
2073                 reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE,
2074                                "reiserquota insert_item(): allocating %u id=%u type=%c",
2075                                quota_bytes, inode->i_uid, head2type(p_s_ih));
2076 #endif
2077                 /* We can't dirty inode here. It would be immediately written but
2078                  * appropriate stat item isn't inserted yet... */
2079                 if (DQUOT_ALLOC_SPACE_NODIRTY(inode, quota_bytes)) {
2080                         pathrelse(p_s_path);
2081                         return -EDQUOT;
2082                 }
2083                 if (DLIMIT_ALLOC_SPACE(inode, quota_bytes)) {
2084                         DQUOT_FREE_SPACE_NODIRTY(inode, quota_bytes);
2085                         pathrelse(p_s_path);
2086                         return -ENOSPC;
2087                 }
2088         }
2089         init_tb_struct(th, &s_ins_balance, th->t_super, p_s_path,
2090                        IH_SIZE + ih_item_len(p_s_ih));
2091 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
2092         s_ins_balance.key = key->on_disk_key;
2093 #endif
2094         /* DQUOT_* can schedule, must check to be sure calling fix_nodes is safe */
2095         if (inode && fs_changed(fs_gen, inode->i_sb)) {
2096                 goto search_again;
2097         }
2098
2099         while ((retval =
2100                 fix_nodes(M_INSERT, &s_ins_balance, p_s_ih,
2101                           p_c_body)) == REPEAT_SEARCH) {
2102               search_again:
2103                 /* file system changed while we were in the fix_nodes */
2104                 PROC_INFO_INC(th->t_super, insert_item_restarted);
2105                 retval = search_item(th->t_super, key, p_s_path);
2106                 if (retval == IO_ERROR) {
2107                         retval = -EIO;
2108                         goto error_out;
2109                 }
2110                 if (retval == ITEM_FOUND) {
2111                         reiserfs_warning(th->t_super,
2112                                          "PAP-5760: reiserfs_insert_item: "
2113                                          "key %K already exists in the tree",
2114                                          key);
2115                         retval = -EEXIST;
2116                         goto error_out;
2117                 }
2118         }
2119
2120         /* make balancing after all resources will be collected at a time */
2121         if (retval == CARRY_ON) {
2122                 do_balance(&s_ins_balance, p_s_ih, p_c_body, M_INSERT);
2123                 return 0;
2124         }
2125
2126         retval = (retval == NO_DISK_SPACE) ? -ENOSPC : -EIO;
2127       error_out:
2128         /* also releases the path */
2129         unfix_nodes(&s_ins_balance);
2130 #ifdef REISERQUOTA_DEBUG
2131         reiserfs_debug(th->t_super, REISERFS_DEBUG_CODE,
2132                        "reiserquota insert_item(): freeing %u id=%u type=%c",
2133                        quota_bytes, inode->i_uid, head2type(p_s_ih));
2134 #endif
2135         if (inode) {
2136                 DLIMIT_FREE_SPACE(inode, quota_bytes);
2137                 DQUOT_FREE_SPACE_NODIRTY(inode, quota_bytes);
2138         }
2139         return retval;
2140 }