← Back to branch summary

~gaul/percona-data-recovery-tool-for-innodb/prerequisites

« back to all changes in this revision

Viewing changes to mysql-source/innobase/include/ut0lst.h

  • Committer: Aleksandr Kuzminsky
  • Date: 2010-01-14 13:05:06 UTC
  • mfrom: (1.1.1 page-signature-check)
  • Revision ID: aleksandr.kuzminsky@percona.com-20100114130506-72t6jxtll15gk3pp
Added InnoDB page signature check.
At the beginning of InnoDB page (type FIL_PAGE_INODE) there are infimum and supremum records.
They are located in fixed position depending on InnoDB page format(REDUNDANT (4.x and 5.x versions) or COMPACT(5.x only)).

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysql-source/innobase/include/ut0lst.h
 
1
/**********************************************************************
 
2
List utilities
 
3
 
 
4
(c) 1995 Innobase Oy
 
5
 
 
6
Created 9/10/1995 Heikki Tuuri
 
7
***********************************************************************/
 
8
 
 
9
#ifndef ut0lst_h
 
10
#define ut0lst_h
 
11
 
 
12
#include "univ.i"
 
13
 
 
14
/* This module implements the two-way linear list which should be used
 
15
if a list is used in the database. Note that a single struct may belong
 
16
to two or more lists, provided that the list are given different names.
 
17
An example of the usage of the lists can be found in fil0fil.c. */
 
18
 
 
19
/***********************************************************************
 
20
This macro expands to the unnamed type definition of a struct which acts
 
21
as the two-way list base node. The base node contains pointers
 
22
to both ends of the list and a count of nodes in the list (excluding
 
23
the base node from the count). TYPE should be the list node type name. */
 
24
 
 
25
#define UT_LIST_BASE_NODE_T(TYPE)\
 
26
struct {\
 
27
        ulint   count;  /* count of nodes in list */\
 
28
        TYPE *  start;  /* pointer to list start, NULL if empty */\
 
29
        TYPE *  end;    /* pointer to list end, NULL if empty */\
 
30
}\
 
31
 
 
32
/***********************************************************************
 
33
This macro expands to the unnamed type definition of a struct which
 
34
should be embedded in the nodes of the list, the node type must be a struct.
 
35
This struct contains the pointers to next and previous nodes in the list.
 
36
The name of the field in the node struct should be the name given
 
37
to the list. TYPE should be the list node type name. Example of usage:
 
38
 
 
39
typedef struct LRU_node_struct  LRU_node_t;
 
40
struct LRU_node_struct {
 
41
        UT_LIST_NODE_T(LRU_node_t)      LRU_list;
 
42
        ...
 
43
}
 
44
The example implements an LRU list of name LRU_list. Its nodes are of type
 
45
LRU_node_t.
 
46
*/
 
47
 
 
48
#define UT_LIST_NODE_T(TYPE)\
 
49
struct {\
 
50
        TYPE *  prev;   /* pointer to the previous node,\
 
51
                        NULL if start of list */\
 
52
        TYPE *  next;   /* pointer to next node, NULL if end of list */\
 
53
}\
 
54
 
 
55
/***********************************************************************
 
56
Initializes the base node of a two-way list. */
 
57
 
 
58
#define UT_LIST_INIT(BASE)\
 
59
{\
 
60
        (BASE).count = 0;\
 
61
        (BASE).start = NULL;\
 
62
        (BASE).end   = NULL;\
 
63
}\
 
64
 
 
65
/***********************************************************************
 
66
Adds the node as the first element in a two-way linked list.
 
67
BASE has to be the base node (not a pointer to it). N has to be
 
68
the pointer to the node to be added to the list. NAME is the list name. */
 
69
 
 
70
#define UT_LIST_ADD_FIRST(NAME, BASE, N)\
 
71
{\
 
72
        ut_ad(N);\
 
73
        ((BASE).count)++;\
 
74
        ((N)->NAME).next = (BASE).start;\
 
75
        ((N)->NAME).prev = NULL;\
 
76
        if ((BASE).start != NULL) {\
 
77
                (((BASE).start)->NAME).prev = (N);\
 
78
        }\
 
79
        (BASE).start = (N);\
 
80
        if ((BASE).end == NULL) {\
 
81
                (BASE).end = (N);\
 
82
        }\
 
83
}\
 
84
 
 
85
/***********************************************************************
 
86
Adds the node as the last element in a two-way linked list.
 
87
BASE has to be the base node (not a pointer to it). N has to be
 
88
the pointer to the node to be added to the list. NAME is the list name. */
 
89
 
 
90
#define UT_LIST_ADD_LAST(NAME, BASE, N)\
 
91
{\
 
92
        ut_ad(N);\
 
93
        ((BASE).count)++;\
 
94
        ((N)->NAME).prev = (BASE).end;\
 
95
        ((N)->NAME).next = NULL;\
 
96
        if ((BASE).end != NULL) {\
 
97
                (((BASE).end)->NAME).next = (N);\
 
98
        }\
 
99
        (BASE).end = (N);\
 
100
        if ((BASE).start == NULL) {\
 
101
                (BASE).start = (N);\
 
102
        }\
 
103
}\
 
