The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/storage/innobase/include/fut0lst.h File Reference

mysql/src/5.1-dbg/storage/innobase/include/fut0lst.h File Reference

#include "univ.i"
#include "fil0fil.h"
#include "mtr0mtr.h"

Include dependency graph for fut0lst.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.


Defines
#define	FLST_BASE_NODE_SIZE (4 + 2 * FIL_ADDR_SIZE)
#define	FLST_NODE_SIZE (2 * FIL_ADDR_SIZE)
Typedefs
typedef byte	flst_base_node_t
typedef byte	flst_node_t
Functions
UNIV_INLINE void	flst_init (flst_base_node_t base, mtr_t mtr)
void	flst_add_last (flst_base_node_t base, flst_node_t node, mtr_t *mtr)
void	flst_add_first (flst_base_node_t base, flst_node_t node, mtr_t *mtr)
void	flst_insert_after (flst_base_node_t base, flst_node_t node1, flst_node_t node2, mtr_t mtr)
void	flst_insert_before (flst_base_node_t base, flst_node_t node2, flst_node_t node3, mtr_t mtr)
void	flst_remove (flst_base_node_t base, flst_node_t node2, mtr_t *mtr)
void	flst_cut_end (flst_base_node_t base, flst_node_t node2, ulint n_nodes, mtr_t *mtr)
void	flst_truncate_end (flst_base_node_t base, flst_node_t node2, ulint n_nodes, mtr_t *mtr)
UNIV_INLINE ulint	flst_get_len (flst_base_node_t base, mtr_t mtr)
UNIV_INLINE fil_addr_t	flst_get_first (flst_base_node_t base, mtr_t mtr)
UNIV_INLINE fil_addr_t	flst_get_last (flst_base_node_t base, mtr_t mtr)
UNIV_INLINE fil_addr_t	flst_get_next_addr (flst_node_t node, mtr_t mtr)
UNIV_INLINE fil_addr_t	flst_get_prev_addr (flst_node_t node, mtr_t mtr)
UNIV_INLINE void	flst_write_addr (fil_faddr_t faddr, fil_addr_t addr, mtr_t mtr)
UNIV_INLINE fil_addr_t	flst_read_addr (fil_faddr_t faddr, mtr_t mtr)
ibool	flst_validate (flst_base_node_t base, mtr_t mtr1)
void	flst_print (flst_base_node_t base, mtr_t mtr)

Define Documentation

#define FLST_BASE_NODE_SIZE (4 + 2 * FIL_ADDR_SIZE)

Definition at line 26 of file fut0lst.h.

#define FLST_NODE_SIZE (2 * FIL_ADDR_SIZE)

Definition at line 29 of file fut0lst.h.

Typedef Documentation

typedef byte flst_base_node_t

Definition at line 22 of file fut0lst.h.

typedef byte flst_node_t

Definition at line 23 of file fut0lst.h.

Function Documentation

void flst_add_first	(	flst_base_node_t *	base,
		flst_node_t *	node,
		mtr_t *	mtr
	)

Definition at line 103 of file fut0lst.c.

