Blame view
fs/btrfs/delayed-ref.c
18.6 KB
56bec294d Btrfs: do extent ... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
/* * Copyright (C) 2009 Oracle. All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License v2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 021110-1307, USA. */ #include <linux/sched.h> |
5a0e3ad6a include cleanup: ... |
20 |
#include <linux/slab.h> |
56bec294d Btrfs: do extent ... |
21 |
#include <linux/sort.h> |
56bec294d Btrfs: do extent ... |
22 23 24 25 26 27 28 29 30 31 32 |
#include "ctree.h" #include "delayed-ref.h" #include "transaction.h" /* * delayed back reference update tracking. For subvolume trees * we queue up extent allocations and backref maintenance for * delayed processing. This avoids deep call chains where we * add extents in the middle of btrfs_search_slot, and it allows * us to buffer up frequently modified backrefs in an rb tree instead * of hammering updates on the extent allocation tree. |
56bec294d Btrfs: do extent ... |
33 34 35 |
*/ /* |
5d4f98a28 Btrfs: Mixed back... |
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
* compare two delayed tree backrefs with same bytenr and type */ static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref2, struct btrfs_delayed_tree_ref *ref1) { if (ref1->node.type == BTRFS_TREE_BLOCK_REF_KEY) { if (ref1->root < ref2->root) return -1; if (ref1->root > ref2->root) return 1; } else { if (ref1->parent < ref2->parent) return -1; if (ref1->parent > ref2->parent) return 1; } return 0; } /* * compare two delayed data backrefs with same bytenr and type |
56bec294d Btrfs: do extent ... |
57 |
*/ |
5d4f98a28 Btrfs: Mixed back... |
58 59 |
static int comp_data_refs(struct btrfs_delayed_data_ref *ref2, struct btrfs_delayed_data_ref *ref1) |
56bec294d Btrfs: do extent ... |
60 |
{ |
5d4f98a28 Btrfs: Mixed back... |
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
if (ref1->node.type == BTRFS_EXTENT_DATA_REF_KEY) { if (ref1->root < ref2->root) return -1; if (ref1->root > ref2->root) return 1; if (ref1->objectid < ref2->objectid) return -1; if (ref1->objectid > ref2->objectid) return 1; if (ref1->offset < ref2->offset) return -1; if (ref1->offset > ref2->offset) return 1; } else { if (ref1->parent < ref2->parent) return -1; if (ref1->parent > ref2->parent) return 1; } return 0; } /* * entries in the rb tree are ordered by the byte number of the extent, * type of the delayed backrefs and content of delayed backrefs. */ static int comp_entry(struct btrfs_delayed_ref_node *ref2, struct btrfs_delayed_ref_node *ref1) { if (ref1->bytenr < ref2->bytenr) |
56bec294d Btrfs: do extent ... |
91 |
return -1; |
5d4f98a28 Btrfs: Mixed back... |
92 |
if (ref1->bytenr > ref2->bytenr) |
56bec294d Btrfs: do extent ... |
93 |
return 1; |
5d4f98a28 Btrfs: Mixed back... |
94 95 96 |
if (ref1->is_head && ref2->is_head) return 0; if (ref2->is_head) |
56bec294d Btrfs: do extent ... |
97 |
return -1; |
5d4f98a28 Btrfs: Mixed back... |
98 |
if (ref1->is_head) |
56bec294d Btrfs: do extent ... |
99 |
return 1; |
5d4f98a28 Btrfs: Mixed back... |
100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
if (ref1->type < ref2->type) return -1; if (ref1->type > ref2->type) return 1; if (ref1->type == BTRFS_TREE_BLOCK_REF_KEY || ref1->type == BTRFS_SHARED_BLOCK_REF_KEY) { return comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref2), btrfs_delayed_node_to_tree_ref(ref1)); } else if (ref1->type == BTRFS_EXTENT_DATA_REF_KEY || ref1->type == BTRFS_SHARED_DATA_REF_KEY) { return comp_data_refs(btrfs_delayed_node_to_data_ref(ref2), btrfs_delayed_node_to_data_ref(ref1)); } BUG(); |
56bec294d Btrfs: do extent ... |
114 115 116 117 118 119 120 121 122 |
return 0; } /* * insert a new ref into the rbtree. This returns any existing refs * for the same (bytenr,parent) tuple, or NULL if the new node was properly * inserted. */ static struct btrfs_delayed_ref_node *tree_insert(struct rb_root *root, |
56bec294d Btrfs: do extent ... |
123 124 125 126 127 |
struct rb_node *node) { struct rb_node **p = &root->rb_node; struct rb_node *parent_node = NULL; struct btrfs_delayed_ref_node *entry; |
5d4f98a28 Btrfs: Mixed back... |
128 |
struct btrfs_delayed_ref_node *ins; |
56bec294d Btrfs: do extent ... |
129 |
int cmp; |
5d4f98a28 Btrfs: Mixed back... |
130 |
ins = rb_entry(node, struct btrfs_delayed_ref_node, rb_node); |
56bec294d Btrfs: do extent ... |
131 132 133 134 |
while (*p) { parent_node = *p; entry = rb_entry(parent_node, struct btrfs_delayed_ref_node, rb_node); |
5d4f98a28 Btrfs: Mixed back... |
135 |
cmp = comp_entry(entry, ins); |
56bec294d Btrfs: do extent ... |
136 137 138 139 140 141 142 |
if (cmp < 0) p = &(*p)->rb_left; else if (cmp > 0) p = &(*p)->rb_right; else return entry; } |
56bec294d Btrfs: do extent ... |
143 144 145 146 147 148 |
rb_link_node(node, parent_node, p); rb_insert_color(node, root); return NULL; } /* |
5d4f98a28 Btrfs: Mixed back... |
149 150 |
* find an head entry based on bytenr. This returns the delayed ref * head if it was able to find one, or NULL if nothing was in that spot |
56bec294d Btrfs: do extent ... |
151 |
*/ |
5d4f98a28 Btrfs: Mixed back... |
152 153 |
static struct btrfs_delayed_ref_node *find_ref_head(struct rb_root *root, u64 bytenr, |
c3e69d58e Btrfs: process th... |
154 |
struct btrfs_delayed_ref_node **last) |
56bec294d Btrfs: do extent ... |
155 156 157 158 159 160 161 162 |
{ struct rb_node *n = root->rb_node; struct btrfs_delayed_ref_node *entry; int cmp; while (n) { entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node); WARN_ON(!entry->in_tree); |
c3e69d58e Btrfs: process th... |
163 164 |
if (last) *last = entry; |
56bec294d Btrfs: do extent ... |
165 |
|
5d4f98a28 Btrfs: Mixed back... |
166 167 168 169 170 171 172 173 |
if (bytenr < entry->bytenr) cmp = -1; else if (bytenr > entry->bytenr) cmp = 1; else if (!btrfs_delayed_ref_is_head(entry)) cmp = 1; else cmp = 0; |
56bec294d Btrfs: do extent ... |
174 175 176 177 178 179 180 181 182 |
if (cmp < 0) n = n->rb_left; else if (cmp > 0) n = n->rb_right; else return entry; } return NULL; } |
c3e69d58e Btrfs: process th... |
183 184 |
int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_head *head) |
56bec294d Btrfs: do extent ... |
185 |
{ |
c3e69d58e Btrfs: process th... |
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 |
struct btrfs_delayed_ref_root *delayed_refs; delayed_refs = &trans->transaction->delayed_refs; assert_spin_locked(&delayed_refs->lock); if (mutex_trylock(&head->mutex)) return 0; atomic_inc(&head->node.refs); spin_unlock(&delayed_refs->lock); mutex_lock(&head->mutex); spin_lock(&delayed_refs->lock); if (!head->node.in_tree) { mutex_unlock(&head->mutex); btrfs_put_delayed_ref(&head->node); return -EAGAIN; } btrfs_put_delayed_ref(&head->node); return 0; } int btrfs_find_ref_cluster(struct btrfs_trans_handle *trans, struct list_head *cluster, u64 start) { int count = 0; struct btrfs_delayed_ref_root *delayed_refs; |
56bec294d Btrfs: do extent ... |
212 |
struct rb_node *node; |
c3e69d58e Btrfs: process th... |
213 |
struct btrfs_delayed_ref_node *ref; |
56bec294d Btrfs: do extent ... |
214 |
struct btrfs_delayed_ref_head *head; |
56bec294d Btrfs: do extent ... |
215 |
|
c3e69d58e Btrfs: process th... |
216 217 218 219 220 |
delayed_refs = &trans->transaction->delayed_refs; if (start == 0) { node = rb_first(&delayed_refs->root); } else { ref = NULL; |
5d4f98a28 Btrfs: Mixed back... |
221 |
find_ref_head(&delayed_refs->root, start, &ref); |
c3e69d58e Btrfs: process th... |
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 |
if (ref) { struct btrfs_delayed_ref_node *tmp; node = rb_prev(&ref->rb_node); while (node) { tmp = rb_entry(node, struct btrfs_delayed_ref_node, rb_node); if (tmp->bytenr < start) break; ref = tmp; node = rb_prev(&ref->rb_node); } node = &ref->rb_node; } else node = rb_first(&delayed_refs->root); } again: while (node && count < 32) { ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node); |
56bec294d Btrfs: do extent ... |
242 243 |
if (btrfs_delayed_ref_is_head(ref)) { head = btrfs_delayed_node_to_head(ref); |
c3e69d58e Btrfs: process th... |
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 |
if (list_empty(&head->cluster)) { list_add_tail(&head->cluster, cluster); delayed_refs->run_delayed_start = head->node.bytenr; count++; WARN_ON(delayed_refs->num_heads_ready == 0); delayed_refs->num_heads_ready--; } else if (count) { /* the goal of the clustering is to find extents * that are likely to end up in the same extent * leaf on disk. So, we don't want them spread * all over the tree. Stop now if we've hit * a head that was already in use */ |
56bec294d Btrfs: do extent ... |
259 260 261 |
break; } } |
c3e69d58e Btrfs: process th... |
262 |
node = rb_next(node); |
56bec294d Btrfs: do extent ... |
263 |
} |
c3e69d58e Btrfs: process th... |
264 265 266 267 268 269 270 271 272 273 274 275 |
if (count) { return 0; } else if (start) { /* * we've gone to the end of the rbtree without finding any * clusters. start from the beginning and try again */ start = 0; node = rb_first(&delayed_refs->root); goto again; } return 1; |
56bec294d Btrfs: do extent ... |
276 277 278 |
} /* |
56bec294d Btrfs: do extent ... |
279 280 281 282 283 284 285 286 287 288 289 290 291 |
* helper function to update an extent delayed ref in the * rbtree. existing and update must both have the same * bytenr and parent * * This may free existing if the update cancels out whatever * operation it was doing. */ static noinline void update_existing_ref(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_root *delayed_refs, struct btrfs_delayed_ref_node *existing, struct btrfs_delayed_ref_node *update) { |
5d4f98a28 Btrfs: Mixed back... |
292 |
if (update->action != existing->action) { |
56bec294d Btrfs: do extent ... |
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
/* * this is effectively undoing either an add or a * drop. We decrement the ref_mod, and if it goes * down to zero we just delete the entry without * every changing the extent allocation tree. */ existing->ref_mod--; if (existing->ref_mod == 0) { rb_erase(&existing->rb_node, &delayed_refs->root); existing->in_tree = 0; btrfs_put_delayed_ref(existing); delayed_refs->num_entries--; if (trans->delayed_ref_updates) trans->delayed_ref_updates--; |
5d4f98a28 Btrfs: Mixed back... |
308 309 310 |
} else { WARN_ON(existing->type == BTRFS_TREE_BLOCK_REF_KEY || existing->type == BTRFS_SHARED_BLOCK_REF_KEY); |
56bec294d Btrfs: do extent ... |
311 312 |
} } else { |
5d4f98a28 Btrfs: Mixed back... |
313 314 |
WARN_ON(existing->type == BTRFS_TREE_BLOCK_REF_KEY || existing->type == BTRFS_SHARED_BLOCK_REF_KEY); |
56bec294d Btrfs: do extent ... |
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 |
/* * the action on the existing ref matches * the action on the ref we're trying to add. * Bump the ref_mod by one so the backref that * is eventually added/removed has the correct * reference count */ existing->ref_mod += update->ref_mod; } } /* * helper function to update the accounting in the head ref * existing and update must have the same bytenr */ static noinline void update_existing_head_ref(struct btrfs_delayed_ref_node *existing, struct btrfs_delayed_ref_node *update) { struct btrfs_delayed_ref_head *existing_ref; struct btrfs_delayed_ref_head *ref; existing_ref = btrfs_delayed_node_to_head(existing); ref = btrfs_delayed_node_to_head(update); |
5d4f98a28 Btrfs: Mixed back... |
339 |
BUG_ON(existing_ref->is_data != ref->is_data); |
56bec294d Btrfs: do extent ... |
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 |
if (ref->must_insert_reserved) { /* if the extent was freed and then * reallocated before the delayed ref * entries were processed, we can end up * with an existing head ref without * the must_insert_reserved flag set. * Set it again here */ existing_ref->must_insert_reserved = ref->must_insert_reserved; /* * update the num_bytes so we make sure the accounting * is done correctly */ existing->num_bytes = update->num_bytes; } |
5d4f98a28 Btrfs: Mixed back... |
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 |
if (ref->extent_op) { if (!existing_ref->extent_op) { existing_ref->extent_op = ref->extent_op; } else { if (ref->extent_op->update_key) { memcpy(&existing_ref->extent_op->key, &ref->extent_op->key, sizeof(ref->extent_op->key)); existing_ref->extent_op->update_key = 1; } if (ref->extent_op->update_flags) { existing_ref->extent_op->flags_to_set |= ref->extent_op->flags_to_set; existing_ref->extent_op->update_flags = 1; } kfree(ref->extent_op); } } |
56bec294d Btrfs: do extent ... |
376 377 378 379 380 381 382 |
/* * update the reference mod on the head to reflect this new operation */ existing->ref_mod += update->ref_mod; } /* |
5d4f98a28 Btrfs: Mixed back... |
383 |
* helper function to actually insert a head node into the rbtree. |
56bec294d Btrfs: do extent ... |
384 |
* this does all the dirty work in terms of maintaining the correct |
5d4f98a28 Btrfs: Mixed back... |
385 |
* overall modification count. |
56bec294d Btrfs: do extent ... |
386 |
*/ |
5d4f98a28 Btrfs: Mixed back... |
387 388 389 390 |
static noinline int add_delayed_ref_head(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_node *ref, u64 bytenr, u64 num_bytes, int action, int is_data) |
56bec294d Btrfs: do extent ... |
391 392 |
{ struct btrfs_delayed_ref_node *existing; |
c3e69d58e Btrfs: process th... |
393 |
struct btrfs_delayed_ref_head *head_ref = NULL; |
56bec294d Btrfs: do extent ... |
394 395 396 397 398 399 400 401 |
struct btrfs_delayed_ref_root *delayed_refs; int count_mod = 1; int must_insert_reserved = 0; /* * the head node stores the sum of all the mods, so dropping a ref * should drop the sum in the head node by one. */ |
5d4f98a28 Btrfs: Mixed back... |
402 403 404 405 |
if (action == BTRFS_UPDATE_DELAYED_HEAD) count_mod = 0; else if (action == BTRFS_DROP_DELAYED_REF) count_mod = -1; |
56bec294d Btrfs: do extent ... |
406 407 408 409 410 411 412 413 414 415 416 417 |
/* * BTRFS_ADD_DELAYED_EXTENT means that we need to update * the reserved accounting when the extent is finally added, or * if a later modification deletes the delayed ref without ever * inserting the extent into the extent allocation tree. * ref->must_insert_reserved is the flag used to record * that accounting mods are required. * * Once we record must_insert_reserved, switch the action to * BTRFS_ADD_DELAYED_REF because other special casing is not required. */ |
5d4f98a28 Btrfs: Mixed back... |
418 |
if (action == BTRFS_ADD_DELAYED_EXTENT) |
56bec294d Btrfs: do extent ... |
419 |
must_insert_reserved = 1; |
5d4f98a28 Btrfs: Mixed back... |
420 |
else |
56bec294d Btrfs: do extent ... |
421 |
must_insert_reserved = 0; |
56bec294d Btrfs: do extent ... |
422 423 424 425 426 427 |
delayed_refs = &trans->transaction->delayed_refs; /* first set the basic ref node struct up */ atomic_set(&ref->refs, 1); ref->bytenr = bytenr; |
5d4f98a28 Btrfs: Mixed back... |
428 |
ref->num_bytes = num_bytes; |
56bec294d Btrfs: do extent ... |
429 |
ref->ref_mod = count_mod; |
5d4f98a28 Btrfs: Mixed back... |
430 431 432 |
ref->type = 0; ref->action = 0; ref->is_head = 1; |
56bec294d Btrfs: do extent ... |
433 |
ref->in_tree = 1; |
5d4f98a28 Btrfs: Mixed back... |
434 435 436 437 438 439 440 |
head_ref = btrfs_delayed_node_to_head(ref); head_ref->must_insert_reserved = must_insert_reserved; head_ref->is_data = is_data; INIT_LIST_HEAD(&head_ref->cluster); mutex_init(&head_ref->mutex); |
1abe9b8a1 Btrfs: add initia... |
441 |
trace_btrfs_delayed_ref_head(ref, head_ref, action); |
5d4f98a28 Btrfs: Mixed back... |
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 |
existing = tree_insert(&delayed_refs->root, &ref->rb_node); if (existing) { update_existing_head_ref(existing, ref); /* * we've updated the existing ref, free the newly * allocated ref */ kfree(ref); } else { delayed_refs->num_heads++; delayed_refs->num_heads_ready++; delayed_refs->num_entries++; trans->delayed_ref_updates++; } return 0; } /* * helper to insert a delayed tree ref into the rbtree. */ static noinline int add_delayed_tree_ref(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_node *ref, u64 bytenr, u64 num_bytes, u64 parent, u64 ref_root, int level, int action) { struct btrfs_delayed_ref_node *existing; struct btrfs_delayed_tree_ref *full_ref; struct btrfs_delayed_ref_root *delayed_refs; if (action == BTRFS_ADD_DELAYED_EXTENT) action = BTRFS_ADD_DELAYED_REF; delayed_refs = &trans->transaction->delayed_refs; /* first set the basic ref node struct up */ atomic_set(&ref->refs, 1); ref->bytenr = bytenr; |
56bec294d Btrfs: do extent ... |
480 |
ref->num_bytes = num_bytes; |
5d4f98a28 Btrfs: Mixed back... |
481 482 483 484 |
ref->ref_mod = 1; ref->action = action; ref->is_head = 0; ref->in_tree = 1; |
56bec294d Btrfs: do extent ... |
485 |
|
5d4f98a28 Btrfs: Mixed back... |
486 487 488 489 |
full_ref = btrfs_delayed_node_to_tree_ref(ref); if (parent) { full_ref->parent = parent; ref->type = BTRFS_SHARED_BLOCK_REF_KEY; |
56bec294d Btrfs: do extent ... |
490 |
} else { |
56bec294d Btrfs: do extent ... |
491 |
full_ref->root = ref_root; |
5d4f98a28 Btrfs: Mixed back... |
492 |
ref->type = BTRFS_TREE_BLOCK_REF_KEY; |
56bec294d Btrfs: do extent ... |
493 |
} |
5d4f98a28 Btrfs: Mixed back... |
494 |
full_ref->level = level; |
56bec294d Btrfs: do extent ... |
495 |
|
1abe9b8a1 Btrfs: add initia... |
496 |
trace_btrfs_delayed_tree_ref(ref, full_ref, action); |
5d4f98a28 Btrfs: Mixed back... |
497 |
existing = tree_insert(&delayed_refs->root, &ref->rb_node); |
56bec294d Btrfs: do extent ... |
498 499 |
if (existing) { |
5d4f98a28 Btrfs: Mixed back... |
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 |
update_existing_ref(trans, delayed_refs, existing, ref); /* * we've updated the existing ref, free the newly * allocated ref */ kfree(ref); } else { delayed_refs->num_entries++; trans->delayed_ref_updates++; } return 0; } /* * helper to insert a delayed data ref into the rbtree. */ static noinline int add_delayed_data_ref(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_node *ref, u64 bytenr, u64 num_bytes, u64 parent, u64 ref_root, u64 owner, u64 offset, int action) { struct btrfs_delayed_ref_node *existing; struct btrfs_delayed_data_ref *full_ref; struct btrfs_delayed_ref_root *delayed_refs; if (action == BTRFS_ADD_DELAYED_EXTENT) action = BTRFS_ADD_DELAYED_REF; delayed_refs = &trans->transaction->delayed_refs; /* first set the basic ref node struct up */ atomic_set(&ref->refs, 1); ref->bytenr = bytenr; ref->num_bytes = num_bytes; ref->ref_mod = 1; ref->action = action; ref->is_head = 0; ref->in_tree = 1; full_ref = btrfs_delayed_node_to_data_ref(ref); if (parent) { full_ref->parent = parent; ref->type = BTRFS_SHARED_DATA_REF_KEY; } else { full_ref->root = ref_root; ref->type = BTRFS_EXTENT_DATA_REF_KEY; } full_ref->objectid = owner; full_ref->offset = offset; |
56bec294d Btrfs: do extent ... |
550 |
|
1abe9b8a1 Btrfs: add initia... |
551 |
trace_btrfs_delayed_data_ref(ref, full_ref, action); |
5d4f98a28 Btrfs: Mixed back... |
552 553 554 555 |
existing = tree_insert(&delayed_refs->root, &ref->rb_node); if (existing) { update_existing_ref(trans, delayed_refs, existing, ref); |
56bec294d Btrfs: do extent ... |
556 557 558 559 560 561 562 563 564 565 566 567 568 |
/* * we've updated the existing ref, free the newly * allocated ref */ kfree(ref); } else { delayed_refs->num_entries++; trans->delayed_ref_updates++; } return 0; } /* |
5d4f98a28 Btrfs: Mixed back... |
569 |
* add a delayed tree ref. This does all of the accounting required |
56bec294d Btrfs: do extent ... |
570 571 572 |
* to make sure the delayed ref is eventually processed before this * transaction commits. */ |
5d4f98a28 Btrfs: Mixed back... |
573 574 575 576 |
int btrfs_add_delayed_tree_ref(struct btrfs_trans_handle *trans, u64 bytenr, u64 num_bytes, u64 parent, u64 ref_root, int level, int action, struct btrfs_delayed_extent_op *extent_op) |
56bec294d Btrfs: do extent ... |
577 |
{ |
5d4f98a28 Btrfs: Mixed back... |
578 |
struct btrfs_delayed_tree_ref *ref; |
56bec294d Btrfs: do extent ... |
579 580 581 |
struct btrfs_delayed_ref_head *head_ref; struct btrfs_delayed_ref_root *delayed_refs; int ret; |
5d4f98a28 Btrfs: Mixed back... |
582 |
BUG_ON(extent_op && extent_op->is_data); |
56bec294d Btrfs: do extent ... |
583 584 585 |
ref = kmalloc(sizeof(*ref), GFP_NOFS); if (!ref) return -ENOMEM; |
5d4f98a28 Btrfs: Mixed back... |
586 587 588 589 590 591 592 593 594 595 |
head_ref = kmalloc(sizeof(*head_ref), GFP_NOFS); if (!head_ref) { kfree(ref); return -ENOMEM; } head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs; spin_lock(&delayed_refs->lock); |
56bec294d Btrfs: do extent ... |
596 |
/* |
5d4f98a28 Btrfs: Mixed back... |
597 598 |
* insert both the head node and the new ref without dropping * the spin lock |
56bec294d Btrfs: do extent ... |
599 |
*/ |
5d4f98a28 Btrfs: Mixed back... |
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 |
ret = add_delayed_ref_head(trans, &head_ref->node, bytenr, num_bytes, action, 0); BUG_ON(ret); ret = add_delayed_tree_ref(trans, &ref->node, bytenr, num_bytes, parent, ref_root, level, action); BUG_ON(ret); spin_unlock(&delayed_refs->lock); return 0; } /* * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref. */ int btrfs_add_delayed_data_ref(struct btrfs_trans_handle *trans, u64 bytenr, u64 num_bytes, u64 parent, u64 ref_root, u64 owner, u64 offset, int action, struct btrfs_delayed_extent_op *extent_op) { struct btrfs_delayed_data_ref *ref; struct btrfs_delayed_ref_head *head_ref; struct btrfs_delayed_ref_root *delayed_refs; int ret; BUG_ON(extent_op && !extent_op->is_data); ref = kmalloc(sizeof(*ref), GFP_NOFS); if (!ref) return -ENOMEM; |
56bec294d Btrfs: do extent ... |
629 630 631 632 633 634 |
head_ref = kmalloc(sizeof(*head_ref), GFP_NOFS); if (!head_ref) { kfree(ref); return -ENOMEM; } |
5d4f98a28 Btrfs: Mixed back... |
635 636 |
head_ref->extent_op = extent_op; |
56bec294d Btrfs: do extent ... |
637 638 639 640 641 642 643 |
delayed_refs = &trans->transaction->delayed_refs; spin_lock(&delayed_refs->lock); /* * insert both the head node and the new ref without dropping * the spin lock */ |
5d4f98a28 Btrfs: Mixed back... |
644 645 |
ret = add_delayed_ref_head(trans, &head_ref->node, bytenr, num_bytes, action, 1); |
56bec294d Btrfs: do extent ... |
646 |
BUG_ON(ret); |
5d4f98a28 Btrfs: Mixed back... |
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 |
ret = add_delayed_data_ref(trans, &ref->node, bytenr, num_bytes, parent, ref_root, owner, offset, action); BUG_ON(ret); spin_unlock(&delayed_refs->lock); return 0; } int btrfs_add_delayed_extent_op(struct btrfs_trans_handle *trans, u64 bytenr, u64 num_bytes, struct btrfs_delayed_extent_op *extent_op) { struct btrfs_delayed_ref_head *head_ref; struct btrfs_delayed_ref_root *delayed_refs; int ret; head_ref = kmalloc(sizeof(*head_ref), GFP_NOFS); if (!head_ref) return -ENOMEM; head_ref->extent_op = extent_op; delayed_refs = &trans->transaction->delayed_refs; spin_lock(&delayed_refs->lock); ret = add_delayed_ref_head(trans, &head_ref->node, bytenr, num_bytes, BTRFS_UPDATE_DELAYED_HEAD, extent_op->is_data); |
56bec294d Btrfs: do extent ... |
674 |
BUG_ON(ret); |
5d4f98a28 Btrfs: Mixed back... |
675 |
|
56bec294d Btrfs: do extent ... |
676 677 678 679 680 |
spin_unlock(&delayed_refs->lock); return 0; } /* |
1887be66d Btrfs: try to cle... |
681 682 683 684 685 686 687 688 689 690 691 |
* this does a simple search for the head node for a given extent. * It must be called with the delayed ref spinlock held, and it returns * the head node if any where found, or NULL if not. */ struct btrfs_delayed_ref_head * btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr) { struct btrfs_delayed_ref_node *ref; struct btrfs_delayed_ref_root *delayed_refs; delayed_refs = &trans->transaction->delayed_refs; |
5d4f98a28 Btrfs: Mixed back... |
692 |
ref = find_ref_head(&delayed_refs->root, bytenr, NULL); |
1887be66d Btrfs: try to cle... |
693 694 695 696 |
if (ref) return btrfs_delayed_node_to_head(ref); return NULL; } |