diff options
Diffstat (limited to 'fs/ubifs/budget.c')
-rw-r--r-- | fs/ubifs/budget.c | 104 |
1 files changed, 52 insertions, 52 deletions
diff --git a/fs/ubifs/budget.c b/fs/ubifs/budget.c index 8b3a7da531eb..315de66e52b2 100644 --- a/fs/ubifs/budget.c +++ b/fs/ubifs/budget.c | |||
@@ -106,7 +106,7 @@ static long long get_liability(struct ubifs_info *c) | |||
106 | long long liab; | 106 | long long liab; |
107 | 107 | ||
108 | spin_lock(&c->space_lock); | 108 | spin_lock(&c->space_lock); |
109 | liab = c->budg_idx_growth + c->budg_data_growth + c->budg_dd_growth; | 109 | liab = c->bi.idx_growth + c->bi.data_growth + c->bi.dd_growth; |
110 | spin_unlock(&c->space_lock); | 110 | spin_unlock(&c->space_lock); |
111 | return liab; | 111 | return liab; |
112 | } | 112 | } |
@@ -180,7 +180,7 @@ int ubifs_calc_min_idx_lebs(struct ubifs_info *c) | |||
180 | int idx_lebs; | 180 | int idx_lebs; |
181 | long long idx_size; | 181 | long long idx_size; |
182 | 182 | ||
183 | idx_size = c->old_idx_sz + c->budg_idx_growth + c->budg_uncommitted_idx; | 183 | idx_size = c->bi.old_idx_sz + c->bi.idx_growth + c->bi.uncommitted_idx; |
184 | /* And make sure we have thrice the index size of space reserved */ | 184 | /* And make sure we have thrice the index size of space reserved */ |
185 | idx_size += idx_size << 1; | 185 | idx_size += idx_size << 1; |
186 | /* | 186 | /* |
@@ -292,13 +292,13 @@ static int can_use_rp(struct ubifs_info *c) | |||
292 | * budgeted index space to the size of the current index, multiplies this by 3, | 292 | * budgeted index space to the size of the current index, multiplies this by 3, |
293 | * and makes sure this does not exceed the amount of free LEBs. | 293 | * and makes sure this does not exceed the amount of free LEBs. |
294 | * | 294 | * |
295 | * Notes about @c->min_idx_lebs and @c->lst.idx_lebs variables: | 295 | * Notes about @c->bi.min_idx_lebs and @c->lst.idx_lebs variables: |
296 | * o @c->lst.idx_lebs is the number of LEBs the index currently uses. It might | 296 | * o @c->lst.idx_lebs is the number of LEBs the index currently uses. It might |
297 | * be large, because UBIFS does not do any index consolidation as long as | 297 | * be large, because UBIFS does not do any index consolidation as long as |
298 | * there is free space. IOW, the index may take a lot of LEBs, but the LEBs | 298 | * there is free space. IOW, the index may take a lot of LEBs, but the LEBs |
299 | * will contain a lot of dirt. | 299 | * will contain a lot of dirt. |
300 | * o @c->min_idx_lebs is the number of LEBS the index presumably takes. IOW, | 300 | * o @c->bi.min_idx_lebs is the number of LEBS the index presumably takes. IOW, |
301 | * the index may be consolidated to take up to @c->min_idx_lebs LEBs. | 301 | * the index may be consolidated to take up to @c->bi.min_idx_lebs LEBs. |
302 | * | 302 | * |
303 | * This function returns zero in case of success, and %-ENOSPC in case of | 303 | * This function returns zero in case of success, and %-ENOSPC in case of |
304 | * failure. | 304 | * failure. |
@@ -343,13 +343,13 @@ static int do_budget_space(struct ubifs_info *c) | |||
343 | c->lst.taken_empty_lebs; | 343 | c->lst.taken_empty_lebs; |
344 | if (unlikely(rsvd_idx_lebs > lebs)) { | 344 | if (unlikely(rsvd_idx_lebs > lebs)) { |
345 | dbg_budg("out of indexing space: min_idx_lebs %d (old %d), " | 345 | dbg_budg("out of indexing space: min_idx_lebs %d (old %d), " |
346 | "rsvd_idx_lebs %d", min_idx_lebs, c->min_idx_lebs, | 346 | "rsvd_idx_lebs %d", min_idx_lebs, c->bi.min_idx_lebs, |
347 | rsvd_idx_lebs); | 347 | rsvd_idx_lebs); |
348 | return -ENOSPC; | 348 | return -ENOSPC; |
349 | } | 349 | } |
350 | 350 | ||
351 | available = ubifs_calc_available(c, min_idx_lebs); | 351 | available = ubifs_calc_available(c, min_idx_lebs); |
352 | outstanding = c->budg_data_growth + c->budg_dd_growth; | 352 | outstanding = c->bi.data_growth + c->bi.dd_growth; |
353 | 353 | ||
354 | if (unlikely(available < outstanding)) { | 354 | if (unlikely(available < outstanding)) { |
355 | dbg_budg("out of data space: available %lld, outstanding %lld", | 355 | dbg_budg("out of data space: available %lld, outstanding %lld", |
@@ -360,7 +360,7 @@ static int do_budget_space(struct ubifs_info *c) | |||
360 | if (available - outstanding <= c->rp_size && !can_use_rp(c)) | 360 | if (available - outstanding <= c->rp_size && !can_use_rp(c)) |
361 | return -ENOSPC; | 361 | return -ENOSPC; |
362 | 362 | ||
363 | c->min_idx_lebs = min_idx_lebs; | 363 | c->bi.min_idx_lebs = min_idx_lebs; |
364 | return 0; | 364 | return 0; |
365 | } | 365 | } |
366 | 366 | ||
@@ -393,11 +393,11 @@ static int calc_data_growth(const struct ubifs_info *c, | |||
393 | { | 393 | { |
394 | int data_growth; | 394 | int data_growth; |
395 | 395 | ||
396 | data_growth = req->new_ino ? c->inode_budget : 0; | 396 | data_growth = req->new_ino ? c->bi.inode_budget : 0; |
397 | if (req->new_page) | 397 | if (req->new_page) |
398 | data_growth += c->page_budget; | 398 | data_growth += c->bi.page_budget; |
399 | if (req->new_dent) | 399 | if (req->new_dent) |
400 | data_growth += c->dent_budget; | 400 | data_growth += c->bi.dent_budget; |
401 | data_growth += req->new_ino_d; | 401 | data_growth += req->new_ino_d; |
402 | return data_growth; | 402 | return data_growth; |
403 | } | 403 | } |
@@ -413,12 +413,12 @@ static int calc_dd_growth(const struct ubifs_info *c, | |||
413 | { | 413 | { |
414 | int dd_growth; | 414 | int dd_growth; |
415 | 415 | ||
416 | dd_growth = req->dirtied_page ? c->page_budget : 0; | 416 | dd_growth = req->dirtied_page ? c->bi.page_budget : 0; |
417 | 417 | ||
418 | if (req->dirtied_ino) | 418 | if (req->dirtied_ino) |
419 | dd_growth += c->inode_budget << (req->dirtied_ino - 1); | 419 | dd_growth += c->bi.inode_budget << (req->dirtied_ino - 1); |
420 | if (req->mod_dent) | 420 | if (req->mod_dent) |
421 | dd_growth += c->dent_budget; | 421 | dd_growth += c->bi.dent_budget; |
422 | dd_growth += req->dirtied_ino_d; | 422 | dd_growth += req->dirtied_ino_d; |
423 | return dd_growth; | 423 | return dd_growth; |
424 | } | 424 | } |
@@ -460,19 +460,19 @@ int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req) | |||
460 | 460 | ||
461 | again: | 461 | again: |
462 | spin_lock(&c->space_lock); | 462 | spin_lock(&c->space_lock); |
463 | ubifs_assert(c->budg_idx_growth >= 0); | 463 | ubifs_assert(c->bi.idx_growth >= 0); |
464 | ubifs_assert(c->budg_data_growth >= 0); | 464 | ubifs_assert(c->bi.data_growth >= 0); |
465 | ubifs_assert(c->budg_dd_growth >= 0); | 465 | ubifs_assert(c->bi.dd_growth >= 0); |
466 | 466 | ||
467 | if (unlikely(c->nospace) && (c->nospace_rp || !can_use_rp(c))) { | 467 | if (unlikely(c->bi.nospace) && (c->bi.nospace_rp || !can_use_rp(c))) { |
468 | dbg_budg("no space"); | 468 | dbg_budg("no space"); |
469 | spin_unlock(&c->space_lock); | 469 | spin_unlock(&c->space_lock); |
470 | return -ENOSPC; | 470 | return -ENOSPC; |
471 | } | 471 | } |
472 | 472 | ||
473 | c->budg_idx_growth += idx_growth; | 473 | c->bi.idx_growth += idx_growth; |
474 | c->budg_data_growth += data_growth; | 474 | c->bi.data_growth += data_growth; |
475 | c->budg_dd_growth += dd_growth; | 475 | c->bi.dd_growth += dd_growth; |
476 | 476 | ||
477 | err = do_budget_space(c); | 477 | err = do_budget_space(c); |
478 | if (likely(!err)) { | 478 | if (likely(!err)) { |
@@ -484,9 +484,9 @@ again: | |||
484 | } | 484 | } |
485 | 485 | ||
486 | /* Restore the old values */ | 486 | /* Restore the old values */ |
487 | c->budg_idx_growth -= idx_growth; | 487 | c->bi.idx_growth -= idx_growth; |
488 | c->budg_data_growth -= data_growth; | 488 | c->bi.data_growth -= data_growth; |
489 | c->budg_dd_growth -= dd_growth; | 489 | c->bi.dd_growth -= dd_growth; |
490 | spin_unlock(&c->space_lock); | 490 | spin_unlock(&c->space_lock); |
491 | 491 | ||
492 | if (req->fast) { | 492 | if (req->fast) { |
@@ -506,9 +506,9 @@ again: | |||
506 | goto again; | 506 | goto again; |
507 | } | 507 | } |
508 | dbg_budg("FS is full, -ENOSPC"); | 508 | dbg_budg("FS is full, -ENOSPC"); |
509 | c->nospace = 1; | 509 | c->bi.nospace = 1; |
510 | if (can_use_rp(c) || c->rp_size == 0) | 510 | if (can_use_rp(c) || c->rp_size == 0) |
511 | c->nospace_rp = 1; | 511 | c->bi.nospace_rp = 1; |
512 | smp_wmb(); | 512 | smp_wmb(); |
513 | } else | 513 | } else |
514 | ubifs_err("cannot budget space, error %d", err); | 514 | ubifs_err("cannot budget space, error %d", err); |
@@ -523,8 +523,8 @@ again: | |||
523 | * This function releases the space budgeted by 'ubifs_budget_space()'. Note, | 523 | * This function releases the space budgeted by 'ubifs_budget_space()'. Note, |
524 | * since the index changes (which were budgeted for in @req->idx_growth) will | 524 | * since the index changes (which were budgeted for in @req->idx_growth) will |
525 | * only be written to the media on commit, this function moves the index budget | 525 | * only be written to the media on commit, this function moves the index budget |
526 | * from @c->budg_idx_growth to @c->budg_uncommitted_idx. The latter will be | 526 | * from @c->bi.idx_growth to @c->bi.uncommitted_idx. The latter will be zeroed |
527 | * zeroed by the commit operation. | 527 | * by the commit operation. |
528 | */ | 528 | */ |
529 | void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req) | 529 | void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req) |
530 | { | 530 | { |
@@ -553,23 +553,23 @@ void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req) | |||
553 | if (!req->data_growth && !req->dd_growth) | 553 | if (!req->data_growth && !req->dd_growth) |
554 | return; | 554 | return; |
555 | 555 | ||
556 | c->nospace = c->nospace_rp = 0; | 556 | c->bi.nospace = c->bi.nospace_rp = 0; |
557 | smp_wmb(); | 557 | smp_wmb(); |
558 | 558 | ||
559 | spin_lock(&c->space_lock); | 559 | spin_lock(&c->space_lock); |
560 | c->budg_idx_growth -= req->idx_growth; | 560 | c->bi.idx_growth -= req->idx_growth; |
561 | c->budg_uncommitted_idx += req->idx_growth; | 561 | c->bi.uncommitted_idx += req->idx_growth; |
562 | c->budg_data_growth -= req->data_growth; | 562 | c->bi.data_growth -= req->data_growth; |
563 | c->budg_dd_growth -= req->dd_growth; | 563 | c->bi.dd_growth -= req->dd_growth; |
564 | c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); | 564 | c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c); |
565 | 565 | ||
566 | ubifs_assert(c->budg_idx_growth >= 0); | 566 | ubifs_assert(c->bi.idx_growth >= 0); |
567 | ubifs_assert(c->budg_data_growth >= 0); | 567 | ubifs_assert(c->bi.data_growth >= 0); |
568 | ubifs_assert(c->budg_dd_growth >= 0); | 568 | ubifs_assert(c->bi.dd_growth >= 0); |
569 | ubifs_assert(c->min_idx_lebs < c->main_lebs); | 569 | ubifs_assert(c->bi.min_idx_lebs < c->main_lebs); |
570 | ubifs_assert(!(c->budg_idx_growth & 7)); | 570 | ubifs_assert(!(c->bi.idx_growth & 7)); |
571 | ubifs_assert(!(c->budg_data_growth & 7)); | 571 | ubifs_assert(!(c->bi.data_growth & 7)); |
572 | ubifs_assert(!(c->budg_dd_growth & 7)); | 572 | ubifs_assert(!(c->bi.dd_growth & 7)); |
573 | spin_unlock(&c->space_lock); | 573 | spin_unlock(&c->space_lock); |
574 | } | 574 | } |
575 | 575 | ||
@@ -586,13 +586,13 @@ void ubifs_convert_page_budget(struct ubifs_info *c) | |||
586 | { | 586 | { |
587 | spin_lock(&c->space_lock); | 587 | spin_lock(&c->space_lock); |
588 | /* Release the index growth reservation */ | 588 | /* Release the index growth reservation */ |
589 | c->budg_idx_growth -= c->max_idx_node_sz << UBIFS_BLOCKS_PER_PAGE_SHIFT; | 589 | c->bi.idx_growth -= c->max_idx_node_sz << UBIFS_BLOCKS_PER_PAGE_SHIFT; |
590 | /* Release the data growth reservation */ | 590 | /* Release the data growth reservation */ |
591 | c->budg_data_growth -= c->page_budget; | 591 | c->bi.data_growth -= c->bi.page_budget; |
592 | /* Increase the dirty data growth reservation instead */ | 592 | /* Increase the dirty data growth reservation instead */ |
593 | c->budg_dd_growth += c->page_budget; | 593 | c->bi.dd_growth += c->bi.page_budget; |
594 | /* And re-calculate the indexing space reservation */ | 594 | /* And re-calculate the indexing space reservation */ |
595 | c->min_idx_lebs = ubifs_calc_min_idx_lebs(c); | 595 | c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c); |
596 | spin_unlock(&c->space_lock); | 596 | spin_unlock(&c->space_lock); |
597 | } | 597 | } |
598 | 598 | ||
@@ -612,7 +612,7 @@ void ubifs_release_dirty_inode_budget(struct ubifs_info *c, | |||
612 | 612 | ||
613 | memset(&req, 0, sizeof(struct ubifs_budget_req)); | 613 | memset(&req, 0, sizeof(struct ubifs_budget_req)); |
614 | /* The "no space" flags will be cleared because dd_growth is > 0 */ | 614 | /* The "no space" flags will be cleared because dd_growth is > 0 */ |
615 | req.dd_growth = c->inode_budget + ALIGN(ui->data_len, 8); | 615 | req.dd_growth = c->bi.inode_budget + ALIGN(ui->data_len, 8); |
616 | ubifs_release_budget(c, &req); | 616 | ubifs_release_budget(c, &req); |
617 | } | 617 | } |
618 | 618 | ||
@@ -682,9 +682,9 @@ long long ubifs_get_free_space_nolock(struct ubifs_info *c) | |||
682 | int rsvd_idx_lebs, lebs; | 682 | int rsvd_idx_lebs, lebs; |
683 | long long available, outstanding, free; | 683 | long long available, outstanding, free; |
684 | 684 | ||
685 | ubifs_assert(c->min_idx_lebs == ubifs_calc_min_idx_lebs(c)); | 685 | ubifs_assert(c->bi.min_idx_lebs == ubifs_calc_min_idx_lebs(c)); |
686 | outstanding = c->budg_data_growth + c->budg_dd_growth; | 686 | outstanding = c->bi.data_growth + c->bi.dd_growth; |
687 | available = ubifs_calc_available(c, c->min_idx_lebs); | 687 | available = ubifs_calc_available(c, c->bi.min_idx_lebs); |
688 | 688 | ||
689 | /* | 689 | /* |
690 | * When reporting free space to user-space, UBIFS guarantees that it is | 690 | * When reporting free space to user-space, UBIFS guarantees that it is |
@@ -697,8 +697,8 @@ long long ubifs_get_free_space_nolock(struct ubifs_info *c) | |||
697 | * Note, the calculations below are similar to what we have in | 697 | * Note, the calculations below are similar to what we have in |
698 | * 'do_budget_space()', so refer there for comments. | 698 | * 'do_budget_space()', so refer there for comments. |
699 | */ | 699 | */ |
700 | if (c->min_idx_lebs > c->lst.idx_lebs) | 700 | if (c->bi.min_idx_lebs > c->lst.idx_lebs) |
701 | rsvd_idx_lebs = c->min_idx_lebs - c->lst.idx_lebs; | 701 | rsvd_idx_lebs = c->bi.min_idx_lebs - c->lst.idx_lebs; |
702 | else | 702 | else |
703 | rsvd_idx_lebs = 0; | 703 | rsvd_idx_lebs = 0; |
704 | lebs = c->lst.empty_lebs + c->freeable_cnt + c->idx_gc_cnt - | 704 | lebs = c->lst.empty_lebs + c->freeable_cnt + c->idx_gc_cnt - |