References fil_addr_struct::boffset, buf_block_align(), buf_frame_align(), buf_ptr_get_fsp_addr(), flst_add_to_empty(), flst_get_first(), flst_get_len(), flst_insert_before(), fut_get_ptr(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, fil_addr_struct::page, RW_X_LATCH, and ut_ad.

Referenced by btr_page_free_for_ibuf(), and trx_purge_add_update_undo_to_history().

00105                                              : pointer to base node of list */
00106         flst_node_t*            node,   /* in: node to add */
00107         mtr_t*                  mtr)    /* in: mini-transaction handle */
00108 {
00109         ulint           space;
00110         fil_addr_t      node_addr;
00111         ulint           len;
00112         fil_addr_t      first_addr;
00113         flst_node_t*    first_node;
00114 
00115         ut_ad(mtr && base && node);
00116         ut_ad(base != node);
00117         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00118                                                 MTR_MEMO_PAGE_X_FIX));
00119         ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
00120                                                 MTR_MEMO_PAGE_X_FIX));
00121         len = flst_get_len(base, mtr);
00122         first_addr = flst_get_first(base, mtr);
00123 
00124         buf_ptr_get_fsp_addr(node, &space, &node_addr);
00125 
00126         /* If the list is not empty, call flst_insert_before */
00127         if (len != 0) {
00128                 if (first_addr.page == node_addr.page) {
00129                         first_node = buf_frame_align(node)
00130                                                         + first_addr.boffset;
00131                 } else {
00132                         first_node = fut_get_ptr(space, first_addr,
00133                                                         RW_X_LATCH, mtr);
00134                 }
00135 
00136                 flst_insert_before(base, node, first_node, mtr);
00137         } else {
00138                 /* else call flst_add_to_empty */
00139                 flst_add_to_empty(base, node, mtr);
00140         }
00141 }

Here is the call graph for this function:

Here is the caller graph for this function:

void flst_add_last	(	flst_base_node_t *	base,
		flst_node_t *	node,
		mtr_t *	mtr
	)

Definition at line 60 of file fut0lst.c.

References fil_addr_struct::boffset, buf_block_align(), buf_frame_align(), buf_ptr_get_fsp_addr(), flst_add_to_empty(), flst_get_last(), flst_get_len(), flst_insert_after(), fut_get_ptr(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, fil_addr_struct::page, RW_X_LATCH, and ut_ad.

Referenced by fseg_alloc_free_extent(), fseg_alloc_free_page_low(), fseg_fill_free_list(), fseg_free_page_low(), fseg_mark_page_used(), fsp_alloc_free_page(), fsp_alloc_seg_inode(), fsp_alloc_seg_inode_page(), fsp_fill_free_list(), fsp_free_extent(), fsp_free_page(), fsp_free_seg_inode(), ibuf_add_free_page(), trx_undo_add_page(), and trx_undo_seg_create().

00062                                              : pointer to base node of list */
00063         flst_node_t*            node,   /* in: node to add */
00064         mtr_t*                  mtr)    /* in: mini-transaction handle */
00065 {
00066         ulint           space;
00067         fil_addr_t      node_addr;
00068         ulint           len;
00069         fil_addr_t      last_addr;
00070         flst_node_t*    last_node;
00071 
00072         ut_ad(mtr && base && node);
00073         ut_ad(base != node);
00074         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00075                                                 MTR_MEMO_PAGE_X_FIX));
00076         ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
00077                                                 MTR_MEMO_PAGE_X_FIX));
00078         len = flst_get_len(base, mtr);
00079         last_addr = flst_get_last(base, mtr);
00080 
00081         buf_ptr_get_fsp_addr(node, &space, &node_addr);
00082 
00083         /* If the list is not empty, call flst_insert_after */
00084         if (len != 0) {
00085                 if (last_addr.page == node_addr.page) {
00086                         last_node = buf_frame_align(node) + last_addr.boffset;
00087                 } else {
00088                         last_node = fut_get_ptr(space, last_addr, RW_X_LATCH,
00089                                                                         mtr);
00090                 }
00091 
00092                 flst_insert_after(base, last_node, node, mtr);
00093         } else {
00094                 /* else call flst_add_to_empty */
00095                 flst_add_to_empty(base, node, mtr);
00096         }
00097 }

Here is the call graph for this function:

Here is the caller graph for this function:

void flst_cut_end	(	flst_base_node_t *	base,
		flst_node_t *	node2,
		ulint	n_nodes,
		mtr_t *	mtr
	)

Definition at line 334 of file fut0lst.c.

