← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Lee Bieber
  • Date: 2010-12-03 01:16:19 UTC
  • mfrom: (1819.9.81 update-innobase)
  • Revision ID: kalebral@gmail.com-20101203011619-n6v584rijwdet05b
Merge Stewart - update Innobase plugin based on InnoDB 1.1.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/fsp/fsp0fsp.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1995, 2010, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
899
899
fsp_parse_init_file_page(
900
900
/*=====================*/
901
901
        byte*           ptr,    /*!< in: buffer */
902
 
        byte*           /*end_ptr __attribute__((unused))*/, /*!< in: buffer end */
 
902
        byte*           end_ptr __attribute__((unused)), /*!< in: buffer end */
903
903
        buf_block_t*    block)  /*!< in: block or NULL */
904
904
{
905
905
        ut_ad(ptr && end_ptr);
1810
1810
/*=============================*/
1811
1811
        page_t* page,   /*!< in: segment inode page */
1812
1812
        ulint   i,      /*!< in: inode index on page */
1813
 
        ulint   /*zip_size __attribute__((unused))*/,
 
1813
        ulint   zip_size __attribute__((unused)),
1814
1814
                        /*!< in: compressed page size, or 0 */
1815
 
        mtr_t*  /*mtr __attribute__((unused))*/)
 
1815
        mtr_t*  mtr __attribute__((unused)))
1816
1816
                        /*!< in: mini-transaction handle */
1817
1817
{
1818
1818
        ut_ad(i < FSP_SEG_INODES_PER_PAGE(zip_size));
2111
2111
/*======================*/
2112
2112
        fseg_inode_t*   inode,  /*!< in: segment inode */
2113
2113
        ulint           n,      /*!< in: slot index */
2114
 
        mtr_t*          /*mtr __attribute__((unused))*/) /*!< in: mtr handle */
 
2114
        mtr_t*          mtr __attribute__((unused))) /*!< in: mtr handle */
2115
2115
{
2116
2116
        ut_ad(inode && mtr);
2117
2117
        ut_ad(n < FSEG_FRAG_ARR_N_SLOTS);
2771
2771
                can be obtained immediately with buf_page_get without need
2772
2772
                for a disk read */
2773
2773
                buf_block_t*    block;
2774
 
                ulint           page_zip_size = dict_table_flags_to_zip_size(
 
2774
                ulint           zip_size = dict_table_flags_to_zip_size(
2775
2775
                        mach_read_from_4(FSP_SPACE_FLAGS + space_header));
2776
2776
 
2777
 
                block = buf_page_create(space, ret_page, page_zip_size, mtr);
 
2777
                block = buf_page_create(space, ret_page, zip_size, mtr);
2778
2778
                buf_block_dbg_add_level(block, SYNC_FSP_PAGE);
2779
2779
 
2780
 
                if (UNIV_UNLIKELY(block != buf_page_get(space, page_zip_size,
 
2780
                if (UNIV_UNLIKELY(block != buf_page_get(space, zip_size,
2781
2781
                                                        ret_page, RW_X_LATCH,
2782
2782
                                                        mtr))) {
2783
2783
                        ut_error;
2790
2790
                The extent is still in the appropriate list (FSEG_NOT_FULL
2791
2791
                or FSEG_FREE), and the page is not yet marked as used. */
2792
2792
 
2793
 
                ut_ad(xdes_get_descriptor(space, page_zip_size, ret_page, mtr)
 
2793
                ut_ad(xdes_get_descriptor(space, zip_size, ret_page, mtr)
2794
2794
                      == ret_descr);
2795
2795
                ut_ad(xdes_get_bit(ret_descr, XDES_FREE_BIT,
2796
2796
                                   ret_page % FSP_EXTENT_SIZE, mtr) == TRUE);
2797
2797
 
2798
 
                fseg_mark_page_used(seg_inode, space, page_zip_size, ret_page, mtr);
 
2798
                fseg_mark_page_used(seg_inode, space, zip_size, ret_page, mtr);
2799
2799
        }
2800
2800
 
2801
2801
        buf_reset_check_index_page_at_flush(space, ret_page);
3097
3097
 
3098
3098
        ut_ad(!mutex_own(&kernel_mutex));
3099
3099
 
3100
 
        /* The convoluted mutex acquire is to overcome latching order
3101
 
        issues: The problem is that the fil_mutex is at a lower level
3102
 
        than the tablespace latch and the buffer pool mutex. We have to
3103
 
        first prevent any operations on the file system by acquiring the
3104
 
        dictionary mutex. Then acquire the tablespace latch to obey the
3105
 
        latching order and then release the dictionary mutex. That way we
3106
 
        ensure that the tablespace instance can't be freed while we are
3107
 
        examining its contents (see fil_space_free()).
3108
 
 
3109
 
        However, there is one further complication, we release the fil_mutex
3110
 
        when we need to invalidate the the pages in the buffer pool and we
3111
 
        reacquire the fil_mutex when deleting and freeing the tablespace
3112
 
        instance in fil0fil.c. Here we need to account for that situation
3113
 
        too. */
3114
 
 
3115
 
        mutex_enter(&dict_sys->mutex);
3116
 
 
3117
 
        /* At this stage there is no guarantee that the tablespace even
3118
 
        exists in the cache. */
3119
 
 
3120
 
        if (fil_tablespace_deleted_or_being_deleted_in_mem(space, -1)) {
3121
 
 
3122
 
                mutex_exit(&dict_sys->mutex);
3123
 
 
3124
 
                return(ULLINT_UNDEFINED);
3125
 
        }
3126
 
 
3127
3100
        mtr_start(&mtr);
3128
3101
 
3129
3102
        latch = fil_space_get_latch(space, &flags);
3130
 
 
3131
 
        /* This should ensure that the tablespace instance can't be freed
3132
 
        by another thread. However, the tablespace pages can still be freed
3133
 
        from the buffer pool. We need to check for that again. */
3134
 
 
3135
3103
        zip_size = dict_table_flags_to_zip_size(flags);
3136
3104
 
3137
3105
        mtr_x_lock(latch, &mtr);
3138
3106
 
3139
 
        mutex_exit(&dict_sys->mutex);
3140
 
 
3141
 
        /* At this point it is possible for the tablespace to be deleted and
3142
 
        its pages removed from the buffer pool. We need to check for that
3143
 
        situation. However, the tablespace instance can't be deleted because
3144
 
        our latching above should ensure that. */
3145
 
 
3146
 
        if (fil_tablespace_is_being_deleted(space)) {
3147
 
 
3148
 
                mtr_commit(&mtr);
3149
 
 
3150
 
                return(ULLINT_UNDEFINED);
3151
 
        }
3152
 
 
3153
 
        /* From here on even if the user has dropped the tablespace, the
3154
 
        pages _must_ still exist in the buffer pool and the tablespace
3155
 
        instance _must_ be in the file system hash table. */
3156
 
 
3157
3107
        space_header = fsp_get_space_header(space, zip_size, &mtr);
3158
3108
 
3159
3109
        size = mtr_read_ulint(space_header + FSP_SIZE, MLOG_4BYTES, &mtr);