← Back to branch summary

~fallenpegasus/drizzle/logcsv

« back to all changes in this revision

Viewing changes to plugin/innobase/fsp/fsp0fsp.c

  • Committer: lbieber at stabletransit
  • Date: 2010-10-13 16:20:08 UTC
  • mfrom: (1843.1.3 build)
  • Revision ID: lbieber@drizzle-build-n02.wc1.dfw1.stabletransit.com-20101013162008-qi2e6k5yvfm16964
Merge Stewart - update innobase plugin to be based on innodb_plugin 1.0.6
Merge Monty - more valgrind cleanup
Merge Monty - Moved libdrizzle api listings from doxygen to sphinx

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/fsp/fsp0fsp.c
232
232
#define XDES_ARR_OFFSET         (FSP_HEADER_OFFSET + FSP_HEADER_SIZE)
233
233
 
234
234
#ifndef UNIV_HOTBACKUP
 
235
/* Flag to indicate if we have printed the tablespace full error. */
 
236
static ibool fsp_tbs_full_error_printed = FALSE;
 
237
 
235
238
/**********************************************************************//**
236
239
Returns an extent to the free list of a space. */
237
240
static
1218
1221
 
1219
1222
        if (space == 0 && !srv_auto_extend_last_data_file) {
1220
1223
 
 
1224
                /* We print the error message only once to avoid
 
1225
                spamming the error log. Note that we don't need
 
1226
                to reset the flag to FALSE as dealing with this
 
1227
                error requires server restart. */
 
1228
                if (fsp_tbs_full_error_printed == FALSE) {
 
1229
                        fprintf(stderr,
 
1230
                                "InnoDB: Error: Data file(s) ran"
 
1231
                                " out of space.\n"
 
1232
                                "Please add another data file or"
 
1233
                                " use \'autoextend\' for the last"
 
1234
                                " data file.\n");
 
1235
                        fsp_tbs_full_error_printed = TRUE;
 
1236
                }
1221
1237
                return(FALSE);
1222
1238
        }
1223
1239
 
1832
1848
                if (!ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))) {
1833
1849
                        /* This is used */
1834
1850
 
 
1851
                        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
 
1852
                              == FSEG_MAGIC_N_VALUE);
1835
1853
                        return(i);
1836
1854
                }
1837
1855
        }
1863
1881
 
1864
1882
                        return(i);
1865
1883
                }
 
1884
 
 
1885
                ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
 
1886
                      == FSEG_MAGIC_N_VALUE);
1866
1887
        }
1867
1888
 
1868
1889
        return(ULINT_UNDEFINED);
1981
2002
                              page + FSEG_INODE_PAGE_NODE, mtr);
1982
2003
        }
1983
2004
 
 
2005
        ut_ad(ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))
 
2006
              || mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
1984
2007
        return(inode);
1985
2008
}
1986
2009
 
2018
2041
        }
2019
2042
 
2020
2043
        mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
2021
 
        mlog_write_ulint(inode + FSEG_MAGIC_N, 0, MLOG_4BYTES, mtr);
 
2044
        mlog_write_ulint(inode + FSEG_MAGIC_N, 0xfa051ce3, MLOG_4BYTES, mtr);
2022
2045
 