References fil_addr_struct::boffset, buf_block_align(), buf_frame_align(), buf_ptr_get_fsp_addr(), fil_addr_is_null(), fil_addr_null, flst_get_len(), flst_get_prev_addr(), flst_write_addr(), fut_get_ptr(), MLOG_4BYTES, mlog_write_ulint(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, fil_addr_struct::page, RW_X_LATCH, and ut_ad.

Referenced by trx_purge_free_segment().

00336                                              : pointer to base node of list */
00337         flst_node_t*            node2,  /* in: first node to remove */
00338         ulint                   n_nodes,/* in: number of nodes to remove,
00339                                         must be >= 1 */
00340         mtr_t*                  mtr)    /* in: mini-transaction handle */
00341 {
00342         ulint           space;
00343         flst_node_t*    node1;
00344         fil_addr_t      node1_addr;
00345         fil_addr_t      node2_addr;
00346         ulint           len;
00347 
00348         ut_ad(mtr && node2 && base);
00349         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00350                                                 MTR_MEMO_PAGE_X_FIX));
00351         ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
00352                                                 MTR_MEMO_PAGE_X_FIX));
00353         ut_ad(n_nodes > 0);
00354 
00355         buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
00356 
00357         node1_addr = flst_get_prev_addr(node2, mtr);
00358 
00359         if (!fil_addr_is_null(node1_addr)) {
00360 
00361                 /* Update next field of node1 */
00362 
00363                 if (node1_addr.page == node2_addr.page) {
00364 
00365                         node1 = buf_frame_align(node2) + node1_addr.boffset;
00366                 } else {
00367                         node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH,
00368                                                                         mtr);
00369                 }
00370 
00371                 flst_write_addr(node1 + FLST_NEXT, fil_addr_null, mtr);
00372         } else {
00373                 /* node2 was first in list: update the field in base */
00374                 flst_write_addr(base + FLST_FIRST, fil_addr_null, mtr);
00375         }
00376 
00377         flst_write_addr(base + FLST_LAST, node1_addr, mtr);
00378 
00379         /* Update len of base node */
00380         len = flst_get_len(base, mtr);
00381         ut_ad(len >= n_nodes);
00382 
00383         mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr);
00384 }

Here is the call graph for this function:

Here is the caller graph for this function:

UNIV_INLINE fil_addr_t flst_get_first	(	flst_base_node_t *	base,
		mtr_t *	mtr
	)

Referenced by btr_page_alloc_for_ibuf(), flst_add_first(), flst_validate(), fseg_alloc_free_extent(), fseg_alloc_free_page_low(), fseg_get_first_extent(), fseg_validate_low(), fsp_alloc_free_extent(), fsp_alloc_free_page(), fsp_alloc_seg_inode(), fsp_print(), and fsp_validate().

Here is the caller graph for this function:

UNIV_INLINE fil_addr_t flst_get_last	(	flst_base_node_t *	base,
		mtr_t *	mtr
	)

Referenced by flst_add_last(), flst_validate(), ibuf_remove_free_page(), trx_purge_truncate_rseg_history(), trx_rseg_mem_create(), trx_undo_free_page(), and trx_undo_mem_create_at_db_start().

Here is the caller graph for this function:

UNIV_INLINE ulint flst_get_len	(	flst_base_node_t *	base,
		mtr_t *	mtr
	)

UNIV_INLINE fil_addr_t flst_get_next_addr	(	flst_node_t *	node,
		mtr_t *	mtr
	)

Referenced by flst_insert_after(), flst_remove(), flst_truncate_end(), flst_validate(), fseg_validate_low(), fsp_print(), fsp_validate(), trx_undo_get_next_rec_from_next_page(), and xdes_lst_get_next().

Here is the caller graph for this function:

UNIV_INLINE fil_addr_t flst_get_prev_addr	(	flst_node_t *	node,
		mtr_t *	mtr
	)

Referenced by flst_cut_end(), flst_insert_before(), flst_remove(), flst_validate(), trx_purge_rseg_get_next_history_log(), trx_purge_truncate_rseg_history(), and trx_undo_get_prev_rec_from_prev_page().

Here is the caller graph for this function:

UNIV_INLINE void flst_init	(	flst_base_node_t *	base,
		mtr_t *	mtr
	)

