← Back to branch summary

~thomir-deactivatedaccount/drizzle/drizzle-fix-bug653747

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-10-10 02:07:52 UTC
  • mfrom: (1827.2.3 staging)
  • Revision ID: brian@tangent.org-20101010020752-ktv73isay5dxtvp3
Merge in switch on table_share_instance inheritance.

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
 
 
238
235
/**********************************************************************//**
239
236
Returns an extent to the free list of a space. */
240
237
static
1221
1218
 
1222
1219
        if (space == 0 && !srv_auto_extend_last_data_file) {
1223
1220
 
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
 
                }
1237
1221
                return(FALSE);
1238
1222
        }
1239
1223
 
1848
1832
                if (!ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))) {
1849
1833
                        /* This is used */
1850
1834
 
1851
 
                        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
1852
 
                              == FSEG_MAGIC_N_VALUE);
1853
1835
                        return(i);
1854
1836
                }
1855
1837
        }
1881
1863
 
1882
1864
                        return(i);
1883
1865
                }
1884
 
 
1885
 
                ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
1886
 
                      == FSEG_MAGIC_N_VALUE);
1887
1866
        }
1888
1867
 
1889
1868
        return(ULINT_UNDEFINED);
2002
1981
                              page + FSEG_INODE_PAGE_NODE, mtr);
2003
1982
        }
2004
1983
 
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);
2007
1984
        return(inode);
2008
1985
}
2009
1986
 
2041
2018
        }
2042
2019
 
2043
2020
        mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
2044
 
        mlog_write_ulint(inode + FSEG_MAGIC_N, 0xfa051ce3, MLOG_4BYTES, mtr);
 
2021
        mlog_write_ulint(inode + FSEG_MAGIC_N, 0, MLOG_4BYTES, mtr);
2045
2022
 
2046
2023
        if (ULINT_UNDEFINED
2047
2024
            == fsp_seg_inode_page_find_used(page, zip_size, mtr)) {
2057
2034
 
2058
2035
/**********************************************************************//**
2059
2036
Returns the file segment inode, page x-latched.
2060
 
@return segment inode, page x-latched; NULL if the inode is free */
 
2037
@return segment inode, page x-latched */
2061
2038
static
2062
2039
fseg_inode_t*
2063
 
fseg_inode_try_get(
2064
 
/*===============*/
 
2040
fseg_inode_get(
 
2041
/*===========*/
2065
2042
        fseg_header_t*  header, /*!< in: segment header */
2066
2043
        ulint           space,  /*!< in: space id */
2067
2044
        ulint           zip_size,/*!< in: compressed page size in bytes
2077
2054
 
2078
2055
        inode = fut_get_ptr(space, zip_size, inode_addr, RW_X_LATCH, mtr);
2079
2056
 
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);
 
2057
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
 
2058
 
2108
2059
        return(inode);
2109
2060
}
2110
2061
 
2122
2073
        ut_ad(inode && mtr);
2123
2074
        ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
2124
2075
        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);
2126
2076
        return(mach_read_from_4(inode + FSEG_FRAG_ARR
2127
2077
                                + n * FSEG_FRAG_SLOT_SIZE));
2128
2078
}
2141
2091
        ut_ad(inode && mtr);
2142
2092
        ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
2143
2093
        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);
2145
2094
 
2146
2095
        mlog_write_ulint(inode + FSEG_FRAG_ARR + n * FSEG_FRAG_SLOT_SIZE,
2147
2096
                         page_no, MLOG_4BYTES, mtr);
2502
2451
                xdes_set_state(descr, XDES_FSEG, mtr);
2503
2452
 
2504
2453
                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);
2507
2454
                mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
2508
2455
 
2509
2456
                flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
2532
2479
        fil_addr_t      first;
2533
2480
 
2534
2481
        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);
2536
2482
 
2537
2483
        if (flst_get_len(inode + FSEG_FREE, mtr) > 0) {
2538
2484
                /* Segment free list is not empty, allocate from it */
3190
3136
 
3191
3137
        ut_ad(seg_inode && mtr);
3192
3138
        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);
3195
3139
 
3196
3140
        descr = xdes_get_descriptor(space, zip_size, page, mtr);
3197
3141
 
3429
3373
        ut_a(xdes_get_state(descr, mtr) == XDES_FSEG);
3430
3374
        ut_a(0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, mtr),
3431
3375
                                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);
3434
3376
 
3435
3377
        first_page_in_extent = page - (page % FSP_EXTENT_SIZE);
3436
3378
 
3521
3463
        ut_a(descr);
3522
3464
        ut_a(xdes_get_bit(descr, XDES_FREE_BIT,
3523
3465
                          header_page % FSP_EXTENT_SIZE, mtr) == FALSE);
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
 
        }
 
3466
        inode = fseg_inode_get(header, space, zip_size, mtr);
3531
3467
 
3532
3468
        descr = fseg_get_first_extent(inode, space, zip_size, mtr);
3533
3469
 
3651
3587
        ut_ad(inode && mtr);
3652
3588
 
3653
3589
        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);
3655
3590
 
3656
3591
        first = fil_addr_null;
3657
3592
 
3866
3801
                (ulong) reserved, (ulong) used, (ulong) n_full,
3867
3802
                (ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
3868
3803
                (ulong) n_used);
3869
 
        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
3870
3804
}
3871
3805
 
3872
3806
#ifdef UNIV_BTR_PRINT