2023
2046
        if (ULINT_UNDEFINED
2024
2047
            == fsp_seg_inode_page_find_used(page, zip_size, mtr)) {
2034
2057
 
2035
2058
/**********************************************************************//**
2036
2059
Returns the file segment inode, page x-latched.
2037
 
@return segment inode, page x-latched */
 
2060
@return segment inode, page x-latched; NULL if the inode is free */
2038
2061
static
2039
2062
fseg_inode_t*
2040
 
fseg_inode_get(
2041
 
/*===========*/
 
2063
fseg_inode_try_get(
 
2064
/*===============*/
2042
2065
        fseg_header_t*  header, /*!< in: segment header */
2043
2066
        ulint           space,  /*!< in: space id */
2044
2067
        ulint           zip_size,/*!< in: compressed page size in bytes
2054
2077
 
2055
2078
        inode = fut_get_ptr(space, zip_size, inode_addr, RW_X_LATCH, mtr);
2056
2079
 
2057
 
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
2058
 
 
 
2080
        if (UNIV_UNLIKELY
 
2081
            (ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID)))) {
 
2082
 
 
2083
                inode = NULL;
 
2084
        } else {
 
2085
                ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
 
2086
                      == FSEG_MAGIC_N_VALUE);
 
2087
        }
 
2088
 
 
2089
        return(inode);
 
2090
}
 
2091
 
 
2092
/**********************************************************************//**
 
2093
Returns the file segment inode, page x-latched.
 
2094
@return segment inode, page x-latched */
 
2095
static
 
2096
fseg_inode_t*
 
2097
fseg_inode_get(
 
2098
/*===========*/
 
2099
        fseg_header_t*  header, /*!< in: segment header */
 
2100
        ulint           space,  /*!< in: space id */
 
2101
        ulint           zip_size,/*!< in: compressed page size in bytes
 
2102
                                or 0 for uncompressed pages */
 
2103
        mtr_t*          mtr)    /*!< in: mtr handle */
 
2104
{
 
2105
        fseg_inode_t*   inode
 
2106
                = fseg_inode_try_get(header, space, zip_size, mtr);
 
2107
        ut_a(inode);
2059
2108
        return(inode);
2060
2109
}
2061
2110
 
2073
2122
        ut_ad(inode && mtr);
2074
2123
        ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
2075
2124
        ut_ad(mtr_memo_contains_page(mtr, inode, MTR_MEMO_PAGE_X_FIX));
 
2125
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
2076
2126
        return(mach_read_from_4(inode + FSEG_FRAG_ARR
2077
2127
                                + n * FSEG_FRAG_SLOT_SIZE));
2078
2128
}
2091
2141
        ut_ad(inode && mtr);
2092
2142
        ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
2093
2143
        ut_ad(mtr_memo_contains_page(mtr, inode, MTR_MEMO_PAGE_X_FIX));
 
2144
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
2094
2145
 
2095
2146
        mlog_write_ulint(inode + FSEG_FRAG_ARR + n * FSEG_FRAG_SLOT_SIZE,
2096
2147
                         page_no, MLOG_4BYTES, mtr);
2451
2502
                xdes_set_state(descr, XDES_FSEG, mtr);
2452
2503
 
2453
2504
                seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
 
2505
                ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
 
2506
                      == FSEG_MAGIC_N_VALUE);
2454
2507
                mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
2455
2508
 
2456
2509
                flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
2479
2532
        fil_addr_t      first;
2480
2533
 
2481
2534
        ut_ad(!((page_offset(inode) - FSEG_ARR_OFFSET) % FSEG_INODE_SIZE));
 
2535
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
2482
2536
 
2483
2537
        if (flst_get_len(inode + FSEG_FREE, mtr) > 0) {
2484
2538
                /* Segment free list is not empty, allocate from it */
3136
3190
 
3137
3191
        ut_ad(seg_inode && mtr);
3138
3192
        ut_ad(!((page_offset(seg_inode) - FSEG_ARR_OFFSET) % FSEG_INODE_SIZE));
 
3193
        ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N)
 
3194
              == FSEG_MAGIC_N_VALUE);
3139
3195
 
3140
3196
        descr = xdes_get_descriptor(space, zip_size, page, mtr);
3141
3197
 
3373
3429
        ut_a(xdes_get_state(descr, mtr) == XDES_FSEG);
3374
3430
        ut_a(0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, mtr),
3375
3431
                                mtr_read_dulint(seg_inode + FSEG_ID, mtr)));
 
3432
        ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N)
 
3433
              == FSEG_MAGIC_N_VALUE);
3376
3434
 
3377
3435
        first_page_in_extent = page - (page % FSP_EXTENT_SIZE);
3378
3436
 
3463
3521
        ut_a(descr);
3464
3522
        ut_a(xdes_get_bit(descr, XDES_FREE_BIT,
3465
3523
                          header_page % FSP_EXTENT_SIZE, mtr) == FALSE);
3466
 
        inode = fseg_inode_get(header, space, zip_size, mtr);
 
3524
        inode = fseg_inode_try_get(header, space, zip_size, mtr);
 
3525
 
 
3526
        if (UNIV_UNLIKELY(inode == NULL)) {
 
3527
                fprintf(stderr, "double free of inode from %u:%u\n",
 
3528
                        (unsigned) space, (unsigned) header_page);
 
3529
                return(TRUE);
 
3530
        }
3467
3531
 
3468
3532
        descr = fseg_get_first_extent(inode, space, zip_size, mtr);
3469
3533
 
3587
3651
        ut_ad(inode && mtr);
3588
3652
 
3589
3653
        ut_ad(space == page_get_space_id(page_align(inode)));
 
3654
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
3590
3655
 
3591
3656
        first = fil_addr_null;
3592
3657
 
3801
3866
                (ulong) reserved, (ulong) used, (ulong) n_full,
3802
3867
                (ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
3803
3868
                (ulong) n_used);
 
3869
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
3804
3870
}
3805
3871
 
3806
3872
#ifdef UNIV_BTR_PRINT