Referenced by btr_create(), fseg_create_general(), fsp_header_init(), trx_rseg_header_create(), and trx_undo_seg_create().

Here is the caller graph for this function:

void flst_insert_after	(	flst_base_node_t *	base,
		flst_node_t *	node1,
		flst_node_t *	node2,
		mtr_t *	mtr
	)

Definition at line 147 of file fut0lst.c.

References buf_block_align(), buf_ptr_get_fsp_addr(), fil_addr_is_null(), flst_get_len(), flst_get_next_addr(), flst_write_addr(), fut_get_ptr(), MLOG_4BYTES, mlog_write_ulint(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, RW_X_LATCH, and ut_ad.

Referenced by flst_add_last().

00149                                              : pointer to base node of list */
00150         flst_node_t*            node1,  /* in: node to insert after */
00151         flst_node_t*            node2,  /* in: node to add */
00152         mtr_t*                  mtr)    /* in: mini-transaction handle */
00153 {
00154         ulint           space;
00155         fil_addr_t      node1_addr;
00156         fil_addr_t      node2_addr;
00157         flst_node_t*    node3;
00158         fil_addr_t      node3_addr;
00159         ulint           len;
00160 
00161         ut_ad(mtr && node1 && node2 && base);
00162         ut_ad(base != node1);
00163         ut_ad(base != node2);
00164         ut_ad(node2 != node1);
00165         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00166                                                 MTR_MEMO_PAGE_X_FIX));
00167         ut_ad(mtr_memo_contains(mtr, buf_block_align(node1),
00168                                                 MTR_MEMO_PAGE_X_FIX));
00169         ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
00170                                                 MTR_MEMO_PAGE_X_FIX));
00171 
00172         buf_ptr_get_fsp_addr(node1, &space, &node1_addr);
00173         buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
00174 
00175         node3_addr = flst_get_next_addr(node1, mtr);
00176 
00177         /* Set prev and next fields of node2 */
00178         flst_write_addr(node2 + FLST_PREV, node1_addr, mtr);
00179         flst_write_addr(node2 + FLST_NEXT, node3_addr, mtr);
00180 
00181         if (!fil_addr_is_null(node3_addr)) {
00182                 /* Update prev field of node3 */
00183                 node3 = fut_get_ptr(space, node3_addr, RW_X_LATCH, mtr);
00184                 flst_write_addr(node3 + FLST_PREV, node2_addr, mtr);
00185         } else {
00186                 /* node1 was last in list: update last field in base */
00187                 flst_write_addr(base + FLST_LAST, node2_addr, mtr);
00188         }
00189 
00190         /* Set next field of node1 */
00191         flst_write_addr(node1 + FLST_NEXT, node2_addr, mtr);
00192 
00193         /* Update len of base node */
00194         len = flst_get_len(base, mtr);
00195         mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
00196 }

Here is the call graph for this function:

Here is the caller graph for this function:

void flst_insert_before	(	flst_base_node_t *	base,
		flst_node_t *	node2,
		flst_node_t *	node3,
		mtr_t *	mtr
	)

Definition at line 202 of file fut0lst.c.