104
 
 
105
/***********************************************************************
 
106
Inserts a NODE2 after NODE1 in a list.
 
107
BASE has to be the base node (not a pointer to it). NAME is the list
 
108
name, NODE1 and NODE2 are pointers to nodes. */
 
109
 
 
110
#define UT_LIST_INSERT_AFTER(NAME, BASE, NODE1, NODE2)\
 
111
{\
 
112
        ut_ad(NODE1);\
 
113
        ut_ad(NODE2);\
 
114
        ((BASE).count)++;\
 
115
        ((NODE2)->NAME).prev = (NODE1);\
 
116
        ((NODE2)->NAME).next = ((NODE1)->NAME).next;\
 
117
        if (((NODE1)->NAME).next != NULL) {\
 
118
                ((((NODE1)->NAME).next)->NAME).prev = (NODE2);\
 
119
        }\
 
120
        ((NODE1)->NAME).next = (NODE2);\
 
121
        if ((BASE).end == (NODE1)) {\
 
122
                (BASE).end = (NODE2);\
 
123
        }\
 
124
}\
 
125
 
 
126
/***********************************************************************
 
127
Removes a node from a two-way linked list. BASE has to be the base node
 
128
(not a pointer to it). N has to be the pointer to the node to be removed
 
129
from the list. NAME is the list name. */
 
130
 
 
131
#define UT_LIST_REMOVE(NAME, BASE, N)\
 
132
{\
 
133
        ut_ad(N);\
 
134
        ut_a((BASE).count > 0);\
 
135
        ((BASE).count)--;\
 
136
        if (((N)->NAME).next != NULL) {\
 
137
                ((((N)->NAME).next)->NAME).prev = ((N)->NAME).prev;\
 
138
        } else {\
 
139
                (BASE).end = ((N)->NAME).prev;\
 
140
        }\
 
141
        if (((N)->NAME).prev != NULL) {\
 
142
                ((((N)->NAME).prev)->NAME).next = ((N)->NAME).next;\
 
143
        } else {\
 
144
                (BASE).start = ((N)->NAME).next;\
 
145
        }\
 
146
}\
 
147
 
 
148
/************************************************************************
 
149
Gets the next node in a two-way list. NAME is the name of the list
 
150
and N is pointer to a node. */
 
151
 
 
152
#define UT_LIST_GET_NEXT(NAME, N)\
 
153
        (((N)->NAME).next)
 
154
 
 
155
/************************************************************************
 
156
Gets the previous node in a two-way list. NAME is the name of the list
 
157
and N is pointer to a node. */
 
158
 
 
159
#define UT_LIST_GET_PREV(NAME, N)\
 
160
        (((N)->NAME).prev)
 
161
 
 
162
/************************************************************************
 
163
Alternative macro to get the number of nodes in a two-way list, i.e.,
 
164
its length. BASE is the base node (not a pointer to it). */
 
165
 
 
166
#define UT_LIST_GET_LEN(BASE)\
 
167
        (BASE).count
 
168
 
 
169
/************************************************************************
 
170
Gets the first node in a two-way list, or returns NULL,
 
171
if the list is empty. BASE is the base node (not a pointer to it). */
 
172
 
 
173
#define UT_LIST_GET_FIRST(BASE)\
 
174
        (BASE).start
 
175
 
 
176
/************************************************************************
 
177
Gets the last node in a two-way list, or returns NULL,
 
178
if the list is empty. BASE is the base node (not a pointer to it). */
 
179
 
 
180
#define UT_LIST_GET_LAST(BASE)\
 
181
        (BASE).end
 
182
 
 
183
/************************************************************************
 
184
Checks the consistency of a two-way list. NAME is the name of the list,
 
185
TYPE is the node type, and BASE is the base node (not a pointer to it). */
 
186
 
 
187
#define UT_LIST_VALIDATE(NAME, TYPE, BASE)\
 
188
{\
 
189
        ulint   ut_list_i_313;\
 
190
        TYPE *  ut_list_node_313;\
 
191
\
 
192
        ut_list_node_313 = (BASE).start;\
 
193
\
 
194
        for (ut_list_i_313 = 0; ut_list_i_313 < (BASE).count;\
 
195
                                                ut_list_i_313++) {\
 
196
                ut_a(ut_list_node_313);\
 
197
                ut_list_node_313 = (ut_list_node_313->NAME).next;\
 
198
        }\
 
199
\
 
200
        ut_a(ut_list_node_313 == NULL);\
 
201
\
 
202
        ut_list_node_313 = (BASE).end;\
 
203
\
 
204
        for (ut_list_i_313 = 0; ut_list_i_313 < (BASE).count;\
 
205
                                                ut_list_i_313++) {\
 
206
                ut_a(ut_list_node_313);\
 
207
                ut_list_node_313 = (ut_list_node_313->NAME).prev;\
 
208
        }\
 
209
\
 
210
        ut_a(ut_list_node_313 == NULL);\
 
211
}\
 
212
        
 
213
 
 
214
#endif
 
215