2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
6 * Written by Anatoly P. Pinchuk pap@namesys.botik.ru
7 * Programm System Institute
8 * Pereslavl-Zalessky Russia
12 * This file contains functions dealing with S+tree
26 * decrement_counters_in_path
28 * pathrelse_and_restore
32 * search_for_position_by_key
34 * prepare_for_direct_item
35 * prepare_for_direntry_item
36 * prepare_for_delete_or_cut
37 * calc_deleted_bytes_number
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
47 * reiserfs_do_truncate
48 * reiserfs_paste_into_item
49 * reiserfs_insert_item
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>
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)
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);
68 return (B_LEVEL(p_s_bh) != FREE_LEVEL);
72 // to gets item head in le form
74 inline void copy_item_head(struct item_head *p_v_to,
75 const struct item_head *p_v_from)
77 memcpy(p_v_to, p_v_from, IH_SIZE);
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
86 inline int comp_short_keys(const struct reiserfs_key *le_key,
87 const struct cpu_key *cpu_key)
90 n = le32_to_cpu(le_key->k_dir_id);
91 if (n < cpu_key->on_disk_key.k_dir_id)
93 if (n > cpu_key->on_disk_key.k_dir_id)
95 n = le32_to_cpu(le_key->k_objectid);
96 if (n < cpu_key->on_disk_key.k_objectid)
98 if (n > cpu_key->on_disk_key.k_objectid)
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)
113 retval = comp_short_keys(le_key, cpu_key);
116 if (le_key_k_offset(le_key_version(le_key), le_key) <
117 cpu_key_k_offset(cpu_key))
119 if (le_key_k_offset(le_key_version(le_key), le_key) >
120 cpu_key_k_offset(cpu_key))
123 if (cpu_key->key_length == 3)
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))
131 if (le_key_k_type(le_key_version(le_key), le_key) >
132 cpu_key_k_type(cpu_key))
138 inline int comp_short_le_keys(const struct reiserfs_key *key1,
139 const struct reiserfs_key *key2)
141 __u32 *p_s_1_u32, *p_s_2_u32;
142 int n_key_length = REISERFS_SHORT_KEY_LEN;
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))
149 if (le32_to_cpu(*p_s_1_u32) > le32_to_cpu(*p_s_2_u32))
155 inline void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from)
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);
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);
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)
173 return memcmp(k1, k2, sizeof(struct reiserfs_key));
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,
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
201 int *p_n_pos /* Number of the searched for element. */
204 int n_rbound, n_lbound, n_j;
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)
209 ((struct reiserfs_key *)((char *)p_v_base +
211 (struct cpu_key *)p_v_key)) {
220 return ITEM_FOUND; /* Key found in the array. */
223 /* bin_search did not find given key, it returns position of key,
224 that is minimal and greater than the given one. */
226 return ITEM_NOT_FOUND;
229 #ifdef CONFIG_REISERFS_CHECK
230 extern struct tree_balance *cur_tb;
233 /* Minimal possible key. It is never in the tree. */
234 const struct reiserfs_key MIN_KEY = { 0, 0, {{0, 0},} };
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)},}
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
250 const struct super_block
253 int n_position, n_path_offset = p_s_chk_path->path_length;
254 struct buffer_head *p_s_parent;
256 RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET,
257 "PAP-5010: invalid offset in the path");
259 /* While not higher in path than first element. */
260 while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
262 RFALSE(!buffer_uptodate
263 (PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)),
264 "PAP-5020: parent is not uptodate");
266 /* Parent at the path is not in the tree now. */
269 PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)))
271 /* Check whether position in the parent is correct. */
273 PATH_OFFSET_POSITION(p_s_chk_path,
275 B_NR_ITEMS(p_s_parent))
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)
282 /* Return delimiting key if position in the parent is not equal to zero. */
284 return B_N_PDELIM_KEY(p_s_parent, n_position - 1);
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))
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)
297 int n_position, n_path_offset = p_s_chk_path->path_length;
298 struct buffer_head *p_s_parent;
300 RFALSE(n_path_offset < FIRST_PATH_ELEMENT_OFFSET,
301 "PAP-5030: invalid offset in the path");
303 while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
305 RFALSE(!buffer_uptodate
306 (PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)),
307 "PAP-5040: parent is not uptodate");
309 /* Parent at the path is not in the tree now. */
312 PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)))
314 /* Check whether position in the parent is correct. */
316 PATH_OFFSET_POSITION(p_s_chk_path,
318 B_NR_ITEMS(p_s_parent))
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)
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);
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))
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. */
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");
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 */
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 */
364 inline void decrement_bcount(struct buffer_head *p_s_bh)
367 if (atomic_read(&(p_s_bh->b_count))) {
372 "PAP-5070: decrement_bcount: trying to free free buffer %b",
377 /* Decrement b_count field of the all buffers in the path. */
378 void decrement_counters_in_path(struct path *p_s_search_path)
380 int n_path_offset = p_s_search_path->path_length;
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);
386 while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
387 struct buffer_head *bh;
389 bh = PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--);
390 decrement_bcount(bh);
392 p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
395 int reiserfs_check_path(struct path *p)
397 RFALSE(p->path_length != ILLEGAL_PATH_ELEMENT_OFFSET,
398 "path not properly relsed");
402 /* Release all buffers in the path. Restore dirty bits clean
403 ** when preparing the buffer for the log
405 ** only called from fix_nodes()
407 void pathrelse_and_restore(struct super_block *s, struct path *p_s_search_path)
409 int n_path_offset = p_s_search_path->path_length;
411 RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
412 "clm-4000: invalid path offset");
414 while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
415 reiserfs_restore_prepared_buffer(s,
419 brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
421 p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
424 /* Release all buffers in the path. */
425 void pathrelse(struct path *p_s_search_path)
427 int n_path_offset = p_s_search_path->path_length;
429 RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET,
430 "PAP-5090: invalid path offset");
432 while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET)
433 brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
435 p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
438 static int is_leaf(char *buf, int blocksize, struct buffer_head *bh)
440 struct block_head *blkh;
441 struct item_head *ih;
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");
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);
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",
468 // FIXME: it is_leaf will hit performance too much - we may have
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",
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",
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",
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",
501 prev_location = ih_location(ih);
504 // one may imagine much more checks
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)
511 struct block_head *blkh;
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");
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",
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);
539 // one may imagine much more checks
543 // make sure that bh contains formatted node of reiserfs tree of
545 static int is_tree_node(struct buffer_head *bh, int level)
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",
553 if (level == DISK_LEAF_NODE_LEVEL)
554 return is_leaf(bh->b_data, bh->b_size, bh);
556 return is_internal(bh->b_data, bh->b_size, bh);
559 #define SEARCH_BY_KEY_READA 16
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)
568 for (i = 0; i < num; i++) {
569 bh[i] = sb_getblk(s, b[i]);
571 for (j = 0; j < i; j++) {
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
576 if (!buffer_uptodate(bh[j]))
577 ll_rw_block(READA, 1, bh + j);
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 **************************************************************************/
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
609 function. It is filled up
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 */
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;
623 struct buffer_head *reada_bh[SEARCH_BY_KEY_READA];
624 unsigned long reada_blocks[SEARCH_BY_KEY_READA];
627 #ifdef CONFIG_REISERFS_CHECK
628 int n_repeat_counter = 0;
631 PROC_INFO_INC(p_s_sb, search_by_key);
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. */
637 decrement_counters_in_path(p_s_search_path);
639 right_neighbor_of_leaf_node = 0;
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);
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,
657 /* prep path to have another element added to it. */
659 PATH_OFFSET_PELEMENT(p_s_search_path,
660 ++p_s_search_path->path_length);
661 fs_gen = get_generation(p_s_sb);
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);
671 ll_rw_block(READ, 1, &p_s_bh);
672 wait_on_buffer(p_s_bh);
673 if (!buffer_uptodate(p_s_bh))
677 p_s_search_path->path_length--;
678 pathrelse(p_s_search_path);
682 if (expected_level == -1)
683 expected_level = SB_TREE_HEIGHT(p_s_sb);
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);
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);
703 right_neighbor_of_leaf_node = 0;
705 /* repeat search from the root */
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
717 print_cur_tb("5140");
718 reiserfs_panic(p_s_sb,
719 "PAP-5140: search_by_key: schedule occurred in do_balance!");
723 // make sure, that the node contents look like a node of
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?",
729 pathrelse(p_s_search_path);
733 /* ok, we have acquired next formatted node in the tree */
734 n_node_level = B_LEVEL(p_s_bh);
736 PROC_INFO_BH_STAT(p_s_sb, p_s_bh, n_node_level - 1);
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);
742 n_retval = bin_search(p_s_key, B_N_PITEM_HEAD(p_s_bh, 0),
745 DISK_LEAF_NODE_LEVEL) ? IH_SIZE :
747 &(p_s_last_element->pe_position));
748 if (n_node_level == n_stop_level) {
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++;
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. */
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. */
765 B_N_CHILD_NUM(p_s_bh, p_s_last_element->pe_position);
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;
774 if (p_s_search_path->reada & PATH_READA_BACK)
776 while (reada_count < SEARCH_BY_KEY_READA) {
779 reada_blocks[reada_count++] =
780 B_N_CHILD_NUM(p_s_bh, pos);
781 if (p_s_search_path->reada & PATH_READA_BACK)
787 * check to make sure we're in the same object
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) {
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
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. */
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. */
820 struct item_head *p_le_ih; /* pointer to on-disk structure */
822 loff_t item_offset, offset;
823 struct reiserfs_dir_entry de;
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,
831 /* If not searching for directory entry. */
833 /* If item is found. */
834 retval = search_item(p_s_sb, p_cpu_key, p_s_search_path);
835 if (retval == IO_ERROR)
837 if (retval == ITEM_FOUND) {
841 (PATH_PLAST_BUFFER(p_s_search_path),
842 PATH_LAST_POSITION(p_s_search_path))),
843 "PAP-5165: item length equals zero");
845 pos_in_item(p_s_search_path) = 0;
846 return POSITION_FOUND;
849 RFALSE(!PATH_LAST_POSITION(p_s_search_path),
850 "PAP-5170: position equals zero");
852 /* Item is not found. Set path to the previous item. */
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;
858 if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
859 return FILE_NOT_FOUND;
861 // FIXME: quite ugly this far
863 item_offset = le_ih_k_offset(p_le_ih);
864 offset = cpu_key_k_offset(p_cpu_key);
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;
873 return POSITION_FOUND;
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;
882 pos_in_item(p_s_search_path) = ih_item_len(p_le_ih);
884 return POSITION_NOT_FOUND;
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)
890 struct buffer_head *p_s_bh;
891 struct item_head *ih;
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)))
897 /* Last path position is invalid. */
898 if (PATH_LAST_POSITION(p_s_path) >= B_NR_ITEMS(p_s_bh))
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);
906 /* unformatted nodes are not logged anymore, ever. This is safe
909 #define held_by_others(bh) (atomic_read(&(bh)->b_count) > 1)
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)))
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,
918 loff_t new_file_length, int *cut_size)
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));
927 // new file gets truncated
928 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_6) {
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. */
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));
940 return M_CUT; /* Cut from this item. */
943 // old file: items may have any length
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. */
949 /* Calculate first position and size for cutting from item. */
950 *cut_size = -(ih_item_len(le_ih) -
952 new_file_length + 1 - le_ih_k_offset(le_ih)));
953 return M_CUT; /* Cut from this item. */
956 static inline int prepare_for_direntry_item(struct path *path,
957 struct item_head *le_ih,
959 loff_t new_file_length,
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. */
970 if (ih_entry_count(le_ih) == 1) {
971 /* Delete the directory item such as there is one record only
973 *cut_size = -(IH_SIZE + ih_item_len(le_ih));
977 /* Cut one record from the directory item. */
980 entry_length(get_last_bh(path), le_ih, pos_in_item(path)));
984 #define JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD (2 * JOURNAL_PER_BALANCE_CNT + 1)
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. */
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);
1000 BUG_ON(!th->t_trans_id);
1002 /* Stat_data item. */
1003 if (is_statdata_le_ih(p_le_ih)) {
1005 RFALSE(n_new_file_length != max_reiserfs_offset(inode),
1006 "PAP-5210: mode must be M_DELETE");
1008 *p_n_cut_size = -(IH_SIZE + ih_item_len(p_le_ih));
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,
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);
1023 /* Case of an indirect item. */
1025 int blk_size = p_s_sb->s_blocksize;
1026 struct item_head s_ih;
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;
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);
1046 while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > n_new_file_length) {
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) {
1057 unfm = (__u32 *)B_I_PITEM(p_s_bh, &s_ih) + pos - 1;
1058 block = get_block_num(unfm, 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);
1069 if (item_moved (&s_ih, p_s_path)) {
1076 (*p_n_cut_size) -= UNFM_P_SIZE;
1079 (*p_n_cut_size) -= IH_SIZE;
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
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;
1092 if (*p_n_cut_size == 0) {
1093 /* Nothing were cut. maybe convert last unformatted node to the
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)
1105 struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_tb->tb_path);
1107 if (is_statdata_le_ih(p_le_ih))
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?
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);
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)
1132 BUG_ON(!th->t_trans_id);
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;
1143 void padd_item(char *item, int total_length, int length)
1147 for (i = total_length; i > length;)
1151 #ifdef REISERQUOTA_DEBUG
1152 char key2type(struct reiserfs_key *ih)
1154 if (is_direntry_le_key(2, ih))
1156 if (is_direct_le_key(2, ih))
1158 if (is_indirect_le_key(2, ih))
1160 if (is_statdata_le_key(2, ih))
1165 char head2type(struct item_head *ih)
1167 if (is_direntry_le_ih(ih))
1169 if (is_direct_le_ih(ih))
1171 if (is_indirect_le_ih(ih))
1173 if (is_statdata_le_ih(ih))
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;
1192 #ifdef CONFIG_REISERFS_CHECK
1197 BUG_ON(!th->t_trans_id);
1199 init_tb_struct(th, &s_del_balance, p_s_sb, p_s_path,
1200 0 /*size is unknown */ );
1205 #ifdef CONFIG_REISERFS_CHECK
1209 prepare_for_delete_or_cut(th, p_s_inode, p_s_path,
1210 p_s_item_key, &n_removed,
1212 max_reiserfs_offset(p_s_inode));
1214 RFALSE(c_mode != M_DELETE, "PAP-5320: mode must be M_DELETE");
1216 copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
1217 s_del_balance.insert_size[0] = n_del_size;
1219 n_ret_value = fix_nodes(M_DELETE, &s_del_balance, NULL, NULL);
1220 if (n_ret_value != REPEAT_SEARCH)
1223 PROC_INFO_INC(p_s_sb, delete_item_restarted);
1225 // file system changed, repeat search
1227 search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path);
1228 if (n_ret_value == IO_ERROR)
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",
1239 if (n_ret_value != CARRY_ON) {
1240 unfix_nodes(&s_del_balance);
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);
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
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;
1258 quota_cut_bytes = 0;
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.
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.
1277 ** The unformatted node must be dirtied later on. We can't be
1278 ** sure here if the entire tail has been deleted yet.
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.
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));
1289 B_I_PITEM(PATH_PLAST_BUFFER(p_s_path), &s_ih),
1291 kunmap_atomic(data, KM_USER0);
1293 /* Perform balancing after all resources have been collected at once. */
1294 do_balance(&s_del_balance, NULL, NULL, M_DELETE);
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));
1301 DLIMIT_FREE_SPACE(p_s_inode, quota_cut_bytes);
1302 DQUOT_FREE_SPACE_NODIRTY(p_s_inode, quota_cut_bytes);
1304 /* Return deleted body length */
1308 /* Summary Of Mechanisms For Handling Collisions Between Processes:
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().
1315 writes and truncates are protected from collisions by use of
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.
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)
1328 struct tree_balance tb;
1329 INITIALIZE_PATH(path);
1332 struct cpu_key cpu_key;
1334 int quota_cut_bytes = 0;
1336 BUG_ON(!th->t_trans_id);
1338 le_key2cpu_key(&cpu_key, key);
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",
1349 if (retval != ITEM_FOUND) {
1351 // No need for a warning, if there is just no free space to insert '..' item into the newly-created subdir
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),
1360 reiserfs_warning(th->t_super,
1361 "vs-5355: reiserfs_delete_solid_item: %k not found",
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));
1371 quota_cut_bytes = ih_item_len(PATH_PITEM_HEAD(&path));
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);
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,
1388 DLIMIT_FREE_SPACE(inode, quota_cut_bytes);
1389 DQUOT_FREE_SPACE_NODIRTY(inode,
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",
1403 reiserfs_check_path(&path);
1406 int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
1407 struct inode *inode)
1411 BUG_ON(!th->t_trans_id);
1413 /* for directory this deletes item containing "." and ".." */
1415 reiserfs_do_truncate(th, inode, NULL, 0 /*no timestamp updates */ );
1419 #if defined( USE_INODE_GENERATION_COUNTER )
1420 if (!old_format_only(th->t_super)) {
1421 __le32 *inode_generation;
1424 &REISERFS_SB(th->t_super)->s_rs->s_inode_generation;
1426 cpu_to_le32(le32_to_cpu(*inode_generation) + 1);
1428 /* USE_INODE_GENERATION_COUNTER */
1430 reiserfs_delete_solid_item(th, inode, INODE_PKEY(inode));
1435 static void unmap_buffers(struct page *page, loff_t pos)
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;
1444 if (page_has_buffers(page)) {
1445 tail_index = pos & (PAGE_CACHE_SIZE - 1);
1447 head = page_buffers(page);
1450 next = bh->b_this_page;
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
1458 cur_index += bh->b_size;
1459 if (cur_index > tail_index) {
1460 reiserfs_unmap_buffer(bh);
1463 } while (bh != head);
1464 if (PAGE_SIZE == bh->b_size) {
1465 clear_page_dirty(page);
1471 static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
1472 struct inode *p_s_inode,
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)
1478 struct super_block *p_s_sb = p_s_inode->i_sb;
1479 int n_block_size = p_s_sb->s_blocksize;
1481 BUG_ON(!th->t_trans_id);
1483 if (n_new_file_size != p_s_inode->i_size)
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
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;
1496 n_block_size - (n_new_file_size & (n_block_size - 1));
1497 pathrelse(p_s_path);
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);
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
1510 static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
1511 struct inode *inode, struct path *path)
1513 struct cpu_key tail_key;
1516 BUG_ON(!th->t_trans_id);
1518 make_cpu_key(&tail_key, inode, inode->i_size + 1, TYPE_DIRECT, 4); // !!!!
1519 tail_key.key_length = 4;
1522 (cpu_key_k_offset(&tail_key) & (inode->i_sb->s_blocksize - 1)) - 1;
1524 /* look for the last byte of the tail */
1525 if (search_for_position_by_key(inode->i_sb, &tail_key, path) ==
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)--;
1535 reiserfs_delete_item(th, path, &tail_key, inode,
1536 NULL /*unbh not needed */ );
1538 || removed > tail_len,
1539 "vs-5617: there was tail %d bytes, removed item length %d bytes",
1541 tail_len -= removed;
1542 set_cpu_key_k_offset(&tail_key,
1543 cpu_key_k_offset(&tail_key) - removed);
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);
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)
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. */
1570 int quota_cut_bytes;
1571 loff_t tail_pos = 0;
1573 BUG_ON(!th->t_trans_id);
1575 init_tb_struct(th, &s_cut_balance, p_s_inode->i_sb, p_s_path,
1578 /* Repeat this loop until we either cut the item without needing
1579 to balance, or we fix_nodes without schedule occurring */
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
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");
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 */
1604 n_is_inode_locked = 1;
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)); */
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
1615 set_cpu_key_k_type(p_s_item_key, TYPE_INDIRECT);
1616 p_s_item_key->key_length = 4;
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)",
1633 if (n_cut_size == 0) {
1634 pathrelse(p_s_path);
1638 s_cut_balance.insert_size[0] = n_cut_size;
1640 n_ret_value = fix_nodes(c_mode, &s_cut_balance, NULL, NULL);
1641 if (n_ret_value != REPEAT_SEARCH)
1644 PROC_INFO_INC(p_s_sb, cut_from_item_restarted);
1647 search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path);
1648 if (n_ret_value == POSITION_FOUND)
1651 reiserfs_warning(p_s_sb,
1652 "PAP-5610: reiserfs_cut_from_item: item %K not found",
1654 unfix_nodes(&s_cut_balance);
1655 return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT;
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
1663 indirect_to_direct_roll_back(th, p_s_inode, p_s_path);
1665 if (n_ret_value == NO_DISK_SPACE)
1666 reiserfs_warning(p_s_sb, "NO_DISK_SPACE");
1667 unfix_nodes(&s_cut_balance);
1671 /* go ahead and perform balancing */
1673 RFALSE(c_mode == M_PASTE || c_mode == M_INSERT, "invalid mode");
1675 /* Calculate number of bytes that need to be cut from the item. */
1678 M_DELETE) ? ih_item_len(get_ih(p_s_path)) : -s_cut_balance.
1681 n_ret_value = calc_deleted_bytes_number(&s_cut_balance, c_mode);
1683 n_ret_value = retval2;
1685 /* For direct items, we only change the quota when deleting the last
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)) ==
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;
1697 quota_cut_bytes = 0;
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
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);
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",
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]);
1726 /* it would be useful to make sure, that right neighboring
1727 item is direct item of this file */
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
1738 unmap_buffers(page, tail_pos);
1739 REISERFS_I(p_s_inode)->i_flags &= ~i_pack_on_close_mask;
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, '?');
1746 DLIMIT_FREE_SPACE(p_s_inode, quota_cut_bytes);
1747 DQUOT_FREE_SPACE_NODIRTY(p_s_inode, quota_cut_bytes);
1751 static void truncate_directory(struct reiserfs_transaction_handle *th,
1752 struct inode *inode)
1754 BUG_ON(!th->t_trans_id);
1756 reiserfs_warning(inode->i_sb,
1757 "vs-5655: truncate_directory: link count != 0");
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);
1767 /* Truncate file to the new size. Note, this must be called with a transaction
1769 int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *p_s_inode, /* ->i_size contains new
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 */
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. */
1787 BUG_ON(!th->t_trans_id);
1789 (S_ISREG(p_s_inode->i_mode) || S_ISDIR(p_s_inode->i_mode)
1790 || S_ISLNK(p_s_inode->i_mode)))
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);
1799 /* Get new file size. */
1800 n_new_file_size = p_s_inode->i_size;
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),
1807 search_for_position_by_key(p_s_inode->i_sb, &s_item_key,
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",
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,
1827 s_search_path.pos_in_item--;
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))
1834 loff_t offset = le_ih_k_offset(p_le_ih);
1836 op_bytes_number(p_le_ih, p_s_inode->i_sb->s_blocksize);
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;
1844 * are we doing a full truncate or delete, if so
1845 * kick in the reada code
1847 if (n_new_file_size == 0)
1848 s_search_path.reada = PATH_READA | PATH_READA_BACK;
1850 if (n_file_size == 0 || n_file_size < n_new_file_size) {
1851 goto update_and_out;
1854 /* Update key to search for the last file item. */
1855 set_cpu_key_k_offset(&s_item_key, n_file_size);
1858 /* Cut or delete file item. */
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);
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);
1873 /* Change key to search the last file item. */
1874 n_file_size -= n_deleted;
1876 set_cpu_key_k_offset(&s_item_key, n_file_size);
1878 /* While there are bytes to truncate and previous file item is presented in the tree. */
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
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);
1892 if (update_timestamps) {
1893 p_s_inode->i_mtime = p_s_inode->i_ctime =
1896 reiserfs_update_sd(th, p_s_inode);
1898 err = journal_end(th, p_s_inode->i_sb, orig_len_alloc);
1901 err = journal_begin(th, p_s_inode->i_sb,
1902 JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD + JOURNAL_PER_BALANCE_CNT * 4) ;
1905 reiserfs_update_inode_transaction(p_s_inode);
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);
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);
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;
1920 reiserfs_update_sd(th, p_s_inode);
1923 pathrelse(&s_search_path);
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)
1932 struct item_head *found_ih = get_ih(path);
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) !=
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);
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);
1960 #endif /* config reiserfs check */
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. */
1968 { /* Size of pasted bytes. */
1969 struct tree_balance s_paste_balance;
1973 BUG_ON(!th->t_trans_id);
1975 fs_gen = get_generation(inode->i_sb);
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)));
1984 if (DQUOT_ALLOC_SPACE_NODIRTY(inode, n_pasted_size)) {
1985 pathrelse(p_s_search_path);
1988 if (DLIMIT_ALLOC_SPACE(inode, n_pasted_size)) {
1989 DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size);
1990 pathrelse(p_s_search_path);
1993 init_tb_struct(th, &s_paste_balance, th->t_super, p_s_search_path,
1995 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
1996 s_paste_balance.key = p_s_key->on_disk_key;
1999 /* DQUOT_* can schedule, must check before the fix_nodes */
2000 if (fs_changed(fs_gen, inode->i_sb)) {
2005 fix_nodes(M_PASTE, &s_paste_balance, NULL,
2006 p_c_body)) == REPEAT_SEARCH) {
2008 /* file system changed while we were in the fix_nodes */
2009 PROC_INFO_INC(th->t_super, paste_into_item_restarted);
2011 search_for_position_by_key(th->t_super, p_s_key,
2013 if (retval == IO_ERROR) {
2017 if (retval == POSITION_FOUND) {
2018 reiserfs_warning(inode->i_sb,
2019 "PAP-5710: reiserfs_paste_into_item: entry or pasted byte (%K) exists",
2024 #ifdef CONFIG_REISERFS_CHECK
2025 check_research_for_paste(p_s_search_path, p_s_key);
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);
2035 retval = (retval == NO_DISK_SPACE) ? -ENOSPC : -EIO;
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)));
2045 DLIMIT_FREE_SPACE(inode, n_pasted_size);
2046 DQUOT_FREE_SPACE_NODIRTY(inode, n_pasted_size);
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;
2058 int quota_bytes = 0;
2060 BUG_ON(!th->t_trans_id);
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);
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
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;
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));
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);
2083 if (DLIMIT_ALLOC_SPACE(inode, quota_bytes)) {
2084 DQUOT_FREE_SPACE_NODIRTY(inode, quota_bytes);
2085 pathrelse(p_s_path);
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;
2094 /* DQUOT_* can schedule, must check to be sure calling fix_nodes is safe */
2095 if (inode && fs_changed(fs_gen, inode->i_sb)) {
2100 fix_nodes(M_INSERT, &s_ins_balance, p_s_ih,
2101 p_c_body)) == REPEAT_SEARCH) {
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) {
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",
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);
2126 retval = (retval == NO_DISK_SPACE) ? -ENOSPC : -EIO;
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));
2136 DLIMIT_FREE_SPACE(inode, quota_bytes);
2137 DQUOT_FREE_SPACE_NODIRTY(inode, quota_bytes);