References buf_block_align(), buf_ptr_get_fsp_addr(), fil_addr_is_null(), flst_get_len(), flst_get_prev_addr(), flst_write_addr(), fut_get_ptr(), MLOG_4BYTES, mlog_write_ulint(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, RW_X_LATCH, and ut_ad.

Referenced by flst_add_first().

00204                                              : pointer to base node of list */
00205         flst_node_t*            node2,  /* in: node to insert */
00206         flst_node_t*            node3,  /* in: node to insert before */
00207         mtr_t*                  mtr)    /* in: mini-transaction handle */
00208 {
00209         ulint           space;
00210         flst_node_t*    node1;
00211         fil_addr_t      node1_addr;
00212         fil_addr_t      node2_addr;
00213         fil_addr_t      node3_addr;
00214         ulint           len;
00215 
00216         ut_ad(mtr && node2 && node3 && base);
00217         ut_ad(base != node2);
00218         ut_ad(base != node3);
00219         ut_ad(node2 != node3);
00220         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00221                                                 MTR_MEMO_PAGE_X_FIX));
00222         ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
00223                                                 MTR_MEMO_PAGE_X_FIX));
00224         ut_ad(mtr_memo_contains(mtr, buf_block_align(node3),
00225                                                 MTR_MEMO_PAGE_X_FIX));
00226 
00227         buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
00228         buf_ptr_get_fsp_addr(node3, &space, &node3_addr);
00229 
00230         node1_addr = flst_get_prev_addr(node3, mtr);
00231 
00232         /* Set prev and next fields of node2 */
00233         flst_write_addr(node2 + FLST_PREV, node1_addr, mtr);
00234         flst_write_addr(node2 + FLST_NEXT, node3_addr, mtr);
00235 
00236         if (!fil_addr_is_null(node1_addr)) {
00237                 /* Update next field of node1 */
00238                 node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH, mtr);
00239                 flst_write_addr(node1 + FLST_NEXT, node2_addr, mtr);
00240         } else {
00241                 /* node3 was first in list: update first field in base */
00242                 flst_write_addr(base + FLST_FIRST, node2_addr, mtr);
00243         }
00244 
00245         /* Set prev field of node3 */
00246         flst_write_addr(node3 + FLST_PREV, node2_addr, mtr);
00247 
00248         /* Update len of base node */
00249         len = flst_get_len(base, mtr);
00250         mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr);
00251 }

Here is the call graph for this function:

Here is the caller graph for this function:

void flst_print	(	flst_base_node_t *	base,
		mtr_t *	mtr
	)

Definition at line 497 of file fut0lst.c.

References buf_block_align(), buf_frame_align(), buf_frame_get_page_no(), buf_frame_get_space_id(), flst_get_len(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, and ut_ad.

00499                                              : pointer to base node of list */
00500         mtr_t*                  mtr)    /* in: mtr */
00501 {
00502         buf_frame_t*    frame;
00503         ulint           len;
00504 
00505         ut_ad(base && mtr);
00506         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00507                         MTR_MEMO_PAGE_X_FIX));
00508         frame = buf_frame_align(base);
00509 
00510         len = flst_get_len(base, mtr);
00511 
00512         fprintf(stderr,
00513                 "FILE-BASED LIST:\n"
00514                 "Base node in space %lu page %lu byte offset %lu; len %lu\n",
00515                 (ulong) buf_frame_get_space_id(frame),
00516                 (ulong) buf_frame_get_page_no(frame),
00517                 (ulong) (base - frame), (ulong) len);
00518 }

Here is the call graph for this function:

UNIV_INLINE fil_addr_t flst_read_addr	(	fil_faddr_t *	faddr,
		mtr_t *	mtr
	)

void flst_remove	(	flst_base_node_t *	base,
		flst_node_t *	node2,
		mtr_t *	mtr
	)

Definition at line 257 of file fut0lst.c.

