← Back to branch summary

~matttbe/ubuntu/quantal/mysql-5.5/lp1013171

« back to all changes in this revision

Viewing changes to storage/innobase/buf/buf0buf.c

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2012-06-11 23:34:14 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120611233414-mu6ybxiajgcxqztj
Tags: 5.5.25-0ubuntu1
https://launchpad.net/bugs/1011371
https://launchpad.net/bugs/986892
* New upstream release (LP: #1011371, LP: #986892)
* d/rules: change get-orig-source to pull from a working mirror.
* d/control: Build with default compiler instead of gcc 4.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/buf/buf0buf.c
2461
2461
 
2462
2462
                block->page.buf_fix_count = 1;
2463
2463
                buf_block_set_io_fix(block, BUF_IO_READ);
2464
 
                rw_lock_x_lock_func(&block->lock, 0, file, line);
 
2464
                rw_lock_x_lock_inline(&block->lock, 0, file, line);
2465
2465
 
2466
2466
                UNIV_MEM_INVALID(bpage, sizeof *bpage);
2467
2467
 
2601
2601
                break;
2602
2602
 
2603
2603
        case RW_S_LATCH:
2604
 
                rw_lock_s_lock_func(&(block->lock), 0, file, line);
 
2604
                rw_lock_s_lock_inline(&(block->lock), 0, file, line);
2605
2605
 
2606
2606
                fix_type = MTR_MEMO_PAGE_S_FIX;
2607
2607
                break;
2608
2608
 
2609
2609
        default:
2610
2610
                ut_ad(rw_latch == RW_X_LATCH);
2611
 
                rw_lock_x_lock_func(&(block->lock), 0, file, line);
 
2611
                rw_lock_x_lock_inline(&(block->lock), 0, file, line);
2612
2612
 
2613
2613
                fix_type = MTR_MEMO_PAGE_X_FIX;
2614
2614
                break;
2688
2688
                                                file, line);
2689
2689
                fix_type = MTR_MEMO_PAGE_S_FIX;
2690
2690
        } else {
2691
 
                success = rw_lock_x_lock_func_nowait(&(block->lock),
2692
 
                                                     file, line);
 
2691
                success = rw_lock_x_lock_func_nowait_inline(&(block->lock),
 
2692
                                                            file, line);
2693
2693
                fix_type = MTR_MEMO_PAGE_X_FIX;
2694
2694
        }
2695
2695
 
2818
2818
                                                file, line);
2819
2819
                fix_type = MTR_MEMO_PAGE_S_FIX;
2820
2820
        } else {
2821
 
                success = rw_lock_x_lock_func_nowait(&(block->lock),
2822
 
                                                     file, line);
 
2821
                success = rw_lock_x_lock_func_nowait_inline(&(block->lock),
 
2822
                                                            file, line);
2823
2823
                fix_type = MTR_MEMO_PAGE_X_FIX;
2824
2824
        }
2825
2825
 
2906
2906
                S-latch. */
2907
2907
 
2908
2908
                fix_type = MTR_MEMO_PAGE_X_FIX;
2909
 
                success = rw_lock_x_lock_func_nowait(&block->lock,
2910
 
                                                     file, line);
 
2909
                success = rw_lock_x_lock_func_nowait_inline(&block->lock,
 
2910
                                                            file, line);
2911
2911
        }
2912
2912
 
2913
2913
        if (!success) {
4750
4750
/*********************************************************************//**
4751
4751
Checks that there currently are no pending i/o-operations for the buffer
4752
4752
pool.
4753
 
@return TRUE if there is no pending i/o */
 
4753
@return number of pending i/o */
4754
4754
UNIV_INTERN
4755
 
ibool
4756
 
buf_pool_check_no_pending_io(void)
4757
 
/*==============================*/
 
4755
ulint
 
4756
buf_pool_check_num_pending_io(void)
 
4757
/*===============================*/
4758
4758
{
4759
4759
        ulint           i;
4760
 
        ibool           ret = TRUE;
 
4760
        ulint           pending_io = 0;
4761
4761
 
4762
4762
        buf_pool_mutex_enter_all();
4763
4763
 
4764
 
        for (i = 0; i < srv_buf_pool_instances && ret; i++) {
 
4764
        for (i = 0; i < srv_buf_pool_instances; i++) {
4765
4765
                const buf_pool_t*       buf_pool;
4766
4766
 
4767
4767
                buf_pool = buf_pool_from_array(i);
4768
4768
 
4769
 
                if (buf_pool->n_pend_reads
4770
 
                    + buf_pool->n_flush[BUF_FLUSH_LRU]
4771
 
                    + buf_pool->n_flush[BUF_FLUSH_LIST]
4772
 
                    + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
 
4769
                pending_io += buf_pool->n_pend_reads
 
4770
                              + buf_pool->n_flush[BUF_FLUSH_LRU]
 
4771
                              + buf_pool->n_flush[BUF_FLUSH_LIST]
 
4772
                              + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE];
4773
4773
 
4774
 
                        ret = FALSE;
4775
 
                }
4776
4774
        }
4777
4775
 
4778
4776
        buf_pool_mutex_exit_all();
4779
4777
 
4780
 
        return(ret);
 
4778
        return(pending_io);
4781
4779
}
4782
4780
 
4783
4781
#if 0