ctree.c (b9729ce014f6c22d4ca7fda97a7d8ea432af5f91) ctree.c (bfb484d922a317183d77b3b6db77a2ff659384cc)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2007,2008 Oracle. All rights reserved.
4 */
5
6#include <linux/sched.h>
7#include <linux/slab.h>
8#include <linux/rbtree.h>

--- 2212 unchanged lines hidden (view full) ---

2221 if (path->reada == READA_BACK && objectid) {
2222 btrfs_node_key(node, &disk_key, nr);
2223 if (btrfs_disk_key_objectid(&disk_key) != objectid)
2224 break;
2225 }
2226 search = btrfs_node_blockptr(node, nr);
2227 if ((search <= target && target - search <= 65536) ||
2228 (search > target && search - target <= 65536)) {
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2007,2008 Oracle. All rights reserved.
4 */
5
6#include <linux/sched.h>
7#include <linux/slab.h>
8#include <linux/rbtree.h>

--- 2212 unchanged lines hidden (view full) ---

2221 if (path->reada == READA_BACK && objectid) {
2222 btrfs_node_key(node, &disk_key, nr);
2223 if (btrfs_disk_key_objectid(&disk_key) != objectid)
2224 break;
2225 }
2226 search = btrfs_node_blockptr(node, nr);
2227 if ((search <= target && target - search <= 65536) ||
2228 (search > target && search - target <= 65536)) {
2229 readahead_tree_block(fs_info, search);
2229 btrfs_readahead_node_child(node, nr);
2230 nread += blocksize;
2231 }
2232 nscan++;
2233 if ((nread > 65536 || nscan > 32))
2234 break;
2235 }
2236}
2237
2230 nread += blocksize;
2231 }
2232 nscan++;
2233 if ((nread > 65536 || nscan > 32))
2234 break;
2235 }
2236}
2237
2238static noinline void reada_for_balance(struct btrfs_fs_info *fs_info,
2239 struct btrfs_path *path, int level)
2238static noinline void reada_for_balance(struct btrfs_path *path, int level)
2240{
2239{
2240 struct extent_buffer *parent;
2241 int slot;
2242 int nritems;
2241 int slot;
2242 int nritems;
2243 struct extent_buffer *parent;
2244 struct extent_buffer *eb;
2245 u64 gen;
2246 u64 block1 = 0;
2247 u64 block2 = 0;
2248
2249 parent = path->nodes[level + 1];
2250 if (!parent)
2251 return;
2252
2253 nritems = btrfs_header_nritems(parent);
2254 slot = path->slots[level + 1];
2255
2243
2244 parent = path->nodes[level + 1];
2245 if (!parent)
2246 return;
2247
2248 nritems = btrfs_header_nritems(parent);
2249 slot = path->slots[level + 1];
2250
2256 if (slot > 0) {
2257 block1 = btrfs_node_blockptr(parent, slot - 1);
2258 gen = btrfs_node_ptr_generation(parent, slot - 1);
2259 eb = find_extent_buffer(fs_info, block1);
2260 /*
2261 * if we get -eagain from btrfs_buffer_uptodate, we
2262 * don't want to return eagain here. That will loop
2263 * forever
2264 */
2265 if (eb && btrfs_buffer_uptodate(eb, gen, 1) != 0)
2266 block1 = 0;
2267 free_extent_buffer(eb);
2268 }
2269 if (slot + 1 < nritems) {
2270 block2 = btrfs_node_blockptr(parent, slot + 1);
2271 gen = btrfs_node_ptr_generation(parent, slot + 1);
2272 eb = find_extent_buffer(fs_info, block2);
2273 if (eb && btrfs_buffer_uptodate(eb, gen, 1) != 0)
2274 block2 = 0;
2275 free_extent_buffer(eb);
2276 }
2277
2278 if (block1)
2279 readahead_tree_block(fs_info, block1);
2280 if (block2)
2281 readahead_tree_block(fs_info, block2);
2251 if (slot > 0)
2252 btrfs_readahead_node_child(parent, slot - 1);
2253 if (slot + 1 < nritems)
2254 btrfs_readahead_node_child(parent, slot + 1);
2282}
2283
2284
2285/*
2286 * when we walk down the tree, it is usually safe to unlock the higher layers
2287 * in the tree. The exceptions are when our path goes through slot 0, because
2288 * operations on the tree might require changing key pointers higher up in the
2289 * tree.

--- 159 unchanged lines hidden (view full) ---

2449 int sret;
2450
2451 if (*write_lock_level < level + 1) {
2452 *write_lock_level = level + 1;
2453 btrfs_release_path(p);
2454 goto again;
2455 }
2456
2255}
2256
2257
2258/*
2259 * when we walk down the tree, it is usually safe to unlock the higher layers
2260 * in the tree. The exceptions are when our path goes through slot 0, because
2261 * operations on the tree might require changing key pointers higher up in the
2262 * tree.

--- 159 unchanged lines hidden (view full) ---

2422 int sret;
2423
2424 if (*write_lock_level < level + 1) {
2425 *write_lock_level = level + 1;
2426 btrfs_release_path(p);
2427 goto again;
2428 }
2429
2457 reada_for_balance(fs_info, p, level);
2430 reada_for_balance(p, level);
2458 sret = split_node(trans, root, p, level);
2459
2460 BUG_ON(sret > 0);
2461 if (sret) {
2462 ret = sret;
2463 goto done;
2464 }
2465 b = p->nodes[level];
2466 } else if (ins_len < 0 && btrfs_header_nritems(b) <
2467 BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 2) {
2468 int sret;
2469
2470 if (*write_lock_level < level + 1) {
2471 *write_lock_level = level + 1;
2472 btrfs_release_path(p);
2473 goto again;
2474 }
2475
2431 sret = split_node(trans, root, p, level);
2432
2433 BUG_ON(sret > 0);
2434 if (sret) {
2435 ret = sret;
2436 goto done;
2437 }
2438 b = p->nodes[level];
2439 } else if (ins_len < 0 && btrfs_header_nritems(b) <
2440 BTRFS_NODEPTRS_PER_BLOCK(fs_info) / 2) {
2441 int sret;
2442
2443 if (*write_lock_level < level + 1) {
2444 *write_lock_level = level + 1;
2445 btrfs_release_path(p);
2446 goto again;
2447 }
2448
2476 reada_for_balance(fs_info, p, level);
2449 reada_for_balance(p, level);
2477 sret = balance_level(trans, root, p, level);
2478
2479 if (sret) {
2480 ret = sret;
2481 goto done;
2482 }
2483 b = p->nodes[level];
2484 if (!b) {

--- 3080 unchanged lines hidden --- 		2450 sret = balance_level(trans, root, p, level);
2451
2452 if (sret) {
2453 ret = sret;
2454 goto done;
2455 }
2456 b = p->nodes[level];
2457 if (!b) {

--- 3080 unchanged lines hidden ---