References fil_addr_struct::boffset, buf_block_align(), buf_frame_align(), buf_ptr_get_fsp_addr(), fil_addr_is_null(), flst_get_len(), flst_get_next_addr(), flst_get_prev_addr(), flst_write_addr(), fut_get_ptr(), MLOG_4BYTES, mlog_write_ulint(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, fil_addr_struct::page, RW_X_LATCH, and ut_ad.

Referenced by btr_page_alloc_for_ibuf(), fseg_free_extent(), fseg_free_page_low(), fseg_mark_page_used(), fsp_alloc_free_extent(), fsp_alloc_free_page(), fsp_alloc_seg_inode(), fsp_free_page(), fsp_free_seg_inode(), ibuf_remove_free_page(), and trx_undo_free_page().

00259                                              : pointer to base node of list */
00260         flst_node_t*            node2,  /* in: node to remove */
00261         mtr_t*                  mtr)    /* in: mini-transaction handle */
00262 {
00263         ulint           space;
00264         flst_node_t*    node1;
00265         fil_addr_t      node1_addr;
00266         fil_addr_t      node2_addr;
00267         flst_node_t*    node3;
00268         fil_addr_t      node3_addr;
00269         ulint           len;
00270 
00271         ut_ad(mtr && node2 && base);
00272         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00273                                                 MTR_MEMO_PAGE_X_FIX));
00274         ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
00275                                                 MTR_MEMO_PAGE_X_FIX));
00276 
00277         buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
00278 
00279         node1_addr = flst_get_prev_addr(node2, mtr);
00280         node3_addr = flst_get_next_addr(node2, mtr);
00281 
00282         if (!fil_addr_is_null(node1_addr)) {
00283 
00284                 /* Update next field of node1 */
00285 
00286                 if (node1_addr.page == node2_addr.page) {
00287 
00288                         node1 = buf_frame_align(node2) + node1_addr.boffset;
00289                 } else {
00290                         node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH,
00291                                                                         mtr);
00292                 }
00293 
00294                 ut_ad(node1 != node2);
00295 
00296                 flst_write_addr(node1 + FLST_NEXT, node3_addr, mtr);
00297         } else {
00298                 /* node2 was first in list: update first field in base */
00299                 flst_write_addr(base + FLST_FIRST, node3_addr, mtr);
00300         }
00301 
00302         if (!fil_addr_is_null(node3_addr)) {
00303                 /* Update prev field of node3 */
00304 
00305                 if (node3_addr.page == node2_addr.page) {
00306 
00307                         node3 = buf_frame_align(node2) + node3_addr.boffset;
00308                 } else {
00309                         node3 = fut_get_ptr(space, node3_addr, RW_X_LATCH,
00310                                                                         mtr);
00311                 }
00312 
00313                 ut_ad(node2 != node3);
00314 
00315                 flst_write_addr(node3 + FLST_PREV, node1_addr, mtr);
00316         } else {
00317                 /* node2 was last in list: update last field in base */
00318                 flst_write_addr(base + FLST_LAST, node1_addr, mtr);
00319         }
00320 
00321         /* Update len of base node */
00322         len = flst_get_len(base, mtr);
00323         ut_ad(len > 0);
00324 
00325         mlog_write_ulint(base + FLST_LEN, len - 1, MLOG_4BYTES, mtr);
00326 }

Here is the call graph for this function:

Here is the caller graph for this function:

void flst_truncate_end	(	flst_base_node_t *	base,
		flst_node_t *	node2,
		ulint	n_nodes,
		mtr_t *	mtr
	)

Definition at line 392 of file fut0lst.c.

References buf_block_align(), buf_ptr_get_fsp_addr(), fil_addr_is_null(), fil_addr_null, flst_get_len(), flst_get_next_addr(), flst_write_addr(), MLOG_4BYTES, mlog_write_ulint(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, and ut_ad.

Referenced by trx_purge_truncate_rseg_history().

00394                                              : pointer to base node of list */
00395         flst_node_t*            node2,  /* in: first node not to remove */
00396         ulint                   n_nodes,/* in: number of nodes to remove */
00397         mtr_t*                  mtr)    /* in: mini-transaction handle */
00398 {
00399         fil_addr_t      node2_addr;
00400         ulint           len;
00401         ulint           space;
00402 
00403         ut_ad(mtr && node2 && base);
00404         ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
00405                                                 MTR_MEMO_PAGE_X_FIX));
00406         ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
00407                                                 MTR_MEMO_PAGE_X_FIX));
00408         if (n_nodes == 0) {
00409 
00410                 ut_ad(fil_addr_is_null(flst_get_next_addr(node2, mtr)));
00411 
00412                 return;
00413         }
00414 
00415         buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
00416 
00417         /* Update next field of node2 */
00418         flst_write_addr(node2 + FLST_NEXT, fil_addr_null, mtr);
00419 
00420         flst_write_addr(base + FLST_LAST, node2_addr, mtr);
00421 
00422         /* Update len of base node */
00423         len = flst_get_len(base, mtr);
00424         ut_ad(len >= n_nodes);
00425 
00426         mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr);
00427 }

Here is the call graph for this function:

Here is the caller graph for this function:

ibool flst_validate	(	flst_base_node_t *	base,
		mtr_t *	mtr1
	)

Definition at line 433 of file fut0lst.c.

References buf_block_align(), buf_ptr_get_fsp_addr(), fil_addr_is_null(), flst_get_first(), flst_get_last(), flst_get_len(), flst_get_next_addr(), flst_get_prev_addr(), fut_get_ptr(), mtr_commit(), mtr_memo_contains(), MTR_MEMO_PAGE_X_FIX, mtr_start(), RW_X_LATCH, TRUE, ut_a, and ut_ad.

Referenced by btr_page_alloc_for_ibuf(), btr_page_free_for_ibuf(), fseg_validate_low(), and fsp_validate().

00435                                               : TRUE if ok */
00436         flst_base_node_t*       base,   /* in: pointer to base node of list */
00437         mtr_t*                  mtr1)   /* in: mtr */
00438 {
00439         ulint           space;
00440         flst_node_t*    node;
00441         fil_addr_t      node_addr;
00442         fil_addr_t      base_addr;
00443         ulint           len;
00444         ulint           i;
00445         mtr_t           mtr2;
00446 
00447         ut_ad(base);
00448         ut_ad(mtr_memo_contains(mtr1, buf_block_align(base),
00449                                                         MTR_MEMO_PAGE_X_FIX));
00450 
00451         /* We use two mini-transaction handles: the first is used to
00452         lock the base node, and prevent other threads from modifying the
00453         list. The second is used to traverse the list. We cannot run the
00454         second mtr without committing it at times, because if the list
00455         is long, then the x-locked pages could fill the buffer resulting
00456         in a deadlock. */
00457 
00458         /* Find out the space id */
00459         buf_ptr_get_fsp_addr(base, &space, &base_addr);
00460 
00461         len = flst_get_len(base, mtr1);
00462         node_addr = flst_get_first(base, mtr1);
00463 
00464         for (i = 0; i < len; i++) {
00465                 mtr_start(&mtr2);
00466 
00467                 node = fut_get_ptr(space, node_addr, RW_X_LATCH, &mtr2);
00468                 node_addr = flst_get_next_addr(node, &mtr2);
00469 
00470                 mtr_commit(&mtr2); /* Commit mtr2 each round to prevent buffer
00471                                    becoming full */
00472         }
00473 
00474         ut_a(fil_addr_is_null(node_addr));
00475 
00476         node_addr = flst_get_last(base, mtr1);
00477 
00478         for (i = 0; i < len; i++) {
00479                 mtr_start(&mtr2);
00480 
00481                 node = fut_get_ptr(space, node_addr, RW_X_LATCH, &mtr2);
00482                 node_addr = flst_get_prev_addr(node, &mtr2);
00483 
00484                 mtr_commit(&mtr2); /* Commit mtr2 each round to prevent buffer
00485                                    becoming full */
00486         }
00487 
00488         ut_a(fil_addr_is_null(node_addr));
00489 
00490         return(TRUE);
00491 }

Here is the call graph for this function:

Here is the caller graph for this function:

UNIV_INLINE void flst_write_addr	(	fil_faddr_t *	faddr,
		fil_addr_t	addr,
		mtr_t *	mtr
	)

Referenced by flst_add_to_empty(), flst_cut_end(), flst_insert_after(), flst_insert_before(), flst_remove(), and flst_truncate_end().

Here is the caller graph for this function:

Generated on Sat Sep 9 07:47:12 2006 for MySQL 5.1 by

1.4.7

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/include/fut0lst.h File Reference

Defines

Typedefs

Functions

Define Documentation

Typedef Documentation

Function Documentation